ZGlmZiAtLWdpdCBhLy5naXRpZ25vcmUgYi8uZ2l0aWdub3JlCmluZGV4IDUyMWQ4ZjQuLjg5YjNiNzkgMTAwNjQ0Ci0tLSBhLy5naXRpZ25vcmUKKysrIGIvLmdpdGlnbm9yZQpAQCAtMjE2LDYgKzIxNiw3IEBACiAvdGFncwogL1RBR1MKIC9jc2NvcGUqCisqLmhjYwogKi5vYmoKICoubGliCiAqLnJlcwpAQCAtMjMxLDcgKzIzMiw2IEBACiAqLmlwZGIKICouZGxsCiAudnMvCi0qLm1hbmlmZXN0CiBEZWJ1Zy8KIFJlbGVhc2UvCiAvVXBncmFkZUxvZyouaHRtCmRpZmYgLS1naXQgYS8ubWFpbG1hcCBiLy5tYWlsbWFwCmluZGV4IDlhNWZmMDQuLjE0ZmEwNDEgMTAwNjQ0Ci0tLSBhLy5tYWlsbWFwCisrKyBiLy5tYWlsbWFwCkBAIC0xOCw2ICsxOCw3IEBACiBBbGV4ZXkgU2h1bWtpbiA8YWxleC5jcmV6b2ZmQGdtYWlsLmNvbT4gPEFsZXguQ3Jlem9mZkBnbWFpbC5jb20+CiBBbmRlcnMgS2FzZW9yZyA8YW5kZXJza0BNSVQuRURVPiA8YW5kZXJza0Brc3BsaWNlLmNvbT4KIEFuZGVycyBLYXNlb3JnIDxhbmRlcnNrQE1JVC5FRFU+IDxhbmRlcnNrQG1pdC5lZHU+CitBbmRyZXkgTWF6byA8YWhpcHBvQHlhbmRleC5jb20+IE1hem8sIEFuZHJleSA8YW1hem9AY2hlY2t2aWRlby5jb20+CiBBbmVlc2ggS3VtYXIgSy5WIDxhbmVlc2gua3VtYXJAZ21haWwuY29tPgogQW1vcyBXYXRlcmxhbmQgPGFwd0BkZWJpYW4ub3JnPiA8YXB3QHJvc3NieS5tZXRyLm91LmVkdT4KIEFtb3MgV2F0ZXJsYW5kIDxhcHdAZGViaWFuLm9yZz4gPGFwd0B1cy5pYm0uY29tPgpkaWZmIC0tZ2l0IGEvQ09ERV9PRl9DT05EVUNULm1kIGIvQ09ERV9PRl9DT05EVUNULm1kCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmZjNDY0NWQKLS0tIC9kZXYvbnVsbAorKysgYi9DT0RFX09GX0NPTkRVQ1QubWQKQEAgLTAsMCArMSw5MyBAQAorIyBHaXQgQ29kZSBvZiBDb25kdWN0CisKK1RoaXMgY29kZSBvZiBjb25kdWN0IG91dGxpbmVzIG91ciBleHBlY3RhdGlvbnMgZm9yIHBhcnRpY2lwYW50cyB3aXRoaW4KK3RoZSBHaXQgY29tbXVuaXR5LCBhcyB3ZWxsIGFzIHN0ZXBzIGZvciByZXBvcnRpbmcgdW5hY2NlcHRhYmxlIGJlaGF2aW9yLgorV2UgYXJlIGNvbW1pdHRlZCB0byBwcm92aWRpbmcgYSB3ZWxjb21pbmcgYW5kIGluc3BpcmluZyBjb21tdW5pdHkgZm9yCithbGwgYW5kIGV4cGVjdCBvdXIgY29kZSBvZiBjb25kdWN0IHRvIGJlIGhvbm9yZWQuIEFueW9uZSB3aG8gdmlvbGF0ZXMKK3RoaXMgY29kZSBvZiBjb25kdWN0IG1heSBiZSBiYW5uZWQgZnJvbSB0aGUgY29tbXVuaXR5LgorCisjIyBPdXIgUGxlZGdlCisKK0luIHRoZSBpbnRlcmVzdCBvZiBmb3N0ZXJpbmcgYW4gb3BlbiBhbmQgd2VsY29taW5nIGVudmlyb25tZW50LCB3ZSBhcworY29udHJpYnV0b3JzIGFuZCBtYWludGFpbmVycyBwbGVkZ2UgdG8gbWFrZSBwYXJ0aWNpcGF0aW9uIGluIG91ciBwcm9qZWN0IGFuZAorb3VyIGNvbW11bml0eSBhIGhhcmFzc21lbnQtZnJlZSBleHBlcmllbmNlIGZvciBldmVyeW9uZSwgcmVnYXJkbGVzcyBvZiBhZ2UsCitib2R5IHNpemUsIGRpc2FiaWxpdHksIGV0aG5pY2l0eSwgc2V4IGNoYXJhY3RlcmlzdGljcywgZ2VuZGVyIGlkZW50aXR5IGFuZAorZXhwcmVzc2lvbiwgbGV2ZWwgb2YgZXhwZXJpZW5jZSwgZWR1Y2F0aW9uLCBzb2Npby1lY29ub21pYyBzdGF0dXMsCituYXRpb25hbGl0eSwgcGVyc29uYWwgYXBwZWFyYW5jZSwgcmFjZSwgcmVsaWdpb24sIG9yIHNleHVhbCBpZGVudGl0eSBhbmQKK29yaWVudGF0aW9uLgorCisjIyBPdXIgU3RhbmRhcmRzCisKK0V4YW1wbGVzIG9mIGJlaGF2aW9yIHRoYXQgY29udHJpYnV0ZXMgdG8gY3JlYXRpbmcgYSBwb3NpdGl2ZSBlbnZpcm9ubWVudAoraW5jbHVkZToKKworKiBVc2luZyB3ZWxjb21pbmcgYW5kIGluY2x1c2l2ZSBsYW5ndWFnZQorKiBCZWluZyByZXNwZWN0ZnVsIG9mIGRpZmZlcmluZyB2aWV3cG9pbnRzIGFuZCBleHBlcmllbmNlcworKiBHcmFjZWZ1bGx5IGFjY2VwdGluZyBjb25zdHJ1Y3RpdmUgY3JpdGljaXNtCisqIEZvY3VzaW5nIG9uIHdoYXQgaXMgYmVzdCBmb3IgdGhlIGNvbW11bml0eQorKiBTaG93aW5nIGVtcGF0aHkgdG93YXJkcyBvdGhlciBjb21tdW5pdHkgbWVtYmVycworCitFeGFtcGxlcyBvZiB1bmFjY2VwdGFibGUgYmVoYXZpb3IgYnkgcGFydGljaXBhbnRzIGluY2x1ZGU6CisKKyogVGhlIHVzZSBvZiBzZXh1YWxpemVkIGxhbmd1YWdlIG9yIGltYWdlcnkgYW5kIHVud2VsY29tZSBzZXh1YWwgYXR0ZW50aW9uIG9yCisgIGFkdmFuY2VzCisqIFRyb2xsaW5nLCBpbnN1bHRpbmcvZGVyb2dhdG9yeSBjb21tZW50cywgYW5kIHBlcnNvbmFsIG9yIHBvbGl0aWNhbCBhdHRhY2tzCisqIFB1YmxpYyBvciBwcml2YXRlIGhhcmFzc21lbnQKKyogUHVibGlzaGluZyBvdGhlcnMnIHByaXZhdGUgaW5mb3JtYXRpb24sIHN1Y2ggYXMgYSBwaHlzaWNhbCBvciBlbGVjdHJvbmljCisgIGFkZHJlc3MsIHdpdGhvdXQgZXhwbGljaXQgcGVybWlzc2lvbgorKiBPdGhlciBjb25kdWN0IHdoaWNoIGNvdWxkIHJlYXNvbmFibHkgYmUgY29uc2lkZXJlZCBpbmFwcHJvcHJpYXRlIGluIGEKKyAgcHJvZmVzc2lvbmFsIHNldHRpbmcKKworIyMgT3VyIFJlc3BvbnNpYmlsaXRpZXMKKworUHJvamVjdCBtYWludGFpbmVycyBhcmUgcmVzcG9uc2libGUgZm9yIGNsYXJpZnlpbmcgdGhlIHN0YW5kYXJkcyBvZiBhY2NlcHRhYmxlCitiZWhhdmlvciBhbmQgYXJlIGV4cGVjdGVkIHRvIHRha2UgYXBwcm9wcmlhdGUgYW5kIGZhaXIgY29ycmVjdGl2ZSBhY3Rpb24gaW4KK3Jlc3BvbnNlIHRvIGFueSBpbnN0YW5jZXMgb2YgdW5hY2NlcHRhYmxlIGJlaGF2aW9yLgorCitQcm9qZWN0IG1haW50YWluZXJzIGhhdmUgdGhlIHJpZ2h0IGFuZCByZXNwb25zaWJpbGl0eSB0byByZW1vdmUsIGVkaXQsIG9yCityZWplY3QgY29tbWVudHMsIGNvbW1pdHMsIGNvZGUsIHdpa2kgZWRpdHMsIGlzc3VlcywgYW5kIG90aGVyIGNvbnRyaWJ1dGlvbnMKK3RoYXQgYXJlIG5vdCBhbGlnbmVkIHRvIHRoaXMgQ29kZSBvZiBDb25kdWN0LCBvciB0byBiYW4gdGVtcG9yYXJpbHkgb3IKK3Blcm1hbmVudGx5IGFueSBjb250cmlidXRvciBmb3Igb3RoZXIgYmVoYXZpb3JzIHRoYXQgdGhleSBkZWVtIGluYXBwcm9wcmlhdGUsCit0aHJlYXRlbmluZywgb2ZmZW5zaXZlLCBvciBoYXJtZnVsLgorCisjIyBTY29wZQorCitUaGlzIENvZGUgb2YgQ29uZHVjdCBhcHBsaWVzIHdpdGhpbiBhbGwgcHJvamVjdCBzcGFjZXMsIGFuZCBpdCBhbHNvIGFwcGxpZXMKK3doZW4gYW4gaW5kaXZpZHVhbCBpcyByZXByZXNlbnRpbmcgdGhlIHByb2plY3Qgb3IgaXRzIGNvbW11bml0eSBpbiBwdWJsaWMKK3NwYWNlcy4gRXhhbXBsZXMgb2YgcmVwcmVzZW50aW5nIGEgcHJvamVjdCBvciBjb21tdW5pdHkgaW5jbHVkZSB1c2luZyBhbgorb2ZmaWNpYWwgcHJvamVjdCBlLW1haWwgYWRkcmVzcywgcG9zdGluZyB2aWEgYW4gb2ZmaWNpYWwgc29jaWFsIG1lZGlhIGFjY291bnQsCitvciBhY3RpbmcgYXMgYW4gYXBwb2ludGVkIHJlcHJlc2VudGF0aXZlIGF0IGFuIG9ubGluZSBvciBvZmZsaW5lIGV2ZW50LgorUmVwcmVzZW50YXRpb24gb2YgYSBwcm9qZWN0IG1heSBiZSBmdXJ0aGVyIGRlZmluZWQgYW5kIGNsYXJpZmllZCBieSBwcm9qZWN0CittYWludGFpbmVycy4KKworIyMgRW5mb3JjZW1lbnQKKworSW5zdGFuY2VzIG9mIGFidXNpdmUsIGhhcmFzc2luZywgb3Igb3RoZXJ3aXNlIHVuYWNjZXB0YWJsZSBiZWhhdmlvciBtYXkgYmUKK3JlcG9ydGVkIGJ5IGNvbnRhY3RpbmcgdGhlIHByb2plY3QgdGVhbSBhdCBnaXRAc2Zjb25zZXJ2YW5jeS5vcmcuIEFsbAorY29tcGxhaW50cyB3aWxsIGJlIHJldmlld2VkIGFuZCBpbnZlc3RpZ2F0ZWQgYW5kIHdpbGwgcmVzdWx0IGluIGEgcmVzcG9uc2UKK3RoYXQgaXMgZGVlbWVkIG5lY2Vzc2FyeSBhbmQgYXBwcm9wcmlhdGUgdG8gdGhlIGNpcmN1bXN0YW5jZXMuIFRoZSBwcm9qZWN0Cit0ZWFtIGlzIG9ibGlnYXRlZCB0byBtYWludGFpbiBjb25maWRlbnRpYWxpdHkgd2l0aCByZWdhcmQgdG8gdGhlIHJlcG9ydGVyIG9mCithbiBpbmNpZGVudC4gRnVydGhlciBkZXRhaWxzIG9mIHNwZWNpZmljIGVuZm9yY2VtZW50IHBvbGljaWVzIG1heSBiZSBwb3N0ZWQKK3NlcGFyYXRlbHkuCisKK1Byb2plY3QgbWFpbnRhaW5lcnMgd2hvIGRvIG5vdCBmb2xsb3cgb3IgZW5mb3JjZSB0aGUgQ29kZSBvZiBDb25kdWN0IGluIGdvb2QKK2ZhaXRoIG1heSBmYWNlIHRlbXBvcmFyeSBvciBwZXJtYW5lbnQgcmVwZXJjdXNzaW9ucyBhcyBkZXRlcm1pbmVkIGJ5IG90aGVyCittZW1iZXJzIG9mIHRoZSBwcm9qZWN0J3MgbGVhZGVyc2hpcC4KKworVGhlIHByb2plY3QgbGVhZGVyc2hpcCB0ZWFtIGNhbiBiZSBjb250YWN0ZWQgYnkgZW1haWwgYXMgYSB3aG9sZSBhdAorZ2l0QHNmY29uc2VydmFuY3kub3JnLCBvciBpbmRpdmlkdWFsbHk6CisKKyAgLSDDhnZhciBBcm5masO2csOwIEJqYXJtYXNvbiA8YXZhcmFiQGdtYWlsLmNvbT4KKyAgLSBDaHJpc3RpYW4gQ291ZGVyIDxjaHJpc3RpYW4uY291ZGVyQGdtYWlsLmNvbT4KKyAgLSBKZWZmIEtpbmcgPHBlZmZAcGVmZi5uZXQ+CisgIC0gSnVuaW8gQyBIYW1hbm8gPGdpdHN0ZXJAcG9ib3guY29tPgorCisjIyBBdHRyaWJ1dGlvbgorCitUaGlzIENvZGUgb2YgQ29uZHVjdCBpcyBhZGFwdGVkIGZyb20gdGhlIFtDb250cmlidXRvciBDb3ZlbmFudF1baG9tZXBhZ2VdLAordmVyc2lvbiAxLjQsIGF2YWlsYWJsZSBhdCBodHRwczovL3d3dy5jb250cmlidXRvci1jb3ZlbmFudC5vcmcvdmVyc2lvbi8xLzQvY29kZS1vZi1jb25kdWN0Lmh0bWwKKworW2hvbWVwYWdlXTogaHR0cHM6Ly93d3cuY29udHJpYnV0b3ItY292ZW5hbnQub3JnCisKK0ZvciBhbnN3ZXJzIHRvIGNvbW1vbiBxdWVzdGlvbnMgYWJvdXQgdGhpcyBjb2RlIG9mIGNvbmR1Y3QsIHNlZQoraHR0cHM6Ly93d3cuY29udHJpYnV0b3ItY292ZW5hbnQub3JnL2ZhcQpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9Db2RpbmdHdWlkZWxpbmVzIGIvRG9jdW1lbnRhdGlvbi9Db2RpbmdHdWlkZWxpbmVzCmluZGV4IGY0NWRiNWIuLmVkNGU0NDMgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vQ29kaW5nR3VpZGVsaW5lcworKysgYi9Eb2N1bWVudGF0aW9uL0NvZGluZ0d1aWRlbGluZXMKQEAgLTc1LDcgKzc1LDcgQEAKIAogIC0gSWYgeW91IHdhbnQgdG8gZmluZCBvdXQgaWYgYSBjb21tYW5kIGlzIGF2YWlsYWJsZSBvbiB0aGUgdXNlcidzCiAgICAkUEFUSCwgeW91IHNob3VsZCB1c2UgJ3R5cGUgPGNvbW1hbmQ+JywgaW5zdGVhZCBvZiAnd2hpY2ggPGNvbW1hbmQ+Jy4KLSAgIFRoZSBvdXRwdXQgb2YgJ3doaWNoJyBpcyBub3QgbWFjaGluZSBwYXJzZWFibGUgYW5kIGl0cyBleGl0IGNvZGUKKyAgIFRoZSBvdXRwdXQgb2YgJ3doaWNoJyBpcyBub3QgbWFjaGluZSBwYXJzYWJsZSBhbmQgaXRzIGV4aXQgY29kZQogICAgaXMgbm90IHJlbGlhYmxlIGFjcm9zcyBwbGF0Zm9ybXMuCiAKICAtIFdlIHVzZSBQT1NJWCBjb21wbGlhbnQgcGFyYW1ldGVyIHN1YnN0aXR1dGlvbnMgYW5kIGF2b2lkIGJhc2hpc21zOwpAQCAtMjAzLDcgKzIwMyw3IEBACiAgICAuIHNpbmNlIGVhcmx5IDIwMTIgd2l0aCBlMTMyNzAyM2VhLCB3ZSBoYXZlIGJlZW4gdXNpbmcgYW4gZW51bQogICAgICBkZWZpbml0aW9uIHdob3NlIGxhc3QgZWxlbWVudCBpcyBmb2xsb3dlZCBieSBhIGNvbW1hLiAgVGhpcywgbGlrZQogICAgICBhbiBhcnJheSBpbml0aWFsaXplciB0aGF0IGVuZHMgd2l0aCBhIHRyYWlsaW5nIGNvbW1hLCBjYW4gYmUgdXNlZAotICAgICB0byByZWR1Y2UgdGhlIHBhdGNoIG5vaXNlIHdoZW4gYWRkaW5nIGEgbmV3IGlkZW50aWZlciBhdCB0aGUgZW5kLgorICAgICB0byByZWR1Y2UgdGhlIHBhdGNoIG5vaXNlIHdoZW4gYWRkaW5nIGEgbmV3IGlkZW50aWZpZXIgYXQgdGhlIGVuZC4KIAogICAgLiBzaW5jZSBtaWQgMjAxNyB3aXRoIGNiYzBmODFkLCB3ZSBoYXZlIGJlZW4gdXNpbmcgZGVzaWduYXRlZAogICAgICBpbml0aWFsaXplcnMgZm9yIHN0cnVjdCAoZS5nLiAic3RydWN0IHQgdiA9IHsgLnZhbCA9ICdhJyB9OyIpLgpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9NYWtlZmlsZSBiL0RvY3VtZW50YXRpb24vTWFrZWZpbGUKaW5kZXggNzZmMmVjZi4uOGZlODI5YyAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9NYWtlZmlsZQorKysgYi9Eb2N1bWVudGF0aW9uL01ha2VmaWxlCkBAIC03Nyw2ICs3Nyw3IEBACiBTUF9BUlRJQ0xFUyArPSAkKEFQSV9ET0NTKQogCiBURUNIX0RPQ1MgKz0gTXlGaXJzdENvbnRyaWJ1dGlvbgorVEVDSF9ET0NTICs9IE15Rmlyc3RPYmplY3RXYWxrCiBURUNIX0RPQ1MgKz0gU3VibWl0dGluZ1BhdGNoZXMKIFRFQ0hfRE9DUyArPSB0ZWNobmljYWwvaGFzaC1mdW5jdGlvbi10cmFuc2l0aW9uCiBURUNIX0RPQ1MgKz0gdGVjaG5pY2FsL2h0dHAtcHJvdG9jb2wKQEAgLTEyMyw3ICsxMjQsOCBAQAogQVNDSUlET0NfRE9DQk9PSyA9IGRvY2Jvb2sKIEFTQ0lJRE9DX0NPTkYgPSAtZiBhc2NpaWRvYy5jb25mCiBBU0NJSURPQ19DT01NT04gPSAkKEFTQ0lJRE9DKSAkKEFTQ0lJRE9DX0VYVFJBKSAkKEFTQ0lJRE9DX0NPTkYpIFwKLQkJLWFnaXRfdmVyc2lvbj0kKEdJVF9WRVJTSU9OKQorCQktYW1hbnZlcnNpb249JChHSVRfVkVSU0lPTikgXAorCQktYW1hbm1hbnVhbD0nR2l0IE1hbnVhbCcgLWFtYW5zb3VyY2U9J0dpdCcKIFRYVF9UT19IVE1MID0gJChBU0NJSURPQ19DT01NT04pIC1iICQoQVNDSUlET0NfSFRNTCkKIFRYVF9UT19YTUwgPSAkKEFTQ0lJRE9DX0NPTU1PTikgLWIgJChBU0NJSURPQ19ET0NCT09LKQogTUFOUEFHRV9YU0wgPSBtYW5wYWdlLW5vcm1hbC54c2wKQEAgLTE5NywxMSArMTk5LDEzIEBACiBBU0NJSURPQyA9IGFzY2lpZG9jdG9yCiBBU0NJSURPQ19DT05GID0KIEFTQ0lJRE9DX0hUTUwgPSB4aHRtbDUKLUFTQ0lJRE9DX0RPQ0JPT0sgPSBkb2Nib29rNDUKK0FTQ0lJRE9DX0RPQ0JPT0sgPSBkb2Nib29rNQogQVNDSUlET0NfRVhUUkEgKz0gLWFjb21wYXQtbW9kZSAtYXRhYnNpemU9OAogQVNDSUlET0NfRVhUUkEgKz0gLUkuIC1yYXNjaWlkb2N0b3ItZXh0ZW5zaW9ucwogQVNDSUlET0NfRVhUUkEgKz0gLWFsaXRkZD0nJlwjeDJkOyZcI3gyZDsnCiBEQkxBVEVYX0NPTU1PTiA9CitYTUxUT19FWFRSQSArPSAtLXNraXAtdmFsaWRhdGlvbgorWE1MVE9fRVhUUkEgKz0gLXggbWFucGFnZS54c2wKIGVuZGlmCiAKIFNIRUxMX1BBVEggPz0gJChTSEVMTCkKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vTXlGaXJzdENvbnRyaWJ1dGlvbi50eHQgYi9Eb2N1bWVudGF0aW9uL015Rmlyc3RDb250cmlidXRpb24udHh0CmluZGV4IGY4NjcwMzcuLmI1NTgzN2UgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vTXlGaXJzdENvbnRyaWJ1dGlvbi50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9NeUZpcnN0Q29udHJpYnV0aW9uLnR4dApAQCAtMzgsNiArMzgsMjYgQEAKICQgY2QgZ2l0CiAtLS0tCiAKK1tbZGVwZW5kZW5jaWVzXV0KKz09PSBJbnN0YWxsaW5nIERlcGVuZGVuY2llcworCitUbyBidWlsZCBHaXQgZnJvbSBzb3VyY2UsIHlvdSBuZWVkIHRvIGhhdmUgYSBoYW5kZnVsIG9mIGRlcGVuZGVuY2llcyBpbnN0YWxsZWQKK29uIHlvdXIgc3lzdGVtLiBGb3IgYSBoaW50IG9mIHdoYXQncyBuZWVkZWQsIHlvdSBjYW4gdGFrZSBhIGxvb2sgYXQKK2BJTlNUQUxMYCwgcGF5aW5nIGNsb3NlIGF0dGVudGlvbiB0byB0aGUgc2VjdGlvbiBhYm91dCBHaXQncyBkZXBlbmRlbmNpZXMgb24KK2V4dGVybmFsIHByb2dyYW1zIGFuZCBsaWJyYXJpZXMuIFRoYXQgZG9jdW1lbnQgbWVudGlvbnMgYSB3YXkgdG8gInRlc3QtZHJpdmUiCitvdXIgZnJlc2hseSBidWlsdCBHaXQgd2l0aG91dCBpbnN0YWxsaW5nOyB0aGF0J3MgdGhlIG1ldGhvZCB3ZSdsbCBiZSB1c2luZyBpbgordGhpcyB0dXRvcmlhbC4KKworTWFrZSBzdXJlIHRoYXQgeW91ciBlbnZpcm9ubWVudCBoYXMgZXZlcnl0aGluZyB5b3UgbmVlZCBieSBidWlsZGluZyB5b3VyIGJyYW5kCituZXcgY2xvbmUgb2YgR2l0IGZyb20gdGhlIGFib3ZlIHN0ZXA6CisKKy0tLS0KKyQgbWFrZQorLS0tLQorCitOT1RFOiBUaGUgR2l0IGJ1aWxkIGlzIHBhcmFsbGVsaXphYmxlLiBgLWojYCBpcyBub3QgaW5jbHVkZWQgYWJvdmUgYnV0IHlvdSBjYW4KK3VzZSBpdCBhcyB5b3UgcHJlZmVyLCBoZXJlIGFuZCBlbHNld2hlcmUuCisKIFtbaWRlbnRpZnktcHJvYmxlbV1dCiA9PT0gSWRlbnRpZnkgUHJvYmxlbSB0byBTb2x2ZQogCkBAIC05Nyw4ICsxMTcsOCBAQAogLS0tLQogCiBXZSdsbCBhbHNvIG5lZWQgdG8gYWRkIHRoZSBkZWNsYXJhdGlvbiBvZiBwc3VoOyBvcGVuIHVwIGBidWlsdGluLmhgLCBmaW5kIHRoZQotZGVjbGFyYXRpb24gZm9yIGBjbWRfcHVzaGAsIGFuZCBhZGQgYSBuZXcgbGluZSBmb3IgYHBzdWhgIGltbWVkaWF0ZWx5IGJlZm9yZSBpdCwKLWluIG9yZGVyIHRvIGtlZXAgdGhlIGRlY2xhcmF0aW9ucyBzb3J0ZWQ6CitkZWNsYXJhdGlvbiBmb3IgYGNtZF9wdWxsYCwgYW5kIGFkZCBhIG5ldyBsaW5lIGZvciBgcHN1aGAgaW1tZWRpYXRlbHkgYmVmb3JlIGl0LAoraW4gb3JkZXIgdG8ga2VlcCB0aGUgZGVjbGFyYXRpb25zIGFscGhhYmV0aWNhbGx5IHNvcnRlZDoKIAogLS0tLQogaW50IGNtZF9wc3VoKGludCBhcmdjLCBjb25zdCBjaGFyICoqYXJndiwgY29uc3QgY2hhciAqcHJlZml4KTsKQEAgLTEyMyw3ICsxNDMsNyBAQAogfQogLS0tLQogCi1MZXQncyB0cnkgdG8gYnVpbGQgaXQuICBPcGVuIGBNYWtlZmlsZWAsIGZpbmQgd2hlcmUgYGJ1aWx0aW4vcHVzaC5vYCBpcyBhZGRlZAorTGV0J3MgdHJ5IHRvIGJ1aWxkIGl0LiAgT3BlbiBgTWFrZWZpbGVgLCBmaW5kIHdoZXJlIGBidWlsdGluL3B1bGwub2AgaXMgYWRkZWQKIHRvIGBCVUlMVElOX09CSlNgLCBhbmQgYWRkIGBidWlsdGluL3BzdWgub2AgaW4gdGhlIHNhbWUgd2F5IG5leHQgdG8gaXQgaW4KIGFscGhhYmV0aWNhbCBvcmRlci4gT25jZSB5b3UndmUgZG9uZSBzbywgbW92ZSB0byB0aGUgdG9wLWxldmVsIGRpcmVjdG9yeSBhbmQKIGJ1aWxkIHNpbXBseSB3aXRoIGBtYWtlYC4gQWxzbyBhZGQgdGhlIGBERVZFTE9QRVI9MWAgdmFyaWFibGUgdG8gdHVybiBvbgpAQCAtMTM4LDkgKzE1OCw2IEBACiBgREVWRUxPUEVSYCBmbGFnOyBpZiB0aGVyZSdzIHNvbWUgcmVhc29uIGl0IGRvZXNuJ3Qgd29yayBmb3IgeW91LCB5b3UgY2FuIHR1cm4KIGl0IG9mZiwgYnV0IGl0J3MgYSBnb29kIGlkZWEgdG8gbWVudGlvbiB0aGUgcHJvYmxlbSB0byB0aGUgbWFpbGluZyBsaXN0LgogCi1OT1RFOiBUaGUgR2l0IGJ1aWxkIGlzIHBhcmFsbGVsaXphYmxlLiBgLWojYCBpcyBub3QgaW5jbHVkZWQgYWJvdmUgYnV0IHlvdSBjYW4KLXVzZSBpdCBhcyB5b3UgcHJlZmVyLCBoZXJlIGFuZCBlbHNld2hlcmUuCi0KIEdyZWF0LCBub3cgeW91ciBuZXcgY29tbWFuZCBidWlsZHMgaGFwcGlseSBvbiBpdHMgb3duLiBCdXQgbm9ib2R5IGludm9rZXMgaXQuCiBMZXQncyBjaGFuZ2UgdGhhdC4KIApAQCAtMTQ5LDcgKzE2Niw3IEBACiB3aXRoIHRoZSBjb21tYW5kIG5hbWUsIGEgZnVuY3Rpb24gcG9pbnRlciB0byB0aGUgY29tbWFuZCBpbXBsZW1lbnRhdGlvbiwgYW5kIGEKIHNldHVwIG9wdGlvbiBmbGFnLiBGb3Igbm93LCBsZXQncyBrZWVwIG1pbWlja2luZyBgcHVzaGAuIEZpbmQgdGhlIGxpbmUgd2hlcmUKIGBjbWRfcHVzaGAgaXMgcmVnaXN0ZXJlZCwgY29weSBpdCwgYW5kIG1vZGlmeSBpdCBmb3IgYGNtZF9wc3VoYCwgcGxhY2luZyB0aGUgbmV3Ci1saW5lIGluIGFscGhhYmV0aWNhbCBvcmRlci4KK2xpbmUgaW4gYWxwaGFiZXRpY2FsIG9yZGVyIChpbW1lZGlhdGVseSBiZWZvcmUgYGNtZF9wdWxsYCkuCiAKIFRoZSBvcHRpb25zIGFyZSBkb2N1bWVudGVkIGluIGBidWlsdGluLmhgIHVuZGVyICJBZGRpbmcgYSBuZXcgYnVpbHQtaW4uIiBTaW5jZQogd2UgaG9wZSB0byBwcmludCBzb21lIGRhdGEgYWJvdXQgdGhlIHVzZXIncyBjdXJyZW50IHdvcmtzcGFjZSBjb250ZXh0IGxhdGVyLApAQCAtMTY3LDcgKzE4NCw3IEBACiAKIGBnaXQgc3RhdHVzYCByZXZlYWxzIG1vZGlmaWVkIGBNYWtlZmlsZWAsIGBidWlsdGluLmhgLCBhbmQgYGdpdC5jYCBhcyB3ZWxsIGFzCiB1bnRyYWNrZWQgYGJ1aWx0aW4vcHN1aC5jYCBhbmQgYGdpdC1wc3VoYC4gRmlyc3QsIGxldCdzIHRha2UgY2FyZSBvZiB0aGUgYmluYXJ5LAotd2hpY2ggc2hvdWxkIGJlIGlnbm9yZWQuIE9wZW4gYC5naXRpZ25vcmVgIGluIHlvdXIgZWRpdG9yLCBmaW5kIGAvZ2l0LXB1c2hgLCBhbmQKK3doaWNoIHNob3VsZCBiZSBpZ25vcmVkLiBPcGVuIGAuZ2l0aWdub3JlYCBpbiB5b3VyIGVkaXRvciwgZmluZCBgL2dpdC1wdWxsYCwgYW5kCiBhZGQgYW4gZW50cnkgZm9yIHlvdXIgbmV3IGNvbW1hbmQgaW4gYWxwaGFiZXRpY2FsIG9yZGVyOgogCiAtLS0tCkBAIC01MzQsNiArNTUxLDI4IEBACiBhIGZsYWcuKSBgcGFyc2Vfb3B0aW9ucygpYCB3aWxsIHRlcm1pbmF0ZSBwYXJzaW5nIHdoZW4gaXQgcmVhY2hlcyBgLS1gIGFuZCBnaXZlCiB5b3UgdGhlIHJlc3Qgb2YgdGhlIG9wdGlvbnMgYWZ0ZXJ3YXJkcywgdW50b3VjaGVkLgogCitOb3cgdGhhdCB5b3UgaGF2ZSBhIHVzYWdlIGhpbnQsIHlvdSBjYW4gdGVhY2ggR2l0IGhvdyB0byBzaG93IGl0IGluIHRoZSBnZW5lcmFsCitjb21tYW5kIGxpc3Qgc2hvd24gYnkgYGdpdCBoZWxwIGdpdGAgb3IgYGdpdCBoZWxwIC1hYCwgd2hpY2ggaXMgZ2VuZXJhdGVkIGZyb20KK2Bjb21tYW5kLWxpc3QudHh0YC4gRmluZCB0aGUgbGluZSBmb3IgJ2dpdC1wdWxsJyBzbyB5b3UgY2FuIGFkZCB5b3VyICdnaXQtcHN1aCcKK2xpbmUgYWJvdmUgaXQgaW4gYWxwaGFiZXRpY2FsIG9yZGVyLiBOb3csIHdlIGNhbiBhZGQgc29tZSBhdHRyaWJ1dGVzIGFib3V0IHRoZQorY29tbWFuZCB3aGljaCBpbXBhY3RzIHdoZXJlIGl0IHNob3dzIHVwIGluIHRoZSBhZm9yZW1lbnRpb25lZCBoZWxwIGNvbW1hbmRzLiBUaGUKK3RvcCBvZiBgY29tbWFuZC1saXN0LnR4dGAgc2hhcmVzIHNvbWUgaW5mb3JtYXRpb24gYWJvdXQgd2hhdCBlYWNoIGF0dHJpYnV0ZQorbWVhbnM7IGluIHRob3NlIGhlbHAgcGFnZXMsIHRoZSBjb21tYW5kcyBhcmUgc29ydGVkIGFjY29yZGluZyB0byB0aGVzZQorYXR0cmlidXRlcy4gYGdpdCBwc3VoYCBpcyB1c2VyLWZhY2luZywgb3IgcG9yY2VsYWluIC0gc28gd2Ugd2lsbCBtYXJrIGl0IGFzCisibWFpbnBvcmNlbGFpbiIuIEZvciAibWFpbnBvcmNlbGFpbiIgY29tbWFuZHMsIHRoZSBjb21tZW50cyBhdCB0aGUgdG9wIG9mCitgY29tbWFuZC1saXN0LnR4dGAgaW5kaWNhdGUgd2UgY2FuIGFsc28gb3B0aW9uYWxseSBhZGQgYW4gYXR0cmlidXRlIGZyb20gYW5vdGhlcgorbGlzdDsgc2luY2UgYGdpdCBwc3VoYCBzaG93cyBzb21lIGluZm9ybWF0aW9uIGFib3V0IHRoZSB1c2VyJ3Mgd29ya3NwYWNlIGJ1dAorZG9lc24ndCBtb2RpZnkgYW55dGhpbmcsIGxldCdzIG1hcmsgaXQgYXMgImluZm8iLiBNYWtlIHN1cmUgdG8ga2VlcCB5b3VyCithdHRyaWJ1dGVzIGluIHRoZSBzYW1lIHN0eWxlIGFzIHRoZSByZXN0IG9mIGBjb21tYW5kLWxpc3QudHh0YCB1c2luZyBzcGFjZXMgdG8KK2FsaWduIGFuZCBkZWxpbmVhdGUgdGhlbToKKworLS0tLQorZ2l0LXBydW5lLXBhY2tlZCAgICAgICAgICAgICAgICAgICAgICAgIHBsdW1iaW5nbWFuaXB1bGF0b3JzCitnaXQtcHN1aCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgbWFpbnBvcmNlbGFpbgkJaW5mbworZ2l0LXB1bGwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIG1haW5wb3JjZWxhaW4gICAgICAgICAgIHJlbW90ZQorZ2l0LXB1c2ggICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIG1haW5wb3JjZWxhaW4gICAgICAgICAgIHJlbW90ZQorLS0tLQorCiBCdWlsZCBhZ2Fpbi4gTm93LCB3aGVuIHlvdSBydW4gd2l0aCBgLWhgLCB5b3Ugc2hvdWxkIHNlZSB5b3VyIHVzYWdlIHByaW50ZWQgYW5kCiB5b3VyIGNvbW1hbmQgdGVybWluYXRlZCBiZWZvcmUgYW55dGhpbmcgZWxzZSBpbnRlcmVzdGluZyBoYXBwZW5zLiBHcmVhdCEKIApAQCAtNzQ2LDYgKzc4NSwxNCBAQAogYnV0IHlvdSB3aWxsIG5vdCBiZSBhYmxlIHRvIGAvc3VibWl0YCB5b3VyIGNoYW5nZXMgdW50aWwgc29tZW9uZSBhbGxvd3MgeW91IHRvCiB1c2UgdGhlIHRvb2wuCiAKK05PVEU6IFlvdSBjYW4gdHlwaWNhbGx5IGZpbmQgc29tZW9uZSB3aG8gY2FuIGAvYWxsb3dgIHlvdSBvbiBHaXRHaXRHYWRnZXQgYnkKK2VpdGhlciBleGFtaW5pbmcgcmVjZW50IHB1bGwgcmVxdWVzdHMgd2hlcmUgc29tZW9uZSBoYXMgYmVlbiBncmFudGVkIGAvYWxsb3dgCisoaHR0cHM6Ly9naXRodWIuY29tL2dpdGdpdGdhZGdldC9naXQvcHVsbHM/dXRmOD0lRTIlOUMlOTMmcT1pcyUzQXByK2lzJTNBb3BlbislMjIlMkZhbGxvdyUyMltTZWFyY2g6CitpczpwciBpczpvcGVuICIvYWxsb3ciXSksIGluIHdoaWNoIGNhc2UgYm90aCB0aGUgYXV0aG9yIGFuZCB0aGUgcGVyc29uIHdobworZ3JhbnRlZCB0aGUgYC9hbGxvd2AgY2FuIG5vdyBgL2FsbG93YCB5b3UsIG9yIGJ5IGlucXVpcmluZyBvbiB0aGUKK2h0dHBzOi8vd2ViY2hhdC5mcmVlbm9kZS5uZXQvI2dpdC1kZXZlbFsjZ2l0LWRldmVsXSBJUkMgY2hhbm5lbCBvbiBGcmVlbm9kZQorbGlua2luZyB5b3VyIHB1bGwgcmVxdWVzdCBhbmQgYXNraW5nIGZvciBzb21lb25lIHRvIGAvYWxsb3dgIHlvdS4KKwogSWYgdGhlIENJIGZhaWxzLCB5b3UgY2FuIHVwZGF0ZSB5b3VyIGNoYW5nZXMgd2l0aCBgZ2l0IHJlYmFzZSAtaWAgYW5kIHB1c2ggeW91cgogYnJhbmNoIGFnYWluOgogCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL015Rmlyc3RPYmplY3RXYWxrLnR4dCBiL0RvY3VtZW50YXRpb24vTXlGaXJzdE9iamVjdFdhbGsudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjRkMjRkYWUKLS0tIC9kZXYvbnVsbAorKysgYi9Eb2N1bWVudGF0aW9uL015Rmlyc3RPYmplY3RXYWxrLnR4dApAQCAtMCwwICsxLDkwNiBAQAorPSBNeSBGaXJzdCBPYmplY3QgV2FsaworCis9PSBXaGF0J3MgYW4gT2JqZWN0IFdhbGs/CisKK1RoZSBvYmplY3Qgd2FsayBpcyBhIGtleSBjb25jZXB0IGluIEdpdCAtIHRoaXMgaXMgdGhlIHByb2Nlc3MgdGhhdCB1bmRlcnBpbnMKK29wZXJhdGlvbnMgbGlrZSBvYmplY3QgdHJhbnNmZXIgYW5kIGZzY2suIEJlZ2lubmluZyBmcm9tIGEgZ2l2ZW4gY29tbWl0LCB0aGUKK2xpc3Qgb2Ygb2JqZWN0cyBpcyBmb3VuZCBieSB3YWxraW5nIHBhcmVudCByZWxhdGlvbnNoaXBzIGJldHdlZW4gY29tbWl0cyAoY29tbWl0CitYIGJhc2VkIG9uIGNvbW1pdCBXKSBhbmQgY29udGFpbm1lbnQgcmVsYXRpb25zaGlwcyBiZXR3ZWVuIG9iamVjdHMgKHRyZWUgWSBpcworY29udGFpbmVkIHdpdGhpbiBjb21taXQgWCwgYW5kIGJsb2IgWiBpcyBsb2NhdGVkIHdpdGhpbiB0cmVlIFksIGdpdmluZyBvdXIKK3dvcmtpbmcgdHJlZSBmb3IgY29tbWl0IFggc29tZXRoaW5nIGxpa2UgYHkvei50eHRgKS4KKworQSByZWxhdGVkIGNvbmNlcHQgaXMgdGhlIHJldmlzaW9uIHdhbGssIHdoaWNoIGlzIGZvY3VzZWQgb24gY29tbWl0IG9iamVjdHMgYW5kCit0aGVpciBwYXJlbnQgcmVsYXRpb25zaGlwcyBhbmQgZG9lcyBub3QgZGVsdmUgaW50byBvdGhlciBvYmplY3QgdHlwZXMuIFRoZQorcmV2aXNpb24gd2FsayBpcyB1c2VkIGZvciBvcGVyYXRpb25zIGxpa2UgYGdpdCBsb2dgLgorCis9PT0gUmVsYXRlZCBSZWFkaW5nCisKKy0gYERvY3VtZW50YXRpb24vdXNlci1tYW51YWwudHh0YCB1bmRlciAiSGFja2luZyBHaXQiIGNvbnRhaW5zIHNvbWUgY292ZXJhZ2Ugb2YKKyAgdGhlIHJldmlzaW9uIHdhbGtlciBpbiBpdHMgdmFyaW91cyBpbmNhcm5hdGlvbnMuCistIGBEb2N1bWVudGF0aW9uL3RlY2huaWNhbC9hcGktcmV2aXNpb24td2Fsa2luZy50eHRgCistIGh0dHBzOi8vZWFnYWluLm5ldC9hcnRpY2xlcy9naXQtZm9yLWNvbXB1dGVyLXNjaWVudGlzdHMvW0dpdCBmb3IgQ29tcHV0ZXIgU2NpZW50aXN0c10KKyAgZ2l2ZXMgYSBnb29kIG92ZXJ2aWV3IG9mIHRoZSB0eXBlcyBvZiBvYmplY3RzIGluIEdpdCBhbmQgd2hhdCB5b3VyIG9iamVjdAorICB3YWxrIGlzIHJlYWxseSBkZXNjcmliaW5nLgorCis9PSBTZXR0aW5nIFVwCisKK0NyZWF0ZSBhIG5ldyBicmFuY2ggZnJvbSBgbWFzdGVyYC4KKworLS0tLQorZ2l0IGNoZWNrb3V0IC1iIHJldndhbGsgb3JpZ2luL21hc3RlcgorLS0tLQorCitXZSdsbCBwdXQgb3VyIGZpZGRsaW5nIGludG8gYSBuZXcgY29tbWFuZC4gRm9yIGZ1biwgbGV0J3MgbmFtZSBpdCBgZ2l0IHdhbGtlbmAuCitPcGVuIHVwIGEgbmV3IGZpbGUgYGJ1aWx0aW4vd2Fsa2VuLmNgIGFuZCBzZXQgdXAgdGhlIGNvbW1hbmQgaGFuZGxlcjoKKworLS0tLQorLyoKKyAqICJnaXQgd2Fsa2VuIgorICoKKyAqIFBhcnQgb2YgdGhlICJNeSBGaXJzdCBPYmplY3QgV2FsayIgdHV0b3JpYWwuCisgKi8KKworI2luY2x1ZGUgImJ1aWx0aW4uaCIKKworaW50IGNtZF93YWxrZW4oaW50IGFyZ2MsIGNvbnN0IGNoYXIgKiphcmd2LCBjb25zdCBjaGFyICpwcmVmaXgpCit7CisJdHJhY2VfcHJpbnRmKF8oImNtZF93YWxrZW4gaW5jb21pbmcuLi5cbiIpKTsKKwlyZXR1cm4gMDsKK30KKy0tLS0KKworTk9URTogYHRyYWNlX3ByaW50ZigpYCBkaWZmZXJzIGZyb20gYHByaW50ZigpYCBpbiB0aGF0IGl0IGNhbiBiZSB0dXJuZWQgb24gb3IKK29mZiBhdCBydW50aW1lLiBGb3IgdGhlIHB1cnBvc2VzIG9mIHRoaXMgdHV0b3JpYWwsIHdlIHdpbGwgd3JpdGUgYHdhbGtlbmAgYXMKK3Rob3VnaCBpdCBpcyBpbnRlbmRlZCBmb3IgdXNlIGFzIGEgInBsdW1iaW5nIiBjb21tYW5kOiB0aGF0IGlzLCBhIGNvbW1hbmQgd2hpY2gKK2lzIHVzZWQgcHJpbWFyaWx5IGluIHNjcmlwdHMsIHJhdGhlciB0aGFuIGludGVyYWN0aXZlbHkgYnkgaHVtYW5zIChhICJwb3JjZWxhaW4iCitjb21tYW5kKS4gU28gd2Ugd2lsbCBzZW5kIG91ciBkZWJ1ZyBvdXRwdXQgdG8gYHRyYWNlX3ByaW50ZigpYCBpbnN0ZWFkLiBXaGVuCitydW5uaW5nLCBlbmFibGUgdHJhY2Ugb3V0cHV0IGJ5IHNldHRpbmcgdGhlIGVudmlyb25tZW50IHZhcmlhYmxlIGBHSVRfVFJBQ0VgLgorCitBZGQgdXNhZ2UgdGV4dCBhbmQgYC1oYCBoYW5kbGluZywgbGlrZSBhbGwgc3ViY29tbWFuZHMgc2hvdWxkIGNvbnNpc3RlbnRseSBkbworKG91ciB0ZXN0IHN1aXRlIHdpbGwgbm90aWNlIGFuZCBjb21wbGFpbiBpZiB5b3UgZmFpbCB0byBkbyBzbykuCisKKy0tLS0KK2ludCBjbWRfd2Fsa2VuKGludCBhcmdjLCBjb25zdCBjaGFyICoqYXJndiwgY29uc3QgY2hhciAqcHJlZml4KQoreworCWNvbnN0IGNoYXIgKiBjb25zdCB3YWxrZW5fdXNhZ2VbXSA9IHsKKwkJTl8oImdpdCB3YWxrZW4iKSwKKwkJTlVMTCwKKwl9CisJc3RydWN0IG9wdGlvbiBvcHRpb25zW10gPSB7CisJCU9QVF9FTkQoKQorCX07CisKKwlhcmdjID0gcGFyc2Vfb3B0aW9ucyhhcmdjLCBhcmd2LCBwcmVmaXgsIG9wdGlvbnMsIHdhbGtlbl91c2FnZSwgMCk7CisKKwkuLi4KK30KKy0tLS0KKworQWxzbyBhZGQgdGhlIHJlbGV2YW50IGxpbmUgaW4gYGJ1aWx0aW4uaGAgbmVhciBgY21kX3doYXRjaGFuZ2VkKClgOgorCistLS0tCitpbnQgY21kX3dhbGtlbihpbnQgYXJnYywgY29uc3QgY2hhciAqKmFyZ3YsIGNvbnN0IGNoYXIgKnByZWZpeCk7CistLS0tCisKK0luY2x1ZGUgdGhlIGNvbW1hbmQgaW4gYGdpdC5jYCBpbiBgY29tbWFuZHNbXWAgbmVhciB0aGUgZW50cnkgZm9yIGB3aGF0Y2hhbmdlZGAsCittYWludGFpbmluZyBhbHBoYWJldGljYWwgb3JkZXJpbmc6CisKKy0tLS0KK3sgIndhbGtlbiIsIGNtZF93YWxrZW4sIFJVTl9TRVRVUCB9LAorLS0tLQorCitBZGQgaXQgdG8gdGhlIGBNYWtlZmlsZWAgbmVhciB0aGUgbGluZSBmb3IgYGJ1aWx0aW4vd29ya3RyZWUub2A6CisKKy0tLS0KK0JVSUxUSU5fT0JKUyArPSBidWlsdGluL3dhbGtlbi5vCistLS0tCisKK0J1aWxkIGFuZCB0ZXN0IG91dCB5b3VyIGNvbW1hbmQsIHdpdGhvdXQgZm9yZ2V0dGluZyB0byBlbnN1cmUgdGhlIGBERVZFTE9QRVJgCitmbGFnIGlzIHNldCwgYW5kIHdpdGggYEdJVF9UUkFDRWAgZW5hYmxlZCBzbyB0aGUgZGVidWcgb3V0cHV0IGNhbiBiZSBzZWVuOgorCistLS0tCiskIGVjaG8gREVWRUxPUEVSPTEgPj5jb25maWcubWFrCiskIG1ha2UKKyQgR0lUX1RSQUNFPTEgLi9iaW4td3JhcHBlcnMvZ2l0IHdhbGtlbgorLS0tLQorCitOT1RFOiBGb3IgYSBtb3JlIGV4aGF1c3RpdmUgb3ZlcnZpZXcgb2YgdGhlIG5ldyBjb21tYW5kIHByb2Nlc3MsIHRha2UgYSBsb29rIGF0CitgRG9jdW1lbnRhdGlvbi9NeUZpcnN0Q29udHJpYnV0aW9uLnR4dGAuCisKK05PVEU6IEEgcmVmZXJlbmNlIGltcGxlbWVudGF0aW9uIGNhbiBiZSBmb3VuZCBhdAoraHR0cHM6Ly9naXRodWIuY29tL25hc2FtdWZmaW4vZ2l0L3RyZWUvcmV2d2Fsay4KKworPT09IGBzdHJ1Y3QgcmV2X2NtZGxpbmVfaW5mb2AKKworVGhlIGRlZmluaXRpb24gb2YgYHN0cnVjdCByZXZfY21kbGluZV9pbmZvYCBjYW4gYmUgZm91bmQgaW4gYHJldmlzaW9uLmhgLgorCitUaGlzIHN0cnVjdCBpcyBjb250YWluZWQgd2l0aGluIHRoZSBgcmV2X2luZm9gIHN0cnVjdCBhbmQgaXMgdXNlZCB0byByZWZsZWN0CitwYXJhbWV0ZXJzIHByb3ZpZGVkIGJ5IHRoZSB1c2VyIG92ZXIgdGhlIENMSS4KKworYG5yYCByZXByZXNlbnRzIHRoZSBudW1iZXIgb2YgYHJldl9jbWRsaW5lX2VudHJ5YCBwcmVzZW50IGluIHRoZSBhcnJheS4KKworYGFsbG9jYCBpcyB1c2VkIGJ5IHRoZSBgQUxMT0NfR1JPV2AgbWFjcm8uIENoZWNrCitgRG9jdW1lbnRhdGlvbi90ZWNobmljYWwvYXBpLWFsbG9jYXRpb24tZ3Jvd2luZy50eHRgIC0gdGhpcyB2YXJpYWJsZSBpcyB1c2VkIHRvCit0cmFjayB0aGUgYWxsb2NhdGVkIHNpemUgb2YgdGhlIGxpc3QuCisKK1BlciBlbnRyeSwgd2UgZmluZDoKKworYGl0ZW1gIGlzIHRoZSBvYmplY3QgcHJvdmlkZWQgdXBvbiB3aGljaCB0byBiYXNlIHRoZSBvYmplY3Qgd2Fsay4gSXRlbXMgaW4gR2l0CitjYW4gYmUgYmxvYnMsIHRyZWVzLCBjb21taXRzLCBvciB0YWdzLiAoU2VlIGBEb2N1bWVudGF0aW9uL2dpdHR1dG9yaWFsLTIudHh0YC4pCisKK2BuYW1lYCBpcyB0aGUgb2JqZWN0IElEIChPSUQpIG9mIHRoZSBvYmplY3QgLSBhIGhleCBzdHJpbmcgeW91IG1heSBiZSBmYW1pbGlhcgord2l0aCBmcm9tIHVzaW5nIEdpdCB0byBvcmdhbml6ZSB5b3VyIHNvdXJjZSBpbiB0aGUgcGFzdC4gQ2hlY2sgdGhlIHR1dG9yaWFsCittZW50aW9uZWQgYWJvdmUgdG93YXJkcyB0aGUgdG9wIGZvciBhIGRpc2N1c3Npb24gb2Ygd2hlcmUgdGhlIE9JRCBjYW4gY29tZQorZnJvbS4KKworYHdoZW5jZWAgaW5kaWNhdGVzIHNvbWUgaW5mb3JtYXRpb24gYWJvdXQgd2hhdCB0byBkbyB3aXRoIHRoZSBwYXJlbnRzIG9mIHRoZQorc3BlY2lmaWVkIG9iamVjdC4gV2UnbGwgZXhwbG9yZSB0aGlzIGZsYWcgbW9yZSBsYXRlciBvbjsgdGFrZSBhIGxvb2sgYXQKK2BEb2N1bWVudGF0aW9uL3JldmlzaW9ucy50eHRgIHRvIGdldCBhbiBpZGVhIG9mIHdoYXQgY291bGQgc2V0IHRoZSBgd2hlbmNlYAordmFsdWUuCisKK2BmbGFnc2AgYXJlIHVzZWQgdG8gaGludCB0aGUgYmVnaW5uaW5nIG9mIHRoZSByZXZpc2lvbiB3YWxrIGFuZCBhcmUgdGhlIGZpcnN0CitibG9jayB1bmRlciB0aGUgYCNpbmNsdWRlYHMgaW4gYHJldmlzaW9uLmhgLiBUaGUgbW9zdCBsaWtlbHkgb25lcyB0byBiZSBzZXQgaW4KK3RoZSBgcmV2X2NtZGxpbmVfaW5mb2AgYXJlIGBVTklOVEVSRVNUSU5HYCBhbmQgYEJPVFRPTWAsIGJ1dCB0aGVzZSBzYW1lIGZsYWdzCitjYW4gYmUgdXNlZCBkdXJpbmcgdGhlIHdhbGssIGFzIHdlbGwuCisKKz09PSBgc3RydWN0IHJldl9pbmZvYAorCitUaGlzIG9uZSBpcyBxdWl0ZSBhIGJpdCBsb25nZXIsIGFuZCBtYW55IGZpZWxkcyBhcmUgb25seSB1c2VkIGR1cmluZyB0aGUgd2FsaworYnkgYHJldmlzaW9uLmNgIC0gbm90IGNvbmZpZ3VyYXRpb24gb3B0aW9ucy4gTW9zdCBvZiB0aGUgY29uZmlndXJhYmxlIGZsYWdzIGluCitgc3RydWN0IHJldl9pbmZvYCBoYXZlIGEgbWlycm9yIGluIGBEb2N1bWVudGF0aW9uL3Jldi1saXN0LW9wdGlvbnMudHh0YC4gSXQncyBhCitnb29kIGlkZWEgdG8gdGFrZSBzb21lIHRpbWUgYW5kIHJlYWQgdGhyb3VnaCB0aGF0IGRvY3VtZW50LgorCis9PSBCYXNpYyBDb21taXQgV2FsaworCitGaXJzdCwgbGV0J3Mgc2VlIGlmIHdlIGNhbiByZXBsaWNhdGUgdGhlIG91dHB1dCBvZiBgZ2l0IGxvZyAtLW9uZWxpbmVgLiBXZSdsbAorcmVmZXIgYmFjayB0byB0aGUgaW1wbGVtZW50YXRpb24gZnJlcXVlbnRseSB0byBkaXNjb3ZlciBub3JtcyB3aGVuIHBlcmZvcm1pbmcKK2FuIG9iamVjdCB3YWxrIG9mIG91ciBvd24uCisKK1RvIGRvIHNvLCB3ZSdsbCBmaXJzdCBmaW5kIGFsbCB0aGUgY29tbWl0cywgaW4gb3JkZXIsIHdoaWNoIHByZWNlZGVkIHRoZSBjdXJyZW50Citjb21taXQuIFdlJ2xsIGV4dHJhY3QgdGhlIG5hbWUgYW5kIHN1YmplY3Qgb2YgdGhlIGNvbW1pdCBmcm9tIGVhY2guCisKK0lkZWFsbHksIHdlIHdpbGwgYWxzbyBiZSBhYmxlIHRvIGZpbmQgb3V0IHdoaWNoIG9uZXMgYXJlIGN1cnJlbnRseSBhdCB0aGUgdGlwIG9mCit2YXJpb3VzIGJyYW5jaGVzLgorCis9PT0gU2V0dGluZyBVcAorCitQcmVwYXJpbmcgZm9yIHlvdXIgb2JqZWN0IHdhbGsgaGFzIHNvbWUgZGlzdGluY3Qgc3RhZ2VzLgorCisxLiBQZXJmb3JtIGRlZmF1bHQgc2V0dXAgZm9yIHRoaXMgbW9kZSwgYW5kIG90aGVycyB3aGljaCBtYXkgYmUgaW52b2tlZC4KKzIuIENoZWNrIGNvbmZpZ3VyYXRpb24gZmlsZXMgZm9yIHJlbGV2YW50IHNldHRpbmdzLgorMy4gU2V0IHVwIHRoZSBgcmV2X2luZm9gIHN0cnVjdC4KKzQuIFR3ZWFrIHRoZSBpbml0aWFsaXplZCBgcmV2X2luZm9gIHRvIHN1aXQgdGhlIGN1cnJlbnQgd2Fsay4KKzUuIFByZXBhcmUgdGhlIGByZXZfaW5mb2AgZm9yIHRoZSB3YWxrLgorNi4gSXRlcmF0ZSBvdmVyIHRoZSBvYmplY3RzLCBwcm9jZXNzaW5nIGVhY2ggb25lLgorCis9PT09IERlZmF1bHQgU2V0dXBzCisKK0JlZm9yZSBleGFtaW5pbmcgY29uZmlndXJhdGlvbiBmaWxlcyB3aGljaCBtYXkgbW9kaWZ5IGNvbW1hbmQgYmVoYXZpb3IsIHNldCB1cAorZGVmYXVsdCBzdGF0ZSBmb3Igc3dpdGNoZXMgb3Igb3B0aW9ucyB5b3VyIGNvbW1hbmQgbWF5IGhhdmUuIElmIHlvdXIgY29tbWFuZAordXRpbGl6ZXMgb3RoZXIgR2l0IGNvbXBvbmVudHMsIGFzayB0aGVtIHRvIHNldCB1cCB0aGVpciBkZWZhdWx0IHN0YXRlcyBhcyB3ZWxsLgorRm9yIGluc3RhbmNlLCBgZ2l0IGxvZ2AgdGFrZXMgYWR2YW50YWdlIG9mIGBncmVwYCBhbmQgYGRpZmZgIGZ1bmN0aW9uYWxpdHksIHNvCitpdHMgYGluaXRfbG9nX2RlZmF1bHRzKClgIHNldHMgaXRzIG93biBzdGF0ZSAoYGRlY29yYXRpb25fc3R5bGVgKSBhbmQgYXNrcworYGdyZXBgIGFuZCBgZGlmZmAgdG8gaW5pdGlhbGl6ZSB0aGVtc2VsdmVzIGJ5IGNhbGxpbmcgZWFjaCBvZiB0aGVpcgoraW5pdGlhbGl6YXRpb24gZnVuY3Rpb25zLgorCitGb3Igb3VyIGZpcnN0IGV4YW1wbGUgd2l0aGluIGBnaXQgd2Fsa2VuYCwgd2UgZG9uJ3QgaW50ZW5kIHRvIHVzZSBhbnkgb3RoZXIKK2NvbXBvbmVudHMgd2l0aGluIEdpdCwgYW5kIHdlIGRvbid0IGhhdmUgYW55IGNvbmZpZ3VyYXRpb24gdG8gZG8uICBIb3dldmVyLCB3ZQorbWF5IHdhbnQgdG8gYWRkIHNvbWUgbGF0ZXIsIHNvIGZvciBub3csIHdlIGNhbiBhZGQgYW4gZW1wdHkgcGxhY2Vob2xkZXIuIENyZWF0ZQorYSBuZXcgZnVuY3Rpb24gaW4gYGJ1aWx0aW4vd2Fsa2VuLmNgOgorCistLS0tCitzdGF0aWMgdm9pZCBpbml0X3dhbGtlbl9kZWZhdWx0cyh2b2lkKQoreworCS8qCisJICogV2UgZG9uJ3QgYWN0dWFsbHkgbmVlZCB0aGUgc2FtZSBjb21wb25lbnRzIGBnaXQgbG9nYCBkb2VzOyBsZWF2ZSB0aGlzCisJICogZW1wdHkgZm9yIG5vdy4KKwkgKi8KK30KKy0tLS0KKworTWFrZSBzdXJlIHRvIGFkZCBhIGxpbmUgaW52b2tpbmcgaXQgaW5zaWRlIG9mIGBjbWRfd2Fsa2VuKClgLgorCistLS0tCitpbnQgY21kX3dhbGtlbihpbnQgYXJnYywgY29uc3QgY2hhciAqKmFyZ3YsIGNvbnN0IGNoYXIgKnByZWZpeCkKK3sKKwlpbml0X3dhbGtlbl9kZWZhdWx0cygpOworfQorLS0tLQorCis9PT09IENvbmZpZ3VyaW5nIEZyb20gYC5naXRjb25maWdgCisKK05leHQsIHdlIHNob3VsZCBoYXZlIGEgbG9vayBhdCBhbnkgcmVsZXZhbnQgY29uZmlndXJhdGlvbiBzZXR0aW5ncyAoaS5lLiwKK3NldHRpbmdzIHJlYWRhYmxlIGFuZCBzZXR0YWJsZSBmcm9tIGBnaXQgY29uZmlnYCkuIFRoaXMgaXMgZG9uZSBieSBwcm92aWRpbmcgYQorY2FsbGJhY2sgdG8gYGdpdF9jb25maWcoKWA7IHdpdGhpbiB0aGF0IGNhbGxiYWNrLCB5b3UgY2FuIGFsc28gaW52b2tlIG1ldGhvZHMKK2Zyb20gb3RoZXIgY29tcG9uZW50cyB5b3UgbWF5IG5lZWQgdGhhdCBuZWVkIHRvIGludGVyY2VwdCB0aGVzZSBvcHRpb25zLiBZb3VyCitjYWxsYmFjayB3aWxsIGJlIGludm9rZWQgb25jZSBwZXIgZWFjaCBjb25maWd1cmF0aW9uIHZhbHVlIHdoaWNoIEdpdCBrbm93cyBhYm91dAorKGdsb2JhbCwgbG9jYWwsIHdvcmt0cmVlLCBldGMuKS4KKworU2ltaWxhcmx5IHRvIHRoZSBkZWZhdWx0IHZhbHVlcywgd2UgZG9uJ3QgaGF2ZSBhbnl0aGluZyB0byBkbyBoZXJlIHlldAorb3Vyc2VsdmVzOyBob3dldmVyLCB3ZSBzaG91bGQgY2FsbCBgZ2l0X2RlZmF1bHRfY29uZmlnKClgIGlmIHdlIGFyZW4ndCBjYWxsaW5nCithbnkgb3RoZXIgZXhpc3RpbmcgY29uZmlnIGNhbGxiYWNrcy4KKworQWRkIGEgbmV3IGZ1bmN0aW9uIHRvIGBidWlsdGluL3dhbGtlbi5jYDoKKworLS0tLQorc3RhdGljIGludCBnaXRfd2Fsa2VuX2NvbmZpZyhjb25zdCBjaGFyICp2YXIsIGNvbnN0IGNoYXIgKnZhbHVlLCB2b2lkICpjYikKK3sKKwkvKgorCSAqIEZvciBub3csIHdlIGRvbid0IGhhdmUgYW55IGN1c3RvbSBjb25maWd1cmF0aW9uLCBzbyBmYWxsIGJhY2sgdG8KKwkgKiB0aGUgZGVmYXVsdCBjb25maWcuCisJICovCisJcmV0dXJuIGdpdF9kZWZhdWx0X2NvbmZpZyh2YXIsIHZhbHVlLCBjYik7Cit9CistLS0tCisKK01ha2Ugc3VyZSB0byBpbnZva2UgYGdpdF9jb25maWcoKWAgd2l0aCBpdCBpbiB5b3VyIGBjbWRfd2Fsa2VuKClgOgorCistLS0tCitpbnQgY21kX3dhbGtlbihpbnQgYXJnYywgY29uc3QgY2hhciAqKmFyZ3YsIGNvbnN0IGNoYXIgKnByZWZpeCkKK3sKKwkuLi4KKworCWdpdF9jb25maWcoZ2l0X3dhbGtlbl9jb25maWcsIE5VTEwpOworCisJLi4uCit9CistLS0tCisKKz09PT0gU2V0dGluZyBVcCBgcmV2X2luZm9gCisKK05vdyB0aGF0IHdlJ3ZlIGdhdGhlcmVkIGV4dGVybmFsIGNvbmZpZ3VyYXRpb24gYW5kIG9wdGlvbnMsIGl0J3MgdGltZSB0bworaW5pdGlhbGl6ZSB0aGUgYHJldl9pbmZvYCBvYmplY3Qgd2hpY2ggd2Ugd2lsbCB1c2UgdG8gcGVyZm9ybSB0aGUgd2Fsay4gVGhpcyBpcwordHlwaWNhbGx5IGRvbmUgYnkgY2FsbGluZyBgcmVwb19pbml0X3JldmlzaW9ucygpYCB3aXRoIHRoZSByZXBvc2l0b3J5IHlvdSBpbnRlbmQKK3RvIHRhcmdldCwgYXMgd2VsbCBhcyB0aGUgYHByZWZpeGAgYXJndW1lbnQgb2YgYGNtZF93YWxrZW5gIGFuZCB5b3VyIGByZXZfaW5mb2AKK3N0cnVjdC4KKworQWRkIHRoZSBgc3RydWN0IHJldl9pbmZvYCBhbmQgdGhlIGByZXBvX2luaXRfcmV2aXNpb25zKClgIGNhbGw6CistLS0tCitpbnQgY21kX3dhbGtlbihpbnQgYXJnYywgY29uc3QgY2hhciAqKmFyZ3YsIGNvbnN0IGNoYXIgKnByZWZpeCkKK3sKKwkvKiBUaGlzIGNhbiBnbyB3aGVyZXZlciB5b3UgbGlrZSBpbiB5b3VyIGRlY2xhcmF0aW9ucy4qLworCXN0cnVjdCByZXZfaW5mbyByZXY7CisJLi4uCisKKwkvKiBUaGlzIHNob3VsZCBnbyBhZnRlciB0aGUgZ2l0X2NvbmZpZygpIGNhbGwuICovCisJcmVwb19pbml0X3JldmlzaW9ucyh0aGVfcmVwb3NpdG9yeSwgJnJldiwgcHJlZml4KTsKKworCS4uLgorfQorLS0tLQorCis9PT09IFR3ZWFraW5nIGByZXZfaW5mb2AgRm9yIHRoZSBXYWxrCisKK1dlJ3JlIGdldHRpbmcgY2xvc2UsIGJ1dCB3ZSdyZSBzdGlsbCBub3QgcXVpdGUgcmVhZHkgdG8gZ28uIE5vdyB0aGF0IGByZXZgIGlzCitpbml0aWFsaXplZCwgd2UgY2FuIG1vZGlmeSBpdCB0byBmaXQgb3VyIG5lZWRzLiBUaGlzIGlzIHVzdWFsbHkgZG9uZSB3aXRoaW4gYQoraGVscGVyIGZvciBjbGFyaXR5LCBzbyBsZXQncyBhZGQgb25lOgorCistLS0tCitzdGF0aWMgdm9pZCBmaW5hbF9yZXZfaW5mb19zZXR1cChzdHJ1Y3QgcmV2X2luZm8gKnJldikKK3sKKwkvKgorCSAqIFdlIHdhbnQgdG8gbWltaWMgdGhlIGFwcGVhcmFuY2Ugb2YgYGdpdCBsb2cgLS1vbmVsaW5lYCwgc28gbGV0J3MKKwkgKiBmb3JjZSBvbmVsaW5lIGZvcm1hdC4KKwkgKi8KKwlnZXRfY29tbWl0X2Zvcm1hdCgib25lbGluZSIsIHJldik7CisKKwkvKiBTdGFydCBvdXIgb2JqZWN0IHdhbGsgYXQgSEVBRC4gKi8KKwlhZGRfaGVhZF90b19wZW5kaW5nKHJldik7Cit9CistLS0tCisKK1tOT1RFXQorPT09PQorSW5zdGVhZCBvZiB1c2luZyB0aGUgc2hvcnRoYW5kIGBhZGRfaGVhZF90b19wZW5kaW5nKClgLCB5b3UgY291bGQgZG8KK3NvbWV0aGluZyBsaWtlIHRoaXM6CistLS0tCisJc3RydWN0IHNldHVwX3JldmlzaW9uX29wdCBvcHQ7CisKKwltZW1zZXQoJm9wdCwgMCwgc2l6ZW9mKG9wdCkpOworCW9wdC5kZWYgPSAiSEVBRCI7CisJb3B0LnJldmFyZ19vcHQgPSBSRVZBUkdfQ09NTUlUVElTSDsKKwlzZXR1cF9yZXZpc2lvbnMoYXJnYywgYXJndiwgcmV2LCAmb3B0KTsKKy0tLS0KK1VzaW5nIGEgYHNldHVwX3JldmlzaW9uX29wdGAgZ2l2ZXMgeW91IGZpbmVyIGNvbnRyb2wgb3ZlciB5b3VyIHdhbGsncyBzdGFydGluZworcG9pbnQuCis9PT09CisKK1RoZW4gbGV0J3MgaW52b2tlIGBmaW5hbF9yZXZfaW5mb19zZXR1cCgpYCBhZnRlciB0aGUgY2FsbCB0bworYHJlcG9faW5pdF9yZXZpc2lvbnMoKWA6CisKKy0tLS0KK2ludCBjbWRfd2Fsa2VuKGludCBhcmdjLCBjb25zdCBjaGFyICoqYXJndiwgY29uc3QgY2hhciAqcHJlZml4KQoreworCS4uLgorCisJZmluYWxfcmV2X2luZm9fc2V0dXAoJnJldik7CisKKwkuLi4KK30KKy0tLS0KKworTGF0ZXIsIHdlIG1heSB3aXNoIHRvIGFkZCBtb3JlIGFyZ3VtZW50cyB0byBgZmluYWxfcmV2X2luZm9fc2V0dXAoKWAuIEJ1dCBmb3IKK25vdywgdGhpcyBpcyBhbGwgd2UgbmVlZC4KKworPT09PSBQcmVwYXJpbmcgYHJldl9pbmZvYCBGb3IgdGhlIFdhbGsKKworTm93IHRoYXQgYHJldmAgaXMgYWxsIGluaXRpYWxpemVkIGFuZCBjb25maWd1cmVkLCB3ZSd2ZSBnb3Qgb25lIG1vcmUgc2V0dXAgc3RlcAorYmVmb3JlIHdlIGdldCByb2xsaW5nLiBXZSBjYW4gZG8gdGhpcyBpbiBhIGhlbHBlciwgd2hpY2ggd2lsbCBib3RoIHByZXBhcmUgdGhlCitgcmV2X2luZm9gIGZvciB0aGUgd2FsaywgYW5kIHBlcmZvcm0gdGhlIHdhbGsgaXRzZWxmLiBMZXQncyBzdGFydCB0aGUgaGVscGVyCit3aXRoIHRoZSBjYWxsIHRvIGBwcmVwYXJlX3JldmlzaW9uX3dhbGsoKWAsIHdoaWNoIGNhbiByZXR1cm4gYW4gZXJyb3Igd2l0aG91dAorZHlpbmcgb24gaXRzIG93bjoKKworLS0tLQorc3RhdGljIHZvaWQgd2Fsa2VuX2NvbW1pdF93YWxrKHN0cnVjdCByZXZfaW5mbyAqcmV2KQoreworCWlmIChwcmVwYXJlX3JldmlzaW9uX3dhbGsocmV2KSkKKwkJZGllKF8oInJldmlzaW9uIHdhbGsgc2V0dXAgZmFpbGVkIikpOworfQorLS0tLQorCitOT1RFOiBgZGllKClgIHByaW50cyB0byBgc3RkZXJyYCBhbmQgZXhpdHMgdGhlIHByb2dyYW0uIFNpbmNlIGl0IHdpbGwgcHJpbnQgdG8KK2BzdGRlcnJgIGl0J3MgbGlrZWx5IHRvIGJlIHNlZW4gYnkgYSBodW1hbiwgc28gd2Ugd2lsbCBsb2NhbGl6ZSBpdC4KKworPT09PSBQZXJmb3JtaW5nIHRoZSBXYWxrIQorCitGaW5hbGx5ISBXZSBhcmUgcmVhZHkgdG8gYmVnaW4gdGhlIHdhbGsgaXRzZWxmLiBOb3cgd2UgY2FuIHNlZSB0aGF0IGByZXZfaW5mb2AKK2NhbiBhbHNvIGJlIHVzZWQgYXMgYW4gaXRlcmF0b3I7IHdlIG1vdmUgdG8gdGhlIG5leHQgaXRlbSBpbiB0aGUgd2FsayBieSB1c2luZworYGdldF9yZXZpc2lvbigpYCByZXBlYXRlZGx5LiBBZGQgdGhlIGxpc3RlZCB2YXJpYWJsZSBkZWNsYXJhdGlvbnMgYXQgdGhlIHRvcCBhbmQKK3RoZSB3YWxrIGxvb3AgYmVsb3cgdGhlIGBwcmVwYXJlX3JldmlzaW9uX3dhbGsoKWAgY2FsbCB3aXRoaW4geW91cgorYHdhbGtlbl9jb21taXRfd2FsaygpYDoKKworLS0tLQorc3RhdGljIHZvaWQgd2Fsa2VuX2NvbW1pdF93YWxrKHN0cnVjdCByZXZfaW5mbyAqcmV2KQoreworCXN0cnVjdCBjb21taXQgKmNvbW1pdDsKKwlzdHJ1Y3Qgc3RyYnVmIHByZXR0eWJ1ZiA9IFNUUkJVRl9JTklUOworCisJLi4uCisKKwl3aGlsZSAoKGNvbW1pdCA9IGdldF9yZXZpc2lvbihyZXYpKSkgeworCQlpZiAoIWNvbW1pdCkKKwkJCWNvbnRpbnVlOworCisJCXN0cmJ1Zl9yZXNldCgmcHJldHR5YnVmKTsKKwkJcHBfY29tbWl0X2Vhc3koQ01JVF9GTVRfT05FTElORSwgY29tbWl0LCAmcHJldHR5YnVmKTsKKwkJcHV0cyhwcmV0dHlidWYuYnVmKTsKKwl9CisJc3RyYnVmX3JlbGVhc2UoJnByZXR0eWJ1Zik7Cit9CistLS0tCisKK05PVEU6IGBwdXRzKClgIHByaW50cyBhIGBjaGFyKmAgdG8gYHN0ZG91dGAuIFNpbmNlIHRoaXMgaXMgdGhlIHBhcnQgb2YgdGhlCitjb21tYW5kIHdlIGV4cGVjdCB0byBiZSBtYWNoaW5lLXBhcnNlZCwgd2UncmUgc2VuZGluZyBpdCBkaXJlY3RseSB0byBzdGRvdXQuCisKK0dpdmUgaXQgYSBzaG90LgorCistLS0tCiskIG1ha2UKKyQgLi9iaW4td3JhcHBlcnMvZ2l0IHdhbGtlbgorLS0tLQorCitZb3Ugc2hvdWxkIHNlZSBhbGwgb2YgdGhlIHN1YmplY3QgbGluZXMgb2YgYWxsIHRoZSBjb21taXRzIGluCit5b3VyIHRyZWUncyBoaXN0b3J5LCBpbiBvcmRlciwgZW5kaW5nIHdpdGggdGhlIGluaXRpYWwgY29tbWl0LCAiSW5pdGlhbCByZXZpc2lvbgorb2YgImdpdCIsIHRoZSBpbmZvcm1hdGlvbiBtYW5hZ2VyIGZyb20gaGVsbCIuIENvbmdyYXR1bGF0aW9ucyEgWW91J3ZlIHdyaXR0ZW4KK3lvdXIgZmlyc3QgcmV2aXNpb24gd2Fsay4gWW91IGNhbiBwbGF5IHdpdGggcHJpbnRpbmcgc29tZSBhZGRpdGlvbmFsIGZpZWxkcworZnJvbSBlYWNoIGNvbW1pdCBpZiB5b3UncmUgY3VyaW91czsgaGF2ZSBhIGxvb2sgYXQgdGhlIGZ1bmN0aW9ucyBhdmFpbGFibGUgaW4KK2Bjb21taXQuaGAuCisKKz09PSBBZGRpbmcgYSBGaWx0ZXIKKworTmV4dCwgbGV0J3MgdHJ5IHRvIGZpbHRlciB0aGUgY29tbWl0cyB3ZSBzZWUgYmFzZWQgb24gdGhlaXIgYXV0aG9yLiBUaGlzIGlzCitlcXVpdmFsZW50IHRvIHJ1bm5pbmcgYGdpdCBsb2cgLS1hdXRob3I9PHBhdHRlcm4+YC4gV2UgY2FuIGFkZCBhIGZpbHRlciBieQorbW9kaWZ5aW5nIGByZXZfaW5mby5ncmVwX2ZpbHRlcmAsIHdoaWNoIGlzIGEgYHN0cnVjdCBncmVwX29wdGAuCisKK0ZpcnN0IHNvbWUgc2V0dXAuIEFkZCBgaW5pdF9ncmVwX2RlZmF1bHRzKClgIHRvIGBpbml0X3dhbGtlbl9kZWZhdWx0cygpYCBhbmQgYWRkCitgZ3JlcF9jb25maWcoKWAgdG8gYGdpdF93YWxrZW5fY29uZmlnKClgOgorCistLS0tCitzdGF0aWMgdm9pZCBpbml0X3dhbGtlbl9kZWZhdWx0cyh2b2lkKQoreworCWluaXRfZ3JlcF9kZWZhdWx0cyh0aGVfcmVwb3NpdG9yeSk7Cit9CisKKy4uLgorCitzdGF0aWMgaW50IGdpdF93YWxrZW5fY29uZmlnKGNvbnN0IGNoYXIgKnZhciwgY29uc3QgY2hhciAqdmFsdWUsIHZvaWQgKmNiKQoreworCWdyZXBfY29uZmlnKHZhciwgdmFsdWUsIGNiKTsKKwlyZXR1cm4gZ2l0X2RlZmF1bHRfY29uZmlnKHZhciwgdmFsdWUsIGNiKTsKK30KKy0tLS0KKworTmV4dCwgd2UgY2FuIG1vZGlmeSB0aGUgYGdyZXBfZmlsdGVyYC4gVGhpcyBpcyBkb25lIHdpdGggY29udmVuaWVuY2UgZnVuY3Rpb25zCitmb3VuZCBpbiBgZ3JlcC5oYC4gRm9yIGZ1biwgd2UncmUgZmlsdGVyaW5nIHRvIG9ubHkgY29tbWl0cyBmcm9tIGZvbGtzIHVzaW5nIGEKK2BnbWFpbC5jb21gIGVtYWlsIGFkZHJlc3MgLSBhIG5vdC12ZXJ5LXByZWNpc2UgZ3Vlc3MgYXQgd2hvIG1heSBiZSB3b3JraW5nIG9uCitHaXQgYXMgYSBob2JieS4gU2luY2Ugd2UncmUgY2hlY2tpbmcgdGhlIGF1dGhvciwgd2hpY2ggaXMgYSBzcGVjaWZpYyBsaW5lIGluIHRoZQoraGVhZGVyLCB3ZSdsbCB1c2UgdGhlIGBhcHBlbmRfaGVhZGVyX2dyZXBfcGF0dGVybigpYCBoZWxwZXIuIFdlIGNhbiB1c2UKK3RoZSBgZW51bSBncmVwX2hlYWRlcl9maWVsZGAgdG8gaW5kaWNhdGUgd2hpY2ggcGFydCBvZiB0aGUgY29tbWl0IGhlYWRlciB3ZSB3YW50Cit0byBzZWFyY2guCisKK0luIGBmaW5hbF9yZXZfaW5mb19zZXR1cCgpYCwgYWRkIHlvdXIgZmlsdGVyIGxpbmU6CisKKy0tLS0KK3N0YXRpYyB2b2lkIGZpbmFsX3Jldl9pbmZvX3NldHVwKGludCBhcmdjLCBjb25zdCBjaGFyICoqYXJndiwKKwkJY29uc3QgY2hhciAqcHJlZml4LCBzdHJ1Y3QgcmV2X2luZm8gKnJldikKK3sKKwkuLi4KKworCWFwcGVuZF9oZWFkZXJfZ3JlcF9wYXR0ZXJuKCZyZXYtPmdyZXBfZmlsdGVyLCBHUkVQX0hFQURFUl9BVVRIT1IsCisJCSJnbWFpbCIpOworCWNvbXBpbGVfZ3JlcF9wYXR0ZXJucygmcmV2LT5ncmVwX2ZpbHRlcik7CisKKwkuLi4KK30KKy0tLS0KKworYGFwcGVuZF9oZWFkZXJfZ3JlcF9wYXR0ZXJuKClgIGFkZHMgeW91ciBuZXcgImdtYWlsIiBwYXR0ZXJuIHRvIGByZXZfaW5mb2AsIGJ1dAoraXQgd29uJ3Qgd29yayB1bmxlc3Mgd2UgY29tcGlsZSBpdCB3aXRoIGBjb21waWxlX2dyZXBfcGF0dGVybnMoKWAuCisKK05PVEU6IElmIHlvdSBhcmUgdXNpbmcgYHNldHVwX3JldmlzaW9ucygpYCAoZm9yIGV4YW1wbGUsIGlmIHlvdSBhcmUgcGFzc2luZyBhCitgc2V0dXBfcmV2aXNpb25fb3B0YCBpbnN0ZWFkIG9mIHVzaW5nIGBhZGRfaGVhZF90b19wZW5kaW5nKClgKSwgeW91IGRvbid0IG5lZWQKK3RvIGNhbGwgYGNvbXBpbGVfZ3JlcF9wYXR0ZXJucygpYCBiZWNhdXNlIGBzZXR1cF9yZXZpc2lvbnMoKWAgY2FsbHMgaXQgZm9yIHlvdS4KKworTk9URTogV2UgY291bGQgYWRkIHRoZSBzYW1lIGZpbHRlciB2aWEgdGhlIGBhcHBlbmRfZ3JlcF9wYXR0ZXJuKClgIGhlbHBlciBpZiB3ZQord2FudGVkIHRvLCBidXQgYGFwcGVuZF9oZWFkZXJfZ3JlcF9wYXR0ZXJuKClgIGFkZHMgdGhlIGBlbnVtIGdyZXBfY29udGV4dGAgYW5kCitgZW51bSBncmVwX3BhdF90b2tlbmAgZm9yIHVzLgorCis9PT0gQ2hhbmdpbmcgdGhlIE9yZGVyCisKK1RoZXJlIGFyZSBhIGZldyB3YXlzIHRoYXQgd2UgY2FuIGNoYW5nZSB0aGUgb3JkZXIgb2YgdGhlIGNvbW1pdHMgZHVyaW5nIGEKK3JldmlzaW9uIHdhbGsuIEZpcnN0bHksIHdlIGNhbiB1c2UgdGhlIGBlbnVtIHJldl9zb3J0X29yZGVyYCB0byBjaG9vc2UgZnJvbSBzb21lCit0eXBpY2FsIG9yZGVyaW5ncy4KKworYHRvcG9fb3JkZXJgIGlzIHRoZSBzYW1lIGFzIGBnaXQgbG9nIC0tdG9wby1vcmRlcmA6IHdlIGF2b2lkIHNob3dpbmcgYSBwYXJlbnQKK2JlZm9yZSBhbGwgb2YgaXRzIGNoaWxkcmVuIGhhdmUgYmVlbiBzaG93biwgYW5kIHdlIGF2b2lkIG1peGluZyBjb21taXRzIHdoaWNoCithcmUgaW4gZGlmZmVyZW50IGxpbmVzIG9mIGhpc3RvcnkuIChgZ2l0IGhlbHAgbG9nYCdzIHNlY3Rpb24gb24gYC0tdG9wby1vcmRlcmAKK2hhcyBhIHZlcnkgbmljZSBkaWFncmFtIHRvIGlsbHVzdHJhdGUgdGhpcy4pCisKK0xldCdzIHNlZSB3aGF0IGhhcHBlbnMgd2hlbiB3ZSBydW4gd2l0aCBgUkVWX1NPUlRfQllfQ09NTUlUX0RBVEVgIGFzIG9wcG9zZWQgdG8KK2BSRVZfU09SVF9CWV9BVVRIT1JfREFURWAuIEFkZCB0aGUgZm9sbG93aW5nOgorCistLS0tCitzdGF0aWMgdm9pZCBmaW5hbF9yZXZfaW5mb19zZXR1cChpbnQgYXJnYywgY29uc3QgY2hhciAqKmFyZ3YsCisJCWNvbnN0IGNoYXIgKnByZWZpeCwgc3RydWN0IHJldl9pbmZvICpyZXYpCit7CisJLi4uCisKKwlyZXYtPnRvcG9fb3JkZXIgPSAxOworCXJldi0+c29ydF9vcmRlciA9IFJFVl9TT1JUX0JZX0NPTU1JVF9EQVRFOworCisJLi4uCit9CistLS0tCisKK0xldCdzIG91dHB1dCB0aGlzIGludG8gYSBmaWxlIHNvIHdlIGNhbiBlYXNpbHkgZGlmZiBpdCB3aXRoIHRoZSB3YWxrIHNvcnRlZCBieQorYXV0aG9yIGRhdGUuCisKKy0tLS0KKyQgbWFrZQorJCAuL2Jpbi13cmFwcGVycy9naXQgd2Fsa2VuID4gY29tbWl0LWRhdGUudHh0CistLS0tCisKK1RoZW4sIGxldCdzIHNvcnQgYnkgYXV0aG9yIGRhdGUgYW5kIHJ1biBpdCBhZ2Fpbi4KKworLS0tLQorc3RhdGljIHZvaWQgZmluYWxfcmV2X2luZm9fc2V0dXAoaW50IGFyZ2MsIGNvbnN0IGNoYXIgKiphcmd2LAorCQljb25zdCBjaGFyICpwcmVmaXgsIHN0cnVjdCByZXZfaW5mbyAqcmV2KQoreworCS4uLgorCisJcmV2LT50b3BvX29yZGVyID0gMTsKKwlyZXYtPnNvcnRfb3JkZXIgPSBSRVZfU09SVF9CWV9BVVRIT1JfREFURTsKKworCS4uLgorfQorLS0tLQorCistLS0tCiskIG1ha2UKKyQgLi9iaW4td3JhcHBlcnMvZ2l0IHdhbGtlbiA+IGF1dGhvci1kYXRlLnR4dAorLS0tLQorCitGaW5hbGx5LCBjb21wYXJlIHRoZSB0d28uIFRoaXMgaXMgYSBsaXR0bGUgbGVzcyBoZWxwZnVsIHdpdGhvdXQgb2JqZWN0IG5hbWVzIG9yCitkYXRlcywgYnV0IGhvcGVmdWxseSB3ZSBnZXQgdGhlIGlkZWEuCisKKy0tLS0KKyQgZGlmZiAtdSBjb21taXQtZGF0ZS50eHQgYXV0aG9yLWRhdGUudHh0CistLS0tCisKK1RoaXMgZGlzcGxheSBpbmRpY2F0ZXMgdGhhdCBjb21taXRzIGNhbiBiZSByZW9yZGVyZWQgYWZ0ZXIgdGhleSdyZSB3cml0dGVuLCBmb3IKK2V4YW1wbGUgd2l0aCBgZ2l0IHJlYmFzZWAuCisKK0xldCdzIHRyeSBvbmUgbW9yZSByZW9yZGVyaW5nIG9mIGNvbW1pdHMuIGByZXZfaW5mb2AgZXhwb3NlcyBhIGByZXZlcnNlYCBmbGFnLgorU2V0IHRoYXQgZmxhZyBzb21ld2hlcmUgaW5zaWRlIG9mIGBmaW5hbF9yZXZfaW5mb19zZXR1cCgpYDoKKworLS0tLQorc3RhdGljIHZvaWQgZmluYWxfcmV2X2luZm9fc2V0dXAoaW50IGFyZ2MsIGNvbnN0IGNoYXIgKiphcmd2LCBjb25zdCBjaGFyICpwcmVmaXgsCisJCXN0cnVjdCByZXZfaW5mbyAqcmV2KQoreworCS4uLgorCisJcmV2LT5yZXZlcnNlID0gMTsKKworCS4uLgorfQorLS0tLQorCitSdW4geW91ciB3YWxrIGFnYWluIGFuZCBub3RlIHRoZSBkaWZmZXJlbmNlIGluIG9yZGVyLiAoSWYgeW91IHJlbW92ZSB0aGUgZ3JlcAorcGF0dGVybiwgeW91IHNob3VsZCBzZWUgdGhlIGxhc3QgY29tbWl0IHRoaXMgY2FsbCBnaXZlcyB5b3UgYXMgeW91ciBjdXJyZW50CitIRUFELikKKworPT0gQmFzaWMgT2JqZWN0IFdhbGsKKworU28gZmFyIHdlJ3ZlIGJlZW4gd2Fsa2luZyBvbmx5IGNvbW1pdHMuIEJ1dCBHaXQgaGFzIG1vcmUgdHlwZXMgb2Ygb2JqZWN0cyB0aGFuCit0aGF0ISBMZXQncyBzZWUgaWYgd2UgY2FuIHdhbGsgX2FsbF8gb2JqZWN0cywgYW5kIGZpbmQgb3V0IHNvbWUgaW5mb3JtYXRpb24KK2Fib3V0IGVhY2ggb25lLgorCitXZSBjYW4gYmFzZSBvdXIgd29yayBvbiBhbiBleGFtcGxlLiBgZ2l0IHBhY2stb2JqZWN0c2AgcHJlcGFyZXMgYWxsIGtpbmRzIG9mCitvYmplY3RzIGZvciBwYWNraW5nIGludG8gYSBiaXRtYXAgb3IgcGFja2ZpbGUuIFRoZSB3b3JrIHdlIGFyZSBpbnRlcmVzdGVkIGluCityZXNpZGVzIGluIGBidWlsdGlucy9wYWNrLW9iamVjdHMuYzpnZXRfb2JqZWN0X2xpc3QoKWA7IGV4YW1pbmF0aW9uIG9mIHRoYXQKK2Z1bmN0aW9uIHNob3dzIHRoYXQgdGhlIGFsbC1vYmplY3Qgd2FsayBpcyBiZWluZyBwZXJmb3JtZWQgYnkKK2B0cmF2ZXJzZV9jb21taXRfbGlzdCgpYCBvciBgdHJhdmVyc2VfY29tbWl0X2xpc3RfZmlsdGVyZWQoKWAuIFRob3NlIHR3bworZnVuY3Rpb25zIHJlc2lkZSBpbiBgbGlzdC1vYmplY3RzLmNgOyBleGFtaW5pbmcgdGhlIHNvdXJjZSBzaG93cyB0aGF0LCBkZXNwaXRlCit0aGUgbmFtZSwgdGhlc2UgZnVuY3Rpb25zIHRyYXZlcnNlIGFsbCBraW5kcyBvZiBvYmplY3RzLiBMZXQncyBoYXZlIGEgbG9vayBhdAordGhlIGFyZ3VtZW50cyB0byBgdHJhdmVyc2VfY29tbWl0X2xpc3RfZmlsdGVyZWQoKWAsIHdoaWNoIGFyZSBhIHN1cGVyc2V0IG9mIHRoZQorYXJndW1lbnRzIHRvIHRoZSB1bmZpbHRlcmVkIHZlcnNpb24uCisKKy0gYHN0cnVjdCBsaXN0X29iamVjdHNfZmlsdGVyX29wdGlvbnMgKmZpbHRlcl9vcHRpb25zYDogVGhpcyBpcyBhIHN0cnVjdCB3aGljaAorICBzdG9yZXMgYSBmaWx0ZXItc3BlYyBhcyBvdXRsaW5lZCBpbiBgRG9jdW1lbnRhdGlvbi9yZXYtbGlzdC1vcHRpb25zLnR4dGAuCistIGBzdHJ1Y3QgcmV2X2luZm8gKnJldnNgOiBUaGlzIGlzIHRoZSBgcmV2X2luZm9gIHVzZWQgZm9yIHRoZSB3YWxrLgorLSBgc2hvd19jb21taXRfZm4gc2hvd19jb21taXRgOiBBIGNhbGxiYWNrIHdoaWNoIHdpbGwgYmUgdXNlZCB0byBoYW5kbGUgZWFjaAorICBpbmRpdmlkdWFsIGNvbW1pdCBvYmplY3QuCistIGBzaG93X29iamVjdF9mbiBzaG93X29iamVjdGA6IEEgY2FsbGJhY2sgd2hpY2ggd2lsbCBiZSB1c2VkIHRvIGhhbmRsZSBlYWNoCisgIG5vbi1jb21taXQgb2JqZWN0IChzbyBlYWNoIGJsb2IsIHRyZWUsIG9yIHRhZykuCistIGB2b2lkICpzaG93X2RhdGFgOiBBIGNvbnRleHQgYnVmZmVyIHdoaWNoIGlzIHBhc3NlZCBpbiB0dXJuIHRvIGBzaG93X2NvbW1pdGAKKyAgYW5kIGBzaG93X29iamVjdGAuCistIGBzdHJ1Y3Qgb2lkc2V0ICpvbWl0dGVkYDogQSBsaW5rZWQtbGlzdCBvZiBvYmplY3QgSURzIHdoaWNoIHRoZSBwcm92aWRlZAorICBmaWx0ZXIgY2F1c2VkIHRvIGJlIG9taXR0ZWQuCisKK0l0IGxvb2tzIGxpa2UgdGhpcyBgdHJhdmVyc2VfY29tbWl0X2xpc3RfZmlsdGVyZWQoKWAgdXNlcyBjYWxsYmFja3Mgd2UgcHJvdmlkZQoraW5zdGVhZCBvZiBuZWVkaW5nIHVzIHRvIGNhbGwgaXQgcmVwZWF0ZWRseSBvdXJzZWx2ZXMuIENvb2whIExldCdzIGFkZCB0aGUKK2NhbGxiYWNrcyBmaXJzdC4KKworRm9yIHRoZSBzYWtlIG9mIHRoaXMgdHV0b3JpYWwsIHdlJ2xsIHNpbXBseSBrZWVwIHRyYWNrIG9mIGhvdyBtYW55IG9mIGVhY2gga2luZAorb2Ygb2JqZWN0IHdlIGZpbmQuIEF0IGZpbGUgc2NvcGUgaW4gYGJ1aWx0aW4vd2Fsa2VuLmNgIGFkZCB0aGUgZm9sbG93aW5nCit0cmFja2luZyB2YXJpYWJsZXM6CisKKy0tLS0KK3N0YXRpYyBpbnQgY29tbWl0X2NvdW50Oworc3RhdGljIGludCB0YWdfY291bnQ7CitzdGF0aWMgaW50IGJsb2JfY291bnQ7CitzdGF0aWMgaW50IHRyZWVfY291bnQ7CistLS0tCisKK0NvbW1pdHMgYXJlIGhhbmRsZWQgYnkgYSBkaWZmZXJlbnQgY2FsbGJhY2sgdGhhbiBvdGhlciBvYmplY3RzOyBsZXQncyBkbyB0aGF0CitvbmUgZmlyc3Q6CisKKy0tLS0KK3N0YXRpYyB2b2lkIHdhbGtlbl9zaG93X2NvbW1pdChzdHJ1Y3QgY29tbWl0ICpjbXQsIHZvaWQgKmJ1ZikKK3sKKwljb21taXRfY291bnQrKzsKK30KKy0tLS0KKworVGhlIGBjbXRgIGFyZ3VtZW50IGlzIGZhaXJseSBzZWxmLWV4cGxhbmF0b3J5LiBCdXQgaXQncyB3b3J0aCBtZW50aW9uaW5nIHRoYXQKK3RoZSBgYnVmYCBhcmd1bWVudCBpcyBhY3R1YWxseSB0aGUgY29udGV4dCBidWZmZXIgdGhhdCB3ZSBjYW4gcHJvdmlkZSB0byB0aGUKK3RyYXZlcnNhbCBjYWxscyAtIGBzaG93X2RhdGFgLCB3aGljaCB3ZSBtZW50aW9uZWQgYSBtb21lbnQgYWdvLgorCitTaW5jZSB3ZSBoYXZlIHRoZSBgc3RydWN0IGNvbW1pdGAgb2JqZWN0LCB3ZSBjYW4gbG9vayBhdCBhbGwgdGhlIHNhbWUgcGFydHMgdGhhdAord2UgbG9va2VkIGF0IGluIG91ciBlYXJsaWVyIGNvbW1pdC1vbmx5IHdhbGsuIEZvciB0aGUgc2FrZSBvZiB0aGlzIHR1dG9yaWFsLAordGhvdWdoLCB3ZSdsbCBqdXN0IGluY3JlbWVudCB0aGUgY29tbWl0IGNvdW50ZXIgYW5kIG1vdmUgb24uCisKK1RoZSBjYWxsYmFjayBmb3Igbm9uLWNvbW1pdHMgaXMgYSBsaXR0bGUgZGlmZmVyZW50LCBhcyB3ZSdsbCBuZWVkIHRvIGNoZWNrCit3aGljaCBraW5kIG9mIG9iamVjdCB3ZSdyZSBkZWFsaW5nIHdpdGg6CisKKy0tLS0KK3N0YXRpYyB2b2lkIHdhbGtlbl9zaG93X29iamVjdChzdHJ1Y3Qgb2JqZWN0ICpvYmosIGNvbnN0IGNoYXIgKnN0ciwgdm9pZCAqYnVmKQoreworCXN3aXRjaCAob2JqLT50eXBlKSB7CisJY2FzZSBPQkpfVFJFRToKKwkJdHJlZV9jb3VudCsrOworCQlicmVhazsKKwljYXNlIE9CSl9CTE9COgorCQlibG9iX2NvdW50Kys7CisJCWJyZWFrOworCWNhc2UgT0JKX1RBRzoKKwkJdGFnX2NvdW50Kys7CisJCWJyZWFrOworCWNhc2UgT0JKX0NPTU1JVDoKKwkJQlVHKCJ1bmV4cGVjdGVkIGNvbW1pdCBvYmplY3QgaW4gd2Fsa2VuX3Nob3dfb2JqZWN0XG4iKTsKKwlkZWZhdWx0OgorCQlCVUcoInVuZXhwZWN0ZWQgb2JqZWN0IHR5cGUgJXMgaW4gd2Fsa2VuX3Nob3dfb2JqZWN0XG4iLAorCQkJdHlwZV9uYW1lKG9iai0+dHlwZSkpOworCX0KK30KKy0tLS0KKworQWdhaW4sIGBvYmpgIGlzIGZhaXJseSBzZWxmLWV4cGxhbmF0b3J5LCBhbmQgd2UgY2FuIGd1ZXNzIHRoYXQgYGJ1ZmAgaXMgdGhlIHNhbWUKK2NvbnRleHQgcG9pbnRlciB0aGF0IGB3YWxrZW5fc2hvd19jb21taXQoKWAgcmVjZWl2ZXM6IHRoZSBgc2hvd19kYXRhYCBhcmd1bWVudAordG8gYHRyYXZlcnNlX2NvbW1pdF9saXN0KClgIGFuZCBgdHJhdmVyc2VfY29tbWl0X2xpc3RfZmlsdGVyZWQoKWAuIEZpbmFsbHksCitgc3RyYCBjb250YWlucyB0aGUgbmFtZSBvZiB0aGUgb2JqZWN0LCB3aGljaCBlbmRzIHVwIGJlaW5nIHNvbWV0aGluZyBsaWtlCitgZm9vLnR4dGAgKGJsb2IpLCBgYmFyL2JhemAgKHRyZWUpLCBvciBgdjEuMi4zYCAodGFnKS4KKworVG8gaGVscCBhc3N1cmUgdXMgdGhhdCB3ZSBhcmVuJ3QgZG91YmxlLWNvdW50aW5nIGNvbW1pdHMsIHdlJ2xsIGluY2x1ZGUgc29tZQorY29tcGxhaW5pbmcgaWYgYSBjb21taXQgb2JqZWN0IGlzIHJvdXRlZCB0aHJvdWdoIG91ciBub24tY29tbWl0IGNhbGxiYWNrOyB3ZSdsbAorYWxzbyBjb21wbGFpbiBpZiB3ZSBzZWUgYW4gaW52YWxpZCBvYmplY3QgdHlwZS4gU2luY2UgdGhvc2UgdHdvIGNhc2VzIHNob3VsZCBiZQordW5yZWFjaGFibGUsIGFuZCB3b3VsZCBvbmx5IGNoYW5nZSBpbiB0aGUgZXZlbnQgb2YgYSBzZW1hbnRpYyBjaGFuZ2UgdG8gdGhlIEdpdAorY29kZWJhc2UsIHdlIGNvbXBsYWluIGJ5IHVzaW5nIGBCVUcoKWAgLSB3aGljaCBpcyBhIHNpZ25hbCB0byBhIGRldmVsb3BlciB0aGF0Cit0aGUgY2hhbmdlIHRoZXkgbWFkZSBjYXVzZWQgdW5pbnRlbmRlZCBjb25zZXF1ZW5jZXMsIGFuZCB0aGUgcmVzdCBvZiB0aGUKK2NvZGViYXNlIG5lZWRzIHRvIGJlIHVwZGF0ZWQgdG8gdW5kZXJzdGFuZCB0aGF0IGNoYW5nZS4gYEJVRygpYCBpcyBub3QgaW50ZW5kZWQKK3RvIGJlIHNlZW4gYnkgdGhlIHB1YmxpYywgc28gaXQgaXMgbm90IGxvY2FsaXplZC4KKworT3VyIG1haW4gb2JqZWN0IHdhbGsgaW1wbGVtZW50YXRpb24gaXMgc3Vic3RhbnRpYWxseSBkaWZmZXJlbnQgZnJvbSBvdXIgY29tbWl0Cit3YWxrIGltcGxlbWVudGF0aW9uLCBzbyBsZXQncyBtYWtlIGEgbmV3IGZ1bmN0aW9uIHRvIHBlcmZvcm0gdGhlIG9iamVjdCB3YWxrLiBXZQorY2FuIHBlcmZvcm0gc2V0dXAgd2hpY2ggaXMgYXBwbGljYWJsZSB0byBhbGwgb2JqZWN0cyBoZXJlLCB0b28sIHRvIGtlZXAgc2VwYXJhdGUKK2Zyb20gc2V0dXAgd2hpY2ggaXMgYXBwbGljYWJsZSB0byBjb21taXQtb25seSB3YWxrcy4KKworV2UnbGwgc3RhcnQgYnkgZW5hYmxpbmcgYWxsIHR5cGVzIG9mIG9iamVjdHMgaW4gdGhlIGBzdHJ1Y3QgcmV2X2luZm9gLiAgV2UnbGwKK2Fsc28gdHVybiBvbiBgdHJlZV9ibG9ic19pbl9jb21taXRfb3JkZXJgLCB3aGljaCBtZWFucyB0aGF0IHdlIHdpbGwgd2FsayBhCitjb21taXQncyB0cmVlIGFuZCBldmVyeXRoaW5nIGl0IHBvaW50cyB0byBpbW1lZGlhdGVseSBhZnRlciB3ZSBmaW5kIGVhY2ggY29tbWl0LAorYXMgb3Bwb3NlZCB0byB3YWl0aW5nIGZvciB0aGUgZW5kIGFuZCB3YWxraW5nIHRocm91Z2ggYWxsIHRyZWVzIGFmdGVyIHRoZSBjb21taXQKK2hpc3RvcnkgaGFzIGJlZW4gZGlzY292ZXJlZC4gV2l0aCB0aGUgYXBwcm9wcmlhdGUgc2V0dGluZ3MgY29uZmlndXJlZCwgd2UgYXJlCityZWFkeSB0byBjYWxsIGBwcmVwYXJlX3JldmlzaW9uX3dhbGsoKWAuCisKKy0tLS0KK3N0YXRpYyB2b2lkIHdhbGtlbl9vYmplY3Rfd2FsayhzdHJ1Y3QgcmV2X2luZm8gKnJldikKK3sKKwlyZXYtPnRyZWVfb2JqZWN0cyA9IDE7CisJcmV2LT5ibG9iX29iamVjdHMgPSAxOworCXJldi0+dGFnX29iamVjdHMgPSAxOworCXJldi0+dHJlZV9ibG9ic19pbl9jb21taXRfb3JkZXIgPSAxOworCisJaWYgKHByZXBhcmVfcmV2aXNpb25fd2FsayhyZXYpKQorCQlkaWUoXygicmV2aXNpb24gd2FsayBzZXR1cCBmYWlsZWQiKSk7CisKKwljb21taXRfY291bnQgPSAwOworCXRhZ19jb3VudCA9IDA7CisJYmxvYl9jb3VudCA9IDA7CisJdHJlZV9jb3VudCA9IDA7CistLS0tCisKK0xldCdzIHN0YXJ0IGJ5IGNhbGxpbmcganVzdCB0aGUgdW5maWx0ZXJlZCB3YWxrIGFuZCByZXBvcnRpbmcgb3VyIGNvdW50cy4KK0NvbXBsZXRlIHlvdXIgaW1wbGVtZW50YXRpb24gb2YgYHdhbGtlbl9vYmplY3Rfd2FsaygpYDoKKworLS0tLQorCXRyYXZlcnNlX2NvbW1pdF9saXN0KHJldiwgd2Fsa2VuX3Nob3dfY29tbWl0LCB3YWxrZW5fc2hvd19vYmplY3QsIE5VTEwpOworCisJcHJpbnRmKCJjb21taXRzICVkXG5ibG9icyAlZFxudGFncyAlZFxudHJlZXMgJWRcbiIsIGNvbW1pdF9jb3VudCwKKwkJYmxvYl9jb3VudCwgdGFnX2NvdW50LCB0cmVlX2NvdW50KTsKK30KKy0tLS0KKworTk9URTogVGhpcyBvdXRwdXQgaXMgaW50ZW5kZWQgdG8gYmUgbWFjaGluZS1wYXJzZWQuIFRoZXJlZm9yZSwgd2UgYXJlIG5vdAorc2VuZGluZyBpdCB0byBgdHJhY2VfcHJpbnRmKClgLCBhbmQgd2UgYXJlIG5vdCBsb2NhbGl6aW5nIGl0IC0gd2UgbmVlZCBzY3JpcHRzCit0byBiZSBhYmxlIHRvIGNvdW50IG9uIHRoZSBmb3JtYXR0aW5nIHRvIGJlIGV4YWN0bHkgdGhlIHdheSBpdCBpcyBzaG93biBoZXJlLgorSWYgd2Ugd2VyZSBpbnRlbmRpbmcgdGhpcyBvdXRwdXQgdG8gYmUgcmVhZCBieSBodW1hbnMsIHdlIHdvdWxkIG5lZWQgdG8gbG9jYWxpemUKK2l0IHdpdGggYF8oKWAuCisKK0ZpbmFsbHksIHdlJ2xsIGFzayBgY21kX3dhbGtlbigpYCB0byB1c2UgdGhlIG9iamVjdCB3YWxrIGluc3RlYWQuIERpc2N1c3NpbmcKK2NvbW1hbmQgbGluZSBvcHRpb25zIGlzIG91dCBvZiBzY29wZSBmb3IgdGhpcyB0dXRvcmlhbCwgc28gd2UnbGwganVzdCBoYXJkY29kZQorYSBicmFuY2ggd2UgY2FuIGNoYW5nZSBhdCBjb21waWxlIHRpbWUuIFdoZXJlIHlvdSBjYWxsIGBmaW5hbF9yZXZfaW5mb19zZXR1cCgpYAorYW5kIGB3YWxrZW5fY29tbWl0X3dhbGsoKWAsIGluc3RlYWQgYnJhbmNoIGxpa2Ugc286CisKKy0tLS0KKwlpZiAoMSkgeworCQlhZGRfaGVhZF90b19wZW5kaW5nKCZyZXYpOworCQl3YWxrZW5fb2JqZWN0X3dhbGsoJnJldik7CisJfSBlbHNlIHsKKwkJZmluYWxfcmV2X2luZm9fc2V0dXAoYXJnYywgYXJndiwgcHJlZml4LCAmcmV2KTsKKwkJd2Fsa2VuX2NvbW1pdF93YWxrKCZyZXYpOworCX0KKy0tLS0KKworTk9URTogRm9yIHNpbXBsaWNpdHksIHdlJ3ZlIGF2b2lkZWQgYWxsIHRoZSBmaWx0ZXJzIGFuZCBzb3J0cyB3ZSBhcHBsaWVkIGluCitgZmluYWxfcmV2X2luZm9fc2V0dXAoKWAgYW5kIHNpbXBseSBhZGRlZCBgSEVBRGAgdG8gb3VyIHBlbmRpbmcgcXVldWUuIElmIHlvdQord2FudCwgeW91IGNhbiBjZXJ0YWlubHkgdXNlIHRoZSBmaWx0ZXJzIHdlIGFkZGVkIGJlZm9yZSBieSBtb3ZpbmcKK2BmaW5hbF9yZXZfaW5mb19zZXR1cCgpYCBvdXQgb2YgdGhlIGNvbmRpdGlvbmFsIGFuZCByZW1vdmluZyB0aGUgY2FsbCB0bworYGFkZF9oZWFkX3RvX3BlbmRpbmcoKWAuCisKK05vdyB3ZSBjYW4gdHJ5IHRvIHJ1biBvdXIgY29tbWFuZCEgSXQgc2hvdWxkIHRha2Ugbm90aWNlYWJseSBsb25nZXIgdGhhbiB0aGUKK2NvbW1pdCB3YWxrLCBidXQgYW4gZXhhbWluYXRpb24gb2YgdGhlIG91dHB1dCB3aWxsIGdpdmUgeW91IGFuIGlkZWEgd2h5LiBZb3VyCitvdXRwdXQgc2hvdWxkIGxvb2sgc2ltaWxhciB0byB0aGlzIGV4YW1wbGUsIGJ1dCB3aXRoIGRpZmZlcmVudCBjb3VudHM6CisKKy0tLS0KK09iamVjdCB3YWxrIGNvbXBsZXRlZC4gRm91bmQgNTU3MzMgY29tbWl0cywgMTAwMjc0IGJsb2JzLCAwIHRhZ3MsIGFuZCAxMDQyMTAgdHJlZXMuCistLS0tCisKK1RoaXMgbWFrZXMgc2Vuc2UuIFdlIGhhdmUgbW9yZSB0cmVlcyB0aGFuIGNvbW1pdHMgYmVjYXVzZSB0aGUgR2l0IHByb2plY3QgaGFzCitsb3RzIG9mIHN1YmRpcmVjdG9yaWVzIHdoaWNoIGNhbiBjaGFuZ2UsIHBsdXMgYXQgbGVhc3Qgb25lIHRyZWUgcGVyIGNvbW1pdC4gV2UKK2hhdmUgbm8gdGFncyBiZWNhdXNlIHdlIHN0YXJ0ZWQgb24gYSBjb21taXQgKGBIRUFEYCkgYW5kIHdoaWxlIHRhZ3MgY2FuIHBvaW50IHRvCitjb21taXRzLCBjb21taXRzIGNhbid0IHBvaW50IHRvIHRhZ3MuCisKK05PVEU6IFlvdSB3aWxsIGhhdmUgZGlmZmVyZW50IGNvdW50cyB3aGVuIHlvdSBydW4gdGhpcyB5b3Vyc2VsZiEgVGhlIG51bWJlciBvZgorb2JqZWN0cyBncm93cyBhbG9uZyB3aXRoIHRoZSBHaXQgcHJvamVjdC4KKworPT09IEFkZGluZyBhIEZpbHRlcgorCitUaGVyZSBhcmUgYSBoYW5kZnVsIG9mIGZpbHRlcnMgdGhhdCB3ZSBjYW4gYXBwbHkgdG8gdGhlIG9iamVjdCB3YWxrIGxhaWQgb3V0IGluCitgRG9jdW1lbnRhdGlvbi9yZXYtbGlzdC1vcHRpb25zLnR4dGAuIFRoZXNlIGZpbHRlcnMgYXJlIHR5cGljYWxseSB1c2VmdWwgZm9yCitvcGVyYXRpb25zIHN1Y2ggYXMgY3JlYXRpbmcgcGFja2ZpbGVzIG9yIHBlcmZvcm1pbmcgYSBwYXJ0aWFsIGNsb25lLiBUaGV5IGFyZQorZGVmaW5lZCBpbiBgbGlzdC1vYmplY3RzLWZpbHRlci1vcHRpb25zLmhgLiBGb3IgdGhlIHB1cnBvc2VzIG9mIHRoaXMgdHV0b3JpYWwgd2UKK3dpbGwgdXNlIHRoZSAidHJlZToxIiBmaWx0ZXIsIHdoaWNoIGNhdXNlcyB0aGUgd2FsayB0byBvbWl0IGFsbCB0cmVlcyBhbmQgYmxvYnMKK3doaWNoIGFyZSBub3QgZGlyZWN0bHkgcmVmZXJlbmNlZCBieSBjb21taXRzIHJlYWNoYWJsZSBmcm9tIHRoZSBjb21taXQgaW4KK2BwZW5kaW5nYCB3aGVuIHRoZSB3YWxrIGJlZ2lucy4gKGBwZW5kaW5nYCBpcyB0aGUgbGlzdCBvZiBvYmplY3RzIHdoaWNoIG5lZWQgdG8KK2JlIHRyYXZlcnNlZCBkdXJpbmcgYSB3YWxrOyB5b3UgY2FuIGltYWdpbmUgYSBicmVhZHRoLWZpcnN0IHRyZWUgdHJhdmVyc2FsIHRvCitoZWxwIHVuZGVyc3RhbmQuIEluIG91ciBjYXNlLCB0aGF0IG1lYW5zIHdlIG9taXQgdHJlZXMgYW5kIGJsb2JzIG5vdCBkaXJlY3RseQorcmVmZXJlbmNlZCBieSBgSEVBRGAgb3IgYEhFQURgJ3MgaGlzdG9yeSwgYmVjYXVzZSB3ZSBiZWdpbiB0aGUgd2FsayB3aXRoIG9ubHkKK2BIRUFEYCBpbiB0aGUgYHBlbmRpbmdgIGxpc3QuKQorCitGaXJzdCwgd2UnbGwgbmVlZCB0byBgI2luY2x1ZGUgImxpc3Qtb2JqZWN0cy1maWx0ZXItb3B0aW9ucy5oYCIgYW5kIHNldCB1cCB0aGUKK2BzdHJ1Y3QgbGlzdF9vYmplY3RzX2ZpbHRlcl9vcHRpb25zYCBhdCB0aGUgdG9wIG9mIHRoZSBmdW5jdGlvbi4KKworLS0tLQorc3RhdGljIHZvaWQgd2Fsa2VuX29iamVjdF93YWxrKHN0cnVjdCByZXZfaW5mbyAqcmV2KQoreworCXN0cnVjdCBsaXN0X29iamVjdHNfZmlsdGVyX29wdGlvbnMgZmlsdGVyX29wdGlvbnMgPSB7fTsKKworCS4uLgorLS0tLQorCitGb3Igbm93LCB3ZSBhcmUgbm90IGdvaW5nIHRvIHRyYWNrIHRoZSBvbWl0dGVkIG9iamVjdHMsIHNvIHdlJ2xsIHJlcGxhY2UgdGhvc2UKK3BhcmFtZXRlcnMgd2l0aCBgTlVMTGAuIEZvciB0aGUgc2FrZSBvZiBzaW1wbGljaXR5LCB3ZSdsbCBhZGQgYSBzaW1wbGUKK2J1aWxkLXRpbWUgYnJhbmNoIHRvIHVzZSBvdXIgZmlsdGVyIG9yIG5vdC4gUmVwbGFjZSB0aGUgbGluZSBjYWxsaW5nCitgdHJhdmVyc2VfY29tbWl0X2xpc3QoKWAgd2l0aCB0aGUgZm9sbG93aW5nLCB3aGljaCB3aWxsIHJlbWluZCB1cyB3aGljaCBraW5kIG9mCit3YWxrIHdlJ3ZlIGp1c3QgcGVyZm9ybWVkOgorCistLS0tCisJaWYgKDApIHsKKwkJLyogVW5maWx0ZXJlZDogKi8KKwkJdHJhY2VfcHJpbnRmKF8oIlVuZmlsdGVyZWQgb2JqZWN0IHdhbGsuXG4iKSk7CisJCXRyYXZlcnNlX2NvbW1pdF9saXN0KHJldiwgd2Fsa2VuX3Nob3dfY29tbWl0LAorCQkJCXdhbGtlbl9zaG93X29iamVjdCwgTlVMTCk7CisJfSBlbHNlIHsKKwkJdHJhY2VfcHJpbnRmKAorCQkJXygiRmlsdGVyZWQgb2JqZWN0IHdhbGsgd2l0aCBmaWx0ZXJzcGVjICd0cmVlOjEnLlxuIikpOworCQlwYXJzZV9saXN0X29iamVjdHNfZmlsdGVyKCZmaWx0ZXJfb3B0aW9ucywgInRyZWU6MSIpOworCisJCXRyYXZlcnNlX2NvbW1pdF9saXN0X2ZpbHRlcmVkKCZmaWx0ZXJfb3B0aW9ucywgcmV2LAorCQkJd2Fsa2VuX3Nob3dfY29tbWl0LCB3YWxrZW5fc2hvd19vYmplY3QsIE5VTEwsIE5VTEwpOworCX0KKy0tLS0KKworYHN0cnVjdCBsaXN0X29iamVjdHNfZmlsdGVyX29wdGlvbnNgIGlzIHVzdWFsbHkgYnVpbHQgZGlyZWN0bHkgZnJvbSBhIGNvbW1hbmQKK2xpbmUgYXJndW1lbnQsIHNvIHRoZSBtb2R1bGUgcHJvdmlkZXMgYW4gZWFzeSB3YXkgdG8gYnVpbGQgb25lIGZyb20gYSBzdHJpbmcuCitFdmVuIHRob3VnaCB3ZSBhcmVuJ3QgdGFraW5nIHVzZXIgaW5wdXQgcmlnaHQgbm93LCB3ZSBjYW4gc3RpbGwgYnVpbGQgb25lIHdpdGgKK2EgaGFyZGNvZGVkIHN0cmluZyB1c2luZyBgcGFyc2VfbGlzdF9vYmplY3RzX2ZpbHRlcigpYC4KKworV2l0aCB0aGUgZmlsdGVyIHNwZWMgInRyZWU6MSIsIHdlIGFyZSBleHBlY3RpbmcgdG8gc2VlIF9vbmx5XyB0aGUgcm9vdCB0cmVlIGZvcgorZWFjaCBjb21taXQ7IHRoZXJlZm9yZSwgdGhlIHRyZWUgb2JqZWN0IGNvdW50IHNob3VsZCBiZSBsZXNzIHRoYW4gb3IgZXF1YWwgdG8KK3RoZSBudW1iZXIgb2YgY29tbWl0cy4gKEZvciBhbiBleGFtcGxlIG9mIHdoeSB0aGF0J3MgdHJ1ZTogYGdpdCBjb21taXQgLS1yZXZlcnRgCitwb2ludHMgdG8gdGhlIHNhbWUgdHJlZSBvYmplY3QgYXMgaXRzIGdyYW5kcGFyZW50LikKKworPT09IENvdW50aW5nIE9taXR0ZWQgT2JqZWN0cworCitXZSBhbHNvIGhhdmUgdGhlIGNhcGFiaWxpdHkgdG8gZW51bWVyYXRlIGFsbCBvYmplY3RzIHdoaWNoIHdlcmUgb21pdHRlZCBieSBhCitmaWx0ZXIsIGxpa2Ugd2l0aCBgZ2l0IGxvZyAtLWZpbHRlcj08c3BlYz4gLS1maWx0ZXItcHJpbnQtb21pdHRlZGAuIEFza2luZworYHRyYXZlcnNlX2NvbW1pdF9saXN0X2ZpbHRlcmVkKClgIHRvIHBvcHVsYXRlIHRoZSBgb21pdHRlZGAgbGlzdCBtZWFucyB0aGF0IG91cgorb2JqZWN0IHdhbGsgZG9lcyBub3QgcGVyZm9ybSBhbnkgYmV0dGVyIHRoYW4gYW4gdW5maWx0ZXJlZCBvYmplY3Qgd2FsazsgYWxsCityZWFjaGFibGUgb2JqZWN0cyBhcmUgd2Fsa2VkIGluIG9yZGVyIHRvIHBvcHVsYXRlIHRoZSBsaXN0LgorCitGaXJzdCwgYWRkIHRoZSBgc3RydWN0IG9pZHNldGAgYW5kIHJlbGF0ZWQgaXRlbXMgd2Ugd2lsbCB1c2UgdG8gaXRlcmF0ZSBpdDoKKworLS0tLQorc3RhdGljIHZvaWQgd2Fsa2VuX29iamVjdF93YWxrKAorCS4uLgorCisJc3RydWN0IG9pZHNldCBvbWl0dGVkOworCXN0cnVjdCBvaWRzZXRfaXRlciBvaXQ7CisJc3RydWN0IG9iamVjdF9pZCAqb2lkID0gTlVMTDsKKwlpbnQgb21pdHRlZF9jb3VudCA9IDA7CisJb2lkc2V0X2luaXQoJm9taXR0ZWQsIDApOworCisJLi4uCistLS0tCisKK01vZGlmeSB0aGUgY2FsbCB0byBgdHJhdmVyc2VfY29tbWl0X2xpc3RfZmlsdGVyZWQoKWAgdG8gaW5jbHVkZSB5b3VyIGBvbWl0dGVkYAorb2JqZWN0OgorCistLS0tCisJLi4uCisKKwkJdHJhdmVyc2VfY29tbWl0X2xpc3RfZmlsdGVyZWQoJmZpbHRlcl9vcHRpb25zLCByZXYsCisJCQl3YWxrZW5fc2hvd19jb21taXQsIHdhbGtlbl9zaG93X29iamVjdCwgTlVMTCwgJm9taXR0ZWQpOworCisJLi4uCistLS0tCisKK1RoZW4sIGFmdGVyIHlvdXIgdHJhdmVyc2FsLCB0aGUgYG9pZHNldGAgdHJhdmVyc2FsIGlzIHByZXR0eSBzdHJhaWdodGZvcndhcmQuCitDb3VudCBhbGwgdGhlIG9iamVjdHMgd2l0aGluIGFuZCBtb2RpZnkgdGhlIHByaW50IHN0YXRlbWVudDoKKworLS0tLQorCS8qIENvdW50IHRoZSBvbWl0dGVkIG9iamVjdHMuICovCisJb2lkc2V0X2l0ZXJfaW5pdCgmb21pdHRlZCwgJm9pdCk7CisKKwl3aGlsZSAoKG9pZCA9IG9pZHNldF9pdGVyX25leHQoJm9pdCkpKQorCQlvbWl0dGVkX2NvdW50Kys7CisKKwlwcmludGYoImNvbW1pdHMgJWRcbmJsb2JzICVkXG50YWdzICVkXG50cmVlcyVkXG5vbWl0dGVkICVkXG4iLAorCQljb21taXRfY291bnQsIGJsb2JfY291bnQsIHRhZ19jb3VudCwgdHJlZV9jb3VudCwgb21pdHRlZF9jb3VudCk7CistLS0tCisKK0J5IHJ1bm5pbmcgeW91ciB3YWxrIHdpdGggYW5kIHdpdGhvdXQgdGhlIGZpbHRlciwgeW91IHNob3VsZCBmaW5kIHRoYXQgdGhlIHRvdGFsCitvYmplY3QgY291bnQgaW4gZWFjaCBjYXNlIGlzIGlkZW50aWNhbC4gWW91IGNhbiBhbHNvIHRpbWUgZWFjaCBpbnZvY2F0aW9uIG9mCit0aGUgYHdhbGtlbmAgc3ViY29tbWFuZCwgd2l0aCBhbmQgd2l0aG91dCBgb21pdHRlZGAgYmVpbmcgcGFzc2VkIGluLCB0byBjb25maXJtCit0byB5b3Vyc2VsZiB0aGUgcnVudGltZSBpbXBhY3Qgb2YgdHJhY2tpbmcgYWxsIG9taXR0ZWQgb2JqZWN0cy4KKworPT09IENoYW5naW5nIHRoZSBPcmRlcgorCitGaW5hbGx5LCBsZXQncyBkZW1vbnN0cmF0ZSB0aGF0IHlvdSBjYW4gYWxzbyByZW9yZGVyIHdhbGtzIG9mIGFsbCBvYmplY3RzLCBub3QKK2p1c3Qgd2Fsa3Mgb2YgY29tbWl0cy4gRmlyc3QsIHdlJ2xsIG1ha2Ugb3VyIGhhbmRsZXJzIGNoYXR0aWVyIC0gbW9kaWZ5Citgd2Fsa2VuX3Nob3dfY29tbWl0KClgIGFuZCBgd2Fsa2VuX3Nob3dfb2JqZWN0KClgIHRvIHByaW50IHRoZSBvYmplY3QgYXMgdGhleQorZ286CisKKy0tLS0KK3N0YXRpYyB2b2lkIHdhbGtlbl9zaG93X2NvbW1pdChzdHJ1Y3QgY29tbWl0ICpjbXQsIHZvaWQgKmJ1ZikKK3sKKwl0cmFjZV9wcmludGYoImNvbW1pdDogJXNcbiIsIG9pZF90b19oZXgoJmNtdC0+b2JqZWN0Lm9pZCkpOworCWNvbW1pdF9jb3VudCsrOworfQorCitzdGF0aWMgdm9pZCB3YWxrZW5fc2hvd19vYmplY3Qoc3RydWN0IG9iamVjdCAqb2JqLCBjb25zdCBjaGFyICpzdHIsIHZvaWQgKmJ1ZikKK3sKKwl0cmFjZV9wcmludGYoIiVzOiAlc1xuIiwgdHlwZV9uYW1lKG9iai0+dHlwZSksIG9pZF90b19oZXgoJm9iai0+b2lkKSk7CisKKwkuLi4KK30KKy0tLS0KKworTk9URTogU2luY2Ugd2Ugd2lsbCBiZSBleGFtaW5pbmcgdGhpcyBvdXRwdXQgZGlyZWN0bHkgYXMgaHVtYW5zLCB3ZSdsbCB1c2UKK2B0cmFjZV9wcmludGYoKWAgaGVyZS4gQWRkaXRpb25hbGx5LCBzaW5jZSB0aGlzIGNoYW5nZSBpbnRyb2R1Y2VzIGEgc2lnbmlmaWNhbnQKK251bWJlciBvZiBwcmludGVkIGxpbmVzLCB1c2luZyBgdHJhY2VfcHJpbnRmKClgIHdpbGwgYWxsb3cgdXMgdG8gZWFzaWx5IHNpbGVuY2UKK3Rob3NlIGxpbmVzIHdpdGhvdXQgaGF2aW5nIHRvIHJlY29tcGlsZS4KKworKExlYXZlIHRoZSBjb3VudGVyIGluY3JlbWVudCBsb2dpYyBpbiBwbGFjZS4pCisKK1dpdGggb25seSB0aGF0IGNoYW5nZSwgcnVuIGFnYWluIChidXQgc2F2ZSB5b3Vyc2VsZiBzb21lIHNjcm9sbGJhY2spOgorCistLS0tCiskIEdJVF9UUkFDRT0xIC4vYmluLXdyYXBwZXJzL2dpdCB3YWxrZW4gfCBoZWFkIC1uIDEwCistLS0tCisKK1Rha2UgYSBsb29rIGF0IHRoZSB0b3AgY29tbWl0IHdpdGggYGdpdCBzaG93YCBhbmQgdGhlIG9iamVjdCBJRCB5b3UgcHJpbnRlZDsgaXQKK3Nob3VsZCBiZSB0aGUgc2FtZSBhcyB0aGUgb3V0cHV0IG9mIGBnaXQgc2hvdyBIRUFEYC4KKworTmV4dCwgbGV0J3MgY2hhbmdlIGEgc2V0dGluZyBvbiBvdXIgYHN0cnVjdCByZXZfaW5mb2Agd2l0aGluCitgd2Fsa2VuX29iamVjdF93YWxrKClgLiBGaW5kIHdoZXJlIHlvdSdyZSBjaGFuZ2luZyB0aGUgb3RoZXIgc2V0dGluZ3Mgb24gYHJldmAsCitzdWNoIGFzIGByZXYtPnRyZWVfb2JqZWN0c2AgYW5kIGByZXYtPnRyZWVfYmxvYnNfaW5fY29tbWl0X29yZGVyYCwgYW5kIGFkZCB0aGUKK2ByZXZlcnNlYCBzZXR0aW5nIGF0IHRoZSBib3R0b206CisKKy0tLS0KKwkuLi4KKworCXJldi0+dHJlZV9vYmplY3RzID0gMTsKKwlyZXYtPmJsb2Jfb2JqZWN0cyA9IDE7CisJcmV2LT50YWdfb2JqZWN0cyA9IDE7CisJcmV2LT50cmVlX2Jsb2JzX2luX2NvbW1pdF9vcmRlciA9IDE7CisJcmV2LT5yZXZlcnNlID0gMTsKKworCS4uLgorLS0tLQorCitOb3csIHJ1biBhZ2FpbiwgYnV0IHRoaXMgdGltZSwgbGV0J3MgZ3JhYiB0aGUgbGFzdCBoYW5kZnVsIG9mIG9iamVjdHMgaW5zdGVhZAorb2YgdGhlIGZpcnN0IGhhbmRmdWw6CisKKy0tLS0KKyQgbWFrZQorJCBHSVRfVFJBQ0U9MSAuL2Jpbi13cmFwcGVycyBnaXQgd2Fsa2VuIHwgdGFpbCAtbiAxMAorLS0tLQorCitUaGUgbGFzdCBjb21taXQgb2JqZWN0IGdpdmVuIHNob3VsZCBoYXZlIHRoZSBzYW1lIE9JRCBhcyB0aGUgb25lIHdlIHNhdyBhdCB0aGUKK3RvcCBiZWZvcmUsIGFuZCBydW5uaW5nIGBnaXQgc2hvdyA8b2lkPmAgd2l0aCB0aGF0IE9JRCBzaG91bGQgZ2l2ZSB5b3UgYWdhaW4KK3RoZSBzYW1lIHJlc3VsdHMgYXMgYGdpdCBzaG93IEhFQURgLiBGdXJ0aGVybW9yZSwgaWYgeW91IHJ1biBhbmQgZXhhbWluZSB0aGUKK2ZpcnN0IHRlbiBsaW5lcyBhZ2FpbiAod2l0aCBgaGVhZGAgaW5zdGVhZCBvZiBgdGFpbGAgbGlrZSB3ZSBkaWQgYmVmb3JlIGFwcGx5aW5nCit0aGUgYHJldmVyc2VgIHNldHRpbmcpLCB5b3Ugc2hvdWxkIHNlZSB0aGF0IG5vdyB0aGUgZmlyc3QgY29tbWl0IHByaW50ZWQgaXMgdGhlCitpbml0aWFsIGNvbW1pdCwgYGU4M2M1MTYzYC4KKworPT0gV3JhcHBpbmcgVXAKKworTGV0J3MgcmV2aWV3LiBJbiB0aGlzIHR1dG9yaWFsLCB3ZToKKworLSBCdWlsdCBhIGNvbW1pdCB3YWxrIGZyb20gdGhlIGdyb3VuZCB1cAorLSBFbmFibGVkIGEgZ3JlcCBmaWx0ZXIgZm9yIHRoYXQgY29tbWl0IHdhbGsKKy0gQ2hhbmdlZCB0aGUgc29ydCBvcmRlciBvZiB0aGF0IGZpbHRlcmVkIGNvbW1pdCB3YWxrCistIEJ1aWx0IGFuIG9iamVjdCB3YWxrICh0YWdzLCBjb21taXRzLCB0cmVlcywgYW5kIGJsb2JzKSBmcm9tIHRoZSBncm91bmQgdXAKKy0gTGVhcm5lZCBob3cgdG8gYWRkIGEgZmlsdGVyLXNwZWMgdG8gYW4gb2JqZWN0IHdhbGsKKy0gQ2hhbmdlZCB0aGUgZGlzcGxheSBvcmRlciBvZiB0aGUgZmlsdGVyZWQgb2JqZWN0IHdhbGsKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vUmVsTm90ZXMvMS41LjAudHh0IGIvRG9jdW1lbnRhdGlvbi9SZWxOb3Rlcy8xLjUuMC50eHQKaW5kZXggZGFmNGJkYi4uZDZkNDJmMyAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9SZWxOb3Rlcy8xLjUuMC50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9SZWxOb3Rlcy8xLjUuMC50eHQKQEAgLTI1MSw3ICsyNTEsNyBAQAogICAgdGhlIHJlcG9zaXRvcnkgd2hlbiB0aGF0IGhhcHBlbnMuCiAKIAotKiBDcnVmdHMgcmVtb3ZhbAorKiBDcnVmdCByZW1vdmFsCiAKICAtIFdlIHVzZWQgdG8gc2F5ICJvbGQgY29tbWl0cyBhcmUgcmV0cmlldmFibGUgdXNpbmcgcmVmbG9nIGFuZAogICAgJ21hc3RlckB7eWVzdGVyZGF5fScgc3ludGF4IGFzIGxvbmcgYXMgeW91IGhhdmVuJ3QgcnVuCkBAIC0zNzksNyArMzc5LDcgQEAKICAtIFRoZSB2YWx1ZSBvZiBpMThuLmNvbW1pdGVuY29kaW5nIGluIHRoZSBvcmlnaW5hdGluZwogICAgcmVwb3NpdG9yeSBpcyByZWNvcmRlZCBpbiB0aGUgY29tbWl0IG9iamVjdCBvbiB0aGUgImVuY29kaW5nIgogICAgaGVhZGVyLCBpZiBpdCBpcyBub3QgVVRGLTguICBnaXQtbG9nIGFuZCBmcmllbmRzIG5vdGljZSB0aGlzLAotICAgYW5kIHJlZW5jb2RlcyB0aGUgbWVzc2FnZSB0byB0aGUgbG9nIG91dHB1dCBlbmNvZGluZyB3aGVuCisgICBhbmQgcmUtZW5jb2RlcyB0aGUgbWVzc2FnZSB0byB0aGUgbG9nIG91dHB1dCBlbmNvZGluZyB3aGVuCiAgICBkaXNwbGF5aW5nLCBpZiB0aGV5IGFyZSBkaWZmZXJlbnQuICBUaGUgbG9nIG91dHB1dCBlbmNvZGluZwogICAgaXMgZGV0ZXJtaW5lZCBieSAiZ2l0IGxvZyAtLWVuY29kaW5nPTxlbmNvZGluZz4iLAogICAgaTE4bi5sb2dvdXRwdXRlbmNvZGluZyBjb25maWd1cmF0aW9uLCBvciBpMThuLmNvbW1pdGVuY29kaW5nCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL1JlbE5vdGVzLzEuNi41LjQudHh0IGIvRG9jdW1lbnRhdGlvbi9SZWxOb3Rlcy8xLjYuNS40LnR4dAppbmRleCBkM2EyYTNlLi4zNDQzMzNkIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL1JlbE5vdGVzLzEuNi41LjQudHh0CisrKyBiL0RvY3VtZW50YXRpb24vUmVsTm90ZXMvMS42LjUuNC50eHQKQEAgLTEwLDcgKzEwLDcgQEAKIAogICogImdpdCBwcnVuZS1wYWNrZWQiIGdhdmUgcHJvZ3Jlc3Mgb3V0cHV0IGV2ZW4gd2hlbiBpdHMgc3RhbmRhcmQgZXJyb3IgaXMKICAgIG5vdCBjb25uZWN0ZWQgdG8gYSB0ZXJtaW5hbDsgdGhpcyBjYXVzZWQgY3JvbiBqb2JzIHRoYXQgcnVuIGl0IHRvCi0gICBwcm9kdWNlIGNydWZ0cy4KKyAgIHByb2R1Y2UgY3J1ZnQuCiAKICAqICJnaXQgcGFjay1vYmplY3RzIC0tYWxsLXByb2dyZXNzIiBpcyBhbiBvcHRpb24gdG8gYXNrIHByb2dyZXNzIG91dHB1dAogICAgZnJvbSB3cml0ZS1vYmplY3QgcGhhc2UgX2lmXyBwcm9ncmVzcyBvdXRwdXQgd2VyZSB0byBiZSBwcm9kdWNlZCwgYW5kCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL1JlbE5vdGVzLzEuNy4wLjIudHh0IGIvRG9jdW1lbnRhdGlvbi9SZWxOb3Rlcy8xLjcuMC4yLnR4dAppbmRleCBmY2I0NmNhLi43M2VkMmI1IDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL1JlbE5vdGVzLzEuNy4wLjIudHh0CisrKyBiL0RvY3VtZW50YXRpb24vUmVsTm90ZXMvMS43LjAuMi50eHQKQEAgLTM0LDcgKzM0LDcgQEAKICAqICJnaXQgc3RhdHVzIiBpbiAxLjcuMCBsYWNrZWQgdGhlIG9wdGltaXphdGlvbiB3ZSB1c2VkIHRvIGhhdmUgaW4gMS42Llggc2VyaWVzCiAgICB0byBzcGVlZCB1cCBzY2FubmluZyBvZiBsYXJnZSB3b3JraW5nIHRyZWUuCiAKLSAqICJnaXR3ZWIiIGRpZCBub3QgZGlhZ25vc2UgcGFyc2luZyBlcnJvcnMgcHJvcGVybHkgd2hpbGUgcmVhZGluZyB0aXMgY29uZmlndXJhdGlvbgorICogImdpdHdlYiIgZGlkIG5vdCBkaWFnbm9zZSBwYXJzaW5nIGVycm9ycyBwcm9wZXJseSB3aGlsZSByZWFkaW5nIGl0cyBjb25maWd1cmF0aW9uCiAgICBmaWxlLgogCiBBbmQgb3RoZXIgbWlub3IgZml4ZXMgYW5kIGRvY3VtZW50YXRpb24gdXBkYXRlcy4KZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vUmVsTm90ZXMvMS43LjEwLjQudHh0IGIvRG9jdW1lbnRhdGlvbi9SZWxOb3Rlcy8xLjcuMTAuNC50eHQKaW5kZXggMzI2NjcwZC4uNTc1OTdmMiAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9SZWxOb3Rlcy8xLjcuMTAuNC50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9SZWxOb3Rlcy8xLjcuMTAuNC50eHQKQEAgLTcsNyArNyw3IEBACiAgKiBUaGUgbWVzc2FnZSBmaWxlIGZvciBTd2VkaXNoIHRyYW5zbGF0aW9uIGhhcyBiZWVuIHVwZGF0ZWQgYSBiaXQuCiAKICAqIEEgbmFtZSB0YWtlbiBmcm9tIG1haWxtYXAgd2FzIGNvcGllZCBpbnRvIGFuIGludGVybmFsIGJ1ZmZlcgotICAgaW5jb3JyZWN0bHkgYW5kIGNvdWxkIG92ZXJ1biB0aGUgYnVmZmVyIGlmIGl0IGlzIHRvbyBsb25nLgorICAgaW5jb3JyZWN0bHkgYW5kIGNvdWxkIG92ZXJydW4gdGhlIGJ1ZmZlciBpZiBpdCBpcyB0b28gbG9uZy4KIAogICogQSBtYWxmb3JtZWQgY29tbWl0IG9iamVjdCB0aGF0IGhhcyBhIGhlYWRlciBsaW5lIGNob21wZWQgaW4gdGhlCiAgICBtaWRkbGUgY291bGQga2lsbCBnaXQgd2l0aCBhIE5VTEwgcG9pbnRlciBkZXJlZmVyZW5jZS4KZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vUmVsTm90ZXMvMS43LjEyLjMudHh0IGIvRG9jdW1lbnRhdGlvbi9SZWxOb3Rlcy8xLjcuMTIuMy50eHQKaW5kZXggZWNkYTQyNy4uNGI4MjI5NyAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9SZWxOb3Rlcy8xLjcuMTIuMy50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9SZWxOb3Rlcy8xLjcuMTIuMy50eHQKQEAgLTI1LDcgKzI1LDcgQEAKICAgIGl0cyBBY2NlcHQtRW5jb2RpbmcgaGVhZGVyLgogCiAgKiAiZ2l0IHJlY2VpdmUtcGFjayIgKHRoZSBjb3VudGVycGFydCB0byAiZ2l0IHB1c2giKSBkaWQgbm90IGdpdmUKLSAgIHByb2dyZXNzIG91dHB1dCB3aGlsZSBwcm9jZXNzaW5nIG9iamVjdHMgaXQgcmVjZWl2ZWQgdG8gdGhlIHB1c2VyCisgICBwcm9ncmVzcyBvdXRwdXQgd2hpbGUgcHJvY2Vzc2luZyBvYmplY3RzIGl0IHJlY2VpdmVkIHRvIHRoZSB1c2VyCiAgICB3aGVuIHJ1biBvdmVyIHRoZSBzbWFydC1odHRwIHByb3RvY29sLgogCiAgKiAiZ2l0IHN0YXR1cyIgaG9ub3JlZCB0aGUgaWdub3JlPWRpcnR5IHNldHRpbmdzIGluIC5naXRtb2R1bGVzIGJ1dApkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9SZWxOb3Rlcy8xLjcuNS4zLnR4dCBiL0RvY3VtZW50YXRpb24vUmVsTm90ZXMvMS43LjUuMy50eHQKaW5kZXggOWMwMzM1My4uMWQyNGVkYyAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9SZWxOb3Rlcy8xLjcuNS4zLnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL1JlbE5vdGVzLzEuNy41LjMudHh0CkBAIC0yMiw3ICsyMiw3IEBACiAgKiAiZ2l0IGxvZyAtLXN0ZGluIHBhdGgiIHdpdGggYW4gaW5wdXQgdGhhdCBoYXMgYWRkaXRpb25hbCBwYXRoc3BlYwogICAgdXNlZCB0byBjb3JydXB0IG1lbW9yeS4KIAotICogImdpdCBzZW5kLXBhY2siIChoZW5jZSAiZ2l0IHB1c2giKSBvdmVyIHNtYWx0LUhUVFAgcHJvdG9jb2wgY291bGQKKyAqICJnaXQgc2VuZC1wYWNrIiAoaGVuY2UgImdpdCBwdXNoIikgb3ZlciBzbWFydC1IVFRQIHByb3RvY29sIGNvdWxkCiAgICBkZWFkbG9jayB3aGVuIHRoZSBjbGllbnQgc2lkZSBwYWNrLW9iamVjdCBkaWVkIGVhcmx5LgogCiAgKiBDb21wcmVzc2VkIHRhcmJhbGwgZ2l0d2ViIGdlbmVyYXRlcyB1c2VkIHRvIGJlIG1hZGUgd2l0aCB0aGUgdGltZXN0YW1wCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL1JlbE5vdGVzLzEuOC4wLnR4dCBiL0RvY3VtZW50YXRpb24vUmVsTm90ZXMvMS44LjAudHh0CmluZGV4IDQzODgzYzEuLjYzZDZlNGEgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vUmVsTm90ZXMvMS44LjAudHh0CisrKyBiL0RvY3VtZW50YXRpb24vUmVsTm90ZXMvMS44LjAudHh0CkBAIC0yMzMsNyArMjMzLDcgQEAKICAgIHRvZ2V0aGVyLCBtaXNkZXRlY3RlZCBicmFuY2hlcy4KIAogICogImdpdCByZWNlaXZlLXBhY2siICh0aGUgY291bnRlcnBhcnQgdG8gImdpdCBwdXNoIikgZGlkIG5vdCBnaXZlCi0gICBwcm9ncmVzcyBvdXRwdXQgd2hpbGUgcHJvY2Vzc2luZyBvYmplY3RzIGl0IHJlY2VpdmVkIHRvIHRoZSBwdXNlcgorICAgcHJvZ3Jlc3Mgb3V0cHV0IHdoaWxlIHByb2Nlc3Npbmcgb2JqZWN0cyBpdCByZWNlaXZlZCB0byB0aGUgdXNlcgogICAgd2hlbiBydW4gb3ZlciB0aGUgc21hcnQtaHR0cCBwcm90b2NvbC4KIAogICogV2hlbiB5b3UgbWlzc3BlbGwgdGhlIGNvbW1hbmQgbmFtZSB5b3UgZ2l2ZSB0byB0aGUgImV4ZWMiIGFjdGlvbiBpbgpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9SZWxOb3Rlcy8xLjguNC4xLnR4dCBiL0RvY3VtZW50YXRpb24vUmVsTm90ZXMvMS44LjQuMS50eHQKaW5kZXggOTYwOTBlZi4uYzI1N2JlYiAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9SZWxOb3Rlcy8xLjguNC4xLnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL1JlbE5vdGVzLzEuOC40LjEudHh0CkBAIC0xNSw3ICsxNSw3IEBACiAgICBpbiAxLjguNC1yYzEpLgogCiAgKiAiZ2l0IHJlYmFzZSAtaSIgYW5kIG90aGVyIHNjcmlwdGVkIGNvbW1hbmRzIHdlcmUgZmVlZGluZyBhCi0gICByYW5kb20sIGRhdGEgZGVwZW5kYW50IGVycm9yIG1lc3NhZ2UgdG8gJ2VjaG8nIGFuZCBleHBlY3RpbmcgaXQKKyAgIHJhbmRvbSwgZGF0YSBkZXBlbmRlbnQgZXJyb3IgbWVzc2FnZSB0byAnZWNobycgYW5kIGV4cGVjdGluZyBpdAogICAgdG8gY29tZSBvdXQgbGl0ZXJhbGx5LgogCiAgKiBTZXR0aW5nIHRoZSAic3VibW9kdWxlLjxuYW1lPi5wYXRoIiB2YXJpYWJsZSB0byB0aGUgZW1wdHkKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vUmVsTm90ZXMvMi4xLjMudHh0IGIvRG9jdW1lbnRhdGlvbi9SZWxOb3Rlcy8yLjEuMy50eHQKaW5kZXggYWNjOWViYi4uMGRmYjE3YyAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9SZWxOb3Rlcy8yLjEuMy50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9SZWxOb3Rlcy8yLjEuMy50eHQKQEAgLTEzLDcgKzEzLDcgQEAKICAgIHRoZXkgYXJlIG5ldyBlbm91Z2ggdG8gc3VwcG9ydCB0aGUgYC0tb3V0cHV0YCBvcHRpb24uCiAKICAqICJnaXQgcGFjay1vYmplY3RzIiBmb3Jnb3QgdG8gZGlzYWJsZSB0aGUgY29kZXBhdGggdG8gZ2VuZXJhdGUKLSAgIG9iamVjdCByZWNoZWFiaWxpdHkgYml0bWFwIHdoZW4gaXQgbmVlZHMgdG8gc3BsaXQgdGhlIHJlc3VsdGluZworICAgb2JqZWN0IHJlYWNoYWJpbGl0eSBiaXRtYXAgd2hlbiBpdCBuZWVkcyB0byBzcGxpdCB0aGUgcmVzdWx0aW5nCiAgICBwYWNrLgogCiAgKiAiZ2l0d2ViIiB1c2VkIGRlcHJlY2F0ZWQgQ0dJOjpzdGFydGZyb20sIHdoaWNoIHdhcyByZW1vdmVkIGZyb20KZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vUmVsTm90ZXMvMi4xMC4wLnR4dCBiL0RvY3VtZW50YXRpb24vUmVsTm90ZXMvMi4xMC4wLnR4dAppbmRleCBmNGRhMjhhLi4zNzkyYjdkIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL1JlbE5vdGVzLzIuMTAuMC50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9SZWxOb3Rlcy8yLjEwLjAudHh0CkBAIC00NzgsNyArNDc4LDcgQEAKICAqIE9uZSBwYXJ0IG9mICJnaXQgYW0iIGhhZCBhbiBvZGRiYWxsIGhlbHBlciBmdW5jdGlvbiB0aGF0IGNhbGxlZAogICAgc3R1ZmYgZnJvbSBvdXRzaWRlICJoaXMiIGFzIG9wcG9zZWQgdG8gY2FsbGluZyB3aGF0IHdlIGhhdmUgIm91cnMiLAogICAgd2hpY2ggd2FzIG5vdCBnZW5kZXItbmV1dHJhbCBhbmQgYWxzbyBpbmNvbnNpc3RlbnQgd2l0aCB0aGUgcmVzdCBvZgotICAgdGhlIHN5c3RlbSB3aGVyZSBvdXRzaWRlIHN0dWZmIGlzIHVzdWFsbCBjYWxsZWQgInRoZWlycyIgaW4KKyAgIHRoZSBzeXN0ZW0gd2hlcmUgb3V0c2lkZSBzdHVmZiBpcyB1c3VhbGx5IGNhbGxlZCAidGhlaXJzIiBpbgogICAgY29udHJhc3QgdG8gIm91cnMiLgogCiAgKiAiZ2l0IGJsYW1lIGZpbGUiIGFsbG93ZWQgdGhlIGxpbmVhZ2Ugb2YgbGluZXMgaW4gdGhlIHVuY29tbWl0dGVkLApkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9SZWxOb3Rlcy8yLjEwLjIudHh0IGIvRG9jdW1lbnRhdGlvbi9SZWxOb3Rlcy8yLjEwLjIudHh0CmluZGV4IGM0ZDQzOTcuLmFiYmQzMzEgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vUmVsTm90ZXMvMi4xMC4yLnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL1JlbE5vdGVzLzIuMTAuMi50eHQKQEAgLTg2LDcgKzg2LDcgQEAKICAgIGJ5IHJlZnVzaW5nIHRvIGNoZWNrIG91dCBhIGJyYW5jaCB0aGF0IGlzIGFscmVhZHkgY2hlY2tlZCBvdXQgaW4KICAgIGFub3RoZXIgd29ya3RyZWUuICBIb3dldmVyLCB0aGlzIGFsc28gcHJldmVudGVkIGNoZWNraW5nIG91dCBhCiAgICBicmFuY2gsIHdoaWNoIGlzIGRlc2lnbmF0ZWQgYXMgdGhlIHByaW1hcnkgYnJhbmNoIG9mIGEgYmFyZQotICAgcmVvcHNpdG9yeSwgaW4gYSB3b3JrdHJlZSB0aGF0IGlzIGNvbm5lY3RlZCB0byB0aGUgYmFyZQorICAgcmVwb3NpdG9yeSwgaW4gYSB3b3JrdHJlZSB0aGF0IGlzIGNvbm5lY3RlZCB0byB0aGUgYmFyZQogICAgcmVwb3NpdG9yeS4gIFRoZSBjaGVjayBoYXMgYmVlbiBjb3JyZWN0ZWQgdG8gYWxsb3cgaXQuCiAKICAqICJnaXQgcmViYXNlIiBpbW1lZGlhdGVseSBhZnRlciAiZ2l0IGNsb25lIiBmYWlsZWQgdG8gZmluZCB0aGUgZm9yawpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9SZWxOb3Rlcy8yLjExLjEudHh0IGIvRG9jdW1lbnRhdGlvbi9SZWxOb3Rlcy8yLjExLjEudHh0CmluZGV4IDljZDE0YzguLjdkMzVjZjEgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vUmVsTm90ZXMvMi4xMS4xLnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL1JlbE5vdGVzLzIuMTEuMS50eHQKQEAgLTEwNCw3ICsxMDQsNyBAQAogICAgImdpdCBkaWZmdG9vbCAtLWRpci1kaWZmIiBmcm9tIGEgc3ViZGlyZWN0b3J5IG5ldmVyIHdvcmtlZC4gVGhpcwogICAgaGFzIGJlZW4gZml4ZWQuCiAKLSAqICJnaXQgcDQiIHRoYXQgdHJhY2tzIG11bHRpbGUgcDQgcGF0aHMgaW1wb3J0ZWQgYSBzaW5nbGUgY2hhbmdlbGlzdAorICogImdpdCBwNCIgdGhhdCB0cmFja3MgbXVsdGlwbGUgcDQgcGF0aHMgaW1wb3J0ZWQgYSBzaW5nbGUgY2hhbmdlbGlzdAogICAgdGhhdCB0b3VjaGVzIGZpbGVzIGluIHRoZXNlIG11bHRpcGxlIHBhdGhzIGFzIG9uZSBjb21taXQsIGZvbGxvd2VkCiAgICBieSBtYW55IGVtcHR5IGNvbW1pdHMuICBUaGlzIGhhcyBiZWVuIGZpeGVkLgogCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL1JlbE5vdGVzLzIuMTIuMC50eHQgYi9Eb2N1bWVudGF0aW9uL1JlbE5vdGVzLzIuMTIuMC50eHQKaW5kZXggZWY4Yjk3ZC4uZDJmNmE4MyAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9SZWxOb3Rlcy8yLjEyLjAudHh0CisrKyBiL0RvY3VtZW50YXRpb24vUmVsTm90ZXMvMi4xMi4wLnR4dApAQCAtMzE1LDcgKzMxNSw3IEBACiAgICAiZ2l0IGRpZmZ0b29sIC0tZGlyLWRpZmYiIGZyb20gYSBzdWJkaXJlY3RvcnkgbmV2ZXIgd29ya2VkLiBUaGlzCiAgICBoYXMgYmVlbiBmaXhlZC4KIAotICogImdpdCBwNCIgdGhhdCB0cmFja3MgbXVsdGlsZSBwNCBwYXRocyBpbXBvcnRlZCBhIHNpbmdsZSBjaGFuZ2VsaXN0CisgKiAiZ2l0IHA0IiB0aGF0IHRyYWNrcyBtdWx0aXBsZSBwNCBwYXRocyBpbXBvcnRlZCBhIHNpbmdsZSBjaGFuZ2VsaXN0CiAgICB0aGF0IHRvdWNoZXMgZmlsZXMgaW4gdGhlc2UgbXVsdGlwbGUgcGF0aHMgYXMgb25lIGNvbW1pdCwgZm9sbG93ZWQKICAgIGJ5IG1hbnkgZW1wdHkgY29tbWl0cy4gIFRoaXMgaGFzIGJlZW4gZml4ZWQuCiAKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vUmVsTm90ZXMvMi4xMy4wLnR4dCBiL0RvY3VtZW50YXRpb24vUmVsTm90ZXMvMi4xMy4wLnR4dAppbmRleCBhYTk5ZDRiLi4yYTQ3YjRjIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL1JlbE5vdGVzLzIuMTMuMC50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9SZWxOb3Rlcy8yLjEzLjAudHh0CkBAIC0xNzcsNyArMTc3LDcgQEAKICAgIGJlZW4gY2hhbmdlZCB0byBlbmFibGUgIi0tZGVjb3JhdGUiLgogCiAgKiBUaGUgb3V0cHV0IGZyb20gImdpdCBzdGF0dXMgLS1zaG9ydCIgaGFzIGJlZW4gZXh0ZW5kZWQgdG8gc2hvdwotICAgdmFyaW91cyBraW5kcyBvZiBkaXJ0eW5lc3MgaW4gc3VibW9kdWxlcyBkaWZmZXJlbnRseTsgaW5zdGVhZCBvZiB0bworICAgdmFyaW91cyBraW5kcyBvZiBkaXJ0aW5lc3MgaW4gc3VibW9kdWxlcyBkaWZmZXJlbnRseTsgaW5zdGVhZCBvZiB0bwogICAgIk0iIGZvciBtb2RpZmllZCwgJ20nIGFuZCAnPycgY2FuIGJlIHNob3duIHRvIHNpZ25hbCBjaGFuZ2VzIG9ubHkKICAgIHRvIHRoZSB3b3JraW5nIHRyZWUgb2YgdGhlIHN1Ym1vZHVsZSBidXQgbm90IHRoZSBjb21taXQgdGhhdCBpcwogICAgY2hlY2tlZCBvdXQuCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL1JlbE5vdGVzLzIuMTMuMy50eHQgYi9Eb2N1bWVudGF0aW9uL1JlbE5vdGVzLzIuMTMuMy50eHQKaW5kZXggNWQ3NmFkNS4uMzg0ZTRkZSAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9SZWxOb3Rlcy8yLjEzLjMudHh0CisrKyBiL0RvY3VtZW50YXRpb24vUmVsTm90ZXMvMi4xMy4zLnR4dApAQCAtMjUsNyArMjUsNyBAQAogICogVGhlIGNvZGUgdG8gcGljayB1cCBhbmQgZXhlY3V0ZSBjb21tYW5kIGFsaWFzIGRlZmluaXRpb24gZnJvbSB0aGUKICAgIGNvbmZpZ3VyYXRpb24gdXNlZCB0byBzd2l0Y2ggdG8gdGhlIHRvcCBvZiB0aGUgd29ya2luZyB0cmVlIGFuZAogICAgdGhlbiBjb21lIGJhY2sgd2hlbiB0aGUgZXhwYW5kZWQgYWxpYXMgd2FzIGV4ZWN1dGVkLCB3aGljaCB3YXMKLSAgIHVubmVjZXNzYXJpbHlsIGNvbXBsZXguICBBdHRlbXB0IHRvIHNpbXBsaWZ5IHRoZSBsb2dpYyBieSB1c2luZyB0aGUKKyAgIHVubmVjZXNzYXJpbHkgY29tcGxleC4gIEF0dGVtcHQgdG8gc2ltcGxpZnkgdGhlIGxvZ2ljIGJ5IHVzaW5nIHRoZQogICAgZWFybHktY29uZmlnIG1lY2hhbmlzbSB0aGF0IGRvZXMgbm90IGNoZGlyIGFyb3VuZC4KIAogICogImdpdCBhZGQgLXAiIHdlcmUgdXBkYXRlZCBpbiAyLjEyIHRpbWVmcmFtZSB0byBjb3BlIHdpdGggY3VzdG9tCkBAIC0zNSw3ICszNSw3IEBACiAgKiBGaXggYSByZWNlbnQgcmVncmVzc2lvbiB0byAiZ2l0IHJlYmFzZSAtaSIgYW5kIGFkZCB0ZXN0cyB0aGF0IHdvdWxkCiAgICBoYXZlIGNhdWdodCBpdCBhbmQgb3RoZXJzLgogCi0gKiBBbiB1bmFsaWduZWQgMzItYml0IGFjY2VzcyBpbiBwYWNrLWJpdG1hcCBjb2RlIGFocyBiZWVuIGNvcnJlY3RlZC4KKyAqIEFuIHVuYWxpZ25lZCAzMi1iaXQgYWNjZXNzIGluIHBhY2stYml0bWFwIGNvZGUgaGFzIGJlZW4gY29ycmVjdGVkLgogCiAgKiBUaWdodGVuIGVycm9yIGNoZWNrcyBmb3IgaW52YWxpZCAiZ2l0IGFwcGx5IiBpbnB1dC4KIApkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9SZWxOb3Rlcy8yLjE0LjAudHh0IGIvRG9jdW1lbnRhdGlvbi9SZWxOb3Rlcy8yLjE0LjAudHh0CmluZGV4IDQyNDZjNjguLjI3MTFhMjUgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vUmVsTm90ZXMvMi4xNC4wLnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL1JlbE5vdGVzLzIuMTQuMC50eHQKQEAgLTE0MSw3ICsxNDEsNyBAQAogICogU29tZSBwbGF0Zm9ybXMgaGF2ZSB1bG9uZyB0aGF0IGlzIHNtYWxsZXIgdGhhbiB0aW1lX3QsIGFuZCBvdXIKICAgIGhpc3RvcmljYWwgdXNlIG9mIHVsb25nIGZvciB0aW1lc3RhbXAgd291bGQgbWVhbiB0aGV5IGNhbm5vdAogICAgcmVwcmVzZW50IHNvbWUgdGltZXN0YW1wIHRoYXQgdGhlIHBsYXRmb3JtIGFsbG93cy4gIEludmVudCBhCi0gICBzZXBhcmF0ZSBhbmQgZGVkaWNhdGVkIHRpbWVzdGFtcF90IChzbyB0aGF0IHdlIGNhbiBkaXN0aW5naXVpc2gKKyAgIHNlcGFyYXRlIGFuZCBkZWRpY2F0ZWQgdGltZXN0YW1wX3QgKHNvIHRoYXQgd2UgY2FuIGRpc3Rpbmd1aXNoCiAgICB0aW1lc3RhbXBzIGFuZCBhIHZhbmlsbGEgdWxvbmdzLCB3aGljaCBhbG9uZyBpcyBhbHJlYWR5IGEgZ29vZAogICAgbW92ZSksIGFuZCB0aGVuIGRlY2xhcmUgdWludG1heF90IGlzIHRoZSB0eXBlIHRvIGJlIHVzZWQgYXMgdGhlCiAgICB0aW1lc3RhbXBfdC4KQEAgLTQ0Miw3ICs0NDIsNyBAQAogICogVGhlIGNvZGUgdG8gcGljayB1cCBhbmQgZXhlY3V0ZSBjb21tYW5kIGFsaWFzIGRlZmluaXRpb24gZnJvbSB0aGUKICAgIGNvbmZpZ3VyYXRpb24gdXNlZCB0byBzd2l0Y2ggdG8gdGhlIHRvcCBvZiB0aGUgd29ya2luZyB0cmVlIGFuZAogICAgdGhlbiBjb21lIGJhY2sgd2hlbiB0aGUgZXhwYW5kZWQgYWxpYXMgd2FzIGV4ZWN1dGVkLCB3aGljaCB3YXMKLSAgIHVubmVjZXNzYXJpbHlsIGNvbXBsZXguICBBdHRlbXB0IHRvIHNpbXBsaWZ5IHRoZSBsb2dpYyBieSB1c2luZyB0aGUKKyAgIHVubmVjZXNzYXJpbHkgY29tcGxleC4gIEF0dGVtcHQgdG8gc2ltcGxpZnkgdGhlIGxvZ2ljIGJ5IHVzaW5nIHRoZQogICAgZWFybHktY29uZmlnIG1lY2hhbmlzbSB0aGF0IGRvZXMgbm90IGNoZGlyIGFyb3VuZC4KIAogICogRml4IGNvbmZpZ3VyYXRpb24gY29kZXBhdGggdG8gcGF5IHByb3BlciBhdHRlbnRpb24gdG8gY29tbW9uZGlyCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL1JlbE5vdGVzLzIuMTYuMC50eHQgYi9Eb2N1bWVudGF0aW9uL1JlbE5vdGVzLzIuMTYuMC50eHQKaW5kZXggMGM4MWM1OS4uYjQ3NDc4MSAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9SZWxOb3Rlcy8yLjE2LjAudHh0CisrKyBiL0RvY3VtZW50YXRpb24vUmVsTm90ZXMvMi4xNi4wLnR4dApAQCAtNDA3LDcgKzQwNyw3IEBACiAgICAobWVyZ2UgZWVmM2RmNWE5MyBidy9wYXRoc3BlYy1tYXRjaC1zdWJtb2R1bGUtYm91bmRhcnkgbGF0ZXIgdG8gbWFpbnQpLgogCiAgKiBBbWVuZGluZyBjb21taXRzIGluIGdpdC1ndWkgYnJva2UgdGhlIGF1dGhvciBuYW1lIHRoYXQgaXMgbm9uLWFzY2lpCi0gICBkdWUgdG8gaW5jb3JyZWN0IGVuY29uZGluZyBjb252ZXJzaW9uLgorICAgZHVlIHRvIGluY29ycmVjdCBlbmNvZGluZyBjb252ZXJzaW9uLgogCiAgKiBSZWNlbnQgdXBkYXRlIHRvIHRoZSBzdWJtb2R1bGUgY29uZmlndXJhdGlvbiBjb2RlIGJyb2tlICJkaWZmLXRyZWUiCiAgICBieSBhY2NpZGVudGFsbHkgc3RvcHBpbmcgdG8gcmVhZCBmcm9tIHRoZSBpbmRleCB1cGZyb250LgpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9SZWxOb3Rlcy8yLjE2LjMudHh0IGIvRG9jdW1lbnRhdGlvbi9SZWxOb3Rlcy8yLjE2LjMudHh0CmluZGV4IDY0YTBiY2IuLmYwMTIxYTggMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vUmVsTm90ZXMvMi4xNi4zLnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL1JlbE5vdGVzLzIuMTYuMy50eHQKQEAgLTI0LDcgKzI0LDcgQEAKIAogICogVGhlIGh0dHAgdHJhY2luZyBjb2RlLCBvZnRlbiB1c2VkIHRvIGRlYnVnIGNvbm5lY3Rpb24gaXNzdWVzLAogICAgbGVhcm5lZCB0byByZWRhY3QgcG90ZW50aWFsbHkgc2Vuc2l0aXZlIGluZm9ybWF0aW9uIGZyb20gaXRzIG91dHB1dAotICAgc28gdGhhdCBpdCBjYW4gYmUgbW9yZSBzYWZlbHkgc2hhcmFibGUuCisgICBzbyB0aGF0IGl0IGNhbiBiZSBtb3JlIHNhZmVseSBzaGFyZWFibGUuCiAKICAqIENyYXNoIGZpeCBmb3IgYSBjb3JuZXIgY2FzZSB3aGVyZSBhbiBlcnJvciBjb2RlcGF0aCB0cmllZCB0byB1bmxvY2sKICAgIHdoYXQgaXQgZGlkIG5vdCBhY3F1aXJlIGxvY2sgb24uCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL1JlbE5vdGVzLzIuMTcuMC50eHQgYi9Eb2N1bWVudGF0aW9uL1JlbE5vdGVzLzIuMTcuMC50eHQKaW5kZXggYzJjZjg5MS4uOGIxN2MyNiAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9SZWxOb3Rlcy8yLjE3LjAudHh0CisrKyBiL0RvY3VtZW50YXRpb24vUmVsTm90ZXMvMi4xNy4wLnR4dApAQCAtMjE2LDcgKzIxNiw3IEBACiAKICAqIFRoZSBodHRwIHRyYWNpbmcgY29kZSwgb2Z0ZW4gdXNlZCB0byBkZWJ1ZyBjb25uZWN0aW9uIGlzc3VlcywKICAgIGxlYXJuZWQgdG8gcmVkYWN0IHBvdGVudGlhbGx5IHNlbnNpdGl2ZSBpbmZvcm1hdGlvbiBmcm9tIGl0cyBvdXRwdXQKLSAgIHNvIHRoYXQgaXQgY2FuIGJlIG1vcmUgc2FmZWx5IHNoYXJhYmxlLgorICAgc28gdGhhdCBpdCBjYW4gYmUgbW9yZSBzYWZlbHkgc2hhcmVhYmxlLgogICAgKG1lcmdlIDhiYTE4ZTZmYTQganQvaHR0cC1yZWRhY3QtY29va2llcyBsYXRlciB0byBtYWludCkuCiAKICAqIENyYXNoIGZpeCBmb3IgYSBjb3JuZXIgY2FzZSB3aGVyZSBhbiBlcnJvciBjb2RlcGF0aCB0cmllZCB0byB1bmxvY2sKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vUmVsTm90ZXMvMi4xOC4wLnR4dCBiL0RvY3VtZW50YXRpb24vUmVsTm90ZXMvMi4xOC4wLnR4dAppbmRleCAzZWEyODBjLi42YzhhMGU5IDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL1JlbE5vdGVzLzIuMTguMC50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9SZWxOb3Rlcy8yLjE4LjAudHh0CkBAIC0xNzksNyArMTc5LDcgQEAKICAgIChtZXJnZSAwMGEzZGEyYTEzIG5kL3JlbW92ZS1pZ25vcmUtZW52LWZpZWxkIGxhdGVyIHRvIG1haW50KS4KIAogICogQ29kZSB0byBmaW5kIHRoZSBsZW5ndGggdG8gdW5pcXVlbHkgYWJicmV2aWF0ZSBvYmplY3QgbmFtZXMgYmFzZWQKLSAgIG9uIHBhY2tmaWxlIGNvbnRlbnQsIHdoaWNoIGlzIGEgcmVsYXRpdmVseSByZWNlbnQgYWRkdGlvbiwgaGFzIGJlZW4KKyAgIG9uIHBhY2tmaWxlIGNvbnRlbnQsIHdoaWNoIGlzIGEgcmVsYXRpdmVseSByZWNlbnQgYWRkaXRpb24sIGhhcyBiZWVuCiAgICBvcHRpbWl6ZWQgdG8gdXNlIHRoZSBzYW1lIGZhbi1vdXQgdGFibGUuCiAKICAqIFRoZSBtZWNoYW5pc20gdG8gdXNlIHBhcnNlLW9wdGlvbnMgQVBJIHRvIGF1dG9tYXRlIHRoZSBjb21tYW5kIGxpbmUKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vUmVsTm90ZXMvMi4xOS4wLnR4dCBiL0RvY3VtZW50YXRpb24vUmVsTm90ZXMvMi4xOS4wLnR4dAppbmRleCBhMDZjY2Y2Li44OTFjNzliIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL1JlbE5vdGVzLzIuMTkuMC50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9SZWxOb3Rlcy8yLjE5LjAudHh0CkBAIC0xMDYsNyArMTA2LDcgQEAKICAqIFRoZSBjb252ZXJzaW9uIHRvIHBhc3MgInRoZV9yZXBvc2l0b3J5IiBhbmQgdGhlbiAiYV9yZXBvc2l0b3J5IgogICAgdGhyb3VnaG91dCB0aGUgb2JqZWN0IGFjY2VzcyBBUEkgY29udGludWVzLgogCi0gKiBDb250aW51aW5nIHdpdGggdGhlIGlkZWEgdG8gcHJvZ3JhbWF0aWNhbGx5IGVudW1lcmF0ZSB2YXJpb3VzCisgKiBDb250aW51aW5nIHdpdGggdGhlIGlkZWEgdG8gcHJvZ3JhbW1hdGljYWxseSBlbnVtZXJhdGUgdmFyaW91cwogICAgcGllY2VzIG9mIGRhdGEgcmVxdWlyZWQgZm9yIGNvbW1hbmQgbGluZSBjb21wbGV0aW9uLCB0ZWFjaCB0aGUKICAgIGNvZGViYXNlIHRvIHJlcG9ydCB0aGUgbGlzdCBvZiBjb25maWd1cmF0aW9uIHZhcmlhYmxlcwogICAgc3ViY29tbWFuZHMgY2FyZSBhYm91dCB0byBoZWxwIGNvbXBsZXRlIHRoZW0uCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL1JlbE5vdGVzLzIuMjAuMC50eHQgYi9Eb2N1bWVudGF0aW9uL1JlbE5vdGVzLzIuMjAuMC50eHQKaW5kZXggZTcxZmUzZC4uM2RkN2U2ZSAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9SZWxOb3Rlcy8yLjIwLjAudHh0CisrKyBiL0RvY3VtZW50YXRpb24vUmVsTm90ZXMvMi4yMC4wLnR4dApAQCAtMTE5LDcgKzExOSw3IEBACiAgICBhbGlhcyBleHBhbnNpb24uCiAKICAqIFRoZSBkb2N1bWVudGF0aW9uIG9mICJnaXQgZ2MiIGhhcyBiZWVuIHVwZGF0ZWQgdG8gbWVudGlvbiB0aGF0IGl0Ci0gICBpcyBubyBsb25nZXIgbGltaXRlZCB0byAicHJ1bmluZyBhd2F5IGNydWZ0cyIgYnV0IGFsc28gdXBkYXRlcworICAgaXMgbm8gbG9uZ2VyIGxpbWl0ZWQgdG8gInBydW5pbmcgYXdheSBjcnVmdCIgYnV0IGFsc28gdXBkYXRlcwogICAgYW5jaWxsYXJ5IGZpbGVzIGxpa2UgY29tbWl0LWdyYXBoIGFzIGEgcGFydCBvZiByZXBvc2l0b3J5CiAgICBvcHRpbWl6YXRpb24uCiAKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vUmVsTm90ZXMvMi4yNC4wLnR4dCBiL0RvY3VtZW50YXRpb24vUmVsTm90ZXMvMi4yNC4wLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5iZGUxNTQxCi0tLSAvZGV2L251bGwKKysrIGIvRG9jdW1lbnRhdGlvbi9SZWxOb3Rlcy8yLjI0LjAudHh0CkBAIC0wLDAgKzEsMzk4IEBACitHaXQgMi4yNCBSZWxlYXNlIE5vdGVzCis9PT09PT09PT09PT09PT09PT09PT09CisKK1VwZGF0ZXMgc2luY2UgdjIuMjMKKy0tLS0tLS0tLS0tLS0tLS0tLS0KKworQmFja3dhcmQgY29tcGF0aWJpbGl0eSBub3RlCisKKyAqICJmaWx0ZXItYnJhbmNoIiBpcyBzaG93aW5nIGl0cyBhZ2UgYW5kIGFsdGVybmF0aXZlcyBhcmUgYXZhaWxhYmxlLgorICAgRnJvbSB0aGlzIHJlbGVhc2UsIHdlIHN0YXJ0ZWQgdG8gZGlzY291cmFnZSBpdHMgdXNlIGFuZCBoaW50CisgICBwZW9wbGUgYWJvdXQgZmlsdGVyLXJlcG8uCisKK1VJLCBXb3JrZmxvd3MgJiBGZWF0dXJlcworCisgKiBXZSBub3cgaGF2ZSBhbiBhY3RpdmUgaW50ZXJpbSBtYWludGFpbmVyIGZvciB0aGUgR2l0LUd1aSBwYXJ0IG9mCisgICB0aGUgc3lzdGVtLiAgUHJhaXNlIGFuZCB0aGFuayBQcmF0eXVzaCBZYWRhdiBmb3Igdm9sdW50ZWVyaW5nLgorCisgKiBUaGUgY29tbWFuZCBsaW5lIHBhcnNlciBsZWFybmVkICItLWVuZC1vZi1vcHRpb25zIiBub3RhdGlvbjsgdGhlCisgICBzdGFuZGFyZCBjb252ZW50aW9uIGZvciBzY3JpcHRlcnMgdG8gaGF2ZSBoYXJkY29kZWQgc2V0IG9mIG9wdGlvbnMKKyAgIGZpcnN0IG9uIHRoZSBjb21tYW5kIGxpbmUsIGFuZCBmb3JjZSB0aGUgY29tbWFuZCB0byB0cmVhdCBlbmQtdXNlcgorICAgaW5wdXQgYXMgbm9uLW9wdGlvbnMsIGhhcyBiZWVuIHRvIHVzZSAiLS0iIGFzIHRoZSBkZWxpbWl0ZXIsIGJ1dAorICAgdGhhdCB3b3VsZCBub3Qgd29yayBmb3IgY29tbWFuZHMgdGhhdCB1c2UgIi0tIiBhcyBhIGRlbGltaXRlcgorICAgYmV0d2VlbiByZXZzIGFuZCBwYXRoc3BlYy4KKworICogQSBtZWNoYW5pc20gdG8gYWZmZWN0IHRoZSBkZWZhdWx0IHNldHRpbmcgZm9yIGEgKHJlbGF0ZWQpIGdyb3VwIG9mCisgICBjb25maWd1cmF0aW9uIHZhcmlhYmxlcyBpcyBpbnRyb2R1Y2VkLgorCisgKiAiZ2l0IGZldGNoIiBsZWFybmVkICItLXNldC11cHN0cmVhbSIgb3B0aW9uIHRvIGhlbHAgdGhvc2Ugd2hvIGZpcnN0CisgICBjbG9uZSBmcm9tIHRoZWlyIHByaXZhdGUgZm9yayB0aGV5IGludGVuZCB0byBwdXNoIHRvLCBhZGQgdGhlIHRydWUKKyAgIHVwc3RyZWFtIHZpYSAiZ2l0IHJlbW90ZSBhZGQiIGFuZCB0aGVuICJnaXQgZmV0Y2giIGZyb20gaXQuCisKKyAqIERldmljZS10cmVlIGZpbGVzIGxlYXJuZWQgdGhlaXIgb3duIHVzZXJkaWZmIHBhdHRlcm5zLgorICAgKG1lcmdlIDNjODE3NjBiYzYgc2IvdXNlcmRpZmYtZHRzIGxhdGVyIHRvIG1haW50KS4KKworICogImdpdCByZWJhc2UgLS1yZWJhc2UtbWVyZ2VzIiBsZWFybmVkIHRvIGRyaXZlIGRpZmZlcmVudCBtZXJnZQorICAgc3RyYXRlZ2llcyBhbmQgcGFzcyBzdHJhdGVneSBzcGVjaWZpYyBvcHRpb25zIHRvIHRoZW0uCisKKyAqIEEgbmV3ICJwcmUtbWVyZ2UtY29tbWl0IiBob29rIGhhcyBiZWVuIGludHJvZHVjZWQuCisKKyAqIENvbW1hbmQgbGluZSBjb21wbGV0aW9uIHVwZGF0ZXMgZm9yICJnaXQgLWMgdmFyLm5hbWU9dmFsIiBoYXZlIGJlZW4KKyAgIGFkZGVkLgorCisgKiBUaGUgbGF6eSBjbG9uZSBtYWNoaW5lcnkgaGFzIGJlZW4gdGF1Z2h0IHRoYXQgdGhlcmUgY2FuIGJlIG1vcmUKKyAgIHRoYW4gb25lIHByb21pc29yIHJlbW90ZSBhbmQgY29uc3VsdCB0aGVtIGluIG9yZGVyIHdoZW4gZG93bmxvYWRpbmcKKyAgIG1pc3Npbmcgb2JqZWN0cyBvbiBkZW1hbmQuCisKKyAqIFRoZSBsaXN0LW9iamVjdHMtZmlsdGVyIEFQSSAodXNlZCB0byBjcmVhdGUgYSBzcGFyc2UvbGF6eSBjbG9uZSkKKyAgIGxlYXJuZWQgdG8gdGFrZSBhIGNvbWJpbmVkIGZpbHRlciBzcGVjaWZpY2F0aW9uLgorCisgKiBUaGUgZG9jdW1lbnRhdGlvbiBhbmQgdGVzdHMgZm9yICJnaXQgZm9ybWF0LXBhdGNoIiBoYXZlIGJlZW4KKyAgIGNsZWFuZWQgdXAuCisKKyAqIE9uIFdpbmRvd3MsIHRoZSByb290IGxldmVsIG9mIFVOQyBzaGFyZSBpcyBub3cgYWxsb3dlZCB0byBiZSB1c2VkCisgICBqdXN0IGxpa2UgYW55IG90aGVyIGRpcmVjdG9yeS4KKworICogVGhlIGNvbW1hbmQgbGluZSBjb21wbGV0aW9uIHN1cHBvcnQgKGluIGNvbnRyaWIvKSBsZWFybmVkIGFib3V0IHRoZQorICAgIi0tc2tpcCIgb3B0aW9uIG9mICJnaXQgcmV2ZXJ0IiBhbmQgImdpdCBjaGVycnktcGljayIuCisKKyAqICJnaXQgcmViYXNlIC0ta2VlcC1iYXNlIDx1cHN0cmVhbT4iIHRyaWVzIHRvIGZpbmQgdGhlIG9yaWdpbmFsIGJhc2UKKyAgIG9mIHRoZSB0b3BpYyBiZWluZyByZWJhc2VkIGFuZCByZWJhc2Ugb24gdG9wIG9mIHRoYXQgc2FtZSBiYXNlLAorICAgd2hpY2ggaXMgdXNlZnVsIHdoZW4gcnVubmluZyB0aGUgImdpdCByZWJhc2UgLWkiIChhbmQgaXRzIGxpbWl0ZWQKKyAgIHZhcmlhbnQgImdpdCByZWJhc2UgLXgiKS4KKworICAgVGhlIGNvbW1hbmQgYWxzbyBoYXMgbGVhcm5lZCB0byBmYXN0LWZvcndhcmQgaW4gbW9yZSBjYXNlcyB3aGVyZSBpdAorICAgY2FuIGluc3RlYWQgb2YgcmVwbGF5aW5nIHRvIHJlY3JlYXRlIGlkZW50aWNhbCBjb21taXRzLgorCisgKiBBIGNvbmZpZ3VyYXRpb24gdmFyaWFibGUgdGVsbHMgImdpdCBmZXRjaCIgdG8gd3JpdGUgdGhlIGNvbW1pdAorICAgZ3JhcGggYWZ0ZXIgZmluaXNoaW5nLgorCisgKiAiZ2l0IGFkZCAtaSIgaGFzIGJlZW4gdGF1Z2h0IHRvIHNob3cgdGhlIHRvdGFsIG51bWJlciBvZiBodW5rcyBhbmQKKyAgIHRoZSBodW5rcyB0aGF0IGhhcyBiZWVuIHByb2Nlc3NlZCBzbyBmYXIgd2hlbiBzaG93aW5nIHByb21wdHMuCisKKyAqICJnaXQgZmV0Y2ggLS1qb2JzPTxuPiIgYWxsb3dlZCA8bj4gcGFyYWxsZWwgam9icyB3aGVuIGZldGNoaW5nCisgICBzdWJtb2R1bGVzLCBidXQgdGhpcyBkaWQgbm90IGFwcGx5IHRvICJnaXQgZmV0Y2ggLS1tdWx0aXBsZSIgdGhhdAorICAgZmV0Y2hlcyBmcm9tIG11bHRpcGxlIHJlbW90ZSByZXBvc2l0b3JpZXMuICBJdCBub3cgZG9lcy4KKworICogVGhlIGluc3RhbGxhdGlvbiBpbnN0cnVjdGlvbiBmb3IgenNoIGNvbXBsZXRpb24gc2NyaXB0IChpbgorICAgY29udHJpYi8pIGhhcyBiZWVuIGEgYml0IGltcHJvdmVkLgorCisKK1BlcmZvcm1hbmNlLCBJbnRlcm5hbCBJbXBsZW1lbnRhdGlvbiwgRGV2ZWxvcG1lbnQgU3VwcG9ydCBldGMuCisKKyAqIFRoZSBjb2RlIHRvIHdyaXRlIGNvbW1pdC1ncmFwaCBvdmVyIGdpdmVuIGNvbW1pdCBvYmplY3QgbmFtZXMgaGFzCisgICBiZWVuIG1hZGUgYSBiaXQgbW9yZSByb2J1c3QuCisKKyAqIFRoZSBmaXJzdCBsaW5lIG9mIHZlcmJvc2Ugb3V0cHV0IGZyb20gZWFjaCB0ZXN0IHBpZWNlIG5vdyBjYXJyaWVzCisgICB0aGUgdGVzdCBuYW1lIGFuZCBudW1iZXIgdG8gaGVscCBzY2FubmluZyB3aXRoIGV5ZWJhbGxzLgorCisgKiBGdXJ0aGVyIGNsZWFuLXVwIG9mIHRoZSBpbml0aWFsaXphdGlvbiBjb2RlLgorCisgKiB4bWFsbG9jKCkgdXNlZCB0byBoYXZlIGEgbWVjaGFuaXNtIHRvIGRpdGNoIG1lbW9yeSBhbmQgYWRkcmVzcworICAgc3BhY2UgcmVzb3VyY2VzIGFzIHRoZSBsYXN0IHJlc29ydCB1cG9uIHNlZWluZyBhbiBhbGxvY2F0aW9uCisgICBmYWlsdXJlIGZyb20gdGhlIHVuZGVybHlpbmcgbWFsbG9jKCksIHdoaWNoIG1hZGUgdGhlIGNvZGUgY29tcGxleAorICAgYW5kIHRocmVhZC11bnNhZmUgd2l0aCBkdWJpb3VzIGJlbmVmaXQsIGFzIG1ham9yIG1lbW9yeSByZXNvdXJjZQorICAgdXNlcnMgYWxyZWFkeSBkbyBsaW1pdCB0aGVpciB1c2VzIHdpdGggdmFyaW91cyBvdGhlciBtZWNoYW5pc21zLgorICAgSXQgaGFzIGJlZW4gc2ltcGxpZmllZCBhd2F5LgorCisgKiBVbm5lY2Vzc2FyeSBmdWxsLXRyZWUgZGlmZiBpbiAiZ2l0IGxvZyAtTCIgbWFjaGluZXJ5IGhhcyBiZWVuCisgICBvcHRpbWl6ZWQgYXdheS4KKworICogVGhlIGh0dHAgdHJhbnNwb3J0IGxhY2tlZCBzb21lIG9wdGltaXphdGlvbiB0aGUgbmF0aXZlIHRyYW5zcG9ydHMKKyAgIGxlYXJuZWQgdG8gYXZvaWQgdW5uZWNlc3NhcnkgcmVmIGFkdmVydGlzZW1lbnQsIHdoaWNoIGhhcyBiZWVuCisgICBjb3JyZWN0ZWQuCisKKyAqIFByZXBhcmF0aW9uIGZvciBTSEEtMjU2IHVwZ3JhZGUgY29udGludWVzIGluIHRoZSB0ZXN0IGRlcGFydG1lbnQuCisgICAobWVyZ2UgMGMzN2M0MWQxMyBiYy9oYXNoLWluZGVwZW5kZW50LXRlc3RzLXBhcnQtNSBsYXRlciB0byBtYWludCkuCisKKyAqIFRoZSBtZW1vcnkgb3duZXJzaGlwIG1vZGVsIG9mIHRoZSAiZ2l0IGZhc3QtaW1wb3J0IiBnb3QKKyAgIHN0cmFpZ2h0ZW5lZCBvdXQuCisKKyAqIE91dHB1dCBmcm9tIHRyYWNlMiBzdWJzeXN0ZW0gaXMgZm9ybWF0dGVkIG1vcmUgcHJldHRpbHkgbm93LgorCisgKiBUaGUgaW50ZXJuYWwgY29kZSBvcmlnaW5hbGx5IGludmVudGVkIGZvciAiLmdpdGlnbm9yZSIgcHJvY2Vzc2luZworICAgZ290IHJlc2h1ZmZsZWQgYW5kIHJlbmFtZWQgdG8gbWFrZSBpdCBsZXNzIHRpZWQgdG8gImV4Y2x1ZGluZyIgYW5kCisgICBzdHJlc3MgbW9yZSB0aGF0IGl0IGlzIGFib3V0ICJtYXRjaGluZyIsIGFzIGl0IGhhcyBiZWVuIHJldXNlZCBmb3IKKyAgIHRoaW5ncyBsaWtlIHNwYXJzZSBjaGVja291dCBzcGVjaWZpY2F0aW9uIHRoYXQgd2FudCB0byBjaGVjayBpZiBhCisgICBwYXRoIGlzICJpbmNsdWRlZCIuCisKKyAqICJnaXQgc3Rhc2giIGxlYXJuZWQgdG8gd3JpdGUgcmVmcmVzaGVkIGluZGV4IGJhY2sgdG8gZGlzay4KKworICogQ29jY2luZWxsZSBjaGVja3MgYXJlIGRvbmUgb24gbW9yZSBzb3VyY2UgZmlsZXMgdGhhbiBiZWZvcmUgbm93LgorCisgKiBUaGUgY2FjaGUtdHJlZSBjb2RlIGhhcyBiZWVuIHRhdWdodCB0byBiZSBsZXNzIGFnZ3Jlc3NpdmUgaW4KKyAgIGF0dGVtcHRpbmcgdG8gc2VlIGlmIGEgdHJlZSBvYmplY3QgaXQgY29tcHV0ZWQgYWxyZWFkeSBleGlzdHMgaW4KKyAgIHRoZSByZXBvc2l0b3J5LgorCisgKiBUaGUgY29kZSB0byBwYXJzZSBhbmQgdXNlIHRoZSBjb21taXQtZ3JhcGggZmlsZSBoYXMgYmVlbiBtYWRlIG1vcmUKKyAgIHJvYnVzdCBhZ2FpbnN0IGNvcnJ1cHRlZCBpbnB1dC4KKworICogVGhlIGhnLXRvLWdpdCBzY3JpcHQgKGluIGNvbnRyaWIvKSBoYXMgYmVlbiB1cGRhdGVkIHRvIHdvcmsgd2l0aAorICAgUHl0aG9uIDMuCisKKyAqIFVwZGF0ZSB0aGUgd2F5IGJ1aWxkIGFydGlmYWN0cyBpbiB0L2hlbHBlci8gZGlyZWN0b3J5IGFyZSBpZ25vcmVkLgorCisgKiBQcmVwYXJhdGlvbiBmb3IgU0hBLTI1NiB1cGdyYWRlIGNvbnRpbnVlcy4KKworICogImdpdCBsb2cgLS1ncmFwaCIgZm9yIGFuIG9jdG9wdXMgbWVyZ2UgaXMgc29tZXRpbWVzIGNvbG9yZWQKKyAgIGluY29ycmVjdGx5LCB3aGljaCBpcyBkZW1vbnN0cmF0ZWQgYW5kIGRvY3VtZW50ZWQgYnV0IG5vdCB5ZXQKKyAgIGZpeGVkLgorCisgKiBUaGUgdHJhY2UyIG91dHB1dCwgd2hlbiBzZW5kaW5nIHRoZW0gdG8gZmlsZXMgaW4gYSBkZXNpZ25hdGVkCisgICBkaXJlY3RvcnksIGNhbiBwb3B1bGF0ZSB0aGUgZGlyZWN0b3J5IHdpdGggdG9vIG1hbnkgZmlsZXM7IGEKKyAgIG1lY2hhbmlzbSBpcyBpbnRyb2R1Y2VkIHRvIHNldCB0aGUgbWF4aW11bSBudW1iZXIgb2YgZmlsZXMgYW5kCisgICBkaXNjYXJkIGZ1cnRoZXIgbG9ncyB3aGVuIHRoZSBtYXhpbXVtIGlzIHJlYWNoZWQuCisKKyAqIFdlIGhhdmUgYWRvcHRlZCBhIENvZGUtb2YtY29uZHVjdCBkb2N1bWVudC4KKyAgIChtZXJnZSAzZjllZjg3NGE3IGprL2NvYyBsYXRlciB0byBtYWludCkuCisKKworRml4ZXMgc2luY2UgdjIuMjMKKy0tLS0tLS0tLS0tLS0tLS0tCisKKyAqICJnaXQgZ3JlcCAtLXJlY3Vyc2Utc3VibW9kdWxlcyIgdGhhdCBsb29rcyBhdCB0aGUgd29ya2luZyB0cmVlCisgICBmaWxlcyBsb29rZWQgYXQgdGhlIGNvbnRlbnRzIGluIHRoZSBpbmRleCBpbiBzdWJtb2R1bGVzLCBpbnN0ZWFkIG9mCisgICBmaWxlcyBpbiB0aGUgd29ya2luZyB0cmVlLgorICAgKG1lcmdlIDZhMjg5ZDQ1YzAgbXQvZ3JlcC1zdWJtb2R1bGVzLXdvcmtpbmctdHJlZSBsYXRlciB0byBtYWludCkuCisKKyAqIENvZGVwYXRocyB0byB3YWxrIHRyZWUgb2JqZWN0cyBoYXZlIGJlZW4gYXVkaXRlZCBmb3IgaW50ZWdlcgorICAgb3ZlcmZsb3dzIGFuZCBoYXJkZW5lZC4KKyAgIChtZXJnZSA1YWEwMmY5ODY4IGprL3RyZWUtd2Fsay1vdmVyZmxvdyBsYXRlciB0byBtYWludCkuCisKKyAqICJnaXQgcGFjay1yZWZzIiBjYW4gbG9zZSByZWZzIHRoYXQgYXJlIGNyZWF0ZWQgd2hpbGUgcnVubmluZywgd2hpY2gKKyAgIGlzIGdldHRpbmcgY29ycmVjdGVkLgorICAgKG1lcmdlIGE2MTNkNGY4MTcgc2MvcGFjay1yZWZzLWRlbGV0aW9uLXJhY2VmaXggbGF0ZXIgdG8gbWFpbnQpLgorCisgKiAiZ2l0IGNoZWNrb3V0IiBhbmQgImdpdCByZXN0b3JlIiB0byByZS1wb3B1bGF0ZSB0aGUgaW5kZXggZnJvbSBhCisgICB0cmVlLWlzaCAodHlwaWNhbGx5IEhFQUQpIGRpZCBub3Qgd29yayBjb3JyZWN0bHkgZm9yIGEgcGF0aCB0aGF0CisgICB3YXMgcmVtb3ZlZCBhbmQgdGhlbiBhZGRlZCBhZ2FpbiB3aXRoIHRoZSBpbnRlbnQtdG8tYWRkIGJpdCwgd2hlbgorICAgdGhlIGNvcnJlc3BvbmRpbmcgd29ya2luZyB0cmVlIGZpbGUgd2FzIGVtcHR5LiAgVGhpcyBoYXMgYmVlbgorICAgY29ycmVjdGVkLgorCisgKiBDb21waWxhdGlvbiBmaXguCisgICAobWVyZ2UgNzA1OTdlODM4NiBycy9uZWRhbGxvYy1maXhsZXRzIGxhdGVyIHRvIG1haW50KS4KKworICogImdpdCBndWkiIGxlYXJuZWQgdG8gY2FsbCB0aGUgY2xlYW4tdXAgcHJvY2VkdXJlIGJlZm9yZSBleGl0aW5nLgorICAgKG1lcmdlIDBkODhmM2QyYzUgcHkvZ2l0LWd1aS1kby1xdWl0IGxhdGVyIHRvIG1haW50KS4KKworICogV2UgcHJvbW90ZWQgdGhlICJpbmRlbnQgaGV1cmlzdGljcyIgdGhhdCBkZWNpZGVzIHdoZXJlIHRvIHNwbGl0CisgICBkaWZmIGh1bmtzIGZyb20gZXhwZXJpbWVudGFsIHRvIHRoZSBkZWZhdWx0IGEgZmV3IHllYXJzIGFnbywgYnV0CisgICBzb21lIHN0YWxlIGRvY3VtZW50YXRpb24gc3RpbGwgbWFya2VkIGl0IGFzIGV4cGVyaW1lbnRhbCwgd2hpY2ggaGFzCisgICBiZWVuIGNvcnJlY3RlZC4KKyAgIChtZXJnZSA2NGU1ZTFmYmExIHNnL2RpZmYtaW5kZW50LWhldXJpc3RpYy1ub24tZXhwZXJpbWVudGFsIGxhdGVyIHRvIG1haW50KS4KKworICogRml4IGEgbWlzbWVyZ2UgdGhhdCBoYXBwZW5lZCBpbiAyLjIyIHRpbWVmcmFtZS4KKyAgIChtZXJnZSBhY2I3ZGEwNWFjIGVuL2NoZWNrb3V0LW1pc21lcmdlLWZpeCBsYXRlciB0byBtYWludCkuCisKKyAqICJnaXQgYXJjaGl2ZSIgcmVjb3JkZWQgaW5jb3JyZWN0IGxlbmd0aCBpbiBleHRlbmRlZCBwYXggaGVhZGVyIGluCisgICBzb21lIGNvcm5lciBjYXNlcywgd2hpY2ggaGFzIGJlZW4gY29ycmVjdGVkLgorICAgKG1lcmdlIDcxZDQxZmY2NTEgcnMvcGF4LWV4dGVuZGVkLWhlYWRlci1sZW5ndGgtZml4IGxhdGVyIHRvIG1haW50KS4KKworICogT24tZGVtYW5kIG9iamVjdCBmZXRjaGluZyBpbiBsYXp5IGNsb25lIGluY29ycmVjdGx5IHRyaWVkIHRvIGZldGNoCisgICBjb21taXRzIGZyb20gc3VibW9kdWxlIHByb2plY3RzLCB3aGlsZSBzdGlsbCB3b3JraW5nIGluIHRoZQorICAgc3VwZXJwcm9qZWN0LCB3aGljaCBoYXMgYmVlbiBjb3JyZWN0ZWQuCisgICAobWVyZ2UgYTYzNjk0ZjUyMyBqdC9kaWZmLWxhenktZmV0Y2gtc3VibW9kdWxlLWZpeCBsYXRlciB0byBtYWludCkuCisKKyAqIFByZXBhcmUgZ2V0X3Nob3J0X29pZCgpIGNvZGVwYXRoIHRvIGJlIHRocmVhZC1zYWZlLgorICAgKG1lcmdlIDdjZmNiMTZiMGUgcnMvc29ydC1vaWQtYXJyYXktdGhyZWFkLXNhZmUgbGF0ZXIgdG8gbWFpbnQpLgorCisgKiAiZm9yLWVhY2gtcmVmIiBhbmQgZnJpZW5kcyB0aGF0IHNob3cgcmVmcyBkaWQgbm90IHByb3RlY3QgdGhlbXNlbHZlcworICAgYWdhaW5zdCBhbmNpZW50IHRhZ3MgdGhhdCBkaWQgbm90IHJlY29yZCB0YWdnZXIgbmFtZXMgd2hlbiBhc2tlZCB0bworICAgc2hvdyAiJSh0YWdnZXJuYW1lKSIsIHdoaWNoIGhhdmUgYmVlbiBjb3JyZWN0ZWQuCisgICAobWVyZ2UgOGIzZjMzZWYxMSBtcC9mb3ItZWFjaC1yZWYtbWlzc2luZy1uYW1lLW9yLWVtYWlsIGxhdGVyIHRvIG1haW50KS4KKworICogVGhlICJnaXQgYW0iIGJhc2VkIGJhY2tlbmQgb2YgImdpdCByZWJhc2UiIGlnbm9yZWQgdGhlIHJlc3VsdCBvZgorICAgdXBkYXRpbmcgIi5naXRhdHRyaWJ1dGVzIiBkb25lIGluIG9uZSBzdGVwIHdoZW4gcmVwbGF5aW5nCisgICBzdWJzZXF1ZW50IHN0ZXBzLgorICAgKG1lcmdlIDJjNjVkOTBmNzUgYmMvcmVyZWFkLWF0dHJpYnV0ZXMtZHVyaW5nLXJlYmFzZSBsYXRlciB0byBtYWludCkuCisKKyAqIFRlbGwgY1VSTCBsaWJyYXJ5IHRvIHVzZSB0aGUgc2FtZSBtYWxsb2MoKSBpbXBsZW1lbnRhdGlvbiwgd2l0aCB0aGUKKyAgIHhtYWxsb2MoKSB3cmFwcGVyLCBhcyB0aGUgcmVzdCBvZiB0aGUgc3lzdGVtLCBmb3IgY29uc2lzdGVuY3kuCisgICAobWVyZ2UgOTNiOTgwZTU4ZiBjYi9jdXJsLXVzZS14bWFsbG9jIGxhdGVyIHRvIG1haW50KS4KKworICogQnVpbGQgZml4IHRvIGFkanVzdCAuZ2l0aWdub3JlIHRvIHVuaWdub3JlIGEgcGF0aCB0aGF0IHdlIHN0YXJ0ZWQgdG8gdHJhY2suCisgICAobWVyZ2UgYWFjNmZmN2I1YiBqcy92aXN1YWwtc3R1ZGlvIGxhdGVyIHRvIG1haW50KS4KKworICogQSBmZXcgaW1wbGVtZW50YXRpb24gZml4ZXMgaW4gdGhlIG5vdGVzIEFQSS4KKyAgIChtZXJnZSA2MGZlNDc3YTBiIG1oL25vdGVzLWR1cGxpY2F0ZS1lbnRyaWVzIGxhdGVyIHRvIG1haW50KS4KKworICogRml4IGFuIGVhcmxpZXIgcmVncmVzc2lvbiB0byAiZ2l0IHB1c2ggLS1hbGwiIHdoaWNoIHNob3VsZCBoYXZlCisgICBiZWVuIGZvcmJpZGRlbiB3aGVuIHRoZSB0YXJnZXQgcmVtb3RlIHJlcG9zaXRvcnkgaXMgc2V0IHRvIGJlIGEKKyAgIG1pcnJvci4KKyAgIChtZXJnZSA4ZTRjOGFmMDU4IHRnL3B1c2gtYWxsLWluLW1pcnJvci1mb3JiaWRkZW4gbGF0ZXIgdG8gbWFpbnQpLgorCisgKiBGaXggYW4gZWFybGllciByZWdyZXNzaW9uIGluIHRoZSB0ZXN0IHN1aXRlLCB3aGljaCBtaXN0YWtlbmx5CisgICBzdG9wcGVkIHJ1bm5pbmcgSFRUUEQgdGVzdHMuCisgICAobWVyZ2UgMzk2MDI5MDY3NSBzZy9naXQtdGVzdC1ib29sZWFuIGxhdGVyIHRvIG1haW50KS4KKworICogImdpdCByZWJhc2UgLS1hdXRvc3Rhc2ggPHVwc3RyZWFtPiA8YnJhbmNoPiIsIHdoZW4gPGJyYW5jaD4gaXMKKyAgIGRpZmZlcmVudCBmcm9tIHRoZSBjdXJyZW50IGJyYW5jaCwgaW5jb3JyZWN0bHkgbW92ZWQgdGhlIHRpcCBvZiB0aGUKKyAgIGN1cnJlbnQgYnJhbmNoLCB3aGljaCBoYXMgYmVlbiBjb3JyZWN0ZWQuCisgICAobWVyZ2UgYmYxZTI4ZTBhZCBidy9yZWJhc2UtYXV0b3N0YXNoLWtlZXAtY3VycmVudC1icmFuY2ggbGF0ZXIgdG8gbWFpbnQpLgorCisgKiBVcGRhdGUgc3VwcG9ydCBmb3IgQXNjaWlkb2N0b3IgZG9jdW1lbnRhdGlvbiB0b29sY2hhaW4uCisgICAobWVyZ2UgODNiMGI4OTUzZSBtYS9hc2NpaWRvY3Rvci1yZWZtaXNjaW5mbyBsYXRlciB0byBtYWludCkuCisKKyAqIFN0YXJ0IHVzaW5nIERvY0Jvb2sgNSAoaW5zdGVhZCBvZiBEb2NCb29rIDQuNSkgYXMgQXNjaWlkb2N0b3IgMi4wCisgICBubyBsb25nZXIgd29ya3Mgd2l0aCB0aGUgb2xkZXIgb25lLgorICAgKG1lcmdlIGY2NDYxYjgyYjkgYmMvZG9jLXVzZS1kb2Nib29rLTUgbGF0ZXIgdG8gbWFpbnQpLgorCisgKiBUaGUgbWFya3VwIHVzZWQgaW4gdXNlci1tYW51YWwgaGFzIGJlZW4gdXBkYXRlZCB0byB3b3JrIGJldHRlciB3aXRoCisgICBhc2NpaWRvY3Rvci4KKyAgIChtZXJnZSBjNGQyZjYxNDNhIG1hL3VzZXItbWFudWFsLW1hcmt1cC11cGRhdGUgbGF0ZXIgdG8gbWFpbnQpLgorCisgKiBNYWtlIHN1cmUgdGhlIGdyZXAgbWFjaGluZXJ5IGRvZXMgbm90IGFib3J0IHdoZW4gc2VlaW5nIGEgcGF5bG9hZAorICAgdGhhdCBpcyBub3QgVVRGLTggZXZlbiB3aGVuIEpJVCBpcyBub3QgaW4gdXNlIHdpdGggUENSRTEuCisgICAobWVyZ2UgYWQ3YzU0M2UzYiBjYi9za2lwLXV0ZjgtY2hlY2std2l0aC1wY3JlMSBsYXRlciB0byBtYWludCkuCisKKyAqIFRoZSBuYW1lIG9mIHRoZSBibG9iIG9iamVjdCB0aGF0IHN0b3JlcyB0aGUgZmlsdGVyIHNwZWNpZmljYXRpb24KKyAgIGZvciBzcGFyc2UgY2xvbmluZy9mZXRjaGluZyB3YXMgaW50ZXJwcmV0ZWQgaW4gYSB3cm9uZyBwbGFjZSBpbiB0aGUKKyAgIGNvZGUsIGNhdXNpbmcgR2l0IHRvIGFib3J0LgorCisgKiAiZ2l0IGxvZyAtLWRlY29yYXRlLXJlZnMtZXhjbHVkZT08cGF0dGVybj4iIHdhcyBpbmNvcnJlY3RseQorICAgb3ZlcnJ1bGVkIHdoZW4gdGhlICItLXNpbXBsaWZ5LWJ5LWRlY29yYXRpb24iIG9wdGlvbiBpcyB1c2VkLCB3aGljaAorICAgaGFzIGJlZW4gY29ycmVjdGVkLgorICAgKG1lcmdlIDBjYzczODBkODggcnMvc2ltcGxpZnktYnktZGVjby13aXRoLWRlY28tcmVmcy1leGNsdWRlIGxhdGVyIHRvIG1haW50KS4KKworICogVGhlICJ1cGxvYWQtcGFjayIgKHRoZSBjb3VudGVycGFydCBvZiAiZ2l0IGZldGNoIikgbmVlZHMgdG8gZGlzYWJsZQorICAgY29tbWl0LWdyYXBoIHdoZW4gcmVzcG9uZGluZyB0byBhIHNoYWxsb3cgY2xvbmUvZmV0Y2ggcmVxdWVzdCwgYnV0CisgICB0aGUgd2F5IHRoaXMgd2FzIGRvbmUgbWFkZSBHaXQgcGFuaWMsIHdoaWNoIGhhcyBiZWVuIGNvcnJlY3RlZC4KKworICogVGhlIG9iamVjdCB0cmF2ZXJzYWwgbWFjaGluZXJ5IGhhcyBiZWVuIG9wdGltaXplZCBub3QgdG8gbG9hZCB0cmVlCisgICBvYmplY3RzIHdoZW4gd2UgYXJlIG9ubHkgaW50ZXJlc3RlZCBpbiBjb21taXQgaGlzdG9yeS4KKyAgIChtZXJnZSA3MmVkODBjNzg0IGprL2xpc3Qtb2JqZWN0cy1vcHRpbS13by10cmVlcyBsYXRlciB0byBtYWludCkuCisKKyAqIFRoZSBvYmplY3QgbmFtZSBwYXJzZXIgZm9yICJOdGggcGFyZW50IiBzeW50YXggaGFzIGJlZW4gbWFkZSBtb3JlCisgICByb2J1c3QgYWdhaW5zdCBpbnRlZ2VyIG92ZXJmbG93cy4KKyAgIChtZXJnZSA1OWZhNWY1YTI1IHJzL250aC1wYXJlbnQtcGFyc2UgbGF0ZXIgdG8gbWFpbnQpLgorCisgKiBUaGUgY29kZSB1c2VkIGluIGZvbGxvd2luZyB0YWdzIGluICJnaXQgZmV0Y2giIGhhcyBiZWVuIG9wdGltaXplZC4KKyAgIChtZXJnZSBiN2UyZDhiY2E1IG1zL2ZldGNoLWZvbGxvdy10YWctb3B0aW0gbGF0ZXIgdG8gbWFpbnQpLgorCisgKiBSZWdyZXNzaW9uIGZpeCBmb3IgcHJvZ3Jlc3Mgb3V0cHV0LgorICAgKG1lcmdlIDJiYjc0YjUzYTQgc2cvcHJvZ3Jlc3MtZml4IGxhdGVyIHRvIG1haW50KS4KKworICogQSBidWcgaW4gbWVyZ2UtcmVjdXJzaXZlIGNvZGUgdGhhdCB0cmlnZ2VycyB3aGVuIGEgYnJhbmNoIHdpdGggYQorICAgc3ltYm9saWMgbGluayBpcyBtZXJnZWQgd2l0aCBhIGJyYW5jaCB0aGF0IHJlcGxhY2VzIGl0IHdpdGggYQorICAgZGlyZWN0b3J5IGhhcyBiZWVuIGZpeGVkLgorICAgKG1lcmdlIDgzZTNhZDNiMTIganQvbWVyZ2UtcmVjdXJzaXZlLXN5bWxpbmstaXMtbm90LWEtZGlyLWluLXdheSBsYXRlciB0byBtYWludCkuCisKKyAqIFRoZSByZW5hbWUgZGV0ZWN0aW9uIGxvZ2ljIHNvcnRzIGEgbGlzdCBvZiByZW5hbWUgc291cmNlIGNhbmRpZGF0ZXMKKyAgIGJ5IHNpbWlsYXJpdHkgdG8gcGljayB0aGUgYmVzdCBjYW5kaWRhdGUsIHdoaWNoIG1lYW5zIHRoYXQgYSB0aWUKKyAgIGJldHdlZW4gc291cmNlcyB3aXRoIHRoZSBzYW1lIHNpbWlsYXJpdHkgaXMgYnJva2VuIGJ5IHRoZSBvcmlnaW5hbAorICAgbG9jYXRpb24gaW4gdGhlIG9yaWdpbmFsIGNhbmRpZGF0ZSBsaXN0ICh3aGljaCBpcyBzb3J0ZWQgYnkgcGF0aCkuCisgICBGb3JjZSB0aGUgc29ydGluZyBieSBzaW1pbGFyaXR5IGRvbmUgd2l0aCBhIHN0YWJsZSBzb3J0LCB3aGljaCBpcworICAgbm90IHByb21pc2VkIGJ5IHN5c3RlbSBzdXBwbGllZCBxc29ydCgzKSwgdG8gZW5zdXJlIGNvbnNpc3RlbnQKKyAgIHJlc3VsdHMgYWNyb3NzIHBsYXRmb3Jtcy4KKyAgIChtZXJnZSAyMDQ5YjhkYzY1IGpzL2RpZmYtcmVuYW1lLWZvcmNlLXN0YWJsZS1zb3J0IGxhdGVyIHRvIG1haW50KS4KKworICogVGhlIGNvZGUgdG8gc2tpcCAiVVRGIiBhbmQgIlVURi0iIHByZWZpeCwgd2hlbiBjb21wdXRpbmcgYW4gYWR2aWNlCisgICBtZXNzYWdlLCBkaWQgbm90IHdvcmsgY29ycmVjdGx5IHdoZW4gdGhlIHByZWZpeCB3YXMgIlVURiIsIHdoaWNoCisgICBoYXMgYmVlbiBmaXhlZC4KKyAgIChtZXJnZSBiMTgxNjc2Y2U5IHJzL2NvbnZlcnQtZml4LXV0Zi13aXRob3V0LWRhc2ggbGF0ZXIgdG8gbWFpbnQpLgorCisgKiBUaGUgYXV0aG9yIG5hbWVzIHRha2VuIGZyb20gU1ZOIHJlcG9zaXRvcmllcyBtYXkgaGF2ZSBleHRyYSBsZWFkaW5nCisgICBvciB0cmFpbGluZyB3aGl0ZXNwYWNlcywgd2hpY2ggYXJlIG5vdyBtdW5nZWQgYXdheS4KKyAgIChtZXJnZSA0ZGRkNGJkZGIxIHRrL2dpdC1zdm4tdHJpbS1hdXRob3ItbmFtZSBsYXRlciB0byBtYWludCkuCisKKyAqICJnaXQgcmViYXNlIC1pIiBzaG93ZWQgYSB3cm9uZyBIRUFEIHdoaWxlICJyZXdvcmQiIG9wZW4gdGhlIGVkaXRvci4KKyAgIChtZXJnZSBiMGEzMTg2MTQwIHB3L3JlYmFzZS1pLXNob3ctSEVBRC10by1yZXdvcmQgbGF0ZXIgdG8gbWFpbnQpLgorCisgKiBBIGZldyBzaW1wbGlmaWNhdGlvbiBhbmQgYnVnZml4ZXMgdG8gUENSRSBpbnRlcmZhY2UuCisgICAobWVyZ2UgYzU4MWU0YTc0OSBhYi9wY3JlLWppdC1maXhlcyBsYXRlciB0byBtYWludCkuCisKKyAqIFBDUkUgZml4ZXMuCisgICAobWVyZ2UgZmY2MTY4MWI0NiBjYi9wY3JlMS1jbGVhbnVwIGxhdGVyIHRvIG1haW50KS4KKworICogImdpdCByYW5nZS1kaWZmIiBzZWdmYXVsdGVkIHdoZW4gZGlmZi5ub3ByZWZpeCBjb25maWd1cmF0aW9uIHdhcworICAgdXNlZCwgYXMgaXQgYmxpbmRseSBleHBlY3RlZCB0aGUgcGF0Y2ggaXQgaW50ZXJuYWxseSBnZW5lcmF0ZXMgdG8KKyAgIGhhdmUgdGhlIHN0YW5kYXJkIGEvIGFuZCBiLyBwcmVmaXhlcy4gIFRoZSBjb21tYW5kIG5vdyBmb3JjZXMgdGhlCisgICBpbnRlcm5hbCBwYXRjaCB0byBiZSBidWlsdCB3aXRob3V0IGFueSBwcmVmaXgsIG5vdCB0byBiZSBhZmZlY3RlZAorICAgYnkgYW55IGVuZC11c2VyIGNvbmZpZ3VyYXRpb24uCisgICAobWVyZ2UgOTM3Yjc2ZWQ0OSBqcy9yYW5nZS1kaWZmLW5vcHJlZml4IGxhdGVyIHRvIG1haW50KS4KKworICogImdpdCBzdGFzaCBhcHBseSIgaW4gYSBzdWJkaXJlY3Rvcnkgb2YgYSBzZWNvbmRhcnkgd29ya3RyZWUgZmFpbGVkCisgICB0byBhY2Nlc3MgdGhlIHdvcmt0cmVlIGNvcnJlY3RseSwgd2hpY2ggaGFzIGJlZW4gY29ycmVjdGVkLgorICAgKG1lcmdlIGRmZDU1N2M5NzgganMvc3Rhc2gtYXBwbHktaW4tc2Vjb25kYXJ5LXdvcmt0cmVlIGxhdGVyIHRvIG1haW50KS4KKworICogVGhlIG1lcmdlLXJlY3Vyc2l2ZSBtYWNoaW5lcnkgaXMgb25lIG9mIHRoZSBtb3N0IGNvbXBsZXggcGFydHMgb2YKKyAgIHRoZSBzeXN0ZW0gdGhhdCBhY2N1bXVsYXRlZCBjcnVmdCBvdmVyIHRpbWUuICBUaGlzIGxhcmdlIHNlcmllcworICAgY2xlYW5zIHVwIHRoZSBpbXBsZW1lbnRhdGlvbiBxdWl0ZSBhIGJpdC4KKyAgIChtZXJnZSBiNjU3MDQ3NzE5IGVuL21lcmdlLXJlY3Vyc2l2ZS1jbGVhbnVwIGxhdGVyIHRvIG1haW50KS4KKworICogUHJldHR5LXByaW50ZWQgY29tbWFuZCBsaW5lIGZvcm1hdHRlciAodXNlZCBpbiBlLmcuIHJlcG9ydGluZyB0aGUKKyAgIGNvbW1hbmQgYmVpbmcgcnVuIGJ5IHRoZSB0cmFjaW5nIEFQSSkgaGFkIGEgYnVnIHRoYXQgbG9zdCBhbgorICAgYXJndW1lbnQgdGhhdCBpcyBhbiBlbXB0eSBzdHJpbmcsIHdoaWNoIGhhcyBiZWVuIGNvcnJlY3RlZC4KKyAgIChtZXJnZSBjZTJkN2VkMmZkIGdzL3NxLXF1b3RlLWJ1Zi1wcmV0dHkgbGF0ZXIgdG8gbWFpbnQpLgorCisgKiAiZ2l0IHJhbmdlLWRpZmYiIGZhaWxlZCB0byBoYW5kbGUgbW9kZS1vbmx5IGNoYW5nZSwgd2hpY2ggaGFzIGJlZW4KKyAgIGNvcnJlY3RlZC4KKyAgIChtZXJnZSAyYjZhOWIxM2NhIHRnL3JhbmdlLWRpZmYtb3V0cHV0LXVwZGF0ZSBsYXRlciB0byBtYWludCkuCisKKyAqIERldiBzdXBwb3J0IHVwZGF0ZS4KKyAgIChtZXJnZSA0ZjNjMWRjNWQ2IGRsL2FsbG93LXJ1bm5pbmctY29jY2ktdmVyYm9zZWx5IGxhdGVyIHRvIG1haW50KS4KKworICogImdpdCBmb3JtYXQtcGF0Y2ggLW8gPG91dGRpcj4iIGRpZCBhbiBlcXVpdmFsZW50IG9mICJta2RpciA8b3V0ZGlyPiIKKyAgIG5vdCAibWtkaXIgLXAgPG91dGRpcj4iLCB3aGljaCB3YXMgY29ycmVjdGVkLgorCisgKiAiZ2l0IHN0YXNoIHNhdmUiIGxvc3QgbG9jYWwgY2hhbmdlcyB0byBzdWJtb2R1bGVzLCB3aGljaCBoYXMgYmVlbgorICAgY29ycmVjdGVkLgorICAgKG1lcmdlIDU1Njg5NWQwYzggamovc3Rhc2gtcmVzZXQtb25seS10b3BsZXZlbCBsYXRlciB0byBtYWludCkuCisKKyAqIFRoZSBhdG9taWMgcHVzaCBvdmVyIHNtYXJ0IEhUVFAgdHJhbnNwb3J0IGRpZCBub3Qgd29yaywgd2hpY2ggaGFzCisgICBiZWVuIGNvcnJlY3RlZC4KKyAgIChtZXJnZSA2ZjExOTQyNDZhIGJjL3NtYXJ0LWh0dHAtYXRvbWljLXB1c2ggbGF0ZXIgdG8gbWFpbnQpLgorCisgKiBPdGhlciBjb2RlIGNsZWFudXAsIGRvY2ZpeCwgYnVpbGQgZml4LCBldGMuCisgICAobWVyZ2UgZDEzODdkMzg5NSBlbi9mYXN0LWltcG9ydC1tZXJnZS1kb2MgbGF0ZXIgdG8gbWFpbnQpLgorICAgKG1lcmdlIDFjMjRhNTRlYTQgYm0vcmVwb3NpdG9yeS1sYXlvdXQtdHlwb2ZpeCBsYXRlciB0byBtYWludCkuCisgICAobWVyZ2UgNDE1Yjc3MGI4OCBkcy9taWR4LWV4cGlyZS1yZXBhY2sgbGF0ZXIgdG8gbWFpbnQpLgorICAgKG1lcmdlIDE5ODAwYmRjM2YgbmQvZGlmZi1wYXJzZW9wdCBsYXRlciB0byBtYWludCkuCisgICAobWVyZ2UgNTgxNjZjMmU5ZCB0Zy90MDAyMS1yYWNlZml4IGxhdGVyIHRvIG1haW50KS4KKyAgIChtZXJnZSA3MDI3ZjUwOGM3IGRsL2NvbXBhdC1jbGVhbnVwIGxhdGVyIHRvIG1haW50KS4KKyAgIChtZXJnZSBlNzcwZmJmZWZmIGpjL3Rlc3QtY2xlYW51cCBsYXRlciB0byBtYWludCkuCisgICAobWVyZ2UgMWZkODgxZDQwNCBycy90cmFjZTItZHN0LXdhcm5pbmcgbGF0ZXIgdG8gbWFpbnQpLgorICAgKG1lcmdlIDdlOTI3NTY3NTEgbWgvaHR0cC11cmxtYXRjaC1jbGVhbnVwIGxhdGVyIHRvIG1haW50KS4KKyAgIChtZXJnZSA5Nzg0Zjk3MzIxIG1oL3JlbGVhc2UtY29tbWl0LW1lbW9yeS1maXggbGF0ZXIgdG8gbWFpbnQpLgorICAgKG1lcmdlIDYwZDE5OGQwMjIgdGIvYmFubmVkLXZzcHJpbnRmLW5hbWVmaXggbGF0ZXIgdG8gbWFpbnQpLgorICAgKG1lcmdlIDgwZTM2NTg2NDcgcnMvaGVscC11bmtub3duLXJlZi1kb2VzLW5vdC1yZXR1cm4gbGF0ZXIgdG8gbWFpbnQpLgorICAgKG1lcmdlIDBhOGJjNzA2OGYgZHQvcmVtb3RlLWhlbHBlci1kb2MtcmUtbG9jay1vcHRpb24gbGF0ZXIgdG8gbWFpbnQpLgorICAgKG1lcmdlIDI3ZmQxZTRlYTcgZW4vbWVyZ2Utb3B0aW9ucy1mZi1hbmQtZnJpZW5kcyBsYXRlciB0byBtYWludCkuCisgICAobWVyZ2UgNTAyYzM4NmZmOSBzZy9jbGVhbi1uZXN0ZWQtcmVwby13aXRoLWlnbm9yZWQgbGF0ZXIgdG8gbWFpbnQpLgorICAgKG1lcmdlIDI2ZTNkMWNiZWEgYW0vbWFpbG1hcC1hbmRyZXktbWF6byBsYXRlciB0byBtYWludCkuCisgICAobWVyZ2UgNDdiMjdjOTZmYSBzcy9nZXQtdGltZS1jbGVhbnVwIGxhdGVyIHRvIG1haW50KS4KKyAgIChtZXJnZSBkZDJlNTBhODRlIGprL2NvbW1pdC1ncmFwaC1jbGVhbnVwIGxhdGVyIHRvIG1haW50KS4KKyAgIChtZXJnZSA0ZmQzOWM3NmU2IGNzL3ByZXR0eS1mb3JtYXRzLWRvYy10eXBvZml4IGxhdGVyIHRvIG1haW50KS4KKyAgIChtZXJnZSA0MGU3NDdlODlkIGRsL3N1Ym1vZHVsZS1zZXQtYnJhbmNoIGxhdGVyIHRvIG1haW50KS4KKyAgIChtZXJnZSA2ODlhMTQ2YzkxIHJzL2NvbW1pdC1ncmFwaC11c2UtbGlzdC1jb3VudCBsYXRlciB0byBtYWludCkuCisgICAobWVyZ2UgMGViN2MzN2E4YSBqcy9kb2MtcGF0Y2gtdGV4dCBsYXRlciB0byBtYWludCkuCisgICAobWVyZ2UgNGIzYWExNzBkMSBycy9udGgtc3dpdGNoLWNvZGUtc2ltcGxpZmljYXRpb24gbGF0ZXIgdG8gbWFpbnQpLgorICAgKG1lcmdlIDBkNDMwNGMxMjQgYWgvZG9jLXN1Ym1vZHVsZS1pZ25vcmUtc3VibW9kdWxlcyBsYXRlciB0byBtYWludCkuCisgICAobWVyZ2UgYWY3ODI0OTQ2MyBjYy9zdm4tZmUtcHktc2hlYmFuZyBsYXRlciB0byBtYWludCkuCisgICAobWVyZ2UgN2JkOTdkNmRmZiBycy9hbGlhcy11c2UtY29weS1hcnJheSBsYXRlciB0byBtYWludCkuCisgICAobWVyZ2UgYzQ2ZWJjMjQ5NiBzZy90cmF2aXMtaGVscC1kZWJ1ZyBsYXRlciB0byBtYWludCkuCisgICAobWVyZ2UgMjRjNjgxNzk0ZiBwcy9teS1maXJzdC1jb250cmlidXRpb24tYWxwaGFzb3J0IGxhdGVyIHRvIG1haW50KS4KKyAgIChtZXJnZSA3NWIyYzE1NDM1IGNiL2RvLW5vdC11c2UtdGVzdC1jbXAtd2l0aC1hIGxhdGVyIHRvIG1haW50KS4KKyAgIChtZXJnZSBjZGEwZDQ5N2UzIGJ3L3N1Ym1vZHVsZS1oZWxwZXItdXNhZ2UtZml4IGxhdGVyIHRvIG1haW50KS4KKyAgIChtZXJnZSBmZTBlZDVkNWU5IGFtL3Zpc3VhbC1zdHVkaW8tY29uZmlnLWZpeCBsYXRlciB0byBtYWludCkuCisgICAobWVyZ2UgMmUwOWMwMTIzMiBzZy9uYW1lLXJldi1jdXRvZmYtdW5kZXJmbG93LWZpeCBsYXRlciB0byBtYWludCkuCisgICAobWVyZ2UgZGRiM2M4NTZmMyBhcy9zaGFsbG93LXNsYWItdXNlLWZpeCBsYXRlciB0byBtYWludCkuCisgICAobWVyZ2UgNzFmNDk2MGI5MSBqcy9taW5ndy1zcGF3bi13aXRoLXNwYWNlcy1pbi1wYXRoIGxhdGVyIHRvIG1haW50KS4KKyAgIChtZXJnZSA1M2Q2ODdiZjVmIGFoL2NsZWFudXBzIGxhdGVyIHRvIG1haW50KS4KKyAgIChtZXJnZSBmNTM3NDg1ZmE1IHJzL3Rlc3QtcmVtb3ZlLXVzZWxlc3MtZGVidWdnaW5nLWNhdCBsYXRlciB0byBtYWludCkuCisgICAobWVyZ2UgMTFhM2QzYWFkZCBkbC9yZXYtbGlzdC1kb2MtY2xlYW51cCBsYXRlciB0byBtYWludCkuCisgICAobWVyZ2UgZDkyOGE4Mzg4YSBhbS90MDAyOC11dGYxNi10ZXN0cyBsYXRlciB0byBtYWludCkuCisgICAobWVyZ2UgYjA1YjQwOTMwZSBkbC90MDAwMC1za2lwLXRlc3QtdGVzdCBsYXRlciB0byBtYWludCkuCisgICAobWVyZ2UgMDNkM2IxMjk3YyBqcy94ZGlmZmktY29tbWVudC11cGRhdGVzIGxhdGVyIHRvIG1haW50KS4KKyAgIChtZXJnZSA1N2Q4ZjRiNGM3IGpzL2RvYy1zdGFzaC1zYXZlIGxhdGVyIHRvIG1haW50KS4KKyAgIChtZXJnZSA4YzFjZmQ1OGUzIHRhL3QxMzA4LXR5cG9maXggbGF0ZXIgdG8gbWFpbnQpLgorICAgKG1lcmdlIGZhMzY0YWQ3OTAgYmIvdXRmOC13Y3dpZHRoLWNsZWFudXAgbGF0ZXIgdG8gbWFpbnQpLgorICAgKG1lcmdlIDY4YjY5MjExYjIgYmIvY29tcGF0LXV0aWwtY29tbWVudC1maXggbGF0ZXIgdG8gbWFpbnQpLgorICAgKG1lcmdlIDVjYzZhNGJlMTEgcnMvaHR0cC1wdXNoLXNpbXBsaWZ5IGxhdGVyIHRvIG1haW50KS4KKyAgIChtZXJnZSBhODFlNDJkMjM1IHJzL2NvbHVtbi11c2UtdXRmOC1zdHJud2lkdGggbGF0ZXIgdG8gbWFpbnQpLgorICAgKG1lcmdlIDA2MmEzMDlkMzYgcnMvcmVtb3RlLWN1cmwtdXNlLWFyZ3YtYXJyYXkgbGF0ZXIgdG8gbWFpbnQpLgorICAgKG1lcmdlIDNiM2M3OWY2YzkgbnIvZGlmZi1oaWdobGlnaHQtaW5kZW50LWZpeCBsYXRlciB0byBtYWludCkuCisgICAobWVyZ2UgMzQ0NGVjMmViMiB3Yi9mc21vbml0b3ItYml0bWFwLWZpeCBsYXRlciB0byBtYWludCkuCisgICAobWVyZ2UgMTBkYTAzMGFiNyBjYi9wY3JlMi1jaGFydGFibGVzLWxlYWtmaXggbGF0ZXIgdG8gbWFpbnQpLgorICAgKG1lcmdlIDYwZTY1NjlhMTIganMvbWluZ3ctbmVlZHMtaGlkaW5nLWZpeCBsYXRlciB0byBtYWludCkuCisgICAobWVyZ2UgNTJiZDNlNDY1NyBybC9naXR3ZWItYmxhbWUtcHJldi1maXggbGF0ZXIgdG8gbWFpbnQpLgpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9SZWxOb3Rlcy8yLjI1LjAudHh0IGIvRG9jdW1lbnRhdGlvbi9SZWxOb3Rlcy8yLjI1LjAudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmU0YmIwN2EKLS0tIC9kZXYvbnVsbAorKysgYi9Eb2N1bWVudGF0aW9uL1JlbE5vdGVzLzIuMjUuMC50eHQKQEAgLTAsMCArMSwxNTUgQEAKK0dpdCAyLjI1IFJlbGVhc2UgTm90ZXMKKz09PT09PT09PT09PT09PT09PT09PT0KKworVXBkYXRlcyBzaW5jZSB2Mi4yNAorLS0tLS0tLS0tLS0tLS0tLS0tLQorCitCYWNrd2FyZCBjb21wYXRpYmlsaXR5IG5vdGVzCisKKworVUksIFdvcmtmbG93cyAmIEZlYXR1cmVzCisKKyAqIEEgdHV0b3JpYWwgb24gb2JqZWN0IGVudW1lcmF0aW9uIGhhcyBiZWVuIGFkZGVkLgorCisgKiBUaGUgYnJhbmNoIGRlc2NyaXB0aW9uICgiZ2l0IGJyYW5jaCAtLWVkaXQtZGVzY3JpcHRpb24iKSBoYXMgYmVlbgorICAgdXNlZCB0byBmaWxsIHRoZSBib2R5IG9mIHRoZSBjb3ZlciBsZXR0ZXJzIGJ5IHRoZSBmb3JtYXQtcGF0Y2gKKyAgIGNvbW1hbmQ7IHRoaXMgaGFzIGJlZW4gZW5oYW5jZWQgc28gdGhhdCB0aGUgc3ViamVjdCBjYW4gYWxzbyBiZQorICAgZmlsbGVkLgorCisgKiAiZ2l0IHJlYmFzZSAtLXByZXNlcnZlLW1lcmdlcyIgaGFzIGJlZW4gbWFya2VkIGFzIGRlcHJlY2F0ZWQ7IHRoaXMKKyAgIHJlbGVhc2Ugc3RvcHMgYWR2ZXJ0aXNpbmcgaXQgaW4gdGhlICJnaXQgcmViYXNlIC1oIiBvdXRwdXQuCisKKyAqIFRoZSBjb2RlIHRvIGdlbmVyYXRlIG11bHRpLXBhY2sgaW5kZXggbGVhcm5lZCB0byBzaG93IChvciBub3QgdG8KKyAgIHNob3cpIHByb2dyZXNzIGluZGljYXRvcnMuCisKKyAqICJnaXQgYXBwbHkgLS0zd2F5IiBsZWFybmVkIHRvIGhvbm9yIG1lcmdlLmNvbmZsaWN0U3R5bGUKKyAgIGNvbmZpZ3VyYXRpb24gdmFyaWFibGUsIGxpa2UgbWVyZ2VzIHdvdWxkLgorCisgKiBUaGUgY3VzdG9tIGZvcm1hdCBmb3IgImdpdCBsb2cgLS1mb3JtYXQ9PGZvcm1hdD4iIGxlYXJuZWQgdGhlIGwvTAorICAgcGxhY2Vob2xkZXIgdGhhdCBpcyBzaW1pbGFyIHRvIGUvRSB0aGF0IGZpbGxzIGluIHRoZSBlLW1haWwKKyAgIGFkZHJlc3MsIGJ1dCBvbmx5IHRoZSBsb2NhbCBwYXJ0IG9uIHRoZSBsZWZ0IHNpZGUgb2YgJ0AnLgorCisgKiBEb2N1bWVudGF0aW9uIHBhZ2VzIGZvciAiZ2l0IHNob3J0bG9nIiBub3cgbGlzdCBjb21taXQgbGltaXRpbmcKKyAgIG9wdGlvbnMgZXhwbGljaXRseS4KKworICogVGhlIHBhdHRlcm5zIHRvIGRldGVjdCBmdW5jdGlvbiBib3VuZGFyeSBmb3IgRWxpeGlyIGxhbmd1YWdlIGhhcworICAgYmVlbiBhZGRlZC4KKworICogVGhlIGNvbXBsZXRpb24gc2NyaXB0IChpbiBjb250cmliLykgbGVhcm5lZCB0aGF0IHRoZSAiLS1vbnRvIgorICAgb3B0aW9uIG9mICJnaXQgcmViYXNlIiBjYW4gdGFrZSBpdHMgYXJndW1lbnQgYXMgdGhlIHZhbHVlIG9mIHRoZQorICAgb3B0aW9uLgorCisKK1BlcmZvcm1hbmNlLCBJbnRlcm5hbCBJbXBsZW1lbnRhdGlvbiwgRGV2ZWxvcG1lbnQgU3VwcG9ydCBldGMuCisKKyAqIERlYnVnZ2luZyBzdXBwb3J0IGZvciBsYXp5IGNsb25pbmcgaGFzIGJlZW4gYSBiaXQgaW1wcm92ZWQuCisKKyAqIE1vdmUgdGhlIGRlZmluaXRpb24gb2YgYSBzZXQgb2YgYml0bWFzayBjb25zdGFudHMgZnJvbSAwY3RhbAorICAgbGl0ZXJhbCB0byAoMVU8PGNvdW50KSBub3RhdGlvbi4KKworICogVGVzdCB1cGRhdGVzIHRvIHByZXBhcmUgZm9yIFNIQS0yIHRyYW5zaXRpb24gY29udGludWVzLgorCisgKiBDcnVmdHkgY29kZSBhbmQgbG9naWMgYWNjdW11bGF0ZWQgb3ZlciB0aW1lIGFyb3VuZCB0aGUgb2JqZWN0CisgICBwYXJzaW5nIGFuZCBsb3ctbGV2ZWwgb2JqZWN0IGFjY2VzcyB1c2VkIGluICJnaXQgZnNjayIgaGF2ZSBiZWVuCisgICBjbGVhbmVkIHVwLgorCisgKiBUaGUgaW1wbGVtZW50YXRpb24gb2YgImdpdCBsb2cgLS1ncmFwaCIgZ290IHJlZmFjdG9yZWQgYW5kIHRoZW4gaXRzCisgICBvdXRwdXQgZ290IHNpbXBsaWZpZWQuCisKKyAqIEZvbGxvdyByZWNlbnQgcHVzaCB0byBtb3ZlIEFQSSBkb2NzIGZyb20gRG9jdW1lbnRhdGlvbi8gdG8gaGVhZGVyCisgICBmaWxlcyBhbmQgdXBkYXRlIGNvbmZpZy5oCisKKyAqICJnaXQgYnVuZGxlIiBoYXMgYmVlbiB0YXVnaHQgdG8gdXNlIHRoZSBwYXJzZSBvcHRpb25zIEFQSS4gICJnaXQKKyAgIGJ1bmRsZSB2ZXJpZnkiIGxlYXJuZWQgIi0tcXVpZXQiIGFuZCAiZ2l0IGJ1bmRsZSBjcmVhdGUiIGxlYXJuZWQKKyAgIG9wdGlvbnMgdG8gY29udHJvbCB0aGUgcHJvZ3Jlc3Mgb3V0cHV0LgorCisgKiBIYW5kbGluZyBvZiBjb21taXQgb2JqZWN0cyB0aGF0IHVzZSBub24gVVRGLTggZW5jb2RpbmcgZHVyaW5nCisgICAicmViYXNlIC1pIiBoYXMgYmVlbiBpbXByb3ZlZC4KKworCitGaXhlcyBzaW5jZSB2Mi4yNAorLS0tLS0tLS0tLS0tLS0tLS0KKworICogInJlYmFzZSAtaSIgY2Vhc2VkIHRvIHJ1biBwb3N0LWNvbW1pdCBob29rIGJ5IG1pc3Rha2UgaW4gYW4gZWFybGllcgorICAgdXBkYXRlLCB3aGljaCBoYXMgYmVlbiBjb3JyZWN0ZWQuCisKKyAqICJnaXQgbm90ZXMgY29weSAkb3JpZ2luYWwiIG91Z2h0IHRvIGNvcHkgdGhlIG5vdGVzIGF0dGFjaGVkIHRvIHRoZQorICAgb3JpZ2luYWwgb2JqZWN0IHRvIEhFQUQsIGJ1dCBhIG1pc3Rha2VuIHRpZ2h0ZW5pbmcgdG8gY29tbWFuZCBsaW5lCisgICBwYXJhbWV0ZXIgdmFsaWRhdGlvbiBtYWRlIGVhcmxpZXIgZGlzYWJsZWQgdGhhdCBmZWF0dXJlIGJ5IG1pc3Rha2UuCisKKyAqIFdoZW4gYWxsIGZpbGVzIGZyb20gc29tZSBzdWJkaXJlY3Rvcnkgd2VyZSByZW5hbWVkIHRvIHRoZSByb290CisgICBkaXJlY3RvcnksIHRoZSBkaXJlY3RvcnkgcmVuYW1lIGhldXJpc3RpY3Mgd291bGQgZmFpbCB0byBkZXRlY3QgdGhhdAorICAgYXMgYSByZW5hbWUvbWVyZ2Ugb2YgdGhlIHN1YmRpcmVjdG9yeSB0byB0aGUgcm9vdCBkaXJlY3RvcnksIHdoaWNoIGhhcworICAgYmVlbiBjb3JyZWN0ZWQuCisKKyAqIENvZGUgY2xlYW4tdXAgYW5kIGEgYnVnZml4IGluIHRoZSBsb2dpYyB1c2VkIHRvIHRlbGwgd29ya3RyZWUgbG9jYWwKKyAgIGFuZCByZXBvc2l0b3J5IGdsb2JhbCByZWZzIGFwYXJ0LgorICAgKG1lcmdlIGY0NWY4OGIyZTQgc2cvZGlyLXRyaWUtZml4ZXMgbGF0ZXIgdG8gbWFpbnQpLgorCisgKiAiZ2l0IHN0YXNoIHNhdmUiIGluIGEgd29ya2luZyB0cmVlIHRoYXQgaXMgc3BhcnNlbHkgY2hlY2tlZCBvdXQKKyAgIG1pc3Rha2VubHkgcmVtb3ZlZCBwYXRocyB0aGF0IGFyZSBvdXRzaWRlIHRoZSBhcmVhIG9mIGludGVyZXN0LgorICAgKG1lcmdlIDRhNThjM2Q3ZjcganMvdXBkYXRlLWluZGV4LWlnbm9yZS1yZW1vdmFsLWZvci1za2lwLXdvcmt0cmVlIGxhdGVyIHRvIG1haW50KS4KKworICogImdpdCByZXYtcGFyc2UgLS1naXQtcGF0aCBIRUFELmxvY2siIGRpZCBub3QgZ2l2ZSB0aGUgcmlnaHQgcGF0aAorICAgd2hlbiBydW4gaW4gYSBzZWNvbmRhcnkgd29ya3RyZWUuCisgICAobWVyZ2UgNzZhNTNkNjQwZiBqcy9naXQtcGF0aC1oZWFkLWRvdC1sb2NrLWZpeCBsYXRlciB0byBtYWludCkuCisKKyAqICJnaXQgbWVyZ2UgLS1uby1jb21taXQiIG5lZWRzICItLW5vLWZmIiBpZiB5b3UgZG8gbm90IHdhbnQgdG8gbW92ZQorICAgSEVBRCwgd2hpY2ggaGFzIGJlZW4gY29ycmVjdGVkIGluIHRoZSBtYW51YWwgcGFnZSBmb3IgImdpdCBiaXNlY3QiLgorICAgKG1lcmdlIDhkZDMyN2IyNDYgbWEvYmlzZWN0LWRvYy1zYW1wbGUtdXBkYXRlIGxhdGVyIHRvIG1haW50KS4KKworICogImdpdCB3b3JrdHJlZSBhZGQiIGludGVybmFsbHkgY2FsbHMgInJlc2V0IC0taGFyZCIgdGhhdCBzaG91bGQgbm90CisgICBkZXNjZW5kIGludG8gc3VibW9kdWxlcywgZXZlbiB3aGVuIHN1Ym1vZHVsZS5yZWN1cnNlIGNvbmZpZ3VyYXRpb24KKyAgIGlzIHNldCwgYnV0IGl0IHdhcyBhZmZlY3RlZC4gIFRoaXMgaGFzIGJlZW4gY29ycmVjdGVkLgorICAgKG1lcmdlIDQ3ODJjZjJhYjYgcGIvbm8tcmVjdXJzaXZlLXJlc2V0LWhhcmQtaW4td29ya3RyZWUtYWRkIGxhdGVyIHRvIG1haW50KS4KKworICogTWVzc2FnZXMgZnJvbSBkaWUoKSBldGMuIGNhbiBiZSBtaXhlZCB1cCBmcm9tIG11bHRpcGxlIHByb2Nlc3NlcworICAgd2l0aG91dCBldmVuIGxpbmUgYnVmZmVyaW5nIG9uIFdpbmRvd3MsIHdoaWNoIGhhcyBiZWVuIHdvcmtlZAorICAgYXJvdW5kLgorICAgKG1lcmdlIDExNmQxZmE2YzYganMvdnJlcG9ydGYtd28tYnVmZmVyaW5nIGxhdGVyIHRvIG1haW50KS4KKworICogSFRUUCB0cmFuc3BvcnQgaGFkIHBvc3NpYmxlIGFsbG9jYXRvci9kZWFsbG9jYXRvciBtaXNtYXRjaCwgd2hpY2gKKyAgIGhhcyBiZWVuIGNvcnJlY3RlZC4KKworICogVGhlIHdhdGNobWFuIGludGVncmF0aW9uIGZvciBmc21vbml0b3Igd2FzIHJhY3ksIHdoaWNoIGhhcyBiZWVuCisgICBjb3JyZWN0ZWQgdG8gYmUgbW9yZSBjb25zZXJ2YXRpdmUuCisgICAobWVyZ2UgZGQwYjYxZjU3NyBrdy9mc21vbml0b3Itd2F0Y2htYW4tZml4IGxhdGVyIHRvIG1haW50KS4KKworICogRmV0Y2hpbmcgZnJvbSBtdWx0aXBsZSByZW1vdGVzIGludG8gdGhlIHNhbWUgcmVwb3NpdG9yeSBpbiBwYXJhbGxlbAorICAgaGFkIGEgYmFkIGludGVyYWN0aW9uIHdpdGggdGhlIHJlY2VudCBjaGFuZ2UgdG8gKG9wdGlvbmFsbHkpIHVwZGF0ZQorICAgdGhlIGNvbW1pdC1ncmFwaCBhZnRlciBhIGZldGNoIGpvYiBmaW5pc2hlcywgYXMgdGhlc2UgcGFyYWxsZWwKKyAgIGZldGNoZXMgY29tcGV0ZSB3aXRoIGVhY2ggb3RoZXIuICBXaGljaCBoYXMgYmVlbiBjb3JyZWN0ZWQuCisKKyAqIFJlY2VudCB1cGRhdGUgdG8gImdpdCBzdGFzaCBwb3AiIG1hZGUgdGhlIGNvbW1hbmQgZW1wdHkgdGhlIGluZGV4CisgICB3aGVuIHJ1biB3aXRoIHRoZSAiLS1xdWlldCIgb3B0aW9uLCB3aGljaCBoYXMgYmVlbiBjb3JyZWN0ZWQuCisKKyAqICJnaXQgZmV0Y2giIGNvZGVwYXRoIGhhZCBhIGJpZyAiZG8gbm90IGxhemlseSBmZXRjaCBtaXNzaW5nIG9iamVjdHMKKyAgIHdoZW4gSSBhc2sgaWYgc29tZXRoaW5nIGV4aXN0cyIgc3dpdGNoLiAgVGhpcyBoYXMgYmVlbiBjb3JyZWN0ZWQgYnkKKyAgIG1hcmtpbmcgdGhlICJkb2VzIHRoaXMgdGhpbmcgZXhpc3Q/IiBjYWxscyB3aXRoICJpZiBub3QgcGxlYXNlIGRvIG5vdAorICAgbGF6aWx5IGZldGNoIGl0IiBmbGFnLgorCisgKiBUZXN0IHVwZGF0ZSB0byBhdm9pZCB3YXN0ZWQgY3ljbGVzLgorICAgKG1lcmdlIGUwMzE2Njk1ZWMgc2cvc2tpcC1za2lwcGVkLXByZXJlcSBsYXRlciB0byBtYWludCkuCisKKyAqIEVycm9yIGhhbmRsaW5nIGFmdGVyICJnaXQgcHVzaCIgZmluaXNoZXMgc2VuZGluZyB0aGUgcGFja2RhdGEgYW5kCisgICB3YWl0cyBmb3IgdGhlIHJlc3BvbnNlIHRvIHRoZSByZW1vdGUgc2lkZSBoYXMgYmVlbiBpbXByb3ZlZC4KKyAgIChtZXJnZSBhZDdhNDAzMjY4IGprL3NlbmQtcGFjay1yZW1vdGUtZmFpbHVyZSBsYXRlciB0byBtYWludCkuCisKKyAqIFNvbWUgY29kZXBhdGhzIGluICJnaXR3ZWIiIHRoYXQgZm9yZ290IHRvIGVzY2FwZSBVUkxzIGdlbmVyYXRlZAorICAgYmFzZWQgb24gZW5kLXVzZXIgaW5wdXQgaGF2ZSBiZWVuIGNvcnJlY3RlZC4KKyAgIChtZXJnZSBhMzc2ZTM3YjJjIGprL2dpdHdlYi1hbnRpLXhzcyBsYXRlciB0byBtYWludCkuCisKKyAqIE90aGVyIGNvZGUgY2xlYW51cCwgZG9jZml4LCBidWlsZCBmaXgsIGV0Yy4KKyAgIChtZXJnZSA4MDczNmQ3YzVlIGpjL2FtLXNob3ctY3VycmVudC1wYXRjaC1kb2NmaXggbGF0ZXIgdG8gbWFpbnQpLgorICAgKG1lcmdlIDhiNjU2NTcyY2Egc2cvY29tbWl0LWdyYXBoLXVzYWdlLWZpeCBsYXRlciB0byBtYWludCkuCisgICAobWVyZ2UgNmMwMjA0MjEzOSBtci9jbG9uZS1kaXItZXhpc3RzLXRvLXBhdGgtZXhpc3RzIGxhdGVyIHRvIG1haW50KS4KKyAgIChtZXJnZSA0NGFlMTMxZTM4IHNnL2JsYW1lLWluZGVudC1oZXVyaXN0aWNzLWlzLW5vdy10aGUtZGVmYXVsdCBsYXRlciB0byBtYWludCkuCisgICAobWVyZ2UgMDExNWU1ZDkyOSBkbC9kb2MtZGlmZi1uby1pbmRleC1pbXBsaWVzLWV4aXQtY29kZSBsYXRlciB0byBtYWludCkuCisgICAobWVyZ2UgMjcwZGU2YWNiZSBlbi90NjAyNC1zdHlsZSBsYXRlciB0byBtYWludCkuCisgICAobWVyZ2UgMTRjNDc3NmQ3NSBucy90ZXN0LWRlc2MtdHlwb2ZpeCBsYXRlciB0byBtYWludCkuCisgICAobWVyZ2UgNjhkNDBmMzBjNCBkai90eXBvZml4LW1lcmdlLXN0cmF0IGxhdGVyIHRvIG1haW50KS4KKyAgIChtZXJnZSBmNjZlMDQwMWFiIGprL29wdGltLWluLXBhY2staWR4LWNvbnZlcnNpb24gbGF0ZXIgdG8gbWFpbnQpLgorICAgKG1lcmdlIDE2OWJlZDc0MjEgcnMvcGFyc2Utb3B0aW9ucy1kdXAtbnVsbC1maXggbGF0ZXIgdG8gbWFpbnQpLgorICAgKG1lcmdlIDUxYmQ2YmUzMmQgcnMvdXNlLWNvcHktYXJyYXktaW4tbWluZ3ctc2hlbGwtY29tbWFuZC1wcmVwYXJhdGlvbiBsYXRlciB0byBtYWludCkuCisgICAobWVyZ2UgYjAxODcxOTkyNyBtYS90NzAwNCBsYXRlciB0byBtYWludCkuCisgICAobWVyZ2UgOTMyNzU3YjBjYyBhci9pbnN0YWxsLWRvYy11cGRhdGUtY21kcy1uZWVkaW5nLXRoZS1zaGVsbCBsYXRlciB0byBtYWludCkuCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL1JlbE5vdGVzLzIuMy4zLnR4dCBiL0RvY3VtZW50YXRpb24vUmVsTm90ZXMvMi4zLjMudHh0CmluZGV4IDVlZjEyNjQuLjg1MGRjNjggMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vUmVsTm90ZXMvMi4zLjMudHh0CisrKyBiL0RvY3VtZW50YXRpb24vUmVsTm90ZXMvMi4zLjMudHh0CkBAIC0xMiw3ICsxMiw3IEBACiAgKiBEZXNjcmlwdGlvbiBnaXZlbiBieSAiZ3JlcCAtaCIgZm9yIGl0cyAtLWV4Y2x1ZGUtc3RhbmRhcmQgb3B0aW9uCiAgICB3YXMgcGhyYXNlZCBwb29ybHkuCiAKLSAqIERvY3VtZW50YXRvbiBmb3IgImdpdCByZW1vdGUgYWRkIiBtZW50aW9uZWQgIi0tdGFncyIgYW5kCisgKiBEb2N1bWVudGF0aW9uIGZvciAiZ2l0IHJlbW90ZSBhZGQiIG1lbnRpb25lZCAiLS10YWdzIiBhbmQKICAgICItLW5vLXRhZ3MiIGFuZCBpdCB3YXMgbm90IGNsZWFyIHRoYXQgZmV0Y2ggZnJvbSB0aGUgcmVtb3RlIGluCiAgICB0aGUgZnV0dXJlIHdpbGwgdXNlIHRoZSBkZWZhdWx0IGJlaGF2aW91ciB3aGVuIG5laXRoZXIgaXMgZ2l2ZW4KICAgIHRvIG92ZXJyaWRlIGl0LgpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9SZWxOb3Rlcy8yLjMuNy50eHQgYi9Eb2N1bWVudGF0aW9uL1JlbE5vdGVzLzIuMy43LnR4dAppbmRleCBmYzk1ODEyLi41NzY5MTg0IDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL1JlbE5vdGVzLzIuMy43LnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL1JlbE5vdGVzLzIuMy43LnR4dApAQCAtNCw3ICs0LDcgQEAKIEZpeGVzIHNpbmNlIHYyLjMuNgogLS0tLS0tLS0tLS0tLS0tLS0tCiAKLSAqIEFuIGVhcmxpZXIgdXBkYXRlIHRvIHRoZSBwYXJzZXIgdGhhdCBkaXNlY3RzIGEgVVJMIGJyb2tlIGFuCisgKiBBbiBlYXJsaWVyIHVwZGF0ZSB0byB0aGUgcGFyc2VyIHRoYXQgZGlzc2VjdHMgYSBVUkwgYnJva2UgYW4KICAgIGFkZHJlc3MsIGZvbGxvd2VkIGJ5IGEgY29sb24sIGZvbGxvd2VkIGJ5IGFuIGVtcHR5IHN0cmluZyAoaW5zdGVhZAogICAgb2YgdGhlIHBvcnQgbnVtYmVyKSwgZS5nLiBzc2g6Ly9leGFtcGxlLmNvbTovcGF0aC90by9yZXBvLgogCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL1JlbE5vdGVzLzIuNC4zLnR4dCBiL0RvY3VtZW50YXRpb24vUmVsTm90ZXMvMi40LjMudHh0CmluZGV4IDkxNGQyYzEuLjQyMmU5MzAgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vUmVsTm90ZXMvMi40LjMudHh0CisrKyBiL0RvY3VtZW50YXRpb24vUmVsTm90ZXMvMi40LjMudHh0CkBAIC02Niw3ICs2Niw3IEBACiAgKiBTb21lIHRpbWUgYWdvLCAiZ2l0IGJsYW1lIiAoaW5jb3JyZWN0bHkpIGxvc3QgdGhlIGNvbnZlcnRfdG9fZ2l0KCkKICAgIGNhbGwgd2hlbiBzeW50aGVzaXppbmcgYSBmYWtlICJ0aXAiIGNvbW1pdCB0aGF0IHJlcHJlc2VudHMgdGhlCiAgICBzdGF0ZSBpbiB0aGUgd29ya2luZyB0cmVlLCB3aGljaCBicm9rZSBmb2xrcyB3aG8gcmVjb3JkIHRoZSBoaXN0b3J5Ci0gICB3aXRoIExGIGxpbmUgZW5kaW5nIHRvIG1ha2UgdGhlaXIgcHJvamVjdCBwb3J0YWJpbGUgYWNyb3NzCisgICB3aXRoIExGIGxpbmUgZW5kaW5nIHRvIG1ha2UgdGhlaXIgcHJvamVjdCBwb3J0YWJsZSBhY3Jvc3MKICAgIHBsYXRmb3JtcyB3aGlsZSB0ZXJtaW5hdGluZyBsaW5lcyBpbiB0aGVpciB3b3JraW5nIHRyZWUgZmlsZXMgd2l0aAogICAgQ1JMRiBmb3IgdGhlaXIgcGxhdGZvcm0uCiAKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vUmVsTm90ZXMvMi43LjAudHh0IGIvRG9jdW1lbnRhdGlvbi9SZWxOb3Rlcy8yLjcuMC50eHQKaW5kZXggNTYzZGFkYy4uZTNjYmYzYSAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9SZWxOb3Rlcy8yLjcuMC50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9SZWxOb3Rlcy8yLjcuMC50eHQKQEAgLTQwLDcgKzQwLDcgQEAKIAogICogImdpdCBpbnRlcnByZXQtdHJhaWxlcnMiIGNhbiBub3cgcnVuIG91dHNpZGUgb2YgYSBHaXQgcmVwb3NpdG9yeS4KIAotICogImdpdCBwNCIgbGVhcm5lZCB0byByZWVuY29kZSB0aGUgcGF0aG5hbWUgaXQgdXNlcyB0byBjb21tdW5pY2F0ZQorICogImdpdCBwNCIgbGVhcm5lZCB0byByZS1lbmNvZGUgdGhlIHBhdGhuYW1lIGl0IHVzZXMgdG8gY29tbXVuaWNhdGUKICAgIHdpdGggdGhlIHA0IGRlcG90IHdpdGggYSBuZXcgb3B0aW9uLgogCiAgKiBHaXZlIHByb2dyZXNzIG1ldGVyIHRvICJnaXQgZmlsdGVyLWJyYW5jaCIuCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL1JlbE5vdGVzLzIuNy4xLnR4dCBiL0RvY3VtZW50YXRpb24vUmVsTm90ZXMvMi43LjEudHh0CmluZGV4IDY1NTNkNjkuLjYzMjNmZWEgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vUmVsTm90ZXMvMi43LjEudHh0CisrKyBiL0RvY3VtZW50YXRpb24vUmVsTm90ZXMvMi43LjEudHh0CkBAIC0xMCw3ICsxMCw3IEBACiAgICBzZXR0aW5nIEdJVF9XT1JLX1RSRUUgZW52aXJvbm1lbnQgdGhlbXNlbHZlcy4KIAogICogVGhlICJleGNsdWRlX2xpc3QiIHN0cnVjdHVyZSBoYXMgdGhlIHVzdWFsICJhbGxvYywgbnIiIHBhaXIgb2YKLSAgIGZpZWxkcyB0byBiZSB1c2VkIGJ5IEFMTE9DX0dST1coKSwgYnV0IGNsZWFyX2V4Y2x1ZGVfbGlzdCgpIGZvcmdvdAorICAgZmllbGRzIHRvIGJlIHVzZWQgYnkgQUxMT0NfR1JPVygpLCBidXQgY2xlYXJfcGF0dGVybl9saXN0KCkgZm9yZ290CiAgICB0byByZXNldCAnYWxsb2MnIHRvIDAgd2hlbiBpdCBjbGVhcmVkICducicgdG8gZGlzY2FyZCB0aGUgbWFuYWdlZAogICAgYXJyYXkuCiAKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vUmVsTm90ZXMvMi44LjAudHh0IGIvRG9jdW1lbnRhdGlvbi9SZWxOb3Rlcy8yLjguMC50eHQKaW5kZXggMjUwNzk3MS4uMjczMjBiNiAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9SZWxOb3Rlcy8yLjguMC50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9SZWxOb3Rlcy8yLjguMC50eHQKQEAgLTE4OSw3ICsxODksNyBAQAogICogU29tZSBjYWxscyB0byBzdHJjcHkoMykgdHJpZ2dlcnMgYSBmYWxzZSB3YXJuaW5nIGZyb20gc3RhdGljCiAgICBhbmFseXplcnMgdGhhdCBhcmUgbGVzcyBpbnRlbGxpZ2VudCB0aGFuIGh1bWFucywgYW5kIHJlZHVjaW5nIHRoZQogICAgbnVtYmVyIG9mIHRoZXNlIGZhbHNlIGhpdHMgaGVscHMgdXMgbm90aWNlIHJlYWwgaXNzdWVzLiAgQSBmZXcKLSAgIGNhbGxzIHRvIHN0cmNweSgzKSBpbiBhIGNvdXBsZSBvZiBwcm90cmFtcyB0aGF0IGFyZSBhbHJlYWR5IHNhZmUKKyAgIGNhbGxzIHRvIHN0cmNweSgzKSBpbiBhIGNvdXBsZSBvZiBwcm9ncmFtcyB0aGF0IGFyZSBhbHJlYWR5IHNhZmUKICAgIGhhcyBiZWVuIHJld3JpdHRlbiB0byBhdm9pZCBmYWxzZSB3YXJuaW5ncy4KIAogICogVGhlICJuYW1lX3BhdGgiIEFQSSB3YXMgYW4gYXR0ZW1wdCB0byByZWR1Y2UgdGhlIG5lZWQgdG8gY29uc3RydWN0CkBAIC0yNzAsNyArMjcwLDcgQEAKICAgIHNldHRpbmcgR0lUX1dPUktfVFJFRSBlbnZpcm9ubWVudCB0aGVtc2VsdmVzLgogCiAgKiBUaGUgImV4Y2x1ZGVfbGlzdCIgc3RydWN0dXJlIGhhcyB0aGUgdXN1YWwgImFsbG9jLCBuciIgcGFpciBvZgotICAgZmllbGRzIHRvIGJlIHVzZWQgYnkgQUxMT0NfR1JPVygpLCBidXQgY2xlYXJfZXhjbHVkZV9saXN0KCkgZm9yZ290CisgICBmaWVsZHMgdG8gYmUgdXNlZCBieSBBTExPQ19HUk9XKCksIGJ1dCBjbGVhcl9wYXR0ZXJuX2xpc3QoKSBmb3Jnb3QKICAgIHRvIHJlc2V0ICdhbGxvYycgdG8gMCB3aGVuIGl0IGNsZWFyZWQgJ25yJyB0byBkaXNjYXJkIHRoZSBtYW5hZ2VkCiAgICBhcnJheS4KIApkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9SZWxOb3Rlcy8yLjkuMy50eHQgYi9Eb2N1bWVudGF0aW9uL1JlbE5vdGVzLzIuOS4zLnR4dAppbmRleCA2OTViODZmLi4zMDVlMDgwIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL1JlbE5vdGVzLzIuOS4zLnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL1JlbE5vdGVzLzIuOS4zLnR4dApAQCAtMzYsNyArMzYsNyBAQAogICogT25lIHBhcnQgb2YgImdpdCBhbSIgaGFkIGFuIG9kZGJhbGwgaGVscGVyIGZ1bmN0aW9uIHRoYXQgY2FsbGVkCiAgICBzdHVmZiBmcm9tIG91dHNpZGUgImhpcyIgYXMgb3Bwb3NlZCB0byBjYWxsaW5nIHdoYXQgd2UgaGF2ZSAib3VycyIsCiAgICB3aGljaCB3YXMgbm90IGdlbmRlci1uZXV0cmFsIGFuZCBhbHNvIGluY29uc2lzdGVudCB3aXRoIHRoZSByZXN0IG9mCi0gICB0aGUgc3lzdGVtIHdoZXJlIG91dHNpZGUgc3R1ZmYgaXMgdXN1YWxsIGNhbGxlZCAidGhlaXJzIiBpbgorICAgdGhlIHN5c3RlbSB3aGVyZSBvdXRzaWRlIHN0dWZmIGlzIHVzdWFsbHkgY2FsbGVkICJ0aGVpcnMiIGluCiAgICBjb250cmFzdCB0byAib3VycyIuCiAKICAqIFRoZSB0ZXN0IGZyYW1ld29yayBsZWFybmVkIGEgbmV3IGhlbHBlciB0ZXN0X21hdGNoX3NpZ25hbCB0bwpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9TdWJtaXR0aW5nUGF0Y2hlcyBiL0RvY3VtZW50YXRpb24vU3VibWl0dGluZ1BhdGNoZXMKaW5kZXggNmQ1ODllMS4uMWE2MGNjMSAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9TdWJtaXR0aW5nUGF0Y2hlcworKysgYi9Eb2N1bWVudGF0aW9uL1N1Ym1pdHRpbmdQYXRjaGVzCkBAIC0zNzIsOSArMzcyLDkgQEAKIFNvbWUgcGFydHMgb2YgdGhlIHN5c3RlbSBoYXZlIGRlZGljYXRlZCBtYWludGFpbmVycyB3aXRoIHRoZWlyIG93bgogcmVwb3NpdG9yaWVzLgogCi0tIGBnaXQtZ3VpL2AgY29tZXMgZnJvbSBnaXQtZ3VpIHByb2plY3QsIG1haW50YWluZWQgYnkgUGF0IFRob3l0czoKKy0gYGdpdC1ndWkvYCBjb21lcyBmcm9tIGdpdC1ndWkgcHJvamVjdCwgbWFpbnRhaW5lZCBieSBQcmF0eXVzaCBZYWRhdjoKIAotCWdpdDovL3JlcG8ub3IuY3ovZ2l0LWd1aS5naXQKKwlodHRwczovL2dpdGh1Yi5jb20vcHJhdGkwMTAwL2dpdC1ndWkuZ2l0CiAKIC0gYGdpdGstZ2l0L2AgY29tZXMgZnJvbSBQYXVsIE1hY2tlcnJhcydzIGdpdGsgcHJvamVjdDoKIApkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9hc2NpaWRvYy5jb25mIGIvRG9jdW1lbnRhdGlvbi9hc2NpaWRvYy5jb25mCmluZGV4IDJjMTZjNTMuLjhmYzRiNjcgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vYXNjaWlkb2MuY29uZgorKysgYi9Eb2N1bWVudGF0aW9uL2FzY2lpZG9jLmNvbmYKQEAgLTc4LDkgKzc4LDkgQEAKIDxyZWZtZXRhPgogPHJlZmVudHJ5dGl0bGU+e21hbnRpdGxlfTwvcmVmZW50cnl0aXRsZT4KIDxtYW52b2xudW0+e21hbnZvbG51bX08L21hbnZvbG51bT4KLTxyZWZtaXNjaW5mbyBjbGFzcz0ic291cmNlIj5HaXQ8L3JlZm1pc2NpbmZvPgotPHJlZm1pc2NpbmZvIGNsYXNzPSJ2ZXJzaW9uIj57Z2l0X3ZlcnNpb259PC9yZWZtaXNjaW5mbz4KLTxyZWZtaXNjaW5mbyBjbGFzcz0ibWFudWFsIj5HaXQgTWFudWFsPC9yZWZtaXNjaW5mbz4KKzxyZWZtaXNjaW5mbyBjbGFzcz0ic291cmNlIj57bWFuc291cmNlfTwvcmVmbWlzY2luZm8+Cis8cmVmbWlzY2luZm8gY2xhc3M9InZlcnNpb24iPnttYW52ZXJzaW9ufTwvcmVmbWlzY2luZm8+Cis8cmVmbWlzY2luZm8gY2xhc3M9Im1hbnVhbCI+e21hbm1hbnVhbH08L3JlZm1pc2NpbmZvPgogPC9yZWZtZXRhPgogPHJlZm5hbWVkaXY+CiAgIDxyZWZuYW1lPnttYW5uYW1lfTwvcmVmbmFtZT4KZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vYXNjaWlkb2N0b3ItZXh0ZW5zaW9ucy5yYiBiL0RvY3VtZW50YXRpb24vYXNjaWlkb2N0b3ItZXh0ZW5zaW9ucy5yYgppbmRleCAwMDg5ZTBjLi5kOTA2YTAwIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2FzY2lpZG9jdG9yLWV4dGVuc2lvbnMucmIKKysrIGIvRG9jdW1lbnRhdGlvbi9hc2NpaWRvY3Rvci1leHRlbnNpb25zLnJiCkBAIC05LDggKzksMTEgQEAKICAgICAgIG5hbWVkIDpjaHJvbWUKIAogICAgICAgZGVmIHByb2Nlc3MocGFyZW50LCB0YXJnZXQsIGF0dHJzKQotICAgICAgICBpZiBwYXJlbnQuZG9jdW1lbnQuYmFzZWJhY2tlbmQ/ICdodG1sJwotICAgICAgICAgIHByZWZpeCA9IHBhcmVudC5kb2N1bWVudC5hdHRyKCdnaXQtcmVsYXRpdmUtaHRtbC1wcmVmaXgnKQorICAgICAgICBwcmVmaXggPSBwYXJlbnQuZG9jdW1lbnQuYXR0cignZ2l0LXJlbGF0aXZlLWh0bWwtcHJlZml4JykKKyAgICAgICAgaWYgcGFyZW50LmRvY3VtZW50LmRvY3R5cGUgPT0gJ2Jvb2snCisgICAgICAgICAgIjx1bGluayB1cmw9XCIje3ByZWZpeH0je3RhcmdldH0uaHRtbFwiPiIgXAorICAgICAgICAgICIje3RhcmdldH0oI3thdHRyc1sxXX0pPC91bGluaz4iCisgICAgICAgIGVsc2lmIHBhcmVudC5kb2N1bWVudC5iYXNlYmFja2VuZD8gJ2h0bWwnCiAgICAgICAgICAgJSg8YSBocmVmPSIje3ByZWZpeH0je3RhcmdldH0uaHRtbCI+I3t0YXJnZXR9KCN7YXR0cnNbMV19KTwvYT4pCiAgICAgICAgIGVsc2lmIHBhcmVudC5kb2N1bWVudC5iYXNlYmFja2VuZD8gJ2RvY2Jvb2snCiAgICAgICAgICAgIjxjaXRlcmVmZW50cnk+XG4iIFwKQEAgLTIwLDkgKzIzLDI2IEBACiAgICAgICAgIGVuZAogICAgICAgZW5kCiAgICAgZW5kCisKKyAgICBjbGFzcyBEb2N1bWVudFBvc3RQcm9jZXNzb3IgPCBBc2NpaWRvY3Rvcjo6RXh0ZW5zaW9uczo6UG9zdHByb2Nlc3NvcgorICAgICAgZGVmIHByb2Nlc3MgZG9jdW1lbnQsIG91dHB1dAorICAgICAgICBpZiBkb2N1bWVudC5iYXNlYmFja2VuZD8gJ2RvY2Jvb2snCisgICAgICAgICAgbWFuc291cmNlID0gZG9jdW1lbnQuYXR0cmlidXRlc1snbWFuc291cmNlJ10KKyAgICAgICAgICBtYW52ZXJzaW9uID0gZG9jdW1lbnQuYXR0cmlidXRlc1snbWFudmVyc2lvbiddCisgICAgICAgICAgbWFubWFudWFsID0gZG9jdW1lbnQuYXR0cmlidXRlc1snbWFubWFudWFsJ10KKyAgICAgICAgICBuZXdfdGFncyA9ICIiIFwKKyAgICAgICAgICAgICI8cmVmbWlzY2luZm8gY2xhc3M9XCJzb3VyY2VcIj4je21hbnNvdXJjZX08L3JlZm1pc2NpbmZvPlxuIiBcCisgICAgICAgICAgICAiPHJlZm1pc2NpbmZvIGNsYXNzPVwidmVyc2lvblwiPiN7bWFudmVyc2lvbn08L3JlZm1pc2NpbmZvPlxuIiBcCisgICAgICAgICAgICAiPHJlZm1pc2NpbmZvIGNsYXNzPVwibWFudWFsXCI+I3ttYW5tYW51YWx9PC9yZWZtaXNjaW5mbz5cbiIKKyAgICAgICAgICBvdXRwdXQgPSBvdXRwdXQuc3ViKC88XC9yZWZtZXRhPi8sIG5ld190YWdzICsgIjwvcmVmbWV0YT4iKQorICAgICAgICBlbmQKKyAgICAgICAgb3V0cHV0CisgICAgICBlbmQKKyAgICBlbmQKICAgZW5kCiBlbmQKIAogQXNjaWlkb2N0b3I6OkV4dGVuc2lvbnMucmVnaXN0ZXIgZG8KICAgaW5saW5lX21hY3JvIEdpdDo6RG9jdW1lbnRhdGlvbjo6TGlua0dpdFByb2Nlc3NvciwgOmxpbmtnaXQKKyAgcG9zdHByb2Nlc3NvciBHaXQ6OkRvY3VtZW50YXRpb246OkRvY3VtZW50UG9zdFByb2Nlc3NvcgogZW5kCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2NvbmZpZy50eHQgYi9Eb2N1bWVudGF0aW9uL2NvbmZpZy50eHQKaW5kZXggZTNmNWJjMy4uODNlN2JiYSAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9jb25maWcudHh0CisrKyBiL0RvY3VtZW50YXRpb24vY29uZmlnLnR4dApAQCAtMTQyLDcgKzE0Miw3IEBACiAKIGBnaXRkaXIvaWA6OgogCVRoaXMgaXMgdGhlIHNhbWUgYXMgYGdpdGRpcmAgZXhjZXB0IHRoYXQgbWF0Y2hpbmcgaXMgZG9uZQotCWNhc2UtaW5zZW5zaXRpdmVseSAoZS5nLiBvbiBjYXNlLWluc2Vuc2l0aXZlIGZpbGUgc3l0ZW1zKQorCWNhc2UtaW5zZW5zaXRpdmVseSAoZS5nLiBvbiBjYXNlLWluc2Vuc2l0aXZlIGZpbGUgc3lzdGVtcykKIAogYG9uYnJhbmNoYDo6CiAJVGhlIGRhdGEgdGhhdCBmb2xsb3dzIHRoZSBrZXl3b3JkIGBvbmJyYW5jaDpgIGlzIHRha2VuIHRvIGJlIGEKQEAgLTE3OCw0NyArMTc4LDQ5IEBACiBFeGFtcGxlCiB+fn5+fn5+CiAKLQkjIENvcmUgdmFyaWFibGVzCi0JW2NvcmVdCi0JCTsgRG9uJ3QgdHJ1c3QgZmlsZSBtb2RlcwotCQlmaWxlbW9kZSA9IGZhbHNlCistLS0tCisjIENvcmUgdmFyaWFibGVzCitbY29yZV0KKwk7IERvbid0IHRydXN0IGZpbGUgbW9kZXMKKwlmaWxlbW9kZSA9IGZhbHNlCiAKLQkjIE91ciBkaWZmIGFsZ29yaXRobQotCVtkaWZmXQotCQlleHRlcm5hbCA9IC91c3IvbG9jYWwvYmluL2RpZmYtd3JhcHBlcgotCQlyZW5hbWVzID0gdHJ1ZQorIyBPdXIgZGlmZiBhbGdvcml0aG0KK1tkaWZmXQorCWV4dGVybmFsID0gL3Vzci9sb2NhbC9iaW4vZGlmZi13cmFwcGVyCisJcmVuYW1lcyA9IHRydWUKIAotCVticmFuY2ggImRldmVsIl0KLQkJcmVtb3RlID0gb3JpZ2luCi0JCW1lcmdlID0gcmVmcy9oZWFkcy9kZXZlbAorW2JyYW5jaCAiZGV2ZWwiXQorCXJlbW90ZSA9IG9yaWdpbgorCW1lcmdlID0gcmVmcy9oZWFkcy9kZXZlbAogCi0JIyBQcm94eSBzZXR0aW5ncwotCVtjb3JlXQotCQlnaXRQcm94eT0ic3NoIiBmb3IgImtlcm5lbC5vcmciCi0JCWdpdFByb3h5PWRlZmF1bHQtcHJveHkgOyBmb3IgdGhlIHJlc3QKKyMgUHJveHkgc2V0dGluZ3MKK1tjb3JlXQorCWdpdFByb3h5PSJzc2giIGZvciAia2VybmVsLm9yZyIKKwlnaXRQcm94eT1kZWZhdWx0LXByb3h5IDsgZm9yIHRoZSByZXN0CiAKLQlbaW5jbHVkZV0KLQkJcGF0aCA9IC9wYXRoL3RvL2Zvby5pbmMgOyBpbmNsdWRlIGJ5IGFic29sdXRlIHBhdGgKLQkJcGF0aCA9IGZvby5pbmMgOyBmaW5kICJmb28uaW5jIiByZWxhdGl2ZSB0byB0aGUgY3VycmVudCBmaWxlCi0JCXBhdGggPSB+L2Zvby5pbmMgOyBmaW5kICJmb28uaW5jIiBpbiB5b3VyIGAkSE9NRWAgZGlyZWN0b3J5CitbaW5jbHVkZV0KKwlwYXRoID0gL3BhdGgvdG8vZm9vLmluYyA7IGluY2x1ZGUgYnkgYWJzb2x1dGUgcGF0aAorCXBhdGggPSBmb28uaW5jIDsgZmluZCAiZm9vLmluYyIgcmVsYXRpdmUgdG8gdGhlIGN1cnJlbnQgZmlsZQorCXBhdGggPSB+L2Zvby5pbmMgOyBmaW5kICJmb28uaW5jIiBpbiB5b3VyIGAkSE9NRWAgZGlyZWN0b3J5CiAKLQk7IGluY2x1ZGUgaWYgJEdJVF9ESVIgaXMgL3BhdGgvdG8vZm9vLy5naXQKLQlbaW5jbHVkZUlmICJnaXRkaXI6L3BhdGgvdG8vZm9vLy5naXQiXQotCQlwYXRoID0gL3BhdGgvdG8vZm9vLmluYworOyBpbmNsdWRlIGlmICRHSVRfRElSIGlzIC9wYXRoL3RvL2Zvby8uZ2l0CitbaW5jbHVkZUlmICJnaXRkaXI6L3BhdGgvdG8vZm9vLy5naXQiXQorCXBhdGggPSAvcGF0aC90by9mb28uaW5jCiAKLQk7IGluY2x1ZGUgZm9yIGFsbCByZXBvc2l0b3JpZXMgaW5zaWRlIC9wYXRoL3RvL2dyb3VwCi0JW2luY2x1ZGVJZiAiZ2l0ZGlyOi9wYXRoL3RvL2dyb3VwLyJdCi0JCXBhdGggPSAvcGF0aC90by9mb28uaW5jCis7IGluY2x1ZGUgZm9yIGFsbCByZXBvc2l0b3JpZXMgaW5zaWRlIC9wYXRoL3RvL2dyb3VwCitbaW5jbHVkZUlmICJnaXRkaXI6L3BhdGgvdG8vZ3JvdXAvIl0KKwlwYXRoID0gL3BhdGgvdG8vZm9vLmluYwogCi0JOyBpbmNsdWRlIGZvciBhbGwgcmVwb3NpdG9yaWVzIGluc2lkZSAkSE9NRS90by9ncm91cAotCVtpbmNsdWRlSWYgImdpdGRpcjp+L3RvL2dyb3VwLyJdCi0JCXBhdGggPSAvcGF0aC90by9mb28uaW5jCis7IGluY2x1ZGUgZm9yIGFsbCByZXBvc2l0b3JpZXMgaW5zaWRlICRIT01FL3RvL2dyb3VwCitbaW5jbHVkZUlmICJnaXRkaXI6fi90by9ncm91cC8iXQorCXBhdGggPSAvcGF0aC90by9mb28uaW5jCiAKLQk7IHJlbGF0aXZlIHBhdGhzIGFyZSBhbHdheXMgcmVsYXRpdmUgdG8gdGhlIGluY2x1ZGluZwotCTsgZmlsZSAoaWYgdGhlIGNvbmRpdGlvbiBpcyB0cnVlKTsgdGhlaXIgbG9jYXRpb24gaXMgbm90Ci0JOyBhZmZlY3RlZCBieSB0aGUgY29uZGl0aW9uCi0JW2luY2x1ZGVJZiAiZ2l0ZGlyOi9wYXRoL3RvL2dyb3VwLyJdCi0JCXBhdGggPSBmb28uaW5jCis7IHJlbGF0aXZlIHBhdGhzIGFyZSBhbHdheXMgcmVsYXRpdmUgdG8gdGhlIGluY2x1ZGluZworOyBmaWxlIChpZiB0aGUgY29uZGl0aW9uIGlzIHRydWUpOyB0aGVpciBsb2NhdGlvbiBpcyBub3QKKzsgYWZmZWN0ZWQgYnkgdGhlIGNvbmRpdGlvbgorW2luY2x1ZGVJZiAiZ2l0ZGlyOi9wYXRoL3RvL2dyb3VwLyJdCisJcGF0aCA9IGZvby5pbmMKKy0tLS0KIAogCTsgaW5jbHVkZSBvbmx5IGlmIHdlIGFyZSBpbiBhIHdvcmt0cmVlIHdoZXJlIGZvby1icmFuY2ggaXMKIAk7IGN1cnJlbnRseSBjaGVja2VkIG91dApAQCAtMzQ1LDYgKzM0Nyw4IEBACiAKIGluY2x1ZGU6OmNvbmZpZy9mYXN0aW1wb3J0LnR4dFtdCiAKK2luY2x1ZGU6OmNvbmZpZy9mZWF0dXJlLnR4dFtdCisKIGluY2x1ZGU6OmNvbmZpZy9mZXRjaC50eHRbXQogCiBpbmNsdWRlOjpjb25maWcvZm9ybWF0LnR4dFtdCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2NvbmZpZy9hZGQudHh0IGIvRG9jdW1lbnRhdGlvbi9jb25maWcvYWRkLnR4dAppbmRleCA0ZDc1M2YwLi5jOWY3NDhmIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2NvbmZpZy9hZGQudHh0CisrKyBiL0RvY3VtZW50YXRpb24vY29uZmlnL2FkZC50eHQKQEAgLTUsMyArNSw4IEBACiAJb3B0aW9uIG9mIGxpbmtnaXQ6Z2l0LWFkZFsxXS4gIGBhZGQuaWdub3JlLWVycm9yc2AgaXMgZGVwcmVjYXRlZCwKIAlhcyBpdCBkb2VzIG5vdCBmb2xsb3cgdGhlIHVzdWFsIG5hbWluZyBjb252ZW50aW9uIGZvciBjb25maWd1cmF0aW9uCiAJdmFyaWFibGVzLgorCithZGQuaW50ZXJhY3RpdmUudXNlQnVpbHRpbjo6CisJW0VYUEVSSU1FTlRBTF0gU2V0IHRvIGB0cnVlYCB0byB1c2UgdGhlIGV4cGVyaW1lbnRhbCBidWlsdC1pbgorCWltcGxlbWVudGF0aW9uIG9mIHRoZSBpbnRlcmFjdGl2ZSB2ZXJzaW9uIG9mIGxpbmtnaXQ6Z2l0LWFkZFsxXQorCWluc3RlYWQgb2YgdGhlIFBlcmwgc2NyaXB0IHZlcnNpb24uIElzIGBmYWxzZWAgYnkgZGVmYXVsdC4KZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vY29uZmlnL2NvcmUudHh0IGIvRG9jdW1lbnRhdGlvbi9jb25maWcvY29yZS50eHQKaW5kZXggNzU1MzhkMi4uODUyZDJiYSAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9jb25maWcvY29yZS50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9jb25maWcvY29yZS50eHQKQEAgLTg2LDcgKzg2LDkgQEAKIAlpdCB3aWxsIGF1dG9tYXRpY2FsbHkgYmUgcmVtb3ZlZCwgaWYgc2V0IHRvIGBmYWxzZWAuIEJlZm9yZQogCXNldHRpbmcgaXQgdG8gYHRydWVgLCB5b3Ugc2hvdWxkIGNoZWNrIHRoYXQgbXRpbWUgaXMgd29ya2luZwogCXByb3Blcmx5IG9uIHlvdXIgc3lzdGVtLgotCVNlZSBsaW5rZ2l0OmdpdC11cGRhdGUtaW5kZXhbMV0uIGBrZWVwYCBieSBkZWZhdWx0LgorCVNlZSBsaW5rZ2l0OmdpdC11cGRhdGUtaW5kZXhbMV0uIGBrZWVwYCBieSBkZWZhdWx0LCB1bmxlc3MKKwlgZmVhdHVyZS5tYW55RmlsZXNgIGlzIGVuYWJsZWQgd2hpY2ggc2V0cyB0aGlzIHNldHRpbmcgdG8KKwlgdHJ1ZWAgYnkgZGVmYXVsdC4KIAogY29yZS5jaGVja1N0YXQ6OgogCVdoZW4gbWlzc2luZyBvciBpcyBzZXQgdG8gYGRlZmF1bHRgLCBtYW55IGZpZWxkcyBpbiB0aGUgc3RhdApAQCAtNTc3LDcgKzU3OSw3IEBACiAKIGNvcmUuY29tbWl0R3JhcGg6OgogCUlmIHRydWUsIHRoZW4gZ2l0IHdpbGwgcmVhZCB0aGUgY29tbWl0LWdyYXBoIGZpbGUgKGlmIGl0IGV4aXN0cykKLQl0byBwYXJzZSB0aGUgZ3JhcGggc3RydWN0dXJlIG9mIGNvbW1pdHMuIERlZmF1bHRzIHRvIGZhbHNlLiBTZWUKKwl0byBwYXJzZSB0aGUgZ3JhcGggc3RydWN0dXJlIG9mIGNvbW1pdHMuIERlZmF1bHRzIHRvIHRydWUuIFNlZQogCWxpbmtnaXQ6Z2l0LWNvbW1pdC1ncmFwaFsxXSBmb3IgbW9yZSBpbmZvcm1hdGlvbi4KIAogY29yZS51c2VSZXBsYWNlUmVmczo6CmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2NvbmZpZy9kaWZmLnR4dCBiL0RvY3VtZW50YXRpb24vY29uZmlnL2RpZmYudHh0CmluZGV4IDVhZmI1YTIuLmZmMDlmMWMgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vY29uZmlnL2RpZmYudHh0CisrKyBiL0RvY3VtZW50YXRpb24vY29uZmlnL2RpZmYudHh0CkBAIC0xODksNyArMTg5LDcgQEAKIGluY2x1ZGU6Oi4uL21lcmdldG9vbHMtZGlmZi50eHRbXQogCiBkaWZmLmluZGVudEhldXJpc3RpYzo6Ci0JU2V0IHRoaXMgb3B0aW9uIHRvIGB0cnVlYCB0byBlbmFibGUgZXhwZXJpbWVudGFsIGhldXJpc3RpY3MKKwlTZXQgdGhpcyBvcHRpb24gdG8gYGZhbHNlYCB0byBkaXNhYmxlIHRoZSBkZWZhdWx0IGhldXJpc3RpY3MKIAl0aGF0IHNoaWZ0IGRpZmYgaHVuayBib3VuZGFyaWVzIHRvIG1ha2UgcGF0Y2hlcyBlYXNpZXIgdG8gcmVhZC4KIAogZGlmZi5hbGdvcml0aG06OgpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9jb25maWcvZmVhdHVyZS50eHQgYi9Eb2N1bWVudGF0aW9uL2NvbmZpZy9mZWF0dXJlLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi44NzVmOGM4Ci0tLSAvZGV2L251bGwKKysrIGIvRG9jdW1lbnRhdGlvbi9jb25maWcvZmVhdHVyZS50eHQKQEAgLTAsMCArMSwzNyBAQAorZmVhdHVyZS4qOjoKKwlUaGUgY29uZmlnIHNldHRpbmdzIHRoYXQgc3RhcnQgd2l0aCBgZmVhdHVyZS5gIG1vZGlmeSB0aGUgZGVmYXVsdHMgb2YKKwlhIGdyb3VwIG9mIG90aGVyIGNvbmZpZyBzZXR0aW5ncy4gVGhlc2UgZ3JvdXBzIGFyZSBjcmVhdGVkIGJ5IHRoZSBHaXQKKwlkZXZlbG9wZXIgY29tbXVuaXR5IGFzIHJlY29tbWVuZGVkIGRlZmF1bHRzIGFuZCBhcmUgc3ViamVjdCB0byBjaGFuZ2UuCisJSW4gcGFydGljdWxhciwgbmV3IGNvbmZpZyBvcHRpb25zIG1heSBiZSBhZGRlZCB3aXRoIGRpZmZlcmVudCBkZWZhdWx0cy4KKworZmVhdHVyZS5leHBlcmltZW50YWw6OgorCUVuYWJsZSBjb25maWcgb3B0aW9ucyB0aGF0IGFyZSBuZXcgdG8gR2l0LCBhbmQgYXJlIGJlaW5nIGNvbnNpZGVyZWQgZm9yCisJZnV0dXJlIGRlZmF1bHRzLiBDb25maWcgc2V0dGluZ3MgaW5jbHVkZWQgaGVyZSBtYXkgYmUgYWRkZWQgb3IgcmVtb3ZlZAorCXdpdGggZWFjaCByZWxlYXNlLCBpbmNsdWRpbmcgbWlub3IgdmVyc2lvbiB1cGRhdGVzLiBUaGVzZSBzZXR0aW5ncyBtYXkKKwloYXZlIHVuaW50ZW5kZWQgaW50ZXJhY3Rpb25zIHNpbmNlIHRoZXkgYXJlIHNvIG5ldy4gUGxlYXNlIGVuYWJsZSB0aGlzCisJc2V0dGluZyBpZiB5b3UgYXJlIGludGVyZXN0ZWQgaW4gcHJvdmlkaW5nIGZlZWRiYWNrIG9uIGV4cGVyaW1lbnRhbAorCWZlYXR1cmVzLiBUaGUgbmV3IGRlZmF1bHQgdmFsdWVzIGFyZToKKysKKyogYHBhY2sudXNlU3BhcnNlPXRydWVgIHVzZXMgYSBuZXcgYWxnb3JpdGhtIHdoZW4gY29uc3RydWN0aW5nIGEgcGFjay1maWxlCit3aGljaCBjYW4gaW1wcm92ZSBgZ2l0IHB1c2hgIHBlcmZvcm1hbmNlIGluIHJlcG9zIHdpdGggbWFueSBmaWxlcy4KKysKKyogYGZldGNoLm5lZ290aWF0aW9uQWxnb3JpdGhtPXNraXBwaW5nYCBtYXkgaW1wcm92ZSBmZXRjaCBuZWdvdGlhdGlvbiB0aW1lcyBieQorc2tpcHBpbmcgbW9yZSBjb21taXRzIGF0IGEgdGltZSwgcmVkdWNpbmcgdGhlIG51bWJlciBvZiByb3VuZCB0cmlwcy4KKysKKyogYGZldGNoLndyaXRlQ29tbWl0R3JhcGg9dHJ1ZWAgd3JpdGVzIGEgY29tbWl0LWdyYXBoIGFmdGVyIGV2ZXJ5IGBnaXQgZmV0Y2hgCitjb21tYW5kIHRoYXQgZG93bmxvYWRzIGEgcGFjay1maWxlIGZyb20gYSByZW1vdGUuIFVzaW5nIHRoZSBgLS1zcGxpdGAgb3B0aW9uLAorbW9zdCBleGVjdXRpb25zIHdpbGwgY3JlYXRlIGEgdmVyeSBzbWFsbCBjb21taXQtZ3JhcGggZmlsZSBvbiB0b3Agb2YgdGhlCitleGlzdGluZyBjb21taXQtZ3JhcGggZmlsZShzKS4gT2NjYXNpb25hbGx5LCB0aGVzZSBmaWxlcyB3aWxsIG1lcmdlIGFuZCB0aGUKK3dyaXRlIG1heSB0YWtlIGxvbmdlci4gSGF2aW5nIGFuIHVwZGF0ZWQgY29tbWl0LWdyYXBoIGZpbGUgaGVscHMgcGVyZm9ybWFuY2UKK29mIG1hbnkgR2l0IGNvbW1hbmRzLCBpbmNsdWRpbmcgYGdpdCBtZXJnZS1iYXNlYCwgYGdpdCBwdXNoIC1mYCwgYW5kCitgZ2l0IGxvZyAtLWdyYXBoYC4KKworZmVhdHVyZS5tYW55RmlsZXM6OgorCUVuYWJsZSBjb25maWcgb3B0aW9ucyB0aGF0IG9wdGltaXplIGZvciByZXBvcyB3aXRoIG1hbnkgZmlsZXMgaW4gdGhlCisJd29ya2luZyBkaXJlY3RvcnkuIFdpdGggbWFueSBmaWxlcywgY29tbWFuZHMgc3VjaCBhcyBgZ2l0IHN0YXR1c2AgYW5kCisJYGdpdCBjaGVja291dGAgbWF5IGJlIHNsb3cgYW5kIHRoZXNlIG5ldyBkZWZhdWx0cyBpbXByb3ZlIHBlcmZvcm1hbmNlOgorKworKiBgaW5kZXgudmVyc2lvbj00YCBlbmFibGVzIHBhdGgtcHJlZml4IGNvbXByZXNzaW9uIGluIHRoZSBpbmRleC4KKysKKyogYGNvcmUudW50cmFja2VkQ2FjaGU9dHJ1ZWAgZW5hYmxlcyB0aGUgdW50cmFja2VkIGNhY2hlLiBUaGlzIHNldHRpbmcgYXNzdW1lcwordGhhdCBtdGltZSBpcyB3b3JraW5nIG9uIHlvdXIgbWFjaGluZS4KZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vY29uZmlnL2ZldGNoLnR4dCBiL0RvY3VtZW50YXRpb24vY29uZmlnL2ZldGNoLnR4dAppbmRleCBiYTg5MGI1Li5mMTE5NDAyIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2NvbmZpZy9mZXRjaC50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9jb25maWcvZmV0Y2gudHh0CkBAIC01OSw3ICs1OSw4IEBACiAJZWZmb3J0IHRvIGNvbnZlcmdlIGZhc3RlciwgYnV0IG1heSByZXN1bHQgaW4gYSBsYXJnZXItdGhhbi1uZWNlc3NhcnkKIAlwYWNrZmlsZTsgVGhlIGRlZmF1bHQgaXMgImRlZmF1bHQiIHdoaWNoIGluc3RydWN0cyBHaXQgdG8gdXNlIHRoZSBkZWZhdWx0IGFsZ29yaXRobQogCXRoYXQgbmV2ZXIgc2tpcHMgY29tbWl0cyAodW5sZXNzIHRoZSBzZXJ2ZXIgaGFzIGFja25vd2xlZGdlZCBpdCBvciBvbmUKLQlvZiBpdHMgZGVzY2VuZGFudHMpLgorCW9mIGl0cyBkZXNjZW5kYW50cykuIElmIGBmZWF0dXJlLmV4cGVyaW1lbnRhbGAgaXMgZW5hYmxlZCwgdGhlbiB0aGlzCisJc2V0dGluZyBkZWZhdWx0cyB0byAic2tpcHBpbmciLgogCVVua25vd24gdmFsdWVzIHdpbGwgY2F1c2UgJ2dpdCBmZXRjaCcgdG8gZXJyb3Igb3V0LgogKwogU2VlIGFsc28gdGhlIGAtLW5lZ290aWF0aW9uLXRpcGAgb3B0aW9uIGZvciBsaW5rZ2l0OmdpdC1mZXRjaFsxXS4KQEAgLTY4LDMgKzY5LDIzIEBACiAJU2V0IHRvIGZhbHNlIHRvIGVuYWJsZSBgLS1uby1zaG93LWZvcmNlZC11cGRhdGVzYCBpbgogCWxpbmtnaXQ6Z2l0LWZldGNoWzFdIGFuZCBsaW5rZ2l0OmdpdC1wdWxsWzFdIGNvbW1hbmRzLgogCURlZmF1bHRzIHRvIHRydWUuCisKK2ZldGNoLnBhcmFsbGVsOjoKKwlTcGVjaWZpZXMgdGhlIG1heGltYWwgbnVtYmVyIG9mIGZldGNoIG9wZXJhdGlvbnMgdG8gYmUgcnVuIGluIHBhcmFsbGVsCisJYXQgYSB0aW1lIChzdWJtb2R1bGVzLCBvciByZW1vdGVzIHdoZW4gdGhlIGAtLW11bHRpcGxlYCBvcHRpb24gb2YKKwlsaW5rZ2l0OmdpdC1mZXRjaFsxXSBpcyBpbiBlZmZlY3QpLgorKworQSB2YWx1ZSBvZiAwIHdpbGwgZ2l2ZSBzb21lIHJlYXNvbmFibGUgZGVmYXVsdC4gSWYgdW5zZXQsIGl0IGRlZmF1bHRzIHRvIDEuCisrCitGb3Igc3VibW9kdWxlcywgdGhpcyBzZXR0aW5nIGNhbiBiZSBvdmVycmlkZGVuIHVzaW5nIHRoZSBgc3VibW9kdWxlLmZldGNoSm9ic2AKK2NvbmZpZyBzZXR0aW5nLgorCitmZXRjaC53cml0ZUNvbW1pdEdyYXBoOjoKKwlTZXQgdG8gdHJ1ZSB0byB3cml0ZSBhIGNvbW1pdC1ncmFwaCBhZnRlciBldmVyeSBgZ2l0IGZldGNoYCBjb21tYW5kCisJdGhhdCBkb3dubG9hZHMgYSBwYWNrLWZpbGUgZnJvbSBhIHJlbW90ZS4gVXNpbmcgdGhlIGAtLXNwbGl0YCBvcHRpb24sCisJbW9zdCBleGVjdXRpb25zIHdpbGwgY3JlYXRlIGEgdmVyeSBzbWFsbCBjb21taXQtZ3JhcGggZmlsZSBvbiB0b3Agb2YKKwl0aGUgZXhpc3RpbmcgY29tbWl0LWdyYXBoIGZpbGUocykuIE9jY2FzaW9uYWxseSwgdGhlc2UgZmlsZXMgd2lsbAorCW1lcmdlIGFuZCB0aGUgd3JpdGUgbWF5IHRha2UgbG9uZ2VyLiBIYXZpbmcgYW4gdXBkYXRlZCBjb21taXQtZ3JhcGgKKwlmaWxlIGhlbHBzIHBlcmZvcm1hbmNlIG9mIG1hbnkgR2l0IGNvbW1hbmRzLCBpbmNsdWRpbmcgYGdpdCBtZXJnZS1iYXNlYCwKKwlgZ2l0IHB1c2ggLWZgLCBhbmQgYGdpdCBsb2cgLS1ncmFwaGAuIERlZmF1bHRzIHRvIGZhbHNlLCB1bmxlc3MKKwlgZmVhdHVyZS5leHBlcmltZW50YWxgIGlzIHRydWUuCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2NvbmZpZy9mb3JtYXQudHh0IGIvRG9jdW1lbnRhdGlvbi9jb25maWcvZm9ybWF0LnR4dAppbmRleCA0MTRhNWE4Li41MTNmY2Q4IDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2NvbmZpZy9mb3JtYXQudHh0CisrKyBiL0RvY3VtZW50YXRpb24vY29uZmlnL2Zvcm1hdC50eHQKQEAgLTM2LDYgKzM2LDEyIEBACiAJVGhlIGRlZmF1bHQgZm9yIGZvcm1hdC1wYXRjaCBpcyB0byBvdXRwdXQgZmlsZXMgd2l0aCB0aGUgJ1tQQVRDSF0nCiAJc3ViamVjdCBwcmVmaXguIFVzZSB0aGlzIHZhcmlhYmxlIHRvIGNoYW5nZSB0aGF0IHByZWZpeC4KIAorZm9ybWF0LmNvdmVyRnJvbURlc2NyaXB0aW9uOjoKKwlUaGUgZGVmYXVsdCBtb2RlIGZvciBmb3JtYXQtcGF0Y2ggdG8gZGV0ZXJtaW5lIHdoaWNoIHBhcnRzIG9mCisJdGhlIGNvdmVyIGxldHRlciB3aWxsIGJlIHBvcHVsYXRlZCB1c2luZyB0aGUgYnJhbmNoJ3MKKwlkZXNjcmlwdGlvbi4gU2VlIHRoZSBgLS1jb3Zlci1mcm9tLWRlc2NyaXB0aW9uYCBvcHRpb24gaW4KKwlsaW5rZ2l0OmdpdC1mb3JtYXQtcGF0Y2hbMV0uCisKIGZvcm1hdC5zaWduYXR1cmU6OgogCVRoZSBkZWZhdWx0IGZvciBmb3JtYXQtcGF0Y2ggaXMgdG8gb3V0cHV0IGEgc2lnbmF0dXJlIGNvbnRhaW5pbmcKIAl0aGUgR2l0IHZlcnNpb24gbnVtYmVyLiBVc2UgdGhpcyB2YXJpYWJsZSB0byBjaGFuZ2UgdGhhdCBkZWZhdWx0LgpAQCAtNzcsMTAgKzgzLDExIEBACiAJQSBib29sZWFuIHRoYXQgY29udHJvbHMgd2hldGhlciB0byBnZW5lcmF0ZSBhIGNvdmVyLWxldHRlciB3aGVuCiAJZm9ybWF0LXBhdGNoIGlzIGludm9rZWQsIGJ1dCBpbiBhZGRpdGlvbiBjYW4gYmUgc2V0IHRvICJhdXRvIiwgdG8KIAlnZW5lcmF0ZSBhIGNvdmVyLWxldHRlciBvbmx5IHdoZW4gdGhlcmUncyBtb3JlIHRoYW4gb25lIHBhdGNoLgorCURlZmF1bHQgaXMgZmFsc2UuCiAKIGZvcm1hdC5vdXRwdXREaXJlY3Rvcnk6OgogCVNldCBhIGN1c3RvbSBkaXJlY3RvcnkgdG8gc3RvcmUgdGhlIHJlc3VsdGluZyBmaWxlcyBpbnN0ZWFkIG9mIHRoZQotCWN1cnJlbnQgd29ya2luZyBkaXJlY3RvcnkuCisJY3VycmVudCB3b3JraW5nIGRpcmVjdG9yeS4gQWxsIGRpcmVjdG9yeSBjb21wb25lbnRzIHdpbGwgYmUgY3JlYXRlZC4KIAogZm9ybWF0LnVzZUF1dG9CYXNlOjoKIAlBIGJvb2xlYW4gdmFsdWUgd2hpY2ggbGV0cyB5b3UgZW5hYmxlIHRoZSBgLS1iYXNlPWF1dG9gIG9wdGlvbiBvZgpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9jb25maWcvZ2MudHh0IGIvRG9jdW1lbnRhdGlvbi9jb25maWcvZ2MudHh0CmluZGV4IDAyYjkyYjEuLjAwZWEwYTYgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vY29uZmlnL2djLnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL2NvbmZpZy9nYy50eHQKQEAgLTYzLDcgKzYzLDcgQEAKIAlJZiB0cnVlLCB0aGVuIGdjIHdpbGwgcmV3cml0ZSB0aGUgY29tbWl0LWdyYXBoIGZpbGUgd2hlbgogCWxpbmtnaXQ6Z2l0LWdjWzFdIGlzIHJ1bi4gV2hlbiB1c2luZyBgZ2l0IGdjIC0tYXV0b2AKIAl0aGUgY29tbWl0LWdyYXBoIHdpbGwgYmUgdXBkYXRlZCBpZiBob3VzZWtlZXBpbmcgaXMKLQlyZXF1aXJlZC4gRGVmYXVsdCBpcyBmYWxzZS4gU2VlIGxpbmtnaXQ6Z2l0LWNvbW1pdC1ncmFwaFsxXQorCXJlcXVpcmVkLiBEZWZhdWx0IGlzIHRydWUuIFNlZSBsaW5rZ2l0OmdpdC1jb21taXQtZ3JhcGhbMV0KIAlmb3IgZGV0YWlscy4KIAogZ2MubG9nRXhwaXJ5OjoKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vY29uZmlnL2luZGV4LnR4dCBiL0RvY3VtZW50YXRpb24vY29uZmlnL2luZGV4LnR4dAppbmRleCBmMTgxNTAzLi43Y2I1MGIzIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2NvbmZpZy9pbmRleC50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9jb25maWcvaW5kZXgudHh0CkBAIC0yNCwzICsyNCw0IEBACiBpbmRleC52ZXJzaW9uOjoKIAlTcGVjaWZ5IHRoZSB2ZXJzaW9uIHdpdGggd2hpY2ggbmV3IGluZGV4IGZpbGVzIHNob3VsZCBiZQogCWluaXRpYWxpemVkLiAgVGhpcyBkb2VzIG5vdCBhZmZlY3QgZXhpc3RpbmcgcmVwb3NpdG9yaWVzLgorCUlmIGBmZWF0dXJlLm1hbnlGaWxlc2AgaXMgZW5hYmxlZCwgdGhlbiB0aGUgZGVmYXVsdCBpcyA0LgpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9jb25maWcvcGFjay50eHQgYi9Eb2N1bWVudGF0aW9uL2NvbmZpZy9wYWNrLnR4dAppbmRleCA5Y2RjZmE3Li4xZDY2ZjBjIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2NvbmZpZy9wYWNrLnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL2NvbmZpZy9wYWNrLnR4dApAQCAtMTEyLDcgKzExMiw4IEBACiAJb2JqZWN0cy4gVGhpcyBjYW4gaGF2ZSBzaWduaWZpY2FudCBwZXJmb3JtYW5jZSBiZW5lZml0cyB3aGVuCiAJY29tcHV0aW5nIGEgcGFjayB0byBzZW5kIGEgc21hbGwgY2hhbmdlLiBIb3dldmVyLCBpdCBpcyBwb3NzaWJsZQogCXRoYXQgZXh0cmEgb2JqZWN0cyBhcmUgYWRkZWQgdG8gdGhlIHBhY2stZmlsZSBpZiB0aGUgaW5jbHVkZWQKLQljb21taXRzIGNvbnRhaW4gY2VydGFpbiB0eXBlcyBvZiBkaXJlY3QgcmVuYW1lcy4KKwljb21taXRzIGNvbnRhaW4gY2VydGFpbiB0eXBlcyBvZiBkaXJlY3QgcmVuYW1lcy4gRGVmYXVsdCBpcyBgZmFsc2VgCisJdW5sZXNzIGBmZWF0dXJlLmV4cGVyaW1lbnRhbGAgaXMgZW5hYmxlZC4KIAogcGFjay53cml0ZUJpdG1hcHMgKGRlcHJlY2F0ZWQpOjoKIAlUaGlzIGlzIGEgZGVwcmVjYXRlZCBzeW5vbnltIGZvciBgcmVwYWNrLndyaXRlQml0bWFwc2AuCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2NvbmZpZy9yZW1vdGUudHh0IGIvRG9jdW1lbnRhdGlvbi9jb25maWcvcmVtb3RlLnR4dAppbmRleCA2YzRjYWQ4Li5hOGU2NDM3IDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2NvbmZpZy9yZW1vdGUudHh0CisrKyBiL0RvY3VtZW50YXRpb24vY29uZmlnL3JlbW90ZS50eHQKQEAgLTc2LDMgKzc2LDExIEBACiArCiBTZWUgYWxzbyBgcmVtb3RlLjxuYW1lPi5wcnVuZWAgYW5kIHRoZSBQUlVOSU5HIHNlY3Rpb24gb2YKIGxpbmtnaXQ6Z2l0LWZldGNoWzFdLgorCityZW1vdGUuPG5hbWU+LnByb21pc29yOjoKKwlXaGVuIHNldCB0byB0cnVlLCB0aGlzIHJlbW90ZSB3aWxsIGJlIHVzZWQgdG8gZmV0Y2ggcHJvbWlzb3IKKwlvYmplY3RzLgorCityZW1vdGUuPG5hbWU+LnBhcnRpYWxjbG9uZWZpbHRlcjo6CisJVGhlIGZpbHRlciB0aGF0IHdpbGwgYmUgYXBwbGllZCB3aGVuIGZldGNoaW5nIGZyb20gdGhpcworCXByb21pc29yIHJlbW90ZS4KZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vY29uZmlnL3RhZy50eHQgYi9Eb2N1bWVudGF0aW9uL2NvbmZpZy90YWcudHh0CmluZGV4IGVmNWFkYjMuLjZkOTExMGQgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vY29uZmlnL3RhZy50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9jb25maWcvdGFnLnR4dApAQCAtMTMsNyArMTMsNyBAQAogCVVzZSBvZiB0aGlzIG9wdGlvbiB3aGVuIHJ1bm5pbmcgaW4gYW4gYXV0b21hdGVkIHNjcmlwdCBjYW4KIAlyZXN1bHQgaW4gYSBsYXJnZSBudW1iZXIgb2YgdGFncyBiZWluZyBzaWduZWQuIEl0IGlzIHRoZXJlZm9yZQogCWNvbnZlbmllbnQgdG8gdXNlIGFuIGFnZW50IHRvIGF2b2lkIHR5cGluZyB5b3VyIGdwZyBwYXNzcGhyYXNlCi0Jc2V2ZXJhbCB0aW1lcy4gTm90ZSB0aGF0IHRoaXMgb3B0aW9uIGRvZXNuJ3QgYWZmZWN0cyB0YWcgc2lnbmluZworCXNldmVyYWwgdGltZXMuIE5vdGUgdGhhdCB0aGlzIG9wdGlvbiBkb2Vzbid0IGFmZmVjdCB0YWcgc2lnbmluZwogCWJlaGF2aW9yIGVuYWJsZWQgYnkgIi11IDxrZXlpZD4iIG9yICItLWxvY2FsLXVzZXI9PGtleWlkPiIgb3B0aW9ucy4KIAogdGFyLnVtYXNrOjoKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vY29uZmlnL3RyYWNlMi50eHQgYi9Eb2N1bWVudGF0aW9uL2NvbmZpZy90cmFjZTIudHh0CmluZGV4IDJlZGJmYjAuLjRjZTBiOWEgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vY29uZmlnL3RyYWNlMi50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9jb25maWcvdHJhY2UyLnR4dApAQCAtNTQsMyArNTQsOSBAQAogCUJ5IGRlZmF1bHQsIHRoZXNlIGVycm9ycyBhcmUgc3VwcHJlc3NlZCBhbmQgdHJhY2luZyBpcwogCXNpbGVudGx5IGRpc2FibGVkLiAgTWF5IGJlIG92ZXJyaWRkZW4gYnkgdGhlCiAJYEdJVF9UUkFDRTJfRFNUX0RFQlVHYCBlbnZpcm9ubWVudCB2YXJpYWJsZS4KKwordHJhY2UyLm1heEZpbGVzOjoKKwlJbnRlZ2VyLiAgV2hlbiB3cml0aW5nIHRyYWNlIGZpbGVzIHRvIGEgdGFyZ2V0IGRpcmVjdG9yeSwgZG8gbm90CisJd3JpdGUgYWRkaXRpb25hbCB0cmFjZXMgaWYgd2Ugd291bGQgZXhjZWVkIHRoaXMgbWFueSBmaWxlcy4gSW5zdGVhZCwKKwl3cml0ZSBhIHNlbnRpbmVsIGZpbGUgdGhhdCB3aWxsIGJsb2NrIGZ1cnRoZXIgdHJhY2luZyB0byB0aGlzCisJZGlyZWN0b3J5LiBEZWZhdWx0cyB0byAwLCB3aGljaCBkaXNhYmxlcyB0aGlzIGNoZWNrLgpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9kaWZmLWdlbmVyYXRlLXBhdGNoLnR4dCBiL0RvY3VtZW50YXRpb24vZGlmZi1nZW5lcmF0ZS1wYXRjaC50eHQKaW5kZXggZjEwY2E0MS4uZThlZDY0NyAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9kaWZmLWdlbmVyYXRlLXBhdGNoLnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL2RpZmYtZ2VuZXJhdGUtcGF0Y2gudHh0CkBAIC0xLDExICsxLDE1IEBACi1HZW5lcmF0aW5nIHBhdGNoZXMgd2l0aCAtcAotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KK0dlbmVyYXRpbmcgcGF0Y2ggdGV4dCB3aXRoIC1wCistLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogCi1XaGVuICJnaXQtZGlmZi1pbmRleCIsICJnaXQtZGlmZi10cmVlIiwgb3IgImdpdC1kaWZmLWZpbGVzIiBhcmUgcnVuCi13aXRoIGEgYC1wYCBvcHRpb24sICJnaXQgZGlmZiIgd2l0aG91dCB0aGUgYC0tcmF3YCBvcHRpb24sIG9yCi0iZ2l0IGxvZyIgd2l0aCB0aGUgIi1wIiBvcHRpb24sIHRoZXkKLWRvIG5vdCBwcm9kdWNlIHRoZSBvdXRwdXQgZGVzY3JpYmVkIGFib3ZlOyBpbnN0ZWFkIHRoZXkgcHJvZHVjZSBhCi1wYXRjaCBmaWxlLiAgWW91IGNhbiBjdXN0b21pemUgdGhlIGNyZWF0aW9uIG9mIHN1Y2ggcGF0Y2hlcyB2aWEgdGhlCitSdW5uaW5nCitsaW5rZ2l0OmdpdC1kaWZmWzFdLAorbGlua2dpdDpnaXQtbG9nWzFdLAorbGlua2dpdDpnaXQtc2hvd1sxXSwKK2xpbmtnaXQ6Z2l0LWRpZmYtaW5kZXhbMV0sCitsaW5rZ2l0OmdpdC1kaWZmLXRyZWVbMV0sIG9yCitsaW5rZ2l0OmdpdC1kaWZmLWZpbGVzWzFdCit3aXRoIHRoZSBgLXBgIG9wdGlvbiBwcm9kdWNlcyBwYXRjaCB0ZXh0LgorWW91IGNhbiBjdXN0b21pemUgdGhlIGNyZWF0aW9uIG9mIHBhdGNoIHRleHQgdmlhIHRoZQogYEdJVF9FWFRFUk5BTF9ESUZGYCBhbmQgdGhlIGBHSVRfRElGRl9PUFRTYCBlbnZpcm9ubWVudCB2YXJpYWJsZXMuCiAKIFdoYXQgdGhlIC1wIG9wdGlvbiBwcm9kdWNlcyBpcyBzbGlnaHRseSBkaWZmZXJlbnQgZnJvbSB0aGUgdHJhZGl0aW9uYWwKQEAgLTQ5LDcgKzUzLDcgQEAKIGZpbGVzLCB3aGlsZSAxMDAlIGRpc3NpbWlsYXJpdHkgbWVhbnMgdGhhdCBubyBsaW5lIGZyb20gdGhlIG9sZAogZmlsZSBtYWRlIGl0IGludG8gdGhlIG5ldyBvbmUuCiArCi1UaGUgaW5kZXggbGluZSBpbmNsdWRlcyB0aGUgU0hBLTEgY2hlY2tzdW0gYmVmb3JlIGFuZCBhZnRlciB0aGUgY2hhbmdlLgorVGhlIGluZGV4IGxpbmUgaW5jbHVkZXMgdGhlIGJsb2Igb2JqZWN0IG5hbWVzIGJlZm9yZSBhbmQgYWZ0ZXIgdGhlIGNoYW5nZS4KIFRoZSA8bW9kZT4gaXMgaW5jbHVkZWQgaWYgdGhlIGZpbGUgbW9kZSBkb2VzIG5vdCBjaGFuZ2U7IG90aGVyd2lzZSwKIHNlcGFyYXRlIGxpbmVzIGluZGljYXRlIHRoZSBvbGQgYW5kIHRoZSBuZXcgbW9kZS4KIApAQCAtNzAsNyArNzQsNyBAQAogICAgICAgcmVuYW1lIHRvIGEKIAogCi1jb21iaW5lZCBkaWZmIGZvcm1hdAorQ29tYmluZWQgZGlmZiBmb3JtYXQKIC0tLS0tLS0tLS0tLS0tLS0tLS0tCiAKIEFueSBkaWZmLWdlbmVyYXRpbmcgY29tbWFuZCBjYW4gdGFrZSB0aGUgYC1jYCBvciBgLS1jY2Agb3B0aW9uIHRvCkBAIC04MCw3ICs4NCw3IEBACiBvZiB0aGVzZSBjb21tYW5kcyB0byBmb3JjZSBnZW5lcmF0aW9uIG9mIGRpZmZzIHdpdGggaW5kaXZpZHVhbCBwYXJlbnRzCiBvZiBhIG1lcmdlLgogCi1BICdjb21iaW5lZCBkaWZmJyBmb3JtYXQgbG9va3MgbGlrZSB0aGlzOgorQSAiY29tYmluZWQgZGlmZiIgZm9ybWF0IGxvb2tzIGxpa2UgdGhpczoKIAogLS0tLS0tLS0tLS0tCiBkaWZmIC0tY29tYmluZWQgZGVzY3JpYmUuYwpAQCAtMTEzLDExICsxMTcsMTEgQEAKIC0tLS0tLS0tLS0tLQogCiAxLiAgIEl0IGlzIHByZWNlZGVkIHdpdGggYSAiZ2l0IGRpZmYiIGhlYWRlciwgdGhhdCBsb29rcyBsaWtlCi0gICAgIHRoaXMgKHdoZW4gYC1jYCBvcHRpb24gaXMgdXNlZCk6CisgICAgIHRoaXMgKHdoZW4gdGhlIGAtY2Agb3B0aW9uIGlzIHVzZWQpOgogCiAgICAgICAgZGlmZiAtLWNvbWJpbmVkIGZpbGUKICsKLW9yIGxpa2UgdGhpcyAod2hlbiBgLS1jY2Agb3B0aW9uIGlzIHVzZWQpOgorb3IgbGlrZSB0aGlzICh3aGVuIHRoZSBgLS1jY2Agb3B0aW9uIGlzIHVzZWQpOgogCiAgICAgICAgZGlmZiAtLWNjIGZpbGUKIApAQCAtMTYwLDcgKzE2NCw3IEBACiA0LiAgIENodW5rIGhlYWRlciBmb3JtYXQgaXMgbW9kaWZpZWQgdG8gcHJldmVudCBwZW9wbGUgZnJvbQogICAgICBhY2NpZGVudGFsbHkgZmVlZGluZyBpdCB0byBgcGF0Y2ggLXAxYC4gQ29tYmluZWQgZGlmZiBmb3JtYXQKICAgICAgd2FzIGNyZWF0ZWQgZm9yIHJldmlldyBvZiBtZXJnZSBjb21taXQgY2hhbmdlcywgYW5kIHdhcyBub3QKLSAgICAgbWVhbnQgZm9yIGFwcGx5LiBUaGUgY2hhbmdlIGlzIHNpbWlsYXIgdG8gdGhlIGNoYW5nZSBpbiB0aGUKKyAgICAgbWVhbnQgdG8gYmUgYXBwbGllZC4gVGhlIGNoYW5nZSBpcyBzaW1pbGFyIHRvIHRoZSBjaGFuZ2UgaW4gdGhlCiAgICAgIGV4dGVuZGVkICdpbmRleCcgaGVhZGVyOgogCiAgICAgICAgQEBAIDxmcm9tLWZpbGUtcmFuZ2U+IDxmcm9tLWZpbGUtcmFuZ2U+IDx0by1maWxlLXJhbmdlPiBAQEAKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vZG9jLWRpZmYgYi9Eb2N1bWVudGF0aW9uL2RvYy1kaWZmCmluZGV4IDMzNTViZTQuLjg4YTliMjAgMTAwNzU1Ci0tLSBhL0RvY3VtZW50YXRpb24vZG9jLWRpZmYKKysrIGIvRG9jdW1lbnRhdGlvbi9kb2MtZGlmZgpAQCAtMjEsNyArMjEsNyBAQAogdG8tYXNjaWlkb2MJCXVzZSBhc2NpaWRvYyB3aXRoIHRoZSAndG8nLWNvbW1pdAogdG8tYXNjaWlkb2N0b3IJCXVzZSBhc2NpaWRvY3RvciB3aXRoIHRoZSAndG8nLWNvbW1pdAogYXNjaWlkb2N0b3IJCXVzZSBhc2NpaWRvY3RvciB3aXRoIGJvdGggY29tbWl0cwotY3V0LWhlYWRlci1mb290ZXIJY3V0IGF3YXkgaGVhZGVyIGFuZCBmb290ZXIKK2N1dC1mb290ZXIJCWN1dCBhd2F5IGZvb3RlcgogIgogU1VCRElSRUNUT1JZX09LPTEKIC4gIiQoZ2l0IC0tZXhlYy1wYXRoKS9naXQtc2gtc2V0dXAiCkBAIC0zMSw3ICszMSw3IEBACiBjbGVhbj0KIGZyb21fcHJvZ3JhbT0KIHRvX3Byb2dyYW09Ci1jdXRfaGVhZGVyX2Zvb3Rlcj0KK2N1dF9mb290ZXI9CiB3aGlsZSB0ZXN0ICQjIC1ndCAwCiBkbwogCWNhc2UgIiQxIiBpbgpAQCAtNTUsOCArNTUsOCBAQAogCS0tYXNjaWlkb2MpCiAJCWZyb21fcHJvZ3JhbT0tYXNjaWlkb2MKIAkJdG9fcHJvZ3JhbT0tYXNjaWlkb2MgOzsKLQktLWN1dC1oZWFkZXItZm9vdGVyKQotCQljdXRfaGVhZGVyX2Zvb3Rlcj0tY3V0LWhlYWRlci1mb290ZXIgOzsKKwktLWN1dC1mb290ZXIpCisJCWN1dF9mb290ZXI9LWN1dC1mb290ZXIgOzsKIAktLSkKIAkJc2hpZnQ7IGJyZWFrIDs7CiAJKikKQEAgLTExOCw4ICsxMTgsOCBAQAogZnJvbV9tYWtlbWFuZmxhZ3M9JChjb25zdHJ1Y3RfbWFrZW1hbmZsYWdzICIkZnJvbV9wcm9ncmFtIikgJiYKIHRvX21ha2VtYW5mbGFncz0kKGNvbnN0cnVjdF9tYWtlbWFuZmxhZ3MgIiR0b19wcm9ncmFtIikgJiYKIAotZnJvbV9kaXI9JGZyb21fb2lkJGZyb21fcHJvZ3JhbSRjdXRfaGVhZGVyX2Zvb3RlciAmJgotdG9fZGlyPSR0b19vaWQkdG9fcHJvZ3JhbSRjdXRfaGVhZGVyX2Zvb3RlciAmJgorZnJvbV9kaXI9JGZyb21fb2lkJGZyb21fcHJvZ3JhbSRjdXRfZm9vdGVyICYmCit0b19kaXI9JHRvX29pZCR0b19wcm9ncmFtJGN1dF9mb290ZXIgJiYKIAogIyBnZW5lcmF0ZV9yZW5kZXJfbWFrZWZpbGUgPHNyY2Rpcj4gPGRzdGRpcj4KIGdlbmVyYXRlX3JlbmRlcl9tYWtlZmlsZSAoKSB7CkBAIC0xNjksMTIgKzE2OSwxMSBAQAogCQltYWtlIC1qJHBhcmFsbGVsIC1mIC0gJiYKIAkJbXYgIiR0bXAvcmVuZGVyZWQvJGRuYW1lKyIgIiR0bXAvcmVuZGVyZWQvJGRuYW1lIgogCi0JCWlmIHRlc3QgIiRjdXRfaGVhZGVyX2Zvb3RlciIgPSAiLWN1dC1oZWFkZXItZm9vdGVyIgorCQlpZiB0ZXN0ICIkY3V0X2Zvb3RlciIgPSAiLWN1dC1mb290ZXIiCiAJCXRoZW4KIAkJCWZvciBmIGluICQoZmluZCAiJHRtcC9yZW5kZXJlZC8kZG5hbWUiIC10eXBlIGYpCiAJCQlkbwotCQkJCXRhaWwgLW4gKzMgIiRmIiB8IGhlYWQgLW4gLTIgfAotCQkJCXNlZCAtZSAnMXsvXiQvZH0nIC1lICckey9eJC9kfScgPiIkZisiICYmCisJCQkJaGVhZCAtbiAtMiAiJGYiIHwgc2VkIC1lICckey9eJC9kfScgPiIkZisiICYmCiAJCQkJbXYgIiRmKyIgIiRmIiB8fAogCQkJCXJldHVybiAxCiAJCQlkb25lCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2ZldGNoLW9wdGlvbnMudHh0IGIvRG9jdW1lbnRhdGlvbi9mZXRjaC1vcHRpb25zLnR4dAppbmRleCAzYzliNGY5Li5hMmY3ODYyIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2ZldGNoLW9wdGlvbnMudHh0CisrKyBiL0RvY3VtZW50YXRpb24vZmV0Y2gtb3B0aW9ucy50eHQKQEAgLTkyLDYgKzkyLDEwIEBACiAJUnVuIGBnaXQgZ2MgLS1hdXRvYCBhdCB0aGUgZW5kIHRvIHBlcmZvcm0gZ2FyYmFnZSBjb2xsZWN0aW9uCiAJaWYgbmVlZGVkLiBUaGlzIGlzIGVuYWJsZWQgYnkgZGVmYXVsdC4KIAorLS1bbm8tXXdyaXRlLWNvbW1pdC1ncmFwaDo6CisJV3JpdGUgYSBjb21taXQtZ3JhcGggYWZ0ZXIgZmV0Y2hpbmcuIFRoaXMgb3ZlcnJpZGVzIHRoZSBjb25maWcKKwlzZXR0aW5nIGBmZXRjaC53cml0ZUNvbW1pdEdyYXBoYC4KKwogLXA6OgogLS1wcnVuZTo6CiAJQmVmb3JlIGZldGNoaW5nLCByZW1vdmUgYW55IHJlbW90ZS10cmFja2luZyByZWZlcmVuY2VzIHRoYXQgbm8KQEAgLTE2MCwxNSArMTY0LDI3IEBACiAKIC1qOjoKIC0tam9icz08bj46OgotCU51bWJlciBvZiBwYXJhbGxlbCBjaGlsZHJlbiB0byBiZSB1c2VkIGZvciBmZXRjaGluZyBzdWJtb2R1bGVzLgotCUVhY2ggd2lsbCBmZXRjaCBmcm9tIGRpZmZlcmVudCBzdWJtb2R1bGVzLCBzdWNoIHRoYXQgZmV0Y2hpbmcgbWFueQotCXN1Ym1vZHVsZXMgd2lsbCBiZSBmYXN0ZXIuIEJ5IGRlZmF1bHQgc3VibW9kdWxlcyB3aWxsIGJlIGZldGNoZWQKLQlvbmUgYXQgYSB0aW1lLgorCU51bWJlciBvZiBwYXJhbGxlbCBjaGlsZHJlbiB0byBiZSB1c2VkIGZvciBhbGwgZm9ybXMgb2YgZmV0Y2hpbmcuCisrCitJZiB0aGUgYC0tbXVsdGlwbGVgIG9wdGlvbiB3YXMgc3BlY2lmaWVkLCB0aGUgZGlmZmVyZW50IHJlbW90ZXMgd2lsbCBiZSBmZXRjaGVkCitpbiBwYXJhbGxlbC4gSWYgbXVsdGlwbGUgc3VibW9kdWxlcyBhcmUgZmV0Y2hlZCwgdGhleSB3aWxsIGJlIGZldGNoZWQgaW4KK3BhcmFsbGVsLiBUbyBjb250cm9sIHRoZW0gaW5kZXBlbmRlbnRseSwgdXNlIHRoZSBjb25maWcgc2V0dGluZ3MKK2BmZXRjaC5wYXJhbGxlbGAgYW5kIGBzdWJtb2R1bGUuZmV0Y2hKb2JzYCAoc2VlIGxpbmtnaXQ6Z2l0LWNvbmZpZ1sxXSkuCisrCitUeXBpY2FsbHksIHBhcmFsbGVsIHJlY3Vyc2l2ZSBhbmQgbXVsdGktcmVtb3RlIGZldGNoZXMgd2lsbCBiZSBmYXN0ZXIuIEJ5CitkZWZhdWx0IGZldGNoZXMgYXJlIHBlcmZvcm1lZCBzZXF1ZW50aWFsbHksIG5vdCBpbiBwYXJhbGxlbC4KIAogLS1uby1yZWN1cnNlLXN1Ym1vZHVsZXM6OgogCURpc2FibGUgcmVjdXJzaXZlIGZldGNoaW5nIG9mIHN1Ym1vZHVsZXMgKHRoaXMgaGFzIHRoZSBzYW1lIGVmZmVjdCBhcwogCXVzaW5nIHRoZSBgLS1yZWN1cnNlLXN1Ym1vZHVsZXM9bm9gIG9wdGlvbikuCiAKKy0tc2V0LXVwc3RyZWFtOjoKKwlJZiB0aGUgcmVtb3RlIGlzIGZldGNoZWQgc3VjY2Vzc2Z1bGx5LCBwdWxsIGFuZCBhZGQgdXBzdHJlYW0KKwkodHJhY2tpbmcpIHJlZmVyZW5jZSwgdXNlZCBieSBhcmd1bWVudC1sZXNzCisJbGlua2dpdDpnaXQtcHVsbFsxXSBhbmQgb3RoZXIgY29tbWFuZHMuIEZvciBtb3JlIGluZm9ybWF0aW9uLAorCXNlZSBgYnJhbmNoLjxuYW1lPi5tZXJnZWAgYW5kIGBicmFuY2guPG5hbWU+LnJlbW90ZWAgaW4KKwlsaW5rZ2l0OmdpdC1jb25maWdbMV0uCisKIC0tc3VibW9kdWxlLXByZWZpeD08cGF0aD46OgogCVByZXBlbmQgPHBhdGg+IHRvIHBhdGhzIHByaW50ZWQgaW4gaW5mb3JtYXRpdmUgbWVzc2FnZXMKIAlzdWNoIGFzICJGZXRjaGluZyBzdWJtb2R1bGUgZm9vIi4gIFRoaXMgb3B0aW9uIGlzIHVzZWQKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vZ2l0LWFtLnR4dCBiL0RvY3VtZW50YXRpb24vZ2l0LWFtLnR4dAppbmRleCBmYzNiOTkzLi5mYzU3NTBiIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2dpdC1hbS50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9naXQtYW0udHh0CkBAIC0xNzcsNyArMTc3LDcgQEAKIAl1bnRvdWNoZWQuCiAKIC0tc2hvdy1jdXJyZW50LXBhdGNoOjoKLQlTaG93IHRoZSBwYXRjaCBiZWluZyBhcHBsaWVkIHdoZW4gImdpdCBhbSIgaXMgc3RvcHBlZCBiZWNhdXNlCisJU2hvdyB0aGUgZW50aXJlIGUtbWFpbCBtZXNzYWdlICJnaXQgYW0iIGhhcyBzdG9wcGVkIGF0LCBiZWNhdXNlCiAJb2YgY29uZmxpY3RzLgogCiBESVNDVVNTSU9OCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2dpdC1iaXNlY3QtbGsyMDA5LnR4dCBiL0RvY3VtZW50YXRpb24vZ2l0LWJpc2VjdC1sazIwMDkudHh0CmluZGV4IGU5OTkyNTEuLjI5NTdiYzUgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vZ2l0LWJpc2VjdC1sazIwMDkudHh0CisrKyBiL0RvY3VtZW50YXRpb24vZ2l0LWJpc2VjdC1sazIwMDkudHh0CkBAIC0xNTgsNyArMTU4LDcgQEAKIHN1cHBvc2VkIHRvIGJlIHVzZWQgc28gdGhhdCBhbGwgdGhlIHRlc3RzIGFyZSBjaGVja2VkIGFmdGVyIGVhY2gKIGNvbW1pdC4gVGhpcyBtZWFucyB0aGF0IHRoZXkgYXJlIG5vdCB2ZXJ5IGVmZmljaWVudCwgYmVjYXVzZSBtYW55CiB0ZXN0cyBhcmUgcnVuIGZvciBubyBpbnRlcmVzdGluZyByZXN1bHQsIGFuZCB0aGV5IHN1ZmZlciBmcm9tCi1jb21iaW5hdGlvbmFsIGV4cGxvc2lvbi4KK2NvbWJpbmF0b3JpYWwgZXhwbG9zaW9uLgogCiBJbiBmYWN0IHRoZSBwcm9ibGVtIGlzIHRoYXQgYmlnIHNvZnR3YXJlIG9mdGVuIGhhcyBtYW55IGRpZmZlcmVudAogY29uZmlndXJhdGlvbiBvcHRpb25zIGFuZCB0aGF0IGVhY2ggdGVzdCBjYXNlIHNob3VsZCBwYXNzIGZvciBlYWNoCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2dpdC1iaXNlY3QudHh0IGIvRG9jdW1lbnRhdGlvbi9naXQtYmlzZWN0LnR4dAppbmRleCA0YjQ1ZDgzLi43NTg2YzVhIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2dpdC1iaXNlY3QudHh0CisrKyBiL0RvY3VtZW50YXRpb24vZ2l0LWJpc2VjdC50eHQKQEAgLTQxMyw3ICs0MTMsNyBAQAogCiAjIHR3ZWFrIHRoZSB3b3JraW5nIHRyZWUgYnkgbWVyZ2luZyB0aGUgaG90LWZpeCBicmFuY2gKICMgYW5kIHRoZW4gYXR0ZW1wdCBhIGJ1aWxkCi1pZglnaXQgbWVyZ2UgLS1uby1jb21taXQgaG90LWZpeCAmJgoraWYJZ2l0IG1lcmdlIC0tbm8tY29tbWl0IC0tbm8tZmYgaG90LWZpeCAmJgogCW1ha2UKIHRoZW4KIAkjIHJ1biBwcm9qZWN0IHNwZWNpZmljIHRlc3QgYW5kIHJlcG9ydCBpdHMgc3RhdHVzCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2dpdC1idW5kbGUudHh0IGIvRG9jdW1lbnRhdGlvbi9naXQtYnVuZGxlLnR4dAppbmRleCA3ZDZjOWRjLi5jY2FkYTgwIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2dpdC1idW5kbGUudHh0CisrKyBiL0RvY3VtZW50YXRpb24vZ2l0LWJ1bmRsZS50eHQKQEAgLTksOCArOSw4IEBACiBTWU5PUFNJUwogLS0tLS0tLS0KIFt2ZXJzZV0KLSdnaXQgYnVuZGxlJyBjcmVhdGUgPGZpbGU+IDxnaXQtcmV2LWxpc3QtYXJncz4KLSdnaXQgYnVuZGxlJyB2ZXJpZnkgPGZpbGU+CisnZ2l0IGJ1bmRsZScgY3JlYXRlIFstcSB8IC0tcXVpZXQgfCAtLXByb2dyZXNzIHwgLS1hbGwtcHJvZ3Jlc3NdIFstLWFsbC1wcm9ncmVzcy1pbXBsaWVkXSA8ZmlsZT4gPGdpdC1yZXYtbGlzdC1hcmdzPgorJ2dpdCBidW5kbGUnIHZlcmlmeSBbLXEgfCAtLXF1aWV0XSA8ZmlsZT4KICdnaXQgYnVuZGxlJyBsaXN0LWhlYWRzIDxmaWxlPiBbPHJlZm5hbWU+Li4uXQogJ2dpdCBidW5kbGUnIHVuYnVuZGxlIDxmaWxlPiBbPHJlZm5hbWU+Li4uXQogCkBAIC0zMyw5ICszMywxMSBAQAogT1BUSU9OUwogLS0tLS0tLQogCi1jcmVhdGUgPGZpbGU+OjoKK2NyZWF0ZSBbb3B0aW9uc10gPGZpbGU+IDxnaXQtcmV2LWxpc3QtYXJncz46OgogCVVzZWQgdG8gY3JlYXRlIGEgYnVuZGxlIG5hbWVkICdmaWxlJy4gIFRoaXMgcmVxdWlyZXMgdGhlCiAJJ2dpdC1yZXYtbGlzdC1hcmdzJyBhcmd1bWVudHMgdG8gZGVmaW5lIHRoZSBidW5kbGUgY29udGVudHMuCisJJ29wdGlvbnMnIGNvbnRhaW5zIHRoZSBvcHRpb25zIHNwZWNpZmljIHRvIHRoZSAnZ2l0IGJ1bmRsZSBjcmVhdGUnCisJc3ViY29tbWFuZC4KIAogdmVyaWZ5IDxmaWxlPjo6CiAJVXNlZCB0byBjaGVjayB0aGF0IGEgYnVuZGxlIGZpbGUgaXMgdmFsaWQgYW5kIHdpbGwgYXBwbHkKQEAgLTc1LDYgKzc3LDMzIEBACiAJbmVjZXNzYXJpbHkgZXZlcnl0aGluZyBpbiB0aGUgcGFjayAoaW4gdGhpcyBjYXNlLCAnZ2l0IGJ1bmRsZScgYWN0cwogCWxpa2UgJ2dpdCBmZXRjaC1wYWNrJykuCiAKKy0tcHJvZ3Jlc3M6OgorCVByb2dyZXNzIHN0YXR1cyBpcyByZXBvcnRlZCBvbiB0aGUgc3RhbmRhcmQgZXJyb3Igc3RyZWFtCisJYnkgZGVmYXVsdCB3aGVuIGl0IGlzIGF0dGFjaGVkIHRvIGEgdGVybWluYWwsIHVubGVzcyAtcQorCWlzIHNwZWNpZmllZC4gVGhpcyBmbGFnIGZvcmNlcyBwcm9ncmVzcyBzdGF0dXMgZXZlbiBpZgorCXRoZSBzdGFuZGFyZCBlcnJvciBzdHJlYW0gaXMgbm90IGRpcmVjdGVkIHRvIGEgdGVybWluYWwuCisKKy0tYWxsLXByb2dyZXNzOjoKKwlXaGVuIC0tc3Rkb3V0IGlzIHNwZWNpZmllZCB0aGVuIHByb2dyZXNzIHJlcG9ydCBpcworCWRpc3BsYXllZCBkdXJpbmcgdGhlIG9iamVjdCBjb3VudCBhbmQgY29tcHJlc3Npb24gcGhhc2VzCisJYnV0IGluaGliaXRlZCBkdXJpbmcgdGhlIHdyaXRlLW91dCBwaGFzZS4gVGhlIHJlYXNvbiBpcworCXRoYXQgaW4gc29tZSBjYXNlcyB0aGUgb3V0cHV0IHN0cmVhbSBpcyBkaXJlY3RseSBsaW5rZWQKKwl0byBhbm90aGVyIGNvbW1hbmQgd2hpY2ggbWF5IHdpc2ggdG8gZGlzcGxheSBwcm9ncmVzcworCXN0YXR1cyBvZiBpdHMgb3duIGFzIGl0IHByb2Nlc3NlcyBpbmNvbWluZyBwYWNrIGRhdGEuCisJVGhpcyBmbGFnIGlzIGxpa2UgLS1wcm9ncmVzcyBleGNlcHQgdGhhdCBpdCBmb3JjZXMgcHJvZ3Jlc3MKKwlyZXBvcnQgZm9yIHRoZSB3cml0ZS1vdXQgcGhhc2UgYXMgd2VsbCBldmVuIGlmIC0tc3Rkb3V0IGlzCisJdXNlZC4KKworLS1hbGwtcHJvZ3Jlc3MtaW1wbGllZDo6CisJVGhpcyBpcyB1c2VkIHRvIGltcGx5IC0tYWxsLXByb2dyZXNzIHdoZW5ldmVyIHByb2dyZXNzIGRpc3BsYXkKKwlpcyBhY3RpdmF0ZWQuICBVbmxpa2UgLS1hbGwtcHJvZ3Jlc3MgdGhpcyBmbGFnIGRvZXNuJ3QgYWN0dWFsbHkKKwlmb3JjZSBhbnkgcHJvZ3Jlc3MgZGlzcGxheSBieSBpdHNlbGYuCisKKy1xOjoKKy0tcXVpZXQ6OgorCVRoaXMgZmxhZyBtYWtlcyB0aGUgY29tbWFuZCBub3QgdG8gcmVwb3J0IGl0cyBwcm9ncmVzcworCW9uIHRoZSBzdGFuZGFyZCBlcnJvciBzdHJlYW0uCisKIFNQRUNJRllJTkcgUkVGRVJFTkNFUwogLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vZ2l0LWNoZWNrLWF0dHIudHh0IGIvRG9jdW1lbnRhdGlvbi9naXQtY2hlY2stYXR0ci50eHQKaW5kZXggM2MwNTc4Mi4uODRmNDFhOCAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9naXQtY2hlY2stYXR0ci50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9naXQtY2hlY2stYXR0ci50eHQKQEAgLTMyLDcgKzMyLDcgQEAKIAlpbnN0ZWFkIG9mIGZyb20gdGhlIGNvbW1hbmQtbGluZS4KIAogLXo6OgotCVRoZSBvdXRwdXQgZm9ybWF0IGlzIG1vZGlmaWVkIHRvIGJlIG1hY2hpbmUtcGFyc2VhYmxlLgorCVRoZSBvdXRwdXQgZm9ybWF0IGlzIG1vZGlmaWVkIHRvIGJlIG1hY2hpbmUtcGFyc2FibGUuCiAJSWYgYC0tc3RkaW5gIGlzIGFsc28gZ2l2ZW4sIGlucHV0IHBhdGhzIGFyZSBzZXBhcmF0ZWQKIAl3aXRoIGEgTlVMIGNoYXJhY3RlciBpbnN0ZWFkIG9mIGEgbGluZWZlZWQgY2hhcmFjdGVyLgogCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2dpdC1jaGVjay1pZ25vcmUudHh0IGIvRG9jdW1lbnRhdGlvbi9naXQtY2hlY2staWdub3JlLnR4dAppbmRleCA4YjQyY2IzLi44YjJkNDljIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2dpdC1jaGVjay1pZ25vcmUudHh0CisrKyBiL0RvY3VtZW50YXRpb24vZ2l0LWNoZWNrLWlnbm9yZS50eHQKQEAgLTM5LDcgKzM5LDcgQEAKIAlpbnN0ZWFkIG9mIGZyb20gdGhlIGNvbW1hbmQtbGluZS4KIAogLXo6OgotCVRoZSBvdXRwdXQgZm9ybWF0IGlzIG1vZGlmaWVkIHRvIGJlIG1hY2hpbmUtcGFyc2VhYmxlIChzZWUKKwlUaGUgb3V0cHV0IGZvcm1hdCBpcyBtb2RpZmllZCB0byBiZSBtYWNoaW5lLXBhcnNhYmxlIChzZWUKIAliZWxvdykuICBJZiBgLS1zdGRpbmAgaXMgYWxzbyBnaXZlbiwgaW5wdXQgcGF0aHMgYXJlIHNlcGFyYXRlZAogCXdpdGggYSBOVUwgY2hhcmFjdGVyIGluc3RlYWQgb2YgYSBsaW5lZmVlZCBjaGFyYWN0ZXIuCiAKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vZ2l0LWNsZWFuLnR4dCBiL0RvY3VtZW50YXRpb24vZ2l0LWNsZWFuLnR4dAppbmRleCAwMDI4ZmYxLi5hN2YzMDlkIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2dpdC1jbGVhbi50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9naXQtY2xlYW4udHh0CkBAIC0yNiwxOCArMjYsMjAgQEAKIE9QVElPTlMKIC0tLS0tLS0KIC1kOjoKLQlSZW1vdmUgdW50cmFja2VkIGRpcmVjdG9yaWVzIGluIGFkZGl0aW9uIHRvIHVudHJhY2tlZCBmaWxlcy4KLQlJZiBhbiB1bnRyYWNrZWQgZGlyZWN0b3J5IGlzIG1hbmFnZWQgYnkgYSBkaWZmZXJlbnQgR2l0Ci0JcmVwb3NpdG9yeSwgaXQgaXMgbm90IHJlbW92ZWQgYnkgZGVmYXVsdC4gIFVzZSAtZiBvcHRpb24gdHdpY2UKLQlpZiB5b3UgcmVhbGx5IHdhbnQgdG8gcmVtb3ZlIHN1Y2ggYSBkaXJlY3RvcnkuCisJTm9ybWFsbHksIHdoZW4gbm8gPHBhdGg+IGlzIHNwZWNpZmllZCwgZ2l0IGNsZWFuIHdpbGwgbm90CisJcmVjdXJzZSBpbnRvIHVudHJhY2tlZCBkaXJlY3RvcmllcyB0byBhdm9pZCByZW1vdmluZyB0b28gbXVjaC4KKwlTcGVjaWZ5IC1kIHRvIGhhdmUgaXQgcmVjdXJzZSBpbnRvIHN1Y2ggZGlyZWN0b3JpZXMgYXMgd2VsbC4KKwlJZiBhbnkgcGF0aHMgYXJlIHNwZWNpZmllZCwgLWQgaXMgaXJyZWxldmFudDsgYWxsIHVudHJhY2tlZAorCWZpbGVzIG1hdGNoaW5nIHRoZSBzcGVjaWZpZWQgcGF0aHMgKHdpdGggZXhjZXB0aW9ucyBmb3IgbmVzdGVkCisJZ2l0IGRpcmVjdG9yaWVzIG1lbnRpb25lZCB1bmRlciBgLS1mb3JjZWApIHdpbGwgYmUgcmVtb3ZlZC4KIAogLWY6OgogLS1mb3JjZTo6CiAJSWYgdGhlIEdpdCBjb25maWd1cmF0aW9uIHZhcmlhYmxlIGNsZWFuLnJlcXVpcmVGb3JjZSBpcyBub3Qgc2V0CiAJdG8gZmFsc2UsICdnaXQgY2xlYW4nIHdpbGwgcmVmdXNlIHRvIGRlbGV0ZSBmaWxlcyBvciBkaXJlY3RvcmllcwotCXVubGVzcyBnaXZlbiAtZiwgLW4gb3IgLWkuIEdpdCB3aWxsIHJlZnVzZSB0byBkZWxldGUgZGlyZWN0b3JpZXMKLQl3aXRoIC5naXQgc3ViIGRpcmVjdG9yeSBvciBmaWxlIHVubGVzcyBhIHNlY29uZCAtZgotCWlzIGdpdmVuLgorCXVubGVzcyBnaXZlbiAtZiBvciAtaS4gIEdpdCB3aWxsIHJlZnVzZSB0byBtb2RpZnkgdW50cmFja2VkCisJbmVzdGVkIGdpdCByZXBvc2l0b3JpZXMgKGRpcmVjdG9yaWVzIHdpdGggYSAuZ2l0IHN1YmRpcmVjdG9yeSkKKwl1bmxlc3MgYSBzZWNvbmQgLWYgaXMgZ2l2ZW4uCiAKIC1pOjoKIC0taW50ZXJhY3RpdmU6OgpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9naXQtY29tbWl0LWdyYXBoLnR4dCBiL0RvY3VtZW50YXRpb24vZ2l0LWNvbW1pdC1ncmFwaC50eHQKaW5kZXggZWI1ZTc4Ni4uYmNkODVjMSAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9naXQtY29tbWl0LWdyYXBoLnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL2dpdC1jb21taXQtZ3JhcGgudHh0CkBAIC05LDkgKzksOCBAQAogU1lOT1BTSVMKIC0tLS0tLS0tCiBbdmVyc2VdCi0nZ2l0IGNvbW1pdC1ncmFwaCByZWFkJyBbLS1vYmplY3QtZGlyIDxkaXI+XQotJ2dpdCBjb21taXQtZ3JhcGggdmVyaWZ5JyBbLS1vYmplY3QtZGlyIDxkaXI+XSBbLS1zaGFsbG93XQotJ2dpdCBjb21taXQtZ3JhcGggd3JpdGUnIDxvcHRpb25zPiBbLS1vYmplY3QtZGlyIDxkaXI+XQorJ2dpdCBjb21taXQtZ3JhcGggdmVyaWZ5JyBbLS1vYmplY3QtZGlyIDxkaXI+XSBbLS1zaGFsbG93XSBbLS1bbm8tXXByb2dyZXNzXQorJ2dpdCBjb21taXQtZ3JhcGggd3JpdGUnIDxvcHRpb25zPiBbLS1vYmplY3QtZGlyIDxkaXI+XSBbLS1bbm8tXXByb2dyZXNzXQogCiAKIERFU0NSSVBUSU9OCkBAIC0yOSw2ICsyOCw5IEBACiAJY29tbWl0LWdyYXBoIGZpbGUgaXMgZXhwZWN0ZWQgdG8gYmUgaW4gdGhlIGA8ZGlyPi9pbmZvYCBkaXJlY3RvcnkgYW5kCiAJdGhlIHBhY2tmaWxlcyBhcmUgZXhwZWN0ZWQgdG8gYmUgaW4gYDxkaXI+L3BhY2tgLgogCistLVtuby1dcHJvZ3Jlc3M6OgorCVR1cm4gcHJvZ3Jlc3Mgb24vb2ZmIGV4cGxpY2l0bHkuIElmIG5laXRoZXIgaXMgc3BlY2lmaWVkLCBwcm9ncmVzcyBpcworCXNob3duIGlmIHN0YW5kYXJkIGVycm9yIGlzIGNvbm5lY3RlZCB0byBhIHRlcm1pbmFsLgogCiBDT01NQU5EUwogLS0tLS0tLS0KQEAgLTcxLDExICs3Myw2IEBACiBiZSB0aGUgY3VycmVudCB0aW1lLiBBZnRlciB3cml0aW5nIHRoZSBzcGxpdCBjb21taXQtZ3JhcGgsIGRlbGV0ZSBhbGwKIHVudXNlZCBjb21taXQtZ3JhcGggd2hvc2UgbW9kaWZpZWQgdGltZXMgYXJlIG9sZGVyIHRoYW4gYGRhdGV0aW1lYC4KIAotJ3JlYWQnOjoKLQotUmVhZCB0aGUgY29tbWl0LWdyYXBoIGZpbGUgYW5kIG91dHB1dCBiYXNpYyBkZXRhaWxzIGFib3V0IGl0LgotVXNlZCBmb3IgZGVidWdnaW5nIHB1cnBvc2VzLgotCiAndmVyaWZ5Jzo6CiAKIFJlYWQgdGhlIGNvbW1pdC1ncmFwaCBmaWxlIGFuZCB2ZXJpZnkgaXRzIGNvbnRlbnRzIGFnYWluc3QgdGhlIG9iamVjdApAQCAtMTE1LDEyICsxMTIsNiBAQAogJCBnaXQgcmV2LXBhcnNlIEhFQUQgfCBnaXQgY29tbWl0LWdyYXBoIHdyaXRlIC0tc3RkaW4tY29tbWl0cyAtLWFwcGVuZAogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAKLSogUmVhZCBiYXNpYyBpbmZvcm1hdGlvbiBmcm9tIHRoZSBjb21taXQtZ3JhcGggZmlsZS4KLSsKLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQotJCBnaXQgY29tbWl0LWdyYXBoIHJlYWQKLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQotCiAKIEdJVAogLS0tCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2dpdC1jb21taXQudHh0IGIvRG9jdW1lbnRhdGlvbi9naXQtY29tbWl0LnR4dAppbmRleCA3NjI4MTkzLi5hZmE3Yjc1IDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2dpdC1jb21taXQudHh0CisrKyBiL0RvY3VtZW50YXRpb24vZ2l0LWNvbW1pdC50eHQKQEAgLTI4MiwxOCArMjgyLDIwIEBACiAtLXVudHJhY2tlZC1maWxlc1s9PG1vZGU+XTo6CiAJU2hvdyB1bnRyYWNrZWQgZmlsZXMuCiArCistLQogVGhlIG1vZGUgcGFyYW1ldGVyIGlzIG9wdGlvbmFsIChkZWZhdWx0cyB0byAnYWxsJyksIGFuZCBpcyB1c2VkIHRvCiBzcGVjaWZ5IHRoZSBoYW5kbGluZyBvZiB1bnRyYWNrZWQgZmlsZXM7IHdoZW4gLXUgaXMgbm90IHVzZWQsIHRoZQogZGVmYXVsdCBpcyAnbm9ybWFsJywgaS5lLiBzaG93IHVudHJhY2tlZCBmaWxlcyBhbmQgZGlyZWN0b3JpZXMuCi0rCisKIFRoZSBwb3NzaWJsZSBvcHRpb25zIGFyZToKLSsKKwogCS0gJ25vJyAgICAgLSBTaG93IG5vIHVudHJhY2tlZCBmaWxlcwogCS0gJ25vcm1hbCcgLSBTaG93cyB1bnRyYWNrZWQgZmlsZXMgYW5kIGRpcmVjdG9yaWVzCiAJLSAnYWxsJyAgICAtIEFsc28gc2hvd3MgaW5kaXZpZHVhbCBmaWxlcyBpbiB1bnRyYWNrZWQgZGlyZWN0b3JpZXMuCi0rCisKIFRoZSBkZWZhdWx0IGNhbiBiZSBjaGFuZ2VkIHVzaW5nIHRoZSBzdGF0dXMuc2hvd1VudHJhY2tlZEZpbGVzCiBjb25maWd1cmF0aW9uIHZhcmlhYmxlIGRvY3VtZW50ZWQgaW4gbGlua2dpdDpnaXQtY29uZmlnWzFdLgorLS0KIAogLXY6OgogLS12ZXJib3NlOjoKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vZ2l0LWNvbmZpZy50eHQgYi9Eb2N1bWVudGF0aW9uL2dpdC1jb25maWcudHh0CmluZGV4IGZmOTMxMGYuLjg5OWU5MmEgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vZ2l0LWNvbmZpZy50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9naXQtY29uZmlnLnR4dApAQCAtMzM5LDMzICszMzksMzUgQEAKIAogR2l2ZW4gYSAuZ2l0L2NvbmZpZyBsaWtlIHRoaXM6CiAKLQkjCi0JIyBUaGlzIGlzIHRoZSBjb25maWcgZmlsZSwgYW5kCi0JIyBhICcjJyBvciAnOycgY2hhcmFjdGVyIGluZGljYXRlcwotCSMgYSBjb21tZW50Ci0JIworLS0tLS0tLS0tLS0tCisjCisjIFRoaXMgaXMgdGhlIGNvbmZpZyBmaWxlLCBhbmQKKyMgYSAnIycgb3IgJzsnIGNoYXJhY3RlciBpbmRpY2F0ZXMKKyMgYSBjb21tZW50CisjCiAKLQk7IGNvcmUgdmFyaWFibGVzCi0JW2NvcmVdCi0JCTsgRG9uJ3QgdHJ1c3QgZmlsZSBtb2RlcwotCQlmaWxlbW9kZSA9IGZhbHNlCis7IGNvcmUgdmFyaWFibGVzCitbY29yZV0KKwk7IERvbid0IHRydXN0IGZpbGUgbW9kZXMKKwlmaWxlbW9kZSA9IGZhbHNlCiAKLQk7IE91ciBkaWZmIGFsZ29yaXRobQotCVtkaWZmXQotCQlleHRlcm5hbCA9IC91c3IvbG9jYWwvYmluL2RpZmYtd3JhcHBlcgotCQlyZW5hbWVzID0gdHJ1ZQorOyBPdXIgZGlmZiBhbGdvcml0aG0KK1tkaWZmXQorCWV4dGVybmFsID0gL3Vzci9sb2NhbC9iaW4vZGlmZi13cmFwcGVyCisJcmVuYW1lcyA9IHRydWUKIAotCTsgUHJveHkgc2V0dGluZ3MKLQlbY29yZV0KLQkJZ2l0cHJveHk9cHJveHktY29tbWFuZCBmb3Iga2VybmVsLm9yZwotCQlnaXRwcm94eT1kZWZhdWx0LXByb3h5IDsgZm9yIGFsbCB0aGUgcmVzdAorOyBQcm94eSBzZXR0aW5ncworW2NvcmVdCisJZ2l0cHJveHk9cHJveHktY29tbWFuZCBmb3Iga2VybmVsLm9yZworCWdpdHByb3h5PWRlZmF1bHQtcHJveHkgOyBmb3IgYWxsIHRoZSByZXN0CiAKLQk7IEhUVFAKLQlbaHR0cF0KLQkJc3NsVmVyaWZ5Ci0JW2h0dHAgImh0dHBzOi8vd2Vhay5leGFtcGxlLmNvbSJdCi0JCXNzbFZlcmlmeSA9IGZhbHNlCi0JCWNvb2tpZUZpbGUgPSAvdG1wL2Nvb2tpZS50eHQKKzsgSFRUUAorW2h0dHBdCisJc3NsVmVyaWZ5CitbaHR0cCAiaHR0cHM6Ly93ZWFrLmV4YW1wbGUuY29tIl0KKwlzc2xWZXJpZnkgPSBmYWxzZQorCWNvb2tpZUZpbGUgPSAvdG1wL2Nvb2tpZS50eHQKKy0tLS0tLS0tLS0tLQogCiB5b3UgY2FuIHNldCB0aGUgZmlsZW1vZGUgdG8gdHJ1ZSB3aXRoCiAKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vZ2l0LWN2c3NlcnZlci50eHQgYi9Eb2N1bWVudGF0aW9uL2dpdC1jdnNzZXJ2ZXIudHh0CmluZGV4IDc5ZTIyYjEuLjFiMWM3MWEgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vZ2l0LWN2c3NlcnZlci50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9naXQtY3Zzc2VydmVyLnR4dApAQCAtMjk0LDcgKzI5NCw3IEBACiAJR2l0IGRpcmVjdG9yeSBuYW1lCiAlZzo6CiAJR2l0IGRpcmVjdG9yeSBuYW1lLCB3aGVyZSBhbGwgY2hhcmFjdGVycyBleGNlcHQgZm9yCi0JYWxwaGEtbnVtZXJpYyBvbmVzLCBgLmAsIGFuZCBgLWAgYXJlIHJlcGxhY2VkIHdpdGgKKwlhbHBoYW51bWVyaWMgb25lcywgYC5gLCBhbmQgYC1gIGFyZSByZXBsYWNlZCB3aXRoCiAJYF9gICh0aGlzIHNob3VsZCBtYWtlIGl0IGVhc2llciB0byB1c2UgdGhlIGRpcmVjdG9yeQogCW5hbWUgaW4gYSBmaWxlbmFtZSBpZiB3YW50ZWQpCiAlbTo6CmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2dpdC1kaWZmLnR4dCBiL0RvY3VtZW50YXRpb24vZ2l0LWRpZmYudHh0CmluZGV4IDcyMTc5ZDkuLjM3NzgxY2YgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vZ2l0LWRpZmYudHh0CisrKyBiL0RvY3VtZW50YXRpb24vZ2l0LWRpZmYudHh0CkBAIC0zNiw3ICszNiw3IEBACiAJcnVubmluZyB0aGUgY29tbWFuZCBpbiBhIHdvcmtpbmcgdHJlZSBjb250cm9sbGVkIGJ5IEdpdCBhbmQKIAlhdCBsZWFzdCBvbmUgb2YgdGhlIHBhdGhzIHBvaW50cyBvdXRzaWRlIHRoZSB3b3JraW5nIHRyZWUsCiAJb3Igd2hlbiBydW5uaW5nIHRoZSBjb21tYW5kIG91dHNpZGUgYSB3b3JraW5nIHRyZWUKLQljb250cm9sbGVkIGJ5IEdpdC4KKwljb250cm9sbGVkIGJ5IEdpdC4gVGhpcyBmb3JtIGltcGxpZXMgYC0tZXhpdC1jb2RlYC4KIAogJ2dpdCBkaWZmJyBbPG9wdGlvbnM+XSAtLWNhY2hlZCBbPGNvbW1pdD5dIFstLV0gWzxwYXRoPi4uLl06OgogCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2dpdC1mYXN0LWV4cG9ydC50eHQgYi9Eb2N1bWVudGF0aW9uL2dpdC1mYXN0LWV4cG9ydC50eHQKaW5kZXggY2M5NDBlYi4uZTg5NTBkZSAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9naXQtZmFzdC1leHBvcnQudHh0CisrKyBiL0RvY3VtZW50YXRpb24vZ2l0LWZhc3QtZXhwb3J0LnR4dApAQCAtMTcsOSArMTcsOSBAQAogaW50byAnZ2l0IGZhc3QtaW1wb3J0Jy4KIAogWW91IGNhbiB1c2UgaXQgYXMgYSBodW1hbi1yZWFkYWJsZSBidW5kbGUgcmVwbGFjZW1lbnQgKHNlZQotbGlua2dpdDpnaXQtYnVuZGxlWzFdKSwgb3IgYXMgYSBraW5kIG9mIGFuIGludGVyYWN0aXZlCi0nZ2l0IGZpbHRlci1icmFuY2gnLgotCitsaW5rZ2l0OmdpdC1idW5kbGVbMV0pLCBvciBhcyBhIGZvcm1hdCB0aGF0IGNhbiBiZSBlZGl0ZWQgYmVmb3JlIGJlaW5nCitmZWQgdG8gJ2dpdCBmYXN0LWltcG9ydCcgaW4gb3JkZXIgdG8gZG8gaGlzdG9yeSByZXdyaXRlcyAoYW4gYWJpbGl0eQorcmVsaWVkIG9uIGJ5IHRvb2xzIGxpa2UgJ2dpdCBmaWx0ZXItcmVwbycpLgogCiBPUFRJT05TCiAtLS0tLS0tCkBAIC03NSwxMSArNzUsMjAgQEAKIAlCZWZvcmUgcHJvY2Vzc2luZyBhbnkgaW5wdXQsIGxvYWQgdGhlIG1hcmtzIHNwZWNpZmllZCBpbgogCTxmaWxlPi4gIFRoZSBpbnB1dCBmaWxlIG11c3QgZXhpc3QsIG11c3QgYmUgcmVhZGFibGUsIGFuZAogCW11c3QgdXNlIHRoZSBzYW1lIGZvcm1hdCBhcyBwcm9kdWNlZCBieSAtLWV4cG9ydC1tYXJrcy4KKworLS1tYXJrLXRhZ3M6OgorCUluIGFkZGl0aW9uIHRvIGxhYmVsbGluZyBibG9icyBhbmQgY29tbWl0cyB3aXRoIG1hcmsgaWRzLCBhbHNvCisJbGFiZWwgdGFncy4gIFRoaXMgaXMgdXNlZnVsIGluIGNvbmp1bmN0aW9uIHdpdGgKKwlgLS1leHBvcnQtbWFya3NgIGFuZCBgLS1pbXBvcnQtbWFya3NgLCBhbmQgaXMgYWxzbyB1c2VmdWwgKGFuZAorCW5lY2Vzc2FyeSkgZm9yIGV4cG9ydGluZyBvZiBuZXN0ZWQgdGFncy4gIEl0IGRvZXMgbm90IGh1cnQKKwlvdGhlciBjYXNlcyBhbmQgd291bGQgYmUgdGhlIGRlZmF1bHQsIGJ1dCBtYW55IGZhc3QtaW1wb3J0CisJZnJvbnRlbmRzIGFyZSBub3QgcHJlcGFyZWQgdG8gYWNjZXB0IHRhZ3Mgd2l0aCBtYXJrCisJaWRlbnRpZmllcnMuCiArCi1BbnkgY29tbWl0cyB0aGF0IGhhdmUgYWxyZWFkeSBiZWVuIG1hcmtlZCB3aWxsIG5vdCBiZSBleHBvcnRlZCBhZ2Fpbi4KLUlmIHRoZSBiYWNrZW5kIHVzZXMgYSBzaW1pbGFyIC0taW1wb3J0LW1hcmtzIGZpbGUsIHRoaXMgYWxsb3dzIGZvcgotaW5jcmVtZW50YWwgYmlkaXJlY3Rpb25hbCBleHBvcnRpbmcgb2YgdGhlIHJlcG9zaXRvcnkgYnkga2VlcGluZyB0aGUKLW1hcmtzIHRoZSBzYW1lIGFjcm9zcyBydW5zLgorQW55IGNvbW1pdHMgKG9yIHRhZ3MpIHRoYXQgaGF2ZSBhbHJlYWR5IGJlZW4gbWFya2VkIHdpbGwgbm90IGJlCitleHBvcnRlZCBhZ2Fpbi4gIElmIHRoZSBiYWNrZW5kIHVzZXMgYSBzaW1pbGFyIC0taW1wb3J0LW1hcmtzIGZpbGUsCit0aGlzIGFsbG93cyBmb3IgaW5jcmVtZW50YWwgYmlkaXJlY3Rpb25hbCBleHBvcnRpbmcgb2YgdGhlIHJlcG9zaXRvcnkKK2J5IGtlZXBpbmcgdGhlIG1hcmtzIHRoZSBzYW1lIGFjcm9zcyBydW5zLgogCiAtLWZha2UtbWlzc2luZy10YWdnZXI6OgogCVNvbWUgb2xkIHJlcG9zaXRvcmllcyBoYXZlIHRhZ3Mgd2l0aG91dCBhIHRhZ2dlci4gIFRoZQpAQCAtMTMzLDcgKzE0Miw3IEBACiAJU3BlY2lmeSBob3cgdG8gaGFuZGxlIGBlbmNvZGluZ2AgaGVhZGVyIGluIGNvbW1pdCBvYmplY3RzLiAgV2hlbgogCWFza2luZyB0byAnYWJvcnQnICh3aGljaCBpcyB0aGUgZGVmYXVsdCksIHRoaXMgcHJvZ3JhbSB3aWxsIGRpZQogCXdoZW4gZW5jb3VudGVyaW5nIHN1Y2ggYSBjb21taXQgb2JqZWN0LiAgV2l0aCAneWVzJywgdGhlIGNvbW1pdAotCW1lc3NhZ2Ugd2lsbCBiZSByZWVuY29kZWQgaW50byBVVEYtOC4gIFdpdGggJ25vJywgdGhlIG9yaWdpbmFsCisJbWVzc2FnZSB3aWxsIGJlIHJlLWVuY29kZWQgaW50byBVVEYtOC4gIFdpdGggJ25vJywgdGhlIG9yaWdpbmFsCiAJZW5jb2Rpbmcgd2lsbCBiZSBwcmVzZXJ2ZWQuCiAKIC0tcmVmc3BlYzo6CmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2dpdC1mYXN0LWltcG9ydC50eHQgYi9Eb2N1bWVudGF0aW9uL2dpdC1mYXN0LWltcG9ydC50eHQKaW5kZXggZmFkMzI3YS4uYTNmMWUwYyAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9naXQtZmFzdC1pbXBvcnQudHh0CisrKyBiL0RvY3VtZW50YXRpb24vZ2l0LWZhc3QtaW1wb3J0LnR4dApAQCAtMzM3LDYgKzMzNywxMyBAQAogCWBjb21taXRgIGNvbW1hbmQuICBUaGlzIGNvbW1hbmQgaXMgb3B0aW9uYWwgYW5kIGlzIG5vdAogCW5lZWRlZCB0byBwZXJmb3JtIGFuIGltcG9ydC4KIAorYGFsaWFzYDo6CisJUmVjb3JkIHRoYXQgYSBtYXJrIHJlZmVycyB0byBhIGdpdmVuIG9iamVjdCB3aXRob3V0IGZpcnN0CisJY3JlYXRpbmcgYW55IG5ldyBvYmplY3QuICBVc2luZyAtLWltcG9ydC1tYXJrcyBhbmQgcmVmZXJyaW5nCisJdG8gbWlzc2luZyBtYXJrcyB3aWxsIGNhdXNlIGZhc3QtaW1wb3J0IHRvIGZhaWwsIHNvIGFsaWFzZXMKKwljYW4gcHJvdmlkZSBhIHdheSB0byBzZXQgb3RoZXJ3aXNlIHBydW5lZCBjb21taXRzIHRvIGEgdmFsaWQKKwl2YWx1ZSAoZS5nLiB0aGUgbmVhcmVzdCBub24tcHJ1bmVkIGFuY2VzdG9yKS4KKwogYGNoZWNrcG9pbnRgOjoKIAlGb3JjZXMgZmFzdC1pbXBvcnQgdG8gY2xvc2UgdGhlIGN1cnJlbnQgcGFja2ZpbGUsIGdlbmVyYXRlIGl0cwogCXVuaXF1ZSBTSEEtMSBjaGVja3N1bSBhbmQgaW5kZXgsIGFuZCBzdGFydCBhIG5ldyBwYWNrZmlsZS4KQEAgLTM5MSw3ICszOTgsNyBAQAogCSgnZW5jb2RpbmcnIFNQIDxlbmNvZGluZz4pPwogCWRhdGEKIAkoJ2Zyb20nIFNQIDxjb21taXQtaXNoPiBMRik/Ci0JKCdtZXJnZScgU1AgPGNvbW1pdC1pc2g+IExGKT8KKwkoJ21lcmdlJyBTUCA8Y29tbWl0LWlzaD4gTEYpKgogCShmaWxlbW9kaWZ5IHwgZmlsZWRlbGV0ZSB8IGZpbGVjb3B5IHwgZmlsZXJlbmFtZSB8IGZpbGVkZWxldGVhbGwgfCBub3RlbW9kaWZ5KSoKIAlMRj8KIC4uLi4KQEAgLTc3NCw2ICs3ODEsNyBAQAogCiAuLi4uCiAJJ3RhZycgU1AgPG5hbWU+IExGCisJbWFyaz8KIAknZnJvbScgU1AgPGNvbW1pdC1pc2g+IExGCiAJb3JpZ2luYWwtb2lkPwogCSd0YWdnZXInIChTUCA8bmFtZT4pPyBTUCBMVCA8ZW1haWw+IEdUIFNQIDx3aGVuPiBMRgpAQCAtOTEzLDYgKzkyMSwyMSBAQAogKwogVGhlIGBMRmAgYWZ0ZXIgYDxkZWxpbT4gTEZgIGlzIG9wdGlvbmFsIChpdCB1c2VkIHRvIGJlIHJlcXVpcmVkKS4KIAorYGFsaWFzYAorfn5+fn5+fgorUmVjb3JkIHRoYXQgYSBtYXJrIHJlZmVycyB0byBhIGdpdmVuIG9iamVjdCB3aXRob3V0IGZpcnN0IGNyZWF0aW5nIGFueQorbmV3IG9iamVjdC4KKworLi4uLgorCSdhbGlhcycgTEYKKwltYXJrCisJJ3RvJyBTUCA8Y29tbWl0LWlzaD4gTEYKKwlMRj8KKy4uLi4KKworRm9yIGEgZGV0YWlsZWQgZGVzY3JpcHRpb24gb2YgYDxjb21taXQtaXNoPmAgc2VlIGFib3ZlIHVuZGVyIGBmcm9tYC4KKworCiBgY2hlY2twb2ludGAKIH5+fn5+fn5+fn5+fgogRm9yY2VzIGZhc3QtaW1wb3J0IHRvIGNsb3NlIHRoZSBjdXJyZW50IHBhY2tmaWxlLCBzdGFydCBhIG5ldyBvbmUsIGFuZCB0bwpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9naXQtZmlsdGVyLWJyYW5jaC50eHQgYi9Eb2N1bWVudGF0aW9uL2dpdC1maWx0ZXItYnJhbmNoLnR4dAppbmRleCA2YjUzZGQ3Li4zNjg2YTY3IDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2dpdC1maWx0ZXItYnJhbmNoLnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL2dpdC1maWx0ZXItYnJhbmNoLnR4dApAQCAtMTYsNiArMTYsMTkgQEAKIAlbLS1vcmlnaW5hbCA8bmFtZXNwYWNlPl0gWy1kIDxkaXJlY3Rvcnk+XSBbLWYgfCAtLWZvcmNlXQogCVstLXN0YXRlLWJyYW5jaCA8YnJhbmNoPl0gWy0tXSBbPHJldi1saXN0IG9wdGlvbnM+Li4uXQogCitXQVJOSU5HCistLS0tLS0tCisnZ2l0IGZpbHRlci1icmFuY2gnIGhhcyBhIHBsZXRob3JhIG9mIHBpdGZhbGxzIHRoYXQgY2FuIHByb2R1Y2Ugbm9uLW9idmlvdXMKK21hbmdsaW5ncyBvZiB0aGUgaW50ZW5kZWQgaGlzdG9yeSByZXdyaXRlIChhbmQgY2FuIGxlYXZlIHlvdSB3aXRoIGxpdHRsZQordGltZSB0byBpbnZlc3RpZ2F0ZSBzdWNoIHByb2JsZW1zIHNpbmNlIGl0IGhhcyBzdWNoIGFieXNtYWwgcGVyZm9ybWFuY2UpLgorVGhlc2Ugc2FmZXR5IGFuZCBwZXJmb3JtYW5jZSBpc3N1ZXMgY2Fubm90IGJlIGJhY2t3YXJkIGNvbXBhdGlibHkgZml4ZWQgYW5kCithcyBzdWNoLCBpdHMgdXNlIGlzIG5vdCByZWNvbW1lbmRlZC4gIFBsZWFzZSB1c2UgYW4gYWx0ZXJuYXRpdmUgaGlzdG9yeQorZmlsdGVyaW5nIHRvb2wgc3VjaCBhcyBodHRwczovL2dpdGh1Yi5jb20vbmV3cmVuL2dpdC1maWx0ZXItcmVwby9bZ2l0CitmaWx0ZXItcmVwb10uICBJZiB5b3Ugc3RpbGwgbmVlZCB0byB1c2UgJ2dpdCBmaWx0ZXItYnJhbmNoJywgcGxlYXNlCitjYXJlZnVsbHkgcmVhZCA8PFNBRkVUWT4+IChhbmQgPDxQRVJGT1JNQU5DRT4+KSB0byBsZWFybiBhYm91dCB0aGUgbGFuZAorbWluZXMgb2YgZmlsdGVyLWJyYW5jaCwgYW5kIHRoZW4gdmlnaWxhbnRseSBhdm9pZCBhcyBtYW55IG9mIHRoZSBoYXphcmRzCitsaXN0ZWQgdGhlcmUgYXMgcmVhc29uYWJseSBwb3NzaWJsZS4KKwogREVTQ1JJUFRJT04KIC0tLS0tLS0tLS0tCiBMZXRzIHlvdSByZXdyaXRlIEdpdCByZXZpc2lvbiBoaXN0b3J5IGJ5IHJld3JpdGluZyB0aGUgYnJhbmNoZXMgbWVudGlvbmVkCkBAIC00NDUsMzYgKzQ1OCwyMzYgQEAKICAgKG9yIGlmIHlvdXIgZ2l0LWdjIGlzIG5vdCBuZXcgZW5vdWdoIHRvIHN1cHBvcnQgYXJndW1lbnRzIHRvCiAgIGAtLXBydW5lYCwgdXNlIGBnaXQgcmVwYWNrIC1hZDsgZ2l0IHBydW5lYCBpbnN0ZWFkKS4KIAotTk9URVMKLS0tLS0tCitbW1BFUkZPUk1BTkNFXV0KK1BFUkZPUk1BTkNFCistLS0tLS0tLS0tLQogCi1naXQtZmlsdGVyLWJyYW5jaCBhbGxvd3MgeW91IHRvIG1ha2UgY29tcGxleCBzaGVsbC1zY3JpcHRlZCByZXdyaXRlcwotb2YgeW91ciBHaXQgaGlzdG9yeSwgYnV0IHlvdSBwcm9iYWJseSBkb24ndCBuZWVkIHRoaXMgZmxleGliaWxpdHkgaWYKLXlvdSdyZSBzaW1wbHkgX3JlbW92aW5nIHVud2FudGVkIGRhdGFfIGxpa2UgbGFyZ2UgZmlsZXMgb3IgcGFzc3dvcmRzLgotRm9yIHRob3NlIG9wZXJhdGlvbnMgeW91IG1heSB3YW50IHRvIGNvbnNpZGVyCi1odHRwOi8vcnR5bGV5LmdpdGh1Yi5pby9iZmctcmVwby1jbGVhbmVyL1tUaGUgQkZHIFJlcG8tQ2xlYW5lcl0sCi1hIEpWTS1iYXNlZCBhbHRlcm5hdGl2ZSB0byBnaXQtZmlsdGVyLWJyYW5jaCwgdHlwaWNhbGx5IGF0IGxlYXN0Ci0xMC01MHggZmFzdGVyIGZvciB0aG9zZSB1c2UtY2FzZXMsIGFuZCB3aXRoIHF1aXRlIGRpZmZlcmVudAotY2hhcmFjdGVyaXN0aWNzOgorVGhlIHBlcmZvcm1hbmNlIG9mIGdpdC1maWx0ZXItYnJhbmNoIGlzIGdsYWNpYWxseSBzbG93OyBpdHMgZGVzaWduIG1ha2VzIGl0CitpbXBvc3NpYmxlIGZvciBhIGJhY2t3YXJkLWNvbXBhdGlibGUgaW1wbGVtZW50YXRpb24gdG8gZXZlciBiZSBmYXN0OgogCi0qIEFueSBwYXJ0aWN1bGFyIHZlcnNpb24gb2YgYSBmaWxlIGlzIGNsZWFuZWQgZXhhY3RseSBfb25jZV8uIFRoZSBCRkcsCi0gIHVubGlrZSBnaXQtZmlsdGVyLWJyYW5jaCwgZG9lcyBub3QgZ2l2ZSB5b3UgdGhlIG9wcG9ydHVuaXR5IHRvCi0gIGhhbmRsZSBhIGZpbGUgZGlmZmVyZW50bHkgYmFzZWQgb24gd2hlcmUgb3Igd2hlbiBpdCB3YXMgY29tbWl0dGVkCi0gIHdpdGhpbiB5b3VyIGhpc3RvcnkuIFRoaXMgY29uc3RyYWludCBnaXZlcyB0aGUgY29yZSBwZXJmb3JtYW5jZQotICBiZW5lZml0IG9mIFRoZSBCRkcsIGFuZCBpcyB3ZWxsLXN1aXRlZCB0byB0aGUgdGFzayBvZiBjbGVhbnNpbmcgYmFkCi0gIGRhdGEgLSB5b3UgZG9uJ3QgY2FyZSBfd2hlcmVfIHRoZSBiYWQgZGF0YSBpcywgeW91IGp1c3Qgd2FudCBpdAotICBfZ29uZV8uCisqIEluIGVkaXRpbmcgZmlsZXMsIGdpdC1maWx0ZXItYnJhbmNoIGJ5IGRlc2lnbiBjaGVja3Mgb3V0IGVhY2ggYW5kCitldmVyeSBjb21taXQgYXMgaXQgZXhpc3RlZCBpbiB0aGUgb3JpZ2luYWwgcmVwby4gIElmIHlvdXIgcmVwbyBoYXMgMTBcXjUKK2ZpbGVzIGFuZCAxMFxeNSBjb21taXRzLCBidXQgZWFjaCBjb21taXQgb25seSBtb2RpZmllcyA1IGZpbGVzLCB0aGVuCitnaXQtZmlsdGVyLWJyYW5jaCB3aWxsIG1ha2UgeW91IGRvIDEwXF4xMCBtb2RpZmljYXRpb25zLCBkZXNwaXRlIG9ubHkKK2hhdmluZyAoYXQgbW9zdCkgNSoxMF41IHVuaXF1ZSBibG9icy4KIAotKiBCeSBkZWZhdWx0IFRoZSBCRkcgdGFrZXMgZnVsbCBhZHZhbnRhZ2Ugb2YgbXVsdGktY29yZSBtYWNoaW5lcywKLSAgY2xlYW5zaW5nIGNvbW1pdCBmaWxlLXRyZWVzIGluIHBhcmFsbGVsLiBnaXQtZmlsdGVyLWJyYW5jaCBjbGVhbnMKLSAgY29tbWl0cyBzZXF1ZW50aWFsbHkgKGkuZS4gaW4gYSBzaW5nbGUtdGhyZWFkZWQgbWFubmVyKSwgdGhvdWdoIGl0Ci0gIF9pc18gcG9zc2libGUgdG8gd3JpdGUgZmlsdGVycyB0aGF0IGluY2x1ZGUgdGhlaXIgb3duIHBhcmFsbGVsaXNtLAotICBpbiB0aGUgc2NyaXB0cyBleGVjdXRlZCBhZ2FpbnN0IGVhY2ggY29tbWl0LgorKiBJZiB5b3UgdHJ5IGFuZCBjaGVhdCBhbmQgdHJ5IHRvIG1ha2UgZ2l0LWZpbHRlci1icmFuY2ggb25seSB3b3JrIG9uCitmaWxlcyBtb2RpZmllZCBpbiBhIGNvbW1pdCwgdGhlbiB0d28gdGhpbmdzIGhhcHBlbgogCi0qIFRoZSBodHRwOi8vcnR5bGV5LmdpdGh1Yi5pby9iZmctcmVwby1jbGVhbmVyLyNleGFtcGxlc1tjb21tYW5kIG9wdGlvbnNdCi0gIGFyZSBtdWNoIG1vcmUgcmVzdHJpY3RpdmUgdGhhbiBnaXQtZmlsdGVyIGJyYW5jaCwgYW5kIGRlZGljYXRlZCBqdXN0Ci0gIHRvIHRoZSB0YXNrcyBvZiByZW1vdmluZyB1bndhbnRlZCBkYXRhLSBlLmc6Ci0gIGAtLXN0cmlwLWJsb2JzLWJpZ2dlci10aGFuIDFNYC4KKyAgKiogeW91IHJ1biBpbnRvIHByb2JsZW1zIHdpdGggZGVsZXRpb25zIHdoZW5ldmVyIHRoZSB1c2VyIGlzIHNpbXBseQorICAgICB0cnlpbmcgdG8gcmVuYW1lIGZpbGVzIChiZWNhdXNlIGF0dGVtcHRpbmcgdG8gZGVsZXRlIGZpbGVzIHRoYXQKKyAgICAgZG9uJ3QgZXhpc3QgbG9va3MgbGlrZSBhIG5vLW9wOyBpdCB0YWtlcyBzb21lIGNoaWNhbmVyeSB0byByZW1hcAorICAgICBkZWxldGVzIGFjcm9zcyBmaWxlIHJlbmFtZXMgd2hlbiB0aGUgcmVuYW1lcyBoYXBwZW4gdmlhIGFyYml0cmFyeQorICAgICB1c2VyLXByb3ZpZGVkIHNoZWxsKQorCisgICoqIGV2ZW4gaWYgeW91IHN1Y2NlZWQgYXQgdGhlIG1hcC1kZWxldGVzLWZvci1yZW5hbWVzIGNoaWNhbmVyeSwgeW91CisgICAgIHN0aWxsIHRlY2huaWNhbGx5IHZpb2xhdGUgYmFja3dhcmQgY29tcGF0aWJpbGl0eSBiZWNhdXNlIHVzZXJzIGFyZQorICAgICBhbGxvd2VkIHRvIGZpbHRlciBmaWxlcyBpbiB3YXlzIHRoYXQgZGVwZW5kIHVwb24gdG9wb2xvZ3kgb2YKKyAgICAgY29tbWl0cyBpbnN0ZWFkIG9mIGZpbHRlcmluZyBzb2xlbHkgYmFzZWQgb24gZmlsZSBjb250ZW50cyBvciBuYW1lcworICAgICAodGhvdWdoIHRoaXMgaGFzIG5vdCBiZWVuIG9ic2VydmVkIGluIHRoZSB3aWxkKS4KKworKiBFdmVuIGlmIHlvdSBkb24ndCBuZWVkIHRvIGVkaXQgZmlsZXMgYnV0IG9ubHkgd2FudCB0byBlLmcuIHJlbmFtZSBvcgorcmVtb3ZlIHNvbWUgYW5kIHRodXMgY2FuIGF2b2lkIGNoZWNraW5nIG91dCBlYWNoIGZpbGUgKGkuZS4geW91IGNhbiB1c2UKKy0taW5kZXgtZmlsdGVyKSwgeW91IHN0aWxsIGFyZSBwYXNzaW5nIHNoZWxsIHNuaXBwZXRzIGZvciB5b3VyIGZpbHRlcnMuCitUaGlzIG1lYW5zIHRoYXQgZm9yIGV2ZXJ5IGNvbW1pdCwgeW91IGhhdmUgdG8gaGF2ZSBhIHByZXBhcmVkIGdpdCByZXBvCit3aGVyZSB0aG9zZSBmaWx0ZXJzIGNhbiBiZSBydW4uICBUaGF0J3MgYSBzaWduaWZpY2FudCBzZXR1cC4KKworKiBGdXJ0aGVyLCBzZXZlcmFsIGFkZGl0aW9uYWwgZmlsZXMgYXJlIGNyZWF0ZWQgb3IgdXBkYXRlZCBwZXIgY29tbWl0IGJ5CitnaXQtZmlsdGVyLWJyYW5jaC4gIFNvbWUgb2YgdGhlc2UgYXJlIGZvciBzdXBwb3J0aW5nIHRoZSBjb252ZW5pZW5jZQorZnVuY3Rpb25zIHByb3ZpZGVkIGJ5IGdpdC1maWx0ZXItYnJhbmNoIChzdWNoIGFzIG1hcCgpKSwgd2hpbGUgb3RoZXJzCithcmUgZm9yIGtlZXBpbmcgdHJhY2sgb2YgaW50ZXJuYWwgc3RhdGUgKGJ1dCBjb3VsZCBoYXZlIGFsc28gYmVlbgorYWNjZXNzZWQgYnkgdXNlciBmaWx0ZXJzOyBvbmUgb2YgZ2l0LWZpbHRlci1icmFuY2gncyByZWdyZXNzaW9uIHRlc3RzCitkb2VzIHNvKS4gIFRoaXMgZXNzZW50aWFsbHkgYW1vdW50cyB0byB1c2luZyB0aGUgZmlsZXN5c3RlbSBhcyBhbiBJUEMKK21lY2hhbmlzbSBiZXR3ZWVuIGdpdC1maWx0ZXItYnJhbmNoIGFuZCB0aGUgdXNlci1wcm92aWRlZCBmaWx0ZXJzLgorRGlza3MgdGVuZCB0byBiZSBhIHNsb3cgSVBDIG1lY2hhbmlzbSwgYW5kIHdyaXRpbmcgdGhlc2UgZmlsZXMgYWxzbworZWZmZWN0aXZlbHkgcmVwcmVzZW50cyBhIGZvcmNlZCBzeW5jaHJvbml6YXRpb24gcG9pbnQgYmV0d2VlbiBzZXBhcmF0ZQorcHJvY2Vzc2VzIHRoYXQgd2UgaGl0IHdpdGggZXZlcnkgY29tbWl0LgorCisqIFRoZSB1c2VyLXByb3ZpZGVkIHNoZWxsIGNvbW1hbmRzIHdpbGwgbGlrZWx5IGludm9sdmUgYSBwaXBlbGluZSBvZgorY29tbWFuZHMsIHJlc3VsdGluZyBpbiB0aGUgY3JlYXRpb24gb2YgbWFueSBwcm9jZXNzZXMgcGVyIGNvbW1pdC4KK0NyZWF0aW5nIGFuZCBydW5uaW5nIGFub3RoZXIgcHJvY2VzcyB0YWtlcyBhIHdpZGVseSB2YXJ5aW5nIGFtb3VudCBvZgordGltZSBiZXR3ZWVuIG9wZXJhdGluZyBzeXN0ZW1zLCBidXQgb24gYW55IHBsYXRmb3JtIGl0IGlzIHZlcnkgc2xvdworcmVsYXRpdmUgdG8gaW52b2tpbmcgYSBmdW5jdGlvbi4KKworKiBnaXQtZmlsdGVyLWJyYW5jaCBpdHNlbGYgaXMgd3JpdHRlbiBpbiBzaGVsbCwgd2hpY2ggaXMga2luZCBvZiBzbG93LgorVGhpcyBpcyB0aGUgb25lIHBlcmZvcm1hbmNlIGlzc3VlIHRoYXQgY291bGQgYmUgYmFja3dhcmQtY29tcGF0aWJseQorZml4ZWQsIGJ1dCBjb21wYXJlZCB0byB0aGUgYWJvdmUgcHJvYmxlbXMgdGhhdCBhcmUgaW50cmluc2ljIHRvIHRoZQorZGVzaWduIG9mIGdpdC1maWx0ZXItYnJhbmNoLCB0aGUgbGFuZ3VhZ2Ugb2YgdGhlIHRvb2wgaXRzZWxmIGlzIGEKK3JlbGF0aXZlbHkgbWlub3IgaXNzdWUuCisKKyAgKiogU2lkZSBub3RlOiBVbmZvcnR1bmF0ZWx5LCBwZW9wbGUgdGVuZCB0byBmaXhhdGUgb24gdGhlCisgICAgIHdyaXR0ZW4taW4tc2hlbGwgYXNwZWN0IGFuZCBwZXJpb2RpY2FsbHkgYXNrIGlmIGdpdC1maWx0ZXItYnJhbmNoCisgICAgIGNvdWxkIGJlIHJld3JpdHRlbiBpbiBhbm90aGVyIGxhbmd1YWdlIHRvIGZpeCB0aGUgcGVyZm9ybWFuY2UKKyAgICAgaXNzdWVzLiAgTm90IG9ubHkgZG9lcyB0aGF0IGlnbm9yZSB0aGUgYmlnZ2VyIGludHJpbnNpYyBwcm9ibGVtcworICAgICB3aXRoIHRoZSBkZXNpZ24sIGl0J2QgaGVscCBsZXNzIHRoYW4geW91J2QgZXhwZWN0OiBpZgorICAgICBnaXQtZmlsdGVyLWJyYW5jaCBpdHNlbGYgd2VyZSBub3Qgc2hlbGwsIHRoZW4gdGhlIGNvbnZlbmllbmNlCisgICAgIGZ1bmN0aW9ucyAobWFwKCksIHNraXBfY29tbWl0KCksIGV0YykgYW5kIHRoZSBgLS1zZXR1cGAgYXJndW1lbnQKKyAgICAgY291bGQgbm8gbG9uZ2VyIGJlIGV4ZWN1dGVkIG9uY2UgYXQgdGhlIGJlZ2lubmluZyBvZiB0aGUgcHJvZ3JhbQorICAgICBidXQgd291bGQgaW5zdGVhZCBuZWVkIHRvIGJlIHByZXBlbmRlZCB0byBldmVyeSB1c2VyIGZpbHRlciAoYW5kCisgICAgIHRodXMgcmUtZXhlY3V0ZWQgd2l0aCBldmVyeSBjb21taXQpLgorCitUaGUgaHR0cHM6Ly9naXRodWIuY29tL25ld3Jlbi9naXQtZmlsdGVyLXJlcG8vW2dpdCBmaWx0ZXItcmVwb10gdG9vbCBpcworYW4gYWx0ZXJuYXRpdmUgdG8gZ2l0LWZpbHRlci1icmFuY2ggd2hpY2ggZG9lcyBub3Qgc3VmZmVyIGZyb20gdGhlc2UKK3BlcmZvcm1hbmNlIHByb2JsZW1zIG9yIHRoZSBzYWZldHkgcHJvYmxlbXMgKG1lbnRpb25lZCBiZWxvdykuIEZvciB0aG9zZQord2l0aCBleGlzdGluZyB0b29saW5nIHdoaWNoIHJlbGllcyB1cG9uIGdpdC1maWx0ZXItYnJhbmNoLCAnZ2l0CityZXBvLWZpbHRlcicgYWxzbyBwcm92aWRlcworaHR0cHM6Ly9naXRodWIuY29tL25ld3Jlbi9naXQtZmlsdGVyLXJlcG8vYmxvYi9tYXN0ZXIvY29udHJpYi9maWx0ZXItcmVwby1kZW1vcy9maWx0ZXItbGFtZWx5W2ZpbHRlci1sYW1lbHldLAorYSBkcm9wLWluIGdpdC1maWx0ZXItYnJhbmNoIHJlcGxhY2VtZW50ICh3aXRoIGEgZmV3IGNhdmVhdHMpLiAgV2hpbGUKK2ZpbHRlci1sYW1lbHkgc3VmZmVycyBmcm9tIGFsbCB0aGUgc2FtZSBzYWZldHkgaXNzdWVzIGFzCitnaXQtZmlsdGVyLWJyYW5jaCwgaXQgYXQgbGVhc3QgYW1lbGlvcmF0ZXMgdGhlIHBlcmZvcm1hbmNlIGlzc3VlcyBhCitsaXR0bGUuCisKK1tbU0FGRVRZXV0KK1NBRkVUWQorLS0tLS0tCisKK2dpdC1maWx0ZXItYnJhbmNoIGlzIHJpZGRsZWQgd2l0aCBnb3RjaGFzIHJlc3VsdGluZyBpbiB2YXJpb3VzIHdheXMgdG8KK2Vhc2lseSBjb3JydXB0IHJlcG9zIG9yIGVuZCB1cCB3aXRoIGEgbWVzcyB3b3JzZSB0aGFuIHdoYXQgeW91IHN0YXJ0ZWQKK3dpdGg6CisKKyogU29tZW9uZSBjYW4gaGF2ZSBhIHNldCBvZiAid29ya2luZyBhbmQgdGVzdGVkIGZpbHRlcnMiIHdoaWNoIHRoZXkKK2RvY3VtZW50IG9yIHByb3ZpZGUgdG8gYSBjb3dvcmtlciwgd2hvIHRoZW4gcnVucyB0aGVtIG9uIGEgZGlmZmVyZW50IE9TCit3aGVyZSB0aGUgc2FtZSBjb21tYW5kcyBhcmUgbm90IHdvcmtpbmcvdGVzdGVkIChzb21lIGV4YW1wbGVzIGluIHRoZQorZ2l0LWZpbHRlci1icmFuY2ggbWFucGFnZSBhcmUgYWxzbyBhZmZlY3RlZCBieSB0aGlzKS4gIEJTRCB2cy4gR05VCit1c2VybGFuZCBkaWZmZXJlbmNlcyBjYW4gcmVhbGx5IGJpdGUuICBJZiBsdWNreSwgZXJyb3IgbWVzc2FnZXMgYXJlCitzcGV3ZWQuICBCdXQganVzdCBhcyBsaWtlbHksIHRoZSBjb21tYW5kcyBlaXRoZXIgZG9uJ3QgZG8gdGhlIGZpbHRlcmluZworcmVxdWVzdGVkLCBvciBzaWxlbnRseSBjb3JydXB0IGJ5IG1ha2luZyBzb21lIHVud2FudGVkIGNoYW5nZS4gIFRoZQordW53YW50ZWQgY2hhbmdlIG1heSBvbmx5IGFmZmVjdCBhIGZldyBjb21taXRzLCBzbyBpdCdzIG5vdCBuZWNlc3NhcmlseQorb2J2aW91cyBlaXRoZXIuICAoVGhlIGZhY3QgdGhhdCBwcm9ibGVtcyB3b24ndCBuZWNlc3NhcmlseSBiZSBvYnZpb3VzCittZWFucyB0aGV5IGFyZSBsaWtlbHkgdG8gZ28gdW5ub3RpY2VkIHVudGlsIHRoZSByZXdyaXR0ZW4gaGlzdG9yeSBpcyBpbgordXNlIGZvciBxdWl0ZSBhIHdoaWxlLCBhdCB3aGljaCBwb2ludCBpdCdzIHJlYWxseSBoYXJkIHRvIGp1c3RpZnkKK2Fub3RoZXIgZmxhZy1kYXkgZm9yIGFub3RoZXIgcmV3cml0ZS4pCisKKyogRmlsZW5hbWVzIHdpdGggc3BhY2VzIGFyZSBvZnRlbiBtaXNoYW5kbGVkIGJ5IHNoZWxsIHNuaXBwZXRzIHNpbmNlCit0aGV5IGNhdXNlIHByb2JsZW1zIGZvciBzaGVsbCBwaXBlbGluZXMuICBOb3QgZXZlcnlvbmUgaXMgZmFtaWxpYXIgd2l0aAorZmluZCAtcHJpbnQwLCB4YXJncyAtMCwgZ2l0LWxzLWZpbGVzIC16LCBldGMuICBFdmVuIHBlb3BsZSB3aG8gYXJlCitmYW1pbGlhciB3aXRoIHRoZXNlIG1heSBhc3N1bWUgc3VjaCBmbGFncyBhcmUgbm90IHJlbGV2YW50IGJlY2F1c2UKK3NvbWVvbmUgZWxzZSByZW5hbWVkIGFueSBzdWNoIGZpbGVzIGluIHRoZWlyIHJlcG8gYmFjayBiZWZvcmUgdGhlIHBlcnNvbgorZG9pbmcgdGhlIGZpbHRlcmluZyBqb2luZWQgdGhlIHByb2plY3QuICBBbmQgb2Z0ZW4sIGV2ZW4gdGhvc2UgZmFtaWxpYXIKK3dpdGggaGFuZGxpbmcgYXJndW1lbnRzIHdpdGggc3BhY2VzIG1heSBub3QgZG8gc28ganVzdCBiZWNhdXNlIHRoZXkKK2FyZW4ndCBpbiB0aGUgbWluZHNldCBvZiB0aGlua2luZyBhYm91dCBldmVyeXRoaW5nIHRoYXQgY291bGQgcG9zc2libHkKK2dvIHdyb25nLgorCisqIE5vbi1hc2NpaSBmaWxlbmFtZXMgY2FuIGJlIHNpbGVudGx5IHJlbW92ZWQgZGVzcGl0ZSBiZWluZyBpbiBhIGRlc2lyZWQKK2RpcmVjdG9yeS4gIEtlZXBpbmcgb25seSB3YW50ZWQgcGF0aHMgaXMgb2Z0ZW4gZG9uZSB1c2luZyBwaXBlbGluZXMgbGlrZQorYGdpdCBscy1maWxlcyB8IGdyZXAgLXYgXldBTlRFRF9ESVIvIHwgeGFyZ3MgZ2l0IHJtYC4gIGxzLWZpbGVzIHdpbGwKK29ubHkgcXVvdGUgZmlsZW5hbWVzIGlmIG5lZWRlZCwgc28gZm9sa3MgbWF5IG5vdCBub3RpY2UgdGhhdCBvbmUgb2YgdGhlCitmaWxlcyBkaWRuJ3QgbWF0Y2ggdGhlIHJlZ2V4IChhdCBsZWFzdCBub3QgdW50aWwgaXQncyBtdWNoIHRvbyBsYXRlKS4KK1llcywgc29tZW9uZSB3aG8ga25vd3MgYWJvdXQgY29yZS5xdW90ZVBhdGggY2FuIGF2b2lkIHRoaXMgKHVubGVzcyB0aGV5CitoYXZlIG90aGVyIHNwZWNpYWwgY2hhcmFjdGVycyBsaWtlIFx0LCBcbiwgb3IgIiksIGFuZCBwZW9wbGUgd2hvIHVzZQorbHMtZmlsZXMgLXogd2l0aCBzb21ldGhpbmcgb3RoZXIgdGhhbiBncmVwIGNhbiBhdm9pZCB0aGlzLCBidXQgdGhhdAorZG9lc24ndCBtZWFuIHRoZXkgd2lsbC4KKworKiBTaW1pbGFybHksIHdoZW4gbW92aW5nIGZpbGVzIGFyb3VuZCwgb25lIGNhbiBmaW5kIHRoYXQgZmlsZW5hbWVzIHdpdGgKK25vbi1hc2NpaSBvciBzcGVjaWFsIGNoYXJhY3RlcnMgZW5kIHVwIGluIGEgZGlmZmVyZW50IGRpcmVjdG9yeSwgb25lCit0aGF0IGluY2x1ZGVzIGEgZG91YmxlIHF1b3RlIGNoYXJhY3Rlci4gIChUaGlzIGlzIHRlY2huaWNhbGx5IHRoZSBzYW1lCitpc3N1ZSBhcyBhYm92ZSB3aXRoIHF1b3RpbmcsIGJ1dCBwZXJoYXBzIGFuIGludGVyZXN0aW5nIGRpZmZlcmVudCB3YXkKK3RoYXQgaXQgY2FuIGFuZCBoYXMgbWFuaWZlc3RlZCBhcyBhIHByb2JsZW0uKQorCisqIEl0J3MgZmFyIHRvbyBlYXN5IHRvIGFjY2lkZW50YWxseSBtaXggdXAgb2xkIGFuZCBuZXcgaGlzdG9yeS4gIEl0J3MKK3N0aWxsIHBvc3NpYmxlIHdpdGggYW55IHRvb2wsIGJ1dCBnaXQtZmlsdGVyLWJyYW5jaCBhbG1vc3QgaW52aXRlcyBpdC4KK0lmIGx1Y2t5LCB0aGUgb25seSBkb3duc2lkZSBpcyB1c2VycyBnZXR0aW5nIGZydXN0cmF0ZWQgdGhhdCB0aGV5IGRvbid0Citrbm93IGhvdyB0byBzaHJpbmsgdGhlaXIgcmVwbyBhbmQgcmVtb3ZlIHRoZSBvbGQgc3R1ZmYuICBJZiB1bmx1Y2t5LAordGhleSBtZXJnZSBvbGQgYW5kIG5ldyBoaXN0b3J5IGFuZCBlbmQgdXAgd2l0aCBtdWx0aXBsZSAiY29waWVzIiBvZiBlYWNoCitjb21taXQsIHNvbWUgb2Ygd2hpY2ggaGF2ZSB1bndhbnRlZCBvciBzZW5zaXRpdmUgZmlsZXMgYW5kIG90aGVycyB3aGljaAorZG9uJ3QuICBUaGlzIGNvbWVzIGFib3V0IGluIG11bHRpcGxlIGRpZmZlcmVudCB3YXlzOgorCisgICoqIHRoZSBkZWZhdWx0IHRvIG9ubHkgZG9pbmcgYSBwYXJ0aWFsIGhpc3RvcnkgcmV3cml0ZSAoJy0tYWxsJyBpcyBub3QKKyAgICAgdGhlIGRlZmF1bHQgYW5kIGZldyBleGFtcGxlcyBzaG93IGl0KQorCisgICoqIHRoZSBmYWN0IHRoYXQgdGhlcmUncyBubyBhdXRvbWF0aWMgcG9zdC1ydW4gY2xlYW51cAorCisgICoqIHRoZSBmYWN0IHRoYXQgLS10YWctbmFtZS1maWx0ZXIgKHdoZW4gdXNlZCB0byByZW5hbWUgdGFncykgZG9lc24ndAorICAgICByZW1vdmUgdGhlIG9sZCB0YWdzIGJ1dCBqdXN0IGFkZHMgbmV3IG9uZXMgd2l0aCB0aGUgbmV3IG5hbWUKKworICAqKiB0aGUgZmFjdCB0aGF0IGxpdHRsZSBlZHVjYXRpb25hbCBpbmZvcm1hdGlvbiBpcyBwcm92aWRlZCB0byBpbmZvcm0KKyAgICAgdXNlcnMgb2YgdGhlIHJhbWlmaWNhdGlvbnMgb2YgYSByZXdyaXRlIGFuZCBob3cgdG8gYXZvaWQgbWl4aW5nIG9sZAorICAgICBhbmQgbmV3IGhpc3RvcnkuICBGb3IgZXhhbXBsZSwgdGhpcyBtYW4gcGFnZSBkaXNjdXNzZXMgaG93IHVzZXJzCisgICAgIG5lZWQgdG8gdW5kZXJzdGFuZCB0aGF0IHRoZXkgbmVlZCB0byByZWJhc2UgdGhlaXIgY2hhbmdlcyBmb3IgYWxsCisgICAgIHRoZWlyIGJyYW5jaGVzIG9uIHRvcCBvZiBuZXcgaGlzdG9yeSAob3IgZGVsZXRlIGFuZCByZWNsb25lKSwgYnV0CisgICAgIHRoYXQncyBvbmx5IG9uZSBvZiBtdWx0aXBsZSBjb25jZXJucyB0byBjb25zaWRlci4gIFNlZSB0aGUKKyAgICAgIkRJU0NVU1NJT04iIHNlY3Rpb24gb2YgdGhlIGdpdCBmaWx0ZXItcmVwbyBtYW51YWwgcGFnZSBmb3IgbW9yZQorICAgICBkZXRhaWxzLgorCisqIEFubm90YXRlZCB0YWdzIGNhbiBiZSBhY2NpZGVudGFsbHkgY29udmVydGVkIHRvIGxpZ2h0d2VpZ2h0IHRhZ3MsIGR1ZQordG8gZWl0aGVyIG9mIHR3byBpc3N1ZXM6CisKKyAgKiogU29tZW9uZSBjYW4gZG8gYSBoaXN0b3J5IHJld3JpdGUsIHJlYWxpemUgdGhleSBtZXNzZWQgdXAsIHJlc3RvcmUKKyAgICAgZnJvbSB0aGUgYmFja3VwcyBpbiByZWZzL29yaWdpbmFsLywgYW5kIHRoZW4gcmVkbyB0aGVpcgorICAgICBnaXQtZmlsdGVyLWJyYW5jaCBjb21tYW5kLiAgKFRoZSBiYWNrdXAgaW4gcmVmcy9vcmlnaW5hbC8gaXMgbm90IGEKKyAgICAgcmVhbCBiYWNrdXA7IGl0IGRlcmVmZXJlbmNlcyB0YWdzIGZpcnN0LikKKworICAqKiBSdW5uaW5nIGdpdC1maWx0ZXItYnJhbmNoIHdpdGggZWl0aGVyIC0tdGFncyBvciAtLWFsbCBpbiB5b3VyCisgICAgIDxyZXYtbGlzdCBvcHRpb25zPi4gIEluIG9yZGVyIHRvIHJldGFpbiBhbm5vdGF0ZWQgdGFncyBhcworICAgICBhbm5vdGF0ZWQsIHlvdSBtdXN0IHVzZSAtLXRhZy1uYW1lLWZpbHRlciAoYW5kIG11c3Qgbm90IGhhdmUKKyAgICAgcmVzdG9yZWQgZnJvbSByZWZzL29yaWdpbmFsLyBpbiBhIHByZXZpb3VzbHkgYm90Y2hlZCByZXdyaXRlKS4KKworKiBBbnkgY29tbWl0IG1lc3NhZ2VzIHRoYXQgc3BlY2lmeSBhbiBlbmNvZGluZyB3aWxsIGJlY29tZSBjb3JydXB0ZWQKK2J5IHRoZSByZXdyaXRlOyBnaXQtZmlsdGVyLWJyYW5jaCBpZ25vcmVzIHRoZSBlbmNvZGluZywgdGFrZXMgdGhlIG9yaWdpbmFsCitieXRlcywgYW5kIGZlZWRzIGl0IHRvIGNvbW1pdC10cmVlIHdpdGhvdXQgdGVsbGluZyBpdCB0aGUgcHJvcGVyCitlbmNvZGluZy4gIChUaGlzIGhhcHBlbnMgd2hldGhlciBvciBub3QgLS1tc2ctZmlsdGVyIGlzIHVzZWQuKQorCisqIENvbW1pdCBtZXNzYWdlcyAoZXZlbiBpZiB0aGV5IGFyZSBhbGwgVVRGLTgpIGJ5IGRlZmF1bHQgYmVjb21lCitjb3JydXB0ZWQgZHVlIHRvIG5vdCBiZWluZyB1cGRhdGVkIC0tIGFueSByZWZlcmVuY2VzIHRvIG90aGVyIGNvbW1pdAoraGFzaGVzIGluIGNvbW1pdCBtZXNzYWdlcyB3aWxsIG5vdyByZWZlciB0byBuby1sb25nZXItZXh0YW50IGNvbW1pdHMuCisKKyogVGhlcmUgYXJlIG5vIGZhY2lsaXRpZXMgZm9yIGhlbHBpbmcgdXNlcnMgZmluZCB3aGF0IHVud2FudGVkIGNydWQgdGhleQorc2hvdWxkIGRlbGV0ZSwgd2hpY2ggbWVhbnMgdGhleSBhcmUgbXVjaCBtb3JlIGxpa2VseSB0byBoYXZlIGluY29tcGxldGUKK29yIHBhcnRpYWwgY2xlYW51cHMgdGhhdCBzb21ldGltZXMgcmVzdWx0IGluIGNvbmZ1c2lvbiBhbmQgcGVvcGxlCit3YXN0aW5nIHRpbWUgdHJ5aW5nIHRvIHVuZGVyc3RhbmQuICAoRm9yIGV4YW1wbGUsIGZvbGtzIHRlbmQgdG8ganVzdAorbG9vayBmb3IgYmlnIGZpbGVzIHRvIGRlbGV0ZSBpbnN0ZWFkIG9mIGJpZyBkaXJlY3RvcmllcyBvciBleHRlbnNpb25zLAorYW5kIG9uY2UgdGhleSBkbyBzbywgdGhlbiBzb21ldGltZSBsYXRlciBmb2xrcyB1c2luZyB0aGUgbmV3IHJlcG9zaXRvcnkKK3dobyBhcmUgZ29pbmcgdGhyb3VnaCBoaXN0b3J5IHdpbGwgbm90aWNlIGEgYnVpbGQgYXJ0aWZhY3QgZGlyZWN0b3J5Cit0aGF0IGhhcyBzb21lIGZpbGVzIGJ1dCBub3Qgb3RoZXJzLCBvciBhIGNhY2hlIG9mIGRlcGVuZGVuY2llcworKG5vZGVfbW9kdWxlcyBvciBzaW1pbGFyKSB3aGljaCBjb3VsZG4ndCBoYXZlIGV2ZXIgYmVlbiBmdW5jdGlvbmFsIHNpbmNlCitpdCdzIG1pc3Npbmcgc29tZSBmaWxlcy4pCisKKyogSWYgLS1wcnVuZS1lbXB0eSBpc24ndCBzcGVjaWZpZWQsIHRoZW4gdGhlIGZpbHRlcmluZyBwcm9jZXNzIGNhbgorY3JlYXRlIGhvYXJkcyBvZiBjb25mdXNpbmcgZW1wdHkgY29tbWl0cworCisqIElmIC0tcHJ1bmUtZW1wdHkgaXMgc3BlY2lmaWVkLCB0aGVuIGludGVudGlvbmFsbHkgcGxhY2VkIGVtcHR5Citjb21taXRzIGZyb20gYmVmb3JlIHRoZSBmaWx0ZXJpbmcgb3BlcmF0aW9uIGFyZSBhbHNvIHBydW5lZCBpbnN0ZWFkIG9mCitqdXN0IHBydW5pbmcgY29tbWl0cyB0aGF0IGJlY2FtZSBlbXB0eSBkdWUgdG8gZmlsdGVyaW5nIHJ1bGVzLgorCisqIElmIC0tcHJ1bmUtZW1wdHkgaXMgc3BlY2lmaWVkLCBzb21ldGltZXMgZW1wdHkgY29tbWl0cyBhcmUgbWlzc2VkCithbmQgbGVmdCBhcm91bmQgYW55d2F5IChhIHNvbWV3aGF0IHJhcmUgYnVnLCBidXQgaXQgaGFwcGVucy4uLikKKworKiBBIG1pbm9yIGlzc3VlLCBidXQgdXNlcnMgd2hvIGhhdmUgYSBnb2FsIHRvIHVwZGF0ZSBhbGwgbmFtZXMgYW5kCitlbWFpbHMgaW4gYSByZXBvc2l0b3J5IG1heSBiZSBsZWQgdG8gLS1lbnYtZmlsdGVyIHdoaWNoIHdpbGwgb25seSB1cGRhdGUKK2F1dGhvcnMgYW5kIGNvbW1pdHRlcnMsIG1pc3NpbmcgdGFnZ2Vycy4KKworKiBJZiB0aGUgdXNlciBwcm92aWRlcyBhIC0tdGFnLW5hbWUtZmlsdGVyIHRoYXQgbWFwcyBtdWx0aXBsZSB0YWdzIHRvCit0aGUgc2FtZSBuYW1lLCBubyB3YXJuaW5nIG9yIGVycm9yIGlzIHByb3ZpZGVkOyBnaXQtZmlsdGVyLWJyYW5jaCBzaW1wbHkKK292ZXJ3cml0ZXMgZWFjaCB0YWcgaW4gc29tZSB1bmRvY3VtZW50ZWQgcHJlLWRlZmluZWQgb3JkZXIgcmVzdWx0aW5nIGluCitvbmx5IG9uZSB0YWcgYXQgdGhlIGVuZC4gIChBIGdpdC1maWx0ZXItYnJhbmNoIHJlZ3Jlc3Npb24gdGVzdCByZXF1aXJlcwordGhpcyBzdXJwcmlzaW5nIGJlaGF2aW9yLikKKworQWxzbywgdGhlIHBvb3IgcGVyZm9ybWFuY2Ugb2YgZ2l0LWZpbHRlci1icmFuY2ggb2Z0ZW4gbGVhZHMgdG8gc2FmZXR5Citpc3N1ZXM6CisKKyogQ29taW5nIHVwIHdpdGggdGhlIGNvcnJlY3Qgc2hlbGwgc25pcHBldCB0byBkbyB0aGUgZmlsdGVyaW5nIHlvdSB3YW50CitpcyBzb21ldGltZXMgZGlmZmljdWx0IHVubGVzcyB5b3UncmUganVzdCBkb2luZyBhIHRyaXZpYWwgbW9kaWZpY2F0aW9uCitzdWNoIGFzIGRlbGV0aW5nIGEgY291cGxlIGZpbGVzLiAgVW5mb3J0dW5hdGVseSwgcGVvcGxlIG9mdGVuIGxlYXJuIGlmCit0aGUgc25pcHBldCBpcyByaWdodCBvciB3cm9uZyBieSB0cnlpbmcgaXQgb3V0LCBidXQgdGhlIHJpZ2h0bmVzcyBvcgord3JvbmduZXNzIGNhbiB2YXJ5IGRlcGVuZGluZyBvbiBzcGVjaWFsIGNpcmN1bXN0YW5jZXMgKHNwYWNlcyBpbgorZmlsZW5hbWVzLCBub24tYXNjaWkgZmlsZW5hbWVzLCBmdW5ueSBhdXRob3IgbmFtZXMgb3IgZW1haWxzLCBpbnZhbGlkCit0aW1lem9uZXMsIHByZXNlbmNlIG9mIGdyYWZ0cyBvciByZXBsYWNlIG9iamVjdHMsIGV0Yy4pLCBtZWFuaW5nIHRoZXkKK21heSBoYXZlIHRvIHdhaXQgYSBsb25nIHRpbWUsIGhpdCBhbiBlcnJvciwgdGhlbiByZXN0YXJ0LiAgVGhlCitwZXJmb3JtYW5jZSBvZiBnaXQtZmlsdGVyLWJyYW5jaCBpcyBzbyBiYWQgdGhhdCB0aGlzIGN5Y2xlIGlzIHBhaW5mdWwsCityZWR1Y2luZyB0aGUgdGltZSBhdmFpbGFibGUgdG8gY2FyZWZ1bGx5IHJlLWNoZWNrICh0byBzYXkgbm90aGluZyBhYm91dAord2hhdCBpdCBkb2VzIHRvIHRoZSBwYXRpZW5jZSBvZiB0aGUgcGVyc29uIGRvaW5nIHRoZSByZXdyaXRlIGV2ZW4gaWYKK3RoZXkgZG8gdGVjaG5pY2FsbHkgaGF2ZSBtb3JlIHRpbWUgYXZhaWxhYmxlKS4gIFRoaXMgcHJvYmxlbSBpcyBleHRyYQorY29tcG91bmRlZCBiZWNhdXNlIGVycm9ycyBmcm9tIGJyb2tlbiBmaWx0ZXJzIG1heSBub3QgYmUgc2hvd24gZm9yIGEKK2xvbmcgdGltZSBhbmQvb3IgZ2V0IGxvc3QgaW4gYSBzZWEgb2Ygb3V0cHV0LiAgRXZlbiB3b3JzZSwgYnJva2VuCitmaWx0ZXJzIG9mdGVuIGp1c3QgcmVzdWx0IGluIHNpbGVudCBpbmNvcnJlY3QgcmV3cml0ZXMuCisKKyogVG8gdG9wIGl0IGFsbCBvZmYsIGV2ZW4gd2hlbiB1c2VycyBmaW5hbGx5IGZpbmQgd29ya2luZyBjb21tYW5kcywgdGhleQorbmF0dXJhbGx5IHdhbnQgdG8gc2hhcmUgdGhlbS4gIEJ1dCB0aGV5IG1heSBiZSB1bmF3YXJlIHRoYXQgdGhlaXIgcmVwbworZGlkbid0IGhhdmUgc29tZSBzcGVjaWFsIGNhc2VzIHRoYXQgc29tZW9uZSBlbHNlJ3MgZG9lcy4gIFNvLCB3aGVuCitzb21lb25lIGVsc2Ugd2l0aCBhIGRpZmZlcmVudCByZXBvc2l0b3J5IHJ1bnMgdGhlIHNhbWUgY29tbWFuZHMsIHRoZXkKK2dldCBoaXQgYnkgdGhlIHByb2JsZW1zIGFib3ZlLiAgT3IsIHRoZSB1c2VyIGp1c3QgcnVucyBjb21tYW5kcyB0aGF0CityZWFsbHkgd2VyZSB2ZXR0ZWQgZm9yIHNwZWNpYWwgY2FzZXMsIGJ1dCB0aGV5IHJ1biBpdCBvbiBhIGRpZmZlcmVudCBPUword2hlcmUgaXQgZG9lc24ndCB3b3JrLCBhcyBub3RlZCBhYm92ZS4KIAogR0lUCiAtLS0KZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vZ2l0LWZvcm1hdC1wYXRjaC50eHQgYi9Eb2N1bWVudGF0aW9uL2dpdC1mb3JtYXQtcGF0Y2gudHh0CmluZGV4IGI5Yjk3ZTYuLjAwYmRmOWIgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vZ2l0LWZvcm1hdC1wYXRjaC50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9naXQtZm9ybWF0LXBhdGNoLnR4dApAQCAtMTcsOSArMTcsMTAgQEAKIAkJICAgWy0tc2lnbmF0dXJlLWZpbGU9PGZpbGU+XQogCQkgICBbLW4gfCAtLW51bWJlcmVkIHwgLU4gfCAtLW5vLW51bWJlcmVkXQogCQkgICBbLS1zdGFydC1udW1iZXIgPG4+XSBbLS1udW1iZXJlZC1maWxlc10KLQkJICAgWy0taW4tcmVwbHktdG89TWVzc2FnZS1JZF0gWy0tc3VmZml4PS48c2Z4Pl0KKwkJICAgWy0taW4tcmVwbHktdG89PG1lc3NhZ2UgaWQ+XSBbLS1zdWZmaXg9LjxzZng+XQogCQkgICBbLS1pZ25vcmUtaWYtaW4tdXBzdHJlYW1dCi0JCSAgIFstLXJmY10gWy0tc3ViamVjdC1wcmVmaXg9U3ViamVjdC1QcmVmaXhdCisJCSAgIFstLWNvdmVyLWZyb20tZGVzY3JpcHRpb249PG1vZGU+XQorCQkgICBbLS1yZmNdIFstLXN1YmplY3QtcHJlZml4PTxzdWJqZWN0IHByZWZpeD5dCiAJCSAgIFsoLS1yZXJvbGwtY291bnR8LXYpIDxuPl0KIAkJICAgWy0tdG89PGVtYWlsPl0gWy0tY2M9PGVtYWlsPl0KIAkJICAgWy0tW25vLV1jb3Zlci1sZXR0ZXJdIFstLXF1aWV0XQpAQCAtNjYsNyArNjcsOCBAQAogY2FuIGJlIHNldCB3aXRoIHRoZSBgZm9ybWF0Lm91dHB1dERpcmVjdG9yeWAgY29uZmlndXJhdGlvbiBvcHRpb24uCiBUaGUgYC1vYCBvcHRpb24gdGFrZXMgcHJlY2VkZW5jZSBvdmVyIGBmb3JtYXQub3V0cHV0RGlyZWN0b3J5YC4KIFRvIHN0b3JlIHBhdGNoZXMgaW4gdGhlIGN1cnJlbnQgd29ya2luZyBkaXJlY3RvcnkgZXZlbiB3aGVuCi1gZm9ybWF0Lm91dHB1dERpcmVjdG9yeWAgcG9pbnRzIGVsc2V3aGVyZSwgdXNlIGAtbyAuYC4KK2Bmb3JtYXQub3V0cHV0RGlyZWN0b3J5YCBwb2ludHMgZWxzZXdoZXJlLCB1c2UgYC1vIC5gLiBBbGwgZGlyZWN0b3J5Citjb21wb25lbnRzIHdpbGwgYmUgY3JlYXRlZC4KIAogQnkgZGVmYXVsdCwgdGhlIHN1YmplY3Qgb2YgYSBzaW5nbGUgcGF0Y2ggaXMgIltQQVRDSF0gIiBmb2xsb3dlZCBieQogdGhlIGNvbmNhdGVuYXRpb24gb2YgbGluZXMgZnJvbSB0aGUgY29tbWl0IG1lc3NhZ2UgdXAgdG8gdGhlIGZpcnN0IGJsYW5rCkBAIC0xNTksOSArMTYxLDkgQEAKIGl0c2VsZi4gIElmIHlvdSB3YW50IGBnaXQgZm9ybWF0LXBhdGNoYCB0byB0YWtlIGNhcmUgb2YgdGhyZWFkaW5nLCB5b3UKIHdpbGwgd2FudCB0byBlbnN1cmUgdGhhdCB0aHJlYWRpbmcgaXMgZGlzYWJsZWQgZm9yIGBnaXQgc2VuZC1lbWFpbGAuCiAKLS0taW4tcmVwbHktdG89TWVzc2FnZS1JZDo6CistLWluLXJlcGx5LXRvPTxtZXNzYWdlIGlkPjo6CiAJTWFrZSB0aGUgZmlyc3QgbWFpbCAob3IgYWxsIHRoZSBtYWlscyB3aXRoIGAtLW5vLXRocmVhZGApIGFwcGVhciBhcyBhCi0JcmVwbHkgdG8gdGhlIGdpdmVuIE1lc3NhZ2UtSWQsIHdoaWNoIGF2b2lkcyBicmVha2luZyB0aHJlYWRzIHRvCisJcmVwbHkgdG8gdGhlIGdpdmVuIDxtZXNzYWdlIGlkPiwgd2hpY2ggYXZvaWRzIGJyZWFraW5nIHRocmVhZHMgdG8KIAlwcm92aWRlIGEgbmV3IHBhdGNoIHNlcmllcy4KIAogLS1pZ25vcmUtaWYtaW4tdXBzdHJlYW06OgpAQCAtMTcxLDkgKzE3MywyOSBAQAogCXBhdGNoZXMgYmVpbmcgZ2VuZXJhdGVkLCBhbmQgYW55IHBhdGNoIHRoYXQgbWF0Y2hlcyBpcwogCWlnbm9yZWQuCiAKLS0tc3ViamVjdC1wcmVmaXg9PFN1YmplY3QtUHJlZml4Pjo6CistLWNvdmVyLWZyb20tZGVzY3JpcHRpb249PG1vZGU+OjoKKwlDb250cm9scyB3aGljaCBwYXJ0cyBvZiB0aGUgY292ZXIgbGV0dGVyIHdpbGwgYmUgYXV0b21hdGljYWxseQorCXBvcHVsYXRlZCB1c2luZyB0aGUgYnJhbmNoJ3MgZGVzY3JpcHRpb24uCisrCitJZiBgPG1vZGU+YCBpcyBgbWVzc2FnZWAgb3IgYGRlZmF1bHRgLCB0aGUgY292ZXIgbGV0dGVyIHN1YmplY3Qgd2lsbCBiZQorcG9wdWxhdGVkIHdpdGggcGxhY2Vob2xkZXIgdGV4dC4gVGhlIGJvZHkgb2YgdGhlIGNvdmVyIGxldHRlciB3aWxsIGJlCitwb3B1bGF0ZWQgd2l0aCB0aGUgYnJhbmNoJ3MgZGVzY3JpcHRpb24uIFRoaXMgaXMgdGhlIGRlZmF1bHQgbW9kZSB3aGVuCitubyBjb25maWd1cmF0aW9uIG5vciBjb21tYW5kIGxpbmUgb3B0aW9uIGlzIHNwZWNpZmllZC4KKysKK0lmIGA8bW9kZT5gIGlzIGBzdWJqZWN0YCwgdGhlIGZpcnN0IHBhcmFncmFwaCBvZiB0aGUgYnJhbmNoIGRlc2NyaXB0aW9uIHdpbGwKK3BvcHVsYXRlIHRoZSBjb3ZlciBsZXR0ZXIgc3ViamVjdC4gVGhlIHJlbWFpbmRlciBvZiB0aGUgZGVzY3JpcHRpb24gd2lsbAorcG9wdWxhdGUgdGhlIGJvZHkgb2YgdGhlIGNvdmVyIGxldHRlci4KKysKK0lmIGA8bW9kZT5gIGlzIGBhdXRvYCwgaWYgdGhlIGZpcnN0IHBhcmFncmFwaCBvZiB0aGUgYnJhbmNoIGRlc2NyaXB0aW9uCitpcyBncmVhdGVyIHRoYW4gMTAwIGJ5dGVzLCB0aGVuIHRoZSBtb2RlIHdpbGwgYmUgYG1lc3NhZ2VgLCBvdGhlcndpc2UKK2BzdWJqZWN0YCB3aWxsIGJlIHVzZWQuCisrCitJZiBgPG1vZGU+YCBpcyBgbm9uZWAsIGJvdGggdGhlIGNvdmVyIGxldHRlciBzdWJqZWN0IGFuZCBib2R5IHdpbGwgYmUKK3BvcHVsYXRlZCB3aXRoIHBsYWNlaG9sZGVyIHRleHQuCisKKy0tc3ViamVjdC1wcmVmaXg9PHN1YmplY3QgcHJlZml4Pjo6CiAJSW5zdGVhZCBvZiB0aGUgc3RhbmRhcmQgJ1tQQVRDSF0nIHByZWZpeCBpbiB0aGUgc3ViamVjdAotCWxpbmUsIGluc3RlYWQgdXNlICdbPFN1YmplY3QtUHJlZml4Pl0nLiBUaGlzCisJbGluZSwgaW5zdGVhZCB1c2UgJ1s8c3ViamVjdCBwcmVmaXg+XScuIFRoaXMKIAlhbGxvd3MgZm9yIHVzZWZ1bCBuYW1pbmcgb2YgYSBwYXRjaCBzZXJpZXMsIGFuZCBjYW4gYmUKIAljb21iaW5lZCB3aXRoIHRoZSBgLS1udW1iZXJlZGAgb3B0aW9uLgogCkBAIC0zMTQsNyArMzM2LDggQEAKIC0tYmFzZT08Y29tbWl0Pjo6CiAJUmVjb3JkIHRoZSBiYXNlIHRyZWUgaW5mb3JtYXRpb24gdG8gaWRlbnRpZnkgdGhlIHN0YXRlIHRoZQogCXBhdGNoIHNlcmllcyBhcHBsaWVzIHRvLiAgU2VlIHRoZSBCQVNFIFRSRUUgSU5GT1JNQVRJT04gc2VjdGlvbgotCWJlbG93IGZvciBkZXRhaWxzLgorCWJlbG93IGZvciBkZXRhaWxzLiBJZiA8Y29tbWl0PiBpcyAiYXV0byIsIGEgYmFzZSBjb21taXQgaXMKKwlhdXRvbWF0aWNhbGx5IGNob3Nlbi4KIAogLS1yb290OjoKIAlUcmVhdCB0aGUgcmV2aXNpb24gYXJndW1lbnQgYXMgYSA8cmV2aXNpb24gcmFuZ2U+LCBldmVuIGlmIGl0CkBAIC0zMzAsOCArMzUzLDkgQEAKIC0tLS0tLS0tLS0tLS0KIFlvdSBjYW4gc3BlY2lmeSBleHRyYSBtYWlsIGhlYWRlciBsaW5lcyB0byBiZSBhZGRlZCB0byBlYWNoIG1lc3NhZ2UsCiBkZWZhdWx0cyBmb3IgdGhlIHN1YmplY3QgcHJlZml4IGFuZCBmaWxlIHN1ZmZpeCwgbnVtYmVyIHBhdGNoZXMgd2hlbgotb3V0cHV0dGluZyBtb3JlIHRoYW4gb25lIHBhdGNoLCBhZGQgIlRvIiBvciAiQ2M6IiBoZWFkZXJzLCBjb25maWd1cmUKLWF0dGFjaG1lbnRzLCBhbmQgc2lnbiBvZmYgcGF0Y2hlcyB3aXRoIGNvbmZpZ3VyYXRpb24gdmFyaWFibGVzLgorb3V0cHV0dGluZyBtb3JlIHRoYW4gb25lIHBhdGNoLCBhZGQgIlRvOiIgb3IgIkNjOiIgaGVhZGVycywgY29uZmlndXJlCithdHRhY2htZW50cywgY2hhbmdlIHRoZSBwYXRjaCBvdXRwdXQgZGlyZWN0b3J5LCBhbmQgc2lnbiBvZmYgcGF0Y2hlcword2l0aCBjb25maWd1cmF0aW9uIHZhcmlhYmxlcy4KIAogLS0tLS0tLS0tLS0tCiBbZm9ybWF0XQpAQCAtMzQzLDcgKzM2Nyw5IEBACiAJY2MgPSA8ZW1haWw+CiAJYXR0YWNoIFsgPSBtaW1lLWJvdW5kYXJ5LXN0cmluZyBdCiAJc2lnbk9mZiA9IHRydWUKLQljb3ZlcmxldHRlciA9IGF1dG8KKwlvdXRwdXREaXJlY3RvcnkgPSA8ZGlyZWN0b3J5PgorCWNvdmVyTGV0dGVyID0gYXV0bworCWNvdmVyRnJvbURlc2NyaXB0aW9uID0gYXV0bwogLS0tLS0tLS0tLS0tCiAKIApkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9naXQtZ2MudHh0IGIvRG9jdW1lbnRhdGlvbi9naXQtZ2MudHh0CmluZGV4IDI0N2Y3NjUuLjBjMTE0YWQgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vZ2l0LWdjLnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL2dpdC1nYy50eHQKQEAgLTExNSwxNSArMTE1LDE0IEBACiAtLS0tLQogCiAnZ2l0IGdjJyB0cmllcyB2ZXJ5IGhhcmQgbm90IHRvIGRlbGV0ZSBvYmplY3RzIHRoYXQgYXJlIHJlZmVyZW5jZWQKLWFueXdoZXJlIGluIHlvdXIgcmVwb3NpdG9yeS4gSW4KLXBhcnRpY3VsYXIsIGl0IHdpbGwga2VlcCBub3Qgb25seSBvYmplY3RzIHJlZmVyZW5jZWQgYnkgeW91ciBjdXJyZW50IHNldAotb2YgYnJhbmNoZXMgYW5kIHRhZ3MsIGJ1dCBhbHNvIG9iamVjdHMgcmVmZXJlbmNlZCBieSB0aGUgaW5kZXgsCi1yZW1vdGUtdHJhY2tpbmcgYnJhbmNoZXMsIHJlZnMgc2F2ZWQgYnkgJ2dpdCBmaWx0ZXItYnJhbmNoJyBpbgotcmVmcy9vcmlnaW5hbC8sIHJlZmxvZ3MgKHdoaWNoIG1heSByZWZlcmVuY2UgY29tbWl0cyBpbiBicmFuY2hlcwotdGhhdCB3ZXJlIGxhdGVyIGFtZW5kZWQgb3IgcmV3b3VuZCksIGFuZCBhbnl0aGluZyBlbHNlIGluIHRoZSByZWZzLyogbmFtZXNwYWNlLgotSWYgeW91IGFyZSBleHBlY3Rpbmcgc29tZSBvYmplY3RzIHRvIGJlIGRlbGV0ZWQgYW5kIHRoZXkgYXJlbid0LCBjaGVjawotYWxsIG9mIHRob3NlIGxvY2F0aW9ucyBhbmQgZGVjaWRlIHdoZXRoZXIgaXQgbWFrZXMgc2Vuc2UgaW4geW91ciBjYXNlIHRvCi1yZW1vdmUgdGhvc2UgcmVmZXJlbmNlcy4KK2FueXdoZXJlIGluIHlvdXIgcmVwb3NpdG9yeS4gSW4gcGFydGljdWxhciwgaXQgd2lsbCBrZWVwIG5vdCBvbmx5CitvYmplY3RzIHJlZmVyZW5jZWQgYnkgeW91ciBjdXJyZW50IHNldCBvZiBicmFuY2hlcyBhbmQgdGFncywgYnV0IGFsc28KK29iamVjdHMgcmVmZXJlbmNlZCBieSB0aGUgaW5kZXgsIHJlbW90ZS10cmFja2luZyBicmFuY2hlcywgbm90ZXMgc2F2ZWQKK2J5ICdnaXQgbm90ZXMnIHVuZGVyIHJlZnMvbm90ZXMvLCByZWZsb2dzICh3aGljaCBtYXkgcmVmZXJlbmNlIGNvbW1pdHMKK2luIGJyYW5jaGVzIHRoYXQgd2VyZSBsYXRlciBhbWVuZGVkIG9yIHJld291bmQpLCBhbmQgYW55dGhpbmcgZWxzZSBpbgordGhlIHJlZnMvKiBuYW1lc3BhY2UuICBJZiB5b3UgYXJlIGV4cGVjdGluZyBzb21lIG9iamVjdHMgdG8gYmUgZGVsZXRlZAorYW5kIHRoZXkgYXJlbid0LCBjaGVjayBhbGwgb2YgdGhvc2UgbG9jYXRpb25zIGFuZCBkZWNpZGUgd2hldGhlciBpdAorbWFrZXMgc2Vuc2UgaW4geW91ciBjYXNlIHRvIHJlbW92ZSB0aG9zZSByZWZlcmVuY2VzLgogCiBPbiB0aGUgb3RoZXIgaGFuZCwgd2hlbiAnZ2l0IGdjJyBydW5zIGNvbmN1cnJlbnRseSB3aXRoIGFub3RoZXIgcHJvY2VzcywKIHRoZXJlIGlzIGEgcmlzayBvZiBpdCBkZWxldGluZyBhbiBvYmplY3QgdGhhdCB0aGUgb3RoZXIgcHJvY2VzcyBpcyB1c2luZwpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9naXQtZ3JlcC50eHQgYi9Eb2N1bWVudGF0aW9uL2dpdC1ncmVwLnR4dAppbmRleCAyZDI3OTY5Li5jODlmYjU2IDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2dpdC1ncmVwLnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL2dpdC1ncmVwLnR4dApAQCAtMjcxLDYgKzI3MSwyMyBAQAogCiAtZiA8ZmlsZT46OgogCVJlYWQgcGF0dGVybnMgZnJvbSA8ZmlsZT4sIG9uZSBwZXIgbGluZS4KKysKK1Bhc3NpbmcgdGhlIHBhdHRlcm4gdmlhIDxmaWxlPiBhbGxvd3MgZm9yIHByb3ZpZGluZyBhIHNlYXJjaCBwYXR0ZXJuCitjb250YWluaW5nIGEgXDAuCisrCitOb3QgYWxsIHBhdHRlcm4gdHlwZXMgc3VwcG9ydCBwYXR0ZXJucyBjb250YWluaW5nIFwwLiBHaXQgd2lsbCBlcnJvcgorb3V0IGlmIGEgZ2l2ZW4gcGF0dGVybiB0eXBlIGNhbid0IHN1cHBvcnQgc3VjaCBhIHBhdHRlcm4uIFRoZQorYC0tcGVybC1yZWdleHBgIHBhdHRlcm4gdHlwZSB3aGVuIGNvbXBpbGVkIGFnYWluc3QgdGhlIFBDUkUgdjIgYmFja2VuZAoraGFzIHRoZSB3aWRlc3Qgc3VwcG9ydCBmb3IgdGhlc2UgdHlwZXMgb2YgcGF0dGVybnMuCisrCitJbiB2ZXJzaW9ucyBvZiBHaXQgYmVmb3JlIDIuMjMuMCBwYXR0ZXJucyBjb250YWluaW5nIFwwIHdvdWxkIGJlCitzaWxlbnRseSBjb25zaWRlcmVkIGZpeGVkLiBUaGlzIHdhcyBuZXZlciBkb2N1bWVudGVkLCB0aGVyZSB3ZXJlIGFsc28KK29kZCBhbmQgdW5kb2N1bWVudGVkIGludGVyYWN0aW9ucyBiZXR3ZWVuIGUuZy4gbm9uLUFTQ0lJIHBhdHRlcm5zCitjb250YWluaW5nIFwwIGFuZCBgLS1pZ25vcmUtY2FzZWAuCisrCitJbiBmdXR1cmUgdmVyc2lvbnMgd2UgbWF5IGxlYXJuIHRvIHN1cHBvcnQgcGF0dGVybnMgY29udGFpbmluZyBcMCBmb3IKK21vcmUgc2VhcmNoIGJhY2tlbmRzLCB1bnRpbCB0aGVuIHdlJ2xsIGRpZSB3aGVuIHRoZSBwYXR0ZXJuIHR5cGUgaW4KK3F1ZXN0aW9uIGRvZXNuJ3Qgc3VwcG9ydCB0aGVtLgogCiAtZTo6CiAJVGhlIG5leHQgcGFyYW1ldGVyIGlzIHRoZSBwYXR0ZXJuLiBUaGlzIG9wdGlvbiBoYXMgdG8gYmUKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vZ2l0LWd1aS50eHQgYi9Eb2N1bWVudGF0aW9uL2dpdC1ndWkudHh0CmluZGV4IDVmOTNmODAuLmM5ZDdlOTYgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vZ2l0LWd1aS50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9naXQtZ3VpLnR4dApAQCAtMTEyLDE1ICsxMTIsOSBAQAogdmVyc2lvbnMgYXJlIGRpc3RyaWJ1dGVkIGFzIHBhcnQgb2YgdGhlIEdpdCBzdWl0ZSBmb3IgdGhlIGNvbnZlbmllbmNlCiBvZiBlbmQgdXNlcnMuCiAKLUEgJ2dpdCBndWknIGRldmVsb3BtZW50IHJlcG9zaXRvcnkgY2FuIGJlIG9idGFpbmVkIGZyb206CitUaGUgb2ZmaWNpYWwgcmVwb3NpdG9yeSBvZiB0aGUgJ2dpdCBndWknIHByb2plY3QgY2FuIGJlIGZvdW5kIGF0OgogCi0gIGdpdCBjbG9uZSBnaXQ6Ly9yZXBvLm9yLmN6L2dpdC1ndWkuZ2l0Ci0KLW9yCi0KLSAgZ2l0IGNsb25lIGh0dHA6Ly9yZXBvLm9yLmN6L3IvZ2l0LWd1aS5naXQKLQotb3IgYnJvd3NlZCBvbmxpbmUgYXQgaHR0cDovL3JlcG8ub3IuY3ovdy9naXQtZ3VpLmdpdC9bXS4KKyAgaHR0cHM6Ly9naXRodWIuY29tL3ByYXRpMDEwMC9naXQtZ3VpLmdpdC8KIAogR0lUCiAtLS0KZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vZ2l0LWxzLXJlbW90ZS50eHQgYi9Eb2N1bWVudGF0aW9uL2dpdC1scy1yZW1vdGUudHh0CmluZGV4IDBiMDU3Y2IuLmEyZWExZmQgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vZ2l0LWxzLXJlbW90ZS50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9naXQtbHMtcmVtb3RlLnR4dApAQCAtOTIsMjEgKzkyLDIzIEBACiBFWEFNUExFUwogLS0tLS0tLS0KIAotCSQgZ2l0IGxzLXJlbW90ZSAtLXRhZ3MgLi8uCi0JZDY2MDJlYzUxOTRjODdiMGZjODcxMDNjYTRkNjcyNTFjNzZmMjMzYQlyZWZzL3RhZ3MvdjAuOTkKLQlmMjVhMjY1YTM0MmFlZDYwNDFhYjBjYzQ4NDIyNGQ5Y2E1NGI2ZjQxCXJlZnMvdGFncy92MC45OS4xCi0JN2NlY2EyNzVkMDQ3YzkwYzBjN2Q1YWZiMTNhYjk3ZWZkZjUxYmQ2ZQlyZWZzL3RhZ3MvdjAuOTkuMwotCWM1ZGI1NDU2YWUzYjA4NzNmYzY1OWMxOWZhZmRkZTIyMzEzY2M0NDEJcmVmcy90YWdzL3YwLjk5LjIKLQkwOTE4Mzg1ZGJkOTY1NmNhYjBkMWQ4MWJhNzQ1M2Q0OWJiYzE2MjUwCXJlZnMvdGFncy9qdW5pby1ncGctcHViCi0JJCBnaXQgbHMtcmVtb3RlIGh0dHA6Ly93d3cua2VybmVsLm9yZy9wdWIvc2NtL2dpdC9naXQuZ2l0IG1hc3RlciBwdSByYwotCTVmZTk3OGE1MzgxZjFmYmFkMjZhODBlNjgyZGRkMmE0MDE5NjY3NDAJcmVmcy9oZWFkcy9tYXN0ZXIKLQljNzgxYTg0YjUyMDRmYjI5NGM5Y2NjNzlmOGIzYmFjZWViMzJjMDYxCXJlZnMvaGVhZHMvcHUKLQkkIGdpdCByZW1vdGUgYWRkIGtvcmcgaHR0cDovL3d3dy5rZXJuZWwub3JnL3B1Yi9zY20vZ2l0L2dpdC5naXQKLQkkIGdpdCBscy1yZW1vdGUgLS10YWdzIGtvcmcgdlwqCi0JZDY2MDJlYzUxOTRjODdiMGZjODcxMDNjYTRkNjcyNTFjNzZmMjMzYQlyZWZzL3RhZ3MvdjAuOTkKLQlmMjVhMjY1YTM0MmFlZDYwNDFhYjBjYzQ4NDIyNGQ5Y2E1NGI2ZjQxCXJlZnMvdGFncy92MC45OS4xCi0JYzVkYjU0NTZhZTNiMDg3M2ZjNjU5YzE5ZmFmZGRlMjIzMTNjYzQ0MQlyZWZzL3RhZ3MvdjAuOTkuMgotCTdjZWNhMjc1ZDA0N2M5MGMwYzdkNWFmYjEzYWI5N2VmZGY1MWJkNmUJcmVmcy90YWdzL3YwLjk5LjMKKy0tLS0KKyQgZ2l0IGxzLXJlbW90ZSAtLXRhZ3MgLi8uCitkNjYwMmVjNTE5NGM4N2IwZmM4NzEwM2NhNGQ2NzI1MWM3NmYyMzNhCXJlZnMvdGFncy92MC45OQorZjI1YTI2NWEzNDJhZWQ2MDQxYWIwY2M0ODQyMjRkOWNhNTRiNmY0MQlyZWZzL3RhZ3MvdjAuOTkuMQorN2NlY2EyNzVkMDQ3YzkwYzBjN2Q1YWZiMTNhYjk3ZWZkZjUxYmQ2ZQlyZWZzL3RhZ3MvdjAuOTkuMworYzVkYjU0NTZhZTNiMDg3M2ZjNjU5YzE5ZmFmZGRlMjIzMTNjYzQ0MQlyZWZzL3RhZ3MvdjAuOTkuMgorMDkxODM4NWRiZDk2NTZjYWIwZDFkODFiYTc0NTNkNDliYmMxNjI1MAlyZWZzL3RhZ3MvanVuaW8tZ3BnLXB1YgorJCBnaXQgbHMtcmVtb3RlIGh0dHA6Ly93d3cua2VybmVsLm9yZy9wdWIvc2NtL2dpdC9naXQuZ2l0IG1hc3RlciBwdSByYworNWZlOTc4YTUzODFmMWZiYWQyNmE4MGU2ODJkZGQyYTQwMTk2Njc0MAlyZWZzL2hlYWRzL21hc3RlcgorYzc4MWE4NGI1MjA0ZmIyOTRjOWNjYzc5ZjhiM2JhY2VlYjMyYzA2MQlyZWZzL2hlYWRzL3B1CiskIGdpdCByZW1vdGUgYWRkIGtvcmcgaHR0cDovL3d3dy5rZXJuZWwub3JnL3B1Yi9zY20vZ2l0L2dpdC5naXQKKyQgZ2l0IGxzLXJlbW90ZSAtLXRhZ3Mga29yZyB2XCoKK2Q2NjAyZWM1MTk0Yzg3YjBmYzg3MTAzY2E0ZDY3MjUxYzc2ZjIzM2EJcmVmcy90YWdzL3YwLjk5CitmMjVhMjY1YTM0MmFlZDYwNDFhYjBjYzQ4NDIyNGQ5Y2E1NGI2ZjQxCXJlZnMvdGFncy92MC45OS4xCitjNWRiNTQ1NmFlM2IwODczZmM2NTljMTlmYWZkZGUyMjMxM2NjNDQxCXJlZnMvdGFncy92MC45OS4yCis3Y2VjYTI3NWQwNDdjOTBjMGM3ZDVhZmIxM2FiOTdlZmRmNTFiZDZlCXJlZnMvdGFncy92MC45OS4zCistLS0tCiAKIFNFRSBBTFNPCiAtLS0tLS0tLQpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9naXQtbWVyZ2UtYmFzZS50eHQgYi9Eb2N1bWVudGF0aW9uL2dpdC1tZXJnZS1iYXNlLnR4dAppbmRleCAyNjFkNWMxLi4yZDk0NGUwIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2dpdC1tZXJnZS1iYXNlLnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL2dpdC1tZXJnZS1iYXNlLnR4dApAQCAtODAsOSArODAsMTEgQEAKIAogRm9yIGV4YW1wbGUsIHdpdGggdGhpcyB0b3BvbG9neToKIAotCSAgICAgICAgIG8tLS1vLS0tby0tLUIKLQkgICAgICAgIC8KLQktLS1vLS0tMS0tLW8tLS1vLS0tby0tLUEKKy4uLi4KKwkgby0tLW8tLS1vLS0tQgorCS8KKy0tLW8tLS0xLS0tby0tLW8tLS1vLS0tQQorLi4uLgogCiB0aGUgbWVyZ2UgYmFzZSBiZXR3ZWVuICdBJyBhbmQgJ0InIGlzICcxJy4KIApAQCAtOTAsMjEgKzkyLDI1IEBACiBtZXJnZSBiYXNlIGJldHdlZW4gJ0EnIGFuZCBhIGh5cG90aGV0aWNhbCBjb21taXQgJ00nLCB3aGljaCBpcyBhIG1lcmdlCiBiZXR3ZWVuICdCJyBhbmQgJ0MnLiAgRm9yIGV4YW1wbGUsIHdpdGggdGhpcyB0b3BvbG9neToKIAotCSAgICAgICBvLS0tby0tLW8tLS1vLS0tQwotCSAgICAgIC8KLQkgICAgIC8gICBvLS0tby0tLW8tLS1CCi0JICAgIC8gICAvCi0JLS0tMi0tLTEtLS1vLS0tby0tLW8tLS1BCisuLi4uCisgICAgICAgby0tLW8tLS1vLS0tby0tLUMKKyAgICAgIC8KKyAgICAgLyAgIG8tLS1vLS0tby0tLUIKKyAgICAvICAgLworLS0tMi0tLTEtLS1vLS0tby0tLW8tLS1BCisuLi4uCiAKIHRoZSByZXN1bHQgb2YgYGdpdCBtZXJnZS1iYXNlIEEgQiBDYCBpcyAnMScuICBUaGlzIGlzIGJlY2F1c2UgdGhlCiBlcXVpdmFsZW50IHRvcG9sb2d5IHdpdGggYSBtZXJnZSBjb21taXQgJ00nIGJldHdlZW4gJ0InIGFuZCAnQycgaXM6CiAKIAotCSAgICAgICBvLS0tby0tLW8tLS1vLS0tbwotCSAgICAgIC8gICAgICAgICAgICAgICAgIFwKLQkgICAgIC8gICBvLS0tby0tLW8tLS1vLS0tTQotCSAgICAvICAgLwotCS0tLTItLS0xLS0tby0tLW8tLS1vLS0tQQorLi4uLgorICAgICAgIG8tLS1vLS0tby0tLW8tLS1vCisgICAgICAvICAgICAgICAgICAgICAgICBcCisgICAgIC8gICBvLS0tby0tLW8tLS1vLS0tTQorICAgIC8gICAvCistLS0yLS0tMS0tLW8tLS1vLS0tby0tLUEKKy4uLi4KIAogYW5kIHRoZSByZXN1bHQgb2YgYGdpdCBtZXJnZS1iYXNlIEEgTWAgaXMgJzEnLiAgQ29tbWl0ICcyJyBpcyBhbHNvIGEKIGNvbW1vbiBhbmNlc3RvciBiZXR3ZWVuICdBJyBhbmQgJ00nLCBidXQgJzEnIGlzIGEgYmV0dGVyIGNvbW1vbiBhbmNlc3RvciwKQEAgLTExNiwxMSArMTIyLDEzIEBACiBXaGVuIHRoZSBoaXN0b3J5IGludm9sdmVzIGNyaXNzLWNyb3NzIG1lcmdlcywgdGhlcmUgY2FuIGJlIG1vcmUgdGhhbiBvbmUKICdiZXN0JyBjb21tb24gYW5jZXN0b3IgZm9yIHR3byBjb21taXRzLiAgRm9yIGV4YW1wbGUsIHdpdGggdGhpcyB0b3BvbG9neToKIAotCS0tLTEtLS1vLS0tQQotCSAgICBcIC8KLQkgICAgIFgKLQkgICAgLyBcCi0JLS0tMi0tLW8tLS1vLS0tQgorLi4uLgorLS0tMS0tLW8tLS1BCisgICAgXCAvCisgICAgIFgKKyAgICAvIFwKKy0tLTItLS1vLS0tby0tLUIKKy4uLi4KIAogYm90aCAnMScgYW5kICcyJyBhcmUgbWVyZ2UtYmFzZXMgb2YgQSBhbmQgQi4gIE5laXRoZXIgb25lIGlzIGJldHRlciB0aGFuCiB0aGUgb3RoZXIgKGJvdGggYXJlICdiZXN0JyBtZXJnZSBiYXNlcykuICBXaGVuIHRoZSBgLS1hbGxgIG9wdGlvbiBpcyBub3QgZ2l2ZW4sCkBAIC0xMzEsMTggKzEzOSwyMiBAQAogQSBhbmQgQiwgYW5kIGNoZWNrIGlmIGl0IGlzIHRoZSBzYW1lIGFzIEEsIGluIHdoaWNoIGNhc2UsIEEgaXMgYW4KIGFuY2VzdG9yIG9mIEIuICBZb3Ugd2lsbCBzZWUgdGhpcyBpZGlvbSB1c2VkIG9mdGVuIGluIG9sZGVyIHNjcmlwdHMuCiAKLQlBPSQoZ2l0IHJldi1wYXJzZSAtLXZlcmlmeSBBKQotCWlmIHRlc3QgIiRBIiA9ICIkKGdpdCBtZXJnZS1iYXNlIEEgQikiCi0JdGhlbgotCQkuLi4gQSBpcyBhbiBhbmNlc3RvciBvZiBCIC4uLgotCWZpCisuLi4uCitBPSQoZ2l0IHJldi1wYXJzZSAtLXZlcmlmeSBBKQoraWYgdGVzdCAiJEEiID0gIiQoZ2l0IG1lcmdlLWJhc2UgQSBCKSIKK3RoZW4KKwkuLi4gQSBpcyBhbiBhbmNlc3RvciBvZiBCIC4uLgorZmkKKy4uLi4KIAogSW4gbW9kZXJuIGdpdCwgeW91IGNhbiBzYXkgdGhpcyBpbiBhIG1vcmUgZGlyZWN0IHdheToKIAotCWlmIGdpdCBtZXJnZS1iYXNlIC0taXMtYW5jZXN0b3IgQSBCCi0JdGhlbgotCQkuLi4gQSBpcyBhbiBhbmNlc3RvciBvZiBCIC4uLgotCWZpCisuLi4uCitpZiBnaXQgbWVyZ2UtYmFzZSAtLWlzLWFuY2VzdG9yIEEgQgordGhlbgorCS4uLiBBIGlzIGFuIGFuY2VzdG9yIG9mIEIgLi4uCitmaQorLi4uLgogCiBpbnN0ZWFkLgogCkBAIC0xNTQsMTMgKzE2NiwxNSBAQAogYG9yaWdpbi9tYXN0ZXJgIG1heSBoYXZlIGJlZW4gcmV3b3VuZCBhbmQgcmVidWlsdCwgbGVhZGluZyB0byBhCiBoaXN0b3J5IG9mIHRoaXMgc2hhcGU6CiAKLQkgICAgICAgICAgICAgICAgIG8tLS1CMgotCSAgICAgICAgICAgICAgICAvCi0JLS0tby0tLW8tLS1CMS0tby0tLW8tLS1vLS0tQiAob3JpZ2luL21hc3RlcikKLQkgICAgICAgIFwKLQkgICAgICAgICBCMAotCSAgICAgICAgICBcCi0JICAgICAgICAgICBEMC0tLUQxLS0tRCAodG9waWMpCisuLi4uCisJCSBvLS0tQjIKKwkJLworLS0tby0tLW8tLS1CMS0tby0tLW8tLS1vLS0tQiAob3JpZ2luL21hc3RlcikKKwlcCisJIEIwCisJICBcCisJICAgRDAtLS1EMS0tLUQgKHRvcGljKQorLi4uLgogCiB3aGVyZSBgb3JpZ2luL21hc3RlcmAgdXNlZCB0byBwb2ludCBhdCBjb21taXRzIEIwLCBCMSwgQjIgYW5kIG5vdyBpdAogcG9pbnRzIGF0IEIsIGFuZCB5b3VyIGB0b3BpY2AgYnJhbmNoIHdhcyBzdGFydGVkIG9uIHRvcCBvZiBpdCBiYWNrCkBAIC0xOTMsMTMgKzIwNywxNSBAQAogd2lsbCByZXBsYXkgRDAsIEQxIGFuZCBEIG9uIHRvcCBvZiBCIHRvIGNyZWF0ZSBhIG5ldyBoaXN0b3J5IG9mIHRoaXMKIHNoYXBlOgogCi0JCQkgby0tLUIyCi0JCQkvCi0JLS0tby0tLW8tLS1CMS0tby0tLW8tLS1vLS0tQiAob3JpZ2luL21hc3RlcikKLQkJXCAgICAgICAgICAgICAgICAgICBcCi0JCSBCMCAgICAgICAgICAgICAgICAgIEQwJy0tRDEnLS1EJyAodG9waWMgLSB1cGRhdGVkKQotCQkgIFwKLQkJICAgRDAtLS1EMS0tLUQgKHRvcGljIC0gb2xkKQorLi4uLgorCQkgby0tLUIyCisJCS8KKy0tLW8tLS1vLS0tQjEtLW8tLS1vLS0tby0tLUIgKG9yaWdpbi9tYXN0ZXIpCisJXCAgICAgICAgICAgICAgICAgICBcCisJIEIwICAgICAgICAgICAgICAgICAgRDAnLS1EMSctLUQnICh0b3BpYyAtIHVwZGF0ZWQpCisJICBcCisJICAgRDAtLS1EMS0tLUQgKHRvcGljIC0gb2xkKQorLi4uLgogCiBBIGNhdmVhdCBpcyB0aGF0IG9sZGVyIHJlZmxvZyBlbnRyaWVzIGluIHlvdXIgcmVwb3NpdG9yeSBtYXkgYmUKIGV4cGlyZWQgYnkgYGdpdCBnY2AuICBJZiBCMCBubyBsb25nZXIgYXBwZWFycyBpbiB0aGUgcmVmbG9nIG9mIHRoZQpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9naXQtbWVyZ2UtaW5kZXgudHh0IGIvRG9jdW1lbnRhdGlvbi9naXQtbWVyZ2UtaW5kZXgudHh0CmluZGV4IDAyNjc2ZmIuLjJhYjg0YTkgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vZ2l0LW1lcmdlLWluZGV4LnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL2dpdC1tZXJnZS1pbmRleC50eHQKQEAgLTU0LDIwICs1NCwyNCBAQAogCiBFeGFtcGxlczoKIAotICB0b3J2YWxkc0BwcGM5NzA6fi9tZXJnZS10ZXN0PiBnaXQgbWVyZ2UtaW5kZXggY2F0IE1NCi0gIFRoaXMgaXMgTU0gZnJvbSB0aGUgb3JpZ2luYWwgdHJlZS4JCQkjIG9yaWdpbmFsCi0gIFRoaXMgaXMgbW9kaWZpZWQgTU0gaW4gdGhlIGJyYW5jaCBBLgkJCSMgbWVyZ2UxCi0gIFRoaXMgaXMgbW9kaWZpZWQgTU0gaW4gdGhlIGJyYW5jaCBCLgkJCSMgbWVyZ2UyCi0gIFRoaXMgaXMgbW9kaWZpZWQgTU0gaW4gdGhlIGJyYW5jaCBCLgkJCSMgY3VycmVudCBjb250ZW50cworLS0tLQordG9ydmFsZHNAcHBjOTcwOn4vbWVyZ2UtdGVzdD4gZ2l0IG1lcmdlLWluZGV4IGNhdCBNTQorVGhpcyBpcyBNTSBmcm9tIHRoZSBvcmlnaW5hbCB0cmVlLgkJIyBvcmlnaW5hbAorVGhpcyBpcyBtb2RpZmllZCBNTSBpbiB0aGUgYnJhbmNoIEEuCQkjIG1lcmdlMQorVGhpcyBpcyBtb2RpZmllZCBNTSBpbiB0aGUgYnJhbmNoIEIuCQkjIG1lcmdlMgorVGhpcyBpcyBtb2RpZmllZCBNTSBpbiB0aGUgYnJhbmNoIEIuCQkjIGN1cnJlbnQgY29udGVudHMKKy0tLS0KIAogb3IKIAotICB0b3J2YWxkc0BwcGM5NzA6fi9tZXJnZS10ZXN0PiBnaXQgbWVyZ2UtaW5kZXggY2F0IEFBIE1NCi0gIGNhdDogOiBObyBzdWNoIGZpbGUgb3IgZGlyZWN0b3J5Ci0gIFRoaXMgaXMgYWRkZWQgQUEgaW4gdGhlIGJyYW5jaCBBLgotICBUaGlzIGlzIGFkZGVkIEFBIGluIHRoZSBicmFuY2ggQi4KLSAgVGhpcyBpcyBhZGRlZCBBQSBpbiB0aGUgYnJhbmNoIEIuCi0gIGZhdGFsOiBtZXJnZSBwcm9ncmFtIGZhaWxlZAorLS0tLQordG9ydmFsZHNAcHBjOTcwOn4vbWVyZ2UtdGVzdD4gZ2l0IG1lcmdlLWluZGV4IGNhdCBBQSBNTQorY2F0OiA6IE5vIHN1Y2ggZmlsZSBvciBkaXJlY3RvcnkKK1RoaXMgaXMgYWRkZWQgQUEgaW4gdGhlIGJyYW5jaCBBLgorVGhpcyBpcyBhZGRlZCBBQSBpbiB0aGUgYnJhbmNoIEIuCitUaGlzIGlzIGFkZGVkIEFBIGluIHRoZSBicmFuY2ggQi4KK2ZhdGFsOiBtZXJnZSBwcm9ncmFtIGZhaWxlZAorLS0tLQogCiB3aGVyZSB0aGUgbGF0dGVyIGV4YW1wbGUgc2hvd3MgaG93ICdnaXQgbWVyZ2UtaW5kZXgnIHdpbGwgc3RvcCB0cnlpbmcgdG8KIG1lcmdlIG9uY2UgYW55dGhpbmcgaGFzIHJldHVybmVkIGFuIGVycm9yIChpLmUuLCBgY2F0YCByZXR1cm5lZCBhbiBlcnJvcgpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9naXQtbWVyZ2UudHh0IGIvRG9jdW1lbnRhdGlvbi9naXQtbWVyZ2UudHh0CmluZGV4IDAxZmQ1MmQuLjA5MjUyOWMgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vZ2l0LW1lcmdlLnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL2dpdC1tZXJnZS50eHQKQEAgLTEwLDcgKzEwLDcgQEAKIC0tLS0tLS0tCiBbdmVyc2VdCiAnZ2l0IG1lcmdlJyBbLW5dIFstLXN0YXRdIFstLW5vLWNvbW1pdF0gWy0tc3F1YXNoXSBbLS1bbm8tXWVkaXRdCi0JWy1zIDxzdHJhdGVneT5dIFstWCA8c3RyYXRlZ3ktb3B0aW9uPl0gWy1TWzxrZXlpZD5dXQorCVstLW5vLXZlcmlmeV0gWy1zIDxzdHJhdGVneT5dIFstWCA8c3RyYXRlZ3ktb3B0aW9uPl0gWy1TWzxrZXlpZD5dXQogCVstLVtuby1dYWxsb3ctdW5yZWxhdGVkLWhpc3Rvcmllc10KIAlbLS1bbm8tXXJlcmVyZS1hdXRvdXBkYXRlXSBbLW0gPG1zZz5dIFstRiA8ZmlsZT5dIFs8Y29tbWl0Pi4uLl0KICdnaXQgbWVyZ2UnICgtLWNvbnRpbnVlIHwgLS1hYm9ydCB8IC0tcXVpdCkKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vZ2l0LW11bHRpLXBhY2staW5kZXgudHh0IGIvRG9jdW1lbnRhdGlvbi9naXQtbXVsdGktcGFjay1pbmRleC50eHQKaW5kZXggMjMzYjJiNy4uNjQyZDlhYyAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9naXQtbXVsdGktcGFjay1pbmRleC50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9naXQtbXVsdGktcGFjay1pbmRleC50eHQKQEAgLTksNyArOSw3IEBACiBTWU5PUFNJUwogLS0tLS0tLS0KIFt2ZXJzZV0KLSdnaXQgbXVsdGktcGFjay1pbmRleCcgWy0tb2JqZWN0LWRpcj08ZGlyPl0gPHN1YmNvbW1hbmQ+CisnZ2l0IG11bHRpLXBhY2staW5kZXgnIFstLW9iamVjdC1kaXI9PGRpcj5dIFstLVtuby1dcHJvZ3Jlc3NdIDxzdWJjb21tYW5kPgogCiBERVNDUklQVElPTgogLS0tLS0tLS0tLS0KQEAgLTIzLDYgKzIzLDEwIEBACiAJYDxkaXI+L3BhY2tzL211bHRpLXBhY2staW5kZXhgIGZvciB0aGUgY3VycmVudCBNSURYIGZpbGUsIGFuZAogCWA8ZGlyPi9wYWNrc2AgZm9yIHRoZSBwYWNrLWZpbGVzIHRvIGluZGV4LgogCistLVtuby1dcHJvZ3Jlc3M6OgorCVR1cm4gcHJvZ3Jlc3Mgb24vb2ZmIGV4cGxpY2l0bHkuIElmIG5laXRoZXIgaXMgc3BlY2lmaWVkLCBwcm9ncmVzcyBpcworCXNob3duIGlmIHN0YW5kYXJkIGVycm9yIGlzIGNvbm5lY3RlZCB0byBhIHRlcm1pbmFsLgorCiBUaGUgZm9sbG93aW5nIHN1YmNvbW1hbmRzIGFyZSBhdmFpbGFibGU6CiAKIHdyaXRlOjoKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vZ2l0LW5vdGVzLnR4dCBiL0RvY3VtZW50YXRpb24vZ2l0LW5vdGVzLnR4dAppbmRleCBmNTZhNWE5Li5jZWQyZTgyIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2dpdC1ub3Rlcy50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9naXQtbm90ZXMudHh0CkBAIC0xMCw3ICsxMCw3IEBACiBbdmVyc2VdCiAnZ2l0IG5vdGVzJyBbbGlzdCBbPG9iamVjdD5dXQogJ2dpdCBub3RlcycgYWRkIFstZl0gWy0tYWxsb3ctZW1wdHldIFstRiA8ZmlsZT4gfCAtbSA8bXNnPiB8ICgtYyB8IC1DKSA8b2JqZWN0Pl0gWzxvYmplY3Q+XQotJ2dpdCBub3RlcycgY29weSBbLWZdICggLS1zdGRpbiB8IDxmcm9tLW9iamVjdD4gPHRvLW9iamVjdD4gKQorJ2dpdCBub3RlcycgY29weSBbLWZdICggLS1zdGRpbiB8IDxmcm9tLW9iamVjdD4gWzx0by1vYmplY3Q+XSApCiAnZ2l0IG5vdGVzJyBhcHBlbmQgWy0tYWxsb3ctZW1wdHldIFstRiA8ZmlsZT4gfCAtbSA8bXNnPiB8ICgtYyB8IC1DKSA8b2JqZWN0Pl0gWzxvYmplY3Q+XQogJ2dpdCBub3RlcycgZWRpdCBbLS1hbGxvdy1lbXB0eV0gWzxvYmplY3Q+XQogJ2dpdCBub3Rlcycgc2hvdyBbPG9iamVjdD5dCkBAIC02OCw4ICs2OCw4IEBACiAJc3ViY29tbWFuZCkuCiAKIGNvcHk6OgotCUNvcHkgdGhlIG5vdGVzIGZvciB0aGUgZmlyc3Qgb2JqZWN0IG9udG8gdGhlIHNlY29uZCBvYmplY3QuCi0JQWJvcnQgaWYgdGhlIHNlY29uZCBvYmplY3QgYWxyZWFkeSBoYXMgbm90ZXMsIG9yIGlmIHRoZSBmaXJzdAorCUNvcHkgdGhlIG5vdGVzIGZvciB0aGUgZmlyc3Qgb2JqZWN0IG9udG8gdGhlIHNlY29uZCBvYmplY3QgKGRlZmF1bHRzIHRvCisJSEVBRCkuIEFib3J0IGlmIHRoZSBzZWNvbmQgb2JqZWN0IGFscmVhZHkgaGFzIG5vdGVzLCBvciBpZiB0aGUgZmlyc3QKIAlvYmplY3QgaGFzIG5vbmUgKHVzZSAtZiB0byBvdmVyd3JpdGUgZXhpc3Rpbmcgbm90ZXMgdG8gdGhlCiAJc2Vjb25kIG9iamVjdCkuIFRoaXMgc3ViY29tbWFuZCBpcyBlcXVpdmFsZW50IHRvOgogCWBnaXQgbm90ZXMgYWRkIFstZl0gLUMgJChnaXQgbm90ZXMgbGlzdCA8ZnJvbS1vYmplY3Q+KSA8dG8tb2JqZWN0PmAKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vZ2l0LXJhbmdlLWRpZmYudHh0IGIvRG9jdW1lbnRhdGlvbi9naXQtcmFuZ2UtZGlmZi50eHQKaW5kZXggOGE2ZWEyYy4uOTcwMWMxZSAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9naXQtcmFuZ2UtZGlmZi50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9naXQtcmFuZ2UtZGlmZi50eHQKQEAgLTU3LDYgKzU3LDEwIEBACiAJU2VlIHRoZSBgYEFsZ29yaXRobWBgIHNlY3Rpb24gYmVsb3cgZm9yIGFuIGV4cGxhbmF0aW9uIHdoeSB0aGlzIGlzCiAJbmVlZGVkLgogCistLVtuby1dbm90ZXNbPTxyZWY+XTo6CisJVGhpcyBmbGFnIGlzIHBhc3NlZCB0byB0aGUgYGdpdCBsb2dgIHByb2dyYW0KKwkoc2VlIGxpbmtnaXQ6Z2l0LWxvZ1sxXSkgdGhhdCBnZW5lcmF0ZXMgdGhlIHBhdGNoZXMuCisKIDxyYW5nZTE+IDxyYW5nZTI+OjoKIAlDb21wYXJlIHRoZSBjb21taXRzIHNwZWNpZmllZCBieSB0aGUgdHdvIHJhbmdlcywgd2hlcmUKIAlgPHJhbmdlMT5gIGlzIGNvbnNpZGVyZWQgYW4gb2xkZXIgdmVyc2lvbiBvZiBgPHJhbmdlMj5gLgpAQCAtNzUsNyArNzksNyBAQAogbGlua2dpdDpnaXQtZGlmZlsxXSksIG1vc3Qgbm90YWJseSB0aGUgYC0tY29sb3I9Wzx3aGVuPl1gIGFuZAogYC0tbm8tY29sb3JgIG9wdGlvbnMuIFRoZXNlIG9wdGlvbnMgYXJlIHVzZWQgd2hlbiBnZW5lcmF0aW5nIHRoZSAiZGlmZgogYmV0d2VlbiBwYXRjaGVzIiwgaS5lLiB0byBjb21wYXJlIHRoZSBhdXRob3IsIGNvbW1pdCBtZXNzYWdlIGFuZCBkaWZmIG9mCi1jb3JyZXNwb25kaW5nIG9sZC9uZXcgY29tbWl0cy4gVGhlcmUgaXMgY3VycmVudGx5IG5vIG1lYW5zIHRvIHR3ZWFrIHRoZQorY29ycmVzcG9uZGluZyBvbGQvbmV3IGNvbW1pdHMuIFRoZXJlIGlzIGN1cnJlbnRseSBubyBtZWFucyB0byB0d2VhayBtb3N0IG9mIHRoZQogZGlmZiBvcHRpb25zIHBhc3NlZCB0byBgZ2l0IGxvZ2Agd2hlbiBnZW5lcmF0aW5nIHRob3NlIHBhdGNoZXMuCiAKIE9VVFBVVCBTVEFCSUxJVFkKQEAgLTI0Miw3ICsyNDYsNyBAQAogCiBUaGUgb3ZlcmFsbCB0aW1lIG5lZWRlZCB0byBjb21wdXRlIHRoaXMgYWxnb3JpdGhtIGlzIHRoZSB0aW1lIG5lZWRlZCB0bwogY29tcHV0ZSBuK20gY29tbWl0IGRpZmZzIGFuZCB0aGVuIG4qbSBkaWZmcyBvZiBwYXRjaGVzLCBwbHVzIHRoZSB0aW1lCi1uZWVkZWQgdG8gY29tcHV0ZSB0aGUgbGVhc3QtY29zdCBhc3NpZ21lbnQgYmV0d2VlbiBuIGFuZCBtIGRpZmZzLiBHaXQKK25lZWRlZCB0byBjb21wdXRlIHRoZSBsZWFzdC1jb3N0IGFzc2lnbm1lbnQgYmV0d2VlbiBuIGFuZCBtIGRpZmZzLiBHaXQKIHVzZXMgYW4gaW1wbGVtZW50YXRpb24gb2YgdGhlIEpvbmtlci1Wb2xnZW5hbnQgYWxnb3JpdGhtIHRvIHNvbHZlIHRoZQogYXNzaWdubWVudCBwcm9ibGVtLCB3aGljaCBoYXMgY3ViaWMgcnVudGltZSBjb21wbGV4aXR5LiBUaGUgbWF0Y2hpbmcKIGZvdW5kIGluIHRoaXMgY2FzZSB3aWxsIGxvb2sgbGlrZSB0aGlzOgpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9naXQtcmViYXNlLnR4dCBiL0RvY3VtZW50YXRpb24vZ2l0LXJlYmFzZS50eHQKaW5kZXggNjE1NjYwOS4uMGM0ZjAzOCAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9naXQtcmViYXNlLnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL2dpdC1yZWJhc2UudHh0CkBAIC04LDggKzgsOCBAQAogU1lOT1BTSVMKIC0tLS0tLS0tCiBbdmVyc2VdCi0nZ2l0IHJlYmFzZScgWy1pIHwgLS1pbnRlcmFjdGl2ZV0gWzxvcHRpb25zPl0gWy0tZXhlYyA8Y21kPl0gWy0tb250byA8bmV3YmFzZT5dCi0JWzx1cHN0cmVhbT4gWzxicmFuY2g+XV0KKydnaXQgcmViYXNlJyBbLWkgfCAtLWludGVyYWN0aXZlXSBbPG9wdGlvbnM+XSBbLS1leGVjIDxjbWQ+XQorCVstLW9udG8gPG5ld2Jhc2U+IHwgLS1rZWVwLWJhc2VdIFs8dXBzdHJlYW0+IFs8YnJhbmNoPl1dCiAnZ2l0IHJlYmFzZScgWy1pIHwgLS1pbnRlcmFjdGl2ZV0gWzxvcHRpb25zPl0gWy0tZXhlYyA8Y21kPl0gWy0tb250byA8bmV3YmFzZT5dCiAJLS1yb290IFs8YnJhbmNoPl0KICdnaXQgcmViYXNlJyAoLS1jb250aW51ZSB8IC0tc2tpcCB8IC0tYWJvcnQgfCAtLXF1aXQgfCAtLWVkaXQtdG9kbyB8IC0tc2hvdy1jdXJyZW50LXBhdGNoKQpAQCAtMjE3LDYgKzIxNywyNCBAQAogbWVyZ2UgYmFzZSBvZiBBIGFuZCBCIGlmIHRoZXJlIGlzIGV4YWN0bHkgb25lIG1lcmdlIGJhc2UuIFlvdSBjYW4KIGxlYXZlIG91dCBhdCBtb3N0IG9uZSBvZiBBIGFuZCBCLCBpbiB3aGljaCBjYXNlIGl0IGRlZmF1bHRzIHRvIEhFQUQuCiAKKy0ta2VlcC1iYXNlOjoKKwlTZXQgdGhlIHN0YXJ0aW5nIHBvaW50IGF0IHdoaWNoIHRvIGNyZWF0ZSB0aGUgbmV3IGNvbW1pdHMgdG8gdGhlCisJbWVyZ2UgYmFzZSBvZiA8dXBzdHJlYW0+IDxicmFuY2g+LiBSdW5uaW5nCisJJ2dpdCByZWJhc2UgLS1rZWVwLWJhc2UgPHVwc3RyZWFtPiA8YnJhbmNoPicgaXMgZXF1aXZhbGVudCB0bworCXJ1bm5pbmcgJ2dpdCByZWJhc2UgLS1vbnRvIDx1cHN0cmVhbT4uLi4gPHVwc3RyZWFtPicuCisrCitUaGlzIG9wdGlvbiBpcyB1c2VmdWwgaW4gdGhlIGNhc2Ugd2hlcmUgb25lIGlzIGRldmVsb3BpbmcgYSBmZWF0dXJlIG9uCit0b3Agb2YgYW4gdXBzdHJlYW0gYnJhbmNoLiBXaGlsZSB0aGUgZmVhdHVyZSBpcyBiZWluZyB3b3JrZWQgb24sIHRoZQordXBzdHJlYW0gYnJhbmNoIG1heSBhZHZhbmNlIGFuZCBpdCBtYXkgbm90IGJlIHRoZSBiZXN0IGlkZWEgdG8ga2VlcAorcmViYXNpbmcgb24gdG9wIG9mIHRoZSB1cHN0cmVhbSBidXQgdG8ga2VlcCB0aGUgYmFzZSBjb21taXQgYXMtaXMuCisrCitBbHRob3VnaCBib3RoIHRoaXMgb3B0aW9uIGFuZCAtLWZvcmstcG9pbnQgZmluZCB0aGUgbWVyZ2UgYmFzZSBiZXR3ZWVuCis8dXBzdHJlYW0+IGFuZCA8YnJhbmNoPiwgdGhpcyBvcHRpb24gdXNlcyB0aGUgbWVyZ2UgYmFzZSBhcyB0aGUgX3N0YXJ0aW5nCitwb2ludF8gb24gd2hpY2ggbmV3IGNvbW1pdHMgd2lsbCBiZSBjcmVhdGVkLCB3aGVyZWFzIC0tZm9yay1wb2ludCB1c2VzCit0aGUgbWVyZ2UgYmFzZSB0byBkZXRlcm1pbmUgdGhlIF9zZXQgb2YgY29tbWl0c18gd2hpY2ggd2lsbCBiZSByZWJhc2VkLgorKworU2VlIGFsc28gSU5DT01QQVRJQkxFIE9QVElPTlMgYmVsb3cuCisKIDx1cHN0cmVhbT46OgogCVVwc3RyZWFtIGJyYW5jaCB0byBjb21wYXJlIGFnYWluc3QuICBNYXkgYmUgYW55IHZhbGlkIGNvbW1pdCwKIAlub3QganVzdCBhbiBleGlzdGluZyBicmFuY2ggbmFtZS4gRGVmYXVsdHMgdG8gdGhlIGNvbmZpZ3VyZWQKQEAgLTM2OSw2ICszODcsMTAgQEAKICsKIElmIGVpdGhlciA8dXBzdHJlYW0+IG9yIC0tcm9vdCBpcyBnaXZlbiBvbiB0aGUgY29tbWFuZCBsaW5lLCB0aGVuIHRoZQogZGVmYXVsdCBpcyBgLS1uby1mb3JrLXBvaW50YCwgb3RoZXJ3aXNlIHRoZSBkZWZhdWx0IGlzIGAtLWZvcmstcG9pbnRgLgorKworSWYgeW91ciBicmFuY2ggd2FzIGJhc2VkIG9uIDx1cHN0cmVhbT4gYnV0IDx1cHN0cmVhbT4gd2FzIHJld291bmQgYW5kCit5b3VyIGJyYW5jaCBjb250YWlucyBjb21taXRzIHdoaWNoIHdlcmUgZHJvcHBlZCwgdGhpcyBvcHRpb24gY2FuIGJlIHVzZWQKK3dpdGggYC0ta2VlcC1iYXNlYCBpbiBvcmRlciB0byBkcm9wIHRob3NlIGNvbW1pdHMgZnJvbSB5b3VyIGJyYW5jaC4KIAogLS1pZ25vcmUtd2hpdGVzcGFjZTo6CiAtLXdoaXRlc3BhY2U9PG9wdGlvbj46OgpAQCAtNDIxLDggKzQ0Myw4IEBACiBvbnRvIGA8dXBzdHJlYW0+YCAob3IgYDxvbnRvPmAsIGlmIHNwZWNpZmllZCkuCiArCiBUaGUgYC0tcmViYXNlLW1lcmdlc2AgbW9kZSBpcyBzaW1pbGFyIGluIHNwaXJpdCB0byB0aGUgZGVwcmVjYXRlZAotYC0tcHJlc2VydmUtbWVyZ2VzYCwgYnV0IGluIGNvbnRyYXN0IHRvIHRoYXQgb3B0aW9uIHdvcmtzIHdlbGwgaW4gaW50ZXJhY3RpdmUKLXJlYmFzZXM6IGNvbW1pdHMgY2FuIGJlIHJlb3JkZXJlZCwgaW5zZXJ0ZWQgYW5kIGRyb3BwZWQgYXQgd2lsbC4KK2AtLXByZXNlcnZlLW1lcmdlc2AgYnV0IHdvcmtzIHdpdGggaW50ZXJhY3RpdmUgcmViYXNlcywKK3doZXJlIGNvbW1pdHMgY2FuIGJlIHJlb3JkZXJlZCwgaW5zZXJ0ZWQgYW5kIGRyb3BwZWQgYXQgd2lsbC4KICsKIEl0IGlzIGN1cnJlbnRseSBvbmx5IHBvc3NpYmxlIHRvIHJlY3JlYXRlIHRoZSBtZXJnZSBjb21taXRzIHVzaW5nIHRoZQogYHJlY3Vyc2l2ZWAgbWVyZ2Ugc3RyYXRlZ3k7IERpZmZlcmVudCBtZXJnZSBzdHJhdGVnaWVzIGNhbiBiZSB1c2VkIG9ubHkgdmlhCkBAIC01NDMsOCArNTY1LDggQEAKICAqIC0tcHJlc2VydmUtbWVyZ2VzIGFuZCAtLWludGVyYWN0aXZlCiAgKiAtLXByZXNlcnZlLW1lcmdlcyBhbmQgLS1zaWdub2ZmCiAgKiAtLXByZXNlcnZlLW1lcmdlcyBhbmQgLS1yZWJhc2UtbWVyZ2VzCi0gKiAtLXJlYmFzZS1tZXJnZXMgYW5kIC0tc3RyYXRlZ3kKLSAqIC0tcmViYXNlLW1lcmdlcyBhbmQgLS1zdHJhdGVneS1vcHRpb24KKyAqIC0ta2VlcC1iYXNlIGFuZCAtLW9udG8KKyAqIC0ta2VlcC1iYXNlIGFuZCAtLXJvb3QKIAogQkVIQVZJT1JBTCBESUZGRVJFTkNFUwogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KQEAgLTgzMiw3ICs4NTQsOCBAQAogCVRoaXMgaGFwcGVucyBpZiB0aGUgJ3N1YnN5c3RlbScgcmViYXNlIGhhZCBjb25mbGljdHMsIG9yIHVzZWQKIAlgLS1pbnRlcmFjdGl2ZWAgdG8gb21pdCwgZWRpdCwgc3F1YXNoLCBvciBmaXh1cCBjb21taXRzOyBvcgogCWlmIHRoZSB1cHN0cmVhbSB1c2VkIG9uZSBvZiBgY29tbWl0IC0tYW1lbmRgLCBgcmVzZXRgLCBvcgotCWBmaWx0ZXItYnJhbmNoYC4KKwlhIGZ1bGwgaGlzdG9yeSByZXdyaXRpbmcgY29tbWFuZCBsaWtlCisJaHR0cHM6Ly9naXRodWIuY29tL25ld3Jlbi9naXQtZmlsdGVyLXJlcG9bYGZpbHRlci1yZXBvYF0uCiAKIAogVGhlIGVhc3kgY2FzZQpAQCAtODcwLDcgKzg5Myw3IEBACiAgICAgICAtLWludGVyYWN0aXZlYCB3aWxsIGJlICoqcmVzdXJyZWN0ZWQqKiEKIAogVGhlIGlkZWEgaXMgdG8gbWFudWFsbHkgdGVsbCAnZ2l0IHJlYmFzZScgIndoZXJlIHRoZSBvbGQgJ3N1YnN5c3RlbScKLWVuZGVkIGFuZCB5b3VyICd0b3BpYycgYmVnYW4iLCB0aGF0IGlzLCB3aGF0IHRoZSBvbGQgbWVyZ2UtYmFzZQorZW5kZWQgYW5kIHlvdXIgJ3RvcGljJyBiZWdhbiIsIHRoYXQgaXMsIHdoYXQgdGhlIG9sZCBtZXJnZSBiYXNlCiBiZXR3ZWVuIHRoZW0gd2FzLiAgWW91IHdpbGwgaGF2ZSB0byBmaW5kIGEgd2F5IHRvIG5hbWUgdGhlIGxhc3QgY29tbWl0CiBvZiB0aGUgb2xkICdzdWJzeXN0ZW0nLCBmb3IgZXhhbXBsZToKIApkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9naXQtcmVjZWl2ZS1wYWNrLnR4dCBiL0RvY3VtZW50YXRpb24vZ2l0LXJlY2VpdmUtcGFjay50eHQKaW5kZXggZGVkZjk3ZS4uMjU3MDJlZCAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9naXQtcmVjZWl2ZS1wYWNrLnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL2dpdC1yZWNlaXZlLXBhY2sudHh0CkBAIC0xNjUsMjkgKzE2NSwzMSBAQAogY2VydGlmaWNhdGVzIG9mIHNpZ25lZCBwdXNoZXMgd2l0aCBnb29kIHNpZ25hdHVyZXMgdG8gYSBsb2dnZXIKIHNlcnZpY2U6CiAKLQkjIS9iaW4vc2gKLQkjIG1haWwgb3V0IGNvbW1pdCB1cGRhdGUgaW5mb3JtYXRpb24uCi0Jd2hpbGUgcmVhZCBvdmFsIG52YWwgcmVmCi0JZG8KLQkJaWYgZXhwciAiJG92YWwiIDogJzAqJCcgPi9kZXYvbnVsbAotCQl0aGVuCi0JCQllY2hvICJDcmVhdGVkIGEgbmV3IHJlZiwgd2l0aCB0aGUgZm9sbG93aW5nIGNvbW1pdHM6IgotCQkJZ2l0IHJldi1saXN0IC0tcHJldHR5ICIkbnZhbCIKLQkJZWxzZQotCQkJZWNobyAiTmV3IGNvbW1pdHM6IgotCQkJZ2l0IHJldi1saXN0IC0tcHJldHR5ICIkbnZhbCIgIl4kb3ZhbCIKLQkJZmkgfAotCQltYWlsIC1zICJDaGFuZ2VzIHRvIHJlZiAkcmVmIiBjb21taXQtbGlzdEBteWRvbWFpbgotCWRvbmUKLQkjIGxvZyBzaWduZWQgcHVzaCBjZXJ0aWZpY2F0ZSwgaWYgYW55Ci0JaWYgdGVzdCAtbiAiJHtHSVRfUFVTSF9DRVJULX0iICYmIHRlc3QgJHtHSVRfUFVTSF9DRVJUX1NUQVRVU30gPSBHCistLS0tCisjIS9iaW4vc2gKKyMgbWFpbCBvdXQgY29tbWl0IHVwZGF0ZSBpbmZvcm1hdGlvbi4KK3doaWxlIHJlYWQgb3ZhbCBudmFsIHJlZgorZG8KKwlpZiBleHByICIkb3ZhbCIgOiAnMCokJyA+L2Rldi9udWxsCiAJdGhlbgotCQkoCi0JCQllY2hvIGV4cGVjdGVkIG5vbmNlIGlzICR7R0lUX1BVU0hfTk9OQ0V9Ci0JCQlnaXQgY2F0LWZpbGUgYmxvYiAke0dJVF9QVVNIX0NFUlR9Ci0JCSkgfCBtYWlsIC1zICJwdXNoIGNlcnRpZmljYXRlIGZyb20gJEdJVF9QVVNIX0NFUlRfU0lHTkVSIiBwdXNoLWxvZ0BteWRvbWFpbgotCWZpCi0JZXhpdCAwCisJCWVjaG8gIkNyZWF0ZWQgYSBuZXcgcmVmLCB3aXRoIHRoZSBmb2xsb3dpbmcgY29tbWl0czoiCisJCWdpdCByZXYtbGlzdCAtLXByZXR0eSAiJG52YWwiCisJZWxzZQorCQllY2hvICJOZXcgY29tbWl0czoiCisJCWdpdCByZXYtbGlzdCAtLXByZXR0eSAiJG52YWwiICJeJG92YWwiCisJZmkgfAorCW1haWwgLXMgIkNoYW5nZXMgdG8gcmVmICRyZWYiIGNvbW1pdC1saXN0QG15ZG9tYWluCitkb25lCisjIGxvZyBzaWduZWQgcHVzaCBjZXJ0aWZpY2F0ZSwgaWYgYW55CitpZiB0ZXN0IC1uICIke0dJVF9QVVNIX0NFUlQtfSIgJiYgdGVzdCAke0dJVF9QVVNIX0NFUlRfU1RBVFVTfSA9IEcKK3RoZW4KKwkoCisJCWVjaG8gZXhwZWN0ZWQgbm9uY2UgaXMgJHtHSVRfUFVTSF9OT05DRX0KKwkJZ2l0IGNhdC1maWxlIGJsb2IgJHtHSVRfUFVTSF9DRVJUfQorCSkgfCBtYWlsIC1zICJwdXNoIGNlcnRpZmljYXRlIGZyb20gJEdJVF9QVVNIX0NFUlRfU0lHTkVSIiBwdXNoLWxvZ0BteWRvbWFpbgorZmkKK2V4aXQgMAorLS0tLQogCiBUaGUgZXhpdCBjb2RlIGZyb20gdGhpcyBob29rIGludm9jYXRpb24gaXMgaWdub3JlZCwgaG93ZXZlciBhCiBub24temVybyBleGl0IGNvZGUgd2lsbCBnZW5lcmF0ZSBhbiBlcnJvciBtZXNzYWdlLgpAQCAtMjEyLDggKzIxNCwxMCBAQAogVGhpcyBob29rIGNhbiBiZSB1c2VkLCBmb3IgZXhhbXBsZSwgdG8gcnVuIGBnaXQgdXBkYXRlLXNlcnZlci1pbmZvYAogaWYgdGhlIHJlcG9zaXRvcnkgaXMgcGFja2VkIGFuZCBpcyBzZXJ2ZWQgdmlhIGEgZHVtYiB0cmFuc3BvcnQuCiAKLQkjIS9iaW4vc2gKLQlleGVjIGdpdCB1cGRhdGUtc2VydmVyLWluZm8KKy0tLS0KKyMhL2Jpbi9zaAorZXhlYyBnaXQgdXBkYXRlLXNlcnZlci1pbmZvCistLS0tCiAKIAogUVVBUkFOVElORSBFTlZJUk9OTUVOVApkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9naXQtcmVwbGFjZS50eHQgYi9Eb2N1bWVudGF0aW9uL2dpdC1yZXBsYWNlLnR4dAppbmRleCAyNDZkYzk5Li5mMjcxZDc1IDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2dpdC1yZXBsYWNlLnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL2dpdC1yZXBsYWNlLnR4dApAQCAtMTIzLDEwICsxMjMsMTAgQEAKIENSRUFUSU5HIFJFUExBQ0VNRU5UIE9CSkVDVFMKIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KIAotbGlua2dpdDpnaXQtZmlsdGVyLWJyYW5jaFsxXSwgbGlua2dpdDpnaXQtaGFzaC1vYmplY3RbMV0gYW5kCi1saW5rZ2l0OmdpdC1yZWJhc2VbMV0sIGFtb25nIG90aGVyIGdpdCBjb21tYW5kcywgY2FuIGJlIHVzZWQgdG8gY3JlYXRlCi1yZXBsYWNlbWVudCBvYmplY3RzIGZyb20gZXhpc3Rpbmcgb2JqZWN0cy4gVGhlIGAtLWVkaXRgIG9wdGlvbiBjYW4KLWFsc28gYmUgdXNlZCB3aXRoICdnaXQgcmVwbGFjZScgdG8gY3JlYXRlIGEgcmVwbGFjZW1lbnQgb2JqZWN0IGJ5CitsaW5rZ2l0OmdpdC1oYXNoLW9iamVjdFsxXSwgbGlua2dpdDpnaXQtcmViYXNlWzFdLCBhbmQKK2h0dHBzOi8vZ2l0aHViLmNvbS9uZXdyZW4vZ2l0LWZpbHRlci1yZXBvW2dpdC1maWx0ZXItcmVwb10sIGFtb25nIG90aGVyIGdpdCBjb21tYW5kcywgY2FuIGJlIHVzZWQgdG8KK2NyZWF0ZSByZXBsYWNlbWVudCBvYmplY3RzIGZyb20gZXhpc3Rpbmcgb2JqZWN0cy4gVGhlIGAtLWVkaXRgIG9wdGlvbgorY2FuIGFsc28gYmUgdXNlZCB3aXRoICdnaXQgcmVwbGFjZScgdG8gY3JlYXRlIGEgcmVwbGFjZW1lbnQgb2JqZWN0IGJ5CiBlZGl0aW5nIGFuIGV4aXN0aW5nIG9iamVjdC4KIAogSWYgeW91IHdhbnQgdG8gcmVwbGFjZSBtYW55IGJsb2JzLCB0cmVlcyBvciBjb21taXRzIHRoYXQgYXJlIHBhcnQgb2YgYQpAQCAtMTQ4LDEzICsxNDgsMTMgQEAKIFNFRSBBTFNPCiAtLS0tLS0tLQogbGlua2dpdDpnaXQtaGFzaC1vYmplY3RbMV0KLWxpbmtnaXQ6Z2l0LWZpbHRlci1icmFuY2hbMV0KIGxpbmtnaXQ6Z2l0LXJlYmFzZVsxXQogbGlua2dpdDpnaXQtdGFnWzFdCiBsaW5rZ2l0OmdpdC1icmFuY2hbMV0KIGxpbmtnaXQ6Z2l0LWNvbW1pdFsxXQogbGlua2dpdDpnaXQtdmFyWzFdCiBsaW5rZ2l0OmdpdFsxXQoraHR0cHM6Ly9naXRodWIuY29tL25ld3Jlbi9naXQtZmlsdGVyLXJlcG9bZ2l0LWZpbHRlci1yZXBvXQogCiBHSVQKIC0tLQpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9naXQtcmV2LWxpc3QudHh0IGIvRG9jdW1lbnRhdGlvbi9naXQtcmV2LWxpc3QudHh0CmluZGV4IDkzOTI3NjAuLjAyNWM5MTEgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vZ2l0LXJldi1saXN0LnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL2dpdC1yZXYtbGlzdC50eHQKQEAgLTksNTkgKzksNyBAQAogU1lOT1BTSVMKIC0tLS0tLS0tCiBbdmVyc2VdCi0nZ2l0IHJldi1saXN0JyBbIC0tbWF4LWNvdW50PTxudW1iZXI+IF0KLQkgICAgIFsgLS1za2lwPTxudW1iZXI+IF0KLQkgICAgIFsgLS1tYXgtYWdlPTx0aW1lc3RhbXA+IF0KLQkgICAgIFsgLS1taW4tYWdlPTx0aW1lc3RhbXA+IF0KLQkgICAgIFsgLS1zcGFyc2UgXQotCSAgICAgWyAtLW1lcmdlcyBdCi0JICAgICBbIC0tbm8tbWVyZ2VzIF0KLQkgICAgIFsgLS1taW4tcGFyZW50cz08bnVtYmVyPiBdCi0JICAgICBbIC0tbm8tbWluLXBhcmVudHMgXQotCSAgICAgWyAtLW1heC1wYXJlbnRzPTxudW1iZXI+IF0KLQkgICAgIFsgLS1uby1tYXgtcGFyZW50cyBdCi0JICAgICBbIC0tZmlyc3QtcGFyZW50IF0KLQkgICAgIFsgLS1yZW1vdmUtZW1wdHkgXQotCSAgICAgWyAtLWZ1bGwtaGlzdG9yeSBdCi0JICAgICBbIC0tbm90IF0KLQkgICAgIFsgLS1hbGwgXQotCSAgICAgWyAtLWJyYW5jaGVzWz08cGF0dGVybj5dIF0KLQkgICAgIFsgLS10YWdzWz08cGF0dGVybj5dIF0KLQkgICAgIFsgLS1yZW1vdGVzWz08cGF0dGVybj5dIF0KLQkgICAgIFsgLS1nbG9iPTxnbG9iLXBhdHRlcm4+IF0KLQkgICAgIFsgLS1pZ25vcmUtbWlzc2luZyBdCi0JICAgICBbIC0tc3RkaW4gXQotCSAgICAgWyAtLXF1aWV0IF0KLQkgICAgIFsgLS10b3BvLW9yZGVyIF0KLQkgICAgIFsgLS1wYXJlbnRzIF0KLQkgICAgIFsgLS10aW1lc3RhbXAgXQotCSAgICAgWyAtLWxlZnQtcmlnaHQgXQotCSAgICAgWyAtLWxlZnQtb25seSBdCi0JICAgICBbIC0tcmlnaHQtb25seSBdCi0JICAgICBbIC0tY2hlcnJ5LW1hcmsgXQotCSAgICAgWyAtLWNoZXJyeS1waWNrIF0KLQkgICAgIFsgLS1lbmNvZGluZz08ZW5jb2Rpbmc+IF0KLQkgICAgIFsgLS0oYXV0aG9yfGNvbW1pdHRlcnxncmVwKT08cGF0dGVybj4gXQotCSAgICAgWyAtLXJlZ2V4cC1pZ25vcmUtY2FzZSB8IC1pIF0KLQkgICAgIFsgLS1leHRlbmRlZC1yZWdleHAgfCAtRSBdCi0JICAgICBbIC0tZml4ZWQtc3RyaW5ncyB8IC1GIF0KLQkgICAgIFsgLS1kYXRlPTxmb3JtYXQ+XQotCSAgICAgWyBbIC0tb2JqZWN0cyB8IC0tb2JqZWN0cy1lZGdlIHwgLS1vYmplY3RzLWVkZ2UtYWdncmVzc2l2ZSBdCi0JICAgICAgIFsgLS11bnBhY2tlZCBdCi0JICAgICAgIFsgLS1vYmplY3QtbmFtZXMgfCAtLW5vLW9iamVjdC1uYW1lcyBdCi0JICAgICAgIFsgLS1maWx0ZXI9PGZpbHRlci1zcGVjPiBbIC0tZmlsdGVyLXByaW50LW9taXR0ZWQgXSBdIF0KLQkgICAgIFsgLS1taXNzaW5nPTxtaXNzaW5nLWFjdGlvbj4gXQotCSAgICAgWyAtLXByZXR0eSB8IC0taGVhZGVyIF0KLQkgICAgIFsgLS1iaXNlY3QgXQotCSAgICAgWyAtLWJpc2VjdC12YXJzIF0KLQkgICAgIFsgLS1iaXNlY3QtYWxsIF0KLQkgICAgIFsgLS1tZXJnZSBdCi0JICAgICBbIC0tcmV2ZXJzZSBdCi0JICAgICBbIC0td2Fsay1yZWZsb2dzIF0KLQkgICAgIFsgLS1uby13YWxrIF0gWyAtLWRvLXdhbGsgXQotCSAgICAgWyAtLWNvdW50IF0KLQkgICAgIFsgLS11c2UtYml0bWFwLWluZGV4IF0KLQkgICAgIDxjb21taXQ+Li4uIFsgXC0tIDxwYXRocz4uLi4gXQorJ2dpdCByZXYtbGlzdCcgWzxvcHRpb25zPl0gPGNvbW1pdD4uLi4gW1stLV0gPHBhdGg+Li4uXQogCiBERVNDUklQVElPTgogLS0tLS0tLS0tLS0KZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vZ2l0LXJldi1wYXJzZS50eHQgYi9Eb2N1bWVudGF0aW9uL2dpdC1yZXYtcGFyc2UudHh0CmluZGV4IGU3MmQzMzIuLjE5YjEyYjYgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vZ2l0LXJldi1wYXJzZS50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9naXQtcmV2LXBhcnNlLnR4dApAQCAtMjYyLDcgKzI2Miw4IEBACiAJZGlyZWN0b3J5LgogCiAtLXNob3ctdG9wbGV2ZWw6OgotCVNob3cgdGhlIGFic29sdXRlIHBhdGggb2YgdGhlIHRvcC1sZXZlbCBkaXJlY3RvcnkuCisJU2hvdyB0aGUgYWJzb2x1dGUgcGF0aCBvZiB0aGUgdG9wLWxldmVsIGRpcmVjdG9yeSBvZiB0aGUgd29ya2luZworCXRyZWUuIElmIHRoZXJlIGlzIG5vIHdvcmtpbmcgdHJlZSwgcmVwb3J0IGFuIGVycm9yLgogCiAtLXNob3ctc3VwZXJwcm9qZWN0LXdvcmtpbmctdHJlZTo6CiAJU2hvdyB0aGUgYWJzb2x1dGUgcGF0aCBvZiB0aGUgcm9vdCBvZiB0aGUgc3VwZXJwcm9qZWN0J3MKQEAgLTI3NCw2ICsyNzUsMTMgQEAKIAlTaG93IHRoZSBwYXRoIHRvIHRoZSBzaGFyZWQgaW5kZXggZmlsZSBpbiBzcGxpdCBpbmRleCBtb2RlLCBvcgogCWVtcHR5IGlmIG5vdCBpbiBzcGxpdC1pbmRleCBtb2RlLgogCistLXNob3ctb2JqZWN0LWZvcm1hdFs9KHN0b3JhZ2V8aW5wdXR8b3V0cHV0KV06OgorCVNob3cgdGhlIG9iamVjdCBmb3JtYXQgKGhhc2ggYWxnb3JpdGhtKSB1c2VkIGZvciB0aGUgcmVwb3NpdG9yeQorCWZvciBzdG9yYWdlIGluc2lkZSB0aGUgYC5naXRgIGRpcmVjdG9yeSwgaW5wdXQsIG9yIG91dHB1dC4gRm9yCisJaW5wdXQsIG11bHRpcGxlIGFsZ29yaXRobXMgbWF5IGJlIHByaW50ZWQsIHNwYWNlLXNlcGFyYXRlZC4KKwlJZiBub3Qgc3BlY2lmaWVkLCB0aGUgZGVmYXVsdCBpcyAic3RvcmFnZSIuCisKKwogT3RoZXIgT3B0aW9ucwogfn5+fn5+fn5+fn5+fgogCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2dpdC1zZW5kLWVtYWlsLnR4dCBiL0RvY3VtZW50YXRpb24vZ2l0LXNlbmQtZW1haWwudHh0CmluZGV4IGQ5M2U1ZDAuLjBhNjk4MTAgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vZ2l0LXNlbmQtZW1haWwudHh0CisrKyBiL0RvY3VtZW50YXRpb24vZ2l0LXNlbmQtZW1haWwudHh0CkBAIC00ODYsMTEgKzQ4NiwxMyBAQAogVG8gdXNlICdnaXQgc2VuZC1lbWFpbCcgdG8gc2VuZCB5b3VyIHBhdGNoZXMgdGhyb3VnaCB0aGUgR01haWwgU01UUCBzZXJ2ZXIsCiBlZGl0IH4vLmdpdGNvbmZpZyB0byBzcGVjaWZ5IHlvdXIgYWNjb3VudCBzZXR0aW5nczoKIAotCVtzZW5kZW1haWxdCi0JCXNtdHBFbmNyeXB0aW9uID0gdGxzCi0JCXNtdHBTZXJ2ZXIgPSBzbXRwLmdtYWlsLmNvbQotCQlzbXRwVXNlciA9IHlvdXJuYW1lQGdtYWlsLmNvbQotCQlzbXRwU2VydmVyUG9ydCA9IDU4NworLS0tLQorW3NlbmRlbWFpbF0KKwlzbXRwRW5jcnlwdGlvbiA9IHRscworCXNtdHBTZXJ2ZXIgPSBzbXRwLmdtYWlsLmNvbQorCXNtdHBVc2VyID0geW91cm5hbWVAZ21haWwuY29tCisJc210cFNlcnZlclBvcnQgPSA1ODcKKy0tLS0KIAogSWYgeW91IGhhdmUgbXVsdGlmYWN0b3IgYXV0aGVudGljYXRpb24gc2V0dXAgb24geW91ciBnbWFpbCBhY2NvdW50LCB5b3Ugd2lsbAogbmVlZCB0byBnZW5lcmF0ZSBhbiBhcHAtc3BlY2lmaWMgcGFzc3dvcmQgZm9yIHVzZSB3aXRoICdnaXQgc2VuZC1lbWFpbCcuIFZpc2l0CmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2dpdC1zaG9ydGxvZy50eHQgYi9Eb2N1bWVudGF0aW9uL2dpdC1zaG9ydGxvZy50eHQKaW5kZXggYmM4MDkwNS4uYTcyZWE3ZiAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9naXQtc2hvcnRsb2cudHh0CisrKyBiL0RvY3VtZW50YXRpb24vZ2l0LXNob3J0bG9nLnR4dApAQCAtNzYsNiArNzYsOSBAQAogUGF0aHMgbWF5IG5lZWQgdG8gYmUgcHJlZml4ZWQgd2l0aCBgLS1gIHRvIHNlcGFyYXRlIHRoZW0gZnJvbQogb3B0aW9ucyBvciB0aGUgcmV2aXNpb24gcmFuZ2UsIHdoZW4gY29uZnVzaW9uIGFyaXNlcy4KIAorOmdpdC1zaG9ydGxvZzogMQoraW5jbHVkZTo6cmV2LWxpc3Qtb3B0aW9ucy50eHRbXQorCiBNQVBQSU5HIEFVVEhPUlMKIC0tLS0tLS0tLS0tLS0tLQogCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2dpdC1zdGFzaC50eHQgYi9Eb2N1bWVudGF0aW9uL2dpdC1zdGFzaC50eHQKaW5kZXggOGZiZTEyYy4uNTNlMWExMiAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9naXQtc3Rhc2gudHh0CisrKyBiL0RvY3VtZW50YXRpb24vZ2l0LXN0YXNoLnR4dApAQCAtODcsOCArODcsOSBAQAogc2F2ZSBbLXB8LS1wYXRjaF0gWy1rfC0tW25vLV1rZWVwLWluZGV4XSBbLXV8LS1pbmNsdWRlLXVudHJhY2tlZF0gWy1hfC0tYWxsXSBbLXF8LS1xdWlldF0gWzxtZXNzYWdlPl06OgogCiAJVGhpcyBvcHRpb24gaXMgZGVwcmVjYXRlZCBpbiBmYXZvdXIgb2YgJ2dpdCBzdGFzaCBwdXNoJy4gIEl0Ci0JZGlmZmVycyBmcm9tICJzdGFzaCBwdXNoIiBpbiB0aGF0IGl0IGNhbm5vdCB0YWtlIHBhdGhzcGVjcywKLQlhbmQgYW55IG5vbi1vcHRpb24gYXJndW1lbnRzIGZvcm0gdGhlIG1lc3NhZ2UuCisJZGlmZmVycyBmcm9tICJzdGFzaCBwdXNoIiBpbiB0aGF0IGl0IGNhbm5vdCB0YWtlIHBhdGhzcGVjcy4KKwlJbnN0ZWFkLCBhbGwgbm9uLW9wdGlvbiBhcmd1bWVudHMgYXJlIGNvbmNhdGVuYXRlZCB0byBmb3JtIHRoZSBzdGFzaAorCW1lc3NhZ2UuCiAKIGxpc3QgWzxvcHRpb25zPl06OgogCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2dpdC1zdGF0dXMudHh0IGIvRG9jdW1lbnRhdGlvbi9naXQtc3RhdHVzLnR4dAppbmRleCBkNGU4ZjI0Li43NzMxYjQ1IDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2dpdC1zdGF0dXMudHh0CisrKyBiL0RvY3VtZW50YXRpb24vZ2l0LXN0YXR1cy50eHQKQEAgLTU5LDE2ICs1OSwxNyBAQAogLS11bnRyYWNrZWQtZmlsZXNbPTxtb2RlPl06OgogCVNob3cgdW50cmFja2VkIGZpbGVzLgogKworLS0KIFRoZSBtb2RlIHBhcmFtZXRlciBpcyB1c2VkIHRvIHNwZWNpZnkgdGhlIGhhbmRsaW5nIG9mIHVudHJhY2tlZCBmaWxlcy4KIEl0IGlzIG9wdGlvbmFsOiBpdCBkZWZhdWx0cyB0byAnYWxsJywgYW5kIGlmIHNwZWNpZmllZCwgaXQgbXVzdCBiZQogc3R1Y2sgdG8gdGhlIG9wdGlvbiAoZS5nLiBgLXVub2AsIGJ1dCBub3QgYC11IG5vYCkuCi0rCisKIFRoZSBwb3NzaWJsZSBvcHRpb25zIGFyZToKLSsKKwogCS0gJ25vJyAgICAgLSBTaG93IG5vIHVudHJhY2tlZCBmaWxlcy4KIAktICdub3JtYWwnIC0gU2hvd3MgdW50cmFja2VkIGZpbGVzIGFuZCBkaXJlY3Rvcmllcy4KIAktICdhbGwnICAgIC0gQWxzbyBzaG93cyBpbmRpdmlkdWFsIGZpbGVzIGluIHVudHJhY2tlZCBkaXJlY3Rvcmllcy4KLSsKKwogV2hlbiBgLXVgIG9wdGlvbiBpcyBub3QgdXNlZCwgdW50cmFja2VkIGZpbGVzIGFuZCBkaXJlY3RvcmllcyBhcmUKIHNob3duIChpLmUuIHRoZSBzYW1lIGFzIHNwZWNpZnlpbmcgYG5vcm1hbGApLCB0byBoZWxwIHlvdSBhdm9pZAogZm9yZ2V0dGluZyB0byBhZGQgbmV3bHkgY3JlYXRlZCBmaWxlcy4gIEJlY2F1c2UgaXQgdGFrZXMgZXh0cmEgd29yawpAQCAtNzgsOSArNzksMTAgQEAKIGBnaXQgdXBkYXRlLWluZGV4IC0tdW50cmFja2VkLWNhY2hlYCBhbmQgYGdpdCB1cGRhdGUtaW5kZXgKIC0tc3BsaXQtaW5kZXhgKSwgT3RoZXJ3aXNlIHlvdSBjYW4gdXNlIGBub2AgdG8gaGF2ZSBgZ2l0IHN0YXR1c2AKIHJldHVybiBtb3JlIHF1aWNrbHkgd2l0aG91dCBzaG93aW5nIHVudHJhY2tlZCBmaWxlcy4KLSsKKwogVGhlIGRlZmF1bHQgY2FuIGJlIGNoYW5nZWQgdXNpbmcgdGhlIHN0YXR1cy5zaG93VW50cmFja2VkRmlsZXMKIGNvbmZpZ3VyYXRpb24gdmFyaWFibGUgZG9jdW1lbnRlZCBpbiBsaW5rZ2l0OmdpdC1jb25maWdbMV0uCistLQogCiAtLWlnbm9yZS1zdWJtb2R1bGVzWz08d2hlbj5dOjoKIAlJZ25vcmUgY2hhbmdlcyB0byBzdWJtb2R1bGVzIHdoZW4gbG9va2luZyBmb3IgY2hhbmdlcy4gPHdoZW4+IGNhbiBiZQpAQCAtMTAwLDExICsxMDIsMTIgQEAKIC0taWdub3JlZFs9PG1vZGU+XTo6CiAJU2hvdyBpZ25vcmVkIGZpbGVzIGFzIHdlbGwuCiArCistLQogVGhlIG1vZGUgcGFyYW1ldGVyIGlzIHVzZWQgdG8gc3BlY2lmeSB0aGUgaGFuZGxpbmcgb2YgaWdub3JlZCBmaWxlcy4KIEl0IGlzIG9wdGlvbmFsOiBpdCBkZWZhdWx0cyB0byAndHJhZGl0aW9uYWwnLgotKworCiBUaGUgcG9zc2libGUgb3B0aW9ucyBhcmU6Ci0rCisKIAktICd0cmFkaXRpb25hbCcgLSBTaG93cyBpZ25vcmVkIGZpbGVzIGFuZCBkaXJlY3RvcmllcywgdW5sZXNzCiAJCQkgIC0tdW50cmFja2VkLWZpbGVzPWFsbCBpcyBzcGVjaWZpZWQsIGluIHdoaWNoIGNhc2UKIAkJCSAgaW5kaXZpZHVhbCBmaWxlcyBpbiBpZ25vcmVkIGRpcmVjdG9yaWVzIGFyZQpAQCAtMTEyLDEyICsxMTUsMTMgQEAKIAktICdubycJICAgICAgICAtIFNob3cgbm8gaWdub3JlZCBmaWxlcy4KIAktICdtYXRjaGluZycgICAgLSBTaG93cyBpZ25vcmVkIGZpbGVzIGFuZCBkaXJlY3RvcmllcyBtYXRjaGluZyBhbgogCQkJICBpZ25vcmUgcGF0dGVybi4KLSsKKwogV2hlbiAnbWF0Y2hpbmcnIG1vZGUgaXMgc3BlY2lmaWVkLCBwYXRocyB0aGF0IGV4cGxpY2l0bHkgbWF0Y2ggYW4KIGlnbm9yZWQgcGF0dGVybiBhcmUgc2hvd24uIElmIGEgZGlyZWN0b3J5IG1hdGNoZXMgYW4gaWdub3JlIHBhdHRlcm4sCiB0aGVuIGl0IGlzIHNob3duLCBidXQgbm90IHBhdGhzIGNvbnRhaW5lZCBpbiB0aGUgaWdub3JlZCBkaXJlY3RvcnkuIElmCiBhIGRpcmVjdG9yeSBkb2VzIG5vdCBtYXRjaCBhbiBpZ25vcmUgcGF0dGVybiwgYnV0IGFsbCBjb250ZW50cyBhcmUKIGlnbm9yZWQsIHRoZW4gdGhlIGRpcmVjdG9yeSBpcyBub3Qgc2hvd24sIGJ1dCBhbGwgY29udGVudHMgYXJlIHNob3duLgorLS0KIAogLXo6OgogCVRlcm1pbmF0ZSBlbnRyaWVzIHdpdGggTlVMLCBpbnN0ZWFkIG9mIExGLiAgVGhpcyBpbXBsaWVzCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2dpdC1zdWJtb2R1bGUudHh0IGIvRG9jdW1lbnRhdGlvbi9naXQtc3VibW9kdWxlLnR4dAppbmRleCAwZWQ1YzI0Li5jM2M1MjIyIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2dpdC1zdWJtb2R1bGUudHh0CisrKyBiL0RvY3VtZW50YXRpb24vZ2l0LXN1Ym1vZHVsZS50eHQKQEAgLTgwLDYgKzgwLDkgQEAKIAlkb2VzIG5vdCBtYXRjaCB0aGUgU0hBLTEgZm91bmQgaW4gdGhlIGluZGV4IG9mIHRoZSBjb250YWluaW5nCiAJcmVwb3NpdG9yeSBhbmQgYFVgIGlmIHRoZSBzdWJtb2R1bGUgaGFzIG1lcmdlIGNvbmZsaWN0cy4KICsKK0lmIGAtLWNhY2hlZGAgaXMgc3BlY2lmaWVkLCB0aGlzIGNvbW1hbmQgd2lsbCBpbnN0ZWFkIHByaW50IHRoZSBTSEEtMQorcmVjb3JkZWQgaW4gdGhlIHN1cGVycHJvamVjdCBmb3IgZWFjaCBzdWJtb2R1bGUuCisrCiBJZiBgLS1yZWN1cnNpdmVgIGlzIHNwZWNpZmllZCwgdGhpcyBjb21tYW5kIHdpbGwgcmVjdXJzZSBpbnRvIG5lc3RlZAogc3VibW9kdWxlcywgYW5kIHNob3cgdGhlaXIgc3RhdHVzIGFzIHdlbGwuCiArCkBAIC0xMzMsNyArMTM2LDggQEAKICsKIC0tCiBVcGRhdGUgdGhlIHJlZ2lzdGVyZWQgc3VibW9kdWxlcyB0byBtYXRjaCB3aGF0IHRoZSBzdXBlcnByb2plY3QKLWV4cGVjdHMgYnkgY2xvbmluZyBtaXNzaW5nIHN1Ym1vZHVsZXMgYW5kIHVwZGF0aW5nIHRoZSB3b3JraW5nIHRyZWUgb2YKK2V4cGVjdHMgYnkgY2xvbmluZyBtaXNzaW5nIHN1Ym1vZHVsZXMsIGZldGNoaW5nIG1pc3NpbmcgY29tbWl0cworaW4gc3VibW9kdWxlcyBhbmQgdXBkYXRpbmcgdGhlIHdvcmtpbmcgdHJlZSBvZgogdGhlIHN1Ym1vZHVsZXMuIFRoZSAidXBkYXRpbmciIGNhbiBiZSBkb25lIGluIHNldmVyYWwgd2F5cyBkZXBlbmRpbmcKIG9uIGNvbW1hbmQgbGluZSBvcHRpb25zIGFuZCB0aGUgdmFsdWUgb2YgYHN1Ym1vZHVsZS48bmFtZT4udXBkYXRlYAogY29uZmlndXJhdGlvbiB2YXJpYWJsZS4gVGhlIGNvbW1hbmQgbGluZSBvcHRpb24gdGFrZXMgcHJlY2VkZW5jZSBvdmVyCkBAIC0xNzMsNyArMTc3LDggQEAKIElmIGAtLXJlY3Vyc2l2ZWAgaXMgc3BlY2lmaWVkLCB0aGlzIGNvbW1hbmQgd2lsbCByZWN1cnNlIGludG8gdGhlCiByZWdpc3RlcmVkIHN1Ym1vZHVsZXMsIGFuZCB1cGRhdGUgYW55IG5lc3RlZCBzdWJtb2R1bGVzIHdpdGhpbi4KIC0tCi1zZXQtYnJhbmNoICgoLWR8LS1kZWZhdWx0KXwoLWJ8LS1icmFuY2ggPGJyYW5jaD4pKSBbLS1dIDxwYXRoPjo6CitzZXQtYnJhbmNoICgtYnwtLWJyYW5jaCkgPGJyYW5jaD4gWy0tXSA8cGF0aD46Ogorc2V0LWJyYW5jaCAoLWR8LS1kZWZhdWx0KSBbLS1dIDxwYXRoPjo6CiAJU2V0cyB0aGUgZGVmYXVsdCByZW1vdGUgdHJhY2tpbmcgYnJhbmNoIGZvciB0aGUgc3VibW9kdWxlLiBUaGUKIAlgLS1icmFuY2hgIG9wdGlvbiBhbGxvd3MgdGhlIHJlbW90ZSBicmFuY2ggdG8gYmUgc3BlY2lmaWVkLiBUaGUKIAlgLS1kZWZhdWx0YCBvcHRpb24gcmVtb3ZlcyB0aGUgc3VibW9kdWxlLjxuYW1lPi5icmFuY2ggY29uZmlndXJhdGlvbgpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9naXQtc3ZuLnR4dCBiL0RvY3VtZW50YXRpb24vZ2l0LXN2bi50eHQKaW5kZXggMzA3MTE2Mi4uNjYyNGExNCAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9naXQtc3ZuLnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL2dpdC1zdm4udHh0CkBAIC02NzcsNyArNjc3LDggQEAKIC1zPHN0cmF0ZWd5Pjo6CiAtLXN0cmF0ZWd5PTxzdHJhdGVneT46OgogLXA6OgotLS1wcmVzZXJ2ZS1tZXJnZXM6OgorLS1yZWJhc2UtbWVyZ2VzOjoKKy0tcHJlc2VydmUtbWVyZ2VzIChERVBSRUNBVEVEKTo6CiAJVGhlc2UgYXJlIG9ubHkgdXNlZCB3aXRoIHRoZSAnZGNvbW1pdCcgYW5kICdyZWJhc2UnIGNvbW1hbmRzLgogKwogUGFzc2VkIGRpcmVjdGx5IHRvICdnaXQgcmViYXNlJyB3aGVuIHVzaW5nICdkY29tbWl0JyBpZiBhCkBAIC03NjksMTEgKzc3MCwxMSBAQAogKwogVGhpcyBvcHRpb24gaXMgTk9UIHJlY29tbWVuZGVkIGFzIGl0IG1ha2VzIGl0IGRpZmZpY3VsdCB0byB0cmFjayBkb3duCiBvbGQgcmVmZXJlbmNlcyB0byBTVk4gcmV2aXNpb24gbnVtYmVycyBpbiBleGlzdGluZyBkb2N1bWVudGF0aW9uLCBidWcKLXJlcG9ydHMgYW5kIGFyY2hpdmVzLiAgSWYgeW91IHBsYW4gdG8gZXZlbnR1YWxseSBtaWdyYXRlIGZyb20gU1ZOIHRvIEdpdAotYW5kIGFyZSBjZXJ0YWluIGFib3V0IGRyb3BwaW5nIFNWTiBoaXN0b3J5LCBjb25zaWRlcgotbGlua2dpdDpnaXQtZmlsdGVyLWJyYW5jaFsxXSBpbnN0ZWFkLiAgZmlsdGVyLWJyYW5jaCBhbHNvIGFsbG93cwotcmVmb3JtYXR0aW5nIG9mIG1ldGFkYXRhIGZvciBlYXNlLW9mLXJlYWRpbmcgYW5kIHJld3JpdGluZyBhdXRob3JzaGlwCi1pbmZvIGZvciBub24tInN2bi5hdXRob3JzRmlsZSIgdXNlcnMuCityZXBvcnRzLCBhbmQgYXJjaGl2ZXMuICBJZiB5b3UgcGxhbiB0byBldmVudHVhbGx5IG1pZ3JhdGUgZnJvbSBTVk4gdG8KK0dpdCBhbmQgYXJlIGNlcnRhaW4gYWJvdXQgZHJvcHBpbmcgU1ZOIGhpc3RvcnksIGNvbnNpZGVyCitodHRwczovL2dpdGh1Yi5jb20vbmV3cmVuL2dpdC1maWx0ZXItcmVwb1tnaXQtZmlsdGVyLXJlcG9dIGluc3RlYWQuCitmaWx0ZXItcmVwbyBhbHNvIGFsbG93cyByZWZvcm1hdHRpbmcgb2YgbWV0YWRhdGEgZm9yIGVhc2Utb2YtcmVhZGluZworYW5kIHJld3JpdGluZyBhdXRob3JzaGlwIGluZm8gZm9yIG5vbi0ic3ZuLmF1dGhvcnNGaWxlIiB1c2Vycy4KIAogc3ZuLnVzZVN2bVByb3BzOjoKIHN2bi1yZW1vdGUuPG5hbWU+LnVzZVN2bVByb3BzOjoKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vZ2l0LXRhZy50eHQgYi9Eb2N1bWVudGF0aW9uL2dpdC10YWcudHh0CmluZGV4IDJlNTU5OWEuLmY2ZDk3OTEgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vZ2l0LXRhZy50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9naXQtdGFnLnR4dApAQCAtNjUsNyArNjUsNyBAQAogLS1zaWduOjoKIAlNYWtlIGEgR1BHLXNpZ25lZCB0YWcsIHVzaW5nIHRoZSBkZWZhdWx0IGUtbWFpbCBhZGRyZXNzJ3Mga2V5LgogCVRoZSBkZWZhdWx0IGJlaGF2aW9yIG9mIHRhZyBHUEctc2lnbmluZyBpcyBjb250cm9sbGVkIGJ5IGB0YWcuZ3BnU2lnbmAKLQljb25maWd1cmF0aW9uIHZhcmlhYmxlIGlmIGl0IGV4aXN0cywgb3IgZGlzYWJsZWQgb2RlciBvdGhlcndpc2UuCisJY29uZmlndXJhdGlvbiB2YXJpYWJsZSBpZiBpdCBleGlzdHMsIG9yIGRpc2FibGVkIG90aGVyd2lzZS4KIAlTZWUgbGlua2dpdDpnaXQtY29uZmlnWzFdLgogCiAtLW5vLXNpZ246OgpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9naXQtdXBkYXRlLWluZGV4LnR4dCBiL0RvY3VtZW50YXRpb24vZ2l0LXVwZGF0ZS1pbmRleC50eHQKaW5kZXggMWM0ZDE0Ni4uYzdhNjI3MSAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9naXQtdXBkYXRlLWluZGV4LnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL2dpdC11cGRhdGUtaW5kZXgudHh0CkBAIC0xNiw2ICsxNiw3IEBACiAJICAgICBbLS1jaG1vZD0oK3wtKXhdCiAJICAgICBbLS1bbm8tXWFzc3VtZS11bmNoYW5nZWRdCiAJICAgICBbLS1bbm8tXXNraXAtd29ya3RyZWVdCisJICAgICBbLS1bbm8tXWlnbm9yZS1za2lwLXdvcmt0cmVlLWVudHJpZXNdCiAJICAgICBbLS1bbm8tXWZzbW9uaXRvci12YWxpZF0KIAkgICAgIFstLWlnbm9yZS1zdWJtb2R1bGVzXQogCSAgICAgWy0tW25vLV1zcGxpdC1pbmRleF0KQEAgLTExMyw2ICsxMTQsMTEgQEAKIAlzZXQgYW5kIHVuc2V0IHRoZSAic2tpcC13b3JrdHJlZSIgYml0IGZvciB0aGUgcGF0aHMuIFNlZQogCXNlY3Rpb24gIlNraXAtd29ya3RyZWUgYml0IiBiZWxvdyBmb3IgbW9yZSBpbmZvcm1hdGlvbi4KIAorCistLVtuby1daWdub3JlLXNraXAtd29ya3RyZWUtZW50cmllczo6CisJRG8gbm90IHJlbW92ZSBza2lwLXdvcmt0cmVlIChBS0EgImluZGV4LW9ubHkiKSBlbnRyaWVzIGV2ZW4gd2hlbgorCXRoZSBgLS1yZW1vdmVgIG9wdGlvbiB3YXMgc3BlY2lmaWVkLgorCiAtLVtuby1dZnNtb25pdG9yLXZhbGlkOjoKIAlXaGVuIG9uZSBvZiB0aGVzZSBmbGFncyBpcyBzcGVjaWZpZWQsIHRoZSBvYmplY3QgbmFtZSByZWNvcmRlZAogCWZvciB0aGUgcGF0aHMgYXJlIG5vdCB1cGRhdGVkLiBJbnN0ZWFkLCB0aGVzZSBvcHRpb25zCkBAIC00MjYsNyArNDMyLDcgQEAKIGxpbmtnaXQ6Z2l0LWNvbmZpZ1sxXSkuCiAKIFRvIGF2b2lkIGRlbGV0aW5nIGEgc2hhcmVkIGluZGV4IGZpbGUgdGhhdCBpcyBzdGlsbCB1c2VkLCBpdHMKLW1vZGlmaWNhdGlvbiB0aW1lIGlzIHVwZGF0ZWQgdG8gdGhlIGN1cnJlbnQgdGltZSBldmVyeXRpbWUgYSBuZXcgc3BsaXQKK21vZGlmaWNhdGlvbiB0aW1lIGlzIHVwZGF0ZWQgdG8gdGhlIGN1cnJlbnQgdGltZSBldmVyeSB0aW1lIGEgbmV3IHNwbGl0CiBpbmRleCBiYXNlZCBvbiB0aGUgc2hhcmVkIGluZGV4IGZpbGUgaXMgZWl0aGVyIGNyZWF0ZWQgb3IgcmVhZCBmcm9tLgogCiBVTlRSQUNLRUQgQ0FDSEUKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vZ2l0LnR4dCBiL0RvY3VtZW50YXRpb24vZ2l0LnR4dAppbmRleCA5YjgyNTY0Li4xYjY3OGUyIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2dpdC50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9naXQudHh0CkBAIC0yNzEsOCArMjcxLDggQEAKIHRoZSB3b3JraW5nIHRyZWUuCiAKIAotU3luY2hpbmcgcmVwb3NpdG9yaWVzCi1+fn5+fn5+fn5+fn5+fn5+fn5+fn4KK1N5bmNpbmcgcmVwb3NpdG9yaWVzCit+fn5+fn5+fn5+fn5+fn5+fn5+fgogCiBpbmNsdWRlOjpjbWRzLXN5bmNoaW5ncmVwb3NpdG9yaWVzLnR4dFtdCiAKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vZ2l0YXR0cmlidXRlcy50eHQgYi9Eb2N1bWVudGF0aW9uL2dpdGF0dHJpYnV0ZXMudHh0CmluZGV4IGZiMWQxODguLjUwOGZlNzEgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vZ2l0YXR0cmlidXRlcy50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9naXRhdHRyaWJ1dGVzLnR4dApAQCAtMjkzLDEwICsyOTMsMTAgQEAKIAogSW4gdGhlc2UgY2FzZXMgeW91IGNhbiB0ZWxsIEdpdCB0aGUgZW5jb2Rpbmcgb2YgYSBmaWxlIGluIHRoZSB3b3JraW5nCiBkaXJlY3Rvcnkgd2l0aCB0aGUgYHdvcmtpbmctdHJlZS1lbmNvZGluZ2AgYXR0cmlidXRlLiBJZiBhIGZpbGUgd2l0aCB0aGlzCi1hdHRyaWJ1dGUgaXMgYWRkZWQgdG8gR2l0LCB0aGVuIEdpdCByZWVuY29kZXMgdGhlIGNvbnRlbnQgZnJvbSB0aGUKK2F0dHJpYnV0ZSBpcyBhZGRlZCB0byBHaXQsIHRoZW4gR2l0IHJlLWVuY29kZXMgdGhlIGNvbnRlbnQgZnJvbSB0aGUKIHNwZWNpZmllZCBlbmNvZGluZyB0byBVVEYtOC4gRmluYWxseSwgR2l0IHN0b3JlcyB0aGUgVVRGLTggZW5jb2RlZAogY29udGVudCBpbiBpdHMgaW50ZXJuYWwgZGF0YSBzdHJ1Y3R1cmUgKGNhbGxlZCAidGhlIGluZGV4IikuIE9uIGNoZWNrb3V0Ci10aGUgY29udGVudCBpcyByZWVuY29kZWQgYmFjayB0byB0aGUgc3BlY2lmaWVkIGVuY29kaW5nLgordGhlIGNvbnRlbnQgaXMgcmUtZW5jb2RlZCBiYWNrIHRvIHRoZSBzcGVjaWZpZWQgZW5jb2RpbmcuCiAKIFBsZWFzZSBub3RlIHRoYXQgdXNpbmcgdGhlIGB3b3JraW5nLXRyZWUtZW5jb2RpbmdgIGF0dHJpYnV0ZSBtYXkgaGF2ZSBhCiBudW1iZXIgb2YgcGl0ZmFsbHM6CkBAIC00OTgsNyArNDk4LDcgQEAKIFdoZW4gR2l0IGVuY291bnRlcnMgdGhlIGZpcnN0IGZpbGUgdGhhdCBuZWVkcyB0byBiZSBjbGVhbmVkIG9yIHNtdWRnZWQsCiBpdCBzdGFydHMgdGhlIGZpbHRlciBhbmQgcGVyZm9ybXMgdGhlIGhhbmRzaGFrZS4gSW4gdGhlIGhhbmRzaGFrZSwgdGhlCiB3ZWxjb21lIG1lc3NhZ2Ugc2VudCBieSBHaXQgaXMgImdpdC1maWx0ZXItY2xpZW50Iiwgb25seSB2ZXJzaW9uIDIgaXMKLXN1cHBwb3J0ZWQsIGFuZCB0aGUgc3VwcG9ydGVkIGNhcGFiaWxpdGllcyBhcmUgImNsZWFuIiwgInNtdWRnZSIsIGFuZAorc3VwcG9ydGVkLCBhbmQgdGhlIHN1cHBvcnRlZCBjYXBhYmlsaXRpZXMgYXJlICJjbGVhbiIsICJzbXVkZ2UiLCBhbmQKICJkZWxheSIuCiAKIEFmdGVyd2FyZHMgR2l0IHNlbmRzIGEgbGlzdCBvZiAia2V5PXZhbHVlIiBwYWlycyB0ZXJtaW5hdGVkIHdpdGgKQEAgLTgxMCw2ICs4MTAsMTAgQEAKIAogLSBgY3NzYCBzdWl0YWJsZSBmb3IgY2FzY2FkaW5nIHN0eWxlIHNoZWV0cy4KIAorLSBgZHRzYCBzdWl0YWJsZSBmb3IgZGV2aWNldHJlZSAoRFRTKSBmaWxlcy4KKworLSBgZWxpeGlyYCBzdWl0YWJsZSBmb3Igc291cmNlIGNvZGUgaW4gdGhlIEVsaXhpciBsYW5ndWFnZS4KKwogLSBgZm9ydHJhbmAgc3VpdGFibGUgZm9yIHNvdXJjZSBjb2RlIGluIHRoZSBGb3J0cmFuIGxhbmd1YWdlLgogCiAtIGBmb3VudGFpbmAgc3VpdGFibGUgZm9yIEZvdW50YWluIGRvY3VtZW50cy4KZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vZ2l0Y2xpLnR4dCBiL0RvY3VtZW50YXRpb24vZ2l0Y2xpLnR4dAppbmRleCAxZWQzY2EzLi40YjMyODc2IDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2dpdGNsaS50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9naXRjbGkudHh0CkBAIC0zNyw2ICszNywxMiBAQAogICAgZmlsZSBjYWxsZWQgSEVBRCBpbiB5b3VyIHdvcmsgdHJlZSwgYGdpdCBkaWZmIEhFQURgIGlzIGFtYmlndW91cywgYW5kCiAgICB5b3UgaGF2ZSB0byBzYXkgZWl0aGVyIGBnaXQgZGlmZiBIRUFEIC0tYCBvciBgZ2l0IGRpZmYgLS0gSEVBRGAgdG8KICAgIGRpc2FtYmlndWF0ZS4KKworICogQmVjYXVzZSBgLS1gIGRpc2FtYmlndWF0ZXMgcmV2aXNpb25zIGFuZCBwYXRocyBpbiBzb21lIGNvbW1hbmRzLCBpdAorICAgY2Fubm90IGJlIHVzZWQgZm9yIHRob3NlIGNvbW1hbmRzIHRvIHNlcGFyYXRlIG9wdGlvbnMgYW5kIHJldmlzaW9ucy4KKyAgIFlvdSBjYW4gdXNlIGAtLWVuZC1vZi1vcHRpb25zYCBmb3IgdGhpcyAoaXQgYWxzbyB3b3JrcyBmb3IgY29tbWFuZHMKKyAgIHRoYXQgZG8gbm90IGRpc3Rpbmd1aXNoIGJldHdlZW4gcmV2aXNpb25zIGluIHBhdGhzLCBpbiB3aGljaCBjYXNlIGl0CisgICBpcyBzaW1wbHkgYW4gYWxpYXMgZm9yIGAtLWApLgogKwogV2hlbiB3cml0aW5nIGEgc2NyaXB0IHRoYXQgaXMgZXhwZWN0ZWQgdG8gaGFuZGxlIHJhbmRvbSB1c2VyLWlucHV0LCBpdCBpcwogYSBnb29kIHByYWN0aWNlIHRvIG1ha2UgaXQgZXhwbGljaXQgd2hpY2ggYXJndW1lbnRzIGFyZSB3aGljaCBieSBwbGFjaW5nCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2dpdGhvb2tzLnR4dCBiL0RvY3VtZW50YXRpb24vZ2l0aG9va3MudHh0CmluZGV4IDgyY2Q1NzMuLjUwMzY1ZjIgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vZ2l0aG9va3MudHh0CisrKyBiL0RvY3VtZW50YXRpb24vZ2l0aG9va3MudHh0CkBAIC0xMDMsNiArMTAzLDI4IEBACiBgaG9va3MuYWxsb3dub25hc2NpaWAgY29uZmlnIG9wdGlvbiB1bnNldCBvciBzZXQgdG8gZmFsc2UtLXByZXZlbnRzCiB0aGUgdXNlIG9mIG5vbi1BU0NJSSBmaWxlbmFtZXMuCiAKK3ByZS1tZXJnZS1jb21taXQKK35+fn5+fn5+fn5+fn5+fn4KKworVGhpcyBob29rIGlzIGludm9rZWQgYnkgbGlua2dpdDpnaXQtbWVyZ2VbMV0sIGFuZCBjYW4gYmUgYnlwYXNzZWQKK3dpdGggdGhlIGAtLW5vLXZlcmlmeWAgb3B0aW9uLiAgSXQgdGFrZXMgbm8gcGFyYW1ldGVycywgYW5kIGlzCitpbnZva2VkIGFmdGVyIHRoZSBtZXJnZSBoYXMgYmVlbiBjYXJyaWVkIG91dCBzdWNjZXNzZnVsbHkgYW5kIGJlZm9yZQorb2J0YWluaW5nIHRoZSBwcm9wb3NlZCBjb21taXQgbG9nIG1lc3NhZ2UgdG8KK21ha2UgYSBjb21taXQuICBFeGl0aW5nIHdpdGggYSBub24temVybyBzdGF0dXMgZnJvbSB0aGlzIHNjcmlwdAorY2F1c2VzIHRoZSBgZ2l0IG1lcmdlYCBjb21tYW5kIHRvIGFib3J0IGJlZm9yZSBjcmVhdGluZyBhIGNvbW1pdC4KKworVGhlIGRlZmF1bHQgJ3ByZS1tZXJnZS1jb21taXQnIGhvb2ssIHdoZW4gZW5hYmxlZCwgcnVucyB0aGUKKydwcmUtY29tbWl0JyBob29rLCBpZiB0aGUgbGF0dGVyIGlzIGVuYWJsZWQuCisKK1RoaXMgaG9vayBpcyBpbnZva2VkIHdpdGggdGhlIGVudmlyb25tZW50IHZhcmlhYmxlCitgR0lUX0VESVRPUj06YCBpZiB0aGUgY29tbWFuZCB3aWxsIG5vdCBicmluZyB1cCBhbiBlZGl0b3IKK3RvIG1vZGlmeSB0aGUgY29tbWl0IG1lc3NhZ2UuCisKK0lmIHRoZSBtZXJnZSBjYW5ub3QgYmUgY2FycmllZCBvdXQgYXV0b21hdGljYWxseSwgdGhlIGNvbmZsaWN0cworbmVlZCB0byBiZSByZXNvbHZlZCBhbmQgdGhlIHJlc3VsdCBjb21taXR0ZWQgc2VwYXJhdGVseSAoc2VlCitsaW5rZ2l0OmdpdC1tZXJnZVsxXSkuIEF0IHRoYXQgcG9pbnQsIHRoaXMgaG9vayB3aWxsIG5vdCBiZSBleGVjdXRlZCwKK2J1dCB0aGUgJ3ByZS1jb21taXQnIGhvb2sgd2lsbCwgaWYgaXQgaXMgZW5hYmxlZC4KKwogcHJlcGFyZS1jb21taXQtbXNnCiB+fn5+fn5+fn5+fn5+fn5+fn4KIApAQCAtNDI1LDEwICs0NDcsMTIgQEAKIAogVGhpcyBob29rIGlzIGludm9rZWQgYnkgY29tbWFuZHMgdGhhdCByZXdyaXRlIGNvbW1pdHMKIChsaW5rZ2l0OmdpdC1jb21taXRbMV0gd2hlbiBjYWxsZWQgd2l0aCBgLS1hbWVuZGAgYW5kCi1saW5rZ2l0OmdpdC1yZWJhc2VbMV07IGN1cnJlbnRseSBgZ2l0IGZpbHRlci1icmFuY2hgIGRvZXMgJ25vdCcgY2FsbAotaXQhKS4gIEl0cyBmaXJzdCBhcmd1bWVudCBkZW5vdGVzIHRoZSBjb21tYW5kIGl0IHdhcyBpbnZva2VkIGJ5OgotY3VycmVudGx5IG9uZSBvZiBgYW1lbmRgIG9yIGByZWJhc2VgLiAgRnVydGhlciBjb21tYW5kLWRlcGVuZGVudAotYXJndW1lbnRzIG1heSBiZSBwYXNzZWQgaW4gdGhlIGZ1dHVyZS4KK2xpbmtnaXQ6Z2l0LXJlYmFzZVsxXTsgaG93ZXZlciwgZnVsbC1oaXN0b3J5IChyZSl3cml0aW5nIHRvb2xzIGxpa2UKK2xpbmtnaXQ6Z2l0LWZhc3QtaW1wb3J0WzFdIG9yCitodHRwczovL2dpdGh1Yi5jb20vbmV3cmVuL2dpdC1maWx0ZXItcmVwb1tnaXQtZmlsdGVyLXJlcG9dIHR5cGljYWxseQorZG8gbm90IGNhbGwgaXQhKS4gIEl0cyBmaXJzdCBhcmd1bWVudCBkZW5vdGVzIHRoZSBjb21tYW5kIGl0IHdhcworaW52b2tlZCBieTogY3VycmVudGx5IG9uZSBvZiBgYW1lbmRgIG9yIGByZWJhc2VgLiAgRnVydGhlcgorY29tbWFuZC1kZXBlbmRlbnQgYXJndW1lbnRzIG1heSBiZSBwYXNzZWQgaW4gdGhlIGZ1dHVyZS4KIAogVGhlIGhvb2sgcmVjZWl2ZXMgYSBsaXN0IG9mIHRoZSByZXdyaXR0ZW4gY29tbWl0cyBvbiBzdGRpbiwgaW4gdGhlCiBmb3JtYXQKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vZ2l0bW9kdWxlcy50eHQgYi9Eb2N1bWVudGF0aW9uL2dpdG1vZHVsZXMudHh0CmluZGV4IGE2NmU5NWIuLjk1M2MzODcgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vZ2l0bW9kdWxlcy50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9naXRtb2R1bGVzLnR4dApAQCAtODEsNyArODEsNyBAQAogCSAgICBDb21taXR0ZWQgZGlmZmVyZW5jZXMgYW5kIG1vZGlmaWNhdGlvbnMgdG8gdHJhY2tlZCBmaWxlcyB3aWxsIHNob3cKIAkgICAgdXAuCiAKLQlub25lOzsgTm8gbW9kaWZpYXRpb25zIHRvIHN1Ym1vZHVsZXMgYXJlIGlnbm9yZWQsIGFsbCBvZiBjb21taXR0ZWQKKwlub25lOzsgTm8gbW9kaWZpY2F0aW9ucyB0byBzdWJtb2R1bGVzIGFyZSBpZ25vcmVkLCBhbGwgb2YgY29tbWl0dGVkCiAJICAgIGRpZmZlcmVuY2VzLCBhbmQgbW9kaWZpY2F0aW9ucyB0byB0cmFja2VkIGFuZCB1bnRyYWNrZWQgZmlsZXMgYXJlCiAJICAgIHNob3duLiBUaGlzIGlzIHRoZSBkZWZhdWx0IG9wdGlvbi4KIApAQCAtOTAsNyArOTAsNyBAQAogLmdpdG1vZHVsZXMuCiAKIEJvdGggc2V0dGluZ3MgY2FuIGJlIG92ZXJyaWRkZW4gb24gdGhlIGNvbW1hbmQgbGluZSBieSB1c2luZyB0aGUKLSItLWlnbm9yZS1zdWJtb2R1bGUiIG9wdGlvbi4gVGhlICdnaXQgc3VibW9kdWxlJyBjb21tYW5kcyBhcmUgbm90CisiLS1pZ25vcmUtc3VibW9kdWxlcyIgb3B0aW9uLiBUaGUgJ2dpdCBzdWJtb2R1bGUnIGNvbW1hbmRzIGFyZSBub3QKIGFmZmVjdGVkIGJ5IHRoaXMgc2V0dGluZy4KIC0tCiAKQEAgLTEwNSwxNCArMTA1LDE1IEBACiAKIENvbnNpZGVyIHRoZSBmb2xsb3dpbmcgLmdpdG1vZHVsZXMgZmlsZToKIAotCVtzdWJtb2R1bGUgImxpYmZvbyJdCi0JCXBhdGggPSBpbmNsdWRlL2ZvbwotCQl1cmwgPSBnaXQ6Ly9mb28uY29tL2dpdC9saWIuZ2l0CistLS0tCitbc3VibW9kdWxlICJsaWJmb28iXQorCXBhdGggPSBpbmNsdWRlL2ZvbworCXVybCA9IGdpdDovL2Zvby5jb20vZ2l0L2xpYi5naXQKIAotCVtzdWJtb2R1bGUgImxpYmJhciJdCi0JCXBhdGggPSBpbmNsdWRlL2JhcgotCQl1cmwgPSBnaXQ6Ly9iYXIuY29tL2dpdC9saWIuZ2l0Ci0KK1tzdWJtb2R1bGUgImxpYmJhciJdCisJcGF0aCA9IGluY2x1ZGUvYmFyCisJdXJsID0gZ2l0Oi8vYmFyLmNvbS9naXQvbGliLmdpdAorLS0tLQogCiBUaGlzIGRlZmluZXMgdHdvIHN1Ym1vZHVsZXMsIGBsaWJmb29gIGFuZCBgbGliYmFyYC4gVGhlc2UgYXJlIGV4cGVjdGVkIHRvCiBiZSBjaGVja2VkIG91dCBpbiB0aGUgcGF0aHMgYGluY2x1ZGUvZm9vYCBhbmQgYGluY2x1ZGUvYmFyYCwgYW5kIGZvciBib3RoCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2dpdHJlbW90ZS1oZWxwZXJzLnR4dCBiL0RvY3VtZW50YXRpb24vZ2l0cmVtb3RlLWhlbHBlcnMudHh0CmluZGV4IDQzZjgwYzguLmY0OGEwMzEgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vZ2l0cmVtb3RlLWhlbHBlcnMudHh0CisrKyBiL0RvY3VtZW50YXRpb24vZ2l0cmVtb3RlLWhlbHBlcnMudHh0CkBAIC0yOTcsOSArMjk3LDEzIEBACiAJc2FtZSBiYXRjaCBhcmUgY29tcGxldGUuIE9ubHkgb2JqZWN0cyB3aGljaCB3ZXJlIHJlcG9ydGVkCiAJaW4gdGhlIG91dHB1dCBvZiAnbGlzdCcgd2l0aCBhIHNoYTEgbWF5IGJlIGZldGNoZWQgdGhpcyB3YXkuCiArCi1PcHRpb25hbGx5IG1heSBvdXRwdXQgYSAnbG9jayA8ZmlsZT4nIGxpbmUgaW5kaWNhdGluZyBhIGZpbGUgdW5kZXIKLUdJVF9ESVIvb2JqZWN0cy9wYWNrIHdoaWNoIGlzIGtlZXBpbmcgYSBwYWNrIHVudGlsIHJlZnMgY2FuIGJlCi1zdWl0YWJseSB1cGRhdGVkLgorT3B0aW9uYWxseSBtYXkgb3V0cHV0IGEgJ2xvY2sgPGZpbGU+JyBsaW5lIGluZGljYXRpbmcgdGhlIGZ1bGwgcGF0aCBvZgorYSBmaWxlIHVuZGVyIGAkR0lUX0RJUi9vYmplY3RzL3BhY2tgIHdoaWNoIGlzIGtlZXBpbmcgYSBwYWNrIHVudGlsCityZWZzIGNhbiBiZSBzdWl0YWJseSB1cGRhdGVkLiAgVGhlIHBhdGggbXVzdCBlbmQgd2l0aCBgLmtlZXBgLiBUaGlzIGlzCithIG1lY2hhbmlzbSB0byBuYW1lIGEgPHBhY2ssaWR4LGtlZXA+IHR1cGxlIGJ5IGdpdmluZyBvbmx5IHRoZSBrZWVwCitjb21wb25lbnQuICBUaGUga2VwdCBwYWNrIHdpbGwgbm90IGJlIGRlbGV0ZWQgYnkgYSBjb25jdXJyZW50IHJlcGFjaywKK2V2ZW4gdGhvdWdoIGl0cyBvYmplY3RzIG1heSBub3QgYmUgcmVmZXJlbmNlZCB1bnRpbCB0aGUgZmV0Y2ggY29tcGxldGVzLgorVGhlIGAua2VlcGAgZmlsZSB3aWxsIGJlIGRlbGV0ZWQgYXQgdGhlIGNvbmNsdXNpb24gb2YgdGhlIGZldGNoLgogKwogSWYgb3B0aW9uICdjaGVjay1jb25uZWN0aXZpdHknIGlzIHJlcXVlc3RlZCwgdGhlIGhlbHBlciBtdXN0IG91dHB1dAogJ2Nvbm5lY3Rpdml0eS1vaycgaWYgdGhlIGNsb25lIGlzIHNlbGYtY29udGFpbmVkIGFuZCBjb25uZWN0ZWQuCkBAIC01MDUsNiArNTA5LDExIEBACiAJSW5kaWNhdGUgdGhhdCBvbmx5IHRoZSBvYmplY3RzIHdhbnRlZCBuZWVkIHRvIGJlIGZldGNoZWQsIG5vdAogCXRoZWlyIGRlcGVuZGVudHMuCiAKKydvcHRpb24gYXRvbWljJyB7J3RydWUnfCdmYWxzZSd9OjoKKwlXaGVuIHB1c2hpbmcsIHJlcXVlc3QgdGhlIHJlbW90ZSBzZXJ2ZXIgdG8gdXBkYXRlIHJlZnMgaW4gYSBzaW5nbGUgYXRvbWljCisJdHJhbnNhY3Rpb24uICBJZiBzdWNjZXNzZnVsLCBhbGwgcmVmcyB3aWxsIGJlIHVwZGF0ZWQsIG9yIG5vbmUgd2lsbC4gIElmIHRoZQorCXJlbW90ZSBzaWRlIGRvZXMgbm90IHN1cHBvcnQgdGhpcyBjYXBhYmlsaXR5LCB0aGUgcHVzaCB3aWxsIGZhaWwuCisKIFNFRSBBTFNPCiAtLS0tLS0tLQogbGlua2dpdDpnaXQtcmVtb3RlWzFdCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2dpdHJlcG9zaXRvcnktbGF5b3V0LnR4dCBiL0RvY3VtZW50YXRpb24vZ2l0cmVwb3NpdG9yeS1sYXlvdXQudHh0CmluZGV4IDIxNmIxMWUuLjFhMmVmNGMgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vZ2l0cmVwb3NpdG9yeS1sYXlvdXQudHh0CisrKyBiL0RvY3VtZW50YXRpb24vZ2l0cmVwb3NpdG9yeS1sYXlvdXQudHh0CkBAIC01OSw3ICs1OSw3IEBACiAJaGVyZSBhcmUgb2Z0ZW4gY2FsbGVkICd1bnBhY2tlZCcgKG9yICdsb29zZScpIG9iamVjdHMuCiAKIG9iamVjdHMvcGFjazo6Ci0JUGFja3MgKGZpbGVzIHRoYXQgc3RvcmUgbWFueSBvYmplY3QgaW4gY29tcHJlc3NlZCBmb3JtLAorCVBhY2tzIChmaWxlcyB0aGF0IHN0b3JlIG1hbnkgb2JqZWN0cyBpbiBjb21wcmVzc2VkIGZvcm0sCiAJYWxvbmcgd2l0aCBpbmRleCBmaWxlcyB0byBhbGxvdyB0aGVtIHRvIGJlIHJhbmRvbWx5CiAJYWNjZXNzZWQpIGFyZSBmb3VuZCBpbiB0aGlzIGRpcmVjdG9yeS4KIApAQCAtOTYsOSArOTYsOSBAQAogCWRpcmVjdG9yeS4gIFRoZSAnZ2l0IHBydW5lJyBjb21tYW5kIGtub3dzIHRvIHByZXNlcnZlCiAJb2JqZWN0cyByZWFjaGFibGUgZnJvbSByZWZzIGZvdW5kIGluIHRoaXMgZGlyZWN0b3J5IGFuZAogCWl0cyBzdWJkaXJlY3Rvcmllcy4KLQlUaGlzIGRpcmVjdG9yeSBpcyBpZ25vcmVkIChleGNlcHQgcmVmcy9iaXNlY3QgYW5kCi0JcmVmcy93b3JrdHJlZSkgaWYgJEdJVF9DT01NT05fRElSIGlzIHNldCBhbmQKLQkiJEdJVF9DT01NT05fRElSL3JlZnMiIHdpbGwgYmUgdXNlZCBpbnN0ZWFkLgorCVRoaXMgZGlyZWN0b3J5IGlzIGlnbm9yZWQgKGV4Y2VwdCByZWZzL2Jpc2VjdCwKKwlyZWZzL3Jld3JpdHRlbiBhbmQgcmVmcy93b3JrdHJlZSkgaWYgJEdJVF9DT01NT05fRElSIGlzCisJc2V0IGFuZCAiJEdJVF9DT01NT05fRElSL3JlZnMiIHdpbGwgYmUgdXNlZCBpbnN0ZWFkLgogCiByZWZzL2hlYWRzL2BuYW1lYDo6CiAJcmVjb3JkcyB0aXAtb2YtdGhlLXRyZWUgY29tbWl0IG9iamVjdHMgb2YgYnJhbmNoIGBuYW1lYApAQCAtMjQwLDggKzI0MCw4IEBACiBsb2dzOjoKIAlSZWNvcmRzIG9mIGNoYW5nZXMgbWFkZSB0byByZWZzIGFyZSBzdG9yZWQgaW4gdGhpcyBkaXJlY3RvcnkuCiAJU2VlIGxpbmtnaXQ6Z2l0LXVwZGF0ZS1yZWZbMV0gZm9yIG1vcmUgaW5mb3JtYXRpb24uIFRoaXMKLQlkaXJlY3RvcnkgaXMgaWdub3JlZCBpZiAkR0lUX0NPTU1PTl9ESVIgaXMgc2V0IGFuZAotCSIkR0lUX0NPTU1PTl9ESVIvbG9ncyIgd2lsbCBiZSB1c2VkIGluc3RlYWQuCisJZGlyZWN0b3J5IGlzIGlnbm9yZWQgKGV4Y2VwdCBsb2dzL0hFQUQpIGlmICRHSVRfQ09NTU9OX0RJUiBpcworCXNldCBhbmQgIiRHSVRfQ09NTU9OX0RJUi9sb2dzIiB3aWxsIGJlIHVzZWQgaW5zdGVhZC4KIAogbG9ncy9yZWZzL2hlYWRzL2BuYW1lYDo6CiAJUmVjb3JkcyBhbGwgY2hhbmdlcyBtYWRlIHRvIHRoZSBicmFuY2ggdGlwIG5hbWVkIGBuYW1lYC4KZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vZ2l0c3VibW9kdWxlcy50eHQgYi9Eb2N1bWVudGF0aW9uL2dpdHN1Ym1vZHVsZXMudHh0CmluZGV4IDBhODkwMjAuLmM0NzZmODkgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vZ2l0c3VibW9kdWxlcy50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9naXRzdWJtb2R1bGVzLnR4dApAQCAtMyw3ICszLDcgQEAKIAogTkFNRQogLS0tLQotZ2l0c3VibW9kdWxlcyAtIG1vdW50aW5nIG9uZSByZXBvc2l0b3J5IGluc2lkZSBhbm90aGVyCitnaXRzdWJtb2R1bGVzIC0gTW91bnRpbmcgb25lIHJlcG9zaXRvcnkgaW5zaWRlIGFub3RoZXIKIAogU1lOT1BTSVMKIC0tLS0tLS0tCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2dpdHdlYi5jb25mLnR4dCBiL0RvY3VtZW50YXRpb24vZ2l0d2ViLmNvbmYudHh0CmluZGV4IDM1MzE3ZTcuLjc5NjNhNzkgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vZ2l0d2ViLmNvbmYudHh0CisrKyBiL0RvY3VtZW50YXRpb24vZ2l0d2ViLmNvbmYudHh0CkBAIC03ODYsOSArNzg2LDkgQEAKIAlzdWJkaXJlY3RvcmllcyBvZiBwcm9qZWN0IHJvb3QgKGJhc2VuYW1lKSB0byBiZSBmb3JrcyBvZiBleGlzdGluZwogCXByb2plY3RzLiAgRm9yIGVhY2ggcHJvamVjdCArJHByb2puYW1lLmdpdCssIHByb2plY3RzIGluIHRoZQogCSskcHJvam5hbWUvKyBkaXJlY3RvcnkgYW5kIGl0cyBzdWJkaXJlY3RvcmllcyB3aWxsIG5vdCBiZQotCXNob3duIGluIHRoZSBtYWluIHByb2plY3RzIGxpc3QuICBJbnN0ZWFkLCBhIFwnXCsnIG1hcmsgaXMgc2hvd24KLQluZXh0IHRvICskcHJvam5hbWUrLCB3aGljaCBsaW5rcyB0byBhICJmb3JrcyIgdmlldyB0aGF0IGxpc3RzIGFsbAotCXRoZSBmb3JrcyAoYWxsIHByb2plY3RzIGluICskcHJvam5hbWUvKyBzdWJkaXJlY3RvcnkpLiAgQWRkaXRpb25hbGx5CisJc2hvd24gaW4gdGhlIG1haW4gcHJvamVjdHMgbGlzdC4gIEluc3RlYWQsIGEgXCcrJyBtYXJrIGlzIHNob3duCisJbmV4dCB0byBgJHByb2puYW1lYCwgd2hpY2ggbGlua3MgdG8gYSAiZm9ya3MiIHZpZXcgdGhhdCBsaXN0cyBhbGwKKwl0aGUgZm9ya3MgKGFsbCBwcm9qZWN0cyBpbiBgJHByb2puYW1lL2Agc3ViZGlyZWN0b3J5KS4gIEFkZGl0aW9uYWxseQogCWEgImZvcmtzIiB2aWV3IGZvciBhIHByb2plY3QgaXMgbGlua2VkIGZyb20gcHJvamVjdCBzdW1tYXJ5IHBhZ2UuCiArCiBJZiB0aGUgcHJvamVjdCBsaXN0IGlzIHRha2VuIGZyb20gYSBmaWxlICgrJHByb2plY3RzX2xpc3QrIHBvaW50cyB0byBhCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2hvd3RvL3NlcGFyYXRpbmctdG9waWMtYnJhbmNoZXMudHh0IGIvRG9jdW1lbnRhdGlvbi9ob3d0by9zZXBhcmF0aW5nLXRvcGljLWJyYW5jaGVzLnR4dAppbmRleCBiZDEwMjc0Li44MWJlMGQ2IDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2hvd3RvL3NlcGFyYXRpbmctdG9waWMtYnJhbmNoZXMudHh0CisrKyBiL0RvY3VtZW50YXRpb24vaG93dG8vc2VwYXJhdGluZy10b3BpYy1icmFuY2hlcy50eHQKQEAgLTgxLDcgKzgxLDcgQEAKICAgICAgICAgICAgICAgby0tLW8tLS1vLS0tby0tLW8tLS1vCiAKIFRoZSBsYXN0IGRpZmYgYmV0dGVyIG5vdCB0byBzaG93IGFueXRoaW5nIG90aGVyIHRoYW4gY2xlYW51cHMKLWZvciBjcnVmdHMuICBUaGVuIEkgY2FuIGZpbmFsbHkgY2xlYW4gdGhpbmdzIHVwOgorZm9yIGNydWZ0LiAgVGhlbiBJIGNhbiBmaW5hbGx5IGNsZWFuIHRoaW5ncyB1cDoKIAogICAgICAgICAkIGdpdCBicmFuY2ggLUQgdG9waWMKICAgICAgICAgJCBnaXQgcmVzZXQgLS1oYXJkIEhFQUReIDsjIG51a2UgcHJldGVuZCBtZXJnZQpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9tYW5wYWdlLWJvbGQtbGl0ZXJhbC54c2wgYi9Eb2N1bWVudGF0aW9uL21hbnBhZ2UtYm9sZC1saXRlcmFsLnhzbAppbmRleCA2MDhlYjVkLi45NGQ2YzFiIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL21hbnBhZ2UtYm9sZC1saXRlcmFsLnhzbAorKysgYi9Eb2N1bWVudGF0aW9uL21hbnBhZ2UtYm9sZC1saXRlcmFsLnhzbApAQCAtMSwxMiArMSwxMyBAQAogPCEtLSBtYW5wYWdlLWJvbGQtbGl0ZXJhbC54c2w6CiAgICAgIHNwZWNpYWwgZm9ybWF0dGluZyBmb3IgbWFucGFnZXMgcmVuZGVyZWQgZnJvbSBhc2NpaWRvYytkb2Nib29rIC0tPgogPHhzbDpzdHlsZXNoZWV0IHhtbG5zOnhzbD0iaHR0cDovL3d3dy53My5vcmcvMTk5OS9YU0wvVHJhbnNmb3JtIgorCQl4bWxuczpkPSJodHRwOi8vZG9jYm9vay5vcmcvbnMvZG9jYm9vayIKIAkJdmVyc2lvbj0iMS4wIj4KIAogPCEtLSByZW5kZXIgbGl0ZXJhbCB0ZXh0IGFzIGJvbGQgKGluc3RlYWQgb2YgcGxhaW4gb3IgbW9ub3NwYWNlKTsKICAgICAgdGhpcyBtYWtlcyBsaXRlcmFsIHRleHQgZWFzaWVyIHRvIGRpc3Rpbmd1aXNoIGluIG1hbnBhZ2VzCiAgICAgIHZpZXdlZCBvbiBhIHR0eSAtLT4KLTx4c2w6dGVtcGxhdGUgbWF0Y2g9ImxpdGVyYWwiPgorPHhzbDp0ZW1wbGF0ZSBtYXRjaD0ibGl0ZXJhbHxkOmxpdGVyYWwiPgogCTx4c2w6dmFsdWUtb2Ygc2VsZWN0PSIkZ2l0LmRvY2Jvb2suYmFja3NsYXNoIi8+CiAJPHhzbDp0ZXh0PmZCPC94c2w6dGV4dD4KIAk8eHNsOmFwcGx5LXRlbXBsYXRlcy8+CmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL21hbnBhZ2UueHNsIGIvRG9jdW1lbnRhdGlvbi9tYW5wYWdlLnhzbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5lZjY0YmFiCi0tLSAvZGV2L251bGwKKysrIGIvRG9jdW1lbnRhdGlvbi9tYW5wYWdlLnhzbApAQCAtMCwwICsxLDMgQEAKKzx4c2w6c3R5bGVzaGVldCB4bWxuczp4c2w9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkvWFNML1RyYW5zZm9ybSIgdmVyc2lvbj0iMS4wIj4KKwk8eHNsOmltcG9ydCBocmVmPSJodHRwOi8vZG9jYm9vay5zb3VyY2Vmb3JnZS5uZXQvcmVsZWFzZS94c2wtbnMvY3VycmVudC9tYW5wYWdlcy9kb2Nib29rLnhzbCIgLz4KKzwveHNsOnN0eWxlc2hlZXQ+CmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL21lcmdlLW9wdGlvbnMudHh0IGIvRG9jdW1lbnRhdGlvbi9tZXJnZS1vcHRpb25zLnR4dAppbmRleCA3OWEwMGQyLi40MGRjNGY1IDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL21lcmdlLW9wdGlvbnMudHh0CisrKyBiL0RvY3VtZW50YXRpb24vbWVyZ2Utb3B0aW9ucy50eHQKQEAgLTM0LDI2ICszNCwzMCBAQAogCiAtLWNsZWFudXA9PG1vZGU+OjoKIAlUaGlzIG9wdGlvbiBkZXRlcm1pbmVzIGhvdyB0aGUgbWVyZ2UgbWVzc2FnZSB3aWxsIGJlIGNsZWFuZWQgdXAgYmVmb3JlCi0JY29tbWl0aW5nLiBTZWUgbGlua2dpdDpnaXQtY29tbWl0WzFdIGZvciBtb3JlIGRldGFpbHMuIEluIGFkZGl0aW9uLCBpZgorCWNvbW1pdHRpbmcuIFNlZSBsaW5rZ2l0OmdpdC1jb21taXRbMV0gZm9yIG1vcmUgZGV0YWlscy4gSW4gYWRkaXRpb24sIGlmCiAJdGhlICc8bW9kZT4nIGlzIGdpdmVuIGEgdmFsdWUgb2YgYHNjaXNzb3JzYCwgc2Npc3NvcnMgd2lsbCBiZSBhcHBlbmRlZAogCXRvIGBNRVJHRV9NU0dgIGJlZm9yZSBiZWluZyBwYXNzZWQgb24gdG8gdGhlIGNvbW1pdCBtYWNoaW5lcnkgaW4gdGhlCiAJY2FzZSBvZiBhIG1lcmdlIGNvbmZsaWN0LgogCiAtLWZmOjoKLQlXaGVuIHRoZSBtZXJnZSByZXNvbHZlcyBhcyBhIGZhc3QtZm9yd2FyZCwgb25seSB1cGRhdGUgdGhlIGJyYW5jaAotCXBvaW50ZXIsIHdpdGhvdXQgY3JlYXRpbmcgYSBtZXJnZSBjb21taXQuICBUaGlzIGlzIHRoZSBkZWZhdWx0Ci0JYmVoYXZpb3IuCi0KIC0tbm8tZmY6OgotCUNyZWF0ZSBhIG1lcmdlIGNvbW1pdCBldmVuIHdoZW4gdGhlIG1lcmdlIHJlc29sdmVzIGFzIGEKLQlmYXN0LWZvcndhcmQuICBUaGlzIGlzIHRoZSBkZWZhdWx0IGJlaGF2aW91ciB3aGVuIG1lcmdpbmcgYW4KLQlhbm5vdGF0ZWQgKGFuZCBwb3NzaWJseSBzaWduZWQpIHRhZyB0aGF0IGlzIG5vdCBzdG9yZWQgaW4KLQlpdHMgbmF0dXJhbCBwbGFjZSBpbiAncmVmcy90YWdzLycgaGllcmFyY2h5LgotCiAtLWZmLW9ubHk6OgotCVJlZnVzZSB0byBtZXJnZSBhbmQgZXhpdCB3aXRoIGEgbm9uLXplcm8gc3RhdHVzIHVubGVzcyB0aGUKLQljdXJyZW50IGBIRUFEYCBpcyBhbHJlYWR5IHVwIHRvIGRhdGUgb3IgdGhlIG1lcmdlIGNhbiBiZQotCXJlc29sdmVkIGFzIGEgZmFzdC1mb3J3YXJkLgorCVNwZWNpZmllcyBob3cgYSBtZXJnZSBpcyBoYW5kbGVkIHdoZW4gdGhlIG1lcmdlZC1pbiBoaXN0b3J5IGlzCisJYWxyZWFkeSBhIGRlc2NlbmRhbnQgb2YgdGhlIGN1cnJlbnQgaGlzdG9yeS4gIGAtLWZmYCBpcyB0aGUKKwlkZWZhdWx0IHVubGVzcyBtZXJnaW5nIGFuIGFubm90YXRlZCAoYW5kIHBvc3NpYmx5IHNpZ25lZCkgdGFnCisJdGhhdCBpcyBub3Qgc3RvcmVkIGluIGl0cyBuYXR1cmFsIHBsYWNlIGluIHRoZSBgcmVmcy90YWdzL2AKKwloaWVyYXJjaHksIGluIHdoaWNoIGNhc2UgYC0tbm8tZmZgIGlzIGFzc3VtZWQuCisrCitXaXRoIGAtLWZmYCwgd2hlbiBwb3NzaWJsZSByZXNvbHZlIHRoZSBtZXJnZSBhcyBhIGZhc3QtZm9yd2FyZCAob25seQordXBkYXRlIHRoZSBicmFuY2ggcG9pbnRlciB0byBtYXRjaCB0aGUgbWVyZ2VkIGJyYW5jaDsgZG8gbm90IGNyZWF0ZSBhCittZXJnZSBjb21taXQpLiAgV2hlbiBub3QgcG9zc2libGUgKHdoZW4gdGhlIG1lcmdlZC1pbiBoaXN0b3J5IGlzIG5vdCBhCitkZXNjZW5kYW50IG9mIHRoZSBjdXJyZW50IGhpc3RvcnkpLCBjcmVhdGUgYSBtZXJnZSBjb21taXQuCisrCitXaXRoIGAtLW5vLWZmYCwgY3JlYXRlIGEgbWVyZ2UgY29tbWl0IGluIGFsbCBjYXNlcywgZXZlbiB3aGVuIHRoZSBtZXJnZQorY291bGQgaW5zdGVhZCBiZSByZXNvbHZlZCBhcyBhIGZhc3QtZm9yd2FyZC4KKysKK1dpdGggYC0tZmYtb25seWAsIHJlc29sdmUgdGhlIG1lcmdlIGFzIGEgZmFzdC1mb3J3YXJkIHdoZW4gcG9zc2libGUuCitXaGVuIG5vdCBwb3NzaWJsZSwgcmVmdXNlIHRvIG1lcmdlIGFuZCBleGl0IHdpdGggYSBub24temVybyBzdGF0dXMuCiAKIC1TWzxrZXlpZD5dOjoKIC0tZ3BnLXNpZ25bPTxrZXlpZD5dOjoKQEAgLTEwNSw2ICsxMDksMTAgQEAKICsKIFdpdGggLS1zcXVhc2gsIC0tY29tbWl0IGlzIG5vdCBhbGxvd2VkLCBhbmQgd2lsbCBmYWlsLgogCistLW5vLXZlcmlmeTo6CisJVGhpcyBvcHRpb24gYnlwYXNzZXMgdGhlIHByZS1tZXJnZSBhbmQgY29tbWl0LW1zZyBob29rcy4KKwlTZWUgYWxzbyBsaW5rZ2l0OmdpdGhvb2tzWzVdLgorCiAtcyA8c3RyYXRlZ3k+OjoKIC0tc3RyYXRlZ3k9PHN0cmF0ZWd5Pjo6CiAJVXNlIHRoZSBnaXZlbiBtZXJnZSBzdHJhdGVneTsgY2FuIGJlIHN1cHBsaWVkIG1vcmUgdGhhbgpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9tZXJnZS1zdHJhdGVnaWVzLnR4dCBiL0RvY3VtZW50YXRpb24vbWVyZ2Utc3RyYXRlZ2llcy50eHQKaW5kZXggYWE2NmNiZS4uMjkxMmRlNyAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9tZXJnZS1zdHJhdGVnaWVzLnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL21lcmdlLXN0cmF0ZWdpZXMudHh0CkBAIC0zMiw3ICszMiw3IEBACiBvdXJzOzsKIAlUaGlzIG9wdGlvbiBmb3JjZXMgY29uZmxpY3RpbmcgaHVua3MgdG8gYmUgYXV0by1yZXNvbHZlZCBjbGVhbmx5IGJ5CiAJZmF2b3JpbmcgJ291cicgdmVyc2lvbi4gIENoYW5nZXMgZnJvbSB0aGUgb3RoZXIgdHJlZSB0aGF0IGRvIG5vdAotCWNvbmZsaWN0IHdpdGggb3VyIHNpZGUgYXJlIHJlZmxlY3RlZCB0byB0aGUgbWVyZ2UgcmVzdWx0LgorCWNvbmZsaWN0IHdpdGggb3VyIHNpZGUgYXJlIHJlZmxlY3RlZCBpbiB0aGUgbWVyZ2UgcmVzdWx0LgogCUZvciBhIGJpbmFyeSBmaWxlLCB0aGUgZW50aXJlIGNvbnRlbnRzIGFyZSB0YWtlbiBmcm9tIG91ciBzaWRlLgogKwogVGhpcyBzaG91bGQgbm90IGJlIGNvbmZ1c2VkIHdpdGggdGhlICdvdXJzJyBtZXJnZSBzdHJhdGVneSwgd2hpY2ggZG9lcyBub3QKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vcHJldHR5LWZvcm1hdHMudHh0IGIvRG9jdW1lbnRhdGlvbi9wcmV0dHktZm9ybWF0cy50eHQKaW5kZXggMDc5NTk4My4uMzFjNmU4ZCAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9wcmV0dHktZm9ybWF0cy50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9wcmV0dHktZm9ybWF0cy50eHQKQEAgLTE2Myw2ICsxNjMsOSBAQAogJyVhZSc6OiBhdXRob3IgZW1haWwKICclYUUnOjogYXV0aG9yIGVtYWlsIChyZXNwZWN0aW5nIC5tYWlsbWFwLCBzZWUgbGlua2dpdDpnaXQtc2hvcnRsb2dbMV0KIAlvciBsaW5rZ2l0OmdpdC1ibGFtZVsxXSkKKyclYWwnOjogYXV0aG9yIGVtYWlsIGxvY2FsLXBhcnQgKHRoZSBwYXJ0IGJlZm9yZSB0aGUgJ0AnIHNpZ24pCisnJWFMJzo6IGF1dGhvciBsb2NhbC1wYXJ0IChzZWUgJyVhbCcpIHJlc3BlY3RpbmcgLm1haWxtYXAsIHNlZQorCWxpbmtnaXQ6Z2l0LXNob3J0bG9nWzFdIG9yIGxpbmtnaXQ6Z2l0LWJsYW1lWzFdKQogJyVhZCc6OiBhdXRob3IgZGF0ZSAoZm9ybWF0IHJlc3BlY3RzIC0tZGF0ZT0gb3B0aW9uKQogJyVhRCc6OiBhdXRob3IgZGF0ZSwgUkZDMjgyMiBzdHlsZQogJyVhcic6OiBhdXRob3IgZGF0ZSwgcmVsYXRpdmUKQEAgLTE3NSw2ICsxNzgsOSBAQAogJyVjZSc6OiBjb21taXR0ZXIgZW1haWwKICclY0UnOjogY29tbWl0dGVyIGVtYWlsIChyZXNwZWN0aW5nIC5tYWlsbWFwLCBzZWUKIAlsaW5rZ2l0OmdpdC1zaG9ydGxvZ1sxXSBvciBsaW5rZ2l0OmdpdC1ibGFtZVsxXSkKKyclY2wnOjogYXV0aG9yIGVtYWlsIGxvY2FsLXBhcnQgKHRoZSBwYXJ0IGJlZm9yZSB0aGUgJ0AnIHNpZ24pCisnJWNMJzo6IGF1dGhvciBsb2NhbC1wYXJ0IChzZWUgJyVjbCcpIHJlc3BlY3RpbmcgLm1haWxtYXAsIHNlZQorCWxpbmtnaXQ6Z2l0LXNob3J0bG9nWzFdIG9yIGxpbmtnaXQ6Z2l0LWJsYW1lWzFdKQogJyVjZCc6OiBjb21taXR0ZXIgZGF0ZSAoZm9ybWF0IHJlc3BlY3RzIC0tZGF0ZT0gb3B0aW9uKQogJyVjRCc6OiBjb21taXR0ZXIgZGF0ZSwgUkZDMjgyMiBzdHlsZQogJyVjcic6OiBjb21taXR0ZXIgZGF0ZSwgcmVsYXRpdmUKQEAgLTIwOCw3ICsyMTQsNyBAQAogJyVHUCc6OiBzaG93IHRoZSBmaW5nZXJwcmludCBvZiB0aGUgcHJpbWFyeSBrZXkgd2hvc2Ugc3Via2V5IHdhcyB1c2VkCiAJdG8gc2lnbiBhIHNpZ25lZCBjb21taXQKICclZ0QnOjogcmVmbG9nIHNlbGVjdG9yLCBlLmcuLCBgcmVmcy9zdGFzaEB7MX1gIG9yIGByZWZzL3N0YXNoQHsyCi0JbWludXRlcyBhZ29gfTsgdGhlIGZvcm1hdCBmb2xsb3dzIHRoZSBydWxlcyBkZXNjcmliZWQgZm9yIHRoZQorCW1pbnV0ZXMgYWdvfWA7IHRoZSBmb3JtYXQgZm9sbG93cyB0aGUgcnVsZXMgZGVzY3JpYmVkIGZvciB0aGUKIAlgLWdgIG9wdGlvbi4gVGhlIHBvcnRpb24gYmVmb3JlIHRoZSBgQGAgaXMgdGhlIHJlZm5hbWUgYXMKIAlnaXZlbiBvbiB0aGUgY29tbWFuZCBsaW5lIChzbyBgZ2l0IGxvZyAtZyByZWZzL2hlYWRzL21hc3RlcmAKIAl3b3VsZCB5aWVsZCBgcmVmcy9oZWFkcy9tYXN0ZXJAezB9YCkuCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL3ByZXR0eS1vcHRpb25zLnR4dCBiL0RvY3VtZW50YXRpb24vcHJldHR5LW9wdGlvbnMudHh0CmluZGV4IGU0NGZjOGYuLjY4OTNhNGEgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vcHJldHR5LW9wdGlvbnMudHh0CisrKyBiL0RvY3VtZW50YXRpb24vcHJldHR5LW9wdGlvbnMudHh0CkBAIC01Nyw3ICs1Nyw3IEBACiBhbmQgJ2Z1bGxlcicpLgogCiBpZm5kZWY6OmdpdC1yZXYtbGlzdFtdCi0tLW5vdGVzWz08dHJlZWlzaD5dOjoKKy0tbm90ZXNbPTxyZWY+XTo6CiAJU2hvdyB0aGUgbm90ZXMgKHNlZSBsaW5rZ2l0OmdpdC1ub3Rlc1sxXSkgdGhhdCBhbm5vdGF0ZSB0aGUKIAljb21taXQsIHdoZW4gc2hvd2luZyB0aGUgY29tbWl0IGxvZyBtZXNzYWdlLiAgVGhpcyBpcyB0aGUgZGVmYXVsdAogCWZvciBgZ2l0IGxvZ2AsIGBnaXQgc2hvd2AgYW5kIGBnaXQgd2hhdGNoYW5nZWRgIGNvbW1hbmRzIHdoZW4KQEAgLTY4LDggKzY4LDggQEAKIGBjb3JlLm5vdGVzUmVmYCBhbmQgYG5vdGVzLmRpc3BsYXlSZWZgIHZhcmlhYmxlcyAob3IgY29ycmVzcG9uZGluZwogZW52aXJvbm1lbnQgb3ZlcnJpZGVzKS4gU2VlIGxpbmtnaXQ6Z2l0LWNvbmZpZ1sxXSBmb3IgbW9yZSBkZXRhaWxzLgogKwotV2l0aCBhbiBvcHRpb25hbCAnPHRyZWVpc2g+JyBhcmd1bWVudCwgdXNlIHRoZSB0cmVlaXNoIHRvIGZpbmQgdGhlIG5vdGVzCi10byBkaXNwbGF5LiAgVGhlIHRyZWVpc2ggY2FuIHNwZWNpZnkgdGhlIGZ1bGwgcmVmbmFtZSB3aGVuIGl0IGJlZ2lucworV2l0aCBhbiBvcHRpb25hbCAnPHJlZj4nIGFyZ3VtZW50LCB1c2UgdGhlIHJlZiB0byBmaW5kIHRoZSBub3RlcwordG8gZGlzcGxheS4gIFRoZSByZWYgY2FuIHNwZWNpZnkgdGhlIGZ1bGwgcmVmbmFtZSB3aGVuIGl0IGJlZ2lucwogd2l0aCBgcmVmcy9ub3Rlcy9gOyB3aGVuIGl0IGJlZ2lucyB3aXRoIGBub3Rlcy9gLCBgcmVmcy9gIGFuZCBvdGhlcndpc2UKIGByZWZzL25vdGVzL2AgaXMgcHJlZml4ZWQgdG8gZm9ybSBhIGZ1bGwgbmFtZSBvZiB0aGUgcmVmLgogKwpAQCAtODUsNyArODUsNyBAQAogCSItLW5vdGVzIC0tbm90ZXM9Zm9vIC0tbm8tbm90ZXMgLS1ub3Rlcz1iYXIiIHdpbGwgb25seSBzaG93IG5vdGVzCiAJZnJvbSAicmVmcy9ub3Rlcy9iYXIiLgogCi0tLXNob3ctbm90ZXNbPTx0cmVlaXNoPl06OgorLS1zaG93LW5vdGVzWz08cmVmPl06OgogLS1bbm8tXXN0YW5kYXJkLW5vdGVzOjoKIAlUaGVzZSBvcHRpb25zIGFyZSBkZXByZWNhdGVkLiBVc2UgdGhlIGFib3ZlIC0tbm90ZXMvLS1uby1ub3RlcwogCW9wdGlvbnMgaW5zdGVhZC4KZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vcmV2LWxpc3Qtb3B0aW9ucy50eHQgYi9Eb2N1bWVudGF0aW9uL3Jldi1saXN0LW9wdGlvbnMudHh0CmluZGV4IGJiMTI1MWMuLmY2M2NlZDYgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vcmV2LWxpc3Qtb3B0aW9ucy50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9yZXYtbGlzdC1vcHRpb25zLnR4dApAQCAtNTgsNyArNTgsNyBAQAogCWAtLWFsbC1tYXRjaGApLgogaWZuZGVmOjpnaXQtcmV2LWxpc3RbXQogKwotV2hlbiBgLS1zaG93LW5vdGVzYCBpcyBpbiBlZmZlY3QsIHRoZSBtZXNzYWdlIGZyb20gdGhlIG5vdGVzIGlzCitXaGVuIGAtLW5vdGVzYCBpcyBpbiBlZmZlY3QsIHRoZSBtZXNzYWdlIGZyb20gdGhlIG5vdGVzIGlzCiBtYXRjaGVkIGFzIGlmIGl0IHdlcmUgcGFydCBvZiB0aGUgbG9nIG1lc3NhZ2UuCiBlbmRpZjo6Z2l0LXJldi1saXN0W10KIApAQCAtNTc5LDYgKzU3OSw3IEBACiBjb250ZW50cyBvZiB0aGUgcGF0aHMgZ2l2ZW4gb24gdGhlIGNvbW1hbmQgbGluZS4gIEFsbCBvdGhlcgogY29tbWl0cyBhcmUgbWFya2VkIGFzIFRSRUVTQU1FIChzdWJqZWN0IHRvIGJlIHNpbXBsaWZpZWQgYXdheSkuCiAKK2lmbmRlZjo6Z2l0LXNob3J0bG9nW10KIGlmZGVmOjpnaXQtcmV2LWxpc3RbXQogQmlzZWN0aW9uIEhlbHBlcnMKIH5+fn5+fn5+fn5+fn5+fn5+CkBAIC02MzQsOCArNjM1LDkgQEAKIGFmdGVyIGFsbCB0aGUgc29ydGVkIGNvbW1pdCBvYmplY3RzLCB0aGVyZSB3aWxsIGJlIHRoZSBzYW1lIHRleHQgYXMgaWYKIGAtLWJpc2VjdC12YXJzYCBoYWQgYmVlbiB1c2VkIGFsb25lLgogZW5kaWY6OmdpdC1yZXYtbGlzdFtdCitlbmRpZjo6Z2l0LXNob3J0bG9nW10KIAotCitpZm5kZWY6OmdpdC1zaG9ydGxvZ1tdCiBDb21taXQgT3JkZXJpbmcKIH5+fn5+fn5+fn5+fn5+fgogCkBAIC02NzcsNyArNjc5LDkgQEAKIAlPdXRwdXQgdGhlIGNvbW1pdHMgY2hvc2VuIHRvIGJlIHNob3duIChzZWUgQ29tbWl0IExpbWl0aW5nCiAJc2VjdGlvbiBhYm92ZSkgaW4gcmV2ZXJzZSBvcmRlci4gQ2Fubm90IGJlIGNvbWJpbmVkIHdpdGgKIAlgLS13YWxrLXJlZmxvZ3NgLgorZW5kaWY6OmdpdC1zaG9ydGxvZ1tdCiAKK2lmbmRlZjo6Z2l0LXNob3J0bG9nW10KIE9iamVjdCBUcmF2ZXJzYWwKIH5+fn5+fn5+fn5+fn5+fn4KIApAQCAtNzU2LDYgKzc2MCwyMiBAQAogTm90ZSB0aGF0IHRoZSBmb3JtICctLWZpbHRlcj1zcGFyc2U6cGF0aD08cGF0aD4nIHRoYXQgd2FudHMgdG8gcmVhZAogZnJvbSBhbiBhcmJpdHJhcnkgcGF0aCBvbiB0aGUgZmlsZXN5c3RlbSBoYXMgYmVlbiBkcm9wcGVkIGZvciBzZWN1cml0eQogcmVhc29ucy4KKysKK011bHRpcGxlICctLWZpbHRlcj0nIGZsYWdzIGNhbiBiZSBzcGVjaWZpZWQgdG8gY29tYmluZSBmaWx0ZXJzLiBPbmx5CitvYmplY3RzIHdoaWNoIGFyZSBhY2NlcHRlZCBieSBldmVyeSBmaWx0ZXIgYXJlIGluY2x1ZGVkLgorKworVGhlIGZvcm0gJy0tZmlsdGVyPWNvbWJpbmU6PGZpbHRlcjE+KzxmaWx0ZXIyPisuLi48ZmlsdGVyTj4nIGNhbiBhbHNvIGJlCit1c2VkIHRvIGNvbWJpbmVkIHNldmVyYWwgZmlsdGVycywgYnV0IHRoaXMgaXMgaGFyZGVyIHRoYW4ganVzdCByZXBlYXRpbmcKK3RoZSAnLS1maWx0ZXInIGZsYWcgYW5kIGlzIHVzdWFsbHkgbm90IG5lY2Vzc2FyeS4gRmlsdGVycyBhcmUgam9pbmVkIGJ5Cisne3BsdXN9JyBhbmQgaW5kaXZpZHVhbCBmaWx0ZXJzIGFyZSAlLWVuY29kZWQgKGkuZS4gVVJMLWVuY29kZWQpLgorQmVzaWRlcyB0aGUgJ3twbHVzfScgYW5kICclJyBjaGFyYWN0ZXJzLCB0aGUgZm9sbG93aW5nIGNoYXJhY3RlcnMgYXJlCityZXNlcnZlZCBhbmQgYWxzbyBtdXN0IGJlIGVuY29kZWQ6IGB+IUAjJF4mKigpW117fVw7Iiw8Pj9gKyYjMzk7JiM5NjsrCithcyB3ZWxsIGFzIGFsbCBjaGFyYWN0ZXJzIHdpdGggQVNDSUkgY29kZSAmbHQ7PSBgMHgyMGAsIHdoaWNoIGluY2x1ZGVzCitzcGFjZSBhbmQgbmV3bGluZS4KKysKK090aGVyIGFyYml0cmFyeSBjaGFyYWN0ZXJzIGNhbiBhbHNvIGJlIGVuY29kZWQuIEZvciBpbnN0YW5jZSwKKydjb21iaW5lOnRyZWU6MytibG9iOm5vbmUnIGFuZCAnY29tYmluZTp0cmVlJTNBMytibG9iJTNBbm9uZScgYXJlCitlcXVpdmFsZW50LgogCiAtLW5vLWZpbHRlcjo6CiAJVHVybiBvZmYgYW55IHByZXZpb3VzIGAtLWZpbHRlcj1gIGFyZ3VtZW50LgpAQCAtODAxLDcgKzgyMSw5IEBACiAKIC0tZG8td2Fsazo6CiAJT3ZlcnJpZGVzIGEgcHJldmlvdXMgYC0tbm8td2Fsa2AuCitlbmRpZjo6Z2l0LXNob3J0bG9nW10KIAoraWZuZGVmOjpnaXQtc2hvcnRsb2dbXQogQ29tbWl0IEZvcm1hdHRpbmcKIH5+fn5+fn5+fn5+fn5+fn5+CiAKQEAgLTk1Nyw3ICs5NzksOSBAQAogCWNvdW50cyBhbmQgcHJpbnQgdGhlIGNvdW50IGZvciBlcXVpdmFsZW50IGNvbW1pdHMgc2VwYXJhdGVkCiAJYnkgYSB0YWIuCiBlbmRpZjo6Z2l0LXJldi1saXN0W10KK2VuZGlmOjpnaXQtc2hvcnRsb2dbXQogCitpZm5kZWY6OmdpdC1zaG9ydGxvZ1tdCiBpZm5kZWY6OmdpdC1yZXYtbGlzdFtdCiBEaWZmIEZvcm1hdHRpbmcKIH5+fn5+fn5+fn5+fn5+fgpAQCAtMTAwMCwzICsxMDI0LDQgQEAKIC10OjoKIAlTaG93IHRoZSB0cmVlIG9iamVjdHMgaW4gdGhlIGRpZmYgb3V0cHV0LiBUaGlzIGltcGxpZXMgYC1yYC4KIGVuZGlmOjpnaXQtcmV2LWxpc3RbXQorZW5kaWY6OmdpdC1zaG9ydGxvZ1tdCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL3RlY2huaWNhbC9hcGktY29uZmlnLnR4dCBiL0RvY3VtZW50YXRpb24vdGVjaG5pY2FsL2FwaS1jb25maWcudHh0CmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA3ZDIwNzE2Li4wMDAwMDAwCi0tLSBhL0RvY3VtZW50YXRpb24vdGVjaG5pY2FsL2FwaS1jb25maWcudHh0CisrKyAvZGV2L251bGwKQEAgLTEsMzE5ICswLDAgQEAKLWNvbmZpZyBBUEkKLT09PT09PT09PT0KLQotVGhlIGNvbmZpZyBBUEkgZ2l2ZXMgY2FsbGVycyBhIHdheSB0byBhY2Nlc3MgR2l0IGNvbmZpZ3VyYXRpb24gZmlsZXMKLShhbmQgZmlsZXMgd2hpY2ggaGF2ZSB0aGUgc2FtZSBzeW50YXgpLiBTZWUgbGlua2dpdDpnaXQtY29uZmlnWzFdIGZvciBhCi1kaXNjdXNzaW9uIG9mIHRoZSBjb25maWcgZmlsZSBzeW50YXguCi0KLUdlbmVyYWwgVXNhZ2UKLS0tLS0tLS0tLS0tLS0KLQotQ29uZmlnIGZpbGVzIGFyZSBwYXJzZWQgbGluZWFybHksIGFuZCBlYWNoIHZhcmlhYmxlIGZvdW5kIGlzIHBhc3NlZCB0byBhCi1jYWxsZXItcHJvdmlkZWQgY2FsbGJhY2sgZnVuY3Rpb24uIFRoZSBjYWxsYmFjayBmdW5jdGlvbiBpcyByZXNwb25zaWJsZQotZm9yIGFueSBhY3Rpb25zIHRvIGJlIHRha2VuIG9uIHRoZSBjb25maWcgb3B0aW9uLCBhbmQgaXMgZnJlZSB0byBpZ25vcmUKLXNvbWUgb3B0aW9ucy4gSXQgaXMgbm90IHVuY29tbW9uIGZvciB0aGUgY29uZmlndXJhdGlvbiB0byBiZSBwYXJzZWQKLXNldmVyYWwgdGltZXMgZHVyaW5nIHRoZSBydW4gb2YgYSBHaXQgcHJvZ3JhbSwgd2l0aCBkaWZmZXJlbnQgY2FsbGJhY2tzCi1waWNraW5nIG91dCBkaWZmZXJlbnQgdmFyaWFibGVzIHVzZWZ1bCB0byB0aGVtc2VsdmVzLgotCi1BIGNvbmZpZyBjYWxsYmFjayBmdW5jdGlvbiB0YWtlcyB0aHJlZSBwYXJhbWV0ZXJzOgotCi0tIHRoZSBuYW1lIG9mIHRoZSBwYXJzZWQgdmFyaWFibGUuIFRoaXMgaXMgaW4gY2Fub25pY2FsICJmbGF0IiBmb3JtOiB0aGUKLSAgc2VjdGlvbiwgc3Vic2VjdGlvbiwgYW5kIHZhcmlhYmxlIHNlZ21lbnRzIHdpbGwgYmUgc2VwYXJhdGVkIGJ5IGRvdHMsCi0gIGFuZCB0aGUgc2VjdGlvbiBhbmQgdmFyaWFibGUgc2VnbWVudHMgd2lsbCBiZSBhbGwgbG93ZXJjYXNlLiBFLmcuLAotICBgY29yZS5pZ25vcmVjYXNlYCwgYGRpZmYuU29tZVR5cGUudGV4dGNvbnZgLgotCi0tIHRoZSB2YWx1ZSBvZiB0aGUgZm91bmQgdmFyaWFibGUsIGFzIGEgc3RyaW5nLiBJZiB0aGUgdmFyaWFibGUgaGFkIG5vCi0gIHZhbHVlIHNwZWNpZmllZCwgdGhlIHZhbHVlIHdpbGwgYmUgTlVMTCAodHlwaWNhbGx5IHRoaXMgbWVhbnMgaXQKLSAgc2hvdWxkIGJlIGludGVycHJldGVkIGFzIGJvb2xlYW4gdHJ1ZSkuCi0KLS0gYSB2b2lkIHBvaW50ZXIgcGFzc2VkIGluIGJ5IHRoZSBjYWxsZXIgb2YgdGhlIGNvbmZpZyBBUEk7IHRoaXMgY2FuCi0gIGNvbnRhaW4gY2FsbGJhY2stc3BlY2lmaWMgZGF0YQotCi1BIGNvbmZpZyBjYWxsYmFjayBzaG91bGQgcmV0dXJuIDAgZm9yIHN1Y2Nlc3MsIG9yIC0xIGlmIHRoZSB2YXJpYWJsZQotY291bGQgbm90IGJlIHBhcnNlZCBwcm9wZXJseS4KLQotQmFzaWMgQ29uZmlnIFF1ZXJ5aW5nCi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KLQotTW9zdCBwcm9ncmFtcyB3aWxsIHNpbXBseSB3YW50IHRvIGxvb2sgdXAgdmFyaWFibGVzIGluIGFsbCBjb25maWcgZmlsZXMKLXRoYXQgR2l0IGtub3dzIGFib3V0LCB1c2luZyB0aGUgbm9ybWFsIHByZWNlZGVuY2UgcnVsZXMuIFRvIGRvIHRoaXMsCi1jYWxsIGBnaXRfY29uZmlnYCB3aXRoIGEgY2FsbGJhY2sgZnVuY3Rpb24gYW5kIHZvaWQgZGF0YSBwb2ludGVyLgotCi1gZ2l0X2NvbmZpZ2Agd2lsbCByZWFkIGFsbCBjb25maWcgc291cmNlcyBpbiBvcmRlciBvZiBpbmNyZWFzaW5nCi1wcmlvcml0eS4gVGh1cyBhIGNhbGxiYWNrIHNob3VsZCB0eXBpY2FsbHkgb3ZlcndyaXRlIHByZXZpb3VzbHktc2VlbgotZW50cmllcyB3aXRoIG5ldyBvbmVzIChlLmcuLCBpZiBib3RoIHRoZSB1c2VyLXdpZGUgYH4vLmdpdGNvbmZpZ2AgYW5kCi1yZXBvLXNwZWNpZmljIGAuZ2l0L2NvbmZpZ2AgY29udGFpbiBgY29sb3IudWlgLCB0aGUgY29uZmlnIG1hY2hpbmVyeQotd2lsbCBmaXJzdCBmZWVkIHRoZSB1c2VyLXdpZGUgb25lIHRvIHRoZSBjYWxsYmFjaywgYW5kIHRoZW4gdGhlCi1yZXBvLXNwZWNpZmljIG9uZTsgYnkgb3ZlcndyaXRpbmcsIHRoZSBoaWdoZXItcHJpb3JpdHkgcmVwby1zcGVjaWZpYwotdmFsdWUgaXMgbGVmdCBhdCB0aGUgZW5kKS4KLQotVGhlIGBjb25maWdfd2l0aF9vcHRpb25zYCBmdW5jdGlvbiBsZXRzIHRoZSBjYWxsZXIgZXhhbWluZSBjb25maWcKLXdoaWxlIGFkanVzdGluZyBzb21lIG9mIHRoZSBkZWZhdWx0IGJlaGF2aW9yIG9mIGBnaXRfY29uZmlnYC4gSXQgc2hvdWxkCi1hbG1vc3QgbmV2ZXIgYmUgdXNlZCBieSAicmVndWxhciIgR2l0IGNvZGUgdGhhdCBpcyBsb29raW5nIHVwCi1jb25maWd1cmF0aW9uIHZhcmlhYmxlcy4gSXQgaXMgaW50ZW5kZWQgZm9yIGFkdmFuY2VkIGNhbGxlcnMgbGlrZQotYGdpdC1jb25maWdgLCB3aGljaCBhcmUgaW50ZW50aW9uYWxseSB0d2Vha2luZyB0aGUgbm9ybWFsIGNvbmZpZy1sb29rdXAKLXByb2Nlc3MuIEl0IHRha2VzIHR3byBleHRyYSBwYXJhbWV0ZXJzOgotCi1gY29uZmlnX3NvdXJjZWA6OgotSWYgdGhpcyBwYXJhbWV0ZXIgaXMgbm9uLU5VTEwsIGl0IHNwZWNpZmllcyB0aGUgc291cmNlIHRvIHBhcnNlIGZvcgotY29uZmlndXJhdGlvbiwgcmF0aGVyIHRoYW4gbG9va2luZyBpbiB0aGUgdXN1YWwgZmlsZXMuIFNlZSBgc3RydWN0Ci1naXRfY29uZmlnX3NvdXJjZWAgaW4gYGNvbmZpZy5oYCBmb3IgZGV0YWlscy4gUmVndWxhciBgZ2l0X2NvbmZpZ2AgZGVmYXVsdHMKLXRvIGBOVUxMYC4KLQotYG9wdHNgOjoKLVNwZWNpZnkgb3B0aW9ucyB0byBhZGp1c3QgdGhlIGJlaGF2aW9yIG9mIHBhcnNpbmcgY29uZmlnIGZpbGVzLiBTZWUgYHN0cnVjdAotY29uZmlnX29wdGlvbnNgIGluIGBjb25maWcuaGAgZm9yIGRldGFpbHMuIEFzIGFuIGV4YW1wbGU6IHJlZ3VsYXIgYGdpdF9jb25maWdgCi1zZXRzIGBvcHRzLnJlc3BlY3RfaW5jbHVkZXNgIHRvIGAxYCBieSBkZWZhdWx0LgotCi1SZWFkaW5nIFNwZWNpZmljIEZpbGVzCi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCi0KLVRvIHJlYWQgYSBzcGVjaWZpYyBmaWxlIGluIGdpdC1jb25maWcgZm9ybWF0LCB1c2UKLWBnaXRfY29uZmlnX2Zyb21fZmlsZWAuIFRoaXMgdGFrZXMgdGhlIHNhbWUgY2FsbGJhY2sgYW5kIGRhdGEgcGFyYW1ldGVycwotYXMgYGdpdF9jb25maWdgLgotCi1RdWVyeWluZyBGb3IgU3BlY2lmaWMgVmFyaWFibGVzCi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCi0KLUZvciBwcm9ncmFtcyB3YW50aW5nIHRvIHF1ZXJ5IGZvciBzcGVjaWZpYyB2YXJpYWJsZXMgaW4gYSBub24tY2FsbGJhY2sKLW1hbm5lciwgdGhlIGNvbmZpZyBBUEkgcHJvdmlkZXMgdHdvIGZ1bmN0aW9ucyBgZ2l0X2NvbmZpZ19nZXRfdmFsdWVgCi1hbmQgYGdpdF9jb25maWdfZ2V0X3ZhbHVlX211bHRpYC4gVGhleSBib3RoIHJlYWQgdmFsdWVzIGZyb20gYW4gaW50ZXJuYWwKLWNhY2hlIGdlbmVyYXRlZCBwcmV2aW91c2x5IGZyb20gcmVhZGluZyB0aGUgY29uZmlnIGZpbGVzLgotCi1gaW50IGdpdF9jb25maWdfZ2V0X3ZhbHVlKGNvbnN0IGNoYXIgKmtleSwgY29uc3QgY2hhciAqKnZhbHVlKWA6OgotCi0JRmluZHMgdGhlIGhpZ2hlc3QtcHJpb3JpdHkgdmFsdWUgZm9yIHRoZSBjb25maWd1cmF0aW9uIHZhcmlhYmxlIGBrZXlgLAotCXN0b3JlcyB0aGUgcG9pbnRlciB0byBpdCBpbiBgdmFsdWVgIGFuZCByZXR1cm5zIDAuIFdoZW4gdGhlCi0JY29uZmlndXJhdGlvbiB2YXJpYWJsZSBga2V5YCBpcyBub3QgZm91bmQsIHJldHVybnMgMSB3aXRob3V0IHRvdWNoaW5nCi0JYHZhbHVlYC4gVGhlIGNhbGxlciBzaG91bGQgbm90IGZyZWUgb3IgbW9kaWZ5IGB2YWx1ZWAsIGFzIGl0IGlzIG93bmVkCi0JYnkgdGhlIGNhY2hlLgotCi1gY29uc3Qgc3RydWN0IHN0cmluZ19saXN0ICpnaXRfY29uZmlnX2dldF92YWx1ZV9tdWx0aShjb25zdCBjaGFyICprZXkpYDo6Ci0KLQlGaW5kcyBhbmQgcmV0dXJucyB0aGUgdmFsdWUgbGlzdCwgc29ydGVkIGluIG9yZGVyIG9mIGluY3JlYXNpbmcgcHJpb3JpdHkKLQlmb3IgdGhlIGNvbmZpZ3VyYXRpb24gdmFyaWFibGUgYGtleWAuIFdoZW4gdGhlIGNvbmZpZ3VyYXRpb24gdmFyaWFibGUKLQlga2V5YCBpcyBub3QgZm91bmQsIHJldHVybnMgTlVMTC4gVGhlIGNhbGxlciBzaG91bGQgbm90IGZyZWUgb3IgbW9kaWZ5Ci0JdGhlIHJldHVybmVkIHBvaW50ZXIsIGFzIGl0IGlzIG93bmVkIGJ5IHRoZSBjYWNoZS4KLQotYHZvaWQgZ2l0X2NvbmZpZ19jbGVhcih2b2lkKWA6OgotCi0JUmVzZXRzIGFuZCBpbnZhbGlkYXRlcyB0aGUgY29uZmlnIGNhY2hlLgotCi1UaGUgY29uZmlnIEFQSSBhbHNvIHByb3ZpZGVzIHR5cGUgc3BlY2lmaWMgQVBJIGZ1bmN0aW9ucyB3aGljaCBkbyBjb252ZXJzaW9uCi1hcyB3ZWxsIGFzIHJldHJpZXZhbCBmb3IgdGhlIHF1ZXJpZWQgdmFyaWFibGUsIGluY2x1ZGluZzoKLQotYGludCBnaXRfY29uZmlnX2dldF9pbnQoY29uc3QgY2hhciAqa2V5LCBpbnQgKmRlc3QpYDo6Ci0KLQlGaW5kcyBhbmQgcGFyc2VzIHRoZSB2YWx1ZSB0byBhbiBpbnRlZ2VyIGZvciB0aGUgY29uZmlndXJhdGlvbiB2YXJpYWJsZQotCWBrZXlgLiBEaWVzIG9uIGVycm9yOyBvdGhlcndpc2UsIHN0b3JlcyB0aGUgdmFsdWUgb2YgdGhlIHBhcnNlZCBpbnRlZ2VyIGluCi0JYGRlc3RgIGFuZCByZXR1cm5zIDAuIFdoZW4gdGhlIGNvbmZpZ3VyYXRpb24gdmFyaWFibGUgYGtleWAgaXMgbm90IGZvdW5kLAotCXJldHVybnMgMSB3aXRob3V0IHRvdWNoaW5nIGBkZXN0YC4KLQotYGludCBnaXRfY29uZmlnX2dldF91bG9uZyhjb25zdCBjaGFyICprZXksIHVuc2lnbmVkIGxvbmcgKmRlc3QpYDo6Ci0KLQlTaW1pbGFyIHRvIGBnaXRfY29uZmlnX2dldF9pbnRgIGJ1dCBmb3IgdW5zaWduZWQgbG9uZ3MuCi0KLWBpbnQgZ2l0X2NvbmZpZ19nZXRfYm9vbChjb25zdCBjaGFyICprZXksIGludCAqZGVzdClgOjoKLQotCUZpbmRzIGFuZCBwYXJzZXMgdGhlIHZhbHVlIGludG8gYSBib29sZWFuIHZhbHVlLCBmb3IgdGhlIGNvbmZpZ3VyYXRpb24KLQl2YXJpYWJsZSBga2V5YCByZXNwZWN0aW5nIGtleXdvcmRzIGxpa2UgInRydWUiIGFuZCAiZmFsc2UiLiBJbnRlZ2VyCi0JdmFsdWVzIGFyZSBjb252ZXJ0ZWQgaW50byB0cnVlL2ZhbHNlIHZhbHVlcyAod2hlbiB0aGV5IGFyZSBub24temVybyBvcgotCXplcm8sIHJlc3BlY3RpdmVseSkuIE90aGVyIHZhbHVlcyBjYXVzZSBhIGRpZSgpLiBJZiBwYXJzaW5nIGlzIHN1Y2Nlc3NmdWwsCi0Jc3RvcmVzIHRoZSB2YWx1ZSBvZiB0aGUgcGFyc2VkIHJlc3VsdCBpbiBgZGVzdGAgYW5kIHJldHVybnMgMC4gV2hlbiB0aGUKLQljb25maWd1cmF0aW9uIHZhcmlhYmxlIGBrZXlgIGlzIG5vdCBmb3VuZCwgcmV0dXJucyAxIHdpdGhvdXQgdG91Y2hpbmcKLQlgZGVzdGAuCi0KLWBpbnQgZ2l0X2NvbmZpZ19nZXRfYm9vbF9vcl9pbnQoY29uc3QgY2hhciAqa2V5LCBpbnQgKmlzX2Jvb2wsIGludCAqZGVzdClgOjoKLQotCVNpbWlsYXIgdG8gYGdpdF9jb25maWdfZ2V0X2Jvb2xgLCBleGNlcHQgdGhhdCBpbnRlZ2VycyBhcmUgY29waWVkIGFzLWlzLAotCWFuZCBgaXNfYm9vbGAgZmxhZyBpcyB1bnNldC4KLQotYGludCBnaXRfY29uZmlnX2dldF9tYXliZV9ib29sKGNvbnN0IGNoYXIgKmtleSwgaW50ICpkZXN0KWA6OgotCi0JU2ltaWxhciB0byBgZ2l0X2NvbmZpZ19nZXRfYm9vbGAsIGV4Y2VwdCB0aGF0IGl0IHJldHVybnMgLTEgb24gZXJyb3IKLQlyYXRoZXIgdGhhbiBkeWluZy4KLQotYGludCBnaXRfY29uZmlnX2dldF9zdHJpbmdfY29uc3QoY29uc3QgY2hhciAqa2V5LCBjb25zdCBjaGFyICoqZGVzdClgOjoKLQotCUFsbG9jYXRlcyBhbmQgY29waWVzIHRoZSByZXRyaWV2ZWQgc3RyaW5nIGludG8gdGhlIGBkZXN0YCBwYXJhbWV0ZXIgZm9yCi0JdGhlIGNvbmZpZ3VyYXRpb24gdmFyaWFibGUgYGtleWA7IGlmIE5VTEwgc3RyaW5nIGlzIGdpdmVuLCBwcmludHMgYW4KLQllcnJvciBtZXNzYWdlIGFuZCByZXR1cm5zIC0xLiBXaGVuIHRoZSBjb25maWd1cmF0aW9uIHZhcmlhYmxlIGBrZXlgIGlzCi0Jbm90IGZvdW5kLCByZXR1cm5zIDEgd2l0aG91dCB0b3VjaGluZyBgZGVzdGAuCi0KLWBpbnQgZ2l0X2NvbmZpZ19nZXRfc3RyaW5nKGNvbnN0IGNoYXIgKmtleSwgY2hhciAqKmRlc3QpYDo6Ci0KLQlTaW1pbGFyIHRvIGBnaXRfY29uZmlnX2dldF9zdHJpbmdfY29uc3RgLCBleGNlcHQgdGhhdCByZXRyaWV2ZWQgdmFsdWUKLQljb3BpZWQgaW50byB0aGUgYGRlc3RgIHBhcmFtZXRlciBpcyBhIG11dGFibGUgc3RyaW5nLgotCi1gaW50IGdpdF9jb25maWdfZ2V0X3BhdGhuYW1lKGNvbnN0IGNoYXIgKmtleSwgY29uc3QgY2hhciAqKmRlc3QpYDo6Ci0KLQlTaW1pbGFyIHRvIGBnaXRfY29uZmlnX2dldF9zdHJpbmdgLCBidXQgZXhwYW5kcyBgfmAgb3IgYH51c2VyYCBpbnRvCi0JdGhlIHVzZXIncyBob21lIGRpcmVjdG9yeSB3aGVuIGZvdW5kIGF0IHRoZSBiZWdpbm5pbmcgb2YgdGhlIHBhdGguCi0KLWBnaXRfZGllX2NvbmZpZyhjb25zdCBjaGFyICprZXksIGNvbnN0IGNoYXIgKmVyciwgLi4uKWA6OgotCi0JRmlyc3QgcHJpbnRzIHRoZSBlcnJvciBtZXNzYWdlIHNwZWNpZmllZCBieSB0aGUgY2FsbGVyIGluIGBlcnJgIGFuZCB0aGVuCi0JZGllcyBwcmludGluZyB0aGUgbGluZSBudW1iZXIgYW5kIHRoZSBmaWxlIG5hbWUgb2YgdGhlIGhpZ2hlc3QgcHJpb3JpdHkKLQl2YWx1ZSBmb3IgdGhlIGNvbmZpZ3VyYXRpb24gdmFyaWFibGUgYGtleWAuCi0KLWB2b2lkIGdpdF9kaWVfY29uZmlnX2xpbmVucihjb25zdCBjaGFyICprZXksIGNvbnN0IGNoYXIgKmZpbGVuYW1lLCBpbnQgbGluZW5yKWA6OgotCi0JSGVscGVyIGZ1bmN0aW9uIHdoaWNoIGZvcm1hdHMgdGhlIGRpZSBlcnJvciBtZXNzYWdlIGFjY29yZGluZyB0byB0aGUKLQlwYXJhbWV0ZXJzIGVudGVyZWQuIFVzZWQgYnkgYGdpdF9kaWVfY29uZmlnKClgLiBJdCBjYW4gYmUgdXNlZCBieSBjYWxsZXJzCi0JaGFuZGxpbmcgYGdpdF9jb25maWdfZ2V0X3ZhbHVlX211bHRpKClgIHRvIHByaW50IHRoZSBjb3JyZWN0IGVycm9yIG1lc3NhZ2UKLQlmb3IgdGhlIGRlc2lyZWQgdmFsdWUuCi0KLVNlZSB0ZXN0LWNvbmZpZy5jIGZvciB1c2FnZSBleGFtcGxlcy4KLQotVmFsdWUgUGFyc2luZyBIZWxwZXJzCi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KLQotVG8gYWlkIGluIHBhcnNpbmcgc3RyaW5nIHZhbHVlcywgdGhlIGNvbmZpZyBBUEkgcHJvdmlkZXMgY2FsbGJhY2tzIHdpdGgKLWEgbnVtYmVyIG9mIGhlbHBlciBmdW5jdGlvbnMsIGluY2x1ZGluZzoKLQotYGdpdF9jb25maWdfaW50YDo6Ci1QYXJzZSB0aGUgc3RyaW5nIHRvIGFuIGludGVnZXIsIGluY2x1ZGluZyB1bml0IGZhY3RvcnMuIERpZXMgb24gZXJyb3I7Ci1vdGhlcndpc2UsIHJldHVybnMgdGhlIHBhcnNlZCByZXN1bHQuCi0KLWBnaXRfY29uZmlnX3Vsb25nYDo6Ci1JZGVudGljYWwgdG8gYGdpdF9jb25maWdfaW50YCwgYnV0IGZvciB1bnNpZ25lZCBsb25ncy4KLQotYGdpdF9jb25maWdfYm9vbGA6OgotUGFyc2UgYSBzdHJpbmcgaW50byBhIGJvb2xlYW4gdmFsdWUsIHJlc3BlY3Rpbmcga2V5d29yZHMgbGlrZSAidHJ1ZSIgYW5kCi0iZmFsc2UiLiBJbnRlZ2VyIHZhbHVlcyBhcmUgY29udmVydGVkIGludG8gdHJ1ZS9mYWxzZSB2YWx1ZXMgKHdoZW4gdGhleQotYXJlIG5vbi16ZXJvIG9yIHplcm8sIHJlc3BlY3RpdmVseSkuIE90aGVyIHZhbHVlcyBjYXVzZSBhIGRpZSgpLiBJZgotcGFyc2luZyBpcyBzdWNjZXNzZnVsLCB0aGUgcmV0dXJuIHZhbHVlIGlzIHRoZSByZXN1bHQuCi0KLWBnaXRfY29uZmlnX2Jvb2xfb3JfaW50YDo6Ci1TYW1lIGFzIGBnaXRfY29uZmlnX2Jvb2xgLCBleGNlcHQgdGhhdCBpbnRlZ2VycyBhcmUgcmV0dXJuZWQgYXMtaXMsIGFuZAotYW4gYGlzX2Jvb2xgIGZsYWcgaXMgdW5zZXQuCi0KLWBnaXRfcGFyc2VfbWF5YmVfYm9vbGA6OgotU2FtZSBhcyBgZ2l0X2NvbmZpZ19ib29sYCwgZXhjZXB0IHRoYXQgaXQgcmV0dXJucyAtMSBvbiBlcnJvciByYXRoZXIKLXRoYW4gZHlpbmcuCi0KLWBnaXRfY29uZmlnX3N0cmluZ2A6OgotQWxsb2NhdGVzIGFuZCBjb3BpZXMgdGhlIHZhbHVlIHN0cmluZyBpbnRvIHRoZSBgZGVzdGAgcGFyYW1ldGVyOyBpZiBubwotc3RyaW5nIGlzIGdpdmVuLCBwcmludHMgYW4gZXJyb3IgbWVzc2FnZSBhbmQgcmV0dXJucyAtMS4KLQotYGdpdF9jb25maWdfcGF0aG5hbWVgOjoKLVNpbWlsYXIgdG8gYGdpdF9jb25maWdfc3RyaW5nYCwgYnV0IGV4cGFuZHMgYH5gIG9yIGB+dXNlcmAgaW50byB0aGUKLXVzZXIncyBob21lIGRpcmVjdG9yeSB3aGVuIGZvdW5kIGF0IHRoZSBiZWdpbm5pbmcgb2YgdGhlIHBhdGguCi0KLUluY2x1ZGUgRGlyZWN0aXZlcwotLS0tLS0tLS0tLS0tLS0tLS0tCi0KLUJ5IGRlZmF1bHQsIHRoZSBjb25maWcgcGFyc2VyIGRvZXMgbm90IHJlc3BlY3QgaW5jbHVkZSBkaXJlY3RpdmVzLgotSG93ZXZlciwgYSBjYWxsZXIgY2FuIHVzZSB0aGUgc3BlY2lhbCBgZ2l0X2NvbmZpZ19pbmNsdWRlYCB3cmFwcGVyCi1jYWxsYmFjayB0byBzdXBwb3J0IHRoZW0uIFRvIGRvIHNvLCB5b3Ugc2ltcGx5IHdyYXAgeW91ciAicmVhbCIgY2FsbGJhY2sKLWZ1bmN0aW9uIGFuZCBkYXRhIHBvaW50ZXIgaW4gYSBgc3RydWN0IGNvbmZpZ19pbmNsdWRlX2RhdGFgLCBhbmQgcGFzcwotdGhlIHdyYXBwZXIgdG8gdGhlIHJlZ3VsYXIgY29uZmlnLXJlYWRpbmcgZnVuY3Rpb25zLiBGb3IgZXhhbXBsZToKLQotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQotaW50IHJlYWRfZmlsZV93aXRoX2luY2x1ZGUoY29uc3QgY2hhciAqZmlsZSwgY29uZmlnX2ZuX3QgZm4sIHZvaWQgKmRhdGEpCi17Ci0Jc3RydWN0IGNvbmZpZ19pbmNsdWRlX2RhdGEgaW5jID0gQ09ORklHX0lOQ0xVREVfSU5JVDsKLQlpbmMuZm4gPSBmbjsKLQlpbmMuZGF0YSA9IGRhdGE7Ci0JcmV0dXJuIGdpdF9jb25maWdfZnJvbV9maWxlKGdpdF9jb25maWdfaW5jbHVkZSwgZmlsZSwgJmluYyk7Ci19Ci0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCi0KLWBnaXRfY29uZmlnYCByZXNwZWN0cyBpbmNsdWRlcyBhdXRvbWF0aWNhbGx5LiBUaGUgbG93ZXItbGV2ZWwKLWBnaXRfY29uZmlnX2Zyb21fZmlsZWAgZG9lcyBub3QuCi0KLUN1c3RvbSBDb25maWdzZXRzCi0tLS0tLS0tLS0tLS0tLS0tLQotCi1BIGBjb25maWdfc2V0YCBjYW4gYmUgdXNlZCB0byBjb25zdHJ1Y3QgYW4gaW4tbWVtb3J5IGNhY2hlIGZvcgotY29uZmlnLWxpa2UgZmlsZXMgdGhhdCB0aGUgY2FsbGVyIHNwZWNpZmllcyAoaS5lLiwgZmlsZXMgbGlrZSBgLmdpdG1vZHVsZXNgLAotYH4vLmdpdGNvbmZpZ2AgZXRjLikuIEZvciBleGFtcGxlLAotCi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCi1zdHJ1Y3QgY29uZmlnX3NldCBnbV9jb25maWc7Ci1naXRfY29uZmlnc2V0X2luaXQoJmdtX2NvbmZpZyk7Ci1pbnQgYjsKLS8qIHdlIGFkZCBjb25maWcgZmlsZXMgdG8gdGhlIGNvbmZpZ19zZXQgKi8KLWdpdF9jb25maWdzZXRfYWRkX2ZpbGUoJmdtX2NvbmZpZywgIi5naXRtb2R1bGVzIik7Ci1naXRfY29uZmlnc2V0X2FkZF9maWxlKCZnbV9jb25maWcsICIuZ2l0bW9kdWxlc19hbHQiKTsKLQotaWYgKCFnaXRfY29uZmlnc2V0X2dldF9ib29sKGdtX2NvbmZpZywgInN1Ym1vZHVsZS5mcm90ei5pZ25vcmUiLCAmYikpIHsKLQkvKiBoYWNrIGhhY2sgaGFjayAqLwotfQotCi0vKiB3aGVuIHdlIGFyZSBkb25lIHdpdGggdGhlIGNvbmZpZ3NldCAqLwotZ2l0X2NvbmZpZ3NldF9jbGVhcigmZ21fY29uZmlnKTsKLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KLQotQ29uZmlnc2V0IEFQSSBwcm92aWRlcyBmdW5jdGlvbnMgZm9yIHRoZSBhYm92ZSBtZW50aW9uZWQgd29yayBmbG93LCBpbmNsdWRpbmc6Ci0KLWB2b2lkIGdpdF9jb25maWdzZXRfaW5pdChzdHJ1Y3QgY29uZmlnX3NldCAqY3MpYDo6Ci0KLQlJbml0aWFsaXplcyB0aGUgY29uZmlnX3NldCBgY3NgLgotCi1gaW50IGdpdF9jb25maWdzZXRfYWRkX2ZpbGUoc3RydWN0IGNvbmZpZ19zZXQgKmNzLCBjb25zdCBjaGFyICpmaWxlbmFtZSlgOjoKLQotCVBhcnNlcyB0aGUgZmlsZSBhbmQgYWRkcyB0aGUgdmFyaWFibGUtdmFsdWUgcGFpcnMgdG8gdGhlIGBjb25maWdfc2V0YCwKLQlkaWVzIGlmIHRoZXJlIGlzIGFuIGVycm9yIGluIHBhcnNpbmcgdGhlIGZpbGUuIFJldHVybnMgMCBvbiBzdWNjZXNzLCBvcgotCS0xIGlmIHRoZSBmaWxlIGRvZXMgbm90IGV4aXN0IG9yIGlzIGluYWNjZXNzaWJsZS4gVGhlIHVzZXIgaGFzIHRvIGRlY2lkZQotCWlmIGhlIHdhbnRzIHRvIGZyZWUgdGhlIGluY29tcGxldGUgY29uZmlnc2V0IG9yIGNvbnRpbnVlIHVzaW5nIGl0IHdoZW4KLQl0aGUgZnVuY3Rpb24gcmV0dXJucyAtMS4KLQotYGludCBnaXRfY29uZmlnc2V0X2dldF92YWx1ZShzdHJ1Y3QgY29uZmlnX3NldCAqY3MsIGNvbnN0IGNoYXIgKmtleSwgY29uc3QgY2hhciAqKnZhbHVlKWA6OgotCi0JRmluZHMgdGhlIGhpZ2hlc3QtcHJpb3JpdHkgdmFsdWUgZm9yIHRoZSBjb25maWd1cmF0aW9uIHZhcmlhYmxlIGBrZXlgCi0JYW5kIGNvbmZpZyBzZXQgYGNzYCwgc3RvcmVzIHRoZSBwb2ludGVyIHRvIGl0IGluIGB2YWx1ZWAgYW5kIHJldHVybnMgMC4KLQlXaGVuIHRoZSBjb25maWd1cmF0aW9uIHZhcmlhYmxlIGBrZXlgIGlzIG5vdCBmb3VuZCwgcmV0dXJucyAxIHdpdGhvdXQKLQl0b3VjaGluZyBgdmFsdWVgLiBUaGUgY2FsbGVyIHNob3VsZCBub3QgZnJlZSBvciBtb2RpZnkgYHZhbHVlYCwgYXMgaXQKLQlpcyBvd25lZCBieSB0aGUgY2FjaGUuCi0KLWBjb25zdCBzdHJ1Y3Qgc3RyaW5nX2xpc3QgKmdpdF9jb25maWdzZXRfZ2V0X3ZhbHVlX211bHRpKHN0cnVjdCBjb25maWdfc2V0ICpjcywgY29uc3QgY2hhciAqa2V5KWA6OgotCi0JRmluZHMgYW5kIHJldHVybnMgdGhlIHZhbHVlIGxpc3QsIHNvcnRlZCBpbiBvcmRlciBvZiBpbmNyZWFzaW5nIHByaW9yaXR5Ci0JZm9yIHRoZSBjb25maWd1cmF0aW9uIHZhcmlhYmxlIGBrZXlgIGFuZCBjb25maWcgc2V0IGBjc2AuIFdoZW4gdGhlCi0JY29uZmlndXJhdGlvbiB2YXJpYWJsZSBga2V5YCBpcyBub3QgZm91bmQsIHJldHVybnMgTlVMTC4gVGhlIGNhbGxlcgotCXNob3VsZCBub3QgZnJlZSBvciBtb2RpZnkgdGhlIHJldHVybmVkIHBvaW50ZXIsIGFzIGl0IGlzIG93bmVkIGJ5IHRoZSBjYWNoZS4KLQotYHZvaWQgZ2l0X2NvbmZpZ3NldF9jbGVhcihzdHJ1Y3QgY29uZmlnX3NldCAqY3MpYDo6Ci0KLQlDbGVhcnMgYGNvbmZpZ19zZXRgIHN0cnVjdHVyZSwgcmVtb3ZlcyBhbGwgc2F2ZWQgdmFyaWFibGUtdmFsdWUgcGFpcnMuCi0KLUluIGFkZGl0aW9uIHRvIGFib3ZlIGZ1bmN0aW9ucywgdGhlIGBjb25maWdfc2V0YCBBUEkgcHJvdmlkZXMgdHlwZSBzcGVjaWZpYwotZnVuY3Rpb25zIGluIHRoZSB2ZWluIG9mIGBnaXRfY29uZmlnX2dldF9pbnRgIGFuZCBmYW1pbHkgYnV0IHdpdGggYW4gZXh0cmEKLXBhcmFtZXRlciwgcG9pbnRlciB0byBzdHJ1Y3QgYGNvbmZpZ19zZXRgLgotVGhleSBhbGwgYmVoYXZlIHNpbWlsYXJseSB0byB0aGUgYGdpdF9jb25maWdfZ2V0KigpYCBmYW1pbHkgZGVzY3JpYmVkIGluCi0iUXVlcnlpbmcgRm9yIFNwZWNpZmljIFZhcmlhYmxlcyIgYWJvdmUuCi0KLVdyaXRpbmcgQ29uZmlnIEZpbGVzCi0tLS0tLS0tLS0tLS0tLS0tLS0tLQotCi1HaXQgZ2l2ZXMgbXVsdGlwbGUgZW50cnkgcG9pbnRzIGluIHRoZSBDb25maWcgQVBJIHRvIHdyaXRlIGNvbmZpZyB2YWx1ZXMgdG8KLWZpbGVzIG5hbWVseSBgZ2l0X2NvbmZpZ19zZXRfaW5fZmlsZWAgYW5kIGBnaXRfY29uZmlnX3NldGAsIHdoaWNoIHdyaXRlIHRvCi1hIHNwZWNpZmljIGNvbmZpZyBmaWxlIG9yIHRvIGAuZ2l0L2NvbmZpZ2AgcmVzcGVjdGl2ZWx5LiBUaGV5IGJvdGggdGFrZSBhCi1rZXkvdmFsdWUgcGFpciBhcyBwYXJhbWV0ZXIuCi1JbiB0aGUgZW5kIHRoZXkgYm90aCBjYWxsIGBnaXRfY29uZmlnX3NldF9tdWx0aXZhcl9pbl9maWxlYCB3aGljaCB0YWtlcyBmb3VyCi1wYXJhbWV0ZXJzOgotCi0tIHRoZSBuYW1lIG9mIHRoZSBmaWxlLCBhcyBhIHN0cmluZywgdG8gd2hpY2gga2V5L3ZhbHVlIHBhaXJzIHdpbGwgYmUgd3JpdHRlbi4KLQotLSB0aGUgbmFtZSBvZiBrZXksIGFzIGEgc3RyaW5nLiBUaGlzIGlzIGluIGNhbm9uaWNhbCAiZmxhdCIgZm9ybTogdGhlIHNlY3Rpb24sCi0gIHN1YnNlY3Rpb24sIGFuZCB2YXJpYWJsZSBzZWdtZW50cyB3aWxsIGJlIHNlcGFyYXRlZCBieSBkb3RzLCBhbmQgdGhlIHNlY3Rpb24KLSAgYW5kIHZhcmlhYmxlIHNlZ21lbnRzIHdpbGwgYmUgYWxsIGxvd2VyY2FzZS4KLSAgRS5nLiwgYGNvcmUuaWdub3JlY2FzZWAsIGBkaWZmLlNvbWVUeXBlLnRleHRjb252YC4KLQotLSB0aGUgdmFsdWUgb2YgdGhlIHZhcmlhYmxlLCBhcyBhIHN0cmluZy4gSWYgdmFsdWUgaXMgZXF1YWwgdG8gTlVMTCwgaXQgd2lsbAotICByZW1vdmUgdGhlIG1hdGNoaW5nIGtleSBmcm9tIHRoZSBjb25maWcgZmlsZS4KLQotLSB0aGUgdmFsdWUgcmVnZXgsIGFzIGEgc3RyaW5nLiBJdCB3aWxsIGRpc3JlZ2FyZCBrZXkvdmFsdWUgcGFpcnMgd2hlcmUgdmFsdWUKLSAgZG9lcyBub3QgbWF0Y2guCi0KLS0gYSBtdWx0aV9yZXBsYWNlIHZhbHVlLCBhcyBhbiBpbnQuIElmIHZhbHVlIGlzIGVxdWFsIHRvIHplcm8sIG5vdGhpbmcgb3Igb25seQotICBvbmUgbWF0Y2hpbmcga2V5L3ZhbHVlIGlzIHJlcGxhY2VkLCBlbHNlIGFsbCBtYXRjaGluZyBrZXkvdmFsdWVzIChyZWdhcmRsZXNzCi0gIGhvdyBtYW55KSBhcmUgcmVtb3ZlZCwgYmVmb3JlIHRoZSBuZXcgcGFpciBpcyB3cml0dGVuLgotCi1JdCByZXR1cm5zIDAgb24gc3VjY2Vzcy4KLQotQWxzbywgdGhlcmUgYXJlIGZ1bmN0aW9ucyBgZ2l0X2NvbmZpZ19yZW5hbWVfc2VjdGlvbmAgYW5kCi1gZ2l0X2NvbmZpZ19yZW5hbWVfc2VjdGlvbl9pbl9maWxlYCB3aXRoIHBhcmFtZXRlcnMgYG9sZF9uYW1lYCBhbmQgYG5ld19uYW1lYAotZm9yIHJlbmFtaW5nIG9yIHJlbW92aW5nIHNlY3Rpb25zIGluIHRoZSBjb25maWcgZmlsZXMuIElmIE5VTEwgaXMgcGFzc2VkCi10aHJvdWdoIGBuZXdfbmFtZWAgcGFyYW1ldGVyLCB0aGUgc2VjdGlvbiB3aWxsIGJlIHJlbW92ZWQgZnJvbSB0aGUgY29uZmlnIGZpbGUuCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL3RlY2huaWNhbC9hcGktZGlyZWN0b3J5LWxpc3RpbmcudHh0IGIvRG9jdW1lbnRhdGlvbi90ZWNobmljYWwvYXBpLWRpcmVjdG9yeS1saXN0aW5nLnR4dAppbmRleCA1YWJiOGU4Li43NmI2ZTRmIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL3RlY2huaWNhbC9hcGktZGlyZWN0b3J5LWxpc3RpbmcudHh0CisrKyBiL0RvY3VtZW50YXRpb24vdGVjaG5pY2FsL2FwaS1kaXJlY3RvcnktbGlzdGluZy50eHQKQEAgLTExMSwxMSArMTExLDExIEBACiAqIFByZXBhcmUgYHN0cnVjdCBkaXJfc3RydWN0IGRpcmAgYW5kIGNsZWFyIGl0IHdpdGggYG1lbXNldCgmZGlyLCAwLAogICBzaXplb2YoZGlyKSlgLgogCi0qIFRvIGFkZCBzaW5nbGUgZXhjbHVkZSBwYXR0ZXJuLCBjYWxsIGBhZGRfZXhjbHVkZV9saXN0KClgIGFuZCB0aGVuCi0gIGBhZGRfZXhjbHVkZSgpYC4KKyogVG8gYWRkIHNpbmdsZSBleGNsdWRlIHBhdHRlcm4sIGNhbGwgYGFkZF9wYXR0ZXJuX2xpc3QoKWAgYW5kIHRoZW4KKyAgYGFkZF9wYXR0ZXJuKClgLgogCiAqIFRvIGFkZCBwYXR0ZXJucyBmcm9tIGEgZmlsZSAoZS5nLiBgLmdpdC9pbmZvL2V4Y2x1ZGVgKSwgY2FsbAotICBgYWRkX2V4Y2x1ZGVzX2Zyb21fZmlsZSgpYCAsIGFuZC9vciBzZXQgYGRpci5leGNsdWRlX3Blcl9kaXJgLiAgQQorICBgYWRkX3BhdHRlcm5zX2Zyb21fZmlsZSgpYCAsIGFuZC9vciBzZXQgYGRpci5leGNsdWRlX3Blcl9kaXJgLiAgQQogICBzaG9ydC1oYW5kIGZ1bmN0aW9uIGBzZXR1cF9zdGFuZGFyZF9leGNsdWRlcygpYCBjYW4gYmUgdXNlZCB0byBzZXQKICAgdXAgdGhlIHN0YW5kYXJkIHNldCBvZiBleGNsdWRlIHNldHRpbmdzLgogCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL3RlY2huaWNhbC9hcGktZ3JlcC50eHQgYi9Eb2N1bWVudGF0aW9uL3RlY2huaWNhbC9hcGktZ3JlcC50eHQKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGE2OWNjODkuLjAwMDAwMDAKLS0tIGEvRG9jdW1lbnRhdGlvbi90ZWNobmljYWwvYXBpLWdyZXAudHh0CisrKyAvZGV2L251bGwKQEAgLTEsOCArMCwwIEBACi1ncmVwIEFQSQotPT09PT09PT0KLQotVGFsayBhYm91dCA8Z3JlcC5oPiwgdGhpbmdzIGxpa2U6Ci0KLSogZ3JlcF9idWZmZXIoKQotCi0oSkMpCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL3RlY2huaWNhbC9hcGktb2JqZWN0LWFjY2Vzcy50eHQgYi9Eb2N1bWVudGF0aW9uL3RlY2huaWNhbC9hcGktb2JqZWN0LWFjY2Vzcy50eHQKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDViMjk2MjIuLjAwMDAwMDAKLS0tIGEvRG9jdW1lbnRhdGlvbi90ZWNobmljYWwvYXBpLW9iamVjdC1hY2Nlc3MudHh0CisrKyAvZGV2L251bGwKQEAgLTEsMTUgKzAsMCBAQAotb2JqZWN0IGFjY2VzcyBBUEkKLT09PT09PT09PT09PT09PT09Ci0KLVRhbGsgYWJvdXQgPHNoYTEtZmlsZS5jPiBhbmQgPG9iamVjdC5oPiBmYW1pbHksIHRoaW5ncyBsaWtlCi0KLSogcmVhZF9zaGExX2ZpbGUoKQotKiByZWFkX29iamVjdF93aXRoX3JlZmVyZW5jZSgpCi0qIGhhc19zaGExX2ZpbGUoKQotKiB3cml0ZV9zaGExX2ZpbGUoKQotKiBwcmV0ZW5kX29iamVjdF9maWxlKCkKLSogbG9va3VwX3tvYmplY3QsY29tbWl0LHRhZyxibG9iLHRyZWV9Ci0qIHBhcnNlX3tvYmplY3QsY29tbWl0LHRhZyxibG9iLHRyZWV9Ci0qIFVzZSBvZiBvYmplY3QgZmxhZ3MKLQotKEpDLCBTaGF3biwgRGFuaWVsLCBEc2NobywgTGludXMpCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL3RlY2huaWNhbC9hcGktcXVvdGUudHh0IGIvRG9jdW1lbnRhdGlvbi90ZWNobmljYWwvYXBpLXF1b3RlLnR4dApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZThhMWJjZS4uMDAwMDAwMAotLS0gYS9Eb2N1bWVudGF0aW9uL3RlY2huaWNhbC9hcGktcXVvdGUudHh0CisrKyAvZGV2L251bGwKQEAgLTEsMTAgKzAsMCBAQAotcXVvdGUgQVBJCi09PT09PT09PT0KLQotVGFsayBhYm91dCA8cXVvdGUuaD4sIHRoaW5ncyBsaWtlCi0KLSogc3FfcXVvdGUgYW5kIHVucXVvdGUKLSogY19zdHlsZSBxdW90ZSBhbmQgdW5xdW90ZQotKiBxdW90aW5nIGZvciBmb3JlaWduIGxhbmd1YWdlcwotCi0oSkMpCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL3RlY2huaWNhbC9hcGktc3VibW9kdWxlLWNvbmZpZy50eHQgYi9Eb2N1bWVudGF0aW9uL3RlY2huaWNhbC9hcGktc3VibW9kdWxlLWNvbmZpZy50eHQKaW5kZXggZmIwNjA4OS4uYzQwOTU1OSAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi90ZWNobmljYWwvYXBpLXN1Ym1vZHVsZS1jb25maWcudHh0CisrKyBiL0RvY3VtZW50YXRpb24vdGVjaG5pY2FsL2FwaS1zdWJtb2R1bGUtY29uZmlnLnR4dApAQCAtNTgsNyArNTgsNyBAQAogCiBXaGVuZXZlciBhIHN1Ym1vZHVsZSBjb25maWd1cmF0aW9uIGlzIHBhcnNlZCBpbiBgcGFyc2Vfc3VibW9kdWxlX2NvbmZpZ19vcHRpb25gCiB2aWEgZS5nLiBgZ2l0bW9kdWxlc19jb25maWcoKWAsIGl0IHdpbGwgb3ZlcndyaXRlIHRoZSBudWxsX3NoYTEgZW50cnkuCi1TbyBpbiB0aGUgbm9ybWFsIGNhc2UsIHdoZW4gSEVBRDouZ2l0bW9kdWxlcyBpcyBwYXJzZWQgZmlyc3QgYW5kIHRoZW4gb3ZlcmxheWVkCitTbyBpbiB0aGUgbm9ybWFsIGNhc2UsIHdoZW4gSEVBRDouZ2l0bW9kdWxlcyBpcyBwYXJzZWQgZmlyc3QgYW5kIHRoZW4gb3ZlcmxhaWQKIHdpdGggdGhlIHJlcG9zaXRvcnkgY29uZmlndXJhdGlvbiwgdGhlIG51bGxfc2hhMSBlbnRyeSBjb250YWlucyB0aGUgbG9jYWwKIGNvbmZpZ3VyYXRpb24gb2YgYSBzdWJtb2R1bGUgKGUuZy4gY29uc29saWRhdGVkIHZhbHVlcyBmcm9tIGxvY2FsIGdpdAogY29uZmlndXJhdGlvbiBhbmQgdGhlIC5naXRtb2R1bGVzIGZpbGUgaW4gdGhlIHdvcmt0cmVlKS4KZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vdGVjaG5pY2FsL2FwaS10cmFjZTIudHh0IGIvRG9jdW1lbnRhdGlvbi90ZWNobmljYWwvYXBpLXRyYWNlMi50eHQKaW5kZXggNzFlYjA4MS4uMTc0OTBiNSAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi90ZWNobmljYWwvYXBpLXRyYWNlMi50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi90ZWNobmljYWwvYXBpLXRyYWNlMi50eHQKQEAgLTEyOCw3ICsxMjgsNyBAQAogCiAtLS0tLS0tLS0tLS0KICQgY2F0IH4vbG9nLmV2ZW50Ci17ImV2ZW50IjoidmVyc2lvbiIsInNpZCI6InNpZCI6IjIwMTkwNDA4VDE5MTYxMC41MDcwMThaLUg5YjY4YzM1Zi1QMDAwMDU5YTgiLCJ0aHJlYWQiOiJtYWluIiwidGltZSI6IjIwMTktMDEtMTZUMTc6Mjg6NDIuNjIwNzEzWiIsImZpbGUiOiJjb21tb24tbWFpbi5jIiwibGluZSI6MzgsImV2dCI6IjEiLCJleGUiOiIyLjIwLjEuMTU1Lmc0MjZjOTZmY2RiIn0KK3siZXZlbnQiOiJ2ZXJzaW9uIiwic2lkIjoic2lkIjoiMjAxOTA0MDhUMTkxNjEwLjUwNzAxOFotSDliNjhjMzVmLVAwMDAwNTlhOCIsInRocmVhZCI6Im1haW4iLCJ0aW1lIjoiMjAxOS0wMS0xNlQxNzoyODo0Mi42MjA3MTNaIiwiZmlsZSI6ImNvbW1vbi1tYWluLmMiLCJsaW5lIjozOCwiZXZ0IjoiMiIsImV4ZSI6IjIuMjAuMS4xNTUuZzQyNmM5NmZjZGIifQogeyJldmVudCI6InN0YXJ0Iiwic2lkIjoiMjAxOTA0MDhUMTkxNjEwLjUwNzAxOFotSDliNjhjMzVmLVAwMDAwNTlhOCIsInRocmVhZCI6Im1haW4iLCJ0aW1lIjoiMjAxOS0wMS0xNlQxNzoyODo0Mi42MjEwMjdaIiwiZmlsZSI6ImNvbW1vbi1tYWluLmMiLCJsaW5lIjozOSwidF9hYnMiOjAuMDAxMTczLCJhcmd2IjpbImdpdCIsInZlcnNpb24iXX0KIHsiZXZlbnQiOiJjbWRfbmFtZSIsInNpZCI6IjIwMTkwNDA4VDE5MTYxMC41MDcwMThaLUg5YjY4YzM1Zi1QMDAwMDU5YTgiLCJ0aHJlYWQiOiJtYWluIiwidGltZSI6IjIwMTktMDEtMTZUMTc6Mjg6NDIuNjIxMTIyWiIsImZpbGUiOiJnaXQuYyIsImxpbmUiOjQzMiwibmFtZSI6InZlcnNpb24iLCJoaWVyYXJjaHkiOiJ2ZXJzaW9uIn0KIHsiZXZlbnQiOiJleGl0Iiwic2lkIjoiMjAxOTA0MDhUMTkxNjEwLjUwNzAxOFotSDliNjhjMzVmLVAwMDAwNTlhOCIsInRocmVhZCI6Im1haW4iLCJ0aW1lIjoiMjAxOS0wMS0xNlQxNzoyODo0Mi42MjEyMzZaIiwiZmlsZSI6ImdpdC5jIiwibGluZSI6NjYyLCJ0X2FicyI6MC4wMDEyMjcsImNvZGUiOjB9CkBAIC0xNDIsMTAgKzE0Miw5IEBACiAKIGluY2x1ZGU6Oi4uL3RyYWNlMi10YXJnZXQtdmFsdWVzLnR4dFtdCiAKLUlmIHRoZSB0YXJnZXQgYWxyZWFkeSBleGlzdHMgYW5kIGlzIGEgZGlyZWN0b3J5LCB0aGUgdHJhY2VzIHdpbGwgYmUKLXdyaXR0ZW4gdG8gZmlsZXMgKG9uZSBwZXIgcHJvY2VzcykgdW5kZXJuZWF0aCB0aGUgZ2l2ZW4gZGlyZWN0b3J5LiBUaGV5Ci13aWxsIGJlIG5hbWVkIGFjY29yZGluZyB0byB0aGUgbGFzdCBjb21wb25lbnQgb2YgdGhlIFNJRCAob3B0aW9uYWxseQotZm9sbG93ZWQgYnkgYSBjb3VudGVyIHRvIGF2b2lkIGZpbGVuYW1lIGNvbGxpc2lvbnMpLgorV2hlbiB0cmFjZSBmaWxlcyBhcmUgd3JpdHRlbiB0byBhIHRhcmdldCBkaXJlY3RvcnksIHRoZXkgd2lsbCBiZSBuYW1lZCBhY2NvcmRpbmcKK3RvIHRoZSBsYXN0IGNvbXBvbmVudCBvZiB0aGUgU0lEIChvcHRpb25hbGx5IGZvbGxvd2VkIGJ5IGEgY291bnRlciB0byBhdm9pZAorZmlsZW5hbWUgY29sbGlzaW9ucykuCiAKID09IFRyYWNlMiBBUEkKIApAQCAtMTc5LDcgKzE3OCw3IEBACiAKID09IFB1YmxpYyBBUEkKIAotQWxsIFRyYWNlMiBBUEkgZnVuY3Rpb25zIHNlbmQgYSBtZXNzc2FnZSB0byBhbGwgb2YgdGhlIGFjdGl2ZQorQWxsIFRyYWNlMiBBUEkgZnVuY3Rpb25zIHNlbmQgYSBtZXNzYWdlIHRvIGFsbCBvZiB0aGUgYWN0aXZlCiBUcmFjZTIgVGFyZ2V0cy4gIFRoaXMgc2VjdGlvbiBkZXNjcmliZXMgdGhlIHNldCBvZiBhdmFpbGFibGUKIG1lc3NhZ2VzLgogCkBAIC0zNzgsNyArMzc3LDcgQEAKIAlhbmQgdGhlIHRocmVhZCBlbGFwc2VkIHRpbWUuCiArCiBUaGlzIGZ1bmN0aW9uIG11c3QgYmUgY2FsbGVkIGJ5IHRoZSB0aHJlYWQtcHJvYyBiZWZvcmUgaXQgcmV0dXJucwotKHNvIHRoYXQgdGhlIGNvb3JlY3QgVExTIGRhdGEgaXMgdXNlZCBhbmQgY2xlYW5lZCB1cC4gIEl0IHNob3VsZAorKHNvIHRoYXQgdGhlIGNvcnJlY3QgVExTIGRhdGEgaXMgdXNlZCBhbmQgY2xlYW5lZCB1cCkuICBJdCBzaG91bGQKIG5vdCBiZSBjYWxsZWQgYnkgdGhlIGNhbGxlciBvZiBgcHRocmVhZF9qb2luKClgLgogCiA9PT0gUmVnaW9uIGFuZCBEYXRhIE1lc3NhZ2VzCkBAIC00MDcsNyArNDA2LDcgQEAKIGJlaW5nIHN0YXJ0ZWQsIHN1Y2ggYXMgInJlYWRfcmVjdXJzaXZlIiBvciAiZG9fcmVhZF9pbmRleCIuCiArCiBUaGUgYHJlcG9gIGZpZWxkLCBpZiBzZXQsIHdpbGwgYmUgdXNlZCB0byBnZXQgdGhlICJyZXBvLWlkIiwgc28gdGhhdAotcmVjdXJzaXZlIG9lcmF0aW9ucyBjYW4gYmUgYXR0cmlidXRlZCB0byB0aGUgY29ycmVjdCByZXBvc2l0b3J5LgorcmVjdXJzaXZlIG9wZXJhdGlvbnMgY2FuIGJlIGF0dHJpYnV0ZWQgdG8gdGhlIGNvcnJlY3QgcmVwb3NpdG9yeS4KIAogYHZvaWQgdHJhY2UyX3JlZ2lvbl9sZWF2ZShjb25zdCBjaGFyICpjYXRlZ29yeSwgY29uc3QgY2hhciAqbGFiZWwsIGNvbnN0IHN0cnVjdCByZXBvc2l0b3J5ICpyZXBvKWA6OgogCkBAIC00MjIsNyArNDIxLDcgQEAKIGFuZCByZXBvcnRzIHRoZSBlbGFwc2VkIHRpbWUgb2YgdGhlIHN0YWNrIGZyYW1lLgogKwogVGhlIGBjYXRlZ29yeWAsIGBsYWJlbGAsIGFuZCBgcmVwb2AgZmllbGRzIGFyZSB0aGUgc2FtZSBhcyBhYm92ZS4KLVRoZSBgY2F0ZWdvcnlgIGFuZCBgbGFiZWxgIGRvIG5vdCBuZWVkIHRvIG1hdGNoIHRoZSBjb3JyZXBzb25kaW5nCitUaGUgYGNhdGVnb3J5YCBhbmQgYGxhYmVsYCBkbyBub3QgbmVlZCB0byBtYXRjaCB0aGUgY29ycmVzcG9uZGluZwogInJlZ2lvbl9lbnRlciIgbWVzc2FnZSwgYnV0IGl0IG1ha2VzIHRoZSBkYXRhIHN0cmVhbSBlYXNpZXIgdG8KIHVuZGVyc3RhbmQuCiAKQEAgLTYwNSwxNyArNjA0LDM1IEBACiA9PT09IEV2ZW50LVNwZWNpZmljIEtleS9WYWx1ZSBQYWlycwogCiBgInZlcnNpb24iYDo6Ci0JVGhpcyBldmVudCBnaXZlcyB0aGUgdmVyc2lvbiBvZiB0aGUgZXhlY3V0YWJsZSBhbmQgdGhlIEVWRU5UIGZvcm1hdC4KKwlUaGlzIGV2ZW50IGdpdmVzIHRoZSB2ZXJzaW9uIG9mIHRoZSBleGVjdXRhYmxlIGFuZCB0aGUgRVZFTlQgZm9ybWF0LiBJdAorCXNob3VsZCBhbHdheXMgYmUgdGhlIGZpcnN0IGV2ZW50IGluIGEgdHJhY2Ugc2Vzc2lvbi4gVGhlIEVWRU5UIGZvcm1hdAorCXZlcnNpb24gd2lsbCBiZSBpbmNyZW1lbnRlZCBpZiBuZXcgZXZlbnQgdHlwZXMgYXJlIGFkZGVkLCBpZiBleGlzdGluZworCWZpZWxkcyBhcmUgcmVtb3ZlZCwgb3IgaWYgdGhlcmUgYXJlIHNpZ25pZmljYW50IGNoYW5nZXMgaW4KKwlpbnRlcnByZXRhdGlvbiBvZiBleGlzdGluZyBldmVudHMgb3IgZmllbGRzLiBTbWFsbGVyIGNoYW5nZXMsIHN1Y2ggYXMKKwlhZGRpbmcgYSBuZXcgZmllbGQgdG8gYW4gZXhpc3RpbmcgZXZlbnQsIHdpbGwgbm90IHJlcXVpcmUgYW4gaW5jcmVtZW50CisJdG8gdGhlIEVWRU5UIGZvcm1hdCB2ZXJzaW9uLgogKwogLS0tLS0tLS0tLS0tCiB7CiAJImV2ZW50IjoidmVyc2lvbiIsCiAJLi4uCi0JImV2dCI6IjEiLAkJICAgICAgICMgRVZFTlQgZm9ybWF0IHZlcnNpb24KKwkiZXZ0IjoiMiIsCQkgICAgICAgIyBFVkVOVCBmb3JtYXQgdmVyc2lvbgogCSJleGUiOiIyLjIwLjEuMTU1Lmc0MjZjOTZmY2RiIiAjIGdpdCB2ZXJzaW9uCiB9CiAtLS0tLS0tLS0tLS0KIAorYCJkaXNjYXJkImA6OgorCVRoaXMgZXZlbnQgaXMgd3JpdHRlbiB0byB0aGUgZ2l0LXRyYWNlMi1kaXNjYXJkIHNlbnRpbmVsIGZpbGUgaWYgdGhlcmUKKwlhcmUgdG9vIG1hbnkgZmlsZXMgaW4gdGhlIHRhcmdldCB0cmFjZSBkaXJlY3RvcnkgKHNlZSB0aGUKKwl0cmFjZTIubWF4RmlsZXMgY29uZmlnIG9wdGlvbikuCisrCistLS0tLS0tLS0tLS0KK3sKKwkiZXZlbnQiOiJkaXNjYXJkIiwKKwkuLi4KK30KKy0tLS0tLS0tLS0tLQorCiBgInN0YXJ0ImA6OgogCVRoaXMgZXZlbnQgY29udGFpbnMgdGhlIGNvbXBsZXRlIGFyZ3YgcmVjZWl2ZWQgYnkgbWFpbigpLgogKwpAQCAtNzk5LDcgKzgxNiw3IEBACiBOb3RlIHRoYXQgdGhlIHNlc3Npb24taWQgb2YgdGhlIGNoaWxkIHByb2Nlc3MgaXMgbm90IGF2YWlsYWJsZSB0bwogdGhlIGN1cnJlbnQvc3Bhd25pbmcgcHJvY2Vzcywgc28gdGhlIGNoaWxkJ3MgUElEIGlzIHJlcG9ydGVkIGhlcmUgYXMKIGEgaGludCBmb3IgcG9zdC1wcm9jZXNzaW5nLiAgKEJ1dCBpdCBpcyBvbmx5IGEgaGludCBiZWNhdXNlIHRoZSBjaGlsZAotcHJvY2VzIG1heSBiZSBhIHNoZWxsIHNjcmlwdCB3aGljaCBkb2Vzbid0IGhhdmUgYSBzZXNzaW9uLWlkLikKK3Byb2Nlc3MgbWF5IGJlIGEgc2hlbGwgc2NyaXB0IHdoaWNoIGRvZXNuJ3QgaGF2ZSBhIHNlc3Npb24taWQuKQogKwogTm90ZSB0aGF0IHRoZSBgdF9yZWxgIGZpZWxkIGNvbnRhaW5zIHRoZSBvYnNlcnZlZCBydW4gdGltZSBpbiBzZWNvbmRzCiBmb3IgdGhlIGNoaWxkIHByb2Nlc3MgKHN0YXJ0aW5nIGJlZm9yZSB0aGUgZm9yay9leGVjL3NwYXduIGFuZApAQCAtMTE1OSw3ICsxMTc2LDcgQEAKICsKIFJlZ2lvbnMgbWF5IGJlIG5lc3RlZC4gIFRoaXMgY2F1c2VzIG1lc3NhZ2VzIHRvIGJlIGluZGVudGVkIGluIHRoZQogUEVSRiB0YXJnZXQsIGZvciBleGFtcGxlLgotRWxhcHNlZCB0aW1lcyBhcmUgcmVsYXRpdmUgdG8gdGhlIHN0YXJ0IG9mIHRoZSBjb3JyZXBzb25kaW5nIG5lc3RpbmcKK0VsYXBzZWQgdGltZXMgYXJlIHJlbGF0aXZlIHRvIHRoZSBzdGFydCBvZiB0aGUgY29ycmVzcG9uZGluZyBuZXN0aW5nCiBsZXZlbCBhcyBleHBlY3RlZC4gIEZvciBleGFtcGxlLCBpZiB3ZSBhZGQgcmVnaW9uIG1lc3NhZ2UgdG86CiArCiAtLS0tLS0tLS0tLS0tLS0tCkBAIC0xMzU0LDcgKzEzNzEsNyBAQAogSW4gdGhpcyBleGFtcGxlLCB0aGUgcHJlbG9hZCByZWdpb24gdG9vayAwLjAwOTEyMiBzZWNvbmRzLiAgVGhlIDcgdGhyZWFkcwogdG9vayBiZXR3ZWVuIDAuMDA2MDY5IGFuZCAwLjAwODk0NyBzZWNvbmRzIHRvIHdvcmsgb24gdGhlaXIgcG9ydGlvbiBvZgogdGhlIGluZGV4LiAgVGhyZWFkICJ0aDAxIiB3b3JrZWQgb24gNTA4IGl0ZW1zIGF0IG9mZnNldCAwLiAgVGhyZWFkICJ0aDAyIgotd29ya2VkIG9uIDUwOCBpdGVtcyBhdCBvZmZzZXQgMjAzMi4gIFRocmVhZCAidGgwNCIgd29ya2VkIG9uIDUwOCBpdGVtdHMKK3dvcmtlZCBvbiA1MDggaXRlbXMgYXQgb2Zmc2V0IDIwMzIuICBUaHJlYWQgInRoMDQiIHdvcmtlZCBvbiA1MDggaXRlbXMKIGF0IG9mZnNldCA1MDguCiArCiBUaGlzIGV4YW1wbGUgYWxzbyBzaG93cyB0aGF0IHRocmVhZCBuYW1lcyBhcmUgYXNzaWduZWQgaW4gYSByYWN5IG1hbm5lcgpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi90ZWNobmljYWwvYXBpLXRyZWUtd2Fsa2luZy50eHQgYi9Eb2N1bWVudGF0aW9uL3RlY2huaWNhbC9hcGktdHJlZS13YWxraW5nLnR4dAppbmRleCBiZGUxODYyLi43OTYyZTMyIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL3RlY2huaWNhbC9hcGktdHJlZS13YWxraW5nLnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL3RlY2huaWNhbC9hcGktdHJlZS13YWxraW5nLnR4dApAQCAtNjIsOSArNjIsNyBAQAogYHNldHVwX3RyYXZlcnNlX2luZm9gOjoKIAogCUluaXRpYWxpemUgYSBgdHJhdmVyc2VfaW5mb2AgZ2l2ZW4gdGhlIHBhdGhuYW1lIG9mIHRoZSB0cmVlIHRvIHN0YXJ0Ci0JdHJhdmVyc2luZyBmcm9tLiBUaGUgYGJhc2VgIGFyZ3VtZW50IGlzIGFzc3VtZWQgdG8gYmUgdGhlIGBwYXRoYAotCW1lbWJlciBvZiB0aGUgYG5hbWVfZW50cnlgIGJlaW5nIHJlY3Vyc2VkIGludG8gdW5sZXNzIHRoZSB0cmVlIGlzIGEKLQl0b3AtbGV2ZWwgdHJlZSBpbiB3aGljaCBjYXNlIHRoZSBlbXB0eSBzdHJpbmcgKCIiKSBpcyB1c2VkLgorCXRyYXZlcnNpbmcgZnJvbS4KIAogV2Fsa2luZwogLS0tLS0tLQpAQCAtMTQwLDYgKzEzOCwxMCBAQAogCVRoaXMgdXRpbGl6ZXMgdGhlIG1lbW9yeSBzdHJ1Y3R1cmUgb2YgYSB0cmVlIGVudHJ5IHRvIGF2b2lkIHRoZQogCW92ZXJoZWFkIG9mIHVzaW5nIGEgZ2VuZXJpYyBzdHJsZW4oKS4KIAorYHN0cmJ1Zl9tYWtlX3RyYXZlcnNlX3BhdGhgOjoKKworCUNvbnZlbmllbmNlIHdyYXBwZXIgdG8gYG1ha2VfdHJhdmVyc2VfcGF0aGAgaW50byBhIHN0cmJ1Zi4KKwogQXV0aG9ycwogLS0tLS0tLQogCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL3RlY2huaWNhbC9hcGkteGRpZmYtaW50ZXJmYWNlLnR4dCBiL0RvY3VtZW50YXRpb24vdGVjaG5pY2FsL2FwaS14ZGlmZi1pbnRlcmZhY2UudHh0CmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA2Mjk2ZWNhLi4wMDAwMDAwCi0tLSBhL0RvY3VtZW50YXRpb24vdGVjaG5pY2FsL2FwaS14ZGlmZi1pbnRlcmZhY2UudHh0CisrKyAvZGV2L251bGwKQEAgLTEsNyArMCwwIEBACi14ZGlmZiBpbnRlcmZhY2UgQVBJCi09PT09PT09PT09PT09PT09PT09Ci0KLVRhbGsgYWJvdXQgb3VyIGNhbGxpbmcgY29udmVudGlvbiB0byB4ZGlmZiBsaWJyYXJ5LCBpbmNsdWRpbmcKLXhkaWZmX2VtaXRfY29uc3VtZV9mbi4KLQotKERzY2hvLCBKQykKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vdGVjaG5pY2FsL2NvbW1pdC1ncmFwaC50eHQgYi9Eb2N1bWVudGF0aW9uL3RlY2huaWNhbC9jb21taXQtZ3JhcGgudHh0CmluZGV4IDcyOWZiY2IuLjE1MDcxMTcgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vdGVjaG5pY2FsL2NvbW1pdC1ncmFwaC50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi90ZWNobmljYWwvY29tbWl0LWdyYXBoLnR4dApAQCAtMjIsMTEgKzIyLDExIEBACiBkaXJlY3Rvcnkgb2YgYW4gYWx0ZXJuYXRlLgogCiBUaGUgY29tbWl0LWdyYXBoIGZpbGUgc3RvcmVzIHRoZSBjb21taXQgZ3JhcGggc3RydWN0dXJlIGFsb25nIHdpdGggc29tZQotZXh0cmEgbWV0YWRhdGEgdG8gc3BlZWQgdXAgZ3JhcGggd2Fsa3MuIEJ5IGxpc3RpbmcgY29tbWl0IE9JRHMgaW4gbGV4aS0KLWNvZ3JhcGhpYyBvcmRlciwgd2UgY2FuIGlkZW50aWZ5IGFuIGludGVnZXIgcG9zaXRpb24gZm9yIGVhY2ggY29tbWl0IGFuZAotcmVmZXIgdG8gdGhlIHBhcmVudHMgb2YgYSBjb21taXQgdXNpbmcgdGhvc2UgaW50ZWdlciBwb3NpdGlvbnMuIFdlIHVzZQotYmluYXJ5IHNlYXJjaCB0byBmaW5kIGluaXRpYWwgY29tbWl0cyBhbmQgdGhlbiB1c2UgdGhlIGludGVnZXIgcG9zaXRpb25zCi1mb3IgZmFzdCBsb29rdXBzIGR1cmluZyB0aGUgd2Fsay4KK2V4dHJhIG1ldGFkYXRhIHRvIHNwZWVkIHVwIGdyYXBoIHdhbGtzLiBCeSBsaXN0aW5nIGNvbW1pdCBPSURzIGluCitsZXhpY29ncmFwaGljIG9yZGVyLCB3ZSBjYW4gaWRlbnRpZnkgYW4gaW50ZWdlciBwb3NpdGlvbiBmb3IgZWFjaCBjb21taXQKK2FuZCByZWZlciB0byB0aGUgcGFyZW50cyBvZiBhIGNvbW1pdCB1c2luZyB0aG9zZSBpbnRlZ2VyIHBvc2l0aW9ucy4gV2UKK3VzZSBiaW5hcnkgc2VhcmNoIHRvIGZpbmQgaW5pdGlhbCBjb21taXRzIGFuZCB0aGVuIHVzZSB0aGUgaW50ZWdlcgorcG9zaXRpb25zIGZvciBmYXN0IGxvb2t1cHMgZHVyaW5nIHRoZSB3YWxrLgogCiBBIGNvbnN1bWVyIG1heSBsb2FkIHRoZSBmb2xsb3dpbmcgaW5mbyBmb3IgYSBjb21taXQgZnJvbSB0aGUgZ3JhcGg6CiAKQEAgLTg1LDcgKzg1LDcgQEAKIFNpbmNlIHRoZSBjb21taXQtZ3JhcGggZmlsZSBpcyBjbG9zZWQgdW5kZXIgcmVhY2hhYmlsaXR5LCB3ZSBjYW4gZ3VhcmFudGVlCiB0aGUgZm9sbG93aW5nIHdlYWtlciBjb25kaXRpb24gb24gYWxsIGNvbW1pdHM6CiAKLSAgICBJZiBBIGFuZCBCIGFyZSBjb21taXRzIHdpdGggZ2VuZXJhdGlvbiBudW1iZXJzIE4gYW1kIE0sIHJlc3BlY3RpdmVseSwKKyAgICBJZiBBIGFuZCBCIGFyZSBjb21taXRzIHdpdGggZ2VuZXJhdGlvbiBudW1iZXJzIE4gYW5kIE0sIHJlc3BlY3RpdmVseSwKICAgICBhbmQgTiA8IE0sIHRoZW4gQSBjYW5ub3QgcmVhY2ggQi4KIAogTm90ZSBob3cgdGhlIHN0cmljdCBpbmVxdWFsaXR5IGRpZmZlcnMgZnJvbSB0aGUgaW5lcXVhbGl0eSB3aGVuIHdlIGhhdmUKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vdGVjaG5pY2FsL2hhc2gtZnVuY3Rpb24tdHJhbnNpdGlvbi50eHQgYi9Eb2N1bWVudGF0aW9uL3RlY2huaWNhbC9oYXNoLWZ1bmN0aW9uLXRyYW5zaXRpb24udHh0CmluZGV4IDJhZThmYTQuLjhhNDU5NmIgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vdGVjaG5pY2FsL2hhc2gtZnVuY3Rpb24tdHJhbnNpdGlvbi50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi90ZWNobmljYWwvaGFzaC1mdW5jdGlvbi10cmFuc2l0aW9uLnR4dApAQCAtNTMxLDcgKzUzMSw3IEBACiBvbiBwdWJsaWMtZmFjaW5nIEdpdCBzZXJ2ZXJzIGlzIHN0cm9uZ2x5IGRpc2NvdXJhZ2VkLiBPbmNlIEdpdAogcHJvdG9jb2wgZ2FpbnMgU0hBLTI1NiBzdXBwb3J0LCBTSEEtMjU2IGJhc2VkIHNlcnZlcnMgYXJlIGxpa2VseSBub3QKIHRvIHN1cHBvcnQgU0hBLTEgY29tcGF0aWJpbGl0eSwgdG8gYXZvaWQgd2hhdCBtYXkgYmUgYSB2ZXJ5IGV4cGVuc2l2ZQotaGFzaCByZWVuY29kZSBkdXJpbmcgY2xvbmUgYW5kIHRvIGVuY291cmFnZSBwZWVycyB0byBtb2Rlcm5pemUuCitoYXNoIHJlLWVuY29kZSBkdXJpbmcgY2xvbmUgYW5kIHRvIGVuY291cmFnZSBwZWVycyB0byBtb2Rlcm5pemUuCiAKIFRoZSBkZXNpZ24gZGVzY3JpYmVkIGhlcmUgYWxsb3dzIGZldGNoZXMgYnkgU0hBLTEgY2xpZW50cyBvZiBhCiBwZXJzb25hbCBTSEEtMjU2IHJlcG9zaXRvcnkgYmVjYXVzZSBpdCdzIG5vdCBtdWNoIG1vcmUgZGlmZmljdWx0IHRoYW4KQEAgLTYwMiw3ICs2MDIsNyBAQAogCiBDaG9pY2Ugb2YgSGFzaAogLS0tLS0tLS0tLS0tLS0KLUluIGVhcmx5IDIwMDUsIGFyb3VuZCB0aGUgdGltZSB0aGF0IEdpdCB3YXMgd3JpdHRlbiwgIFhpYW95dW4gV2FuZywKK0luIGVhcmx5IDIwMDUsIGFyb3VuZCB0aGUgdGltZSB0aGF0IEdpdCB3YXMgd3JpdHRlbiwgWGlhb3l1biBXYW5nLAogWWlxdW4gTGlzYSBZaW4sIGFuZCBIb25nYm8gWXUgYW5ub3VuY2VkIGFuIGF0dGFjayBmaW5kaW5nIFNIQS0xCiBjb2xsaXNpb25zIGluIDJeNjkgb3BlcmF0aW9ucy4gSW4gQXVndXN0IHRoZXkgcHVibGlzaGVkIGRldGFpbHMuCiBMdWNraWx5LCBubyBwcmFjdGljYWwgZGVtb25zdHJhdGlvbnMgb2YgYSBjb2xsaXNpb24gaW4gZnVsbCBTSEEtMSB3ZXJlCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL3RlY2huaWNhbC9pbmRleC1mb3JtYXQudHh0IGIvRG9jdW1lbnRhdGlvbi90ZWNobmljYWwvaW5kZXgtZm9ybWF0LnR4dAppbmRleCA3YzRkNjdhLi5mYWEyNWM1IDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL3RlY2huaWNhbC9pbmRleC1mb3JtYXQudHh0CisrKyBiL0RvY3VtZW50YXRpb24vdGVjaG5pY2FsL2luZGV4LWZvcm1hdC50eHQKQEAgLTMxOCw3ICszMTgsNyBAQAogPT0gRW5kIG9mIEluZGV4IEVudHJ5CiAKICAgVGhlIEVuZCBvZiBJbmRleCBFbnRyeSAoRU9JRSkgaXMgdXNlZCB0byBsb2NhdGUgdGhlIGVuZCBvZiB0aGUgdmFyaWFibGUKLSAgbGVuZ3RoIGluZGV4IGVudHJpZXMgYW5kIHRoZSBiZWdpbmluZyBvZiB0aGUgZXh0ZW5zaW9ucy4gQ29kZSBjYW4gdGFrZQorICBsZW5ndGggaW5kZXggZW50cmllcyBhbmQgdGhlIGJlZ2lubmluZyBvZiB0aGUgZXh0ZW5zaW9ucy4gQ29kZSBjYW4gdGFrZQogICBhZHZhbnRhZ2Ugb2YgdGhpcyB0byBxdWlja2x5IGxvY2F0ZSB0aGUgaW5kZXggZXh0ZW5zaW9ucyB3aXRob3V0IGhhdmluZwogICB0byBwYXJzZSB0aHJvdWdoIGFsbCBvZiB0aGUgaW5kZXggZW50cmllcy4KIApAQCAtMzUxLDcgKzM1MSw3IEBACiAKICAgLSBBIG51bWJlciBvZiBpbmRleCBvZmZzZXQgZW50cmllcyBlYWNoIGNvbnNpc3Rpbmcgb2Y6CiAKLSAgICAtIDMyLWJpdCBvZmZzZXQgZnJvbSB0aGUgYmVnaW5pbmcgb2YgdGhlIGZpbGUgdG8gdGhlIGZpcnN0IGNhY2hlIGVudHJ5CisgICAgLSAzMi1iaXQgb2Zmc2V0IGZyb20gdGhlIGJlZ2lubmluZyBvZiB0aGUgZmlsZSB0byB0aGUgZmlyc3QgY2FjaGUgZW50cnkKIAlpbiB0aGlzIGJsb2NrIG9mIGVudHJpZXMuCiAKICAgICAtIDMyLWJpdCBjb3VudCBvZiBjYWNoZSBlbnRyaWVzIGluIHRoaXMgYmxvY2sKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vdGVjaG5pY2FsL3BhY2stcHJvdG9jb2wudHh0IGIvRG9jdW1lbnRhdGlvbi90ZWNobmljYWwvcGFjay1wcm90b2NvbC50eHQKaW5kZXggYzczZTcyZC4uZDVjZTRlZSAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi90ZWNobmljYWwvcGFjay1wcm90b2NvbC50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi90ZWNobmljYWwvcGFjay1wcm90b2NvbC50eHQKQEAgLTY0NCw3ICs2NDQsNyBAQAogICBjb21tYW5kLW9rICAgICAgICA9IFBLVC1MSU5FKCJvayIgU1AgcmVmbmFtZSkKICAgY29tbWFuZC1mYWlsICAgICAgPSBQS1QtTElORSgibmciIFNQIHJlZm5hbWUgU1AgZXJyb3ItbXNnKQogCi0gIGVycm9yLW1zZyAgICAgICAgID0gMSooT0NURUNUKSA7IHdoZXJlIG5vdCAib2siCisgIGVycm9yLW1zZyAgICAgICAgID0gMSooT0NURVQpIDsgd2hlcmUgbm90ICJvayIKIC0tLS0KIAogVXBkYXRlcyBjYW4gYmUgdW5zdWNjZXNzZnVsIGZvciBhIG51bWJlciBvZiByZWFzb25zLiAgVGhlIHJlZmVyZW5jZSBjYW4gaGF2ZQpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi90ZWNobmljYWwvcGFydGlhbC1jbG9uZS50eHQgYi9Eb2N1bWVudGF0aW9uL3RlY2huaWNhbC9wYXJ0aWFsLWNsb25lLnR4dAppbmRleCA4OTZjN2IzLi5hNjAzNGQ1IDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL3RlY2huaWNhbC9wYXJ0aWFsLWNsb25lLnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL3RlY2huaWNhbC9wYXJ0aWFsLWNsb25lLnR4dApAQCAtMzAsMTIgKzMwLDIwIEBACiB0aW1lcyBhbmQgZGlzayB1c2FnZS4gIE1pc3Npbmcgb2JqZWN0cyBjYW4gbGF0ZXIgYmUgImRlbWFuZCBmZXRjaGVkIgogaWYvd2hlbiBuZWVkZWQuCiAKK0EgcmVtb3RlIHRoYXQgY2FuIGxhdGVyIHByb3ZpZGUgdGhlIG1pc3Npbmcgb2JqZWN0cyBpcyBjYWxsZWQgYQorcHJvbWlzb3IgcmVtb3RlLCBhcyBpdCBwcm9taXNlcyB0byBzZW5kIHRoZSBvYmplY3RzIHdoZW4KK3JlcXVlc3RlZC4gSW5pdGlhbGx5IEdpdCBzdXBwb3J0ZWQgb25seSBvbmUgcHJvbWlzb3IgcmVtb3RlLCB0aGUgb3JpZ2luCityZW1vdGUgZnJvbSB3aGljaCB0aGUgdXNlciBjbG9uZWQgYW5kIHRoYXQgd2FzIGNvbmZpZ3VyZWQgaW4gdGhlCisiZXh0ZW5zaW9ucy5wYXJ0aWFsQ2xvbmUiIGNvbmZpZyBvcHRpb24uIExhdGVyIHN1cHBvcnQgZm9yIG1vcmUgdGhhbgorb25lIHByb21pc29yIHJlbW90ZSBoYXMgYmVlbiBpbXBsZW1lbnRlZC4KKwogVXNlIG9mIHBhcnRpYWwgY2xvbmUgcmVxdWlyZXMgdGhhdCB0aGUgdXNlciBiZSBvbmxpbmUgYW5kIHRoZSBvcmlnaW4KLXJlbW90ZSBiZSBhdmFpbGFibGUgZm9yIG9uLWRlbWFuZCBmZXRjaGluZyBvZiBtaXNzaW5nIG9iamVjdHMuICBUaGlzIG1heQotb3IgbWF5IG5vdCBiZSBwcm9ibGVtYXRpYyBmb3IgdGhlIHVzZXIuICBGb3IgZXhhbXBsZSwgaWYgdGhlIHVzZXIgY2FuCi1zdGF5IHdpdGhpbiB0aGUgcHJlLXNlbGVjdGVkIHN1YnNldCBvZiB0aGUgc291cmNlIHRyZWUsIHRoZXkgbWF5IG5vdAotZW5jb3VudGVyIGFueSBtaXNzaW5nIG9iamVjdHMuICBBbHRlcm5hdGl2ZWx5LCB0aGUgdXNlciBjb3VsZCB0cnkgdG8KLXByZS1mZXRjaCB2YXJpb3VzIG9iamVjdHMgaWYgdGhleSBrbm93IHRoYXQgdGhleSBhcmUgZ29pbmcgb2ZmbGluZS4KK3JlbW90ZSBvciBvdGhlciBwcm9taXNvciByZW1vdGVzIGJlIGF2YWlsYWJsZSBmb3Igb24tZGVtYW5kIGZldGNoaW5nCitvZiBtaXNzaW5nIG9iamVjdHMuICBUaGlzIG1heSBvciBtYXkgbm90IGJlIHByb2JsZW1hdGljIGZvciB0aGUgdXNlci4KK0ZvciBleGFtcGxlLCBpZiB0aGUgdXNlciBjYW4gc3RheSB3aXRoaW4gdGhlIHByZS1zZWxlY3RlZCBzdWJzZXQgb2YKK3RoZSBzb3VyY2UgdHJlZSwgdGhleSBtYXkgbm90IGVuY291bnRlciBhbnkgbWlzc2luZyBvYmplY3RzLgorQWx0ZXJuYXRpdmVseSwgdGhlIHVzZXIgY291bGQgdHJ5IHRvIHByZS1mZXRjaCB2YXJpb3VzIG9iamVjdHMgaWYgdGhleQora25vdyB0aGF0IHRoZXkgYXJlIGdvaW5nIG9mZmxpbmUuCiAKIAogTm9uLUdvYWxzCkBAIC0xMDAsMTggKzEwOCwxOCBAQAogSGFuZGxpbmcgTWlzc2luZyBPYmplY3RzCiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KIAotLSBBbiBvYmplY3QgbWF5IGJlIG1pc3NpbmcgZHVlIHRvIGEgcGFydGlhbCBjbG9uZSBvciBmZXRjaCwgb3IgbWlzc2luZyBkdWUKLSAgdG8gcmVwb3NpdG9yeSBjb3JydXB0aW9uLiAgVG8gZGlmZmVyZW50aWF0ZSB0aGVzZSBjYXNlcywgdGhlIGxvY2FsCi0gIHJlcG9zaXRvcnkgc3BlY2lhbGx5IGluZGljYXRlcyBzdWNoIGZpbHRlcmVkIHBhY2tmaWxlcyBvYnRhaW5lZCBmcm9tIHRoZQotICBwcm9taXNvciByZW1vdGUgYXMgInByb21pc29yIHBhY2tmaWxlcyIuCistIEFuIG9iamVjdCBtYXkgYmUgbWlzc2luZyBkdWUgdG8gYSBwYXJ0aWFsIGNsb25lIG9yIGZldGNoLCBvciBtaXNzaW5nCisgIGR1ZSB0byByZXBvc2l0b3J5IGNvcnJ1cHRpb24uICBUbyBkaWZmZXJlbnRpYXRlIHRoZXNlIGNhc2VzLCB0aGUKKyAgbG9jYWwgcmVwb3NpdG9yeSBzcGVjaWFsbHkgaW5kaWNhdGVzIHN1Y2ggZmlsdGVyZWQgcGFja2ZpbGVzCisgIG9idGFpbmVkIGZyb20gcHJvbWlzb3IgcmVtb3RlcyBhcyAicHJvbWlzb3IgcGFja2ZpbGVzIi4KICsKIFRoZXNlIHByb21pc29yIHBhY2tmaWxlcyBjb25zaXN0IG9mIGEgIjxuYW1lPi5wcm9taXNvciIgZmlsZSB3aXRoCiBhcmJpdHJhcnkgY29udGVudHMgKGxpa2UgdGhlICI8bmFtZT4ua2VlcCIgZmlsZXMpLCBpbiBhZGRpdGlvbiB0bwogdGhlaXIgIjxuYW1lPi5wYWNrIiBhbmQgIjxuYW1lPi5pZHgiIGZpbGVzLgogCiAtIFRoZSBsb2NhbCByZXBvc2l0b3J5IGNvbnNpZGVycyBhICJwcm9taXNvciBvYmplY3QiIHRvIGJlIGFuIG9iamVjdCB0aGF0Ci0gIGl0IGtub3dzICh0byB0aGUgYmVzdCBvZiBpdHMgYWJpbGl0eSkgdGhhdCB0aGUgcHJvbWlzb3IgcmVtb3RlIGhhcyBwcm9taXNlZAotICB0aGF0IGl0IGhhcywgZWl0aGVyIGJlY2F1c2UgdGhlIGxvY2FsIHJlcG9zaXRvcnkgaGFzIHRoYXQgb2JqZWN0IGluIG9uZSBvZgorICBpdCBrbm93cyAodG8gdGhlIGJlc3Qgb2YgaXRzIGFiaWxpdHkpIHRoYXQgcHJvbWlzb3IgcmVtb3RlcyBoYXZlIHByb21pc2VkCisgIHRoYXQgdGhleSBoYXZlLCBlaXRoZXIgYmVjYXVzZSB0aGUgbG9jYWwgcmVwb3NpdG9yeSBoYXMgdGhhdCBvYmplY3QgaW4gb25lIG9mCiAgIGl0cyBwcm9taXNvciBwYWNrZmlsZXMsIG9yIGJlY2F1c2UgYW5vdGhlciBwcm9taXNvciBvYmplY3QgcmVmZXJzIHRvIGl0LgogKwogV2hlbiBHaXQgZW5jb3VudGVycyBhIG1pc3Npbmcgb2JqZWN0LCBHaXQgY2FuIHNlZSBpZiBpdCBpcyBhIHByb21pc29yIG9iamVjdApAQCAtMTIzLDEyICsxMzEsMTIgQEAKIC0gU2luY2UgYWxtb3N0IGFsbCBHaXQgY29kZSBjdXJyZW50bHkgZXhwZWN0cyBhbnkgcmVmZXJlbmNlZCBvYmplY3QgdG8gYmUKICAgcHJlc2VudCBsb2NhbGx5IGFuZCBiZWNhdXNlIHdlIGRvIG5vdCB3YW50IHRvIGZvcmNlIGV2ZXJ5IGNvbW1hbmQgdG8gZG8KICAgYSBkcnktcnVuIGZpcnN0LCBhIGZhbGxiYWNrIG1lY2hhbmlzbSBpcyBhZGRlZCB0byBhbGxvdyBHaXQgdG8gYXR0ZW1wdAotICB0byBkeW5hbWljYWxseSBmZXRjaCBtaXNzaW5nIG9iamVjdHMgZnJvbSB0aGUgcHJvbWlzb3IgcmVtb3RlLgorICB0byBkeW5hbWljYWxseSBmZXRjaCBtaXNzaW5nIG9iamVjdHMgZnJvbSBwcm9taXNvciByZW1vdGVzLgogKwogV2hlbiB0aGUgbm9ybWFsIG9iamVjdCBsb29rdXAgZmFpbHMgdG8gZmluZCBhbiBvYmplY3QsIEdpdCBpbnZva2VzCi1mZXRjaC1vYmplY3QgdG8gdHJ5IHRvIGdldCB0aGUgb2JqZWN0IGZyb20gdGhlIHNlcnZlciBhbmQgdGhlbiByZXRyeQotdGhlIG9iamVjdCBsb29rdXAuICBUaGlzIGFsbG93cyBvYmplY3RzIHRvIGJlICJmYXVsdGVkIGluIiB3aXRob3V0Ci1jb21wbGljYXRlZCBwcmVkaWN0aW9uIGFsZ29yaXRobXMuCitwcm9taXNvcl9yZW1vdGVfZ2V0X2RpcmVjdCgpIHRvIHRyeSB0byBnZXQgdGhlIG9iamVjdCBmcm9tIGEgcHJvbWlzb3IKK3JlbW90ZSBhbmQgdGhlbiByZXRyeSB0aGUgb2JqZWN0IGxvb2t1cC4gIFRoaXMgYWxsb3dzIG9iamVjdHMgdG8gYmUKKyJmYXVsdGVkIGluIiB3aXRob3V0IGNvbXBsaWNhdGVkIHByZWRpY3Rpb24gYWxnb3JpdGhtcy4KICsKIEZvciBlZmZpY2llbmN5IHJlYXNvbnMsIG5vIGNoZWNrIGFzIHRvIHdoZXRoZXIgdGhlIG1pc3Npbmcgb2JqZWN0IGlzCiBhY3R1YWxseSBhIHByb21pc29yIG9iamVjdCBpcyBwZXJmb3JtZWQuCkBAIC0xNTcsOCArMTY1LDcgQEAKICsKIFdlIGFyZSBub3QgaGFwcHkgd2l0aCB0aGlzIGdsb2JhbCB2YXJpYWJsZSBhbmQgd291bGQgbGlrZSB0byByZW1vdmUgaXQsCiBidXQgdGhhdCByZXF1aXJlcyBzaWduaWZpY2FudCByZWZhY3RvcmluZyBvZiB0aGUgb2JqZWN0IGNvZGUgdG8gcGFzcyBhbgotYWRkaXRpb25hbCBmbGFnLiAgV2UgaG9wZSB0aGF0IGNvbmN1cnJlbnQgZWZmb3J0cyB0byBhZGQgYW4gT0RCIEFQSSBjYW4KLWVuY29tcGFzcyB0aGlzLgorYWRkaXRpb25hbCBmbGFnLgogCiAKIEZldGNoaW5nIE1pc3NpbmcgT2JqZWN0cwpAQCAtMTgyLDIxICsxODksNjMgQEAKICAgdGhvdWdoIHRoZXkgYXJlIG5vdCBuZWNlc3NhcnkuCiAKIAorVXNpbmcgbWFueSBwcm9taXNvciByZW1vdGVzCistLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKworTWFueSBwcm9taXNvciByZW1vdGVzIGNhbiBiZSBjb25maWd1cmVkIGFuZCB1c2VkLgorCitUaGlzIGFsbG93cyBmb3IgZXhhbXBsZSBhIHVzZXIgdG8gaGF2ZSBtdWx0aXBsZSBnZW9ncmFwaGljYWxseS1jbG9zZQorY2FjaGUgc2VydmVycyBmb3IgZmV0Y2hpbmcgbWlzc2luZyBibG9icyB3aGlsZSBjb250aW51aW5nIHRvIGRvCitmaWx0ZXJlZCBgZ2l0LWZldGNoYCBjb21tYW5kcyBmcm9tIHRoZSBjZW50cmFsIHNlcnZlci4KKworV2hlbiBmZXRjaGluZyBvYmplY3RzLCBwcm9taXNvciByZW1vdGVzIGFyZSB0cmllZCBvbmUgYWZ0ZXIgdGhlIG90aGVyCit1bnRpbCBhbGwgdGhlIG9iamVjdHMgaGF2ZSBiZWVuIGZldGNoZWQuCisKK1JlbW90ZXMgdGhhdCBhcmUgY29uc2lkZXJlZCAicHJvbWlzb3IiIHJlbW90ZXMgYXJlIHRob3NlIHNwZWNpZmllZCBieQordGhlIGZvbGxvd2luZyBjb25maWd1cmF0aW9uIHZhcmlhYmxlczoKKworLSBgZXh0ZW5zaW9ucy5wYXJ0aWFsQ2xvbmUgPSA8bmFtZT5gCisKKy0gYHJlbW90ZS48bmFtZT4ucHJvbWlzb3IgPSB0cnVlYAorCistIGByZW1vdGUuPG5hbWU+LnBhcnRpYWxDbG9uZUZpbHRlciA9IC4uLmAKKworT25seSBvbmUgcHJvbWlzb3IgcmVtb3RlIGNhbiBiZSBjb25maWd1cmVkIHVzaW5nIHRoZQorYGV4dGVuc2lvbnMucGFydGlhbENsb25lYCBjb25maWcgdmFyaWFibGUuIFRoaXMgcHJvbWlzb3IgcmVtb3RlIHdpbGwKK2JlIHRoZSBsYXN0IG9uZSB0cmllZCB3aGVuIGZldGNoaW5nIG9iamVjdHMuCisKK1dlIGRlY2lkZWQgdG8gbWFrZSBpdCB0aGUgbGFzdCBvbmUgd2UgdHJ5LCBiZWNhdXNlIGl0IGlzIGxpa2VseSB0aGF0Citzb21lb25lIHVzaW5nIG1hbnkgcHJvbWlzb3IgcmVtb3RlcyBpcyBkb2luZyBzbyBiZWNhdXNlIHRoZSBvdGhlcgorcHJvbWlzb3IgcmVtb3RlcyBhcmUgYmV0dGVyIGZvciBzb21lIHJlYXNvbiAobWF5YmUgdGhleSBhcmUgY2xvc2VyIG9yCitmYXN0ZXIgZm9yIHNvbWUga2luZCBvZiBvYmplY3RzKSB0aGFuIHRoZSBvcmlnaW4sIGFuZCB0aGUgb3JpZ2luIGlzCitsaWtlbHkgdG8gYmUgdGhlIHJlbW90ZSBzcGVjaWZpZWQgYnkgZXh0ZW5zaW9ucy5wYXJ0aWFsQ2xvbmUuCisKK1RoaXMganVzdGlmaWNhdGlvbiBpcyBub3QgdmVyeSBzdHJvbmcsIGJ1dCBvbmUgY2hvaWNlIGhhZCB0byBiZSBtYWRlLAorYW5kIGFueXdheSB0aGUgbG9uZyB0ZXJtIHBsYW4gc2hvdWxkIGJlIHRvIG1ha2UgdGhlIG9yZGVyIHNvbWVob3cKK2Z1bGx5IGNvbmZpZ3VyYWJsZS4KKworRm9yIG5vdyB0aG91Z2ggdGhlIG90aGVyIHByb21pc29yIHJlbW90ZXMgd2lsbCBiZSB0cmllZCBpbiB0aGUgb3JkZXIKK3RoZXkgYXBwZWFyIGluIHRoZSBjb25maWcgZmlsZS4KKwogQ3VycmVudCBMaW1pdGF0aW9ucwogLS0tLS0tLS0tLS0tLS0tLS0tLQogCi0tIFRoZSByZW1vdGUgdXNlZCBmb3IgYSBwYXJ0aWFsIGNsb25lIChvciB0aGUgZmlyc3QgcGFydGlhbCBmZXRjaAotICBmb2xsb3dpbmcgYSByZWd1bGFyIGNsb25lKSBpcyBtYXJrZWQgYXMgdGhlICJwcm9taXNvciByZW1vdGUiLgorLSBJdCBpcyBub3QgcG9zc2libGUgdG8gc3BlY2lmeSB0aGUgb3JkZXIgaW4gd2hpY2ggdGhlIHByb21pc29yCisgIHJlbW90ZXMgYXJlIHRyaWVkIGluIG90aGVyIHdheXMgdGhhbiB0aGUgb3JkZXIgaW4gd2hpY2ggdGhleSBhcHBlYXIKKyAgaW4gdGhlIGNvbmZpZyBmaWxlLgogKwotV2UgYXJlIGN1cnJlbnRseSBsaW1pdGVkIHRvIGEgc2luZ2xlIHByb21pc29yIHJlbW90ZSBhbmQgb25seSB0aGF0Ci1yZW1vdGUgbWF5IGJlIHVzZWQgZm9yIHN1YnNlcXVlbnQgcGFydGlhbCBmZXRjaGVzLgotKwotV2UgYWNjZXB0IHRoaXMgbGltaXRhdGlvbiBiZWNhdXNlIHdlIGJlbGlldmUgaW5pdGlhbCB1c2VycyBvZiB0aGlzCi1mZWF0dXJlIHdpbGwgYmUgdXNpbmcgaXQgb24gcmVwb3NpdG9yaWVzIHdpdGggYSBzdHJvbmcgc2luZ2xlIGNlbnRyYWwKLXNlcnZlci4KK0l0IGlzIGFsc28gbm90IHBvc3NpYmxlIHRvIHNwZWNpZnkgYW4gb3JkZXIgdG8gYmUgdXNlZCB3aGVuIGZldGNoaW5nCitmcm9tIG9uZSByZW1vdGUgYW5kIGEgZGlmZmVyZW50IG9yZGVyIHdoZW4gZmV0Y2hpbmcgZnJvbSBhbm90aGVyCityZW1vdGUuCiAKLS0gRHluYW1pYyBvYmplY3QgZmV0Y2hpbmcgd2lsbCBvbmx5IGFzayB0aGUgcHJvbWlzb3IgcmVtb3RlIGZvciBtaXNzaW5nCi0gIG9iamVjdHMuICBXZSBhc3N1bWUgdGhhdCB0aGUgcHJvbWlzb3IgcmVtb3RlIGhhcyBhIGNvbXBsZXRlIHZpZXcgb2YgdGhlCistIEl0IGlzIG5vdCBwb3NzaWJsZSB0byBwdXNoIG9ubHkgc3BlY2lmaWMgb2JqZWN0cyB0byBhIHByb21pc29yCisgIHJlbW90ZS4KKysKK0l0IGlzIG5vdCBwb3NzaWJsZSB0byBwdXNoIGF0IHRoZSBzYW1lIHRpbWUgdG8gbXVsdGlwbGUgcHJvbWlzb3IKK3JlbW90ZSBpbiBhIHNwZWNpZmljIG9yZGVyLgorCistIER5bmFtaWMgb2JqZWN0IGZldGNoaW5nIHdpbGwgb25seSBhc2sgcHJvbWlzb3IgcmVtb3RlcyBmb3IgbWlzc2luZworICBvYmplY3RzLiAgV2UgYXNzdW1lIHRoYXQgcHJvbWlzb3IgcmVtb3RlcyBoYXZlIGEgY29tcGxldGUgdmlldyBvZiB0aGUKICAgcmVwb3NpdG9yeSBhbmQgY2FuIHNhdGlzZnkgYWxsIHN1Y2ggcmVxdWVzdHMuCiAKIC0gUmVwYWNrIGVzc2VudGlhbGx5IHRyZWF0cyBwcm9taXNvciBhbmQgbm9uLXByb21pc29yIHBhY2tmaWxlcyBhcyAyCkBAIC0yMTgsMTUgKzI2NywxNyBAQAogRnV0dXJlIFdvcmsKIC0tLS0tLS0tLS0tCiAKLS0gQWxsb3cgbW9yZSB0aGFuIG9uZSBwcm9taXNvciByZW1vdGUgYW5kIGRlZmluZSBhIHN0cmF0ZWd5IGZvciBmZXRjaGluZwotICBtaXNzaW5nIG9iamVjdHMgZnJvbSBzcGVjaWZpYyBwcm9taXNvciByZW1vdGVzIG9yIG9mIGl0ZXJhdGluZyBvdmVyIHRoZQotICBzZXQgb2YgcHJvbWlzb3IgcmVtb3RlcyB1bnRpbCBhIG1pc3Npbmcgb2JqZWN0IGlzIGZvdW5kLgorLSBJbXByb3ZlIHRoZSB3YXkgdG8gc3BlY2lmeSB0aGUgb3JkZXIgaW4gd2hpY2ggcHJvbWlzb3IgcmVtb3RlcyBhcmUKKyAgdHJpZWQuCiArCi1BIHVzZXIgbWlnaHQgd2FudCB0byBoYXZlIG11bHRpcGxlIGdlb2dyYXBoaWNhbGx5LWNsb3NlIGNhY2hlIHNlcnZlcnMKLWZvciBmZXRjaGluZyBtaXNzaW5nIGJsb2JzIHdoaWxlIGNvbnRpbnVpbmcgdG8gZG8gZmlsdGVyZWQgYGdpdC1mZXRjaGAKLWNvbW1hbmRzIGZyb20gdGhlIGNlbnRyYWwgc2VydmVyLCBmb3IgZXhhbXBsZS4KK0ZvciBleGFtcGxlIHRoaXMgY291bGQgYWxsb3cgdG8gc3BlY2lmeSBleHBsaWNpdGx5IHNvbWV0aGluZyBsaWtlOgorIldoZW4gZmV0Y2hpbmcgZnJvbSB0aGlzIHJlbW90ZSwgSSB3YW50IHRvIHVzZSB0aGVzZSBwcm9taXNvciByZW1vdGVzCitpbiB0aGlzIG9yZGVyLCB0aG91Z2gsIHdoZW4gcHVzaGluZyBvciBmZXRjaGluZyB0byB0aGF0IHJlbW90ZSwgSSB3YW50Cit0byB1c2UgdGhvc2UgcHJvbWlzb3IgcmVtb3RlcyBpbiB0aGF0IG9yZGVyLiIKKworLSBBbGxvdyBwdXNoaW5nIHRvIHByb21pc29yIHJlbW90ZXMuCiArCi1PciB0aGUgdXNlciBtaWdodCB3YW50IHRvIHdvcmsgaW4gYSB0cmlhbmd1bGFyIHdvcmsgZmxvdyB3aXRoIG11bHRpcGxlCitUaGUgdXNlciBtaWdodCB3YW50IHRvIHdvcmsgaW4gYSB0cmlhbmd1bGFyIHdvcmsgZmxvdyB3aXRoIG11bHRpcGxlCiBwcm9taXNvciByZW1vdGVzIHRoYXQgZWFjaCBoYXZlIGFuIGluY29tcGxldGUgdmlldyBvZiB0aGUgcmVwb3NpdG9yeS4KIAogLSBBbGxvdyByZXBhY2sgdG8gd29yayBvbiBwcm9taXNvciBwYWNrZmlsZXMgKHdoaWxlIGtlZXBpbmcgdGhlbSBkaXN0aW5jdApkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi90ZWNobmljYWwvcHJvdG9jb2wtdjIudHh0IGIvRG9jdW1lbnRhdGlvbi90ZWNobmljYWwvcHJvdG9jb2wtdjIudHh0CmluZGV4IDQwZjkxZjYuLjdlMzc2NmMgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vdGVjaG5pY2FsL3Byb3RvY29sLXYyLnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL3RlY2huaWNhbC9wcm90b2NvbC12Mi50eHQKQEAgLTI1Miw3ICsyNTIsNyBAQAogICAgIG9mcy1kZWx0YQogCUluZGljYXRlIHRoYXQgdGhlIGNsaWVudCB1bmRlcnN0YW5kcyBQQUNLdjIgd2l0aCBkZWx0YSByZWZlcnJpbmcKIAl0byBpdHMgYmFzZSBieSBwb3NpdGlvbiBpbiBwYWNrIHJhdGhlciB0aGFuIGJ5IGFuIG9pZC4gIFRoYXQgaXMsCi0JdGhleSBjYW4gcmVhZCBPQkpfT0ZTX0RFTFRBIChha2UgdHlwZSA2KSBpbiBhIHBhY2tmaWxlLgorCXRoZXkgY2FuIHJlYWQgT0JKX09GU19ERUxUQSAoYWthIHR5cGUgNikgaW4gYSBwYWNrZmlsZS4KIAogSWYgdGhlICdzaGFsbG93JyBmZWF0dXJlIGlzIGFkdmVydGlzZWQgdGhlIGZvbGxvd2luZyBhcmd1bWVudHMgY2FuIGJlCiBpbmNsdWRlZCBpbiB0aGUgY2xpZW50cyByZXF1ZXN0IGFzIHdlbGwgYXMgdGhlIHBvdGVudGlhbCBhZGRpdGlvbiBvZiB0aGUKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vdGVjaG5pY2FsL3JlcmVyZS50eHQgYi9Eb2N1bWVudGF0aW9uL3RlY2huaWNhbC9yZXJlcmUudHh0CmluZGV4IGFhMjJkN2EuLmFmNWY5ZmMgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vdGVjaG5pY2FsL3JlcmVyZS50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi90ZWNobmljYWwvcmVyZXJlLnR4dApAQCAtMTE3LDcgKzExNyw3IEBACiA0IGNvbWJpbmF0aW9ucyBvZiAoIkIgb3IgQyIsICJDIG9yIEIiKSB4ICgiWCBvciBZIiwgIlkgb3IgWCIpLgogCiBCeSBzb3J0aW5nLCB0aGUgY29uZmxpY3QgaXMgZ2l2ZW4gaXRzIGNhbm9uaWNhbCBuYW1lLCBuYW1lbHksICJhbgotZWFybHkgcGFydCBiZWNhbWUgQiBvciBDLCBhIGxhdGUgcGFydCBiZWNhbWVzIFggb3IgWSIsIGFuZCB3aGVuZXZlcgorZWFybHkgcGFydCBiZWNhbWUgQiBvciBDLCBhIGxhdGUgcGFydCBiZWNhbWUgWCBvciBZIiwgYW5kIHdoZW5ldmVyCiBhbnkgb2YgdGhlc2UgZm91ciBwYXR0ZXJucyBhcHBlYXIsIGFuZCB3ZSBjYW4gZ2V0IHRvIHRoZSBzYW1lIGNvbmZsaWN0CiBhbmQgcmVzb2x1dGlvbiB0aGF0IHdlIHNhdyBlYXJsaWVyLgogCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL3RyYWNlMi10YXJnZXQtdmFsdWVzLnR4dCBiL0RvY3VtZW50YXRpb24vdHJhY2UyLXRhcmdldC12YWx1ZXMudHh0CmluZGV4IDI3ZDNjNjQuLjM5ODViNmQgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vdHJhY2UyLXRhcmdldC12YWx1ZXMudHh0CisrKyBiL0RvY3VtZW50YXRpb24vdHJhY2UyLXRhcmdldC12YWx1ZXMudHh0CkBAIC0yLDcgKzIsOSBAQAogKiBgMGAgb3IgYGZhbHNlYCAtIERpc2FibGVzIHRoZSB0YXJnZXQuCiAqIGAxYCBvciBgdHJ1ZWAgLSBXcml0ZXMgdG8gYFNUREVSUmAuCiAqIGBbMi05XWAgLSBXcml0ZXMgdG8gdGhlIGFscmVhZHkgb3BlbmVkIGZpbGUgZGVzY3JpcHRvci4KLSogYDxhYnNvbHV0ZS1wYXRobmFtZT5gIC0gV3JpdGVzIHRvIHRoZSBmaWxlIGluIGFwcGVuZCBtb2RlLgorKiBgPGFic29sdXRlLXBhdGhuYW1lPmAgLSBXcml0ZXMgdG8gdGhlIGZpbGUgaW4gYXBwZW5kIG1vZGUuIElmIHRoZSB0YXJnZXQKK2FscmVhZHkgZXhpc3RzIGFuZCBpcyBhIGRpcmVjdG9yeSwgdGhlIHRyYWNlcyB3aWxsIGJlIHdyaXR0ZW4gdG8gZmlsZXMgKG9uZQorcGVyIHByb2Nlc3MpIHVuZGVybmVhdGggdGhlIGdpdmVuIGRpcmVjdG9yeS4KICogYGFmX3VuaXg6Wzxzb2NrZXRfdHlwZT46XTxhYnNvbHV0ZS1wYXRobmFtZT5gIC0gV3JpdGUgdG8gYQogVW5peCBEb21haW5Tb2NrZXQgKG9uIHBsYXRmb3JtcyB0aGF0IHN1cHBvcnQgdGhlbSkuICBTb2NrZXQKIHR5cGUgY2FuIGJlIGVpdGhlciBgc3RyZWFtYCBvciBgZGdyYW1gOyBpZiBvbWl0dGVkIEdpdCB3aWxsCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL3VzZXItbWFudWFsLnR4dCBiL0RvY3VtZW50YXRpb24vdXNlci1tYW51YWwudHh0CmluZGV4IDhiY2U3NWIuLjA2YmQ4OTkgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vdXNlci1tYW51YWwudHh0CisrKyBiL0RvY3VtZW50YXRpb24vdXNlci1tYW51YWwudHh0CkBAIC0xLDUgKzEsNCBAQAotR2l0IFVzZXIgTWFudWFsCi09PT09PT09PT09PT09PT0KKz0gR2l0IFVzZXIgTWFudWFsCiAKIEdpdCBpcyBhIGZhc3QgZGlzdHJpYnV0ZWQgcmV2aXNpb24gY29udHJvbCBzeXN0ZW0uCiAKQEAgLTQxLDEyICs0MCwxMCBAQAogCiAKIFtbcmVwb3NpdG9yaWVzLWFuZC1icmFuY2hlc11dCi1SZXBvc2l0b3JpZXMgYW5kIEJyYW5jaGVzCi09PT09PT09PT09PT09PT09PT09PT09PT09Cis9PSBSZXBvc2l0b3JpZXMgYW5kIEJyYW5jaGVzCiAKIFtbaG93LXRvLWdldC1hLWdpdC1yZXBvc2l0b3J5XV0KLUhvdyB0byBnZXQgYSBHaXQgcmVwb3NpdG9yeQotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCis9PT0gSG93IHRvIGdldCBhIEdpdCByZXBvc2l0b3J5CiAKIEl0IHdpbGwgYmUgdXNlZnVsIHRvIGhhdmUgYSBHaXQgcmVwb3NpdG9yeSB0byBleHBlcmltZW50IHdpdGggYXMgeW91CiByZWFkIHRoaXMgbWFudWFsLgpAQCAtNzMsOCArNzAsNyBAQAogYWJvdXQgdGhlIGhpc3Rvcnkgb2YgdGhlIHByb2plY3QuCiAKIFtbaG93LXRvLWNoZWNrLW91dF1dCi1Ib3cgdG8gY2hlY2sgb3V0IGEgZGlmZmVyZW50IHZlcnNpb24gb2YgYSBwcm9qZWN0Ci0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCis9PT0gSG93IHRvIGNoZWNrIG91dCBhIGRpZmZlcmVudCB2ZXJzaW9uIG9mIGEgcHJvamVjdAogCiBHaXQgaXMgYmVzdCB0aG91Z2h0IG9mIGFzIGEgdG9vbCBmb3Igc3RvcmluZyB0aGUgaGlzdG9yeSBvZiBhIGNvbGxlY3Rpb24KIG9mIGZpbGVzLiAgSXQgc3RvcmVzIHRoZSBoaXN0b3J5IGFzIGEgY29tcHJlc3NlZCBjb2xsZWN0aW9uIG9mCkBAIC0xNTEsOCArMTQ3LDcgQEAKIGNhcmVmdWxseS4KIAogW1t1bmRlcnN0YW5kaW5nLWNvbW1pdHNdXQotVW5kZXJzdGFuZGluZyBIaXN0b3J5OiBDb21taXRzCi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKz09PSBVbmRlcnN0YW5kaW5nIEhpc3Rvcnk6IENvbW1pdHMKIAogRXZlcnkgY2hhbmdlIGluIHRoZSBoaXN0b3J5IG9mIGEgcHJvamVjdCBpcyByZXByZXNlbnRlZCBieSBhIGNvbW1pdC4KIFRoZSBsaW5rZ2l0OmdpdC1zaG93WzFdIGNvbW1hbmQgc2hvd3MgdGhlIG1vc3QgcmVjZW50IGNvbW1pdCBvbiB0aGUKQEAgLTIwMiw4ICsxOTcsNyBAQAogd2l0aCBhIG5hbWUgdGhhdCBpcyBhIGhhc2ggb2YgaXRzIGNvbnRlbnRzLgogCiBbW3VuZGVyc3RhbmRpbmctcmVhY2hhYmlsaXR5XV0KLVVuZGVyc3RhbmRpbmcgaGlzdG9yeTogY29tbWl0cywgcGFyZW50cywgYW5kIHJlYWNoYWJpbGl0eQotfn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+Cis9PT09IFVuZGVyc3RhbmRpbmcgaGlzdG9yeTogY29tbWl0cywgcGFyZW50cywgYW5kIHJlYWNoYWJpbGl0eQogCiBFdmVyeSBjb21taXQgKGV4Y2VwdCB0aGUgdmVyeSBmaXJzdCBjb21taXQgaW4gYSBwcm9qZWN0KSBhbHNvIGhhcyBhCiBwYXJlbnQgY29tbWl0IHdoaWNoIHNob3dzIHdoYXQgaGFwcGVuZWQgYmVmb3JlIHRoaXMgY29tbWl0LgpAQCAtMjI3LDggKzIyMSw3IEBACiBsZWFkaW5nIGZyb20gY29tbWl0IFkgdG8gY29tbWl0IFguCiAKIFtbaGlzdG9yeS1kaWFncmFtc11dCi1VbmRlcnN0YW5kaW5nIGhpc3Rvcnk6IEhpc3RvcnkgZGlhZ3JhbXMKLX5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fgorPT09PSBVbmRlcnN0YW5kaW5nIGhpc3Rvcnk6IEhpc3RvcnkgZGlhZ3JhbXMKIAogV2Ugd2lsbCBzb21ldGltZXMgcmVwcmVzZW50IEdpdCBoaXN0b3J5IHVzaW5nIGRpYWdyYW1zIGxpa2UgdGhlIG9uZQogYmVsb3cuICBDb21taXRzIGFyZSBzaG93biBhcyAibyIsIGFuZCB0aGUgbGlua3MgYmV0d2VlbiB0aGVtIHdpdGgKQEAgLTI0Nyw4ICsyNDAsNyBAQAogYmUgcmVwbGFjZWQgd2l0aCBhbm90aGVyIGxldHRlciBvciBudW1iZXIuCiAKIFtbd2hhdC1pcy1hLWJyYW5jaF1dCi1VbmRlcnN0YW5kaW5nIGhpc3Rvcnk6IFdoYXQgaXMgYSBicmFuY2g/Ci1+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+Cis9PT09IFVuZGVyc3RhbmRpbmcgaGlzdG9yeTogV2hhdCBpcyBhIGJyYW5jaD8KIAogV2hlbiB3ZSBuZWVkIHRvIGJlIHByZWNpc2UsIHdlIHdpbGwgdXNlIHRoZSB3b3JkICJicmFuY2giIHRvIG1lYW4gYSBsaW5lCiBvZiBkZXZlbG9wbWVudCwgYW5kICJicmFuY2ggaGVhZCIgKG9yIGp1c3QgImhlYWQiKSB0byBtZWFuIGEgcmVmZXJlbmNlCkBAIC0yNjEsOCArMjUzLDcgQEAKICJicmFuY2giIGJvdGggZm9yIGJyYW5jaGVzIGFuZCBmb3IgYnJhbmNoIGhlYWRzLgogCiBbW21hbmlwdWxhdGluZy1icmFuY2hlc11dCi1NYW5pcHVsYXRpbmcgYnJhbmNoZXMKLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorPT09IE1hbmlwdWxhdGluZyBicmFuY2hlcwogCiBDcmVhdGluZywgZGVsZXRpbmcsIGFuZCBtb2RpZnlpbmcgYnJhbmNoZXMgaXMgcXVpY2sgYW5kIGVhc3k7IGhlcmUncwogYSBzdW1tYXJ5IG9mIHRoZSBjb21tYW5kczoKQEAgLTI5OSw4ICsyOTAsNyBAQAogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAKIFtbZGV0YWNoZWQtaGVhZF1dCi1FeGFtaW5pbmcgYW4gb2xkIHZlcnNpb24gd2l0aG91dCBjcmVhdGluZyBhIG5ldyBicmFuY2gKLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorPT09IEV4YW1pbmluZyBhbiBvbGQgdmVyc2lvbiB3aXRob3V0IGNyZWF0aW5nIGEgbmV3IGJyYW5jaAogCiBUaGUgYGdpdCBzd2l0Y2hgIGNvbW1hbmQgbm9ybWFsbHkgZXhwZWN0cyBhIGJyYW5jaCBoZWFkLCBidXQgd2lsbCBhbHNvCiBhY2NlcHQgYW4gYXJiaXRyYXJ5IGNvbW1pdCB3aGVuIGludm9rZWQgd2l0aCAtLWRldGFjaDsgZm9yIGV4YW1wbGUsCkBAIC0zNDAsOCArMzMwLDcgQEAKIChvciB0YWcpIGZvciB0aGlzIHZlcnNpb24gbGF0ZXIgaWYgeW91IGRlY2lkZSB0by4KIAogW1tleGFtaW5pbmctcmVtb3RlLWJyYW5jaGVzXV0KLUV4YW1pbmluZyBicmFuY2hlcyBmcm9tIGEgcmVtb3RlIHJlcG9zaXRvcnkKLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKz09PSBFeGFtaW5pbmcgYnJhbmNoZXMgZnJvbSBhIHJlbW90ZSByZXBvc2l0b3J5CiAKIFRoZSAibWFzdGVyIiBicmFuY2ggdGhhdCB3YXMgY3JlYXRlZCBhdCB0aGUgdGltZSB5b3UgY2xvbmVkIGlzIGEgY29weQogb2YgdGhlIEhFQUQgaW4gdGhlIHJlcG9zaXRvcnkgdGhhdCB5b3UgY2xvbmVkIGZyb20uICBUaGF0IHJlcG9zaXRvcnkKQEAgLTM4Myw4ICszNzIsNyBAQAogdG8gcmVmZXIgdG8gdGhlIHJlcG9zaXRvcnkgdGhhdCB5b3UgY2xvbmVkIGZyb20uCiAKIFtbaG93LWdpdC1zdG9yZXMtcmVmZXJlbmNlc11dCi1OYW1pbmcgYnJhbmNoZXMsIHRhZ3MsIGFuZCBvdGhlciByZWZlcmVuY2VzCi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCis9PT0gTmFtaW5nIGJyYW5jaGVzLCB0YWdzLCBhbmQgb3RoZXIgcmVmZXJlbmNlcwogCiBCcmFuY2hlcywgcmVtb3RlLXRyYWNraW5nIGJyYW5jaGVzLCBhbmQgdGFncyBhcmUgYWxsIHJlZmVyZW5jZXMgdG8KIGNvbW1pdHMuICBBbGwgcmVmZXJlbmNlcyBhcmUgbmFtZWQgd2l0aCBhIHNsYXNoLXNlcGFyYXRlZCBwYXRoIG5hbWUKQEAgLTQxMyw4ICs0MDEsNyBAQAogUkVWSVNJT05TIiBzZWN0aW9uIG9mIGxpbmtnaXQ6Z2l0cmV2aXNpb25zWzddLgogCiBbW1VwZGF0aW5nLWEtcmVwb3NpdG9yeS1XaXRoLWdpdC1mZXRjaF1dCi1VcGRhdGluZyBhIHJlcG9zaXRvcnkgd2l0aCBnaXQgZmV0Y2gKLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorPT09IFVwZGF0aW5nIGEgcmVwb3NpdG9yeSB3aXRoIGdpdCBmZXRjaAogCiBBZnRlciB5b3UgY2xvbmUgYSByZXBvc2l0b3J5IGFuZCBjb21taXQgYSBmZXcgY2hhbmdlcyBvZiB5b3VyIG93biwgeW91CiBtYXkgd2lzaCB0byBjaGVjayB0aGUgb3JpZ2luYWwgcmVwb3NpdG9yeSBmb3IgdXBkYXRlcy4KQEAgLTQyNSw4ICs0MTIsNyBAQAogIm1hc3RlciIgYnJhbmNoIHRoYXQgd2FzIGNyZWF0ZWQgZm9yIHlvdSBvbiBjbG9uZS4KIAogW1tmZXRjaGluZy1icmFuY2hlc11dCi1GZXRjaGluZyBicmFuY2hlcyBmcm9tIG90aGVyIHJlcG9zaXRvcmllcwotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKz09PSBGZXRjaGluZyBicmFuY2hlcyBmcm9tIG90aGVyIHJlcG9zaXRvcmllcwogCiBZb3UgY2FuIGFsc28gdHJhY2sgYnJhbmNoZXMgZnJvbSByZXBvc2l0b3JpZXMgb3RoZXIgdGhhbiB0aGUgb25lIHlvdQogY2xvbmVkIGZyb20sIHVzaW5nIGxpbmtnaXQ6Z2l0LXJlbW90ZVsxXToKQEAgLTQ3NCw4ICs0NjAsNyBAQAogbGlua2dpdDpnaXQtY29uZmlnWzFdIGZvciBkZXRhaWxzLikKIAogW1tleHBsb3JpbmctZ2l0LWhpc3RvcnldXQotRXhwbG9yaW5nIEdpdCBoaXN0b3J5Ci09PT09PT09PT09PT09PT09PT09PT0KKz09IEV4cGxvcmluZyBHaXQgaGlzdG9yeQogCiBHaXQgaXMgYmVzdCB0aG91Z2h0IG9mIGFzIGEgdG9vbCBmb3Igc3RvcmluZyB0aGUgaGlzdG9yeSBvZiBhCiBjb2xsZWN0aW9uIG9mIGZpbGVzLiAgSXQgZG9lcyB0aGlzIGJ5IHN0b3JpbmcgY29tcHJlc3NlZCBzbmFwc2hvdHMgb2YKQEAgLTQ4OSw4ICs0NzQsNyBAQAogY29tbWl0IHRoYXQgaW50cm9kdWNlZCBhIGJ1ZyBpbnRvIGEgcHJvamVjdC4KIAogW1t1c2luZy1iaXNlY3RdXQotSG93IHRvIHVzZSBiaXNlY3QgdG8gZmluZCBhIHJlZ3Jlc3Npb24KLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCis9PT0gSG93IHRvIHVzZSBiaXNlY3QgdG8gZmluZCBhIHJlZ3Jlc3Npb24KIAogU3VwcG9zZSB2ZXJzaW9uIDIuNi4xOCBvZiB5b3VyIHByb2plY3Qgd29ya2VkLCBidXQgdGhlIHZlcnNpb24gYXQKICJtYXN0ZXIiIGNyYXNoZXMuICBTb21ldGltZXMgdGhlIGJlc3Qgd2F5IHRvIGZpbmQgdGhlIGNhdXNlIG9mIHN1Y2ggYQpAQCAtNTcyLDggKzU1Niw3IEBACiBiaXNlY3RgIGZlYXR1cmVzLgogCiBbW25hbWluZy1jb21taXRzXV0KLU5hbWluZyBjb21taXRzCi0tLS0tLS0tLS0tLS0tLQorPT09IE5hbWluZyBjb21taXRzCiAKIFdlIGhhdmUgc2VlbiBzZXZlcmFsIHdheXMgb2YgbmFtaW5nIGNvbW1pdHMgYWxyZWFkeToKIApAQCAtNjM3LDggKzYyMCw3IEBACiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAKIFtbY3JlYXRpbmctdGFnc11dCi1DcmVhdGluZyB0YWdzCi0tLS0tLS0tLS0tLS0tCis9PT0gQ3JlYXRpbmcgdGFncwogCiBXZSBjYW4gYWxzbyBjcmVhdGUgYSB0YWcgdG8gcmVmZXIgdG8gYSBwYXJ0aWN1bGFyIGNvbW1pdDsgYWZ0ZXIKIHJ1bm5pbmcKQEAgLTY1NSw4ICs2MzcsNyBAQAogZm9yIGRldGFpbHMuCiAKIFtbYnJvd3NpbmctcmV2aXNpb25zXV0KLUJyb3dzaW5nIHJldmlzaW9ucwotLS0tLS0tLS0tLS0tLS0tLS0tCis9PT0gQnJvd3NpbmcgcmV2aXNpb25zCiAKIFRoZSBsaW5rZ2l0OmdpdC1sb2dbMV0gY29tbWFuZCBjYW4gc2hvdyBsaXN0cyBvZiBjb21taXRzLiAgT24gaXRzCiBvd24sIGl0IHNob3dzIGFsbCBjb21taXRzIHJlYWNoYWJsZSBmcm9tIHRoZSBwYXJlbnQgY29tbWl0OyBidXQgeW91CkBAIC02OTcsOCArNjc4LDcgQEAKIGNvbW1pdHMgYXJlIGxpc3RlZCBpbiBtYXkgYmUgc29tZXdoYXQgYXJiaXRyYXJ5LgogCiBbW2dlbmVyYXRpbmctZGlmZnNdXQotR2VuZXJhdGluZyBkaWZmcwotLS0tLS0tLS0tLS0tLS0tLQorPT09IEdlbmVyYXRpbmcgZGlmZnMKIAogWW91IGNhbiBnZW5lcmF0ZSBkaWZmcyBiZXR3ZWVuIGFueSB0d28gdmVyc2lvbnMgdXNpbmcKIGxpbmtnaXQ6Z2l0LWRpZmZbMV06CkBAIC03MjYsOCArNzA2LDcgQEAKIGJ1dCBub3QgZnJvbSBtYXN0ZXIuCiAKIFtbdmlld2luZy1vbGQtZmlsZS12ZXJzaW9uc11dCi1WaWV3aW5nIG9sZCBmaWxlIHZlcnNpb25zCi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCis9PT0gVmlld2luZyBvbGQgZmlsZSB2ZXJzaW9ucwogCiBZb3UgY2FuIGFsd2F5cyB2aWV3IGFuIG9sZCB2ZXJzaW9uIG9mIGEgZmlsZSBieSBqdXN0IGNoZWNraW5nIG91dCB0aGUKIGNvcnJlY3QgcmV2aXNpb24gZmlyc3QuICBCdXQgc29tZXRpbWVzIGl0IGlzIG1vcmUgY29udmVuaWVudCB0byBiZQpAQCAtNzQyLDEyICs3MjEsMTAgQEAKIG1heSBiZSBhbnkgcGF0aCB0byBhIGZpbGUgdHJhY2tlZCBieSBHaXQuCiAKIFtbaGlzdG9yeS1leGFtcGxlc11dCi1FeGFtcGxlcwotLS0tLS0tLS0KKz09PSBFeGFtcGxlcwogCiBbW2NvdW50aW5nLWNvbW1pdHMtb24tYS1icmFuY2hdXQotQ291bnRpbmcgdGhlIG51bWJlciBvZiBjb21taXRzIG9uIGEgYnJhbmNoCi1+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn4KKz09PT0gQ291bnRpbmcgdGhlIG51bWJlciBvZiBjb21taXRzIG9uIGEgYnJhbmNoCiAKIFN1cHBvc2UgeW91IHdhbnQgdG8ga25vdyBob3cgbWFueSBjb21taXRzIHlvdSd2ZSBtYWRlIG9uIGBteWJyYW5jaGAKIHNpbmNlIGl0IGRpdmVyZ2VkIGZyb20gYG9yaWdpbmA6CkBAIC03NjUsOCArNzQyLDcgQEAKIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KIAogW1tjaGVja2luZy1mb3ItZXF1YWwtYnJhbmNoZXNdXQotQ2hlY2sgd2hldGhlciB0d28gYnJhbmNoZXMgcG9pbnQgYXQgdGhlIHNhbWUgaGlzdG9yeQotfn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fgorPT09PSBDaGVjayB3aGV0aGVyIHR3byBicmFuY2hlcyBwb2ludCBhdCB0aGUgc2FtZSBoaXN0b3J5CiAKIFN1cHBvc2UgeW91IHdhbnQgdG8gY2hlY2sgd2hldGhlciB0d28gYnJhbmNoZXMgcG9pbnQgYXQgdGhlIHNhbWUgcG9pbnQKIGluIGhpc3RvcnkuCkBAIC03OTgsOCArNzc0LDcgQEAKIHdpbGwgcmV0dXJuIG5vIGNvbW1pdHMgd2hlbiB0aGUgdHdvIGJyYW5jaGVzIGFyZSBlcXVhbC4KIAogW1tmaW5kaW5nLXRhZ2dlZC1kZXNjZW5kYW50c11dCi1GaW5kIGZpcnN0IHRhZ2dlZCB2ZXJzaW9uIGluY2x1ZGluZyBhIGdpdmVuIGZpeAotfn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn4KKz09PT0gRmluZCBmaXJzdCB0YWdnZWQgdmVyc2lvbiBpbmNsdWRpbmcgYSBnaXZlbiBmaXgKIAogU3VwcG9zZSB5b3Uga25vdyB0aGF0IHRoZSBjb21taXQgZTA1ZGIwZmQgZml4ZWQgYSBjZXJ0YWluIHByb2JsZW0uCiBZb3UnZCBsaWtlIHRvIGZpbmQgdGhlIGVhcmxpZXN0IHRhZ2dlZCByZWxlYXNlIHRoYXQgY29udGFpbnMgdGhhdApAQCAtODgzLDggKzg1OCw3IEBACiBhbmQgZnJvbSB2MS41LjAtcmMyLCBhbmQgbm90IGZyb20gdjEuNS4wLXJjMC4KIAogW1tzaG93aW5nLWNvbW1pdHMtdW5pcXVlLXRvLWEtYnJhbmNoXV0KLVNob3dpbmcgY29tbWl0cyB1bmlxdWUgdG8gYSBnaXZlbiBicmFuY2gKLX5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn4KKz09PT0gU2hvd2luZyBjb21taXRzIHVuaXF1ZSB0byBhIGdpdmVuIGJyYW5jaAogCiBTdXBwb3NlIHlvdSB3b3VsZCBsaWtlIHRvIHNlZSBhbGwgdGhlIGNvbW1pdHMgcmVhY2hhYmxlIGZyb20gdGhlIGJyYW5jaAogaGVhZCBuYW1lZCBgbWFzdGVyYCBidXQgbm90IGZyb20gYW55IG90aGVyIGhlYWQgaW4geW91ciByZXBvc2l0b3J5LgpAQCAtOTMxLDggKzkwNSw3IEBACiBzeW50YXggc3VjaCBhcyBgLS1ub3RgLikKIAogW1ttYWtpbmctYS1yZWxlYXNlXV0KLUNyZWF0aW5nIGEgY2hhbmdlbG9nIGFuZCB0YXJiYWxsIGZvciBhIHNvZnR3YXJlIHJlbGVhc2UKLX5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn4KKz09PT0gQ3JlYXRpbmcgYSBjaGFuZ2Vsb2cgYW5kIHRhcmJhbGwgZm9yIGEgc29mdHdhcmUgcmVsZWFzZQogCiBUaGUgbGlua2dpdDpnaXQtYXJjaGl2ZVsxXSBjb21tYW5kIGNhbiBjcmVhdGUgYSB0YXIgb3IgemlwIGFyY2hpdmUgZnJvbQogYW55IHZlcnNpb24gb2YgYSBwcm9qZWN0OyBmb3IgZXhhbXBsZToKQEAgLTk4Myw4ICs5NTYsNyBAQAogdGhleSBsb29rIE9LLgogCiBbW0ZpbmRpbmctY29tbWl0cy1XaXRoLWdpdmVuLUNvbnRlbnRdXQotRmluZGluZyBjb21taXRzIHJlZmVyZW5jaW5nIGEgZmlsZSB3aXRoIGdpdmVuIGNvbnRlbnQKLX5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+Cis9PT09IEZpbmRpbmcgY29tbWl0cyByZWZlcmVuY2luZyBhIGZpbGUgd2l0aCBnaXZlbiBjb250ZW50CiAKIFNvbWVib2R5IGhhbmRzIHlvdSBhIGNvcHkgb2YgYSBmaWxlLCBhbmQgYXNrcyB3aGljaCBjb21taXRzIG1vZGlmaWVkIGEKIGZpbGUgc3VjaCB0aGF0IGl0IGNvbnRhaW5lZCB0aGUgZ2l2ZW4gY29udGVudCBlaXRoZXIgYmVmb3JlIG9yIGFmdGVyIHRoZQpAQCAtMTAwMCwxMiArOTcyLDEwIEBACiBsaW5rZ2l0OmdpdC1oYXNoLW9iamVjdFsxXSBtYW4gcGFnZXMgbWF5IHByb3ZlIGhlbHBmdWwuCiAKIFtbRGV2ZWxvcGluZy1XaXRoLWdpdF1dCi1EZXZlbG9waW5nIHdpdGggR2l0Ci09PT09PT09PT09PT09PT09PT09Cis9PSBEZXZlbG9waW5nIHdpdGggR2l0CiAKIFtbdGVsbGluZy1naXQteW91ci1uYW1lXV0KLVRlbGxpbmcgR2l0IHlvdXIgbmFtZQotLS0tLS0tLS0tLS0tLS0tLS0tLS0tCis9PT0gVGVsbGluZyBHaXQgeW91ciBuYW1lCiAKIEJlZm9yZSBjcmVhdGluZyBhbnkgY29tbWl0cywgeW91IHNob3VsZCBpbnRyb2R1Y2UgeW91cnNlbGYgdG8gR2l0LgogVGhlIGVhc2llc3Qgd2F5IHRvIGRvIHNvIGlzIHRvIHVzZSBsaW5rZ2l0OmdpdC1jb25maWdbMV06CkBAIC0xMDMwLDggKzEwMDAsNyBAQAogCiAKIFtbY3JlYXRpbmctYS1uZXctcmVwb3NpdG9yeV1dCi1DcmVhdGluZyBhIG5ldyByZXBvc2l0b3J5Ci0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCis9PT0gQ3JlYXRpbmcgYSBuZXcgcmVwb3NpdG9yeQogCiBDcmVhdGluZyBhIG5ldyByZXBvc2l0b3J5IGZyb20gc2NyYXRjaCBpcyB2ZXJ5IGVhc3k6CiAKQEAgLTEwNTIsOCArMTAyMSw3IEBACiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAKIFtbaG93LXRvLW1ha2UtYS1jb21taXRdXQotSG93IHRvIG1ha2UgYSBjb21taXQKLS0tLS0tLS0tLS0tLS0tLS0tLS0tCis9PT0gSG93IHRvIG1ha2UgYSBjb21taXQKIAogQ3JlYXRpbmcgYSBuZXcgY29tbWl0IHRha2VzIHRocmVlIHN0ZXBzOgogCkBAIC0xMTQ4LDggKzExMTYsNyBAQAogY2hvb3NpbmcgIlN0YWdlIEh1bmsgRm9yIENvbW1pdCIpLgogCiBbW2NyZWF0aW5nLWdvb2QtY29tbWl0LW1lc3NhZ2VzXV0KLUNyZWF0aW5nIGdvb2QgY29tbWl0IG1lc3NhZ2VzCi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorPT09IENyZWF0aW5nIGdvb2QgY29tbWl0IG1lc3NhZ2VzCiAKIFRob3VnaCBub3QgcmVxdWlyZWQsIGl0J3MgYSBnb29kIGlkZWEgdG8gYmVnaW4gdGhlIGNvbW1pdCBtZXNzYWdlCiB3aXRoIGEgc2luZ2xlIHNob3J0IChsZXNzIHRoYW4gNTAgY2hhcmFjdGVyKSBsaW5lIHN1bW1hcml6aW5nIHRoZQpAQCAtMTE2Miw4ICsxMTI5LDcgQEAKIAogCiBbW2lnbm9yaW5nLWZpbGVzXV0KLUlnbm9yaW5nIGZpbGVzCi0tLS0tLS0tLS0tLS0tLQorPT09IElnbm9yaW5nIGZpbGVzCiAKIEEgcHJvamVjdCB3aWxsIG9mdGVuIGdlbmVyYXRlIGZpbGVzIHRoYXQgeW91IGRvICdub3QnIHdhbnQgdG8gdHJhY2sgd2l0aCBHaXQuCiBUaGlzIHR5cGljYWxseSBpbmNsdWRlcyBmaWxlcyBnZW5lcmF0ZWQgYnkgYSBidWlsZCBwcm9jZXNzIG9yIHRlbXBvcmFyeQpAQCAtMTIwNSw4ICsxMTcxLDcgQEAKIGNvbW1hbmQgbGluZS4gIFNlZSBsaW5rZ2l0OmdpdGlnbm9yZVs1XSBmb3IgdGhlIGRldGFpbHMuCiAKIFtbaG93LXRvLW1lcmdlXV0KLUhvdyB0byBtZXJnZQotLS0tLS0tLS0tLS0tCis9PT0gSG93IHRvIG1lcmdlCiAKIFlvdSBjYW4gcmVqb2luIHR3byBkaXZlcmdpbmcgYnJhbmNoZXMgb2YgZGV2ZWxvcG1lbnQgdXNpbmcKIGxpbmtnaXQ6Z2l0LW1lcmdlWzFdOgpAQCAtMTI1NCw4ICsxMjE5LDcgQEAKIG9uZSB0byB0aGUgdG9wIG9mIHRoZSBvdGhlciBicmFuY2guCiAKIFtbcmVzb2x2aW5nLWEtbWVyZ2VdXQotUmVzb2x2aW5nIGEgbWVyZ2UKLS0tLS0tLS0tLS0tLS0tLS0tCis9PT0gUmVzb2x2aW5nIGEgbWVyZ2UKIAogV2hlbiBhIG1lcmdlIGlzbid0IHJlc29sdmVkIGF1dG9tYXRpY2FsbHksIEdpdCBsZWF2ZXMgdGhlIGluZGV4IGFuZAogdGhlIHdvcmtpbmcgdHJlZSBpbiBhIHNwZWNpYWwgc3RhdGUgdGhhdCBnaXZlcyB5b3UgYWxsIHRoZQpAQCAtMTI5Nyw4ICsxMjYxLDcgQEAKIGFsc28gcHJvdmlkZXMgbW9yZSBpbmZvcm1hdGlvbiB0byBoZWxwIHJlc29sdmUgY29uZmxpY3RzOgogCiBbW2NvbmZsaWN0LXJlc29sdXRpb25dXQotR2V0dGluZyBjb25mbGljdC1yZXNvbHV0aW9uIGhlbHAgZHVyaW5nIGEgbWVyZ2UKLX5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+Cis9PT09IEdldHRpbmcgY29uZmxpY3QtcmVzb2x1dGlvbiBoZWxwIGR1cmluZyBhIG1lcmdlCiAKIEFsbCBvZiB0aGUgY2hhbmdlcyB0aGF0IEdpdCB3YXMgYWJsZSB0byBtZXJnZSBhdXRvbWF0aWNhbGx5IGFyZQogYWxyZWFkeSBhZGRlZCB0byB0aGUgaW5kZXggZmlsZSwgc28gbGlua2dpdDpnaXQtZGlmZlsxXSBzaG93cyBvbmx5CkBAIC0xNDAxLDggKzEzNjQsNyBAQAogYGdpdCBkaWZmYCB3aWxsIChieSBkZWZhdWx0KSBubyBsb25nZXIgc2hvdyBkaWZmcyBmb3IgdGhhdCBmaWxlLgogCiBbW3VuZG9pbmctYS1tZXJnZV1dCi1VbmRvaW5nIGEgbWVyZ2UKLS0tLS0tLS0tLS0tLS0tLQorPT09IFVuZG9pbmcgYSBtZXJnZQogCiBJZiB5b3UgZ2V0IHN0dWNrIGFuZCBkZWNpZGUgdG8ganVzdCBnaXZlIHVwIGFuZCB0aHJvdyB0aGUgd2hvbGUgbWVzcwogYXdheSwgeW91IGNhbiBhbHdheXMgcmV0dXJuIHRvIHRoZSBwcmUtbWVyZ2Ugc3RhdGUgd2l0aApAQCAtMTQyMyw4ICsxMzg1LDcgQEAKIGZ1cnRoZXIgbWVyZ2VzLgogCiBbW2Zhc3QtZm9yd2FyZHNdXQotRmFzdC1mb3J3YXJkIG1lcmdlcwotLS0tLS0tLS0tLS0tLS0tLS0tLQorPT09IEZhc3QtZm9yd2FyZCBtZXJnZXMKIAogVGhlcmUgaXMgb25lIHNwZWNpYWwgY2FzZSBub3QgbWVudGlvbmVkIGFib3ZlLCB3aGljaCBpcyB0cmVhdGVkCiBkaWZmZXJlbnRseS4gIE5vcm1hbGx5LCBhIG1lcmdlIHJlc3VsdHMgaW4gYSBtZXJnZSBjb21taXQsIHdpdGggdHdvCkBAIC0xNDM4LDggKzEzOTksNyBAQAogY3JlYXRlZC4KIAogW1tmaXhpbmctbWlzdGFrZXNdXQotRml4aW5nIG1pc3Rha2VzCi0tLS0tLS0tLS0tLS0tLS0KKz09PSBGaXhpbmcgbWlzdGFrZXMKIAogSWYgeW91J3ZlIG1lc3NlZCB1cCB0aGUgd29ya2luZyB0cmVlLCBidXQgaGF2ZW4ndCB5ZXQgY29tbWl0dGVkIHlvdXIKIG1pc3Rha2UsIHlvdSBjYW4gcmV0dXJuIHRoZSBlbnRpcmUgd29ya2luZyB0cmVlIHRvIHRoZSBsYXN0IGNvbW1pdHRlZApAQCAtMTQ2Myw4ICsxNDIzLDcgQEAKIAlhIGJyYW5jaCB0aGF0IGhhcyBoYWQgaXRzIGhpc3RvcnkgY2hhbmdlZC4KIAogW1tyZXZlcnRpbmctYS1jb21taXRdXQotRml4aW5nIGEgbWlzdGFrZSB3aXRoIGEgbmV3IGNvbW1pdAotfn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fgorPT09PSBGaXhpbmcgYSBtaXN0YWtlIHdpdGggYSBuZXcgY29tbWl0CiAKIENyZWF0aW5nIGEgbmV3IGNvbW1pdCB0aGF0IHJldmVydHMgYW4gZWFybGllciBjaGFuZ2UgaXMgdmVyeSBlYXN5OwoganVzdCBwYXNzIHRoZSBsaW5rZ2l0OmdpdC1yZXZlcnRbMV0gY29tbWFuZCBhIHJlZmVyZW5jZSB0byB0aGUgYmFkCkBAIC0xNDkwLDggKzE0NDksNyBAQAogcmVzb2x2aW5nIGEgbWVyZ2U+Pi4KIAogW1tmaXhpbmctYS1taXN0YWtlLWJ5LXJld3JpdGluZy1oaXN0b3J5XV0KLUZpeGluZyBhIG1pc3Rha2UgYnkgcmV3cml0aW5nIGhpc3RvcnkKLX5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn4KKz09PT0gRml4aW5nIGEgbWlzdGFrZSBieSByZXdyaXRpbmcgaGlzdG9yeQogCiBJZiB0aGUgcHJvYmxlbWF0aWMgY29tbWl0IGlzIHRoZSBtb3N0IHJlY2VudCBjb21taXQsIGFuZCB5b3UgaGF2ZSBub3QKIHlldCBtYWRlIHRoYXQgY29tbWl0IHB1YmxpYywgdGhlbiB5b3UgbWF5IGp1c3QKQEAgLTE1MTgsOCArMTQ3Niw3IEBACiA8PGNsZWFuaW5nLXVwLWhpc3RvcnksYW5vdGhlciBjaGFwdGVyPj4uCiAKIFtbY2hlY2tvdXQtb2YtcGF0aF1dCi1DaGVja2luZyBvdXQgYW4gb2xkIHZlcnNpb24gb2YgYSBmaWxlCi1+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+Cis9PT09IENoZWNraW5nIG91dCBhbiBvbGQgdmVyc2lvbiBvZiBhIGZpbGUKIAogSW4gdGhlIHByb2Nlc3Mgb2YgdW5kb2luZyBhIHByZXZpb3VzIGJhZCBjaGFuZ2UsIHlvdSBtYXkgZmluZCBpdAogdXNlZnVsIHRvIGNoZWNrIG91dCBhbiBvbGRlciB2ZXJzaW9uIG9mIGEgcGFydGljdWxhciBmaWxlIHVzaW5nCkBAIC0xNTQzLDggKzE1MDAsNyBAQAogd2hpY2ggd2lsbCBkaXNwbGF5IHRoZSBnaXZlbiB2ZXJzaW9uIG9mIHRoZSBmaWxlLgogCiBbW2ludGVycnVwdGVkLXdvcmtdXQotVGVtcG9yYXJpbHkgc2V0dGluZyBhc2lkZSB3b3JrIGluIHByb2dyZXNzCi1+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn4KKz09PT0gVGVtcG9yYXJpbHkgc2V0dGluZyBhc2lkZSB3b3JrIGluIHByb2dyZXNzCiAKIFdoaWxlIHlvdSBhcmUgaW4gdGhlIG1pZGRsZSBvZiB3b3JraW5nIG9uIHNvbWV0aGluZyBjb21wbGljYXRlZCwgeW91CiBmaW5kIGFuIHVucmVsYXRlZCBidXQgb2J2aW91cyBhbmQgdHJpdmlhbCBidWcuICBZb3Ugd291bGQgbGlrZSB0byBmaXggaXQKQEAgLTE1NzUsOCArMTUzMSw3IEBACiAKIAogW1tlbnN1cmluZy1nb29kLXBlcmZvcm1hbmNlXV0KLUVuc3VyaW5nIGdvb2QgcGVyZm9ybWFuY2UKLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKz09PSBFbnN1cmluZyBnb29kIHBlcmZvcm1hbmNlCiAKIE9uIGxhcmdlIHJlcG9zaXRvcmllcywgR2l0IGRlcGVuZHMgb24gY29tcHJlc3Npb24gdG8ga2VlcCB0aGUgaGlzdG9yeQogaW5mb3JtYXRpb24gZnJvbSB0YWtpbmcgdXAgdG9vIG11Y2ggc3BhY2Ugb24gZGlzayBvciBpbiBtZW1vcnkuICBTb21lCkBAIC0xNTg3LDEyICsxNTQyLDEwIEBACiAKIAogW1tlbnN1cmluZy1yZWxpYWJpbGl0eV1dCi1FbnN1cmluZyByZWxpYWJpbGl0eQotLS0tLS0tLS0tLS0tLS0tLS0tLS0KKz09PSBFbnN1cmluZyByZWxpYWJpbGl0eQogCiBbW2NoZWNraW5nLWZvci1jb3JydXB0aW9uXV0KLUNoZWNraW5nIHRoZSByZXBvc2l0b3J5IGZvciBjb3JydXB0aW9uCi1+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fgorPT09PSBDaGVja2luZyB0aGUgcmVwb3NpdG9yeSBmb3IgY29ycnVwdGlvbgogCiBUaGUgbGlua2dpdDpnaXQtZnNja1sxXSBjb21tYW5kIHJ1bnMgYSBudW1iZXIgb2Ygc2VsZi1jb25zaXN0ZW5jeSBjaGVja3MKIG9uIHRoZSByZXBvc2l0b3J5LCBhbmQgcmVwb3J0cyBvbiBhbnkgcHJvYmxlbXMuICBUaGlzIG1heSB0YWtlIHNvbWUKQEAgLTE2MTgsMTIgKzE1NzEsMTAgQEAKIHZpZXcgcmVhbCBlcnJvcnMuCiAKIFtbcmVjb3ZlcmluZy1sb3N0LWNoYW5nZXNdXQotUmVjb3ZlcmluZyBsb3N0IGNoYW5nZXMKLX5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+Cis9PT09IFJlY292ZXJpbmcgbG9zdCBjaGFuZ2VzCiAKIFtbcmVmbG9nc11dCi1SZWZsb2dzCi1eXl5eXl5eCis9PT09PSBSZWZsb2dzCiAKIFNheSB5b3UgbW9kaWZ5IGEgYnJhbmNoIHdpdGggPDxmaXhpbmctbWlzdGFrZXMsYGdpdCByZXNldCAtLWhhcmRgPj4sCiBhbmQgdGhlbiByZWFsaXplIHRoYXQgdGhlIGJyYW5jaCB3YXMgdGhlIG9ubHkgcmVmZXJlbmNlIHlvdSBoYWQgdG8KQEAgLTE2NzAsOCArMTYyMSw3IEBACiBob3cgdGhlIGJyYW5jaGVzIGluIHlvdXIgbG9jYWwgcmVwb3NpdG9yeSBoYXZlIGNoYW5nZWQgb3ZlciB0aW1lLgogCiBbW2RhbmdsaW5nLW9iamVjdC1yZWNvdmVyeV1dCi1FeGFtaW5pbmcgZGFuZ2xpbmcgb2JqZWN0cwotXl5eXl5eXl5eXl5eXl5eXl5eXl5eXl5eXl4KKz09PT09IEV4YW1pbmluZyBkYW5nbGluZyBvYmplY3RzCiAKIEluIHNvbWUgc2l0dWF0aW9ucyB0aGUgcmVmbG9nIG1heSBub3QgYmUgYWJsZSB0byBzYXZlIHlvdS4gIEZvciBleGFtcGxlLAogc3VwcG9zZSB5b3UgZGVsZXRlIGEgYnJhbmNoLCB0aGVuIHJlYWxpemUgeW91IG5lZWQgdGhlIGhpc3RvcnkgaXQKQEAgLTE3MTUsMTIgKzE2NjUsMTAgQEAKIAogCiBbW3NoYXJpbmctZGV2ZWxvcG1lbnRdXQotU2hhcmluZyBkZXZlbG9wbWVudCB3aXRoIG90aGVycwotPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQorPT0gU2hhcmluZyBkZXZlbG9wbWVudCB3aXRoIG90aGVycwogCiBbW2dldHRpbmctdXBkYXRlcy1XaXRoLWdpdC1wdWxsXV0KLUdldHRpbmcgdXBkYXRlcyB3aXRoIGdpdCBwdWxsCi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorPT09IEdldHRpbmcgdXBkYXRlcyB3aXRoIGdpdCBwdWxsCiAKIEFmdGVyIHlvdSBjbG9uZSBhIHJlcG9zaXRvcnkgYW5kIGNvbW1pdCBhIGZldyBjaGFuZ2VzIG9mIHlvdXIgb3duLCB5b3UKIG1heSB3aXNoIHRvIGNoZWNrIHRoZSBvcmlnaW5hbCByZXBvc2l0b3J5IGZvciB1cGRhdGVzIGFuZCBtZXJnZSB0aGVtCkBAIC0xNzgzLDggKzE3MzEsNyBAQAogYXJlIHJvdWdobHkgZXF1aXZhbGVudC4KIAogW1tzdWJtaXR0aW5nLXBhdGNoZXNdXQotU3VibWl0dGluZyBwYXRjaGVzIHRvIGEgcHJvamVjdAotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorPT09IFN1Ym1pdHRpbmcgcGF0Y2hlcyB0byBhIHByb2plY3QKIAogSWYgeW91IGp1c3QgaGF2ZSBhIGZldyBjaGFuZ2VzLCB0aGUgc2ltcGxlc3Qgd2F5IHRvIHN1Ym1pdCB0aGVtIG1heQoganVzdCBiZSB0byBzZW5kIHRoZW0gYXMgcGF0Y2hlcyBpbiBlbWFpbDoKQEAgLTE4MTIsOCArMTc1OSw3IEBACiB0aGVpciByZXF1aXJlbWVudHMgZm9yIHN1Ym1pdHRpbmcgcGF0Y2hlcy4KIAogW1tpbXBvcnRpbmctcGF0Y2hlc11dCi1JbXBvcnRpbmcgcGF0Y2hlcyB0byBhIHByb2plY3QKLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorPT09IEltcG9ydGluZyBwYXRjaGVzIHRvIGEgcHJvamVjdAogCiBHaXQgYWxzbyBwcm92aWRlcyBhIHRvb2wgY2FsbGVkIGxpbmtnaXQ6Z2l0LWFtWzFdIChhbSBzdGFuZHMgZm9yCiAiYXBwbHkgbWFpbGJveCIpLCBmb3IgaW1wb3J0aW5nIHN1Y2ggYW4gZW1haWxlZCBzZXJpZXMgb2YgcGF0Y2hlcy4KQEAgLTE4NDUsOCArMTc5MSw3IEBACiB0YWtlbiBmcm9tIHRoZSBtZXNzYWdlIGNvbnRhaW5pbmcgZWFjaCBwYXRjaC4KIAogW1twdWJsaWMtcmVwb3NpdG9yaWVzXV0KLVB1YmxpYyBHaXQgcmVwb3NpdG9yaWVzCi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorPT09IFB1YmxpYyBHaXQgcmVwb3NpdG9yaWVzCiAKIEFub3RoZXIgd2F5IHRvIHN1Ym1pdCBjaGFuZ2VzIHRvIGEgcHJvamVjdCBpcyB0byB0ZWxsIHRoZSBtYWludGFpbmVyCiBvZiB0aGF0IHByb2plY3QgdG8gcHVsbCB0aGUgY2hhbmdlcyBmcm9tIHlvdXIgcmVwb3NpdG9yeSB1c2luZwpAQCAtMTg4NiwyMSArMTgzMSwyMiBAQAogd2hlcmUgdGhlcmUgaXMgb25lIG90aGVyIGRldmVsb3BlciB3aXRoIGEgcHVibGljIHJlcG9zaXRvcnksIGxvb2tzCiBsaWtlIHRoaXM6CiAKLSAgICAgICAgICAgICAgICAgICAgICAgIHlvdSBwdXNoCi0gIHlvdXIgcGVyc29uYWwgcmVwbyAtLS0tLS0tLS0tLS0tLS0tLS0+IHlvdXIgcHVibGljIHJlcG8KLQleICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwKLQl8ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwKLQl8IHlvdSBwdWxsICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgdGhleSBwdWxsCi0JfCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8Ci0JfCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8Ci0gICAgICAgIHwgICAgICAgICAgICAgICB0aGV5IHB1c2ggICAgICAgICAgICAgVgotICB0aGVpciBwdWJsaWMgcmVwbyA8LS0tLS0tLS0tLS0tLS0tLS0tLSB0aGVpciByZXBvCisuLi4uCisJCSAgICAgIHlvdSBwdXNoCit5b3VyIHBlcnNvbmFsIHJlcG8gLS0tLS0tLS0tLS0tLS0tLS0tPiB5b3VyIHB1YmxpYyByZXBvCisgICAgICBeICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwKKyAgICAgIHwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfAorICAgICAgfCB5b3UgcHVsbCAgICAgICAgICAgICAgICAgICAgICAgICAgICB8IHRoZXkgcHVsbAorICAgICAgfCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8CisgICAgICB8ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwKKyAgICAgIHwgICAgICAgICAgICAgICB0aGV5IHB1c2ggICAgICAgICAgICAgVgordGhlaXIgcHVibGljIHJlcG8gPC0tLS0tLS0tLS0tLS0tLS0tLS0gdGhlaXIgcmVwbworLi4uLgogCiBXZSBleHBsYWluIGhvdyB0byBkbyB0aGlzIGluIHRoZSBmb2xsb3dpbmcgc2VjdGlvbnMuCiAKIFtbc2V0dGluZy11cC1hLXB1YmxpYy1yZXBvc2l0b3J5XV0KLVNldHRpbmcgdXAgYSBwdWJsaWMgcmVwb3NpdG9yeQotfn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+Cis9PT09IFNldHRpbmcgdXAgYSBwdWJsaWMgcmVwb3NpdG9yeQogCiBBc3N1bWUgeW91ciBwZXJzb25hbCByZXBvc2l0b3J5IGlzIGluIHRoZSBkaXJlY3RvcnkgYH4vcHJvamAuICBXZQogZmlyc3QgY3JlYXRlIGEgbmV3IGNsb25lIG9mIHRoZSByZXBvc2l0b3J5IGFuZCB0ZWxsIGBnaXQgZGFlbW9uYCB0aGF0IGl0CkBAIC0xOTIwLDggKzE4NjYsNyBAQAogY29udmVuaWVudC4KIAogW1tleHBvcnRpbmctdmlhLWdpdF1dCi1FeHBvcnRpbmcgYSBHaXQgcmVwb3NpdG9yeSB2aWEgdGhlIEdpdCBwcm90b2NvbAotfn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn4KKz09PT0gRXhwb3J0aW5nIGEgR2l0IHJlcG9zaXRvcnkgdmlhIHRoZSBHaXQgcHJvdG9jb2wKIAogVGhpcyBpcyB0aGUgcHJlZmVycmVkIG1ldGhvZC4KIApAQCAtMTk0Miw4ICsxODg3LDcgQEAKIGV4YW1wbGVzIHNlY3Rpb24uKQogCiBbW2V4cG9ydGluZy12aWEtaHR0cF1dCi1FeHBvcnRpbmcgYSBnaXQgcmVwb3NpdG9yeSB2aWEgSFRUUAotfn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn4KKz09PT0gRXhwb3J0aW5nIGEgZ2l0IHJlcG9zaXRvcnkgdmlhIEhUVFAKIAogVGhlIEdpdCBwcm90b2NvbCBnaXZlcyBiZXR0ZXIgcGVyZm9ybWFuY2UgYW5kIHJlbGlhYmlsaXR5LCBidXQgb24gYQogaG9zdCB3aXRoIGEgd2ViIHNlcnZlciBzZXQgdXAsIEhUVFAgZXhwb3J0cyBtYXkgYmUgc2ltcGxlciB0byBzZXQgdXAuCkBAIC0xOTc1LDggKzE5MTksNyBAQAogYWxsb3dzIHB1c2hpbmcgb3ZlciBIVFRQLikKIAogW1twdXNoaW5nLWNoYW5nZXMtdG8tYS1wdWJsaWMtcmVwb3NpdG9yeV1dCi1QdXNoaW5nIGNoYW5nZXMgdG8gYSBwdWJsaWMgcmVwb3NpdG9yeQotfn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn4KKz09PT0gUHVzaGluZyBjaGFuZ2VzIHRvIGEgcHVibGljIHJlcG9zaXRvcnkKIAogTm90ZSB0aGF0IHRoZSB0d28gdGVjaG5pcXVlcyBvdXRsaW5lZCBhYm92ZSAoZXhwb3J0aW5nIHZpYQogPDxleHBvcnRpbmctdmlhLWh0dHAsaHR0cD4+IG9yIDw8ZXhwb3J0aW5nLXZpYS1naXQsZ2l0Pj4pIGFsbG93IG90aGVyCkBAIC0yMDM1LDggKzE5NzgsNyBAQAogbGlua2dpdDpnaXQtY29uZmlnWzFdIGZvciBkZXRhaWxzLgogCiBbW2ZvcmNpbmctcHVzaF1dCi1XaGF0IHRvIGRvIHdoZW4gYSBwdXNoIGZhaWxzCi1+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+Cis9PT09IFdoYXQgdG8gZG8gd2hlbiBhIHB1c2ggZmFpbHMKIAogSWYgYSBwdXNoIHdvdWxkIG5vdCByZXN1bHQgaW4gYSA8PGZhc3QtZm9yd2FyZHMsZmFzdC1mb3J3YXJkPj4gb2YgdGhlCiByZW1vdGUgYnJhbmNoLCB0aGVuIGl0IHdpbGwgZmFpbCB3aXRoIGFuIGVycm9yIGxpa2U6CkBAIC0yMDkwLDggKzIwMzIsNyBAQAogbGlua2dpdDpnaXRjdnMtbWlncmF0aW9uWzddIGZvciBtb3JlLgogCiBbW3NldHRpbmctdXAtYS1zaGFyZWQtcmVwb3NpdG9yeV1dCi1TZXR0aW5nIHVwIGEgc2hhcmVkIHJlcG9zaXRvcnkKLX5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fgorPT09PSBTZXR0aW5nIHVwIGEgc2hhcmVkIHJlcG9zaXRvcnkKIAogQW5vdGhlciB3YXkgdG8gY29sbGFib3JhdGUgaXMgYnkgdXNpbmcgYSBtb2RlbCBzaW1pbGFyIHRvIHRoYXQKIGNvbW1vbmx5IHVzZWQgaW4gQ1ZTLCB3aGVyZSBzZXZlcmFsIGRldmVsb3BlcnMgd2l0aCBzcGVjaWFsIHJpZ2h0cwpAQCAtMjEyMSw4ICsyMDYyLDcgQEAKIAkgICJvdXQiLgogCiBbW3NldHRpbmctdXAtZ2l0d2ViXV0KLUFsbG93aW5nIHdlYiBicm93c2luZyBvZiBhIHJlcG9zaXRvcnkKLX5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn4KKz09PT0gQWxsb3dpbmcgd2ViIGJyb3dzaW5nIG9mIGEgcmVwb3NpdG9yeQogCiBUaGUgZ2l0d2ViIGNnaSBzY3JpcHQgcHJvdmlkZXMgdXNlcnMgYW4gZWFzeSB3YXkgdG8gYnJvd3NlIHlvdXIKIHByb2plY3QncyByZXZpc2lvbnMsIGZpbGUgY29udGVudHMgYW5kIGxvZ3Mgd2l0aG91dCBoYXZpbmcgdG8gaW5zdGFsbApAQCAtMjEzOCw4ICsyMDc4LDcgQEAKIGluc3RhbGxhdGlvbiB3aXRoIGEgQ0dJIG9yIFBlcmwgY2FwYWJsZSBzZXJ2ZXIuCiAKIFtbaG93LXRvLWdldC1hLWdpdC1yZXBvc2l0b3J5LXdpdGgtbWluaW1hbC1oaXN0b3J5XV0KLUhvdyB0byBnZXQgYSBHaXQgcmVwb3NpdG9yeSB3aXRoIG1pbmltYWwgaGlzdG9yeQotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCis9PT0gSG93IHRvIGdldCBhIEdpdCByZXBvc2l0b3J5IHdpdGggbWluaW1hbCBoaXN0b3J5CiAKIEEgPDxkZWZfc2hhbGxvd19jbG9uZSxzaGFsbG93IGNsb25lPj4sIHdpdGggaXRzIHRydW5jYXRlZAogaGlzdG9yeSwgaXMgdXNlZnVsIHdoZW4gb25lIGlzIGludGVyZXN0ZWQgb25seSBpbiByZWNlbnQgaGlzdG9yeQpAQCAtMjE1OCwxMiArMjA5NywxMCBAQAogYSByZXBvc2l0b3J5IHVuc3VpdGFibGUgdG8gYmUgdXNlZCBpbiBtZXJnZSBiYXNlZCB3b3JrZmxvd3MuCiAKIFtbc2hhcmluZy1kZXZlbG9wbWVudC1leGFtcGxlc11dCi1FeGFtcGxlcwotLS0tLS0tLS0KKz09PSBFeGFtcGxlcwogCiBbW21haW50YWluaW5nLXRvcGljLWJyYW5jaGVzXV0KLU1haW50YWluaW5nIHRvcGljIGJyYW5jaGVzIGZvciBhIExpbnV4IHN1YnN5c3RlbSBtYWludGFpbmVyCi1+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fgorPT09PSBNYWludGFpbmluZyB0b3BpYyBicmFuY2hlcyBmb3IgYSBMaW51eCBzdWJzeXN0ZW0gbWFpbnRhaW5lcgogCiBUaGlzIGRlc2NyaWJlcyBob3cgVG9ueSBMdWNrIHVzZXMgR2l0IGluIGhpcyByb2xlIGFzIG1haW50YWluZXIgb2YgdGhlCiBJQTY0IGFyY2hpdGVjdHVyZSBmb3IgdGhlIExpbnV4IGtlcm5lbC4KQEAgLTI0NTksOCArMjM5Niw3IEBACiAKIAogW1tjbGVhbmluZy11cC1oaXN0b3J5XV0KLVJld3JpdGluZyBoaXN0b3J5IGFuZCBtYWludGFpbmluZyBwYXRjaCBzZXJpZXMKLT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KKz09IFJld3JpdGluZyBoaXN0b3J5IGFuZCBtYWludGFpbmluZyBwYXRjaCBzZXJpZXMKIAogTm9ybWFsbHkgY29tbWl0cyBhcmUgb25seSBhZGRlZCB0byBhIHByb2plY3QsIG5ldmVyIHRha2VuIGF3YXkgb3IKIHJlcGxhY2VkLiAgR2l0IGlzIGRlc2lnbmVkIHdpdGggdGhpcyBhc3N1bXB0aW9uLCBhbmQgdmlvbGF0aW5nIGl0IHdpbGwKQEAgLTI0NzAsOCArMjQwNiw3IEBACiBhc3N1bXB0aW9uLgogCiBbW3BhdGNoLXNlcmllc11dCi1DcmVhdGluZyB0aGUgcGVyZmVjdCBwYXRjaCBzZXJpZXMKLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorPT09IENyZWF0aW5nIHRoZSBwZXJmZWN0IHBhdGNoIHNlcmllcwogCiBTdXBwb3NlIHlvdSBhcmUgYSBjb250cmlidXRvciB0byBhIGxhcmdlIHByb2plY3QsIGFuZCB5b3Ugd2FudCB0byBhZGQgYQogY29tcGxpY2F0ZWQgZmVhdHVyZSwgYW5kIHRvIHByZXNlbnQgaXQgdG8gdGhlIG90aGVyIGRldmVsb3BlcnMgaW4gYSB3YXkKQEAgLTI1MDMsOCArMjQzOCw3IEBACiB5b3UgYXJlIHJld3JpdGluZyBoaXN0b3J5LgogCiBbW3VzaW5nLWdpdC1yZWJhc2VdXQotS2VlcGluZyBhIHBhdGNoIHNlcmllcyB1cCB0byBkYXRlIHVzaW5nIGdpdCByZWJhc2UKLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCis9PT0gS2VlcGluZyBhIHBhdGNoIHNlcmllcyB1cCB0byBkYXRlIHVzaW5nIGdpdCByZWJhc2UKIAogU3VwcG9zZSB0aGF0IHlvdSBjcmVhdGUgYSBicmFuY2ggYG15d29ya2Agb24gYSByZW1vdGUtdHJhY2tpbmcgYnJhbmNoCiBgb3JpZ2luYCwgYW5kIGNyZWF0ZSBzb21lIGNvbW1pdHMgb24gdG9wIG9mIGl0OgpAQCAtMjU5MSw4ICsyNTI1LDcgQEAKIDw8cmVvcmRlcmluZy1wYXRjaC1zZXJpZXM+PiBmb3IgYWx0ZXJuYXRpdmVzLgogCiBbW3Jld3JpdGluZy1vbmUtY29tbWl0XV0KLVJld3JpdGluZyBhIHNpbmdsZSBjb21taXQKLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKz09PSBSZXdyaXRpbmcgYSBzaW5nbGUgY29tbWl0CiAKIFdlIHNhdyBpbiA8PGZpeGluZy1hLW1pc3Rha2UtYnktcmV3cml0aW5nLWhpc3Rvcnk+PiB0aGF0IHlvdSBjYW4gcmVwbGFjZSB0aGUKIG1vc3QgcmVjZW50IGNvbW1pdCB1c2luZwpAQCAtMjYxMCw4ICsyNTQzLDcgQEAKIHVzZSA8PGludGVyYWN0aXZlLXJlYmFzZSxpbnRlcmFjdGl2ZSByZWJhc2UncyBgZWRpdGAgaW5zdHJ1Y3Rpb24+Pi4KIAogW1tyZW9yZGVyaW5nLXBhdGNoLXNlcmllc11dCi1SZW9yZGVyaW5nIG9yIHNlbGVjdGluZyBmcm9tIGEgcGF0Y2ggc2VyaWVzCi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCis9PT0gUmVvcmRlcmluZyBvciBzZWxlY3RpbmcgZnJvbSBhIHBhdGNoIHNlcmllcwogCiBTb21ldGltZXMgeW91IHdhbnQgdG8gZWRpdCBhIGNvbW1pdCBkZWVwZXIgaW4geW91ciBoaXN0b3J5LiAgT25lCiBhcHByb2FjaCBpcyB0byB1c2UgYGdpdCBmb3JtYXQtcGF0Y2hgIHRvIGNyZWF0ZSBhIHNlcmllcyBvZiBwYXRjaGVzCkBAIC0yNjMwLDggKzI1NjIsNyBAQAogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogCiBbW2ludGVyYWN0aXZlLXJlYmFzZV1dCi1Vc2luZyBpbnRlcmFjdGl2ZSByZWJhc2VzCi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCis9PT0gVXNpbmcgaW50ZXJhY3RpdmUgcmViYXNlcwogCiBZb3UgY2FuIGFsc28gZWRpdCBhIHBhdGNoIHNlcmllcyB3aXRoIGFuIGludGVyYWN0aXZlIHJlYmFzZS4gIFRoaXMgaXMKIHRoZSBzYW1lIGFzIDw8cmVvcmRlcmluZy1wYXRjaC1zZXJpZXMscmVvcmRlcmluZyBhIHBhdGNoIHNlcmllcyB1c2luZwpAQCAtMjY4OCwxNiArMjYxOSwxNCBAQAogc2VlIHRoZSAiSU5URVJBQ1RJVkUgTU9ERSIgc2VjdGlvbiBvZiBsaW5rZ2l0OmdpdC1yZWJhc2VbMV0uCiAKIFtbcGF0Y2gtc2VyaWVzLXRvb2xzXV0KLU90aGVyIHRvb2xzCi0tLS0tLS0tLS0tLQorPT09IE90aGVyIHRvb2xzCiAKIFRoZXJlIGFyZSBudW1lcm91cyBvdGhlciB0b29scywgc3VjaCBhcyBTdEdpdCwgd2hpY2ggZXhpc3QgZm9yIHRoZQogcHVycG9zZSBvZiBtYWludGFpbmluZyBhIHBhdGNoIHNlcmllcy4gIFRoZXNlIGFyZSBvdXRzaWRlIG9mIHRoZSBzY29wZSBvZgogdGhpcyBtYW51YWwuCiAKIFtbcHJvYmxlbXMtV2l0aC1yZXdyaXRpbmctaGlzdG9yeV1dCi1Qcm9ibGVtcyB3aXRoIHJld3JpdGluZyBoaXN0b3J5Ci0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCis9PT0gUHJvYmxlbXMgd2l0aCByZXdyaXRpbmcgaGlzdG9yeQogCiBUaGUgcHJpbWFyeSBwcm9ibGVtIHdpdGggcmV3cml0aW5nIHRoZSBoaXN0b3J5IG9mIGEgYnJhbmNoIGhhcyB0byBkbwogd2l0aCBtZXJnaW5nLiAgU3VwcG9zZSBzb21lYm9keSBmZXRjaGVzIHlvdXIgYnJhbmNoIGFuZCBtZXJnZXMgaXQgaW50bwpAQCAtMjc0NSw4ICsyNjc0LDcgQEAKIHB1Ymxpc2hlZCBicmFuY2hlcyBzaG91bGQgbmV2ZXIgYmUgcmV3cml0dGVuLgogCiBbW2Jpc2VjdC1tZXJnZXNdXQotV2h5IGJpc2VjdGluZyBtZXJnZSBjb21taXRzIGNhbiBiZSBoYXJkZXIgdGhhbiBiaXNlY3RpbmcgbGluZWFyIGhpc3RvcnkKLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCis9PT0gV2h5IGJpc2VjdGluZyBtZXJnZSBjb21taXRzIGNhbiBiZSBoYXJkZXIgdGhhbiBiaXNlY3RpbmcgbGluZWFyIGhpc3RvcnkKIAogVGhlIGxpbmtnaXQ6Z2l0LWJpc2VjdFsxXSBjb21tYW5kIGNvcnJlY3RseSBoYW5kbGVzIGhpc3RvcnkgdGhhdAogaW5jbHVkZXMgbWVyZ2UgY29tbWl0cy4gIEhvd2V2ZXIsIHdoZW4gdGhlIGNvbW1pdCB0aGF0IGl0IGZpbmRzIGlzIGEKQEAgLTI4MTEsMTIgKzI3MzksMTAgQEAKIHB1Ymxpc2hpbmcuCiAKIFtbYWR2YW5jZWQtYnJhbmNoLW1hbmFnZW1lbnRdXQotQWR2YW5jZWQgYnJhbmNoIG1hbmFnZW1lbnQKLT09PT09PT09PT09PT09PT09PT09PT09PT09Cis9PSBBZHZhbmNlZCBicmFuY2ggbWFuYWdlbWVudAogCiBbW2ZldGNoaW5nLWluZGl2aWR1YWwtYnJhbmNoZXNdXQotRmV0Y2hpbmcgaW5kaXZpZHVhbCBicmFuY2hlcwotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorPT09IEZldGNoaW5nIGluZGl2aWR1YWwgYnJhbmNoZXMKIAogSW5zdGVhZCBvZiB1c2luZyBsaW5rZ2l0OmdpdC1yZW1vdGVbMV0sIHlvdSBjYW4gYWxzbyBjaG9vc2UganVzdAogdG8gdXBkYXRlIG9uZSBicmFuY2ggYXQgYSB0aW1lLCBhbmQgdG8gc3RvcmUgaXQgbG9jYWxseSB1bmRlciBhbgpAQCAtMjg0NCw4ICsyNzcwLDcgQEAKIG1hc3RlciBicmFuY2guICBJbiBtb3JlIGRldGFpbDoKIAogW1tmZXRjaC1mYXN0LWZvcndhcmRzXV0KLWdpdCBmZXRjaCBhbmQgZmFzdC1mb3J3YXJkcwotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCis9PT0gZ2l0IGZldGNoIGFuZCBmYXN0LWZvcndhcmRzCiAKIEluIHRoZSBwcmV2aW91cyBleGFtcGxlLCB3aGVuIHVwZGF0aW5nIGFuIGV4aXN0aW5nIGJyYW5jaCwgYGdpdCBmZXRjaGAKIGNoZWNrcyB0byBtYWtlIHN1cmUgdGhhdCB0aGUgbW9zdCByZWNlbnQgY29tbWl0IG9uIHRoZSByZW1vdGUKQEAgLTI4ODIsOCArMjgwNyw3IEBACiB0aGVtLgogCiBbW2ZvcmNpbmctZmV0Y2hdXQotRm9yY2luZyBnaXQgZmV0Y2ggdG8gZG8gbm9uLWZhc3QtZm9yd2FyZCB1cGRhdGVzCi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKz09PSBGb3JjaW5nIGdpdCBmZXRjaCB0byBkbyBub24tZmFzdC1mb3J3YXJkIHVwZGF0ZXMKIAogSWYgZ2l0IGZldGNoIGZhaWxzIGJlY2F1c2UgdGhlIG5ldyBoZWFkIG9mIGEgYnJhbmNoIGlzIG5vdCBhCiBkZXNjZW5kYW50IG9mIHRoZSBvbGQgaGVhZCwgeW91IG1heSBmb3JjZSB0aGUgdXBkYXRlIHdpdGg6CkBAIC0yOTAzLDggKzI4MjcsNyBAQAogbWF5IGJlIGxvc3QsIGFzIHdlIHNhdyBpbiB0aGUgcHJldmlvdXMgc2VjdGlvbi4KIAogW1tyZW1vdGUtYnJhbmNoLWNvbmZpZ3VyYXRpb25dXQotQ29uZmlndXJpbmcgcmVtb3RlLXRyYWNraW5nIGJyYW5jaGVzCi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKz09PSBDb25maWd1cmluZyByZW1vdGUtdHJhY2tpbmcgYnJhbmNoZXMKIAogV2Ugc2F3IGFib3ZlIHRoYXQgYG9yaWdpbmAgaXMganVzdCBhIHNob3J0Y3V0IHRvIHJlZmVyIHRvIHRoZQogcmVwb3NpdG9yeSB0aGF0IHlvdSBvcmlnaW5hbGx5IGNsb25lZCBmcm9tLiAgVGhpcyBpbmZvcm1hdGlvbiBpcwpAQCAtMjk1NSw4ICsyODc4LDcgQEAKIAogCiBbW2dpdC1jb25jZXB0c11dCi1HaXQgY29uY2VwdHMKLT09PT09PT09PT09PQorPT0gR2l0IGNvbmNlcHRzCiAKIEdpdCBpcyBidWlsdCBvbiBhIHNtYWxsIG51bWJlciBvZiBzaW1wbGUgYnV0IHBvd2VyZnVsIGlkZWFzLiAgV2hpbGUgaXQKIGlzIHBvc3NpYmxlIHRvIGdldCB0aGluZ3MgZG9uZSB3aXRob3V0IHVuZGVyc3RhbmRpbmcgdGhlbSwgeW91IHdpbGwgZmluZApAQCAtMjk2Niw4ICsyODg4LDcgQEAKIGRhdGFiYXNlPj4gYW5kIHRoZSA8PGRlZl9pbmRleCxpbmRleD4+LgogCiBbW3RoZS1vYmplY3QtZGF0YWJhc2VdXQotVGhlIE9iamVjdCBEYXRhYmFzZQotLS0tLS0tLS0tLS0tLS0tLS0tLQorPT09IFRoZSBPYmplY3QgRGF0YWJhc2UKIAogCiBXZSBhbHJlYWR5IHNhdyBpbiA8PHVuZGVyc3RhbmRpbmctY29tbWl0cz4+IHRoYXQgYWxsIGNvbW1pdHMgYXJlIHN0b3JlZApAQCAtMzAxMSw4ICsyOTMyLDcgQEAKIFRoZSBvYmplY3QgdHlwZXMgaW4gc29tZSBtb3JlIGRldGFpbDoKIAogW1tjb21taXQtb2JqZWN0XV0KLUNvbW1pdCBPYmplY3QKLX5+fn5+fn5+fn5+fn4KKz09PT0gQ29tbWl0IE9iamVjdAogCiBUaGUgImNvbW1pdCIgb2JqZWN0IGxpbmtzIGEgcGh5c2ljYWwgc3RhdGUgb2YgYSB0cmVlIHdpdGggYSBkZXNjcmlwdGlvbgogb2YgaG93IHdlIGdvdCB0aGVyZSBhbmQgd2h5LiAgVXNlIHRoZSBgLS1wcmV0dHk9cmF3YCBvcHRpb24gdG8KQEAgLTMwNjQsOCArMjk4NCw3IEBACiB0YWtlbiBmcm9tIHRoZSBjb250ZW50IGN1cnJlbnRseSBzdG9yZWQgaW4gdGhlIGluZGV4LgogCiBbW3RyZWUtb2JqZWN0XV0KLVRyZWUgT2JqZWN0Ci1+fn5+fn5+fn5+fgorPT09PSBUcmVlIE9iamVjdAogCiBUaGUgZXZlci12ZXJzYXRpbGUgbGlua2dpdDpnaXQtc2hvd1sxXSBjb21tYW5kIGNhbiBhbHNvIGJlIHVzZWQgdG8KIGV4YW1pbmUgdHJlZSBvYmplY3RzLCBidXQgbGlua2dpdDpnaXQtbHMtdHJlZVsxXSB3aWxsIGdpdmUgeW91IG1vcmUKQEAgLTMxMDQsOCArMzAyMyw3IEBACiBhdHRlbnRpb24gdG8gdGhlIGV4ZWN1dGFibGUgYml0LgogCiBbW2Jsb2Itb2JqZWN0XV0KLUJsb2IgT2JqZWN0Ci1+fn5+fn5+fn5+fgorPT09PSBCbG9iIE9iamVjdAogCiBZb3UgY2FuIHVzZSBsaW5rZ2l0OmdpdC1zaG93WzFdIHRvIGV4YW1pbmUgdGhlIGNvbnRlbnRzIG9mIGEgYmxvYjsgdGFrZSwKIGZvciBleGFtcGxlLCB0aGUgYmxvYiBpbiB0aGUgZW50cnkgZm9yIGBDT1BZSU5HYCBmcm9tIHRoZSB0cmVlIGFib3ZlOgpAQCAtMzEzNCw4ICszMDUyLDcgQEAKIGN1cnJlbnRseSBjaGVja2VkIG91dC4KIAogW1t0cnVzdF1dCi1UcnVzdAotfn5+fn4KKz09PT0gVHJ1c3QKIAogSWYgeW91IHJlY2VpdmUgdGhlIFNIQS0xIG5hbWUgb2YgYSBibG9iIGZyb20gb25lIHNvdXJjZSwgYW5kIGl0cyBjb250ZW50cwogZnJvbSBhbm90aGVyIChwb3NzaWJseSB1bnRydXN0ZWQpIHNvdXJjZSwgeW91IGNhbiBzdGlsbCB0cnVzdCB0aGF0IHRob3NlCkBAIC0zMTY0LDggKzMwODEsNyBAQAogVG8gYXNzaXN0IGluIHRoaXMsIEdpdCBhbHNvIHByb3ZpZGVzIHRoZSB0YWcgb2JqZWN0Li4uCiAKIFtbdGFnLW9iamVjdF1dCi1UYWcgT2JqZWN0Ci1+fn5+fn5+fn5+Cis9PT09IFRhZyBPYmplY3QKIAogQSB0YWcgb2JqZWN0IGNvbnRhaW5zIGFuIG9iamVjdCwgb2JqZWN0IHR5cGUsIHRhZyBuYW1lLCB0aGUgbmFtZSBvZiB0aGUKIHBlcnNvbiAoInRhZ2dlciIpIHdobyBjcmVhdGVkIHRoZSB0YWcsIGFuZCBhIG1lc3NhZ2UsIHdoaWNoIG1heSBjb250YWluCkBAIC0zMTk0LDggKzMxMTAsNyBAQAogcmVmZXJlbmNlcyB3aG9zZSBuYW1lcyBiZWdpbiB3aXRoIGByZWZzL3RhZ3MvYCkuCiAKIFtbcGFjay1maWxlc11dCi1Ib3cgR2l0IHN0b3JlcyBvYmplY3RzIGVmZmljaWVudGx5OiBwYWNrIGZpbGVzCi1+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+Cis9PT09IEhvdyBHaXQgc3RvcmVzIG9iamVjdHMgZWZmaWNpZW50bHk6IHBhY2sgZmlsZXMKIAogTmV3bHkgY3JlYXRlZCBvYmplY3RzIGFyZSBpbml0aWFsbHkgY3JlYXRlZCBpbiBhIGZpbGUgbmFtZWQgYWZ0ZXIgdGhlCiBvYmplY3QncyBTSEEtMSBoYXNoIChzdG9yZWQgaW4gYC5naXQvb2JqZWN0c2ApLgpAQCAtMzI1Myw4ICszMTY4LDcgQEAKIHlvdSwgc28gaXMgbm9ybWFsbHkgdGhlIG9ubHkgaGlnaC1sZXZlbCBjb21tYW5kIHlvdSBuZWVkLgogCiBbW2RhbmdsaW5nLW9iamVjdHNdXQotRGFuZ2xpbmcgb2JqZWN0cwotfn5+fn5+fn5+fn5+fn5+fgorPT09PSBEYW5nbGluZyBvYmplY3RzCiAKIFRoZSBsaW5rZ2l0OmdpdC1mc2NrWzFdIGNvbW1hbmQgd2lsbCBzb21ldGltZXMgY29tcGxhaW4gYWJvdXQgZGFuZ2xpbmcKIG9iamVjdHMuICBUaGV5IGFyZSBub3QgYSBwcm9ibGVtLgpAQCAtMzMzNCw4ICszMjQ4LDcgQEAKIGFjY2Vzc2VzIHRvIGEgcmVwb3NpdG9yeSBidXQgeW91IG1pZ2h0IHJlY2VpdmUgY29uZnVzaW5nIG9yIHNjYXJ5IG1lc3NhZ2VzLikKIAogW1tyZWNvdmVyaW5nLWZyb20tcmVwb3NpdG9yeS1jb3JydXB0aW9uXV0KLVJlY292ZXJpbmcgZnJvbSByZXBvc2l0b3J5IGNvcnJ1cHRpb24KLX5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn4KKz09PT0gUmVjb3ZlcmluZyBmcm9tIHJlcG9zaXRvcnkgY29ycnVwdGlvbgogCiBCeSBkZXNpZ24sIEdpdCB0cmVhdHMgZGF0YSB0cnVzdGVkIHRvIGl0IHdpdGggY2F1dGlvbi4gIEhvd2V2ZXIsIGV2ZW4gaW4KIHRoZSBhYnNlbmNlIG9mIGJ1Z3MgaW4gR2l0IGl0c2VsZiwgaXQgaXMgc3RpbGwgcG9zc2libGUgdGhhdCBoYXJkd2FyZSBvcgpAQCAtMzQ1Miw4ICszMzY1LDcgQEAKIGp1c3QgbWlzc2luZyBvbmUgcGFydGljdWxhciBibG9iIHZlcnNpb24uCiAKIFtbdGhlLWluZGV4XV0KLVRoZSBpbmRleAotLS0tLS0tLS0tCis9PT0gVGhlIGluZGV4CiAKIFRoZSBpbmRleCBpcyBhIGJpbmFyeSBmaWxlIChnZW5lcmFsbHkga2VwdCBpbiBgLmdpdC9pbmRleGApIGNvbnRhaW5pbmcgYQogc29ydGVkIGxpc3Qgb2YgcGF0aCBuYW1lcywgZWFjaCB3aXRoIHBlcm1pc3Npb25zIGFuZCB0aGUgU0hBLTEgb2YgYSBibG9iCkBAIC0zNTExLDggKzM0MjMsNyBAQAogaW5mb3JtYXRpb24gYXMgbG9uZyBhcyB5b3UgaGF2ZSB0aGUgbmFtZSBvZiB0aGUgdHJlZSB0aGF0IGl0IGRlc2NyaWJlZC4KIAogW1tzdWJtb2R1bGVzXV0KLVN1Ym1vZHVsZXMKLT09PT09PT09PT0KKz09IFN1Ym1vZHVsZXMKIAogTGFyZ2UgcHJvamVjdHMgYXJlIG9mdGVuIGNvbXBvc2VkIG9mIHNtYWxsZXIsIHNlbGYtY29udGFpbmVkIG1vZHVsZXMuICBGb3IKIGV4YW1wbGUsIGFuIGVtYmVkZGVkIExpbnV4IGRpc3RyaWJ1dGlvbidzIHNvdXJjZSB0cmVlIHdvdWxkIGluY2x1ZGUgZXZlcnkKQEAgLTM2OTgsOCArMzYwOSw4IEBACiBZb3UgaGF2ZSB0byBydW4gYGdpdCBzdWJtb2R1bGUgdXBkYXRlYCBhZnRlciBgZ2l0IHB1bGxgIGlmIHlvdSB3YW50IHRvIHVwZGF0ZQogc3VibW9kdWxlcywgdG9vLgogCi1QaXRmYWxscyB3aXRoIHN1Ym1vZHVsZXMKLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorW1twaXRmYWxscy13aXRoLXN1Ym1vZHVsZXNdXQorPT09IFBpdGZhbGxzIHdpdGggc3VibW9kdWxlcwogCiBBbHdheXMgcHVibGlzaCB0aGUgc3VibW9kdWxlIGNoYW5nZSBiZWZvcmUgcHVibGlzaGluZyB0aGUgY2hhbmdlIHRvIHRoZQogc3VwZXJwcm9qZWN0IHRoYXQgcmVmZXJlbmNlcyBpdC4gSWYgeW91IGZvcmdldCB0byBwdWJsaXNoIHRoZSBzdWJtb2R1bGUgY2hhbmdlLApAQCAtMzc2OCw4ICszNjc5LDcgQEAKIHdhcm5pbmcgYWJvdXQgbm90IGJlaW5nIGFibGUgc3dpdGNoIGZyb20gYSBkaXJ0eSBicmFuY2guCiAKIFtbbG93LWxldmVsLW9wZXJhdGlvbnNdXQotTG93LWxldmVsIEdpdCBvcGVyYXRpb25zCi09PT09PT09PT09PT09PT09PT09PT09PT0KKz09IExvdy1sZXZlbCBHaXQgb3BlcmF0aW9ucwogCiBNYW55IG9mIHRoZSBoaWdoZXItbGV2ZWwgY29tbWFuZHMgd2VyZSBvcmlnaW5hbGx5IGltcGxlbWVudGVkIGFzIHNoZWxsCiBzY3JpcHRzIHVzaW5nIGEgc21hbGxlciBjb3JlIG9mIGxvdy1sZXZlbCBHaXQgY29tbWFuZHMuICBUaGVzZSBjYW4gc3RpbGwKQEAgLTM3NzcsOCArMzY4Nyw3IEBACiB1bmRlcnN0YW5kIGl0cyBpbm5lciB3b3JraW5ncy4KIAogW1tvYmplY3QtbWFuaXB1bGF0aW9uXV0KLU9iamVjdCBhY2Nlc3MgYW5kIG1hbmlwdWxhdGlvbgotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCis9PT0gT2JqZWN0IGFjY2VzcyBhbmQgbWFuaXB1bGF0aW9uCiAKIFRoZSBsaW5rZ2l0OmdpdC1jYXQtZmlsZVsxXSBjb21tYW5kIGNhbiBzaG93IHRoZSBjb250ZW50cyBvZiBhbnkgb2JqZWN0LAogdGhvdWdoIHRoZSBoaWdoZXItbGV2ZWwgbGlua2dpdDpnaXQtc2hvd1sxXSBpcyB1c3VhbGx5IG1vcmUgdXNlZnVsLgpAQCAtMzc5NSw4ICszNzA0LDcgQEAKIHVzZSBsaW5rZ2l0OmdpdC10YWdbMV0gZm9yIGJvdGguCiAKIFtbdGhlLXdvcmtmbG93XV0KLVRoZSBXb3JrZmxvdwotLS0tLS0tLS0tLS0tCis9PT0gVGhlIFdvcmtmbG93CiAKIEhpZ2gtbGV2ZWwgb3BlcmF0aW9ucyBzdWNoIGFzIGxpbmtnaXQ6Z2l0LWNvbW1pdFsxXSBhbmQKIGxpbmtnaXQ6Z2l0LXJlc3RvcmVbMV0gd29yayBieSBtb3ZpbmcgZGF0YQpAQCAtMzgxMSw4ICszNzE5LDcgQEAKIGNvbWJpbmF0aW9uczoKIAogW1t3b3JraW5nLWRpcmVjdG9yeS10by1pbmRleF1dCi13b3JraW5nIGRpcmVjdG9yeSAtPiBpbmRleAotfn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn4KKz09PT0gd29ya2luZyBkaXJlY3RvcnkgLT4gaW5kZXgKIAogVGhlIGxpbmtnaXQ6Z2l0LXVwZGF0ZS1pbmRleFsxXSBjb21tYW5kIHVwZGF0ZXMgdGhlIGluZGV4IHdpdGgKIGluZm9ybWF0aW9uIGZyb20gdGhlIHdvcmtpbmcgZGlyZWN0b3J5LiAgWW91IGdlbmVyYWxseSB1cGRhdGUgdGhlCkBAIC0zODQ4LDggKzM3NTUsNyBAQAogbGlua2dpdDpnaXQtdXBkYXRlLWluZGV4WzFdLgogCiBbW2luZGV4LXRvLW9iamVjdC1kYXRhYmFzZV1dCi1pbmRleCAtPiBvYmplY3QgZGF0YWJhc2UKLX5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fgorPT09PSBpbmRleCAtPiBvYmplY3QgZGF0YWJhc2UKIAogWW91IHdyaXRlIHlvdXIgY3VycmVudCBpbmRleCBmaWxlIHRvIGEgInRyZWUiIG9iamVjdCB3aXRoIHRoZSBwcm9ncmFtCiAKQEAgLTM4NjQsOCArMzc3MCw3IEBACiBvdGhlciBkaXJlY3Rpb246CiAKIFtbb2JqZWN0LWRhdGFiYXNlLXRvLWluZGV4XV0KLW9iamVjdCBkYXRhYmFzZSAtPiBpbmRleAotfn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+Cis9PT09IG9iamVjdCBkYXRhYmFzZSAtPiBpbmRleAogCiBZb3UgcmVhZCBhICJ0cmVlIiBmaWxlIGZyb20gdGhlIG9iamVjdCBkYXRhYmFzZSwgYW5kIHVzZSB0aGF0IHRvCiBwb3B1bGF0ZSAoYW5kIG92ZXJ3cml0ZS0tZG9uJ3QgZG8gdGhpcyBpZiB5b3VyIGluZGV4IGNvbnRhaW5zIGFueQpAQCAtMzg4MSw4ICszNzg2LDcgQEAKIGRpcmVjdG9yeSBjb250ZW50cyBoYXZlIG5vdCBiZWVuIG1vZGlmaWVkLgogCiBbW2luZGV4LXRvLXdvcmtpbmctZGlyZWN0b3J5XV0KLWluZGV4IC0+IHdvcmtpbmcgZGlyZWN0b3J5Ci1+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fgorPT09PSBpbmRleCAtPiB3b3JraW5nIGRpcmVjdG9yeQogCiBZb3UgdXBkYXRlIHlvdXIgd29ya2luZyBkaXJlY3RvcnkgZnJvbSB0aGUgaW5kZXggYnkgImNoZWNraW5nIG91dCIKIGZpbGVzLiBUaGlzIGlzIG5vdCBhIHZlcnkgY29tbW9uIG9wZXJhdGlvbiwgc2luY2Ugbm9ybWFsbHkgeW91J2QganVzdApAQCAtMzkxMSw4ICszODE1LDcgQEAKIGZyb20gb25lIHJlcHJlc2VudGF0aW9uIHRvIHRoZSBvdGhlcjoKIAogW1t0eWluZy1pdC1hbGwtdG9nZXRoZXJdXQotVHlpbmcgaXQgYWxsIHRvZ2V0aGVyCi1+fn5+fn5+fn5+fn5+fn5+fn5+fn4KKz09PT0gVHlpbmcgaXQgYWxsIHRvZ2V0aGVyCiAKIFRvIGNvbW1pdCBhIHRyZWUgeW91IGhhdmUgaW5zdGFudGlhdGVkIHdpdGggYGdpdCB3cml0ZS10cmVlYCwgeW91J2QKIGNyZWF0ZSBhICJjb21taXQiIG9iamVjdCB0aGF0IHJlZmVycyB0byB0aGF0IHRyZWUgYW5kIHRoZSBoaXN0b3J5CkBAIC0zOTg2LDggKzM4ODksNyBAQAogCiAKIFtbZXhhbWluaW5nLXRoZS1kYXRhXV0KLUV4YW1pbmluZyB0aGUgZGF0YQotLS0tLS0tLS0tLS0tLS0tLS0tCis9PT0gRXhhbWluaW5nIHRoZSBkYXRhCiAKIFlvdSBjYW4gZXhhbWluZSB0aGUgZGF0YSByZXByZXNlbnRlZCBpbiB0aGUgb2JqZWN0IGRhdGFiYXNlIGFuZCB0aGUKIGluZGV4IHdpdGggdmFyaW91cyBoZWxwZXIgdG9vbHMuIEZvciBldmVyeSBvYmplY3QsIHlvdSBjYW4gdXNlCkBAIC00MDIyLDggKzM5MjQsNyBAQAogdG8gc2VlIHdoYXQgdGhlIHRvcCBjb21taXQgd2FzLgogCiBbW21lcmdpbmctbXVsdGlwbGUtdHJlZXNdXQotTWVyZ2luZyBtdWx0aXBsZSB0cmVlcwotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorPT09IE1lcmdpbmcgbXVsdGlwbGUgdHJlZXMKIAogR2l0IGNhbiBoZWxwIHlvdSBwZXJmb3JtIGEgdGhyZWUtd2F5IG1lcmdlLCB3aGljaCBjYW4gaW4gdHVybiBiZQogdXNlZCBmb3IgYSBtYW55LXdheSBtZXJnZSBieSByZXBlYXRpbmcgdGhlIG1lcmdlIHByb2NlZHVyZSBzZXZlcmFsCkBAIC00MDczLDggKzM5NzQsNyBAQAogCiAKIFtbbWVyZ2luZy1tdWx0aXBsZS10cmVlcy0yXV0KLU1lcmdpbmcgbXVsdGlwbGUgdHJlZXMsIGNvbnRpbnVlZAotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCis9PT0gTWVyZ2luZyBtdWx0aXBsZSB0cmVlcywgY29udGludWVkCiAKIFNhZGx5LCBtYW55IG1lcmdlcyBhcmVuJ3QgdHJpdmlhbC4gSWYgdGhlcmUgYXJlIGZpbGVzIHRoYXQgaGF2ZQogYmVlbiBhZGRlZCwgbW92ZWQgb3IgcmVtb3ZlZCwgb3IgaWYgYm90aCBicmFuY2hlcyBoYXZlIG1vZGlmaWVkIHRoZQpAQCAtNDE0NCwxNSArNDA0NCwxMyBAQAogYW5kIHRoYXQgaXMgd2hhdCBoaWdoZXIgbGV2ZWwgYGdpdCBtZXJnZSAtcyByZXNvbHZlYCBpcyBpbXBsZW1lbnRlZCB3aXRoLgogCiBbW2hhY2tpbmctZ2l0XV0KLUhhY2tpbmcgR2l0Ci09PT09PT09PT09PQorPT0gSGFja2luZyBHaXQKIAogVGhpcyBjaGFwdGVyIGNvdmVycyBpbnRlcm5hbCBkZXRhaWxzIG9mIHRoZSBHaXQgaW1wbGVtZW50YXRpb24gd2hpY2gKIHByb2JhYmx5IG9ubHkgR2l0IGRldmVsb3BlcnMgbmVlZCB0byB1bmRlcnN0YW5kLgogCiBbW29iamVjdC1kZXRhaWxzXV0KLU9iamVjdCBzdG9yYWdlIGZvcm1hdAotLS0tLS0tLS0tLS0tLS0tLS0tLS0tCis9PT0gT2JqZWN0IHN0b3JhZ2UgZm9ybWF0CiAKIEFsbCBvYmplY3RzIGhhdmUgYSBzdGF0aWNhbGx5IGRldGVybWluZWQgInR5cGUiIHdoaWNoIGlkZW50aWZpZXMgdGhlCiBmb3JtYXQgb2YgdGhlIG9iamVjdCAoaS5lLiBob3cgaXQgaXMgdXNlZCwgYW5kIGhvdyBpdCBjYW4gcmVmZXIgdG8gb3RoZXIKQEAgLTQxODIsOCArNDA4MCw3IEBACiB0byBqdXN0IHZlcmlmeWluZyB0aGVpciBzdXBlcmZpY2lhbCBjb25zaXN0ZW5jeSB0aHJvdWdoIHRoZSBoYXNoKS4KIAogW1tiaXJkdmlldy1vbi10aGUtc291cmNlLWNvZGVdXQotQSBiaXJkcy1leWUgdmlldyBvZiBHaXQncyBzb3VyY2UgY29kZQotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorPT09IEEgYmlyZHMtZXllIHZpZXcgb2YgR2l0J3Mgc291cmNlIGNvZGUKIAogSXQgaXMgbm90IGFsd2F5cyBlYXN5IGZvciBuZXcgZGV2ZWxvcGVycyB0byBmaW5kIHRoZWlyIHdheSB0aHJvdWdoIEdpdCdzCiBzb3VyY2UgY29kZS4gIFRoaXMgc2VjdGlvbiBnaXZlcyB5b3UgYSBsaXR0bGUgZ3VpZGFuY2UgdG8gc2hvdyB3aGVyZSB0bwpAQCAtNDM5MiwyNSArNDI4OSwyMiBAQAogaXRzZWxmIQogCiBbW2dsb3NzYXJ5XV0KLUdpdCBHbG9zc2FyeQotPT09PT09PT09PT09Cis9PSBHaXQgR2xvc3NhcnkKIAogW1tnaXQtZXhwbGFpbmVkXV0KLUdpdCBleHBsYWluZWQKLS0tLS0tLS0tLS0tLS0KKz09PSBHaXQgZXhwbGFpbmVkCiAKIGluY2x1ZGU6Omdsb3NzYXJ5LWNvbnRlbnQudHh0W10KIAogW1tnaXQtcXVpY2stc3RhcnRdXQotQXBwZW5kaXggQTogR2l0IFF1aWNrIFJlZmVyZW5jZQotPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQorW2FwcGVuZGl4XQorPT0gR2l0IFF1aWNrIFJlZmVyZW5jZQogCiBUaGlzIGlzIGEgcXVpY2sgc3VtbWFyeSBvZiB0aGUgbWFqb3IgY29tbWFuZHM7IHRoZSBwcmV2aW91cyBjaGFwdGVycwogZXhwbGFpbiBob3cgdGhlc2Ugd29yayBpbiBtb3JlIGRldGFpbC4KIAogW1txdWljay1jcmVhdGluZy1hLW5ldy1yZXBvc2l0b3J5XV0KLUNyZWF0aW5nIGEgbmV3IHJlcG9zaXRvcnkKLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKz09PSBDcmVhdGluZyBhIG5ldyByZXBvc2l0b3J5CiAKIEZyb20gYSB0YXJiYWxsOgogCkBAIC00NDMxLDggKzQzMjUsNyBAQAogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KIAogW1ttYW5hZ2luZy1icmFuY2hlc11dCi1NYW5hZ2luZyBicmFuY2hlcwotLS0tLS0tLS0tLS0tLS0tLS0KKz09PSBNYW5hZ2luZyBicmFuY2hlcwogCiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogJCBnaXQgYnJhbmNoCQkJIyBsaXN0IGFsbCBsb2NhbCBicmFuY2hlcyBpbiB0aGlzIHJlcG8KQEAgLTQ0OTYsOCArNDM4OSw3IEBACiAKIAogW1tleHBsb3JpbmctaGlzdG9yeV1dCi1FeHBsb3JpbmcgaGlzdG9yeQotLS0tLS0tLS0tLS0tLS0tLS0KKz09PSBFeHBsb3JpbmcgaGlzdG9yeQogCiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogJCBnaXRrCQkJICAgICMgdmlzdWFsaXplIGFuZCBicm93c2UgaGlzdG9yeQpAQCAtNDUzMiw4ICs0NDI0LDcgQEAKIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAKIFtbbWFraW5nLWNoYW5nZXNdXQotTWFraW5nIGNoYW5nZXMKLS0tLS0tLS0tLS0tLS0tCis9PT0gTWFraW5nIGNoYW5nZXMKIAogTWFrZSBzdXJlIEdpdCBrbm93cyB3aG8gdG8gYmxhbWU6CiAKQEAgLTQ1NjMsOCArNDQ1NCw3IEBACiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogCiBbW21lcmdpbmddXQotTWVyZ2luZwotLS0tLS0tLQorPT09IE1lcmdpbmcKIAogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KICQgZ2l0IG1lcmdlIHRlc3QgICAjIG1lcmdlIGJyYW5jaCAidGVzdCIgaW50byB0aGUgY3VycmVudCBicmFuY2gKQEAgLTQ1NzQsOCArNDQ2NCw3IEBACiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogCiBbW3NoYXJpbmcteW91ci1jaGFuZ2VzXV0KLVNoYXJpbmcgeW91ciBjaGFuZ2VzCi0tLS0tLS0tLS0tLS0tLS0tLS0tLQorPT09IFNoYXJpbmcgeW91ciBjaGFuZ2VzCiAKIEltcG9ydGluZyBvciBleHBvcnRpbmcgcGF0Y2hlczoKIApAQCAtNDYyMCw4ICs0NTA5LDcgQEAKIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAKIFtbcmVwb3NpdG9yeS1tYWludGVuYW5jZV1dCi1SZXBvc2l0b3J5IG1haW50ZW5hbmNlCi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCis9PT0gUmVwb3NpdG9yeSBtYWludGVuYW5jZQogCiBDaGVjayBmb3IgY29ycnVwdGlvbjoKIApAQCAtNDYzNywxMiArNDUyNSwxMSBAQAogCiAKIFtbdG9kb11dCi1BcHBlbmRpeCBCOiBOb3RlcyBhbmQgdG9kbyBsaXN0IGZvciB0aGlzIG1hbnVhbAotPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KK1thcHBlbmRpeF0KKz09IE5vdGVzIGFuZCB0b2RvIGxpc3QgZm9yIHRoaXMgbWFudWFsCiAKIFtbdG9kby1saXN0XV0KLVRvZG8gbGlzdAotLS0tLS0tLS0tCis9PT0gVG9kbyBsaXN0CiAKIFRoaXMgaXMgYSB3b3JrIGluIHByb2dyZXNzLgogCmRpZmYgLS1naXQgYS9HSVQtVkVSU0lPTi1HRU4gYi9HSVQtVkVSU0lPTi1HRU4KaW5kZXggYTE1MzlhNy4uMjJlOGQ4MyAxMDA3NTUKLS0tIGEvR0lULVZFUlNJT04tR0VOCisrKyBiL0dJVC1WRVJTSU9OLUdFTgpAQCAtMSw3ICsxLDcgQEAKICMhL2Jpbi9zaAogCiBHVkY9R0lULVZFUlNJT04tRklMRQotREVGX1ZFUj12Mi4yMy4wCitERUZfVkVSPXYyLjI0LkdJVAogCiBMRj0nCiAnCmRpZmYgLS1naXQgYS9JTlNUQUxMIGIvSU5TVEFMTAppbmRleCBjMzkwMDZlLi4yMmMzNjRmIDEwMDY0NAotLS0gYS9JTlNUQUxMCisrKyBiL0lOU1RBTEwKQEAgLTEwOSwxNSArMTA5LDE1IEBACiAKICAtIEdpdCBpcyByZWFzb25hYmx5IHNlbGYtc3VmZmljaWVudCwgYnV0IGRvZXMgZGVwZW5kIG9uIGEgZmV3IGV4dGVybmFsCiAgICBwcm9ncmFtcyBhbmQgbGlicmFyaWVzLiAgR2l0IGNhbiBiZSB1c2VkIHdpdGhvdXQgbW9zdCBvZiB0aGVtIGJ5IGFkZGluZwotICAgdGhlIGFwcHJvcmlhdGUgIk5PXzxMSUJSQVJZPj1ZZXNQbGVhc2UiIHRvIHRoZSBtYWtlIGNvbW1hbmQgbGluZSBvcgorICAgdGhlIGFwcHJvcHJpYXRlICJOT188TElCUkFSWT49WWVzUGxlYXNlIiB0byB0aGUgbWFrZSBjb21tYW5kIGxpbmUgb3IKICAgIGNvbmZpZy5tYWsgZmlsZS4KIAogCS0gInpsaWIiLCB0aGUgY29tcHJlc3Npb24gbGlicmFyeS4gR2l0IHdvbid0IGJ1aWxkIHdpdGhvdXQgaXQuCiAKIAktICJzc2giIGlzIHVzZWQgdG8gcHVzaCBhbmQgcHVsbCBvdmVyIHRoZSBuZXQuCiAKLQktIEEgUE9TSVgtY29tcGxpYW50IHNoZWxsIGlzIHJlcXVpcmVkIHRvIHJ1biBtYW55IHNjcmlwdHMgbmVlZGVkCi0JICBmb3IgZXZlcnlkYXkgdXNlIChlLmcuICJiaXNlY3QiLCAicHVsbCIpLgorCS0gQSBQT1NJWC1jb21wbGlhbnQgc2hlbGwgaXMgcmVxdWlyZWQgdG8gcnVuIHNvbWUgc2NyaXB0cyBuZWVkZWQKKwkgIGZvciBldmVyeWRheSB1c2UgKGUuZy4gImJpc2VjdCIsICJyZXF1ZXN0LXB1bGwiKS4KIAogCS0gIlBlcmwiIHZlcnNpb24gNS44IG9yIGxhdGVyIGlzIG5lZWRlZCB0byB1c2Ugc29tZSBvZiB0aGUKIAkgIGZlYXR1cmVzIChlLmcuIHByZXBhcmluZyBhIHBhcnRpYWwgY29tbWl0IHVzaW5nICJnaXQgYWRkIC1pLy1wIiwKZGlmZiAtLWdpdCBhL01ha2VmaWxlIGIvTWFrZWZpbGUKaW5kZXggZjkyNTUzNC4uYjdkNzM3NCAxMDA2NDQKLS0tIGEvTWFrZWZpbGUKKysrIGIvTWFrZWZpbGUKQEAgLTM0LDEzICszNCw4IEBACiAjIGxpYnJhcnkuIFN1cHBvcnQgZm9yIHZlcnNpb24gMSB3aWxsIGxpa2VseSBiZSByZW1vdmVkIGluIHNvbWUgZnV0dXJlCiAjIHJlbGVhc2Ugb2YgR2l0LCBhcyB1cHN0cmVhbSBoYXMgYWxsIGJ1dCBhYmFuZG9uZWQgaXQuCiAjCi0jIFdoZW4gdXNpbmcgVVNFX0xJQlBDUkUxLCBkZWZpbmUgTk9fTElCUENSRTFfSklUIGlmIHRoZSBQQ1JFIHYxCi0jIGxpYnJhcnkgaXMgY29tcGlsZWQgd2l0aG91dCAtLWVuYWJsZS1qaXQuIFdlIHdpbGwgYXV0by1kZXRlY3QKLSMgd2hldGhlciB0aGUgdmVyc2lvbiBvZiB0aGUgUENSRSB2MSBsaWJyYXJ5IGluIHVzZSBoYXMgSklUIHN1cHBvcnQgYXQKLSMgYWxsLCBidXQgd2UgdW5mb3J0dW5hdGVseSBjYW4ndCBhdXRvLWRldGVjdCB3aGV0aGVyIEpJVCBzdXBwb3J0Ci0jIGhhc24ndCBiZWVuIGNvbXBpbGVkIGluIGluIGFuIG90aGVyd2lzZSBKSVQtc3VwcG9ydGluZyB2ZXJzaW9uLiBJZgotIyB5b3UgaGF2ZSBsaW5rLXRpbWUgZXJyb3JzIGFib3V0IGEgbWlzc2luZyBgcGNyZV9qaXRfZXhlY2AgZGVmaW5lCi0jIHRoaXMsIG9yIHJlY29tcGlsZSBQQ1JFIHYxIHdpdGggLS1lbmFibGUtaml0LgorIyBXaGVuIHVzaW5nIFVTRV9MSUJQQ1JFMSwgZGVmaW5lIE5PX0xJQlBDUkUxX0pJVCBpZiB5b3Ugd2FudCB0bworIyBkaXNhYmxlIEpJVCBldmVuIGlmIHN1cHBvcnRlZCBieSB5b3VyIGxpYnJhcnkuCiAjCiAjIERlZmluZSBMSUJQQ1JFRElSPS9mb28vYmFyIGlmIHlvdXIgUENSRSBoZWFkZXIgYW5kIGxpYnJhcnkgZmlsZXMgYXJlCiAjIGluIC9mb28vYmFyL2luY2x1ZGUgYW5kIC9mb28vYmFyL2xpYiBkaXJlY3Rvcmllcy4gV2hpY2ggdmVyc2lvbiBvZgpAQCAtNTk4LDYgKzU5Myw3IEBACiBTQ1JJUFRfTElCID0KIFRFU1RfQlVJTFRJTlNfT0JKUyA9CiBURVNUX1BST0dSQU1TX05FRURfWCA9CitUSElSRF9QQVJUWV9TT1VSQ0VTID0KIAogIyBIYXZpbmcgdGhpcyB2YXJpYWJsZSBpbiB5b3VyIGVudmlyb25tZW50IHdvdWxkIGJyZWFrIHBpcGVsaW5lcyBiZWNhdXNlCiAjIHlvdSBjYXVzZSAiY2QiIHRvIGVjaG8gaXRzIGRlc3RpbmF0aW9uIHRvIHN0ZG91dC4gIEl0IGNhbiBhbHNvIHRha2UKQEAgLTcyOCw4ICs3MjQsMTAgQEAKIFRFU1RfQlVJTFRJTlNfT0JKUyArPSB0ZXN0LXBhdGgtdXRpbHMubwogVEVTVF9CVUlMVElOU19PQkpTICs9IHRlc3QtcGt0LWxpbmUubwogVEVTVF9CVUlMVElOU19PQkpTICs9IHRlc3QtcHJpby1xdWV1ZS5vCitURVNUX0JVSUxUSU5TX09CSlMgKz0gdGVzdC1wcm9ncmVzcy5vCiBURVNUX0JVSUxUSU5TX09CSlMgKz0gdGVzdC1yZWFjaC5vCiBURVNUX0JVSUxUSU5TX09CSlMgKz0gdGVzdC1yZWFkLWNhY2hlLm8KK1RFU1RfQlVJTFRJTlNfT0JKUyArPSB0ZXN0LXJlYWQtZ3JhcGgubwogVEVTVF9CVUlMVElOU19PQkpTICs9IHRlc3QtcmVhZC1taWR4Lm8KIFRFU1RfQlVJTFRJTlNfT0JKUyArPSB0ZXN0LXJlZi1zdG9yZS5vCiBURVNUX0JVSUxUSU5TX09CSlMgKz0gdGVzdC1yZWdleC5vCkBAIC04MTgsMTQgKzgxNiwxNSBAQAogCiBHRU5FUkFURURfSCArPSBjb21tYW5kLWxpc3QuaAogCi1MSUJfSCA6PSAkKHNvcnQgJChzaGVsbCBnaXQgbHMtZmlsZXMgJyouaCcgJzohdC8nICc6IURvY3VtZW50YXRpb24vJyAyPi9kZXYvbnVsbCB8fCBcCitMSUJfSCA6PSAkKHNvcnQgJChwYXRzdWJzdCAuLyUsJSwkKHNoZWxsIGdpdCBscy1maWxlcyAnKi5oJyAnOiF0LycgJzohRG9jdW1lbnRhdGlvbi8nIDI+L2Rldi9udWxsIHx8IFwKIAkkKEZJTkQpIC4gXAogCS1uYW1lIC5naXQgLXBydW5lIC1vIFwKIAktbmFtZSB0IC1wcnVuZSAtbyBcCiAJLW5hbWUgRG9jdW1lbnRhdGlvbiAtcHJ1bmUgLW8gXAotCS1uYW1lICcqLmgnIC1wcmludCkpCisJLW5hbWUgJyouaCcgLXByaW50KSkpCiAKIExJQl9PQkpTICs9IGFic3BhdGgubworTElCX09CSlMgKz0gYWRkLWludGVyYWN0aXZlLm8KIExJQl9PQkpTICs9IGFkdmljZS5vCiBMSUJfT0JKUyArPSBhbGlhcy5vCiBMSUJfT0JKUyArPSBhbGxvYy5vCkBAIC04ODQsNyArODgzLDYgQEAKIExJQl9PQkpTICs9IGV3YWgvZXdhaF9ybHcubwogTElCX09CSlMgKz0gZXhlYy1jbWQubwogTElCX09CSlMgKz0gZmV0Y2gtbmVnb3RpYXRvci5vCi1MSUJfT0JKUyArPSBmZXRjaC1vYmplY3QubwogTElCX09CSlMgKz0gZmV0Y2gtcGFjay5vCiBMSUJfT0JKUyArPSBmc2NrLm8KIExJQl9PQkpTICs9IGZzbW9uaXRvci5vCkBAIC05NDgsNiArOTQ2LDcgQEAKIExJQl9PQkpTICs9IHByZXR0eS5vCiBMSUJfT0JKUyArPSBwcmlvLXF1ZXVlLm8KIExJQl9PQkpTICs9IHByb2dyZXNzLm8KK0xJQl9PQkpTICs9IHByb21pc29yLXJlbW90ZS5vCiBMSUJfT0JKUyArPSBwcm9tcHQubwogTElCX09CSlMgKz0gcHJvdG9jb2wubwogTElCX09CSlMgKz0gcXVvdGUubwpAQCAtOTY1LDYgKzk2NCw3IEBACiBMSUJfT0JKUyArPSByZWYtZmlsdGVyLm8KIExJQl9PQkpTICs9IHJlbW90ZS5vCiBMSUJfT0JKUyArPSByZXBsYWNlLW9iamVjdC5vCitMSUJfT0JKUyArPSByZXBvLXNldHRpbmdzLm8KIExJQl9PQkpTICs9IHJlcG9zaXRvcnkubwogTElCX09CSlMgKz0gcmVyZXJlLm8KIExJQl9PQkpTICs9IHJlc29sdmUtdW5kby5vCkBAIC05ODMsNiArOTgzLDcgQEAKIExJQl9PQkpTICs9IHNpZGViYW5kLm8KIExJQl9PQkpTICs9IHNpZ2NoYWluLm8KIExJQl9PQkpTICs9IHNwbGl0LWluZGV4Lm8KK0xJQl9PQkpTICs9IHN0YWJsZS1xc29ydC5vCiBMSUJfT0JKUyArPSBzdHJidWYubwogTElCX09CSlMgKz0gc3RyZWFtaW5nLm8KIExJQl9PQkpTICs9IHN0cmluZy1saXN0Lm8KQEAgLTExNDUsNiArMTE0NiwyMCBAQAogQlVJTFRJTl9PQkpTICs9IGJ1aWx0aW4vd29ya3RyZWUubwogQlVJTFRJTl9PQkpTICs9IGJ1aWx0aW4vd3JpdGUtdHJlZS5vCiAKKyMgVEhJUkRfUEFSVFlfU09VUkNFUyBpcyBhIGxpc3Qgb2YgcGF0dGVybnMgY29tcGF0aWJsZSB3aXRoIHRoZQorIyAkKGZpbHRlcikgYW5kICQoZmlsdGVyLW91dCkgZmFtaWx5IG9mIGZ1bmN0aW9ucy4gVGhleSBzcGVjaWZ5IHNvdXJjZQorIyBmaWxlcyB3aGljaCBhcmUgdGFrZW4gZnJvbSBzb21lIHRoaXJkLXBhcnR5IHNvdXJjZSB3aGVyZSB3ZSB3YW50IHRvIGJlCisjIGxlc3Mgc3RyaWN0IGFib3V0IGlzc3VlcyBzdWNoIGFzIGNvZGluZyBzdHlsZSBzbyB3ZSBkb24ndCBkaXZlcmdlIGZyb20KKyMgdXBzdHJlYW0gdW5uZWNlc3NhcmlseSAobWFraW5nIG1lcmdpbmcgaW4gZnV0dXJlIGNoYW5nZXMgZWFzaWVyKS4KK1RISVJEX1BBUlRZX1NPVVJDRVMgKz0gY29tcGF0L2luZXRfbnRvcC5jCitUSElSRF9QQVJUWV9TT1VSQ0VTICs9IGNvbXBhdC9pbmV0X3B0b24uYworVEhJUkRfUEFSVFlfU09VUkNFUyArPSBjb21wYXQvbmVkbWFsbG9jLyUKK1RISVJEX1BBUlRZX1NPVVJDRVMgKz0gY29tcGF0L29ic3RhY2suJQorVEhJUkRfUEFSVFlfU09VUkNFUyArPSBjb21wYXQvcG9sbC8lCitUSElSRF9QQVJUWV9TT1VSQ0VTICs9IGNvbXBhdC9yZWdleC8lCitUSElSRF9QQVJUWV9TT1VSQ0VTICs9IHNoYTFjb2xsaXNpb25kZXRlY3Rpb24vJQorVEhJUkRfUEFSVFlfU09VUkNFUyArPSBzaGExZGMvJQorCiBHSVRMSUJTID0gY29tbW9uLW1haW4ubyAkKExJQl9GSUxFKSAkKFhESUZGX0xJQikKIEVYVExJQlMgPQogCkBAIC0xNzE0LDcgKzE3MjksNiBAQAogZW5kaWYKIGlmZGVmIElOVEVSTkFMX1FTT1JUCiAJQ09NUEFUX0NGTEFHUyArPSAtRElOVEVSTkFMX1FTT1JUCi0JQ09NUEFUX09CSlMgKz0gY29tcGF0L3Fzb3J0Lm8KIGVuZGlmCiBpZmRlZiBIQVZFX0lTT19RU09SVF9TCiAJQ09NUEFUX0NGTEFHUyArPSAtREhBVkVfSVNPX1FTT1JUX1MKQEAgLTE4NzEsOCArMTg4NSw5IEBACiAJUVVJRVRfTVNHRk1UICAgPSBAZWNobyAnICAgJyBNU0dGTVQgJEA7CiAJUVVJRVRfR0NPViAgICAgPSBAZWNobyAnICAgJyBHQ09WICRAOwogCVFVSUVUX1NQICAgICAgID0gQGVjaG8gJyAgICcgU1AgJDw7Ci0JUVVJRVRfSERSICAgICAgPSBAZWNobyAnICAgJyBIRFIgJDw7CisJUVVJRVRfSERSICAgICAgPSBAZWNobyAnICAgJyBIRFIgJCg8OmhjYz1oKTsKIAlRVUlFVF9SQyAgICAgICA9IEBlY2hvICcgICAnIFJDICRAOworCVFVSUVUX1NQQVRDSCAgID0gQGVjaG8gJyAgICcgU1BBVENIICQ8OwogCVFVSUVUX1NVQkRJUjAgID0gK0BzdWJkaXI9CiAJUVVJRVRfU1VCRElSMSAgPSA7JChOT19TVUJESVIpIGVjaG8gJyAgICcgU1VCRElSICQkc3ViZGlyOyBcCiAJCQkgJChNQUtFKSAkKFBSSU5UX0RJUikgLUMgJCRzdWJkaXIKQEAgLTI1OTksNiArMjYxNCw3IEBACiAJCS1vIFwoIC1uYW1lICd0cmFzaConIC10eXBlIGQgLXBydW5lIFwpIFwKIAkJLW8gXCggLW5hbWUgJyouW2hjU10nIC10eXBlIGYgLXByaW50IFwpIFwKIAkJLW8gXCggLW5hbWUgJyouc2gnIC10eXBlIGYgLXByaW50IFwpIFwKKwkJfCBzZWQgLWUgJ3N8XlwuL3x8JyBcCiAJKQogCiAkKEVUQUdTX1RBUkdFVCk6IEZPUkNFCkBAIC0yNzY4LDExICsyNzg0LDE2IEBACiBpZm5kZWYgR0NSWVBUX1NIQTI1NgogCUVYQ0VQVF9IRFJTICs9IHNoYTI1Ni9nY3J5cHQuaAogZW5kaWYKLUNIS19IRFJTID0gJChmaWx0ZXItb3V0ICQoRVhDRVBUX0hEUlMpLCQocGF0c3Vic3QgLi8lLCUsJChMSUJfSCkpKQorQ0hLX0hEUlMgPSAkKGZpbHRlci1vdXQgJChFWENFUFRfSERSUyksJChMSUJfSCkpCiBIQ08gPSAkKHBhdHN1YnN0ICUuaCwlLmhjbywkKENIS19IRFJTKSkKK0hDQyA9ICQoSENPOmhjbz1oY2MpCiAKLSQoSENPKTogJS5oY286ICUuaCBGT1JDRQotCSQoUVVJRVRfSERSKSQoQ0MpIC1pbmNsdWRlIGdpdC1jb21wYXQtdXRpbC5oIC1JLiAtbyAvZGV2L251bGwgLWMgLXhjICQ8CislLmhjYzogJS5oCisJQGVjaG8gJyNpbmNsdWRlICJnaXQtY29tcGF0LXV0aWwuaCInID4kQAorCUBlY2hvICcjaW5jbHVkZSAiJDwiJyA+PiRACisKKyQoSENPKTogJS5oY286ICUuaGNjIEZPUkNFCisJJChRVUlFVF9IRFIpJChDQykgJChBTExfQ0ZMQUdTKSAtbyAvZGV2L251bGwgLWMgLXhjICQ8CiAKIC5QSE9OWTogaGRyLWNoZWNrICQoSENPKQogaGRyLWNoZWNrOiAkKEhDTykKQEAgLTI3OTEsMTUgKzI4MTIsMTEgQEAKIAkJZXhpdCAxOyBcCiAJZmkKIAotQ19TT1VSQ0VTID0gJChwYXRzdWJzdCAlLm8sJS5jLCQoQ19PQkopKQotaWZkZWYgRENfU0hBMV9TVUJNT0RVTEUKLUNPQ0NJX1NPVVJDRVMgPSAkKGZpbHRlci1vdXQgc2hhMWNvbGxpc2lvbmRldGVjdGlvbi8lLCQoQ19TT1VSQ0VTKSkKLWVsc2UKLUNPQ0NJX1NPVVJDRVMgPSAkKGZpbHRlci1vdXQgc2hhMWRjLyUsJChDX1NPVVJDRVMpKQotZW5kaWYKK0ZPVU5EX0NfU09VUkNFUyA9ICQoZmlsdGVyICUuYywkKHNoZWxsICQoRklORF9TT1VSQ0VfRklMRVMpKSkKK0NPQ0NJX1NPVVJDRVMgPSAkKGZpbHRlci1vdXQgJChUSElSRF9QQVJUWV9TT1VSQ0VTKSwkKEZPVU5EX0NfU09VUkNFUykpCiAKICUuY29jY2kucGF0Y2g6ICUuY29jY2kgJChDT0NDSV9TT1VSQ0VTKQotCUBlY2hvICcgICAgJyBTUEFUQ0ggJDw7IFwKKwkkKFFVSUVUX1NQQVRDSCkgXAogCWlmIHRlc3QgJChTUEFUQ0hfQkFUQ0hfU0laRSkgPSAwOyB0aGVuIFwKIAkJbGltaXQ9OyBcCiAJZWxzZSBcCkBAIC0zMDI4LDYgKzMwNDUsMTAgQEAKIAlAZmFsc2UKIC5QSE9OWTogcnBtCiAKK2lmbmVxICgkKElOQ0xVREVfRExMU19JTl9BUlRJRkFDVFMpLCkKK09USEVSX1BST0dSQU1TICs9ICQoc2hlbGwgZWNobyAqLmRsbCB0L2hlbHBlci8qLmRsbCkKK2VuZGlmCisKIGFydGlmYWN0cy10YXI6OiAkKEFMTF9QUk9HUkFNUykgJChTQ1JJUFRfTElCKSAkKEJVSUxUX0lOUykgJChPVEhFUl9QUk9HUkFNUykgXAogCQlHSVQtQlVJTEQtT1BUSU9OUyAkKFRFU1RfUFJPR1JBTVMpICQodGVzdF9iaW5kaXJfcHJvZ3JhbXMpIFwKIAkJJChNT0ZJTEVTKQpAQCAtMzA4MSw2ICszMTAyLDcgQEAKIAkkKFJNKSAkKEFMTF9QUk9HUkFNUykgJChTQ1JJUFRfTElCKSAkKEJVSUxUX0lOUykgZ2l0JFgKIAkkKFJNKSAkKFRFU1RfUFJPR1JBTVMpCiAJJChSTSkgJChGVVpaX1BST0dSQU1TKQorCSQoUk0pICQoSENDKQogCSQoUk0pIC1yIGJpbi13cmFwcGVycyAkKGRlcF9kaXJzKQogCSQoUk0pIC1yIHBvL2J1aWxkLwogCSQoUk0pICoucHljICoucHlvICovKi5weWMgKi8qLnB5byBjb21tYW5kLWxpc3QuaCAkKEVUQUdTX1RBUkdFVCkgdGFncyBjc2NvcGUqCmRpZmYgLS1naXQgYS9SZWxOb3RlcyBiL1JlbE5vdGVzCmluZGV4IDI0OGQxMzcuLjA5MWRkMDIgMTIwMDAwCi0tLSBhL1JlbE5vdGVzCisrKyBiL1JlbE5vdGVzCkBAIC0xICsxIEBACi1Eb2N1bWVudGF0aW9uL1JlbE5vdGVzLzIuMjMuMC50eHQKXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCitEb2N1bWVudGF0aW9uL1JlbE5vdGVzLzIuMjUuMC50eHQKXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9hZGQtaW50ZXJhY3RpdmUuYyBiL2FkZC1pbnRlcmFjdGl2ZS5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmQ2Y2I5OGMKLS0tIC9kZXYvbnVsbAorKysgYi9hZGQtaW50ZXJhY3RpdmUuYwpAQCAtMCwwICsxLDY1MiBAQAorI2luY2x1ZGUgImNhY2hlLmgiCisjaW5jbHVkZSAiYWRkLWludGVyYWN0aXZlLmgiCisjaW5jbHVkZSAiY29sb3IuaCIKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJkaWZmY29yZS5oIgorI2luY2x1ZGUgInJldmlzaW9uLmgiCisjaW5jbHVkZSAicmVmcy5oIgorI2luY2x1ZGUgInN0cmluZy1saXN0LmgiCisKK3N0cnVjdCBhZGRfaV9zdGF0ZSB7CisJc3RydWN0IHJlcG9zaXRvcnkgKnI7CisJaW50IHVzZV9jb2xvcjsKKwljaGFyIGhlYWRlcl9jb2xvcltDT0xPUl9NQVhMRU5dOworCWNoYXIgaGVscF9jb2xvcltDT0xPUl9NQVhMRU5dOworCWNoYXIgcHJvbXB0X2NvbG9yW0NPTE9SX01BWExFTl07CisJY2hhciBlcnJvcl9jb2xvcltDT0xPUl9NQVhMRU5dOworCWNoYXIgcmVzZXRfY29sb3JbQ09MT1JfTUFYTEVOXTsKK307CisKK3N0YXRpYyB2b2lkIGluaXRfY29sb3Ioc3RydWN0IHJlcG9zaXRvcnkgKnIsIHN0cnVjdCBhZGRfaV9zdGF0ZSAqcywKKwkJICAgICAgIGNvbnN0IGNoYXIgKnNsb3RfbmFtZSwgY2hhciAqZHN0LAorCQkgICAgICAgY29uc3QgY2hhciAqZGVmYXVsdF9jb2xvcikKK3sKKwljaGFyICprZXkgPSB4c3RyZm10KCJjb2xvci5pbnRlcmFjdGl2ZS4lcyIsIHNsb3RfbmFtZSk7CisJY29uc3QgY2hhciAqdmFsdWU7CisKKwlpZiAoIXMtPnVzZV9jb2xvcikKKwkJZHN0WzBdID0gJ1wwJzsKKwllbHNlIGlmIChyZXBvX2NvbmZpZ19nZXRfdmFsdWUociwga2V5LCAmdmFsdWUpIHx8CisJCSBjb2xvcl9wYXJzZSh2YWx1ZSwgZHN0KSkKKwkJc3RybGNweShkc3QsIGRlZmF1bHRfY29sb3IsIENPTE9SX01BWExFTik7CisKKwlmcmVlKGtleSk7Cit9CisKK3N0YXRpYyB2b2lkIGluaXRfYWRkX2lfc3RhdGUoc3RydWN0IGFkZF9pX3N0YXRlICpzLCBzdHJ1Y3QgcmVwb3NpdG9yeSAqcikKK3sKKwljb25zdCBjaGFyICp2YWx1ZTsKKworCXMtPnIgPSByOworCisJaWYgKHJlcG9fY29uZmlnX2dldF92YWx1ZShyLCAiY29sb3IuaW50ZXJhY3RpdmUiLCAmdmFsdWUpKQorCQlzLT51c2VfY29sb3IgPSAtMTsKKwllbHNlCisJCXMtPnVzZV9jb2xvciA9CisJCQlnaXRfY29uZmlnX2NvbG9yYm9vbCgiY29sb3IuaW50ZXJhY3RpdmUiLCB2YWx1ZSk7CisJcy0+dXNlX2NvbG9yID0gd2FudF9jb2xvcihzLT51c2VfY29sb3IpOworCisJaW5pdF9jb2xvcihyLCBzLCAiaGVhZGVyIiwgcy0+aGVhZGVyX2NvbG9yLCBHSVRfQ09MT1JfQk9MRCk7CisJaW5pdF9jb2xvcihyLCBzLCAiaGVscCIsIHMtPmhlbHBfY29sb3IsIEdJVF9DT0xPUl9CT0xEX1JFRCk7CisJaW5pdF9jb2xvcihyLCBzLCAicHJvbXB0Iiwgcy0+cHJvbXB0X2NvbG9yLCBHSVRfQ09MT1JfQk9MRF9CTFVFKTsKKwlpbml0X2NvbG9yKHIsIHMsICJlcnJvciIsIHMtPmVycm9yX2NvbG9yLCBHSVRfQ09MT1JfQk9MRF9SRUQpOworCWluaXRfY29sb3IociwgcywgInJlc2V0Iiwgcy0+cmVzZXRfY29sb3IsIEdJVF9DT0xPUl9SRVNFVCk7Cit9CisKKy8qCisgKiBBICJwcmVmaXggaXRlbSBsaXN0IiBpcyBhIGxpc3Qgb2YgaXRlbXMgdGhhdCBhcmUgaWRlbnRpZmllZCBieSBhIHN0cmluZywgYW5kCisgKiBhIHVuaXF1ZSBwcmVmaXggKGlmIGFueSkgaXMgZGV0ZXJtaW5lZCBmb3IgZWFjaCBpdGVtLgorICoKKyAqIEl0IGlzIGltcGxlbWVudGVkIGluIHRoZSBmb3JtIG9mIGEgcGFpciBvZiBgc3RyaW5nX2xpc3RgcywgdGhlIGZpcnN0IG9uZQorICogZHVwbGljYXRpbmcgdGhlIHN0cmluZ3MsIHdpdGggdGhlIGB1dGlsYCBmaWVsZCBwb2ludGluZyBhdCBhIHN0cnVjdHVyZSB3aG9zZQorICogZmlyc3QgZmllbGQgbXVzdCBiZSBgc2l6ZV90IHByZWZpeF9sZW5ndGhgLgorICoKKyAqIFRoYXQgYHByZWZpeF9sZW5ndGhgIGZpZWxkIHdpbGwgYmUgY29tcHV0ZWQgYnkgYGZpbmRfdW5pcXVlX3ByZWZpeGVzKClgOyBJdAorICogd2lsbCBiZSBzZXQgdG8gemVybyBpZiBubyB2YWxpZCwgdW5pcXVlIHByZWZpeCBjb3VsZCBiZSBmb3VuZC4KKyAqCisgKiBUaGUgc2Vjb25kIGBzdHJpbmdfbGlzdGAgaXMgY2FsbGVkIGBzb3J0ZWRgIGFuZCBkb2VzIF9ub3RfIGR1cGxpY2F0ZSB0aGUKKyAqIHN0cmluZ3MgYnV0IHNpbXBseSByZXVzZXMgdGhlIGZpcnN0IG9uZSdzLCB3aXRoIHRoZSBgdXRpbGAgZmllbGQgcG9pbnRpbmcgYXQKKyAqIHRoZSBgc3RyaW5nX2l0ZW1fbGlzdGAgb2YgdGhlIGZpcnN0IGBzdHJpbmdfbGlzdGAuIEl0ICB3aWxsIGJlIHBvcHVsYXRlZCBhbmQKKyAqIHNvcnRlZCBieSBgZmluZF91bmlxdWVfcHJlZml4ZXMoKWAuCisgKi8KK3N0cnVjdCBwcmVmaXhfaXRlbV9saXN0IHsKKwlzdHJ1Y3Qgc3RyaW5nX2xpc3QgaXRlbXM7CisJc3RydWN0IHN0cmluZ19saXN0IHNvcnRlZDsKKwlzaXplX3QgbWluX2xlbmd0aCwgbWF4X2xlbmd0aDsKK307CisjZGVmaW5lIFBSRUZJWF9JVEVNX0xJU1RfSU5JVCBcCisJeyBTVFJJTkdfTElTVF9JTklUX0RVUCwgU1RSSU5HX0xJU1RfSU5JVF9OT0RVUCwgMSwgNCB9CisKK3N0YXRpYyB2b2lkIHByZWZpeF9pdGVtX2xpc3RfY2xlYXIoc3RydWN0IHByZWZpeF9pdGVtX2xpc3QgKmxpc3QpCit7CisJc3RyaW5nX2xpc3RfY2xlYXIoJmxpc3QtPml0ZW1zLCAxKTsKKwlzdHJpbmdfbGlzdF9jbGVhcigmbGlzdC0+c29ydGVkLCAwKTsKK30KKworc3RhdGljIHZvaWQgZXh0ZW5kX3ByZWZpeF9sZW5ndGgoc3RydWN0IHN0cmluZ19saXN0X2l0ZW0gKnAsCisJCQkJIGNvbnN0IGNoYXIgKm90aGVyX3N0cmluZywgc2l6ZV90IG1heF9sZW5ndGgpCit7CisJc2l6ZV90ICpsZW4gPSBwLT51dGlsOworCisJaWYgKCEqbGVuIHx8IG1lbWNtcChwLT5zdHJpbmcsIG90aGVyX3N0cmluZywgKmxlbikpCisJCXJldHVybjsKKworCWZvciAoOzspIHsKKwkJY2hhciBjID0gcC0+c3RyaW5nWypsZW5dOworCisJCS8qCisJCSAqIElzIGBwYCBhIHN0cmljdCBwcmVmaXggb2YgYG90aGVyYD8gT3IgaGF2ZSB3ZSBleGhhdXN0ZWQgdGhlCisJCSAqIG1heGltYWwgbGVuZ3RoIG9mIHRoZSBwcmVmaXg/IE9yIGlzIHRoZSBjdXJyZW50IGNoYXJhY3RlciBhCisJCSAqIG11bHRpLWJ5dGUgVVRGLTggb25lPyBJZiBzbywgdGhlcmUgaXMgbm8gdmFsaWQsIHVuaXF1ZQorCQkgKiBwcmVmaXguCisJCSAqLworCQlpZiAoIWMgfHwgKysqbGVuID4gbWF4X2xlbmd0aCB8fCAhaXNhc2NpaShjKSkgeworCQkJKmxlbiA9IDA7CisJCQlicmVhazsKKwkJfQorCisJCWlmIChjICE9IG90aGVyX3N0cmluZ1sqbGVuIC0gMV0pCisJCQlicmVhazsKKwl9Cit9CisKK3N0YXRpYyB2b2lkIGZpbmRfdW5pcXVlX3ByZWZpeGVzKHN0cnVjdCBwcmVmaXhfaXRlbV9saXN0ICpsaXN0KQoreworCXNpemVfdCBpOworCisJaWYgKGxpc3QtPnNvcnRlZC5uciA9PSBsaXN0LT5pdGVtcy5ucikKKwkJcmV0dXJuOworCisJc3RyaW5nX2xpc3RfY2xlYXIoJmxpc3QtPnNvcnRlZCwgMCk7CisJLyogQXZvaWQgcmVhbGxvY2F0aW5nIGluY3JlbWVudGFsbHkgKi8KKwlsaXN0LT5zb3J0ZWQuaXRlbXMgPSB4bWFsbG9jKHN0X211bHQoc2l6ZW9mKCpsaXN0LT5zb3J0ZWQuaXRlbXMpLAorCQkJCQkgICAgIGxpc3QtPml0ZW1zLm5yKSk7CisJbGlzdC0+c29ydGVkLm5yID0gbGlzdC0+c29ydGVkLmFsbG9jID0gbGlzdC0+aXRlbXMubnI7CisKKwlmb3IgKGkgPSAwOyBpIDwgbGlzdC0+aXRlbXMubnI7IGkrKykgeworCQlsaXN0LT5zb3J0ZWQuaXRlbXNbaV0uc3RyaW5nID0gbGlzdC0+aXRlbXMuaXRlbXNbaV0uc3RyaW5nOworCQlsaXN0LT5zb3J0ZWQuaXRlbXNbaV0udXRpbCA9IGxpc3QtPml0ZW1zLml0ZW1zICsgaTsKKwl9CisKKwlzdHJpbmdfbGlzdF9zb3J0KCZsaXN0LT5zb3J0ZWQpOworCisJZm9yIChpID0gMDsgaSA8IGxpc3QtPnNvcnRlZC5ucjsgaSsrKSB7CisJCXN0cnVjdCBzdHJpbmdfbGlzdF9pdGVtICpzb3J0ZWRfaXRlbSA9IGxpc3QtPnNvcnRlZC5pdGVtcyArIGk7CisJCXN0cnVjdCBzdHJpbmdfbGlzdF9pdGVtICppdGVtID0gc29ydGVkX2l0ZW0tPnV0aWw7CisJCXNpemVfdCAqbGVuID0gaXRlbS0+dXRpbDsKKworCQkqbGVuID0gMDsKKwkJd2hpbGUgKCpsZW4gPCBsaXN0LT5taW5fbGVuZ3RoKSB7CisJCQljaGFyIGMgPSBpdGVtLT5zdHJpbmdbKCpsZW4pKytdOworCisJCQlpZiAoIWMgfHwgIWlzYXNjaWkoYykpIHsKKwkJCQkqbGVuID0gMDsKKwkJCQlicmVhazsKKwkJCX0KKwkJfQorCisJCWlmIChpID4gMCkKKwkJCWV4dGVuZF9wcmVmaXhfbGVuZ3RoKGl0ZW0sIHNvcnRlZF9pdGVtWy0xXS5zdHJpbmcsCisJCQkJCSAgICAgbGlzdC0+bWF4X2xlbmd0aCk7CisJCWlmIChpICsgMSA8IGxpc3QtPnNvcnRlZC5ucikKKwkJCWV4dGVuZF9wcmVmaXhfbGVuZ3RoKGl0ZW0sIHNvcnRlZF9pdGVtWzFdLnN0cmluZywKKwkJCQkJICAgICBsaXN0LT5tYXhfbGVuZ3RoKTsKKwl9Cit9CisKK3N0YXRpYyBzc2l6ZV90IGZpbmRfdW5pcXVlKGNvbnN0IGNoYXIgKnN0cmluZywgc3RydWN0IHByZWZpeF9pdGVtX2xpc3QgKmxpc3QpCit7CisJaW50IGluZGV4ID0gc3RyaW5nX2xpc3RfZmluZF9pbnNlcnRfaW5kZXgoJmxpc3QtPnNvcnRlZCwgc3RyaW5nLCAxKTsKKwlzdHJ1Y3Qgc3RyaW5nX2xpc3RfaXRlbSAqaXRlbTsKKworCWlmIChsaXN0LT5pdGVtcy5uciAhPSBsaXN0LT5zb3J0ZWQubnIpCisJCUJVRygicHJlZml4X2l0ZW1fbGlzdCBpbiBpbmNvbnNpc3RlbnQgc3RhdGUgKCUiUFJJdU1BWAorCQkgICAgIiB2cyAlIlBSSXVNQVgiKSIsCisJCSAgICAodWludG1heF90KWxpc3QtPml0ZW1zLm5yLCAodWludG1heF90KWxpc3QtPnNvcnRlZC5ucik7CisKKwlpZiAoaW5kZXggPCAwKQorCQlpdGVtID0gbGlzdC0+c29ydGVkLml0ZW1zWy0xIC0gaW5kZXhdLnV0aWw7CisJZWxzZSBpZiAoaW5kZXggPiAwICYmCisJCSBzdGFydHNfd2l0aChsaXN0LT5zb3J0ZWQuaXRlbXNbaW5kZXggLSAxXS5zdHJpbmcsIHN0cmluZykpCisJCXJldHVybiAtMTsKKwllbHNlIGlmIChpbmRleCArIDEgPCBsaXN0LT5zb3J0ZWQubnIgJiYKKwkJIHN0YXJ0c193aXRoKGxpc3QtPnNvcnRlZC5pdGVtc1tpbmRleCArIDFdLnN0cmluZywgc3RyaW5nKSkKKwkJcmV0dXJuIC0xOworCWVsc2UgaWYgKGluZGV4IDwgbGlzdC0+c29ydGVkLm5yKQorCQlpdGVtID0gbGlzdC0+c29ydGVkLml0ZW1zW2luZGV4XS51dGlsOworCWVsc2UKKwkJcmV0dXJuIC0xOworCXJldHVybiBpdGVtIC0gbGlzdC0+aXRlbXMuaXRlbXM7Cit9CisKK3N0cnVjdCBsaXN0X29wdGlvbnMgeworCWludCBjb2x1bW5zOworCWNvbnN0IGNoYXIgKmhlYWRlcjsKKwl2b2lkICgqcHJpbnRfaXRlbSkoaW50IGksIHN0cnVjdCBzdHJpbmdfbGlzdF9pdGVtICppdGVtLCB2b2lkICpwcmludF9pdGVtX2RhdGEpOworCXZvaWQgKnByaW50X2l0ZW1fZGF0YTsKK307CisKK3N0YXRpYyB2b2lkIGxpc3Qoc3RydWN0IGFkZF9pX3N0YXRlICpzLCBzdHJ1Y3Qgc3RyaW5nX2xpc3QgKmxpc3QsCisJCSBzdHJ1Y3QgbGlzdF9vcHRpb25zICpvcHRzKQoreworCWludCBpLCBsYXN0X2xmID0gMDsKKworCWlmICghbGlzdC0+bnIpCisJCXJldHVybjsKKworCWlmIChvcHRzLT5oZWFkZXIpCisJCWNvbG9yX2ZwcmludGZfbG4oc3Rkb3V0LCBzLT5oZWFkZXJfY29sb3IsCisJCQkJICIlcyIsIG9wdHMtPmhlYWRlcik7CisKKwlmb3IgKGkgPSAwOyBpIDwgbGlzdC0+bnI7IGkrKykgeworCQlvcHRzLT5wcmludF9pdGVtKGksIGxpc3QtPml0ZW1zICsgaSwgb3B0cy0+cHJpbnRfaXRlbV9kYXRhKTsKKworCQlpZiAoKG9wdHMtPmNvbHVtbnMpICYmICgoaSArIDEpICUgKG9wdHMtPmNvbHVtbnMpKSkgeworCQkJcHV0Y2hhcignXHQnKTsKKwkJCWxhc3RfbGYgPSAwOworCQl9CisJCWVsc2UgeworCQkJcHV0Y2hhcignXG4nKTsKKwkJCWxhc3RfbGYgPSAxOworCQl9CisJfQorCisJaWYgKCFsYXN0X2xmKQorCQlwdXRjaGFyKCdcbicpOworfQorc3RydWN0IGxpc3RfYW5kX2Nob29zZV9vcHRpb25zIHsKKwlzdHJ1Y3QgbGlzdF9vcHRpb25zIGxpc3Rfb3B0czsKKworCWNvbnN0IGNoYXIgKnByb21wdDsKKwl2b2lkICgqcHJpbnRfaGVscCkoc3RydWN0IGFkZF9pX3N0YXRlICpzKTsKK307CisKKyNkZWZpbmUgTElTVF9BTkRfQ0hPT1NFX0VSUk9SICgtMSkKKyNkZWZpbmUgTElTVF9BTkRfQ0hPT1NFX1FVSVQgICgtMikKKworLyoKKyAqIFJldHVybnMgdGhlIHNlbGVjdGVkIGluZGV4LgorICoKKyAqIElmIGFuIGVycm9yIG9jY3VycmVkLCByZXR1cm5zIGBMSVNUX0FORF9DSE9PU0VfRVJST1JgLiBVcG9uIEVPRiwKKyAqIGBMSVNUX0FORF9DSE9PU0VfUVVJVGAgaXMgcmV0dXJuZWQuCisgKi8KK3N0YXRpYyBzc2l6ZV90IGxpc3RfYW5kX2Nob29zZShzdHJ1Y3QgYWRkX2lfc3RhdGUgKnMsCisJCQkgICAgICAgc3RydWN0IHByZWZpeF9pdGVtX2xpc3QgKml0ZW1zLAorCQkJICAgICAgIHN0cnVjdCBsaXN0X2FuZF9jaG9vc2Vfb3B0aW9ucyAqb3B0cykKK3sKKwlzdHJ1Y3Qgc3RyYnVmIGlucHV0ID0gU1RSQlVGX0lOSVQ7CisJc3NpemVfdCByZXMgPSBMSVNUX0FORF9DSE9PU0VfRVJST1I7CisKKwlmaW5kX3VuaXF1ZV9wcmVmaXhlcyhpdGVtcyk7CisKKwlmb3IgKDs7KSB7CisJCWNoYXIgKnA7CisKKwkJc3RyYnVmX3Jlc2V0KCZpbnB1dCk7CisKKwkJbGlzdChzLCAmaXRlbXMtPml0ZW1zLCAmb3B0cy0+bGlzdF9vcHRzKTsKKworCQljb2xvcl9mcHJpbnRmKHN0ZG91dCwgcy0+cHJvbXB0X2NvbG9yLCAiJXMiLCBvcHRzLT5wcm9tcHQpOworCQlmcHV0cygiPiAiLCBzdGRvdXQpOworCQlmZmx1c2goc3Rkb3V0KTsKKworCQlpZiAoc3RyYnVmX2dldGxpbmUoJmlucHV0LCBzdGRpbikgPT0gRU9GKSB7CisJCQlwdXRjaGFyKCdcbicpOworCQkJcmVzID0gTElTVF9BTkRfQ0hPT1NFX1FVSVQ7CisJCQlicmVhazsKKwkJfQorCQlzdHJidWZfdHJpbSgmaW5wdXQpOworCisJCWlmICghaW5wdXQubGVuKQorCQkJYnJlYWs7CisKKwkJaWYgKCFzdHJjbXAoaW5wdXQuYnVmLCAiPyIpKSB7CisJCQlvcHRzLT5wcmludF9oZWxwKHMpOworCQkJY29udGludWU7CisJCX0KKworCQlwID0gaW5wdXQuYnVmOworCQlmb3IgKDs7KSB7CisJCQlzaXplX3Qgc2VwID0gc3RyY3NwbihwLCAiIFx0XHJcbiwiKTsKKwkJCXNzaXplX3QgaW5kZXggPSAtMTsKKworCQkJaWYgKCFzZXApIHsKKwkJCQlpZiAoISpwKQorCQkJCQlicmVhazsKKwkJCQlwKys7CisJCQkJY29udGludWU7CisJCQl9CisKKwkJCWlmIChpc2RpZ2l0KCpwKSkgeworCQkJCWNoYXIgKmVuZHA7CisJCQkJaW5kZXggPSBzdHJ0b3VsKHAsICZlbmRwLCAxMCkgLSAxOworCQkJCWlmIChlbmRwICE9IHAgKyBzZXApCisJCQkJCWluZGV4ID0gLTE7CisJCQl9CisKKwkJCWlmIChwW3NlcF0pCisJCQkJcFtzZXArK10gPSAnXDAnOworCQkJaWYgKGluZGV4IDwgMCkKKwkJCQlpbmRleCA9IGZpbmRfdW5pcXVlKHAsIGl0ZW1zKTsKKworCQkJaWYgKGluZGV4IDwgMCB8fCBpbmRleCA+PSBpdGVtcy0+aXRlbXMubnIpCisJCQkJY29sb3JfZnByaW50Zl9sbihzdGRvdXQsIHMtPmVycm9yX2NvbG9yLAorCQkJCQkJIF8oIkh1aCAoJXMpPyIpLCBwKTsKKwkJCWVsc2UgeworCQkJCXJlcyA9IGluZGV4OworCQkJCWJyZWFrOworCQkJfQorCisJCQlwICs9IHNlcDsKKwkJfQorCisJCWlmIChyZXMgIT0gTElTVF9BTkRfQ0hPT1NFX0VSUk9SKQorCQkJYnJlYWs7CisJfQorCisJc3RyYnVmX3JlbGVhc2UoJmlucHV0KTsKKwlyZXR1cm4gcmVzOworfQorCitzdHJ1Y3QgYWRkZGVsIHsKKwl1aW50bWF4X3QgYWRkLCBkZWw7CisJdW5zaWduZWQgc2VlbjoxLCBiaW5hcnk6MTsKK307CisKK3N0cnVjdCBmaWxlX2l0ZW0geworCXN0cnVjdCBhZGRkZWwgaW5kZXgsIHdvcmt0cmVlOworfTsKKworc3RhdGljIHZvaWQgYWRkX2ZpbGVfaXRlbShzdHJ1Y3Qgc3RyaW5nX2xpc3QgKmZpbGVzLCBjb25zdCBjaGFyICpuYW1lKQoreworCXN0cnVjdCBmaWxlX2l0ZW0gKml0ZW0gPSB4Y2FsbG9jKHNpemVvZigqaXRlbSksIDEpOworCisJc3RyaW5nX2xpc3RfYXBwZW5kKGZpbGVzLCBuYW1lKS0+dXRpbCA9IGl0ZW07Cit9CisKK3N0cnVjdCBwYXRobmFtZV9lbnRyeSB7CisJc3RydWN0IGhhc2htYXBfZW50cnkgZW50OworCWNvbnN0IGNoYXIgKm5hbWU7CisJc3RydWN0IGZpbGVfaXRlbSAqaXRlbTsKK307CisKK3N0YXRpYyBpbnQgcGF0aG5hbWVfZW50cnlfY21wKGNvbnN0IHZvaWQgKnVudXNlZF9jbXBfZGF0YSwKKwkJCSAgICAgIGNvbnN0IHN0cnVjdCBoYXNobWFwX2VudHJ5ICpoZTEsCisJCQkgICAgICBjb25zdCBzdHJ1Y3QgaGFzaG1hcF9lbnRyeSAqaGUyLAorCQkJICAgICAgY29uc3Qgdm9pZCAqbmFtZSkKK3sKKwljb25zdCBzdHJ1Y3QgcGF0aG5hbWVfZW50cnkgKmUxID0KKwkJY29udGFpbmVyX29mKGhlMSwgY29uc3Qgc3RydWN0IHBhdGhuYW1lX2VudHJ5LCBlbnQpOworCWNvbnN0IHN0cnVjdCBwYXRobmFtZV9lbnRyeSAqZTIgPQorCQljb250YWluZXJfb2YoaGUyLCBjb25zdCBzdHJ1Y3QgcGF0aG5hbWVfZW50cnksIGVudCk7CisKKwlyZXR1cm4gc3RyY21wKGUxLT5uYW1lLCBuYW1lID8gKGNvbnN0IGNoYXIgKiluYW1lIDogZTItPm5hbWUpOworfQorCitzdHJ1Y3QgY29sbGVjdGlvbl9zdGF0dXMgeworCWVudW0geyBGUk9NX1dPUktUUkVFID0gMCwgRlJPTV9JTkRFWCA9IDEgfSBwaGFzZTsKKworCWNvbnN0IGNoYXIgKnJlZmVyZW5jZTsKKworCXN0cnVjdCBzdHJpbmdfbGlzdCAqZmlsZXM7CisJc3RydWN0IGhhc2htYXAgZmlsZV9tYXA7Cit9OworCitzdGF0aWMgdm9pZCBjb2xsZWN0X2NoYW5nZXNfY2Ioc3RydWN0IGRpZmZfcXVldWVfc3RydWN0ICpxLAorCQkJICAgICAgIHN0cnVjdCBkaWZmX29wdGlvbnMgKm9wdGlvbnMsCisJCQkgICAgICAgdm9pZCAqZGF0YSkKK3sKKwlzdHJ1Y3QgY29sbGVjdGlvbl9zdGF0dXMgKnMgPSBkYXRhOworCXN0cnVjdCBkaWZmc3RhdF90IHN0YXQgPSB7IDAgfTsKKwlpbnQgaTsKKworCWlmICghcS0+bnIpCisJCXJldHVybjsKKworCWNvbXB1dGVfZGlmZnN0YXQob3B0aW9ucywgJnN0YXQsIHEpOworCisJZm9yIChpID0gMDsgaSA8IHN0YXQubnI7IGkrKykgeworCQljb25zdCBjaGFyICpuYW1lID0gc3RhdC5maWxlc1tpXS0+bmFtZTsKKwkJaW50IGhhc2ggPSBzdHJoYXNoKG5hbWUpOworCQlzdHJ1Y3QgcGF0aG5hbWVfZW50cnkgKmVudHJ5OworCQlzdHJ1Y3QgZmlsZV9pdGVtICpmaWxlX2l0ZW07CisJCXN0cnVjdCBhZGRkZWwgKmFkZGRlbDsKKworCQllbnRyeSA9IGhhc2htYXBfZ2V0X2VudHJ5X2Zyb21faGFzaCgmcy0+ZmlsZV9tYXAsIGhhc2gsIG5hbWUsCisJCQkJCQkgICAgc3RydWN0IHBhdGhuYW1lX2VudHJ5LCBlbnQpOworCQlpZiAoIWVudHJ5KSB7CisJCQlhZGRfZmlsZV9pdGVtKHMtPmZpbGVzLCBuYW1lKTsKKworCQkJZW50cnkgPSB4Y2FsbG9jKHNpemVvZigqZW50cnkpLCAxKTsKKwkJCWhhc2htYXBfZW50cnlfaW5pdCgmZW50cnktPmVudCwgaGFzaCk7CisJCQllbnRyeS0+bmFtZSA9IHMtPmZpbGVzLT5pdGVtc1tzLT5maWxlcy0+bnIgLSAxXS5zdHJpbmc7CisJCQllbnRyeS0+aXRlbSA9IHMtPmZpbGVzLT5pdGVtc1tzLT5maWxlcy0+bnIgLSAxXS51dGlsOworCQkJaGFzaG1hcF9hZGQoJnMtPmZpbGVfbWFwLCAmZW50cnktPmVudCk7CisJCX0KKworCQlmaWxlX2l0ZW0gPSBlbnRyeS0+aXRlbTsKKwkJYWRkZGVsID0gcy0+cGhhc2UgPT0gRlJPTV9JTkRFWCA/CisJCQkmZmlsZV9pdGVtLT5pbmRleCA6ICZmaWxlX2l0ZW0tPndvcmt0cmVlOworCQlhZGRkZWwtPnNlZW4gPSAxOworCQlhZGRkZWwtPmFkZCA9IHN0YXQuZmlsZXNbaV0tPmFkZGVkOworCQlhZGRkZWwtPmRlbCA9IHN0YXQuZmlsZXNbaV0tPmRlbGV0ZWQ7CisJCWlmIChzdGF0LmZpbGVzW2ldLT5pc19iaW5hcnkpCisJCQlhZGRkZWwtPmJpbmFyeSA9IDE7CisJfQorCWZyZWVfZGlmZnN0YXRfaW5mbygmc3RhdCk7Cit9CisKK3N0YXRpYyBpbnQgZ2V0X21vZGlmaWVkX2ZpbGVzKHN0cnVjdCByZXBvc2l0b3J5ICpyLCBzdHJ1Y3Qgc3RyaW5nX2xpc3QgKmZpbGVzLAorCQkJICAgICAgY29uc3Qgc3RydWN0IHBhdGhzcGVjICpwcykKK3sKKwlzdHJ1Y3Qgb2JqZWN0X2lkIGhlYWRfb2lkOworCWludCBpc19pbml0aWFsID0gIXJlc29sdmVfcmVmX3Vuc2FmZSgiSEVBRCIsIFJFU09MVkVfUkVGX1JFQURJTkcsCisJCQkJCSAgICAgJmhlYWRfb2lkLCBOVUxMKTsKKwlzdHJ1Y3QgY29sbGVjdGlvbl9zdGF0dXMgcyA9IHsgRlJPTV9XT1JLVFJFRSB9OworCisJaWYgKGRpc2NhcmRfaW5kZXgoci0+aW5kZXgpIDwgMCB8fAorCSAgICByZXBvX3JlYWRfaW5kZXhfcHJlbG9hZChyLCBwcywgMCkgPCAwKQorCQlyZXR1cm4gZXJyb3IoXygiY291bGQgbm90IHJlYWQgaW5kZXgiKSk7CisKKwlzdHJpbmdfbGlzdF9jbGVhcihmaWxlcywgMSk7CisJcy5maWxlcyA9IGZpbGVzOworCWhhc2htYXBfaW5pdCgmcy5maWxlX21hcCwgcGF0aG5hbWVfZW50cnlfY21wLCBOVUxMLCAwKTsKKworCWZvciAocy5waGFzZSA9IEZST01fV09SS1RSRUU7IHMucGhhc2UgPD0gRlJPTV9JTkRFWDsgcy5waGFzZSsrKSB7CisJCXN0cnVjdCByZXZfaW5mbyByZXY7CisJCXN0cnVjdCBzZXR1cF9yZXZpc2lvbl9vcHQgb3B0ID0geyAwIH07CisKKwkJb3B0LmRlZiA9IGlzX2luaXRpYWwgPworCQkJZW1wdHlfdHJlZV9vaWRfaGV4KCkgOiBvaWRfdG9faGV4KCZoZWFkX29pZCk7CisKKwkJaW5pdF9yZXZpc2lvbnMoJnJldiwgTlVMTCk7CisJCXNldHVwX3JldmlzaW9ucygwLCBOVUxMLCAmcmV2LCAmb3B0KTsKKworCQlyZXYuZGlmZm9wdC5vdXRwdXRfZm9ybWF0ID0gRElGRl9GT1JNQVRfQ0FMTEJBQ0s7CisJCXJldi5kaWZmb3B0LmZvcm1hdF9jYWxsYmFjayA9IGNvbGxlY3RfY2hhbmdlc19jYjsKKwkJcmV2LmRpZmZvcHQuZm9ybWF0X2NhbGxiYWNrX2RhdGEgPSAmczsKKworCQlpZiAocHMpCisJCQljb3B5X3BhdGhzcGVjKCZyZXYucHJ1bmVfZGF0YSwgcHMpOworCisJCWlmIChzLnBoYXNlID09IEZST01fSU5ERVgpCisJCQlydW5fZGlmZl9pbmRleCgmcmV2LCAxKTsKKwkJZWxzZSB7CisJCQlyZXYuZGlmZm9wdC5mbGFncy5pZ25vcmVfZGlydHlfc3VibW9kdWxlcyA9IDE7CisJCQlydW5fZGlmZl9maWxlcygmcmV2LCAwKTsKKwkJfQorCX0KKwloYXNobWFwX2ZyZWVfZW50cmllcygmcy5maWxlX21hcCwgc3RydWN0IHBhdGhuYW1lX2VudHJ5LCBlbnQpOworCisJLyogV2hpbGUgdGhlIGRpZmZzIGFyZSBvcmRlcmVkIGFscmVhZHksIHdlIHJhbiAqdHdvKiBkaWZmcy4uLiAqLworCXN0cmluZ19saXN0X3NvcnQoZmlsZXMpOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyB2b2lkIHJlbmRlcl9hZGRkZWwoc3RydWN0IHN0cmJ1ZiAqYnVmLAorCQkJCXN0cnVjdCBhZGRkZWwgKmFkLCBjb25zdCBjaGFyICpub19jaGFuZ2VzKQoreworCWlmIChhZC0+YmluYXJ5KQorCQlzdHJidWZfYWRkc3RyKGJ1ZiwgXygiYmluYXJ5IikpOworCWVsc2UgaWYgKGFkLT5zZWVuKQorCQlzdHJidWZfYWRkZihidWYsICIrJSJQUkl1TUFYIi8tJSJQUkl1TUFYLAorCQkJICAgICh1aW50bWF4X3QpYWQtPmFkZCwgKHVpbnRtYXhfdClhZC0+ZGVsKTsKKwllbHNlCisJCXN0cmJ1Zl9hZGRzdHIoYnVmLCBub19jaGFuZ2VzKTsKK30KKworLyogZmlsdGVycyBvdXQgcHJlZml4ZXMgd2hpY2ggaGF2ZSBzcGVjaWFsIG1lYW5pbmcgdG8gbGlzdF9hbmRfY2hvb3NlKCkgKi8KK3N0YXRpYyBpbnQgaXNfdmFsaWRfcHJlZml4KGNvbnN0IGNoYXIgKnByZWZpeCwgc2l6ZV90IHByZWZpeF9sZW4pCit7CisJcmV0dXJuIHByZWZpeF9sZW4gJiYgcHJlZml4ICYmCisJCS8qCisJCSAqIFdlIGV4cGVjdCBgcHJlZml4YCB0byBiZSBOVUwgdGVybWluYXRlZCwgdGhlcmVmb3JlIHRoaXMKKwkJICogYHN0cmNzcG4oKWAgY2FsbCBpcyBva2F5LCBldmVuIGlmIGl0IG1pZ2h0IGRvIG11Y2ggbW9yZQorCQkgKiB3b3JrIHRoYW4gc3RyaWN0bHkgbmVjZXNzYXJ5LgorCQkgKi8KKwkJc3RyY3NwbihwcmVmaXgsICIgXHRcclxuLCIpID49IHByZWZpeF9sZW4gJiYJLyogc2VwYXJhdG9ycyAqLworCQkqcHJlZml4ICE9ICctJyAmJgkJCQkvKiBkZXNlbGVjdGlvbiAqLworCQkhaXNkaWdpdCgqcHJlZml4KSAmJgkJCQkvKiBzZWxlY3Rpb24gKi8KKwkJKHByZWZpeF9sZW4gIT0gMSB8fAorCQkgKCpwcmVmaXggIT0gJyonICYmCQkJCS8qICJhbGwiIHdpbGRjYXJkICovCisJCSAgKnByZWZpeCAhPSAnPycpKTsJCQkJLyogcHJvbXB0IGhlbHAgKi8KK30KKworc3RydWN0IHByaW50X2ZpbGVfaXRlbV9kYXRhIHsKKwljb25zdCBjaGFyICptb2RpZmllZF9mbXQ7CisJc3RydWN0IHN0cmJ1ZiBidWYsIGluZGV4LCB3b3JrdHJlZTsKK307CisKK3N0YXRpYyB2b2lkIHByaW50X2ZpbGVfaXRlbShpbnQgaSwgc3RydWN0IHN0cmluZ19saXN0X2l0ZW0gKml0ZW0sCisJCQkgICAgdm9pZCAqcHJpbnRfZmlsZV9pdGVtX2RhdGEpCit7CisJc3RydWN0IGZpbGVfaXRlbSAqYyA9IGl0ZW0tPnV0aWw7CisJc3RydWN0IHByaW50X2ZpbGVfaXRlbV9kYXRhICpkID0gcHJpbnRfZmlsZV9pdGVtX2RhdGE7CisKKwlzdHJidWZfcmVzZXQoJmQtPmluZGV4KTsKKwlzdHJidWZfcmVzZXQoJmQtPndvcmt0cmVlKTsKKwlzdHJidWZfcmVzZXQoJmQtPmJ1Zik7CisKKwlyZW5kZXJfYWRkZGVsKCZkLT53b3JrdHJlZSwgJmMtPndvcmt0cmVlLCBfKCJub3RoaW5nIikpOworCXJlbmRlcl9hZGRkZWwoJmQtPmluZGV4LCAmYy0+aW5kZXgsIF8oInVuY2hhbmdlZCIpKTsKKwlzdHJidWZfYWRkZigmZC0+YnVmLCBkLT5tb2RpZmllZF9mbXQsCisJCSAgICBkLT5pbmRleC5idWYsIGQtPndvcmt0cmVlLmJ1ZiwgaXRlbS0+c3RyaW5nKTsKKworCXByaW50ZigiICUyZDogJXMiLCBpICsgMSwgZC0+YnVmLmJ1Zik7Cit9CisKK3N0YXRpYyBpbnQgcnVuX3N0YXR1cyhzdHJ1Y3QgYWRkX2lfc3RhdGUgKnMsIGNvbnN0IHN0cnVjdCBwYXRoc3BlYyAqcHMsCisJCSAgICAgIHN0cnVjdCBzdHJpbmdfbGlzdCAqZmlsZXMsIHN0cnVjdCBsaXN0X29wdGlvbnMgKm9wdHMpCit7CisJaWYgKGdldF9tb2RpZmllZF9maWxlcyhzLT5yLCBmaWxlcywgcHMpIDwgMCkKKwkJcmV0dXJuIC0xOworCisJbGlzdChzLCBmaWxlcywgb3B0cyk7CisJcHV0Y2hhcignXG4nKTsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50IHJ1bl9oZWxwKHN0cnVjdCBhZGRfaV9zdGF0ZSAqcywgY29uc3Qgc3RydWN0IHBhdGhzcGVjICp1bnVzZWRfcHMsCisJCSAgICBzdHJ1Y3Qgc3RyaW5nX2xpc3QgKnVudXNlZF9maWxlcywKKwkJICAgIHN0cnVjdCBsaXN0X29wdGlvbnMgKnVudXNlZF9vcHRzKQoreworCWNvbG9yX2ZwcmludGZfbG4oc3Rkb3V0LCBzLT5oZWxwX2NvbG9yLCAic3RhdHVzICAgICAgICAtICVzIiwKKwkJCSBfKCJzaG93IHBhdGhzIHdpdGggY2hhbmdlcyIpKTsKKwljb2xvcl9mcHJpbnRmX2xuKHN0ZG91dCwgcy0+aGVscF9jb2xvciwgInVwZGF0ZSAgICAgICAgLSAlcyIsCisJCQkgXygiYWRkIHdvcmtpbmcgdHJlZSBzdGF0ZSB0byB0aGUgc3RhZ2VkIHNldCBvZiBjaGFuZ2VzIikpOworCWNvbG9yX2ZwcmludGZfbG4oc3Rkb3V0LCBzLT5oZWxwX2NvbG9yLCAicmV2ZXJ0ICAgICAgICAtICVzIiwKKwkJCSBfKCJyZXZlcnQgc3RhZ2VkIHNldCBvZiBjaGFuZ2VzIGJhY2sgdG8gdGhlIEhFQUQgdmVyc2lvbiIpKTsKKwljb2xvcl9mcHJpbnRmX2xuKHN0ZG91dCwgcy0+aGVscF9jb2xvciwgInBhdGNoICAgICAgICAgLSAlcyIsCisJCQkgXygicGljayBodW5rcyBhbmQgdXBkYXRlIHNlbGVjdGl2ZWx5IikpOworCWNvbG9yX2ZwcmludGZfbG4oc3Rkb3V0LCBzLT5oZWxwX2NvbG9yLCAiZGlmZiAgICAgICAgICAtICVzIiwKKwkJCSBfKCJ2aWV3IGRpZmYgYmV0d2VlbiBIRUFEIGFuZCBpbmRleCIpKTsKKwljb2xvcl9mcHJpbnRmX2xuKHN0ZG91dCwgcy0+aGVscF9jb2xvciwgImFkZCB1bnRyYWNrZWQgLSAlcyIsCisJCQkgXygiYWRkIGNvbnRlbnRzIG9mIHVudHJhY2tlZCBmaWxlcyB0byB0aGUgc3RhZ2VkIHNldCBvZiBjaGFuZ2VzIikpOworCisJcmV0dXJuIDA7Cit9CisKK3R5cGVkZWYgaW50ICgqY29tbWFuZF90KShzdHJ1Y3QgYWRkX2lfc3RhdGUgKnMsIGNvbnN0IHN0cnVjdCBwYXRoc3BlYyAqcHMsCisJCQkgc3RydWN0IHN0cmluZ19saXN0ICpmaWxlcywKKwkJCSBzdHJ1Y3QgbGlzdF9vcHRpb25zICpvcHRzKTsKKworc3RydWN0IGNvbW1hbmRfaXRlbSB7CisJc2l6ZV90IHByZWZpeF9sZW5ndGg7CisJY29tbWFuZF90IGNvbW1hbmQ7Cit9OworCitzdHJ1Y3QgcHJpbnRfY29tbWFuZF9pdGVtX2RhdGEgeworCWNvbnN0IGNoYXIgKmNvbG9yLCAqcmVzZXQ7Cit9OworCitzdGF0aWMgdm9pZCBwcmludF9jb21tYW5kX2l0ZW0oaW50IGksIHN0cnVjdCBzdHJpbmdfbGlzdF9pdGVtICppdGVtLAorCQkJICAgICAgIHZvaWQgKnByaW50X2NvbW1hbmRfaXRlbV9kYXRhKQoreworCXN0cnVjdCBwcmludF9jb21tYW5kX2l0ZW1fZGF0YSAqZCA9IHByaW50X2NvbW1hbmRfaXRlbV9kYXRhOworCXN0cnVjdCBjb21tYW5kX2l0ZW0gKnV0aWwgPSBpdGVtLT51dGlsOworCisJaWYgKCF1dGlsLT5wcmVmaXhfbGVuZ3RoIHx8CisJICAgICFpc192YWxpZF9wcmVmaXgoaXRlbS0+c3RyaW5nLCB1dGlsLT5wcmVmaXhfbGVuZ3RoKSkKKwkJcHJpbnRmKCIgJTJkOiAlcyIsIGkgKyAxLCBpdGVtLT5zdHJpbmcpOworCWVsc2UKKwkJcHJpbnRmKCIgJTJkOiAlcyUuKnMlcyVzIiwgaSArIDEsCisJCSAgICAgICBkLT5jb2xvciwgKGludCl1dGlsLT5wcmVmaXhfbGVuZ3RoLCBpdGVtLT5zdHJpbmcsCisJCSAgICAgICBkLT5yZXNldCwgaXRlbS0+c3RyaW5nICsgdXRpbC0+cHJlZml4X2xlbmd0aCk7Cit9CisKK3N0YXRpYyB2b2lkIGNvbW1hbmRfcHJvbXB0X2hlbHAoc3RydWN0IGFkZF9pX3N0YXRlICpzKQoreworCWNvbnN0IGNoYXIgKmhlbHBfY29sb3IgPSBzLT5oZWxwX2NvbG9yOworCWNvbG9yX2ZwcmludGZfbG4oc3Rkb3V0LCBoZWxwX2NvbG9yLCAiJXMiLCBfKCJQcm9tcHQgaGVscDoiKSk7CisJY29sb3JfZnByaW50Zl9sbihzdGRvdXQsIGhlbHBfY29sb3IsICIxICAgICAgICAgIC0gJXMiLAorCQkJIF8oInNlbGVjdCBhIG51bWJlcmVkIGl0ZW0iKSk7CisJY29sb3JfZnByaW50Zl9sbihzdGRvdXQsIGhlbHBfY29sb3IsICJmb28gICAgICAgIC0gJXMiLAorCQkJIF8oInNlbGVjdCBpdGVtIGJhc2VkIG9uIHVuaXF1ZSBwcmVmaXgiKSk7CisJY29sb3JfZnByaW50Zl9sbihzdGRvdXQsIGhlbHBfY29sb3IsICIgICAgICAgICAgIC0gJXMiLAorCQkJIF8oIihlbXB0eSkgc2VsZWN0IG5vdGhpbmciKSk7Cit9CisKK2ludCBydW5fYWRkX2koc3RydWN0IHJlcG9zaXRvcnkgKnIsIGNvbnN0IHN0cnVjdCBwYXRoc3BlYyAqcHMpCit7CisJc3RydWN0IGFkZF9pX3N0YXRlIHMgPSB7IE5VTEwgfTsKKwlzdHJ1Y3QgcHJpbnRfY29tbWFuZF9pdGVtX2RhdGEgZGF0YSA9IHsgIlsiLCAiXSIgfTsKKwlzdHJ1Y3QgbGlzdF9hbmRfY2hvb3NlX29wdGlvbnMgbWFpbl9sb29wX29wdHMgPSB7CisJCXsgNCwgTl8oIioqKiBDb21tYW5kcyAqKioiKSwgcHJpbnRfY29tbWFuZF9pdGVtLCAmZGF0YSB9LAorCQlOXygiV2hhdCBub3ciKSwgY29tbWFuZF9wcm9tcHRfaGVscAorCX07CisJc3RydWN0IHsKKwkJY29uc3QgY2hhciAqc3RyaW5nOworCQljb21tYW5kX3QgY29tbWFuZDsKKwl9IGNvbW1hbmRfbGlzdFtdID0geworCQl7ICJzdGF0dXMiLCBydW5fc3RhdHVzIH0sCisJCXsgImhlbHAiLCBydW5faGVscCB9LAorCX07CisJc3RydWN0IHByZWZpeF9pdGVtX2xpc3QgY29tbWFuZHMgPSBQUkVGSVhfSVRFTV9MSVNUX0lOSVQ7CisKKwlzdHJ1Y3QgcHJpbnRfZmlsZV9pdGVtX2RhdGEgcHJpbnRfZmlsZV9pdGVtX2RhdGEgPSB7CisJCSIlMTJzICUxMnMgJXMiLCBTVFJCVUZfSU5JVCwgU1RSQlVGX0lOSVQsIFNUUkJVRl9JTklUCisJfTsKKwlzdHJ1Y3QgbGlzdF9vcHRpb25zIG9wdHMgPSB7CisJCTAsIE5VTEwsIHByaW50X2ZpbGVfaXRlbSwgJnByaW50X2ZpbGVfaXRlbV9kYXRhCisJfTsKKwlzdHJ1Y3Qgc3RyYnVmIGhlYWRlciA9IFNUUkJVRl9JTklUOworCXN0cnVjdCBzdHJpbmdfbGlzdCBmaWxlcyA9IFNUUklOR19MSVNUX0lOSVRfRFVQOworCXNzaXplX3QgaTsKKwlpbnQgcmVzID0gMDsKKworCWZvciAoaSA9IDA7IGkgPCBBUlJBWV9TSVpFKGNvbW1hbmRfbGlzdCk7IGkrKykgeworCQlzdHJ1Y3QgY29tbWFuZF9pdGVtICp1dGlsID0geGNhbGxvYyhzaXplb2YoKnV0aWwpLCAxKTsKKwkJdXRpbC0+Y29tbWFuZCA9IGNvbW1hbmRfbGlzdFtpXS5jb21tYW5kOworCQlzdHJpbmdfbGlzdF9hcHBlbmQoJmNvbW1hbmRzLml0ZW1zLCBjb21tYW5kX2xpc3RbaV0uc3RyaW5nKQorCQkJLT51dGlsID0gdXRpbDsKKwl9CisKKwlpbml0X2FkZF9pX3N0YXRlKCZzLCByKTsKKworCS8qCisJICogV2hlbiBjb2xvciB3YXMgYXNrZWQgZm9yLCB1c2UgdGhlIHByb21wdCBjb2xvciBmb3IKKwkgKiBoaWdobGlnaHRpbmcsIG90aGVyd2lzZSB1c2Ugc3F1YXJlIGJyYWNrZXRzLgorCSAqLworCWlmIChzLnVzZV9jb2xvcikgeworCQlkYXRhLmNvbG9yID0gcy5wcm9tcHRfY29sb3I7CisJCWRhdGEucmVzZXQgPSBzLnJlc2V0X2NvbG9yOworCX0KKworCXN0cmJ1Zl9hZGRzdHIoJmhlYWRlciwgIiAgICAgICIpOworCXN0cmJ1Zl9hZGRmKCZoZWFkZXIsIHByaW50X2ZpbGVfaXRlbV9kYXRhLm1vZGlmaWVkX2ZtdCwKKwkJICAgIF8oInN0YWdlZCIpLCBfKCJ1bnN0YWdlZCIpLCBfKCJwYXRoIikpOworCW9wdHMuaGVhZGVyID0gaGVhZGVyLmJ1ZjsKKworCWlmIChkaXNjYXJkX2luZGV4KHItPmluZGV4KSA8IDAgfHwKKwkgICAgcmVwb19yZWFkX2luZGV4KHIpIDwgMCB8fAorCSAgICByZXBvX3JlZnJlc2hfYW5kX3dyaXRlX2luZGV4KHIsIFJFRlJFU0hfUVVJRVQsIDAsIDEsCisJCQkJCSBOVUxMLCBOVUxMLCBOVUxMKSA8IDApCisJCXdhcm5pbmcoXygiY291bGQgbm90IHJlZnJlc2ggaW5kZXgiKSk7CisKKwlyZXMgPSBydW5fc3RhdHVzKCZzLCBwcywgJmZpbGVzLCAmb3B0cyk7CisKKwlmb3IgKDs7KSB7CisJCWkgPSBsaXN0X2FuZF9jaG9vc2UoJnMsICZjb21tYW5kcywgJm1haW5fbG9vcF9vcHRzKTsKKwkJaWYgKGkgPT0gTElTVF9BTkRfQ0hPT1NFX1FVSVQpIHsKKwkJCXByaW50ZihfKCJCeWUuXG4iKSk7CisJCQlyZXMgPSAwOworCQkJYnJlYWs7CisJCX0KKwkJaWYgKGkgIT0gTElTVF9BTkRfQ0hPT1NFX0VSUk9SKSB7CisJCQlzdHJ1Y3QgY29tbWFuZF9pdGVtICp1dGlsID0KKwkJCQljb21tYW5kcy5pdGVtcy5pdGVtc1tpXS51dGlsOworCQkJcmVzID0gdXRpbC0+Y29tbWFuZCgmcywgcHMsICZmaWxlcywgJm9wdHMpOworCQl9CisJfQorCisJc3RyaW5nX2xpc3RfY2xlYXIoJmZpbGVzLCAxKTsKKwlzdHJidWZfcmVsZWFzZSgmcHJpbnRfZmlsZV9pdGVtX2RhdGEuYnVmKTsKKwlzdHJidWZfcmVsZWFzZSgmcHJpbnRfZmlsZV9pdGVtX2RhdGEuaW5kZXgpOworCXN0cmJ1Zl9yZWxlYXNlKCZwcmludF9maWxlX2l0ZW1fZGF0YS53b3JrdHJlZSk7CisJc3RyYnVmX3JlbGVhc2UoJmhlYWRlcik7CisJcHJlZml4X2l0ZW1fbGlzdF9jbGVhcigmY29tbWFuZHMpOworCisJcmV0dXJuIHJlczsKK30KZGlmZiAtLWdpdCBhL2FkZC1pbnRlcmFjdGl2ZS5oIGIvYWRkLWludGVyYWN0aXZlLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNzA0M2I4NwotLS0gL2Rldi9udWxsCisrKyBiL2FkZC1pbnRlcmFjdGl2ZS5oCkBAIC0wLDAgKzEsOCBAQAorI2lmbmRlZiBBRERfSU5URVJBQ1RJVkVfSAorI2RlZmluZSBBRERfSU5URVJBQ1RJVkVfSAorCitzdHJ1Y3QgcmVwb3NpdG9yeTsKK3N0cnVjdCBwYXRoc3BlYzsKK2ludCBydW5fYWRkX2koc3RydWN0IHJlcG9zaXRvcnkgKnIsIGNvbnN0IHN0cnVjdCBwYXRoc3BlYyAqcHMpOworCisjZW5kaWYKZGlmZiAtLWdpdCBhL2FwcGx5LmMgYi9hcHBseS5jCmluZGV4IGNkZTk1MzYuLmQ1N2FjMGQgMTAwNjQ0Ci0tLSBhL2FwcGx5LmMKKysrIGIvYXBwbHkuYwpAQCAtMzIsNyArMzIsNyBAQAogewogCWdpdF9jb25maWdfZ2V0X3N0cmluZ19jb25zdCgiYXBwbHkud2hpdGVzcGFjZSIsICZhcHBseV9kZWZhdWx0X3doaXRlc3BhY2UpOwogCWdpdF9jb25maWdfZ2V0X3N0cmluZ19jb25zdCgiYXBwbHkuaWdub3Jld2hpdGVzcGFjZSIsICZhcHBseV9kZWZhdWx0X2lnbm9yZXdoaXRlc3BhY2UpOwotCWdpdF9jb25maWcoZ2l0X2RlZmF1bHRfY29uZmlnLCBOVUxMKTsKKwlnaXRfY29uZmlnKGdpdF94bWVyZ2VfY29uZmlnLCBOVUxMKTsKIH0KIAogc3RhdGljIGludCBwYXJzZV93aGl0ZXNwYWNlX29wdGlvbihzdHJ1Y3QgYXBwbHlfc3RhdGUgKnN0YXRlLCBjb25zdCBjaGFyICpvcHRpb24pCkBAIC0xMzYxLDExICsxMzYxLDMyIEBACiAJCQlpZiAoY2hlY2tfaGVhZGVyX2xpbmUoKmxpbmVuciwgcGF0Y2gpKQogCQkJCXJldHVybiAtMTsKIAkJCWlmIChyZXMgPiAwKQotCQkJCXJldHVybiBvZmZzZXQ7CisJCQkJZ290byBkb25lOwogCQkJYnJlYWs7CiAJCX0KIAl9CiAKK2RvbmU6CisJaWYgKCFwYXRjaC0+b2xkX25hbWUgJiYgIXBhdGNoLT5uZXdfbmFtZSkgeworCQlpZiAoIXBhdGNoLT5kZWZfbmFtZSkgeworCQkJZXJyb3IoUV8oImdpdCBkaWZmIGhlYWRlciBsYWNrcyBmaWxlbmFtZSBpbmZvcm1hdGlvbiB3aGVuIHJlbW92aW5nICIKKwkJCQkgIiVkIGxlYWRpbmcgcGF0aG5hbWUgY29tcG9uZW50IChsaW5lICVkKSIsCisJCQkJICJnaXQgZGlmZiBoZWFkZXIgbGFja3MgZmlsZW5hbWUgaW5mb3JtYXRpb24gd2hlbiByZW1vdmluZyAiCisJCQkJICIlZCBsZWFkaW5nIHBhdGhuYW1lIGNvbXBvbmVudHMgKGxpbmUgJWQpIiwKKwkJCQkgcGFyc2VfaGRyX3N0YXRlLnBfdmFsdWUpLAorCQkJICAgICAgcGFyc2VfaGRyX3N0YXRlLnBfdmFsdWUsICpsaW5lbnIpOworCQkJcmV0dXJuIC0xMjg7CisJCX0KKwkJcGF0Y2gtPm9sZF9uYW1lID0geHN0cmR1cChwYXRjaC0+ZGVmX25hbWUpOworCQlwYXRjaC0+bmV3X25hbWUgPSB4c3RyZHVwKHBhdGNoLT5kZWZfbmFtZSk7CisJfQorCWlmICgoIXBhdGNoLT5uZXdfbmFtZSAmJiAhcGF0Y2gtPmlzX2RlbGV0ZSkgfHwKKwkgICAgKCFwYXRjaC0+b2xkX25hbWUgJiYgIXBhdGNoLT5pc19uZXcpKSB7CisJCWVycm9yKF8oImdpdCBkaWZmIGhlYWRlciBsYWNrcyBmaWxlbmFtZSBpbmZvcm1hdGlvbiAiCisJCQkiKGxpbmUgJWQpIiksICpsaW5lbnIpOworCQlyZXR1cm4gLTEyODsKKwl9CisJcGF0Y2gtPmlzX3RvcGxldmVsX3JlbGF0aXZlID0gMTsKIAlyZXR1cm4gb2Zmc2V0OwogfQogCkBAIC0xNTQ2LDI2ICsxNTY3LDYgQEAKIAkJCQlyZXR1cm4gLTEyODsKIAkJCWlmIChnaXRfaGRyX2xlbiA8PSBsZW4pCiAJCQkJY29udGludWU7Ci0JCQlpZiAoIXBhdGNoLT5vbGRfbmFtZSAmJiAhcGF0Y2gtPm5ld19uYW1lKSB7Ci0JCQkJaWYgKCFwYXRjaC0+ZGVmX25hbWUpIHsKLQkJCQkJZXJyb3IoUV8oImdpdCBkaWZmIGhlYWRlciBsYWNrcyBmaWxlbmFtZSBpbmZvcm1hdGlvbiB3aGVuIHJlbW92aW5nICIKLQkJCQkJCQkiJWQgbGVhZGluZyBwYXRobmFtZSBjb21wb25lbnQgKGxpbmUgJWQpIiwKLQkJCQkJCQkiZ2l0IGRpZmYgaGVhZGVyIGxhY2tzIGZpbGVuYW1lIGluZm9ybWF0aW9uIHdoZW4gcmVtb3ZpbmcgIgotCQkJCQkJCSIlZCBsZWFkaW5nIHBhdGhuYW1lIGNvbXBvbmVudHMgKGxpbmUgJWQpIiwKLQkJCQkJCQlzdGF0ZS0+cF92YWx1ZSksCi0JCQkJCQkgICAgIHN0YXRlLT5wX3ZhbHVlLCBzdGF0ZS0+bGluZW5yKTsKLQkJCQkJcmV0dXJuIC0xMjg7Ci0JCQkJfQotCQkJCXBhdGNoLT5vbGRfbmFtZSA9IHhzdHJkdXAocGF0Y2gtPmRlZl9uYW1lKTsKLQkJCQlwYXRjaC0+bmV3X25hbWUgPSB4c3RyZHVwKHBhdGNoLT5kZWZfbmFtZSk7Ci0JCQl9Ci0JCQlpZiAoKCFwYXRjaC0+bmV3X25hbWUgJiYgIXBhdGNoLT5pc19kZWxldGUpIHx8Ci0JCQkgICAgKCFwYXRjaC0+b2xkX25hbWUgJiYgIXBhdGNoLT5pc19uZXcpKSB7Ci0JCQkJZXJyb3IoXygiZ2l0IGRpZmYgaGVhZGVyIGxhY2tzIGZpbGVuYW1lIGluZm9ybWF0aW9uICIKLQkJCQkJICAgICAiKGxpbmUgJWQpIiksIHN0YXRlLT5saW5lbnIpOwotCQkJCXJldHVybiAtMTI4OwotCQkJfQotCQkJcGF0Y2gtPmlzX3RvcGxldmVsX3JlbGF0aXZlID0gMTsKIAkJCSpoZHJzaXplID0gZ2l0X2hkcl9sZW47CiAJCQlyZXR1cm4gb2Zmc2V0OwogCQl9CkBAIC00MTgyLDggKzQxODMsOCBAQAogCQlvbGRfbmFtZSA9IHNsYXNoX29sZCArIDE7CiAJCW5ld19uYW1lID0gc2xhc2hfbmV3ICsgMTsKIAl9Ci0JLyogcC0+b2xkX25hbWUgdGhydSBvbGRfbmFtZSBpcyB0aGUgY29tbW9uIHByZWZpeCwgYW5kIG9sZF9uYW1lIGFuZCBuZXdfbmFtZQotCSAqIHRocm91Z2ggdGhlIGVuZCBvZiBuYW1lcyBhcmUgcmVuYW1lcworCS8qIHAtPm9sZF9uYW1lIHRocm91Z2ggb2xkX25hbWUgaXMgdGhlIGNvbW1vbiBwcmVmaXgsIGFuZCBvbGRfbmFtZSBhbmQKKwkgKiBuZXdfbmFtZSB0aHJvdWdoIHRoZSBlbmQgb2YgbmFtZXMgYXJlIHJlbmFtZXMKIAkgKi8KIAlpZiAob2xkX25hbWUgIT0gcC0+b2xkX25hbWUpCiAJCXByaW50ZigiICVzICUuKnN7JXMgPT4gJXN9ICglZCUlKVxuIiwgcmVuYW1lY29weSwKQEAgLTQ2NDMsNiArNDY0NCw3IEBACiAJc3RydWN0IHBhdGNoICpsaXN0ID0gTlVMTCwgKipsaXN0cCA9ICZsaXN0OwogCWludCBza2lwcGVkX3BhdGNoID0gMDsKIAlpbnQgcmVzID0gMDsKKwlpbnQgZmx1c2hfYXR0cmlidXRlcyA9IDA7CiAKIAlzdGF0ZS0+cGF0Y2hfaW5wdXRfZmlsZSA9IGZpbGVuYW1lOwogCWlmIChyZWFkX3BhdGNoX2ZpbGUoJmJ1ZiwgZmQpIDwgMCkKQEAgLTQ2NzAsNiArNDY3MiwxNCBAQAogCQkJcGF0Y2hfc3RhdHMoc3RhdGUsIHBhdGNoKTsKIAkJCSpsaXN0cCA9IHBhdGNoOwogCQkJbGlzdHAgPSAmcGF0Y2gtPm5leHQ7CisKKwkJCWlmICgocGF0Y2gtPm5ld19uYW1lICYmCisJCQkgICAgIGVuZHNfd2l0aF9wYXRoX2NvbXBvbmVudHMocGF0Y2gtPm5ld19uYW1lLAorCQkJCQkJICAgICAgIEdJVEFUVFJJQlVURVNfRklMRSkpIHx8CisJCQkgICAgKHBhdGNoLT5vbGRfbmFtZSAmJgorCQkJICAgICBlbmRzX3dpdGhfcGF0aF9jb21wb25lbnRzKHBhdGNoLT5vbGRfbmFtZSwKKwkJCQkJCSAgICAgICBHSVRBVFRSSUJVVEVTX0ZJTEUpKSkKKwkJCQlmbHVzaF9hdHRyaWJ1dGVzID0gMTsKIAkJfQogCQllbHNlIHsKIAkJCWlmIChzdGF0ZS0+YXBwbHlfdmVyYm9zaXR5ID4gdmVyYm9zaXR5X25vcm1hbCkKQEAgLTQ3NDYsNiArNDc1Niw4IEBACiAJaWYgKHN0YXRlLT5zdW1tYXJ5ICYmIHN0YXRlLT5hcHBseV92ZXJib3NpdHkgPiB2ZXJib3NpdHlfc2lsZW50KQogCQlzdW1tYXJ5X3BhdGNoX2xpc3QobGlzdCk7CiAKKwlpZiAoZmx1c2hfYXR0cmlidXRlcykKKwkJcmVzZXRfcGFyc2VkX2F0dHJpYnV0ZXMoKTsKIGVuZDoKIAlmcmVlX3BhdGNoX2xpc3QobGlzdCk7CiAJc3RyYnVmX3JlbGVhc2UoJmJ1Zik7CmRpZmYgLS1naXQgYS9hcHBseS5oIGIvYXBwbHkuaAppbmRleCBhNzk1MTkzLi5kYTNkOTVmIDEwMDY0NAotLS0gYS9hcHBseS5oCisrKyBiL2FwcGx5LmgKQEAgLTEsNiArMSw3IEBACiAjaWZuZGVmIEFQUExZX0gKICNkZWZpbmUgQVBQTFlfSAogCisjaW5jbHVkZSAiaGFzaC5oIgogI2luY2x1ZGUgImxvY2tmaWxlLmgiCiAjaW5jbHVkZSAic3RyaW5nLWxpc3QuaCIKIApkaWZmIC0tZ2l0IGEvYXJjaGl2ZS10YXIuYyBiL2FyY2hpdmUtdGFyLmMKaW5kZXggM2U1M2FhYy4uZTE2ZDNmNyAxMDA2NDQKLS0tIGEvYXJjaGl2ZS10YXIuYworKysgYi9hcmNoaXZlLXRhci5jCkBAIC0xNDIsMTkgKzE0MiwyNSBAQAogICogc3RyaW5nIGFuZCBhcHBlbmRzIGl0IHRvIGEgc3RydWN0IHN0cmJ1Zi4KICAqLwogc3RhdGljIHZvaWQgc3RyYnVmX2FwcGVuZF9leHRfaGVhZGVyKHN0cnVjdCBzdHJidWYgKnNiLCBjb25zdCBjaGFyICprZXl3b3JkLAotCQkJCSAgICAgY29uc3QgY2hhciAqdmFsdWUsIHVuc2lnbmVkIGludCB2YWx1ZWxlbikKKwkJCQkgICAgIGNvbnN0IGNoYXIgKnZhbHVlLCBzaXplX3QgdmFsdWVsZW4pCiB7Ci0JaW50IGxlbiwgdG1wOworCXNpemVfdCBvcmlnX2xlbiA9IHNiLT5sZW47CisJc2l6ZV90IGxlbiwgdG1wOwogCiAJLyogIiV1ICVzPSVzXG4iICovCiAJbGVuID0gMSArIDEgKyBzdHJsZW4oa2V5d29yZCkgKyAxICsgdmFsdWVsZW4gKyAxOwotCWZvciAodG1wID0gbGVuOyB0bXAgPiA5OyB0bXAgLz0gMTApCisJZm9yICh0bXAgPSAxOyBsZW4gLyAxMCA+PSB0bXA7IHRtcCAqPSAxMCkKIAkJbGVuKys7CiAKIAlzdHJidWZfZ3JvdyhzYiwgbGVuKTsKLQlzdHJidWZfYWRkZihzYiwgIiV1ICVzPSIsIGxlbiwga2V5d29yZCk7CisJc3RyYnVmX2FkZGYoc2IsICIlIlBSSXVNQVgiICVzPSIsICh1aW50bWF4X3QpbGVuLCBrZXl3b3JkKTsKIAlzdHJidWZfYWRkKHNiLCB2YWx1ZSwgdmFsdWVsZW4pOwogCXN0cmJ1Zl9hZGRjaChzYiwgJ1xuJyk7CisKKwlpZiAobGVuICE9IHNiLT5sZW4gLSBvcmlnX2xlbikKKwkJQlVHKCJwYXggZXh0ZW5kZWQgaGVhZGVyIGxlbmd0aCBtaXNjYWxjdWxhdGVkIGFzICUiUFJJdU1BWAorCQkgICAgIiwgc2hvdWxkIGJlICUiUFJJdU1BWCwKKwkJICAgICh1aW50bWF4X3QpbGVuLCAodWludG1heF90KShzYi0+bGVuIC0gb3JpZ19sZW4pKTsKIH0KIAogLyoKZGlmZiAtLWdpdCBhL2FyZ3YtYXJyYXkuYyBiL2FyZ3YtYXJyYXkuYwppbmRleCBmMzUyZWE5Li42MWVmOGMwIDEwMDY0NAotLS0gYS9hcmd2LWFycmF5LmMKKysrIGIvYXJndi1hcnJheS5jCkBAIC00Niw3ICs0Niw3IEBACiAJY29uc3QgY2hhciAqYXJnOwogCiAJdmFfc3RhcnQoYXAsIGFycmF5KTsKLQl3aGlsZSgoYXJnID0gdmFfYXJnKGFwLCBjb25zdCBjaGFyICopKSkKKwl3aGlsZSAoKGFyZyA9IHZhX2FyZyhhcCwgY29uc3QgY2hhciAqKSkpCiAJCWFyZ3ZfYXJyYXlfcHVzaChhcnJheSwgYXJnKTsKIAl2YV9lbmQoYXApOwogfQpkaWZmIC0tZ2l0IGEvYXR0ci5jIGIvYXR0ci5jCmluZGV4IDkzZGMxNmIuLjExZjE5YjUgMTAwNjQ0Ci0tLSBhL2F0dHIuYworKysgYi9hdHRyLmMKQEAgLTYyLDcgKzYyLDcgQEAKIAogLyogVGhlIGNvbnRhaW5lciBmb3Igb2JqZWN0cyBzdG9yZWQgaW4gInN0cnVjdCBhdHRyX2hhc2htYXAiICovCiBzdHJ1Y3QgYXR0cl9oYXNoX2VudHJ5IHsKLQlzdHJ1Y3QgaGFzaG1hcF9lbnRyeSBlbnQ7IC8qIG11c3QgYmUgdGhlIGZpcnN0IG1lbWJlciEgKi8KKwlzdHJ1Y3QgaGFzaG1hcF9lbnRyeSBlbnQ7CiAJY29uc3QgY2hhciAqa2V5OyAvKiB0aGUga2V5OyBtZW1vcnkgc2hvdWxkIGJlIG93bmVkIGJ5IHZhbHVlICovCiAJc2l6ZV90IGtleWxlbjsgLyogbGVuZ3RoIG9mIHRoZSBrZXkgKi8KIAl2b2lkICp2YWx1ZTsgLyogdGhlIHN0b3JlZCB2YWx1ZSAqLwpAQCAtNzAsMTIgKzcwLDE0IEBACiAKIC8qIGF0dHJfaGFzaG1hcCBjb21wYXJpc29uIGZ1bmN0aW9uICovCiBzdGF0aWMgaW50IGF0dHJfaGFzaF9lbnRyeV9jbXAoY29uc3Qgdm9pZCAqdW51c2VkX2NtcF9kYXRhLAotCQkJICAgICAgIGNvbnN0IHZvaWQgKmVudHJ5LAotCQkJICAgICAgIGNvbnN0IHZvaWQgKmVudHJ5X29yX2tleSwKKwkJCSAgICAgICBjb25zdCBzdHJ1Y3QgaGFzaG1hcF9lbnRyeSAqZXB0ciwKKwkJCSAgICAgICBjb25zdCBzdHJ1Y3QgaGFzaG1hcF9lbnRyeSAqZW50cnlfb3Jfa2V5LAogCQkJICAgICAgIGNvbnN0IHZvaWQgKnVudXNlZF9rZXlkYXRhKQogewotCWNvbnN0IHN0cnVjdCBhdHRyX2hhc2hfZW50cnkgKmEgPSBlbnRyeTsKLQljb25zdCBzdHJ1Y3QgYXR0cl9oYXNoX2VudHJ5ICpiID0gZW50cnlfb3Jfa2V5OworCWNvbnN0IHN0cnVjdCBhdHRyX2hhc2hfZW50cnkgKmEsICpiOworCisJYSA9IGNvbnRhaW5lcl9vZihlcHRyLCBjb25zdCBzdHJ1Y3QgYXR0cl9oYXNoX2VudHJ5LCBlbnQpOworCWIgPSBjb250YWluZXJfb2YoZW50cnlfb3Jfa2V5LCBjb25zdCBzdHJ1Y3QgYXR0cl9oYXNoX2VudHJ5LCBlbnQpOwogCXJldHVybiAoYS0+a2V5bGVuICE9IGItPmtleWxlbikgfHwgc3RybmNtcChhLT5rZXksIGItPmtleSwgYS0+a2V5bGVuKTsKIH0KIApAQCAtOTgsMTAgKzEwMCwxMCBAQAogCWlmICghbWFwLT5tYXAudGFibGVzaXplKQogCQlhdHRyX2hhc2htYXBfaW5pdChtYXApOwogCi0JaGFzaG1hcF9lbnRyeV9pbml0KCZrLCBtZW1oYXNoKGtleSwga2V5bGVuKSk7CisJaGFzaG1hcF9lbnRyeV9pbml0KCZrLmVudCwgbWVtaGFzaChrZXksIGtleWxlbikpOwogCWsua2V5ID0ga2V5OwogCWsua2V5bGVuID0ga2V5bGVuOwotCWUgPSBoYXNobWFwX2dldCgmbWFwLT5tYXAsICZrLCBOVUxMKTsKKwllID0gaGFzaG1hcF9nZXRfZW50cnkoJm1hcC0+bWFwLCAmaywgZW50LCBOVUxMKTsKIAogCXJldHVybiBlID8gZS0+dmFsdWUgOiBOVUxMOwogfQpAQCAtMTE3LDEyICsxMTksMTIgQEAKIAkJYXR0cl9oYXNobWFwX2luaXQobWFwKTsKIAogCWUgPSB4bWFsbG9jKHNpemVvZihzdHJ1Y3QgYXR0cl9oYXNoX2VudHJ5KSk7Ci0JaGFzaG1hcF9lbnRyeV9pbml0KGUsIG1lbWhhc2goa2V5LCBrZXlsZW4pKTsKKwloYXNobWFwX2VudHJ5X2luaXQoJmUtPmVudCwgbWVtaGFzaChrZXksIGtleWxlbikpOwogCWUtPmtleSA9IGtleTsKIAllLT5rZXlsZW4gPSBrZXlsZW47CiAJZS0+dmFsdWUgPSB2YWx1ZTsKIAotCWhhc2htYXBfYWRkKCZtYXAtPm1hcCwgZSk7CisJaGFzaG1hcF9hZGQoJm1hcC0+bWFwLCAmZS0+ZW50KTsKIH0KIAogc3RydWN0IGFsbF9hdHRyc19pdGVtIHsKQEAgLTE2MSwxMiArMTYzLDEyIEBACiAJaWYgKHNpemUgIT0gY2hlY2stPmFsbF9hdHRyc19ucikgewogCQlzdHJ1Y3QgYXR0cl9oYXNoX2VudHJ5ICplOwogCQlzdHJ1Y3QgaGFzaG1hcF9pdGVyIGl0ZXI7Ci0JCWhhc2htYXBfaXRlcl9pbml0KCZtYXAtPm1hcCwgJml0ZXIpOwogCiAJCVJFQUxMT0NfQVJSQVkoY2hlY2stPmFsbF9hdHRycywgc2l6ZSk7CiAJCWNoZWNrLT5hbGxfYXR0cnNfbnIgPSBzaXplOwogCi0JCXdoaWxlICgoZSA9IGhhc2htYXBfaXRlcl9uZXh0KCZpdGVyKSkpIHsKKwkJaGFzaG1hcF9mb3JfZWFjaF9lbnRyeSgmbWFwLT5tYXAsICZpdGVyLCBlLAorCQkJCQllbnQgLyogbWVtYmVyIG5hbWUgKi8pIHsKIAkJCWNvbnN0IHN0cnVjdCBnaXRfYXR0ciAqYSA9IGUtPnZhbHVlOwogCQkJY2hlY2stPmFsbF9hdHRyc1thLT5hdHRyX25yXS5hdHRyID0gYTsKIAkJfQpAQCAtMjU5LDcgKzI2MSw3IEBACiAJY29uc3QgY2hhciAqcGF0dGVybjsKIAlpbnQgcGF0dGVybmxlbjsKIAlpbnQgbm93aWxkY2FyZGxlbjsKLQl1bnNpZ25lZCBmbGFnczsJCS8qIEVYQ19GTEFHXyogKi8KKwl1bnNpZ25lZCBmbGFnczsJCS8qIFBBVFRFUk5fRkxBR18qICovCiB9OwogCiAvKgpAQCAtNDAwLDExICs0MDIsMTEgQEAKIAkJY2hhciAqcCA9IChjaGFyICopJihyZXMtPnN0YXRlW251bV9hdHRyXSk7CiAJCW1lbWNweShwLCBuYW1lLCBuYW1lbGVuKTsKIAkJcmVzLT51LnBhdC5wYXR0ZXJuID0gcDsKLQkJcGFyc2VfZXhjbHVkZV9wYXR0ZXJuKCZyZXMtPnUucGF0LnBhdHRlcm4sCisJCXBhcnNlX3BhdGhfcGF0dGVybigmcmVzLT51LnBhdC5wYXR0ZXJuLAogCQkJCSAgICAgICZyZXMtPnUucGF0LnBhdHRlcm5sZW4sCiAJCQkJICAgICAgJnJlcy0+dS5wYXQuZmxhZ3MsCiAJCQkJICAgICAgJnJlcy0+dS5wYXQubm93aWxkY2FyZGxlbik7Ci0JCWlmIChyZXMtPnUucGF0LmZsYWdzICYgRVhDX0ZMQUdfTkVHQVRJVkUpIHsKKwkJaWYgKHJlcy0+dS5wYXQuZmxhZ3MgJiBQQVRURVJOX0ZMQUdfTkVHQVRJVkUpIHsKIAkJCXdhcm5pbmcoXygiTmVnYXRpdmUgcGF0dGVybnMgYXJlIGlnbm9yZWQgaW4gZ2l0IGF0dHJpYnV0ZXNcbiIKIAkJCQkgICJVc2UgJ1xcIScgZm9yIGxpdGVyYWwgbGVhZGluZyBleGNsYW1hdGlvbi4iKSk7CiAJCQlnb3RvIGZhaWxfcmV0dXJuOwpAQCAtOTkxLDEwICs5OTMsMTAgQEAKIAlpbnQgcHJlZml4ID0gcGF0LT5ub3dpbGRjYXJkbGVuOwogCWludCBpc2RpciA9IChwYXRobGVuICYmIHBhdGhuYW1lW3BhdGhsZW4gLSAxXSA9PSAnLycpOwogCi0JaWYgKChwYXQtPmZsYWdzICYgRVhDX0ZMQUdfTVVTVEJFRElSKSAmJiAhaXNkaXIpCisJaWYgKChwYXQtPmZsYWdzICYgUEFUVEVSTl9GTEFHX01VU1RCRURJUikgJiYgIWlzZGlyKQogCQlyZXR1cm4gMDsKIAotCWlmIChwYXQtPmZsYWdzICYgRVhDX0ZMQUdfTk9ESVIpIHsKKwlpZiAocGF0LT5mbGFncyAmIFBBVFRFUk5fRkxBR19OT0RJUikgewogCQlyZXR1cm4gbWF0Y2hfYmFzZW5hbWUocGF0aG5hbWUgKyBiYXNlbmFtZV9vZmZzZXQsCiAJCQkJICAgICAgcGF0aGxlbiAtIGJhc2VuYW1lX29mZnNldCAtIGlzZGlyLAogCQkJCSAgICAgIHBhdHRlcm4sIHByZWZpeCwKZGlmZiAtLWdpdCBhL2F6dXJlLXBpcGVsaW5lcy55bWwgYi9henVyZS1waXBlbGluZXMueW1sCmluZGV4IGMzMjliNzIuLmFmMmE1ZWEgMTAwNjQ0Ci0tLSBhL2F6dXJlLXBpcGVsaW5lcy55bWwKKysrIGIvYXp1cmUtcGlwZWxpbmVzLnltbApAQCAtMSw2ICsxLDUgQEAKLXJlc291cmNlczoKLS0gcmVwbzogc2VsZgotICBmZXRjaERlcHRoOiAxCit2YXJpYWJsZXM6CisgIEFnZW50LlNvdXJjZS5HaXQuU2hhbGxvd0ZldGNoRGVwdGg6IDEKIAogam9iczoKIC0gam9iOiB3aW5kb3dzX2J1aWxkCkBAIC0xMzEsNiArMTMwLDE2NSBAQAogICAgICAgUGF0aHRvUHVibGlzaDogdC9mYWlsZWQtdGVzdC1hcnRpZmFjdHMKICAgICAgIEFydGlmYWN0TmFtZTogZmFpbGVkLXRlc3QtYXJ0aWZhY3RzCiAKKy0gam9iOiB2c19idWlsZAorICBkaXNwbGF5TmFtZTogVmlzdWFsIFN0dWRpbyBCdWlsZAorICBjb25kaXRpb246IHN1Y2NlZWRlZCgpCisgIHBvb2w6IEhvc3RlZCBWUzIwMTcKKyAgdGltZW91dEluTWludXRlczogMjQwCisgIHN0ZXBzOgorICAtIHBvd2Vyc2hlbGw6IHwKKyAgICAgIGlmICgiJEdJVEZJTEVTSEFSRVBXRCIgLW5lICIiIC1hbmQgIiRHSVRGSUxFU0hBUkVQV0QiIC1uZSAiYCRgKGdpdGZpbGVzaGFyZS5wd2QpIikgeworICAgICAgICBuZXQgdXNlIHM6IFxcZ2l0ZmlsZXNoYXJlLmZpbGUuY29yZS53aW5kb3dzLm5ldFx0ZXN0LWNhY2hlICIkR0lURklMRVNIQVJFUFdEIiAvdXNlcjpBWlVSRVxnaXRmaWxlc2hhcmUgL3BlcnNpc3RlbnQ6bm8KKyAgICAgICAgY21kIC9jIG1rbGluayAvZCAiJChCdWlsZC5Tb3VyY2VzRGlyZWN0b3J5KVx0ZXN0LWNhY2hlIiBTOlwKKyAgICAgIH0KKyAgICBkaXNwbGF5TmFtZTogJ01vdW50IHRlc3QtY2FjaGUnCisgICAgZW52OgorICAgICAgR0lURklMRVNIQVJFUFdEOiAkKGdpdGZpbGVzaGFyZS5wd2QpCisgIC0gcG93ZXJzaGVsbDogfAorICAgICAgJHVybGJhc2UgPSAiaHR0cHM6Ly9kZXYuYXp1cmUuY29tL2dpdC1mb3Itd2luZG93cy9naXQvX2FwaXMvYnVpbGQvYnVpbGRzIgorICAgICAgJGlkID0gKChJbnZva2UtV2ViUmVxdWVzdCAtVXNlQmFzaWNQYXJzaW5nICIke3VybGJhc2V9P2RlZmluaXRpb25zPTIyJnN0YXR1c0ZpbHRlcj1jb21wbGV0ZWQmcmVzdWx0RmlsdGVyPXN1Y2NlZWRlZCZgJHRvcD0xIikuY29udGVudCB8IENvbnZlcnRGcm9tLUpTT04pLnZhbHVlWzBdLmlkCisgICAgICAkZG93bmxvYWRVcmwgPSAoKEludm9rZS1XZWJSZXF1ZXN0IC1Vc2VCYXNpY1BhcnNpbmcgIiR7dXJsYmFzZX0vJGlkL2FydGlmYWN0cyIpLmNvbnRlbnQgfCBDb252ZXJ0RnJvbS1KU09OKS52YWx1ZVsxXS5yZXNvdXJjZS5kb3dubG9hZFVybAorICAgICAgKE5ldy1PYmplY3QgTmV0LldlYkNsaWVudCkuRG93bmxvYWRGaWxlKCRkb3dubG9hZFVybCwiZ2l0LXNkay02NC1taW5pbWFsLnppcCIpCisgICAgICBFeHBhbmQtQXJjaGl2ZSBnaXQtc2RrLTY0LW1pbmltYWwuemlwIC1EZXN0aW5hdGlvblBhdGggLiAtRm9yY2UKKyAgICAgIFJlbW92ZS1JdGVtIGdpdC1zZGstNjQtbWluaW1hbC56aXAKKworICAgICAgIyBMZXQgR2l0IGlnbm9yZSB0aGUgU0RLIGFuZCB0aGUgdGVzdC1jYWNoZQorICAgICAgIi9naXQtc2RrLTY0LW1pbmltYWwvYG4vdGVzdC1jYWNoZS9gbiIgfCBPdXQtRmlsZSAtTm9OZXdMaW5lIC1FbmNvZGluZyBhc2NpaSAtQXBwZW5kICIkKEJ1aWxkLlNvdXJjZXNEaXJlY3RvcnkpXC5naXRcaW5mb1xleGNsdWRlIgorICAgIGRpc3BsYXlOYW1lOiAnRG93bmxvYWQgZ2l0LXNkay02NC1taW5pbWFsJworICAtIHBvd2Vyc2hlbGw6IHwKKyAgICAgICYgZ2l0LXNkay02NC1taW5pbWFsXHVzclxiaW5cYmFzaC5leGUgLWxjIEAiCisgICAgICAgIG1ha2UgTkRFQlVHPTEgREVWRUxPUEVSPTEgdmN4cHJvagorICAgICAgIkAKKyAgICAgIGlmICghJD8pIHsgZXhpdCgxKSB9CisgICAgZGlzcGxheU5hbWU6IEdlbmVyYXRlIFZpc3VhbCBTdHVkaW8gU29sdXRpb24KKyAgICBlbnY6CisgICAgICBIT01FOiAkKEJ1aWxkLlNvdXJjZXNEaXJlY3RvcnkpCisgICAgICBNU1lTVEVNOiBNSU5HVzY0CisgICAgICBERVZFTE9QRVI6IDEKKyAgICAgIE5PX1BFUkw6IDEKKyAgICAgIEdJVF9DT05GSUdfUEFSQU1FVEVSUzogIid1c2VyLm5hbWU9Q0knICd1c2VyLmVtYWlsPWNpQGdpdCciCisgIC0gcG93ZXJzaGVsbDogfAorICAgICAgJHVybGJhc2UgPSAiaHR0cHM6Ly9kZXYuYXp1cmUuY29tL2dpdC9naXQvX2FwaXMvYnVpbGQvYnVpbGRzIgorICAgICAgJGlkID0gKChJbnZva2UtV2ViUmVxdWVzdCAtVXNlQmFzaWNQYXJzaW5nICIke3VybGJhc2V9P2RlZmluaXRpb25zPTkmc3RhdHVzRmlsdGVyPWNvbXBsZXRlZCZyZXN1bHRGaWx0ZXI9c3VjY2VlZGVkJmAkdG9wPTEiKS5jb250ZW50IHwgQ29udmVydEZyb20tSlNPTikudmFsdWVbMF0uaWQKKyAgICAgICRkb3dubG9hZFVybCA9ICgoSW52b2tlLVdlYlJlcXVlc3QgLVVzZUJhc2ljUGFyc2luZyAiJHt1cmxiYXNlfS8kaWQvYXJ0aWZhY3RzIikuY29udGVudCB8IENvbnZlcnRGcm9tLUpTT04pLnZhbHVlWzBdLnJlc291cmNlLmRvd25sb2FkVXJsCisgICAgICAoTmV3LU9iamVjdCBOZXQuV2ViQ2xpZW50KS5Eb3dubG9hZEZpbGUoJGRvd25sb2FkVXJsLCAiY29tcGF0LnppcCIpCisgICAgICBFeHBhbmQtQXJjaGl2ZSBjb21wYXQuemlwIC1EZXN0aW5hdGlvblBhdGggLiAtRm9yY2UKKyAgICAgIFJlbW92ZS1JdGVtIGNvbXBhdC56aXAKKyAgICBkaXNwbGF5TmFtZTogJ0Rvd25sb2FkIHZjcGtnIGFydGlmYWN0cycKKyAgLSB0YXNrOiBNU0J1aWxkQDEKKyAgICBpbnB1dHM6CisgICAgICBzb2x1dGlvbjogZ2l0LnNsbgorICAgICAgcGxhdGZvcm06IHg2NAorICAgICAgY29uZmlndXJhdGlvbjogUmVsZWFzZQorICAgICAgbWF4aW11bUNwdUNvdW50OiA0CisgIC0gcG93ZXJzaGVsbDogfAorICAgICAgJiBjb21wYXRcdmNidWlsZFx2Y3BrZ19jb3B5X2RsbHMuYmF0IHJlbGVhc2UKKyAgICAgIGlmICghJD8pIHsgZXhpdCgxKSB9CisgICAgICAmIGdpdC1zZGstNjQtbWluaW1hbFx1c3JcYmluXGJhc2guZXhlIC1sYyBAIgorICAgICAgICBta2RpciAtcCBhcnRpZmFjdHMgJiYKKyAgICAgICAgZXZhbCBcImAkKG1ha2UgLW4gYXJ0aWZhY3RzLXRhciBJTkNMVURFX0RMTFNfSU5fQVJUSUZBQ1RTPVllc1BsZWFzZSBBUlRJRkFDVFNfRElSRUNUT1JZPWFydGlmYWN0cyB8IGdyZXAgXnRhcilcIgorICAgICAgIkAKKyAgICAgIGlmICghJD8pIHsgZXhpdCgxKSB9CisgICAgZGlzcGxheU5hbWU6IEJ1bmRsZSBhcnRpZmFjdCB0YXIKKyAgICBlbnY6CisgICAgICBIT01FOiAkKEJ1aWxkLlNvdXJjZXNEaXJlY3RvcnkpCisgICAgICBNU1lTVEVNOiBNSU5HVzY0CisgICAgICBERVZFTE9QRVI6IDEKKyAgICAgIE5PX1BFUkw6IDEKKyAgICAgIE1TVkM6IDEKKyAgICAgIFZDUEtHX1JPT1Q6ICQoQnVpbGQuU291cmNlc0RpcmVjdG9yeSlcY29tcGF0XHZjYnVpbGRcdmNwa2cKKyAgLSBwb3dlcnNoZWxsOiB8CisgICAgICAkdGFnID0gKEludm9rZS1XZWJSZXF1ZXN0IC1Vc2VCYXNpY1BhcnNpbmcgImh0dHBzOi8vZ2l0Zm9yd2luZG93cy5vcmcvbGF0ZXN0LXRhZy50eHQiKS5jb250ZW50CisgICAgICAkdmVyc2lvbiA9IChJbnZva2UtV2ViUmVxdWVzdCAtVXNlQmFzaWNQYXJzaW5nICJodHRwczovL2dpdGZvcndpbmRvd3Mub3JnL2xhdGVzdC12ZXJzaW9uLnR4dCIpLmNvbnRlbnQKKyAgICAgICR1cmwgPSAiaHR0cHM6Ly9naXRodWIuY29tL2dpdC1mb3Itd2luZG93cy9naXQvcmVsZWFzZXMvZG93bmxvYWQvJHt0YWd9L1BvcnRhYmxlR2l0LSR7dmVyc2lvbn0tNjQtYml0Ljd6LmV4ZSIKKyAgICAgIChOZXctT2JqZWN0IE5ldC5XZWJDbGllbnQpLkRvd25sb2FkRmlsZSgkdXJsLCJQb3J0YWJsZUdpdC5leGUiKQorICAgICAgJiAuXFBvcnRhYmxlR2l0LmV4ZSAteSAtb2FydGlmYWN0c1xQb3J0YWJsZUdpdAorICAgICAgIyBXYWl0IHVudGlsIGl0IGlzIHVucGFja2VkCisgICAgICB3aGlsZSAoLW5vdCBAKFJlbW92ZS1JdGVtIC1FcnJvckFjdGlvbiBTaWxlbnRseUNvbnRpbnVlIFBvcnRhYmxlR2l0LmV4ZTsgJD8pKSB7IHNsZWVwIDEgfQorICAgIGRpc3BsYXlOYW1lOiBEb3dubG9hZCAmIGV4dHJhY3QgcG9ydGFibGUgR2l0CisgIC0gdGFzazogUHVibGlzaFBpcGVsaW5lQXJ0aWZhY3RAMAorICAgIGRpc3BsYXlOYW1lOiAnUHVibGlzaCBQaXBlbGluZSBBcnRpZmFjdDogTVNWQyB0ZXN0IGFydGlmYWN0cycKKyAgICBpbnB1dHM6CisgICAgICBhcnRpZmFjdE5hbWU6ICd2cy1hcnRpZmFjdHMnCisgICAgICB0YXJnZXRQYXRoOiAnJChCdWlsZC5Tb3VyY2VzRGlyZWN0b3J5KVxhcnRpZmFjdHMnCisgIC0gcG93ZXJzaGVsbDogfAorICAgICAgaWYgKCIkR0lURklMRVNIQVJFUFdEIiAtbmUgIiIgLWFuZCAiJEdJVEZJTEVTSEFSRVBXRCIgLW5lICJgJGAoZ2l0ZmlsZXNoYXJlLnB3ZCkiKSB7CisgICAgICAgIGNtZCAvYyBybWRpciAiJChCdWlsZC5Tb3VyY2VzRGlyZWN0b3J5KVx0ZXN0LWNhY2hlIgorICAgICAgfQorICAgIGRpc3BsYXlOYW1lOiAnVW5tb3VudCB0ZXN0LWNhY2hlJworICAgIGNvbmRpdGlvbjogdHJ1ZQorICAgIGVudjoKKyAgICAgIEdJVEZJTEVTSEFSRVBXRDogJChnaXRmaWxlc2hhcmUucHdkKQorCistIGpvYjogdnNfdGVzdAorICBkaXNwbGF5TmFtZTogVmlzdWFsIFN0dWRpbyBUZXN0CisgIGRlcGVuZHNPbjogdnNfYnVpbGQKKyAgY29uZGl0aW9uOiBzdWNjZWVkZWQoKQorICBwb29sOiBIb3N0ZWQKKyAgdGltZW91dEluTWludXRlczogMjQwCisgIHN0cmF0ZWd5OgorICAgIHBhcmFsbGVsOiAxMAorICBzdGVwczoKKyAgLSBwb3dlcnNoZWxsOiB8CisgICAgICBpZiAoIiRHSVRGSUxFU0hBUkVQV0QiIC1uZSAiIiAtYW5kICIkR0lURklMRVNIQVJFUFdEIiAtbmUgImAkYChnaXRmaWxlc2hhcmUucHdkKSIpIHsKKyAgICAgICAgbmV0IHVzZSBzOiBcXGdpdGZpbGVzaGFyZS5maWxlLmNvcmUud2luZG93cy5uZXRcdGVzdC1jYWNoZSAiJEdJVEZJTEVTSEFSRVBXRCIgL3VzZXI6QVpVUkVcZ2l0ZmlsZXNoYXJlIC9wZXJzaXN0ZW50Om5vCisgICAgICAgIGNtZCAvYyBta2xpbmsgL2QgIiQoQnVpbGQuU291cmNlc0RpcmVjdG9yeSlcdGVzdC1jYWNoZSIgUzpcCisgICAgICB9CisgICAgZGlzcGxheU5hbWU6ICdNb3VudCB0ZXN0LWNhY2hlJworICAgIGVudjoKKyAgICAgIEdJVEZJTEVTSEFSRVBXRDogJChnaXRmaWxlc2hhcmUucHdkKQorICAtIHRhc2s6IERvd25sb2FkUGlwZWxpbmVBcnRpZmFjdEAwCisgICAgZGlzcGxheU5hbWU6ICdEb3dubG9hZCBQaXBlbGluZSBBcnRpZmFjdDogVlMgdGVzdCBhcnRpZmFjdHMnCisgICAgaW5wdXRzOgorICAgICAgYXJ0aWZhY3ROYW1lOiAndnMtYXJ0aWZhY3RzJworICAgICAgdGFyZ2V0UGF0aDogJyQoQnVpbGQuU291cmNlc0RpcmVjdG9yeSknCisgIC0gcG93ZXJzaGVsbDogfAorICAgICAgJiBQb3J0YWJsZUdpdFxnaXQtY21kLmV4ZSAtLWNvbW1hbmQ9dXNyXGJpblxiYXNoLmV4ZSAtbGMgQCIKKyAgICAgICAgdGVzdCAtZiBhcnRpZmFjdHMudGFyLmd6IHx8IHsKKyAgICAgICAgICBlY2hvIE5vIHRlc3QgYXJ0aWZhY3RzIGZvdW5kXDsgc2tpcHBpbmcgPiYyCisgICAgICAgICAgZXhpdCAwCisgICAgICAgIH0KKyAgICAgICAgdGFyIHhmIGFydGlmYWN0cy50YXIuZ3ogfHwgZXhpdCAxCisKKyAgICAgICAgIyBMZXQgR2l0IGlnbm9yZSB0aGUgU0RLIGFuZCB0aGUgdGVzdC1jYWNoZQorICAgICAgICBwcmludGYgJyVzXG4nIC9Qb3J0YWJsZUdpdC8gL3Rlc3QtY2FjaGUvID4+LmdpdC9pbmZvL2V4Y2x1ZGUKKworICAgICAgICBjZCB0ICYmCisgICAgICAgIFBBVEg9XCJgJFBXRC9oZWxwZXI6YCRQQVRIXCIgJiYKKyAgICAgICAgdGVzdC10b29sLmV4ZSBydW4tY29tbWFuZCB0ZXN0c3VpdGUgLS1qb2JzPTEwIC1WIC14IC0td3JpdGUtanVuaXQteG1sIFwKKyAgICAgICAgICAgICAgICBgJCh0ZXN0LXRvb2wuZXhlIHBhdGgtdXRpbHMgc2xpY2UtdGVzdHMgXAorICAgICAgICAgICAgICAgICAgICAgICAgYCRTWVNURU1fSk9CUE9TSVRJT05JTlBIQVNFIGAkU1lTVEVNX1RPVEFMSk9CU0lOUEhBU0UgdFswLTldKi5zaCkKKyAgICAgICJACisgICAgICBpZiAoISQ/KSB7IGV4aXQoMSkgfQorICAgIGRpc3BsYXlOYW1lOiAnVGVzdCAocGFyYWxsZWwpJworICAgIGVudjoKKyAgICAgIEhPTUU6ICQoQnVpbGQuU291cmNlc0RpcmVjdG9yeSkKKyAgICAgIE1TWVNURU06IE1JTkdXNjQKKyAgICAgIE5PX1NWTl9URVNUUzogMQorICAgICAgR0lUX1RFU1RfU0tJUF9SRUJBU0VfUDogMQorICAtIHBvd2Vyc2hlbGw6IHwKKyAgICAgIGlmICgiJEdJVEZJTEVTSEFSRVBXRCIgLW5lICIiIC1hbmQgIiRHSVRGSUxFU0hBUkVQV0QiIC1uZSAiYCRgKGdpdGZpbGVzaGFyZS5wd2QpIikgeworICAgICAgICBjbWQgL2Mgcm1kaXIgIiQoQnVpbGQuU291cmNlc0RpcmVjdG9yeSlcdGVzdC1jYWNoZSIKKyAgICAgIH0KKyAgICBkaXNwbGF5TmFtZTogJ1VubW91bnQgdGVzdC1jYWNoZScKKyAgICBjb25kaXRpb246IHRydWUKKyAgICBlbnY6CisgICAgICBHSVRGSUxFU0hBUkVQV0Q6ICQoZ2l0ZmlsZXNoYXJlLnB3ZCkKKyAgLSB0YXNrOiBQdWJsaXNoVGVzdFJlc3VsdHNAMgorICAgIGRpc3BsYXlOYW1lOiAnUHVibGlzaCBUZXN0IFJlc3VsdHMgKiovVEVTVC0qLnhtbCcKKyAgICBpbnB1dHM6CisgICAgICBtZXJnZVRlc3RSZXN1bHRzOiB0cnVlCisgICAgICB0ZXN0UnVuVGl0bGU6ICd2cycKKyAgICAgIHBsYXRmb3JtOiBXaW5kb3dzCisgICAgICBwdWJsaXNoUnVuQXR0YWNobWVudHM6IGZhbHNlCisgICAgY29uZGl0aW9uOiBzdWNjZWVkZWRPckZhaWxlZCgpCisgIC0gdGFzazogUHVibGlzaEJ1aWxkQXJ0aWZhY3RzQDEKKyAgICBkaXNwbGF5TmFtZTogJ1B1Ymxpc2ggdHJhc2ggZGlyZWN0b3JpZXMgb2YgZmFpbGVkIHRlc3RzJworICAgIGNvbmRpdGlvbjogZmFpbGVkKCkKKyAgICBpbnB1dHM6CisgICAgICBQYXRodG9QdWJsaXNoOiB0L2ZhaWxlZC10ZXN0LWFydGlmYWN0cworICAgICAgQXJ0aWZhY3ROYW1lOiBmYWlsZWQtdnMtdGVzdC1hcnRpZmFjdHMKKwogLSBqb2I6IGxpbnV4X2NsYW5nCiAgIGRpc3BsYXlOYW1lOiBsaW51eC1jbGFuZwogICBjb25kaXRpb246IHN1Y2NlZWRlZCgpCkBAIC0zNTQsNyArNTEyLDcgQEAKICAgICAgICB0ZXN0ICIkR0lURklMRVNIQVJFUFdEIiA9ICckKGdpdGZpbGVzaGFyZS5wd2QpJyB8fCBjaS9tb3VudC1maWxlc2hhcmUuc2ggLy9naXRmaWxlc2hhcmUuZmlsZS5jb3JlLndpbmRvd3MubmV0L3Rlc3QtY2FjaGUgZ2l0ZmlsZXNoYXJlICIkR0lURklMRVNIQVJFUFdEIiAiJEhPTUUvdGVzdC1jYWNoZSIgfHwgZXhpdCAxCiAKICAgICAgICBzdWRvIGFwdC1nZXQgdXBkYXRlICYmCi0gICAgICAgc3VkbyBhcHQtZ2V0IGluc3RhbGwgLXkgY29jY2luZWxsZSAmJgorICAgICAgIHN1ZG8gYXB0LWdldCBpbnN0YWxsIC15IGNvY2NpbmVsbGUgbGliY3VybDQtb3BlbnNzbC1kZXYgbGlic3NsLWRldiBsaWJleHBhdC1kZXYgZ2V0dGV4dCAmJgogCiAgICAgICAgZXhwb3J0IGpvYm5hbWU9U3RhdGljQW5hbHlzaXMgJiYKIApAQCAtMzc0LDcgKzUzMiw3IEBACiAgICAgICAgdGVzdCAiJEdJVEZJTEVTSEFSRVBXRCIgPSAnJChnaXRmaWxlc2hhcmUucHdkKScgfHwgY2kvbW91bnQtZmlsZXNoYXJlLnNoIC8vZ2l0ZmlsZXNoYXJlLmZpbGUuY29yZS53aW5kb3dzLm5ldC90ZXN0LWNhY2hlIGdpdGZpbGVzaGFyZSAiJEdJVEZJTEVTSEFSRVBXRCIgIiRIT01FL3Rlc3QtY2FjaGUiIHx8IGV4aXQgMQogCiAgICAgICAgc3VkbyBhcHQtZ2V0IHVwZGF0ZSAmJgotICAgICAgIHN1ZG8gYXB0LWdldCBpbnN0YWxsIC15IGFzY2lpZG9jIHhtbHRvIGFzY2lpZG9jdG9yICYmCisgICAgICAgc3VkbyBhcHQtZ2V0IGluc3RhbGwgLXkgYXNjaWlkb2MgeG1sdG8gYXNjaWlkb2N0b3IgZG9jYm9vay14c2wtbnMgJiYKIAogICAgICAgIGV4cG9ydCBBTFJFQURZX0hBVkVfQVNDSUlET0NUT1I9eWVzLiAmJgogICAgICAgIGV4cG9ydCBqb2JuYW1lPURvY3VtZW50YXRpb24gJiYKZGlmZiAtLWdpdCBhL2Jhbm5lZC5oIGIvYmFubmVkLmgKaW5kZXggNDQ3YWYyNC4uNjBhMThkNCAxMDA2NDQKLS0tIGEvYmFubmVkLmgKKysrIGIvYmFubmVkLmgKQEAgLTI2LDcgKzI2LDcgQEAKICNkZWZpbmUgdnNwcmludGYoLi4uKSBCQU5ORUQodnNwcmludGYpCiAjZWxzZQogI2RlZmluZSBzcHJpbnRmKGJ1ZixmbXQsYXJnKSBCQU5ORUQoc3ByaW50ZikKLSNkZWZpbmUgdnNwcmludGYoYnVmLGZtdCxhcmcpIEJBTk5FRChzcHJpbnRmKQorI2RlZmluZSB2c3ByaW50ZihidWYsZm10LGFyZykgQkFOTkVEKHZzcHJpbnRmKQogI2VuZGlmCiAKICNlbmRpZiAvKiBCQU5ORURfSCAqLwpkaWZmIC0tZ2l0IGEvYmlzZWN0LmMgYi9iaXNlY3QuYwppbmRleCBlODdhYzI5Li5lODFjOTFkIDEwMDY0NAotLS0gYS9iaXNlY3QuYworKysgYi9iaXNlY3QuYwpAQCAtNzA3LDcgKzcwNyw3IEBACiB7CiAJY2hhciBiaXNlY3RfcmV2X2hleFtHSVRfTUFYX0hFWFNaICsgMV07CiAKLQltZW1jcHkoYmlzZWN0X3Jldl9oZXgsIG9pZF90b19oZXgoYmlzZWN0X3JldiksIEdJVF9TSEExX0hFWFNaICsgMSk7CisJbWVtY3B5KGJpc2VjdF9yZXZfaGV4LCBvaWRfdG9faGV4KGJpc2VjdF9yZXYpLCB0aGVfaGFzaF9hbGdvLT5oZXhzeiArIDEpOwogCXVwZGF0ZV9yZWYoTlVMTCwgIkJJU0VDVF9FWFBFQ1RFRF9SRVYiLCBiaXNlY3RfcmV2LCBOVUxMLCAwLCBVUERBVEVfUkVGU19ESUVfT05fRVJSKTsKIAogCWFyZ3ZfY2hlY2tvdXRbMl0gPSBiaXNlY3RfcmV2X2hleDsKZGlmZiAtLWdpdCBhL2JsYW1lLmMgYi9ibGFtZS5jCmluZGV4IDM2YTJlN2UuLjI5NzcwZTUgMTAwNjQ0Ci0tLSBhL2JsYW1lLmMKKysrIGIvYmxhbWUuYwpAQCAtMTQ0LDcgKzE0NCw3IEBACiAKIAl3aGlsZSAoIXN0cmJ1Zl9nZXR3aG9sZWxpbmVfZmQoJmxpbmUsIG1lcmdlX2hlYWQsICdcbicpKSB7CiAJCXN0cnVjdCBvYmplY3RfaWQgb2lkOwotCQlpZiAobGluZS5sZW4gPCBHSVRfU0hBMV9IRVhTWiB8fCBnZXRfb2lkX2hleChsaW5lLmJ1ZiwgJm9pZCkpCisJCWlmIChnZXRfb2lkX2hleChsaW5lLmJ1ZiwgJm9pZCkpCiAJCQlkaWUoInVua25vd24gbGluZSBpbiAnJXMnOiAlcyIsCiAJCQkgICAgZ2l0X3BhdGhfbWVyZ2VfaGVhZChyKSwgbGluZS5idWYpOwogCQl0YWlsID0gYXBwZW5kX3BhcmVudChyLCB0YWlsLCAmb2lkKTsKQEAgLTQxNywxNCArNDE3LDE1IEBACiAJCS8qIElnbm9yZSB3aGl0ZXNwYWNlIHBhaXJzICovCiAJCWlmIChoYXNoID09IDApCiAJCQljb250aW51ZTsKLQkJaGFzaG1hcF9lbnRyeV9pbml0KGVudHJ5LCBoYXNoKTsKKwkJaGFzaG1hcF9lbnRyeV9pbml0KCZlbnRyeS0+ZW50cnksIGhhc2gpOwogCi0JCWZvdW5kX2VudHJ5ID0gaGFzaG1hcF9nZXQoJnJlc3VsdC0+bWFwLCBlbnRyeSwgTlVMTCk7CisJCWZvdW5kX2VudHJ5ID0gaGFzaG1hcF9nZXRfZW50cnkoJnJlc3VsdC0+bWFwLCBlbnRyeSwKKwkJCQkJCS8qIG1lbWJlciBuYW1lICovIGVudHJ5LCBOVUxMKTsKIAkJaWYgKGZvdW5kX2VudHJ5KSB7CiAJCQlmb3VuZF9lbnRyeS0+Y291bnQgKz0gMTsKIAkJfSBlbHNlIHsKIAkJCWVudHJ5LT5jb3VudCA9IDE7Ci0JCQloYXNobWFwX2FkZCgmcmVzdWx0LT5tYXAsIGVudHJ5KTsKKwkJCWhhc2htYXBfYWRkKCZyZXN1bHQtPm1hcCwgJmVudHJ5LT5lbnRyeSk7CiAJCQkrK2VudHJ5OwogCQl9CiAJfQpAQCAtNDMyLDcgKzQzMyw3IEBACiAKIHN0YXRpYyB2b2lkIGZyZWVfZmluZ2VycHJpbnQoc3RydWN0IGZpbmdlcnByaW50ICpmKQogewotCWhhc2htYXBfZnJlZSgmZi0+bWFwLCAwKTsKKwloYXNobWFwX2ZyZWUoJmYtPm1hcCk7CiAJZnJlZShmLT5lbnRyaWVzKTsKIH0KIApAQCAtNDQ5LDEwICs0NTAsMTAgQEAKIAlzdHJ1Y3QgaGFzaG1hcF9pdGVyIGl0ZXI7CiAJY29uc3Qgc3RydWN0IGZpbmdlcnByaW50X2VudHJ5ICplbnRyeV9hLCAqZW50cnlfYjsKIAotCWhhc2htYXBfaXRlcl9pbml0KCZiLT5tYXAsICZpdGVyKTsKLQotCXdoaWxlICgoZW50cnlfYiA9IGhhc2htYXBfaXRlcl9uZXh0KCZpdGVyKSkpIHsKLQkJaWYgKChlbnRyeV9hID0gaGFzaG1hcF9nZXQoJmEtPm1hcCwgZW50cnlfYiwgTlVMTCkpKSB7CisJaGFzaG1hcF9mb3JfZWFjaF9lbnRyeSgmYi0+bWFwLCAmaXRlciwgZW50cnlfYiwKKwkJCQllbnRyeSAvKiBtZW1iZXIgbmFtZSAqLykgeworCQllbnRyeV9hID0gaGFzaG1hcF9nZXRfZW50cnkoJmEtPm1hcCwgZW50cnlfYiwgZW50cnksIE5VTEwpOworCQlpZiAoZW50cnlfYSkgewogCQkJaW50ZXJzZWN0aW9uICs9IGVudHJ5X2EtPmNvdW50IDwgZW50cnlfYi0+Y291bnQgPwogCQkJCQllbnRyeV9hLT5jb3VudCA6IGVudHJ5X2ItPmNvdW50OwogCQl9CkBAIC00NzAsMTAgKzQ3MSwxMiBAQAogCiAJaGFzaG1hcF9pdGVyX2luaXQoJmItPm1hcCwgJml0ZXIpOwogCi0Jd2hpbGUgKChlbnRyeV9iID0gaGFzaG1hcF9pdGVyX25leHQoJml0ZXIpKSkgewotCQlpZiAoKGVudHJ5X2EgPSBoYXNobWFwX2dldCgmYS0+bWFwLCBlbnRyeV9iLCBOVUxMKSkpIHsKKwloYXNobWFwX2Zvcl9lYWNoX2VudHJ5KCZiLT5tYXAsICZpdGVyLCBlbnRyeV9iLAorCQkJCWVudHJ5IC8qIG1lbWJlciBuYW1lICovKSB7CisJCWVudHJ5X2EgPSBoYXNobWFwX2dldF9lbnRyeSgmYS0+bWFwLCBlbnRyeV9iLCBlbnRyeSwgTlVMTCk7CisJCWlmIChlbnRyeV9hKSB7CiAJCQlpZiAoZW50cnlfYS0+Y291bnQgPD0gZW50cnlfYi0+Y291bnQpCi0JCQkJaGFzaG1hcF9yZW1vdmUoJmEtPm1hcCwgZW50cnlfYiwgTlVMTCk7CisJCQkJaGFzaG1hcF9yZW1vdmUoJmEtPm1hcCwgJmVudHJ5X2ItPmVudHJ5LCBOVUxMKTsKIAkJCWVsc2UKIAkJCQllbnRyeV9hLT5jb3VudCAtPSBlbnRyeV9iLT5jb3VudDsKIAkJfQpkaWZmIC0tZ2l0IGEvYnVpbHRpbi9hZGQuYyBiL2J1aWx0aW4vYWRkLmMKaW5kZXggZGQxOGU1Yy4uZDQ2ODZkNSAxMDA2NDQKLS0tIGEvYnVpbHRpbi9hZGQuYworKysgYi9idWlsdGluL2FkZC5jCkBAIC0yMCw2ICsyMCw3IEBACiAjaW5jbHVkZSAiYnVsay1jaGVja2luLmgiCiAjaW5jbHVkZSAiYXJndi1hcnJheS5oIgogI2luY2x1ZGUgInN1Ym1vZHVsZS5oIgorI2luY2x1ZGUgImFkZC1pbnRlcmFjdGl2ZS5oIgogCiBzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IGJ1aWx0aW5fYWRkX3VzYWdlW10gPSB7CiAJTl8oImdpdCBhZGQgWzxvcHRpb25zPl0gWy0tXSA8cGF0aHNwZWM+Li4uIiksCkBAIC0xODUsNiArMTg2LDE2IEBACiB7CiAJaW50IHN0YXR1cywgaTsKIAlzdHJ1Y3QgYXJndl9hcnJheSBhcmd2ID0gQVJHVl9BUlJBWV9JTklUOworCWludCB1c2VfYnVpbHRpbl9hZGRfaSA9CisJCWdpdF9lbnZfYm9vbCgiR0lUX1RFU1RfQUREX0lfVVNFX0JVSUxUSU4iLCAtMSk7CisKKwlpZiAoIXBhdGNoX21vZGUpIHsKKwkJaWYgKHVzZV9idWlsdGluX2FkZF9pIDwgMCkKKwkJCWdpdF9jb25maWdfZ2V0X2Jvb2woImFkZC5pbnRlcmFjdGl2ZS51c2VidWlsdGluIiwKKwkJCQkJICAgICZ1c2VfYnVpbHRpbl9hZGRfaSk7CisJCWlmICh1c2VfYnVpbHRpbl9hZGRfaSA9PSAxKQorCQkJcmV0dXJuICEhcnVuX2FkZF9pKHRoZV9yZXBvc2l0b3J5LCBwYXRoc3BlYyk7CisJfQogCiAJYXJndl9hcnJheV9wdXNoKCZhcmd2LCAiYWRkLS1pbnRlcmFjdGl2ZSIpOwogCWlmIChwYXRjaF9tb2RlKQpAQCAtMzE5LDYgKzMzMCw3IEBACiAJCWlnbm9yZV9hZGRfZXJyb3JzID0gZ2l0X2NvbmZpZ19ib29sKHZhciwgdmFsdWUpOwogCQlyZXR1cm4gMDsKIAl9CisKIAlyZXR1cm4gZ2l0X2RlZmF1bHRfY29uZmlnKHZhciwgdmFsdWUsIGNiKTsKIH0KIApkaWZmIC0tZ2l0IGEvYnVpbHRpbi9hbS5jIGIvYnVpbHRpbi9hbS5jCmluZGV4IDFhZWE2NTcuLjgxODFjMmEgMTAwNjQ0Ci0tLSBhL2J1aWx0aW4vYW0uYworKysgYi9idWlsdGluL2FtLmMKQEAgLTI0LDcgKzI0LDYgQEAKICNpbmNsdWRlICJzZXF1ZW5jZXIuaCIKICNpbmNsdWRlICJyZXZpc2lvbi5oIgogI2luY2x1ZGUgIm1lcmdlLXJlY3Vyc2l2ZS5oIgotI2luY2x1ZGUgInJldmlzaW9uLmgiCiAjaW5jbHVkZSAibG9nLXRyZWUuaCIKICNpbmNsdWRlICJub3Rlcy11dGlscy5oIgogI2luY2x1ZGUgInJlcmVyZS5oIgpAQCAtMTA3MiwxOSArMTA3MSw2IEBACiB9CiAKIC8qKgotICogUmVmcmVzaCBhbmQgd3JpdGUgaW5kZXguCi0gKi8KLXN0YXRpYyB2b2lkIHJlZnJlc2hfYW5kX3dyaXRlX2NhY2hlKHZvaWQpCi17Ci0Jc3RydWN0IGxvY2tfZmlsZSBsb2NrX2ZpbGUgPSBMT0NLX0lOSVQ7Ci0KLQlob2xkX2xvY2tlZF9pbmRleCgmbG9ja19maWxlLCBMT0NLX0RJRV9PTl9FUlJPUik7Ci0JcmVmcmVzaF9jYWNoZShSRUZSRVNIX1FVSUVUKTsKLQlpZiAod3JpdGVfbG9ja2VkX2luZGV4KCZ0aGVfaW5kZXgsICZsb2NrX2ZpbGUsIENPTU1JVF9MT0NLKSkKLQkJZGllKF8oInVuYWJsZSB0byB3cml0ZSBpbmRleCBmaWxlIikpOwotfQotCi0vKioKICAqIERpZXMgd2l0aCBhIHVzZXItZnJpZW5kbHkgbWVzc2FnZSBvbiBob3cgdG8gcHJvY2VlZCBhZnRlciByZXNvbHZpbmcgdGhlCiAgKiBwcm9ibGVtLiBUaGlzIG1lc3NhZ2UgY2FuIGJlIG92ZXJyaWRkZW4gd2l0aCBzdGF0ZS0+cmVzb2x2ZW1zZy4KICAqLwpAQCAtMTI3Miw3ICsxMjU4LDkgQEAKIAlidWZmZXIgPSBsb2dtc2dfcmVlbmNvZGUoY29tbWl0LCBOVUxMLCBnZXRfY29tbWl0X291dHB1dF9lbmNvZGluZygpKTsKIAogCWlkZW50X2xpbmUgPSBmaW5kX2NvbW1pdF9oZWFkZXIoYnVmZmVyLCAiYXV0aG9yIiwgJmlkZW50X2xlbik7Ci0KKwlpZiAoIWlkZW50X2xpbmUpCisJCWRpZShfKCJtaXNzaW5nIGF1dGhvciBsaW5lIGluIGNvbW1pdCAlcyIpLAorCQkgICAgICBvaWRfdG9faGV4KCZjb21taXQtPm9iamVjdC5vaWQpKTsKIAlpZiAoc3BsaXRfaWRlbnRfbGluZSgmaWQsIGlkZW50X2xpbmUsIGlkZW50X2xlbikgPCAwKQogCQlkaWUoXygiaW52YWxpZCBpZGVudCBsaW5lOiAlLipzIiksIChpbnQpaWRlbnRfbGVuLCBpZGVudF9saW5lKTsKIApAQCAtMTUzOCw3ICsxNTI2LDcgQEAKIAlvLmJyYW5jaDEgPSAiSEVBRCI7CiAJdGhlaXJfdHJlZV9uYW1lID0geHN0cmZtdCgiJS4qcyIsIGxpbmVsZW4oc3RhdGUtPm1zZyksIHN0YXRlLT5tc2cpOwogCW8uYnJhbmNoMiA9IHRoZWlyX3RyZWVfbmFtZTsKLQlvLmRldGVjdF9kaXJlY3RvcnlfcmVuYW1lcyA9IDA7CisJby5kZXRlY3RfZGlyZWN0b3J5X3JlbmFtZXMgPSBNRVJHRV9ESVJFQ1RPUllfUkVOQU1FU19OT05FOwogCiAJaWYgKHN0YXRlLT5xdWlldCkKIAkJby52ZXJib3NpdHkgPSAwOwpAQCAtMTcwMyw3ICsxNjkxLDggQEAKIAogCXVubGluayhhbV9wYXRoKHN0YXRlLCAiZGlydHlpbmRleCIpKTsKIAotCXJlZnJlc2hfYW5kX3dyaXRlX2NhY2hlKCk7CisJaWYgKHJlZnJlc2hfYW5kX3dyaXRlX2NhY2hlKFJFRlJFU0hfUVVJRVQsIDAsIDApIDwgMCkKKwkJZGllKF8oInVuYWJsZSB0byB3cml0ZSBpbmRleCBmaWxlIikpOwogCiAJaWYgKHJlcG9faW5kZXhfaGFzX2NoYW5nZXModGhlX3JlcG9zaXRvcnksIE5VTEwsICZzYikpIHsKIAkJd3JpdGVfc3RhdGVfYm9vbChzdGF0ZSwgImRpcnR5aW5kZXgiLCAxKTsKZGlmZiAtLWdpdCBhL2J1aWx0aW4vYmxhbWUuYyBiL2J1aWx0aW4vYmxhbWUuYwppbmRleCBiNjUzNGQ0Li5iZjFjZWNkIDEwMDY0NAotLS0gYS9idWlsdGluL2JsYW1lLmMKKysrIGIvYnVpbHRpbi9ibGFtZS5jCkBAIC0yNiw3ICsyNiw2IEBACiAjaW5jbHVkZSAicHJvZ3Jlc3MuaCIKICNpbmNsdWRlICJvYmplY3Qtc3RvcmUuaCIKICNpbmNsdWRlICJibGFtZS5oIgotI2luY2x1ZGUgInN0cmluZy1saXN0LmgiCiAjaW5jbHVkZSAicmVmcy5oIgogCiBzdGF0aWMgY2hhciBibGFtZV91c2FnZVtdID0gTl8oImdpdCBibGFtZSBbPG9wdGlvbnM+XSBbPHJldi1vcHRzPl0gWzxyZXY+XSBbLS1dIDxmaWxlPiIpOwpAQCAtMzIwLDE4ICszMTksMTggQEAKIAlyZXR1cm4gdGltZV9idWYuYnVmOwogfQogCi0jZGVmaW5lIE9VVFBVVF9BTk5PVEFURV9DT01QQVQJMDAxCi0jZGVmaW5lIE9VVFBVVF9MT05HX09CSkVDVF9OQU1FCTAwMgotI2RlZmluZSBPVVRQVVRfUkFXX1RJTUVTVEFNUAkwMDQKLSNkZWZpbmUgT1VUUFVUX1BPUkNFTEFJTgkwMTAKLSNkZWZpbmUgT1VUUFVUX1NIT1dfTkFNRQkwMjAKLSNkZWZpbmUgT1VUUFVUX1NIT1dfTlVNQkVSCTA0MAotI2RlZmluZSBPVVRQVVRfU0hPV19TQ09SRQkwMTAwCi0jZGVmaW5lIE9VVFBVVF9OT19BVVRIT1IJMDIwMAotI2RlZmluZSBPVVRQVVRfU0hPV19FTUFJTAkwNDAwCi0jZGVmaW5lIE9VVFBVVF9MSU5FX1BPUkNFTEFJTgkwMTAwMAotI2RlZmluZSBPVVRQVVRfQ09MT1JfTElORQkwMjAwMAotI2RlZmluZSBPVVRQVVRfU0hPV19BR0VfV0lUSF9DT0xPUgkwNDAwMAorI2RlZmluZSBPVVRQVVRfQU5OT1RBVEVfQ09NUEFUICAgICAgKDFVPDwwKQorI2RlZmluZSBPVVRQVVRfTE9OR19PQkpFQ1RfTkFNRSAgICAgKDFVPDwxKQorI2RlZmluZSBPVVRQVVRfUkFXX1RJTUVTVEFNUCAgICAgICAgKDFVPDwyKQorI2RlZmluZSBPVVRQVVRfUE9SQ0VMQUlOICAgICAgICAgICAgKDFVPDwzKQorI2RlZmluZSBPVVRQVVRfU0hPV19OQU1FICAgICAgICAgICAgKDFVPDw0KQorI2RlZmluZSBPVVRQVVRfU0hPV19OVU1CRVIgICAgICAgICAgKDFVPDw1KQorI2RlZmluZSBPVVRQVVRfU0hPV19TQ09SRSAgICAgICAgICAgKDFVPDw2KQorI2RlZmluZSBPVVRQVVRfTk9fQVVUSE9SICAgICAgICAgICAgKDFVPDw3KQorI2RlZmluZSBPVVRQVVRfU0hPV19FTUFJTCAgICAgICAgICAgKDFVPDw4KQorI2RlZmluZSBPVVRQVVRfTElORV9QT1JDRUxBSU4gICAgICAgKDFVPDw5KQorI2RlZmluZSBPVVRQVVRfQ09MT1JfTElORSAgICAgICAgICAgKDFVPDwxMCkKKyNkZWZpbmUgT1VUUFVUX1NIT1dfQUdFX1dJVEhfQ09MT1IgICgxVTw8MTEpCiAKIHN0YXRpYyB2b2lkIGVtaXRfcG9yY2VsYWluX2RldGFpbHMoc3RydWN0IGJsYW1lX29yaWdpbiAqc3VzcGVjdCwgaW50IHJlcGVhdCkKIHsKQEAgLTQ2MCw3ICs0NTksNyBAQAogCiAJZm9yIChjbnQgPSAwOyBjbnQgPCBlbnQtPm51bV9saW5lczsgY250KyspIHsKIAkJY2hhciBjaDsKLQkJaW50IGxlbmd0aCA9IChvcHQgJiBPVVRQVVRfTE9OR19PQkpFQ1RfTkFNRSkgPyBHSVRfU0hBMV9IRVhTWiA6IGFiYnJldjsKKwkJaW50IGxlbmd0aCA9IChvcHQgJiBPVVRQVVRfTE9OR19PQkpFQ1RfTkFNRSkgPyB0aGVfaGFzaF9hbGdvLT5oZXhzeiA6IGFiYnJldjsKIAogCQlpZiAob3B0ICYgT1VUUFVUX0NPTE9SX0xJTkUpIHsKIAkJCWlmIChjbnQgPiAwKSB7CkBAIC04NjIsMTQgKzg2MSw2IEBACiAJCU9QVF9TVFJJTkdfTElTVCgwLCAiaWdub3JlLXJldnMtZmlsZSIsICZpZ25vcmVfcmV2c19maWxlX2xpc3QsIE5fKCJmaWxlIiksIE5fKCJJZ25vcmUgcmV2aXNpb25zIGZyb20gPGZpbGU+IikpLAogCQlPUFRfQklUKDAsICJjb2xvci1saW5lcyIsICZvdXRwdXRfb3B0aW9uLCBOXygiY29sb3IgcmVkdW5kYW50IG1ldGFkYXRhIGZyb20gcHJldmlvdXMgbGluZSBkaWZmZXJlbnRseSIpLCBPVVRQVVRfQ09MT1JfTElORSksCiAJCU9QVF9CSVQoMCwgImNvbG9yLWJ5LWFnZSIsICZvdXRwdXRfb3B0aW9uLCBOXygiY29sb3IgbGluZXMgYnkgYWdlIiksIE9VVFBVVF9TSE9XX0FHRV9XSVRIX0NPTE9SKSwKLQotCQkvKgotCQkgKiBUaGUgZm9sbG93aW5nIHR3byBvcHRpb25zIGFyZSBwYXJzZWQgYnkgcGFyc2VfcmV2aXNpb25fb3B0KCkKLQkJICogYW5kIGFyZSBvbmx5IGluY2x1ZGVkIGhlcmUgdG8gZ2V0IGluY2x1ZGVkIGluIHRoZSAiLWgiCi0JCSAqIG91dHB1dDoKLQkJICovCi0JCXsgT1BUSU9OX0xPV0xFVkVMX0NBTExCQUNLLCAwLCAiaW5kZW50LWhldXJpc3RpYyIsIE5VTEwsIE5VTEwsIE5fKCJVc2UgYW4gZXhwZXJpbWVudGFsIGhldXJpc3RpYyB0byBpbXByb3ZlIGRpZmZzIiksIFBBUlNFX09QVF9OT0FSRywgTlVMTCwgMCwgcGFyc2Vfb3B0X3Vua25vd25fY2IgfSwKLQogCQlPUFRfQklUKDAsICJtaW5pbWFsIiwgJnhkbF9vcHRzLCBOXygiU3BlbmQgZXh0cmEgY3ljbGVzIHRvIGZpbmQgYmV0dGVyIG1hdGNoIiksIFhERl9ORUVEX01JTklNQUwpLAogCQlPUFRfU1RSSU5HKCdTJywgTlVMTCwgJnJldnNfZmlsZSwgTl8oImZpbGUiKSwgTl8oIlVzZSByZXZpc2lvbnMgZnJvbSA8ZmlsZT4gaW5zdGVhZCBvZiBjYWxsaW5nIGdpdC1yZXYtbGlzdCIpKSwKIAkJT1BUX1NUUklORygwLCAiY29udGVudHMiLCAmY29udGVudHNfZnJvbSwgTl8oImZpbGUiKSwgTl8oIlVzZSA8ZmlsZT4ncyBjb250ZW50cyBhcyB0aGUgZmluYWwgaW1hZ2UiKSksCkBAIC04ODUsNiArODc2LDcgQEAKIAlzdHJ1Y3QgcmFuZ2Vfc2V0IHJhbmdlczsKIAl1bnNpZ25lZCBpbnQgcmFuZ2VfaTsKIAlsb25nIGFuY2hvcjsKKwljb25zdCBpbnQgaGV4c3ogPSB0aGVfaGFzaF9hbGdvLT5oZXhzejsKIAogCXNldHVwX2RlZmF1bHRfY29sb3JfYnlfYWdlKCk7CiAJZ2l0X2NvbmZpZyhnaXRfYmxhbWVfY29uZmlnLCAmb3V0cHV0X29wdGlvbik7CkBAIC05MzEsMTEgKzkyMywxMSBAQAogCX0gZWxzZSBpZiAoc2hvd19wcm9ncmVzcyA8IDApCiAJCXNob3dfcHJvZ3Jlc3MgPSBpc2F0dHkoMik7CiAKLQlpZiAoMCA8IGFiYnJldiAmJiBhYmJyZXYgPCBHSVRfU0hBMV9IRVhTWikKKwlpZiAoMCA8IGFiYnJldiAmJiBhYmJyZXYgPCBoZXhzeikKIAkJLyogb25lIG1vcmUgYWJicmV2IGxlbmd0aCBpcyBuZWVkZWQgZm9yIHRoZSBib3VuZGFyeSBjb21taXQgKi8KIAkJYWJicmV2Kys7CiAJZWxzZSBpZiAoIWFiYnJldikKLQkJYWJicmV2ID0gR0lUX1NIQTFfSEVYU1o7CisJCWFiYnJldiA9IGhleHN6OwogCiAJaWYgKHJldnNfZmlsZSAmJiByZWFkX2FuY2VzdHJ5KHJldnNfZmlsZSkpCiAJCWRpZV9lcnJubygicmVhZGluZyBncmFmdCBmaWxlICclcycgZmFpbGVkIiwgcmV2c19maWxlKTsKZGlmZiAtLWdpdCBhL2J1aWx0aW4vYnVuZGxlLmMgYi9idWlsdGluL2J1bmRsZS5jCmluZGV4IDFlYTRiZmQuLmYwNDlkMjcgMTAwNjQ0Ci0tLSBhL2J1aWx0aW4vYnVuZGxlLmMKKysrIGIvYnVpbHRpbi9idW5kbGUuYwpAQCAtMSw0ICsxLDYgQEAKICNpbmNsdWRlICJidWlsdGluLmgiCisjaW5jbHVkZSAiYXJndi1hcnJheS5oIgorI2luY2x1ZGUgInBhcnNlLW9wdGlvbnMuaCIKICNpbmNsdWRlICJjYWNoZS5oIgogI2luY2x1ZGUgImJ1bmRsZS5oIgogCkBAIC05LDU5ICsxMSwxODQgQEAKICAqIGJ1bmRsZSBzdXBwb3J0aW5nICJmZXRjaCIsICJwdWxsIiwgYW5kICJscy1yZW1vdGUiLgogICovCiAKLXN0YXRpYyBjb25zdCBjaGFyIGJ1aWx0aW5fYnVuZGxlX3VzYWdlW10gPQotICAiZ2l0IGJ1bmRsZSBjcmVhdGUgPGZpbGU+IDxnaXQtcmV2LWxpc3QgYXJncz5cbiIKLSAgIiAgIG9yOiBnaXQgYnVuZGxlIHZlcmlmeSA8ZmlsZT5cbiIKLSAgIiAgIG9yOiBnaXQgYnVuZGxlIGxpc3QtaGVhZHMgPGZpbGU+IFs8cmVmbmFtZT4uLi5dXG4iCi0gICIgICBvcjogZ2l0IGJ1bmRsZSB1bmJ1bmRsZSA8ZmlsZT4gWzxyZWZuYW1lPi4uLl0iOworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBidWlsdGluX2J1bmRsZV91c2FnZVtdID0geworICBOXygiZ2l0IGJ1bmRsZSBjcmVhdGUgWzxvcHRpb25zPl0gPGZpbGU+IDxnaXQtcmV2LWxpc3QgYXJncz4iKSwKKyAgTl8oImdpdCBidW5kbGUgdmVyaWZ5IFs8b3B0aW9ucz5dIDxmaWxlPiIpLAorICBOXygiZ2l0IGJ1bmRsZSBsaXN0LWhlYWRzIDxmaWxlPiBbPHJlZm5hbWU+Li4uXSIpLAorICBOXygiZ2l0IGJ1bmRsZSB1bmJ1bmRsZSA8ZmlsZT4gWzxyZWZuYW1lPi4uLl0iKSwKKyAgTlVMTAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBidWlsdGluX2J1bmRsZV9jcmVhdGVfdXNhZ2VbXSA9IHsKKyAgTl8oImdpdCBidW5kbGUgY3JlYXRlIFs8b3B0aW9ucz5dIDxmaWxlPiA8Z2l0LXJldi1saXN0IGFyZ3M+IiksCisgIE5VTEwKK307CisKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgYnVpbHRpbl9idW5kbGVfdmVyaWZ5X3VzYWdlW10gPSB7CisgIE5fKCJnaXQgYnVuZGxlIHZlcmlmeSBbPG9wdGlvbnM+XSA8ZmlsZT4iKSwKKyAgTlVMTAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBidWlsdGluX2J1bmRsZV9saXN0X2hlYWRzX3VzYWdlW10gPSB7CisgIE5fKCJnaXQgYnVuZGxlIGxpc3QtaGVhZHMgPGZpbGU+IFs8cmVmbmFtZT4uLi5dIiksCisgIE5VTEwKK307CisKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgYnVpbHRpbl9idW5kbGVfdW5idW5kbGVfdXNhZ2VbXSA9IHsKKyAgTl8oImdpdCBidW5kbGUgdW5idW5kbGUgPGZpbGU+IFs8cmVmbmFtZT4uLi5dIiksCisgIE5VTEwKK307CisKK3N0YXRpYyBpbnQgdmVyYm9zZTsKKworc3RhdGljIGludCBwYXJzZV9vcHRpb25zX2NtZF9idW5kbGUoaW50IGFyZ2MsCisJCWNvbnN0IGNoYXIgKiphcmd2LAorCQljb25zdCBjaGFyKiBwcmVmaXgsCisJCWNvbnN0IGNoYXIgKiBjb25zdCB1c2FnZXN0cltdLAorCQljb25zdCBzdHJ1Y3Qgb3B0aW9uIG9wdGlvbnNbXSwKKwkJY29uc3QgY2hhciAqKmJ1bmRsZV9maWxlKSB7CisJaW50IG5ld2FyZ2M7CisJbmV3YXJnYyA9IHBhcnNlX29wdGlvbnMoYXJnYywgYXJndiwgTlVMTCwgb3B0aW9ucywgdXNhZ2VzdHIsCisJCQkgICAgIFBBUlNFX09QVF9TVE9QX0FUX05PTl9PUFRJT04pOworCWlmIChhcmdjIDwgMSkKKwkJdXNhZ2Vfd2l0aF9vcHRpb25zKHVzYWdlc3RyLCBvcHRpb25zKTsKKwkqYnVuZGxlX2ZpbGUgPSBwcmVmaXhfZmlsZW5hbWUocHJlZml4LCBhcmd2WzBdKTsKKwlyZXR1cm4gbmV3YXJnYzsKK30KKworc3RhdGljIGludCBjbWRfYnVuZGxlX2NyZWF0ZShpbnQgYXJnYywgY29uc3QgY2hhciAqKmFyZ3YsIGNvbnN0IGNoYXIgKnByZWZpeCkgeworCWludCBhbGxfcHJvZ3Jlc3NfaW1wbGllZCA9IDA7CisJaW50IHByb2dyZXNzID0gaXNhdHR5KFNUREVSUl9GSUxFTk8pOworCXN0cnVjdCBhcmd2X2FycmF5IHBhY2tfb3B0czsKKworCXN0cnVjdCBvcHRpb24gb3B0aW9uc1tdID0geworCQlPUFRfU0VUX0lOVCgncScsICJxdWlldCIsICZwcm9ncmVzcywKKwkJCSAgICBOXygiZG8gbm90IHNob3cgcHJvZ3Jlc3MgbWV0ZXIiKSwgMCksCisJCU9QVF9TRVRfSU5UKDAsICJwcm9ncmVzcyIsICZwcm9ncmVzcywKKwkJCSAgICBOXygic2hvdyBwcm9ncmVzcyBtZXRlciIpLCAxKSwKKwkJT1BUX1NFVF9JTlQoMCwgImFsbC1wcm9ncmVzcyIsICZwcm9ncmVzcywKKwkJCSAgICBOXygic2hvdyBwcm9ncmVzcyBtZXRlciBkdXJpbmcgb2JqZWN0IHdyaXRpbmcgcGhhc2UiKSwgMiksCisJCU9QVF9CT09MKDAsICJhbGwtcHJvZ3Jlc3MtaW1wbGllZCIsCisJCQkgJmFsbF9wcm9ncmVzc19pbXBsaWVkLAorCQkJIE5fKCJzaW1pbGFyIHRvIC0tYWxsLXByb2dyZXNzIHdoZW4gcHJvZ3Jlc3MgbWV0ZXIgaXMgc2hvd24iKSksCisJCU9QVF9FTkQoKQorCX07CisJY29uc3QgY2hhciogYnVuZGxlX2ZpbGU7CisKKwlhcmdjID0gcGFyc2Vfb3B0aW9uc19jbWRfYnVuZGxlKGFyZ2MsIGFyZ3YsIHByZWZpeCwKKwkJCWJ1aWx0aW5fYnVuZGxlX2NyZWF0ZV91c2FnZSwgb3B0aW9ucywgJmJ1bmRsZV9maWxlKTsKKwkvKiBidW5kbGUgaW50ZXJuYWxzIHVzZSBhcmd2WzFdIGFzIGZ1cnRoZXIgcGFyYW1ldGVycyAqLworCisJYXJndl9hcnJheV9pbml0KCZwYWNrX29wdHMpOworCWlmIChwcm9ncmVzcyA9PSAwKQorCQlhcmd2X2FycmF5X3B1c2goJnBhY2tfb3B0cywgIi0tcXVpZXQiKTsKKwllbHNlIGlmIChwcm9ncmVzcyA9PSAxKQorCQlhcmd2X2FycmF5X3B1c2goJnBhY2tfb3B0cywgIi0tcHJvZ3Jlc3MiKTsKKwllbHNlIGlmIChwcm9ncmVzcyA9PSAyKQorCQlhcmd2X2FycmF5X3B1c2goJnBhY2tfb3B0cywgIi0tYWxsLXByb2dyZXNzIik7CisJaWYgKHByb2dyZXNzICYmIGFsbF9wcm9ncmVzc19pbXBsaWVkKQorCQlhcmd2X2FycmF5X3B1c2goJnBhY2tfb3B0cywgIi0tYWxsLXByb2dyZXNzLWltcGxpZWQiKTsKKworCWlmICghc3RhcnR1cF9pbmZvLT5oYXZlX3JlcG9zaXRvcnkpCisJCWRpZShfKCJOZWVkIGEgcmVwb3NpdG9yeSB0byBjcmVhdGUgYSBidW5kbGUuIikpOworCXJldHVybiAhIWNyZWF0ZV9idW5kbGUodGhlX3JlcG9zaXRvcnksIGJ1bmRsZV9maWxlLCBhcmdjLCBhcmd2LCAmcGFja19vcHRzKTsKK30KKworc3RhdGljIGludCBjbWRfYnVuZGxlX3ZlcmlmeShpbnQgYXJnYywgY29uc3QgY2hhciAqKmFyZ3YsIGNvbnN0IGNoYXIgKnByZWZpeCkgeworCXN0cnVjdCBidW5kbGVfaGVhZGVyIGhlYWRlcjsKKwlpbnQgYnVuZGxlX2ZkID0gLTE7CisJaW50IHF1aWV0ID0gMDsKKworCXN0cnVjdCBvcHRpb24gb3B0aW9uc1tdID0geworCQlPUFRfQk9PTCgncScsICJxdWlldCIsICZxdWlldCwKKwkJCSAgICBOXygiZG8gbm90IHNob3cgYnVuZGxlIGRldGFpbHMiKSksCisJCU9QVF9FTkQoKQorCX07CisJY29uc3QgY2hhciogYnVuZGxlX2ZpbGU7CisKKwlhcmdjID0gcGFyc2Vfb3B0aW9uc19jbWRfYnVuZGxlKGFyZ2MsIGFyZ3YsIHByZWZpeCwKKwkJCWJ1aWx0aW5fYnVuZGxlX3ZlcmlmeV91c2FnZSwgb3B0aW9ucywgJmJ1bmRsZV9maWxlKTsKKwkvKiBidW5kbGUgaW50ZXJuYWxzIHVzZSBhcmd2WzFdIGFzIGZ1cnRoZXIgcGFyYW1ldGVycyAqLworCisJbWVtc2V0KCZoZWFkZXIsIDAsIHNpemVvZihoZWFkZXIpKTsKKwlpZiAoKGJ1bmRsZV9mZCA9IHJlYWRfYnVuZGxlX2hlYWRlcihidW5kbGVfZmlsZSwgJmhlYWRlcikpIDwgMCkKKwkJcmV0dXJuIDE7CisJY2xvc2UoYnVuZGxlX2ZkKTsKKwlpZiAodmVyaWZ5X2J1bmRsZSh0aGVfcmVwb3NpdG9yeSwgJmhlYWRlciwgIXF1aWV0KSkKKwkJcmV0dXJuIDE7CisJZnByaW50ZihzdGRlcnIsIF8oIiVzIGlzIG9rYXlcbiIpLCBidW5kbGVfZmlsZSk7CisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgY21kX2J1bmRsZV9saXN0X2hlYWRzKGludCBhcmdjLCBjb25zdCBjaGFyICoqYXJndiwgY29uc3QgY2hhciAqcHJlZml4KSB7CisJc3RydWN0IGJ1bmRsZV9oZWFkZXIgaGVhZGVyOworCWludCBidW5kbGVfZmQgPSAtMTsKKworCXN0cnVjdCBvcHRpb24gb3B0aW9uc1tdID0geworCQlPUFRfRU5EKCkKKwl9OworCWNvbnN0IGNoYXIqIGJ1bmRsZV9maWxlOworCisJYXJnYyA9IHBhcnNlX29wdGlvbnNfY21kX2J1bmRsZShhcmdjLCBhcmd2LCBwcmVmaXgsCisJCQlidWlsdGluX2J1bmRsZV9saXN0X2hlYWRzX3VzYWdlLCBvcHRpb25zLCAmYnVuZGxlX2ZpbGUpOworCS8qIGJ1bmRsZSBpbnRlcm5hbHMgdXNlIGFyZ3ZbMV0gYXMgZnVydGhlciBwYXJhbWV0ZXJzICovCisKKwltZW1zZXQoJmhlYWRlciwgMCwgc2l6ZW9mKGhlYWRlcikpOworCWlmICgoYnVuZGxlX2ZkID0gcmVhZF9idW5kbGVfaGVhZGVyKGJ1bmRsZV9maWxlLCAmaGVhZGVyKSkgPCAwKQorCQlyZXR1cm4gMTsKKwljbG9zZShidW5kbGVfZmQpOworCXJldHVybiAhIWxpc3RfYnVuZGxlX3JlZnMoJmhlYWRlciwgYXJnYywgYXJndik7Cit9CisKK3N0YXRpYyBpbnQgY21kX2J1bmRsZV91bmJ1bmRsZShpbnQgYXJnYywgY29uc3QgY2hhciAqKmFyZ3YsIGNvbnN0IGNoYXIgKnByZWZpeCkgeworCXN0cnVjdCBidW5kbGVfaGVhZGVyIGhlYWRlcjsKKwlpbnQgYnVuZGxlX2ZkID0gLTE7CisKKwlzdHJ1Y3Qgb3B0aW9uIG9wdGlvbnNbXSA9IHsKKwkJT1BUX0VORCgpCisJfTsKKwljb25zdCBjaGFyKiBidW5kbGVfZmlsZTsKKworCWFyZ2MgPSBwYXJzZV9vcHRpb25zX2NtZF9idW5kbGUoYXJnYywgYXJndiwgcHJlZml4LAorCQkJYnVpbHRpbl9idW5kbGVfdW5idW5kbGVfdXNhZ2UsIG9wdGlvbnMsICZidW5kbGVfZmlsZSk7CisJLyogYnVuZGxlIGludGVybmFscyB1c2UgYXJndlsxXSBhcyBmdXJ0aGVyIHBhcmFtZXRlcnMgKi8KKworCW1lbXNldCgmaGVhZGVyLCAwLCBzaXplb2YoaGVhZGVyKSk7CisJaWYgKChidW5kbGVfZmQgPSByZWFkX2J1bmRsZV9oZWFkZXIoYnVuZGxlX2ZpbGUsICZoZWFkZXIpKSA8IDApCisJCXJldHVybiAxOworCWlmICghc3RhcnR1cF9pbmZvLT5oYXZlX3JlcG9zaXRvcnkpCisJCWRpZShfKCJOZWVkIGEgcmVwb3NpdG9yeSB0byB1bmJ1bmRsZS4iKSk7CisJcmV0dXJuICEhdW5idW5kbGUodGhlX3JlcG9zaXRvcnksICZoZWFkZXIsIGJ1bmRsZV9mZCwgMCkgfHwKKwkJbGlzdF9idW5kbGVfcmVmcygmaGVhZGVyLCBhcmdjLCBhcmd2KTsKK30KIAogaW50IGNtZF9idW5kbGUoaW50IGFyZ2MsIGNvbnN0IGNoYXIgKiphcmd2LCBjb25zdCBjaGFyICpwcmVmaXgpCiB7Ci0Jc3RydWN0IGJ1bmRsZV9oZWFkZXIgaGVhZGVyOwotCWNvbnN0IGNoYXIgKmNtZCwgKmJ1bmRsZV9maWxlOwotCWludCBidW5kbGVfZmQgPSAtMTsKKwlzdHJ1Y3Qgb3B0aW9uIG9wdGlvbnNbXSA9IHsKKwkJT1BUX19WRVJCT1NFKCZ2ZXJib3NlLCBOXygiYmUgdmVyYm9zZTsgbXVzdCBiZSBwbGFjZWQgYmVmb3JlIGEgc3ViY29tbWFuZCIpKSwKKwkJT1BUX0VORCgpCisJfTsKKwlpbnQgcmVzdWx0OwogCi0JaWYgKGFyZ2MgPCAzKQotCQl1c2FnZShidWlsdGluX2J1bmRsZV91c2FnZSk7CisJYXJnYyA9IHBhcnNlX29wdGlvbnMoYXJnYywgYXJndiwgcHJlZml4LCBvcHRpb25zLCBidWlsdGluX2J1bmRsZV91c2FnZSwKKwkJUEFSU0VfT1BUX1NUT1BfQVRfTk9OX09QVElPTik7CiAKLQljbWQgPSBhcmd2WzFdOwotCWJ1bmRsZV9maWxlID0gcHJlZml4X2ZpbGVuYW1lKHByZWZpeCwgYXJndlsyXSk7Ci0JYXJnYyAtPSAyOwotCWFyZ3YgKz0gMjsKKwlwYWNrZXRfdHJhY2VfaWRlbnRpdHkoImJ1bmRsZSIpOwogCi0JbWVtc2V0KCZoZWFkZXIsIDAsIHNpemVvZihoZWFkZXIpKTsKLQlpZiAoc3RyY21wKGNtZCwgImNyZWF0ZSIpICYmIChidW5kbGVfZmQgPQotCQkJCXJlYWRfYnVuZGxlX2hlYWRlcihidW5kbGVfZmlsZSwgJmhlYWRlcikpIDwgMCkKLQkJcmV0dXJuIDE7CisJaWYgKGFyZ2MgPCAyKQorCQl1c2FnZV93aXRoX29wdGlvbnMoYnVpbHRpbl9idW5kbGVfdXNhZ2UsIG9wdGlvbnMpOwogCi0JaWYgKCFzdHJjbXAoY21kLCAidmVyaWZ5IikpIHsKLQkJY2xvc2UoYnVuZGxlX2ZkKTsKLQkJaWYgKGFyZ2MgIT0gMSkgewotCQkJdXNhZ2UoYnVpbHRpbl9idW5kbGVfdXNhZ2UpOwotCQkJcmV0dXJuIDE7Ci0JCX0KLQkJaWYgKHZlcmlmeV9idW5kbGUodGhlX3JlcG9zaXRvcnksICZoZWFkZXIsIDEpKQotCQkJcmV0dXJuIDE7Ci0JCWZwcmludGYoc3RkZXJyLCBfKCIlcyBpcyBva2F5XG4iKSwgYnVuZGxlX2ZpbGUpOwotCQlyZXR1cm4gMDsKKwllbHNlIGlmICghc3RyY21wKGFyZ3ZbMF0sICJjcmVhdGUiKSkKKwkJcmVzdWx0ID0gY21kX2J1bmRsZV9jcmVhdGUoYXJnYywgYXJndiwgcHJlZml4KTsKKwllbHNlIGlmICghc3RyY21wKGFyZ3ZbMF0sICJ2ZXJpZnkiKSkKKwkJcmVzdWx0ID0gY21kX2J1bmRsZV92ZXJpZnkoYXJnYywgYXJndiwgcHJlZml4KTsKKwllbHNlIGlmICghc3RyY21wKGFyZ3ZbMF0sICJsaXN0LWhlYWRzIikpCisJCXJlc3VsdCA9IGNtZF9idW5kbGVfbGlzdF9oZWFkcyhhcmdjLCBhcmd2LCBwcmVmaXgpOworCWVsc2UgaWYgKCFzdHJjbXAoYXJndlswXSwgInVuYnVuZGxlIikpCisJCXJlc3VsdCA9IGNtZF9idW5kbGVfdW5idW5kbGUoYXJnYywgYXJndiwgcHJlZml4KTsKKwllbHNlIHsKKwkJZXJyb3IoXygiVW5rbm93biBzdWJjb21tYW5kOiAlcyIpLCBhcmd2WzBdKTsKKwkJdXNhZ2Vfd2l0aF9vcHRpb25zKGJ1aWx0aW5fYnVuZGxlX3VzYWdlLCBvcHRpb25zKTsKIAl9Ci0JaWYgKCFzdHJjbXAoY21kLCAibGlzdC1oZWFkcyIpKSB7Ci0JCWNsb3NlKGJ1bmRsZV9mZCk7Ci0JCXJldHVybiAhIWxpc3RfYnVuZGxlX3JlZnMoJmhlYWRlciwgYXJnYywgYXJndik7Ci0JfQotCWlmICghc3RyY21wKGNtZCwgImNyZWF0ZSIpKSB7Ci0JCWlmIChhcmdjIDwgMikgewotCQkJdXNhZ2UoYnVpbHRpbl9idW5kbGVfdXNhZ2UpOwotCQkJcmV0dXJuIDE7Ci0JCX0KLQkJaWYgKCFzdGFydHVwX2luZm8tPmhhdmVfcmVwb3NpdG9yeSkKLQkJCWRpZShfKCJOZWVkIGEgcmVwb3NpdG9yeSB0byBjcmVhdGUgYSBidW5kbGUuIikpOwotCQlyZXR1cm4gISFjcmVhdGVfYnVuZGxlKHRoZV9yZXBvc2l0b3J5LCBidW5kbGVfZmlsZSwgYXJnYywgYXJndik7Ci0JfSBlbHNlIGlmICghc3RyY21wKGNtZCwgInVuYnVuZGxlIikpIHsKLQkJaWYgKCFzdGFydHVwX2luZm8tPmhhdmVfcmVwb3NpdG9yeSkKLQkJCWRpZShfKCJOZWVkIGEgcmVwb3NpdG9yeSB0byB1bmJ1bmRsZS4iKSk7Ci0JCXJldHVybiAhIXVuYnVuZGxlKHRoZV9yZXBvc2l0b3J5LCAmaGVhZGVyLCBidW5kbGVfZmQsIDApIHx8Ci0JCQlsaXN0X2J1bmRsZV9yZWZzKCZoZWFkZXIsIGFyZ2MsIGFyZ3YpOwotCX0gZWxzZQotCQl1c2FnZShidWlsdGluX2J1bmRsZV91c2FnZSk7CisJcmV0dXJuIHJlc3VsdCA/IDEgOiAwOwogfQpkaWZmIC0tZ2l0IGEvYnVpbHRpbi9jYXQtZmlsZS5jIGIvYnVpbHRpbi9jYXQtZmlsZS5jCmluZGV4IDk5NWQ0N2MuLmQ2YTFhYTcgMTAwNjQ0Ci0tLSBhL2J1aWx0aW4vY2F0LWZpbGUuYworKysgYi9idWlsdGluL2NhdC1maWxlLmMKQEAgLTE1LDYgKzE1LDcgQEAKICNpbmNsdWRlICJzaGExLWFycmF5LmgiCiAjaW5jbHVkZSAicGFja2ZpbGUuaCIKICNpbmNsdWRlICJvYmplY3Qtc3RvcmUuaCIKKyNpbmNsdWRlICJwcm9taXNvci1yZW1vdGUuaCIKIAogc3RydWN0IGJhdGNoX29wdGlvbnMgewogCWludCBlbmFibGVkOwpAQCAtNTI0LDggKzUyNSw4IEBACiAJaWYgKG9wdC0+YWxsX29iamVjdHMpIHsKIAkJc3RydWN0IG9iamVjdF9jYl9kYXRhIGNiOwogCi0JCWlmIChyZXBvc2l0b3J5X2Zvcm1hdF9wYXJ0aWFsX2Nsb25lKQotCQkJd2FybmluZygiVGhpcyByZXBvc2l0b3J5IGhhcyBleHRlbnNpb25zLnBhcnRpYWxDbG9uZSBzZXQuIFNvbWUgb2JqZWN0cyBtYXkgbm90IGJlIGxvYWRlZC4iKTsKKwkJaWYgKGhhc19wcm9taXNvcl9yZW1vdGUoKSkKKwkJCXdhcm5pbmcoIlRoaXMgcmVwb3NpdG9yeSB1c2VzIHByb21pc29yIHJlbW90ZXMuIFNvbWUgb2JqZWN0cyBtYXkgbm90IGJlIGxvYWRlZC4iKTsKIAogCQljYi5vcHQgPSBvcHQ7CiAJCWNiLmV4cGFuZCA9ICZkYXRhOwpkaWZmIC0tZ2l0IGEvYnVpbHRpbi9jaGVjay1pZ25vcmUuYyBiL2J1aWx0aW4vY2hlY2staWdub3JlLmMKaW5kZXggNTk5MDk3My4uNWE0ZjkyMyAxMDA2NDQKLS0tIGEvYnVpbHRpbi9jaGVjay1pZ25vcmUuYworKysgYi9idWlsdGluL2NoZWNrLWlnbm9yZS5jCkBAIC0zMiwxOSArMzIsMTkgQEAKIAlPUFRfRU5EKCkKIH07CiAKLXN0YXRpYyB2b2lkIG91dHB1dF9leGNsdWRlKGNvbnN0IGNoYXIgKnBhdGgsIHN0cnVjdCBleGNsdWRlICpleGNsdWRlKQorc3RhdGljIHZvaWQgb3V0cHV0X3BhdHRlcm4oY29uc3QgY2hhciAqcGF0aCwgc3RydWN0IHBhdGhfcGF0dGVybiAqcGF0dGVybikKIHsKLQljaGFyICpiYW5nICA9IChleGNsdWRlICYmIGV4Y2x1ZGUtPmZsYWdzICYgRVhDX0ZMQUdfTkVHQVRJVkUpICA/ICIhIiA6ICIiOwotCWNoYXIgKnNsYXNoID0gKGV4Y2x1ZGUgJiYgZXhjbHVkZS0+ZmxhZ3MgJiBFWENfRkxBR19NVVNUQkVESVIpID8gIi8iIDogIiI7CisJY2hhciAqYmFuZyAgPSAocGF0dGVybiAmJiBwYXR0ZXJuLT5mbGFncyAmIFBBVFRFUk5fRkxBR19ORUdBVElWRSkgID8gIiEiIDogIiI7CisJY2hhciAqc2xhc2ggPSAocGF0dGVybiAmJiBwYXR0ZXJuLT5mbGFncyAmIFBBVFRFUk5fRkxBR19NVVNUQkVESVIpID8gIi8iIDogIiI7CiAJaWYgKCFudWxfdGVybV9saW5lKSB7CiAJCWlmICghdmVyYm9zZSkgewogCQkJd3JpdGVfbmFtZV9xdW90ZWQocGF0aCwgc3Rkb3V0LCAnXG4nKTsKIAkJfSBlbHNlIHsKLQkJCWlmIChleGNsdWRlKSB7Ci0JCQkJcXVvdGVfY19zdHlsZShleGNsdWRlLT5lbC0+c3JjLCBOVUxMLCBzdGRvdXQsIDApOworCQkJaWYgKHBhdHRlcm4pIHsKKwkJCQlxdW90ZV9jX3N0eWxlKHBhdHRlcm4tPnBsLT5zcmMsIE5VTEwsIHN0ZG91dCwgMCk7CiAJCQkJcHJpbnRmKCI6JWQ6JXMlcyVzXHQiLAotCQkJCSAgICAgICBleGNsdWRlLT5zcmNwb3MsCi0JCQkJICAgICAgIGJhbmcsIGV4Y2x1ZGUtPnBhdHRlcm4sIHNsYXNoKTsKKwkJCQkgICAgICAgcGF0dGVybi0+c3JjcG9zLAorCQkJCSAgICAgICBiYW5nLCBwYXR0ZXJuLT5wYXR0ZXJuLCBzbGFzaCk7CiAJCQl9CiAJCQllbHNlIHsKIAkJCQlwcmludGYoIjo6XHQiKTsKQEAgLTU2LDExICs1NiwxMSBAQAogCQlpZiAoIXZlcmJvc2UpIHsKIAkJCXByaW50ZigiJXMlYyIsIHBhdGgsICdcMCcpOwogCQl9IGVsc2UgewotCQkJaWYgKGV4Y2x1ZGUpCisJCQlpZiAocGF0dGVybikKIAkJCQlwcmludGYoIiVzJWMlZCVjJXMlcyVzJWMlcyVjIiwKLQkJCQkgICAgICAgZXhjbHVkZS0+ZWwtPnNyYywgJ1wwJywKLQkJCQkgICAgICAgZXhjbHVkZS0+c3JjcG9zLCAnXDAnLAotCQkJCSAgICAgICBiYW5nLCBleGNsdWRlLT5wYXR0ZXJuLCBzbGFzaCwgJ1wwJywKKwkJCQkgICAgICAgcGF0dGVybi0+cGwtPnNyYywgJ1wwJywKKwkJCQkgICAgICAgcGF0dGVybi0+c3JjcG9zLCAnXDAnLAorCQkJCSAgICAgICBiYW5nLCBwYXR0ZXJuLT5wYXR0ZXJuLCBzbGFzaCwgJ1wwJywKIAkJCQkgICAgICAgcGF0aCwgJ1wwJyk7CiAJCQllbHNlCiAJCQkJcHJpbnRmKCIlYyVjJWMlcyVjIiwgJ1wwJywgJ1wwJywgJ1wwJywgcGF0aCwgJ1wwJyk7CkBAIC03NCw3ICs3NCw3IEBACiAJY29uc3QgY2hhciAqZnVsbF9wYXRoOwogCWNoYXIgKnNlZW47CiAJaW50IG51bV9pZ25vcmVkID0gMCwgaTsKLQlzdHJ1Y3QgZXhjbHVkZSAqZXhjbHVkZTsKKwlzdHJ1Y3QgcGF0aF9wYXR0ZXJuICpwYXR0ZXJuOwogCXN0cnVjdCBwYXRoc3BlYyBwYXRoc3BlYzsKIAogCWlmICghYXJnYykgewpAQCAtMTAzLDE1ICsxMDMsMTUgQEAKIAlzZWVuID0gZmluZF9wYXRoc3BlY3NfbWF0Y2hpbmdfYWdhaW5zdF9pbmRleCgmcGF0aHNwZWMsICZ0aGVfaW5kZXgpOwogCWZvciAoaSA9IDA7IGkgPCBwYXRoc3BlYy5ucjsgaSsrKSB7CiAJCWZ1bGxfcGF0aCA9IHBhdGhzcGVjLml0ZW1zW2ldLm1hdGNoOwotCQlleGNsdWRlID0gTlVMTDsKKwkJcGF0dGVybiA9IE5VTEw7CiAJCWlmICghc2VlbltpXSkgewogCQkJaW50IGR0eXBlID0gRFRfVU5LTk9XTjsKLQkJCWV4Y2x1ZGUgPSBsYXN0X2V4Y2x1ZGVfbWF0Y2hpbmcoZGlyLCAmdGhlX2luZGV4LAorCQkJcGF0dGVybiA9IGxhc3RfbWF0Y2hpbmdfcGF0dGVybihkaXIsICZ0aGVfaW5kZXgsCiAJCQkJCQkJZnVsbF9wYXRoLCAmZHR5cGUpOwogCQl9Ci0JCWlmICghcXVpZXQgJiYgKGV4Y2x1ZGUgfHwgc2hvd19ub25fbWF0Y2hpbmcpKQotCQkJb3V0cHV0X2V4Y2x1ZGUocGF0aHNwZWMuaXRlbXNbaV0ub3JpZ2luYWwsIGV4Y2x1ZGUpOwotCQlpZiAoZXhjbHVkZSkKKwkJaWYgKCFxdWlldCAmJiAocGF0dGVybiB8fCBzaG93X25vbl9tYXRjaGluZykpCisJCQlvdXRwdXRfcGF0dGVybihwYXRoc3BlYy5pdGVtc1tpXS5vcmlnaW5hbCwgcGF0dGVybik7CisJCWlmIChwYXR0ZXJuKQogCQkJbnVtX2lnbm9yZWQrKzsKIAl9CiAJZnJlZShzZWVuKTsKZGlmZiAtLWdpdCBhL2J1aWx0aW4vY2hlY2tvdXQuYyBiL2J1aWx0aW4vY2hlY2tvdXQuYwppbmRleCA2MTIzZjczLi4zNjM0YTNkIDEwMDY0NAotLS0gYS9idWlsdGluL2NoZWNrb3V0LmMKKysrIGIvYnVpbHRpbi9jaGVja291dC5jCkBAIC0xMjYsNiArMTI2LDcgQEAKIAlpZiAocG9zID49IDApIHsKIAkJc3RydWN0IGNhY2hlX2VudHJ5ICpvbGQgPSBhY3RpdmVfY2FjaGVbcG9zXTsKIAkJaWYgKGNlLT5jZV9tb2RlID09IG9sZC0+Y2VfbW9kZSAmJgorCQkgICAgIWNlX2ludGVudF90b19hZGQob2xkKSAmJgogCQkgICAgb2lkZXEoJmNlLT5vaWQsICZvbGQtPm9pZCkpIHsKIAkJCW9sZC0+Y2VfZmxhZ3MgfD0gQ0VfVVBEQVRFOwogCQkJZGlzY2FyZF9jYWNoZV9lbnRyeShjZSk7CkBAIC03MDgsMTEgKzcwOSwxMSBAQAogCQkJICogZ2l2ZSB1cCBvciBkbyBhIHJlYWwgbWVyZ2UsIGRlcGVuZGluZyBvbgogCQkJICogd2hldGhlciB0aGUgbWVyZ2UgZmxhZyB3YXMgdXNlZC4KIAkJCSAqLwotCQkJc3RydWN0IHRyZWUgKnJlc3VsdDsKIAkJCXN0cnVjdCB0cmVlICp3b3JrOwogCQkJc3RydWN0IHRyZWUgKm9sZF90cmVlOwogCQkJc3RydWN0IG1lcmdlX29wdGlvbnMgbzsKIAkJCXN0cnVjdCBzdHJidWYgc2IgPSBTVFJCVUZfSU5JVDsKKwkJCXN0cnVjdCBzdHJidWYgb2xkX2NvbW1pdF9zaG9ydG5hbWUgPSBTVFJCVUZfSU5JVDsKIAogCQkJaWYgKCFvcHRzLT5tZXJnZSkKIAkJCQlyZXR1cm4gMTsKQEAgLTczMCwxMyArNzMxLDYgQEAKIAkJCQkgICAgICAidGhlIGZvbGxvd2luZyBmaWxlczpcbiVzIiksIHNiLmJ1Zik7CiAJCQlzdHJidWZfcmVsZWFzZSgmc2IpOwogCi0JCQlpZiAocmVwb19pbmRleF9oYXNfY2hhbmdlcyh0aGVfcmVwb3NpdG9yeSwKLQkJCQkJCSAgIGdldF9jb21taXRfdHJlZShvbGRfYnJhbmNoX2luZm8tPmNvbW1pdCksCi0JCQkJCQkgICAmc2IpKQotCQkJCXdhcm5pbmcoXygic3RhZ2VkIGNoYW5nZXMgaW4gdGhlIGZvbGxvd2luZyBmaWxlcyBtYXkgYmUgbG9zdDogJXMiKSwKLQkJCQkJc2IuYnVmKTsKLQkJCXN0cmJ1Zl9yZWxlYXNlKCZzYik7Ci0KIAkJCS8qIERvIG1vcmUgcmVhbCBtZXJnZSAqLwogCiAJCQkvKgpAQCAtNzYwLDcgKzc1NCw3IEBACiAJCQkgKi8KIAkJCWluaXRfbWVyZ2Vfb3B0aW9ucygmbywgdGhlX3JlcG9zaXRvcnkpOwogCQkJby52ZXJib3NpdHkgPSAwOwotCQkJd29yayA9IHdyaXRlX3RyZWVfZnJvbV9tZW1vcnkoJm8pOworCQkJd29yayA9IHdyaXRlX2luX2NvcmVfaW5kZXhfYXNfdHJlZSh0aGVfcmVwb3NpdG9yeSk7CiAKIAkJCXJldCA9IHJlc2V0X3RyZWUobmV3X3RyZWUsCiAJCQkJCSBvcHRzLCAxLApAQCAtNzY4LDE5ICs3NjIsMjUgQEAKIAkJCWlmIChyZXQpCiAJCQkJcmV0dXJuIHJldDsKIAkJCW8uYW5jZXN0b3IgPSBvbGRfYnJhbmNoX2luZm8tPm5hbWU7CisJCQlpZiAob2xkX2JyYW5jaF9pbmZvLT5uYW1lID09IE5VTEwpIHsKKwkJCQlzdHJidWZfYWRkX3VuaXF1ZV9hYmJyZXYoJm9sZF9jb21taXRfc2hvcnRuYW1lLAorCQkJCQkJCSAmb2xkX2JyYW5jaF9pbmZvLT5jb21taXQtPm9iamVjdC5vaWQsCisJCQkJCQkJIERFRkFVTFRfQUJCUkVWKTsKKwkJCQlvLmFuY2VzdG9yID0gb2xkX2NvbW1pdF9zaG9ydG5hbWUuYnVmOworCQkJfQogCQkJby5icmFuY2gxID0gbmV3X2JyYW5jaF9pbmZvLT5uYW1lOwogCQkJby5icmFuY2gyID0gImxvY2FsIjsKIAkJCXJldCA9IG1lcmdlX3RyZWVzKCZvLAogCQkJCQkgIG5ld190cmVlLAogCQkJCQkgIHdvcmssCi0JCQkJCSAgb2xkX3RyZWUsCi0JCQkJCSAgJnJlc3VsdCk7CisJCQkJCSAgb2xkX3RyZWUpOwogCQkJaWYgKHJldCA8IDApCiAJCQkJZXhpdCgxMjgpOwogCQkJcmV0ID0gcmVzZXRfdHJlZShuZXdfdHJlZSwKIAkJCQkJIG9wdHMsIDAsCiAJCQkJCSB3cml0ZW91dF9lcnJvcik7CiAJCQlzdHJidWZfcmVsZWFzZSgmby5vYnVmKTsKKwkJCXN0cmJ1Zl9yZWxlYXNlKCZvbGRfY29tbWl0X3Nob3J0bmFtZSk7CiAJCQlpZiAocmV0KQogCQkJCXJldHVybiByZXQ7CiAJCX0KQEAgLTE3MTQsNiArMTcxNCwxNSBAQAogCW9wdHMuY2hlY2tvdXRfaW5kZXggPSAtMjsgICAgLyogZGVmYXVsdCBvbiAqLwogCW9wdHMuY2hlY2tvdXRfd29ya3RyZWUgPSAtMjsgLyogZGVmYXVsdCBvbiAqLwogCisJaWYgKGFyZ2MgPT0gMyAmJiAhc3RyY21wKGFyZ3ZbMV0sICItYiIpKSB7CisJCS8qCisJCSAqIFVzZXIgcmFuICdnaXQgY2hlY2tvdXQgLWIgPGJyYW5jaD4nIGFuZCBleHBlY3RzCisJCSAqIHRoZSBzYW1lIGJlaGF2aW9yIGFzICdnaXQgc3dpdGNoIC1jIDxicmFuY2g+Jy4KKwkJICovCisJCW9wdHMuc3dpdGNoX2JyYW5jaF9kb2luZ19ub3RoaW5nX2lzX29rID0gMDsKKwkJb3B0cy5vbmx5X21lcmdlX29uX3N3aXRjaGluZ19icmFuY2hlcyA9IDE7CisJfQorCiAJb3B0aW9ucyA9IHBhcnNlX29wdGlvbnNfZHVwKGNoZWNrb3V0X29wdGlvbnMpOwogCW9wdGlvbnMgPSBhZGRfY29tbW9uX29wdGlvbnMoJm9wdHMsIG9wdGlvbnMpOwogCW9wdGlvbnMgPSBhZGRfY29tbW9uX3N3aXRjaF9icmFuY2hfb3B0aW9ucygmb3B0cywgb3B0aW9ucyk7CmRpZmYgLS1naXQgYS9idWlsdGluL2NsZWFuLmMgYi9idWlsdGluL2NsZWFuLmMKaW5kZXggZDU1NzlkYS4uNWFiZjA4NyAxMDA2NDQKLS0tIGEvYnVpbHRpbi9jbGVhbi5jCisrKyBiL2J1aWx0aW4vY2xlYW4uYwpAQCAtMTU4LDcgKzE1OCw4IEBACiAKIAkqZGlyX2dvbmUgPSAxOwogCi0JaWYgKChmb3JjZV9mbGFnICYgUkVNT1ZFX0RJUl9LRUVQX05FU1RFRF9HSVQpICYmIGlzX25vbmJhcmVfcmVwb3NpdG9yeV9kaXIocGF0aCkpIHsKKwlpZiAoKGZvcmNlX2ZsYWcgJiBSRU1PVkVfRElSX0tFRVBfTkVTVEVEX0dJVCkgJiYKKwkgICAgaXNfbm9uYmFyZV9yZXBvc2l0b3J5X2RpcihwYXRoKSkgewogCQlpZiAoIXF1aWV0KSB7CiAJCQlxdW90ZV9wYXRoX3JlbGF0aXZlKHBhdGgtPmJ1ZiwgcHJlZml4LCAmcXVvdGVkKTsKIAkJCXByaW50ZihkcnlfcnVuID8gIF8obXNnX3dvdWxkX3NraXBfZ2l0X2RpcikgOiBfKG1zZ19za2lwX2dpdF9kaXIpLApAQCAtNjQ4LDcgKzY0OSw3IEBACiAJc3RydWN0IHN0cmJ1ZiBjb25maXJtID0gU1RSQlVGX0lOSVQ7CiAJc3RydWN0IHN0cmJ1ZiAqKmlnbm9yZV9saXN0OwogCXN0cnVjdCBzdHJpbmdfbGlzdF9pdGVtICppdGVtOwotCXN0cnVjdCBleGNsdWRlX2xpc3QgKmVsOworCXN0cnVjdCBwYXR0ZXJuX2xpc3QgKnBsOwogCWludCBjaGFuZ2VkID0gLTEsIGk7CiAKIAlmb3IgKDs7KSB7CkBAIC02NzEsNyArNjcyLDcgQEAKIAkJCWJyZWFrOwogCiAJCW1lbXNldCgmZGlyLCAwLCBzaXplb2YoZGlyKSk7Ci0JCWVsID0gYWRkX2V4Y2x1ZGVfbGlzdCgmZGlyLCBFWENfQ01ETCwgIm1hbnVhbCBleGNsdWRlIik7CisJCXBsID0gYWRkX3BhdHRlcm5fbGlzdCgmZGlyLCBFWENfQ01ETCwgIm1hbnVhbCBleGNsdWRlIik7CiAJCWlnbm9yZV9saXN0ID0gc3RyYnVmX3NwbGl0X21heCgmY29uZmlybSwgJyAnLCAwKTsKIAogCQlmb3IgKGkgPSAwOyBpZ25vcmVfbGlzdFtpXTsgaSsrKSB7CkBAIC02NzksNyArNjgwLDcgQEAKIAkJCWlmICghaWdub3JlX2xpc3RbaV0tPmxlbikKIAkJCQljb250aW51ZTsKIAotCQkJYWRkX2V4Y2x1ZGUoaWdub3JlX2xpc3RbaV0tPmJ1ZiwgIiIsIDAsIGVsLCAtKGkrMSkpOworCQkJYWRkX3BhdHRlcm4oaWdub3JlX2xpc3RbaV0tPmJ1ZiwgIiIsIDAsIHBsLCAtKGkrMSkpOwogCQl9CiAKIAkJY2hhbmdlZCA9IDA7CkBAIC05MDEsNyArOTAyLDcgQEAKIAlzdHJ1Y3QgcGF0aHNwZWMgcGF0aHNwZWM7CiAJc3RydWN0IHN0cmJ1ZiBidWYgPSBTVFJCVUZfSU5JVDsKIAlzdHJ1Y3Qgc3RyaW5nX2xpc3QgZXhjbHVkZV9saXN0ID0gU1RSSU5HX0xJU1RfSU5JVF9OT0RVUDsKLQlzdHJ1Y3QgZXhjbHVkZV9saXN0ICplbDsKKwlzdHJ1Y3QgcGF0dGVybl9saXN0ICpwbDsKIAlzdHJ1Y3Qgc3RyaW5nX2xpc3RfaXRlbSAqaXRlbTsKIAljb25zdCBjaGFyICpxbmFtZTsKIAlzdHJ1Y3Qgb3B0aW9uIG9wdGlvbnNbXSA9IHsKQEAgLTk0Niw5ICs5NDcsMTkgQEAKIAogCWlmIChmb3JjZSA+IDEpCiAJCXJtX2ZsYWdzID0gMDsKKwllbHNlCisJCWRpci5mbGFncyB8PSBESVJfU0tJUF9ORVNURURfR0lUOwogCiAJZGlyLmZsYWdzIHw9IERJUl9TSE9XX09USEVSX0RJUkVDVE9SSUVTOwogCisJaWYgKGFyZ2MpIHsKKwkJLyoKKwkJICogUmVtYWluaW5nIGFyZ3MgaW1wbGllcyBwYXRoc3BlY3Mgc3BlY2lmaWVkLCBhbmQgd2Ugc2hvdWxkCisJCSAqIHJlY3Vyc2Ugd2l0aGluIHRob3NlLgorCQkgKi8KKwkJcmVtb3ZlX2RpcmVjdG9yaWVzID0gMTsKKwl9CisKIAlpZiAocmVtb3ZlX2RpcmVjdG9yaWVzKQogCQlkaXIuZmxhZ3MgfD0gRElSX1NIT1dfSUdOT1JFRF9UT08gfCBESVJfS0VFUF9VTlRSQUNLRURfQ09OVEVOVFM7CiAKQEAgLTk1OCw5ICs5NjksOSBAQAogCWlmICghaWdub3JlZCkKIAkJc2V0dXBfc3RhbmRhcmRfZXhjbHVkZXMoJmRpcik7CiAKLQllbCA9IGFkZF9leGNsdWRlX2xpc3QoJmRpciwgRVhDX0NNREwsICItLWV4Y2x1ZGUgb3B0aW9uIik7CisJcGwgPSBhZGRfcGF0dGVybl9saXN0KCZkaXIsIEVYQ19DTURMLCAiLS1leGNsdWRlIG9wdGlvbiIpOwogCWZvciAoaSA9IDA7IGkgPCBleGNsdWRlX2xpc3QubnI7IGkrKykKLQkJYWRkX2V4Y2x1ZGUoZXhjbHVkZV9saXN0Lml0ZW1zW2ldLnN0cmluZywgIiIsIDAsIGVsLCAtKGkrMSkpOworCQlhZGRfcGF0dGVybihleGNsdWRlX2xpc3QuaXRlbXNbaV0uc3RyaW5nLCAiIiwgMCwgcGwsIC0oaSsxKSk7CiAKIAlwYXJzZV9wYXRoc3BlYygmcGF0aHNwZWMsIDAsCiAJCSAgICAgICBQQVRIU1BFQ19QUkVGRVJfQ1dELApAQCAtMTAwNyw2ICsxMDE4LDcgQEAKIAlmb3JfZWFjaF9zdHJpbmdfbGlzdF9pdGVtKGl0ZW0sICZkZWxfbGlzdCkgewogCQlzdHJ1Y3Qgc3RhdCBzdDsKIAorCQlzdHJidWZfcmVzZXQoJmFic19wYXRoKTsKIAkJaWYgKHByZWZpeCkKIAkJCXN0cmJ1Zl9hZGRzdHIoJmFic19wYXRoLCBwcmVmaXgpOwogCkBAIC0xMDQwLDcgKzEwNTIsNiBAQAogCQkJCXByaW50ZihkcnlfcnVuID8gXyhtc2dfd291bGRfcmVtb3ZlKSA6IF8obXNnX3JlbW92ZSksIHFuYW1lKTsKIAkJCX0KIAkJfQotCQlzdHJidWZfcmVzZXQoJmFic19wYXRoKTsKIAl9CiAKIAlzdHJidWZfcmVsZWFzZSgmYWJzX3BhdGgpOwpkaWZmIC0tZ2l0IGEvYnVpbHRpbi9jbG9uZS5jIGIvYnVpbHRpbi9jbG9uZS5jCmluZGV4IGY2NjViMjguLjQwYzBiZjIgMTAwNjQ0Ci0tLSBhL2J1aWx0aW4vY2xvbmUuYworKysgYi9idWlsdGluL2Nsb25lLmMKQEAgLTMyLDcgKzMyLDYgQEAKICNpbmNsdWRlICJjb25uZWN0ZWQuaCIKICNpbmNsdWRlICJwYWNrZmlsZS5oIgogI2luY2x1ZGUgImxpc3Qtb2JqZWN0cy1maWx0ZXItb3B0aW9ucy5oIgotI2luY2x1ZGUgIm9iamVjdC1zdG9yZS5oIgogCiAvKgogICogT3ZlcmFsbCBGSVhNRXM6CkBAIC03ODUsNyArNzg0LDcgQEAKIAlpZiAod3JpdGVfbG9ja2VkX2luZGV4KCZ0aGVfaW5kZXgsICZsb2NrX2ZpbGUsIENPTU1JVF9MT0NLKSkKIAkJZGllKF8oInVuYWJsZSB0byB3cml0ZSBuZXcgaW5kZXggZmlsZSIpKTsKIAotCWVyciB8PSBydW5faG9va19sZShOVUxMLCAicG9zdC1jaGVja291dCIsIHNoYTFfdG9faGV4KG51bGxfc2hhMSksCisJZXJyIHw9IHJ1bl9ob29rX2xlKE5VTEwsICJwb3N0LWNoZWNrb3V0Iiwgb2lkX3RvX2hleCgmbnVsbF9vaWQpLAogCQkJICAgb2lkX3RvX2hleCgmb2lkKSwgIjEiLCBOVUxMKTsKIAogCWlmICghZXJyICYmIChvcHRpb25fcmVjdXJzZV9zdWJtb2R1bGVzLm5yID4gMCkpIHsKQEAgLTkwMCw3ICs4OTksNyBAQAogCWZyZWUoYWx0ZXJuYXRlcyk7CiB9CiAKLXN0YXRpYyBpbnQgZGlyX2V4aXN0cyhjb25zdCBjaGFyICpwYXRoKQorc3RhdGljIGludCBwYXRoX2V4aXN0cyhjb25zdCBjaGFyICpwYXRoKQogewogCXN0cnVjdCBzdGF0IHNiOwogCXJldHVybiAhc3RhdChwYXRoLCAmc2IpOwpAQCAtOTI4LDggKzkyNyw2IEBACiAKIAlzdHJ1Y3QgYXJndl9hcnJheSByZWZfcHJlZml4ZXMgPSBBUkdWX0FSUkFZX0lOSVQ7CiAKLQlmZXRjaF9pZl9taXNzaW5nID0gMDsKLQogCXBhY2tldF90cmFjZV9pZGVudGl0eSgiY2xvbmUiKTsKIAlhcmdjID0gcGFyc2Vfb3B0aW9ucyhhcmdjLCBhcmd2LCBwcmVmaXgsIGJ1aWx0aW5fY2xvbmVfb3B0aW9ucywKIAkJCSAgICAgYnVpbHRpbl9jbG9uZV91c2FnZSwgMCk7CkBAIC05ODIsNyArOTc5LDcgQEAKIAkJZGlyID0gZ3Vlc3NfZGlyX25hbWUocmVwb19uYW1lLCBpc19idW5kbGUsIG9wdGlvbl9iYXJlKTsKIAlzdHJpcF90cmFpbGluZ19zbGFzaGVzKGRpcik7CiAKLQlkZXN0X2V4aXN0cyA9IGRpcl9leGlzdHMoZGlyKTsKKwlkZXN0X2V4aXN0cyA9IHBhdGhfZXhpc3RzKGRpcik7CiAJaWYgKGRlc3RfZXhpc3RzICYmICFpc19lbXB0eV9kaXIoZGlyKSkKIAkJZGllKF8oImRlc3RpbmF0aW9uIHBhdGggJyVzJyBhbHJlYWR5IGV4aXN0cyBhbmQgaXMgbm90ICIKIAkJCSJhbiBlbXB0eSBkaXJlY3RvcnkuIiksIGRpcik7CkBAIC05OTMsNyArOTkwLDcgQEAKIAkJd29ya190cmVlID0gTlVMTDsKIAllbHNlIHsKIAkJd29ya190cmVlID0gZ2V0ZW52KCJHSVRfV09SS19UUkVFIik7Ci0JCWlmICh3b3JrX3RyZWUgJiYgZGlyX2V4aXN0cyh3b3JrX3RyZWUpKQorCQlpZiAod29ya190cmVlICYmIHBhdGhfZXhpc3RzKHdvcmtfdHJlZSkpCiAJCQlkaWUoXygid29ya2luZyB0cmVlICclcycgYWxyZWFkeSBleGlzdHMuIiksIHdvcmtfdHJlZSk7CiAJfQogCkBAIC0xMDIxLDcgKzEwMTgsNyBAQAogCX0KIAogCWlmIChyZWFsX2dpdF9kaXIpIHsKLQkJaWYgKGRpcl9leGlzdHMocmVhbF9naXRfZGlyKSkKKwkJaWYgKHBhdGhfZXhpc3RzKHJlYWxfZ2l0X2RpcikpCiAJCQlqdW5rX2dpdF9kaXJfZmxhZ3MgfD0gUkVNT1ZFX0RJUl9LRUVQX1RPUExFVkVMOwogCQlqdW5rX2dpdF9kaXIgPSByZWFsX2dpdF9kaXI7CiAJfSBlbHNlIHsKQEAgLTExNjAsMTMgKzExNTcsMTEgQEAKIAkJdHJhbnNwb3J0LT5zZXJ2ZXJfb3B0aW9ucyA9ICZzZXJ2ZXJfb3B0aW9uczsKIAogCWlmIChmaWx0ZXJfb3B0aW9ucy5jaG9pY2UpIHsKLQkJc3RydWN0IHN0cmJ1ZiBleHBhbmRlZF9maWx0ZXJfc3BlYyA9IFNUUkJVRl9JTklUOwotCQlleHBhbmRfbGlzdF9vYmplY3RzX2ZpbHRlcl9zcGVjKCZmaWx0ZXJfb3B0aW9ucywKLQkJCQkJCSZleHBhbmRlZF9maWx0ZXJfc3BlYyk7CisJCWNvbnN0IGNoYXIgKnNwZWMgPQorCQkJZXhwYW5kX2xpc3Rfb2JqZWN0c19maWx0ZXJfc3BlYygmZmlsdGVyX29wdGlvbnMpOwogCQl0cmFuc3BvcnRfc2V0X29wdGlvbih0cmFuc3BvcnQsIFRSQU5TX09QVF9MSVNUX09CSkVDVFNfRklMVEVSLAotCQkJCSAgICAgZXhwYW5kZWRfZmlsdGVyX3NwZWMuYnVmKTsKKwkJCQkgICAgIHNwZWMpOwogCQl0cmFuc3BvcnRfc2V0X29wdGlvbih0cmFuc3BvcnQsIFRSQU5TX09QVF9GUk9NX1BST01JU09SLCAiMSIpOwotCQlzdHJidWZfcmVsZWFzZSgmZXhwYW5kZWRfZmlsdGVyX3NwZWMpOwogCX0KIAogCWlmICh0cmFuc3BvcnQtPnNtYXJ0X29wdGlvbnMgJiYgIWRlZXBlbiAmJiAhZmlsdGVyX29wdGlvbnMuY2hvaWNlKQpAQCAtMTI2OCw3ICsxMjYzLDYgQEAKIAl9CiAKIAlqdW5rX21vZGUgPSBKVU5LX0xFQVZFX1JFUE87Ci0JZmV0Y2hfaWZfbWlzc2luZyA9IDE7CiAJZXJyID0gY2hlY2tvdXQoc3VibW9kdWxlX3Byb2dyZXNzKTsKIAogCXN0cmJ1Zl9yZWxlYXNlKCZyZWZsb2dfbXNnKTsKZGlmZiAtLWdpdCBhL2J1aWx0aW4vY29tbWl0LWdyYXBoLmMgYi9idWlsdGluL2NvbW1pdC1ncmFwaC5jCmluZGV4IDM4MDI3YjguLmUwYzZmYzQgMTAwNjQ0Ci0tLSBhL2J1aWx0aW4vY29tbWl0LWdyYXBoLmMKKysrIGIvYnVpbHRpbi9jb21taXQtZ3JhcGguYwpAQCAtOCwyNSArOCwxOCBAQAogI2luY2x1ZGUgIm9iamVjdC1zdG9yZS5oIgogCiBzdGF0aWMgY2hhciBjb25zdCAqIGNvbnN0IGJ1aWx0aW5fY29tbWl0X2dyYXBoX3VzYWdlW10gPSB7Ci0JTl8oImdpdCBjb21taXQtZ3JhcGggWy0tb2JqZWN0LWRpciA8b2JqZGlyPl0iKSwKLQlOXygiZ2l0IGNvbW1pdC1ncmFwaCByZWFkIFstLW9iamVjdC1kaXIgPG9iamRpcj5dIiksCi0JTl8oImdpdCBjb21taXQtZ3JhcGggdmVyaWZ5IFstLW9iamVjdC1kaXIgPG9iamRpcj5dIFstLXNoYWxsb3ddIiksCi0JTl8oImdpdCBjb21taXQtZ3JhcGggd3JpdGUgWy0tb2JqZWN0LWRpciA8b2JqZGlyPl0gWy0tYXBwZW5kfC0tc3BsaXRdIFstLXJlYWNoYWJsZXwtLXN0ZGluLXBhY2tzfC0tc3RkaW4tY29tbWl0c10gPHNwbGl0IG9wdGlvbnM+IiksCisJTl8oImdpdCBjb21taXQtZ3JhcGggdmVyaWZ5IFstLW9iamVjdC1kaXIgPG9iamRpcj5dIFstLXNoYWxsb3ddIFstLVtuby1dcHJvZ3Jlc3NdIiksCisJTl8oImdpdCBjb21taXQtZ3JhcGggd3JpdGUgWy0tb2JqZWN0LWRpciA8b2JqZGlyPl0gWy0tYXBwZW5kfC0tc3BsaXRdIFstLXJlYWNoYWJsZXwtLXN0ZGluLXBhY2tzfC0tc3RkaW4tY29tbWl0c10gWy0tW25vLV1wcm9ncmVzc10gPHNwbGl0IG9wdGlvbnM+IiksCiAJTlVMTAogfTsKIAogc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBidWlsdGluX2NvbW1pdF9ncmFwaF92ZXJpZnlfdXNhZ2VbXSA9IHsKLQlOXygiZ2l0IGNvbW1pdC1ncmFwaCB2ZXJpZnkgWy0tb2JqZWN0LWRpciA8b2JqZGlyPl0gWy0tc2hhbGxvd10iKSwKLQlOVUxMCi19OwotCi1zdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IGJ1aWx0aW5fY29tbWl0X2dyYXBoX3JlYWRfdXNhZ2VbXSA9IHsKLQlOXygiZ2l0IGNvbW1pdC1ncmFwaCByZWFkIFstLW9iamVjdC1kaXIgPG9iamRpcj5dIiksCisJTl8oImdpdCBjb21taXQtZ3JhcGggdmVyaWZ5IFstLW9iamVjdC1kaXIgPG9iamRpcj5dIFstLXNoYWxsb3ddIFstLVtuby1dcHJvZ3Jlc3NdIiksCiAJTlVMTAogfTsKIAogc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBidWlsdGluX2NvbW1pdF9ncmFwaF93cml0ZV91c2FnZVtdID0gewotCU5fKCJnaXQgY29tbWl0LWdyYXBoIHdyaXRlIFstLW9iamVjdC1kaXIgPG9iamRpcj5dIFstLWFwcGVuZHwtLXNwbGl0XSBbLS1yZWFjaGFibGV8LS1zdGRpbi1wYWNrc3wtLXN0ZGluLWNvbW1pdHNdIDxzcGxpdCBvcHRpb25zPiIpLAorCU5fKCJnaXQgY29tbWl0LWdyYXBoIHdyaXRlIFstLW9iamVjdC1kaXIgPG9iamRpcj5dIFstLWFwcGVuZHwtLXNwbGl0XSBbLS1yZWFjaGFibGV8LS1zdGRpbi1wYWNrc3wtLXN0ZGluLWNvbW1pdHNdIFstLVtuby1dcHJvZ3Jlc3NdIDxzcGxpdCBvcHRpb25zPiIpLAogCU5VTEwKIH07CiAKQEAgLTM4LDYgKzMxLDcgQEAKIAlpbnQgYXBwZW5kOwogCWludCBzcGxpdDsKIAlpbnQgc2hhbGxvdzsKKwlpbnQgcHJvZ3Jlc3M7CiB9IG9wdHM7CiAKIHN0YXRpYyBpbnQgZ3JhcGhfdmVyaWZ5KGludCBhcmdjLCBjb25zdCBjaGFyICoqYXJndikKQEAgLTU1LDkgKzQ5LDEzIEBACiAJCQkgICBOXygiVGhlIG9iamVjdCBkaXJlY3RvcnkgdG8gc3RvcmUgdGhlIGdyYXBoIikpLAogCQlPUFRfQk9PTCgwLCAic2hhbGxvdyIsICZvcHRzLnNoYWxsb3csCiAJCQkgTl8oImlmIHRoZSBjb21taXQtZ3JhcGggaXMgc3BsaXQsIG9ubHkgdmVyaWZ5IHRoZSB0aXAgZmlsZSIpKSwKKwkJT1BUX0JPT0woMCwgInByb2dyZXNzIiwgJm9wdHMucHJvZ3Jlc3MsIE5fKCJmb3JjZSBwcm9ncmVzcyByZXBvcnRpbmciKSksCiAJCU9QVF9FTkQoKSwKIAl9OwogCisJdHJhY2UyX2NtZF9tb2RlKCJ2ZXJpZnkiKTsKKworCW9wdHMucHJvZ3Jlc3MgPSBpc2F0dHkoMik7CiAJYXJnYyA9IHBhcnNlX29wdGlvbnMoYXJnYywgYXJndiwgTlVMTCwKIAkJCSAgICAgYnVpbHRpbl9jb21taXRfZ3JhcGhfdmVyaWZ5X29wdGlvbnMsCiAJCQkgICAgIGJ1aWx0aW5fY29tbWl0X2dyYXBoX3ZlcmlmeV91c2FnZSwgMCk7CkBAIC02Niw2ICs2NCw4IEBACiAJCW9wdHMub2JqX2RpciA9IGdldF9vYmplY3RfZGlyZWN0b3J5KCk7CiAJaWYgKG9wdHMuc2hhbGxvdykKIAkJZmxhZ3MgfD0gQ09NTUlUX0dSQVBIX1ZFUklGWV9TSEFMTE9XOworCWlmIChvcHRzLnByb2dyZXNzKQorCQlmbGFncyB8PSBDT01NSVRfR1JBUEhfV1JJVEVfUFJPR1JFU1M7CiAKIAlncmFwaF9uYW1lID0gZ2V0X2NvbW1pdF9ncmFwaF9maWxlbmFtZShvcHRzLm9ial9kaXIpOwogCW9wZW5fb2sgPSBvcGVuX2NvbW1pdF9ncmFwaChncmFwaF9uYW1lLCAmZmQsICZzdCk7CkBAIC04Nyw2NCArODcsNiBAQAogCXJldHVybiB2ZXJpZnlfY29tbWl0X2dyYXBoKHRoZV9yZXBvc2l0b3J5LCBncmFwaCwgZmxhZ3MpOwogfQogCi1zdGF0aWMgaW50IGdyYXBoX3JlYWQoaW50IGFyZ2MsIGNvbnN0IGNoYXIgKiphcmd2KQotewotCXN0cnVjdCBjb21taXRfZ3JhcGggKmdyYXBoID0gTlVMTDsKLQljaGFyICpncmFwaF9uYW1lOwotCWludCBvcGVuX29rOwotCWludCBmZDsKLQlzdHJ1Y3Qgc3RhdCBzdDsKLQotCXN0YXRpYyBzdHJ1Y3Qgb3B0aW9uIGJ1aWx0aW5fY29tbWl0X2dyYXBoX3JlYWRfb3B0aW9uc1tdID0gewotCQlPUFRfU1RSSU5HKDAsICJvYmplY3QtZGlyIiwgJm9wdHMub2JqX2RpciwKLQkJCU5fKCJkaXIiKSwKLQkJCU5fKCJUaGUgb2JqZWN0IGRpcmVjdG9yeSB0byBzdG9yZSB0aGUgZ3JhcGgiKSksCi0JCU9QVF9FTkQoKSwKLQl9OwotCi0JYXJnYyA9IHBhcnNlX29wdGlvbnMoYXJnYywgYXJndiwgTlVMTCwKLQkJCSAgICAgYnVpbHRpbl9jb21taXRfZ3JhcGhfcmVhZF9vcHRpb25zLAotCQkJICAgICBidWlsdGluX2NvbW1pdF9ncmFwaF9yZWFkX3VzYWdlLCAwKTsKLQotCWlmICghb3B0cy5vYmpfZGlyKQotCQlvcHRzLm9ial9kaXIgPSBnZXRfb2JqZWN0X2RpcmVjdG9yeSgpOwotCi0JZ3JhcGhfbmFtZSA9IGdldF9jb21taXRfZ3JhcGhfZmlsZW5hbWUob3B0cy5vYmpfZGlyKTsKLQotCW9wZW5fb2sgPSBvcGVuX2NvbW1pdF9ncmFwaChncmFwaF9uYW1lLCAmZmQsICZzdCk7Ci0JaWYgKCFvcGVuX29rKQotCQlkaWVfZXJybm8oXygiQ291bGQgbm90IG9wZW4gY29tbWl0LWdyYXBoICclcyciKSwgZ3JhcGhfbmFtZSk7Ci0KLQlncmFwaCA9IGxvYWRfY29tbWl0X2dyYXBoX29uZV9mZF9zdChmZCwgJnN0KTsKLQlpZiAoIWdyYXBoKQotCQlyZXR1cm4gMTsKLQotCUZSRUVfQU5EX05VTEwoZ3JhcGhfbmFtZSk7Ci0KLQlwcmludGYoImhlYWRlcjogJTA4eCAlZCAlZCAlZCAlZFxuIiwKLQkJbnRvaGwoKih1aW50MzJfdCopZ3JhcGgtPmRhdGEpLAotCQkqKHVuc2lnbmVkIGNoYXIqKShncmFwaC0+ZGF0YSArIDQpLAotCQkqKHVuc2lnbmVkIGNoYXIqKShncmFwaC0+ZGF0YSArIDUpLAotCQkqKHVuc2lnbmVkIGNoYXIqKShncmFwaC0+ZGF0YSArIDYpLAotCQkqKHVuc2lnbmVkIGNoYXIqKShncmFwaC0+ZGF0YSArIDcpKTsKLQlwcmludGYoIm51bV9jb21taXRzOiAldVxuIiwgZ3JhcGgtPm51bV9jb21taXRzKTsKLQlwcmludGYoImNodW5rczoiKTsKLQotCWlmIChncmFwaC0+Y2h1bmtfb2lkX2Zhbm91dCkKLQkJcHJpbnRmKCIgb2lkX2Zhbm91dCIpOwotCWlmIChncmFwaC0+Y2h1bmtfb2lkX2xvb2t1cCkKLQkJcHJpbnRmKCIgb2lkX2xvb2t1cCIpOwotCWlmIChncmFwaC0+Y2h1bmtfY29tbWl0X2RhdGEpCi0JCXByaW50ZigiIGNvbW1pdF9tZXRhZGF0YSIpOwotCWlmIChncmFwaC0+Y2h1bmtfZXh0cmFfZWRnZXMpCi0JCXByaW50ZigiIGV4dHJhX2VkZ2VzIik7Ci0JcHJpbnRmKCJcbiIpOwotCi0JVU5MRUFLKGdyYXBoKTsKLQotCXJldHVybiAwOwotfQotCiBleHRlcm4gaW50IHJlYWRfcmVwbGFjZV9yZWZzOwogc3RhdGljIHN0cnVjdCBzcGxpdF9jb21taXRfZ3JhcGhfb3B0cyBzcGxpdF9vcHRzOwogCkBAIC0xNTQsNyArOTYsNyBAQAogCXN0cnVjdCBzdHJpbmdfbGlzdCAqY29tbWl0X2hleCA9IE5VTEw7CiAJc3RydWN0IHN0cmluZ19saXN0IGxpbmVzOwogCWludCByZXN1bHQgPSAwOwotCXVuc2lnbmVkIGludCBmbGFncyA9IENPTU1JVF9HUkFQSF9QUk9HUkVTUzsKKwllbnVtIGNvbW1pdF9ncmFwaF93cml0ZV9mbGFncyBmbGFncyA9IDA7CiAKIAlzdGF0aWMgc3RydWN0IG9wdGlvbiBidWlsdGluX2NvbW1pdF9ncmFwaF93cml0ZV9vcHRpb25zW10gPSB7CiAJCU9QVF9TVFJJTkcoMCwgIm9iamVjdC1kaXIiLCAmb3B0cy5vYmpfZGlyLApAQCAtMTY4LDYgKzExMCw3IEBACiAJCQlOXygic3RhcnQgd2FsayBhdCBjb21taXRzIGxpc3RlZCBieSBzdGRpbiIpKSwKIAkJT1BUX0JPT0woMCwgImFwcGVuZCIsICZvcHRzLmFwcGVuZCwKIAkJCU5fKCJpbmNsdWRlIGFsbCBjb21taXRzIGFscmVhZHkgaW4gdGhlIGNvbW1pdC1ncmFwaCBmaWxlIikpLAorCQlPUFRfQk9PTCgwLCAicHJvZ3Jlc3MiLCAmb3B0cy5wcm9ncmVzcywgTl8oImZvcmNlIHByb2dyZXNzIHJlcG9ydGluZyIpKSwKIAkJT1BUX0JPT0woMCwgInNwbGl0IiwgJm9wdHMuc3BsaXQsCiAJCQlOXygiYWxsb3cgd3JpdGluZyBhbiBpbmNyZW1lbnRhbCBjb21taXQtZ3JhcGggZmlsZSIpKSwKIAkJT1BUX0lOVEVHRVIoMCwgIm1heC1jb21taXRzIiwgJnNwbGl0X29wdHMubWF4X2NvbW1pdHMsCkBAIC0xNzksMTAgKzEyMiwxMyBAQAogCQlPUFRfRU5EKCksCiAJfTsKIAorCW9wdHMucHJvZ3Jlc3MgPSBpc2F0dHkoMik7CiAJc3BsaXRfb3B0cy5zaXplX211bHRpcGxlID0gMjsKIAlzcGxpdF9vcHRzLm1heF9jb21taXRzID0gMDsKIAlzcGxpdF9vcHRzLmV4cGlyZV90aW1lID0gMDsKIAorCXRyYWNlMl9jbWRfbW9kZSgid3JpdGUiKTsKKwogCWFyZ2MgPSBwYXJzZV9vcHRpb25zKGFyZ2MsIGFyZ3YsIE5VTEwsCiAJCQkgICAgIGJ1aWx0aW5fY29tbWl0X2dyYXBoX3dyaXRlX29wdGlvbnMsCiAJCQkgICAgIGJ1aWx0aW5fY29tbWl0X2dyYXBoX3dyaXRlX3VzYWdlLCAwKTsKQEAgLTE5Miw5ICsxMzgsMTEgQEAKIAlpZiAoIW9wdHMub2JqX2RpcikKIAkJb3B0cy5vYmpfZGlyID0gZ2V0X29iamVjdF9kaXJlY3RvcnkoKTsKIAlpZiAob3B0cy5hcHBlbmQpCi0JCWZsYWdzIHw9IENPTU1JVF9HUkFQSF9BUFBFTkQ7CisJCWZsYWdzIHw9IENPTU1JVF9HUkFQSF9XUklURV9BUFBFTkQ7CiAJaWYgKG9wdHMuc3BsaXQpCi0JCWZsYWdzIHw9IENPTU1JVF9HUkFQSF9TUExJVDsKKwkJZmxhZ3MgfD0gQ09NTUlUX0dSQVBIX1dSSVRFX1NQTElUOworCWlmIChvcHRzLnByb2dyZXNzKQorCQlmbGFncyB8PSBDT01NSVRfR1JBUEhfV1JJVEVfUFJPR1JFU1M7CiAKIAlyZWFkX3JlcGxhY2VfcmVmcyA9IDA7CiAKQEAgLTIxMyw4ICsxNjEsMTAgQEAKIAogCQlpZiAob3B0cy5zdGRpbl9wYWNrcykKIAkJCXBhY2tfaW5kZXhlcyA9ICZsaW5lczsKLQkJaWYgKG9wdHMuc3RkaW5fY29tbWl0cykKKwkJaWYgKG9wdHMuc3RkaW5fY29tbWl0cykgewogCQkJY29tbWl0X2hleCA9ICZsaW5lczsKKwkJCWZsYWdzIHw9IENPTU1JVF9HUkFQSF9XUklURV9DSEVDS19PSURTOworCQl9CiAKIAkJVU5MRUFLKGJ1Zik7CiAJfQpAQCAtMjQ5LDkgKzE5OSw5IEBACiAJCQkgICAgIGJ1aWx0aW5fY29tbWl0X2dyYXBoX3VzYWdlLAogCQkJICAgICBQQVJTRV9PUFRfU1RPUF9BVF9OT05fT1BUSU9OKTsKIAorCXNhdmVfY29tbWl0X2J1ZmZlciA9IDA7CisKIAlpZiAoYXJnYyA+IDApIHsKLQkJaWYgKCFzdHJjbXAoYXJndlswXSwgInJlYWQiKSkKLQkJCXJldHVybiBncmFwaF9yZWFkKGFyZ2MsIGFyZ3YpOwogCQlpZiAoIXN0cmNtcChhcmd2WzBdLCAidmVyaWZ5IikpCiAJCQlyZXR1cm4gZ3JhcGhfdmVyaWZ5KGFyZ2MsIGFyZ3YpOwogCQlpZiAoIXN0cmNtcChhcmd2WzBdLCAid3JpdGUiKSkKZGlmZiAtLWdpdCBhL2J1aWx0aW4vY29tbWl0LmMgYi9idWlsdGluL2NvbW1pdC5jCmluZGV4IGFlN2FhZjYuLjI5NGRjNTcgMTAwNjQ0Ci0tLSBhL2J1aWx0aW4vY29tbWl0LmMKKysrIGIvYnVpbHRpbi9jb21taXQuYwpAQCAtNTEwLDcgKzUxMCw3IEBACiAJcy0+bm93YXJuID0gbm93YXJuOwogCXMtPmlzX2luaXRpYWwgPSBnZXRfb2lkKHMtPnJlZmVyZW5jZSwgJm9pZCkgPyAxIDogMDsKIAlpZiAoIXMtPmlzX2luaXRpYWwpCi0JCWhhc2hjcHkocy0+c2hhMV9jb21taXQsIG9pZC5oYXNoKTsKKwkJb2lkY3B5KCZzLT5vaWRfY29tbWl0LCAmb2lkKTsKIAlzLT5zdGF0dXNfZm9ybWF0ID0gc3RhdHVzX2Zvcm1hdDsKIAlzLT5pZ25vcmVfc3VibW9kdWxlX2FyZyA9IGlnbm9yZV9zdWJtb2R1bGVfYXJnOwogCkBAIC0xNDA2LDcgKzE0MDYsNyBAQAogCiAJcy5pc19pbml0aWFsID0gZ2V0X29pZChzLnJlZmVyZW5jZSwgJm9pZCkgPyAxIDogMDsKIAlpZiAoIXMuaXNfaW5pdGlhbCkKLQkJaGFzaGNweShzLnNoYTFfY29tbWl0LCBvaWQuaGFzaCk7CisJCW9pZGNweSgmcy5vaWRfY29tbWl0LCAmb2lkKTsKIAogCXMuaWdub3JlX3N1Ym1vZHVsZV9hcmcgPSBpZ25vcmVfc3VibW9kdWxlX2FyZzsKIAlzLnN0YXR1c19mb3JtYXQgPSBzdGF0dXNfZm9ybWF0OwpAQCAtMTQ2MywyOCArMTQ2Myw2IEBACiAJcmV0dXJuIGdpdF9zdGF0dXNfY29uZmlnKGssIHYsIHMpOwogfQogCi1pbnQgcnVuX2NvbW1pdF9ob29rKGludCBlZGl0b3JfaXNfdXNlZCwgY29uc3QgY2hhciAqaW5kZXhfZmlsZSwgY29uc3QgY2hhciAqbmFtZSwgLi4uKQotewotCXN0cnVjdCBhcmd2X2FycmF5IGhvb2tfZW52ID0gQVJHVl9BUlJBWV9JTklUOwotCXZhX2xpc3QgYXJnczsKLQlpbnQgcmV0OwotCi0JYXJndl9hcnJheV9wdXNoZigmaG9va19lbnYsICJHSVRfSU5ERVhfRklMRT0lcyIsIGluZGV4X2ZpbGUpOwotCi0JLyoKLQkgKiBMZXQgdGhlIGhvb2sga25vdyB0aGF0IG5vIGVkaXRvciB3aWxsIGJlIGxhdW5jaGVkLgotCSAqLwotCWlmICghZWRpdG9yX2lzX3VzZWQpCi0JCWFyZ3ZfYXJyYXlfcHVzaCgmaG9va19lbnYsICJHSVRfRURJVE9SPToiKTsKLQotCXZhX3N0YXJ0KGFyZ3MsIG5hbWUpOwotCXJldCA9IHJ1bl9ob29rX3ZlKGhvb2tfZW52LmFyZ3YsbmFtZSwgYXJncyk7Ci0JdmFfZW5kKGFyZ3MpOwotCWFyZ3ZfYXJyYXlfY2xlYXIoJmhvb2tfZW52KTsKLQotCXJldHVybiByZXQ7Ci19Ci0KIGludCBjbWRfY29tbWl0KGludCBhcmdjLCBjb25zdCBjaGFyICoqYXJndiwgY29uc3QgY2hhciAqcHJlZml4KQogewogCWNvbnN0IGNoYXIgKmFyZ3ZfZ2NfYXV0b1tdID0geyJnYyIsICItLWF1dG8iLCBOVUxMfTsKZGlmZiAtLWdpdCBhL2J1aWx0aW4vZGVzY3JpYmUuYyBiL2J1aWx0aW4vZGVzY3JpYmUuYwppbmRleCAyMDAxNTQyLi5iNmRmODFkIDEwMDY0NAotLS0gYS9idWlsdGluL2Rlc2NyaWJlLmMKKysrIGIvYnVpbHRpbi9kZXNjcmliZS5jCkBAIC0xNSw3ICsxNSw2IEBACiAjaW5jbHVkZSAiYXJndi1hcnJheS5oIgogI2luY2x1ZGUgInJ1bi1jb21tYW5kLmgiCiAjaW5jbHVkZSAib2JqZWN0LXN0b3JlLmgiCi0jaW5jbHVkZSAicmV2aXNpb24uaCIKICNpbmNsdWRlICJsaXN0LW9iamVjdHMuaCIKICNpbmNsdWRlICJjb21taXQtc2xhYi5oIgogCkBAIC02NCwxOSArNjMsMjIgQEAKIH07CiAKIHN0YXRpYyBpbnQgY29tbWl0X25hbWVfbmVxKGNvbnN0IHZvaWQgKnVudXNlZF9jbXBfZGF0YSwKLQkJCSAgIGNvbnN0IHZvaWQgKmVudHJ5LAotCQkJICAgY29uc3Qgdm9pZCAqZW50cnlfb3Jfa2V5LAorCQkJICAgY29uc3Qgc3RydWN0IGhhc2htYXBfZW50cnkgKmVwdHIsCisJCQkgICBjb25zdCBzdHJ1Y3QgaGFzaG1hcF9lbnRyeSAqZW50cnlfb3Jfa2V5LAogCQkJICAgY29uc3Qgdm9pZCAqcGVlbGVkKQogewotCWNvbnN0IHN0cnVjdCBjb21taXRfbmFtZSAqY24xID0gZW50cnk7Ci0JY29uc3Qgc3RydWN0IGNvbW1pdF9uYW1lICpjbjIgPSBlbnRyeV9vcl9rZXk7CisJY29uc3Qgc3RydWN0IGNvbW1pdF9uYW1lICpjbjEsICpjbjI7CisKKwljbjEgPSBjb250YWluZXJfb2YoZXB0ciwgY29uc3Qgc3RydWN0IGNvbW1pdF9uYW1lLCBlbnRyeSk7CisJY24yID0gY29udGFpbmVyX29mKGVudHJ5X29yX2tleSwgY29uc3Qgc3RydWN0IGNvbW1pdF9uYW1lLCBlbnRyeSk7CiAKIAlyZXR1cm4gIW9pZGVxKCZjbjEtPnBlZWxlZCwgcGVlbGVkID8gcGVlbGVkIDogJmNuMi0+cGVlbGVkKTsKIH0KIAogc3RhdGljIGlubGluZSBzdHJ1Y3QgY29tbWl0X25hbWUgKmZpbmRfY29tbWl0X25hbWUoY29uc3Qgc3RydWN0IG9iamVjdF9pZCAqcGVlbGVkKQogewotCXJldHVybiBoYXNobWFwX2dldF9mcm9tX2hhc2goJm5hbWVzLCBvaWRoYXNoKHBlZWxlZCksIHBlZWxlZCk7CisJcmV0dXJuIGhhc2htYXBfZ2V0X2VudHJ5X2Zyb21faGFzaCgmbmFtZXMsIG9pZGhhc2gocGVlbGVkKSwgcGVlbGVkLAorCQkJCQkJc3RydWN0IGNvbW1pdF9uYW1lLCBlbnRyeSk7CiB9CiAKIHN0YXRpYyBpbnQgcmVwbGFjZV9uYW1lKHN0cnVjdCBjb21taXRfbmFtZSAqZSwKQEAgLTEyMyw4ICsxMjUsOCBAQAogCQlpZiAoIWUpIHsKIAkJCWUgPSB4bWFsbG9jKHNpemVvZihzdHJ1Y3QgY29tbWl0X25hbWUpKTsKIAkJCW9pZGNweSgmZS0+cGVlbGVkLCBwZWVsZWQpOwotCQkJaGFzaG1hcF9lbnRyeV9pbml0KGUsIG9pZGhhc2gocGVlbGVkKSk7Ci0JCQloYXNobWFwX2FkZCgmbmFtZXMsIGUpOworCQkJaGFzaG1hcF9lbnRyeV9pbml0KCZlLT5lbnRyeSwgb2lkaGFzaChwZWVsZWQpKTsKKwkJCWhhc2htYXBfYWRkKCZuYW1lcywgJmUtPmVudHJ5KTsKIAkJCWUtPnBhdGggPSBOVUxMOwogCQl9CiAJCWUtPnRhZyA9IHRhZzsKQEAgLTMxMyw3ICszMTUsNyBAQAogCQkgKi8KIAkJYXBwZW5kX25hbWUobiwgZHN0KTsKIAkJaWYgKGxvbmdmb3JtYXQpCi0JCQlhcHBlbmRfc3VmZml4KDAsIG4tPnRhZyA/ICZuLT50YWctPnRhZ2dlZC0+b2lkIDogb2lkLCBkc3QpOworCQkJYXBwZW5kX3N1ZmZpeCgwLCBuLT50YWcgPyBnZXRfdGFnZ2VkX29pZChuLT50YWcpIDogb2lkLCBkc3QpOwogCQlpZiAoc3VmZml4KQogCQkJc3RyYnVmX2FkZHN0cihkc3QsIHN1ZmZpeCk7CiAJCXJldHVybjsKQEAgLTMzMCw4ICszMzIsOCBAQAogCQlzdHJ1Y3QgY29tbWl0X25hbWUgKm47CiAKIAkJaW5pdF9jb21taXRfbmFtZXMoJmNvbW1pdF9uYW1lcyk7Ci0JCW4gPSBoYXNobWFwX2l0ZXJfZmlyc3QoJm5hbWVzLCAmaXRlcik7Ci0JCWZvciAoOyBuOyBuID0gaGFzaG1hcF9pdGVyX25leHQoJml0ZXIpKSB7CisJCWhhc2htYXBfZm9yX2VhY2hfZW50cnkoJm5hbWVzLCAmaXRlciwgbiwKKwkJCQkJZW50cnkgLyogbWVtYmVyIG5hbWUgKi8pIHsKIAkJCWMgPSBsb29rdXBfY29tbWl0X3JlZmVyZW5jZV9nZW50bHkodGhlX3JlcG9zaXRvcnksCiAJCQkJCQkJICAgJm4tPnBlZWxlZCwgMSk7CiAJCQlpZiAoYykKZGlmZiAtLWdpdCBhL2J1aWx0aW4vZGlmZnRvb2wuYyBiL2J1aWx0aW4vZGlmZnRvb2wuYwppbmRleCAxNmViOGI3Li5jMjgwZTY4IDEwMDY0NAotLS0gYS9idWlsdGluL2RpZmZ0b29sLmMKKysrIGIvYnVpbHRpbi9kaWZmdG9vbC5jCkBAIC0xMjUsMTIgKzEyNSwxNSBAQAogfTsKIAogc3RhdGljIGludCB3b3JraW5nX3RyZWVfZW50cnlfY21wKGNvbnN0IHZvaWQgKnVudXNlZF9jbXBfZGF0YSwKLQkJCQkgIGNvbnN0IHZvaWQgKmVudHJ5LAotCQkJCSAgY29uc3Qgdm9pZCAqZW50cnlfb3Jfa2V5LAorCQkJCSAgY29uc3Qgc3RydWN0IGhhc2htYXBfZW50cnkgKmVwdHIsCisJCQkJICBjb25zdCBzdHJ1Y3QgaGFzaG1hcF9lbnRyeSAqZW50cnlfb3Jfa2V5LAogCQkJCSAgY29uc3Qgdm9pZCAqdW51c2VkX2tleWRhdGEpCiB7Ci0JY29uc3Qgc3RydWN0IHdvcmtpbmdfdHJlZV9lbnRyeSAqYSA9IGVudHJ5OwotCWNvbnN0IHN0cnVjdCB3b3JraW5nX3RyZWVfZW50cnkgKmIgPSBlbnRyeV9vcl9rZXk7CisJY29uc3Qgc3RydWN0IHdvcmtpbmdfdHJlZV9lbnRyeSAqYSwgKmI7CisKKwlhID0gY29udGFpbmVyX29mKGVwdHIsIGNvbnN0IHN0cnVjdCB3b3JraW5nX3RyZWVfZW50cnksIGVudHJ5KTsKKwliID0gY29udGFpbmVyX29mKGVudHJ5X29yX2tleSwgY29uc3Qgc3RydWN0IHdvcmtpbmdfdHJlZV9lbnRyeSwgZW50cnkpOworCiAJcmV0dXJuIHN0cmNtcChhLT5wYXRoLCBiLT5wYXRoKTsKIH0KIApAQCAtMTQ1LDEyICsxNDgsMTQgQEAKIH07CiAKIHN0YXRpYyBpbnQgcGFpcl9jbXAoY29uc3Qgdm9pZCAqdW51c2VkX2NtcF9kYXRhLAotCQkgICAgY29uc3Qgdm9pZCAqZW50cnksCi0JCSAgICBjb25zdCB2b2lkICplbnRyeV9vcl9rZXksCisJCSAgICBjb25zdCBzdHJ1Y3QgaGFzaG1hcF9lbnRyeSAqZXB0ciwKKwkJICAgIGNvbnN0IHN0cnVjdCBoYXNobWFwX2VudHJ5ICplbnRyeV9vcl9rZXksCiAJCSAgICBjb25zdCB2b2lkICp1bnVzZWRfa2V5ZGF0YSkKIHsKLQljb25zdCBzdHJ1Y3QgcGFpcl9lbnRyeSAqYSA9IGVudHJ5OwotCWNvbnN0IHN0cnVjdCBwYWlyX2VudHJ5ICpiID0gZW50cnlfb3Jfa2V5OworCWNvbnN0IHN0cnVjdCBwYWlyX2VudHJ5ICphLCAqYjsKKworCWEgPSBjb250YWluZXJfb2YoZXB0ciwgY29uc3Qgc3RydWN0IHBhaXJfZW50cnksIGVudHJ5KTsKKwliID0gY29udGFpbmVyX29mKGVudHJ5X29yX2tleSwgY29uc3Qgc3RydWN0IHBhaXJfZW50cnksIGVudHJ5KTsKIAogCXJldHVybiBzdHJjbXAoYS0+cGF0aCwgYi0+cGF0aCk7CiB9CkBAIC0xNjEsMTQgKzE2NiwxNCBAQAogCXN0cnVjdCBwYWlyX2VudHJ5ICplLCAqZXhpc3Rpbmc7CiAKIAlGTEVYX0FMTE9DX1NUUihlLCBwYXRoLCBwYXRoKTsKLQloYXNobWFwX2VudHJ5X2luaXQoZSwgc3RyaGFzaChwYXRoKSk7Ci0JZXhpc3RpbmcgPSBoYXNobWFwX2dldChtYXAsIGUsIE5VTEwpOworCWhhc2htYXBfZW50cnlfaW5pdCgmZS0+ZW50cnksIHN0cmhhc2gocGF0aCkpOworCWV4aXN0aW5nID0gaGFzaG1hcF9nZXRfZW50cnkobWFwLCBlLCBlbnRyeSwgTlVMTCk7CiAJaWYgKGV4aXN0aW5nKSB7CiAJCWZyZWUoZSk7CiAJCWUgPSBleGlzdGluZzsKIAl9IGVsc2UgewogCQllLT5sZWZ0WzBdID0gZS0+cmlnaHRbMF0gPSAnXDAnOwotCQloYXNobWFwX2FkZChtYXAsIGUpOworCQloYXNobWFwX2FkZChtYXAsICZlLT5lbnRyeSk7CiAJfQogCXN0cmxjcHkoaXNfcmlnaHQgPyBlLT5yaWdodCA6IGUtPmxlZnQsIGNvbnRlbnQsIFBBVEhfTUFYKTsKIH0KQEAgLTE3OSwxMiArMTg0LDE0IEBACiB9OwogCiBzdGF0aWMgaW50IHBhdGhfZW50cnlfY21wKGNvbnN0IHZvaWQgKnVudXNlZF9jbXBfZGF0YSwKLQkJCSAgY29uc3Qgdm9pZCAqZW50cnksCi0JCQkgIGNvbnN0IHZvaWQgKmVudHJ5X29yX2tleSwKKwkJCSAgY29uc3Qgc3RydWN0IGhhc2htYXBfZW50cnkgKmVwdHIsCisJCQkgIGNvbnN0IHN0cnVjdCBoYXNobWFwX2VudHJ5ICplbnRyeV9vcl9rZXksCiAJCQkgIGNvbnN0IHZvaWQgKmtleSkKIHsKLQljb25zdCBzdHJ1Y3QgcGF0aF9lbnRyeSAqYSA9IGVudHJ5OwotCWNvbnN0IHN0cnVjdCBwYXRoX2VudHJ5ICpiID0gZW50cnlfb3Jfa2V5OworCWNvbnN0IHN0cnVjdCBwYXRoX2VudHJ5ICphLCAqYjsKKworCWEgPSBjb250YWluZXJfb2YoZXB0ciwgY29uc3Qgc3RydWN0IHBhdGhfZW50cnksIGVudHJ5KTsKKwliID0gY29udGFpbmVyX29mKGVudHJ5X29yX2tleSwgY29uc3Qgc3RydWN0IHBhdGhfZW50cnksIGVudHJ5KTsKIAogCXJldHVybiBzdHJjbXAoYS0+cGF0aCwga2V5ID8ga2V5IDogYi0+cGF0aCk7CiB9CkBAIC0yMzQsOCArMjQxLDggQEAKIAl3aGlsZSAoIXN0cmJ1Zl9nZXRsaW5lX251bCgmYnVmLCBmcCkpIHsKIAkJc3RydWN0IHBhdGhfZW50cnkgKmVudHJ5OwogCQlGTEVYX0FMTE9DX1NUUihlbnRyeSwgcGF0aCwgYnVmLmJ1Zik7Ci0JCWhhc2htYXBfZW50cnlfaW5pdChlbnRyeSwgc3RyaGFzaChidWYuYnVmKSk7Ci0JCWhhc2htYXBfYWRkKHJlc3VsdCwgZW50cnkpOworCQloYXNobWFwX2VudHJ5X2luaXQoJmVudHJ5LT5lbnRyeSwgc3RyaGFzaChidWYuYnVmKSk7CisJCWhhc2htYXBfYWRkKHJlc3VsdCwgJmVudHJ5LT5lbnRyeSk7CiAJfQogCWZjbG9zZShmcCk7CiAJaWYgKGZpbmlzaF9jb21tYW5kKCZkaWZmX2ZpbGVzKSkKQEAgLTQ2MSwxMiArNDY4LDEzIEBACiAKIAkJCS8qIEF2b2lkIGR1cGxpY2F0ZSB3b3JraW5nX3RyZWUgZW50cmllcyAqLwogCQkJRkxFWF9BTExPQ19TVFIoZW50cnksIHBhdGgsIGRzdF9wYXRoKTsKLQkJCWhhc2htYXBfZW50cnlfaW5pdChlbnRyeSwgc3RyaGFzaChkc3RfcGF0aCkpOwotCQkJaWYgKGhhc2htYXBfZ2V0KCZ3b3JraW5nX3RyZWVfZHVwcywgZW50cnksIE5VTEwpKSB7CisJCQloYXNobWFwX2VudHJ5X2luaXQoJmVudHJ5LT5lbnRyeSwgc3RyaGFzaChkc3RfcGF0aCkpOworCQkJaWYgKGhhc2htYXBfZ2V0KCZ3b3JraW5nX3RyZWVfZHVwcywgJmVudHJ5LT5lbnRyeSwKKwkJCQkJTlVMTCkpIHsKIAkJCQlmcmVlKGVudHJ5KTsKIAkJCQljb250aW51ZTsKIAkJCX0KLQkJCWhhc2htYXBfYWRkKCZ3b3JraW5nX3RyZWVfZHVwcywgZW50cnkpOworCQkJaGFzaG1hcF9hZGQoJndvcmtpbmdfdHJlZV9kdXBzLCAmZW50cnktPmVudHJ5KTsKIAogCQkJaWYgKCF1c2Vfd3RfZmlsZSh3b3JrZGlyLCBkc3RfcGF0aCwgJnJvaWQpKSB7CiAJCQkJaWYgKGNoZWNrb3V0X3BhdGgocm1vZGUsICZyb2lkLCBkc3RfcGF0aCwKQEAgLTUzMCw4ICs1MzgsOCBAQAogCSAqIHRlbXBvcmFyeSBmaWxlIHRvIGJvdGggdGhlIGxlZnQgYW5kIHJpZ2h0IGRpcmVjdG9yaWVzIHRvIHNob3cgdGhlCiAJICogY2hhbmdlIGluIHRoZSByZWNvcmRlZCBTSEExIGZvciB0aGUgc3VibW9kdWxlLgogCSAqLwotCWhhc2htYXBfaXRlcl9pbml0KCZzdWJtb2R1bGVzLCAmaXRlcik7Ci0Jd2hpbGUgKChlbnRyeSA9IGhhc2htYXBfaXRlcl9uZXh0KCZpdGVyKSkpIHsKKwloYXNobWFwX2Zvcl9lYWNoX2VudHJ5KCZzdWJtb2R1bGVzLCAmaXRlciwgZW50cnksCisJCQkJZW50cnkgLyogbWVtYmVyIG5hbWUgKi8pIHsKIAkJaWYgKCplbnRyeS0+bGVmdCkgewogCQkJYWRkX3BhdGgoJmxkaXIsIGxkaXJfbGVuLCBlbnRyeS0+cGF0aCk7CiAJCQllbnN1cmVfbGVhZGluZ19kaXJlY3RvcmllcyhsZGlyLmJ1Zik7CkBAIC01NDksOCArNTU3LDggQEAKIAkgKiBzaG93cyBvbmx5IHRoZSBsaW5rIGl0c2VsZiwgbm90IHRoZSBjb250ZW50cyBvZiB0aGUgbGluayB0YXJnZXQuCiAJICogVGhpcyBsb29wIHJlcGxpY2F0ZXMgdGhhdCBiZWhhdmlvci4KIAkgKi8KLQloYXNobWFwX2l0ZXJfaW5pdCgmc3ltbGlua3MyLCAmaXRlcik7Ci0Jd2hpbGUgKChlbnRyeSA9IGhhc2htYXBfaXRlcl9uZXh0KCZpdGVyKSkpIHsKKwloYXNobWFwX2Zvcl9lYWNoX2VudHJ5KCZzeW1saW5rczIsICZpdGVyLCBlbnRyeSwKKwkJCQllbnRyeSAvKiBtZW1iZXIgbmFtZSAqLykgewogCQlpZiAoKmVudHJ5LT5sZWZ0KSB7CiAJCQlhZGRfcGF0aCgmbGRpciwgbGRpcl9sZW4sIGVudHJ5LT5wYXRoKTsKIAkJCWVuc3VyZV9sZWFkaW5nX2RpcmVjdG9yaWVzKGxkaXIuYnVmKTsKZGlmZiAtLWdpdCBhL2J1aWx0aW4vZmFzdC1leHBvcnQuYyBiL2J1aWx0aW4vZmFzdC1leHBvcnQuYwppbmRleCBmNTQxZjU1Li5kYmVjNGRmIDEwMDY0NAotLS0gYS9idWlsdGluL2Zhc3QtZXhwb3J0LmMKKysrIGIvYnVpbHRpbi9mYXN0LWV4cG9ydC5jCkBAIC00MCw2ICs0MCw3IEBACiBzdGF0aWMgaW50IGZ1bGxfdHJlZTsKIHN0YXRpYyBpbnQgcmVmZXJlbmNlX2V4Y2x1ZGVkX2NvbW1pdHM7CiBzdGF0aWMgaW50IHNob3dfb3JpZ2luYWxfaWRzOworc3RhdGljIGludCBtYXJrX3RhZ3M7CiBzdGF0aWMgc3RydWN0IHN0cmluZ19saXN0IGV4dHJhX3JlZnMgPSBTVFJJTkdfTElTVF9JTklUX05PRFVQOwogc3RhdGljIHN0cnVjdCBzdHJpbmdfbGlzdCB0YWdfcmVmcyA9IFNUUklOR19MSVNUX0lOSVRfTk9EVVA7CiBzdGF0aWMgc3RydWN0IHJlZnNwZWMgcmVmc3BlY3MgPSBSRUZTUEVDX0lOSVRfRkVUQ0g7CkBAIC0xMjYsMTAgKzEyNywxNSBAQAogfTsKIAogc3RhdGljIGludCBhbm9ueW1pemVkX2VudHJ5X2NtcChjb25zdCB2b2lkICp1bnVzZWRfY21wX2RhdGEsCi0JCQkJY29uc3Qgdm9pZCAqdmEsIGNvbnN0IHZvaWQgKnZiLAorCQkJCWNvbnN0IHN0cnVjdCBoYXNobWFwX2VudHJ5ICplcHRyLAorCQkJCWNvbnN0IHN0cnVjdCBoYXNobWFwX2VudHJ5ICplbnRyeV9vcl9rZXksCiAJCQkJY29uc3Qgdm9pZCAqdW51c2VkX2tleWRhdGEpCiB7Ci0JY29uc3Qgc3RydWN0IGFub255bWl6ZWRfZW50cnkgKmEgPSB2YSwgKmIgPSB2YjsKKwljb25zdCBzdHJ1Y3QgYW5vbnltaXplZF9lbnRyeSAqYSwgKmI7CisKKwlhID0gY29udGFpbmVyX29mKGVwdHIsIGNvbnN0IHN0cnVjdCBhbm9ueW1pemVkX2VudHJ5LCBoYXNoKTsKKwliID0gY29udGFpbmVyX29mKGVudHJ5X29yX2tleSwgY29uc3Qgc3RydWN0IGFub255bWl6ZWRfZW50cnksIGhhc2gpOworCiAJcmV0dXJuIGEtPm9yaWdfbGVuICE9IGItPm9yaWdfbGVuIHx8CiAJCW1lbWNtcChhLT5vcmlnLCBiLT5vcmlnLCBhLT5vcmlnX2xlbik7CiB9CkBAIC0xNDgsMTAgKzE1NCwxMCBAQAogCWlmICghbWFwLT5jbXBmbikKIAkJaGFzaG1hcF9pbml0KG1hcCwgYW5vbnltaXplZF9lbnRyeV9jbXAsIE5VTEwsIDApOwogCi0JaGFzaG1hcF9lbnRyeV9pbml0KCZrZXksIG1lbWhhc2gob3JpZywgKmxlbikpOworCWhhc2htYXBfZW50cnlfaW5pdCgma2V5Lmhhc2gsIG1lbWhhc2gob3JpZywgKmxlbikpOwogCWtleS5vcmlnID0gb3JpZzsKIAlrZXkub3JpZ19sZW4gPSAqbGVuOwotCXJldCA9IGhhc2htYXBfZ2V0KG1hcCwgJmtleSwgTlVMTCk7CisJcmV0ID0gaGFzaG1hcF9nZXRfZW50cnkobWFwLCAma2V5LCBoYXNoLCBOVUxMKTsKIAogCWlmICghcmV0KSB7CiAJCXJldCA9IHhtYWxsb2Moc2l6ZW9mKCpyZXQpKTsKQEAgLTE2MCw3ICsxNjYsNyBAQAogCQlyZXQtPm9yaWdfbGVuID0gKmxlbjsKIAkJcmV0LT5hbm9uID0gZ2VuZXJhdGUob3JpZywgbGVuKTsKIAkJcmV0LT5hbm9uX2xlbiA9ICpsZW47Ci0JCWhhc2htYXBfcHV0KG1hcCwgcmV0KTsKKwkJaGFzaG1hcF9wdXQobWFwLCAmcmV0LT5oYXNoKTsKIAl9CiAKIAkqbGVuID0gcmV0LT5hbm9uX2xlbjsKQEAgLTg0MiwyNSArODQ4LDQwIEBACiAJCQlmcmVlKGJ1Zik7CiAJCQlyZXR1cm47CiAJCWNhc2UgUkVXUklURToKLQkJCWlmICh0YWdnZWQtPnR5cGUgIT0gT0JKX0NPTU1JVCkgewotCQkJCWRpZSgidGFnICVzIHRhZ3MgdW5leHBvcnRlZCAlcyEiLAotCQkJCSAgICBvaWRfdG9faGV4KCZ0YWctPm9iamVjdC5vaWQpLAotCQkJCSAgICB0eXBlX25hbWUodGFnZ2VkLT50eXBlKSk7CisJCQlpZiAodGFnZ2VkLT50eXBlID09IE9CSl9UQUcgJiYgIW1hcmtfdGFncykgeworCQkJCWRpZShfKCJFcnJvcjogQ2Fubm90IGV4cG9ydCBuZXN0ZWQgdGFncyB1bmxlc3MgLS1tYXJrLXRhZ3MgaXMgc3BlY2lmaWVkLiIpKTsKKwkJCX0gZWxzZSBpZiAodGFnZ2VkLT50eXBlID09IE9CSl9DT01NSVQpIHsKKwkJCQlwID0gcmV3cml0ZV9jb21taXQoKHN0cnVjdCBjb21taXQgKil0YWdnZWQpOworCQkJCWlmICghcCkgeworCQkJCQlwcmludGYoInJlc2V0ICVzXG5mcm9tICVzXG5cbiIsCisJCQkJCSAgICAgICBuYW1lLCBvaWRfdG9faGV4KCZudWxsX29pZCkpOworCQkJCQlmcmVlKGJ1Zik7CisJCQkJCXJldHVybjsKKwkJCQl9CisJCQkJdGFnZ2VkX21hcmsgPSBnZXRfb2JqZWN0X21hcmsoJnAtPm9iamVjdCk7CisJCQl9IGVsc2UgeworCQkJCS8qIHRhZ2dlZC0+dHlwZSBpcyBlaXRoZXIgT0JKX0JMT0Igb3IgT0JKX1RBRyAqLworCQkJCXRhZ2dlZF9tYXJrID0gZ2V0X29iamVjdF9tYXJrKHRhZ2dlZCk7CiAJCQl9Ci0JCQlwID0gcmV3cml0ZV9jb21taXQoKHN0cnVjdCBjb21taXQgKil0YWdnZWQpOwotCQkJaWYgKCFwKSB7Ci0JCQkJcHJpbnRmKCJyZXNldCAlc1xuZnJvbSAlc1xuXG4iLAotCQkJCSAgICAgICBuYW1lLCBvaWRfdG9faGV4KCZudWxsX29pZCkpOwotCQkJCWZyZWUoYnVmKTsKLQkJCQlyZXR1cm47Ci0JCQl9Ci0JCQl0YWdnZWRfbWFyayA9IGdldF9vYmplY3RfbWFyaygmcC0+b2JqZWN0KTsKIAkJfQogCX0KIAorCWlmICh0YWdnZWQtPnR5cGUgPT0gT0JKX1RBRykgeworCQlwcmludGYoInJlc2V0ICVzXG5mcm9tICVzXG5cbiIsCisJCSAgICAgICBuYW1lLCBvaWRfdG9faGV4KCZudWxsX29pZCkpOworCX0KIAlpZiAoc3RhcnRzX3dpdGgobmFtZSwgInJlZnMvdGFncy8iKSkKIAkJbmFtZSArPSAxMDsKLQlwcmludGYoInRhZyAlc1xuZnJvbSA6JWRcbiIsIG5hbWUsIHRhZ2dlZF9tYXJrKTsKKwlwcmludGYoInRhZyAlc1xuIiwgbmFtZSk7CisJaWYgKG1hcmtfdGFncykgeworCQltYXJrX25leHRfb2JqZWN0KCZ0YWctPm9iamVjdCk7CisJCXByaW50ZigibWFyayA6JSJQUkl1MzIiXG4iLCBsYXN0X2lkbnVtKTsKKwl9CisJaWYgKHRhZ2dlZF9tYXJrKQorCQlwcmludGYoImZyb20gOiVkXG4iLCB0YWdnZWRfbWFyayk7CisJZWxzZQorCQlwcmludGYoImZyb20gJXNcbiIsIG9pZF90b19oZXgoJnRhZ2dlZC0+b2lkKSk7CisKIAlpZiAoc2hvd19vcmlnaW5hbF9pZHMpCiAJCXByaW50Zigib3JpZ2luYWwtb2lkICVzXG4iLCBvaWRfdG9faGV4KCZ0YWctPm9iamVjdC5vaWQpKTsKIAlwcmludGYoIiUuKnMlc2RhdGEgJWRcbiUuKnNcbiIsCkBAIC0xMDQ3LDExICsxMDY4LDE2IEBACiAJCWVycm9yKCJVbmFibGUgdG8gd3JpdGUgbWFya3MgZmlsZSAlcy4iLCBmaWxlKTsKIH0KIAotc3RhdGljIHZvaWQgaW1wb3J0X21hcmtzKGNoYXIgKmlucHV0X2ZpbGUpCitzdGF0aWMgdm9pZCBpbXBvcnRfbWFya3MoY2hhciAqaW5wdXRfZmlsZSwgaW50IGNoZWNrX2V4aXN0cykKIHsKIAljaGFyIGxpbmVbNTEyXTsKLQlGSUxFICpmID0geGZvcGVuKGlucHV0X2ZpbGUsICJyIik7CisJRklMRSAqZjsKKwlzdHJ1Y3Qgc3RhdCBzYjsKIAorCWlmIChjaGVja19leGlzdHMgJiYgc3RhdChpbnB1dF9maWxlLCAmc2IpKQorCQlyZXR1cm47CisKKwlmID0geGZvcGVuKGlucHV0X2ZpbGUsICJyIik7CiAJd2hpbGUgKGZnZXRzKGxpbmUsIHNpemVvZihsaW5lKSwgZikpIHsKIAkJdWludDMyX3QgbWFyazsKIAkJY2hhciAqbGluZV9lbmQsICptYXJrX2VuZDsKQEAgLTExMTUsNyArMTE0MSw5IEBACiAJc3RydWN0IHJldl9pbmZvIHJldnM7CiAJc3RydWN0IG9iamVjdF9hcnJheSBjb21taXRzID0gT0JKRUNUX0FSUkFZX0lOSVQ7CiAJc3RydWN0IGNvbW1pdCAqY29tbWl0OwotCWNoYXIgKmV4cG9ydF9maWxlbmFtZSA9IE5VTEwsICppbXBvcnRfZmlsZW5hbWUgPSBOVUxMOworCWNoYXIgKmV4cG9ydF9maWxlbmFtZSA9IE5VTEwsCisJICAgICAqaW1wb3J0X2ZpbGVuYW1lID0gTlVMTCwKKwkgICAgICppbXBvcnRfZmlsZW5hbWVfaWZfZXhpc3RzID0gTlVMTDsKIAl1aW50MzJfdCBsYXN0aW1wb3J0aWQ7CiAJc3RydWN0IHN0cmluZ19saXN0IHJlZnNwZWNzX2xpc3QgPSBTVFJJTkdfTElTVF9JTklUX05PRFVQOwogCXN0cnVjdCBzdHJpbmdfbGlzdCBwYXRoc19vZl9jaGFuZ2VkX29iamVjdHMgPSBTVFJJTkdfTElTVF9JTklUX0RVUDsKQEAgLTExMzUsNiArMTE2MywxMCBAQAogCQkJICAgICBOXygiRHVtcCBtYXJrcyB0byB0aGlzIGZpbGUiKSksCiAJCU9QVF9TVFJJTkcoMCwgImltcG9ydC1tYXJrcyIsICZpbXBvcnRfZmlsZW5hbWUsIE5fKCJmaWxlIiksCiAJCQkgICAgIE5fKCJJbXBvcnQgbWFya3MgZnJvbSB0aGlzIGZpbGUiKSksCisJCU9QVF9TVFJJTkcoMCwgImltcG9ydC1tYXJrcy1pZi1leGlzdHMiLAorCQkJICAgICAmaW1wb3J0X2ZpbGVuYW1lX2lmX2V4aXN0cywKKwkJCSAgICAgTl8oImZpbGUiKSwKKwkJCSAgICAgTl8oIkltcG9ydCBtYXJrcyBmcm9tIHRoaXMgZmlsZSBpZiBpdCBleGlzdHMiKSksCiAJCU9QVF9CT09MKDAsICJmYWtlLW1pc3NpbmctdGFnZ2VyIiwgJmZha2VfbWlzc2luZ190YWdnZXIsCiAJCQkgTl8oIkZha2UgYSB0YWdnZXIgd2hlbiB0YWdzIGxhY2sgb25lIikpLAogCQlPUFRfQk9PTCgwLCAiZnVsbC10cmVlIiwgJmZ1bGxfdHJlZSwKQEAgLTExNDksNiArMTE4MSw4IEBACiAJCQkgJnJlZmVyZW5jZV9leGNsdWRlZF9jb21taXRzLCBOXygiUmVmZXJlbmNlIHBhcmVudHMgd2hpY2ggYXJlIG5vdCBpbiBmYXN0LWV4cG9ydCBzdHJlYW0gYnkgb2JqZWN0IGlkIikpLAogCQlPUFRfQk9PTCgwLCAic2hvdy1vcmlnaW5hbC1pZHMiLCAmc2hvd19vcmlnaW5hbF9pZHMsCiAJCQkgICAgTl8oIlNob3cgb3JpZ2luYWwgb2JqZWN0IGlkcyBvZiBibG9icy9jb21taXRzIikpLAorCQlPUFRfQk9PTCgwLCAibWFyay10YWdzIiwgJm1hcmtfdGFncywKKwkJCSAgICBOXygiTGFiZWwgdGFncyB3aXRoIG1hcmsgaWRzIikpLAogCiAJCU9QVF9FTkQoKQogCX07CkBAIC0xMTgyLDggKzEyMTYsMTIgQEAKIAlpZiAodXNlX2RvbmVfZmVhdHVyZSkKIAkJcHJpbnRmKCJmZWF0dXJlIGRvbmVcbiIpOwogCisJaWYgKGltcG9ydF9maWxlbmFtZSAmJiBpbXBvcnRfZmlsZW5hbWVfaWZfZXhpc3RzKQorCQlkaWUoXygiQ2Fubm90IHBhc3MgYm90aCAtLWltcG9ydC1tYXJrcyBhbmQgLS1pbXBvcnQtbWFya3MtaWYtZXhpc3RzIikpOwogCWlmIChpbXBvcnRfZmlsZW5hbWUpCi0JCWltcG9ydF9tYXJrcyhpbXBvcnRfZmlsZW5hbWUpOworCQlpbXBvcnRfbWFya3MoaW1wb3J0X2ZpbGVuYW1lLCAwKTsKKwllbHNlIGlmIChpbXBvcnRfZmlsZW5hbWVfaWZfZXhpc3RzKQorCQlpbXBvcnRfbWFya3MoaW1wb3J0X2ZpbGVuYW1lX2lmX2V4aXN0cywgMSk7CiAJbGFzdGltcG9ydGlkID0gbGFzdF9pZG51bTsKIAogCWlmIChpbXBvcnRfZmlsZW5hbWUgJiYgcmV2cy5wcnVuZV9kYXRhLm5yKQpkaWZmIC0tZ2l0IGEvYnVpbHRpbi9mZXRjaC5jIGIvYnVpbHRpbi9mZXRjaC5jCmluZGV4IDcxN2RkMTQuLjQ2Y2U3YzIgMTAwNjQ0Ci0tLSBhL2J1aWx0aW4vZmV0Y2guYworKysgYi9idWlsdGluL2ZldGNoLmMKQEAgLTcsNiArNyw3IEBACiAjaW5jbHVkZSAicmVmcy5oIgogI2luY2x1ZGUgInJlZnNwZWMuaCIKICNpbmNsdWRlICJvYmplY3Qtc3RvcmUuaCIKKyNpbmNsdWRlICJvaWRzZXQuaCIKICNpbmNsdWRlICJjb21taXQuaCIKICNpbmNsdWRlICJidWlsdGluLmgiCiAjaW5jbHVkZSAic3RyaW5nLWxpc3QuaCIKQEAgLTIzLDYgKzI0LDkgQEAKICNpbmNsdWRlICJwYWNrZmlsZS5oIgogI2luY2x1ZGUgImxpc3Qtb2JqZWN0cy1maWx0ZXItb3B0aW9ucy5oIgogI2luY2x1ZGUgImNvbW1pdC1yZWFjaC5oIgorI2luY2x1ZGUgImJyYW5jaC5oIgorI2luY2x1ZGUgInByb21pc29yLXJlbW90ZS5oIgorI2luY2x1ZGUgImNvbW1pdC1ncmFwaC5oIgogCiAjZGVmaW5lIEZPUkNFRF9VUERBVEVTX0RFTEFZX1dBUk5JTkdfSU5fTVMgKDEwICogMTAwMCkKIApAQCAtNTAsMTEgKzU0LDEzIEBACiBzdGF0aWMgaW50IHBydW5lX3RhZ3MgPSAtMTsgLyogdW5zcGVjaWZpZWQgKi8KICNkZWZpbmUgUFJVTkVfVEFHU19CWV9ERUZBVUxUIDAgLyogZG8gd2UgcHJ1bmUgdGFncyBieSBkZWZhdWx0PyAqLwogCi1zdGF0aWMgaW50IGFsbCwgYXBwZW5kLCBkcnlfcnVuLCBmb3JjZSwga2VlcCwgbXVsdGlwbGUsIHVwZGF0ZV9oZWFkX29rLCB2ZXJib3NpdHksIGRlZXBlbl9yZWxhdGl2ZTsKK3N0YXRpYyBpbnQgYWxsLCBhcHBlbmQsIGRyeV9ydW4sIGZvcmNlLCBrZWVwLCBtdWx0aXBsZSwgdXBkYXRlX2hlYWRfb2s7CitzdGF0aWMgaW50IHZlcmJvc2l0eSwgZGVlcGVuX3JlbGF0aXZlLCBzZXRfdXBzdHJlYW07CiBzdGF0aWMgaW50IHByb2dyZXNzID0gLTE7CiBzdGF0aWMgaW50IGVuYWJsZV9hdXRvX2djID0gMTsKIHN0YXRpYyBpbnQgdGFncyA9IFRBR1NfREVGQVVMVCwgdW5zaGFsbG93LCB1cGRhdGVfc2hhbGxvdywgZGVlcGVuOwotc3RhdGljIGludCBtYXhfY2hpbGRyZW4gPSAxOworc3RhdGljIGludCBtYXhfam9icyA9IC0xLCBzdWJtb2R1bGVfZmV0Y2hfam9ic19jb25maWcgPSAtMTsKK3N0YXRpYyBpbnQgZmV0Y2hfcGFyYWxsZWxfY29uZmlnID0gMTsKIHN0YXRpYyBlbnVtIHRyYW5zcG9ydF9mYW1pbHkgZmFtaWx5Owogc3RhdGljIGNvbnN0IGNoYXIgKmRlcHRoOwogc3RhdGljIGNvbnN0IGNoYXIgKmRlZXBlbl9zaW5jZTsKQEAgLTcxLDYgKzc3LDcgQEAKIHN0YXRpYyBzdHJ1Y3QgbGlzdF9vYmplY3RzX2ZpbHRlcl9vcHRpb25zIGZpbHRlcl9vcHRpb25zOwogc3RhdGljIHN0cnVjdCBzdHJpbmdfbGlzdCBzZXJ2ZXJfb3B0aW9ucyA9IFNUUklOR19MSVNUX0lOSVRfRFVQOwogc3RhdGljIHN0cnVjdCBzdHJpbmdfbGlzdCBuZWdvdGlhdGlvbl90aXAgPSBTVFJJTkdfTElTVF9JTklUX05PRFVQOworc3RhdGljIGludCBmZXRjaF93cml0ZV9jb21taXRfZ3JhcGggPSAtMTsKIAogc3RhdGljIGludCBnaXRfZmV0Y2hfY29uZmlnKGNvbnN0IGNoYXIgKmssIGNvbnN0IGNoYXIgKnYsIHZvaWQgKmNiKQogewpAQCAtOTYsMTMgKzEwMywyMCBAQAogCX0KIAogCWlmICghc3RyY21wKGssICJzdWJtb2R1bGUuZmV0Y2hqb2JzIikpIHsKLQkJbWF4X2NoaWxkcmVuID0gcGFyc2Vfc3VibW9kdWxlX2ZldGNoam9icyhrLCB2KTsKKwkJc3VibW9kdWxlX2ZldGNoX2pvYnNfY29uZmlnID0gcGFyc2Vfc3VibW9kdWxlX2ZldGNoam9icyhrLCB2KTsKIAkJcmV0dXJuIDA7CiAJfSBlbHNlIGlmICghc3RyY21wKGssICJmZXRjaC5yZWN1cnNlc3VibW9kdWxlcyIpKSB7CiAJCXJlY3Vyc2Vfc3VibW9kdWxlcyA9IHBhcnNlX2ZldGNoX3JlY3Vyc2Vfc3VibW9kdWxlc19hcmcoaywgdik7CiAJCXJldHVybiAwOwogCX0KIAorCWlmICghc3RyY21wKGssICJmZXRjaC5wYXJhbGxlbCIpKSB7CisJCWZldGNoX3BhcmFsbGVsX2NvbmZpZyA9IGdpdF9jb25maWdfaW50KGssIHYpOworCQlpZiAoZmV0Y2hfcGFyYWxsZWxfY29uZmlnIDwgMCkKKwkJCWRpZShfKCJmZXRjaC5wYXJhbGxlbCBjYW5ub3QgYmUgbmVnYXRpdmUiKSk7CisJCXJldHVybiAwOworCX0KKwogCXJldHVybiBnaXRfZGVmYXVsdF9jb25maWcoaywgdiwgY2IpOwogfQogCkBAIC0xMjMsNiArMTM3LDggQEAKIAlPUFRfX1ZFUkJPU0lUWSgmdmVyYm9zaXR5KSwKIAlPUFRfQk9PTCgwLCAiYWxsIiwgJmFsbCwKIAkJIE5fKCJmZXRjaCBmcm9tIGFsbCByZW1vdGVzIikpLAorCU9QVF9CT09MKDAsICJzZXQtdXBzdHJlYW0iLCAmc2V0X3Vwc3RyZWFtLAorCQkgTl8oInNldCB1cHN0cmVhbSBmb3IgZ2l0IHB1bGwvZmV0Y2giKSksCiAJT1BUX0JPT0woJ2EnLCAiYXBwZW5kIiwgJmFwcGVuZCwKIAkJIE5fKCJhcHBlbmQgdG8gLmdpdC9GRVRDSF9IRUFEIGluc3RlYWQgb2Ygb3ZlcndyaXRpbmciKSksCiAJT1BUX1NUUklORygwLCAidXBsb2FkLXBhY2siLCAmdXBsb2FkX3BhY2ssIE5fKCJwYXRoIiksCkBAIC0xMzQsNyArMTUwLDcgQEAKIAkJICAgIE5fKCJmZXRjaCBhbGwgdGFncyBhbmQgYXNzb2NpYXRlZCBvYmplY3RzIiksIFRBR1NfU0VUKSwKIAlPUFRfU0VUX0lOVCgnbicsIE5VTEwsICZ0YWdzLAogCQkgICAgTl8oImRvIG5vdCBmZXRjaCBhbGwgdGFncyAoLS1uby10YWdzKSIpLCBUQUdTX1VOU0VUKSwKLQlPUFRfSU5URUdFUignaicsICJqb2JzIiwgJm1heF9jaGlsZHJlbiwKKwlPUFRfSU5URUdFUignaicsICJqb2JzIiwgJm1heF9qb2JzLAogCQkgICAgTl8oIm51bWJlciBvZiBzdWJtb2R1bGVzIGZldGNoZWQgaW4gcGFyYWxsZWwiKSksCiAJT1BUX0JPT0woJ3AnLCAicHJ1bmUiLCAmcHJ1bmUsCiAJCSBOXygicHJ1bmUgcmVtb3RlLXRyYWNraW5nIGJyYW5jaGVzIG5vIGxvbmdlciBvbiByZW1vdGUiKSksCkBAIC0xODMsNiArMTk5LDggQEAKIAkJIE5fKCJydW4gJ2djIC0tYXV0bycgYWZ0ZXIgZmV0Y2hpbmciKSksCiAJT1BUX0JPT0woMCwgInNob3ctZm9yY2VkLXVwZGF0ZXMiLCAmZmV0Y2hfc2hvd19mb3JjZWRfdXBkYXRlcywKIAkJIE5fKCJjaGVjayBmb3IgZm9yY2VkLXVwZGF0ZXMgb24gYWxsIHVwZGF0ZWQgYnJhbmNoZXMiKSksCisJT1BUX0JPT0woMCwgIndyaXRlLWNvbW1pdC1ncmFwaCIsICZmZXRjaF93cml0ZV9jb21taXRfZ3JhcGgsCisJCSBOXygid3JpdGUgdGhlIGNvbW1pdC1ncmFwaCBhZnRlciBmZXRjaGluZyIpKSwKIAlPUFRfRU5EKCkKIH07CiAKQEAgLTIzOSwzMiArMjU3LDMxIEBACiAJfQogfQogCi1zdGF0aWMgaW50IHdpbGxfZmV0Y2goc3RydWN0IHJlZiAqKmhlYWQsIGNvbnN0IHVuc2lnbmVkIGNoYXIgKnNoYTEpCitzdGF0aWMgdm9pZCBjcmVhdGVfZmV0Y2hfb2lkc2V0KHN0cnVjdCByZWYgKipoZWFkLCBzdHJ1Y3Qgb2lkc2V0ICpvdXQpCiB7CiAJc3RydWN0IHJlZiAqcm0gPSAqaGVhZDsKIAl3aGlsZSAocm0pIHsKLQkJaWYgKGhhc2hlcShybS0+b2xkX29pZC5oYXNoLCBzaGExKSkKLQkJCXJldHVybiAxOworCQlvaWRzZXRfaW5zZXJ0KG91dCwgJnJtLT5vbGRfb2lkKTsKIAkJcm0gPSBybS0+bmV4dDsKIAl9Ci0JcmV0dXJuIDA7CiB9CiAKIHN0cnVjdCByZWZuYW1lX2hhc2hfZW50cnkgewotCXN0cnVjdCBoYXNobWFwX2VudHJ5IGVudDsgLyogbXVzdCBiZSB0aGUgZmlyc3QgbWVtYmVyICovCisJc3RydWN0IGhhc2htYXBfZW50cnkgZW50OwogCXN0cnVjdCBvYmplY3RfaWQgb2lkOwogCWludCBpZ25vcmU7CiAJY2hhciByZWZuYW1lW0ZMRVhfQVJSQVldOwogfTsKIAogc3RhdGljIGludCByZWZuYW1lX2hhc2hfZW50cnlfY21wKGNvbnN0IHZvaWQgKmhhc2htYXBfY21wX2ZuX2RhdGEsCi0JCQkJICBjb25zdCB2b2lkICplMV8sCi0JCQkJICBjb25zdCB2b2lkICplMl8sCisJCQkJICBjb25zdCBzdHJ1Y3QgaGFzaG1hcF9lbnRyeSAqZXB0ciwKKwkJCQkgIGNvbnN0IHN0cnVjdCBoYXNobWFwX2VudHJ5ICplbnRyeV9vcl9rZXksCiAJCQkJICBjb25zdCB2b2lkICprZXlkYXRhKQogewotCWNvbnN0IHN0cnVjdCByZWZuYW1lX2hhc2hfZW50cnkgKmUxID0gZTFfOwotCWNvbnN0IHN0cnVjdCByZWZuYW1lX2hhc2hfZW50cnkgKmUyID0gZTJfOworCWNvbnN0IHN0cnVjdCByZWZuYW1lX2hhc2hfZW50cnkgKmUxLCAqZTI7CiAKKwllMSA9IGNvbnRhaW5lcl9vZihlcHRyLCBjb25zdCBzdHJ1Y3QgcmVmbmFtZV9oYXNoX2VudHJ5LCBlbnQpOworCWUyID0gY29udGFpbmVyX29mKGVudHJ5X29yX2tleSwgY29uc3Qgc3RydWN0IHJlZm5hbWVfaGFzaF9lbnRyeSwgZW50KTsKIAlyZXR1cm4gc3RyY21wKGUxLT5yZWZuYW1lLCBrZXlkYXRhID8ga2V5ZGF0YSA6IGUyLT5yZWZuYW1lKTsKIH0KIApAQCAtMjc2LDkgKzI5Myw5IEBACiAJc2l6ZV90IGxlbiA9IHN0cmxlbihyZWZuYW1lKTsKIAogCUZMRVhfQUxMT0NfTUVNKGVudCwgcmVmbmFtZSwgcmVmbmFtZSwgbGVuKTsKLQloYXNobWFwX2VudHJ5X2luaXQoZW50LCBzdHJoYXNoKHJlZm5hbWUpKTsKKwloYXNobWFwX2VudHJ5X2luaXQoJmVudC0+ZW50LCBzdHJoYXNoKHJlZm5hbWUpKTsKIAlvaWRjcHkoJmVudC0+b2lkLCBvaWQpOwotCWhhc2htYXBfYWRkKG1hcCwgZW50KTsKKwloYXNobWFwX2FkZChtYXAsICZlbnQtPmVudCk7CiAJcmV0dXJuIGVudDsKIH0KIApAQCAtMzEzLDYgKzMzMCw3IEBACiB7CiAJc3RydWN0IGhhc2htYXAgZXhpc3RpbmdfcmVmczsKIAlzdHJ1Y3QgaGFzaG1hcCByZW1vdGVfcmVmczsKKwlzdHJ1Y3Qgb2lkc2V0IGZldGNoX29pZHMgPSBPSURTRVRfSU5JVDsKIAlzdHJ1Y3Qgc3RyaW5nX2xpc3QgcmVtb3RlX3JlZnNfbGlzdCA9IFNUUklOR19MSVNUX0lOSVRfTk9EVVA7CiAJc3RydWN0IHN0cmluZ19saXN0X2l0ZW0gKnJlbW90ZV9yZWZfaXRlbTsKIAljb25zdCBzdHJ1Y3QgcmVmICpyZWY7CkBAIC0zMjAsNiArMzM4LDcgQEAKIAogCXJlZm5hbWVfaGFzaF9pbml0KCZleGlzdGluZ19yZWZzKTsKIAlyZWZuYW1lX2hhc2hfaW5pdCgmcmVtb3RlX3JlZnMpOworCWNyZWF0ZV9mZXRjaF9vaWRzZXQoaGVhZCwgJmZldGNoX29pZHMpOwogCiAJZm9yX2VhY2hfcmVmKGFkZF9vbmVfcmVmbmFtZSwgJmV4aXN0aW5nX3JlZnMpOwogCWZvciAocmVmID0gcmVmczsgcmVmOyByZWYgPSByZWYtPm5leHQpIHsKQEAgLTMzNiw5ICszNTUsOSBAQAogCQkJaWYgKGl0ZW0gJiYKIAkJCSAgICAhaGFzX29iamVjdF9maWxlX3dpdGhfZmxhZ3MoJnJlZi0+b2xkX29pZCwKIAkJCQkJCQlPQkpFQ1RfSU5GT19RVUlDSykgJiYKLQkJCSAgICAhd2lsbF9mZXRjaChoZWFkLCByZWYtPm9sZF9vaWQuaGFzaCkgJiYKKwkJCSAgICAhb2lkc2V0X2NvbnRhaW5zKCZmZXRjaF9vaWRzLCAmcmVmLT5vbGRfb2lkKSAmJgogCQkJICAgICFoYXNfb2JqZWN0X2ZpbGVfd2l0aF9mbGFncygmaXRlbS0+b2lkLCBPQkpFQ1RfSU5GT19RVUlDSykgJiYKLQkJCSAgICAhd2lsbF9mZXRjaChoZWFkLCBpdGVtLT5vaWQuaGFzaCkpCisJCQkgICAgIW9pZHNldF9jb250YWlucygmZmV0Y2hfb2lkcywgJml0ZW0tPm9pZCkpCiAJCQkJY2xlYXJfaXRlbShpdGVtKTsKIAkJCWl0ZW0gPSBOVUxMOwogCQkJY29udGludWU7CkBAIC0zNTIsNyArMzcxLDcgQEAKIAkJICovCiAJCWlmIChpdGVtICYmCiAJCSAgICAhaGFzX29iamVjdF9maWxlX3dpdGhfZmxhZ3MoJml0ZW0tPm9pZCwgT0JKRUNUX0lORk9fUVVJQ0spICYmCi0JCSAgICAhd2lsbF9mZXRjaChoZWFkLCBpdGVtLT5vaWQuaGFzaCkpCisJCSAgICAhb2lkc2V0X2NvbnRhaW5zKCZmZXRjaF9vaWRzLCAmaXRlbS0+b2lkKSkKIAkJCWNsZWFyX2l0ZW0oaXRlbSk7CiAKIAkJaXRlbSA9IE5VTEw7CkBAIC0zNjUsNyArMzg0LDcgQEAKIAkJaXRlbSA9IHJlZm5hbWVfaGFzaF9hZGQoJnJlbW90ZV9yZWZzLCByZWYtPm5hbWUsICZyZWYtPm9sZF9vaWQpOwogCQlzdHJpbmdfbGlzdF9pbnNlcnQoJnJlbW90ZV9yZWZzX2xpc3QsIHJlZi0+bmFtZSk7CiAJfQotCWhhc2htYXBfZnJlZSgmZXhpc3RpbmdfcmVmcywgMSk7CisJaGFzaG1hcF9mcmVlX2VudHJpZXMoJmV4aXN0aW5nX3JlZnMsIHN0cnVjdCByZWZuYW1lX2hhc2hfZW50cnksIGVudCk7CiAKIAkvKgogCSAqIFdlIG1heSBoYXZlIGEgZmluYWwgbGlnaHR3ZWlnaHQgdGFnIHRoYXQgbmVlZHMgdG8gYmUKQEAgLTM3Myw3ICszOTIsNyBAQAogCSAqLwogCWlmIChpdGVtICYmCiAJICAgICFoYXNfb2JqZWN0X2ZpbGVfd2l0aF9mbGFncygmaXRlbS0+b2lkLCBPQkpFQ1RfSU5GT19RVUlDSykgJiYKLQkgICAgIXdpbGxfZmV0Y2goaGVhZCwgaXRlbS0+b2lkLmhhc2gpKQorCSAgICAhb2lkc2V0X2NvbnRhaW5zKCZmZXRjaF9vaWRzLCAmaXRlbS0+b2lkKSkKIAkJY2xlYXJfaXRlbShpdGVtKTsKIAogCS8qCkBAIC0zODMsOCArNDAyLDEwIEBACiAJZm9yX2VhY2hfc3RyaW5nX2xpc3RfaXRlbShyZW1vdGVfcmVmX2l0ZW0sICZyZW1vdGVfcmVmc19saXN0KSB7CiAJCWNvbnN0IGNoYXIgKnJlZm5hbWUgPSByZW1vdGVfcmVmX2l0ZW0tPnN0cmluZzsKIAkJc3RydWN0IHJlZiAqcm07CisJCXVuc2lnbmVkIGludCBoYXNoID0gc3RyaGFzaChyZWZuYW1lKTsKIAotCQlpdGVtID0gaGFzaG1hcF9nZXRfZnJvbV9oYXNoKCZyZW1vdGVfcmVmcywgc3RyaGFzaChyZWZuYW1lKSwgcmVmbmFtZSk7CisJCWl0ZW0gPSBoYXNobWFwX2dldF9lbnRyeV9mcm9tX2hhc2goJnJlbW90ZV9yZWZzLCBoYXNoLCByZWZuYW1lLAorCQkJCQlzdHJ1Y3QgcmVmbmFtZV9oYXNoX2VudHJ5LCBlbnQpOwogCQlpZiAoIWl0ZW0pCiAJCQlCVUcoInVuc2VlbiByZW1vdGUgcmVmPyIpOwogCkBAIC0zOTgsOCArNDE5LDkgQEAKIAkJKip0YWlsID0gcm07CiAJCSp0YWlsID0gJnJtLT5uZXh0OwogCX0KLQloYXNobWFwX2ZyZWUoJnJlbW90ZV9yZWZzLCAxKTsKKwloYXNobWFwX2ZyZWVfZW50cmllcygmcmVtb3RlX3JlZnMsIHN0cnVjdCByZWZuYW1lX2hhc2hfZW50cnksIGVudCk7CiAJc3RyaW5nX2xpc3RfY2xlYXIoJnJlbW90ZV9yZWZzX2xpc3QsIDApOworCW9pZHNldF9jbGVhcigmZmV0Y2hfb2lkcyk7CiB9CiAKIHN0YXRpYyBzdHJ1Y3QgcmVmICpnZXRfcmVmX21hcChzdHJ1Y3QgcmVtb3RlICpyZW1vdGUsCkBAIC01MTYsMTcgKzUzOCwxOCBAQAogCQlpZiAocm0tPnBlZXJfcmVmKSB7CiAJCQljb25zdCBjaGFyICpyZWZuYW1lID0gcm0tPnBlZXJfcmVmLT5uYW1lOwogCQkJc3RydWN0IHJlZm5hbWVfaGFzaF9lbnRyeSAqcGVlcl9pdGVtOworCQkJdW5zaWduZWQgaW50IGhhc2ggPSBzdHJoYXNoKHJlZm5hbWUpOwogCi0JCQlwZWVyX2l0ZW0gPSBoYXNobWFwX2dldF9mcm9tX2hhc2goJmV4aXN0aW5nX3JlZnMsCi0JCQkJCQkJICBzdHJoYXNoKHJlZm5hbWUpLAotCQkJCQkJCSAgcmVmbmFtZSk7CisJCQlwZWVyX2l0ZW0gPSBoYXNobWFwX2dldF9lbnRyeV9mcm9tX2hhc2goJmV4aXN0aW5nX3JlZnMsCisJCQkJCQloYXNoLCByZWZuYW1lLAorCQkJCQkJc3RydWN0IHJlZm5hbWVfaGFzaF9lbnRyeSwgZW50KTsKIAkJCWlmIChwZWVyX2l0ZW0pIHsKIAkJCQlzdHJ1Y3Qgb2JqZWN0X2lkICpvbGRfb2lkID0gJnBlZXJfaXRlbS0+b2lkOwogCQkJCW9pZGNweSgmcm0tPnBlZXJfcmVmLT5vbGRfb2lkLCBvbGRfb2lkKTsKIAkJCX0KIAkJfQogCX0KLQloYXNobWFwX2ZyZWUoJmV4aXN0aW5nX3JlZnMsIDEpOworCWhhc2htYXBfZnJlZV9lbnRyaWVzKCZleGlzdGluZ19yZWZzLCBzdHJ1Y3QgcmVmbmFtZV9oYXNoX2VudHJ5LCBlbnQpOwogCiAJcmV0dXJuIHJlZl9tYXA7CiB9CkBAIC0xMDU0LDcgKzEwNzcsOCBAQAogCSAqIHdlIG5lZWQgYWxsIGRpcmVjdCB0YXJnZXRzIHRvIGV4aXN0LgogCSAqLwogCWZvciAociA9IHJtOyByOyByID0gci0+bmV4dCkgewotCQlpZiAoIWhhc19vYmplY3RfZmlsZSgmci0+b2xkX29pZCkpCisJCWlmICghaGFzX29iamVjdF9maWxlX3dpdGhfZmxhZ3MoJnItPm9sZF9vaWQsCisJCQkJCQlPQkpFQ1RfSU5GT19TS0lQX0ZFVENIX09CSkVDVCkpCiAJCQlyZXR1cm4gLTE7CiAJfQogCkBAIC0xMDY1LDggKzEwODksMTEgQEAKIHN0YXRpYyBpbnQgZmV0Y2hfcmVmcyhzdHJ1Y3QgdHJhbnNwb3J0ICp0cmFuc3BvcnQsIHN0cnVjdCByZWYgKnJlZl9tYXApCiB7CiAJaW50IHJldCA9IGNoZWNrX2V4aXN0X2FuZF9jb25uZWN0ZWQocmVmX21hcCk7Ci0JaWYgKHJldCkKKwlpZiAocmV0KSB7CisJCXRyYWNlMl9yZWdpb25fZW50ZXIoImZldGNoIiwgImZldGNoX3JlZnMiLCB0aGVfcmVwb3NpdG9yeSk7CiAJCXJldCA9IHRyYW5zcG9ydF9mZXRjaF9yZWZzKHRyYW5zcG9ydCwgcmVmX21hcCk7CisJCXRyYWNlMl9yZWdpb25fbGVhdmUoImZldGNoIiwgImZldGNoX3JlZnMiLCB0aGVfcmVwb3NpdG9yeSk7CisJfQogCWlmICghcmV0KQogCQkvKgogCQkgKiBLZWVwIHRoZSBuZXcgcGFjaydzICIua2VlcCIgZmlsZSBhcm91bmQgdG8gYWxsb3cgdGhlIGNhbGxlcgpAQCAtMTA4MiwxMSArMTEwOSwxNCBAQAogewogCWludCBjb25uZWN0aXZpdHlfY2hlY2tlZCA9IHRyYW5zcG9ydC0+c21hcnRfb3B0aW9ucwogCQk/IHRyYW5zcG9ydC0+c21hcnRfb3B0aW9ucy0+Y29ubmVjdGl2aXR5X2NoZWNrZWQgOiAwOwotCWludCByZXQgPSBzdG9yZV91cGRhdGVkX3JlZnModHJhbnNwb3J0LT51cmwsCi0JCQkJICAgICB0cmFuc3BvcnQtPnJlbW90ZS0+bmFtZSwKLQkJCQkgICAgIGNvbm5lY3Rpdml0eV9jaGVja2VkLAotCQkJCSAgICAgcmVmX21hcCk7CisJaW50IHJldDsKKwl0cmFjZTJfcmVnaW9uX2VudGVyKCJmZXRjaCIsICJjb25zdW1lX3JlZnMiLCB0aGVfcmVwb3NpdG9yeSk7CisJcmV0ID0gc3RvcmVfdXBkYXRlZF9yZWZzKHRyYW5zcG9ydC0+dXJsLAorCQkJCSB0cmFuc3BvcnQtPnJlbW90ZS0+bmFtZSwKKwkJCQkgY29ubmVjdGl2aXR5X2NoZWNrZWQsCisJCQkJIHJlZl9tYXApOwogCXRyYW5zcG9ydF91bmxvY2tfcGFjayh0cmFuc3BvcnQpOworCXRyYWNlMl9yZWdpb25fbGVhdmUoImZldGNoIiwgImNvbnN1bWVfcmVmcyIsIHRoZV9yZXBvc2l0b3J5KTsKIAlyZXR1cm4gcmV0OwogfQogCkBAIC0xMjM4LDEzICsxMjY4LDEwIEBACiAJaWYgKHVwZGF0ZV9zaGFsbG93KQogCQlzZXRfb3B0aW9uKHRyYW5zcG9ydCwgVFJBTlNfT1BUX1VQREFURV9TSEFMTE9XLCAieWVzIik7CiAJaWYgKGZpbHRlcl9vcHRpb25zLmNob2ljZSkgewotCQlzdHJ1Y3Qgc3RyYnVmIGV4cGFuZGVkX2ZpbHRlcl9zcGVjID0gU1RSQlVGX0lOSVQ7Ci0JCWV4cGFuZF9saXN0X29iamVjdHNfZmlsdGVyX3NwZWMoJmZpbHRlcl9vcHRpb25zLAotCQkJCQkJJmV4cGFuZGVkX2ZpbHRlcl9zcGVjKTsKLQkJc2V0X29wdGlvbih0cmFuc3BvcnQsIFRSQU5TX09QVF9MSVNUX09CSkVDVFNfRklMVEVSLAotCQkJICAgZXhwYW5kZWRfZmlsdGVyX3NwZWMuYnVmKTsKKwkJY29uc3QgY2hhciAqc3BlYyA9CisJCQlleHBhbmRfbGlzdF9vYmplY3RzX2ZpbHRlcl9zcGVjKCZmaWx0ZXJfb3B0aW9ucyk7CisJCXNldF9vcHRpb24odHJhbnNwb3J0LCBUUkFOU19PUFRfTElTVF9PQkpFQ1RTX0ZJTFRFUiwgc3BlYyk7CiAJCXNldF9vcHRpb24odHJhbnNwb3J0LCBUUkFOU19PUFRfRlJPTV9QUk9NSVNPUiwgIjEiKTsKLQkJc3RyYnVmX3JlbGVhc2UoJmV4cGFuZGVkX2ZpbHRlcl9zcGVjKTsKIAl9CiAJaWYgKG5lZ290aWF0aW9uX3RpcC5ucikgewogCQlpZiAodHJhbnNwb3J0LT5zbWFydF9vcHRpb25zKQpAQCAtMTMzNCw5ICsxMzYxLDExIEBACiAJCQlhcmd2X2FycmF5X3B1c2goJnJlZl9wcmVmaXhlcywgInJlZnMvdGFncy8iKTsKIAl9CiAKLQlpZiAobXVzdF9saXN0X3JlZnMpCisJaWYgKG11c3RfbGlzdF9yZWZzKSB7CisJCXRyYWNlMl9yZWdpb25fZW50ZXIoImZldGNoIiwgInJlbW90ZV9yZWZzIiwgdGhlX3JlcG9zaXRvcnkpOwogCQlyZW1vdGVfcmVmcyA9IHRyYW5zcG9ydF9nZXRfcmVtb3RlX3JlZnModHJhbnNwb3J0LCAmcmVmX3ByZWZpeGVzKTsKLQllbHNlCisJCXRyYWNlMl9yZWdpb25fbGVhdmUoImZldGNoIiwgInJlbW90ZV9yZWZzIiwgdGhlX3JlcG9zaXRvcnkpOworCX0gZWxzZQogCQlyZW1vdGVfcmVmcyA9IE5VTEw7CiAKIAlhcmd2X2FycmF5X2NsZWFyKCZyZWZfcHJlZml4ZXMpOwpAQCAtMTM2Nyw2ICsxMzk2LDUxIEBACiAJCXJldGNvZGUgPSAxOwogCQlnb3RvIGNsZWFudXA7CiAJfQorCisJaWYgKHNldF91cHN0cmVhbSkgeworCQlzdHJ1Y3QgYnJhbmNoICpicmFuY2ggPSBicmFuY2hfZ2V0KCJIRUFEIik7CisJCXN0cnVjdCByZWYgKnJtOworCQlzdHJ1Y3QgcmVmICpzb3VyY2VfcmVmID0gTlVMTDsKKworCQkvKgorCQkgKiBXZSdyZSBzZXR0aW5nIHRoZSB1cHN0cmVhbSBjb25maWd1cmF0aW9uIGZvciB0aGUKKwkJICogY3VycmVudCBicmFuY2guIFRoZSByZWxldmFudCB1cHN0cmVhbSBpcyB0aGUKKwkJICogZmV0Y2hlZCBicmFuY2ggdGhhdCBpcyBtZWFudCB0byBiZSBtZXJnZWQgd2l0aCB0aGUKKwkJICogY3VycmVudCBvbmUsIGkuZS4gdGhlIG9uZSBmZXRjaGVkIHRvIEZFVENIX0hFQUQuCisJCSAqCisJCSAqIFdoZW4gdGhlcmUgYXJlIHNldmVyYWwgc3VjaCBicmFuY2hlcywgY29uc2lkZXIgdGhlCisJCSAqIHJlcXVlc3QgYW1iaWd1b3VzIGFuZCBlcnIgb24gdGhlIHNhZmUgc2lkZSBieSBkb2luZworCQkgKiBub3RoaW5nIGFuZCBqdXN0IGVtaXQgYSB3YXJuaW5nLgorCQkgKi8KKwkJZm9yIChybSA9IHJlZl9tYXA7IHJtOyBybSA9IHJtLT5uZXh0KSB7CisJCQlpZiAoIXJtLT5wZWVyX3JlZikgeworCQkJCWlmIChzb3VyY2VfcmVmKSB7CisJCQkJCXdhcm5pbmcoXygibXVsdGlwbGUgYnJhbmNoZXMgZGV0ZWN0ZWQsIGluY29tcGF0aWJsZSB3aXRoIC0tc2V0LXVwc3RyZWFtIikpOworCQkJCQlnb3RvIHNraXA7CisJCQkJfSBlbHNlIHsKKwkJCQkJc291cmNlX3JlZiA9IHJtOworCQkJCX0KKwkJCX0KKwkJfQorCQlpZiAoc291cmNlX3JlZikgeworCQkJaWYgKCFzdHJjbXAoc291cmNlX3JlZi0+bmFtZSwgIkhFQUQiKSB8fAorCQkJICAgIHN0YXJ0c193aXRoKHNvdXJjZV9yZWYtPm5hbWUsICJyZWZzL2hlYWRzLyIpKQorCQkJCWluc3RhbGxfYnJhbmNoX2NvbmZpZygwLAorCQkJCQkJICAgICAgYnJhbmNoLT5uYW1lLAorCQkJCQkJICAgICAgdHJhbnNwb3J0LT5yZW1vdGUtPm5hbWUsCisJCQkJCQkgICAgICBzb3VyY2VfcmVmLT5uYW1lKTsKKwkJCWVsc2UgaWYgKHN0YXJ0c193aXRoKHNvdXJjZV9yZWYtPm5hbWUsICJyZWZzL3JlbW90ZXMvIikpCisJCQkJd2FybmluZyhfKCJub3Qgc2V0dGluZyB1cHN0cmVhbSBmb3IgYSByZW1vdGUgcmVtb3RlLXRyYWNraW5nIGJyYW5jaCIpKTsKKwkJCWVsc2UgaWYgKHN0YXJ0c193aXRoKHNvdXJjZV9yZWYtPm5hbWUsICJyZWZzL3RhZ3MvIikpCisJCQkJd2FybmluZyhfKCJub3Qgc2V0dGluZyB1cHN0cmVhbSBmb3IgYSByZW1vdGUgdGFnIikpOworCQkJZWxzZQorCQkJCXdhcm5pbmcoXygidW5rbm93biBicmFuY2ggdHlwZSIpKTsKKwkJfSBlbHNlIHsKKwkJCXdhcm5pbmcoXygibm8gc291cmNlIGJyYW5jaCBmb3VuZC5cbiIKKwkJCQkieW91IG5lZWQgdG8gc3BlY2lmeSBleGFjdGx5IG9uZSBicmFuY2ggd2l0aCB0aGUgLS1zZXQtdXBzdHJlYW0gb3B0aW9uLiIpKTsKKwkJfQorCX0KKyBza2lwOgogCWZyZWVfcmVmcyhyZWZfbWFwKTsKIAogCS8qIGlmIG5laXRoZXIgLS1uby10YWdzIG5vciAtLXRhZ3Mgd2FzIHNwZWNpZmllZCwgZG8gYXV0b21hdGVkIHRhZwpAQCAtMTQ2Myw3ICsxNTM3LDYyIEBACiAKIH0KIAotc3RhdGljIGludCBmZXRjaF9tdWx0aXBsZShzdHJ1Y3Qgc3RyaW5nX2xpc3QgKmxpc3QpCisvKiBGZXRjaCBtdWx0aXBsZSByZW1vdGVzIGluIHBhcmFsbGVsICovCisKK3N0cnVjdCBwYXJhbGxlbF9mZXRjaF9zdGF0ZSB7CisJY29uc3QgY2hhciAqKmFyZ3Y7CisJc3RydWN0IHN0cmluZ19saXN0ICpyZW1vdGVzOworCWludCBuZXh0LCByZXN1bHQ7Cit9OworCitzdGF0aWMgaW50IGZldGNoX25leHRfcmVtb3RlKHN0cnVjdCBjaGlsZF9wcm9jZXNzICpjcCwgc3RydWN0IHN0cmJ1ZiAqb3V0LAorCQkJICAgICB2b2lkICpjYiwgdm9pZCAqKnRhc2tfY2IpCit7CisJc3RydWN0IHBhcmFsbGVsX2ZldGNoX3N0YXRlICpzdGF0ZSA9IGNiOworCWNoYXIgKnJlbW90ZTsKKworCWlmIChzdGF0ZS0+bmV4dCA8IDAgfHwgc3RhdGUtPm5leHQgPj0gc3RhdGUtPnJlbW90ZXMtPm5yKQorCQlyZXR1cm4gMDsKKworCXJlbW90ZSA9IHN0YXRlLT5yZW1vdGVzLT5pdGVtc1tzdGF0ZS0+bmV4dCsrXS5zdHJpbmc7CisJKnRhc2tfY2IgPSByZW1vdGU7CisKKwlhcmd2X2FycmF5X3B1c2h2KCZjcC0+YXJncywgc3RhdGUtPmFyZ3YpOworCWFyZ3ZfYXJyYXlfcHVzaCgmY3AtPmFyZ3MsIHJlbW90ZSk7CisJY3AtPmdpdF9jbWQgPSAxOworCisJaWYgKHZlcmJvc2l0eSA+PSAwKQorCQlwcmludGYoXygiRmV0Y2hpbmcgJXNcbiIpLCByZW1vdGUpOworCisJcmV0dXJuIDE7Cit9CisKK3N0YXRpYyBpbnQgZmV0Y2hfZmFpbGVkX3RvX3N0YXJ0KHN0cnVjdCBzdHJidWYgKm91dCwgdm9pZCAqY2IsIHZvaWQgKnRhc2tfY2IpCit7CisJc3RydWN0IHBhcmFsbGVsX2ZldGNoX3N0YXRlICpzdGF0ZSA9IGNiOworCWNvbnN0IGNoYXIgKnJlbW90ZSA9IHRhc2tfY2I7CisKKwlzdGF0ZS0+cmVzdWx0ID0gZXJyb3IoXygiQ291bGQgbm90IGZldGNoICVzIiksIHJlbW90ZSk7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGludCBmZXRjaF9maW5pc2hlZChpbnQgcmVzdWx0LCBzdHJ1Y3Qgc3RyYnVmICpvdXQsCisJCQkgIHZvaWQgKmNiLCB2b2lkICp0YXNrX2NiKQoreworCXN0cnVjdCBwYXJhbGxlbF9mZXRjaF9zdGF0ZSAqc3RhdGUgPSBjYjsKKwljb25zdCBjaGFyICpyZW1vdGUgPSB0YXNrX2NiOworCisJaWYgKHJlc3VsdCkgeworCQlzdHJidWZfYWRkZihvdXQsIF8oImNvdWxkIG5vdCBmZXRjaCAnJXMnIChleGl0IGNvZGU6ICVkKVxuIiksCisJCQkgICAgcmVtb3RlLCByZXN1bHQpOworCQlzdGF0ZS0+cmVzdWx0ID0gLTE7CisJfQorCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgZmV0Y2hfbXVsdGlwbGUoc3RydWN0IHN0cmluZ19saXN0ICpsaXN0LCBpbnQgbWF4X2NoaWxkcmVuKQogewogCWludCBpLCByZXN1bHQgPSAwOwogCXN0cnVjdCBhcmd2X2FycmF5IGFyZ3YgPSBBUkdWX0FSUkFZX0lOSVQ7CkBAIC0xNDc0LDIzICsxNjAzLDM4IEBACiAJCQlyZXR1cm4gZXJyY29kZTsKIAl9CiAKLQlhcmd2X2FycmF5X3B1c2hsKCZhcmd2LCAiZmV0Y2giLCAiLS1hcHBlbmQiLCAiLS1uby1hdXRvLWdjIiwgTlVMTCk7CisJYXJndl9hcnJheV9wdXNobCgmYXJndiwgImZldGNoIiwgIi0tYXBwZW5kIiwgIi0tbm8tYXV0by1nYyIsCisJCQkiLS1uby13cml0ZS1jb21taXQtZ3JhcGgiLCBOVUxMKTsKIAlhZGRfb3B0aW9uc190b19hcmd2KCZhcmd2KTsKIAotCWZvciAoaSA9IDA7IGkgPCBsaXN0LT5ucjsgaSsrKSB7Ci0JCWNvbnN0IGNoYXIgKm5hbWUgPSBsaXN0LT5pdGVtc1tpXS5zdHJpbmc7Ci0JCWFyZ3ZfYXJyYXlfcHVzaCgmYXJndiwgbmFtZSk7Ci0JCWlmICh2ZXJib3NpdHkgPj0gMCkKLQkJCXByaW50ZihfKCJGZXRjaGluZyAlc1xuIiksIG5hbWUpOwotCQlpZiAocnVuX2NvbW1hbmRfdl9vcHQoYXJndi5hcmd2LCBSVU5fR0lUX0NNRCkpIHsKLQkJCWVycm9yKF8oIkNvdWxkIG5vdCBmZXRjaCAlcyIpLCBuYW1lKTsKLQkJCXJlc3VsdCA9IDE7CisJaWYgKG1heF9jaGlsZHJlbiAhPSAxICYmIGxpc3QtPm5yICE9IDEpIHsKKwkJc3RydWN0IHBhcmFsbGVsX2ZldGNoX3N0YXRlIHN0YXRlID0geyBhcmd2LmFyZ3YsIGxpc3QsIDAsIDAgfTsKKworCQlhcmd2X2FycmF5X3B1c2goJmFyZ3YsICItLWVuZC1vZi1vcHRpb25zIik7CisJCXJlc3VsdCA9IHJ1bl9wcm9jZXNzZXNfcGFyYWxsZWxfdHIyKG1heF9jaGlsZHJlbiwKKwkJCQkJCSAgICAmZmV0Y2hfbmV4dF9yZW1vdGUsCisJCQkJCQkgICAgJmZldGNoX2ZhaWxlZF90b19zdGFydCwKKwkJCQkJCSAgICAmZmV0Y2hfZmluaXNoZWQsCisJCQkJCQkgICAgJnN0YXRlLAorCQkJCQkJICAgICJmZXRjaCIsICJwYXJhbGxlbC9mZXRjaCIpOworCisJCWlmICghcmVzdWx0KQorCQkJcmVzdWx0ID0gc3RhdGUucmVzdWx0OworCX0gZWxzZQorCQlmb3IgKGkgPSAwOyBpIDwgbGlzdC0+bnI7IGkrKykgeworCQkJY29uc3QgY2hhciAqbmFtZSA9IGxpc3QtPml0ZW1zW2ldLnN0cmluZzsKKwkJCWFyZ3ZfYXJyYXlfcHVzaCgmYXJndiwgbmFtZSk7CisJCQlpZiAodmVyYm9zaXR5ID49IDApCisJCQkJcHJpbnRmKF8oIkZldGNoaW5nICVzXG4iKSwgbmFtZSk7CisJCQlpZiAocnVuX2NvbW1hbmRfdl9vcHQoYXJndi5hcmd2LCBSVU5fR0lUX0NNRCkpIHsKKwkJCQllcnJvcihfKCJDb3VsZCBub3QgZmV0Y2ggJXMiKSwgbmFtZSk7CisJCQkJcmVzdWx0ID0gMTsKKwkJCX0KKwkJCWFyZ3ZfYXJyYXlfcG9wKCZhcmd2KTsKIAkJfQotCQlhcmd2X2FycmF5X3BvcCgmYXJndik7Ci0JfQogCiAJYXJndl9hcnJheV9jbGVhcigmYXJndik7Ci0JcmV0dXJuIHJlc3VsdDsKKwlyZXR1cm4gISFyZXN1bHQ7CiB9CiAKIC8qCkBAIC0xNTEwLDM3ICsxNjU0LDI3IEBACiAJICogSWYgbm8gcHJpb3IgcGFydGlhbCBjbG9uZS9mZXRjaCBhbmQgdGhlIGN1cnJlbnQgZmV0Y2ggRElEIE5PVAogCSAqIHJlcXVlc3QgYSBwYXJ0aWFsLWZldGNoLCBkbyBhIG5vcm1hbCBmZXRjaC4KIAkgKi8KLQlpZiAoIXJlcG9zaXRvcnlfZm9ybWF0X3BhcnRpYWxfY2xvbmUgJiYgIWZpbHRlcl9vcHRpb25zLmNob2ljZSkKKwlpZiAoIWhhc19wcm9taXNvcl9yZW1vdGUoKSAmJiAhZmlsdGVyX29wdGlvbnMuY2hvaWNlKQogCQlyZXR1cm47CiAKIAkvKgotCSAqIElmIHRoaXMgaXMgdGhlIEZJUlNUIHBhcnRpYWwtZmV0Y2ggcmVxdWVzdCwgd2UgZW5hYmxlIHBhcnRpYWwKLQkgKiBvbiB0aGlzIHJlcG8gYW5kIHJlbWVtYmVyIHRoZSBnaXZlbiBmaWx0ZXItc3BlYyBhcyB0aGUgZGVmYXVsdAotCSAqIGZvciBzdWJzZXF1ZW50IGZldGNoZXMgdG8gdGhpcyByZW1vdGUuCisJICogSWYgdGhpcyBpcyBhIHBhcnRpYWwtZmV0Y2ggcmVxdWVzdCwgd2UgZW5hYmxlIHBhcnRpYWwgb24KKwkgKiB0aGlzIHJlcG8gaWYgbm90IGFscmVhZHkgZW5hYmxlZCBhbmQgcmVtZW1iZXIgdGhlIGdpdmVuCisJICogZmlsdGVyLXNwZWMgYXMgdGhlIGRlZmF1bHQgZm9yIHN1YnNlcXVlbnQgZmV0Y2hlcyB0byB0aGlzCisJICogcmVtb3RlLgogCSAqLwotCWlmICghcmVwb3NpdG9yeV9mb3JtYXRfcGFydGlhbF9jbG9uZSAmJiBmaWx0ZXJfb3B0aW9ucy5jaG9pY2UpIHsKKwlpZiAoZmlsdGVyX29wdGlvbnMuY2hvaWNlKSB7CiAJCXBhcnRpYWxfY2xvbmVfcmVnaXN0ZXIocmVtb3RlLT5uYW1lLCAmZmlsdGVyX29wdGlvbnMpOwogCQlyZXR1cm47CiAJfQogCiAJLyoKLQkgKiBXZSBhcmUgY3VycmVudGx5IGxpbWl0ZWQgdG8gb25seSBPTkUgcHJvbWlzb3IgcmVtb3RlIGFuZCBvbmx5Ci0JICogYWxsb3cgcGFydGlhbC1mZXRjaGVzIGZyb20gdGhlIHByb21pc29yIHJlbW90ZS4KLQkgKi8KLQlpZiAoc3RyY21wKHJlbW90ZS0+bmFtZSwgcmVwb3NpdG9yeV9mb3JtYXRfcGFydGlhbF9jbG9uZSkpIHsKLQkJaWYgKGZpbHRlcl9vcHRpb25zLmNob2ljZSkKLQkJCWRpZShfKCItLWZpbHRlciBjYW4gb25seSBiZSB1c2VkIHdpdGggdGhlIHJlbW90ZSAiCi0JCQkgICAgICAiY29uZmlndXJlZCBpbiBleHRlbnNpb25zLnBhcnRpYWxDbG9uZSIpKTsKLQkJcmV0dXJuOwotCX0KLQotCS8qCiAJICogRG8gYSBwYXJ0aWFsLWZldGNoIGZyb20gdGhlIHByb21pc29yIHJlbW90ZSB1c2luZyBlaXRoZXIgdGhlCiAJICogZXhwbGljaXRseSBnaXZlbiBmaWx0ZXItc3BlYyBvciBpbmhlcml0IHRoZSBmaWx0ZXItc3BlYyBmcm9tCiAJICogdGhlIGNvbmZpZy4KIAkgKi8KIAlpZiAoIWZpbHRlcl9vcHRpb25zLmNob2ljZSkKLQkJcGFydGlhbF9jbG9uZV9nZXRfZGVmYXVsdF9maWx0ZXJfc3BlYygmZmlsdGVyX29wdGlvbnMpOworCQlwYXJ0aWFsX2Nsb25lX2dldF9kZWZhdWx0X2ZpbHRlcl9zcGVjKCZmaWx0ZXJfb3B0aW9ucywgcmVtb3RlLT5uYW1lKTsKIAlyZXR1cm47CiB9CiAKQEAgLTE2MjYsMTQgKzE3NjAsMTMgQEAKIAogCXBhY2tldF90cmFjZV9pZGVudGl0eSgiZmV0Y2giKTsKIAotCWZldGNoX2lmX21pc3NpbmcgPSAwOwotCiAJLyogUmVjb3JkIHRoZSBjb21tYW5kIGxpbmUgZm9yIHRoZSByZWZsb2cgKi8KIAlzdHJidWZfYWRkc3RyKCZkZWZhdWx0X3JsYSwgImZldGNoIik7CiAJZm9yIChpID0gMTsgaSA8IGFyZ2M7IGkrKykKIAkJc3RyYnVmX2FkZGYoJmRlZmF1bHRfcmxhLCAiICVzIiwgYXJndltpXSk7CiAKLQlmZXRjaF9jb25maWdfZnJvbV9naXRtb2R1bGVzKCZtYXhfY2hpbGRyZW4sICZyZWN1cnNlX3N1Ym1vZHVsZXMpOworCWZldGNoX2NvbmZpZ19mcm9tX2dpdG1vZHVsZXMoJnN1Ym1vZHVsZV9mZXRjaF9qb2JzX2NvbmZpZywKKwkJCQkgICAgICZyZWN1cnNlX3N1Ym1vZHVsZXMpOwogCWdpdF9jb25maWcoZ2l0X2ZldGNoX2NvbmZpZywgTlVMTCk7CiAKIAlhcmdjID0gcGFyc2Vfb3B0aW9ucyhhcmdjLCBhcmd2LCBwcmVmaXgsCkBAIC0xNjYxLDcgKzE3OTQsNyBAQAogCWlmIChkZXB0aCB8fCBkZWVwZW5fc2luY2UgfHwgZGVlcGVuX25vdC5ucikKIAkJZGVlcGVuID0gMTsKIAotCWlmIChmaWx0ZXJfb3B0aW9ucy5jaG9pY2UgJiYgIXJlcG9zaXRvcnlfZm9ybWF0X3BhcnRpYWxfY2xvbmUpCisJaWYgKGZpbHRlcl9vcHRpb25zLmNob2ljZSAmJiAhaGFzX3Byb21pc29yX3JlbW90ZSgpKQogCQlkaWUoIi0tZmlsdGVyIGNhbiBvbmx5IGJlIHVzZWQgd2hlbiBleHRlbnNpb25zLnBhcnRpYWxDbG9uZSBpcyBzZXQiKTsKIAogCWlmIChhbGwpIHsKQEAgLTE2OTUsMTkgKzE4MjgsMzEgQEAKIAl9CiAKIAlpZiAocmVtb3RlKSB7Ci0JCWlmIChmaWx0ZXJfb3B0aW9ucy5jaG9pY2UgfHwgcmVwb3NpdG9yeV9mb3JtYXRfcGFydGlhbF9jbG9uZSkKKwkJaWYgKGZpbHRlcl9vcHRpb25zLmNob2ljZSB8fCBoYXNfcHJvbWlzb3JfcmVtb3RlKCkpCiAJCQlmZXRjaF9vbmVfc2V0dXBfcGFydGlhbChyZW1vdGUpOwogCQlyZXN1bHQgPSBmZXRjaF9vbmUocmVtb3RlLCBhcmdjLCBhcmd2LCBwcnVuZV90YWdzX29rKTsKIAl9IGVsc2UgeworCQlpbnQgbWF4X2NoaWxkcmVuID0gbWF4X2pvYnM7CisKIAkJaWYgKGZpbHRlcl9vcHRpb25zLmNob2ljZSkKIAkJCWRpZShfKCItLWZpbHRlciBjYW4gb25seSBiZSB1c2VkIHdpdGggdGhlIHJlbW90ZSAiCiAJCQkgICAgICAiY29uZmlndXJlZCBpbiBleHRlbnNpb25zLnBhcnRpYWxjbG9uZSIpKTsKKworCQlpZiAobWF4X2NoaWxkcmVuIDwgMCkKKwkJCW1heF9jaGlsZHJlbiA9IGZldGNoX3BhcmFsbGVsX2NvbmZpZzsKKwogCQkvKiBUT0RPIHNob3VsZCB0aGlzIGFsc28gZGllIGlmIHdlIGhhdmUgYSBwcmV2aW91cyBwYXJ0aWFsLWNsb25lPyAqLwotCQlyZXN1bHQgPSBmZXRjaF9tdWx0aXBsZSgmbGlzdCk7CisJCXJlc3VsdCA9IGZldGNoX211bHRpcGxlKCZsaXN0LCBtYXhfY2hpbGRyZW4pOwogCX0KIAogCWlmICghcmVzdWx0ICYmIChyZWN1cnNlX3N1Ym1vZHVsZXMgIT0gUkVDVVJTRV9TVUJNT0RVTEVTX09GRikpIHsKIAkJc3RydWN0IGFyZ3ZfYXJyYXkgb3B0aW9ucyA9IEFSR1ZfQVJSQVlfSU5JVDsKKwkJaW50IG1heF9jaGlsZHJlbiA9IG1heF9qb2JzOworCisJCWlmIChtYXhfY2hpbGRyZW4gPCAwKQorCQkJbWF4X2NoaWxkcmVuID0gc3VibW9kdWxlX2ZldGNoX2pvYnNfY29uZmlnOworCQlpZiAobWF4X2NoaWxkcmVuIDwgMCkKKwkJCW1heF9jaGlsZHJlbiA9IGZldGNoX3BhcmFsbGVsX2NvbmZpZzsKIAogCQlhZGRfb3B0aW9uc190b19hcmd2KCZvcHRpb25zKTsKIAkJcmVzdWx0ID0gZmV0Y2hfcG9wdWxhdGVkX3N1Ym1vZHVsZXModGhlX3JlcG9zaXRvcnksCkBAIC0xNzIyLDYgKzE4NjcsMjIgQEAKIAogCXN0cmluZ19saXN0X2NsZWFyKCZsaXN0LCAwKTsKIAorCXByZXBhcmVfcmVwb19zZXR0aW5ncyh0aGVfcmVwb3NpdG9yeSk7CisJaWYgKGZldGNoX3dyaXRlX2NvbW1pdF9ncmFwaCA+IDAgfHwKKwkgICAgKGZldGNoX3dyaXRlX2NvbW1pdF9ncmFwaCA8IDAgJiYKKwkgICAgIHRoZV9yZXBvc2l0b3J5LT5zZXR0aW5ncy5mZXRjaF93cml0ZV9jb21taXRfZ3JhcGgpKSB7CisJCWludCBjb21taXRfZ3JhcGhfZmxhZ3MgPSBDT01NSVRfR1JBUEhfV1JJVEVfU1BMSVQ7CisJCXN0cnVjdCBzcGxpdF9jb21taXRfZ3JhcGhfb3B0cyBzcGxpdF9vcHRzOworCQltZW1zZXQoJnNwbGl0X29wdHMsIDAsIHNpemVvZihzdHJ1Y3Qgc3BsaXRfY29tbWl0X2dyYXBoX29wdHMpKTsKKworCQlpZiAocHJvZ3Jlc3MpCisJCQljb21taXRfZ3JhcGhfZmxhZ3MgfD0gQ09NTUlUX0dSQVBIX1dSSVRFX1BST0dSRVNTOworCisJCXdyaXRlX2NvbW1pdF9ncmFwaF9yZWFjaGFibGUoZ2V0X29iamVjdF9kaXJlY3RvcnkoKSwKKwkJCQkJICAgICBjb21taXRfZ3JhcGhfZmxhZ3MsCisJCQkJCSAgICAgJnNwbGl0X29wdHMpOworCX0KKwogCWNsb3NlX29iamVjdF9zdG9yZSh0aGVfcmVwb3NpdG9yeS0+b2JqZWN0cyk7CiAKIAlpZiAoZW5hYmxlX2F1dG9fZ2MpIHsKZGlmZiAtLWdpdCBhL2J1aWx0aW4vZnNjay5jIGIvYnVpbHRpbi9mc2NrLmMKaW5kZXggMTg0MDNhOS4uOGQxMzc5NCAxMDA2NDQKLS0tIGEvYnVpbHRpbi9mc2NrLmMKKysrIGIvYnVpbHRpbi9mc2NrLmMKQEAgLTUwLDQwICs1MCwyMCBAQAogI2RlZmluZSBFUlJPUl9SRUZTIDAxMAogI2RlZmluZSBFUlJPUl9DT01NSVRfR1JBUEggMDIwCiAKLXN0YXRpYyBjb25zdCBjaGFyICpkZXNjcmliZV9vYmplY3Qoc3RydWN0IG9iamVjdCAqb2JqKQorc3RhdGljIGNvbnN0IGNoYXIgKmRlc2NyaWJlX29iamVjdChjb25zdCBzdHJ1Y3Qgb2JqZWN0X2lkICpvaWQpCiB7Ci0Jc3RhdGljIHN0cnVjdCBzdHJidWYgYnVmc1tdID0gewotCQlTVFJCVUZfSU5JVCwgU1RSQlVGX0lOSVQsIFNUUkJVRl9JTklULCBTVFJCVUZfSU5JVAotCX07Ci0Jc3RhdGljIGludCBiID0gMDsKLQlzdHJ1Y3Qgc3RyYnVmICpidWY7Ci0JY2hhciAqbmFtZSA9IE5VTEw7Ci0KLQlpZiAobmFtZV9vYmplY3RzKQotCQluYW1lID0gbG9va3VwX2RlY29yYXRpb24oZnNja193YWxrX29wdGlvbnMub2JqZWN0X25hbWVzLCBvYmopOwotCi0JYnVmID0gYnVmcyArIGI7Ci0JYiA9IChiICsgMSkgJSBBUlJBWV9TSVpFKGJ1ZnMpOwotCXN0cmJ1Zl9yZXNldChidWYpOwotCXN0cmJ1Zl9hZGRzdHIoYnVmLCBvaWRfdG9faGV4KCZvYmotPm9pZCkpOwotCWlmIChuYW1lKQotCQlzdHJidWZfYWRkZihidWYsICIgKCVzKSIsIG5hbWUpOwotCi0JcmV0dXJuIGJ1Zi0+YnVmOworCXJldHVybiBmc2NrX2Rlc2NyaWJlX29iamVjdCgmZnNja193YWxrX29wdGlvbnMsIG9pZCk7CiB9CiAKLXN0YXRpYyBjb25zdCBjaGFyICpwcmludGFibGVfdHlwZShzdHJ1Y3Qgb2JqZWN0ICpvYmopCitzdGF0aWMgY29uc3QgY2hhciAqcHJpbnRhYmxlX3R5cGUoY29uc3Qgc3RydWN0IG9iamVjdF9pZCAqb2lkLAorCQkJCSAgZW51bSBvYmplY3RfdHlwZSB0eXBlKQogewogCWNvbnN0IGNoYXIgKnJldDsKIAotCWlmIChvYmotPnR5cGUgPT0gT0JKX05PTkUpIHsKLQkJZW51bSBvYmplY3RfdHlwZSB0eXBlID0gb2lkX29iamVjdF9pbmZvKHRoZV9yZXBvc2l0b3J5LAotCQkJCQkJCSZvYmotPm9pZCwgTlVMTCk7Ci0JCWlmICh0eXBlID4gMCkKLQkJCW9iamVjdF9hc190eXBlKHRoZV9yZXBvc2l0b3J5LCBvYmosIHR5cGUsIDApOwotCX0KKwlpZiAodHlwZSA9PSBPQkpfTk9ORSkKKwkJdHlwZSA9IG9pZF9vYmplY3RfaW5mbyh0aGVfcmVwb3NpdG9yeSwgb2lkLCBOVUxMKTsKIAotCXJldCA9IHR5cGVfbmFtZShvYmotPnR5cGUpOworCXJldCA9IHR5cGVfbmFtZSh0eXBlKTsKIAlpZiAoIXJldCkKIAkJcmV0ID0gXygidW5rbm93biIpOwogCkBAIC0xMTgsMjYgKzk4LDMyIEBACiAJZXJyb3JzX2ZvdW5kIHw9IEVSUk9SX09CSkVDVDsKIAkvKiBUUkFOU0xBVE9SUzogZS5nLiBlcnJvciBpbiB0cmVlIDAxYmZkYTogPG1vcmUgZXhwbGFuYXRpb24+ICovCiAJZnByaW50Zl9sbihzdGRlcnIsIF8oImVycm9yIGluICVzICVzOiAlcyIpLAotCQkgICBwcmludGFibGVfdHlwZShvYmopLCBkZXNjcmliZV9vYmplY3Qob2JqKSwgZXJyKTsKKwkJICAgcHJpbnRhYmxlX3R5cGUoJm9iai0+b2lkLCBvYmotPnR5cGUpLAorCQkgICBkZXNjcmliZV9vYmplY3QoJm9iai0+b2lkKSwgZXJyKTsKIAlyZXR1cm4gLTE7CiB9CiAKIHN0YXRpYyBpbnQgZnNja19lcnJvcl9mdW5jKHN0cnVjdCBmc2NrX29wdGlvbnMgKm8sCi0Jc3RydWN0IG9iamVjdCAqb2JqLCBpbnQgdHlwZSwgY29uc3QgY2hhciAqbWVzc2FnZSkKKwkJCSAgIGNvbnN0IHN0cnVjdCBvYmplY3RfaWQgKm9pZCwKKwkJCSAgIGVudW0gb2JqZWN0X3R5cGUgb2JqZWN0X3R5cGUsCisJCQkgICBpbnQgbXNnX3R5cGUsIGNvbnN0IGNoYXIgKm1lc3NhZ2UpCiB7Ci0Jc3dpdGNoICh0eXBlKSB7CisJc3dpdGNoIChtc2dfdHlwZSkgewogCWNhc2UgRlNDS19XQVJOOgogCQkvKiBUUkFOU0xBVE9SUzogZS5nLiB3YXJuaW5nIGluIHRyZWUgMDFiZmRhOiA8bW9yZSBleHBsYW5hdGlvbj4gKi8KIAkJZnByaW50Zl9sbihzdGRlcnIsIF8oIndhcm5pbmcgaW4gJXMgJXM6ICVzIiksCi0JCQkgICBwcmludGFibGVfdHlwZShvYmopLCBkZXNjcmliZV9vYmplY3Qob2JqKSwgbWVzc2FnZSk7CisJCQkgICBwcmludGFibGVfdHlwZShvaWQsIG9iamVjdF90eXBlKSwKKwkJCSAgIGRlc2NyaWJlX29iamVjdChvaWQpLCBtZXNzYWdlKTsKIAkJcmV0dXJuIDA7CiAJY2FzZSBGU0NLX0VSUk9SOgogCQkvKiBUUkFOU0xBVE9SUzogZS5nLiBlcnJvciBpbiB0cmVlIDAxYmZkYTogPG1vcmUgZXhwbGFuYXRpb24+ICovCiAJCWZwcmludGZfbG4oc3RkZXJyLCBfKCJlcnJvciBpbiAlcyAlczogJXMiKSwKLQkJCSAgIHByaW50YWJsZV90eXBlKG9iaiksIGRlc2NyaWJlX29iamVjdChvYmopLCBtZXNzYWdlKTsKKwkJCSAgIHByaW50YWJsZV90eXBlKG9pZCwgb2JqZWN0X3R5cGUpLAorCQkJICAgZGVzY3JpYmVfb2JqZWN0KG9pZCksIG1lc3NhZ2UpOwogCQlyZXR1cm4gMTsKIAlkZWZhdWx0OgotCQlCVUcoIiVkIChGU0NLX0lHTk9SRT8pIHNob3VsZCBuZXZlciB0cmlnZ2VyIHRoaXMgY2FsbGJhY2siLCB0eXBlKTsKKwkJQlVHKCIlZCAoRlNDS19JR05PUkU/KSBzaG91bGQgbmV2ZXIgdHJpZ2dlciB0aGlzIGNhbGxiYWNrIiwKKwkJICAgIG1zZ190eXBlKTsKIAl9CiB9CiAKQEAgLTE1NSw3ICsxNDEsOCBAQAogCWlmICghb2JqKSB7CiAJCS8qIC4uLiB0aGVzZSByZWZlcmVuY2VzIHRvIHBhcmVudC0+ZmxkIGFyZSBzYWZlIGhlcmUgKi8KIAkJcHJpbnRmX2xuKF8oImJyb2tlbiBsaW5rIGZyb20gJTdzICVzIiksCi0JCQkgIHByaW50YWJsZV90eXBlKHBhcmVudCksIGRlc2NyaWJlX29iamVjdChwYXJlbnQpKTsKKwkJCSAgcHJpbnRhYmxlX3R5cGUoJnBhcmVudC0+b2lkLCBwYXJlbnQtPnR5cGUpLAorCQkJICBkZXNjcmliZV9vYmplY3QoJnBhcmVudC0+b2lkKSk7CiAJCXByaW50Zl9sbihfKCJicm9rZW4gbGluayBmcm9tICU3cyAlcyIpLAogCQkJICAodHlwZSA9PSBPQkpfQU5ZID8gXygidW5rbm93biIpIDogdHlwZV9uYW1lKHR5cGUpKSwKIAkJCSAgXygidW5rbm93biIpKTsKQEAgLTE4MywxMCArMTcwLDEwIEBACiAJCWlmIChwYXJlbnQgJiYgIWhhc19vYmplY3RfZmlsZSgmb2JqLT5vaWQpKSB7CiAJCQlwcmludGZfbG4oXygiYnJva2VuIGxpbmsgZnJvbSAlN3MgJXNcbiIKIAkJCQkgICAgIiAgICAgICAgICAgICAgdG8gJTdzICVzIiksCi0JCQkJICBwcmludGFibGVfdHlwZShwYXJlbnQpLAotCQkJCSAgZGVzY3JpYmVfb2JqZWN0KHBhcmVudCksCi0JCQkJICBwcmludGFibGVfdHlwZShvYmopLAotCQkJCSAgZGVzY3JpYmVfb2JqZWN0KG9iaikpOworCQkJCSAgcHJpbnRhYmxlX3R5cGUoJnBhcmVudC0+b2lkLCBwYXJlbnQtPnR5cGUpLAorCQkJCSAgZGVzY3JpYmVfb2JqZWN0KCZwYXJlbnQtPm9pZCksCisJCQkJICBwcmludGFibGVfdHlwZSgmb2JqLT5vaWQsIG9iai0+dHlwZSksCisJCQkJICBkZXNjcmliZV9vYmplY3QoJm9iai0+b2lkKSk7CiAJCQllcnJvcnNfZm91bmQgfD0gRVJST1JfUkVBQ0hBQkxFOwogCQl9CiAJCXJldHVybiAxOwpAQCAtMjkyLDggKzI3OSw5IEBACiAJCQlyZXR1cm47CiAJCWlmIChoYXNfb2JqZWN0X3BhY2soJm9iai0+b2lkKSkKIAkJCXJldHVybjsgLyogaXQgaXMgaW4gcGFjayAtIGZvcmdldCBhYm91dCBpdCAqLwotCQlwcmludGZfbG4oXygibWlzc2luZyAlcyAlcyIpLCBwcmludGFibGVfdHlwZShvYmopLAotCQkJICBkZXNjcmliZV9vYmplY3Qob2JqKSk7CisJCXByaW50Zl9sbihfKCJtaXNzaW5nICVzICVzIiksCisJCQkgIHByaW50YWJsZV90eXBlKCZvYmotPm9pZCwgb2JqLT50eXBlKSwKKwkJCSAgZGVzY3JpYmVfb2JqZWN0KCZvYmotPm9pZCkpOwogCQllcnJvcnNfZm91bmQgfD0gRVJST1JfUkVBQ0hBQkxFOwogCQlyZXR1cm47CiAJfQpAQCAtMzE4LDggKzMwNiw5IEBACiAJICogc2luY2UgdGhpcyBpcyBzb21ldGhpbmcgdGhhdCBpcyBwcnVuYWJsZS4KIAkgKi8KIAlpZiAoc2hvd191bnJlYWNoYWJsZSkgewotCQlwcmludGZfbG4oXygidW5yZWFjaGFibGUgJXMgJXMiKSwgcHJpbnRhYmxlX3R5cGUob2JqKSwKLQkJCSAgZGVzY3JpYmVfb2JqZWN0KG9iaikpOworCQlwcmludGZfbG4oXygidW5yZWFjaGFibGUgJXMgJXMiKSwKKwkJCSAgcHJpbnRhYmxlX3R5cGUoJm9iai0+b2lkLCBvYmotPnR5cGUpLAorCQkJICBkZXNjcmliZV9vYmplY3QoJm9iai0+b2lkKSk7CiAJCXJldHVybjsKIAl9CiAKQEAgLTMzNywxMiArMzI2LDEzIEBACiAJICovCiAJaWYgKCEob2JqLT5mbGFncyAmIFVTRUQpKSB7CiAJCWlmIChzaG93X2RhbmdsaW5nKQotCQkJcHJpbnRmX2xuKF8oImRhbmdsaW5nICVzICVzIiksIHByaW50YWJsZV90eXBlKG9iaiksCi0JCQkJICBkZXNjcmliZV9vYmplY3Qob2JqKSk7CisJCQlwcmludGZfbG4oXygiZGFuZ2xpbmcgJXMgJXMiKSwKKwkJCQkgIHByaW50YWJsZV90eXBlKCZvYmotPm9pZCwgb2JqLT50eXBlKSwKKwkJCQkgIGRlc2NyaWJlX29iamVjdCgmb2JqLT5vaWQpKTsKIAkJaWYgKHdyaXRlX2xvc3RfYW5kX2ZvdW5kKSB7CiAJCQljaGFyICpmaWxlbmFtZSA9IGdpdF9wYXRoZHVwKCJsb3N0LWZvdW5kLyVzLyVzIiwKIAkJCQlvYmotPnR5cGUgPT0gT0JKX0NPTU1JVCA/ICJjb21taXQiIDogIm90aGVyIiwKLQkJCQlkZXNjcmliZV9vYmplY3Qob2JqKSk7CisJCQkJZGVzY3JpYmVfb2JqZWN0KCZvYmotPm9pZCkpOwogCQkJRklMRSAqZjsKIAogCQkJaWYgKHNhZmVfY3JlYXRlX2xlYWRpbmdfZGlyZWN0b3JpZXNfY29uc3QoZmlsZW5hbWUpKSB7CkBAIC0zNTUsNyArMzQ1LDcgQEAKIAkJCQlpZiAoc3RyZWFtX2Jsb2JfdG9fZmQoZmlsZW5vKGYpLCAmb2JqLT5vaWQsIE5VTEwsIDEpKQogCQkJCQlkaWVfZXJybm8oXygiY291bGQgbm90IHdyaXRlICclcyciKSwgZmlsZW5hbWUpOwogCQkJfSBlbHNlCi0JCQkJZnByaW50ZihmLCAiJXNcbiIsIGRlc2NyaWJlX29iamVjdChvYmopKTsKKwkJCQlmcHJpbnRmKGYsICIlc1xuIiwgZGVzY3JpYmVfb2JqZWN0KCZvYmotPm9pZCkpOwogCQkJaWYgKGZjbG9zZShmKSkKIAkJCQlkaWVfZXJybm8oXygiY291bGQgbm90IGZpbmlzaCAnJXMnIiksCiAJCQkJCSAgZmlsZW5hbWUpOwpAQCAtMzc0LDcgKzM2NCw3IEBACiBzdGF0aWMgdm9pZCBjaGVja19vYmplY3Qoc3RydWN0IG9iamVjdCAqb2JqKQogewogCWlmICh2ZXJib3NlKQotCQlmcHJpbnRmX2xuKHN0ZGVyciwgXygiQ2hlY2tpbmcgJXMiKSwgZGVzY3JpYmVfb2JqZWN0KG9iaikpOworCQlmcHJpbnRmX2xuKHN0ZGVyciwgXygiQ2hlY2tpbmcgJXMiKSwgZGVzY3JpYmVfb2JqZWN0KCZvYmotPm9pZCkpOwogCiAJaWYgKG9iai0+ZmxhZ3MgJiBSRUFDSEFCTEUpCiAJCWNoZWNrX3JlYWNoYWJsZV9vYmplY3Qob2JqKTsKQEAgLTQzMiw3ICs0MjIsOCBAQAogCiAJaWYgKHZlcmJvc2UpCiAJCWZwcmludGZfbG4oc3RkZXJyLCBfKCJDaGVja2luZyAlcyAlcyIpLAotCQkJICAgcHJpbnRhYmxlX3R5cGUob2JqKSwgZGVzY3JpYmVfb2JqZWN0KG9iaikpOworCQkJICAgcHJpbnRhYmxlX3R5cGUoJm9iai0+b2lkLCBvYmotPnR5cGUpLAorCQkJICAgZGVzY3JpYmVfb2JqZWN0KCZvYmotPm9pZCkpOwogCiAJaWYgKGZzY2tfd2FsayhvYmosIE5VTEwsICZmc2NrX29ial9vcHRpb25zKSkKIAkJb2JqZXJyb3Iob2JqLCBfKCJicm9rZW4gbGlua3MiKSk7CkBAIC00NDUsNyArNDM2LDcgQEAKIAogCQlpZiAoIWNvbW1pdC0+cGFyZW50cyAmJiBzaG93X3Jvb3QpCiAJCQlwcmludGZfbG4oXygicm9vdCAlcyIpLAotCQkJCSAgZGVzY3JpYmVfb2JqZWN0KCZjb21taXQtPm9iamVjdCkpOworCQkJCSAgZGVzY3JpYmVfb2JqZWN0KCZjb21taXQtPm9iamVjdC5vaWQpKTsKIAl9CiAKIAlpZiAob2JqLT50eXBlID09IE9CSl9UQUcpIHsKQEAgLTQ1MywxMCArNDQ0LDEwIEBACiAKIAkJaWYgKHNob3dfdGFncyAmJiB0YWctPnRhZ2dlZCkgewogCQkJcHJpbnRmX2xuKF8oInRhZ2dlZCAlcyAlcyAoJXMpIGluICVzIiksCi0JCQkJICBwcmludGFibGVfdHlwZSh0YWctPnRhZ2dlZCksCi0JCQkJICBkZXNjcmliZV9vYmplY3QodGFnLT50YWdnZWQpLAorCQkJCSAgcHJpbnRhYmxlX3R5cGUoJnRhZy0+dGFnZ2VkLT5vaWQsIHRhZy0+dGFnZ2VkLT50eXBlKSwKKwkJCQkgIGRlc2NyaWJlX29iamVjdCgmdGFnLT50YWdnZWQtPm9pZCksCiAJCQkJICB0YWctPnRhZywKLQkJCQkgIGRlc2NyaWJlX29iamVjdCgmdGFnLT5vYmplY3QpKTsKKwkJCQkgIGRlc2NyaWJlX29iamVjdCgmdGFnLT5vYmplY3Qub2lkKSk7CiAJCX0KIAl9CiAKQEAgLTQ5OSwxMCArNDkwLDEwIEBACiAJaWYgKCFpc19udWxsX29pZChvaWQpKSB7CiAJCW9iaiA9IGxvb2t1cF9vYmplY3QodGhlX3JlcG9zaXRvcnksIG9pZCk7CiAJCWlmIChvYmogJiYgKG9iai0+ZmxhZ3MgJiBIQVNfT0JKKSkgewotCQkJaWYgKHRpbWVzdGFtcCAmJiBuYW1lX29iamVjdHMpCi0JCQkJYWRkX2RlY29yYXRpb24oZnNja193YWxrX29wdGlvbnMub2JqZWN0X25hbWVzLAotCQkJCQlvYmosCi0JCQkJCXhzdHJmbXQoIiVzQHslIlBSSXRpbWUifSIsIHJlZm5hbWUsIHRpbWVzdGFtcCkpOworCQkJaWYgKHRpbWVzdGFtcCkKKwkJCQlmc2NrX3B1dF9vYmplY3RfbmFtZSgmZnNja193YWxrX29wdGlvbnMsIG9pZCwKKwkJCQkJCSAgICAgIiVzQHslIlBSSXRpbWUifSIsCisJCQkJCQkgICAgIHJlZm5hbWUsIHRpbWVzdGFtcCk7CiAJCQlvYmotPmZsYWdzIHw9IFVTRUQ7CiAJCQltYXJrX29iamVjdF9yZWFjaGFibGUob2JqKTsKIAkJfSBlbHNlIGlmICghaXNfcHJvbWlzb3Jfb2JqZWN0KG9pZCkpIHsKQEAgLTU2Niw5ICs1NTcsOCBAQAogCX0KIAlkZWZhdWx0X3JlZnMrKzsKIAlvYmotPmZsYWdzIHw9IFVTRUQ7Ci0JaWYgKG5hbWVfb2JqZWN0cykKLQkJYWRkX2RlY29yYXRpb24oZnNja193YWxrX29wdGlvbnMub2JqZWN0X25hbWVzLAotCQkJb2JqLCB4c3RyZHVwKHJlZm5hbWUpKTsKKwlmc2NrX3B1dF9vYmplY3RfbmFtZSgmZnNja193YWxrX29wdGlvbnMsCisJCQkgICAgIG9pZCwgIiVzIiwgcmVmbmFtZSk7CiAJbWFya19vYmplY3RfcmVhY2hhYmxlKG9iaik7CiAKIAlyZXR1cm4gMDsKQEAgLTc0Miw5ICs3MzIsNyBAQAogCQkJcmV0dXJuIDE7CiAJCX0KIAkJb2JqLT5mbGFncyB8PSBVU0VEOwotCQlpZiAobmFtZV9vYmplY3RzKQotCQkJYWRkX2RlY29yYXRpb24oZnNja193YWxrX29wdGlvbnMub2JqZWN0X25hbWVzLAotCQkJCW9iaiwgeHN0cmR1cCgiOiIpKTsKKwkJZnNja19wdXRfb2JqZWN0X25hbWUoJmZzY2tfd2Fsa19vcHRpb25zLCAmaXQtPm9pZCwgIjoiKTsKIAkJbWFya19vYmplY3RfcmVhY2hhYmxlKG9iaik7CiAJCWlmIChvYmotPnR5cGUgIT0gT0JKX1RSRUUpCiAJCQllcnIgfD0gb2JqZXJyb3Iob2JqLCBfKCJub24tdHJlZSBpbiBjYWNoZS10cmVlIikpOwpAQCAtODMwLDggKzgxOCw3IEBACiAJfQogCiAJaWYgKG5hbWVfb2JqZWN0cykKLQkJZnNja193YWxrX29wdGlvbnMub2JqZWN0X25hbWVzID0KLQkJCXhjYWxsb2MoMSwgc2l6ZW9mKHN0cnVjdCBkZWNvcmF0aW9uKSk7CisJCWZzY2tfZW5hYmxlX29iamVjdF9uYW1lcygmZnNja193YWxrX29wdGlvbnMpOwogCiAJZ2l0X2NvbmZpZyhmc2NrX2NvbmZpZywgTlVMTCk7CiAKQEAgLTg5MCw5ICs4NzcsOCBAQAogCQkJfQogCiAJCQlvYmotPmZsYWdzIHw9IFVTRUQ7Ci0JCQlpZiAobmFtZV9vYmplY3RzKQotCQkJCWFkZF9kZWNvcmF0aW9uKGZzY2tfd2Fsa19vcHRpb25zLm9iamVjdF9uYW1lcywKLQkJCQkJb2JqLCB4c3RyZHVwKGFyZykpOworCQkJZnNja19wdXRfb2JqZWN0X25hbWUoJmZzY2tfd2Fsa19vcHRpb25zLCAmb2lkLAorCQkJCQkgICAgICIlcyIsIGFyZyk7CiAJCQltYXJrX29iamVjdF9yZWFjaGFibGUob2JqKTsKIAkJCWNvbnRpbnVlOwogCQl9CkBAIC05MjgsMTAgKzkxNCw4IEBACiAJCQkJY29udGludWU7CiAJCQlvYmogPSAmYmxvYi0+b2JqZWN0OwogCQkJb2JqLT5mbGFncyB8PSBVU0VEOwotCQkJaWYgKG5hbWVfb2JqZWN0cykKLQkJCQlhZGRfZGVjb3JhdGlvbihmc2NrX3dhbGtfb3B0aW9ucy5vYmplY3RfbmFtZXMsCi0JCQkJCW9iaiwKLQkJCQkJeHN0cmZtdCgiOiVzIiwgYWN0aXZlX2NhY2hlW2ldLT5uYW1lKSk7CisJCQlmc2NrX3B1dF9vYmplY3RfbmFtZSgmZnNja193YWxrX29wdGlvbnMsICZvYmotPm9pZCwKKwkJCQkJICAgICAiOiVzIiwgYWN0aXZlX2NhY2hlW2ldLT5uYW1lKTsKIAkJCW1hcmtfb2JqZWN0X3JlYWNoYWJsZShvYmopOwogCQl9CiAJCWlmIChhY3RpdmVfY2FjaGVfdHJlZSkKZGlmZiAtLWdpdCBhL2J1aWx0aW4vZ2MuYyBiL2J1aWx0aW4vZ2MuYwppbmRleCBjMThlZmFkLi4zZjc2YmY0IDEwMDY0NAotLS0gYS9idWlsdGluL2djLmMKKysrIGIvYnVpbHRpbi9nYy5jCkBAIC0yNyw2ICsyNyw3IEBACiAjaW5jbHVkZSAicGFjay1vYmplY3RzLmgiCiAjaW5jbHVkZSAiYmxvYi5oIgogI2luY2x1ZGUgInRyZWUuaCIKKyNpbmNsdWRlICJwcm9taXNvci1yZW1vdGUuaCIKIAogI2RlZmluZSBGQUlMRURfUlVOICJmYWlsZWQgdG8gcnVuICVzIgogCkBAIC00MSw3ICs0Miw2IEBACiBzdGF0aWMgaW50IGFnZ3Jlc3NpdmVfd2luZG93ID0gMjUwOwogc3RhdGljIGludCBnY19hdXRvX3RocmVzaG9sZCA9IDY3MDA7CiBzdGF0aWMgaW50IGdjX2F1dG9fcGFja19saW1pdCA9IDUwOwotc3RhdGljIGludCBnY193cml0ZV9jb21taXRfZ3JhcGg7CiBzdGF0aWMgaW50IGRldGFjaF9hdXRvID0gMTsKIHN0YXRpYyB0aW1lc3RhbXBfdCBnY19sb2dfZXhwaXJlX3RpbWU7CiBzdGF0aWMgY29uc3QgY2hhciAqZ2NfbG9nX2V4cGlyZSA9ICIxLmRheS5hZ28iOwpAQCAtMTQ4LDcgKzE0OCw2IEBACiAJZ2l0X2NvbmZpZ19nZXRfaW50KCJnYy5hZ2dyZXNzaXZlZGVwdGgiLCAmYWdncmVzc2l2ZV9kZXB0aCk7CiAJZ2l0X2NvbmZpZ19nZXRfaW50KCJnYy5hdXRvIiwgJmdjX2F1dG9fdGhyZXNob2xkKTsKIAlnaXRfY29uZmlnX2dldF9pbnQoImdjLmF1dG9wYWNrbGltaXQiLCAmZ2NfYXV0b19wYWNrX2xpbWl0KTsKLQlnaXRfY29uZmlnX2dldF9ib29sKCJnYy53cml0ZWNvbW1pdGdyYXBoIiwgJmdjX3dyaXRlX2NvbW1pdF9ncmFwaCk7CiAJZ2l0X2NvbmZpZ19nZXRfYm9vbCgiZ2MuYXV0b2RldGFjaCIsICZkZXRhY2hfYXV0byk7CiAJZ2l0X2NvbmZpZ19nZXRfZXhwaXJ5KCJnYy5wcnVuZWV4cGlyZSIsICZwcnVuZV9leHBpcmUpOwogCWdpdF9jb25maWdfZ2V0X2V4cGlyeSgiZ2Mud29ya3RyZWVwcnVuZWV4cGlyZSIsICZwcnVuZV93b3JrdHJlZXNfZXhwaXJlKTsKQEAgLTQ1OSw3ICs0NTgsNyBAQAogLyoKICAqIFJldHVybnMgMCBpZiB0aGVyZSB3YXMgbm8gcHJldmlvdXMgZXJyb3IgYW5kIGdjIGNhbiBwcm9jZWVkLCAxIGlmCiAgKiBnYyBzaG91bGQgbm90IHByb2NlZWQgZHVlIHRvIGFuIGVycm9yIGluIHRoZSBsYXN0IHJ1bi4gUHJpbnRzIGEKLSAqIG1lc3NhZ2UgYW5kIHJldHVybnMgLTEgaWYgYW4gZXJyb3Igb2NjdXJlZCB3aGlsZSByZWFkaW5nIGdjLmxvZworICogbWVzc2FnZSBhbmQgcmV0dXJucyAtMSBpZiBhbiBlcnJvciBvY2N1cnJlZCB3aGlsZSByZWFkaW5nIGdjLmxvZwogICovCiBzdGF0aWMgaW50IHJlcG9ydF9sYXN0X2djX2Vycm9yKHZvaWQpCiB7CkBAIC02MDIsNyArNjAxLDcgQEAKIAkJaWYgKGRldGFjaF9hdXRvKSB7CiAJCQlpbnQgcmV0ID0gcmVwb3J0X2xhc3RfZ2NfZXJyb3IoKTsKIAkJCWlmIChyZXQgPCAwKQotCQkJCS8qIGFuIEkvTyBlcnJvciBvY2N1cmVkLCBhbHJlYWR5IHJlcG9ydGVkICovCisJCQkJLyogYW4gSS9PIGVycm9yIG9jY3VycmVkLCBhbHJlYWR5IHJlcG9ydGVkICovCiAJCQkJZXhpdCgxMjgpOwogCQkJaWYgKHJldCA9PSAxKQogCQkJCS8qIExhc3QgZ2MgLS1hdXRvIGZhaWxlZC4gU2tpcCB0aGlzIG9uZS4gKi8KQEAgLTY2MSw3ICs2NjAsNyBAQAogCQkJYXJndl9hcnJheV9wdXNoKCZwcnVuZSwgcHJ1bmVfZXhwaXJlKTsKIAkJCWlmIChxdWlldCkKIAkJCQlhcmd2X2FycmF5X3B1c2goJnBydW5lLCAiLS1uby1wcm9ncmVzcyIpOwotCQkJaWYgKHJlcG9zaXRvcnlfZm9ybWF0X3BhcnRpYWxfY2xvbmUpCisJCQlpZiAoaGFzX3Byb21pc29yX3JlbW90ZSgpKQogCQkJCWFyZ3ZfYXJyYXlfcHVzaCgmcHJ1bmUsCiAJCQkJCQkiLS1leGNsdWRlLXByb21pc29yLW9iamVjdHMiKTsKIAkJCWlmIChydW5fY29tbWFuZF92X29wdChwcnVuZS5hcmd2LCBSVU5fR0lUX0NNRCkpCkBAIC02ODUsMTEgKzY4NCwxMSBAQAogCQljbGVhbl9wYWNrX2dhcmJhZ2UoKTsKIAl9CiAKLQlpZiAoZ2Nfd3JpdGVfY29tbWl0X2dyYXBoICYmCi0JICAgIHdyaXRlX2NvbW1pdF9ncmFwaF9yZWFjaGFibGUoZ2V0X29iamVjdF9kaXJlY3RvcnkoKSwKLQkJCQkJICFxdWlldCAmJiAhZGFlbW9uaXplZCA/IENPTU1JVF9HUkFQSF9QUk9HUkVTUyA6IDAsCi0JCQkJCSBOVUxMKSkKLQkJcmV0dXJuIDE7CisJcHJlcGFyZV9yZXBvX3NldHRpbmdzKHRoZV9yZXBvc2l0b3J5KTsKKwlpZiAodGhlX3JlcG9zaXRvcnktPnNldHRpbmdzLmdjX3dyaXRlX2NvbW1pdF9ncmFwaCA9PSAxKQorCQl3cml0ZV9jb21taXRfZ3JhcGhfcmVhY2hhYmxlKGdldF9vYmplY3RfZGlyZWN0b3J5KCksCisJCQkJCSAgICAgIXF1aWV0ICYmICFkYWVtb25pemVkID8gQ09NTUlUX0dSQVBIX1dSSVRFX1BST0dSRVNTIDogMCwKKwkJCQkJICAgICBOVUxMKTsKIAogCWlmIChhdXRvX2djICYmIHRvb19tYW55X2xvb3NlX29iamVjdHMoKSkKIAkJd2FybmluZyhfKCJUaGVyZSBhcmUgdG9vIG1hbnkgdW5yZWFjaGFibGUgbG9vc2Ugb2JqZWN0czsgIgpkaWZmIC0tZ2l0IGEvYnVpbHRpbi9ncmVwLmMgYi9idWlsdGluL2dyZXAuYwppbmRleCA1NjAwNTE3Li41MGNlOGQ5IDEwMDY0NAotLS0gYS9idWlsdGluL2dyZXAuYworKysgYi9idWlsdGluL2dyZXAuYwpAQCAtNDAzLDcgKzQwMyw3IEBACiBzdGF0aWMgaW50IGdyZXBfc3VibW9kdWxlKHN0cnVjdCBncmVwX29wdCAqb3B0LAogCQkJICBjb25zdCBzdHJ1Y3QgcGF0aHNwZWMgKnBhdGhzcGVjLAogCQkJICBjb25zdCBzdHJ1Y3Qgb2JqZWN0X2lkICpvaWQsCi0JCQkgIGNvbnN0IGNoYXIgKmZpbGVuYW1lLCBjb25zdCBjaGFyICpwYXRoKQorCQkJICBjb25zdCBjaGFyICpmaWxlbmFtZSwgY29uc3QgY2hhciAqcGF0aCwgaW50IGNhY2hlZCkKIHsKIAlzdHJ1Y3QgcmVwb3NpdG9yeSBzdWJyZXBvOwogCXN0cnVjdCByZXBvc2l0b3J5ICpzdXBlcnByb2plY3QgPSBvcHQtPnJlcG87CkBAIC00NzUsNyArNDc1LDcgQEAKIAkJc3RyYnVmX3JlbGVhc2UoJmJhc2UpOwogCQlmcmVlKGRhdGEpOwogCX0gZWxzZSB7Ci0JCWhpdCA9IGdyZXBfY2FjaGUoJnN1Ym9wdCwgcGF0aHNwZWMsIDEpOworCQloaXQgPSBncmVwX2NhY2hlKCZzdWJvcHQsIHBhdGhzcGVjLCBjYWNoZWQpOwogCX0KIAogCXJlcG9fY2xlYXIoJnN1YnJlcG8pOwpAQCAtNTIzLDcgKzUyMyw4IEBACiAJCQl9CiAJCX0gZWxzZSBpZiAocmVjdXJzZV9zdWJtb2R1bGVzICYmIFNfSVNHSVRMSU5LKGNlLT5jZV9tb2RlKSAmJgogCQkJICAgc3VibW9kdWxlX3BhdGhfbWF0Y2gocmVwby0+aW5kZXgsIHBhdGhzcGVjLCBuYW1lLmJ1ZiwgTlVMTCkpIHsKLQkJCWhpdCB8PSBncmVwX3N1Ym1vZHVsZShvcHQsIHBhdGhzcGVjLCBOVUxMLCBjZS0+bmFtZSwgY2UtPm5hbWUpOworCQkJaGl0IHw9IGdyZXBfc3VibW9kdWxlKG9wdCwgcGF0aHNwZWMsIE5VTEwsIGNlLT5uYW1lLAorCQkJCQkgICAgICBjZS0+bmFtZSwgY2FjaGVkKTsKIAkJfSBlbHNlIHsKIAkJCWNvbnRpbnVlOwogCQl9CkBAIC01OTgsNyArNTk5LDggQEAKIAkJCWZyZWUoZGF0YSk7CiAJCX0gZWxzZSBpZiAocmVjdXJzZV9zdWJtb2R1bGVzICYmIFNfSVNHSVRMSU5LKGVudHJ5Lm1vZGUpKSB7CiAJCQloaXQgfD0gZ3JlcF9zdWJtb2R1bGUob3B0LCBwYXRoc3BlYywgJmVudHJ5Lm9pZCwKLQkJCQkJICAgICAgYmFzZS0+YnVmLCBiYXNlLT5idWYgKyB0bl9sZW4pOworCQkJCQkgICAgICBiYXNlLT5idWYsIGJhc2UtPmJ1ZiArIHRuX2xlbiwKKwkJCQkJICAgICAgMSk7IC8qIGlnbm9yZWQgKi8KIAkJfQogCiAJCXN0cmJ1Zl9zZXRsZW4oYmFzZSwgb2xkX2Jhc2VsZW4pOwpAQCAtMTEwOCw4ICsxMTEwLDggQEAKIAkJCXN0cmJ1Zl9hZGRmKCZidWYsICIrLyVzJXMiLAogCQkJCQlzdHJjbXAoImxlc3MiLCBwYWdlcikgPyAiIiA6ICIqIiwKIAkJCQkJb3B0LnBhdHRlcm5fbGlzdC0+cGF0dGVybik7Ci0JCQlzdHJpbmdfbGlzdF9hcHBlbmQoJnBhdGhfbGlzdCwgYnVmLmJ1Zik7Ci0JCQlzdHJidWZfZGV0YWNoKCZidWYsIE5VTEwpOworCQkJc3RyaW5nX2xpc3RfYXBwZW5kKCZwYXRoX2xpc3QsCisJCQkJCSAgIHN0cmJ1Zl9kZXRhY2goJmJ1ZiwgTlVMTCkpOwogCQl9CiAJfQogCkBAIC0xMTQ1LDUgKzExNDcsNiBAQAogCQlydW5fcGFnZXIoJm9wdCwgcHJlZml4KTsKIAljbGVhcl9wYXRoc3BlYygmcGF0aHNwZWMpOwogCWZyZWVfZ3JlcF9wYXR0ZXJucygmb3B0KTsKKwlncmVwX2Rlc3Ryb3koKTsKIAlyZXR1cm4gIWhpdDsKIH0KZGlmZiAtLWdpdCBhL2J1aWx0aW4vaW5kZXgtcGFjay5jIGIvYnVpbHRpbi9pbmRleC1wYWNrLmMKaW5kZXggMGQ1NWY3My4uNjBhNTU5MSAxMDA2NDQKLS0tIGEvYnVpbHRpbi9pbmRleC1wYWNrLmMKKysrIGIvYnVpbHRpbi9pbmRleC1wYWNrLmMKQEAgLTE0LDcgKzE0LDcgQEAKICNpbmNsdWRlICJ0aHJlYWQtdXRpbHMuaCIKICNpbmNsdWRlICJwYWNrZmlsZS5oIgogI2luY2x1ZGUgIm9iamVjdC1zdG9yZS5oIgotI2luY2x1ZGUgImZldGNoLW9iamVjdC5oIgorI2luY2x1ZGUgInByb21pc29yLXJlbW90ZS5oIgogCiBzdGF0aWMgY29uc3QgY2hhciBpbmRleF9wYWNrX3VzYWdlW10gPQogImdpdCBpbmRleC1wYWNrIFstdl0gWy1vIDxpbmRleC1maWxlPl0gWy0ta2VlcCB8IC0ta2VlcD08bXNnPl0gWy0tdmVyaWZ5XSBbLS1zdHJpY3RdICg8cGFjay1maWxlPiB8IC0tc3RkaW4gWy0tZml4LXRoaW5dIFs8cGFjay1maWxlPl0pIjsKQEAgLTEzNTIsNyArMTM1Miw3IEBACiAJCXNvcnRlZF9ieV9wb3NbaV0gPSAmcmVmX2RlbHRhc1tpXTsKIAlRU09SVChzb3J0ZWRfYnlfcG9zLCBucl9yZWZfZGVsdGFzLCBkZWx0YV9wb3NfY29tcGFyZSk7CiAKLQlpZiAocmVwb3NpdG9yeV9mb3JtYXRfcGFydGlhbF9jbG9uZSkgeworCWlmIChoYXNfcHJvbWlzb3JfcmVtb3RlKCkpIHsKIAkJLyoKIAkJICogUHJlZmV0Y2ggdGhlIGRlbHRhIGJhc2VzLgogCQkgKi8KQEAgLTEzNjYsOCArMTM2Niw4IEBACiAJCQlvaWRfYXJyYXlfYXBwZW5kKCZ0b19mZXRjaCwgJmQtPm9pZCk7CiAJCX0KIAkJaWYgKHRvX2ZldGNoLm5yKQotCQkJZmV0Y2hfb2JqZWN0cyhyZXBvc2l0b3J5X2Zvcm1hdF9wYXJ0aWFsX2Nsb25lLAotCQkJCSAgICAgIHRvX2ZldGNoLm9pZCwgdG9fZmV0Y2gubnIpOworCQkJcHJvbWlzb3JfcmVtb3RlX2dldF9kaXJlY3QodGhlX3JlcG9zaXRvcnksCisJCQkJCQkgICB0b19mZXRjaC5vaWQsIHRvX2ZldGNoLm5yKTsKIAkJb2lkX2FycmF5X2NsZWFyKCZ0b19mZXRjaCk7CiAJfQogCkBAIC0xNDkwLDExICsxNDkwLDExIEBACiAJfQogCiAJaWYgKCFmcm9tX3N0ZGluKSB7Ci0JCXByaW50ZigiJXNcbiIsIHNoYTFfdG9faGV4KGhhc2gpKTsKKwkJcHJpbnRmKCIlc1xuIiwgaGFzaF90b19oZXgoaGFzaCkpOwogCX0gZWxzZSB7CiAJCXN0cnVjdCBzdHJidWYgYnVmID0gU1RSQlVGX0lOSVQ7CiAKLQkJc3RyYnVmX2FkZGYoJmJ1ZiwgIiVzXHQlc1xuIiwgcmVwb3J0LCBzaGExX3RvX2hleChoYXNoKSk7CisJCXN0cmJ1Zl9hZGRmKCZidWYsICIlc1x0JXNcbiIsIHJlcG9ydCwgaGFzaF90b19oZXgoaGFzaCkpOwogCQl3cml0ZV9vcl9kaWUoMSwgYnVmLmJ1ZiwgYnVmLmxlbik7CiAJCXN0cmJ1Zl9yZWxlYXNlKCZidWYpOwogCmRpZmYgLS1naXQgYS9idWlsdGluL2xvZy5jIGIvYnVpbHRpbi9sb2cuYwppbmRleCA0NGIxMGIzLi5lMTkyZjIxIDEwMDY0NAotLS0gYS9idWlsdGluL2xvZy5jCisrKyBiL2J1aWx0aW4vbG9nLmMKQEAgLTM3LDYgKzM3LDcgQEAKICNpbmNsdWRlICJyYW5nZS1kaWZmLmgiCiAKICNkZWZpbmUgTUFJTF9ERUZBVUxUX1dSQVAgNzIKKyNkZWZpbmUgQ09WRVJfRlJPTV9BVVRPX01BWF9TVUJKRUNUX0xFTiAxMDAKIAogLyogU2V0IGEgZGVmYXVsdCBkYXRlLXRpbWUgZm9ybWF0IGZvciBnaXQgbG9nICgibG9nLmRhdGUiIGNvbmZpZyB2YXJpYWJsZSkgKi8KIHN0YXRpYyBjb25zdCBjaGFyICpkZWZhdWx0X2RhdGVfbW9kZSA9IE5VTEw7CkBAIC02MjcsNiArNjI4LDcgQEAKIAkJCWJyZWFrOwogCQljYXNlIE9CSl9UQUc6IHsKIAkJCXN0cnVjdCB0YWcgKnQgPSAoc3RydWN0IHRhZyAqKW87CisJCQlzdHJ1Y3Qgb2JqZWN0X2lkICpvaWQgPSBnZXRfdGFnZ2VkX29pZCh0KTsKIAogCQkJaWYgKHJldi5zaG93bl9vbmUpCiAJCQkJcHV0Y2hhcignXG4nKTsKQEAgLTYzOCwxMCArNjQwLDEwIEBACiAJCQlyZXYuc2hvd25fb25lID0gMTsKIAkJCWlmIChyZXQpCiAJCQkJYnJlYWs7Ci0JCQlvID0gcGFyc2Vfb2JqZWN0KHRoZV9yZXBvc2l0b3J5LCAmdC0+dGFnZ2VkLT5vaWQpOworCQkJbyA9IHBhcnNlX29iamVjdCh0aGVfcmVwb3NpdG9yeSwgb2lkKTsKIAkJCWlmICghbykKIAkJCQlyZXQgPSBlcnJvcihfKCJjb3VsZCBub3QgcmVhZCBvYmplY3QgJXMiKSwKLQkJCQkJICAgIG9pZF90b19oZXgoJnQtPnRhZ2dlZC0+b2lkKSk7CisJCQkJCSAgICBvaWRfdG9faGV4KG9pZCkpOwogCQkJb2JqZWN0c1tpXS5pdGVtID0gbzsKIAkJCWktLTsKIAkJCWJyZWFrOwpAQCAtNzY0LDI0ICs3NjYsNTIgQEAKIAlpdGVtLT5zdHJpbmdbbGVuXSA9ICdcMCc7CiB9CiAKLSNkZWZpbmUgVEhSRUFEX1NIQUxMT1cgMQotI2RlZmluZSBUSFJFQURfREVFUCAyCi1zdGF0aWMgaW50IHRocmVhZDsKLXN0YXRpYyBpbnQgZG9fc2lnbm9mZjsKLXN0YXRpYyBpbnQgYmFzZV9hdXRvOwotc3RhdGljIGNoYXIgKmZyb207Ci1zdGF0aWMgY29uc3QgY2hhciAqc2lnbmF0dXJlID0gZ2l0X3ZlcnNpb25fc3RyaW5nOwotc3RhdGljIGNvbnN0IGNoYXIgKnNpZ25hdHVyZV9maWxlOwotc3RhdGljIGludCBjb25maWdfY292ZXJfbGV0dGVyOwotc3RhdGljIGNvbnN0IGNoYXIgKmNvbmZpZ19vdXRwdXRfZGlyZWN0b3J5OwotCi1lbnVtIHsKK2VudW0gY292ZXJfc2V0dGluZyB7CiAJQ09WRVJfVU5TRVQsCiAJQ09WRVJfT0ZGLAogCUNPVkVSX09OLAogCUNPVkVSX0FVVE8KIH07CiAKK2VudW0gdGhyZWFkX2xldmVsIHsKKwlUSFJFQURfVU5TRVQsCisJVEhSRUFEX1NIQUxMT1csCisJVEhSRUFEX0RFRVAKK307CisKK2VudW0gY292ZXJfZnJvbV9kZXNjcmlwdGlvbiB7CisJQ09WRVJfRlJPTV9OT05FLAorCUNPVkVSX0ZST01fTUVTU0FHRSwKKwlDT1ZFUl9GUk9NX1NVQkpFQ1QsCisJQ09WRVJfRlJPTV9BVVRPCit9OworCitzdGF0aWMgZW51bSB0aHJlYWRfbGV2ZWwgdGhyZWFkOworc3RhdGljIGludCBkb19zaWdub2ZmOworc3RhdGljIGludCBiYXNlX2F1dG87CitzdGF0aWMgY2hhciAqZnJvbTsKK3N0YXRpYyBjb25zdCBjaGFyICpzaWduYXR1cmUgPSBnaXRfdmVyc2lvbl9zdHJpbmc7CitzdGF0aWMgY29uc3QgY2hhciAqc2lnbmF0dXJlX2ZpbGU7CitzdGF0aWMgZW51bSBjb3Zlcl9zZXR0aW5nIGNvbmZpZ19jb3Zlcl9sZXR0ZXI7CitzdGF0aWMgY29uc3QgY2hhciAqY29uZmlnX291dHB1dF9kaXJlY3Rvcnk7CitzdGF0aWMgZW51bSBjb3Zlcl9mcm9tX2Rlc2NyaXB0aW9uIGNvdmVyX2Zyb21fZGVzY3JpcHRpb25fbW9kZSA9IENPVkVSX0ZST01fTUVTU0FHRTsKKworc3RhdGljIGVudW0gY292ZXJfZnJvbV9kZXNjcmlwdGlvbiBwYXJzZV9jb3Zlcl9mcm9tX2Rlc2NyaXB0aW9uKGNvbnN0IGNoYXIgKmFyZykKK3sKKwlpZiAoIWFyZyB8fCAhc3RyY21wKGFyZywgImRlZmF1bHQiKSkKKwkJcmV0dXJuIENPVkVSX0ZST01fTUVTU0FHRTsKKwllbHNlIGlmICghc3RyY21wKGFyZywgIm5vbmUiKSkKKwkJcmV0dXJuIENPVkVSX0ZST01fTk9ORTsKKwllbHNlIGlmICghc3RyY21wKGFyZywgIm1lc3NhZ2UiKSkKKwkJcmV0dXJuIENPVkVSX0ZST01fTUVTU0FHRTsKKwllbHNlIGlmICghc3RyY21wKGFyZywgInN1YmplY3QiKSkKKwkJcmV0dXJuIENPVkVSX0ZST01fU1VCSkVDVDsKKwllbHNlIGlmICghc3RyY21wKGFyZywgImF1dG8iKSkKKwkJcmV0dXJuIENPVkVSX0ZST01fQVVUTzsKKwllbHNlCisJCWRpZShfKCIlczogaW52YWxpZCBjb3ZlciBmcm9tIGRlc2NyaXB0aW9uIG1vZGUiKSwgYXJnKTsKK30KKwogc3RhdGljIGludCBnaXRfZm9ybWF0X2NvbmZpZyhjb25zdCBjaGFyICp2YXIsIGNvbnN0IGNoYXIgKnZhbHVlLCB2b2lkICpjYikKIHsKIAlzdHJ1Y3QgcmV2X2luZm8gKnJldiA9IGNiOwpAQCAtODM1LDcgKzg2NSw3IEBACiAJCQl0aHJlYWQgPSBUSFJFQURfU0hBTExPVzsKIAkJCXJldHVybiAwOwogCQl9Ci0JCXRocmVhZCA9IGdpdF9jb25maWdfYm9vbCh2YXIsIHZhbHVlKSAmJiBUSFJFQURfU0hBTExPVzsKKwkJdGhyZWFkID0gZ2l0X2NvbmZpZ19ib29sKHZhciwgdmFsdWUpID8gVEhSRUFEX1NIQUxMT1cgOiBUSFJFQURfVU5TRVQ7CiAJCXJldHVybiAwOwogCX0KIAlpZiAoIXN0cmNtcCh2YXIsICJmb3JtYXQuc2lnbm9mZiIpKSB7CkBAIC04ODcsNiArOTE3LDEwIEBACiAJCX0KIAkJcmV0dXJuIDA7CiAJfQorCWlmICghc3RyY21wKHZhciwgImZvcm1hdC5jb3ZlcmZyb21kZXNjcmlwdGlvbiIpKSB7CisJCWNvdmVyX2Zyb21fZGVzY3JpcHRpb25fbW9kZSA9IHBhcnNlX2NvdmVyX2Zyb21fZGVzY3JpcHRpb24odmFsdWUpOworCQlyZXR1cm4gMDsKKwl9CiAKIAlyZXR1cm4gZ2l0X2xvZ19jb25maWcodmFyLCB2YWx1ZSwgY2IpOwogfQpAQCAtOTkzLDIwICsxMDI3LDYgQEAKIAlwdXRjKCdcbicsIGZpbGUpOwogfQogCi1zdGF0aWMgdm9pZCBhZGRfYnJhbmNoX2Rlc2NyaXB0aW9uKHN0cnVjdCBzdHJidWYgKmJ1ZiwgY29uc3QgY2hhciAqYnJhbmNoX25hbWUpCi17Ci0Jc3RydWN0IHN0cmJ1ZiBkZXNjID0gU1RSQlVGX0lOSVQ7Ci0JaWYgKCFicmFuY2hfbmFtZSB8fCAhKmJyYW5jaF9uYW1lKQotCQlyZXR1cm47Ci0JcmVhZF9icmFuY2hfZGVzYygmZGVzYywgYnJhbmNoX25hbWUpOwotCWlmIChkZXNjLmxlbikgewotCQlzdHJidWZfYWRkY2goYnVmLCAnXG4nKTsKLQkJc3RyYnVmX2FkZGJ1ZihidWYsICZkZXNjKTsKLQkJc3RyYnVmX2FkZGNoKGJ1ZiwgJ1xuJyk7Ci0JfQotCXN0cmJ1Zl9yZWxlYXNlKCZkZXNjKTsKLX0KLQogc3RhdGljIGNoYXIgKmZpbmRfYnJhbmNoX25hbWUoc3RydWN0IHJldl9pbmZvICpyZXYpCiB7CiAJaW50IGksIHBvc2l0aXZlID0gLTE7CkBAIC0xMDUzLDYgKzEwNzMsNjMgQEAKIAlmcHJpbnRmKHJldi0+ZGlmZm9wdC5maWxlLCAiXG4iKTsKIH0KIAorc3RhdGljIHZvaWQgcHJlcGFyZV9jb3Zlcl90ZXh0KHN0cnVjdCBwcmV0dHlfcHJpbnRfY29udGV4dCAqcHAsCisJCQkgICAgICAgY29uc3QgY2hhciAqYnJhbmNoX25hbWUsCisJCQkgICAgICAgc3RydWN0IHN0cmJ1ZiAqc2IsCisJCQkgICAgICAgY29uc3QgY2hhciAqZW5jb2RpbmcsCisJCQkgICAgICAgaW50IG5lZWRfOGJpdF9jdGUpCit7CisJY29uc3QgY2hhciAqc3ViamVjdCA9ICIqKiogU1VCSkVDVCBIRVJFICoqKiI7CisJY29uc3QgY2hhciAqYm9keSA9ICIqKiogQkxVUkIgSEVSRSAqKioiOworCXN0cnVjdCBzdHJidWYgZGVzY3JpcHRpb25fc2IgPSBTVFJCVUZfSU5JVDsKKwlzdHJ1Y3Qgc3RyYnVmIHN1YmplY3Rfc2IgPSBTVFJCVUZfSU5JVDsKKworCWlmIChjb3Zlcl9mcm9tX2Rlc2NyaXB0aW9uX21vZGUgPT0gQ09WRVJfRlJPTV9OT05FKQorCQlnb3RvIGRvX3BwOworCisJaWYgKGJyYW5jaF9uYW1lICYmICpicmFuY2hfbmFtZSkKKwkJcmVhZF9icmFuY2hfZGVzYygmZGVzY3JpcHRpb25fc2IsIGJyYW5jaF9uYW1lKTsKKwlpZiAoIWRlc2NyaXB0aW9uX3NiLmxlbikKKwkJZ290byBkb19wcDsKKworCWlmIChjb3Zlcl9mcm9tX2Rlc2NyaXB0aW9uX21vZGUgPT0gQ09WRVJfRlJPTV9TVUJKRUNUIHx8CisJCQljb3Zlcl9mcm9tX2Rlc2NyaXB0aW9uX21vZGUgPT0gQ09WRVJfRlJPTV9BVVRPKQorCQlib2R5ID0gZm9ybWF0X3N1YmplY3QoJnN1YmplY3Rfc2IsIGRlc2NyaXB0aW9uX3NiLmJ1ZiwgIiAiKTsKKworCWlmIChjb3Zlcl9mcm9tX2Rlc2NyaXB0aW9uX21vZGUgPT0gQ09WRVJfRlJPTV9NRVNTQUdFIHx8CisJCQkoY292ZXJfZnJvbV9kZXNjcmlwdGlvbl9tb2RlID09IENPVkVSX0ZST01fQVVUTyAmJgorCQkJIHN1YmplY3Rfc2IubGVuID4gQ09WRVJfRlJPTV9BVVRPX01BWF9TVUJKRUNUX0xFTikpCisJCWJvZHkgPSBkZXNjcmlwdGlvbl9zYi5idWY7CisJZWxzZQorCQlzdWJqZWN0ID0gc3ViamVjdF9zYi5idWY7CisKK2RvX3BwOgorCXBwX3RpdGxlX2xpbmUocHAsICZzdWJqZWN0LCBzYiwgZW5jb2RpbmcsIG5lZWRfOGJpdF9jdGUpOworCXBwX3JlbWFpbmRlcihwcCwgJmJvZHksIHNiLCAwKTsKKworCXN0cmJ1Zl9yZWxlYXNlKCZkZXNjcmlwdGlvbl9zYik7CisJc3RyYnVmX3JlbGVhc2UoJnN1YmplY3Rfc2IpOworfQorCitzdGF0aWMgaW50IGdldF9ub3Rlc19yZWZzKHN0cnVjdCBzdHJpbmdfbGlzdF9pdGVtICppdGVtLCB2b2lkICphcmcpCit7CisJYXJndl9hcnJheV9wdXNoZihhcmcsICItLW5vdGVzPSVzIiwgaXRlbS0+c3RyaW5nKTsKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIHZvaWQgZ2V0X25vdGVzX2FyZ3Moc3RydWN0IGFyZ3ZfYXJyYXkgKmFyZywgc3RydWN0IHJldl9pbmZvICpyZXYpCit7CisJaWYgKCFyZXYtPnNob3dfbm90ZXMpIHsKKwkJYXJndl9hcnJheV9wdXNoKGFyZywgIi0tbm8tbm90ZXMiKTsKKwl9IGVsc2UgaWYgKHJldi0+bm90ZXNfb3B0LnVzZV9kZWZhdWx0X25vdGVzID4gMCB8fAorCQkgICAocmV2LT5ub3Rlc19vcHQudXNlX2RlZmF1bHRfbm90ZXMgPT0gLTEgJiYKKwkJICAgICFyZXYtPm5vdGVzX29wdC5leHRyYV9ub3Rlc19yZWZzLm5yKSkgeworCQlhcmd2X2FycmF5X3B1c2goYXJnLCAiLS1ub3RlcyIpOworCX0gZWxzZSB7CisJCWZvcl9lYWNoX3N0cmluZ19saXN0KCZyZXYtPm5vdGVzX29wdC5leHRyYV9ub3Rlc19yZWZzLCBnZXRfbm90ZXNfcmVmcywgYXJnKTsKKwl9Cit9CisKIHN0YXRpYyB2b2lkIG1ha2VfY292ZXJfbGV0dGVyKHN0cnVjdCByZXZfaW5mbyAqcmV2LCBpbnQgdXNlX3N0ZG91dCwKIAkJCSAgICAgIHN0cnVjdCBjb21taXQgKm9yaWdpbiwKIAkJCSAgICAgIGludCBuciwgc3RydWN0IGNvbW1pdCAqKmxpc3QsCkBAIC0xMDYwLDggKzExMzcsNiBAQAogCQkJICAgICAgaW50IHF1aWV0KQogewogCWNvbnN0IGNoYXIgKmNvbW1pdHRlcjsKLQljb25zdCBjaGFyICpib2R5ID0gIioqKiBTVUJKRUNUIEhFUkUgKioqXG5cbioqKiBCTFVSQiBIRVJFICoqKlxuIjsKLQljb25zdCBjaGFyICptc2c7CiAJc3RydWN0IHNob3J0bG9nIGxvZzsKIAlzdHJ1Y3Qgc3RyYnVmIHNiID0gU1RSQlVGX0lOSVQ7CiAJaW50IGk7CkBAIC0xMDkxLDE1ICsxMTY2LDEyIEBACiAJaWYgKCFicmFuY2hfbmFtZSkKIAkJYnJhbmNoX25hbWUgPSBmaW5kX2JyYW5jaF9uYW1lKHJldik7CiAKLQltc2cgPSBib2R5OwogCXBwLmZtdCA9IENNSVRfRk1UX0VNQUlMOwogCXBwLmRhdGVfbW9kZS50eXBlID0gREFURV9SRkMyODIyOwogCXBwLnJldiA9IHJldjsKIAlwcC5wcmludF9lbWFpbF9zdWJqZWN0ID0gMTsKIAlwcF91c2VyX2luZm8oJnBwLCBOVUxMLCAmc2IsIGNvbW1pdHRlciwgZW5jb2RpbmcpOwotCXBwX3RpdGxlX2xpbmUoJnBwLCAmbXNnLCAmc2IsIGVuY29kaW5nLCBuZWVkXzhiaXRfY3RlKTsKLQlwcF9yZW1haW5kZXIoJnBwLCAmbXNnLCAmc2IsIDApOwotCWFkZF9icmFuY2hfZGVzY3JpcHRpb24oJnNiLCBicmFuY2hfbmFtZSk7CisJcHJlcGFyZV9jb3Zlcl90ZXh0KCZwcCwgYnJhbmNoX25hbWUsICZzYiwgZW5jb2RpbmcsIG5lZWRfOGJpdF9jdGUpOwogCWZwcmludGYocmV2LT5kaWZmb3B0LmZpbGUsICIlc1xuIiwgc2IuYnVmKTsKIAogCXN0cmJ1Zl9yZWxlYXNlKCZzYik7CkBAIC0xMTMwLDEzICsxMjAyLDE2IEBACiAJCSAqIGNhbiBiZSBhZGRlZCBsYXRlciBpZiBkZWVtZWQgZGVzaXJhYmxlLgogCQkgKi8KIAkJc3RydWN0IGRpZmZfb3B0aW9ucyBvcHRzOworCQlzdHJ1Y3QgYXJndl9hcnJheSBvdGhlcl9hcmcgPSBBUkdWX0FSUkFZX0lOSVQ7CiAJCWRpZmZfc2V0dXAoJm9wdHMpOwogCQlvcHRzLmZpbGUgPSByZXYtPmRpZmZvcHQuZmlsZTsKIAkJb3B0cy51c2VfY29sb3IgPSByZXYtPmRpZmZvcHQudXNlX2NvbG9yOwogCQlkaWZmX3NldHVwX2RvbmUoJm9wdHMpOwogCQlmcHJpbnRmX2xuKHJldi0+ZGlmZm9wdC5maWxlLCAiJXMiLCByZXYtPnJkaWZmX3RpdGxlKTsKKwkJZ2V0X25vdGVzX2FyZ3MoJm90aGVyX2FyZywgcmV2KTsKIAkJc2hvd19yYW5nZV9kaWZmKHJldi0+cmRpZmYxLCByZXYtPnJkaWZmMiwKLQkJCQlyZXYtPmNyZWF0aW9uX2ZhY3RvciwgMSwgJm9wdHMpOworCQkJCXJldi0+Y3JlYXRpb25fZmFjdG9yLCAxLCAmb3B0cywgJm90aGVyX2FyZyk7CisJCWFyZ3ZfYXJyYXlfY2xlYXIoJm90aGVyX2FyZyk7CiAJfQogfQogCkBAIC0xMjQ4LDkgKzEzMjMsOSBAQAogCiBzdGF0aWMgaW50IHRocmVhZF9jYWxsYmFjayhjb25zdCBzdHJ1Y3Qgb3B0aW9uICpvcHQsIGNvbnN0IGNoYXIgKmFyZywgaW50IHVuc2V0KQogewotCWludCAqdGhyZWFkID0gKGludCAqKW9wdC0+dmFsdWU7CisJZW51bSB0aHJlYWRfbGV2ZWwgKnRocmVhZCA9IChlbnVtIHRocmVhZF9sZXZlbCAqKW9wdC0+dmFsdWU7CiAJaWYgKHVuc2V0KQotCQkqdGhyZWFkID0gMDsKKwkJKnRocmVhZCA9IFRIUkVBRF9VTlNFVDsKIAllbHNlIGlmICghYXJnIHx8ICFzdHJjbXAoYXJnLCAic2hhbGxvdyIpKQogCQkqdGhyZWFkID0gVEhSRUFEX1NIQUxMT1c7CiAJZWxzZSBpZiAoIXN0cmNtcChhcmcsICJkZWVwIikpCkBAIC0xNTQxLDYgKzE2MTYsNyBAQAogCWludCB1c2VfcGF0Y2hfZm9ybWF0ID0gMDsKIAlpbnQgcXVpZXQgPSAwOwogCWludCByZXJvbGxfY291bnQgPSAtMTsKKwljaGFyICpjb3Zlcl9mcm9tX2Rlc2NyaXB0aW9uX2FyZyA9IE5VTEw7CiAJY2hhciAqYnJhbmNoX25hbWUgPSBOVUxMOwogCWNoYXIgKmJhc2VfY29tbWl0ID0gTlVMTDsKIAlzdHJ1Y3QgYmFzZV90cmVlX2luZm8gYmFzZXM7CkBAIC0xNTc3LDYgKzE2NTMsOSBAQAogCQl7IE9QVElPTl9DQUxMQkFDSywgMCwgInJmYyIsICZyZXYsIE5VTEwsCiAJCQkgICAgTl8oIlVzZSBbUkZDIFBBVENIXSBpbnN0ZWFkIG9mIFtQQVRDSF0iKSwKIAkJCSAgICBQQVJTRV9PUFRfTk9BUkcgfCBQQVJTRV9PUFRfTk9ORUcsIHJmY19jYWxsYmFjayB9LAorCQlPUFRfU1RSSU5HKDAsICJjb3Zlci1mcm9tLWRlc2NyaXB0aW9uIiwgJmNvdmVyX2Zyb21fZGVzY3JpcHRpb25fYXJnLAorCQkJICAgIE5fKCJjb3Zlci1mcm9tLWRlc2NyaXB0aW9uLW1vZGUiKSwKKwkJCSAgICBOXygiZ2VuZXJhdGUgcGFydHMgb2YgYSBjb3ZlciBsZXR0ZXIgYmFzZWQgb24gYSBicmFuY2gncyBkZXNjcmlwdGlvbiIpKSwKIAkJeyBPUFRJT05fQ0FMTEJBQ0ssIDAsICJzdWJqZWN0LXByZWZpeCIsICZyZXYsIE5fKCJwcmVmaXgiKSwKIAkJCSAgICBOXygiVXNlIFs8cHJlZml4Pl0gaW5zdGVhZCBvZiBbUEFUQ0hdIiksCiAJCQkgICAgUEFSU0VfT1BUX05PTkVHLCBzdWJqZWN0X3ByZWZpeF9jYWxsYmFjayB9LApAQCAtMTY2OCw2ICsxNzQ3LDkgQEAKIAkJCSAgICAgUEFSU0VfT1BUX0tFRVBfQVJHVjAgfCBQQVJTRV9PUFRfS0VFUF9VTktOT1dOIHwKIAkJCSAgICAgUEFSU0VfT1BUX0tFRVBfREFTSERBU0gpOwogCisJaWYgKGNvdmVyX2Zyb21fZGVzY3JpcHRpb25fYXJnKQorCQljb3Zlcl9mcm9tX2Rlc2NyaXB0aW9uX21vZGUgPSBwYXJzZV9jb3Zlcl9mcm9tX2Rlc2NyaXB0aW9uKGNvdmVyX2Zyb21fZGVzY3JpcHRpb25fYXJnKTsKKwogCWlmICgwIDwgcmVyb2xsX2NvdW50KSB7CiAJCXN0cnVjdCBzdHJidWYgc3ByZWZpeCA9IFNUUkJVRl9JTklUOwogCQlzdHJidWZfYWRkZigmc3ByZWZpeCwgIiVzIHYlZCIsCkBAIC0xNzY1LDEwICsxODQ3LDI2IEBACiAJCXNldHVwX3BhZ2VyKCk7CiAKIAlpZiAob3V0cHV0X2RpcmVjdG9yeSkgeworCQlpbnQgc2F2ZWQ7CiAJCWlmIChyZXYuZGlmZm9wdC51c2VfY29sb3IgIT0gR0lUX0NPTE9SX0FMV0FZUykKIAkJCXJldi5kaWZmb3B0LnVzZV9jb2xvciA9IEdJVF9DT0xPUl9ORVZFUjsKIAkJaWYgKHVzZV9zdGRvdXQpCiAJCQlkaWUoXygic3RhbmRhcmQgb3V0cHV0LCBvciBkaXJlY3RvcnksIHdoaWNoIG9uZT8iKSk7CisJCS8qCisJCSAqIFdlIGNvbnNpZGVyIDxvdXRkaXI+IGFzICdvdXRzaWRlIG9mIGdpdGRpcicsIHRoZXJlZm9yZSBhdm9pZAorCQkgKiBhcHBseWluZyBhZGp1c3Rfc2hhcmVkX3Blcm0gaW4gcy1jLWwtZC4KKwkJICovCisJCXNhdmVkID0gZ2V0X3NoYXJlZF9yZXBvc2l0b3J5KCk7CisJCXNldF9zaGFyZWRfcmVwb3NpdG9yeSgwKTsKKwkJc3dpdGNoIChzYWZlX2NyZWF0ZV9sZWFkaW5nX2RpcmVjdG9yaWVzX2NvbnN0KG91dHB1dF9kaXJlY3RvcnkpKSB7CisJCWNhc2UgU0NMRF9PSzoKKwkJY2FzZSBTQ0xEX0VYSVNUUzoKKwkJCWJyZWFrOworCQlkZWZhdWx0OgorCQkJZGllKF8oImNvdWxkIG5vdCBjcmVhdGUgbGVhZGluZyBkaXJlY3RvcmllcyAiCisJCQkgICAgICAib2YgJyVzJyIpLCBvdXRwdXRfZGlyZWN0b3J5KTsKKwkJfQorCQlzZXRfc2hhcmVkX3JlcG9zaXRvcnkoc2F2ZWQpOwogCQlpZiAobWtkaXIob3V0cHV0X2RpcmVjdG9yeSwgMDc3NykgPCAwICYmIGVycm5vICE9IEVFWElTVCkKIAkJCWRpZV9lcnJubyhfKCJjb3VsZCBub3QgY3JlYXRlIGRpcmVjdG9yeSAnJXMnIiksCiAJCQkJICBvdXRwdXRfZGlyZWN0b3J5KTsKZGlmZiAtLWdpdCBhL2J1aWx0aW4vbHMtZmlsZXMuYyBiL2J1aWx0aW4vbHMtZmlsZXMuYwppbmRleCA2NzBlOGZiLi5mMDY5YTAyIDEwMDY0NAotLS0gYS9idWlsdGluL2xzLWZpbGVzLmMKKysrIGIvYnVpbHRpbi9scy1maWxlcy5jCkBAIC00OTIsNyArNDkyLDcgQEAKIAlCVUdfT05fT1BUX05FRyh1bnNldCk7CiAKIAlleGNfZ2l2ZW4gPSAxOwotCWFkZF9leGNsdWRlc19mcm9tX2ZpbGUoZGlyLCBhcmcpOworCWFkZF9wYXR0ZXJuc19mcm9tX2ZpbGUoZGlyLCBhcmcpOwogCiAJcmV0dXJuIDA7CiB9CkBAIC01MTYsNyArNTE2LDcgQEAKIAlpbnQgcmVxdWlyZV93b3JrX3RyZWUgPSAwLCBzaG93X3RhZyA9IDAsIGk7CiAJY29uc3QgY2hhciAqbWF4X3ByZWZpeDsKIAlzdHJ1Y3QgZGlyX3N0cnVjdCBkaXI7Ci0Jc3RydWN0IGV4Y2x1ZGVfbGlzdCAqZWw7CisJc3RydWN0IHBhdHRlcm5fbGlzdCAqcGw7CiAJc3RydWN0IHN0cmluZ19saXN0IGV4Y2x1ZGVfbGlzdCA9IFNUUklOR19MSVNUX0lOSVRfTk9EVVA7CiAJc3RydWN0IG9wdGlvbiBidWlsdGluX2xzX2ZpbGVzX29wdGlvbnNbXSA9IHsKIAkJLyogVGhpbmsgdHdpY2UgYmVmb3JlIGFkZGluZyAiLS1udWwiIHN5bm9ueW0gdG8gdGhpcyAqLwpAQCAtNTk0LDkgKzU5NCw5IEBACiAKIAlhcmdjID0gcGFyc2Vfb3B0aW9ucyhhcmdjLCBhcmd2LCBwcmVmaXgsIGJ1aWx0aW5fbHNfZmlsZXNfb3B0aW9ucywKIAkJCWxzX2ZpbGVzX3VzYWdlLCAwKTsKLQllbCA9IGFkZF9leGNsdWRlX2xpc3QoJmRpciwgRVhDX0NNREwsICItLWV4Y2x1ZGUgb3B0aW9uIik7CisJcGwgPSBhZGRfcGF0dGVybl9saXN0KCZkaXIsIEVYQ19DTURMLCAiLS1leGNsdWRlIG9wdGlvbiIpOwogCWZvciAoaSA9IDA7IGkgPCBleGNsdWRlX2xpc3QubnI7IGkrKykgewotCQlhZGRfZXhjbHVkZShleGNsdWRlX2xpc3QuaXRlbXNbaV0uc3RyaW5nLCAiIiwgMCwgZWwsIC0tZXhjbHVkZV9hcmdzKTsKKwkJYWRkX3BhdHRlcm4oZXhjbHVkZV9saXN0Lml0ZW1zW2ldLnN0cmluZywgIiIsIDAsIHBsLCAtLWV4Y2x1ZGVfYXJncyk7CiAJfQogCWlmIChzaG93X3RhZyB8fCBzaG93X3ZhbGlkX2JpdCB8fCBzaG93X2ZzbW9uaXRvcl9iaXQpIHsKIAkJdGFnX2NhY2hlZCA9ICJIICI7CmRpZmYgLS1naXQgYS9idWlsdGluL21lcmdlLXJlY3Vyc2l2ZS5jIGIvYnVpbHRpbi9tZXJnZS1yZWN1cnNpdmUuYwppbmRleCA1YjkxMGUzLi5hNGJmZDhmIDEwMDY0NAotLS0gYS9idWlsdGluL21lcmdlLXJlY3Vyc2l2ZS5jCisrKyBiL2J1aWx0aW4vbWVyZ2UtcmVjdXJzaXZlLmMKQEAgLTEsMyArMSw0IEBACisjaW5jbHVkZSAiY2FjaGUuaCIKICNpbmNsdWRlICJidWlsdGluLmgiCiAjaW5jbHVkZSAiY29tbWl0LmgiCiAjaW5jbHVkZSAidGFnLmgiCkBAIC02Myw2ICs2NCw5IEBACiAJaWYgKGFyZ2MgLSBpICE9IDMpIC8qICItLSIgIjxoZWFkPiIgIjxyZW1vdGU+IiAqLwogCQlkaWUoXygibm90IGhhbmRsaW5nIGFueXRoaW5nIG90aGVyIHRoYW4gdHdvIGhlYWRzIG1lcmdlLiIpKTsKIAorCWlmIChyZXBvX3JlYWRfaW5kZXhfdW5tZXJnZWQodGhlX3JlcG9zaXRvcnkpKQorCQlkaWVfcmVzb2x2ZV9jb25mbGljdCgibWVyZ2UiKTsKKwogCW8uYnJhbmNoMSA9IGFyZ3ZbKytpXTsKIAlvLmJyYW5jaDIgPSBhcmd2WysraV07CiAKZGlmZiAtLWdpdCBhL2J1aWx0aW4vbWVyZ2UtdHJlZS5jIGIvYnVpbHRpbi9tZXJnZS10cmVlLmMKaW5kZXggOTdiNTRjYS4uZTcyNzE0YSAxMDA2NDQKLS0tIGEvYnVpbHRpbi9tZXJnZS10cmVlLmMKKysrIGIvYnVpbHRpbi9tZXJnZS10cmVlLmMKQEAgLTE4MCw4ICsxODAsOSBAQAogCiBzdGF0aWMgY2hhciAqdHJhdmVyc2VfcGF0aChjb25zdCBzdHJ1Y3QgdHJhdmVyc2VfaW5mbyAqaW5mbywgY29uc3Qgc3RydWN0IG5hbWVfZW50cnkgKm4pCiB7Ci0JY2hhciAqcGF0aCA9IHhtYWxsb2N6KHRyYXZlcnNlX3BhdGhfbGVuKGluZm8sIG4pICsgdGhlX2hhc2hfYWxnby0+cmF3c3opOwotCXJldHVybiBtYWtlX3RyYXZlcnNlX3BhdGgocGF0aCwgaW5mbywgbik7CisJc3RydWN0IHN0cmJ1ZiBidWYgPSBTVFJCVUZfSU5JVDsKKwlzdHJidWZfbWFrZV90cmF2ZXJzZV9wYXRoKCZidWYsIGluZm8sIG4tPnBhdGgsIG4tPnBhdGhsZW4pOworCXJldHVybiBzdHJidWZfZGV0YWNoKCZidWYsIE5VTEwpOwogfQogCiBzdGF0aWMgdm9pZCByZXNvbHZlKGNvbnN0IHN0cnVjdCB0cmF2ZXJzZV9pbmZvICppbmZvLCBzdHJ1Y3QgbmFtZV9lbnRyeSAqb3Vycywgc3RydWN0IG5hbWVfZW50cnkgKnJlc3VsdCkKZGlmZiAtLWdpdCBhL2J1aWx0aW4vbWVyZ2UuYyBiL2J1aWx0aW4vbWVyZ2UuYwppbmRleCBlMmNjYmM0Li4wNjJlOTExIDEwMDY0NAotLS0gYS9idWlsdGluL21lcmdlLmMKKysrIGIvYnVpbHRpbi9tZXJnZS5jCkBAIC04MSw3ICs4MSw3IEBACiBzdGF0aWMgaW50IGRlZmF1bHRfdG9fdXBzdHJlYW0gPSAxOwogc3RhdGljIGludCBzaWdub2ZmOwogc3RhdGljIGNvbnN0IGNoYXIgKnNpZ25fY29tbWl0Owotc3RhdGljIGludCB2ZXJpZnlfbXNnID0gMTsKK3N0YXRpYyBpbnQgbm9fdmVyaWZ5OwogCiBzdGF0aWMgc3RydWN0IHN0cmF0ZWd5IGFsbF9zdHJhdGVneVtdID0gewogCXsgInJlY3Vyc2l2ZSIsICBERUZBVUxUX1RXT0hFQUQgfCBOT19UUklWSUFMIH0sCkBAIC0yODcsNyArMjg3LDcgQEAKIAkgIE5fKCJHUEcgc2lnbiBjb21taXQiKSwgUEFSU0VfT1BUX09QVEFSRywgTlVMTCwgKGludHB0cl90KSAiIiB9LAogCU9QVF9CT09MKDAsICJvdmVyd3JpdGUtaWdub3JlIiwgJm92ZXJ3cml0ZV9pZ25vcmUsIE5fKCJ1cGRhdGUgaWdub3JlZCBmaWxlcyAoZGVmYXVsdCkiKSksCiAJT1BUX0JPT0woMCwgInNpZ25vZmYiLCAmc2lnbm9mZiwgTl8oImFkZCBTaWduZWQtb2ZmLWJ5OiIpKSwKLQlPUFRfQk9PTCgwLCAidmVyaWZ5IiwgJnZlcmlmeV9tc2csIE5fKCJ2ZXJpZnkgY29tbWl0LW1zZyBob29rIikpLAorCU9QVF9CT09MKDAsICJuby12ZXJpZnkiLCAmbm9fdmVyaWZ5LCBOXygiYnlwYXNzIHByZS1tZXJnZS1jb21taXQgYW5kIGNvbW1pdC1tc2cgaG9va3MiKSksCiAJT1BUX0VORCgpCiB9OwogCkBAIC02ODgsMTYgKzY4OCwxMyBAQAogCQkJICAgICAgc3RydWN0IGNvbW1pdF9saXN0ICpyZW1vdGVoZWFkcywKIAkJCSAgICAgIHN0cnVjdCBjb21taXQgKmhlYWQpCiB7Ci0Jc3RydWN0IGxvY2tfZmlsZSBsb2NrID0gTE9DS19JTklUOwogCWNvbnN0IGNoYXIgKmhlYWRfYXJnID0gIkhFQUQiOwogCi0JaG9sZF9sb2NrZWRfaW5kZXgoJmxvY2ssIExPQ0tfRElFX09OX0VSUk9SKTsKLQlyZWZyZXNoX2NhY2hlKFJFRlJFU0hfUVVJRVQpOwotCWlmICh3cml0ZV9sb2NrZWRfaW5kZXgoJnRoZV9pbmRleCwgJmxvY2ssCi0JCQkgICAgICAgQ09NTUlUX0xPQ0sgfCBTS0lQX0lGX1VOQ0hBTkdFRCkpCisJaWYgKHJlZnJlc2hfYW5kX3dyaXRlX2NhY2hlKFJFRlJFU0hfUVVJRVQsIFNLSVBfSUZfVU5DSEFOR0VELCAwKSA8IDApCiAJCXJldHVybiBlcnJvcihfKCJVbmFibGUgdG8gd3JpdGUgaW5kZXguIikpOwogCiAJaWYgKCFzdHJjbXAoc3RyYXRlZ3ksICJyZWN1cnNpdmUiKSB8fCAhc3RyY21wKHN0cmF0ZWd5LCAic3VidHJlZSIpKSB7CisJCXN0cnVjdCBsb2NrX2ZpbGUgbG9jayA9IExPQ0tfSU5JVDsKIAkJaW50IGNsZWFuLCB4OwogCQlzdHJ1Y3QgY29tbWl0ICpyZXN1bHQ7CiAJCXN0cnVjdCBjb21taXRfbGlzdCAqcmV2ZXJzZWQgPSBOVUxMOwpAQCAtODE2LDYgKzgxMywxOCBAQAogc3RhdGljIHZvaWQgcHJlcGFyZV90b19jb21taXQoc3RydWN0IGNvbW1pdF9saXN0ICpyZW1vdGVoZWFkcykKIHsKIAlzdHJ1Y3Qgc3RyYnVmIG1zZyA9IFNUUkJVRl9JTklUOworCWNvbnN0IGNoYXIgKmluZGV4X2ZpbGUgPSBnZXRfaW5kZXhfZmlsZSgpOworCisJaWYgKCFub192ZXJpZnkgJiYgcnVuX2NvbW1pdF9ob29rKDAgPCBvcHRpb25fZWRpdCwgaW5kZXhfZmlsZSwgInByZS1tZXJnZS1jb21taXQiLCBOVUxMKSkKKwkJYWJvcnRfY29tbWl0KHJlbW90ZWhlYWRzLCBOVUxMKTsKKwkvKgorCSAqIFJlLXJlYWQgdGhlIGluZGV4IGFzIHByZS1tZXJnZS1jb21taXQgaG9vayBjb3VsZCBoYXZlIHVwZGF0ZWQgaXQsCisJICogYW5kIHdyaXRlIGl0IG91dCBhcyBhIHRyZWUuICBXZSBtdXN0IGRvIHRoaXMgYmVmb3JlIHdlIGludm9rZQorCSAqIHRoZSBlZGl0b3IgYW5kIGFmdGVyIHdlIGludm9rZSBydW5fc3RhdHVzIGFib3ZlLgorCSAqLworCWlmIChmaW5kX2hvb2soInByZS1tZXJnZS1jb21taXQiKSkKKwkJZGlzY2FyZF9jYWNoZSgpOworCXJlYWRfY2FjaGVfZnJvbShpbmRleF9maWxlKTsKIAlzdHJidWZfYWRkYnVmKCZtc2csICZtZXJnZV9tc2cpOwogCWlmIChzcXVhc2gpCiAJCUJVRygidGhlIGNvbnRyb2wgbXVzdCBub3QgcmVhY2ggaGVyZSB1bmRlciAtLXNxdWFzaCIpOwpAQCAtODQyLDcgKzg1MSw3IEBACiAJCQlhYm9ydF9jb21taXQocmVtb3RlaGVhZHMsIE5VTEwpOwogCX0KIAotCWlmICh2ZXJpZnlfbXNnICYmIHJ1bl9jb21taXRfaG9vaygwIDwgb3B0aW9uX2VkaXQsIGdldF9pbmRleF9maWxlKCksCisJaWYgKCFub192ZXJpZnkgJiYgcnVuX2NvbW1pdF9ob29rKDAgPCBvcHRpb25fZWRpdCwgZ2V0X2luZGV4X2ZpbGUoKSwKIAkJCQkJICAiY29tbWl0LW1zZyIsCiAJCQkJCSAgZ2l0X3BhdGhfbWVyZ2VfbXNnKHRoZV9yZXBvc2l0b3J5KSwgTlVMTCkpCiAJCWFib3J0X2NvbW1pdChyZW1vdGVoZWFkcywgTlVMTCk7CkBAIC04NjAsMTIgKzg2OSw4IEBACiB7CiAJc3RydWN0IG9iamVjdF9pZCByZXN1bHRfdHJlZSwgcmVzdWx0X2NvbW1pdDsKIAlzdHJ1Y3QgY29tbWl0X2xpc3QgKnBhcmVudHMsICoqcHB0ciA9ICZwYXJlbnRzOwotCXN0cnVjdCBsb2NrX2ZpbGUgbG9jayA9IExPQ0tfSU5JVDsKIAotCWhvbGRfbG9ja2VkX2luZGV4KCZsb2NrLCBMT0NLX0RJRV9PTl9FUlJPUik7Ci0JcmVmcmVzaF9jYWNoZShSRUZSRVNIX1FVSUVUKTsKLQlpZiAod3JpdGVfbG9ja2VkX2luZGV4KCZ0aGVfaW5kZXgsICZsb2NrLAotCQkJICAgICAgIENPTU1JVF9MT0NLIHwgU0tJUF9JRl9VTkNIQU5HRUQpKQorCWlmIChyZWZyZXNoX2FuZF93cml0ZV9jYWNoZShSRUZSRVNIX1FVSUVULCBTS0lQX0lGX1VOQ0hBTkdFRCwgMCkgPCAwKQogCQlyZXR1cm4gZXJyb3IoXygiVW5hYmxlIHRvIHdyaXRlIGluZGV4LiIpKTsKIAogCXdyaXRlX3RyZWVfdHJpdmlhbCgmcmVzdWx0X3RyZWUpOwpkaWZmIC0tZ2l0IGEvYnVpbHRpbi9tdWx0aS1wYWNrLWluZGV4LmMgYi9idWlsdGluL211bHRpLXBhY2staW5kZXguYwppbmRleCBiMWVhMWE2Li41YmY4OGNkIDEwMDY0NAotLS0gYS9idWlsdGluL211bHRpLXBhY2staW5kZXguYworKysgYi9idWlsdGluL211bHRpLXBhY2staW5kZXguYwpAQCAtNiwyMSArNiwyNSBAQAogI2luY2x1ZGUgInRyYWNlMi5oIgogCiBzdGF0aWMgY2hhciBjb25zdCAqIGNvbnN0IGJ1aWx0aW5fbXVsdGlfcGFja19pbmRleF91c2FnZVtdID0gewotCU5fKCJnaXQgbXVsdGktcGFjay1pbmRleCBbLS1vYmplY3QtZGlyPTxkaXI+XSAod3JpdGV8dmVyaWZ5fGV4cGlyZXxyZXBhY2sgLS1iYXRjaC1zaXplPTxzaXplPikiKSwKKwlOXygiZ2l0IG11bHRpLXBhY2staW5kZXggWzxvcHRpb25zPl0gKHdyaXRlfHZlcmlmeXxleHBpcmV8cmVwYWNrIC0tYmF0Y2gtc2l6ZT08c2l6ZT4pIiksCiAJTlVMTAogfTsKIAogc3RhdGljIHN0cnVjdCBvcHRzX211bHRpX3BhY2tfaW5kZXggewogCWNvbnN0IGNoYXIgKm9iamVjdF9kaXI7CiAJdW5zaWduZWQgbG9uZyBiYXRjaF9zaXplOworCWludCBwcm9ncmVzczsKIH0gb3B0czsKIAogaW50IGNtZF9tdWx0aV9wYWNrX2luZGV4KGludCBhcmdjLCBjb25zdCBjaGFyICoqYXJndiwKIAkJCSBjb25zdCBjaGFyICpwcmVmaXgpCiB7CisJdW5zaWduZWQgZmxhZ3MgPSAwOworCiAJc3RhdGljIHN0cnVjdCBvcHRpb24gYnVpbHRpbl9tdWx0aV9wYWNrX2luZGV4X29wdGlvbnNbXSA9IHsKIAkJT1BUX0ZJTEVOQU1FKDAsICJvYmplY3QtZGlyIiwgJm9wdHMub2JqZWN0X2RpciwKIAkJICBOXygib2JqZWN0IGRpcmVjdG9yeSBjb250YWluaW5nIHNldCBvZiBwYWNrZmlsZSBhbmQgcGFjay1pbmRleCBwYWlycyIpKSwKKwkJT1BUX0JPT0woMCwgInByb2dyZXNzIiwgJm9wdHMucHJvZ3Jlc3MsIE5fKCJmb3JjZSBwcm9ncmVzcyByZXBvcnRpbmciKSksCiAJCU9QVF9NQUdOSVRVREUoMCwgImJhdGNoLXNpemUiLCAmb3B0cy5iYXRjaF9zaXplLAogCQkgIE5fKCJkdXJpbmcgcmVwYWNrLCBjb2xsZWN0IHBhY2stZmlsZXMgb2Ygc21hbGxlciBzaXplIGludG8gYSBiYXRjaCB0aGF0IGlzIGxhcmdlciB0aGFuIHRoaXMgc2l6ZSIpKSwKIAkJT1BUX0VORCgpLApAQCAtMjgsMTIgKzMyLDE1IEBACiAKIAlnaXRfY29uZmlnKGdpdF9kZWZhdWx0X2NvbmZpZywgTlVMTCk7CiAKKwlvcHRzLnByb2dyZXNzID0gaXNhdHR5KDIpOwogCWFyZ2MgPSBwYXJzZV9vcHRpb25zKGFyZ2MsIGFyZ3YsIHByZWZpeCwKIAkJCSAgICAgYnVpbHRpbl9tdWx0aV9wYWNrX2luZGV4X29wdGlvbnMsCiAJCQkgICAgIGJ1aWx0aW5fbXVsdGlfcGFja19pbmRleF91c2FnZSwgMCk7CiAKIAlpZiAoIW9wdHMub2JqZWN0X2RpcikKIAkJb3B0cy5vYmplY3RfZGlyID0gZ2V0X29iamVjdF9kaXJlY3RvcnkoKTsKKwlpZiAob3B0cy5wcm9ncmVzcykKKwkJZmxhZ3MgfD0gTUlEWF9QUk9HUkVTUzsKIAogCWlmIChhcmdjID09IDApCiAJCXVzYWdlX3dpdGhfb3B0aW9ucyhidWlsdGluX211bHRpX3BhY2tfaW5kZXhfdXNhZ2UsCkBAIC00NywxNiArNTQsMTcgQEAKIAl0cmFjZTJfY21kX21vZGUoYXJndlswXSk7CiAKIAlpZiAoIXN0cmNtcChhcmd2WzBdLCAicmVwYWNrIikpCi0JCXJldHVybiBtaWR4X3JlcGFjayh0aGVfcmVwb3NpdG9yeSwgb3B0cy5vYmplY3RfZGlyLCAoc2l6ZV90KW9wdHMuYmF0Y2hfc2l6ZSk7CisJCXJldHVybiBtaWR4X3JlcGFjayh0aGVfcmVwb3NpdG9yeSwgb3B0cy5vYmplY3RfZGlyLAorCQkJKHNpemVfdClvcHRzLmJhdGNoX3NpemUsIGZsYWdzKTsKIAlpZiAob3B0cy5iYXRjaF9zaXplKQogCQlkaWUoXygiLS1iYXRjaC1zaXplIG9wdGlvbiBpcyBvbmx5IGZvciAncmVwYWNrJyBzdWJjb21tYW5kIikpOwogCiAJaWYgKCFzdHJjbXAoYXJndlswXSwgIndyaXRlIikpCi0JCXJldHVybiB3cml0ZV9taWR4X2ZpbGUob3B0cy5vYmplY3RfZGlyKTsKKwkJcmV0dXJuIHdyaXRlX21pZHhfZmlsZShvcHRzLm9iamVjdF9kaXIsIGZsYWdzKTsKIAlpZiAoIXN0cmNtcChhcmd2WzBdLCAidmVyaWZ5IikpCi0JCXJldHVybiB2ZXJpZnlfbWlkeF9maWxlKHRoZV9yZXBvc2l0b3J5LCBvcHRzLm9iamVjdF9kaXIpOworCQlyZXR1cm4gdmVyaWZ5X21pZHhfZmlsZSh0aGVfcmVwb3NpdG9yeSwgb3B0cy5vYmplY3RfZGlyLCBmbGFncyk7CiAJaWYgKCFzdHJjbXAoYXJndlswXSwgImV4cGlyZSIpKQotCQlyZXR1cm4gZXhwaXJlX21pZHhfcGFja3ModGhlX3JlcG9zaXRvcnksIG9wdHMub2JqZWN0X2Rpcik7CisJCXJldHVybiBleHBpcmVfbWlkeF9wYWNrcyh0aGVfcmVwb3NpdG9yeSwgb3B0cy5vYmplY3RfZGlyLCBmbGFncyk7CiAKIAlkaWUoXygidW5yZWNvZ25pemVkIHN1YmNvbW1hbmQ6ICVzIiksIGFyZ3ZbMF0pOwogfQpkaWZmIC0tZ2l0IGEvYnVpbHRpbi9uYW1lLXJldi5jIGIvYnVpbHRpbi9uYW1lLXJldi5jCmluZGV4IGM3ODVmZTEuLmIwZjA3NzYgMTAwNjQ0Ci0tLSBhL2J1aWx0aW4vbmFtZS1yZXYuYworKysgYi9idWlsdGluL25hbWUtcmV2LmMKQEAgLTksNyArOSwxMSBAQAogI2luY2x1ZGUgInNoYTEtbG9va3VwLmgiCiAjaW5jbHVkZSAiY29tbWl0LXNsYWIuaCIKIAotI2RlZmluZSBDVVRPRkZfREFURV9TTE9QIDg2NDAwIC8qIG9uZSBkYXkgKi8KKy8qCisgKiBPbmUgZGF5LiAgU2VlIHRoZSAnbmFtZSBhIHJldiBzaG9ydGx5IGFmdGVyIGVwb2NoJyB0ZXN0IGluIHQ2MTIwIHdoZW4KKyAqIGNoYW5naW5nIHRoaXMgdmFsdWUKKyAqLworI2RlZmluZSBDVVRPRkZfREFURV9TTE9QIDg2NDAwCiAKIHR5cGVkZWYgc3RydWN0IHJldl9uYW1lIHsKIAljb25zdCBjaGFyICp0aXBfbmFtZTsKQEAgLTQ4MSw4ICs0ODUsMTMgQEAKIAkJYWRkX29iamVjdF9hcnJheShvYmplY3QsICphcmd2LCAmcmV2cyk7CiAJfQogCi0JaWYgKGN1dG9mZikKLQkJY3V0b2ZmID0gY3V0b2ZmIC0gQ1VUT0ZGX0RBVEVfU0xPUDsKKwlpZiAoY3V0b2ZmKSB7CisJCS8qIGNoZWNrIGZvciB1bmRlZmxvdyAqLworCQlpZiAoY3V0b2ZmID4gVElNRV9NSU4gKyBDVVRPRkZfREFURV9TTE9QKQorCQkJY3V0b2ZmID0gY3V0b2ZmIC0gQ1VUT0ZGX0RBVEVfU0xPUDsKKwkJZWxzZQorCQkJY3V0b2ZmID0gVElNRV9NSU47CisJfQogCWZvcl9lYWNoX3JlZihuYW1lX3JlZiwgJmRhdGEpOwogCiAJaWYgKHRyYW5zZm9ybV9zdGRpbikgewpkaWZmIC0tZ2l0IGEvYnVpbHRpbi9ub3Rlcy5jIGIvYnVpbHRpbi9ub3Rlcy5jCmluZGV4IDAyZTk3ZjUuLjk1NDU2ZjMgMTAwNjQ0Ci0tLSBhL2J1aWx0aW4vbm90ZXMuYworKysgYi9idWlsdGluL25vdGVzLmMKQEAgLTUxMyw3ICs1MTMsNyBAQAogCQl9CiAJfQogCi0JaWYgKGFyZ2MgPCAyKSB7CisJaWYgKGFyZ2MgPCAxKSB7CiAJCWVycm9yKF8oInRvbyBmZXcgcGFyYW1ldGVycyIpKTsKIAkJdXNhZ2Vfd2l0aF9vcHRpb25zKGdpdF9ub3Rlc19jb3B5X3VzYWdlLCBvcHRpb25zKTsKIAl9CmRpZmYgLS1naXQgYS9idWlsdGluL3BhY2stb2JqZWN0cy5jIGIvYnVpbHRpbi9wYWNrLW9iamVjdHMuYwppbmRleCA3NmNlOTA2Li4zOTNjMjBhIDEwMDY0NAotLS0gYS9idWlsdGluL3BhY2stb2JqZWN0cy5jCisrKyBiL2J1aWx0aW4vcGFjay1vYmplY3RzLmMKQEAgLTE2Myw3ICsxNjMsNyBAQAogCWRlbHRhX2J1ZiA9IGRpZmZfZGVsdGEoYmFzZV9idWYsIGJhc2Vfc2l6ZSwKIAkJCSAgICAgICBidWYsIHNpemUsICZkZWx0YV9zaXplLCAwKTsKIAkvKgotCSAqIFdlIHN1Y2Nlc2Z1bGx5IGNvbXB1dGVkIHRoaXMgZGVsdGEgb25jZSBidXQgZHJvcHBlZCBpdCBmb3IKKwkgKiBXZSBzdWNjZXNzZnVsbHkgY29tcHV0ZWQgdGhpcyBkZWx0YSBvbmNlIGJ1dCBkcm9wcGVkIGl0IGZvcgogCSAqIG1lbW9yeSByZWFzb25zLiBTb21ldGhpbmcgaXMgdmVyeSB3cm9uZyBpZiB0aGlzIHRpbWUgd2UKIAkgKiByZWNvbXB1dGUgYW5kIGNyZWF0ZSBhIGRpZmZlcmVudCBkZWx0YS4KIAkgKi8KQEAgLTYxMCwxMiArNjEwLDEyIEBACiAJCSAgICAgICB2b2lkICpjYl9kYXRhKQogewogCXN0cnVjdCBvYmplY3RfaWQgcGVlbGVkOwotCXN0cnVjdCBvYmplY3RfZW50cnkgKmVudHJ5ID0gcGFja2xpc3RfZmluZCgmdG9fcGFjaywgb2lkLCBOVUxMKTsKKwlzdHJ1Y3Qgb2JqZWN0X2VudHJ5ICplbnRyeSA9IHBhY2tsaXN0X2ZpbmQoJnRvX3BhY2ssIG9pZCk7CiAKIAlpZiAoZW50cnkpCiAJCWVudHJ5LT50YWdnZWQgPSAxOwogCWlmICghcGVlbF9yZWYocGF0aCwgJnBlZWxlZCkpIHsKLQkJZW50cnkgPSBwYWNrbGlzdF9maW5kKCZ0b19wYWNrLCAmcGVlbGVkLCBOVUxMKTsKKwkJZW50cnkgPSBwYWNrbGlzdF9maW5kKCZ0b19wYWNrLCAmcGVlbGVkKTsKIAkJaWYgKGVudHJ5KQogCQkJZW50cnktPnRhZ2dlZCA9IDE7CiAJfQpAQCAtOTk2LDEyICs5OTYsMTEgQEAKICAqIGZldyBsaW5lcyBsYXRlciB3aGVuIHdlIHdhbnQgdG8gYWRkIHRoZSBuZXcgZW50cnkuCiAgKi8KIHN0YXRpYyBpbnQgaGF2ZV9kdXBsaWNhdGVfZW50cnkoY29uc3Qgc3RydWN0IG9iamVjdF9pZCAqb2lkLAotCQkJCWludCBleGNsdWRlLAotCQkJCXVpbnQzMl90ICppbmRleF9wb3MpCisJCQkJaW50IGV4Y2x1ZGUpCiB7CiAJc3RydWN0IG9iamVjdF9lbnRyeSAqZW50cnk7CiAKLQllbnRyeSA9IHBhY2tsaXN0X2ZpbmQoJnRvX3BhY2ssIG9pZCwgaW5kZXhfcG9zKTsKKwllbnRyeSA9IHBhY2tsaXN0X2ZpbmQoJnRvX3BhY2ssIG9pZCk7CiAJaWYgKCFlbnRyeSkKIAkJcmV0dXJuIDA7CiAKQEAgLTExNDEsMTMgKzExNDAsMTIgQEAKIAkJCQl1aW50MzJfdCBoYXNoLAogCQkJCWludCBleGNsdWRlLAogCQkJCWludCBub190cnlfZGVsdGEsCi0JCQkJdWludDMyX3QgaW5kZXhfcG9zLAogCQkJCXN0cnVjdCBwYWNrZWRfZ2l0ICpmb3VuZF9wYWNrLAogCQkJCW9mZl90IGZvdW5kX29mZnNldCkKIHsKIAlzdHJ1Y3Qgb2JqZWN0X2VudHJ5ICplbnRyeTsKIAotCWVudHJ5ID0gcGFja2xpc3RfYWxsb2MoJnRvX3BhY2ssIG9pZC0+aGFzaCwgaW5kZXhfcG9zKTsKKwllbnRyeSA9IHBhY2tsaXN0X2FsbG9jKCZ0b19wYWNrLCBvaWQpOwogCWVudHJ5LT5oYXNoID0gaGFzaDsKIAlvZV9zZXRfdHlwZShlbnRyeSwgdHlwZSk7CiAJaWYgKGV4Y2x1ZGUpCkBAIC0xMTcxLDExICsxMTY5LDEwIEBACiB7CiAJc3RydWN0IHBhY2tlZF9naXQgKmZvdW5kX3BhY2sgPSBOVUxMOwogCW9mZl90IGZvdW5kX29mZnNldCA9IDA7Ci0JdWludDMyX3QgaW5kZXhfcG9zOwogCiAJZGlzcGxheV9wcm9ncmVzcyhwcm9ncmVzc19zdGF0ZSwgKytucl9zZWVuKTsKIAotCWlmIChoYXZlX2R1cGxpY2F0ZV9lbnRyeShvaWQsIGV4Y2x1ZGUsICZpbmRleF9wb3MpKQorCWlmIChoYXZlX2R1cGxpY2F0ZV9lbnRyeShvaWQsIGV4Y2x1ZGUpKQogCQlyZXR1cm4gMDsKIAogCWlmICghd2FudF9vYmplY3RfaW5fcGFjayhvaWQsIGV4Y2x1ZGUsICZmb3VuZF9wYWNrLCAmZm91bmRfb2Zmc2V0KSkgewpAQCAtMTE5MCw3ICsxMTg3LDcgQEAKIAogCWNyZWF0ZV9vYmplY3RfZW50cnkob2lkLCB0eXBlLCBwYWNrX25hbWVfaGFzaChuYW1lKSwKIAkJCSAgICBleGNsdWRlLCBuYW1lICYmIG5vX3RyeV9kZWx0YShuYW1lKSwKLQkJCSAgICBpbmRleF9wb3MsIGZvdW5kX3BhY2ssIGZvdW5kX29mZnNldCk7CisJCQkgICAgZm91bmRfcGFjaywgZm91bmRfb2Zmc2V0KTsKIAlyZXR1cm4gMTsKIH0KIApAQCAtMTE5OSwxNyArMTE5NiwxNSBAQAogCQkJCQlpbnQgZmxhZ3MsIHVpbnQzMl90IG5hbWVfaGFzaCwKIAkJCQkJc3RydWN0IHBhY2tlZF9naXQgKnBhY2ssIG9mZl90IG9mZnNldCkKIHsKLQl1aW50MzJfdCBpbmRleF9wb3M7Ci0KIAlkaXNwbGF5X3Byb2dyZXNzKHByb2dyZXNzX3N0YXRlLCArK25yX3NlZW4pOwogCi0JaWYgKGhhdmVfZHVwbGljYXRlX2VudHJ5KG9pZCwgMCwgJmluZGV4X3BvcykpCisJaWYgKGhhdmVfZHVwbGljYXRlX2VudHJ5KG9pZCwgMCkpCiAJCXJldHVybiAwOwogCiAJaWYgKCF3YW50X29iamVjdF9pbl9wYWNrKG9pZCwgMCwgJnBhY2ssICZvZmZzZXQpKQogCQlyZXR1cm4gMDsKIAotCWNyZWF0ZV9vYmplY3RfZW50cnkob2lkLCB0eXBlLCBuYW1lX2hhc2gsIDAsIDAsIGluZGV4X3BvcywgcGFjaywgb2Zmc2V0KTsKKwljcmVhdGVfb2JqZWN0X2VudHJ5KG9pZCwgdHlwZSwgbmFtZV9oYXNoLCAwLCAwLCBwYWNrLCBvZmZzZXQpOwogCXJldHVybiAxOwogfQogCkBAIC0xNTA3LDcgKzE1MDIsNyBAQAogCSAqIEZpcnN0IHNlZSBpZiB3ZSdyZSBhbHJlYWR5IHNlbmRpbmcgdGhlIGJhc2UgKG9yIGl0J3MgZXhwbGljaXRseSBpbgogCSAqIG91ciAiZXhjbHVkZWQiIGxpc3QpLgogCSAqLwotCWJhc2UgPSBwYWNrbGlzdF9maW5kKCZ0b19wYWNrLCAmYmFzZV9vaWQsIE5VTEwpOworCWJhc2UgPSBwYWNrbGlzdF9maW5kKCZ0b19wYWNrLCAmYmFzZV9vaWQpOwogCWlmIChiYXNlKSB7CiAJCWlmICghaW5fc2FtZV9pc2xhbmQoJmRlbHRhLT5pZHgub2lkLCAmYmFzZS0+aWR4Lm9pZCkpCiAJCQlyZXR1cm4gMDsKQEAgLTIzNDIsMTUgKzIzMzcsNiBAQAogCWZyZWUoYXJyYXkpOwogfQogCi1zdGF0aWMgdm9pZCB0cnlfdG9fZnJlZV9mcm9tX3RocmVhZHMoc2l6ZV90IHNpemUpCi17Ci0JcGFja2luZ19kYXRhX2xvY2soJnRvX3BhY2spOwotCXJlbGVhc2VfcGFja19tZW1vcnkoc2l6ZSk7Ci0JcGFja2luZ19kYXRhX3VubG9jaygmdG9fcGFjayk7Ci19Ci0KLXN0YXRpYyB0cnlfdG9fZnJlZV90IG9sZF90cnlfdG9fZnJlZV9yb3V0aW5lOwotCiAvKgogICogVGhlIG1haW4gb2JqZWN0IGxpc3QgaXMgc3BsaXQgaW50byBzbWFsbGVyIGxpc3RzLCBlYWNoIGlzIGhhbmRlZCB0bwogICogb25lIHdvcmtlci4KQEAgLTIzOTEsMTIgKzIzNzcsMTAgQEAKIAlwdGhyZWFkX211dGV4X2luaXQoJmNhY2hlX211dGV4LCBOVUxMKTsKIAlwdGhyZWFkX211dGV4X2luaXQoJnByb2dyZXNzX211dGV4LCBOVUxMKTsKIAlwdGhyZWFkX2NvbmRfaW5pdCgmcHJvZ3Jlc3NfY29uZCwgTlVMTCk7Ci0Jb2xkX3RyeV90b19mcmVlX3JvdXRpbmUgPSBzZXRfdHJ5X3RvX2ZyZWVfcm91dGluZSh0cnlfdG9fZnJlZV9mcm9tX3RocmVhZHMpOwogfQogCiBzdGF0aWMgdm9pZCBjbGVhbnVwX3RocmVhZGVkX3NlYXJjaCh2b2lkKQogewotCXNldF90cnlfdG9fZnJlZV9yb3V0aW5lKG9sZF90cnlfdG9fZnJlZV9yb3V0aW5lKTsKIAlwdGhyZWFkX2NvbmRfZGVzdHJveSgmcHJvZ3Jlc3NfY29uZCk7CiAJcHRocmVhZF9tdXRleF9kZXN0cm95KCZjYWNoZV9tdXRleCk7CiAJcHRocmVhZF9tdXRleF9kZXN0cm95KCZwcm9ncmVzc19tdXRleCk7CkBAIC0yNTc5LDcgKzI1NjMsNyBAQAogCSAqIGl0IHdhcyBpbmNsdWRlZCB2aWEgYml0bWFwcywgd2Ugd291bGQgbm90IGhhdmUgcGFyc2VkIGl0CiAJICogcHJldmlvdXNseSkuCiAJICovCi0JaWYgKHBhY2tsaXN0X2ZpbmQoJnRvX3BhY2ssIG9pZCwgTlVMTCkpCisJaWYgKHBhY2tsaXN0X2ZpbmQoJnRvX3BhY2ssIG9pZCkpCiAJCXJldHVybjsKIAogCXRhZyA9IGxvb2t1cF90YWcodGhlX3JlcG9zaXRvcnksIG9pZCk7CkBAIC0yNjAzLDcgKzI1ODcsNyBAQAogCiAJaWYgKHN0YXJ0c193aXRoKHBhdGgsICJyZWZzL3RhZ3MvIikgJiYgLyogaXMgYSB0YWc/ICovCiAJICAgICFwZWVsX3JlZihwYXRoLCAmcGVlbGVkKSAgICAmJiAvKiBwZWVsYWJsZT8gKi8KLQkgICAgcGFja2xpc3RfZmluZCgmdG9fcGFjaywgJnBlZWxlZCwgTlVMTCkpICAgICAgLyogb2JqZWN0IHBhY2tlZD8gKi8KKwkgICAgcGFja2xpc3RfZmluZCgmdG9fcGFjaywgJnBlZWxlZCkpICAgICAgLyogb2JqZWN0IHBhY2tlZD8gKi8KIAkJYWRkX3RhZ19jaGFpbihvaWQpOwogCXJldHVybiAwOwogfQpAQCAtMjcxNSwxMCArMjY5OSw2IEBACiAJCXVzZV9iaXRtYXBfaW5kZXhfZGVmYXVsdCA9IGdpdF9jb25maWdfYm9vbChrLCB2KTsKIAkJcmV0dXJuIDA7CiAJfQotCWlmICghc3RyY21wKGssICJwYWNrLnVzZXNwYXJzZSIpKSB7Ci0JCXNwYXJzZSA9IGdpdF9jb25maWdfYm9vbChrLCB2KTsKLQkJcmV0dXJuIDA7Ci0JfQogCWlmICghc3RyY21wKGssICJwYWNrLnRocmVhZHMiKSkgewogCQlkZWx0YV9zZWFyY2hfdGhyZWFkcyA9IGdpdF9jb25maWdfaW50KGssIHYpOwogCQlpZiAoZGVsdGFfc2VhcmNoX3RocmVhZHMgPCAwKQpAQCAtMjgwMyw3ICsyNzgzLDcgQEAKIAkJZm9yIChwID0gc3RyY2hyKG5hbWUsICcvJyk7IHA7IHAgPSBzdHJjaHIocCArIDEsICcvJykpCiAJCQlkZXB0aCsrOwogCi0JCWVudCA9IHBhY2tsaXN0X2ZpbmQoJnRvX3BhY2ssICZvYmotPm9pZCwgTlVMTCk7CisJCWVudCA9IHBhY2tsaXN0X2ZpbmQoJnRvX3BhY2ssICZvYmotPm9pZCk7CiAJCWlmIChlbnQgJiYgZGVwdGggPiBvZV90cmVlX2RlcHRoKCZ0b19wYWNrLCBlbnQpKQogCQkJb2Vfc2V0X3RyZWVfZGVwdGgoJnRvX3BhY2ssIGVudCwgZGVwdGgpOwogCX0KQEAgLTMwMzQsNyArMzAxNCw3IEBACiAKIAkJZm9yIChpID0gMDsgaSA8IHAtPm51bV9vYmplY3RzOyBpKyspIHsKIAkJCW50aF9wYWNrZWRfb2JqZWN0X29pZCgmb2lkLCBwLCBpKTsKLQkJCWlmICghcGFja2xpc3RfZmluZCgmdG9fcGFjaywgJm9pZCwgTlVMTCkgJiYKKwkJCWlmICghcGFja2xpc3RfZmluZCgmdG9fcGFjaywgJm9pZCkgJiYKIAkJCSAgICAhaGFzX3NoYTFfcGFja19rZXB0X29yX25vbmxvY2FsKCZvaWQpICYmCiAJCQkgICAgIWxvb3NlbmVkX29iamVjdF9jYW5fYmVfZGlzY2FyZGVkKCZvaWQsIHAtPm10aW1lKSkKIAkJCQlpZiAoZm9yY2Vfb2JqZWN0X2xvb3NlKCZvaWQsIHAtPm10aW1lKSkKQEAgLTMzNDMsNiArMzMyMywxMCBAQAogCXJlYWRfcmVwbGFjZV9yZWZzID0gMDsKIAogCXNwYXJzZSA9IGdpdF9lbnZfYm9vbCgiR0lUX1RFU1RfUEFDS19TUEFSU0UiLCAwKTsKKwlwcmVwYXJlX3JlcG9fc2V0dGluZ3ModGhlX3JlcG9zaXRvcnkpOworCWlmICghc3BhcnNlICYmIHRoZV9yZXBvc2l0b3J5LT5zZXR0aW5ncy5wYWNrX3VzZV9zcGFyc2UgIT0gLTEpCisJCXNwYXJzZSA9IHRoZV9yZXBvc2l0b3J5LT5zZXR0aW5ncy5wYWNrX3VzZV9zcGFyc2U7CisKIAlyZXNldF9wYWNrX2lkeF9vcHRpb24oJnBhY2tfaWR4X29wdHMpOwogCWdpdF9jb25maWcoZ2l0X3BhY2tfY29uZmlnLCBOVUxMKTsKIApkaWZmIC0tZ2l0IGEvYnVpbHRpbi9wYXRjaC1pZC5jIGIvYnVpbHRpbi9wYXRjaC1pZC5jCmluZGV4IGJkMjhiODAuLjMwNTllNTIgMTAwNjQ0Ci0tLSBhL2J1aWx0aW4vcGF0Y2gtaWQuYworKysgYi9idWlsdGluL3BhdGNoLWlkLmMKQEAgLTEsMTUgKzEsMTYgQEAKKyNpbmNsdWRlICJjYWNoZS5oIgogI2luY2x1ZGUgImJ1aWx0aW4uaCIKICNpbmNsdWRlICJjb25maWcuaCIKICNpbmNsdWRlICJkaWZmLmgiCiAKIHN0YXRpYyB2b2lkIGZsdXNoX2N1cnJlbnRfaWQoaW50IHBhdGNobGVuLCBzdHJ1Y3Qgb2JqZWN0X2lkICppZCwgc3RydWN0IG9iamVjdF9pZCAqcmVzdWx0KQogewotCWNoYXIgbmFtZVs1MF07CisJY2hhciBuYW1lW0dJVF9NQVhfSEVYU1ogKyAxXTsKIAogCWlmICghcGF0Y2hsZW4pCiAJCXJldHVybjsKIAotCW1lbWNweShuYW1lLCBvaWRfdG9faGV4KGlkKSwgR0lUX1NIQTFfSEVYU1ogKyAxKTsKKwltZW1jcHkobmFtZSwgb2lkX3RvX2hleChpZCksIHRoZV9oYXNoX2FsZ28tPmhleHN6ICsgMSk7CiAJcHJpbnRmKCIlcyAlc1xuIiwgb2lkX3RvX2hleChyZXN1bHQpLCBuYW1lKTsKIH0KIApAQCAtNjAsOSArNjEsOSBAQAogewogCWludCBwYXRjaGxlbiA9IDAsIGZvdW5kX25leHQgPSAwOwogCWludCBiZWZvcmUgPSAtMSwgYWZ0ZXIgPSAtMTsKLQlnaXRfU0hBX0NUWCBjdHg7CisJZ2l0X2hhc2hfY3R4IGN0eDsKIAotCWdpdF9TSEExX0luaXQoJmN0eCk7CisJdGhlX2hhc2hfYWxnby0+aW5pdF9mbigmY3R4KTsKIAlvaWRjbHIocmVzdWx0KTsKIAogCXdoaWxlIChzdHJidWZfZ2V0d2hvbGVsaW5lKGxpbmVfYnVmLCBzdGRpbiwgJ1xuJykgIT0gRU9GKSB7CkBAIC0xMjIsNyArMTIzLDcgQEAKIAkJLyogQ29tcHV0ZSB0aGUgc2hhIHdpdGhvdXQgd2hpdGVzcGFjZSAqLwogCQlsZW4gPSByZW1vdmVfc3BhY2UobGluZSk7CiAJCXBhdGNobGVuICs9IGxlbjsKLQkJZ2l0X1NIQTFfVXBkYXRlKCZjdHgsIGxpbmUsIGxlbik7CisJCXRoZV9oYXNoX2FsZ28tPnVwZGF0ZV9mbigmY3R4LCBsaW5lLCBsZW4pOwogCX0KIAogCWlmICghZm91bmRfbmV4dCkKZGlmZiAtLWdpdCBhL2J1aWx0aW4vcHVsbC5jIGIvYnVpbHRpbi9wdWxsLmMKaW5kZXggZjFlYWY2ZS4uZDI1ZmYxMyAxMDA2NDQKLS0tIGEvYnVpbHRpbi9wdWxsLmMKKysrIGIvYnVpbHRpbi9wdWxsLmMKQEAgLTEyOSw2ICsxMjksNyBAQAogc3RhdGljIGNoYXIgKm9wdF9pcHY0Owogc3RhdGljIGNoYXIgKm9wdF9pcHY2Owogc3RhdGljIGludCBvcHRfc2hvd19mb3JjZWRfdXBkYXRlcyA9IC0xOworc3RhdGljIGNoYXIgKnNldF91cHN0cmVhbTsKIAogc3RhdGljIHN0cnVjdCBvcHRpb24gcHVsbF9vcHRpb25zW10gPSB7CiAJLyogU2hhcmVkIG9wdGlvbnMgKi8KQEAgLTI0Myw2ICsyNDQsOSBAQAogCQlQQVJTRV9PUFRfTk9BUkcpLAogCU9QVF9CT09MKDAsICJzaG93LWZvcmNlZC11cGRhdGVzIiwgJm9wdF9zaG93X2ZvcmNlZF91cGRhdGVzLAogCQkgTl8oImNoZWNrIGZvciBmb3JjZWQtdXBkYXRlcyBvbiBhbGwgdXBkYXRlZCBicmFuY2hlcyIpKSwKKwlPUFRfUEFTU1RIUlUoMCwgInNldC11cHN0cmVhbSIsICZzZXRfdXBzdHJlYW0sIE5VTEwsCisJCU5fKCJzZXQgdXBzdHJlYW0gZm9yIGdpdCBwdWxsL2ZldGNoIiksCisJCVBBUlNFX09QVF9OT0FSRyksCiAKIAlPUFRfRU5EKCkKIH07CkBAIC01NTYsNiArNTYwLDggQEAKIAkJYXJndl9hcnJheV9wdXNoKCZhcmdzLCAiLS1zaG93LWZvcmNlZC11cGRhdGVzIik7CiAJZWxzZSBpZiAob3B0X3Nob3dfZm9yY2VkX3VwZGF0ZXMgPT0gMCkKIAkJYXJndl9hcnJheV9wdXNoKCZhcmdzLCAiLS1uby1zaG93LWZvcmNlZC11cGRhdGVzIik7CisJaWYgKHNldF91cHN0cmVhbSkKKwkJYXJndl9hcnJheV9wdXNoKCZhcmdzLCBzZXRfdXBzdHJlYW0pOwogCiAJaWYgKHJlcG8pIHsKIAkJYXJndl9hcnJheV9wdXNoKCZhcmdzLCByZXBvKTsKZGlmZiAtLWdpdCBhL2J1aWx0aW4vcHVzaC5jIGIvYnVpbHRpbi9wdXNoLmMKaW5kZXggMDIxZGQzYi4uODQzZjViMiAxMDA2NDQKLS0tIGEvYnVpbHRpbi9wdXNoLmMKKysrIGIvYnVpbHRpbi9wdXNoLmMKQEAgLTE0Myw4ICsxNDMsOCBAQAogCXJldHVybiByZW1vdGUtPnVybF9ucjsKIH0KIAotc3RhdGljIE5PUkVUVVJOIGludCBkaWVfcHVzaF9zaW1wbGUoc3RydWN0IGJyYW5jaCAqYnJhbmNoLAotCQkJCSAgICBzdHJ1Y3QgcmVtb3RlICpyZW1vdGUpCitzdGF0aWMgTk9SRVRVUk4gdm9pZCBkaWVfcHVzaF9zaW1wbGUoc3RydWN0IGJyYW5jaCAqYnJhbmNoLAorCQkJCSAgICAgc3RydWN0IHJlbW90ZSAqcmVtb3RlKQogewogCS8qCiAJICogVGhlcmUncyBubyBwb2ludCBpbiB1c2luZyBzaG9ydGVuX3VuYW1iaWd1b3VzX3JlZiBoZXJlLApAQCAtMzU3LDggKzM1NywxMCBAQAogCiAJaWYgKHZlcmJvc2l0eSA+IDApCiAJCWZwcmludGYoc3RkZXJyLCBfKCJQdXNoaW5nIHRvICVzXG4iKSwgdHJhbnNwb3J0LT51cmwpOworCXRyYWNlMl9yZWdpb25fZW50ZXIoInB1c2giLCAidHJhbnNwb3J0X3B1c2giLCB0aGVfcmVwb3NpdG9yeSk7CiAJZXJyID0gdHJhbnNwb3J0X3B1c2godGhlX3JlcG9zaXRvcnksIHRyYW5zcG9ydCwKIAkJCSAgICAgcnMsIGZsYWdzLCAmcmVqZWN0X3JlYXNvbnMpOworCXRyYWNlMl9yZWdpb25fbGVhdmUoInB1c2giLCAidHJhbnNwb3J0X3B1c2giLCB0aGVfcmVwb3NpdG9yeSk7CiAJaWYgKGVyciAhPSAwKSB7CiAJCWZwcmludGYoc3RkZXJyLCAiJXMiLCBwdXNoX2dldF9jb2xvcihQVVNIX0NPTE9SX0VSUk9SKSk7CiAJCWVycm9yKF8oImZhaWxlZCB0byBwdXNoIHNvbWUgcmVmcyB0byAnJXMnIiksIHRyYW5zcG9ydC0+dXJsKTsKQEAgLTM4NSwzMCArMzg3LDE0IEBACiB9CiAKIHN0YXRpYyBpbnQgZG9fcHVzaChjb25zdCBjaGFyICpyZXBvLCBpbnQgZmxhZ3MsCi0JCSAgIGNvbnN0IHN0cnVjdCBzdHJpbmdfbGlzdCAqcHVzaF9vcHRpb25zKQorCQkgICBjb25zdCBzdHJ1Y3Qgc3RyaW5nX2xpc3QgKnB1c2hfb3B0aW9ucywKKwkJICAgc3RydWN0IHJlbW90ZSAqcmVtb3RlKQogewogCWludCBpLCBlcnJzOwotCXN0cnVjdCByZW1vdGUgKnJlbW90ZSA9IHB1c2hyZW1vdGVfZ2V0KHJlcG8pOwogCWNvbnN0IGNoYXIgKip1cmw7CiAJaW50IHVybF9ucjsKIAlzdHJ1Y3QgcmVmc3BlYyAqcHVzaF9yZWZzcGVjID0gJnJzOwogCi0JaWYgKCFyZW1vdGUpIHsKLQkJaWYgKHJlcG8pCi0JCQlkaWUoXygiYmFkIHJlcG9zaXRvcnkgJyVzJyIpLCByZXBvKTsKLQkJZGllKF8oIk5vIGNvbmZpZ3VyZWQgcHVzaCBkZXN0aW5hdGlvbi5cbiIKLQkJICAgICJFaXRoZXIgc3BlY2lmeSB0aGUgVVJMIGZyb20gdGhlIGNvbW1hbmQtbGluZSBvciBjb25maWd1cmUgYSByZW1vdGUgcmVwb3NpdG9yeSB1c2luZ1xuIgotCQkgICAgIlxuIgotCQkgICAgIiAgICBnaXQgcmVtb3RlIGFkZCA8bmFtZT4gPHVybD5cbiIKLQkJICAgICJcbiIKLQkJICAgICJhbmQgdGhlbiBwdXNoIHVzaW5nIHRoZSByZW1vdGUgbmFtZVxuIgotCQkgICAgIlxuIgotCQkgICAgIiAgICBnaXQgcHVzaCA8bmFtZT5cbiIpKTsKLQl9Ci0KLQlpZiAocmVtb3RlLT5taXJyb3IpCi0JCWZsYWdzIHw9IChUUkFOU1BPUlRfUFVTSF9NSVJST1J8VFJBTlNQT1JUX1BVU0hfRk9SQ0UpOwotCiAJaWYgKHB1c2hfb3B0aW9ucy0+bnIpCiAJCWZsYWdzIHw9IFRSQU5TUE9SVF9QVVNIX09QVElPTlM7CiAKQEAgLTU0OCw2ICs1MzQsNyBAQAogCXN0cnVjdCBzdHJpbmdfbGlzdCBwdXNoX29wdGlvbnNfY21kbGluZSA9IFNUUklOR19MSVNUX0lOSVRfRFVQOwogCXN0cnVjdCBzdHJpbmdfbGlzdCAqcHVzaF9vcHRpb25zOwogCWNvbnN0IHN0cnVjdCBzdHJpbmdfbGlzdF9pdGVtICppdGVtOworCXN0cnVjdCByZW1vdGUgKnJlbW90ZTsKIAogCXN0cnVjdCBvcHRpb24gb3B0aW9uc1tdID0gewogCQlPUFRfX1ZFUkJPU0lUWSgmdmVyYm9zaXR5KSwKQEAgLTYwMiwyMCArNTg5LDYgQEAKIAkJZGllKF8oIi0tZGVsZXRlIGlzIGluY29tcGF0aWJsZSB3aXRoIC0tYWxsLCAtLW1pcnJvciBhbmQgLS10YWdzIikpOwogCWlmIChkZWxldGVyZWZzICYmIGFyZ2MgPCAyKQogCQlkaWUoXygiLS1kZWxldGUgZG9lc24ndCBtYWtlIHNlbnNlIHdpdGhvdXQgYW55IHJlZnMiKSk7Ci0JaWYgKGZsYWdzICYgVFJBTlNQT1JUX1BVU0hfQUxMKSB7Ci0JCWlmICh0YWdzKQotCQkJZGllKF8oIi0tYWxsIGFuZCAtLXRhZ3MgYXJlIGluY29tcGF0aWJsZSIpKTsKLQkJaWYgKGFyZ2MgPj0gMikKLQkJCWRpZShfKCItLWFsbCBjYW4ndCBiZSBjb21iaW5lZCB3aXRoIHJlZnNwZWNzIikpOwotCX0KLQlpZiAoZmxhZ3MgJiBUUkFOU1BPUlRfUFVTSF9NSVJST1IpIHsKLQkJaWYgKHRhZ3MpCi0JCQlkaWUoXygiLS1taXJyb3IgYW5kIC0tdGFncyBhcmUgaW5jb21wYXRpYmxlIikpOwotCQlpZiAoYXJnYyA+PSAyKQotCQkJZGllKF8oIi0tbWlycm9yIGNhbid0IGJlIGNvbWJpbmVkIHdpdGggcmVmc3BlY3MiKSk7Ci0JfQotCWlmICgoZmxhZ3MgJiBUUkFOU1BPUlRfUFVTSF9BTEwpICYmIChmbGFncyAmIFRSQU5TUE9SVF9QVVNIX01JUlJPUikpCi0JCWRpZShfKCItLWFsbCBhbmQgLS1taXJyb3IgYXJlIGluY29tcGF0aWJsZSIpKTsKIAogCWlmIChyZWN1cnNlX3N1Ym1vZHVsZXMgPT0gUkVDVVJTRV9TVUJNT0RVTEVTX0NIRUNLKQogCQlmbGFncyB8PSBUUkFOU1BPUlRfUkVDVVJTRV9TVUJNT0RVTEVTX0NIRUNLOwpAQCAtNjMyLDExICs2MDUsNDMgQEAKIAkJc2V0X3JlZnNwZWNzKGFyZ3YgKyAxLCBhcmdjIC0gMSwgcmVwbyk7CiAJfQogCisJcmVtb3RlID0gcHVzaHJlbW90ZV9nZXQocmVwbyk7CisJaWYgKCFyZW1vdGUpIHsKKwkJaWYgKHJlcG8pCisJCQlkaWUoXygiYmFkIHJlcG9zaXRvcnkgJyVzJyIpLCByZXBvKTsKKwkJZGllKF8oIk5vIGNvbmZpZ3VyZWQgcHVzaCBkZXN0aW5hdGlvbi5cbiIKKwkJICAgICJFaXRoZXIgc3BlY2lmeSB0aGUgVVJMIGZyb20gdGhlIGNvbW1hbmQtbGluZSBvciBjb25maWd1cmUgYSByZW1vdGUgcmVwb3NpdG9yeSB1c2luZ1xuIgorCQkgICAgIlxuIgorCQkgICAgIiAgICBnaXQgcmVtb3RlIGFkZCA8bmFtZT4gPHVybD5cbiIKKwkJICAgICJcbiIKKwkJICAgICJhbmQgdGhlbiBwdXNoIHVzaW5nIHRoZSByZW1vdGUgbmFtZVxuIgorCQkgICAgIlxuIgorCQkgICAgIiAgICBnaXQgcHVzaCA8bmFtZT5cbiIpKTsKKwl9CisKKwlpZiAocmVtb3RlLT5taXJyb3IpCisJCWZsYWdzIHw9IChUUkFOU1BPUlRfUFVTSF9NSVJST1J8VFJBTlNQT1JUX1BVU0hfRk9SQ0UpOworCisJaWYgKGZsYWdzICYgVFJBTlNQT1JUX1BVU0hfQUxMKSB7CisJCWlmICh0YWdzKQorCQkJZGllKF8oIi0tYWxsIGFuZCAtLXRhZ3MgYXJlIGluY29tcGF0aWJsZSIpKTsKKwkJaWYgKGFyZ2MgPj0gMikKKwkJCWRpZShfKCItLWFsbCBjYW4ndCBiZSBjb21iaW5lZCB3aXRoIHJlZnNwZWNzIikpOworCX0KKwlpZiAoZmxhZ3MgJiBUUkFOU1BPUlRfUFVTSF9NSVJST1IpIHsKKwkJaWYgKHRhZ3MpCisJCQlkaWUoXygiLS1taXJyb3IgYW5kIC0tdGFncyBhcmUgaW5jb21wYXRpYmxlIikpOworCQlpZiAoYXJnYyA+PSAyKQorCQkJZGllKF8oIi0tbWlycm9yIGNhbid0IGJlIGNvbWJpbmVkIHdpdGggcmVmc3BlY3MiKSk7CisJfQorCWlmICgoZmxhZ3MgJiBUUkFOU1BPUlRfUFVTSF9BTEwpICYmIChmbGFncyAmIFRSQU5TUE9SVF9QVVNIX01JUlJPUikpCisJCWRpZShfKCItLWFsbCBhbmQgLS1taXJyb3IgYXJlIGluY29tcGF0aWJsZSIpKTsKKwogCWZvcl9lYWNoX3N0cmluZ19saXN0X2l0ZW0oaXRlbSwgcHVzaF9vcHRpb25zKQogCQlpZiAoc3RyY2hyKGl0ZW0tPnN0cmluZywgJ1xuJykpCiAJCQlkaWUoXygicHVzaCBvcHRpb25zIG11c3Qgbm90IGhhdmUgbmV3IGxpbmUgY2hhcmFjdGVycyIpKTsKIAotCXJjID0gZG9fcHVzaChyZXBvLCBmbGFncywgcHVzaF9vcHRpb25zKTsKKwlyYyA9IGRvX3B1c2gocmVwbywgZmxhZ3MsIHB1c2hfb3B0aW9ucywgcmVtb3RlKTsKIAlzdHJpbmdfbGlzdF9jbGVhcigmcHVzaF9vcHRpb25zX2NtZGxpbmUsIDApOwogCXN0cmluZ19saXN0X2NsZWFyKCZwdXNoX29wdGlvbnNfY29uZmlnLCAwKTsKIAlpZiAocmMgPT0gLTEpCmRpZmYgLS1naXQgYS9idWlsdGluL3JhbmdlLWRpZmYuYyBiL2J1aWx0aW4vcmFuZ2UtZGlmZi5jCmluZGV4IDkyMDJlNzUuLjk4YWNmMzUgMTAwNjQ0Ci0tLSBhL2J1aWx0aW4vcmFuZ2UtZGlmZi5jCisrKyBiL2J1aWx0aW4vcmFuZ2UtZGlmZi5jCkBAIC0xNSwxMiArMTUsMTYgQEAKIHsKIAlpbnQgY3JlYXRpb25fZmFjdG9yID0gUkFOR0VfRElGRl9DUkVBVElPTl9GQUNUT1JfREVGQVVMVDsKIAlzdHJ1Y3QgZGlmZl9vcHRpb25zIGRpZmZvcHQgPSB7IE5VTEwgfTsKKwlzdHJ1Y3QgYXJndl9hcnJheSBvdGhlcl9hcmcgPSBBUkdWX0FSUkFZX0lOSVQ7CiAJaW50IHNpbXBsZV9jb2xvciA9IC0xOwogCXN0cnVjdCBvcHRpb24gcmFuZ2VfZGlmZl9vcHRpb25zW10gPSB7CiAJCU9QVF9JTlRFR0VSKDAsICJjcmVhdGlvbi1mYWN0b3IiLCAmY3JlYXRpb25fZmFjdG9yLAogCQkJICAgIE5fKCJQZXJjZW50YWdlIGJ5IHdoaWNoIGNyZWF0aW9uIGlzIHdlaWdodGVkIikpLAogCQlPUFRfQk9PTCgwLCAibm8tZHVhbC1jb2xvciIsICZzaW1wbGVfY29sb3IsCiAJCQkgICAgTl8oInVzZSBzaW1wbGUgZGlmZiBjb2xvcnMiKSksCisJCU9QVF9QQVNTVEhSVV9BUkdWKDAsICJub3RlcyIsICZvdGhlcl9hcmcsCisJCQkJICBOXygibm90ZXMiKSwgTl8oInBhc3NlZCB0byAnZ2l0IGxvZyciKSwKKwkJCQkgIFBBUlNFX09QVF9PUFRBUkcpLAogCQlPUFRfRU5EKCkKIAl9OwogCXN0cnVjdCBvcHRpb24gKm9wdGlvbnM7CkBAIC03OCw3ICs4Miw3IEBACiAJRlJFRV9BTkRfTlVMTChvcHRpb25zKTsKIAogCXJlcyA9IHNob3dfcmFuZ2VfZGlmZihyYW5nZTEuYnVmLCByYW5nZTIuYnVmLCBjcmVhdGlvbl9mYWN0b3IsCi0JCQkgICAgICBzaW1wbGVfY29sb3IgPCAxLCAmZGlmZm9wdCk7CisJCQkgICAgICBzaW1wbGVfY29sb3IgPCAxLCAmZGlmZm9wdCwgJm90aGVyX2FyZyk7CiAKIAlzdHJidWZfcmVsZWFzZSgmcmFuZ2UxKTsKIAlzdHJidWZfcmVsZWFzZSgmcmFuZ2UyKTsKZGlmZiAtLWdpdCBhL2J1aWx0aW4vcmViYXNlLmMgYi9idWlsdGluL3JlYmFzZS5jCmluZGV4IDY3MDA5NmMuLmU3NTUwODcgMTAwNjQ0Ci0tLSBhL2J1aWx0aW4vcmViYXNlLmMKKysrIGIvYnVpbHRpbi9yZWJhc2UuYwpAQCAtMjksOCArMjksOCBAQAogI2luY2x1ZGUgInJlYmFzZS1pbnRlcmFjdGl2ZS5oIgogCiBzdGF0aWMgY2hhciBjb25zdCAqIGNvbnN0IGJ1aWx0aW5fcmViYXNlX3VzYWdlW10gPSB7Ci0JTl8oImdpdCByZWJhc2UgWy1pXSBbb3B0aW9uc10gWy0tZXhlYyA8Y21kPl0gWy0tb250byA8bmV3YmFzZT5dICIKLQkJIls8dXBzdHJlYW0+XSBbPGJyYW5jaD5dIiksCisJTl8oImdpdCByZWJhc2UgWy1pXSBbb3B0aW9uc10gWy0tZXhlYyA8Y21kPl0gIgorCQkiWy0tb250byA8bmV3YmFzZT4gfCAtLWtlZXAtYmFzZV0gWzx1cHN0cmVhbT4gWzxicmFuY2g+XV0iKSwKIAlOXygiZ2l0IHJlYmFzZSBbLWldIFtvcHRpb25zXSBbLS1leGVjIDxjbWQ+XSBbLS1vbnRvIDxuZXdiYXNlPl0gIgogCQkiLS1yb290IFs8YnJhbmNoPl0iKSwKIAlOXygiZ2l0IHJlYmFzZSAtLWNvbnRpbnVlIHwgLS1hYm9ydCB8IC0tc2tpcCB8IC0tZWRpdC10b2RvIiksCkBAIC02Miw3ICs2Miw3IEBACiAJY29uc3QgY2hhciAqb250b19uYW1lOwogCWNvbnN0IGNoYXIgKnJldmlzaW9uczsKIAljb25zdCBjaGFyICpzd2l0Y2hfdG87Ci0JaW50IHJvb3Q7CisJaW50IHJvb3QsIHJvb3Rfd2l0aF9vbnRvOwogCXN0cnVjdCBvYmplY3RfaWQgKnNxdWFzaF9vbnRvOwogCXN0cnVjdCBjb21taXQgKnJlc3RyaWN0X3JldmlzaW9uOwogCWludCBkb250X2ZpbmlzaF9yZWJhc2U7CkBAIC0zNzQsNiArMzc0LDcgQEAKIAlmbGFncyB8PSBhYmJyZXZpYXRlX2NvbW1hbmRzID8gVE9ET19MSVNUX0FCQlJFVklBVEVfQ01EUyA6IDA7CiAJZmxhZ3MgfD0gb3B0cy0+cmViYXNlX21lcmdlcyA/IFRPRE9fTElTVF9SRUJBU0VfTUVSR0VTIDogMDsKIAlmbGFncyB8PSBvcHRzLT5yZWJhc2VfY291c2lucyA+IDAgPyBUT0RPX0xJU1RfUkVCQVNFX0NPVVNJTlMgOiAwOworCWZsYWdzIHw9IG9wdHMtPnJvb3Rfd2l0aF9vbnRvID8gVE9ET19MSVNUX1JPT1RfV0lUSF9PTlRPIDogMDsKIAlmbGFncyB8PSBjb21tYW5kID09IEFDVElPTl9TSE9SVEVOX09JRFMgPyBUT0RPX0xJU1RfU0hPUlRFTl9JRFMgOiAwOwogCiAJc3dpdGNoIChjb21tYW5kKSB7CkBAIC0xMjYwLDI0ICsxMjYxLDQ0IEBACiAJcmV0dXJuIDE7CiB9CiAKLXN0YXRpYyBpbnQgY2FuX2Zhc3RfZm9yd2FyZChzdHJ1Y3QgY29tbWl0ICpvbnRvLCBzdHJ1Y3Qgb2JqZWN0X2lkICpoZWFkX29pZCwKLQkJCSAgICBzdHJ1Y3Qgb2JqZWN0X2lkICptZXJnZV9iYXNlKQorc3RhdGljIGludCBjYW5fZmFzdF9mb3J3YXJkKHN0cnVjdCBjb21taXQgKm9udG8sIHN0cnVjdCBjb21taXQgKnVwc3RyZWFtLAorCQkJICAgIHN0cnVjdCBjb21taXQgKnJlc3RyaWN0X3JldmlzaW9uLAorCQkJICAgIHN0cnVjdCBvYmplY3RfaWQgKmhlYWRfb2lkLCBzdHJ1Y3Qgb2JqZWN0X2lkICptZXJnZV9iYXNlKQogewogCXN0cnVjdCBjb21taXQgKmhlYWQgPSBsb29rdXBfY29tbWl0KHRoZV9yZXBvc2l0b3J5LCBoZWFkX29pZCk7Ci0Jc3RydWN0IGNvbW1pdF9saXN0ICptZXJnZV9iYXNlczsKLQlpbnQgcmVzOworCXN0cnVjdCBjb21taXRfbGlzdCAqbWVyZ2VfYmFzZXMgPSBOVUxMOworCWludCByZXMgPSAwOwogCiAJaWYgKCFoZWFkKQotCQlyZXR1cm4gMDsKKwkJZ290byBkb25lOwogCiAJbWVyZ2VfYmFzZXMgPSBnZXRfbWVyZ2VfYmFzZXMob250bywgaGVhZCk7Ci0JaWYgKG1lcmdlX2Jhc2VzICYmICFtZXJnZV9iYXNlcy0+bmV4dCkgewotCQlvaWRjcHkobWVyZ2VfYmFzZSwgJm1lcmdlX2Jhc2VzLT5pdGVtLT5vYmplY3Qub2lkKTsKLQkJcmVzID0gb2lkZXEobWVyZ2VfYmFzZSwgJm9udG8tPm9iamVjdC5vaWQpOwotCX0gZWxzZSB7CisJaWYgKCFtZXJnZV9iYXNlcyB8fCBtZXJnZV9iYXNlcy0+bmV4dCkgewogCQlvaWRjcHkobWVyZ2VfYmFzZSwgJm51bGxfb2lkKTsKLQkJcmVzID0gMDsKKwkJZ290byBkb25lOwogCX0KKworCW9pZGNweShtZXJnZV9iYXNlLCAmbWVyZ2VfYmFzZXMtPml0ZW0tPm9iamVjdC5vaWQpOworCWlmICghb2lkZXEobWVyZ2VfYmFzZSwgJm9udG8tPm9iamVjdC5vaWQpKQorCQlnb3RvIGRvbmU7CisKKwlpZiAocmVzdHJpY3RfcmV2aXNpb24gJiYgIW9pZGVxKCZyZXN0cmljdF9yZXZpc2lvbi0+b2JqZWN0Lm9pZCwgbWVyZ2VfYmFzZSkpCisJCWdvdG8gZG9uZTsKKworCWlmICghdXBzdHJlYW0pCisJCWdvdG8gZG9uZTsKKworCWZyZWVfY29tbWl0X2xpc3QobWVyZ2VfYmFzZXMpOworCW1lcmdlX2Jhc2VzID0gZ2V0X21lcmdlX2Jhc2VzKHVwc3RyZWFtLCBoZWFkKTsKKwlpZiAoIW1lcmdlX2Jhc2VzIHx8IG1lcmdlX2Jhc2VzLT5uZXh0KQorCQlnb3RvIGRvbmU7CisKKwlpZiAoIW9pZGVxKCZvbnRvLT5vYmplY3Qub2lkLCAmbWVyZ2VfYmFzZXMtPml0ZW0tPm9iamVjdC5vaWQpKQorCQlnb3RvIGRvbmU7CisKKwlyZXMgPSAxOworCitkb25lOgogCWZyZWVfY29tbWl0X2xpc3QobWVyZ2VfYmFzZXMpOwogCXJldHVybiByZXMgJiYgaXNfbGluZWFyX2hpc3Rvcnkob250bywgaGVhZCk7CiB9CkBAIC0xMzc2LDYgKzEzOTcsNyBAQAogCXN0cnVjdCByZWJhc2Vfb3B0aW9ucyBvcHRpb25zID0gUkVCQVNFX09QVElPTlNfSU5JVDsKIAljb25zdCBjaGFyICpicmFuY2hfbmFtZTsKIAlpbnQgcmV0LCBmbGFncywgdG90YWxfYXJnYywgaW5fcHJvZ3Jlc3MgPSAwOworCWludCBrZWVwX2Jhc2UgPSAwOwogCWludCBva190b19za2lwX3ByZV9yZWJhc2UgPSAwOwogCXN0cnVjdCBzdHJidWYgbXNnID0gU1RSQlVGX0lOSVQ7CiAJc3RydWN0IHN0cmJ1ZiByZXZpc2lvbnMgPSBTVFJCVUZfSU5JVDsKQEAgLTEzOTQsNiArMTQxNiw4IEBACiAJCU9QVF9TVFJJTkcoMCwgIm9udG8iLCAmb3B0aW9ucy5vbnRvX25hbWUsCiAJCQkgICBOXygicmV2aXNpb24iKSwKIAkJCSAgIE5fKCJyZWJhc2Ugb250byBnaXZlbiBicmFuY2ggaW5zdGVhZCBvZiB1cHN0cmVhbSIpKSwKKwkJT1BUX0JPT0woMCwgImtlZXAtYmFzZSIsICZrZWVwX2Jhc2UsCisJCQkgTl8oInVzZSB0aGUgbWVyZ2UtYmFzZSBvZiB1cHN0cmVhbSBhbmQgYnJhbmNoIGFzIHRoZSBjdXJyZW50IGJhc2UiKSksCiAJCU9QVF9CT09MKDAsICJuby12ZXJpZnkiLCAmb2tfdG9fc2tpcF9wcmVfcmViYXNlLAogCQkJIE5fKCJhbGxvdyBwcmUtcmViYXNlIGhvb2sgdG8gcnVuIikpLAogCQlPUFRfTkVHQklUKCdxJywgInF1aWV0IiwgJm9wdGlvbnMuZmxhZ3MsCkBAIC0xNDQ3LDkgKzE0NzEsMTAgQEAKIAkJCU5fKCJsZXQgdGhlIHVzZXIgZWRpdCB0aGUgbGlzdCBvZiBjb21taXRzIHRvIHJlYmFzZSIpLAogCQkJUEFSU0VfT1BUX05PQVJHIHwgUEFSU0VfT1BUX05PTkVHLAogCQkJcGFyc2Vfb3B0X2ludGVyYWN0aXZlIH0sCi0JCU9QVF9TRVRfSU5UKCdwJywgInByZXNlcnZlLW1lcmdlcyIsICZvcHRpb25zLnR5cGUsCi0JCQkgICAgTl8oIihERVBSRUNBVEVEKSB0cnkgdG8gcmVjcmVhdGUgbWVyZ2VzIGluc3RlYWQgb2YgIgotCQkJICAgICAgICJpZ25vcmluZyB0aGVtIiksIFJFQkFTRV9QUkVTRVJWRV9NRVJHRVMpLAorCQlPUFRfU0VUX0lOVF9GKCdwJywgInByZXNlcnZlLW1lcmdlcyIsICZvcHRpb25zLnR5cGUsCisJCQkgICAgICBOXygiKERFUFJFQ0FURUQpIHRyeSB0byByZWNyZWF0ZSBtZXJnZXMgaW5zdGVhZCBvZiAiCisJCQkJICJpZ25vcmluZyB0aGVtIiksCisJCQkgICAgICBSRUJBU0VfUFJFU0VSVkVfTUVSR0VTLCBQQVJTRV9PUFRfSElEREVOKSwKIAkJT1BUX1JFUkVSRV9BVVRPVVBEQVRFKCZvcHRpb25zLmFsbG93X3JlcmVyZV9hdXRvdXBkYXRlKSwKIAkJT1BUX0JPT0woJ2snLCAia2VlcC1lbXB0eSIsICZvcHRpb25zLmtlZXBfZW1wdHksCiAJCQkgTl8oInByZXNlcnZlIGVtcHR5IGNvbW1pdHMgZHVyaW5nIHJlYmFzZSIpKSwKQEAgLTE1NDcsNiArMTU3MiwxMyBAQAogCQl3YXJuaW5nKF8oImdpdCByZWJhc2UgLS1wcmVzZXJ2ZS1tZXJnZXMgaXMgZGVwcmVjYXRlZC4gIgogCQkJICAiVXNlIC0tcmViYXNlLW1lcmdlcyBpbnN0ZWFkLiIpKTsKIAorCWlmIChrZWVwX2Jhc2UpIHsKKwkJaWYgKG9wdGlvbnMub250b19uYW1lKQorCQkJZGllKF8oImNhbm5vdCBjb21iaW5lICctLWtlZXAtYmFzZScgd2l0aCAnLS1vbnRvJyIpKTsKKwkJaWYgKG9wdGlvbnMucm9vdCkKKwkJCWRpZShfKCJjYW5ub3QgY29tYmluZSAnLS1rZWVwLWJhc2UnIHdpdGggJy0tcm9vdCciKSk7CisJfQorCiAJaWYgKGFjdGlvbiAhPSBBQ1RJT05fTk9ORSAmJiAhaW5fcHJvZ3Jlc3MpCiAJCWRpZShfKCJObyByZWJhc2UgaW4gcHJvZ3Jlc3M/IikpOwogCXNldGVudihHSVRfUkVGTE9HX0FDVElPTl9FTlZJUk9OTUVOVCwgInJlYmFzZSIsIDApOwpAQCAtMTgzMywxNSArMTg2NSw2IEBACiAJCQkgICAgICAiJy0tcmVzY2hlZHVsZS1mYWlsZWQtZXhlYyciKSk7CiAJfQogCi0JaWYgKG9wdGlvbnMucmViYXNlX21lcmdlcykgewotCQlpZiAoc3RyYXRlZ3lfb3B0aW9ucy5ucikKLQkJCWRpZShfKCJjYW5ub3QgY29tYmluZSAnLS1yZWJhc2UtbWVyZ2VzJyB3aXRoICIKLQkJCSAgICAgICInLS1zdHJhdGVneS1vcHRpb24nIikpOwotCQlpZiAob3B0aW9ucy5zdHJhdGVneSkKLQkJCWRpZShfKCJjYW5ub3QgY29tYmluZSAnLS1yZWJhc2UtbWVyZ2VzJyB3aXRoICIKLQkJCSAgICAgICInLS1zdHJhdGVneSciKSk7Ci0JfQotCiAJaWYgKCFvcHRpb25zLnJvb3QpIHsKIAkJaWYgKGFyZ2MgPCAxKSB7CiAJCQlzdHJ1Y3QgYnJhbmNoICpicmFuY2g7CkBAIC0xODcyLDcgKzE4OTUsOSBAQAogCQkJb3B0aW9ucy5zcXVhc2hfb250byA9ICZzcXVhc2hfb250bzsKIAkJCW9wdGlvbnMub250b19uYW1lID0gc3F1YXNoX29udG9fbmFtZSA9CiAJCQkJeHN0cmR1cChvaWRfdG9faGV4KCZzcXVhc2hfb250bykpOwotCQl9CisJCX0gZWxzZQorCQkJb3B0aW9ucy5yb290X3dpdGhfb250byA9IDE7CisKIAkJb3B0aW9ucy51cHN0cmVhbV9uYW1lID0gTlVMTDsKIAkJb3B0aW9ucy51cHN0cmVhbSA9IE5VTEw7CiAJCWlmIChhcmdjID4gMSkKQEAgLTE4ODIsMTIgKzE5MDcsMjIgQEAKIAl9CiAKIAkvKiBNYWtlIHN1cmUgdGhlIGJyYW5jaCB0byByZWJhc2Ugb250byBpcyB2YWxpZC4gKi8KLQlpZiAoIW9wdGlvbnMub250b19uYW1lKQorCWlmIChrZWVwX2Jhc2UpIHsKKwkJc3RyYnVmX3Jlc2V0KCZidWYpOworCQlzdHJidWZfYWRkc3RyKCZidWYsIG9wdGlvbnMudXBzdHJlYW1fbmFtZSk7CisJCXN0cmJ1Zl9hZGRzdHIoJmJ1ZiwgIi4uLiIpOworCQlvcHRpb25zLm9udG9fbmFtZSA9IHhzdHJkdXAoYnVmLmJ1Zik7CisJfSBlbHNlIGlmICghb3B0aW9ucy5vbnRvX25hbWUpCiAJCW9wdGlvbnMub250b19uYW1lID0gb3B0aW9ucy51cHN0cmVhbV9uYW1lOwogCWlmIChzdHJzdHIob3B0aW9ucy5vbnRvX25hbWUsICIuLi4iKSkgewotCQlpZiAoZ2V0X29pZF9tYihvcHRpb25zLm9udG9fbmFtZSwgJm1lcmdlX2Jhc2UpIDwgMCkKLQkJCWRpZShfKCInJXMnOiBuZWVkIGV4YWN0bHkgb25lIG1lcmdlIGJhc2UiKSwKLQkJCSAgICBvcHRpb25zLm9udG9fbmFtZSk7CisJCWlmIChnZXRfb2lkX21iKG9wdGlvbnMub250b19uYW1lLCAmbWVyZ2VfYmFzZSkgPCAwKSB7CisJCQlpZiAoa2VlcF9iYXNlKQorCQkJCWRpZShfKCInJXMnOiBuZWVkIGV4YWN0bHkgb25lIG1lcmdlIGJhc2Ugd2l0aCBicmFuY2giKSwKKwkJCQkgICAgb3B0aW9ucy51cHN0cmVhbV9uYW1lKTsKKwkJCWVsc2UKKwkJCQlkaWUoXygiJyVzJzogbmVlZCBleGFjdGx5IG9uZSBtZXJnZSBiYXNlIiksCisJCQkJICAgIG9wdGlvbnMub250b19uYW1lKTsKKwkJfQogCQlvcHRpb25zLm9udG8gPSBsb29rdXBfY29tbWl0X29yX2RpZSgmbWVyZ2VfYmFzZSwKIAkJCQkJCSAgICBvcHRpb25zLm9udG9fbmFtZSk7CiAJfSBlbHNlIHsKQEAgLTE5NjgsOSArMjAwMyw2IEBACiAJCQkJc3RhdGVfZGlyX3BhdGgoImF1dG9zdGFzaCIsICZvcHRpb25zKTsKIAkJCXN0cnVjdCBjaGlsZF9wcm9jZXNzIHN0YXNoID0gQ0hJTERfUFJPQ0VTU19JTklUOwogCQkJc3RydWN0IG9iamVjdF9pZCBvaWQ7Ci0JCQlzdHJ1Y3QgY29tbWl0ICpoZWFkID0KLQkJCQlsb29rdXBfY29tbWl0X3JlZmVyZW5jZSh0aGVfcmVwb3NpdG9yeSwKLQkJCQkJCQkmb3B0aW9ucy5vcmlnX2hlYWQpOwogCiAJCQlhcmd2X2FycmF5X3B1c2hsKCZzdGFzaC5hcmdzLAogCQkJCQkgInN0YXNoIiwgImNyZWF0ZSIsICJhdXRvc3Rhc2giLCBOVUxMKTsKQEAgLTE5OTEsMTcgKzIwMjMsOSBAQAogCQkJCSAgICBvcHRpb25zLnN0YXRlX2Rpcik7CiAJCQl3cml0ZV9maWxlKGF1dG9zdGFzaCwgIiVzIiwgb2lkX3RvX2hleCgmb2lkKSk7CiAJCQlwcmludGYoXygiQ3JlYXRlZCBhdXRvc3Rhc2g6ICVzXG4iKSwgYnVmLmJ1Zik7Ci0JCQlpZiAocmVzZXRfaGVhZCgmaGVhZC0+b2JqZWN0Lm9pZCwgInJlc2V0IC0taGFyZCIsCisJCQlpZiAocmVzZXRfaGVhZChOVUxMLCAicmVzZXQgLS1oYXJkIiwKIAkJCQkgICAgICAgTlVMTCwgUkVTRVRfSEVBRF9IQVJELCBOVUxMLCBOVUxMKSA8IDApCiAJCQkJZGllKF8oImNvdWxkIG5vdCByZXNldCAtLWhhcmQiKSk7Ci0JCQlwcmludGYoXygiSEVBRCBpcyBub3cgYXQgJXMiKSwKLQkJCSAgICAgICBmaW5kX3VuaXF1ZV9hYmJyZXYoJmhlYWQtPm9iamVjdC5vaWQsCi0JCQkJCQkgIERFRkFVTFRfQUJCUkVWKSk7Ci0JCQlzdHJidWZfcmVzZXQoJmJ1Zik7Ci0JCQlwcF9jb21taXRfZWFzeShDTUlUX0ZNVF9PTkVMSU5FLCBoZWFkLCAmYnVmKTsKLQkJCWlmIChidWYubGVuID4gMCkKLQkJCQlwcmludGYoIiAlcyIsIGJ1Zi5idWYpOwotCQkJcHV0Y2hhcignXG4nKTsKIAogCQkJaWYgKGRpc2NhcmRfaW5kZXgodGhlX3JlcG9zaXRvcnktPmluZGV4KSA8IDAgfHwKIAkJCQlyZXBvX3JlYWRfaW5kZXgodGhlX3JlcG9zaXRvcnkpIDwgMCkKQEAgLTIwMjIsMTMgKzIwNDYsMTMgQEAKIAogCS8qCiAJICogQ2hlY2sgaWYgd2UgYXJlIGFscmVhZHkgYmFzZWQgb24gb250byB3aXRoIGxpbmVhciBoaXN0b3J5LAotCSAqIGJ1dCB0aGlzIHNob3VsZCBiZSBkb25lIG9ubHkgd2hlbiB1cHN0cmVhbSBhbmQgb250byBhcmUgdGhlIHNhbWUKLQkgKiBhbmQgaWYgdGhpcyBpcyBub3QgYW4gaW50ZXJhY3RpdmUgcmViYXNlLgorCSAqIGluIHdoaWNoIGNhc2Ugd2UgY291bGQgZmFzdC1mb3J3YXJkIHdpdGhvdXQgcmVwbGFjaW5nIHRoZSBjb21taXRzCisJICogd2l0aCBuZXcgY29tbWl0cyByZWNyZWF0ZWQgYnkgcmVwbGF5aW5nIHRoZWlyIGNoYW5nZXMuIFRoaXMKKwkgKiBvcHRpbWl6YXRpb24gbXVzdCBub3QgYmUgZG9uZSBpZiB0aGlzIGlzIGFuIGludGVyYWN0aXZlIHJlYmFzZS4KIAkgKi8KLQlpZiAoY2FuX2Zhc3RfZm9yd2FyZChvcHRpb25zLm9udG8sICZvcHRpb25zLm9yaWdfaGVhZCwgJm1lcmdlX2Jhc2UpICYmCi0JICAgICFpc19pbnRlcmFjdGl2ZSgmb3B0aW9ucykgJiYgIW9wdGlvbnMucmVzdHJpY3RfcmV2aXNpb24gJiYKLQkgICAgb3B0aW9ucy51cHN0cmVhbSAmJgotCSAgICAhb2lkY21wKCZvcHRpb25zLnVwc3RyZWFtLT5vYmplY3Qub2lkLCAmb3B0aW9ucy5vbnRvLT5vYmplY3Qub2lkKSkgeworCWlmIChjYW5fZmFzdF9mb3J3YXJkKG9wdGlvbnMub250bywgb3B0aW9ucy51cHN0cmVhbSwgb3B0aW9ucy5yZXN0cmljdF9yZXZpc2lvbiwKKwkJICAgICZvcHRpb25zLm9yaWdfaGVhZCwgJm1lcmdlX2Jhc2UpICYmCisJICAgICFpc19pbnRlcmFjdGl2ZSgmb3B0aW9ucykpIHsKIAkJaW50IGZsYWc7CiAKIAkJaWYgKCEob3B0aW9ucy5mbGFncyAmIFJFQkFTRV9GT1JDRSkpIHsKZGlmZiAtLWdpdCBhL2J1aWx0aW4vcmVjZWl2ZS1wYWNrLmMgYi9idWlsdGluL3JlY2VpdmUtcGFjay5jCmluZGV4IGRjZjM4NTUuLjQxMWUwYjQgMTAwNjQ0Ci0tLSBhL2J1aWx0aW4vcmVjZWl2ZS1wYWNrLmMKKysrIGIvYnVpbHRpbi9yZWNlaXZlLXBhY2suYwpAQCAtNDE3LDI0ICs0MTcsMjIgQEAKIAlyZXR1cm4gMDsKIH0KIAotI2RlZmluZSBITUFDX0JMT0NLX1NJWkUgNjQKLQotc3RhdGljIHZvaWQgaG1hY19zaGExKHVuc2lnbmVkIGNoYXIgKm91dCwKK3N0YXRpYyB2b2lkIGhtYWModW5zaWduZWQgY2hhciAqb3V0LAogCQkgICAgICBjb25zdCBjaGFyICprZXlfaW4sIHNpemVfdCBrZXlfbGVuLAogCQkgICAgICBjb25zdCBjaGFyICp0ZXh0LCBzaXplX3QgdGV4dF9sZW4pCiB7Ci0JdW5zaWduZWQgY2hhciBrZXlbSE1BQ19CTE9DS19TSVpFXTsKLQl1bnNpZ25lZCBjaGFyIGtfaXBhZFtITUFDX0JMT0NLX1NJWkVdOwotCXVuc2lnbmVkIGNoYXIga19vcGFkW0hNQUNfQkxPQ0tfU0laRV07CisJdW5zaWduZWQgY2hhciBrZXlbR0lUX01BWF9CTEtTWl07CisJdW5zaWduZWQgY2hhciBrX2lwYWRbR0lUX01BWF9CTEtTWl07CisJdW5zaWduZWQgY2hhciBrX29wYWRbR0lUX01BWF9CTEtTWl07CiAJaW50IGk7Ci0JZ2l0X1NIQV9DVFggY3R4OworCWdpdF9oYXNoX2N0eCBjdHg7CiAKIAkvKiBSRkMgMjEwNCAyLiAoMSkgKi8KLQltZW1zZXQoa2V5LCAnXDAnLCBITUFDX0JMT0NLX1NJWkUpOwotCWlmIChITUFDX0JMT0NLX1NJWkUgPCBrZXlfbGVuKSB7Ci0JCWdpdF9TSEExX0luaXQoJmN0eCk7Ci0JCWdpdF9TSEExX1VwZGF0ZSgmY3R4LCBrZXlfaW4sIGtleV9sZW4pOwotCQlnaXRfU0hBMV9GaW5hbChrZXksICZjdHgpOworCW1lbXNldChrZXksICdcMCcsIEdJVF9NQVhfQkxLU1opOworCWlmICh0aGVfaGFzaF9hbGdvLT5ibGtzeiA8IGtleV9sZW4pIHsKKwkJdGhlX2hhc2hfYWxnby0+aW5pdF9mbigmY3R4KTsKKwkJdGhlX2hhc2hfYWxnby0+dXBkYXRlX2ZuKCZjdHgsIGtleV9pbiwga2V5X2xlbik7CisJCXRoZV9oYXNoX2FsZ28tPmZpbmFsX2ZuKGtleSwgJmN0eCk7CiAJfSBlbHNlIHsKIAkJbWVtY3B5KGtleSwga2V5X2luLCBrZXlfbGVuKTsKIAl9CkBAIC00NDYsMjkgKzQ0NCwyOSBAQAogCX0KIAogCS8qIFJGQyAyMTA0IDIuICgzKSAmICg0KSAqLwotCWdpdF9TSEExX0luaXQoJmN0eCk7Ci0JZ2l0X1NIQTFfVXBkYXRlKCZjdHgsIGtfaXBhZCwgc2l6ZW9mKGtfaXBhZCkpOwotCWdpdF9TSEExX1VwZGF0ZSgmY3R4LCB0ZXh0LCB0ZXh0X2xlbik7Ci0JZ2l0X1NIQTFfRmluYWwob3V0LCAmY3R4KTsKKwl0aGVfaGFzaF9hbGdvLT5pbml0X2ZuKCZjdHgpOworCXRoZV9oYXNoX2FsZ28tPnVwZGF0ZV9mbigmY3R4LCBrX2lwYWQsIHNpemVvZihrX2lwYWQpKTsKKwl0aGVfaGFzaF9hbGdvLT51cGRhdGVfZm4oJmN0eCwgdGV4dCwgdGV4dF9sZW4pOworCXRoZV9oYXNoX2FsZ28tPmZpbmFsX2ZuKG91dCwgJmN0eCk7CiAKIAkvKiBSRkMgMjEwNCAyLiAoNikgJiAoNykgKi8KLQlnaXRfU0hBMV9Jbml0KCZjdHgpOwotCWdpdF9TSEExX1VwZGF0ZSgmY3R4LCBrX29wYWQsIHNpemVvZihrX29wYWQpKTsKLQlnaXRfU0hBMV9VcGRhdGUoJmN0eCwgb3V0LCBHSVRfU0hBMV9SQVdTWik7Ci0JZ2l0X1NIQTFfRmluYWwob3V0LCAmY3R4KTsKKwl0aGVfaGFzaF9hbGdvLT5pbml0X2ZuKCZjdHgpOworCXRoZV9oYXNoX2FsZ28tPnVwZGF0ZV9mbigmY3R4LCBrX29wYWQsIHNpemVvZihrX29wYWQpKTsKKwl0aGVfaGFzaF9hbGdvLT51cGRhdGVfZm4oJmN0eCwgb3V0LCB0aGVfaGFzaF9hbGdvLT5yYXdzeik7CisJdGhlX2hhc2hfYWxnby0+ZmluYWxfZm4ob3V0LCAmY3R4KTsKIH0KIAogc3RhdGljIGNoYXIgKnByZXBhcmVfcHVzaF9jZXJ0X25vbmNlKGNvbnN0IGNoYXIgKnBhdGgsIHRpbWVzdGFtcF90IHN0YW1wKQogewogCXN0cnVjdCBzdHJidWYgYnVmID0gU1RSQlVGX0lOSVQ7Ci0JdW5zaWduZWQgY2hhciBzaGExW0dJVF9TSEExX1JBV1NaXTsKKwl1bnNpZ25lZCBjaGFyIGhhc2hbR0lUX01BWF9SQVdTWl07CiAKIAlzdHJidWZfYWRkZigmYnVmLCAiJXM6JSJQUkl0aW1lLCBwYXRoLCBzdGFtcCk7Ci0JaG1hY19zaGExKHNoYTEsIGJ1Zi5idWYsIGJ1Zi5sZW4sIGNlcnRfbm9uY2Vfc2VlZCwgc3RybGVuKGNlcnRfbm9uY2Vfc2VlZCkpOworCWhtYWMoaGFzaCwgYnVmLmJ1ZiwgYnVmLmxlbiwgY2VydF9ub25jZV9zZWVkLCBzdHJsZW4oY2VydF9ub25jZV9zZWVkKSk7CiAJc3RyYnVmX3JlbGVhc2UoJmJ1Zik7CiAKIAkvKiBSRkMgMjEwNCA1LiBITUFDLVNIQTEtODAgKi8KLQlzdHJidWZfYWRkZigmYnVmLCAiJSJQUkl0aW1lIi0lLipzIiwgc3RhbXAsIEdJVF9TSEExX0hFWFNaLCBzaGExX3RvX2hleChzaGExKSk7CisJc3RyYnVmX2FkZGYoJmJ1ZiwgIiUiUFJJdGltZSItJS4qcyIsIHN0YW1wLCAoaW50KXRoZV9oYXNoX2FsZ28tPmhleHN6LCBoYXNoX3RvX2hleChoYXNoKSk7CiAJcmV0dXJuIHN0cmJ1Zl9kZXRhY2goJmJ1ZiwgTlVMTCk7CiB9CiAKQEAgLTk3MCw3ICs5NjgsNyBAQAogCWlmIChydW5fY29tbWFuZCgmY2hpbGQpKQogCQlyZXR1cm4gIldvcmtpbmcgZGlyZWN0b3J5IGhhcyBzdGFnZWQgY2hhbmdlcyI7CiAKLQlyZWFkX3RyZWVbM10gPSBzaGExX3RvX2hleChzaGExKTsKKwlyZWFkX3RyZWVbM10gPSBoYXNoX3RvX2hleChzaGExKTsKIAljaGlsZF9wcm9jZXNzX2luaXQoJmNoaWxkKTsKIAljaGlsZC5hcmd2ID0gcmVhZF90cmVlOwogCWNoaWxkLmVudiA9IGVudi0+YXJndjsKQEAgLTk4NywxMyArOTg1LDEzIEBACiAKIHN0YXRpYyBjb25zdCBjaGFyICpwdXNoX3RvX2NoZWNrb3V0X2hvb2sgPSAicHVzaC10by1jaGVja291dCI7CiAKLXN0YXRpYyBjb25zdCBjaGFyICpwdXNoX3RvX2NoZWNrb3V0KHVuc2lnbmVkIGNoYXIgKnNoYTEsCitzdGF0aWMgY29uc3QgY2hhciAqcHVzaF90b19jaGVja291dCh1bnNpZ25lZCBjaGFyICpoYXNoLAogCQkJCSAgICBzdHJ1Y3QgYXJndl9hcnJheSAqZW52LAogCQkJCSAgICBjb25zdCBjaGFyICp3b3JrX3RyZWUpCiB7CiAJYXJndl9hcnJheV9wdXNoZihlbnYsICJHSVRfV09SS19UUkVFPSVzIiwgYWJzb2x1dGVfcGF0aCh3b3JrX3RyZWUpKTsKIAlpZiAocnVuX2hvb2tfbGUoZW52LT5hcmd2LCBwdXNoX3RvX2NoZWNrb3V0X2hvb2ssCi0JCQlzaGExX3RvX2hleChzaGExKSwgTlVMTCkpCisJCQloYXNoX3RvX2hleChoYXNoKSwgTlVMTCkpCiAJCXJldHVybiAicHVzaC10by1jaGVja291dCBob29rIGRlY2xpbmVkIjsKIAllbHNlCiAJCXJldHVybiBOVUxMOwpkaWZmIC0tZ2l0IGEvYnVpbHRpbi9yZXBhY2suYyBiL2J1aWx0aW4vcmVwYWNrLmMKaW5kZXggNjMyYzBjMC4uMDc4MTc2MyAxMDA2NDQKLS0tIGEvYnVpbHRpbi9yZXBhY2suYworKysgYi9idWlsdGluL3JlcGFjay5jCkBAIC0xMSw2ICsxMSw3IEBACiAjaW5jbHVkZSAibWlkeC5oIgogI2luY2x1ZGUgInBhY2tmaWxlLmgiCiAjaW5jbHVkZSAib2JqZWN0LXN0b3JlLmgiCisjaW5jbHVkZSAicHJvbWlzb3ItcmVtb3RlLmgiCiAKIHN0YXRpYyBpbnQgZGVsdGFfYmFzZV9vZmZzZXQgPSAxOwogc3RhdGljIGludCBwYWNrX2tlcHRfb2JqZWN0cyA9IC0xOwpAQCAtMTkwLDcgKzE5MSw3IEBACiAJCQlkaWUoXygiY291bGQgbm90IHN0YXJ0IHBhY2stb2JqZWN0cyB0byByZXBhY2sgcHJvbWlzb3Igb2JqZWN0cyIpKTsKIAl9CiAKLQl4d3JpdGUoY21kLT5pbiwgb2lkX3RvX2hleChvaWQpLCBHSVRfU0hBMV9IRVhTWik7CisJeHdyaXRlKGNtZC0+aW4sIG9pZF90b19oZXgob2lkKSwgdGhlX2hhc2hfYWxnby0+aGV4c3opOwogCXh3cml0ZShjbWQtPmluLCAiXG4iLCAxKTsKIAlyZXR1cm4gMDsKIH0KQEAgLTIzMiw2ICsyMzMsMTMgQEAKIAkJLyoKIAkJICogcGFjay1vYmplY3RzIGNyZWF0ZXMgdGhlIC5wYWNrIGFuZCAuaWR4IGZpbGVzLCBidXQgbm90IHRoZQogCQkgKiAucHJvbWlzb3IgZmlsZS4gQ3JlYXRlIHRoZSAucHJvbWlzb3IgZmlsZSwgd2hpY2ggaXMgZW1wdHkuCisJCSAqCisJCSAqIE5FRURTV09SSzogZmV0Y2gtcGFjayBzb21ldGltZXMgZ2VuZXJhdGVzIG5vbi1lbXB0eQorCQkgKiAucHJvbWlzb3IgZmlsZXMgY29udGFpbmluZyB0aGUgcmVmIG5hbWVzIGFuZCBhc3NvY2lhdGVkCisJCSAqIGhhc2hlcyBhdCB0aGUgcG9pbnQgb2YgZ2VuZXJhdGlvbiBvZiB0aGUgY29ycmVzcG9uZGluZworCQkgKiBwYWNrZmlsZSwgYnV0IHRoaXMgd291bGQgbm90IHByZXNlcnZlIHRoZWlyIGNvbnRlbnRzLiBNYXliZQorCQkgKiBjb25jYXRlbmF0ZSB0aGUgY29udGVudHMgb2YgYWxsIC5wcm9taXNvciBmaWxlcyBpbnN0ZWFkIG9mCisJCSAqIGp1c3QgY3JlYXRpbmcgYSBuZXcgZW1wdHkgZmlsZS4KIAkJICovCiAJCXByb21pc29yX25hbWUgPSBta3BhdGhkdXAoIiVzLSVzLnByb21pc29yIiwgcGFja3RtcCwKIAkJCQkJICBsaW5lLmJ1Zik7CkBAIC0zNjEsNyArMzY5LDcgQEAKIAlhcmd2X2FycmF5X3B1c2goJmNtZC5hcmdzLCAiLS1hbGwiKTsKIAlhcmd2X2FycmF5X3B1c2goJmNtZC5hcmdzLCAiLS1yZWZsb2ciKTsKIAlhcmd2X2FycmF5X3B1c2goJmNtZC5hcmdzLCAiLS1pbmRleGVkLW9iamVjdHMiKTsKLQlpZiAocmVwb3NpdG9yeV9mb3JtYXRfcGFydGlhbF9jbG9uZSkKKwlpZiAoaGFzX3Byb21pc29yX3JlbW90ZSgpKQogCQlhcmd2X2FycmF5X3B1c2goJmNtZC5hcmdzLCAiLS1leGNsdWRlLXByb21pc29yLW9iamVjdHMiKTsKIAlpZiAod3JpdGVfYml0bWFwcyA+IDApCiAJCWFyZ3ZfYXJyYXlfcHVzaCgmY21kLmFyZ3MsICItLXdyaXRlLWJpdG1hcC1pbmRleCIpOwpAQCAtNTYxLDcgKzU2OSw3IEBACiAJcmVtb3ZlX3RlbXBvcmFyeV9maWxlcygpOwogCiAJaWYgKGdpdF9lbnZfYm9vbChHSVRfVEVTVF9NVUxUSV9QQUNLX0lOREVYLCAwKSkKLQkJd3JpdGVfbWlkeF9maWxlKGdldF9vYmplY3RfZGlyZWN0b3J5KCkpOworCQl3cml0ZV9taWR4X2ZpbGUoZ2V0X29iamVjdF9kaXJlY3RvcnkoKSwgMCk7CiAKIAlzdHJpbmdfbGlzdF9jbGVhcigmbmFtZXMsIDApOwogCXN0cmluZ19saXN0X2NsZWFyKCZyb2xsYmFjaywgMCk7CmRpZmYgLS1naXQgYS9idWlsdGluL3JlcGxhY2UuYyBiL2J1aWx0aW4vcmVwbGFjZS5jCmluZGV4IDY0NGIyMWMuLmJkOTJkYzYgMTAwNjQ0Ci0tLSBhL2J1aWx0aW4vcmVwbGFjZS5jCisrKyBiL2J1aWx0aW4vcmVwbGFjZS5jCkBAIC0yNzIsNyArMjcyLDcgQEAKIAkJCXJldHVybiBlcnJvcihfKCJ1bmFibGUgdG8gc3Bhd24gbWt0cmVlIikpOwogCQl9CiAKLQkJaWYgKHN0cmJ1Zl9yZWFkKCZyZXN1bHQsIGNtZC5vdXQsIDQxKSA8IDApIHsKKwkJaWYgKHN0cmJ1Zl9yZWFkKCZyZXN1bHQsIGNtZC5vdXQsIHRoZV9oYXNoX2FsZ28tPmhleHN6ICsgMSkgPCAwKSB7CiAJCQllcnJvcl9lcnJubyhfKCJ1bmFibGUgdG8gcmVhZCBmcm9tIG1rdHJlZSIpKTsKIAkJCWNsb3NlKGZkKTsKIAkJCWNsb3NlKGNtZC5vdXQpOwpAQCAtMzU4LDE0ICszNTgsMTUgQEAKIAlzdHJ1Y3Qgc3RyYnVmIG5ld19wYXJlbnRzID0gU1RSQlVGX0lOSVQ7CiAJY29uc3QgY2hhciAqcGFyZW50X3N0YXJ0LCAqcGFyZW50X2VuZDsKIAlpbnQgaTsKKwljb25zdCB1bnNpZ25lZCBoZXhzeiA9IHRoZV9oYXNoX2FsZ28tPmhleHN6OwogCiAJLyogZmluZCBleGlzdGluZyBwYXJlbnRzICovCiAJcGFyZW50X3N0YXJ0ID0gYnVmLT5idWY7Ci0JcGFyZW50X3N0YXJ0ICs9IEdJVF9TSEExX0hFWFNaICsgNjsgLyogInRyZWUgIiArICJoZXggc2hhMSIgKyAiXG4iICovCisJcGFyZW50X3N0YXJ0ICs9IGhleHN6ICsgNjsgLyogInRyZWUgIiArICJoZXggc2hhMSIgKyAiXG4iICovCiAJcGFyZW50X2VuZCA9IHBhcmVudF9zdGFydDsKIAogCXdoaWxlIChzdGFydHNfd2l0aChwYXJlbnRfZW5kLCAicGFyZW50ICIpKQotCQlwYXJlbnRfZW5kICs9IDQ4OyAvKiAicGFyZW50ICIgKyAiaGV4IHNoYTEiICsgIlxuIiAqLworCQlwYXJlbnRfZW5kICs9IGhleHN6ICsgODsgLyogInBhcmVudCAiICsgImhleCBzaGExIiArICJcbiIgKi8KIAogCS8qIHByZXBhcmUgbmV3IHBhcmVudHMgKi8KIAlmb3IgKGkgPSAwOyBpIDwgYXJnYzsgaSsrKSB7CkBAIC00MjEsNyArNDIyLDcgQEAKIAkJaWYgKGdldF9vaWQobWVyZ2V0YWdfZGF0YS0+YXJndltpXSwgJm9pZCkgPCAwKQogCQkJcmV0dXJuIGVycm9yKF8oIm5vdCBhIHZhbGlkIG9iamVjdCBuYW1lOiAnJXMnIiksCiAJCQkJICAgICBtZXJnZXRhZ19kYXRhLT5hcmd2W2ldKTsKLQkJaWYgKG9pZGVxKCZ0YWctPnRhZ2dlZC0+b2lkLCAmb2lkKSkKKwkJaWYgKG9pZGVxKGdldF90YWdnZWRfb2lkKHRhZyksICZvaWQpKQogCQkJcmV0dXJuIDA7IC8qIGZvdW5kICovCiAJfQogCmRpZmYgLS1naXQgYS9idWlsdGluL3Jlc2V0LmMgYi9idWlsdGluL3Jlc2V0LmMKaW5kZXggZmRkNTcyMS4uNWNiZmIyMSAxMDA2NDQKLS0tIGEvYnVpbHRpbi9yZXNldC5jCisrKyBiL2J1aWx0aW4vcmVzZXQuYwpAQCAtMzIwLDcgKzMyMCw3IEBACiAJaWYgKHVuYm9ybikgewogCQkvKiByZXNldCBvbiB1bmJvcm4gYnJhbmNoOiB0cmVhdCBhcyByZXNldCB0byBlbXB0eSB0cmVlICovCiAJCW9pZGNweSgmb2lkLCB0aGVfaGFzaF9hbGdvLT5lbXB0eV90cmVlKTsKLQl9IGVsc2UgaWYgKCFwYXRoc3BlYy5ucikgeworCX0gZWxzZSBpZiAoIXBhdGhzcGVjLm5yICYmICFwYXRjaF9tb2RlKSB7CiAJCXN0cnVjdCBjb21taXQgKmNvbW1pdDsKIAkJaWYgKGdldF9vaWRfY29tbWl0dGlzaChyZXYsICZvaWQpKQogCQkJZGllKF8oIkZhaWxlZCB0byByZXNvbHZlICclcycgYXMgYSB2YWxpZCByZXZpc2lvbi4iKSwgcmV2KTsKZGlmZiAtLWdpdCBhL2J1aWx0aW4vcmV2LWxpc3QuYyBiL2J1aWx0aW4vcmV2LWxpc3QuYwppbmRleCAzMDFjY2I5Li5lMjhkNjJlIDEwMDY0NAotLS0gYS9idWlsdGluL3Jldi1saXN0LmMKKysrIGIvYnVpbHRpbi9yZXYtbGlzdC5jCkBAIC0xOCw3ICsxOCw2IEBACiAjaW5jbHVkZSAicmVmbG9nLXdhbGsuaCIKICNpbmNsdWRlICJvaWRzZXQuaCIKICNpbmNsdWRlICJwYWNrZmlsZS5oIgotI2luY2x1ZGUgIm9iamVjdC1zdG9yZS5oIgogCiBzdGF0aWMgY29uc3QgY2hhciByZXZfbGlzdF91c2FnZVtdID0KICJnaXQgcmV2LWxpc3QgW09QVElPTl0gPGNvbW1pdC1pZD4uLi4gWyAtLSBwYXRocy4uLiBdXG4iCkBAIC00NzEsMTAgKzQ3MCw2IEBACiAJCQlwYXJzZV9saXN0X29iamVjdHNfZmlsdGVyKCZmaWx0ZXJfb3B0aW9ucywgYXJnKTsKIAkJCWlmIChmaWx0ZXJfb3B0aW9ucy5jaG9pY2UgJiYgIXJldnMuYmxvYl9vYmplY3RzKQogCQkJCWRpZShfKCJvYmplY3QgZmlsdGVyaW5nIHJlcXVpcmVzIC0tb2JqZWN0cyIpKTsKLQkJCWlmIChmaWx0ZXJfb3B0aW9ucy5jaG9pY2UgPT0gTE9GQ19TUEFSU0VfT0lEICYmCi0JCQkgICAgIWZpbHRlcl9vcHRpb25zLnNwYXJzZV9vaWRfdmFsdWUpCi0JCQkJZGllKF8oImludmFsaWQgc3BhcnNlIHZhbHVlICclcyciKSwKLQkJCQkgICAgZmlsdGVyX29wdGlvbnMuZmlsdGVyX3NwZWMpOwogCQkJY29udGludWU7CiAJCX0KIAkJaWYgKCFzdHJjbXAoYXJnLCAoIi0tbm8tIiBDTF9BUkdfX0ZJTFRFUikpKSB7CmRpZmYgLS1naXQgYS9idWlsdGluL3Jldi1wYXJzZS5jIGIvYnVpbHRpbi9yZXYtcGFyc2UuYwppbmRleCBmOGJiZTZkLi43YTAwZGE4IDEwMDY0NAotLS0gYS9idWlsdGluL3Jldi1wYXJzZS5jCisrKyBiL2J1aWx0aW4vcmV2LXBhcnNlLmMKQEAgLTU5Myw2ICs1OTMsNyBAQAogCWNvbnN0IGNoYXIgKm5hbWUgPSBOVUxMOwogCXN0cnVjdCBvYmplY3RfY29udGV4dCB1bnVzZWQ7CiAJc3RydWN0IHN0cmJ1ZiBidWYgPSBTVFJCVUZfSU5JVDsKKwljb25zdCBpbnQgaGV4c3ogPSB0aGVfaGFzaF9hbGdvLT5oZXhzejsKIAogCWlmIChhcmdjID4gMSAmJiAhc3RyY21wKCItLXBhcnNlb3B0IiwgYXJndlsxXSkpCiAJCXJldHVybiBjbWRfcGFyc2VvcHQoYXJnYyAtIDEsIGFyZ3YgKyAxLCBwcmVmaXgpOwpAQCAtNzMwLDggKzczMSw4IEBACiAJCQkJYWJicmV2ID0gc3RydG91bChhcmcsIE5VTEwsIDEwKTsKIAkJCQlpZiAoYWJicmV2IDwgTUlOSU1VTV9BQkJSRVYpCiAJCQkJCWFiYnJldiA9IE1JTklNVU1fQUJCUkVWOwotCQkJCWVsc2UgaWYgKDQwIDw9IGFiYnJldikKLQkJCQkJYWJicmV2ID0gNDA7CisJCQkJZWxzZSBpZiAoaGV4c3ogPD0gYWJicmV2KQorCQkJCQlhYmJyZXYgPSBoZXhzejsKIAkJCQljb250aW51ZTsKIAkJCX0KIAkJCWlmICghc3RyY21wKGFyZywgIi0tc3EiKSkgewpAQCAtODAyLDYgKzgwMyw4IEBACiAJCQkJY29uc3QgY2hhciAqd29ya190cmVlID0gZ2V0X2dpdF93b3JrX3RyZWUoKTsKIAkJCQlpZiAod29ya190cmVlKQogCQkJCQlwdXRzKHdvcmtfdHJlZSk7CisJCQkJZWxzZQorCQkJCQlkaWUoInRoaXMgb3BlcmF0aW9uIG11c3QgYmUgcnVuIGluIGEgd29yayB0cmVlIik7CiAJCQkJY29udGludWU7CiAJCQl9CiAJCQlpZiAoIXN0cmNtcChhcmcsICItLXNob3ctc3VwZXJwcm9qZWN0LXdvcmtpbmctdHJlZSIpKSB7CkBAIC05MTgsNiArOTIxLDE3IEBACiAJCQkJc2hvd19kYXRlc3RyaW5nKCItLW1pbi1hZ2U9IiwgYXJnKTsKIAkJCQljb250aW51ZTsKIAkJCX0KKwkJCWlmIChvcHRfd2l0aF92YWx1ZShhcmcsICItLXNob3ctb2JqZWN0LWZvcm1hdCIsICZhcmcpKSB7CisJCQkJY29uc3QgY2hhciAqdmFsID0gYXJnID8gYXJnIDogInN0b3JhZ2UiOworCisJCQkJaWYgKHN0cmNtcCh2YWwsICJzdG9yYWdlIikgJiYKKwkJCQkgICAgc3RyY21wKHZhbCwgImlucHV0IikgJiYKKwkJCQkgICAgc3RyY21wKHZhbCwgIm91dHB1dCIpKQorCQkJCQlkaWUoInVua25vd24gbW9kZSBmb3IgLS1zaG93LW9iamVjdC1mb3JtYXQ6ICVzIiwKKwkJCQkJICAgIGFyZyk7CisJCQkJcHV0cyh0aGVfaGFzaF9hbGdvLT5uYW1lKTsKKwkJCQljb250aW51ZTsKKwkJCX0KIAkJCWlmIChzaG93X2ZsYWcoYXJnKSAmJiB2ZXJpZnkpCiAJCQkJZGllX25vX3NpbmdsZV9yZXYocXVpZXQpOwogCQkJY29udGludWU7CmRpZmYgLS1naXQgYS9idWlsdGluL3Nob3ctaW5kZXguYyBiL2J1aWx0aW4vc2hvdy1pbmRleC5jCmluZGV4IGE2ZTY3ODguLjA4MjZmNmEgMTAwNjQ0Ci0tLSBhL2J1aWx0aW4vc2hvdy1pbmRleC5jCisrKyBiL2J1aWx0aW4vc2hvdy1pbmRleC5jCkBAIC0xMSw2ICsxMSw3IEBACiAJdW5zaWduZWQgbnI7CiAJdW5zaWduZWQgaW50IHZlcnNpb247CiAJc3RhdGljIHVuc2lnbmVkIGludCB0b3BfaW5kZXhbMjU2XTsKKwljb25zdCB1bnNpZ25lZCBoYXNoc3ogPSB0aGVfaGFzaF9hbGdvLT5yYXdzejsKIAogCWlmIChhcmdjICE9IDEpCiAJCXVzYWdlKHNob3dfaW5kZXhfdXNhZ2UpOwpAQCAtMzYsMjMgKzM3LDIzIEBACiAJfQogCWlmICh2ZXJzaW9uID09IDEpIHsKIAkJZm9yIChpID0gMDsgaSA8IG5yOyBpKyspIHsKLQkJCXVuc2lnbmVkIGludCBvZmZzZXQsIGVudHJ5WzZdOworCQkJdW5zaWduZWQgaW50IG9mZnNldCwgZW50cnlbKEdJVF9NQVhfUkFXU1ogKyA0KSAvIHNpemVvZih1bnNpZ25lZCBpbnQpXTsKIAotCQkJaWYgKGZyZWFkKGVudHJ5LCA0ICsgMjAsIDEsIHN0ZGluKSAhPSAxKQorCQkJaWYgKGZyZWFkKGVudHJ5LCA0ICsgaGFzaHN6LCAxLCBzdGRpbikgIT0gMSkKIAkJCQlkaWUoInVuYWJsZSB0byByZWFkIGVudHJ5ICV1LyV1IiwgaSwgbnIpOwogCQkJb2Zmc2V0ID0gbnRvaGwoZW50cnlbMF0pOwotCQkJcHJpbnRmKCIldSAlc1xuIiwgb2Zmc2V0LCBzaGExX3RvX2hleCgodm9pZCAqKShlbnRyeSsxKSkpOworCQkJcHJpbnRmKCIldSAlc1xuIiwgb2Zmc2V0LCBoYXNoX3RvX2hleCgodm9pZCAqKShlbnRyeSsxKSkpOwogCQl9CiAJfSBlbHNlIHsKIAkJdW5zaWduZWQgb2ZmNjRfbnIgPSAwOwogCQlzdHJ1Y3QgewotCQkJdW5zaWduZWQgY2hhciBzaGExWzIwXTsKKwkJCXN0cnVjdCBvYmplY3RfaWQgb2lkOwogCQkJdWludDMyX3QgY3JjOwogCQkJdWludDMyX3Qgb2ZmOwogCQl9ICplbnRyaWVzOwogCQlBTExPQ19BUlJBWShlbnRyaWVzLCBucik7CiAJCWZvciAoaSA9IDA7IGkgPCBucjsgaSsrKQotCQkJaWYgKGZyZWFkKGVudHJpZXNbaV0uc2hhMSwgMjAsIDEsIHN0ZGluKSAhPSAxKQorCQkJaWYgKGZyZWFkKGVudHJpZXNbaV0ub2lkLmhhc2gsIGhhc2hzeiwgMSwgc3RkaW4pICE9IDEpCiAJCQkJZGllKCJ1bmFibGUgdG8gcmVhZCBzaGExICV1LyV1IiwgaSwgbnIpOwogCQlmb3IgKGkgPSAwOyBpIDwgbnI7IGkrKykKIAkJCWlmIChmcmVhZCgmZW50cmllc1tpXS5jcmMsIDQsIDEsIHN0ZGluKSAhPSAxKQpAQCAtNzcsNyArNzgsNyBAQAogCQkJfQogCQkJcHJpbnRmKCIlIiBQUkl1TUFYICIgJXMgKCUwOCJQUkl4MzIiKVxuIiwKIAkJCSAgICAgICAodWludG1heF90KSBvZmZzZXQsCi0JCQkgICAgICAgc2hhMV90b19oZXgoZW50cmllc1tpXS5zaGExKSwKKwkJCSAgICAgICBvaWRfdG9faGV4KCZlbnRyaWVzW2ldLm9pZCksCiAJCQkgICAgICAgbnRvaGwoZW50cmllc1tpXS5jcmMpKTsKIAkJfQogCQlmcmVlKGVudHJpZXMpOwpkaWZmIC0tZ2l0IGEvYnVpbHRpbi9zdGFzaC5jIGIvYnVpbHRpbi9zdGFzaC5jCmluZGV4IGI1YTMwMWYuLjRhZDNhZGYgMTAwNjQ0Ci0tLSBhL2J1aWx0aW4vc3Rhc2guYworKysgYi9idWlsdGluL3N0YXNoLmMKQEAgLTM5Niw3ICszOTYsNyBAQAogCWNvbnN0IHN0cnVjdCBvYmplY3RfaWQgKmJhc2VzWzFdOwogCiAJcmVhZF9jYWNoZV9wcmVsb2FkKE5VTEwpOwotCWlmIChyZWZyZXNoX2NhY2hlKFJFRlJFU0hfUVVJRVQpKQorCWlmIChyZWZyZXNoX2FuZF93cml0ZV9jYWNoZShSRUZSRVNIX1FVSUVULCAwLCAwKSkKIAkJcmV0dXJuIC0xOwogCiAJaWYgKHdyaXRlX2NhY2hlX2FzX3RyZWUoJmNfdHJlZSwgMCwgTlVMTCkpCkBAIC00MjcsNiArNDI3LDggQEAKIAkJCQlyZXR1cm4gZXJyb3IoXygiY291bGQgbm90IHNhdmUgaW5kZXggdHJlZSIpKTsKIAogCQkJcmVzZXRfaGVhZCgpOworCQkJZGlzY2FyZF9jYWNoZSgpOworCQkJcmVhZF9jYWNoZSgpOwogCQl9CiAJfQogCkBAIC00ODEsMTMgKzQ4MywxMiBAQAogCQlpZiAocmV0KQogCQkJcmV0dXJuIC0xOwogCisJCS8qIHJlYWQgYmFjayB0aGUgcmVzdWx0IG9mIHVwZGF0ZV9pbmRleCgpIGJhY2sgZnJvbSB0aGUgZGlzayAqLwogCQlkaXNjYXJkX2NhY2hlKCk7CisJCXJlYWRfY2FjaGUoKTsKIAl9CiAKLQlpZiAocXVpZXQpIHsKLQkJaWYgKHJlZnJlc2hfY2FjaGUoUkVGUkVTSF9RVUlFVCkpCi0JCQl3YXJuaW5nKCJjb3VsZCBub3QgcmVmcmVzaCBpbmRleCIpOwotCX0gZWxzZSB7CisJaWYgKCFxdWlldCkgewogCQlzdHJ1Y3QgY2hpbGRfcHJvY2VzcyBjcCA9IENISUxEX1BST0NFU1NfSU5JVDsKIAogCQkvKgpAQCAtNDk3LDYgKzQ5OCwxMCBAQAogCQkgKi8KIAkJY3AuZ2l0X2NtZCA9IDE7CiAJCWNwLmRpciA9IHByZWZpeDsKKwkJYXJndl9hcnJheV9wdXNoZigmY3AuZW52X2FycmF5LCBHSVRfV09SS19UUkVFX0VOVklST05NRU5UIj0lcyIsCisJCQkJIGFic29sdXRlX3BhdGgoZ2V0X2dpdF93b3JrX3RyZWUoKSkpOworCQlhcmd2X2FycmF5X3B1c2hmKCZjcC5lbnZfYXJyYXksIEdJVF9ESVJfRU5WSVJPTk1FTlQiPSVzIiwKKwkJCQkgYWJzb2x1dGVfcGF0aChnZXRfZ2l0X2RpcigpKSk7CiAJCWFyZ3ZfYXJyYXlfcHVzaCgmY3AuYXJncywgInN0YXR1cyIpOwogCQlydW5fY29tbWFuZCgmY3ApOwogCX0KQEAgLTEwODIsOCArMTA4Nyw5IEBACiAJfQogCiAJY3BfdXBkX2luZGV4LmdpdF9jbWQgPSAxOwotCWFyZ3ZfYXJyYXlfcHVzaGwoJmNwX3VwZF9pbmRleC5hcmdzLCAidXBkYXRlLWluZGV4IiwgIi16IiwgIi0tYWRkIiwKLQkJCSAiLS1yZW1vdmUiLCAiLS1zdGRpbiIsIE5VTEwpOworCWFyZ3ZfYXJyYXlfcHVzaGwoJmNwX3VwZF9pbmRleC5hcmdzLCAidXBkYXRlLWluZGV4IiwKKwkJCSAiLS1pZ25vcmUtc2tpcC13b3JrdHJlZS1lbnRyaWVzIiwKKwkJCSAiLXoiLCAiLS1hZGQiLCAiLS1yZW1vdmUiLCAiLS1zdGRpbiIsIE5VTEwpOwogCWFyZ3ZfYXJyYXlfcHVzaGYoJmNwX3VwZF9pbmRleC5lbnZfYXJyYXksICJHSVRfSU5ERVhfRklMRT0lcyIsCiAJCQkgc3Rhc2hfaW5kZXhfcGF0aC5idWYpOwogCkBAIC0xMTI5LDcgKzExMzUsMTAgQEAKIAlwcmVwYXJlX2ZhbGxiYWNrX2lkZW50KCJnaXQgc3Rhc2giLCAiZ2l0QHN0YXNoIik7CiAKIAlyZWFkX2NhY2hlX3ByZWxvYWQoTlVMTCk7Ci0JcmVmcmVzaF9jYWNoZShSRUZSRVNIX1FVSUVUKTsKKwlpZiAocmVmcmVzaF9hbmRfd3JpdGVfY2FjaGUoUkVGUkVTSF9RVUlFVCwgMCwgMCkgPCAwKSB7CisJCXJldCA9IC0xOworCQlnb3RvIGRvbmU7CisJfQogCiAJaWYgKGdldF9vaWQoIkhFQUQiLCAmaW5mby0+Yl9jb21taXQpKSB7CiAJCWlmICghcXVpZXQpCkBAIC0xMjkwLDcgKzEyOTksNyBAQAogCQlmcmVlKHBzX21hdGNoZWQpOwogCX0KIAotCWlmIChyZWZyZXNoX2NhY2hlKFJFRlJFU0hfUVVJRVQpKSB7CisJaWYgKHJlZnJlc2hfYW5kX3dyaXRlX2NhY2hlKFJFRlJFU0hfUVVJRVQsIDAsIDApKSB7CiAJCXJldCA9IC0xOwogCQlnb3RvIGRvbmU7CiAJfQpAQCAtMTM4Myw3ICsxMzkyLDcgQEAKIAkJCXN0cnVjdCBjaGlsZF9wcm9jZXNzIGNwID0gQ0hJTERfUFJPQ0VTU19JTklUOwogCQkJY3AuZ2l0X2NtZCA9IDE7CiAJCQlhcmd2X2FycmF5X3B1c2hsKCZjcC5hcmdzLCAicmVzZXQiLCAiLS1oYXJkIiwgIi1xIiwKLQkJCQkJIE5VTEwpOworCQkJCQkgIi0tbm8tcmVjdXJzZS1zdWJtb2R1bGVzIiwgTlVMTCk7CiAJCQlpZiAocnVuX2NvbW1hbmQoJmNwKSkgewogCQkJCXJldCA9IC0xOwogCQkJCWdvdG8gZG9uZTsKZGlmZiAtLWdpdCBhL2J1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYyBiL2J1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYwppbmRleCA5MDllNzdlLi42ZjczYTc0IDEwMDY0NAotLS0gYS9idWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmMKKysrIGIvYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jCkBAIC00MjQsNyArNDI0LDcgQEAKIAkJY29uc3Qgc3RydWN0IGNhY2hlX2VudHJ5ICpjZSA9IGxpc3QuZW50cmllc1tpXTsKIAogCQlpZiAoY2Vfc3RhZ2UoY2UpKQotCQkJcHJpbnRmKCIlMDZvICVzIFVcdCIsIGNlLT5jZV9tb2RlLCBzaGExX3RvX2hleChudWxsX3NoYTEpKTsKKwkJCXByaW50ZigiJTA2byAlcyBVXHQiLCBjZS0+Y2VfbW9kZSwgb2lkX3RvX2hleCgmbnVsbF9vaWQpKTsKIAkJZWxzZQogCQkJcHJpbnRmKCIlMDZvICVzICVkXHQiLCBjZS0+Y2VfbW9kZSwKIAkJCSAgICAgICBvaWRfdG9faGV4KCZjZS0+b2lkKSwgY2Vfc3RhZ2UoY2UpKTsKQEAgLTgwMiw3ICs4MDIsOCBAQAogCQkJIHBhdGgsIE5VTEwpOwogCiAJZ2l0X2NvbmZpZyhnaXRfZGlmZl9iYXNpY19jb25maWcsIE5VTEwpOwotCXJlcG9faW5pdF9yZXZpc2lvbnModGhlX3JlcG9zaXRvcnksICZyZXYsIHByZWZpeCk7CisKKwlyZXBvX2luaXRfcmV2aXNpb25zKHRoZV9yZXBvc2l0b3J5LCAmcmV2LCBOVUxMKTsKIAlyZXYuYWJicmV2ID0gMDsKIAlkaWZmX2ZpbGVzX2FyZ3MuYXJnYyA9IHNldHVwX3JldmlzaW9ucyhkaWZmX2ZpbGVzX2FyZ3MuYXJnYywKIAkJCQkJICAgICAgIGRpZmZfZmlsZXNfYXJncy5hcmd2LApAQCAtMTg3NCw3ICsxODc1LDcgQEAKIAl9OwogCiAJY29uc3QgY2hhciAqY29uc3QgZ2l0X3N1Ym1vZHVsZV9oZWxwZXJfdXNhZ2VbXSA9IHsKLQkJTl8oImdpdCBzdWJtb2R1bGUtLWhlbHBlciB1cGRhdGVfY2xvbmUgWy0tcHJlZml4PTxwYXRoPl0gWzxwYXRoPi4uLl0iKSwKKwkJTl8oImdpdCBzdWJtb2R1bGUtLWhlbHBlciB1cGRhdGUtY2xvbmUgWy0tcHJlZml4PTxwYXRoPl0gWzxwYXRoPi4uLl0iKSwKIAkJTlVMTAogCX07CiAJc3VjLnByZWZpeCA9IHByZWZpeDsKZGlmZiAtLWdpdCBhL2J1aWx0aW4vdW5wYWNrLW9iamVjdHMuYyBiL2J1aWx0aW4vdW5wYWNrLW9iamVjdHMuYwppbmRleCBhODdhNGJmLi45MTAwOTY0IDEwMDY0NAotLS0gYS9idWlsdGluL3VucGFjay1vYmplY3RzLmMKKysrIGIvYnVpbHRpbi91bnBhY2stb2JqZWN0cy5jCkBAIC0yNCw2ICsyNCw3IEBACiBzdGF0aWMgb2ZmX3QgbWF4X2lucHV0X3NpemU7CiBzdGF0aWMgZ2l0X2hhc2hfY3R4IGN0eDsKIHN0YXRpYyBzdHJ1Y3QgZnNja19vcHRpb25zIGZzY2tfb3B0aW9ucyA9IEZTQ0tfT1BUSU9OU19TVFJJQ1Q7CitzdGF0aWMgc3RydWN0IHByb2dyZXNzICpwcm9ncmVzczsKIAogLyoKICAqIFdoZW4gcnVubmluZyB1bmRlciAtLXN0cmljdCBtb2RlLCBvYmplY3RzIHdob3NlIHJlYWNoYWJpbGl0eSBhcmUKQEAgLTkyLDYgKzkzLDcgQEAKIAljb25zdW1lZF9ieXRlcyArPSBieXRlczsKIAlpZiAobWF4X2lucHV0X3NpemUgJiYgY29uc3VtZWRfYnl0ZXMgPiBtYXhfaW5wdXRfc2l6ZSkKIAkJZGllKF8oInBhY2sgZXhjZWVkcyBtYXhpbXVtIGFsbG93ZWQgc2l6ZSIpKTsKKwlkaXNwbGF5X3Rocm91Z2hwdXQocHJvZ3Jlc3MsIGNvbnN1bWVkX2J5dGVzKTsKIH0KIAogc3RhdGljIHZvaWQgKmdldF9kYXRhKHVuc2lnbmVkIGxvbmcgc2l6ZSkKQEAgLTQ4NCw3ICs0ODYsNiBAQAogc3RhdGljIHZvaWQgdW5wYWNrX2FsbCh2b2lkKQogewogCWludCBpOwotCXN0cnVjdCBwcm9ncmVzcyAqcHJvZ3Jlc3MgPSBOVUxMOwogCXN0cnVjdCBwYWNrX2hlYWRlciAqaGRyID0gZmlsbChzaXplb2Yoc3RydWN0IHBhY2tfaGVhZGVyKSk7CiAKIAlucl9vYmplY3RzID0gbnRvaGwoaGRyLT5oZHJfZW50cmllcyk7CmRpZmYgLS1naXQgYS9idWlsdGluL3VwZGF0ZS1pbmRleC5jIGIvYnVpbHRpbi91cGRhdGUtaW5kZXguYwppbmRleCBkZmYyZjRiLi5kNTI3YjhmIDEwMDY0NAotLS0gYS9idWlsdGluL3VwZGF0ZS1pbmRleC5jCisrKyBiL2J1aWx0aW4vdXBkYXRlLWluZGV4LmMKQEAgLTM1LDYgKzM1LDcgQEAKIHN0YXRpYyBpbnQgbWFya192YWxpZF9vbmx5Owogc3RhdGljIGludCBtYXJrX3NraXBfd29ya3RyZWVfb25seTsKIHN0YXRpYyBpbnQgbWFya19mc21vbml0b3Jfb25seTsKK3N0YXRpYyBpbnQgaWdub3JlX3NraXBfd29ya3RyZWVfZW50cmllczsKICNkZWZpbmUgTUFSS19GTEFHIDEKICNkZWZpbmUgVU5NQVJLX0ZMQUcgMgogc3RhdGljIHN0cnVjdCBzdHJidWYgbXRpbWVfZGlyID0gU1RSQlVGX0lOSVQ7CkBAIC0zODEsNyArMzgyLDggQEAKIAkJICogc28gdXBkYXRpbmcgaXQgZG9lcyBub3QgbWFrZSBzZW5zZS4KIAkJICogT24gdGhlIG90aGVyIGhhbmQsIHJlbW92aW5nIGl0IGZyb20gaW5kZXggc2hvdWxkIHdvcmsKIAkJICovCi0JCWlmIChhbGxvd19yZW1vdmUgJiYgcmVtb3ZlX2ZpbGVfZnJvbV9jYWNoZShwYXRoKSkKKwkJaWYgKCFpZ25vcmVfc2tpcF93b3JrdHJlZV9lbnRyaWVzICYmIGFsbG93X3JlbW92ZSAmJgorCQkgICAgcmVtb3ZlX2ZpbGVfZnJvbV9jYWNoZShwYXRoKSkKIAkJCXJldHVybiBlcnJvcigiJXM6IGNhbm5vdCByZW1vdmUgZnJvbSB0aGUgaW5kZXgiLCBwYXRoKTsKIAkJcmV0dXJuIDA7CiAJfQpAQCAtOTY2LDYgKzk2OCw3IEBACiAJc3RydWN0IHBhcnNlX29wdF9jdHhfdCBjdHg7CiAJc3RyYnVmX2dldGxpbmVfZm4gZ2V0bGluZV9mbjsKIAlpbnQgcGFyc2VvcHRfc3RhdGUgPSBQQVJTRV9PUFRfVU5LTk9XTjsKKwlzdHJ1Y3QgcmVwb3NpdG9yeSAqciA9IHRoZV9yZXBvc2l0b3J5OwogCXN0cnVjdCBvcHRpb24gb3B0aW9uc1tdID0gewogCQlPUFRfQklUKCdxJywgTlVMTCwgJnJlZnJlc2hfYXJncy5mbGFncywKIAkJCU5fKCJjb250aW51ZSByZWZyZXNoIGV2ZW4gd2hlbiBpbmRleCBuZWVkcyB1cGRhdGUiKSwKQEAgLTEwMTMsNiArMTAxNiw4IEBACiAJCXtPUFRJT05fU0VUX0lOVCwgMCwgIm5vLXNraXAtd29ya3RyZWUiLCAmbWFya19za2lwX3dvcmt0cmVlX29ubHksIE5VTEwsCiAJCQlOXygiY2xlYXIgc2tpcC13b3JrdHJlZSBiaXQiKSwKIAkJCVBBUlNFX09QVF9OT0FSRyB8IFBBUlNFX09QVF9OT05FRywgTlVMTCwgVU5NQVJLX0ZMQUd9LAorCQlPUFRfQk9PTCgwLCAiaWdub3JlLXNraXAtd29ya3RyZWUtZW50cmllcyIsICZpZ25vcmVfc2tpcF93b3JrdHJlZV9lbnRyaWVzLAorCQkJIE5fKCJkbyBub3QgdG91Y2ggaW5kZXgtb25seSBlbnRyaWVzIikpLAogCQlPUFRfU0VUX0lOVCgwLCAiaW5mby1vbmx5IiwgJmluZm9fb25seSwKIAkJCU5fKCJhZGQgdG8gaW5kZXggb25seTsgZG8gbm90IGFkZCBjb250ZW50IHRvIG9iamVjdCBkYXRhYmFzZSIpLCAxKSwKIAkJT1BUX1NFVF9JTlQoMCwgImZvcmNlLXJlbW92ZSIsICZmb3JjZV9yZW1vdmUsCkBAIC0xMTgwLDExICsxMTg1LDEyIEBACiAJCXJlbW92ZV9zcGxpdF9pbmRleCgmdGhlX2luZGV4KTsKIAl9CiAKKwlwcmVwYXJlX3JlcG9fc2V0dGluZ3Mocik7CiAJc3dpdGNoICh1bnRyYWNrZWRfY2FjaGUpIHsKIAljYXNlIFVDX1VOU1BFQ0lGSUVEOgogCQlicmVhazsKIAljYXNlIFVDX0RJU0FCTEU6Ci0JCWlmIChnaXRfY29uZmlnX2dldF91bnRyYWNrZWRfY2FjaGUoKSA9PSAxKQorCQlpZiAoci0+c2V0dGluZ3MuY29yZV91bnRyYWNrZWRfY2FjaGUgPT0gVU5UUkFDS0VEX0NBQ0hFX1dSSVRFKQogCQkJd2FybmluZyhfKCJjb3JlLnVudHJhY2tlZENhY2hlIGlzIHNldCB0byB0cnVlOyAiCiAJCQkJICAicmVtb3ZlIG9yIGNoYW5nZSBpdCwgaWYgeW91IHJlYWxseSB3YW50IHRvICIKIAkJCQkgICJkaXNhYmxlIHRoZSB1bnRyYWNrZWQgY2FjaGUiKSk7CkBAIC0xMTk2LDcgKzEyMDIsNyBAQAogCQlyZXR1cm4gIXRlc3RfaWZfdW50cmFja2VkX2NhY2hlX2lzX3N1cHBvcnRlZCgpOwogCWNhc2UgVUNfRU5BQkxFOgogCWNhc2UgVUNfRk9SQ0U6Ci0JCWlmIChnaXRfY29uZmlnX2dldF91bnRyYWNrZWRfY2FjaGUoKSA9PSAwKQorCQlpZiAoci0+c2V0dGluZ3MuY29yZV91bnRyYWNrZWRfY2FjaGUgPT0gVU5UUkFDS0VEX0NBQ0hFX1JFTU9WRSkKIAkJCXdhcm5pbmcoXygiY29yZS51bnRyYWNrZWRDYWNoZSBpcyBzZXQgdG8gZmFsc2U7ICIKIAkJCQkgICJyZW1vdmUgb3IgY2hhbmdlIGl0LCBpZiB5b3UgcmVhbGx5IHdhbnQgdG8gIgogCQkJCSAgImVuYWJsZSB0aGUgdW50cmFja2VkIGNhY2hlIikpOwpkaWZmIC0tZ2l0IGEvYnVpbHRpbi93b3JrdHJlZS5jIGIvYnVpbHRpbi93b3JrdHJlZS5jCmluZGV4IGE1YmIwMmIuLmQ2YmM1MjYgMTAwNjQ0Ci0tLSBhL2J1aWx0aW4vd29ya3RyZWUuYworKysgYi9idWlsdGluL3dvcmt0cmVlLmMKQEAgLTEwLDcgKzEwLDYgQEAKICNpbmNsdWRlICJydW4tY29tbWFuZC5oIgogI2luY2x1ZGUgInNpZ2NoYWluLmgiCiAjaW5jbHVkZSAic3VibW9kdWxlLmgiCi0jaW5jbHVkZSAicmVmcy5oIgogI2luY2x1ZGUgInV0ZjguaCIKICNpbmNsdWRlICJ3b3JrdHJlZS5oIgogCkBAIC0zNTAsNyArMzQ5LDcgQEAKIAkgKi8KIAlzdHJidWZfcmVzZXQoJnNiKTsKIAlzdHJidWZfYWRkZigmc2IsICIlcy9IRUFEIiwgc2JfcmVwby5idWYpOwotCXdyaXRlX2ZpbGUoc2IuYnVmLCAiJXMiLCBzaGExX3RvX2hleChudWxsX3NoYTEpKTsKKwl3cml0ZV9maWxlKHNiLmJ1ZiwgIiVzIiwgb2lkX3RvX2hleCgmbnVsbF9vaWQpKTsKIAlzdHJidWZfcmVzZXQoJnNiKTsKIAlzdHJidWZfYWRkZigmc2IsICIlcy9jb21tb25kaXIiLCBzYl9yZXBvLmJ1Zik7CiAJd3JpdGVfZmlsZShzYi5idWYsICIuLi8uLiIpOwpAQCAtMzc3LDcgKzM3Niw3IEBACiAJaWYgKG9wdHMtPmNoZWNrb3V0KSB7CiAJCWNwLmFyZ3YgPSBOVUxMOwogCQlhcmd2X2FycmF5X2NsZWFyKCZjcC5hcmdzKTsKLQkJYXJndl9hcnJheV9wdXNobCgmY3AuYXJncywgInJlc2V0IiwgIi0taGFyZCIsIE5VTEwpOworCQlhcmd2X2FycmF5X3B1c2hsKCZjcC5hcmdzLCAicmVzZXQiLCAiLS1oYXJkIiwgIi0tbm8tcmVjdXJzZS1zdWJtb2R1bGVzIiwgTlVMTCk7CiAJCWlmIChvcHRzLT5xdWlldCkKIAkJCWFyZ3ZfYXJyYXlfcHVzaCgmY3AuYXJncywgIi0tcXVpZXQiKTsKIAkJY3AuZW52ID0gY2hpbGRfZW52LmFyZ3Y7CkBAIC04ODAsNyArODc5LDcgQEAKIAkJCSAgb3JpZ2luYWxfcGF0aCk7CiAJcmV0ID0geHJlYWQoY3Aub3V0LCBidWYsIHNpemVvZihidWYpKTsKIAlpZiAocmV0KQotCQlkaWUoXygiJyVzJyBpcyBkaXJ0eSwgdXNlIC0tZm9yY2UgdG8gZGVsZXRlIGl0IiksCisJCWRpZShfKCInJXMnIGNvbnRhaW5zIG1vZGlmaWVkIG9yIHVudHJhY2tlZCBmaWxlcywgdXNlIC0tZm9yY2UgdG8gZGVsZXRlIGl0IiksCiAJCSAgICBvcmlnaW5hbF9wYXRoKTsKIAljbG9zZShjcC5vdXQpOwogCXJldCA9IGZpbmlzaF9jb21tYW5kKCZjcCk7CmRpZmYgLS1naXQgYS9idWxrLWNoZWNraW4uYyBiL2J1bGstY2hlY2tpbi5jCmluZGV4IDM5ZWU3ZDYuLjU4M2FhY2IgMTAwNjQ0Ci0tLSBhL2J1bGstY2hlY2tpbi5jCisrKyBiL2J1bGstY2hlY2tpbi5jCkBAIC0xOTcsNyArMTk3LDcgQEAKIAlnaXRfaGFzaF9jdHggY3R4OwogCXVuc2lnbmVkIGNoYXIgb2J1ZlsxNjM4NF07CiAJdW5zaWduZWQgaGVhZGVyX2xlbjsKLQlzdHJ1Y3QgaGFzaGZpbGVfY2hlY2twb2ludCBjaGVja3BvaW50OworCXN0cnVjdCBoYXNoZmlsZV9jaGVja3BvaW50IGNoZWNrcG9pbnQgPSB7MH07CiAJc3RydWN0IHBhY2tfaWR4X2VudHJ5ICppZHggPSBOVUxMOwogCiAJc2Vla2JhY2sgPSBsc2VlayhmZCwgMCwgU0VFS19DVVIpOwpkaWZmIC0tZ2l0IGEvYnVuZGxlLmMgYi9idW5kbGUuYwppbmRleCBiNWQyMWNkLi45OTQzOWUwIDEwMDY0NAotLS0gYS9idW5kbGUuYworKysgYi9idW5kbGUuYwpAQCAtMjQ5LDE1ICsyNDksMTYgQEAKIAogCiAvKiBXcml0ZSB0aGUgcGFjayBkYXRhIHRvIGJ1bmRsZV9mZCAqLwotc3RhdGljIGludCB3cml0ZV9wYWNrX2RhdGEoaW50IGJ1bmRsZV9mZCwgc3RydWN0IHJldl9pbmZvICpyZXZzKQorc3RhdGljIGludCB3cml0ZV9wYWNrX2RhdGEoaW50IGJ1bmRsZV9mZCwgc3RydWN0IHJldl9pbmZvICpyZXZzLCBzdHJ1Y3QgYXJndl9hcnJheSAqcGFja19vcHRpb25zKQogewogCXN0cnVjdCBjaGlsZF9wcm9jZXNzIHBhY2tfb2JqZWN0cyA9IENISUxEX1BST0NFU1NfSU5JVDsKIAlpbnQgaTsKIAogCWFyZ3ZfYXJyYXlfcHVzaGwoJnBhY2tfb2JqZWN0cy5hcmdzLAotCQkJICJwYWNrLW9iamVjdHMiLCAiLS1hbGwtcHJvZ3Jlc3MtaW1wbGllZCIsCisJCQkgInBhY2stb2JqZWN0cyIsCiAJCQkgIi0tc3Rkb3V0IiwgIi0tdGhpbiIsICItLWRlbHRhLWJhc2Utb2Zmc2V0IiwKIAkJCSBOVUxMKTsKKwlhcmd2X2FycmF5X3B1c2h2KCZwYWNrX29iamVjdHMuYXJncywgcGFja19vcHRpb25zLT5hcmd2KTsKIAlwYWNrX29iamVjdHMuaW4gPSAtMTsKIAlwYWNrX29iamVjdHMub3V0ID0gYnVuZGxlX2ZkOwogCXBhY2tfb2JqZWN0cy5naXRfY21kID0gMTsKQEAgLTI4Miw3ICsyODMsNyBAQAogCQlzdHJ1Y3Qgb2JqZWN0ICpvYmplY3QgPSByZXZzLT5wZW5kaW5nLm9iamVjdHNbaV0uaXRlbTsKIAkJaWYgKG9iamVjdC0+ZmxhZ3MgJiBVTklOVEVSRVNUSU5HKQogCQkJd3JpdGVfb3JfZGllKHBhY2tfb2JqZWN0cy5pbiwgIl4iLCAxKTsKLQkJd3JpdGVfb3JfZGllKHBhY2tfb2JqZWN0cy5pbiwgb2lkX3RvX2hleCgmb2JqZWN0LT5vaWQpLCBHSVRfU0hBMV9IRVhTWik7CisJCXdyaXRlX29yX2RpZShwYWNrX29iamVjdHMuaW4sIG9pZF90b19oZXgoJm9iamVjdC0+b2lkKSwgdGhlX2hhc2hfYWxnby0+aGV4c3opOwogCQl3cml0ZV9vcl9kaWUocGFja19vYmplY3RzLmluLCAiXG4iLCAxKTsKIAl9CiAJY2xvc2UocGFja19vYmplY3RzLmluKTsKQEAgLTQxNCw3ICs0MTUsNyBAQAogCQl9CiAKIAkJcmVmX2NvdW50Kys7Ci0JCXdyaXRlX29yX2RpZShidW5kbGVfZmQsIG9pZF90b19oZXgoJmUtPml0ZW0tPm9pZCksIDQwKTsKKwkJd3JpdGVfb3JfZGllKGJ1bmRsZV9mZCwgb2lkX3RvX2hleCgmZS0+aXRlbS0+b2lkKSwgdGhlX2hhc2hfYWxnby0+aGV4c3opOwogCQl3cml0ZV9vcl9kaWUoYnVuZGxlX2ZkLCAiICIsIDEpOwogCQl3cml0ZV9vcl9kaWUoYnVuZGxlX2ZkLCBkaXNwbGF5X3JlZiwgc3RybGVuKGRpc3BsYXlfcmVmKSk7CiAJCXdyaXRlX29yX2RpZShidW5kbGVfZmQsICJcbiIsIDEpOwpAQCAtNDI4LDcgKzQyOSw3IEBACiB9CiAKIGludCBjcmVhdGVfYnVuZGxlKHN0cnVjdCByZXBvc2l0b3J5ICpyLCBjb25zdCBjaGFyICpwYXRoLAotCQkgIGludCBhcmdjLCBjb25zdCBjaGFyICoqYXJndikKKwkJICBpbnQgYXJnYywgY29uc3QgY2hhciAqKmFyZ3YsIHN0cnVjdCBhcmd2X2FycmF5ICpwYWNrX29wdGlvbnMpCiB7CiAJc3RydWN0IGxvY2tfZmlsZSBsb2NrID0gTE9DS19JTklUOwogCWludCBidW5kbGVfZmQgPSAtMTsKQEAgLTQ3MCw3ICs0NzEsNyBAQAogCQlnb3RvIGVycjsKIAogCS8qIHdyaXRlIHBhY2sgKi8KLQlpZiAod3JpdGVfcGFja19kYXRhKGJ1bmRsZV9mZCwgJnJldnMpKQorCWlmICh3cml0ZV9wYWNrX2RhdGEoYnVuZGxlX2ZkLCAmcmV2cywgcGFja19vcHRpb25zKSkKIAkJZ290byBlcnI7CiAKIAlpZiAoIWJ1bmRsZV90b19zdGRvdXQpIHsKZGlmZiAtLWdpdCBhL2J1bmRsZS5oIGIvYnVuZGxlLmgKaW5kZXggMzdjMzdkNy4uY2VhYjBjNyAxMDA2NDQKLS0tIGEvYnVuZGxlLmgKKysrIGIvYnVuZGxlLmgKQEAgLTEsNiArMSw3IEBACiAjaWZuZGVmIEJVTkRMRV9ICiAjZGVmaW5lIEJVTkRMRV9ICiAKKyNpbmNsdWRlICJhcmd2LWFycmF5LmgiCiAjaW5jbHVkZSAiY2FjaGUuaCIKIAogc3RydWN0IHJlZl9saXN0IHsKQEAgLTE5LDcgKzIwLDcgQEAKIGludCBpc19idW5kbGUoY29uc3QgY2hhciAqcGF0aCwgaW50IHF1aWV0KTsKIGludCByZWFkX2J1bmRsZV9oZWFkZXIoY29uc3QgY2hhciAqcGF0aCwgc3RydWN0IGJ1bmRsZV9oZWFkZXIgKmhlYWRlcik7CiBpbnQgY3JlYXRlX2J1bmRsZShzdHJ1Y3QgcmVwb3NpdG9yeSAqciwgY29uc3QgY2hhciAqcGF0aCwKLQkJICBpbnQgYXJnYywgY29uc3QgY2hhciAqKmFyZ3YpOworCQkgIGludCBhcmdjLCBjb25zdCBjaGFyICoqYXJndiwgc3RydWN0IGFyZ3ZfYXJyYXkgKnBhY2tfb3B0aW9ucyk7CiBpbnQgdmVyaWZ5X2J1bmRsZShzdHJ1Y3QgcmVwb3NpdG9yeSAqciwgc3RydWN0IGJ1bmRsZV9oZWFkZXIgKmhlYWRlciwgaW50IHZlcmJvc2UpOwogI2RlZmluZSBCVU5ETEVfVkVSQk9TRSAxCiBpbnQgdW5idW5kbGUoc3RydWN0IHJlcG9zaXRvcnkgKnIsIHN0cnVjdCBidW5kbGVfaGVhZGVyICpoZWFkZXIsCmRpZmYgLS1naXQgYS9jYWNoZS10cmVlLmMgYi9jYWNoZS10cmVlLmMKaW5kZXggNzA2ZmZjZi4uMWJkMWIyMyAxMDA2NDQKLS0tIGEvY2FjaGUtdHJlZS5jCisrKyBiL2NhY2hlLXRyZWUuYwpAQCAtNSw2ICs1LDcgQEAKICNpbmNsdWRlICJjYWNoZS10cmVlLmgiCiAjaW5jbHVkZSAib2JqZWN0LXN0b3JlLmgiCiAjaW5jbHVkZSAicmVwbGFjZS1vYmplY3QuaCIKKyNpbmNsdWRlICJwcm9taXNvci1yZW1vdGUuaCIKIAogI2lmbmRlZiBERUJVR19DQUNIRV9UUkVFCiAjZGVmaW5lIERFQlVHX0NBQ0hFX1RSRUUgMApAQCAtMzU3LDcgKzM1OCw3IEBACiAJCX0KIAogCQljZV9taXNzaW5nX29rID0gbW9kZSA9PSBTX0lGR0lUTElOSyB8fCBtaXNzaW5nX29rIHx8Ci0JCQkocmVwb3NpdG9yeV9mb3JtYXRfcGFydGlhbF9jbG9uZSAmJgorCQkJKGhhc19wcm9taXNvcl9yZW1vdGUoKSAmJgogCQkJIGNlX3NraXBfd29ya3RyZWUoY2UpKTsKIAkJaWYgKGlzX251bGxfb2lkKG9pZCkgfHwKIAkJICAgICghY2VfbWlzc2luZ19vayAmJiAhaGFzX29iamVjdF9maWxlKG9pZCkpKSB7CkBAIC00MDcsNyArNDA4LDcgQEAKIAlpZiAocmVwYWlyKSB7CiAJCXN0cnVjdCBvYmplY3RfaWQgb2lkOwogCQloYXNoX29iamVjdF9maWxlKGJ1ZmZlci5idWYsIGJ1ZmZlci5sZW4sIHRyZWVfdHlwZSwgJm9pZCk7Ci0JCWlmIChoYXNfb2JqZWN0X2ZpbGUoJm9pZCkpCisJCWlmIChoYXNfb2JqZWN0X2ZpbGVfd2l0aF9mbGFncygmb2lkLCBPQkpFQ1RfSU5GT19TS0lQX0ZFVENIX09CSkVDVCkpCiAJCQlvaWRjcHkoJml0LT5vaWQsICZvaWQpOwogCQllbHNlCiAJCQl0b19pbnZhbGlkYXRlID0gMTsKQEAgLTYwOCwxMSArNjA5LDY2IEBACiAJcmV0dXJuIGl0OwogfQogCitzdGF0aWMgaW50IHdyaXRlX2luZGV4X2FzX3RyZWVfaW50ZXJuYWwoc3RydWN0IG9iamVjdF9pZCAqb2lkLAorCQkJCQlzdHJ1Y3QgaW5kZXhfc3RhdGUgKmluZGV4X3N0YXRlLAorCQkJCQlpbnQgY2FjaGVfdHJlZV92YWxpZCwKKwkJCQkJaW50IGZsYWdzLAorCQkJCQljb25zdCBjaGFyICpwcmVmaXgpCit7CisJaWYgKGZsYWdzICYgV1JJVEVfVFJFRV9JR05PUkVfQ0FDSEVfVFJFRSkgeworCQljYWNoZV90cmVlX2ZyZWUoJmluZGV4X3N0YXRlLT5jYWNoZV90cmVlKTsKKwkJY2FjaGVfdHJlZV92YWxpZCA9IDA7CisJfQorCisJaWYgKCFpbmRleF9zdGF0ZS0+Y2FjaGVfdHJlZSkKKwkJaW5kZXhfc3RhdGUtPmNhY2hlX3RyZWUgPSBjYWNoZV90cmVlKCk7CisKKwlpZiAoIWNhY2hlX3RyZWVfdmFsaWQgJiYgY2FjaGVfdHJlZV91cGRhdGUoaW5kZXhfc3RhdGUsIGZsYWdzKSA8IDApCisJCXJldHVybiBXUklURV9UUkVFX1VOTUVSR0VEX0lOREVYOworCisJaWYgKHByZWZpeCkgeworCQlzdHJ1Y3QgY2FjaGVfdHJlZSAqc3VidHJlZTsKKwkJc3VidHJlZSA9IGNhY2hlX3RyZWVfZmluZChpbmRleF9zdGF0ZS0+Y2FjaGVfdHJlZSwgcHJlZml4KTsKKwkJaWYgKCFzdWJ0cmVlKQorCQkJcmV0dXJuIFdSSVRFX1RSRUVfUFJFRklYX0VSUk9SOworCQlvaWRjcHkob2lkLCAmc3VidHJlZS0+b2lkKTsKKwl9CisJZWxzZQorCQlvaWRjcHkob2lkLCAmaW5kZXhfc3RhdGUtPmNhY2hlX3RyZWUtPm9pZCk7CisKKwlyZXR1cm4gMDsKK30KKworc3RydWN0IHRyZWUqIHdyaXRlX2luX2NvcmVfaW5kZXhfYXNfdHJlZShzdHJ1Y3QgcmVwb3NpdG9yeSAqcmVwbykgeworCXN0cnVjdCBvYmplY3RfaWQgbzsKKwlpbnQgd2FzX3ZhbGlkLCByZXQ7CisKKwlzdHJ1Y3QgaW5kZXhfc3RhdGUgKmluZGV4X3N0YXRlCT0gcmVwby0+aW5kZXg7CisJd2FzX3ZhbGlkID0gaW5kZXhfc3RhdGUtPmNhY2hlX3RyZWUgJiYKKwkJICAgIGNhY2hlX3RyZWVfZnVsbHlfdmFsaWQoaW5kZXhfc3RhdGUtPmNhY2hlX3RyZWUpOworCisJcmV0ID0gd3JpdGVfaW5kZXhfYXNfdHJlZV9pbnRlcm5hbCgmbywgaW5kZXhfc3RhdGUsIHdhc192YWxpZCwgMCwgTlVMTCk7CisJaWYgKHJldCA9PSBXUklURV9UUkVFX1VOTUVSR0VEX0lOREVYKSB7CisJCWludCBpOworCQlmcHJpbnRmKHN0ZGVyciwgIkJVRzogVGhlcmUgYXJlIHVubWVyZ2VkIGluZGV4IGVudHJpZXM6XG4iKTsKKwkJZm9yIChpID0gMDsgaSA8IGluZGV4X3N0YXRlLT5jYWNoZV9ucjsgaSsrKSB7CisJCQljb25zdCBzdHJ1Y3QgY2FjaGVfZW50cnkgKmNlID0gaW5kZXhfc3RhdGUtPmNhY2hlW2ldOworCQkJaWYgKGNlX3N0YWdlKGNlKSkKKwkJCQlmcHJpbnRmKHN0ZGVyciwgIkJVRzogJWQgJS4qc1xuIiwgY2Vfc3RhZ2UoY2UpLAorCQkJCQkoaW50KWNlX25hbWVsZW4oY2UpLCBjZS0+bmFtZSk7CisJCX0KKwkJQlVHKCJ1bm1lcmdlZCBpbmRleCBlbnRyaWVzIHdoZW4gd3JpdGluZyBpbm1lbW9yeSBpbmRleCIpOworCX0KKworCXJldHVybiBsb29rdXBfdHJlZShyZXBvLCAmaW5kZXhfc3RhdGUtPmNhY2hlX3RyZWUtPm9pZCk7Cit9CisKKwogaW50IHdyaXRlX2luZGV4X2FzX3RyZWUoc3RydWN0IG9iamVjdF9pZCAqb2lkLCBzdHJ1Y3QgaW5kZXhfc3RhdGUgKmluZGV4X3N0YXRlLCBjb25zdCBjaGFyICppbmRleF9wYXRoLCBpbnQgZmxhZ3MsIGNvbnN0IGNoYXIgKnByZWZpeCkKIHsKIAlpbnQgZW50cmllcywgd2FzX3ZhbGlkOwogCXN0cnVjdCBsb2NrX2ZpbGUgbG9ja19maWxlID0gTE9DS19JTklUOwotCWludCByZXQgPSAwOworCWludCByZXQ7CiAKIAlob2xkX2xvY2tfZmlsZV9mb3JfdXBkYXRlKCZsb2NrX2ZpbGUsIGluZGV4X3BhdGgsIExPQ0tfRElFX09OX0VSUk9SKTsKIApAQCAtNjIxLDE4ICs2NzcsMTQgQEAKIAkJcmV0ID0gV1JJVEVfVFJFRV9VTlJFQURBQkxFX0lOREVYOwogCQlnb3RvIG91dDsKIAl9Ci0JaWYgKGZsYWdzICYgV1JJVEVfVFJFRV9JR05PUkVfQ0FDSEVfVFJFRSkKLQkJY2FjaGVfdHJlZV9mcmVlKCZpbmRleF9zdGF0ZS0+Y2FjaGVfdHJlZSk7CiAKLQlpZiAoIWluZGV4X3N0YXRlLT5jYWNoZV90cmVlKQotCQlpbmRleF9zdGF0ZS0+Y2FjaGVfdHJlZSA9IGNhY2hlX3RyZWUoKTsKKwl3YXNfdmFsaWQgPSAhKGZsYWdzICYgV1JJVEVfVFJFRV9JR05PUkVfQ0FDSEVfVFJFRSkgJiYKKwkJICAgIGluZGV4X3N0YXRlLT5jYWNoZV90cmVlICYmCisJCSAgICBjYWNoZV90cmVlX2Z1bGx5X3ZhbGlkKGluZGV4X3N0YXRlLT5jYWNoZV90cmVlKTsKIAotCXdhc192YWxpZCA9IGNhY2hlX3RyZWVfZnVsbHlfdmFsaWQoaW5kZXhfc3RhdGUtPmNhY2hlX3RyZWUpOwotCWlmICghd2FzX3ZhbGlkKSB7Ci0JCWlmIChjYWNoZV90cmVlX3VwZGF0ZShpbmRleF9zdGF0ZSwgZmxhZ3MpIDwgMCkgewotCQkJcmV0ID0gV1JJVEVfVFJFRV9VTk1FUkdFRF9JTkRFWDsKLQkJCWdvdG8gb3V0OwotCQl9CisJcmV0ID0gd3JpdGVfaW5kZXhfYXNfdHJlZV9pbnRlcm5hbChvaWQsIGluZGV4X3N0YXRlLCB3YXNfdmFsaWQsIGZsYWdzLAorCQkJCQkgICBwcmVmaXgpOworCWlmICghcmV0ICYmICF3YXNfdmFsaWQpIHsKIAkJd3JpdGVfbG9ja2VkX2luZGV4KGluZGV4X3N0YXRlLCAmbG9ja19maWxlLCBDT01NSVRfTE9DSyk7CiAJCS8qIE5vdCBiZWluZyBhYmxlIHRvIHdyaXRlIGlzIGZpbmUgLS0gd2UgYXJlIG9ubHkgaW50ZXJlc3RlZAogCQkgKiBpbiB1cGRhdGluZyB0aGUgY2FjaGUtdHJlZSBwYXJ0LCBhbmQgaWYgdGhlIG5leHQgY2FsbGVyCkBAIC02NDIsMTggKzY5NCw2IEBACiAJCSAqLwogCX0KIAotCWlmIChwcmVmaXgpIHsKLQkJc3RydWN0IGNhY2hlX3RyZWUgKnN1YnRyZWU7Ci0JCXN1YnRyZWUgPSBjYWNoZV90cmVlX2ZpbmQoaW5kZXhfc3RhdGUtPmNhY2hlX3RyZWUsIHByZWZpeCk7Ci0JCWlmICghc3VidHJlZSkgewotCQkJcmV0ID0gV1JJVEVfVFJFRV9QUkVGSVhfRVJST1I7Ci0JCQlnb3RvIG91dDsKLQkJfQotCQlvaWRjcHkob2lkLCAmc3VidHJlZS0+b2lkKTsKLQl9Ci0JZWxzZQotCQlvaWRjcHkob2lkLCAmaW5kZXhfc3RhdGUtPmNhY2hlX3RyZWUtPm9pZCk7Ci0KIG91dDoKIAlyb2xsYmFja19sb2NrX2ZpbGUoJmxvY2tfZmlsZSk7CiAJcmV0dXJuIHJldDsKQEAgLTcxMyw3ICs3NTMsNyBAQAogCWlmICghaW5mby0+cHJldikKIAkJcmV0dXJuIHJvb3Q7CiAJb3VyX3BhcmVudCA9IGZpbmRfY2FjaGVfdHJlZV9mcm9tX3RyYXZlcnNhbChyb290LCBpbmZvLT5wcmV2KTsKLQlyZXR1cm4gY2FjaGVfdHJlZV9maW5kKG91cl9wYXJlbnQsIGluZm8tPm5hbWUucGF0aCk7CisJcmV0dXJuIGNhY2hlX3RyZWVfZmluZChvdXJfcGFyZW50LCBpbmZvLT5uYW1lKTsKIH0KIAogaW50IGNhY2hlX3RyZWVfbWF0Y2hlc190cmF2ZXJzYWwoc3RydWN0IGNhY2hlX3RyZWUgKnJvb3QsCmRpZmYgLS1naXQgYS9jYWNoZS10cmVlLmggYi9jYWNoZS10cmVlLmgKaW5kZXggNzU3YmJjNC4uNjM5YmZhNSAxMDA2NDQKLS0tIGEvY2FjaGUtdHJlZS5oCisrKyBiL2NhY2hlLXRyZWUuaApAQCAtMzQsNyArMzQsNyBAQAogaW50IGNhY2hlX3RyZWVfdXBkYXRlKHN0cnVjdCBpbmRleF9zdGF0ZSAqLCBpbnQpOwogdm9pZCBjYWNoZV90cmVlX3ZlcmlmeShzdHJ1Y3QgcmVwb3NpdG9yeSAqLCBzdHJ1Y3QgaW5kZXhfc3RhdGUgKik7CiAKLS8qIGJpdG1hc2tzIHRvIHdyaXRlX2NhY2hlX2FzX3RyZWUgZmxhZ3MgKi8KKy8qIGJpdG1hc2tzIHRvIHdyaXRlX2luZGV4X2FzX3RyZWUgZmxhZ3MgKi8KICNkZWZpbmUgV1JJVEVfVFJFRV9NSVNTSU5HX09LIDEKICNkZWZpbmUgV1JJVEVfVFJFRV9JR05PUkVfQ0FDSEVfVFJFRSAyCiAjZGVmaW5lIFdSSVRFX1RSRUVfRFJZX1JVTiA0CkBAIC00Niw2ICs0Niw3IEBACiAjZGVmaW5lIFdSSVRFX1RSRUVfVU5NRVJHRURfSU5ERVggKC0yKQogI2RlZmluZSBXUklURV9UUkVFX1BSRUZJWF9FUlJPUiAoLTMpCiAKK3N0cnVjdCB0cmVlKiB3cml0ZV9pbl9jb3JlX2luZGV4X2FzX3RyZWUoc3RydWN0IHJlcG9zaXRvcnkgKnJlcG8pOwogaW50IHdyaXRlX2luZGV4X2FzX3RyZWUoc3RydWN0IG9iamVjdF9pZCAqb2lkLCBzdHJ1Y3QgaW5kZXhfc3RhdGUgKmluZGV4X3N0YXRlLCBjb25zdCBjaGFyICppbmRleF9wYXRoLCBpbnQgZmxhZ3MsIGNvbnN0IGNoYXIgKnByZWZpeCk7CiB2b2lkIHByaW1lX2NhY2hlX3RyZWUoc3RydWN0IHJlcG9zaXRvcnkgKiwgc3RydWN0IGluZGV4X3N0YXRlICosIHN0cnVjdCB0cmVlICopOwogCmRpZmYgLS1naXQgYS9jYWNoZS5oIGIvY2FjaGUuaAppbmRleCBiMWRhMWFiLi42NDY2OWE0IDEwMDY0NAotLS0gYS9jYWNoZS5oCisrKyBiL2NhY2hlLmgKQEAgLTQxNCw2ICs0MTQsNyBAQAogI2RlZmluZSBhZGRfZmlsZV90b19jYWNoZShwYXRoLCBmbGFncykgYWRkX2ZpbGVfdG9faW5kZXgoJnRoZV9pbmRleCwgKHBhdGgpLCAoZmxhZ3MpKQogI2RlZmluZSBjaG1vZF9jYWNoZV9lbnRyeShjZSwgZmxpcCkgY2htb2RfaW5kZXhfZW50cnkoJnRoZV9pbmRleCwgKGNlKSwgKGZsaXApKQogI2RlZmluZSByZWZyZXNoX2NhY2hlKGZsYWdzKSByZWZyZXNoX2luZGV4KCZ0aGVfaW5kZXgsIChmbGFncyksIE5VTEwsIE5VTEwsIE5VTEwpCisjZGVmaW5lIHJlZnJlc2hfYW5kX3dyaXRlX2NhY2hlKHJlZnJlc2hfZmxhZ3MsIHdyaXRlX2ZsYWdzLCBnZW50bGUpIHJlcG9fcmVmcmVzaF9hbmRfd3JpdGVfaW5kZXgodGhlX3JlcG9zaXRvcnksIChyZWZyZXNoX2ZsYWdzKSwgKHdyaXRlX2ZsYWdzKSwgKGdlbnRsZSksIE5VTEwsIE5VTEwsIE5VTEwpCiAjZGVmaW5lIGNlX21hdGNoX3N0YXQoY2UsIHN0LCBvcHRpb25zKSBpZV9tYXRjaF9zdGF0KCZ0aGVfaW5kZXgsIChjZSksIChzdCksIChvcHRpb25zKSkKICNkZWZpbmUgY2VfbW9kaWZpZWQoY2UsIHN0LCBvcHRpb25zKSBpZV9tb2RpZmllZCgmdGhlX2luZGV4LCAoY2UpLCAoc3QpLCAob3B0aW9ucykpCiAjZGVmaW5lIGNhY2hlX2Rpcl9leGlzdHMobmFtZSwgbmFtZWxlbikgaW5kZXhfZGlyX2V4aXN0cygmdGhlX2luZGV4LCAobmFtZSksIChuYW1lbGVuKSkKQEAgLTYzNiw2ICs2MzcsOSBAQAogICogYXQgbGVhc3QgJ25yJyBlbnRyaWVzOyB0aGUgbnVtYmVyIG9mIGVudHJpZXMgY3VycmVudGx5IGFsbG9jYXRlZAogICogaXMgJ2FsbG9jJywgdXNpbmcgdGhlIHN0YW5kYXJkIGdyb3dpbmcgZmFjdG9yIGFsbG9jX25yKCkgbWFjcm8uCiAgKgorICogQ29uc2lkZXIgdXNpbmcgQUxMT0NfR1JPV19CWSBpbnN0ZWFkIG9mIEFMTE9DX0dST1cgYXMgaXQgaGFzIHNvbWUKKyAqIGFkZGVkIG5pY2V0aWVzLgorICoKICAqIERPIE5PVCBVU0UgYW55IGV4cHJlc3Npb24gd2l0aCBzaWRlLWVmZmVjdCBmb3IgJ3gnLCAnbnInLCBvciAnYWxsb2MnLgogICovCiAjZGVmaW5lIEFMTE9DX0dST1coeCwgbnIsIGFsbG9jKSBcCkBAIC02NDksNiArNjUzLDI1IEBACiAJCX0gXAogCX0gd2hpbGUgKDApCiAKKy8qCisgKiBTaW1pbGFyIHRvIEFMTE9DX0dST1cgYnV0IGhhbmRsZXMgdXBkYXRpbmcgb2YgdGhlIG5yIHZhbHVlIGFuZAorICogemVyb2luZyB0aGUgYnl0ZXMgb2YgdGhlIG5ld2x5LWdyb3duIGFycmF5IGVsZW1lbnRzLgorICoKKyAqIERPIE5PVCBVU0UgYW55IGV4cHJlc3Npb24gd2l0aCBzaWRlLWVmZmVjdCBmb3IgYW55IG9mIHRoZQorICogYXJndW1lbnRzLgorICovCisjZGVmaW5lIEFMTE9DX0dST1dfQlkoeCwgbnIsIGluY3JlYXNlLCBhbGxvYykgXAorCWRvIHsgXAorCQlpZiAoaW5jcmVhc2UpIHsgXAorCQkJc2l6ZV90IG5ld19uciA9IG5yICsgKGluY3JlYXNlKTsgXAorCQkJaWYgKG5ld19uciA8IG5yKSBcCisJCQkJQlVHKCJuZWdhdGl2ZSBncm93dGggaW4gQUxMT0NfR1JPV19CWSIpOyBcCisJCQlBTExPQ19HUk9XKHgsIG5ld19uciwgYWxsb2MpOyBcCisJCQltZW1zZXQoKHgpICsgbnIsIDAsIHNpemVvZigqKHgpKSAqIChpbmNyZWFzZSkpOyBcCisJCQluciA9IG5ld19ucjsgXAorCQl9IFwKKwl9IHdoaWxlICgwKQorCiAvKiBJbml0aWFsaXplIGFuZCB1c2UgdGhlIGNhY2hlIGluZm9ybWF0aW9uICovCiBzdHJ1Y3QgbG9ja19maWxlOwogdm9pZCBwcmVsb2FkX2luZGV4KHN0cnVjdCBpbmRleF9zdGF0ZSAqaW5kZXgsCkBAIC03MjUsNiArNzQ4LDE5IEBACiAgKi8KIGludCBpbmRleF9uYW1lX3Bvcyhjb25zdCBzdHJ1Y3QgaW5kZXhfc3RhdGUgKiwgY29uc3QgY2hhciAqbmFtZSwgaW50IG5hbWVsZW4pOwogCisvKgorICogU29tZSBmdW5jdGlvbnMgcmV0dXJuIHRoZSBuZWdhdGl2ZSBjb21wbGVtZW50IG9mIGFuIGluc2VydCBwb3NpdGlvbiB3aGVuIGEKKyAqIHByZWNpc2UgbWF0Y2ggd2FzIG5vdCBmb3VuZCBidXQgYSBwb3NpdGlvbiB3YXMgZm91bmQgd2hlcmUgdGhlIGVudHJ5IHdvdWxkCisgKiBuZWVkIHRvIGJlIGluc2VydGVkLiBUaGlzIGhlbHBlciBwcm90ZWN0cyB0aGF0IGxvZ2ljIGZyb20gYW55IGludGVnZXIKKyAqIHVuZGVyZmxvdy4KKyAqLworc3RhdGljIGlubGluZSBpbnQgaW5kZXhfcG9zX3RvX2luc2VydF9wb3ModWludG1heF90IHBvcykKK3sKKwlpZiAocG9zID4gSU5UX01BWCkKKwkJZGllKCJvdmVyZmxvdzogLTEgLSAlIlBSSXVNQVgsIHBvcyk7CisJcmV0dXJuIC0xIC0gKGludClwb3M7Cit9CisKICNkZWZpbmUgQUREX0NBQ0hFX09LX1RPX0FERCAxCQkvKiBPayB0byBhZGQgKi8KICNkZWZpbmUgQUREX0NBQ0hFX09LX1RPX1JFUExBQ0UgMgkvKiBPayB0byByZXBsYWNlIGZpbGUvZGlyZWN0b3J5ICovCiAjZGVmaW5lIEFERF9DQUNIRV9TS0lQX0RGQ0hFQ0sgNAkvKiBPayB0byBza2lwIERGIGNvbmZsaWN0IGNoZWNrcyAqLwpAQCAtODEyLDYgKzg0OCwyMyBAQAogI2RlZmluZSBSRUZSRVNIX0lOX1BPUkNFTEFJTgkweDAwMjAJLyogdXNlciBmcmllbmRseSBvdXRwdXQsIG5vdCAibmVlZHMgdXBkYXRlIiAqLwogI2RlZmluZSBSRUZSRVNIX1BST0dSRVNTCTB4MDA0MCAgLyogc2hvdyBwcm9ncmVzcyBiYXIgaWYgc3RkZXJyIGlzIHR0eSAqLwogaW50IHJlZnJlc2hfaW5kZXgoc3RydWN0IGluZGV4X3N0YXRlICosIHVuc2lnbmVkIGludCBmbGFncywgY29uc3Qgc3RydWN0IHBhdGhzcGVjICpwYXRoc3BlYywgY2hhciAqc2VlbiwgY29uc3QgY2hhciAqaGVhZGVyX21zZyk7CisvKgorICogUmVmcmVzaCB0aGUgaW5kZXggYW5kIHdyaXRlIGl0IHRvIGRpc2suCisgKgorICogJ3JlZnJlc2hfZmxhZ3MnIGlzIHBhc3NlZCBkaXJlY3RseSB0byAncmVmcmVzaF9pbmRleCgpJywgd2hpbGUKKyAqICdDT01NSVRfTE9DSyB8IHdyaXRlX2ZsYWdzJyBpcyBwYXNzZWQgdG8gJ3dyaXRlX2xvY2tlZF9pbmRleCgpJywgc28KKyAqIHRoZSBsb2NrZmlsZSBpcyBhbHdheXMgZWl0aGVyIGNvbW1pdHRlZCBvciByb2xsZWQgYmFjay4KKyAqCisgKiBJZiAnZ2VudGxlJyBpcyBwYXNzZWQsIGVycm9ycyBsb2NraW5nIHRoZSBpbmRleCBhcmUgaWdub3JlZC4KKyAqCisgKiBSZXR1cm4gMSBpZiByZWZyZXNoaW5nIHRoZSBpbmRleCByZXR1cm5zIGFuIGVycm9yLCAtMSBpZiB3cml0aW5nCisgKiB0aGUgaW5kZXggdG8gZGlzayBmYWlscywgMCBvbiBzdWNjZXNzLgorICoKKyAqIE5vdGUgdGhhdCBpZiByZWZyZXNoaW5nIHRoZSBpbmRleCByZXR1cm5zIGFuIGVycm9yLCB3ZSBzdGlsbCB3cml0ZQorICogb3V0IHRoZSBpbmRleCAodW5sZXNzIGxvY2tpbmcgZmFpbHMpLgorICovCitpbnQgcmVwb19yZWZyZXNoX2FuZF93cml0ZV9pbmRleChzdHJ1Y3QgcmVwb3NpdG9yeSosIHVuc2lnbmVkIGludCByZWZyZXNoX2ZsYWdzLCB1bnNpZ25lZCBpbnQgd3JpdGVfZmxhZ3MsIGludCBnZW50bGUsIGNvbnN0IHN0cnVjdCBwYXRoc3BlYyAqLCBjaGFyICpzZWVuLCBjb25zdCBjaGFyICpoZWFkZXJfbXNnKTsKKwogc3RydWN0IGNhY2hlX2VudHJ5ICpyZWZyZXNoX2NhY2hlX2VudHJ5KHN0cnVjdCBpbmRleF9zdGF0ZSAqLCBzdHJ1Y3QgY2FjaGVfZW50cnkgKiwgdW5zaWduZWQgaW50KTsKIAogdm9pZCBzZXRfYWx0ZXJuYXRlX2luZGV4X291dHB1dChjb25zdCBjaGFyICopOwpAQCAtOTM3LDggKzk5MCw2IEBACiAjZGVmaW5lIEdJVF9SRVBPX1ZFUlNJT04gMAogI2RlZmluZSBHSVRfUkVQT19WRVJTSU9OX1JFQUQgMQogZXh0ZXJuIGludCByZXBvc2l0b3J5X2Zvcm1hdF9wcmVjaW91c19vYmplY3RzOwotZXh0ZXJuIGNoYXIgKnJlcG9zaXRvcnlfZm9ybWF0X3BhcnRpYWxfY2xvbmU7Ci1leHRlcm4gY29uc3QgY2hhciAqY29yZV9wYXJ0aWFsX2Nsb25lX2ZpbHRlcl9kZWZhdWx0OwogZXh0ZXJuIGludCByZXBvc2l0b3J5X2Zvcm1hdF93b3JrdHJlZV9jb25maWc7CiAKIC8qCkBAIC0xMDI5LDcgKzEwODAsNiBAQAogaW50IHJlcG9fZmluZF91bmlxdWVfYWJicmV2X3Ioc3RydWN0IHJlcG9zaXRvcnkgKnIsIGNoYXIgKmhleCwgY29uc3Qgc3RydWN0IG9iamVjdF9pZCAqb2lkLCBpbnQgbGVuKTsKICNkZWZpbmUgZmluZF91bmlxdWVfYWJicmV2X3IoaGV4LCBvaWQsIGxlbikgcmVwb19maW5kX3VuaXF1ZV9hYmJyZXZfcih0aGVfcmVwb3NpdG9yeSwgaGV4LCBvaWQsIGxlbikKIAotZXh0ZXJuIGNvbnN0IHVuc2lnbmVkIGNoYXIgbnVsbF9zaGExW0dJVF9NQVhfUkFXU1pdOwogZXh0ZXJuIGNvbnN0IHN0cnVjdCBvYmplY3RfaWQgbnVsbF9vaWQ7CiAKIHN0YXRpYyBpbmxpbmUgaW50IGhhc2hjbXAoY29uc3QgdW5zaWduZWQgY2hhciAqc2hhMSwgY29uc3QgdW5zaWduZWQgY2hhciAqc2hhMikKQEAgLTEwNjQsMTQgKzExMTQsOSBAQAogCXJldHVybiBoYXNoZXEob2lkMS0+aGFzaCwgb2lkMi0+aGFzaCk7CiB9CiAKLXN0YXRpYyBpbmxpbmUgaW50IGlzX251bGxfc2hhMShjb25zdCB1bnNpZ25lZCBjaGFyICpzaGExKQotewotCXJldHVybiBoYXNoZXEoc2hhMSwgbnVsbF9zaGExKTsKLX0KLQogc3RhdGljIGlubGluZSBpbnQgaXNfbnVsbF9vaWQoY29uc3Qgc3RydWN0IG9iamVjdF9pZCAqb2lkKQogewotCXJldHVybiBoYXNoZXEob2lkLT5oYXNoLCBudWxsX3NoYTEpOworCXJldHVybiBvaWRlcShvaWQsICZudWxsX29pZCk7CiB9CiAKIHN0YXRpYyBpbmxpbmUgdm9pZCBoYXNoY3B5KHVuc2lnbmVkIGNoYXIgKnNoYV9kc3QsIGNvbnN0IHVuc2lnbmVkIGNoYXIgKnNoYV9zcmMpCkBAIC0xNDA2LDcgKzE0NTEsOCBAQAogaW50IGhleF90b19ieXRlcyh1bnNpZ25lZCBjaGFyICpiaW5hcnksIGNvbnN0IGNoYXIgKmhleCwgc2l6ZV90IGxlbik7CiAKIC8qCi0gKiBDb252ZXJ0IGEgYmluYXJ5IGhhc2ggdG8gaXRzIGhleCBlcXVpdmFsZW50LiBUaGUgYF9yYCB2YXJpYW50IGlzIHJlZW50cmFudCwKKyAqIENvbnZlcnQgYSBiaW5hcnkgaGFzaCBpbiAidW5zaWduZWQgY2hhciBbXSIgb3IgYW4gb2JqZWN0IG5hbWUgaW4KKyAqICJzdHJ1Y3Qgb2JqZWN0X2lkICoiIHRvIGl0cyBoZXggZXF1aXZhbGVudC4gVGhlIGBfcmAgdmFyaWFudCBpcyByZWVudHJhbnQsCiAgKiBhbmQgd3JpdGVzIHRoZSBOVUwtdGVybWluYXRlZCBvdXRwdXQgdG8gdGhlIGJ1ZmZlciBgb3V0YCwgd2hpY2ggbXVzdCBiZSBhdAogICogbGVhc3QgYEdJVF9NQVhfSEVYU1ogKyAxYCBieXRlcywgYW5kIHJldHVybnMgYSBwb2ludGVyIHRvIG91dCBmb3IKICAqIGNvbnZlbmllbmNlLgpAQCAtMTQxNCwxMyArMTQ2MCwxMiBAQAogICogVGhlIG5vbi1gX3JgIHZhcmlhbnQgcmV0dXJucyBhIHN0YXRpYyBidWZmZXIsIGJ1dCB1c2VzIGEgcmluZyBvZiA0CiAgKiBidWZmZXJzLCBtYWtpbmcgaXQgc2FmZSB0byBtYWtlIG11bHRpcGxlIGNhbGxzIGZvciBhIHNpbmdsZSBzdGF0ZW1lbnQsIGxpa2U6CiAgKgotICogICBwcmludGYoIiVzIC0+ICVzIiwgc2hhMV90b19oZXgob25lKSwgc2hhMV90b19oZXgodHdvKSk7CisgKiAgIHByaW50ZigiJXMgLT4gJXMiLCBoYXNoX3RvX2hleChvbmUpLCBoYXNoX3RvX2hleCh0d28pKTsKKyAqICAgcHJpbnRmKCIlcyAtPiAlcyIsIG9pZF90b19oZXgob25lKSwgb2lkX3RvX2hleCh0d28pKTsKICAqLwogY2hhciAqaGFzaF90b19oZXhfYWxnb3BfcihjaGFyICpidWZmZXIsIGNvbnN0IHVuc2lnbmVkIGNoYXIgKmhhc2gsIGNvbnN0IHN0cnVjdCBnaXRfaGFzaF9hbGdvICopOwotY2hhciAqc2hhMV90b19oZXhfcihjaGFyICpvdXQsIGNvbnN0IHVuc2lnbmVkIGNoYXIgKnNoYTEpOwogY2hhciAqb2lkX3RvX2hleF9yKGNoYXIgKm91dCwgY29uc3Qgc3RydWN0IG9iamVjdF9pZCAqb2lkKTsKIGNoYXIgKmhhc2hfdG9faGV4X2FsZ29wKGNvbnN0IHVuc2lnbmVkIGNoYXIgKmhhc2gsIGNvbnN0IHN0cnVjdCBnaXRfaGFzaF9hbGdvICopOwkvKiBzdGF0aWMgYnVmZmVyIHJlc3VsdCEgKi8KLWNoYXIgKnNoYTFfdG9faGV4KGNvbnN0IHVuc2lnbmVkIGNoYXIgKnNoYTEpOwkJCQkJCS8qIHNhbWUgc3RhdGljIGJ1ZmZlciAqLwogY2hhciAqaGFzaF90b19oZXgoY29uc3QgdW5zaWduZWQgY2hhciAqaGFzaCk7CQkJCQkJLyogc2FtZSBzdGF0aWMgYnVmZmVyICovCiBjaGFyICpvaWRfdG9faGV4KGNvbnN0IHN0cnVjdCBvYmplY3RfaWQgKm9pZCk7CQkJCQkJLyogc2FtZSBzdGF0aWMgYnVmZmVyICovCiAKQEAgLTE1MTYsOCArMTU2MSw3IEBACiBzdHJ1Y3QgZGF0ZV9tb2RlICpkYXRlX21vZGVfZnJvbV90eXBlKGVudW0gZGF0ZV9tb2RlX3R5cGUgdHlwZSk7CiAKIGNvbnN0IGNoYXIgKnNob3dfZGF0ZSh0aW1lc3RhbXBfdCB0aW1lLCBpbnQgdGltZXpvbmUsIGNvbnN0IHN0cnVjdCBkYXRlX21vZGUgKm1vZGUpOwotdm9pZCBzaG93X2RhdGVfcmVsYXRpdmUodGltZXN0YW1wX3QgdGltZSwgY29uc3Qgc3RydWN0IHRpbWV2YWwgKm5vdywKLQkJCXN0cnVjdCBzdHJidWYgKnRpbWVidWYpOwordm9pZCBzaG93X2RhdGVfcmVsYXRpdmUodGltZXN0YW1wX3QgdGltZSwgc3RydWN0IHN0cmJ1ZiAqdGltZWJ1Zik7CiB2b2lkIHNob3dfZGF0ZV9odW1hbih0aW1lc3RhbXBfdCB0aW1lLCBpbnQgdHosIGNvbnN0IHN0cnVjdCB0aW1ldmFsICpub3csCiAJCQlzdHJ1Y3Qgc3RyYnVmICp0aW1lYnVmKTsKIGludCBwYXJzZV9kYXRlKGNvbnN0IGNoYXIgKmRhdGUsIHN0cnVjdCBzdHJidWYgKm91dCk7CkBAIC0xNTI2LDcgKzE1NzAsNyBAQAogdm9pZCBkYXRlc3RhbXAoc3RydWN0IHN0cmJ1ZiAqb3V0KTsKICNkZWZpbmUgYXBwcm94aWRhdGUocykgYXBwcm94aWRhdGVfY2FyZWZ1bCgocyksIE5VTEwpCiB0aW1lc3RhbXBfdCBhcHByb3hpZGF0ZV9jYXJlZnVsKGNvbnN0IGNoYXIgKiwgaW50ICopOwotdGltZXN0YW1wX3QgYXBwcm94aWRhdGVfcmVsYXRpdmUoY29uc3QgY2hhciAqZGF0ZSwgY29uc3Qgc3RydWN0IHRpbWV2YWwgKm5vdyk7Cit0aW1lc3RhbXBfdCBhcHByb3hpZGF0ZV9yZWxhdGl2ZShjb25zdCBjaGFyICpkYXRlKTsKIHZvaWQgcGFyc2VfZGF0ZV9mb3JtYXQoY29uc3QgY2hhciAqZm9ybWF0LCBzdHJ1Y3QgZGF0ZV9tb2RlICptb2RlKTsKIGludCBkYXRlX292ZXJmbG93cyh0aW1lc3RhbXBfdCBkYXRlKTsKIApkaWZmIC0tZ2l0IGEvY2kvaW5zdGFsbC1kZXBlbmRlbmNpZXMuc2ggYi9jaS9pbnN0YWxsLWRlcGVuZGVuY2llcy5zaAppbmRleCA4Y2M3MjUwLi5iNmI0ZjQ3IDEwMDc1NQotLS0gYS9jaS9pbnN0YWxsLWRlcGVuZGVuY2llcy5zaAorKysgYi9jaS9pbnN0YWxsLWRlcGVuZGVuY2llcy5zaApAQCAtNDAsMjAgKzQwLDI4IEBACiAJdGVzdCAteiAiJEJSRVdfSU5TVEFMTF9QQUNLQUdFUyIgfHwKIAlicmV3IGluc3RhbGwgJEJSRVdfSU5TVEFMTF9QQUNLQUdFUwogCWJyZXcgbGluayAtLWZvcmNlIGdldHRleHQKKwlicmV3IGNhc2sgaW5zdGFsbCBwZXJmb3JjZSB8fCB7CisJCSMgVXBkYXRlIHRoZSBkZWZpbml0aW9ucyBhbmQgdHJ5IGFnYWluCisJCWNhc2tfcmVwbz0iJChicmV3IC0tcmVwb3NpdG9yeSkiL0xpYnJhcnkvVGFwcy9ob21lYnJldy9ob21lYnJldy1jYXNrICYmCisJCWdpdCAtQyAiJGNhc2tfcmVwbyIgcHVsbCAtLW5vLXN0YXQgJiYKKwkJYnJldyBjYXNrIGluc3RhbGwgcGVyZm9yY2UKKwl9IHx8CiAJYnJldyBpbnN0YWxsIGNhc2tyb29tL2Nhc2svcGVyZm9yY2UKIAljYXNlICIkam9ibmFtZSIgaW4KIAlvc3gtZ2NjKQorCQlicmV3IGxpbmsgZ2NjIHx8CiAJCWJyZXcgbGluayBnY2NAOAogCQk7OwogCWVzYWMKIAk7OwogU3RhdGljQW5hbHlzaXMpCiAJc3VkbyBhcHQtZ2V0IC1xIHVwZGF0ZQotCXN1ZG8gYXB0LWdldCAtcSAteSBpbnN0YWxsIGNvY2NpbmVsbGUKKwlzdWRvIGFwdC1nZXQgLXEgLXkgaW5zdGFsbCBjb2NjaW5lbGxlIGxpYmN1cmw0LW9wZW5zc2wtZGV2IGxpYnNzbC1kZXYgXAorCQlsaWJleHBhdC1kZXYgZ2V0dGV4dAogCTs7CiBEb2N1bWVudGF0aW9uKQogCXN1ZG8gYXB0LWdldCAtcSB1cGRhdGUKLQlzdWRvIGFwdC1nZXQgLXEgLXkgaW5zdGFsbCBhc2NpaWRvYyB4bWx0bworCXN1ZG8gYXB0LWdldCAtcSAteSBpbnN0YWxsIGFzY2lpZG9jIHhtbHRvIGRvY2Jvb2steHNsLW5zCiAKIAl0ZXN0IC1uICIkQUxSRUFEWV9IQVZFX0FTQ0lJRE9DVE9SIiB8fAogCWdlbSBpbnN0YWxsIC0tdmVyc2lvbiAxLjUuOCBhc2NpaWRvY3RvcgpkaWZmIC0tZ2l0IGEvY2kvbGliLnNoIGIvY2kvbGliLnNoCmluZGV4IDQ0ZGIyZDUuLjVmY2EwNDMgMTAwNzU1Ci0tLSBhL2NpL2xpYi5zaAorKysgYi9jaS9saWIuc2gKQEAgLTM0LDYgKzM0LDExIEBACiAjIHN1Y2Nlc3NmdWxseSBiZWZvcmUgKGUuZy4gYmVjYXVzZSB0aGUgYnJhbmNoIGdvdCByZWJhc2VkLCBjaGFuZ2luZyBvbmx5CiAjIHRoZSBjb21taXQgbWVzc2FnZXMpLgogc2tpcF9nb29kX3RyZWUgKCkgeworCWlmIHRlc3QgIiRUUkFWSVNfREVCVUdfTU9ERSIgPSB0cnVlCisJdGhlbgorCQlyZXR1cm4KKwlmaQorCiAJaWYgISBnb29kX3RyZWVfaW5mbz0iJChncmVwICJeJChnaXQgcmV2LXBhcnNlICRDSV9DT01NSVRee3RyZWV9KSAiICIkZ29vZF90cmVlc19maWxlIikiCiAJdGhlbgogCQkjIEhhdmVuJ3Qgc2VlbiB0aGlzIHRyZWUgeWV0LCBvciBubyBjYWNoZWQgZ29vZCB0cmVlcyBmaWxlIHlldC4KQEAgLTE1MSw3ICsxNTYsNyBAQAogCiBleHBvcnQgREVWRUxPUEVSPTEKIGV4cG9ydCBERUZBVUxUX1RFU1RfVEFSR0VUPXByb3ZlCi1leHBvcnQgR0lUX1RFU1RfQ0xPTkVfMkdCPVllc1BsZWFzZQorZXhwb3J0IEdJVF9URVNUX0NMT05FXzJHQj10cnVlCiAKIGNhc2UgIiRqb2JuYW1lIiBpbgogbGludXgtY2xhbmd8bGludXgtZ2NjKQpAQCAtMTYwLDcgKzE2NSw3IEBACiAJCWV4cG9ydCBDQz1nY2MtOAogCWZpCiAKLQlleHBvcnQgR0lUX1RFU1RfSFRUUEQ9WWVzUGxlYXNlCisJZXhwb3J0IEdJVF9URVNUX0hUVFBEPXRydWUKIAogCSMgVGhlIExpbnV4IGJ1aWxkIGluc3RhbGxzIHRoZSBkZWZpbmVkIGRlcGVuZGVuY3kgdmVyc2lvbnMgYmVsb3cuCiAJIyBUaGUgT1MgWCBidWlsZCBpbnN0YWxscyBtdWNoIG1vcmUgcmVjZW50IHZlcnNpb25zLCB3aGljaGV2ZXIKZGlmZiAtLWdpdCBhL2NpL3J1bi1zdGF0aWMtYW5hbHlzaXMuc2ggYi9jaS9ydW4tc3RhdGljLWFuYWx5c2lzLnNoCmluZGV4IGExOWFhN2UuLjY1YmNlYmQgMTAwNzU1Ci0tLSBhL2NpL3J1bi1zdGF0aWMtYW5hbHlzaXMuc2gKKysrIGIvY2kvcnVuLXN0YXRpYy1hbmFseXNpcy5zaApAQCAtMjYsNCArMjYsNyBAQAogCWV4aXQgMQogZmkKIAorbWFrZSBoZHItY2hlY2sgfHwKK2V4aXQgMQorCiBzYXZlX2dvb2RfdHJlZQpkaWZmIC0tZ2l0IGEvY2kvdGVzdC1kb2N1bWVudGF0aW9uLnNoIGIvY2kvdGVzdC1kb2N1bWVudGF0aW9uLnNoCmluZGV4IGQ0OTA4OTguLmIzZTc2ZWYgMTAwNzU1Ci0tLSBhL2NpL3Rlc3QtZG9jdW1lbnRhdGlvbi5zaAorKysgYi9jaS90ZXN0LWRvY3VtZW50YXRpb24uc2gKQEAgLTgsNiArOCw4IEBACiBmaWx0ZXJfbG9nICgpIHsKIAlzZWQgLWUgJy9eR0lUX1ZFUlNJT04gPSAvZCcgXAogCSAgICAtZSAnL14gICAgXCogbmV3IGFzY2lpZG9jIGZsYWdzJC9kJyBcCisJICAgIC1lICcvc3RyaXBwZWQgbmFtZXNwYWNlIGJlZm9yZSBwcm9jZXNzaW5nL2QnIFwKKwkgICAgLWUgJy9BdHRyaWJ1dGVkLipJRHMgZm9yIGVsZW1lbnQvZCcgXAogCSAgICAiJDEiCiB9CiAKZGlmZiAtLWdpdCBhL2NvbHVtbi5jIGIvY29sdW1uLmMKaW5kZXggN2ExN2MxNC4uNGEzOGVlZCAxMDA2NDQKLS0tIGEvY29sdW1uLmMKKysrIGIvY29sdW1uLmMKQEAgLTIzLDE4ICsyMyw3IEBACiAvKiByZXR1cm4gbGVuZ3RoIG9mICdzJyBpbiBsZXR0ZXJzLCBBTlNJIGVzY2FwZXMgc3RyaXBwZWQgKi8KIHN0YXRpYyBpbnQgaXRlbV9sZW5ndGgoY29uc3QgY2hhciAqcykKIHsKLQlpbnQgbGVuLCBpID0gMDsKLQlzdHJ1Y3Qgc3RyYnVmIHN0ciA9IFNUUkJVRl9JTklUOwotCi0Jc3RyYnVmX2FkZHN0cigmc3RyLCBzKTsKLQl3aGlsZSAoKHMgPSBzdHJzdHIoc3RyLmJ1ZiArIGksICJcMDMzWyIpKSAhPSBOVUxMKSB7Ci0JCWludCBsZW4gPSBzdHJzcG4ocyArIDIsICIwMTIzNDU2Nzg5OyIpOwotCQlpID0gcyAtIHN0ci5idWY7Ci0JCXN0cmJ1Zl9yZW1vdmUoJnN0ciwgaSwgbGVuICsgMyk7IC8qIFwwMzNbPGxlbj48ZnVuYyBjaGFyPiAqLwotCX0KLQlsZW4gPSB1dGY4X3N0cndpZHRoKHN0ci5idWYpOwotCXN0cmJ1Zl9yZWxlYXNlKCZzdHIpOwotCXJldHVybiBsZW47CisJcmV0dXJuIHV0Zjhfc3RybndpZHRoKHMsIC0xLCAxKTsKIH0KIAogLyoKZGlmZiAtLWdpdCBhL2NvbWJpbmUtZGlmZi5jIGIvY29tYmluZS1kaWZmLmMKaW5kZXggM2U0OWYzYi4uZDVjNGQ4MyAxMDA2NDQKLS0tIGEvY29tYmluZS1kaWZmLmMKKysrIGIvY29tYmluZS1kaWZmLmMKQEAgLTkzMCw3ICs5MzAsNyBAQAogCQkJCSBpbnQgc2hvd19maWxlX2hlYWRlcikKIHsKIAlzdHJ1Y3QgZGlmZl9vcHRpb25zICpvcHQgPSAmcmV2LT5kaWZmb3B0OwotCWludCBhYmJyZXYgPSBvcHQtPmZsYWdzLmZ1bGxfaW5kZXggPyBHSVRfU0hBMV9IRVhTWiA6IERFRkFVTFRfQUJCUkVWOworCWludCBhYmJyZXYgPSBvcHQtPmZsYWdzLmZ1bGxfaW5kZXggPyB0aGVfaGFzaF9hbGdvLT5oZXhzeiA6IERFRkFVTFRfQUJCUkVWOwogCWNvbnN0IGNoYXIgKmFfcHJlZml4ID0gb3B0LT5hX3ByZWZpeCA/IG9wdC0+YV9wcmVmaXggOiAiYS8iOwogCWNvbnN0IGNoYXIgKmJfcHJlZml4ID0gb3B0LT5iX3ByZWZpeCA/IG9wdC0+Yl9wcmVmaXggOiAiYi8iOwogCWNvbnN0IGNoYXIgKmNfbWV0YSA9IGRpZmZfZ2V0X2NvbG9yX29wdChvcHQsIERJRkZfTUVUQUlORk8pOwpkaWZmIC0tZ2l0IGEvY29tbWFuZC1saXN0LnR4dCBiL2NvbW1hbmQtbGlzdC50eHQKaW5kZXggYTlhYzcyYi4uNzJlNDM1YyAxMDA2NDQKLS0tIGEvY29tbWFuZC1saXN0LnR4dAorKysgYi9jb21tYW5kLWxpc3QudHh0CkBAIC0yMDMsNiArMjAzLDcgQEAKIGdpdG5hbWVzcGFjZXMgICAgICAgICAgICAgICAgICAgICAgICAgICBndWlkZQogZ2l0cmVwb3NpdG9yeS1sYXlvdXQgICAgICAgICAgICAgICAgICAgIGd1aWRlCiBnaXRyZXZpc2lvbnMgICAgICAgICAgICAgICAgICAgICAgICAgICAgZ3VpZGUKK2dpdHN1Ym1vZHVsZXMgICAgICAgICAgICAgICAgICAgICAgICAgICBndWlkZQogZ2l0dHV0b3JpYWwtMiAgICAgICAgICAgICAgICAgICAgICAgICAgIGd1aWRlCiBnaXR0dXRvcmlhbCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZ3VpZGUKIGdpdHdvcmtmbG93cyAgICAgICAgICAgICAgICAgICAgICAgICAgICBndWlkZQpkaWZmIC0tZ2l0IGEvY29tbWl0LWdyYXBoLmMgYi9jb21taXQtZ3JhcGguYwppbmRleCBmZTk1NGFiLi43OWJjNTY0IDEwMDY0NAotLS0gYS9jb21taXQtZ3JhcGguYworKysgYi9jb21taXQtZ3JhcGguYwpAQCAtNDEsNiArNDEsOSBAQAogI2RlZmluZSBHUkFQSF9NSU5fU0laRSAoR1JBUEhfSEVBREVSX1NJWkUgKyA0ICogR1JBUEhfQ0hVTktMT09LVVBfV0lEVEggXAogCQkJKyBHUkFQSF9GQU5PVVRfU0laRSArIHRoZV9oYXNoX2FsZ28tPnJhd3N6KQogCisvKiBSZW1lbWJlciB0byB1cGRhdGUgb2JqZWN0IGZsYWcgYWxsb2NhdGlvbiBpbiBvYmplY3QuaCAqLworI2RlZmluZSBSRUFDSEFCTEUgICAgICAgKDF1PDwxNSkKKwogY2hhciAqZ2V0X2NvbW1pdF9ncmFwaF9maWxlbmFtZShjb25zdCBjaGFyICpvYmpfZGlyKQogewogCWNoYXIgKmZpbGVuYW1lID0geHN0cmZtdCgiJXMvaW5mby9jb21taXQtZ3JhcGgiLCBvYmpfZGlyKTsKQEAgLTQ2MSwyNSArNDY0LDMyIEBACiAvKgogICogUmV0dXJuIDEgaWYgY29tbWl0X2dyYXBoIGlzIG5vbi1OVUxMLCBhbmQgMCBvdGhlcndpc2UuCiAgKgotICogT24gdGhlIGZpcnN0IGludm9jYXRpb24sIHRoaXMgZnVuY3Rpb24gYXR0ZW1wcyB0byBsb2FkIHRoZSBjb21taXQKKyAqIE9uIHRoZSBmaXJzdCBpbnZvY2F0aW9uLCB0aGlzIGZ1bmN0aW9uIGF0dGVtcHRzIHRvIGxvYWQgdGhlIGNvbW1pdAogICogZ3JhcGggaWYgdGhlX3JlcG9zaXRvcnkgaXMgY29uZmlndXJlZCB0byBoYXZlIG9uZS4KICAqLwogc3RhdGljIGludCBwcmVwYXJlX2NvbW1pdF9ncmFwaChzdHJ1Y3QgcmVwb3NpdG9yeSAqcikKIHsKIAlzdHJ1Y3Qgb2JqZWN0X2RpcmVjdG9yeSAqb2RiOwotCWludCBjb25maWdfdmFsdWU7CiAKLQlpZiAoZ2l0X2Vudl9ib29sKEdJVF9URVNUX0NPTU1JVF9HUkFQSF9ESUVfT05fTE9BRCwgMCkpCi0JCWRpZSgiZHlpbmcgYXMgcmVxdWVzdGVkIGJ5IHRoZSAnJXMnIHZhcmlhYmxlIG9uIGNvbW1pdC1ncmFwaCBsb2FkISIsCi0JCSAgICBHSVRfVEVTVF9DT01NSVRfR1JBUEhfRElFX09OX0xPQUQpOworCS8qCisJICogVGhpcyBtdXN0IGNvbWUgYmVmb3JlIHRoZSAiYWxyZWFkeSBhdHRlbXB0ZWQ/IiBjaGVjayBiZWxvdywgYmVjYXVzZQorCSAqIHdlIHdhbnQgdG8gZGlzYWJsZSBldmVuIGFuIGFscmVhZHktbG9hZGVkIGdyYXBoIGZpbGUuCisJICovCisJaWYgKHItPmNvbW1pdF9ncmFwaF9kaXNhYmxlZCkKKwkJcmV0dXJuIDA7CiAKIAlpZiAoci0+b2JqZWN0cy0+Y29tbWl0X2dyYXBoX2F0dGVtcHRlZCkKIAkJcmV0dXJuICEhci0+b2JqZWN0cy0+Y29tbWl0X2dyYXBoOwogCXItPm9iamVjdHMtPmNvbW1pdF9ncmFwaF9hdHRlbXB0ZWQgPSAxOwogCisJaWYgKGdpdF9lbnZfYm9vbChHSVRfVEVTVF9DT01NSVRfR1JBUEhfRElFX09OX0xPQUQsIDApKQorCQlkaWUoImR5aW5nIGFzIHJlcXVlc3RlZCBieSB0aGUgJyVzJyB2YXJpYWJsZSBvbiBjb21taXQtZ3JhcGggbG9hZCEiLAorCQkgICAgR0lUX1RFU1RfQ09NTUlUX0dSQVBIX0RJRV9PTl9MT0FEKTsKKworCXByZXBhcmVfcmVwb19zZXR0aW5ncyhyKTsKKwogCWlmICghZ2l0X2Vudl9ib29sKEdJVF9URVNUX0NPTU1JVF9HUkFQSCwgMCkgJiYKLQkgICAgKHJlcG9fY29uZmlnX2dldF9ib29sKHIsICJjb3JlLmNvbW1pdGdyYXBoIiwgJmNvbmZpZ192YWx1ZSkgfHwKLQkgICAgIWNvbmZpZ192YWx1ZSkpCisJICAgIHItPnNldHRpbmdzLmNvcmVfY29tbWl0X2dyYXBoICE9IDEpCiAJCS8qCiAJCSAqIFRoaXMgcmVwb3NpdG9yeSBpcyBub3QgY29uZmlndXJlZCB0byB1c2UgY29tbWl0IGdyYXBocywgc28KIAkJICogZG8gbm90IGxvYWQgb25lLiAoQnV0IHJlcG9ydCBjb21taXRfZ3JhcGhfYXR0ZW1wdGVkIGFueXdheQpAQCAtNzgzLDcgKzc5Myw4IEBACiAKIAl1bnNpZ25lZCBhcHBlbmQ6MSwKIAkJIHJlcG9ydF9wcm9ncmVzczoxLAotCQkgc3BsaXQ6MTsKKwkJIHNwbGl0OjEsCisJCSBjaGVja19vaWRzOjE7CiAKIAljb25zdCBzdHJ1Y3Qgc3BsaXRfY29tbWl0X2dyYXBoX29wdHMgKnNwbGl0X29wdHM7CiB9OwpAQCAtODM4LDEyICs4NDksMTYgQEAKIAogCXdoaWxlIChsaXN0IDwgbGFzdCkgewogCQlzdHJ1Y3QgY29tbWl0X2xpc3QgKnBhcmVudDsKKwkJc3RydWN0IG9iamVjdF9pZCAqdHJlZTsKIAkJaW50IGVkZ2VfdmFsdWU7CiAJCXVpbnQzMl90IHBhY2tlZERhdGVbMl07CiAJCWRpc3BsYXlfcHJvZ3Jlc3MoY3R4LT5wcm9ncmVzcywgKytjdHgtPnByb2dyZXNzX2NudCk7CiAKLQkJcGFyc2VfY29tbWl0X25vX2dyYXBoKCpsaXN0KTsKLQkJaGFzaHdyaXRlKGYsIGdldF9jb21taXRfdHJlZV9vaWQoKmxpc3QpLT5oYXNoLCBoYXNoX2xlbik7CisJCWlmIChwYXJzZV9jb21taXRfbm9fZ3JhcGgoKmxpc3QpKQorCQkJZGllKF8oInVuYWJsZSB0byBwYXJzZSBjb21taXQgJXMiKSwKKwkJCQlvaWRfdG9faGV4KCYoKmxpc3QpLT5vYmplY3Qub2lkKSk7CisJCXRyZWUgPSBnZXRfY29tbWl0X3RyZWVfb2lkKCpsaXN0KTsKKwkJaGFzaHdyaXRlKGYsIHRyZWUtPmhhc2gsIGhhc2hfbGVuKTsKIAogCQlwYXJlbnQgPSAoKmxpc3QpLT5wYXJlbnRzOwogCkBAIC0xMDE1LDExICsxMDMwLDExIEBACiB7CiAJc3RydWN0IGNvbW1pdF9saXN0ICpwYXJlbnQ7CiAJZm9yIChwYXJlbnQgPSBjb21taXQtPnBhcmVudHM7IHBhcmVudDsgcGFyZW50ID0gcGFyZW50LT5uZXh0KSB7Ci0JCWlmICghKHBhcmVudC0+aXRlbS0+b2JqZWN0LmZsYWdzICYgVU5JTlRFUkVTVElORykpIHsKKwkJaWYgKCEocGFyZW50LT5pdGVtLT5vYmplY3QuZmxhZ3MgJiBSRUFDSEFCTEUpKSB7CiAJCQlBTExPQ19HUk9XKGN0eC0+b2lkcy5saXN0LCBjdHgtPm9pZHMubnIgKyAxLCBjdHgtPm9pZHMuYWxsb2MpOwogCQkJb2lkY3B5KCZjdHgtPm9pZHMubGlzdFtjdHgtPm9pZHMubnJdLCAmKHBhcmVudC0+aXRlbS0+b2JqZWN0Lm9pZCkpOwogCQkJY3R4LT5vaWRzLm5yKys7Ci0JCQlwYXJlbnQtPml0ZW0tPm9iamVjdC5mbGFncyB8PSBVTklOVEVSRVNUSU5HOworCQkJcGFyZW50LT5pdGVtLT5vYmplY3QuZmxhZ3MgfD0gUkVBQ0hBQkxFOwogCQl9CiAJfQogfQpAQCAtMTAzNyw3ICsxMDUyLDcgQEAKIAkJZGlzcGxheV9wcm9ncmVzcyhjdHgtPnByb2dyZXNzLCBpICsgMSk7CiAJCWNvbW1pdCA9IGxvb2t1cF9jb21taXQoY3R4LT5yLCAmY3R4LT5vaWRzLmxpc3RbaV0pOwogCQlpZiAoY29tbWl0KQotCQkJY29tbWl0LT5vYmplY3QuZmxhZ3MgfD0gVU5JTlRFUkVTVElORzsKKwkJCWNvbW1pdC0+b2JqZWN0LmZsYWdzIHw9IFJFQUNIQUJMRTsKIAl9CiAJc3RvcF9wcm9ncmVzcygmY3R4LT5wcm9ncmVzcyk7CiAKQEAgLTEwNDksNyArMTA2NCw3IEBACiAJaWYgKGN0eC0+cmVwb3J0X3Byb2dyZXNzKQogCQljdHgtPnByb2dyZXNzID0gc3RhcnRfZGVsYXllZF9wcm9ncmVzcygKIAkJCQkJXygiRXhwYW5kaW5nIHJlYWNoYWJsZSBjb21taXRzIGluIGNvbW1pdCBncmFwaCIpLAotCQkJCQljdHgtPm9pZHMubnIpOworCQkJCQkwKTsKIAlmb3IgKGkgPSAwOyBpIDwgY3R4LT5vaWRzLm5yOyBpKyspIHsKIAkJZGlzcGxheV9wcm9ncmVzcyhjdHgtPnByb2dyZXNzLCBpICsgMSk7CiAJCWNvbW1pdCA9IGxvb2t1cF9jb21taXQoY3R4LT5yLCAmY3R4LT5vaWRzLmxpc3RbaV0pOwpAQCAtMTA3NCw3ICsxMDg5LDcgQEAKIAkJY29tbWl0ID0gbG9va3VwX2NvbW1pdChjdHgtPnIsICZjdHgtPm9pZHMubGlzdFtpXSk7CiAKIAkJaWYgKGNvbW1pdCkKLQkJCWNvbW1pdC0+b2JqZWN0LmZsYWdzICY9IH5VTklOVEVSRVNUSU5HOworCQkJY29tbWl0LT5vYmplY3QuZmxhZ3MgJj0gflJFQUNIQUJMRTsKIAl9CiAJc3RvcF9wcm9ncmVzcygmY3R4LT5wcm9ncmVzcyk7CiB9CkBAIC0xMTM0LDcgKzExNDksOCBAQAogCXJldHVybiAwOwogfQogCi1pbnQgd3JpdGVfY29tbWl0X2dyYXBoX3JlYWNoYWJsZShjb25zdCBjaGFyICpvYmpfZGlyLCB1bnNpZ25lZCBpbnQgZmxhZ3MsCitpbnQgd3JpdGVfY29tbWl0X2dyYXBoX3JlYWNoYWJsZShjb25zdCBjaGFyICpvYmpfZGlyLAorCQkJCSBlbnVtIGNvbW1pdF9ncmFwaF93cml0ZV9mbGFncyBmbGFncywKIAkJCQkgY29uc3Qgc3RydWN0IHNwbGl0X2NvbW1pdF9ncmFwaF9vcHRzICpzcGxpdF9vcHRzKQogewogCXN0cnVjdCBzdHJpbmdfbGlzdCBsaXN0ID0gU1RSSU5HX0xJU1RfSU5JVF9EVVA7CkBAIC0xMTkzLDggKzEyMDksOCBAQAogCXJldHVybiAwOwogfQogCi1zdGF0aWMgdm9pZCBmaWxsX29pZHNfZnJvbV9jb21taXRfaGV4KHN0cnVjdCB3cml0ZV9jb21taXRfZ3JhcGhfY29udGV4dCAqY3R4LAotCQkJCSAgICAgIHN0cnVjdCBzdHJpbmdfbGlzdCAqY29tbWl0X2hleCkKK3N0YXRpYyBpbnQgZmlsbF9vaWRzX2Zyb21fY29tbWl0X2hleChzdHJ1Y3Qgd3JpdGVfY29tbWl0X2dyYXBoX2NvbnRleHQgKmN0eCwKKwkJCQkgICAgIHN0cnVjdCBzdHJpbmdfbGlzdCAqY29tbWl0X2hleCkKIHsKIAl1aW50MzJfdCBpOwogCXN0cnVjdCBzdHJidWYgcHJvZ3Jlc3NfdGl0bGUgPSBTVFJCVUZfSU5JVDsKQEAgLTEyMTUsMjAgKzEyMzEsMjEgQEAKIAkJc3RydWN0IGNvbW1pdCAqcmVzdWx0OwogCiAJCWRpc3BsYXlfcHJvZ3Jlc3MoY3R4LT5wcm9ncmVzcywgaSArIDEpOwotCQlpZiAoY29tbWl0X2hleC0+aXRlbXNbaV0uc3RyaW5nICYmCi0JCSAgICBwYXJzZV9vaWRfaGV4KGNvbW1pdF9oZXgtPml0ZW1zW2ldLnN0cmluZywgJm9pZCwgJmVuZCkpCi0JCQljb250aW51ZTsKLQotCQlyZXN1bHQgPSBsb29rdXBfY29tbWl0X3JlZmVyZW5jZV9nZW50bHkoY3R4LT5yLCAmb2lkLCAxKTsKLQotCQlpZiAocmVzdWx0KSB7CisJCWlmICghcGFyc2Vfb2lkX2hleChjb21taXRfaGV4LT5pdGVtc1tpXS5zdHJpbmcsICZvaWQsICZlbmQpICYmCisJCSAgICAocmVzdWx0ID0gbG9va3VwX2NvbW1pdF9yZWZlcmVuY2VfZ2VudGx5KGN0eC0+ciwgJm9pZCwgMSkpKSB7CiAJCQlBTExPQ19HUk9XKGN0eC0+b2lkcy5saXN0LCBjdHgtPm9pZHMubnIgKyAxLCBjdHgtPm9pZHMuYWxsb2MpOwogCQkJb2lkY3B5KCZjdHgtPm9pZHMubGlzdFtjdHgtPm9pZHMubnJdLCAmKHJlc3VsdC0+b2JqZWN0Lm9pZCkpOwogCQkJY3R4LT5vaWRzLm5yKys7CisJCX0gZWxzZSBpZiAoY3R4LT5jaGVja19vaWRzKSB7CisJCQllcnJvcihfKCJpbnZhbGlkIGNvbW1pdCBvYmplY3QgaWQ6ICVzIiksCisJCQkgICAgY29tbWl0X2hleC0+aXRlbXNbaV0uc3RyaW5nKTsKKwkJCXJldHVybiAtMTsKIAkJfQogCX0KIAlzdG9wX3Byb2dyZXNzKCZjdHgtPnByb2dyZXNzKTsKIAlzdHJidWZfcmVsZWFzZSgmcHJvZ3Jlc3NfdGl0bGUpOworCisJcmV0dXJuIDA7CiB9CiAKIHN0YXRpYyB2b2lkIGZpbGxfb2lkc19mcm9tX2FsbF9wYWNrcyhzdHJ1Y3Qgd3JpdGVfY29tbWl0X2dyYXBoX2NvbnRleHQgKmN0eCkKQEAgLTEyNzYsNyArMTI5Myw2IEBACiBzdGF0aWMgdm9pZCBjb3B5X29pZHNfdG9fY29tbWl0cyhzdHJ1Y3Qgd3JpdGVfY29tbWl0X2dyYXBoX2NvbnRleHQgKmN0eCkKIHsKIAl1aW50MzJfdCBpOwotCXN0cnVjdCBjb21taXRfbGlzdCAqcGFyZW50OwogCiAJY3R4LT5udW1fZXh0cmFfZWRnZXMgPSAwOwogCWlmIChjdHgtPnJlcG9ydF9wcm9ncmVzcykKQEAgLTEyODQsNyArMTMwMCw4IEBACiAJCQlfKCJGaW5kaW5nIGV4dHJhIGVkZ2VzIGluIGNvbW1pdCBncmFwaCIpLAogCQkJY3R4LT5vaWRzLm5yKTsKIAlmb3IgKGkgPSAwOyBpIDwgY3R4LT5vaWRzLm5yOyBpKyspIHsKLQkJaW50IG51bV9wYXJlbnRzID0gMDsKKwkJdW5zaWduZWQgaW50IG51bV9wYXJlbnRzOworCiAJCWRpc3BsYXlfcHJvZ3Jlc3MoY3R4LT5wcm9ncmVzcywgaSArIDEpOwogCQlpZiAoaSA+IDAgJiYgb2lkZXEoJmN0eC0+b2lkcy5saXN0W2kgLSAxXSwgJmN0eC0+b2lkcy5saXN0W2ldKSkKIAkJCWNvbnRpbnVlOwpAQCAtMTI5OCwxMCArMTMxNSw3IEBACiAKIAkJcGFyc2VfY29tbWl0X25vX2dyYXBoKGN0eC0+Y29tbWl0cy5saXN0W2N0eC0+Y29tbWl0cy5ucl0pOwogCi0JCWZvciAocGFyZW50ID0gY3R4LT5jb21taXRzLmxpc3RbY3R4LT5jb21taXRzLm5yXS0+cGFyZW50czsKLQkJICAgICBwYXJlbnQ7IHBhcmVudCA9IHBhcmVudC0+bmV4dCkKLQkJCW51bV9wYXJlbnRzKys7Ci0KKwkJbnVtX3BhcmVudHMgPSBjb21taXRfbGlzdF9jb3VudChjdHgtPmNvbW1pdHMubGlzdFtjdHgtPmNvbW1pdHMubnJdLT5wYXJlbnRzKTsKIAkJaWYgKG51bV9wYXJlbnRzID4gMikKIAkJCWN0eC0+bnVtX2V4dHJhX2VkZ2VzICs9IG51bV9wYXJlbnRzIC0gMTsKIApAQCAtMTUxOSw4ICsxNTMzLDggQEAKIAogc3RhdGljIHZvaWQgc3BsaXRfZ3JhcGhfbWVyZ2Vfc3RyYXRlZ3koc3RydWN0IHdyaXRlX2NvbW1pdF9ncmFwaF9jb250ZXh0ICpjdHgpCiB7Ci0Jc3RydWN0IGNvbW1pdF9ncmFwaCAqZyA9IGN0eC0+ci0+b2JqZWN0cy0+Y29tbWl0X2dyYXBoOwotCXVpbnQzMl90IG51bV9jb21taXRzID0gY3R4LT5jb21taXRzLm5yOworCXN0cnVjdCBjb21taXRfZ3JhcGggKmc7CisJdWludDMyX3QgbnVtX2NvbW1pdHM7CiAJdWludDMyX3QgaTsKIAogCWludCBtYXhfY29tbWl0cyA9IDA7CkBAIC0xNTMyLDYgKzE1NDYsNyBAQAogCX0KIAogCWcgPSBjdHgtPnItPm9iamVjdHMtPmNvbW1pdF9ncmFwaDsKKwludW1fY29tbWl0cyA9IGN0eC0+Y29tbWl0cy5ucjsKIAljdHgtPm51bV9jb21taXRfZ3JhcGhzX2FmdGVyID0gY3R4LT5udW1fY29tbWl0X2dyYXBoc19iZWZvcmUgKyAxOwogCiAJd2hpbGUgKGcgJiYgKGctPm51bV9jb21taXRzIDw9IHNpemVfbXVsdCAqIG51bV9jb21taXRzIHx8CkBAIC0xNjEzLDggKzE2MjgsNyBAQAogCiBzdGF0aWMgdm9pZCBzb3J0X2FuZF9zY2FuX21lcmdlZF9jb21taXRzKHN0cnVjdCB3cml0ZV9jb21taXRfZ3JhcGhfY29udGV4dCAqY3R4KQogewotCXVpbnQzMl90IGksIG51bV9wYXJlbnRzOwotCXN0cnVjdCBjb21taXRfbGlzdCAqcGFyZW50OworCXVpbnQzMl90IGk7CiAKIAlpZiAoY3R4LT5yZXBvcnRfcHJvZ3Jlc3MpCiAJCWN0eC0+cHJvZ3Jlc3MgPSBzdGFydF9kZWxheWVkX3Byb2dyZXNzKApAQCAtMTYzMiwxMCArMTY0Niw5IEBACiAJCQlkaWUoXygidW5leHBlY3RlZCBkdXBsaWNhdGUgY29tbWl0IGlkICVzIiksCiAJCQkgICAgb2lkX3RvX2hleCgmY3R4LT5jb21taXRzLmxpc3RbaV0tPm9iamVjdC5vaWQpKTsKIAkJfSBlbHNlIHsKLQkJCW51bV9wYXJlbnRzID0gMDsKLQkJCWZvciAocGFyZW50ID0gY3R4LT5jb21taXRzLmxpc3RbaV0tPnBhcmVudHM7IHBhcmVudDsgcGFyZW50ID0gcGFyZW50LT5uZXh0KQotCQkJCW51bV9wYXJlbnRzKys7CisJCQl1bnNpZ25lZCBpbnQgbnVtX3BhcmVudHM7CiAKKwkJCW51bV9wYXJlbnRzID0gY29tbWl0X2xpc3RfY291bnQoY3R4LT5jb21taXRzLmxpc3RbaV0tPnBhcmVudHMpOwogCQkJaWYgKG51bV9wYXJlbnRzID4gMikKIAkJCQljdHgtPm51bV9leHRyYV9lZGdlcyArPSBudW1fcGFyZW50cyAtIDE7CiAJCX0KQEAgLTE3NTIsNyArMTc2NSw3IEBACiBpbnQgd3JpdGVfY29tbWl0X2dyYXBoKGNvbnN0IGNoYXIgKm9ial9kaXIsCiAJCSAgICAgICBzdHJ1Y3Qgc3RyaW5nX2xpc3QgKnBhY2tfaW5kZXhlcywKIAkJICAgICAgIHN0cnVjdCBzdHJpbmdfbGlzdCAqY29tbWl0X2hleCwKLQkJICAgICAgIHVuc2lnbmVkIGludCBmbGFncywKKwkJICAgICAgIGVudW0gY29tbWl0X2dyYXBoX3dyaXRlX2ZsYWdzIGZsYWdzLAogCQkgICAgICAgY29uc3Qgc3RydWN0IHNwbGl0X2NvbW1pdF9ncmFwaF9vcHRzICpzcGxpdF9vcHRzKQogewogCXN0cnVjdCB3cml0ZV9jb21taXRfZ3JhcGhfY29udGV4dCAqY3R4OwpAQCAtMTc3Myw5ICsxNzg2LDEwIEBACiAJaWYgKGxlbiAmJiBjdHgtPm9ial9kaXJbbGVuIC0gMV0gPT0gJy8nKQogCQljdHgtPm9ial9kaXJbbGVuIC0gMV0gPSAwOwogCi0JY3R4LT5hcHBlbmQgPSBmbGFncyAmIENPTU1JVF9HUkFQSF9BUFBFTkQgPyAxIDogMDsKLQljdHgtPnJlcG9ydF9wcm9ncmVzcyA9IGZsYWdzICYgQ09NTUlUX0dSQVBIX1BST0dSRVNTID8gMSA6IDA7Ci0JY3R4LT5zcGxpdCA9IGZsYWdzICYgQ09NTUlUX0dSQVBIX1NQTElUID8gMSA6IDA7CisJY3R4LT5hcHBlbmQgPSBmbGFncyAmIENPTU1JVF9HUkFQSF9XUklURV9BUFBFTkQgPyAxIDogMDsKKwljdHgtPnJlcG9ydF9wcm9ncmVzcyA9IGZsYWdzICYgQ09NTUlUX0dSQVBIX1dSSVRFX1BST0dSRVNTID8gMSA6IDA7CisJY3R4LT5zcGxpdCA9IGZsYWdzICYgQ09NTUlUX0dSQVBIX1dSSVRFX1NQTElUID8gMSA6IDA7CisJY3R4LT5jaGVja19vaWRzID0gZmxhZ3MgJiBDT01NSVRfR1JBUEhfV1JJVEVfQ0hFQ0tfT0lEUyA/IDEgOiAwOwogCWN0eC0+c3BsaXRfb3B0cyA9IHNwbGl0X29wdHM7CiAKIAlpZiAoY3R4LT5zcGxpdCkgewpAQCAtMTgzMCw4ICsxODQ0LDEwIEBACiAJCQlnb3RvIGNsZWFudXA7CiAJfQogCi0JaWYgKGNvbW1pdF9oZXgpCi0JCWZpbGxfb2lkc19mcm9tX2NvbW1pdF9oZXgoY3R4LCBjb21taXRfaGV4KTsKKwlpZiAoY29tbWl0X2hleCkgeworCQlpZiAoKHJlcyA9IGZpbGxfb2lkc19mcm9tX2NvbW1pdF9oZXgoY3R4LCBjb21taXRfaGV4KSkpCisJCQlnb3RvIGNsZWFudXA7CisJfQogCiAJaWYgKCFwYWNrX2luZGV4ZXMgJiYgIWNvbW1pdF9oZXgpCiAJCWZpbGxfb2lkc19mcm9tX2FsbF9wYWNrcyhjdHgpOwpAQCAtMTk4Niw4ICsyMDAyLDEwIEBACiAJaWYgKHZlcmlmeV9jb21taXRfZ3JhcGhfZXJyb3IgJiB+VkVSSUZZX0NPTU1JVF9HUkFQSF9FUlJPUl9IQVNIKQogCQlyZXR1cm4gdmVyaWZ5X2NvbW1pdF9ncmFwaF9lcnJvcjsKIAotCXByb2dyZXNzID0gc3RhcnRfcHJvZ3Jlc3MoXygiVmVyaWZ5aW5nIGNvbW1pdHMgaW4gY29tbWl0IGdyYXBoIiksCi0JCQkJICBnLT5udW1fY29tbWl0cyk7CisJaWYgKGZsYWdzICYgQ09NTUlUX0dSQVBIX1dSSVRFX1BST0dSRVNTKQorCQlwcm9ncmVzcyA9IHN0YXJ0X3Byb2dyZXNzKF8oIlZlcmlmeWluZyBjb21taXRzIGluIGNvbW1pdCBncmFwaCIpLAorCQkJCQlnLT5udW1fY29tbWl0cyk7CisKIAlmb3IgKGkgPSAwOyBpIDwgZy0+bnVtX2NvbW1pdHM7IGkrKykgewogCQlzdHJ1Y3QgY29tbWl0ICpncmFwaF9jb21taXQsICpvZGJfY29tbWl0OwogCQlzdHJ1Y3QgY29tbWl0X2xpc3QgKmdyYXBoX3BhcmVudHMsICpvZGJfcGFyZW50czsKQEAgLTIwOTUsMyArMjExMyw4IEBACiAJZnJlZShnLT5maWxlbmFtZSk7CiAJZnJlZShnKTsKIH0KKwordm9pZCBkaXNhYmxlX2NvbW1pdF9ncmFwaChzdHJ1Y3QgcmVwb3NpdG9yeSAqcikKK3sKKwlyLT5jb21taXRfZ3JhcGhfZGlzYWJsZWQgPSAxOworfQpkaWZmIC0tZ2l0IGEvY29tbWl0LWdyYXBoLmggYi9jb21taXQtZ3JhcGguaAppbmRleCBkZjlhM2IyLi43ZjVjOTMzIDEwMDY0NAotLS0gYS9jb21taXQtZ3JhcGguaAorKysgYi9jb21taXQtZ3JhcGguaApAQCAtNzEsOSArNzEsMTMgQEAKICAqLwogaW50IGdlbmVyYXRpb25fbnVtYmVyc19lbmFibGVkKHN0cnVjdCByZXBvc2l0b3J5ICpyKTsKIAotI2RlZmluZSBDT01NSVRfR1JBUEhfQVBQRU5EICAgICAoMSA8PCAwKQotI2RlZmluZSBDT01NSVRfR1JBUEhfUFJPR1JFU1MgICAoMSA8PCAxKQotI2RlZmluZSBDT01NSVRfR1JBUEhfU1BMSVQgICAgICAoMSA8PCAyKQorZW51bSBjb21taXRfZ3JhcGhfd3JpdGVfZmxhZ3MgeworCUNPTU1JVF9HUkFQSF9XUklURV9BUFBFTkQgICAgID0gKDEgPDwgMCksCisJQ09NTUlUX0dSQVBIX1dSSVRFX1BST0dSRVNTICAgPSAoMSA8PCAxKSwKKwlDT01NSVRfR1JBUEhfV1JJVEVfU1BMSVQgICAgICA9ICgxIDw8IDIpLAorCS8qIE1ha2Ugc3VyZSB0aGF0IGVhY2ggT0lEIGluIHRoZSBpbnB1dCBpcyBhIHZhbGlkIGNvbW1pdCBPSUQuICovCisJQ09NTUlUX0dSQVBIX1dSSVRFX0NIRUNLX09JRFMgPSAoMSA8PCAzKQorfTsKIAogc3RydWN0IHNwbGl0X2NvbW1pdF9ncmFwaF9vcHRzIHsKIAlpbnQgc2l6ZV9tdWx0aXBsZTsKQEAgLTg3LDEyICs5MSwxMyBAQAogICogaXMgbm90IGNvbXBhdGlibGUgd2l0aCB0aGUgY29tbWl0LWdyYXBoIGZlYXR1cmUsIHRoZW4gdGhlCiAgKiBtZXRob2RzIHdpbGwgcmV0dXJuIDAgd2l0aG91dCB3cml0aW5nIGEgY29tbWl0LWdyYXBoLgogICovCi1pbnQgd3JpdGVfY29tbWl0X2dyYXBoX3JlYWNoYWJsZShjb25zdCBjaGFyICpvYmpfZGlyLCB1bnNpZ25lZCBpbnQgZmxhZ3MsCitpbnQgd3JpdGVfY29tbWl0X2dyYXBoX3JlYWNoYWJsZShjb25zdCBjaGFyICpvYmpfZGlyLAorCQkJCSBlbnVtIGNvbW1pdF9ncmFwaF93cml0ZV9mbGFncyBmbGFncywKIAkJCQkgY29uc3Qgc3RydWN0IHNwbGl0X2NvbW1pdF9ncmFwaF9vcHRzICpzcGxpdF9vcHRzKTsKIGludCB3cml0ZV9jb21taXRfZ3JhcGgoY29uc3QgY2hhciAqb2JqX2RpciwKIAkJICAgICAgIHN0cnVjdCBzdHJpbmdfbGlzdCAqcGFja19pbmRleGVzLAogCQkgICAgICAgc3RydWN0IHN0cmluZ19saXN0ICpjb21taXRfaGV4LAotCQkgICAgICAgdW5zaWduZWQgaW50IGZsYWdzLAorCQkgICAgICAgZW51bSBjb21taXRfZ3JhcGhfd3JpdGVfZmxhZ3MgZmxhZ3MsCiAJCSAgICAgICBjb25zdCBzdHJ1Y3Qgc3BsaXRfY29tbWl0X2dyYXBoX29wdHMgKnNwbGl0X29wdHMpOwogCiAjZGVmaW5lIENPTU1JVF9HUkFQSF9WRVJJRllfU0hBTExPVwkoMSA8PCAwKQpAQCAtMTAyLDQgKzEwNywxMCBAQAogdm9pZCBjbG9zZV9jb21taXRfZ3JhcGgoc3RydWN0IHJhd19vYmplY3Rfc3RvcmUgKik7CiB2b2lkIGZyZWVfY29tbWl0X2dyYXBoKHN0cnVjdCBjb21taXRfZ3JhcGggKik7CiAKKy8qCisgKiBEaXNhYmxlIGZ1cnRoZXIgdXNlIG9mIHRoZSBjb21taXQgZ3JhcGggaW4gdGhpcyBwcm9jZXNzIHdoZW4gcGFyc2luZyBhCisgKiAic3RydWN0IGNvbW1pdCIuCisgKi8KK3ZvaWQgZGlzYWJsZV9jb21taXRfZ3JhcGgoc3RydWN0IHJlcG9zaXRvcnkgKnIpOworCiAjZW5kaWYKZGlmZiAtLWdpdCBhL2NvbW1pdC1yZWFjaC5jIGIvY29tbWl0LXJlYWNoLmMKaW5kZXggM2VhMTc0Ny4uNGNhN2U3MCAxMDA2NDQKLS0tIGEvY29tbWl0LXJlYWNoLmMKKysrIGIvY29tbWl0LXJlYWNoLmMKQEAgLTEwLDcgKzEwLDYgQEAKICNpbmNsdWRlICJjb21taXQtcmVhY2guaCIKIAogLyogUmVtZW1iZXIgdG8gdXBkYXRlIG9iamVjdCBmbGFnIGFsbG9jYXRpb24gaW4gb2JqZWN0LmggKi8KLSNkZWZpbmUgUkVBQ0hBQkxFICAgICAgICgxdTw8MTUpCiAjZGVmaW5lIFBBUkVOVDEJCSgxdTw8MTYpCiAjZGVmaW5lIFBBUkVOVDIJCSgxdTw8MTcpCiAjZGVmaW5lIFNUQUxFCQkoMXU8PDE4KQpkaWZmIC0tZ2l0IGEvY29tbWl0LmMgYi9jb21taXQuYwppbmRleCBhOThkZTE2Li40MzRlYzAzIDEwMDY0NAotLS0gYS9jb21taXQuYworKysgYi9jb21taXQuYwpAQCAtMTksNiArMTksNyBAQAogI2luY2x1ZGUgImFkdmljZS5oIgogI2luY2x1ZGUgInJlZnMuaCIKICNpbmNsdWRlICJjb21taXQtcmVhY2guaCIKKyNpbmNsdWRlICJydW4tY29tbWFuZC5oIgogCiBzdGF0aWMgc3RydWN0IGNvbW1pdF9leHRyYV9oZWFkZXIgKnJlYWRfY29tbWl0X2V4dHJhX2hlYWRlcl9saW5lcyhjb25zdCBjaGFyICpidWYsIHNpemVfdCBsZW4sIGNvbnN0IGNoYXIgKiopOwogCkBAIC0zNTgsMTQgKzM1OSwxNSBAQAogCiBzdHJ1Y3Qgb2JqZWN0X2lkICpnZXRfY29tbWl0X3RyZWVfb2lkKGNvbnN0IHN0cnVjdCBjb21taXQgKmNvbW1pdCkKIHsKLQlyZXR1cm4gJmdldF9jb21taXRfdHJlZShjb21taXQpLT5vYmplY3Qub2lkOworCXN0cnVjdCB0cmVlICp0cmVlID0gZ2V0X2NvbW1pdF90cmVlKGNvbW1pdCk7CisJcmV0dXJuIHRyZWUgPyAmdHJlZS0+b2JqZWN0Lm9pZCA6IE5VTEw7CiB9CiAKIHZvaWQgcmVsZWFzZV9jb21taXRfbWVtb3J5KHN0cnVjdCBwYXJzZWRfb2JqZWN0X3Bvb2wgKnBvb2wsIHN0cnVjdCBjb21taXQgKmMpCiB7CiAJc2V0X2NvbW1pdF90cmVlKGMsIE5VTEwpOwotCWMtPmluZGV4ID0gMDsKIAlmcmVlX2NvbW1pdF9idWZmZXIocG9vbCwgYyk7CisJYy0+aW5kZXggPSAwOwogCWZyZWVfY29tbWl0X2xpc3QoYy0+cGFyZW50cyk7CiAKIAljLT5vYmplY3QucGFyc2VkID0gMDsKQEAgLTQwMCwxMCArNDAyLDIyIEBACiAJc3RydWN0IGNvbW1pdF9ncmFmdCAqZ3JhZnQ7CiAJY29uc3QgaW50IHRyZWVfZW50cnlfbGVuID0gdGhlX2hhc2hfYWxnby0+aGV4c3ogKyA1OwogCWNvbnN0IGludCBwYXJlbnRfZW50cnlfbGVuID0gdGhlX2hhc2hfYWxnby0+aGV4c3ogKyA3OworCXN0cnVjdCB0cmVlICp0cmVlOwogCiAJaWYgKGl0ZW0tPm9iamVjdC5wYXJzZWQpCiAJCXJldHVybiAwOwotCWl0ZW0tPm9iamVjdC5wYXJzZWQgPSAxOworCisJaWYgKGl0ZW0tPnBhcmVudHMpIHsKKwkJLyoKKwkJICogUHJlc3VtYWJseSB0aGlzIGlzIGxlZnRvdmVyIGZyb20gYW4gZWFybGllciBmYWlsZWQgcGFyc2U7CisJCSAqIGNsZWFyIGl0IG91dCBpbiBwcmVwYXJhdGlvbiBmb3IgdXMgcmUtcGFyc2luZyAod2UnbGwgaGl0IHRoZQorCQkgKiBzYW1lIGVycm9yLCBidXQgdGhhdCdzIGdvb2QsIHNpbmNlIGl0IGxldHMgb3VyIGNhbGxlciBrbm93CisJCSAqIHRoZSByZXN1bHQgY2Fubm90IGJlIHRydXN0ZWQuCisJCSAqLworCQlmcmVlX2NvbW1pdF9saXN0KGl0ZW0tPnBhcmVudHMpOworCQlpdGVtLT5wYXJlbnRzID0gTlVMTDsKKwl9CisKIAl0YWlsICs9IHNpemU7CiAJaWYgKHRhaWwgPD0gYnVmcHRyICsgdHJlZV9lbnRyeV9sZW4gKyAxIHx8IG1lbWNtcChidWZwdHIsICJ0cmVlICIsIDUpIHx8CiAJCQlidWZwdHJbdHJlZV9lbnRyeV9sZW5dICE9ICdcbicpCkBAIC00MTEsNyArNDI1LDEyIEBACiAJaWYgKGdldF9vaWRfaGV4KGJ1ZnB0ciArIDUsICZwYXJlbnQpIDwgMCkKIAkJcmV0dXJuIGVycm9yKCJiYWQgdHJlZSBwb2ludGVyIGluIGNvbW1pdCAlcyIsCiAJCQkgICAgIG9pZF90b19oZXgoJml0ZW0tPm9iamVjdC5vaWQpKTsKLQlzZXRfY29tbWl0X3RyZWUoaXRlbSwgbG9va3VwX3RyZWUociwgJnBhcmVudCkpOworCXRyZWUgPSBsb29rdXBfdHJlZShyLCAmcGFyZW50KTsKKwlpZiAoIXRyZWUpCisJCXJldHVybiBlcnJvcigiYmFkIHRyZWUgcG9pbnRlciAlcyBpbiBjb21taXQgJXMiLAorCQkJICAgICBvaWRfdG9faGV4KCZwYXJlbnQpLAorCQkJICAgICBvaWRfdG9faGV4KCZpdGVtLT5vYmplY3Qub2lkKSk7CisJc2V0X2NvbW1pdF90cmVlKGl0ZW0sIHRyZWUpOwogCWJ1ZnB0ciArPSB0cmVlX2VudHJ5X2xlbiArIDE7IC8qICJ0cmVlICIgKyAiaGV4IHNoYTEiICsgIlxuIiAqLwogCXBwdHIgPSAmaXRlbS0+cGFyZW50czsKIApAQCAtNDMxLDggKzQ1MCwxMSBAQAogCQlpZiAoZ3JhZnQgJiYgKGdyYWZ0LT5ucl9wYXJlbnQgPCAwIHx8IGdyYWZ0c19yZXBsYWNlX3BhcmVudHMpKQogCQkJY29udGludWU7CiAJCW5ld19wYXJlbnQgPSBsb29rdXBfY29tbWl0KHIsICZwYXJlbnQpOwotCQlpZiAobmV3X3BhcmVudCkKLQkJCXBwdHIgPSAmY29tbWl0X2xpc3RfaW5zZXJ0KG5ld19wYXJlbnQsIHBwdHIpLT5uZXh0OworCQlpZiAoIW5ld19wYXJlbnQpCisJCQlyZXR1cm4gZXJyb3IoImJhZCBwYXJlbnQgJXMgaW4gY29tbWl0ICVzIiwKKwkJCQkgICAgIG9pZF90b19oZXgoJnBhcmVudCksCisJCQkJICAgICBvaWRfdG9faGV4KCZpdGVtLT5vYmplY3Qub2lkKSk7CisJCXBwdHIgPSAmY29tbWl0X2xpc3RfaW5zZXJ0KG5ld19wYXJlbnQsIHBwdHIpLT5uZXh0OwogCX0KIAlpZiAoZ3JhZnQpIHsKIAkJaW50IGk7CkBAIC00NDEsNyArNDYzLDkgQEAKIAkJCW5ld19wYXJlbnQgPSBsb29rdXBfY29tbWl0KHIsCiAJCQkJCQkgICAmZ3JhZnQtPnBhcmVudFtpXSk7CiAJCQlpZiAoIW5ld19wYXJlbnQpCi0JCQkJY29udGludWU7CisJCQkJcmV0dXJuIGVycm9yKCJiYWQgZ3JhZnQgcGFyZW50ICVzIGluIGNvbW1pdCAlcyIsCisJCQkJCSAgICAgb2lkX3RvX2hleCgmZ3JhZnQtPnBhcmVudFtpXSksCisJCQkJCSAgICAgb2lkX3RvX2hleCgmaXRlbS0+b2JqZWN0Lm9pZCkpOwogCQkJcHB0ciA9ICZjb21taXRfbGlzdF9pbnNlcnQobmV3X3BhcmVudCwgcHB0ciktPm5leHQ7CiAJCX0KIAl9CkBAIC00NTAsNiArNDc0LDcgQEAKIAlpZiAoY2hlY2tfZ3JhcGgpCiAJCWxvYWRfY29tbWl0X2dyYXBoX2luZm8ociwgaXRlbSk7CiAKKwlpdGVtLT5vYmplY3QucGFyc2VkID0gMTsKIAlyZXR1cm4gMDsKIH0KIApAQCAtMTU4MCwzICsxNjA1LDI2IEBACiAJfQogCXJldHVybiBib2MgPyBsZW4gLSBib2MgOiBsZW4gLSBjdXRvZmY7CiB9CisKK2ludCBydW5fY29tbWl0X2hvb2soaW50IGVkaXRvcl9pc191c2VkLCBjb25zdCBjaGFyICppbmRleF9maWxlLAorCQkgICAgY29uc3QgY2hhciAqbmFtZSwgLi4uKQoreworCXN0cnVjdCBhcmd2X2FycmF5IGhvb2tfZW52ID0gQVJHVl9BUlJBWV9JTklUOworCXZhX2xpc3QgYXJnczsKKwlpbnQgcmV0OworCisJYXJndl9hcnJheV9wdXNoZigmaG9va19lbnYsICJHSVRfSU5ERVhfRklMRT0lcyIsIGluZGV4X2ZpbGUpOworCisJLyoKKwkgKiBMZXQgdGhlIGhvb2sga25vdyB0aGF0IG5vIGVkaXRvciB3aWxsIGJlIGxhdW5jaGVkLgorCSAqLworCWlmICghZWRpdG9yX2lzX3VzZWQpCisJCWFyZ3ZfYXJyYXlfcHVzaCgmaG9va19lbnYsICJHSVRfRURJVE9SPToiKTsKKworCXZhX3N0YXJ0KGFyZ3MsIG5hbWUpOworCXJldCA9IHJ1bl9ob29rX3ZlKGhvb2tfZW52LmFyZ3YsbmFtZSwgYXJncyk7CisJdmFfZW5kKGFyZ3MpOworCWFyZ3ZfYXJyYXlfY2xlYXIoJmhvb2tfZW52KTsKKworCXJldHVybiByZXQ7Cit9CmRpZmYgLS1naXQgYS9jb21taXQuaCBiL2NvbW1pdC5oCmluZGV4IGY1Mjk1Y2EuLjIyMWNkYWEgMTAwNjQ0Ci0tLSBhL2NvbW1pdC5oCisrKyBiL2NvbW1pdC5oCkBAIC0xMzIsNyArMTMyLDcgQEAKICNlbmRpZgogCiAvKgotICogVGVsbCB0aGUgY29tbWl0IHN1YnN5dGVtIHRoYXQgd2UgYXJlIGRvbmUgd2l0aCBhIHBhcnRpY3VsYXIgY29tbWl0IGJ1ZmZlci4KKyAqIFRlbGwgdGhlIGNvbW1pdCBzdWJzeXN0ZW0gdGhhdCB3ZSBhcmUgZG9uZSB3aXRoIGEgcGFydGljdWxhciBjb21taXQgYnVmZmVyLgogICogVGhlIGNvbW1pdCBhbmQgYnVmZmVyIHNob3VsZCBiZSB0aGUgaW5wdXQgYW5kIHJldHVybiB2YWx1ZSwgcmVzcGVjdGl2ZWx5LAogICogZnJvbSBhbiBlYXJsaWVyIGNhbGwgdG8gZ2V0X2NvbW1pdF9idWZmZXIuICBUaGUgYnVmZmVyIG1heSBvciBtYXkgbm90IGJlCiAgKiBmcmVlZCBieSB0aGlzIGNhbGw7IGNhbGxlcnMgc2hvdWxkIG5vdCBhY2Nlc3MgdGhlIG1lbW9yeSBhZnRlcndhcmRzLgpkaWZmIC0tZ2l0IGEvY29tbW9uLW1haW4uYyBiL2NvbW1vbi1tYWluLmMKaW5kZXggNTgyYTdiMS4uNzFlMjFkZCAxMDA2NDQKLS0tIGEvY29tbW9uLW1haW4uYworKysgYi9jb21tb24tbWFpbi5jCkBAIC0zOSwxNiArMzksMTYgQEAKIAogCWdpdF9yZXNvbHZlX2V4ZWN1dGFibGVfZGlyKGFyZ3ZbMF0pOwogCi0JdHJhY2UyX2luaXRpYWxpemUoKTsKLQl0cmFjZTJfY21kX3N0YXJ0KGFyZ3YpOwotCXRyYWNlMl9jb2xsZWN0X3Byb2Nlc3NfaW5mbyhUUkFDRTJfUFJPQ0VTU19JTkZPX1NUQVJUVVApOwotCiAJZ2l0X3NldHVwX2dldHRleHQoKTsKIAogCWluaXRpYWxpemVfdGhlX3JlcG9zaXRvcnkoKTsKIAogCWF0dHJfc3RhcnQoKTsKIAorCXRyYWNlMl9pbml0aWFsaXplKCk7CisJdHJhY2UyX2NtZF9zdGFydChhcmd2KTsKKwl0cmFjZTJfY29sbGVjdF9wcm9jZXNzX2luZm8oVFJBQ0UyX1BST0NFU1NfSU5GT19TVEFSVFVQKTsKKwogCXJlc3VsdCA9IGNtZF9tYWluKGFyZ2MsIGFyZ3YpOwogCiAJdHJhY2UyX2NtZF9leGl0KHJlc3VsdCk7CmRpZmYgLS1naXQgYS9jb21wYXQvbWluZ3cuYyBiL2NvbXBhdC9taW5ndy5jCmluZGV4IDczOGYwYTguLjJmNDY1NGMgMTAwNjQ0Ci0tLSBhL2NvbXBhdC9taW5ndy5jCisrKyBiL2NvbXBhdC9taW5ndy5jCkBAIC0zNjMsNiArMzYzLDggQEAKIAkJCS8qIGlnbm9yZSB0cmFpbGluZyBzbGFzaGVzICovCiAJCQlpZiAoKnBhdGgpCiAJCQkJYmFzZW5hbWUgPSBwYXRoOworCQkJZWxzZQorCQkJCWJyZWFrOwogCQl9CiAKIAlpZiAoaGlkZV9kb3RmaWxlcyA9PSBISURFX0RPVEZJTEVTX1RSVUUpCkBAIC0xMTYxLDE0ICsxMTYzLDIxIEBACiAJCQkgaW50IGlzZXhlLCBpbnQgZXhlX29ubHkpCiB7CiAJY2hhciBwYXRoW01BWF9QQVRIXTsKKwl3Y2hhcl90IHdwYXRoW01BWF9QQVRIXTsKIAlzbnByaW50ZihwYXRoLCBzaXplb2YocGF0aCksICIlLipzXFwlcy5leGUiLCBkaXJsZW4sIGRpciwgY21kKTsKIAotCWlmICghaXNleGUgJiYgYWNjZXNzKHBhdGgsIEZfT0spID09IDApCisJaWYgKHh1dGZ0b3djc19wYXRoKHdwYXRoLCBwYXRoKSA8IDApCisJCXJldHVybiBOVUxMOworCisJaWYgKCFpc2V4ZSAmJiBfd2FjY2Vzcyh3cGF0aCwgRl9PSykgPT0gMCkKIAkJcmV0dXJuIHhzdHJkdXAocGF0aCk7Ci0JcGF0aFtzdHJsZW4ocGF0aCktNF0gPSAnXDAnOwotCWlmICgoIWV4ZV9vbmx5IHx8IGlzZXhlKSAmJiBhY2Nlc3MocGF0aCwgRl9PSykgPT0gMCkKLQkJaWYgKCEoR2V0RmlsZUF0dHJpYnV0ZXMocGF0aCkgJiBGSUxFX0FUVFJJQlVURV9ESVJFQ1RPUlkpKQorCXdwYXRoW3djc2xlbih3cGF0aCktNF0gPSAnXDAnOworCWlmICgoIWV4ZV9vbmx5IHx8IGlzZXhlKSAmJiBfd2FjY2Vzcyh3cGF0aCwgRl9PSykgPT0gMCkgeworCQlpZiAoIShHZXRGaWxlQXR0cmlidXRlc1cod3BhdGgpICYgRklMRV9BVFRSSUJVVEVfRElSRUNUT1JZKSkgeworCQkJcGF0aFtzdHJsZW4ocGF0aCktNF0gPSAnXDAnOwogCQkJcmV0dXJuIHhzdHJkdXAocGF0aCk7CisJCX0KKwl9CiAJcmV0dXJuIE5VTEw7CiB9CiAKQEAgLTEyMjksMTEgKzEyMzgsNiBAQAogCXJldHVybiBfd2NzbmljbXAocCwgcSwgcF9sZW4pOwogfQogCi0vKiBXZSBuZWVkIGEgc3RhYmxlIHNvcnQgdG8gY29udmVydCB0aGUgZW52aXJvbm1lbnQgYmV0d2VlbiBVVEYtMTYgPC0+IFVURi04ICovCi0jaWZuZGVmIElOVEVSTkFMX1FTT1JUCi0jaW5jbHVkZSAicXNvcnQuYyIKLSNlbmRpZgotCiAvKgogICogQnVpbGQgYW4gZW52aXJvbm1lbnQgYmxvY2sgY29tYmluaW5nIHRoZSBpbmhlcml0ZWQgZW52aXJvbm1lbnQKICAqIG1lcmdlZCB3aXRoIHRoZSBnaXZlbiBsaXN0IG9mIHNldHRpbmdzLgpAQCAtMTI2NSwxNSArMTI2OSwxNSBAQAogCQl9CiAKIAkJQUxMT0NfQVJSQVkocmVzdWx0LCBzaXplKTsKLQkJbWVtY3B5KHJlc3VsdCwgd2Vudiwgc2l6ZSAqIHNpemVvZigqd2VudikpOworCQlDT1BZX0FSUkFZKHJlc3VsdCwgd2Vudiwgc2l6ZSk7CiAJCUZyZWVFbnZpcm9ubWVudFN0cmluZ3NXKHdlbnYpOwogCQlyZXR1cm4gcmVzdWx0OwogCX0KIAogCS8qCiAJICogSWYgdGhlcmUgaXMgYSBkZWx0YWVudiwgbGV0J3MgYWNjdW11bGF0ZSBhbGwga2V5cyBpbnRvIGBhcnJheWAsCi0JICogc29ydCB0aGVtIHVzaW5nIHRoZSBzdGFibGUgZ2l0X3Fzb3J0KCkgYW5kIHRoZW4gY29weSwgc2tpcHBpbmcKLQkgKiBkdXBsaWNhdGUga2V5cworCSAqIHNvcnQgdGhlbSB1c2luZyB0aGUgc3RhYmxlIGdpdF9zdGFibGVfcXNvcnQoKSBhbmQgdGhlbiBjb3B5LAorCSAqIHNraXBwaW5nIGR1cGxpY2F0ZSBrZXlzCiAJICovCiAJZm9yIChwID0gd2VudjsgcCAmJiAqcDsgKSB7CiAJCUFMTE9DX0dST1coYXJyYXksIG5yICsgMSwgYWxsb2MpOwpAQCAtMTI5Niw3ICsxMzAwLDcgQEAKIAkJcCArPSB3bGVuICsgMTsKIAl9CiAKLQlnaXRfcXNvcnQoYXJyYXksIG5yLCBzaXplb2YoKmFycmF5KSwgd2VudmNtcCk7CisJZ2l0X3N0YWJsZV9xc29ydChhcnJheSwgbnIsIHNpemVvZigqYXJyYXkpLCB3ZW52Y21wKTsKIAlBTExPQ19BUlJBWShyZXN1bHQsIHNpemUgKyBkZWx0YV9zaXplKTsKIAogCWZvciAocCA9IHJlc3VsdCwgaSA9IDA7IGkgPCBucjsgaSsrKSB7CkBAIC0xMzA5LDcgKzEzMTMsNyBAQAogCQkJY29udGludWU7CiAKIAkJc2l6ZSA9IHdjc2xlbihhcnJheVtpXSkgKyAxOwotCQltZW1jcHkocCwgYXJyYXlbaV0sIHNpemUgKiBzaXplb2YoKnApKTsKKwkJQ09QWV9BUlJBWShwLCBhcnJheVtpXSwgc2l6ZSk7CiAJCXAgKz0gc2l6ZTsKIAl9CiAJKnAgPSBMJ1wwJzsKQEAgLTE1NjIsNyArMTU2Niw3IEBACiAJCXdoaWxlIChhcmd2W2FyZ2NdKSBhcmdjKys7CiAJCUFMTE9DX0FSUkFZKGFyZ3YyLCBhcmdjICsgMSk7CiAJCWFyZ3YyWzBdID0gKGNoYXIgKiljbWQ7CS8qIGZ1bGwgcGF0aCB0byB0aGUgc2NyaXB0IGZpbGUgKi8KLQkJbWVtY3B5KCZhcmd2MlsxXSwgJmFyZ3ZbMV0sIHNpemVvZigqYXJndikgKiBhcmdjKTsKKwkJQ09QWV9BUlJBWSgmYXJndjJbMV0sICZhcmd2WzFdLCBhcmdjKTsKIAkJZXhlY19pZCA9IHRyYWNlMl9leGVjKHByb2csIGFyZ3YyKTsKIAkJcGlkID0gbWluZ3dfc3Bhd252KHByb2csIGFyZ3YyLCAxKTsKIAkJaWYgKHBpZCA+PSAwKSB7CkBAIC0xNjYzLDYgKzE2NjcsOCBAQAogCWlmICghd19rZXkpCiAJCWRpZSgiT3V0IG9mIG1lbW9yeSwgKHRyaWVkIHRvIGFsbG9jYXRlICV1IHdjaGFyX3QncykiLCBsZW5fa2V5KTsKIAl4dXRmdG93Y3Mod19rZXksIG5hbWUsIGxlbl9rZXkpOworCS8qIEdldEVudmlyb25tZW50VmFyaWFibGVXKCkgb25seSBzZXRzIHRoZSBsYXN0IGVycm9yIHVwb24gZmFpbHVyZSAqLworCVNldExhc3RFcnJvcihFUlJPUl9TVUNDRVNTKTsKIAlsZW5fdmFsdWUgPSBHZXRFbnZpcm9ubWVudFZhcmlhYmxlVyh3X2tleSwgd192YWx1ZSwgQVJSQVlfU0laRSh3X3ZhbHVlKSk7CiAJaWYgKCFsZW5fdmFsdWUgJiYgR2V0TGFzdEVycm9yKCkgPT0gRVJST1JfRU5WVkFSX05PVF9GT1VORCkgewogCQlmcmVlKHdfa2V5KTsKZGlmZiAtLWdpdCBhL2NvbXBhdC9taW5ndy5oIGIvY29tcGF0L21pbmd3LmgKaW5kZXggYTAzZTQwZS4uMWE0NjMzNCAxMDA2NDQKLS0tIGEvY29tcGF0L21pbmd3LmgKKysrIGIvY29tcGF0L21pbmd3LmgKQEAgLTExLDcgKzExLDcgQEAKICN1bmRlZiBfUE9TSVhfVEhSRUFEX1NBRkVfRlVOQ1RJT05TCiAjZW5kaWYKIAotZXh0ZXJuIGludCBtaW5nd19jb3JlX2NvbmZpZyhjb25zdCBjaGFyICp2YXIsIGNvbnN0IGNoYXIgKnZhbHVlLCB2b2lkICpjYik7CitpbnQgbWluZ3dfY29yZV9jb25maWcoY29uc3QgY2hhciAqdmFyLCBjb25zdCBjaGFyICp2YWx1ZSwgdm9pZCAqY2IpOwogI2RlZmluZSBwbGF0Zm9ybV9jb3JlX2NvbmZpZyBtaW5nd19jb3JlX2NvbmZpZwogCiAvKgpAQCAtNDQzLDcgKzQ0Myw3IEBACiAJCQkqcGF0aCA9ICcvJzsKIH0KICNkZWZpbmUgUEFUSF9TRVAgJzsnCi1leHRlcm4gY2hhciAqbWluZ3dfcXVlcnlfdXNlcl9lbWFpbCh2b2lkKTsKK2NoYXIgKm1pbmd3X3F1ZXJ5X3VzZXJfZW1haWwodm9pZCk7CiAjZGVmaW5lIHF1ZXJ5X3VzZXJfZW1haWwgbWluZ3dfcXVlcnlfdXNlcl9lbWFpbAogI2lmICFkZWZpbmVkKF9fTUlOR1c2NF9WRVJTSU9OX01BSk9SKSAmJiAoIWRlZmluZWQoX01TQ19WRVIpIHx8IF9NU0NfVkVSIDwgMTgwMCkKICNkZWZpbmUgUFJJdU1BWCAiSTY0dSIKQEAgLTU1OCw3ICs1NTgsNyBAQAogCiAvKgogICogQSBjcml0aWNhbCBzZWN0aW9uIHVzZWQgaW4gdGhlIGltcGxlbWVudGF0aW9uIG9mIHRoZSBzcGF3bgotICogZnVuY3Rpb25zIChtaW5nd19zcGF3bnZbcF1lKCkpIGFuZCB3YWl0cGlkKCkuIEludGlhbGlzZWQgaW4KKyAqIGZ1bmN0aW9ucyAobWluZ3dfc3Bhd252W3BdZSgpKSBhbmQgd2FpdHBpZCgpLiBJbml0aWFsaXNlZCBpbgogICogdGhlIHJlcGxhY2VtZW50IG1haW4oKSBtYWNybyBiZWxvdy4KICAqLwogZXh0ZXJuIENSSVRJQ0FMX1NFQ1RJT04gcGluZm9fY3M7CkBAIC01ODAsNCArNTgwLDQgQEAKIC8qCiAgKiBVc2VkIGJ5IFB0aHJlYWQgQVBJIGltcGxlbWVudGF0aW9uIGZvciBXaW5kb3dzCiAgKi8KLWV4dGVybiBpbnQgZXJyX3dpbl90b19wb3NpeChEV09SRCB3aW5lcnIpOworaW50IGVycl93aW5fdG9fcG9zaXgoRFdPUkQgd2luZXJyKTsKZGlmZiAtLWdpdCBhL2NvbXBhdC9uZWRtYWxsb2MvbWFsbG9jLmMuaCBiL2NvbXBhdC9uZWRtYWxsb2MvbWFsbG9jLmMuaAppbmRleCBiODMzZmY5Li44MTQ4NDVkIDEwMDY0NAotLS0gYS9jb21wYXQvbmVkbWFsbG9jL21hbGxvYy5jLmgKKysrIGIvY29tcGF0L25lZG1hbGxvYy9tYWxsb2MuYy5oCkBAIC0xNTY0LDcgKzE1NjQsNyBAQAogICByZXR1cm4gKHB0ciAhPSAwKT8gcHRyOiBNRkFJTDsKIH0KIAotLyogVGhpcyBmdW5jdGlvbiBzdXBwb3J0cyByZWxlYXNpbmcgY29hbGVzZWQgc2VnbWVudHMgKi8KKy8qIFRoaXMgZnVuY3Rpb24gc3VwcG9ydHMgcmVsZWFzaW5nIGNvYWxlc2NlZCBzZWdtZW50cyAqLwogc3RhdGljIEZPUkNFSU5MSU5FIGludCB3aW4zMm11bm1hcCh2b2lkKiBwdHIsIHNpemVfdCBzaXplKSB7CiAgIE1FTU9SWV9CQVNJQ19JTkZPUk1BVElPTiBtaW5mbzsKICAgY2hhciogY3B0ciA9IChjaGFyKilwdHI7CkBAIC0xNjU1LDcgKzE2NTUsNyBAQAogICAgICNkZWZpbmUgQ0FMTF9NUkVNQVAoYWRkciwgb3N6LCBuc3osIG12KSAgICAgTUZBSUwKICNlbmRpZiAvKiBIQVZFX01NQVAgJiYgSEFWRV9NUkVNQVAgKi8KIAotLyogbXN0YXRlIGJpdCBzZXQgaWYgY29udGluZ3VvdXMgbW9yZWNvcmUgZGlzYWJsZWQgb3IgZmFpbGVkICovCisvKiBtc3RhdGUgYml0IHNldCBpZiBjb250aWd1b3VzIG1vcmVjb3JlIGRpc2FibGVkIG9yIGZhaWxlZCAqLwogI2RlZmluZSBVU0VfTk9OQ09OVElHVU9VU19CSVQgKDRVKQogCiAvKiBzZWdtZW50IGJpdCBzZXQgaW4gY3JlYXRlX21zcGFjZV93aXRoX2Jhc2UgKi8KQEAgLTE3NTUsMTAgKzE3NTUsMTAgQEAKICAgYXNzZXJ0KHNsLT5sICE9IDApOwogICBhc3NlcnQoc2wtPnRocmVhZGlkID09IENVUlJFTlRfVEhSRUFEKTsKICAgaWYgKC0tc2wtPmMgPT0gMCkgewotICAgIHNsLT50aHJlYWRpZCA9IDA7CiAgICAgdm9sYXRpbGUgdW5zaWduZWQgaW50KiBscCA9ICZzbC0+bDsKICAgICBpbnQgcHJldiA9IDA7CiAgICAgaW50IHJldDsKKyAgICBzbC0+dGhyZWFkaWQgPSAwOwogICAgIF9fYXNtX18gX192b2xhdGlsZV9fICgibG9jazsgeGNoZ2wgJTAsICUxIgogCQkJICA6ICI9ciIgKHJldCkKIAkJCSAgOiAibSIgKCoobHApKSwgIjAiKHByZXYpCkBAIC0yNDg1LDcgKzI0ODUsNyBAQAogCiAgIFRyaW0gc3VwcG9ydAogICAgIEZpZWxkcyBob2xkaW5nIHRoZSBhbW91bnQgb2YgdW51c2VkIHRvcG1vc3QgbWVtb3J5IHRoYXQgc2hvdWxkIHRyaWdnZXIKLSAgICB0aW1taW5nLCBhbmQgYSBjb3VudGVyIHRvIGZvcmNlIHBlcmlvZGljIHNjYW5uaW5nIHRvIHJlbGVhc2UgdW51c2VkCisgICAgdGltaW5nLCBhbmQgYSBjb3VudGVyIHRvIGZvcmNlIHBlcmlvZGljIHNjYW5uaW5nIHRvIHJlbGVhc2UgdW51c2VkCiAgICAgbm9uLXRvcG1vc3Qgc2VnbWVudHMuCiAKICAgTG9ja2luZwpAQCAtMzA2Niw3ICszMDY2LDcgQEAKICNpZiAhT05MWV9NU1BBQ0VTCiAgICAgLyogU2V0IHVwIGxvY2sgZm9yIG1haW4gbWFsbG9jIGFyZWEgKi8KICAgICBnbS0+bWZsYWdzID0gbXBhcmFtcy5kZWZhdWx0X21mbGFnczsKLSAgICBJTklUSUFMX0xPQ0soJmdtLT5tdXRleCk7CisgICAgKHZvaWQpSU5JVElBTF9MT0NLKCZnbS0+bXV0ZXgpOwogI2VuZGlmCiAKICNpZiAoRk9PVEVSUyAmJiAhSU5TRUNVUkUpCkBAIC01MDE3LDcgKzUwMTcsNyBAQAogICBtY2h1bmtwdHIgbXNwID0gYWxpZ25fYXNfY2h1bmsodGJhc2UpOwogICBtc3RhdGUgbSA9IChtc3RhdGUpKGNodW5rMm1lbShtc3ApKTsKICAgbWVtc2V0KG0sIDAsIG1zaXplKTsKLSAgSU5JVElBTF9MT0NLKCZtLT5tdXRleCk7CisgICh2b2lkKUlOSVRJQUxfTE9DSygmbS0+bXV0ZXgpOwogICBtc3AtPmhlYWQgPSAobXNpemV8UElOVVNFX0JJVHxDSU5VU0VfQklUKTsKICAgbS0+c2VnLmJhc2UgPSBtLT5sZWFzdF9hZGRyID0gdGJhc2U7CiAgIG0tPnNlZy5zaXplID0gbS0+Zm9vdHByaW50ID0gbS0+bWF4X2Zvb3RwcmludCA9IHRzaXplOwpkaWZmIC0tZ2l0IGEvY29tcGF0L29ic3RhY2suaCBiL2NvbXBhdC9vYnN0YWNrLmgKaW5kZXggYWUzNmVkNi4uMDFlN2M4MSAxMDA2NDQKLS0tIGEvY29tcGF0L29ic3RhY2suaAorKysgYi9jb21wYXQvb2JzdGFjay5oCkBAIC03OSw3ICs3OSw3IEBACiBXaGVuIHRoZSBjaGFycyBidXJzdCBvdmVyIGEgY2h1bmsgYm91bmRhcnksIHdlIGFsbG9jYXRlIGEgbGFyZ2VyCiBjaHVuaywgYW5kIHRoZW4gY29weSB0aGUgcGFydGx5IGZvcm1lZCBvYmplY3QgZnJvbSB0aGUgZW5kIG9mIHRoZSBvbGQKIGNodW5rIHRvIHRoZSBiZWdpbm5pbmcgb2YgdGhlIG5ldyBsYXJnZXIgY2h1bmsuICBXZSB0aGVuIGNhcnJ5IG9uCi1hY2NyZXRpbmcgY2hhcmFjdGVycyB0byB0aGUgZW5kIG9mIHRoZSBvYmplY3QgYXMgd2Ugbm9ybWFsbHkgd291bGQuCithY2NyZWRpdGluZyBjaGFyYWN0ZXJzIHRvIHRoZSBlbmQgb2YgdGhlIG9iamVjdCBhcyB3ZSBub3JtYWxseSB3b3VsZC4KIAogQSBzcGVjaWFsIG1hY3JvIGlzIHByb3ZpZGVkIHRvIGFkZCBhIHNpbmdsZSBjaGFyIGF0IGEgdGltZSB0byBhCiBncm93aW5nIG9iamVjdC4gIFRoaXMgYWxsb3dzIHRoZSB1c2Ugb2YgcmVnaXN0ZXIgdmFyaWFibGVzLCB3aGljaApkaWZmIC0tZ2l0IGEvY29tcGF0L3JlZ2V4L3JlZ2NvbXAuYyBiL2NvbXBhdC9yZWdleC9yZWdjb21wLmMKaW5kZXggYzBkODM4OC4uZDFiYzA5ZSAxMDA2NDQKLS0tIGEvY29tcGF0L3JlZ2V4L3JlZ2NvbXAuYworKysgYi9jb21wYXQvcmVnZXgvcmVnY29tcC5jCkBAIC0zNDYyLDcgKzM0NjIsNyBAQAogCS8qIFRoaXMgaXNuJ3QgYSB2YWxpZCBjaGFyYWN0ZXIuICAqLwogCXJldHVybiBSRUdfRUNPTExBVEU7CiAKLSAgICAgIC8qIEJ1aWxkIHNpbmdsZSBieXRlIG1hdGNpbmcgdGFibGUgZm9yIHRoaXMgZXF1aXZhbGVuY2UgY2xhc3MuICAqLworICAgICAgLyogQnVpbGQgc2luZ2xlIGJ5dGUgbWF0Y2hpbmcgdGFibGUgZm9yIHRoaXMgZXF1aXZhbGVuY2UgY2xhc3MuICAqLwogICAgICAgY2hhcl9idWZbMV0gPSAodW5zaWduZWQgY2hhcikgJ1wwJzsKICAgICAgIGxlbiA9IHdlaWdodHNbaWR4MSAmIDB4ZmZmZmZmXTsKICAgICAgIGZvciAoY2ggPSAwOyBjaCA8IFNCQ19NQVg7ICsrY2gpCmRpZmYgLS1naXQgYS9jb21wYXQvcmVnZXgvcmVnZXguaCBiL2NvbXBhdC9yZWdleC9yZWdleC5oCmluZGV4IDRkODEzNTguLjA4YTI2MDkgMTAwNjQ0Ci0tLSBhL2NvbXBhdC9yZWdleC9yZWdleC5oCisrKyBiL2NvbXBhdC9yZWdleC9yZWdleC5oCkBAIC0zMjIsNyArMzIyLDcgQEAKICAgLyogUE9TSVggcmVnY29tcCByZXR1cm4gZXJyb3IgY29kZXMuICAoSW4gdGhlIG9yZGVyIGxpc3RlZCBpbiB0aGUKICAgICAgc3RhbmRhcmQuKSAgKi8KICAgUkVHX0JBRFBBVCwJCS8qIEludmFsaWQgcGF0dGVybi4gICovCi0gIFJFR19FQ09MTEFURSwJCS8qIEluYWxpZCBjb2xsYXRpbmcgZWxlbWVudC4gICovCisgIFJFR19FQ09MTEFURSwJCS8qIEludmFsaWQgY29sbGF0aW5nIGVsZW1lbnQuICAqLwogICBSRUdfRUNUWVBFLAkJLyogSW52YWxpZCBjaGFyYWN0ZXIgY2xhc3MgbmFtZS4gICovCiAgIFJFR19FRVNDQVBFLAkJLyogVHJhaWxpbmcgYmFja3NsYXNoLiAgKi8KICAgUkVHX0VTVUJSRUcsCQkvKiBJbnZhbGlkIGJhY2sgcmVmZXJlbmNlLiAgKi8KZGlmZiAtLWdpdCBhL2NvbXBhdC9yZWdleC9yZWdleF9pbnRlcm5hbC5jIGIvY29tcGF0L3JlZ2V4L3JlZ2V4X2ludGVybmFsLmMKaW5kZXggNTliZjE1MS4uZWM1MWNmMyAxMDA2NDQKLS0tIGEvY29tcGF0L3JlZ2V4L3JlZ2V4X2ludGVybmFsLmMKKysrIGIvY29tcGF0L3JlZ2V4L3JlZ2V4X2ludGVybmFsLmMKQEAgLTE2MTYsNyArMTYxNiw3IEBACiAgIHJlX2ZyZWUgKHN0YXRlKTsKIH0KIAotLyogQ3JlYXRlIHRoZSBuZXcgc3RhdGUgd2hpY2ggaXMgaW5kZXBlbmQgb2YgY29udGV4dHMuCisvKiBDcmVhdGUgdGhlIG5ldyBzdGF0ZSB3aGljaCBpcyBpbmRlcGVuZGVudCBvZiBjb250ZXh0cy4KICAgIFJldHVybiB0aGUgbmV3IHN0YXRlIGlmIHN1Y2NlZWRlZCwgb3RoZXJ3aXNlIHJldHVybiBOVUxMLiAgKi8KIAogc3RhdGljIHJlX2RmYXN0YXRlX3QgKgpkaWZmIC0tZ2l0IGEvY29tcGF0L3JlZ2V4L3JlZ2V4ZWMuYyBiL2NvbXBhdC9yZWdleC9yZWdleGVjLmMKaW5kZXggMWI1ZDg5Zi4uNDkzNThhZSAxMDA2NDQKLS0tIGEvY29tcGF0L3JlZ2V4L3JlZ2V4ZWMuYworKysgYi9jb21wYXQvcmVnZXgvcmVnZXhlYy5jCkBAIC0yNDIwLDcgKzI0MjAsNyBAQAogLyogRnJvbSB0aGUgbm9kZSBzZXQgQ1VSX05PREVTLCBwaWNrIHVwIHRoZSBub2RlcyB3aG9zZSB0eXBlcyBhcmUKICAgIE9QX09QRU5fU1VCRVhQIGFuZCB3aGljaCBoYXZlIGNvcnJlc3BvbmRpbmcgYmFjayByZWZlcmVuY2VzIGluIHRoZSByZWd1bGFyCiAgICBleHByZXNzaW9uLiBBbmQgcmVnaXN0ZXIgdGhlbSB0byB1c2UgdGhlbSBsYXRlciBmb3IgZXZhbHVhdGluZyB0aGUKLSAgIGNvcnJlc3BvZGluZyBiYWNrIHJlZmVyZW5jZXMuICAqLworICAgY29ycmVzcG9uZGluZyBiYWNrIHJlZmVyZW5jZXMuICAqLwogCiBzdGF0aWMgcmVnX2VycmNvZGVfdAogaW50ZXJuYWxfZnVuY3Rpb24KQEAgLTMzNDcsNyArMzM0Nyw3IEBACiAgIGRlc3RzX25vZGUgPSBkZXN0c19hbGxvYy0+ZGVzdHNfbm9kZTsKICAgZGVzdHNfY2ggPSBkZXN0c19hbGxvYy0+ZGVzdHNfY2g7CiAKLSAgLyogSW5pdGlhbGl6ZSB0cmFuc2l0b24gdGFibGUuICAqLworICAvKiBJbml0aWFsaXplIHRyYW5zaXRpb24gdGFibGUuICAqLwogICBzdGF0ZS0+d29yZF90cnRhYmxlID0gc3RhdGUtPnRydGFibGUgPSBOVUxMOwogCiAgIC8qIEF0IGZpcnN0LCBncm91cCBhbGwgbm9kZXMgYmVsb25naW5nIHRvIGBzdGF0ZScgaW50byBzZXZlcmFsCmRpZmYgLS1naXQgYS9jb21wYXQvdmNidWlsZC9maW5kX3ZzX2Vudi5iYXQgYi9jb21wYXQvdmNidWlsZC9maW5kX3ZzX2Vudi5iYXQKaW5kZXggNDAxOTRkZC4uYjM1ZDI2NCAxMDA2NDQKLS0tIGEvY29tcGF0L3ZjYnVpbGQvZmluZF92c19lbnYuYmF0CisrKyBiL2NvbXBhdC92Y2J1aWxkL2ZpbmRfdnNfZW52LmJhdApAQCAtMTgsNyArMTgsNyBAQAogUkVNIGF0dGVtcHRzIHRvIGRvIHRoYXQuCiBSRU0gPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQogUkVNIFRoaXMgQkFUIGZpbGUgc3RhcnRzIGluIGEgcGxhaW4gKG5vbi1kZXZlbG9wZXIpIGNvbW1hbmQgcHJvbXB0LAotUkVNIHNlYXJjaGVzIGZvciB0aGUgImJlc3QiIGNvbW1tYW5kIHByb21wdCBzZXR1cCBzY3JpcHQsIGluc3RhbGxzCitSRU0gc2VhcmNoZXMgZm9yIHRoZSAiYmVzdCIgY29tbWFuZCBwcm9tcHQgc2V0dXAgc2NyaXB0LCBpbnN0YWxscwogUkVNIGl0IGludG8gdGhlIGN1cnJlbnQgQ01EIHByb2Nlc3MsIGFuZCBleHBvcnRzIHRoZSB2YXJpb3VzIE1TVkMKIFJFTSBlbnZpcm9ubWVudCB2YXJpYWJsZXMgZm9yIHVzZSBieSBNQUtFLgogUkVNCmRpZmYgLS1naXQgYS9jb21wYXQvdmNidWlsZC9zY3JpcHRzL2NsaW5rLnBsIGIvY29tcGF0L3ZjYnVpbGQvc2NyaXB0cy9jbGluay5wbAppbmRleCBjN2IwMjFiLi5lYzk1YTNiIDEwMDc1NQotLS0gYS9jb21wYXQvdmNidWlsZC9zY3JpcHRzL2NsaW5rLnBsCisrKyBiL2NvbXBhdC92Y2J1aWxkL3NjcmlwdHMvY2xpbmsucGwKQEAgLTY4LDggKzY4LDU0IEBACiAJfSBlbHNpZiAoIiRhcmciID1+IC9eLUwvICYmICIkYXJnIiBuZSAiLUxUQ0ciKSB7CiAJCSRhcmcgPX4gcy9eLUwvLUxJQlBBVEg6LzsKIAkJcHVzaChAbGZsYWdzLCAkYXJnKTsKLQl9IGVsc2lmICgiJGFyZyIgPX4gL14tUi8pIHsKKwl9IGVsc2lmICgiJGFyZyIgPX4gL14tW1JsXS8pIHsKIAkJIyBlYXQKKwl9IGVsc2lmICgiJGFyZyIgZXEgIi1XZXJyb3IiKSB7CisJCXB1c2goQGNmbGFncywgIi1XWCIpOworCX0gZWxzaWYgKCIkYXJnIiBlcSAiLVdhbGwiKSB7CisJCSMgY2wuZXhlIHVuZGVyc3RhbmRzIC1XYWxsLCBidXQgaXQgaXMgcmVhbGx5IG92ZXJ6ZWFsb3VzCisJCXB1c2goQGNmbGFncywgIi1XNCIpOworCQkjIGRpc2FibGUgdGhlICJzaWduZWQvdW5zaWduZWQgbWlzbWF0Y2giIHdhcm5pbmdzOyBvdXIgc291cmNlIGNvZGUgdmlvbGF0ZXMgdGhhdAorCQlwdXNoKEBjZmxhZ3MsICItd2Q0MDE4Iik7CisJCXB1c2goQGNmbGFncywgIi13ZDQyNDUiKTsKKwkJcHVzaChAY2ZsYWdzLCAiLXdkNDM4OSIpOworCQkjIGRpc2FibGUgdGhlICJ1bnJlZmVyZW5jZWQgZm9ybWFsIHBhcmFtZXRlciIgd2FybmluZzsgb3VyIHNvdXJjZSBjb2RlIHZpb2xhdGVzIHRoYXQKKwkJcHVzaChAY2ZsYWdzLCAiLXdkNDEwMCIpOworCQkjIGRpc2FibGUgdGhlICJjb25kaXRpb25hbCBleHByZXNzaW9uIGlzIGNvbnN0YW50IiB3YXJuaW5nOyBvdXIgc291cmNlIGNvZGUgdmlvbGF0ZXMgdGhhdAorCQlwdXNoKEBjZmxhZ3MsICItd2Q0MTI3Iik7CisJCSMgZGlzYWJsZSB0aGUgImNvbnN0IG9iamVjdCBzaG91bGQgYmUgaW5pdGlhbGl6ZWQiIHdhcm5pbmc7IHRoZXNlIHdhcm5pbmdzIGFmZmVjdCBvbmx5IG9iamVjdHMgdGhhdCBhcmUgYHN0YXRpY2AKKwkJcHVzaChAY2ZsYWdzLCAiLXdkNDEzMiIpOworCQkjIGRpc2FibGUgdGhlICJmdW5jdGlvbi9kYXRhIHBvaW50ZXIgY29udmVyc2lvbiBpbiBleHByZXNzaW9uIiB3YXJuaW5nOyBvdXIgc291cmNlIGNvZGUgdmlvbGF0ZXMgdGhhdAorCQlwdXNoKEBjZmxhZ3MsICItd2Q0MTUyIik7CisJCSMgZGlzYWJsZSB0aGUgIm5vbi1jb25zdGFudCBhZ2dyZWdhdGUgaW5pdGlhbGl6ZXIiIHdhcm5pbmc7IG91ciBzb3VyY2UgY29kZSB2aW9sYXRlcyB0aGF0CisJCXB1c2goQGNmbGFncywgIi13ZDQyMDQiKTsKKwkJIyBkaXNhYmxlIHRoZSAiY2Fubm90IGJlIGluaXRpYWxpemVkIHVzaW5nIGFkZHJlc3Mgb2YgYXV0b21hdGljIHZhcmlhYmxlIiB3YXJuaW5nOyBvdXIgc291cmNlIGNvZGUgdmlvbGF0ZXMgdGhhdAorCQlwdXNoKEBjZmxhZ3MsICItd2Q0MjIxIik7CisJCSMgZGlzYWJsZSB0aGUgInBvc3NpYmxlIGxvc3Mgb2YgZGF0YSIgd2FybmluZ3M7IG91ciBzb3VyY2UgY29kZSB2aW9sYXRlcyB0aGF0CisJCXB1c2goQGNmbGFncywgIi13ZDQyNDQiKTsKKwkJcHVzaChAY2ZsYWdzLCAiLXdkNDI2NyIpOworCQkjIGRpc2FibGUgdGhlICJhcnJheSBpcyB0b28gc21hbGwgdG8gaW5jbHVkZSBhIHRlcm1pbmF0aW5nIG51bGwgY2hhcmFjdGVyIiB3YXJuaW5nOyB3ZSBhYi11c2Ugc3RyaW5ncyB0byBpbml0aWFsaXplIE9JRHMKKwkJcHVzaChAY2ZsYWdzLCAiLXdkNDI5NSIpOworCQkjIGRpc2FibGUgdGhlICInPDwnOiByZXN1bHQgb2YgMzItYml0IHNoaWZ0IGltcGxpY2l0bHkgY29udmVydGVkIHRvIDY0IGJpdHMiIHdhcm5pbmc7IG91ciBzb3VyY2UgY29kZSB2aW9sYXRlcyB0aGF0CisJCXB1c2goQGNmbGFncywgIi13ZDQzMzQiKTsKKwkJIyBkaXNhYmxlIHRoZSAiZGVjbGFyYXRpb24gaGlkZXMgcHJldmlvdXMgbG9jYWwgZGVjbGFyYXRpb24iIHdhcm5pbmc7IG91ciBzb3VyY2UgY29kZSB2aW9sYXRlcyB0aGF0CisJCXB1c2goQGNmbGFncywgIi13ZDQ0NTYiKTsKKwkJIyBkaXNhYmxlIHRoZSAiZGVjbGFyYXRpb24gaGlkZXMgZnVuY3Rpb24gcGFyYW1ldGVyIiB3YXJuaW5nOyBvdXIgc291cmNlIGNvZGUgdmlvbGF0ZXMgdGhhdAorCQlwdXNoKEBjZmxhZ3MsICItd2Q0NDU3Iik7CisJCSMgZGlzYWJsZSB0aGUgImRlY2xhcmF0aW9uIGhpZGVzIGdsb2JhbCBkZWNsYXJhdGlvbiIgd2FybmluZzsgb3VyIHNvdXJjZSBjb2RlIHZpb2xhdGVzIHRoYXQKKwkJcHVzaChAY2ZsYWdzLCAiLXdkNDQ1OSIpOworCQkjIGRpc2FibGUgdGhlICJwb3RlbnRpYWxseSB1bmluaXRpYWxpemVkIGxvY2FsIHZhcmlhYmxlICc8bmFtZT4nIHVzZWQiIHdhcm5pbmc7IG91ciBzb3VyY2UgY29kZSB2aW9sYXRlcyB0aGF0CisJCXB1c2goQGNmbGFncywgIi13ZDQ3MDEiKTsKKwkJIyBkaXNhYmxlIHRoZSAidW5yZWFjaGFibGUgY29kZSIgd2FybmluZzsgb3VyIHNvdXJjZSBjb2RlIHZpb2xhdGVzIHRoYXQKKwkJcHVzaChAY2ZsYWdzLCAiLXdkNDcwMiIpOworCQkjIGRpc2FibGUgdGhlICJwb3RlbnRpYWxseSB1bmluaXRpYWxpemVkIGxvY2FsIHBvaW50ZXIgdmFyaWFibGUgdXNlZCIgd2FybmluZzsgb3VyIHNvdXJjZSBjb2RlIHZpb2xhdGVzIHRoYXQKKwkJcHVzaChAY2ZsYWdzLCAiLXdkNDcwMyIpOworCQkjIGRpc2FibGUgdGhlICJhc3NpZ25tZW50IHdpdGhpbiBjb25kaXRpb25hbCBleHByZXNzaW9uIiB3YXJuaW5nOyBvdXIgc291cmNlIGNvZGUgdmlvbGF0ZXMgdGhhdAorCQlwdXNoKEBjZmxhZ3MsICItd2Q0NzA2Iik7CisJCSMgZGlzYWJsZSB0aGUgIidpbmV0X250b2EnOiBVc2UgaW5ldF9udG9wKCkgb3IgSW5ldE50b3AoKSBpbnN0ZWFkIiB3YXJuaW5nOyBvdXIgc291cmNlIGNvZGUgdmlvbGF0ZXMgdGhhdAorCQlwdXNoKEBjZmxhZ3MsICItd2Q0OTk2Iik7CisJfSBlbHNpZiAoIiRhcmciID1+IC9eLVdbYS16XS8pIHsKKwkJIyBsZXQncyBpZ25vcmUgdGhvc2UKIAl9IGVsc2UgewogCQlwdXNoKEBhcmdzLCAkYXJnKTsKIAl9CmRpZmYgLS1naXQgYS9jb21wYXQvd2luMzIvcGF0aC11dGlscy5oIGIvY29tcGF0L3dpbjMyL3BhdGgtdXRpbHMuaAppbmRleCAwZjcwZDQzLi44ZWQwNjJhIDEwMDY0NAotLS0gYS9jb21wYXQvd2luMzIvcGF0aC11dGlscy5oCisrKyBiL2NvbXBhdC93aW4zMi9wYXRoLXV0aWxzLmgKQEAgLTEsMyArMSw2IEBACisjaWZuZGVmIFdJTjMyX1BBVEhfVVRJTFNfSAorI2RlZmluZSBXSU4zMl9QQVRIX1VUSUxTX0gKKwogI2RlZmluZSBoYXNfZG9zX2RyaXZlX3ByZWZpeChwYXRoKSBcCiAJKGlzYWxwaGEoKihwYXRoKSkgJiYgKHBhdGgpWzFdID09ICc6JyA/IDIgOiAwKQogaW50IHdpbjMyX3NraXBfZG9zX2RyaXZlX3ByZWZpeChjaGFyICoqcGF0aCk7CkBAIC0xOCwzICsyMSw1IEBACiAjZGVmaW5lIGZpbmRfbGFzdF9kaXJfc2VwIHdpbjMyX2ZpbmRfbGFzdF9kaXJfc2VwCiBpbnQgd2luMzJfb2Zmc2V0XzFzdF9jb21wb25lbnQoY29uc3QgY2hhciAqcGF0aCk7CiAjZGVmaW5lIG9mZnNldF8xc3RfY29tcG9uZW50IHdpbjMyX29mZnNldF8xc3RfY29tcG9uZW50CisKKyNlbmRpZgpkaWZmIC0tZ2l0IGEvY29tcGF0L3dpbjMyL3B0aHJlYWQuaCBiL2NvbXBhdC93aW4zMi9wdGhyZWFkLmgKaW5kZXggYzZjYjhkZC4uNzM3OTgzZCAxMDA2NDQKLS0tIGEvY29tcGF0L3dpbjMyL3B0aHJlYWQuaAorKysgYi9jb21wYXQvd2luMzIvcHRocmVhZC5oCkBAIC01MCw4ICs1MCw4IEBACiAJRFdPUkQgdGlkOwogfSBwdGhyZWFkX3Q7CiAKLWV4dGVybiBpbnQgcHRocmVhZF9jcmVhdGUocHRocmVhZF90ICp0aHJlYWQsIGNvbnN0IHZvaWQgKnVudXNlZCwKLQkJCSAgdm9pZCAqKCpzdGFydF9yb3V0aW5lKSh2b2lkKiksIHZvaWQgKmFyZyk7CitpbnQgcHRocmVhZF9jcmVhdGUocHRocmVhZF90ICp0aHJlYWQsIGNvbnN0IHZvaWQgKnVudXNlZCwKKwkJICAgdm9pZCAqKCpzdGFydF9yb3V0aW5lKSh2b2lkKiksIHZvaWQgKmFyZyk7CiAKIC8qCiAgKiBUbyBhdm9pZCB0aGUgbmVlZCBvZiBjb3B5aW5nIGEgc3RydWN0LCB3ZSB1c2Ugc21hbGwgbWFjcm8gd3JhcHBlciB0byBwYXNzCkBAIC01OSwxMCArNTksMTAgQEAKICAqLwogI2RlZmluZSBwdGhyZWFkX2pvaW4oYSwgYikgd2luMzJfcHRocmVhZF9qb2luKCYoYSksIChiKSkKIAotZXh0ZXJuIGludCB3aW4zMl9wdGhyZWFkX2pvaW4ocHRocmVhZF90ICp0aHJlYWQsIHZvaWQgKip2YWx1ZV9wdHIpOworaW50IHdpbjMyX3B0aHJlYWRfam9pbihwdGhyZWFkX3QgKnRocmVhZCwgdm9pZCAqKnZhbHVlX3B0cik7CiAKICNkZWZpbmUgcHRocmVhZF9lcXVhbCh0MSwgdDIpICgodDEpLnRpZCA9PSAodDIpLnRpZCkKLWV4dGVybiBwdGhyZWFkX3QgcHRocmVhZF9zZWxmKHZvaWQpOworcHRocmVhZF90IHB0aHJlYWRfc2VsZih2b2lkKTsKIAogc3RhdGljIGlubGluZSB2b2lkIE5PUkVUVVJOIHB0aHJlYWRfZXhpdCh2b2lkICpyZXQpCiB7CmRpZmYgLS1naXQgYS9jb21wYXQvd2luYW5zaS5jIGIvY29tcGF0L3dpbmFuc2kuYwppbmRleCBjYWNkODJjLi41NGZkNzAxIDEwMDY0NAotLS0gYS9jb21wYXQvd2luYW5zaS5jCisrKyBiL2NvbXBhdC93aW5hbnNpLmMKQEAgLTU0Niw3ICs1NDYsNyBAQAogdHlwZWRlZiBzdHJ1Y3QgX09CSkVDVF9OQU1FX0lORk9STUFUSU9OCiB7CiAJVU5JQ09ERV9TVFJJTkcgTmFtZTsKLQlXQ0hBUiBOYW1lQnVmZmVyWzBdOworCVdDSEFSIE5hbWVCdWZmZXJbRkxFWF9BUlJBWV07CiB9IE9CSkVDVF9OQU1FX0lORk9STUFUSU9OLCAqUE9CSkVDVF9OQU1FX0lORk9STUFUSU9OOwogCiAjZGVmaW5lIE9iamVjdE5hbWVJbmZvcm1hdGlvbiAxCmRpZmYgLS1naXQgYS9jb25maWcuYyBiL2NvbmZpZy5jCmluZGV4IDM5MDBlNDkuLmU3MDUyYjMgMTAwNjQ0Ci0tLSBhL2NvbmZpZy5jCisrKyBiL2NvbmZpZy5jCkBAIC0yNzUsNyArMjc1LDcgQEAKIAlpbnQgZmxhZ3M7CiAJaW50IHJldDsKIAlzdHJ1Y3Qgc3RyYnVmIHBhdHRlcm4gPSBTVFJCVUZfSU5JVDsKLQljb25zdCBjaGFyICpyZWZuYW1lID0gIXRoZV9yZXBvc2l0b3J5IHx8ICF0aGVfcmVwb3NpdG9yeS0+Z2l0ZGlyID8KKwljb25zdCBjaGFyICpyZWZuYW1lID0gIXRoZV9yZXBvc2l0b3J5LT5naXRkaXIgPwogCQlOVUxMIDogcmVzb2x2ZV9yZWZfdW5zYWZlKCJIRUFEIiwgMCwgTlVMTCwgJmZsYWdzKTsKIAljb25zdCBjaGFyICpzaG9ydG5hbWU7CiAKQEAgLTEyMDQsNyArMTIwNCw3IEBACiAJCQlkZWZhdWx0X2FiYnJldiA9IC0xOwogCQllbHNlIHsKIAkJCWludCBhYmJyZXYgPSBnaXRfY29uZmlnX2ludCh2YXIsIHZhbHVlKTsKLQkJCWlmIChhYmJyZXYgPCBtaW5pbXVtX2FiYnJldiB8fCBhYmJyZXYgPiA0MCkKKwkJCWlmIChhYmJyZXYgPCBtaW5pbXVtX2FiYnJldiB8fCBhYmJyZXYgPiB0aGVfaGFzaF9hbGdvLT5oZXhzeikKIAkJCQlyZXR1cm4gZXJyb3IoXygiYWJicmV2IGxlbmd0aCBvdXQgb2YgcmFuZ2U6ICVkIiksIGFiYnJldik7CiAJCQlkZWZhdWx0X2FiYnJldiA9IGFiYnJldjsKIAkJfQpAQCAtMTM3OSwxMSArMTM3OSw2IEBACiAJCXJldHVybiAwOwogCX0KIAotCWlmICghc3RyY21wKHZhciwgImNvcmUucGFydGlhbGNsb25lZmlsdGVyIikpIHsKLQkJcmV0dXJuIGdpdF9jb25maWdfc3RyaW5nKCZjb3JlX3BhcnRpYWxfY2xvbmVfZmlsdGVyX2RlZmF1bHQsCi0JCQkJCSB2YXIsIHZhbHVlKTsKLQl9Ci0KIAlpZiAoIXN0cmNtcCh2YXIsICJjb3JlLnVzZXJlcGxhY2VyZWZzIikpIHsKIAkJcmVhZF9yZXBsYWNlX3JlZnMgPSBnaXRfY29uZmlnX2Jvb2wodmFyLCB2YWx1ZSk7CiAJCXJldHVybiAwOwpAQCAtMTg2MSw5ICsxODU2LDkgQEAKIAlpZiAoZ2l0X2NvbmZpZ19wYXJzZV9rZXkoa2V5LCAmbm9ybWFsaXplZF9rZXksIE5VTEwpKQogCQlyZXR1cm4gTlVMTDsKIAotCWhhc2htYXBfZW50cnlfaW5pdCgmaywgc3RyaGFzaChub3JtYWxpemVkX2tleSkpOworCWhhc2htYXBfZW50cnlfaW5pdCgmay5lbnQsIHN0cmhhc2gobm9ybWFsaXplZF9rZXkpKTsKIAlrLmtleSA9IG5vcm1hbGl6ZWRfa2V5OwotCWZvdW5kX2VudHJ5ID0gaGFzaG1hcF9nZXQoJmNzLT5jb25maWdfaGFzaCwgJmssIE5VTEwpOworCWZvdW5kX2VudHJ5ID0gaGFzaG1hcF9nZXRfZW50cnkoJmNzLT5jb25maWdfaGFzaCwgJmssIGVudCwgTlVMTCk7CiAJZnJlZShub3JtYWxpemVkX2tleSk7CiAJcmV0dXJuIGZvdW5kX2VudHJ5OwogfQpAQCAtMTg4MiwxMCArMTg3NywxMCBAQAogCSAqLwogCWlmICghZSkgewogCQllID0geG1hbGxvYyhzaXplb2YoKmUpKTsKLQkJaGFzaG1hcF9lbnRyeV9pbml0KGUsIHN0cmhhc2goa2V5KSk7CisJCWhhc2htYXBfZW50cnlfaW5pdCgmZS0+ZW50LCBzdHJoYXNoKGtleSkpOwogCQllLT5rZXkgPSB4c3RyZHVwKGtleSk7CiAJCXN0cmluZ19saXN0X2luaXQoJmUtPnZhbHVlX2xpc3QsIDEpOwotCQloYXNobWFwX2FkZCgmY3MtPmNvbmZpZ19oYXNoLCBlKTsKKwkJaGFzaG1hcF9hZGQoJmNzLT5jb25maWdfaGFzaCwgJmUtPmVudCk7CiAJfQogCXNpID0gc3RyaW5nX2xpc3RfYXBwZW5kX25vZHVwKCZlLT52YWx1ZV9saXN0LCB4c3RyZHVwX29yX251bGwodmFsdWUpKTsKIApAQCAtMTkxMywxMiArMTkwOCwxNCBAQAogfQogCiBzdGF0aWMgaW50IGNvbmZpZ19zZXRfZWxlbWVudF9jbXAoY29uc3Qgdm9pZCAqdW51c2VkX2NtcF9kYXRhLAotCQkJCSAgY29uc3Qgdm9pZCAqZW50cnksCi0JCQkJICBjb25zdCB2b2lkICplbnRyeV9vcl9rZXksCisJCQkJICBjb25zdCBzdHJ1Y3QgaGFzaG1hcF9lbnRyeSAqZXB0ciwKKwkJCQkgIGNvbnN0IHN0cnVjdCBoYXNobWFwX2VudHJ5ICplbnRyeV9vcl9rZXksCiAJCQkJICBjb25zdCB2b2lkICp1bnVzZWRfa2V5ZGF0YSkKIHsKLQljb25zdCBzdHJ1Y3QgY29uZmlnX3NldF9lbGVtZW50ICplMSA9IGVudHJ5OwotCWNvbnN0IHN0cnVjdCBjb25maWdfc2V0X2VsZW1lbnQgKmUyID0gZW50cnlfb3Jfa2V5OworCWNvbnN0IHN0cnVjdCBjb25maWdfc2V0X2VsZW1lbnQgKmUxLCAqZTI7CisKKwllMSA9IGNvbnRhaW5lcl9vZihlcHRyLCBjb25zdCBzdHJ1Y3QgY29uZmlnX3NldF9lbGVtZW50LCBlbnQpOworCWUyID0gY29udGFpbmVyX29mKGVudHJ5X29yX2tleSwgY29uc3Qgc3RydWN0IGNvbmZpZ19zZXRfZWxlbWVudCwgZW50KTsKIAogCXJldHVybiBzdHJjbXAoZTEtPmtleSwgZTItPmtleSk7CiB9CkBAIC0xOTM5LDEyICsxOTM2LDEyIEBACiAJaWYgKCFjcy0+aGFzaF9pbml0aWFsaXplZCkKIAkJcmV0dXJuOwogCi0JaGFzaG1hcF9pdGVyX2luaXQoJmNzLT5jb25maWdfaGFzaCwgJml0ZXIpOwotCXdoaWxlICgoZW50cnkgPSBoYXNobWFwX2l0ZXJfbmV4dCgmaXRlcikpKSB7CisJaGFzaG1hcF9mb3JfZWFjaF9lbnRyeSgmY3MtPmNvbmZpZ19oYXNoLCAmaXRlciwgZW50cnksCisJCQkJZW50IC8qIG1lbWJlciBuYW1lICovKSB7CiAJCWZyZWUoZW50cnktPmtleSk7CiAJCXN0cmluZ19saXN0X2NsZWFyKCZlbnRyeS0+dmFsdWVfbGlzdCwgMSk7CiAJfQotCWhhc2htYXBfZnJlZSgmY3MtPmNvbmZpZ19oYXNoLCAxKTsKKwloYXNobWFwX2ZyZWVfZW50cmllcygmY3MtPmNvbmZpZ19oYXNoLCBzdHJ1Y3QgY29uZmlnX3NldF9lbGVtZW50LCBlbnQpOwogCWNzLT5oYXNoX2luaXRpYWxpemVkID0gMDsKIAlmcmVlKGNzLT5saXN0Lml0ZW1zKTsKIAljcy0+bGlzdC5uciA9IDA7CkBAIC0yMjg4LDMwICsyMjg1LDYgQEAKIAlyZXR1cm4gLTE7IC8qIHRoaW5nIGV4aXN0cyBidXQgY2Fubm90IGJlIHBhcnNlZCAqLwogfQogCi1pbnQgZ2l0X2NvbmZpZ19nZXRfdW50cmFja2VkX2NhY2hlKHZvaWQpCi17Ci0JaW50IHZhbCA9IC0xOwotCWNvbnN0IGNoYXIgKnY7Ci0KLQkvKiBIYWNrIGZvciB0ZXN0IHByb2dyYW1zIGxpa2UgdGVzdC1kdW1wLXVudHJhY2tlZC1jYWNoZSAqLwotCWlmIChpZ25vcmVfdW50cmFja2VkX2NhY2hlX2NvbmZpZykKLQkJcmV0dXJuIC0xOwotCi0JaWYgKCFnaXRfY29uZmlnX2dldF9tYXliZV9ib29sKCJjb3JlLnVudHJhY2tlZGNhY2hlIiwgJnZhbCkpCi0JCXJldHVybiB2YWw7Ci0KLQlpZiAoIWdpdF9jb25maWdfZ2V0X3ZhbHVlKCJjb3JlLnVudHJhY2tlZGNhY2hlIiwgJnYpKSB7Ci0JCWlmICghc3RyY2FzZWNtcCh2LCAia2VlcCIpKQotCQkJcmV0dXJuIC0xOwotCi0JCWVycm9yKF8oInVua25vd24gY29yZS51bnRyYWNrZWRDYWNoZSB2YWx1ZSAnJXMnOyAiCi0JCQkidXNpbmcgJ2tlZXAnIGRlZmF1bHQgdmFsdWUiKSwgdik7Ci0JCXJldHVybiAtMTsKLQl9Ci0KLQlyZXR1cm4gLTE7IC8qIGRlZmF1bHQgdmFsdWUgKi8KLX0KLQogaW50IGdpdF9jb25maWdfZ2V0X3NwbGl0X2luZGV4KHZvaWQpCiB7CiAJaW50IHZhbDsKZGlmZiAtLWdpdCBhL2NvbmZpZy5oIGIvY29uZmlnLmgKaW5kZXggZjBlZDQ2NC4uOTFmZDRjNSAxMDA2NDQKLS0tIGEvY29uZmlnLmgKKysrIGIvY29uZmlnLmgKQEAgLTQsNiArNCwyMiBAQAogI2luY2x1ZGUgImhhc2htYXAuaCIKICNpbmNsdWRlICJzdHJpbmctbGlzdC5oIgogCisKKy8qKgorICogVGhlIGNvbmZpZyBBUEkgZ2l2ZXMgY2FsbGVycyBhIHdheSB0byBhY2Nlc3MgR2l0IGNvbmZpZ3VyYXRpb24gZmlsZXMKKyAqIChhbmQgZmlsZXMgd2hpY2ggaGF2ZSB0aGUgc2FtZSBzeW50YXgpLgorICoKKyAqIEdlbmVyYWwgVXNhZ2UKKyAqIC0tLS0tLS0tLS0tLS0KKyAqCisgKiBDb25maWcgZmlsZXMgYXJlIHBhcnNlZCBsaW5lYXJseSwgYW5kIGVhY2ggdmFyaWFibGUgZm91bmQgaXMgcGFzc2VkIHRvIGEKKyAqIGNhbGxlci1wcm92aWRlZCBjYWxsYmFjayBmdW5jdGlvbi4gVGhlIGNhbGxiYWNrIGZ1bmN0aW9uIGlzIHJlc3BvbnNpYmxlCisgKiBmb3IgYW55IGFjdGlvbnMgdG8gYmUgdGFrZW4gb24gdGhlIGNvbmZpZyBvcHRpb24sIGFuZCBpcyBmcmVlIHRvIGlnbm9yZQorICogc29tZSBvcHRpb25zLiBJdCBpcyBub3QgdW5jb21tb24gZm9yIHRoZSBjb25maWd1cmF0aW9uIHRvIGJlIHBhcnNlZAorICogc2V2ZXJhbCB0aW1lcyBkdXJpbmcgdGhlIHJ1biBvZiBhIEdpdCBwcm9ncmFtLCB3aXRoIGRpZmZlcmVudCBjYWxsYmFja3MKKyAqIHBpY2tpbmcgb3V0IGRpZmZlcmVudCB2YXJpYWJsZXMgdXNlZnVsIHRvIHRoZW1zZWx2ZXMuCisgKi8KKwogc3RydWN0IG9iamVjdF9pZDsKIAogLyogZ2l0X2NvbmZpZ19wYXJzZV9rZXkoKSByZXR1cm5zIHRoZXNlIG5lZ2F0ZWQ6ICovCkBAIC03MSw5ICs4NywzNCBAQAogCX0gZXJyb3JfYWN0aW9uOwogfTsKIAorLyoqCisgKiBBIGNvbmZpZyBjYWxsYmFjayBmdW5jdGlvbiB0YWtlcyB0aHJlZSBwYXJhbWV0ZXJzOgorICoKKyAqIC0gdGhlIG5hbWUgb2YgdGhlIHBhcnNlZCB2YXJpYWJsZS4gVGhpcyBpcyBpbiBjYW5vbmljYWwgImZsYXQiIGZvcm06IHRoZQorICogICBzZWN0aW9uLCBzdWJzZWN0aW9uLCBhbmQgdmFyaWFibGUgc2VnbWVudHMgd2lsbCBiZSBzZXBhcmF0ZWQgYnkgZG90cywKKyAqICAgYW5kIHRoZSBzZWN0aW9uIGFuZCB2YXJpYWJsZSBzZWdtZW50cyB3aWxsIGJlIGFsbCBsb3dlcmNhc2UuIEUuZy4sCisgKiAgIGBjb3JlLmlnbm9yZWNhc2VgLCBgZGlmZi5Tb21lVHlwZS50ZXh0Y29udmAuCisgKgorICogLSB0aGUgdmFsdWUgb2YgdGhlIGZvdW5kIHZhcmlhYmxlLCBhcyBhIHN0cmluZy4gSWYgdGhlIHZhcmlhYmxlIGhhZCBubworICogICB2YWx1ZSBzcGVjaWZpZWQsIHRoZSB2YWx1ZSB3aWxsIGJlIE5VTEwgKHR5cGljYWxseSB0aGlzIG1lYW5zIGl0CisgKiAgIHNob3VsZCBiZSBpbnRlcnByZXRlZCBhcyBib29sZWFuIHRydWUpLgorICoKKyAqIC0gYSB2b2lkIHBvaW50ZXIgcGFzc2VkIGluIGJ5IHRoZSBjYWxsZXIgb2YgdGhlIGNvbmZpZyBBUEk7IHRoaXMgY2FuCisgKiAgIGNvbnRhaW4gY2FsbGJhY2stc3BlY2lmaWMgZGF0YQorICoKKyAqIEEgY29uZmlnIGNhbGxiYWNrIHNob3VsZCByZXR1cm4gMCBmb3Igc3VjY2Vzcywgb3IgLTEgaWYgdGhlIHZhcmlhYmxlCisgKiBjb3VsZCBub3QgYmUgcGFyc2VkIHByb3Blcmx5LgorICovCiB0eXBlZGVmIGludCAoKmNvbmZpZ19mbl90KShjb25zdCBjaGFyICosIGNvbnN0IGNoYXIgKiwgdm9pZCAqKTsKKwogaW50IGdpdF9kZWZhdWx0X2NvbmZpZyhjb25zdCBjaGFyICosIGNvbnN0IGNoYXIgKiwgdm9pZCAqKTsKKworLyoqCisgKiBSZWFkIGEgc3BlY2lmaWMgZmlsZSBpbiBnaXQtY29uZmlnIGZvcm1hdC4KKyAqIFRoaXMgZnVuY3Rpb24gdGFrZXMgdGhlIHNhbWUgY2FsbGJhY2sgYW5kIGRhdGEgcGFyYW1ldGVycyBhcyBgZ2l0X2NvbmZpZ2AuCisgKi8KIGludCBnaXRfY29uZmlnX2Zyb21fZmlsZShjb25maWdfZm5fdCBmbiwgY29uc3QgY2hhciAqLCB2b2lkICopOworCiBpbnQgZ2l0X2NvbmZpZ19mcm9tX2ZpbGVfd2l0aF9vcHRpb25zKGNvbmZpZ19mbl90IGZuLCBjb25zdCBjaGFyICosCiAJCQkJICAgICAgdm9pZCAqLAogCQkJCSAgICAgIGNvbnN0IHN0cnVjdCBjb25maWdfb3B0aW9ucyAqKTsKQEAgLTg4LDM0ICsxMjksMTU3IEBACiBpbnQgZ2l0X2NvbmZpZ19mcm9tX3BhcmFtZXRlcnMoY29uZmlnX2ZuX3QgZm4sIHZvaWQgKmRhdGEpOwogdm9pZCByZWFkX2Vhcmx5X2NvbmZpZyhjb25maWdfZm5fdCBjYiwgdm9pZCAqZGF0YSk7CiB2b2lkIHJlYWRfdmVyeV9lYXJseV9jb25maWcoY29uZmlnX2ZuX3QgY2IsIHZvaWQgKmRhdGEpOworCisvKioKKyAqIE1vc3QgcHJvZ3JhbXMgd2lsbCBzaW1wbHkgd2FudCB0byBsb29rIHVwIHZhcmlhYmxlcyBpbiBhbGwgY29uZmlnIGZpbGVzCisgKiB0aGF0IEdpdCBrbm93cyBhYm91dCwgdXNpbmcgdGhlIG5vcm1hbCBwcmVjZWRlbmNlIHJ1bGVzLiBUbyBkbyB0aGlzLAorICogY2FsbCBgZ2l0X2NvbmZpZ2Agd2l0aCBhIGNhbGxiYWNrIGZ1bmN0aW9uIGFuZCB2b2lkIGRhdGEgcG9pbnRlci4KKyAqCisgKiBgZ2l0X2NvbmZpZ2Agd2lsbCByZWFkIGFsbCBjb25maWcgc291cmNlcyBpbiBvcmRlciBvZiBpbmNyZWFzaW5nCisgKiBwcmlvcml0eS4gVGh1cyBhIGNhbGxiYWNrIHNob3VsZCB0eXBpY2FsbHkgb3ZlcndyaXRlIHByZXZpb3VzbHktc2VlbgorICogZW50cmllcyB3aXRoIG5ldyBvbmVzIChlLmcuLCBpZiBib3RoIHRoZSB1c2VyLXdpZGUgYH4vLmdpdGNvbmZpZ2AgYW5kCisgKiByZXBvLXNwZWNpZmljIGAuZ2l0L2NvbmZpZ2AgY29udGFpbiBgY29sb3IudWlgLCB0aGUgY29uZmlnIG1hY2hpbmVyeQorICogd2lsbCBmaXJzdCBmZWVkIHRoZSB1c2VyLXdpZGUgb25lIHRvIHRoZSBjYWxsYmFjaywgYW5kIHRoZW4gdGhlCisgKiByZXBvLXNwZWNpZmljIG9uZTsgYnkgb3ZlcndyaXRpbmcsIHRoZSBoaWdoZXItcHJpb3JpdHkgcmVwby1zcGVjaWZpYworICogdmFsdWUgaXMgbGVmdCBhdCB0aGUgZW5kKS4KKyAqLwogdm9pZCBnaXRfY29uZmlnKGNvbmZpZ19mbl90IGZuLCB2b2lkICopOworCisvKioKKyAqIExldHMgdGhlIGNhbGxlciBleGFtaW5lIGNvbmZpZyB3aGlsZSBhZGp1c3Rpbmcgc29tZSBvZiB0aGUgZGVmYXVsdAorICogYmVoYXZpb3Igb2YgYGdpdF9jb25maWdgLiBJdCBzaG91bGQgYWxtb3N0IG5ldmVyIGJlIHVzZWQgYnkgInJlZ3VsYXIiCisgKiBHaXQgY29kZSB0aGF0IGlzIGxvb2tpbmcgdXAgY29uZmlndXJhdGlvbiB2YXJpYWJsZXMuCisgKiBJdCBpcyBpbnRlbmRlZCBmb3IgYWR2YW5jZWQgY2FsbGVycyBsaWtlIGBnaXQtY29uZmlnYCwgd2hpY2ggYXJlCisgKiBpbnRlbnRpb25hbGx5IHR3ZWFraW5nIHRoZSBub3JtYWwgY29uZmlnLWxvb2t1cCBwcm9jZXNzLgorICogSXQgdGFrZXMgdHdvIGV4dHJhIHBhcmFtZXRlcnM6CisgKgorICogLSBgY29uZmlnX3NvdXJjZWAKKyAqIElmIHRoaXMgcGFyYW1ldGVyIGlzIG5vbi1OVUxMLCBpdCBzcGVjaWZpZXMgdGhlIHNvdXJjZSB0byBwYXJzZSBmb3IKKyAqIGNvbmZpZ3VyYXRpb24sIHJhdGhlciB0aGFuIGxvb2tpbmcgaW4gdGhlIHVzdWFsIGZpbGVzLiBTZWUgYHN0cnVjdAorICogZ2l0X2NvbmZpZ19zb3VyY2VgIGluIGBjb25maWcuaGAgZm9yIGRldGFpbHMuIFJlZ3VsYXIgYGdpdF9jb25maWdgIGRlZmF1bHRzCisgKiB0byBgTlVMTGAuCisgKgorICogLSBgb3B0c2AKKyAqIFNwZWNpZnkgb3B0aW9ucyB0byBhZGp1c3QgdGhlIGJlaGF2aW9yIG9mIHBhcnNpbmcgY29uZmlnIGZpbGVzLiBTZWUgYHN0cnVjdAorICogY29uZmlnX29wdGlvbnNgIGluIGBjb25maWcuaGAgZm9yIGRldGFpbHMuIEFzIGFuIGV4YW1wbGU6IHJlZ3VsYXIgYGdpdF9jb25maWdgCisgKiBzZXRzIGBvcHRzLnJlc3BlY3RfaW5jbHVkZXNgIHRvIGAxYCBieSBkZWZhdWx0LgorICovCiBpbnQgY29uZmlnX3dpdGhfb3B0aW9ucyhjb25maWdfZm5fdCBmbiwgdm9pZCAqLAogCQkJc3RydWN0IGdpdF9jb25maWdfc291cmNlICpjb25maWdfc291cmNlLAogCQkJY29uc3Qgc3RydWN0IGNvbmZpZ19vcHRpb25zICpvcHRzKTsKKworLyoqCisgKiBWYWx1ZSBQYXJzaW5nIEhlbHBlcnMKKyAqIC0tLS0tLS0tLS0tLS0tLS0tLS0tLQorICoKKyAqIFRoZSBmb2xsb3dpbmcgaGVscGVyIGZ1bmN0aW9ucyBhaWQgaW4gcGFyc2luZyBzdHJpbmcgdmFsdWVzCisgKi8KKwogaW50IGdpdF9wYXJzZV9zc2l6ZV90KGNvbnN0IGNoYXIgKiwgc3NpemVfdCAqKTsKIGludCBnaXRfcGFyc2VfdWxvbmcoY29uc3QgY2hhciAqLCB1bnNpZ25lZCBsb25nICopOworCisvKioKKyAqIFNhbWUgYXMgYGdpdF9jb25maWdfYm9vbGAsIGV4Y2VwdCB0aGF0IGl0IHJldHVybnMgLTEgb24gZXJyb3IgcmF0aGVyCisgKiB0aGFuIGR5aW5nLgorICovCiBpbnQgZ2l0X3BhcnNlX21heWJlX2Jvb2woY29uc3QgY2hhciAqKTsKKworLyoqCisgKiBQYXJzZSB0aGUgc3RyaW5nIHRvIGFuIGludGVnZXIsIGluY2x1ZGluZyB1bml0IGZhY3RvcnMuIERpZXMgb24gZXJyb3I7CisgKiBvdGhlcndpc2UsIHJldHVybnMgdGhlIHBhcnNlZCByZXN1bHQuCisgKi8KIGludCBnaXRfY29uZmlnX2ludChjb25zdCBjaGFyICosIGNvbnN0IGNoYXIgKik7CisKIGludDY0X3QgZ2l0X2NvbmZpZ19pbnQ2NChjb25zdCBjaGFyICosIGNvbnN0IGNoYXIgKik7CisKKy8qKgorICogSWRlbnRpY2FsIHRvIGBnaXRfY29uZmlnX2ludGAsIGJ1dCBmb3IgdW5zaWduZWQgbG9uZ3MuCisgKi8KIHVuc2lnbmVkIGxvbmcgZ2l0X2NvbmZpZ191bG9uZyhjb25zdCBjaGFyICosIGNvbnN0IGNoYXIgKik7CisKIHNzaXplX3QgZ2l0X2NvbmZpZ19zc2l6ZV90KGNvbnN0IGNoYXIgKiwgY29uc3QgY2hhciAqKTsKKworLyoqCisgKiBTYW1lIGFzIGBnaXRfY29uZmlnX2Jvb2xgLCBleGNlcHQgdGhhdCBpbnRlZ2VycyBhcmUgcmV0dXJuZWQgYXMtaXMsIGFuZAorICogYW4gYGlzX2Jvb2xgIGZsYWcgaXMgdW5zZXQuCisgKi8KIGludCBnaXRfY29uZmlnX2Jvb2xfb3JfaW50KGNvbnN0IGNoYXIgKiwgY29uc3QgY2hhciAqLCBpbnQgKik7CisKKy8qKgorICogUGFyc2UgYSBzdHJpbmcgaW50byBhIGJvb2xlYW4gdmFsdWUsIHJlc3BlY3Rpbmcga2V5d29yZHMgbGlrZSAidHJ1ZSIgYW5kCisgKiAiZmFsc2UiLiBJbnRlZ2VyIHZhbHVlcyBhcmUgY29udmVydGVkIGludG8gdHJ1ZS9mYWxzZSB2YWx1ZXMgKHdoZW4gdGhleQorICogYXJlIG5vbi16ZXJvIG9yIHplcm8sIHJlc3BlY3RpdmVseSkuIE90aGVyIHZhbHVlcyBjYXVzZSBhIGRpZSgpLiBJZgorICogcGFyc2luZyBpcyBzdWNjZXNzZnVsLCB0aGUgcmV0dXJuIHZhbHVlIGlzIHRoZSByZXN1bHQuCisgKi8KIGludCBnaXRfY29uZmlnX2Jvb2woY29uc3QgY2hhciAqLCBjb25zdCBjaGFyICopOworCisvKioKKyAqIEFsbG9jYXRlcyBhbmQgY29waWVzIHRoZSB2YWx1ZSBzdHJpbmcgaW50byB0aGUgYGRlc3RgIHBhcmFtZXRlcjsgaWYgbm8KKyAqIHN0cmluZyBpcyBnaXZlbiwgcHJpbnRzIGFuIGVycm9yIG1lc3NhZ2UgYW5kIHJldHVybnMgLTEuCisgKi8KIGludCBnaXRfY29uZmlnX3N0cmluZyhjb25zdCBjaGFyICoqLCBjb25zdCBjaGFyICosIGNvbnN0IGNoYXIgKik7CisKKy8qKgorICogU2ltaWxhciB0byBgZ2l0X2NvbmZpZ19zdHJpbmdgLCBidXQgZXhwYW5kcyBgfmAgb3IgYH51c2VyYCBpbnRvIHRoZQorICogdXNlcidzIGhvbWUgZGlyZWN0b3J5IHdoZW4gZm91bmQgYXQgdGhlIGJlZ2lubmluZyBvZiB0aGUgcGF0aC4KKyAqLwogaW50IGdpdF9jb25maWdfcGF0aG5hbWUoY29uc3QgY2hhciAqKiwgY29uc3QgY2hhciAqLCBjb25zdCBjaGFyICopOworCiBpbnQgZ2l0X2NvbmZpZ19leHBpcnlfZGF0ZSh0aW1lc3RhbXBfdCAqLCBjb25zdCBjaGFyICosIGNvbnN0IGNoYXIgKik7CiBpbnQgZ2l0X2NvbmZpZ19jb2xvcihjaGFyICosIGNvbnN0IGNoYXIgKiwgY29uc3QgY2hhciAqKTsKIGludCBnaXRfY29uZmlnX3NldF9pbl9maWxlX2dlbnRseShjb25zdCBjaGFyICosIGNvbnN0IGNoYXIgKiwgY29uc3QgY2hhciAqKTsKKworLyoqCisgKiB3cml0ZSBjb25maWcgdmFsdWVzIHRvIGEgc3BlY2lmaWMgY29uZmlnIGZpbGUsIHRha2VzIGEga2V5L3ZhbHVlIHBhaXIgYXMKKyAqIHBhcmFtZXRlci4KKyAqLwogdm9pZCBnaXRfY29uZmlnX3NldF9pbl9maWxlKGNvbnN0IGNoYXIgKiwgY29uc3QgY2hhciAqLCBjb25zdCBjaGFyICopOworCiBpbnQgZ2l0X2NvbmZpZ19zZXRfZ2VudGx5KGNvbnN0IGNoYXIgKiwgY29uc3QgY2hhciAqKTsKKworLyoqCisgKiB3cml0ZSBjb25maWcgdmFsdWVzIHRvIGAuZ2l0L2NvbmZpZ2AsIHRha2VzIGEga2V5L3ZhbHVlIHBhaXIgYXMgcGFyYW1ldGVyLgorICovCiB2b2lkIGdpdF9jb25maWdfc2V0KGNvbnN0IGNoYXIgKiwgY29uc3QgY2hhciAqKTsKKwogaW50IGdpdF9jb25maWdfcGFyc2Vfa2V5KGNvbnN0IGNoYXIgKiwgY2hhciAqKiwgaW50ICopOwogaW50IGdpdF9jb25maWdfa2V5X2lzX3ZhbGlkKGNvbnN0IGNoYXIgKmtleSk7CiBpbnQgZ2l0X2NvbmZpZ19zZXRfbXVsdGl2YXJfZ2VudGx5KGNvbnN0IGNoYXIgKiwgY29uc3QgY2hhciAqLCBjb25zdCBjaGFyICosIGludCk7CiB2b2lkIGdpdF9jb25maWdfc2V0X211bHRpdmFyKGNvbnN0IGNoYXIgKiwgY29uc3QgY2hhciAqLCBjb25zdCBjaGFyICosIGludCk7CiBpbnQgZ2l0X2NvbmZpZ19zZXRfbXVsdGl2YXJfaW5fZmlsZV9nZW50bHkoY29uc3QgY2hhciAqLCBjb25zdCBjaGFyICosIGNvbnN0IGNoYXIgKiwgY29uc3QgY2hhciAqLCBpbnQpOworCisvKioKKyAqIHRha2VzIGZvdXIgcGFyYW1ldGVyczoKKyAqCisgKiAtIHRoZSBuYW1lIG9mIHRoZSBmaWxlLCBhcyBhIHN0cmluZywgdG8gd2hpY2gga2V5L3ZhbHVlIHBhaXJzIHdpbGwgYmUgd3JpdHRlbi4KKyAqCisgKiAtIHRoZSBuYW1lIG9mIGtleSwgYXMgYSBzdHJpbmcuIFRoaXMgaXMgaW4gY2Fub25pY2FsICJmbGF0IiBmb3JtOiB0aGUgc2VjdGlvbiwKKyAqICAgc3Vic2VjdGlvbiwgYW5kIHZhcmlhYmxlIHNlZ21lbnRzIHdpbGwgYmUgc2VwYXJhdGVkIGJ5IGRvdHMsIGFuZCB0aGUgc2VjdGlvbgorICogICBhbmQgdmFyaWFibGUgc2VnbWVudHMgd2lsbCBiZSBhbGwgbG93ZXJjYXNlLgorICogICBFLmcuLCBgY29yZS5pZ25vcmVjYXNlYCwgYGRpZmYuU29tZVR5cGUudGV4dGNvbnZgLgorICoKKyAqIC0gdGhlIHZhbHVlIG9mIHRoZSB2YXJpYWJsZSwgYXMgYSBzdHJpbmcuIElmIHZhbHVlIGlzIGVxdWFsIHRvIE5VTEwsIGl0IHdpbGwKKyAqICAgcmVtb3ZlIHRoZSBtYXRjaGluZyBrZXkgZnJvbSB0aGUgY29uZmlnIGZpbGUuCisgKgorICogLSB0aGUgdmFsdWUgcmVnZXgsIGFzIGEgc3RyaW5nLiBJdCB3aWxsIGRpc3JlZ2FyZCBrZXkvdmFsdWUgcGFpcnMgd2hlcmUgdmFsdWUKKyAqICAgZG9lcyBub3QgbWF0Y2guCisgKgorICogLSBhIG11bHRpX3JlcGxhY2UgdmFsdWUsIGFzIGFuIGludC4gSWYgdmFsdWUgaXMgZXF1YWwgdG8gemVybywgbm90aGluZyBvciBvbmx5CisgKiAgIG9uZSBtYXRjaGluZyBrZXkvdmFsdWUgaXMgcmVwbGFjZWQsIGVsc2UgYWxsIG1hdGNoaW5nIGtleS92YWx1ZXMgKHJlZ2FyZGxlc3MKKyAqICAgaG93IG1hbnkpIGFyZSByZW1vdmVkLCBiZWZvcmUgdGhlIG5ldyBwYWlyIGlzIHdyaXR0ZW4uCisgKgorICogSXQgcmV0dXJucyAwIG9uIHN1Y2Nlc3MuCisgKi8KIHZvaWQgZ2l0X2NvbmZpZ19zZXRfbXVsdGl2YXJfaW5fZmlsZShjb25zdCBjaGFyICosIGNvbnN0IGNoYXIgKiwgY29uc3QgY2hhciAqLCBjb25zdCBjaGFyICosIGludCk7CisKKy8qKgorICogcmVuYW1lIG9yIHJlbW92ZSBzZWN0aW9ucyBpbiB0aGUgY29uZmlnIGZpbGUKKyAqIHBhcmFtZXRlcnMgYG9sZF9uYW1lYCBhbmQgYG5ld19uYW1lYAorICogSWYgTlVMTCBpcyBwYXNzZWQgdGhyb3VnaCBgbmV3X25hbWVgIHBhcmFtZXRlciwKKyAqIHRoZSBzZWN0aW9uIHdpbGwgYmUgcmVtb3ZlZCBmcm9tIHRoZSBjb25maWcgZmlsZS4KKyAqLwogaW50IGdpdF9jb25maWdfcmVuYW1lX3NlY3Rpb24oY29uc3QgY2hhciAqLCBjb25zdCBjaGFyICopOworCiBpbnQgZ2l0X2NvbmZpZ19yZW5hbWVfc2VjdGlvbl9pbl9maWxlKGNvbnN0IGNoYXIgKiwgY29uc3QgY2hhciAqLCBjb25zdCBjaGFyICopOwogaW50IGdpdF9jb25maWdfY29weV9zZWN0aW9uKGNvbnN0IGNoYXIgKiwgY29uc3QgY2hhciAqKTsKIGludCBnaXRfY29uZmlnX2NvcHlfc2VjdGlvbl9pbl9maWxlKGNvbnN0IGNoYXIgKiwgY29uc3QgY2hhciAqLCBjb25zdCBjaGFyICopOwpAQCAtMTQyLDYgKzMwNiwzMCBAQAogY29uc3QgY2hhciAqY3VycmVudF9jb25maWdfb3JpZ2luX3R5cGUodm9pZCk7CiBjb25zdCBjaGFyICpjdXJyZW50X2NvbmZpZ19uYW1lKHZvaWQpOwogCisvKioKKyAqIEluY2x1ZGUgRGlyZWN0aXZlcworICogLS0tLS0tLS0tLS0tLS0tLS0tCisgKgorICogQnkgZGVmYXVsdCwgdGhlIGNvbmZpZyBwYXJzZXIgZG9lcyBub3QgcmVzcGVjdCBpbmNsdWRlIGRpcmVjdGl2ZXMuCisgKiBIb3dldmVyLCBhIGNhbGxlciBjYW4gdXNlIHRoZSBzcGVjaWFsIGBnaXRfY29uZmlnX2luY2x1ZGVgIHdyYXBwZXIKKyAqIGNhbGxiYWNrIHRvIHN1cHBvcnQgdGhlbS4gVG8gZG8gc28sIHlvdSBzaW1wbHkgd3JhcCB5b3VyICJyZWFsIiBjYWxsYmFjaworICogZnVuY3Rpb24gYW5kIGRhdGEgcG9pbnRlciBpbiBhIGBzdHJ1Y3QgY29uZmlnX2luY2x1ZGVfZGF0YWAsIGFuZCBwYXNzCisgKiB0aGUgd3JhcHBlciB0byB0aGUgcmVndWxhciBjb25maWctcmVhZGluZyBmdW5jdGlvbnMuIEZvciBleGFtcGxlOgorICoKKyAqIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKyAqIGludCByZWFkX2ZpbGVfd2l0aF9pbmNsdWRlKGNvbnN0IGNoYXIgKmZpbGUsIGNvbmZpZ19mbl90IGZuLCB2b2lkICpkYXRhKQorICogeworICogc3RydWN0IGNvbmZpZ19pbmNsdWRlX2RhdGEgaW5jID0gQ09ORklHX0lOQ0xVREVfSU5JVDsKKyAqIGluYy5mbiA9IGZuOworICogaW5jLmRhdGEgPSBkYXRhOworICogcmV0dXJuIGdpdF9jb25maWdfZnJvbV9maWxlKGdpdF9jb25maWdfaW5jbHVkZSwgZmlsZSwgJmluYyk7CisgKiB9CisgKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisgKgorICogYGdpdF9jb25maWdgIHJlc3BlY3RzIGluY2x1ZGVzIGF1dG9tYXRpY2FsbHkuIFRoZSBsb3dlci1sZXZlbAorICogYGdpdF9jb25maWdfZnJvbV9maWxlYCBkb2VzIG5vdC4KKyAqCisgKi8KIHN0cnVjdCBjb25maWdfaW5jbHVkZV9kYXRhIHsKIAlpbnQgZGVwdGg7CiAJY29uZmlnX2ZuX3QgZm47CkBAIC0xNjksNiArMzU3LDMzIEBACiAJCSAgICAgY29uc3QgY2hhciAqKnN1YnNlY3Rpb24sIGludCAqc3Vic2VjdGlvbl9sZW4sCiAJCSAgICAgY29uc3QgY2hhciAqKmtleSk7CiAKKy8qKgorICogQ3VzdG9tIENvbmZpZ3NldHMKKyAqIC0tLS0tLS0tLS0tLS0tLS0tCisgKgorICogQSBgY29uZmlnX3NldGAgY2FuIGJlIHVzZWQgdG8gY29uc3RydWN0IGFuIGluLW1lbW9yeSBjYWNoZSBmb3IKKyAqIGNvbmZpZy1saWtlIGZpbGVzIHRoYXQgdGhlIGNhbGxlciBzcGVjaWZpZXMgKGkuZS4sIGZpbGVzIGxpa2UgYC5naXRtb2R1bGVzYCwKKyAqIGB+Ly5naXRjb25maWdgIGV0Yy4pLiBGb3IgZXhhbXBsZSwKKyAqCisgKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisgKiBzdHJ1Y3QgY29uZmlnX3NldCBnbV9jb25maWc7CisgKiBnaXRfY29uZmlnc2V0X2luaXQoJmdtX2NvbmZpZyk7CisgKiBpbnQgYjsKKyAqIC8vd2UgYWRkIGNvbmZpZyBmaWxlcyB0byB0aGUgY29uZmlnX3NldAorICogZ2l0X2NvbmZpZ3NldF9hZGRfZmlsZSgmZ21fY29uZmlnLCAiLmdpdG1vZHVsZXMiKTsKKyAqIGdpdF9jb25maWdzZXRfYWRkX2ZpbGUoJmdtX2NvbmZpZywgIi5naXRtb2R1bGVzX2FsdCIpOworICoKKyAqIGlmICghZ2l0X2NvbmZpZ3NldF9nZXRfYm9vbChnbV9jb25maWcsICJzdWJtb2R1bGUuZnJvdHouaWdub3JlIiwgJmIpKSB7CisgKiAvL2hhY2sgaGFjayBoYWNrCisgKiB9CisgKgorICogd2hlbiB3ZSBhcmUgZG9uZSB3aXRoIHRoZSBjb25maWdzZXQ6CisgKiBnaXRfY29uZmlnc2V0X2NsZWFyKCZnbV9jb25maWcpOworICogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorICoKKyAqIENvbmZpZ3NldCBBUEkgcHJvdmlkZXMgZnVuY3Rpb25zIGZvciB0aGUgYWJvdmUgbWVudGlvbmVkIHdvcmsgZmxvdworICovCisKIHN0cnVjdCBjb25maWdfc2V0X2VsZW1lbnQgewogCXN0cnVjdCBoYXNobWFwX2VudHJ5IGVudDsKIAljaGFyICprZXk7CkBAIC0xOTcsMTYgKzQxMiw0NyBAQAogCXN0cnVjdCBjb25maWdzZXRfbGlzdCBsaXN0OwogfTsKIAorLyoqCisgKiBJbml0aWFsaXplcyB0aGUgY29uZmlnX3NldCBgY3NgLgorICovCiB2b2lkIGdpdF9jb25maWdzZXRfaW5pdChzdHJ1Y3QgY29uZmlnX3NldCAqY3MpOworCisvKioKKyAqIFBhcnNlcyB0aGUgZmlsZSBhbmQgYWRkcyB0aGUgdmFyaWFibGUtdmFsdWUgcGFpcnMgdG8gdGhlIGBjb25maWdfc2V0YCwKKyAqIGRpZXMgaWYgdGhlcmUgaXMgYW4gZXJyb3IgaW4gcGFyc2luZyB0aGUgZmlsZS4gUmV0dXJucyAwIG9uIHN1Y2Nlc3MsIG9yCisgKiAtMSBpZiB0aGUgZmlsZSBkb2VzIG5vdCBleGlzdCBvciBpcyBpbmFjY2Vzc2libGUuIFRoZSB1c2VyIGhhcyB0byBkZWNpZGUKKyAqIGlmIGhlIHdhbnRzIHRvIGZyZWUgdGhlIGluY29tcGxldGUgY29uZmlnc2V0IG9yIGNvbnRpbnVlIHVzaW5nIGl0IHdoZW4KKyAqIHRoZSBmdW5jdGlvbiByZXR1cm5zIC0xLgorICovCiBpbnQgZ2l0X2NvbmZpZ3NldF9hZGRfZmlsZShzdHJ1Y3QgY29uZmlnX3NldCAqY3MsIGNvbnN0IGNoYXIgKmZpbGVuYW1lKTsKKworLyoqCisgKiBGaW5kcyBhbmQgcmV0dXJucyB0aGUgdmFsdWUgbGlzdCwgc29ydGVkIGluIG9yZGVyIG9mIGluY3JlYXNpbmcgcHJpb3JpdHkKKyAqIGZvciB0aGUgY29uZmlndXJhdGlvbiB2YXJpYWJsZSBga2V5YCBhbmQgY29uZmlnIHNldCBgY3NgLiBXaGVuIHRoZQorICogY29uZmlndXJhdGlvbiB2YXJpYWJsZSBga2V5YCBpcyBub3QgZm91bmQsIHJldHVybnMgTlVMTC4gVGhlIGNhbGxlcgorICogc2hvdWxkIG5vdCBmcmVlIG9yIG1vZGlmeSB0aGUgcmV0dXJuZWQgcG9pbnRlciwgYXMgaXQgaXMgb3duZWQgYnkgdGhlIGNhY2hlLgorICovCiBjb25zdCBzdHJ1Y3Qgc3RyaW5nX2xpc3QgKmdpdF9jb25maWdzZXRfZ2V0X3ZhbHVlX211bHRpKHN0cnVjdCBjb25maWdfc2V0ICpjcywgY29uc3QgY2hhciAqa2V5KTsKKworLyoqCisgKiBDbGVhcnMgYGNvbmZpZ19zZXRgIHN0cnVjdHVyZSwgcmVtb3ZlcyBhbGwgc2F2ZWQgdmFyaWFibGUtdmFsdWUgcGFpcnMuCisgKi8KIHZvaWQgZ2l0X2NvbmZpZ3NldF9jbGVhcihzdHJ1Y3QgY29uZmlnX3NldCAqY3MpOwogCiAvKgogICogVGhlc2UgZnVuY3Rpb25zIHJldHVybiAxIGlmIG5vdCBmb3VuZCwgYW5kIDAgaWYgZm91bmQsIGxlYXZpbmcgdGhlIGZvdW5kCiAgKiB2YWx1ZSBpbiB0aGUgJ2Rlc3QnIHBvaW50ZXIuCiAgKi8KKworLyoKKyAqIEZpbmRzIHRoZSBoaWdoZXN0LXByaW9yaXR5IHZhbHVlIGZvciB0aGUgY29uZmlndXJhdGlvbiB2YXJpYWJsZSBga2V5YAorICogYW5kIGNvbmZpZyBzZXQgYGNzYCwgc3RvcmVzIHRoZSBwb2ludGVyIHRvIGl0IGluIGB2YWx1ZWAgYW5kIHJldHVybnMgMC4KKyAqIFdoZW4gdGhlIGNvbmZpZ3VyYXRpb24gdmFyaWFibGUgYGtleWAgaXMgbm90IGZvdW5kLCByZXR1cm5zIDEgd2l0aG91dAorICogdG91Y2hpbmcgYHZhbHVlYC4gVGhlIGNhbGxlciBzaG91bGQgbm90IGZyZWUgb3IgbW9kaWZ5IGB2YWx1ZWAsIGFzIGl0CisgKiBpcyBvd25lZCBieSB0aGUgY2FjaGUuCisgKi8KIGludCBnaXRfY29uZmlnc2V0X2dldF92YWx1ZShzdHJ1Y3QgY29uZmlnX3NldCAqY3MsIGNvbnN0IGNoYXIgKmtleSwgY29uc3QgY2hhciAqKmRlc3QpOworCiBpbnQgZ2l0X2NvbmZpZ3NldF9nZXRfc3RyaW5nX2NvbnN0KHN0cnVjdCBjb25maWdfc2V0ICpjcywgY29uc3QgY2hhciAqa2V5LCBjb25zdCBjaGFyICoqZGVzdCk7CiBpbnQgZ2l0X2NvbmZpZ3NldF9nZXRfc3RyaW5nKHN0cnVjdCBjb25maWdfc2V0ICpjcywgY29uc3QgY2hhciAqa2V5LCBjaGFyICoqZGVzdCk7CiBpbnQgZ2l0X2NvbmZpZ3NldF9nZXRfaW50KHN0cnVjdCBjb25maWdfc2V0ICpjcywgY29uc3QgY2hhciAqa2V5LCBpbnQgKmRlc3QpOwpAQCAtMjQwLDE3ICs0ODYsOTQgQEAKIGludCByZXBvX2NvbmZpZ19nZXRfcGF0aG5hbWUoc3RydWN0IHJlcG9zaXRvcnkgKnJlcG8sCiAJCQkgICAgIGNvbnN0IGNoYXIgKmtleSwgY29uc3QgY2hhciAqKmRlc3QpOwogCisvKioKKyAqIFF1ZXJ5aW5nIEZvciBTcGVjaWZpYyBWYXJpYWJsZXMKKyAqIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKyAqCisgKiBGb3IgcHJvZ3JhbXMgd2FudGluZyB0byBxdWVyeSBmb3Igc3BlY2lmaWMgdmFyaWFibGVzIGluIGEgbm9uLWNhbGxiYWNrCisgKiBtYW5uZXIsIHRoZSBjb25maWcgQVBJIHByb3ZpZGVzIHR3byBmdW5jdGlvbnMgYGdpdF9jb25maWdfZ2V0X3ZhbHVlYAorICogYW5kIGBnaXRfY29uZmlnX2dldF92YWx1ZV9tdWx0aWAuIFRoZXkgYm90aCByZWFkIHZhbHVlcyBmcm9tIGFuIGludGVybmFsCisgKiBjYWNoZSBnZW5lcmF0ZWQgcHJldmlvdXNseSBmcm9tIHJlYWRpbmcgdGhlIGNvbmZpZyBmaWxlcy4KKyAqLworCisvKioKKyAqIEZpbmRzIHRoZSBoaWdoZXN0LXByaW9yaXR5IHZhbHVlIGZvciB0aGUgY29uZmlndXJhdGlvbiB2YXJpYWJsZSBga2V5YCwKKyAqIHN0b3JlcyB0aGUgcG9pbnRlciB0byBpdCBpbiBgdmFsdWVgIGFuZCByZXR1cm5zIDAuIFdoZW4gdGhlCisgKiBjb25maWd1cmF0aW9uIHZhcmlhYmxlIGBrZXlgIGlzIG5vdCBmb3VuZCwgcmV0dXJucyAxIHdpdGhvdXQgdG91Y2hpbmcKKyAqIGB2YWx1ZWAuIFRoZSBjYWxsZXIgc2hvdWxkIG5vdCBmcmVlIG9yIG1vZGlmeSBgdmFsdWVgLCBhcyBpdCBpcyBvd25lZAorICogYnkgdGhlIGNhY2hlLgorICovCiBpbnQgZ2l0X2NvbmZpZ19nZXRfdmFsdWUoY29uc3QgY2hhciAqa2V5LCBjb25zdCBjaGFyICoqdmFsdWUpOworCisvKioKKyAqIEZpbmRzIGFuZCByZXR1cm5zIHRoZSB2YWx1ZSBsaXN0LCBzb3J0ZWQgaW4gb3JkZXIgb2YgaW5jcmVhc2luZyBwcmlvcml0eQorICogZm9yIHRoZSBjb25maWd1cmF0aW9uIHZhcmlhYmxlIGBrZXlgLiBXaGVuIHRoZSBjb25maWd1cmF0aW9uIHZhcmlhYmxlCisgKiBga2V5YCBpcyBub3QgZm91bmQsIHJldHVybnMgTlVMTC4gVGhlIGNhbGxlciBzaG91bGQgbm90IGZyZWUgb3IgbW9kaWZ5CisgKiB0aGUgcmV0dXJuZWQgcG9pbnRlciwgYXMgaXQgaXMgb3duZWQgYnkgdGhlIGNhY2hlLgorICovCiBjb25zdCBzdHJ1Y3Qgc3RyaW5nX2xpc3QgKmdpdF9jb25maWdfZ2V0X3ZhbHVlX211bHRpKGNvbnN0IGNoYXIgKmtleSk7CisKKy8qKgorICogUmVzZXRzIGFuZCBpbnZhbGlkYXRlcyB0aGUgY29uZmlnIGNhY2hlLgorICovCiB2b2lkIGdpdF9jb25maWdfY2xlYXIodm9pZCk7CisKKy8qKgorICogQWxsb2NhdGVzIGFuZCBjb3BpZXMgdGhlIHJldHJpZXZlZCBzdHJpbmcgaW50byB0aGUgYGRlc3RgIHBhcmFtZXRlciBmb3IKKyAqIHRoZSBjb25maWd1cmF0aW9uIHZhcmlhYmxlIGBrZXlgOyBpZiBOVUxMIHN0cmluZyBpcyBnaXZlbiwgcHJpbnRzIGFuCisgKiBlcnJvciBtZXNzYWdlIGFuZCByZXR1cm5zIC0xLiBXaGVuIHRoZSBjb25maWd1cmF0aW9uIHZhcmlhYmxlIGBrZXlgIGlzCisgKiBub3QgZm91bmQsIHJldHVybnMgMSB3aXRob3V0IHRvdWNoaW5nIGBkZXN0YC4KKyAqLwogaW50IGdpdF9jb25maWdfZ2V0X3N0cmluZ19jb25zdChjb25zdCBjaGFyICprZXksIGNvbnN0IGNoYXIgKipkZXN0KTsKKworLyoqCisgKiBTaW1pbGFyIHRvIGBnaXRfY29uZmlnX2dldF9zdHJpbmdfY29uc3RgLCBleGNlcHQgdGhhdCByZXRyaWV2ZWQgdmFsdWUKKyAqIGNvcGllZCBpbnRvIHRoZSBgZGVzdGAgcGFyYW1ldGVyIGlzIGEgbXV0YWJsZSBzdHJpbmcuCisgKi8KIGludCBnaXRfY29uZmlnX2dldF9zdHJpbmcoY29uc3QgY2hhciAqa2V5LCBjaGFyICoqZGVzdCk7CisKKy8qKgorICogRmluZHMgYW5kIHBhcnNlcyB0aGUgdmFsdWUgdG8gYW4gaW50ZWdlciBmb3IgdGhlIGNvbmZpZ3VyYXRpb24gdmFyaWFibGUKKyAqIGBrZXlgLiBEaWVzIG9uIGVycm9yOyBvdGhlcndpc2UsIHN0b3JlcyB0aGUgdmFsdWUgb2YgdGhlIHBhcnNlZCBpbnRlZ2VyIGluCisgKiBgZGVzdGAgYW5kIHJldHVybnMgMC4gV2hlbiB0aGUgY29uZmlndXJhdGlvbiB2YXJpYWJsZSBga2V5YCBpcyBub3QgZm91bmQsCisgKiByZXR1cm5zIDEgd2l0aG91dCB0b3VjaGluZyBgZGVzdGAuCisgKi8KIGludCBnaXRfY29uZmlnX2dldF9pbnQoY29uc3QgY2hhciAqa2V5LCBpbnQgKmRlc3QpOworCisvKioKKyAqIFNpbWlsYXIgdG8gYGdpdF9jb25maWdfZ2V0X2ludGAgYnV0IGZvciB1bnNpZ25lZCBsb25ncy4KKyAqLwogaW50IGdpdF9jb25maWdfZ2V0X3Vsb25nKGNvbnN0IGNoYXIgKmtleSwgdW5zaWduZWQgbG9uZyAqZGVzdCk7CisKKy8qKgorICogRmluZHMgYW5kIHBhcnNlcyB0aGUgdmFsdWUgaW50byBhIGJvb2xlYW4gdmFsdWUsIGZvciB0aGUgY29uZmlndXJhdGlvbgorICogdmFyaWFibGUgYGtleWAgcmVzcGVjdGluZyBrZXl3b3JkcyBsaWtlICJ0cnVlIiBhbmQgImZhbHNlIi4gSW50ZWdlcgorICogdmFsdWVzIGFyZSBjb252ZXJ0ZWQgaW50byB0cnVlL2ZhbHNlIHZhbHVlcyAod2hlbiB0aGV5IGFyZSBub24temVybyBvcgorICogemVybywgcmVzcGVjdGl2ZWx5KS4gT3RoZXIgdmFsdWVzIGNhdXNlIGEgZGllKCkuIElmIHBhcnNpbmcgaXMgc3VjY2Vzc2Z1bCwKKyAqIHN0b3JlcyB0aGUgdmFsdWUgb2YgdGhlIHBhcnNlZCByZXN1bHQgaW4gYGRlc3RgIGFuZCByZXR1cm5zIDAuIFdoZW4gdGhlCisgKiBjb25maWd1cmF0aW9uIHZhcmlhYmxlIGBrZXlgIGlzIG5vdCBmb3VuZCwgcmV0dXJucyAxIHdpdGhvdXQgdG91Y2hpbmcKKyAqIGBkZXN0YC4KKyAqLwogaW50IGdpdF9jb25maWdfZ2V0X2Jvb2woY29uc3QgY2hhciAqa2V5LCBpbnQgKmRlc3QpOworCisvKioKKyAqIFNpbWlsYXIgdG8gYGdpdF9jb25maWdfZ2V0X2Jvb2xgLCBleGNlcHQgdGhhdCBpbnRlZ2VycyBhcmUgY29waWVkIGFzLWlzLAorICogYW5kIGBpc19ib29sYCBmbGFnIGlzIHVuc2V0LgorICovCiBpbnQgZ2l0X2NvbmZpZ19nZXRfYm9vbF9vcl9pbnQoY29uc3QgY2hhciAqa2V5LCBpbnQgKmlzX2Jvb2wsIGludCAqZGVzdCk7CisKKy8qKgorICogU2ltaWxhciB0byBgZ2l0X2NvbmZpZ19nZXRfYm9vbGAsIGV4Y2VwdCB0aGF0IGl0IHJldHVybnMgLTEgb24gZXJyb3IKKyAqIHJhdGhlciB0aGFuIGR5aW5nLgorICovCiBpbnQgZ2l0X2NvbmZpZ19nZXRfbWF5YmVfYm9vbChjb25zdCBjaGFyICprZXksIGludCAqZGVzdCk7CisKKy8qKgorICogU2ltaWxhciB0byBgZ2l0X2NvbmZpZ19nZXRfc3RyaW5nYCwgYnV0IGV4cGFuZHMgYH5gIG9yIGB+dXNlcmAgaW50bworICogdGhlIHVzZXIncyBob21lIGRpcmVjdG9yeSB3aGVuIGZvdW5kIGF0IHRoZSBiZWdpbm5pbmcgb2YgdGhlIHBhdGguCisgKi8KIGludCBnaXRfY29uZmlnX2dldF9wYXRobmFtZShjb25zdCBjaGFyICprZXksIGNvbnN0IGNoYXIgKipkZXN0KTsKKwogaW50IGdpdF9jb25maWdfZ2V0X2luZGV4X3RocmVhZHMoaW50ICpkZXN0KTsKIGludCBnaXRfY29uZmlnX2dldF91bnRyYWNrZWRfY2FjaGUodm9pZCk7CiBpbnQgZ2l0X2NvbmZpZ19nZXRfc3BsaXRfaW5kZXgodm9pZCk7CkBAIC0yNzAsNyArNTkzLDE5IEBACiAJZW51bSBjb25maWdfc2NvcGUgc2NvcGU7CiB9OwogCisvKioKKyAqIEZpcnN0IHByaW50cyB0aGUgZXJyb3IgbWVzc2FnZSBzcGVjaWZpZWQgYnkgdGhlIGNhbGxlciBpbiBgZXJyYCBhbmQgdGhlbgorICogZGllcyBwcmludGluZyB0aGUgbGluZSBudW1iZXIgYW5kIHRoZSBmaWxlIG5hbWUgb2YgdGhlIGhpZ2hlc3QgcHJpb3JpdHkKKyAqIHZhbHVlIGZvciB0aGUgY29uZmlndXJhdGlvbiB2YXJpYWJsZSBga2V5YC4KKyAqLwogTk9SRVRVUk4gdm9pZCBnaXRfZGllX2NvbmZpZyhjb25zdCBjaGFyICprZXksIGNvbnN0IGNoYXIgKmVyciwgLi4uKSBfX2F0dHJpYnV0ZV9fKChmb3JtYXQocHJpbnRmLCAyLCAzKSkpOworCisvKioKKyAqIEhlbHBlciBmdW5jdGlvbiB3aGljaCBmb3JtYXRzIHRoZSBkaWUgZXJyb3IgbWVzc2FnZSBhY2NvcmRpbmcgdG8gdGhlCisgKiBwYXJhbWV0ZXJzIGVudGVyZWQuIFVzZWQgYnkgYGdpdF9kaWVfY29uZmlnKClgLiBJdCBjYW4gYmUgdXNlZCBieSBjYWxsZXJzCisgKiBoYW5kbGluZyBgZ2l0X2NvbmZpZ19nZXRfdmFsdWVfbXVsdGkoKWAgdG8gcHJpbnQgdGhlIGNvcnJlY3QgZXJyb3IgbWVzc2FnZQorICogZm9yIHRoZSBkZXNpcmVkIHZhbHVlLgorICovCiBOT1JFVFVSTiB2b2lkIGdpdF9kaWVfY29uZmlnX2xpbmVucihjb25zdCBjaGFyICprZXksIGNvbnN0IGNoYXIgKmZpbGVuYW1lLCBpbnQgbGluZW5yKTsKIAogI2RlZmluZSBMT09LVVBfQ09ORklHKG1hcHBpbmcsIHZhcikgXApkaWZmIC0tZ2l0IGEvY29uZmlnLm1hay51bmFtZSBiL2NvbmZpZy5tYWsudW5hbWUKaW5kZXggZGI3ZjA2Yi4uY2M4ZWZkOSAxMDA2NDQKLS0tIGEvY29uZmlnLm1hay51bmFtZQorKysgYi9jb25maWcubWFrLnVuYW1lCkBAIC03MDMsMjAgKzcwMywyNCBAQAogCXBlcmwgY29udHJpYi9idWlsZHN5c3RlbXMvZ2VuZXJhdGUgLWcgVmN4cHJvagogCWdpdCBhZGQgLWYgZ2l0LnNsbiB7KiwqL2xpYix0L2hlbHBlci8qfS8qLnZjeHByb2oKIAotCSMgR2VuZXJhdGUgdGhlIExpbmtPckNvcHlCdWlsdGlucy50YXJnZXRzIGZpbGUKKwkjIEdlbmVyYXRlIHRoZSBMaW5rT3JDb3B5QnVpbHRpbnMudGFyZ2V0cyBhbmQgTGlua09yQ29weVJlbW90ZUh0dHAudGFyZ2V0cyBmaWxlCiAJKGVjaG8gJzxQcm9qZWN0IHhtbG5zPSJodHRwOi8vc2NoZW1hcy5taWNyb3NvZnQuY29tL2RldmVsb3Blci9tc2J1aWxkLzIwMDMiPicgJiYgXAogCSBlY2hvICcgIDxUYXJnZXQgTmFtZT0iQ29weUJ1aWx0aW5zX0FmdGVyQnVpbGQiIEFmdGVyVGFyZ2V0cz0iQWZ0ZXJCdWlsZCI+JyAmJiBcCiAJIGZvciBuYW1lIGluICQoQlVJTFRfSU5TKTtcCiAJIGRvIFwKIAkgICBlY2hvICcgICAgPENvcHkgU291cmNlRmlsZXM9IiQkKE91dERpcilcZ2l0LmV4ZSIgRGVzdGluYXRpb25GaWxlcz0iJCQoT3V0RGlyKVwnIiQkbmFtZSInIiBTa2lwVW5jaGFuZ2VkRmlsZXM9InRydWUiIFVzZUhhcmRsaW5rc0lmUG9zc2libGU9InRydWUiIC8+JzsgXAogCSBkb25lICYmIFwKKwkgZWNobyAnICA8L1RhcmdldD4nICYmIFwKKwkgZWNobyAnPC9Qcm9qZWN0PicpID5naXQvTGlua09yQ29weUJ1aWx0aW5zLnRhcmdldHMKKwkoZWNobyAnPFByb2plY3QgeG1sbnM9Imh0dHA6Ly9zY2hlbWFzLm1pY3Jvc29mdC5jb20vZGV2ZWxvcGVyL21zYnVpbGQvMjAwMyI+JyAmJiBcCisJIGVjaG8gJyAgPFRhcmdldCBOYW1lPSJDb3B5QnVpbHRpbnNfQWZ0ZXJCdWlsZCIgQWZ0ZXJUYXJnZXRzPSJBZnRlckJ1aWxkIj4nICYmIFwKIAkgZm9yIG5hbWUgaW4gJChSRU1PVEVfQ1VSTF9BTElBU0VTKTsgXAogCSBkbyBcCiAJICAgZWNobyAnICAgIDxDb3B5IFNvdXJjZUZpbGVzPSIkJChPdXREaXIpXCciJChSRU1PVEVfQ1VSTF9QUklNQVJZKSInIiBEZXN0aW5hdGlvbkZpbGVzPSIkJChPdXREaXIpXCciJCRuYW1lIiciIFNraXBVbmNoYW5nZWRGaWxlcz0idHJ1ZSIgVXNlSGFyZGxpbmtzSWZQb3NzaWJsZT0idHJ1ZSIgLz4nOyBcCiAJIGRvbmUgJiYgXAogCSBlY2hvICcgIDwvVGFyZ2V0PicgJiYgXAotCSBlY2hvICc8L1Byb2plY3Q+JykgPmdpdC9MaW5rT3JDb3B5QnVpbHRpbnMudGFyZ2V0cwotCWdpdCBhZGQgLWYgZ2l0L0xpbmtPckNvcHlCdWlsdGlucy50YXJnZXRzCisJIGVjaG8gJzwvUHJvamVjdD4nKSA+Z2l0LXJlbW90ZS1odHRwL0xpbmtPckNvcHlSZW1vdGVIdHRwLnRhcmdldHMKKwlnaXQgYWRkIC1mIGdpdC9MaW5rT3JDb3B5QnVpbHRpbnMudGFyZ2V0cyBnaXQtcmVtb3RlLWh0dHAvTGlua09yQ29weVJlbW90ZUh0dHAudGFyZ2V0cwogCiAJIyBBZGQgY29tbWFuZC1saXN0LmgKIAkkKE1BS0UpIE1TVkM9MSBTS0lQX1ZDUEtHPTEgcHJlZml4PS9taW5ndzY0IGNvbW1hbmQtbGlzdC5oCkBAIC03MjQsMTEgKzcyOCwxMCBAQAogCiAJIyBBZGQgc2NyaXB0cwogCXJtIC1mIHBlcmwvcGVybC5tYWsKLQkkKE1BS0UpIE1TVkM9MSBTS0lQX1ZDUEtHPTEgcHJlZml4PS9taW5ndzY0IFwKLQkJJChTQ1JJUFRfTElCKSAkKFNDUklQVF9TSF9HRU4pICQoU0NSSVBUX1BFUkxfR0VOKQorCSQoTUFLRSkgTVNWQz0xIFNLSVBfVkNQS0c9MSBwcmVmaXg9L21pbmd3NjQgJChTQ1JJUFRfTElCKSAkKFNDUklQVFMpCiAJIyBTdHJpcCBvdXQgdGhlIHNhbmUgdG9vbCBwYXRoLCBuZWVkZWQgb25seSBmb3IgYnVpbGRpbmcKIAlzZWQgLWkgJy9eZ2l0X2Jyb2tlbl9wYXRoX2ZpeCAiLiovZCcgZ2l0LXNoLXNldHVwCi0JZ2l0IGFkZCAtZiAkKFNDUklQVF9MSUIpICQoU0NSSVBUX1NIX0dFTikgJChTQ1JJUFRfUEVSTF9HRU4pCisJZ2l0IGFkZCAtZiAkKFNDUklQVF9MSUIpICQoU0NSSVBUUykKIAogCSMgQWRkIFBlcmwgbW9kdWxlCiAJJChNQUtFKSAkKExJQl9QRVJMX0dFTikKQEAgLTc1OCw2ICs3NjEsMTAgQEAKIAkkKE1BS0UpIC1DIHRlbXBsYXRlcwogCWdpdCBhZGQgLWYgdGVtcGxhdGVzL2JvaWxlcnBsYXRlcy5tYWRlIHRlbXBsYXRlcy9ibHQvCiAKKwkjIEFkZCB0aGUgdHJhbnNsYXRlZCBtZXNzYWdlcworCW1ha2UgTVNWQz0xIFNLSVBfVkNQS0c9MSBwcmVmaXg9L21pbmd3NjQgJChNT0ZJTEVTKQorCWdpdCBhZGQgLWYgJChNT0ZJTEVTKQorCiAJIyBBZGQgYnVpbGQgb3B0aW9ucwogCSQoTUFLRSkgTVNWQz0xIFNLSVBfVkNQS0c9MSBwcmVmaXg9L21pbmd3NjQgR0lULUJVSUxELU9QVElPTlMKIAlnaXQgYWRkIC1mIEdJVC1CVUlMRC1PUFRJT05TCmRpZmYgLS1naXQgYS9jb25maWd1cmUuYWMgYi9jb25maWd1cmUuYWMKaW5kZXggYTQzYjQ3Ni4uNjZhZWRiOSAxMDA2NDQKLS0tIGEvY29uZmlndXJlLmFjCisrKyBiL2NvbmZpZ3VyZS5hYwpAQCAtODUsNyArODUsNyBAQAogCiAjIEdJVF9QQVJTRV9XSVRIX1NFVF9NQUtFX1ZBUihXSVRITkFNRSwgVkFSLCBIRUxQX1RFWFQpCiAjIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCi0jIFNldCBWQVIgdG8gdGhlIHZhbHVlIHNwZWNpZWQgYnkgLS13aXRoLVdJVEhOQU1FLgorIyBTZXQgVkFSIHRvIHRoZSB2YWx1ZSBzcGVjaWZpZWQgYnkgLS13aXRoLVdJVEhOQU1FLgogIyBObyB2ZXJpZmljYXRpb24gb2YgYXJndW1lbnRzIGlzIHBlcmZvcm1lZCwgYnV0IHdhcm5pbmdzIGFyZSBpc3N1ZWQKICMgaWYgZWl0aGVyICd5ZXMnIG9yICdubycgaXMgc3BlY2lmaWVkLgogIyBIRUxQX1RFWFQgaXMgcHJlc2VudGVkIHdoZW4gLS1oZWxwIGlzIGNhbGxlZC4KQEAgLTg0NCwxMiArODQ0LDYxIEBACiBBQ19DT01QSUxFX0lGRUxTRShbT0xESUNPTlZURVNUX1NSQ10sCiAJW0FDX01TR19SRVNVTFQoW25vXSldLAogCVtBQ19NU0dfUkVTVUxUKFt5ZXNdKQorCUFDX0RFRklORShIQVZFX09MRF9JQ09OViwgMSkKIAlPTERfSUNPTlY9VW5mb3J0dW5hdGVseVllc10pCiAKIEdJVF9VTlNUQVNIX0ZMQUdTKCRJQ09OVkRJUikKIAogR0lUX0NPTkZfU1VCU1QoW09MRF9JQ09OVl0pCiAKKyMKKyMgRGVmaW5lIElDT05WX09NSVRTX0JPTSBpZiB5b3UgYXJlIG9uIGEgc3lzdGVtIHdoaWNoCisjIGljb252IG9taXRzIGJvbSBmb3IgdXRmLXsxNiwzMn0KK2lmIHRlc3QgLXogIiROT19JQ09OViI7IHRoZW4KK0FDX0NBQ0hFX0NIRUNLKFt3aGV0aGVyIGljb252IG9taXRzIGJvbSBmb3IgdXRmLTE2IGFuZCB1dGYtMzJdLAorIFthY19jdl9pY29udl9vbWl0c19ib21dLAorWworb2xkX0xJQlM9IiRMSUJTIgoraWYgdGVzdCAtbiAiJE5FRURTX0xJQklDT05WIjsgdGhlbgorCUxJQlM9IiRMSUJTIC1saWNvbnYiCitmaQorCitBQ19SVU5fSUZFTFNFKAorCVtBQ19MQU5HX1BST0dSQU0oW0FDX0lOQ0xVREVTX0RFRkFVTFQKKwkjaW5jbHVkZSA8aWNvbnYuaD4KKwkjaWZkZWYgSEFWRV9PTERfSUNPTlYKKwl0eXBlZGVmIGNvbnN0IGNoYXIgKmljb252X2licDsKKwkjZWxzZQorCXR5cGVkZWYgY2hhciAqaWNvbnZfaWJwOworCSNlbmRpZgorCV0sCisJW1sKKwlpbnQgdjsKKwlpY29udl90IGNvbnY7CisJY2hhciBpbltdID0gImEiOyBpY29udl9pYnAgcGluID0gaW47CisJY2hhciBvdXRbMjBdID0gIiI7IGNoYXIgKnBvdXQgPSBvdXQ7CisJc2l6ZV90IGlzeiA9IHNpemVvZiBpbjsKKwlzaXplX3Qgb3N6ID0gc2l6ZW9mIG91dDsKKworCWNvbnYgPSBpY29udl9vcGVuKCJVVEYtMTYiLCAiVVRGLTgiKTsKKwlpY29udihjb252LCAmcGluLCAmaXN6LCAmcG91dCwgJm9zeik7CisJaWNvbnZfY2xvc2UoY29udik7CisJdiA9ICh1bnNpZ25lZCBjaGFyKShvdXRbMF0pICsgKHVuc2lnbmVkIGNoYXIpKG91dFsxXSk7CisJcmV0dXJuIHYgIT0gMHhmZSArIDB4ZmY7CisJXV0pXSwKKwlbYWNfY3ZfaWNvbnZfb21pdHNfYm9tPW5vXSwKKwlbYWNfY3ZfaWNvbnZfb21pdHNfYm9tPXllc10pCisKK0xJQlM9IiRvbGRfTElCUyIKK10pCitpZiB0ZXN0ICJ4JGFjX2N2X2ljb252X29taXRzX2JvbSIgPSB4eWVzOyB0aGVuCisJSUNPTlZfT01JVFNfQk9NPVllcworZWxzZQorCUlDT05WX09NSVRTX0JPTT0KK2ZpCitHSVRfQ09ORl9TVUJTVChbSUNPTlZfT01JVFNfQk9NXSkKK2ZpCisKICMjIENoZWNrcyBmb3IgdHlwZWRlZnMsIHN0cnVjdHVyZXMsIGFuZCBjb21waWxlciBjaGFyYWN0ZXJpc3RpY3MuCiBBQ19NU0dfTk9USUNFKFtDSEVDS1MgZm9yIHR5cGVkZWZzLCBzdHJ1Y3R1cmVzLCBhbmQgY29tcGlsZXIgY2hhcmFjdGVyaXN0aWNzXSkKICMKZGlmZiAtLWdpdCBhL2Nvbm5lY3QuYyBiL2Nvbm5lY3QuYwppbmRleCAyNzc4NDgxLi5kYTdkYWEyIDEwMDY0NAotLS0gYS9jb25uZWN0LmMKKysrIGIvY29ubmVjdC5jCkBAIC05MTUsNiArOTE1LDEwIEBACiAKIAlpZiAocHJvdG9jb2wgPT0gUFJPVE9fTE9DQUwpCiAJCXBhdGggPSBlbmQ7CisJZWxzZSBpZiAocHJvdG9jb2wgPT0gUFJPVE9fRklMRSAmJiAqaG9zdCAhPSAnLycgJiYKKwkJICFoYXNfZG9zX2RyaXZlX3ByZWZpeChob3N0KSAmJgorCQkgb2Zmc2V0XzFzdF9jb21wb25lbnQoaG9zdCAtIDIpID4gMSkKKwkJcGF0aCA9IGhvc3QgLSAyOyAvKiBpbmNsdWRlIHRoZSBsZWFkaW5nICIvLyIgKi8KIAllbHNlIGlmIChwcm90b2NvbCA9PSBQUk9UT19GSUxFICYmIGhhc19kb3NfZHJpdmVfcHJlZml4KGVuZCkpCiAJCXBhdGggPSBlbmQ7IC8qICJmaWxlOi8vJChwd2QpIiBtYXkgYmUgImZpbGU6Ly9DOi9wcm9qZWN0cy9yZXBvIiAqLwogCWVsc2UKZGlmZiAtLWdpdCBhL2Nvbm5lY3RlZC5jIGIvY29ubmVjdGVkLmMKaW5kZXggY2Q5YjMyNC4uYzMzN2Y1ZiAxMDA2NDQKLS0tIGEvY29ubmVjdGVkLmMKKysrIGIvY29ubmVjdGVkLmMKQEAgLTUsNiArNSw3IEBACiAjaW5jbHVkZSAiY29ubmVjdGVkLmgiCiAjaW5jbHVkZSAidHJhbnNwb3J0LmgiCiAjaW5jbHVkZSAicGFja2ZpbGUuaCIKKyNpbmNsdWRlICJwcm9taXNvci1yZW1vdGUuaCIKIAogLyoKICAqIElmIHdlIGZlZWQgYWxsIHRoZSBjb21taXRzIHdlIHdhbnQgdG8gdmVyaWZ5IHRvIHRoaXMgY29tbWFuZApAQCAtMjgsNiArMjksNyBAQAogCXN0cnVjdCBwYWNrZWRfZ2l0ICpuZXdfcGFjayA9IE5VTEw7CiAJc3RydWN0IHRyYW5zcG9ydCAqdHJhbnNwb3J0OwogCXNpemVfdCBiYXNlX2xlbjsKKwljb25zdCB1bnNpZ25lZCBoZXhzeiA9IHRoZV9oYXNoX2FsZ28tPmhleHN6OwogCiAJaWYgKCFvcHQpCiAJCW9wdCA9ICZkZWZhdWx0czsKQEAgLTYwLDcgKzYyLDggQEAKIAkJICogcmVjZWl2ZWQgdGhlIG9iamVjdHMgcG9pbnRlZCB0byBieSBlYWNoIHdhbnRlZCByZWYuCiAJCSAqLwogCQlkbyB7Ci0JCQlpZiAoIXJlcG9faGFzX29iamVjdF9maWxlKHRoZV9yZXBvc2l0b3J5LCAmb2lkKSkKKwkJCWlmICghcmVwb19oYXNfb2JqZWN0X2ZpbGVfd2l0aF9mbGFncyh0aGVfcmVwb3NpdG9yeSwgJm9pZCwKKwkJCQkJCQkgICAgIE9CSkVDVF9JTkZPX1NLSVBfRkVUQ0hfT0JKRUNUKSkKIAkJCQlyZXR1cm4gMTsKIAkJfSB3aGlsZSAoIWZuKGNiX2RhdGEsICZvaWQpKTsKIAkJcmV0dXJuIDA7CkBAIC03Myw3ICs3Niw3IEBACiAJYXJndl9hcnJheV9wdXNoKCZyZXZfbGlzdC5hcmdzLCJyZXYtbGlzdCIpOwogCWFyZ3ZfYXJyYXlfcHVzaCgmcmV2X2xpc3QuYXJncywgIi0tb2JqZWN0cyIpOwogCWFyZ3ZfYXJyYXlfcHVzaCgmcmV2X2xpc3QuYXJncywgIi0tc3RkaW4iKTsKLQlpZiAocmVwb3NpdG9yeV9mb3JtYXRfcGFydGlhbF9jbG9uZSkKKwlpZiAoaGFzX3Byb21pc29yX3JlbW90ZSgpKQogCQlhcmd2X2FycmF5X3B1c2goJnJldl9saXN0LmFyZ3MsICItLWV4Y2x1ZGUtcHJvbWlzb3Itb2JqZWN0cyIpOwogCWlmICghb3B0LT5pc19kZWVwZW5pbmdfZmV0Y2gpIHsKIAkJYXJndl9hcnJheV9wdXNoKCZyZXZfbGlzdC5hcmdzLCAiLS1ub3QiKTsKQEAgLTk5LDcgKzEwMiw3IEBACiAKIAlzaWdjaGFpbl9wdXNoKFNJR1BJUEUsIFNJR19JR04pOwogCi0JY29tbWl0W0dJVF9TSEExX0hFWFNaXSA9ICdcbic7CisJY29tbWl0W2hleHN6XSA9ICdcbic7CiAJZG8gewogCQkvKgogCQkgKiBJZiBpbmRleC1wYWNrIGFscmVhZHkgY2hlY2tlZCB0aGF0OgpAQCAtMTEyLDggKzExNSw4IEBACiAJCWlmIChuZXdfcGFjayAmJiBmaW5kX3BhY2tfZW50cnlfb25lKG9pZC5oYXNoLCBuZXdfcGFjaykpCiAJCQljb250aW51ZTsKIAotCQltZW1jcHkoY29tbWl0LCBvaWRfdG9faGV4KCZvaWQpLCBHSVRfU0hBMV9IRVhTWik7Ci0JCWlmICh3cml0ZV9pbl9mdWxsKHJldl9saXN0LmluLCBjb21taXQsIEdJVF9TSEExX0hFWFNaICsgMSkgPCAwKSB7CisJCW1lbWNweShjb21taXQsIG9pZF90b19oZXgoJm9pZCksIGhleHN6KTsKKwkJaWYgKHdyaXRlX2luX2Z1bGwocmV2X2xpc3QuaW4sIGNvbW1pdCwgaGV4c3ogKyAxKSA8IDApIHsKIAkJCWlmIChlcnJubyAhPSBFUElQRSAmJiBlcnJubyAhPSBFSU5WQUwpCiAJCQkJZXJyb3JfZXJybm8oXygiZmFpbGVkIHdyaXRlIHRvIHJldi1saXN0IikpOwogCQkJZXJyID0gLTE7CmRpZmYgLS1naXQgYS9jb250cmliL2J1aWxkc3lzdGVtcy9HZW5lcmF0b3JzL1ZjeHByb2oucG0gYi9jb250cmliL2J1aWxkc3lzdGVtcy9HZW5lcmF0b3JzL1ZjeHByb2oucG0KaW5kZXggNTc2Y2NhYi4uNWM2NjZmOSAxMDA2NDQKLS0tIGEvY29udHJpYi9idWlsZHN5c3RlbXMvR2VuZXJhdG9ycy9WY3hwcm9qLnBtCisrKyBiL2NvbnRyaWIvYnVpbGRzeXN0ZW1zL0dlbmVyYXRvcnMvVmN4cHJvai5wbQpAQCAtNzksNyArNzksOCBAQAogICAgIGlmICghJHN0YXRpY19saWJyYXJ5KSB7CiAgICAgICAkbGlic19yZWxlYXNlID0gam9pbigiOyIsIHNvcnQoZ3JlcCAvXig/IWxpYmdpdFwubGlifHhkaWZmXC9saWJcLmxpYnx2Y3Mtc3ZuXC9saWJcLmxpYikvLCBAeyQkYnVpbGRfc3RydWN0dXJleyIkcHJlZml4JHtuYW1lfV9MSUJTIn19KSk7CiAgICAgICAkbGlic19kZWJ1ZyA9ICRsaWJzX3JlbGVhc2U7Ci0gICAgICAkbGlic19kZWJ1ZyA9fiBzL3psaWJcLmxpYi96bGliZFwubGliLzsKKyAgICAgICRsaWJzX2RlYnVnID1+IHMvemxpYlwubGliL3psaWJkXC5saWIvZzsKKyAgICAgICRsaWJzX2RlYnVnID1+IHMvbGliY3VybFwubGliL2xpYmN1cmwtZFwubGliL2c7CiAgICAgfQogCiAgICAgJGRlZmluZXMgPX4gcy8tRC8vZzsKQEAgLTExOSwxMyArMTIwLDEzIEBACiAgICAgPFZDUEtHQXJjaCBDb25kaXRpb249IidcJChQbGF0Zm9ybSknPT0nV2luMzInIj54ODYtd2luZG93czwvVkNQS0dBcmNoPgogICAgIDxWQ1BLR0FyY2ggQ29uZGl0aW9uPSInXCQoUGxhdGZvcm0pJyE9J1dpbjMyJyI+eDY0LXdpbmRvd3M8L1ZDUEtHQXJjaD4KICAgICA8VkNQS0dBcmNoRGlyZWN0b3J5PiRjZHVwXFxjb21wYXRcXHZjYnVpbGRcXHZjcGtnXFxpbnN0YWxsZWRcXFwkKFZDUEtHQXJjaCk8L1ZDUEtHQXJjaERpcmVjdG9yeT4KLSAgICA8VkNQS0dCaW5EaXJlY3RvcnkgQ29uZGl0aW9uPSInXChDb25maWd1cmF0aW9uKSc9PSdEZWJ1ZyciPlwkKFZDUEtHQXJjaERpcmVjdG9yeSlcXGRlYnVnXFxiaW48L1ZDUEtHQmluRGlyZWN0b3J5PgotICAgIDxWQ1BLR0xpYkRpcmVjdG9yeSBDb25kaXRpb249IidcKENvbmZpZ3VyYXRpb24pJz09J0RlYnVnJyI+XCQoVkNQS0dBcmNoRGlyZWN0b3J5KVxcZGVidWdcXGxpYjwvVkNQS0dMaWJEaXJlY3Rvcnk+Ci0gICAgPFZDUEtHQmluRGlyZWN0b3J5IENvbmRpdGlvbj0iJ1woQ29uZmlndXJhdGlvbiknIT0nRGVidWcnIj5cJChWQ1BLR0FyY2hEaXJlY3RvcnkpXFxiaW48L1ZDUEtHQmluRGlyZWN0b3J5PgotICAgIDxWQ1BLR0xpYkRpcmVjdG9yeSBDb25kaXRpb249IidcKENvbmZpZ3VyYXRpb24pJyE9J0RlYnVnJyI+XCQoVkNQS0dBcmNoRGlyZWN0b3J5KVxcbGliPC9WQ1BLR0xpYkRpcmVjdG9yeT4KKyAgICA8VkNQS0dCaW5EaXJlY3RvcnkgQ29uZGl0aW9uPSInXCQoQ29uZmlndXJhdGlvbiknPT0nRGVidWcnIj5cJChWQ1BLR0FyY2hEaXJlY3RvcnkpXFxkZWJ1Z1xcYmluPC9WQ1BLR0JpbkRpcmVjdG9yeT4KKyAgICA8VkNQS0dMaWJEaXJlY3RvcnkgQ29uZGl0aW9uPSInXCQoQ29uZmlndXJhdGlvbiknPT0nRGVidWcnIj5cJChWQ1BLR0FyY2hEaXJlY3RvcnkpXFxkZWJ1Z1xcbGliPC9WQ1BLR0xpYkRpcmVjdG9yeT4KKyAgICA8VkNQS0dCaW5EaXJlY3RvcnkgQ29uZGl0aW9uPSInXCQoQ29uZmlndXJhdGlvbiknIT0nRGVidWcnIj5cJChWQ1BLR0FyY2hEaXJlY3RvcnkpXFxiaW48L1ZDUEtHQmluRGlyZWN0b3J5PgorICAgIDxWQ1BLR0xpYkRpcmVjdG9yeSBDb25kaXRpb249IidcJChDb25maWd1cmF0aW9uKSchPSdEZWJ1ZyciPlwkKFZDUEtHQXJjaERpcmVjdG9yeSlcXGxpYjwvVkNQS0dMaWJEaXJlY3Rvcnk+CiAgICAgPFZDUEtHSW5jbHVkZURpcmVjdG9yeT5cJChWQ1BLR0FyY2hEaXJlY3RvcnkpXFxpbmNsdWRlPC9WQ1BLR0luY2x1ZGVEaXJlY3Rvcnk+Ci0gICAgPFZDUEtHTGlicyBDb25kaXRpb249IidcKENvbmZpZ3VyYXRpb24pJz09J0RlYnVnJyI+JGxpYnNfZGVidWc8L1ZDUEtHTGlicz4KLSAgICA8VkNQS0dMaWJzIENvbmRpdGlvbj0iJ1woQ29uZmlndXJhdGlvbiknIT0nRGVidWcnIj4kbGlic19yZWxlYXNlPC9WQ1BLR0xpYnM+CisgICAgPFZDUEtHTGlicyBDb25kaXRpb249IidcJChDb25maWd1cmF0aW9uKSc9PSdEZWJ1ZyciPiRsaWJzX2RlYnVnPC9WQ1BLR0xpYnM+CisgICAgPFZDUEtHTGlicyBDb25kaXRpb249IidcJChDb25maWd1cmF0aW9uKSchPSdEZWJ1ZyciPiRsaWJzX3JlbGVhc2U8L1ZDUEtHTGlicz4KICAgPC9Qcm9wZXJ0eUdyb3VwPgogICA8SW1wb3J0IFByb2plY3Q9IlwkKFZDVGFyZ2V0c1BhdGgpXFxNaWNyb3NvZnQuQ3BwLkRlZmF1bHQucHJvcHMiIC8+CiAgIDxQcm9wZXJ0eUdyb3VwIENvbmRpdGlvbj0iJ1wkKENvbmZpZ3VyYXRpb24pJz09J0RlYnVnJyIgTGFiZWw9IkNvbmZpZ3VyYXRpb24iPgpAQCAtMjc3LDYgKzI3OCw5IEBACiAgICAgaWYgKCR0YXJnZXQgZXEgJ2dpdCcpIHsKICAgICAgIHByaW50IEYgIiAgPEltcG9ydCBQcm9qZWN0PVwiTGlua09yQ29weUJ1aWx0aW5zLnRhcmdldHNcIiAvPlxuIjsKICAgICB9CisgICAgaWYgKCR0YXJnZXQgZXEgJ2dpdC1yZW1vdGUtaHR0cCcpIHsKKyAgICAgIHByaW50IEYgIiAgPEltcG9ydCBQcm9qZWN0PVwiTGlua09yQ29weVJlbW90ZUh0dHAudGFyZ2V0c1wiIC8+XG4iOworICAgIH0KICAgICBwcmludCBGIDw8ICJFT00iOwogPC9Qcm9qZWN0PgogRU9NCmRpZmYgLS1naXQgYS9jb250cmliL2NvY2NpbmVsbGUvY29tbWl0LmNvY2NpIGIvY29udHJpYi9jb2NjaW5lbGxlL2NvbW1pdC5jb2NjaQppbmRleCBkMDM0NTMzLi43NzhlNDcwIDEwMDY0NAotLS0gYS9jb250cmliL2NvY2NpbmVsbGUvY29tbWl0LmNvY2NpCisrKyBiL2NvbnRyaWIvY29jY2luZWxsZS9jb21taXQuY29jY2kKQEAgLTIwLDcgKzIwLDcgQEAKICsgc2V0X2NvbW1pdF90cmVlKGMsIHMpCiAgIC4uLj59CiAKLS8vIFRoZXNlIGV4Y2x1ZGVkIGZ1bmN0aW9ucyBtdXN0IGFjY2VzcyBjLT5tYXliZV90cmVlIGRpcmVjbHkuCisvLyBUaGVzZSBleGNsdWRlZCBmdW5jdGlvbnMgbXVzdCBhY2Nlc3MgYy0+bWF5YmVfdHJlZSBkaXJlY3RseS4KIC8vIE5vdGUgdGhhdCBpZiBjLT5tYXliZV90cmVlIGlzIHdyaXR0ZW4gc29tZXdoZXJlIG91dHNpZGUgb2YgdGhlc2UKIC8vIGZ1bmN0aW9ucywgdGhlbiB0aGUgcmVjb21tZW5kZWQgdHJhbnNmb3JtYXRpb24gd2lsbCBiZSBib2d1cyB3aXRoCiAvLyByZXBvX2dldF9jb21taXRfdHJlZSgpIG9uIHRoZSBMSFMuCmRpZmYgLS1naXQgYS9jb250cmliL2NvY2NpbmVsbGUvaGFzaG1hcC5jb2NjaSBiL2NvbnRyaWIvY29jY2luZWxsZS9oYXNobWFwLmNvY2NpCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmQ2OWUxMjAKLS0tIC9kZXYvbnVsbAorKysgYi9jb250cmliL2NvY2NpbmVsbGUvaGFzaG1hcC5jb2NjaQpAQCAtMCwwICsxLDE2IEBACitAIGhhc2htYXBfZW50cnlfaW5pdF91c2FnZSBACitleHByZXNzaW9uIEU7CitzdHJ1Y3QgaGFzaG1hcF9lbnRyeSBITUU7CitAQAorLSBITUUuaGFzaCA9IEU7CisrIGhhc2htYXBfZW50cnlfaW5pdCgmSE1FLCBFKTsKKworQEAKK2lkZW50aWZpZXIgZiAhfiAiXmhhc2htYXBfZW50cnlfaW5pdCQiOworZXhwcmVzc2lvbiBFOworc3RydWN0IGhhc2htYXBfZW50cnkgKkhNRVA7CitAQAorICBmKC4uLikgezwuLi4KKy0gSE1FUC0+aGFzaCA9IEU7CisrIGhhc2htYXBfZW50cnlfaW5pdChITUVQLCBFKTsKKyAgLi4uPn0KZGlmZiAtLWdpdCBhL2NvbnRyaWIvY29jY2luZWxsZS9vYmplY3RfaWQuY29jY2kgYi9jb250cmliL2NvY2NpbmVsbGUvb2JqZWN0X2lkLmNvY2NpCmluZGV4IDNlNTM2YTkuLmRkZjRmMjIgMTAwNjQ0Ci0tLSBhL2NvbnRyaWIvY29jY2luZWxsZS9vYmplY3RfaWQuY29jY2kKKysrIGIvY29udHJpYi9jb2NjaW5lbGxlL29iamVjdF9pZC5jb2NjaQpAQCAtMTMsMzggKzEzLDYgQEAKIEBACiBzdHJ1Y3Qgb2JqZWN0X2lkIE9JRDsKIEBACi0tIHNoYTFfdG9faGV4KE9JRC5oYXNoKQotKyBvaWRfdG9faGV4KCZPSUQpCi0KLUBACi1pZGVudGlmaWVyIGYgIT0gb2lkX3RvX2hleDsKLXN0cnVjdCBvYmplY3RfaWQgKk9JRFBUUjsKLUBACi0gIGYoLi4uKSB7PC4uLgotLSBzaGExX3RvX2hleChPSURQVFItPmhhc2gpCi0rIG9pZF90b19oZXgoT0lEUFRSKQotICAuLi4+fQotCi1AQAotZXhwcmVzc2lvbiBFOwotc3RydWN0IG9iamVjdF9pZCBPSUQ7Ci1AQAotLSBzaGExX3RvX2hleF9yKEUsIE9JRC5oYXNoKQotKyBvaWRfdG9faGV4X3IoRSwgJk9JRCkKLQotQEAKLWlkZW50aWZpZXIgZiAhPSBvaWRfdG9faGV4X3I7Ci1leHByZXNzaW9uIEU7Ci1zdHJ1Y3Qgb2JqZWN0X2lkICpPSURQVFI7Ci1AQAotICAgZiguLi4pIHs8Li4uCi0tIHNoYTFfdG9faGV4X3IoRSwgT0lEUFRSLT5oYXNoKQotKyBvaWRfdG9faGV4X3IoRSwgT0lEUFRSKQotICAuLi4+fQotCi1AQAotc3RydWN0IG9iamVjdF9pZCBPSUQ7Ci1AQAogLSBoYXNoY2xyKE9JRC5oYXNoKQogKyBvaWRjbHIoJk9JRCkKIApkaWZmIC0tZ2l0IGEvY29udHJpYi9jb21wbGV0aW9uL2dpdC1jb21wbGV0aW9uLmJhc2ggYi9jb250cmliL2NvbXBsZXRpb24vZ2l0LWNvbXBsZXRpb24uYmFzaAppbmRleCBlMDg3YzRiLi42NzcwNWRhIDEwMDY0NAotLS0gYS9jb250cmliL2NvbXBsZXRpb24vZ2l0LWNvbXBsZXRpb24uYmFzaAorKysgYi9jb250cmliL2NvbXBsZXRpb24vZ2l0LWNvbXBsZXRpb24uYmFzaApAQCAtMzQwLDcgKzM0MCw3IEBACiAJCQljPSIkYyR7NC19IgogCQkJaWYgW1sgJGMgPT0gIiRjdXJfIiogXV07IHRoZW4KIAkJCQljYXNlICRjIGluCi0JCQkJLS0qPSp8Ki4pIDs7CisJCQkJLS0qPXwqLikgOzsKIAkJCQkqKSBjPSIkYyAiIDs7CiAJCQkJZXNhYwogCQkJCUNPTVBSRVBMWVtpKytdPSIkezItfSRjIgpAQCAtMzYwLDcgKzM2MCw3IEBACiAJCQljPSIkYyR7NC19IgogCQkJaWYgW1sgJGMgPT0gIiRjdXJfIiogXV07IHRoZW4KIAkJCQljYXNlICRjIGluCi0JCQkJLS0qPSp8Ki4pIDs7CisJCQkJKj18Ki4pIDs7CiAJCQkJKikgYz0iJGMgIiA7OwogCQkJCWVzYWMKIAkJCQlDT01QUkVQTFlbaSsrXT0iJHsyLX0kYyIKQEAgLTUyNCw3ICs1MjQsNyBAQAogCQkJIyBFdmVuIHdoZW4gYSBkaXJlY3RvcnkgbmFtZSBpdHNlbGYgZG9lcyBub3QgY29udGFpbgogCQkJIyBhbnkgc3BlY2lhbCBjaGFyYWN0ZXJzLCBpdCB3aWxsIHN0aWxsIGJlIHF1b3RlZCBpZgogCQkJIyBhbnkgb2YgaXRzIChzdHJpcHBlZCkgdHJhaWxpbmcgcGF0aCBjb21wb25lbnRzIGRvLgotCQkJIyBCZWNhdXNlIG9mIHRoaXMgd2UgbWF5IGhhdmUgc2VlbiB0aGUgc2FtZSBkaXJlY29yeQorCQkJIyBCZWNhdXNlIG9mIHRoaXMgd2UgbWF5IGhhdmUgc2VlbiB0aGUgc2FtZSBkaXJlY3RvcnkKIAkJCSMgYm90aCBxdW90ZWQgYW5kIHVucXVvdGVkLgogCQkJaWYgKHAgaW4gcGF0aHMpCiAJCQkJIyBXZSBoYXZlIHNlZW4gdGhlIHNhbWUgZGlyZWN0b3J5IHVucXVvdGVkLApAQCAtNTUwLDcgKzU1MCw3IEBACiAJCQkJCQkgZXNjX2lkeCwgMSkKIAkJCX0gZWxzZSBpZiAoZXNjID09ICJuIikgewogCQkJCSMgVWgtb2gsIGEgbmV3bGluZSBjaGFyYWN0ZXIuCi0JCQkJIyBXZSBjYW50IHJlbGlhYmx5IHB1dCBhIHBhdGhuYW1lCisJCQkJIyBXZSBjYW5ub3QgcmVsaWFibHkgcHV0IGEgcGF0aG5hbWUKIAkJCQkjIGNvbnRhaW5pbmcgYSBuZXdsaW5lIGludG8gQ09NUFJFUExZLAogCQkJCSMgYW5kIHRoZSBuZXdsaW5lIHdvdWxkIGNyZWF0ZSBhIG1lc3MuCiAJCQkJIyBTa2lwIHRoaXMgcGF0aC4KQEAgLTU2NSw3ICs1NjUsNyBAQAogCQkJfQogCQl9CiAJCSMgRHJvcCBjbG9zaW5nIGRvdWJsZSBxdW90ZSwgaWYgdGhlcmUgaXMgb25lLgotCQkjIChUaGVyZSBpc250IGFueSBpZiB0aGlzIGlzIGEgZGlyZWN0b3J5LCBhcyBpdCB3YXMKKwkJIyAoVGhlcmUgaXMgbm90IGFueSBpZiB0aGlzIGlzIGEgZGlyZWN0b3J5LCBhcyBpdCB3YXMKIAkJIyBhbHJlYWR5IHN0cmlwcGVkIHdpdGggdGhlIHRyYWlsaW5nIHBhdGggY29tcG9uZW50cy4pCiAJCWlmIChzdWJzdHIocCwgbGVuZ3RoKHApLCAxKSA9PSAiXCIiKQogCQkJb3V0ID0gb3V0IHN1YnN0cihwLCAxLCBsZW5ndGgocCkgLSAxKQpAQCAtMTI1MCwxMCArMTI1MCw3IEBACiAJCXJldHVybgogCQk7OwogCS0tKikKLQkJX19naXRjb21wICIKLQkJCS0tZm9ybWF0PSAtLWxpc3QgLS12ZXJib3NlCi0JCQktLXByZWZpeD0gLS1yZW1vdGU9IC0tZXhlYz0gLS1vdXRwdXQKLQkJCSIKKwkJX19naXRjb21wX2J1aWx0aW4gYXJjaGl2ZSAiLS1mb3JtYXQ9IC0tbGlzdCAtLXZlcmJvc2UgLS1wcmVmaXg9IC0td29ya3RyZWUtYXR0cmlidXRlcyIKIAkJcmV0dXJuCiAJCTs7CiAJZXNhYwpAQCAtMTM2MSw3ICsxMzU4LDkgQEAKIAllc2FjCiB9CiAKLV9fZ2l0X2NoZXJyeV9waWNrX2lucHJvZ3Jlc3Nfb3B0aW9ucz0iLS1jb250aW51ZSAtLXF1aXQgLS1hYm9ydCIKK19fZ2l0X3NlcXVlbmNlcl9pbnByb2dyZXNzX29wdGlvbnM9Ii0tY29udGludWUgLS1xdWl0IC0tYWJvcnQgLS1za2lwIgorCitfX2dpdF9jaGVycnlfcGlja19pbnByb2dyZXNzX29wdGlvbnM9JF9fZ2l0X3NlcXVlbmNlcl9pbnByb2dyZXNzX29wdGlvbnMKIAogX2dpdF9jaGVycnlfcGljayAoKQogewpAQCAtMTM5OSw3ICsxMzk4LDE4IEBACiAKIF9naXRfY2xvbmUgKCkKIHsKKwljYXNlICIkcHJldiIgaW4KKwktY3wtLWNvbmZpZykKKwkJX19naXRfY29tcGxldGVfY29uZmlnX3ZhcmlhYmxlX25hbWVfYW5kX3ZhbHVlCisJCXJldHVybgorCQk7OworCWVzYWMKIAljYXNlICIkY3VyIiBpbgorCS0tY29uZmlnPSopCisJCV9fZ2l0X2NvbXBsZXRlX2NvbmZpZ192YXJpYWJsZV9uYW1lX2FuZF92YWx1ZSBcCisJCQktLWN1cj0iJHtjdXIjIy0tY29uZmlnPX0iCisJCXJldHVybgorCQk7OwogCS0tKikKIAkJX19naXRjb21wX2J1aWx0aW4gY2xvbmUKIAkJcmV0dXJuCkBAIC0xNDc2LDYgKzE0ODYsOCBAQAogCQkJLS1kaXJzdGF0LWJ5LWZpbGU9IC0tY3VtdWxhdGl2ZQogCQkJLS1kaWZmLWFsZ29yaXRobT0KIAkJCS0tc3VibW9kdWxlIC0tc3VibW9kdWxlPSAtLWlnbm9yZS1zdWJtb2R1bGVzCisJCQktLWluZGVudC1oZXVyaXN0aWMgLS1uby1pbmRlbnQtaGV1cmlzdGljCisJCQktLXRleHRjb252IC0tbm8tdGV4dGNvbnYKICIKIAogX2dpdF9kaWZmICgpCkBAIC0xNzg0LDYgKzE3OTYsMTAgQEAKIAkJX19naXRjb21wICIkX19naXRfZGlmZl9zdWJtb2R1bGVfZm9ybWF0cyIgIiIgIiR7Y3VyIyMtLXN1Ym1vZHVsZT19IgogCQlyZXR1cm4KIAkJOzsKKwktLW5vLXdhbGs9KikKKwkJX19naXRjb21wICJzb3J0ZWQgdW5zb3J0ZWQiICIiICIke2N1ciMjLS1uby13YWxrPX0iCisJCXJldHVybgorCQk7OwogCS0tKikKIAkJX19naXRjb21wICIKIAkJCSRfX2dpdF9sb2dfY29tbW9uX29wdGlvbnMKQEAgLTE3OTEsMTYgKzE4MDcsMTkgQEAKIAkJCSRfX2dpdF9sb2dfZ2l0a19vcHRpb25zCiAJCQktLXJvb3QgLS10b3BvLW9yZGVyIC0tZGF0ZS1vcmRlciAtLXJldmVyc2UKIAkJCS0tZm9sbG93IC0tZnVsbC1kaWZmCi0JCQktLWFiYnJldi1jb21taXQgLS1hYmJyZXY9CisJCQktLWFiYnJldi1jb21taXQgLS1uby1hYmJyZXYtY29tbWl0IC0tYWJicmV2PQogCQkJLS1yZWxhdGl2ZS1kYXRlIC0tZGF0ZT0KIAkJCS0tcHJldHR5PSAtLWZvcm1hdD0gLS1vbmVsaW5lCiAJCQktLXNob3ctc2lnbmF0dXJlCiAJCQktLWNoZXJyeS1tYXJrCiAJCQktLWNoZXJyeS1waWNrCiAJCQktLWdyYXBoCi0JCQktLWRlY29yYXRlIC0tZGVjb3JhdGU9CisJCQktLWRlY29yYXRlIC0tZGVjb3JhdGU9IC0tbm8tZGVjb3JhdGUKIAkJCS0td2Fsay1yZWZsb2dzCisJCQktLW5vLXdhbGsgLS1uby13YWxrPSAtLWRvLXdhbGsKIAkJCS0tcGFyZW50cyAtLWNoaWxkcmVuCisJCQktLWV4cGFuZC10YWJzIC0tZXhwYW5kLXRhYnM9IC0tbm8tZXhwYW5kLXRhYnMKKwkJCS0tcGF0Y2gKIAkJCSRtZXJnZQogCQkJJF9fZ2l0X2RpZmZfY29tbW9uX29wdGlvbnMKIAkJCS0tcGlja2F4ZS1hbGwgLS1waWNrYXhlLXJlZ2V4CkBAIC0yMDA0LDE1ICsyMDIzLDE4IEBACiAJX19naXRfY29tcGxldGVfcmV2bGlzdAogfQogCitfX2dpdF9yZWJhc2VfaW5wcm9ncmVzc19vcHRpb25zPSItLWNvbnRpbnVlIC0tc2tpcCAtLWFib3J0IC0tcXVpdCAtLXNob3ctY3VycmVudC1wYXRjaCIKK19fZ2l0X3JlYmFzZV9pbnRlcmFjdGl2ZV9pbnByb2dyZXNzX29wdGlvbnM9IiRfX2dpdF9yZWJhc2VfaW5wcm9ncmVzc19vcHRpb25zIC0tZWRpdC10b2RvIgorCiBfZ2l0X3JlYmFzZSAoKQogewogCV9fZ2l0X2ZpbmRfcmVwb19wYXRoCiAJaWYgWyAtZiAiJF9fZ2l0X3JlcG9fcGF0aCIvcmViYXNlLW1lcmdlL2ludGVyYWN0aXZlIF07IHRoZW4KLQkJX19naXRjb21wICItLWNvbnRpbnVlIC0tc2tpcCAtLWFib3J0IC0tcXVpdCAtLWVkaXQtdG9kbyAtLXNob3ctY3VycmVudC1wYXRjaCIKKwkJX19naXRjb21wICIkX19naXRfcmViYXNlX2ludGVyYWN0aXZlX2lucHJvZ3Jlc3Nfb3B0aW9ucyIKIAkJcmV0dXJuCiAJZWxpZiBbIC1kICIkX19naXRfcmVwb19wYXRoIi9yZWJhc2UtYXBwbHkgXSB8fCBcCiAJICAgICBbIC1kICIkX19naXRfcmVwb19wYXRoIi9yZWJhc2UtbWVyZ2UgXTsgdGhlbgotCQlfX2dpdGNvbXAgIi0tY29udGludWUgLS1za2lwIC0tYWJvcnQgLS1xdWl0IC0tc2hvdy1jdXJyZW50LXBhdGNoIgorCQlfX2dpdGNvbXAgIiRfX2dpdF9yZWJhc2VfaW5wcm9ncmVzc19vcHRpb25zIgogCQlyZXR1cm4KIAlmaQogCV9fZ2l0X2NvbXBsZXRlX3N0cmF0ZWd5ICYmIHJldHVybgpAQCAtMjAyMSwyMCArMjA0MywxMyBAQAogCQlfX2dpdGNvbXAgIiRfX2dpdF93aGl0ZXNwYWNlbGlzdCIgIiIgIiR7Y3VyIyMtLXdoaXRlc3BhY2U9fSIKIAkJcmV0dXJuCiAJCTs7CisJLS1vbnRvPSopCisJCV9fZ2l0X2NvbXBsZXRlX3JlZnMgLS1jdXI9IiR7Y3VyIyMtLW9udG89fSIKKwkJcmV0dXJuCisJCTs7CiAJLS0qKQotCQlfX2dpdGNvbXAgIgotCQkJLS1vbnRvIC0tbWVyZ2UgLS1zdHJhdGVneSAtLWludGVyYWN0aXZlCi0JCQktLXJlYmFzZS1tZXJnZXMgLS1wcmVzZXJ2ZS1tZXJnZXMgLS1zdGF0IC0tbm8tc3RhdAotCQkJLS1jb21taXR0ZXItZGF0ZS1pcy1hdXRob3ItZGF0ZSAtLWlnbm9yZS1kYXRlCi0JCQktLWlnbm9yZS13aGl0ZXNwYWNlIC0td2hpdGVzcGFjZT0KLQkJCS0tYXV0b3NxdWFzaCAtLW5vLWF1dG9zcXVhc2gKLQkJCS0tZm9yay1wb2ludCAtLW5vLWZvcmstcG9pbnQKLQkJCS0tYXV0b3N0YXNoIC0tbm8tYXV0b3N0YXNoCi0JCQktLXZlcmlmeSAtLW5vLXZlcmlmeQotCQkJLS1rZWVwLWVtcHR5IC0tcm9vdCAtLWZvcmNlLXJlYmFzZSAtLW5vLWZmCi0JCQktLXJlcmVyZS1hdXRvdXBkYXRlCi0JCQktLWV4ZWMKLQkJCSIKKwkJX19naXRjb21wX2J1aWx0aW4gcmViYXNlICIiIFwKKwkJCSIkX19naXRfcmViYXNlX2ludGVyYWN0aXZlX2lucHJvZ3Jlc3Nfb3B0aW9ucyIKIAogCQlyZXR1cm4KIAllc2FjCkBAIC0yMjI1LDE4MSArMjI0MCwyODIgQEAKIF9fZ2l0X2NvbXB1dGVfY29uZmlnX3ZhcnMgKCkKIHsKIAl0ZXN0IC1uICIkX19naXRfY29uZmlnX3ZhcnMiIHx8Ci0JX19naXRfY29uZmlnX3ZhcnM9IiQoZ2l0IGhlbHAgLS1jb25maWctZm9yLWNvbXBsZXRpb24gfCBzb3J0IHwgdW5pcSkiCisJX19naXRfY29uZmlnX3ZhcnM9IiQoZ2l0IGhlbHAgLS1jb25maWctZm9yLWNvbXBsZXRpb24gfCBzb3J0IC11KSIKIH0KIAotX2dpdF9jb25maWcgKCkKKyMgQ29tcGxldGVzIHBvc3NpYmxlIHZhbHVlcyBvZiB2YXJpb3VzIGNvbmZpZ3VyYXRpb24gdmFyaWFibGVzLgorIworIyBVc2FnZTogX19naXRfY29tcGxldGVfY29uZmlnX3ZhcmlhYmxlX3ZhbHVlIFs8b3B0aW9uPl0uLi4KKyMgLS12YXJuYW1lPTx3b3JkPjogVGhlIG5hbWUgb2YgdGhlIGNvbmZpZ3VyYXRpb24gdmFyaWFibGUgd2hvc2UgdmFsdWUgaXMKKyMgICAgICAgICAgICAgICAgICAgdG8gYmUgY29tcGxldGVkLiAgRGVmYXVsdHMgdG8gdGhlIHByZXZpb3VzIHdvcmQgb24gdGhlCisjICAgICAgICAgICAgICAgICAgIGNvbW1hbmQgbGluZS4KKyMgLS1jdXI9PHdvcmQ+OiBUaGUgY3VycmVudCB2YWx1ZSB0byBiZSBjb21wbGV0ZWQuICBEZWZhdWx0cyB0byB0aGUgY3VycmVudAorIyAgICAgICAgICAgICAgIHdvcmQgdG8gYmUgY29tcGxldGVkLgorX19naXRfY29tcGxldGVfY29uZmlnX3ZhcmlhYmxlX3ZhbHVlICgpCiB7Ci0JbG9jYWwgdmFybmFtZQorCWxvY2FsIHZhcm5hbWU9IiRwcmV2IiBjdXJfPSIkY3VyIgorCisJd2hpbGUgdGVzdCAkIyAhPSAwOyBkbworCQljYXNlICIkMSIgaW4KKwkJLS12YXJuYW1lPSopCXZhcm5hbWU9IiR7MSMjLS12YXJuYW1lPX0iIDs7CisJCS0tY3VyPSopCWN1cl89IiR7MSMjLS1jdXI9fSIgOzsKKwkJKikJCXJldHVybiAxIDs7CisJCWVzYWMKKwkJc2hpZnQKKwlkb25lCiAKIAlpZiBbICIke0JBU0hfVkVSU0lORk9bMF06LTB9IiAtZ2UgNCBdOyB0aGVuCi0JCXZhcm5hbWU9IiR7cHJldiwsfSIKKwkJdmFybmFtZT0iJHt2YXJuYW1lLCx9IgogCWVsc2UKLQkJdmFybmFtZT0iJChlY2hvICIkcHJldiIgfHRyIEEtWiBhLXopIgorCQl2YXJuYW1lPSIkKGVjaG8gIiR2YXJuYW1lIiB8dHIgQS1aIGEteikiCiAJZmkKIAogCWNhc2UgIiR2YXJuYW1lIiBpbgogCWJyYW5jaC4qLnJlbW90ZXxicmFuY2guKi5wdXNocmVtb3RlKQotCQlfX2dpdGNvbXBfbmwgIiQoX19naXRfcmVtb3RlcykiCisJCV9fZ2l0Y29tcF9ubCAiJChfX2dpdF9yZW1vdGVzKSIgIiIgIiRjdXJfIgogCQlyZXR1cm4KIAkJOzsKIAlicmFuY2guKi5tZXJnZSkKLQkJX19naXRfY29tcGxldGVfcmVmcworCQlfX2dpdF9jb21wbGV0ZV9yZWZzIC0tY3VyPSIkY3VyXyIKIAkJcmV0dXJuCiAJCTs7CiAJYnJhbmNoLioucmViYXNlKQotCQlfX2dpdGNvbXAgImZhbHNlIHRydWUgbWVyZ2VzIHByZXNlcnZlIGludGVyYWN0aXZlIgorCQlfX2dpdGNvbXAgImZhbHNlIHRydWUgbWVyZ2VzIHByZXNlcnZlIGludGVyYWN0aXZlIiAiIiAiJGN1cl8iCiAJCXJldHVybgogCQk7OwogCXJlbW90ZS5wdXNoZGVmYXVsdCkKLQkJX19naXRjb21wX25sICIkKF9fZ2l0X3JlbW90ZXMpIgorCQlfX2dpdGNvbXBfbmwgIiQoX19naXRfcmVtb3RlcykiICIiICIkY3VyXyIKIAkJcmV0dXJuCiAJCTs7CiAJcmVtb3RlLiouZmV0Y2gpCi0JCWxvY2FsIHJlbW90ZT0iJHtwcmV2I3JlbW90ZS59IgorCQlsb2NhbCByZW1vdGU9IiR7dmFybmFtZSNyZW1vdGUufSIKIAkJcmVtb3RlPSIke3JlbW90ZSUuZmV0Y2h9IgotCQlpZiBbIC16ICIkY3VyIiBdOyB0aGVuCisJCWlmIFsgLXogIiRjdXJfIiBdOyB0aGVuCiAJCQlfX2dpdGNvbXBfbmwgInJlZnMvaGVhZHMvIiAiIiAiIiAiIgogCQkJcmV0dXJuCiAJCWZpCi0JCV9fZ2l0Y29tcF9ubCAiJChfX2dpdF9yZWZzX3JlbW90ZXMgIiRyZW1vdGUiKSIKKwkJX19naXRjb21wX25sICIkKF9fZ2l0X3JlZnNfcmVtb3RlcyAiJHJlbW90ZSIpIiAiIiAiJGN1cl8iCiAJCXJldHVybgogCQk7OwogCXJlbW90ZS4qLnB1c2gpCi0JCWxvY2FsIHJlbW90ZT0iJHtwcmV2I3JlbW90ZS59IgorCQlsb2NhbCByZW1vdGU9IiR7dmFybmFtZSNyZW1vdGUufSIKIAkJcmVtb3RlPSIke3JlbW90ZSUucHVzaH0iCiAJCV9fZ2l0Y29tcF9ubCAiJChfX2dpdCBmb3ItZWFjaC1yZWYgXAotCQkJLS1mb3JtYXQ9JyUocmVmbmFtZSk6JShyZWZuYW1lKScgcmVmcy9oZWFkcykiCisJCQktLWZvcm1hdD0nJShyZWZuYW1lKTolKHJlZm5hbWUpJyByZWZzL2hlYWRzKSIgIiIgIiRjdXJfIgogCQlyZXR1cm4KIAkJOzsKIAlwdWxsLnR3b2hlYWR8cHVsbC5vY3RvcHVzKQogCQlfX2dpdF9jb21wdXRlX21lcmdlX3N0cmF0ZWdpZXMKLQkJX19naXRjb21wICIkX19naXRfbWVyZ2Vfc3RyYXRlZ2llcyIKLQkJcmV0dXJuCi0JCTs7Ci0JY29sb3IuYnJhbmNofGNvbG9yLmRpZmZ8Y29sb3IuaW50ZXJhY3RpdmV8XAotCWNvbG9yLnNob3dicmFuY2h8Y29sb3Iuc3RhdHVzfGNvbG9yLnVpKQotCQlfX2dpdGNvbXAgImFsd2F5cyBuZXZlciBhdXRvIgorCQlfX2dpdGNvbXAgIiRfX2dpdF9tZXJnZV9zdHJhdGVnaWVzIiAiIiAiJGN1cl8iCiAJCXJldHVybgogCQk7OwogCWNvbG9yLnBhZ2VyKQotCQlfX2dpdGNvbXAgImZhbHNlIHRydWUiCisJCV9fZ2l0Y29tcCAiZmFsc2UgdHJ1ZSIgIiIgIiRjdXJfIgogCQlyZXR1cm4KIAkJOzsKIAljb2xvci4qLiopCiAJCV9fZ2l0Y29tcCAiCiAJCQlub3JtYWwgYmxhY2sgcmVkIGdyZWVuIHllbGxvdyBibHVlIG1hZ2VudGEgY3lhbiB3aGl0ZQogCQkJYm9sZCBkaW0gdWwgYmxpbmsgcmV2ZXJzZQotCQkJIgorCQkJIiAiIiAiJGN1cl8iCisJCXJldHVybgorCQk7OworCWNvbG9yLiopCisJCV9fZ2l0Y29tcCAiZmFsc2UgdHJ1ZSBhbHdheXMgbmV2ZXIgYXV0byIgIiIgIiRjdXJfIgogCQlyZXR1cm4KIAkJOzsKIAlkaWZmLnN1Ym1vZHVsZSkKLQkJX19naXRjb21wICIkX19naXRfZGlmZl9zdWJtb2R1bGVfZm9ybWF0cyIKKwkJX19naXRjb21wICIkX19naXRfZGlmZl9zdWJtb2R1bGVfZm9ybWF0cyIgIiIgIiRjdXJfIgogCQlyZXR1cm4KIAkJOzsKIAloZWxwLmZvcm1hdCkKLQkJX19naXRjb21wICJtYW4gaW5mbyB3ZWIgaHRtbCIKKwkJX19naXRjb21wICJtYW4gaW5mbyB3ZWIgaHRtbCIgIiIgIiRjdXJfIgogCQlyZXR1cm4KIAkJOzsKIAlsb2cuZGF0ZSkKLQkJX19naXRjb21wICIkX19naXRfbG9nX2RhdGVfZm9ybWF0cyIKKwkJX19naXRjb21wICIkX19naXRfbG9nX2RhdGVfZm9ybWF0cyIgIiIgIiRjdXJfIgogCQlyZXR1cm4KIAkJOzsKIAlzZW5kZW1haWwuYWxpYXNmaWxldHlwZSkKLQkJX19naXRjb21wICJtdXR0IG1haWxyYyBwaW5lIGVsbSBnbnVzIgorCQlfX2dpdGNvbXAgIm11dHQgbWFpbHJjIHBpbmUgZWxtIGdudXMiICIiICIkY3VyXyIKIAkJcmV0dXJuCiAJCTs7CiAJc2VuZGVtYWlsLmNvbmZpcm0pCi0JCV9fZ2l0Y29tcCAiJF9fZ2l0X3NlbmRfZW1haWxfY29uZmlybV9vcHRpb25zIgorCQlfX2dpdGNvbXAgIiRfX2dpdF9zZW5kX2VtYWlsX2NvbmZpcm1fb3B0aW9ucyIgIiIgIiRjdXJfIgogCQlyZXR1cm4KIAkJOzsKIAlzZW5kZW1haWwuc3VwcHJlc3NjYykKLQkJX19naXRjb21wICIkX19naXRfc2VuZF9lbWFpbF9zdXBwcmVzc2NjX29wdGlvbnMiCisJCV9fZ2l0Y29tcCAiJF9fZ2l0X3NlbmRfZW1haWxfc3VwcHJlc3NjY19vcHRpb25zIiAiIiAiJGN1cl8iCiAJCXJldHVybgogCQk7OwogCXNlbmRlbWFpbC50cmFuc2ZlcmVuY29kaW5nKQotCQlfX2dpdGNvbXAgIjdiaXQgOGJpdCBxdW90ZWQtcHJpbnRhYmxlIGJhc2U2NCIKLQkJcmV0dXJuCi0JCTs7Ci0JLS1nZXR8LS1nZXQtYWxsfC0tdW5zZXR8LS11bnNldC1hbGwpCi0JCV9fZ2l0Y29tcF9ubCAiJChfX2dpdF9jb25maWdfZ2V0X3NldF92YXJpYWJsZXMpIgorCQlfX2dpdGNvbXAgIjdiaXQgOGJpdCBxdW90ZWQtcHJpbnRhYmxlIGJhc2U2NCIgIiIgIiRjdXJfIgogCQlyZXR1cm4KIAkJOzsKIAkqLiopCiAJCXJldHVybgogCQk7OwogCWVzYWMKLQljYXNlICIkY3VyIiBpbgotCS0tKikKLQkJX19naXRjb21wX2J1aWx0aW4gY29uZmlnCi0JCXJldHVybgotCQk7OworfQorCisjIENvbXBsZXRlcyBjb25maWd1cmF0aW9uIHNlY3Rpb25zLCBzdWJzZWN0aW9ucywgdmFyaWFibGUgbmFtZXMuCisjCisjIFVzYWdlOiBfX2dpdF9jb21wbGV0ZV9jb25maWdfdmFyaWFibGVfbmFtZSBbPG9wdGlvbj5dLi4uCisjIC0tY3VyPTx3b3JkPjogVGhlIGN1cnJlbnQgY29uZmlndXJhdGlvbiBzZWN0aW9uL3ZhcmlhYmxlIG5hbWUgdG8gYmUKKyMgICAgICAgICAgICAgICBjb21wbGV0ZWQuICBEZWZhdWx0cyB0byB0aGUgY3VycmVudCB3b3JkIHRvIGJlIGNvbXBsZXRlZC4KKyMgLS1zZng9PHN1ZmZpeD46IEEgc3VmZml4IHRvIGJlIGFwcGVuZGVkIHRvIGVhY2ggZnVsbHkgY29tcGxldGVkCisjICAgICAgICAgICAgICAgICBjb25maWd1cmF0aW9uIHZhcmlhYmxlIG5hbWUgKGJ1dCBub3QgdG8gc2VjdGlvbnMgb3IKKyMgICAgICAgICAgICAgICAgIHN1YnNlY3Rpb25zKSBpbnN0ZWFkIG9mIHRoZSBkZWZhdWx0IHNwYWNlLgorX19naXRfY29tcGxldGVfY29uZmlnX3ZhcmlhYmxlX25hbWUgKCkKK3sKKwlsb2NhbCBjdXJfPSIkY3VyIiBzZngKKworCXdoaWxlIHRlc3QgJCMgIT0gMDsgZG8KKwkJY2FzZSAiJDEiIGluCisJCS0tY3VyPSopCWN1cl89IiR7MSMjLS1jdXI9fSIgOzsKKwkJLS1zZng9KikJc2Z4PSIkezEjIy0tc2Z4PX0iIDs7CisJCSopCQlyZXR1cm4gMSA7OworCQllc2FjCisJCXNoaWZ0CisJZG9uZQorCisJY2FzZSAiJGN1cl8iIGluCiAJYnJhbmNoLiouKikKLQkJbG9jYWwgcGZ4PSIke2N1ciUuKn0uIiBjdXJfPSIke2N1ciMjKi59IgotCQlfX2dpdGNvbXAgInJlbW90ZSBwdXNoUmVtb3RlIG1lcmdlIG1lcmdlT3B0aW9ucyByZWJhc2UiICIkcGZ4IiAiJGN1cl8iCisJCWxvY2FsIHBmeD0iJHtjdXJfJS4qfS4iCisJCWN1cl89IiR7Y3VyXyMjKi59IgorCQlfX2dpdGNvbXAgInJlbW90ZSBwdXNoUmVtb3RlIG1lcmdlIG1lcmdlT3B0aW9ucyByZWJhc2UiICIkcGZ4IiAiJGN1cl8iICIkc2Z4IgogCQlyZXR1cm4KIAkJOzsKIAlicmFuY2guKikKLQkJbG9jYWwgcGZ4PSIke2N1ciUuKn0uIiBjdXJfPSIke2N1ciMqLn0iCisJCWxvY2FsIHBmeD0iJHtjdXIlLip9LiIKKwkJY3VyXz0iJHtjdXIjKi59IgogCQlfX2dpdGNvbXBfZGlyZWN0ICIkKF9fZ2l0X2hlYWRzICIkcGZ4IiAiJGN1cl8iICIuIikiCi0JCV9fZ2l0Y29tcF9ubF9hcHBlbmQgJCdhdXRvU2V0dXBNZXJnZVxuYXV0b1NldHVwUmViYXNlXG4nICIkcGZ4IiAiJGN1cl8iCisJCV9fZ2l0Y29tcF9ubF9hcHBlbmQgJCdhdXRvU2V0dXBNZXJnZVxuYXV0b1NldHVwUmViYXNlXG4nICIkcGZ4IiAiJGN1cl8iICIkc2Z4IgogCQlyZXR1cm4KIAkJOzsKIAlndWl0b29sLiouKikKLQkJbG9jYWwgcGZ4PSIke2N1ciUuKn0uIiBjdXJfPSIke2N1ciMjKi59IgorCQlsb2NhbCBwZng9IiR7Y3VyXyUuKn0uIgorCQljdXJfPSIke2N1cl8jIyoufSIKIAkJX19naXRjb21wICIKIAkJCWFyZ1Byb21wdCBjbWQgY29uZmlybSBuZWVkc0ZpbGUgbm9Db25zb2xlIG5vUmVzY2FuCiAJCQlwcm9tcHQgcmV2UHJvbXB0IHJldlVubWVyZ2VkIHRpdGxlCi0JCQkiICIkcGZ4IiAiJGN1cl8iCisJCQkiICIkcGZ4IiAiJGN1cl8iICIkc2Z4IgogCQlyZXR1cm4KIAkJOzsKIAlkaWZmdG9vbC4qLiopCi0JCWxvY2FsIHBmeD0iJHtjdXIlLip9LiIgY3VyXz0iJHtjdXIjIyoufSIKLQkJX19naXRjb21wICJjbWQgcGF0aCIgIiRwZngiICIkY3VyXyIKKwkJbG9jYWwgcGZ4PSIke2N1cl8lLip9LiIKKwkJY3VyXz0iJHtjdXJfIyMqLn0iCisJCV9fZ2l0Y29tcCAiY21kIHBhdGgiICIkcGZ4IiAiJGN1cl8iICIkc2Z4IgogCQlyZXR1cm4KIAkJOzsKIAltYW4uKi4qKQotCQlsb2NhbCBwZng9IiR7Y3VyJS4qfS4iIGN1cl89IiR7Y3VyIyMqLn0iCi0JCV9fZ2l0Y29tcCAiY21kIHBhdGgiICIkcGZ4IiAiJGN1cl8iCisJCWxvY2FsIHBmeD0iJHtjdXJfJS4qfS4iCisJCWN1cl89IiR7Y3VyXyMjKi59IgorCQlfX2dpdGNvbXAgImNtZCBwYXRoIiAiJHBmeCIgIiRjdXJfIiAiJHNmeCIKIAkJcmV0dXJuCiAJCTs7CiAJbWVyZ2V0b29sLiouKikKLQkJbG9jYWwgcGZ4PSIke2N1ciUuKn0uIiBjdXJfPSIke2N1ciMjKi59IgotCQlfX2dpdGNvbXAgImNtZCBwYXRoIHRydXN0RXhpdENvZGUiICIkcGZ4IiAiJGN1cl8iCisJCWxvY2FsIHBmeD0iJHtjdXJfJS4qfS4iCisJCWN1cl89IiR7Y3VyXyMjKi59IgorCQlfX2dpdGNvbXAgImNtZCBwYXRoIHRydXN0RXhpdENvZGUiICIkcGZ4IiAiJGN1cl8iICIkc2Z4IgogCQlyZXR1cm4KIAkJOzsKIAlwYWdlci4qKQotCQlsb2NhbCBwZng9IiR7Y3VyJS4qfS4iIGN1cl89IiR7Y3VyIyoufSIKKwkJbG9jYWwgcGZ4PSIke2N1cl8lLip9LiIKKwkJY3VyXz0iJHtjdXJfIyoufSIKIAkJX19naXRfY29tcHV0ZV9hbGxfY29tbWFuZHMKLQkJX19naXRjb21wX25sICIkX19naXRfYWxsX2NvbW1hbmRzIiAiJHBmeCIgIiRjdXJfIgorCQlfX2dpdGNvbXBfbmwgIiRfX2dpdF9hbGxfY29tbWFuZHMiICIkcGZ4IiAiJGN1cl8iICIkc2Z4IgogCQlyZXR1cm4KIAkJOzsKIAlyZW1vdGUuKi4qKQotCQlsb2NhbCBwZng9IiR7Y3VyJS4qfS4iIGN1cl89IiR7Y3VyIyMqLn0iCisJCWxvY2FsIHBmeD0iJHtjdXJfJS4qfS4iCisJCWN1cl89IiR7Y3VyXyMjKi59IgogCQlfX2dpdGNvbXAgIgogCQkJdXJsIHByb3h5IGZldGNoIHB1c2ggbWlycm9yIHNraXBEZWZhdWx0VXBkYXRlCiAJCQlyZWNlaXZlcGFjayB1cGxvYWRwYWNrIHRhZ09wdCBwdXNodXJsCi0JCQkiICIkcGZ4IiAiJGN1cl8iCisJCQkiICIkcGZ4IiAiJGN1cl8iICIkc2Z4IgogCQlyZXR1cm4KIAkJOzsKIAlyZW1vdGUuKikKLQkJbG9jYWwgcGZ4PSIke2N1ciUuKn0uIiBjdXJfPSIke2N1ciMqLn0iCisJCWxvY2FsIHBmeD0iJHtjdXJfJS4qfS4iCisJCWN1cl89IiR7Y3VyXyMqLn0iCiAJCV9fZ2l0Y29tcF9ubCAiJChfX2dpdF9yZW1vdGVzKSIgIiRwZngiICIkY3VyXyIgIi4iCi0JCV9fZ2l0Y29tcF9ubF9hcHBlbmQgInB1c2hEZWZhdWx0IiAiJHBmeCIgIiRjdXJfIgorCQlfX2dpdGNvbXBfbmxfYXBwZW5kICJwdXNoRGVmYXVsdCIgIiRwZngiICIkY3VyXyIgIiRzZngiCiAJCXJldHVybgogCQk7OwogCXVybC4qLiopCi0JCWxvY2FsIHBmeD0iJHtjdXIlLip9LiIgY3VyXz0iJHtjdXIjIyoufSIKLQkJX19naXRjb21wICJpbnN0ZWFkT2YgcHVzaEluc3RlYWRPZiIgIiRwZngiICIkY3VyXyIKKwkJbG9jYWwgcGZ4PSIke2N1cl8lLip9LiIKKwkJY3VyXz0iJHtjdXJfIyMqLn0iCisJCV9fZ2l0Y29tcCAiaW5zdGVhZE9mIHB1c2hJbnN0ZWFkT2YiICIkcGZ4IiAiJGN1cl8iICIkc2Z4IgogCQlyZXR1cm4KIAkJOzsKIAkqLiopCiAJCV9fZ2l0X2NvbXB1dGVfY29uZmlnX3ZhcnMKLQkJX19naXRjb21wICIkX19naXRfY29uZmlnX3ZhcnMiCisJCV9fZ2l0Y29tcCAiJF9fZ2l0X2NvbmZpZ192YXJzIiAiIiAiJGN1cl8iICIkc2Z4IgogCQk7OwogCSopCiAJCV9fZ2l0X2NvbXB1dGVfY29uZmlnX3ZhcnMKLQkJX19naXRjb21wICIkKGVjaG8gIiRfX2dpdF9jb25maWdfdmFycyIgfCBzZWQgJ3MvXC5bXiBdKi8uL2cnKSIKKwkJX19naXRjb21wICIkKGVjaG8gIiRfX2dpdF9jb25maWdfdmFycyIgfAorCQkJCWF3ayAtRiAuICd7CisJCQkJCXNlY3Rpb25zWyQxXSA9IDEKKwkJCQl9CisJCQkJRU5EIHsKKwkJCQkJZm9yIChzIGluIHNlY3Rpb25zKQorCQkJCQkJcHJpbnQgcyAiLiIKKwkJCQl9CisJCQkJJykiICIiICIkY3VyXyIKKwkJOzsKKwllc2FjCit9CisKKyMgQ29tcGxldGVzICc9Jy1zZXBhcmF0ZWQgY29uZmlndXJhdGlvbiBzZWN0aW9ucy92YXJpYWJsZSBuYW1lcyBhbmQgdmFsdWVzCisjIGZvciAnZ2l0IC1jIHNlY3Rpb24ubmFtZT12YWx1ZScuCisjCisjIFVzYWdlOiBfX2dpdF9jb21wbGV0ZV9jb25maWdfdmFyaWFibGVfbmFtZV9hbmRfdmFsdWUgWzxvcHRpb24+XS4uLgorIyAtLWN1cj08d29yZD46IFRoZSBjdXJyZW50IGNvbmZpZ3VyYXRpb24gc2VjdGlvbi92YXJpYWJsZSBuYW1lL3ZhbHVlIHRvIGJlCisjICAgICAgICAgICAgICAgY29tcGxldGVkLiBEZWZhdWx0cyB0byB0aGUgY3VycmVudCB3b3JkIHRvIGJlIGNvbXBsZXRlZC4KK19fZ2l0X2NvbXBsZXRlX2NvbmZpZ192YXJpYWJsZV9uYW1lX2FuZF92YWx1ZSAoKQoreworCWxvY2FsIGN1cl89IiRjdXIiCisKKwl3aGlsZSB0ZXN0ICQjICE9IDA7IGRvCisJCWNhc2UgIiQxIiBpbgorCQktLWN1cj0qKQljdXJfPSIkezEjIy0tY3VyPX0iIDs7CisJCSopCQlyZXR1cm4gMSA7OworCQllc2FjCisJCXNoaWZ0CisJZG9uZQorCisJY2FzZSAiJGN1cl8iIGluCisJKj0qKQorCQlfX2dpdF9jb21wbGV0ZV9jb25maWdfdmFyaWFibGVfdmFsdWUgXAorCQkJLS12YXJuYW1lPSIke2N1cl8lJT0qfSIgLS1jdXI9IiR7Y3VyXyMqPX0iCisJCTs7CisJKikKKwkJX19naXRfY29tcGxldGVfY29uZmlnX3ZhcmlhYmxlX25hbWUgLS1jdXI9IiRjdXJfIiAtLXNmeD0nPScKKwkJOzsKKwllc2FjCit9CisKK19naXRfY29uZmlnICgpCit7CisJY2FzZSAiJHByZXYiIGluCisJLS1nZXR8LS1nZXQtYWxsfC0tdW5zZXR8LS11bnNldC1hbGwpCisJCV9fZ2l0Y29tcF9ubCAiJChfX2dpdF9jb25maWdfZ2V0X3NldF92YXJpYWJsZXMpIgorCQlyZXR1cm4KKwkJOzsKKwkqLiopCisJCV9fZ2l0X2NvbXBsZXRlX2NvbmZpZ192YXJpYWJsZV92YWx1ZQorCQlyZXR1cm4KKwkJOzsKKwllc2FjCisJY2FzZSAiJGN1ciIgaW4KKwktLSopCisJCV9fZ2l0Y29tcF9idWlsdGluIGNvbmZpZworCQk7OworCSopCisJCV9fZ2l0X2NvbXBsZXRlX2NvbmZpZ192YXJpYWJsZV9uYW1lCisJCTs7CiAJZXNhYwogfQogCkBAIC0yNTEyLDcgKzI2MjgsNyBAQAogCWVzYWMKIH0KIAotX19naXRfcmV2ZXJ0X2lucHJvZ3Jlc3Nfb3B0aW9ucz0iLS1jb250aW51ZSAtLXF1aXQgLS1hYm9ydCIKK19fZ2l0X3JldmVydF9pbnByb2dyZXNzX29wdGlvbnM9JF9fZ2l0X3NlcXVlbmNlcl9pbnByb2dyZXNzX29wdGlvbnMKIAogX2dpdF9yZXZlcnQgKCkKIHsKQEAgLTI1ODAsOCArMjY5Niw5IEBACiAJCXJldHVybgogCQk7OwogCS0tKikKLQkJX19naXRjb21wICItLXByZXR0eT0gLS1mb3JtYXQ9IC0tYWJicmV2LWNvbW1pdCAtLW9uZWxpbmUKLQkJCS0tc2hvdy1zaWduYXR1cmUKKwkJX19naXRjb21wICItLXByZXR0eT0gLS1mb3JtYXQ9IC0tYWJicmV2LWNvbW1pdCAtLW5vLWFiYnJldi1jb21taXQKKwkJCS0tb25lbGluZSAtLXNob3ctc2lnbmF0dXJlIC0tcGF0Y2gKKwkJCS0tZXhwYW5kLXRhYnMgLS1leHBhbmQtdGFicz0gLS1uby1leHBhbmQtdGFicwogCQkJJF9fZ2l0X2RpZmZfY29tbW9uX29wdGlvbnMKIAkJCSIKIAkJcmV0dXJuCkBAIC0yNzMwLDYgKzI4NDcsNyBAQAogCQkJLS1sb2ctd2luZG93LXNpemU9IC0tbm8tY2hlY2tvdXQgLS1xdWlldAogCQkJLS1yZXBhY2stZmxhZ3MgLS11c2UtbG9nLWF1dGhvciAtLWxvY2FsdGltZQogCQkJLS1hZGQtYXV0aG9yLWZyb20KKwkJCS0tcmVjdXJzaXZlCiAJCQktLWlnbm9yZS1wYXRocz0gLS1pbmNsdWRlLXBhdGhzPSAkcmVtb3RlX29wdHMKIAkJCSIKIAkJbG9jYWwgaW5pdF9vcHRzPSIKQEAgLTI5NTYsNyArMzA3NCwxMSBAQAogCQkJIyBCYXNoIGZpbGVuYW1lIGNvbXBsZXRpb24KIAkJCXJldHVybgogCQkJOzsKLQkJLWN8LS1uYW1lc3BhY2UpCisJCS1jKQorCQkJX19naXRfY29tcGxldGVfY29uZmlnX3ZhcmlhYmxlX25hbWVfYW5kX3ZhbHVlCisJCQlyZXR1cm4KKwkJCTs7CisJCS0tbmFtZXNwYWNlKQogCQkJIyB3ZSBkb24ndCBzdXBwb3J0IGNvbXBsZXRpbmcgdGhlc2Ugb3B0aW9ucycgYXJndW1lbnRzCiAJCQlyZXR1cm4KIAkJCTs7CmRpZmYgLS1naXQgYS9jb250cmliL2NvbXBsZXRpb24vZ2l0LWNvbXBsZXRpb24uenNoIGIvY29udHJpYi9jb21wbGV0aW9uL2dpdC1jb21wbGV0aW9uLnpzaAppbmRleCA4ODZiZjk1Li5lZWY0ZWZmIDEwMDY0NAotLS0gYS9jb250cmliL2NvbXBsZXRpb24vZ2l0LWNvbXBsZXRpb24uenNoCisrKyBiL2NvbnRyaWIvY29tcGxldGlvbi9naXQtY29tcGxldGlvbi56c2gKQEAgLTExLDggKzExLDkgQEAKICMKICMgIHpzdHlsZSAnOmNvbXBsZXRpb246KjoqOmdpdDoqJyBzY3JpcHQgfi8uZ2l0LWNvbXBsZXRpb24uenNoCiAjCi0jIFRoZSByZWNvbW1lbmRlZCB3YXkgdG8gaW5zdGFsbCB0aGlzIHNjcmlwdCBpcyB0byBjb3B5IHRvICd+Ly56c2gvX2dpdCcsIGFuZAotIyB0aGVuIGFkZCB0aGUgZm9sbG93aW5nIHRvIHlvdXIgfi8uenNocmMgZmlsZToKKyMgVGhlIHJlY29tbWVuZGVkIHdheSB0byBpbnN0YWxsIHRoaXMgc2NyaXB0IGlzIHRvIG1ha2UgYSBjb3B5IG9mIGl0IGluCisjIH4vLnpzaC8gZGlyZWN0b3J5IGFzIH4vLnpzaC9naXQtY29tcGxldGlvbi56c2ggYW5kIHRoZW4gYWRkIHRoZSBmb2xsb3dpbmcKKyMgdG8geW91ciB+Ly56c2hyYyBmaWxlOgogIwogIyAgZnBhdGg9KH4vLnpzaCAkZnBhdGgpCiAKZGlmZiAtLWdpdCBhL2NvbnRyaWIvZGlmZi1oaWdobGlnaHQvRGlmZkhpZ2hsaWdodC5wbSBiL2NvbnRyaWIvZGlmZi1oaWdobGlnaHQvRGlmZkhpZ2hsaWdodC5wbQppbmRleCA3NDQwYWExLi5lMjU4OTkyIDEwMDY0NAotLS0gYS9jb250cmliL2RpZmYtaGlnaGxpZ2h0L0RpZmZIaWdobGlnaHQucG0KKysrIGIvY29udHJpYi9kaWZmLWhpZ2hsaWdodC9EaWZmSGlnaGxpZ2h0LnBtCkBAIC03Miw3ICs3Miw3IEBACiAJICAgICAgKD86JENPTE9SP1x8JENPTE9SP1sgXSkqICMgemVybyBvciBtb3JlIHRyYWlsaW5nICJ8IgogCSAgICAgICAgICAgICAgICAgICAgICAgICBbIF0qICAjIHRyYWlsaW5nIHdoaXRlc3BhY2UgZm9yIG1lcmdlcwogCSAgICAveCkgewotCSAgICAgICAgbXkgJGdyYXBoX3ByZWZpeCA9ICQmOworCQlteSAkZ3JhcGhfcHJlZml4ID0gJCY7CiAKIAkJIyBXZSBtdXN0IGZsdXNoIGJlZm9yZSBzZXR0aW5nIGdyYXBoIGluZGVudCwgc2luY2UgdGhlCiAJCSMgbmV3IGNvbW1pdCBtYXkgYmUgaW5kZW50ZWQgZGlmZmVyZW50bHkgZnJvbSB3aGF0IHdlCmRpZmYgLS1naXQgYS9jb250cmliL2hnLXRvLWdpdC9oZy10by1naXQucHkgYi9jb250cmliL2hnLXRvLWdpdC9oZy10by1naXQucHkKaW5kZXggZGUzZjgxNi4uN2ViMWIyNCAxMDA3NTUKLS0tIGEvY29udHJpYi9oZy10by1naXQvaGctdG8tZ2l0LnB5CisrKyBiL2NvbnRyaWIvaGctdG8tZ2l0L2hnLXRvLWdpdC5weQpAQCAtNDIsNyArNDIsNyBAQAogCiBkZWYgdXNhZ2UoKToKIAotICAgICAgICBwcmludCAiIiJcCisgICAgICAgIHByaW50KCIiIlwKICVzOiBbT1BUSU9OU10gPGhncHJqPgogCiBvcHRpb25zOgpAQCAtNTQsNyArNTQsNyBAQAogCiByZXF1aXJlZDoKICAgICBoZ3ByajogIG5hbWUgb2YgdGhlIEhHIHByb2plY3QgdG8gaW1wb3J0IChkaXJlY3RvcnkpCi0iIiIgJSBzeXMuYXJndlswXQorIiIiICUgc3lzLmFyZ3ZbMF0pCiAKICMtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KIApAQCAtMTA0LDIyICsxMDQsMjIgQEAKIGlmIHN0YXRlOgogICAgIGlmIG9zLnBhdGguZXhpc3RzKHN0YXRlKToKICAgICAgICAgaWYgdmVyYm9zZToKLSAgICAgICAgICAgIHByaW50ICdTdGF0ZSBkb2VzIGV4aXN0LCByZWFkaW5nJworICAgICAgICAgICAgcHJpbnQoJ1N0YXRlIGRvZXMgZXhpc3QsIHJlYWRpbmcnKQogICAgICAgICBmID0gb3BlbihzdGF0ZSwgJ3InKQogICAgICAgICBoZ3ZlcnMgPSBwaWNrbGUubG9hZChmKQogICAgIGVsc2U6Ci0gICAgICAgIHByaW50ICdTdGF0ZSBkb2VzIG5vdCBleGlzdCwgZmlyc3QgcnVuJworICAgICAgICBwcmludCgnU3RhdGUgZG9lcyBub3QgZXhpc3QsIGZpcnN0IHJ1bicpCiAKIHNvY2sgPSBvcy5wb3BlbignaGcgdGlwIC0tdGVtcGxhdGUgIntyZXZ9IicpCiB0aXAgPSBzb2NrLnJlYWQoKQogaWYgc29jay5jbG9zZSgpOgogICAgIHN5cy5leGl0KDEpCiBpZiB2ZXJib3NlOgotICAgIHByaW50ICd0aXAgaXMnLCB0aXAKKyAgICBwcmludCgndGlwIGlzJywgdGlwKQogCiAjIENhbGN1bGF0ZSB0aGUgYnJhbmNoZXMKIGlmIHZlcmJvc2U6Ci0gICAgcHJpbnQgJ2FuYWx5c2luZyB0aGUgYnJhbmNoZXMuLi4nCisgICAgcHJpbnQoJ2FuYWx5c2luZyB0aGUgYnJhbmNoZXMuLi4nKQogaGdjaGlsZHJlblsiMCJdID0gKCkKIGhncGFyZW50c1siMCJdID0gKE5vbmUsIE5vbmUpCiBoZ2JyYW5jaFsiMCJdID0gIm1hc3RlciIKQEAgLTE1NCwxNSArMTU0LDE1IEBACiAgICAgICAgIGVsc2U6CiAgICAgICAgICAgICBoZ2JyYW5jaFtzdHIoY3NldCldID0gImJyYW5jaC0iICsgc3RyKGNzZXQpCiAKLWlmIG5vdCBoZ3ZlcnMuaGFzX2tleSgiMCIpOgotICAgIHByaW50ICdjcmVhdGluZyByZXBvc2l0b3J5JworaWYgIjAiIG5vdCBpbiBoZ3ZlcnM6CisgICAgcHJpbnQoJ2NyZWF0aW5nIHJlcG9zaXRvcnknKQogICAgIG9zLnN5c3RlbSgnZ2l0IGluaXQnKQogCiAjIGxvb3AgdGhyb3VnaCBldmVyeSBoZyBjaGFuZ2VzZXQKIGZvciBjc2V0IGluIHJhbmdlKGludCh0aXApICsgMSk6CiAKICAgICAjIGluY3JlbWVudGFsLCBhbHJlYWR5IHNlZW4KLSAgICBpZiBoZ3ZlcnMuaGFzX2tleShzdHIoY3NldCkpOgorICAgIGlmIHN0cihjc2V0KSBpbiBoZ3ZlcnM6CiAgICAgICAgIGNvbnRpbnVlCiAgICAgaGduZXdjc2V0cyArPSAxCiAKQEAgLTE4MCwyNyArMTgwLDI3IEBACiAgICAgb3Mud3JpdGUoZmRjb21tZW50LCBjc2V0Y29tbWVudCkKICAgICBvcy5jbG9zZShmZGNvbW1lbnQpCiAKLSAgICBwcmludCAnLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0nCi0gICAgcHJpbnQgJ2NzZXQ6JywgY3NldAotICAgIHByaW50ICdicmFuY2g6JywgaGdicmFuY2hbc3RyKGNzZXQpXQotICAgIHByaW50ICd1c2VyOicsIHVzZXIKLSAgICBwcmludCAnZGF0ZTonLCBkYXRlCi0gICAgcHJpbnQgJ2NvbW1lbnQ6JywgY3NldGNvbW1lbnQKKyAgICBwcmludCgnLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0nKQorICAgIHByaW50KCdjc2V0OicsIGNzZXQpCisgICAgcHJpbnQoJ2JyYW5jaDonLCBoZ2JyYW5jaFtzdHIoY3NldCldKQorICAgIHByaW50KCd1c2VyOicsIHVzZXIpCisgICAgcHJpbnQoJ2RhdGU6JywgZGF0ZSkKKyAgICBwcmludCgnY29tbWVudDonLCBjc2V0Y29tbWVudCkKICAgICBpZiBwYXJlbnQ6Ci0JcHJpbnQgJ3BhcmVudDonLCBwYXJlbnQKKyAgICAgICAgcHJpbnQoJ3BhcmVudDonLCBwYXJlbnQpCiAgICAgaWYgbXBhcmVudDoKLSAgICAgICAgcHJpbnQgJ21wYXJlbnQ6JywgbXBhcmVudAorICAgICAgICBwcmludCgnbXBhcmVudDonLCBtcGFyZW50KQogICAgIGlmIHRhZzoKLSAgICAgICAgcHJpbnQgJ3RhZzonLCB0YWcKLSAgICBwcmludCAnLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0nCisgICAgICAgIHByaW50KCd0YWc6JywgdGFnKQorICAgIHByaW50KCctLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLScpCiAKICAgICAjIGNoZWNrb3V0IHRoZSBwYXJlbnQgaWYgbmVjZXNzYXJ5CiAgICAgaWYgY3NldCAhPSAwOgogICAgICAgICBpZiBoZ2JyYW5jaFtzdHIoY3NldCldID09ICJicmFuY2gtIiArIHN0cihjc2V0KToKLSAgICAgICAgICAgIHByaW50ICdjcmVhdGluZyBuZXcgYnJhbmNoJywgaGdicmFuY2hbc3RyKGNzZXQpXQorICAgICAgICAgICAgcHJpbnQoJ2NyZWF0aW5nIG5ldyBicmFuY2gnLCBoZ2JyYW5jaFtzdHIoY3NldCldKQogICAgICAgICAgICAgb3Muc3lzdGVtKCdnaXQgY2hlY2tvdXQgLWIgJXMgJXMnICUgKGhnYnJhbmNoW3N0cihjc2V0KV0sIGhndmVyc1twYXJlbnRdKSkKICAgICAgICAgZWxzZToKLSAgICAgICAgICAgIHByaW50ICdjaGVja2luZyBvdXQgYnJhbmNoJywgaGdicmFuY2hbc3RyKGNzZXQpXQorICAgICAgICAgICAgcHJpbnQoJ2NoZWNraW5nIG91dCBicmFuY2gnLCBoZ2JyYW5jaFtzdHIoY3NldCldKQogICAgICAgICAgICAgb3Muc3lzdGVtKCdnaXQgY2hlY2tvdXQgJXMnICUgaGdicmFuY2hbc3RyKGNzZXQpXSkKIAogICAgICMgbWVyZ2UKQEAgLTIwOSw3ICsyMDksNyBAQAogICAgICAgICAgICAgb3RoZXJicmFuY2ggPSBoZ2JyYW5jaFttcGFyZW50XQogICAgICAgICBlbHNlOgogICAgICAgICAgICAgb3RoZXJicmFuY2ggPSBoZ2JyYW5jaFtwYXJlbnRdCi0gICAgICAgIHByaW50ICdtZXJnaW5nJywgb3RoZXJicmFuY2gsICdpbnRvJywgaGdicmFuY2hbc3RyKGNzZXQpXQorICAgICAgICBwcmludCgnbWVyZ2luZycsIG90aGVyYnJhbmNoLCAnaW50bycsIGhnYnJhbmNoW3N0cihjc2V0KV0pCiAgICAgICAgIG9zLnN5c3RlbShnZXRnaXRlbnYodXNlciwgZGF0ZSkgKyAnZ2l0IG1lcmdlIC0tbm8tY29tbWl0IC1zIG91cnMgIiIgJXMgJXMnICUgKGhnYnJhbmNoW3N0cihjc2V0KV0sIG90aGVyYnJhbmNoKSkKIAogICAgICMgcmVtb3ZlIGV2ZXJ5dGhpbmcgZXhjZXB0IC5naXQgYW5kIC5oZyBkaXJlY3RvcmllcwpAQCAtMjMzLDEyICsyMzMsMTIgQEAKIAogICAgICMgZGVsZXRlIGJyYW5jaCBpZiBub3QgdXNlZCBhbnltb3JlLi4uCiAgICAgaWYgbXBhcmVudCBhbmQgbGVuKGhnY2hpbGRyZW5bc3RyKGNzZXQpXSk6Ci0gICAgICAgIHByaW50ICJEZWxldGluZyB1bnVzZWQgYnJhbmNoOiIsIG90aGVyYnJhbmNoCisgICAgICAgIHByaW50KCJEZWxldGluZyB1bnVzZWQgYnJhbmNoOiIsIG90aGVyYnJhbmNoKQogICAgICAgICBvcy5zeXN0ZW0oJ2dpdCBicmFuY2ggLWQgJXMnICUgb3RoZXJicmFuY2gpCiAKICAgICAjIHJldHJpZXZlIGFuZCByZWNvcmQgdGhlIHZlcnNpb24KICAgICB2dnYgPSBvcy5wb3BlbignZ2l0IHNob3cgLS1xdWlldCAtLXByZXR0eT1mb3JtYXQ6JUgnKS5yZWFkKCkKLSAgICBwcmludCAncmVjb3JkJywgY3NldCwgJy0+JywgdnZ2CisgICAgcHJpbnQoJ3JlY29yZCcsIGNzZXQsICctPicsIHZ2dikKICAgICBoZ3ZlcnNbc3RyKGNzZXQpXSA9IHZ2dgogCiBpZiBoZ25ld2NzZXRzID49IG9wdF9ucmVwYWNrIGFuZCBvcHRfbnJlcGFjayAhPSAtMToKQEAgLTI0Nyw3ICsyNDcsNyBAQAogIyB3cml0ZSB0aGUgc3RhdGUgZm9yIGluY3JlbWVudGFscwogaWYgc3RhdGU6CiAgICAgaWYgdmVyYm9zZToKLSAgICAgICAgcHJpbnQgJ1dyaXRpbmcgc3RhdGUnCisgICAgICAgIHByaW50KCdXcml0aW5nIHN0YXRlJykKICAgICBmID0gb3BlbihzdGF0ZSwgJ3cnKQogICAgIHBpY2tsZS5kdW1wKGhndmVycywgZikKIApkaWZmIC0tZ2l0IGEvY29udHJpYi9ob29rcy9tdWx0aW1haWwvZ2l0X211bHRpbWFpbC5weSBiL2NvbnRyaWIvaG9va3MvbXVsdGltYWlsL2dpdF9tdWx0aW1haWwucHkKaW5kZXggODgyMzM5OS4uZjU2M2JlOCAxMDA3NTUKLS0tIGEvY29udHJpYi9ob29rcy9tdWx0aW1haWwvZ2l0X211bHRpbWFpbC5weQorKysgYi9jb250cmliL2hvb2tzL211bHRpbWFpbC9naXRfbXVsdGltYWlsLnB5CkBAIC05NSw3ICs5NSw3IEBACiAgICAgdW5pY29kZSA9IHN0cgogCiAgICAgZGVmIHdyaXRlX3N0cihmLCBtc2cpOgotICAgICAgICAjIFRyeSBvdXRwdXRpbmcgd2l0aCB0aGUgZGVmYXVsdCBlbmNvZGluZy4gSWYgaXQgZmFpbHMsCisgICAgICAgICMgVHJ5IG91dHB1dHRpbmcgd2l0aCB0aGUgZGVmYXVsdCBlbmNvZGluZy4gSWYgaXQgZmFpbHMsCiAgICAgICAgICMgdHJ5IFVURi04LgogICAgICAgICB0cnk6CiAgICAgICAgICAgICBmLmJ1ZmZlci53cml0ZShtc2cuZW5jb2RlKHN5cy5nZXRkZWZhdWx0ZW5jb2RpbmcoKSkpCkBAIC0yMTI5LDcgKzIxMjksNyBAQAogICAgICAgICAgICAgICAgICMgZXF1aXZhbGVudCB0bwogICAgICAgICAgICAgICAgICMgICAgIHNlbGYuc210cC5laGxvKCkKICAgICAgICAgICAgICAgICAjICAgICBzZWxmLnNtdHAuc3RhcnR0bHMoKQotICAgICAgICAgICAgICAgICMgd2l0aCBhY2NlcyB0byB0aGUgc3NsIGxheWVyCisgICAgICAgICAgICAgICAgIyB3aXRoIGFjY2VzcyB0byB0aGUgc3NsIGxheWVyCiAgICAgICAgICAgICAgICAgc2VsZi5zbXRwLmVobG8oKQogICAgICAgICAgICAgICAgIGlmIG5vdCBzZWxmLnNtdHAuaGFzX2V4dG4oInN0YXJ0dGxzIik6CiAgICAgICAgICAgICAgICAgICAgIHJhaXNlIHNtdHBsaWIuU01UUEV4Y2VwdGlvbigiU1RBUlRUTFMgZXh0ZW5zaW9uIG5vdCBzdXBwb3J0ZWQgYnkgc2VydmVyIikKQEAgLTIxNDgsNyArMjE0OCw3IEBACiAgICAgICAgICAgICAgICAgICAgICAgICBjZXJ0X3JlcXM9c3NsLkNFUlRfTk9ORQogICAgICAgICAgICAgICAgICAgICAgICAgKQogICAgICAgICAgICAgICAgICAgICBzZWxmLmVudmlyb25tZW50LmdldF9sb2dnZXIoKS5lcnJvcigKLSAgICAgICAgICAgICAgICAgICAgICAgICcqKiogV2FybmluZywgdGhlIHNlcnZlciBjZXJ0aWZpY2F0IGlzIG5vdCB2ZXJpZmllZCAoc210cCkgKioqXG4nCisgICAgICAgICAgICAgICAgICAgICAgICAnKioqIFdhcm5pbmcsIHRoZSBzZXJ2ZXIgY2VydGlmaWNhdGUgaXMgbm90IHZlcmlmaWVkIChzbXRwKSAqKipcbicKICAgICAgICAgICAgICAgICAgICAgICAgICcqKiogICAgICAgICAgc2V0IHRoZSBvcHRpb24gc210cENBQ2VydHMgICAgICAgICAgICAgICAgICAgKioqXG4nCiAgICAgICAgICAgICAgICAgICAgICAgICApCiAgICAgICAgICAgICAgICAgaWYgbm90IGhhc2F0dHIoc2VsZi5zbXRwLnNvY2ssICJyZWFkIik6CkBAIC0zMTg5LDcgKzMxODksNyBAQAogICAgICAgICBzZWxmLkNPTVBVVEVEX0tFWVMgKz0gWydwcm9qZWN0ZGVzYyddCiAKICAgICBkZWYgZ2V0X3Byb2plY3RkZXNjKHNlbGYpOgotICAgICAgICAiIiJSZXR1cm4gYSBvbmUtbGluZSBkZXNjcmlwaXRpb24gb2YgdGhlIHByb2plY3QuIiIiCisgICAgICAgICIiIlJldHVybiBhIG9uZS1saW5lIGRlc2NyaXB0aW9uIG9mIHRoZSBwcm9qZWN0LiIiIgogCiAgICAgICAgIGdpdF9kaXIgPSBnZXRfZ2l0X2RpcigpCiAgICAgICAgIHRyeToKZGlmZiAtLWdpdCBhL2NvbnRyaWIvaG9va3MvbXVsdGltYWlsL3Bvc3QtcmVjZWl2ZS5leGFtcGxlIGIvY29udHJpYi9ob29rcy9tdWx0aW1haWwvcG9zdC1yZWNlaXZlLmV4YW1wbGUKaW5kZXggYjliYjExOC4uMGY5OGM1YSAxMDA3NTUKLS0tIGEvY29udHJpYi9ob29rcy9tdWx0aW1haWwvcG9zdC1yZWNlaXZlLmV4YW1wbGUKKysrIGIvY29udHJpYi9ob29rcy9tdWx0aW1haWwvcG9zdC1yZWNlaXZlLmV4YW1wbGUKQEAgLTU2LDcgKzU2LDcgQEAKIAogIyBTZXQgc29tZSBHaXQgY29uZmlndXJhdGlvbiB2YXJpYWJsZXMuIEVxdWl2YWxlbnQgdG8gcGFzc2luZyB2YXI9dmFsCiAjIHRvICJnaXQgLWMgdmFyPXZhbCIgZWFjaCB0aW1lIGdpdCBpcyBjYWxsZWQsIG9yIHRvIGFkZGluZyB0aGUKLSMgY29uZmlndXJhdGlvbiBpbiAuZ2l0L2NvbmZpZyAobXVzdCBjb21lIGJlZm9yZSBpbnN0YW5jaWF0aW5nIHRoZQorIyBjb25maWd1cmF0aW9uIGluIC5naXQvY29uZmlnIChtdXN0IGNvbWUgYmVmb3JlIGluc3RhbnRpYXRpbmcgdGhlCiAjIGVudmlyb25tZW50KSA6CiAjZ2l0X211bHRpbWFpbC5Db25maWcuYWRkX2NvbmZpZ19wYXJhbWV0ZXJzKCdtdWx0aW1haWxob29rLmNvbW1pdEVtYWlsRm9ybWF0PWh0bWwnKQogI2dpdF9tdWx0aW1haWwuQ29uZmlnLmFkZF9jb25maWdfcGFyYW1ldGVycygoJ3VzZXIubmFtZT1mb28nLCAndXNlci5lbWFpbD1mb29AZXhhbXBsZS5jb20nKSkKZGlmZiAtLWdpdCBhL2NvbnRyaWIvaG9va3MvcG9zdC1yZWNlaXZlLWVtYWlsIGIvY29udHJpYi9ob29rcy9wb3N0LXJlY2VpdmUtZW1haWwKaW5kZXggODc0N2I4NC4uZmY1NjVlYiAxMDA3NTUKLS0tIGEvY29udHJpYi9ob29rcy9wb3N0LXJlY2VpdmUtZW1haWwKKysrIGIvY29udHJpYi9ob29rcy9wb3N0LXJlY2VpdmUtZW1haWwKQEAgLTMyOSw3ICszMjksNyBAQAogCSMKIAkjICBnaXQgcmV2LXBhcnNlIC0tbm90IC0tYWxsIHwgZ3JlcCAtdiAkKGdpdCByZXYtcGFyc2UgJHJlZm5hbWUpCiAJIwotCSMgR2V0J3MgdXMgdG8gc29tZXRoaW5nIHByZXR0eSBzYWZlIChhcGFydCBmcm9tIHRoZSBzbWFsbCB0aW1lCisJIyBHZXRzIHVzIHRvIHNvbWV0aGluZyBwcmV0dHkgc2FmZSAoYXBhcnQgZnJvbSB0aGUgc21hbGwgdGltZQogCSMgYmV0d2VlbiByZWZuYW1lIGJlaW5nIHJlYWQsIGFuZCBnaXQgcmV2LXBhcnNlIHJ1bm5pbmcgLSBmb3IgdGhhdCwKIAkjIEkgZ2l2ZSB1cCkKIAkjCmRpZmYgLS1naXQgYS9jb250cmliL2hvb2tzL3VwZGF0ZS1wYXJhbm9pZCBiL2NvbnRyaWIvaG9va3MvdXBkYXRlLXBhcmFub2lkCmluZGV4IGQxOGIzMTcuLjAwOTJkNjcgMTAwNzU1Ci0tLSBhL2NvbnRyaWIvaG9va3MvdXBkYXRlLXBhcmFub2lkCisrKyBiL2NvbnRyaWIvaG9va3MvdXBkYXRlLXBhcmFub2lkCkBAIC00OSw3ICs0OSw3IEBACiBSZXBvc2l0b3J5IHNlY3Rpb25zIGFyZSBtYXRjaGVkIG9uIHRoZSBiYXNlbmFtZSBvZiB0aGUgcmVwb3NpdG9yeQogKGFmdGVyIHJlbW92aW5nIHRoZSAuZ2l0IHN1ZmZpeCkuCiAKLVRoZSBvcGNvZGUgYWJicmV2YXRpb25zIGFyZToKK1RoZSBvcGNvZGUgYWJicmV2aWF0aW9ucyBhcmU6CiAKICAgQzogY3JlYXRlIG5ldyByZWYKICAgRDogZGVsZXRlIGV4aXN0aW5nIHJlZgpkaWZmIC0tZ2l0IGEvY29udHJpYi9tdy10by1naXQvLnBlcmxjcml0aWNyYyBiL2NvbnRyaWIvbXctdG8tZ2l0Ly5wZXJsY3JpdGljcmMKaW5kZXggMTU4OTU4ZC4uYjczMzMyNiAxMDA2NDQKLS0tIGEvY29udHJpYi9tdy10by1naXQvLnBlcmxjcml0aWNyYworKysgYi9jb250cmliL213LXRvLWdpdC8ucGVybGNyaXRpY3JjCkBAIC0xNCw3ICsxNCw3IEBACiAKICMgVGhpcyBydWxlIHN0YXRlcyB0aGF0IGVhY2ggc3lzdGVtIGNhbGwgc2hvdWxkIGhhdmUgaXRzIHJldHVybiB2YWx1ZSBjaGVja2VkCiAjIFRoZSBwcm9ibGVtIGlzIHRoYXQgaXQgaW5jbHVkZXMgdGhlIHByaW50IGNhbGwuIENoZWNraW5nIGV2ZXJ5IHByaW50IGNhbGwncwotIyByZXR1cm4gdmFsdWUgd291bGQgYmUgaGFybWZ1bCB0byB0aGUgY29kZSByZWFkYWJpbHR5LgorIyByZXR1cm4gdmFsdWUgd291bGQgYmUgaGFybWZ1bCB0byB0aGUgY29kZSByZWFkYWJpbGl0eS4KICMgVGhpcyBjb25maWd1cmF0aW9uIGtlZXBzIGFsbCBkZWZhdWx0IGZ1bmN0aW9uIGJ1dCBwcmludC4KIFtJbnB1dE91dHB1dDo6UmVxdWlyZUNoZWNrZWRTeXNjYWxsc10KIGZ1bmN0aW9ucyA9IG9wZW4gc2F5IGNsb3NlCmRpZmYgLS1naXQgYS9jb250cmliL213LXRvLWdpdC9naXQtcmVtb3RlLW1lZGlhd2lraS5wZXJsIGIvY29udHJpYi9tdy10by1naXQvZ2l0LXJlbW90ZS1tZWRpYXdpa2kucGVybAppbmRleCBhZjljYmM5Li5kOGZmMmU2IDEwMDc1NQotLS0gYS9jb250cmliL213LXRvLWdpdC9naXQtcmVtb3RlLW1lZGlhd2lraS5wZXJsCisrKyBiL2NvbnRyaWIvbXctdG8tZ2l0L2dpdC1yZW1vdGUtbWVkaWF3aWtpLnBlcmwKQEAgLTc5LDcgKzc5LDcgQEAKICRleHBvcnRfbWVkaWEgPSAhKCRleHBvcnRfbWVkaWEgZXEgJ2ZhbHNlJyk7CiAKIG15ICR3aWtpX2xvZ2luID0gcnVuX2dpdCgiY29uZmlnIC0tZ2V0IHJlbW90ZS4ke3JlbW90ZW5hbWV9Lm13TG9naW4iKTsKLSMgTm90ZTogbXdQYXNzd29yZCBpcyBkaXNjb3VycmFnZWQuIFVzZSB0aGUgY3JlZGVudGlhbCBzeXN0ZW0gaW5zdGVhZC4KKyMgTm90ZTogbXdQYXNzd29yZCBpcyBkaXNjb3VyYWdlZC4gVXNlIHRoZSBjcmVkZW50aWFsIHN5c3RlbSBpbnN0ZWFkLgogbXkgJHdpa2lfcGFzc3dkID0gcnVuX2dpdCgiY29uZmlnIC0tZ2V0IHJlbW90ZS4ke3JlbW90ZW5hbWV9Lm13UGFzc3dvcmQiKTsKIG15ICR3aWtpX2RvbWFpbiA9IHJ1bl9naXQoImNvbmZpZyAtLWdldCByZW1vdGUuJHtyZW1vdGVuYW1lfS5td0RvbWFpbiIpOwogY2hvbXAoJHdpa2lfbG9naW4pOwpkaWZmIC0tZ2l0IGEvY29udHJpYi9tdy10by1naXQvdC9pbnN0YWxsLXdpa2kvZGJfaW5zdGFsbC5waHAgYi9jb250cmliL213LXRvLWdpdC90L2luc3RhbGwtd2lraS9kYl9pbnN0YWxsLnBocAppbmRleCAwZjNmNGUwLi5iMDMzODQ5IDEwMDY0NAotLS0gYS9jb250cmliL213LXRvLWdpdC90L2luc3RhbGwtd2lraS9kYl9pbnN0YWxsLnBocAorKysgYi9jb250cmliL213LXRvLWdpdC90L2luc3RhbGwtd2lraS9kYl9pbnN0YWxsLnBocApAQCAtMjQsNyArMjQsNyBAQAogJGRiX2RpciA9IHVybGVuY29kZSgkdG1wKTsKICR0bXBfY29va2llID0gdGVtcG5hbSgkdG1wLCAiQ09PS0lFXyIpOwogLyoKLSAqIEZldGNocyBhIHBhZ2Ugd2l0aCBjVVJMLgorICogRmV0Y2hlcyBhIHBhZ2Ugd2l0aCBjVVJMLgogICovCiBmdW5jdGlvbiBnZXQoJHBhZ2VfbmFtZSA9ICIiKSB7CiAJJGN1cmwgPSBjdXJsX2luaXQoKTsKZGlmZiAtLWdpdCBhL2NvbnRyaWIvbXctdG8tZ2l0L3QvdDkzNjAtbXctdG8tZ2l0LWNsb25lLnNoIGIvY29udHJpYi9tdy10by1naXQvdC90OTM2MC1tdy10by1naXQtY2xvbmUuc2gKaW5kZXggY2ZiZmU3ZC4uOTEwNjgzMyAxMDA3NTUKLS0tIGEvY29udHJpYi9tdy10by1naXQvdC90OTM2MC1tdy10by1naXQtY2xvbmUuc2gKKysrIGIvY29udHJpYi9tdy10by1naXQvdC90OTM2MC1tdy10by1naXQtY2xvbmUuc2gKQEAgLTE0Myw3ICsxNDMsNyBAQAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnR2l0IGNsb25lIHdvcmtzIHdpdGggbXVsdGlwbGUgc3BlY2lmaWMgcGFnZSBjbG9uZWQgJyAnCiAJd2lraV9yZXNldCAmJgogCXdpa2lfZWRpdHBhZ2UgZm9vICJJIHdpbGwgYmUgdGhlcmUiIGZhbHNlICYmCi0Jd2lraV9lZGl0cGFnZSBiYXIgIkkgd2lsbCBub3QgZGlzYXBlYXIiIGZhbHNlICYmCisJd2lraV9lZGl0cGFnZSBiYXIgIkkgd2lsbCBub3QgZGlzYXBwZWFyIiBmYWxzZSAmJgogCXdpa2lfZWRpdHBhZ2UgbmFtbmFtICJJIGJlIGVyYXNlZCIgZmFsc2UgJiYKIAl3aWtpX2VkaXRwYWdlIG55YW5jYXQgIm55YW4gbnlhbiBueWFuIHlvdSB3aWxsIG5vdCBlcmFzZSBtZSIgZmFsc2UgJiYKIAl3aWtpX2RlbGV0ZV9wYWdlIG5hbW5hbSAmJgpkaWZmIC0tZ2l0IGEvY29udHJpYi9tdy10by1naXQvdC90ZXN0LWdpdG13LWxpYi5zaCBiL2NvbnRyaWIvbXctdG8tZ2l0L3QvdGVzdC1naXRtdy1saWIuc2gKaW5kZXggNjU0NjI5NC4uMzk0OGEwMCAxMDA3NTUKLS0tIGEvY29udHJpYi9tdy10by1naXQvdC90ZXN0LWdpdG13LWxpYi5zaAorKysgYi9jb250cmliL213LXRvLWdpdC90L3Rlc3QtZ2l0bXctbGliLnNoCkBAIC0yNzksNyArMjc5LDcgQEAKIAkiJExJR0hUVFBEX0RJUiIvbGlnaHR0cGQgLWYgIiRXRUIiL2xpZ2h0dHBkLmNvbmYKIAogCWlmIHRlc3QgJD8gLW5lIDAgOyB0aGVuCi0JCWVjaG8gIkNvdWxkIG5vdCBleGVjdXRlIGh0dHAgZGVhbW9uIGxpZ2h0dHBkIgorCQllY2hvICJDb3VsZCBub3QgZXhlY3V0ZSBodHRwIGRhZW1vbiBsaWdodHRwZCIKIAkJZXhpdCAxCiAJZmkKIH0KZGlmZiAtLWdpdCBhL2NvbnRyaWIvc3ZuLWZlL3N2bi1mZS50eHQgYi9jb250cmliL3N2bi1mZS9zdm4tZmUudHh0CmluZGV4IGEzNDI1ZjQuLjE5MzMzZmMgMTAwNjQ0Ci0tLSBhL2NvbnRyaWIvc3ZuLWZlL3N2bi1mZS50eHQKKysrIGIvY29udHJpYi9zdm4tZmUvc3ZuLWZlLnR4dApAQCAtNTYsNyArNTYsNyBAQAogCiBUaGUgcmVzdWx0aW5nIHJlcG9zaXRvcnkgd2lsbCBnZW5lcmFsbHkgcmVxdWlyZSBmdXJ0aGVyIHByb2Nlc3NpbmcKIHRvIHB1dCBlYWNoIHByb2plY3QgaW4gaXRzIG93biByZXBvc2l0b3J5IGFuZCB0byBzZXBhcmF0ZSB0aGUgaGlzdG9yeQotb2YgZWFjaCBicmFuY2guICBUaGUgJ2dpdCBmaWx0ZXItYnJhbmNoIC0tc3ViZGlyZWN0b3J5LWZpbHRlcicgY29tbWFuZAorb2YgZWFjaCBicmFuY2guICBUaGUgJ2dpdCBmaWx0ZXItcmVwbyAtLXN1YmRpcmVjdG9yeS1maWx0ZXInIGNvbW1hbmQKIG1heSBiZSB1c2VmdWwgZm9yIHRoaXMgcHVycG9zZS4KIAogQlVHUwpAQCAtNjcsNSArNjcsNSBAQAogCiBTRUUgQUxTTwogLS0tLS0tLS0KLWdpdC1zdm4oMSksIHN2bjJnaXQoMSksIHN2aygxKSwgZ2l0LWZpbHRlci1icmFuY2goMSksIGdpdC1mYXN0LWltcG9ydCgxKSwKK2dpdC1zdm4oMSksIHN2bjJnaXQoMSksIHN2aygxKSwgZ2l0LWZpbHRlci1yZXBvKDEpLCBnaXQtZmFzdC1pbXBvcnQoMSksCiBodHRwczovL3N2bi5hcGFjaGUub3JnL3JlcG9zL2FzZi9zdWJ2ZXJzaW9uL3RydW5rL25vdGVzL2R1bXAtbG9hZC1mb3JtYXQudHh0CmRpZmYgLS1naXQgYS9jb250cmliL3N2bi1mZS9zdm5yZHVtcF9zaW0ucHkgYi9jb250cmliL3N2bi1mZS9zdm5yZHVtcF9zaW0ucHkKaW5kZXggMTFhYzZmNi4uOGEzY2VlNiAxMDA3NTUKLS0tIGEvY29udHJpYi9zdm4tZmUvc3ZucmR1bXBfc2ltLnB5CisrKyBiL2NvbnRyaWIvc3ZuLWZlL3N2bnJkdW1wX3NpbS5weQpAQCAtMSw0ICsxLDQgQEAKLSMhL3Vzci9iaW4vcHl0aG9uCisjIS91c3IvYmluL2VudiBweXRob24KICIiIgogU2ltdWxhdGVzIHN2bnJkdW1wIGJ5IHJlcGxheWluZyBhbiBleGlzdGluZyBkdW1wIGZyb20gYSBmaWxlLCB0YWtpbmcgY2FyZQogb2YgdGhlIHNwZWNpZmllZCByZXZpc2lvbiByYW5nZS4KQEAgLTU0LDcgKzU0LDcgQEAKICAgICAgICAgcHJpbnQoInVzYWdlOiAlcyBkdW1wIFVSTCAtckxPV0VSOlVQUEVSIikKICAgICAgICAgc3lzLmV4aXQoMSkKICAgICBpZiBub3Qgc3lzLmFyZ3ZbMV0gPT0gJ2R1bXAnOgotICAgICAgICByYWlzZSBOb3RJbXBsZW1lbnRlZEVycm9yKCdvbmx5ICJkdW1wIiBpcyBzdXBwcG9ydGVkLicpCisgICAgICAgIHJhaXNlIE5vdEltcGxlbWVudGVkRXJyb3IoJ29ubHkgImR1bXAiIGlzIHN1cHBvcnRlZC4nKQogICAgIHVybCA9IHN5cy5hcmd2WzJdCiAgICAgciA9ICgnMCcsICdIRUFEJykKICAgICBpZiBsZW4oc3lzLmFyZ3YpID09IDQgYW5kIHN5cy5hcmd2WzNdWzA6Ml0gPT0gJy1yJzoKZGlmZiAtLWdpdCBhL2NvbnZlcnQuYyBiL2NvbnZlcnQuYwppbmRleCA5NGZmODM3Li43OTdlMGJkIDEwMDY0NAotLS0gYS9jb252ZXJ0LmMKKysrIGIvY29udmVydC5jCkBAIC04LDYgKzgsNyBAQAogI2luY2x1ZGUgInBrdC1saW5lLmgiCiAjaW5jbHVkZSAic3ViLXByb2Nlc3MuaCIKICNpbmNsdWRlICJ1dGY4LmgiCisjaW5jbHVkZSAibGwtbWVyZ2UuaCIKIAogLyoKICAqIGNvbnZlcnQuYyAtIGNvbnZlcnQgYSBmaWxlIHdoZW4gY2hlY2tpbmcgaXQgb3V0IGFuZCBjaGVja2luZyBpdCBpbi4KQEAgLTI2OSw4ICsyNzAsMTIgQEAKIHN0YXRpYyBpbnQgdmFsaWRhdGVfZW5jb2RpbmcoY29uc3QgY2hhciAqcGF0aCwgY29uc3QgY2hhciAqZW5jLAogCQkgICAgICBjb25zdCBjaGFyICpkYXRhLCBzaXplX3QgbGVuLCBpbnQgZGllX29uX2Vycm9yKQogeworCWNvbnN0IGNoYXIgKnN0cmlwcGVkOworCiAJLyogV2Ugb25seSBjaGVjayBmb3IgVVRGIGhlcmUgYXMgVVRGPz8gY2FuIGJlIGFuIGFsaWFzIGZvciBVVEYtPz8gKi8KLQlpZiAoaXN0YXJ0c193aXRoKGVuYywgIlVURiIpKSB7CisJaWYgKHNraXBfaXByZWZpeChlbmMsICJVVEYiLCAmc3RyaXBwZWQpKSB7CisJCXNraXBfcHJlZml4KHN0cmlwcGVkLCAiLSIsICZzdHJpcHBlZCk7CisKIAkJLyoKIAkJICogQ2hlY2sgZm9yIGRldGVjdGFibGUgZXJyb3JzIGluIFVURiBlbmNvZGluZ3MKIAkJICovCkBAIC0yODQsMTUgKzI4OSwxMCBAQAogCQkJICovCiAJCQljb25zdCBjaGFyICphZHZpc2VfbXNnID0gXygKIAkJCQkiVGhlIGZpbGUgJyVzJyBjb250YWlucyBhIGJ5dGUgb3JkZXIgIgotCQkJCSJtYXJrIChCT00pLiBQbGVhc2UgdXNlIFVURi0lcyBhcyAiCisJCQkJIm1hcmsgKEJPTSkuIFBsZWFzZSB1c2UgVVRGLSUuKnMgYXMgIgogCQkJCSJ3b3JraW5nLXRyZWUtZW5jb2RpbmcuIik7Ci0JCQljb25zdCBjaGFyICpzdHJpcHBlZCA9IE5VTEw7Ci0JCQljaGFyICp1cHBlciA9IHhzdHJkdXBfdG91cHBlcihlbmMpOwotCQkJdXBwZXJbc3RybGVuKHVwcGVyKS0yXSA9ICdcMCc7Ci0JCQlpZiAoIXNraXBfcHJlZml4KHVwcGVyLCAiVVRGLSIsICZzdHJpcHBlZCkpCi0JCQkJc2tpcF9wcmVmaXgoc3RyaXBwZWQsICJVVEYiLCAmc3RyaXBwZWQpOwotCQkJYWR2aXNlKGFkdmlzZV9tc2csIHBhdGgsIHN0cmlwcGVkKTsKLQkJCWZyZWUodXBwZXIpOworCQkJaW50IHN0cmlwcGVkX2xlbiA9IHN0cmxlbihzdHJpcHBlZCkgLSBzdHJsZW4oIkJFIik7CisJCQlhZHZpc2UoYWR2aXNlX21zZywgcGF0aCwgc3RyaXBwZWRfbGVuLCBzdHJpcHBlZCk7CiAJCQlpZiAoZGllX29uX2Vycm9yKQogCQkJCWRpZShlcnJvcl9tc2csIHBhdGgsIGVuYyk7CiAJCQllbHNlIHsKQEAgLTMwNywxMiArMzA3LDcgQEAKIAkJCQkibWFyayAoQk9NKS4gUGxlYXNlIHVzZSBVVEYtJXNCRSBvciBVVEYtJXNMRSAiCiAJCQkJIihkZXBlbmRpbmcgb24gdGhlIGJ5dGUgb3JkZXIpIGFzICIKIAkJCQkid29ya2luZy10cmVlLWVuY29kaW5nLiIpOwotCQkJY29uc3QgY2hhciAqc3RyaXBwZWQgPSBOVUxMOwotCQkJY2hhciAqdXBwZXIgPSB4c3RyZHVwX3RvdXBwZXIoZW5jKTsKLQkJCWlmICghc2tpcF9wcmVmaXgodXBwZXIsICJVVEYtIiwgJnN0cmlwcGVkKSkKLQkJCQlza2lwX3ByZWZpeChzdHJpcHBlZCwgIlVURiIsICZzdHJpcHBlZCk7CiAJCQlhZHZpc2UoYWR2aXNlX21zZywgcGF0aCwgc3RyaXBwZWQsIHN0cmlwcGVkKTsKLQkJCWZyZWUodXBwZXIpOwogCQkJaWYgKGRpZV9vbl9lcnJvcikKIAkJCQlkaWUoZXJyb3JfbXNnLCBwYXRoLCBlbmMpOwogCQkJZWxzZSB7CkBAIC00MTcsNyArNDEyLDcgQEAKIAlpZiAoIWRzdCkgewogCQkvKgogCQkgKiBXZSBjb3VsZCBhZGQgdGhlIGJsb2IgImFzLWlzIiB0byBHaXQuIEhvd2V2ZXIsIG9uIGNoZWNrb3V0Ci0JCSAqIHdlIHdvdWxkIHRyeSB0byByZWVuY29kZSB0byB0aGUgb3JpZ2luYWwgZW5jb2RpbmcuIFRoaXMKKwkJICogd2Ugd291bGQgdHJ5IHRvIHJlLWVuY29kZSB0byB0aGUgb3JpZ2luYWwgZW5jb2RpbmcuIFRoaXMKIAkJICogd291bGQgZmFpbCBhbmQgd2Ugd291bGQgbGVhdmUgdGhlIHVzZXIgd2l0aCBhIG1lc3NlZC11cAogCQkgKiB3b3JraW5nIHRyZWUuIExldCdzIHRyeSB0byBhdm9pZCB0aGlzIGJ5IHNjcmVhbWluZyBsb3VkLgogCQkgKi8KQEAgLTEyOTMsMTAgKzEyODgsMTEgQEAKIAljb25zdCBjaGFyICp3b3JraW5nX3RyZWVfZW5jb2Rpbmc7IC8qIFN1cHBvcnRlZCBlbmNvZGluZyBvciBkZWZhdWx0IGVuY29kaW5nIGlmIE5VTEwgKi8KIH07CiAKK3N0YXRpYyBzdHJ1Y3QgYXR0cl9jaGVjayAqY2hlY2s7CisKIHN0YXRpYyB2b2lkIGNvbnZlcnRfYXR0cnMoY29uc3Qgc3RydWN0IGluZGV4X3N0YXRlICppc3RhdGUsCiAJCQkgIHN0cnVjdCBjb252X2F0dHJzICpjYSwgY29uc3QgY2hhciAqcGF0aCkKIHsKLQlzdGF0aWMgc3RydWN0IGF0dHJfY2hlY2sgKmNoZWNrOwogCXN0cnVjdCBhdHRyX2NoZWNrX2l0ZW0gKmNjaGVjayA9IE5VTEw7CiAKIAlpZiAoIWNoZWNrKSB7CkBAIC0xMzM5LDYgKzEzMzUsMjMgQEAKIAkJY2EtPmNybGZfYWN0aW9uID0gQ1JMRl9BVVRPX0lOUFVUOwogfQogCit2b2lkIHJlc2V0X3BhcnNlZF9hdHRyaWJ1dGVzKHZvaWQpCit7CisJc3RydWN0IGNvbnZlcnRfZHJpdmVyICpkcnYsICpuZXh0OworCisJYXR0cl9jaGVja19mcmVlKGNoZWNrKTsKKwljaGVjayA9IE5VTEw7CisJcmVzZXRfbWVyZ2VfYXR0cmlidXRlcygpOworCisJZm9yIChkcnYgPSB1c2VyX2NvbnZlcnQ7IGRydjsgZHJ2ID0gbmV4dCkgeworCQluZXh0ID0gZHJ2LT5uZXh0OworCQlmcmVlKCh2b2lkICopZHJ2LT5uYW1lKTsKKwkJZnJlZShkcnYpOworCX0KKwl1c2VyX2NvbnZlcnQgPSBOVUxMOworCXVzZXJfY29udmVydF90YWlsID0gTlVMTDsKK30KKwogaW50IHdvdWxkX2NvbnZlcnRfdG9fZ2l0X2ZpbHRlcl9mZChjb25zdCBzdHJ1Y3QgaW5kZXhfc3RhdGUgKmlzdGF0ZSwgY29uc3QgY2hhciAqcGF0aCkKIHsKIAlzdHJ1Y3QgY29udl9hdHRycyBjYTsKZGlmZiAtLWdpdCBhL2NvbnZlcnQuaCBiL2NvbnZlcnQuaAppbmRleCA4MzE1NTlmLi4zNzEwOTY5IDEwMDY0NAotLS0gYS9jb252ZXJ0LmgKKysrIGIvY29udmVydC5oCkBAIC05NCw2ICs5NCwxMiBAQAogaW50IHdvdWxkX2NvbnZlcnRfdG9fZ2l0X2ZpbHRlcl9mZChjb25zdCBzdHJ1Y3QgaW5kZXhfc3RhdGUgKmlzdGF0ZSwKIAkJCQkgICBjb25zdCBjaGFyICpwYXRoKTsKIAorLyoKKyAqIFJlc2V0IHRoZSBpbnRlcm5hbCBsaXN0IG9mIGF0dHJpYnV0ZXMgdXNlZCBieSBjb252ZXJ0X3RvX2dpdCBhbmQKKyAqIGNvbnZlcnRfdG9fd29ya2luZ190cmVlLgorICovCit2b2lkIHJlc2V0X3BhcnNlZF9hdHRyaWJ1dGVzKHZvaWQpOworCiAvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICAqCiAgKiBTdHJlYW1pbmcgY29udmVyc2lvbiBzdXBwb3J0CmRpZmYgLS1naXQgYS9jcmVkZW50aWFsLXN0b3JlLmMgYi9jcmVkZW50aWFsLXN0b3JlLmMKaW5kZXggYWMyOTU0Mi4uYzAxMDQ5NyAxMDA2NDQKLS0tIGEvY3JlZGVudGlhbC1zdG9yZS5jCisrKyBiL2NyZWRlbnRpYWwtc3RvcmUuYwpAQCAtNzIsMTUgKzcyLDE2IEBACiAJc3RydWN0IHN0cmJ1ZiBidWYgPSBTVFJCVUZfSU5JVDsKIAogCXN0cmJ1Zl9hZGRmKCZidWYsICIlczovLyIsIGMtPnByb3RvY29sKTsKLQlzdHJidWZfYWRkc3RyX3VybGVuY29kZSgmYnVmLCBjLT51c2VybmFtZSwgMSk7CisJc3RyYnVmX2FkZHN0cl91cmxlbmNvZGUoJmJ1ZiwgYy0+dXNlcm5hbWUsIGlzX3JmYzM5ODZfdW5yZXNlcnZlZCk7CiAJc3RyYnVmX2FkZGNoKCZidWYsICc6Jyk7Ci0Jc3RyYnVmX2FkZHN0cl91cmxlbmNvZGUoJmJ1ZiwgYy0+cGFzc3dvcmQsIDEpOworCXN0cmJ1Zl9hZGRzdHJfdXJsZW5jb2RlKCZidWYsIGMtPnBhc3N3b3JkLCBpc19yZmMzOTg2X3VucmVzZXJ2ZWQpOwogCXN0cmJ1Zl9hZGRjaCgmYnVmLCAnQCcpOwogCWlmIChjLT5ob3N0KQotCQlzdHJidWZfYWRkc3RyX3VybGVuY29kZSgmYnVmLCBjLT5ob3N0LCAxKTsKKwkJc3RyYnVmX2FkZHN0cl91cmxlbmNvZGUoJmJ1ZiwgYy0+aG9zdCwgaXNfcmZjMzk4Nl91bnJlc2VydmVkKTsKIAlpZiAoYy0+cGF0aCkgewogCQlzdHJidWZfYWRkY2goJmJ1ZiwgJy8nKTsKLQkJc3RyYnVmX2FkZHN0cl91cmxlbmNvZGUoJmJ1ZiwgYy0+cGF0aCwgMCk7CisJCXN0cmJ1Zl9hZGRzdHJfdXJsZW5jb2RlKCZidWYsIGMtPnBhdGgsCisJCQkJCWlzX3JmYzM5ODZfcmVzZXJ2ZWRfb3JfdW5yZXNlcnZlZCk7CiAJfQogCiAJcmV3cml0ZV9jcmVkZW50aWFsX2ZpbGUoZm4sIGMsICZidWYpOwpkaWZmIC0tZ2l0IGEvZGFlbW9uLmMgYi9kYWVtb24uYwppbmRleCA5ZDJlMGQyLi5mZDY2OWVkIDEwMDY0NAotLS0gYS9kYWVtb24uYworKysgYi9kYWVtb24uYwpAQCAtNTk4LDcgKzU5OCw3IEBACiAgKiBSZWFkIHRoZSBob3N0IGFzIHN1cHBsaWVkIGJ5IHRoZSBjbGllbnQgY29ubmVjdGlvbi4KICAqCiAgKiBSZXR1cm5zIGEgcG9pbnRlciB0byB0aGUgY2hhcmFjdGVyIGFmdGVyIHRoZSBOVUwgYnl0ZSB0ZXJtaW5hdGluZyB0aGUgaG9zdAotICogYXJndWVtbnQsIG9yICdleHRyYV9hcmdzJyBpZiB0aGVyZSBpcyBubyBob3N0IGFyZ3VlbW50LgorICogYXJndW1lbnQsIG9yICdleHRyYV9hcmdzJyBpZiB0aGVyZSBpcyBubyBob3N0IGFyZ3VtZW50LgogICovCiBzdGF0aWMgY2hhciAqcGFyc2VfaG9zdF9hcmcoc3RydWN0IGhvc3RpbmZvICpoaSwgY2hhciAqZXh0cmFfYXJncywgaW50IGJ1ZmxlbikKIHsKQEAgLTY1Miw3ICs2NTIsNyBAQAogCQkgKiBzZXJ2aWNlIHRoYXQgd2lsbCBiZSBydW4uCiAJCSAqCiAJCSAqIElmIHRoZXJlIGVuZHMgdXAgYmVpbmcgYSBwYXJ0aWN1bGFyIGFyZyBpbiB0aGUgZnV0dXJlIHRoYXQKLQkJICogZ2l0LWRhZW1vbiBuZWVkcyB0byBwYXJzZSBzcGVjaWZpY2x5IChsaWtlIHRoZSAnaG9zdCcgYXJnKQorCQkgKiBnaXQtZGFlbW9uIG5lZWRzIHRvIHBhcnNlIHNwZWNpZmljYWxseSAobGlrZSB0aGUgJ2hvc3QnIGFyZykKIAkJICogdGhlbiBpdCBjYW4gYmUgcGFyc2VkIGhlcmUgYW5kIG5vdCBhZGRlZCB0byAnZ2l0X3Byb3RvY29sJy4KIAkJICovCiAJCWlmICgqYXJnKSB7CmRpZmYgLS1naXQgYS9kYXRlLmMgYi9kYXRlLmMKaW5kZXggODEyNjE0Ni4uMDQxZGI3ZCAxMDA2NDQKLS0tIGEvZGF0ZS5jCisrKyBiL2RhdGUuYwpAQCAtMTI4LDE2ICsxMjgsMTcgQEAKIAkJZ2V0dGltZW9mZGF5KG5vdywgTlVMTCk7CiB9CiAKLXZvaWQgc2hvd19kYXRlX3JlbGF0aXZlKHRpbWVzdGFtcF90IHRpbWUsCi0JCQljb25zdCBzdHJ1Y3QgdGltZXZhbCAqbm93LAotCQkJc3RydWN0IHN0cmJ1ZiAqdGltZWJ1ZikKK3ZvaWQgc2hvd19kYXRlX3JlbGF0aXZlKHRpbWVzdGFtcF90IHRpbWUsIHN0cnVjdCBzdHJidWYgKnRpbWVidWYpCiB7CisJc3RydWN0IHRpbWV2YWwgbm93OwogCXRpbWVzdGFtcF90IGRpZmY7Ci0JaWYgKG5vdy0+dHZfc2VjIDwgdGltZSkgeworCisJZ2V0X3RpbWUoJm5vdyk7CisJaWYgKG5vdy50dl9zZWMgPCB0aW1lKSB7CiAJCXN0cmJ1Zl9hZGRzdHIodGltZWJ1ZiwgXygiaW4gdGhlIGZ1dHVyZSIpKTsKIAkJcmV0dXJuOwogCX0KLQlkaWZmID0gbm93LT50dl9zZWMgLSB0aW1lOworCWRpZmYgPSBub3cudHZfc2VjIC0gdGltZTsKIAlpZiAoZGlmZiA8IDkwKSB7CiAJCXN0cmJ1Zl9hZGRmKHRpbWVidWYsCiAJCQkgUV8oIiUiUFJJdGltZSIgc2Vjb25kIGFnbyIsICIlIlBSSXRpbWUiIHNlY29uZHMgYWdvIiwgZGlmZiksIGRpZmYpOwpAQCAtMjQwLDkgKzI0MSw3IEBACiAKIAkvKiBTaG93ICJ0b2RheSIgdGltZXMgYXMganVzdCByZWxhdGl2ZSB0aW1lcyAqLwogCWlmIChoaWRlLndkYXkpIHsKLQkJc3RydWN0IHRpbWV2YWwgbm93OwotCQlnZXRfdGltZSgmbm93KTsKLQkJc2hvd19kYXRlX3JlbGF0aXZlKHRpbWUsICZub3csIGJ1Zik7CisJCXNob3dfZGF0ZV9yZWxhdGl2ZSh0aW1lLCBidWYpOwogCQlyZXR1cm47CiAJfQogCkBAIC0zMTMsMTEgKzMxMiw4IEBACiAJfQogCiAJaWYgKG1vZGUtPnR5cGUgPT0gREFURV9SRUxBVElWRSkgewotCQlzdHJ1Y3QgdGltZXZhbCBub3c7Ci0KIAkJc3RyYnVmX3Jlc2V0KCZ0aW1lYnVmKTsKLQkJZ2V0X3RpbWUoJm5vdyk7Ci0JCXNob3dfZGF0ZV9yZWxhdGl2ZSh0aW1lLCAmbm93LCAmdGltZWJ1Zik7CisJCXNob3dfZGF0ZV9yZWxhdGl2ZSh0aW1lLCAmdGltZWJ1Zik7CiAJCXJldHVybiB0aW1lYnVmLmJ1ZjsKIAl9CiAKQEAgLTEyODgsMTUgKzEyODQsMTggQEAKIAlyZXR1cm4gKHRpbWVzdGFtcF90KXVwZGF0ZV90bSgmdG0sICZub3csIDApOwogfQogCi10aW1lc3RhbXBfdCBhcHByb3hpZGF0ZV9yZWxhdGl2ZShjb25zdCBjaGFyICpkYXRlLCBjb25zdCBzdHJ1Y3QgdGltZXZhbCAqdHYpCit0aW1lc3RhbXBfdCBhcHByb3hpZGF0ZV9yZWxhdGl2ZShjb25zdCBjaGFyICpkYXRlKQogeworCXN0cnVjdCB0aW1ldmFsIHR2OwogCXRpbWVzdGFtcF90IHRpbWVzdGFtcDsKIAlpbnQgb2Zmc2V0OwogCWludCBlcnJvcnMgPSAwOwogCiAJaWYgKCFwYXJzZV9kYXRlX2Jhc2ljKGRhdGUsICZ0aW1lc3RhbXAsICZvZmZzZXQpKQogCQlyZXR1cm4gdGltZXN0YW1wOwotCXJldHVybiBhcHByb3hpZGF0ZV9zdHIoZGF0ZSwgdHYsICZlcnJvcnMpOworCisJZ2V0X3RpbWUoJnR2KTsKKwlyZXR1cm4gYXBwcm94aWRhdGVfc3RyKGRhdGUsIChjb25zdCBzdHJ1Y3QgdGltZXZhbCAqKSAmdHYsICZlcnJvcnMpOwogfQogCiB0aW1lc3RhbXBfdCBhcHByb3hpZGF0ZV9jYXJlZnVsKGNvbnN0IGNoYXIgKmRhdGUsIGludCAqZXJyb3JfcmV0KQpkaWZmIC0tZ2l0IGEvZGlmZi1kZWx0YS5jIGIvZGlmZi1kZWx0YS5jCmluZGV4IGU0OTY0MzMuLjc3ZmVhMDggMTAwNjQ0Ci0tLSBhL2RpZmYtZGVsdGEuYworKysgYi9kaWZmLWRlbHRhLmMKQEAgLTMyNiw2ICszMjYsOCBAQAogCWNvbnN0IHVuc2lnbmVkIGNoYXIgKnJlZl9kYXRhLCAqcmVmX3RvcCwgKmRhdGEsICp0b3A7CiAJdW5zaWduZWQgY2hhciAqb3V0OwogCisJKmRlbHRhX3NpemUgPSAwOworCiAJaWYgKCF0cmdfYnVmIHx8ICF0cmdfc2l6ZSkKIAkJcmV0dXJuIE5VTEw7CiAKZGlmZiAtLWdpdCBhL2RpZmYuYyBiL2RpZmYuYwppbmRleCBlZmU0MmIzLi44ZTI5MTRjIDEwMDY0NAotLS0gYS9kaWZmLmMKKysrIGIvZGlmZi5jCkBAIC0yNSw3ICsyNSw3IEBACiAjaW5jbHVkZSAicGFja2ZpbGUuaCIKICNpbmNsdWRlICJwYXJzZS1vcHRpb25zLmgiCiAjaW5jbHVkZSAiaGVscC5oIgotI2luY2x1ZGUgImZldGNoLW9iamVjdC5oIgorI2luY2x1ZGUgInByb21pc29yLXJlbW90ZS5oIgogCiAjaWZkZWYgTk9fRkFTVF9XT1JLSU5HX0RJUkVDVE9SWQogI2RlZmluZSBGQVNUX1dPUktJTkdfRElSRUNUT1JZIDAKQEAgLTkzMywxNiArOTMzLDE4IEBACiB9CiAKIHN0YXRpYyBpbnQgbW92ZWRfZW50cnlfY21wKGNvbnN0IHZvaWQgKmhhc2htYXBfY21wX2ZuX2RhdGEsCi0JCQkgICBjb25zdCB2b2lkICplbnRyeSwKLQkJCSAgIGNvbnN0IHZvaWQgKmVudHJ5X29yX2tleSwKKwkJCSAgIGNvbnN0IHN0cnVjdCBoYXNobWFwX2VudHJ5ICplcHRyLAorCQkJICAgY29uc3Qgc3RydWN0IGhhc2htYXBfZW50cnkgKmVudHJ5X29yX2tleSwKIAkJCSAgIGNvbnN0IHZvaWQgKmtleWRhdGEpCiB7CiAJY29uc3Qgc3RydWN0IGRpZmZfb3B0aW9ucyAqZGlmZm9wdCA9IGhhc2htYXBfY21wX2ZuX2RhdGE7Ci0JY29uc3Qgc3RydWN0IG1vdmVkX2VudHJ5ICphID0gZW50cnk7Ci0JY29uc3Qgc3RydWN0IG1vdmVkX2VudHJ5ICpiID0gZW50cnlfb3Jfa2V5OworCWNvbnN0IHN0cnVjdCBtb3ZlZF9lbnRyeSAqYSwgKmI7CiAJdW5zaWduZWQgZmxhZ3MgPSBkaWZmb3B0LT5jb2xvcl9tb3ZlZF93c19oYW5kbGluZwogCQkJICYgWERGX1dISVRFU1BBQ0VfRkxBR1M7CiAKKwlhID0gY29udGFpbmVyX29mKGVwdHIsIGNvbnN0IHN0cnVjdCBtb3ZlZF9lbnRyeSwgZW50KTsKKwliID0gY29udGFpbmVyX29mKGVudHJ5X29yX2tleSwgY29uc3Qgc3RydWN0IG1vdmVkX2VudHJ5LCBlbnQpOworCiAJaWYgKGRpZmZvcHQtPmNvbG9yX21vdmVkX3dzX2hhbmRsaW5nICYKIAkgICAgQ09MT1JfTU9WRURfV1NfQUxMT1dfSU5ERU5UQVRJT05fQ0hBTkdFKQogCQkvKgpAQCAtOTY0LDggKzk2Niw5IEBACiAJc3RydWN0IG1vdmVkX2VudHJ5ICpyZXQgPSB4bWFsbG9jKHNpemVvZigqcmV0KSk7CiAJc3RydWN0IGVtaXR0ZWRfZGlmZl9zeW1ib2wgKmwgPSAmby0+ZW1pdHRlZF9zeW1ib2xzLT5idWZbbGluZV9ub107CiAJdW5zaWduZWQgZmxhZ3MgPSBvLT5jb2xvcl9tb3ZlZF93c19oYW5kbGluZyAmIFhERl9XSElURVNQQUNFX0ZMQUdTOworCXVuc2lnbmVkIGludCBoYXNoID0geGRpZmZfaGFzaF9zdHJpbmcobC0+bGluZSwgbC0+bGVuLCBmbGFncyk7CiAKLQlyZXQtPmVudC5oYXNoID0geGRpZmZfaGFzaF9zdHJpbmcobC0+bGluZSwgbC0+bGVuLCBmbGFncyk7CisJaGFzaG1hcF9lbnRyeV9pbml0KCZyZXQtPmVudCwgaGFzaCk7CiAJcmV0LT5lcyA9IGw7CiAJcmV0LT5uZXh0X2xpbmUgPSBOVUxMOwogCkBAIC0xMDAyLDcgKzEwMDUsNyBAQAogCQlpZiAocHJldl9saW5lICYmIHByZXZfbGluZS0+ZXMtPnMgPT0gby0+ZW1pdHRlZF9zeW1ib2xzLT5idWZbbl0ucykKIAkJCXByZXZfbGluZS0+bmV4dF9saW5lID0ga2V5OwogCi0JCWhhc2htYXBfYWRkKGhtLCBrZXkpOworCQloYXNobWFwX2FkZChobSwgJmtleS0+ZW50KTsKIAkJcHJldl9saW5lID0ga2V5OwogCX0KIH0KQEAgLTEwMTgsNyArMTAyMSw3IEBACiAJCXN0cnVjdCBtb3ZlZF9lbnRyeSAqcHJldiA9IHBtYltpXS5tYXRjaDsKIAkJc3RydWN0IG1vdmVkX2VudHJ5ICpjdXIgPSAocHJldiAmJiBwcmV2LT5uZXh0X2xpbmUpID8KIAkJCQlwcmV2LT5uZXh0X2xpbmUgOiBOVUxMOwotCQlpZiAoY3VyICYmICFobS0+Y21wZm4obywgY3VyLCBtYXRjaCwgTlVMTCkpIHsKKwkJaWYgKGN1ciAmJiAhaG0tPmNtcGZuKG8sICZjdXItPmVudCwgJm1hdGNoLT5lbnQsIE5VTEwpKSB7CiAJCQlwbWJbaV0ubWF0Y2ggPSBjdXI7CiAJCX0gZWxzZSB7CiAJCQlwbWJbaV0ubWF0Y2ggPSBOVUxMOwpAQCAtMTAzNSw3ICsxMDM4LDcgQEAKIAlpbnQgaTsKIAljaGFyICpnb3RfbWF0Y2ggPSB4Y2FsbG9jKDEsIHBtYl9ucik7CiAKLQlmb3IgKDsgbWF0Y2g7IG1hdGNoID0gaGFzaG1hcF9nZXRfbmV4dChobSwgbWF0Y2gpKSB7CisJaGFzaG1hcF9mb3JfZWFjaF9lbnRyeV9mcm9tKGhtLCBtYXRjaCwgZW50KSB7CiAJCWZvciAoaSA9IDA7IGkgPCBwbWJfbnI7IGkrKykgewogCQkJc3RydWN0IG1vdmVkX2VudHJ5ICpwcmV2ID0gcG1iW2ldLm1hdGNoOwogCQkJc3RydWN0IG1vdmVkX2VudHJ5ICpjdXIgPSAocHJldiAmJiBwcmV2LT5uZXh0X2xpbmUpID8KQEAgLTExNDMsMTMgKzExNDYsMTMgQEAKIAkJY2FzZSBESUZGX1NZTUJPTF9QTFVTOgogCQkJaG0gPSBkZWxfbGluZXM7CiAJCQlrZXkgPSBwcmVwYXJlX2VudHJ5KG8sIG4pOwotCQkJbWF0Y2ggPSBoYXNobWFwX2dldChobSwga2V5LCBOVUxMKTsKKwkJCW1hdGNoID0gaGFzaG1hcF9nZXRfZW50cnkoaG0sIGtleSwgZW50LCBOVUxMKTsKIAkJCWZyZWUoa2V5KTsKIAkJCWJyZWFrOwogCQljYXNlIERJRkZfU1lNQk9MX01JTlVTOgogCQkJaG0gPSBhZGRfbGluZXM7CiAJCQlrZXkgPSBwcmVwYXJlX2VudHJ5KG8sIG4pOwotCQkJbWF0Y2ggPSBoYXNobWFwX2dldChobSwga2V5LCBOVUxMKTsKKwkJCW1hdGNoID0gaGFzaG1hcF9nZXRfZW50cnkoaG0sIGtleSwgZW50LCBOVUxMKTsKIAkJCWZyZWUoa2V5KTsKIAkJCWJyZWFrOwogCQlkZWZhdWx0OgpAQCAtMTE4OCw3ICsxMTkxLDcgQEAKIAkJCSAqIFRoZSBjdXJyZW50IGxpbmUgaXMgdGhlIHN0YXJ0IG9mIGEgbmV3IGJsb2NrLgogCQkJICogU2V0dXAgdGhlIHNldCBvZiBwb3RlbnRpYWwgYmxvY2tzLgogCQkJICovCi0JCQlmb3IgKDsgbWF0Y2g7IG1hdGNoID0gaGFzaG1hcF9nZXRfbmV4dChobSwgbWF0Y2gpKSB7CisJCQloYXNobWFwX2Zvcl9lYWNoX2VudHJ5X2Zyb20oaG0sIG1hdGNoLCBlbnQpIHsKIAkJCQlBTExPQ19HUk9XKHBtYiwgcG1iX25yICsgMSwgcG1iX2FsbG9jKTsKIAkJCQlpZiAoby0+Y29sb3JfbW92ZWRfd3NfaGFuZGxpbmcgJgogCQkJCSAgICBDT0xPUl9NT1ZFRF9XU19BTExPV19JTkRFTlRBVElPTl9DSEFOR0UpIHsKQEAgLTI0OTIsMjIgKzI0OTUsNiBAQAogCX0KIH0KIAotc3RydWN0IGRpZmZzdGF0X3QgewotCWludCBucjsKLQlpbnQgYWxsb2M7Ci0Jc3RydWN0IGRpZmZzdGF0X2ZpbGUgewotCQljaGFyICpmcm9tX25hbWU7Ci0JCWNoYXIgKm5hbWU7Ci0JCWNoYXIgKnByaW50X25hbWU7Ci0JCWNvbnN0IGNoYXIgKmNvbW1lbnRzOwotCQl1bnNpZ25lZCBpc191bm1lcmdlZDoxOwotCQl1bnNpZ25lZCBpc19iaW5hcnk6MTsKLQkJdW5zaWduZWQgaXNfcmVuYW1lZDoxOwotCQl1bnNpZ25lZCBpc19pbnRlcmVzdGluZzoxOwotCQl1aW50bWF4X3QgYWRkZWQsIGRlbGV0ZWQ7Ci0JfSAqKmZpbGVzOwotfTsKLQogc3RhdGljIHN0cnVjdCBkaWZmc3RhdF9maWxlICpkaWZmc3RhdF9hZGQoc3RydWN0IGRpZmZzdGF0X3QgKmRpZmZzdGF0LAogCQkJCQkgIGNvbnN0IGNoYXIgKm5hbWVfYSwKIAkJCQkJICBjb25zdCBjaGFyICpuYW1lX2IpCkBAIC0yNTQ4LDcgKzI1MzUsNyBAQAogCS8qCiAJICogbWFrZSBzdXJlIHRoYXQgYXQgbGVhc3Qgb25lICctJyBvciAnKycgaXMgcHJpbnRlZCBpZgogCSAqIHRoZXJlIGlzIGFueSBjaGFuZ2UgdG8gdGhpcyBwYXRoLiBUaGUgZWFzaWVzdCB3YXkgaXMgdG8KLQkgKiBzY2FsZSBsaW5lYXJseSBhcyBpZiB0aGUgYWxsb3RlZCB3aWR0aCBpcyBvbmUgY29sdW1uIHNob3J0ZXIKKwkgKiBzY2FsZSBsaW5lYXJseSBhcyBpZiB0aGUgYWxsb3R0ZWQgd2lkdGggaXMgb25lIGNvbHVtbiBzaG9ydGVyCiAJICogdGhhbiBpdCBpcywgYW5kIHRoZW4gYWRkIDEgdG8gdGhlIHJlc3VsdC4KIAkgKi8KIAlyZXR1cm4gMSArIChpdCAqICh3aWR0aCAtIDEpIC8gbWF4X2NoYW5nZSk7CkBAIC0zMTU0LDcgKzMxNDEsNyBAQAogCWdhdGhlcl9kaXJzdGF0KG9wdGlvbnMsICZkaXIsIGNoYW5nZWQsICIiLCAwKTsKIH0KIAotc3RhdGljIHZvaWQgZnJlZV9kaWZmc3RhdF9pbmZvKHN0cnVjdCBkaWZmc3RhdF90ICpkaWZmc3RhdCkKK3ZvaWQgZnJlZV9kaWZmc3RhdF9pbmZvKHN0cnVjdCBkaWZmc3RhdF90ICpkaWZmc3RhdCkKIHsKIAlpbnQgaTsKIAlmb3IgKGkgPSAwOyBpIDwgZGlmZnN0YXQtPm5yOyBpKyspIHsKQEAgLTMxOTMsNyArMzE4MCw3IEBACiAJZm9yIChjbnQgPSAxOyBjbnQgPCBtYXJrZXJfc2l6ZTsgY250KyspCiAJCWlmIChsaW5lW2NudF0gIT0gZmlyc3RjaGFyKQogCQkJcmV0dXJuIDA7Ci0JLyogbGluZVsxXSB0aHJ1IGxpbmVbbWFya2VyX3NpemUtMV0gYXJlIHNhbWUgYXMgZmlyc3RjaGFyICovCisJLyogbGluZVsxXSB0aHJvdWdoIGxpbmVbbWFya2VyX3NpemUtMV0gYXJlIHNhbWUgYXMgZmlyc3RjaGFyICovCiAJaWYgKGxlbiA8IG1hcmtlcl9zaXplICsgMSB8fCAhaXNzcGFjZShsaW5lW21hcmtlcl9zaXplXSkpCiAJCXJldHVybiAwOwogCXJldHVybiAxOwpAQCAtNTk3OCw3ICs1OTY1LDcgQEAKIH0KIAogc3RydWN0IHBhdGNoX2lkX3QgewotCWdpdF9TSEFfQ1RYICpjdHg7CisJZ2l0X2hhc2hfY3R4ICpjdHg7CiAJaW50IHBhdGNobGVuOwogfTsKIApAQCAtNTk5NSwxNiArNTk4MiwxNiBAQAogCXJldHVybiBkc3QgLSBsaW5lOwogfQogCi12b2lkIGZsdXNoX29uZV9odW5rKHN0cnVjdCBvYmplY3RfaWQgKnJlc3VsdCwgZ2l0X1NIQV9DVFggKmN0eCkKK3ZvaWQgZmx1c2hfb25lX2h1bmsoc3RydWN0IG9iamVjdF9pZCAqcmVzdWx0LCBnaXRfaGFzaF9jdHggKmN0eCkKIHsKIAl1bnNpZ25lZCBjaGFyIGhhc2hbR0lUX01BWF9SQVdTWl07CiAJdW5zaWduZWQgc2hvcnQgY2FycnkgPSAwOwogCWludCBpOwogCi0JZ2l0X1NIQTFfRmluYWwoaGFzaCwgY3R4KTsKLQlnaXRfU0hBMV9Jbml0KGN0eCk7CisJdGhlX2hhc2hfYWxnby0+ZmluYWxfZm4oaGFzaCwgY3R4KTsKKwl0aGVfaGFzaF9hbGdvLT5pbml0X2ZuKGN0eCk7CiAJLyogMjAtYnl0ZSBzdW0sIHdpdGggY2FycnkgKi8KLQlmb3IgKGkgPSAwOyBpIDwgR0lUX1NIQTFfUkFXU1o7ICsraSkgeworCWZvciAoaSA9IDA7IGkgPCB0aGVfaGFzaF9hbGdvLT5yYXdzejsgKytpKSB7CiAJCWNhcnJ5ICs9IHJlc3VsdC0+aGFzaFtpXSArIGhhc2hbaV07CiAJCXJlc3VsdC0+aGFzaFtpXSA9IGNhcnJ5OwogCQljYXJyeSA+Pj0gODsKQEAgLTYwMTgsMjEgKzYwMDUsMjEgQEAKIAogCW5ld19sZW4gPSByZW1vdmVfc3BhY2UobGluZSwgbGVuKTsKIAotCWdpdF9TSEExX1VwZGF0ZShkYXRhLT5jdHgsIGxpbmUsIG5ld19sZW4pOworCXRoZV9oYXNoX2FsZ28tPnVwZGF0ZV9mbihkYXRhLT5jdHgsIGxpbmUsIG5ld19sZW4pOwogCWRhdGEtPnBhdGNobGVuICs9IG5ld19sZW47CiB9CiAKLXN0YXRpYyB2b2lkIHBhdGNoX2lkX2FkZF9zdHJpbmcoZ2l0X1NIQV9DVFggKmN0eCwgY29uc3QgY2hhciAqc3RyKQorc3RhdGljIHZvaWQgcGF0Y2hfaWRfYWRkX3N0cmluZyhnaXRfaGFzaF9jdHggKmN0eCwgY29uc3QgY2hhciAqc3RyKQogewotCWdpdF9TSEExX1VwZGF0ZShjdHgsIHN0ciwgc3RybGVuKHN0cikpOworCXRoZV9oYXNoX2FsZ28tPnVwZGF0ZV9mbihjdHgsIHN0ciwgc3RybGVuKHN0cikpOwogfQogCi1zdGF0aWMgdm9pZCBwYXRjaF9pZF9hZGRfbW9kZShnaXRfU0hBX0NUWCAqY3R4LCB1bnNpZ25lZCBtb2RlKQorc3RhdGljIHZvaWQgcGF0Y2hfaWRfYWRkX21vZGUoZ2l0X2hhc2hfY3R4ICpjdHgsIHVuc2lnbmVkIG1vZGUpCiB7CiAJLyogbGFyZ2UgZW5vdWdoIGZvciAyXjMyIGluIG9jdGFsICovCiAJY2hhciBidWZbMTJdOwogCWludCBsZW4gPSB4c25wcmludGYoYnVmLCBzaXplb2YoYnVmKSwgIiUwNm8iLCBtb2RlKTsKLQlnaXRfU0hBMV9VcGRhdGUoY3R4LCBidWYsIGxlbik7CisJdGhlX2hhc2hfYWxnby0+dXBkYXRlX2ZuKGN0eCwgYnVmLCBsZW4pOwogfQogCiAvKiByZXR1cm5zIDAgdXBvbiBzdWNjZXNzLCBhbmQgd3JpdGVzIHJlc3VsdCBpbnRvIG9pZCAqLwpAQCAtNjA0MCwxMCArNjAyNywxMCBAQAogewogCXN0cnVjdCBkaWZmX3F1ZXVlX3N0cnVjdCAqcSA9ICZkaWZmX3F1ZXVlZF9kaWZmOwogCWludCBpOwotCWdpdF9TSEFfQ1RYIGN0eDsKKwlnaXRfaGFzaF9jdHggY3R4OwogCXN0cnVjdCBwYXRjaF9pZF90IGRhdGE7CiAKLQlnaXRfU0hBMV9Jbml0KCZjdHgpOworCXRoZV9oYXNoX2FsZ28tPmluaXRfZm4oJmN0eCk7CiAJbWVtc2V0KCZkYXRhLCAwLCBzaXplb2Yoc3RydWN0IHBhdGNoX2lkX3QpKTsKIAlkYXRhLmN0eCA9ICZjdHg7CiAJb2lkY2xyKG9pZCk7CkBAIC02MDc2LDI3ICs2MDYzLDI3IEBACiAJCWxlbjIgPSByZW1vdmVfc3BhY2UocC0+dHdvLT5wYXRoLCBzdHJsZW4ocC0+dHdvLT5wYXRoKSk7CiAJCXBhdGNoX2lkX2FkZF9zdHJpbmcoJmN0eCwgImRpZmYtLWdpdCIpOwogCQlwYXRjaF9pZF9hZGRfc3RyaW5nKCZjdHgsICJhLyIpOwotCQlnaXRfU0hBMV9VcGRhdGUoJmN0eCwgcC0+b25lLT5wYXRoLCBsZW4xKTsKKwkJdGhlX2hhc2hfYWxnby0+dXBkYXRlX2ZuKCZjdHgsIHAtPm9uZS0+cGF0aCwgbGVuMSk7CiAJCXBhdGNoX2lkX2FkZF9zdHJpbmcoJmN0eCwgImIvIik7Ci0JCWdpdF9TSEExX1VwZGF0ZSgmY3R4LCBwLT50d28tPnBhdGgsIGxlbjIpOworCQl0aGVfaGFzaF9hbGdvLT51cGRhdGVfZm4oJmN0eCwgcC0+dHdvLT5wYXRoLCBsZW4yKTsKIAogCQlpZiAocC0+b25lLT5tb2RlID09IDApIHsKIAkJCXBhdGNoX2lkX2FkZF9zdHJpbmcoJmN0eCwgIm5ld2ZpbGVtb2RlIik7CiAJCQlwYXRjaF9pZF9hZGRfbW9kZSgmY3R4LCBwLT50d28tPm1vZGUpOwogCQkJcGF0Y2hfaWRfYWRkX3N0cmluZygmY3R4LCAiLS0tL2Rldi9udWxsIik7CiAJCQlwYXRjaF9pZF9hZGRfc3RyaW5nKCZjdHgsICIrKytiLyIpOwotCQkJZ2l0X1NIQTFfVXBkYXRlKCZjdHgsIHAtPnR3by0+cGF0aCwgbGVuMik7CisJCQl0aGVfaGFzaF9hbGdvLT51cGRhdGVfZm4oJmN0eCwgcC0+dHdvLT5wYXRoLCBsZW4yKTsKIAkJfSBlbHNlIGlmIChwLT50d28tPm1vZGUgPT0gMCkgewogCQkJcGF0Y2hfaWRfYWRkX3N0cmluZygmY3R4LCAiZGVsZXRlZGZpbGVtb2RlIik7CiAJCQlwYXRjaF9pZF9hZGRfbW9kZSgmY3R4LCBwLT5vbmUtPm1vZGUpOwogCQkJcGF0Y2hfaWRfYWRkX3N0cmluZygmY3R4LCAiLS0tYS8iKTsKLQkJCWdpdF9TSEExX1VwZGF0ZSgmY3R4LCBwLT5vbmUtPnBhdGgsIGxlbjEpOworCQkJdGhlX2hhc2hfYWxnby0+dXBkYXRlX2ZuKCZjdHgsIHAtPm9uZS0+cGF0aCwgbGVuMSk7CiAJCQlwYXRjaF9pZF9hZGRfc3RyaW5nKCZjdHgsICIrKysvZGV2L251bGwiKTsKIAkJfSBlbHNlIHsKIAkJCXBhdGNoX2lkX2FkZF9zdHJpbmcoJmN0eCwgIi0tLWEvIik7Ci0JCQlnaXRfU0hBMV9VcGRhdGUoJmN0eCwgcC0+b25lLT5wYXRoLCBsZW4xKTsKKwkJCXRoZV9oYXNoX2FsZ28tPnVwZGF0ZV9mbigmY3R4LCBwLT5vbmUtPnBhdGgsIGxlbjEpOwogCQkJcGF0Y2hfaWRfYWRkX3N0cmluZygmY3R4LCAiKysrYi8iKTsKLQkJCWdpdF9TSEExX1VwZGF0ZSgmY3R4LCBwLT50d28tPnBhdGgsIGxlbjIpOworCQkJdGhlX2hhc2hfYWxnby0+dXBkYXRlX2ZuKCZjdHgsIHAtPnR3by0+cGF0aCwgbGVuMik7CiAJCX0KIAogCQlpZiAoZGlmZl9oZWFkZXJfb25seSkKQEAgLTYxMDgsMTAgKzYwOTUsMTAgQEAKIAogCQlpZiAoZGlmZl9maWxlc3BlY19pc19iaW5hcnkob3B0aW9ucy0+cmVwbywgcC0+b25lKSB8fAogCQkgICAgZGlmZl9maWxlc3BlY19pc19iaW5hcnkob3B0aW9ucy0+cmVwbywgcC0+dHdvKSkgewotCQkJZ2l0X1NIQTFfVXBkYXRlKCZjdHgsIG9pZF90b19oZXgoJnAtPm9uZS0+b2lkKSwKLQkJCQkJR0lUX1NIQTFfSEVYU1opOwotCQkJZ2l0X1NIQTFfVXBkYXRlKCZjdHgsIG9pZF90b19oZXgoJnAtPnR3by0+b2lkKSwKLQkJCQkJR0lUX1NIQTFfSEVYU1opOworCQkJdGhlX2hhc2hfYWxnby0+dXBkYXRlX2ZuKCZjdHgsIG9pZF90b19oZXgoJnAtPm9uZS0+b2lkKSwKKwkJCQkJdGhlX2hhc2hfYWxnby0+aGV4c3opOworCQkJdGhlX2hhc2hfYWxnby0+dXBkYXRlX2ZuKCZjdHgsIG9pZF90b19oZXgoJnAtPnR3by0+b2lkKSwKKwkJCQkJdGhlX2hhc2hfYWxnby0+aGV4c3opOwogCQkJY29udGludWU7CiAJCX0KIApAQCAtNjEyOCw3ICs2MTE1LDcgQEAKIAl9CiAKIAlpZiAoIXN0YWJsZSkKLQkJZ2l0X1NIQTFfRmluYWwob2lkLT5oYXNoLCAmY3R4KTsKKwkJdGhlX2hhc2hfYWxnby0+ZmluYWxfZm4ob2lkLT5oYXNoLCAmY3R4KTsKIAogCXJldHVybiAwOwogfQpAQCAtNjIzMCw4ICs2MjE3LDEwIEBACiAJCQlpZiAoby0+Y29sb3JfbW92ZWQgPT0gQ09MT1JfTU9WRURfWkVCUkFfRElNKQogCQkJCWRpbV9tb3ZlZF9saW5lcyhvKTsKIAotCQkJaGFzaG1hcF9mcmVlKCZhZGRfbGluZXMsIDEpOwotCQkJaGFzaG1hcF9mcmVlKCZkZWxfbGluZXMsIDEpOworCQkJaGFzaG1hcF9mcmVlX2VudHJpZXMoJmFkZF9saW5lcywgc3RydWN0IG1vdmVkX2VudHJ5LAorCQkJCQkJZW50KTsKKwkJCWhhc2htYXBfZnJlZV9lbnRyaWVzKCZkZWxfbGluZXMsIHN0cnVjdCBtb3ZlZF9lbnRyeSwKKwkJCQkJCWVudCk7CiAJCX0KIAogCQlmb3IgKGkgPSAwOyBpIDwgZXNtLm5yOyBpKyspCkBAIC02Mjc4LDEyICs2MjY3LDcgQEAKIAkgICAgZGlyc3RhdF9ieV9saW5lKSB7CiAJCXN0cnVjdCBkaWZmc3RhdF90IGRpZmZzdGF0OwogCi0JCW1lbXNldCgmZGlmZnN0YXQsIDAsIHNpemVvZihzdHJ1Y3QgZGlmZnN0YXRfdCkpOwotCQlmb3IgKGkgPSAwOyBpIDwgcS0+bnI7IGkrKykgewotCQkJc3RydWN0IGRpZmZfZmlsZXBhaXIgKnAgPSBxLT5xdWV1ZVtpXTsKLQkJCWlmIChjaGVja19wYWlyX3N0YXR1cyhwKSkKLQkJCQlkaWZmX2ZsdXNoX3N0YXQocCwgb3B0aW9ucywgJmRpZmZzdGF0KTsKLQkJfQorCQljb21wdXRlX2RpZmZzdGF0KG9wdGlvbnMsICZkaWZmc3RhdCwgcSk7CiAJCWlmIChvdXRwdXRfZm9ybWF0ICYgRElGRl9GT1JNQVRfTlVNU1RBVCkKIAkJCXNob3dfbnVtc3RhdCgmZGlmZnN0YXQsIG9wdGlvbnMpOwogCQlpZiAob3V0cHV0X2Zvcm1hdCAmIERJRkZfRk9STUFUX0RJRkZTVEFUKQpAQCAtNjUxMiw2ICs2NDk2LDcgQEAKIAkJCSAgIGNvbnN0IHN0cnVjdCBkaWZmX2ZpbGVzcGVjICpmaWxlc3BlYykKIHsKIAlpZiAoZmlsZXNwZWMgJiYgZmlsZXNwZWMtPm9pZF92YWxpZCAmJgorCSAgICAhU19JU0dJVExJTksoZmlsZXNwZWMtPm1vZGUpICYmCiAJICAgIG9pZF9vYmplY3RfaW5mb19leHRlbmRlZChyLCAmZmlsZXNwZWMtPm9pZCwgTlVMTCwKIAkJCQkgICAgIE9CSkVDVF9JTkZPX0ZPUl9QUkVGRVRDSCkpCiAJCW9pZF9hcnJheV9hcHBlbmQodG9fZmV0Y2gsICZmaWxlc3BlYy0+b2lkKTsKQEAgLTY1MTksOCArNjUwNCw3IEBACiAKIHZvaWQgZGlmZmNvcmVfc3RkKHN0cnVjdCBkaWZmX29wdGlvbnMgKm9wdGlvbnMpCiB7Ci0JaWYgKG9wdGlvbnMtPnJlcG8gPT0gdGhlX3JlcG9zaXRvcnkgJiYKLQkgICAgcmVwb3NpdG9yeV9mb3JtYXRfcGFydGlhbF9jbG9uZSkgeworCWlmIChvcHRpb25zLT5yZXBvID09IHRoZV9yZXBvc2l0b3J5ICYmIGhhc19wcm9taXNvcl9yZW1vdGUoKSkgewogCQkvKgogCQkgKiBQcmVmZXRjaCB0aGUgZGlmZiBwYWlycyB0aGF0IGFyZSBhYm91dCB0byBiZSBmbHVzaGVkLgogCQkgKi8KQEAgLTY1MzcsOCArNjUyMSw4IEBACiAJCQkvKgogCQkJICogTkVFRFNXT1JLOiBDb25zaWRlciBkZWR1cGxpY2F0aW5nIHRoZSBPSURzIHNlbnQuCiAJCQkgKi8KLQkJCWZldGNoX29iamVjdHMocmVwb3NpdG9yeV9mb3JtYXRfcGFydGlhbF9jbG9uZSwKLQkJCQkgICAgICB0b19mZXRjaC5vaWQsIHRvX2ZldGNoLm5yKTsKKwkJCXByb21pc29yX3JlbW90ZV9nZXRfZGlyZWN0KG9wdGlvbnMtPnJlcG8sCisJCQkJCQkgICB0b19mZXRjaC5vaWQsIHRvX2ZldGNoLm5yKTsKIAkJb2lkX2FycmF5X2NsZWFyKCZ0b19mZXRjaCk7CiAJfQogCkBAIC02NjE2LDYgKzY2MDAsMjAgQEAKIAlyZXR1cm4gaWdub3JlZDsKIH0KIAordm9pZCBjb21wdXRlX2RpZmZzdGF0KHN0cnVjdCBkaWZmX29wdGlvbnMgKm9wdGlvbnMsCisJCSAgICAgIHN0cnVjdCBkaWZmc3RhdF90ICpkaWZmc3RhdCwKKwkJICAgICAgc3RydWN0IGRpZmZfcXVldWVfc3RydWN0ICpxKQoreworCWludCBpOworCisJbWVtc2V0KGRpZmZzdGF0LCAwLCBzaXplb2Yoc3RydWN0IGRpZmZzdGF0X3QpKTsKKwlmb3IgKGkgPSAwOyBpIDwgcS0+bnI7IGkrKykgeworCQlzdHJ1Y3QgZGlmZl9maWxlcGFpciAqcCA9IHEtPnF1ZXVlW2ldOworCQlpZiAoY2hlY2tfcGFpcl9zdGF0dXMocCkpCisJCQlkaWZmX2ZsdXNoX3N0YXQocCwgb3B0aW9ucywgZGlmZnN0YXQpOworCX0KK30KKwogdm9pZCBkaWZmX2FkZHJlbW92ZShzdHJ1Y3QgZGlmZl9vcHRpb25zICpvcHRpb25zLAogCQkgICAgaW50IGFkZHJlbW92ZSwgdW5zaWduZWQgbW9kZSwKIAkJICAgIGNvbnN0IHN0cnVjdCBvYmplY3RfaWQgKm9pZCwKZGlmZiAtLWdpdCBhL2RpZmYuaCBiL2RpZmYuaAppbmRleCBjMmMzMDU2Li5kOTg2ZGRjIDEwMDY0NAotLS0gYS9kaWZmLmgKKysrIGIvZGlmZi5oCkBAIC0yNDUsNiArMjQ1LDIyIEBACiB2b2lkIGRpZmZfZW1pdF9zdWJtb2R1bGVfcGlwZXRocm91Z2goc3RydWN0IGRpZmZfb3B0aW9ucyAqbywKIAkJCQkgICAgIGNvbnN0IGNoYXIgKmxpbmUsIGludCBsZW4pOwogCitzdHJ1Y3QgZGlmZnN0YXRfdCB7CisJaW50IG5yOworCWludCBhbGxvYzsKKwlzdHJ1Y3QgZGlmZnN0YXRfZmlsZSB7CisJCWNoYXIgKmZyb21fbmFtZTsKKwkJY2hhciAqbmFtZTsKKwkJY2hhciAqcHJpbnRfbmFtZTsKKwkJY29uc3QgY2hhciAqY29tbWVudHM7CisJCXVuc2lnbmVkIGlzX3VubWVyZ2VkOjE7CisJCXVuc2lnbmVkIGlzX2JpbmFyeToxOworCQl1bnNpZ25lZCBpc19yZW5hbWVkOjE7CisJCXVuc2lnbmVkIGlzX2ludGVyZXN0aW5nOjE7CisJCXVpbnRtYXhfdCBhZGRlZCwgZGVsZXRlZDsKKwl9ICoqZmlsZXM7Cit9OworCiBlbnVtIGNvbG9yX2RpZmYgewogCURJRkZfUkVTRVQgPSAwLAogCURJRkZfQ09OVEVYVCA9IDEsCkBAIC0zMzQsNiArMzUwLDEwIEBACiAKIHN0cnVjdCBkaWZmX2ZpbGVwYWlyICpkaWZmX3VubWVyZ2Uoc3RydWN0IGRpZmZfb3B0aW9ucyAqLCBjb25zdCBjaGFyICpwYXRoKTsKIAordm9pZCBjb21wdXRlX2RpZmZzdGF0KHN0cnVjdCBkaWZmX29wdGlvbnMgKm9wdGlvbnMsIHN0cnVjdCBkaWZmc3RhdF90ICpkaWZmc3RhdCwKKwkJICAgICAgc3RydWN0IGRpZmZfcXVldWVfc3RydWN0ICpxKTsKK3ZvaWQgZnJlZV9kaWZmc3RhdF9pbmZvKHN0cnVjdCBkaWZmc3RhdF90ICpkaWZmc3RhdCk7CisKICNkZWZpbmUgRElGRl9TRVRVUF9SRVZFUlNFICAgICAgCTEKICNkZWZpbmUgRElGRl9TRVRVUF9VU0VfU0laRV9DQUNIRQk0CiAKQEAgLTQzOCw3ICs0NTgsNyBAQAogCiBpbnQgZG9fZGlmZl9jYWNoZShjb25zdCBzdHJ1Y3Qgb2JqZWN0X2lkICosIHN0cnVjdCBkaWZmX29wdGlvbnMgKik7CiBpbnQgZGlmZl9mbHVzaF9wYXRjaF9pZChzdHJ1Y3QgZGlmZl9vcHRpb25zICosIHN0cnVjdCBvYmplY3RfaWQgKiwgaW50LCBpbnQpOwotdm9pZCBmbHVzaF9vbmVfaHVuayhzdHJ1Y3Qgb2JqZWN0X2lkICosIGdpdF9TSEFfQ1RYICopOwordm9pZCBmbHVzaF9vbmVfaHVuayhzdHJ1Y3Qgb2JqZWN0X2lkICpyZXN1bHQsIGdpdF9oYXNoX2N0eCAqY3R4KTsKIAogaW50IGRpZmZfcmVzdWx0X2NvZGUoc3RydWN0IGRpZmZfb3B0aW9ucyAqLCBpbnQpOwogCmRpZmYgLS1naXQgYS9kaWZmY29yZS1icmVhay5jIGIvZGlmZmNvcmUtYnJlYWsuYwppbmRleCA4NzVhZWZkLi45ZDIwYTZhIDEwMDY0NAotLS0gYS9kaWZmY29yZS1icmVhay5jCisrKyBiL2RpZmZjb3JlLWJyZWFrLmMKQEAgLTI4NiwxNyArMjg2LDE3IEBACiAJCQkJCS8qIFBlZXIgc3Vydml2ZWQuICBNZXJnZSB0aGVtICovCiAJCQkJCW1lcmdlX2Jyb2tlbihwLCBwcCwgJm91dHEpOwogCQkJCQlxLT5xdWV1ZVtqXSA9IE5VTEw7Ci0JCQkJCWJyZWFrOworCQkJCQlnb3RvIG5leHQ7CiAJCQkJfQogCQkJfQotCQkJaWYgKHEtPm5yIDw9IGopCi0JCQkJLyogVGhlIHBlZXIgZGlkIG5vdCBzdXJ2aXZlLCBzbyB3ZSBrZWVwCi0JCQkJICogaXQgaW4gdGhlIG91dHB1dC4KLQkJCQkgKi8KLQkJCQlkaWZmX3EoJm91dHEsIHApOworCQkJLyogVGhlIHBlZXIgZGlkIG5vdCBzdXJ2aXZlLCBzbyB3ZSBrZWVwCisJCQkgKiBpdCBpbiB0aGUgb3V0cHV0LgorCQkJICovCisJCQlkaWZmX3EoJm91dHEsIHApOwogCQl9CiAJCWVsc2UKIAkJCWRpZmZfcSgmb3V0cSwgcCk7CituZXh0OjsKIAl9CiAJZnJlZShxLT5xdWV1ZSk7CiAJKnEgPSBvdXRxOwpkaWZmIC0tZ2l0IGEvZGlmZmNvcmUtcmVuYW1lLmMgYi9kaWZmY29yZS1yZW5hbWUuYwppbmRleCA5NjI0ODY0Li41MzFkN2FkIDEwMDY0NAotLS0gYS9kaWZmY29yZS1yZW5hbWUuYworKysgYi9kaWZmY29yZS1yZW5hbWUuYwpAQCAtMjc0LDE4ICsyNzQsMTcgQEAKIAkJCQlzdHJ1Y3QgZGlmZl9vcHRpb25zICpvcHRpb25zKQogewogCWludCByZW5hbWVzID0gMDsKLQogCXN0cnVjdCBkaWZmX2ZpbGVzcGVjICp0YXJnZXQgPSByZW5hbWVfZHN0W2RzdF9pbmRleF0udHdvOwogCXN0cnVjdCBmaWxlX3NpbWlsYXJpdHkgKnAsICpiZXN0ID0gTlVMTDsKIAlpbnQgaSA9IDEwMCwgYmVzdF9zY29yZSA9IC0xOworCXVuc2lnbmVkIGludCBoYXNoID0gaGFzaF9maWxlc3BlYyhvcHRpb25zLT5yZXBvLCB0YXJnZXQpOwogCiAJLyoKIAkgKiBGaW5kIHRoZSBiZXN0IHNvdXJjZSBtYXRjaCBmb3Igc3BlY2lmaWVkIGRlc3RpbmF0aW9uLgogCSAqLwotCXAgPSBoYXNobWFwX2dldF9mcm9tX2hhc2goc3JjcywKLQkJCQkgIGhhc2hfZmlsZXNwZWMob3B0aW9ucy0+cmVwbywgdGFyZ2V0KSwKLQkJCQkgIE5VTEwpOwotCWZvciAoOyBwOyBwID0gaGFzaG1hcF9nZXRfbmV4dChzcmNzLCBwKSkgeworCXAgPSBoYXNobWFwX2dldF9lbnRyeV9mcm9tX2hhc2goc3JjcywgaGFzaCwgTlVMTCwKKwkJCQkJc3RydWN0IGZpbGVfc2ltaWxhcml0eSwgZW50cnkpOworCWhhc2htYXBfZm9yX2VhY2hfZW50cnlfZnJvbShzcmNzLCBwLCBlbnRyeSkgewogCQlpbnQgc2NvcmU7CiAJCXN0cnVjdCBkaWZmX2ZpbGVzcGVjICpzb3VyY2UgPSBwLT5maWxlc3BlYzsKIApAQCAtMzI5LDggKzMyOCw4IEBACiAJZW50cnktPmluZGV4ID0gaW5kZXg7CiAJZW50cnktPmZpbGVzcGVjID0gZmlsZXNwZWM7CiAKLQloYXNobWFwX2VudHJ5X2luaXQoZW50cnksIGhhc2hfZmlsZXNwZWMociwgZmlsZXNwZWMpKTsKLQloYXNobWFwX2FkZCh0YWJsZSwgZW50cnkpOworCWhhc2htYXBfZW50cnlfaW5pdCgmZW50cnktPmVudHJ5LCBoYXNoX2ZpbGVzcGVjKHIsIGZpbGVzcGVjKSk7CisJaGFzaG1hcF9hZGQodGFibGUsICZlbnRyeS0+ZW50cnkpOwogfQogCiAvKgpAQCAtMzU5LDcgKzM1OCw3IEBACiAJCXJlbmFtZXMgKz0gZmluZF9pZGVudGljYWxfZmlsZXMoJmZpbGVfdGFibGUsIGksIG9wdGlvbnMpOwogCiAJLyogRnJlZSB0aGUgaGFzaCBkYXRhIHN0cnVjdHVyZSBhbmQgZW50cmllcyAqLwotCWhhc2htYXBfZnJlZSgmZmlsZV90YWJsZSwgMSk7CisJaGFzaG1hcF9mcmVlX2VudHJpZXMoJmZpbGVfdGFibGUsIHN0cnVjdCBmaWxlX3NpbWlsYXJpdHksIGVudHJ5KTsKIAogCXJldHVybiByZW5hbWVzOwogfQpAQCAtNTg1LDcgKzU4NCw3IEBACiAJc3RvcF9wcm9ncmVzcygmcHJvZ3Jlc3MpOwogCiAJLyogY29zdCBtYXRyaXggc29ydGVkIGJ5IG1vc3QgdG8gbGVhc3Qgc2ltaWxhciBwYWlyICovCi0JUVNPUlQobXgsIGRzdF9jbnQgKiBOVU1fQ0FORElEQVRFX1BFUl9EU1QsIHNjb3JlX2NvbXBhcmUpOworCVNUQUJMRV9RU09SVChteCwgZHN0X2NudCAqIE5VTV9DQU5ESURBVEVfUEVSX0RTVCwgc2NvcmVfY29tcGFyZSk7CiAKIAlyZW5hbWVfY291bnQgKz0gZmluZF9yZW5hbWVzKG14LCBkc3RfY250LCBtaW5pbXVtX3Njb3JlLCAwKTsKIAlpZiAoZGV0ZWN0X3JlbmFtZSA9PSBESUZGX0RFVEVDVF9DT1BZKQpkaWZmIC0tZ2l0IGEvZGlyLmMgYi9kaXIuYwppbmRleCBkMDIxYzkwLi45MDQ3MzczIDEwMDY0NAotLS0gYS9kaXIuYworKysgYi9kaXIuYwpAQCAtMTM5LDcgKzEzOSw3IEBACiAJICogIjooaWNhc2UpcGF0aCIgaXMgdHJlYXRlZCBhcyBhIHBhdGhzcGVjIGZ1bGwgb2YKIAkgKiB3aWxkY2FyZC4gSW4gb3RoZXIgd29yZHMsIG9ubHkgcHJlZml4IGlzIGNvbnNpZGVyZWQgY29tbW9uCiAJICogcHJlZml4LiBJZiB0aGUgcGF0aHNwZWMgaXMgYWJjL2ZvbyBhYmMvYmFyLCBydW5uaW5nIGluCi0JICogc3ViZGlyIHh5eiwgdGhlIGNvbW1vbiBwcmVmaXggaXMgc3RpbGwgeHl6LCBub3QgeHV6L2FiYyBhcworCSAqIHN1YmRpciB4eXosIHRoZSBjb21tb24gcHJlZml4IGlzIHN0aWxsIHh5eiwgbm90IHh5ei9hYmMgYXMKIAkgKiBpbiBub24tOihpY2FzZSkuCiAJICovCiAJR1VBUkRfUEFUSFNQRUMocGF0aHNwZWMsCkBAIC0yNzMsMTkgKzI3MywzMCBAQAogCiAjZGVmaW5lIERPX01BVENIX0VYQ0xVREUgICAoMTw8MCkKICNkZWZpbmUgRE9fTUFUQ0hfRElSRUNUT1JZICgxPDwxKQotI2RlZmluZSBET19NQVRDSF9TVUJNT0RVTEUgKDE8PDIpCisjZGVmaW5lIERPX01BVENIX0xFQURJTkdfUEFUSFNQRUMgKDE8PDIpCiAKIC8qCi0gKiBEb2VzICdtYXRjaCcgbWF0Y2ggdGhlIGdpdmVuIG5hbWU/Ci0gKiBBIG1hdGNoIGlzIGZvdW5kIGlmCisgKiBEb2VzIHRoZSBnaXZlbiBwYXRoc3BlYyBtYXRjaCB0aGUgZ2l2ZW4gbmFtZT8gIEEgbWF0Y2ggaXMgZm91bmQgaWYKICAqCi0gKiAoMSkgdGhlICdtYXRjaCcgc3RyaW5nIGlzIGxlYWRpbmcgZGlyZWN0b3J5IG9mICduYW1lJywgb3IKLSAqICgyKSB0aGUgJ21hdGNoJyBzdHJpbmcgaXMgYSB3aWxkY2FyZCBhbmQgbWF0Y2hlcyAnbmFtZScsIG9yCi0gKiAoMykgdGhlICdtYXRjaCcgc3RyaW5nIGlzIGV4YWN0bHkgdGhlIHNhbWUgYXMgJ25hbWUnLgorICogKDEpIHRoZSBwYXRoc3BlYyBzdHJpbmcgaXMgbGVhZGluZyBkaXJlY3Rvcnkgb2YgJ25hbWUnICgiUkVDVVJTSVZFTFkiKSwgb3IKKyAqICgyKSB0aGUgcGF0aHNwZWMgc3RyaW5nIGhhcyBhIGxlYWRpbmcgcGFydCBtYXRjaGluZyAnbmFtZScgKCJMRUFESU5HIiksIG9yCisgKiAoMykgdGhlIHBhdGhzcGVjIHN0cmluZyBpcyBhIHdpbGRjYXJkIGFuZCBtYXRjaGVzICduYW1lJyAoIldJTERDQVJEIiksIG9yCisgKiAoNCkgdGhlIHBhdGhzcGVjIHN0cmluZyBpcyBleGFjdGx5IHRoZSBzYW1lIGFzICduYW1lJyAoIkVYQUNUIikuCiAgKgotICogYW5kIHRoZSByZXR1cm4gdmFsdWUgdGVsbHMgd2hpY2ggY2FzZSBpdCB3YXMuCisgKiBSZXR1cm4gdmFsdWUgdGVsbHMgd2hpY2ggY2FzZSBpdCB3YXMgKDEtNCksIG9yIDAgd2hlbiB0aGVyZSBpcyBubyBtYXRjaC4KICAqCi0gKiBJdCByZXR1cm5zIDAgd2hlbiB0aGVyZSBpcyBubyBtYXRjaC4KKyAqIEl0IG1heSBiZSBpbnN0cnVjdGl2ZSB0byBsb29rIGF0IGEgc21hbGwgdGFibGUgb2YgY29uY3JldGUgZXhhbXBsZXMKKyAqIHRvIHVuZGVyc3RhbmQgdGhlIGRpZmZlcmVuY2VzIGJldHdlZW4gMSwgMiwgYW5kIDQ6CisgKgorICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICBQYXRoc3BlY3MKKyAqICAgICAgICAgICAgICAgIHwgICAgYS9iICAgIHwgICBhL2IvICAgIHwgICBhL2IvYworICogICAgICAgICAgLS0tLS0tKy0tLS0tLS0tLS0tKy0tLS0tLS0tLS0tKy0tLS0tLS0tLS0tLQorICogICAgICAgICAgYS9iICAgfCAgRVhBQ1QgICAgfCAgRVhBQ1RbMV0gfCBMRUFESU5HWzJdCisgKiAgTmFtZXMgICBhL2IvICB8IFJFQ1VSU0lWRSB8ICAgRVhBQ1QgICB8IExFQURJTkdbMl0KKyAqICAgICAgICAgIGEvYi9jIHwgUkVDVVJTSVZFIHwgUkVDVVJTSVZFIHwgICBFWEFDVAorICoKKyAqIFsxXSBPbmx5IGlmIERPX01BVENIX0RJUkVDVE9SWSBpcyBwYXNzZWQ7IG90aGVyd2lzZSwgdGhpcyBpcyBOT1QgYSBtYXRjaC4KKyAqIFsyXSBPbmx5IGlmIERPX01BVENIX0xFQURJTkdfUEFUSFNQRUMgaXMgcGFzc2VkOyBvdGhlcndpc2UsIG5vdCBhIG1hdGNoLgogICovCiBzdGF0aWMgaW50IG1hdGNoX3BhdGhzcGVjX2l0ZW0oY29uc3Qgc3RydWN0IGluZGV4X3N0YXRlICppc3RhdGUsCiAJCQkgICAgICAgY29uc3Qgc3RydWN0IHBhdGhzcGVjX2l0ZW0gKml0ZW0sIGludCBwcmVmaXgsCkBAIC0zNTMsMTMgKzM2NCwxNCBAQAogCQkJIGl0ZW0tPm5vd2lsZGNhcmRfbGVuIC0gcHJlZml4KSkKIAkJcmV0dXJuIE1BVENIRURfRk5NQVRDSDsKIAotCS8qIFBlcmZvcm0gY2hlY2tzIHRvIHNlZSBpZiAibmFtZSIgaXMgYSBzdXBlciBzZXQgb2YgdGhlIHBhdGhzcGVjICovCi0JaWYgKGZsYWdzICYgRE9fTUFUQ0hfU1VCTU9EVUxFKSB7CisJLyogUGVyZm9ybSBjaGVja3MgdG8gc2VlIGlmICJuYW1lIiBpcyBhIGxlYWRpbmcgc3RyaW5nIG9mIHRoZSBwYXRoc3BlYyAqLworCWlmIChmbGFncyAmIERPX01BVENIX0xFQURJTkdfUEFUSFNQRUMpIHsKIAkJLyogbmFtZSBpcyBhIGxpdGVyYWwgcHJlZml4IG9mIHRoZSBwYXRoc3BlYyAqLworCQlpbnQgb2Zmc2V0ID0gbmFtZVtuYW1lbGVuLTFdID09ICcvJyA/IDEgOiAwOwogCQlpZiAoKG5hbWVsZW4gPCBtYXRjaGxlbikgJiYKLQkJICAgIChtYXRjaFtuYW1lbGVuXSA9PSAnLycpICYmCisJCSAgICAobWF0Y2hbbmFtZWxlbi1vZmZzZXRdID09ICcvJykgJiYKIAkJICAgICFwc19zdHJuY21wKGl0ZW0sIG1hdGNoLCBuYW1lLCBuYW1lbGVuKSkKLQkJCXJldHVybiBNQVRDSEVEX1JFQ1VSU0lWRUxZOworCQkJcmV0dXJuIE1BVENIRURfUkVDVVJTSVZFTFlfTEVBRElOR19QQVRIU1BFQzsKIAogCQkvKiBuYW1lIiBkb2Vzbid0IG1hdGNoIHVwIHRvIHRoZSBmaXJzdCB3aWxkIGNoYXJhY3RlciAqLwogCQlpZiAoaXRlbS0+bm93aWxkY2FyZF9sZW4gPCBpdGVtLT5sZW4gJiYKQEAgLTM3Niw3ICszODgsNyBAQAogCQkgKiBUaGUgc3VibW9kdWxlcyB0aGVtc2VsdmVzIHdpbGwgYmUgYWJsZSB0byBwZXJmb3JtIG1vcmUKIAkJICogYWNjdXJhdGUgbWF0Y2hpbmcgdG8gZGV0ZXJtaW5lIGlmIHRoZSBwYXRoc3BlYyBtYXRjaGVzLgogCQkgKi8KLQkJcmV0dXJuIE1BVENIRURfUkVDVVJTSVZFTFk7CisJCXJldHVybiBNQVRDSEVEX1JFQ1VSU0lWRUxZX0xFQURJTkdfUEFUSFNQRUM7CiAJfQogCiAJcmV0dXJuIDA7CkBAIC00OTcsNyArNTA5LDcgQEAKIAkJCQkJc3RybGVuKHN1Ym1vZHVsZV9uYW1lKSwKIAkJCQkJMCwgc2VlbiwKIAkJCQkJRE9fTUFUQ0hfRElSRUNUT1JZIHwKLQkJCQkJRE9fTUFUQ0hfU1VCTU9EVUxFKTsKKwkJCQkJRE9fTUFUQ0hfTEVBRElOR19QQVRIU1BFQyk7CiAJcmV0dXJuIG1hdGNoZWQ7CiB9CiAKQEAgLTU2MSw3ICs1NzMsNyBAQAogCXJldHVybiBzdHJpbmdbc2ltcGxlX2xlbmd0aChzdHJpbmcpXSA9PSAnXDAnOwogfQogCi12b2lkIHBhcnNlX2V4Y2x1ZGVfcGF0dGVybihjb25zdCBjaGFyICoqcGF0dGVybiwKK3ZvaWQgcGFyc2VfcGF0aF9wYXR0ZXJuKGNvbnN0IGNoYXIgKipwYXR0ZXJuLAogCQkJICAgaW50ICpwYXR0ZXJubGVuLAogCQkJICAgdW5zaWduZWQgKmZsYWdzLAogCQkJICAgaW50ICpub3dpbGRjYXJkbGVuKQpAQCAtNTcxLDIwICs1ODMsMjAgQEAKIAogCSpmbGFncyA9IDA7CiAJaWYgKCpwID09ICchJykgewotCQkqZmxhZ3MgfD0gRVhDX0ZMQUdfTkVHQVRJVkU7CisJCSpmbGFncyB8PSBQQVRURVJOX0ZMQUdfTkVHQVRJVkU7CiAJCXArKzsKIAl9CiAJbGVuID0gc3RybGVuKHApOwogCWlmIChsZW4gJiYgcFtsZW4gLSAxXSA9PSAnLycpIHsKIAkJbGVuLS07Ci0JCSpmbGFncyB8PSBFWENfRkxBR19NVVNUQkVESVI7CisJCSpmbGFncyB8PSBQQVRURVJOX0ZMQUdfTVVTVEJFRElSOwogCX0KIAlmb3IgKGkgPSAwOyBpIDwgbGVuOyBpKyspIHsKIAkJaWYgKHBbaV0gPT0gJy8nKQogCQkJYnJlYWs7CiAJfQogCWlmIChpID09IGxlbikKLQkJKmZsYWdzIHw9IEVYQ19GTEFHX05PRElSOworCQkqZmxhZ3MgfD0gUEFUVEVSTl9GTEFHX05PRElSOwogCSpub3dpbGRjYXJkbGVuID0gc2ltcGxlX2xlbmd0aChwKTsKIAkvKgogCSAqIHdlIHNob3VsZCBoYXZlIGV4Y2x1ZGVkIHRoZSB0cmFpbGluZyBzbGFzaCBmcm9tICdwJyB0b28sCkBAIC01OTQsMzUgKzYwNiwzNSBAQAogCWlmICgqbm93aWxkY2FyZGxlbiA+IGxlbikKIAkJKm5vd2lsZGNhcmRsZW4gPSBsZW47CiAJaWYgKCpwID09ICcqJyAmJiBub193aWxkY2FyZChwICsgMSkpCi0JCSpmbGFncyB8PSBFWENfRkxBR19FTkRTV0lUSDsKKwkJKmZsYWdzIHw9IFBBVFRFUk5fRkxBR19FTkRTV0lUSDsKIAkqcGF0dGVybiA9IHA7CiAJKnBhdHRlcm5sZW4gPSBsZW47CiB9CiAKLXZvaWQgYWRkX2V4Y2x1ZGUoY29uc3QgY2hhciAqc3RyaW5nLCBjb25zdCBjaGFyICpiYXNlLAotCQkgaW50IGJhc2VsZW4sIHN0cnVjdCBleGNsdWRlX2xpc3QgKmVsLCBpbnQgc3JjcG9zKQordm9pZCBhZGRfcGF0dGVybihjb25zdCBjaGFyICpzdHJpbmcsIGNvbnN0IGNoYXIgKmJhc2UsCisJCSBpbnQgYmFzZWxlbiwgc3RydWN0IHBhdHRlcm5fbGlzdCAqcGwsIGludCBzcmNwb3MpCiB7Ci0Jc3RydWN0IGV4Y2x1ZGUgKng7CisJc3RydWN0IHBhdGhfcGF0dGVybiAqcGF0dGVybjsKIAlpbnQgcGF0dGVybmxlbjsKIAl1bnNpZ25lZCBmbGFnczsKIAlpbnQgbm93aWxkY2FyZGxlbjsKIAotCXBhcnNlX2V4Y2x1ZGVfcGF0dGVybigmc3RyaW5nLCAmcGF0dGVybmxlbiwgJmZsYWdzLCAmbm93aWxkY2FyZGxlbik7Ci0JaWYgKGZsYWdzICYgRVhDX0ZMQUdfTVVTVEJFRElSKSB7Ci0JCUZMRVhQVFJfQUxMT0NfTUVNKHgsIHBhdHRlcm4sIHN0cmluZywgcGF0dGVybmxlbik7CisJcGFyc2VfcGF0aF9wYXR0ZXJuKCZzdHJpbmcsICZwYXR0ZXJubGVuLCAmZmxhZ3MsICZub3dpbGRjYXJkbGVuKTsKKwlpZiAoZmxhZ3MgJiBQQVRURVJOX0ZMQUdfTVVTVEJFRElSKSB7CisJCUZMRVhQVFJfQUxMT0NfTUVNKHBhdHRlcm4sIHBhdHRlcm4sIHN0cmluZywgcGF0dGVybmxlbik7CiAJfSBlbHNlIHsKLQkJeCA9IHhtYWxsb2Moc2l6ZW9mKCp4KSk7Ci0JCXgtPnBhdHRlcm4gPSBzdHJpbmc7CisJCXBhdHRlcm4gPSB4bWFsbG9jKHNpemVvZigqcGF0dGVybikpOworCQlwYXR0ZXJuLT5wYXR0ZXJuID0gc3RyaW5nOwogCX0KLQl4LT5wYXR0ZXJubGVuID0gcGF0dGVybmxlbjsKLQl4LT5ub3dpbGRjYXJkbGVuID0gbm93aWxkY2FyZGxlbjsKLQl4LT5iYXNlID0gYmFzZTsKLQl4LT5iYXNlbGVuID0gYmFzZWxlbjsKLQl4LT5mbGFncyA9IGZsYWdzOwotCXgtPnNyY3BvcyA9IHNyY3BvczsKLQlBTExPQ19HUk9XKGVsLT5leGNsdWRlcywgZWwtPm5yICsgMSwgZWwtPmFsbG9jKTsKLQllbC0+ZXhjbHVkZXNbZWwtPm5yKytdID0geDsKLQl4LT5lbCA9IGVsOworCXBhdHRlcm4tPnBhdHRlcm5sZW4gPSBwYXR0ZXJubGVuOworCXBhdHRlcm4tPm5vd2lsZGNhcmRsZW4gPSBub3dpbGRjYXJkbGVuOworCXBhdHRlcm4tPmJhc2UgPSBiYXNlOworCXBhdHRlcm4tPmJhc2VsZW4gPSBiYXNlbGVuOworCXBhdHRlcm4tPmZsYWdzID0gZmxhZ3M7CisJcGF0dGVybi0+c3JjcG9zID0gc3JjcG9zOworCUFMTE9DX0dST1cocGwtPnBhdHRlcm5zLCBwbC0+bnIgKyAxLCBwbC0+YWxsb2MpOworCXBsLT5wYXR0ZXJuc1twbC0+bnIrK10gPSBwYXR0ZXJuOworCXBhdHRlcm4tPnBsID0gcGw7CiB9CiAKIHN0YXRpYyBpbnQgcmVhZF9za2lwX3dvcmt0cmVlX2ZpbGVfZnJvbV9pbmRleChjb25zdCBzdHJ1Y3QgaW5kZXhfc3RhdGUgKmlzdGF0ZSwKQEAgLTY0MywxOSArNjU1LDE5IEBACiB9CiAKIC8qCi0gKiBGcmVlcyBtZW1vcnkgd2l0aGluIGVsIHdoaWNoIHdhcyBhbGxvY2F0ZWQgZm9yIGV4Y2x1ZGUgcGF0dGVybnMgYW5kCi0gKiB0aGUgZmlsZSBidWZmZXIuICBEb2VzIG5vdCBmcmVlIGVsIGl0c2VsZi4KKyAqIEZyZWVzIG1lbW9yeSB3aXRoaW4gcGwgd2hpY2ggd2FzIGFsbG9jYXRlZCBmb3IgZXhjbHVkZSBwYXR0ZXJucyBhbmQKKyAqIHRoZSBmaWxlIGJ1ZmZlci4gIERvZXMgbm90IGZyZWUgcGwgaXRzZWxmLgogICovCi12b2lkIGNsZWFyX2V4Y2x1ZGVfbGlzdChzdHJ1Y3QgZXhjbHVkZV9saXN0ICplbCkKK3ZvaWQgY2xlYXJfcGF0dGVybl9saXN0KHN0cnVjdCBwYXR0ZXJuX2xpc3QgKnBsKQogewogCWludCBpOwogCi0JZm9yIChpID0gMDsgaSA8IGVsLT5ucjsgaSsrKQotCQlmcmVlKGVsLT5leGNsdWRlc1tpXSk7Ci0JZnJlZShlbC0+ZXhjbHVkZXMpOwotCWZyZWUoZWwtPmZpbGVidWYpOworCWZvciAoaSA9IDA7IGkgPCBwbC0+bnI7IGkrKykKKwkJZnJlZShwbC0+cGF0dGVybnNbaV0pOworCWZyZWUocGwtPnBhdHRlcm5zKTsKKwlmcmVlKHBsLT5maWxlYnVmKTsKIAotCW1lbXNldChlbCwgMCwgc2l6ZW9mKCplbCkpOworCW1lbXNldChwbCwgMCwgc2l6ZW9mKCpwbCkpOwogfQogCiBzdGF0aWMgdm9pZCB0cmltX3RyYWlsaW5nX3NwYWNlcyhjaGFyICpidWYpCkBAIC03NjIsMjEgKzc3NCwyMSBAQAogCQlkaXItPmRpcnNbaV0tPnJlY3Vyc2UgPSAwOwogfQogCi1zdGF0aWMgaW50IGFkZF9leGNsdWRlc19mcm9tX2J1ZmZlcihjaGFyICpidWYsIHNpemVfdCBzaXplLAorc3RhdGljIGludCBhZGRfcGF0dGVybnNfZnJvbV9idWZmZXIoY2hhciAqYnVmLCBzaXplX3Qgc2l6ZSwKIAkJCQkgICAgY29uc3QgY2hhciAqYmFzZSwgaW50IGJhc2VsZW4sCi0JCQkJICAgIHN0cnVjdCBleGNsdWRlX2xpc3QgKmVsKTsKKwkJCQkgICAgc3RydWN0IHBhdHRlcm5fbGlzdCAqcGwpOwogCiAvKgogICogR2l2ZW4gYSBmaWxlIHdpdGggbmFtZSAiZm5hbWUiLCByZWFkIGl0IChlaXRoZXIgZnJvbSBkaXNrLCBvciBmcm9tCiAgKiBhbiBpbmRleCBpZiAnaXN0YXRlJyBpcyBub24tbnVsbCksIHBhcnNlIGl0IGFuZCBzdG9yZSB0aGUKLSAqIGV4Y2x1ZGUgcnVsZXMgaW4gImVsIi4KKyAqIGV4Y2x1ZGUgcnVsZXMgaW4gInBsIi4KICAqCiAgKiBJZiAic3MiIGlzIG5vdCBOVUxMLCBjb21wdXRlIFNIQS0xIG9mIHRoZSBleGNsdWRlIGZpbGUgYW5kIGZpbGwKLSAqIHN0YXQgZGF0YSBmcm9tIGRpc2sgKG9ubHkgdmFsaWQgaWYgYWRkX2V4Y2x1ZGVzIHJldHVybnMgemVybykuIElmCisgKiBzdGF0IGRhdGEgZnJvbSBkaXNrIChvbmx5IHZhbGlkIGlmIGFkZF9wYXR0ZXJucyByZXR1cm5zIHplcm8pLiBJZgogICogc3NfdmFsaWQgaXMgbm9uLXplcm8sICJzcyIgbXVzdCBjb250YWluIGdvb2QgdmFsdWUgYXMgaW5wdXQuCiAgKi8KLXN0YXRpYyBpbnQgYWRkX2V4Y2x1ZGVzKGNvbnN0IGNoYXIgKmZuYW1lLCBjb25zdCBjaGFyICpiYXNlLCBpbnQgYmFzZWxlbiwKLQkJCXN0cnVjdCBleGNsdWRlX2xpc3QgKmVsLCBzdHJ1Y3QgaW5kZXhfc3RhdGUgKmlzdGF0ZSwKK3N0YXRpYyBpbnQgYWRkX3BhdHRlcm5zKGNvbnN0IGNoYXIgKmZuYW1lLCBjb25zdCBjaGFyICpiYXNlLCBpbnQgYmFzZWxlbiwKKwkJCXN0cnVjdCBwYXR0ZXJuX2xpc3QgKnBsLCBzdHJ1Y3QgaW5kZXhfc3RhdGUgKmlzdGF0ZSwKIAkJCXN0cnVjdCBvaWRfc3RhdCAqb2lkX3N0YXQpCiB7CiAJc3RydWN0IHN0YXQgc3Q7CkBAIC04MzcsMjEgKzg0OSwyMSBAQAogCQl9CiAJfQogCi0JYWRkX2V4Y2x1ZGVzX2Zyb21fYnVmZmVyKGJ1Ziwgc2l6ZSwgYmFzZSwgYmFzZWxlbiwgZWwpOworCWFkZF9wYXR0ZXJuc19mcm9tX2J1ZmZlcihidWYsIHNpemUsIGJhc2UsIGJhc2VsZW4sIHBsKTsKIAlyZXR1cm4gMDsKIH0KIAotc3RhdGljIGludCBhZGRfZXhjbHVkZXNfZnJvbV9idWZmZXIoY2hhciAqYnVmLCBzaXplX3Qgc2l6ZSwKK3N0YXRpYyBpbnQgYWRkX3BhdHRlcm5zX2Zyb21fYnVmZmVyKGNoYXIgKmJ1Ziwgc2l6ZV90IHNpemUsCiAJCQkJICAgIGNvbnN0IGNoYXIgKmJhc2UsIGludCBiYXNlbGVuLAotCQkJCSAgICBzdHJ1Y3QgZXhjbHVkZV9saXN0ICplbCkKKwkJCQkgICAgc3RydWN0IHBhdHRlcm5fbGlzdCAqcGwpCiB7CiAJaW50IGksIGxpbmVubyA9IDE7CiAJY2hhciAqZW50cnk7CiAKLQllbC0+ZmlsZWJ1ZiA9IGJ1ZjsKKwlwbC0+ZmlsZWJ1ZiA9IGJ1ZjsKIAogCWlmIChza2lwX3V0ZjhfYm9tKCZidWYsIHNpemUpKQotCQlzaXplIC09IGJ1ZiAtIGVsLT5maWxlYnVmOworCQlzaXplIC09IGJ1ZiAtIHBsLT5maWxlYnVmOwogCiAJZW50cnkgPSBidWY7CiAKQEAgLTg2MCw3ICs4NzIsNyBAQAogCQkJaWYgKGVudHJ5ICE9IGJ1ZiArIGkgJiYgZW50cnlbMF0gIT0gJyMnKSB7CiAJCQkJYnVmW2kgLSAoaSAmJiBidWZbaS0xXSA9PSAnXHInKV0gPSAwOwogCQkJCXRyaW1fdHJhaWxpbmdfc3BhY2VzKGVudHJ5KTsKLQkJCQlhZGRfZXhjbHVkZShlbnRyeSwgYmFzZSwgYmFzZWxlbiwgZWwsIGxpbmVubyk7CisJCQkJYWRkX3BhdHRlcm4oZW50cnksIGJhc2UsIGJhc2VsZW4sIHBsLCBsaW5lbm8pOwogCQkJfQogCQkJbGluZW5vKys7CiAJCQllbnRyeSA9IGJ1ZiArIGkgKyAxOwpAQCAtODY5LDE3ICs4ODEsMTcgQEAKIAlyZXR1cm4gMDsKIH0KIAotaW50IGFkZF9leGNsdWRlc19mcm9tX2ZpbGVfdG9fbGlzdChjb25zdCBjaGFyICpmbmFtZSwgY29uc3QgY2hhciAqYmFzZSwKLQkJCQkgICBpbnQgYmFzZWxlbiwgc3RydWN0IGV4Y2x1ZGVfbGlzdCAqZWwsCitpbnQgYWRkX3BhdHRlcm5zX2Zyb21fZmlsZV90b19saXN0KGNvbnN0IGNoYXIgKmZuYW1lLCBjb25zdCBjaGFyICpiYXNlLAorCQkJCSAgIGludCBiYXNlbGVuLCBzdHJ1Y3QgcGF0dGVybl9saXN0ICpwbCwKIAkJCQkgICBzdHJ1Y3QgaW5kZXhfc3RhdGUgKmlzdGF0ZSkKIHsKLQlyZXR1cm4gYWRkX2V4Y2x1ZGVzKGZuYW1lLCBiYXNlLCBiYXNlbGVuLCBlbCwgaXN0YXRlLCBOVUxMKTsKKwlyZXR1cm4gYWRkX3BhdHRlcm5zKGZuYW1lLCBiYXNlLCBiYXNlbGVuLCBwbCwgaXN0YXRlLCBOVUxMKTsKIH0KIAotaW50IGFkZF9leGNsdWRlc19mcm9tX2Jsb2JfdG9fbGlzdCgKK2ludCBhZGRfcGF0dGVybnNfZnJvbV9ibG9iX3RvX2xpc3QoCiAJc3RydWN0IG9iamVjdF9pZCAqb2lkLAogCWNvbnN0IGNoYXIgKmJhc2UsIGludCBiYXNlbGVuLAotCXN0cnVjdCBleGNsdWRlX2xpc3QgKmVsKQorCXN0cnVjdCBwYXR0ZXJuX2xpc3QgKnBsKQogewogCWNoYXIgKmJ1ZjsKIAlzaXplX3Qgc2l6ZTsKQEAgLTg4OSwzMSArOTAxLDMxIEBACiAJaWYgKHIgIT0gMSkKIAkJcmV0dXJuIHI7CiAKLQlhZGRfZXhjbHVkZXNfZnJvbV9idWZmZXIoYnVmLCBzaXplLCBiYXNlLCBiYXNlbGVuLCBlbCk7CisJYWRkX3BhdHRlcm5zX2Zyb21fYnVmZmVyKGJ1Ziwgc2l6ZSwgYmFzZSwgYmFzZWxlbiwgcGwpOwogCXJldHVybiAwOwogfQogCi1zdHJ1Y3QgZXhjbHVkZV9saXN0ICphZGRfZXhjbHVkZV9saXN0KHN0cnVjdCBkaXJfc3RydWN0ICpkaXIsCitzdHJ1Y3QgcGF0dGVybl9saXN0ICphZGRfcGF0dGVybl9saXN0KHN0cnVjdCBkaXJfc3RydWN0ICpkaXIsCiAJCQkJICAgICAgaW50IGdyb3VwX3R5cGUsIGNvbnN0IGNoYXIgKnNyYykKIHsKLQlzdHJ1Y3QgZXhjbHVkZV9saXN0ICplbDsKKwlzdHJ1Y3QgcGF0dGVybl9saXN0ICpwbDsKIAlzdHJ1Y3QgZXhjbHVkZV9saXN0X2dyb3VwICpncm91cDsKIAogCWdyb3VwID0gJmRpci0+ZXhjbHVkZV9saXN0X2dyb3VwW2dyb3VwX3R5cGVdOwotCUFMTE9DX0dST1coZ3JvdXAtPmVsLCBncm91cC0+bnIgKyAxLCBncm91cC0+YWxsb2MpOwotCWVsID0gJmdyb3VwLT5lbFtncm91cC0+bnIrK107Ci0JbWVtc2V0KGVsLCAwLCBzaXplb2YoKmVsKSk7Ci0JZWwtPnNyYyA9IHNyYzsKLQlyZXR1cm4gZWw7CisJQUxMT0NfR1JPVyhncm91cC0+cGwsIGdyb3VwLT5uciArIDEsIGdyb3VwLT5hbGxvYyk7CisJcGwgPSAmZ3JvdXAtPnBsW2dyb3VwLT5ucisrXTsKKwltZW1zZXQocGwsIDAsIHNpemVvZigqcGwpKTsKKwlwbC0+c3JjID0gc3JjOworCXJldHVybiBwbDsKIH0KIAogLyoKICAqIFVzZWQgdG8gc2V0IHVwIGNvcmUuZXhjbHVkZXNmaWxlIGFuZCAuZ2l0L2luZm8vZXhjbHVkZSBsaXN0cy4KICAqLwotc3RhdGljIHZvaWQgYWRkX2V4Y2x1ZGVzX2Zyb21fZmlsZV8xKHN0cnVjdCBkaXJfc3RydWN0ICpkaXIsIGNvbnN0IGNoYXIgKmZuYW1lLAorc3RhdGljIHZvaWQgYWRkX3BhdHRlcm5zX2Zyb21fZmlsZV8xKHN0cnVjdCBkaXJfc3RydWN0ICpkaXIsIGNvbnN0IGNoYXIgKmZuYW1lLAogCQkJCSAgICAgc3RydWN0IG9pZF9zdGF0ICpvaWRfc3RhdCkKIHsKLQlzdHJ1Y3QgZXhjbHVkZV9saXN0ICplbDsKKwlzdHJ1Y3QgcGF0dGVybl9saXN0ICpwbDsKIAkvKgogCSAqIGNhdGNoIHNldHVwX3N0YW5kYXJkX2V4Y2x1ZGVzKCkgdGhhdCdzIGNhbGxlZCBiZWZvcmUKIAkgKiBkaXItPnVudHJhY2tlZCBpcyBhc3NpZ25lZC4gVGhhdCBmdW5jdGlvbiBiZWhhdmVzCkBAIC05MjEsMTUgKzkzMywxNSBAQAogCSAqLwogCWlmICghZGlyLT51bnRyYWNrZWQpCiAJCWRpci0+dW5tYW5hZ2VkX2V4Y2x1ZGVfZmlsZXMrKzsKLQllbCA9IGFkZF9leGNsdWRlX2xpc3QoZGlyLCBFWENfRklMRSwgZm5hbWUpOwotCWlmIChhZGRfZXhjbHVkZXMoZm5hbWUsICIiLCAwLCBlbCwgTlVMTCwgb2lkX3N0YXQpIDwgMCkKKwlwbCA9IGFkZF9wYXR0ZXJuX2xpc3QoZGlyLCBFWENfRklMRSwgZm5hbWUpOworCWlmIChhZGRfcGF0dGVybnMoZm5hbWUsICIiLCAwLCBwbCwgTlVMTCwgb2lkX3N0YXQpIDwgMCkKIAkJZGllKF8oImNhbm5vdCB1c2UgJXMgYXMgYW4gZXhjbHVkZSBmaWxlIiksIGZuYW1lKTsKIH0KIAotdm9pZCBhZGRfZXhjbHVkZXNfZnJvbV9maWxlKHN0cnVjdCBkaXJfc3RydWN0ICpkaXIsIGNvbnN0IGNoYXIgKmZuYW1lKQordm9pZCBhZGRfcGF0dGVybnNfZnJvbV9maWxlKHN0cnVjdCBkaXJfc3RydWN0ICpkaXIsIGNvbnN0IGNoYXIgKmZuYW1lKQogewogCWRpci0+dW5tYW5hZ2VkX2V4Y2x1ZGVfZmlsZXMrKzsgLyogc2VlIHZhbGlkYXRlX3VudHJhY2tlZF9jYWNoZSgpICovCi0JYWRkX2V4Y2x1ZGVzX2Zyb21fZmlsZV8xKGRpciwgZm5hbWUsIE5VTEwpOworCWFkZF9wYXR0ZXJuc19mcm9tX2ZpbGVfMShkaXIsIGZuYW1lLCBOVUxMKTsKIH0KIAogaW50IG1hdGNoX2Jhc2VuYW1lKGNvbnN0IGNoYXIgKmJhc2VuYW1lLCBpbnQgYmFzZW5hbWVsZW4sCkBAIC05NDAsNyArOTUyLDcgQEAKIAkJaWYgKHBhdHRlcm5sZW4gPT0gYmFzZW5hbWVsZW4gJiYKIAkJICAgICFmc3BhdGhuY21wKHBhdHRlcm4sIGJhc2VuYW1lLCBiYXNlbmFtZWxlbikpCiAJCQlyZXR1cm4gMTsKLQl9IGVsc2UgaWYgKGZsYWdzICYgRVhDX0ZMQUdfRU5EU1dJVEgpIHsKKwl9IGVsc2UgaWYgKGZsYWdzICYgUEFUVEVSTl9GTEFHX0VORFNXSVRIKSB7CiAJCS8qICIqbGl0ZXJhbCIgbWF0Y2hpbmcgYWdhaW5zdCAiZm9vbGl0ZXJhbCIgKi8KIAkJaWYgKHBhdHRlcm5sZW4gLSAxIDw9IGJhc2VuYW1lbGVuICYmCiAJCSAgICAhZnNwYXRobmNtcChwYXR0ZXJuICsgMSwKQEAgLTEwMjEsODUgKzEwMzMsOTcgQEAKICAqIGFueSwgZGV0ZXJtaW5lcyB0aGUgZmF0ZS4gIFJldHVybnMgdGhlIGV4Y2x1ZGVfbGlzdCBlbGVtZW50IHdoaWNoCiAgKiBtYXRjaGVkLCBvciBOVUxMIGZvciB1bmRlY2lkZWQuCiAgKi8KLXN0YXRpYyBzdHJ1Y3QgZXhjbHVkZSAqbGFzdF9leGNsdWRlX21hdGNoaW5nX2Zyb21fbGlzdChjb25zdCBjaGFyICpwYXRobmFtZSwKK3N0YXRpYyBzdHJ1Y3QgcGF0aF9wYXR0ZXJuICpsYXN0X21hdGNoaW5nX3BhdHRlcm5fZnJvbV9saXN0KGNvbnN0IGNoYXIgKnBhdGhuYW1lLAogCQkJCQkJICAgICAgIGludCBwYXRobGVuLAogCQkJCQkJICAgICAgIGNvbnN0IGNoYXIgKmJhc2VuYW1lLAogCQkJCQkJICAgICAgIGludCAqZHR5cGUsCi0JCQkJCQkgICAgICAgc3RydWN0IGV4Y2x1ZGVfbGlzdCAqZWwsCisJCQkJCQkgICAgICAgc3RydWN0IHBhdHRlcm5fbGlzdCAqcGwsCiAJCQkJCQkgICAgICAgc3RydWN0IGluZGV4X3N0YXRlICppc3RhdGUpCiB7Ci0Jc3RydWN0IGV4Y2x1ZGUgKmV4YyA9IE5VTEw7IC8qIHVuZGVjaWRlZCAqLworCXN0cnVjdCBwYXRoX3BhdHRlcm4gKnJlcyA9IE5VTEw7IC8qIHVuZGVjaWRlZCAqLwogCWludCBpOwogCi0JaWYgKCFlbC0+bnIpCisJaWYgKCFwbC0+bnIpCiAJCXJldHVybiBOVUxMOwkvKiB1bmRlZmluZWQgKi8KIAotCWZvciAoaSA9IGVsLT5uciAtIDE7IDAgPD0gaTsgaS0tKSB7Ci0JCXN0cnVjdCBleGNsdWRlICp4ID0gZWwtPmV4Y2x1ZGVzW2ldOwotCQljb25zdCBjaGFyICpleGNsdWRlID0geC0+cGF0dGVybjsKLQkJaW50IHByZWZpeCA9IHgtPm5vd2lsZGNhcmRsZW47CisJZm9yIChpID0gcGwtPm5yIC0gMTsgMCA8PSBpOyBpLS0pIHsKKwkJc3RydWN0IHBhdGhfcGF0dGVybiAqcGF0dGVybiA9IHBsLT5wYXR0ZXJuc1tpXTsKKwkJY29uc3QgY2hhciAqZXhjbHVkZSA9IHBhdHRlcm4tPnBhdHRlcm47CisJCWludCBwcmVmaXggPSBwYXR0ZXJuLT5ub3dpbGRjYXJkbGVuOwogCi0JCWlmICh4LT5mbGFncyAmIEVYQ19GTEFHX01VU1RCRURJUikgeworCQlpZiAocGF0dGVybi0+ZmxhZ3MgJiBQQVRURVJOX0ZMQUdfTVVTVEJFRElSKSB7CiAJCQlpZiAoKmR0eXBlID09IERUX1VOS05PV04pCiAJCQkJKmR0eXBlID0gZ2V0X2R0eXBlKE5VTEwsIGlzdGF0ZSwgcGF0aG5hbWUsIHBhdGhsZW4pOwogCQkJaWYgKCpkdHlwZSAhPSBEVF9ESVIpCiAJCQkJY29udGludWU7CiAJCX0KIAotCQlpZiAoeC0+ZmxhZ3MgJiBFWENfRkxBR19OT0RJUikgeworCQlpZiAocGF0dGVybi0+ZmxhZ3MgJiBQQVRURVJOX0ZMQUdfTk9ESVIpIHsKIAkJCWlmIChtYXRjaF9iYXNlbmFtZShiYXNlbmFtZSwKIAkJCQkJICAgcGF0aGxlbiAtIChiYXNlbmFtZSAtIHBhdGhuYW1lKSwKLQkJCQkJICAgZXhjbHVkZSwgcHJlZml4LCB4LT5wYXR0ZXJubGVuLAotCQkJCQkgICB4LT5mbGFncykpIHsKLQkJCQlleGMgPSB4OworCQkJCQkgICBleGNsdWRlLCBwcmVmaXgsIHBhdHRlcm4tPnBhdHRlcm5sZW4sCisJCQkJCSAgIHBhdHRlcm4tPmZsYWdzKSkgeworCQkJCXJlcyA9IHBhdHRlcm47CiAJCQkJYnJlYWs7CiAJCQl9CiAJCQljb250aW51ZTsKIAkJfQogCi0JCWFzc2VydCh4LT5iYXNlbGVuID09IDAgfHwgeC0+YmFzZVt4LT5iYXNlbGVuIC0gMV0gPT0gJy8nKTsKKwkJYXNzZXJ0KHBhdHRlcm4tPmJhc2VsZW4gPT0gMCB8fAorCQkgICAgICAgcGF0dGVybi0+YmFzZVtwYXR0ZXJuLT5iYXNlbGVuIC0gMV0gPT0gJy8nKTsKIAkJaWYgKG1hdGNoX3BhdGhuYW1lKHBhdGhuYW1lLCBwYXRobGVuLAotCQkJCSAgIHgtPmJhc2UsIHgtPmJhc2VsZW4gPyB4LT5iYXNlbGVuIC0gMSA6IDAsCi0JCQkJICAgZXhjbHVkZSwgcHJlZml4LCB4LT5wYXR0ZXJubGVuLCB4LT5mbGFncykpIHsKLQkJCWV4YyA9IHg7CisJCQkJICAgcGF0dGVybi0+YmFzZSwKKwkJCQkgICBwYXR0ZXJuLT5iYXNlbGVuID8gcGF0dGVybi0+YmFzZWxlbiAtIDEgOiAwLAorCQkJCSAgIGV4Y2x1ZGUsIHByZWZpeCwgcGF0dGVybi0+cGF0dGVybmxlbiwKKwkJCQkgICBwYXR0ZXJuLT5mbGFncykpIHsKKwkJCXJlcyA9IHBhdHRlcm47CiAJCQlicmVhazsKIAkJfQogCX0KLQlyZXR1cm4gZXhjOworCXJldHVybiByZXM7CiB9CiAKIC8qCi0gKiBTY2FuIHRoZSBsaXN0IGFuZCBsZXQgdGhlIGxhc3QgbWF0Y2ggZGV0ZXJtaW5lIHRoZSBmYXRlLgotICogUmV0dXJuIDEgZm9yIGV4Y2x1ZGUsIDAgZm9yIGluY2x1ZGUgYW5kIC0xIGZvciB1bmRlY2lkZWQuCisgKiBTY2FuIHRoZSBsaXN0IG9mIHBhdHRlcm5zIHRvIGRldGVybWluZSBpZiB0aGUgb3JkZXJlZCBsaXN0CisgKiBvZiBwYXR0ZXJucyBtYXRjaGVzIG9uICdwYXRobmFtZScuCisgKgorICogUmV0dXJuIDEgZm9yIGEgbWF0Y2gsIDAgZm9yIG5vdCBtYXRjaGVkIGFuZCAtMSBmb3IgdW5kZWNpZGVkLgogICovCi1pbnQgaXNfZXhjbHVkZWRfZnJvbV9saXN0KGNvbnN0IGNoYXIgKnBhdGhuYW1lLAotCQkJICBpbnQgcGF0aGxlbiwgY29uc3QgY2hhciAqYmFzZW5hbWUsIGludCAqZHR5cGUsCi0JCQkgIHN0cnVjdCBleGNsdWRlX2xpc3QgKmVsLCBzdHJ1Y3QgaW5kZXhfc3RhdGUgKmlzdGF0ZSkKK2VudW0gcGF0dGVybl9tYXRjaF9yZXN1bHQgcGF0aF9tYXRjaGVzX3BhdHRlcm5fbGlzdCgKKwkJCQljb25zdCBjaGFyICpwYXRobmFtZSwgaW50IHBhdGhsZW4sCisJCQkJY29uc3QgY2hhciAqYmFzZW5hbWUsIGludCAqZHR5cGUsCisJCQkJc3RydWN0IHBhdHRlcm5fbGlzdCAqcGwsCisJCQkJc3RydWN0IGluZGV4X3N0YXRlICppc3RhdGUpCiB7Ci0Jc3RydWN0IGV4Y2x1ZGUgKmV4Y2x1ZGU7Ci0JZXhjbHVkZSA9IGxhc3RfZXhjbHVkZV9tYXRjaGluZ19mcm9tX2xpc3QocGF0aG5hbWUsIHBhdGhsZW4sIGJhc2VuYW1lLAotCQkJCQkJICBkdHlwZSwgZWwsIGlzdGF0ZSk7Ci0JaWYgKGV4Y2x1ZGUpCi0JCXJldHVybiBleGNsdWRlLT5mbGFncyAmIEVYQ19GTEFHX05FR0FUSVZFID8gMCA6IDE7Ci0JcmV0dXJuIC0xOyAvKiB1bmRlY2lkZWQgKi8KKwlzdHJ1Y3QgcGF0aF9wYXR0ZXJuICpwYXR0ZXJuOworCXBhdHRlcm4gPSBsYXN0X21hdGNoaW5nX3BhdHRlcm5fZnJvbV9saXN0KHBhdGhuYW1lLCBwYXRobGVuLCBiYXNlbmFtZSwKKwkJCQkJCSAgZHR5cGUsIHBsLCBpc3RhdGUpOworCWlmIChwYXR0ZXJuKSB7CisJCWlmIChwYXR0ZXJuLT5mbGFncyAmIFBBVFRFUk5fRkxBR19ORUdBVElWRSkKKwkJCXJldHVybiBOT1RfTUFUQ0hFRDsKKwkJZWxzZQorCQkJcmV0dXJuIE1BVENIRUQ7CisJfQorCisJcmV0dXJuIFVOREVDSURFRDsKIH0KIAotc3RhdGljIHN0cnVjdCBleGNsdWRlICpsYXN0X2V4Y2x1ZGVfbWF0Y2hpbmdfZnJvbV9saXN0cyhzdHJ1Y3QgZGlyX3N0cnVjdCAqZGlyLAotCQkJCQkJCXN0cnVjdCBpbmRleF9zdGF0ZSAqaXN0YXRlLAotCQljb25zdCBjaGFyICpwYXRobmFtZSwgaW50IHBhdGhsZW4sIGNvbnN0IGNoYXIgKmJhc2VuYW1lLAotCQlpbnQgKmR0eXBlX3ApCitzdGF0aWMgc3RydWN0IHBhdGhfcGF0dGVybiAqbGFzdF9tYXRjaGluZ19wYXR0ZXJuX2Zyb21fbGlzdHMoCisJCXN0cnVjdCBkaXJfc3RydWN0ICpkaXIsIHN0cnVjdCBpbmRleF9zdGF0ZSAqaXN0YXRlLAorCQljb25zdCBjaGFyICpwYXRobmFtZSwgaW50IHBhdGhsZW4sCisJCWNvbnN0IGNoYXIgKmJhc2VuYW1lLCBpbnQgKmR0eXBlX3ApCiB7CiAJaW50IGksIGo7CiAJc3RydWN0IGV4Y2x1ZGVfbGlzdF9ncm91cCAqZ3JvdXA7Ci0Jc3RydWN0IGV4Y2x1ZGUgKmV4Y2x1ZGU7CisJc3RydWN0IHBhdGhfcGF0dGVybiAqcGF0dGVybjsKIAlmb3IgKGkgPSBFWENfQ01ETDsgaSA8PSBFWENfRklMRTsgaSsrKSB7CiAJCWdyb3VwID0gJmRpci0+ZXhjbHVkZV9saXN0X2dyb3VwW2ldOwogCQlmb3IgKGogPSBncm91cC0+bnIgLSAxOyBqID49IDA7IGotLSkgewotCQkJZXhjbHVkZSA9IGxhc3RfZXhjbHVkZV9tYXRjaGluZ19mcm9tX2xpc3QoCisJCQlwYXR0ZXJuID0gbGFzdF9tYXRjaGluZ19wYXR0ZXJuX2Zyb21fbGlzdCgKIAkJCQlwYXRobmFtZSwgcGF0aGxlbiwgYmFzZW5hbWUsIGR0eXBlX3AsCi0JCQkJJmdyb3VwLT5lbFtqXSwgaXN0YXRlKTsKLQkJCWlmIChleGNsdWRlKQotCQkJCXJldHVybiBleGNsdWRlOworCQkJCSZncm91cC0+cGxbal0sIGlzdGF0ZSk7CisJCQlpZiAocGF0dGVybikKKwkJCQlyZXR1cm4gcGF0dGVybjsKIAkJfQogCX0KIAlyZXR1cm4gTlVMTDsKQEAgLTExMTQsNyArMTEzOCw3IEBACiAJCQkgY29uc3QgY2hhciAqYmFzZSwgaW50IGJhc2VsZW4pCiB7CiAJc3RydWN0IGV4Y2x1ZGVfbGlzdF9ncm91cCAqZ3JvdXA7Ci0Jc3RydWN0IGV4Y2x1ZGVfbGlzdCAqZWw7CisJc3RydWN0IHBhdHRlcm5fbGlzdCAqcGw7CiAJc3RydWN0IGV4Y2x1ZGVfc3RhY2sgKnN0ayA9IE5VTEw7CiAJc3RydWN0IHVudHJhY2tlZF9jYWNoZV9kaXIgKnVudHJhY2tlZDsKIAlpbnQgY3VycmVudDsKQEAgLTExMzAsMTcgKzExNTQsMTcgQEAKIAkJaWYgKHN0ay0+YmFzZWxlbiA8PSBiYXNlbGVuICYmCiAJCSAgICAhc3RybmNtcChkaXItPmJhc2VidWYuYnVmLCBiYXNlLCBzdGstPmJhc2VsZW4pKQogCQkJYnJlYWs7Ci0JCWVsID0gJmdyb3VwLT5lbFtkaXItPmV4Y2x1ZGVfc3RhY2stPmV4Y2x1ZGVfaXhdOworCQlwbCA9ICZncm91cC0+cGxbZGlyLT5leGNsdWRlX3N0YWNrLT5leGNsdWRlX2l4XTsKIAkJZGlyLT5leGNsdWRlX3N0YWNrID0gc3RrLT5wcmV2OwotCQlkaXItPmV4Y2x1ZGUgPSBOVUxMOwotCQlmcmVlKChjaGFyICopZWwtPnNyYyk7IC8qIHNlZSBzdHJidWZfZGV0YWNoKCkgYmVsb3cgKi8KLQkJY2xlYXJfZXhjbHVkZV9saXN0KGVsKTsKKwkJZGlyLT5wYXR0ZXJuID0gTlVMTDsKKwkJZnJlZSgoY2hhciAqKXBsLT5zcmMpOyAvKiBzZWUgc3RyYnVmX2RldGFjaCgpIGJlbG93ICovCisJCWNsZWFyX3BhdHRlcm5fbGlzdChwbCk7CiAJCWZyZWUoc3RrKTsKIAkJZ3JvdXAtPm5yLS07CiAJfQogCiAJLyogU2tpcCB0cmF2ZXJzaW5nIGludG8gc3ViIGRpcmVjdG9yaWVzIGlmIHRoZSBwYXJlbnQgaXMgZXhjbHVkZWQgKi8KLQlpZiAoZGlyLT5leGNsdWRlKQorCWlmIChkaXItPnBhdHRlcm4pCiAJCXJldHVybjsKIAogCS8qCkBAIC0xMTgxLDcgKzEyMDUsNyBAQAogCQlzdGstPmJhc2VsZW4gPSBjcCAtIGJhc2U7CiAJCXN0ay0+ZXhjbHVkZV9peCA9IGdyb3VwLT5ucjsKIAkJc3RrLT51Y2QgPSB1bnRyYWNrZWQ7Ci0JCWVsID0gYWRkX2V4Y2x1ZGVfbGlzdChkaXIsIEVYQ19ESVJTLCBOVUxMKTsKKwkJcGwgPSBhZGRfcGF0dGVybl9saXN0KGRpciwgRVhDX0RJUlMsIE5VTEwpOwogCQlzdHJidWZfYWRkKCZkaXItPmJhc2VidWYsIGJhc2UgKyBjdXJyZW50LCBzdGstPmJhc2VsZW4gLSBjdXJyZW50KTsKIAkJYXNzZXJ0KHN0ay0+YmFzZWxlbiA9PSBkaXItPmJhc2VidWYubGVuKTsKIApAQCAtMTE4OSwxNSArMTIxMywxNSBAQAogCQlpZiAoc3RrLT5iYXNlbGVuKSB7CiAJCQlpbnQgZHQgPSBEVF9ESVI7CiAJCQlkaXItPmJhc2VidWYuYnVmW3N0ay0+YmFzZWxlbiAtIDFdID0gMDsKLQkJCWRpci0+ZXhjbHVkZSA9IGxhc3RfZXhjbHVkZV9tYXRjaGluZ19mcm9tX2xpc3RzKGRpciwKKwkJCWRpci0+cGF0dGVybiA9IGxhc3RfbWF0Y2hpbmdfcGF0dGVybl9mcm9tX2xpc3RzKGRpciwKIAkJCQkJCQkJCWlzdGF0ZSwKIAkJCQlkaXItPmJhc2VidWYuYnVmLCBzdGstPmJhc2VsZW4gLSAxLAogCQkJCWRpci0+YmFzZWJ1Zi5idWYgKyBjdXJyZW50LCAmZHQpOwogCQkJZGlyLT5iYXNlYnVmLmJ1ZltzdGstPmJhc2VsZW4gLSAxXSA9ICcvJzsKLQkJCWlmIChkaXItPmV4Y2x1ZGUgJiYKLQkJCSAgICBkaXItPmV4Y2x1ZGUtPmZsYWdzICYgRVhDX0ZMQUdfTkVHQVRJVkUpCi0JCQkJZGlyLT5leGNsdWRlID0gTlVMTDsKLQkJCWlmIChkaXItPmV4Y2x1ZGUpIHsKKwkJCWlmIChkaXItPnBhdHRlcm4gJiYKKwkJCSAgICBkaXItPnBhdHRlcm4tPmZsYWdzICYgUEFUVEVSTl9GTEFHX05FR0FUSVZFKQorCQkJCWRpci0+cGF0dGVybiA9IE5VTEw7CisJCQlpZiAoZGlyLT5wYXR0ZXJuKSB7CiAJCQkJZGlyLT5leGNsdWRlX3N0YWNrID0gc3RrOwogCQkJCXJldHVybjsKIAkJCX0KQEAgLTEyMjMsMzAgKzEyNDcsMzAgQEAKIAkJCS8qCiAJCQkgKiBkaXItPmJhc2VidWYgZ2V0cyByZXVzZWQgYnkgdGhlIHRyYXZlcnNhbCwgYnV0IHdlCiAJCQkgKiBuZWVkIGZuYW1lIHRvIHJlbWFpbiB1bmNoYW5nZWQgdG8gZW5zdXJlIHRoZSBzcmMKLQkJCSAqIG1lbWJlciBvZiBlYWNoIHN0cnVjdCBleGNsdWRlIGNvcnJlY3RseQorCQkJICogbWVtYmVyIG9mIGVhY2ggc3RydWN0IHBhdGhfcGF0dGVybiBjb3JyZWN0bHkKIAkJCSAqIGJhY2stcmVmZXJlbmNlcyBpdHMgc291cmNlIGZpbGUuICBPdGhlciBpbnZvY2F0aW9ucwotCQkJICogb2YgYWRkX2V4Y2x1ZGVfbGlzdCBwcm92aWRlIHN0YWJsZSBzdHJpbmdzLCBzbyB3ZQorCQkJICogb2YgYWRkX3BhdHRlcm5fbGlzdCBwcm92aWRlIHN0YWJsZSBzdHJpbmdzLCBzbyB3ZQogCQkJICogc3RyYnVmX2RldGFjaCgpIGFuZCBmcmVlKCkgaGVyZSBpbiB0aGUgY2FsbGVyLgogCQkJICovCiAJCQlzdHJ1Y3Qgc3RyYnVmIHNiID0gU1RSQlVGX0lOSVQ7CiAJCQlzdHJidWZfYWRkYnVmKCZzYiwgJmRpci0+YmFzZWJ1Zik7CiAJCQlzdHJidWZfYWRkc3RyKCZzYiwgZGlyLT5leGNsdWRlX3Blcl9kaXIpOwotCQkJZWwtPnNyYyA9IHN0cmJ1Zl9kZXRhY2goJnNiLCBOVUxMKTsKLQkJCWFkZF9leGNsdWRlcyhlbC0+c3JjLCBlbC0+c3JjLCBzdGstPmJhc2VsZW4sIGVsLCBpc3RhdGUsCisJCQlwbC0+c3JjID0gc3RyYnVmX2RldGFjaCgmc2IsIE5VTEwpOworCQkJYWRkX3BhdHRlcm5zKHBsLT5zcmMsIHBsLT5zcmMsIHN0ay0+YmFzZWxlbiwgcGwsIGlzdGF0ZSwKIAkJCQkgICAgIHVudHJhY2tlZCA/ICZvaWRfc3RhdCA6IE5VTEwpOwogCQl9CiAJCS8qCiAJCSAqIE5FRURTV09SSzogd2hlbiB1bnRyYWNrZWQgY2FjaGUgaXMgZW5hYmxlZCwgcHJlcF9leGNsdWRlKCkKIAkJICogd2lsbCBmaXJzdCBiZSBjYWxsZWQgaW4gdmFsaWRfY2FjaGVkX2RpcigpIHRoZW4gbWF5YmUgbWFueQotCQkgKiB0aW1lcyBtb3JlIGluIGxhc3RfZXhjbHVkZV9tYXRjaGluZygpLiBXaGVuIHRoZSBjYWNoZSBpcwotCQkgKiB1c2VkLCBsYXN0X2V4Y2x1ZGVfbWF0Y2hpbmcoKSB3aWxsIG5vdCBiZSBjYWxsZWQgYW5kCisJCSAqIHRpbWVzIG1vcmUgaW4gbGFzdF9tYXRjaGluZ19wYXR0ZXJuKCkuIFdoZW4gdGhlIGNhY2hlIGlzCisJCSAqIHVzZWQsIGxhc3RfbWF0Y2hpbmdfcGF0dGVybigpIHdpbGwgbm90IGJlIGNhbGxlZCBhbmQKIAkJICogcmVhZGluZyAuZ2l0aWdub3JlIGNvbnRlbnQgd2lsbCBiZSBhIHdhc3RlLgogCQkgKgogCQkgKiBTbyB3aGVuIGl0J3MgY2FsbGVkIGJ5IHZhbGlkX2NhY2hlZF9kaXIoKSBhbmQgd2UgY2FuIGdldAogCQkgKiAuZ2l0aWdub3JlIFNIQS0xIGZyb20gdGhlIGluZGV4IChpLmUuIC5naXRpZ25vcmUgaXMgbm90CiAJCSAqIG1vZGlmaWVkIG9uIHdvcmsgdHJlZSksIHdlIGNvdWxkIGRlbGF5IHJlYWRpbmcgdGhlCiAJCSAqIC5naXRpZ25vcmUgY29udGVudCB1bnRpbCB3ZSBhYnNvbHV0ZWx5IG5lZWQgaXQgaW4KLQkJICogbGFzdF9leGNsdWRlX21hdGNoaW5nKCkuIEJlIGNhcmVmdWwgYWJvdXQgaWdub3JlIHJ1bGUKKwkJICogbGFzdF9tYXRjaGluZ19wYXR0ZXJuKCkuIEJlIGNhcmVmdWwgYWJvdXQgaWdub3JlIHJ1bGUKIAkJICogb3JkZXIsIHRob3VnaCwgaWYgeW91IGRvIHRoYXQuCiAJCSAqLwogCQlpZiAodW50cmFja2VkICYmCkBAIC0xMjY2LDcgKzEyOTAsNyBAQAogICogUmV0dXJucyB0aGUgZXhjbHVkZV9saXN0IGVsZW1lbnQgd2hpY2ggbWF0Y2hlZCwgb3IgTlVMTCBmb3IKICAqIHVuZGVjaWRlZC4KICAqLwotc3RydWN0IGV4Y2x1ZGUgKmxhc3RfZXhjbHVkZV9tYXRjaGluZyhzdHJ1Y3QgZGlyX3N0cnVjdCAqZGlyLAorc3RydWN0IHBhdGhfcGF0dGVybiAqbGFzdF9tYXRjaGluZ19wYXR0ZXJuKHN0cnVjdCBkaXJfc3RydWN0ICpkaXIsCiAJCQkJICAgICAgc3RydWN0IGluZGV4X3N0YXRlICppc3RhdGUsCiAJCQkJICAgICAgY29uc3QgY2hhciAqcGF0aG5hbWUsCiAJCQkJICAgICAgaW50ICpkdHlwZV9wKQpAQCAtMTI3NywxMCArMTMwMSwxMCBAQAogCiAJcHJlcF9leGNsdWRlKGRpciwgaXN0YXRlLCBwYXRobmFtZSwgYmFzZW5hbWUtcGF0aG5hbWUpOwogCi0JaWYgKGRpci0+ZXhjbHVkZSkKLQkJcmV0dXJuIGRpci0+ZXhjbHVkZTsKKwlpZiAoZGlyLT5wYXR0ZXJuKQorCQlyZXR1cm4gZGlyLT5wYXR0ZXJuOwogCi0JcmV0dXJuIGxhc3RfZXhjbHVkZV9tYXRjaGluZ19mcm9tX2xpc3RzKGRpciwgaXN0YXRlLCBwYXRobmFtZSwgcGF0aGxlbiwKKwlyZXR1cm4gbGFzdF9tYXRjaGluZ19wYXR0ZXJuX2Zyb21fbGlzdHMoZGlyLCBpc3RhdGUsIHBhdGhuYW1lLCBwYXRobGVuLAogCQkJYmFzZW5hbWUsIGR0eXBlX3ApOwogfQogCkBAIC0xMjkyLDEwICsxMzE2LDEwIEBACiBpbnQgaXNfZXhjbHVkZWQoc3RydWN0IGRpcl9zdHJ1Y3QgKmRpciwgc3RydWN0IGluZGV4X3N0YXRlICppc3RhdGUsCiAJCWNvbnN0IGNoYXIgKnBhdGhuYW1lLCBpbnQgKmR0eXBlX3ApCiB7Ci0Jc3RydWN0IGV4Y2x1ZGUgKmV4Y2x1ZGUgPQotCQlsYXN0X2V4Y2x1ZGVfbWF0Y2hpbmcoZGlyLCBpc3RhdGUsIHBhdGhuYW1lLCBkdHlwZV9wKTsKLQlpZiAoZXhjbHVkZSkKLQkJcmV0dXJuIGV4Y2x1ZGUtPmZsYWdzICYgRVhDX0ZMQUdfTkVHQVRJVkUgPyAwIDogMTsKKwlzdHJ1Y3QgcGF0aF9wYXR0ZXJuICpwYXR0ZXJuID0KKwkJbGFzdF9tYXRjaGluZ19wYXR0ZXJuKGRpciwgaXN0YXRlLCBwYXRobmFtZSwgZHR5cGVfcCk7CisJaWYgKHBhdHRlcm4pCisJCXJldHVybiBwYXR0ZXJuLT5mbGFncyAmIFBBVFRFUk5fRkxBR19ORUdBVElWRSA/IDAgOiAxOwogCXJldHVybiAwOwogfQogCkBAIC0xNDM5LDYgKzE0NjMsMTYgQEAKIAkJcmV0dXJuIHBhdGhfbm9uZTsKIAogCWNhc2UgaW5kZXhfbm9uZXhpc3RlbnQ6CisJCWlmIChkaXItPmZsYWdzICYgRElSX1NLSVBfTkVTVEVEX0dJVCkgeworCQkJaW50IG5lc3RlZF9yZXBvOworCQkJc3RydWN0IHN0cmJ1ZiBzYiA9IFNUUkJVRl9JTklUOworCQkJc3RyYnVmX2FkZHN0cigmc2IsIGRpcm5hbWUpOworCQkJbmVzdGVkX3JlcG8gPSBpc19ub25iYXJlX3JlcG9zaXRvcnlfZGlyKCZzYik7CisJCQlzdHJidWZfcmVsZWFzZSgmc2IpOworCQkJaWYgKG5lc3RlZF9yZXBvKQorCQkJCXJldHVybiBwYXRoX25vbmU7CisJCX0KKwogCQlpZiAoZGlyLT5mbGFncyAmIERJUl9TSE9XX09USEVSX0RJUkVDVE9SSUVTKQogCQkJYnJlYWs7CiAJCWlmIChleGNsdWRlICYmCkBAIC0xODA4LDcgKzE4NDIsNyBAQAogCiAJLyoKIAkgKiBwcmVwX2V4Y2x1ZGUgd2lsbCBiZSBjYWxsZWQgZXZlbnR1YWxseSBvbiB0aGlzIGRpcmVjdG9yeSwKLQkgKiBidXQgaXQncyBjYWxsZWQgbXVjaCBsYXRlciBpbiBsYXN0X2V4Y2x1ZGVfbWF0Y2hpbmcoKS4gV2UKKwkgKiBidXQgaXQncyBjYWxsZWQgbXVjaCBsYXRlciBpbiBsYXN0X21hdGNoaW5nX3BhdHRlcm4oKS4gV2UKIAkgKiBuZWVkIGl0IG5vdyB0byBkZXRlcm1pbmUgdGhlIHZhbGlkaXR5IG9mIHRoZSBjYWNoZSBmb3IgdGhpcwogCSAqIHBhdGguIFRoZSBuZXh0IGNhbGxzIHdpbGwgYmUgbmVhcmx5IG5vLW9wLCB0aGUgd2F5CiAJICogcHJlcF9leGNsdWRlKCkgaXMgZGVzaWduZWQuCkBAIC0xOTM4LDggKzE5NzIsMTEgQEAKIAkJLyogcmVjdXJzZSBpbnRvIHN1YmRpciBpZiBpbnN0cnVjdGVkIGJ5IHRyZWF0X3BhdGggKi8KIAkJaWYgKChzdGF0ZSA9PSBwYXRoX3JlY3Vyc2UpIHx8CiAJCQkoKHN0YXRlID09IHBhdGhfdW50cmFja2VkKSAmJgotCQkJIChkaXItPmZsYWdzICYgRElSX1NIT1dfSUdOT1JFRF9UT08pICYmCi0JCQkgKGdldF9kdHlwZShjZGlyLmRlLCBpc3RhdGUsIHBhdGguYnVmLCBwYXRoLmxlbikgPT0gRFRfRElSKSkpIHsKKwkJCSAoZ2V0X2R0eXBlKGNkaXIuZGUsIGlzdGF0ZSwgcGF0aC5idWYsIHBhdGgubGVuKSA9PSBEVF9ESVIpICYmCisJCQkgKChkaXItPmZsYWdzICYgRElSX1NIT1dfSUdOT1JFRF9UT08pIHx8CisJCQkgIChwYXRoc3BlYyAmJgorCQkJICAgZG9fbWF0Y2hfcGF0aHNwZWMoaXN0YXRlLCBwYXRoc3BlYywgcGF0aC5idWYsIHBhdGgubGVuLAorCQkJCQkgICAgIGJhc2VsZW4sIE5VTEwsIERPX01BVENIX0xFQURJTkdfUEFUSFNQRUMpID09IE1BVENIRURfUkVDVVJTSVZFTFlfTEVBRElOR19QQVRIU1BFQykpKSkgewogCQkJc3RydWN0IHVudHJhY2tlZF9jYWNoZV9kaXIgKnVkOwogCQkJdWQgPSBsb29rdXBfdW50cmFja2VkKGRpci0+dW50cmFja2VkLCB1bnRyYWNrZWQsCiAJCQkJCSAgICAgIHBhdGguYnVmICsgYmFzZWxlbiwKQEAgLTE5NTAsNiArMTk4NywxMiBAQAogCQkJCQkJCSBjaGVja19vbmx5LCBzdG9wX2F0X2ZpcnN0X2ZpbGUsIHBhdGhzcGVjKTsKIAkJCWlmIChzdWJkaXJfc3RhdGUgPiBkaXJfc3RhdGUpCiAJCQkJZGlyX3N0YXRlID0gc3ViZGlyX3N0YXRlOworCisJCQlpZiAocGF0aHNwZWMgJiYKKwkJCSAgICAhbWF0Y2hfcGF0aHNwZWMoaXN0YXRlLCBwYXRoc3BlYywgcGF0aC5idWYsIHBhdGgubGVuLAorCQkJCQkgICAgMCAvKiBwcmVmaXggKi8sIE5VTEwsCisJCQkJCSAgICAwIC8qIGRvIE5PVCBzcGVjaWFsIGNhc2UgZGlycyAqLykpCisJCQkJc3RhdGUgPSBwYXRoX25vbmU7CiAJCX0KIAogCQlpZiAoY2hlY2tfb25seSkgewpAQCAtMjQ0Niw3ICsyNDg5LDcgQEAKIAkJCQkgKiB3YW50ZWQgYW55d2F5CiAJCQkJICovCiAJCQkJY29udGludWU7Ci0JCQkvKiBmYWxsIHRocnUgKi8KKwkJCS8qIGZhbGwgdGhyb3VnaCAqLwogCQl9IGVsc2UgaWYgKFNfSVNESVIoc3Quc3RfbW9kZSkpIHsKIAkJCWlmICghcmVtb3ZlX2Rpcl9yZWN1cnNlKHBhdGgsIGZsYWcsICZrZXB0X2Rvd24pKQogCQkJCWNvbnRpbnVlOyAvKiBoYXBweSAqLwpAQCAtMjQ4OCwxNCArMjUzMSwxNCBAQAogCWlmICghZXhjbHVkZXNfZmlsZSkKIAkJZXhjbHVkZXNfZmlsZSA9IHhkZ19jb25maWdfaG9tZSgiaWdub3JlIik7CiAJaWYgKGV4Y2x1ZGVzX2ZpbGUgJiYgIWFjY2Vzc19vcl93YXJuKGV4Y2x1ZGVzX2ZpbGUsIFJfT0ssIDApKQotCQlhZGRfZXhjbHVkZXNfZnJvbV9maWxlXzEoZGlyLCBleGNsdWRlc19maWxlLAorCQlhZGRfcGF0dGVybnNfZnJvbV9maWxlXzEoZGlyLCBleGNsdWRlc19maWxlLAogCQkJCQkgZGlyLT51bnRyYWNrZWQgPyAmZGlyLT5zc19leGNsdWRlc19maWxlIDogTlVMTCk7CiAKIAkvKiBwZXIgcmVwb3NpdG9yeSB1c2VyIHByZWZlcmVuY2UgKi8KIAlpZiAoc3RhcnR1cF9pbmZvLT5oYXZlX3JlcG9zaXRvcnkpIHsKIAkJY29uc3QgY2hhciAqcGF0aCA9IGdpdF9wYXRoX2luZm9fZXhjbHVkZSgpOwogCQlpZiAoIWFjY2Vzc19vcl93YXJuKHBhdGgsIFJfT0ssIDApKQotCQkJYWRkX2V4Y2x1ZGVzX2Zyb21fZmlsZV8xKGRpciwgcGF0aCwKKwkJCWFkZF9wYXR0ZXJuc19mcm9tX2ZpbGVfMShkaXIsIHBhdGgsCiAJCQkJCQkgZGlyLT51bnRyYWNrZWQgPyAmZGlyLT5zc19pbmZvX2V4Y2x1ZGUgOiBOVUxMKTsKIAl9CiB9CkBAIC0yNTI3LDE4ICsyNTcwLDE4IEBACiB7CiAJaW50IGksIGo7CiAJc3RydWN0IGV4Y2x1ZGVfbGlzdF9ncm91cCAqZ3JvdXA7Ci0Jc3RydWN0IGV4Y2x1ZGVfbGlzdCAqZWw7CisJc3RydWN0IHBhdHRlcm5fbGlzdCAqcGw7CiAJc3RydWN0IGV4Y2x1ZGVfc3RhY2sgKnN0azsKIAogCWZvciAoaSA9IEVYQ19DTURMOyBpIDw9IEVYQ19GSUxFOyBpKyspIHsKIAkJZ3JvdXAgPSAmZGlyLT5leGNsdWRlX2xpc3RfZ3JvdXBbaV07CiAJCWZvciAoaiA9IDA7IGogPCBncm91cC0+bnI7IGorKykgewotCQkJZWwgPSAmZ3JvdXAtPmVsW2pdOworCQkJcGwgPSAmZ3JvdXAtPnBsW2pdOwogCQkJaWYgKGkgPT0gRVhDX0RJUlMpCi0JCQkJZnJlZSgoY2hhciAqKWVsLT5zcmMpOwotCQkJY2xlYXJfZXhjbHVkZV9saXN0KGVsKTsKKwkJCQlmcmVlKChjaGFyICopcGwtPnNyYyk7CisJCQljbGVhcl9wYXR0ZXJuX2xpc3QocGwpOwogCQl9Ci0JCWZyZWUoZ3JvdXAtPmVsKTsKKwkJZnJlZShncm91cC0+cGwpOwogCX0KIAogCXN0ayA9IGRpci0+ZXhjbHVkZV9zdGFjazsKZGlmZiAtLWdpdCBhL2Rpci5oIGIvZGlyLmgKaW5kZXggNjgwMDc5Yi4uMmZiZGVmMCAxMDA2NDQKLS0tIGEvZGlyLmgKKysrIGIvZGlyLmgKQEAgLTExLDI0ICsxMSwyNCBAQAogCWNoYXIgbmFtZVtGTEVYX0FSUkFZXTsgLyogbW9yZSAqLwogfTsKIAotI2RlZmluZSBFWENfRkxBR19OT0RJUiAxCi0jZGVmaW5lIEVYQ19GTEFHX0VORFNXSVRIIDQKLSNkZWZpbmUgRVhDX0ZMQUdfTVVTVEJFRElSIDgKLSNkZWZpbmUgRVhDX0ZMQUdfTkVHQVRJVkUgMTYKKyNkZWZpbmUgUEFUVEVSTl9GTEFHX05PRElSIDEKKyNkZWZpbmUgUEFUVEVSTl9GTEFHX0VORFNXSVRIIDQKKyNkZWZpbmUgUEFUVEVSTl9GTEFHX01VU1RCRURJUiA4CisjZGVmaW5lIFBBVFRFUk5fRkxBR19ORUdBVElWRSAxNgogCi1zdHJ1Y3QgZXhjbHVkZSB7CitzdHJ1Y3QgcGF0aF9wYXR0ZXJuIHsKIAkvKgotCSAqIFRoaXMgYWxsb3dzIGNhbGxlcnMgb2YgbGFzdF9leGNsdWRlX21hdGNoaW5nKCkgZXRjLgorCSAqIFRoaXMgYWxsb3dzIGNhbGxlcnMgb2YgbGFzdF9tYXRjaGluZ19wYXR0ZXJuKCkgZXRjLgogCSAqIHRvIGRldGVybWluZSB0aGUgb3JpZ2luIG9mIHRoZSBtYXRjaGluZyBwYXR0ZXJuLgogCSAqLwotCXN0cnVjdCBleGNsdWRlX2xpc3QgKmVsOworCXN0cnVjdCBwYXR0ZXJuX2xpc3QgKnBsOwogCiAJY29uc3QgY2hhciAqcGF0dGVybjsKIAlpbnQgcGF0dGVybmxlbjsKIAlpbnQgbm93aWxkY2FyZGxlbjsKIAljb25zdCBjaGFyICpiYXNlOwogCWludCBiYXNlbGVuOwotCXVuc2lnbmVkIGZsYWdzOwkJLyogRVhDX0ZMQUdfKiAqLworCXVuc2lnbmVkIGZsYWdzOwkJLyogUEFUVEVSTl9GTEFHXyogKi8KIAogCS8qCiAJICogQ291bnRpbmcgc3RhcnRzIGZyb20gMSBmb3IgbGluZSBudW1iZXJzIGluIGlnbm9yZSBmaWxlcywKQEAgLTQ0LDcgKzQ0LDcgQEAKICAqIGNhbiBhbHNvIGJlIHVzZWQgdG8gcmVwcmVzZW50IHRoZSBsaXN0IG9mIC0tZXhjbHVkZSB2YWx1ZXMgcGFzc2VkCiAgKiB2aWEgQ0xJIGFyZ3MuCiAgKi8KLXN0cnVjdCBleGNsdWRlX2xpc3Qgeworc3RydWN0IHBhdHRlcm5fbGlzdCB7CiAJaW50IG5yOwogCWludCBhbGxvYzsKIApAQCAtNTQsNyArNTQsNyBAQAogCS8qIG9yaWdpbiBvZiBsaXN0LCBlLmcuIHBhdGggdG8gZmlsZW5hbWUsIG9yIGRlc2NyaXB0aXZlIHN0cmluZyAqLwogCWNvbnN0IGNoYXIgKnNyYzsKIAotCXN0cnVjdCBleGNsdWRlICoqZXhjbHVkZXM7CisJc3RydWN0IHBhdGhfcGF0dGVybiAqKnBhdHRlcm5zOwogfTsKIAogLyoKQEAgLTcyLDcgKzcyLDcgQEAKIAogc3RydWN0IGV4Y2x1ZGVfbGlzdF9ncm91cCB7CiAJaW50IG5yLCBhbGxvYzsKLQlzdHJ1Y3QgZXhjbHVkZV9saXN0ICplbDsKKwlzdHJ1Y3QgcGF0dGVybl9saXN0ICpwbDsKIH07CiAKIHN0cnVjdCBvaWRfc3RhdCB7CkBAIC0xNTYsNyArMTU2LDggQEAKIAkJRElSX1NIT1dfSUdOT1JFRF9UT08gPSAxPDw1LAogCQlESVJfQ09MTEVDVF9LSUxMRURfT05MWSA9IDE8PDYsCiAJCURJUl9LRUVQX1VOVFJBQ0tFRF9DT05URU5UUyA9IDE8PDcsCi0JCURJUl9TSE9XX0lHTk9SRURfVE9PX01PREVfTUFUQ0hJTkcgPSAxPDw4CisJCURJUl9TSE9XX0lHTk9SRURfVE9PX01PREVfTUFUQ0hJTkcgPSAxPDw4LAorCQlESVJfU0tJUF9ORVNURURfR0lUID0gMTw8OQogCX0gZmxhZ3M7CiAJc3RydWN0IGRpcl9lbnRyeSAqKmVudHJpZXM7CiAJc3RydWN0IGRpcl9lbnRyeSAqKmlnbm9yZWQ7CkBAIC0xOTEsNyArMTkyLDcgQEAKIAkgKiBtYXRjaGluZyBleGNsdWRlIHN0cnVjdCBpZiB0aGUgZGlyZWN0b3J5IGlzIGV4Y2x1ZGVkLgogCSAqLwogCXN0cnVjdCBleGNsdWRlX3N0YWNrICpleGNsdWRlX3N0YWNrOwotCXN0cnVjdCBleGNsdWRlICpleGNsdWRlOworCXN0cnVjdCBwYXRoX3BhdHRlcm4gKnBhdHRlcm47CiAJc3RydWN0IHN0cmJ1ZiBiYXNlYnVmOwogCiAJLyogRW5hYmxlIHVudHJhY2tlZCBmaWxlIGNhY2hlIGlmIHNldCAqLwpAQCAtMjExLDggKzIxMiw5IEBACiAgKiB3aGVuIHBvcHVsYXRpbmcgdGhlIHNlZW5bXSBhcnJheS4KICAqLwogI2RlZmluZSBNQVRDSEVEX1JFQ1VSU0lWRUxZIDEKLSNkZWZpbmUgTUFUQ0hFRF9GTk1BVENIIDIKLSNkZWZpbmUgTUFUQ0hFRF9FWEFDVExZIDMKKyNkZWZpbmUgTUFUQ0hFRF9SRUNVUlNJVkVMWV9MRUFESU5HX1BBVEhTUEVDIDIKKyNkZWZpbmUgTUFUQ0hFRF9GTk1BVENIIDMKKyNkZWZpbmUgTUFUQ0hFRF9FWEFDVExZIDQKIGludCBzaW1wbGVfbGVuZ3RoKGNvbnN0IGNoYXIgKm1hdGNoKTsKIGludCBub193aWxkY2FyZChjb25zdCBjaGFyICpzdHJpbmcpOwogY2hhciAqY29tbW9uX3ByZWZpeChjb25zdCBzdHJ1Y3QgcGF0aHNwZWMgKnBhdGhzcGVjKTsKQEAgLTIzMCwxMCArMjMyLDIzIEBACiAJCSAgIGNvbnN0IGNoYXIgKnBhdGgsIGludCBsZW4sCiAJCSAgIGNvbnN0IHN0cnVjdCBwYXRoc3BlYyAqcGF0aHNwZWMpOwogCi1pbnQgaXNfZXhjbHVkZWRfZnJvbV9saXN0KGNvbnN0IGNoYXIgKnBhdGhuYW1lLCBpbnQgcGF0aGxlbiwKLQkJCSAgY29uc3QgY2hhciAqYmFzZW5hbWUsIGludCAqZHR5cGUsCi0JCQkgIHN0cnVjdCBleGNsdWRlX2xpc3QgKmVsLAotCQkJICBzdHJ1Y3QgaW5kZXhfc3RhdGUgKmlzdGF0ZSk7CitlbnVtIHBhdHRlcm5fbWF0Y2hfcmVzdWx0IHsKKwlVTkRFQ0lERUQgPSAtMSwKKwlOT1RfTUFUQ0hFRCA9IDAsCisJTUFUQ0hFRCA9IDEsCit9OworCisvKgorICogU2NhbiB0aGUgbGlzdCBvZiBwYXR0ZXJucyB0byBkZXRlcm1pbmUgaWYgdGhlIG9yZGVyZWQgbGlzdAorICogb2YgcGF0dGVybnMgbWF0Y2hlcyBvbiAncGF0aG5hbWUnLgorICoKKyAqIFJldHVybiAxIGZvciBhIG1hdGNoLCAwIGZvciBub3QgbWF0Y2hlZCBhbmQgLTEgZm9yIHVuZGVjaWRlZC4KKyAqLworZW51bSBwYXR0ZXJuX21hdGNoX3Jlc3VsdCBwYXRoX21hdGNoZXNfcGF0dGVybl9saXN0KGNvbnN0IGNoYXIgKnBhdGhuYW1lLAorCQkJCWludCBwYXRobGVuLAorCQkJCWNvbnN0IGNoYXIgKmJhc2VuYW1lLCBpbnQgKmR0eXBlLAorCQkJCXN0cnVjdCBwYXR0ZXJuX2xpc3QgKnBsLAorCQkJCXN0cnVjdCBpbmRleF9zdGF0ZSAqaXN0YXRlKTsKIHN0cnVjdCBkaXJfZW50cnkgKmRpcl9hZGRfaWdub3JlZChzdHJ1Y3QgZGlyX3N0cnVjdCAqZGlyLAogCQkJCSAgc3RydWN0IGluZGV4X3N0YXRlICppc3RhdGUsCiAJCQkJICBjb25zdCBjaGFyICpwYXRobmFtZSwgaW50IGxlbik7CkBAIC0yNDgsMjYgKzI2MywyNiBAQAogCQkgICBjb25zdCBjaGFyICosIGludCwKIAkJICAgY29uc3QgY2hhciAqLCBpbnQsIGludCwgdW5zaWduZWQpOwogCi1zdHJ1Y3QgZXhjbHVkZSAqbGFzdF9leGNsdWRlX21hdGNoaW5nKHN0cnVjdCBkaXJfc3RydWN0ICpkaXIsCi0JCQkJICAgICAgc3RydWN0IGluZGV4X3N0YXRlICppc3RhdGUsCi0JCQkJICAgICAgY29uc3QgY2hhciAqbmFtZSwgaW50ICpkdHlwZSk7CitzdHJ1Y3QgcGF0aF9wYXR0ZXJuICpsYXN0X21hdGNoaW5nX3BhdHRlcm4oc3RydWN0IGRpcl9zdHJ1Y3QgKmRpciwKKwkJCQkJICAgc3RydWN0IGluZGV4X3N0YXRlICppc3RhdGUsCisJCQkJCSAgIGNvbnN0IGNoYXIgKm5hbWUsIGludCAqZHR5cGUpOwogCiBpbnQgaXNfZXhjbHVkZWQoc3RydWN0IGRpcl9zdHJ1Y3QgKmRpciwKIAkJc3RydWN0IGluZGV4X3N0YXRlICppc3RhdGUsCiAJCWNvbnN0IGNoYXIgKm5hbWUsIGludCAqZHR5cGUpOwogCi1zdHJ1Y3QgZXhjbHVkZV9saXN0ICphZGRfZXhjbHVkZV9saXN0KHN0cnVjdCBkaXJfc3RydWN0ICpkaXIsCitzdHJ1Y3QgcGF0dGVybl9saXN0ICphZGRfcGF0dGVybl9saXN0KHN0cnVjdCBkaXJfc3RydWN0ICpkaXIsCiAJCQkJICAgICAgaW50IGdyb3VwX3R5cGUsIGNvbnN0IGNoYXIgKnNyYyk7Ci1pbnQgYWRkX2V4Y2x1ZGVzX2Zyb21fZmlsZV90b19saXN0KGNvbnN0IGNoYXIgKmZuYW1lLCBjb25zdCBjaGFyICpiYXNlLCBpbnQgYmFzZWxlbiwKLQkJCQkgICBzdHJ1Y3QgZXhjbHVkZV9saXN0ICplbCwgc3RydWN0ICBpbmRleF9zdGF0ZSAqaXN0YXRlKTsKLXZvaWQgYWRkX2V4Y2x1ZGVzX2Zyb21fZmlsZShzdHJ1Y3QgZGlyX3N0cnVjdCAqLCBjb25zdCBjaGFyICpmbmFtZSk7Ci1pbnQgYWRkX2V4Y2x1ZGVzX2Zyb21fYmxvYl90b19saXN0KHN0cnVjdCBvYmplY3RfaWQgKm9pZCwKK2ludCBhZGRfcGF0dGVybnNfZnJvbV9maWxlX3RvX2xpc3QoY29uc3QgY2hhciAqZm5hbWUsIGNvbnN0IGNoYXIgKmJhc2UsIGludCBiYXNlbGVuLAorCQkJCSAgIHN0cnVjdCBwYXR0ZXJuX2xpc3QgKnBsLCBzdHJ1Y3QgIGluZGV4X3N0YXRlICppc3RhdGUpOwordm9pZCBhZGRfcGF0dGVybnNfZnJvbV9maWxlKHN0cnVjdCBkaXJfc3RydWN0ICosIGNvbnN0IGNoYXIgKmZuYW1lKTsKK2ludCBhZGRfcGF0dGVybnNfZnJvbV9ibG9iX3RvX2xpc3Qoc3RydWN0IG9iamVjdF9pZCAqb2lkLAogCQkJCSAgIGNvbnN0IGNoYXIgKmJhc2UsIGludCBiYXNlbGVuLAotCQkJCSAgIHN0cnVjdCBleGNsdWRlX2xpc3QgKmVsKTsKLXZvaWQgcGFyc2VfZXhjbHVkZV9wYXR0ZXJuKGNvbnN0IGNoYXIgKipzdHJpbmcsIGludCAqcGF0dGVybmxlbiwgdW5zaWduZWQgKmZsYWdzLCBpbnQgKm5vd2lsZGNhcmRsZW4pOwotdm9pZCBhZGRfZXhjbHVkZShjb25zdCBjaGFyICpzdHJpbmcsIGNvbnN0IGNoYXIgKmJhc2UsCi0JCSBpbnQgYmFzZWxlbiwgc3RydWN0IGV4Y2x1ZGVfbGlzdCAqZWwsIGludCBzcmNwb3MpOwotdm9pZCBjbGVhcl9leGNsdWRlX2xpc3Qoc3RydWN0IGV4Y2x1ZGVfbGlzdCAqZWwpOworCQkJCSAgIHN0cnVjdCBwYXR0ZXJuX2xpc3QgKnBsKTsKK3ZvaWQgcGFyc2VfcGF0aF9wYXR0ZXJuKGNvbnN0IGNoYXIgKipzdHJpbmcsIGludCAqcGF0dGVybmxlbiwgdW5zaWduZWQgKmZsYWdzLCBpbnQgKm5vd2lsZGNhcmRsZW4pOwordm9pZCBhZGRfcGF0dGVybihjb25zdCBjaGFyICpzdHJpbmcsIGNvbnN0IGNoYXIgKmJhc2UsCisJCSBpbnQgYmFzZWxlbiwgc3RydWN0IHBhdHRlcm5fbGlzdCAqcGwsIGludCBzcmNwb3MpOwordm9pZCBjbGVhcl9wYXR0ZXJuX2xpc3Qoc3RydWN0IHBhdHRlcm5fbGlzdCAqcGwpOwogdm9pZCBjbGVhcl9kaXJlY3Rvcnkoc3RydWN0IGRpcl9zdHJ1Y3QgKmRpcik7CiAKIGludCByZXBvX2ZpbGVfZXhpc3RzKHN0cnVjdCByZXBvc2l0b3J5ICpyZXBvLCBjb25zdCBjaGFyICpwYXRoKTsKZGlmZiAtLWdpdCBhL2Vudmlyb25tZW50LmMgYi9lbnZpcm9ubWVudC5jCmluZGV4IDg5YWY0N2MuLmVmYTA3MjYgMTAwNjQ0Ci0tLSBhL2Vudmlyb25tZW50LmMKKysrIGIvZW52aXJvbm1lbnQuYwpAQCAtMzEsOCArMzEsNiBAQAogaW50IHdhcm5fb25fb2JqZWN0X3JlZm5hbWVfYW1iaWd1aXR5ID0gMTsKIGludCByZWZfcGFyYW5vaWEgPSAtMTsKIGludCByZXBvc2l0b3J5X2Zvcm1hdF9wcmVjaW91c19vYmplY3RzOwotY2hhciAqcmVwb3NpdG9yeV9mb3JtYXRfcGFydGlhbF9jbG9uZTsKLWNvbnN0IGNoYXIgKmNvcmVfcGFydGlhbF9jbG9uZV9maWx0ZXJfZGVmYXVsdDsKIGludCByZXBvc2l0b3J5X2Zvcm1hdF93b3JrdHJlZV9jb25maWc7CiBjb25zdCBjaGFyICpnaXRfY29tbWl0X2VuY29kaW5nOwogY29uc3QgY2hhciAqZ2l0X2xvZ19vdXRwdXRfZW5jb2Rpbmc7CmRpZmYgLS1naXQgYS9mYXN0LWltcG9ydC5jIGIvZmFzdC1pbXBvcnQuYwppbmRleCBiNDRkNmE0Li45NTAzZDA4IDEwMDY0NAotLS0gYS9mYXN0LWltcG9ydC5jCisrKyBiL2Zhc3QtaW1wb3J0LmMKQEAgLTE3NjMsNyArMTc2Myw2IEBACiAJCX0gZWxzZSB7CiAJCQlzdHJ1Y3QgcmVjZW50X2NvbW1hbmQgKnJjOwogCi0JCQlzdHJidWZfZGV0YWNoKCZjb21tYW5kX2J1ZiwgTlVMTCk7CiAJCQlzdGRpbl9lb2YgPSBzdHJidWZfZ2V0bGluZV9sZigmY29tbWFuZF9idWYsIHN0ZGluKTsKIAkJCWlmIChzdGRpbl9lb2YpCiAJCQkJcmV0dXJuIEVPRjsKQEAgLTE3ODQsNyArMTc4Myw3IEBACiAJCQkJZnJlZShyYy0+YnVmKTsKIAkJCX0KIAotCQkJcmMtPmJ1ZiA9IGNvbW1hbmRfYnVmLmJ1ZjsKKwkJCXJjLT5idWYgPSB4c3RyZHVwKGNvbW1hbmRfYnVmLmJ1Zik7CiAJCQlyYy0+cHJldiA9IGNtZF90YWlsOwogCQkJcmMtPm5leHQgPSBjbWRfaGlzdC5wcmV2OwogCQkJcmMtPnByZXYtPm5leHQgPSByYzsKQEAgLTE4MzMsNyArMTgzMiw2IEBACiAJCWNoYXIgKnRlcm0gPSB4c3RyZHVwKGRhdGEpOwogCQlzaXplX3QgdGVybV9sZW4gPSBjb21tYW5kX2J1Zi5sZW4gLSAoZGF0YSAtIGNvbW1hbmRfYnVmLmJ1Zik7CiAKLQkJc3RyYnVmX2RldGFjaCgmY29tbWFuZF9idWYsIE5VTEwpOwogCQlmb3IgKDs7KSB7CiAJCQlpZiAoc3RyYnVmX2dldGxpbmVfbGYoJmNvbW1hbmRfYnVmLCBzdGRpbikgPT0gRU9GKQogCQkJCWRpZSgiRU9GIGluIGRhdGEgKHRlcm1pbmF0b3IgJyVzJyBub3QgZm91bmQpIiwgdGVybSk7CkBAIC0yNDkxLDE4ICsyNDg5LDE0IEBACiAJfQogfQogCi1zdGF0aWMgaW50IHBhcnNlX2Zyb20oc3RydWN0IGJyYW5jaCAqYikKK3N0YXRpYyBpbnQgcGFyc2Vfb2JqZWN0aXNoKHN0cnVjdCBicmFuY2ggKmIsIGNvbnN0IGNoYXIgKm9iamVjdGlzaCkKIHsKLQljb25zdCBjaGFyICpmcm9tOwogCXN0cnVjdCBicmFuY2ggKnM7CiAJc3RydWN0IG9iamVjdF9pZCBvaWQ7CiAKLQlpZiAoIXNraXBfcHJlZml4KGNvbW1hbmRfYnVmLmJ1ZiwgImZyb20gIiwgJmZyb20pKQotCQlyZXR1cm4gMDsKLQogCW9pZGNweSgmb2lkLCAmYi0+YnJhbmNoX3RyZWUudmVyc2lvbnNbMV0ub2lkKTsKIAotCXMgPSBsb29rdXBfYnJhbmNoKGZyb20pOworCXMgPSBsb29rdXBfYnJhbmNoKG9iamVjdGlzaCk7CiAJaWYgKGIgPT0gcykKIAkJZGllKCJDYW4ndCBjcmVhdGUgYSBicmFuY2ggZnJvbSBpdHNlbGY6ICVzIiwgYi0+bmFtZSk7CiAJZWxzZSBpZiAocykgewpAQCAtMjUxMCw4ICsyNTA0LDggQEAKIAkJb2lkY3B5KCZiLT5vaWQsICZzLT5vaWQpOwogCQlvaWRjcHkoJmItPmJyYW5jaF90cmVlLnZlcnNpb25zWzBdLm9pZCwgdCk7CiAJCW9pZGNweSgmYi0+YnJhbmNoX3RyZWUudmVyc2lvbnNbMV0ub2lkLCB0KTsKLQl9IGVsc2UgaWYgKCpmcm9tID09ICc6JykgewotCQl1aW50bWF4X3QgaWRudW0gPSBwYXJzZV9tYXJrX3JlZl9lb2woZnJvbSk7CisJfSBlbHNlIGlmICgqb2JqZWN0aXNoID09ICc6JykgeworCQl1aW50bWF4X3QgaWRudW0gPSBwYXJzZV9tYXJrX3JlZl9lb2wob2JqZWN0aXNoKTsKIAkJc3RydWN0IG9iamVjdF9lbnRyeSAqb2UgPSBmaW5kX21hcmsoaWRudW0pOwogCQlpZiAob2UtPnR5cGUgIT0gT0JKX0NPTU1JVCkKIAkJCWRpZSgiTWFyayA6JSIgUFJJdU1BWCAiIG5vdCBhIGNvbW1pdCIsIGlkbnVtKTsKQEAgLTI1MjUsMTMgKzI1MTksMTMgQEAKIAkJCX0gZWxzZQogCQkJCXBhcnNlX2Zyb21fZXhpc3RpbmcoYik7CiAJCX0KLQl9IGVsc2UgaWYgKCFnZXRfb2lkKGZyb20sICZiLT5vaWQpKSB7CisJfSBlbHNlIGlmICghZ2V0X29pZChvYmplY3Rpc2gsICZiLT5vaWQpKSB7CiAJCXBhcnNlX2Zyb21fZXhpc3RpbmcoYik7CiAJCWlmIChpc19udWxsX29pZCgmYi0+b2lkKSkKIAkJCWItPmRlbGV0ZSA9IDE7CiAJfQogCWVsc2UKLQkJZGllKCJJbnZhbGlkIHJlZiBuYW1lIG9yIFNIQTEgZXhwcmVzc2lvbjogJXMiLCBmcm9tKTsKKwkJZGllKCJJbnZhbGlkIHJlZiBuYW1lIG9yIFNIQTEgZXhwcmVzc2lvbjogJXMiLCBvYmplY3Rpc2gpOwogCiAJaWYgKGItPmJyYW5jaF90cmVlLnRyZWUgJiYgIW9pZGVxKCZvaWQsICZiLT5icmFuY2hfdHJlZS52ZXJzaW9uc1sxXS5vaWQpKSB7CiAJCXJlbGVhc2VfdHJlZV9jb250ZW50X3JlY3Vyc2l2ZShiLT5icmFuY2hfdHJlZS50cmVlKTsKQEAgLTI1NDIsNiArMjUzNiwyNiBAQAogCXJldHVybiAxOwogfQogCitzdGF0aWMgaW50IHBhcnNlX2Zyb20oc3RydWN0IGJyYW5jaCAqYikKK3sKKwljb25zdCBjaGFyICpmcm9tOworCisJaWYgKCFza2lwX3ByZWZpeChjb21tYW5kX2J1Zi5idWYsICJmcm9tICIsICZmcm9tKSkKKwkJcmV0dXJuIDA7CisKKwlyZXR1cm4gcGFyc2Vfb2JqZWN0aXNoKGIsIGZyb20pOworfQorCitzdGF0aWMgaW50IHBhcnNlX29iamVjdGlzaF93aXRoX3ByZWZpeChzdHJ1Y3QgYnJhbmNoICpiLCBjb25zdCBjaGFyICpwcmVmaXgpCit7CisJY29uc3QgY2hhciAqYmFzZTsKKworCWlmICghc2tpcF9wcmVmaXgoY29tbWFuZF9idWYuYnVmLCBwcmVmaXgsICZiYXNlKSkKKwkJcmV0dXJuIDA7CisKKwlyZXR1cm4gcGFyc2Vfb2JqZWN0aXNoKGIsIGJhc2UpOworfQorCiBzdGF0aWMgc3RydWN0IGhhc2hfbGlzdCAqcGFyc2VfbWVyZ2UodW5zaWduZWQgaW50ICpjb3VudCkKIHsKIAlzdHJ1Y3QgaGFzaF9saXN0ICpsaXN0ID0gTlVMTCwgKip0YWlsID0gJmxpc3QsICpuOwpAQCAtMjU4OCw3ICsyNjAyLDcgQEAKIAlzdHJ1Y3QgYnJhbmNoICpiOwogCWNoYXIgKmF1dGhvciA9IE5VTEw7CiAJY2hhciAqY29tbWl0dGVyID0gTlVMTDsKLQljb25zdCBjaGFyICplbmNvZGluZyA9IE5VTEw7CisJY2hhciAqZW5jb2RpbmcgPSBOVUxMOwogCXN0cnVjdCBoYXNoX2xpc3QgKm1lcmdlX2xpc3QgPSBOVUxMOwogCXVuc2lnbmVkIGludCBtZXJnZV9jb3VudDsKIAl1bnNpZ25lZCBjaGFyIHByZXZfZmFub3V0LCBuZXdfZmFub3V0OwpAQCAtMjYxMSw4ICsyNjI1LDEwIEBACiAJfQogCWlmICghY29tbWl0dGVyKQogCQlkaWUoIkV4cGVjdGVkIGNvbW1pdHRlciBidXQgZGlkbid0IGdldCBvbmUiKTsKLQlpZiAoc2tpcF9wcmVmaXgoY29tbWFuZF9idWYuYnVmLCAiZW5jb2RpbmcgIiwgJmVuY29kaW5nKSkKKwlpZiAoc2tpcF9wcmVmaXgoY29tbWFuZF9idWYuYnVmLCAiZW5jb2RpbmcgIiwgJnYpKSB7CisJCWVuY29kaW5nID0geHN0cmR1cCh2KTsKIAkJcmVhZF9uZXh0X2NvbW1hbmQoKTsKKwl9CiAJcGFyc2VfZGF0YSgmbXNnLCAwLCBOVUxMKTsKIAlyZWFkX25leHRfY29tbWFuZCgpOwogCXBhcnNlX2Zyb20oYik7CkBAIC0yNjg2LDYgKzI3MDIsNyBAQAogCXN0cmJ1Zl9hZGRidWYoJm5ld19kYXRhLCAmbXNnKTsKIAlmcmVlKGF1dGhvcik7CiAJZnJlZShjb21taXR0ZXIpOworCWZyZWUoZW5jb2RpbmcpOwogCiAJaWYgKCFzdG9yZV9vYmplY3QoT0JKX0NPTU1JVCwgJm5ld19kYXRhLCBOVUxMLCAmYi0+b2lkLCBuZXh0X21hcmspKQogCQliLT5wYWNrX2lkID0gcGFja19pZDsKQEAgLTI3MTMsNiArMjczMCw3IEBACiAJCWZpcnN0X3RhZyA9IHQ7CiAJbGFzdF90YWcgPSB0OwogCXJlYWRfbmV4dF9jb21tYW5kKCk7CisJcGFyc2VfbWFyaygpOwogCiAJLyogZnJvbSAuLi4gKi8KIAlpZiAoIXNraXBfcHJlZml4KGNvbW1hbmRfYnVmLmJ1ZiwgImZyb20gIiwgJmZyb20pKQpAQCAtMjc2OSw3ICsyNzg3LDcgQEAKIAlzdHJidWZfYWRkYnVmKCZuZXdfZGF0YSwgJm1zZyk7CiAJZnJlZSh0YWdnZXIpOwogCi0JaWYgKHN0b3JlX29iamVjdChPQkpfVEFHLCAmbmV3X2RhdGEsIE5VTEwsICZ0LT5vaWQsIDApKQorCWlmIChzdG9yZV9vYmplY3QoT0JKX1RBRywgJm5ld19kYXRhLCBOVUxMLCAmdC0+b2lkLCBuZXh0X21hcmspKQogCQl0LT5wYWNrX2lkID0gTUFYX1BBQ0tfSUQ7CiAJZWxzZQogCQl0LT5wYWNrX2lkID0gcGFja19pZDsKQEAgLTI3NzgsNiArMjc5Niw3IEBACiBzdGF0aWMgdm9pZCBwYXJzZV9yZXNldF9icmFuY2goY29uc3QgY2hhciAqYXJnKQogewogCXN0cnVjdCBicmFuY2ggKmI7CisJY29uc3QgY2hhciAqdGFnX25hbWU7CiAKIAliID0gbG9va3VwX2JyYW5jaChhcmcpOwogCWlmIChiKSB7CkBAIC0yNzkzLDYgKzI4MTIsMzIgQEAKIAkJYiA9IG5ld19icmFuY2goYXJnKTsKIAlyZWFkX25leHRfY29tbWFuZCgpOwogCXBhcnNlX2Zyb20oYik7CisJaWYgKGItPmRlbGV0ZSAmJiBza2lwX3ByZWZpeChiLT5uYW1lLCAicmVmcy90YWdzLyIsICZ0YWdfbmFtZSkpIHsKKwkJLyoKKwkJICogRWxzZXdoZXJlLCB3ZSBjYWxsIGR1bXBfYnJhbmNoZXMoKSBiZWZvcmUgZHVtcF90YWdzKCksCisJCSAqIGFuZCBkdW1wX2JyYW5jaGVzKCkgd2lsbCBoYW5kbGUgcmVmIGRlbGV0aW9ucyBmaXJzdCwgc28KKwkJICogaW4gb3JkZXIgdG8gbWFrZSBzdXJlIHRoZSBkZWxldGlvbiBhY3R1YWxseSB0YWtlcyBlZmZlY3QsCisJCSAqIHdlIG5lZWQgdG8gcmVtb3ZlIHRoZSB0YWcgZnJvbSBvdXIgbGlzdCBvZiB0YWdzIHRvIHVwZGF0ZS4KKwkJICoKKwkJICogTkVFRFNXT1JLOiByZXBsYWNlIGxpc3Qgb2YgdGFncyB3aXRoIGhhc2htYXAgZm9yIGZhc3RlcgorCQkgKiBkZWxldGlvbj8KKwkJICovCisJCXN0cnVjdCB0YWcgKnQsICpwcmV2ID0gTlVMTDsKKwkJZm9yICh0ID0gZmlyc3RfdGFnOyB0OyB0ID0gdC0+bmV4dF90YWcpIHsKKwkJCWlmICghc3RyY21wKHQtPm5hbWUsIHRhZ19uYW1lKSkKKwkJCQlicmVhazsKKwkJCXByZXYgPSB0OworCQl9CisJCWlmICh0KSB7CisJCQlpZiAocHJldikKKwkJCQlwcmV2LT5uZXh0X3RhZyA9IHQtPm5leHRfdGFnOworCQkJZWxzZQorCQkJCWZpcnN0X3RhZyA9IHQtPm5leHRfdGFnOworCQkJaWYgKCF0LT5uZXh0X3RhZykKKwkJCQlsYXN0X3RhZyA9IHByZXY7CisJCQkvKiBUaGVyZSBpcyBubyBtZW1fcG9vbF9mcmVlKHQpIGZ1bmN0aW9uIHRvIGNhbGwuICovCisJCX0KKwl9CiAJaWYgKGNvbW1hbmRfYnVmLmxlbiA+IDApCiAJCXVucmVhZF9jb21tYW5kX2J1ZiA9IDE7CiB9CkBAIC0zMDU5LDYgKzMxMDQsMjggQEAKIAlza2lwX29wdGlvbmFsX2xmKCk7CiB9CiAKK3N0YXRpYyB2b2lkIHBhcnNlX2FsaWFzKHZvaWQpCit7CisJc3RydWN0IG9iamVjdF9lbnRyeSAqZTsKKwlzdHJ1Y3QgYnJhbmNoIGI7CisKKwlza2lwX29wdGlvbmFsX2xmKCk7CisJcmVhZF9uZXh0X2NvbW1hbmQoKTsKKworCS8qIG1hcmsgLi4uICovCisJcGFyc2VfbWFyaygpOworCWlmICghbmV4dF9tYXJrKQorCQlkaWUoXygiRXhwZWN0ZWQgJ21hcmsnIGNvbW1hbmQsIGdvdCAlcyIpLCBjb21tYW5kX2J1Zi5idWYpOworCisJLyogdG8gLi4uICovCisJbWVtc2V0KCZiLCAwLCBzaXplb2YoYikpOworCWlmICghcGFyc2Vfb2JqZWN0aXNoX3dpdGhfcHJlZml4KCZiLCAidG8gIikpCisJCWRpZShfKCJFeHBlY3RlZCAndG8nIGNvbW1hbmQsIGdvdCAlcyIpLCBjb21tYW5kX2J1Zi5idWYpOworCWUgPSBmaW5kX29iamVjdCgmYi5vaWQpOworCWFzc2VydChlKTsKKwlpbnNlcnRfbWFyayhuZXh0X21hcmssIGUpOworfQorCiBzdGF0aWMgY2hhciogbWFrZV9mYXN0X2ltcG9ydF9wYXRoKGNvbnN0IGNoYXIgKnBhdGgpCiB7CiAJaWYgKCFyZWxhdGl2ZV9tYXJrc19wYXRocyB8fCBpc19hYnNvbHV0ZV9wYXRoKHBhdGgpKQpAQCAtMzE4Niw2ICszMjUzLDggQEAKIAkJb3B0aW9uX2ltcG9ydF9tYXJrcyhhcmcsIGZyb21fc3RyZWFtLCAxKTsKIAl9IGVsc2UgaWYgKHNraXBfcHJlZml4KGZlYXR1cmUsICJleHBvcnQtbWFya3M9IiwgJmFyZykpIHsKIAkJb3B0aW9uX2V4cG9ydF9tYXJrcyhhcmcpOworCX0gZWxzZSBpZiAoIXN0cmNtcChmZWF0dXJlLCAiYWxpYXMiKSkgeworCQk7IC8qIERvbid0IGRpZSAtIHRoaXMgZmVhdHVyZSBpcyBzdXBwb3J0ZWQgKi8KIAl9IGVsc2UgaWYgKCFzdHJjbXAoZmVhdHVyZSwgImdldC1tYXJrIikpIHsKIAkJOyAvKiBEb24ndCBkaWUgLSB0aGlzIGZlYXR1cmUgaXMgc3VwcG9ydGVkICovCiAJfSBlbHNlIGlmICghc3RyY21wKGZlYXR1cmUsICJjYXQtYmxvYiIpKSB7CkBAIC0zMzQyLDYgKzM0MTEsOCBAQAogCQkJcGFyc2VfY2hlY2twb2ludCgpOwogCQllbHNlIGlmICghc3RyY21wKCJkb25lIiwgY29tbWFuZF9idWYuYnVmKSkKIAkJCWJyZWFrOworCQllbHNlIGlmICghc3RyY21wKCJhbGlhcyIsIGNvbW1hbmRfYnVmLmJ1ZikpCisJCQlwYXJzZV9hbGlhcygpOwogCQllbHNlIGlmIChzdGFydHNfd2l0aChjb21tYW5kX2J1Zi5idWYsICJwcm9ncmVzcyAiKSkKIAkJCXBhcnNlX3Byb2dyZXNzKCk7CiAJCWVsc2UgaWYgKHNraXBfcHJlZml4KGNvbW1hbmRfYnVmLmJ1ZiwgImZlYXR1cmUgIiwgJnYpKQpkaWZmIC0tZ2l0IGEvZmV0Y2gtbmVnb3RpYXRvci5jIGIvZmV0Y2gtbmVnb3RpYXRvci5jCmluZGV4IGQ2ZDY4NWMuLjBhMTM1N2QgMTAwNjQ0Ci0tLSBhL2ZldGNoLW5lZ290aWF0b3IuYworKysgYi9mZXRjaC1uZWdvdGlhdG9yLmMKQEAgLTIsMTkgKzIsMjAgQEAKICNpbmNsdWRlICJmZXRjaC1uZWdvdGlhdG9yLmgiCiAjaW5jbHVkZSAibmVnb3RpYXRvci9kZWZhdWx0LmgiCiAjaW5jbHVkZSAibmVnb3RpYXRvci9za2lwcGluZy5oIgorI2luY2x1ZGUgInJlcG9zaXRvcnkuaCIKIAotdm9pZCBmZXRjaF9uZWdvdGlhdG9yX2luaXQoc3RydWN0IGZldGNoX25lZ290aWF0b3IgKm5lZ290aWF0b3IsCi0JCQkgICBjb25zdCBjaGFyICphbGdvcml0aG0pCit2b2lkIGZldGNoX25lZ290aWF0b3JfaW5pdChzdHJ1Y3QgcmVwb3NpdG9yeSAqciwKKwkJCSAgIHN0cnVjdCBmZXRjaF9uZWdvdGlhdG9yICpuZWdvdGlhdG9yKQogewotCWlmIChhbGdvcml0aG0pIHsKLQkJaWYgKCFzdHJjbXAoYWxnb3JpdGhtLCAic2tpcHBpbmciKSkgewotCQkJc2tpcHBpbmdfbmVnb3RpYXRvcl9pbml0KG5lZ290aWF0b3IpOwotCQkJcmV0dXJuOwotCQl9IGVsc2UgaWYgKCFzdHJjbXAoYWxnb3JpdGhtLCAiZGVmYXVsdCIpKSB7Ci0JCQkvKiBGYWxsIHRocm91Z2ggdG8gZGVmYXVsdCBpbml0aWFsaXphdGlvbiAqLwotCQl9IGVsc2UgewotCQkJZGllKCJ1bmtub3duIGZldGNoIG5lZ290aWF0aW9uIGFsZ29yaXRobSAnJXMnIiwgYWxnb3JpdGhtKTsKLQkJfQorCXByZXBhcmVfcmVwb19zZXR0aW5ncyhyKTsKKwlzd2l0Y2goci0+c2V0dGluZ3MuZmV0Y2hfbmVnb3RpYXRpb25fYWxnb3JpdGhtKSB7CisJY2FzZSBGRVRDSF9ORUdPVElBVElPTl9TS0lQUElORzoKKwkJc2tpcHBpbmdfbmVnb3RpYXRvcl9pbml0KG5lZ290aWF0b3IpOworCQlyZXR1cm47CisKKwljYXNlIEZFVENIX05FR09USUFUSU9OX0RFRkFVTFQ6CisJZGVmYXVsdDoKKwkJZGVmYXVsdF9uZWdvdGlhdG9yX2luaXQobmVnb3RpYXRvcik7CisJCXJldHVybjsKIAl9Ci0JZGVmYXVsdF9uZWdvdGlhdG9yX2luaXQobmVnb3RpYXRvcik7CiB9CmRpZmYgLS1naXQgYS9mZXRjaC1uZWdvdGlhdG9yLmggYi9mZXRjaC1uZWdvdGlhdG9yLmgKaW5kZXggOWUzOTY3Yy4uZWE3ODg2OCAxMDA2NDQKLS0tIGEvZmV0Y2gtbmVnb3RpYXRvci5oCisrKyBiL2ZldGNoLW5lZ290aWF0b3IuaApAQCAtMiw2ICsyLDcgQEAKICNkZWZpbmUgRkVUQ0hfTkVHT1RJQVRPUl9ICiAKIHN0cnVjdCBjb21taXQ7CitzdHJ1Y3QgcmVwb3NpdG9yeTsKIAogLyoKICAqIEFuIG9iamVjdCB0aGF0IHN1cHBsaWVzIHRoZSBpbmZvcm1hdGlvbiBuZWVkZWQgdG8gbmVnb3RpYXRlIHRoZSBjb250ZW50cyBvZgpAQCAtNTIsNyArNTMsNyBAQAogCXZvaWQgKmRhdGE7CiB9OwogCi12b2lkIGZldGNoX25lZ290aWF0b3JfaW5pdChzdHJ1Y3QgZmV0Y2hfbmVnb3RpYXRvciAqbmVnb3RpYXRvciwKLQkJCSAgIGNvbnN0IGNoYXIgKmFsZ29yaXRobSk7Cit2b2lkIGZldGNoX25lZ290aWF0b3JfaW5pdChzdHJ1Y3QgcmVwb3NpdG9yeSAqciwKKwkJCSAgIHN0cnVjdCBmZXRjaF9uZWdvdGlhdG9yICpuZWdvdGlhdG9yKTsKIAogI2VuZGlmCmRpZmYgLS1naXQgYS9mZXRjaC1vYmplY3QuYyBiL2ZldGNoLW9iamVjdC5jCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA0MjY2NTQ4Li4wMDAwMDAwCi0tLSBhL2ZldGNoLW9iamVjdC5jCisrKyAvZGV2L251bGwKQEAgLTEsNDAgKzAsMCBAQAotI2luY2x1ZGUgImNhY2hlLmgiCi0jaW5jbHVkZSAicGFja2ZpbGUuaCIKLSNpbmNsdWRlICJwa3QtbGluZS5oIgotI2luY2x1ZGUgInN0cmJ1Zi5oIgotI2luY2x1ZGUgInRyYW5zcG9ydC5oIgotI2luY2x1ZGUgImZldGNoLW9iamVjdC5oIgotCi1zdGF0aWMgdm9pZCBmZXRjaF9yZWZzKGNvbnN0IGNoYXIgKnJlbW90ZV9uYW1lLCBzdHJ1Y3QgcmVmICpyZWYpCi17Ci0Jc3RydWN0IHJlbW90ZSAqcmVtb3RlOwotCXN0cnVjdCB0cmFuc3BvcnQgKnRyYW5zcG9ydDsKLQlpbnQgb3JpZ2luYWxfZmV0Y2hfaWZfbWlzc2luZyA9IGZldGNoX2lmX21pc3Npbmc7Ci0KLQlmZXRjaF9pZl9taXNzaW5nID0gMDsKLQlyZW1vdGUgPSByZW1vdGVfZ2V0KHJlbW90ZV9uYW1lKTsKLQlpZiAoIXJlbW90ZS0+dXJsWzBdKQotCQlkaWUoXygiUmVtb3RlIHdpdGggbm8gVVJMIikpOwotCXRyYW5zcG9ydCA9IHRyYW5zcG9ydF9nZXQocmVtb3RlLCByZW1vdGUtPnVybFswXSk7Ci0KLQl0cmFuc3BvcnRfc2V0X29wdGlvbih0cmFuc3BvcnQsIFRSQU5TX09QVF9GUk9NX1BST01JU09SLCAiMSIpOwotCXRyYW5zcG9ydF9zZXRfb3B0aW9uKHRyYW5zcG9ydCwgVFJBTlNfT1BUX05PX0RFUEVOREVOVFMsICIxIik7Ci0JdHJhbnNwb3J0X2ZldGNoX3JlZnModHJhbnNwb3J0LCByZWYpOwotCWZldGNoX2lmX21pc3NpbmcgPSBvcmlnaW5hbF9mZXRjaF9pZl9taXNzaW5nOwotfQotCi12b2lkIGZldGNoX29iamVjdHMoY29uc3QgY2hhciAqcmVtb3RlX25hbWUsIGNvbnN0IHN0cnVjdCBvYmplY3RfaWQgKm9pZHMsCi0JCSAgIGludCBvaWRfbnIpCi17Ci0Jc3RydWN0IHJlZiAqcmVmID0gTlVMTDsKLQlpbnQgaTsKLQotCWZvciAoaSA9IDA7IGkgPCBvaWRfbnI7IGkrKykgewotCQlzdHJ1Y3QgcmVmICpuZXdfcmVmID0gYWxsb2NfcmVmKG9pZF90b19oZXgoJm9pZHNbaV0pKTsKLQkJb2lkY3B5KCZuZXdfcmVmLT5vbGRfb2lkLCAmb2lkc1tpXSk7Ci0JCW5ld19yZWYtPmV4YWN0X29pZCA9IDE7Ci0JCW5ld19yZWYtPm5leHQgPSByZWY7Ci0JCXJlZiA9IG5ld19yZWY7Ci0JfQotCWZldGNoX3JlZnMocmVtb3RlX25hbWUsIHJlZik7Ci19CmRpZmYgLS1naXQgYS9mZXRjaC1vYmplY3QuaCBiL2ZldGNoLW9iamVjdC5oCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBkNjQ0NGNhLi4wMDAwMDAwCi0tLSBhL2ZldGNoLW9iamVjdC5oCisrKyAvZGV2L251bGwKQEAgLTEsOSArMCwwIEBACi0jaWZuZGVmIEZFVENIX09CSkVDVF9ICi0jZGVmaW5lIEZFVENIX09CSkVDVF9ICi0KLXN0cnVjdCBvYmplY3RfaWQ7Ci0KLXZvaWQgZmV0Y2hfb2JqZWN0cyhjb25zdCBjaGFyICpyZW1vdGVfbmFtZSwgY29uc3Qgc3RydWN0IG9iamVjdF9pZCAqb2lkcywKLQkJICAgaW50IG9pZF9ucik7Ci0KLSNlbmRpZgpkaWZmIC0tZ2l0IGEvZmV0Y2gtcGFjay5jIGIvZmV0Y2gtcGFjay5jCmluZGV4IDY1YmUwNDMuLjE3MzRhNTcgMTAwNjQ0Ci0tLSBhL2ZldGNoLXBhY2suYworKysgYi9mZXRjaC1wYWNrLmMKQEAgLTM2LDcgKzM2LDYgQEAKIHN0YXRpYyBpbnQgc2VydmVyX3N1cHBvcnRzX2ZpbHRlcmluZzsKIHN0YXRpYyBzdHJ1Y3QgbG9ja19maWxlIHNoYWxsb3dfbG9jazsKIHN0YXRpYyBjb25zdCBjaGFyICphbHRlcm5hdGVfc2hhbGxvd19maWxlOwotc3RhdGljIGNoYXIgKm5lZ290aWF0aW9uX2FsZ29yaXRobTsKIHN0YXRpYyBzdHJ1Y3Qgc3RyYnVmIGZzY2tfbXNnX3R5cGVzID0gU1RSQlVGX0lOSVQ7CiAKIC8qIFJlbWVtYmVyIHRvIHVwZGF0ZSBvYmplY3QgZmxhZyBhbGxvY2F0aW9uIGluIG9iamVjdC5oICovCkBAIC0xNjgsMTYgKzE2NywxNiBAQAogCWlmICghc3RyY21wKHJlYWRlci0+bGluZSwgIk5BSyIpKQogCQlyZXR1cm4gTkFLOwogCWlmIChza2lwX3ByZWZpeChyZWFkZXItPmxpbmUsICJBQ0sgIiwgJmFyZykpIHsKLQkJaWYgKCFnZXRfb2lkX2hleChhcmcsIHJlc3VsdF9vaWQpKSB7Ci0JCQlhcmcgKz0gNDA7Ci0JCQlsZW4gLT0gYXJnIC0gcmVhZGVyLT5saW5lOworCQljb25zdCBjaGFyICpwOworCQlpZiAoIXBhcnNlX29pZF9oZXgoYXJnLCByZXN1bHRfb2lkLCAmcCkpIHsKKwkJCWxlbiAtPSBwIC0gcmVhZGVyLT5saW5lOwogCQkJaWYgKGxlbiA8IDEpCiAJCQkJcmV0dXJuIEFDSzsKLQkJCWlmIChzdHJzdHIoYXJnLCAiY29udGludWUiKSkKKwkJCWlmIChzdHJzdHIocCwgImNvbnRpbnVlIikpCiAJCQkJcmV0dXJuIEFDS19jb250aW51ZTsKLQkJCWlmIChzdHJzdHIoYXJnLCAiY29tbW9uIikpCisJCQlpZiAoc3Ryc3RyKHAsICJjb21tb24iKSkKIAkJCQlyZXR1cm4gQUNLX2NvbW1vbjsKLQkJCWlmIChzdHJzdHIoYXJnLCAicmVhZHkiKSkKKwkJCWlmIChzdHJzdHIocCwgInJlYWR5IikpCiAJCQkJcmV0dXJuIEFDS19yZWFkeTsKIAkJCXJldHVybiBBQ0s7CiAJCX0KQEAgLTMzOSwxMiArMzM4LDkgQEAKIAkJfQogCX0KIAlpZiAoc2VydmVyX3N1cHBvcnRzX2ZpbHRlcmluZyAmJiBhcmdzLT5maWx0ZXJfb3B0aW9ucy5jaG9pY2UpIHsKLQkJc3RydWN0IHN0cmJ1ZiBleHBhbmRlZF9maWx0ZXJfc3BlYyA9IFNUUkJVRl9JTklUOwotCQlleHBhbmRfbGlzdF9vYmplY3RzX2ZpbHRlcl9zcGVjKCZhcmdzLT5maWx0ZXJfb3B0aW9ucywKLQkJCQkJCSZleHBhbmRlZF9maWx0ZXJfc3BlYyk7Ci0JCXBhY2tldF9idWZfd3JpdGUoJnJlcV9idWYsICJmaWx0ZXIgJXMiLAotCQkJCSBleHBhbmRlZF9maWx0ZXJfc3BlYy5idWYpOwotCQlzdHJidWZfcmVsZWFzZSgmZXhwYW5kZWRfZmlsdGVyX3NwZWMpOworCQljb25zdCBjaGFyICpzcGVjID0KKwkJCWV4cGFuZF9saXN0X29iamVjdHNfZmlsdGVyX3NwZWMoJmFyZ3MtPmZpbHRlcl9vcHRpb25zKTsKKwkJcGFja2V0X2J1Zl93cml0ZSgmcmVxX2J1ZiwgImZpbHRlciAlcyIsIHNwZWMpOwogCX0KIAlwYWNrZXRfYnVmX2ZsdXNoKCZyZXFfYnVmKTsKIAlzdGF0ZV9sZW4gPSByZXFfYnVmLmxlbjsKQEAgLTM4Niw2ICszODIsNyBAQAogCQlzdGF0ZV9sZW4gPSAwOwogCX0KIAorCXRyYWNlMl9yZWdpb25fZW50ZXIoImZldGNoLXBhY2siLCAibmVnb3RpYXRpb25fdjBfdjEiLCB0aGVfcmVwb3NpdG9yeSk7CiAJZmx1c2hlcyA9IDA7CiAJcmV0dmFsID0gLTE7CiAJaWYgKGFyZ3MtPm5vX2RlcGVuZGVudHMpCkBAIC00NzAsNiArNDY3LDcgQEAKIAkJfQogCX0KIGRvbmU6CisJdHJhY2UyX3JlZ2lvbl9sZWF2ZSgiZmV0Y2gtcGFjayIsICJuZWdvdGlhdGlvbl92MF92MSIsIHRoZV9yZXBvc2l0b3J5KTsKIAlpZiAoIWdvdF9yZWFkeSB8fCAhbm9fZG9uZSkgewogCQlwYWNrZXRfYnVmX3dyaXRlKCZyZXFfYnVmLCAiZG9uZVxuIik7CiAJCXNlbmRfcmVxdWVzdChhcmdzLCBmZFsxXSwgJnJlcV9idWYpOwpAQCAtNjcxLDE3ICs2NjksMjAgQEAKIAogCXNhdmVfY29tbWl0X2J1ZmZlciA9IDA7CiAKKwl0cmFjZTJfcmVnaW9uX2VudGVyKCJmZXRjaC1wYWNrIiwgInBhcnNlX3JlbW90ZV9yZWZzX2FuZF9maW5kX2N1dG9mZiIsIE5VTEwpOwogCWZvciAocmVmID0gKnJlZnM7IHJlZjsgcmVmID0gcmVmLT5uZXh0KSB7CiAJCXN0cnVjdCBvYmplY3QgKm87CiAKIAkJaWYgKCFoYXNfb2JqZWN0X2ZpbGVfd2l0aF9mbGFncygmcmVmLT5vbGRfb2lkLAotCQkJCQkJT0JKRUNUX0lORk9fUVVJQ0spKQorCQkJCQkJT0JKRUNUX0lORk9fUVVJQ0sgfAorCQkJCQkJCU9CSkVDVF9JTkZPX1NLSVBfRkVUQ0hfT0JKRUNUKSkKIAkJCWNvbnRpbnVlOwogCQlvID0gcGFyc2Vfb2JqZWN0KHRoZV9yZXBvc2l0b3J5LCAmcmVmLT5vbGRfb2lkKTsKIAkJaWYgKCFvKQogCQkJY29udGludWU7CiAKLQkJLyogV2UgYWxyZWFkeSBoYXZlIGl0IC0tIHdoaWNoIG1heSBtZWFuIHRoYXQgd2Ugd2VyZQorCQkvKgorCQkgKiBXZSBhbHJlYWR5IGhhdmUgaXQgLS0gd2hpY2ggbWF5IG1lYW4gdGhhdCB3ZSB3ZXJlCiAJCSAqIGluIHN5bmMgd2l0aCB0aGUgb3RoZXIgc2lkZSBhdCBzb21lIHRpbWUgYWZ0ZXIKIAkJICogdGhhdCAoaXQgaXMgT0sgaWYgd2UgZ3Vlc3Mgd3JvbmcgaGVyZSkuCiAJCSAqLwpAQCAtNjkxLDcgKzY5MiwxMyBAQAogCQkJCWN1dG9mZiA9IGNvbW1pdC0+ZGF0ZTsKIAkJfQogCX0KKwl0cmFjZTJfcmVnaW9uX2xlYXZlKCJmZXRjaC1wYWNrIiwgInBhcnNlX3JlbW90ZV9yZWZzX2FuZF9maW5kX2N1dG9mZiIsIE5VTEwpOwogCisJLyoKKwkgKiBUaGlzIGJsb2NrIG1hcmtzIGFsbCBsb2NhbCByZWZzIGFzIENPTVBMRVRFLCBhbmQgdGhlbiByZWN1cnNpdmVseSBtYXJrcyBhbGwKKwkgKiBwYXJlbnRzIG9mIHRob3NlIHJlZnMgYXMgQ09NUExFVEUuCisJICovCisJdHJhY2UyX3JlZ2lvbl9lbnRlcigiZmV0Y2gtcGFjayIsICJtYXJrX2NvbXBsZXRlX2xvY2FsX3JlZnMiLCBOVUxMKTsKIAlpZiAoIWFyZ3MtPmRlZXBlbikgewogCQlmb3JfZWFjaF9yZWYobWFya19jb21wbGV0ZV9vaWQsIE5VTEwpOwogCQlmb3JfZWFjaF9jYWNoZWRfYWx0ZXJuYXRlKE5VTEwsIG1hcmtfYWx0ZXJuYXRlX2NvbXBsZXRlKTsKQEAgLTY5OSwxMSArNzA2LDEzIEBACiAJCWlmIChjdXRvZmYpCiAJCQltYXJrX3JlY2VudF9jb21wbGV0ZV9jb21taXRzKGFyZ3MsIGN1dG9mZik7CiAJfQorCXRyYWNlMl9yZWdpb25fbGVhdmUoImZldGNoLXBhY2siLCAibWFya19jb21wbGV0ZV9sb2NhbF9yZWZzIiwgTlVMTCk7CiAKIAkvKgogCSAqIE1hcmsgYWxsIGNvbXBsZXRlIHJlbW90ZSByZWZzIGFzIGNvbW1vbiByZWZzLgogCSAqIERvbid0IG1hcmsgdGhlbSBjb21tb24geWV0OyB0aGUgc2VydmVyIGhhcyB0byBiZSB0b2xkIHNvIGZpcnN0LgogCSAqLworCXRyYWNlMl9yZWdpb25fZW50ZXIoImZldGNoLXBhY2siLCAibWFya19jb21tb25fcmVtb3RlX3JlZnMiLCBOVUxMKTsKIAlmb3IgKHJlZiA9ICpyZWZzOyByZWY7IHJlZiA9IHJlZi0+bmV4dCkgewogCQlzdHJ1Y3Qgb2JqZWN0ICpvID0gZGVyZWZfdGFnKHRoZV9yZXBvc2l0b3J5LAogCQkJCQkgICAgIGxvb2t1cF9vYmplY3QodGhlX3JlcG9zaXRvcnksCkBAIC03MTYsNiArNzI1LDcgQEAKIAkJbmVnb3RpYXRvci0+a25vd25fY29tbW9uKG5lZ290aWF0b3IsCiAJCQkJCSAoc3RydWN0IGNvbW1pdCAqKW8pOwogCX0KKwl0cmFjZTJfcmVnaW9uX2xlYXZlKCJmZXRjaC1wYWNrIiwgIm1hcmtfY29tbW9uX3JlbW90ZV9yZWZzIiwgTlVMTCk7CiAKIAlzYXZlX2NvbW1pdF9idWZmZXIgPSBvbGRfc2F2ZV9jb21taXRfYnVmZmVyOwogfQpAQCAtNzU4LDggKzc2OCwzMyBAQAogCXJldHVybiByZXQ7CiB9CiAKK3N0YXRpYyB2b2lkIHdyaXRlX3Byb21pc29yX2ZpbGUoY29uc3QgY2hhciAqa2VlcF9uYW1lLAorCQkJCXN0cnVjdCByZWYgKipzb3VnaHQsIGludCBucl9zb3VnaHQpCit7CisJc3RydWN0IHN0cmJ1ZiBwcm9taXNvcl9uYW1lID0gU1RSQlVGX0lOSVQ7CisJaW50IHN1ZmZpeF9zdHJpcHBlZDsKKwlGSUxFICpvdXRwdXQ7CisJaW50IGk7CisKKwlzdHJidWZfYWRkc3RyKCZwcm9taXNvcl9uYW1lLCBrZWVwX25hbWUpOworCXN1ZmZpeF9zdHJpcHBlZCA9IHN0cmJ1Zl9zdHJpcF9zdWZmaXgoJnByb21pc29yX25hbWUsICIua2VlcCIpOworCWlmICghc3VmZml4X3N0cmlwcGVkKQorCQlCVUcoIm5hbWUgb2YgcGFjayBsb2NrZmlsZSBzaG91bGQgZW5kIHdpdGggLmtlZXAgKHdhcyAnJXMnKSIsCisJCSAgICBrZWVwX25hbWUpOworCXN0cmJ1Zl9hZGRzdHIoJnByb21pc29yX25hbWUsICIucHJvbWlzb3IiKTsKKworCW91dHB1dCA9IHhmb3Blbihwcm9taXNvcl9uYW1lLmJ1ZiwgInciKTsKKwlmb3IgKGkgPSAwOyBpIDwgbnJfc291Z2h0OyBpKyspCisJCWZwcmludGYob3V0cHV0LCAiJXMgJXNcbiIsIG9pZF90b19oZXgoJnNvdWdodFtpXS0+b2xkX29pZCksCisJCQlzb3VnaHRbaV0tPm5hbWUpOworCWZjbG9zZShvdXRwdXQpOworCisJc3RyYnVmX3JlbGVhc2UoJnByb21pc29yX25hbWUpOworfQorCiBzdGF0aWMgaW50IGdldF9wYWNrKHN0cnVjdCBmZXRjaF9wYWNrX2FyZ3MgKmFyZ3MsCi0JCSAgICBpbnQgeGRbMl0sIGNoYXIgKipwYWNrX2xvY2tmaWxlKQorCQkgICAgaW50IHhkWzJdLCBjaGFyICoqcGFja19sb2NrZmlsZSwKKwkJICAgIHN0cnVjdCByZWYgKipzb3VnaHQsIGludCBucl9zb3VnaHQpCiB7CiAJc3RydWN0IGFzeW5jIGRlbXV4OwogCWludCBkb19rZWVwID0gYXJncy0+a2VlcF9wYWNrOwpAQCAtODIxLDcgKzg1NiwxMyBAQAogCQl9CiAJCWlmIChhcmdzLT5jaGVja19zZWxmX2NvbnRhaW5lZF9hbmRfY29ubmVjdGVkKQogCQkJYXJndl9hcnJheV9wdXNoKCZjbWQuYXJncywgIi0tY2hlY2stc2VsZi1jb250YWluZWQtYW5kLWNvbm5lY3RlZCIpOwotCQlpZiAoYXJncy0+ZnJvbV9wcm9taXNvcikKKwkJLyoKKwkJICogSWYgd2UncmUgb2J0YWluaW5nIHRoZSBmaWxlbmFtZSBvZiBhIGxvY2tmaWxlLCB3ZSdsbCB1c2UKKwkJICogdGhhdCBmaWxlbmFtZSB0byB3cml0ZSBhIC5wcm9taXNvciBmaWxlIHdpdGggbW9yZQorCQkgKiBpbmZvcm1hdGlvbiBiZWxvdy4gSWYgbm90LCB3ZSBuZWVkIGluZGV4LXBhY2sgdG8gZG8gaXQgZm9yCisJCSAqIHVzLgorCQkgKi8KKwkJaWYgKCEoZG9fa2VlcCAmJiBwYWNrX2xvY2tmaWxlKSAmJiBhcmdzLT5mcm9tX3Byb21pc29yKQogCQkJYXJndl9hcnJheV9wdXNoKCZjbWQuYXJncywgIi0tcHJvbWlzb3IiKTsKIAl9CiAJZWxzZSB7CkBAIC04NzUsNiArOTE2LDE0IEBACiAJCWRpZShfKCIlcyBmYWlsZWQiKSwgY21kX25hbWUpOwogCWlmICh1c2Vfc2lkZWJhbmQgJiYgZmluaXNoX2FzeW5jKCZkZW11eCkpCiAJCWRpZShfKCJlcnJvciBpbiBzaWRlYmFuZCBkZW11bHRpcGxleGVyIikpOworCisJLyoKKwkgKiBOb3cgdGhhdCBpbmRleC1wYWNrIGhhcyBzdWNjZWVkZWQsIHdyaXRlIHRoZSBwcm9taXNvciBmaWxlIHVzaW5nIHRoZQorCSAqIG9idGFpbmVkIC5rZWVwIGZpbGVuYW1lIGlmIG5lY2Vzc2FyeQorCSAqLworCWlmIChkb19rZWVwICYmIHBhY2tfbG9ja2ZpbGUgJiYgYXJncy0+ZnJvbV9wcm9taXNvcikKKwkJd3JpdGVfcHJvbWlzb3JfZmlsZSgqcGFja19sb2NrZmlsZSwgc291Z2h0LCBucl9zb3VnaHQpOworCiAJcmV0dXJuIDA7CiB9CiAKQEAgLTg5MiwxMiArOTQxLDIwIEBACiAJCQkJIHN0cnVjdCBzaGFsbG93X2luZm8gKnNpLAogCQkJCSBjaGFyICoqcGFja19sb2NrZmlsZSkKIHsKKwlzdHJ1Y3QgcmVwb3NpdG9yeSAqciA9IHRoZV9yZXBvc2l0b3J5OwogCXN0cnVjdCByZWYgKnJlZiA9IGNvcHlfcmVmX2xpc3Qob3JpZ19yZWYpOwogCXN0cnVjdCBvYmplY3RfaWQgb2lkOwogCWNvbnN0IGNoYXIgKmFnZW50X2ZlYXR1cmU7CiAJaW50IGFnZW50X2xlbjsKLQlzdHJ1Y3QgZmV0Y2hfbmVnb3RpYXRvciBuZWdvdGlhdG9yOwotCWZldGNoX25lZ290aWF0b3JfaW5pdCgmbmVnb3RpYXRvciwgbmVnb3RpYXRpb25fYWxnb3JpdGhtKTsKKwlzdHJ1Y3QgZmV0Y2hfbmVnb3RpYXRvciBuZWdvdGlhdG9yX2FsbG9jOworCXN0cnVjdCBmZXRjaF9uZWdvdGlhdG9yICpuZWdvdGlhdG9yOworCisJaWYgKGFyZ3MtPm5vX2RlcGVuZGVudHMpIHsKKwkJbmVnb3RpYXRvciA9IE5VTEw7CisJfSBlbHNlIHsKKwkJbmVnb3RpYXRvciA9ICZuZWdvdGlhdG9yX2FsbG9jOworCQlmZXRjaF9uZWdvdGlhdG9yX2luaXQociwgbmVnb3RpYXRvcik7CisJfQogCiAJc29ydF9yZWZfbGlzdCgmcmVmLCByZWZfY29tcGFyZV9uYW1lKTsKIAlRU09SVChzb3VnaHQsIG5yX3NvdWdodCwgY21wX3JlZl9ieV9uYW1lKTsKQEAgLTkxMSw3ICs5NjgsNyBAQAogCiAJaWYgKHNlcnZlcl9zdXBwb3J0cygic2hhbGxvdyIpKQogCQlwcmludF92ZXJib3NlKGFyZ3MsIF8oIlNlcnZlciBzdXBwb3J0cyAlcyIpLCAic2hhbGxvdyIpOwotCWVsc2UgaWYgKGFyZ3MtPmRlcHRoID4gMCB8fCBpc19yZXBvc2l0b3J5X3NoYWxsb3codGhlX3JlcG9zaXRvcnkpKQorCWVsc2UgaWYgKGFyZ3MtPmRlcHRoID4gMCB8fCBpc19yZXBvc2l0b3J5X3NoYWxsb3cocikpCiAJCWRpZShfKCJTZXJ2ZXIgZG9lcyBub3Qgc3VwcG9ydCBzaGFsbG93IGNsaWVudHMiKSk7CiAJaWYgKGFyZ3MtPmRlcHRoID4gMCB8fCBhcmdzLT5kZWVwZW5fc2luY2UgfHwgYXJncy0+ZGVlcGVuX25vdCkKIAkJYXJncy0+ZGVlcGVuID0gMTsKQEAgLTk4NCw3ICsxMDQxLDcgQEAKIAkJZGllKF8oIlNlcnZlciBkb2VzIG5vdCBzdXBwb3J0IC0tZGVlcGVuIikpOwogCiAJaWYgKCFhcmdzLT5ub19kZXBlbmRlbnRzKSB7Ci0JCW1hcmtfY29tcGxldGVfYW5kX2NvbW1vbl9yZWYoJm5lZ290aWF0b3IsIGFyZ3MsICZyZWYpOworCQltYXJrX2NvbXBsZXRlX2FuZF9jb21tb25fcmVmKG5lZ290aWF0b3IsIGFyZ3MsICZyZWYpOwogCQlmaWx0ZXJfcmVmcyhhcmdzLCAmcmVmLCBzb3VnaHQsIG5yX3NvdWdodCk7CiAJCWlmIChldmVyeXRoaW5nX2xvY2FsKGFyZ3MsICZyZWYpKSB7CiAJCQlwYWNrZXRfZmx1c2goZmRbMV0pOwpAQCAtOTkzLDcgKzEwNTAsNyBAQAogCX0gZWxzZSB7CiAJCWZpbHRlcl9yZWZzKGFyZ3MsICZyZWYsIHNvdWdodCwgbnJfc291Z2h0KTsKIAl9Ci0JaWYgKGZpbmRfY29tbW9uKCZuZWdvdGlhdG9yLCBhcmdzLCBmZCwgJm9pZCwgcmVmKSA8IDApCisJaWYgKGZpbmRfY29tbW9uKG5lZ290aWF0b3IsIGFyZ3MsIGZkLCAmb2lkLCByZWYpIDwgMCkKIAkJaWYgKCFhcmdzLT5rZWVwX3BhY2spCiAJCQkvKiBXaGVuIGNsb25pbmcsIGl0IGlzIG5vdCB1bnVzdWFsIHRvIGhhdmUKIAkJCSAqIG5vIGNvbW1vbiBjb21taXQuCkBAIC0xMDA5LDExICsxMDY2LDEyIEBACiAJCWFsdGVybmF0ZV9zaGFsbG93X2ZpbGUgPSBzZXR1cF90ZW1wb3Jhcnlfc2hhbGxvdyhzaS0+c2hhbGxvdyk7CiAJZWxzZQogCQlhbHRlcm5hdGVfc2hhbGxvd19maWxlID0gTlVMTDsKLQlpZiAoZ2V0X3BhY2soYXJncywgZmQsIHBhY2tfbG9ja2ZpbGUpKQorCWlmIChnZXRfcGFjayhhcmdzLCBmZCwgcGFja19sb2NrZmlsZSwgc291Z2h0LCBucl9zb3VnaHQpKQogCQlkaWUoXygiZ2l0IGZldGNoLXBhY2s6IGZldGNoIGZhaWxlZC4iKSk7CiAKICBhbGxfZG9uZToKLQluZWdvdGlhdG9yLnJlbGVhc2UoJm5lZ290aWF0b3IpOworCWlmIChuZWdvdGlhdG9yKQorCQluZWdvdGlhdG9yLT5yZWxlYXNlKG5lZ290aWF0b3IpOwogCXJldHVybiByZWY7CiB9CiAKQEAgLTExMTIsNyArMTE3MCw3IEBACiB9CiAKIHN0YXRpYyBpbnQgc2VuZF9mZXRjaF9yZXF1ZXN0KHN0cnVjdCBmZXRjaF9uZWdvdGlhdG9yICpuZWdvdGlhdG9yLCBpbnQgZmRfb3V0LAotCQkJICAgICAgY29uc3Qgc3RydWN0IGZldGNoX3BhY2tfYXJncyAqYXJncywKKwkJCSAgICAgIHN0cnVjdCBmZXRjaF9wYWNrX2FyZ3MgKmFyZ3MsCiAJCQkgICAgICBjb25zdCBzdHJ1Y3QgcmVmICp3YW50cywgc3RydWN0IG9pZHNldCAqY29tbW9uLAogCQkJICAgICAgaW50ICpoYXZlc190b19zZW5kLCBpbnQgKmluX3ZhaW4sCiAJCQkgICAgICBpbnQgc2lkZWJhbmRfYWxsKQpAQCAtMTE1MywxMyArMTIxMSwxMCBAQAogCS8qIEFkZCBmaWx0ZXIgKi8KIAlpZiAoc2VydmVyX3N1cHBvcnRzX2ZlYXR1cmUoImZldGNoIiwgImZpbHRlciIsIDApICYmCiAJICAgIGFyZ3MtPmZpbHRlcl9vcHRpb25zLmNob2ljZSkgewotCQlzdHJ1Y3Qgc3RyYnVmIGV4cGFuZGVkX2ZpbHRlcl9zcGVjID0gU1RSQlVGX0lOSVQ7CisJCWNvbnN0IGNoYXIgKnNwZWMgPQorCQkJZXhwYW5kX2xpc3Rfb2JqZWN0c19maWx0ZXJfc3BlYygmYXJncy0+ZmlsdGVyX29wdGlvbnMpOwogCQlwcmludF92ZXJib3NlKGFyZ3MsIF8oIlNlcnZlciBzdXBwb3J0cyBmaWx0ZXIiKSk7Ci0JCWV4cGFuZF9saXN0X29iamVjdHNfZmlsdGVyX3NwZWMoJmFyZ3MtPmZpbHRlcl9vcHRpb25zLAotCQkJCQkJJmV4cGFuZGVkX2ZpbHRlcl9zcGVjKTsKLQkJcGFja2V0X2J1Zl93cml0ZSgmcmVxX2J1ZiwgImZpbHRlciAlcyIsCi0JCQkJIGV4cGFuZGVkX2ZpbHRlcl9zcGVjLmJ1Zik7Ci0JCXN0cmJ1Zl9yZWxlYXNlKCZleHBhbmRlZF9maWx0ZXJfc3BlYyk7CisJCXBhY2tldF9idWZfd3JpdGUoJnJlcV9idWYsICJmaWx0ZXIgJXMiLCBzcGVjKTsKIAl9IGVsc2UgaWYgKGFyZ3MtPmZpbHRlcl9vcHRpb25zLmNob2ljZSkgewogCQl3YXJuaW5nKCJmaWx0ZXJpbmcgbm90IHJlY29nbml6ZWQgYnkgc2VydmVyLCBpZ25vcmluZyIpOwogCX0KQEAgLTEyMzQsNyArMTI4OSw4IEBACiAJCQkJc3RydWN0IGNvbW1pdCAqY29tbWl0OwogCQkJCW9pZHNldF9pbnNlcnQoY29tbW9uLCAmb2lkKTsKIAkJCQljb21taXQgPSBsb29rdXBfY29tbWl0KHRoZV9yZXBvc2l0b3J5LCAmb2lkKTsKLQkJCQluZWdvdGlhdG9yLT5hY2sobmVnb3RpYXRvciwgY29tbWl0KTsKKwkJCQlpZiAobmVnb3RpYXRvcikKKwkJCQkJbmVnb3RpYXRvci0+YWNrKG5lZ290aWF0b3IsIGNvbW1pdCk7CiAJCQl9CiAJCQljb250aW51ZTsKIAkJfQpAQCAtMTM3OSwxNCArMTQzNSwyMyBAQAogCQkJCSAgICBzdHJ1Y3Qgc2hhbGxvd19pbmZvICpzaSwKIAkJCQkgICAgY2hhciAqKnBhY2tfbG9ja2ZpbGUpCiB7CisJc3RydWN0IHJlcG9zaXRvcnkgKnIgPSB0aGVfcmVwb3NpdG9yeTsKIAlzdHJ1Y3QgcmVmICpyZWYgPSBjb3B5X3JlZl9saXN0KG9yaWdfcmVmKTsKIAllbnVtIGZldGNoX3N0YXRlIHN0YXRlID0gRkVUQ0hfQ0hFQ0tfTE9DQUw7CiAJc3RydWN0IG9pZHNldCBjb21tb24gPSBPSURTRVRfSU5JVDsKIAlzdHJ1Y3QgcGFja2V0X3JlYWRlciByZWFkZXI7Ci0JaW50IGluX3ZhaW4gPSAwOworCWludCBpbl92YWluID0gMCwgbmVnb3RpYXRpb25fc3RhcnRlZCA9IDA7CiAJaW50IGhhdmVzX3RvX3NlbmQgPSBJTklUSUFMX0ZMVVNIOwotCXN0cnVjdCBmZXRjaF9uZWdvdGlhdG9yIG5lZ290aWF0b3I7Ci0JZmV0Y2hfbmVnb3RpYXRvcl9pbml0KCZuZWdvdGlhdG9yLCBuZWdvdGlhdGlvbl9hbGdvcml0aG0pOworCXN0cnVjdCBmZXRjaF9uZWdvdGlhdG9yIG5lZ290aWF0b3JfYWxsb2M7CisJc3RydWN0IGZldGNoX25lZ290aWF0b3IgKm5lZ290aWF0b3I7CisKKwlpZiAoYXJncy0+bm9fZGVwZW5kZW50cykgeworCQluZWdvdGlhdG9yID0gTlVMTDsKKwl9IGVsc2UgeworCQluZWdvdGlhdG9yID0gJm5lZ290aWF0b3JfYWxsb2M7CisJCWZldGNoX25lZ290aWF0b3JfaW5pdChyLCBuZWdvdGlhdG9yKTsKKwl9CisKIAlwYWNrZXRfcmVhZGVyX2luaXQoJnJlYWRlciwgZmRbMF0sIE5VTEwsIDAsCiAJCQkgICBQQUNLRVRfUkVBRF9DSE9NUF9ORVdMSU5FIHwKIAkJCSAgIFBBQ0tFVF9SRUFEX0RJRV9PTl9FUlJfUEFDS0VUKTsKQEAgLTE0MTAsMTUgKzE0NzUsMTUgQEAKIAogCQkJLyogRmlsdGVyICdyZWYnIGJ5ICdzb3VnaHQnIGFuZCB0aG9zZSB0aGF0IGFyZW4ndCBsb2NhbCAqLwogCQkJaWYgKCFhcmdzLT5ub19kZXBlbmRlbnRzKSB7Ci0JCQkJbWFya19jb21wbGV0ZV9hbmRfY29tbW9uX3JlZigmbmVnb3RpYXRvciwgYXJncywgJnJlZik7CisJCQkJbWFya19jb21wbGV0ZV9hbmRfY29tbW9uX3JlZihuZWdvdGlhdG9yLCBhcmdzLCAmcmVmKTsKIAkJCQlmaWx0ZXJfcmVmcyhhcmdzLCAmcmVmLCBzb3VnaHQsIG5yX3NvdWdodCk7CiAJCQkJaWYgKGV2ZXJ5dGhpbmdfbG9jYWwoYXJncywgJnJlZikpCiAJCQkJCXN0YXRlID0gRkVUQ0hfRE9ORTsKIAkJCQllbHNlCiAJCQkJCXN0YXRlID0gRkVUQ0hfU0VORF9SRVFVRVNUOwogCi0JCQkJbWFya190aXBzKCZuZWdvdGlhdG9yLCBhcmdzLT5uZWdvdGlhdGlvbl90aXBzKTsKLQkJCQlmb3JfZWFjaF9jYWNoZWRfYWx0ZXJuYXRlKCZuZWdvdGlhdG9yLAorCQkJCW1hcmtfdGlwcyhuZWdvdGlhdG9yLCBhcmdzLT5uZWdvdGlhdGlvbl90aXBzKTsKKwkJCQlmb3JfZWFjaF9jYWNoZWRfYWx0ZXJuYXRlKG5lZ290aWF0b3IsCiAJCQkJCQkJICBpbnNlcnRfb25lX2FsdGVybmF0ZV9vYmplY3QpOwogCQkJfSBlbHNlIHsKIAkJCQlmaWx0ZXJfcmVmcyhhcmdzLCAmcmVmLCBzb3VnaHQsIG5yX3NvdWdodCk7CkBAIC0xNDI2LDcgKzE0OTEsMTMgQEAKIAkJCX0KIAkJCWJyZWFrOwogCQljYXNlIEZFVENIX1NFTkRfUkVRVUVTVDoKLQkJCWlmIChzZW5kX2ZldGNoX3JlcXVlc3QoJm5lZ290aWF0b3IsIGZkWzFdLCBhcmdzLCByZWYsCisJCQlpZiAoIW5lZ290aWF0aW9uX3N0YXJ0ZWQpIHsKKwkJCQluZWdvdGlhdGlvbl9zdGFydGVkID0gMTsKKwkJCQl0cmFjZTJfcmVnaW9uX2VudGVyKCJmZXRjaC1wYWNrIiwKKwkJCQkJCSAgICAibmVnb3RpYXRpb25fdjIiLAorCQkJCQkJICAgIHRoZV9yZXBvc2l0b3J5KTsKKwkJCX0KKwkJCWlmIChzZW5kX2ZldGNoX3JlcXVlc3QobmVnb3RpYXRvciwgZmRbMV0sIGFyZ3MsIHJlZiwKIAkJCQkJICAgICAgICZjb21tb24sCiAJCQkJCSAgICAgICAmaGF2ZXNfdG9fc2VuZCwgJmluX3ZhaW4sCiAJCQkJCSAgICAgICByZWFkZXIudXNlX3NpZGViYW5kKSkKQEAgLTE0MzYsNyArMTUwNyw3IEBACiAJCQlicmVhazsKIAkJY2FzZSBGRVRDSF9QUk9DRVNTX0FDS1M6CiAJCQkvKiBQcm9jZXNzIEFDS3MvTkFLcyAqLwotCQkJc3dpdGNoIChwcm9jZXNzX2Fja3MoJm5lZ290aWF0b3IsICZyZWFkZXIsICZjb21tb24pKSB7CisJCQlzd2l0Y2ggKHByb2Nlc3NfYWNrcyhuZWdvdGlhdG9yLCAmcmVhZGVyLCAmY29tbW9uKSkgewogCQkJY2FzZSAyOgogCQkJCXN0YXRlID0gRkVUQ0hfR0VUX1BBQ0s7CiAJCQkJYnJlYWs7CkBAIC0xNDQ5LDYgKzE1MjAsOSBAQAogCQkJfQogCQkJYnJlYWs7CiAJCWNhc2UgRkVUQ0hfR0VUX1BBQ0s6CisJCQl0cmFjZTJfcmVnaW9uX2xlYXZlKCJmZXRjaC1wYWNrIiwKKwkJCQkJICAgICJuZWdvdGlhdGlvbl92MiIsCisJCQkJCSAgICB0aGVfcmVwb3NpdG9yeSk7CiAJCQkvKiBDaGVjayBmb3Igc2hhbGxvdy1pbmZvIHNlY3Rpb24gKi8KIAkJCWlmIChwcm9jZXNzX3NlY3Rpb25faGVhZGVyKCZyZWFkZXIsICJzaGFsbG93LWluZm8iLCAxKSkKIAkJCQlyZWNlaXZlX3NoYWxsb3dfaW5mbyhhcmdzLCAmcmVhZGVyLCBzaGFsbG93cywgc2kpOwpAQCAtMTQ1OCw3ICsxNTMyLDcgQEAKIAogCQkJLyogZ2V0IHRoZSBwYWNrICovCiAJCQlwcm9jZXNzX3NlY3Rpb25faGVhZGVyKCZyZWFkZXIsICJwYWNrZmlsZSIsIDApOwotCQkJaWYgKGdldF9wYWNrKGFyZ3MsIGZkLCBwYWNrX2xvY2tmaWxlKSkKKwkJCWlmIChnZXRfcGFjayhhcmdzLCBmZCwgcGFja19sb2NrZmlsZSwgc291Z2h0LCBucl9zb3VnaHQpKQogCQkJCWRpZShfKCJnaXQgZmV0Y2gtcGFjazogZmV0Y2ggZmFpbGVkLiIpKTsKIAogCQkJc3RhdGUgPSBGRVRDSF9ET05FOwpAQCAtMTQ2OCw3ICsxNTQyLDggQEAKIAkJfQogCX0KIAotCW5lZ290aWF0b3IucmVsZWFzZSgmbmVnb3RpYXRvcik7CisJaWYgKG5lZ290aWF0b3IpCisJCW5lZ290aWF0b3ItPnJlbGVhc2UobmVnb3RpYXRvcik7CiAJb2lkc2V0X2NsZWFyKCZjb21tb24pOwogCXJldHVybiByZWY7CiB9CkBAIC0xNTA1LDggKzE1ODAsNiBAQAogCWdpdF9jb25maWdfZ2V0X2Jvb2woInJlcGFjay51c2VkZWx0YWJhc2VvZmZzZXQiLCAmcHJlZmVyX29mc19kZWx0YSk7CiAJZ2l0X2NvbmZpZ19nZXRfYm9vbCgiZmV0Y2guZnNja29iamVjdHMiLCAmZmV0Y2hfZnNja19vYmplY3RzKTsKIAlnaXRfY29uZmlnX2dldF9ib29sKCJ0cmFuc2Zlci5mc2Nrb2JqZWN0cyIsICZ0cmFuc2Zlcl9mc2NrX29iamVjdHMpOwotCWdpdF9jb25maWdfZ2V0X3N0cmluZygiZmV0Y2gubmVnb3RpYXRpb25hbGdvcml0aG0iLAotCQkJICAgICAgJm5lZ290aWF0aW9uX2FsZ29yaXRobSk7CiAKIAlnaXRfY29uZmlnKGZldGNoX3BhY2tfY29uZmlnX2NiLCBOVUxMKTsKIH0KZGlmZiAtLWdpdCBhL2ZzY2suYyBiL2ZzY2suYwppbmRleCBjZGI3ZDhkLi5hYzRiYTRjIDEwMDY0NAotLS0gYS9mc2NrLmMKKysrIGIvZnNjay5jCkBAIC00MywyMSArNDMsMTcgQEAKIAlGVU5DKE1JU1NJTkdfQVVUSE9SLCBFUlJPUikgXAogCUZVTkMoTUlTU0lOR19DT01NSVRURVIsIEVSUk9SKSBcCiAJRlVOQyhNSVNTSU5HX0VNQUlMLCBFUlJPUikgXAotCUZVTkMoTUlTU0lOR19HUkFGVCwgRVJST1IpIFwKIAlGVU5DKE1JU1NJTkdfTkFNRV9CRUZPUkVfRU1BSUwsIEVSUk9SKSBcCiAJRlVOQyhNSVNTSU5HX09CSkVDVCwgRVJST1IpIFwKLQlGVU5DKE1JU1NJTkdfUEFSRU5ULCBFUlJPUikgXAogCUZVTkMoTUlTU0lOR19TUEFDRV9CRUZPUkVfREFURSwgRVJST1IpIFwKIAlGVU5DKE1JU1NJTkdfU1BBQ0VfQkVGT1JFX0VNQUlMLCBFUlJPUikgXAogCUZVTkMoTUlTU0lOR19UQUcsIEVSUk9SKSBcCiAJRlVOQyhNSVNTSU5HX1RBR19FTlRSWSwgRVJST1IpIFwKLQlGVU5DKE1JU1NJTkdfVEFHX09CSkVDVCwgRVJST1IpIFwKIAlGVU5DKE1JU1NJTkdfVFJFRSwgRVJST1IpIFwKIAlGVU5DKE1JU1NJTkdfVFJFRV9PQkpFQ1QsIEVSUk9SKSBcCiAJRlVOQyhNSVNTSU5HX1RZUEUsIEVSUk9SKSBcCiAJRlVOQyhNSVNTSU5HX1RZUEVfRU5UUlksIEVSUk9SKSBcCiAJRlVOQyhNVUxUSVBMRV9BVVRIT1JTLCBFUlJPUikgXAotCUZVTkMoVEFHX09CSkVDVF9OT1RfVEFHLCBFUlJPUikgXAogCUZVTkMoVFJFRV9OT1RfU09SVEVELCBFUlJPUikgXAogCUZVTkMoVU5LTk9XTl9UWVBFLCBFUlJPUikgXAogCUZVTkMoWkVST19QQURERURfREFURSwgRVJST1IpIFwKQEAgLTI4MSwxNCArMjc3LDE2IEBACiAJc3RyYnVmX2FkZHN0cihzYiwgIjogIik7CiB9CiAKLXN0YXRpYyBpbnQgb2JqZWN0X29uX3NraXBsaXN0KHN0cnVjdCBmc2NrX29wdGlvbnMgKm9wdHMsIHN0cnVjdCBvYmplY3QgKm9iaikKK3N0YXRpYyBpbnQgb2JqZWN0X29uX3NraXBsaXN0KHN0cnVjdCBmc2NrX29wdGlvbnMgKm9wdHMsCisJCQkgICAgICBjb25zdCBzdHJ1Y3Qgb2JqZWN0X2lkICpvaWQpCiB7Ci0JcmV0dXJuIG9wdHMgJiYgb2JqICYmIG9pZHNldF9jb250YWlucygmb3B0cy0+c2tpcGxpc3QsICZvYmotPm9pZCk7CisJcmV0dXJuIG9wdHMgJiYgb2lkICYmIG9pZHNldF9jb250YWlucygmb3B0cy0+c2tpcGxpc3QsIG9pZCk7CiB9CiAKLV9fYXR0cmlidXRlX18oKGZvcm1hdCAocHJpbnRmLCA0LCA1KSkpCi1zdGF0aWMgaW50IHJlcG9ydChzdHJ1Y3QgZnNja19vcHRpb25zICpvcHRpb25zLCBzdHJ1Y3Qgb2JqZWN0ICpvYmplY3QsCi0JZW51bSBmc2NrX21zZ19pZCBpZCwgY29uc3QgY2hhciAqZm10LCAuLi4pCitfX2F0dHJpYnV0ZV9fKChmb3JtYXQgKHByaW50ZiwgNSwgNikpKQorc3RhdGljIGludCByZXBvcnQoc3RydWN0IGZzY2tfb3B0aW9ucyAqb3B0aW9ucywKKwkJICBjb25zdCBzdHJ1Y3Qgb2JqZWN0X2lkICpvaWQsIGVudW0gb2JqZWN0X3R5cGUgb2JqZWN0X3R5cGUsCisJCSAgZW51bSBmc2NrX21zZ19pZCBpZCwgY29uc3QgY2hhciAqZm10LCAuLi4pCiB7CiAJdmFfbGlzdCBhcDsKIAlzdHJ1Y3Qgc3RyYnVmIHNiID0gU1RSQlVGX0lOSVQ7CkBAIC0yOTcsNyArMjk1LDcgQEAKIAlpZiAobXNnX3R5cGUgPT0gRlNDS19JR05PUkUpCiAJCXJldHVybiAwOwogCi0JaWYgKG9iamVjdF9vbl9za2lwbGlzdChvcHRpb25zLCBvYmplY3QpKQorCWlmIChvYmplY3Rfb25fc2tpcGxpc3Qob3B0aW9ucywgb2lkKSkKIAkJcmV0dXJuIDA7CiAKIAlpZiAobXNnX3R5cGUgPT0gRlNDS19GQVRBTCkKQEAgLTMwOSw0OSArMzA3LDcxIEBACiAKIAl2YV9zdGFydChhcCwgZm10KTsKIAlzdHJidWZfdmFkZGYoJnNiLCBmbXQsIGFwKTsKLQlyZXN1bHQgPSBvcHRpb25zLT5lcnJvcl9mdW5jKG9wdGlvbnMsIG9iamVjdCwgbXNnX3R5cGUsIHNiLmJ1Zik7CisJcmVzdWx0ID0gb3B0aW9ucy0+ZXJyb3JfZnVuYyhvcHRpb25zLCBvaWQsIG9iamVjdF90eXBlLAorCQkJCSAgICAgbXNnX3R5cGUsIHNiLmJ1Zik7CiAJc3RyYnVmX3JlbGVhc2UoJnNiKTsKIAl2YV9lbmQoYXApOwogCiAJcmV0dXJuIHJlc3VsdDsKIH0KIAotc3RhdGljIGNoYXIgKmdldF9vYmplY3RfbmFtZShzdHJ1Y3QgZnNja19vcHRpb25zICpvcHRpb25zLCBzdHJ1Y3Qgb2JqZWN0ICpvYmopCit2b2lkIGZzY2tfZW5hYmxlX29iamVjdF9uYW1lcyhzdHJ1Y3QgZnNja19vcHRpb25zICpvcHRpb25zKQogewogCWlmICghb3B0aW9ucy0+b2JqZWN0X25hbWVzKQotCQlyZXR1cm4gTlVMTDsKLQlyZXR1cm4gbG9va3VwX2RlY29yYXRpb24ob3B0aW9ucy0+b2JqZWN0X25hbWVzLCBvYmopOworCQlvcHRpb25zLT5vYmplY3RfbmFtZXMgPSBraF9pbml0X29pZF9tYXAoKTsKIH0KIAotc3RhdGljIHZvaWQgcHV0X29iamVjdF9uYW1lKHN0cnVjdCBmc2NrX29wdGlvbnMgKm9wdGlvbnMsIHN0cnVjdCBvYmplY3QgKm9iaiwKLQljb25zdCBjaGFyICpmbXQsIC4uLikKK2NvbnN0IGNoYXIgKmZzY2tfZ2V0X29iamVjdF9uYW1lKHN0cnVjdCBmc2NrX29wdGlvbnMgKm9wdGlvbnMsCisJCQkJIGNvbnN0IHN0cnVjdCBvYmplY3RfaWQgKm9pZCkKK3sKKwlraGl0ZXJfdCBwb3M7CisJaWYgKCFvcHRpb25zLT5vYmplY3RfbmFtZXMpCisJCXJldHVybiBOVUxMOworCXBvcyA9IGtoX2dldF9vaWRfbWFwKG9wdGlvbnMtPm9iamVjdF9uYW1lcywgKm9pZCk7CisJaWYgKHBvcyA+PSBraF9lbmQob3B0aW9ucy0+b2JqZWN0X25hbWVzKSkKKwkJcmV0dXJuIE5VTEw7CisJcmV0dXJuIGtoX3ZhbHVlKG9wdGlvbnMtPm9iamVjdF9uYW1lcywgcG9zKTsKK30KKwordm9pZCBmc2NrX3B1dF9vYmplY3RfbmFtZShzdHJ1Y3QgZnNja19vcHRpb25zICpvcHRpb25zLAorCQkJICBjb25zdCBzdHJ1Y3Qgb2JqZWN0X2lkICpvaWQsCisJCQkgIGNvbnN0IGNoYXIgKmZtdCwgLi4uKQogewogCXZhX2xpc3QgYXA7CiAJc3RydWN0IHN0cmJ1ZiBidWYgPSBTVFJCVUZfSU5JVDsKLQljaGFyICpleGlzdGluZzsKKwlraGl0ZXJfdCBwb3M7CisJaW50IGhhc2hyZXQ7CiAKIAlpZiAoIW9wdGlvbnMtPm9iamVjdF9uYW1lcykKIAkJcmV0dXJuOwotCWV4aXN0aW5nID0gbG9va3VwX2RlY29yYXRpb24ob3B0aW9ucy0+b2JqZWN0X25hbWVzLCBvYmopOwotCWlmIChleGlzdGluZykKKworCXBvcyA9IGtoX3B1dF9vaWRfbWFwKG9wdGlvbnMtPm9iamVjdF9uYW1lcywgKm9pZCwgJmhhc2hyZXQpOworCWlmICghaGFzaHJldCkKIAkJcmV0dXJuOwogCXZhX3N0YXJ0KGFwLCBmbXQpOwogCXN0cmJ1Zl92YWRkZigmYnVmLCBmbXQsIGFwKTsKLQlhZGRfZGVjb3JhdGlvbihvcHRpb25zLT5vYmplY3RfbmFtZXMsIG9iaiwgc3RyYnVmX2RldGFjaCgmYnVmLCBOVUxMKSk7CisJa2hfdmFsdWUob3B0aW9ucy0+b2JqZWN0X25hbWVzLCBwb3MpID0gc3RyYnVmX2RldGFjaCgmYnVmLCBOVUxMKTsKIAl2YV9lbmQoYXApOwogfQogCi1zdGF0aWMgY29uc3QgY2hhciAqZGVzY3JpYmVfb2JqZWN0KHN0cnVjdCBmc2NrX29wdGlvbnMgKm8sIHN0cnVjdCBvYmplY3QgKm9iaikKK2NvbnN0IGNoYXIgKmZzY2tfZGVzY3JpYmVfb2JqZWN0KHN0cnVjdCBmc2NrX29wdGlvbnMgKm9wdGlvbnMsCisJCQkJIGNvbnN0IHN0cnVjdCBvYmplY3RfaWQgKm9pZCkKIHsKLQlzdGF0aWMgc3RydWN0IHN0cmJ1ZiBidWYgPSBTVFJCVUZfSU5JVDsKLQljaGFyICpuYW1lOworCXN0YXRpYyBzdHJ1Y3Qgc3RyYnVmIGJ1ZnNbXSA9IHsKKwkJU1RSQlVGX0lOSVQsIFNUUkJVRl9JTklULCBTVFJCVUZfSU5JVCwgU1RSQlVGX0lOSVQKKwl9OworCXN0YXRpYyBpbnQgYiA9IDA7CisJc3RydWN0IHN0cmJ1ZiAqYnVmOworCWNvbnN0IGNoYXIgKm5hbWUgPSBmc2NrX2dldF9vYmplY3RfbmFtZShvcHRpb25zLCBvaWQpOwogCi0Jc3RyYnVmX3Jlc2V0KCZidWYpOwotCXN0cmJ1Zl9hZGRzdHIoJmJ1Ziwgb2lkX3RvX2hleCgmb2JqLT5vaWQpKTsKLQlpZiAoby0+b2JqZWN0X25hbWVzICYmIChuYW1lID0gbG9va3VwX2RlY29yYXRpb24oby0+b2JqZWN0X25hbWVzLCBvYmopKSkKLQkJc3RyYnVmX2FkZGYoJmJ1ZiwgIiAoJXMpIiwgbmFtZSk7CisJYnVmID0gYnVmcyArIGI7CisJYiA9IChiICsgMSkgJSBBUlJBWV9TSVpFKGJ1ZnMpOworCXN0cmJ1Zl9yZXNldChidWYpOworCXN0cmJ1Zl9hZGRzdHIoYnVmLCBvaWRfdG9faGV4KG9pZCkpOworCWlmIChuYW1lKQorCQlzdHJidWZfYWRkZihidWYsICIgKCVzKSIsIG5hbWUpOwogCi0JcmV0dXJuIGJ1Zi5idWY7CisJcmV0dXJuIGJ1Zi0+YnVmOwogfQogCiBzdGF0aWMgaW50IGZzY2tfd2Fsa190cmVlKHN0cnVjdCB0cmVlICp0cmVlLCB2b2lkICpkYXRhLCBzdHJ1Y3QgZnNja19vcHRpb25zICpvcHRpb25zKQpAQCAtMzY0LDcgKzM4NCw3IEBACiAJaWYgKHBhcnNlX3RyZWUodHJlZSkpCiAJCXJldHVybiAtMTsKIAotCW5hbWUgPSBnZXRfb2JqZWN0X25hbWUob3B0aW9ucywgJnRyZWUtPm9iamVjdCk7CisJbmFtZSA9IGZzY2tfZ2V0X29iamVjdF9uYW1lKG9wdGlvbnMsICZ0cmVlLT5vYmplY3Qub2lkKTsKIAlpZiAoaW5pdF90cmVlX2Rlc2NfZ2VudGx5KCZkZXNjLCB0cmVlLT5idWZmZXIsIHRyZWUtPnNpemUpKQogCQlyZXR1cm4gLTE7CiAJd2hpbGUgKHRyZWVfZW50cnlfZ2VudGx5KCZkZXNjLCAmZW50cnkpKSB7CkBAIC0zNzcsMjAgKzM5NywyMSBAQAogCQlpZiAoU19JU0RJUihlbnRyeS5tb2RlKSkgewogCQkJb2JqID0gKHN0cnVjdCBvYmplY3QgKilsb29rdXBfdHJlZSh0aGVfcmVwb3NpdG9yeSwgJmVudHJ5Lm9pZCk7CiAJCQlpZiAobmFtZSAmJiBvYmopCi0JCQkJcHV0X29iamVjdF9uYW1lKG9wdGlvbnMsIG9iaiwgIiVzJXMvIiwgbmFtZSwKLQkJCQkJZW50cnkucGF0aCk7CisJCQkJZnNja19wdXRfb2JqZWN0X25hbWUob3B0aW9ucywgJmVudHJ5Lm9pZCwgIiVzJXMvIiwKKwkJCQkJCSAgICAgbmFtZSwgZW50cnkucGF0aCk7CiAJCQlyZXN1bHQgPSBvcHRpb25zLT53YWxrKG9iaiwgT0JKX1RSRUUsIGRhdGEsIG9wdGlvbnMpOwogCQl9CiAJCWVsc2UgaWYgKFNfSVNSRUcoZW50cnkubW9kZSkgfHwgU19JU0xOSyhlbnRyeS5tb2RlKSkgewogCQkJb2JqID0gKHN0cnVjdCBvYmplY3QgKilsb29rdXBfYmxvYih0aGVfcmVwb3NpdG9yeSwgJmVudHJ5Lm9pZCk7CiAJCQlpZiAobmFtZSAmJiBvYmopCi0JCQkJcHV0X29iamVjdF9uYW1lKG9wdGlvbnMsIG9iaiwgIiVzJXMiLCBuYW1lLAotCQkJCQllbnRyeS5wYXRoKTsKKwkJCQlmc2NrX3B1dF9vYmplY3RfbmFtZShvcHRpb25zLCAmZW50cnkub2lkLCAiJXMlcyIsCisJCQkJCQkgICAgIG5hbWUsIGVudHJ5LnBhdGgpOwogCQkJcmVzdWx0ID0gb3B0aW9ucy0+d2FsayhvYmosIE9CSl9CTE9CLCBkYXRhLCBvcHRpb25zKTsKIAkJfQogCQllbHNlIHsKIAkJCXJlc3VsdCA9IGVycm9yKCJpbiB0cmVlICVzOiBlbnRyeSAlcyBoYXMgYmFkIG1vZGUgJS42byIsCi0JCQkJCWRlc2NyaWJlX29iamVjdChvcHRpb25zLCAmdHJlZS0+b2JqZWN0KSwgZW50cnkucGF0aCwgZW50cnkubW9kZSk7CisJCQkJICAgICAgIGZzY2tfZGVzY3JpYmVfb2JqZWN0KG9wdGlvbnMsICZ0cmVlLT5vYmplY3Qub2lkKSwKKwkJCQkgICAgICAgZW50cnkucGF0aCwgZW50cnkubW9kZSk7CiAJCX0KIAkJaWYgKHJlc3VsdCA8IDApCiAJCQlyZXR1cm4gcmVzdWx0OwpAQCAtNDExLDEwICs0MzIsMTAgQEAKIAlpZiAocGFyc2VfY29tbWl0KGNvbW1pdCkpCiAJCXJldHVybiAtMTsKIAotCW5hbWUgPSBnZXRfb2JqZWN0X25hbWUob3B0aW9ucywgJmNvbW1pdC0+b2JqZWN0KTsKKwluYW1lID0gZnNja19nZXRfb2JqZWN0X25hbWUob3B0aW9ucywgJmNvbW1pdC0+b2JqZWN0Lm9pZCk7CiAJaWYgKG5hbWUpCi0JCXB1dF9vYmplY3RfbmFtZShvcHRpb25zLCAmZ2V0X2NvbW1pdF90cmVlKGNvbW1pdCktPm9iamVjdCwKLQkJCQkiJXM6IiwgbmFtZSk7CisJCWZzY2tfcHV0X29iamVjdF9uYW1lKG9wdGlvbnMsIGdldF9jb21taXRfdHJlZV9vaWQoY29tbWl0KSwKKwkJCQkgICAgICIlczoiLCBuYW1lKTsKIAogCXJlc3VsdCA9IG9wdGlvbnMtPndhbGsoKHN0cnVjdCBvYmplY3QgKilnZXRfY29tbWl0X3RyZWUoY29tbWl0KSwKIAkJCSAgICAgICBPQkpfVFJFRSwgZGF0YSwgb3B0aW9ucyk7CkBAIC00NDIsMTYgKzQ2MywxNyBAQAogCiAJd2hpbGUgKHBhcmVudHMpIHsKIAkJaWYgKG5hbWUpIHsKLQkJCXN0cnVjdCBvYmplY3QgKm9iaiA9ICZwYXJlbnRzLT5pdGVtLT5vYmplY3Q7CisJCQlzdHJ1Y3Qgb2JqZWN0X2lkICpvaWQgPSAmcGFyZW50cy0+aXRlbS0+b2JqZWN0Lm9pZDsKIAogCQkJaWYgKGNvdW50ZXIrKykKLQkJCQlwdXRfb2JqZWN0X25hbWUob3B0aW9ucywgb2JqLCAiJXNeJWQiLAotCQkJCQluYW1lLCBjb3VudGVyKTsKKwkJCQlmc2NrX3B1dF9vYmplY3RfbmFtZShvcHRpb25zLCBvaWQsICIlc14lZCIsCisJCQkJCQkgICAgIG5hbWUsIGNvdW50ZXIpOwogCQkJZWxzZSBpZiAoZ2VuZXJhdGlvbiA+IDApCi0JCQkJcHV0X29iamVjdF9uYW1lKG9wdGlvbnMsIG9iaiwgIiUuKnN+JWQiLAotCQkJCQluYW1lX3ByZWZpeF9sZW4sIG5hbWUsIGdlbmVyYXRpb24gKyAxKTsKKwkJCQlmc2NrX3B1dF9vYmplY3RfbmFtZShvcHRpb25zLCBvaWQsICIlLipzfiVkIiwKKwkJCQkJCSAgICAgbmFtZV9wcmVmaXhfbGVuLCBuYW1lLAorCQkJCQkJICAgICBnZW5lcmF0aW9uICsgMSk7CiAJCQllbHNlCi0JCQkJcHV0X29iamVjdF9uYW1lKG9wdGlvbnMsIG9iaiwgIiVzXiIsIG5hbWUpOworCQkJCWZzY2tfcHV0X29iamVjdF9uYW1lKG9wdGlvbnMsIG9pZCwgIiVzXiIsIG5hbWUpOwogCQl9CiAJCXJlc3VsdCA9IG9wdGlvbnMtPndhbGsoKHN0cnVjdCBvYmplY3QgKilwYXJlbnRzLT5pdGVtLCBPQkpfQ09NTUlULCBkYXRhLCBvcHRpb25zKTsKIAkJaWYgKHJlc3VsdCA8IDApCkBAIC00NjUsMTIgKzQ4NywxMiBAQAogCiBzdGF0aWMgaW50IGZzY2tfd2Fsa190YWcoc3RydWN0IHRhZyAqdGFnLCB2b2lkICpkYXRhLCBzdHJ1Y3QgZnNja19vcHRpb25zICpvcHRpb25zKQogewotCWNoYXIgKm5hbWUgPSBnZXRfb2JqZWN0X25hbWUob3B0aW9ucywgJnRhZy0+b2JqZWN0KTsKKwljb25zdCBjaGFyICpuYW1lID0gZnNja19nZXRfb2JqZWN0X25hbWUob3B0aW9ucywgJnRhZy0+b2JqZWN0Lm9pZCk7CiAKIAlpZiAocGFyc2VfdGFnKHRhZykpCiAJCXJldHVybiAtMTsKIAlpZiAobmFtZSkKLQkJcHV0X29iamVjdF9uYW1lKG9wdGlvbnMsIHRhZy0+dGFnZ2VkLCAiJXMiLCBuYW1lKTsKKwkJZnNja19wdXRfb2JqZWN0X25hbWUob3B0aW9ucywgJnRhZy0+dGFnZ2VkLT5vaWQsICIlcyIsIG5hbWUpOwogCXJldHVybiBvcHRpb25zLT53YWxrKHRhZy0+dGFnZ2VkLCBPQkpfQU5ZLCBkYXRhLCBvcHRpb25zKTsKIH0KIApAQCAtNDkyLDcgKzUxNCw4IEBACiAJY2FzZSBPQkpfVEFHOgogCQlyZXR1cm4gZnNja193YWxrX3RhZygoc3RydWN0IHRhZyAqKW9iaiwgZGF0YSwgb3B0aW9ucyk7CiAJZGVmYXVsdDoKLQkJZXJyb3IoIlVua25vd24gb2JqZWN0IHR5cGUgZm9yICVzIiwgZGVzY3JpYmVfb2JqZWN0KG9wdGlvbnMsIG9iaikpOworCQllcnJvcigiVW5rbm93biBvYmplY3QgdHlwZSBmb3IgJXMiLAorCQkgICAgICBmc2NrX2Rlc2NyaWJlX29iamVjdChvcHRpb25zLCAmb2JqLT5vaWQpKTsKIAkJcmV0dXJuIC0xOwogCX0KIH0KQEAgLTU0Myw3ICs1NjYsOSBAQAogCXJldHVybiBjMSA8IGMyID8gMCA6IFRSRUVfVU5PUkRFUkVEOwogfQogCi1zdGF0aWMgaW50IGZzY2tfdHJlZShzdHJ1Y3QgdHJlZSAqaXRlbSwgc3RydWN0IGZzY2tfb3B0aW9ucyAqb3B0aW9ucykKK3N0YXRpYyBpbnQgZnNja190cmVlKGNvbnN0IHN0cnVjdCBvYmplY3RfaWQgKm9pZCwKKwkJICAgICBjb25zdCBjaGFyICpidWZmZXIsIHVuc2lnbmVkIGxvbmcgc2l6ZSwKKwkJICAgICBzdHJ1Y3QgZnNja19vcHRpb25zICpvcHRpb25zKQogewogCWludCByZXR2YWwgPSAwOwogCWludCBoYXNfbnVsbF9zaGExID0gMDsKQEAgLTU2MCw4ICs1ODUsOCBAQAogCXVuc2lnbmVkIG9fbW9kZTsKIAljb25zdCBjaGFyICpvX25hbWU7CiAKLQlpZiAoaW5pdF90cmVlX2Rlc2NfZ2VudGx5KCZkZXNjLCBpdGVtLT5idWZmZXIsIGl0ZW0tPnNpemUpKSB7Ci0JCXJldHZhbCArPSByZXBvcnQob3B0aW9ucywgJml0ZW0tPm9iamVjdCwgRlNDS19NU0dfQkFEX1RSRUUsICJjYW5ub3QgYmUgcGFyc2VkIGFzIGEgdHJlZSIpOworCWlmIChpbml0X3RyZWVfZGVzY19nZW50bHkoJmRlc2MsIGJ1ZmZlciwgc2l6ZSkpIHsKKwkJcmV0dmFsICs9IHJlcG9ydChvcHRpb25zLCBvaWQsIE9CSl9UUkVFLCBGU0NLX01TR19CQURfVFJFRSwgImNhbm5vdCBiZSBwYXJzZWQgYXMgYSB0cmVlIik7CiAJCXJldHVybiByZXR2YWw7CiAJfQogCkBAIC01ODcsMTMgKzYxMiwxNCBAQAogCQkJaWYgKCFTX0lTTE5LKG1vZGUpKQogCQkJCW9pZHNldF9pbnNlcnQoJmdpdG1vZHVsZXNfZm91bmQsIG9pZCk7CiAJCQllbHNlCi0JCQkJcmV0dmFsICs9IHJlcG9ydChvcHRpb25zLCAmaXRlbS0+b2JqZWN0LAorCQkJCXJldHZhbCArPSByZXBvcnQob3B0aW9ucywKKwkJCQkJCSBvaWQsIE9CSl9UUkVFLAogCQkJCQkJIEZTQ0tfTVNHX0dJVE1PRFVMRVNfU1lNTElOSywKIAkJCQkJCSAiLmdpdG1vZHVsZXMgaXMgYSBzeW1ib2xpYyBsaW5rIik7CiAJCX0KIAogCQlpZiAodXBkYXRlX3RyZWVfZW50cnlfZ2VudGx5KCZkZXNjKSkgewotCQkJcmV0dmFsICs9IHJlcG9ydChvcHRpb25zLCAmaXRlbS0+b2JqZWN0LCBGU0NLX01TR19CQURfVFJFRSwgImNhbm5vdCBiZSBwYXJzZWQgYXMgYSB0cmVlIik7CisJCQlyZXR2YWwgKz0gcmVwb3J0KG9wdGlvbnMsIG9pZCwgT0JKX1RSRUUsIEZTQ0tfTVNHX0JBRF9UUkVFLCAiY2Fubm90IGJlIHBhcnNlZCBhcyBhIHRyZWUiKTsKIAkJCWJyZWFrOwogCQl9CiAKQEAgLTYzOCwzMCArNjY0LDMxIEBACiAJfQogCiAJaWYgKGhhc19udWxsX3NoYTEpCi0JCXJldHZhbCArPSByZXBvcnQob3B0aW9ucywgJml0ZW0tPm9iamVjdCwgRlNDS19NU0dfTlVMTF9TSEExLCAiY29udGFpbnMgZW50cmllcyBwb2ludGluZyB0byBudWxsIHNoYTEiKTsKKwkJcmV0dmFsICs9IHJlcG9ydChvcHRpb25zLCBvaWQsIE9CSl9UUkVFLCBGU0NLX01TR19OVUxMX1NIQTEsICJjb250YWlucyBlbnRyaWVzIHBvaW50aW5nIHRvIG51bGwgc2hhMSIpOwogCWlmIChoYXNfZnVsbF9wYXRoKQotCQlyZXR2YWwgKz0gcmVwb3J0KG9wdGlvbnMsICZpdGVtLT5vYmplY3QsIEZTQ0tfTVNHX0ZVTExfUEFUSE5BTUUsICJjb250YWlucyBmdWxsIHBhdGhuYW1lcyIpOworCQlyZXR2YWwgKz0gcmVwb3J0KG9wdGlvbnMsIG9pZCwgT0JKX1RSRUUsIEZTQ0tfTVNHX0ZVTExfUEFUSE5BTUUsICJjb250YWlucyBmdWxsIHBhdGhuYW1lcyIpOwogCWlmIChoYXNfZW1wdHlfbmFtZSkKLQkJcmV0dmFsICs9IHJlcG9ydChvcHRpb25zLCAmaXRlbS0+b2JqZWN0LCBGU0NLX01TR19FTVBUWV9OQU1FLCAiY29udGFpbnMgZW1wdHkgcGF0aG5hbWUiKTsKKwkJcmV0dmFsICs9IHJlcG9ydChvcHRpb25zLCBvaWQsIE9CSl9UUkVFLCBGU0NLX01TR19FTVBUWV9OQU1FLCAiY29udGFpbnMgZW1wdHkgcGF0aG5hbWUiKTsKIAlpZiAoaGFzX2RvdCkKLQkJcmV0dmFsICs9IHJlcG9ydChvcHRpb25zLCAmaXRlbS0+b2JqZWN0LCBGU0NLX01TR19IQVNfRE9ULCAiY29udGFpbnMgJy4nIik7CisJCXJldHZhbCArPSByZXBvcnQob3B0aW9ucywgb2lkLCBPQkpfVFJFRSwgRlNDS19NU0dfSEFTX0RPVCwgImNvbnRhaW5zICcuJyIpOwogCWlmIChoYXNfZG90ZG90KQotCQlyZXR2YWwgKz0gcmVwb3J0KG9wdGlvbnMsICZpdGVtLT5vYmplY3QsIEZTQ0tfTVNHX0hBU19ET1RET1QsICJjb250YWlucyAnLi4nIik7CisJCXJldHZhbCArPSByZXBvcnQob3B0aW9ucywgb2lkLCBPQkpfVFJFRSwgRlNDS19NU0dfSEFTX0RPVERPVCwgImNvbnRhaW5zICcuLiciKTsKIAlpZiAoaGFzX2RvdGdpdCkKLQkJcmV0dmFsICs9IHJlcG9ydChvcHRpb25zLCAmaXRlbS0+b2JqZWN0LCBGU0NLX01TR19IQVNfRE9UR0lULCAiY29udGFpbnMgJy5naXQnIik7CisJCXJldHZhbCArPSByZXBvcnQob3B0aW9ucywgb2lkLCBPQkpfVFJFRSwgRlNDS19NU0dfSEFTX0RPVEdJVCwgImNvbnRhaW5zICcuZ2l0JyIpOwogCWlmIChoYXNfemVyb19wYWQpCi0JCXJldHZhbCArPSByZXBvcnQob3B0aW9ucywgJml0ZW0tPm9iamVjdCwgRlNDS19NU0dfWkVST19QQURERURfRklMRU1PREUsICJjb250YWlucyB6ZXJvLXBhZGRlZCBmaWxlIG1vZGVzIik7CisJCXJldHZhbCArPSByZXBvcnQob3B0aW9ucywgb2lkLCBPQkpfVFJFRSwgRlNDS19NU0dfWkVST19QQURERURfRklMRU1PREUsICJjb250YWlucyB6ZXJvLXBhZGRlZCBmaWxlIG1vZGVzIik7CiAJaWYgKGhhc19iYWRfbW9kZXMpCi0JCXJldHZhbCArPSByZXBvcnQob3B0aW9ucywgJml0ZW0tPm9iamVjdCwgRlNDS19NU0dfQkFEX0ZJTEVNT0RFLCAiY29udGFpbnMgYmFkIGZpbGUgbW9kZXMiKTsKKwkJcmV0dmFsICs9IHJlcG9ydChvcHRpb25zLCBvaWQsIE9CSl9UUkVFLCBGU0NLX01TR19CQURfRklMRU1PREUsICJjb250YWlucyBiYWQgZmlsZSBtb2RlcyIpOwogCWlmIChoYXNfZHVwX2VudHJpZXMpCi0JCXJldHZhbCArPSByZXBvcnQob3B0aW9ucywgJml0ZW0tPm9iamVjdCwgRlNDS19NU0dfRFVQTElDQVRFX0VOVFJJRVMsICJjb250YWlucyBkdXBsaWNhdGUgZmlsZSBlbnRyaWVzIik7CisJCXJldHZhbCArPSByZXBvcnQob3B0aW9ucywgb2lkLCBPQkpfVFJFRSwgRlNDS19NU0dfRFVQTElDQVRFX0VOVFJJRVMsICJjb250YWlucyBkdXBsaWNhdGUgZmlsZSBlbnRyaWVzIik7CiAJaWYgKG5vdF9wcm9wZXJseV9zb3J0ZWQpCi0JCXJldHZhbCArPSByZXBvcnQob3B0aW9ucywgJml0ZW0tPm9iamVjdCwgRlNDS19NU0dfVFJFRV9OT1RfU09SVEVELCAibm90IHByb3Blcmx5IHNvcnRlZCIpOworCQlyZXR2YWwgKz0gcmVwb3J0KG9wdGlvbnMsIG9pZCwgT0JKX1RSRUUsIEZTQ0tfTVNHX1RSRUVfTk9UX1NPUlRFRCwgIm5vdCBwcm9wZXJseSBzb3J0ZWQiKTsKIAlyZXR1cm4gcmV0dmFsOwogfQogCiBzdGF0aWMgaW50IHZlcmlmeV9oZWFkZXJzKGNvbnN0IHZvaWQgKmRhdGEsIHVuc2lnbmVkIGxvbmcgc2l6ZSwKLQkJCSAgc3RydWN0IG9iamVjdCAqb2JqLCBzdHJ1Y3QgZnNja19vcHRpb25zICpvcHRpb25zKQorCQkJICBjb25zdCBzdHJ1Y3Qgb2JqZWN0X2lkICpvaWQsIGVudW0gb2JqZWN0X3R5cGUgdHlwZSwKKwkJCSAgc3RydWN0IGZzY2tfb3B0aW9ucyAqb3B0aW9ucykKIHsKIAljb25zdCBjaGFyICpidWZmZXIgPSAoY29uc3QgY2hhciAqKWRhdGE7CiAJdW5zaWduZWQgbG9uZyBpOwpAQCAtNjY5LDcgKzY5Niw3IEBACiAJZm9yIChpID0gMDsgaSA8IHNpemU7IGkrKykgewogCQlzd2l0Y2ggKGJ1ZmZlcltpXSkgewogCQljYXNlICdcMCc6Ci0JCQlyZXR1cm4gcmVwb3J0KG9wdGlvbnMsIG9iaiwKKwkJCXJldHVybiByZXBvcnQob3B0aW9ucywgb2lkLCB0eXBlLAogCQkJCUZTQ0tfTVNHX05VTF9JTl9IRUFERVIsCiAJCQkJInVudGVybWluYXRlZCBoZWFkZXI6IE5VTCBhdCBvZmZzZXQgJWxkIiwgaSk7CiAJCWNhc2UgJ1xuJzoKQEAgLTY4NywxMSArNzE0LDEzIEBACiAJaWYgKHNpemUgJiYgYnVmZmVyW3NpemUgLSAxXSA9PSAnXG4nKQogCQlyZXR1cm4gMDsKIAotCXJldHVybiByZXBvcnQob3B0aW9ucywgb2JqLAorCXJldHVybiByZXBvcnQob3B0aW9ucywgb2lkLCB0eXBlLAogCQlGU0NLX01TR19VTlRFUk1JTkFURURfSEVBREVSLCAidW50ZXJtaW5hdGVkIGhlYWRlciIpOwogfQogCi1zdGF0aWMgaW50IGZzY2tfaWRlbnQoY29uc3QgY2hhciAqKmlkZW50LCBzdHJ1Y3Qgb2JqZWN0ICpvYmosIHN0cnVjdCBmc2NrX29wdGlvbnMgKm9wdGlvbnMpCitzdGF0aWMgaW50IGZzY2tfaWRlbnQoY29uc3QgY2hhciAqKmlkZW50LAorCQkgICAgICBjb25zdCBzdHJ1Y3Qgb2JqZWN0X2lkICpvaWQsIGVudW0gb2JqZWN0X3R5cGUgdHlwZSwKKwkJICAgICAgc3RydWN0IGZzY2tfb3B0aW9ucyAqb3B0aW9ucykKIHsKIAljb25zdCBjaGFyICpwID0gKmlkZW50OwogCWNoYXIgKmVuZDsKQEAgLTcwMSwyOCArNzMwLDI4IEBACiAJCSgqaWRlbnQpKys7CiAKIAlpZiAoKnAgPT0gJzwnKQotCQlyZXR1cm4gcmVwb3J0KG9wdGlvbnMsIG9iaiwgRlNDS19NU0dfTUlTU0lOR19OQU1FX0JFRk9SRV9FTUFJTCwgImludmFsaWQgYXV0aG9yL2NvbW1pdHRlciBsaW5lIC0gbWlzc2luZyBzcGFjZSBiZWZvcmUgZW1haWwiKTsKKwkJcmV0dXJuIHJlcG9ydChvcHRpb25zLCBvaWQsIHR5cGUsIEZTQ0tfTVNHX01JU1NJTkdfTkFNRV9CRUZPUkVfRU1BSUwsICJpbnZhbGlkIGF1dGhvci9jb21taXR0ZXIgbGluZSAtIG1pc3Npbmcgc3BhY2UgYmVmb3JlIGVtYWlsIik7CiAJcCArPSBzdHJjc3BuKHAsICI8PlxuIik7CiAJaWYgKCpwID09ICc+JykKLQkJcmV0dXJuIHJlcG9ydChvcHRpb25zLCBvYmosIEZTQ0tfTVNHX0JBRF9OQU1FLCAiaW52YWxpZCBhdXRob3IvY29tbWl0dGVyIGxpbmUgLSBiYWQgbmFtZSIpOworCQlyZXR1cm4gcmVwb3J0KG9wdGlvbnMsIG9pZCwgdHlwZSwgRlNDS19NU0dfQkFEX05BTUUsICJpbnZhbGlkIGF1dGhvci9jb21taXR0ZXIgbGluZSAtIGJhZCBuYW1lIik7CiAJaWYgKCpwICE9ICc8JykKLQkJcmV0dXJuIHJlcG9ydChvcHRpb25zLCBvYmosIEZTQ0tfTVNHX01JU1NJTkdfRU1BSUwsICJpbnZhbGlkIGF1dGhvci9jb21taXR0ZXIgbGluZSAtIG1pc3NpbmcgZW1haWwiKTsKKwkJcmV0dXJuIHJlcG9ydChvcHRpb25zLCBvaWQsIHR5cGUsIEZTQ0tfTVNHX01JU1NJTkdfRU1BSUwsICJpbnZhbGlkIGF1dGhvci9jb21taXR0ZXIgbGluZSAtIG1pc3NpbmcgZW1haWwiKTsKIAlpZiAocFstMV0gIT0gJyAnKQotCQlyZXR1cm4gcmVwb3J0KG9wdGlvbnMsIG9iaiwgRlNDS19NU0dfTUlTU0lOR19TUEFDRV9CRUZPUkVfRU1BSUwsICJpbnZhbGlkIGF1dGhvci9jb21taXR0ZXIgbGluZSAtIG1pc3Npbmcgc3BhY2UgYmVmb3JlIGVtYWlsIik7CisJCXJldHVybiByZXBvcnQob3B0aW9ucywgb2lkLCB0eXBlLCBGU0NLX01TR19NSVNTSU5HX1NQQUNFX0JFRk9SRV9FTUFJTCwgImludmFsaWQgYXV0aG9yL2NvbW1pdHRlciBsaW5lIC0gbWlzc2luZyBzcGFjZSBiZWZvcmUgZW1haWwiKTsKIAlwKys7CiAJcCArPSBzdHJjc3BuKHAsICI8PlxuIik7CiAJaWYgKCpwICE9ICc+JykKLQkJcmV0dXJuIHJlcG9ydChvcHRpb25zLCBvYmosIEZTQ0tfTVNHX0JBRF9FTUFJTCwgImludmFsaWQgYXV0aG9yL2NvbW1pdHRlciBsaW5lIC0gYmFkIGVtYWlsIik7CisJCXJldHVybiByZXBvcnQob3B0aW9ucywgb2lkLCB0eXBlLCBGU0NLX01TR19CQURfRU1BSUwsICJpbnZhbGlkIGF1dGhvci9jb21taXR0ZXIgbGluZSAtIGJhZCBlbWFpbCIpOwogCXArKzsKIAlpZiAoKnAgIT0gJyAnKQotCQlyZXR1cm4gcmVwb3J0KG9wdGlvbnMsIG9iaiwgRlNDS19NU0dfTUlTU0lOR19TUEFDRV9CRUZPUkVfREFURSwgImludmFsaWQgYXV0aG9yL2NvbW1pdHRlciBsaW5lIC0gbWlzc2luZyBzcGFjZSBiZWZvcmUgZGF0ZSIpOworCQlyZXR1cm4gcmVwb3J0KG9wdGlvbnMsIG9pZCwgdHlwZSwgRlNDS19NU0dfTUlTU0lOR19TUEFDRV9CRUZPUkVfREFURSwgImludmFsaWQgYXV0aG9yL2NvbW1pdHRlciBsaW5lIC0gbWlzc2luZyBzcGFjZSBiZWZvcmUgZGF0ZSIpOwogCXArKzsKIAlpZiAoKnAgPT0gJzAnICYmIHBbMV0gIT0gJyAnKQotCQlyZXR1cm4gcmVwb3J0KG9wdGlvbnMsIG9iaiwgRlNDS19NU0dfWkVST19QQURERURfREFURSwgImludmFsaWQgYXV0aG9yL2NvbW1pdHRlciBsaW5lIC0gemVyby1wYWRkZWQgZGF0ZSIpOworCQlyZXR1cm4gcmVwb3J0KG9wdGlvbnMsIG9pZCwgdHlwZSwgRlNDS19NU0dfWkVST19QQURERURfREFURSwgImludmFsaWQgYXV0aG9yL2NvbW1pdHRlciBsaW5lIC0gemVyby1wYWRkZWQgZGF0ZSIpOwogCWlmIChkYXRlX292ZXJmbG93cyhwYXJzZV90aW1lc3RhbXAocCwgJmVuZCwgMTApKSkKLQkJcmV0dXJuIHJlcG9ydChvcHRpb25zLCBvYmosIEZTQ0tfTVNHX0JBRF9EQVRFX09WRVJGTE9XLCAiaW52YWxpZCBhdXRob3IvY29tbWl0dGVyIGxpbmUgLSBkYXRlIGNhdXNlcyBpbnRlZ2VyIG92ZXJmbG93Iik7CisJCXJldHVybiByZXBvcnQob3B0aW9ucywgb2lkLCB0eXBlLCBGU0NLX01TR19CQURfREFURV9PVkVSRkxPVywgImludmFsaWQgYXV0aG9yL2NvbW1pdHRlciBsaW5lIC0gZGF0ZSBjYXVzZXMgaW50ZWdlciBvdmVyZmxvdyIpOwogCWlmICgoZW5kID09IHAgfHwgKmVuZCAhPSAnICcpKQotCQlyZXR1cm4gcmVwb3J0KG9wdGlvbnMsIG9iaiwgRlNDS19NU0dfQkFEX0RBVEUsICJpbnZhbGlkIGF1dGhvci9jb21taXR0ZXIgbGluZSAtIGJhZCBkYXRlIik7CisJCXJldHVybiByZXBvcnQob3B0aW9ucywgb2lkLCB0eXBlLCBGU0NLX01TR19CQURfREFURSwgImludmFsaWQgYXV0aG9yL2NvbW1pdHRlciBsaW5lIC0gYmFkIGRhdGUiKTsKIAlwID0gZW5kICsgMTsKIAlpZiAoKCpwICE9ICcrJyAmJiAqcCAhPSAnLScpIHx8CiAJICAgICFpc2RpZ2l0KHBbMV0pIHx8CkBAIC03MzAsODMgKzc1OSw2MCBAQAogCSAgICAhaXNkaWdpdChwWzNdKSB8fAogCSAgICAhaXNkaWdpdChwWzRdKSB8fAogCSAgICAocFs1XSAhPSAnXG4nKSkKLQkJcmV0dXJuIHJlcG9ydChvcHRpb25zLCBvYmosIEZTQ0tfTVNHX0JBRF9USU1FWk9ORSwgImludmFsaWQgYXV0aG9yL2NvbW1pdHRlciBsaW5lIC0gYmFkIHRpbWUgem9uZSIpOworCQlyZXR1cm4gcmVwb3J0KG9wdGlvbnMsIG9pZCwgdHlwZSwgRlNDS19NU0dfQkFEX1RJTUVaT05FLCAiaW52YWxpZCBhdXRob3IvY29tbWl0dGVyIGxpbmUgLSBiYWQgdGltZSB6b25lIik7CiAJcCArPSA2OwogCXJldHVybiAwOwogfQogCi1zdGF0aWMgaW50IGZzY2tfY29tbWl0X2J1ZmZlcihzdHJ1Y3QgY29tbWl0ICpjb21taXQsIGNvbnN0IGNoYXIgKmJ1ZmZlciwKLQl1bnNpZ25lZCBsb25nIHNpemUsIHN0cnVjdCBmc2NrX29wdGlvbnMgKm9wdGlvbnMpCitzdGF0aWMgaW50IGZzY2tfY29tbWl0KGNvbnN0IHN0cnVjdCBvYmplY3RfaWQgKm9pZCwKKwkJICAgICAgIGNvbnN0IGNoYXIgKmJ1ZmZlciwgdW5zaWduZWQgbG9uZyBzaXplLAorCQkgICAgICAgc3RydWN0IGZzY2tfb3B0aW9ucyAqb3B0aW9ucykKIHsKLQlzdHJ1Y3Qgb2JqZWN0X2lkIHRyZWVfb2lkLCBvaWQ7Ci0Jc3RydWN0IGNvbW1pdF9ncmFmdCAqZ3JhZnQ7Ci0JdW5zaWduZWQgcGFyZW50X2NvdW50LCBwYXJlbnRfbGluZV9jb3VudCA9IDAsIGF1dGhvcl9jb3VudDsKKwlzdHJ1Y3Qgb2JqZWN0X2lkIHRyZWVfb2lkLCBwYXJlbnRfb2lkOworCXVuc2lnbmVkIGF1dGhvcl9jb3VudDsKIAlpbnQgZXJyOwogCWNvbnN0IGNoYXIgKmJ1ZmZlcl9iZWdpbiA9IGJ1ZmZlcjsKIAljb25zdCBjaGFyICpwOwogCi0JaWYgKHZlcmlmeV9oZWFkZXJzKGJ1ZmZlciwgc2l6ZSwgJmNvbW1pdC0+b2JqZWN0LCBvcHRpb25zKSkKKwlpZiAodmVyaWZ5X2hlYWRlcnMoYnVmZmVyLCBzaXplLCBvaWQsIE9CSl9DT01NSVQsIG9wdGlvbnMpKQogCQlyZXR1cm4gLTE7CiAKIAlpZiAoIXNraXBfcHJlZml4KGJ1ZmZlciwgInRyZWUgIiwgJmJ1ZmZlcikpCi0JCXJldHVybiByZXBvcnQob3B0aW9ucywgJmNvbW1pdC0+b2JqZWN0LCBGU0NLX01TR19NSVNTSU5HX1RSRUUsICJpbnZhbGlkIGZvcm1hdCAtIGV4cGVjdGVkICd0cmVlJyBsaW5lIik7CisJCXJldHVybiByZXBvcnQob3B0aW9ucywgb2lkLCBPQkpfQ09NTUlULCBGU0NLX01TR19NSVNTSU5HX1RSRUUsICJpbnZhbGlkIGZvcm1hdCAtIGV4cGVjdGVkICd0cmVlJyBsaW5lIik7CiAJaWYgKHBhcnNlX29pZF9oZXgoYnVmZmVyLCAmdHJlZV9vaWQsICZwKSB8fCAqcCAhPSAnXG4nKSB7Ci0JCWVyciA9IHJlcG9ydChvcHRpb25zLCAmY29tbWl0LT5vYmplY3QsIEZTQ0tfTVNHX0JBRF9UUkVFX1NIQTEsICJpbnZhbGlkICd0cmVlJyBsaW5lIGZvcm1hdCAtIGJhZCBzaGExIik7CisJCWVyciA9IHJlcG9ydChvcHRpb25zLCBvaWQsIE9CSl9DT01NSVQsIEZTQ0tfTVNHX0JBRF9UUkVFX1NIQTEsICJpbnZhbGlkICd0cmVlJyBsaW5lIGZvcm1hdCAtIGJhZCBzaGExIik7CiAJCWlmIChlcnIpCiAJCQlyZXR1cm4gZXJyOwogCX0KIAlidWZmZXIgPSBwICsgMTsKIAl3aGlsZSAoc2tpcF9wcmVmaXgoYnVmZmVyLCAicGFyZW50ICIsICZidWZmZXIpKSB7Ci0JCWlmIChwYXJzZV9vaWRfaGV4KGJ1ZmZlciwgJm9pZCwgJnApIHx8ICpwICE9ICdcbicpIHsKLQkJCWVyciA9IHJlcG9ydChvcHRpb25zLCAmY29tbWl0LT5vYmplY3QsIEZTQ0tfTVNHX0JBRF9QQVJFTlRfU0hBMSwgImludmFsaWQgJ3BhcmVudCcgbGluZSBmb3JtYXQgLSBiYWQgc2hhMSIpOworCQlpZiAocGFyc2Vfb2lkX2hleChidWZmZXIsICZwYXJlbnRfb2lkLCAmcCkgfHwgKnAgIT0gJ1xuJykgeworCQkJZXJyID0gcmVwb3J0KG9wdGlvbnMsIG9pZCwgT0JKX0NPTU1JVCwgRlNDS19NU0dfQkFEX1BBUkVOVF9TSEExLCAiaW52YWxpZCAncGFyZW50JyBsaW5lIGZvcm1hdCAtIGJhZCBzaGExIik7CiAJCQlpZiAoZXJyKQogCQkJCXJldHVybiBlcnI7CiAJCX0KIAkJYnVmZmVyID0gcCArIDE7Ci0JCXBhcmVudF9saW5lX2NvdW50Kys7Ci0JfQotCWdyYWZ0ID0gbG9va3VwX2NvbW1pdF9ncmFmdCh0aGVfcmVwb3NpdG9yeSwgJmNvbW1pdC0+b2JqZWN0Lm9pZCk7Ci0JcGFyZW50X2NvdW50ID0gY29tbWl0X2xpc3RfY291bnQoY29tbWl0LT5wYXJlbnRzKTsKLQlpZiAoZ3JhZnQpIHsKLQkJaWYgKGdyYWZ0LT5ucl9wYXJlbnQgPT0gLTEgJiYgIXBhcmVudF9jb3VudCkKLQkJCTsgLyogc2hhbGxvdyBjb21taXQgKi8KLQkJZWxzZSBpZiAoZ3JhZnQtPm5yX3BhcmVudCAhPSBwYXJlbnRfY291bnQpIHsKLQkJCWVyciA9IHJlcG9ydChvcHRpb25zLCAmY29tbWl0LT5vYmplY3QsIEZTQ0tfTVNHX01JU1NJTkdfR1JBRlQsICJncmFmdCBvYmplY3RzIG1pc3NpbmciKTsKLQkJCWlmIChlcnIpCi0JCQkJcmV0dXJuIGVycjsKLQkJfQotCX0gZWxzZSB7Ci0JCWlmIChwYXJlbnRfY291bnQgIT0gcGFyZW50X2xpbmVfY291bnQpIHsKLQkJCWVyciA9IHJlcG9ydChvcHRpb25zLCAmY29tbWl0LT5vYmplY3QsIEZTQ0tfTVNHX01JU1NJTkdfUEFSRU5ULCAicGFyZW50IG9iamVjdHMgbWlzc2luZyIpOwotCQkJaWYgKGVycikKLQkJCQlyZXR1cm4gZXJyOwotCQl9CiAJfQogCWF1dGhvcl9jb3VudCA9IDA7CiAJd2hpbGUgKHNraXBfcHJlZml4KGJ1ZmZlciwgImF1dGhvciAiLCAmYnVmZmVyKSkgewogCQlhdXRob3JfY291bnQrKzsKLQkJZXJyID0gZnNja19pZGVudCgmYnVmZmVyLCAmY29tbWl0LT5vYmplY3QsIG9wdGlvbnMpOworCQllcnIgPSBmc2NrX2lkZW50KCZidWZmZXIsIG9pZCwgT0JKX0NPTU1JVCwgb3B0aW9ucyk7CiAJCWlmIChlcnIpCiAJCQlyZXR1cm4gZXJyOwogCX0KIAlpZiAoYXV0aG9yX2NvdW50IDwgMSkKLQkJZXJyID0gcmVwb3J0KG9wdGlvbnMsICZjb21taXQtPm9iamVjdCwgRlNDS19NU0dfTUlTU0lOR19BVVRIT1IsICJpbnZhbGlkIGZvcm1hdCAtIGV4cGVjdGVkICdhdXRob3InIGxpbmUiKTsKKwkJZXJyID0gcmVwb3J0KG9wdGlvbnMsIG9pZCwgT0JKX0NPTU1JVCwgRlNDS19NU0dfTUlTU0lOR19BVVRIT1IsICJpbnZhbGlkIGZvcm1hdCAtIGV4cGVjdGVkICdhdXRob3InIGxpbmUiKTsKIAllbHNlIGlmIChhdXRob3JfY291bnQgPiAxKQotCQllcnIgPSByZXBvcnQob3B0aW9ucywgJmNvbW1pdC0+b2JqZWN0LCBGU0NLX01TR19NVUxUSVBMRV9BVVRIT1JTLCAiaW52YWxpZCBmb3JtYXQgLSBtdWx0aXBsZSAnYXV0aG9yJyBsaW5lcyIpOworCQllcnIgPSByZXBvcnQob3B0aW9ucywgb2lkLCBPQkpfQ09NTUlULCBGU0NLX01TR19NVUxUSVBMRV9BVVRIT1JTLCAiaW52YWxpZCBmb3JtYXQgLSBtdWx0aXBsZSAnYXV0aG9yJyBsaW5lcyIpOwogCWlmIChlcnIpCiAJCXJldHVybiBlcnI7CiAJaWYgKCFza2lwX3ByZWZpeChidWZmZXIsICJjb21taXR0ZXIgIiwgJmJ1ZmZlcikpCi0JCXJldHVybiByZXBvcnQob3B0aW9ucywgJmNvbW1pdC0+b2JqZWN0LCBGU0NLX01TR19NSVNTSU5HX0NPTU1JVFRFUiwgImludmFsaWQgZm9ybWF0IC0gZXhwZWN0ZWQgJ2NvbW1pdHRlcicgbGluZSIpOwotCWVyciA9IGZzY2tfaWRlbnQoJmJ1ZmZlciwgJmNvbW1pdC0+b2JqZWN0LCBvcHRpb25zKTsKKwkJcmV0dXJuIHJlcG9ydChvcHRpb25zLCBvaWQsIE9CSl9DT01NSVQsIEZTQ0tfTVNHX01JU1NJTkdfQ09NTUlUVEVSLCAiaW52YWxpZCBmb3JtYXQgLSBleHBlY3RlZCAnY29tbWl0dGVyJyBsaW5lIik7CisJZXJyID0gZnNja19pZGVudCgmYnVmZmVyLCBvaWQsIE9CSl9DT01NSVQsIG9wdGlvbnMpOwogCWlmIChlcnIpCiAJCXJldHVybiBlcnI7Ci0JaWYgKCFnZXRfY29tbWl0X3RyZWUoY29tbWl0KSkgewotCQllcnIgPSByZXBvcnQob3B0aW9ucywgJmNvbW1pdC0+b2JqZWN0LCBGU0NLX01TR19CQURfVFJFRSwgImNvdWxkIG5vdCBsb2FkIGNvbW1pdCdzIHRyZWUgJXMiLCBvaWRfdG9faGV4KCZ0cmVlX29pZCkpOwotCQlpZiAoZXJyKQotCQkJcmV0dXJuIGVycjsKLQl9CiAJaWYgKG1lbWNocihidWZmZXJfYmVnaW4sICdcMCcsIHNpemUpKSB7Ci0JCWVyciA9IHJlcG9ydChvcHRpb25zLCAmY29tbWl0LT5vYmplY3QsIEZTQ0tfTVNHX05VTF9JTl9DT01NSVQsCisJCWVyciA9IHJlcG9ydChvcHRpb25zLCBvaWQsIE9CSl9DT01NSVQsIEZTQ0tfTVNHX05VTF9JTl9DT01NSVQsCiAJCQkgICAgICJOVUwgYnl0ZSBpbiB0aGUgY29tbWl0IG9iamVjdCBib2R5Iik7CiAJCWlmIChlcnIpCiAJCQlyZXR1cm4gZXJyOwpAQCAtODE0LDkxICs4MjAsNjAgQEAKIAlyZXR1cm4gMDsKIH0KIAotc3RhdGljIGludCBmc2NrX2NvbW1pdChzdHJ1Y3QgY29tbWl0ICpjb21taXQsIGNvbnN0IGNoYXIgKmRhdGEsCi0JdW5zaWduZWQgbG9uZyBzaXplLCBzdHJ1Y3QgZnNja19vcHRpb25zICpvcHRpb25zKQorc3RhdGljIGludCBmc2NrX3RhZyhjb25zdCBzdHJ1Y3Qgb2JqZWN0X2lkICpvaWQsIGNvbnN0IGNoYXIgKmJ1ZmZlciwKKwkJICAgIHVuc2lnbmVkIGxvbmcgc2l6ZSwgc3RydWN0IGZzY2tfb3B0aW9ucyAqb3B0aW9ucykKIHsKLQljb25zdCBjaGFyICpidWZmZXIgPSBkYXRhID8gIGRhdGEgOiBnZXRfY29tbWl0X2J1ZmZlcihjb21taXQsICZzaXplKTsKLQlpbnQgcmV0ID0gZnNja19jb21taXRfYnVmZmVyKGNvbW1pdCwgYnVmZmVyLCBzaXplLCBvcHRpb25zKTsKLQlpZiAoIWRhdGEpCi0JCXVudXNlX2NvbW1pdF9idWZmZXIoY29tbWl0LCBidWZmZXIpOwotCXJldHVybiByZXQ7Ci19Ci0KLXN0YXRpYyBpbnQgZnNja190YWdfYnVmZmVyKHN0cnVjdCB0YWcgKnRhZywgY29uc3QgY2hhciAqZGF0YSwKLQl1bnNpZ25lZCBsb25nIHNpemUsIHN0cnVjdCBmc2NrX29wdGlvbnMgKm9wdGlvbnMpCi17Ci0Jc3RydWN0IG9iamVjdF9pZCBvaWQ7CisJc3RydWN0IG9iamVjdF9pZCB0YWdnZWRfb2lkOwogCWludCByZXQgPSAwOwotCWNvbnN0IGNoYXIgKmJ1ZmZlcjsKLQljaGFyICp0b19mcmVlID0gTlVMTCwgKmVvbDsKKwljaGFyICplb2w7CiAJc3RydWN0IHN0cmJ1ZiBzYiA9IFNUUkJVRl9JTklUOwogCWNvbnN0IGNoYXIgKnA7CiAKLQlpZiAoZGF0YSkKLQkJYnVmZmVyID0gZGF0YTsKLQllbHNlIHsKLQkJZW51bSBvYmplY3RfdHlwZSB0eXBlOwotCi0JCWJ1ZmZlciA9IHRvX2ZyZWUgPQotCQkJcmVhZF9vYmplY3RfZmlsZSgmdGFnLT5vYmplY3Qub2lkLCAmdHlwZSwgJnNpemUpOwotCQlpZiAoIWJ1ZmZlcikKLQkJCXJldHVybiByZXBvcnQob3B0aW9ucywgJnRhZy0+b2JqZWN0LAotCQkJCUZTQ0tfTVNHX01JU1NJTkdfVEFHX09CSkVDVCwKLQkJCQkiY2Fubm90IHJlYWQgdGFnIG9iamVjdCIpOwotCi0JCWlmICh0eXBlICE9IE9CSl9UQUcpIHsKLQkJCXJldCA9IHJlcG9ydChvcHRpb25zLCAmdGFnLT5vYmplY3QsCi0JCQkJRlNDS19NU0dfVEFHX09CSkVDVF9OT1RfVEFHLAotCQkJCSJleHBlY3RlZCB0YWcgZ290ICVzIiwKLQkJCSAgICB0eXBlX25hbWUodHlwZSkpOwotCQkJZ290byBkb25lOwotCQl9Ci0JfQotCi0JcmV0ID0gdmVyaWZ5X2hlYWRlcnMoYnVmZmVyLCBzaXplLCAmdGFnLT5vYmplY3QsIG9wdGlvbnMpOworCXJldCA9IHZlcmlmeV9oZWFkZXJzKGJ1ZmZlciwgc2l6ZSwgb2lkLCBPQkpfVEFHLCBvcHRpb25zKTsKIAlpZiAocmV0KQogCQlnb3RvIGRvbmU7CiAKIAlpZiAoIXNraXBfcHJlZml4KGJ1ZmZlciwgIm9iamVjdCAiLCAmYnVmZmVyKSkgewotCQlyZXQgPSByZXBvcnQob3B0aW9ucywgJnRhZy0+b2JqZWN0LCBGU0NLX01TR19NSVNTSU5HX09CSkVDVCwgImludmFsaWQgZm9ybWF0IC0gZXhwZWN0ZWQgJ29iamVjdCcgbGluZSIpOworCQlyZXQgPSByZXBvcnQob3B0aW9ucywgb2lkLCBPQkpfVEFHLCBGU0NLX01TR19NSVNTSU5HX09CSkVDVCwgImludmFsaWQgZm9ybWF0IC0gZXhwZWN0ZWQgJ29iamVjdCcgbGluZSIpOwogCQlnb3RvIGRvbmU7CiAJfQotCWlmIChwYXJzZV9vaWRfaGV4KGJ1ZmZlciwgJm9pZCwgJnApIHx8ICpwICE9ICdcbicpIHsKLQkJcmV0ID0gcmVwb3J0KG9wdGlvbnMsICZ0YWctPm9iamVjdCwgRlNDS19NU0dfQkFEX09CSkVDVF9TSEExLCAiaW52YWxpZCAnb2JqZWN0JyBsaW5lIGZvcm1hdCAtIGJhZCBzaGExIik7CisJaWYgKHBhcnNlX29pZF9oZXgoYnVmZmVyLCAmdGFnZ2VkX29pZCwgJnApIHx8ICpwICE9ICdcbicpIHsKKwkJcmV0ID0gcmVwb3J0KG9wdGlvbnMsIG9pZCwgT0JKX1RBRywgRlNDS19NU0dfQkFEX09CSkVDVF9TSEExLCAiaW52YWxpZCAnb2JqZWN0JyBsaW5lIGZvcm1hdCAtIGJhZCBzaGExIik7CiAJCWlmIChyZXQpCiAJCQlnb3RvIGRvbmU7CiAJfQogCWJ1ZmZlciA9IHAgKyAxOwogCiAJaWYgKCFza2lwX3ByZWZpeChidWZmZXIsICJ0eXBlICIsICZidWZmZXIpKSB7Ci0JCXJldCA9IHJlcG9ydChvcHRpb25zLCAmdGFnLT5vYmplY3QsIEZTQ0tfTVNHX01JU1NJTkdfVFlQRV9FTlRSWSwgImludmFsaWQgZm9ybWF0IC0gZXhwZWN0ZWQgJ3R5cGUnIGxpbmUiKTsKKwkJcmV0ID0gcmVwb3J0KG9wdGlvbnMsIG9pZCwgT0JKX1RBRywgRlNDS19NU0dfTUlTU0lOR19UWVBFX0VOVFJZLCAiaW52YWxpZCBmb3JtYXQgLSBleHBlY3RlZCAndHlwZScgbGluZSIpOwogCQlnb3RvIGRvbmU7CiAJfQogCWVvbCA9IHN0cmNocihidWZmZXIsICdcbicpOwogCWlmICghZW9sKSB7Ci0JCXJldCA9IHJlcG9ydChvcHRpb25zLCAmdGFnLT5vYmplY3QsIEZTQ0tfTVNHX01JU1NJTkdfVFlQRSwgImludmFsaWQgZm9ybWF0IC0gdW5leHBlY3RlZCBlbmQgYWZ0ZXIgJ3R5cGUnIGxpbmUiKTsKKwkJcmV0ID0gcmVwb3J0KG9wdGlvbnMsIG9pZCwgT0JKX1RBRywgRlNDS19NU0dfTUlTU0lOR19UWVBFLCAiaW52YWxpZCBmb3JtYXQgLSB1bmV4cGVjdGVkIGVuZCBhZnRlciAndHlwZScgbGluZSIpOwogCQlnb3RvIGRvbmU7CiAJfQogCWlmICh0eXBlX2Zyb21fc3RyaW5nX2dlbnRseShidWZmZXIsIGVvbCAtIGJ1ZmZlciwgMSkgPCAwKQotCQlyZXQgPSByZXBvcnQob3B0aW9ucywgJnRhZy0+b2JqZWN0LCBGU0NLX01TR19CQURfVFlQRSwgImludmFsaWQgJ3R5cGUnIHZhbHVlIik7CisJCXJldCA9IHJlcG9ydChvcHRpb25zLCBvaWQsIE9CSl9UQUcsIEZTQ0tfTVNHX0JBRF9UWVBFLCAiaW52YWxpZCAndHlwZScgdmFsdWUiKTsKIAlpZiAocmV0KQogCQlnb3RvIGRvbmU7CiAJYnVmZmVyID0gZW9sICsgMTsKIAogCWlmICghc2tpcF9wcmVmaXgoYnVmZmVyLCAidGFnICIsICZidWZmZXIpKSB7Ci0JCXJldCA9IHJlcG9ydChvcHRpb25zLCAmdGFnLT5vYmplY3QsIEZTQ0tfTVNHX01JU1NJTkdfVEFHX0VOVFJZLCAiaW52YWxpZCBmb3JtYXQgLSBleHBlY3RlZCAndGFnJyBsaW5lIik7CisJCXJldCA9IHJlcG9ydChvcHRpb25zLCBvaWQsIE9CSl9UQUcsIEZTQ0tfTVNHX01JU1NJTkdfVEFHX0VOVFJZLCAiaW52YWxpZCBmb3JtYXQgLSBleHBlY3RlZCAndGFnJyBsaW5lIik7CiAJCWdvdG8gZG9uZTsKIAl9CiAJZW9sID0gc3RyY2hyKGJ1ZmZlciwgJ1xuJyk7CiAJaWYgKCFlb2wpIHsKLQkJcmV0ID0gcmVwb3J0KG9wdGlvbnMsICZ0YWctPm9iamVjdCwgRlNDS19NU0dfTUlTU0lOR19UQUcsICJpbnZhbGlkIGZvcm1hdCAtIHVuZXhwZWN0ZWQgZW5kIGFmdGVyICd0eXBlJyBsaW5lIik7CisJCXJldCA9IHJlcG9ydChvcHRpb25zLCBvaWQsIE9CSl9UQUcsIEZTQ0tfTVNHX01JU1NJTkdfVEFHLCAiaW52YWxpZCBmb3JtYXQgLSB1bmV4cGVjdGVkIGVuZCBhZnRlciAndHlwZScgbGluZSIpOwogCQlnb3RvIGRvbmU7CiAJfQogCXN0cmJ1Zl9hZGRmKCZzYiwgInJlZnMvdGFncy8lLipzIiwgKGludCkoZW9sIC0gYnVmZmVyKSwgYnVmZmVyKTsKIAlpZiAoY2hlY2tfcmVmbmFtZV9mb3JtYXQoc2IuYnVmLCAwKSkgewotCQlyZXQgPSByZXBvcnQob3B0aW9ucywgJnRhZy0+b2JqZWN0LCBGU0NLX01TR19CQURfVEFHX05BTUUsCi0JCQkgICAiaW52YWxpZCAndGFnJyBuYW1lOiAlLipzIiwKLQkJCSAgIChpbnQpKGVvbCAtIGJ1ZmZlciksIGJ1ZmZlcik7CisJCXJldCA9IHJlcG9ydChvcHRpb25zLCBvaWQsIE9CSl9UQUcsCisJCQkgICAgIEZTQ0tfTVNHX0JBRF9UQUdfTkFNRSwKKwkJCSAgICAgImludmFsaWQgJ3RhZycgbmFtZTogJS4qcyIsCisJCQkgICAgIChpbnQpKGVvbCAtIGJ1ZmZlciksIGJ1ZmZlcik7CiAJCWlmIChyZXQpCiAJCQlnb3RvIGRvbmU7CiAJfQpAQCAtOTA2LDMyICs4ODEsMjAgQEAKIAogCWlmICghc2tpcF9wcmVmaXgoYnVmZmVyLCAidGFnZ2VyICIsICZidWZmZXIpKSB7CiAJCS8qIGVhcmx5IHRhZ3MgZG8gbm90IGNvbnRhaW4gJ3RhZ2dlcicgbGluZXM7IHdhcm4gb25seSAqLwotCQlyZXQgPSByZXBvcnQob3B0aW9ucywgJnRhZy0+b2JqZWN0LCBGU0NLX01TR19NSVNTSU5HX1RBR0dFUl9FTlRSWSwgImludmFsaWQgZm9ybWF0IC0gZXhwZWN0ZWQgJ3RhZ2dlcicgbGluZSIpOworCQlyZXQgPSByZXBvcnQob3B0aW9ucywgb2lkLCBPQkpfVEFHLCBGU0NLX01TR19NSVNTSU5HX1RBR0dFUl9FTlRSWSwgImludmFsaWQgZm9ybWF0IC0gZXhwZWN0ZWQgJ3RhZ2dlcicgbGluZSIpOwogCQlpZiAocmV0KQogCQkJZ290byBkb25lOwogCX0KIAllbHNlCi0JCXJldCA9IGZzY2tfaWRlbnQoJmJ1ZmZlciwgJnRhZy0+b2JqZWN0LCBvcHRpb25zKTsKKwkJcmV0ID0gZnNja19pZGVudCgmYnVmZmVyLCBvaWQsIE9CSl9UQUcsIG9wdGlvbnMpOwogCiBkb25lOgogCXN0cmJ1Zl9yZWxlYXNlKCZzYik7Ci0JZnJlZSh0b19mcmVlKTsKIAlyZXR1cm4gcmV0OwogfQogCi1zdGF0aWMgaW50IGZzY2tfdGFnKHN0cnVjdCB0YWcgKnRhZywgY29uc3QgY2hhciAqZGF0YSwKLQl1bnNpZ25lZCBsb25nIHNpemUsIHN0cnVjdCBmc2NrX29wdGlvbnMgKm9wdGlvbnMpCi17Ci0Jc3RydWN0IG9iamVjdCAqdGFnZ2VkID0gdGFnLT50YWdnZWQ7Ci0KLQlpZiAoIXRhZ2dlZCkKLQkJcmV0dXJuIHJlcG9ydChvcHRpb25zLCAmdGFnLT5vYmplY3QsIEZTQ0tfTVNHX0JBRF9UQUdfT0JKRUNULCAiY291bGQgbm90IGxvYWQgdGFnZ2VkIG9iamVjdCIpOwotCi0JcmV0dXJuIGZzY2tfdGFnX2J1ZmZlcih0YWcsIGRhdGEsIHNpemUsIG9wdGlvbnMpOwotfQotCiBzdHJ1Y3QgZnNja19naXRtb2R1bGVzX2RhdGEgewotCXN0cnVjdCBvYmplY3QgKm9iajsKKwljb25zdCBzdHJ1Y3Qgb2JqZWN0X2lkICpvaWQ7CiAJc3RydWN0IGZzY2tfb3B0aW9ucyAqb3B0aW9uczsKIAlpbnQgcmV0OwogfTsKQEAgLTk0OSwxOSArOTEyLDIyIEBACiAKIAluYW1lID0geG1lbWR1cHooc3Vic2VjdGlvbiwgc3Vic2VjdGlvbl9sZW4pOwogCWlmIChjaGVja19zdWJtb2R1bGVfbmFtZShuYW1lKSA8IDApCi0JCWRhdGEtPnJldCB8PSByZXBvcnQoZGF0YS0+b3B0aW9ucywgZGF0YS0+b2JqLAorCQlkYXRhLT5yZXQgfD0gcmVwb3J0KGRhdGEtPm9wdGlvbnMsCisJCQkJICAgIGRhdGEtPm9pZCwgT0JKX0JMT0IsCiAJCQkJICAgIEZTQ0tfTVNHX0dJVE1PRFVMRVNfTkFNRSwKIAkJCQkgICAgImRpc2FsbG93ZWQgc3VibW9kdWxlIG5hbWU6ICVzIiwKIAkJCQkgICAgbmFtZSk7CiAJaWYgKCFzdHJjbXAoa2V5LCAidXJsIikgJiYgdmFsdWUgJiYKIAkgICAgbG9va3NfbGlrZV9jb21tYW5kX2xpbmVfb3B0aW9uKHZhbHVlKSkKLQkJZGF0YS0+cmV0IHw9IHJlcG9ydChkYXRhLT5vcHRpb25zLCBkYXRhLT5vYmosCisJCWRhdGEtPnJldCB8PSByZXBvcnQoZGF0YS0+b3B0aW9ucywKKwkJCQkgICAgZGF0YS0+b2lkLCBPQkpfQkxPQiwKIAkJCQkgICAgRlNDS19NU0dfR0lUTU9EVUxFU19VUkwsCiAJCQkJICAgICJkaXNhbGxvd2VkIHN1Ym1vZHVsZSB1cmw6ICVzIiwKIAkJCQkgICAgdmFsdWUpOwogCWlmICghc3RyY21wKGtleSwgInBhdGgiKSAmJiB2YWx1ZSAmJgogCSAgICBsb29rc19saWtlX2NvbW1hbmRfbGluZV9vcHRpb24odmFsdWUpKQotCQlkYXRhLT5yZXQgfD0gcmVwb3J0KGRhdGEtPm9wdGlvbnMsIGRhdGEtPm9iaiwKKwkJZGF0YS0+cmV0IHw9IHJlcG9ydChkYXRhLT5vcHRpb25zLAorCQkJCSAgICBkYXRhLT5vaWQsIE9CSl9CTE9CLAogCQkJCSAgICBGU0NLX01TR19HSVRNT0RVTEVTX1BBVEgsCiAJCQkJICAgICJkaXNhbGxvd2VkIHN1Ym1vZHVsZSBwYXRoOiAlcyIsCiAJCQkJICAgIHZhbHVlKTsKQEAgLTk3MCwxNyArOTM2LDE3IEBACiAJcmV0dXJuIDA7CiB9CiAKLXN0YXRpYyBpbnQgZnNja19ibG9iKHN0cnVjdCBibG9iICpibG9iLCBjb25zdCBjaGFyICpidWYsCitzdGF0aWMgaW50IGZzY2tfYmxvYihjb25zdCBzdHJ1Y3Qgb2JqZWN0X2lkICpvaWQsIGNvbnN0IGNoYXIgKmJ1ZiwKIAkJICAgICB1bnNpZ25lZCBsb25nIHNpemUsIHN0cnVjdCBmc2NrX29wdGlvbnMgKm9wdGlvbnMpCiB7CiAJc3RydWN0IGZzY2tfZ2l0bW9kdWxlc19kYXRhIGRhdGE7CiAJc3RydWN0IGNvbmZpZ19vcHRpb25zIGNvbmZpZ19vcHRzID0geyAwIH07CiAKLQlpZiAoIW9pZHNldF9jb250YWlucygmZ2l0bW9kdWxlc19mb3VuZCwgJmJsb2ItPm9iamVjdC5vaWQpKQorCWlmICghb2lkc2V0X2NvbnRhaW5zKCZnaXRtb2R1bGVzX2ZvdW5kLCBvaWQpKQogCQlyZXR1cm4gMDsKLQlvaWRzZXRfaW5zZXJ0KCZnaXRtb2R1bGVzX2RvbmUsICZibG9iLT5vYmplY3Qub2lkKTsKKwlvaWRzZXRfaW5zZXJ0KCZnaXRtb2R1bGVzX2RvbmUsIG9pZCk7CiAKLQlpZiAob2JqZWN0X29uX3NraXBsaXN0KG9wdGlvbnMsICZibG9iLT5vYmplY3QpKQorCWlmIChvYmplY3Rfb25fc2tpcGxpc3Qob3B0aW9ucywgb2lkKSkKIAkJcmV0dXJuIDA7CiAKIAlpZiAoIWJ1ZikgewpAQCAtOTg5LDE4ICs5NTUsMTggQEAKIAkJICogYmxvYiB0b28gZ2lnYW50aWMgdG8gbG9hZCBpbnRvIG1lbW9yeS4gTGV0J3MganVzdCBjb25zaWRlcgogCQkgKiB0aGF0IGFuIGVycm9yLgogCQkgKi8KLQkJcmV0dXJuIHJlcG9ydChvcHRpb25zLCAmYmxvYi0+b2JqZWN0LAorCQlyZXR1cm4gcmVwb3J0KG9wdGlvbnMsIG9pZCwgT0JKX0JMT0IsCiAJCQkgICAgICBGU0NLX01TR19HSVRNT0RVTEVTX0xBUkdFLAogCQkJICAgICAgIi5naXRtb2R1bGVzIHRvbyBsYXJnZSB0byBwYXJzZSIpOwogCX0KIAotCWRhdGEub2JqID0gJmJsb2ItPm9iamVjdDsKKwlkYXRhLm9pZCA9IG9pZDsKIAlkYXRhLm9wdGlvbnMgPSBvcHRpb25zOwogCWRhdGEucmV0ID0gMDsKIAljb25maWdfb3B0cy5lcnJvcl9hY3Rpb24gPSBDT05GSUdfRVJST1JfU0lMRU5UOwogCWlmIChnaXRfY29uZmlnX2Zyb21fbWVtKGZzY2tfZ2l0bW9kdWxlc19mbiwgQ09ORklHX09SSUdJTl9CTE9CLAogCQkJCSIuZ2l0bW9kdWxlcyIsIGJ1Ziwgc2l6ZSwgJmRhdGEsICZjb25maWdfb3B0cykpCi0JCWRhdGEucmV0IHw9IHJlcG9ydChvcHRpb25zLCAmYmxvYi0+b2JqZWN0LAorCQlkYXRhLnJldCB8PSByZXBvcnQob3B0aW9ucywgb2lkLCBPQkpfQkxPQiwKIAkJCQkgICBGU0NLX01TR19HSVRNT0RVTEVTX1BBUlNFLAogCQkJCSAgICJjb3VsZCBub3QgcGFyc2UgZ2l0bW9kdWxlcyBibG9iIik7CiAKQEAgLTEwMTEsMzEgKzk3NywzMyBAQAogCXN0cnVjdCBmc2NrX29wdGlvbnMgKm9wdGlvbnMpCiB7CiAJaWYgKCFvYmopCi0JCXJldHVybiByZXBvcnQob3B0aW9ucywgb2JqLCBGU0NLX01TR19CQURfT0JKRUNUX1NIQTEsICJubyB2YWxpZCBvYmplY3QgdG8gZnNjayIpOworCQlyZXR1cm4gcmVwb3J0KG9wdGlvbnMsIE5VTEwsIE9CSl9OT05FLCBGU0NLX01TR19CQURfT0JKRUNUX1NIQTEsICJubyB2YWxpZCBvYmplY3QgdG8gZnNjayIpOwogCiAJaWYgKG9iai0+dHlwZSA9PSBPQkpfQkxPQikKLQkJcmV0dXJuIGZzY2tfYmxvYigoc3RydWN0IGJsb2IgKilvYmosIGRhdGEsIHNpemUsIG9wdGlvbnMpOworCQlyZXR1cm4gZnNja19ibG9iKCZvYmotPm9pZCwgZGF0YSwgc2l6ZSwgb3B0aW9ucyk7CiAJaWYgKG9iai0+dHlwZSA9PSBPQkpfVFJFRSkKLQkJcmV0dXJuIGZzY2tfdHJlZSgoc3RydWN0IHRyZWUgKikgb2JqLCBvcHRpb25zKTsKKwkJcmV0dXJuIGZzY2tfdHJlZSgmb2JqLT5vaWQsIGRhdGEsIHNpemUsIG9wdGlvbnMpOwogCWlmIChvYmotPnR5cGUgPT0gT0JKX0NPTU1JVCkKLQkJcmV0dXJuIGZzY2tfY29tbWl0KChzdHJ1Y3QgY29tbWl0ICopIG9iaiwgKGNvbnN0IGNoYXIgKikgZGF0YSwKLQkJCXNpemUsIG9wdGlvbnMpOworCQlyZXR1cm4gZnNja19jb21taXQoJm9iai0+b2lkLCBkYXRhLCBzaXplLCBvcHRpb25zKTsKIAlpZiAob2JqLT50eXBlID09IE9CSl9UQUcpCi0JCXJldHVybiBmc2NrX3RhZygoc3RydWN0IHRhZyAqKSBvYmosIChjb25zdCBjaGFyICopIGRhdGEsCi0JCQlzaXplLCBvcHRpb25zKTsKKwkJcmV0dXJuIGZzY2tfdGFnKCZvYmotPm9pZCwgZGF0YSwgc2l6ZSwgb3B0aW9ucyk7CiAKLQlyZXR1cm4gcmVwb3J0KG9wdGlvbnMsIG9iaiwgRlNDS19NU0dfVU5LTk9XTl9UWVBFLCAidW5rbm93biB0eXBlICclZCcgKGludGVybmFsIGZzY2sgZXJyb3IpIiwKLQkJCSAgb2JqLT50eXBlKTsKKwlyZXR1cm4gcmVwb3J0KG9wdGlvbnMsICZvYmotPm9pZCwgb2JqLT50eXBlLAorCQkgICAgICBGU0NLX01TR19VTktOT1dOX1RZUEUsCisJCSAgICAgICJ1bmtub3duIHR5cGUgJyVkJyAoaW50ZXJuYWwgZnNjayBlcnJvcikiLAorCQkgICAgICBvYmotPnR5cGUpOwogfQogCiBpbnQgZnNja19lcnJvcl9mdW5jdGlvbihzdHJ1Y3QgZnNja19vcHRpb25zICpvLAotCXN0cnVjdCBvYmplY3QgKm9iaiwgaW50IG1zZ190eXBlLCBjb25zdCBjaGFyICptZXNzYWdlKQorCQkJY29uc3Qgc3RydWN0IG9iamVjdF9pZCAqb2lkLAorCQkJZW51bSBvYmplY3RfdHlwZSBvYmplY3RfdHlwZSwKKwkJCWludCBtc2dfdHlwZSwgY29uc3QgY2hhciAqbWVzc2FnZSkKIHsKIAlpZiAobXNnX3R5cGUgPT0gRlNDS19XQVJOKSB7Ci0JCXdhcm5pbmcoIm9iamVjdCAlczogJXMiLCBkZXNjcmliZV9vYmplY3Qobywgb2JqKSwgbWVzc2FnZSk7CisJCXdhcm5pbmcoIm9iamVjdCAlczogJXMiLCBmc2NrX2Rlc2NyaWJlX29iamVjdChvLCBvaWQpLCBtZXNzYWdlKTsKIAkJcmV0dXJuIDA7CiAJfQotCWVycm9yKCJvYmplY3QgJXM6ICVzIiwgZGVzY3JpYmVfb2JqZWN0KG8sIG9iaiksIG1lc3NhZ2UpOworCWVycm9yKCJvYmplY3QgJXM6ICVzIiwgZnNja19kZXNjcmliZV9vYmplY3Qobywgb2lkKSwgbWVzc2FnZSk7CiAJcmV0dXJuIDE7CiB9CiAKQEAgLTEwNDcsNyArMTAxNSw2IEBACiAKIAlvaWRzZXRfaXRlcl9pbml0KCZnaXRtb2R1bGVzX2ZvdW5kLCAmaXRlcik7CiAJd2hpbGUgKChvaWQgPSBvaWRzZXRfaXRlcl9uZXh0KCZpdGVyKSkpIHsKLQkJc3RydWN0IGJsb2IgKmJsb2I7CiAJCWVudW0gb2JqZWN0X3R5cGUgdHlwZTsKIAkJdW5zaWduZWQgbG9uZyBzaXplOwogCQljaGFyICpidWY7CkBAIC0xMDU1LDI5ICsxMDIyLDIyIEBACiAJCWlmIChvaWRzZXRfY29udGFpbnMoJmdpdG1vZHVsZXNfZG9uZSwgb2lkKSkKIAkJCWNvbnRpbnVlOwogCi0JCWJsb2IgPSBsb29rdXBfYmxvYih0aGVfcmVwb3NpdG9yeSwgb2lkKTsKLQkJaWYgKCFibG9iKSB7Ci0JCQlzdHJ1Y3Qgb2JqZWN0ICpvYmogPSBsb29rdXBfdW5rbm93bl9vYmplY3Qob2lkKTsKLQkJCXJldCB8PSByZXBvcnQob3B0aW9ucywgb2JqLAotCQkJCSAgICAgIEZTQ0tfTVNHX0dJVE1PRFVMRVNfQkxPQiwKLQkJCQkgICAgICAibm9uLWJsb2IgZm91bmQgYXQgLmdpdG1vZHVsZXMiKTsKLQkJCWNvbnRpbnVlOwotCQl9Ci0KIAkJYnVmID0gcmVhZF9vYmplY3RfZmlsZShvaWQsICZ0eXBlLCAmc2l6ZSk7CiAJCWlmICghYnVmKSB7Ci0JCQlpZiAoaXNfcHJvbWlzb3Jfb2JqZWN0KCZibG9iLT5vYmplY3Qub2lkKSkKKwkJCWlmIChpc19wcm9taXNvcl9vYmplY3Qob2lkKSkKIAkJCQljb250aW51ZTsKLQkJCXJldCB8PSByZXBvcnQob3B0aW9ucywgJmJsb2ItPm9iamVjdCwKKwkJCXJldCB8PSByZXBvcnQob3B0aW9ucywKKwkJCQkgICAgICBvaWQsIE9CSl9CTE9CLAogCQkJCSAgICAgIEZTQ0tfTVNHX0dJVE1PRFVMRVNfTUlTU0lORywKIAkJCQkgICAgICAidW5hYmxlIHRvIHJlYWQgLmdpdG1vZHVsZXMgYmxvYiIpOwogCQkJY29udGludWU7CiAJCX0KIAogCQlpZiAodHlwZSA9PSBPQkpfQkxPQikKLQkJCXJldCB8PSBmc2NrX2Jsb2IoYmxvYiwgYnVmLCBzaXplLCBvcHRpb25zKTsKKwkJCXJldCB8PSBmc2NrX2Jsb2Iob2lkLCBidWYsIHNpemUsIG9wdGlvbnMpOwogCQllbHNlCi0JCQlyZXQgfD0gcmVwb3J0KG9wdGlvbnMsICZibG9iLT5vYmplY3QsCisJCQlyZXQgfD0gcmVwb3J0KG9wdGlvbnMsCisJCQkJICAgICAgb2lkLCB0eXBlLAogCQkJCSAgICAgIEZTQ0tfTVNHX0dJVE1PRFVMRVNfQkxPQiwKIAkJCQkgICAgICAibm9uLWJsb2IgZm91bmQgYXQgLmdpdG1vZHVsZXMiKTsKIAkJZnJlZShidWYpOwpkaWZmIC0tZ2l0IGEvZnNjay5oIGIvZnNjay5oCmluZGV4IGI5NTU5NWEuLjY5Y2Y3MTUgMTAwNjQ0Ci0tLSBhL2ZzY2suaAorKysgYi9mc2NrLmgKQEAgLTI3LDEwICsyNywxMiBAQAogCiAvKiBjYWxsYmFjayBmb3IgZnNja19vYmplY3QsIHR5cGUgaXMgRlNDS19FUlJPUiBvciBGU0NLX1dBUk4gKi8KIHR5cGVkZWYgaW50ICgqZnNja19lcnJvcikoc3RydWN0IGZzY2tfb3B0aW9ucyAqbywKLQlzdHJ1Y3Qgb2JqZWN0ICpvYmosIGludCB0eXBlLCBjb25zdCBjaGFyICptZXNzYWdlKTsKKwkJCSAgY29uc3Qgc3RydWN0IG9iamVjdF9pZCAqb2lkLCBlbnVtIG9iamVjdF90eXBlIG9iamVjdF90eXBlLAorCQkJICBpbnQgbXNnX3R5cGUsIGNvbnN0IGNoYXIgKm1lc3NhZ2UpOwogCiBpbnQgZnNja19lcnJvcl9mdW5jdGlvbihzdHJ1Y3QgZnNja19vcHRpb25zICpvLAotCXN0cnVjdCBvYmplY3QgKm9iaiwgaW50IHR5cGUsIGNvbnN0IGNoYXIgKm1lc3NhZ2UpOworCQkJY29uc3Qgc3RydWN0IG9iamVjdF9pZCAqb2lkLCBlbnVtIG9iamVjdF90eXBlIG9iamVjdF90eXBlLAorCQkJaW50IG1zZ190eXBlLCBjb25zdCBjaGFyICptZXNzYWdlKTsKIAogc3RydWN0IGZzY2tfb3B0aW9ucyB7CiAJZnNja193YWxrX2Z1bmMgd2FsazsKQEAgLTM4LDcgKzQwLDcgQEAKIAl1bnNpZ25lZCBzdHJpY3Q6MTsKIAlpbnQgKm1zZ190eXBlOwogCXN0cnVjdCBvaWRzZXQgc2tpcGxpc3Q7Ci0Jc3RydWN0IGRlY29yYXRpb24gKm9iamVjdF9uYW1lczsKKwlraF9vaWRfbWFwX3QgKm9iamVjdF9uYW1lczsKIH07CiAKICNkZWZpbmUgRlNDS19PUFRJT05TX0RFRkFVTFQgeyBOVUxMLCBmc2NrX2Vycm9yX2Z1bmN0aW9uLCAwLCBOVUxMLCBPSURTRVRfSU5JVCB9CkBAIC01Miw3ICs1NCwxMSBAQAogICogICAgMAkJZXZlcnl0aGluZyBPSwogICovCiBpbnQgZnNja193YWxrKHN0cnVjdCBvYmplY3QgKm9iaiwgdm9pZCAqZGF0YSwgc3RydWN0IGZzY2tfb3B0aW9ucyAqb3B0aW9ucyk7Ci0vKiBJZiBOVUxMIGlzIHBhc3NlZCBmb3IgZGF0YSwgd2UgYXNzdW1lIHRoZSBvYmplY3QgaXMgbG9jYWwgYW5kIHJlYWQgaXQuICovCisKKy8qCisgKiBCbG9iIG9iamVjdHMgbXkgcGFzcyBhIE5VTEwgZGF0YSBwb2ludGVyLCB3aGljaCBpbmRpY2F0ZXMgdGhleSBhcmUgdG9vIGxhcmdlCisgKiB0byBmaXQgaW4gbWVtb3J5LiBBbGwgb3RoZXIgdHlwZXMgbXVzdCBwYXNzIGEgcmVhbCBidWZmZXIuCisgKi8KIGludCBmc2NrX29iamVjdChzdHJ1Y3Qgb2JqZWN0ICpvYmosIHZvaWQgKmRhdGEsIHVuc2lnbmVkIGxvbmcgc2l6ZSwKIAlzdHJ1Y3QgZnNja19vcHRpb25zICpvcHRpb25zKTsKIApAQCAtNjMsNCArNjksMjkgQEAKICAqLwogaW50IGZzY2tfZmluaXNoKHN0cnVjdCBmc2NrX29wdGlvbnMgKm9wdGlvbnMpOwogCisvKgorICogU3Vic3lzdGVtIGZvciBzdG9yaW5nIGh1bWFuLXJlYWRhYmxlIG5hbWVzIGZvciBlYWNoIG9iamVjdC4KKyAqCisgKiBJZiBmc2NrX2VuYWJsZV9vYmplY3RfbmFtZXMoKSBoYXMgbm90IGJlZW4gY2FsbGVkLCBhbGwgb3RoZXIgZnVuY3Rpb25zIGFyZQorICogbm9vcHMuCisgKgorICogVXNlIGZzY2tfcHV0X29iamVjdF9uYW1lKCkgdG8gc2VlZCBpbml0aWFsIG5hbWVzIChlLmcuIGZyb20gcmVmbmFtZXMpOyB0aGUKKyAqIGZzY2sgY29kZSB3aWxsIGV4dGVuZCB0aGF0IHdoaWxlIHdhbGtpbmcgdHJlZXMsIGV0Yy4KKyAqCisgKiBVc2UgZnNja19nZXRfb2JqZWN0X25hbWUoKSB0byBnZXQgYSBzaW5nbGUgbmFtZSAob3IgTlVMTCBpZiBub25lKS4gT3IgdGhlCisgKiBtb3JlIGNvbnZlbmllbnQgZGVzY3JpYmVfb2JqZWN0KCksIHdoaWNoIGFsd2F5cyBwcm9kdWNlcyBhbiBvdXRwdXQgc3RyaW5nCisgKiB3aXRoIHRoZSBvaWQgY29tYmluZWQgd2l0aCB0aGUgbmFtZSAoaWYgYW55KS4gTm90ZSB0aGF0IHRoZSByZXR1cm4gdmFsdWUKKyAqIHBvaW50cyB0byBhIHJvdGF0aW5nIGFycmF5IG9mIHN0YXRpYyBidWZmZXJzLCBhbmQgbWF5IGJlIGludmFsaWRhdGVkIGJ5IGEKKyAqIHN1YnNlcXVlbnQgY2FsbC4KKyAqLwordm9pZCBmc2NrX2VuYWJsZV9vYmplY3RfbmFtZXMoc3RydWN0IGZzY2tfb3B0aW9ucyAqb3B0aW9ucyk7Citjb25zdCBjaGFyICpmc2NrX2dldF9vYmplY3RfbmFtZShzdHJ1Y3QgZnNja19vcHRpb25zICpvcHRpb25zLAorCQkJCSBjb25zdCBzdHJ1Y3Qgb2JqZWN0X2lkICpvaWQpOworX19hdHRyaWJ1dGVfXygoZm9ybWF0IChwcmludGYsMyw0KSkpCit2b2lkIGZzY2tfcHV0X29iamVjdF9uYW1lKHN0cnVjdCBmc2NrX29wdGlvbnMgKm9wdGlvbnMsCisJCQkgIGNvbnN0IHN0cnVjdCBvYmplY3RfaWQgKm9pZCwKKwkJCSAgY29uc3QgY2hhciAqZm10LCAuLi4pOworY29uc3QgY2hhciAqZnNja19kZXNjcmliZV9vYmplY3Qoc3RydWN0IGZzY2tfb3B0aW9ucyAqb3B0aW9ucywKKwkJCQkgY29uc3Qgc3RydWN0IG9iamVjdF9pZCAqb2lkKTsKKwogI2VuZGlmCmRpZmYgLS1naXQgYS9naXQtYWRkLS1pbnRlcmFjdGl2ZS5wZXJsIGIvZ2l0LWFkZC0taW50ZXJhY3RpdmUucGVybAppbmRleCBjMjBhZTllLi41MjY1OWJiIDEwMDc1NQotLS0gYS9naXQtYWRkLS1pbnRlcmFjdGl2ZS5wZXJsCisrKyBiL2dpdC1hZGQtLWludGVyYWN0aXZlLnBlcmwKQEAgLTE1NDEsNyArMTU0MSw3IEBACiAJCWZvciAoQHskaHVua1skaXhde0RJU1BMQVl9fSkgewogCQkJcHJpbnQ7CiAJCX0KLQkJcHJpbnQgY29sb3JlZCAkcHJvbXB0X2NvbG9yLAorCQlwcmludCBjb2xvcmVkICRwcm9tcHRfY29sb3IsICIoIiwgKCRpeCsxKSwgIi8kbnVtKSAiLAogCQkJc3ByaW50ZihfXygkcGF0Y2hfdXBkYXRlX3Byb21wdF9tb2Rlc3skcGF0Y2hfbW9kZX17JGh1bmtbJGl4XXtUWVBFfX0pLCAkb3RoZXIpOwogCiAJCW15ICRsaW5lID0gcHJvbXB0X3NpbmdsZV9jaGFyYWN0ZXI7CmRpZmYgLS1naXQgYS9naXQtY29tcGF0LXV0aWwuaCBiL2dpdC1jb21wYXQtdXRpbC5oCmluZGV4IDgzYmU4OWQuLmRkYjdmY2EgMTAwNjQ0Ci0tLSBhL2dpdC1jb21wYXQtdXRpbC5oCisrKyBiL2dpdC1jb21wYXQtdXRpbC5oCkBAIC03Nyw3ICs3Nyw3IEBACiAjZW5kaWYKIC8qCiAgKiBBUlJBWV9TSVpFIC0gZ2V0IHRoZSBudW1iZXIgb2YgZWxlbWVudHMgaW4gYSB2aXNpYmxlIGFycmF5Ci0gKiAgPGF0PiB4OiB0aGUgYXJyYXkgd2hvc2Ugc2l6ZSB5b3Ugd2FudC4KKyAqIEB4OiB0aGUgYXJyYXkgd2hvc2Ugc2l6ZSB5b3Ugd2FudC4KICAqCiAgKiBUaGlzIGRvZXMgbm90IHdvcmsgb24gcG9pbnRlcnMsIG9yIGFycmF5cyBkZWNsYXJlZCBhcyBbXSwgb3IKICAqIGZ1bmN0aW9uIHBhcmFtZXRlcnMuICBXaXRoIGNvcnJlY3QgY29tcGlsZXIgc3VwcG9ydCwgc3VjaCB1c2FnZQpAQCAtMzIwLDMwICszMjAsMTEgQEAKICNkZWZpbmUgUEFUSF9NQVggNDA5NgogI2VuZGlmCiAKLSNpZm5kZWYgUFJJdU1BWAotI2RlZmluZSBQUkl1TUFYICJsbHUiCi0jZW5kaWYKLQotI2lmbmRlZiBTQ051TUFYCi0jZGVmaW5lIFNDTnVNQVggUFJJdU1BWAotI2VuZGlmCi0KLSNpZm5kZWYgUFJJdTMyCi0jZGVmaW5lIFBSSXUzMiAidSIKLSNlbmRpZgotCi0jaWZuZGVmIFBSSXgzMgotI2RlZmluZSBQUkl4MzIgIngiCi0jZW5kaWYKLQotI2lmbmRlZiBQUklvMzIKLSNkZWZpbmUgUFJJbzMyICJvIgotI2VuZGlmCi0KIHR5cGVkZWYgdWludG1heF90IHRpbWVzdGFtcF90OwogI2RlZmluZSBQUkl0aW1lIFBSSXVNQVgKICNkZWZpbmUgcGFyc2VfdGltZXN0YW1wIHN0cnRvdW1heAogI2RlZmluZSBUSU1FX01BWCBVSU5UTUFYX01BWAorI2RlZmluZSBUSU1FX01JTiAwCiAKICNpZm5kZWYgUEFUSF9TRVAKICNkZWZpbmUgUEFUSF9TRVAgJzonCkBAIC04MTgsOSArNzk5LDYgQEAKIGludCBnaXRfYXRleGl0KHZvaWQgKCpoYW5kbGVyKSh2b2lkKSk7CiAjZW5kaWYKIAotdHlwZWRlZiB2b2lkICgqdHJ5X3RvX2ZyZWVfdCkoc2l6ZV90KTsKLXRyeV90b19mcmVlX3Qgc2V0X3RyeV90b19mcmVlX3JvdXRpbmUodHJ5X3RvX2ZyZWVfdCk7Ci0KIHN0YXRpYyBpbmxpbmUgc2l6ZV90IHN0X2FkZChzaXplX3QgYSwgc2l6ZV90IGIpCiB7CiAJaWYgKHVuc2lnbmVkX2FkZF9vdmVyZmxvd3MoYSwgYikpCkBAIC0xMDk0LDEwICsxMDcyLDEwIEBACiAJcmV0dXJuIDA7CiB9CiAKK3ZvaWQgZ2l0X3N0YWJsZV9xc29ydCh2b2lkICpiYXNlLCBzaXplX3Qgbm1lbWIsIHNpemVfdCBzaXplLAorCQkgICAgICBpbnQoKmNvbXBhcikoY29uc3Qgdm9pZCAqLCBjb25zdCB2b2lkICopKTsKICNpZmRlZiBJTlRFUk5BTF9RU09SVAotdm9pZCBnaXRfcXNvcnQodm9pZCAqYmFzZSwgc2l6ZV90IG5tZW1iLCBzaXplX3Qgc2l6ZSwKLQkgICAgICAgaW50KCpjb21wYXIpKGNvbnN0IHZvaWQgKiwgY29uc3Qgdm9pZCAqKSk7Ci0jZGVmaW5lIHFzb3J0IGdpdF9xc29ydAorI2RlZmluZSBxc29ydCBnaXRfc3RhYmxlX3Fzb3J0CiAjZW5kaWYKIAogI2RlZmluZSBRU09SVChiYXNlLCBuLCBjb21wYXIpIHNhbmVfcXNvcnQoKGJhc2UpLCAobiksIHNpemVvZigqKGJhc2UpKSwgY29tcGFyKQpAQCAtMTEwOCw2ICsxMDg2LDkgQEAKIAkJcXNvcnQoYmFzZSwgbm1lbWIsIHNpemUsIGNvbXBhcik7CiB9CiAKKyNkZWZpbmUgU1RBQkxFX1FTT1JUKGJhc2UsIG4sIGNvbXBhcikgXAorCWdpdF9zdGFibGVfcXNvcnQoKGJhc2UpLCAobiksIHNpemVvZigqKGJhc2UpKSwgY29tcGFyKQorCiAjaWZuZGVmIEhBVkVfSVNPX1FTT1JUX1MKIGludCBnaXRfcXNvcnRfcyh2b2lkICpiYXNlLCBzaXplX3Qgbm1lbWIsIHNpemVfdCBzaXplLAogCQlpbnQgKCpjb21wYXIpKGNvbnN0IHZvaWQgKiwgY29uc3Qgdm9pZCAqLCB2b2lkICopLCB2b2lkICpjdHgpOwpAQCAtMTMxMiw0ICsxMjkzLDQyIEBACiAgKi8KICNpbmNsdWRlICJiYW5uZWQuaCIKIAorLyoKKyAqIGNvbnRhaW5lcl9vZiAtIEdldCB0aGUgYWRkcmVzcyBvZiBhbiBvYmplY3QgY29udGFpbmluZyBhIGZpZWxkLgorICoKKyAqIEBwdHI6IHBvaW50ZXIgdG8gdGhlIGZpZWxkLgorICogQHR5cGU6IHR5cGUgb2YgdGhlIG9iamVjdC4KKyAqIEBtZW1iZXI6IG5hbWUgb2YgdGhlIGZpZWxkIHdpdGhpbiB0aGUgb2JqZWN0LgorICovCisjZGVmaW5lIGNvbnRhaW5lcl9vZihwdHIsIHR5cGUsIG1lbWJlcikgXAorCSgodHlwZSAqKSAoKGNoYXIgKikocHRyKSAtIG9mZnNldG9mKHR5cGUsIG1lbWJlcikpKQorCisvKgorICogaGVscGVyIGZ1bmN0aW9uIGZvciBgY29udGFpbmVyX29mX29yX251bGwnIHRvIGF2b2lkIG11bHRpcGxlCisgKiBldmFsdWF0aW9uIG9mIEBwdHIKKyAqLworc3RhdGljIGlubGluZSB2b2lkICpjb250YWluZXJfb2Zfb3JfbnVsbF9vZmZzZXQodm9pZCAqcHRyLCBzaXplX3Qgb2Zmc2V0KQoreworCXJldHVybiBwdHIgPyAoY2hhciAqKXB0ciAtIG9mZnNldCA6IE5VTEw7Cit9CisKKy8qCisgKiBsaWtlIGBjb250YWluZXJfb2YnLCBidXQgYWxsb3dzIHJldHVybmVkIHZhbHVlIHRvIGJlIE5VTEwKKyAqLworI2RlZmluZSBjb250YWluZXJfb2Zfb3JfbnVsbChwdHIsIHR5cGUsIG1lbWJlcikgXAorCSh0eXBlICopY29udGFpbmVyX29mX29yX251bGxfb2Zmc2V0KHB0ciwgb2Zmc2V0b2YodHlwZSwgbWVtYmVyKSkKKworLyoKKyAqIGxpa2Ugb2Zmc2V0b2YoKSwgYnV0IHRha2VzIGEgcG9pbnRlciB0byBhIGEgdmFyaWFibGUgb2YgdHlwZSB3aGljaAorICogY29udGFpbnMgQG1lbWJlciwgaW5zdGVhZCBvZiBhIHNwZWNpZmllZCB0eXBlLgorICogQHB0ciBpcyBzdWJqZWN0IHRvIG11bHRpcGxlIGV2YWx1YXRpb24gc2luY2Ugd2UgY2FuJ3QgcmVseSBvbiBfX3R5cGVvZl9fCisgKiBldmVyeXdoZXJlLgorICovCisjaWYgZGVmaW5lZChfX0dOVUNfXykgLyogY2xhbmcgc2V0cyB0aGlzLCB0b28gKi8KKyNkZWZpbmUgT0ZGU0VUT0ZfVkFSKHB0ciwgbWVtYmVyKSBvZmZzZXRvZihfX3R5cGVvZl9fKCpwdHIpLCBtZW1iZXIpCisjZWxzZSAvKiAhX19HTlVDX18gKi8KKyNkZWZpbmUgT0ZGU0VUT0ZfVkFSKHB0ciwgbWVtYmVyKSBcCisJKCh1aW50cHRyX3QpJihwdHIpLT5tZW1iZXIgLSAodWludHB0cl90KShwdHIpKQorI2VuZGlmIC8qICFfX0dOVUNfXyAqLworCiAjZW5kaWYKZGlmZiAtLWdpdCBhL2dpdC1jdnNpbXBvcnQucGVybCBiL2dpdC1jdnNpbXBvcnQucGVybAppbmRleCBiMzE2MTNjLi4xMDU3ZjM4IDEwMDc1NQotLS0gYS9naXQtY3ZzaW1wb3J0LnBlcmwKKysrIGIvZ2l0LWN2c2ltcG9ydC5wZXJsCkBAIC02MDAsNyArNjAwLDcgQEAKIHN1YiBwZGF0ZSgkKSB7CiAJbXkgKCRkKSA9IEBfOwogCW0jKFxkezIsNH0pLyhcZFxkKS8oXGRcZClccyhcZFxkKTooXGRcZCkoPzo6KFxkXGQpKT8jCi0JCW9yIGRpZSAiVW5wYXJzZWFibGUgZGF0ZTogJGRcbiI7CisJCW9yIGRpZSAiVW5wYXJzYWJsZSBkYXRlOiAkZFxuIjsKIAlteSAkeT0kMTsKIAkkeSs9MTAwIGlmICR5PDcwOwogCSR5Kz0xOTAwIGlmICR5PDEwMDA7CmRpZmYgLS1naXQgYS9naXQtZmlsdGVyLWJyYW5jaC5zaCBiL2dpdC1maWx0ZXItYnJhbmNoLnNoCmluZGV4IDVjNWFmYTIuLmZlYTc5NjQgMTAwNzU1Ci0tLSBhL2dpdC1maWx0ZXItYnJhbmNoLnNoCisrKyBiL2dpdC1maWx0ZXItYnJhbmNoLnNoCkBAIC04Myw2ICs4MywyMCBAQAogCWZpbmlzaF9pZGVudCBDT01NSVRURVIKIH0KIAoraWYgdGVzdCAteiAiJEZJTFRFUl9CUkFOQ0hfU1FVRUxDSF9XQVJOSU5HJEdJVF9URVNUX0RJU0FMTE9XX0FCQlJFVklBVEVEX09QVElPTlMiCit0aGVuCisJY2F0IDw8RU9GCitXQVJOSU5HOiBnaXQtZmlsdGVyLWJyYW5jaCBoYXMgYSBnbHV0IG9mIGdvdGNoYXMgZ2VuZXJhdGluZyBtYW5nbGVkIGhpc3RvcnkKKwkgcmV3cml0ZXMuICBIaXQgQ3RybC1DIGJlZm9yZSBwcm9jZWVkaW5nIHRvIGFib3J0LCB0aGVuIHVzZSBhbgorCSBhbHRlcm5hdGl2ZSBmaWx0ZXJpbmcgdG9vbCBzdWNoIGFzICdnaXQgZmlsdGVyLXJlcG8nCisJIChodHRwczovL2dpdGh1Yi5jb20vbmV3cmVuL2dpdC1maWx0ZXItcmVwby8pIGluc3RlYWQuICBTZWUgdGhlCisJIGZpbHRlci1icmFuY2ggbWFudWFsIHBhZ2UgZm9yIG1vcmUgZGV0YWlsczsgdG8gc3F1ZWxjaCB0aGlzIHdhcm5pbmcsCisJIHNldCBGSUxURVJfQlJBTkNIX1NRVUVMQ0hfV0FSTklORz0xLgorRU9GCisJc2xlZXAgMTAKKwlwcmludGYgIlByb2NlZWRpbmcgd2l0aCBmaWx0ZXItYnJhbmNoLi4uXG5cbiIKK2ZpCisKIFVTQUdFPSJbLS1zZXR1cCA8Y29tbWFuZD5dIFstLXN1YmRpcmVjdG9yeS1maWx0ZXIgPGRpcmVjdG9yeT5dIFstLWVudi1maWx0ZXIgPGNvbW1hbmQ+XQogCVstLXRyZWUtZmlsdGVyIDxjb21tYW5kPl0gWy0taW5kZXgtZmlsdGVyIDxjb21tYW5kPl0KIAlbLS1wYXJlbnQtZmlsdGVyIDxjb21tYW5kPl0gWy0tbXNnLWZpbHRlciA8Y29tbWFuZD5dCmRpZmYgLS1naXQgYS9naXQtZ3VpL1JFQURNRS5tZCBiL2dpdC1ndWkvUkVBRE1FLm1kCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjVjZTIxMjIKLS0tIC9kZXYvbnVsbAorKysgYi9naXQtZ3VpL1JFQURNRS5tZApAQCAtMCwwICsxLDE3NCBAQAorIyBHaXQgR1VJIC0gQSBncmFwaGljYWwgdXNlciBpbnRlcmZhY2UgZm9yIEdpdAorCitHaXQgR1VJIGFsbG93cyB5b3UgdG8gdXNlIHRoZSBbR2l0IHNvdXJjZSBjb250cm9sIG1hbmFnZW1lbnQKK3Rvb2xzXShodHRwczovL2dpdC1zY20uY29tLykgdmlhIGEgR1VJLiBUaGlzIGluY2x1ZGVzIHN0YWdpbmcsIGNvbW1pdHRpbmcsCithZGRpbmcsIHB1c2hpbmcsIGV0Yy4gSXQgY2FuIGFsc28gYmUgdXNlZCBhcyBhIGJsYW1lIHZpZXdlciwgYSB0cmVlIGJyb3dzZXIsCithbmQgYSBjaXRvb2wgKG1ha2UgZXhhY3RseSBvbmUgY29tbWl0IGJlZm9yZSBleGl0aW5nIGFuZCByZXR1cm5pbmcgdG8gc2hlbGwpLgorTW9yZSBkZXRhaWxzIGFib3V0IEdpdCBHVUkgY2FuIGJlIGZvdW5kIGluIGl0cyBtYW51YWwgcGFnZSBieSBlaXRoZXIgcnVubmluZworYG1hbiBnaXQtZ3VpYCwgb3IgYnkgdmlzaXRpbmcgdGhlIFtvbmxpbmUgbWFudWFsCitwYWdlXShodHRwczovL2dpdC1zY20uY29tL2RvY3MvZ2l0LWd1aSkuCisKK0dpdCBHVUkgd2FzIGluaXRpYWxseSB3cml0dGVuIGJ5IFNoYXduIE8uIFBlYXJjZSwgYW5kIGlzIGRpc3RyaWJ1dGVkIHdpdGggdGhlCitzdGFuZGFyZCBHaXQgaW5zdGFsbGF0aW9uLgorCisjIEJ1aWxkaW5nIGFuZCBpbnN0YWxsaW5nCisKK1lvdSBuZWVkIHRvIGhhdmUgdGhlIGZvbGxvd2luZyBkZXBlbmRlbmNpZXMgaW5zdGFsbGVkIGJlZm9yZSB5b3UgYmVnaW46CisKKy0gR2l0CistIFRjbAorLSBUaworLSB3aXNoCistIEdpdGsgKG5lZWRlZCBmb3IgYnJvd3NpbmcgaGlzdG9yeSkKKy0gbXNnZm10CisKK01vc3Qgb2YgR2l0IEdVSSBpcyB3cml0dGVuIGluIFRjbCwgc28gdGhlcmUgaXMgbm8gY29tcGlsYXRpb24gaW52b2x2ZWQuIFN0aWxsLAorc29tZSB0aGluZ3MgZG8gbmVlZCB0byBiZSBkb25lIChtb3N0bHkgc29tZSBzdWJzdGl0dXRpb25zKSwgc28geW91IGRvIG5lZWQgdG8KKyJidWlsZCIgaXQuCisKK1lvdSBjYW4gYnVpbGQgR2l0IEdVSSB1c2luZzoKKworYGBgCittYWtlCitgYGAKKworQW5kIHRoZW4gaW5zdGFsbCBpdCB1c2luZzoKKworYGBgCittYWtlIGluc3RhbGwKK2BgYAorCitZb3UgcHJvYmFibHkgbmVlZCB0byBoYXZlIHJvb3QvYWRtaW4gcGVybWlzc2lvbnMgdG8gaW5zdGFsbC4KKworIyBDb250cmlidXRpbmcKKworVGhlIHByb2plY3QgaXMgY3VycmVudGx5IG1haW50YWluZWQgYnkgUHJhdHl1c2ggWWFkYXYgb3ZlciBhdAoraHR0cHM6Ly9naXRodWIuY29tL3ByYXRpMDEwMC9naXQtZ3VpLiBFdmVuIHRob3VnaCB0aGUgcHJvamVjdCBpcyBob3N0ZWQgYXQKK0dpdEh1YiwgdGhlIGRldmVsb3BtZW50IGRvZXMgbm90IGhhcHBlbiBvdmVyIEdpdEh1YiBJc3N1ZXMgYW5kIFB1bGwgUmVxdWVzdHMuCitJbnN0ZWFkLCBhbiBlbWFpbCBiYXNlZCB3b3JrZmxvdyBpcyB1c2VkLiBUaGUgR2l0IG1haWxpbmcgbGlzdAorW2dpdEB2Z2VyLmtlcm5lbC5vcmddKG1haWx0bzpnaXRAdmdlci5rZXJuZWwub3JnKSBpcyB3aGVyZSB0aGUgcGF0Y2hlcyBhcmUKK2Rpc2N1c3NlZCBhbmQgcmV2aWV3ZWQuCisKK01vcmUgaW5mb3JtYXRpb24gYWJvdXQgdGhlIEdpdCBtYWlsaW5nIGxpc3QgYW5kIGluc3RydWN0aW9ucyB0byBzdWJzY3JpYmUgY2FuCitiZSBmb3VuZCBbaGVyZV0oaHR0cHM6Ly9naXQud2lraS5rZXJuZWwub3JnL2luZGV4LnBocC9HaXRDb21tdW5pdHkpLgorCisjIyBTZW5kaW5nIHlvdXIgY2hhbmdlcworCitTaW5jZSB0aGUgZGV2ZWxvcG1lbnQgaGFwcGVucyBvdmVyIGVtYWlsLCB5b3UgbmVlZCB0byBzZW5kIGluIHlvdXIgY29tbWl0cyBpbgordGV4dCBmb3JtYXQuIENvbW1pdHMgY2FuIGJlIGNvbnZlcnRlZCB0byBlbWFpbHMgdmlhIHRoZSB0d28gdG9vbHMgcHJvdmlkZWQgYnkKK0dpdDogYGdpdC1zZW5kLWVtYWlsYCBhbmQgYGdpdC1mb3JtYXQtcGF0Y2hgLgorCitZb3UgY2FuIHVzZSBgZ2l0LWZvcm1hdC1wYXRjaGAgdG8gZ2VuZXJhdGUgcGF0Y2hlcyBpbiBtYm94IGZvcm1hdCBmcm9tIHlvdXIKK2NvbW1pdHMgdGhhdCBjYW4gdGhlbiBiZSBzZW50IHZpYSBlbWFpbC4gTGV0J3Mgc2F5IHlvdSBhcmUgd29ya2luZyBvbiBhIGJyYW5jaAorY2FsbGVkICdmb28nIHRoYXQgd2FzIGNyZWF0ZWQgb24gdG9wIG9mICdtYXN0ZXInLiBZb3UgY2FuIHJ1bjoKKworYGBgCitnaXQgZm9ybWF0LXBhdGNoIC1vIG91dHB1dF9kaXIgbWFzdGVyLi5mb28KK2BgYAorCit0byBjb252ZXJ0IGFsbCB0aGUgZXh0cmEgY29tbWl0cyBpbiAnZm9vJyBpbnRvIGEgc2V0IG9mIHBhdGNoZXMgc2F2ZWQgaW4gdGhlCitmb2xkZXIgYG91dHB1dF9kaXJgLgorCitJZiB5b3UgYXJlIHNlbmRpbmcgbXVsdGlwbGUgcGF0Y2hlcywgaXQgaXMgcmVjb21tZW5kZWQgdG8gaW5jbHVkZSBhIGNvdmVyCitsZXR0ZXIuIEEgY292ZXIgbGV0dGVyIGlzIGFuIGVtYWlsIGV4cGxhaW5pbmcgaW4gYnJpZWYgd2hhdCB0aGUgc2VyaWVzIGlzCitzdXBwb3NlZCB0byBkby4gQSBjb3ZlciBsZXR0ZXIgdGVtcGxhdGUgY2FuIGJlIGdlbmVyYXRlZCBieSBwYXNzaW5nCitgLS1jb3Zlci1sZXR0ZXJgIHRvIGBnaXQtZm9ybWF0LXBhdGNoYC4KKworQWZ0ZXIgeW91IHNlbmQgeW91ciBwYXRjaGVzLCB5b3UgbWlnaHQgZ2V0IGEgcmV2aWV3IHN1Z2dlc3Rpbmcgc29tZSBjaGFuZ2VzLgorTWFrZSB0aG9zZSBjaGFuZ2VzLCBhbmQgcmUtc2VuZCB5b3VyIHBhdGNoKGVzKSBpbiByZXBseSB0byB0aGUgZmlyc3QgcGF0Y2ggb2YKK3lvdXIgaW5pdGlhbCB2ZXJzaW9uLiBBbHNvIHBsZWFzZSBtZW50aW9uIHRoZSB2ZXJzaW9uIG9mIHRoZSBwYXRjaC4gVGhpcyBjYW4gYmUKK2RvbmUgYnkgcGFzc2luZyBgLXYgWGAgdG8gYGdpdC1mb3JtYXQtcGF0Y2hgLCB3aGVyZSAnWCcgaXMgdGhlIHZlcnNpb24gbnVtYmVyCitvZiB0aGUgcGF0Y2goZXMpLgorCisjIyMgVXNpbmcgZ2l0LXNlbmQtZW1haWwKKworWW91IGNhbiB1c2UgYGdpdC1zZW5kLWVtYWlsYCB0byBzZW5kIHBhdGNoZXMgZ2VuZXJhdGVkIHZpYSBgZ2l0LWZvcm1hdC1wYXRjaGAuCitXaGlsZSB5b3UgY2FuIGRpcmVjdGx5IHNlbmQgcGF0Y2hlcyB2aWEgYGdpdC1zZW5kLWVtYWlsYCwgaXQgaXMgcmVjb21tZW5kZWQKK3RoYXQgeW91IGZpcnN0IHVzZSBgZ2l0LWZvcm1hdC1wYXRjaGAgdG8gZ2VuZXJhdGUgdGhlIGVtYWlscywgYXVkaXQgdGhlbSwgYW5kCit0aGVuIHNlbmQgdGhlbSB2aWEgYGdpdC1zZW5kLWVtYWlsYC4KKworQSBwcmV0dHkgZ29vZCBndWlkZSB0byBjb25maWd1cmluZyBhbmQgdXNpbmcgYGdpdC1zZW5kLWVtYWlsYCBjYW4gYmUgZm91bmQKK1toZXJlXShodHRwczovL3d3dy5mcmVlZGVza3RvcC5vcmcvd2lraS9Tb2Z0d2FyZS9QdWxzZUF1ZGlvL0hvd1RvVXNlR2l0U2VuZEVtYWlsLykKKworIyMjIFVzaW5nIHlvdXIgZW1haWwgY2xpZW50CisKK0lmIHlvdXIgZW1haWwgY2xpZW50IHN1cHBvcnRzIHNlbmRpbmcgbWJveCBmb3JtYXQgZW1haWxzLCB5b3UgY2FuIHVzZQorYGdpdC1mb3JtYXQtcGF0Y2hgIHRvIGdldCBhbiBtYm94IGZpbGUgZm9yIGVhY2ggY29tbWl0LCBhbmQgdGhlbiBzZW5kIHRoZW0uIElmCit0aGVyZSBpcyBtb3JlIHRoYW4gb25lIHBhdGNoIGluIHRoZSBzZXJpZXMsIHRoZW4gYWxsIHBhdGNoZXMgYWZ0ZXIgdGhlIGZpcnN0CitwYXRjaCAob3IgdGhlIGNvdmVyIGxldHRlcikgbmVlZCB0byBiZSBzZW50IGFzIHJlcGxpZXMgdG8gdGhlIGZpcnN0LgorYGdpdC1zZW5kLWVtYWlsYCBkb2VzIHRoaXMgYnkgZGVmYXVsdC4KKworIyMjIFVzaW5nIEdpdEdpdEdhZGdldAorCitTaW5jZSBzb21lIHBlb3BsZSBwcmVmZXIgYSBHaXRIdWIgcHVsbCByZXF1ZXN0IGJhc2VkIHdvcmtmbG93LCB0aGV5IGNhbiB1c2UKK1tHaXRHaXRHYWRnZXRdKGh0dHBzOi8vZ2l0Z2l0Z2FkZ2V0LmdpdGh1Yi5pby8pIHRvIHNlbmQgaW4gcGF0Y2hlcy4gVGhlIHRvb2wKK3dhcyBvcmlnaW5hbGx5IHdyaXR0ZW4gZm9yIHNlbmRpbmcgcGF0Y2hlcyB0byB0aGUgR2l0IHByb2plY3QsIGJ1dCBpdCBub3cgYWxzbworc3VwcG9ydHMgc2VuZGluZyBwYXRjaGVzIGZvciBnaXQtZ3VpLgorCitJbnN0cnVjdGlvbnMgZm9yIHVzaW5nIEdpdEdpdEdhZGdldCB0byBzZW5kIGdpdC1ndWkgcGF0Y2hlcywgY291cnRlc3kgb2YKK0pvaGFubmVzIFNjaGluZGVsaW46CisKK0lmIHlvdSBkb24ndCBhbHJlYWR5IGhhdmUgYSBmb3JrIG9mIHRoZSBbZ2l0L2dpdF0oaHR0cHM6Ly9naXRodWIuY29tL2dpdC9naXQpCityZXBvLCB5b3UgbmVlZCB0byBtYWtlIG9uZS4gVGhlbiBjbG9uZSB5b3VyIGZvcms6CisKK2BgYAorZ2l0IGNsb25lIGh0dHBzOi8vZ2l0aHViLmNvbS88eW91ci11c2VybmFtZT4vZ2l0CitgYGAKKworVGhlbiBhZGQgR2l0R2l0R2FkZ2V0IGFzIGEgcmVtb3RlOgorCitgYGAKK2dpdCByZW1vdGUgYWRkIGdpdGdpdGdhZGdldCBodHRwczovL2dpdGh1Yi5jb20vZ2l0Z2l0Z2FkZ2V0L2dpdAorYGBgCisKK1RoZW4gZmV0Y2ggdGhlIGdpdC1ndWkgYnJhbmNoOgorCitgYGAKK2dpdCBmZXRjaCBnaXRnaXRnYWRnZXQgZ2l0LWd1aS9tYXN0ZXIKK2BgYAorCitUaGVuIGNyZWF0ZSBhIG5ldyBicmFuY2ggYmFzZWQgb24gZ2l0LWd1aS9tYXN0ZXI6CisKK2BgYAorZ2l0IGNoZWNrb3V0IC1iIDx5b3VyLWJyYW5jaC1uYW1lPiBnaXQtZ3VpL21hc3RlcgorYGBgCisKK01ha2Ugd2hhdGV2ZXIgY29tbWl0cyB5b3UgbmVlZCB0bywgcHVzaCB0aGVtIHRvIHlvdXIgZm9yaywgYW5kIHRoZW4gaGVhZCBvdmVyCit0byBodHRwczovL2dpdGh1Yi5jb20vZ2l0Z2l0Z2FkZ2V0L2dpdC9wdWxscyBhbmQgb3BlbiBhIFB1bGwgUmVxdWVzdCB0YXJnZXRpbmcKK2dpdC1ndWkvbWFzdGVyLgorCitHaXRHaXRHYWRnZXQgd2lsbCB3ZWxjb21lIHlvdSB3aXRoIGEgKGhvcGVmdWxseSkgaGVscGZ1bCBtZXNzYWdlLgorCisjIyBTaWduaW5nIG9mZgorCitZb3UgbmVlZCB0byBzaWduIG9mZiB5b3VyIGNvbW1pdHMgYmVmb3JlIHNlbmRpbmcgdGhlbSB0byB0aGUgbGlzdC4gWW91IGNhbiBkbwordGhhdCBieSBwYXNzaW5nIHRoZSBgLXNgIG9wdGlvbiB0byBgZ2l0LWNvbW1pdGAuIFlvdSBjYW4gYWxzbyB1c2UgdGhlICJTaWduCitPZmYiIG9wdGlvbiBpbiBHaXQgR1VJLgorCitBIHNpZ24tb2ZmIGlzIGEgc2ltcGxlICdTaWduZWQtb2ZmLWJ5OiBBIFUgVGhvciBcPGF1dGhvckBleGFtcGxlLmNvbVw+JyBsaW5lIGF0Cit0aGUgZW5kIG9mIHRoZSBjb21taXQgbWVzc2FnZSwgYWZ0ZXIgeW91ciBleHBsYW5hdGlvbiBvZiB0aGUgY29tbWl0LgorCitBIHNpZ24tb2ZmIG1lYW5zIHRoYXQgeW91IGFyZSBsZWdhbGx5IGFsbG93ZWQgdG8gc2VuZCB0aGUgY29kZSwgYW5kIGl0IHNlcnZlcworYXMgYSBjZXJ0aWZpY2F0ZSBvZiBvcmlnaW4uIE1vcmUgaW5mb3JtYXRpb24gY2FuIGJlIGZvdW5kIGF0CitbZGV2ZWxvcGVyY2VydGlmaWNhdGUub3JnXShodHRwczovL2RldmVsb3BlcmNlcnRpZmljYXRlLm9yZy8pLgorCisjIyBSZXNwb25kaW5nIHRvIHJldmlldyBjb21tZW50cworCitJdCBpcyBxdWl0ZSBsaWtlbHkgeW91ciBwYXRjaGVzIHdpbGwgZ2V0IHJldmlldyBjb21tZW50cy4gVGhvc2UgY29tbWVudHMgYXJlCitzZW50IG9uIHRoZSBHaXQgbWFpbGluZyBsaXN0IGFzIHJlcGxpZXMgdG8geW91ciBwYXRjaCwgYW5kIHlvdSB3aWxsIHVzdWFsbHkgYmUKK0NjJ2VkIGluIHRob3NlIHJlcGxpZXMuCisKK1lvdSBhcmUgZXhwZWN0ZWQgdG8gcmVzcG9uZCBieSBlaXRoZXIgZXhwbGFpbmluZyB5b3VyIGNvZGUgZnVydGhlciB0byBjb252aW5jZQordGhlIHJldmlld2VyIHdoYXQgeW91IGFyZSBkb2luZyBpcyBjb3JyZWN0LCBvciBhY2tub3dsZWRnZSB0aGUgY29tbWVudHMgYW5kCityZS1zZW5kIHRoZSBwYXRjaGVzIHdpdGggdGhvc2UgY29tbWVudHMgYWRkcmVzc2VkLgorCitTb21lIHRpcHMgZm9yIHRob3NlIG5vdCBmYW1pbGlhciB3aXRoIGNvbW11bmljYXRpb24gb24gYSBtYWlsaW5nIGxpc3Q6CisKKy0gVXNlIG9ubHkgcGxhaW4gdGV4dCBlbWFpbHMuIE5vIEhUTUwgYXQgYWxsLgorLSBXcmFwIGxpbmVzIGF0IGFyb3VuZCA3NSBjaGFyYWN0ZXJzLgorLSBEbyBub3Qgc2VuZCBhdHRhY2htZW50cy4gSWYgeW91IGRvIG5lZWQgdG8gc2VuZCBzb21lIGZpbGVzLCBjb25zaWRlciB1c2luZyBhCisgIGhvc3Rpbmcgc2VydmljZSwgYW5kIHBhc3RlIHRoZSBsaW5rIGluIHlvdXIgZW1haWwuCistIERvIG5vdCBbdG9wIHBvc3RdKGh0dHA6Ly93d3cuaWRhbGxlbi5jb20vdG9wcG9zdGluZy5odG1sKS4KKy0gQWx3YXlzICJyZXBseSBhbGwiLiBLZWVwIGFsbCBjb3JyZXNwb25kZW50cyBhbmQgdGhlIGxpc3QgaW4gQ2MuIElmIHlvdSByZXBseQorICBkaXJlY3RseSB0byBhIHJldmlld2VyLCBhbmQgbm90IENjIHRoZSBsaXN0LCBvdGhlciBwZW9wbGUgd291bGQgbm90IGJlIGFibGUKKyAgdG8gY2hpbWUgaW4uCmRpZmYgLS1naXQgYS9naXQtZ3VpL2dpdC1ndWkuc2ggYi9naXQtZ3VpL2dpdC1ndWkuc2gKaW5kZXggNmRlNzRjZS4uMGQyMWY1NiAxMDA3NTUKLS0tIGEvZ2l0LWd1aS9naXQtZ3VpLnNoCisrKyBiL2dpdC1ndWkvZ2l0LWd1aS5zaApAQCAtMTM0MCw2ICsxMzQwLDcgQEAKIHNldCBQQVJFTlQge30KIHNldCBNRVJHRV9IRUFEIFtsaXN0XQogc2V0IGNvbW1pdF90eXBlIHt9CitzZXQgY29tbWl0X3R5cGVfaXNfYW1lbmQgMAogc2V0IGVtcHR5X3RyZWUge30KIHNldCBjdXJyZW50X2JyYW5jaCB7fQogc2V0IGlzX2RldGFjaGVkIDAKQEAgLTEzNDcsOCArMTM0OCw5IEBACiBzZXQgaXNfM3dheV9kaWZmIDAKIHNldCBpc19zdWJtb2R1bGVfZGlmZiAwCiBzZXQgaXNfY29uZmxpY3RfZGlmZiAwCi1zZXQgc2VsZWN0ZWRfY29tbWl0X3R5cGUgbmV3CiBzZXQgZGlmZl9lbXB0eV9jb3VudCAwCitzZXQgbGFzdF9yZXZlcnQge30KK3NldCBsYXN0X3JldmVydF9lbmMge30KIAogc2V0IG51bGxpZCAiMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMCIKIHNldCBudWxsaWQyICIwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAxIgpAQCAtMTQzNCw3ICsxNDM2LDcgQEAKIH0KIAogcHJvYyBmb3JjZV9hbWVuZCB7fSB7Ci0JZ2xvYmFsIHNlbGVjdGVkX2NvbW1pdF90eXBlCisJZ2xvYmFsIGNvbW1pdF90eXBlX2lzX2FtZW5kCiAJZ2xvYmFsIEhFQUQgUEFSRU5UIE1FUkdFX0hFQUQgY29tbWl0X3R5cGUKIAogCXJlcG9zaXRvcnlfc3RhdGUgbmV3VHlwZSBuZXdIRUFEIG5ld01FUkdFX0hFQUQKQEAgLTE0NDMsNyArMTQ0NSw3IEBACiAJc2V0IE1FUkdFX0hFQUQgJG5ld01FUkdFX0hFQUQKIAlzZXQgY29tbWl0X3R5cGUgJG5ld1R5cGUKIAotCXNldCBzZWxlY3RlZF9jb21taXRfdHlwZSBhbWVuZAorCXNldCBjb21taXRfdHlwZV9pc19hbWVuZCAxCiAJZG9fc2VsZWN0X2NvbW1pdF90eXBlCiB9CiAKQEAgLTI0OTQsNyArMjQ5Niw3IEBACiAKIHByb2MgdG9nZ2xlX29yX2RpZmYge21vZGUgdyBhcmdzfSB7CiAJZ2xvYmFsIGZpbGVfc3RhdGVzIGZpbGVfbGlzdHMgY3VycmVudF9kaWZmX3BhdGggdWlfaW5kZXggdWlfd29ya2RpcgotCWdsb2JhbCBsYXN0X2NsaWNrZWQgc2VsZWN0ZWRfcGF0aHMKKwlnbG9iYWwgbGFzdF9jbGlja2VkIHNlbGVjdGVkX3BhdGhzIGZpbGVfbGlzdHNfbGFzdF9jbGlja2VkCiAKIAlpZiB7JG1vZGUgZXEgImNsaWNrIn0gewogCQlmb3JlYWNoIHt4IHl9ICRhcmdzIGJyZWFrCkBAIC0yNTUxLDYgKzI1NTMsOCBAQAogCSR1aV9pbmRleCB0YWcgcmVtb3ZlIGluX3NlbCAwLjAgZW5kCiAJJHVpX3dvcmtkaXIgdGFnIHJlbW92ZSBpbl9zZWwgMC4wIGVuZAogCisJc2V0IGZpbGVfbGlzdHNfbGFzdF9jbGlja2VkKCR3KSAkcGF0aAorCiAJIyBEZXRlcm1pbmUgdGhlIHN0YXRlIG9mIHRoZSBmaWxlCiAJaWYge1tpbmZvIGV4aXN0cyBmaWxlX3N0YXRlcygkcGF0aCldfSB7CiAJCXNldCBzdGF0ZSBbbGluZGV4ICRmaWxlX3N0YXRlcygkcGF0aCkgMF0KQEAgLTI2NjQsNiArMjY2OCwzMiBAQAogCX0KIH0KIAorcHJvYyBmb2N1c193aWRnZXQge3dpZGdldH0geworCWdsb2JhbCBmaWxlX2xpc3RzIGxhc3RfY2xpY2tlZCBzZWxlY3RlZF9wYXRocworCWdsb2JhbCBmaWxlX2xpc3RzX2xhc3RfY2xpY2tlZAorCisJaWYge1tsbGVuZ3RoICRmaWxlX2xpc3RzKCR3aWRnZXQpXSA+IDB9IHsKKwkJc2V0IHBhdGggJGZpbGVfbGlzdHNfbGFzdF9jbGlja2VkKCR3aWRnZXQpCisJCXNldCBpbmRleCBbbHNlYXJjaCAtc29ydGVkIC1leGFjdCAkZmlsZV9saXN0cygkd2lkZ2V0KSAkcGF0aF0KKwkJaWYgeyRpbmRleCA8IDB9IHsKKwkJCXNldCBpbmRleCAwCisJCQlzZXQgcGF0aCBbbGluZGV4ICRmaWxlX2xpc3RzKCR3aWRnZXQpICRpbmRleF0KKwkJfQorCisJCWZvY3VzICR3aWRnZXQKKwkJc2V0IGxhc3RfY2xpY2tlZCBbbGlzdCAkd2lkZ2V0IFtleHByICRpbmRleCArIDFdXQorCQlhcnJheSB1bnNldCBzZWxlY3RlZF9wYXRocworCQlzZXQgc2VsZWN0ZWRfcGF0aHMoJHBhdGgpIDEKKwkJc2hvd19kaWZmICRwYXRoICR3aWRnZXQKKwl9Cit9CisKK3Byb2MgdG9nZ2xlX2NvbW1pdF90eXBlIHt9IHsKKwlnbG9iYWwgY29tbWl0X3R5cGVfaXNfYW1lbmQKKwlzZXQgY29tbWl0X3R5cGVfaXNfYW1lbmQgW2V4cHIgISRjb21taXRfdHlwZV9pc19hbWVuZF0KKwlkb19zZWxlY3RfY29tbWl0X3R5cGUKK30KKwogIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIwogIyMKICMjIHVpIGNvbnN0cnVjdGlvbgpAQCAtMjcwNiwxMCArMjczNiwxOCBAQAogfQogCiBpZiB7W2lzX1dpbmRvd3NdfSB7CisJIyBVc2UgL2dpdC1iYXNoLmV4ZSBpZiBhdmFpbGFibGUKKwlzZXQgbm9ybWFsaXplZCBbZmlsZSBub3JtYWxpemUgJDo6YXJndjBdCisJcmVnc3ViICIvbWluZ3cuLi9saWJleGVjL2dpdC1jb3JlL2dpdC1ndWkkIiBcCisJCSRub3JtYWxpemVkICIvZ2l0LWJhc2guZXhlIiBjbWRMaW5lCisJaWYgeyRjbWRMaW5lICE9ICRub3JtYWxpemVkICYmIFtmaWxlIGV4aXN0cyAkY21kTGluZV19IHsKKwkJc2V0IGNtZExpbmUgW2xpc3QgIkdpdCBCYXNoIiAkY21kTGluZSAmXQorCX0gZWxzZSB7CisJCXNldCBjbWRMaW5lIFtsaXN0ICJHaXQgQmFzaCIgYmFzaCAtLWxvZ2luIC1sICZdCisJfQogCS5tYmFyLnJlcG9zaXRvcnkgYWRkIGNvbW1hbmQgXAogCQktbGFiZWwgW21jICJHaXQgQmFzaCJdIFwKLQkJLWNvbW1hbmQge2V2YWwgZXhlYyBbYXV0b19leGVjb2sgc3RhcnRdIFwKLQkJCQkJICBbbGlzdCAiR2l0IEJhc2giIGJhc2ggLS1sb2dpbiAtbCAmXX0KKwkJLWNvbW1hbmQge2V2YWwgZXhlYyBbYXV0b19leGVjb2sgc3RhcnRdICRjbWRMaW5lfQogfQogCiBpZiB7W2lzX1dpbmRvd3NdIHx8ICFbaXNfYmFyZV19IHsKQEAgLTI4NTIsMTkgKzI4OTAsMTEgQEAKIAltZW51IC5tYmFyLmNvbW1pdAogCiAJaWYgeyFbaXNfZW5hYmxlZCBub2NvbW1pdF19IHsKLQkJLm1iYXIuY29tbWl0IGFkZCByYWRpb2J1dHRvbiBcCi0JCQktbGFiZWwgW21jICJOZXcgQ29tbWl0Il0gXAotCQkJLWNvbW1hbmQgZG9fc2VsZWN0X2NvbW1pdF90eXBlIFwKLQkJCS12YXJpYWJsZSBzZWxlY3RlZF9jb21taXRfdHlwZSBcCi0JCQktdmFsdWUgbmV3Ci0JCWxhcHBlbmQgZGlzYWJsZV9vbl9sb2NrIFwKLQkJCVtsaXN0IC5tYmFyLmNvbW1pdCBlbnRyeWNvbmYgWy5tYmFyLmNvbW1pdCBpbmRleCBsYXN0XSAtc3RhdGVdCi0KLQkJLm1iYXIuY29tbWl0IGFkZCByYWRpb2J1dHRvbiBcCisJCS5tYmFyLmNvbW1pdCBhZGQgY2hlY2tidXR0b24gXAogCQkJLWxhYmVsIFttYyAiQW1lbmQgTGFzdCBDb21taXQiXSBcCi0JCQktY29tbWFuZCBkb19zZWxlY3RfY29tbWl0X3R5cGUgXAotCQkJLXZhcmlhYmxlIHNlbGVjdGVkX2NvbW1pdF90eXBlIFwKLQkJCS12YWx1ZSBhbWVuZAorCQkJLWFjY2VsZXJhdG9yICRNMVQtRSBcCisJCQktdmFyaWFibGUgY29tbWl0X3R5cGVfaXNfYW1lbmQgXAorCQkJLWNvbW1hbmQgZG9fc2VsZWN0X2NvbW1pdF90eXBlCiAJCWxhcHBlbmQgZGlzYWJsZV9vbl9sb2NrIFwKIAkJCVtsaXN0IC5tYmFyLmNvbW1pdCBlbnRyeWNvbmYgWy5tYmFyLmNvbW1pdCBpbmRleCBsYXN0XSAtc3RhdGVdCiAKQEAgLTMwMzAsOCArMzA2MCwyMyBAQAogd20gcHJvdG9jb2wgLiBXTV9ERUxFVEVfV0lORE9XIGRvX3F1aXQKIGJpbmQgYWxsIDwkTTFCLUtleS1xPiBkb19xdWl0CiBiaW5kIGFsbCA8JE0xQi1LZXktUT4gZG9fcXVpdAotYmluZCBhbGwgPCRNMUItS2V5LXc+IHtkZXN0cm95IFt3aW5mbyB0b3BsZXZlbCAlV119Ci1iaW5kIGFsbCA8JE0xQi1LZXktVz4ge2Rlc3Ryb3kgW3dpbmZvIHRvcGxldmVsICVXXX0KKworc2V0IG0xYl93X3NjcmlwdCB7CisJc2V0IHRvcGx2bF93aW4gW3dpbmZvIHRvcGxldmVsICVXXQorCisJIyBJZiB3ZSBhcmUgZGVzdHJveWluZyB0aGUgbWFpbiB3aW5kb3csIHdlIHNob3VsZCBjYWxsIGRvX3F1aXQgdG8gdGFrZQorCSMgY2FyZSBvZiBjbGVhbnVwIGJlZm9yZSBleGl0aW5nIHRoZSBwcm9ncmFtLgorCWlmIHskdG9wbHZsX3dpbiBlcSAiLiJ9IHsKKwkJZG9fcXVpdAorCX0gZWxzZSB7CisJCWRlc3Ryb3kgJHRvcGx2bF93aW4KKwl9Cit9CisKK2JpbmQgYWxsIDwkTTFCLUtleS13PiAkbTFiX3dfc2NyaXB0CitiaW5kIGFsbCA8JE0xQi1LZXktVz4gJG0xYl93X3NjcmlwdAorCit1bnNldCBtMWJfd19zY3JpcHQKIAogc2V0IHN1YmNvbW1hbmRfYXJncyB7fQogcHJvYyB1c2FnZSB7fSB7CkBAIC0zMzM3LDE4ICszMzgyLDEwIEBACiBzZXQgdWlfY29tbCAudnBhbmUubG93ZXIuY29tbWFyZWEuYnVmZmVyLmhlYWRlci5sCiAKIGlmIHshW2lzX2VuYWJsZWQgbm9jb21taXRdfSB7Ci0JJHtOU306OnJhZGlvYnV0dG9uIC52cGFuZS5sb3dlci5jb21tYXJlYS5idWZmZXIuaGVhZGVyLm5ldyBcCi0JCS10ZXh0IFttYyAiTmV3IENvbW1pdCJdIFwKLQkJLWNvbW1hbmQgZG9fc2VsZWN0X2NvbW1pdF90eXBlIFwKLQkJLXZhcmlhYmxlIHNlbGVjdGVkX2NvbW1pdF90eXBlIFwKLQkJLXZhbHVlIG5ldwotCWxhcHBlbmQgZGlzYWJsZV9vbl9sb2NrIFwKLQkJW2xpc3QgLnZwYW5lLmxvd2VyLmNvbW1hcmVhLmJ1ZmZlci5oZWFkZXIubmV3IGNvbmYgLXN0YXRlXQotCSR7TlN9OjpyYWRpb2J1dHRvbiAudnBhbmUubG93ZXIuY29tbWFyZWEuYnVmZmVyLmhlYWRlci5hbWVuZCBcCisJJHtOU306OmNoZWNrYnV0dG9uIC52cGFuZS5sb3dlci5jb21tYXJlYS5idWZmZXIuaGVhZGVyLmFtZW5kIFwKIAkJLXRleHQgW21jICJBbWVuZCBMYXN0IENvbW1pdCJdIFwKLQkJLWNvbW1hbmQgZG9fc2VsZWN0X2NvbW1pdF90eXBlIFwKLQkJLXZhcmlhYmxlIHNlbGVjdGVkX2NvbW1pdF90eXBlIFwKLQkJLXZhbHVlIGFtZW5kCisJCS12YXJpYWJsZSBjb21taXRfdHlwZV9pc19hbWVuZCBcCisJCS1jb21tYW5kIGRvX3NlbGVjdF9jb21taXRfdHlwZQogCWxhcHBlbmQgZGlzYWJsZV9vbl9sb2NrIFwKIAkJW2xpc3QgLnZwYW5lLmxvd2VyLmNvbW1hcmVhLmJ1ZmZlci5oZWFkZXIuYW1lbmQgY29uZiAtc3RhdGVdCiB9CkBAIC0zMzczLDcgKzM0MTAsNiBAQAogCiBpZiB7IVtpc19lbmFibGVkIG5vY29tbWl0XX0gewogCXBhY2sgLnZwYW5lLmxvd2VyLmNvbW1hcmVhLmJ1ZmZlci5oZWFkZXIuYW1lbmQgLXNpZGUgcmlnaHQKLQlwYWNrIC52cGFuZS5sb3dlci5jb21tYXJlYS5idWZmZXIuaGVhZGVyLm5ldyAtc2lkZSByaWdodAogfQogCiB0ZXh0ZnJhbWUgLnZwYW5lLmxvd2VyLmNvbW1hcmVhLmJ1ZmZlci5mcmFtZQpAQCAtMzM4NywxMCArMzQyMywxNiBAQAogCS1yZWxpZWYgc3Vua2VuIFwKIAktd2lkdGggJHJlcG9fY29uZmlnKGd1aS5jb21taXRtc2d3aWR0aCkgLWhlaWdodCA5IC13cmFwIG5vbmUgXAogCS1mb250IGZvbnRfZGlmZiBcCisJLXhzY3JvbGxjb21tYW5kIHsudnBhbmUubG93ZXIuY29tbWFyZWEuYnVmZmVyLmZyYW1lLnNieCBzZXR9IFwKIAkteXNjcm9sbGNvbW1hbmQgey52cGFuZS5sb3dlci5jb21tYXJlYS5idWZmZXIuZnJhbWUuc2J5IHNldH0KKyR7TlN9OjpzY3JvbGxiYXIgLnZwYW5lLmxvd2VyLmNvbW1hcmVhLmJ1ZmZlci5mcmFtZS5zYnggXAorCS1vcmllbnQgaG9yaXpvbnRhbCBcCisJLWNvbW1hbmQgW2xpc3QgJHVpX2NvbW0geHZpZXddCiAke05TfTo6c2Nyb2xsYmFyIC52cGFuZS5sb3dlci5jb21tYXJlYS5idWZmZXIuZnJhbWUuc2J5IFwKKwktb3JpZW50IHZlcnRpY2FsIFwKIAktY29tbWFuZCBbbGlzdCAkdWlfY29tbSB5dmlld10KIAorcGFjayAudnBhbmUubG93ZXIuY29tbWFyZWEuYnVmZmVyLmZyYW1lLnNieCAtc2lkZSBib3R0b20gLWZpbGwgeAogcGFjayAudnBhbmUubG93ZXIuY29tbWFyZWEuYnVmZmVyLmZyYW1lLnNieSAtc2lkZSByaWdodCAtZmlsbCB5CiBwYWNrICR1aV9jb21tIC1zaWRlIGxlZnQgLWZpbGwgeQogcGFjayAudnBhbmUubG93ZXIuY29tbWFyZWEuYnVmZmVyLmhlYWRlciAtc2lkZSB0b3AgLWZpbGwgeApAQCAtMzU0Nyw2ICszNTg5LDkgQEAKICR1aV9kaWZmIHRhZyBjb25mIGQ8IFwKIAktZm9yZWdyb3VuZCBvcmFuZ2UgXAogCS1mb250IGZvbnRfZGlmZmJvbGQKKyR1aV9kaWZmIHRhZyBjb25mIGR8IFwKKwktZm9yZWdyb3VuZCBvcmFuZ2UgXAorCS1mb250IGZvbnRfZGlmZmJvbGQKICR1aV9kaWZmIHRhZyBjb25mIGQ9IFwKIAktZm9yZWdyb3VuZCBvcmFuZ2UgXAogCS1mb250IGZvbnRfZGlmZmJvbGQKQEAgLTM2MDYsMTYgKzM2NTEsMzIgQEAKIG1lbnUgJGN0eG0gLXRlYXJvZmYgMAogJGN0eG0gYWRkIGNvbW1hbmQgXAogCS1sYWJlbCBbbWMgIkFwcGx5L1JldmVyc2UgSHVuayJdIFwKLQktY29tbWFuZCB7YXBwbHlfaHVuayAkY3Vyc29yWCAkY3Vyc29yWX0KKwktY29tbWFuZCB7YXBwbHlfb3JfcmV2ZXJ0X2h1bmsgJGN1cnNvclggJGN1cnNvclkgMH0KIHNldCB1aV9kaWZmX2FwcGx5aHVuayBbJGN0eG0gaW5kZXggbGFzdF0KIGxhcHBlbmQgZGlmZl9hY3Rpb25zIFtsaXN0ICRjdHhtIGVudHJ5Y29uZiAkdWlfZGlmZl9hcHBseWh1bmsgLXN0YXRlXQogJGN0eG0gYWRkIGNvbW1hbmQgXAogCS1sYWJlbCBbbWMgIkFwcGx5L1JldmVyc2UgTGluZSJdIFwKLQktY29tbWFuZCB7YXBwbHlfcmFuZ2Vfb3JfbGluZSAkY3Vyc29yWCAkY3Vyc29yWTsgZG9fcmVzY2FufQorCS1jb21tYW5kIHthcHBseV9vcl9yZXZlcnRfcmFuZ2Vfb3JfbGluZSAkY3Vyc29yWCAkY3Vyc29yWSAwOyBkb19yZXNjYW59CiBzZXQgdWlfZGlmZl9hcHBseWxpbmUgWyRjdHhtIGluZGV4IGxhc3RdCiBsYXBwZW5kIGRpZmZfYWN0aW9ucyBbbGlzdCAkY3R4bSBlbnRyeWNvbmYgJHVpX2RpZmZfYXBwbHlsaW5lIC1zdGF0ZV0KICRjdHhtIGFkZCBzZXBhcmF0b3IKICRjdHhtIGFkZCBjb21tYW5kIFwKKwktbGFiZWwgW21jICJSZXZlcnQgSHVuayJdIFwKKwktY29tbWFuZCB7YXBwbHlfb3JfcmV2ZXJ0X2h1bmsgJGN1cnNvclggJGN1cnNvclkgMX0KK3NldCB1aV9kaWZmX3JldmVydGh1bmsgWyRjdHhtIGluZGV4IGxhc3RdCitsYXBwZW5kIGRpZmZfYWN0aW9ucyBbbGlzdCAkY3R4bSBlbnRyeWNvbmYgJHVpX2RpZmZfcmV2ZXJ0aHVuayAtc3RhdGVdCiskY3R4bSBhZGQgY29tbWFuZCBcCisJLWxhYmVsIFttYyAiUmV2ZXJ0IExpbmUiXSBcCisJLWNvbW1hbmQge2FwcGx5X29yX3JldmVydF9yYW5nZV9vcl9saW5lICRjdXJzb3JYICRjdXJzb3JZIDE7IGRvX3Jlc2Nhbn0KK3NldCB1aV9kaWZmX3JldmVydGxpbmUgWyRjdHhtIGluZGV4IGxhc3RdCitsYXBwZW5kIGRpZmZfYWN0aW9ucyBbbGlzdCAkY3R4bSBlbnRyeWNvbmYgJHVpX2RpZmZfcmV2ZXJ0bGluZSAtc3RhdGVdCiskY3R4bSBhZGQgY29tbWFuZCBcCisJLWxhYmVsIFttYyAiVW5kbyBMYXN0IFJldmVydCJdIFwKKwktY29tbWFuZCB7dW5kb19sYXN0X3JldmVydDsgZG9fcmVzY2FufQorc2V0IHVpX2RpZmZfdW5kb3JldmVydCBbJGN0eG0gaW5kZXggbGFzdF0KK2xhcHBlbmQgZGlmZl9hY3Rpb25zIFtsaXN0ICRjdHhtIGVudHJ5Y29uZiAkdWlfZGlmZl91bmRvcmV2ZXJ0IC1zdGF0ZV0KKyRjdHhtIGFkZCBzZXBhcmF0b3IKKyRjdHhtIGFkZCBjb21tYW5kIFwKIAktbGFiZWwgW21jICJTaG93IExlc3MgQ29udGV4dCJdIFwKIAktY29tbWFuZCBzaG93X2xlc3NfY29udGV4dAogbGFwcGVuZCBkaWZmX2FjdGlvbnMgW2xpc3QgJGN0eG0gZW50cnljb25mIFskY3R4bSBpbmRleCBsYXN0XSAtc3RhdGVdCkBAIC0zNjkzLDcgKzM3NTQsNyBAQAogfQogCiBwcm9jIHBvcHVwX2RpZmZfbWVudSB7Y3R4bSBjdHhtbWcgY3R4bXNtIHggeSBYIFl9IHsKLQlnbG9iYWwgY3VycmVudF9kaWZmX3BhdGggZmlsZV9zdGF0ZXMKKwlnbG9iYWwgY3VycmVudF9kaWZmX3BhdGggZmlsZV9zdGF0ZXMgbGFzdF9yZXZlcnQKIAlzZXQgOjpjdXJzb3JYICR4CiAJc2V0IDo6Y3Vyc29yWSAkeQogCWlmIHtbaW5mbyBleGlzdHMgZmlsZV9zdGF0ZXMoJGN1cnJlbnRfZGlmZl9wYXRoKV19IHsKQEAgLTM3MDcsMTkgKzM3NjgsMjggQEAKIAkJdGtfcG9wdXAgJGN0eG1zbSAkWCAkWQogCX0gZWxzZSB7CiAJCXNldCBoYXNfcmFuZ2UgW2V4cHIge1skOjp1aV9kaWZmIHRhZyBuZXh0cmFuZ2Ugc2VsIDAuMF0gIT0ge319XQorCQlzZXQgdSBbbWMgIlVuZG8gTGFzdCBSZXZlcnQiXQogCQlpZiB7JDo6dWlfaW5kZXggZXEgJDo6Y3VycmVudF9kaWZmX3NpZGV9IHsKIAkJCXNldCBsIFttYyAiVW5zdGFnZSBIdW5rIEZyb20gQ29tbWl0Il0KKwkJCXNldCBoIFttYyAiUmV2ZXJ0IEh1bmsiXQorCiAJCQlpZiB7JGhhc19yYW5nZX0gewogCQkJCXNldCB0IFttYyAiVW5zdGFnZSBMaW5lcyBGcm9tIENvbW1pdCJdCisJCQkJc2V0IHIgW21jICJSZXZlcnQgTGluZXMiXQogCQkJfSBlbHNlIHsKIAkJCQlzZXQgdCBbbWMgIlVuc3RhZ2UgTGluZSBGcm9tIENvbW1pdCJdCisJCQkJc2V0IHIgW21jICJSZXZlcnQgTGluZSJdCiAJCQl9CiAJCX0gZWxzZSB7CiAJCQlzZXQgbCBbbWMgIlN0YWdlIEh1bmsgRm9yIENvbW1pdCJdCisJCQlzZXQgaCBbbWMgIlJldmVydCBIdW5rIl0KKwogCQkJaWYgeyRoYXNfcmFuZ2V9IHsKIAkJCQlzZXQgdCBbbWMgIlN0YWdlIExpbmVzIEZvciBDb21taXQiXQorCQkJCXNldCByIFttYyAiUmV2ZXJ0IExpbmVzIl0KIAkJCX0gZWxzZSB7CiAJCQkJc2V0IHQgW21jICJTdGFnZSBMaW5lIEZvciBDb21taXQiXQorCQkJCXNldCByIFttYyAiUmV2ZXJ0IExpbmUiXQogCQkJfQogCQl9CiAJCWlmIHskOjppc18zd2F5X2RpZmYKQEAgLTM3MzAsMTEgKzM4MDAsMzUgQEAKIAkJCXx8IFtzdHJpbmcgbWF0Y2gge1Q/fSAkc3RhdGVdCiAJCQl8fCBbaGFzX3RleHRjb252ICRjdXJyZW50X2RpZmZfcGF0aF19IHsKIAkJCXNldCBzIGRpc2FibGVkCisJCQlzZXQgcmV2ZXJ0X3N0YXRlIGRpc2FibGVkCiAJCX0gZWxzZSB7CiAJCQlzZXQgcyBub3JtYWwKKworCQkJIyBPbmx5IGFsbG93IHJldmVydGluZyBjaGFuZ2VzIGluIHRoZSB3b3JraW5nIHRyZWUuIElmCisJCQkjIHRoZSB1c2VyIHdhbnRzIHRvIHJldmVydCBjaGFuZ2VzIGluIHRoZSBpbmRleCwgdGhleQorCQkJIyBuZWVkIHRvIHVuc3RhZ2UgdGhvc2UgZmlyc3QuCisJCQlpZiB7JDo6dWlfd29ya2RpciBlcSAkOjpjdXJyZW50X2RpZmZfc2lkZX0geworCQkJCXNldCByZXZlcnRfc3RhdGUgbm9ybWFsCisJCQl9IGVsc2UgeworCQkJCXNldCByZXZlcnRfc3RhdGUgZGlzYWJsZWQKKwkJCX0KIAkJfQorCisJCWlmIHskbGFzdF9yZXZlcnQgZXEge319IHsKKwkJCXNldCB1bmRvX3N0YXRlIGRpc2FibGVkCisJCX0gZWxzZSB7CisJCQlzZXQgdW5kb19zdGF0ZSBub3JtYWwKKwkJfQorCiAJCSRjdHhtIGVudHJ5Y29uZiAkOjp1aV9kaWZmX2FwcGx5aHVuayAtc3RhdGUgJHMgLWxhYmVsICRsCiAJCSRjdHhtIGVudHJ5Y29uZiAkOjp1aV9kaWZmX2FwcGx5bGluZSAtc3RhdGUgJHMgLWxhYmVsICR0CisJCSRjdHhtIGVudHJ5Y29uZiAkOjp1aV9kaWZmX3JldmVydGxpbmUgLXN0YXRlICRyZXZlcnRfc3RhdGUgXAorCQkJLWxhYmVsICRyCisJCSRjdHhtIGVudHJ5Y29uZiAkOjp1aV9kaWZmX3JldmVydGh1bmsgLXN0YXRlICRyZXZlcnRfc3RhdGUgXAorCQkJLWxhYmVsICRoCisJCSRjdHhtIGVudHJ5Y29uZiAkOjp1aV9kaWZmX3VuZG9yZXZlcnQgLXN0YXRlICR1bmRvX3N0YXRlIFwKKwkJCS1sYWJlbCAkdQorCiAJCXRrX3BvcHVwICRjdHhtICRYICRZCiAJfQogfQpAQCAtMzg2MSw2ICszOTU1LDggQEAKIGJpbmQgLiAgIDwkTTFCLUtleS1KPiBkb19yZXZlcnRfc2VsZWN0aW9uCiBiaW5kIC4gICA8JE0xQi1LZXktaT4gZG9fYWRkX2FsbAogYmluZCAuICAgPCRNMUItS2V5LUk+IGRvX2FkZF9hbGwKK2JpbmQgLiAgIDwkTTFCLUtleS1lPiB0b2dnbGVfY29tbWl0X3R5cGUKK2JpbmQgLiAgIDwkTTFCLUtleS1FPiB0b2dnbGVfY29tbWl0X3R5cGUKIGJpbmQgLiAgIDwkTTFCLUtleS1taW51cz4ge3Nob3dfbGVzc19jb250ZXh0O2JyZWFrfQogYmluZCAuICAgPCRNMUItS2V5LUtQX1N1YnRyYWN0PiB7c2hvd19sZXNzX2NvbnRleHQ7YnJlYWt9CiBiaW5kIC4gICA8JE0xQi1LZXktZXF1YWw+IHtzaG93X21vcmVfY29udGV4dDticmVha30KQEAgLTM4NzcsNiArMzk3MywxNCBAQAogfQogdW5zZXQgaQogCitiaW5kIC4gICA8QWx0LUtleS0xPiB7Zm9jdXNfd2lkZ2V0ICQ6OnVpX3dvcmtkaXJ9CitiaW5kIC4gICA8QWx0LUtleS0yPiB7Zm9jdXNfd2lkZ2V0ICQ6OnVpX2luZGV4fQorYmluZCAuICAgPEFsdC1LZXktMz4ge2ZvY3VzICQ6OnVpX2RpZmZ9CitiaW5kIC4gICA8QWx0LUtleS00PiB7Zm9jdXMgJDo6dWlfY29tbX0KKworc2V0IGZpbGVfbGlzdHNfbGFzdF9jbGlja2VkKCR1aV9pbmRleCkge30KK3NldCBmaWxlX2xpc3RzX2xhc3RfY2xpY2tlZCgkdWlfd29ya2Rpcikge30KKwogc2V0IGZpbGVfbGlzdHMoJHVpX2luZGV4KSBbbGlzdF0KIHNldCBmaWxlX2xpc3RzKCR1aV93b3JrZGlyKSBbbGlzdF0KIApkaWZmIC0tZ2l0IGEvZ2l0LWd1aS9saWIvY2hlY2tvdXRfb3AudGNsIGIvZ2l0LWd1aS9saWIvY2hlY2tvdXRfb3AudGNsCmluZGV4IDllNzQxMmMuLmE1MjI4MjkgMTAwNjQ0Ci0tLSBhL2dpdC1ndWkvbGliL2NoZWNrb3V0X29wLnRjbAorKysgYi9naXQtZ3VpL2xpYi9jaGVja291dF9vcC50Y2wKQEAgLTM4OSw3ICszODksNyBAQAogfQogCiBtZXRob2QgX2FmdGVyX3JlYWR0cmVlIHt9IHsKLQlnbG9iYWwgc2VsZWN0ZWRfY29tbWl0X3R5cGUgY29tbWl0X3R5cGUgSEVBRCBNRVJHRV9IRUFEIFBBUkVOVAorCWdsb2JhbCBjb21taXRfdHlwZSBIRUFEIE1FUkdFX0hFQUQgUEFSRU5UCiAJZ2xvYmFsIGN1cnJlbnRfYnJhbmNoIGlzX2RldGFjaGVkCiAJZ2xvYmFsIHVpX2NvbW0KIApAQCAtNDkwLDEyICs0OTAsMTIgQEAKIAkjICAgIGFtZW5kIG1vZGUgb3VyIGZpbGUgbGlzdHMgYXJlIGFjY3VyYXRlIGFuZCB3ZSBjYW4gYXZvaWQKIAkjICAgIHRoZSByZXNjYW4uCiAJIwotCWdsb2JhbCBzZWxlY3RlZF9jb21taXRfdHlwZSBjb21taXRfdHlwZSBIRUFEIE1FUkdFX0hFQUQgUEFSRU5UCisJZ2xvYmFsIGNvbW1pdF90eXBlX2lzX2FtZW5kIGNvbW1pdF90eXBlIEhFQUQgTUVSR0VfSEVBRCBQQVJFTlQKIAlnbG9iYWwgdWlfY29tbQogCiAJdW5sb2NrX2luZGV4CiAJc2V0IG5hbWUgW19uYW1lICR0aGlzXQotCXNldCBzZWxlY3RlZF9jb21taXRfdHlwZSBuZXcKKwlzZXQgY29tbWl0X3R5cGVfaXNfYW1lbmQgMAogCWlmIHtbc3RyaW5nIG1hdGNoIGFtZW5kKiAkY29tbWl0X3R5cGVdfSB7CiAJCSR1aV9jb21tIGRlbGV0ZSAwLjAgZW5kCiAJCSR1aV9jb21tIGVkaXQgcmVzZXQKZGlmZiAtLWdpdCBhL2dpdC1ndWkvbGliL2NvbW1pdC50Y2wgYi9naXQtZ3VpL2xpYi9jb21taXQudGNsCmluZGV4IDc1ZWE5NjUuLmI1MTZhYTIgMTAwNjQ0Ci0tLSBhL2dpdC1ndWkvbGliL2NvbW1pdC50Y2wKKysrIGIvZ2l0LWd1aS9saWIvY29tbWl0LnRjbApAQCAtMzMzLDcgKzMzMyw3IEBACiBwcm9jIGNvbW1pdF9jb21taXR0cmVlIHtmZF93dCBjdXJIRUFEIG1zZ19wfSB7CiAJZ2xvYmFsIEhFQUQgUEFSRU5UIE1FUkdFX0hFQUQgY29tbWl0X3R5cGUgY29tbWl0X2F1dGhvcgogCWdsb2JhbCBjdXJyZW50X2JyYW5jaAotCWdsb2JhbCB1aV9jb21tIHNlbGVjdGVkX2NvbW1pdF90eXBlCisJZ2xvYmFsIHVpX2NvbW0gY29tbWl0X3R5cGVfaXNfYW1lbmQKIAlnbG9iYWwgZmlsZV9zdGF0ZXMgc2VsZWN0ZWRfcGF0aHMgcmVzY2FuX2FjdGl2ZQogCWdsb2JhbCByZXBvX2NvbmZpZwogCWdsb2JhbCBlbnYKQEAgLTQ2Nyw4ICs0NjcsOCBAQAogCiAJIyAtLSBVcGRhdGUgaW4gbWVtb3J5IHN0YXR1cwogCSMKLQlzZXQgc2VsZWN0ZWRfY29tbWl0X3R5cGUgbmV3CiAJc2V0IGNvbW1pdF90eXBlIG5vcm1hbAorCXNldCBjb21taXRfdHlwZV9pc19hbWVuZCAwCiAJc2V0IEhFQUQgJGNtdF9pZAogCXNldCBQQVJFTlQgJGNtdF9pZAogCXNldCBNRVJHRV9IRUFEIFtsaXN0XQpkaWZmIC0tZ2l0IGEvZ2l0LWd1aS9saWIvZGlmZi50Y2wgYi9naXQtZ3VpL2xpYi9kaWZmLnRjbAppbmRleCA2OGM0YTZjLi44NzFhZDQ4IDEwMDY0NAotLS0gYS9naXQtZ3VpL2xpYi9kaWZmLnRjbAorKysgYi9naXQtZ3VpL2xpYi9kaWZmLnRjbApAQCAtNTUsNyArNTUsNyBAQAogCiBwcm9jIGZvcmNlX2RpZmZfZW5jb2Rpbmcge2VuY30gewogCWdsb2JhbCBjdXJyZW50X2RpZmZfcGF0aAotCQorCiAJaWYgeyRjdXJyZW50X2RpZmZfcGF0aCBuZSB7fX0gewogCQlmb3JjZV9wYXRoX2VuY29kaW5nICRjdXJyZW50X2RpZmZfcGF0aCAkZW5jCiAJCXJlc2hvd19kaWZmCkBAIC0yNzAsMTkgKzI3MCw2IEBACiAJfQogfQogCi1wcm9jIGdldF9jb25mbGljdF9tYXJrZXJfc2l6ZSB7cGF0aH0gewotCXNldCBzaXplIDcKLQljYXRjaCB7Ci0JCXNldCBmZF9yYyBbZXZhbCBbbGlzdCBnaXRfcmVhZCBjaGVjay1hdHRyICJjb25mbGljdC1tYXJrZXItc2l6ZSIgLS0gJHBhdGhdXQotCQlzZXQgcmV0IFtnZXRzICRmZF9yYyBsaW5lXQotCQljbG9zZSAkZmRfcmMKLQkJaWYgeyRyZXQgPiAwfSB7Ci0JCQlyZWdleHAgey4qOiBjb25mbGljdC1tYXJrZXItc2l6ZTogKFxkKykkfSAkbGluZSBsaW5lIHNpemUKLQkJfQotCX0KLQlyZXR1cm4gJHNpemUKLX0KLQogcHJvYyBzdGFydF9zaG93X2RpZmYge2NvbnRfaW5mbyB7YWRkX29wdHMge319fSB7CiAJZ2xvYmFsIGZpbGVfc3RhdGVzIGZpbGVfbGlzdHMKIAlnbG9iYWwgaXNfM3dheV9kaWZmIGlzX3N1Ym1vZHVsZV9kaWZmIGRpZmZfYWN0aXZlIHJlcG9fY29uZmlnCkBAIC0yOTgsNyArMjg1LDcgQEAKIAlzZXQgaXNfc3VibW9kdWxlX2RpZmYgMAogCXNldCBkaWZmX2FjdGl2ZSAxCiAJc2V0IGN1cnJlbnRfZGlmZl9oZWFkZXIge30KLQlzZXQgY29uZmxpY3Rfc2l6ZSBbZ2V0X2NvbmZsaWN0X21hcmtlcl9zaXplICRwYXRoXQorCXNldCBjb25mbGljdF9zaXplIFtnaXRhdHRyICRwYXRoIGNvbmZsaWN0LW1hcmtlci1zaXplIDddCiAKIAlzZXQgY21kIFtsaXN0XQogCWlmIHskdyBlcSAkdWlfaW5kZXh9IHsKQEAgLTM2MCw2ICszNDcsMTAgQEAKIAl9CiAKIAlzZXQgOjpjdXJyZW50X2RpZmZfaW5oZWFkZXIgMQorCSMgRGV0ZWN0IHByZS1pbWFnZSBsaW5lcyBvZiB0aGUgZGlmZjMgY29uZmxpY3Qtc3R5bGUuIFRoZXkgYXJlIGp1c3QKKwkjICcrKycgbGluZXMgd2hpY2ggaXMgbm90IGJpamVjdGl2ZS4gVGh1cywgd2UgbmVlZCB0byBtYWludGFpbiBhIHN0YXRlCisJIyBhY3Jvc3MgbGluZXMuCisJc2V0IDo6Y29uZmxpY3RfaW5fcHJlX2ltYWdlIDAKIAlmY29uZmlndXJlICRmZCBcCiAJCS1ibG9ja2luZyAwIFwKIAkJLWVuY29kaW5nIFtnZXRfcGF0aF9lbmNvZGluZyAkcGF0aF0gXApAQCAtNDYyLDExICs0NTMsMjMgQEAKIAkJCXstLX0ge3NldCB0YWdzIGRfLS19CiAJCQl7Kyt9IHsKIAkJCQlzZXQgcmVnZXhwIFtzdHJpbmcgbWFwIFtsaXN0ICVjb25mbGljdF9zaXplICRjb25mbGljdF9zaXplXVwKLQkJCQkJCQkJe15cK1wrKFs8Pj1dKXslY29uZmxpY3Rfc2l6ZX0oPzogfCQpfV0KKwkJCQkJCQkJe15cK1wrKFs8Pj18XSl7JWNvbmZsaWN0X3NpemV9KD86IHwkKX1dCiAJCQkJaWYge1tyZWdleHAgJHJlZ2V4cCAkbGluZSBfZyBvcF19IHsKIAkJCQkJc2V0IGlzX2NvbmZsaWN0X2RpZmYgMQogCQkJCQlzZXQgbGluZSBbc3RyaW5nIHJlcGxhY2UgJGxpbmUgMCAxIHsgIH1dCiAJCQkJCXNldCB0YWdzIGQkb3AKKworCQkJCQkjIFRoZSB8fHwgY29uZmxpY3QtbWFya2VyIG1hcmtzIHRoZSBzdGFydCBvZiB0aGUgcHJlLWltYWdlLgorCQkJCQkjIEFsbCB0aG9zZSBsaW5lcyBhcmUgYWxzbyBwcmVmaXhlZCB3aXRoICcrKycuIFRodXMgd2UgbmVlZAorCQkJCQkjIHRvIG1haW50YWluIHRoaXMgc3RhdGUuCisJCQkJCXNldCA6OmNvbmZsaWN0X2luX3ByZV9pbWFnZSBbZXhwciB7JG9wIGVxIHt8fX1dCisJCQkJfSBlbHNlaWYgeyQ6OmNvbmZsaWN0X2luX3ByZV9pbWFnZX0geworCQkJCQkjIFRoaXMgaXMgYSBwcmUtaW1hZ2UgbGluZS4gSXQgaXMgdGhlIG9uZSB3aGljaCBib3RoIHNpZGVzCisJCQkJCSMgYXJlIGJhc2VkIG9uLiBBcyBpdCBoYXMgYWxzbyB0aGUgJysrJyBsaW5lIHN0YXJ0LCBpdCBpcworCQkJCQkjIG5vcm1hbGx5IHNob3duIGFzICdhZGRlZCcuIEludmVydCB0aGlzIHRvICctLScgdG8gbWFrZQorCQkJCQkjIGl0IGEgJ3JlbW92ZWQnIGxpbmUuCisJCQkJCXNldCBsaW5lIFtzdHJpbmcgcmVwbGFjZSAkbGluZSAwIDEgey0tfV0KKwkJCQkJc2V0IHRhZ3MgZF8tLQogCQkJCX0gZWxzZSB7CiAJCQkJCXNldCB0YWdzIGRfKysKIAkJCQl9CkBAIC01NjcsMjQgKzU3MCwzMSBAQAogCX0KIH0KIAotcHJvYyBhcHBseV9odW5rIHt4IHl9IHsKK3Byb2MgYXBwbHlfb3JfcmV2ZXJ0X2h1bmsge3ggeSByZXZlcnR9IHsKIAlnbG9iYWwgY3VycmVudF9kaWZmX3BhdGggY3VycmVudF9kaWZmX2hlYWRlciBjdXJyZW50X2RpZmZfc2lkZQotCWdsb2JhbCB1aV9kaWZmIHVpX2luZGV4IGZpbGVfc3RhdGVzCisJZ2xvYmFsIHVpX2RpZmYgdWlfaW5kZXggZmlsZV9zdGF0ZXMgbGFzdF9yZXZlcnQgbGFzdF9yZXZlcnRfZW5jCiAKIAlpZiB7JGN1cnJlbnRfZGlmZl9wYXRoIGVxIHt9IHx8ICRjdXJyZW50X2RpZmZfaGVhZGVyIGVxIHt9fSByZXR1cm4KIAlpZiB7IVtsb2NrX2luZGV4IGFwcGx5X2h1bmtdfSByZXR1cm4KIAotCXNldCBhcHBseV9jbWQge2FwcGx5IC0tY2FjaGVkIC0td2hpdGVzcGFjZT1ub3dhcm59CisJc2V0IGFwcGx5X2NtZCB7YXBwbHkgLS13aGl0ZXNwYWNlPW5vd2Fybn0KIAlzZXQgbWkgW2xpbmRleCAkZmlsZV9zdGF0ZXMoJGN1cnJlbnRfZGlmZl9wYXRoKSAwXQogCWlmIHskY3VycmVudF9kaWZmX3NpZGUgZXEgJHVpX2luZGV4fSB7CiAJCXNldCBmYWlsZWRfbXNnIFttYyAiRmFpbGVkIHRvIHVuc3RhZ2Ugc2VsZWN0ZWQgaHVuay4iXQotCQlsYXBwZW5kIGFwcGx5X2NtZCAtLXJldmVyc2UKKwkJbGFwcGVuZCBhcHBseV9jbWQgLS1yZXZlcnNlIC0tY2FjaGVkCiAJCWlmIHtbc3RyaW5nIGluZGV4ICRtaSAwXSBuZSB7TX19IHsKIAkJCXVubG9ja19pbmRleAogCQkJcmV0dXJuCiAJCX0KIAl9IGVsc2UgewotCQlzZXQgZmFpbGVkX21zZyBbbWMgIkZhaWxlZCB0byBzdGFnZSBzZWxlY3RlZCBodW5rLiJdCisJCWlmIHskcmV2ZXJ0fSB7CisJCQlzZXQgZmFpbGVkX21zZyBbbWMgIkZhaWxlZCB0byByZXZlcnQgc2VsZWN0ZWQgaHVuay4iXQorCQkJbGFwcGVuZCBhcHBseV9jbWQgLS1yZXZlcnNlCisJCX0gZWxzZSB7CisJCQlzZXQgZmFpbGVkX21zZyBbbWMgIkZhaWxlZCB0byBzdGFnZSBzZWxlY3RlZCBodW5rLiJdCisJCQlsYXBwZW5kIGFwcGx5X2NtZCAtLWNhY2hlZAorCQl9CisKIAkJaWYge1tzdHJpbmcgaW5kZXggJG1pIDFdIG5lIHtNfX0gewogCQkJdW5sb2NrX2luZGV4CiAJCQlyZXR1cm4KQEAgLTYwMywyOSArNjEzLDQwIEBACiAJCXNldCBlX2xubyBlbmQKIAl9CiAKKwlzZXQgd2hvbGVwYXRjaCAiJGN1cnJlbnRfZGlmZl9oZWFkZXJbJHVpX2RpZmYgZ2V0ICRzX2xubyAkZV9sbm9dIgorCiAJaWYge1tjYXRjaCB7CiAJCXNldCBlbmMgW2dldF9wYXRoX2VuY29kaW5nICRjdXJyZW50X2RpZmZfcGF0aF0KIAkJc2V0IHAgW2V2YWwgZ2l0X3dyaXRlICRhcHBseV9jbWRdCiAJCWZjb25maWd1cmUgJHAgLXRyYW5zbGF0aW9uIGJpbmFyeSAtZW5jb2RpbmcgJGVuYwotCQlwdXRzIC1ub25ld2xpbmUgJHAgJGN1cnJlbnRfZGlmZl9oZWFkZXIKLQkJcHV0cyAtbm9uZXdsaW5lICRwIFskdWlfZGlmZiBnZXQgJHNfbG5vICRlX2xub10KKwkJcHV0cyAtbm9uZXdsaW5lICRwICR3aG9sZXBhdGNoCiAJCWNsb3NlICRwfSBlcnJdfSB7CiAJCWVycm9yX3BvcHVwICIkZmFpbGVkX21zZ1xuXG4kZXJyIgogCQl1bmxvY2tfaW5kZXgKIAkJcmV0dXJuCiAJfQogCisJaWYgeyRyZXZlcnR9IHsKKwkJIyBTYXZlIGEgY29weSBvZiB0aGlzIHBhdGNoIGZvciB1bmRvaW5nIHJldmVydHMuCisJCXNldCBsYXN0X3JldmVydCAkd2hvbGVwYXRjaAorCQlzZXQgbGFzdF9yZXZlcnRfZW5jICRlbmMKKwl9CisKIAkkdWlfZGlmZiBjb25mIC1zdGF0ZSBub3JtYWwKIAkkdWlfZGlmZiBkZWxldGUgJHNfbG5vICRlX2xubwogCSR1aV9kaWZmIGNvbmYgLXN0YXRlIGRpc2FibGVkCiAKKwkjIENoZWNrIGlmIHRoZSBodW5rIHdhcyB0aGUgbGFzdCBvbmUgaW4gdGhlIGZpbGUuCiAJaWYge1skdWlfZGlmZiBnZXQgMS4wIGVuZF0gZXEgIlxuIn0gewogCQlzZXQgbyBfCiAJfSBlbHNlIHsKIAkJc2V0IG8gPwogCX0KIAotCWlmIHskY3VycmVudF9kaWZmX3NpZGUgZXEgJHVpX2luZGV4fSB7CisJIyBVcGRhdGUgdGhlIHN0YXR1cyBmbGFncy4KKwlpZiB7JHJldmVydH0geworCQlzZXQgbWkgW3N0cmluZyBpbmRleCAkbWkgMF0kbworCX0gZWxzZWlmIHskY3VycmVudF9kaWZmX3NpZGUgZXEgJHVpX2luZGV4fSB7CiAJCXNldCBtaSAke299TQogCX0gZWxzZWlmIHtbc3RyaW5nIGluZGV4ICRtaSAwXSBlcSB7X319IHsKIAkJc2V0IG1pIE0kbwpAQCAtNjQwLDkgKzY2MSw5IEBACiAJfQogfQogCi1wcm9jIGFwcGx5X3JhbmdlX29yX2xpbmUge3ggeX0geworcHJvYyBhcHBseV9vcl9yZXZlcnRfcmFuZ2Vfb3JfbGluZSB7eCB5IHJldmVydH0gewogCWdsb2JhbCBjdXJyZW50X2RpZmZfcGF0aCBjdXJyZW50X2RpZmZfaGVhZGVyIGN1cnJlbnRfZGlmZl9zaWRlCi0JZ2xvYmFsIHVpX2RpZmYgdWlfaW5kZXggZmlsZV9zdGF0ZXMKKwlnbG9iYWwgdWlfZGlmZiB1aV9pbmRleCBmaWxlX3N0YXRlcyBsYXN0X3JldmVydAogCiAJc2V0IHNlbGVjdGVkIFskdWlfZGlmZiB0YWcgbmV4dHJhbmdlIHNlbCAwLjBdCiAKQEAgLTY2MCwxOSArNjgxLDI3IEBACiAJaWYgeyRjdXJyZW50X2RpZmZfcGF0aCBlcSB7fSB8fCAkY3VycmVudF9kaWZmX2hlYWRlciBlcSB7fX0gcmV0dXJuCiAJaWYgeyFbbG9ja19pbmRleCBhcHBseV9odW5rXX0gcmV0dXJuCiAKLQlzZXQgYXBwbHlfY21kIHthcHBseSAtLWNhY2hlZCAtLXdoaXRlc3BhY2U9bm93YXJufQorCXNldCBhcHBseV9jbWQge2FwcGx5IC0td2hpdGVzcGFjZT1ub3dhcm59CiAJc2V0IG1pIFtsaW5kZXggJGZpbGVfc3RhdGVzKCRjdXJyZW50X2RpZmZfcGF0aCkgMF0KIAlpZiB7JGN1cnJlbnRfZGlmZl9zaWRlIGVxICR1aV9pbmRleH0gewogCQlzZXQgZmFpbGVkX21zZyBbbWMgIkZhaWxlZCB0byB1bnN0YWdlIHNlbGVjdGVkIGxpbmUuIl0KIAkJc2V0IHRvX2NvbnRleHQgeyt9Ci0JCWxhcHBlbmQgYXBwbHlfY21kIC0tcmV2ZXJzZQorCQlsYXBwZW5kIGFwcGx5X2NtZCAtLXJldmVyc2UgLS1jYWNoZWQKIAkJaWYge1tzdHJpbmcgaW5kZXggJG1pIDBdIG5lIHtNfX0gewogCQkJdW5sb2NrX2luZGV4CiAJCQlyZXR1cm4KIAkJfQogCX0gZWxzZSB7Ci0JCXNldCBmYWlsZWRfbXNnIFttYyAiRmFpbGVkIHRvIHN0YWdlIHNlbGVjdGVkIGxpbmUuIl0KLQkJc2V0IHRvX2NvbnRleHQgey19CisJCWlmIHskcmV2ZXJ0fSB7CisJCQlzZXQgZmFpbGVkX21zZyBbbWMgIkZhaWxlZCB0byByZXZlcnQgc2VsZWN0ZWQgbGluZS4iXQorCQkJc2V0IHRvX2NvbnRleHQgeyt9CisJCQlsYXBwZW5kIGFwcGx5X2NtZCAtLXJldmVyc2UKKwkJfSBlbHNlIHsKKwkJCXNldCBmYWlsZWRfbXNnIFttYyAiRmFpbGVkIHRvIHN0YWdlIHNlbGVjdGVkIGxpbmUuIl0KKwkJCXNldCB0b19jb250ZXh0IHstfQorCQkJbGFwcGVuZCBhcHBseV9jbWQgLS1jYWNoZWQKKwkJfQorCiAJCWlmIHtbc3RyaW5nIGluZGV4ICRtaSAxXSBuZSB7TX19IHsKIAkJCXVubG9ja19pbmRleAogCQkJcmV0dXJuCkBAIC04MzAsNyArODU5LDQ3IEBACiAJCXB1dHMgLW5vbmV3bGluZSAkcCAkd2hvbGVwYXRjaAogCQljbG9zZSAkcH0gZXJyXX0gewogCQllcnJvcl9wb3B1cCAiJGZhaWxlZF9tc2dcblxuJGVyciIKKwkJdW5sb2NrX2luZGV4CisJCXJldHVybgogCX0KIAorCWlmIHskcmV2ZXJ0fSB7CisJCSMgU2F2ZSBhIGNvcHkgb2YgdGhpcyBwYXRjaCBmb3IgdW5kb2luZyByZXZlcnRzLgorCQlzZXQgbGFzdF9yZXZlcnQgJGN1cnJlbnRfZGlmZl9oZWFkZXIkd2hvbGVwYXRjaAorCQlzZXQgbGFzdF9yZXZlcnRfZW5jICRlbmMKKwl9CisKKwl1bmxvY2tfaW5kZXgKK30KKworIyBVbmRvIHRoZSBsYXN0IGxpbmUvaHVuayByZXZlcnRlZC4gV2hlbiBodW5rcyBhbmQgbGluZXMgYXJlIHJldmVydGVkLCBhIGNvcHkKKyMgb2YgdGhlIGRpZmYgYXBwbGllZCBpcyBzYXZlZC4gUmUtYXBwbHkgdGhhdCBkaWZmIHRvIHVuZG8gdGhlIHJldmVydC4KKyMKKyMgUmlnaHQgbm93LCB3ZSBvbmx5IHVzZSBhIHNpbmdsZSB2YXJpYWJsZSB0byBob2xkIHRoZSBjb3B5LCBhbmQgbm90IGEKKyMgc3RhY2svZGVxdWUgZm9yIHNpbXBsaWNpdHksIHNvIG11bHRpcGxlIHVuZG9zIGFyZSBub3QgcG9zc2libGUuIE1heWJlIHRoaXMKKyMgY2FuIGJlIGFkZGVkIGlmIHRoZSBuZWVkIGZvciBzb21ldGhpbmcgbGlrZSB0aGlzIGlzIGZlbHQgaW4gdGhlIGZ1dHVyZS4KK3Byb2MgdW5kb19sYXN0X3JldmVydCB7fSB7CisJZ2xvYmFsIGxhc3RfcmV2ZXJ0IGN1cnJlbnRfZGlmZl9wYXRoIGN1cnJlbnRfZGlmZl9oZWFkZXIKKwlnbG9iYWwgbGFzdF9yZXZlcnRfZW5jCisKKwlpZiB7JGxhc3RfcmV2ZXJ0IGVxIHt9fSByZXR1cm4KKwlpZiB7IVtsb2NrX2luZGV4IGFwcGx5X2h1bmtdfSByZXR1cm4KKworCXNldCBhcHBseV9jbWQge2FwcGx5IC0td2hpdGVzcGFjZT1ub3dhcm59CisJc2V0IGZhaWxlZF9tc2cgW21jICJGYWlsZWQgdG8gdW5kbyBsYXN0IHJldmVydC4iXQorCisJaWYge1tjYXRjaCB7CisJCXNldCBlbmMgJGxhc3RfcmV2ZXJ0X2VuYworCQlzZXQgcCBbZXZhbCBnaXRfd3JpdGUgJGFwcGx5X2NtZF0KKwkJZmNvbmZpZ3VyZSAkcCAtdHJhbnNsYXRpb24gYmluYXJ5IC1lbmNvZGluZyAkZW5jCisJCXB1dHMgLW5vbmV3bGluZSAkcCAkbGFzdF9yZXZlcnQKKwkJY2xvc2UgJHB9IGVycl19IHsKKwkJZXJyb3JfcG9wdXAgIiRmYWlsZWRfbXNnXG5cbiRlcnIiCisJCXVubG9ja19pbmRleAorCQlyZXR1cm4KKwl9CisKKwlzZXQgbGFzdF9yZXZlcnQge30KKwogCXVubG9ja19pbmRleAogfQpkaWZmIC0tZ2l0IGEvZ2l0LWd1aS9saWIvaW5kZXgudGNsIGIvZ2l0LWd1aS9saWIvaW5kZXgudGNsCmluZGV4IGI1ODhkYjEuLmUwN2I3YTMgMTAwNjQ0Ci0tLSBhL2dpdC1ndWkvbGliL2luZGV4LnRjbAorKysgYi9naXQtZ3VpL2xpYi9pbmRleC50Y2wKQEAgLTQ2NiwxOSArNDY2LDE5IEBACiB9CiAKIHByb2MgZG9fc2VsZWN0X2NvbW1pdF90eXBlIHt9IHsKLQlnbG9iYWwgY29tbWl0X3R5cGUgc2VsZWN0ZWRfY29tbWl0X3R5cGUKKwlnbG9iYWwgY29tbWl0X3R5cGUgY29tbWl0X3R5cGVfaXNfYW1lbmQKIAotCWlmIHskc2VsZWN0ZWRfY29tbWl0X3R5cGUgZXEge25ld30KKwlpZiB7JGNvbW1pdF90eXBlX2lzX2FtZW5kID09IDAKIAkJJiYgW3N0cmluZyBtYXRjaCBhbWVuZCogJGNvbW1pdF90eXBlXX0gewogCQljcmVhdGVfbmV3X2NvbW1pdAotCX0gZWxzZWlmIHskc2VsZWN0ZWRfY29tbWl0X3R5cGUgZXEge2FtZW5kfQorCX0gZWxzZWlmIHskY29tbWl0X3R5cGVfaXNfYW1lbmQgPT0gMQogCQkmJiAhW3N0cmluZyBtYXRjaCBhbWVuZCogJGNvbW1pdF90eXBlXX0gewogCQlsb2FkX2xhc3RfY29tbWl0CiAKIAkJIyBUaGUgYW1lbmQgcmVxdWVzdCB3YXMgcmVqZWN0ZWQuLi4KIAkJIwogCQlpZiB7IVtzdHJpbmcgbWF0Y2ggYW1lbmQqICRjb21taXRfdHlwZV19IHsKLQkJCXNldCBzZWxlY3RlZF9jb21taXRfdHlwZSBuZXcKKwkJCXNldCBjb21taXRfdHlwZV9pc19hbWVuZCAwCiAJCX0KIAl9CiB9CmRpZmYgLS1naXQgYS9naXQtZ3VpL3BvL2phLnBvIGIvZ2l0LWd1aS9wby9qYS5wbwppbmRleCAyMDg2NTFjLi4yZjYxMTUzIDEwMDY0NAotLS0gYS9naXQtZ3VpL3BvL2phLnBvCisrKyBiL2dpdC1ndWkvcG8vamEucG8KQEAgLTQsMTQgKzQsMTUgQEAKICMKICMg44GX44KJ44GE44GXIOOBquOBquOBkyA8bmFuYWtvM0BibHVlYm90dGxlLmNvbT4sIDIwMDcuCiAjIFNhdG9zaGkgWWFzdXNoaW1hIDxzLnlhc3VzaGltYUBnbWFpbC5jb20+LCAyMDE2LgorIyBLSURBTkkgQWtpdG8gPGEua2lkLjE5ODVAZ21haWwuY29tPiwgMjAxOS4KICMKIG1zZ2lkICIiCiBtc2dzdHIgIiIKICJQcm9qZWN0LUlkLVZlcnNpb246IGdpdC1ndWlcbiIKICJSZXBvcnQtTXNnaWQtQnVncy1UbzogXG4iCiAiUE9ULUNyZWF0aW9uLURhdGU6IDIwMTYtMDUtMjcgMTc6NTIrMDkwMFxuIgotIlBPLVJldmlzaW9uLURhdGU6IDIwMTYtMDYtMjIgMTI6NTArMDkwMFxuIgotIkxhc3QtVHJhbnNsYXRvcjogU2F0b3NoaSBZYXN1c2hpbWEgPHMueWFzdXNoaW1hQGdtYWlsLmNvbT5cbiIKKyJQTy1SZXZpc2lvbi1EYXRlOiAyMDE5LTEwLTEzIDIzOjIwKzA5MDBcbiIKKyJMYXN0LVRyYW5zbGF0b3I6IEtJREFOSSBBa2l0byA8YS5raWQuMTk4NUBnbWFpbC5jb20+XG4iCiAiTGFuZ3VhZ2UtVGVhbTogSmFwYW5lc2VcbiIKICJMYW5ndWFnZTogamFcbiIKICJNSU1FLVZlcnNpb246IDEuMFxuIgpAQCAtNjYxLDcgKzY2Miw3IEBACiAjOiBsaWIvbWVyZ2UudGNsOjEwOAogIywgdGNsLWZvcm1hdAogbXNnaWQgIiVzIG9mICVzIgotbXNnc3RyICIlcyDjga4gJXMg44OW44Op44Oz44OBIgorbXNnc3RyICIlMiRzIOOBriAlMSRzIOODluODqeODs+ODgSIKIAogIzogbGliL21lcmdlLnRjbDoxMjIKICMsIHRjbC1mb3JtYXQKQEAgLTk1Niw3ICs5NTcsNyBAQAogIzogbGliL2NoZWNrb3V0X29wLnRjbDo4NQogIywgdGNsLWZvcm1hdAogbXNnaWQgIkZldGNoaW5nICVzIGZyb20gJXMiCi1tc2dzdHIgIiVzIOOBi+OCiSAlcyDjgpLjg5Xjgqfjg4Pjg4HjgZfjgabjgYTjgb7jgZkiCittc2dzdHIgIiUyJHMg44GL44KJICUxJHMg44KS44OV44Kn44OD44OB44GX44Gm44GE44G+44GZIgogCiAjOiBsaWIvY2hlY2tvdXRfb3AudGNsOjEzMwogIywgdGNsLWZvcm1hdApkaWZmIC0tZ2l0IGEvZ2l0LWxlZ2FjeS1zdGFzaC5zaCBiL2dpdC1sZWdhY3ktc3Rhc2guc2gKaW5kZXggZjYwZTliMy4uNTNmYTU3NCAxMDA3NTUKLS0tIGEvZ2l0LWxlZ2FjeS1zdGFzaC5zaAorKysgYi9naXQtbGVnYWN5LXN0YXNoLnNoCkBAIC0xOTMsNyArMTkzLDggQEAKIAkJCUdJVF9JTkRFWF9GSUxFPSIkVE1QaW5kZXgiICYmCiAJCQlleHBvcnQgR0lUX0lOREVYX0ZJTEUgJiYKIAkJCWdpdCBkaWZmLWluZGV4IC0tbmFtZS1vbmx5IC16IEhFQUQgLS0gIiRAIiA+IiRUTVAtc3RhZ2VuYW1lcyIgJiYKLQkJCWdpdCB1cGRhdGUtaW5kZXggLXogLS1hZGQgLS1yZW1vdmUgLS1zdGRpbiA8IiRUTVAtc3RhZ2VuYW1lcyIgJiYKKwkJCWdpdCB1cGRhdGUtaW5kZXggLS1pZ25vcmUtc2tpcC13b3JrdHJlZS1lbnRyaWVzIFwKKwkJCQkteiAtLWFkZCAtLXJlbW92ZSAtLXN0ZGluIDwiJFRNUC1zdGFnZW5hbWVzIiAmJgogCQkJZ2l0IHdyaXRlLXRyZWUgJiYKIAkJCXJtIC1mICIkVE1QaW5kZXgiCiAJCSkgKSB8fApAQCAtMzcwLDcgKzM3MSw3IEBACiAJCQlnaXQgZGlmZi1pbmRleCAtcCAtLWNhY2hlZCAtLWJpbmFyeSBIRUFEIC0tICIkQCIgfAogCQkJZ2l0IGFwcGx5IC0taW5kZXggLVIKIAkJZWxzZQotCQkJZ2l0IHJlc2V0IC0taGFyZCAtcQorCQkJZ2l0IHJlc2V0IC0taGFyZCAtcSAtLW5vLXJlY3Vyc2Utc3VibW9kdWxlcwogCQlmaQogCiAJCWlmIHRlc3QgIiRrZWVwX2luZGV4IiA9ICJ0IiAmJiB0ZXN0IC1uICIkaV90cmVlIgpkaWZmIC0tZ2l0IGEvZ2l0LXA0LnB5IGIvZ2l0LXA0LnB5CmluZGV4IDM5OTFlN2QuLjYwYzczYjYgMTAwNzU1Ci0tLSBhL2dpdC1wNC5weQorKysgYi9naXQtcDQucHkKQEAgLTExNjAsMTMgKzExNjAsMTEgQEAKICAgICAgICAgICAgIGlmIGNvbnRlbnRzU2l6ZSA8PSBnaXRDb25maWdJbnQoJ2dpdC1wNC5sYXJnZUZpbGVDb21wcmVzc2VkVGhyZXNob2xkJyk6CiAgICAgICAgICAgICAgICAgcmV0dXJuIEZhbHNlCiAgICAgICAgICAgICBjb250ZW50VGVtcEZpbGUgPSBzZWxmLmdlbmVyYXRlVGVtcEZpbGUoY29udGVudHMpCi0gICAgICAgICAgICBjb21wcmVzc2VkQ29udGVudEZpbGUgPSB0ZW1wZmlsZS5OYW1lZFRlbXBvcmFyeUZpbGUocHJlZml4PSdnaXQtcDQtbGFyZ2UtZmlsZScsIGRlbGV0ZT1GYWxzZSkKLSAgICAgICAgICAgIHpmID0gemlwZmlsZS5aaXBGaWxlKGNvbXByZXNzZWRDb250ZW50RmlsZS5uYW1lLCBtb2RlPSd3JykKLSAgICAgICAgICAgIHpmLndyaXRlKGNvbnRlbnRUZW1wRmlsZSwgY29tcHJlc3NfdHlwZT16aXBmaWxlLlpJUF9ERUZMQVRFRCkKLSAgICAgICAgICAgIHpmLmNsb3NlKCkKLSAgICAgICAgICAgIGNvbXByZXNzZWRDb250ZW50c1NpemUgPSB6Zi5pbmZvbGlzdCgpWzBdLmNvbXByZXNzX3NpemUKKyAgICAgICAgICAgIGNvbXByZXNzZWRDb250ZW50RmlsZSA9IHRlbXBmaWxlLk5hbWVkVGVtcG9yYXJ5RmlsZShwcmVmaXg9J2dpdC1wNC1sYXJnZS1maWxlJywgZGVsZXRlPVRydWUpCisgICAgICAgICAgICB3aXRoIHppcGZpbGUuWmlwRmlsZShjb21wcmVzc2VkQ29udGVudEZpbGUsIG1vZGU9J3cnKSBhcyB6ZjoKKyAgICAgICAgICAgICAgICB6Zi53cml0ZShjb250ZW50VGVtcEZpbGUsIGNvbXByZXNzX3R5cGU9emlwZmlsZS5aSVBfREVGTEFURUQpCisgICAgICAgICAgICAgICAgY29tcHJlc3NlZENvbnRlbnRzU2l6ZSA9IHpmLmluZm9saXN0KClbMF0uY29tcHJlc3Nfc2l6ZQogICAgICAgICAgICAgb3MucmVtb3ZlKGNvbnRlbnRUZW1wRmlsZSkKLSAgICAgICAgICAgIG9zLnJlbW92ZShjb21wcmVzc2VkQ29udGVudEZpbGUubmFtZSkKICAgICAgICAgICAgIGlmIGNvbXByZXNzZWRDb250ZW50c1NpemUgPiBnaXRDb25maWdJbnQoJ2dpdC1wNC5sYXJnZUZpbGVDb21wcmVzc2VkVGhyZXNob2xkJyk6CiAgICAgICAgICAgICAgICAgcmV0dXJuIFRydWUKICAgICAgICAgcmV0dXJuIEZhbHNlCkBAIC0zNTI1LDggKzM1MjMsOSBAQAogICAgICAgICBzZWxmLnVwZGF0ZU9wdGlvbkRpY3QoZGV0YWlscykKICAgICAgICAgdHJ5OgogICAgICAgICAgICAgc2VsZi5jb21taXQoZGV0YWlscywgc2VsZi5leHRyYWN0RmlsZXNGcm9tQ29tbWl0KGRldGFpbHMpLCBzZWxmLmJyYW5jaCkKLSAgICAgICAgZXhjZXB0IElPRXJyb3I6CisgICAgICAgIGV4Y2VwdCBJT0Vycm9yIGFzIGVycjoKICAgICAgICAgICAgIHByaW50KCJJTyBlcnJvciB3aXRoIGdpdCBmYXN0LWltcG9ydC4gSXMgeW91ciBnaXQgdmVyc2lvbiByZWNlbnQgZW5vdWdoPyIpCisgICAgICAgICAgICBwcmludCgiSU8gZXJyb3IgZGV0YWlsczoge30iLmZvcm1hdChlcnIpKQogICAgICAgICAgICAgcHJpbnQoc2VsZi5naXRFcnJvci5yZWFkKCkpCiAKICAgICBkZWYgb3BlblN0cmVhbXMoc2VsZik6CmRpZmYgLS1naXQgYS9naXQtc2VuZC1lbWFpbC5wZXJsIGIvZ2l0LXNlbmQtZW1haWwucGVybAppbmRleCA1ZjkyYzg5Li5kYzk1NjU2IDEwMDc1NQotLS0gYS9naXQtc2VuZC1lbWFpbC5wZXJsCisrKyBiL2dpdC1zZW5kLWVtYWlsLnBlcmwKQEAgLTEyMjgsNyArMTIyOCw3IEBACiAjIGRvbWFpbiBuYW1lIHRoYXQgY29ycmVzcG9uZHMgdGhlIElQIGFkZHJlc3MgaW4gdGhlIEhFTE8vRUhMTwogIyBoYW5kc2hha2UuIFRoaXMgaXMgdXNlZCB0byB2ZXJpZnkgdGhlIGNvbm5lY3Rpb24gYW5kIHByZXZlbnQKICMgc3BhbW1lcnMgZnJvbSB0cnlpbmcgdG8gaGlkZSB0aGVpciBpZGVudGl0eS4gSWYgdGhlIEROUyBhbmQgSVAgZG9uJ3QKLSMgbWF0Y2gsIHRoZSByZWNlaXZlaW5nIE1UQSBtYXkgZGVueSB0aGUgY29ubmVjdGlvbi4KKyMgbWF0Y2gsIHRoZSByZWNlaXZpbmcgTVRBIG1heSBkZW55IHRoZSBjb25uZWN0aW9uLgogIwogIyBIZXJlIGlzIGEgZGVueSBleGFtcGxlIG9mIE5ldDo6U01UUCB3aXRoIHRoZSBkZWZhdWx0ICJsb2NhbGhvc3QubG9jYWxkb21haW4iCiAjCmRpZmYgLS1naXQgYS9naXQtc3ZuLnBlcmwgYi9naXQtc3ZuLnBlcmwKaW5kZXggMDUwZjJhMy4uNGFhMjA4ZiAxMDA3NTUKLS0tIGEvZ2l0LXN2bi5wZXJsCisrKyBiL2dpdC1zdm4ucGVybApAQCAtMTEwLDcgKzExMCw3IEBACiAJJF90ZW1wbGF0ZSwgJF9zaGFyZWQsCiAJJF92ZXJzaW9uLCAkX2ZldGNoX2FsbCwgJF9ub19yZWJhc2UsICRfZmV0Y2hfcGFyZW50LAogCSRfYmVmb3JlLCAkX2FmdGVyLAotCSRfbWVyZ2UsICRfc3RyYXRlZ3ksICRfcHJlc2VydmVfbWVyZ2VzLCAkX2RyeV9ydW4sICRfcGFyZW50cywgJF9sb2NhbCwKKwkkX21lcmdlLCAkX3N0cmF0ZWd5LCAkX3JlYmFzZV9tZXJnZXMsICRfZHJ5X3J1biwgJF9wYXJlbnRzLCAkX2xvY2FsLAogCSRfcHJlZml4LCAkX25vX2NoZWNrb3V0LCAkX3VybCwgJF92ZXJib3NlLAogCSRfY29tbWl0X3VybCwgJF90YWcsICRfbWVyZ2VfaW5mbywgJF9pbnRlcmFjdGl2ZSwgJF9zZXRfc3ZuX3Byb3BzKTsKIApAQCAtMjcwLDcgKzI3MCw4IEBACiAJCQkgICdsb2NhbHxsJyA9PiBcJF9sb2NhbCwKIAkJCSAgJ2ZldGNoLWFsbHxhbGwnID0+IFwkX2ZldGNoX2FsbCwKIAkJCSAgJ2RyeS1ydW58bicgPT4gXCRfZHJ5X3J1biwKLQkJCSAgJ3ByZXNlcnZlLW1lcmdlc3xwJyA9PiBcJF9wcmVzZXJ2ZV9tZXJnZXMsCisJCQkgICdyZWJhc2UtbWVyZ2VzfHAnID0+IFwkX3JlYmFzZV9tZXJnZXMsCisJCQkgICdwcmVzZXJ2ZS1tZXJnZXN8cCcgPT4gXCRfcmViYXNlX21lcmdlcywKIAkJCSAgJWZjX29wdHMgfSBdLAogCSdjb21taXQtZGlmZicgPT4gWyBcJmNtZF9jb21taXRfZGlmZiwKIAkgICAgICAgICAgICAgICAgICAgJ0NvbW1pdCBhIGRpZmYgYmV0d2VlbiB0d28gdHJlZXMnLApAQCAtMTA1NCw3ICsxMDU1LDcgQEAKIAkJCQkJICAnSWYgeW91IGFyZSBhdHRlbXB0aW5nIHRvIGNvbW1pdCAnLAogCQkJCQkgICJtZXJnZXMsIHRyeSBydW5uaW5nOlxuXHQiLAogCQkJCQkgICdnaXQgcmViYXNlIC0taW50ZXJhY3RpdmUnLAotCQkJCQkgICctLXByZXNlcnZlLW1lcmdlcyAnLAorCQkJCQkgICctLXJlYmFzZS1tZXJnZXMgJywKIAkJCQkJICAkZ3MtPnJlZm5hbWUsCiAJCQkJCSAgIlxuQmVmb3JlIGRjb21taXR0aW5nIjsKIAkJCQl9CkBAIC0xNzE3LDcgKzE3MTgsNyBAQAogCXB1c2ggQGNtZCwgJy12JyBpZiAkX3ZlcmJvc2U7CiAJcHVzaCBAY21kLCBxdy8tLW1lcmdlLyBpZiAkX21lcmdlOwogCXB1c2ggQGNtZCwgIi0tc3RyYXRlZ3k9JF9zdHJhdGVneSIgaWYgJF9zdHJhdGVneTsKLQlwdXNoIEBjbWQsICItLXByZXNlcnZlLW1lcmdlcyIgaWYgJF9wcmVzZXJ2ZV9tZXJnZXM7CisJcHVzaCBAY21kLCAiLS1yZWJhc2UtbWVyZ2VzIiBpZiAkX3JlYmFzZV9tZXJnZXM7CiAJQGNtZDsKIH0KIApkaWZmIC0tZ2l0IGEvZ2l0LmMgYi9naXQuYwppbmRleCBjMWVlNzEyLi5jZTZhYjBlIDEwMDY0NAotLS0gYS9naXQuYworKysgYi9naXQuYwpAQCAtMzY5LDggKzM2OSw3IEBACiAJCQlkaWUoXygiYWxpYXMgJyVzJyBjaGFuZ2VzIGVudmlyb25tZW50IHZhcmlhYmxlcy5cbiIKIAkJCSAgICAgICJZb3UgY2FuIHVzZSAnIWdpdCcgaW4gdGhlIGFsaWFzIHRvIGRvIHRoaXMiKSwKIAkJCSAgICBhbGlhc19jb21tYW5kKTsKLQkJbWVtbW92ZShuZXdfYXJndiAtIG9wdGlvbl9jb3VudCwgbmV3X2FyZ3YsCi0JCQkJY291bnQgKiBzaXplb2YoY2hhciAqKSk7CisJCU1PVkVfQVJSQVkobmV3X2FyZ3YgLSBvcHRpb25fY291bnQsIG5ld19hcmd2LCBjb3VudCk7CiAJCW5ld19hcmd2IC09IG9wdGlvbl9jb3VudDsKIAogCQlpZiAoY291bnQgPCAxKQpAQCAtMzg1LDcgKzM4NCw3IEBACiAKIAkJUkVBTExPQ19BUlJBWShuZXdfYXJndiwgY291bnQgKyAqYXJnY3ApOwogCQkvKiBpbnNlcnQgYWZ0ZXIgY29tbWFuZCBuYW1lICovCi0JCW1lbWNweShuZXdfYXJndiArIGNvdW50LCAqYXJndiArIDEsIHNpemVvZihjaGFyICopICogKmFyZ2NwKTsKKwkJQ09QWV9BUlJBWShuZXdfYXJndiArIGNvdW50LCAqYXJndiArIDEsICphcmdjcCk7CiAKIAkJdHJhY2UyX2NtZF9hbGlhcyhhbGlhc19jb21tYW5kLCBuZXdfYXJndik7CiAJCXRyYWNlMl9jbWRfbGlzdF9jb25maWcoKTsKZGlmZiAtLWdpdCBhL2dpdGstZ2l0L2dpdGsgYi9naXRrLWdpdC9naXRrCmluZGV4IGExNGQ3YTEuLmFiZTQ4MDUgMTAwNzU1Ci0tLSBhL2dpdGstZ2l0L2dpdGsKKysrIGIvZ2l0ay1naXQvZ2l0awpAQCAtMzQwNCw2ICszNDA0LDggQEAKIH0KIGltYWdlIGNyZWF0ZSBiaXRtYXAgcmVmaWNvbi1IIC1iYWNrZ3JvdW5kIGJsYWNrIC1mb3JlZ3JvdW5kICIjMDBmZjAwIiBcCiAgICAgLWRhdGEgJHJlY3RkYXRhIC1tYXNrZGF0YSAkcmVjdG1hc2sKK2ltYWdlIGNyZWF0ZSBiaXRtYXAgcmVmaWNvbi1SIC1iYWNrZ3JvdW5kIGJsYWNrIC1mb3JlZ3JvdW5kICIjZmZkZGFhIiBcCisgICAgLWRhdGEgJHJlY3RkYXRhIC1tYXNrZGF0YSAkcmVjdG1hc2sKIGltYWdlIGNyZWF0ZSBiaXRtYXAgcmVmaWNvbi1vIC1iYWNrZ3JvdW5kIGJsYWNrIC1mb3JlZ3JvdW5kICIjZGRkZGZmIiBcCiAgICAgLWRhdGEgJHJlY3RkYXRhIC1tYXNrZGF0YSAkcmVjdG1hc2sKIApAQCAtNzAxNiw2ICs3MDE4LDcgQEAKIAogIyBhcHBlbmQgc29tZSB0ZXh0IHRvIHRoZSBjdGV4dCB3aWRnZXQsIGFuZCBtYWtlIGFueSBTSEExIElECiAjIHRoYXQgd2Uga25vdyBhYm91dCBiZSBhIGNsaWNrYWJsZSBsaW5rLgorIyBBbHNvIGxvb2sgZm9yIFVSTHMgb2YgdGhlIGZvcm0gImh0dHBbc106Ly8uLi4iIGFuZCBtYWtlIHRoZW0gd2ViIGxpbmtzLgogcHJvYyBhcHBlbmR3aXRobGlua3Mge3RleHQgdGFnc30gewogICAgIGdsb2JhbCBjdGV4dCBsaW5rbnVtIGN1cnZpZXcKIApAQCAtNzAzMiw2ICs3MDM1LDE4IEBACiAJc2V0bGluayAkbGlua2lkIGxpbmskbGlua251bQogCWluY3IgbGlua251bQogICAgIH0KKyAgICBzZXQgd2xpbmtzIFtyZWdleHAgLWluZGljZXMgLWFsbCAtaW5saW5lIC1saW5lIFwKKwkJICAgIHtodHRwcz86Ly9bXls6c3BhY2U6XV0rfSAkdGV4dF0KKyAgICBmb3JlYWNoIGwgJHdsaW5rcyB7CisJc2V0IHMyIFtsaW5kZXggJGwgMF0KKwlzZXQgZTIgW2xpbmRleCAkbCAxXQorCXNldCB1cmwgW3N0cmluZyByYW5nZSAkdGV4dCAkczIgJGUyXQorCWluY3IgZTIKKwkkY3RleHQgdGFnIGRlbGV0ZSBsaW5rJGxpbmtudW0KKwkkY3RleHQgdGFnIGFkZCBsaW5rJGxpbmtudW0gIiRzdGFydCArICRzMiBjIiAiJHN0YXJ0ICsgJGUyIGMiCisJc2V0d2xpbmsgJHVybCBsaW5rJGxpbmtudW0KKwlpbmNyIGxpbmtudW0KKyAgICB9CiB9CiAKIHByb2Mgc2V0bGluayB7aWQgbGt9IHsKQEAgLTcwNjQsNiArNzA3OSwxOCBAQAogICAgIH0KIH0KIAorcHJvYyBzZXR3bGluayB7dXJsIGxrfSB7CisgICAgZ2xvYmFsIGN0ZXh0CisgICAgZ2xvYmFsIGxpbmtmZ2NvbG9yCisgICAgZ2xvYmFsIHdlYl9icm93c2VyCisKKyAgICBpZiB7JHdlYl9icm93c2VyIGVxIHt9fSByZXR1cm4KKyAgICAkY3RleHQgdGFnIGNvbmYgJGxrIC1mb3JlZ3JvdW5kICRsaW5rZmdjb2xvciAtdW5kZXJsaW5lIDEKKyAgICAkY3RleHQgdGFnIGJpbmQgJGxrIDwxPiBbbGlzdCBicm93c2V3ZWIgJHVybF0KKyAgICAkY3RleHQgdGFnIGJpbmQgJGxrIDxFbnRlcj4ge2xpbmtjdXJzb3IgJVcgMX0KKyAgICAkY3RleHQgdGFnIGJpbmQgJGxrIDxMZWF2ZT4ge2xpbmtjdXJzb3IgJVcgLTF9Cit9CisKIHByb2MgYXBwZW5kc2hvcnRsaW5rIHtpZCB7cHJlIHt9fSB7cG9zdCB7fX19IHsKICAgICBnbG9iYWwgY3RleHQgbGlua251bQogCkBAIC03MDk4LDYgKzcxMjUsMTYgQEAKICAgICB9CiB9CiAKK3Byb2MgYnJvd3Nld2ViIHt1cmx9IHsKKyAgICBnbG9iYWwgd2ViX2Jyb3dzZXIKKworICAgIGlmIHskd2ViX2Jyb3dzZXIgZXEge319IHJldHVybgorICAgICMgVXNlIGV2YWwgaGVyZSBpbiBjYXNlICR3ZWJfYnJvd3NlciBpcyBhIGNvbW1hbmQgcGx1cyBzb21lIGFyZ3VtZW50cworICAgIGlmIHtbY2F0Y2gge2V2YWwgZXhlYyAkd2ViX2Jyb3dzZXIgW2xpc3QgJHVybF0gJn0gZXJyXX0geworCWVycm9yX3BvcHVwICJbbWMgIkVycm9yIHN0YXJ0aW5nIHdlYiBicm93c2VyOiJdICRlcnIiCisgICAgfQorfQorCiBwcm9jIHZpZXduZXh0bGluZSB7ZGlyfSB7CiAgICAgZ2xvYmFsIGNhbnYgbGluZXNwYwogCkBAIC04MTkxLDExICs4MjI4LDExIEBACiAJfSBlbHNlIHsKIAkgICAgJGN0ZXh0IGluc2VydCBlbmQgIiRsaW5lXG4iIGZpbGVzZXAKIAl9Ci0gICAgfSBlbHNlaWYgeyFbc3RyaW5nIGNvbXBhcmUgLWxlbmd0aCAzICIgID4iICRsaW5lXX0geworICAgIH0gZWxzZWlmIHskY3VycmRpZmZzdWJtb2QgIT0gIiIgJiYgIVtzdHJpbmcgY29tcGFyZSAtbGVuZ3RoIDMgIiAgPiIgJGxpbmVdfSB7CiAJc2V0ICRjdXJyZGlmZnN1Ym1vZCAiIgogCXNldCBsaW5lIFtlbmNvZGluZyBjb252ZXJ0ZnJvbSAkZGlmZmVuY29kaW5nICRsaW5lXQogCSRjdGV4dCBpbnNlcnQgZW5kICIkbGluZVxuIiBkcmVzdWx0Ci0gICAgfSBlbHNlaWYgeyFbc3RyaW5nIGNvbXBhcmUgLWxlbmd0aCAzICIgIDwiICRsaW5lXX0geworICAgIH0gZWxzZWlmIHskY3VycmRpZmZzdWJtb2QgIT0gIiIgJiYgIVtzdHJpbmcgY29tcGFyZSAtbGVuZ3RoIDMgIiAgPCIgJGxpbmVdfSB7CiAJc2V0ICRjdXJyZGlmZnN1Ym1vZCAiIgogCXNldCBsaW5lIFtlbmNvZGluZyBjb252ZXJ0ZnJvbSAkZGlmZmVuY29kaW5nICRsaW5lXQogCSRjdGV4dCBpbnNlcnQgZW5kICIkbGluZVxuIiBkMApAQCAtMTAwMjIsNiArMTAwNTksNyBAQAogICAgIHNldCBuIFtsaW5kZXggJHJlZiAwXQogICAgIHN3aXRjaCAtLSBbbGluZGV4ICRyZWYgMV0gewogCSJIIiB7c2VsYnlpZCAkaGVhZGlkcygkbil9CisJIlIiIHtzZWxieWlkICRoZWFkaWRzKCRuKX0KIAkiVCIge3NlbGJ5aWQgJHRhZ2lkcygkbil9CiAJIm8iIHtzZWxieWlkICRvdGhlcnJlZmlkcygkbil9CiAgICAgfQpAQCAtMTAwNTEsNyArMTAwODksMTEgQEAKICAgICBmb3JlYWNoIG4gW2FycmF5IG5hbWVzIGhlYWRpZHNdIHsKIAlpZiB7W3N0cmluZyBtYXRjaCAkcmVmbGlzdGZpbHRlciAkbl19IHsKIAkgICAgaWYge1tjb21taXRpbnZpZXcgJGhlYWRpZHMoJG4pICRjdXJ2aWV3XX0gewotCQlsYXBwZW5kIHJlZnMgW2xpc3QgJG4gSF0KKwkJaWYge1tzdHJpbmcgbWF0Y2ggInJlbW90ZXMvKiIgJG5dfSB7CisJCSAgICBsYXBwZW5kIHJlZnMgW2xpc3QgJG4gUl0KKwkJfSBlbHNlIHsKKwkJICAgIGxhcHBlbmQgcmVmcyBbbGlzdCAkbiBIXQorCQl9CiAJICAgIH0gZWxzZSB7CiAJCWludGVyZXN0ZWRpbiAkaGVhZGlkcygkbikge3J1biByZWZpbGxfcmVmbGlzdH0KIAkgICAgfQpAQCAtMTE0ODgsNyArMTE1MzAsNyBAQAogcHJvYyBwcmVmc3BhZ2VfZ2VuZXJhbCB7bm90ZWJvb2t9IHsKICAgICBnbG9iYWwgTlMgbWF4d2lkdGggbWF4Z3JhcGhwY3Qgc2hvd25lYXJ0YWdzIHNob3dsb2NhbGNoYW5nZXMKICAgICBnbG9iYWwgdGFic3RvcCBsaW1pdGRpZmZzIGF1dG9zZWxlY3QgYXV0b3NlbGxlbiBleHRkaWZmdG9vbCBwZXJmaWxlX2F0dHJzCi0gICAgZ2xvYmFsIGhpZGVyZW1vdGVzIHdhbnRfdHRrIGhhdmVfdHRrIG1heHJlZnMKKyAgICBnbG9iYWwgaGlkZXJlbW90ZXMgd2FudF90dGsgaGF2ZV90dGsgbWF4cmVmcyB3ZWJfYnJvd3NlcgogCiAgICAgc2V0IHBhZ2UgW2NyZWF0ZV9wcmVmc19wYWdlICRub3RlYm9vay5nZW5lcmFsXQogCkBAIC0xMTUzOSw2ICsxMTU4MSwxMyBAQAogICAgIHBhY2sgY29uZmlndXJlICRwYWdlLmV4dGRpZmZmLmwgLXBhZHggMTAKICAgICBncmlkIHggJHBhZ2UuZXh0ZGlmZmYgJHBhZ2UuZXh0ZGlmZnQgLXN0aWNreSBldwogCisgICAgJHtOU306OmVudHJ5ICRwYWdlLndlYmJyb3dzZXIgLXRleHR2YXJpYWJsZSB3ZWJfYnJvd3NlcgorICAgICR7TlN9OjpmcmFtZSAkcGFnZS53ZWJicm93c2VyZgorICAgICR7TlN9OjpsYWJlbCAkcGFnZS53ZWJicm93c2VyZi5sIC10ZXh0IFttYyAiV2ViIGJyb3dzZXIiIF0KKyAgICBwYWNrICRwYWdlLndlYmJyb3dzZXJmLmwgLXNpZGUgbGVmdAorICAgIHBhY2sgY29uZmlndXJlICRwYWdlLndlYmJyb3dzZXJmLmwgLXBhZHggMTAKKyAgICBncmlkIHggJHBhZ2Uud2ViYnJvd3NlcmYgJHBhZ2Uud2ViYnJvd3NlciAtc3RpY2t5IGV3CisKICAgICAke05TfTo6bGFiZWwgJHBhZ2UubGdlbiAtdGV4dCBbbWMgIkdlbmVyYWwgb3B0aW9ucyJdCiAgICAgZ3JpZCAkcGFnZS5sZ2VuIC0gLXN0aWNreSB3IC1wYWR5IDEwCiAgICAgJHtOU306OmNoZWNrYnV0dG9uICRwYWdlLndhbnRfdHRrIC12YXJpYWJsZSB3YW50X3R0ayBcCkBAIC0xMjMxMCw2ICsxMjM1OSw3IEBACiAgICAgc2V0IGJnY29sb3IgU3lzdGVtV2luZG93CiAgICAgc2V0IGZnY29sb3IgU3lzdGVtV2luZG93VGV4dAogICAgIHNldCBzZWxlY3RiZ2NvbG9yIFN5c3RlbUhpZ2hsaWdodAorICAgIHNldCB3ZWJfYnJvd3NlciAiY21kIC9jIHN0YXJ0IgogfSBlbHNlIHsKICAgICBzZXQgdWljb2xvciBncmV5ODUKICAgICBzZXQgdWlmZ2NvbG9yIGJsYWNrCkBAIC0xMjMxNyw2ICsxMjM2NywxMSBAQAogICAgIHNldCBiZ2NvbG9yIHdoaXRlCiAgICAgc2V0IGZnY29sb3IgYmxhY2sKICAgICBzZXQgc2VsZWN0Ymdjb2xvciBncmF5ODUKKyAgICBpZiB7W3RrIHdpbmRvd2luZ3N5c3RlbV0gZXEgImFxdWEifSB7CisJc2V0IHdlYl9icm93c2VyICJvcGVuIgorICAgIH0gZWxzZSB7CisJc2V0IHdlYl9icm93c2VyICJ4ZGctb3BlbiIKKyAgICB9CiB9CiBzZXQgZGlmZmNvbG9ycyB7cmVkICIjMDBhMDAwIiBibHVlfQogc2V0IGRpZmZjb250ZXh0IDMKQEAgLTEyMzkwLDYgKzEyNDQ1LDcgQEAKICAgICBmaWxlc2VwYmdjb2xvciBmaWxlc2VwZmdjb2xvciBsaW5laG92ZXJiZ2NvbG9yIGxpbmVob3ZlcmZnY29sb3IKICAgICBsaW5laG92ZXJvdXRsaW5lY29sb3IgbWFpbmhlYWRjaXJjbGVjb2xvciB3b3JraW5nZmlsZXNjaXJjbGVjb2xvcgogICAgIGluZGV4Y2lyY2xlY29sb3IgY2lyY2xlY29sb3JzIGxpbmtmZ2NvbG9yIGNpcmNsZW91dGxpbmVjb2xvcgorICAgIHdlYl9icm93c2VyCiB9CiBmb3JlYWNoIHZhciAkY29uZmlnX3ZhcmlhYmxlcyB7CiAgICAgY29uZmlnX2luaXRfdHJhY2UgJHZhcgpkaWZmIC0tZ2l0IGEvZ2l0ay1naXQvcG8vemhfY24ucG8gYi9naXRrLWdpdC9wby96aF9jbi5wbwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4xN2I3Zjg5Ci0tLSAvZGV2L251bGwKKysrIGIvZ2l0ay1naXQvcG8vemhfY24ucG8KQEAgLTAsMCArMSwxMzY3IEBACisjIFRyYW5zbGF0aW9uIG9mIGdpdGsgdG8gU2ltcGxpZmllZCBDaGluZXNlLgorIworIyBUcmFuc2xhdG9yczoKKyMgWWFuS2UgPGlteWFua2VAMTYzLmNvbT4sIDIwMTcKKworbXNnaWQgIiIKK21zZ3N0ciAiIgorIlByb2plY3QtSWQtVmVyc2lvbjogR2l0IENoaW5lc2UgTG9jYWxpemF0aW9uIFByb2plY3RcbiIKKyJSZXBvcnQtTXNnaWQtQnVncy1UbzogXG4iCisiUE9ULUNyZWF0aW9uLURhdGU6IDIwMTctMDItMjggMjM6MTErMDgwMFxuIgorIlBPLVJldmlzaW9uLURhdGU6IDIwMTctMDMtMTEgMDI6MjcrMDgwMFxuIgorIkxhc3QtVHJhbnNsYXRvcjogWWFuS2UgPGlteWFua2VAMTYzLmNvbT5cbiIKKyJMYW5ndWFnZS1UZWFtOiBDaGluZXNlXG4iCisiTUlNRS1WZXJzaW9uOiAxLjBcbiIKKyJDb250ZW50LVR5cGU6IHRleHQvcGxhaW47IGNoYXJzZXQ9VVRGLThcbiIKKyJDb250ZW50LVRyYW5zZmVyLUVuY29kaW5nOiA4Yml0XG4iCisiTGFuZ3VhZ2U6IHpoX0NOXG4iCisKKyM6IGdpdGs6MTQwCittc2dpZCAiQ291bGRuJ3QgZ2V0IGxpc3Qgb2YgdW5tZXJnZWQgZmlsZXM6IgorbXNnc3RyICLkuI3og73ojrflj5bmnKrlkIjlubbmlofku7bliJfooajvvJoiCisKKyM6IGdpdGs6MjEyIGdpdGs6MjQwMworbXNnaWQgIkNvbG9yIHdvcmRzIgorbXNnc3RyICLnnYDoibLmmL7npLrlt67lvIIiCisKKyM6IGdpdGs6MjE3IGdpdGs6MjQwMyBnaXRrOjgyNDkgZ2l0azo4MjgyCittc2dpZCAiTWFya3VwIHdvcmRzIgorbXNnc3RyICLmoIforrDmmL7npLrlt67lvIIiCisKKyM6IGdpdGs6MzI0Cittc2dpZCAiRXJyb3IgcGFyc2luZyByZXZpc2lvbnM6IgorbXNnc3RyICLop6PmnpDniYjmnKzplJnor6/vvJoiCisKKyM6IGdpdGs6MzgwCittc2dpZCAiRXJyb3IgZXhlY3V0aW5nIC0tYXJnc2NtZCBjb21tYW5kOiIKK21zZ3N0ciAi6L+Q6KGMIC0tYXJnc2NtZOWRveS7pOWHuumUmSIKKworIzogZ2l0azozOTMKK21zZ2lkICJObyBmaWxlcyBzZWxlY3RlZDogLS1tZXJnZSBzcGVjaWZpZWQgYnV0IG5vIGZpbGVzIGFyZSB1bm1lcmdlZC4iCittc2dzdHIgIuayoeaciemAieS4reaWh+S7tu+8mi0t5oyH5a6abWVyZ2Xlj4LmlbDkvYbmsqHmnInmnKrlkIjlubbnmoTmlofku7bjgIIiCisKKyM6IGdpdGs6Mzk2Cittc2dpZCAiIgorIk5vIGZpbGVzIHNlbGVjdGVkOiAtLW1lcmdlIHNwZWNpZmllZCBidXQgbm8gdW5tZXJnZWQgZmlsZXMgYXJlIHdpdGhpbiBmaWxlICIKKyJsaW1pdC4iCittc2dzdHIgIuayoeaciemAieS4reaWh+S7tu+8mi0t5oyH5a6abWVyZ2Xlj4LmlbDkvYbmsqHmnInmnKrlkIjlubbnmoTmlofku7blnKjmlofku7bkuK0iCisKKyM6IGdpdGs6NDE4IGdpdGs6NTY2Cittc2dpZCAiRXJyb3IgZXhlY3V0aW5nIGdpdCBsb2c6IgorbXNnc3RyICLmiafooYxnaXQgbG9n5ZG95Luk5Ye66ZSZ77yaIgorCisjOiBnaXRrOjQzNiBnaXRrOjU4MgorbXNnaWQgIlJlYWRpbmciCittc2dzdHIgIuivu+WPluS4rSIKKworIzogZ2l0azo0OTYgZ2l0azo0NTQ5Cittc2dpZCAiUmVhZGluZyBjb21taXRzLi4uIgorbXNnc3RyICLmj5DkuqTorrDlvZXor7vlj5bkuK0uLi4iCisKKyM6IGdpdGs6NDk5IGdpdGs6MTY0MSBnaXRrOjQ1NTIKK21zZ2lkICJObyBjb21taXRzIHNlbGVjdGVkIgorbXNnc3RyICLmnKrpgInkuK3ku7vkvZXmj5DkuqQiCisKKyM6IGdpdGs6MTQ0OSBnaXRrOjQwNjkgZ2l0azoxMjU4MworbXNnaWQgIkNvbW1hbmQgbGluZSIKK21zZ3N0ciAi5ZG95Luk6KGMIgorCisjOiBnaXRrOjE1MTUKK21zZ2lkICJDYW4ndCBwYXJzZSBnaXQgbG9nIG91dHB1dDoiCittc2dzdHIgIuS4jeiDveino+aekGdpdCBsb2fovpPlh7rvvJoiCisKKyM6IGdpdGs6MTc0NAorbXNnaWQgIk5vIGNvbW1pdCBpbmZvcm1hdGlvbiBhdmFpbGFibGUiCittc2dzdHIgIuaXoOWPr+eUqOaPkOS6pOS/oeaBryIKKworIzogZ2l0azoxOTA3IGdpdGs6MTkzNiBnaXRrOjQzMzkgZ2l0azo5Nzg5IGdpdGs6MTEzODggZ2l0azoxMTY2OAorbXNnaWQgIk9LIgorbXNnc3RyICLnoa7lrpoiCisKKyM6IGdpdGs6MTkzOCBnaXRrOjQzNDEgZ2l0azo5MjI1IGdpdGs6OTMwNCBnaXRrOjk0MzQgZ2l0azo5NTIwIGdpdGs6OTc5MQorIzogZ2l0azoxMTM4OSBnaXRrOjExNjY5Cittc2dpZCAiQ2FuY2VsIgorbXNnc3RyICLlj5bmtogiCisKKyM6IGdpdGs6MjA4NworbXNnaWQgIiZVcGRhdGUiCittc2dzdHIgIuabtOaWsCIKKworIzogZ2l0azoyMDg4Cittc2dpZCAiJlJlbG9hZCIKK21zZ3N0ciAi6YeN5paw5Yqg6L29IgorCisjOiBnaXRrOjIwODkKK21zZ2lkICJSZXJlYWQgcmUmZmVyZW5jZXMiCittc2dzdHIgIumHjeaWsOivu+WPluW8leeUqCIKKworIzogZ2l0azoyMDkwCittc2dpZCAiJkxpc3QgcmVmZXJlbmNlcyIKK21zZ3N0ciAi5YiX5Ye65byV55SoKOWIhuaUr+S7peWPinRhZykiCisKKyM6IGdpdGs6MjA5MgorbXNnaWQgIlN0YXJ0IGdpdCAmZ3VpIgorbXNnc3RyICLlkK/liqhnaXQgZ3Vp5a6i5oi356uvIgorCisjOiBnaXRrOjIwOTQKK21zZ2lkICImUXVpdCIKK21zZ3N0ciAi6YCA5Ye6IgorCisjOiBnaXRrOjIwODYKK21zZ2lkICImRmlsZSIKK21zZ3N0ciAi5paH5Lu2IgorCisjOiBnaXRrOjIwOTgKK21zZ2lkICImUHJlZmVyZW5jZXMiCittc2dzdHIgIuWBj+Wlveiuvue9riIKKworIzogZ2l0azoyMDk3Cittc2dpZCAiJkVkaXQiCittc2dzdHIgIue8lui+kSIKKworIzogZ2l0azoyMTAyCittc2dpZCAiJk5ldyB2aWV3Li4uIgorbXNnc3RyICLmlrDop4blm74uLi4iCisKKyM6IGdpdGs6MjEwMworbXNnaWQgIiZFZGl0IHZpZXcuLi4iCittc2dzdHIgIue8lui+keinhuWbvi4uLiIKKworIzogZ2l0azoyMTA0Cittc2dpZCAiJkRlbGV0ZSB2aWV3IgorbXNnc3RyICLliKDpmaTop4blm74iCisKKyM6IGdpdGs6MjEwNgorbXNnaWQgIiZBbGwgZmlsZXMiCittc2dzdHIgIuaJgOacieaWh+S7tiIKKworIzogZ2l0azoyMTAxCittc2dpZCAiJlZpZXciCittc2dzdHIgIuinhuWbviIKKworIzogZ2l0azoyMTExIGdpdGs6MjEyMQorbXNnaWQgIiZBYm91dCBnaXRrIgorbXNnc3RyICLlhbPkuo5naXRrIgorCisjOiBnaXRrOjIxMTIgZ2l0azoyMTI2Cittc2dpZCAiJktleSBiaW5kaW5ncyIKK21zZ3N0ciAi5b+r5o236ZSuIgorCisjOiBnaXRrOjIxMTAgZ2l0azoyMTI1Cittc2dpZCAiJkhlbHAiCittc2dzdHIgIuW4ruWKqSIKKworIzogZ2l0azoyMjAzIGdpdGs6ODY4MQorbXNnaWQgIlNIQTEgSUQ6IgorbXNnc3RyICJTSEExIElE77yaIgorCisjOiBnaXRrOjIyNDcKK21zZ2lkICJSb3ciCittc2dzdHIgIuihjCIKKworIzogZ2l0azoyMjg1Cittc2dpZCAiRmluZCIKK21zZ3N0ciAi5p+l5om+IgorCisjOiBnaXRrOjIzMTMKK21zZ2lkICJjb21taXQiCittc2dzdHIgIuaPkOS6pCIKKworIzogZ2l0azoyMzE3IGdpdGs6MjMxOSBnaXRrOjQ3MTEgZ2l0azo0NzM0IGdpdGs6NDc1OCBnaXRrOjY3NzkgZ2l0azo2ODUxCisjOiBnaXRrOjY5MzYKK21zZ2lkICJjb250YWluaW5nOiIKK21zZ3N0ciAi5YyF5ZCr77yaIgorCisjOiBnaXRrOjIzMjAgZ2l0azozNTUwIGdpdGs6MzU1NSBnaXRrOjQ3ODcKK21zZ2lkICJ0b3VjaGluZyBwYXRoczoiCittc2dzdHIgIuW9seWTjei3r+W+hO+8miIKKworIzogZ2l0azoyMzIxIGdpdGs6NDgwMQorbXNnaWQgImFkZGluZy9yZW1vdmluZyBzdHJpbmc6IgorbXNnc3RyICLlop7liqAv5Yig6Zmk5a2X56ym5Liy77yaIgorCisjOiBnaXRrOjIzMjIgZ2l0azo0ODAzCittc2dpZCAiY2hhbmdpbmcgbGluZXMgbWF0Y2hpbmc6IgorbXNnc3RyICLmlLnlj5jooYzljLnphY3vvJoiCisKKyM6IGdpdGs6MjMzMSBnaXRrOjIzMzMgZ2l0azo0NzkwCittc2dpZCAiRXhhY3QiCittc2dzdHIgIueyvuehruWMuemFjSIKKworIzogZ2l0azoyMzMzIGdpdGs6NDg3OCBnaXRrOjY3NDcKK21zZ2lkICJJZ25DYXNlIgorbXNnc3RyICLlv73nlaXlpKflsI/lhpkiCisKKyM6IGdpdGs6MjMzMyBnaXRrOjQ3NjAgZ2l0azo0ODc2IGdpdGs6Njc0MworbXNnaWQgIlJlZ2V4cCIKK21zZ3N0ciAi5q2j5YiZIgorCisjOiBnaXRrOjIzMzUgZ2l0azoyMzM2IGdpdGs6NDg5OCBnaXRrOjQ5MjggZ2l0azo0OTM1IGdpdGs6Njg3MiBnaXRrOjY5NDAKK21zZ2lkICJBbGwgZmllbGRzIgorbXNnc3RyICLmiYDmnInlrZfmrrUiCisKKyM6IGdpdGs6MjMzNiBnaXRrOjQ4OTUgZ2l0azo0OTI4IGdpdGs6NjgxMAorbXNnaWQgIkhlYWRsaW5lIgorbXNnc3RyICLmoIfpopgiCisKKyM6IGdpdGs6MjMzNyBnaXRrOjQ4OTUgZ2l0azo2ODEwIGdpdGs6Njk0MCBnaXRrOjc0MTMKK21zZ2lkICJDb21tZW50cyIKK21zZ3N0ciAi5o+Q5Lqk5rOo6YeKIgorCisjOiBnaXRrOjIzMzcgZ2l0azo0ODk1IGdpdGs6NDkwMCBnaXRrOjQ5MzUgZ2l0azo2ODEwIGdpdGs6NzM0OCBnaXRrOjg4NTkKKyM6IGdpdGs6ODg3NAorbXNnaWQgIkF1dGhvciIKK21zZ3N0ciAi5L2c6ICFIgorCisjOiBnaXRrOjIzMzcgZ2l0azo0ODk1IGdpdGs6NjgxMCBnaXRrOjczNTAKK21zZ2lkICJDb21taXR0ZXIiCittc2dzdHIgIuaPkOS6pOiAhSIKKworIzogZ2l0azoyMzcxCittc2dpZCAiU2VhcmNoIgorbXNnc3RyICLmkJzntKIiCisKKyM6IGdpdGs6MjM3OQorbXNnaWQgIkRpZmYiCittc2dzdHIgIuW3ruW8giIKKworIzogZ2l0azoyMzgxCittc2dpZCAiT2xkIHZlcnNpb24iCittc2dzdHIgIuiAgeeJiOacrCIKKworIzogZ2l0azoyMzgzCittc2dpZCAiTmV3IHZlcnNpb24iCittc2dzdHIgIuaWsOeJiOacrCIKKworIzogZ2l0azoyMzg2Cittc2dpZCAiTGluZXMgb2YgY29udGV4dCIKK21zZ3N0ciAiRGlmZuS4iuS4i+aWh+aYvuekuuihjOaVsCIKKworIzogZ2l0azoyMzk2Cittc2dpZCAiSWdub3JlIHNwYWNlIGNoYW5nZSIKK21zZ3N0ciAi5b+955Wl56m65qC85L+u5pS5IgorCisjOiBnaXRrOjI0MDAgZ2l0azoyNDAyIGdpdGs6Nzk4MyBnaXRrOjgyMzUKK21zZ2lkICJMaW5lIGRpZmYiCittc2dzdHIgIuaMieihjOaYvuekuuW3ruW8giIKKworIzogZ2l0azoyNDY3Cittc2dpZCAiUGF0Y2giCittc2dzdHIgIuihpeS4gSIKKworIzogZ2l0azoyNDY5Cittc2dpZCAiVHJlZSIKK21zZ3N0ciAi5qCRIgorCisjOiBnaXRrOjI2MzkgZ2l0azoyNjYwCittc2dpZCAiRGlmZiB0aGlzIC0+IHNlbGVjdGVkIgorbXNnc3RyICLmr5TovoPku47lvZPliY3mj5DkuqTliLDpgInkuK3mj5DkuqTnmoTlt67lvIIiCisKKyM6IGdpdGs6MjY0MCBnaXRrOjI2NjEKK21zZ2lkICJEaWZmIHNlbGVjdGVkIC0+IHRoaXMiCittc2dzdHIgIuavlOi+g+S7jumAieS4reaPkOS6pOWIsOW9k+WJjeaPkOS6pOeahOW3ruW8giIKKworIzogZ2l0azoyNjQxIGdpdGs6MjY2MgorbXNnaWQgIk1ha2UgcGF0Y2giCittc2dzdHIgIuWItuS9nOihpeS4gSIKKworIzogZ2l0azoyNjQyIGdpdGs6OTI4MworbXNnaWQgIkNyZWF0ZSB0YWciCittc2dzdHIgIuWIm+W7unRhZyIKKworIzogZ2l0azoyNjQzCittc2dpZCAiQ29weSBjb21taXQgc3VtbWFyeSIKK21zZ3N0ciAi5aSN5Yi25o+Q5Lqk5pGY6KaBIgorCisjOiBnaXRrOjI2NDQgZ2l0azo5NDE0Cittc2dpZCAiV3JpdGUgY29tbWl0IHRvIGZpbGUiCittc2dzdHIgIuWGmeWFpeaPkOS6pOWIsOaWh+S7tiIKKworIzogZ2l0azoyNjQ1Cittc2dpZCAiQ3JlYXRlIG5ldyBicmFuY2giCittc2dzdHIgIuWIm+W7uuaWsOWIhuaUryIKKworIzogZ2l0azoyNjQ2Cittc2dpZCAiQ2hlcnJ5LXBpY2sgdGhpcyBjb21taXQiCittc2dzdHIgIuWcqOatpOaPkOS6pOi/kOeUqOihpeS4gShjaGVycnktcGljaynlkb3ku6QiCisKKyM6IGdpdGs6MjY0NworbXNnaWQgIlJlc2V0IEhFQUQgYnJhbmNoIHRvIGhlcmUiCittc2dzdHIgIuWwhuWIhuaUr+WktChIRUFEKemHjee9ruWIsOatpOWkhCIKKworIzogZ2l0azoyNjQ4Cittc2dpZCAiTWFyayB0aGlzIGNvbW1pdCIKK21zZ3N0ciAi5qCH6K6w5q2k5o+Q5LqkIgorCisjOiBnaXRrOjI2NDkKK21zZ2lkICJSZXR1cm4gdG8gbWFyayIKK21zZ3N0ciAi6L+U5Zue5Yiw5qCH6K6wIgorCisjOiBnaXRrOjI2NTAKK21zZ2lkICJGaW5kIGRlc2NlbmRhbnQgb2YgdGhpcyBhbmQgbWFyayIKK21zZ3N0ciAi5p+l5om+5pys5qyh5o+Q5Lqk55qE5a2Q5o+Q5Lqk5bm25qCH6K6wIgorCisjOiBnaXRrOjI2NTEKK21zZ2lkICJDb21wYXJlIHdpdGggbWFya2VkIGNvbW1pdCIKK21zZ3N0ciAi5ZKM5bey5qCH6K6w55qE5o+Q5Lqk5L2c5q+U6L6DIgorCisjOiBnaXRrOjI2NTIgZ2l0azoyNjYzCittc2dpZCAiRGlmZiB0aGlzIC0+IG1hcmtlZCBjb21taXQiCittc2dzdHIgIuavlOi+g+S7juW9k+WJjeaPkOS6pOWIsOW3suagh+iusOaPkOS6pOeahOW3ruW8giIKKworIzogZ2l0azoyNjUzIGdpdGs6MjY2NAorbXNnaWQgIkRpZmYgbWFya2VkIGNvbW1pdCAtPiB0aGlzIgorbXNnc3RyICLmr5TovoPku47lt7LmoIforrDmj5DkuqTliLDlvZPliY3mj5DkuqTnmoTlt67lvIIiCisKKyM6IGdpdGs6MjY1NAorbXNnaWQgIlJldmVydCB0aGlzIGNvbW1pdCIKK21zZ3N0ciAi5pKk6ZSAKHJldmVydCnmraTmj5DkuqQiCisKKyM6IGdpdGs6MjY3MAorbXNnaWQgIkNoZWNrIG91dCB0aGlzIGJyYW5jaCIKK21zZ3N0ciAi5qOA5Ye6KGNoZWNrb3V0KeatpOWIhuaUryIKKworIzogZ2l0azoyNjcxCittc2dpZCAiUmVuYW1lIHRoaXMgYnJhbmNoIgorbXNnc3RyICLph43lkb3lkI0oUmVuYW1lKeatpOWIhuaUryIKKworIzogZ2l0azoyNjcyCittc2dpZCAiUmVtb3ZlIHRoaXMgYnJhbmNoIgorbXNnc3RyICLliKDpmaQoUmVtb3ZlKeatpOWIhuaUryIKKworIzogZ2l0azoyNjczCittc2dpZCAiQ29weSBicmFuY2ggbmFtZSIKK21zZ3N0ciAi5aSN5Yi25YiG5pSv5ZCN56ewIgorCisjOiBnaXRrOjI2ODAKK21zZ2lkICJIaWdobGlnaHQgdGhpcyB0b28iCittc2dzdHIgIumrmOS6ruatpOWkhCIKKworIzogZ2l0azoyNjgxCittc2dpZCAiSGlnaGxpZ2h0IHRoaXMgb25seSIKK21zZ3N0ciAi5Y+q6auY5Lqu5q2k5aSEIgorCisjOiBnaXRrOjI2ODIKK21zZ2lkICJFeHRlcm5hbCBkaWZmIgorbXNnc3RyICLlpJbpg6hkaWZmIgorCisjOiBnaXRrOjI2ODMKK21zZ2lkICJCbGFtZSBwYXJlbnQgY29tbWl0IgorbXNnc3RyICJCbGFtZeeItuaPkOS6pCIKKworIzogZ2l0azoyNjg0Cittc2dpZCAiQ29weSBwYXRoIgorbXNnc3RyICLlpI3liLbot6/lvoQiCisKKyM6IGdpdGs6MjY5MQorbXNnaWQgIlNob3cgb3JpZ2luIG9mIHRoaXMgbGluZSIKK21zZ3N0ciAi5pi+56S65q2k6KGM5Y6f5aeL5o+Q5LqkIgorCisjOiBnaXRrOjI2OTIKK21zZ2lkICJSdW4gZ2l0IGd1aSBibGFtZSBvbiB0aGlzIGxpbmUiCittc2dzdHIgIuWcqOatpOihjOi/kOihjGdpdCBndWnlrqLmiLfnq6/nmoRibGFtZSIKKworIzogZ2l0azozMDM2Cittc2dpZCAiQWJvdXQgZ2l0ayIKK21zZ3N0ciAi5YWz5LqOZ2l0ayIKKworIzogZ2l0azozMDM4Cittc2dpZCAiIgorIlxuIgorIkdpdGsgLSBhIGNvbW1pdCB2aWV3ZXIgZm9yIGdpdFxuIgorIlxuIgorIkNvcHlyaWdodCDCqSAyMDA1LTIwMTYgUGF1bCBNYWNrZXJyYXNcbiIKKyJcbiIKKyJVc2UgYW5kIHJlZGlzdHJpYnV0ZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIgorbXNnc3RyICJcbkdpdGsg4oCUIOS4gOS4qmdpdOeahOaPkOS6pOafpeeci+WZqFxuXG7CqSAyMDA1LTIwMTYgUGF1bCBNYWNrZXJyYXNcblxu5ZyoR05V6K645Y+v6K+B5LiL5L2/55So5Lul5Y+K5YiG5Y+RIgorCisjOiBnaXRrOjMwNDYgZ2l0azozMTEzIGdpdGs6MTAwMDQKK21zZ2lkICJDbG9zZSIKK21zZ3N0ciAi5YWz6ZetIgorCisjOiBnaXRrOjMwNjcKK21zZ2lkICJHaXRrIGtleSBiaW5kaW5ncyIKK21zZ3N0ciAiR2l0a+W/q+aNt+mUriIKKworIzogZ2l0azozMDcwCittc2dpZCAiR2l0ayBrZXkgYmluZGluZ3M6IgorbXNnc3RyICJHaXRr5b+r5o236ZSu77yaIgorCisjOiBnaXRrOjMwNzIKKyMsIHRjbC1mb3JtYXQKK21zZ2lkICI8JXMtUT5cdFx0UXVpdCIKK21zZ3N0ciAiPCVzLVE+XHRcdOmAgOWHuiIKKworIzogZ2l0azozMDczCisjLCB0Y2wtZm9ybWF0Cittc2dpZCAiPCVzLVc+XHRcdENsb3NlIHdpbmRvdyIKK21zZ3N0ciAiPCVzLVc+XHRcdOWFs+mXreeql+WPoyIKKworIzogZ2l0azozMDc0Cittc2dpZCAiPEhvbWU+XHRcdE1vdmUgdG8gZmlyc3QgY29tbWl0IgorbXNnc3RyICI8SG9tZT5cdFx056e75Yqo5Yiw56ys5LiA5qyh5o+Q5LqkIgorCisjOiBnaXRrOjMwNzUKK21zZ2lkICI8RW5kPlx0XHRNb3ZlIHRvIGxhc3QgY29tbWl0IgorbXNnc3RyICI8RW5kPlx0XHTnp7vliqjliLDmnIDlkI7kuIDmrKHmj5DkuqQiCisKKyM6IGdpdGs6MzA3NgorbXNnaWQgIjxVcD4sIHAsIGtcdE1vdmUgdXAgb25lIGNvbW1pdCIKK21zZ3N0ciAiPFVwPiwgcCwga1x056e75Yqo5Yiw5LiK5LiA5qyh5o+Q5LqkIgorCisjOiBnaXRrOjMwNzcKK21zZ2lkICI8RG93bj4sIG4sIGpcdE1vdmUgZG93biBvbmUgY29tbWl0IgorbXNnc3RyICI8RG93bj4sIG4sIGpcdOenu+WKqOWIsOS4i+S4gOasoeaPkOS6pCIKKworIzogZ2l0azozMDc4Cittc2dpZCAiPExlZnQ+LCB6LCBoXHRHbyBiYWNrIGluIGhpc3RvcnkgbGlzdCIKK21zZ3N0ciAiPExlZnQ+LCB6LCBoXHTljoblj7LliJfooajnmoTkuIrkuIDpobkiCisKKyM6IGdpdGs6MzA3OQorbXNnaWQgIjxSaWdodD4sIHgsIGxcdEdvIGZvcndhcmQgaW4gaGlzdG9yeSBsaXN0IgorbXNnc3RyICI8UmlnaHQ+LCB4LCBsXHTljoblj7LliJfooajnmoTkuIvkuIDpobkiCisKKyM6IGdpdGs6MzA4MAorIywgdGNsLWZvcm1hdAorbXNnaWQgIjwlcy1uPlx0R28gdG8gbi10aCBwYXJlbnQgb2YgY3VycmVudCBjb21taXQgaW4gaGlzdG9yeSBsaXN0IgorbXNnc3RyICI8JXMtbj5cdOWcqOWOhuWPsuWIl+ihqOS4reWJjeW+gOacrOasoeaPkOS6pOeahOesrG7kuKrniLbmj5DkuqQiCisKKyM6IGdpdGs6MzA4MQorbXNnaWQgIjxQYWdlVXA+XHRNb3ZlIHVwIG9uZSBwYWdlIGluIGNvbW1pdCBsaXN0IgorbXNnc3RyICI8UGFnZVVwPlx05LiK5LiA6aG15o+Q5Lqk5YiX6KGoIgorCisjOiBnaXRrOjMwODIKK21zZ2lkICI8UGFnZURvd24+XHRNb3ZlIGRvd24gb25lIHBhZ2UgaW4gY29tbWl0IGxpc3QiCittc2dzdHIgIjxQYWdlRG93bj5cdOS4i+S4gOmhteaPkOS6pOWIl+ihqCIKKworIzogZ2l0azozMDgzCisjLCB0Y2wtZm9ybWF0Cittc2dpZCAiPCVzLUhvbWU+XHRTY3JvbGwgdG8gdG9wIG9mIGNvbW1pdCBsaXN0IgorbXNnc3RyICI8JXMtSG9tZT5cdOa7muWKqOWIsOaPkOS6pOWIl+ihqOmhtumDqCIKKworIzogZ2l0azozMDg0CisjLCB0Y2wtZm9ybWF0Cittc2dpZCAiPCVzLUVuZD5cdFNjcm9sbCB0byBib3R0b20gb2YgY29tbWl0IGxpc3QiCittc2dzdHIgIjwlcy1FbmQ+XHTmu5rliqjliLDmj5DkuqTliJfooajlupXpg6giCisKKyM6IGdpdGs6MzA4NQorIywgdGNsLWZvcm1hdAorbXNnaWQgIjwlcy1VcD5cdFNjcm9sbCBjb21taXQgbGlzdCB1cCBvbmUgbGluZSIKK21zZ3N0ciAiPCVzLVVwPlx05ZCR5LiK5rua5Yqo5LiA6KGM5o+Q5Lqk5YiX6KGoIgorCisjOiBnaXRrOjMwODYKKyMsIHRjbC1mb3JtYXQKK21zZ2lkICI8JXMtRG93bj5cdFNjcm9sbCBjb21taXQgbGlzdCBkb3duIG9uZSBsaW5lIgorbXNnc3RyICI8JXMtRG93bj5cdOWQkeS4i+a7muWKqOS4gOihjOaPkOS6pOWIl+ihqCIKKworIzogZ2l0azozMDg3CisjLCB0Y2wtZm9ybWF0Cittc2dpZCAiPCVzLVBhZ2VVcD5cdFNjcm9sbCBjb21taXQgbGlzdCB1cCBvbmUgcGFnZSIKK21zZ3N0ciAiPCVzLVBhZ2VVcD5cdOWQkeS4iua7muWKqOS4gOmhteaPkOS6pOWIl+ihqCIKKworIzogZ2l0azozMDg4CisjLCB0Y2wtZm9ybWF0Cittc2dpZCAiPCVzLVBhZ2VEb3duPlx0U2Nyb2xsIGNvbW1pdCBsaXN0IGRvd24gb25lIHBhZ2UiCittc2dzdHIgIjwlcy1QYWdlRG93bj5cdOWQkeS4i+a7muWKqOS4gOmhteaPkOS6pOWIl+ihqCIKKworIzogZ2l0azozMDg5Cittc2dpZCAiPFNoaWZ0LVVwPlx0RmluZCBiYWNrd2FyZHMgKHVwd2FyZHMsIGxhdGVyIGNvbW1pdHMpIgorbXNnc3RyICI8U2hpZnQtVXA+XHTlkJHlkI7mn6Xmib4o5ZCR5LiK55qE77yM5pu05pma55qE5o+Q5LqkKSIKKworIzogZ2l0azozMDkwCittc2dpZCAiPFNoaWZ0LURvd24+XHRGaW5kIGZvcndhcmRzIChkb3dud2FyZHMsIGVhcmxpZXIgY29tbWl0cykiCittc2dzdHIgIjxTaGlmdC1Eb3duPlx05ZCR5YmN5p+l5om+KOWQkeS4i+eahO+8jOabtOaXqeeahOaPkOS6pCkiCisKKyM6IGdpdGs6MzA5MQorbXNnaWQgIjxEZWxldGU+LCBiXHRTY3JvbGwgZGlmZiB2aWV3IHVwIG9uZSBwYWdlIgorbXNnc3RyICI8RGVsZXRlPiwgYlx05ZCR5LiK5rua5YqoZGlmZuinhuWbvuS4gOmhtSIKKworIzogZ2l0azozMDkyCittc2dpZCAiPEJhY2tzcGFjZT5cdFNjcm9sbCBkaWZmIHZpZXcgdXAgb25lIHBhZ2UiCittc2dzdHIgIjxCYWNrc3BhY2U+XHTlkJHkuIrmu5rliqhkaWZm6KeG5Zu+5LiA6aG1IgorCisjOiBnaXRrOjMwOTMKK21zZ2lkICI8U3BhY2U+XHRcdFNjcm9sbCBkaWZmIHZpZXcgZG93biBvbmUgcGFnZSIKK21zZ3N0ciAiPFNwYWNlPlx0XHTlkJHkuIvmu5rliqhkaWZm6KeG5Zu+5LiA6aG1IgorCisjOiBnaXRrOjMwOTQKK21zZ2lkICJ1XHRcdFNjcm9sbCBkaWZmIHZpZXcgdXAgMTggbGluZXMiCittc2dzdHIgInVcdFx05ZCR5LiK5rua5YqoZGlmZuinhuWbvjE46KGMIgorCisjOiBnaXRrOjMwOTUKK21zZ2lkICJkXHRcdFNjcm9sbCBkaWZmIHZpZXcgZG93biAxOCBsaW5lcyIKK21zZ3N0ciAiZFx0XHTlkJHkuIvmu5rliqhkaWZm6KeG5Zu+MTjooYwiCisKKyM6IGdpdGs6MzA5NgorIywgdGNsLWZvcm1hdAorbXNnaWQgIjwlcy1GPlx0XHRGaW5kIgorbXNnc3RyICI8JXMtRj5cdFx05p+l5om+IgorCisjOiBnaXRrOjMwOTcKKyMsIHRjbC1mb3JtYXQKK21zZ2lkICI8JXMtRz5cdFx0TW92ZSB0byBuZXh0IGZpbmQgaGl0IgorbXNnc3RyICI8JXMtRz5cdFx056e75Yqo5Yiw5LiL5LiA5qyh5p+l5om+5ZG95LitIgorCisjOiBnaXRrOjMwOTgKK21zZ2lkICI8UmV0dXJuPlx0TW92ZSB0byBuZXh0IGZpbmQgaGl0IgorbXNnc3RyICI8UmV0dXJuPlx0XHTnp7vliqjliLDkuIvkuIDmrKHmn6Xmib7lkb3kuK0iCisKKyM6IGdpdGs6MzA5OQorbXNnaWQgImdcdFx0R28gdG8gY29tbWl0IgorbXNnc3RyICJnXHRcdOi9rOWIsOaPkOS6pCIKKworIzogZ2l0azozMTAwCittc2dpZCAiL1x0XHRGb2N1cyB0aGUgc2VhcmNoIGJveCIKK21zZ3N0ciAiL1x0XHTpgInkuK3mkJzntKLmoYYiCisKKyM6IGdpdGs6MzEwMQorbXNnaWQgIj9cdFx0TW92ZSB0byBwcmV2aW91cyBmaW5kIGhpdCIKK21zZ3N0ciAiP1x0XHTnp7vliqjliLDkuIrkuIDmrKHmn6Xmib7lkb3kuK0iCisKKyM6IGdpdGs6MzEwMgorbXNnaWQgImZcdFx0U2Nyb2xsIGRpZmYgdmlldyB0byBuZXh0IGZpbGUiCittc2dzdHIgImZcdFx05rua5YqoZGlmZuinhuWbvuWIsOS4i+S4gOS4quaWh+S7tiIKKworIzogZ2l0azozMTAzCisjLCB0Y2wtZm9ybWF0Cittc2dpZCAiPCVzLVM+XHRcdFNlYXJjaCBmb3IgbmV4dCBoaXQgaW4gZGlmZiB2aWV3IgorbXNnc3RyICI8JXMtUz5cdFx05ZyoZGlmZuinhuWbvuS4reafpeaJvuS4i+S4gOatpOWRveS4rSIKKworIzogZ2l0azozMTA0CisjLCB0Y2wtZm9ybWF0Cittc2dpZCAiPCVzLVI+XHRcdFNlYXJjaCBmb3IgcHJldmlvdXMgaGl0IGluIGRpZmYgdmlldyIKK21zZ3N0ciAiPCVzLVI+XHRcdOWcqGRpZmbop4blm77kuK3mn6Xmib7kuIrkuIDmrKHlkb3kuK0iCisKKyM6IGdpdGs6MzEwNQorIywgdGNsLWZvcm1hdAorbXNnaWQgIjwlcy1LUCs+XHRJbmNyZWFzZSBmb250IHNpemUiCittc2dzdHIgIjwlcy1LUCs+XHTlop7lpKflrZfkvZPlpKflsI8iCisKKyM6IGdpdGs6MzEwNgorIywgdGNsLWZvcm1hdAorbXNnaWQgIjwlcy1wbHVzPlx0SW5jcmVhc2UgZm9udCBzaXplIgorbXNnc3RyICI8JXMtcGx1cz5cdOWinuWkp+Wtl+S9k+Wkp+WwjyIKKworIzogZ2l0azozMTA3CisjLCB0Y2wtZm9ybWF0Cittc2dpZCAiPCVzLUtQLT5cdERlY3JlYXNlIGZvbnQgc2l6ZSIKK21zZ3N0ciAiPCVzLUtQLT5cdOWHj+Wwj+Wtl+S9k+Wkp+WwjyIKKworIzogZ2l0azozMTA4CisjLCB0Y2wtZm9ybWF0Cittc2dpZCAiPCVzLW1pbnVzPlx0RGVjcmVhc2UgZm9udCBzaXplIgorbXNnc3RyICI8JXMtbWludXM+XHTlh4/lsI/lrZfkvZPlpKflsI8iCisKKyM6IGdpdGs6MzEwOQorbXNnaWQgIjxGNT5cdFx0VXBkYXRlIgorbXNnc3RyICI8RjU+XHRcdOabtOaWsCIKKworIzogZ2l0azozNTc0IGdpdGs6MzU4MworIywgdGNsLWZvcm1hdAorbXNnaWQgIkVycm9yIGNyZWF0aW5nIHRlbXBvcmFyeSBkaXJlY3RvcnkgJXM6IgorbXNnc3RyICLliJvlu7rkuLTml7bnm67lvZXlh7rplJklc++8miIKKworIzogZ2l0azozNTk2CisjLCB0Y2wtZm9ybWF0Cittc2dpZCAiRXJyb3IgZ2V0dGluZyBcIiVzXCIgZnJvbSAlczoiCittc2dzdHIgIuS7jiVz6I635Y+WXCIlc1wi5Ye66ZSZ77yaIgorCisjOiBnaXRrOjM2NTkKK21zZ2lkICJjb21tYW5kIGZhaWxlZDoiCittc2dzdHIgIuaJp+ihjOWRveS7pOWksei0pe+8miIKKworIzogZ2l0azozODA4Cittc2dpZCAiTm8gc3VjaCBjb21taXQiCittc2dzdHIgIuaXoOatpOaPkOS6pCIKKworIzogZ2l0azozODIyCittc2dpZCAiZ2l0IGd1aSBibGFtZTogY29tbWFuZCBmYWlsZWQ6IgorbXNnc3RyICJnaXQgZ3VpIGJsYW1l77ya5omn6KGM5ZG95Luk5aSx6LSl77yaIgorCisjOiBnaXRrOjM4NTMKKyMsIHRjbC1mb3JtYXQKK21zZ2lkICJDb3VsZG4ndCByZWFkIG1lcmdlIGhlYWQ6ICVzIgorbXNnc3RyICLkuI3og73or7vlj5blkIjlubblpLQobWVyZ2UgaGVhZCnvvJolcyIKKworIzogZ2l0azozODYxCisjLCB0Y2wtZm9ybWF0Cittc2dpZCAiRXJyb3IgcmVhZGluZyBpbmRleDogJXMiCittc2dzdHIgIuivu+WPlue0ouW8leWHuumUme+8miVzIgorCisjOiBnaXRrOjM4ODYKKyMsIHRjbC1mb3JtYXQKK21zZ2lkICJDb3VsZG4ndCBzdGFydCBnaXQgYmxhbWU6ICVzIgorbXNnc3RyICLkuI3og73miafooYxnaXQgYmxhbWXvvJolcyIKKworIzogZ2l0azozODg5IGdpdGs6Njc3OAorbXNnaWQgIlNlYXJjaGluZyIKK21zZ3N0ciAi5pCc57Si5LitIgorCisjOiBnaXRrOjM5MjEKKyMsIHRjbC1mb3JtYXQKK21zZ2lkICJFcnJvciBydW5uaW5nIGdpdCBibGFtZTogJXMiCittc2dzdHIgIui/kOihjGdpdCBibGFtZeWHuumUme+8miVzIgorCisjOiBnaXRrOjM5NDkKKyMsIHRjbC1mb3JtYXQKK21zZ2lkICJUaGF0IGxpbmUgY29tZXMgZnJvbSBjb21taXQgJXMsICB3aGljaCBpcyBub3QgaW4gdGhpcyB2aWV3IgorbXNnc3RyICLmraTooYzmnaXoh6rmj5DkuqQlc++8jOS4jeWcqOatpOinhuWbvuS4rSIKKworIzogZ2l0azozOTYzCittc2dpZCAiRXh0ZXJuYWwgZGlmZiB2aWV3ZXIgZmFpbGVkOiIKK21zZ3N0ciAi5aSW6YOoZGlmZuafpeeci+WZqOWksei0pe+8miIKKworIzogZ2l0azo0MDY3Cittc2dpZCAiQWxsIGZpbGVzIgorbXNnc3RyICLmiYDmnInmlofku7YiCisKKyM6IGdpdGs6NDA5MQorbXNnaWQgIlZpZXciCittc2dzdHIgIuinhuWbviIKKworIzogZ2l0azo0MDk0Cittc2dpZCAiR2l0ayB2aWV3IGRlZmluaXRpb24iCittc2dzdHIgIkdpdGvop4blm77lrprkuYkiCisKKyM6IGdpdGs6NDA5OAorbXNnaWQgIlJlbWVtYmVyIHRoaXMgdmlldyIKK21zZ3N0ciAi6K6w5L2P5q2k6KeG5Zu+IgorCisjOiBnaXRrOjQwOTkKK21zZ2lkICJSZWZlcmVuY2VzIChzcGFjZSBzZXBhcmF0ZWQgbGlzdCk6IgorbXNnc3RyICLlvJXnlKgo56m65qC85YiH5YiG55qE5YiX6KGoKe+8miIKKworIzogZ2l0azo0MTAwCittc2dpZCAiQnJhbmNoZXMgJiB0YWdzOiIKK21zZ3N0ciAi5YiG5pSv5ZKMdGFncyIKKworIzogZ2l0azo0MTAxCittc2dpZCAiQWxsIHJlZnMiCittc2dzdHIgIuaJgOacieW8leeUqCIKKworIzogZ2l0azo0MTAyCittc2dpZCAiQWxsIChsb2NhbCkgYnJhbmNoZXMiCittc2dzdHIgIuaJgOaciSjmnKzlnLAp5YiG5pSvIgorCisjOiBnaXRrOjQxMDMKK21zZ2lkICJBbGwgdGFncyIKK21zZ3N0ciAi5omA5pyJdGFnIgorCisjOiBnaXRrOjQxMDQKK21zZ2lkICJBbGwgcmVtb3RlLXRyYWNraW5nIGJyYW5jaGVzIgorbXNnc3RyICLmiYDmnInov5znqIvot5/ouKrliIbmlK8iCisKKyM6IGdpdGs6NDEwNQorbXNnaWQgIkNvbW1pdCBJbmZvIChyZWd1bGFyIGV4cHJlc3Npb25zKToiCittc2dzdHIgIuaPkOS6pOS/oeaBryAo5q2j5YiZ6KGo6L6+5byPKe+8miIKKworIzogZ2l0azo0MTA2Cittc2dpZCAiQXV0aG9yOiIKK21zZ3N0ciAi5L2c6ICF77yaIgorCisjOiBnaXRrOjQxMDcKK21zZ2lkICJDb21taXR0ZXI6IgorbXNnc3RyICLmj5DkuqTogIXvvJoiCisKKyM6IGdpdGs6NDEwOAorbXNnaWQgIkNvbW1pdCBNZXNzYWdlOiIKK21zZ3N0ciAi5o+Q5Lqk5L+h5oGv77yaIgorCisjOiBnaXRrOjQxMDkKK21zZ2lkICJNYXRjaGVzIGFsbCBDb21taXQgSW5mbyBjcml0ZXJpYSIKK21zZ3N0ciAi5Yy56YWN5omA5pyJ5o+Q5Lqk5L+h5oGv5qCH5YeGIgorCisjOiBnaXRrOjQxMTAKK21zZ2lkICJNYXRjaGVzIG5vIENvbW1pdCBJbmZvIGNyaXRlcmlhIgorbXNnc3RyICLljLnphY3ml6Dmj5DkuqTkv6Hmga/moIflh4YiCisKKyM6IGdpdGs6NDExMQorbXNnaWQgIkNoYW5nZXMgdG8gRmlsZXM6IgorbXNnc3RyICLmlofku7bkv67mlLnliJfooajvvJoiCisKKyM6IGdpdGs6NDExMgorbXNnaWQgIkZpeGVkIFN0cmluZyIKK21zZ3N0ciAi5Zu65a6a5a2X56ym5LiyIgorCisjOiBnaXRrOjQxMTMKK21zZ2lkICJSZWd1bGFyIEV4cHJlc3Npb24iCittc2dzdHIgIuato+WImeihqOi+vuW8j++8miIKKworIzogZ2l0azo0MTE0Cittc2dpZCAiU2VhcmNoIHN0cmluZzoiCittc2dzdHIgIuaQnOe0ouWtl+espuS4su+8miIKKworIzogZ2l0azo0MTE1Cittc2dpZCAiIgorIkNvbW1pdCBEYXRlcyAoXCIyIHdlZWtzIGFnb1wiLCBcIjIwMDktMDMtMTcgMTU6Mjc6MzhcIiwgXCJNYXJjaCAxNywgMjAwOSAiCisiMTU6Mjc6MzhcIik6IgorbXNnc3RyICLmj5DkuqTml6XmnJ8gKFwiMuaYn+acn+S5i+WJjVwiLCBcIjIwMDktMDMtMTcgMTU6Mjc6MzhcIiwgXCI15pyIIDE3LCAyMDA5IDE1OjI3OjM4XCIpOiIKKworIzogZ2l0azo0MTE2Cittc2dpZCAiU2luY2U6IgorbXNnc3RyICLoh6rvvJoiCisKKyM6IGdpdGs6NDExNworbXNnaWQgIlVudGlsOiIKK21zZ3N0ciAi5Yiw77yaIgorCisjOiBnaXRrOjQxMTgKK21zZ2lkICJMaW1pdCBhbmQvb3Igc2tpcCBhIG51bWJlciBvZiByZXZpc2lvbnMgKHBvc2l0aXZlIGludGVnZXIpOiIKK21zZ3N0ciAi6ZmQ5Yi2IOS4lC/miJYg6Lez6L+H5LiA5a6a5pWw6YeP55qE54mI5pysKOato+aVtOaVsCnvvJoiCisKKyM6IGdpdGs6NDExOQorbXNnaWQgIk51bWJlciB0byBzaG93OiIKK21zZ3N0ciAi5pi+56S65pWw6YeP77yaIgorCisjOiBnaXRrOjQxMjAKK21zZ2lkICJOdW1iZXIgdG8gc2tpcDoiCittc2dzdHIgIui3s+i/h+aVsOmHj++8miIKKworIzogZ2l0azo0MTIxCittc2dpZCAiTWlzY2VsbGFuZW91cyBvcHRpb25zOiIKK21zZ3N0ciAi5YW25LuW6YCJ6aG577yaIgorCisjOiBnaXRrOjQxMjIKK21zZ2lkICJTdHJpY3RseSBzb3J0IGJ5IGRhdGUiCittc2dzdHIgIuS4peagvOaMieaXpeacn+aVtOeQhiIKKworIzogZ2l0azo0MTIzCittc2dpZCAiTWFyayBicmFuY2ggc2lkZXMiCittc2dzdHIgIuagh+iusOWIhuaUr+i+ueeVjCIKKworIzogZ2l0azo0MTI0Cittc2dpZCAiTGltaXQgdG8gZmlyc3QgcGFyZW50IgorbXNnc3RyICLpmZDliLbliLDnrKzkuIDkuKrniLbmj5DkuqQiCisKKyM6IGdpdGs6NDEyNQorbXNnaWQgIlNpbXBsZSBoaXN0b3J5IgorbXNnc3RyICLnroDmmJPljoblj7IiCisKKyM6IGdpdGs6NDEyNgorbXNnaWQgIkFkZGl0aW9uYWwgYXJndW1lbnRzIHRvIGdpdCBsb2c6IgorbXNnc3RyICJnaXQgbG9n5ZG95Luk55qE6aKd5aSW5Y+C5pWw77yaIgorCisjOiBnaXRrOjQxMjcKK21zZ2lkICJFbnRlciBmaWxlcyBhbmQgZGlyZWN0b3JpZXMgdG8gaW5jbHVkZSwgb25lIHBlciBsaW5lOiIKK21zZ3N0ciAi6L6T5YWl5paH5Lu25ZKM5paH5Lu25aS55p2l5byV55So77yM5q+P6KGM5LiA5Liq77yaIgorCisjOiBnaXRrOjQxMjgKK21zZ2lkICJDb21tYW5kIHRvIGdlbmVyYXRlIG1vcmUgY29tbWl0cyB0byBpbmNsdWRlOiIKK21zZ3N0ciAi5ZG95Luk5Lqn55Sf5pu05aSa55qE5o+Q5Lqk5p2l5byV55So77yaIgorCisjOiBnaXRrOjQyNTIKK21zZ2lkICJHaXRrOiBlZGl0IHZpZXciCittc2dzdHIgIkdpdGs6IOe8lui+keinhuWbviIKKworIzogZ2l0azo0MjYwCittc2dpZCAiLS0gY3JpdGVyaWEgZm9yIHNlbGVjdGluZyByZXZpc2lvbnMiCittc2dzdHIgIi0tIOeUqOadpemAieaLqeeJiOacrOeahOinhOWImSIKKworIzogZ2l0azo0MjY1Cittc2dpZCAiVmlldyBOYW1lIgorbXNnc3RyICLop4blm77lkI3np7AiCisKKyM6IGdpdGs6NDM0MAorbXNnaWQgIkFwcGx5IChGNSkiCittc2dzdHIgIuW6lOeUqChGNSkiCisKKyM6IGdpdGs6NDM3OAorbXNnaWQgIkVycm9yIGluIGNvbW1pdCBzZWxlY3Rpb24gYXJndW1lbnRzOiIKK21zZ3N0ciAi5o+Q5Lqk6YCJ5oup5Y+C5pWw6ZSZ6K+v77yaIgorCisjOiBnaXRrOjQ0MzMgZ2l0azo0NDg2IGdpdGs6NDk0OCBnaXRrOjQ5NjIgZ2l0azo2MjMyIGdpdGs6MTI1MjQgZ2l0azoxMjUyNQorbXNnaWQgIk5vbmUiCittc2dzdHIgIuaXoCIKKworIzogZ2l0azo1MDQ1IGdpdGs6NTA1MAorbXNnaWQgIkRlc2NlbmRhbnQiCittc2dzdHIgIuWtkOaPkOS6pCIKKworIzogZ2l0azo1MDQ2Cittc2dpZCAiTm90IGRlc2NlbmRhbnQiCittc2dzdHIgIumdnuWtkOaPkOS6pCIKKworIzogZ2l0azo1MDUzIGdpdGs6NTA1OAorbXNnaWQgIkFuY2VzdG9yIgorbXNnc3RyICLniLbmj5DkuqQiCisKKyM6IGdpdGs6NTA1NAorbXNnaWQgIk5vdCBhbmNlc3RvciIKK21zZ3N0ciAi6Z2e54i25o+Q5LqkIgorCisjOiBnaXRrOjUzNDgKK21zZ2lkICJMb2NhbCBjaGFuZ2VzIGNoZWNrZWQgaW4gdG8gaW5kZXggYnV0IG5vdCBjb21taXR0ZWQiCittc2dzdHIgIuW3sua3u+WKoOWIsOe0ouW8leS9huacquaPkOS6pOeahOS/ruaUuSIKKworIzogZ2l0azo1Mzg0Cittc2dpZCAiTG9jYWwgdW5jb21taXR0ZWQgY2hhbmdlcywgbm90IGNoZWNrZWQgaW4gdG8gaW5kZXgiCittc2dzdHIgIuacqua3u+WKoOWIsOe0ouW8leS4lOacquaPkOS6pOeahOS/ruaUuSIKKworIzogZ2l0azo3MTU4Cittc2dpZCAiYW5kIG1hbnkgbW9yZSIKK21zZ3N0ciAi5pu05aSaIgorCisjOiBnaXRrOjcxNjEKK21zZ2lkICJtYW55IgorbXNnc3RyICLlvojlpJoiCisKKyM6IGdpdGs6NzM1MgorbXNnaWQgIlRhZ3M6IgorbXNnc3RyICJUYWdzOiIKKworIzogZ2l0azo3MzY5IGdpdGs6NzM3NSBnaXRrOjg4NTQKK21zZ2lkICJQYXJlbnQiCittc2dzdHIgIueItuiKgueCuSIKKworIzogZ2l0azo3MzgwCittc2dpZCAiQ2hpbGQiCittc2dzdHIgIuWtkOiKgueCuSIKKworIzogZ2l0azo3Mzg5Cittc2dpZCAiQnJhbmNoIgorbXNnc3RyICLliIbmlK8iCisKKyM6IGdpdGs6NzM5MgorbXNnaWQgIkZvbGxvd3MiCittc2dzdHIgIuS5i+WQjueahHRhZyIKKworIzogZ2l0azo3Mzk1Cittc2dpZCAiUHJlY2VkZXMiCittc2dzdHIgIuS5i+WJjeeahHRhZyIKKworIzogZ2l0azo3OTkwCisjLCB0Y2wtZm9ybWF0Cittc2dpZCAiRXJyb3IgZ2V0dGluZyBkaWZmczogJXMiCittc2dzdHIgIuiOt+WPluW3ruW8gumUmeivr++8miVzIgorCisjOiBnaXRrOjg2NzkKK21zZ2lkICJHb3RvOiIKK21zZ3N0ciAi6L2s5Yiw77yaIgorCisjOiBnaXRrOjg3MDAKKyMsIHRjbC1mb3JtYXQKK21zZ2lkICJTaG9ydCBTSEExIGlkICVzIGlzIGFtYmlndW91cyIKK21zZ3N0ciAi55+t5qC85byP55qEU0hBMeaPkOS6pOWPtyVz5LiN5piO56Gu44CB5pyJ5q2n5LmJIgorCisjOiBnaXRrOjg3MDcKKyMsIHRjbC1mb3JtYXQKK21zZ2lkICJSZXZpc2lvbiAlcyBpcyBub3Qga25vd24iCittc2dzdHIgIueJiOacrCVz5pyq55+lIgorCisjOiBnaXRrOjg3MTcKKyMsIHRjbC1mb3JtYXQKK21zZ2lkICJTSEExIGlkICVzIGlzIG5vdCBrbm93biIKK21zZ3N0ciAi5o+Q5Lqk5Y+3KFNIQTEgaWQpJXPmnKrnn6UiCisKKyM6IGdpdGs6ODcxOQorIywgdGNsLWZvcm1hdAorbXNnaWQgIlJldmlzaW9uICVzIGlzIG5vdCBpbiB0aGUgY3VycmVudCB2aWV3IgorbXNnc3RyICLniYjmnKwlc+S4jeWcqOW9k+WJjeinhuWbvuS4rSIKKworIzogZ2l0azo4ODYxIGdpdGs6ODg3NgorbXNnaWQgIkRhdGUiCittc2dzdHIgIuaXpeacnyIKKworIzogZ2l0azo4ODY0Cittc2dpZCAiQ2hpbGRyZW4iCittc2dzdHIgIuWtkOiKgueCuSIKKworIzogZ2l0azo4OTI3CisjLCB0Y2wtZm9ybWF0Cittc2dpZCAiUmVzZXQgJXMgYnJhbmNoIHRvIGhlcmUiCittc2dzdHIgIumHjee9ruWIhuaUryVz5Yiw5q2k5aSEIgorCisjOiBnaXRrOjg5MjkKK21zZ2lkICJEZXRhY2hlZCBoZWFkOiBjYW4ndCByZXNldCIKK21zZ3N0ciAi5YiG56a755qE5aS0KGhlYWQp77ya5LiN6IO96YeN572uKHJlc2V0KSIKKworIzogZ2l0azo5MDM0IGdpdGs6OTA0MAorbXNnaWQgIlNraXBwaW5nIG1lcmdlIGNvbW1pdCAiCittc2dzdHIgIui3s+i/h+WQiOW5tuaPkOS6pCIKKworIzogZ2l0azo5MDQ5IGdpdGs6OTA1NAorbXNnaWQgIkVycm9yIGdldHRpbmcgcGF0Y2ggSUQgZm9yICIKK21zZ3N0ciAi6I635Y+W6KGl5LiBSUTlh7rplJkiCisKKyM6IGdpdGs6OTA1MCBnaXRrOjkwNTUKK21zZ2lkICIgLSBzdG9wcGluZ1xuIgorbXNnc3RyICIg4oCUIOWBnOatouS4rVxuIgorCisjOiBnaXRrOjkwNjAgZ2l0azo5MDYzIGdpdGs6OTA3MSBnaXRrOjkwODUgZ2l0azo5MDk0Cittc2dpZCAiQ29tbWl0ICIKK21zZ3N0ciAi5o+Q5LqkIgorCisjOiBnaXRrOjkwNjQKK21zZ2lkICIiCisiIGlzIHRoZSBzYW1lIHBhdGNoIGFzXG4iCisiICAgICAgICIKK21zZ3N0ciAiIOaYr+ebuOWQjOeahOihpeS4gShwYXRjaClcbiAgICAgICAiCisKKyM6IGdpdGs6OTA3MgorbXNnaWQgIiIKKyIgZGlmZmVycyBmcm9tXG4iCisiICAgICAgICIKK21zZ3N0ciAiIOW3ruW8guadpeiHqlxuICAgICAgICIKKworIzogZ2l0azo5MDc0Cittc2dpZCAiIgorIkRpZmYgb2YgY29tbWl0czpcbiIKKyJcbiIKK21zZ3N0ciAi5o+Q5Lqk55qE5beu5byCKERpZmYp77yaXG5cbiIKKworIzogZ2l0azo5MDg2IGdpdGs6OTA5NQorIywgdGNsLWZvcm1hdAorbXNnaWQgIiBoYXMgJXMgY2hpbGRyZW4gLSBzdG9wcGluZ1xuIgorbXNnc3RyICLmnIklc+WtkOiKgueCuSDigJQg5YGc5q2i5LitXG4iCisKKyM6IGdpdGs6OTExNAorIywgdGNsLWZvcm1hdAorbXNnaWQgIkVycm9yIHdyaXRpbmcgY29tbWl0IHRvIGZpbGU6ICVzIgorbXNnc3RyICLlhpnlhaXmj5DkuqTliLDmlofku7blh7rplJnvvJolcyIKKworIzogZ2l0azo5MTIwCisjLCB0Y2wtZm9ybWF0Cittc2dpZCAiRXJyb3IgZGlmZmluZyBjb21taXRzOiAlcyIKK21zZ3N0ciAi5q+U6L6D5o+Q5Lqk5beu5byC5Ye66ZSZ77yaJXMiCisKKyM6IGdpdGs6OTE2NgorbXNnaWQgIlRvcCIKK21zZ3N0ciAi6aG26YOoIgorCisjOiBnaXRrOjkxNjcKK21zZ2lkICJGcm9tIgorbXNnc3RyICLku44iCisKKyM6IGdpdGs6OTE3MgorbXNnaWQgIlRvIgorbXNnc3RyICLliLAiCisKKyM6IGdpdGs6OTE5NgorbXNnaWQgIkdlbmVyYXRlIHBhdGNoIgorbXNnc3RyICLnlJ/miJDooaXkuIEocGF0Y2gpIgorCisjOiBnaXRrOjkxOTgKK21zZ2lkICJGcm9tOiIKK21zZ3N0ciAi5LuO77yaIgorCisjOiBnaXRrOjkyMDcKK21zZ2lkICJUbzoiCittc2dzdHIgIuWIsO+8miIKKworIzogZ2l0azo5MjE2Cittc2dpZCAiUmV2ZXJzZSIKK21zZ3N0ciAi5Y+N5ZCRKFJldmVyc2UpIgorCisjOiBnaXRrOjkyMTggZ2l0azo5NDI4Cittc2dpZCAiT3V0cHV0IGZpbGU6IgorbXNnc3RyICLovpPlh7rmlofku7bvvJoiCisKKyM6IGdpdGs6OTIyNAorbXNnaWQgIkdlbmVyYXRlIgorbXNnc3RyICLnlJ/miJAiCisKKyM6IGdpdGs6OTI2MgorbXNnaWQgIkVycm9yIGNyZWF0aW5nIHBhdGNoOiIKK21zZ3N0ciAi5Yib5bu66KGl5LiBKHBhdGNoKeWHuumUme+8miIKKworIzogZ2l0azo5Mjg1IGdpdGs6OTQxNiBnaXRrOjk1MDQKK21zZ2lkICJJRDoiCittc2dzdHIgIklEOiIKKworIzogZ2l0azo5Mjk0Cittc2dpZCAiVGFnIG5hbWU6IgorbXNnc3RyICJUYWflkI3np7DvvJoiCisKKyM6IGdpdGs6OTI5NworbXNnaWQgIlRhZyBtZXNzYWdlIGlzIG9wdGlvbmFsIgorbXNnc3RyICJUYWfkv6Hmga/mmK/lj6/pgInnmoQiCisKKyM6IGdpdGs6OTI5OQorbXNnaWQgIlRhZyBtZXNzYWdlOiIKK21zZ3N0ciAiVGFn5L+h5oGv77yaIgorCisjOiBnaXRrOjkzMDMgZ2l0azo5NDc0Cittc2dpZCAiQ3JlYXRlIgorbXNnc3RyICLliJvlu7oiCisKKyM6IGdpdGs6OTMyMQorbXNnaWQgIk5vIHRhZyBuYW1lIHNwZWNpZmllZCIKK21zZ3N0ciAi5pyq5oyH5a6adGFn5ZCN56ewIgorCisjOiBnaXRrOjkzMjUKKyMsIHRjbC1mb3JtYXQKK21zZ2lkICJUYWcgXCIlc1wiIGFscmVhZHkgZXhpc3RzIgorbXNnc3RyICJUYWdcIiVzXCLlt7Lnu4/lrZjlnKgiCisKKyM6IGdpdGs6OTMzNQorbXNnaWQgIkVycm9yIGNyZWF0aW5nIHRhZzoiCittc2dzdHIgIuWIm+W7unRhZ+WHuumUme+8miIKKworIzogZ2l0azo5NDI1Cittc2dpZCAiQ29tbWFuZDoiCittc2dzdHIgIuWRveS7pO+8miIKKworIzogZ2l0azo5NDMzCittc2dpZCAiV3JpdGUiCittc2dzdHIgIuWGmeWFpSIKKworIzogZ2l0azo5NDUxCittc2dpZCAiRXJyb3Igd3JpdGluZyBjb21taXQ6IgorbXNnc3RyICLlhpnlhaXmj5DkuqTlh7rplJnvvJoiCisKKyM6IGdpdGs6OTQ3MworbXNnaWQgIkNyZWF0ZSBicmFuY2giCittc2dzdHIgIuWIm+W7uuWIhuaUryIKKworIzogZ2l0azo5NDg5CisjLCB0Y2wtZm9ybWF0Cittc2dpZCAiUmVuYW1lIGJyYW5jaCAlcyIKK21zZ3N0ciAi6YeN5ZG95ZCN5YiG5pSvJXMiCisKKyM6IGdpdGs6OTQ5MAorbXNnaWQgIlJlbmFtZSIKK21zZ3N0ciAi6YeN5ZG95ZCNIgorCisjOiBnaXRrOjk1MTQKK21zZ2lkICJOYW1lOiIKK21zZ3N0ciAi5ZCN56ew77yaIgorCisjOiBnaXRrOjk1MzgKK21zZ2lkICJQbGVhc2Ugc3BlY2lmeSBhIG5hbWUgZm9yIHRoZSBuZXcgYnJhbmNoIgorbXNnc3RyICLor7fmjIflrprmlrDliIbmlK/nmoTlkI3np7AiCisKKyM6IGdpdGs6OTU0MworIywgdGNsLWZvcm1hdAorbXNnaWQgIkJyYW5jaCAnJXMnIGFscmVhZHkgZXhpc3RzLiBPdmVyd3JpdGU/IgorbXNnc3RyICLliIbmlK9cIiVzXCLlt7Lnu4/lrZjlnKjjgILopobnm5blroPvvJ8iCisKKyM6IGdpdGs6OTU4NworbXNnaWQgIlBsZWFzZSBzcGVjaWZ5IGEgbmV3IG5hbWUgZm9yIHRoZSBicmFuY2giCittc2dzdHIgIuivt+mHjeaWsOaMh+WumuaWsOWIhuaUr+eahOWQjeensCIKKworIzogZ2l0azo5NjUwCisjLCB0Y2wtZm9ybWF0Cittc2dpZCAiQ29tbWl0ICVzIGlzIGFscmVhZHkgaW5jbHVkZWQgaW4gYnJhbmNoICVzIC0tIHJlYWxseSByZS1hcHBseSBpdD8iCittc2dzdHIgIuaPkOS6pCVz5bey57uP5a2Y5Zyo5LqO5YiG5pSvJXPjgILnoa7lrprph43mlrDlupTnlKjlroPvvJ8iCisKKyM6IGdpdGs6OTY1NQorbXNnaWQgIkNoZXJyeS1waWNraW5nIgorbXNnc3RyICLmiZPooaXkuIHkuK0oQ2hlcnJ5LXBpY2tpbmcpIgorCisjOiBnaXRrOjk2NjQKKyMsIHRjbC1mb3JtYXQKK21zZ2lkICIiCisiQ2hlcnJ5LXBpY2sgZmFpbGVkIGJlY2F1c2Ugb2YgbG9jYWwgY2hhbmdlcyB0byBmaWxlICclcycuXG4iCisiUGxlYXNlIGNvbW1pdCwgcmVzZXQgb3Igc3Rhc2ggeW91ciBjaGFuZ2VzIGFuZCB0cnkgYWdhaW4uIgorbXNnc3RyICLmiZPooaXkuIEoQ2hlcnJ5LXBpY2sp5aSx6LSl77yM5Zug5Li65pys5Zyw5L+u5pS55LqG5paH5Lu2XCIlc1wi44CCXG7or7fmj5DkuqQoY29tbWl0KeOAgemHjee9rihyZXNldCnmiJbmmoLlrZgoc3Rhc2gp5L+u5pS55ZCO6YeN6K+V44CCIgorCisjOiBnaXRrOjk2NzAKK21zZ2lkICIiCisiQ2hlcnJ5LXBpY2sgZmFpbGVkIGJlY2F1c2Ugb2YgbWVyZ2UgY29uZmxpY3QuXG4iCisiRG8geW91IHdpc2ggdG8gcnVuIGdpdCBjaXRvb2wgdG8gcmVzb2x2ZSBpdD8iCittc2dzdHIgIuaJk+ihpeS4gShDaGVycnktcGljaynlpLHotKXlm6DkuLrlkIjlubblhrLnqoHjgIJcbuS9oOaYr+WQpuW4jOacm+i/kOihjGdpdCBjaXRvb2wg5p2l6Kej5Yaz5Yay56qB77yfIgorCisjOiBnaXRrOjk2ODYgZ2l0azo5NzQ0Cittc2dpZCAiTm8gY2hhbmdlcyBjb21taXR0ZWQiCittc2dzdHIgIuaXoOW3sue7j+aPkOS6pOeahOS/ruaUuSIKKworIzogZ2l0azo5NzEzCisjLCB0Y2wtZm9ybWF0Cittc2dpZCAiQ29tbWl0ICVzIGlzIG5vdCBpbmNsdWRlZCBpbiBicmFuY2ggJXMgLS0gcmVhbGx5IHJldmVydCBpdD8iCittc2dzdHIgIuaPkOS6pCVz5LiN5YyF5ZCr5Zyo5YiG5pSvJXPkuK3vvIznoa7orqTlm57mu5oocmV2ZXJ0KeWug++8nyIKKworIzogZ2l0azo5NzE4Cittc2dpZCAiUmV2ZXJ0aW5nIgorbXNnc3RyICLlm57mu5rkuK0oUmV2ZXJ0aW5nKSIKKworIzogZ2l0azo5NzI2CisjLCB0Y2wtZm9ybWF0Cittc2dpZCAiIgorIlJldmVydCBmYWlsZWQgYmVjYXVzZSBvZiBsb2NhbCBjaGFuZ2VzIHRvIHRoZSBmb2xsb3dpbmcgZmlsZXM6JXMgUGxlYXNlICIKKyJjb21taXQsIHJlc2V0IG9yIHN0YXNoICB5b3VyIGNoYW5nZXMgYW5kIHRyeSBhZ2Fpbi4iCittc2dzdHIgIuWbnua7mihyZXZlcnQp5aSx6LSl77yM5Zug5Li65aaC5LiL55qE5pys5Zyw5paH5Lu25L+u5pS577yaJXNcbuivt+aPkOS6pChjb21taXQp44CB6YeN572uKHJlc2V0KeaIluiAheaaguWtmChzdGFzaCnmlLnlj5jlkI7ph43or5XjgIIiCisKKyM6IGdpdGs6OTczMAorbXNnaWQgIiIKKyJSZXZlcnQgZmFpbGVkIGJlY2F1c2Ugb2YgbWVyZ2UgY29uZmxpY3QuXG4iCisiIERvIHlvdSB3aXNoIHRvIHJ1biBnaXQgY2l0b29sIHRvIHJlc29sdmUgaXQ/IgorbXNnc3RyICLlm57mu5oocmV2ZXJ0KeWksei0pe+8jOWboOS4uuWQiOW5tuWGsueqgeOAglxu5L2g5piv5ZCm5biM5pyb6L+Q6KGMZ2l0IGNpdG9vbOadpeino+WGs+WGsueqge+8nyIKKworIzogZ2l0azo5NzczCittc2dpZCAiQ29uZmlybSByZXNldCIKK21zZ3N0ciAi56Gu6K6k6YeN572uKHJlc2V0KSIKKworIzogZ2l0azo5Nzc1CisjLCB0Y2wtZm9ybWF0Cittc2dpZCAiUmVzZXQgYnJhbmNoICVzIHRvICVzPyIKK21zZ3N0ciAi6YeN572uKHJlc2V0KeWIhuaUryVz5YiwJXPvvJ8iCisKKyM6IGdpdGs6OTc3NworbXNnaWQgIlJlc2V0IHR5cGU6IgorbXNnc3RyICLph43nva4ocmVzZXQp57G75Z6L77yaIgorCisjOiBnaXRrOjk3ODAKK21zZ2lkICJTb2Z0OiBMZWF2ZSB3b3JraW5nIHRyZWUgYW5kIGluZGV4IHVudG91Y2hlZCIKK21zZ3N0ciAi6L2v5oCn77ya56a75byA5bel5L2c5qCR77yM57Si5byV5pyq5pS55Y+YIgorCisjOiBnaXRrOjk3ODMKK21zZ2lkICJNaXhlZDogTGVhdmUgd29ya2luZyB0cmVlIHVudG91Y2hlZCwgcmVzZXQgaW5kZXgiCittc2dzdHIgIua3t+WQiO+8muemu+W8gOW3peS9nOagkSjmnKrmlLnlj5gp77yM57Si5byV6YeN572uIgorCisjOiBnaXRrOjk3ODYKK21zZ2lkICIiCisiSGFyZDogUmVzZXQgd29ya2luZyB0cmVlIGFuZCBpbmRleFxuIgorIihkaXNjYXJkIEFMTCBsb2NhbCBjaGFuZ2VzKSIKK21zZ3N0ciAi56Gs5oCn77ya6YeN572u5bel5L2c5qCR5ZKM57Si5byVXG4o5Lii5byD5omA5pyJ55qE5pys5Zyw5L+u5pS5KSIKKworIzogZ2l0azo5ODAzCittc2dpZCAiUmVzZXR0aW5nIgorbXNnc3RyICLph43nva7kuK0oUmVzZXR0aW5nKSIKKworIzogZ2l0azo5ODc2CisjLCB0Y2wtZm9ybWF0Cittc2dpZCAiQSBsb2NhbCBicmFuY2ggbmFtZWQgJXMgZXhpc3RzIGFscmVhZHkiCittc2dzdHIgIuacrOWcsOWIhuaUryVz5bey57uP5a2Y5ZyoIgorCisjOiBnaXRrOjk4ODQKK21zZ2lkICJDaGVja2luZyBvdXQiCittc2dzdHIgIuajgOWHuuS4rShDaGVja2luZyBvdXQpIgorCisjOiBnaXRrOjk5NDMKK21zZ2lkICJDYW5ub3QgZGVsZXRlIHRoZSBjdXJyZW50bHkgY2hlY2tlZC1vdXQgYnJhbmNoIgorbXNnc3RyICLkuI3og73liKDpmaTlvZPliY3mo4Dlh7ooY2hlY2tvdXQp5YiG5pSvIgorCisjOiBnaXRrOjk5NDkKKyMsIHRjbC1mb3JtYXQKK21zZ2lkICIiCisiVGhlIGNvbW1pdHMgb24gYnJhbmNoICVzIGFyZW4ndCBvbiBhbnkgb3RoZXIgYnJhbmNoLlxuIgorIlJlYWxseSBkZWxldGUgYnJhbmNoICVzPyIKK21zZ3N0ciAi5Zyo5YiG5pSvJXPkuIrnmoTmj5DkuqTkuI3lnKjlhbbku5bku7vkvZXliIbmlK/kuIrjgIJcbuehruiupOWIoOmZpOWIhuaUryVz77yfIgorCisjOiBnaXRrOjk5ODAKKyMsIHRjbC1mb3JtYXQKK21zZ2lkICJUYWdzIGFuZCBoZWFkczogJXMiCittc2dzdHIgIlRhZ3PlkozlpLTmjIfpkogoaGVhZHMp77yaJXMiCisKKyM6IGdpdGs6OTk5NworbXNnaWQgIkZpbHRlciIKK21zZ3N0ciAi6L+H5ruk5ZmoIgorCisjOiBnaXRrOjEwMjkzCittc2dpZCAiIgorIkVycm9yIHJlYWRpbmcgY29tbWl0IHRvcG9sb2d5IGluZm9ybWF0aW9uOyBicmFuY2ggYW5kIHByZWNlZGluZy9mb2xsb3dpbmcgIgorInRhZyBpbmZvcm1hdGlvbiB3aWxsIGJlIGluY29tcGxldGUuIgorbXNnc3RyICLor7vlj5bmj5DkuqTmi5PmiZHkv6Hmga/lh7rplJnvvJvliIbmlK/lkozkuYvliY0v5LmL5ZCO55qEdGFn5L+h5oGv5bCG5LiN6IO95a6M5oiQ44CCIgorCisjOiBnaXRrOjExMjcwCittc2dpZCAiVGFnIgorbXNnc3RyICLmoIfnrb4oVGFnKSIKKworIzogZ2l0azoxMTI3NAorbXNnaWQgIklkIgorbXNnc3RyICJJZCIKKworIzogZ2l0azoxMTM1NworbXNnaWQgIkdpdGsgZm9udCBjaG9vc2VyIgorbXNnc3RyICJHaXRr5a2X5L2T6YCJ5oupIgorCisjOiBnaXRrOjExMzc0Cittc2dpZCAiQiIKK21zZ3N0ciAi57KX5L2TIgorCisjOiBnaXRrOjExMzc3Cittc2dpZCAiSSIKK21zZ3N0ciAi5pac5L2TIgorCisjOiBnaXRrOjExNDk1Cittc2dpZCAiQ29tbWl0IGxpc3QgZGlzcGxheSBvcHRpb25zIgorbXNnc3RyICLmj5DkuqTliJfooajlsZXnpLrpgInpobkiCisKKyM6IGdpdGs6MTE0OTgKK21zZ2lkICJNYXhpbXVtIGdyYXBoIHdpZHRoIChsaW5lcykiCittc2dzdHIgIuacgOWkp+WbvuWuveW6pijooYzmlbApIgorCisjOiBnaXRrOjExNTAyCisjLCBuby10Y2wtZm9ybWF0Cittc2dpZCAiTWF4aW11bSBncmFwaCB3aWR0aCAoJSBvZiBwYW5lKSIKK21zZ3N0ciAi5pyA5aSn5Zu+5a695bqmKCXnqpflj6Pnmb7liIbmr5QpIgorCisjOiBnaXRrOjExNTA1Cittc2dpZCAiU2hvdyBsb2NhbCBjaGFuZ2VzIgorbXNnc3RyICLmmL7npLrmnKzlnLDkv67mlLkiCisKKyM6IGdpdGs6MTE1MDgKK21zZ2lkICJBdXRvLXNlbGVjdCBTSEExIChsZW5ndGgpIgorbXNnc3RyICLoh6rliqjpgInmi6lTSEExKOmVv+W6pikiCisKKyM6IGdpdGs6MTE1MTIKK21zZ2lkICJIaWRlIHJlbW90ZSByZWZzIgorbXNnc3RyICLpmpDol4/ov5znqIvlvJXnlKgiCisKKyM6IGdpdGs6MTE1MTYKK21zZ2lkICJEaWZmIGRpc3BsYXkgb3B0aW9ucyIKK21zZ3N0ciAi5beu5byCKERpZmYp5bGV56S66YCJ6aG5IgorCisjOiBnaXRrOjExNTE4Cittc2dpZCAiVGFiIHNwYWNpbmciCittc2dzdHIgIuWItuihqOespuWuveW6piIKKworIzogZ2l0azoxMTUyMQorbXNnaWQgIkRpc3BsYXkgbmVhcmJ5IHRhZ3MvaGVhZHMiCittc2dzdHIgIuaYvuekuuS4tOi/keeahHRhZ3MvaGVhZHMiCisKKyM6IGdpdGs6MTE1MjQKK21zZ2lkICJNYXhpbXVtICMgdGFncy9oZWFkcyB0byBzaG93IgorbXNnc3RyICLmnIDlpKd0YWdzL2hlYWRz5bGV56S65pWw6YePIgorCisjOiBnaXRrOjExNTI3Cittc2dpZCAiTGltaXQgZGlmZnMgdG8gbGlzdGVkIHBhdGhzIgorbXNnc3RyICJkaWZm5Lit5YiX5Ye65paH5Lu26ZmQ5Yi2IgorCisjOiBnaXRrOjExNTMwCittc2dpZCAiU3VwcG9ydCBwZXItZmlsZSBlbmNvZGluZ3MiCittc2dzdHIgIuWNleeLrOaWh+S7tue8lueggeaUr+aMgSIKKworIzogZ2l0azoxMTUzNiBnaXRrOjExNjgzCittc2dpZCAiRXh0ZXJuYWwgZGlmZiB0b29sIgorbXNnc3RyICLlpJbpg6jlt67lvIIoZGlmZinlt6XlhbciCisKKyM6IGdpdGs6MTE1MzcKK21zZ2lkICJDaG9vc2UuLi4iCittc2dzdHIgIumAieaLqS4uLiIKKworIzogZ2l0azoxMTU0MgorbXNnaWQgIkdlbmVyYWwgb3B0aW9ucyIKK21zZ3N0ciAi5bi46KeE6YCJ6aG5IgorCisjOiBnaXRrOjExNTQ1Cittc2dpZCAiVXNlIHRoZW1lZCB3aWRnZXRzIgorbXNnc3RyICLkvb/nlKjkuLvpopjlsI/pg6jku7YiCisKKyM6IGdpdGs6MTE1NDcKK21zZ2lkICIoY2hhbmdlIHJlcXVpcmVzIHJlc3RhcnQpIgorbXNnc3RyICIo6ZyA6YeN5ZCv55Sf5pWIKSIKKworIzogZ2l0azoxMTU0OQorbXNnaWQgIihjdXJyZW50bHkgdW5hdmFpbGFibGUpIgorbXNnc3RyICIo5b2T5YmN5LiN5Y+v55SoKSIKKworIzogZ2l0azoxMTU2MAorbXNnaWQgIkNvbG9yczogcHJlc3MgdG8gY2hvb3NlIgorbXNnc3RyICLpopzoibLvvJrngrnlh7vmnaXpgInmi6kiCisKKyM6IGdpdGs6MTE1NjMKK21zZ2lkICJJbnRlcmZhY2UiCittc2dzdHIgIueVjOmdoiIKKworIzogZ2l0azoxMTU2NAorbXNnaWQgImludGVyZmFjZSIKK21zZ3N0ciAi55WM6Z2iIgorCisjOiBnaXRrOjExNTY3Cittc2dpZCAiQmFja2dyb3VuZCIKK21zZ3N0ciAi6IOM5pmvIgorCisjOiBnaXRrOjExNTY4IGdpdGs6MTE1OTgKK21zZ2lkICJiYWNrZ3JvdW5kIgorbXNnc3RyICLog4zmma8iCisKKyM6IGdpdGs6MTE1NzEKK21zZ2lkICJGb3JlZ3JvdW5kIgorbXNnc3RyICLliY3mma8iCisKKyM6IGdpdGs6MTE1NzIKK21zZ2lkICJmb3JlZ3JvdW5kIgorbXNnc3RyICLliY3mma8iCisKKyM6IGdpdGs6MTE1NzUKK21zZ2lkICJEaWZmOiBvbGQgbGluZXMiCittc2dzdHIgIuW3ruW8gihEaWZmKe+8muiAgeS7o+eggeihjCIKKworIzogZ2l0azoxMTU3NgorbXNnaWQgImRpZmYgb2xkIGxpbmVzIgorbXNnc3RyICLlt67lvIIoZGlmZinogIHku6PnoIHooYwiCisKKyM6IGdpdGs6MTE1ODAKK21zZ2lkICJEaWZmOiBuZXcgbGluZXMiCittc2dzdHIgIuW3ruW8gihEaWZmKe+8muaWsOS7o+eggeihjCIKKworIzogZ2l0azoxMTU4MQorbXNnaWQgImRpZmYgbmV3IGxpbmVzIgorbXNnc3RyICLlt67lvIIoZGlmZinmlrDku6PnoIHooYwiCisKKyM6IGdpdGs6MTE1ODUKK21zZ2lkICJEaWZmOiBodW5rIGhlYWRlciIKK21zZ3N0ciAi5beu5byCKERpZmYp77ya6KGl5LiB54mH5q615aS05L+h5oGvIgorCisjOiBnaXRrOjExNTg3Cittc2dpZCAiZGlmZiBodW5rIGhlYWRlciIKK21zZ3N0ciAi5beu5byCKGRpZmYp6KGl5LiB54mH5q615aS05L+h5oGvIgorCisjOiBnaXRrOjExNTkxCittc2dpZCAiTWFya2VkIGxpbmUgYmciCittc2dzdHIgIuW3suagh+iusOS7o+eggeihjOiDjOaZryIKKworIzogZ2l0azoxMTU5MworbXNnaWQgIm1hcmtlZCBsaW5lIGJhY2tncm91bmQiCittc2dzdHIgIuW3suagh+iusOS7o+eggeihjOiDjOaZryIKKworIzogZ2l0azoxMTU5NworbXNnaWQgIlNlbGVjdCBiZyIKK21zZ3N0ciAi6YCJ5oup6IOM5pmvIgorCisjOiBnaXRrOjExNjA2Cittc2dpZCAiRm9udHM6IHByZXNzIHRvIGNob29zZSIKK21zZ3N0ciAi5a2X5L2T77ya54K55Ye75p2l6YCJ5oupIgorCisjOiBnaXRrOjExNjA4Cittc2dpZCAiTWFpbiBmb250IgorbXNnc3RyICLkuLvlrZfkvZMiCisKKyM6IGdpdGs6MTE2MDkKK21zZ2lkICJEaWZmIGRpc3BsYXkgZm9udCIKK21zZ3N0ciAi5beu5byCKERpZmYp5pi+56S65a2X5L2TIgorCisjOiBnaXRrOjExNjEwCittc2dpZCAiVXNlciBpbnRlcmZhY2UgZm9udCIKK21zZ3N0ciAi55So5oi355WM6Z2i5a2X5L2TIgorCisjOiBnaXRrOjExNjMyCittc2dpZCAiR2l0ayBwcmVmZXJlbmNlcyIKK21zZ3N0ciAiR2l0a+WBj+Wlveiuvue9riIKKworIzogZ2l0azoxMTY0MQorbXNnaWQgIkdlbmVyYWwiCittc2dzdHIgIuW4uOinhCIKKworIzogZ2l0azoxMTY0MgorbXNnaWQgIkNvbG9ycyIKK21zZ3N0ciAi6aKc6ImyIgorCisjOiBnaXRrOjExNjQzCittc2dpZCAiRm9udHMiCittc2dzdHIgIuWtl+S9kyIKKworIzogZ2l0azoxMTY5MworIywgdGNsLWZvcm1hdAorbXNnaWQgIkdpdGs6IGNob29zZSBjb2xvciBmb3IgJXMiCittc2dzdHIgIkdpdGvvvJrpgInmi6npopzoibLnlKjkuo4lcyIKKworIzogZ2l0azoxMjIwNgorbXNnaWQgIiIKKyJTb3JyeSwgZ2l0ayBjYW5ub3QgcnVuIHdpdGggdGhpcyB2ZXJzaW9uIG9mIFRjbC9Uay5cbiIKKyIgR2l0ayByZXF1aXJlcyBhdCBsZWFzdCBUY2wvVGsgOC40LiIKK21zZ3N0ciAi5a+55LiN6LW377yMZ2l0a+S4jeiDvei/kOihjOWcqOW9k+WJjeeJiOacrOeahFRjbC9Ua+S4reOAglxuR2l0a+i/kOihjOmcgOimgeacgOS9jueJiOacrOS4ulRjbC9UazguNOOAgiIKKworIzogZ2l0azoxMjQxNgorbXNnaWQgIkNhbm5vdCBmaW5kIGEgZ2l0IHJlcG9zaXRvcnkgaGVyZS4iCittc2dzdHIgIuWcqOatpOS9jee9ruacquWPkeeOsGdpdOS7k+W6k+OAgiIKKworIzogZ2l0azoxMjQ2MworIywgdGNsLWZvcm1hdAorbXNnaWQgIkFtYmlndW91cyBhcmd1bWVudCAnJXMnOiBib3RoIHJldmlzaW9uIGFuZCBmaWxlbmFtZSIKK21zZ3N0ciAi5LiN5piO56Gu5pyJ5q2n5LmJ55qE5Y+C5pWwXCIlc1wi77ya54mI5pys5ZKM5paH5Lu25ZCN56ewIgorCisjOiBnaXRrOjEyNDc1Cittc2dpZCAiQmFkIGFyZ3VtZW50cyB0byBnaXRrOiIKK21zZ3N0ciAi6L+Q6KGMZ2l0a+WPguaVsOmUmeivr++8miIKZGlmZiAtLWdpdCBhL2dpdHdlYi9naXR3ZWIucGVybCBiL2dpdHdlYi9naXR3ZWIucGVybAppbmRleCA3ZmVmMTlmLi4wZjg1N2Q3IDEwMDc1NQotLS0gYS9naXR3ZWIvZ2l0d2ViLnBlcmwKKysrIGIvZ2l0d2ViL2dpdHdlYi5wZXJsCkBAIC0xNjU3LDE1ICsxNjU3LDE1IEBACiAJbXkgJGNudHJsID0gc2hpZnQ7CiAJbXkgJW9wdHMgPSBAXzsKIAlteSAlZXMgPSAoICMgY2hhcmFjdGVyIGVzY2FwZSBjb2RlcywgYWthIGVzY2FwZSBzZXF1ZW5jZXMKLQkJIlx0IiA9PiAnXHQnLCAgICMgdGFiICAgICAgICAgICAgKEhUKQotCQkiXG4iID0+ICdcbicsICAgIyBsaW5lIGZlZWQgICAgICAoTEYpCi0JCSJcciIgPT4gJ1xyJywgICAjIGNhcnJpZ2UgcmV0dXJuIChDUikKLQkJIlxmIiA9PiAnXGYnLCAgICMgZm9ybSBmZWVkICAgICAgKEZGKQotCQkiXGIiID0+ICdcYicsICAgIyBiYWNrc3BhY2UgICAgICAoQlMpCi0JCSJcYSIgPT4gJ1xhJywgICAjIGFsYXJtIChiZWxsKSAgIChCRUwpCi0JCSJcZSIgPT4gJ1xlJywgICAjIGVzY2FwZSAgICAgICAgIChFU0MpCi0JCSJcMDEzIiA9PiAnXHYnLCAjIHZlcnRpY2FsIHRhYiAgIChWVCkKLQkJIlwwMDAiID0+ICdcMCcsICMgbnVsIGNoYXJhY3RlciAgKE5VTCkKKwkJIlx0IiA9PiAnXHQnLCAgICMgdGFiICAgICAgICAgICAgIChIVCkKKwkJIlxuIiA9PiAnXG4nLCAgICMgbGluZSBmZWVkICAgICAgIChMRikKKwkJIlxyIiA9PiAnXHInLCAgICMgY2FycmlhZ2UgcmV0dXJuIChDUikKKwkJIlxmIiA9PiAnXGYnLCAgICMgZm9ybSBmZWVkICAgICAgIChGRikKKwkJIlxiIiA9PiAnXGInLCAgICMgYmFja3NwYWNlICAgICAgIChCUykKKwkJIlxhIiA9PiAnXGEnLCAgICMgYWxhcm0gKGJlbGwpICAgIChCRUwpCisJCSJcZSIgPT4gJ1xlJywgICAjIGVzY2FwZSAgICAgICAgICAoRVNDKQorCQkiXDAxMyIgPT4gJ1x2JywgIyB2ZXJ0aWNhbCB0YWIgICAgKFZUKQorCQkiXDAwMCIgPT4gJ1wwJywgIyBudWwgY2hhcmFjdGVyICAgKE5VTCkKIAkpOwogCW15ICRjaHIgPSAoIChleGlzdHMgJGVzeyRjbnRybH0pCiAJCSAgICA/ICRlc3skY250cmx9CkBAIC00MDQ4LDcgKzQwNDgsNyBAQAogCiAJCQkkaHJlZl9wYXJhbXN7J2V4dHJhX29wdGlvbnMnfSA9IHVuZGVmOwogCQkJJGhyZWZfcGFyYW1zeydhY3Rpb24nfSA9ICR0eXBlOwotCQkJJGxpbmtfYXR0cnsnLWhyZWYnfSA9IGhyZWYoJWhyZWZfcGFyYW1zKTsKKwkJCSRsaW5rX2F0dHJ7Jy1ocmVmJ30gPSBlc2NfYXR0cihocmVmKCVocmVmX3BhcmFtcykpOwogCQkJcHJpbnQgIjxsaW5rICIuCiAJCQkgICAgICAicmVsPVwiJGxpbmtfYXR0cnsnLXJlbCd9XCIgIi4KIAkJCSAgICAgICJ0aXRsZT1cIiRsaW5rX2F0dHJ7Jy10aXRsZSd9XCIgIi4KQEAgLTQwNTcsNyArNDA1Nyw3IEBACiAJCQkgICAgICAiLz5cbiI7CiAKIAkJCSRocmVmX3BhcmFtc3snZXh0cmFfb3B0aW9ucyd9ID0gJy0tbm8tbWVyZ2VzJzsKLQkJCSRsaW5rX2F0dHJ7Jy1ocmVmJ30gPSBocmVmKCVocmVmX3BhcmFtcyk7CisJCQkkbGlua19hdHRyeyctaHJlZid9ID0gZXNjX2F0dHIoaHJlZiglaHJlZl9wYXJhbXMpKTsKIAkJCSRsaW5rX2F0dHJ7Jy10aXRsZSd9IC49ICcgKG5vIG1lcmdlcyknOwogCQkJcHJpbnQgIjxsaW5rICIuCiAJCQkgICAgICAicmVsPVwiJGxpbmtfYXR0cnsnLXJlbCd9XCIgIi4KQEAgLTQwNzAsMTAgKzQwNzAsMTIgQEAKIAl9IGVsc2UgewogCQlwcmludGYoJzxsaW5rIHJlbD0iYWx0ZXJuYXRlIiB0aXRsZT0iJXMgcHJvamVjdHMgbGlzdCIgJy4KIAkJICAgICAgICdocmVmPSIlcyIgdHlwZT0idGV4dC9wbGFpbjsgY2hhcnNldD11dGYtOCIgLz4nLiJcbiIsCi0JCSAgICAgICBlc2NfYXR0cigkc2l0ZV9uYW1lKSwgaHJlZihwcm9qZWN0PT51bmRlZiwgYWN0aW9uPT4icHJvamVjdF9pbmRleCIpKTsKKwkJICAgICAgIGVzY19hdHRyKCRzaXRlX25hbWUpLAorCQkgICAgICAgZXNjX2F0dHIoaHJlZihwcm9qZWN0PT51bmRlZiwgYWN0aW9uPT4icHJvamVjdF9pbmRleCIpKSk7CiAJCXByaW50ZignPGxpbmsgcmVsPSJhbHRlcm5hdGUiIHRpdGxlPSIlcyBwcm9qZWN0cyBmZWVkcyIgJy4KIAkJICAgICAgICdocmVmPSIlcyIgdHlwZT0idGV4dC94LW9wbWwiIC8+Jy4iXG4iLAotCQkgICAgICAgZXNjX2F0dHIoJHNpdGVfbmFtZSksIGhyZWYocHJvamVjdD0+dW5kZWYsIGFjdGlvbj0+Im9wbWwiKSk7CisJCSAgICAgICBlc2NfYXR0cigkc2l0ZV9uYW1lKSwKKwkJICAgICAgIGVzY19hdHRyKGhyZWYocHJvamVjdD0+dW5kZWYsIGFjdGlvbj0+Im9wbWwiKSkpOwogCX0KIH0KIApAQCAtNDI4Nyw4ICs0Mjg5LDggQEAKIAlpZiAoZGVmaW5lZCAkYWN0aW9uICYmCiAJICAgICRhY3Rpb24gZXEgJ2JsYW1lX2luY3JlbWVudGFsJykgewogCQlwcmludCBxcSE8c2NyaXB0IHR5cGU9InRleHQvamF2YXNjcmlwdCI+XG4hLgotCQkgICAgICBxcSFzdGFydEJsYW1lKCIhLiBocmVmKGFjdGlvbj0+ImJsYW1lX2RhdGEiLCAtcmVwbGF5PT4xKSAucXEhIixcbiEuCi0JCSAgICAgIHFxISAgICAgICAgICAgIiEuIGhyZWYoKSAucXEhIik7XG4hLgorCQkgICAgICBxcSFzdGFydEJsYW1lKCIhLiBlc2NfYXR0cihocmVmKGFjdGlvbj0+ImJsYW1lX2RhdGEiLCAtcmVwbGF5PT4xKSkgLnFxISIsXG4hLgorCQkgICAgICBxcSEgICAgICAgICAgICIhLiBlc2NfYXR0cihocmVmKCkpIC5xcSEiKTtcbiEuCiAJCSAgICAgIHFxITwvc2NyaXB0PlxuITsKIAl9IGVsc2UgewogCQlteSAoJGpzdGltZXpvbmUsICR0el9jb29raWUsICRkYXRldGltZV9jbGFzcykgPQpAQCAtNzE1NSw4ICs3MTU3LDggQEAKIAkJCXByaW50IHFxISBhbHQ9IiEuZXNjX2F0dHIoJGZpbGVfbmFtZSkucXEhIiB0aXRsZT0iIS5lc2NfYXR0cigkZmlsZV9uYW1lKS5xcSEiITsKIAkJfQogCQlwcmludCBxcSEgc3JjPSIhIC4KLQkJICAgICAgaHJlZihhY3Rpb249PiJibG9iX3BsYWluIiwgaGFzaD0+JGhhc2gsCi0JCSAgICAgICAgICAgaGFzaF9iYXNlPT4kaGFzaF9iYXNlLCBmaWxlX25hbWU9PiRmaWxlX25hbWUpIC4KKwkJICAgICAgZXNjX2F0dHIoaHJlZihhY3Rpb249PiJibG9iX3BsYWluIiwgaGFzaD0+JGhhc2gsCisJCSAgICAgICAgICAgaGFzaF9iYXNlPT4kaGFzaF9iYXNlLCBmaWxlX25hbWU9PiRmaWxlX25hbWUpKSAuCiAJCSAgICAgIHFxISIgLz5cbiE7CiAJfSBlbHNlIHsKIAkJbXkgJG5yOwpAQCAtODIzOSw2ICs4MjQxLDcgQEAKIAl9IGVsc2UgewogCQkkYWx0X3VybCA9IGhyZWYoLWZ1bGw9PjEsIGFjdGlvbj0+InN1bW1hcnkiKTsKIAl9CisJJGFsdF91cmwgPSBlc2NfYXR0cigkYWx0X3VybCk7CiAJcHJpbnQgcXEhPD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0idXRmLTgiPz5cbiE7CiAJaWYgKCRmb3JtYXQgZXEgJ3JzcycpIHsKIAkJcHJpbnQgPDxYTUw7CkBAIC04Mjc2LDcgKzgyNzksNyBAQAogCQkgICAgICAkYWx0X3VybCAuICciIC8+JyAuICJcbiIgLgogCQkgICAgICAnPGxpbmsgcmVsPSJzZWxmIiB0eXBlPSInIC4gJGNvbnRlbnRfdHlwZSAuICciIGhyZWY9IicgLgogCQkgICAgICAkY2dpLT5zZWxmX3VybCgpIC4gJyIgLz4nIC4gIlxuIiAuCi0JCSAgICAgICI8aWQ+IiAuIGhyZWYoLWZ1bGw9PjEpIC4gIjwvaWQ+XG4iIC4KKwkJICAgICAgIjxpZD4iIC4gZXNjX3VybChocmVmKC1mdWxsPT4xKSkgLiAiPC9pZD5cbiIgLgogCQkgICAgICAjIHVzZSBwcm9qZWN0IG93bmVyIGZvciBmZWVkIGF1dGhvcgogCQkgICAgICAiPGF1dGhvcj48bmFtZT4kb3duZXI8L25hbWU+PC9hdXRob3I+XG4iOwogCQlpZiAoZGVmaW5lZCAkZmF2aWNvbikgewpAQCAtODMyMiw3ICs4MzI1LDcgQEAKIAkJCSAgICAgICI8YXV0aG9yPiIgLiBlc2NfaHRtbCgkY297J2F1dGhvcid9KSAuICI8L2F1dGhvcj5cbiIgLgogCQkJICAgICAgIjxwdWJEYXRlPiRjZHsncmZjMjgyMid9PC9wdWJEYXRlPlxuIiAuCiAJCQkgICAgICAiPGd1aWQgaXNQZXJtYUxpbms9XCJ0cnVlXCI+JGNvX3VybDwvZ3VpZD5cbiIgLgotCQkJICAgICAgIjxsaW5rPiRjb191cmw8L2xpbms+XG4iIC4KKwkJCSAgICAgICI8bGluaz4iIC4gZXNjX2h0bWwoJGNvX3VybCkgLiAiPC9saW5rPlxuIiAuCiAJCQkgICAgICAiPGRlc2NyaXB0aW9uPiIgLiBlc2NfaHRtbCgkY297J3RpdGxlJ30pIC4gIjwvZGVzY3JpcHRpb24+XG4iIC4KIAkJCSAgICAgICI8Y29udGVudDplbmNvZGVkPiIgLgogCQkJICAgICAgIjwhW0NEQVRBW1xuIjsKQEAgLTgzNDQsOCArODM0Nyw4IEBACiAJCQl9CiAJCQlwcmludCAiPC9jb250cmlidXRvcj5cbiIgLgogCQkJICAgICAgIjxwdWJsaXNoZWQ+JGNkeydpc28tODYwMSd9PC9wdWJsaXNoZWQ+XG4iIC4KLQkJCSAgICAgICI8bGluayByZWw9XCJhbHRlcm5hdGVcIiB0eXBlPVwidGV4dC9odG1sXCIgaHJlZj1cIiRjb191cmxcIiAvPlxuIiAuCi0JCQkgICAgICAiPGlkPiRjb191cmw8L2lkPlxuIiAuCisJCQkgICAgICAiPGxpbmsgcmVsPVwiYWx0ZXJuYXRlXCIgdHlwZT1cInRleHQvaHRtbFwiIGhyZWY9XCIiIC4gZXNjX2F0dHIoJGNvX3VybCkgLiAiXCIgLz5cbiIgLgorCQkJICAgICAgIjxpZD4iIC4gZXNjX2h0bWwoJGNvX3VybCkgLiAiPC9pZD5cbiIgLgogCQkJICAgICAgIjxjb250ZW50IHR5cGU9XCJ4aHRtbFwiIHhtbDpiYXNlPVwiIiAuIGVzY191cmwoJG15X3VybCkgLiAiXCI+XG4iIC4KIAkJCSAgICAgICI8ZGl2IHhtbG5zPVwiaHR0cDovL3d3dy53My5vcmcvMTk5OS94aHRtbFwiPlxuIjsKIAkJfQpAQCAtODQ1Miw4ICs4NDU1LDggQEAKIAkJfQogCiAJCW15ICRwYXRoID0gZXNjX2h0bWwoY2hvcF9zdHIoJHByb2p7J3BhdGgnfSwgMjUsIDUpKTsKLQkJbXkgJHJzcyAgPSBocmVmKCdwcm9qZWN0JyA9PiAkcHJvansncGF0aCd9LCAnYWN0aW9uJyA9PiAncnNzJywgLWZ1bGwgPT4gMSk7Ci0JCW15ICRodG1sID0gaHJlZigncHJvamVjdCcgPT4gJHByb2p7J3BhdGgnfSwgJ2FjdGlvbicgPT4gJ3N1bW1hcnknLCAtZnVsbCA9PiAxKTsKKwkJbXkgJHJzcyAgPSBlc2NfYXR0cihocmVmKCdwcm9qZWN0JyA9PiAkcHJvansncGF0aCd9LCAnYWN0aW9uJyA9PiAncnNzJywgLWZ1bGwgPT4gMSkpOworCQlteSAkaHRtbCA9IGVzY19hdHRyKGhyZWYoJ3Byb2plY3QnID0+ICRwcm9qeydwYXRoJ30sICdhY3Rpb24nID0+ICdzdW1tYXJ5JywgLWZ1bGwgPT4gMSkpOwogCQlwcmludCAiPG91dGxpbmUgdHlwZT1cInJzc1wiIHRleHQ9XCIkcGF0aFwiIHRpdGxlPVwiJHBhdGhcIiB4bWxVcmw9XCIkcnNzXCIgaHRtbFVybD1cIiRodG1sXCIvPlxuIjsKIAl9CiAJcHJpbnQgPDxYTUw7CmRpZmYgLS1naXQgYS9naXR3ZWIvc3RhdGljL2pzL2JsYW1lX2luY3JlbWVudGFsLmpzIGIvZ2l0d2ViL3N0YXRpYy9qcy9ibGFtZV9pbmNyZW1lbnRhbC5qcwppbmRleCBkYjZlYjUwLi5lMTAwZDgyIDEwMDY0NAotLS0gYS9naXR3ZWIvc3RhdGljL2pzL2JsYW1lX2luY3JlbWVudGFsLmpzCisrKyBiL2dpdHdlYi9zdGF0aWMvanMvYmxhbWVfaW5jcmVtZW50YWwuanMKQEAgLTQ4NCw3ICs0ODQsNyBAQAogCQkJY2FzZSAncHJldmlvdXMnOgogCQkJCWN1ckNvbW1pdC5ucHJldmlvdXMrKzsKIAkJCQkvLyBzdG9yZSBvbmx5IGZpcnN0ICdwcmV2aW91cycgaGVhZGVyCi0JCQkJaWYgKCEncHJldmlvdXMnIGluIGN1ckNvbW1pdCkgeworCQkJCWlmICghKCdwcmV2aW91cycgaW4gY3VyQ29tbWl0KSkgewogCQkJCQl2YXIgcGFydHMgPSBkYXRhLnNwbGl0KCcgJywgMik7CiAJCQkJCWN1ckNvbW1pdC5wcmV2aW91cyAgICA9IHBhcnRzWzBdOwogCQkJCQljdXJDb21taXQuZmlsZV9wYXJlbnQgPSB1bnF1b3RlKHBhcnRzWzFdKTsKZGlmZiAtLWdpdCBhL2dwZy1pbnRlcmZhY2UuYyBiL2dwZy1pbnRlcmZhY2UuYwppbmRleCBkNjAxMTVjLi4xMzFlN2Q1IDEwMDY0NAotLS0gYS9ncGctaW50ZXJmYWNlLmMKKysrIGIvZ3BnLWludGVyZmFjZS5jCkBAIC0xMDUsNiArMTA1LDE2IEBACiAJeyAwLCAiVkFMSURTSUcgIiwgR1BHX1NUQVRVU19GSU5HRVJQUklOVCB9LAogfTsKIAorc3RhdGljIHZvaWQgcmVwbGFjZV9jc3RyaW5nKGNoYXIgKipmaWVsZCwgY29uc3QgY2hhciAqbGluZSwgY29uc3QgY2hhciAqbmV4dCkKK3sKKwlmcmVlKCpmaWVsZCk7CisKKwlpZiAobGluZSAmJiBuZXh0KQorCQkqZmllbGQgPSB4bWVtZHVweihsaW5lLCBuZXh0IC0gbGluZSk7CisJZWxzZQorCQkqZmllbGQgPSBOVUxMOworfQorCiBzdGF0aWMgdm9pZCBwYXJzZV9ncGdfb3V0cHV0KHN0cnVjdCBzaWduYXR1cmVfY2hlY2sgKnNpZ2MpCiB7CiAJY29uc3QgY2hhciAqYnVmID0gc2lnYy0+Z3BnX3N0YXR1czsKQEAgLTEzNiwzMyArMTQ2LDQzIEBACiAJCQkJLyogRG8gd2UgaGF2ZSBrZXkgaW5mb3JtYXRpb24/ICovCiAJCQkJaWYgKHNpZ2NoZWNrX2dwZ19zdGF0dXNbaV0uZmxhZ3MgJiBHUEdfU1RBVFVTX0tFWUlEKSB7CiAJCQkJCW5leHQgPSBzdHJjaHJudWwobGluZSwgJyAnKTsKLQkJCQkJZnJlZShzaWdjLT5rZXkpOwotCQkJCQlzaWdjLT5rZXkgPSB4bWVtZHVweihsaW5lLCBuZXh0IC0gbGluZSk7CisJCQkJCXJlcGxhY2VfY3N0cmluZygmc2lnYy0+a2V5LCBsaW5lLCBuZXh0KTsKIAkJCQkJLyogRG8gd2UgaGF2ZSBzaWduZXIgaW5mb3JtYXRpb24/ICovCiAJCQkJCWlmICgqbmV4dCAmJiAoc2lnY2hlY2tfZ3BnX3N0YXR1c1tpXS5mbGFncyAmIEdQR19TVEFUVVNfVUlEKSkgewogCQkJCQkJbGluZSA9IG5leHQgKyAxOwogCQkJCQkJbmV4dCA9IHN0cmNocm51bChsaW5lLCAnXG4nKTsKLQkJCQkJCWZyZWUoc2lnYy0+c2lnbmVyKTsKLQkJCQkJCXNpZ2MtPnNpZ25lciA9IHhtZW1kdXB6KGxpbmUsIG5leHQgLSBsaW5lKTsKKwkJCQkJCXJlcGxhY2VfY3N0cmluZygmc2lnYy0+c2lnbmVyLCBsaW5lLCBuZXh0KTsKIAkJCQkJfQogCQkJCX0KIAkJCQkvKiBEbyB3ZSBoYXZlIGZpbmdlcnByaW50PyAqLwogCQkJCWlmIChzaWdjaGVja19ncGdfc3RhdHVzW2ldLmZsYWdzICYgR1BHX1NUQVRVU19GSU5HRVJQUklOVCkgewotCQkJCQluZXh0ID0gc3RyY2hybnVsKGxpbmUsICcgJyk7Ci0JCQkJCWZyZWUoc2lnYy0+ZmluZ2VycHJpbnQpOwotCQkJCQlzaWdjLT5maW5nZXJwcmludCA9IHhtZW1kdXB6KGxpbmUsIG5leHQgLSBsaW5lKTsKKwkJCQkJY29uc3QgY2hhciAqbGltaXQ7CisJCQkJCWNoYXIgKipmaWVsZDsKIAotCQkJCQkvKiBTa2lwIGludGVyaW0gZmllbGRzICovCisJCQkJCW5leHQgPSBzdHJjaHJudWwobGluZSwgJyAnKTsKKwkJCQkJcmVwbGFjZV9jc3RyaW5nKCZzaWdjLT5maW5nZXJwcmludCwgbGluZSwgbmV4dCk7CisKKwkJCQkJLyoKKwkJCQkJICogU2tpcCBpbnRlcmltIGZpZWxkcy4gIFRoZSBzZWFyY2ggaXMKKwkJCQkJICogbGltaXRlZCB0byB0aGUgc2FtZSBsaW5lIHNpbmNlIG9ubHkKKwkJCQkJICogT3BlblBHUCBzaWduYXR1cmVzIGhhcyBhIGZpZWxkIHdpdGgKKwkJCQkJICogdGhlIHByaW1hcnkgZmluZ2VycHJpbnQuCisJCQkJCSAqLworCQkJCQlsaW1pdCA9IHN0cmNocm51bChsaW5lLCAnXG4nKTsKIAkJCQkJZm9yIChqID0gOTsgaiA+IDA7IGotLSkgewotCQkJCQkJaWYgKCEqbmV4dCkKKwkJCQkJCWlmICghKm5leHQgfHwgbGltaXQgPD0gbmV4dCkKIAkJCQkJCQlicmVhazsKIAkJCQkJCWxpbmUgPSBuZXh0ICsgMTsKIAkJCQkJCW5leHQgPSBzdHJjaHJudWwobGluZSwgJyAnKTsKIAkJCQkJfQogCi0JCQkJCW5leHQgPSBzdHJjaHJudWwobGluZSwgJ1xuJyk7Ci0JCQkJCWZyZWUoc2lnYy0+cHJpbWFyeV9rZXlfZmluZ2VycHJpbnQpOwotCQkJCQlzaWdjLT5wcmltYXJ5X2tleV9maW5nZXJwcmludCA9IHhtZW1kdXB6KGxpbmUsIG5leHQgLSBsaW5lKTsKKwkJCQkJZmllbGQgPSAmc2lnYy0+cHJpbWFyeV9rZXlfZmluZ2VycHJpbnQ7CisJCQkJCWlmICghaikgeworCQkJCQkJbmV4dCA9IHN0cmNocm51bChsaW5lLCAnXG4nKTsKKwkJCQkJCXJlcGxhY2VfY3N0cmluZyhmaWVsZCwgbGluZSwgbmV4dCk7CisJCQkJCX0gZWxzZSB7CisJCQkJCQlyZXBsYWNlX2NzdHJpbmcoZmllbGQsIE5VTEwsIE5VTEwpOworCQkJCQl9CiAJCQkJfQogCiAJCQkJYnJlYWs7CmRpZmYgLS1naXQgYS9ncmFwaC5jIGIvZ3JhcGguYwppbmRleCBmNTMxMzU0Li5lM2ZkMGVhIDEwMDY0NAotLS0gYS9ncmFwaC5jCisrKyBiL2dyYXBoLmMKQEAgLTExMiwxNCArMTEyLDQyIEBACiAJcmV0dXJuIGNvbHVtbl9jb2xvcnNbY29sb3JdOwogfQogCi1zdGF0aWMgdm9pZCBzdHJidWZfd3JpdGVfY29sdW1uKHN0cnVjdCBzdHJidWYgKnNiLCBjb25zdCBzdHJ1Y3QgY29sdW1uICpjLAotCQkJCWNoYXIgY29sX2NoYXIpCitzdHJ1Y3QgZ3JhcGhfbGluZSB7CisJc3RydWN0IHN0cmJ1ZiAqYnVmOworCXNpemVfdCB3aWR0aDsKK307CisKK3N0YXRpYyBpbmxpbmUgdm9pZCBncmFwaF9saW5lX2FkZGNoKHN0cnVjdCBncmFwaF9saW5lICpsaW5lLCBpbnQgYykKK3sKKwlzdHJidWZfYWRkY2gobGluZS0+YnVmLCBjKTsKKwlsaW5lLT53aWR0aCsrOworfQorCitzdGF0aWMgaW5saW5lIHZvaWQgZ3JhcGhfbGluZV9hZGRjaGFycyhzdHJ1Y3QgZ3JhcGhfbGluZSAqbGluZSwgaW50IGMsIHNpemVfdCBuKQoreworCXN0cmJ1Zl9hZGRjaGFycyhsaW5lLT5idWYsIGMsIG4pOworCWxpbmUtPndpZHRoICs9IG47Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9pZCBncmFwaF9saW5lX2FkZHN0cihzdHJ1Y3QgZ3JhcGhfbGluZSAqbGluZSwgY29uc3QgY2hhciAqcykKK3sKKwlzdHJidWZfYWRkc3RyKGxpbmUtPmJ1Ziwgcyk7CisJbGluZS0+d2lkdGggKz0gc3RybGVuKHMpOworfQorCitzdGF0aWMgaW5saW5lIHZvaWQgZ3JhcGhfbGluZV9hZGRjb2xvcihzdHJ1Y3QgZ3JhcGhfbGluZSAqbGluZSwgdW5zaWduZWQgc2hvcnQgY29sb3IpCit7CisJc3RyYnVmX2FkZHN0cihsaW5lLT5idWYsIGNvbHVtbl9nZXRfY29sb3JfY29kZShjb2xvcikpOworfQorCitzdGF0aWMgdm9pZCBncmFwaF9saW5lX3dyaXRlX2NvbHVtbihzdHJ1Y3QgZ3JhcGhfbGluZSAqbGluZSwgY29uc3Qgc3RydWN0IGNvbHVtbiAqYywKKwkJCQkgICAgY2hhciBjb2xfY2hhcikKIHsKIAlpZiAoYy0+Y29sb3IgPCBjb2x1bW5fY29sb3JzX21heCkKLQkJc3RyYnVmX2FkZHN0cihzYiwgY29sdW1uX2dldF9jb2xvcl9jb2RlKGMtPmNvbG9yKSk7Ci0Jc3RyYnVmX2FkZGNoKHNiLCBjb2xfY2hhcik7CisJCWdyYXBoX2xpbmVfYWRkY29sb3IobGluZSwgYy0+Y29sb3IpOworCWdyYXBoX2xpbmVfYWRkY2gobGluZSwgY29sX2NoYXIpOwogCWlmIChjLT5jb2xvciA8IGNvbHVtbl9jb2xvcnNfbWF4KQotCQlzdHJidWZfYWRkc3RyKHNiLCBjb2x1bW5fZ2V0X2NvbG9yX2NvZGUoY29sdW1uX2NvbG9yc19tYXgpKTsKKwkJZ3JhcGhfbGluZV9hZGRjb2xvcihsaW5lLCBjb2x1bW5fY29sb3JzX21heCk7CiB9CiAKIHN0cnVjdCBnaXRfZ3JhcGggewpAQCAtMTc1LDkgKzIwMyw2MyBAQAogCSAqLwogCWludCBwcmV2X2NvbW1pdF9pbmRleDsKIAkvKgorCSAqIFdoaWNoIGxheW91dCB2YXJpYW50IHRvIHVzZSB0byBkaXNwbGF5IG1lcmdlIGNvbW1pdHMuIElmIHRoZQorCSAqIGNvbW1pdCdzIGZpcnN0IHBhcmVudCBpcyBrbm93biB0byBiZSBpbiBhIGNvbHVtbiB0byB0aGUgbGVmdCBvZiB0aGUKKwkgKiBtZXJnZSwgdGhlbiB0aGlzIHZhbHVlIGlzIDAgYW5kIHdlIHVzZSB0aGUgbGF5b3V0IG9uIHRoZSBsZWZ0LgorCSAqIE90aGVyd2lzZSwgdGhlIHZhbHVlIGlzIDEgYW5kIHRoZSBsYXlvdXQgb24gdGhlIHJpZ2h0IGlzIHVzZWQuIFRoaXMKKwkgKiBmaWVsZCB0ZWxscyB1cyBob3cgbWFueSBjb2x1bW5zIHRoZSBmaXJzdCBwYXJlbnQgb2NjdXBpZXMuCisJICoKKwkgKiAJCTApCQkJMSkKKwkgKgorCSAqIAkJfCB8IHwgKi0uCQl8IHwgKi0tLS4KKwkgKiAJCXwgfF98L3xcIFwJCXwgfCB8XCBcIFwKKwkgKiAJCXwvfCB8IHwgfCB8CQl8IHwgfCB8IHwgKgorCSAqLworCWludCBtZXJnZV9sYXlvdXQ7CisJLyoKKwkgKiBUaGUgbnVtYmVyIG9mIGNvbHVtbnMgYWRkZWQgdG8gdGhlIGdyYXBoIGJ5IHRoZSBjdXJyZW50IGNvbW1pdC4gRm9yCisJICogMi13YXkgYW5kIG9jdG9wdXMgbWVyZ2VzLCB0aGlzIGlzIGlzIHVzdWFsbHkgb25lIGxlc3MgdGhhbiB0aGUKKwkgKiBudW1iZXIgb2YgcGFyZW50czoKKwkgKgorCSAqIAkJfCB8IHwJCQl8IHwgICAgXAorCSAqCQl8ICogfAkJCXwgKi0tLS4gXAorCSAqCQl8IHxcIFwJCQl8IHxcIFwgXCBcCisJICoJCXwgfCB8IHwgICAgICAgICAJfCB8IHwgfCB8IHwKKwkgKgorCSAqCQludW1fcGFyZW50czogMgkJbnVtX3BhcmVudHM6IDQKKwkgKgkJZWRnZXNfYWRkZWQ6IDEJCWVkZ2VzX2FkZGVkOiAzCisJICoKKwkgKiBGb3IgbGVmdC1za2V3ZWQgbWVyZ2VzLCB0aGUgZmlyc3QgcGFyZW50IGZ1c2VzIHdpdGggaXRzIG5laWdoYm9yIGFuZAorCSAqIHNvIG9uZSBsZXNzIGNvbHVtbiBpcyBhZGRlZDoKKwkgKgorCSAqCQl8IHwgfAkJCXwgfCAgXAorCSAqCQl8ICogfAkJCXwgKi0uIFwKKwkgKgkJfC98IHwJCQl8L3xcIFwgXAorCSAqCQl8IHwgfAkJCXwgfCB8IHwgfAorCSAqCisJICoJCW51bV9wYXJlbnRzOiAyCQludW1fcGFyZW50czogNAorCSAqCQllZGdlc19hZGRlZDogMAkJZWRnZXNfYWRkZWQ6IDIKKwkgKgorCSAqIFRoaXMgbnVtYmVyIGRldGVybWluZXMgaG93IGVkZ2VzIHRvIHRoZSByaWdodCBvZiB0aGUgbWVyZ2UgYXJlCisJICogZGlzcGxheWVkIGluIGNvbW1pdCBhbmQgcG9zdC1tZXJnZSBsaW5lczsgaWYgbm8gY29sdW1ucyBoYXZlIGJlZW4KKwkgKiBhZGRlZCB0aGVuIGEgdmVydGljYWwgbGluZSBzaG91bGQgYmUgdXNlZCB3aGVyZSBhIHJpZ2h0LXRyYWNraW5nCisJICogbGluZSB3b3VsZCBvdGhlcndpc2UgYmUgdXNlZC4KKwkgKgorCSAqCQl8ICogXAkJCXwgKiB8CisJICoJCXwgfFwgXAkJCXwvfCB8CisJICoJCXwgfCAqIFwJCQl8ICogfAorCSAqLworCWludCBlZGdlc19hZGRlZDsKKwkvKgorCSAqIFRoZSBudW1iZXIgb2YgY29sdW1ucyBhZGRlZCBieSB0aGUgcHJldmlvdXMgY29tbWl0LCB3aGljaCBpcyB1c2VkIHRvCisJICogc21vb3RoIGVkZ2VzIGFwcGVhcmluZyB0byB0aGUgcmlnaHQgb2YgYSBjb21taXQgaW4gYSBjb21taXQgbGluZQorCSAqIGZvbGxvd2luZyBhIHBvc3QtbWVyZ2UgbGluZS4KKwkgKi8KKwlpbnQgcHJldl9lZGdlc19hZGRlZDsKKwkvKgogCSAqIFRoZSBtYXhpbXVtIG51bWJlciBvZiBjb2x1bW5zIHRoYXQgY2FuIGJlIHN0b3JlZCBpbiB0aGUgY29sdW1ucwogCSAqIGFuZCBuZXdfY29sdW1ucyBhcnJheXMuICBUaGlzIGlzIGFsc28gaGFsZiB0aGUgbnVtYmVyIG9mIGVudHJpZXMKLQkgKiB0aGF0IGNhbiBiZSBzdG9yZWQgaW4gdGhlIG1hcHBpbmcgYW5kIG5ld19tYXBwaW5nIGFycmF5cy4KKwkgKiB0aGF0IGNhbiBiZSBzdG9yZWQgaW4gdGhlIG1hcHBpbmcgYW5kIG9sZF9tYXBwaW5nIGFycmF5cy4KIAkgKi8KIAlpbnQgY29sdW1uX2NhcGFjaXR5OwogCS8qCkBAIC0yMTUsMTIgKzI5NywxMiBAQAogCSAqLwogCWludCAqbWFwcGluZzsKIAkvKgotCSAqIEEgdGVtcG9yYXJ5IGFycmF5IGZvciBjb21wdXRpbmcgdGhlIG5leHQgbWFwcGluZyBzdGF0ZQotCSAqIHdoaWxlIHdlIGFyZSBvdXRwdXR0aW5nIGEgbWFwcGluZyBsaW5lLiAgVGhpcyBpcyBzdG9yZWQgYXMgcGFydAotCSAqIG9mIHRoZSBnaXRfZ3JhcGggc2ltcGx5IHNvIHdlIGRvbid0IGhhdmUgdG8gYWxsb2NhdGUgYSBuZXcKLQkgKiB0ZW1wb3JhcnkgYXJyYXkgZWFjaCB0aW1lIHdlIGhhdmUgdG8gb3V0cHV0IGEgY29sbGFwc2luZyBsaW5lLgorCSAqIEEgY29weSBvZiB0aGUgY29udGVudHMgb2YgdGhlIG1hcHBpbmcgYXJyYXkgZnJvbSB0aGUgbGFzdCBjb21taXQsCisJICogd2hpY2ggd2UgdXNlIHRvIGltcHJvdmUgdGhlIGRpc3BsYXkgb2YgY29sdW1ucyB0aGF0IGFyZSB0cmFja2luZworCSAqIGZyb20gcmlnaHQgdG8gbGVmdCB0aHJvdWdoIGEgY29tbWl0IGxpbmUuICBXZSBhbHNvIHVzZSB0aGlzIHRvCisJICogYXZvaWQgYWxsb2NhdGluZyBhIGZyZXNoIGFycmF5IHdoZW4gd2UgY29tcHV0ZSB0aGUgbmV4dCBtYXBwaW5nLgogCSAqLwotCWludCAqbmV3X21hcHBpbmc7CisJaW50ICpvbGRfbWFwcGluZzsKIAkvKgogCSAqIFRoZSBjdXJyZW50IGRlZmF1bHQgY29sdW1uIGNvbG9yIGJlaW5nIHVzZWQuICBUaGlzIGlzCiAJICogc3RvcmVkIGFzIGFuIGluZGV4IGludG8gdGhlIGFycmF5IGNvbHVtbl9jb2xvcnMuCkBAIC0yODUsNiArMzY3LDkgQEAKIAlncmFwaC0+cHJldl9zdGF0ZSA9IEdSQVBIX1BBRERJTkc7CiAJZ3JhcGgtPmNvbW1pdF9pbmRleCA9IDA7CiAJZ3JhcGgtPnByZXZfY29tbWl0X2luZGV4ID0gMDsKKwlncmFwaC0+bWVyZ2VfbGF5b3V0ID0gMDsKKwlncmFwaC0+ZWRnZXNfYWRkZWQgPSAwOworCWdyYXBoLT5wcmV2X2VkZ2VzX2FkZGVkID0gMDsKIAlncmFwaC0+bnVtX2NvbHVtbnMgPSAwOwogCWdyYXBoLT5udW1fbmV3X2NvbHVtbnMgPSAwOwogCWdyYXBoLT5tYXBwaW5nX3NpemUgPSAwOwpAQCAtMzAzLDcgKzM4OCw3IEBACiAJQUxMT0NfQVJSQVkoZ3JhcGgtPmNvbHVtbnMsIGdyYXBoLT5jb2x1bW5fY2FwYWNpdHkpOwogCUFMTE9DX0FSUkFZKGdyYXBoLT5uZXdfY29sdW1ucywgZ3JhcGgtPmNvbHVtbl9jYXBhY2l0eSk7CiAJQUxMT0NfQVJSQVkoZ3JhcGgtPm1hcHBpbmcsIDIgKiBncmFwaC0+Y29sdW1uX2NhcGFjaXR5KTsKLQlBTExPQ19BUlJBWShncmFwaC0+bmV3X21hcHBpbmcsIDIgKiBncmFwaC0+Y29sdW1uX2NhcGFjaXR5KTsKKwlBTExPQ19BUlJBWShncmFwaC0+b2xkX21hcHBpbmcsIDIgKiBncmFwaC0+Y29sdW1uX2NhcGFjaXR5KTsKIAogCS8qCiAJICogVGhlIGRpZmYgb3V0cHV0IHByZWZpeCBjYWxsYmFjaywgd2l0aCB0aGlzIHdlIGNhbiBtYWtlCkBAIC0zMzMsNyArNDE4LDcgQEAKIAlSRUFMTE9DX0FSUkFZKGdyYXBoLT5jb2x1bW5zLCBncmFwaC0+Y29sdW1uX2NhcGFjaXR5KTsKIAlSRUFMTE9DX0FSUkFZKGdyYXBoLT5uZXdfY29sdW1ucywgZ3JhcGgtPmNvbHVtbl9jYXBhY2l0eSk7CiAJUkVBTExPQ19BUlJBWShncmFwaC0+bWFwcGluZywgZ3JhcGgtPmNvbHVtbl9jYXBhY2l0eSAqIDIpOwotCVJFQUxMT0NfQVJSQVkoZ3JhcGgtPm5ld19tYXBwaW5nLCBncmFwaC0+Y29sdW1uX2NhcGFjaXR5ICogMik7CisJUkVBTExPQ19BUlJBWShncmFwaC0+b2xkX21hcHBpbmcsIGdyYXBoLT5jb2x1bW5fY2FwYWNpdHkgKiAyKTsKIH0KIAogLyoKQEAgLTQzMiw3NCArNTE3LDc2IEBACiAJcmV0dXJuIGdyYXBoX2dldF9jdXJyZW50X2NvbHVtbl9jb2xvcihncmFwaCk7CiB9CiAKLXN0YXRpYyB2b2lkIGdyYXBoX2luc2VydF9pbnRvX25ld19jb2x1bW5zKHN0cnVjdCBnaXRfZ3JhcGggKmdyYXBoLAotCQkJCQkgIHN0cnVjdCBjb21taXQgKmNvbW1pdCwKLQkJCQkJICBpbnQgKm1hcHBpbmdfaW5kZXgpCitzdGF0aWMgaW50IGdyYXBoX2ZpbmRfbmV3X2NvbHVtbl9ieV9jb21taXQoc3RydWN0IGdpdF9ncmFwaCAqZ3JhcGgsCisJCQkJCSAgIHN0cnVjdCBjb21taXQgKmNvbW1pdCkKIHsKIAlpbnQgaTsKLQotCS8qCi0JICogSWYgdGhlIGNvbW1pdCBpcyBhbHJlYWR5IGluIHRoZSBuZXdfY29sdW1ucyBsaXN0LCB3ZSBkb24ndCBuZWVkIHRvCi0JICogYWRkIGl0LiAgSnVzdCB1cGRhdGUgdGhlIG1hcHBpbmcgY29ycmVjdGx5LgotCSAqLwogCWZvciAoaSA9IDA7IGkgPCBncmFwaC0+bnVtX25ld19jb2x1bW5zOyBpKyspIHsKLQkJaWYgKGdyYXBoLT5uZXdfY29sdW1uc1tpXS5jb21taXQgPT0gY29tbWl0KSB7Ci0JCQlncmFwaC0+bWFwcGluZ1sqbWFwcGluZ19pbmRleF0gPSBpOwotCQkJKm1hcHBpbmdfaW5kZXggKz0gMjsKLQkJCXJldHVybjsKLQkJfQorCQlpZiAoZ3JhcGgtPm5ld19jb2x1bW5zW2ldLmNvbW1pdCA9PSBjb21taXQpCisJCQlyZXR1cm4gaTsKIAl9Ci0KLQkvKgotCSAqIFRoaXMgY29tbWl0IGlzbid0IGFscmVhZHkgaW4gbmV3X2NvbHVtbnMuICBBZGQgaXQuCi0JICovCi0JZ3JhcGgtPm5ld19jb2x1bW5zW2dyYXBoLT5udW1fbmV3X2NvbHVtbnNdLmNvbW1pdCA9IGNvbW1pdDsKLQlncmFwaC0+bmV3X2NvbHVtbnNbZ3JhcGgtPm51bV9uZXdfY29sdW1uc10uY29sb3IgPSBncmFwaF9maW5kX2NvbW1pdF9jb2xvcihncmFwaCwgY29tbWl0KTsKLQlncmFwaC0+bWFwcGluZ1sqbWFwcGluZ19pbmRleF0gPSBncmFwaC0+bnVtX25ld19jb2x1bW5zOwotCSptYXBwaW5nX2luZGV4ICs9IDI7Ci0JZ3JhcGgtPm51bV9uZXdfY29sdW1ucysrOworCXJldHVybiAtMTsKIH0KIAotc3RhdGljIHZvaWQgZ3JhcGhfdXBkYXRlX3dpZHRoKHN0cnVjdCBnaXRfZ3JhcGggKmdyYXBoLAotCQkJICAgICAgIGludCBpc19jb21taXRfaW5fZXhpc3RpbmdfY29sdW1ucykKK3N0YXRpYyB2b2lkIGdyYXBoX2luc2VydF9pbnRvX25ld19jb2x1bW5zKHN0cnVjdCBnaXRfZ3JhcGggKmdyYXBoLAorCQkJCQkgIHN0cnVjdCBjb21taXQgKmNvbW1pdCwKKwkJCQkJICBpbnQgaWR4KQogewotCS8qCi0JICogQ29tcHV0ZSB0aGUgd2lkdGggbmVlZGVkIHRvIGRpc3BsYXkgdGhlIGdyYXBoIGZvciB0aGlzIGNvbW1pdC4KLQkgKiBUaGlzIGlzIHRoZSBtYXhpbXVtIHdpZHRoIG5lZWRlZCBmb3IgYW55IHJvdy4gIEFsbCBvdGhlciByb3dzCi0JICogd2lsbCBiZSBwYWRkZWQgdG8gdGhpcyB3aWR0aC4KLQkgKgotCSAqIENvbXB1dGUgdGhlIG51bWJlciBvZiBjb2x1bW5zIGluIHRoZSB3aWRlc3Qgcm93OgotCSAqIENvdW50IGVhY2ggZXhpc3RpbmcgY29sdW1uIChncmFwaC0+bnVtX2NvbHVtbnMpLCBhbmQgZWFjaCBuZXcKLQkgKiBjb2x1bW4gYWRkZWQgYnkgdGhpcyBjb21taXQuCi0JICovCi0JaW50IG1heF9jb2xzID0gZ3JhcGgtPm51bV9jb2x1bW5zICsgZ3JhcGgtPm51bV9wYXJlbnRzOworCWludCBpID0gZ3JhcGhfZmluZF9uZXdfY29sdW1uX2J5X2NvbW1pdChncmFwaCwgY29tbWl0KTsKKwlpbnQgbWFwcGluZ19pZHg7CiAKIAkvKgotCSAqIEV2ZW4gaWYgdGhlIGN1cnJlbnQgY29tbWl0IGhhcyBubyBwYXJlbnRzIHRvIGJlIHByaW50ZWQsIGl0Ci0JICogc3RpbGwgdGFrZXMgdXAgYSBjb2x1bW4gZm9yIGl0c2VsZi4KKwkgKiBJZiB0aGUgY29tbWl0IGlzIG5vdCBhbHJlYWR5IGluIHRoZSBuZXdfY29sdW1ucyBhcnJheSwgdGhlbiBhZGQgaXQKKwkgKiBhbmQgcmVjb3JkIGl0IGFzIGJlaW5nIGluIHRoZSBmaW5hbCBjb2x1bW4uCiAJICovCi0JaWYgKGdyYXBoLT5udW1fcGFyZW50cyA8IDEpCi0JCW1heF9jb2xzKys7CisJaWYgKGkgPCAwKSB7CisJCWkgPSBncmFwaC0+bnVtX25ld19jb2x1bW5zKys7CisJCWdyYXBoLT5uZXdfY29sdW1uc1tpXS5jb21taXQgPSBjb21taXQ7CisJCWdyYXBoLT5uZXdfY29sdW1uc1tpXS5jb2xvciA9IGdyYXBoX2ZpbmRfY29tbWl0X2NvbG9yKGdyYXBoLCBjb21taXQpOworCX0KIAotCS8qCi0JICogV2UgYWRkZWQgYSBjb2x1bW4gZm9yIHRoZSBjdXJyZW50IGNvbW1pdCBhcyBwYXJ0IG9mCi0JICogZ3JhcGgtPm51bV9wYXJlbnRzLiAgSWYgdGhlIGN1cnJlbnQgY29tbWl0IHdhcyBhbHJlYWR5IGluCi0JICogZ3JhcGgtPmNvbHVtbnMsIHRoZW4gd2UgaGF2ZSBkb3VibGUgY291bnRlZCBpdC4KLQkgKi8KLQlpZiAoaXNfY29tbWl0X2luX2V4aXN0aW5nX2NvbHVtbnMpCi0JCW1heF9jb2xzLS07CisJaWYgKGdyYXBoLT5udW1fcGFyZW50cyA+IDEgJiYgaWR4ID4gLTEgJiYgZ3JhcGgtPm1lcmdlX2xheW91dCA9PSAtMSkgeworCQkvKgorCQkgKiBJZiB0aGlzIGlzIHRoZSBmaXJzdCBwYXJlbnQgb2YgYSBtZXJnZSwgY2hvb3NlIGEgbGF5b3V0IGZvcgorCQkgKiB0aGUgbWVyZ2UgbGluZSBiYXNlZCBvbiB3aGV0aGVyIHRoZSBwYXJlbnQgYXBwZWFycyBpbiBhCisJCSAqIGNvbHVtbiB0byB0aGUgbGVmdCBvZiB0aGUgbWVyZ2UKKwkJICovCisJCWludCBkaXN0LCBzaGlmdDsKIAotCS8qCi0JICogRWFjaCBjb2x1bW4gdGFrZXMgdXAgMiBzcGFjZXMKLQkgKi8KLQlncmFwaC0+d2lkdGggPSBtYXhfY29scyAqIDI7CisJCWRpc3QgPSBpZHggLSBpOworCQlzaGlmdCA9IChkaXN0ID4gMSkgPyAyICogZGlzdCAtIDMgOiAxOworCisJCWdyYXBoLT5tZXJnZV9sYXlvdXQgPSAoZGlzdCA+IDApID8gMCA6IDE7CisJCWdyYXBoLT5lZGdlc19hZGRlZCA9IGdyYXBoLT5udW1fcGFyZW50cyArIGdyYXBoLT5tZXJnZV9sYXlvdXQgIC0gMjsKKworCQltYXBwaW5nX2lkeCA9IGdyYXBoLT53aWR0aCArIChncmFwaC0+bWVyZ2VfbGF5b3V0IC0gMSkgKiBzaGlmdDsKKwkJZ3JhcGgtPndpZHRoICs9IDIgKiBncmFwaC0+bWVyZ2VfbGF5b3V0OworCisJfSBlbHNlIGlmIChncmFwaC0+ZWRnZXNfYWRkZWQgPiAwICYmIGkgPT0gZ3JhcGgtPm1hcHBpbmdbZ3JhcGgtPndpZHRoIC0gMl0pIHsKKwkJLyoKKwkJICogSWYgc29tZSBjb2x1bW5zIGhhdmUgYmVlbiBhZGRlZCBieSBhIG1lcmdlLCBidXQgdGhpcyBjb21taXQKKwkJICogd2FzIGZvdW5kIGluIHRoZSBsYXN0IGV4aXN0aW5nIGNvbHVtbiwgdGhlbiBhZGp1c3QgdGhlCisJCSAqIG51bWJlcnMgc28gdGhhdCB0aGUgdHdvIGVkZ2VzIGltbWVkaWF0ZWx5IGpvaW4sIGkuZS46CisJCSAqCisJCSAqCQkqIHwJCSogfAorCQkgKgkJfFwgXAk9Pgl8XHwKKwkJICoJCXwgfC8JCXwgKgorCQkgKgkJfCAqCisJCSAqLworCQltYXBwaW5nX2lkeCA9IGdyYXBoLT53aWR0aCAtIDI7CisJCWdyYXBoLT5lZGdlc19hZGRlZCA9IC0xOworCX0gZWxzZSB7CisJCW1hcHBpbmdfaWR4ID0gZ3JhcGgtPndpZHRoOworCQlncmFwaC0+d2lkdGggKz0gMjsKKwl9CisKKwlncmFwaC0+bWFwcGluZ1ttYXBwaW5nX2lkeF0gPSBpOwogfQogCiBzdGF0aWMgdm9pZCBncmFwaF91cGRhdGVfY29sdW1ucyhzdHJ1Y3QgZ2l0X2dyYXBoICpncmFwaCkKIHsKIAlzdHJ1Y3QgY29tbWl0X2xpc3QgKnBhcmVudDsKIAlpbnQgbWF4X25ld19jb2x1bW5zOwotCWludCBtYXBwaW5nX2lkeDsKIAlpbnQgaSwgc2Vlbl90aGlzLCBpc19jb21taXRfaW5fY29sdW1uczsKIAogCS8qCkBAIC01MzIsNiArNjE5LDEwIEBACiAJZm9yIChpID0gMDsgaSA8IGdyYXBoLT5tYXBwaW5nX3NpemU7IGkrKykKIAkJZ3JhcGgtPm1hcHBpbmdbaV0gPSAtMTsKIAorCWdyYXBoLT53aWR0aCA9IDA7CisJZ3JhcGgtPnByZXZfZWRnZXNfYWRkZWQgPSBncmFwaC0+ZWRnZXNfYWRkZWQ7CisJZ3JhcGgtPmVkZ2VzX2FkZGVkID0gMDsKKwogCS8qCiAJICogUG9wdWxhdGUgZ3JhcGgtPm5ld19jb2x1bW5zIGFuZCBncmFwaC0+bWFwcGluZwogCSAqCkBAIC01NDIsNyArNjMzLDYgQEAKIAkgKiBzdXBwb3NlZCB0byBlbmQgdXAgYWZ0ZXIgdGhlIGNvbGxhcHNpbmcgaXMgcGVyZm9ybWVkLgogCSAqLwogCXNlZW5fdGhpcyA9IDA7Ci0JbWFwcGluZ19pZHggPSAwOwogCWlzX2NvbW1pdF9pbl9jb2x1bW5zID0gMTsKIAlmb3IgKGkgPSAwOyBpIDw9IGdyYXBoLT5udW1fY29sdW1uczsgaSsrKSB7CiAJCXN0cnVjdCBjb21taXQgKmNvbF9jb21taXQ7CkBAIC01NTYsOSArNjQ2LDkgQEAKIAkJfQogCiAJCWlmIChjb2xfY29tbWl0ID09IGdyYXBoLT5jb21taXQpIHsKLQkJCWludCBvbGRfbWFwcGluZ19pZHggPSBtYXBwaW5nX2lkeDsKIAkJCXNlZW5fdGhpcyA9IDE7CiAJCQlncmFwaC0+Y29tbWl0X2luZGV4ID0gaTsKKwkJCWdyYXBoLT5tZXJnZV9sYXlvdXQgPSAtMTsKIAkJCWZvciAocGFyZW50ID0gZmlyc3RfaW50ZXJlc3RpbmdfcGFyZW50KGdyYXBoKTsKIAkJCSAgICAgcGFyZW50OwogCQkJICAgICBwYXJlbnQgPSBuZXh0X2ludGVyZXN0aW5nX3BhcmVudChncmFwaCwgcGFyZW50KSkgewpAQCAtNTcxLDIxICs2NjEsMTggQEAKIAkJCQkgICAgIWlzX2NvbW1pdF9pbl9jb2x1bW5zKSB7CiAJCQkJCWdyYXBoX2luY3JlbWVudF9jb2x1bW5fY29sb3IoZ3JhcGgpOwogCQkJCX0KLQkJCQlncmFwaF9pbnNlcnRfaW50b19uZXdfY29sdW1ucyhncmFwaCwKLQkJCQkJCQkgICAgICBwYXJlbnQtPml0ZW0sCi0JCQkJCQkJICAgICAgJm1hcHBpbmdfaWR4KTsKKwkJCQlncmFwaF9pbnNlcnRfaW50b19uZXdfY29sdW1ucyhncmFwaCwgcGFyZW50LT5pdGVtLCBpKTsKIAkJCX0KIAkJCS8qCi0JCQkgKiBXZSBhbHdheXMgbmVlZCB0byBpbmNyZW1lbnQgbWFwcGluZ19pZHggYnkgYXQKKwkJCSAqIFdlIGFsd2F5cyBuZWVkIHRvIGluY3JlbWVudCBncmFwaC0+d2lkdGggYnkgYXQKIAkJCSAqIGxlYXN0IDIsIGV2ZW4gaWYgaXQgaGFzIG5vIGludGVyZXN0aW5nIHBhcmVudHMuCiAJCQkgKiBUaGUgY3VycmVudCBjb21taXQgYWx3YXlzIHRha2VzIHVwIGF0IGxlYXN0IDIKIAkJCSAqIHNwYWNlcy4KIAkJCSAqLwotCQkJaWYgKG1hcHBpbmdfaWR4ID09IG9sZF9tYXBwaW5nX2lkeCkKLQkJCQltYXBwaW5nX2lkeCArPSAyOworCQkJaWYgKGdyYXBoLT5udW1fcGFyZW50cyA9PSAwKQorCQkJCWdyYXBoLT53aWR0aCArPSAyOwogCQl9IGVsc2UgewotCQkJZ3JhcGhfaW5zZXJ0X2ludG9fbmV3X2NvbHVtbnMoZ3JhcGgsIGNvbF9jb21taXQsCi0JCQkJCQkgICAgICAmbWFwcGluZ19pZHgpOworCQkJZ3JhcGhfaW5zZXJ0X2ludG9fbmV3X2NvbHVtbnMoZ3JhcGgsIGNvbF9jb21taXQsIC0xKTsKIAkJfQogCX0KIApAQCAtNTk1LDExICs2ODIsNDMgQEAKIAl3aGlsZSAoZ3JhcGgtPm1hcHBpbmdfc2l6ZSA+IDEgJiYKIAkgICAgICAgZ3JhcGgtPm1hcHBpbmdbZ3JhcGgtPm1hcHBpbmdfc2l6ZSAtIDFdIDwgMCkKIAkJZ3JhcGgtPm1hcHBpbmdfc2l6ZS0tOworfQogCitzdGF0aWMgaW50IGdyYXBoX251bV9kYXNoZWRfcGFyZW50cyhzdHJ1Y3QgZ2l0X2dyYXBoICpncmFwaCkKK3sKKwlyZXR1cm4gZ3JhcGgtPm51bV9wYXJlbnRzICsgZ3JhcGgtPm1lcmdlX2xheW91dCAtIDM7Cit9CisKK3N0YXRpYyBpbnQgZ3JhcGhfbnVtX2V4cGFuc2lvbl9yb3dzKHN0cnVjdCBnaXRfZ3JhcGggKmdyYXBoKQorewogCS8qCi0JICogQ29tcHV0ZSBncmFwaC0+d2lkdGggZm9yIHRoaXMgY29tbWl0CisJICogTm9ybWFsbHksIHdlIG5lZWQgdHdvIGV4cGFuc2lvbiByb3dzIGZvciBlYWNoIGRhc2hlZCBwYXJlbnQgbGluZSBmcm9tCisJICogYW4gb2N0b3B1cyBtZXJnZToKKwkgKgorCSAqIAkJfCAqCisJICogCQl8IHxcCisJICogCQl8IHwgXAorCSAqIAkJfCB8ICBcCisJICogCQl8ICotLiBcCisJICogCQl8IHxcIFwgXAorCSAqCisJICogSWYgdGhlIG1lcmdlIGlzIHNrZXdlZCB0byB0aGUgbGVmdCwgdGhlbiBpdHMgcGFyZW50cyBvY2N1cHkgb25lIGxlc3MKKwkgKiBjb2x1bW4sIGFuZCB3ZSBkb24ndCBuZWVkIGFzIG1hbnkgZXhwYW5zaW9uIHJvd3MgdG8gcm91dGUgYXJvdW5kIGl0OworCSAqIGluIHNvbWUgY2FzZXMgdGhhdCBtZWFucyB3ZSBkb24ndCBuZWVkIGFueSBleHBhbnNpb24gcm93cyBhdCBhbGw6CisJICoKKwkgKiAJCXwgKgorCSAqIAkJfCB8XAorCSAqIAkJfCAqIFwKKwkgKiAJCXwvfFwgXAogCSAqLwotCWdyYXBoX3VwZGF0ZV93aWR0aChncmFwaCwgaXNfY29tbWl0X2luX2NvbHVtbnMpOworCXJldHVybiBncmFwaF9udW1fZGFzaGVkX3BhcmVudHMoZ3JhcGgpICogMjsKK30KKworc3RhdGljIGludCBncmFwaF9uZWVkc19wcmVfY29tbWl0X2xpbmUoc3RydWN0IGdpdF9ncmFwaCAqZ3JhcGgpCit7CisJcmV0dXJuIGdyYXBoLT5udW1fcGFyZW50cyA+PSAzICYmCisJICAgICAgIGdyYXBoLT5jb21taXRfaW5kZXggPCAoZ3JhcGgtPm51bV9jb2x1bW5zIC0gMSkgJiYKKwkgICAgICAgZ3JhcGgtPmV4cGFuc2lvbl9yb3cgPCBncmFwaF9udW1fZXhwYW5zaW9uX3Jvd3MoZ3JhcGgpOwogfQogCiB2b2lkIGdyYXBoX3VwZGF0ZShzdHJ1Y3QgZ2l0X2dyYXBoICpncmFwaCwgc3RydWN0IGNvbW1pdCAqY29tbWl0KQpAQCAtNjU3LDggKzc3Niw3IEBACiAJICovCiAJaWYgKGdyYXBoLT5zdGF0ZSAhPSBHUkFQSF9QQURESU5HKQogCQlncmFwaC0+c3RhdGUgPSBHUkFQSF9TS0lQOwotCWVsc2UgaWYgKGdyYXBoLT5udW1fcGFyZW50cyA+PSAzICYmCi0JCSBncmFwaC0+Y29tbWl0X2luZGV4IDwgKGdyYXBoLT5udW1fY29sdW1ucyAtIDEpKQorCWVsc2UgaWYgKGdyYXBoX25lZWRzX3ByZV9jb21taXRfbGluZShncmFwaCkpCiAJCWdyYXBoLT5zdGF0ZSA9IEdSQVBIX1BSRV9DT01NSVQ7CiAJZWxzZQogCQlncmFwaC0+c3RhdGUgPSBHUkFQSF9DT01NSVQ7CkBAIC02ODYsOCArODA0LDcgQEAKIAlyZXR1cm4gMTsKIH0KIAotc3RhdGljIHZvaWQgZ3JhcGhfcGFkX2hvcml6b250YWxseShzdHJ1Y3QgZ2l0X2dyYXBoICpncmFwaCwgc3RydWN0IHN0cmJ1ZiAqc2IsCi0JCQkJICAgaW50IGNoYXJzX3dyaXR0ZW4pCitzdGF0aWMgdm9pZCBncmFwaF9wYWRfaG9yaXpvbnRhbGx5KHN0cnVjdCBnaXRfZ3JhcGggKmdyYXBoLCBzdHJ1Y3QgZ3JhcGhfbGluZSAqbGluZSkKIHsKIAkvKgogCSAqIEFkZCBhZGRpdGlvbmFsIHNwYWNlcyB0byB0aGUgZW5kIG9mIHRoZSBzdHJidWYsIHNvIHRoYXQgYWxsCkBAIC02OTYsMzQgKzgxMywyMiBAQAogCSAqIFRoaXMgd2F5LCBmaWVsZHMgcHJpbnRlZCB0byB0aGUgcmlnaHQgb2YgdGhlIGdyYXBoIHdpbGwgcmVtYWluCiAJICogYWxpZ25lZCBmb3IgdGhlIGVudGlyZSBjb21taXQuCiAJICovCi0JaWYgKGNoYXJzX3dyaXR0ZW4gPCBncmFwaC0+d2lkdGgpCi0JCXN0cmJ1Zl9hZGRjaGFycyhzYiwgJyAnLCBncmFwaC0+d2lkdGggLSBjaGFyc193cml0dGVuKTsKKwlpZiAobGluZS0+d2lkdGggPCBncmFwaC0+d2lkdGgpCisJCWdyYXBoX2xpbmVfYWRkY2hhcnMobGluZSwgJyAnLCBncmFwaC0+d2lkdGggLSBsaW5lLT53aWR0aCk7CiB9CiAKIHN0YXRpYyB2b2lkIGdyYXBoX291dHB1dF9wYWRkaW5nX2xpbmUoc3RydWN0IGdpdF9ncmFwaCAqZ3JhcGgsCi0JCQkJICAgICAgc3RydWN0IHN0cmJ1ZiAqc2IpCisJCQkJICAgICAgc3RydWN0IGdyYXBoX2xpbmUgKmxpbmUpCiB7CiAJaW50IGk7CiAKIAkvKgotCSAqIFdlIGNvdWxkIGNvbmNlaXZhYmxlIGJlIGNhbGxlZCB3aXRoIGEgTlVMTCBjb21taXQKLQkgKiBpZiBvdXIgY2FsbGVyIGhhcyBhIGJ1ZywgYW5kIGludm9rZXMgZ3JhcGhfbmV4dF9saW5lKCkKLQkgKiBpbW1lZGlhdGVseSBhZnRlciBncmFwaF9pbml0KCksIHdpdGhvdXQgZmlyc3QgY2FsbGluZwotCSAqIGdyYXBoX3VwZGF0ZSgpLiAgUmV0dXJuIHdpdGhvdXQgb3V0cHV0dGluZyBhbnl0aGluZyBpbiB0aGlzCi0JICogY2FzZS4KLQkgKi8KLQlpZiAoIWdyYXBoLT5jb21taXQpCi0JCXJldHVybjsKLQotCS8qCiAJICogT3V0cHV0IGEgcGFkZGluZyByb3csIHRoYXQgbGVhdmVzIGFsbCBicmFuY2ggbGluZXMgdW5jaGFuZ2VkCiAJICovCiAJZm9yIChpID0gMDsgaSA8IGdyYXBoLT5udW1fbmV3X2NvbHVtbnM7IGkrKykgewotCQlzdHJidWZfd3JpdGVfY29sdW1uKHNiLCAmZ3JhcGgtPm5ld19jb2x1bW5zW2ldLCAnfCcpOwotCQlzdHJidWZfYWRkY2goc2IsICcgJyk7CisJCWdyYXBoX2xpbmVfd3JpdGVfY29sdW1uKGxpbmUsICZncmFwaC0+bmV3X2NvbHVtbnNbaV0sICd8Jyk7CisJCWdyYXBoX2xpbmVfYWRkY2gobGluZSwgJyAnKTsKIAl9Ci0KLQlncmFwaF9wYWRfaG9yaXpvbnRhbGx5KGdyYXBoLCBzYiwgZ3JhcGgtPm51bV9uZXdfY29sdW1ucyAqIDIpOwogfQogCiAKQEAgLTczMywyOCArODM4LDI0IEBACiB9CiAKIAotc3RhdGljIHZvaWQgZ3JhcGhfb3V0cHV0X3NraXBfbGluZShzdHJ1Y3QgZ2l0X2dyYXBoICpncmFwaCwgc3RydWN0IHN0cmJ1ZiAqc2IpCitzdGF0aWMgdm9pZCBncmFwaF9vdXRwdXRfc2tpcF9saW5lKHN0cnVjdCBnaXRfZ3JhcGggKmdyYXBoLCBzdHJ1Y3QgZ3JhcGhfbGluZSAqbGluZSkKIHsKIAkvKgogCSAqIE91dHB1dCBhbiBlbGxpcHNpcyB0byBpbmRpY2F0ZSB0aGF0IGEgcG9ydGlvbgogCSAqIG9mIHRoZSBncmFwaCBpcyBtaXNzaW5nLgogCSAqLwotCXN0cmJ1Zl9hZGRzdHIoc2IsICIuLi4iKTsKLQlncmFwaF9wYWRfaG9yaXpvbnRhbGx5KGdyYXBoLCBzYiwgMyk7CisJZ3JhcGhfbGluZV9hZGRzdHIobGluZSwgIi4uLiIpOwogCi0JaWYgKGdyYXBoLT5udW1fcGFyZW50cyA+PSAzICYmCi0JICAgIGdyYXBoLT5jb21taXRfaW5kZXggPCAoZ3JhcGgtPm51bV9jb2x1bW5zIC0gMSkpCisJaWYgKGdyYXBoX25lZWRzX3ByZV9jb21taXRfbGluZShncmFwaCkpCiAJCWdyYXBoX3VwZGF0ZV9zdGF0ZShncmFwaCwgR1JBUEhfUFJFX0NPTU1JVCk7CiAJZWxzZQogCQlncmFwaF91cGRhdGVfc3RhdGUoZ3JhcGgsIEdSQVBIX0NPTU1JVCk7CiB9CiAKIHN0YXRpYyB2b2lkIGdyYXBoX291dHB1dF9wcmVfY29tbWl0X2xpbmUoc3RydWN0IGdpdF9ncmFwaCAqZ3JhcGgsCi0JCQkJCSBzdHJ1Y3Qgc3RyYnVmICpzYikKKwkJCQkJIHN0cnVjdCBncmFwaF9saW5lICpsaW5lKQogewotCWludCBudW1fZXhwYW5zaW9uX3Jvd3M7CiAJaW50IGksIHNlZW5fdGhpczsKLQlpbnQgY2hhcnNfd3JpdHRlbjsKIAogCS8qCiAJICogVGhpcyBmdW5jdGlvbiBmb3JtYXRzIGEgcm93IHRoYXQgaW5jcmVhc2VzIHRoZSBzcGFjZSBhcm91bmQgYSBjb21taXQKQEAgLTc2NCwyNyArODY1LDI0IEBACiAJICogV2UgbmVlZCAyIGV4dHJhIHJvd3MgZm9yIGV2ZXJ5IHBhcmVudCBvdmVyIDIuCiAJICovCiAJYXNzZXJ0KGdyYXBoLT5udW1fcGFyZW50cyA+PSAzKTsKLQludW1fZXhwYW5zaW9uX3Jvd3MgPSAoZ3JhcGgtPm51bV9wYXJlbnRzIC0gMikgKiAyOwogCiAJLyoKIAkgKiBncmFwaC0+ZXhwYW5zaW9uX3JvdyB0cmFja3MgdGhlIGN1cnJlbnQgZXhwYW5zaW9uIHJvdyB3ZSBhcmUgb24uCiAJICogSXQgc2hvdWxkIGJlIGluIHRoZSByYW5nZSBbMCwgbnVtX2V4cGFuc2lvbl9yb3dzIC0gMV0KIAkgKi8KIAlhc3NlcnQoMCA8PSBncmFwaC0+ZXhwYW5zaW9uX3JvdyAmJgotCSAgICAgICBncmFwaC0+ZXhwYW5zaW9uX3JvdyA8IG51bV9leHBhbnNpb25fcm93cyk7CisJICAgICAgIGdyYXBoLT5leHBhbnNpb25fcm93IDwgZ3JhcGhfbnVtX2V4cGFuc2lvbl9yb3dzKGdyYXBoKSk7CiAKIAkvKgogCSAqIE91dHB1dCB0aGUgcm93CiAJICovCiAJc2Vlbl90aGlzID0gMDsKLQljaGFyc193cml0dGVuID0gMDsKIAlmb3IgKGkgPSAwOyBpIDwgZ3JhcGgtPm51bV9jb2x1bW5zOyBpKyspIHsKIAkJc3RydWN0IGNvbHVtbiAqY29sID0gJmdyYXBoLT5jb2x1bW5zW2ldOwogCQlpZiAoY29sLT5jb21taXQgPT0gZ3JhcGgtPmNvbW1pdCkgewogCQkJc2Vlbl90aGlzID0gMTsKLQkJCXN0cmJ1Zl93cml0ZV9jb2x1bW4oc2IsIGNvbCwgJ3wnKTsKLQkJCXN0cmJ1Zl9hZGRjaGFycyhzYiwgJyAnLCBncmFwaC0+ZXhwYW5zaW9uX3Jvdyk7Ci0JCQljaGFyc193cml0dGVuICs9IDEgKyBncmFwaC0+ZXhwYW5zaW9uX3JvdzsKKwkJCWdyYXBoX2xpbmVfd3JpdGVfY29sdW1uKGxpbmUsIGNvbCwgJ3wnKTsKKwkJCWdyYXBoX2xpbmVfYWRkY2hhcnMobGluZSwgJyAnLCBncmFwaC0+ZXhwYW5zaW9uX3Jvdyk7CiAJCX0gZWxzZSBpZiAoc2Vlbl90aGlzICYmIChncmFwaC0+ZXhwYW5zaW9uX3JvdyA9PSAwKSkgewogCQkJLyoKIAkJCSAqIFRoaXMgaXMgdGhlIGZpcnN0IGxpbmUgb2YgdGhlIHByZS1jb21taXQgb3V0cHV0LgpAQCAtNzk3LDMzICs4OTUsMjcgQEAKIAkJCSAqLwogCQkJaWYgKGdyYXBoLT5wcmV2X3N0YXRlID09IEdSQVBIX1BPU1RfTUVSR0UgJiYKIAkJCSAgICBncmFwaC0+cHJldl9jb21taXRfaW5kZXggPCBpKQotCQkJCXN0cmJ1Zl93cml0ZV9jb2x1bW4oc2IsIGNvbCwgJ1xcJyk7CisJCQkJZ3JhcGhfbGluZV93cml0ZV9jb2x1bW4obGluZSwgY29sLCAnXFwnKTsKIAkJCWVsc2UKLQkJCQlzdHJidWZfd3JpdGVfY29sdW1uKHNiLCBjb2wsICd8Jyk7Ci0JCQljaGFyc193cml0dGVuKys7CisJCQkJZ3JhcGhfbGluZV93cml0ZV9jb2x1bW4obGluZSwgY29sLCAnfCcpOwogCQl9IGVsc2UgaWYgKHNlZW5fdGhpcyAmJiAoZ3JhcGgtPmV4cGFuc2lvbl9yb3cgPiAwKSkgewotCQkJc3RyYnVmX3dyaXRlX2NvbHVtbihzYiwgY29sLCAnXFwnKTsKLQkJCWNoYXJzX3dyaXR0ZW4rKzsKKwkJCWdyYXBoX2xpbmVfd3JpdGVfY29sdW1uKGxpbmUsIGNvbCwgJ1xcJyk7CiAJCX0gZWxzZSB7Ci0JCQlzdHJidWZfd3JpdGVfY29sdW1uKHNiLCBjb2wsICd8Jyk7Ci0JCQljaGFyc193cml0dGVuKys7CisJCQlncmFwaF9saW5lX3dyaXRlX2NvbHVtbihsaW5lLCBjb2wsICd8Jyk7CiAJCX0KLQkJc3RyYnVmX2FkZGNoKHNiLCAnICcpOwotCQljaGFyc193cml0dGVuKys7CisJCWdyYXBoX2xpbmVfYWRkY2gobGluZSwgJyAnKTsKIAl9CiAKLQlncmFwaF9wYWRfaG9yaXpvbnRhbGx5KGdyYXBoLCBzYiwgY2hhcnNfd3JpdHRlbik7Ci0KIAkvKgogCSAqIEluY3JlbWVudCBncmFwaC0+ZXhwYW5zaW9uX3JvdywKIAkgKiBhbmQgbW92ZSB0byBzdGF0ZSBHUkFQSF9DT01NSVQgaWYgbmVjZXNzYXJ5CiAJICovCiAJZ3JhcGgtPmV4cGFuc2lvbl9yb3crKzsKLQlpZiAoZ3JhcGgtPmV4cGFuc2lvbl9yb3cgPj0gbnVtX2V4cGFuc2lvbl9yb3dzKQorCWlmICghZ3JhcGhfbmVlZHNfcHJlX2NvbW1pdF9saW5lKGdyYXBoKSkKIAkJZ3JhcGhfdXBkYXRlX3N0YXRlKGdyYXBoLCBHUkFQSF9DT01NSVQpOwogfQogCi1zdGF0aWMgdm9pZCBncmFwaF9vdXRwdXRfY29tbWl0X2NoYXIoc3RydWN0IGdpdF9ncmFwaCAqZ3JhcGgsIHN0cnVjdCBzdHJidWYgKnNiKQorc3RhdGljIHZvaWQgZ3JhcGhfb3V0cHV0X2NvbW1pdF9jaGFyKHN0cnVjdCBnaXRfZ3JhcGggKmdyYXBoLCBzdHJ1Y3QgZ3JhcGhfbGluZSAqbGluZSkKIHsKIAkvKgogCSAqIEZvciBib3VuZGFyeSBjb21taXRzLCBwcmludCAnbycKQEAgLTgzMSw3MiArOTIzLDY3IEBACiAJICovCiAJaWYgKGdyYXBoLT5jb21taXQtPm9iamVjdC5mbGFncyAmIEJPVU5EQVJZKSB7CiAJCWFzc2VydChncmFwaC0+cmV2cy0+Ym91bmRhcnkpOwotCQlzdHJidWZfYWRkY2goc2IsICdvJyk7CisJCWdyYXBoX2xpbmVfYWRkY2gobGluZSwgJ28nKTsKIAkJcmV0dXJuOwogCX0KIAogCS8qCiAJICogZ2V0X3JldmlzaW9uX21hcmsoKSBoYW5kbGVzIGFsbCBvdGhlciBjYXNlcyB3aXRob3V0IGFzc2VydCgpCiAJICovCi0Jc3RyYnVmX2FkZHN0cihzYiwgZ2V0X3JldmlzaW9uX21hcmsoZ3JhcGgtPnJldnMsIGdyYXBoLT5jb21taXQpKTsKKwlncmFwaF9saW5lX2FkZHN0cihsaW5lLCBnZXRfcmV2aXNpb25fbWFyayhncmFwaC0+cmV2cywgZ3JhcGgtPmNvbW1pdCkpOwogfQogCiAvKgotICogRHJhdyB0aGUgaG9yaXpvbnRhbCBkYXNoZXMgb2YgYW4gb2N0b3B1cyBtZXJnZSBhbmQgcmV0dXJuIHRoZSBudW1iZXIgb2YKLSAqIGNoYXJhY3RlcnMgd3JpdHRlbi4KKyAqIERyYXcgdGhlIGhvcml6b250YWwgZGFzaGVzIG9mIGFuIG9jdG9wdXMgbWVyZ2UuCiAgKi8KLXN0YXRpYyBpbnQgZ3JhcGhfZHJhd19vY3RvcHVzX21lcmdlKHN0cnVjdCBnaXRfZ3JhcGggKmdyYXBoLAotCQkJCSAgICBzdHJ1Y3Qgc3RyYnVmICpzYikKK3N0YXRpYyB2b2lkIGdyYXBoX2RyYXdfb2N0b3B1c19tZXJnZShzdHJ1Y3QgZ2l0X2dyYXBoICpncmFwaCwgc3RydWN0IGdyYXBoX2xpbmUgKmxpbmUpCiB7CiAJLyoKLQkgKiBIZXJlIGRhc2hsZXNzX3BhcmVudHMgcmVwcmVzZW50cyB0aGUgbnVtYmVyIG9mIHBhcmVudHMgd2hpY2ggZG9uJ3QKLQkgKiBuZWVkIHRvIGhhdmUgZGFzaGVzICh0aGUgZWRnZXMgbGFiZWxlZCAiMCIgYW5kICIxIikuICBBbmQKLQkgKiBkYXNoZnVsX3BhcmVudHMgYXJlIHRoZSByZW1haW5pbmcgb25lcy4KKwkgKiBUaGUgcGFyZW50cyBvZiBhIG1lcmdlIGNvbW1pdCBjYW4gYmUgYXJiaXRyYXJpbHkgcmVvcmRlcmVkIGFzIHRoZXkKKwkgKiBhcmUgbWFwcGVkIG9udG8gZGlzcGxheSBjb2x1bW5zLCBmb3IgZXhhbXBsZSB0aGlzIGlzIGEgdmFsaWQgbWVyZ2U6CiAJICoKLQkgKiB8ICotLS0uCi0JICogfCB8XCBcIFwKLQkgKiB8IHwgfCB8IHwKLQkgKiB4IDAgMSAyIDMKKwkgKgl8IHwgKi0tLS4KKwkgKgl8IHwgfFwgXCBcCisJICoJfCB8IHwvIC8gLworCSAqCXwgfC98IHwgLworCSAqCXwgfF98X3wvCisJICoJfC98IHwgfAorCSAqCTMgMSAwIDIKIAkgKgorCSAqIFRoZSBudW1iZXJzIGRlbm90ZSB3aGljaCBwYXJlbnQgb2YgdGhlIG1lcmdlIGVhY2ggdmlzdWFsIGNvbHVtbgorCSAqIGNvcnJlc3BvbmRzIHRvOyB3ZSBjYW4ndCBhc3N1bWUgdGhhdCB0aGUgcGFyZW50cyB3aWxsIGluaXRpYWxseQorCSAqIGRpc3BsYXkgaW4gdGhlIG9yZGVyIGdpdmVuIGJ5IG5ld19jb2x1bW5zLgorCSAqCisJICogVG8gZmluZCB0aGUgcmlnaHQgY29sb3IgZm9yIGVhY2ggZGFzaCwgd2UgbmVlZCB0byBjb25zdWx0IHRoZQorCSAqIG1hcHBpbmcgYXJyYXksIHN0YXJ0aW5nIGZyb20gdGhlIGNvbHVtbiAyIHBsYWNlcyB0byB0aGUgcmlnaHQgb2YgdGhlCisJICogbWVyZ2UgY29tbWl0LCBhbmQgdXNlIHRoYXQgdG8gZmluZCBvdXQgd2hpY2ggbG9naWNhbCBjb2x1bW4gZWFjaAorCSAqIGVkZ2Ugd2lsbCBjb2xsYXBzZSB0by4KKwkgKgorCSAqIENvbW1pdHMgYXJlIHJlbmRlcmVkIG9uY2UgYWxsIGVkZ2VzIGhhdmUgY29sbGFwc2VkIHRvIHRoZWlyIGNvcnJlY3QKKwkgKiBsb2djaWFsIGNvbHVtbiwgc28gY29tbWl0X2luZGV4IGdpdmVzIHVzIHRoZSByaWdodCB2aXN1YWwgb2Zmc2V0IGZvcgorCSAqIHRoZSBtZXJnZSBjb21taXQuCiAJICovCi0JY29uc3QgaW50IGRhc2hsZXNzX3BhcmVudHMgPSAyOwotCWludCBkYXNoZnVsX3BhcmVudHMgPSBncmFwaC0+bnVtX3BhcmVudHMgLSBkYXNobGVzc19wYXJlbnRzOwogCi0JLyoKLQkgKiBVc3VhbGx5LCB3ZSBhZGQgb25lIG5ldyBjb2x1bW4gZm9yIGVhY2ggcGFyZW50IChsaWtlIHRoZSBkaWFncmFtCi0JICogYWJvdmUpIGJ1dCBzb21ldGltZXMgdGhlIGZpcnN0IHBhcmVudCBnb2VzIGludG8gYW4gZXhpc3RpbmcgY29sdW1uLAotCSAqIGxpa2UgdGhpczoKLQkgKgotCSAqIHwgKi0tLS4KLQkgKiB8IHxcIFwgXAotCSAqIHwvIC8gLyAvCi0JICogeCAwIDEgMgotCSAqCi0JICogSW4gd2hpY2ggY2FzZSB0aGUgbnVtYmVyIG9mIHBhcmVudHMgd2lsbCBiZSBvbmUgZ3JlYXRlciB0aGFuIHRoZQotCSAqIG51bWJlciBvZiBhZGRlZCBjb2x1bW5zLgotCSAqLwotCWludCBhZGRlZF9jb2xzID0gKGdyYXBoLT5udW1fbmV3X2NvbHVtbnMgLSBncmFwaC0+bnVtX2NvbHVtbnMpOwotCWludCBwYXJlbnRfaW5fb2xkX2NvbHMgPSBncmFwaC0+bnVtX3BhcmVudHMgLSBhZGRlZF9jb2xzOworCWludCBpLCBqOworCXN0cnVjdCBjb2x1bW4gKmNvbDsKIAotCS8qCi0JICogSW4gYm90aCBjYXNlcywgY29tbWl0X2luZGV4IGNvcnJlc3BvbmRzIHRvIHRoZSBlZGdlIGxhYmVsZWQgIjAiLgotCSAqLwotCWludCBmaXJzdF9jb2wgPSBncmFwaC0+Y29tbWl0X2luZGV4ICsgZGFzaGxlc3NfcGFyZW50cwotCSAgICAtIHBhcmVudF9pbl9vbGRfY29sczsKKwlpbnQgZGFzaGVkX3BhcmVudHMgPSBncmFwaF9udW1fZGFzaGVkX3BhcmVudHMoZ3JhcGgpOwogCi0JaW50IGk7Ci0JZm9yIChpID0gMDsgaSA8IGRhc2hmdWxfcGFyZW50czsgaSsrKSB7Ci0JCXN0cmJ1Zl93cml0ZV9jb2x1bW4oc2IsICZncmFwaC0+bmV3X2NvbHVtbnNbaStmaXJzdF9jb2xdLCAnLScpOwotCQlzdHJidWZfd3JpdGVfY29sdW1uKHNiLCAmZ3JhcGgtPm5ld19jb2x1bW5zW2krZmlyc3RfY29sXSwKLQkJCQkgICAgaSA9PSBkYXNoZnVsX3BhcmVudHMtMSA/ICcuJyA6ICctJyk7CisJZm9yIChpID0gMDsgaSA8IGRhc2hlZF9wYXJlbnRzOyBpKyspIHsKKwkJaiA9IGdyYXBoLT5tYXBwaW5nWyhncmFwaC0+Y29tbWl0X2luZGV4ICsgaSArIDIpICogMl07CisJCWNvbCA9ICZncmFwaC0+bmV3X2NvbHVtbnNbal07CisKKwkJZ3JhcGhfbGluZV93cml0ZV9jb2x1bW4obGluZSwgY29sLCAnLScpOworCQlncmFwaF9saW5lX3dyaXRlX2NvbHVtbihsaW5lLCBjb2wsIChpID09IGRhc2hlZF9wYXJlbnRzIC0gMSkgPyAnLicgOiAnLScpOwogCX0KLQlyZXR1cm4gMiAqIGRhc2hmdWxfcGFyZW50czsKKworCXJldHVybjsKIH0KIAotc3RhdGljIHZvaWQgZ3JhcGhfb3V0cHV0X2NvbW1pdF9saW5lKHN0cnVjdCBnaXRfZ3JhcGggKmdyYXBoLCBzdHJ1Y3Qgc3RyYnVmICpzYikKK3N0YXRpYyB2b2lkIGdyYXBoX291dHB1dF9jb21taXRfbGluZShzdHJ1Y3QgZ2l0X2dyYXBoICpncmFwaCwgc3RydWN0IGdyYXBoX2xpbmUgKmxpbmUpCiB7CiAJaW50IHNlZW5fdGhpcyA9IDA7Ci0JaW50IGksIGNoYXJzX3dyaXR0ZW47CisJaW50IGk7CiAKIAkvKgogCSAqIE91dHB1dCB0aGUgcm93IGNvbnRhaW5pbmcgdGhpcyBjb21taXQKQEAgLTkwNiw3ICs5OTMsNiBAQAogCSAqIGNoaWxkcmVuIHRoYXQgd2UgaGF2ZSBhbHJlYWR5IHByb2Nlc3NlZC4pCiAJICovCiAJc2Vlbl90aGlzID0gMDsKLQljaGFyc193cml0dGVuID0gMDsKIAlmb3IgKGkgPSAwOyBpIDw9IGdyYXBoLT5udW1fY29sdW1uczsgaSsrKSB7CiAJCXN0cnVjdCBjb2x1bW4gKmNvbCA9ICZncmFwaC0+Y29sdW1uc1tpXTsKIAkJc3RydWN0IGNvbW1pdCAqY29sX2NvbW1pdDsKQEAgLTkyMCwxOSArMTAwNiwxNyBAQAogCiAJCWlmIChjb2xfY29tbWl0ID09IGdyYXBoLT5jb21taXQpIHsKIAkJCXNlZW5fdGhpcyA9IDE7Ci0JCQlncmFwaF9vdXRwdXRfY29tbWl0X2NoYXIoZ3JhcGgsIHNiKTsKLQkJCWNoYXJzX3dyaXR0ZW4rKzsKKwkJCWdyYXBoX291dHB1dF9jb21taXRfY2hhcihncmFwaCwgbGluZSk7CiAKIAkJCWlmIChncmFwaC0+bnVtX3BhcmVudHMgPiAyKQotCQkJCWNoYXJzX3dyaXR0ZW4gKz0gZ3JhcGhfZHJhd19vY3RvcHVzX21lcmdlKGdyYXBoLAotCQkJCQkJCQkJICBzYik7Ci0JCX0gZWxzZSBpZiAoc2Vlbl90aGlzICYmIChncmFwaC0+bnVtX3BhcmVudHMgPiAyKSkgewotCQkJc3RyYnVmX3dyaXRlX2NvbHVtbihzYiwgY29sLCAnXFwnKTsKLQkJCWNoYXJzX3dyaXR0ZW4rKzsKLQkJfSBlbHNlIGlmIChzZWVuX3RoaXMgJiYgKGdyYXBoLT5udW1fcGFyZW50cyA9PSAyKSkgeworCQkJCWdyYXBoX2RyYXdfb2N0b3B1c19tZXJnZShncmFwaCwgbGluZSk7CisJCX0gZWxzZSBpZiAoc2Vlbl90aGlzICYmIChncmFwaC0+ZWRnZXNfYWRkZWQgPiAxKSkgeworCQkJZ3JhcGhfbGluZV93cml0ZV9jb2x1bW4obGluZSwgY29sLCAnXFwnKTsKKwkJfSBlbHNlIGlmIChzZWVuX3RoaXMgJiYgKGdyYXBoLT5lZGdlc19hZGRlZCA9PSAxKSkgewogCQkJLyoKLQkJCSAqIFRoaXMgaXMgYSAyLXdheSBtZXJnZSBjb21taXQuCi0JCQkgKiBUaGVyZSBpcyBubyBHUkFQSF9QUkVfQ09NTUlUIHN0YWdlIGZvciAyLXdheQorCQkJICogVGhpcyBpcyBlaXRoZXIgYSByaWdodC1za2V3ZWQgMi13YXkgbWVyZ2UKKwkJCSAqIGNvbW1pdCwgb3IgYSBsZWZ0LXNrZXdlZCAzLXdheSBtZXJnZS4KKwkJCSAqIFRoZXJlIGlzIG5vIEdSQVBIX1BSRV9DT01NSVQgc3RhZ2UgZm9yIHN1Y2gKIAkJCSAqIG1lcmdlcywgc28gdGhpcyBpcyB0aGUgZmlyc3QgbGluZSBvZiBvdXRwdXQKIAkJCSAqIGZvciB0aGlzIGNvbW1pdC4gIENoZWNrIHRvIHNlZSB3aGF0IHRoZSBwcmV2aW91cwogCQkJICogbGluZSBvZiBvdXRwdXQgd2FzLgpAQCAtOTQ0LDIxICsxMDI4LDIxIEBACiAJCQkgKiBtYWtlcyB0aGUgb3V0cHV0IGxvb2sgbmljZXIuCiAJCQkgKi8KIAkJCWlmIChncmFwaC0+cHJldl9zdGF0ZSA9PSBHUkFQSF9QT1NUX01FUkdFICYmCisJCQkgICAgZ3JhcGgtPnByZXZfZWRnZXNfYWRkZWQgPiAwICYmCiAJCQkgICAgZ3JhcGgtPnByZXZfY29tbWl0X2luZGV4IDwgaSkKLQkJCQlzdHJidWZfd3JpdGVfY29sdW1uKHNiLCBjb2wsICdcXCcpOworCQkJCWdyYXBoX2xpbmVfd3JpdGVfY29sdW1uKGxpbmUsIGNvbCwgJ1xcJyk7CiAJCQllbHNlCi0JCQkJc3RyYnVmX3dyaXRlX2NvbHVtbihzYiwgY29sLCAnfCcpOwotCQkJY2hhcnNfd3JpdHRlbisrOworCQkJCWdyYXBoX2xpbmVfd3JpdGVfY29sdW1uKGxpbmUsIGNvbCwgJ3wnKTsKKwkJfSBlbHNlIGlmIChncmFwaC0+cHJldl9zdGF0ZSA9PSBHUkFQSF9DT0xMQVBTSU5HICYmCisJCQkgICBncmFwaC0+b2xkX21hcHBpbmdbMiAqIGkgKyAxXSA9PSBpICYmCisJCQkgICBncmFwaC0+bWFwcGluZ1syICogaV0gPCBpKSB7CisJCQlncmFwaF9saW5lX3dyaXRlX2NvbHVtbihsaW5lLCBjb2wsICcvJyk7CiAJCX0gZWxzZSB7Ci0JCQlzdHJidWZfd3JpdGVfY29sdW1uKHNiLCBjb2wsICd8Jyk7Ci0JCQljaGFyc193cml0dGVuKys7CisJCQlncmFwaF9saW5lX3dyaXRlX2NvbHVtbihsaW5lLCBjb2wsICd8Jyk7CiAJCX0KLQkJc3RyYnVmX2FkZGNoKHNiLCAnICcpOwotCQljaGFyc193cml0dGVuKys7CisJCWdyYXBoX2xpbmVfYWRkY2gobGluZSwgJyAnKTsKIAl9CiAKLQlncmFwaF9wYWRfaG9yaXpvbnRhbGx5KGdyYXBoLCBzYiwgY2hhcnNfd3JpdHRlbik7Ci0KIAkvKgogCSAqIFVwZGF0ZSBncmFwaC0+c3RhdGUKIAkgKi8KQEAgLTk3MCwyNiArMTA1NCwxOSBAQAogCQlncmFwaF91cGRhdGVfc3RhdGUoZ3JhcGgsIEdSQVBIX0NPTExBUFNJTkcpOwogfQogCi1zdGF0aWMgc3RydWN0IGNvbHVtbiAqZmluZF9uZXdfY29sdW1uX2J5X2NvbW1pdChzdHJ1Y3QgZ2l0X2dyYXBoICpncmFwaCwKLQkJCQkJCXN0cnVjdCBjb21taXQgKmNvbW1pdCkKLXsKLQlpbnQgaTsKLQlmb3IgKGkgPSAwOyBpIDwgZ3JhcGgtPm51bV9uZXdfY29sdW1uczsgaSsrKSB7Ci0JCWlmIChncmFwaC0+bmV3X2NvbHVtbnNbaV0uY29tbWl0ID09IGNvbW1pdCkKLQkJCXJldHVybiAmZ3JhcGgtPm5ld19jb2x1bW5zW2ldOwotCX0KLQlyZXR1cm4gTlVMTDsKLX0KK2NvbnN0IGNoYXIgbWVyZ2VfY2hhcnNbXSA9IHsnLycsICd8JywgJ1xcJ307CiAKLXN0YXRpYyB2b2lkIGdyYXBoX291dHB1dF9wb3N0X21lcmdlX2xpbmUoc3RydWN0IGdpdF9ncmFwaCAqZ3JhcGgsIHN0cnVjdCBzdHJidWYgKnNiKQorc3RhdGljIHZvaWQgZ3JhcGhfb3V0cHV0X3Bvc3RfbWVyZ2VfbGluZShzdHJ1Y3QgZ2l0X2dyYXBoICpncmFwaCwgc3RydWN0IGdyYXBoX2xpbmUgKmxpbmUpCiB7CiAJaW50IHNlZW5fdGhpcyA9IDA7Ci0JaW50IGksIGosIGNoYXJzX3dyaXR0ZW47CisJaW50IGksIGo7CisKKwlzdHJ1Y3QgY29tbWl0X2xpc3QgKmZpcnN0X3BhcmVudCA9IGZpcnN0X2ludGVyZXN0aW5nX3BhcmVudChncmFwaCk7CisJaW50IHNlZW5fcGFyZW50ID0gMDsKIAogCS8qCiAJICogT3V0cHV0IHRoZSBwb3N0LW1lcmdlIHJvdwogCSAqLwotCWNoYXJzX3dyaXR0ZW4gPSAwOwogCWZvciAoaSA9IDA7IGkgPD0gZ3JhcGgtPm51bV9jb2x1bW5zOyBpKyspIHsKIAkJc3RydWN0IGNvbHVtbiAqY29sID0gJmdyYXBoLT5jb2x1bW5zW2ldOwogCQlzdHJ1Y3QgY29tbWl0ICpjb2xfY29tbWl0OwpAQCAtMTAwOCwzNyArMTA4NSw0NCBAQAogCQkJICogbmV3X2NvbHVtbnMgYW5kIHVzZSB0aG9zZSB0byBmb3JtYXQgdGhlCiAJCQkgKiBlZGdlcy4KIAkJCSAqLwotCQkJc3RydWN0IGNvbW1pdF9saXN0ICpwYXJlbnRzID0gTlVMTDsKLQkJCXN0cnVjdCBjb2x1bW4gKnBhcl9jb2x1bW47CisJCQlzdHJ1Y3QgY29tbWl0X2xpc3QgKnBhcmVudHMgPSBmaXJzdF9wYXJlbnQ7CisJCQlpbnQgcGFyX2NvbHVtbjsKKwkJCWludCBpZHggPSBncmFwaC0+bWVyZ2VfbGF5b3V0OworCQkJY2hhciBjOwogCQkJc2Vlbl90aGlzID0gMTsKLQkJCXBhcmVudHMgPSBmaXJzdF9pbnRlcmVzdGluZ19wYXJlbnQoZ3JhcGgpOwotCQkJYXNzZXJ0KHBhcmVudHMpOwotCQkJcGFyX2NvbHVtbiA9IGZpbmRfbmV3X2NvbHVtbl9ieV9jb21taXQoZ3JhcGgsIHBhcmVudHMtPml0ZW0pOwotCQkJYXNzZXJ0KHBhcl9jb2x1bW4pOwogCi0JCQlzdHJidWZfd3JpdGVfY29sdW1uKHNiLCBwYXJfY29sdW1uLCAnfCcpOwotCQkJY2hhcnNfd3JpdHRlbisrOwotCQkJZm9yIChqID0gMDsgaiA8IGdyYXBoLT5udW1fcGFyZW50cyAtIDE7IGorKykgeworCQkJZm9yIChqID0gMDsgaiA8IGdyYXBoLT5udW1fcGFyZW50czsgaisrKSB7CisJCQkJcGFyX2NvbHVtbiA9IGdyYXBoX2ZpbmRfbmV3X2NvbHVtbl9ieV9jb21taXQoZ3JhcGgsIHBhcmVudHMtPml0ZW0pOworCQkJCWFzc2VydChwYXJfY29sdW1uID49IDApOworCisJCQkJYyA9IG1lcmdlX2NoYXJzW2lkeF07CisJCQkJZ3JhcGhfbGluZV93cml0ZV9jb2x1bW4obGluZSwgJmdyYXBoLT5uZXdfY29sdW1uc1twYXJfY29sdW1uXSwgYyk7CisJCQkJaWYgKGlkeCA9PSAyKSB7CisJCQkJCWlmIChncmFwaC0+ZWRnZXNfYWRkZWQgPiAwIHx8IGogPCBncmFwaC0+bnVtX3BhcmVudHMgLSAxKQorCQkJCQkJZ3JhcGhfbGluZV9hZGRjaChsaW5lLCAnICcpOworCQkJCX0gZWxzZSB7CisJCQkJCWlkeCsrOworCQkJCX0KIAkJCQlwYXJlbnRzID0gbmV4dF9pbnRlcmVzdGluZ19wYXJlbnQoZ3JhcGgsIHBhcmVudHMpOwotCQkJCWFzc2VydChwYXJlbnRzKTsKLQkJCQlwYXJfY29sdW1uID0gZmluZF9uZXdfY29sdW1uX2J5X2NvbW1pdChncmFwaCwgcGFyZW50cy0+aXRlbSk7Ci0JCQkJYXNzZXJ0KHBhcl9jb2x1bW4pOwotCQkJCXN0cmJ1Zl93cml0ZV9jb2x1bW4oc2IsIHBhcl9jb2x1bW4sICdcXCcpOwotCQkJCXN0cmJ1Zl9hZGRjaChzYiwgJyAnKTsKIAkJCX0KLQkJCWNoYXJzX3dyaXR0ZW4gKz0gaiAqIDI7Ci0JCX0gZWxzZSBpZiAoc2Vlbl90aGlzKSB7Ci0JCQlzdHJidWZfd3JpdGVfY29sdW1uKHNiLCBjb2wsICdcXCcpOwotCQkJc3RyYnVmX2FkZGNoKHNiLCAnICcpOwotCQkJY2hhcnNfd3JpdHRlbiArPSAyOwotCQl9IGVsc2UgewotCQkJc3RyYnVmX3dyaXRlX2NvbHVtbihzYiwgY29sLCAnfCcpOwotCQkJc3RyYnVmX2FkZGNoKHNiLCAnICcpOwotCQkJY2hhcnNfd3JpdHRlbiArPSAyOwotCQl9Ci0JfQorCQkJaWYgKGdyYXBoLT5lZGdlc19hZGRlZCA9PSAwKQorCQkJCWdyYXBoX2xpbmVfYWRkY2gobGluZSwgJyAnKTsKIAotCWdyYXBoX3BhZF9ob3Jpem9udGFsbHkoZ3JhcGgsIHNiLCBjaGFyc193cml0dGVuKTsKKwkJfSBlbHNlIGlmIChzZWVuX3RoaXMpIHsKKwkJCWlmIChncmFwaC0+ZWRnZXNfYWRkZWQgPiAwKQorCQkJCWdyYXBoX2xpbmVfd3JpdGVfY29sdW1uKGxpbmUsIGNvbCwgJ1xcJyk7CisJCQllbHNlCisJCQkJZ3JhcGhfbGluZV93cml0ZV9jb2x1bW4obGluZSwgY29sLCAnfCcpOworCQkJZ3JhcGhfbGluZV9hZGRjaChsaW5lLCAnICcpOworCQl9IGVsc2UgeworCQkJZ3JhcGhfbGluZV93cml0ZV9jb2x1bW4obGluZSwgY29sLCAnfCcpOworCQkJaWYgKGdyYXBoLT5tZXJnZV9sYXlvdXQgIT0gMCB8fCBpICE9IGdyYXBoLT5jb21taXRfaW5kZXggLSAxKQorCQkJCWdyYXBoX2xpbmVfYWRkY2gobGluZSwgc2Vlbl9wYXJlbnQgPyAnXycgOiAnICcpOworCQl9CisKKwkJaWYgKGNvbF9jb21taXQgPT0gZmlyc3RfcGFyZW50LT5pdGVtKQorCQkJc2Vlbl9wYXJlbnQgPSAxOworCX0KIAogCS8qCiAJICogVXBkYXRlIGdyYXBoLT5zdGF0ZQpAQCAtMTA0OSw3ICsxMTMzLDcgQEAKIAkJZ3JhcGhfdXBkYXRlX3N0YXRlKGdyYXBoLCBHUkFQSF9DT0xMQVBTSU5HKTsKIH0KIAotc3RhdGljIHZvaWQgZ3JhcGhfb3V0cHV0X2NvbGxhcHNpbmdfbGluZShzdHJ1Y3QgZ2l0X2dyYXBoICpncmFwaCwgc3RydWN0IHN0cmJ1ZiAqc2IpCitzdGF0aWMgdm9pZCBncmFwaF9vdXRwdXRfY29sbGFwc2luZ19saW5lKHN0cnVjdCBnaXRfZ3JhcGggKmdyYXBoLCBzdHJ1Y3QgZ3JhcGhfbGluZSAqbGluZSkKIHsKIAlpbnQgaTsKIAlzaG9ydCB1c2VkX2hvcml6b250YWwgPSAwOwpAQCAtMTA1NywxMyArMTE0MSwxOCBAQAogCWludCBob3Jpem9udGFsX2VkZ2VfdGFyZ2V0ID0gLTE7CiAKIAkvKgotCSAqIENsZWFyIG91dCB0aGUgbmV3X21hcHBpbmcgYXJyYXkKKwkgKiBTd2FwIHRoZSBtYXBwaW5nIGFuZCBvbGRfbWFwcGluZyBhcnJheXMKKwkgKi8KKwlTV0FQKGdyYXBoLT5tYXBwaW5nLCBncmFwaC0+b2xkX21hcHBpbmcpOworCisJLyoKKwkgKiBDbGVhciBvdXQgdGhlIG1hcHBpbmcgYXJyYXkKIAkgKi8KIAlmb3IgKGkgPSAwOyBpIDwgZ3JhcGgtPm1hcHBpbmdfc2l6ZTsgaSsrKQotCQlncmFwaC0+bmV3X21hcHBpbmdbaV0gPSAtMTsKKwkJZ3JhcGgtPm1hcHBpbmdbaV0gPSAtMTsKIAogCWZvciAoaSA9IDA7IGkgPCBncmFwaC0+bWFwcGluZ19zaXplOyBpKyspIHsKLQkJaW50IHRhcmdldCA9IGdyYXBoLT5tYXBwaW5nW2ldOworCQlpbnQgdGFyZ2V0ID0gZ3JhcGgtPm9sZF9tYXBwaW5nW2ldOwogCQlpZiAodGFyZ2V0IDwgMCkKIAkJCWNvbnRpbnVlOwogCkBAIC0xMDg0LDE0ICsxMTczLDE0IEBACiAJCQkgKiBUaGlzIGNvbHVtbiBpcyBhbHJlYWR5IGluIHRoZQogCQkJICogY29ycmVjdCBwbGFjZQogCQkJICovCi0JCQlhc3NlcnQoZ3JhcGgtPm5ld19tYXBwaW5nW2ldID09IC0xKTsKLQkJCWdyYXBoLT5uZXdfbWFwcGluZ1tpXSA9IHRhcmdldDsKLQkJfSBlbHNlIGlmIChncmFwaC0+bmV3X21hcHBpbmdbaSAtIDFdIDwgMCkgeworCQkJYXNzZXJ0KGdyYXBoLT5tYXBwaW5nW2ldID09IC0xKTsKKwkJCWdyYXBoLT5tYXBwaW5nW2ldID0gdGFyZ2V0OworCQl9IGVsc2UgaWYgKGdyYXBoLT5tYXBwaW5nW2kgLSAxXSA8IDApIHsKIAkJCS8qCiAJCQkgKiBOb3RoaW5nIGlzIHRvIHRoZSBsZWZ0LgogCQkJICogTW92ZSB0byB0aGUgbGVmdCBieSBvbmUKIAkJCSAqLwotCQkJZ3JhcGgtPm5ld19tYXBwaW5nW2kgLSAxXSA9IHRhcmdldDsKKwkJCWdyYXBoLT5tYXBwaW5nW2kgLSAxXSA9IHRhcmdldDsKIAkJCS8qCiAJCQkgKiBJZiB0aGVyZSBpc24ndCBhbHJlYWR5IGFuIGVkZ2UgbW92aW5nIGhvcml6b250YWxseQogCQkJICogc2VsZWN0IHRoaXMgb25lLgpAQCAtMTEwNyw5ICsxMTk2LDkgQEAKIAkJCQkgKiBsaW5lLgogCQkJCSAqLwogCQkJCWZvciAoaiA9ICh0YXJnZXQgKiAyKSszOyBqIDwgKGkgLSAyKTsgaiArPSAyKQotCQkJCQlncmFwaC0+bmV3X21hcHBpbmdbal0gPSB0YXJnZXQ7CisJCQkJCWdyYXBoLT5tYXBwaW5nW2pdID0gdGFyZ2V0OwogCQkJfQotCQl9IGVsc2UgaWYgKGdyYXBoLT5uZXdfbWFwcGluZ1tpIC0gMV0gPT0gdGFyZ2V0KSB7CisJCX0gZWxzZSBpZiAoZ3JhcGgtPm1hcHBpbmdbaSAtIDFdID09IHRhcmdldCkgewogCQkJLyoKIAkJCSAqIFRoZXJlIGlzIGEgYnJhbmNoIGxpbmUgdG8gb3VyIGxlZnQKIAkJCSAqIGFscmVhZHksIGFuZCBpdCBpcyBvdXIgdGFyZ2V0LiAgV2UKQEAgLTExMTcsNyArMTIwNiw3IEBACiAJCQkgKiB0aGUgc2FtZSBwYXJlbnQgY29tbWl0LgogCQkJICoKIAkJCSAqIFdlIGRvbid0IGhhdmUgdG8gYWRkIGFueXRoaW5nIHRvIHRoZQotCQkJICogb3V0cHV0IG9yIG5ld19tYXBwaW5nLCBzaW5jZSB0aGUKKwkJCSAqIG91dHB1dCBvciBtYXBwaW5nLCBzaW5jZSB0aGUKIAkJCSAqIGV4aXN0aW5nIGJyYW5jaCBsaW5lIGhhcyBhbHJlYWR5IHRha2VuCiAJCQkgKiBjYXJlIG9mIGl0LgogCQkJICovCkBAIC0xMTMzLDEwICsxMjIyLDEwIEBACiAJCQkgKiBUaGUgYnJhbmNoIHRvIHRoZSBsZWZ0IG9mIHRoYXQgc3BhY2UKIAkJCSAqIHNob3VsZCBiZSBvdXIgZXZlbnR1YWwgdGFyZ2V0LgogCQkJICovCi0JCQlhc3NlcnQoZ3JhcGgtPm5ld19tYXBwaW5nW2kgLSAxXSA+IHRhcmdldCk7Ci0JCQlhc3NlcnQoZ3JhcGgtPm5ld19tYXBwaW5nW2kgLSAyXSA8IDApOwotCQkJYXNzZXJ0KGdyYXBoLT5uZXdfbWFwcGluZ1tpIC0gM10gPT0gdGFyZ2V0KTsKLQkJCWdyYXBoLT5uZXdfbWFwcGluZ1tpIC0gMl0gPSB0YXJnZXQ7CisJCQlhc3NlcnQoZ3JhcGgtPm1hcHBpbmdbaSAtIDFdID4gdGFyZ2V0KTsKKwkJCWFzc2VydChncmFwaC0+bWFwcGluZ1tpIC0gMl0gPCAwKTsKKwkJCWFzc2VydChncmFwaC0+bWFwcGluZ1tpIC0gM10gPT0gdGFyZ2V0KTsKKwkJCWdyYXBoLT5tYXBwaW5nW2kgLSAyXSA9IHRhcmdldDsKIAkJCS8qCiAJCQkgKiBNYXJrIHRoaXMgYnJhbmNoIGFzIHRoZSBob3Jpem9udGFsIGVkZ2UgdG8KIAkJCSAqIHByZXZlbnQgYW55IG90aGVyIGVkZ2VzIGZyb20gbW92aW5nCkBAIC0xMTQ4LDIwICsxMjM3LDI1IEBACiAJfQogCiAJLyoKKwkgKiBDb3B5IHRoZSBjdXJyZW50IG1hcHBpbmcgYXJyYXkgaW50byBvbGRfbWFwcGluZworCSAqLworCUNPUFlfQVJSQVkoZ3JhcGgtPm9sZF9tYXBwaW5nLCBncmFwaC0+bWFwcGluZywgZ3JhcGgtPm1hcHBpbmdfc2l6ZSk7CisKKwkvKgogCSAqIFRoZSBuZXcgbWFwcGluZyBtYXkgYmUgMSBzbWFsbGVyIHRoYW4gdGhlIG9sZCBtYXBwaW5nCiAJICovCi0JaWYgKGdyYXBoLT5uZXdfbWFwcGluZ1tncmFwaC0+bWFwcGluZ19zaXplIC0gMV0gPCAwKQorCWlmIChncmFwaC0+bWFwcGluZ1tncmFwaC0+bWFwcGluZ19zaXplIC0gMV0gPCAwKQogCQlncmFwaC0+bWFwcGluZ19zaXplLS07CiAKIAkvKgogCSAqIE91dHB1dCBvdXQgYSBsaW5lIGJhc2VkIG9uIHRoZSBuZXcgbWFwcGluZyBpbmZvCiAJICovCiAJZm9yIChpID0gMDsgaSA8IGdyYXBoLT5tYXBwaW5nX3NpemU7IGkrKykgewotCQlpbnQgdGFyZ2V0ID0gZ3JhcGgtPm5ld19tYXBwaW5nW2ldOworCQlpbnQgdGFyZ2V0ID0gZ3JhcGgtPm1hcHBpbmdbaV07CiAJCWlmICh0YXJnZXQgPCAwKQotCQkJc3RyYnVmX2FkZGNoKHNiLCAnICcpOworCQkJZ3JhcGhfbGluZV9hZGRjaChsaW5lLCAnICcpOwogCQllbHNlIGlmICh0YXJnZXQgKiAyID09IGkpCi0JCQlzdHJidWZfd3JpdGVfY29sdW1uKHNiLCAmZ3JhcGgtPm5ld19jb2x1bW5zW3RhcmdldF0sICd8Jyk7CisJCQlncmFwaF9saW5lX3dyaXRlX2NvbHVtbihsaW5lLCAmZ3JhcGgtPm5ld19jb2x1bW5zW3RhcmdldF0sICd8Jyk7CiAJCWVsc2UgaWYgKHRhcmdldCA9PSBob3Jpem9udGFsX2VkZ2VfdGFyZ2V0ICYmCiAJCQkgaSAhPSBob3Jpem9udGFsX2VkZ2UgLSAxKSB7CiAJCQkJLyoKQEAgLTExNzAsMjQgKzEyNjQsMTcgQEAKIAkJCQkgKiB3b24ndCBjb250aW51ZSBpbnRvIHRoZSBuZXh0IGxpbmUuCiAJCQkJICovCiAJCQkJaWYgKGkgIT0gKHRhcmdldCAqIDIpKzMpCi0JCQkJCWdyYXBoLT5uZXdfbWFwcGluZ1tpXSA9IC0xOworCQkJCQlncmFwaC0+bWFwcGluZ1tpXSA9IC0xOwogCQkJCXVzZWRfaG9yaXpvbnRhbCA9IDE7Ci0JCQlzdHJidWZfd3JpdGVfY29sdW1uKHNiLCAmZ3JhcGgtPm5ld19jb2x1bW5zW3RhcmdldF0sICdfJyk7CisJCQlncmFwaF9saW5lX3dyaXRlX2NvbHVtbihsaW5lLCAmZ3JhcGgtPm5ld19jb2x1bW5zW3RhcmdldF0sICdfJyk7CiAJCX0gZWxzZSB7CiAJCQlpZiAodXNlZF9ob3Jpem9udGFsICYmIGkgPCBob3Jpem9udGFsX2VkZ2UpCi0JCQkJZ3JhcGgtPm5ld19tYXBwaW5nW2ldID0gLTE7Ci0JCQlzdHJidWZfd3JpdGVfY29sdW1uKHNiLCAmZ3JhcGgtPm5ld19jb2x1bW5zW3RhcmdldF0sICcvJyk7CisJCQkJZ3JhcGgtPm1hcHBpbmdbaV0gPSAtMTsKKwkJCWdyYXBoX2xpbmVfd3JpdGVfY29sdW1uKGxpbmUsICZncmFwaC0+bmV3X2NvbHVtbnNbdGFyZ2V0XSwgJy8nKTsKIAogCQl9CiAJfQogCi0JZ3JhcGhfcGFkX2hvcml6b250YWxseShncmFwaCwgc2IsIGdyYXBoLT5tYXBwaW5nX3NpemUpOwotCi0JLyoKLQkgKiBTd2FwIG1hcHBpbmcgYW5kIG5ld19tYXBwaW5nCi0JICovCi0JU1dBUChncmFwaC0+bWFwcGluZywgZ3JhcGgtPm5ld19tYXBwaW5nKTsKLQogCS8qCiAJICogSWYgZ3JhcGgtPm1hcHBpbmcgaW5kaWNhdGVzIHRoYXQgYWxsIG9mIHRoZSBicmFuY2ggbGluZXMKIAkgKiBhcmUgYWxyZWFkeSBpbiB0aGUgY29ycmVjdCBwb3NpdGlvbnMsIHdlIGFyZSBkb25lLgpAQCAtMTE5OSwzNSArMTI4Niw0OSBAQAogCiBpbnQgZ3JhcGhfbmV4dF9saW5lKHN0cnVjdCBnaXRfZ3JhcGggKmdyYXBoLCBzdHJ1Y3Qgc3RyYnVmICpzYikKIHsKKwlpbnQgc2hvd25fY29tbWl0X2xpbmUgPSAwOworCXN0cnVjdCBncmFwaF9saW5lIGxpbmUgPSB7IC5idWYgPSBzYiwgLndpZHRoID0gMCB9OworCisJLyoKKwkgKiBXZSBjb3VsZCBjb25jZWl2YWJsZSBiZSBjYWxsZWQgd2l0aCBhIE5VTEwgY29tbWl0CisJICogaWYgb3VyIGNhbGxlciBoYXMgYSBidWcsIGFuZCBpbnZva2VzIGdyYXBoX25leHRfbGluZSgpCisJICogaW1tZWRpYXRlbHkgYWZ0ZXIgZ3JhcGhfaW5pdCgpLCB3aXRob3V0IGZpcnN0IGNhbGxpbmcKKwkgKiBncmFwaF91cGRhdGUoKS4gIFJldHVybiB3aXRob3V0IG91dHB1dHRpbmcgYW55dGhpbmcgaW4gdGhpcworCSAqIGNhc2UuCisJICovCisJaWYgKCFncmFwaC0+Y29tbWl0KQorCQlyZXR1cm4gLTE7CisKIAlzd2l0Y2ggKGdyYXBoLT5zdGF0ZSkgewogCWNhc2UgR1JBUEhfUEFERElORzoKLQkJZ3JhcGhfb3V0cHV0X3BhZGRpbmdfbGluZShncmFwaCwgc2IpOwotCQlyZXR1cm4gMDsKKwkJZ3JhcGhfb3V0cHV0X3BhZGRpbmdfbGluZShncmFwaCwgJmxpbmUpOworCQlicmVhazsKIAljYXNlIEdSQVBIX1NLSVA6Ci0JCWdyYXBoX291dHB1dF9za2lwX2xpbmUoZ3JhcGgsIHNiKTsKLQkJcmV0dXJuIDA7CisJCWdyYXBoX291dHB1dF9za2lwX2xpbmUoZ3JhcGgsICZsaW5lKTsKKwkJYnJlYWs7CiAJY2FzZSBHUkFQSF9QUkVfQ09NTUlUOgotCQlncmFwaF9vdXRwdXRfcHJlX2NvbW1pdF9saW5lKGdyYXBoLCBzYik7Ci0JCXJldHVybiAwOworCQlncmFwaF9vdXRwdXRfcHJlX2NvbW1pdF9saW5lKGdyYXBoLCAmbGluZSk7CisJCWJyZWFrOwogCWNhc2UgR1JBUEhfQ09NTUlUOgotCQlncmFwaF9vdXRwdXRfY29tbWl0X2xpbmUoZ3JhcGgsIHNiKTsKLQkJcmV0dXJuIDE7CisJCWdyYXBoX291dHB1dF9jb21taXRfbGluZShncmFwaCwgJmxpbmUpOworCQlzaG93bl9jb21taXRfbGluZSA9IDE7CisJCWJyZWFrOwogCWNhc2UgR1JBUEhfUE9TVF9NRVJHRToKLQkJZ3JhcGhfb3V0cHV0X3Bvc3RfbWVyZ2VfbGluZShncmFwaCwgc2IpOwotCQlyZXR1cm4gMDsKKwkJZ3JhcGhfb3V0cHV0X3Bvc3RfbWVyZ2VfbGluZShncmFwaCwgJmxpbmUpOworCQlicmVhazsKIAljYXNlIEdSQVBIX0NPTExBUFNJTkc6Ci0JCWdyYXBoX291dHB1dF9jb2xsYXBzaW5nX2xpbmUoZ3JhcGgsIHNiKTsKLQkJcmV0dXJuIDA7CisJCWdyYXBoX291dHB1dF9jb2xsYXBzaW5nX2xpbmUoZ3JhcGgsICZsaW5lKTsKKwkJYnJlYWs7CiAJfQogCi0JYXNzZXJ0KDApOwotCXJldHVybiAwOworCWdyYXBoX3BhZF9ob3Jpem9udGFsbHkoZ3JhcGgsICZsaW5lKTsKKwlyZXR1cm4gc2hvd25fY29tbWl0X2xpbmU7CiB9CiAKIHN0YXRpYyB2b2lkIGdyYXBoX3BhZGRpbmdfbGluZShzdHJ1Y3QgZ2l0X2dyYXBoICpncmFwaCwgc3RydWN0IHN0cmJ1ZiAqc2IpCiB7CiAJaW50IGk7Ci0JaW50IGNoYXJzX3dyaXR0ZW4gPSAwOworCXN0cnVjdCBncmFwaF9saW5lIGxpbmUgPSB7IC5idWYgPSBzYiwgLndpZHRoID0gMCB9OwogCiAJaWYgKGdyYXBoLT5zdGF0ZSAhPSBHUkFQSF9DT01NSVQpIHsKIAkJZ3JhcGhfbmV4dF9saW5lKGdyYXBoLCBzYik7CkBAIC0xMjQ0LDIwICsxMzQ1LDE3IEBACiAJZm9yIChpID0gMDsgaSA8IGdyYXBoLT5udW1fY29sdW1uczsgaSsrKSB7CiAJCXN0cnVjdCBjb2x1bW4gKmNvbCA9ICZncmFwaC0+Y29sdW1uc1tpXTsKIAotCQlzdHJidWZfd3JpdGVfY29sdW1uKHNiLCBjb2wsICd8Jyk7Ci0JCWNoYXJzX3dyaXR0ZW4rKzsKKwkJZ3JhcGhfbGluZV93cml0ZV9jb2x1bW4oJmxpbmUsIGNvbCwgJ3wnKTsKIAogCQlpZiAoY29sLT5jb21taXQgPT0gZ3JhcGgtPmNvbW1pdCAmJiBncmFwaC0+bnVtX3BhcmVudHMgPiAyKSB7CiAJCQlpbnQgbGVuID0gKGdyYXBoLT5udW1fcGFyZW50cyAtIDIpICogMjsKLQkJCXN0cmJ1Zl9hZGRjaGFycyhzYiwgJyAnLCBsZW4pOwotCQkJY2hhcnNfd3JpdHRlbiArPSBsZW47CisJCQlncmFwaF9saW5lX2FkZGNoYXJzKCZsaW5lLCAnICcsIGxlbik7CiAJCX0gZWxzZSB7Ci0JCQlzdHJidWZfYWRkY2goc2IsICcgJyk7Ci0JCQljaGFyc193cml0dGVuKys7CisJCQlncmFwaF9saW5lX2FkZGNoKCZsaW5lLCAnICcpOwogCQl9CiAJfQogCi0JZ3JhcGhfcGFkX2hvcml6b250YWxseShncmFwaCwgc2IsIGNoYXJzX3dyaXR0ZW4pOworCWdyYXBoX3BhZF9ob3Jpem9udGFsbHkoZ3JhcGgsICZsaW5lKTsKIAogCS8qCiAJICogVXBkYXRlIGdyYXBoLT5wcmV2X3N0YXRlIHNpbmNlIHdlIGhhdmUgb3V0cHV0IGEgcGFkZGluZyBsaW5lCmRpZmYgLS1naXQgYS9ncmVwLmMgYi9ncmVwLmMKaW5kZXggY2Q5NTJlZi4uYjdhZTVhNCAxMDA2NDQKLS0tIGEvZ3JlcC5jCisrKyBiL2dyZXAuYwpAQCAtMTYsNiArMTYsMjAgQEAKIAogc3RhdGljIHN0cnVjdCBncmVwX29wdCBncmVwX2RlZmF1bHRzOwogCisjaWZkZWYgVVNFX0xJQlBDUkUyCitzdGF0aWMgcGNyZTJfZ2VuZXJhbF9jb250ZXh0ICpwY3JlMl9nbG9iYWxfY29udGV4dDsKKworc3RhdGljIHZvaWQgKnBjcmUyX21hbGxvYyhQQ1JFMl9TSVpFIHNpemUsIE1BWUJFX1VOVVNFRCB2b2lkICptZW1vcnlfZGF0YSkKK3sKKwlyZXR1cm4gbWFsbG9jKHNpemUpOworfQorCitzdGF0aWMgdm9pZCBwY3JlMl9mcmVlKHZvaWQgKnBvaW50ZXIsIE1BWUJFX1VOVVNFRCB2b2lkICptZW1vcnlfZGF0YSkKK3sKKwlyZXR1cm4gZnJlZShwb2ludGVyKTsKK30KKyNlbmRpZgorCiBzdGF0aWMgY29uc3QgY2hhciAqY29sb3JfZ3JlcF9zbG90c1tdID0gewogCVtHUkVQX0NPTE9SX0NPTlRFWFRdCSAgICA9ICJjb250ZXh0IiwKIAlbR1JFUF9DT0xPUl9GSUxFTkFNRV0JICAgID0gImZpbGVuYW1lIiwKQEAgLTE1MCwxMiArMTY0LDI4IEBACiAgKiBJbml0aWFsaXplIG9uZSBpbnN0YW5jZSBvZiBncmVwX29wdCBhbmQgY29weSB0aGUKICAqIGRlZmF1bHQgdmFsdWVzIGZyb20gdGhlIHRlbXBsYXRlIHdlIHJlYWQgdGhlIGNvbmZpZ3VyYXRpb24KICAqIGluZm9ybWF0aW9uIGluIGFuIGVhcmxpZXIgY2FsbCB0byBnaXRfY29uZmlnKGdyZXBfY29uZmlnKS4KKyAqCisgKiBJZiB1c2luZyBQQ1JFLCBtYWtlIHN1cmUgdGhhdCB0aGUgbGlicmFyeSBpcyBjb25maWd1cmVkCisgKiB0byB1c2UgdGhlIHNhbWUgYWxsb2NhdG9yIGFzIEdpdCAoZS5nLiBuZWRtYWxsb2Mgb24gV2luZG93cykuCisgKgorICogQW55IGFsbG9jYXRlZCBtZW1vcnkgbmVlZHMgdG8gYmUgcmVsZWFzZWQgaW4gZ3JlcF9kZXN0cm95KCkuCiAgKi8KIHZvaWQgZ3JlcF9pbml0KHN0cnVjdCBncmVwX29wdCAqb3B0LCBzdHJ1Y3QgcmVwb3NpdG9yeSAqcmVwbywgY29uc3QgY2hhciAqcHJlZml4KQogewogCXN0cnVjdCBncmVwX29wdCAqZGVmID0gJmdyZXBfZGVmYXVsdHM7CiAJaW50IGk7CiAKKyNpZiBkZWZpbmVkKFVTRV9MSUJQQ1JFMikKKwlpZiAoIXBjcmUyX2dsb2JhbF9jb250ZXh0KQorCQlwY3JlMl9nbG9iYWxfY29udGV4dCA9IHBjcmUyX2dlbmVyYWxfY29udGV4dF9jcmVhdGUoCisJCQkJCXBjcmUyX21hbGxvYywgcGNyZTJfZnJlZSwgTlVMTCk7CisjZW5kaWYKKworI2lmZGVmIFVTRV9MSUJQQ1JFMQorCXBjcmVfbWFsbG9jID0gbWFsbG9jOworCXBjcmVfZnJlZSA9IGZyZWU7CisjZW5kaWYKKwogCW1lbXNldChvcHQsIDAsIHNpemVvZigqb3B0KSk7CiAJb3B0LT5yZXBvID0gcmVwbzsKIAlvcHQtPnByZWZpeCA9IHByZWZpeDsKQEAgLTE3OCw2ICsyMDgsMTMgQEAKIAkJY29sb3Jfc2V0KG9wdC0+Y29sb3JzW2ldLCBkZWYtPmNvbG9yc1tpXSk7CiB9CiAKK3ZvaWQgZ3JlcF9kZXN0cm95KHZvaWQpCit7CisjaWZkZWYgVVNFX0xJQlBDUkUyCisJcGNyZTJfZ2VuZXJhbF9jb250ZXh0X2ZyZWUocGNyZTJfZ2xvYmFsX2NvbnRleHQpOworI2VuZGlmCit9CisKIHN0YXRpYyB2b2lkIGdyZXBfc2V0X3BhdHRlcm5fdHlwZV9vcHRpb24oZW51bSBncmVwX3BhdHRlcm5fdHlwZSBwYXR0ZXJuX3R5cGUsIHN0cnVjdCBncmVwX29wdCAqb3B0KQogewogCS8qCkBAIC0zNjgsMzEgKzQwNSwyMCBAQAogCXJldHVybiAxOwogfQogCi1zdGF0aWMgaW50IGhhc19udWxsKGNvbnN0IGNoYXIgKnMsIHNpemVfdCBsZW4pCi17Ci0JLyoKLQkgKiByZWdjb21wIGNhbm5vdCBhY2NlcHQgcGF0dGVybnMgd2l0aCBOVUxzIHNvIHdoZW4gdXNpbmcgaXQKLQkgKiB3ZSBjb25zaWRlciBhbnkgcGF0dGVybiBjb250YWluaW5nIGEgTlVMIGZpeGVkLgotCSAqLwotCWlmIChtZW1jaHIocywgMCwgbGVuKSkKLQkJcmV0dXJuIDE7Ci0KLQlyZXR1cm4gMDsKLX0KLQogI2lmZGVmIFVTRV9MSUJQQ1JFMQogc3RhdGljIHZvaWQgY29tcGlsZV9wY3JlMV9yZWdleHAoc3RydWN0IGdyZXBfcGF0ICpwLCBjb25zdCBzdHJ1Y3QgZ3JlcF9vcHQgKm9wdCkKIHsKIAljb25zdCBjaGFyICplcnJvcjsKIAlpbnQgZXJyb2Zmc2V0OwogCWludCBvcHRpb25zID0gUENSRV9NVUxUSUxJTkU7CisJaW50IHN0dWR5X29wdGlvbnMgPSAwOwogCiAJaWYgKG9wdC0+aWdub3JlX2Nhc2UpIHsKLQkJaWYgKGhhc19ub25fYXNjaWkocC0+cGF0dGVybikpCisJCWlmICghb3B0LT5pZ25vcmVfbG9jYWxlICYmIGhhc19ub25fYXNjaWkocC0+cGF0dGVybikpCiAJCQlwLT5wY3JlMV90YWJsZXMgPSBwY3JlX21ha2V0YWJsZXMoKTsKIAkJb3B0aW9ucyB8PSBQQ1JFX0NBU0VMRVNTOwogCX0KLQlpZiAoaXNfdXRmOF9sb2NhbGUoKSAmJiBoYXNfbm9uX2FzY2lpKHAtPnBhdHRlcm4pKQorCWlmICghb3B0LT5pZ25vcmVfbG9jYWxlICYmIGlzX3V0ZjhfbG9jYWxlKCkgJiYgaGFzX25vbl9hc2NpaShwLT5wYXR0ZXJuKSkKIAkJb3B0aW9ucyB8PSBQQ1JFX1VURjg7CiAKIAlwLT5wY3JlMV9yZWdleHAgPSBwY3JlX2NvbXBpbGUocC0+cGF0dGVybiwgb3B0aW9ucywgJmVycm9yLCAmZXJyb2Zmc2V0LApAQCAtNDAwLDQ0ICs0MjYsMzEgQEAKIAlpZiAoIXAtPnBjcmUxX3JlZ2V4cCkKIAkJY29tcGlsZV9yZWdleHBfZmFpbGVkKHAsIGVycm9yKTsKIAotCXAtPnBjcmUxX2V4dHJhX2luZm8gPSBwY3JlX3N0dWR5KHAtPnBjcmUxX3JlZ2V4cCwgR0lUX1BDUkVfU1RVRFlfSklUX0NPTVBJTEUsICZlcnJvcik7CisjaWYgZGVmaW5lZChQQ1JFX0NPTkZJR19KSVQpICYmICFkZWZpbmVkKE5PX0xJQlBDUkUxX0pJVCkKKwlwY3JlX2NvbmZpZyhQQ1JFX0NPTkZJR19KSVQsICZwLT5wY3JlMV9qaXRfb24pOworCWlmIChvcHQtPmRlYnVnKQorCQlmcHJpbnRmKHN0ZGVyciwgInBjcmUxX2ppdF9vbj0lZFxuIiwgcC0+cGNyZTFfaml0X29uKTsKKworCWlmIChwLT5wY3JlMV9qaXRfb24pCisJCXN0dWR5X29wdGlvbnMgPSBQQ1JFX1NUVURZX0pJVF9DT01QSUxFOworI2VuZGlmCisKKwlwLT5wY3JlMV9leHRyYV9pbmZvID0gcGNyZV9zdHVkeShwLT5wY3JlMV9yZWdleHAsIHN0dWR5X29wdGlvbnMsICZlcnJvcik7CiAJaWYgKCFwLT5wY3JlMV9leHRyYV9pbmZvICYmIGVycm9yKQogCQlkaWUoIiVzIiwgZXJyb3IpOwotCi0jaWZkZWYgR0lUX1BDUkUxX1VTRV9KSVQKLQlwY3JlX2NvbmZpZyhQQ1JFX0NPTkZJR19KSVQsICZwLT5wY3JlMV9qaXRfb24pOwotCWlmIChwLT5wY3JlMV9qaXRfb24gPT0gMSkgewotCQlwLT5wY3JlMV9qaXRfc3RhY2sgPSBwY3JlX2ppdF9zdGFja19hbGxvYygxLCAxMDI0ICogMTAyNCk7Ci0JCWlmICghcC0+cGNyZTFfaml0X3N0YWNrKQotCQkJZGllKCJDb3VsZG4ndCBhbGxvY2F0ZSBQQ1JFIEpJVCBzdGFjayIpOwotCQlwY3JlX2Fzc2lnbl9qaXRfc3RhY2socC0+cGNyZTFfZXh0cmFfaW5mbywgTlVMTCwgcC0+cGNyZTFfaml0X3N0YWNrKTsKLQl9IGVsc2UgaWYgKHAtPnBjcmUxX2ppdF9vbiAhPSAwKSB7Ci0JCUJVRygiVGhlIHBjcmUxX2ppdF9vbiB2YXJpYWJsZSBzaG91bGQgYmUgMCBvciAxLCBub3QgJWQiLAotCQkgICAgcC0+cGNyZTFfaml0X29uKTsKLQl9Ci0jZW5kaWYKIH0KIAogc3RhdGljIGludCBwY3JlMW1hdGNoKHN0cnVjdCBncmVwX3BhdCAqcCwgY29uc3QgY2hhciAqbGluZSwgY29uc3QgY2hhciAqZW9sLAogCQlyZWdtYXRjaF90ICptYXRjaCwgaW50IGVmbGFncykKIHsKLQlpbnQgb3ZlY3RvclszMF0sIHJldCwgZmxhZ3MgPSAwOworCWludCBvdmVjdG9yWzMwXSwgcmV0LCBmbGFncyA9IFBDUkVfTk9fVVRGOF9DSEVDSzsKIAogCWlmIChlZmxhZ3MgJiBSRUdfTk9UQk9MKQogCQlmbGFncyB8PSBQQ1JFX05PVEJPTDsKIAotI2lmZGVmIEdJVF9QQ1JFMV9VU0VfSklUCi0JaWYgKHAtPnBjcmUxX2ppdF9vbikgewotCQlyZXQgPSBwY3JlX2ppdF9leGVjKHAtPnBjcmUxX3JlZ2V4cCwgcC0+cGNyZTFfZXh0cmFfaW5mbywgbGluZSwKLQkJCQkgICAgZW9sIC0gbGluZSwgMCwgZmxhZ3MsIG92ZWN0b3IsCi0JCQkJICAgIEFSUkFZX1NJWkUob3ZlY3RvciksIHAtPnBjcmUxX2ppdF9zdGFjayk7Ci0JfSBlbHNlCi0jZW5kaWYKLQl7Ci0JCXJldCA9IHBjcmVfZXhlYyhwLT5wY3JlMV9yZWdleHAsIHAtPnBjcmUxX2V4dHJhX2luZm8sIGxpbmUsCi0JCQkJZW9sIC0gbGluZSwgMCwgZmxhZ3MsIG92ZWN0b3IsCi0JCQkJQVJSQVlfU0laRShvdmVjdG9yKSk7Ci0JfQorCXJldCA9IHBjcmVfZXhlYyhwLT5wY3JlMV9yZWdleHAsIHAtPnBjcmUxX2V4dHJhX2luZm8sIGxpbmUsCisJCQllb2wgLSBsaW5lLCAwLCBmbGFncywgb3ZlY3RvciwKKwkJCUFSUkFZX1NJWkUob3ZlY3RvcikpOwogCiAJaWYgKHJldCA8IDAgJiYgcmV0ICE9IFBDUkVfRVJST1JfTk9NQVRDSCkKIAkJZGllKCJwY3JlX2V4ZWMgZmFpbGVkIHdpdGggZXJyb3IgY29kZSAlZCIsIHJldCk7CkBAIC00NTMsMTUgKzQ2NiwxMiBAQAogc3RhdGljIHZvaWQgZnJlZV9wY3JlMV9yZWdleHAoc3RydWN0IGdyZXBfcGF0ICpwKQogewogCXBjcmVfZnJlZShwLT5wY3JlMV9yZWdleHApOwotI2lmZGVmIEdJVF9QQ1JFMV9VU0VfSklUCi0JaWYgKHAtPnBjcmUxX2ppdF9vbikgeworI2lmZGVmIFBDUkVfQ09ORklHX0pJVAorCWlmIChwLT5wY3JlMV9qaXRfb24pCiAJCXBjcmVfZnJlZV9zdHVkeShwLT5wY3JlMV9leHRyYV9pbmZvKTsKLQkJcGNyZV9qaXRfc3RhY2tfZnJlZShwLT5wY3JlMV9qaXRfc3RhY2spOwotCX0gZWxzZQorCWVsc2UKICNlbmRpZgotCXsKIAkJcGNyZV9mcmVlKHAtPnBjcmUxX2V4dHJhX2luZm8pOwotCX0KIAlwY3JlX2ZyZWUoKHZvaWQgKilwLT5wY3JlMV90YWJsZXMpOwogfQogI2Vsc2UgLyogIVVTRV9MSUJQQ1JFMSAqLwpAQCAtNDg4LDcgKzQ5OCw2IEBACiAJUENSRTJfVUNIQVIgZXJyYnVmWzI1Nl07CiAJUENSRTJfU0laRSBlcnJvZmZzZXQ7CiAJaW50IG9wdGlvbnMgPSBQQ1JFMl9NVUxUSUxJTkU7Ci0JY29uc3QgdWludDhfdCAqY2hhcmFjdGVyX3RhYmxlcyA9IE5VTEw7CiAJaW50IGppdHJldDsKIAlpbnQgcGF0aW5mb3JldDsKIAlzaXplX3Qgaml0c2l6ZWFyZzsKQEAgLTQ5NywxNSArNTA2LDIwIEBACiAKIAlwLT5wY3JlMl9jb21waWxlX2NvbnRleHQgPSBOVUxMOwogCisJLyogcGNyZTJfZ2xvYmFsX2NvbnRleHQgaXMgaW5pdGlhbGl6ZWQgaW4gYXBwZW5kX2dyZXBfcGF0dGVybiAqLwogCWlmIChvcHQtPmlnbm9yZV9jYXNlKSB7Ci0JCWlmIChoYXNfbm9uX2FzY2lpKHAtPnBhdHRlcm4pKSB7Ci0JCQljaGFyYWN0ZXJfdGFibGVzID0gcGNyZTJfbWFrZXRhYmxlcyhOVUxMKTsKKwkJaWYgKCFvcHQtPmlnbm9yZV9sb2NhbGUgJiYgaGFzX25vbl9hc2NpaShwLT5wYXR0ZXJuKSkgeworCQkJaWYgKCFwY3JlMl9nbG9iYWxfY29udGV4dCkKKwkJCQlCVUcoInBjcmUyX2dsb2JhbF9jb250ZXh0IHVuaW5pdGlhbGl6ZWQiKTsKKwkJCXAtPnBjcmUyX3RhYmxlcyA9IHBjcmUyX21ha2V0YWJsZXMocGNyZTJfZ2xvYmFsX2NvbnRleHQpOwogCQkJcC0+cGNyZTJfY29tcGlsZV9jb250ZXh0ID0gcGNyZTJfY29tcGlsZV9jb250ZXh0X2NyZWF0ZShOVUxMKTsKLQkJCXBjcmUyX3NldF9jaGFyYWN0ZXJfdGFibGVzKHAtPnBjcmUyX2NvbXBpbGVfY29udGV4dCwgY2hhcmFjdGVyX3RhYmxlcyk7CisJCQlwY3JlMl9zZXRfY2hhcmFjdGVyX3RhYmxlcyhwLT5wY3JlMl9jb21waWxlX2NvbnRleHQsCisJCQkJCQkJcC0+cGNyZTJfdGFibGVzKTsKIAkJfQogCQlvcHRpb25zIHw9IFBDUkUyX0NBU0VMRVNTOwogCX0KLQlpZiAoaXNfdXRmOF9sb2NhbGUoKSAmJiBoYXNfbm9uX2FzY2lpKHAtPnBhdHRlcm4pKQorCWlmICghb3B0LT5pZ25vcmVfbG9jYWxlICYmIGlzX3V0ZjhfbG9jYWxlKCkgJiYgaGFzX25vbl9hc2NpaShwLT5wYXR0ZXJuKSAmJgorCSAgICAhKCFvcHQtPmlnbm9yZV9jYXNlICYmIChwLT5maXhlZCB8fCBwLT5pc19maXhlZCkpKQogCQlvcHRpb25zIHw9IFBDUkUyX1VURjsKIAogCXAtPnBjcmUyX3BhdHRlcm4gPSBwY3JlMl9jb21waWxlKChQQ1JFMl9TUFRSKXAtPnBhdHRlcm4sCkBAIC01MjIsNyArNTM2LDkgQEAKIAl9CiAKIAlwY3JlMl9jb25maWcoUENSRTJfQ09ORklHX0pJVCwgJnAtPnBjcmUyX2ppdF9vbik7Ci0JaWYgKHAtPnBjcmUyX2ppdF9vbiA9PSAxKSB7CisJaWYgKG9wdC0+ZGVidWcpCisJCWZwcmludGYoc3RkZXJyLCAicGNyZTJfaml0X29uPSVkXG4iLCBwLT5wY3JlMl9qaXRfb24pOworCWlmIChwLT5wY3JlMl9qaXRfb24pIHsKIAkJaml0cmV0ID0gcGNyZTJfaml0X2NvbXBpbGUocC0+cGNyZTJfcGF0dGVybiwgUENSRTJfSklUX0NPTVBMRVRFKTsKIAkJaWYgKGppdHJldCkKIAkJCWRpZSgiQ291bGRuJ3QgSklUIHRoZSBQQ1JFMiBwYXR0ZXJuICclcycsIGdvdCAnJWQnXG4iLCBwLT5wYXR0ZXJuLCBqaXRyZXQpOwpAQCAtNTQ3LDE5ICs1NjMsMTEgQEAKIAkJCUJVRygicGNyZTJfcGF0dGVybl9pbmZvKCkgZmFpbGVkOiAlZCIsIHBhdGluZm9yZXQpOwogCQlpZiAoaml0c2l6ZWFyZyA9PSAwKSB7CiAJCQlwLT5wY3JlMl9qaXRfb24gPSAwOworCQkJaWYgKG9wdC0+ZGVidWcpCisJCQkJZnByaW50ZihzdGRlcnIsICJwY3JlMl9qaXRfb249JWQ6ICgqTk9fSklUKSBpbiByZWdleFxuIiwKKwkJCQkJcC0+cGNyZTJfaml0X29uKTsKIAkJCXJldHVybjsKIAkJfQotCi0JCXAtPnBjcmUyX2ppdF9zdGFjayA9IHBjcmUyX2ppdF9zdGFja19jcmVhdGUoMSwgMTAyNCAqIDEwMjQsIE5VTEwpOwotCQlpZiAoIXAtPnBjcmUyX2ppdF9zdGFjaykKLQkJCWRpZSgiQ291bGRuJ3QgYWxsb2NhdGUgUENSRTIgSklUIHN0YWNrIik7Ci0JCXAtPnBjcmUyX21hdGNoX2NvbnRleHQgPSBwY3JlMl9tYXRjaF9jb250ZXh0X2NyZWF0ZShOVUxMKTsKLQkJaWYgKCFwLT5wY3JlMl9tYXRjaF9jb250ZXh0KQotCQkJZGllKCJDb3VsZG4ndCBhbGxvY2F0ZSBQQ1JFMiBtYXRjaCBjb250ZXh0Iik7Ci0JCXBjcmUyX2ppdF9zdGFja19hc3NpZ24ocC0+cGNyZTJfbWF0Y2hfY29udGV4dCwgTlVMTCwgcC0+cGNyZTJfaml0X3N0YWNrKTsKLQl9IGVsc2UgaWYgKHAtPnBjcmUyX2ppdF9vbiAhPSAwKSB7Ci0JCUJVRygiVGhlIHBjcmUyX2ppdF9vbiB2YXJpYWJsZSBzaG91bGQgYmUgMCBvciAxLCBub3QgJWQiLAotCQkgICAgcC0+cGNyZTJfaml0X29uKTsKIAl9CiB9CiAKQEAgLTYwMyw4ICs2MTEsNyBAQAogCXBjcmUyX2NvbXBpbGVfY29udGV4dF9mcmVlKHAtPnBjcmUyX2NvbXBpbGVfY29udGV4dCk7CiAJcGNyZTJfY29kZV9mcmVlKHAtPnBjcmUyX3BhdHRlcm4pOwogCXBjcmUyX21hdGNoX2RhdGFfZnJlZShwLT5wY3JlMl9tYXRjaF9kYXRhKTsKLQlwY3JlMl9qaXRfc3RhY2tfZnJlZShwLT5wY3JlMl9qaXRfc3RhY2spOwotCXBjcmUyX21hdGNoX2NvbnRleHRfZnJlZShwLT5wY3JlMl9tYXRjaF9jb250ZXh0KTsKKwlmcmVlKCh2b2lkICopcC0+cGNyZTJfdGFibGVzKTsKIH0KICNlbHNlIC8qICFVU0VfTElCUENSRTIgKi8KIHN0YXRpYyB2b2lkIGNvbXBpbGVfcGNyZTJfcGF0dGVybihzdHJ1Y3QgZ3JlcF9wYXQgKnAsIGNvbnN0IHN0cnVjdCBncmVwX29wdCAqb3B0KQpAQCAtNjI2LDcgKzYzMyw2IEBACiBzdGF0aWMgdm9pZCBmcmVlX3BjcmUyX3BhdHRlcm4oc3RydWN0IGdyZXBfcGF0ICpwKQogewogfQotI2VuZGlmIC8qICFVU0VfTElCUENSRTIgKi8KIAogc3RhdGljIHZvaWQgY29tcGlsZV9maXhlZF9yZWdleHAoc3RydWN0IGdyZXBfcGF0ICpwLCBzdHJ1Y3QgZ3JlcF9vcHQgKm9wdCkKIHsKQEAgLTY0Nyw0NiArNjUzLDY2IEBACiAJCWNvbXBpbGVfcmVnZXhwX2ZhaWxlZChwLCBlcnJidWYpOwogCX0KIH0KKyNlbmRpZiAvKiAhVVNFX0xJQlBDUkUyICovCiAKIHN0YXRpYyB2b2lkIGNvbXBpbGVfcmVnZXhwKHN0cnVjdCBncmVwX3BhdCAqcCwgc3RydWN0IGdyZXBfb3B0ICpvcHQpCiB7Ci0JaW50IGFzY2lpX29ubHk7CiAJaW50IGVycjsKIAlpbnQgcmVnZmxhZ3MgPSBSRUdfTkVXTElORTsKIAogCXAtPndvcmRfcmVnZXhwID0gb3B0LT53b3JkX3JlZ2V4cDsKIAlwLT5pZ25vcmVfY2FzZSA9IG9wdC0+aWdub3JlX2Nhc2U7Ci0JYXNjaWlfb25seSAgICAgPSAhaGFzX25vbl9hc2NpaShwLT5wYXR0ZXJuKTsKKwlwLT5maXhlZCA9IG9wdC0+Zml4ZWQ7CiAKLQkvKgotCSAqIEV2ZW4gd2hlbiAtRiAoZml4ZWQpIGFza3MgdXMgdG8gZG8gYSBub24tcmVnZXhwIHNlYXJjaCwgd2UKLQkgKiBtYXkgbm90IGJlIGFibGUgdG8gY29ycmVjdGx5IGNhc2UtZm9sZCB3aGVuIC1pCi0JICogKGlnbm9yZS1jYXNlKSBpcyBhc2tlZCAoaW4gd2hpY2ggY2FzZSwgd2UnbGwgc3ludGhlc2l6ZSBhCi0JICogcmVnZXhwIHRvIG1hdGNoIHRoZSBwYXR0ZXJuIHRoYXQgbWF0Y2hlcyByZWdleHAgc3BlY2lhbAotCSAqIGNoYXJhY3RlcnMgbGl0ZXJhbGx5LCB3aGlsZSBpZ25vcmluZyBjYXNlIGRpZmZlcmVuY2VzKS4gIE9uCi0JICogdGhlIG90aGVyIGhhbmQsIGV2ZW4gd2l0aG91dCAtRiwgaWYgdGhlIHBhdHRlcm4gZG9lcyBub3QKLQkgKiBoYXZlIGFueSByZWdleHAgc3BlY2lhbCBjaGFyYWN0ZXJzIGFuZCB0aGVyZSBpcyBubyBuZWVkIGZvcgotCSAqIGNhc2UtZm9sZGluZyBzZWFyY2gsIHdlIGNhbiBpbnRlcm5hbGx5IHR1cm4gaXQgaW50byBhCi0JICogc2ltcGxlIHN0cmluZyBtYXRjaCB1c2luZyBrd3MuICBwLT5maXhlZCB0ZWxscyB1cyBpZiB3ZQotCSAqIHdhbnQgdG8gdXNlIGt3cy4KLQkgKi8KLQlpZiAob3B0LT5maXhlZCB8fAotCSAgICBoYXNfbnVsbChwLT5wYXR0ZXJuLCBwLT5wYXR0ZXJubGVuKSB8fAotCSAgICBpc19maXhlZChwLT5wYXR0ZXJuLCBwLT5wYXR0ZXJubGVuKSkKLQkJcC0+Zml4ZWQgPSAhcC0+aWdub3JlX2Nhc2UgfHwgYXNjaWlfb25seTsKKwlpZiAobWVtY2hyKHAtPnBhdHRlcm4sIDAsIHAtPnBhdHRlcm5sZW4pICYmICFvcHQtPnBjcmUyKQorCQlkaWUoXygiZ2l2ZW4gcGF0dGVybiBjb250YWlucyBOVUxMIGJ5dGUgKHZpYSAtZiA8ZmlsZT4pLiBUaGlzIGlzIG9ubHkgc3VwcG9ydGVkIHdpdGggLVAgdW5kZXIgUENSRSB2MiIpKTsKIAotCWlmIChwLT5maXhlZCkgewotCQlwLT5rd3MgPSBrd3NhbGxvYyhwLT5pZ25vcmVfY2FzZSA/IHRvbG93ZXJfdHJhbnNfdGJsIDogTlVMTCk7Ci0JCWt3c2luY3IocC0+a3dzLCBwLT5wYXR0ZXJuLCBwLT5wYXR0ZXJubGVuKTsKLQkJa3dzcHJlcChwLT5rd3MpOwotCQlyZXR1cm47Ci0JfSBlbHNlIGlmIChvcHQtPmZpeGVkKSB7Ci0JCS8qCi0JCSAqIFdlIGNvbWUgaGVyZSB3aGVuIHRoZSBwYXR0ZXJuIGhhcyB0aGUgbm9uLWFzY2lpCi0JCSAqIGNoYXJhY3RlcnMgd2UgY2Fubm90IGNhc2UtZm9sZCwgYW5kIGFza2VkIHRvCi0JCSAqIGlnbm9yZS1jYXNlLgotCQkgKi8KKwlwLT5pc19maXhlZCA9IGlzX2ZpeGVkKHAtPnBhdHRlcm4sIHAtPnBhdHRlcm5sZW4pOworI2lmZGVmIFVTRV9MSUJQQ1JFMgorICAgICAgIGlmICghcC0+Zml4ZWQgJiYgIXAtPmlzX2ZpeGVkKSB7CisJICAgICAgIGNvbnN0IGNoYXIgKm5vX2ppdCA9ICIoKk5PX0pJVCkiOworCSAgICAgICBjb25zdCBpbnQgbm9faml0X2xlbiA9IHN0cmxlbihub19qaXQpOworCSAgICAgICBpZiAoc3RhcnRzX3dpdGgocC0+cGF0dGVybiwgbm9faml0KSAmJgorCQkgICBpc19maXhlZChwLT5wYXR0ZXJuICsgbm9faml0X2xlbiwKKwkJCSAgICBwLT5wYXR0ZXJubGVuIC0gbm9faml0X2xlbikpCisJCSAgICAgICBwLT5pc19maXhlZCA9IDE7CisgICAgICAgfQorI2VuZGlmCisJaWYgKHAtPmZpeGVkIHx8IHAtPmlzX2ZpeGVkKSB7CisjaWZkZWYgVVNFX0xJQlBDUkUyCisJCW9wdC0+cGNyZTIgPSAxOworCQlpZiAocC0+aXNfZml4ZWQpIHsKKwkJCWNvbXBpbGVfcGNyZTJfcGF0dGVybihwLCBvcHQpOworCQl9IGVsc2UgeworCQkJLyoKKwkJCSAqIEUuZy4gdDc4MTEtZ3JlcC1vcGVuLnNoIHJlbGllcyBvbiB0aGUKKwkJCSAqIHBhdHRlcm4gYmVpbmcgcmVzdG9yZWQuCisJCQkgKi8KKwkJCWNoYXIgKm9sZF9wYXR0ZXJuID0gcC0+cGF0dGVybjsKKwkJCXNpemVfdCBvbGRfcGF0dGVybmxlbiA9IHAtPnBhdHRlcm5sZW47CisJCQlzdHJ1Y3Qgc3RyYnVmIHNiID0gU1RSQlVGX0lOSVQ7CisKKwkJCS8qCisJCQkgKiBUaGVyZSBpcyB0aGUgUENSRTJfTElURVJBTCBmbGFnLCBidXQgaXQncworCQkJICogb25seSBpbiBQQ1JFIHYyIDEwLjMwIGFuZCBsYXRlci4gTmVlZGluZyB0bworCQkJICogaWZkZWYgb3VyIHdheSBhcm91bmQgdGhhdCBhbmQgZGVhbGluZyB3aXRoCisJCQkgKiBpdCArIFBDUkUyX01VTFRJTElORSBiZWluZyBhbiBlcnJvciBpcyBtb3JlCisJCQkgKiBjb21wbGV4IHRoYW4ganVzdCBxdW90aW5nIHRoaXMgb3Vyc2VsdmVzLgorCQkJKi8KKwkJCXN0cmJ1Zl9hZGQoJnNiLCAiXFxRIiwgMik7CisJCQlzdHJidWZfYWRkKCZzYiwgcC0+cGF0dGVybiwgcC0+cGF0dGVybmxlbik7CisJCQlzdHJidWZfYWRkKCZzYiwgIlxcRSIsIDIpOworCisJCQlwLT5wYXR0ZXJuID0gc2IuYnVmOworCQkJcC0+cGF0dGVybmxlbiA9IHNiLmxlbjsKKwkJCWNvbXBpbGVfcGNyZTJfcGF0dGVybihwLCBvcHQpOworCQkJcC0+cGF0dGVybiA9IG9sZF9wYXR0ZXJuOworCQkJcC0+cGF0dGVybmxlbiA9IG9sZF9wYXR0ZXJubGVuOworCQkJc3RyYnVmX3JlbGVhc2UoJnNiKTsKKwkJfQorI2Vsc2UgLyogIVVTRV9MSUJQQ1JFMiAqLwogCQljb21waWxlX2ZpeGVkX3JlZ2V4cChwLCBvcHQpOworI2VuZGlmIC8qICFVU0VfTElCUENSRTIgKi8KIAkJcmV0dXJuOwogCX0KIApAQCAtMTA1Myw5ICsxMDc5LDcgQEAKIAkJY2FzZSBHUkVQX1BBVFRFUk46IC8qIGF0b20gKi8KIAkJY2FzZSBHUkVQX1BBVFRFUk5fSEVBRDoKIAkJY2FzZSBHUkVQX1BBVFRFUk5fQk9EWToKLQkJCWlmIChwLT5rd3MpCi0JCQkJa3dzZnJlZShwLT5rd3MpOwotCQkJZWxzZSBpZiAocC0+cGNyZTFfcmVnZXhwKQorCQkJaWYgKHAtPnBjcmUxX3JlZ2V4cCkKIAkJCQlmcmVlX3BjcmUxX3JlZ2V4cChwKTsKIAkJCWVsc2UgaWYgKHAtPnBjcmUyX3BhdHRlcm4pCiAJCQkJZnJlZV9wY3JlMl9wYXR0ZXJuKHApOwpAQCAtMTExNSwyOSArMTEzOSwxMiBAQAogCW9wdC0+b3V0cHV0KG9wdCwgb3B0LT5udWxsX2ZvbGxvd2luZ19uYW1lID8gIlwwIiA6ICJcbiIsIDEpOwogfQogCi1zdGF0aWMgaW50IGZpeG1hdGNoKHN0cnVjdCBncmVwX3BhdCAqcCwgY2hhciAqbGluZSwgY2hhciAqZW9sLAotCQkgICAgcmVnbWF0Y2hfdCAqbWF0Y2gpCi17Ci0Jc3RydWN0IGt3c21hdGNoIGt3c207Ci0Jc2l6ZV90IG9mZnNldCA9IGt3c2V4ZWMocC0+a3dzLCBsaW5lLCBlb2wgLSBsaW5lLCAma3dzbSk7Ci0JaWYgKG9mZnNldCA9PSAtMSkgewotCQltYXRjaC0+cm1fc28gPSBtYXRjaC0+cm1fZW8gPSAtMTsKLQkJcmV0dXJuIFJFR19OT01BVENIOwotCX0gZWxzZSB7Ci0JCW1hdGNoLT5ybV9zbyA9IG9mZnNldDsKLQkJbWF0Y2gtPnJtX2VvID0gbWF0Y2gtPnJtX3NvICsga3dzbS5zaXplWzBdOwotCQlyZXR1cm4gMDsKLQl9Ci19Ci0KIHN0YXRpYyBpbnQgcGF0bWF0Y2goc3RydWN0IGdyZXBfcGF0ICpwLCBjaGFyICpsaW5lLCBjaGFyICplb2wsCiAJCSAgICByZWdtYXRjaF90ICptYXRjaCwgaW50IGVmbGFncykKIHsKIAlpbnQgaGl0OwogCi0JaWYgKHAtPmZpeGVkKQotCQloaXQgPSAhZml4bWF0Y2gocCwgbGluZSwgZW9sLCBtYXRjaCk7Ci0JZWxzZSBpZiAocC0+cGNyZTFfcmVnZXhwKQorCWlmIChwLT5wY3JlMV9yZWdleHApCiAJCWhpdCA9ICFwY3JlMW1hdGNoKHAsIGxpbmUsIGVvbCwgbWF0Y2gsIGVmbGFncyk7CiAJZWxzZSBpZiAocC0+cGNyZTJfcGF0dGVybikKIAkJaGl0ID0gIXBjcmUybWF0Y2gocCwgbGluZSwgZW9sLCBtYXRjaCwgZWZsYWdzKTsKZGlmZiAtLWdpdCBhL2dyZXAuaCBiL2dyZXAuaAppbmRleCAxODc1ODgwLi44MTFmZDI3IDEwMDY0NAotLS0gYS9ncmVwLmgKKysrIGIvZ3JlcC5oCkBAIC0zLDI0ICszLDEyIEBACiAjaW5jbHVkZSAiY29sb3IuaCIKICNpZmRlZiBVU0VfTElCUENSRTEKICNpbmNsdWRlIDxwY3JlLmg+Ci0jaWZkZWYgUENSRV9DT05GSUdfSklUCi0jaWYgUENSRV9NQUpPUiA+PSA4ICYmIFBDUkVfTUlOT1IgPj0gMzIKLSNpZm5kZWYgTk9fTElCUENSRTFfSklUCi0jZGVmaW5lIEdJVF9QQ1JFMV9VU0VfSklUCi0jZGVmaW5lIEdJVF9QQ1JFX1NUVURZX0pJVF9DT01QSUxFIFBDUkVfU1RVRFlfSklUX0NPTVBJTEUKLSNlbmRpZgotI2VuZGlmCi0jZW5kaWYKLSNpZm5kZWYgR0lUX1BDUkVfU1RVRFlfSklUX0NPTVBJTEUKLSNkZWZpbmUgR0lUX1BDUkVfU1RVRFlfSklUX0NPTVBJTEUgMAotI2VuZGlmCi0jaWYgUENSRV9NQUpPUiA8PSA4ICYmIFBDUkVfTUlOT1IgPCAyMAotdHlwZWRlZiBpbnQgcGNyZV9qaXRfc3RhY2s7CisjaWZuZGVmIFBDUkVfTk9fVVRGOF9DSEVDSworI2RlZmluZSBQQ1JFX05PX1VURjhfQ0hFQ0sgMAogI2VuZGlmCiAjZWxzZQogdHlwZWRlZiBpbnQgcGNyZTsKIHR5cGVkZWYgaW50IHBjcmVfZXh0cmE7Ci10eXBlZGVmIGludCBwY3JlX2ppdF9zdGFjazsKICNlbmRpZgogI2lmZGVmIFVTRV9MSUJQQ1JFMgogI2RlZmluZSBQQ1JFMl9DT0RFX1VOSVRfV0lEVEggOApAQCAtMjksMTAgKzE3LDcgQEAKIHR5cGVkZWYgaW50IHBjcmUyX2NvZGU7CiB0eXBlZGVmIGludCBwY3JlMl9tYXRjaF9kYXRhOwogdHlwZWRlZiBpbnQgcGNyZTJfY29tcGlsZV9jb250ZXh0OwotdHlwZWRlZiBpbnQgcGNyZTJfbWF0Y2hfY29udGV4dDsKLXR5cGVkZWYgaW50IHBjcmUyX2ppdF9zdGFjazsKICNlbmRpZgotI2luY2x1ZGUgImt3c2V0LmgiCiAjaW5jbHVkZSAidGhyZWFkLXV0aWxzLmgiCiAjaW5jbHVkZSAidXNlcmRpZmYuaCIKIApAQCAtODgsMTcgKzczLDE1IEBACiAJcmVnZXhfdCByZWdleHA7CiAJcGNyZSAqcGNyZTFfcmVnZXhwOwogCXBjcmVfZXh0cmEgKnBjcmUxX2V4dHJhX2luZm87Ci0JcGNyZV9qaXRfc3RhY2sgKnBjcmUxX2ppdF9zdGFjazsKIAljb25zdCB1bnNpZ25lZCBjaGFyICpwY3JlMV90YWJsZXM7CiAJaW50IHBjcmUxX2ppdF9vbjsKIAlwY3JlMl9jb2RlICpwY3JlMl9wYXR0ZXJuOwogCXBjcmUyX21hdGNoX2RhdGEgKnBjcmUyX21hdGNoX2RhdGE7CiAJcGNyZTJfY29tcGlsZV9jb250ZXh0ICpwY3JlMl9jb21waWxlX2NvbnRleHQ7Ci0JcGNyZTJfbWF0Y2hfY29udGV4dCAqcGNyZTJfbWF0Y2hfY29udGV4dDsKLQlwY3JlMl9qaXRfc3RhY2sgKnBjcmUyX2ppdF9zdGFjazsKKwljb25zdCB1aW50OF90ICpwY3JlMl90YWJsZXM7CiAJdWludDMyX3QgcGNyZTJfaml0X29uOwotCWt3c2V0X3Qga3dzOwogCXVuc2lnbmVkIGZpeGVkOjE7CisJdW5zaWduZWQgaXNfZml4ZWQ6MTsKIAl1bnNpZ25lZCBpZ25vcmVfY2FzZToxOwogCXVuc2lnbmVkIHdvcmRfcmVnZXhwOjE7CiB9OwpAQCAtMTczLDYgKzE1Niw3IEBACiAJaW50IGZ1bmNib2R5OwogCWludCBleHRlbmRlZF9yZWdleHBfb3B0aW9uOwogCWludCBwYXR0ZXJuX3R5cGVfb3B0aW9uOworCWludCBpZ25vcmVfbG9jYWxlOwogCWNoYXIgY29sb3JzW05SX0dSRVBfQ09MT1JTXVtDT0xPUl9NQVhMRU5dOwogCXVuc2lnbmVkIHByZV9jb250ZXh0OwogCXVuc2lnbmVkIHBvc3RfY29udGV4dDsKQEAgLTE4OSw2ICsxNzMsNyBAQAogdm9pZCBpbml0X2dyZXBfZGVmYXVsdHMoc3RydWN0IHJlcG9zaXRvcnkgKik7CiBpbnQgZ3JlcF9jb25maWcoY29uc3QgY2hhciAqdmFyLCBjb25zdCBjaGFyICp2YWx1ZSwgdm9pZCAqKTsKIHZvaWQgZ3JlcF9pbml0KHN0cnVjdCBncmVwX29wdCAqLCBzdHJ1Y3QgcmVwb3NpdG9yeSAqcmVwbywgY29uc3QgY2hhciAqcHJlZml4KTsKK3ZvaWQgZ3JlcF9kZXN0cm95KHZvaWQpOwogdm9pZCBncmVwX2NvbW1pdF9wYXR0ZXJuX3R5cGUoZW51bSBncmVwX3BhdHRlcm5fdHlwZSwgc3RydWN0IGdyZXBfb3B0ICpvcHQpOwogCiB2b2lkIGFwcGVuZF9ncmVwX3BhdChzdHJ1Y3QgZ3JlcF9vcHQgKm9wdCwgY29uc3QgY2hhciAqcGF0LCBzaXplX3QgcGF0bGVuLCBjb25zdCBjaGFyICpvcmlnaW4sIGludCBubywgZW51bSBncmVwX3BhdF90b2tlbiB0KTsKZGlmZiAtLWdpdCBhL2hhc2htYXAuYyBiL2hhc2htYXAuYwppbmRleCBkNDJmMDFmLi4wOTgxM2UxIDEwMDY0NAotLS0gYS9oYXNobWFwLmMKKysrIGIvaGFzaG1hcC5jCkBAIC01MSw3ICs1MSw3IEBACiB9CiAKIC8qCi0gKiBJbmNvcG9yYXRlIGFub3RoZXIgY2h1bmsgb2YgZGF0YSBpbnRvIGEgbWVtaWhhc2gKKyAqIEluY29ycG9yYXRlIGFub3RoZXIgY2h1bmsgb2YgZGF0YSBpbnRvIGEgbWVtaWhhc2gKICAqIGNvbXB1dGF0aW9uLgogICovCiB1bnNpZ25lZCBpbnQgbWVtaWhhc2hfY29udCh1bnNpZ25lZCBpbnQgaGFzaF9zZWVkLCBjb25zdCB2b2lkICpidWYsIHNpemVfdCBsZW4pCkBAIC0xNDAsOCArMTQwLDggQEAKIH0KIAogc3RhdGljIGludCBhbHdheXNfZXF1YWwoY29uc3Qgdm9pZCAqdW51c2VkX2NtcF9kYXRhLAotCQkJY29uc3Qgdm9pZCAqdW51c2VkMSwKLQkJCWNvbnN0IHZvaWQgKnVudXNlZDIsCisJCQljb25zdCBzdHJ1Y3QgaGFzaG1hcF9lbnRyeSAqdW51c2VkMSwKKwkJCWNvbnN0IHN0cnVjdCBoYXNobWFwX2VudHJ5ICp1bnVzZWQyLAogCQkJY29uc3Qgdm9pZCAqdW51c2VkX2tleWRhdGEpCiB7CiAJcmV0dXJuIDA7CkBAIC0xNzEsNDEgKzE3MSw0OSBAQAogCW1hcC0+ZG9fY291bnRfaXRlbXMgPSAxOwogfQogCi12b2lkIGhhc2htYXBfZnJlZShzdHJ1Y3QgaGFzaG1hcCAqbWFwLCBpbnQgZnJlZV9lbnRyaWVzKQordm9pZCBoYXNobWFwX2ZyZWVfKHN0cnVjdCBoYXNobWFwICptYXAsIHNzaXplX3QgZW50cnlfb2Zmc2V0KQogewogCWlmICghbWFwIHx8ICFtYXAtPnRhYmxlKQogCQlyZXR1cm47Ci0JaWYgKGZyZWVfZW50cmllcykgeworCWlmIChlbnRyeV9vZmZzZXQgPj0gMCkgeyAvKiBjYWxsZWQgYnkgaGFzaG1hcF9mcmVlX2VudHJpZXMgKi8KIAkJc3RydWN0IGhhc2htYXBfaXRlciBpdGVyOwogCQlzdHJ1Y3QgaGFzaG1hcF9lbnRyeSAqZTsKKwogCQloYXNobWFwX2l0ZXJfaW5pdChtYXAsICZpdGVyKTsKIAkJd2hpbGUgKChlID0gaGFzaG1hcF9pdGVyX25leHQoJml0ZXIpKSkKLQkJCWZyZWUoZSk7CisJCQkvKgorCQkJICogbGlrZSBjb250YWluZXJfb2YsIGJ1dCB1c2luZyBjYWxsZXItY2FsY3VsYXRlZAorCQkJICogb2Zmc2V0IChjYWxsZXIgYmVpbmcgaGFzaG1hcF9mcmVlX2VudHJpZXMpCisJCQkgKi8KKwkJCWZyZWUoKGNoYXIgKillIC0gZW50cnlfb2Zmc2V0KTsKIAl9CiAJZnJlZShtYXAtPnRhYmxlKTsKIAltZW1zZXQobWFwLCAwLCBzaXplb2YoKm1hcCkpOwogfQogCi12b2lkICpoYXNobWFwX2dldChjb25zdCBzdHJ1Y3QgaGFzaG1hcCAqbWFwLCBjb25zdCB2b2lkICprZXksIGNvbnN0IHZvaWQgKmtleWRhdGEpCitzdHJ1Y3QgaGFzaG1hcF9lbnRyeSAqaGFzaG1hcF9nZXQoY29uc3Qgc3RydWN0IGhhc2htYXAgKm1hcCwKKwkJCQljb25zdCBzdHJ1Y3QgaGFzaG1hcF9lbnRyeSAqa2V5LAorCQkJCWNvbnN0IHZvaWQgKmtleWRhdGEpCiB7CiAJcmV0dXJuICpmaW5kX2VudHJ5X3B0cihtYXAsIGtleSwga2V5ZGF0YSk7CiB9CiAKLXZvaWQgKmhhc2htYXBfZ2V0X25leHQoY29uc3Qgc3RydWN0IGhhc2htYXAgKm1hcCwgY29uc3Qgdm9pZCAqZW50cnkpCitzdHJ1Y3QgaGFzaG1hcF9lbnRyeSAqaGFzaG1hcF9nZXRfbmV4dChjb25zdCBzdHJ1Y3QgaGFzaG1hcCAqbWFwLAorCQkJY29uc3Qgc3RydWN0IGhhc2htYXBfZW50cnkgKmVudHJ5KQogewotCXN0cnVjdCBoYXNobWFwX2VudHJ5ICplID0gKChzdHJ1Y3QgaGFzaG1hcF9lbnRyeSAqKSBlbnRyeSktPm5leHQ7CisJc3RydWN0IGhhc2htYXBfZW50cnkgKmUgPSBlbnRyeS0+bmV4dDsKIAlmb3IgKDsgZTsgZSA9IGUtPm5leHQpCiAJCWlmIChlbnRyeV9lcXVhbHMobWFwLCBlbnRyeSwgZSwgTlVMTCkpCiAJCQlyZXR1cm4gZTsKIAlyZXR1cm4gTlVMTDsKIH0KIAotdm9pZCBoYXNobWFwX2FkZChzdHJ1Y3QgaGFzaG1hcCAqbWFwLCB2b2lkICplbnRyeSkKK3ZvaWQgaGFzaG1hcF9hZGQoc3RydWN0IGhhc2htYXAgKm1hcCwgc3RydWN0IGhhc2htYXBfZW50cnkgKmVudHJ5KQogewogCXVuc2lnbmVkIGludCBiID0gYnVja2V0KG1hcCwgZW50cnkpOwogCiAJLyogYWRkIGVudHJ5ICovCi0JKChzdHJ1Y3QgaGFzaG1hcF9lbnRyeSAqKSBlbnRyeSktPm5leHQgPSBtYXAtPnRhYmxlW2JdOworCWVudHJ5LT5uZXh0ID0gbWFwLT50YWJsZVtiXTsKIAltYXAtPnRhYmxlW2JdID0gZW50cnk7CiAKIAkvKiBmaXggc2l6ZSBhbmQgcmVoYXNoIGlmIGFwcHJvcHJpYXRlICovCkBAIC0yMTYsNyArMjI0LDkgQEAKIAl9CiB9CiAKLXZvaWQgKmhhc2htYXBfcmVtb3ZlKHN0cnVjdCBoYXNobWFwICptYXAsIGNvbnN0IHZvaWQgKmtleSwgY29uc3Qgdm9pZCAqa2V5ZGF0YSkKK3N0cnVjdCBoYXNobWFwX2VudHJ5ICpoYXNobWFwX3JlbW92ZShzdHJ1Y3QgaGFzaG1hcCAqbWFwLAorCQkJCQljb25zdCBzdHJ1Y3QgaGFzaG1hcF9lbnRyeSAqa2V5LAorCQkJCQljb25zdCB2b2lkICprZXlkYXRhKQogewogCXN0cnVjdCBoYXNobWFwX2VudHJ5ICpvbGQ7CiAJc3RydWN0IGhhc2htYXBfZW50cnkgKiplID0gZmluZF9lbnRyeV9wdHIobWFwLCBrZXksIGtleWRhdGEpOwpAQCAtMjM4LDcgKzI0OCw4IEBACiAJcmV0dXJuIG9sZDsKIH0KIAotdm9pZCAqaGFzaG1hcF9wdXQoc3RydWN0IGhhc2htYXAgKm1hcCwgdm9pZCAqZW50cnkpCitzdHJ1Y3QgaGFzaG1hcF9lbnRyeSAqaGFzaG1hcF9wdXQoc3RydWN0IGhhc2htYXAgKm1hcCwKKwkJCQlzdHJ1Y3QgaGFzaG1hcF9lbnRyeSAqZW50cnkpCiB7CiAJc3RydWN0IGhhc2htYXBfZW50cnkgKm9sZCA9IGhhc2htYXBfcmVtb3ZlKG1hcCwgZW50cnksIE5VTEwpOwogCWhhc2htYXBfYWRkKG1hcCwgZW50cnkpOwpAQCAtMjUyLDcgKzI2Myw3IEBACiAJaXRlci0+bmV4dCA9IE5VTEw7CiB9CiAKLXZvaWQgKmhhc2htYXBfaXRlcl9uZXh0KHN0cnVjdCBoYXNobWFwX2l0ZXIgKml0ZXIpCitzdHJ1Y3QgaGFzaG1hcF9lbnRyeSAqaGFzaG1hcF9pdGVyX25leHQoc3RydWN0IGhhc2htYXBfaXRlciAqaXRlcikKIHsKIAlzdHJ1Y3QgaGFzaG1hcF9lbnRyeSAqY3VycmVudCA9IGl0ZXItPm5leHQ7CiAJZm9yICg7OykgewpAQCAtMjc1LDEwICsyODYsMTUgQEAKIH07CiAKIHN0YXRpYyBpbnQgcG9vbF9lbnRyeV9jbXAoY29uc3Qgdm9pZCAqdW51c2VkX2NtcF9kYXRhLAotCQkJICBjb25zdCBzdHJ1Y3QgcG9vbF9lbnRyeSAqZTEsCi0JCQkgIGNvbnN0IHN0cnVjdCBwb29sX2VudHJ5ICplMiwKLQkJCSAgY29uc3QgdW5zaWduZWQgY2hhciAqa2V5ZGF0YSkKKwkJCSAgY29uc3Qgc3RydWN0IGhhc2htYXBfZW50cnkgKmVwdHIsCisJCQkgIGNvbnN0IHN0cnVjdCBoYXNobWFwX2VudHJ5ICplbnRyeV9vcl9rZXksCisJCQkgIGNvbnN0IHZvaWQgKmtleWRhdGEpCiB7CisJY29uc3Qgc3RydWN0IHBvb2xfZW50cnkgKmUxLCAqZTI7CisKKwllMSA9IGNvbnRhaW5lcl9vZihlcHRyLCBjb25zdCBzdHJ1Y3QgcG9vbF9lbnRyeSwgZW50KTsKKwllMiA9IGNvbnRhaW5lcl9vZihlbnRyeV9vcl9rZXksIGNvbnN0IHN0cnVjdCBwb29sX2VudHJ5LCBlbnQpOworCiAJcmV0dXJuIGUxLT5kYXRhICE9IGtleWRhdGEgJiYKIAkgICAgICAgKGUxLT5sZW4gIT0gZTItPmxlbiB8fCBtZW1jbXAoZTEtPmRhdGEsIGtleWRhdGEsIGUxLT5sZW4pKTsKIH0KQEAgLTI5MCwxOCArMzA2LDE4IEBACiAKIAkvKiBpbml0aWFsaXplIHN0cmluZyBwb29sIGhhc2htYXAgKi8KIAlpZiAoIW1hcC50YWJsZXNpemUpCi0JCWhhc2htYXBfaW5pdCgmbWFwLCAoaGFzaG1hcF9jbXBfZm4pIHBvb2xfZW50cnlfY21wLCBOVUxMLCAwKTsKKwkJaGFzaG1hcF9pbml0KCZtYXAsIHBvb2xfZW50cnlfY21wLCBOVUxMLCAwKTsKIAogCS8qIGxvb2t1cCBpbnRlcm5lZCBzdHJpbmcgaW4gcG9vbCAqLwotCWhhc2htYXBfZW50cnlfaW5pdCgma2V5LCBtZW1oYXNoKGRhdGEsIGxlbikpOworCWhhc2htYXBfZW50cnlfaW5pdCgma2V5LmVudCwgbWVtaGFzaChkYXRhLCBsZW4pKTsKIAlrZXkubGVuID0gbGVuOwotCWUgPSBoYXNobWFwX2dldCgmbWFwLCAma2V5LCBkYXRhKTsKKwllID0gaGFzaG1hcF9nZXRfZW50cnkoJm1hcCwgJmtleSwgZW50LCBkYXRhKTsKIAlpZiAoIWUpIHsKIAkJLyogbm90IGZvdW5kOiBjcmVhdGUgaXQgKi8KIAkJRkxFWF9BTExPQ19NRU0oZSwgZGF0YSwgZGF0YSwgbGVuKTsKLQkJaGFzaG1hcF9lbnRyeV9pbml0KGUsIGtleS5lbnQuaGFzaCk7CisJCWhhc2htYXBfZW50cnlfaW5pdCgmZS0+ZW50LCBrZXkuZW50Lmhhc2gpOwogCQllLT5sZW4gPSBsZW47Ci0JCWhhc2htYXBfYWRkKCZtYXAsIGUpOworCQloYXNobWFwX2FkZCgmbWFwLCAmZS0+ZW50KTsKIAl9CiAJcmV0dXJuIGUtPmRhdGE7CiB9CmRpZmYgLS1naXQgYS9oYXNobWFwLmggYi9oYXNobWFwLmgKaW5kZXggODQyNDkxMS4uNzlhZTlmOCAxMDA2NDQKLS0tIGEvaGFzaG1hcC5oCisrKyBiL2hhc2htYXAuaApAQCAtMTMsNyArMTMsNyBAQAogICoKICAqIHN0cnVjdCBoYXNobWFwIG1hcDsKICAqIHN0cnVjdCBsb25nMnN0cmluZyB7Ci0gKiAgICAgc3RydWN0IGhhc2htYXBfZW50cnkgZW50OyAvLyBtdXN0IGJlIHRoZSBmaXJzdCBtZW1iZXIhCisgKiAgICAgc3RydWN0IGhhc2htYXBfZW50cnkgZW50OwogICogICAgIGxvbmcga2V5OwogICogICAgIGNoYXIgdmFsdWVbRkxFWF9BUlJBWV07ICAgLy8gYmUgY2FyZWZ1bCB3aXRoIGFsbG9jYXRpbmcgb24gc3RhY2shCiAgKiB9OwpAQCAtMjEsMTIgKzIxLDE2IEBACiAgKiAjZGVmaW5lIENPTVBBUkVfVkFMVUUgMQogICoKICAqIHN0YXRpYyBpbnQgbG9uZzJzdHJpbmdfY21wKGNvbnN0IHZvaWQgKmhhc2htYXBfY21wX2ZuX2RhdGEsCi0gKiAgICAgICAgICAgICAgICAgICAgICAgICAgICBjb25zdCBzdHJ1Y3QgbG9uZzJzdHJpbmcgKmUxLAotICogICAgICAgICAgICAgICAgICAgICAgICAgICAgY29uc3Qgc3RydWN0IGxvbmcyc3RyaW5nICplMiwKKyAqICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNvbnN0IHN0cnVjdCBoYXNobWFwX2VudHJ5ICplcHRyLAorICogICAgICAgICAgICAgICAgICAgICAgICAgICAgY29uc3Qgc3RydWN0IGhhc2htYXBfZW50cnkgKmVudHJ5X29yX2tleSwKICAqICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNvbnN0IHZvaWQgKmtleWRhdGEpCiAgKiB7CiAgKiAgICAgY29uc3QgY2hhciAqc3RyaW5nID0ga2V5ZGF0YTsKICAqICAgICB1bnNpZ25lZCBmbGFncyA9ICoodW5zaWduZWQgKiloYXNobWFwX2NtcF9mbl9kYXRhOworICogICAgIGNvbnN0IHN0cnVjdCBsb25nMnN0cmluZyAqZTEsICplMjsKKyAqCisgKiAgICAgZTEgPSBjb250YWluZXJfb2YoZXB0ciwgY29uc3Qgc3RydWN0IGxvbmcyc3RyaW5nLCBlbnQpOworICogICAgIGUyID0gY29udGFpbmVyX29mKGVudHJ5X29yX2tleSwgY29uc3Qgc3RydWN0IGxvbmcyc3RyaW5nLCBlbnQpOwogICoKICAqICAgICBpZiAoZmxhZ3MgJiBDT01QQVJFX1ZBTFVFKQogICogICAgICAgICByZXR1cm4gZTEtPmtleSAhPSBlMi0+a2V5IHx8CkBAIC00MSw1NCArNDUsNTggQEAKICAqICAgICBjaGFyIHZhbHVlWzI1NV0sIGFjdGlvblszMl07CiAgKiAgICAgdW5zaWduZWQgZmxhZ3MgPSAwOwogICoKLSAqICAgICBoYXNobWFwX2luaXQoJm1hcCwgKGhhc2htYXBfY21wX2ZuKSBsb25nMnN0cmluZ19jbXAsICZmbGFncywgMCk7CisgKiAgICAgaGFzaG1hcF9pbml0KCZtYXAsIGxvbmcyc3RyaW5nX2NtcCwgJmZsYWdzLCAwKTsKICAqCiAgKiAgICAgd2hpbGUgKHNjYW5mKCIlcyAlbGQgJXMiLCBhY3Rpb24sICZrZXksIHZhbHVlKSkgewogICoKICAqICAgICAgICAgaWYgKCFzdHJjbXAoImFkZCIsIGFjdGlvbikpIHsKICAqICAgICAgICAgICAgIHN0cnVjdCBsb25nMnN0cmluZyAqZTsKICAqICAgICAgICAgICAgIEZMRVhfQUxMT0NfU1RSKGUsIHZhbHVlLCB2YWx1ZSk7Ci0gKiAgICAgICAgICAgICBoYXNobWFwX2VudHJ5X2luaXQoZSwgbWVtaGFzaCgma2V5LCBzaXplb2YobG9uZykpKTsKKyAqICAgICAgICAgICAgIGhhc2htYXBfZW50cnlfaW5pdCgmZS0+ZW50LCBtZW1oYXNoKCZrZXksIHNpemVvZihsb25nKSkpOwogICogICAgICAgICAgICAgZS0+a2V5ID0ga2V5OwotICogICAgICAgICAgICAgaGFzaG1hcF9hZGQoJm1hcCwgZSk7CisgKiAgICAgICAgICAgICBoYXNobWFwX2FkZCgmbWFwLCAmZS0+ZW50KTsKICAqICAgICAgICAgfQogICoKICAqICAgICAgICAgaWYgKCFzdHJjbXAoInByaW50X2FsbF9ieV9rZXkiLCBhY3Rpb24pKSB7CiAgKiAgICAgICAgICAgICBzdHJ1Y3QgbG9uZzJzdHJpbmcgaywgKmU7Ci0gKiAgICAgICAgICAgICBoYXNobWFwX2VudHJ5X2luaXQoJmssIG1lbWhhc2goJmtleSwgc2l6ZW9mKGxvbmcpKSk7CisgKiAgICAgICAgICAgICBoYXNobWFwX2VudHJ5X2luaXQoJmsuZW50LCBtZW1oYXNoKCZrZXksIHNpemVvZihsb25nKSkpOwogICogICAgICAgICAgICAgay5rZXkgPSBrZXk7CiAgKgogICogICAgICAgICAgICAgZmxhZ3MgJj0gfkNPTVBBUkVfVkFMVUU7Ci0gKiAgICAgICAgICAgICBlID0gaGFzaG1hcF9nZXQoJm1hcCwgJmssIE5VTEwpOworICogICAgICAgICAgICAgZSA9IGhhc2htYXBfZ2V0X2VudHJ5KCZtYXAsICZrLCBlbnQsIE5VTEwpOwogICogICAgICAgICAgICAgaWYgKGUpIHsKICAqICAgICAgICAgICAgICAgICBwcmludGYoImZpcnN0OiAlbGQgJXNcbiIsIGUtPmtleSwgZS0+dmFsdWUpOwotICogICAgICAgICAgICAgICAgIHdoaWxlICgoZSA9IGhhc2htYXBfZ2V0X25leHQoJm1hcCwgZSkpKQorICogICAgICAgICAgICAgICAgIHdoaWxlICgoZSA9IGhhc2htYXBfZ2V0X25leHRfZW50cnkoJm1hcCwgZSwKKyAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHN0cnVjdCBsb25nMnN0cmluZywgZW50KSkpIHsKICAqICAgICAgICAgICAgICAgICAgICAgcHJpbnRmKCJmb3VuZCBtb3JlOiAlbGQgJXNcbiIsIGUtPmtleSwgZS0+dmFsdWUpOworICogICAgICAgICAgICAgICAgIH0KICAqICAgICAgICAgICAgIH0KICAqICAgICAgICAgfQogICoKICAqICAgICAgICAgaWYgKCFzdHJjbXAoImhhc19leGFjdF9tYXRjaCIsIGFjdGlvbikpIHsKICAqICAgICAgICAgICAgIHN0cnVjdCBsb25nMnN0cmluZyAqZTsKICAqICAgICAgICAgICAgIEZMRVhfQUxMT0NfU1RSKGUsIHZhbHVlLCB2YWx1ZSk7Ci0gKiAgICAgICAgICAgICBoYXNobWFwX2VudHJ5X2luaXQoZSwgbWVtaGFzaCgma2V5LCBzaXplb2YobG9uZykpKTsKKyAqICAgICAgICAgICAgIGhhc2htYXBfZW50cnlfaW5pdCgmZS0+ZW50LCBtZW1oYXNoKCZrZXksIHNpemVvZihsb25nKSkpOwogICogICAgICAgICAgICAgZS0+a2V5ID0ga2V5OwogICoKICAqICAgICAgICAgICAgIGZsYWdzIHw9IENPTVBBUkVfVkFMVUU7Ci0gKiAgICAgICAgICAgICBwcmludGYoIiVzZm91bmRcbiIsIGhhc2htYXBfZ2V0KCZtYXAsIGUsIE5VTEwpID8gIiIgOiAibm90ICIpOworICogICAgICAgICAgICAgcHJpbnRmKCIlc2ZvdW5kXG4iLAorICogICAgICAgICAgICAgICAgICAgIGhhc2htYXBfZ2V0KCZtYXAsICZlLT5lbnQsIE5VTEwpID8gIiIgOiAibm90ICIpOwogICogICAgICAgICAgICAgZnJlZShlKTsKICAqICAgICAgICAgfQogICoKICAqICAgICAgICAgaWYgKCFzdHJjbXAoImhhc19leGFjdF9tYXRjaF9ub19oZWFwX2FsbG9jIiwgYWN0aW9uKSkgewogICogICAgICAgICAgICAgc3RydWN0IGxvbmcyc3RyaW5nIGs7Ci0gKiAgICAgICAgICAgICBoYXNobWFwX2VudHJ5X2luaXQoJmssIG1lbWhhc2goJmtleSwgc2l6ZW9mKGxvbmcpKSk7CisgKiAgICAgICAgICAgICBoYXNobWFwX2VudHJ5X2luaXQoJmsuZW50LCBtZW1oYXNoKCZrZXksIHNpemVvZihsb25nKSkpOwogICogICAgICAgICAgICAgay5rZXkgPSBrZXk7CiAgKgogICogICAgICAgICAgICAgZmxhZ3MgfD0gQ09NUEFSRV9WQUxVRTsKLSAqICAgICAgICAgICAgIHByaW50ZigiJXNmb3VuZFxuIiwgaGFzaG1hcF9nZXQoJm1hcCwgJmssIHZhbHVlKSA/ICIiIDogIm5vdCAiKTsKKyAqICAgICAgICAgICAgIHByaW50ZigiJXNmb3VuZFxuIiwKKyAqICAgICAgICAgICAgICAgICAgICBoYXNobWFwX2dldCgmbWFwLCAmay5lbnQsIHZhbHVlKSA/ICIiIDogIm5vdCAiKTsKICAqICAgICAgICAgfQogICoKICAqICAgICAgICAgaWYgKCFzdHJjbXAoImVuZCIsIGFjdGlvbikpIHsKLSAqICAgICAgICAgICAgIGhhc2htYXBfZnJlZSgmbWFwLCAxKTsKKyAqICAgICAgICAgICAgIGhhc2htYXBfZnJlZV9lbnRyaWVzKCZtYXAsIHN0cnVjdCBsb25nMnN0cmluZywgZW50KTsKICAqICAgICAgICAgICAgIGJyZWFrOwogICogICAgICAgICB9CiAgKiAgICAgfQpAQCAtMTMzLDcgKzE0MSw3IEBACiAKIC8qCiAgKiBzdHJ1Y3QgaGFzaG1hcF9lbnRyeSBpcyBhbiBvcGFxdWUgc3RydWN0dXJlIHJlcHJlc2VudGluZyBhbiBlbnRyeSBpbiB0aGUKLSAqIGhhc2ggdGFibGUsIHdoaWNoIG11c3QgYmUgdXNlZCBhcyBmaXJzdCBtZW1iZXIgb2YgdXNlciBkYXRhIHN0cnVjdHVyZXMuCisgKiBoYXNoIHRhYmxlLgogICogSWRlYWxseSBpdCBzaG91bGQgYmUgZm9sbG93ZWQgYnkgYW4gaW50LXNpemVkIG1lbWJlciB0byBwcmV2ZW50IHVudXNlZAogICogbWVtb3J5IG9uIDY0LWJpdCBzeXN0ZW1zIGR1ZSB0byBhbGlnbm1lbnQuCiAgKi8KQEAgLTE2OCw3ICsxNzYsOCBAQAogICogVGhlIGBoYXNobWFwX2NtcF9mbl9kYXRhYCBlbnRyeSBpcyB0aGUgcG9pbnRlciBnaXZlbiBpbiB0aGUgaW5pdCBmdW5jdGlvbi4KICAqLwogdHlwZWRlZiBpbnQgKCpoYXNobWFwX2NtcF9mbikoY29uc3Qgdm9pZCAqaGFzaG1hcF9jbXBfZm5fZGF0YSwKLQkJCSAgICAgIGNvbnN0IHZvaWQgKmVudHJ5LCBjb25zdCB2b2lkICplbnRyeV9vcl9rZXksCisJCQkgICAgICBjb25zdCBzdHJ1Y3QgaGFzaG1hcF9lbnRyeSAqZW50cnksCisJCQkgICAgICBjb25zdCBzdHJ1Y3QgaGFzaG1hcF9lbnRyeSAqZW50cnlfb3Jfa2V5LAogCQkJICAgICAgY29uc3Qgdm9pZCAqa2V5ZGF0YSk7CiAKIC8qCkBAIC0yMjMsMTMgKzIzMiwyMCBAQAogCQkJIGNvbnN0IHZvaWQgKmVxdWFsc19mdW5jdGlvbl9kYXRhLAogCQkJIHNpemVfdCBpbml0aWFsX3NpemUpOwogCisvKiBpbnRlcm5hbCBmdW5jdGlvbiBmb3IgZnJlZWluZyBoYXNobWFwICovCit2b2lkIGhhc2htYXBfZnJlZV8oc3RydWN0IGhhc2htYXAgKm1hcCwgc3NpemVfdCBvZmZzZXQpOworCiAvKgotICogRnJlZXMgYSBoYXNobWFwIHN0cnVjdHVyZSBhbmQgYWxsb2NhdGVkIG1lbW9yeS4KLSAqCi0gKiBJZiBgZnJlZV9lbnRyaWVzYCBpcyB0cnVlLCBlYWNoIGhhc2htYXBfZW50cnkgaW4gdGhlIG1hcCBpcyBmcmVlZCBhcyB3ZWxsCi0gKiB1c2luZyBzdGRsaWJzIGZyZWUoKS4KKyAqIEZyZWVzIGEgaGFzaG1hcCBzdHJ1Y3R1cmUgYW5kIGFsbG9jYXRlZCBtZW1vcnksIGxlYXZlcyBlbnRyaWVzIHVuZGlzdHVyYmVkCiAgKi8KLXZvaWQgaGFzaG1hcF9mcmVlKHN0cnVjdCBoYXNobWFwICptYXAsIGludCBmcmVlX2VudHJpZXMpOworI2RlZmluZSBoYXNobWFwX2ZyZWUobWFwKSBoYXNobWFwX2ZyZWVfKG1hcCwgLTEpCisKKy8qCisgKiBGcmVlcyBAbWFwIGFuZCBhbGwgZW50cmllcy4gIEB0eXBlIGlzIHRoZSBzdHJ1Y3QgdHlwZSBvZiB0aGUgZW50cnkKKyAqIHdoZXJlIEBtZW1iZXIgaXMgdGhlIGhhc2htYXBfZW50cnkgc3RydWN0IHVzZWQgdG8gYXNzb2NpYXRlIHdpdGggQG1hcAorICovCisjZGVmaW5lIGhhc2htYXBfZnJlZV9lbnRyaWVzKG1hcCwgdHlwZSwgbWVtYmVyKSBcCisJaGFzaG1hcF9mcmVlXyhtYXAsIG9mZnNldG9mKHR5cGUsIG1lbWJlcikpOwogCiAvKiBoYXNobWFwX2VudHJ5IGZ1bmN0aW9ucyAqLwogCkBAIC0yNDQsOSArMjYwLDkgQEAKICAqIHlvdXIgc3RydWN0dXJlIHdhcyBhbGxvY2F0ZWQgd2l0aCB4bWFsbG9jKCksIHlvdSBjYW4ganVzdCBmcmVlKDMpIGl0LAogICogYW5kIGlmIGl0IGlzIG9uIHN0YWNrLCB5b3UgY2FuIGp1c3QgbGV0IGl0IGdvIG91dCBvZiBzY29wZSkuCiAgKi8KLXN0YXRpYyBpbmxpbmUgdm9pZCBoYXNobWFwX2VudHJ5X2luaXQodm9pZCAqZW50cnksIHVuc2lnbmVkIGludCBoYXNoKQorc3RhdGljIGlubGluZSB2b2lkIGhhc2htYXBfZW50cnlfaW5pdChzdHJ1Y3QgaGFzaG1hcF9lbnRyeSAqZSwKKwkJCQkJdW5zaWduZWQgaW50IGhhc2gpCiB7Ci0Jc3RydWN0IGhhc2htYXBfZW50cnkgKmUgPSBlbnRyeTsKIAllLT5oYXNoID0gaGFzaDsKIAllLT5uZXh0ID0gTlVMTDsKIH0KQEAgLTI4Niw4ICszMDIsOSBAQAogICogSWYgYW4gZW50cnkgd2l0aCBtYXRjaGluZyBoYXNoIGNvZGUgaXMgZm91bmQsIGBrZXlgIGFuZCBga2V5ZGF0YWAgYXJlIHBhc3NlZAogICogdG8gYGhhc2htYXBfY21wX2ZuYCB0byBkZWNpZGUgd2hldGhlciB0aGUgZW50cnkgbWF0Y2hlcyB0aGUga2V5LgogICovCi12b2lkICpoYXNobWFwX2dldChjb25zdCBzdHJ1Y3QgaGFzaG1hcCAqbWFwLCBjb25zdCB2b2lkICprZXksCi0JCQkgY29uc3Qgdm9pZCAqa2V5ZGF0YSk7CitzdHJ1Y3QgaGFzaG1hcF9lbnRyeSAqaGFzaG1hcF9nZXQoY29uc3Qgc3RydWN0IGhhc2htYXAgKm1hcCwKKwkJCQljb25zdCBzdHJ1Y3QgaGFzaG1hcF9lbnRyeSAqa2V5LAorCQkJCWNvbnN0IHZvaWQgKmtleWRhdGEpOwogCiAvKgogICogUmV0dXJucyB0aGUgaGFzaG1hcCBlbnRyeSBmb3IgdGhlIHNwZWNpZmllZCBoYXNoIGNvZGUgYW5kIGtleSBkYXRhLApAQCAtMzAxLDkgKzMxOCwxMCBAQAogICogYGVudHJ5X29yX2tleWAgcGFyYW1ldGVyIG9mIGBoYXNobWFwX2NtcF9mbmAgcG9pbnRzIHRvIGEgaGFzaG1hcF9lbnRyeQogICogc3RydWN0dXJlIHRoYXQgc2hvdWxkIG5vdCBiZSB1c2VkIGluIHRoZSBjb21wYXJpc29uLgogICovCi1zdGF0aWMgaW5saW5lIHZvaWQgKmhhc2htYXBfZ2V0X2Zyb21faGFzaChjb25zdCBzdHJ1Y3QgaGFzaG1hcCAqbWFwLAotCQkJCQkgIHVuc2lnbmVkIGludCBoYXNoLAotCQkJCQkgIGNvbnN0IHZvaWQgKmtleWRhdGEpCitzdGF0aWMgaW5saW5lIHN0cnVjdCBoYXNobWFwX2VudHJ5ICpoYXNobWFwX2dldF9mcm9tX2hhc2goCisJCQkJCWNvbnN0IHN0cnVjdCBoYXNobWFwICptYXAsCisJCQkJCXVuc2lnbmVkIGludCBoYXNoLAorCQkJCQljb25zdCB2b2lkICprZXlkYXRhKQogewogCXN0cnVjdCBoYXNobWFwX2VudHJ5IGtleTsKIAloYXNobWFwX2VudHJ5X2luaXQoJmtleSwgaGFzaCk7CkBAIC0zMTgsNyArMzM2LDggQEAKICAqIGBlbnRyeWAgaXMgdGhlIGhhc2htYXBfZW50cnkgdG8gc3RhcnQgdGhlIHNlYXJjaCBmcm9tLCBvYnRhaW5lZCB2aWEgYSBwcmV2aW91cwogICogY2FsbCB0byBgaGFzaG1hcF9nZXRgIG9yIGBoYXNobWFwX2dldF9uZXh0YC4KICAqLwotdm9pZCAqaGFzaG1hcF9nZXRfbmV4dChjb25zdCBzdHJ1Y3QgaGFzaG1hcCAqbWFwLCBjb25zdCB2b2lkICplbnRyeSk7CitzdHJ1Y3QgaGFzaG1hcF9lbnRyeSAqaGFzaG1hcF9nZXRfbmV4dChjb25zdCBzdHJ1Y3QgaGFzaG1hcCAqbWFwLAorCQkJY29uc3Qgc3RydWN0IGhhc2htYXBfZW50cnkgKmVudHJ5KTsKIAogLyoKICAqIEFkZHMgYSBoYXNobWFwIGVudHJ5LiBUaGlzIGFsbG93cyB0byBhZGQgZHVwbGljYXRlIGVudHJpZXMgKGkuZS4KQEAgLTMyNyw3ICszNDYsNyBAQAogICogYG1hcGAgaXMgdGhlIGhhc2htYXAgc3RydWN0dXJlLgogICogYGVudHJ5YCBpcyB0aGUgZW50cnkgdG8gYWRkLgogICovCi12b2lkIGhhc2htYXBfYWRkKHN0cnVjdCBoYXNobWFwICptYXAsIHZvaWQgKmVudHJ5KTsKK3ZvaWQgaGFzaG1hcF9hZGQoc3RydWN0IGhhc2htYXAgKm1hcCwgc3RydWN0IGhhc2htYXBfZW50cnkgKmVudHJ5KTsKIAogLyoKICAqIEFkZHMgb3IgcmVwbGFjZXMgYSBoYXNobWFwIGVudHJ5LiBJZiB0aGUgaGFzaG1hcCBjb250YWlucyBkdXBsaWNhdGUKQEAgLTMzNyw3ICszNTYsMjAgQEAKICAqIGBlbnRyeWAgaXMgdGhlIGVudHJ5IHRvIGFkZCBvciByZXBsYWNlLgogICogUmV0dXJucyB0aGUgcmVwbGFjZWQgZW50cnksIG9yIE5VTEwgaWYgbm90IGZvdW5kIChpLmUuIHRoZSBlbnRyeSB3YXMgYWRkZWQpLgogICovCi12b2lkICpoYXNobWFwX3B1dChzdHJ1Y3QgaGFzaG1hcCAqbWFwLCB2b2lkICplbnRyeSk7CitzdHJ1Y3QgaGFzaG1hcF9lbnRyeSAqaGFzaG1hcF9wdXQoc3RydWN0IGhhc2htYXAgKm1hcCwKKwkJCQlzdHJ1Y3QgaGFzaG1hcF9lbnRyeSAqZW50cnkpOworCisvKgorICogQWRkcyBvciByZXBsYWNlcyBhIGhhc2htYXAgZW50cnkgY29udGFpbmVkIHdpdGhpbiBAa2V5dmFyLAorICogd2hlcmUgQGtleXZhciBpcyBhIHBvaW50ZXIgdG8gYSBzdHJ1Y3QgY29udGFpbmluZyBhCisgKiAic3RydWN0IGhhc2htYXBfZW50cnkiIEBtZW1iZXIuCisgKgorICogUmV0dXJucyB0aGUgcmVwbGFjZWQgcG9pbnRlciB3aGljaCBpcyBvZiB0aGUgc2FtZSB0eXBlIGFzIEBrZXl2YXIsCisgKiBvciBOVUxMIGlmIG5vdCBmb3VuZC4KKyAqLworI2RlZmluZSBoYXNobWFwX3B1dF9lbnRyeShtYXAsIGtleXZhciwgbWVtYmVyKSBcCisJY29udGFpbmVyX29mX29yX251bGxfb2Zmc2V0KGhhc2htYXBfcHV0KG1hcCwgJihrZXl2YXIpLT5tZW1iZXIpLCBcCisJCQkJT0ZGU0VUT0ZfVkFSKGtleXZhciwgbWVtYmVyKSkKIAogLyoKICAqIFJlbW92ZXMgYSBoYXNobWFwIGVudHJ5IG1hdGNoaW5nIHRoZSBzcGVjaWZpZWQga2V5LiBJZiB0aGUgaGFzaG1hcCBjb250YWlucwpAQCAtMzQ2LDggKzM3OCwyNCBAQAogICoKICAqIEFyZ3VtZW50IGV4cGxhbmF0aW9uIGlzIHRoZSBzYW1lIGFzIGluIGBoYXNobWFwX2dldGAuCiAgKi8KLXZvaWQgKmhhc2htYXBfcmVtb3ZlKHN0cnVjdCBoYXNobWFwICptYXAsIGNvbnN0IHZvaWQgKmtleSwKLQkJY29uc3Qgdm9pZCAqa2V5ZGF0YSk7CitzdHJ1Y3QgaGFzaG1hcF9lbnRyeSAqaGFzaG1hcF9yZW1vdmUoc3RydWN0IGhhc2htYXAgKm1hcCwKKwkJCQkJY29uc3Qgc3RydWN0IGhhc2htYXBfZW50cnkgKmtleSwKKwkJCQkJY29uc3Qgdm9pZCAqa2V5ZGF0YSk7CisKKy8qCisgKiBSZW1vdmVzIGEgaGFzaG1hcCBlbnRyeSBjb250YWluZWQgd2l0aGluIEBrZXl2YXIsCisgKiB3aGVyZSBAa2V5dmFyIGlzIGEgcG9pbnRlciB0byBhIHN0cnVjdCBjb250YWluaW5nIGEKKyAqICJzdHJ1Y3QgaGFzaG1hcF9lbnRyeSIgQG1lbWJlci4KKyAqCisgKiBTZWUgYGhhc2htYXBfZ2V0YCBmb3IgYW4gZXhwbGFuYXRpb24gb2YgQGtleWRhdGEKKyAqCisgKiBSZXR1cm5zIHRoZSByZXBsYWNlZCBwb2ludGVyIHdoaWNoIGlzIG9mIHRoZSBzYW1lIHR5cGUgYXMgQGtleXZhciwKKyAqIG9yIE5VTEwgaWYgbm90IGZvdW5kLgorICovCisjZGVmaW5lIGhhc2htYXBfcmVtb3ZlX2VudHJ5KG1hcCwga2V5dmFyLCBtZW1iZXIsIGtleWRhdGEpIFwKKwljb250YWluZXJfb2Zfb3JfbnVsbF9vZmZzZXQoIFwKKwkJCWhhc2htYXBfcmVtb3ZlKG1hcCwgJihrZXl2YXIpLT5tZW1iZXIsIGtleWRhdGEpLCBcCisJCQlPRkZTRVRPRl9WQVIoa2V5dmFyLCBtZW1iZXIpKQogCiAvKgogICogUmV0dXJucyB0aGUgYGJ1Y2tldGAgYW4gZW50cnkgaXMgc3RvcmVkIGluLgpAQCAtMzcwLDEwICs0MTgsMTAgQEAKIHZvaWQgaGFzaG1hcF9pdGVyX2luaXQoc3RydWN0IGhhc2htYXAgKm1hcCwgc3RydWN0IGhhc2htYXBfaXRlciAqaXRlcik7CiAKIC8qIFJldHVybnMgdGhlIG5leHQgaGFzaG1hcF9lbnRyeSwgb3IgTlVMTCBpZiB0aGVyZSBhcmUgbm8gbW9yZSBlbnRyaWVzLiAqLwotdm9pZCAqaGFzaG1hcF9pdGVyX25leHQoc3RydWN0IGhhc2htYXBfaXRlciAqaXRlcik7CitzdHJ1Y3QgaGFzaG1hcF9lbnRyeSAqaGFzaG1hcF9pdGVyX25leHQoc3RydWN0IGhhc2htYXBfaXRlciAqaXRlcik7CiAKIC8qIEluaXRpYWxpemVzIHRoZSBpdGVyYXRvciBhbmQgcmV0dXJucyB0aGUgZmlyc3QgZW50cnksIGlmIGFueS4gKi8KLXN0YXRpYyBpbmxpbmUgdm9pZCAqaGFzaG1hcF9pdGVyX2ZpcnN0KHN0cnVjdCBoYXNobWFwICptYXAsCitzdGF0aWMgaW5saW5lIHN0cnVjdCBoYXNobWFwX2VudHJ5ICpoYXNobWFwX2l0ZXJfZmlyc3Qoc3RydWN0IGhhc2htYXAgKm1hcCwKIAkJc3RydWN0IGhhc2htYXBfaXRlciAqaXRlcikKIHsKIAloYXNobWFwX2l0ZXJfaW5pdChtYXAsIGl0ZXIpOwpAQCAtMzgxLDYgKzQyOSw2NCBAQAogfQogCiAvKgorICogcmV0dXJucyB0aGUgZmlyc3QgZW50cnkgaW4gQG1hcCB1c2luZyBAaXRlciwgd2hlcmUgdGhlIGVudHJ5IGlzIG9mCisgKiBAdHlwZSAoZS5nLiAic3RydWN0IGZvbyIpIGFuZCBAbWVtYmVyIGlzIHRoZSBuYW1lIG9mIHRoZQorICogInN0cnVjdCBoYXNobWFwX2VudHJ5IiBpbiBAdHlwZQorICovCisjZGVmaW5lIGhhc2htYXBfaXRlcl9maXJzdF9lbnRyeShtYXAsIGl0ZXIsIHR5cGUsIG1lbWJlcikgXAorCWNvbnRhaW5lcl9vZl9vcl9udWxsKGhhc2htYXBfaXRlcl9maXJzdChtYXAsIGl0ZXIpLCB0eXBlLCBtZW1iZXIpCisKKy8qIGludGVybmFsIG1hY3JvIGZvciBoYXNobWFwX2Zvcl9lYWNoX2VudHJ5ICovCisjZGVmaW5lIGhhc2htYXBfaXRlcl9uZXh0X2VudHJ5X29mZnNldChpdGVyLCBvZmZzZXQpIFwKKwljb250YWluZXJfb2Zfb3JfbnVsbF9vZmZzZXQoaGFzaG1hcF9pdGVyX25leHQoaXRlciksIG9mZnNldCkKKworLyogaW50ZXJuYWwgbWFjcm8gZm9yIGhhc2htYXBfZm9yX2VhY2hfZW50cnkgKi8KKyNkZWZpbmUgaGFzaG1hcF9pdGVyX2ZpcnN0X2VudHJ5X29mZnNldChtYXAsIGl0ZXIsIG9mZnNldCkgXAorCWNvbnRhaW5lcl9vZl9vcl9udWxsX29mZnNldChoYXNobWFwX2l0ZXJfZmlyc3QobWFwLCBpdGVyKSwgb2Zmc2V0KQorCisvKgorICogaXRlcmF0ZSB0aHJvdWdoIEBtYXAgdXNpbmcgQGl0ZXIsIEB2YXIgaXMgYSBwb2ludGVyIHRvIGEgdHlwZQorICogY29udGFpbmluZyBhIEBtZW1iZXIgd2hpY2ggaXMgYSAic3RydWN0IGhhc2htYXBfZW50cnkiCisgKi8KKyNkZWZpbmUgaGFzaG1hcF9mb3JfZWFjaF9lbnRyeShtYXAsIGl0ZXIsIHZhciwgbWVtYmVyKSBcCisJZm9yICh2YXIgPSBoYXNobWFwX2l0ZXJfZmlyc3RfZW50cnlfb2Zmc2V0KG1hcCwgaXRlciwgXAorCQkJCQkJT0ZGU0VUT0ZfVkFSKHZhciwgbWVtYmVyKSk7IFwKKwkJdmFyOyBcCisJCXZhciA9IGhhc2htYXBfaXRlcl9uZXh0X2VudHJ5X29mZnNldChpdGVyLCBcCisJCQkJCQlPRkZTRVRPRl9WQVIodmFyLCBtZW1iZXIpKSkKKworLyoKKyAqIHJldHVybnMgYSBwb2ludGVyIG9mIHR5cGUgbWF0Y2hpbmcgQGtleXZhciwgb3IgTlVMTCBpZiBub3RoaW5nIGZvdW5kLgorICogQGtleXZhciBpcyBhIHBvaW50ZXIgdG8gYSBzdHJ1Y3QgY29udGFpbmluZyBhCisgKiAic3RydWN0IGhhc2htYXBfZW50cnkiIEBtZW1iZXIuCisgKi8KKyNkZWZpbmUgaGFzaG1hcF9nZXRfZW50cnkobWFwLCBrZXl2YXIsIG1lbWJlciwga2V5ZGF0YSkgXAorCWNvbnRhaW5lcl9vZl9vcl9udWxsX29mZnNldCggXAorCQkJCWhhc2htYXBfZ2V0KG1hcCwgJihrZXl2YXIpLT5tZW1iZXIsIGtleWRhdGEpLCBcCisJCQkJT0ZGU0VUT0ZfVkFSKGtleXZhciwgbWVtYmVyKSkKKworI2RlZmluZSBoYXNobWFwX2dldF9lbnRyeV9mcm9tX2hhc2gobWFwLCBoYXNoLCBrZXlkYXRhLCB0eXBlLCBtZW1iZXIpIFwKKwljb250YWluZXJfb2Zfb3JfbnVsbChoYXNobWFwX2dldF9mcm9tX2hhc2gobWFwLCBoYXNoLCBrZXlkYXRhKSwgXAorCQkJCXR5cGUsIG1lbWJlcikKKy8qCisgKiByZXR1cm5zIHRoZSBuZXh0IGVxdWFsIHBvaW50ZXIgdG8gQHZhciwgb3IgTlVMTCBpZiBub3QgZm91bmQuCisgKiBAdmFyIGlzIGEgcG9pbnRlciBvZiBhbnkgdHlwZSBjb250YWluaW5nICJzdHJ1Y3QgaGFzaG1hcF9lbnRyeSIKKyAqIEBtZW1iZXIgaXMgdGhlIG5hbWUgb2YgdGhlICJzdHJ1Y3QgaGFzaG1hcF9lbnRyeSIgZmllbGQKKyAqLworI2RlZmluZSBoYXNobWFwX2dldF9uZXh0X2VudHJ5KG1hcCwgdmFyLCBtZW1iZXIpIFwKKwljb250YWluZXJfb2Zfb3JfbnVsbF9vZmZzZXQoaGFzaG1hcF9nZXRfbmV4dChtYXAsICYodmFyKS0+bWVtYmVyKSwgXAorCQkJCU9GRlNFVE9GX1ZBUih2YXIsIG1lbWJlcikpCisKKy8qCisgKiBpdGVyYXRlIEBtYXAgc3RhcnRpbmcgZnJvbSBAdmFyLCB3aGVyZSBAdmFyIGlzIGEgcG9pbnRlciBvZiBAdHlwZQorICogYW5kIEBtZW1iZXIgaXMgdGhlIG5hbWUgb2YgdGhlICJzdHJ1Y3QgaGFzaG1hcF9lbnRyeSIgZmllbGQgaW4gQHR5cGUKKyAqLworI2RlZmluZSBoYXNobWFwX2Zvcl9lYWNoX2VudHJ5X2Zyb20obWFwLCB2YXIsIG1lbWJlcikgXAorCWZvciAoOyBcCisJCXZhcjsgXAorCQl2YXIgPSBoYXNobWFwX2dldF9uZXh0X2VudHJ5KG1hcCwgdmFyLCBtZW1iZXIpKQorCisvKgogICogRGlzYWJsZSBpdGVtIGNvdW50aW5nIGFuZCBhdXRvbWF0aWMgcmVoYXNoaW5nIHdoZW4gYWRkaW5nL3JlbW92aW5nIGl0ZW1zLgogICoKICAqIE5vcm1hbGx5LCB0aGUgaGFzaG1hcCBrZWVwcyB0cmFjayBvZiB0aGUgbnVtYmVyIG9mIGl0ZW1zIGluIHRoZSBtYXAKQEAgLTM5Niw3ICs1MDIsNyBAQAogfQogCiAvKgotICogUmUtZW5hYmxlIGl0ZW0gY291dGluZyB3aGVuIGFkZGluZy9yZW1vdmluZyBpdGVtcy4KKyAqIFJlLWVuYWJsZSBpdGVtIGNvdW50aW5nIHdoZW4gYWRkaW5nL3JlbW92aW5nIGl0ZW1zLgogICogSWYgY291bnRpbmcgaXMgY3VycmVudGx5IGRpc2FibGVkLCBpdCB3aWxsIGZvcmNlIGNvdW50IHRoZW0uCiAgKiBJdCBXSUxMIE5PVCBhdXRvbWF0aWNhbGx5IHJlaGFzaCB0aGVtLgogICovCmRpZmYgLS1naXQgYS9oZWxwLmMgYi9oZWxwLmMKaW5kZXggNTI2MWQ4My4uY2Y2NzYyNCAxMDA2NDQKLS0tIGEvaGVscC5jCisrKyBiL2hlbHAuYwpAQCAtMzQsNyArMzQsNyBAQAogCXsgQ0FUX2ZvcmVpZ25zY21pbnRlcmZhY2UsIE5fKCJJbnRlcmFjdGluZyB3aXRoIE90aGVycyIpIH0sCiAJeyBDQVRfcGx1bWJpbmdtYW5pcHVsYXRvcnMsIE5fKCJMb3ctbGV2ZWwgQ29tbWFuZHMgLyBNYW5pcHVsYXRvcnMiKSB9LAogCXsgQ0FUX3BsdW1iaW5naW50ZXJyb2dhdG9ycywgTl8oIkxvdy1sZXZlbCBDb21tYW5kcyAvIEludGVycm9nYXRvcnMiKSB9LAotCXsgQ0FUX3N5bmNoaW5ncmVwb3NpdG9yaWVzLCBOXygiTG93LWxldmVsIENvbW1hbmRzIC8gU3luY2hpbmcgUmVwb3NpdG9yaWVzIikgfSwKKwl7IENBVF9zeW5jaGluZ3JlcG9zaXRvcmllcywgTl8oIkxvdy1sZXZlbCBDb21tYW5kcyAvIFN5bmNpbmcgUmVwb3NpdG9yaWVzIikgfSwKIAl7IENBVF9wdXJlaGVscGVycywgTl8oIkxvdy1sZXZlbCBDb21tYW5kcyAvIEludGVybmFsIEhlbHBlcnMiKSB9LAogCXsgMCwgTlVMTCB9CiB9OwpAQCAtNzc0LDcgKzc3NCw4IEBACiAJcmV0dXJuIHNpbWlsYXJfcmVmczsKIH0KIAotdm9pZCBoZWxwX3Vua25vd25fcmVmKGNvbnN0IGNoYXIgKnJlZiwgY29uc3QgY2hhciAqY21kLCBjb25zdCBjaGFyICplcnJvcikKK05PUkVUVVJOIHZvaWQgaGVscF91bmtub3duX3JlZihjb25zdCBjaGFyICpyZWYsIGNvbnN0IGNoYXIgKmNtZCwKKwkJCSAgICAgICBjb25zdCBjaGFyICplcnJvcikKIHsKIAlpbnQgaTsKIAlzdHJ1Y3Qgc3RyaW5nX2xpc3Qgc3VnZ2VzdGVkX3JlZnMgPSBndWVzc19yZWZzKHJlZik7CmRpZmYgLS1naXQgYS9oZWxwLmggYi9oZWxwLmgKaW5kZXggYjg3ODBmYi4uN2E0NTViZSAxMDA2NDQKLS0tIGEvaGVscC5oCisrKyBiL2hlbHAuaApAQCAtNDMsNyArNDMsNyBAQAogICogY2FsbCB0aGlzIHRvIGRpZSgpLCB3aGVuIGl0IGlzIHN1c3BlY3RlZCB0aGF0IHRoZSB1c2VyIG1pc3R5cGVkIGEKICAqIHJlZiB0byB0aGUgY29tbWFuZCwgdG8gZ2l2ZSBzdWdnZXN0ZWQgImNvcnJlY3QiIHJlZnMuCiAgKi8KLXZvaWQgaGVscF91bmtub3duX3JlZihjb25zdCBjaGFyICpyZWYsIGNvbnN0IGNoYXIgKmNtZCwgY29uc3QgY2hhciAqZXJyb3IpOworTk9SRVRVUk4gdm9pZCBoZWxwX3Vua25vd25fcmVmKGNvbnN0IGNoYXIgKnJlZiwgY29uc3QgY2hhciAqY21kLCBjb25zdCBjaGFyICplcnJvcik7CiAKIHN0YXRpYyBpbmxpbmUgdm9pZCBsaXN0X2NvbmZpZ19pdGVtKHN0cnVjdCBzdHJpbmdfbGlzdCAqbGlzdCwKIAkJCQkgICAgY29uc3QgY2hhciAqcHJlZml4LApkaWZmIC0tZ2l0IGEvaGV4LmMgYi9oZXguYwppbmRleCA3ODUwYTg4Li5mZDdmMDBjIDEwMDY0NAotLS0gYS9oZXguYworKysgYi9oZXguYwpAQCAtOTAsMTEgKzkwLDYgQEAKIAlyZXR1cm4gYnVmZmVyOwogfQogCi1jaGFyICpzaGExX3RvX2hleF9yKGNoYXIgKmJ1ZmZlciwgY29uc3QgdW5zaWduZWQgY2hhciAqc2hhMSkKLXsKLQlyZXR1cm4gaGFzaF90b19oZXhfYWxnb3BfcihidWZmZXIsIHNoYTEsICZoYXNoX2FsZ29zW0dJVF9IQVNIX1NIQTFdKTsKLX0KLQogY2hhciAqb2lkX3RvX2hleF9yKGNoYXIgKmJ1ZmZlciwgY29uc3Qgc3RydWN0IG9iamVjdF9pZCAqb2lkKQogewogCXJldHVybiBoYXNoX3RvX2hleF9hbGdvcF9yKGJ1ZmZlciwgb2lkLT5oYXNoLCB0aGVfaGFzaF9hbGdvKTsKQEAgLTEwOCwxMSArMTAzLDYgQEAKIAlyZXR1cm4gaGFzaF90b19oZXhfYWxnb3BfcihoZXhidWZmZXJbYnVmbm9dLCBoYXNoLCBhbGdvcCk7CiB9CiAKLWNoYXIgKnNoYTFfdG9faGV4KGNvbnN0IHVuc2lnbmVkIGNoYXIgKnNoYTEpCi17Ci0JcmV0dXJuIGhhc2hfdG9faGV4X2FsZ29wKHNoYTEsICZoYXNoX2FsZ29zW0dJVF9IQVNIX1NIQTFdKTsKLX0KLQogY2hhciAqaGFzaF90b19oZXgoY29uc3QgdW5zaWduZWQgY2hhciAqaGFzaCkKIHsKIAlyZXR1cm4gaGFzaF90b19oZXhfYWxnb3AoaGFzaCwgdGhlX2hhc2hfYWxnbyk7CmRpZmYgLS1naXQgYS9odHRwLXB1c2guYyBiL2h0dHAtcHVzaC5jCmluZGV4IDAzNTNmOWYuLjgyMmYzMjYgMTAwNjQ0Ci0tLSBhL2h0dHAtcHVzaC5jCisrKyBiL2h0dHAtcHVzaC5jCkBAIC01MDEsMTAgKzUwMSwxMCBAQAogCWlmIChyZXF1ZXN0ID09IHJlcXVlc3RfcXVldWVfaGVhZCkgewogCQlyZXF1ZXN0X3F1ZXVlX2hlYWQgPSByZXF1ZXN0LT5uZXh0OwogCX0gZWxzZSB7Ci0JCXdoaWxlIChlbnRyeS0+bmV4dCAhPSBOVUxMICYmIGVudHJ5LT5uZXh0ICE9IHJlcXVlc3QpCisJCXdoaWxlIChlbnRyeSAmJiBlbnRyeS0+bmV4dCAhPSByZXF1ZXN0KQogCQkJZW50cnkgPSBlbnRyeS0+bmV4dDsKLQkJaWYgKGVudHJ5LT5uZXh0ID09IHJlcXVlc3QpCi0JCQllbnRyeS0+bmV4dCA9IGVudHJ5LT5uZXh0LT5uZXh0OworCQlpZiAoZW50cnkpCisJCQllbnRyeS0+bmV4dCA9IHJlcXVlc3QtPm5leHQ7CiAJfQogCiAJZnJlZShyZXF1ZXN0LT51cmwpOwpAQCAtOTgxLDcgKzk4MSw3IEBACiAJCXdoaWxlIChwcmV2ICYmIHByZXYtPm5leHQgIT0gbG9jaykKIAkJCXByZXYgPSBwcmV2LT5uZXh0OwogCQlpZiAocHJldikKLQkJCXByZXYtPm5leHQgPSBwcmV2LT5uZXh0LT5uZXh0OworCQkJcHJldi0+bmV4dCA9IGxvY2stPm5leHQ7CiAJfQogCiAJZnJlZShsb2NrLT5vd25lcik7CmRpZmYgLS1naXQgYS9odHRwLmMgYi9odHRwLmMKaW5kZXggMjdhYTBhMy4uNWYzNDgxNiAxMDA2NDQKLS0tIGEvaHR0cC5jCisrKyBiL2h0dHAuYwpAQCAtMTUwLDcgKzE1MCw3IEBACiAKIHN0YXRpYyBzdHJ1Y3QgY3VybF9zbGlzdCAqcHJhZ21hX2hlYWRlcjsKIHN0YXRpYyBzdHJ1Y3QgY3VybF9zbGlzdCAqbm9fcHJhZ21hX2hlYWRlcjsKLXN0YXRpYyBzdHJ1Y3QgY3VybF9zbGlzdCAqZXh0cmFfaHR0cF9oZWFkZXJzOworc3RhdGljIHN0cnVjdCBzdHJpbmdfbGlzdCBleHRyYV9odHRwX2hlYWRlcnMgPSBTVFJJTkdfTElTVF9JTklUX0RVUDsKIAogc3RhdGljIHN0cnVjdCBhY3RpdmVfcmVxdWVzdF9zbG90ICphY3RpdmVfcXVldWVfaGVhZDsKIApAQCAtNDE0LDExICs0MTQsOSBAQAogCQlpZiAoIXZhbHVlKSB7CiAJCQlyZXR1cm4gY29uZmlnX2Vycm9yX25vbmJvb2wodmFyKTsKIAkJfSBlbHNlIGlmICghKnZhbHVlKSB7Ci0JCQljdXJsX3NsaXN0X2ZyZWVfYWxsKGV4dHJhX2h0dHBfaGVhZGVycyk7Ci0JCQlleHRyYV9odHRwX2hlYWRlcnMgPSBOVUxMOworCQkJc3RyaW5nX2xpc3RfY2xlYXIoJmV4dHJhX2h0dHBfaGVhZGVycywgMCk7CiAJCX0gZWxzZSB7Ci0JCQlleHRyYV9odHRwX2hlYWRlcnMgPQotCQkJCWN1cmxfc2xpc3RfYXBwZW5kKGV4dHJhX2h0dHBfaGVhZGVycywgdmFsdWUpOworCQkJc3RyaW5nX2xpc3RfYXBwZW5kKCZleHRyYV9odHRwX2hlYWRlcnMsIHZhbHVlKTsKIAkJfQogCQlyZXR1cm4gMDsKIAl9CkBAIC01MTMsOSArNTExLDExIEBACiAjZWxzZQogCQlzdHJ1Y3Qgc3RyYnVmIHMgPSBTVFJCVUZfSU5JVDsKIAotCQlzdHJidWZfYWRkc3RyX3VybGVuY29kZSgmcywgcHJveHlfYXV0aC51c2VybmFtZSwgMSk7CisJCXN0cmJ1Zl9hZGRzdHJfdXJsZW5jb2RlKCZzLCBwcm94eV9hdXRoLnVzZXJuYW1lLAorCQkJCQlpc19yZmMzOTg2X3VucmVzZXJ2ZWQpOwogCQlzdHJidWZfYWRkY2goJnMsICc6Jyk7Ci0JCXN0cmJ1Zl9hZGRzdHJfdXJsZW5jb2RlKCZzLCBwcm94eV9hdXRoLnBhc3N3b3JkLCAxKTsKKwkJc3RyYnVmX2FkZHN0cl91cmxlbmNvZGUoJnMsIHByb3h5X2F1dGgucGFzc3dvcmQsCisJCQkJCWlzX3JmYzM5ODZfdW5yZXNlcnZlZCk7CiAJCWN1cmxfcHJveHl1c2VycHdkID0gc3RyYnVmX2RldGFjaCgmcywgTlVMTCk7CiAJCWN1cmxfZWFzeV9zZXRvcHQocmVzdWx0LCBDVVJMT1BUX1BST1hZVVNFUlBXRCwgY3VybF9wcm94eXVzZXJwd2QpOwogI2VuZGlmCkBAIC0xMDczLDYgKzEwNzMsNyBAQAogCiAJZ2l0X2NvbmZpZyh1cmxtYXRjaF9jb25maWdfZW50cnksICZjb25maWcpOwogCWZyZWUobm9ybWFsaXplZF91cmwpOworCXN0cmluZ19saXN0X2NsZWFyKCZjb25maWcudmFycywgMSk7CiAKICNpZiBMSUJDVVJMX1ZFUlNJT05fTlVNID49IDB4MDczODAwCiAJaWYgKGh0dHBfc3NsX2JhY2tlbmQpIHsKQEAgLTExOTksOCArMTIwMCw3IEBACiAjZW5kaWYKIAljdXJsX2dsb2JhbF9jbGVhbnVwKCk7CiAKLQljdXJsX3NsaXN0X2ZyZWVfYWxsKGV4dHJhX2h0dHBfaGVhZGVycyk7Ci0JZXh0cmFfaHR0cF9oZWFkZXJzID0gTlVMTDsKKwlzdHJpbmdfbGlzdF9jbGVhcigmZXh0cmFfaHR0cF9oZWFkZXJzLCAwKTsKIAogCWN1cmxfc2xpc3RfZnJlZV9hbGwocHJhZ21hX2hlYWRlcik7CiAJcHJhZ21hX2hlYWRlciA9IE5VTEw7CkBAIC0xNjI0LDEwICsxNjI0LDExIEBACiAKIHN0cnVjdCBjdXJsX3NsaXN0ICpodHRwX2NvcHlfZGVmYXVsdF9oZWFkZXJzKHZvaWQpCiB7Ci0Jc3RydWN0IGN1cmxfc2xpc3QgKmhlYWRlcnMgPSBOVUxMLCAqaDsKKwlzdHJ1Y3QgY3VybF9zbGlzdCAqaGVhZGVycyA9IE5VTEw7CisJY29uc3Qgc3RydWN0IHN0cmluZ19saXN0X2l0ZW0gKml0ZW07CiAKLQlmb3IgKGggPSBleHRyYV9odHRwX2hlYWRlcnM7IGg7IGggPSBoLT5uZXh0KQotCQloZWFkZXJzID0gY3VybF9zbGlzdF9hcHBlbmQoaGVhZGVycywgaC0+ZGF0YSk7CisJZm9yX2VhY2hfc3RyaW5nX2xpc3RfaXRlbShpdGVtLCAmZXh0cmFfaHR0cF9oZWFkZXJzKQorCQloZWFkZXJzID0gY3VybF9zbGlzdF9hcHBlbmQoaGVhZGVycywgaXRlbS0+c3RyaW5nKTsKIAogCXJldHVybiBoZWFkZXJzOwogfQpkaWZmIC0tZ2l0IGEvaHR0cC5oIGIvaHR0cC5oCmluZGV4IGI0MjlmMWMuLjVlMGFkNzIgMTAwNjQ0Ci0tLSBhL2h0dHAuaAorKysgYi9odHRwLmgKQEAgLTI1LDggKzI1LDEyIEBACiAjaWYgTElCQ1VSTF9WRVJTSU9OX05VTSA8IDB4MDcwNzA0CiAjZGVmaW5lIGN1cmxfZ2xvYmFsX2NsZWFudXAoKSBkbyB7IC8qIG5vdGhpbmcgKi8gfSB3aGlsZSAoMCkKICNlbmRpZgorCiAjaWYgTElCQ1VSTF9WRVJTSU9OX05VTSA8IDB4MDcwODAwCiAjZGVmaW5lIGN1cmxfZ2xvYmFsX2luaXQoYSkgZG8geyAvKiBub3RoaW5nICovIH0gd2hpbGUgKDApCisjZWxpZiBMSUJDVVJMX1ZFUlNJT05fTlVNID49IDB4MDcwYzAwCisjZGVmaW5lIGN1cmxfZ2xvYmFsX2luaXQoYSkgY3VybF9nbG9iYWxfaW5pdF9tZW0oYSwgeG1hbGxvYywgZnJlZSwgXAorCQkJCQkJeHJlYWxsb2MsIHhzdHJkdXAsIHhjYWxsb2MpCiAjZW5kaWYKIAogI2lmIChMSUJDVVJMX1ZFUlNJT05fTlVNIDwgMHgwNzBjMDQpIHx8IChMSUJDVVJMX1ZFUlNJT05fTlVNID09IDB4MDcxMDAwKQpkaWZmIC0tZ2l0IGEva3dzZXQuaCBiL2t3c2V0LmgKaW5kZXggZGY5OWE5Mi4uZjUwZWNhZSAxMDA2NDQKLS0tIGEva3dzZXQuaAorKysgYi9rd3NldC5oCkBAIC0xLDMgKzEsNiBAQAorI2lmbmRlZiBLV1NFVF9ICisjZGVmaW5lIEtXU0VUX0gKKwogLyogVGhpcyBmaWxlIGhhcyBiZWVuIGNvcGllZCBmcm9tIGNvbW1pdCBlN2FjNzEzZF4gaW4gdGhlIEdOVSBncmVwIGdpdAogICogcmVwb3NpdG9yeS4gQSBmZXcgc21hbGwgY2hhbmdlcyBoYXZlIGJlZW4gbWFkZSB0byBhZGFwdCB0aGUgY29kZSB0bwogICogR2l0LgpAQCAtNTksMyArNjIsNCBAQAogLyogRGVhbGxvY2F0ZSB0aGUgZ2l2ZW4ga2V5d29yZCBzZXQgYW5kIGFsbCBpdHMgYXNzb2NpYXRlZCBzdG9yYWdlLiAqLwogdm9pZCBrd3NmcmVlKGt3c2V0X3QpOwogCisjZW5kaWYgLyogS1dTRVRfSCAqLwpkaWZmIC0tZ2l0IGEvbGluZS1sb2cuYyBiL2xpbmUtbG9nLmMKaW5kZXggM2FmZjE4NDkuLjkwMTBlMDAgMTAwNjQ0Ci0tLSBhL2xpbmUtbG9nLmMKKysrIGIvbGluZS1sb2cuYwpAQCAtNzM3LDYgKzczNywzOCBAQAogCXJldHVybiByZXQ7CiB9CiAKK3N0YXRpYyBpbnQgc2FtZV9wYXRoc19pbl9wYXRoc3BlY19hbmRfcmFuZ2Uoc3RydWN0IHBhdGhzcGVjICpwYXRoc3BlYywKKwkJCQkJICAgIHN0cnVjdCBsaW5lX2xvZ19kYXRhICpyYW5nZSkKK3sKKwlpbnQgaTsKKwlzdHJ1Y3QgbGluZV9sb2dfZGF0YSAqcjsKKworCWZvciAoaSA9IDAsIHIgPSByYW5nZTsgaSA8IHBhdGhzcGVjLT5uciAmJiByOyBpKyssIHIgPSByLT5uZXh0KQorCQlpZiAoc3RyY21wKHBhdGhzcGVjLT5pdGVtc1tpXS5tYXRjaCwgci0+cGF0aCkpCisJCQlyZXR1cm4gMDsKKwlpZiAoaSA8IHBhdGhzcGVjLT5uciB8fCByKQorCQkvKiBkaWZmZXJlbnQgbnVtYmVyIG9mIHBhdGhzcGVjIGl0ZW1zIGFuZCByYW5nZXMgKi8KKwkJcmV0dXJuIDA7CisKKwlyZXR1cm4gMTsKK30KKworc3RhdGljIHZvaWQgcGFyc2VfcGF0aHNwZWNfZnJvbV9yYW5nZXMoc3RydWN0IHBhdGhzcGVjICpwYXRoc3BlYywKKwkJCQkgICAgICAgc3RydWN0IGxpbmVfbG9nX2RhdGEgKnJhbmdlKQoreworCXN0cnVjdCBsaW5lX2xvZ19kYXRhICpyOworCXN0cnVjdCBhcmd2X2FycmF5IGFycmF5ID0gQVJHVl9BUlJBWV9JTklUOworCWNvbnN0IGNoYXIgKipwYXRoczsKKworCWZvciAociA9IHJhbmdlOyByOyByID0gci0+bmV4dCkKKwkJYXJndl9hcnJheV9wdXNoKCZhcnJheSwgci0+cGF0aCk7CisJcGF0aHMgPSBhcmd2X2FycmF5X2RldGFjaCgmYXJyYXkpOworCisJcGFyc2VfcGF0aHNwZWMocGF0aHNwZWMsIDAsIFBBVEhTUEVDX1BSRUZFUl9GVUxMLCAiIiwgcGF0aHMpOworCS8qIHN0cmluZ3MgYXJlIG5vdyBvd25lZCBieSBwYXRoc3BlYyAqLworCWZyZWUocGF0aHMpOworfQorCiB2b2lkIGxpbmVfbG9nX2luaXQoc3RydWN0IHJldl9pbmZvICpyZXYsIGNvbnN0IGNoYXIgKnByZWZpeCwgc3RydWN0IHN0cmluZ19saXN0ICphcmdzKQogewogCXN0cnVjdCBjb21taXQgKmNvbW1pdCA9IE5VTEw7CkBAIC03NDYsMjAgKzc3OCw3IEBACiAJcmFuZ2UgPSBwYXJzZV9saW5lcyhyZXYtPmRpZmZvcHQucmVwbywgY29tbWl0LCBwcmVmaXgsIGFyZ3MpOwogCWFkZF9saW5lX3JhbmdlKHJldiwgY29tbWl0LCByYW5nZSk7CiAKLQlpZiAoIXJldi0+ZGlmZm9wdC5kZXRlY3RfcmVuYW1lKSB7Ci0JCXN0cnVjdCBsaW5lX2xvZ19kYXRhICpyOwotCQlzdHJ1Y3QgYXJndl9hcnJheSBhcnJheSA9IEFSR1ZfQVJSQVlfSU5JVDsKLQkJY29uc3QgY2hhciAqKnBhdGhzOwotCi0JCWZvciAociA9IHJhbmdlOyByOyByID0gci0+bmV4dCkKLQkJCWFyZ3ZfYXJyYXlfcHVzaCgmYXJyYXksIHItPnBhdGgpOwotCQlwYXRocyA9IGFyZ3ZfYXJyYXlfZGV0YWNoKCZhcnJheSk7Ci0KLQkJcGFyc2VfcGF0aHNwZWMoJnJldi0+ZGlmZm9wdC5wYXRoc3BlYywgMCwKLQkJCSAgICAgICBQQVRIU1BFQ19QUkVGRVJfRlVMTCwgIiIsIHBhdGhzKTsKLQkJLyogc3RyaW5ncyBhcmUgbm93IG93bmVkIGJ5IHBhdGhzcGVjICovCi0JCWZyZWUocGF0aHMpOwotCX0KKwlwYXJzZV9wYXRoc3BlY19mcm9tX3JhbmdlcygmcmV2LT5kaWZmb3B0LnBhdGhzcGVjLCByYW5nZSk7CiB9CiAKIHN0YXRpYyB2b2lkIG1vdmVfZGlmZl9xdWV1ZShzdHJ1Y3QgZGlmZl9xdWV1ZV9zdHJ1Y3QgKmRzdCwKQEAgLTgxNywxNSArODM2LDI5IEBACiAJCQlzdHJ1Y3QgZGlmZl9xdWV1ZV9zdHJ1Y3QgKnF1ZXVlLAogCQkJc3RydWN0IGNvbW1pdCAqY29tbWl0LCBzdHJ1Y3QgY29tbWl0ICpwYXJlbnQpCiB7CisJc3RydWN0IG9iamVjdF9pZCAqdHJlZV9vaWQsICpwYXJlbnRfdHJlZV9vaWQ7CisKIAlhc3NlcnQoY29tbWl0KTsKIAorCXRyZWVfb2lkID0gZ2V0X2NvbW1pdF90cmVlX29pZChjb21taXQpOworCXBhcmVudF90cmVlX29pZCA9IHBhcmVudCA/IGdldF9jb21taXRfdHJlZV9vaWQocGFyZW50KSA6IE5VTEw7CisKKwlpZiAob3B0LT5kZXRlY3RfcmVuYW1lICYmCisJICAgICFzYW1lX3BhdGhzX2luX3BhdGhzcGVjX2FuZF9yYW5nZSgmb3B0LT5wYXRoc3BlYywgcmFuZ2UpKSB7CisJCWNsZWFyX3BhdGhzcGVjKCZvcHQtPnBhdGhzcGVjKTsKKwkJcGFyc2VfcGF0aHNwZWNfZnJvbV9yYW5nZXMoJm9wdC0+cGF0aHNwZWMsIHJhbmdlKTsKKwl9CiAJRElGRl9RVUVVRV9DTEVBUigmZGlmZl9xdWV1ZWRfZGlmZik7Ci0JZGlmZl90cmVlX29pZChwYXJlbnQgPyBnZXRfY29tbWl0X3RyZWVfb2lkKHBhcmVudCkgOiBOVUxMLAotCQkgICAgICBnZXRfY29tbWl0X3RyZWVfb2lkKGNvbW1pdCksICIiLCBvcHQpOwotCWlmIChvcHQtPmRldGVjdF9yZW5hbWUpIHsKKwlkaWZmX3RyZWVfb2lkKHBhcmVudF90cmVlX29pZCwgdHJlZV9vaWQsICIiLCBvcHQpOworCWlmIChvcHQtPmRldGVjdF9yZW5hbWUgJiYgZGlmZl9taWdodF9iZV9yZW5hbWUoKSkgeworCQkvKiBtdXN0IGxvb2sgYXQgdGhlIGZ1bGwgdHJlZSBkaWZmIHRvIGRldGVjdCByZW5hbWVzICovCisJCWNsZWFyX3BhdGhzcGVjKCZvcHQtPnBhdGhzcGVjKTsKKwkJRElGRl9RVUVVRV9DTEVBUigmZGlmZl9xdWV1ZWRfZGlmZik7CisKKwkJZGlmZl90cmVlX29pZChwYXJlbnRfdHJlZV9vaWQsIHRyZWVfb2lkLCAiIiwgb3B0KTsKKwogCQlmaWx0ZXJfZGlmZnNfZm9yX3BhdGhzKHJhbmdlLCAxKTsKLQkJaWYgKGRpZmZfbWlnaHRfYmVfcmVuYW1lKCkpCi0JCQlkaWZmY29yZV9zdGQob3B0KTsKKwkJZGlmZmNvcmVfc3RkKG9wdCk7CiAJCWZpbHRlcl9kaWZmc19mb3JfcGF0aHMocmFuZ2UsIDApOwogCX0KIAltb3ZlX2RpZmZfcXVldWUocXVldWUsICZkaWZmX3F1ZXVlZF9kaWZmKTsKZGlmZiAtLWdpdCBhL2xpc3Qtb2JqZWN0cy1maWx0ZXItb3B0aW9ucy5jIGIvbGlzdC1vYmplY3RzLWZpbHRlci1vcHRpb25zLmMKaW5kZXggMWNiMjBjNi4uMjU2YmNmYiAxMDA2NDQKLS0tIGEvbGlzdC1vYmplY3RzLWZpbHRlci1vcHRpb25zLmMKKysrIGIvbGlzdC1vYmplY3RzLWZpbHRlci1vcHRpb25zLmMKQEAgLTYsNiArNiwxNCBAQAogI2luY2x1ZGUgImxpc3Qtb2JqZWN0cy5oIgogI2luY2x1ZGUgImxpc3Qtb2JqZWN0cy1maWx0ZXIuaCIKICNpbmNsdWRlICJsaXN0LW9iamVjdHMtZmlsdGVyLW9wdGlvbnMuaCIKKyNpbmNsdWRlICJwcm9taXNvci1yZW1vdGUuaCIKKyNpbmNsdWRlICJ0cmFjZS5oIgorI2luY2x1ZGUgInVybC5oIgorCitzdGF0aWMgaW50IHBhcnNlX2NvbWJpbmVfZmlsdGVyKAorCXN0cnVjdCBsaXN0X29iamVjdHNfZmlsdGVyX29wdGlvbnMgKmZpbHRlcl9vcHRpb25zLAorCWNvbnN0IGNoYXIgKmFyZywKKwlzdHJ1Y3Qgc3RyYnVmICplcnJidWYpOwogCiAvKgogICogUGFyc2UgdmFsdWUgb2YgdGhlIGFyZ3VtZW50IHRvIHRoZSAiZmlsdGVyIiBrZXl3b3JkLgpAQCAtMjksMTYgKzM3LDExIEBACiB7CiAJY29uc3QgY2hhciAqdjA7CiAKLQlpZiAoZmlsdGVyX29wdGlvbnMtPmNob2ljZSkgewotCQlpZiAoZXJyYnVmKSB7Ci0JCQlzdHJidWZfYWRkc3RyKAotCQkJCWVycmJ1ZiwKLQkJCQlfKCJtdWx0aXBsZSBmaWx0ZXItc3BlY3MgY2Fubm90IGJlIGNvbWJpbmVkIikpOwotCQl9Ci0JCXJldHVybiAxOwotCX0KKwlpZiAoIWFyZykKKwkJcmV0dXJuIDA7CiAKLQlmaWx0ZXJfb3B0aW9ucy0+ZmlsdGVyX3NwZWMgPSBzdHJkdXAoYXJnKTsKKwlpZiAoZmlsdGVyX29wdGlvbnMtPmNob2ljZSkKKwkJQlVHKCJmaWx0ZXJfb3B0aW9ucyBhbHJlYWR5IHBvcHVsYXRlZCIpOwogCiAJaWYgKCFzdHJjbXAoYXJnLCAiYmxvYjpub25lIikpIHsKIAkJZmlsdGVyX29wdGlvbnMtPmNob2ljZSA9IExPRkNfQkxPQl9OT05FOwpAQCAtNTIsMjggKzU1LDE0IEBACiAKIAl9IGVsc2UgaWYgKHNraXBfcHJlZml4KGFyZywgInRyZWU6IiwgJnYwKSkgewogCQlpZiAoIWdpdF9wYXJzZV91bG9uZyh2MCwgJmZpbHRlcl9vcHRpb25zLT50cmVlX2V4Y2x1ZGVfZGVwdGgpKSB7Ci0JCQlpZiAoZXJyYnVmKSB7Ci0JCQkJc3RyYnVmX2FkZHN0cigKLQkJCQkJZXJyYnVmLAotCQkJCQlfKCJleHBlY3RlZCAndHJlZTo8ZGVwdGg+JyIpKTsKLQkJCX0KKwkJCXN0cmJ1Zl9hZGRzdHIoZXJyYnVmLCBfKCJleHBlY3RlZCAndHJlZTo8ZGVwdGg+JyIpKTsKIAkJCXJldHVybiAxOwogCQl9CiAJCWZpbHRlcl9vcHRpb25zLT5jaG9pY2UgPSBMT0ZDX1RSRUVfREVQVEg7CiAJCXJldHVybiAwOwogCiAJfSBlbHNlIGlmIChza2lwX3ByZWZpeChhcmcsICJzcGFyc2U6b2lkPSIsICZ2MCkpIHsKLQkJc3RydWN0IG9iamVjdF9jb250ZXh0IG9jOwotCQlzdHJ1Y3Qgb2JqZWN0X2lkIHNwYXJzZV9vaWQ7Ci0KLQkJLyoKLQkJICogVHJ5IHRvIHBhcnNlIDxvaWQtZXhwcmVzc2lvbj4gaW50byBhbiBPSUQgZm9yIHRoZSBjdXJyZW50Ci0JCSAqIGNvbW1hbmQsIGJ1dCBETyBOT1QgY29tcGxhaW4gaWYgd2UgZG9uJ3QgaGF2ZSB0aGUgYmxvYiBvcgotCQkgKiByZWYgbG9jYWxseS4KLQkJICovCi0JCWlmICghZ2V0X29pZF93aXRoX2NvbnRleHQodGhlX3JlcG9zaXRvcnksIHYwLCBHRVRfT0lEX0JMT0IsCi0JCQkJCSAgJnNwYXJzZV9vaWQsICZvYykpCi0JCQlmaWx0ZXJfb3B0aW9ucy0+c3BhcnNlX29pZF92YWx1ZSA9IG9pZGR1cCgmc3BhcnNlX29pZCk7CisJCWZpbHRlcl9vcHRpb25zLT5zcGFyc2Vfb2lkX25hbWUgPSB4c3RyZHVwKHYwKTsKIAkJZmlsdGVyX29wdGlvbnMtPmNob2ljZSA9IExPRkNfU1BBUlNFX09JRDsKIAkJcmV0dXJuIDA7CiAKQEAgLTg0LDI2ICs3MywxODkgQEAKIAkJCQlfKCJzcGFyc2U6cGF0aCBmaWx0ZXJzIHN1cHBvcnQgaGFzIGJlZW4gZHJvcHBlZCIpKTsKIAkJfQogCQlyZXR1cm4gMTsKKworCX0gZWxzZSBpZiAoc2tpcF9wcmVmaXgoYXJnLCAiY29tYmluZToiLCAmdjApKSB7CisJCXJldHVybiBwYXJzZV9jb21iaW5lX2ZpbHRlcihmaWx0ZXJfb3B0aW9ucywgdjAsIGVycmJ1Zik7CisKIAl9CiAJLyoKIAkgKiBQbGVhc2UgdXBkYXRlIF9naXRfZmV0Y2goKSBpbiBnaXQtY29tcGxldGlvbi5iYXNoIHdoZW4geW91CiAJICogYWRkIG5ldyBmaWx0ZXJzCiAJICovCiAKLQlpZiAoZXJyYnVmKQotCQlzdHJidWZfYWRkZihlcnJidWYsIF8oImludmFsaWQgZmlsdGVyLXNwZWMgJyVzJyIpLCBhcmcpOworCXN0cmJ1Zl9hZGRmKGVycmJ1ZiwgXygiaW52YWxpZCBmaWx0ZXItc3BlYyAnJXMnIiksIGFyZyk7CiAKIAltZW1zZXQoZmlsdGVyX29wdGlvbnMsIDAsIHNpemVvZigqZmlsdGVyX29wdGlvbnMpKTsKIAlyZXR1cm4gMTsKIH0KIAotaW50IHBhcnNlX2xpc3Rfb2JqZWN0c19maWx0ZXIoc3RydWN0IGxpc3Rfb2JqZWN0c19maWx0ZXJfb3B0aW9ucyAqZmlsdGVyX29wdGlvbnMsCi0JCQkgICAgICBjb25zdCBjaGFyICphcmcpCitzdGF0aWMgY29uc3QgY2hhciAqUkVTRVJWRURfTk9OX1dTID0gIn5gIUAjJF4mKigpW117fVxcOydcIiw8Pj8iOworCitzdGF0aWMgaW50IGhhc19yZXNlcnZlZF9jaGFyYWN0ZXIoCisJc3RydWN0IHN0cmJ1ZiAqc3ViX3NwZWMsIHN0cnVjdCBzdHJidWYgKmVycmJ1ZikKK3sKKwljb25zdCBjaGFyICpjID0gc3ViX3NwZWMtPmJ1ZjsKKwl3aGlsZSAoKmMpIHsKKwkJaWYgKCpjIDw9ICcgJyB8fCBzdHJjaHIoUkVTRVJWRURfTk9OX1dTLCAqYykpIHsKKwkJCXN0cmJ1Zl9hZGRmKAorCQkJCWVycmJ1ZiwKKwkJCQlfKCJtdXN0IGVzY2FwZSBjaGFyIGluIHN1Yi1maWx0ZXItc3BlYzogJyVjJyIpLAorCQkJCSpjKTsKKwkJCXJldHVybiAxOworCQl9CisJCWMrKzsKKwl9CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGludCBwYXJzZV9jb21iaW5lX3N1YmZpbHRlcigKKwlzdHJ1Y3QgbGlzdF9vYmplY3RzX2ZpbHRlcl9vcHRpb25zICpmaWx0ZXJfb3B0aW9ucywKKwlzdHJ1Y3Qgc3RyYnVmICpzdWJzcGVjLAorCXN0cnVjdCBzdHJidWYgKmVycmJ1ZikKK3sKKwlzaXplX3QgbmV3X2luZGV4ID0gZmlsdGVyX29wdGlvbnMtPnN1Yl9ucjsKKwljaGFyICpkZWNvZGVkOworCWludCByZXN1bHQ7CisKKwlBTExPQ19HUk9XX0JZKGZpbHRlcl9vcHRpb25zLT5zdWIsIGZpbHRlcl9vcHRpb25zLT5zdWJfbnIsIDEsCisJCSAgICAgIGZpbHRlcl9vcHRpb25zLT5zdWJfYWxsb2MpOworCisJZGVjb2RlZCA9IHVybF9wZXJjZW50X2RlY29kZShzdWJzcGVjLT5idWYpOworCisJcmVzdWx0ID0gaGFzX3Jlc2VydmVkX2NoYXJhY3RlcihzdWJzcGVjLCBlcnJidWYpIHx8CisJCWdlbnRseV9wYXJzZV9saXN0X29iamVjdHNfZmlsdGVyKAorCQkJJmZpbHRlcl9vcHRpb25zLT5zdWJbbmV3X2luZGV4XSwgZGVjb2RlZCwgZXJyYnVmKTsKKworCWZyZWUoZGVjb2RlZCk7CisJcmV0dXJuIHJlc3VsdDsKK30KKworc3RhdGljIGludCBwYXJzZV9jb21iaW5lX2ZpbHRlcigKKwlzdHJ1Y3QgbGlzdF9vYmplY3RzX2ZpbHRlcl9vcHRpb25zICpmaWx0ZXJfb3B0aW9ucywKKwljb25zdCBjaGFyICphcmcsCisJc3RydWN0IHN0cmJ1ZiAqZXJyYnVmKQoreworCXN0cnVjdCBzdHJidWYgKipzdWJzcGVjcyA9IHN0cmJ1Zl9zcGxpdF9zdHIoYXJnLCAnKycsIDApOworCXNpemVfdCBzdWI7CisJaW50IHJlc3VsdCA9IDA7CisKKwlpZiAoIXN1YnNwZWNzWzBdKSB7CisJCXN0cmJ1Zl9hZGRzdHIoZXJyYnVmLCBfKCJleHBlY3RlZCBzb21ldGhpbmcgYWZ0ZXIgY29tYmluZToiKSk7CisJCXJlc3VsdCA9IDE7CisJCWdvdG8gY2xlYW51cDsKKwl9CisKKwlmb3IgKHN1YiA9IDA7IHN1YnNwZWNzW3N1Yl0gJiYgIXJlc3VsdDsgc3ViKyspIHsKKwkJaWYgKHN1YnNwZWNzW3N1YiArIDFdKSB7CisJCQkvKgorCQkJICogVGhpcyBpcyBub3QgdGhlIGxhc3Qgc3Vic3BlYy4gUmVtb3ZlIHRyYWlsaW5nICIrIiBzbworCQkJICogd2UgY2FuIHBhcnNlIGl0LgorCQkJICovCisJCQlzaXplX3QgbGFzdCA9IHN1YnNwZWNzW3N1Yl0tPmxlbiAtIDE7CisJCQlhc3NlcnQoc3Vic3BlY3Nbc3ViXS0+YnVmW2xhc3RdID09ICcrJyk7CisJCQlzdHJidWZfcmVtb3ZlKHN1YnNwZWNzW3N1Yl0sIGxhc3QsIDEpOworCQl9CisJCXJlc3VsdCA9IHBhcnNlX2NvbWJpbmVfc3ViZmlsdGVyKAorCQkJZmlsdGVyX29wdGlvbnMsIHN1YnNwZWNzW3N1Yl0sIGVycmJ1Zik7CisJfQorCisJZmlsdGVyX29wdGlvbnMtPmNob2ljZSA9IExPRkNfQ09NQklORTsKKworY2xlYW51cDoKKwlzdHJidWZfbGlzdF9mcmVlKHN1YnNwZWNzKTsKKwlpZiAocmVzdWx0KSB7CisJCWxpc3Rfb2JqZWN0c19maWx0ZXJfcmVsZWFzZShmaWx0ZXJfb3B0aW9ucyk7CisJCW1lbXNldChmaWx0ZXJfb3B0aW9ucywgMCwgc2l6ZW9mKCpmaWx0ZXJfb3B0aW9ucykpOworCX0KKwlyZXR1cm4gcmVzdWx0OworfQorCitzdGF0aWMgaW50IGFsbG93X3VuZW5jb2RlZChjaGFyIGNoKQoreworCWlmIChjaCA8PSAnICcgfHwgY2ggPT0gJyUnIHx8IGNoID09ICcrJykKKwkJcmV0dXJuIDA7CisJcmV0dXJuICFzdHJjaHIoUkVTRVJWRURfTk9OX1dTLCBjaCk7Cit9CisKK3N0YXRpYyB2b2lkIGZpbHRlcl9zcGVjX2FwcGVuZF91cmxlbmNvZGUoCisJc3RydWN0IGxpc3Rfb2JqZWN0c19maWx0ZXJfb3B0aW9ucyAqZmlsdGVyLCBjb25zdCBjaGFyICpyYXcpCiB7CiAJc3RydWN0IHN0cmJ1ZiBidWYgPSBTVFJCVUZfSU5JVDsKLQlpZiAoZ2VudGx5X3BhcnNlX2xpc3Rfb2JqZWN0c19maWx0ZXIoZmlsdGVyX29wdGlvbnMsIGFyZywgJmJ1ZikpCi0JCWRpZSgiJXMiLCBidWYuYnVmKTsKLQlyZXR1cm4gMDsKKwlzdHJidWZfYWRkc3RyX3VybGVuY29kZSgmYnVmLCByYXcsIGFsbG93X3VuZW5jb2RlZCk7CisJdHJhY2VfcHJpbnRmKCJBZGQgdG8gY29tYmluZSBmaWx0ZXItc3BlYzogJXNcbiIsIGJ1Zi5idWYpOworCXN0cmluZ19saXN0X2FwcGVuZCgmZmlsdGVyLT5maWx0ZXJfc3BlYywgc3RyYnVmX2RldGFjaCgmYnVmLCBOVUxMKSk7Cit9CisKKy8qCisgKiBDaGFuZ2VzIGZpbHRlcl9vcHRpb25zIGludG8gYW4gZXF1aXZhbGVudCBMT0ZDX0NPTUJJTkUgZmlsdGVyIG9wdGlvbnMKKyAqIGluc3RhbmNlLiBEb2VzIG5vdCBkbyBhbnl0aGluZyBpZiBmaWx0ZXJfb3B0aW9ucyBpcyBhbHJlYWR5IExPRkNfQ09NQklORS4KKyAqLworc3RhdGljIHZvaWQgdHJhbnNmb3JtX3RvX2NvbWJpbmVfdHlwZSgKKwlzdHJ1Y3QgbGlzdF9vYmplY3RzX2ZpbHRlcl9vcHRpb25zICpmaWx0ZXJfb3B0aW9ucykKK3sKKwlhc3NlcnQoZmlsdGVyX29wdGlvbnMtPmNob2ljZSk7CisJaWYgKGZpbHRlcl9vcHRpb25zLT5jaG9pY2UgPT0gTE9GQ19DT01CSU5FKQorCQlyZXR1cm47CisJeworCQljb25zdCBpbnQgaW5pdGlhbF9zdWJfYWxsb2MgPSAyOworCQlzdHJ1Y3QgbGlzdF9vYmplY3RzX2ZpbHRlcl9vcHRpb25zICpzdWJfYXJyYXkgPQorCQkJeGNhbGxvYyhpbml0aWFsX3N1Yl9hbGxvYywgc2l6ZW9mKCpzdWJfYXJyYXkpKTsKKwkJc3ViX2FycmF5WzBdID0gKmZpbHRlcl9vcHRpb25zOworCQltZW1zZXQoZmlsdGVyX29wdGlvbnMsIDAsIHNpemVvZigqZmlsdGVyX29wdGlvbnMpKTsKKwkJZmlsdGVyX29wdGlvbnMtPnN1YiA9IHN1Yl9hcnJheTsKKwkJZmlsdGVyX29wdGlvbnMtPnN1Yl9hbGxvYyA9IGluaXRpYWxfc3ViX2FsbG9jOworCX0KKwlmaWx0ZXJfb3B0aW9ucy0+c3ViX25yID0gMTsKKwlmaWx0ZXJfb3B0aW9ucy0+Y2hvaWNlID0gTE9GQ19DT01CSU5FOworCXN0cmluZ19saXN0X2FwcGVuZCgmZmlsdGVyX29wdGlvbnMtPmZpbHRlcl9zcGVjLCB4c3RyZHVwKCJjb21iaW5lOiIpKTsKKwlmaWx0ZXJfc3BlY19hcHBlbmRfdXJsZW5jb2RlKAorCQlmaWx0ZXJfb3B0aW9ucywKKwkJbGlzdF9vYmplY3RzX2ZpbHRlcl9zcGVjKCZmaWx0ZXJfb3B0aW9ucy0+c3ViWzBdKSk7CisJLyoKKwkgKiBXZSBkb24ndCBuZWVkIHRoZSBmaWx0ZXJfc3BlYyBzdHJpbmdzIGZvciBzdWJmaWx0ZXIgc3BlY3MsIG9ubHkgdGhlCisJICogdG9wIGxldmVsLgorCSAqLworCXN0cmluZ19saXN0X2NsZWFyKCZmaWx0ZXJfb3B0aW9ucy0+c3ViWzBdLmZpbHRlcl9zcGVjLCAvKmZyZWVfdXRpbD0qLzApOworfQorCit2b2lkIGxpc3Rfb2JqZWN0c19maWx0ZXJfZGllX2lmX3BvcHVsYXRlZCgKKwlzdHJ1Y3QgbGlzdF9vYmplY3RzX2ZpbHRlcl9vcHRpb25zICpmaWx0ZXJfb3B0aW9ucykKK3sKKwlpZiAoZmlsdGVyX29wdGlvbnMtPmNob2ljZSkKKwkJZGllKF8oIm11bHRpcGxlIGZpbHRlci1zcGVjcyBjYW5ub3QgYmUgY29tYmluZWQiKSk7Cit9CisKK3ZvaWQgcGFyc2VfbGlzdF9vYmplY3RzX2ZpbHRlcigKKwlzdHJ1Y3QgbGlzdF9vYmplY3RzX2ZpbHRlcl9vcHRpb25zICpmaWx0ZXJfb3B0aW9ucywKKwljb25zdCBjaGFyICphcmcpCit7CisJc3RydWN0IHN0cmJ1ZiBlcnJidWYgPSBTVFJCVUZfSU5JVDsKKwlpbnQgcGFyc2VfZXJyb3I7CisKKwlpZiAoIWZpbHRlcl9vcHRpb25zLT5jaG9pY2UpIHsKKwkJc3RyaW5nX2xpc3RfYXBwZW5kKCZmaWx0ZXJfb3B0aW9ucy0+ZmlsdGVyX3NwZWMsIHhzdHJkdXAoYXJnKSk7CisKKwkJcGFyc2VfZXJyb3IgPSBnZW50bHlfcGFyc2VfbGlzdF9vYmplY3RzX2ZpbHRlcigKKwkJCWZpbHRlcl9vcHRpb25zLCBhcmcsICZlcnJidWYpOworCX0gZWxzZSB7CisJCS8qCisJCSAqIE1ha2UgZmlsdGVyX29wdGlvbnMgYW4gTE9GQ19DT01CSU5FIHNwZWMgc28gd2UgY2FuIHRyaXZpYWxseQorCQkgKiBhZGQgc3Vic3BlY3MgdG8gaXQuCisJCSAqLworCQl0cmFuc2Zvcm1fdG9fY29tYmluZV90eXBlKGZpbHRlcl9vcHRpb25zKTsKKworCQlzdHJpbmdfbGlzdF9hcHBlbmQoJmZpbHRlcl9vcHRpb25zLT5maWx0ZXJfc3BlYywgeHN0cmR1cCgiKyIpKTsKKwkJZmlsdGVyX3NwZWNfYXBwZW5kX3VybGVuY29kZShmaWx0ZXJfb3B0aW9ucywgYXJnKTsKKwkJQUxMT0NfR1JPV19CWShmaWx0ZXJfb3B0aW9ucy0+c3ViLCBmaWx0ZXJfb3B0aW9ucy0+c3ViX25yLCAxLAorCQkJICAgICAgZmlsdGVyX29wdGlvbnMtPnN1Yl9hbGxvYyk7CisKKwkJcGFyc2VfZXJyb3IgPSBnZW50bHlfcGFyc2VfbGlzdF9vYmplY3RzX2ZpbHRlcigKKwkJCSZmaWx0ZXJfb3B0aW9ucy0+c3ViW2ZpbHRlcl9vcHRpb25zLT5zdWJfbnIgLSAxXSwgYXJnLAorCQkJJmVycmJ1Zik7CisJfQorCWlmIChwYXJzZV9lcnJvcikKKwkJZGllKCIlcyIsIGVycmJ1Zi5idWYpOwogfQogCiBpbnQgb3B0X3BhcnNlX2xpc3Rfb2JqZWN0c19maWx0ZXIoY29uc3Qgc3RydWN0IG9wdGlvbiAqb3B0LApAQCAtMTExLDc2ICsyNjMsMTA4IEBACiB7CiAJc3RydWN0IGxpc3Rfb2JqZWN0c19maWx0ZXJfb3B0aW9ucyAqZmlsdGVyX29wdGlvbnMgPSBvcHQtPnZhbHVlOwogCi0JaWYgKHVuc2V0IHx8ICFhcmcpIHsKKwlpZiAodW5zZXQgfHwgIWFyZykKIAkJbGlzdF9vYmplY3RzX2ZpbHRlcl9zZXRfbm9fZmlsdGVyKGZpbHRlcl9vcHRpb25zKTsKLQkJcmV0dXJuIDA7Ci0JfQotCi0JcmV0dXJuIHBhcnNlX2xpc3Rfb2JqZWN0c19maWx0ZXIoZmlsdGVyX29wdGlvbnMsIGFyZyk7CisJZWxzZQorCQlwYXJzZV9saXN0X29iamVjdHNfZmlsdGVyKGZpbHRlcl9vcHRpb25zLCBhcmcpOworCXJldHVybiAwOwogfQogCi12b2lkIGV4cGFuZF9saXN0X29iamVjdHNfZmlsdGVyX3NwZWMoCi0JY29uc3Qgc3RydWN0IGxpc3Rfb2JqZWN0c19maWx0ZXJfb3B0aW9ucyAqZmlsdGVyLAotCXN0cnVjdCBzdHJidWYgKmV4cGFuZGVkX3NwZWMpCitjb25zdCBjaGFyICpsaXN0X29iamVjdHNfZmlsdGVyX3NwZWMoc3RydWN0IGxpc3Rfb2JqZWN0c19maWx0ZXJfb3B0aW9ucyAqZmlsdGVyKQogewotCXN0cmJ1Zl9pbml0KGV4cGFuZGVkX3NwZWMsIHN0cmxlbihmaWx0ZXItPmZpbHRlcl9zcGVjKSk7Ci0JaWYgKGZpbHRlci0+Y2hvaWNlID09IExPRkNfQkxPQl9MSU1JVCkKLQkJc3RyYnVmX2FkZGYoZXhwYW5kZWRfc3BlYywgImJsb2I6bGltaXQ9JWx1IiwKKwlpZiAoIWZpbHRlci0+ZmlsdGVyX3NwZWMubnIpCisJCUJVRygibm8gZmlsdGVyX3NwZWMgYXZhaWxhYmxlIGZvciB0aGlzIGZpbHRlciIpOworCWlmIChmaWx0ZXItPmZpbHRlcl9zcGVjLm5yICE9IDEpIHsKKwkJc3RydWN0IHN0cmJ1ZiBjb25jYXR0ZWQgPSBTVFJCVUZfSU5JVDsKKwkJc3RyYnVmX2FkZF9zZXBhcmF0ZWRfc3RyaW5nX2xpc3QoCisJCQkmY29uY2F0dGVkLCAiIiwgJmZpbHRlci0+ZmlsdGVyX3NwZWMpOworCQlzdHJpbmdfbGlzdF9jbGVhcigmZmlsdGVyLT5maWx0ZXJfc3BlYywgLypmcmVlX3V0aWw9Ki8wKTsKKwkJc3RyaW5nX2xpc3RfYXBwZW5kKAorCQkJJmZpbHRlci0+ZmlsdGVyX3NwZWMsIHN0cmJ1Zl9kZXRhY2goJmNvbmNhdHRlZCwgTlVMTCkpOworCX0KKworCXJldHVybiBmaWx0ZXItPmZpbHRlcl9zcGVjLml0ZW1zWzBdLnN0cmluZzsKK30KKworY29uc3QgY2hhciAqZXhwYW5kX2xpc3Rfb2JqZWN0c19maWx0ZXJfc3BlYygKKwlzdHJ1Y3QgbGlzdF9vYmplY3RzX2ZpbHRlcl9vcHRpb25zICpmaWx0ZXIpCit7CisJaWYgKGZpbHRlci0+Y2hvaWNlID09IExPRkNfQkxPQl9MSU1JVCkgeworCQlzdHJ1Y3Qgc3RyYnVmIGV4cGFuZGVkX3NwZWMgPSBTVFJCVUZfSU5JVDsKKwkJc3RyYnVmX2FkZGYoJmV4cGFuZGVkX3NwZWMsICJibG9iOmxpbWl0PSVsdSIsCiAJCQkgICAgZmlsdGVyLT5ibG9iX2xpbWl0X3ZhbHVlKTsKLQllbHNlIGlmIChmaWx0ZXItPmNob2ljZSA9PSBMT0ZDX1RSRUVfREVQVEgpCi0JCXN0cmJ1Zl9hZGRmKGV4cGFuZGVkX3NwZWMsICJ0cmVlOiVsdSIsCi0JCQkgICAgZmlsdGVyLT50cmVlX2V4Y2x1ZGVfZGVwdGgpOwotCWVsc2UKLQkJc3RyYnVmX2FkZHN0cihleHBhbmRlZF9zcGVjLCBmaWx0ZXItPmZpbHRlcl9zcGVjKTsKKwkJc3RyaW5nX2xpc3RfY2xlYXIoJmZpbHRlci0+ZmlsdGVyX3NwZWMsIC8qZnJlZV91dGlsPSovMCk7CisJCXN0cmluZ19saXN0X2FwcGVuZCgKKwkJCSZmaWx0ZXItPmZpbHRlcl9zcGVjLAorCQkJc3RyYnVmX2RldGFjaCgmZXhwYW5kZWRfc3BlYywgTlVMTCkpOworCX0KKworCXJldHVybiBsaXN0X29iamVjdHNfZmlsdGVyX3NwZWMoZmlsdGVyKTsKIH0KIAogdm9pZCBsaXN0X29iamVjdHNfZmlsdGVyX3JlbGVhc2UoCiAJc3RydWN0IGxpc3Rfb2JqZWN0c19maWx0ZXJfb3B0aW9ucyAqZmlsdGVyX29wdGlvbnMpCiB7Ci0JZnJlZShmaWx0ZXJfb3B0aW9ucy0+ZmlsdGVyX3NwZWMpOwotCWZyZWUoZmlsdGVyX29wdGlvbnMtPnNwYXJzZV9vaWRfdmFsdWUpOworCXNpemVfdCBzdWI7CisKKwlpZiAoIWZpbHRlcl9vcHRpb25zKQorCQlyZXR1cm47CisJc3RyaW5nX2xpc3RfY2xlYXIoJmZpbHRlcl9vcHRpb25zLT5maWx0ZXJfc3BlYywgLypmcmVlX3V0aWw9Ki8wKTsKKwlmcmVlKGZpbHRlcl9vcHRpb25zLT5zcGFyc2Vfb2lkX25hbWUpOworCWZvciAoc3ViID0gMDsgc3ViIDwgZmlsdGVyX29wdGlvbnMtPnN1Yl9ucjsgc3ViKyspCisJCWxpc3Rfb2JqZWN0c19maWx0ZXJfcmVsZWFzZSgmZmlsdGVyX29wdGlvbnMtPnN1YltzdWJdKTsKKwlmcmVlKGZpbHRlcl9vcHRpb25zLT5zdWIpOwogCW1lbXNldChmaWx0ZXJfb3B0aW9ucywgMCwgc2l6ZW9mKCpmaWx0ZXJfb3B0aW9ucykpOwogfQogCiB2b2lkIHBhcnRpYWxfY2xvbmVfcmVnaXN0ZXIoCiAJY29uc3QgY2hhciAqcmVtb3RlLAotCWNvbnN0IHN0cnVjdCBsaXN0X29iamVjdHNfZmlsdGVyX29wdGlvbnMgKmZpbHRlcl9vcHRpb25zKQorCXN0cnVjdCBsaXN0X29iamVjdHNfZmlsdGVyX29wdGlvbnMgKmZpbHRlcl9vcHRpb25zKQogewotCS8qCi0JICogUmVjb3JkIHRoZSBuYW1lIG9mIHRoZSBwYXJ0aWFsIGNsb25lIHJlbW90ZSBpbiB0aGUKLQkgKiBjb25maWcgYW5kIGluIHRoZSBnbG9iYWwgdmFyaWFibGUgLS0gdGhlIGxhdHRlciBpcwotCSAqIHVzZWQgdGhyb3VnaG91dCB0byBpbmRpY2F0ZSB0aGF0IHBhcnRpYWwgY2xvbmUgaXMKLQkgKiBlbmFibGVkIGFuZCB0byBleHBlY3QgbWlzc2luZyBvYmplY3RzLgotCSAqLwotCWlmIChyZXBvc2l0b3J5X2Zvcm1hdF9wYXJ0aWFsX2Nsb25lICYmCi0JICAgICpyZXBvc2l0b3J5X2Zvcm1hdF9wYXJ0aWFsX2Nsb25lICYmCi0JICAgIHN0cmNtcChyZW1vdGUsIHJlcG9zaXRvcnlfZm9ybWF0X3BhcnRpYWxfY2xvbmUpKQotCQlkaWUoXygiY2Fubm90IGNoYW5nZSBwYXJ0aWFsIGNsb25lIHByb21pc29yIHJlbW90ZSIpKTsKKwljaGFyICpjZmdfbmFtZTsKKwljaGFyICpmaWx0ZXJfbmFtZTsKIAotCWdpdF9jb25maWdfc2V0KCJjb3JlLnJlcG9zaXRvcnlmb3JtYXR2ZXJzaW9uIiwgIjEiKTsKLQlnaXRfY29uZmlnX3NldCgiZXh0ZW5zaW9ucy5wYXJ0aWFsY2xvbmUiLCByZW1vdGUpOworCS8qIENoZWNrIGlmIGl0IGlzIGFscmVhZHkgcmVnaXN0ZXJlZCAqLworCWlmICghcHJvbWlzb3JfcmVtb3RlX2ZpbmQocmVtb3RlKSkgeworCQlnaXRfY29uZmlnX3NldCgiY29yZS5yZXBvc2l0b3J5Zm9ybWF0dmVyc2lvbiIsICIxIik7CiAKLQlyZXBvc2l0b3J5X2Zvcm1hdF9wYXJ0aWFsX2Nsb25lID0geHN0cmR1cChyZW1vdGUpOworCQkvKiBBZGQgcHJvbWlzb3IgY29uZmlnIGZvciB0aGUgcmVtb3RlICovCisJCWNmZ19uYW1lID0geHN0cmZtdCgicmVtb3RlLiVzLnByb21pc29yIiwgcmVtb3RlKTsKKwkJZ2l0X2NvbmZpZ19zZXQoY2ZnX25hbWUsICJ0cnVlIik7CisJCWZyZWUoY2ZnX25hbWUpOworCX0KIAogCS8qCiAJICogUmVjb3JkIHRoZSBpbml0aWFsIGZpbHRlci1zcGVjIGluIHRoZSBjb25maWcgYXMKIAkgKiB0aGUgZGVmYXVsdCBmb3Igc3Vic2VxdWVudCBmZXRjaGVzIGZyb20gdGhpcyByZW1vdGUuCiAJICovCi0JY29yZV9wYXJ0aWFsX2Nsb25lX2ZpbHRlcl9kZWZhdWx0ID0KLQkJeHN0cmR1cChmaWx0ZXJfb3B0aW9ucy0+ZmlsdGVyX3NwZWMpOwotCWdpdF9jb25maWdfc2V0KCJjb3JlLnBhcnRpYWxjbG9uZWZpbHRlciIsCi0JCSAgICAgICBjb3JlX3BhcnRpYWxfY2xvbmVfZmlsdGVyX2RlZmF1bHQpOworCWZpbHRlcl9uYW1lID0geHN0cmZtdCgicmVtb3RlLiVzLnBhcnRpYWxjbG9uZWZpbHRlciIsIHJlbW90ZSk7CisJLyogTkVFRFNXT1JLOiAnZXhwYW5kJyByZXN1bHQgbGVha2luZz8/PyAqLworCWdpdF9jb25maWdfc2V0KGZpbHRlcl9uYW1lLAorCQkgICAgICAgZXhwYW5kX2xpc3Rfb2JqZWN0c19maWx0ZXJfc3BlYyhmaWx0ZXJfb3B0aW9ucykpOworCWZyZWUoZmlsdGVyX25hbWUpOworCisJLyogTWFrZSBzdXJlIHRoZSBjb25maWcgaW5mbyBhcmUgcmVzZXQgKi8KKwlwcm9taXNvcl9yZW1vdGVfcmVpbml0KCk7CiB9CiAKIHZvaWQgcGFydGlhbF9jbG9uZV9nZXRfZGVmYXVsdF9maWx0ZXJfc3BlYygKLQlzdHJ1Y3QgbGlzdF9vYmplY3RzX2ZpbHRlcl9vcHRpb25zICpmaWx0ZXJfb3B0aW9ucykKKwlzdHJ1Y3QgbGlzdF9vYmplY3RzX2ZpbHRlcl9vcHRpb25zICpmaWx0ZXJfb3B0aW9ucywKKwljb25zdCBjaGFyICpyZW1vdGUpCiB7CisJc3RydWN0IHByb21pc29yX3JlbW90ZSAqcHJvbWlzb3IgPSBwcm9taXNvcl9yZW1vdGVfZmluZChyZW1vdGUpOworCXN0cnVjdCBzdHJidWYgZXJyYnVmID0gU1RSQlVGX0lOSVQ7CisKIAkvKgogCSAqIFBhcnNlIGRlZmF1bHQgdmFsdWUsIGJ1dCBzaWxlbnRseSBpZ25vcmUgaXQgaWYgaXQgaXMgaW52YWxpZC4KIAkgKi8KLQlpZiAoIWNvcmVfcGFydGlhbF9jbG9uZV9maWx0ZXJfZGVmYXVsdCkKKwlpZiAoIXByb21pc29yKQogCQlyZXR1cm47CisKKwlzdHJpbmdfbGlzdF9hcHBlbmQoJmZpbHRlcl9vcHRpb25zLT5maWx0ZXJfc3BlYywKKwkJCSAgIHByb21pc29yLT5wYXJ0aWFsX2Nsb25lX2ZpbHRlcik7CiAJZ2VudGx5X3BhcnNlX2xpc3Rfb2JqZWN0c19maWx0ZXIoZmlsdGVyX29wdGlvbnMsCi0JCQkJCSBjb3JlX3BhcnRpYWxfY2xvbmVfZmlsdGVyX2RlZmF1bHQsCi0JCQkJCSBOVUxMKTsKKwkJCQkJIHByb21pc29yLT5wYXJ0aWFsX2Nsb25lX2ZpbHRlciwKKwkJCQkJICZlcnJidWYpOworCXN0cmJ1Zl9yZWxlYXNlKCZlcnJidWYpOwogfQpkaWZmIC0tZ2l0IGEvbGlzdC1vYmplY3RzLWZpbHRlci1vcHRpb25zLmggYi9saXN0LW9iamVjdHMtZmlsdGVyLW9wdGlvbnMuaAppbmRleCBjNTRmMDAwLi4yZmZiMzkyIDEwMDY0NAotLS0gYS9saXN0LW9iamVjdHMtZmlsdGVyLW9wdGlvbnMuaAorKysgYi9saXN0LW9iamVjdHMtZmlsdGVyLW9wdGlvbnMuaApAQCAtMiw3ICsyLDcgQEAKICNkZWZpbmUgTElTVF9PQkpFQ1RTX0ZJTFRFUl9PUFRJT05TX0gKIAogI2luY2x1ZGUgInBhcnNlLW9wdGlvbnMuaCIKLSNpbmNsdWRlICJzdHJidWYuaCIKKyNpbmNsdWRlICJzdHJpbmctbGlzdC5oIgogCiAvKgogICogVGhlIGxpc3Qgb2YgZGVmaW5lZCBmaWx0ZXJzIGZvciBsaXN0LW9iamVjdHMuCkBAIC0xMyw2ICsxMyw3IEBACiAJTE9GQ19CTE9CX0xJTUlULAogCUxPRkNfVFJFRV9ERVBUSCwKIAlMT0ZDX1NQQVJTRV9PSUQsCisJTE9GQ19DT01CSU5FLAogCUxPRkNfX0NPVU5UIC8qIG11c3QgYmUgbGFzdCAqLwogfTsKIApAQCAtMjMsOCArMjQsMTAgQEAKIAkgKiBjb21tYW5kcyB0aGF0IGxhdW5jaCBmaWx0ZXJpbmcgc3ViLXByb2Nlc3Nlcywgb3IgZm9yIGNvbW11bmljYXRpb24KIAkgKiBvdmVyIHRoZSBuZXR3b3JrLCBkb24ndCB1c2UgdGhpcyB2YWx1ZTsgdXNlIHRoZSByZXN1bHQgb2YKIAkgKiBleHBhbmRfbGlzdF9vYmplY3RzX2ZpbHRlcl9zcGVjKCkgaW5zdGVhZC4KKwkgKiBUbyBnZXQgdGhlIHJhdyBmaWx0ZXIgc3BlYyBnaXZlbiBieSB0aGUgdXNlciwgdXNlIHRoZSByZXN1bHQgb2YKKwkgKiBsaXN0X29iamVjdHNfZmlsdGVyX3NwZWMoKS4KIAkgKi8KLQljaGFyICpmaWx0ZXJfc3BlYzsKKwlzdHJ1Y3Qgc3RyaW5nX2xpc3QgZmlsdGVyX3NwZWM7CiAKIAkvKgogCSAqICdjaG9pY2UnIGlzIGRldGVybWluZWQgYnkgcGFyc2luZyB0aGUgZmlsdGVyLXNwZWMuICBUaGlzIGluZGljYXRlcwpAQCAtMzgsMTkgKzQxLDQwIEBACiAJdW5zaWduZWQgaW50IG5vX2ZpbHRlciA6IDE7CiAKIAkvKgotCSAqIFBhcnNlZCB2YWx1ZXMgKGZpZWxkcykgZnJvbSB3aXRoaW4gdGhlIGZpbHRlci1zcGVjLiAgVGhlc2UgYXJlCi0JICogY2hvaWNlLXNwZWNpZmljOyBub3QgYWxsIHZhbHVlcyB3aWxsIGJlIGRlZmluZWQgZm9yIGFueSBnaXZlbgotCSAqIGNob2ljZS4KKwkgKiBCRUdJTiBjaG9pY2Utc3BlY2lmaWMgcGFyc2VkIHZhbHVlcyBmcm9tIHdpdGhpbiB0aGUgZmlsdGVyLXNwZWMuIE9ubHkKKwkgKiBzb21lIHZhbHVlcyB3aWxsIGJlIGRlZmluZWQgZm9yIGFueSBnaXZlbiBjaG9pY2UuCiAJICovCi0Jc3RydWN0IG9iamVjdF9pZCAqc3BhcnNlX29pZF92YWx1ZTsKKworCWNoYXIgKnNwYXJzZV9vaWRfbmFtZTsKIAl1bnNpZ25lZCBsb25nIGJsb2JfbGltaXRfdmFsdWU7CiAJdW5zaWduZWQgbG9uZyB0cmVlX2V4Y2x1ZGVfZGVwdGg7CisKKwkvKiBMT0ZDX0NPTUJJTkUgdmFsdWVzICovCisKKwkvKiBUaGlzIGFycmF5IGNvbnRhaW5zIGFsbCB0aGUgc3ViZmlsdGVycyB3aGljaCB0aGlzIGZpbHRlciBjb21iaW5lcy4gKi8KKwlzaXplX3Qgc3ViX25yLCBzdWJfYWxsb2M7CisJc3RydWN0IGxpc3Rfb2JqZWN0c19maWx0ZXJfb3B0aW9ucyAqc3ViOworCisJLyoKKwkgKiBFTkQgY2hvaWNlLXNwZWNpZmljIHBhcnNlZCB2YWx1ZXMuCisJICovCiB9OwogCiAvKiBOb3JtYWxpemVkIGNvbW1hbmQgbGluZSBhcmd1bWVudHMgKi8KICNkZWZpbmUgQ0xfQVJHX19GSUxURVIgImZpbHRlciIKIAotaW50IHBhcnNlX2xpc3Rfb2JqZWN0c19maWx0ZXIoCit2b2lkIGxpc3Rfb2JqZWN0c19maWx0ZXJfZGllX2lmX3BvcHVsYXRlZCgKKwlzdHJ1Y3QgbGlzdF9vYmplY3RzX2ZpbHRlcl9vcHRpb25zICpmaWx0ZXJfb3B0aW9ucyk7CisKKy8qCisgKiBQYXJzZXMgdGhlIGZpbHRlciBzcGVjIHN0cmluZyBnaXZlbiBieSBhcmcgYW5kIGVpdGhlciAoMSkgc2ltcGx5IHBsYWNlcyB0aGUKKyAqIHJlc3VsdCBpbiBmaWx0ZXJfb3B0aW9ucyBpZiBpdCBpcyBub3QgeWV0IHBvcHVsYXRlZCBvciAoMikgY29tYmluZXMgaXQgd2l0aAorICogdGhlIGZpbHRlciBhbHJlYWR5IGluIGZpbHRlcl9vcHRpb25zIGlmIGl0IGlzIGFscmVhZHkgcG9wdWxhdGVkLiBJbiB0aGUgY2FzZQorICogb2YgKDIpLCB0aGUgZmlsdGVyIHNwZWNzIGFyZSBjb21iaW5lZCBhcyBpZiBzcGVjaWZpZWQgd2l0aCAnY29tYmluZTonLgorICoKKyAqIERpZXMgYW5kIHByaW50cyBhIHVzZXItZmFjaW5nIG1lc3NhZ2UgaWYgYW4gZXJyb3Igb2NjdXJzLgorICovCit2b2lkIHBhcnNlX2xpc3Rfb2JqZWN0c19maWx0ZXIoCiAJc3RydWN0IGxpc3Rfb2JqZWN0c19maWx0ZXJfb3B0aW9ucyAqZmlsdGVyX29wdGlvbnMsCiAJY29uc3QgY2hhciAqYXJnKTsKIApAQCAtNjUsMTMgKzg5LDIyIEBACiAvKgogICogVHJhbnNsYXRlcyBhYmJyZXZpYXRlZCBudW1iZXJzIGluIHRoZSBmaWx0ZXIncyBmaWx0ZXJfc3BlYyBpbnRvIHRoZWlyCiAgKiBmdWxseS1leHBhbmRlZCBmb3JtcyAoZS5nLiwgImxpbWl0OmJsb2I9MWsiIGJlY29tZXMgImxpbWl0OmJsb2I9MTAyNCIpLgorICogUmV0dXJucyBhIHN0cmluZyBvd25lZCBieSB0aGUgbGlzdF9vYmplY3RzX2ZpbHRlcl9vcHRpb25zIG9iamVjdC4KICAqCi0gKiBUaGlzIGZvcm0gc2hvdWxkIGJlIHVzZWQgaW5zdGVhZCBvZiB0aGUgcmF3IGZpbHRlcl9zcGVjIGZpZWxkIHdoZW4KLSAqIGNvbW11bmljYXRpbmcgd2l0aCBhIHJlbW90ZSBwcm9jZXNzIG9yIHN1YnByb2Nlc3MuCisgKiBUaGlzIGZvcm0gc2hvdWxkIGJlIHVzZWQgaW5zdGVhZCBvZiB0aGUgcmF3IGxpc3Rfb2JqZWN0c19maWx0ZXJfc3BlYygpCisgKiB2YWx1ZSB3aGVuIGNvbW11bmljYXRpbmcgd2l0aCBhIHJlbW90ZSBwcm9jZXNzIG9yIHN1YnByb2Nlc3MuCiAgKi8KLXZvaWQgZXhwYW5kX2xpc3Rfb2JqZWN0c19maWx0ZXJfc3BlYygKLQljb25zdCBzdHJ1Y3QgbGlzdF9vYmplY3RzX2ZpbHRlcl9vcHRpb25zICpmaWx0ZXIsCi0Jc3RydWN0IHN0cmJ1ZiAqZXhwYW5kZWRfc3BlYyk7Citjb25zdCBjaGFyICpleHBhbmRfbGlzdF9vYmplY3RzX2ZpbHRlcl9zcGVjKAorCXN0cnVjdCBsaXN0X29iamVjdHNfZmlsdGVyX29wdGlvbnMgKmZpbHRlcik7CisKKy8qCisgKiBSZXR1cm5zIHRoZSBmaWx0ZXIgc3BlYyBzdHJpbmcgbW9yZSBvciBsZXNzIGluIHRoZSBmb3JtIGFzIHRoZSB1c2VyCisgKiBlbnRlcmVkIGl0LiBUaGlzIGZvcm0gb2YgdGhlIGZpbHRlcl9zcGVjIGNhbiBiZSB1c2VkIGluIHVzZXItZmFjaW5nCisgKiBtZXNzYWdlcy4gIFJldHVybnMgYSBzdHJpbmcgb3duZWQgYnkgdGhlIGxpc3Rfb2JqZWN0c19maWx0ZXJfb3B0aW9ucworICogb2JqZWN0LgorICovCitjb25zdCBjaGFyICpsaXN0X29iamVjdHNfZmlsdGVyX3NwZWMoCisJc3RydWN0IGxpc3Rfb2JqZWN0c19maWx0ZXJfb3B0aW9ucyAqZmlsdGVyKTsKIAogdm9pZCBsaXN0X29iamVjdHNfZmlsdGVyX3JlbGVhc2UoCiAJc3RydWN0IGxpc3Rfb2JqZWN0c19maWx0ZXJfb3B0aW9ucyAqZmlsdGVyX29wdGlvbnMpOwpAQCAtODUsOCArMTE4LDkgQEAKIAogdm9pZCBwYXJ0aWFsX2Nsb25lX3JlZ2lzdGVyKAogCWNvbnN0IGNoYXIgKnJlbW90ZSwKLQljb25zdCBzdHJ1Y3QgbGlzdF9vYmplY3RzX2ZpbHRlcl9vcHRpb25zICpmaWx0ZXJfb3B0aW9ucyk7Ci12b2lkIHBhcnRpYWxfY2xvbmVfZ2V0X2RlZmF1bHRfZmlsdGVyX3NwZWMoCiAJc3RydWN0IGxpc3Rfb2JqZWN0c19maWx0ZXJfb3B0aW9ucyAqZmlsdGVyX29wdGlvbnMpOwordm9pZCBwYXJ0aWFsX2Nsb25lX2dldF9kZWZhdWx0X2ZpbHRlcl9zcGVjKAorCXN0cnVjdCBsaXN0X29iamVjdHNfZmlsdGVyX29wdGlvbnMgKmZpbHRlcl9vcHRpb25zLAorCWNvbnN0IGNoYXIgKnJlbW90ZSk7CiAKICNlbmRpZiAvKiBMSVNUX09CSkVDVFNfRklMVEVSX09QVElPTlNfSCAqLwpkaWZmIC0tZ2l0IGEvbGlzdC1vYmplY3RzLWZpbHRlci5jIGIvbGlzdC1vYmplY3RzLWZpbHRlci5jCmluZGV4IDM2ZTFmNzcuLjFlOGQ0ZTcgMTAwNjQ0Ci0tLSBhL2xpc3Qtb2JqZWN0cy1maWx0ZXIuYworKysgYi9saXN0LW9iamVjdHMtZmlsdGVyLmMKQEAgLTI2LDExICsyNiw0NiBAQAogICovCiAjZGVmaW5lIEZJTFRFUl9TSE9XTl9CVVRfUkVWSVNJVCAoMTw8MjEpCiAKLS8qCi0gKiBBIGZpbHRlciBmb3IgbGlzdC1vYmplY3RzIHRvIG9taXQgQUxMIGJsb2JzIGZyb20gdGhlIHRyYXZlcnNhbC4KLSAqIEFuZCB0byBPUFRJT05BTExZIGNvbGxlY3QgYSBsaXN0IG9mIHRoZSBvbWl0dGVkIE9JRHMuCi0gKi8KLXN0cnVjdCBmaWx0ZXJfYmxvYnNfbm9uZV9kYXRhIHsKK3N0cnVjdCBzdWJmaWx0ZXIgeworCXN0cnVjdCBmaWx0ZXIgKmZpbHRlcjsKKwlzdHJ1Y3Qgb2lkc2V0IHNlZW47CisJc3RydWN0IG9pZHNldCBvbWl0czsKKwlzdHJ1Y3Qgb2JqZWN0X2lkIHNraXBfdHJlZTsKKwl1bnNpZ25lZCBpc19za2lwcGluZ190cmVlIDogMTsKK307CisKK3N0cnVjdCBmaWx0ZXIgeworCWVudW0gbGlzdF9vYmplY3RzX2ZpbHRlcl9yZXN1bHQgKCpmaWx0ZXJfb2JqZWN0X2ZuKSgKKwkJc3RydWN0IHJlcG9zaXRvcnkgKnIsCisJCWVudW0gbGlzdF9vYmplY3RzX2ZpbHRlcl9zaXR1YXRpb24gZmlsdGVyX3NpdHVhdGlvbiwKKwkJc3RydWN0IG9iamVjdCAqb2JqLAorCQljb25zdCBjaGFyICpwYXRobmFtZSwKKwkJY29uc3QgY2hhciAqZmlsZW5hbWUsCisJCXN0cnVjdCBvaWRzZXQgKm9taXRzLAorCQl2b2lkICpmaWx0ZXJfZGF0YSk7CisKKwkvKgorCSAqIE9wdGlvbmFsLiBJZiB0aGlzIGZ1bmN0aW9uIGlzIHN1cHBsaWVkIGFuZCB0aGUgZmlsdGVyIG5lZWRzCisJICogdG8gY29sbGVjdCBvbWl0cywgdGhlbiB0aGlzIGZ1bmN0aW9uIGlzIGNhbGxlZCBvbmNlIGJlZm9yZQorCSAqIGZyZWVfZm4gaXMgY2FsbGVkLgorCSAqCisJICogVGhpcyBpcyByZXF1aXJlZCBiZWNhdXNlIHRoZSBmb2xsb3dpbmcgdHdvIGNvbmRpdGlvbnMgaG9sZDoKKwkgKgorCSAqICAgYS4gQSB0cmVlIGZpbHRlciBjYW4gYWRkIGFuZCByZW1vdmUgb2JqZWN0cyBhcyBhbiBvYmplY3QKKwkgKiAgICAgIGdyYXBoIGlzIHRyYXZlcnNlZC4KKwkgKiAgIGIuIEEgY29tYmluZSBmaWx0ZXIncyBvbWl0IHNldCBpcyB0aGUgdW5pb24gb2YgYWxsIGl0cworCSAqICAgICAgc3ViZmlsdGVycywgd2hpY2ggbWF5IGluY2x1ZGUgdHJlZTogZmlsdGVycy4KKwkgKgorCSAqIEFzIHN1Y2gsIHRoZSBvbWl0cyBzZXRzIG11c3QgYmUgc2VwYXJhdGUgc2V0cywgYW5kIGNhbiBvbmx5CisJICogYmUgdW5pb25lZCBhZnRlciB0aGUgdHJhdmVyc2FsIGlzIGNvbXBsZXRlZC4KKwkgKi8KKwl2b2lkICgqZmluYWxpemVfb21pdHNfZm4pKHN0cnVjdCBvaWRzZXQgKm9taXRzLCB2b2lkICpmaWx0ZXJfZGF0YSk7CisKKwl2b2lkICgqZnJlZV9mbikodm9pZCAqZmlsdGVyX2RhdGEpOworCisJdm9pZCAqZmlsdGVyX2RhdGE7CisKKwkvKiBJZiBub24tTlVMTCwgdGhlIGZpbHRlciBjb2xsZWN0cyBhIGxpc3Qgb2YgdGhlIG9taXR0ZWQgT0lEcyBoZXJlLiAqLwogCXN0cnVjdCBvaWRzZXQgKm9taXRzOwogfTsKIApAQCAtNDAsMTAgKzc1LDkgQEAKIAlzdHJ1Y3Qgb2JqZWN0ICpvYmosCiAJY29uc3QgY2hhciAqcGF0aG5hbWUsCiAJY29uc3QgY2hhciAqZmlsZW5hbWUsCisJc3RydWN0IG9pZHNldCAqb21pdHMsCiAJdm9pZCAqZmlsdGVyX2RhdGFfKQogewotCXN0cnVjdCBmaWx0ZXJfYmxvYnNfbm9uZV9kYXRhICpmaWx0ZXJfZGF0YSA9IGZpbHRlcl9kYXRhXzsKLQogCXN3aXRjaCAoZmlsdGVyX3NpdHVhdGlvbikgewogCWRlZmF1bHQ6CiAJCUJVRygidW5rbm93biBmaWx0ZXJfc2l0dWF0aW9uOiAlZCIsIGZpbHRlcl9zaXR1YXRpb24pOwpAQCAtNjEsMjQgKzk1LDE4IEBACiAJCWFzc2VydChvYmotPnR5cGUgPT0gT0JKX0JMT0IpOwogCQlhc3NlcnQoKG9iai0+ZmxhZ3MgJiBTRUVOKSA9PSAwKTsKIAotCQlpZiAoZmlsdGVyX2RhdGEtPm9taXRzKQotCQkJb2lkc2V0X2luc2VydChmaWx0ZXJfZGF0YS0+b21pdHMsICZvYmotPm9pZCk7CisJCWlmIChvbWl0cykKKwkJCW9pZHNldF9pbnNlcnQob21pdHMsICZvYmotPm9pZCk7CiAJCXJldHVybiBMT0ZSX01BUktfU0VFTjsgLyogYnV0IG5vdCBMT0ZSX0RPX1NIT1cgKGhhcmQgb21pdCkgKi8KIAl9CiB9CiAKLXN0YXRpYyB2b2lkICpmaWx0ZXJfYmxvYnNfbm9uZV9faW5pdCgKLQlzdHJ1Y3Qgb2lkc2V0ICpvbWl0dGVkLAorc3RhdGljIHZvaWQgZmlsdGVyX2Jsb2JzX25vbmVfX2luaXQoCiAJc3RydWN0IGxpc3Rfb2JqZWN0c19maWx0ZXJfb3B0aW9ucyAqZmlsdGVyX29wdGlvbnMsCi0JZmlsdGVyX29iamVjdF9mbiAqZmlsdGVyX2ZuLAotCWZpbHRlcl9mcmVlX2ZuICpmaWx0ZXJfZnJlZV9mbikKKwlzdHJ1Y3QgZmlsdGVyICpmaWx0ZXIpCiB7Ci0Jc3RydWN0IGZpbHRlcl9ibG9ic19ub25lX2RhdGEgKmQgPSB4Y2FsbG9jKDEsIHNpemVvZigqZCkpOwotCWQtPm9taXRzID0gb21pdHRlZDsKLQotCSpmaWx0ZXJfZm4gPSBmaWx0ZXJfYmxvYnNfbm9uZTsKLQkqZmlsdGVyX2ZyZWVfZm4gPSBmcmVlOwotCXJldHVybiBkOworCWZpbHRlci0+ZmlsdGVyX29iamVjdF9mbiA9IGZpbHRlcl9ibG9ic19ub25lOworCWZpbHRlci0+ZnJlZV9mbiA9IGZyZWU7CiB9CiAKIC8qCkBAIC04Niw4ICsxMTQsNiBAQAogICogQ2FuIE9QVElPTkFMTFkgY29sbGVjdCBhIGxpc3Qgb2YgdGhlIG9taXR0ZWQgT0lEcy4KICAqLwogc3RydWN0IGZpbHRlcl90cmVlc19kZXB0aF9kYXRhIHsKLQlzdHJ1Y3Qgb2lkc2V0ICpvbWl0czsKLQogCS8qCiAJICogTWFwcyB0cmVlcyB0byB0aGUgbWluaW11bSBkZXB0aCBhdCB3aGljaCB0aGV5IHdlcmUgc2Vlbi4gSXQgaXMgbm90CiAJICogbmVjZXNzYXJ5IHRvIHJlLXRyYXZlcnNlIGEgdHJlZSBhdCBkZWVwZXIgb3IgZXF1YWwgZGVwdGhzIHRoYW4gaXQgaGFzCkBAIC0xMTAsMTYgKzEzNiwxNiBAQAogLyogUmV0dXJucyAxIGlmIHRoZSBvaWQgd2FzIGluIHRoZSBvbWl0cyBzZXQgYmVmb3JlIGl0IHdhcyBpbnZva2VkLiAqLwogc3RhdGljIGludCBmaWx0ZXJfdHJlZXNfdXBkYXRlX29taXRzKAogCXN0cnVjdCBvYmplY3QgKm9iaiwKLQlzdHJ1Y3QgZmlsdGVyX3RyZWVzX2RlcHRoX2RhdGEgKmZpbHRlcl9kYXRhLAorCXN0cnVjdCBvaWRzZXQgKm9taXRzLAogCWludCBpbmNsdWRlX2l0KQogewotCWlmICghZmlsdGVyX2RhdGEtPm9taXRzKQorCWlmICghb21pdHMpCiAJCXJldHVybiAwOwogCiAJaWYgKGluY2x1ZGVfaXQpCi0JCXJldHVybiBvaWRzZXRfcmVtb3ZlKGZpbHRlcl9kYXRhLT5vbWl0cywgJm9iai0+b2lkKTsKKwkJcmV0dXJuIG9pZHNldF9yZW1vdmUob21pdHMsICZvYmotPm9pZCk7CiAJZWxzZQotCQlyZXR1cm4gb2lkc2V0X2luc2VydChmaWx0ZXJfZGF0YS0+b21pdHMsICZvYmotPm9pZCk7CisJCXJldHVybiBvaWRzZXRfaW5zZXJ0KG9taXRzLCAmb2JqLT5vaWQpOwogfQogCiBzdGF0aWMgZW51bSBsaXN0X29iamVjdHNfZmlsdGVyX3Jlc3VsdCBmaWx0ZXJfdHJlZXNfZGVwdGgoCkBAIC0xMjgsNiArMTU0LDcgQEAKIAlzdHJ1Y3Qgb2JqZWN0ICpvYmosCiAJY29uc3QgY2hhciAqcGF0aG5hbWUsCiAJY29uc3QgY2hhciAqZmlsZW5hbWUsCisJc3RydWN0IG9pZHNldCAqb21pdHMsCiAJdm9pZCAqZmlsdGVyX2RhdGFfKQogewogCXN0cnVjdCBmaWx0ZXJfdHJlZXNfZGVwdGhfZGF0YSAqZmlsdGVyX2RhdGEgPSBmaWx0ZXJfZGF0YV87CkBAIC0xNTIsNyArMTc5LDcgQEAKIAkJcmV0dXJuIExPRlJfWkVSTzsKIAogCWNhc2UgTE9GU19CTE9COgotCQlmaWx0ZXJfdHJlZXNfdXBkYXRlX29taXRzKG9iaiwgZmlsdGVyX2RhdGEsIGluY2x1ZGVfaXQpOworCQlmaWx0ZXJfdHJlZXNfdXBkYXRlX29taXRzKG9iaiwgb21pdHMsIGluY2x1ZGVfaXQpOwogCQlyZXR1cm4gaW5jbHVkZV9pdCA/IExPRlJfTUFSS19TRUVOIHwgTE9GUl9ET19TSE9XIDogTE9GUl9aRVJPOwogCiAJY2FzZSBMT0ZTX0JFR0lOX1RSRUU6CkBAIC0xNzMsMTIgKzIwMCwxMiBAQAogCQkJZmlsdGVyX3JlcyA9IExPRlJfU0tJUF9UUkVFOwogCQl9IGVsc2UgewogCQkJaW50IGJlZW5fb21pdHRlZCA9IGZpbHRlcl90cmVlc191cGRhdGVfb21pdHMoCi0JCQkJb2JqLCBmaWx0ZXJfZGF0YSwgaW5jbHVkZV9pdCk7CisJCQkJb2JqLCBvbWl0cywgaW5jbHVkZV9pdCk7CiAJCQlzZWVuX2luZm8tPmRlcHRoID0gZmlsdGVyX2RhdGEtPmN1cnJlbnRfZGVwdGg7CiAKIAkJCWlmIChpbmNsdWRlX2l0KQogCQkJCWZpbHRlcl9yZXMgPSBMT0ZSX0RPX1NIT1c7Ci0JCQllbHNlIGlmIChmaWx0ZXJfZGF0YS0+b21pdHMgJiYgIWJlZW5fb21pdHRlZCkKKwkJCWVsc2UgaWYgKG9taXRzICYmICFiZWVuX29taXR0ZWQpCiAJCQkJLyoKIAkJCQkgKiBNdXN0IHVwZGF0ZSBvbWl0IGluZm9ybWF0aW9uIG9mIGNoaWxkcmVuCiAJCQkJICogcmVjdXJzaXZlbHk7IHRoZXkgaGF2ZSBub3QgYmVlbiBvbWl0dGVkIHlldC4KQEAgLTIwMSwyMSArMjI4LDE4IEBACiAJZnJlZShkKTsKIH0KIAotc3RhdGljIHZvaWQgKmZpbHRlcl90cmVlc19kZXB0aF9faW5pdCgKLQlzdHJ1Y3Qgb2lkc2V0ICpvbWl0dGVkLAorc3RhdGljIHZvaWQgZmlsdGVyX3RyZWVzX2RlcHRoX19pbml0KAogCXN0cnVjdCBsaXN0X29iamVjdHNfZmlsdGVyX29wdGlvbnMgKmZpbHRlcl9vcHRpb25zLAotCWZpbHRlcl9vYmplY3RfZm4gKmZpbHRlcl9mbiwKLQlmaWx0ZXJfZnJlZV9mbiAqZmlsdGVyX2ZyZWVfZm4pCisJc3RydWN0IGZpbHRlciAqZmlsdGVyKQogewogCXN0cnVjdCBmaWx0ZXJfdHJlZXNfZGVwdGhfZGF0YSAqZCA9IHhjYWxsb2MoMSwgc2l6ZW9mKCpkKSk7Ci0JZC0+b21pdHMgPSBvbWl0dGVkOwogCW9pZG1hcF9pbml0KCZkLT5zZWVuX2F0X2RlcHRoLCAwKTsKIAlkLT5leGNsdWRlX2RlcHRoID0gZmlsdGVyX29wdGlvbnMtPnRyZWVfZXhjbHVkZV9kZXB0aDsKIAlkLT5jdXJyZW50X2RlcHRoID0gMDsKIAotCSpmaWx0ZXJfZm4gPSBmaWx0ZXJfdHJlZXNfZGVwdGg7Ci0JKmZpbHRlcl9mcmVlX2ZuID0gZmlsdGVyX3RyZWVzX2ZyZWU7Ci0JcmV0dXJuIGQ7CisJZmlsdGVyLT5maWx0ZXJfZGF0YSA9IGQ7CisJZmlsdGVyLT5maWx0ZXJfb2JqZWN0X2ZuID0gZmlsdGVyX3RyZWVzX2RlcHRoOworCWZpbHRlci0+ZnJlZV9mbiA9IGZpbHRlcl90cmVlc19mcmVlOwogfQogCiAvKgpAQCAtMjIzLDcgKzI0Nyw2IEBACiAgKiBBbmQgdG8gT1BUSU9OQUxMWSBjb2xsZWN0IGEgbGlzdCBvZiB0aGUgb21pdHRlZCBPSURzLgogICovCiBzdHJ1Y3QgZmlsdGVyX2Jsb2JzX2xpbWl0X2RhdGEgewotCXN0cnVjdCBvaWRzZXQgKm9taXRzOwogCXVuc2lnbmVkIGxvbmcgbWF4X2J5dGVzOwogfTsKIApAQCAtMjMzLDYgKzI1Niw3IEBACiAJc3RydWN0IG9iamVjdCAqb2JqLAogCWNvbnN0IGNoYXIgKnBhdGhuYW1lLAogCWNvbnN0IGNoYXIgKmZpbGVuYW1lLAorCXN0cnVjdCBvaWRzZXQgKm9taXRzLAogCXZvaWQgKmZpbHRlcl9kYXRhXykKIHsKIAlzdHJ1Y3QgZmlsdGVyX2Jsb2JzX2xpbWl0X2RhdGEgKmZpbHRlcl9kYXRhID0gZmlsdGVyX2RhdGFfOwpAQCAtMjcwLDMwICsyOTQsMjcgQEAKIAkJaWYgKG9iamVjdF9sZW5ndGggPCBmaWx0ZXJfZGF0YS0+bWF4X2J5dGVzKQogCQkJZ290byBpbmNsdWRlX2l0OwogCi0JCWlmIChmaWx0ZXJfZGF0YS0+b21pdHMpCi0JCQlvaWRzZXRfaW5zZXJ0KGZpbHRlcl9kYXRhLT5vbWl0cywgJm9iai0+b2lkKTsKKwkJaWYgKG9taXRzKQorCQkJb2lkc2V0X2luc2VydChvbWl0cywgJm9iai0+b2lkKTsKIAkJcmV0dXJuIExPRlJfTUFSS19TRUVOOyAvKiBidXQgbm90IExPRlJfRE9fU0hPVyAoaGFyZCBvbWl0KSAqLwogCX0KIAogaW5jbHVkZV9pdDoKLQlpZiAoZmlsdGVyX2RhdGEtPm9taXRzKQotCQlvaWRzZXRfcmVtb3ZlKGZpbHRlcl9kYXRhLT5vbWl0cywgJm9iai0+b2lkKTsKKwlpZiAob21pdHMpCisJCW9pZHNldF9yZW1vdmUob21pdHMsICZvYmotPm9pZCk7CiAJcmV0dXJuIExPRlJfTUFSS19TRUVOIHwgTE9GUl9ET19TSE9XOwogfQogCi1zdGF0aWMgdm9pZCAqZmlsdGVyX2Jsb2JzX2xpbWl0X19pbml0KAotCXN0cnVjdCBvaWRzZXQgKm9taXR0ZWQsCitzdGF0aWMgdm9pZCBmaWx0ZXJfYmxvYnNfbGltaXRfX2luaXQoCiAJc3RydWN0IGxpc3Rfb2JqZWN0c19maWx0ZXJfb3B0aW9ucyAqZmlsdGVyX29wdGlvbnMsCi0JZmlsdGVyX29iamVjdF9mbiAqZmlsdGVyX2ZuLAotCWZpbHRlcl9mcmVlX2ZuICpmaWx0ZXJfZnJlZV9mbikKKwlzdHJ1Y3QgZmlsdGVyICpmaWx0ZXIpCiB7CiAJc3RydWN0IGZpbHRlcl9ibG9ic19saW1pdF9kYXRhICpkID0geGNhbGxvYygxLCBzaXplb2YoKmQpKTsKLQlkLT5vbWl0cyA9IG9taXR0ZWQ7CiAJZC0+bWF4X2J5dGVzID0gZmlsdGVyX29wdGlvbnMtPmJsb2JfbGltaXRfdmFsdWU7CiAKLQkqZmlsdGVyX2ZuID0gZmlsdGVyX2Jsb2JzX2xpbWl0OwotCSpmaWx0ZXJfZnJlZV9mbiA9IGZyZWU7Ci0JcmV0dXJuIGQ7CisJZmlsdGVyLT5maWx0ZXJfZGF0YSA9IGQ7CisJZmlsdGVyLT5maWx0ZXJfb2JqZWN0X2ZuID0gZmlsdGVyX2Jsb2JzX2xpbWl0OworCWZpbHRlci0+ZnJlZV9mbiA9IGZyZWU7CiB9CiAKIC8qCkBAIC0zMDcsMTIgKzMyOCwxMiBAQAogICovCiBzdHJ1Y3QgZnJhbWUgewogCS8qCi0JICogZGVmdmFsIGlzIHRoZSB1c3VhbCBkZWZhdWx0IGluY2x1ZGUvZXhjbHVkZSB2YWx1ZSB0aGF0CisJICogZGVmYXVsdF9tYXRjaCBpcyB0aGUgdXN1YWwgZGVmYXVsdCBpbmNsdWRlL2V4Y2x1ZGUgdmFsdWUgdGhhdAogCSAqIHNob3VsZCBiZSBpbmhlcml0ZWQgYXMgd2UgcmVjdXJzZSBpbnRvIGRpcmVjdG9yaWVzIGJhc2VkCiAJICogdXBvbiBwYXR0ZXJuIG1hdGNoaW5nIG9mIHRoZSBkaXJlY3RvcnkgaXRzZWxmIG9yIG9mIGEKIAkgKiBjb250YWluaW5nIGRpcmVjdG9yeS4KIAkgKi8KLQlpbnQgZGVmdmFsOworCWVudW0gcGF0dGVybl9tYXRjaF9yZXN1bHQgZGVmYXVsdF9tYXRjaDsKIAogCS8qCiAJICogMSBpZiB0aGUgZGlyZWN0b3J5IChyZWN1cnNpdmVseSkgY29udGFpbnMgYW55IHByb3Zpc2lvbmFsbHkKQEAgLTMyNiw4ICszNDcsNyBAQAogfTsKIAogc3RydWN0IGZpbHRlcl9zcGFyc2VfZGF0YSB7Ci0Jc3RydWN0IG9pZHNldCAqb21pdHM7Ci0Jc3RydWN0IGV4Y2x1ZGVfbGlzdCBlbDsKKwlzdHJ1Y3QgcGF0dGVybl9saXN0IHBsOwogCiAJc2l6ZV90IG5yLCBhbGxvYzsKIAlzdHJ1Y3QgZnJhbWUgKmFycmF5X2ZyYW1lOwpAQCAtMzM5LDExICszNTksMTMgQEAKIAlzdHJ1Y3Qgb2JqZWN0ICpvYmosCiAJY29uc3QgY2hhciAqcGF0aG5hbWUsCiAJY29uc3QgY2hhciAqZmlsZW5hbWUsCisJc3RydWN0IG9pZHNldCAqb21pdHMsCiAJdm9pZCAqZmlsdGVyX2RhdGFfKQogewogCXN0cnVjdCBmaWx0ZXJfc3BhcnNlX2RhdGEgKmZpbHRlcl9kYXRhID0gZmlsdGVyX2RhdGFfOwotCWludCB2YWwsIGR0eXBlOworCWludCBkdHlwZTsKIAlzdHJ1Y3QgZnJhbWUgKmZyYW1lOworCWVudW0gcGF0dGVybl9tYXRjaF9yZXN1bHQgbWF0Y2g7CiAKIAlzd2l0Y2ggKGZpbHRlcl9zaXR1YXRpb24pIHsKIAlkZWZhdWx0OgpAQCAtMzUyLDE1ICszNzQsMTUgQEAKIAljYXNlIExPRlNfQkVHSU5fVFJFRToKIAkJYXNzZXJ0KG9iai0+dHlwZSA9PSBPQkpfVFJFRSk7CiAJCWR0eXBlID0gRFRfRElSOwotCQl2YWwgPSBpc19leGNsdWRlZF9mcm9tX2xpc3QocGF0aG5hbWUsIHN0cmxlbihwYXRobmFtZSksCi0JCQkJCSAgICBmaWxlbmFtZSwgJmR0eXBlLCAmZmlsdGVyX2RhdGEtPmVsLAotCQkJCQkgICAgci0+aW5kZXgpOwotCQlpZiAodmFsIDwgMCkKLQkJCXZhbCA9IGZpbHRlcl9kYXRhLT5hcnJheV9mcmFtZVtmaWx0ZXJfZGF0YS0+bnIgLSAxXS5kZWZ2YWw7CisJCW1hdGNoID0gcGF0aF9tYXRjaGVzX3BhdHRlcm5fbGlzdChwYXRobmFtZSwgc3RybGVuKHBhdGhuYW1lKSwKKwkJCQkJCSAgZmlsZW5hbWUsICZkdHlwZSwgJmZpbHRlcl9kYXRhLT5wbCwKKwkJCQkJCSAgci0+aW5kZXgpOworCQlpZiAobWF0Y2ggPT0gVU5ERUNJREVEKQorCQkJbWF0Y2ggPSBmaWx0ZXJfZGF0YS0+YXJyYXlfZnJhbWVbZmlsdGVyX2RhdGEtPm5yIC0gMV0uZGVmYXVsdF9tYXRjaDsKIAogCQlBTExPQ19HUk9XKGZpbHRlcl9kYXRhLT5hcnJheV9mcmFtZSwgZmlsdGVyX2RhdGEtPm5yICsgMSwKIAkJCSAgIGZpbHRlcl9kYXRhLT5hbGxvYyk7Ci0JCWZpbHRlcl9kYXRhLT5hcnJheV9mcmFtZVtmaWx0ZXJfZGF0YS0+bnJdLmRlZnZhbCA9IHZhbDsKKwkJZmlsdGVyX2RhdGEtPmFycmF5X2ZyYW1lW2ZpbHRlcl9kYXRhLT5ucl0uZGVmYXVsdF9tYXRjaCA9IG1hdGNoOwogCQlmaWx0ZXJfZGF0YS0+YXJyYXlfZnJhbWVbZmlsdGVyX2RhdGEtPm5yXS5jaGlsZF9wcm92X29taXQgPSAwOwogCQlmaWx0ZXJfZGF0YS0+bnIrKzsKIApAQCAtNDE0LDE0ICs0MzYsMTQgQEAKIAkJZnJhbWUgPSAmZmlsdGVyX2RhdGEtPmFycmF5X2ZyYW1lW2ZpbHRlcl9kYXRhLT5uciAtIDFdOwogCiAJCWR0eXBlID0gRFRfUkVHOwotCQl2YWwgPSBpc19leGNsdWRlZF9mcm9tX2xpc3QocGF0aG5hbWUsIHN0cmxlbihwYXRobmFtZSksCi0JCQkJCSAgICBmaWxlbmFtZSwgJmR0eXBlLCAmZmlsdGVyX2RhdGEtPmVsLAorCQltYXRjaCA9IHBhdGhfbWF0Y2hlc19wYXR0ZXJuX2xpc3QocGF0aG5hbWUsIHN0cmxlbihwYXRobmFtZSksCisJCQkJCSAgICBmaWxlbmFtZSwgJmR0eXBlLCAmZmlsdGVyX2RhdGEtPnBsLAogCQkJCQkgICAgci0+aW5kZXgpOwotCQlpZiAodmFsIDwgMCkKLQkJCXZhbCA9IGZyYW1lLT5kZWZ2YWw7Ci0JCWlmICh2YWwgPiAwKSB7Ci0JCQlpZiAoZmlsdGVyX2RhdGEtPm9taXRzKQotCQkJCW9pZHNldF9yZW1vdmUoZmlsdGVyX2RhdGEtPm9taXRzLCAmb2JqLT5vaWQpOworCQlpZiAobWF0Y2ggPT0gVU5ERUNJREVEKQorCQkJbWF0Y2ggPSBmcmFtZS0+ZGVmYXVsdF9tYXRjaDsKKwkJaWYgKG1hdGNoID09IE1BVENIRUQpIHsKKwkJCWlmIChvbWl0cykKKwkJCQlvaWRzZXRfcmVtb3ZlKG9taXRzLCAmb2JqLT5vaWQpOwogCQkJcmV0dXJuIExPRlJfTUFSS19TRUVOIHwgTE9GUl9ET19TSE9XOwogCQl9CiAKQEAgLTQzNSw4ICs0NTcsOCBAQAogCQkgKiBMZWF2ZSB0aGUgTE9GUl8gYml0cyB1bnNldCBzbyB0aGF0IGlmIHRoZSBibG9iIGFwcGVhcnMKIAkJICogYWdhaW4gaW4gdGhlIHRyYXZlcnNhbCwgd2Ugd2lsbCBiZSBhc2tlZCBhZ2Fpbi4KIAkJICovCi0JCWlmIChmaWx0ZXJfZGF0YS0+b21pdHMpCi0JCQlvaWRzZXRfaW5zZXJ0KGZpbHRlcl9kYXRhLT5vbWl0cywgJm9iai0+b2lkKTsKKwkJaWYgKG9taXRzKQorCQkJb2lkc2V0X2luc2VydChvbWl0cywgJm9iai0+b2lkKTsKIAogCQkvKgogCQkgKiBSZW1lbWJlciB0aGF0IGF0IGxlYXN0IDEgYmxvYiBpbiB0aGlzIHRyZWUgd2FzCkBAIC00NTYsMzMgKzQ3OCwxNjkgQEAKIAlmcmVlKGQpOwogfQogCi1zdGF0aWMgdm9pZCAqZmlsdGVyX3NwYXJzZV9vaWRfX2luaXQoCi0Jc3RydWN0IG9pZHNldCAqb21pdHRlZCwKK3N0YXRpYyB2b2lkIGZpbHRlcl9zcGFyc2Vfb2lkX19pbml0KAogCXN0cnVjdCBsaXN0X29iamVjdHNfZmlsdGVyX29wdGlvbnMgKmZpbHRlcl9vcHRpb25zLAotCWZpbHRlcl9vYmplY3RfZm4gKmZpbHRlcl9mbiwKLQlmaWx0ZXJfZnJlZV9mbiAqZmlsdGVyX2ZyZWVfZm4pCisJc3RydWN0IGZpbHRlciAqZmlsdGVyKQogewogCXN0cnVjdCBmaWx0ZXJfc3BhcnNlX2RhdGEgKmQgPSB4Y2FsbG9jKDEsIHNpemVvZigqZCkpOwotCWQtPm9taXRzID0gb21pdHRlZDsKLQlpZiAoYWRkX2V4Y2x1ZGVzX2Zyb21fYmxvYl90b19saXN0KGZpbHRlcl9vcHRpb25zLT5zcGFyc2Vfb2lkX3ZhbHVlLAotCQkJCQkgICBOVUxMLCAwLCAmZC0+ZWwpIDwgMCkKLQkJZGllKCJjb3VsZCBub3QgbG9hZCBmaWx0ZXIgc3BlY2lmaWNhdGlvbiIpOworCXN0cnVjdCBvYmplY3RfY29udGV4dCBvYzsKKwlzdHJ1Y3Qgb2JqZWN0X2lkIHNwYXJzZV9vaWQ7CisKKwlpZiAoZ2V0X29pZF93aXRoX2NvbnRleHQodGhlX3JlcG9zaXRvcnksCisJCQkJIGZpbHRlcl9vcHRpb25zLT5zcGFyc2Vfb2lkX25hbWUsCisJCQkJIEdFVF9PSURfQkxPQiwgJnNwYXJzZV9vaWQsICZvYykpCisJCWRpZShfKCJ1bmFibGUgdG8gYWNjZXNzIHNwYXJzZSBibG9iIGluICclcyciKSwKKwkJICAgIGZpbHRlcl9vcHRpb25zLT5zcGFyc2Vfb2lkX25hbWUpOworCWlmIChhZGRfcGF0dGVybnNfZnJvbV9ibG9iX3RvX2xpc3QoJnNwYXJzZV9vaWQsICIiLCAwLCAmZC0+cGwpIDwgMCkKKwkJZGllKF8oInVuYWJsZSB0byBwYXJzZSBzcGFyc2UgZmlsdGVyIGRhdGEgaW4gJXMiKSwKKwkJICAgIG9pZF90b19oZXgoJnNwYXJzZV9vaWQpKTsKIAogCUFMTE9DX0dST1coZC0+YXJyYXlfZnJhbWUsIGQtPm5yICsgMSwgZC0+YWxsb2MpOwotCWQtPmFycmF5X2ZyYW1lW2QtPm5yXS5kZWZ2YWwgPSAwOyAvKiBkZWZhdWx0IHRvIGluY2x1ZGUgKi8KKwlkLT5hcnJheV9mcmFtZVtkLT5ucl0uZGVmYXVsdF9tYXRjaCA9IDA7IC8qIGRlZmF1bHQgdG8gaW5jbHVkZSAqLwogCWQtPmFycmF5X2ZyYW1lW2QtPm5yXS5jaGlsZF9wcm92X29taXQgPSAwOwogCWQtPm5yKys7CiAKLQkqZmlsdGVyX2ZuID0gZmlsdGVyX3NwYXJzZTsKLQkqZmlsdGVyX2ZyZWVfZm4gPSBmaWx0ZXJfc3BhcnNlX2ZyZWU7Ci0JcmV0dXJuIGQ7CisJZmlsdGVyLT5maWx0ZXJfZGF0YSA9IGQ7CisJZmlsdGVyLT5maWx0ZXJfb2JqZWN0X2ZuID0gZmlsdGVyX3NwYXJzZTsKKwlmaWx0ZXItPmZyZWVfZm4gPSBmaWx0ZXJfc3BhcnNlX2ZyZWU7CiB9CiAKLXR5cGVkZWYgdm9pZCAqKCpmaWx0ZXJfaW5pdF9mbikoCi0Jc3RydWN0IG9pZHNldCAqb21pdHRlZCwKKy8qIEEgZmlsdGVyIHdoaWNoIG9ubHkgc2hvd3Mgb2JqZWN0cyBzaG93biBieSBhbGwgc3ViLWZpbHRlcnMuICovCitzdHJ1Y3QgY29tYmluZV9maWx0ZXJfZGF0YSB7CisJc3RydWN0IHN1YmZpbHRlciAqc3ViOworCXNpemVfdCBucjsKK307CisKK3N0YXRpYyBlbnVtIGxpc3Rfb2JqZWN0c19maWx0ZXJfcmVzdWx0IHByb2Nlc3Nfc3ViZmlsdGVyKAorCXN0cnVjdCByZXBvc2l0b3J5ICpyLAorCWVudW0gbGlzdF9vYmplY3RzX2ZpbHRlcl9zaXR1YXRpb24gZmlsdGVyX3NpdHVhdGlvbiwKKwlzdHJ1Y3Qgb2JqZWN0ICpvYmosCisJY29uc3QgY2hhciAqcGF0aG5hbWUsCisJY29uc3QgY2hhciAqZmlsZW5hbWUsCisJc3RydWN0IHN1YmZpbHRlciAqc3ViKQoreworCWVudW0gbGlzdF9vYmplY3RzX2ZpbHRlcl9yZXN1bHQgcmVzdWx0OworCisJLyoKKwkgKiBDaGVjayBhbmQgdXBkYXRlIGlzX3NraXBwaW5nX3RyZWUgYmVmb3JlIG9pZHNldF9jb250YWlucyBzbworCSAqIHRoYXQgaXNfc2tpcHBpbmdfdHJlZSBnZXRzIHVuc2V0IGV2ZW4gd2hlbiB0aGUgb2JqZWN0IGlzCisJICogbWFya2VkIGFzIHNlZW4uICBBcyBvZiB0aGlzIHdyaXRpbmcsIG5vIGZpbHRlciB1c2VzCisJICogTE9GUl9NQVJLX1NFRU4gb24gdHJlZXMgdGhhdCBhbHNvIHVzZXMgTE9GUl9TS0lQX1RSRUUsIHNvIHRoZQorCSAqIG9yZGVyaW5nIGlzIG9ubHkgdGhlb3JldGljYWxseSBpbXBvcnRhbnQuIEJlIGNhdXRpb3VzIGlmIHlvdQorCSAqIGNoYW5nZSB0aGUgb3JkZXIgb2YgdGhlIGJlbG93IGNoZWNrcyBhbmQgbW9yZSBmaWx0ZXJzIGhhdmUKKwkgKiBiZWVuIGFkZGVkIQorCSAqLworCWlmIChzdWItPmlzX3NraXBwaW5nX3RyZWUpIHsKKwkJaWYgKGZpbHRlcl9zaXR1YXRpb24gPT0gTE9GU19FTkRfVFJFRSAmJgorCQkgICAgb2lkZXEoJm9iai0+b2lkLCAmc3ViLT5za2lwX3RyZWUpKQorCQkJc3ViLT5pc19za2lwcGluZ190cmVlID0gMDsKKwkJZWxzZQorCQkJcmV0dXJuIExPRlJfWkVSTzsKKwl9CisJaWYgKG9pZHNldF9jb250YWlucygmc3ViLT5zZWVuLCAmb2JqLT5vaWQpKQorCQlyZXR1cm4gTE9GUl9aRVJPOworCisJcmVzdWx0ID0gbGlzdF9vYmplY3RzX2ZpbHRlcl9fZmlsdGVyX29iamVjdCgKKwkJciwgZmlsdGVyX3NpdHVhdGlvbiwgb2JqLCBwYXRobmFtZSwgZmlsZW5hbWUsIHN1Yi0+ZmlsdGVyKTsKKworCWlmIChyZXN1bHQgJiBMT0ZSX01BUktfU0VFTikKKwkJb2lkc2V0X2luc2VydCgmc3ViLT5zZWVuLCAmb2JqLT5vaWQpOworCisJaWYgKHJlc3VsdCAmIExPRlJfU0tJUF9UUkVFKSB7CisJCXN1Yi0+aXNfc2tpcHBpbmdfdHJlZSA9IDE7CisJCXN1Yi0+c2tpcF90cmVlID0gb2JqLT5vaWQ7CisJfQorCisJcmV0dXJuIHJlc3VsdDsKK30KKworc3RhdGljIGVudW0gbGlzdF9vYmplY3RzX2ZpbHRlcl9yZXN1bHQgZmlsdGVyX2NvbWJpbmUoCisJc3RydWN0IHJlcG9zaXRvcnkgKnIsCisJZW51bSBsaXN0X29iamVjdHNfZmlsdGVyX3NpdHVhdGlvbiBmaWx0ZXJfc2l0dWF0aW9uLAorCXN0cnVjdCBvYmplY3QgKm9iaiwKKwljb25zdCBjaGFyICpwYXRobmFtZSwKKwljb25zdCBjaGFyICpmaWxlbmFtZSwKKwlzdHJ1Y3Qgb2lkc2V0ICpvbWl0cywKKwl2b2lkICpmaWx0ZXJfZGF0YSkKK3sKKwlzdHJ1Y3QgY29tYmluZV9maWx0ZXJfZGF0YSAqZCA9IGZpbHRlcl9kYXRhOworCWVudW0gbGlzdF9vYmplY3RzX2ZpbHRlcl9yZXN1bHQgY29tYmluZWRfcmVzdWx0ID0KKwkJTE9GUl9ET19TSE9XIHwgTE9GUl9NQVJLX1NFRU4gfCBMT0ZSX1NLSVBfVFJFRTsKKwlzaXplX3Qgc3ViOworCisJZm9yIChzdWIgPSAwOyBzdWIgPCBkLT5ucjsgc3ViKyspIHsKKwkJZW51bSBsaXN0X29iamVjdHNfZmlsdGVyX3Jlc3VsdCBzdWJfcmVzdWx0ID0gcHJvY2Vzc19zdWJmaWx0ZXIoCisJCQlyLCBmaWx0ZXJfc2l0dWF0aW9uLCBvYmosIHBhdGhuYW1lLCBmaWxlbmFtZSwKKwkJCSZkLT5zdWJbc3ViXSk7CisJCWlmICghKHN1Yl9yZXN1bHQgJiBMT0ZSX0RPX1NIT1cpKQorCQkJY29tYmluZWRfcmVzdWx0ICY9IH5MT0ZSX0RPX1NIT1c7CisJCWlmICghKHN1Yl9yZXN1bHQgJiBMT0ZSX01BUktfU0VFTikpCisJCQljb21iaW5lZF9yZXN1bHQgJj0gfkxPRlJfTUFSS19TRUVOOworCQlpZiAoIWQtPnN1YltzdWJdLmlzX3NraXBwaW5nX3RyZWUpCisJCQljb21iaW5lZF9yZXN1bHQgJj0gfkxPRlJfU0tJUF9UUkVFOworCX0KKworCXJldHVybiBjb21iaW5lZF9yZXN1bHQ7Cit9CisKK3N0YXRpYyB2b2lkIGZpbHRlcl9jb21iaW5lX19mcmVlKHZvaWQgKmZpbHRlcl9kYXRhKQoreworCXN0cnVjdCBjb21iaW5lX2ZpbHRlcl9kYXRhICpkID0gZmlsdGVyX2RhdGE7CisJc2l6ZV90IHN1YjsKKwlmb3IgKHN1YiA9IDA7IHN1YiA8IGQtPm5yOyBzdWIrKykgeworCQlsaXN0X29iamVjdHNfZmlsdGVyX19mcmVlKGQtPnN1YltzdWJdLmZpbHRlcik7CisJCW9pZHNldF9jbGVhcigmZC0+c3ViW3N1Yl0uc2Vlbik7CisJCWlmIChkLT5zdWJbc3ViXS5vbWl0cy5zZXQuc2l6ZSkKKwkJCUJVRygiZXhwZWN0ZWQgb2lkc2V0IHRvIGJlIGNsZWFyZWQgYWxyZWFkeSIpOworCX0KKwlmcmVlKGQtPnN1Yik7Cit9CisKK3N0YXRpYyB2b2lkIGFkZF9hbGwoc3RydWN0IG9pZHNldCAqZGVzdCwgc3RydWN0IG9pZHNldCAqc3JjKSB7CisJc3RydWN0IG9pZHNldF9pdGVyIGl0ZXI7CisJc3RydWN0IG9iamVjdF9pZCAqc3JjX29pZDsKKworCW9pZHNldF9pdGVyX2luaXQoc3JjLCAmaXRlcik7CisJd2hpbGUgKChzcmNfb2lkID0gb2lkc2V0X2l0ZXJfbmV4dCgmaXRlcikpICE9IE5VTEwpCisJCW9pZHNldF9pbnNlcnQoZGVzdCwgc3JjX29pZCk7Cit9CisKK3N0YXRpYyB2b2lkIGZpbHRlcl9jb21iaW5lX19maW5hbGl6ZV9vbWl0cygKKwlzdHJ1Y3Qgb2lkc2V0ICpvbWl0cywKKwl2b2lkICpmaWx0ZXJfZGF0YSkKK3sKKwlzdHJ1Y3QgY29tYmluZV9maWx0ZXJfZGF0YSAqZCA9IGZpbHRlcl9kYXRhOworCXNpemVfdCBzdWI7CisKKwlmb3IgKHN1YiA9IDA7IHN1YiA8IGQtPm5yOyBzdWIrKykgeworCQlhZGRfYWxsKG9taXRzLCAmZC0+c3ViW3N1Yl0ub21pdHMpOworCQlvaWRzZXRfY2xlYXIoJmQtPnN1YltzdWJdLm9taXRzKTsKKwl9Cit9CisKK3N0YXRpYyB2b2lkIGZpbHRlcl9jb21iaW5lX19pbml0KAogCXN0cnVjdCBsaXN0X29iamVjdHNfZmlsdGVyX29wdGlvbnMgKmZpbHRlcl9vcHRpb25zLAotCWZpbHRlcl9vYmplY3RfZm4gKmZpbHRlcl9mbiwKLQlmaWx0ZXJfZnJlZV9mbiAqZmlsdGVyX2ZyZWVfZm4pOworCXN0cnVjdCBmaWx0ZXIqIGZpbHRlcikKK3sKKwlzdHJ1Y3QgY29tYmluZV9maWx0ZXJfZGF0YSAqZCA9IHhjYWxsb2MoMSwgc2l6ZW9mKCpkKSk7CisJc2l6ZV90IHN1YjsKKworCWQtPm5yID0gZmlsdGVyX29wdGlvbnMtPnN1Yl9ucjsKKwlkLT5zdWIgPSB4Y2FsbG9jKGQtPm5yLCBzaXplb2YoKmQtPnN1YikpOworCWZvciAoc3ViID0gMDsgc3ViIDwgZC0+bnI7IHN1YisrKQorCQlkLT5zdWJbc3ViXS5maWx0ZXIgPSBsaXN0X29iamVjdHNfZmlsdGVyX19pbml0KAorCQkJZmlsdGVyLT5vbWl0cyA/ICZkLT5zdWJbc3ViXS5vbWl0cyA6IE5VTEwsCisJCQkmZmlsdGVyX29wdGlvbnMtPnN1YltzdWJdKTsKKworCWZpbHRlci0+ZmlsdGVyX2RhdGEgPSBkOworCWZpbHRlci0+ZmlsdGVyX29iamVjdF9mbiA9IGZpbHRlcl9jb21iaW5lOworCWZpbHRlci0+ZnJlZV9mbiA9IGZpbHRlcl9jb21iaW5lX19mcmVlOworCWZpbHRlci0+ZmluYWxpemVfb21pdHNfZm4gPSBmaWx0ZXJfY29tYmluZV9fZmluYWxpemVfb21pdHM7Cit9CisKK3R5cGVkZWYgdm9pZCAoKmZpbHRlcl9pbml0X2ZuKSgKKwlzdHJ1Y3QgbGlzdF9vYmplY3RzX2ZpbHRlcl9vcHRpb25zICpmaWx0ZXJfb3B0aW9ucywKKwlzdHJ1Y3QgZmlsdGVyICpmaWx0ZXIpOwogCiAvKgogICogTXVzdCBtYXRjaCAiZW51bSBsaXN0X29iamVjdHNfZmlsdGVyX2Nob2ljZSIuCkBAIC00OTMsMTQgKzY1MSwxNCBAQAogCWZpbHRlcl9ibG9ic19saW1pdF9faW5pdCwKIAlmaWx0ZXJfdHJlZXNfZGVwdGhfX2luaXQsCiAJZmlsdGVyX3NwYXJzZV9vaWRfX2luaXQsCisJZmlsdGVyX2NvbWJpbmVfX2luaXQsCiB9OwogCi12b2lkICpsaXN0X29iamVjdHNfZmlsdGVyX19pbml0KAorc3RydWN0IGZpbHRlciAqbGlzdF9vYmplY3RzX2ZpbHRlcl9faW5pdCgKIAlzdHJ1Y3Qgb2lkc2V0ICpvbWl0dGVkLAotCXN0cnVjdCBsaXN0X29iamVjdHNfZmlsdGVyX29wdGlvbnMgKmZpbHRlcl9vcHRpb25zLAotCWZpbHRlcl9vYmplY3RfZm4gKmZpbHRlcl9mbiwKLQlmaWx0ZXJfZnJlZV9mbiAqZmlsdGVyX2ZyZWVfZm4pCisJc3RydWN0IGxpc3Rfb2JqZWN0c19maWx0ZXJfb3B0aW9ucyAqZmlsdGVyX29wdGlvbnMpCiB7CisJc3RydWN0IGZpbHRlciAqZmlsdGVyOwogCWZpbHRlcl9pbml0X2ZuIGluaXRfZm47CiAKIAlhc3NlcnQoKHNpemVvZihzX2ZpbHRlcnMpIC8gc2l6ZW9mKHNfZmlsdGVyc1swXSkpID09IExPRkNfX0NPVU5UKTsKQEAgLTUxMCwxMCArNjY4LDQ0IEBACiAJCSAgICBmaWx0ZXJfb3B0aW9ucy0+Y2hvaWNlKTsKIAogCWluaXRfZm4gPSBzX2ZpbHRlcnNbZmlsdGVyX29wdGlvbnMtPmNob2ljZV07Ci0JaWYgKGluaXRfZm4pCi0JCXJldHVybiBpbml0X2ZuKG9taXR0ZWQsIGZpbHRlcl9vcHRpb25zLAotCQkJICAgICAgIGZpbHRlcl9mbiwgZmlsdGVyX2ZyZWVfZm4pOwotCSpmaWx0ZXJfZm4gPSBOVUxMOwotCSpmaWx0ZXJfZnJlZV9mbiA9IE5VTEw7Ci0JcmV0dXJuIE5VTEw7CisJaWYgKCFpbml0X2ZuKQorCQlyZXR1cm4gTlVMTDsKKworCWZpbHRlciA9IHhjYWxsb2MoMSwgc2l6ZW9mKCpmaWx0ZXIpKTsKKwlmaWx0ZXItPm9taXRzID0gb21pdHRlZDsKKwlpbml0X2ZuKGZpbHRlcl9vcHRpb25zLCBmaWx0ZXIpOworCXJldHVybiBmaWx0ZXI7Cit9CisKK2VudW0gbGlzdF9vYmplY3RzX2ZpbHRlcl9yZXN1bHQgbGlzdF9vYmplY3RzX2ZpbHRlcl9fZmlsdGVyX29iamVjdCgKKwlzdHJ1Y3QgcmVwb3NpdG9yeSAqciwKKwllbnVtIGxpc3Rfb2JqZWN0c19maWx0ZXJfc2l0dWF0aW9uIGZpbHRlcl9zaXR1YXRpb24sCisJc3RydWN0IG9iamVjdCAqb2JqLAorCWNvbnN0IGNoYXIgKnBhdGhuYW1lLAorCWNvbnN0IGNoYXIgKmZpbGVuYW1lLAorCXN0cnVjdCBmaWx0ZXIgKmZpbHRlcikKK3sKKwlpZiAoZmlsdGVyICYmIChvYmotPmZsYWdzICYgTk9UX1VTRVJfR0lWRU4pKQorCQlyZXR1cm4gZmlsdGVyLT5maWx0ZXJfb2JqZWN0X2ZuKHIsIGZpbHRlcl9zaXR1YXRpb24sIG9iaiwKKwkJCQkJCXBhdGhuYW1lLCBmaWxlbmFtZSwKKwkJCQkJCWZpbHRlci0+b21pdHMsCisJCQkJCQlmaWx0ZXItPmZpbHRlcl9kYXRhKTsKKwkvKgorCSAqIE5vIGZpbHRlciBpcyBhY3RpdmUgb3IgdXNlciBnYXZlIG9iamVjdCBleHBsaWNpdGx5LiBJbiB0aGlzIGNhc2UsCisJICogYWx3YXlzIHNob3cgdGhlIG9iamVjdCAoZXhjZXB0IHdoZW4gTE9GU19FTkRfVFJFRSwgc2luY2UgdGhpcyB0cmVlCisJICogaGFkIGFscmVhZHkgYmVlbiBzaG93biB3aGVuIExPRlNfQkVHSU5fVFJFRSkuCisJICovCisJaWYgKGZpbHRlcl9zaXR1YXRpb24gPT0gTE9GU19FTkRfVFJFRSkKKwkJcmV0dXJuIDA7CisJcmV0dXJuIExPRlJfTUFSS19TRUVOIHwgTE9GUl9ET19TSE9XOworfQorCit2b2lkIGxpc3Rfb2JqZWN0c19maWx0ZXJfX2ZyZWUoc3RydWN0IGZpbHRlciAqZmlsdGVyKQoreworCWlmICghZmlsdGVyKQorCQlyZXR1cm47CisJaWYgKGZpbHRlci0+ZmluYWxpemVfb21pdHNfZm4gJiYgZmlsdGVyLT5vbWl0cykKKwkJZmlsdGVyLT5maW5hbGl6ZV9vbWl0c19mbihmaWx0ZXItPm9taXRzLCBmaWx0ZXItPmZpbHRlcl9kYXRhKTsKKwlmaWx0ZXItPmZyZWVfZm4oZmlsdGVyLT5maWx0ZXJfZGF0YSk7CisJZnJlZShmaWx0ZXIpOwogfQpkaWZmIC0tZ2l0IGEvbGlzdC1vYmplY3RzLWZpbHRlci5oIGIvbGlzdC1vYmplY3RzLWZpbHRlci5oCmluZGV4IDFkNDVhNGEuLmNmZDc4NGUgMTAwNjQ0Ci0tLSBhL2xpc3Qtb2JqZWN0cy1maWx0ZXIuaAorKysgYi9saXN0LW9iamVjdHMtZmlsdGVyLmgKQEAgLTYwLDMwICs2MCwzNiBAQAogCUxPRlNfQkxPQgogfTsKIAotdHlwZWRlZiBlbnVtIGxpc3Rfb2JqZWN0c19maWx0ZXJfcmVzdWx0ICgqZmlsdGVyX29iamVjdF9mbikoCitzdHJ1Y3QgZmlsdGVyOworCisvKgorICogQ29uc3RydWN0b3IgZm9yIHRoZSBzZXQgb2YgZGVmaW5lZCBsaXN0LW9iamVjdHMgZmlsdGVycy4KKyAqIFRoZSBgb21pdHRlZGAgc2V0IGlzIG9wdGlvbmFsLiBJdCBpcyBwb3B1bGF0ZWQgd2l0aCBvYmplY3RzIHRoYXQgdGhlCisgKiBmaWx0ZXIgZXhjbHVkZXMuIFRoaXMgc2V0IHNob3VsZCBub3QgYmUgY29uc2lkZXJlZCBmaW5hbGl6ZWQgdW50aWwKKyAqIGFmdGVyIGxpc3Rfb2JqZWN0c19maWx0ZXJfX2ZyZWUgaXMgY2FsbGVkIG9uIHRoZSByZXR1cm5lZCBgc3RydWN0CisgKiBmaWx0ZXIgKmAuCisgKi8KK3N0cnVjdCBmaWx0ZXIgKmxpc3Rfb2JqZWN0c19maWx0ZXJfX2luaXQoCisJc3RydWN0IG9pZHNldCAqb21pdHRlZCwKKwlzdHJ1Y3QgbGlzdF9vYmplY3RzX2ZpbHRlcl9vcHRpb25zICpmaWx0ZXJfb3B0aW9ucyk7CisKKy8qCisgKiBMZXRzIGBmaWx0ZXJgIGRlY2lkZSBob3cgdG8gaGFuZGxlIHRoZSBgb2JqYC4gSWYgYGZpbHRlcmAgaXMgTlVMTCwgdGhpcworICogZnVuY3Rpb24gYmVoYXZlcyBhcyBleHBlY3RlZCBpZiBubyBmaWx0ZXIgaXMgY29uZmlndXJlZDogYWxsIG9iamVjdHMgYXJlCisgKiBpbmNsdWRlZC4KKyAqLworZW51bSBsaXN0X29iamVjdHNfZmlsdGVyX3Jlc3VsdCBsaXN0X29iamVjdHNfZmlsdGVyX19maWx0ZXJfb2JqZWN0KAogCXN0cnVjdCByZXBvc2l0b3J5ICpyLAogCWVudW0gbGlzdF9vYmplY3RzX2ZpbHRlcl9zaXR1YXRpb24gZmlsdGVyX3NpdHVhdGlvbiwKIAlzdHJ1Y3Qgb2JqZWN0ICpvYmosCiAJY29uc3QgY2hhciAqcGF0aG5hbWUsCiAJY29uc3QgY2hhciAqZmlsZW5hbWUsCi0Jdm9pZCAqZmlsdGVyX2RhdGEpOwotCi10eXBlZGVmIHZvaWQgKCpmaWx0ZXJfZnJlZV9mbikodm9pZCAqZmlsdGVyX2RhdGEpOworCXN0cnVjdCBmaWx0ZXIgKmZpbHRlcik7CiAKIC8qCi0gKiBDb25zdHJ1Y3RvciBmb3IgdGhlIHNldCBvZiBkZWZpbmVkIGxpc3Qtb2JqZWN0cyBmaWx0ZXJzLgotICogUmV0dXJucyBhIGdlbmVyaWMgInZvaWQgKmZpbHRlcl9kYXRhIi4KLSAqCi0gKiBUaGUgcmV0dXJuZWQgImZpbHRlcl9mbiIgd2lsbCBiZSB1c2VkIGJ5IHRyYXZlcnNlX2NvbW1pdF9saXN0KCkKLSAqIHRvIGZpbHRlciB0aGUgcmVzdWx0cy4KLSAqCi0gKiBUaGUgcmV0dXJuZWQgImZpbHRlcl9mcmVlX2ZuIiBpcyBhIGRlc3RydWN0b3IgZm9yIHRoZQotICogZmlsdGVyX2RhdGEuCisgKiBEZXN0cm95cyBgZmlsdGVyYCBhbmQgZmluYWxpemVzIHRoZSBgb21pdHRlZGAgc2V0LCBpZiBwcmVzZW50LiBEb2VzCisgKiBub3RoaW5nIGlmIGBmaWx0ZXJgIGlzIG51bGwuCiAgKi8KLXZvaWQgKmxpc3Rfb2JqZWN0c19maWx0ZXJfX2luaXQoCi0Jc3RydWN0IG9pZHNldCAqb21pdHRlZCwKLQlzdHJ1Y3QgbGlzdF9vYmplY3RzX2ZpbHRlcl9vcHRpb25zICpmaWx0ZXJfb3B0aW9ucywKLQlmaWx0ZXJfb2JqZWN0X2ZuICpmaWx0ZXJfZm4sCi0JZmlsdGVyX2ZyZWVfZm4gKmZpbHRlcl9mcmVlX2ZuKTsKK3ZvaWQgbGlzdF9vYmplY3RzX2ZpbHRlcl9fZnJlZShzdHJ1Y3QgZmlsdGVyICpmaWx0ZXIpOwogCiAjZW5kaWYgLyogTElTVF9PQkpFQ1RTX0ZJTFRFUl9IICovCmRpZmYgLS1naXQgYS9saXN0LW9iamVjdHMuYyBiL2xpc3Qtb2JqZWN0cy5jCmluZGV4IGI1NjUxZGQuLmUxOTU4OWIgMTAwNjQ0Ci0tLSBhL2xpc3Qtb2JqZWN0cy5jCisrKyBiL2xpc3Qtb2JqZWN0cy5jCkBAIC0xOCw4ICsxOCw3IEBACiAJc2hvd19vYmplY3RfZm4gc2hvd19vYmplY3Q7CiAJc2hvd19jb21taXRfZm4gc2hvd19jb21taXQ7CiAJdm9pZCAqc2hvd19kYXRhOwotCWZpbHRlcl9vYmplY3RfZm4gZmlsdGVyX2ZuOwotCXZvaWQgKmZpbHRlcl9kYXRhOworCXN0cnVjdCBmaWx0ZXIgKmZpbHRlcjsKIH07CiAKIHN0YXRpYyB2b2lkIHByb2Nlc3NfYmxvYihzdHJ1Y3QgdHJhdmVyc2FsX2NvbnRleHQgKmN0eCwKQEAgLTI5LDcgKzI4LDcgQEAKIHsKIAlzdHJ1Y3Qgb2JqZWN0ICpvYmogPSAmYmxvYi0+b2JqZWN0OwogCXNpemVfdCBwYXRobGVuOwotCWVudW0gbGlzdF9vYmplY3RzX2ZpbHRlcl9yZXN1bHQgciA9IExPRlJfTUFSS19TRUVOIHwgTE9GUl9ET19TSE9XOworCWVudW0gbGlzdF9vYmplY3RzX2ZpbHRlcl9yZXN1bHQgcjsKIAogCWlmICghY3R4LT5yZXZzLT5ibG9iX29iamVjdHMpCiAJCXJldHVybjsKQEAgLTU0LDExICs1MywxMCBAQAogCiAJcGF0aGxlbiA9IHBhdGgtPmxlbjsKIAlzdHJidWZfYWRkc3RyKHBhdGgsIG5hbWUpOwotCWlmICgob2JqLT5mbGFncyAmIE5PVF9VU0VSX0dJVkVOKSAmJiBjdHgtPmZpbHRlcl9mbikKLQkJciA9IGN0eC0+ZmlsdGVyX2ZuKGN0eC0+cmV2cy0+cmVwbywKLQkJCQkgICBMT0ZTX0JMT0IsIG9iaiwKLQkJCQkgICBwYXRoLT5idWYsICZwYXRoLT5idWZbcGF0aGxlbl0sCi0JCQkJICAgY3R4LT5maWx0ZXJfZGF0YSk7CisJciA9IGxpc3Rfb2JqZWN0c19maWx0ZXJfX2ZpbHRlcl9vYmplY3QoY3R4LT5yZXZzLT5yZXBvLAorCQkJCQkgICAgICAgTE9GU19CTE9CLCBvYmosCisJCQkJCSAgICAgICBwYXRoLT5idWYsICZwYXRoLT5idWZbcGF0aGxlbl0sCisJCQkJCSAgICAgICBjdHgtPmZpbHRlcik7CiAJaWYgKHIgJiBMT0ZSX01BUktfU0VFTikKIAkJb2JqLT5mbGFncyB8PSBTRUVOOwogCWlmIChyICYgTE9GUl9ET19TSE9XKQpAQCAtMTU3LDcgKzE1NSw3IEBACiAJc3RydWN0IG9iamVjdCAqb2JqID0gJnRyZWUtPm9iamVjdDsKIAlzdHJ1Y3QgcmV2X2luZm8gKnJldnMgPSBjdHgtPnJldnM7CiAJaW50IGJhc2VsZW4gPSBiYXNlLT5sZW47Ci0JZW51bSBsaXN0X29iamVjdHNfZmlsdGVyX3Jlc3VsdCByID0gTE9GUl9NQVJLX1NFRU4gfCBMT0ZSX0RPX1NIT1c7CisJZW51bSBsaXN0X29iamVjdHNfZmlsdGVyX3Jlc3VsdCByOwogCWludCBmYWlsZWRfcGFyc2U7CiAKIAlpZiAoIXJldnMtPnRyZWVfb2JqZWN0cykKQEAgLTE4NiwxMSArMTg0LDEwIEBACiAJfQogCiAJc3RyYnVmX2FkZHN0cihiYXNlLCBuYW1lKTsKLQlpZiAoKG9iai0+ZmxhZ3MgJiBOT1RfVVNFUl9HSVZFTikgJiYgY3R4LT5maWx0ZXJfZm4pCi0JCXIgPSBjdHgtPmZpbHRlcl9mbihjdHgtPnJldnMtPnJlcG8sCi0JCQkJICAgTE9GU19CRUdJTl9UUkVFLCBvYmosCi0JCQkJICAgYmFzZS0+YnVmLCAmYmFzZS0+YnVmW2Jhc2VsZW5dLAotCQkJCSAgIGN0eC0+ZmlsdGVyX2RhdGEpOworCXIgPSBsaXN0X29iamVjdHNfZmlsdGVyX19maWx0ZXJfb2JqZWN0KGN0eC0+cmV2cy0+cmVwbywKKwkJCQkJICAgICAgIExPRlNfQkVHSU5fVFJFRSwgb2JqLAorCQkJCQkgICAgICAgYmFzZS0+YnVmLCAmYmFzZS0+YnVmW2Jhc2VsZW5dLAorCQkJCQkgICAgICAgY3R4LT5maWx0ZXIpOwogCWlmIChyICYgTE9GUl9NQVJLX1NFRU4pCiAJCW9iai0+ZmxhZ3MgfD0gU0VFTjsKIAlpZiAociAmIExPRlJfRE9fU0hPVykKQEAgLTIwMywxNiArMjAwLDE0IEBACiAJZWxzZSBpZiAoIWZhaWxlZF9wYXJzZSkKIAkJcHJvY2Vzc190cmVlX2NvbnRlbnRzKGN0eCwgdHJlZSwgYmFzZSk7CiAKLQlpZiAoKG9iai0+ZmxhZ3MgJiBOT1RfVVNFUl9HSVZFTikgJiYgY3R4LT5maWx0ZXJfZm4pIHsKLQkJciA9IGN0eC0+ZmlsdGVyX2ZuKGN0eC0+cmV2cy0+cmVwbywKLQkJCQkgICBMT0ZTX0VORF9UUkVFLCBvYmosCi0JCQkJICAgYmFzZS0+YnVmLCAmYmFzZS0+YnVmW2Jhc2VsZW5dLAotCQkJCSAgIGN0eC0+ZmlsdGVyX2RhdGEpOwotCQlpZiAociAmIExPRlJfTUFSS19TRUVOKQotCQkJb2JqLT5mbGFncyB8PSBTRUVOOwotCQlpZiAociAmIExPRlJfRE9fU0hPVykKLQkJCWN0eC0+c2hvd19vYmplY3Qob2JqLCBiYXNlLT5idWYsIGN0eC0+c2hvd19kYXRhKTsKLQl9CisJciA9IGxpc3Rfb2JqZWN0c19maWx0ZXJfX2ZpbHRlcl9vYmplY3QoY3R4LT5yZXZzLT5yZXBvLAorCQkJCQkgICAgICAgTE9GU19FTkRfVFJFRSwgb2JqLAorCQkJCQkgICAgICAgYmFzZS0+YnVmLCAmYmFzZS0+YnVmW2Jhc2VsZW5dLAorCQkJCQkgICAgICAgY3R4LT5maWx0ZXIpOworCWlmIChyICYgTE9GUl9NQVJLX1NFRU4pCisJCW9iai0+ZmxhZ3MgfD0gU0VFTjsKKwlpZiAociAmIExPRlJfRE9fU0hPVykKKwkJY3R4LT5zaG93X29iamVjdChvYmosIGJhc2UtPmJ1ZiwgY3R4LT5zaG93X2RhdGEpOwogCiAJc3RyYnVmX3NldGxlbihiYXNlLCBiYXNlbGVuKTsKIAlmcmVlX3RyZWVfYnVmZmVyKHRyZWUpOwpAQCAtMzcwLDcgKzM2NSw5IEBACiAJCSAqIGFuIHVuaW50ZXJlc3RpbmcgYm91bmRhcnkgY29tbWl0IG1heSBub3QgaGF2ZSBpdHMgdHJlZQogCQkgKiBwYXJzZWQgeWV0LCBidXQgd2UgYXJlIG5vdCBnb2luZyB0byBzaG93IHRoZW0gYW55d2F5CiAJCSAqLwotCQlpZiAoZ2V0X2NvbW1pdF90cmVlKGNvbW1pdCkpIHsKKwkJaWYgKCFjdHgtPnJldnMtPnRyZWVfb2JqZWN0cykKKwkJCTsgLyogZG8gbm90IGJvdGhlciBsb2FkaW5nIHRyZWUgKi8KKwkJZWxzZSBpZiAoZ2V0X2NvbW1pdF90cmVlKGNvbW1pdCkpIHsKIAkJCXN0cnVjdCB0cmVlICp0cmVlID0gZ2V0X2NvbW1pdF90cmVlKGNvbW1pdCk7CiAJCQl0cmVlLT5vYmplY3QuZmxhZ3MgfD0gTk9UX1VTRVJfR0lWRU47CiAJCQlhZGRfcGVuZGluZ190cmVlKGN0eC0+cmV2cywgdHJlZSk7CkBAIC00MDIsOCArMzk5LDcgQEAKIAljdHguc2hvd19jb21taXQgPSBzaG93X2NvbW1pdDsKIAljdHguc2hvd19vYmplY3QgPSBzaG93X29iamVjdDsKIAljdHguc2hvd19kYXRhID0gc2hvd19kYXRhOwotCWN0eC5maWx0ZXJfZm4gPSBOVUxMOwotCWN0eC5maWx0ZXJfZGF0YSA9IE5VTEw7CisJY3R4LmZpbHRlciA9IE5VTEw7CiAJZG9fdHJhdmVyc2UoJmN0eCk7CiB9CiAKQEAgLTQxNiwxNyArNDEyLDEyIEBACiAJc3RydWN0IG9pZHNldCAqb21pdHRlZCkKIHsKIAlzdHJ1Y3QgdHJhdmVyc2FsX2NvbnRleHQgY3R4OwotCWZpbHRlcl9mcmVlX2ZuIGZpbHRlcl9mcmVlX2ZuID0gTlVMTDsKIAogCWN0eC5yZXZzID0gcmV2czsKIAljdHguc2hvd19vYmplY3QgPSBzaG93X29iamVjdDsKIAljdHguc2hvd19jb21taXQgPSBzaG93X2NvbW1pdDsKIAljdHguc2hvd19kYXRhID0gc2hvd19kYXRhOwotCWN0eC5maWx0ZXJfZm4gPSBOVUxMOwotCi0JY3R4LmZpbHRlcl9kYXRhID0gbGlzdF9vYmplY3RzX2ZpbHRlcl9faW5pdChvbWl0dGVkLCBmaWx0ZXJfb3B0aW9ucywKLQkJCQkJCSAgICAmY3R4LmZpbHRlcl9mbiwgJmZpbHRlcl9mcmVlX2ZuKTsKKwljdHguZmlsdGVyID0gbGlzdF9vYmplY3RzX2ZpbHRlcl9faW5pdChvbWl0dGVkLCBmaWx0ZXJfb3B0aW9ucyk7CiAJZG9fdHJhdmVyc2UoJmN0eCk7Ci0JaWYgKGN0eC5maWx0ZXJfZGF0YSAmJiBmaWx0ZXJfZnJlZV9mbikKLQkJZmlsdGVyX2ZyZWVfZm4oY3R4LmZpbHRlcl9kYXRhKTsKKwlsaXN0X29iamVjdHNfZmlsdGVyX19mcmVlKGN0eC5maWx0ZXIpOwogfQpkaWZmIC0tZ2l0IGEvbGwtbWVyZ2UuYyBiL2xsLW1lcmdlLmMKaW5kZXggNWI4ZDQ2YS4uZDY1YTg5NyAxMDA2NDQKLS0tIGEvbGwtbWVyZ2UuYworKysgYi9sbC1tZXJnZS5jCkBAIC0zMiw2ICszMiwyMCBAQAogCWNoYXIgKmNtZGxpbmU7CiB9OwogCitzdGF0aWMgc3RydWN0IGF0dHJfY2hlY2sgKm1lcmdlX2F0dHJpYnV0ZXM7CitzdGF0aWMgc3RydWN0IGF0dHJfY2hlY2sgKmxvYWRfbWVyZ2VfYXR0cmlidXRlcyh2b2lkKQoreworCWlmICghbWVyZ2VfYXR0cmlidXRlcykKKwkJbWVyZ2VfYXR0cmlidXRlcyA9IGF0dHJfY2hlY2tfaW5pdGwoIm1lcmdlIiwgImNvbmZsaWN0LW1hcmtlci1zaXplIiwgTlVMTCk7CisJcmV0dXJuIG1lcmdlX2F0dHJpYnV0ZXM7Cit9CisKK3ZvaWQgcmVzZXRfbWVyZ2VfYXR0cmlidXRlcyh2b2lkKQoreworCWF0dHJfY2hlY2tfZnJlZShtZXJnZV9hdHRyaWJ1dGVzKTsKKwltZXJnZV9hdHRyaWJ1dGVzID0gTlVMTDsKK30KKwogLyoKICAqIEJ1aWx0LWluIGxvdy1sZXZlbHMKICAqLwpAQCAtMzU0LDcgKzM2OCw3IEBACiAJICAgICBzdHJ1Y3QgaW5kZXhfc3RhdGUgKmlzdGF0ZSwKIAkgICAgIGNvbnN0IHN0cnVjdCBsbF9tZXJnZV9vcHRpb25zICpvcHRzKQogewotCXN0YXRpYyBzdHJ1Y3QgYXR0cl9jaGVjayAqY2hlY2s7CisJc3RydWN0IGF0dHJfY2hlY2sgKmNoZWNrID0gbG9hZF9tZXJnZV9hdHRyaWJ1dGVzKCk7CiAJc3RhdGljIGNvbnN0IHN0cnVjdCBsbF9tZXJnZV9vcHRpb25zIGRlZmF1bHRfb3B0czsKIAljb25zdCBjaGFyICpsbF9kcml2ZXJfbmFtZSA9IE5VTEw7CiAJaW50IG1hcmtlcl9zaXplID0gREVGQVVMVF9DT05GTElDVF9NQVJLRVJfU0laRTsKQEAgLTM2OSw5ICszODMsNiBAQAogCQlub3JtYWxpemVfZmlsZSh0aGVpcnMsIHBhdGgsIGlzdGF0ZSk7CiAJfQogCi0JaWYgKCFjaGVjaykKLQkJY2hlY2sgPSBhdHRyX2NoZWNrX2luaXRsKCJtZXJnZSIsICJjb25mbGljdC1tYXJrZXItc2l6ZSIsIE5VTEwpOwotCiAJZ2l0X2NoZWNrX2F0dHIoaXN0YXRlLCBwYXRoLCBjaGVjayk7CiAJbGxfZHJpdmVyX25hbWUgPSBjaGVjay0+aXRlbXNbMF0udmFsdWU7CiAJaWYgKGNoZWNrLT5pdGVtc1sxXS52YWx1ZSkgewpkaWZmIC0tZ2l0IGEvbGwtbWVyZ2UuaCBiL2xsLW1lcmdlLmgKaW5kZXggYjllMmFmMS4uZTc4OTczZCAxMDA2NDQKLS0tIGEvbGwtbWVyZ2UuaAorKysgYi9sbC1tZXJnZS5oCkBAIC0yNiw1ICsyNiw2IEBACiAJICAgICBjb25zdCBzdHJ1Y3QgbGxfbWVyZ2Vfb3B0aW9ucyAqb3B0cyk7CiAKIGludCBsbF9tZXJnZV9tYXJrZXJfc2l6ZShzdHJ1Y3QgaW5kZXhfc3RhdGUgKmlzdGF0ZSwgY29uc3QgY2hhciAqcGF0aCk7Cit2b2lkIHJlc2V0X21lcmdlX2F0dHJpYnV0ZXModm9pZCk7CiAKICNlbmRpZgpkaWZmIC0tZ2l0IGEvbG9nLXRyZWUuYyBiL2xvZy10cmVlLmMKaW5kZXggMWU1NmRmNi4uMTUxZTEyZiAxMDA2NDQKLS0tIGEvbG9nLXRyZWUuYworKysgYi9sb2ctdHJlZS5jCkBAIC03Nyw2ICs3Nyw3IEBACiAKIGNvbnN0IHN0cnVjdCBuYW1lX2RlY29yYXRpb24gKmdldF9uYW1lX2RlY29yYXRpb24oY29uc3Qgc3RydWN0IG9iamVjdCAqb2JqKQogeworCWxvYWRfcmVmX2RlY29yYXRpb25zKE5VTEwsIERFQ09SQVRFX1NIT1JUX1JFRlMpOwogCXJldHVybiBsb29rdXBfZGVjb3JhdGlvbigmbmFtZV9kZWNvcmF0aW9uLCBvYmopOwogfQogCkBAIC02NzcsOSArNjc4LDcgQEAKIAkJcmF3ID0gKG9wdC0+Y29tbWl0X2Zvcm1hdCA9PSBDTUlUX0ZNVF9VU0VSRk9STUFUKTsKIAkJZm9ybWF0X2Rpc3BsYXlfbm90ZXMoJmNvbW1pdC0+b2JqZWN0Lm9pZCwgJm5vdGVidWYsCiAJCQkJICAgICBnZXRfbG9nX291dHB1dF9lbmNvZGluZygpLCByYXcpOwotCQljdHgubm90ZXNfbWVzc2FnZSA9IG5vdGVidWYubGVuCi0JCQk/IHN0cmJ1Zl9kZXRhY2goJm5vdGVidWYsIE5VTEwpCi0JCQk6IHhjYWxsb2MoMSwgMSk7CisJCWN0eC5ub3Rlc19tZXNzYWdlID0gc3RyYnVmX2RldGFjaCgmbm90ZWJ1ZiwgTlVMTCk7CiAJfQogCiAJLyoKQEAgLTc3MSw3ICs3NzAsNyBAQAogCQlvcHRzLnVzZV9jb2xvciA9IG9wdC0+ZGlmZm9wdC51c2VfY29sb3I7CiAJCWRpZmZfc2V0dXBfZG9uZSgmb3B0cyk7CiAJCXNob3dfcmFuZ2VfZGlmZihvcHQtPnJkaWZmMSwgb3B0LT5yZGlmZjIsCi0JCQkJb3B0LT5jcmVhdGlvbl9mYWN0b3IsIDEsICZvcHRzKTsKKwkJCQlvcHQtPmNyZWF0aW9uX2ZhY3RvciwgMSwgJm9wdHMsIE5VTEwpOwogCiAJCW1lbWNweSgmZGlmZl9xdWV1ZWRfZGlmZiwgJmRxLCBzaXplb2YoZGlmZl9xdWV1ZWRfZGlmZikpOwogCX0KZGlmZiAtLWdpdCBhL21lcmdlLXJlY3Vyc2l2ZS5jIGIvbWVyZ2UtcmVjdXJzaXZlLmMKaW5kZXggNmI4MTJkNi4uMTE4NjlhZCAxMDA2NDQKLS0tIGEvbWVyZ2UtcmVjdXJzaXZlLmMKKysrIGIvbWVyZ2UtcmVjdXJzaXZlLmMKQEAgLTQsMzAgKzQsNDAgQEAKICAqIFRoZSB0aGlldmVzIHdlcmUgQWxleCBSaWVzZW4gYW5kIEpvaGFubmVzIFNjaGluZGVsaW4sIGluIEp1bmUvSnVseSAyMDA2CiAgKi8KICNpbmNsdWRlICJjYWNoZS5oIgotI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUgIm1lcmdlLXJlY3Vyc2l2ZS5oIgorCiAjaW5jbHVkZSAiYWR2aWNlLmgiCi0jaW5jbHVkZSAibG9ja2ZpbGUuaCIKLSNpbmNsdWRlICJjYWNoZS10cmVlLmgiCi0jaW5jbHVkZSAib2JqZWN0LXN0b3JlLmgiCi0jaW5jbHVkZSAicmVwb3NpdG9yeS5oIgotI2luY2x1ZGUgImNvbW1pdC5oIgorI2luY2x1ZGUgImFsbG9jLmgiCisjaW5jbHVkZSAiYXR0ci5oIgogI2luY2x1ZGUgImJsb2IuaCIKICNpbmNsdWRlICJidWlsdGluLmgiCi0jaW5jbHVkZSAidHJlZS13YWxrLmgiCisjaW5jbHVkZSAiY2FjaGUtdHJlZS5oIgorI2luY2x1ZGUgImNvbW1pdC5oIgorI2luY2x1ZGUgImNvbW1pdC1yZWFjaC5oIgorI2luY2x1ZGUgImNvbmZpZy5oIgogI2luY2x1ZGUgImRpZmYuaCIKICNpbmNsdWRlICJkaWZmY29yZS5oIgotI2luY2x1ZGUgInRhZy5oIgotI2luY2x1ZGUgImFsbG9jLmgiCi0jaW5jbHVkZSAidW5wYWNrLXRyZWVzLmgiCi0jaW5jbHVkZSAic3RyaW5nLWxpc3QuaCIKLSNpbmNsdWRlICJ4ZGlmZi1pbnRlcmZhY2UuaCIKLSNpbmNsdWRlICJsbC1tZXJnZS5oIgotI2luY2x1ZGUgImF0dHIuaCIKLSNpbmNsdWRlICJtZXJnZS1yZWN1cnNpdmUuaCIKICNpbmNsdWRlICJkaXIuaCIKLSNpbmNsdWRlICJzdWJtb2R1bGUuaCIKKyNpbmNsdWRlICJsbC1tZXJnZS5oIgorI2luY2x1ZGUgImxvY2tmaWxlLmgiCisjaW5jbHVkZSAib2JqZWN0LXN0b3JlLmgiCisjaW5jbHVkZSAicmVwb3NpdG9yeS5oIgogI2luY2x1ZGUgInJldmlzaW9uLmgiCi0jaW5jbHVkZSAiY29tbWl0LXJlYWNoLmgiCisjaW5jbHVkZSAic3RyaW5nLWxpc3QuaCIKKyNpbmNsdWRlICJzdWJtb2R1bGUuaCIKKyNpbmNsdWRlICJ0YWcuaCIKKyNpbmNsdWRlICJ0cmVlLXdhbGsuaCIKKyNpbmNsdWRlICJ1bnBhY2stdHJlZXMuaCIKKyNpbmNsdWRlICJ4ZGlmZi1pbnRlcmZhY2UuaCIKKworc3RydWN0IG1lcmdlX29wdGlvbnNfaW50ZXJuYWwgeworCWludCBjYWxsX2RlcHRoOworCWludCBuZWVkZWRfcmVuYW1lX2xpbWl0OworCXN0cnVjdCBoYXNobWFwIGN1cnJlbnRfZmlsZV9kaXJfc2V0OworCXN0cnVjdCBzdHJpbmdfbGlzdCBkZl9jb25mbGljdF9maWxlX3NldDsKKwlzdHJ1Y3QgdW5wYWNrX3RyZWVzX29wdGlvbnMgdW5wYWNrX29wdHM7CisJc3RydWN0IGluZGV4X3N0YXRlIG9yaWdfaW5kZXg7Cit9OwogCiBzdHJ1Y3QgcGF0aF9oYXNobWFwX2VudHJ5IHsKIAlzdHJ1Y3QgaGFzaG1hcF9lbnRyeSBlOwpAQCAtMzUsMTQgKzQ1LDE2IEBACiB9OwogCiBzdGF0aWMgaW50IHBhdGhfaGFzaG1hcF9jbXAoY29uc3Qgdm9pZCAqY21wX2RhdGEsCi0JCQkgICAgY29uc3Qgdm9pZCAqZW50cnksCi0JCQkgICAgY29uc3Qgdm9pZCAqZW50cnlfb3Jfa2V5LAorCQkJICAgIGNvbnN0IHN0cnVjdCBoYXNobWFwX2VudHJ5ICplcHRyLAorCQkJICAgIGNvbnN0IHN0cnVjdCBoYXNobWFwX2VudHJ5ICplbnRyeV9vcl9rZXksCiAJCQkgICAgY29uc3Qgdm9pZCAqa2V5ZGF0YSkKIHsKLQljb25zdCBzdHJ1Y3QgcGF0aF9oYXNobWFwX2VudHJ5ICphID0gZW50cnk7Ci0JY29uc3Qgc3RydWN0IHBhdGhfaGFzaG1hcF9lbnRyeSAqYiA9IGVudHJ5X29yX2tleTsKKwljb25zdCBzdHJ1Y3QgcGF0aF9oYXNobWFwX2VudHJ5ICphLCAqYjsKIAljb25zdCBjaGFyICprZXkgPSBrZXlkYXRhOwogCisJYSA9IGNvbnRhaW5lcl9vZihlcHRyLCBjb25zdCBzdHJ1Y3QgcGF0aF9oYXNobWFwX2VudHJ5LCBlKTsKKwliID0gY29udGFpbmVyX29mKGVudHJ5X29yX2tleSwgY29uc3Qgc3RydWN0IHBhdGhfaGFzaG1hcF9lbnRyeSwgZSk7CisKIAlpZiAoaWdub3JlX2Nhc2UpCiAJCXJldHVybiBzdHJjYXNlY21wKGEtPnBhdGgsIGtleSA/IGtleSA6IGItPnBhdGgpOwogCWVsc2UKQEAgLTU0LDYgKzY2LDI0IEBACiAJcmV0dXJuIGlnbm9yZV9jYXNlID8gc3RyaWhhc2gocGF0aCkgOiBzdHJoYXNoKHBhdGgpOwogfQogCisvKgorICogRm9yIGRpcl9yZW5hbWVfZW50cnksIGRpcmVjdG9yeSBuYW1lcyBhcmUgc3RvcmVkIGFzIGEgZnVsbCBwYXRoIGZyb20gdGhlCisgKiB0b3BsZXZlbCBvZiB0aGUgcmVwb3NpdG9yeSBhbmQgZG8gbm90IGluY2x1ZGUgYSB0cmFpbGluZyAnLycuICBBbHNvOgorICoKKyAqICAgZGlyOiAgICAgICAgICAgICAgICBvcmlnaW5hbCBuYW1lIG9mIGRpcmVjdG9yeSBiZWluZyByZW5hbWVkCisgKiAgIG5vbl91bmlxdWVfbmV3X2RpcjogaWYgdHJ1ZSwgY291bGQgbm90IGRldGVybWluZSBuZXdfZGlyCisgKiAgIG5ld19kaXI6ICAgICAgICAgICAgZmluYWwgbmFtZSBvZiBkaXJlY3RvcnkgYmVpbmcgcmVuYW1lZAorICogICBwb3NzaWJsZV9uZXdfZGlyczogIHRlbXBvcmFyeSB1c2VkIHRvIGhlbHAgZGV0ZXJtaW5lIG5ld19kaXI7IHNlZSBjb21tZW50cworICogICAgICAgICAgICAgICAgICAgICAgIGluIGdldF9kaXJlY3RvcnlfcmVuYW1lcygpIGZvciBkZXRhaWxzCisgKi8KK3N0cnVjdCBkaXJfcmVuYW1lX2VudHJ5IHsKKwlzdHJ1Y3QgaGFzaG1hcF9lbnRyeSBlbnQ7CisJY2hhciAqZGlyOworCXVuc2lnbmVkIG5vbl91bmlxdWVfbmV3X2RpcjoxOworCXN0cnVjdCBzdHJidWYgbmV3X2RpcjsKKwlzdHJ1Y3Qgc3RyaW5nX2xpc3QgcG9zc2libGVfbmV3X2RpcnM7Cit9OworCiBzdGF0aWMgc3RydWN0IGRpcl9yZW5hbWVfZW50cnkgKmRpcl9yZW5hbWVfZmluZF9lbnRyeShzdHJ1Y3QgaGFzaG1hcCAqaGFzaG1hcCwKIAkJCQkJCSAgICAgIGNoYXIgKmRpcikKIHsKQEAgLTYxLDE4ICs5MSwyMCBAQAogCiAJaWYgKGRpciA9PSBOVUxMKQogCQlyZXR1cm4gTlVMTDsKLQloYXNobWFwX2VudHJ5X2luaXQoJmtleSwgc3RyaGFzaChkaXIpKTsKKwloYXNobWFwX2VudHJ5X2luaXQoJmtleS5lbnQsIHN0cmhhc2goZGlyKSk7CiAJa2V5LmRpciA9IGRpcjsKLQlyZXR1cm4gaGFzaG1hcF9nZXQoaGFzaG1hcCwgJmtleSwgTlVMTCk7CisJcmV0dXJuIGhhc2htYXBfZ2V0X2VudHJ5KGhhc2htYXAsICZrZXksIGVudCwgTlVMTCk7CiB9CiAKIHN0YXRpYyBpbnQgZGlyX3JlbmFtZV9jbXAoY29uc3Qgdm9pZCAqdW51c2VkX2NtcF9kYXRhLAotCQkJICBjb25zdCB2b2lkICplbnRyeSwKLQkJCSAgY29uc3Qgdm9pZCAqZW50cnlfb3Jfa2V5LAorCQkJICBjb25zdCBzdHJ1Y3QgaGFzaG1hcF9lbnRyeSAqZXB0ciwKKwkJCSAgY29uc3Qgc3RydWN0IGhhc2htYXBfZW50cnkgKmVudHJ5X29yX2tleSwKIAkJCSAgY29uc3Qgdm9pZCAqdW51c2VkX2tleWRhdGEpCiB7Ci0JY29uc3Qgc3RydWN0IGRpcl9yZW5hbWVfZW50cnkgKmUxID0gZW50cnk7Ci0JY29uc3Qgc3RydWN0IGRpcl9yZW5hbWVfZW50cnkgKmUyID0gZW50cnlfb3Jfa2V5OworCWNvbnN0IHN0cnVjdCBkaXJfcmVuYW1lX2VudHJ5ICplMSwgKmUyOworCisJZTEgPSBjb250YWluZXJfb2YoZXB0ciwgY29uc3Qgc3RydWN0IGRpcl9yZW5hbWVfZW50cnksIGVudCk7CisJZTIgPSBjb250YWluZXJfb2YoZW50cnlfb3Jfa2V5LCBjb25zdCBzdHJ1Y3QgZGlyX3JlbmFtZV9lbnRyeSwgZW50KTsKIAogCXJldHVybiBzdHJjbXAoZTEtPmRpciwgZTItPmRpcik7CiB9CkBAIC04NSwzNCArMTE3LDQ2IEBACiBzdGF0aWMgdm9pZCBkaXJfcmVuYW1lX2VudHJ5X2luaXQoc3RydWN0IGRpcl9yZW5hbWVfZW50cnkgKmVudHJ5LAogCQkJCSAgY2hhciAqZGlyZWN0b3J5KQogewotCWhhc2htYXBfZW50cnlfaW5pdChlbnRyeSwgc3RyaGFzaChkaXJlY3RvcnkpKTsKKwloYXNobWFwX2VudHJ5X2luaXQoJmVudHJ5LT5lbnQsIHN0cmhhc2goZGlyZWN0b3J5KSk7CiAJZW50cnktPmRpciA9IGRpcmVjdG9yeTsKIAllbnRyeS0+bm9uX3VuaXF1ZV9uZXdfZGlyID0gMDsKIAlzdHJidWZfaW5pdCgmZW50cnktPm5ld19kaXIsIDApOwogCXN0cmluZ19saXN0X2luaXQoJmVudHJ5LT5wb3NzaWJsZV9uZXdfZGlycywgMCk7CiB9CiAKK3N0cnVjdCBjb2xsaXNpb25fZW50cnkgeworCXN0cnVjdCBoYXNobWFwX2VudHJ5IGVudDsKKwljaGFyICp0YXJnZXRfZmlsZTsKKwlzdHJ1Y3Qgc3RyaW5nX2xpc3Qgc291cmNlX2ZpbGVzOworCXVuc2lnbmVkIHJlcG9ydGVkX2FscmVhZHk6MTsKK307CisKIHN0YXRpYyBzdHJ1Y3QgY29sbGlzaW9uX2VudHJ5ICpjb2xsaXNpb25fZmluZF9lbnRyeShzdHJ1Y3QgaGFzaG1hcCAqaGFzaG1hcCwKIAkJCQkJCSAgICBjaGFyICp0YXJnZXRfZmlsZSkKIHsKIAlzdHJ1Y3QgY29sbGlzaW9uX2VudHJ5IGtleTsKIAotCWhhc2htYXBfZW50cnlfaW5pdCgma2V5LCBzdHJoYXNoKHRhcmdldF9maWxlKSk7CisJaGFzaG1hcF9lbnRyeV9pbml0KCZrZXkuZW50LCBzdHJoYXNoKHRhcmdldF9maWxlKSk7CiAJa2V5LnRhcmdldF9maWxlID0gdGFyZ2V0X2ZpbGU7Ci0JcmV0dXJuIGhhc2htYXBfZ2V0KGhhc2htYXAsICZrZXksIE5VTEwpOworCXJldHVybiBoYXNobWFwX2dldF9lbnRyeShoYXNobWFwLCAma2V5LCBlbnQsIE5VTEwpOwogfQogCi1zdGF0aWMgaW50IGNvbGxpc2lvbl9jbXAodm9pZCAqdW51c2VkX2NtcF9kYXRhLAotCQkJIGNvbnN0IHN0cnVjdCBjb2xsaXNpb25fZW50cnkgKmUxLAotCQkJIGNvbnN0IHN0cnVjdCBjb2xsaXNpb25fZW50cnkgKmUyLAorc3RhdGljIGludCBjb2xsaXNpb25fY21wKGNvbnN0IHZvaWQgKnVudXNlZF9jbXBfZGF0YSwKKwkJCSBjb25zdCBzdHJ1Y3QgaGFzaG1hcF9lbnRyeSAqZXB0ciwKKwkJCSBjb25zdCBzdHJ1Y3QgaGFzaG1hcF9lbnRyeSAqZW50cnlfb3Jfa2V5LAogCQkJIGNvbnN0IHZvaWQgKnVudXNlZF9rZXlkYXRhKQogeworCWNvbnN0IHN0cnVjdCBjb2xsaXNpb25fZW50cnkgKmUxLCAqZTI7CisKKwllMSA9IGNvbnRhaW5lcl9vZihlcHRyLCBjb25zdCBzdHJ1Y3QgY29sbGlzaW9uX2VudHJ5LCBlbnQpOworCWUyID0gY29udGFpbmVyX29mKGVudHJ5X29yX2tleSwgY29uc3Qgc3RydWN0IGNvbGxpc2lvbl9lbnRyeSwgZW50KTsKKwogCXJldHVybiBzdHJjbXAoZTEtPnRhcmdldF9maWxlLCBlMi0+dGFyZ2V0X2ZpbGUpOwogfQogCiBzdGF0aWMgdm9pZCBjb2xsaXNpb25faW5pdChzdHJ1Y3QgaGFzaG1hcCAqbWFwKQogewotCWhhc2htYXBfaW5pdChtYXAsIChoYXNobWFwX2NtcF9mbikgY29sbGlzaW9uX2NtcCwgTlVMTCwgMCk7CisJaGFzaG1hcF9pbml0KG1hcCwgY29sbGlzaW9uX2NtcCwgTlVMTCwgMCk7CiB9CiAKIHN0YXRpYyB2b2lkIGZsdXNoX291dHB1dChzdHJ1Y3QgbWVyZ2Vfb3B0aW9ucyAqb3B0KQpAQCAtMjg0LDcgKzMyOCw4IEBACiAKIHN0YXRpYyBpbnQgc2hvdyhzdHJ1Y3QgbWVyZ2Vfb3B0aW9ucyAqb3B0LCBpbnQgdikKIHsKLQlyZXR1cm4gKCFvcHQtPmNhbGxfZGVwdGggJiYgb3B0LT52ZXJib3NpdHkgPj0gdikgfHwgb3B0LT52ZXJib3NpdHkgPj0gNTsKKwlyZXR1cm4gKCFvcHQtPnByaXYtPmNhbGxfZGVwdGggJiYgb3B0LT52ZXJib3NpdHkgPj0gdikgfHwKKwkJb3B0LT52ZXJib3NpdHkgPj0gNTsKIH0KIAogX19hdHRyaWJ1dGVfXygoZm9ybWF0IChwcmludGYsIDMsIDQpKSkKQEAgLTI5NSw3ICszNDAsNyBAQAogCWlmICghc2hvdyhvcHQsIHYpKQogCQlyZXR1cm47CiAKLQlzdHJidWZfYWRkY2hhcnMoJm9wdC0+b2J1ZiwgJyAnLCBvcHQtPmNhbGxfZGVwdGggKiAyKTsKKwlzdHJidWZfYWRkY2hhcnMoJm9wdC0+b2J1ZiwgJyAnLCBvcHQtPnByaXYtPmNhbGxfZGVwdGggKiAyKTsKIAogCXZhX3N0YXJ0KGFwLCBmbXQpOwogCXN0cmJ1Zl92YWRkZigmb3B0LT5vYnVmLCBmbXQsIGFwKTsKQEAgLTMxMCw3ICszNTUsNyBAQAogewogCXN0cnVjdCBtZXJnZV9yZW1vdGVfZGVzYyAqZGVzYzsKIAotCXN0cmJ1Zl9hZGRjaGFycygmb3B0LT5vYnVmLCAnICcsIG9wdC0+Y2FsbF9kZXB0aCAqIDIpOworCXN0cmJ1Zl9hZGRjaGFycygmb3B0LT5vYnVmLCAnICcsIG9wdC0+cHJpdi0+Y2FsbF9kZXB0aCAqIDIpOwogCWRlc2MgPSBtZXJnZV9yZW1vdGVfdXRpbChjb21taXQpOwogCWlmIChkZXNjKQogCQlzdHJidWZfYWRkZigmb3B0LT5vYnVmLCAidmlydHVhbCAlc1xuIiwgZGVzYy0+bmFtZSk7CkBAIC0zNTgsNiArNDAzLDExIEBACiAJcmV0dXJuIHJldDsKIH0KIAorc3RhdGljIGlubGluZSBpbnQgbWVyZ2VfZGV0ZWN0X3JlbmFtZShzdHJ1Y3QgbWVyZ2Vfb3B0aW9ucyAqb3B0KQoreworCXJldHVybiAob3B0LT5kZXRlY3RfcmVuYW1lcyA+PSAwKSA/IG9wdC0+ZGV0ZWN0X3JlbmFtZXMgOiAxOworfQorCiBzdGF0aWMgdm9pZCBpbml0X3RyZWVfZGVzY19mcm9tX3RyZWUoc3RydWN0IHRyZWVfZGVzYyAqZGVzYywgc3RydWN0IHRyZWUgKnRyZWUpCiB7CiAJcGFyc2VfdHJlZSh0cmVlKTsKQEAgLTM3Myw3NCArNDIzLDQzIEBACiAJc3RydWN0IHRyZWVfZGVzYyB0WzNdOwogCXN0cnVjdCBpbmRleF9zdGF0ZSB0bXBfaW5kZXggPSB7IE5VTEwgfTsKIAotCW1lbXNldCgmb3B0LT51bnBhY2tfb3B0cywgMCwgc2l6ZW9mKG9wdC0+dW5wYWNrX29wdHMpKTsKLQlpZiAob3B0LT5jYWxsX2RlcHRoKQotCQlvcHQtPnVucGFja19vcHRzLmluZGV4X29ubHkgPSAxOworCW1lbXNldCgmb3B0LT5wcml2LT51bnBhY2tfb3B0cywgMCwgc2l6ZW9mKG9wdC0+cHJpdi0+dW5wYWNrX29wdHMpKTsKKwlpZiAob3B0LT5wcml2LT5jYWxsX2RlcHRoKQorCQlvcHQtPnByaXYtPnVucGFja19vcHRzLmluZGV4X29ubHkgPSAxOwogCWVsc2UKLQkJb3B0LT51bnBhY2tfb3B0cy51cGRhdGUgPSAxOwotCW9wdC0+dW5wYWNrX29wdHMubWVyZ2UgPSAxOwotCW9wdC0+dW5wYWNrX29wdHMuaGVhZF9pZHggPSAyOwotCW9wdC0+dW5wYWNrX29wdHMuZm4gPSB0aHJlZXdheV9tZXJnZTsKLQlvcHQtPnVucGFja19vcHRzLnNyY19pbmRleCA9IG9wdC0+cmVwby0+aW5kZXg7Ci0Jb3B0LT51bnBhY2tfb3B0cy5kc3RfaW5kZXggPSAmdG1wX2luZGV4OwotCW9wdC0+dW5wYWNrX29wdHMuYWdncmVzc2l2ZSA9ICFtZXJnZV9kZXRlY3RfcmVuYW1lKG9wdCk7Ci0Jc2V0dXBfdW5wYWNrX3RyZWVzX3BvcmNlbGFpbigmb3B0LT51bnBhY2tfb3B0cywgIm1lcmdlIik7CisJCW9wdC0+cHJpdi0+dW5wYWNrX29wdHMudXBkYXRlID0gMTsKKwlvcHQtPnByaXYtPnVucGFja19vcHRzLm1lcmdlID0gMTsKKwlvcHQtPnByaXYtPnVucGFja19vcHRzLmhlYWRfaWR4ID0gMjsKKwlvcHQtPnByaXYtPnVucGFja19vcHRzLmZuID0gdGhyZWV3YXlfbWVyZ2U7CisJb3B0LT5wcml2LT51bnBhY2tfb3B0cy5zcmNfaW5kZXggPSBvcHQtPnJlcG8tPmluZGV4OworCW9wdC0+cHJpdi0+dW5wYWNrX29wdHMuZHN0X2luZGV4ID0gJnRtcF9pbmRleDsKKwlvcHQtPnByaXYtPnVucGFja19vcHRzLmFnZ3Jlc3NpdmUgPSAhbWVyZ2VfZGV0ZWN0X3JlbmFtZShvcHQpOworCXNldHVwX3VucGFja190cmVlc19wb3JjZWxhaW4oJm9wdC0+cHJpdi0+dW5wYWNrX29wdHMsICJtZXJnZSIpOwogCiAJaW5pdF90cmVlX2Rlc2NfZnJvbV90cmVlKHQrMCwgY29tbW9uKTsKIAlpbml0X3RyZWVfZGVzY19mcm9tX3RyZWUodCsxLCBoZWFkKTsKIAlpbml0X3RyZWVfZGVzY19mcm9tX3RyZWUodCsyLCBtZXJnZSk7CiAKLQlyYyA9IHVucGFja190cmVlcygzLCB0LCAmb3B0LT51bnBhY2tfb3B0cyk7CisJcmMgPSB1bnBhY2tfdHJlZXMoMywgdCwgJm9wdC0+cHJpdi0+dW5wYWNrX29wdHMpOwogCWNhY2hlX3RyZWVfZnJlZSgmb3B0LT5yZXBvLT5pbmRleC0+Y2FjaGVfdHJlZSk7CiAKIAkvKgotCSAqIFVwZGF0ZSBvcHQtPnJlcG8tPmluZGV4IHRvIG1hdGNoIHRoZSBuZXcgcmVzdWx0cywgQUZURVIgc2F2aW5nIGEgY29weQotCSAqIGluIG9wdC0+b3JpZ19pbmRleC4gIFVwZGF0ZSBzcmNfaW5kZXggdG8gcG9pbnQgdG8gdGhlIHNhdmVkIGNvcHkuCi0JICogKHZlcmlmeV91cHRvZGF0ZSgpIGNoZWNrcyBzcmNfaW5kZXgsIGFuZCB0aGUgb3JpZ2luYWwgaW5kZXggaXMKLQkgKiB0aGUgb25lIHRoYXQgaGFkIHRoZSBuZWNlc3NhcnkgbW9kaWZpY2F0aW9uIHRpbWVzdGFtcHMuKQorCSAqIFVwZGF0ZSBvcHQtPnJlcG8tPmluZGV4IHRvIG1hdGNoIHRoZSBuZXcgcmVzdWx0cywgQUZURVIgc2F2aW5nIGEKKwkgKiBjb3B5IGluIG9wdC0+cHJpdi0+b3JpZ19pbmRleC4gIFVwZGF0ZSBzcmNfaW5kZXggdG8gcG9pbnQgdG8gdGhlCisJICogc2F2ZWQgY29weS4gICh2ZXJpZnlfdXB0b2RhdGUoKSBjaGVja3Mgc3JjX2luZGV4LCBhbmQgdGhlIG9yaWdpbmFsCisJICogaW5kZXggaXMgdGhlIG9uZSB0aGF0IGhhZCB0aGUgbmVjZXNzYXJ5IG1vZGlmaWNhdGlvbiB0aW1lc3RhbXBzLikKIAkgKi8KLQlvcHQtPm9yaWdfaW5kZXggPSAqb3B0LT5yZXBvLT5pbmRleDsKKwlvcHQtPnByaXYtPm9yaWdfaW5kZXggPSAqb3B0LT5yZXBvLT5pbmRleDsKIAkqb3B0LT5yZXBvLT5pbmRleCA9IHRtcF9pbmRleDsKLQlvcHQtPnVucGFja19vcHRzLnNyY19pbmRleCA9ICZvcHQtPm9yaWdfaW5kZXg7CisJb3B0LT5wcml2LT51bnBhY2tfb3B0cy5zcmNfaW5kZXggPSAmb3B0LT5wcml2LT5vcmlnX2luZGV4OwogCiAJcmV0dXJuIHJjOwogfQogCiBzdGF0aWMgdm9pZCB1bnBhY2tfdHJlZXNfZmluaXNoKHN0cnVjdCBtZXJnZV9vcHRpb25zICpvcHQpCiB7Ci0JZGlzY2FyZF9pbmRleCgmb3B0LT5vcmlnX2luZGV4KTsKLQljbGVhcl91bnBhY2tfdHJlZXNfcG9yY2VsYWluKCZvcHQtPnVucGFja19vcHRzKTsKLX0KLQotc3RydWN0IHRyZWUgKndyaXRlX3RyZWVfZnJvbV9tZW1vcnkoc3RydWN0IG1lcmdlX29wdGlvbnMgKm9wdCkKLXsKLQlzdHJ1Y3QgdHJlZSAqcmVzdWx0ID0gTlVMTDsKLQlzdHJ1Y3QgaW5kZXhfc3RhdGUgKmlzdGF0ZSA9IG9wdC0+cmVwby0+aW5kZXg7Ci0KLQlpZiAodW5tZXJnZWRfaW5kZXgoaXN0YXRlKSkgewotCQlpbnQgaTsKLQkJZnByaW50ZihzdGRlcnIsICJCVUc6IFRoZXJlIGFyZSB1bm1lcmdlZCBpbmRleCBlbnRyaWVzOlxuIik7Ci0JCWZvciAoaSA9IDA7IGkgPCBpc3RhdGUtPmNhY2hlX25yOyBpKyspIHsKLQkJCWNvbnN0IHN0cnVjdCBjYWNoZV9lbnRyeSAqY2UgPSBpc3RhdGUtPmNhY2hlW2ldOwotCQkJaWYgKGNlX3N0YWdlKGNlKSkKLQkJCQlmcHJpbnRmKHN0ZGVyciwgIkJVRzogJWQgJS4qc1xuIiwgY2Vfc3RhZ2UoY2UpLAotCQkJCQkoaW50KWNlX25hbWVsZW4oY2UpLCBjZS0+bmFtZSk7Ci0JCX0KLQkJQlVHKCJ1bm1lcmdlZCBpbmRleCBlbnRyaWVzIGluIG1lcmdlLXJlY3Vyc2l2ZS5jIik7Ci0JfQotCi0JaWYgKCFpc3RhdGUtPmNhY2hlX3RyZWUpCi0JCWlzdGF0ZS0+Y2FjaGVfdHJlZSA9IGNhY2hlX3RyZWUoKTsKLQotCWlmICghY2FjaGVfdHJlZV9mdWxseV92YWxpZChpc3RhdGUtPmNhY2hlX3RyZWUpICYmCi0JICAgIGNhY2hlX3RyZWVfdXBkYXRlKGlzdGF0ZSwgMCkgPCAwKSB7Ci0JCWVycihvcHQsIF8oImVycm9yIGJ1aWxkaW5nIHRyZWVzIikpOwotCQlyZXR1cm4gTlVMTDsKLQl9Ci0KLQlyZXN1bHQgPSBsb29rdXBfdHJlZShvcHQtPnJlcG8sICZpc3RhdGUtPmNhY2hlX3RyZWUtPm9pZCk7Ci0KLQlyZXR1cm4gcmVzdWx0OworCWRpc2NhcmRfaW5kZXgoJm9wdC0+cHJpdi0+b3JpZ19pbmRleCk7CisJY2xlYXJfdW5wYWNrX3RyZWVzX3BvcmNlbGFpbigmb3B0LT5wcml2LT51bnBhY2tfb3B0cyk7CiB9CiAKIHN0YXRpYyBpbnQgc2F2ZV9maWxlc19kaXJzKGNvbnN0IHN0cnVjdCBvYmplY3RfaWQgKm9pZCwKQEAgLTQ1NCw4ICs0NzMsOCBAQAogCXN0cmJ1Zl9hZGRzdHIoYmFzZSwgcGF0aCk7CiAKIAlGTEVYX0FMTE9DX01FTShlbnRyeSwgcGF0aCwgYmFzZS0+YnVmLCBiYXNlLT5sZW4pOwotCWhhc2htYXBfZW50cnlfaW5pdChlbnRyeSwgcGF0aF9oYXNoKGVudHJ5LT5wYXRoKSk7Ci0JaGFzaG1hcF9hZGQoJm9wdC0+Y3VycmVudF9maWxlX2Rpcl9zZXQsIGVudHJ5KTsKKwloYXNobWFwX2VudHJ5X2luaXQoJmVudHJ5LT5lLCBwYXRoX2hhc2goZW50cnktPnBhdGgpKTsKKwloYXNobWFwX2FkZCgmb3B0LT5wcml2LT5jdXJyZW50X2ZpbGVfZGlyX3NldCwgJmVudHJ5LT5lKTsKIAogCXN0cmJ1Zl9zZXRsZW4oYmFzZSwgYmFzZWxlbik7CiAJcmV0dXJuIChTX0lTRElSKG1vZGUpID8gUkVBRF9UUkVFX1JFQ1VSU0lWRSA6IDApOwpAQCAtNTg2LDcgKzYwNSw3IEBACiAJICogSWYgd2UncmUgbWVyZ2luZyBtZXJnZS1iYXNlcywgd2UgZG9uJ3Qgd2FudCB0byBib3RoZXIgd2l0aAogCSAqIGFueSB3b3JraW5nIGRpcmVjdG9yeSBjaGFuZ2VzLgogCSAqLwotCWlmIChvcHQtPmNhbGxfZGVwdGgpCisJaWYgKG9wdC0+cHJpdi0+Y2FsbF9kZXB0aCkKIAkJcmV0dXJuOwogCiAJLyogRW5zdXJlIEQvRiBjb25mbGljdHMgYXJlIGFkamFjZW50IGluIHRoZSBlbnRyaWVzIGxpc3QuICovCkBAIC01OTgsNyArNjE3LDcgQEAKIAlkZl9zb3J0ZWRfZW50cmllcy5jbXAgPSBzdHJpbmdfbGlzdF9kZl9uYW1lX2NvbXBhcmU7CiAJc3RyaW5nX2xpc3Rfc29ydCgmZGZfc29ydGVkX2VudHJpZXMpOwogCi0Jc3RyaW5nX2xpc3RfY2xlYXIoJm9wdC0+ZGZfY29uZmxpY3RfZmlsZV9zZXQsIDEpOworCXN0cmluZ19saXN0X2NsZWFyKCZvcHQtPnByaXYtPmRmX2NvbmZsaWN0X2ZpbGVfc2V0LCAxKTsKIAlmb3IgKGkgPSAwOyBpIDwgZGZfc29ydGVkX2VudHJpZXMubnI7IGkrKykgewogCQljb25zdCBjaGFyICpwYXRoID0gZGZfc29ydGVkX2VudHJpZXMuaXRlbXNbaV0uc3RyaW5nOwogCQlpbnQgbGVuID0gc3RybGVuKHBhdGgpOwpAQCAtNjE0LDcgKzYzMyw3IEBACiAJCSAgICBsZW4gPiBsYXN0X2xlbiAmJgogCQkgICAgbWVtY21wKHBhdGgsIGxhc3RfZmlsZSwgbGFzdF9sZW4pID09IDAgJiYKIAkJICAgIHBhdGhbbGFzdF9sZW5dID09ICcvJykgewotCQkJc3RyaW5nX2xpc3RfaW5zZXJ0KCZvcHQtPmRmX2NvbmZsaWN0X2ZpbGVfc2V0LCBsYXN0X2ZpbGUpOworCQkJc3RyaW5nX2xpc3RfaW5zZXJ0KCZvcHQtPnByaXYtPmRmX2NvbmZsaWN0X2ZpbGVfc2V0LCBsYXN0X2ZpbGUpOwogCQl9CiAKIAkJLyoKQEAgLTY4MSw4ICs3MDAsOCBAQAogc3RhdGljIGludCByZW1vdmVfZmlsZShzdHJ1Y3QgbWVyZ2Vfb3B0aW9ucyAqb3B0LCBpbnQgY2xlYW4sCiAJCSAgICAgICBjb25zdCBjaGFyICpwYXRoLCBpbnQgbm9fd2QpCiB7Ci0JaW50IHVwZGF0ZV9jYWNoZSA9IG9wdC0+Y2FsbF9kZXB0aCB8fCBjbGVhbjsKLQlpbnQgdXBkYXRlX3dvcmtpbmdfZGlyZWN0b3J5ID0gIW9wdC0+Y2FsbF9kZXB0aCAmJiAhbm9fd2Q7CisJaW50IHVwZGF0ZV9jYWNoZSA9IG9wdC0+cHJpdi0+Y2FsbF9kZXB0aCB8fCBjbGVhbjsKKwlpbnQgdXBkYXRlX3dvcmtpbmdfZGlyZWN0b3J5ID0gIW9wdC0+cHJpdi0+Y2FsbF9kZXB0aCAmJiAhbm9fd2Q7CiAKIAlpZiAodXBkYXRlX2NhY2hlKSB7CiAJCWlmIChyZW1vdmVfZmlsZV9mcm9tX2luZGV4KG9wdC0+cmVwby0+aW5kZXgsIHBhdGgpKQpAQCAtNzEyLDcgKzczMSw5IEBACiAJCQlvdXQtPmJ1ZltpXSA9ICdfJzsKIH0KIAotc3RhdGljIGNoYXIgKnVuaXF1ZV9wYXRoKHN0cnVjdCBtZXJnZV9vcHRpb25zICpvcHQsIGNvbnN0IGNoYXIgKnBhdGgsIGNvbnN0IGNoYXIgKmJyYW5jaCkKK3N0YXRpYyBjaGFyICp1bmlxdWVfcGF0aChzdHJ1Y3QgbWVyZ2Vfb3B0aW9ucyAqb3B0LAorCQkJIGNvbnN0IGNoYXIgKnBhdGgsCisJCQkgY29uc3QgY2hhciAqYnJhbmNoKQogewogCXN0cnVjdCBwYXRoX2hhc2htYXBfZW50cnkgKmVudHJ5OwogCXN0cnVjdCBzdHJidWYgbmV3cGF0aCA9IFNUUkJVRl9JTklUOwpAQCAtNzIzLDE2ICs3NDQsMTYgQEAKIAlhZGRfZmxhdHRlbmVkX3BhdGgoJm5ld3BhdGgsIGJyYW5jaCk7CiAKIAliYXNlX2xlbiA9IG5ld3BhdGgubGVuOwotCXdoaWxlIChoYXNobWFwX2dldF9mcm9tX2hhc2goJm9wdC0+Y3VycmVudF9maWxlX2Rpcl9zZXQsCisJd2hpbGUgKGhhc2htYXBfZ2V0X2Zyb21faGFzaCgmb3B0LT5wcml2LT5jdXJyZW50X2ZpbGVfZGlyX3NldCwKIAkJCQkgICAgIHBhdGhfaGFzaChuZXdwYXRoLmJ1ZiksIG5ld3BhdGguYnVmKSB8fAotCSAgICAgICAoIW9wdC0+Y2FsbF9kZXB0aCAmJiBmaWxlX2V4aXN0cyhuZXdwYXRoLmJ1ZikpKSB7CisJICAgICAgICghb3B0LT5wcml2LT5jYWxsX2RlcHRoICYmIGZpbGVfZXhpc3RzKG5ld3BhdGguYnVmKSkpIHsKIAkJc3RyYnVmX3NldGxlbigmbmV3cGF0aCwgYmFzZV9sZW4pOwogCQlzdHJidWZfYWRkZigmbmV3cGF0aCwgIl8lZCIsIHN1ZmZpeCsrKTsKIAl9CiAKIAlGTEVYX0FMTE9DX01FTShlbnRyeSwgcGF0aCwgbmV3cGF0aC5idWYsIG5ld3BhdGgubGVuKTsKLQloYXNobWFwX2VudHJ5X2luaXQoZW50cnksIHBhdGhfaGFzaChlbnRyeS0+cGF0aCkpOwotCWhhc2htYXBfYWRkKCZvcHQtPmN1cnJlbnRfZmlsZV9kaXJfc2V0LCBlbnRyeSk7CisJaGFzaG1hcF9lbnRyeV9pbml0KCZlbnRyeS0+ZSwgcGF0aF9oYXNoKGVudHJ5LT5wYXRoKSk7CisJaGFzaG1hcF9hZGQoJm9wdC0+cHJpdi0+Y3VycmVudF9maWxlX2Rpcl9zZXQsICZlbnRyeS0+ZSk7CiAJcmV0dXJuIHN0cmJ1Zl9kZXRhY2goJm5ld3BhdGgsIE5VTEwpOwogfQogCkBAIC03NjQsNyArNzg1LDggQEAKIAogCXN0cmJ1Zl9yZWxlYXNlKCZkaXJwYXRoKTsKIAlyZXR1cm4gY2hlY2tfd29ya2luZ19jb3B5ICYmICFsc3RhdChwYXRoLCAmc3QpICYmIFNfSVNESVIoc3Quc3RfbW9kZSkgJiYKLQkJIShlbXB0eV9vayAmJiBpc19lbXB0eV9kaXIocGF0aCkpOworCQkhKGVtcHR5X29rICYmIGlzX2VtcHR5X2RpcihwYXRoKSkgJiYKKwkJIWhhc19zeW1saW5rX2xlYWRpbmdfcGF0aChwYXRoLCBzdHJsZW4ocGF0aCkpOwogfQogCiAvKgpAQCAtNzc0LDcgKzc5Niw3IEBACiBzdGF0aWMgaW50IHdhc190cmFja2VkX2FuZF9tYXRjaGVzKHN0cnVjdCBtZXJnZV9vcHRpb25zICpvcHQsIGNvbnN0IGNoYXIgKnBhdGgsCiAJCQkJICAgY29uc3Qgc3RydWN0IGRpZmZfZmlsZXNwZWMgKmJsb2IpCiB7Ci0JaW50IHBvcyA9IGluZGV4X25hbWVfcG9zKCZvcHQtPm9yaWdfaW5kZXgsIHBhdGgsIHN0cmxlbihwYXRoKSk7CisJaW50IHBvcyA9IGluZGV4X25hbWVfcG9zKCZvcHQtPnByaXYtPm9yaWdfaW5kZXgsIHBhdGgsIHN0cmxlbihwYXRoKSk7CiAJc3RydWN0IGNhY2hlX2VudHJ5ICpjZTsKIAogCWlmICgwID4gcG9zKQpAQCAtNzgyLDcgKzgwNCw3IEBACiAJCXJldHVybiAwOwogCiAJLyogU2VlIGlmIHRoZSBmaWxlIHdlIHdlcmUgdHJhY2tpbmcgYmVmb3JlIG1hdGNoZXMgKi8KLQljZSA9IG9wdC0+b3JpZ19pbmRleC5jYWNoZVtwb3NdOworCWNlID0gb3B0LT5wcml2LT5vcmlnX2luZGV4LmNhY2hlW3Bvc107CiAJcmV0dXJuIChvaWRfZXEoJmNlLT5vaWQsICZibG9iLT5vaWQpICYmIGNlLT5jZV9tb2RlID09IGJsb2ItPm1vZGUpOwogfQogCkBAIC03OTEsNyArODEzLDcgQEAKICAqLwogc3RhdGljIGludCB3YXNfdHJhY2tlZChzdHJ1Y3QgbWVyZ2Vfb3B0aW9ucyAqb3B0LCBjb25zdCBjaGFyICpwYXRoKQogewotCWludCBwb3MgPSBpbmRleF9uYW1lX3Bvcygmb3B0LT5vcmlnX2luZGV4LCBwYXRoLCBzdHJsZW4ocGF0aCkpOworCWludCBwb3MgPSBpbmRleF9uYW1lX3Bvcygmb3B0LT5wcml2LT5vcmlnX2luZGV4LCBwYXRoLCBzdHJsZW4ocGF0aCkpOwogCiAJaWYgKDAgPD0gcG9zKQogCQkvKiB3ZSB3ZXJlIHRyYWNraW5nIHRoaXMgcGF0aCBiZWZvcmUgdGhlIG1lcmdlICovCkBAIC04NDgsMTIgKzg3MCwxMiBAQAogCXN0cnVjdCBjYWNoZV9lbnRyeSAqY2U7CiAJaW50IGRpcnR5ID0gMTsKIAotCWlmIChvcHQtPmNhbGxfZGVwdGggfHwgIXdhc190cmFja2VkKG9wdCwgcGF0aCkpCisJaWYgKG9wdC0+cHJpdi0+Y2FsbF9kZXB0aCB8fCAhd2FzX3RyYWNrZWQob3B0LCBwYXRoKSkKIAkJcmV0dXJuICFkaXJ0eTsKIAotCWNlID0gaW5kZXhfZmlsZV9leGlzdHMob3B0LT51bnBhY2tfb3B0cy5zcmNfaW5kZXgsCisJY2UgPSBpbmRleF9maWxlX2V4aXN0cyhvcHQtPnByaXYtPnVucGFja19vcHRzLnNyY19pbmRleCwKIAkJCSAgICAgICBwYXRoLCBzdHJsZW4ocGF0aCksIGlnbm9yZV9jYXNlKTsKLQlkaXJ0eSA9IHZlcmlmeV91cHRvZGF0ZShjZSwgJm9wdC0+dW5wYWNrX29wdHMpICE9IDA7CisJZGlydHkgPSB2ZXJpZnlfdXB0b2RhdGUoY2UsICZvcHQtPnByaXYtPnVucGFja19vcHRzKSAhPSAwOwogCXJldHVybiBkaXJ0eTsKIH0KIApAQCAtODYzLDggKzg4NSw4IEBACiAJY29uc3QgY2hhciAqbXNnID0gXygiZmFpbGVkIHRvIGNyZWF0ZSBwYXRoICclcyclcyIpOwogCiAJLyogVW5saW5rIGFueSBEL0YgY29uZmxpY3QgZmlsZXMgdGhhdCBhcmUgaW4gdGhlIHdheSAqLwotCWZvciAoaSA9IDA7IGkgPCBvcHQtPmRmX2NvbmZsaWN0X2ZpbGVfc2V0Lm5yOyBpKyspIHsKLQkJY29uc3QgY2hhciAqZGZfcGF0aCA9IG9wdC0+ZGZfY29uZmxpY3RfZmlsZV9zZXQuaXRlbXNbaV0uc3RyaW5nOworCWZvciAoaSA9IDA7IGkgPCBvcHQtPnByaXYtPmRmX2NvbmZsaWN0X2ZpbGVfc2V0Lm5yOyBpKyspIHsKKwkJY29uc3QgY2hhciAqZGZfcGF0aCA9IG9wdC0+cHJpdi0+ZGZfY29uZmxpY3RfZmlsZV9zZXQuaXRlbXNbaV0uc3RyaW5nOwogCQlzaXplX3QgcGF0aGxlbiA9IHN0cmxlbihwYXRoKTsKIAkJc2l6ZV90IGRmX3BhdGhsZW4gPSBzdHJsZW4oZGZfcGF0aCk7CiAJCWlmIChkZl9wYXRobGVuIDwgcGF0aGxlbiAmJgpAQCAtODc0LDcgKzg5Niw3IEBACiAJCQkgICAgICAgXygiUmVtb3ZpbmcgJXMgdG8gbWFrZSByb29tIGZvciBzdWJkaXJlY3RvcnlcbiIpLAogCQkJICAgICAgIGRmX3BhdGgpOwogCQkJdW5saW5rKGRmX3BhdGgpOwotCQkJdW5zb3J0ZWRfc3RyaW5nX2xpc3RfZGVsZXRlX2l0ZW0oJm9wdC0+ZGZfY29uZmxpY3RfZmlsZV9zZXQsCisJCQl1bnNvcnRlZF9zdHJpbmdfbGlzdF9kZWxldGVfaXRlbSgmb3B0LT5wcml2LT5kZl9jb25mbGljdF9maWxlX3NldCwKIAkJCQkJCQkgaSwgMCk7CiAJCQlicmVhazsKIAkJfQpAQCAtOTE1LDcgKzkzNyw3IEBACiB7CiAJaW50IHJldCA9IDA7CiAKLQlpZiAob3B0LT5jYWxsX2RlcHRoKQorCWlmIChvcHQtPnByaXYtPmNhbGxfZGVwdGgpCiAJCXVwZGF0ZV93ZCA9IDA7CiAKIAlpZiAodXBkYXRlX3dkKSB7CkBAIC05MzQsOSArOTU2LDExIEBACiAJCX0KIAogCQlidWYgPSByZWFkX29iamVjdF9maWxlKCZjb250ZW50cy0+b2lkLCAmdHlwZSwgJnNpemUpOwotCQlpZiAoIWJ1ZikKLQkJCXJldHVybiBlcnIob3B0LCBfKCJjYW5ub3QgcmVhZCBvYmplY3QgJXMgJyVzJyIpLAotCQkJCSAgIG9pZF90b19oZXgoJmNvbnRlbnRzLT5vaWQpLCBwYXRoKTsKKwkJaWYgKCFidWYpIHsKKwkJCXJldCA9IGVycihvcHQsIF8oImNhbm5vdCByZWFkIG9iamVjdCAlcyAnJXMnIiksCisJCQkJICBvaWRfdG9faGV4KCZjb250ZW50cy0+b2lkKSwgcGF0aCk7CisJCQlnb3RvIGZyZWVfYnVmOworCQl9CiAJCWlmICh0eXBlICE9IE9CSl9CTE9CKSB7CiAJCQlyZXQgPSBlcnIob3B0LCBfKCJibG9iIGV4cGVjdGVkIGZvciAlcyAnJXMnIiksCiAJCQkJICBvaWRfdG9faGV4KCZjb250ZW50cy0+b2lkKSwgcGF0aCk7CkBAIC05NDQsNyArOTY4LDggQEAKIAkJfQogCQlpZiAoU19JU1JFRyhjb250ZW50cy0+bW9kZSkpIHsKIAkJCXN0cnVjdCBzdHJidWYgc3RyYnVmID0gU1RSQlVGX0lOSVQ7Ci0JCQlpZiAoY29udmVydF90b193b3JraW5nX3RyZWUob3B0LT5yZXBvLT5pbmRleCwgcGF0aCwgYnVmLCBzaXplLCAmc3RyYnVmKSkgeworCQkJaWYgKGNvbnZlcnRfdG9fd29ya2luZ190cmVlKG9wdC0+cmVwby0+aW5kZXgsCisJCQkJCQkgICAgcGF0aCwgYnVmLCBzaXplLCAmc3RyYnVmKSkgewogCQkJCWZyZWUoYnVmKTsKIAkJCQlzaXplID0gc3RyYnVmLmxlbjsKIAkJCQlidWYgPSBzdHJidWZfZGV0YWNoKCZzdHJidWYsIE5VTEwpOwpAQCAtOTk3LDcgKzEwMjIsNyBAQAogCQkgICAgICAgY29uc3QgY2hhciAqcGF0aCkKIHsKIAlyZXR1cm4gdXBkYXRlX2ZpbGVfZmxhZ3Mob3B0LCBjb250ZW50cywgcGF0aCwKLQkJCQkgb3B0LT5jYWxsX2RlcHRoIHx8IGNsZWFuLCAhb3B0LT5jYWxsX2RlcHRoKTsKKwkJCQkgb3B0LT5wcml2LT5jYWxsX2RlcHRoIHx8IGNsZWFuLCAhb3B0LT5wcml2LT5jYWxsX2RlcHRoKTsKIH0KIAogLyogTG93IGxldmVsIGZpbGUgbWVyZ2luZywgdXBkYXRlIGFuZCByZW1vdmFsICovCkBAIC0xMDE5LDIyICsxMDQ0LDIyIEBACiB7CiAJbW1maWxlX3Qgb3JpZywgc3JjMSwgc3JjMjsKIAlzdHJ1Y3QgbGxfbWVyZ2Vfb3B0aW9ucyBsbF9vcHRzID0gezB9OwotCWNoYXIgKmJhc2VfbmFtZSwgKm5hbWUxLCAqbmFtZTI7CisJY2hhciAqYmFzZSwgKm5hbWUxLCAqbmFtZTI7CiAJaW50IG1lcmdlX3N0YXR1czsKIAogCWxsX29wdHMucmVub3JtYWxpemUgPSBvcHQtPnJlbm9ybWFsaXplOwogCWxsX29wdHMuZXh0cmFfbWFya2VyX3NpemUgPSBleHRyYV9tYXJrZXJfc2l6ZTsKIAlsbF9vcHRzLnhkbF9vcHRzID0gb3B0LT54ZGxfb3B0czsKIAotCWlmIChvcHQtPmNhbGxfZGVwdGgpIHsKKwlpZiAob3B0LT5wcml2LT5jYWxsX2RlcHRoKSB7CiAJCWxsX29wdHMudmlydHVhbF9hbmNlc3RvciA9IDE7CiAJCWxsX29wdHMudmFyaWFudCA9IDA7CiAJfSBlbHNlIHsKIAkJc3dpdGNoIChvcHQtPnJlY3Vyc2l2ZV92YXJpYW50KSB7Ci0JCWNhc2UgTUVSR0VfUkVDVVJTSVZFX09VUlM6CisJCWNhc2UgTUVSR0VfVkFSSUFOVF9PVVJTOgogCQkJbGxfb3B0cy52YXJpYW50ID0gWERMX01FUkdFX0ZBVk9SX09VUlM7CiAJCQlicmVhazsKLQkJY2FzZSBNRVJHRV9SRUNVUlNJVkVfVEhFSVJTOgorCQljYXNlIE1FUkdFX1ZBUklBTlRfVEhFSVJTOgogCQkJbGxfb3B0cy52YXJpYW50ID0gWERMX01FUkdFX0ZBVk9SX1RIRUlSUzsKIAkJCWJyZWFrOwogCQlkZWZhdWx0OgpAQCAtMTA0MywxNiArMTA2OCwxMyBAQAogCQl9CiAJfQogCi0JYXNzZXJ0KGEtPnBhdGggJiYgYi0+cGF0aCk7Ci0JaWYgKHN0cmNtcChhLT5wYXRoLCBiLT5wYXRoKSB8fAotCSAgICAob3B0LT5hbmNlc3RvciAhPSBOVUxMICYmIHN0cmNtcChhLT5wYXRoLCBvLT5wYXRoKSAhPSAwKSkgewotCQliYXNlX25hbWUgPSBvcHQtPmFuY2VzdG9yID09IE5VTEwgPyBOVUxMIDoKLQkJCW1rcGF0aGR1cCgiJXM6JXMiLCBvcHQtPmFuY2VzdG9yLCBvLT5wYXRoKTsKKwlhc3NlcnQoYS0+cGF0aCAmJiBiLT5wYXRoICYmIG8tPnBhdGggJiYgb3B0LT5hbmNlc3Rvcik7CisJaWYgKHN0cmNtcChhLT5wYXRoLCBiLT5wYXRoKSB8fCBzdHJjbXAoYS0+cGF0aCwgby0+cGF0aCkgIT0gMCkgeworCQliYXNlICA9IG1rcGF0aGR1cCgiJXM6JXMiLCBvcHQtPmFuY2VzdG9yLCBvLT5wYXRoKTsKIAkJbmFtZTEgPSBta3BhdGhkdXAoIiVzOiVzIiwgYnJhbmNoMSwgYS0+cGF0aCk7CiAJCW5hbWUyID0gbWtwYXRoZHVwKCIlczolcyIsIGJyYW5jaDIsIGItPnBhdGgpOwogCX0gZWxzZSB7Ci0JCWJhc2VfbmFtZSA9IG9wdC0+YW5jZXN0b3IgPT0gTlVMTCA/IE5VTEwgOgotCQkJbWtwYXRoZHVwKCIlcyIsIG9wdC0+YW5jZXN0b3IpOworCQliYXNlICA9IG1rcGF0aGR1cCgiJXMiLCBvcHQtPmFuY2VzdG9yKTsKIAkJbmFtZTEgPSBta3BhdGhkdXAoIiVzIiwgYnJhbmNoMSk7CiAJCW5hbWUyID0gbWtwYXRoZHVwKCIlcyIsIGJyYW5jaDIpOwogCX0KQEAgLTEwNjEsMTEgKzEwODMsMTEgQEAKIAlyZWFkX21tYmxvYigmc3JjMSwgJmEtPm9pZCk7CiAJcmVhZF9tbWJsb2IoJnNyYzIsICZiLT5vaWQpOwogCi0JbWVyZ2Vfc3RhdHVzID0gbGxfbWVyZ2UocmVzdWx0X2J1ZiwgYS0+cGF0aCwgJm9yaWcsIGJhc2VfbmFtZSwKKwltZXJnZV9zdGF0dXMgPSBsbF9tZXJnZShyZXN1bHRfYnVmLCBhLT5wYXRoLCAmb3JpZywgYmFzZSwKIAkJCQkmc3JjMSwgbmFtZTEsICZzcmMyLCBuYW1lMiwKIAkJCQlvcHQtPnJlcG8tPmluZGV4LCAmbGxfb3B0cyk7CiAKLQlmcmVlKGJhc2VfbmFtZSk7CisJZnJlZShiYXNlKTsKIAlmcmVlKG5hbWUxKTsKIAlmcmVlKG5hbWUyKTsKIAlmcmVlKG9yaWcucHRyKTsKQEAgLTExNjAsNyArMTE4Miw3IEBACiAJc3RydWN0IG9iamVjdF9hcnJheSBtZXJnZXM7CiAKIAlpbnQgaTsKLQlpbnQgc2VhcmNoID0gIW9wdC0+Y2FsbF9kZXB0aDsKKwlpbnQgc2VhcmNoID0gIW9wdC0+cHJpdi0+Y2FsbF9kZXB0aDsKIAogCS8qIHN0b3JlIGEgaW4gcmVzdWx0IGluIGNhc2Ugd2UgZmFpbCAqLwogCW9pZGNweShyZXN1bHQsIGEpOwpAQCAtMTM0NCwxNSArMTM2NiwxNSBAQAogCQkJCQkJCSZiLT5vaWQpOwogCQl9IGVsc2UgaWYgKFNfSVNMTksoYS0+bW9kZSkpIHsKIAkJCXN3aXRjaCAob3B0LT5yZWN1cnNpdmVfdmFyaWFudCkgewotCQkJY2FzZSBNRVJHRV9SRUNVUlNJVkVfTk9STUFMOgorCQkJY2FzZSBNRVJHRV9WQVJJQU5UX05PUk1BTDoKIAkJCQlvaWRjcHkoJnJlc3VsdC0+YmxvYi5vaWQsICZhLT5vaWQpOwogCQkJCWlmICghb2lkX2VxKCZhLT5vaWQsICZiLT5vaWQpKQogCQkJCQlyZXN1bHQtPmNsZWFuID0gMDsKIAkJCQlicmVhazsKLQkJCWNhc2UgTUVSR0VfUkVDVVJTSVZFX09VUlM6CisJCQljYXNlIE1FUkdFX1ZBUklBTlRfT1VSUzoKIAkJCQlvaWRjcHkoJnJlc3VsdC0+YmxvYi5vaWQsICZhLT5vaWQpOwogCQkJCWJyZWFrOwotCQkJY2FzZSBNRVJHRV9SRUNVUlNJVkVfVEhFSVJTOgorCQkJY2FzZSBNRVJHRV9WQVJJQU5UX1RIRUlSUzoKIAkJCQlvaWRjcHkoJnJlc3VsdC0+YmxvYi5vaWQsICZiLT5vaWQpOwogCQkJCWJyZWFrOwogCQkJfQpAQCAtMTM3OCwxMCArMTQwMCwxMSBAQAogCWNvbnN0IHN0cnVjdCByZW5hbWUgKnJlbiA9IGNpLT5yZW4xOwogCWNvbnN0IHN0cnVjdCBkaWZmX2ZpbGVzcGVjICpkZXN0ID0gcmVuLT5wYWlyLT50d287CiAJY2hhciAqZmlsZV9wYXRoID0gZGVzdC0+cGF0aDsKLQlpbnQgbWFya19jb25mbGljdGVkID0gKG9wdC0+ZGV0ZWN0X2RpcmVjdG9yeV9yZW5hbWVzID09IDEpOworCWludCBtYXJrX2NvbmZsaWN0ZWQgPSAob3B0LT5kZXRlY3RfZGlyZWN0b3J5X3JlbmFtZXMgPT0KKwkJCSAgICAgICBNRVJHRV9ESVJFQ1RPUllfUkVOQU1FU19DT05GTElDVCk7CiAJYXNzZXJ0KHJlbi0+ZGlyX3JlbmFtZV9vcmlnaW5hbF9kZXN0KTsKIAotCWlmICghb3B0LT5jYWxsX2RlcHRoICYmIHdvdWxkX2xvc2VfdW50cmFja2VkKG9wdCwgZGVzdC0+cGF0aCkpIHsKKwlpZiAoIW9wdC0+cHJpdi0+Y2FsbF9kZXB0aCAmJiB3b3VsZF9sb3NlX3VudHJhY2tlZChvcHQsIGRlc3QtPnBhdGgpKSB7CiAJCW1hcmtfY29uZmxpY3RlZCA9IDE7CiAJCWZpbGVfcGF0aCA9IHVuaXF1ZV9wYXRoKG9wdCwgZGVzdC0+cGF0aCwgcmVuLT5icmFuY2gpOwogCQlvdXRwdXQob3B0LCAxLCBfKCJFcnJvcjogUmVmdXNpbmcgdG8gbG9zZSB1bnRyYWNrZWQgZmlsZSBhdCAlczsgIgpAQCAtMTQyNCwxMiArMTQ0NywxMiBAQAogCWNvbnN0IGNoYXIgKnVwZGF0ZV9wYXRoID0gcGF0aDsKIAlpbnQgcmV0ID0gMDsKIAotCWlmIChkaXJfaW5fd2F5KG9wdC0+cmVwby0+aW5kZXgsIHBhdGgsICFvcHQtPmNhbGxfZGVwdGgsIDApIHx8Ci0JICAgICghb3B0LT5jYWxsX2RlcHRoICYmIHdvdWxkX2xvc2VfdW50cmFja2VkKG9wdCwgcGF0aCkpKSB7CisJaWYgKGRpcl9pbl93YXkob3B0LT5yZXBvLT5pbmRleCwgcGF0aCwgIW9wdC0+cHJpdi0+Y2FsbF9kZXB0aCwgMCkgfHwKKwkgICAgKCFvcHQtPnByaXYtPmNhbGxfZGVwdGggJiYgd291bGRfbG9zZV91bnRyYWNrZWQob3B0LCBwYXRoKSkpIHsKIAkJdXBkYXRlX3BhdGggPSBhbHRfcGF0aCA9IHVuaXF1ZV9wYXRoKG9wdCwgcGF0aCwgY2hhbmdlX2JyYW5jaCk7CiAJfQogCi0JaWYgKG9wdC0+Y2FsbF9kZXB0aCkgeworCWlmIChvcHQtPnByaXYtPmNhbGxfZGVwdGgpIHsKIAkJLyoKIAkJICogV2UgY2Fubm90IGFyYml0cmFyaWx5IGFjY2VwdCBlaXRoZXIgYV9zaGEgb3IgYl9zaGEgYXMKIAkJICogY29ycmVjdDsgc2luY2UgdGhlcmUgaXMgbm8gdHJ1ZSAibWlkZGxlIHBvaW50IiBiZXR3ZWVuCkBAIC0xNTA0LDE0ICsxNTI3LDE0IEBACiAJCQkJICAgICBvcHQtPmJyYW5jaDIgOiBvcHQtPmJyYW5jaDEpOwogCiAJaWYgKGhhbmRsZV9jaGFuZ2VfZGVsZXRlKG9wdCwKLQkJCQkgb3B0LT5jYWxsX2RlcHRoID8gb3JpZy0+cGF0aCA6IGRlc3QtPnBhdGgsCi0JCQkJIG9wdC0+Y2FsbF9kZXB0aCA/IE5VTEwgOiBvcmlnLT5wYXRoLAorCQkJCSBvcHQtPnByaXYtPmNhbGxfZGVwdGggPyBvcmlnLT5wYXRoIDogZGVzdC0+cGF0aCwKKwkJCQkgb3B0LT5wcml2LT5jYWxsX2RlcHRoID8gTlVMTCA6IG9yaWctPnBhdGgsCiAJCQkJIG9yaWcsIGRlc3QsCiAJCQkJIHJlbmFtZV9icmFuY2gsIGRlbGV0ZV9icmFuY2gsCiAJCQkJIF8oInJlbmFtZSIpLCBfKCJyZW5hbWVkIikpKQogCQlyZXR1cm4gLTE7CiAKLQlpZiAob3B0LT5jYWxsX2RlcHRoKQorCWlmIChvcHQtPnByaXYtPmNhbGxfZGVwdGgpCiAJCXJldHVybiByZW1vdmVfZmlsZV9mcm9tX2luZGV4KG9wdC0+cmVwby0+aW5kZXgsIGRlc3QtPnBhdGgpOwogCWVsc2UKIAkJcmV0dXJuIHVwZGF0ZV9zdGFnZXMob3B0LCBkZXN0LT5wYXRoLCBOVUxMLApAQCAtMTU0OCw3ICsxNTcxLDcgQEAKIAkvKgogCSAqIEluIHRoZSByZWN1cnNpdmUgY2FzZSwgd2UganVzdCBvcHQgdG8gdW5kbyByZW5hbWVzCiAJICovCi0JaWYgKG9wdC0+Y2FsbF9kZXB0aCAmJiAocHJldl9wYXRoMSB8fCBwcmV2X3BhdGgyKSkgeworCWlmIChvcHQtPnByaXYtPmNhbGxfZGVwdGggJiYgKHByZXZfcGF0aDEgfHwgcHJldl9wYXRoMikpIHsKIAkJLyogUHV0IGZpcnN0IGZpbGUgKGEtPm9pZCwgYS0+bW9kZSkgaW4gaXRzIG9yaWdpbmFsIHNwb3QgKi8KIAkJaWYgKHByZXZfcGF0aDEpIHsKIAkJCWlmICh1cGRhdGVfZmlsZShvcHQsIDEsIGEsIHByZXZfcGF0aDEpKQpAQCAtMTU3NywxMCArMTYwMCwxMCBAQAogCS8qIFJlbW92ZSByZW5hbWUgc291cmNlcyBpZiByZW5hbWUvYWRkIG9yIHJlbmFtZS9yZW5hbWUoMnRvMSkgKi8KIAlpZiAocHJldl9wYXRoMSkKIAkJcmVtb3ZlX2ZpbGUob3B0LCAxLCBwcmV2X3BhdGgxLAotCQkJICAgIG9wdC0+Y2FsbF9kZXB0aCB8fCB3b3VsZF9sb3NlX3VudHJhY2tlZChvcHQsIHByZXZfcGF0aDEpKTsKKwkJCSAgICBvcHQtPnByaXYtPmNhbGxfZGVwdGggfHwgd291bGRfbG9zZV91bnRyYWNrZWQob3B0LCBwcmV2X3BhdGgxKSk7CiAJaWYgKHByZXZfcGF0aDIpCiAJCXJlbW92ZV9maWxlKG9wdCwgMSwgcHJldl9wYXRoMiwKLQkJCSAgICBvcHQtPmNhbGxfZGVwdGggfHwgd291bGRfbG9zZV91bnRyYWNrZWQob3B0LCBwcmV2X3BhdGgyKSk7CisJCQkgICAgb3B0LT5wcml2LT5jYWxsX2RlcHRoIHx8IHdvdWxkX2xvc2VfdW50cmFja2VkKG9wdCwgcHJldl9wYXRoMikpOwogCiAJLyoKIAkgKiBSZW1vdmUgdGhlIGNvbGxpc2lvbiBwYXRoLCBpZiBpdCB3b3VsZG4ndCBjYXVzZSBkaXJ0eSBjb250ZW50cwpAQCAtMTYyMiwxMiArMTY0NSwxMiBAQAogCW51bGwubW9kZSA9IDA7CiAKIAlpZiAobWVyZ2VfbW9kZV9hbmRfY29udGVudHMob3B0LCAmbnVsbCwgYSwgYiwgY29sbGlkZV9wYXRoLAotCQkJCSAgICBicmFuY2gxLCBicmFuY2gyLCBvcHQtPmNhbGxfZGVwdGggKiAyLCAmbWZpKSkKKwkJCQkgICAgYnJhbmNoMSwgYnJhbmNoMiwgb3B0LT5wcml2LT5jYWxsX2RlcHRoICogMiwgJm1maSkpCiAJCXJldHVybiAtMTsKIAltZmkuY2xlYW4gJj0gIWFsdF9wYXRoOwogCWlmICh1cGRhdGVfZmlsZShvcHQsIG1maS5jbGVhbiwgJm1maS5ibG9iLCB1cGRhdGVfcGF0aCkpCiAJCXJldHVybiAtMTsKLQlpZiAoIW1maS5jbGVhbiAmJiAhb3B0LT5jYWxsX2RlcHRoICYmCisJaWYgKCFtZmkuY2xlYW4gJiYgIW9wdC0+cHJpdi0+Y2FsbF9kZXB0aCAmJgogCSAgICB1cGRhdGVfc3RhZ2VzKG9wdCwgY29sbGlkZV9wYXRoLCBOVUxMLCBhLCBiKSkKIAkJcmV0dXJuIC0xOwogCWZyZWUoYWx0X3BhdGgpOwpAQCAtMTY2Nyw3ICsxNjkwLDcgQEAKIAkJCQkgICAgJmNpLT5yZW4xLT5zcmNfZW50cnktPnN0YWdlc1tvdGhlcl9zdGFnZV0sCiAJCQkJICAgIHByZXZfcGF0aF9kZXNjLAogCQkJCSAgICBvcHQtPmJyYW5jaDEsIG9wdC0+YnJhbmNoMiwKLQkJCQkgICAgMSArIG9wdC0+Y2FsbF9kZXB0aCAqIDIsICZtZmkpKQorCQkJCSAgICAxICsgb3B0LT5wcml2LT5jYWxsX2RlcHRoICogMiwgJm1maSkpCiAJCXJldHVybiAtMTsKIAlmcmVlKHByZXZfcGF0aF9kZXNjKTsKIApAQCAtMTY4NSw3ICsxNzA4LDcgQEAKIAkJCQkgICAgY29uc3QgY2hhciAqYnJhbmNoMikKIHsKIAljaGFyICpuZXdfcGF0aCA9IE5VTEw7Ci0JaWYgKGRpcl9pbl93YXkob3B0LT5yZXBvLT5pbmRleCwgcGF0aCwgIW9wdC0+Y2FsbF9kZXB0aCwgMCkpIHsKKwlpZiAoZGlyX2luX3dheShvcHQtPnJlcG8tPmluZGV4LCBwYXRoLCAhb3B0LT5wcml2LT5jYWxsX2RlcHRoLCAwKSkgewogCQluZXdfcGF0aCA9IHVuaXF1ZV9wYXRoKG9wdCwgcGF0aCwgYnJhbmNoMSk7CiAJCW91dHB1dChvcHQsIDEsIF8oIiVzIGlzIGEgZGlyZWN0b3J5IGluICVzIGFkZGluZyAiCiAJCQkgICAgICAgImFzICVzIGluc3RlYWQiKSwKQEAgLTE3MTYsMTcgKzE3MzksMTcgQEAKIAkgICAgICAgInJlbmFtZSBcIiVzXCItPlwiJXNcIiBpbiBcIiVzXCIlcyIpLAogCSAgICAgICBvLT5wYXRoLCBhLT5wYXRoLCBjaS0+cmVuMS0+YnJhbmNoLAogCSAgICAgICBvLT5wYXRoLCBiLT5wYXRoLCBjaS0+cmVuMi0+YnJhbmNoLAotCSAgICAgICBvcHQtPmNhbGxfZGVwdGggPyBfKCIgKGxlZnQgdW5yZXNvbHZlZCkiKSA6ICIiKTsKKwkgICAgICAgb3B0LT5wcml2LT5jYWxsX2RlcHRoID8gXygiIChsZWZ0IHVucmVzb2x2ZWQpIikgOiAiIik7CiAKIAlwYXRoX2Rlc2MgPSB4c3RyZm10KCIlcyBhbmQgJXMsIGJvdGggcmVuYW1lZCBmcm9tICVzIiwKIAkJCSAgICBhLT5wYXRoLCBiLT5wYXRoLCBvLT5wYXRoKTsKIAlpZiAobWVyZ2VfbW9kZV9hbmRfY29udGVudHMob3B0LCBvLCBhLCBiLCBwYXRoX2Rlc2MsCiAJCQkJICAgIGNpLT5yZW4xLT5icmFuY2gsIGNpLT5yZW4yLT5icmFuY2gsCi0JCQkJICAgIG9wdC0+Y2FsbF9kZXB0aCAqIDIsICZtZmkpKQorCQkJCSAgICBvcHQtPnByaXYtPmNhbGxfZGVwdGggKiAyLCAmbWZpKSkKIAkJcmV0dXJuIC0xOwogCWZyZWUocGF0aF9kZXNjKTsKIAotCWlmIChvcHQtPmNhbGxfZGVwdGgpIHsKKwlpZiAob3B0LT5wcml2LT5jYWxsX2RlcHRoKSB7CiAJCS8qCiAJCSAqIEZJWE1FOiBGb3IgcmVuYW1lL2FkZC1zb3VyY2UgY29uZmxpY3RzIChpZiB3ZSBjb3VsZCBkZXRlY3QKIAkJICogc3VjaCksIHRoaXMgaXMgd3JvbmcuICBXZSBzaG91bGQgaW5zdGVhZCBmaW5kIGEgdW5pcXVlCkBAIC0xODQxLDEyICsxODY0LDEyIEBACiAJCQkJICAgICZjaS0+cmVuMS0+c3JjX2VudHJ5LT5zdGFnZXNbb3N0YWdlMV0sCiAJCQkJICAgIHBhdGhfc2lkZV8xX2Rlc2MsCiAJCQkJICAgIG9wdC0+YnJhbmNoMSwgb3B0LT5icmFuY2gyLAotCQkJCSAgICAxICsgb3B0LT5jYWxsX2RlcHRoICogMiwgJm1maV9jMSkgfHwKKwkJCQkgICAgMSArIG9wdC0+cHJpdi0+Y2FsbF9kZXB0aCAqIDIsICZtZmlfYzEpIHx8CiAJICAgIG1lcmdlX21vZGVfYW5kX2NvbnRlbnRzKG9wdCwgYiwKIAkJCQkgICAgJmNpLT5yZW4yLT5zcmNfZW50cnktPnN0YWdlc1tvc3RhZ2UyXSwKIAkJCQkgICAgYzIsIHBhdGhfc2lkZV8yX2Rlc2MsCiAJCQkJICAgIG9wdC0+YnJhbmNoMSwgb3B0LT5icmFuY2gyLAotCQkJCSAgICAxICsgb3B0LT5jYWxsX2RlcHRoICogMiwgJm1maV9jMikpCisJCQkJICAgIDEgKyBvcHQtPnByaXYtPmNhbGxfZGVwdGggKiAyLCAmbWZpX2MyKSkKIAkJcmV0dXJuIC0xOwogCWZyZWUocGF0aF9zaWRlXzFfZGVzYyk7CiAJZnJlZShwYXRoX3NpZGVfMl9kZXNjKTsKQEAgLTE4ODAsMTcgKzE5MDMsMTUgQEAKIAkgKi8KIAlpZiAob3B0cy5kZXRlY3RfcmVuYW1lID4gRElGRl9ERVRFQ1RfUkVOQU1FKQogCQlvcHRzLmRldGVjdF9yZW5hbWUgPSBESUZGX0RFVEVDVF9SRU5BTUU7Ci0Jb3B0cy5yZW5hbWVfbGltaXQgPSBvcHQtPm1lcmdlX3JlbmFtZV9saW1pdCA+PSAwID8gb3B0LT5tZXJnZV9yZW5hbWVfbGltaXQgOgotCQkJICAgIG9wdC0+ZGlmZl9yZW5hbWVfbGltaXQgPj0gMCA/IG9wdC0+ZGlmZl9yZW5hbWVfbGltaXQgOgotCQkJICAgIDEwMDA7CisJb3B0cy5yZW5hbWVfbGltaXQgPSAob3B0LT5yZW5hbWVfbGltaXQgPj0gMCkgPyBvcHQtPnJlbmFtZV9saW1pdCA6IDEwMDA7CiAJb3B0cy5yZW5hbWVfc2NvcmUgPSBvcHQtPnJlbmFtZV9zY29yZTsKIAlvcHRzLnNob3dfcmVuYW1lX3Byb2dyZXNzID0gb3B0LT5zaG93X3JlbmFtZV9wcm9ncmVzczsKIAlvcHRzLm91dHB1dF9mb3JtYXQgPSBESUZGX0ZPUk1BVF9OT19PVVRQVVQ7CiAJZGlmZl9zZXR1cF9kb25lKCZvcHRzKTsKIAlkaWZmX3RyZWVfb2lkKCZvX3RyZWUtPm9iamVjdC5vaWQsICZ0cmVlLT5vYmplY3Qub2lkLCAiIiwgJm9wdHMpOwogCWRpZmZjb3JlX3N0ZCgmb3B0cyk7Ci0JaWYgKG9wdHMubmVlZGVkX3JlbmFtZV9saW1pdCA+IG9wdC0+bmVlZGVkX3JlbmFtZV9saW1pdCkKLQkJb3B0LT5uZWVkZWRfcmVuYW1lX2xpbWl0ID0gb3B0cy5uZWVkZWRfcmVuYW1lX2xpbWl0OworCWlmIChvcHRzLm5lZWRlZF9yZW5hbWVfbGltaXQgPiBvcHQtPnByaXYtPm5lZWRlZF9yZW5hbWVfbGltaXQpCisJCW9wdC0+cHJpdi0+bmVlZGVkX3JlbmFtZV9saW1pdCA9IG9wdHMubmVlZGVkX3JlbmFtZV9saW1pdDsKIAogCXJldCA9IHhtYWxsb2Moc2l6ZW9mKCpyZXQpKTsKIAkqcmV0ID0gZGlmZl9xdWV1ZWRfZGlmZjsKQEAgLTE5MzAsNiArMTk1MSwxNiBAQAogCQlyZXR1cm4gTlVMTDsKIAogCW9sZGxlbiA9IHN0cmxlbihlbnRyeS0+ZGlyKTsKKwlpZiAoZW50cnktPm5ld19kaXIubGVuID09IDApCisJCS8qCisJCSAqIElmIHNvbWVvbmUgcmVuYW1lZC9tZXJnZWQgYSBzdWJkaXJlY3RvcnkgaW50byB0aGUgcm9vdAorCQkgKiBkaXJlY3RvcnkgKGUuZy4gJ3NvbWUvc3ViZGlyJyAtPiAnJyksIHRoZW4gd2Ugd2FudCB0bworCQkgKiBhdm9pZCByZXR1cm5pbmcKKwkJICogICAgICcnICsgJy9maWxlbmFtZScKKwkJICogYXMgdGhlIHJlbmFtZTsgd2UgbmVlZCB0byBtYWtlIG9sZF9wYXRoICsgb2xkbGVuIGFkdmFuY2UKKwkJICogcGFzdCB0aGUgJy8nIGNoYXJhY3Rlci4KKwkJICovCisJCW9sZGxlbisrOwogCW5ld2xlbiA9IGVudHJ5LT5uZXdfZGlyLmxlbiArIChzdHJsZW4ob2xkX3BhdGgpIC0gb2xkbGVuKSArIDE7CiAJc3RyYnVmX2dyb3coJm5ld19wYXRoLCBuZXdsZW4pOwogCXN0cmJ1Zl9hZGRidWYoJm5ld19wYXRoLCAmZW50cnktPm5ld19kaXIpOwpAQCAtMTk0Miw4ICsxOTczLDggQEAKIAkJCQkgICAgY2hhciAqKm9sZF9kaXIsIGNoYXIgKipuZXdfZGlyKQogewogCWNoYXIgKmVuZF9vZl9vbGQsICplbmRfb2ZfbmV3OwotCWludCBvbGRfbGVuLCBuZXdfbGVuOwogCisJLyogRGVmYXVsdCByZXR1cm4gdmFsdWVzOiBOVUxMLCBtZWFuaW5nIG5vIHJlbmFtZSAqLwogCSpvbGRfZGlyID0gTlVMTDsKIAkqbmV3X2RpciA9IE5VTEw7CiAKQEAgLTE5NTQsNDMgKzE5ODUsOTEgQEAKIAkgKiAgICAiYS9iL2MvZCIgd2FzIHJlbmFtZWQgdG8gImEvYi9zb21lL3RoaW5nL2Vsc2UiCiAJICogc28sIGZvciB0aGlzIGV4YW1wbGUsIHRoaXMgZnVuY3Rpb24gcmV0dXJucyAiYS9iL2MvZCIgaW4KIAkgKiAqb2xkX2RpciBhbmQgImEvYi9zb21lL3RoaW5nL2Vsc2UiIGluICpuZXdfZGlyLgotCSAqCi0JICogQWxzbywgaWYgdGhlIGJhc2VuYW1lIG9mIHRoZSBmaWxlIGNoYW5nZWQsIHdlIGRvbid0IGNhcmUuICBXZQotCSAqIHdhbnQgdG8ga25vdyB3aGljaCBwb3J0aW9uIG9mIHRoZSBkaXJlY3RvcnksIGlmIGFueSwgY2hhbmdlZC4KKwkgKi8KKworCS8qCisJICogSWYgdGhlIGJhc2VuYW1lIG9mIHRoZSBmaWxlIGNoYW5nZWQsIHdlIGRvbid0IGNhcmUuICBXZSB3YW50CisJICogdG8ga25vdyB3aGljaCBwb3J0aW9uIG9mIHRoZSBkaXJlY3RvcnksIGlmIGFueSwgY2hhbmdlZC4KIAkgKi8KIAllbmRfb2Zfb2xkID0gc3RycmNocihvbGRfcGF0aCwgJy8nKTsKIAllbmRfb2ZfbmV3ID0gc3RycmNocihuZXdfcGF0aCwgJy8nKTsKIAotCWlmIChlbmRfb2Zfb2xkID09IE5VTEwgfHwgZW5kX29mX25ldyA9PSBOVUxMKQorCS8qCisJICogSWYgZW5kX29mX29sZCBpcyBOVUxMLCBvbGRfcGF0aCB3YXNuJ3QgaW4gYSBkaXJlY3RvcnksIHNvIHRoZXJlCisJICogY291bGQgbm90IGJlIGEgZGlyZWN0b3J5IHJlbmFtZSAob3VyIHJ1bGUgZWxzZXdoZXJlIHRoYXQgYQorCSAqIGRpcmVjdG9yeSB3aGljaCBzdGlsbCBleGlzdHMgaXMgbm90IGNvbnNpZGVyZWQgdG8gaGF2ZSBiZWVuCisJICogcmVuYW1lZCBtZWFucyB0aGUgcm9vdCBkaXJlY3RvcnkgY2FuIG5ldmVyIGJlIHJlbmFtZWQgLS0gYmVjYXVzZQorCSAqIHRoZSByb290IGRpcmVjdG9yeSBhbHdheXMgZXhpc3RzKS4KKwkgKi8KKwlpZiAoZW5kX29mX29sZCA9PSBOVUxMKQorCQlyZXR1cm47IC8qIE5vdGU6ICpvbGRfZGlyIGFuZCAqbmV3X2RpciBhcmUgc3RpbGwgTlVMTCAqLworCisJLyoKKwkgKiBJZiBuZXdfcGF0aCBjb250YWlucyBubyBkaXJlY3RvcnkgKGVuZF9vZl9uZXcgaXMgTlVMTCksIHRoZW4gd2UKKwkgKiBoYXZlIGEgcmVuYW1lIG9mIG9sZF9wYXRoJ3MgZGlyZWN0b3J5IHRvIHRoZSByb290IGRpcmVjdG9yeS4KKwkgKi8KKwlpZiAoZW5kX29mX25ldyA9PSBOVUxMKSB7CisJCSpvbGRfZGlyID0geHN0cm5kdXAob2xkX3BhdGgsIGVuZF9vZl9vbGQgLSBvbGRfcGF0aCk7CisJCSpuZXdfZGlyID0geHN0cmR1cCgiIik7CiAJCXJldHVybjsKKwl9CisKKwkvKiBGaW5kIHRoZSBmaXJzdCBub24tbWF0Y2hpbmcgY2hhcmFjdGVyIHRyYXZlcnNpbmcgYmFja3dhcmRzICovCiAJd2hpbGUgKCotLWVuZF9vZl9uZXcgPT0gKi0tZW5kX29mX29sZCAmJgogCSAgICAgICBlbmRfb2Zfb2xkICE9IG9sZF9wYXRoICYmCiAJICAgICAgIGVuZF9vZl9uZXcgIT0gbmV3X3BhdGgpCiAJCTsgLyogRG8gbm90aGluZzsgYWxsIGluIHRoZSB3aGlsZSBsb29wICovCisKKwkvKgorCSAqIElmIGJvdGggZ290IGJhY2sgdG8gdGhlIGJlZ2lubmluZyBvZiB0aGVpciBzdHJpbmdzLCB0aGVuIHRoZQorCSAqIGRpcmVjdG9yeSBkaWRuJ3QgY2hhbmdlIGF0IGFsbCwgb25seSB0aGUgYmFzZW5hbWUgZGlkLgorCSAqLworCWlmIChlbmRfb2Zfb2xkID09IG9sZF9wYXRoICYmIGVuZF9vZl9uZXcgPT0gbmV3X3BhdGggJiYKKwkgICAgKmVuZF9vZl9vbGQgPT0gKmVuZF9vZl9uZXcpCisJCXJldHVybjsgLyogTm90ZTogKm9sZF9kaXIgYW5kICpuZXdfZGlyIGFyZSBzdGlsbCBOVUxMICovCisKKwkvKgorCSAqIElmIGVuZF9vZl9uZXcgZ290IGJhY2sgdG8gdGhlIGJlZ2lubmluZyBvZiBpdHMgc3RyaW5nLCBhbmQKKwkgKiBlbmRfb2Zfb2xkIGdvdCBiYWNrIHRvIHRoZSBiZWdpbm5pbmcgb2Ygc29tZSBzdWJkaXJlY3RvcnksIHRoZW4KKwkgKiB3ZSBoYXZlIGEgcmVuYW1lL21lcmdlIG9mIGEgc3ViZGlyZWN0b3J5IGludG8gdGhlIHJvb3QsIHdoaWNoCisJICogbmVlZHMgc2xpZ2h0bHkgc3BlY2lhbCBoYW5kbGluZy4KKwkgKgorCSAqIE5vdGU6IFRoZXJlIGlzIG5vIG5lZWQgdG8gY29uc2lkZXIgdGhlIG9wcG9zaXRlIGNhc2UsIHdpdGggYQorCSAqIHJlbmFtZS9tZXJnZSBvZiB0aGUgcm9vdCBkaXJlY3RvcnkgaW50byBzb21lIHN1YmRpcmVjdG9yeQorCSAqIGJlY2F1c2UgYXMgbm90ZWQgYWJvdmUgdGhlIHJvb3QgZGlyZWN0b3J5IGFsd2F5cyBleGlzdHMgc28gaXQKKwkgKiBjYW5ub3QgYmUgY29uc2lkZXJlZCB0byBiZSByZW5hbWVkLgorCSAqLworCWlmIChlbmRfb2ZfbmV3ID09IG5ld19wYXRoICYmCisJICAgIGVuZF9vZl9vbGQgIT0gb2xkX3BhdGggJiYgZW5kX29mX29sZFstMV0gPT0gJy8nKSB7CisJCSpvbGRfZGlyID0geHN0cm5kdXAob2xkX3BhdGgsIC0tZW5kX29mX29sZCAtIG9sZF9wYXRoKTsKKwkJKm5ld19kaXIgPSB4c3RyZHVwKCIiKTsKKwkJcmV0dXJuOworCX0KKwogCS8qCiAJICogV2UndmUgZm91bmQgdGhlIGZpcnN0IG5vbi1tYXRjaGluZyBjaGFyYWN0ZXIgaW4gdGhlIGRpcmVjdG9yeQotCSAqIHBhdGhzLiAgVGhhdCBtZWFucyB0aGUgY3VycmVudCBkaXJlY3Rvcnkgd2Ugd2VyZSBjb21wYXJpbmcKLQkgKiByZXByZXNlbnRzIHRoZSByZW5hbWUuICBNb3ZlIGVuZF9vZl9vbGQgYW5kIGVuZF9vZl9uZXcgYmFjawotCSAqIHRvIHRoZSBmdWxsIGRpcmVjdG9yeSBuYW1lLgorCSAqIHBhdGhzLiAgVGhhdCBtZWFucyB0aGUgY3VycmVudCBjaGFyYWN0ZXJzIHdlIHdlcmUgbG9va2luZyBhdAorCSAqIHdlcmUgcGFydCBvZiB0aGUgZmlyc3Qgbm9uLW1hdGNoaW5nIHN1YmRpciBuYW1lIGdvaW5nIGJhY2sgZnJvbQorCSAqIHRoZSBlbmQgb2YgdGhlIHN0cmluZ3MuICBHZXQgdGhlIHdob2xlIG5hbWUgYnkgYWR2YW5jaW5nIGJvdGgKKwkgKiBlbmRfb2Zfb2xkIGFuZCBlbmRfb2ZfbmV3IHRvIHRoZSBORVhUICcvJyBjaGFyYWN0ZXIuICBUaGF0IHdpbGwKKwkgKiByZXByZXNlbnQgdGhlIGVudGlyZSBkaXJlY3RvcnkgcmVuYW1lLgorCSAqCisJICogVGhlIHJlYXNvbiBmb3IgdGhlIGluY3JlbWVudCBpcyBjYXNlcyBsaWtlCisJICogICAgYS9iL3N0YXIvZm9vL3doYXRldmVyLmMgLT4gYS9iL3Rhci9mb28vcmFuZG9tLmMKKwkgKiBBZnRlciBkcm9wcGluZyB0aGUgYmFzZW5hbWUgYW5kIGdvaW5nIGJhY2sgdG8gdGhlIGZpcnN0CisJICogbm9uLW1hdGNoaW5nIGNoYXJhY3Rlciwgd2UncmUgbm93IGNvbXBhcmluZzoKKwkgKiAgICBhL2IvcyAgICAgICAgICBhbmQgICAgICAgICBhL2IvCisJICogYW5kIHdlIHdhbnQgdG8gYmUgY29tcGFyaW5nOgorCSAqICAgIGEvYi9zdGFyLyAgICAgIGFuZCAgICAgICAgIGEvYi90YXIvCisJICogYnV0IHdpdGhvdXQgdGhlIHByZS1pbmNyZW1lbnQsIHRoZSBvbmUgb24gdGhlIHJpZ2h0IHdvdWxkIHN0YXkKKwkgKiBhL2IvLgogCSAqLwotCWlmICgqZW5kX29mX29sZCA9PSAnLycpCi0JCWVuZF9vZl9vbGQrKzsKLQlpZiAoKmVuZF9vZl9vbGQgIT0gJy8nKQotCQllbmRfb2ZfbmV3Kys7Ci0JZW5kX29mX29sZCA9IHN0cmNocihlbmRfb2Zfb2xkLCAnLycpOwotCWVuZF9vZl9uZXcgPSBzdHJjaHIoZW5kX29mX25ldywgJy8nKTsKKwllbmRfb2Zfb2xkID0gc3RyY2hyKCsrZW5kX29mX29sZCwgJy8nKTsKKwllbmRfb2ZfbmV3ID0gc3RyY2hyKCsrZW5kX29mX25ldywgJy8nKTsKIAotCS8qCi0JICogSXQgbWF5IGhhdmUgYmVlbiB0aGUgY2FzZSB0aGF0IG9sZF9wYXRoIGFuZCBuZXdfcGF0aCB3ZXJlIHRoZSBzYW1lCi0JICogZGlyZWN0b3J5IGFsbCBhbG9uZy4gIERvbid0IGNsYWltIGEgcmVuYW1lIGlmIHRoZXkncmUgdGhlIHNhbWUuCi0JICovCi0Jb2xkX2xlbiA9IGVuZF9vZl9vbGQgLSBvbGRfcGF0aDsKLQluZXdfbGVuID0gZW5kX29mX25ldyAtIG5ld19wYXRoOwotCi0JaWYgKG9sZF9sZW4gIT0gbmV3X2xlbiB8fCBzdHJuY21wKG9sZF9wYXRoLCBuZXdfcGF0aCwgb2xkX2xlbikpIHsKLQkJKm9sZF9kaXIgPSB4c3RybmR1cChvbGRfcGF0aCwgb2xkX2xlbik7Ci0JCSpuZXdfZGlyID0geHN0cm5kdXAobmV3X3BhdGgsIG5ld19sZW4pOwotCX0KKwkvKiBDb3B5IHRoZSBvbGQgYW5kIG5ldyBkaXJlY3RvcmllcyBpbnRvICpvbGRfZGlyIGFuZCAqbmV3X2Rpci4gKi8KKwkqb2xkX2RpciA9IHhzdHJuZHVwKG9sZF9wYXRoLCBlbmRfb2Zfb2xkIC0gb2xkX3BhdGgpOworCSpuZXdfZGlyID0geHN0cm5kdXAobmV3X3BhdGgsIGVuZF9vZl9uZXcgLSBuZXdfcGF0aCk7CiB9CiAKIHN0YXRpYyB2b2lkIHJlbW92ZV9oYXNobWFwX2VudHJpZXMoc3RydWN0IGhhc2htYXAgKmRpcl9yZW5hbWVzLApAQCAtMjAwMSw3ICsyMDgwLDcgQEAKIAogCWZvciAoaSA9IDA7IGkgPCBpdGVtc190b19yZW1vdmUtPm5yOyBpKyspIHsKIAkJZW50cnkgPSBpdGVtc190b19yZW1vdmUtPml0ZW1zW2ldLnV0aWw7Ci0JCWhhc2htYXBfcmVtb3ZlKGRpcl9yZW5hbWVzLCBlbnRyeSwgTlVMTCk7CisJCWhhc2htYXBfcmVtb3ZlKGRpcl9yZW5hbWVzLCAmZW50cnktPmVudCwgTlVMTCk7CiAJfQogCXN0cmluZ19saXN0X2NsZWFyKGl0ZW1zX3RvX3JlbW92ZSwgMCk7CiB9CkBAIC0yMTI0LDggKzIyMDMsOCBAQAogCXN0cnVjdCBzdHJpbmdfbGlzdCByZW1vdmVfZnJvbV9oZWFkID0gU1RSSU5HX0xJU1RfSU5JVF9OT0RVUDsKIAlzdHJ1Y3Qgc3RyaW5nX2xpc3QgcmVtb3ZlX2Zyb21fbWVyZ2UgPSBTVFJJTkdfTElTVF9JTklUX05PRFVQOwogCi0JaGFzaG1hcF9pdGVyX2luaXQoZGlyX3JlX2hlYWQsICZpdGVyKTsKLQl3aGlsZSAoKGhlYWRfZW50ID0gaGFzaG1hcF9pdGVyX25leHQoJml0ZXIpKSkgeworCWhhc2htYXBfZm9yX2VhY2hfZW50cnkoZGlyX3JlX2hlYWQsICZpdGVyLCBoZWFkX2VudCwKKwkJCQllbnQgLyogbWVtYmVyIG5hbWUgKi8pIHsKIAkJbWVyZ2VfZW50ID0gZGlyX3JlbmFtZV9maW5kX2VudHJ5KGRpcl9yZV9tZXJnZSwgaGVhZF9lbnQtPmRpcik7CiAJCWlmIChtZXJnZV9lbnQgJiYKIAkJICAgICFoZWFkX2VudC0+bm9uX3VuaXF1ZV9uZXdfZGlyICYmCkBAIC0yMTQ5LDggKzIyMjgsOCBAQAogCXJlbW92ZV9oYXNobWFwX2VudHJpZXMoZGlyX3JlX2hlYWQsICZyZW1vdmVfZnJvbV9oZWFkKTsKIAlyZW1vdmVfaGFzaG1hcF9lbnRyaWVzKGRpcl9yZV9tZXJnZSwgJnJlbW92ZV9mcm9tX21lcmdlKTsKIAotCWhhc2htYXBfaXRlcl9pbml0KGRpcl9yZV9tZXJnZSwgJml0ZXIpOwotCXdoaWxlICgobWVyZ2VfZW50ID0gaGFzaG1hcF9pdGVyX25leHQoJml0ZXIpKSkgeworCWhhc2htYXBfZm9yX2VhY2hfZW50cnkoZGlyX3JlX21lcmdlLCAmaXRlciwgbWVyZ2VfZW50LAorCQkJCWVudCAvKiBtZW1iZXIgbmFtZSAqLykgewogCQloZWFkX2VudCA9IGRpcl9yZW5hbWVfZmluZF9lbnRyeShkaXJfcmVfaGVhZCwgbWVyZ2VfZW50LT5kaXIpOwogCQlpZiAodHJlZV9oYXNfcGF0aChvcHQtPnJlcG8sIG1lcmdlLCBtZXJnZV9lbnQtPmRpcikpIHsKIAkJCS8qIDIuIFRoaXMgd2Fzbid0IGEgZGlyZWN0b3J5IHJlbmFtZSBhZnRlciBhbGwgKi8KQEAgLTIyMjksNyArMjMwOCw3IEBACiAJCWlmICghZW50cnkpIHsKIAkJCWVudHJ5ID0geG1hbGxvYyhzaXplb2YoKmVudHJ5KSk7CiAJCQlkaXJfcmVuYW1lX2VudHJ5X2luaXQoZW50cnksIG9sZF9kaXIpOwotCQkJaGFzaG1hcF9wdXQoZGlyX3JlbmFtZXMsIGVudHJ5KTsKKwkJCWhhc2htYXBfcHV0KGRpcl9yZW5hbWVzLCAmZW50cnktPmVudCk7CiAJCX0gZWxzZSB7CiAJCQlmcmVlKG9sZF9kaXIpOwogCQl9CkBAIC0yMjU0LDggKzIzMzMsOCBAQAogCSAqIHdlIHNldCBub25fdW5pcXVlX25ld19kaXIuICBPbmNlIHdlJ3ZlIGRldGVybWluZWQgdGhlIHdpbm5lciAob3IKIAkgKiB0aGF0IHRoZXJlIGlzIG5vIHdpbm5lciksIHdlIG5vIGxvbmdlciBuZWVkIHBvc3NpYmxlX25ld19kaXJzLgogCSAqLwotCWhhc2htYXBfaXRlcl9pbml0KGRpcl9yZW5hbWVzLCAmaXRlcik7Ci0Jd2hpbGUgKChlbnRyeSA9IGhhc2htYXBfaXRlcl9uZXh0KCZpdGVyKSkpIHsKKwloYXNobWFwX2Zvcl9lYWNoX2VudHJ5KGRpcl9yZW5hbWVzLCAmaXRlciwgZW50cnksCisJCQkJZW50IC8qIG1lbWJlciBuYW1lICovKSB7CiAJCWludCBtYXggPSAwOwogCQlpbnQgYmFkX21heCA9IDA7CiAJCWNoYXIgKmJlc3QgPSBOVUxMOwpAQCAtMjM1OCw4ICsyNDM3LDkgQEAKIAkJaWYgKCFjb2xsaXNpb25fZW50KSB7CiAJCQljb2xsaXNpb25fZW50ID0geGNhbGxvYygxLAogCQkJCQkJc2l6ZW9mKHN0cnVjdCBjb2xsaXNpb25fZW50cnkpKTsKLQkJCWhhc2htYXBfZW50cnlfaW5pdChjb2xsaXNpb25fZW50LCBzdHJoYXNoKG5ld19wYXRoKSk7Ci0JCQloYXNobWFwX3B1dChjb2xsaXNpb25zLCBjb2xsaXNpb25fZW50KTsKKwkJCWhhc2htYXBfZW50cnlfaW5pdCgmY29sbGlzaW9uX2VudC0+ZW50LAorCQkJCQkJc3RyaGFzaChuZXdfcGF0aCkpOworCQkJaGFzaG1hcF9wdXQoY29sbGlzaW9ucywgJmNvbGxpc2lvbl9lbnQtPmVudCk7CiAJCQljb2xsaXNpb25fZW50LT50YXJnZXRfZmlsZSA9IG5ld19wYXRoOwogCQl9IGVsc2UgewogCQkJZnJlZShuZXdfcGF0aCk7CkBAIC0yNjEyLDEyICsyNjkyLDEyIEBACiAJCQkJCQkJICAgICBlbnRyaWVzKTsKIAl9CiAKLQloYXNobWFwX2l0ZXJfaW5pdCgmY29sbGlzaW9ucywgJml0ZXIpOwotCXdoaWxlICgoZSA9IGhhc2htYXBfaXRlcl9uZXh0KCZpdGVyKSkpIHsKKwloYXNobWFwX2Zvcl9lYWNoX2VudHJ5KCZjb2xsaXNpb25zLCAmaXRlciwgZSwKKwkJCQllbnQgLyogbWVtYmVyIG5hbWUgKi8pIHsKIAkJZnJlZShlLT50YXJnZXRfZmlsZSk7CiAJCXN0cmluZ19saXN0X2NsZWFyKCZlLT5zb3VyY2VfZmlsZXMsIDApOwogCX0KLQloYXNobWFwX2ZyZWUoJmNvbGxpc2lvbnMsIDEpOworCWhhc2htYXBfZnJlZV9lbnRyaWVzKCZjb2xsaXNpb25zLCBzdHJ1Y3QgY29sbGlzaW9uX2VudHJ5LCBlbnQpOwogCXJldHVybiByZW5hbWVzOwogfQogCkBAIC0yODMwLDEzICsyOTEwLDEzIEBACiAJc3RydWN0IGhhc2htYXBfaXRlciBpdGVyOwogCXN0cnVjdCBkaXJfcmVuYW1lX2VudHJ5ICplOwogCi0JaGFzaG1hcF9pdGVyX2luaXQoZGlyX3JlbmFtZXMsICZpdGVyKTsKLQl3aGlsZSAoKGUgPSBoYXNobWFwX2l0ZXJfbmV4dCgmaXRlcikpKSB7CisJaGFzaG1hcF9mb3JfZWFjaF9lbnRyeShkaXJfcmVuYW1lcywgJml0ZXIsIGUsCisJCQkJZW50IC8qIG1lbWJlciBuYW1lICovKSB7CiAJCWZyZWUoZS0+ZGlyKTsKIAkJc3RyYnVmX3JlbGVhc2UoJmUtPm5ld19kaXIpOwogCQkvKiBwb3NzaWJsZV9uZXdfZGlycyBhbHJlYWR5IGNsZWFyZWQgaW4gZ2V0X2RpcmVjdG9yeV9yZW5hbWVzICovCiAJfQotCWhhc2htYXBfZnJlZShkaXJfcmVuYW1lcywgMSk7CisJaGFzaG1hcF9mcmVlX2VudHJpZXMoZGlyX3JlbmFtZXMsIHN0cnVjdCBkaXJfcmVuYW1lX2VudHJ5LCBlbnQpOwogCWZyZWUoZGlyX3JlbmFtZXMpOwogCiAJZnJlZShwYWlycy0+cXVldWUpOwpAQCAtMjg2Myw4ICsyOTQzLDkgQEAKIAloZWFkX3BhaXJzID0gZ2V0X2RpZmZwYWlycyhvcHQsIGNvbW1vbiwgaGVhZCk7CiAJbWVyZ2VfcGFpcnMgPSBnZXRfZGlmZnBhaXJzKG9wdCwgY29tbW9uLCBtZXJnZSk7CiAKLQlpZiAoKG9wdC0+ZGV0ZWN0X2RpcmVjdG9yeV9yZW5hbWVzID09IDIpIHx8Ci0JICAgIChvcHQtPmRldGVjdF9kaXJlY3RvcnlfcmVuYW1lcyA9PSAxICYmICFvcHQtPmNhbGxfZGVwdGgpKSB7CisJaWYgKChvcHQtPmRldGVjdF9kaXJlY3RvcnlfcmVuYW1lcyA9PSBNRVJHRV9ESVJFQ1RPUllfUkVOQU1FU19UUlVFKSB8fAorCSAgICAob3B0LT5kZXRlY3RfZGlyZWN0b3J5X3JlbmFtZXMgPT0gTUVSR0VfRElSRUNUT1JZX1JFTkFNRVNfQ09ORkxJQ1QgJiYKKwkgICAgICFvcHQtPnByaXYtPmNhbGxfZGVwdGgpKSB7CiAJCWRpcl9yZV9oZWFkID0gZ2V0X2RpcmVjdG9yeV9yZW5hbWVzKGhlYWRfcGFpcnMpOwogCQlkaXJfcmVfbWVyZ2UgPSBnZXRfZGlyZWN0b3J5X3JlbmFtZXMobWVyZ2VfcGFpcnMpOwogCkBAIC0zMDIxLDEzICszMTAyLDEzIEBACiAJCXJlYXNvbiA9IF8oImFkZC9hZGQiKTsKIAogCWFzc2VydChvLT5wYXRoICYmIGEtPnBhdGggJiYgYi0+cGF0aCk7Ci0JaWYgKGNpICYmIGRpcl9pbl93YXkob3B0LT5yZXBvLT5pbmRleCwgcGF0aCwgIW9wdC0+Y2FsbF9kZXB0aCwKKwlpZiAoY2kgJiYgZGlyX2luX3dheShvcHQtPnJlcG8tPmluZGV4LCBwYXRoLCAhb3B0LT5wcml2LT5jYWxsX2RlcHRoLAogCQkJICAgICBTX0lTR0lUTElOSyhjaS0+cmVuMS0+cGFpci0+dHdvLT5tb2RlKSkpCiAJCWRmX2NvbmZsaWN0X3JlbWFpbnMgPSAxOwogCiAJaWYgKG1lcmdlX21vZGVfYW5kX2NvbnRlbnRzKG9wdCwgbywgYSwgYiwgcGF0aCwKIAkJCQkgICAgb3B0LT5icmFuY2gxLCBvcHQtPmJyYW5jaDIsCi0JCQkJICAgIG9wdC0+Y2FsbF9kZXB0aCAqIDIsIG1maSkpCisJCQkJICAgIG9wdC0+cHJpdi0+Y2FsbF9kZXB0aCAqIDIsIG1maSkpCiAJCXJldHVybiAtMTsKIAogCS8qCkBAIC0zMDQzLDcgKzMxMjQsNyBAQAogCiAJCW91dHB1dChvcHQsIDMsIF8oIlNraXBwZWQgJXMgKG1lcmdlZCBzYW1lIGFzIGV4aXN0aW5nKSIpLCBwYXRoKTsKIAkJaWYgKGFkZF9jYWNoZWluZm8ob3B0LCAmbWZpLT5ibG9iLCBwYXRoLAotCQkJCSAgMCwgKCFvcHQtPmNhbGxfZGVwdGggJiYgIWlzX2RpcnR5KSwgMCkpCisJCQkJICAwLCAoIW9wdC0+cHJpdi0+Y2FsbF9kZXB0aCAmJiAhaXNfZGlydHkpLCAwKSkKIAkJCXJldHVybiAtMTsKIAkJLyoKIAkJICogSG93ZXZlciwgYWRkX2NhY2hlaW5mbygpIHdpbGwgZGVsZXRlIHRoZSBvbGQgY2FjaGUgZW50cnkKQEAgLTMwNTEsOCArMzEzMiw4IEBACiAJCSAqIGZsYWcgdG8gYXZvaWQgbWFraW5nIHRoZSBmaWxlIGFwcGVhciBhcyBpZiBpdCB3ZXJlCiAJCSAqIGRlbGV0ZWQgYnkgdGhlIHVzZXIuCiAJCSAqLwotCQlwb3MgPSBpbmRleF9uYW1lX3Bvcygmb3B0LT5vcmlnX2luZGV4LCBwYXRoLCBzdHJsZW4ocGF0aCkpOwotCQljZSA9IG9wdC0+b3JpZ19pbmRleC5jYWNoZVtwb3NdOworCQlwb3MgPSBpbmRleF9uYW1lX3Bvcygmb3B0LT5wcml2LT5vcmlnX2luZGV4LCBwYXRoLCBzdHJsZW4ocGF0aCkpOworCQljZSA9IG9wdC0+cHJpdi0+b3JpZ19pbmRleC5jYWNoZVtwb3NdOwogCQlpZiAoY2Vfc2tpcF93b3JrdHJlZShjZSkpIHsKIAkJCXBvcyA9IGluZGV4X25hbWVfcG9zKG9wdC0+cmVwby0+aW5kZXgsIHBhdGgsIHN0cmxlbihwYXRoKSk7CiAJCQljZSA9IG9wdC0+cmVwby0+aW5kZXgtPmNhY2hlW3Bvc107CkBAIC0zMDczLDcgKzMxNTQsNyBAQAogCiAJaWYgKGRmX2NvbmZsaWN0X3JlbWFpbnMgfHwgaXNfZGlydHkpIHsKIAkJY2hhciAqbmV3X3BhdGg7Ci0JCWlmIChvcHQtPmNhbGxfZGVwdGgpIHsKKwkJaWYgKG9wdC0+cHJpdi0+Y2FsbF9kZXB0aCkgewogCQkJcmVtb3ZlX2ZpbGVfZnJvbV9pbmRleChvcHQtPnJlcG8tPmluZGV4LCBwYXRoKTsKIAkJfSBlbHNlIHsKIAkJCWlmICghbWZpLT5jbGVhbikgewpAQCAtMzEyMiw3ICszMjAzLDggQEAKIAljbGVhbiA9IGhhbmRsZV9jb250ZW50X21lcmdlKCZtZmksIG9wdCwgcGF0aCwgd2FzX2RpcnR5KG9wdCwgcGF0aCksCiAJCQkJICAgICBvLCBhLCBiLCBjaSk7CiAKLQlpZiAoY2xlYW4gJiYgb3B0LT5kZXRlY3RfZGlyZWN0b3J5X3JlbmFtZXMgPT0gMSAmJgorCWlmIChjbGVhbiAmJgorCSAgICBvcHQtPmRldGVjdF9kaXJlY3RvcnlfcmVuYW1lcyA9PSBNRVJHRV9ESVJFQ1RPUllfUkVOQU1FU19DT05GTElDVCAmJgogCSAgICByZW4tPmRpcl9yZW5hbWVfb3JpZ2luYWxfZGVzdCkgewogCQlpZiAodXBkYXRlX3N0YWdlcyhvcHQsIHBhdGgsCiAJCQkJICBOVUxMLApAQCAtMzE2NywxMiArMzI0OSwxMiBAQAogCQlyZXR1cm4gY2xlYW47CiAKIAkvKiBTYW5pdHkgY2hlY2tzICovCi0JYXNzZXJ0KG9wdC0+ZGV0ZWN0X2RpcmVjdG9yeV9yZW5hbWVzID4gMCk7CisJYXNzZXJ0KG9wdC0+ZGV0ZWN0X2RpcmVjdG9yeV9yZW5hbWVzID4gTUVSR0VfRElSRUNUT1JZX1JFTkFNRVNfTk9ORSk7CiAJYXNzZXJ0KHJlbi0+ZGlyX3JlbmFtZV9vcmlnaW5hbF90eXBlID09ICdBJyB8fAogCSAgICAgICByZW4tPmRpcl9yZW5hbWVfb3JpZ2luYWxfdHlwZSA9PSAnUicpOwogCiAJLyogQ2hlY2sgd2hldGhlciB0byB0cmVhdCBkaXJlY3RvcnkgcmVuYW1lcyBhcyBhIGNvbmZsaWN0ICovCi0JY2xlYW4gPSAob3B0LT5kZXRlY3RfZGlyZWN0b3J5X3JlbmFtZXMgPT0gMik7CisJY2xlYW4gPSAob3B0LT5kZXRlY3RfZGlyZWN0b3J5X3JlbmFtZXMgPT0gTUVSR0VfRElSRUNUT1JZX1JFTkFNRVNfVFJVRSk7CiAKIAlpc19hZGQgPSAocmVuLT5kaXJfcmVuYW1lX29yaWdpbmFsX3R5cGUgPT0gJ0EnKTsKIAlpZiAocmVuLT5kaXJfcmVuYW1lX29yaWdpbmFsX3R5cGUgPT0gJ0EnICYmIGNsZWFuKSB7CkBAIC0zMzMxLDcgKzM0MTMsNyBAQAogCQkJY29uZiA9IF8oImRpcmVjdG9yeS9maWxlIik7CiAJCX0KIAkJaWYgKGRpcl9pbl93YXkob3B0LT5yZXBvLT5pbmRleCwgcGF0aCwKLQkJCSAgICAgICAhb3B0LT5jYWxsX2RlcHRoICYmICFTX0lTR0lUTElOSyhhLT5tb2RlKSwKKwkJCSAgICAgICAhb3B0LT5wcml2LT5jYWxsX2RlcHRoICYmICFTX0lTR0lUTElOSyhhLT5tb2RlKSwKIAkJCSAgICAgICAwKSkgewogCQkJY2hhciAqbmV3X3BhdGggPSB1bmlxdWVfcGF0aChvcHQsIHBhdGgsIGFkZF9icmFuY2gpOwogCQkJY2xlYW5fbWVyZ2UgPSAwOwpAQCAtMzM0MCw3ICszNDIyLDcgQEAKIAkJCSAgICAgICBjb25mLCBwYXRoLCBvdGhlcl9icmFuY2gsIHBhdGgsIG5ld19wYXRoKTsKIAkJCWlmICh1cGRhdGVfZmlsZShvcHQsIDAsIGNvbnRlbnRzLCBuZXdfcGF0aCkpCiAJCQkJY2xlYW5fbWVyZ2UgPSAtMTsKLQkJCWVsc2UgaWYgKG9wdC0+Y2FsbF9kZXB0aCkKKwkJCWVsc2UgaWYgKG9wdC0+cHJpdi0+Y2FsbF9kZXB0aCkKIAkJCQlyZW1vdmVfZmlsZV9mcm9tX2luZGV4KG9wdC0+cmVwby0+aW5kZXgsIHBhdGgpOwogCQkJZnJlZShuZXdfcGF0aCk7CiAJCX0gZWxzZSB7CkBAIC0zMzgwLDM3ICszNDYyLDMyIEBACiAJcmV0dXJuIGNsZWFuX21lcmdlOwogfQogCi1pbnQgbWVyZ2VfdHJlZXMoc3RydWN0IG1lcmdlX29wdGlvbnMgKm9wdCwKLQkJc3RydWN0IHRyZWUgKmhlYWQsCi0JCXN0cnVjdCB0cmVlICptZXJnZSwKLQkJc3RydWN0IHRyZWUgKmNvbW1vbiwKLQkJc3RydWN0IHRyZWUgKipyZXN1bHQpCitzdGF0aWMgaW50IG1lcmdlX3RyZWVzX2ludGVybmFsKHN0cnVjdCBtZXJnZV9vcHRpb25zICpvcHQsCisJCQkJc3RydWN0IHRyZWUgKmhlYWQsCisJCQkJc3RydWN0IHRyZWUgKm1lcmdlLAorCQkJCXN0cnVjdCB0cmVlICptZXJnZV9iYXNlLAorCQkJCXN0cnVjdCB0cmVlICoqcmVzdWx0KQogewogCXN0cnVjdCBpbmRleF9zdGF0ZSAqaXN0YXRlID0gb3B0LT5yZXBvLT5pbmRleDsKIAlpbnQgY29kZSwgY2xlYW47Ci0Jc3RydWN0IHN0cmJ1ZiBzYiA9IFNUUkJVRl9JTklUOwotCi0JaWYgKCFvcHQtPmNhbGxfZGVwdGggJiYgcmVwb19pbmRleF9oYXNfY2hhbmdlcyhvcHQtPnJlcG8sIGhlYWQsICZzYikpIHsKLQkJZXJyKG9wdCwgXygiWW91ciBsb2NhbCBjaGFuZ2VzIHRvIHRoZSBmb2xsb3dpbmcgZmlsZXMgd291bGQgYmUgb3ZlcndyaXR0ZW4gYnkgbWVyZ2U6XG4gICVzIiksCi0JCSAgICBzYi5idWYpOwotCQlyZXR1cm4gLTE7Ci0JfQogCiAJaWYgKG9wdC0+c3VidHJlZV9zaGlmdCkgewotCQltZXJnZSA9IHNoaWZ0X3RyZWVfb2JqZWN0KG9wdC0+cmVwbywgaGVhZCwgbWVyZ2UsIG9wdC0+c3VidHJlZV9zaGlmdCk7Ci0JCWNvbW1vbiA9IHNoaWZ0X3RyZWVfb2JqZWN0KG9wdC0+cmVwbywgaGVhZCwgY29tbW9uLCBvcHQtPnN1YnRyZWVfc2hpZnQpOworCQltZXJnZSA9IHNoaWZ0X3RyZWVfb2JqZWN0KG9wdC0+cmVwbywgaGVhZCwgbWVyZ2UsCisJCQkJCSAgb3B0LT5zdWJ0cmVlX3NoaWZ0KTsKKwkJbWVyZ2VfYmFzZSA9IHNoaWZ0X3RyZWVfb2JqZWN0KG9wdC0+cmVwbywgaGVhZCwgbWVyZ2VfYmFzZSwKKwkJCQkJICAgICAgIG9wdC0+c3VidHJlZV9zaGlmdCk7CiAJfQogCi0JaWYgKG9pZF9lcSgmY29tbW9uLT5vYmplY3Qub2lkLCAmbWVyZ2UtPm9iamVjdC5vaWQpKSB7CisJaWYgKG9pZF9lcSgmbWVyZ2VfYmFzZS0+b2JqZWN0Lm9pZCwgJm1lcmdlLT5vYmplY3Qub2lkKSkgewogCQlvdXRwdXQob3B0LCAwLCBfKCJBbHJlYWR5IHVwIHRvIGRhdGUhIikpOwogCQkqcmVzdWx0ID0gaGVhZDsKIAkJcmV0dXJuIDE7CiAJfQogCi0JY29kZSA9IHVucGFja190cmVlc19zdGFydChvcHQsIGNvbW1vbiwgaGVhZCwgbWVyZ2UpOworCWNvZGUgPSB1bnBhY2tfdHJlZXNfc3RhcnQob3B0LCBtZXJnZV9iYXNlLCBoZWFkLCBtZXJnZSk7CiAKIAlpZiAoY29kZSAhPSAwKSB7Ci0JCWlmIChzaG93KG9wdCwgNCkgfHwgb3B0LT5jYWxsX2RlcHRoKQorCQlpZiAoc2hvdyhvcHQsIDQpIHx8IG9wdC0+cHJpdi0+Y2FsbF9kZXB0aCkKIAkJCWVycihvcHQsIF8oIm1lcmdpbmcgb2YgdHJlZXMgJXMgYW5kICVzIGZhaWxlZCIpLAogCQkJICAgIG9pZF90b19oZXgoJmhlYWQtPm9iamVjdC5vaWQpLAogCQkJICAgIG9pZF90b19oZXgoJm1lcmdlLT5vYmplY3Qub2lkKSk7CkBAIC0zNDI5LDEyICszNTA2LDEzIEBACiAJCSAqIG9wcG9zZWQgdG8gZGVjYXJpbmcgYSBsb2NhbCBoYXNobWFwIGlzIGZvciBjb252ZW5pZW5jZQogCQkgKiBzbyB0aGF0IHdlIGRvbid0IGhhdmUgdG8gcGFzcyBpdCB0byBhcm91bmQuCiAJCSAqLwotCQloYXNobWFwX2luaXQoJm9wdC0+Y3VycmVudF9maWxlX2Rpcl9zZXQsIHBhdGhfaGFzaG1hcF9jbXAsIE5VTEwsIDUxMik7CisJCWhhc2htYXBfaW5pdCgmb3B0LT5wcml2LT5jdXJyZW50X2ZpbGVfZGlyX3NldCwgcGF0aF9oYXNobWFwX2NtcCwKKwkJCSAgICAgTlVMTCwgNTEyKTsKIAkJZ2V0X2ZpbGVzX2RpcnMob3B0LCBoZWFkKTsKIAkJZ2V0X2ZpbGVzX2RpcnMob3B0LCBtZXJnZSk7CiAKIAkJZW50cmllcyA9IGdldF91bm1lcmdlZChvcHQtPnJlcG8tPmluZGV4KTsKLQkJY2xlYW4gPSBkZXRlY3RfYW5kX3Byb2Nlc3NfcmVuYW1lcyhvcHQsIGNvbW1vbiwgaGVhZCwgbWVyZ2UsCisJCWNsZWFuID0gZGV0ZWN0X2FuZF9wcm9jZXNzX3JlbmFtZXMob3B0LCBtZXJnZV9iYXNlLCBoZWFkLCBtZXJnZSwKIAkJCQkJCSAgIGVudHJpZXMsICZyZV9pbmZvKTsKIAkJcmVjb3JkX2RmX2NvbmZsaWN0X2ZpbGVzKG9wdCwgZW50cmllcyk7CiAJCWlmIChjbGVhbiA8IDApCkBAIC0zNDY1LDcgKzM1NDMsOCBAQAogCQlzdHJpbmdfbGlzdF9jbGVhcihlbnRyaWVzLCAxKTsKIAkJZnJlZShlbnRyaWVzKTsKIAotCQloYXNobWFwX2ZyZWUoJm9wdC0+Y3VycmVudF9maWxlX2Rpcl9zZXQsIDEpOworCQloYXNobWFwX2ZyZWVfZW50cmllcygmb3B0LT5wcml2LT5jdXJyZW50X2ZpbGVfZGlyX3NldCwKKwkJCQkJc3RydWN0IHBhdGhfaGFzaG1hcF9lbnRyeSwgZSk7CiAKIAkJaWYgKGNsZWFuIDwgMCkgewogCQkJdW5wYWNrX3RyZWVzX2ZpbmlzaChvcHQpOwpAQCAtMzQ3Nyw3ICszNTU2LDggQEAKIAogCXVucGFja190cmVlc19maW5pc2gob3B0KTsKIAotCWlmIChvcHQtPmNhbGxfZGVwdGggJiYgISgqcmVzdWx0ID0gd3JpdGVfdHJlZV9mcm9tX21lbW9yeShvcHQpKSkKKwlpZiAob3B0LT5wcml2LT5jYWxsX2RlcHRoICYmCisJICAgICEoKnJlc3VsdCA9IHdyaXRlX2luX2NvcmVfaW5kZXhfYXNfdHJlZShvcHQtPnJlcG8pKSkKIAkJcmV0dXJuIC0xOwogCiAJcmV0dXJuIGNsZWFuOwpAQCAtMzQ5OCwxNiArMzU3OCwxOCBAQAogICogTWVyZ2UgdGhlIGNvbW1pdHMgaDEgYW5kIGgyLCByZXR1cm4gdGhlIHJlc3VsdGluZyB2aXJ0dWFsCiAgKiBjb21taXQgb2JqZWN0IGFuZCBhIGZsYWcgaW5kaWNhdGluZyB0aGUgY2xlYW5uZXNzIG9mIHRoZSBtZXJnZS4KICAqLwotaW50IG1lcmdlX3JlY3Vyc2l2ZShzdHJ1Y3QgbWVyZ2Vfb3B0aW9ucyAqb3B0LAotCQkgICAgc3RydWN0IGNvbW1pdCAqaDEsCi0JCSAgICBzdHJ1Y3QgY29tbWl0ICpoMiwKLQkJICAgIHN0cnVjdCBjb21taXRfbGlzdCAqY2EsCi0JCSAgICBzdHJ1Y3QgY29tbWl0ICoqcmVzdWx0KQorc3RhdGljIGludCBtZXJnZV9yZWN1cnNpdmVfaW50ZXJuYWwoc3RydWN0IG1lcmdlX29wdGlvbnMgKm9wdCwKKwkJCQkgICAgc3RydWN0IGNvbW1pdCAqaDEsCisJCQkJICAgIHN0cnVjdCBjb21taXQgKmgyLAorCQkJCSAgICBzdHJ1Y3QgY29tbWl0X2xpc3QgKm1lcmdlX2Jhc2VzLAorCQkJCSAgICBzdHJ1Y3QgY29tbWl0ICoqcmVzdWx0KQogewogCXN0cnVjdCBjb21taXRfbGlzdCAqaXRlcjsKLQlzdHJ1Y3QgY29tbWl0ICptZXJnZWRfY29tbW9uX2FuY2VzdG9yczsKLQlzdHJ1Y3QgdHJlZSAqbXJ0cmVlOworCXN0cnVjdCBjb21taXQgKm1lcmdlZF9tZXJnZV9iYXNlczsKKwlzdHJ1Y3QgdHJlZSAqcmVzdWx0X3RyZWU7CiAJaW50IGNsZWFuOworCWNvbnN0IGNoYXIgKmFuY2VzdG9yX25hbWU7CisJc3RydWN0IHN0cmJ1ZiBtZXJnZV9iYXNlX2FiYnJldiA9IFNUUkJVRl9JTklUOwogCiAJaWYgKHNob3cob3B0LCA0KSkgewogCQlvdXRwdXQob3B0LCA0LCBfKCJNZXJnaW5nOiIpKTsKQEAgLTM1MTUsMzIgKzM1OTcsNDMgQEAKIAkJb3V0cHV0X2NvbW1pdF90aXRsZShvcHQsIGgyKTsKIAl9CiAKLQlpZiAoIWNhKSB7Ci0JCWNhID0gZ2V0X21lcmdlX2Jhc2VzKGgxLCBoMik7Ci0JCWNhID0gcmV2ZXJzZV9jb21taXRfbGlzdChjYSk7CisJaWYgKCFtZXJnZV9iYXNlcykgeworCQltZXJnZV9iYXNlcyA9IGdldF9tZXJnZV9iYXNlcyhoMSwgaDIpOworCQltZXJnZV9iYXNlcyA9IHJldmVyc2VfY29tbWl0X2xpc3QobWVyZ2VfYmFzZXMpOwogCX0KIAogCWlmIChzaG93KG9wdCwgNSkpIHsKLQkJdW5zaWduZWQgY250ID0gY29tbWl0X2xpc3RfY291bnQoY2EpOworCQl1bnNpZ25lZCBjbnQgPSBjb21taXRfbGlzdF9jb3VudChtZXJnZV9iYXNlcyk7CiAKIAkJb3V0cHV0KG9wdCwgNSwgUV8oImZvdW5kICV1IGNvbW1vbiBhbmNlc3RvcjoiLAogCQkJCSJmb3VuZCAldSBjb21tb24gYW5jZXN0b3JzOiIsIGNudCksIGNudCk7Ci0JCWZvciAoaXRlciA9IGNhOyBpdGVyOyBpdGVyID0gaXRlci0+bmV4dCkKKwkJZm9yIChpdGVyID0gbWVyZ2VfYmFzZXM7IGl0ZXI7IGl0ZXIgPSBpdGVyLT5uZXh0KQogCQkJb3V0cHV0X2NvbW1pdF90aXRsZShvcHQsIGl0ZXItPml0ZW0pOwogCX0KIAotCW1lcmdlZF9jb21tb25fYW5jZXN0b3JzID0gcG9wX2NvbW1pdCgmY2EpOwotCWlmIChtZXJnZWRfY29tbW9uX2FuY2VzdG9ycyA9PSBOVUxMKSB7CisJbWVyZ2VkX21lcmdlX2Jhc2VzID0gcG9wX2NvbW1pdCgmbWVyZ2VfYmFzZXMpOworCWlmIChtZXJnZWRfbWVyZ2VfYmFzZXMgPT0gTlVMTCkgewogCQkvKiBpZiB0aGVyZSBpcyBubyBjb21tb24gYW5jZXN0b3IsIHVzZSBhbiBlbXB0eSB0cmVlICovCiAJCXN0cnVjdCB0cmVlICp0cmVlOwogCiAJCXRyZWUgPSBsb29rdXBfdHJlZShvcHQtPnJlcG8sIG9wdC0+cmVwby0+aGFzaF9hbGdvLT5lbXB0eV90cmVlKTsKLQkJbWVyZ2VkX2NvbW1vbl9hbmNlc3RvcnMgPSBtYWtlX3ZpcnR1YWxfY29tbWl0KG9wdC0+cmVwbywgdHJlZSwgImFuY2VzdG9yIik7CisJCW1lcmdlZF9tZXJnZV9iYXNlcyA9IG1ha2VfdmlydHVhbF9jb21taXQob3B0LT5yZXBvLCB0cmVlLAorCQkJCQkJCSAiYW5jZXN0b3IiKTsKKwkJYW5jZXN0b3JfbmFtZSA9ICJlbXB0eSB0cmVlIjsKKwl9IGVsc2UgaWYgKG9wdC0+YW5jZXN0b3IgJiYgIW9wdC0+cHJpdi0+Y2FsbF9kZXB0aCkgeworCQlhbmNlc3Rvcl9uYW1lID0gb3B0LT5hbmNlc3RvcjsKKwl9IGVsc2UgaWYgKG1lcmdlX2Jhc2VzKSB7CisJCWFuY2VzdG9yX25hbWUgPSAibWVyZ2VkIGNvbW1vbiBhbmNlc3RvcnMiOworCX0gZWxzZSB7CisJCXN0cmJ1Zl9hZGRfdW5pcXVlX2FiYnJldigmbWVyZ2VfYmFzZV9hYmJyZXYsCisJCQkJCSAmbWVyZ2VkX21lcmdlX2Jhc2VzLT5vYmplY3Qub2lkLAorCQkJCQkgREVGQVVMVF9BQkJSRVYpOworCQlhbmNlc3Rvcl9uYW1lID0gbWVyZ2VfYmFzZV9hYmJyZXYuYnVmOwogCX0KIAotCWZvciAoaXRlciA9IGNhOyBpdGVyOyBpdGVyID0gaXRlci0+bmV4dCkgeworCWZvciAoaXRlciA9IG1lcmdlX2Jhc2VzOyBpdGVyOyBpdGVyID0gaXRlci0+bmV4dCkgewogCQljb25zdCBjaGFyICpzYXZlZF9iMSwgKnNhdmVkX2IyOwotCQlvcHQtPmNhbGxfZGVwdGgrKzsKKwkJb3B0LT5wcml2LT5jYWxsX2RlcHRoKys7CiAJCS8qCiAJCSAqIFdoZW4gdGhlIG1lcmdlIGZhaWxzLCB0aGUgcmVzdWx0IGNvbnRhaW5zIGZpbGVzCiAJCSAqIHdpdGggY29uZmxpY3QgbWFya2Vycy4gVGhlIGNsZWFubmVzcyBmbGFnIGlzCkBAIC0zNTU0LDQ1ICszNjQ3LDEzNCBAQAogCQlzYXZlZF9iMiA9IG9wdC0+YnJhbmNoMjsKIAkJb3B0LT5icmFuY2gxID0gIlRlbXBvcmFyeSBtZXJnZSBicmFuY2ggMSI7CiAJCW9wdC0+YnJhbmNoMiA9ICJUZW1wb3JhcnkgbWVyZ2UgYnJhbmNoIDIiOwotCQlpZiAobWVyZ2VfcmVjdXJzaXZlKG9wdCwgbWVyZ2VkX2NvbW1vbl9hbmNlc3RvcnMsIGl0ZXItPml0ZW0sCi0JCQkJICAgIE5VTEwsICZtZXJnZWRfY29tbW9uX2FuY2VzdG9ycykgPCAwKQorCQlpZiAobWVyZ2VfcmVjdXJzaXZlX2ludGVybmFsKG9wdCwgbWVyZ2VkX21lcmdlX2Jhc2VzLCBpdGVyLT5pdGVtLAorCQkJCQkgICAgIE5VTEwsICZtZXJnZWRfbWVyZ2VfYmFzZXMpIDwgMCkKIAkJCXJldHVybiAtMTsKIAkJb3B0LT5icmFuY2gxID0gc2F2ZWRfYjE7CiAJCW9wdC0+YnJhbmNoMiA9IHNhdmVkX2IyOwotCQlvcHQtPmNhbGxfZGVwdGgtLTsKKwkJb3B0LT5wcml2LT5jYWxsX2RlcHRoLS07CiAKLQkJaWYgKCFtZXJnZWRfY29tbW9uX2FuY2VzdG9ycykKKwkJaWYgKCFtZXJnZWRfbWVyZ2VfYmFzZXMpCiAJCQlyZXR1cm4gZXJyKG9wdCwgXygibWVyZ2UgcmV0dXJuZWQgbm8gY29tbWl0IikpOwogCX0KIAogCWRpc2NhcmRfaW5kZXgob3B0LT5yZXBvLT5pbmRleCk7Ci0JaWYgKCFvcHQtPmNhbGxfZGVwdGgpCisJaWYgKCFvcHQtPnByaXYtPmNhbGxfZGVwdGgpCiAJCXJlcG9fcmVhZF9pbmRleChvcHQtPnJlcG8pOwogCi0Jb3B0LT5hbmNlc3RvciA9ICJtZXJnZWQgY29tbW9uIGFuY2VzdG9ycyI7Ci0JY2xlYW4gPSBtZXJnZV90cmVlcyhvcHQsIGdldF9jb21taXRfdHJlZShoMSksIGdldF9jb21taXRfdHJlZShoMiksCi0JCQkgICAgZ2V0X2NvbW1pdF90cmVlKG1lcmdlZF9jb21tb25fYW5jZXN0b3JzKSwKLQkJCSAgICAmbXJ0cmVlKTsKKwlvcHQtPmFuY2VzdG9yID0gYW5jZXN0b3JfbmFtZTsKKwljbGVhbiA9IG1lcmdlX3RyZWVzX2ludGVybmFsKG9wdCwKKwkJCQkgICAgIHJlcG9fZ2V0X2NvbW1pdF90cmVlKG9wdC0+cmVwbywgaDEpLAorCQkJCSAgICAgcmVwb19nZXRfY29tbWl0X3RyZWUob3B0LT5yZXBvLCBoMiksCisJCQkJICAgICByZXBvX2dldF9jb21taXRfdHJlZShvcHQtPnJlcG8sCisJCQkJCQkJICBtZXJnZWRfbWVyZ2VfYmFzZXMpLAorCQkJCSAgICAgJnJlc3VsdF90cmVlKTsKKwlzdHJidWZfcmVsZWFzZSgmbWVyZ2VfYmFzZV9hYmJyZXYpOworCW9wdC0+YW5jZXN0b3IgPSBOVUxMOyAgLyogYXZvaWQgYWNjaWRlbnRhbCByZS11c2Ugb2Ygb3B0LT5hbmNlc3RvciAqLwogCWlmIChjbGVhbiA8IDApIHsKIAkJZmx1c2hfb3V0cHV0KG9wdCk7CiAJCXJldHVybiBjbGVhbjsKIAl9CiAKLQlpZiAob3B0LT5jYWxsX2RlcHRoKSB7Ci0JCSpyZXN1bHQgPSBtYWtlX3ZpcnR1YWxfY29tbWl0KG9wdC0+cmVwbywgbXJ0cmVlLCAibWVyZ2VkIHRyZWUiKTsKKwlpZiAob3B0LT5wcml2LT5jYWxsX2RlcHRoKSB7CisJCSpyZXN1bHQgPSBtYWtlX3ZpcnR1YWxfY29tbWl0KG9wdC0+cmVwbywgcmVzdWx0X3RyZWUsCisJCQkJCSAgICAgICJtZXJnZWQgdHJlZSIpOwogCQljb21taXRfbGlzdF9pbnNlcnQoaDEsICYoKnJlc3VsdCktPnBhcmVudHMpOwogCQljb21taXRfbGlzdF9pbnNlcnQoaDIsICYoKnJlc3VsdCktPnBhcmVudHMtPm5leHQpOwogCX0KLQlmbHVzaF9vdXRwdXQob3B0KTsKLQlpZiAoIW9wdC0+Y2FsbF9kZXB0aCAmJiBvcHQtPmJ1ZmZlcl9vdXRwdXQgPCAyKQotCQlzdHJidWZfcmVsZWFzZSgmb3B0LT5vYnVmKTsKLQlpZiAoc2hvdyhvcHQsIDIpKQotCQlkaWZmX3dhcm5fcmVuYW1lX2xpbWl0KCJtZXJnZS5yZW5hbWVsaW1pdCIsCi0JCQkJICAgICAgIG9wdC0+bmVlZGVkX3JlbmFtZV9saW1pdCwgMCk7CiAJcmV0dXJuIGNsZWFuOwogfQogCi1zdGF0aWMgc3RydWN0IGNvbW1pdCAqZ2V0X3JlZihzdHJ1Y3QgcmVwb3NpdG9yeSAqcmVwbywgY29uc3Qgc3RydWN0IG9iamVjdF9pZCAqb2lkLAorc3RhdGljIGludCBtZXJnZV9zdGFydChzdHJ1Y3QgbWVyZ2Vfb3B0aW9ucyAqb3B0LCBzdHJ1Y3QgdHJlZSAqaGVhZCkKK3sKKwlzdHJ1Y3Qgc3RyYnVmIHNiID0gU1RSQlVGX0lOSVQ7CisKKwkvKiBTYW5pdHkgY2hlY2tzIG9uIG9wdCAqLworCWFzc2VydChvcHQtPnJlcG8pOworCisJYXNzZXJ0KG9wdC0+YnJhbmNoMSAmJiBvcHQtPmJyYW5jaDIpOworCisJYXNzZXJ0KG9wdC0+ZGV0ZWN0X3JlbmFtZXMgPj0gLTEgJiYKKwkgICAgICAgb3B0LT5kZXRlY3RfcmVuYW1lcyA8PSBESUZGX0RFVEVDVF9DT1BZKTsKKwlhc3NlcnQob3B0LT5kZXRlY3RfZGlyZWN0b3J5X3JlbmFtZXMgPj0gTUVSR0VfRElSRUNUT1JZX1JFTkFNRVNfTk9ORSAmJgorCSAgICAgICBvcHQtPmRldGVjdF9kaXJlY3RvcnlfcmVuYW1lcyA8PSBNRVJHRV9ESVJFQ1RPUllfUkVOQU1FU19UUlVFKTsKKwlhc3NlcnQob3B0LT5yZW5hbWVfbGltaXQgPj0gLTEpOworCWFzc2VydChvcHQtPnJlbmFtZV9zY29yZSA+PSAwICYmIG9wdC0+cmVuYW1lX3Njb3JlIDw9IE1BWF9TQ09SRSk7CisJYXNzZXJ0KG9wdC0+c2hvd19yZW5hbWVfcHJvZ3Jlc3MgPj0gMCAmJiBvcHQtPnNob3dfcmVuYW1lX3Byb2dyZXNzIDw9IDEpOworCisJYXNzZXJ0KG9wdC0+eGRsX29wdHMgPj0gMCk7CisJYXNzZXJ0KG9wdC0+cmVjdXJzaXZlX3ZhcmlhbnQgPj0gTUVSR0VfVkFSSUFOVF9OT1JNQUwgJiYKKwkgICAgICAgb3B0LT5yZWN1cnNpdmVfdmFyaWFudCA8PSBNRVJHRV9WQVJJQU5UX1RIRUlSUyk7CisKKwlhc3NlcnQob3B0LT52ZXJib3NpdHkgPj0gMCAmJiBvcHQtPnZlcmJvc2l0eSA8PSA1KTsKKwlhc3NlcnQob3B0LT5idWZmZXJfb3V0cHV0IDw9IDIpOworCWFzc2VydChvcHQtPm9idWYubGVuID09IDApOworCisJYXNzZXJ0KG9wdC0+cHJpdiA9PSBOVUxMKTsKKworCS8qIFNhbml0eSBjaGVjayBvbiByZXBvIHN0YXRlOyBpbmRleCBtdXN0IG1hdGNoIGhlYWQgKi8KKwlpZiAocmVwb19pbmRleF9oYXNfY2hhbmdlcyhvcHQtPnJlcG8sIGhlYWQsICZzYikpIHsKKwkJZXJyKG9wdCwgXygiWW91ciBsb2NhbCBjaGFuZ2VzIHRvIHRoZSBmb2xsb3dpbmcgZmlsZXMgd291bGQgYmUgb3ZlcndyaXR0ZW4gYnkgbWVyZ2U6XG4gICVzIiksCisJCSAgICBzYi5idWYpOworCQlzdHJidWZfcmVsZWFzZSgmc2IpOworCQlyZXR1cm4gLTE7CisJfQorCisJb3B0LT5wcml2ID0geGNhbGxvYygxLCBzaXplb2YoKm9wdC0+cHJpdikpOworCXN0cmluZ19saXN0X2luaXQoJm9wdC0+cHJpdi0+ZGZfY29uZmxpY3RfZmlsZV9zZXQsIDEpOworCXJldHVybiAwOworfQorCitzdGF0aWMgdm9pZCBtZXJnZV9maW5hbGl6ZShzdHJ1Y3QgbWVyZ2Vfb3B0aW9ucyAqb3B0KQoreworCWZsdXNoX291dHB1dChvcHQpOworCWlmICghb3B0LT5wcml2LT5jYWxsX2RlcHRoICYmIG9wdC0+YnVmZmVyX291dHB1dCA8IDIpCisJCXN0cmJ1Zl9yZWxlYXNlKCZvcHQtPm9idWYpOworCWlmIChzaG93KG9wdCwgMikpCisJCWRpZmZfd2Fybl9yZW5hbWVfbGltaXQoIm1lcmdlLnJlbmFtZWxpbWl0IiwKKwkJCQkgICAgICAgb3B0LT5wcml2LT5uZWVkZWRfcmVuYW1lX2xpbWl0LCAwKTsKKwlGUkVFX0FORF9OVUxMKG9wdC0+cHJpdik7Cit9CisKK2ludCBtZXJnZV90cmVlcyhzdHJ1Y3QgbWVyZ2Vfb3B0aW9ucyAqb3B0LAorCQlzdHJ1Y3QgdHJlZSAqaGVhZCwKKwkJc3RydWN0IHRyZWUgKm1lcmdlLAorCQlzdHJ1Y3QgdHJlZSAqbWVyZ2VfYmFzZSkKK3sKKwlpbnQgY2xlYW47CisJc3RydWN0IHRyZWUgKmlnbm9yZWQ7CisKKwlhc3NlcnQob3B0LT5hbmNlc3RvciAhPSBOVUxMKTsKKworCWlmIChtZXJnZV9zdGFydChvcHQsIGhlYWQpKQorCQlyZXR1cm4gLTE7CisJY2xlYW4gPSBtZXJnZV90cmVlc19pbnRlcm5hbChvcHQsIGhlYWQsIG1lcmdlLCBtZXJnZV9iYXNlLCAmaWdub3JlZCk7CisJbWVyZ2VfZmluYWxpemUob3B0KTsKKworCXJldHVybiBjbGVhbjsKK30KKworaW50IG1lcmdlX3JlY3Vyc2l2ZShzdHJ1Y3QgbWVyZ2Vfb3B0aW9ucyAqb3B0LAorCQkgICAgc3RydWN0IGNvbW1pdCAqaDEsCisJCSAgICBzdHJ1Y3QgY29tbWl0ICpoMiwKKwkJICAgIHN0cnVjdCBjb21taXRfbGlzdCAqbWVyZ2VfYmFzZXMsCisJCSAgICBzdHJ1Y3QgY29tbWl0ICoqcmVzdWx0KQoreworCWludCBjbGVhbjsKKworCWFzc2VydChvcHQtPmFuY2VzdG9yID09IE5VTEwgfHwKKwkgICAgICAgIXN0cmNtcChvcHQtPmFuY2VzdG9yLCAiY29uc3RydWN0ZWQgbWVyZ2UgYmFzZSIpKTsKKworCWlmIChtZXJnZV9zdGFydChvcHQsIHJlcG9fZ2V0X2NvbW1pdF90cmVlKG9wdC0+cmVwbywgaDEpKSkKKwkJcmV0dXJuIC0xOworCWNsZWFuID0gbWVyZ2VfcmVjdXJzaXZlX2ludGVybmFsKG9wdCwgaDEsIGgyLCBtZXJnZV9iYXNlcywgcmVzdWx0KTsKKwltZXJnZV9maW5hbGl6ZShvcHQpOworCisJcmV0dXJuIGNsZWFuOworfQorCitzdGF0aWMgc3RydWN0IGNvbW1pdCAqZ2V0X3JlZihzdHJ1Y3QgcmVwb3NpdG9yeSAqcmVwbywKKwkJCSAgICAgIGNvbnN0IHN0cnVjdCBvYmplY3RfaWQgKm9pZCwKIAkJCSAgICAgIGNvbnN0IGNoYXIgKm5hbWUpCiB7CiAJc3RydWN0IG9iamVjdCAqb2JqZWN0OwpAQCAtMzYxMyw4ICszNzk1LDggQEAKIGludCBtZXJnZV9yZWN1cnNpdmVfZ2VuZXJpYyhzdHJ1Y3QgbWVyZ2Vfb3B0aW9ucyAqb3B0LAogCQkJICAgIGNvbnN0IHN0cnVjdCBvYmplY3RfaWQgKmhlYWQsCiAJCQkgICAgY29uc3Qgc3RydWN0IG9iamVjdF9pZCAqbWVyZ2UsCi0JCQkgICAgaW50IG51bV9iYXNlX2xpc3QsCi0JCQkgICAgY29uc3Qgc3RydWN0IG9iamVjdF9pZCAqKmJhc2VfbGlzdCwKKwkJCSAgICBpbnQgbnVtX21lcmdlX2Jhc2VzLAorCQkJICAgIGNvbnN0IHN0cnVjdCBvYmplY3RfaWQgKiptZXJnZV9iYXNlcywKIAkJCSAgICBzdHJ1Y3QgY29tbWl0ICoqcmVzdWx0KQogewogCWludCBjbGVhbjsKQEAgLTM2MjMsMTUgKzM4MDUsMTggQEAKIAlzdHJ1Y3QgY29tbWl0ICpuZXh0X2NvbW1pdCA9IGdldF9yZWYob3B0LT5yZXBvLCBtZXJnZSwgb3B0LT5icmFuY2gyKTsKIAlzdHJ1Y3QgY29tbWl0X2xpc3QgKmNhID0gTlVMTDsKIAotCWlmIChiYXNlX2xpc3QpIHsKKwlpZiAobWVyZ2VfYmFzZXMpIHsKIAkJaW50IGk7Ci0JCWZvciAoaSA9IDA7IGkgPCBudW1fYmFzZV9saXN0OyArK2kpIHsKKwkJZm9yIChpID0gMDsgaSA8IG51bV9tZXJnZV9iYXNlczsgKytpKSB7CiAJCQlzdHJ1Y3QgY29tbWl0ICpiYXNlOwotCQkJaWYgKCEoYmFzZSA9IGdldF9yZWYob3B0LT5yZXBvLCBiYXNlX2xpc3RbaV0sIG9pZF90b19oZXgoYmFzZV9saXN0W2ldKSkpKQorCQkJaWYgKCEoYmFzZSA9IGdldF9yZWYob3B0LT5yZXBvLCBtZXJnZV9iYXNlc1tpXSwKKwkJCQkJICAgICBvaWRfdG9faGV4KG1lcmdlX2Jhc2VzW2ldKSkpKQogCQkJCXJldHVybiBlcnIob3B0LCBfKCJDb3VsZCBub3QgcGFyc2Ugb2JqZWN0ICclcyciKSwKLQkJCQkJICAgb2lkX3RvX2hleChiYXNlX2xpc3RbaV0pKTsKKwkJCQkJICAgb2lkX3RvX2hleChtZXJnZV9iYXNlc1tpXSkpOwogCQkJY29tbWl0X2xpc3RfaW5zZXJ0KGJhc2UsICZjYSk7CiAJCX0KKwkJaWYgKG51bV9tZXJnZV9iYXNlcyA9PSAxKQorCQkJb3B0LT5hbmNlc3RvciA9ICJjb25zdHJ1Y3RlZCBtZXJnZSBiYXNlIjsKIAl9CiAKIAlyZXBvX2hvbGRfbG9ja2VkX2luZGV4KG9wdC0+cmVwbywgJmxvY2ssIExPQ0tfRElFX09OX0VSUk9SKTsKQEAgLTM2NTMsMjIgKzM4MzgsMjUgQEAKIHsKIAljaGFyICp2YWx1ZSA9IE5VTEw7CiAJZ2l0X2NvbmZpZ19nZXRfaW50KCJtZXJnZS52ZXJib3NpdHkiLCAmb3B0LT52ZXJib3NpdHkpOwotCWdpdF9jb25maWdfZ2V0X2ludCgiZGlmZi5yZW5hbWVsaW1pdCIsICZvcHQtPmRpZmZfcmVuYW1lX2xpbWl0KTsKLQlnaXRfY29uZmlnX2dldF9pbnQoIm1lcmdlLnJlbmFtZWxpbWl0IiwgJm9wdC0+bWVyZ2VfcmVuYW1lX2xpbWl0KTsKKwlnaXRfY29uZmlnX2dldF9pbnQoImRpZmYucmVuYW1lbGltaXQiLCAmb3B0LT5yZW5hbWVfbGltaXQpOworCWdpdF9jb25maWdfZ2V0X2ludCgibWVyZ2UucmVuYW1lbGltaXQiLCAmb3B0LT5yZW5hbWVfbGltaXQpOwogCWlmICghZ2l0X2NvbmZpZ19nZXRfc3RyaW5nKCJkaWZmLnJlbmFtZXMiLCAmdmFsdWUpKSB7Ci0JCW9wdC0+ZGlmZl9kZXRlY3RfcmVuYW1lID0gZ2l0X2NvbmZpZ19yZW5hbWUoImRpZmYucmVuYW1lcyIsIHZhbHVlKTsKKwkJb3B0LT5kZXRlY3RfcmVuYW1lcyA9IGdpdF9jb25maWdfcmVuYW1lKCJkaWZmLnJlbmFtZXMiLCB2YWx1ZSk7CiAJCWZyZWUodmFsdWUpOwogCX0KIAlpZiAoIWdpdF9jb25maWdfZ2V0X3N0cmluZygibWVyZ2UucmVuYW1lcyIsICZ2YWx1ZSkpIHsKLQkJb3B0LT5tZXJnZV9kZXRlY3RfcmVuYW1lID0gZ2l0X2NvbmZpZ19yZW5hbWUoIm1lcmdlLnJlbmFtZXMiLCB2YWx1ZSk7CisJCW9wdC0+ZGV0ZWN0X3JlbmFtZXMgPSBnaXRfY29uZmlnX3JlbmFtZSgibWVyZ2UucmVuYW1lcyIsIHZhbHVlKTsKIAkJZnJlZSh2YWx1ZSk7CiAJfQogCWlmICghZ2l0X2NvbmZpZ19nZXRfc3RyaW5nKCJtZXJnZS5kaXJlY3RvcnlyZW5hbWVzIiwgJnZhbHVlKSkgewogCQlpbnQgYm9vbHZhbCA9IGdpdF9wYXJzZV9tYXliZV9ib29sKHZhbHVlKTsKIAkJaWYgKDAgPD0gYm9vbHZhbCkgewotCQkJb3B0LT5kZXRlY3RfZGlyZWN0b3J5X3JlbmFtZXMgPSBib29sdmFsID8gMiA6IDA7CisJCQlvcHQtPmRldGVjdF9kaXJlY3RvcnlfcmVuYW1lcyA9IGJvb2x2YWwgPworCQkJCU1FUkdFX0RJUkVDVE9SWV9SRU5BTUVTX1RSVUUgOgorCQkJCU1FUkdFX0RJUkVDVE9SWV9SRU5BTUVTX05PTkU7CiAJCX0gZWxzZSBpZiAoIXN0cmNhc2VjbXAodmFsdWUsICJjb25mbGljdCIpKSB7Ci0JCQlvcHQtPmRldGVjdF9kaXJlY3RvcnlfcmVuYW1lcyA9IDE7CisJCQlvcHQtPmRldGVjdF9kaXJlY3RvcnlfcmVuYW1lcyA9CisJCQkJTUVSR0VfRElSRUNUT1JZX1JFTkFNRVNfQ09ORkxJQ1Q7CiAJCX0gLyogYXZvaWQgZXJyb3Jpbmcgb24gdmFsdWVzIGZyb20gZnV0dXJlIHZlcnNpb25zIG9mIGdpdCAqLwogCQlmcmVlKHZhbHVlKTsKIAl9CkBAIC0zNjgwLDIzICszODY4LDI1IEBACiB7CiAJY29uc3QgY2hhciAqbWVyZ2VfdmVyYm9zaXR5OwogCW1lbXNldChvcHQsIDAsIHNpemVvZihzdHJ1Y3QgbWVyZ2Vfb3B0aW9ucykpOworCiAJb3B0LT5yZXBvID0gcmVwbzsKKworCW9wdC0+ZGV0ZWN0X3JlbmFtZXMgPSAtMTsKKwlvcHQtPmRldGVjdF9kaXJlY3RvcnlfcmVuYW1lcyA9IE1FUkdFX0RJUkVDVE9SWV9SRU5BTUVTX0NPTkZMSUNUOworCW9wdC0+cmVuYW1lX2xpbWl0ID0gLTE7CisKIAlvcHQtPnZlcmJvc2l0eSA9IDI7CiAJb3B0LT5idWZmZXJfb3V0cHV0ID0gMTsKLQlvcHQtPmRpZmZfcmVuYW1lX2xpbWl0ID0gLTE7Ci0Jb3B0LT5tZXJnZV9yZW5hbWVfbGltaXQgPSAtMTsKKwlzdHJidWZfaW5pdCgmb3B0LT5vYnVmLCAwKTsKKwogCW9wdC0+cmVub3JtYWxpemUgPSAwOwotCW9wdC0+ZGlmZl9kZXRlY3RfcmVuYW1lID0gLTE7Ci0Jb3B0LT5tZXJnZV9kZXRlY3RfcmVuYW1lID0gLTE7Ci0Jb3B0LT5kZXRlY3RfZGlyZWN0b3J5X3JlbmFtZXMgPSAxOworCiAJbWVyZ2VfcmVjdXJzaXZlX2NvbmZpZyhvcHQpOwogCW1lcmdlX3ZlcmJvc2l0eSA9IGdldGVudigiR0lUX01FUkdFX1ZFUkJPU0lUWSIpOwogCWlmIChtZXJnZV92ZXJib3NpdHkpCiAJCW9wdC0+dmVyYm9zaXR5ID0gc3RydG9sKG1lcmdlX3ZlcmJvc2l0eSwgTlVMTCwgMTApOwogCWlmIChvcHQtPnZlcmJvc2l0eSA+PSA1KQogCQlvcHQtPmJ1ZmZlcl9vdXRwdXQgPSAwOwotCXN0cmJ1Zl9pbml0KCZvcHQtPm9idWYsIDApOwotCXN0cmluZ19saXN0X2luaXQoJm9wdC0+ZGZfY29uZmxpY3RfZmlsZV9zZXQsIDEpOwogfQogCiBpbnQgcGFyc2VfbWVyZ2Vfb3B0KHN0cnVjdCBtZXJnZV9vcHRpb25zICpvcHQsIGNvbnN0IGNoYXIgKnMpCkBAIC0zNzA2LDkgKzM4OTYsOSBAQAogCWlmICghcyB8fCAhKnMpCiAJCXJldHVybiAtMTsKIAlpZiAoIXN0cmNtcChzLCAib3VycyIpKQotCQlvcHQtPnJlY3Vyc2l2ZV92YXJpYW50ID0gTUVSR0VfUkVDVVJTSVZFX09VUlM7CisJCW9wdC0+cmVjdXJzaXZlX3ZhcmlhbnQgPSBNRVJHRV9WQVJJQU5UX09VUlM7CiAJZWxzZSBpZiAoIXN0cmNtcChzLCAidGhlaXJzIikpCi0JCW9wdC0+cmVjdXJzaXZlX3ZhcmlhbnQgPSBNRVJHRV9SRUNVUlNJVkVfVEhFSVJTOworCQlvcHQtPnJlY3Vyc2l2ZV92YXJpYW50ID0gTUVSR0VfVkFSSUFOVF9USEVJUlM7CiAJZWxzZSBpZiAoIXN0cmNtcChzLCAic3VidHJlZSIpKQogCQlvcHQtPnN1YnRyZWVfc2hpZnQgPSAiIjsKIAllbHNlIGlmIChza2lwX3ByZWZpeChzLCAic3VidHJlZT0iLCAmYXJnKSkKQEAgLTM3MzksMTYgKzM5MjksMTYgQEAKIAllbHNlIGlmICghc3RyY21wKHMsICJuby1yZW5vcm1hbGl6ZSIpKQogCQlvcHQtPnJlbm9ybWFsaXplID0gMDsKIAllbHNlIGlmICghc3RyY21wKHMsICJuby1yZW5hbWVzIikpCi0JCW9wdC0+bWVyZ2VfZGV0ZWN0X3JlbmFtZSA9IDA7CisJCW9wdC0+ZGV0ZWN0X3JlbmFtZXMgPSAwOwogCWVsc2UgaWYgKCFzdHJjbXAocywgImZpbmQtcmVuYW1lcyIpKSB7Ci0JCW9wdC0+bWVyZ2VfZGV0ZWN0X3JlbmFtZSA9IDE7CisJCW9wdC0+ZGV0ZWN0X3JlbmFtZXMgPSAxOwogCQlvcHQtPnJlbmFtZV9zY29yZSA9IDA7CiAJfQogCWVsc2UgaWYgKHNraXBfcHJlZml4KHMsICJmaW5kLXJlbmFtZXM9IiwgJmFyZykgfHwKIAkJIHNraXBfcHJlZml4KHMsICJyZW5hbWUtdGhyZXNob2xkPSIsICZhcmcpKSB7CiAJCWlmICgob3B0LT5yZW5hbWVfc2NvcmUgPSBwYXJzZV9yZW5hbWVfc2NvcmUoJmFyZykpID09IC0xIHx8ICphcmcgIT0gMCkKIAkJCXJldHVybiAtMTsKLQkJb3B0LT5tZXJnZV9kZXRlY3RfcmVuYW1lID0gMTsKKwkJb3B0LT5kZXRlY3RfcmVuYW1lcyA9IDE7CiAJfQogCS8qCiAJICogUGxlYXNlIHVwZGF0ZSAkX19naXRfbWVyZ2Vfc3RyYXRlZ3lfb3B0aW9ucyBpbgpkaWZmIC0tZ2l0IGEvbWVyZ2UtcmVjdXJzaXZlLmggYi9tZXJnZS1yZWN1cnNpdmUuaAppbmRleCBjMmI3YmI2Li45Nzg4NDdlIDEwMDY0NAotLS0gYS9tZXJnZS1yZWN1cnNpdmUuaAorKysgYi9tZXJnZS1yZWN1cnNpdmUuaApAQCAtMSwxMDQgKzEsMTI0IEBACiAjaWZuZGVmIE1FUkdFX1JFQ1VSU0lWRV9ICiAjZGVmaW5lIE1FUkdFX1JFQ1VSU0lWRV9ICiAKLSNpbmNsdWRlICJzdHJpbmctbGlzdC5oIgotI2luY2x1ZGUgInVucGFjay10cmVlcy5oIgorI2luY2x1ZGUgInN0cmJ1Zi5oIgogCiBzdHJ1Y3QgY29tbWl0OwotCitzdHJ1Y3QgY29tbWl0X2xpc3Q7CitzdHJ1Y3Qgb2JqZWN0X2lkOwogc3RydWN0IHJlcG9zaXRvcnk7CitzdHJ1Y3QgdHJlZTsKIAorc3RydWN0IG1lcmdlX29wdGlvbnNfaW50ZXJuYWw7CiBzdHJ1Y3QgbWVyZ2Vfb3B0aW9ucyB7CisJc3RydWN0IHJlcG9zaXRvcnkgKnJlcG87CisKKwkvKiByZWYgbmFtZXMgdXNlZCBpbiBjb25zb2xlIG1lc3NhZ2VzIGFuZCBjb25mbGljdCBtYXJrZXJzICovCiAJY29uc3QgY2hhciAqYW5jZXN0b3I7CiAJY29uc3QgY2hhciAqYnJhbmNoMTsKIAljb25zdCBjaGFyICpicmFuY2gyOworCisJLyogcmVuYW1lIHJlbGF0ZWQgb3B0aW9ucyAqLworCWludCBkZXRlY3RfcmVuYW1lczsKIAllbnVtIHsKLQkJTUVSR0VfUkVDVVJTSVZFX05PUk1BTCA9IDAsCi0JCU1FUkdFX1JFQ1VSU0lWRV9PVVJTLAotCQlNRVJHRV9SRUNVUlNJVkVfVEhFSVJTCi0JfSByZWN1cnNpdmVfdmFyaWFudDsKLQljb25zdCBjaGFyICpzdWJ0cmVlX3NoaWZ0OwotCXVuc2lnbmVkIGJ1ZmZlcl9vdXRwdXQ7IC8qIDE6IG91dHB1dCBhdCBlbmQsIDI6IGtlZXAgYnVmZmVyZWQgKi8KLQl1bnNpZ25lZCByZW5vcm1hbGl6ZSA6IDE7Ci0JbG9uZyB4ZGxfb3B0czsKLQlpbnQgdmVyYm9zaXR5OwotCWludCBkZXRlY3RfZGlyZWN0b3J5X3JlbmFtZXM7Ci0JaW50IGRpZmZfZGV0ZWN0X3JlbmFtZTsKLQlpbnQgbWVyZ2VfZGV0ZWN0X3JlbmFtZTsKLQlpbnQgZGlmZl9yZW5hbWVfbGltaXQ7Ci0JaW50IG1lcmdlX3JlbmFtZV9saW1pdDsKKwkJTUVSR0VfRElSRUNUT1JZX1JFTkFNRVNfTk9ORSA9IDAsCisJCU1FUkdFX0RJUkVDVE9SWV9SRU5BTUVTX0NPTkZMSUNUID0gMSwKKwkJTUVSR0VfRElSRUNUT1JZX1JFTkFNRVNfVFJVRSA9IDIKKwl9IGRldGVjdF9kaXJlY3RvcnlfcmVuYW1lczsKKwlpbnQgcmVuYW1lX2xpbWl0OwogCWludCByZW5hbWVfc2NvcmU7Ci0JaW50IG5lZWRlZF9yZW5hbWVfbGltaXQ7CiAJaW50IHNob3dfcmVuYW1lX3Byb2dyZXNzOwotCWludCBjYWxsX2RlcHRoOwotCXN0cnVjdCBzdHJidWYgb2J1ZjsKLQlzdHJ1Y3QgaGFzaG1hcCBjdXJyZW50X2ZpbGVfZGlyX3NldDsKLQlzdHJ1Y3Qgc3RyaW5nX2xpc3QgZGZfY29uZmxpY3RfZmlsZV9zZXQ7Ci0Jc3RydWN0IHVucGFja190cmVlc19vcHRpb25zIHVucGFja19vcHRzOwotCXN0cnVjdCBpbmRleF9zdGF0ZSBvcmlnX2luZGV4OwotCXN0cnVjdCByZXBvc2l0b3J5ICpyZXBvOworCisJLyogeGRpZmYtcmVsYXRlZCBvcHRpb25zIChwYXRpZW5jZSwgaWdub3JlIHdoaXRlc3BhY2UsIG91cnMvdGhlaXJzKSAqLworCWxvbmcgeGRsX29wdHM7CisJZW51bSB7CisJCU1FUkdFX1ZBUklBTlRfTk9STUFMID0gMCwKKwkJTUVSR0VfVkFSSUFOVF9PVVJTLAorCQlNRVJHRV9WQVJJQU5UX1RIRUlSUworCX0gcmVjdXJzaXZlX3ZhcmlhbnQ7CisKKwkvKiBjb25zb2xlIG91dHB1dCByZWxhdGVkIG9wdGlvbnMgKi8KKwlpbnQgdmVyYm9zaXR5OworCXVuc2lnbmVkIGJ1ZmZlcl9vdXRwdXQ7IC8qIDE6IG91dHB1dCBhdCBlbmQsIDI6IGtlZXAgYnVmZmVyZWQgKi8KKwlzdHJ1Y3Qgc3RyYnVmIG9idWY7ICAgICAvKiBvdXRwdXQgYnVmZmVyOyBpZiBidWZmZXJfb3V0cHV0ID09IDIsIGNhbGxlcgorCQkJCSAqIG11c3QgaGFuZGxlIGFuZCBjYWxsIHN0cmJ1Zl9yZWxlYXNlICovCisKKwkvKiBtaXNjZWxsYW5lb3VzIGNvbnRyb2wgb3B0aW9ucyAqLworCWNvbnN0IGNoYXIgKnN1YnRyZWVfc2hpZnQ7CisJdW5zaWduZWQgcmVub3JtYWxpemUgOiAxOworCisJLyogaW50ZXJuYWwgZmllbGRzIHVzZWQgYnkgdGhlIGltcGxlbWVudGF0aW9uICovCisJc3RydWN0IG1lcmdlX29wdGlvbnNfaW50ZXJuYWwgKnByaXY7CiB9OwogCit2b2lkIGluaXRfbWVyZ2Vfb3B0aW9ucyhzdHJ1Y3QgbWVyZ2Vfb3B0aW9ucyAqb3B0LCBzdHJ1Y3QgcmVwb3NpdG9yeSAqcmVwbyk7CisKKy8qIHBhcnNlIHRoZSBvcHRpb24gaW4gcyBhbmQgdXBkYXRlIHRoZSByZWxldmFudCBmaWVsZCBvZiBvcHQgKi8KK2ludCBwYXJzZV9tZXJnZV9vcHQoc3RydWN0IG1lcmdlX29wdGlvbnMgKm9wdCwgY29uc3QgY2hhciAqcyk7CisKIC8qCi0gKiBGb3IgZGlyX3JlbmFtZV9lbnRyeSwgZGlyZWN0b3J5IG5hbWVzIGFyZSBzdG9yZWQgYXMgYSBmdWxsIHBhdGggZnJvbSB0aGUKLSAqIHRvcGxldmVsIG9mIHRoZSByZXBvc2l0b3J5IGFuZCBkbyBub3QgaW5jbHVkZSBhIHRyYWlsaW5nICcvJy4gIEFsc286Ci0gKgotICogICBkaXI6ICAgICAgICAgICAgICAgIG9yaWdpbmFsIG5hbWUgb2YgZGlyZWN0b3J5IGJlaW5nIHJlbmFtZWQKLSAqICAgbm9uX3VuaXF1ZV9uZXdfZGlyOiBpZiB0cnVlLCBjb3VsZCBub3QgZGV0ZXJtaW5lIG5ld19kaXIKLSAqICAgbmV3X2RpcjogICAgICAgICAgICBmaW5hbCBuYW1lIG9mIGRpcmVjdG9yeSBiZWluZyByZW5hbWVkCi0gKiAgIHBvc3NpYmxlX25ld19kaXJzOiAgdGVtcG9yYXJ5IHVzZWQgdG8gaGVscCBkZXRlcm1pbmUgbmV3X2Rpcjsgc2VlIGNvbW1lbnRzCi0gKiAgICAgICAgICAgICAgICAgICAgICAgaW4gZ2V0X2RpcmVjdG9yeV9yZW5hbWVzKCkgZm9yIGRldGFpbHMKKyAqIFJFVFVSTiBWQUxVRVM6IEFsbCB0aGUgbWVyZ2VfKiBmdW5jdGlvbnMgYmVsb3cgcmV0dXJuIGEgdmFsdWUgYXMgZm9sbG93czoKKyAqICAgPiAwICAgICBNZXJnZSB3YXMgY2xlYW4KKyAqICAgPSAwICAgICBNZXJnZSBoYWQgY29uZmxpY3RzCisgKiAgIDwgMCAgICAgTWVyZ2UgaGl0IGFuIHVuZXhwZWN0ZWQgYW5kIHVucmVjb3ZlcmFibGUgcHJvYmxlbSAoZS5nLiBkaXNrCisgKiAgICAgICAgICAgICBmdWxsKSBhbmQgYWJvcnRlZCBtZXJnZSBwYXJ0LXdheSB0aHJvdWdoLgogICovCi1zdHJ1Y3QgZGlyX3JlbmFtZV9lbnRyeSB7Ci0Jc3RydWN0IGhhc2htYXBfZW50cnkgZW50OyAvKiBtdXN0IGJlIHRoZSBmaXJzdCBtZW1iZXIhICovCi0JY2hhciAqZGlyOwotCXVuc2lnbmVkIG5vbl91bmlxdWVfbmV3X2RpcjoxOwotCXN0cnVjdCBzdHJidWYgbmV3X2RpcjsKLQlzdHJ1Y3Qgc3RyaW5nX2xpc3QgcG9zc2libGVfbmV3X2RpcnM7Ci19OwogCi1zdHJ1Y3QgY29sbGlzaW9uX2VudHJ5IHsKLQlzdHJ1Y3QgaGFzaG1hcF9lbnRyeSBlbnQ7IC8qIG11c3QgYmUgdGhlIGZpcnN0IG1lbWJlciEgKi8KLQljaGFyICp0YXJnZXRfZmlsZTsKLQlzdHJ1Y3Qgc3RyaW5nX2xpc3Qgc291cmNlX2ZpbGVzOwotCXVuc2lnbmVkIHJlcG9ydGVkX2FscmVhZHk6MTsKLX07Ci0KLXN0YXRpYyBpbmxpbmUgaW50IG1lcmdlX2RldGVjdF9yZW5hbWUoc3RydWN0IG1lcmdlX29wdGlvbnMgKm8pCi17Ci0JcmV0dXJuIG8tPm1lcmdlX2RldGVjdF9yZW5hbWUgPj0gMCA/IG8tPm1lcmdlX2RldGVjdF9yZW5hbWUgOgotCQlvLT5kaWZmX2RldGVjdF9yZW5hbWUgPj0gMCA/IG8tPmRpZmZfZGV0ZWN0X3JlbmFtZSA6IDE7Ci19Ci0KLS8qIG1lcmdlX3RyZWVzKCkgYnV0IHdpdGggcmVjdXJzaXZlIGFuY2VzdG9yIGNvbnNvbGlkYXRpb24gKi8KLWludCBtZXJnZV9yZWN1cnNpdmUoc3RydWN0IG1lcmdlX29wdGlvbnMgKm8sCi0JCSAgICBzdHJ1Y3QgY29tbWl0ICpoMSwKLQkJICAgIHN0cnVjdCBjb21taXQgKmgyLAotCQkgICAgc3RydWN0IGNvbW1pdF9saXN0ICphbmNlc3RvcnMsCi0JCSAgICBzdHJ1Y3QgY29tbWl0ICoqcmVzdWx0KTsKLQotLyogcmVuYW1lLWRldGVjdGluZyB0aHJlZS13YXkgbWVyZ2UsIG5vIHJlY3Vyc2lvbiAqLwotaW50IG1lcmdlX3RyZWVzKHN0cnVjdCBtZXJnZV9vcHRpb25zICpvLAorLyoKKyAqIHJlbmFtZS1kZXRlY3RpbmcgdGhyZWUtd2F5IG1lcmdlLCBubyByZWN1cnNpb24uCisgKgorICogT3V0cHV0czoKKyAqICAgLSBTZWUgUkVUVVJOIFZBTFVFUyBhYm92ZQorICogICAtIE5vIGNvbW1pdCBpcyBjcmVhdGVkCisgKiAgIC0gb3B0LT5yZXBvLT5pbmRleCBoYXMgdGhlIG5ldyBpbmRleAorICogICAtICRHSVRfSU5ERVhfRklMRSBpcyBub3QgdXBkYXRlZAorICogICAtIFRoZSB3b3JraW5nIHRyZWUgaXMgdXBkYXRlZCB3aXRoIHJlc3VsdHMgb2YgdGhlIG1lcmdlCisgKi8KK2ludCBtZXJnZV90cmVlcyhzdHJ1Y3QgbWVyZ2Vfb3B0aW9ucyAqb3B0LAogCQlzdHJ1Y3QgdHJlZSAqaGVhZCwKIAkJc3RydWN0IHRyZWUgKm1lcmdlLAotCQlzdHJ1Y3QgdHJlZSAqY29tbW9uLAotCQlzdHJ1Y3QgdHJlZSAqKnJlc3VsdCk7CisJCXN0cnVjdCB0cmVlICptZXJnZV9iYXNlKTsKIAogLyoKLSAqICJnaXQtbWVyZ2UtcmVjdXJzaXZlIiBjYW4gYmUgZmVkIHRyZWVzOyB3cmFwIHRoZW0gaW50bwotICogdmlydHVhbCBjb21taXRzIGFuZCBjYWxsIG1lcmdlX3JlY3Vyc2l2ZSgpIHByb3Blci4KKyAqIG1lcmdlX3JlY3Vyc2l2ZSBpcyBsaWtlIG1lcmdlX3RyZWVzKCkgYnV0IHdpdGggcmVjdXJzaXZlIGFuY2VzdG9yCisgKiBjb25zb2xpZGF0aW9uIGFuZCwgaWYgdGhlIGNvbW1pdCBpcyBjbGVhbiwgY3JlYXRpb24gb2YgYSBjb21taXQuCisgKgorICogTk9URTogZW1waXJpY2FsbHksIGFib3V0IGEgZGVjYWRlIGFnbyBpdCB3YXMgZGV0ZXJtaW5lZCB0aGF0IHdpdGggbW9yZQorICogICAgICAgdGhhbiB0d28gbWVyZ2UgYmFzZXMsIG9wdGltYWwgYmVoYXZpb3Igd2FzIGZvdW5kIHdoZW4gdGhlCisgKiAgICAgICBtZXJnZV9iYXNlcyB3ZXJlIHBhc3NlZCBpbiB0aGUgb3JkZXIgb2Ygb2xkZXN0IGNvbW1pdCB0byBuZXdlc3QKKyAqICAgICAgIGNvbW1pdC4gIEFsc28sIG1lcmdlX2Jhc2VzIHdpbGwgYmUgY29uc3VtZWQgKGVtcHRpZWQpIHNvIG1ha2UgYQorICogICAgICAgY29weSBpZiB5b3UgbmVlZCBpdC4KKyAqCisgKiBPdXRwdXRzOgorICogICAtIFNlZSBSRVRVUk4gVkFMVUVTIGFib3ZlCisgKiAgIC0gSWYgbWVyZ2UgaXMgY2xlYW4sIGEgY29tbWl0IGlzIGNyZWF0ZWQgYW5kIGl0cyBhZGRyZXNzIHdyaXR0ZW4gdG8gKnJlc3VsdAorICogICAtIG9wdC0+cmVwby0+aW5kZXggaGFzIHRoZSBuZXcgaW5kZXgKKyAqICAgLSAkR0lUX0lOREVYX0ZJTEUgaXMgbm90IHVwZGF0ZWQKKyAqICAgLSBUaGUgd29ya2luZyB0cmVlIGlzIHVwZGF0ZWQgd2l0aCByZXN1bHRzIG9mIHRoZSBtZXJnZQogICovCi1pbnQgbWVyZ2VfcmVjdXJzaXZlX2dlbmVyaWMoc3RydWN0IG1lcmdlX29wdGlvbnMgKm8sCitpbnQgbWVyZ2VfcmVjdXJzaXZlKHN0cnVjdCBtZXJnZV9vcHRpb25zICpvcHQsCisJCSAgICBzdHJ1Y3QgY29tbWl0ICpoMSwKKwkJICAgIHN0cnVjdCBjb21taXQgKmgyLAorCQkgICAgc3RydWN0IGNvbW1pdF9saXN0ICptZXJnZV9iYXNlcywKKwkJICAgIHN0cnVjdCBjb21taXQgKipyZXN1bHQpOworCisvKgorICogbWVyZ2VfcmVjdXJzaXZlX2dlbmVyaWMgY2FuIG9wZXJhdGUgb24gdHJlZXMgaW5zdGVhZCBvZiBjb21taXRzLCBieQorICogd3JhcHBpbmcgdGhlIHRyZWVzIGludG8gdmlydHVhbCBjb21taXRzLCBhbmQgY2FsbGluZyBtZXJnZV9yZWN1cnNpdmUoKS4KKyAqIEl0IGFsc28gd3JpdGVzIG91dCB0aGUgaW4tbWVtb3J5IGluZGV4IHRvIGRpc2sgaWYgdGhlIG1lcmdlIGlzIHN1Y2Nlc3NmdWwuCisgKgorICogT3V0cHV0czoKKyAqICAgLSBTZWUgUkVUVVJOIFZBTFVFUyBhYm92ZQorICogICAtIElmIG1lcmdlIGlzIGNsZWFuLCBhIGNvbW1pdCBpcyBjcmVhdGVkIGFuZCBpdHMgYWRkcmVzcyB3cml0dGVuIHRvICpyZXN1bHQKKyAqICAgLSBvcHQtPnJlcG8tPmluZGV4IGhhcyB0aGUgbmV3IGluZGV4CisgKiAgIC0gJEdJVF9JTkRFWF9GSUxFIGlzIHVwZGF0ZWQKKyAqICAgLSBUaGUgd29ya2luZyB0cmVlIGlzIHVwZGF0ZWQgd2l0aCByZXN1bHRzIG9mIHRoZSBtZXJnZQorICovCitpbnQgbWVyZ2VfcmVjdXJzaXZlX2dlbmVyaWMoc3RydWN0IG1lcmdlX29wdGlvbnMgKm9wdCwKIAkJCSAgICBjb25zdCBzdHJ1Y3Qgb2JqZWN0X2lkICpoZWFkLAogCQkJICAgIGNvbnN0IHN0cnVjdCBvYmplY3RfaWQgKm1lcmdlLAotCQkJICAgIGludCBudW1fY2EsCi0JCQkgICAgY29uc3Qgc3RydWN0IG9iamVjdF9pZCAqKmNhLAorCQkJICAgIGludCBudW1fbWVyZ2VfYmFzZXMsCisJCQkgICAgY29uc3Qgc3RydWN0IG9iamVjdF9pZCAqKm1lcmdlX2Jhc2VzLAogCQkJICAgIHN0cnVjdCBjb21taXQgKipyZXN1bHQpOwogCi12b2lkIGluaXRfbWVyZ2Vfb3B0aW9ucyhzdHJ1Y3QgbWVyZ2Vfb3B0aW9ucyAqbywKLQkJCXN0cnVjdCByZXBvc2l0b3J5ICpyZXBvKTsKLXN0cnVjdCB0cmVlICp3cml0ZV90cmVlX2Zyb21fbWVtb3J5KHN0cnVjdCBtZXJnZV9vcHRpb25zICpvKTsKLQotaW50IHBhcnNlX21lcmdlX29wdChzdHJ1Y3QgbWVyZ2Vfb3B0aW9ucyAqb3V0LCBjb25zdCBjaGFyICpzKTsKLQogI2VuZGlmCmRpZmYgLS1naXQgYS9taWR4LmMgYi9taWR4LmMKaW5kZXggZDY0OTY0NC4uMzdlYzI4NiAxMDA2NDQKLS0tIGEvbWlkeC5jCisrKyBiL21pZHguYwpAQCAtMTksOCArMTksNyBAQAogI2RlZmluZSBNSURYX0JZVEVfTlVNX1BBQ0tTIDgKICNkZWZpbmUgTUlEWF9IQVNIX1ZFUlNJT04gMQogI2RlZmluZSBNSURYX0hFQURFUl9TSVpFIDEyCi0jZGVmaW5lIE1JRFhfSEFTSF9MRU4gMjAKLSNkZWZpbmUgTUlEWF9NSU5fU0laRSAoTUlEWF9IRUFERVJfU0laRSArIE1JRFhfSEFTSF9MRU4pCisjZGVmaW5lIE1JRFhfTUlOX1NJWkUgKE1JRFhfSEVBREVSX1NJWkUgKyB0aGVfaGFzaF9hbGdvLT5yYXdzeikKIAogI2RlZmluZSBNSURYX01BWF9DSFVOS1MgNQogI2RlZmluZSBNSURYX0NIVU5LX0FMSUdOTUVOVCA0CkBAIC05Myw3ICs5Miw3IEBACiAJaGFzaF92ZXJzaW9uID0gbS0+ZGF0YVtNSURYX0JZVEVfSEFTSF9WRVJTSU9OXTsKIAlpZiAoaGFzaF92ZXJzaW9uICE9IE1JRFhfSEFTSF9WRVJTSU9OKQogCQlkaWUoXygiaGFzaCB2ZXJzaW9uICV1IGRvZXMgbm90IG1hdGNoIiksIGhhc2hfdmVyc2lvbik7Ci0JbS0+aGFzaF9sZW4gPSBNSURYX0hBU0hfTEVOOworCW0tPmhhc2hfbGVuID0gdGhlX2hhc2hfYWxnby0+cmF3c3o7CiAKIAltLT5udW1fY2h1bmtzID0gbS0+ZGF0YVtNSURYX0JZVEVfTlVNX0NIVU5LU107CiAKQEAgLTIzNCw3ICsyMzMsNyBAQAogaW50IGJzZWFyY2hfbWlkeChjb25zdCBzdHJ1Y3Qgb2JqZWN0X2lkICpvaWQsIHN0cnVjdCBtdWx0aV9wYWNrX2luZGV4ICptLCB1aW50MzJfdCAqcmVzdWx0KQogewogCXJldHVybiBic2VhcmNoX2hhc2gob2lkLT5oYXNoLCBtLT5jaHVua19vaWRfZmFub3V0LCBtLT5jaHVua19vaWRfbG9va3VwLAotCQkJICAgIE1JRFhfSEFTSF9MRU4sIHJlc3VsdCk7CisJCQkgICAgdGhlX2hhc2hfYWxnby0+cmF3c3osIHJlc3VsdCk7CiB9CiAKIHN0cnVjdCBvYmplY3RfaWQgKm50aF9taWR4ZWRfb2JqZWN0X29pZChzdHJ1Y3Qgb2JqZWN0X2lkICpvaWQsCkBAIC00NDksNiArNDQ4LDggQEAKIAl1aW50MzJfdCBucjsKIAl1aW50MzJfdCBhbGxvYzsKIAlzdHJ1Y3QgbXVsdGlfcGFja19pbmRleCAqbTsKKwlzdHJ1Y3QgcHJvZ3Jlc3MgKnByb2dyZXNzOworCXVuc2lnbmVkIHBhY2tfcGF0aHNfY2hlY2tlZDsKIH07CiAKIHN0YXRpYyB2b2lkIGFkZF9wYWNrX3RvX21pZHgoY29uc3QgY2hhciAqZnVsbF9wYXRoLCBzaXplX3QgZnVsbF9wYXRoX2xlbiwKQEAgLTQ1Nyw2ICs0NTgsNyBAQAogCXN0cnVjdCBwYWNrX2xpc3QgKnBhY2tzID0gKHN0cnVjdCBwYWNrX2xpc3QgKilkYXRhOwogCiAJaWYgKGVuZHNfd2l0aChmaWxlX25hbWUsICIuaWR4IikpIHsKKwkJZGlzcGxheV9wcm9ncmVzcyhwYWNrcy0+cHJvZ3Jlc3MsICsrcGFja3MtPnBhY2tfcGF0aHNfY2hlY2tlZCk7CiAJCWlmIChwYWNrcy0+bSAmJiBtaWR4X2NvbnRhaW5zX3BhY2socGFja3MtPm0sIGZpbGVfbmFtZSkpCiAJCQlyZXR1cm47CiAKQEAgLTc4Niw3ICs3ODgsNyBAQAogfQogCiBzdGF0aWMgaW50IHdyaXRlX21pZHhfaW50ZXJuYWwoY29uc3QgY2hhciAqb2JqZWN0X2Rpciwgc3RydWN0IG11bHRpX3BhY2tfaW5kZXggKm0sCi0JCQkgICAgICAgc3RydWN0IHN0cmluZ19saXN0ICpwYWNrc190b19kcm9wKQorCQkJICAgICAgIHN0cnVjdCBzdHJpbmdfbGlzdCAqcGFja3NfdG9fZHJvcCwgdW5zaWduZWQgZmxhZ3MpCiB7CiAJdW5zaWduZWQgY2hhciBjdXJfY2h1bmssIG51bV9jaHVua3MgPSAwOwogCWNoYXIgKm1pZHhfbmFtZTsKQEAgLTgwMCw2ICs4MDIsNyBAQAogCXVpbnQ2NF90IGNodW5rX29mZnNldHNbTUlEWF9NQVhfQ0hVTktTICsgMV07CiAJdWludDMyX3QgbnJfZW50cmllcywgbnVtX2xhcmdlX29mZnNldHMgPSAwOwogCXN0cnVjdCBwYWNrX21pZHhfZW50cnkgKmVudHJpZXMgPSBOVUxMOworCXN0cnVjdCBwcm9ncmVzcyAqcHJvZ3Jlc3MgPSBOVUxMOwogCWludCBsYXJnZV9vZmZzZXRzX25lZWRlZCA9IDA7CiAJaW50IHBhY2tfbmFtZV9jb25jYXRfbGVuID0gMDsKIAlpbnQgZHJvcHBlZF9wYWNrcyA9IDA7CkBAIC04MzQsNyArODM3LDE0IEBACiAJCX0KIAl9CiAKKwlwYWNrcy5wYWNrX3BhdGhzX2NoZWNrZWQgPSAwOworCWlmIChmbGFncyAmIE1JRFhfUFJPR1JFU1MpCisJCXBhY2tzLnByb2dyZXNzID0gc3RhcnRfcHJvZ3Jlc3MoXygiQWRkaW5nIHBhY2tmaWxlcyB0byBtdWx0aS1wYWNrLWluZGV4IiksIDApOworCWVsc2UKKwkJcGFja3MucHJvZ3Jlc3MgPSBOVUxMOworCiAJZm9yX2VhY2hfZmlsZV9pbl9wYWNrX2RpcihvYmplY3RfZGlyLCBhZGRfcGFja190b19taWR4LCAmcGFja3MpOworCXN0b3BfcHJvZ3Jlc3MoJnBhY2tzLnByb2dyZXNzKTsKIAogCWlmIChwYWNrcy5tICYmIHBhY2tzLm5yID09IHBhY2tzLm0tPm51bV9wYWNrcyAmJiAhcGFja3NfdG9fZHJvcCkKIAkJZ290byBjbGVhbnVwOwpAQCAtOTI4LDcgKzkzOCw3IEBACiAKIAljdXJfY2h1bmsrKzsKIAljaHVua19pZHNbY3VyX2NodW5rXSA9IE1JRFhfQ0hVTktJRF9PQkpFQ1RPRkZTRVRTOwotCWNodW5rX29mZnNldHNbY3VyX2NodW5rXSA9IGNodW5rX29mZnNldHNbY3VyX2NodW5rIC0gMV0gKyBucl9lbnRyaWVzICogTUlEWF9IQVNIX0xFTjsKKwljaHVua19vZmZzZXRzW2N1cl9jaHVua10gPSBjaHVua19vZmZzZXRzW2N1cl9jaHVuayAtIDFdICsgbnJfZW50cmllcyAqIHRoZV9oYXNoX2FsZ28tPnJhd3N6OwogCiAJY3VyX2NodW5rKys7CiAJY2h1bmtfb2Zmc2V0c1tjdXJfY2h1bmtdID0gY2h1bmtfb2Zmc2V0c1tjdXJfY2h1bmsgLSAxXSArIG5yX2VudHJpZXMgKiBNSURYX0NIVU5LX09GRlNFVF9XSURUSDsKQEAgLTk1OSw2ICs5NjksOSBAQAogCQl3cml0dGVuICs9IE1JRFhfQ0hVTktMT09LVVBfV0lEVEg7CiAJfQogCisJaWYgKGZsYWdzICYgTUlEWF9QUk9HUkVTUykKKwkJcHJvZ3Jlc3MgPSBzdGFydF9wcm9ncmVzcyhfKCJXcml0aW5nIGNodW5rcyB0byBtdWx0aS1wYWNrLWluZGV4IiksCisJCQkJCSAgbnVtX2NodW5rcyk7CiAJZm9yIChpID0gMDsgaSA8IG51bV9jaHVua3M7IGkrKykgewogCQlpZiAod3JpdHRlbiAhPSBjaHVua19vZmZzZXRzW2ldKQogCQkJQlVHKCJpbmNvcnJlY3QgY2h1bmsgb2Zmc2V0ICglIlBSSXU2NCIgIT0gJSJQUkl1NjQiKSBmb3IgY2h1bmsgaWQgJSJQUkl4MzIsCkBAIC05NzYsNyArOTg5LDcgQEAKIAkJCQlicmVhazsKIAogCQkJY2FzZSBNSURYX0NIVU5LSURfT0lETE9PS1VQOgotCQkJCXdyaXR0ZW4gKz0gd3JpdGVfbWlkeF9vaWRfbG9va3VwKGYsIE1JRFhfSEFTSF9MRU4sIGVudHJpZXMsIG5yX2VudHJpZXMpOworCQkJCXdyaXR0ZW4gKz0gd3JpdGVfbWlkeF9vaWRfbG9va3VwKGYsIHRoZV9oYXNoX2FsZ28tPnJhd3N6LCBlbnRyaWVzLCBucl9lbnRyaWVzKTsKIAkJCQlicmVhazsKIAogCQkJY2FzZSBNSURYX0NIVU5LSURfT0JKRUNUT0ZGU0VUUzoKQEAgLTk5MSw3ICsxMDA0LDEwIEBACiAJCQkJQlVHKCJ0cnlpbmcgdG8gd3JpdGUgdW5rbm93biBjaHVuayBpZCAlIlBSSXgzMiwKIAkJCQkgICAgY2h1bmtfaWRzW2ldKTsKIAkJfQorCisJCWRpc3BsYXlfcHJvZ3Jlc3MocHJvZ3Jlc3MsIGkgKyAxKTsKIAl9CisJc3RvcF9wcm9ncmVzcygmcHJvZ3Jlc3MpOwogCiAJaWYgKHdyaXR0ZW4gIT0gY2h1bmtfb2Zmc2V0c1tudW1fY2h1bmtzXSkKIAkJQlVHKCJpbmNvcnJlY3QgZmluYWwgb2Zmc2V0ICUiUFJJdTY0IiAhPSAlIlBSSXU2NCwKQEAgLTEwMTcsOSArMTAzMyw5IEBACiAJcmV0dXJuIHJlc3VsdDsKIH0KIAotaW50IHdyaXRlX21pZHhfZmlsZShjb25zdCBjaGFyICpvYmplY3RfZGlyKQoraW50IHdyaXRlX21pZHhfZmlsZShjb25zdCBjaGFyICpvYmplY3RfZGlyLCB1bnNpZ25lZCBmbGFncykKIHsKLQlyZXR1cm4gd3JpdGVfbWlkeF9pbnRlcm5hbChvYmplY3RfZGlyLCBOVUxMLCBOVUxMKTsKKwlyZXR1cm4gd3JpdGVfbWlkeF9pbnRlcm5hbChvYmplY3RfZGlyLCBOVUxMLCBOVUxMLCBmbGFncyk7CiB9CiAKIHZvaWQgY2xlYXJfbWlkeF9maWxlKHN0cnVjdCByZXBvc2l0b3J5ICpyKQpAQCAtMTA3NywxOSArMTA5MywyMCBAQAogCQkJZGlzcGxheV9wcm9ncmVzcyhwcm9ncmVzcywgX24pOyBcCiAJfSB3aGlsZSAoMCkKIAotaW50IHZlcmlmeV9taWR4X2ZpbGUoc3RydWN0IHJlcG9zaXRvcnkgKnIsIGNvbnN0IGNoYXIgKm9iamVjdF9kaXIpCitpbnQgdmVyaWZ5X21pZHhfZmlsZShzdHJ1Y3QgcmVwb3NpdG9yeSAqciwgY29uc3QgY2hhciAqb2JqZWN0X2RpciwgdW5zaWduZWQgZmxhZ3MpCiB7CiAJc3RydWN0IHBhaXJfcG9zX3ZzX2lkICpwYWlycyA9IE5VTEw7CiAJdWludDMyX3QgaTsKLQlzdHJ1Y3QgcHJvZ3Jlc3MgKnByb2dyZXNzOworCXN0cnVjdCBwcm9ncmVzcyAqcHJvZ3Jlc3MgPSBOVUxMOwogCXN0cnVjdCBtdWx0aV9wYWNrX2luZGV4ICptID0gbG9hZF9tdWx0aV9wYWNrX2luZGV4KG9iamVjdF9kaXIsIDEpOwogCXZlcmlmeV9taWR4X2Vycm9yID0gMDsKIAogCWlmICghbSkKIAkJcmV0dXJuIDA7CiAKLQlwcm9ncmVzcyA9IHN0YXJ0X3Byb2dyZXNzKF8oIkxvb2tpbmcgZm9yIHJlZmVyZW5jZWQgcGFja2ZpbGVzIiksCi0JCQkJICBtLT5udW1fcGFja3MpOworCWlmIChmbGFncyAmIE1JRFhfUFJPR1JFU1MpCisJCXByb2dyZXNzID0gc3RhcnRfcHJvZ3Jlc3MoXygiTG9va2luZyBmb3IgcmVmZXJlbmNlZCBwYWNrZmlsZXMiKSwKKwkJCQkJICBtLT5udW1fcGFja3MpOwogCWZvciAoaSA9IDA7IGkgPCBtLT5udW1fcGFja3M7IGkrKykgewogCQlpZiAocHJlcGFyZV9taWR4X3BhY2sociwgbSwgaSkpCiAJCQltaWR4X3JlcG9ydCgiZmFpbGVkIHRvIGxvYWQgcGFjayBpbiBwb3NpdGlvbiAlZCIsIGkpOwpAQCAtMTEwNyw4ICsxMTI0LDkgQEAKIAkJCQkgICAgaSwgb2lkX2Zhbm91dDEsIG9pZF9mYW5vdXQyLCBpICsgMSk7CiAJfQogCi0JcHJvZ3Jlc3MgPSBzdGFydF9zcGFyc2VfcHJvZ3Jlc3MoXygiVmVyaWZ5aW5nIE9JRCBvcmRlciBpbiBNSURYIiksCi0JCQkJCSBtLT5udW1fb2JqZWN0cyAtIDEpOworCWlmIChmbGFncyAmIE1JRFhfUFJPR1JFU1MpCisJCXByb2dyZXNzID0gc3RhcnRfc3BhcnNlX3Byb2dyZXNzKF8oIlZlcmlmeWluZyBPSUQgb3JkZXIgaW4gbXVsdGktcGFjay1pbmRleCIpLAorCQkJCQkJIG0tPm51bV9vYmplY3RzIC0gMSk7CiAJZm9yIChpID0gMDsgaSA8IG0tPm51bV9vYmplY3RzIC0gMTsgaSsrKSB7CiAJCXN0cnVjdCBvYmplY3RfaWQgb2lkMSwgb2lkMjsKIApAQCAtMTEzNSwxMyArMTE1MywxNSBAQAogCQlwYWlyc1tpXS5wYWNrX2ludF9pZCA9IG50aF9taWR4ZWRfcGFja19pbnRfaWQobSwgaSk7CiAJfQogCi0JcHJvZ3Jlc3MgPSBzdGFydF9zcGFyc2VfcHJvZ3Jlc3MoXygiU29ydGluZyBvYmplY3RzIGJ5IHBhY2tmaWxlIiksCi0JCQkJCSBtLT5udW1fb2JqZWN0cyk7CisJaWYgKGZsYWdzICYgTUlEWF9QUk9HUkVTUykKKwkJcHJvZ3Jlc3MgPSBzdGFydF9zcGFyc2VfcHJvZ3Jlc3MoXygiU29ydGluZyBvYmplY3RzIGJ5IHBhY2tmaWxlIiksCisJCQkJCQkgbS0+bnVtX29iamVjdHMpOwogCWRpc3BsYXlfcHJvZ3Jlc3MocHJvZ3Jlc3MsIDApOyAvKiBUT0RPOiBNZWFzdXJlIFFTT1JUKCkgcHJvZ3Jlc3MgKi8KIAlRU09SVChwYWlycywgbS0+bnVtX29iamVjdHMsIGNvbXBhcmVfcGFpcl9wb3NfdnNfaWQpOwogCXN0b3BfcHJvZ3Jlc3MoJnByb2dyZXNzKTsKIAotCXByb2dyZXNzID0gc3RhcnRfc3BhcnNlX3Byb2dyZXNzKF8oIlZlcmlmeWluZyBvYmplY3Qgb2Zmc2V0cyIpLCBtLT5udW1fb2JqZWN0cyk7CisJaWYgKGZsYWdzICYgTUlEWF9QUk9HUkVTUykKKwkJcHJvZ3Jlc3MgPSBzdGFydF9zcGFyc2VfcHJvZ3Jlc3MoXygiVmVyaWZ5aW5nIG9iamVjdCBvZmZzZXRzIiksIG0tPm51bV9vYmplY3RzKTsKIAlmb3IgKGkgPSAwOyBpIDwgbS0+bnVtX29iamVjdHM7IGkrKykgewogCQlzdHJ1Y3Qgb2JqZWN0X2lkIG9pZDsKIAkJc3RydWN0IHBhY2tfZW50cnkgZTsKQEAgLTExODQsMjMgKzEyMDQsMzQgQEAKIAlyZXR1cm4gdmVyaWZ5X21pZHhfZXJyb3I7CiB9CiAKLWludCBleHBpcmVfbWlkeF9wYWNrcyhzdHJ1Y3QgcmVwb3NpdG9yeSAqciwgY29uc3QgY2hhciAqb2JqZWN0X2RpcikKK2ludCBleHBpcmVfbWlkeF9wYWNrcyhzdHJ1Y3QgcmVwb3NpdG9yeSAqciwgY29uc3QgY2hhciAqb2JqZWN0X2RpciwgdW5zaWduZWQgZmxhZ3MpCiB7CiAJdWludDMyX3QgaSwgKmNvdW50LCByZXN1bHQgPSAwOwogCXN0cnVjdCBzdHJpbmdfbGlzdCBwYWNrc190b19kcm9wID0gU1RSSU5HX0xJU1RfSU5JVF9EVVA7CiAJc3RydWN0IG11bHRpX3BhY2tfaW5kZXggKm0gPSBsb2FkX211bHRpX3BhY2tfaW5kZXgob2JqZWN0X2RpciwgMSk7CisJc3RydWN0IHByb2dyZXNzICpwcm9ncmVzcyA9IE5VTEw7CiAKIAlpZiAoIW0pCiAJCXJldHVybiAwOwogCiAJY291bnQgPSB4Y2FsbG9jKG0tPm51bV9wYWNrcywgc2l6ZW9mKHVpbnQzMl90KSk7CisKKwlpZiAoZmxhZ3MgJiBNSURYX1BST0dSRVNTKQorCQlwcm9ncmVzcyA9IHN0YXJ0X3Byb2dyZXNzKF8oIkNvdW50aW5nIHJlZmVyZW5jZWQgb2JqZWN0cyIpLAorCQkJCQkgIG0tPm51bV9vYmplY3RzKTsKIAlmb3IgKGkgPSAwOyBpIDwgbS0+bnVtX29iamVjdHM7IGkrKykgewogCQlpbnQgcGFja19pbnRfaWQgPSBudGhfbWlkeGVkX3BhY2tfaW50X2lkKG0sIGkpOwogCQljb3VudFtwYWNrX2ludF9pZF0rKzsKKwkJZGlzcGxheV9wcm9ncmVzcyhwcm9ncmVzcywgaSArIDEpOwogCX0KKwlzdG9wX3Byb2dyZXNzKCZwcm9ncmVzcyk7CiAKKwlpZiAoZmxhZ3MgJiBNSURYX1BST0dSRVNTKQorCQlwcm9ncmVzcyA9IHN0YXJ0X3Byb2dyZXNzKF8oIkZpbmRpbmcgYW5kIGRlbGV0aW5nIHVucmVmZXJlbmNlZCBwYWNrZmlsZXMiKSwKKwkJCQkJICBtLT5udW1fcGFja3MpOwogCWZvciAoaSA9IDA7IGkgPCBtLT5udW1fcGFja3M7IGkrKykgewogCQljaGFyICpwYWNrX25hbWU7CisJCWRpc3BsYXlfcHJvZ3Jlc3MocHJvZ3Jlc3MsIGkgKyAxKTsKIAogCQlpZiAoY291bnRbaV0pCiAJCQljb250aW51ZTsKQEAgLTEyMTgsMTEgKzEyNDksMTIgQEAKIAkJdW5saW5rX3BhY2tfcGF0aChwYWNrX25hbWUsIDApOwogCQlmcmVlKHBhY2tfbmFtZSk7CiAJfQorCXN0b3BfcHJvZ3Jlc3MoJnByb2dyZXNzKTsKIAogCWZyZWUoY291bnQpOwogCiAJaWYgKHBhY2tzX3RvX2Ryb3AubnIpCi0JCXJlc3VsdCA9IHdyaXRlX21pZHhfaW50ZXJuYWwob2JqZWN0X2RpciwgbSwgJnBhY2tzX3RvX2Ryb3ApOworCQlyZXN1bHQgPSB3cml0ZV9taWR4X2ludGVybmFsKG9iamVjdF9kaXIsIG0sICZwYWNrc190b19kcm9wLCBmbGFncyk7CiAKIAlzdHJpbmdfbGlzdF9jbGVhcigmcGFja3NfdG9fZHJvcCwgMCk7CiAJcmV0dXJuIHJlc3VsdDsKQEAgLTEzMTYsNyArMTM0OCw3IEBACiAJcmV0dXJuIDA7CiB9CiAKLWludCBtaWR4X3JlcGFjayhzdHJ1Y3QgcmVwb3NpdG9yeSAqciwgY29uc3QgY2hhciAqb2JqZWN0X2Rpciwgc2l6ZV90IGJhdGNoX3NpemUpCitpbnQgbWlkeF9yZXBhY2soc3RydWN0IHJlcG9zaXRvcnkgKnIsIGNvbnN0IGNoYXIgKm9iamVjdF9kaXIsIHNpemVfdCBiYXRjaF9zaXplLCB1bnNpZ25lZCBmbGFncykKIHsKIAlpbnQgcmVzdWx0ID0gMDsKIAl1aW50MzJfdCBpOwpAQCAtMTM0MSw2ICsxMzczLDEyIEBACiAJc3RyYnVmX2FkZHN0cigmYmFzZV9uYW1lLCBvYmplY3RfZGlyKTsKIAlzdHJidWZfYWRkc3RyKCZiYXNlX25hbWUsICIvcGFjay9wYWNrIik7CiAJYXJndl9hcnJheV9wdXNoKCZjbWQuYXJncywgYmFzZV9uYW1lLmJ1Zik7CisKKwlpZiAoZmxhZ3MgJiBNSURYX1BST0dSRVNTKQorCQlhcmd2X2FycmF5X3B1c2goJmNtZC5hcmdzLCAiLS1wcm9ncmVzcyIpOworCWVsc2UKKwkJYXJndl9hcnJheV9wdXNoKCZjbWQuYXJncywgIi1xIik7CisKIAlzdHJidWZfcmVsZWFzZSgmYmFzZV9uYW1lKTsKIAogCWNtZC5naXRfY21kID0gMTsKQEAgLTEzNzEsNyArMTQwOSw3IEBACiAJCWdvdG8gY2xlYW51cDsKIAl9CiAKLQlyZXN1bHQgPSB3cml0ZV9taWR4X2ludGVybmFsKG9iamVjdF9kaXIsIG0sIE5VTEwpOworCXJlc3VsdCA9IHdyaXRlX21pZHhfaW50ZXJuYWwob2JqZWN0X2RpciwgbSwgTlVMTCwgZmxhZ3MpOwogCW0gPSBOVUxMOwogCiBjbGVhbnVwOgpkaWZmIC0tZ2l0IGEvbWlkeC5oIGIvbWlkeC5oCmluZGV4IGYwYWU2NTYuLmU2ZmEzNTYgMTAwNjQ0Ci0tLSBhL21pZHguaAorKysgYi9taWR4LmgKQEAgLTM3LDYgKzM3LDggQEAKIAljaGFyIG9iamVjdF9kaXJbRkxFWF9BUlJBWV07CiB9OwogCisjZGVmaW5lIE1JRFhfUFJPR1JFU1MgICAgICgxIDw8IDApCisKIHN0cnVjdCBtdWx0aV9wYWNrX2luZGV4ICpsb2FkX211bHRpX3BhY2tfaW5kZXgoY29uc3QgY2hhciAqb2JqZWN0X2RpciwgaW50IGxvY2FsKTsKIGludCBwcmVwYXJlX21pZHhfcGFjayhzdHJ1Y3QgcmVwb3NpdG9yeSAqciwgc3RydWN0IG11bHRpX3BhY2tfaW5kZXggKm0sIHVpbnQzMl90IHBhY2tfaW50X2lkKTsKIGludCBic2VhcmNoX21pZHgoY29uc3Qgc3RydWN0IG9iamVjdF9pZCAqb2lkLCBzdHJ1Y3QgbXVsdGlfcGFja19pbmRleCAqbSwgdWludDMyX3QgKnJlc3VsdCk7CkBAIC00NywxMSArNDksMTEgQEAKIGludCBtaWR4X2NvbnRhaW5zX3BhY2soc3RydWN0IG11bHRpX3BhY2tfaW5kZXggKm0sIGNvbnN0IGNoYXIgKmlkeF9vcl9wYWNrX25hbWUpOwogaW50IHByZXBhcmVfbXVsdGlfcGFja19pbmRleF9vbmUoc3RydWN0IHJlcG9zaXRvcnkgKnIsIGNvbnN0IGNoYXIgKm9iamVjdF9kaXIsIGludCBsb2NhbCk7CiAKLWludCB3cml0ZV9taWR4X2ZpbGUoY29uc3QgY2hhciAqb2JqZWN0X2Rpcik7CitpbnQgd3JpdGVfbWlkeF9maWxlKGNvbnN0IGNoYXIgKm9iamVjdF9kaXIsIHVuc2lnbmVkIGZsYWdzKTsKIHZvaWQgY2xlYXJfbWlkeF9maWxlKHN0cnVjdCByZXBvc2l0b3J5ICpyKTsKLWludCB2ZXJpZnlfbWlkeF9maWxlKHN0cnVjdCByZXBvc2l0b3J5ICpyLCBjb25zdCBjaGFyICpvYmplY3RfZGlyKTsKLWludCBleHBpcmVfbWlkeF9wYWNrcyhzdHJ1Y3QgcmVwb3NpdG9yeSAqciwgY29uc3QgY2hhciAqb2JqZWN0X2Rpcik7Ci1pbnQgbWlkeF9yZXBhY2soc3RydWN0IHJlcG9zaXRvcnkgKnIsIGNvbnN0IGNoYXIgKm9iamVjdF9kaXIsIHNpemVfdCBiYXRjaF9zaXplKTsKK2ludCB2ZXJpZnlfbWlkeF9maWxlKHN0cnVjdCByZXBvc2l0b3J5ICpyLCBjb25zdCBjaGFyICpvYmplY3RfZGlyLCB1bnNpZ25lZCBmbGFncyk7CitpbnQgZXhwaXJlX21pZHhfcGFja3Moc3RydWN0IHJlcG9zaXRvcnkgKnIsIGNvbnN0IGNoYXIgKm9iamVjdF9kaXIsIHVuc2lnbmVkIGZsYWdzKTsKK2ludCBtaWR4X3JlcGFjayhzdHJ1Y3QgcmVwb3NpdG9yeSAqciwgY29uc3QgY2hhciAqb2JqZWN0X2Rpciwgc2l6ZV90IGJhdGNoX3NpemUsIHVuc2lnbmVkIGZsYWdzKTsKIAogdm9pZCBjbG9zZV9taWR4KHN0cnVjdCBtdWx0aV9wYWNrX2luZGV4ICptKTsKIApkaWZmIC0tZ2l0IGEvbmFtZS1oYXNoLmMgYi9uYW1lLWhhc2guYwppbmRleCA2OTU5MDg2Li5mYjUyNmEzIDEwMDY0NAotLS0gYS9uYW1lLWhhc2guYworKysgYi9uYW1lLWhhc2guYwpAQCAtMTcsMTQgKzE3LDE2IEBACiB9OwogCiBzdGF0aWMgaW50IGRpcl9lbnRyeV9jbXAoY29uc3Qgdm9pZCAqdW51c2VkX2NtcF9kYXRhLAotCQkJIGNvbnN0IHZvaWQgKmVudHJ5LAotCQkJIGNvbnN0IHZvaWQgKmVudHJ5X29yX2tleSwKKwkJCSBjb25zdCBzdHJ1Y3QgaGFzaG1hcF9lbnRyeSAqZXB0ciwKKwkJCSBjb25zdCBzdHJ1Y3QgaGFzaG1hcF9lbnRyeSAqZW50cnlfb3Jfa2V5LAogCQkJIGNvbnN0IHZvaWQgKmtleWRhdGEpCiB7Ci0JY29uc3Qgc3RydWN0IGRpcl9lbnRyeSAqZTEgPSBlbnRyeTsKLQljb25zdCBzdHJ1Y3QgZGlyX2VudHJ5ICplMiA9IGVudHJ5X29yX2tleTsKKwljb25zdCBzdHJ1Y3QgZGlyX2VudHJ5ICplMSwgKmUyOwogCWNvbnN0IGNoYXIgKm5hbWUgPSBrZXlkYXRhOwogCisJZTEgPSBjb250YWluZXJfb2YoZXB0ciwgY29uc3Qgc3RydWN0IGRpcl9lbnRyeSwgZW50KTsKKwllMiA9IGNvbnRhaW5lcl9vZihlbnRyeV9vcl9rZXksIGNvbnN0IHN0cnVjdCBkaXJfZW50cnksIGVudCk7CisKIAlyZXR1cm4gZTEtPm5hbWVsZW4gIT0gZTItPm5hbWVsZW4gfHwgc3RybmNhc2VjbXAoZTEtPm5hbWUsCiAJCQluYW1lID8gbmFtZSA6IGUyLT5uYW1lLCBlMS0+bmFtZWxlbik7CiB9CkBAIC0zMyw5ICszNSw5IEBACiAJCWNvbnN0IGNoYXIgKm5hbWUsIHVuc2lnbmVkIGludCBuYW1lbGVuLCB1bnNpZ25lZCBpbnQgaGFzaCkKIHsKIAlzdHJ1Y3QgZGlyX2VudHJ5IGtleTsKLQloYXNobWFwX2VudHJ5X2luaXQoJmtleSwgaGFzaCk7CisJaGFzaG1hcF9lbnRyeV9pbml0KCZrZXkuZW50LCBoYXNoKTsKIAlrZXkubmFtZWxlbiA9IG5hbWVsZW47Ci0JcmV0dXJuIGhhc2htYXBfZ2V0KCZpc3RhdGUtPmRpcl9oYXNoLCAma2V5LCBuYW1lKTsKKwlyZXR1cm4gaGFzaG1hcF9nZXRfZW50cnkoJmlzdGF0ZS0+ZGlyX2hhc2gsICZrZXksIGVudCwgbmFtZSk7CiB9CiAKIHN0YXRpYyBzdHJ1Y3QgZGlyX2VudHJ5ICpmaW5kX2Rpcl9lbnRyeShzdHJ1Y3QgaW5kZXhfc3RhdGUgKmlzdGF0ZSwKQEAgLTY4LDkgKzcwLDkgQEAKIAlpZiAoIWRpcikgewogCQkvKiBub3QgZm91bmQsIGNyZWF0ZSBpdCBhbmQgYWRkIHRvIGhhc2ggdGFibGUgKi8KIAkJRkxFWF9BTExPQ19NRU0oZGlyLCBuYW1lLCBjZS0+bmFtZSwgbmFtZWxlbik7Ci0JCWhhc2htYXBfZW50cnlfaW5pdChkaXIsIG1lbWloYXNoKGNlLT5uYW1lLCBuYW1lbGVuKSk7CisJCWhhc2htYXBfZW50cnlfaW5pdCgmZGlyLT5lbnQsIG1lbWloYXNoKGNlLT5uYW1lLCBuYW1lbGVuKSk7CiAJCWRpci0+bmFtZWxlbiA9IG5hbWVsZW47Ci0JCWhhc2htYXBfYWRkKCZpc3RhdGUtPmRpcl9oYXNoLCBkaXIpOworCQloYXNobWFwX2FkZCgmaXN0YXRlLT5kaXJfaGFzaCwgJmRpci0+ZW50KTsKIAogCQkvKiByZWN1cnNpdmVseSBhZGQgbWlzc2luZyBwYXJlbnQgZGlyZWN0b3JpZXMgKi8KIAkJZGlyLT5wYXJlbnQgPSBoYXNoX2Rpcl9lbnRyeShpc3RhdGUsIGNlLCBuYW1lbGVuKTsKQEAgLTk1LDcgKzk3LDcgQEAKIAlzdHJ1Y3QgZGlyX2VudHJ5ICpkaXIgPSBoYXNoX2Rpcl9lbnRyeShpc3RhdGUsIGNlLCBjZV9uYW1lbGVuKGNlKSk7CiAJd2hpbGUgKGRpciAmJiAhKC0tZGlyLT5ucikpIHsKIAkJc3RydWN0IGRpcl9lbnRyeSAqcGFyZW50ID0gZGlyLT5wYXJlbnQ7Ci0JCWhhc2htYXBfcmVtb3ZlKCZpc3RhdGUtPmRpcl9oYXNoLCBkaXIsIE5VTEwpOworCQloYXNobWFwX3JlbW92ZSgmaXN0YXRlLT5kaXJfaGFzaCwgJmRpci0+ZW50LCBOVUxMKTsKIAkJZnJlZShkaXIpOwogCQlkaXIgPSBwYXJlbnQ7CiAJfQpAQCAtMTA2LDIwICsxMDgsMjMgQEAKIAlpZiAoY2UtPmNlX2ZsYWdzICYgQ0VfSEFTSEVEKQogCQlyZXR1cm47CiAJY2UtPmNlX2ZsYWdzIHw9IENFX0hBU0hFRDsKLQloYXNobWFwX2VudHJ5X2luaXQoY2UsIG1lbWloYXNoKGNlLT5uYW1lLCBjZV9uYW1lbGVuKGNlKSkpOwotCWhhc2htYXBfYWRkKCZpc3RhdGUtPm5hbWVfaGFzaCwgY2UpOworCWhhc2htYXBfZW50cnlfaW5pdCgmY2UtPmVudCwgbWVtaWhhc2goY2UtPm5hbWUsIGNlX25hbWVsZW4oY2UpKSk7CisJaGFzaG1hcF9hZGQoJmlzdGF0ZS0+bmFtZV9oYXNoLCAmY2UtPmVudCk7CiAKIAlpZiAoaWdub3JlX2Nhc2UpCiAJCWFkZF9kaXJfZW50cnkoaXN0YXRlLCBjZSk7CiB9CiAKIHN0YXRpYyBpbnQgY2FjaGVfZW50cnlfY21wKGNvbnN0IHZvaWQgKnVudXNlZF9jbXBfZGF0YSwKLQkJCSAgIGNvbnN0IHZvaWQgKmVudHJ5LAotCQkJICAgY29uc3Qgdm9pZCAqZW50cnlfb3Jfa2V5LAorCQkJICAgY29uc3Qgc3RydWN0IGhhc2htYXBfZW50cnkgKmVwdHIsCisJCQkgICBjb25zdCBzdHJ1Y3QgaGFzaG1hcF9lbnRyeSAqZW50cnlfb3Jfa2V5LAogCQkJICAgY29uc3Qgdm9pZCAqcmVtb3ZlKQogewotCWNvbnN0IHN0cnVjdCBjYWNoZV9lbnRyeSAqY2UxID0gZW50cnk7Ci0JY29uc3Qgc3RydWN0IGNhY2hlX2VudHJ5ICpjZTIgPSBlbnRyeV9vcl9rZXk7CisJY29uc3Qgc3RydWN0IGNhY2hlX2VudHJ5ICpjZTEsICpjZTI7CisKKwljZTEgPSBjb250YWluZXJfb2YoZXB0ciwgY29uc3Qgc3RydWN0IGNhY2hlX2VudHJ5LCBlbnQpOworCWNlMiA9IGNvbnRhaW5lcl9vZihlbnRyeV9vcl9rZXksIGNvbnN0IHN0cnVjdCBjYWNoZV9lbnRyeSwgZW50KTsKKwogCS8qCiAJICogRm9yIHJlbW92ZV9uYW1lX2hhc2gsIGZpbmQgdGhlIGV4YWN0IGVudHJ5IChwb2ludGVyIGVxdWFsaXR5KTsgZm9yCiAJICogaW5kZXhfZmlsZV9leGlzdHMsIGZpbmQgYWxsIGVudHJpZXMgd2l0aCBtYXRjaGluZyBoYXNoIGNvZGUgYW5kCkBAIC0xMzMsNyArMTM4LDcgQEAKIAogLyoKICAqIFNldCBhIG1pbmltdW0gbnVtYmVyIG9mIGNhY2hlX2VudHJpZXMgdGhhdCB3ZSB3aWxsIGhhbmRsZSBwZXIKLSAqIHRocmVhZCBhbmQgdXNlIHRoYXQgdG8gZGVjaWRlIGhvdyBtYW55IHRocmVhZHMgdG8gcnVuICh1cHRvCisgKiB0aHJlYWQgYW5kIHVzZSB0aGF0IHRvIGRlY2lkZSBob3cgbWFueSB0aHJlYWRzIHRvIHJ1biAodXAgdG8KICAqIHRoZSBudW1iZXIgb24gdGhlIHN5c3RlbSkuCiAgKgogICogRm9yIGd1aWRhbmNlIHNldHRpbmcgdGhlIGxvd2VyIHBlci10aHJlYWQgYm91bmQsIHNlZToKQEAgLTIxMyw3ICsyMTgsNyBAQAogICogSG93ZXZlciwgdGhlIGhhc2htYXAgaXMgZ29pbmcgdG8gcHV0IGl0ZW1zIGludG8gYnVja2V0CiAgKiBjaGFpbnMgYmFzZWQgb24gdGhlaXIgaGFzaCB2YWx1ZXMuICBVc2UgdGhhdCB0byBjcmVhdGUgbgogICogbXV0ZXhlcyBhbmQgbG9jayBvbiBtdXRleFtidWNrZXQoaGFzaCkgJSBuXS4gIFRoaXMgd2lsbAotICogZGVjcmVhc2UgdGhlIGNvbGxpc2lvbiByYXRlIGJ5IChob3BlZnVsbHkpIGJ5IGEgZmFjdG9yIG9mIG4uCisgKiBkZWNyZWFzZSB0aGUgY29sbGlzaW9uIHJhdGUgYnkgKGhvcGVmdWxseSkgYSBmYWN0b3Igb2Ygbi4KICAqLwogc3RhdGljIHZvaWQgaW5pdF9kaXJfbXV0ZXgodm9pZCkKIHsKQEAgLTI4MCwxMCArMjg1LDEwIEBACiAJZGlyID0gZmluZF9kaXJfZW50cnlfX2hhc2goaXN0YXRlLCBwcmVmaXgtPmJ1ZiwgcHJlZml4LT5sZW4sIGhhc2gpOwogCWlmICghZGlyKSB7CiAJCUZMRVhfQUxMT0NfTUVNKGRpciwgbmFtZSwgcHJlZml4LT5idWYsIHByZWZpeC0+bGVuKTsKLQkJaGFzaG1hcF9lbnRyeV9pbml0KGRpciwgaGFzaCk7CisJCWhhc2htYXBfZW50cnlfaW5pdCgmZGlyLT5lbnQsIGhhc2gpOwogCQlkaXItPm5hbWVsZW4gPSBwcmVmaXgtPmxlbjsKIAkJZGlyLT5wYXJlbnQgPSBwYXJlbnQ7Ci0JCWhhc2htYXBfYWRkKCZpc3RhdGUtPmRpcl9oYXNoLCBkaXIpOworCQloYXNobWFwX2FkZCgmaXN0YXRlLT5kaXJfaGFzaCwgJmRpci0+ZW50KTsKIAogCQlpZiAocGFyZW50KSB7CiAJCQl1bmxvY2tfZGlyX211dGV4KGxvY2tfbnIpOwpAQCAtNDcyLDggKzQ3Nyw4IEBACiAJZm9yIChrID0gMDsgayA8IGQtPmlzdGF0ZS0+Y2FjaGVfbnI7IGsrKykgewogCQlzdHJ1Y3QgY2FjaGVfZW50cnkgKmNlX2sgPSBkLT5pc3RhdGUtPmNhY2hlW2tdOwogCQljZV9rLT5jZV9mbGFncyB8PSBDRV9IQVNIRUQ7Ci0JCWhhc2htYXBfZW50cnlfaW5pdChjZV9rLCBkLT5sYXp5X2VudHJpZXNba10uaGFzaF9uYW1lKTsKLQkJaGFzaG1hcF9hZGQoJmQtPmlzdGF0ZS0+bmFtZV9oYXNoLCBjZV9rKTsKKwkJaGFzaG1hcF9lbnRyeV9pbml0KCZjZV9rLT5lbnQsIGQtPmxhenlfZW50cmllc1trXS5oYXNoX25hbWUpOworCQloYXNobWFwX2FkZCgmZC0+aXN0YXRlLT5uYW1lX2hhc2gsICZjZV9rLT5lbnQpOwogCX0KIAogCXJldHVybiBOVUxMOwpAQCAtNjI1LDcgKzYzMCw3IEBACiAJaWYgKCFpc3RhdGUtPm5hbWVfaGFzaF9pbml0aWFsaXplZCB8fCAhKGNlLT5jZV9mbGFncyAmIENFX0hBU0hFRCkpCiAJCXJldHVybjsKIAljZS0+Y2VfZmxhZ3MgJj0gfkNFX0hBU0hFRDsKLQloYXNobWFwX3JlbW92ZSgmaXN0YXRlLT5uYW1lX2hhc2gsIGNlLCBjZSk7CisJaGFzaG1hcF9yZW1vdmUoJmlzdGF0ZS0+bmFtZV9oYXNoLCAmY2UtPmVudCwgY2UpOwogCiAJaWYgKGlnbm9yZV9jYXNlKQogCQlyZW1vdmVfZGlyX2VudHJ5KGlzdGF0ZSwgY2UpOwpAQCAtNzAyLDE1ICs3MDcsMTUgQEAKIHN0cnVjdCBjYWNoZV9lbnRyeSAqaW5kZXhfZmlsZV9leGlzdHMoc3RydWN0IGluZGV4X3N0YXRlICppc3RhdGUsIGNvbnN0IGNoYXIgKm5hbWUsIGludCBuYW1lbGVuLCBpbnQgaWNhc2UpCiB7CiAJc3RydWN0IGNhY2hlX2VudHJ5ICpjZTsKKwl1bnNpZ25lZCBpbnQgaGFzaCA9IG1lbWloYXNoKG5hbWUsIG5hbWVsZW4pOwogCiAJbGF6eV9pbml0X25hbWVfaGFzaChpc3RhdGUpOwogCi0JY2UgPSBoYXNobWFwX2dldF9mcm9tX2hhc2goJmlzdGF0ZS0+bmFtZV9oYXNoLAotCQkJCSAgIG1lbWloYXNoKG5hbWUsIG5hbWVsZW4pLCBOVUxMKTsKLQl3aGlsZSAoY2UpIHsKKwljZSA9IGhhc2htYXBfZ2V0X2VudHJ5X2Zyb21faGFzaCgmaXN0YXRlLT5uYW1lX2hhc2gsIGhhc2gsIE5VTEwsCisJCQkJCSBzdHJ1Y3QgY2FjaGVfZW50cnksIGVudCk7CisJaGFzaG1hcF9mb3JfZWFjaF9lbnRyeV9mcm9tKCZpc3RhdGUtPm5hbWVfaGFzaCwgY2UsIGVudCkgewogCQlpZiAoc2FtZV9uYW1lKGNlLCBuYW1lLCBuYW1lbGVuLCBpY2FzZSkpCiAJCQlyZXR1cm4gY2U7Ci0JCWNlID0gaGFzaG1hcF9nZXRfbmV4dCgmaXN0YXRlLT5uYW1lX2hhc2gsIGNlKTsKIAl9CiAJcmV0dXJuIE5VTEw7CiB9CkBAIC03MjEsNiArNzI2LDYgQEAKIAkJcmV0dXJuOwogCWlzdGF0ZS0+bmFtZV9oYXNoX2luaXRpYWxpemVkID0gMDsKIAotCWhhc2htYXBfZnJlZSgmaXN0YXRlLT5uYW1lX2hhc2gsIDApOwotCWhhc2htYXBfZnJlZSgmaXN0YXRlLT5kaXJfaGFzaCwgMSk7CisJaGFzaG1hcF9mcmVlKCZpc3RhdGUtPm5hbWVfaGFzaCk7CisJaGFzaG1hcF9mcmVlX2VudHJpZXMoJmlzdGF0ZS0+ZGlyX2hhc2gsIHN0cnVjdCBkaXJfZW50cnksIGVudCk7CiB9CmRpZmYgLS1naXQgYS9ub3Rlcy5jIGIvbm90ZXMuYwppbmRleCA3NWMwMjhiLi4wM2U3ZDBjIDEwMDY0NAotLS0gYS9ub3Rlcy5jCisrKyBiL25vdGVzLmMKQEAgLTI2OSw4ICsyNjksMTAgQEAKIAkJY2FzZSBQVFJfVFlQRV9OT1RFOgogCQkJaWYgKG9pZGVxKCZsLT5rZXlfb2lkLCAmZW50cnktPmtleV9vaWQpKSB7CiAJCQkJLyogc2tpcCBjb25jYXRlbmF0aW9uIGlmIGwgPT0gZW50cnkgKi8KLQkJCQlpZiAob2lkZXEoJmwtPnZhbF9vaWQsICZlbnRyeS0+dmFsX29pZCkpCisJCQkJaWYgKG9pZGVxKCZsLT52YWxfb2lkLCAmZW50cnktPnZhbF9vaWQpKSB7CisJCQkJCWZyZWUoZW50cnkpOwogCQkJCQlyZXR1cm4gMDsKKwkJCQl9CiAKIAkJCQlyZXQgPSBjb21iaW5lX25vdGVzKCZsLT52YWxfb2lkLAogCQkJCQkJICAgICZlbnRyeS0+dmFsX29pZCk7CkBAIC00NTgsNyArNDYwLDcgQEAKIAkJCWRpZSgiRmFpbGVkIHRvIGxvYWQgJXMgJXMgaW50byBub3RlcyB0cmVlICIKIAkJCSAgICAiZnJvbSAlcyIsCiAJCQkgICAgdHlwZSA9PSBQVFJfVFlQRV9OT1RFID8gIm5vdGUiIDogInN1YnRyZWUiLAotCQkJICAgIG9pZF90b19oZXgoJmwtPmtleV9vaWQpLCB0LT5yZWYpOworCQkJICAgIG9pZF90b19oZXgoJm9iamVjdF9vaWQpLCB0LT5yZWYpOwogCiAJCWNvbnRpbnVlOwogCmRpZmYgLS1naXQgYS9vYmplY3QuYyBiL29iamVjdC5jCmluZGV4IDA3YmRkNWIuLjNiOGI4YzUgMTAwNjQ0Ci0tLSBhL29iamVjdC5jCisrKyBiL29iamVjdC5jCkBAIC03LDcgKzcsNiBAQAogI2luY2x1ZGUgImNvbW1pdC5oIgogI2luY2x1ZGUgInRhZy5oIgogI2luY2x1ZGUgImFsbG9jLmgiCi0jaW5jbHVkZSAib2JqZWN0LXN0b3JlLmgiCiAjaW5jbHVkZSAicGFja2ZpbGUuaCIKICNpbmNsdWRlICJjb21taXQtZ3JhcGguaCIKIApkaWZmIC0tZ2l0IGEvb2JqZWN0LmggYi9vYmplY3QuaAppbmRleCAwMTIwODkyLi4yNWY1YWIzIDEwMDY0NAotLS0gYS9vYmplY3QuaAorKysgYi9vYmplY3QuaApAQCAtNjgsNyArNjgsOCBAQAogICogYmlzZWN0LmM6ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDE2CiAgKiBidW5kbGUuYzogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgMTYKICAqIGh0dHAtcHVzaC5jOiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAxNi0tLS0tMTkKLSAqIGNvbW1pdC1yZWFjaC5jOiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgMTUtLS0tLS0tMTkKKyAqIGNvbW1pdC1ncmFwaC5jOiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgMTUKKyAqIGNvbW1pdC1yZWFjaC5jOiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAxNi0tLS0tMTkKICAqIHNoYTEtbmFtZS5jOiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAyMAogICogbGlzdC1vYmplY3RzLWZpbHRlci5jOiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgMjEKICAqIGJ1aWx0aW4vZnNjay5jOiAgICAgICAgICAgMC0tMwpkaWZmIC0tZ2l0IGEvb2lkbWFwLmMgYi9vaWRtYXAuYwppbmRleCA2ZDZlODQwLi40MjNhYTAxIDEwMDY0NAotLS0gYS9vaWRtYXAuYworKysgYi9vaWRtYXAuYwpAQCAtMiwxNCArMiwxOCBAQAogI2luY2x1ZGUgIm9pZG1hcC5oIgogCiBzdGF0aWMgaW50IG9pZG1hcF9uZXEoY29uc3Qgdm9pZCAqaGFzaG1hcF9jbXBfZm5fZGF0YSwKLQkJICAgICAgY29uc3Qgdm9pZCAqZW50cnksIGNvbnN0IHZvaWQgKmVudHJ5X29yX2tleSwKKwkJICAgICAgY29uc3Qgc3RydWN0IGhhc2htYXBfZW50cnkgKmUxLAorCQkgICAgICBjb25zdCBzdHJ1Y3QgaGFzaG1hcF9lbnRyeSAqZTIsCiAJCSAgICAgIGNvbnN0IHZvaWQgKmtleWRhdGEpCiB7Ci0JY29uc3Qgc3RydWN0IG9pZG1hcF9lbnRyeSAqZW50cnlfID0gZW50cnk7CisJY29uc3Qgc3RydWN0IG9pZG1hcF9lbnRyeSAqYSwgKmI7CisKKwlhID0gY29udGFpbmVyX29mKGUxLCBjb25zdCBzdHJ1Y3Qgb2lkbWFwX2VudHJ5LCBpbnRlcm5hbF9lbnRyeSk7CisJYiA9IGNvbnRhaW5lcl9vZihlMiwgY29uc3Qgc3RydWN0IG9pZG1hcF9lbnRyeSwgaW50ZXJuYWxfZW50cnkpOworCiAJaWYgKGtleWRhdGEpCi0JCXJldHVybiAhb2lkZXEoJmVudHJ5Xy0+b2lkLCAoY29uc3Qgc3RydWN0IG9iamVjdF9pZCAqKSBrZXlkYXRhKTsKLQlyZXR1cm4gIW9pZGVxKCZlbnRyeV8tPm9pZCwKLQkJICAgICAgJigoY29uc3Qgc3RydWN0IG9pZG1hcF9lbnRyeSAqKSBlbnRyeV9vcl9rZXkpLT5vaWQpOworCQlyZXR1cm4gIW9pZGVxKCZhLT5vaWQsIChjb25zdCBzdHJ1Y3Qgb2JqZWN0X2lkICopIGtleWRhdGEpOworCXJldHVybiAhb2lkZXEoJmEtPm9pZCwgJmItPm9pZCk7CiB9CiAKIHZvaWQgb2lkbWFwX2luaXQoc3RydWN0IG9pZG1hcCAqbWFwLCBzaXplX3QgaW5pdGlhbF9zaXplKQpAQCAtMjEsNyArMjUsOSBAQAogewogCWlmICghbWFwKQogCQlyZXR1cm47Ci0JaGFzaG1hcF9mcmVlKCZtYXAtPm1hcCwgZnJlZV9lbnRyaWVzKTsKKworCS8qIFRPRE86IG1ha2Ugb2lkbWFwIGl0c2VsZiBub3QgZGVwZW5kIG9uIHN0cnVjdCBsYXlvdXRzICovCisJaGFzaG1hcF9mcmVlXygmbWFwLT5tYXAsIGZyZWVfZW50cmllcyA/IDAgOiAtMSk7CiB9CiAKIHZvaWQgKm9pZG1hcF9nZXQoY29uc3Qgc3RydWN0IG9pZG1hcCAqbWFwLCBjb25zdCBzdHJ1Y3Qgb2JqZWN0X2lkICprZXkpCkBAIC01MSw1ICs1Nyw1IEBACiAJCW9pZG1hcF9pbml0KG1hcCwgMCk7CiAKIAloYXNobWFwX2VudHJ5X2luaXQoJnRvX3B1dC0+aW50ZXJuYWxfZW50cnksIG9pZGhhc2goJnRvX3B1dC0+b2lkKSk7Ci0JcmV0dXJuIGhhc2htYXBfcHV0KCZtYXAtPm1hcCwgdG9fcHV0KTsKKwlyZXR1cm4gaGFzaG1hcF9wdXQoJm1hcC0+bWFwLCAmdG9fcHV0LT5pbnRlcm5hbF9lbnRyeSk7CiB9CmRpZmYgLS1naXQgYS9vaWRtYXAuaCBiL29pZG1hcC5oCmluZGV4IDdhOTM5NDYuLmM2NmE4M2EgMTAwNjQ0Ci0tLSBhL29pZG1hcC5oCisrKyBiL29pZG1hcC5oCkBAIC03OCwxNCArNzgsMTYgQEAKIAogc3RhdGljIGlubGluZSB2b2lkICpvaWRtYXBfaXRlcl9uZXh0KHN0cnVjdCBvaWRtYXBfaXRlciAqaXRlcikKIHsKLQlyZXR1cm4gaGFzaG1hcF9pdGVyX25leHQoJml0ZXItPmhfaXRlcik7CisJLyogVE9ETzogdGhpcyBBUEkgY291bGQgYmUgcmV3b3JrZWQgdG8gZG8gY29tcGlsZS10aW1lIHR5cGUgY2hlY2tzICovCisJcmV0dXJuICh2b2lkICopaGFzaG1hcF9pdGVyX25leHQoJml0ZXItPmhfaXRlcik7CiB9CiAKIHN0YXRpYyBpbmxpbmUgdm9pZCAqb2lkbWFwX2l0ZXJfZmlyc3Qoc3RydWN0IG9pZG1hcCAqbWFwLAogCQkJCSAgICAgIHN0cnVjdCBvaWRtYXBfaXRlciAqaXRlcikKIHsKIAlvaWRtYXBfaXRlcl9pbml0KG1hcCwgaXRlcik7Ci0JcmV0dXJuIG9pZG1hcF9pdGVyX25leHQoaXRlcik7CisJLyogVE9ETzogdGhpcyBBUEkgY291bGQgYmUgcmV3b3JrZWQgdG8gZG8gY29tcGlsZS10aW1lIHR5cGUgY2hlY2tzICovCisJcmV0dXJuICh2b2lkICopb2lkbWFwX2l0ZXJfbmV4dChpdGVyKTsKIH0KIAogI2VuZGlmCmRpZmYgLS1naXQgYS9wYWNrLWJpdG1hcC13cml0ZS5jIGIvcGFjay1iaXRtYXAtd3JpdGUuYwppbmRleCBmYTc4YTQ2Li5hN2E0OTY0IDEwMDY0NAotLS0gYS9wYWNrLWJpdG1hcC13cml0ZS5jCisrKyBiL3BhY2stYml0bWFwLXdyaXRlLmMKQEAgLTE0NCw3ICsxNDQsNyBAQAogCiBzdGF0aWMgdWludDMyX3QgZmluZF9vYmplY3RfcG9zKGNvbnN0IHN0cnVjdCBvYmplY3RfaWQgKm9pZCkKIHsKLQlzdHJ1Y3Qgb2JqZWN0X2VudHJ5ICplbnRyeSA9IHBhY2tsaXN0X2ZpbmQod3JpdGVyLnRvX3BhY2ssIG9pZCwgTlVMTCk7CisJc3RydWN0IG9iamVjdF9lbnRyeSAqZW50cnkgPSBwYWNrbGlzdF9maW5kKHdyaXRlci50b19wYWNrLCBvaWQpOwogCiAJaWYgKCFlbnRyeSkgewogCQlkaWUoIkZhaWxlZCB0byB3cml0ZSBiaXRtYXAgaW5kZXguIFBhY2tmaWxlIGRvZXNuJ3QgaGF2ZSBmdWxsIGNsb3N1cmUgIgpkaWZmIC0tZ2l0IGEvcGFjay1iaXRtYXAuYyBiL3BhY2stYml0bWFwLmMKaW5kZXggZWQyYmVmYS4uZTA3Yzc5OCAxMDA2NDQKLS0tIGEvcGFjay1iaXRtYXAuYworKysgYi9wYWNrLWJpdG1hcC5jCkBAIC03MDksOSArNzA5LDcgQEAKIAkJCWVsc2UKIAkJCQlvYmplY3RfbGlzdF9pbnNlcnQob2JqZWN0LCAmd2FudHMpOwogCi0JCQlpZiAoIXRhZy0+dGFnZ2VkKQotCQkJCWRpZSgiYmFkIHRhZyIpOwotCQkJb2JqZWN0ID0gcGFyc2Vfb2JqZWN0X29yX2RpZSgmdGFnLT50YWdnZWQtPm9pZCwgTlVMTCk7CisJCQlvYmplY3QgPSBwYXJzZV9vYmplY3Rfb3JfZGllKGdldF90YWdnZWRfb2lkKHRhZyksIE5VTEwpOwogCQl9CiAKIAkJaWYgKG9iamVjdC0+ZmxhZ3MgJiBVTklOVEVSRVNUSU5HKQpAQCAtMTA2Myw3ICsxMDYxLDcgQEAKIAogCQllbnRyeSA9ICZiaXRtYXBfZ2l0LT5wYWNrLT5yZXZpbmRleFtpXTsKIAkJbnRoX3BhY2tlZF9vYmplY3Rfb2lkKCZvaWQsIGJpdG1hcF9naXQtPnBhY2ssIGVudHJ5LT5ucik7Ci0JCW9lID0gcGFja2xpc3RfZmluZChtYXBwaW5nLCAmb2lkLCBOVUxMKTsKKwkJb2UgPSBwYWNrbGlzdF9maW5kKG1hcHBpbmcsICZvaWQpOwogCiAJCWlmIChvZSkKIAkJCXJlcG9zaXRpb25baV0gPSBvZV9pbl9wYWNrX3BvcyhtYXBwaW5nLCBvZSkgKyAxOwpkaWZmIC0tZ2l0IGEvcGFjay1iaXRtYXAuaCBiL3BhY2stYml0bWFwLmgKaW5kZXggMDBkZTNlYy4uNDY2YzVhZiAxMDA2NDQKLS0tIGEvcGFjay1iaXRtYXAuaAorKysgYi9wYWNrLWJpdG1hcC5oCkBAIC05LDE2ICs5LDE2IEBACiBzdHJ1Y3QgcmVwb3NpdG9yeTsKIHN0cnVjdCByZXZfaW5mbzsKIAorc3RhdGljIGNvbnN0IGNoYXIgQklUTUFQX0lEWF9TSUdOQVRVUkVbXSA9IHsnQicsICdJJywgJ1QnLCAnTSd9OworCiBzdHJ1Y3QgYml0bWFwX2Rpc2tfaGVhZGVyIHsKLQljaGFyIG1hZ2ljWzRdOworCWNoYXIgbWFnaWNbQVJSQVlfU0laRShCSVRNQVBfSURYX1NJR05BVFVSRSldOwogCXVpbnQxNl90IHZlcnNpb247CiAJdWludDE2X3Qgb3B0aW9uczsKIAl1aW50MzJfdCBlbnRyeV9jb3VudDsKIAl1bnNpZ25lZCBjaGFyIGNoZWNrc3VtW0dJVF9NQVhfUkFXU1pdOwogfTsKIAotc3RhdGljIGNvbnN0IGNoYXIgQklUTUFQX0lEWF9TSUdOQVRVUkVbXSA9IHsnQicsICdJJywgJ1QnLCAnTSd9OwotCiAjZGVmaW5lIE5FRURTX0JJVE1BUCAoMXU8PDIyKQogCiBlbnVtIHBhY2tfYml0bWFwX29wdHMgewpkaWZmIC0tZ2l0IGEvcGFjay1vYmplY3RzLmMgYi9wYWNrLW9iamVjdHMuYwppbmRleCA1MjU2MDI5Li41ZTVhM2M2IDEwMDY0NAotLS0gYS9wYWNrLW9iamVjdHMuYworKysgYi9wYWNrLW9iamVjdHMuYwpAQCAtNjgsOCArNjgsNyBAQAogfQogCiBzdHJ1Y3Qgb2JqZWN0X2VudHJ5ICpwYWNrbGlzdF9maW5kKHN0cnVjdCBwYWNraW5nX2RhdGEgKnBkYXRhLAotCQkJCSAgIGNvbnN0IHN0cnVjdCBvYmplY3RfaWQgKm9pZCwKLQkJCQkgICB1aW50MzJfdCAqaW5kZXhfcG9zKQorCQkJCSAgIGNvbnN0IHN0cnVjdCBvYmplY3RfaWQgKm9pZCkKIHsKIAl1aW50MzJfdCBpOwogCWludCBmb3VuZDsKQEAgLTc5LDkgKzc4LDYgQEAKIAogCWkgPSBsb2NhdGVfb2JqZWN0X2VudHJ5X2hhc2gocGRhdGEsIG9pZCwgJmZvdW5kKTsKIAotCWlmIChpbmRleF9wb3MpCi0JCSppbmRleF9wb3MgPSBpOwotCiAJaWYgKCFmb3VuZCkKIAkJcmV0dXJuIE5VTEw7CiAKQEAgLTEyMyw3ICsxMTksMTAgQEAKIHsKIAl1aW50MzJfdCBpOwogCi0JUkVBTExPQ19BUlJBWShwYWNrLT5pbl9wYWNrLCBwYWNrLT5ucl9hbGxvYyk7CisJaWYgKHBhY2stPmluX3BhY2spCisJCUJVRygicGFja2luZ19kYXRhIGhhcyBhbHJlYWR5IGJlZW4gY29udmVydGVkIHRvIHBhY2sgYXJyYXkiKTsKKworCUFMTE9DX0FSUkFZKHBhY2stPmluX3BhY2ssIHBhY2stPm5yX2FsbG9jKTsKIAogCWZvciAoaSA9IDA7IGkgPCBwYWNrLT5ucl9vYmplY3RzOyBpKyspCiAJCXBhY2stPmluX3BhY2tbaV0gPSBvZV9pbl9wYWNrKHBhY2ssIHBhY2stPm9iamVjdHMgKyBpKTsKQEAgLTE1Myw4ICsxNTIsNyBAQAogfQogCiBzdHJ1Y3Qgb2JqZWN0X2VudHJ5ICpwYWNrbGlzdF9hbGxvYyhzdHJ1Y3QgcGFja2luZ19kYXRhICpwZGF0YSwKLQkJCQkgICAgY29uc3QgdW5zaWduZWQgY2hhciAqc2hhMSwKLQkJCQkgICAgdWludDMyX3QgaW5kZXhfcG9zKQorCQkJCSAgICBjb25zdCBzdHJ1Y3Qgb2JqZWN0X2lkICpvaWQpCiB7CiAJc3RydWN0IG9iamVjdF9lbnRyeSAqbmV3X2VudHJ5OwogCkBAIC0xNzcsMTIgKzE3NSwxOSBAQAogCW5ld19lbnRyeSA9IHBkYXRhLT5vYmplY3RzICsgcGRhdGEtPm5yX29iamVjdHMrKzsKIAogCW1lbXNldChuZXdfZW50cnksIDAsIHNpemVvZigqbmV3X2VudHJ5KSk7Ci0JaGFzaGNweShuZXdfZW50cnktPmlkeC5vaWQuaGFzaCwgc2hhMSk7CisJb2lkY3B5KCZuZXdfZW50cnktPmlkeC5vaWQsIG9pZCk7CiAKIAlpZiAocGRhdGEtPmluZGV4X3NpemUgKiAzIDw9IHBkYXRhLT5ucl9vYmplY3RzICogNCkKIAkJcmVoYXNoX29iamVjdHMocGRhdGEpOwotCWVsc2UKLQkJcGRhdGEtPmluZGV4W2luZGV4X3Bvc10gPSBwZGF0YS0+bnJfb2JqZWN0czsKKwllbHNlIHsKKwkJaW50IGZvdW5kOworCQl1aW50MzJfdCBwb3MgPSBsb2NhdGVfb2JqZWN0X2VudHJ5X2hhc2gocGRhdGEsCisJCQkJCQkJJm5ld19lbnRyeS0+aWR4Lm9pZCwKKwkJCQkJCQkmZm91bmQpOworCQlpZiAoZm91bmQpCisJCQlCVUcoImR1cGxpY2F0ZSBvYmplY3QgaW5zZXJ0ZWQgaW50byBoYXNoIik7CisJCXBkYXRhLT5pbmRleFtwb3NdID0gcGRhdGEtPm5yX29iamVjdHM7CisJfQogCiAJaWYgKHBkYXRhLT5pbl9wYWNrKQogCQlwZGF0YS0+aW5fcGFja1twZGF0YS0+bnJfb2JqZWN0cyAtIDFdID0gTlVMTDsKZGlmZiAtLWdpdCBhL3BhY2stb2JqZWN0cy5oIGIvcGFjay1vYmplY3RzLmgKaW5kZXggODU3ZDQzOC4uZDM5NzVlMCAxMDA2NDQKLS0tIGEvcGFjay1vYmplY3RzLmgKKysrIGIvcGFjay1vYmplY3RzLmgKQEAgLTE4MywxMiArMTgzLDEwIEBACiB9CiAKIHN0cnVjdCBvYmplY3RfZW50cnkgKnBhY2tsaXN0X2FsbG9jKHN0cnVjdCBwYWNraW5nX2RhdGEgKnBkYXRhLAotCQkJCSAgICBjb25zdCB1bnNpZ25lZCBjaGFyICpzaGExLAotCQkJCSAgICB1aW50MzJfdCBpbmRleF9wb3MpOworCQkJCSAgICBjb25zdCBzdHJ1Y3Qgb2JqZWN0X2lkICpvaWQpOwogCiBzdHJ1Y3Qgb2JqZWN0X2VudHJ5ICpwYWNrbGlzdF9maW5kKHN0cnVjdCBwYWNraW5nX2RhdGEgKnBkYXRhLAotCQkJCSAgIGNvbnN0IHN0cnVjdCBvYmplY3RfaWQgKm9pZCwKLQkJCQkgICB1aW50MzJfdCAqaW5kZXhfcG9zKTsKKwkJCQkgICBjb25zdCBzdHJ1Y3Qgb2JqZWN0X2lkICpvaWQpOwogCiBzdGF0aWMgaW5saW5lIHVpbnQzMl90IHBhY2tfbmFtZV9oYXNoKGNvbnN0IGNoYXIgKm5hbWUpCiB7CkBAIC0yNTMsMTIgKzI1MSwyMSBAQAogCQkJCSAgc3RydWN0IG9iamVjdF9lbnRyeSAqZSwKIAkJCQkgIHN0cnVjdCBwYWNrZWRfZ2l0ICpwKQogewotCWlmICghcC0+aW5kZXgpCisJaWYgKHBhY2stPmluX3BhY2tfYnlfaWR4KSB7CisJCWlmIChwLT5pbmRleCkgeworCQkJZS0+aW5fcGFja19pZHggPSBwLT5pbmRleDsKKwkJCXJldHVybjsKKwkJfQorCQkvKgorCQkgKiBXZSdyZSBhY2Nlc3NpbmcgcGFja3MgYnkgaW5kZXgsIGJ1dCB0aGlzIHBhY2sgZG9lc24ndCBoYXZlCisJCSAqIGFuIGluZGV4IChlLmcuLCBiZWNhdXNlIGl0IHdhcyBhZGRlZCBzaW5jZSB3ZSBjcmVhdGVkIHRoZQorCQkgKiBpbl9wYWNrX2J5X2lkeCBhcnJheSkuIEJhaWwgdG8gb2VfbWFwX25ld19wYWNrKCksIHdoaWNoCisJCSAqIHdpbGwgY29udmVydCB1cyB0byB1c2luZyB0aGUgZnVsbCBpbl9wYWNrIGFycmF5LCBhbmQgdGhlbgorCQkgKiBmYWxsIHRocm91Z2ggdG8gb3VyIGluX3BhY2sgaGFuZGxpbmcuCisJCSAqLwogCQlvZV9tYXBfbmV3X3BhY2socGFjayk7Ci0JaWYgKHBhY2stPmluX3BhY2tfYnlfaWR4KQotCQllLT5pbl9wYWNrX2lkeCA9IHAtPmluZGV4OwotCWVsc2UKLQkJcGFjay0+aW5fcGFja1tlIC0gcGFjay0+b2JqZWN0c10gPSBwOworCX0KKwlwYWNrLT5pbl9wYWNrW2UgLSBwYWNrLT5vYmplY3RzXSA9IHA7CiB9CiAKIHN0YXRpYyBpbmxpbmUgc3RydWN0IG9iamVjdF9lbnRyeSAqb2VfZGVsdGEoCmRpZmYgLS1naXQgYS9wYWNrLXdyaXRlLmMgYi9wYWNrLXdyaXRlLmMKaW5kZXggMjlkMTdhOS4uZjAwMTdiZSAxMDA2NDQKLS0tIGEvcGFjay13cml0ZS5jCisrKyBiL3BhY2std3JpdGUuYwpAQCAtMzQ5LDcgKzM0OSw3IEBACiAJCQkgc3RydWN0IHBhY2tfaWR4X2VudHJ5ICoqd3JpdHRlbl9saXN0LAogCQkJIHVpbnQzMl90IG5yX3dyaXR0ZW4sCiAJCQkgc3RydWN0IHBhY2tfaWR4X29wdGlvbiAqcGFja19pZHhfb3B0cywKLQkJCSB1bnNpZ25lZCBjaGFyIHNoYTFbXSkKKwkJCSB1bnNpZ25lZCBjaGFyIGhhc2hbXSkKIHsKIAljb25zdCBjaGFyICppZHhfdG1wX25hbWU7CiAJaW50IGJhc2VuYW1lX2xlbiA9IG5hbWVfYnVmZmVyLT5sZW47CkBAIC0zNTgsMTggKzM1OCwxOCBAQAogCQlkaWVfZXJybm8oInVuYWJsZSB0byBtYWtlIHRlbXBvcmFyeSBwYWNrIGZpbGUgcmVhZGFibGUiKTsKIAogCWlkeF90bXBfbmFtZSA9IHdyaXRlX2lkeF9maWxlKE5VTEwsIHdyaXR0ZW5fbGlzdCwgbnJfd3JpdHRlbiwKLQkJCQkgICAgICBwYWNrX2lkeF9vcHRzLCBzaGExKTsKKwkJCQkgICAgICBwYWNrX2lkeF9vcHRzLCBoYXNoKTsKIAlpZiAoYWRqdXN0X3NoYXJlZF9wZXJtKGlkeF90bXBfbmFtZSkpCiAJCWRpZV9lcnJubygidW5hYmxlIHRvIG1ha2UgdGVtcG9yYXJ5IGluZGV4IGZpbGUgcmVhZGFibGUiKTsKIAotCXN0cmJ1Zl9hZGRmKG5hbWVfYnVmZmVyLCAiJXMucGFjayIsIHNoYTFfdG9faGV4KHNoYTEpKTsKKwlzdHJidWZfYWRkZihuYW1lX2J1ZmZlciwgIiVzLnBhY2siLCBoYXNoX3RvX2hleChoYXNoKSk7CiAKIAlpZiAocmVuYW1lKHBhY2tfdG1wX25hbWUsIG5hbWVfYnVmZmVyLT5idWYpKQogCQlkaWVfZXJybm8oInVuYWJsZSB0byByZW5hbWUgdGVtcG9yYXJ5IHBhY2sgZmlsZSIpOwogCiAJc3RyYnVmX3NldGxlbihuYW1lX2J1ZmZlciwgYmFzZW5hbWVfbGVuKTsKIAotCXN0cmJ1Zl9hZGRmKG5hbWVfYnVmZmVyLCAiJXMuaWR4Iiwgc2hhMV90b19oZXgoc2hhMSkpOworCXN0cmJ1Zl9hZGRmKG5hbWVfYnVmZmVyLCAiJXMuaWR4IiwgaGFzaF90b19oZXgoaGFzaCkpOwogCWlmIChyZW5hbWUoaWR4X3RtcF9uYW1lLCBuYW1lX2J1ZmZlci0+YnVmKSkKIAkJZGllX2Vycm5vKCJ1bmFibGUgdG8gcmVuYW1lIHRlbXBvcmFyeSBpbmRleCBmaWxlIik7CiAKZGlmZiAtLWdpdCBhL3BhY2tmaWxlLmMgYi9wYWNrZmlsZS5jCmluZGV4IGZjNDNhNmMuLjM1NTA2NmQgMTAwNjQ0Ci0tLSBhL3BhY2tmaWxlLmMKKysrIGIvcGFja2ZpbGUuYwpAQCAtNiw3ICs2LDYgQEAKICNpbmNsdWRlICJtZXJnZXNvcnQuaCIKICNpbmNsdWRlICJwYWNrZmlsZS5oIgogI2luY2x1ZGUgImRlbHRhLmgiCi0jaW5jbHVkZSAibGlzdC5oIgogI2luY2x1ZGUgInN0cmVhbWluZy5oIgogI2luY2x1ZGUgInNoYTEtbG9va3VwLmgiCiAjaW5jbHVkZSAiY29tbWl0LmgiCkBAIC0xNywxNCArMTYsMTUgQEAKICNpbmNsdWRlICJvYmplY3Qtc3RvcmUuaCIKICNpbmNsdWRlICJtaWR4LmgiCiAjaW5jbHVkZSAiY29tbWl0LWdyYXBoLmgiCisjaW5jbHVkZSAicHJvbWlzb3ItcmVtb3RlLmgiCiAKIGNoYXIgKm9kYl9wYWNrX25hbWUoc3RydWN0IHN0cmJ1ZiAqYnVmLAotCQkgICAgY29uc3QgdW5zaWduZWQgY2hhciAqc2hhMSwKKwkJICAgIGNvbnN0IHVuc2lnbmVkIGNoYXIgKmhhc2gsCiAJCSAgICBjb25zdCBjaGFyICpleHQpCiB7CiAJc3RyYnVmX3Jlc2V0KGJ1Zik7CiAJc3RyYnVmX2FkZGYoYnVmLCAiJXMvcGFjay9wYWNrLSVzLiVzIiwgZ2V0X29iamVjdF9kaXJlY3RvcnkoKSwKLQkJICAgIHNoYTFfdG9faGV4KHNoYTEpLCBleHQpOworCQkgICAgaGFzaF90b19oZXgoaGFzaCksIGV4dCk7CiAJcmV0dXJuIGJ1Zi0+YnVmOwogfQogCkBAIC0yODcsMTMgKzI4Nyw2IEBACiAJcmV0dXJuIDA7CiB9CiAKLXZvaWQgcmVsZWFzZV9wYWNrX21lbW9yeShzaXplX3QgbmVlZCkKLXsKLQlzaXplX3QgY3VyID0gcGFja19tYXBwZWQ7Ci0Jd2hpbGUgKG5lZWQgPj0gKGN1ciAtIHBhY2tfbWFwcGVkKSAmJiB1bnVzZV9vbmVfd2luZG93KE5VTEwpKQotCQk7IC8qIG5vdGhpbmcgKi8KLX0KLQogdm9pZCBjbG9zZV9wYWNrX3dpbmRvd3Moc3RydWN0IHBhY2tlZF9naXQgKnApCiB7CiAJd2hpbGUgKHAtPndpbmRvd3MpIHsKQEAgLTcxMCwyMyArNzAzLDEyIEBACiAJfQogfQogCi1zdGF0aWMgdm9pZCB0cnlfdG9fZnJlZV9wYWNrX21lbW9yeShzaXplX3Qgc2l6ZSkKLXsKLQlyZWxlYXNlX3BhY2tfbWVtb3J5KHNpemUpOwotfQotCiBzdHJ1Y3QgcGFja2VkX2dpdCAqYWRkX3BhY2tlZF9naXQoY29uc3QgY2hhciAqcGF0aCwgc2l6ZV90IHBhdGhfbGVuLCBpbnQgbG9jYWwpCiB7Ci0Jc3RhdGljIGludCBoYXZlX3NldF90cnlfdG9fZnJlZV9yb3V0aW5lOwogCXN0cnVjdCBzdGF0IHN0OwogCXNpemVfdCBhbGxvYzsKIAlzdHJ1Y3QgcGFja2VkX2dpdCAqcDsKIAotCWlmICghaGF2ZV9zZXRfdHJ5X3RvX2ZyZWVfcm91dGluZSkgewotCQloYXZlX3NldF90cnlfdG9fZnJlZV9yb3V0aW5lID0gMTsKLQkJc2V0X3RyeV90b19mcmVlX3JvdXRpbmUodHJ5X3RvX2ZyZWVfcGFja19tZW1vcnkpOwotCX0KLQogCS8qCiAJICogTWFrZSBzdXJlIGEgY29ycmVzcG9uZGluZyAucGFjayBmaWxlIGV4aXN0cyBhbmQgdGhhdAogCSAqIHRoZSBpbmRleCBsb29rcyBzYW5lLgpAQCAtMTM2MSw3ICsxMzQzLDcgQEAKIH07CiAKIHN0cnVjdCBkZWx0YV9iYXNlX2NhY2hlX2VudHJ5IHsKLQlzdHJ1Y3QgaGFzaG1hcCBoYXNoOworCXN0cnVjdCBoYXNobWFwX2VudHJ5IGVudDsKIAlzdHJ1Y3QgZGVsdGFfYmFzZV9jYWNoZV9rZXkga2V5OwogCXN0cnVjdCBsaXN0X2hlYWQgbHJ1OwogCXZvaWQgKmRhdGE7CkBAIC0xMzgxLDcgKzEzNjMsNyBAQAogc3RhdGljIHN0cnVjdCBkZWx0YV9iYXNlX2NhY2hlX2VudHJ5ICoKIGdldF9kZWx0YV9iYXNlX2NhY2hlX2VudHJ5KHN0cnVjdCBwYWNrZWRfZ2l0ICpwLCBvZmZfdCBiYXNlX29mZnNldCkKIHsKLQlzdHJ1Y3QgaGFzaG1hcF9lbnRyeSBlbnRyeTsKKwlzdHJ1Y3QgaGFzaG1hcF9lbnRyeSBlbnRyeSwgKmU7CiAJc3RydWN0IGRlbHRhX2Jhc2VfY2FjaGVfa2V5IGtleTsKIAogCWlmICghZGVsdGFfYmFzZV9jYWNoZS5jbXBmbikKQEAgLTEzOTAsNyArMTM3Miw4IEBACiAJaGFzaG1hcF9lbnRyeV9pbml0KCZlbnRyeSwgcGFja19lbnRyeV9oYXNoKHAsIGJhc2Vfb2Zmc2V0KSk7CiAJa2V5LnAgPSBwOwogCWtleS5iYXNlX29mZnNldCA9IGJhc2Vfb2Zmc2V0OwotCXJldHVybiBoYXNobWFwX2dldCgmZGVsdGFfYmFzZV9jYWNoZSwgJmVudHJ5LCAma2V5KTsKKwllID0gaGFzaG1hcF9nZXQoJmRlbHRhX2Jhc2VfY2FjaGUsICZlbnRyeSwgJmtleSk7CisJcmV0dXJuIGUgPyBjb250YWluZXJfb2YoZSwgc3RydWN0IGRlbHRhX2Jhc2VfY2FjaGVfZW50cnksIGVudCkgOiBOVUxMOwogfQogCiBzdGF0aWMgaW50IGRlbHRhX2Jhc2VfY2FjaGVfa2V5X2VxKGNvbnN0IHN0cnVjdCBkZWx0YV9iYXNlX2NhY2hlX2tleSAqYSwKQEAgLTE0MDAsMTEgKzEzODMsMTYgQEAKIH0KIAogc3RhdGljIGludCBkZWx0YV9iYXNlX2NhY2hlX2hhc2hfY21wKGNvbnN0IHZvaWQgKnVudXNlZF9jbXBfZGF0YSwKLQkJCQkgICAgIGNvbnN0IHZvaWQgKnZhLCBjb25zdCB2b2lkICp2YiwKKwkJCQkgICAgIGNvbnN0IHN0cnVjdCBoYXNobWFwX2VudHJ5ICp2YSwKKwkJCQkgICAgIGNvbnN0IHN0cnVjdCBoYXNobWFwX2VudHJ5ICp2YiwKIAkJCQkgICAgIGNvbnN0IHZvaWQgKnZrZXkpCiB7Ci0JY29uc3Qgc3RydWN0IGRlbHRhX2Jhc2VfY2FjaGVfZW50cnkgKmEgPSB2YSwgKmIgPSB2YjsKKwljb25zdCBzdHJ1Y3QgZGVsdGFfYmFzZV9jYWNoZV9lbnRyeSAqYSwgKmI7CiAJY29uc3Qgc3RydWN0IGRlbHRhX2Jhc2VfY2FjaGVfa2V5ICprZXkgPSB2a2V5OworCisJYSA9IGNvbnRhaW5lcl9vZih2YSwgY29uc3Qgc3RydWN0IGRlbHRhX2Jhc2VfY2FjaGVfZW50cnksIGVudCk7CisJYiA9IGNvbnRhaW5lcl9vZih2YiwgY29uc3Qgc3RydWN0IGRlbHRhX2Jhc2VfY2FjaGVfZW50cnksIGVudCk7CisKIAlpZiAoa2V5KQogCQlyZXR1cm4gIWRlbHRhX2Jhc2VfY2FjaGVfa2V5X2VxKCZhLT5rZXksIGtleSk7CiAJZWxzZQpAQCAtMTQyMyw3ICsxNDExLDcgQEAKICAqLwogc3RhdGljIHZvaWQgZGV0YWNoX2RlbHRhX2Jhc2VfY2FjaGVfZW50cnkoc3RydWN0IGRlbHRhX2Jhc2VfY2FjaGVfZW50cnkgKmVudCkKIHsKLQloYXNobWFwX3JlbW92ZSgmZGVsdGFfYmFzZV9jYWNoZSwgZW50LCAmZW50LT5rZXkpOworCWhhc2htYXBfcmVtb3ZlKCZkZWx0YV9iYXNlX2NhY2hlLCAmZW50LT5lbnQsICZlbnQtPmtleSk7CiAJbGlzdF9kZWwoJmVudC0+bHJ1KTsKIAlkZWx0YV9iYXNlX2NhY2hlZCAtPSBlbnQtPnNpemU7CiAJZnJlZShlbnQpOwpAQCAtMTQ4Nyw4ICsxNDc1LDggQEAKIAogCWlmICghZGVsdGFfYmFzZV9jYWNoZS5jbXBmbikKIAkJaGFzaG1hcF9pbml0KCZkZWx0YV9iYXNlX2NhY2hlLCBkZWx0YV9iYXNlX2NhY2hlX2hhc2hfY21wLCBOVUxMLCAwKTsKLQloYXNobWFwX2VudHJ5X2luaXQoZW50LCBwYWNrX2VudHJ5X2hhc2gocCwgYmFzZV9vZmZzZXQpKTsKLQloYXNobWFwX2FkZCgmZGVsdGFfYmFzZV9jYWNoZSwgZW50KTsKKwloYXNobWFwX2VudHJ5X2luaXQoJmVudC0+ZW50LCBwYWNrX2VudHJ5X2hhc2gocCwgYmFzZV9vZmZzZXQpKTsKKwloYXNobWFwX2FkZCgmZGVsdGFfYmFzZV9jYWNoZSwgJmVudC0+ZW50KTsKIH0KIAogaW50IHBhY2tlZF9vYmplY3RfaW5mbyhzdHJ1Y3QgcmVwb3NpdG9yeSAqciwgc3RydWN0IHBhY2tlZF9naXQgKnAsCkBAIC0yMTM5LDcgKzIxMjcsNyBAQAogCQkJb2lkc2V0X2luc2VydChzZXQsICZwYXJlbnRzLT5pdGVtLT5vYmplY3Qub2lkKTsKIAl9IGVsc2UgaWYgKG9iai0+dHlwZSA9PSBPQkpfVEFHKSB7CiAJCXN0cnVjdCB0YWcgKnRhZyA9IChzdHJ1Y3QgdGFnICopIG9iajsKLQkJb2lkc2V0X2luc2VydChzZXQsICZ0YWctPnRhZ2dlZC0+b2lkKTsKKwkJb2lkc2V0X2luc2VydChzZXQsIGdldF90YWdnZWRfb2lkKHRhZykpOwogCX0KIAlyZXR1cm4gMDsKIH0KQEAgLTIxNTAsNyArMjEzOCw3IEBACiAJc3RhdGljIGludCBwcm9taXNvcl9vYmplY3RzX3ByZXBhcmVkOwogCiAJaWYgKCFwcm9taXNvcl9vYmplY3RzX3ByZXBhcmVkKSB7Ci0JCWlmIChyZXBvc2l0b3J5X2Zvcm1hdF9wYXJ0aWFsX2Nsb25lKSB7CisJCWlmIChoYXNfcHJvbWlzb3JfcmVtb3RlKCkpIHsKIAkJCWZvcl9lYWNoX3BhY2tlZF9vYmplY3QoYWRkX3Byb21pc29yX29iamVjdCwKIAkJCQkJICAgICAgICZwcm9taXNvcl9vYmplY3RzLAogCQkJCQkgICAgICAgRk9SX0VBQ0hfT0JKRUNUX1BST01JU09SX09OTFkpOwpkaWZmIC0tZ2l0IGEvcGFja2ZpbGUuaCBiL3BhY2tmaWxlLmgKaW5kZXggM2U5ODkxMC4uZmM3OTA0ZSAxMDA2NDQKLS0tIGEvcGFja2ZpbGUuaAorKysgYi9wYWNrZmlsZS5oCkBAIC0xMDAsNyArMTAwLDcgQEAKICAqIERvZXMgbm90IHVubGluayBpZiAnZm9yY2VfZGVsZXRlJyBpcyBmYWxzZSBhbmQgdGhlIHBhY2stZmlsZSBpcwogICogbWFya2VkIGFzICIua2VlcCIuCiAgKi8KLWV4dGVybiB2b2lkIHVubGlua19wYWNrX3BhdGgoY29uc3QgY2hhciAqcGFja19uYW1lLCBpbnQgZm9yY2VfZGVsZXRlKTsKK3ZvaWQgdW5saW5rX3BhY2tfcGF0aChjb25zdCBjaGFyICpwYWNrX25hbWUsIGludCBmb3JjZV9kZWxldGUpOwogCiAvKgogICogTWFrZSBzdXJlIHRoYXQgYSBwb2ludGVyIGFjY2VzcyBpbnRvIGFuIG1tYXAnZCBpbmRleCBmaWxlIGlzIHdpdGhpbiBib3VuZHMsCmRpZmYgLS1naXQgYS9wYXJzZS1vcHRpb25zLWNiLmMgYi9wYXJzZS1vcHRpb25zLWNiLmMKaW5kZXggMTI0MGE4NS4uYzIwNjJhZSAxMDA2NDQKLS0tIGEvcGFyc2Utb3B0aW9ucy1jYi5jCisrKyBiL3BhcnNlLW9wdGlvbnMtY2IuYwpAQCAtMTYxLDYgKzE2MSw3IEBACiAKIHN0cnVjdCBvcHRpb24gKnBhcnNlX29wdGlvbnNfZHVwKGNvbnN0IHN0cnVjdCBvcHRpb24gKm8pCiB7CisJY29uc3Qgc3RydWN0IG9wdGlvbiAqb3JpZyA9IG87CiAJc3RydWN0IG9wdGlvbiAqb3B0czsKIAlpbnQgbnIgPSAwOwogCkBAIC0xNzAsNyArMTcxLDcgQEAKIAl9CiAKIAlBTExPQ19BUlJBWShvcHRzLCBuciArIDEpOwotCW1lbWNweShvcHRzLCBvIC0gbnIsIHNpemVvZigqbykgKiBucik7CisJQ09QWV9BUlJBWShvcHRzLCBvcmlnLCBucik7CiAJbWVtc2V0KG9wdHMgKyBuciwgMCwgc2l6ZW9mKCpvcHRzKSk7CiAJb3B0c1tucl0udHlwZSA9IE9QVElPTl9FTkQ7CiAJcmV0dXJuIG9wdHM7CmRpZmYgLS1naXQgYS9wYXJzZS1vcHRpb25zLmMgYi9wYXJzZS1vcHRpb25zLmMKaW5kZXggODdiMjZhMS4uNjBmYWUzYSAxMDA2NDQKLS0tIGEvcGFyc2Utb3B0aW9ucy5jCisrKyBiL3BhcnNlLW9wdGlvbnMuYwpAQCAtNjIzLDcgKzYyMyw3IEBACiAgKiBTY2FuIGFuZCBtYXkgcHJvZHVjZSBhIG5ldyBvcHRpb25bXSBhcnJheSwgd2hpY2ggc2hvdWxkIGJlIHVzZWQKICAqIGluc3RlYWQgb2YgdGhlIG9yaWdpbmFsICdvcHRpb25zJy4KICAqCi0gKiBSaWdodCBub3cgdGhpcyBpcyBvbmx5IHVzZWQgdG8gcHJlcHJvY2VzcyBhbmQgc3Vic3RpdHVlCisgKiBSaWdodCBub3cgdGhpcyBpcyBvbmx5IHVzZWQgdG8gcHJlcHJvY2VzcyBhbmQgc3Vic3RpdHV0ZQogICogT1BUSU9OX0FMSUFTLgogICovCiBzdGF0aWMgc3RydWN0IG9wdGlvbiAqcHJlcHJvY2Vzc19vcHRpb25zKHN0cnVjdCBwYXJzZV9vcHRfY3R4X3QgKmN0eCwKQEAgLTc4MCw3ICs3ODAsOCBAQAogCQkJY29udGludWU7CiAJCX0KIAotCQlpZiAoIWFyZ1syXSkgeyAvKiAiLS0iICovCisJCWlmICghYXJnWzJdIC8qICItLSIgKi8gfHwKKwkJICAgICFzdHJjbXAoYXJnICsgMiwgImVuZC1vZi1vcHRpb25zIikpIHsKIAkJCWlmICghKGN0eC0+ZmxhZ3MgJiBQQVJTRV9PUFRfS0VFUF9EQVNIREFTSCkpIHsKIAkJCQljdHgtPmFyZ2MtLTsKIAkJCQljdHgtPmFyZ3YrKzsKZGlmZiAtLWdpdCBhL3BhcnNlLW9wdGlvbnMuaCBiL3BhcnNlLW9wdGlvbnMuaAppbmRleCBhNGJkNDBiLi4zOGEzM2EwIDEwMDY0NAotLS0gYS9wYXJzZS1vcHRpb25zLmgKKysrIGIvcGFyc2Utb3B0aW9ucy5oCkBAIC00Niw2ICs0NiwxNSBAQAogCVBBUlNFX09QVF9DT01QX0FSRyA9IDEwMjQKIH07CiAKK2VudW0gcGFyc2Vfb3B0X3Jlc3VsdCB7CisJUEFSU0VfT1BUX0NPTVBMRVRFID0gLTMsCisJUEFSU0VfT1BUX0hFTFAgPSAtMiwKKwlQQVJTRV9PUFRfRVJST1IgPSAtMSwJLyogbXVzdCBiZSB0aGUgc2FtZSBhcyBlcnJvcigpICovCisJUEFSU0VfT1BUX0RPTkUgPSAwLAkvKiBmaXhlZCBzbyB0aGF0ICJyZXR1cm4gMCIgd29ya3MgKi8KKwlQQVJTRV9PUFRfTk9OX09QVElPTiwKKwlQQVJTRV9PUFRfVU5LTk9XTgorfTsKKwogc3RydWN0IG9wdGlvbjsKIHR5cGVkZWYgaW50IHBhcnNlX29wdF9jYihjb25zdCBzdHJ1Y3Qgb3B0aW9uICosIGNvbnN0IGNoYXIgKmFyZywgaW50IHVuc2V0KTsKIApAQCAtMjQxLDE1ICsyNTAsNiBAQAogCiAvKi0tLS0tIGluY3JlbWVudGFsIGFkdmFuY2VkIEFQSXMgLS0tLS0qLwogCi1lbnVtIHBhcnNlX29wdF9yZXN1bHQgewotCVBBUlNFX09QVF9DT01QTEVURSA9IC0zLAotCVBBUlNFX09QVF9IRUxQID0gLTIsCi0JUEFSU0VfT1BUX0VSUk9SID0gLTEsCS8qIG11c3QgYmUgdGhlIHNhbWUgYXMgZXJyb3IoKSAqLwotCVBBUlNFX09QVF9ET05FID0gMCwJLyogZml4ZWQgc28gdGhhdCAicmV0dXJuIDAiIHdvcmtzICovCi0JUEFSU0VfT1BUX05PTl9PUFRJT04sCi0JUEFSU0VfT1BUX1VOS05PV04KLX07Ci0KIC8qCiAgKiBJdCdzIG9rYXkgZm9yIHRoZSBjYWxsZXIgdG8gY29uc3VtZSBhcmd2L2FyZ2MgaW4gdGhlIHVzdWFsIHdheS4KICAqIE90aGVyIGZpZWxkcyBvZiB0aGF0IHN0cnVjdHVyZSBhcmUgcHJpdmF0ZSB0byBwYXJzZS1vcHRpb25zIGFuZCBzaG91bGQgbm90CmRpZmYgLS1naXQgYS9wYXRjaC1pZHMuYyBiL3BhdGNoLWlkcy5jCmluZGV4IGU4YzE1MGQuLjEyYWE2ZDQgMTAwNjQ0Ci0tLSBhL3BhdGNoLWlkcy5jCisrKyBiL3BhdGNoLWlkcy5jCkBAIC0zNiwxNCArMzYsMTYgQEAKICAqIGFueSBzaWduaWZpY2FuY2U7IG9ubHkgdGhhdCBpdCBpcyBub24temVybyBtYXR0ZXJzLgogICovCiBzdGF0aWMgaW50IHBhdGNoX2lkX25lcShjb25zdCB2b2lkICpjbXBmbl9kYXRhLAotCQkJY29uc3Qgdm9pZCAqZW50cnksCi0JCQljb25zdCB2b2lkICplbnRyeV9vcl9rZXksCisJCQljb25zdCBzdHJ1Y3QgaGFzaG1hcF9lbnRyeSAqZXB0ciwKKwkJCWNvbnN0IHN0cnVjdCBoYXNobWFwX2VudHJ5ICplbnRyeV9vcl9rZXksCiAJCQljb25zdCB2b2lkICp1bnVzZWRfa2V5ZGF0YSkKIHsKIAkvKiBORUVEU1dPUks6IGNvbnN0IGNvcnJlY3RuZXNzPyAqLwogCXN0cnVjdCBkaWZmX29wdGlvbnMgKm9wdCA9ICh2b2lkICopY21wZm5fZGF0YTsKLQlzdHJ1Y3QgcGF0Y2hfaWQgKmEgPSAodm9pZCAqKWVudHJ5OwotCXN0cnVjdCBwYXRjaF9pZCAqYiA9ICh2b2lkICopZW50cnlfb3Jfa2V5OworCXN0cnVjdCBwYXRjaF9pZCAqYSwgKmI7CisKKwlhID0gY29udGFpbmVyX29mKGVwdHIsIHN0cnVjdCBwYXRjaF9pZCwgZW50KTsKKwliID0gY29udGFpbmVyX29mKGVudHJ5X29yX2tleSwgc3RydWN0IHBhdGNoX2lkLCBlbnQpOwogCiAJaWYgKGlzX251bGxfb2lkKCZhLT5wYXRjaF9pZCkgJiYKIAkgICAgY29tbWl0X3BhdGNoX2lkKGEtPmNvbW1pdCwgb3B0LCAmYS0+cGF0Y2hfaWQsIDAsIDApKQpAQCAtNjksNyArNzEsNyBAQAogCiBpbnQgZnJlZV9wYXRjaF9pZHMoc3RydWN0IHBhdGNoX2lkcyAqaWRzKQogewotCWhhc2htYXBfZnJlZSgmaWRzLT5wYXRjaGVzLCAxKTsKKwloYXNobWFwX2ZyZWVfZW50cmllcygmaWRzLT5wYXRjaGVzLCBzdHJ1Y3QgcGF0Y2hfaWQsIGVudCk7CiAJcmV0dXJuIDA7CiB9CiAKQEAgLTgzLDcgKzg1LDcgQEAKIAlpZiAoY29tbWl0X3BhdGNoX2lkKGNvbW1pdCwgJmlkcy0+ZGlmZm9wdHMsICZoZWFkZXJfb25seV9wYXRjaF9pZCwgMSwgMCkpCiAJCXJldHVybiAtMTsKIAotCWhhc2htYXBfZW50cnlfaW5pdChwYXRjaCwgb2lkaGFzaCgmaGVhZGVyX29ubHlfcGF0Y2hfaWQpKTsKKwloYXNobWFwX2VudHJ5X2luaXQoJnBhdGNoLT5lbnQsIG9pZGhhc2goJmhlYWRlcl9vbmx5X3BhdGNoX2lkKSk7CiAJcmV0dXJuIDA7CiB9CiAKQEAgLTk5LDcgKzEwMSw3IEBACiAJaWYgKGluaXRfcGF0Y2hfaWRfZW50cnkoJnBhdGNoLCBjb21taXQsIGlkcykpCiAJCXJldHVybiBOVUxMOwogCi0JcmV0dXJuIGhhc2htYXBfZ2V0KCZpZHMtPnBhdGNoZXMsICZwYXRjaCwgTlVMTCk7CisJcmV0dXJuIGhhc2htYXBfZ2V0X2VudHJ5KCZpZHMtPnBhdGNoZXMsICZwYXRjaCwgZW50LCBOVUxMKTsKIH0KIAogc3RydWN0IHBhdGNoX2lkICphZGRfY29tbWl0X3BhdGNoX2lkKHN0cnVjdCBjb21taXQgKmNvbW1pdCwKQEAgLTExNiw2ICsxMTgsNiBAQAogCQlyZXR1cm4gTlVMTDsKIAl9CiAKLQloYXNobWFwX2FkZCgmaWRzLT5wYXRjaGVzLCBrZXkpOworCWhhc2htYXBfYWRkKCZpZHMtPnBhdGNoZXMsICZrZXktPmVudCk7CiAJcmV0dXJuIGtleTsKIH0KZGlmZiAtLWdpdCBhL3BhdGguYyBiL3BhdGguYwppbmRleCAyNWU5N2I4Li4wNjA3MTU2IDEwMDY0NAotLS0gYS9wYXRoLmMKKysrIGIvcGF0aC5jCkBAIC0xMSw2ICsxMSw3IEBACiAjaW5jbHVkZSAicGF0aC5oIgogI2luY2x1ZGUgInBhY2tmaWxlLmgiCiAjaW5jbHVkZSAib2JqZWN0LXN0b3JlLmgiCisjaW5jbHVkZSAibG9ja2ZpbGUuaCIKIAogc3RhdGljIGludCBnZXRfc3RfbW9kZV9iaXRzKGNvbnN0IGNoYXIgKnBhdGgsIGludCAqbW9kZSkKIHsKQEAgLTEwMSwzNiArMTAyLDM2IEBACiAJLyogTm90IGNvbnNpZGVyZWQgZ2FyYmFnZSBmb3IgcmVwb3J0X2xpbmtlZF9jaGVja291dF9nYXJiYWdlICovCiAJdW5zaWduZWQgaWdub3JlX2dhcmJhZ2U6MTsKIAl1bnNpZ25lZCBpc19kaXI6MTsKLQkvKiBOb3QgY29tbW9uIGV2ZW4gdGhvdWdoIGl0cyBwYXJlbnQgaXMgKi8KLQl1bnNpZ25lZCBleGNsdWRlOjE7Ci0JY29uc3QgY2hhciAqZGlybmFtZTsKKwkvKiBCZWxvbmdzIHRvIHRoZSBjb21tb24gZGlyLCB0aG91Z2ggaXQgbWF5IGNvbnRhaW4gcGF0aHMgdGhhdCBkb24ndCAqLworCXVuc2lnbmVkIGlzX2NvbW1vbjoxOworCWNvbnN0IGNoYXIgKnBhdGg7CiB9OwogCiBzdGF0aWMgc3RydWN0IGNvbW1vbl9kaXIgY29tbW9uX2xpc3RbXSA9IHsKLQl7IDAsIDEsIDAsICJicmFuY2hlcyIgfSwKLQl7IDAsIDEsIDAsICJjb21tb24iIH0sCi0JeyAwLCAxLCAwLCAiaG9va3MiIH0sCi0JeyAwLCAxLCAwLCAiaW5mbyIgfSwKLQl7IDAsIDAsIDEsICJpbmZvL3NwYXJzZS1jaGVja291dCIgfSwKLQl7IDEsIDEsIDAsICJsb2dzIiB9LAotCXsgMSwgMSwgMSwgImxvZ3MvSEVBRCIgfSwKLQl7IDAsIDEsIDEsICJsb2dzL3JlZnMvYmlzZWN0IiB9LAotCXsgMCwgMSwgMSwgImxvZ3MvcmVmcy9yZXdyaXR0ZW4iIH0sCi0JeyAwLCAxLCAxLCAibG9ncy9yZWZzL3dvcmt0cmVlIiB9LAotCXsgMCwgMSwgMCwgImxvc3QtZm91bmQiIH0sCi0JeyAwLCAxLCAwLCAib2JqZWN0cyIgfSwKLQl7IDAsIDEsIDAsICJyZWZzIiB9LAotCXsgMCwgMSwgMSwgInJlZnMvYmlzZWN0IiB9LAotCXsgMCwgMSwgMSwgInJlZnMvcmV3cml0dGVuIiB9LAotCXsgMCwgMSwgMSwgInJlZnMvd29ya3RyZWUiIH0sCi0JeyAwLCAxLCAwLCAicmVtb3RlcyIgfSwKLQl7IDAsIDEsIDAsICJ3b3JrdHJlZXMiIH0sCi0JeyAwLCAxLCAwLCAicnItY2FjaGUiIH0sCi0JeyAwLCAxLCAwLCAic3ZuIiB9LAotCXsgMCwgMCwgMCwgImNvbmZpZyIgfSwKLQl7IDEsIDAsIDAsICJnYy5waWQiIH0sCi0JeyAwLCAwLCAwLCAicGFja2VkLXJlZnMiIH0sCi0JeyAwLCAwLCAwLCAic2hhbGxvdyIgfSwKKwl7IDAsIDEsIDEsICJicmFuY2hlcyIgfSwKKwl7IDAsIDEsIDEsICJjb21tb24iIH0sCisJeyAwLCAxLCAxLCAiaG9va3MiIH0sCisJeyAwLCAxLCAxLCAiaW5mbyIgfSwKKwl7IDAsIDAsIDAsICJpbmZvL3NwYXJzZS1jaGVja291dCIgfSwKKwl7IDEsIDEsIDEsICJsb2dzIiB9LAorCXsgMSwgMCwgMCwgImxvZ3MvSEVBRCIgfSwKKwl7IDAsIDEsIDAsICJsb2dzL3JlZnMvYmlzZWN0IiB9LAorCXsgMCwgMSwgMCwgImxvZ3MvcmVmcy9yZXdyaXR0ZW4iIH0sCisJeyAwLCAxLCAwLCAibG9ncy9yZWZzL3dvcmt0cmVlIiB9LAorCXsgMCwgMSwgMSwgImxvc3QtZm91bmQiIH0sCisJeyAwLCAxLCAxLCAib2JqZWN0cyIgfSwKKwl7IDAsIDEsIDEsICJyZWZzIiB9LAorCXsgMCwgMSwgMCwgInJlZnMvYmlzZWN0IiB9LAorCXsgMCwgMSwgMCwgInJlZnMvcmV3cml0dGVuIiB9LAorCXsgMCwgMSwgMCwgInJlZnMvd29ya3RyZWUiIH0sCisJeyAwLCAxLCAxLCAicmVtb3RlcyIgfSwKKwl7IDAsIDEsIDEsICJ3b3JrdHJlZXMiIH0sCisJeyAwLCAxLCAxLCAicnItY2FjaGUiIH0sCisJeyAwLCAxLCAxLCAic3ZuIiB9LAorCXsgMCwgMCwgMSwgImNvbmZpZyIgfSwKKwl7IDEsIDAsIDEsICJnYy5waWQiIH0sCisJeyAwLCAwLCAxLCAicGFja2VkLXJlZnMiIH0sCisJeyAwLCAwLCAxLCAic2hhbGxvdyIgfSwKIAl7IDAsIDAsIDAsIE5VTEwgfQogfTsKIApAQCAtMjM2LDMwICsyMzcsNDEgQEAKIAlyZXR1cm4gb2xkOwogfQogCi10eXBlZGVmIGludCAoKm1hdGNoX2ZuKShjb25zdCBjaGFyICp1bm1hdGNoZWQsIHZvaWQgKmRhdGEsIHZvaWQgKmJhdG9uKTsKK3R5cGVkZWYgaW50ICgqbWF0Y2hfZm4pKGNvbnN0IGNoYXIgKnVubWF0Y2hlZCwgdm9pZCAqdmFsdWUsIHZvaWQgKmJhdG9uKTsKIAogLyoKICAqIFNlYXJjaCBhIHRyaWUgZm9yIHNvbWUga2V5LiAgRmluZCB0aGUgbG9uZ2VzdCAvLW9yLVwwLXRlcm1pbmF0ZWQKLSAqIHByZWZpeCBvZiB0aGUga2V5IGZvciB3aGljaCB0aGUgdHJpZSBjb250YWlucyBhIHZhbHVlLiAgQ2FsbCBmbgotICogd2l0aCB0aGUgdW5tYXRjaGVkIHBvcnRpb24gb2YgdGhlIGtleSBhbmQgdGhlIGZvdW5kIHZhbHVlLCBhbmQKLSAqIHJldHVybiBpdHMgcmV0dXJuIHZhbHVlLiAgSWYgdGhlcmUgaXMgbm8gc3VjaCBwcmVmaXgsIHJldHVybiAtMS4KKyAqIHByZWZpeCBvZiB0aGUga2V5IGZvciB3aGljaCB0aGUgdHJpZSBjb250YWlucyBhIHZhbHVlLiAgSWYgdGhlcmUgaXMKKyAqIG5vIHN1Y2ggcHJlZml4LCByZXR1cm4gLTEuICBPdGhlcndpc2UgY2FsbCBmbiB3aXRoIHRoZSB1bm1hdGNoZWQKKyAqIHBvcnRpb24gb2YgdGhlIGtleSBhbmQgdGhlIGZvdW5kIHZhbHVlLiAgSWYgZm4gcmV0dXJucyAwIG9yCisgKiBwb3NpdGl2ZSwgdGhlbiByZXR1cm4gaXRzIHJldHVybiB2YWx1ZS4gIElmIGZuIHJldHVybnMgbmVnYXRpdmUsCisgKiB0aGVuIGNhbGwgZm4gd2l0aCB0aGUgbmV4dC1sb25nZXN0IC8tdGVybWluYXRlZCBwcmVmaXggb2YgdGhlIGtleQorICogKGkuZS4gYSBwYXJlbnQgZGlyZWN0b3J5KSBmb3Igd2hpY2ggdGhlIHRyaWUgY29udGFpbnMgYSB2YWx1ZSwgYW5kCisgKiBoYW5kbGUgaXRzIHJldHVybiB2YWx1ZSB0aGUgc2FtZSB3YXkuICBJZiB0aGVyZSBpcyBubyBzaG9ydGVyCisgKiAvLXRlcm1pbmF0ZWQgcHJlZml4IHdpdGggYSB2YWx1ZSBsZWZ0LCB0aGVuIHJldHVybiB0aGUgbmVnYXRpdmUKKyAqIHJldHVybiB2YWx1ZSBvZiB0aGUgbW9zdCByZWNlbnQgZm4gaW52b2NhdGlvbi4KICAqCiAgKiBUaGUga2V5IGlzIHBhcnRpYWxseSBub3JtYWxpemVkOiBjb25zZWN1dGl2ZSBzbGFzaGVzIGFyZSBza2lwcGVkLgogICoKLSAqIEZvciBleGFtcGxlLCBjb25zaWRlciB0aGUgdHJpZSBjb250YWluaW5nIG9ubHkgW3JlZnMsCi0gKiByZWZzL3dvcmt0cmVlXSAoYm90aCB3aXRoIHZhbHVlcykuCisgKiBGb3IgZXhhbXBsZSwgY29uc2lkZXIgdGhlIHRyaWUgY29udGFpbmluZyBvbmx5IFtsb2dzLAorICogbG9ncy9yZWZzL2Jpc2VjdF0sIGJvdGggd2l0aCB2YWx1ZXMsIGJ1dCBub3QgbG9ncy9yZWZzLgogICoKLSAqIHwga2V5ICAgICAgICAgICAgIHwgdW5tYXRjaGVkICB8IHZhbCBmcm9tIG5vZGUgfCByZXR1cm4gdmFsdWUgfAotICogfC0tLS0tLS0tLS0tLS0tLS0tfC0tLS0tLS0tLS0tLXwtLS0tLS0tLS0tLS0tLS18LS0tLS0tLS0tLS0tLS18Ci0gKiB8IGEgICAgICAgICAgICAgICB8IG5vdCBjYWxsZWQgfCBuL2EgICAgICAgICAgIHwgLTEgICAgICAgICAgIHwKLSAqIHwgcmVmcyAgICAgICAgICAgIHwgXDAgICAgICAgICB8IHJlZnMgICAgICAgICAgfCBhcyBwZXIgZm4gICAgfAotICogfCByZWZzLyAgICAgICAgICAgfCAvICAgICAgICAgIHwgcmVmcyAgICAgICAgICB8IGFzIHBlciBmbiAgICB8Ci0gKiB8IHJlZnMvdyAgICAgICAgICB8IC93ICAgICAgICAgfCByZWZzICAgICAgICAgIHwgYXMgcGVyIGZuICAgIHwKLSAqIHwgcmVmcy93b3JrdHJlZSAgIHwgXDAgICAgICAgICB8IHJlZnMvd29ya3RyZWUgfCBhcyBwZXIgZm4gICAgfAotICogfCByZWZzL3dvcmt0cmVlLyAgfCAvICAgICAgICAgIHwgcmVmcy93b3JrdHJlZSB8IGFzIHBlciBmbiAgICB8Ci0gKiB8IHJlZnMvd29ya3RyZWUvYSB8IC9hICAgICAgICAgfCByZWZzL3dvcmt0cmVlIHwgYXMgcGVyIGZuICAgIHwKLSAqIHwtLS0tLS0tLS0tLS0tLS0tLXwtLS0tLS0tLS0tLS18LS0tLS0tLS0tLS0tLS0tfC0tLS0tLS0tLS0tLS0tfAotICoKKyAqIHwga2V5ICAgICAgICAgICAgICAgIHwgdW5tYXRjaGVkICAgICAgfCBwcmVmaXggdG8gbm9kZSAgIHwgcmV0dXJuIHZhbHVlIHwKKyAqIHwtLS0tLS0tLS0tLS0tLS0tLS0tLXwtLS0tLS0tLS0tLS0tLS0tfC0tLS0tLS0tLS0tLS0tLS0tLXwtLS0tLS0tLS0tLS0tLXwKKyAqIHwgYSAgICAgICAgICAgICAgICAgIHwgbm90IGNhbGxlZCAgICAgfCBuL2EgICAgICAgICAgICAgIHwgLTEgICAgICAgICAgIHwKKyAqIHwgbG9nc3RvcmUgICAgICAgICAgIHwgbm90IGNhbGxlZCAgICAgfCBuL2EgICAgICAgICAgICAgIHwgLTEgICAgICAgICAgIHwKKyAqIHwgbG9ncyAgICAgICAgICAgICAgIHwgXDAgICAgICAgICAgICAgfCBsb2dzICAgICAgICAgICAgIHwgYXMgcGVyIGZuICAgIHwKKyAqIHwgbG9ncy8gICAgICAgICAgICAgIHwgLyAgICAgICAgICAgICAgfCBsb2dzICAgICAgICAgICAgIHwgYXMgcGVyIGZuICAgIHwKKyAqIHwgbG9ncy9yZWZzICAgICAgICAgIHwgL3JlZnMgICAgICAgICAgfCBsb2dzICAgICAgICAgICAgIHwgYXMgcGVyIGZuICAgIHwKKyAqIHwgbG9ncy9yZWZzLyAgICAgICAgIHwgL3JlZnMvICAgICAgICAgfCBsb2dzICAgICAgICAgICAgIHwgYXMgcGVyIGZuICAgIHwKKyAqIHwgbG9ncy9yZWZzL2IgICAgICAgIHwgL3JlZnMvYiAgICAgICAgfCBsb2dzICAgICAgICAgICAgIHwgYXMgcGVyIGZuICAgIHwKKyAqIHwgbG9ncy9yZWZzL2Jpc2VjdGVkIHwgL3JlZnMvYmlzZWN0ZWQgfCBsb2dzICAgICAgICAgICAgIHwgYXMgcGVyIGZuICAgIHwKKyAqIHwgbG9ncy9yZWZzL2Jpc2VjdCAgIHwgXDAgICAgICAgICAgICAgfCBsb2dzL3JlZnMvYmlzZWN0IHwgYXMgcGVyIGZuICAgIHwKKyAqIHwgbG9ncy9yZWZzL2Jpc2VjdC8gIHwgLyAgICAgICAgICAgICAgfCBsb2dzL3JlZnMvYmlzZWN0IHwgYXMgcGVyIGZuICAgIHwKKyAqIHwgbG9ncy9yZWZzL2Jpc2VjdC9hIHwgL2EgICAgICAgICAgICAgfCBsb2dzL3JlZnMvYmlzZWN0IHwgYXMgcGVyIGZuICAgIHwKKyAqIHwgKElmIGZuIGluIHRoZSBwcmV2aW91cyBsaW5lIHJldHVybnMgLTEsIHRoZW4gZm4gaXMgY2FsbGVkIG9uY2UgbW9yZTopIHwKKyAqIHwgbG9ncy9yZWZzL2Jpc2VjdC9hIHwgL3JlZnMvYmlzZWN0L2EgfCBsb2dzICAgICAgICAgICAgIHwgYXMgcGVyIGZuICAgIHwKKyAqIHwtLS0tLS0tLS0tLS0tLS0tLS0tLXwtLS0tLS0tLS0tLS0tLS0tfC0tLS0tLS0tLS0tLS0tLS0tLXwtLS0tLS0tLS0tLS0tLXwKICAqLwogc3RhdGljIGludCB0cmllX2ZpbmQoc3RydWN0IHRyaWUgKnJvb3QsIGNvbnN0IGNoYXIgKmtleSwgbWF0Y2hfZm4gZm4sCiAJCSAgICAgdm9pZCAqYmF0b24pCkBAIC0yODgsOSArMzAwLDEzIEBACiAKIAkvKiBNYXRjaGVkIHRoZSBlbnRpcmUgY29tcHJlc3NlZCBzZWN0aW9uICovCiAJa2V5ICs9IGk7Ci0JaWYgKCEqa2V5KQorCWlmICghKmtleSkgewogCQkvKiBFbmQgb2Yga2V5ICovCi0JCXJldHVybiBmbihrZXksIHJvb3QtPnZhbHVlLCBiYXRvbik7CisJCWlmIChyb290LT52YWx1ZSkKKwkJCXJldHVybiBmbihrZXksIHJvb3QtPnZhbHVlLCBiYXRvbik7CisJCWVsc2UKKwkJCXJldHVybiAtMTsKKwl9CiAKIAkvKiBQYXJ0aWFsIHBhdGggbm9ybWFsaXphdGlvbjogc2tpcCBjb25zZWN1dGl2ZSBzbGFzaGVzICovCiAJd2hpbGUgKGtleVswXSA9PSAnLycgJiYga2V5WzFdID09ICcvJykKQEAgLTMyMCw4ICszMzYsOCBAQAogCWlmIChjb21tb25fdHJpZV9kb25lX3NldHVwKQogCQlyZXR1cm47CiAKLQlmb3IgKHAgPSBjb21tb25fbGlzdDsgcC0+ZGlybmFtZTsgcCsrKQotCQlhZGRfdG9fdHJpZSgmY29tbW9uX3RyaWUsIHAtPmRpcm5hbWUsIHApOworCWZvciAocCA9IGNvbW1vbl9saXN0OyBwLT5wYXRoOyBwKyspCisJCWFkZF90b190cmllKCZjb21tb25fdHJpZSwgcC0+cGF0aCwgcCk7CiAKIAljb21tb25fdHJpZV9kb25lX3NldHVwID0gMTsKIH0KQEAgLTMzNCwxNCArMzUwLDExIEBACiB7CiAJc3RydWN0IGNvbW1vbl9kaXIgKmRpciA9IHZhbHVlOwogCi0JaWYgKCFkaXIpCi0JCXJldHVybiAwOwotCiAJaWYgKGRpci0+aXNfZGlyICYmICh1bm1hdGNoZWRbMF0gPT0gMCB8fCB1bm1hdGNoZWRbMF0gPT0gJy8nKSkKLQkJcmV0dXJuICFkaXItPmV4Y2x1ZGU7CisJCXJldHVybiBkaXItPmlzX2NvbW1vbjsKIAogCWlmICghZGlyLT5pc19kaXIgJiYgdW5tYXRjaGVkWzBdID09IDApCi0JCXJldHVybiAhZGlyLT5leGNsdWRlOworCQlyZXR1cm4gZGlyLT5pc19jb21tb247CiAKIAlyZXR1cm4gMDsKIH0KQEAgLTM1MCw5ICszNjMsMTQgQEAKIAkJCSAgICAgIGNvbnN0IGNoYXIgKmNvbW1vbl9kaXIpCiB7CiAJY2hhciAqYmFzZSA9IGJ1Zi0+YnVmICsgZ2l0X2Rpcl9sZW47CisJaW50IGhhc19sb2NrX3N1ZmZpeCA9IHN0cmJ1Zl9zdHJpcF9zdWZmaXgoYnVmLCBMT0NLX1NVRkZJWCk7CisKIAlpbml0X2NvbW1vbl90cmllKCk7CiAJaWYgKHRyaWVfZmluZCgmY29tbW9uX3RyaWUsIGJhc2UsIGNoZWNrX2NvbW1vbiwgTlVMTCkgPiAwKQogCQlyZXBsYWNlX2RpcihidWYsIGdpdF9kaXJfbGVuLCBjb21tb25fZGlyKTsKKworCWlmIChoYXNfbG9ja19zdWZmaXgpCisJCXN0cmJ1Zl9hZGRzdHIoYnVmLCBMT0NLX1NVRkZJWCk7CiB9CiAKIHZvaWQgcmVwb3J0X2xpbmtlZF9jaGVja291dF9nYXJiYWdlKHZvaWQpCkBAIC0zNjUsOCArMzgzLDggQEAKIAkJcmV0dXJuOwogCXN0cmJ1Zl9hZGRmKCZzYiwgIiVzLyIsIGdldF9naXRfZGlyKCkpOwogCWxlbiA9IHNiLmxlbjsKLQlmb3IgKHAgPSBjb21tb25fbGlzdDsgcC0+ZGlybmFtZTsgcCsrKSB7Ci0JCWNvbnN0IGNoYXIgKnBhdGggPSBwLT5kaXJuYW1lOworCWZvciAocCA9IGNvbW1vbl9saXN0OyBwLT5wYXRoOyBwKyspIHsKKwkJY29uc3QgY2hhciAqcGF0aCA9IHAtPnBhdGg7CiAJCWlmIChwLT5pZ25vcmVfZ2FyYmFnZSkKIAkJCWNvbnRpbnVlOwogCQlzdHJidWZfc2V0bGVuKCZzYiwgbGVuKTsKQEAgLTEyMjEsMzEgKzEyMzksNTIgQEAKIH0KIAogLyoKKyAqIElmIHBhdGggZW5kcyB3aXRoIHN1ZmZpeCAoY29tcGxldGUgcGF0aCBjb21wb25lbnRzKSwgcmV0dXJucyB0aGUgb2Zmc2V0IG9mCisgKiB0aGUgbGFzdCBjaGFyYWN0ZXIgaW4gdGhlIHBhdGggYmVmb3JlIHRoZSBzdWZmaXggKHNhbnMgdHJhaWxpbmcgZGlyZWN0b3J5CisgKiBzZXBhcmF0b3JzKSwgYW5kIC0xIG90aGVyd2lzZS4KKyAqLworc3RhdGljIHNzaXplX3Qgc3RyaXBwZWRfcGF0aF9zdWZmaXhfb2Zmc2V0KGNvbnN0IGNoYXIgKnBhdGgsIGNvbnN0IGNoYXIgKnN1ZmZpeCkKK3sKKwlpbnQgcGF0aF9sZW4gPSBzdHJsZW4ocGF0aCksIHN1ZmZpeF9sZW4gPSBzdHJsZW4oc3VmZml4KTsKKworCXdoaWxlIChzdWZmaXhfbGVuKSB7CisJCWlmICghcGF0aF9sZW4pCisJCQlyZXR1cm4gLTE7CisKKwkJaWYgKGlzX2Rpcl9zZXAocGF0aFtwYXRoX2xlbiAtIDFdKSkgeworCQkJaWYgKCFpc19kaXJfc2VwKHN1ZmZpeFtzdWZmaXhfbGVuIC0gMV0pKQorCQkJCXJldHVybiAtMTsKKwkJCXBhdGhfbGVuID0gY2hvbXBfdHJhaWxpbmdfZGlyX3NlcChwYXRoLCBwYXRoX2xlbik7CisJCQlzdWZmaXhfbGVuID0gY2hvbXBfdHJhaWxpbmdfZGlyX3NlcChzdWZmaXgsIHN1ZmZpeF9sZW4pOworCQl9CisJCWVsc2UgaWYgKHBhdGhbLS1wYXRoX2xlbl0gIT0gc3VmZml4Wy0tc3VmZml4X2xlbl0pCisJCQlyZXR1cm4gLTE7CisJfQorCisJaWYgKHBhdGhfbGVuICYmICFpc19kaXJfc2VwKHBhdGhbcGF0aF9sZW4gLSAxXSkpCisJCXJldHVybiAtMTsKKwlyZXR1cm4gY2hvbXBfdHJhaWxpbmdfZGlyX3NlcChwYXRoLCBwYXRoX2xlbik7Cit9CisKKy8qCisgKiBSZXR1cm5zIHRydWUgaWYgdGhlIHBhdGggZW5kcyB3aXRoIGNvbXBvbmVudHMsIGNvbnNpZGVyaW5nIG9ubHkgY29tcGxldGUgcGF0aAorICogY29tcG9uZW50cywgYW5kIGZhbHNlIG90aGVyd2lzZS4KKyAqLworaW50IGVuZHNfd2l0aF9wYXRoX2NvbXBvbmVudHMoY29uc3QgY2hhciAqcGF0aCwgY29uc3QgY2hhciAqY29tcG9uZW50cykKK3sKKwlyZXR1cm4gc3RyaXBwZWRfcGF0aF9zdWZmaXhfb2Zmc2V0KHBhdGgsIGNvbXBvbmVudHMpICE9IC0xOworfQorCisvKgogICogSWYgcGF0aCBlbmRzIHdpdGggc3VmZml4IChjb21wbGV0ZSBwYXRoIGNvbXBvbmVudHMpLCByZXR1cm5zIHRoZQogICogcGFydCBiZWZvcmUgc3VmZml4IChzYW5zIHRyYWlsaW5nIGRpcmVjdG9yeSBzZXBhcmF0b3JzKS4KICAqIE90aGVyd2lzZSByZXR1cm5zIE5VTEwuCiAgKi8KIGNoYXIgKnN0cmlwX3BhdGhfc3VmZml4KGNvbnN0IGNoYXIgKnBhdGgsIGNvbnN0IGNoYXIgKnN1ZmZpeCkKIHsKLQlpbnQgcGF0aF9sZW4gPSBzdHJsZW4ocGF0aCksIHN1ZmZpeF9sZW4gPSBzdHJsZW4oc3VmZml4KTsKKwlzc2l6ZV90IG9mZnNldCA9IHN0cmlwcGVkX3BhdGhfc3VmZml4X29mZnNldChwYXRoLCBzdWZmaXgpOwogCi0Jd2hpbGUgKHN1ZmZpeF9sZW4pIHsKLQkJaWYgKCFwYXRoX2xlbikKLQkJCXJldHVybiBOVUxMOwotCi0JCWlmIChpc19kaXJfc2VwKHBhdGhbcGF0aF9sZW4gLSAxXSkpIHsKLQkJCWlmICghaXNfZGlyX3NlcChzdWZmaXhbc3VmZml4X2xlbiAtIDFdKSkKLQkJCQlyZXR1cm4gTlVMTDsKLQkJCXBhdGhfbGVuID0gY2hvbXBfdHJhaWxpbmdfZGlyX3NlcChwYXRoLCBwYXRoX2xlbik7Ci0JCQlzdWZmaXhfbGVuID0gY2hvbXBfdHJhaWxpbmdfZGlyX3NlcChzdWZmaXgsIHN1ZmZpeF9sZW4pOwotCQl9Ci0JCWVsc2UgaWYgKHBhdGhbLS1wYXRoX2xlbl0gIT0gc3VmZml4Wy0tc3VmZml4X2xlbl0pCi0JCQlyZXR1cm4gTlVMTDsKLQl9Ci0KLQlpZiAocGF0aF9sZW4gJiYgIWlzX2Rpcl9zZXAocGF0aFtwYXRoX2xlbiAtIDFdKSkKLQkJcmV0dXJuIE5VTEw7Ci0JcmV0dXJuIHhzdHJuZHVwKHBhdGgsIGNob21wX3RyYWlsaW5nX2Rpcl9zZXAocGF0aCwgcGF0aF9sZW4pKTsKKwlyZXR1cm4gb2Zmc2V0ID09IC0xID8gTlVMTCA6IHhzdHJuZHVwKHBhdGgsIG9mZnNldCk7CiB9CiAKIGludCBkYWVtb25fYXZvaWRfYWxpYXMoY29uc3QgY2hhciAqcCkKZGlmZiAtLWdpdCBhL3BhdGguaCBiL3BhdGguaAppbmRleCAyYmE2Y2E1Li4xNGQ2ZGNhIDEwMDY0NAotLS0gYS9wYXRoLmgKKysrIGIvcGF0aC5oCkBAIC0xOTMsNCArMTkzLDcgQEAKIGNvbnN0IGNoYXIgKmdpdF9wYXRoX2ZldGNoX2hlYWQoc3RydWN0IHJlcG9zaXRvcnkgKnIpOwogY29uc3QgY2hhciAqZ2l0X3BhdGhfc2hhbGxvdyhzdHJ1Y3QgcmVwb3NpdG9yeSAqcik7CiAKKworaW50IGVuZHNfd2l0aF9wYXRoX2NvbXBvbmVudHMoY29uc3QgY2hhciAqcGF0aCwgY29uc3QgY2hhciAqY29tcG9uZW50cyk7CisKICNlbmRpZiAvKiBQQVRIX0ggKi8KZGlmZiAtLWdpdCBhL3BlcmwvR2l0LnBtIGIvcGVybC9HaXQucG0KaW5kZXggNjJjNDcyZS4uNTRjOWVkMCAxMDA2NDQKLS0tIGEvcGVybC9HaXQucG0KKysrIGIvcGVybC9HaXQucG0KQEAgLTU2Myw3ICs1NjMsNyBAQAogUXVlcnkgdXNlciBDPFBST01QVD4gYW5kIHJldHVybiBhbnN3ZXIgZnJvbSB1c2VyLgogCiBIb25vdXJzIEdJVF9BU0tQQVNTIGFuZCBTU0hfQVNLUEFTUyBlbnZpcm9ubWVudCB2YXJpYWJsZXMgZm9yIHF1ZXJ5aW5nCi10aGUgdXNlci4gSWYgbm8gKl9BU0tQQVNTIHZhcmlhYmxlIGlzIHNldCBvciBhbiBlcnJvciBvY2NvdXJlZCwKK3RoZSB1c2VyLiBJZiBubyAqX0FTS1BBU1MgdmFyaWFibGUgaXMgc2V0IG9yIGFuIGVycm9yIG9jY3VycmVkLAogdGhlIHRlcm1pbmFsIGlzIHRyaWVkIGFzIGEgZmFsbGJhY2suCiBJZiBDPElTUEFTU1dPUkQ+IGlzIHNldCBhbmQgdHJ1ZSwgdGhlIHRlcm1pbmFsIGRpc2FibGVzIGVjaG8uCiAKZGlmZiAtLWdpdCBhL3BlcmwvR2l0L1NWTi5wbSBiL3BlcmwvR2l0L1NWTi5wbQppbmRleCA3NmIyOTY1Li40YjI4Yjg3IDEwMDY0NAotLS0gYS9wZXJsL0dpdC9TVk4ucG0KKysrIGIvcGVybC9HaXQvU1ZOLnBtCkBAIC0xNDkxLDYgKzE0OTEsMTAgQEAKIAogc3ViIGNoZWNrX2F1dGhvciB7CiAJbXkgKCRhdXRob3IpID0gQF87CisJaWYgKGRlZmluZWQgJGF1dGhvcikgeworCQkkYXV0aG9yID1+IHMvXlxzKy8vZzsKKwkJJGF1dGhvciA9fiBzL1xzKyQvL2c7CisJfQogCWlmICghZGVmaW5lZCAkYXV0aG9yIHx8IGxlbmd0aCAkYXV0aG9yID09IDApIHsKIAkJJGF1dGhvciA9ICcobm8gYXV0aG9yKSc7CiAJfQpkaWZmIC0tZ2l0IGEvcG8vYmcucG8gYi9wby9iZy5wbwppbmRleCBlMWQxMGRiLi5lNDQ2Yzc2IDEwMDY0NAotLS0gYS9wby9iZy5wbworKysgYi9wby9iZy5wbwpAQCAtMzEsNyArMzEsNyBAQAogIyBhbSDQv9GA0LjQu9Cw0LPQsNC8INC/0L7RgNC10LTQuNGG0LAg0L7RgiDQutGA0YrQv9C60LgKICMgd29ya2luZyBkaXJlY3RvcnkvdHJlZSDigJQg0LLQuNC90LDQs9C4INGA0LDQsdC+0YLQvdC+INC00YrRgNCy0L4sIGdpdCDRgdC70LXQtNC4INGG0Y/Qu9C+0YLQviDQtNGK0YDQstC+LCDQsCDQvdC1INC00LjRgNC10LrRgtC+0YDQuNC4LCDRgNCw0LHQvtGC0L3QsCDQtNC40YDQtdC60YLQvtGA0LjRjyDQt9CwIGN3ZAogIyBzd2l0Y2ggdG8gYnJhbmNoINC/0YDQtdC80LjQvdCw0LLQsNC8INC60YrQvCDQutC70L7QvQotIyBzcGFyc2UgZW50cnkg0YfQsNGB0YLQuNGH0L3QviDQuNC30YLQtdCz0LvQtdC90LAg0LTQuNGA0LXQutGC0L7RgNC40Y8v0L/RitGCCisjIHNwYXJzZSBlbnRyeS9ibG9iINGH0LDRgdGC0LjRh9C90L4g0LjQt9GC0LXQs9C70LXQvdCwINC00LjRgNC10LrRgtC+0YDQuNGPL9C/0YrRgi/QvtCx0LXQutGCLUJMT0IKICMgcmV2aXNpb24gcmFuZ2Ug0LTQuNCw0L/QsNC30L7QvSDQvdCwINCy0LXRgNGB0LjQuNGC0LUKICMgY292ZXIgbGV0dGVyINC/0YDQuNC00YDRg9C20LDQstCw0YnQviDQv9C40YHQvNC+CiAjIHJlZmVyZW5jZSByZXBvc2l0b3J5INC10YLQsNC70L7QvdC90L4g0YXRgNCw0L3QuNC70LjRidC1CkBAIC0xNTUsMTAgKzE1NSwxMCBAQAogIyBmb3IgaSBpbiBgc29ydCAtdSBGSUxFU2A7IGRvIGNudD1gZ3JlcCAkaSBGSUxFUyB8IHdjIC1sYDsgZWNobyAkY250ICRpIDtkb25lIHwgc29ydCAtbgogbXNnaWQgIiIKIG1zZ3N0ciAiIgotIlByb2plY3QtSWQtVmVyc2lvbjogZ2l0IDIuMjJcbiIKKyJQcm9qZWN0LUlkLVZlcnNpb246IGdpdCAyLjI0XG4iCiAiUmVwb3J0LU1zZ2lkLUJ1Z3MtVG86IEdpdCBNYWlsaW5nIExpc3QgPGdpdEB2Z2VyLmtlcm5lbC5vcmc+XG4iCi0iUE9ULUNyZWF0aW9uLURhdGU6IDIwMTktMDgtMTAgMTI6MjUrMDMwMFxuIgotIlBPLVJldmlzaW9uLURhdGU6IDIwMTktMDgtMTAgMTI6MzMrMDMwMFxuIgorIlBPVC1DcmVhdGlvbi1EYXRlOiAyMDE5LTEwLTI4IDEzOjE5KzA4MDBcbiIKKyJQTy1SZXZpc2lvbi1EYXRlOiAyMDE5LTEwLTI5IDExOjM1KzAxMDBcbiIKICJMYXN0LVRyYW5zbGF0b3I6IEFsZXhhbmRlciBTaG9wb3YgPGFzaEBrYW1iYW5hcmlhLm9yZz5cbiIKICJMYW5ndWFnZS1UZWFtOiBCdWxnYXJpYW4gPGRpY3RAZnNhLWJnLm9yZz5cbiIKICJMYW5ndWFnZTogYmdcbiIKQEAgLTIwOSw3ICsyMDksNyBAQAogbXNnaWQgIkV4aXRpbmcgYmVjYXVzZSBvZiBhbiB1bnJlc29sdmVkIGNvbmZsaWN0LiIKIG1zZ3N0ciAi0JjQt9GF0L7QtCDQvtGCINC/0YDQvtCz0YDQsNC80LDRgtCwINC30LDRgNCw0LTQuCDQvdC10LrQvtGA0LjQs9C40YDQsNC9INC60L7QvdGE0LvQuNC60YIuIgogCi0jOiBhZHZpY2UuYzoxOTMgYnVpbHRpbi9tZXJnZS5jOjEzMjcKKyM6IGFkdmljZS5jOjE5MyBidWlsdGluL21lcmdlLmM6MTMzMgogbXNnaWQgIllvdSBoYXZlIG5vdCBjb25jbHVkZWQgeW91ciBtZXJnZSAoTUVSR0VfSEVBRCBleGlzdHMpLiIKIG1zZ3N0ciAi0J3QtSDRgdGC0LUg0LfQsNCy0YrRgNGI0LjQu9C4INGB0LvQuNCy0LDQvdC1LiAgKNCj0LrQsNC30LDRgtC10LvRj9GCIOKAnk1FUkdFX0hFQUTigJwg0YHRitGJ0LXRgdGC0LLRg9Cy0LApLiIKIApAQCAtMzU1LDE3ICszNTUsNyBAQAogbXNnaWQgImluY29uc2lzdGVudCBoZWFkZXIgbGluZXMgJWQgYW5kICVkIgogbXNnc3RyICLQvdC10YHRitCy0LzQtdGB0YLQuNC80Lgg0LfQsNCz0LvQsNCy0L3QuCDRh9Cw0YHRgtC4INC90LAg0YDQtdC00L7QstC1IOKEliVkINC4IOKEliVkIgogCi0jOiBhcHBseS5jOjE0NjAKLSMsIGMtZm9ybWF0Ci1tc2dpZCAicmVjb3VudDogdW5leHBlY3RlZCBsaW5lOiAlLipzIgotbXNnc3RyICLQv9GA0Lgg0L/QvtCy0YLQvtGA0L3QvtGC0L4g0L/RgNC10LHRgNC+0Y/QstCw0L3QtSDQsdC1INC/0L7Qu9GD0YfQtdC9INC90LXQvtGH0LDQutCy0LDQvSDRgNC10LQ6IOKAniUuKnPigJwiCi0KLSM6IGFwcGx5LmM6MTUyOQotIywgYy1mb3JtYXQKLW1zZ2lkICJwYXRjaCBmcmFnbWVudCB3aXRob3V0IGhlYWRlciBhdCBsaW5lICVkOiAlLipzIgotbXNnc3RyICLRh9Cw0YHRgiDQvtGCINC60YDRitC/0LrQsCDQsdC10Lcg0LfQsNCz0LvQsNCy0L3QsCDRh9Cw0YHRgiDQvdCwINGA0LXQtCAlZDogJS4qcyIKLQotIzogYXBwbHkuYzoxNTUxCisjOiBhcHBseS5jOjEzNzIKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogImdpdCBkaWZmIGhlYWRlciBsYWNrcyBmaWxlbmFtZSBpbmZvcm1hdGlvbiB3aGVuIHJlbW92aW5nICVkIGxlYWRpbmcgcGF0aG5hbWUgIgpAQCAtMzgwLDcxICszNzAsODEgQEAKICLQodC70LXQtCDRgdGK0LrRgNCw0YnQsNCy0LDQvdC10YLQviDQvdCwINC/0YrRgNCy0LjRgtC1ICVkINGH0LDRgdGC0Lgg0L7RgiDQutC+0LzQv9C+0L3QtdC90YLQuNGC0LUg0L3QsCDQv9GK0YLRjywg0LIg0LfQsNCz0LvQsNCy0L3QsNGC0LAgIgogItGH0LDRgdGCINC90LAg4oCeZ2l0IGRpZmbigJwg0LvQuNC/0YHQstCwINC40L3RhNC+0YDQvNCw0YbQuNGPINC30LAg0LjQvNC1INC90LAg0YTQsNC50LsgKNGA0LXQtDogJWQpIgogCi0jOiBhcHBseS5jOjE1NjQKKyM6IGFwcGx5LmM6MTM4NQogIywgYy1mb3JtYXQKIG1zZ2lkICJnaXQgZGlmZiBoZWFkZXIgbGFja3MgZmlsZW5hbWUgaW5mb3JtYXRpb24gKGxpbmUgJWQpIgogbXNnc3RyICIiCiAi0LIg0LfQsNCz0LvQsNCy0L3QsNGC0LAg0YfQsNGB0YIg0L3QsCDigJ5naXQgZGlmZuKAnCDQu9C40L/RgdCy0LAg0LjQvdGE0L7RgNC80LDRhtC40Y8g0LfQsCDQuNC80LUg0L3QsCDRhNCw0LnQuyAo0YDQtdC0OiAlZCkiCiAKLSM6IGFwcGx5LmM6MTc1MgorIzogYXBwbHkuYzoxNDgxCisjLCBjLWZvcm1hdAorbXNnaWQgInJlY291bnQ6IHVuZXhwZWN0ZWQgbGluZTogJS4qcyIKK21zZ3N0ciAi0L/RgNC4INC/0L7QstGC0L7RgNC90L7RgtC+INC/0YDQtdCx0YDQvtGP0LLQsNC90LUg0LHQtSDQv9C+0LvRg9GH0LXQvSDQvdC10L7Rh9Cw0LrQstCw0L0g0YDQtdC0OiDigJ4lLipz4oCcIgorCisjOiBhcHBseS5jOjE1NTAKKyMsIGMtZm9ybWF0Cittc2dpZCAicGF0Y2ggZnJhZ21lbnQgd2l0aG91dCBoZWFkZXIgYXQgbGluZSAlZDogJS4qcyIKK21zZ3N0ciAi0YfQsNGB0YIg0L7RgiDQutGA0YrQv9C60LAg0LHQtdC3INC30LDQs9C70LDQstC90LAg0YfQsNGB0YIg0L3QsCDRgNC10LQgJWQ6ICUuKnMiCisKKyM6IGFwcGx5LmM6MTc1MwogbXNnaWQgIm5ldyBmaWxlIGRlcGVuZHMgb24gb2xkIGNvbnRlbnRzIgogbXNnc3RyICLQvdC+0LLQuNGP0YIg0YTQsNC50Lsg0LfQsNCy0LjRgdC4INC+0YIg0YHRgtCw0YDQvtGC0L4g0YHRitC00YrRgNC20LDQvdC40LUg0L3QsCDRhNCw0LnQu9CwIgogCi0jOiBhcHBseS5jOjE3NTQKKyM6IGFwcGx5LmM6MTc1NQogbXNnaWQgImRlbGV0ZWQgZmlsZSBzdGlsbCBoYXMgY29udGVudHMiCiBtc2dzdHIgItC40LfRgtGA0LjRgtC40Y/RgiDRhNCw0LnQuyDQvdC1INC1INC/0YDQsNC30LXQvSIKIAotIzogYXBwbHkuYzoxNzg4CisjOiBhcHBseS5jOjE3ODkKICMsIGMtZm9ybWF0CiBtc2dpZCAiY29ycnVwdCBwYXRjaCBhdCBsaW5lICVkIgogbXNnc3RyICLQs9GA0LXRiNC60LAg0LIg0LrRgNGK0L/QutCw0YLQsCDQvdCwINGA0LXQtCAlZCIKIAotIzogYXBwbHkuYzoxODI1CisjOiBhcHBseS5jOjE4MjYKICMsIGMtZm9ybWF0CiBtc2dpZCAibmV3IGZpbGUgJXMgZGVwZW5kcyBvbiBvbGQgY29udGVudHMiCiBtc2dzdHIgItC90L7QstC40Y/RgiDRhNCw0LnQuyDigJ4lc+KAnCDQt9Cw0LLQuNGB0Lgg0L7RgiDRgdGC0LDRgNC+0YLQviDRgdGK0LTRitGA0LbQsNC90LjQtSDQvdCwINGE0LDQudC70LAiCiAKLSM6IGFwcGx5LmM6MTgyNworIzogYXBwbHkuYzoxODI4CiAjLCBjLWZvcm1hdAogbXNnaWQgImRlbGV0ZWQgZmlsZSAlcyBzdGlsbCBoYXMgY29udGVudHMiCiBtc2dzdHIgItC40LfRgtGA0LjRgtC40Y/RgiDRhNCw0LnQuyDigJ4lc+KAnCDQvdC1INC1INC/0YDQsNC30LXQvSIKIAotIzogYXBwbHkuYzoxODMwCisjOiBhcHBseS5jOjE4MzEKICMsIGMtZm9ybWF0CiBtc2dpZCAiKiogd2FybmluZzogZmlsZSAlcyBiZWNvbWVzIGVtcHR5IGJ1dCBpcyBub3QgZGVsZXRlZCIKIG1zZ3N0ciAi4pePINC/0YDQtdC00YPQv9GA0LXQttC00LXQvdC40LU6INGE0LDQudC70YrRgiDigJ4lc+KAnCDQstC10YfQtSDQtSDQv9GA0LDQt9C10L0sINC90L4g0L3QtSDQtSDQuNC30YLRgNC40YIiCiAKLSM6IGFwcGx5LmM6MTk3NworIzogYXBwbHkuYzoxOTc4CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvcnJ1cHQgYmluYXJ5IHBhdGNoIGF0IGxpbmUgJWQ6ICUuKnMiCiBtc2dzdHIgItCz0YDQtdGI0LrQsCDQsiDQtNCy0L7QuNGH0L3QsNGC0LAg0LrRgNGK0L/QutCwINC90LAg0YDQtdC0ICVkOiAlLipzIgogCi0jOiBhcHBseS5jOjIwMTQKKyM6IGFwcGx5LmM6MjAxNQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bnJlY29nbml6ZWQgYmluYXJ5IHBhdGNoIGF0IGxpbmUgJWQiCiBtc2dzdHIgItC90LXRgNCw0LfQv9C+0LfQvdCw0YLQsCDQtNCy0L7QuNGH0L3QsNGC0LAg0LrRgNGK0L/QutCwINC90LAg0YDQtdC0ICVkIgogCi0jOiBhcHBseS5jOjIxNzYKKyM6IGFwcGx5LmM6MjE3NwogIywgYy1mb3JtYXQKIG1zZ2lkICJwYXRjaCB3aXRoIG9ubHkgZ2FyYmFnZSBhdCBsaW5lICVkIgogbXNnc3RyICLQutGA0YrQv9C60LDRgtCwINC1INGBINC40LfRhtGP0LvQviDQv9C+0LLRgNC10LTQtdC90Lgg0LTQsNC90L3QuCDQvdCwINGA0LXQtCAlZCIKIAotIzogYXBwbHkuYzoyMjYyCisjOiBhcHBseS5jOjIyNjMKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHJlYWQgc3ltbGluayAlcyIKIG1zZ3N0ciAi0YHQuNC80LLQvtC70L3QsNGC0LAg0LLRgNGK0LfQutCwIOKAniVz4oCcINC90LUg0LzQvtC20LUg0LTQsCDQsdGK0LTQtSDQv9GA0L7Rh9C10YLQtdC90LAiCiAKLSM6IGFwcGx5LmM6MjI2NgorIzogYXBwbHkuYzoyMjY3CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBvcGVuIG9yIHJlYWQgJXMiCiBtc2dzdHIgItGE0LDQudC70YrRgiDigJ4lc+KAnCDQvdC1INC80L7QttC1INC00LAg0LHRitC00LUg0L7RgtCy0L7RgNC10L0g0LjQu9C4INC/0YDQvtGH0LXRgtC10L0iCiAKLSM6IGFwcGx5LmM6MjkyNQorIzogYXBwbHkuYzoyOTI2CiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgc3RhcnQgb2YgbGluZTogJyVjJyIKIG1zZ3N0ciAi0L3QtdC/0YDQsNCy0LjQu9C90L4g0L3QsNGH0LDQu9C+INC90LAg0YDQtdC0OiDigJ4lY+KAnCIKIAotIzogYXBwbHkuYzozMDQ2CisjOiBhcHBseS5jOjMwNDcKICMsIGMtZm9ybWF0CiBtc2dpZCAiSHVuayAjJWQgc3VjY2VlZGVkIGF0ICVkIChvZmZzZXQgJWQgbGluZSkuIgogbXNnaWRfcGx1cmFsICJIdW5rICMlZCBzdWNjZWVkZWQgYXQgJWQgKG9mZnNldCAlZCBsaW5lcykuIgpAQCAtNDUzLDEzICs0NTMsMTMgQEAKIG1zZ3N0clsxXSAiIgogIiVkLdGC0L4g0L/QsNGA0YfQtSDQutC+0LQg0LHQtSDRg9GB0L/QtdGI0L3QviDQv9GA0LjQu9C+0LbQtdC90L4g0L3QsCDRgNC10LQgJWQgKNC+0YLQvNC10YHRgtCy0LDQvdC1INC+0YIgJWQg0YDQtdC00LApLiIKIAotIzogYXBwbHkuYzozMDU4CisjOiBhcHBseS5jOjMwNTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ29udGV4dCByZWR1Y2VkIHRvICglbGQvJWxkKSB0byBhcHBseSBmcmFnbWVudCBhdCAlZCIKIG1zZ3N0ciAiIgogItCa0L7QvdGC0LXQutGB0YLRitGCINC1INC90LDQvNCw0LvQtdC9INC90LAgKCVsZC8lbGQpINC30LAg0L/RgNC40LvQsNCz0LDQvdC10YLQviDQvdCwINC/0LDRgNGH0LXRgtC+INC60L7QtCDQvdCwINGA0LXQtCAlZCIKIAotIzogYXBwbHkuYzozMDY0CisjOiBhcHBseS5jOjMwNjUKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIndoaWxlIHNlYXJjaGluZyBmb3I6XG4iCkBAIC00NjgsMzE3ICs0NjgsMzE3IEBACiAi0L/RgNC4INGC0YrRgNGB0LXQvdC1INC30LA6XG4iCiAiJS4qcyIKIAotIzogYXBwbHkuYzozMDg2CisjOiBhcHBseS5jOjMwODcKICMsIGMtZm9ybWF0CiBtc2dpZCAibWlzc2luZyBiaW5hcnkgcGF0Y2ggZGF0YSBmb3IgJyVzJyIKIG1zZ3N0ciAi0LvQuNC/0YHQstCw0YIg0LTQsNC90L3QuNGC0LUg0LfQsCDQtNCy0L7QuNGH0L3QsNGC0LAg0LrRgNGK0L/QutCwINC30LAg4oCeJXPigJwiCiAKLSM6IGFwcGx5LmM6MzA5NAorIzogYXBwbHkuYzozMDk1CiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCByZXZlcnNlLWFwcGx5IGEgYmluYXJ5IHBhdGNoIHdpdGhvdXQgdGhlIHJldmVyc2UgaHVuayB0byAnJXMnIgogbXNnc3RyICIiCiAi0LTQstC+0LjRh9C90LDRgtCwINC60YDRitC/0LrQsCDQvdC1INC80L7QttC1INC00LAg0YHQtSDQv9GA0LjQu9C+0LbQuCDQsiDQvtCx0YDQsNGC0L3QsCDQv9C+0YHQvtC60LAsINC60L7Qs9Cw0YLQviDQvtCx0YDQsNGC0L3QvtGC0L4gIgogItC/0LDRgNGH0LUg0LfQsCDigJ4lc+KAnCDQu9C40L/RgdCy0LAiCiAKLSM6IGFwcGx5LmM6MzE0MQorIzogYXBwbHkuYzozMTQyCiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCBhcHBseSBiaW5hcnkgcGF0Y2ggdG8gJyVzJyB3aXRob3V0IGZ1bGwgaW5kZXggbGluZSIKIG1zZ3N0ciAi0LrRitC8IOKAniVz4oCcINC90LUg0LzQvtC20LUg0LTQsCDRgdC1INC/0YDQuNC70L7QttC4INC00LLQvtC40YfQvdCwINC60YDRitC/0LrQsCDQsdC10Lcg0L/RitC70LXQvSDQuNC90LTQtdC60YEiCiAKLSM6IGFwcGx5LmM6MzE1MQorIzogYXBwbHkuYzozMTUyCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJ0aGUgcGF0Y2ggYXBwbGllcyB0byAnJXMnICglcyksIHdoaWNoIGRvZXMgbm90IG1hdGNoIHRoZSBjdXJyZW50IGNvbnRlbnRzLiIKIG1zZ3N0ciAi0LrRgNGK0L/QutCw0YLQsCDRgdGK0L7RgtCy0LXRgtGB0YLQstCwINC90LAg4oCeJXPigJwgKCVzKSwg0LrQvtC50YLQviDQvdC1INGB0YrQstC/0LDQtNCwINC/0L4g0YHRitC00YrRgNC20LDQvdC40LUuIgogCi0jOiBhcHBseS5jOjMxNTkKKyM6IGFwcGx5LmM6MzE2MAogIywgYy1mb3JtYXQKIG1zZ2lkICJ0aGUgcGF0Y2ggYXBwbGllcyB0byBhbiBlbXB0eSAnJXMnIGJ1dCBpdCBpcyBub3QgZW1wdHkiCiBtc2dzdHIgItC60YDRitC/0LrQsNGC0LAg0YHRitC+0YLQstC10YLRgdGC0LLQsCDQvdCwIOKAniVz4oCcLCDQutC+0LnRgtC+INGC0YDRj9Cx0LLQsCDQtNCwINC1INC/0YDQsNC30LXQvSwg0L3QviDQvdC1INC1IgogCi0jOiBhcHBseS5jOjMxNzcKKyM6IGFwcGx5LmM6MzE3OAogIywgYy1mb3JtYXQKIG1zZ2lkICJ0aGUgbmVjZXNzYXJ5IHBvc3RpbWFnZSAlcyBmb3IgJyVzJyBjYW5ub3QgYmUgcmVhZCIKIG1zZ3N0ciAiIgogItC90LXQvtCx0YXQvtC00LjQvNC40Y/RgiDRgNC10LfRg9C70YLQsNGCINGB0LvQtdC0INC+0L/QtdGA0LDRhtC40Y/RgtCwICDigJQg4oCeJXPigJwg0LfQsCDigJ4lc+KAnCDQvdC1INC80L7QttC1INC00LAg0LHRitC00LUgIgogItC/0YDQvtGH0LXRgtC10L0iCiAKLSM6IGFwcGx5LmM6MzE5MAorIzogYXBwbHkuYzozMTkxCiAjLCBjLWZvcm1hdAogbXNnaWQgImJpbmFyeSBwYXRjaCBkb2VzIG5vdCBhcHBseSB0byAnJXMnIgogbXNnc3RyICLQtNCy0L7QuNGH0L3QsNGC0LAg0LrRgNGK0L/QutCwINC90LUg0LzQvtC20LUg0LTQsCDQsdGK0LTQtSDQv9GA0LjQu9C+0LbQtdC90LAg0LLRitGA0YXRgyDigJ4lc+KAnCIKIAotIzogYXBwbHkuYzozMTk2CisjOiBhcHBseS5jOjMxOTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiYmluYXJ5IHBhdGNoIHRvICclcycgY3JlYXRlcyBpbmNvcnJlY3QgcmVzdWx0IChleHBlY3RpbmcgJXMsIGdvdCAlcykiCiBtc2dzdHIgIiIKICLQtNCy0L7QuNGH0L3QsNGC0LAg0LrRgNGK0L/QutCwINC30LAg4oCeJXPigJwg0LLQvtC00Lgg0LTQviDQvdC10L/RgNCw0LLQuNC70L3QuCDRgNC10LfRg9C70YLQsNGC0LggKNC+0YfQsNC60LLQsNGI0LUg0YHQtTog4oCeJXPigJwsINCwICIKICLQsdC1INC/0L7Qu9GD0YfQtdC90L46IOKAniVz4oCcKSIKIAotIzogYXBwbHkuYzozMjE3CisjOiBhcHBseS5jOjMyMTgKICMsIGMtZm9ybWF0CiBtc2dpZCAicGF0Y2ggZmFpbGVkOiAlczolbGQiCiBtc2dzdHIgItC90LXRg9GB0L/QtdGI0L3QviDQv9GA0LjQu9Cw0LPQsNC90LUg0L3QsCDQutGA0YrQv9C60LA6IOKAniVzOiVsZOKAnCIKIAotIzogYXBwbHkuYzozMzQwCisjOiBhcHBseS5jOjMzNDEKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IGNoZWNrb3V0ICVzIgogbXNnc3RyICLigJ4lc+KAnCDQvdC1INC80L7QttC1INC00LAg0YHQtSDQuNC30YLQtdCz0LvQuCIKIAotIzogYXBwbHkuYzozMzkyIGFwcGx5LmM6MzQwMyBhcHBseS5jOjM0NDkgbWlkeC5jOjYyIHNldHVwLmM6Mjc5CisjOiBhcHBseS5jOjMzOTMgYXBwbHkuYzozNDA0IGFwcGx5LmM6MzQ1MCBtaWR4LmM6NjEgc2V0dXAuYzoyODAKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIHJlYWQgJXMiCiBtc2dzdHIgItGE0LDQudC70YrRgiDigJ4lc+KAnCDQvdC1INC80L7QttC1INC00LAg0LHRitC00LUg0L/RgNC+0YfQtdGC0LXQvSIKIAotIzogYXBwbHkuYzozNDAwCisjOiBhcHBseS5jOjM0MDEKICMsIGMtZm9ybWF0CiBtc2dpZCAicmVhZGluZyBmcm9tICclcycgYmV5b25kIGEgc3ltYm9saWMgbGluayIKIG1zZ3N0ciAi0LjQt9GH0LjRgtCw0L3QtSDQvdCwIOKAniVz4oCcINGB0LvQtdC0INC/0YDQvtGB0LvQtdC00Y/QstCw0L3QtSDQvdCwINGB0LjQvNCy0L7Qu9C90LAg0LLRgNGK0LfQutCwIgogCi0jOiBhcHBseS5jOjM0MjkgYXBwbHkuYzozNjcyCisjOiBhcHBseS5jOjM0MzAgYXBwbHkuYzozNjczCiAjLCBjLWZvcm1hdAogbXNnaWQgInBhdGggJXMgaGFzIGJlZW4gcmVuYW1lZC9kZWxldGVkIgogbXNnc3RyICLQvtCx0LXQutGC0YrRgiDRgSDQv9GK0YIg4oCeJXPigJwg0LUg0L/RgNC10LjQvNC10L3Rg9Cy0LDQvSDQuNC70Lgg0LjQt9GC0YDQuNGCIgogCi0jOiBhcHBseS5jOjM1MTUgYXBwbHkuYzozNjg3CisjOiBhcHBseS5jOjM1MTYgYXBwbHkuYzozNjg4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiBkb2VzIG5vdCBleGlzdCBpbiBpbmRleCIKIG1zZ3N0ciAi4oCeJXPigJwg0L3QtSDRgdGK0YnQtdGB0YLQstGD0LLQsCDQsiDQuNC90LTQtdC60YHQsCIKIAotIzogYXBwbHkuYzozNTI0IGFwcGx5LmM6MzY5NQorIzogYXBwbHkuYzozNTI1IGFwcGx5LmM6MzY5NgogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogZG9lcyBub3QgbWF0Y2ggaW5kZXgiCiBtc2dzdHIgIuKAniVz4oCcINC90LUg0YHRitC+0YLQstC10YLRgdGC0LLQsCDQvdCwINC40L3QtNC10LrRgdCwIgogCi0jOiBhcHBseS5jOjM1NTkKKyM6IGFwcGx5LmM6MzU2MAogbXNnaWQgInJlcG9zaXRvcnkgbGFja3MgdGhlIG5lY2Vzc2FyeSBibG9iIHRvIGZhbGwgYmFjayBvbiAzLXdheSBtZXJnZS4iCiBtc2dzdHIgIiIKICLQsiDRhdGA0LDQvdC40LvQuNGJ0LXRgtC+INC70LjQv9GB0LLQsNGCINC90LXQvtCx0YXQvtC00LjQvNC40YLQtSDQvtCx0LXQutGC0LgtQkxPQiwg0LfQsCDQtNCwINGB0LUg0L/RgNC10LzQuNC90LUg0LrRitC8INGC0YDQvtC50L3QviAiCiAi0YHQu9C40LLQsNC90LUuIgogCi0jOiBhcHBseS5jOjM1NjIKKyM6IGFwcGx5LmM6MzU2MwogIywgYy1mb3JtYXQKIG1zZ2lkICJGYWxsaW5nIGJhY2sgdG8gdGhyZWUtd2F5IG1lcmdlLi4uXG4iCiBtc2dzdHIgItCf0YDQtdC80LjQvdCw0LLQsNC90LUg0LrRitC8INGC0YDQvtC50L3QviDRgdC70LjQstCw0L3QteKAplxuIgogCi0jOiBhcHBseS5jOjM1NzggYXBwbHkuYzozNTgyCisjOiBhcHBseS5jOjM1NzkgYXBwbHkuYzozNTgzCiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCByZWFkIHRoZSBjdXJyZW50IGNvbnRlbnRzIG9mICclcyciCiBtc2dzdHIgItGC0LXQutGD0YnQvtGC0L4g0YHRitC00YrRgNC20LDQvdC40LUg0L3QsCDigJ4lc+KAnCDQvdC1INC80L7QttC1INC00LAg0LHRitC00LUg0L/RgNC+0YfQtdGC0LXQvdC+IgogCi0jOiBhcHBseS5jOjM1OTQKKyM6IGFwcGx5LmM6MzU5NQogIywgYy1mb3JtYXQKIG1zZ2lkICJGYWlsZWQgdG8gZmFsbCBiYWNrIG9uIHRocmVlLXdheSBtZXJnZS4uLlxuIgogbXNnc3RyICLQndC10YPRgdC/0LXRiNC90L4g0L/RgNC10LzQuNC90LDQstCw0L3QtSDQutGK0Lwg0YLRgNC+0LnQvdC+INGB0LvQuNCy0LDQvdC14oCmXG4iCiAKLSM6IGFwcGx5LmM6MzYwOAorIzogYXBwbHkuYzozNjA5CiAjLCBjLWZvcm1hdAogbXNnaWQgIkFwcGxpZWQgcGF0Y2ggdG8gJyVzJyB3aXRoIGNvbmZsaWN0cy5cbiIKIG1zZ3N0ciAi0JrQvtC90YTQu9C40LrRgtC4INC/0YDQuCDQv9GA0LjQu9Cw0LPQsNC90LXRgtC+INC90LAg0LrRgNGK0L/QutCw0YLQsCDQutGK0Lwg4oCeJXPigJwuXG4iCiAKLSM6IGFwcGx5LmM6MzYxMworIzogYXBwbHkuYzozNjE0CiAjLCBjLWZvcm1hdAogbXNnaWQgIkFwcGxpZWQgcGF0Y2ggdG8gJyVzJyBjbGVhbmx5LlxuIgogbXNnc3RyICLQmtGA0YrQv9C60LDRgtCwINCx0LUg0L/RgNC40LvQvtC20LXQvdCwINGH0LjRgdGC0L4g0LrRitC8IOKAniVz4oCcLlxuIgogCi0jOiBhcHBseS5jOjM2MzkKKyM6IGFwcGx5LmM6MzY0MAogbXNnaWQgInJlbW92YWwgcGF0Y2ggbGVhdmVzIGZpbGUgY29udGVudHMiCiBtc2dzdHIgItC40LfRgtGA0LjQstCw0YnQsNGC0LAg0LrRgNGK0L/QutCwINC+0YHRgtCw0LLRjyDRhNCw0LnQu9CwINC90LXQv9GA0LDQt9C10L0iCiAKLSM6IGFwcGx5LmM6MzcxMgorIzogYXBwbHkuYzozNzEzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiB3cm9uZyB0eXBlIgogbXNnc3RyICLigJ4lc+KAnDog0L3QtdC/0YDQsNCy0LjQu9C10L0g0LLQuNC0IgogCi0jOiBhcHBseS5jOjM3MTQKKyM6IGFwcGx5LmM6MzcxNQogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyBoYXMgdHlwZSAlbywgZXhwZWN0ZWQgJW8iCiBtc2dzdHIgIuKAniVz4oCcINC1INC+0YIg0LLQuNC0IOKAniVv4oCcLCDQsCDRgdC1INC+0YfQsNC60LLQsNGI0LUg4oCeJW/igJwiCiAKLSM6IGFwcGx5LmM6Mzg2NSBhcHBseS5jOjM4NjcgcmVhZC1jYWNoZS5jOjgzMCByZWFkLWNhY2hlLmM6ODU2CisjOiBhcHBseS5jOjM4NjYgYXBwbHkuYzozODY4IHJlYWQtY2FjaGUuYzo4MzAgcmVhZC1jYWNoZS5jOjg1NgogIzogcmVhZC1jYWNoZS5jOjEzMDkKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBwYXRoICclcyciCiBtc2dzdHIgItC90LXQv9GA0LDQstC40LvQtdC9INC/0YrRgjog4oCeJXPigJwiCiAKLSM6IGFwcGx5LmM6MzkyMworIzogYXBwbHkuYzozOTI0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiBhbHJlYWR5IGV4aXN0cyBpbiBpbmRleCIKIG1zZ3N0ciAi4oCeJXPigJw6INCy0LXRh9C1INGB0YrRidC10YHRgtCy0YPQstCwINCyINC40L3QtNC10LrRgdCwIgogCi0jOiBhcHBseS5jOjM5MjYKKyM6IGFwcGx5LmM6MzkyNwogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogYWxyZWFkeSBleGlzdHMgaW4gd29ya2luZyBkaXJlY3RvcnkiCiBtc2dzdHIgIuKAniVz4oCcOiDQstC10YfQtSDRgdGK0YnQtdGB0YLQstGD0LLQsCDQsiDRgNCw0LHQvtGC0L3QvtGC0L4g0LTRitGA0LLQviIKIAotIzogYXBwbHkuYzozOTQ2CisjOiBhcHBseS5jOjM5NDcKICMsIGMtZm9ybWF0CiBtc2dpZCAibmV3IG1vZGUgKCVvKSBvZiAlcyBkb2VzIG5vdCBtYXRjaCBvbGQgbW9kZSAoJW8pIgogbXNnc3RyICLQvdC+0LLQuNGC0LUg0L/RgNCw0LLQsCDQt9CwINC00L7RgdGC0YrQvyAoJW8pINC90LAg4oCeJXPigJwg0L3QtSDRgdGK0LLQv9Cw0LTQsNGCINGB0YrRgSDRgdGC0LDRgNC40YLQtSAoJW8pIgogCi0jOiBhcHBseS5jOjM5NTEKKyM6IGFwcGx5LmM6Mzk1MgogIywgYy1mb3JtYXQKIG1zZ2lkICJuZXcgbW9kZSAoJW8pIG9mICVzIGRvZXMgbm90IG1hdGNoIG9sZCBtb2RlICglbykgb2YgJXMiCiBtc2dzdHIgIiIKICLQvdC+0LLQuNGC0LUg0L/RgNCw0LLQsCDQt9CwINC00L7RgdGC0YrQvyAoJW8pINC90LAg4oCeJXPigJwg0L3QtSDRgdGK0LLQv9Cw0LTQsNGCINGB0YrRgSDRgdGC0LDRgNC40YLQtSAoJW8pINC90LAg4oCeJXPigJwiCiAKLSM6IGFwcGx5LmM6Mzk3MQorIzogYXBwbHkuYzozOTcyCiAjLCBjLWZvcm1hdAogbXNnaWQgImFmZmVjdGVkIGZpbGUgJyVzJyBpcyBiZXlvbmQgYSBzeW1ib2xpYyBsaW5rIgogbXNnc3RyICLQt9Cw0YHQtdCz0L3QsNGC0LjRj9GCINGE0LDQudC7IOKAniVz4oCcINC1INGB0LvQtdC0INGB0LjQvNCy0L7Qu9C90LAg0LLRgNGK0LfQutCwIgogCi0jOiBhcHBseS5jOjM5NzUKKyM6IGFwcGx5LmM6Mzk3NgogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogcGF0Y2ggZG9lcyBub3QgYXBwbHkiCiBtc2dzdHIgItCa0YDRitC/0LrQsNGC0LAg4oCeJXPigJwg0L3QtSDQvNC+0LbQtSDQtNCwINCx0YrQtNC1INC/0YDQuNC70L7QttC10L3QsCIKIAotIzogYXBwbHkuYzozOTkwCisjOiBhcHBseS5jOjM5OTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ2hlY2tpbmcgcGF0Y2ggJXMuLi4iCiBtc2dzdHIgItCf0YDQvtCy0LXRgNGP0LLQsNC90LUg0L3QsCDQutGA0YrQv9C60LDRgtCwIOKAniVz4oCc4oCmIgogCi0jOiBhcHBseS5jOjQwODIKKyM6IGFwcGx5LmM6NDA4MwogIywgYy1mb3JtYXQKIG1zZ2lkICJzaGExIGluZm9ybWF0aW9uIGlzIGxhY2tpbmcgb3IgdXNlbGVzcyBmb3Igc3VibW9kdWxlICVzIgogbXNnc3RyICIiCiAi0LjQvdGE0L7RgNC80LDRhtC40Y/RgtCwINC30LAg0YHRg9C80LDRgtCwINC/0L4gU0hBMSDQt9CwINC/0L7QtNC80L7QtNGD0LvQsCDQu9C40L/RgdCy0LAg0LjQu9C4INC90LUg0LUg0LTQvtGB0YLQsNGC0YrRh9C90LAgKCVzKS4iCiAKLSM6IGFwcGx5LmM6NDA4OQorIzogYXBwbHkuYzo0MDkwCiAjLCBjLWZvcm1hdAogbXNnaWQgIm1vZGUgY2hhbmdlIGZvciAlcywgd2hpY2ggaXMgbm90IGluIGN1cnJlbnQgSEVBRCIKIG1zZ3N0ciAi0YHQvNGP0L3QsCDQvdCwINGA0LXQttC40LzQsCDQvdCwINC00L7RgdGC0YrQv9CwINC90LAg4oCeJXPigJwsINC60L7QudGC0L4g0L3QtSDQtSDQsiDRgtC10LrRg9GJ0LjRjyDQstGA0YrRhSDigJ5IRUFE4oCcIgogCi0jOiBhcHBseS5jOjQwOTIKKyM6IGFwcGx5LmM6NDA5MwogIywgYy1mb3JtYXQKIG1zZ2lkICJzaGExIGluZm9ybWF0aW9uIGlzIGxhY2tpbmcgb3IgdXNlbGVzcyAoJXMpLiIKIG1zZ3N0ciAi0LjQvdGE0L7RgNC80LDRhtC40Y/RgtCwINC30LAg0YHRg9C80LDRgtCwINC/0L4gU0hBMSDQu9C40L/RgdCy0LAg0LjQu9C4INC90LUg0LUg0LTQvtGB0YLQsNGC0YrRh9C90LAgKCVzKS4iCiAKLSM6IGFwcGx5LmM6NDA5NyBidWlsdGluL2NoZWNrb3V0LmM6Mjc4IGJ1aWx0aW4vcmVzZXQuYzoxNDMKKyM6IGFwcGx5LmM6NDA5OCBidWlsdGluL2NoZWNrb3V0LmM6Mjc5IGJ1aWx0aW4vcmVzZXQuYzoxNDMKICMsIGMtZm9ybWF0CiBtc2dpZCAibWFrZV9jYWNoZV9lbnRyeSBmYWlsZWQgZm9yIHBhdGggJyVzJyIKIG1zZ3N0ciAi0L3QtdGD0YHQv9C10YjQvdC+INGB0YrQt9C00LDQstCw0L3QtSDQvdCwINC30LDQv9C40YEg0LIg0LrQtdGI0LAg0YfRgNC10Lcg4oCebWFrZV9jYWNoZV9lbnRyeeKAnCDQt9CwIOKAniVz4oCcIgogCi0jOiBhcHBseS5jOjQxMDEKKyM6IGFwcGx5LmM6NDEwMgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgYWRkICVzIHRvIHRlbXBvcmFyeSBpbmRleCIKIG1zZ3N0ciAi4oCeJXPigJwg0L3QtSDQvNC+0LbQtSDQtNCwINGB0LUg0LTQvtCx0LDQstC4INC60YrQvCDQstGA0LXQvNC10L3QvdC40Y8g0LjQvdC00LXQutGBIgogCi0jOiBhcHBseS5jOjQxMTEKKyM6IGFwcGx5LmM6NDExMgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3Qgd3JpdGUgdGVtcG9yYXJ5IGluZGV4IHRvICVzIgogbXNnc3RyICLQstGA0LXQvNC10L3QvdC40Y/RgiDQuNC90LTQtdC60YEg0L3QtSDQvNC+0LbQtSDQtNCwINGB0LUg0LfQsNC/0LDQt9C4INCyIOKAniVz4oCcIgogCi0jOiBhcHBseS5jOjQyNDkKKyM6IGFwcGx5LmM6NDI1MAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gcmVtb3ZlICVzIGZyb20gaW5kZXgiCiBtc2dzdHIgIuKAniVz4oCcINC90LUg0LzQvtC20LUg0LTQsCDRgdC1INC40LfQstCw0LTQuCDQvtGCINC40L3QtNC10LrRgdCwIgogCi0jOiBhcHBseS5jOjQyODMKKyM6IGFwcGx5LmM6NDI4NAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3JydXB0IHBhdGNoIGZvciBzdWJtb2R1bGUgJXMiCiBtc2dzdHIgItC/0L7QstGA0LXQtNC10L3QsCDQutGA0YrQv9C60LAg0LfQsCDQvNC+0LTRg9C70LAg4oCeJXPigJwiCiAKLSM6IGFwcGx5LmM6NDI4OQorIzogYXBwbHkuYzo0MjkwCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBzdGF0IG5ld2x5IGNyZWF0ZWQgZmlsZSAnJXMnIgogbXNnc3RyICIiCiAi0L3QtSDQvNC+0LbQtSDQtNCwINGB0LUg0L/QvtC70YPRh9C4INC40L3RhNC+0YDQvNCw0YbQuNGPINGH0YDQtdC3IOKAnnN0YXTigJwg0LfQsCDQvdC+0LLQvtGB0YrQt9C00LDQtNC10L3QuNGPINGE0LDQudC7IOKAniVz4oCcIgogCi0jOiBhcHBseS5jOjQyOTcKKyM6IGFwcGx5LmM6NDI5OAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gY3JlYXRlIGJhY2tpbmcgc3RvcmUgZm9yIG5ld2x5IGNyZWF0ZWQgZmlsZSAlcyIKIG1zZ3N0ciAiIgogItC90LUg0LzQvtC20LUg0LTQsCDRgdC1INC30LAg0YHRitC30LTQsNC00LUg0LzRj9GB0YLQvtGC0L4g0LfQsCDRgdGK0YXRgNCw0L3QtdC90LjQtSDQvdCwINC90L7QstC+0YHRitC30LTQsNC00LXQvdC40Y8g0YTQsNC50Lsg4oCeJXPigJwiCiAKLSM6IGFwcGx5LmM6NDMwMyBhcHBseS5jOjQ0NDgKKyM6IGFwcGx5LmM6NDMwNCBhcHBseS5jOjQ0NDkKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGFkZCBjYWNoZSBlbnRyeSBmb3IgJXMiCiBtc2dzdHIgItC90LUg0LzQvtC20LUg0LTQsCDRgdC1INC00L7QsdCw0LLQuCDQt9Cw0L/QuNGBINCyINC60LXRiNCwINC30LAg4oCeJXPigJwiCiAKLSM6IGFwcGx5LmM6NDM0NgorIzogYXBwbHkuYzo0MzQ3CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byB3cml0ZSB0byAnJXMnIgogbXNnc3RyICLQsiDigJ4lc+KAnCDQvdC1INC80L7QttC1INC00LAg0YHQtSDQv9C40YjQtSIKIAotIzogYXBwbHkuYzo0MzUwCisjOiBhcHBseS5jOjQzNTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2xvc2luZyBmaWxlICclcyciCiBtc2dzdHIgItC30LDRgtCy0LDRgNGP0L3QtSDQvdCwINGE0LDQudC70LAg4oCeJXPigJwiCiAKLSM6IGFwcGx5LmM6NDQyMAorIzogYXBwbHkuYzo0NDIxCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byB3cml0ZSBmaWxlICclcycgbW9kZSAlbyIKIG1zZ3N0ciAi0YTQsNC50LvRitGCIOKAniVz4oCcINC90LUg0LzQvtC20LUg0LTQsCDRgdC1INC30LDQv9C40YjQtSDRgSDRgNC10LbQuNC8INC90LAg0LTQvtGB0YLRitC/IOKAniVv4oCcIgogCi0jOiBhcHBseS5jOjQ1MTgKKyM6IGFwcGx5LmM6NDUxOQogIywgYy1mb3JtYXQKIG1zZ2lkICJBcHBsaWVkIHBhdGNoICVzIGNsZWFubHkuIgogbXNnc3RyICLQmtGA0YrQv9C60LDRgtCwIOKAniVz4oCcINCx0LUg0L/RgNC40LvQvtC20LXQvdCwINGH0LjRgdGC0L4uIgogCi0jOiBhcHBseS5jOjQ1MjYKKyM6IGFwcGx5LmM6NDUyNwogbXNnaWQgImludGVybmFsIGVycm9yIgogbXNnc3RyICLQstGK0YLRgNC10YjQvdCwINCz0YDQtdGI0LrQsCIKIAotIzogYXBwbHkuYzo0NTI5CisjOiBhcHBseS5jOjQ1MzAKICMsIGMtZm9ybWF0CiBtc2dpZCAiQXBwbHlpbmcgcGF0Y2ggJSVzIHdpdGggJWQgcmVqZWN0Li4uIgogbXNnaWRfcGx1cmFsICJBcHBseWluZyBwYXRjaCAlJXMgd2l0aCAlZCByZWplY3RzLi4uIgogbXNnc3RyWzBdICLQn9GA0LjQu9Cw0LPQsNC90LUg0L3QsCDQutGA0YrQv9C60LDRgtCwIOKAniUlc+KAnCDRgSAlZCDQvtGC0YXQstGK0YDQu9C10L3QviDQv9Cw0YDRh9C14oCmIgogbXNnc3RyWzFdICLQn9GA0LjQu9Cw0LPQsNC90LUg0L3QsCDQutGA0YrQv9C60LDRgtCwIOKAniUlc+KAnCDRgSAlZCDQvtGC0YXQstGK0YDQu9C10L3QuCDQv9Cw0YDRh9C10YLQsOKApiIKIAotIzogYXBwbHkuYzo0NTQwCisjOiBhcHBseS5jOjQ1NDEKICMsIGMtZm9ybWF0CiBtc2dpZCAidHJ1bmNhdGluZyAucmVqIGZpbGVuYW1lIHRvICUuKnMucmVqIgogbXNnc3RyICLRgdGK0LrRgNCw0YnQsNCy0LDQvdC1INC90LAg0LjQvNC10YLQviDQvdCwINGE0LDQudC70LAg0YEg0L7RgtGF0LLRitGA0LvQtdC90LjRgtC1INC/0LDRgNGH0LXRgtCwINC90LAg4oCeICUuKnMucmVq4oCcIgogCi0jOiBhcHBseS5jOjQ1NDggYnVpbHRpbi9mZXRjaC5jOjg3OCBidWlsdGluL2ZldGNoLmM6MTE2OAorIzogYXBwbHkuYzo0NTQ5IGJ1aWx0aW4vZmV0Y2guYzo4OTggYnVpbHRpbi9mZXRjaC5jOjExOTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IG9wZW4gJXMiCiBtc2dzdHIgIuKAniVz4oCcINC90LUg0LzQvtC20LUg0LTQsCDQsdGK0LTQtSDQvtGC0LLQvtGA0LXQvSIKIAotIzogYXBwbHkuYzo0NTYyCisjOiBhcHBseS5jOjQ1NjMKICMsIGMtZm9ybWF0CiBtc2dpZCAiSHVuayAjJWQgYXBwbGllZCBjbGVhbmx5LiIKIG1zZ3N0ciAiJWQt0YLQviDQv9Cw0YDRh9C1INCx0LUg0YPRgdC/0LXRiNC90L4g0L/RgNC40LvQvtC20LXQvdC+LiIKIAotIzogYXBwbHkuYzo0NTY2CisjOiBhcHBseS5jOjQ1NjcKICMsIGMtZm9ybWF0CiBtc2dpZCAiUmVqZWN0ZWQgaHVuayAjJWQuIgogbXNnc3RyICIlZC3RgtC+INC/0LDRgNGH0LUg0LHQtSDQvtGC0YXQstGK0YDQu9C10L3Qvi4iCiAKLSM6IGFwcGx5LmM6NDY3NgorIzogYXBwbHkuYzo0Njg2CiAjLCBjLWZvcm1hdAogbXNnaWQgIlNraXBwZWQgcGF0Y2ggJyVzJy4iCiBtc2dzdHIgItCf0YDQvtC/0YPRgdC90LDRgtCwINC60YDRitC/0LrQsDog4oCeJXPigJwiCiAKLSM6IGFwcGx5LmM6NDY4NAorIzogYXBwbHkuYzo0Njk0CiBtc2dpZCAidW5yZWNvZ25pemVkIGlucHV0IgogbXNnc3RyICLQvdC10L/QvtC30L3QsNGCINCy0YXQvtC0IgogCi0jOiBhcHBseS5jOjQ3MDQKKyM6IGFwcGx5LmM6NDcxNAogbXNnaWQgInVuYWJsZSB0byByZWFkIGluZGV4IGZpbGUiCiBtc2dzdHIgItC40L3QtNC10LrRgdGK0YIg0L3QtSDQvNC+0LbQtSDQtNCwINCx0YrQtNC1INC30LDQv9C40YHQsNC9IgogCi0jOiBhcHBseS5jOjQ4NTkKKyM6IGFwcGx5LmM6NDg3MQogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW4ndCBvcGVuIHBhdGNoICclcyc6ICVzIgogbXNnc3RyICLQutGA0YrQv9C60LDRgtCwIOKAniVz4oCcINC90LUg0LzQvtC20LUg0LTQsCDQsdGK0LTQtSDQvtGC0LLQvtGA0LXQvdCwOiAlcyIKIAotIzogYXBwbHkuYzo0ODg2CisjOiBhcHBseS5jOjQ4OTgKICMsIGMtZm9ybWF0CiBtc2dpZCAic3F1ZWxjaGVkICVkIHdoaXRlc3BhY2UgZXJyb3IiCiBtc2dpZF9wbHVyYWwgInNxdWVsY2hlZCAlZCB3aGl0ZXNwYWNlIGVycm9ycyIKIG1zZ3N0clswXSAi0L/RgNC10L3QtdCx0YDQtdCz0L3QsNGC0LAg0LUgJWQg0LPRgNC10YjQutCwINCyINC30L3QsNGG0LjRgtC1INC30LAg0LjQvdGC0LXRgNCy0LDQu9C4IgogbXNnc3RyWzFdICLQv9GA0LXQvdC10LHRgNC10LPQvdCw0YLQuCDRgdCwICVkINCz0YDQtdGI0LrQuCDQsiDQt9C90LDRhtC40YLQtSDQt9CwINC40L3RgtC10YDQstCw0LvQuCIKIAotIzogYXBwbHkuYzo0ODkyIGFwcGx5LmM6NDkwNworIzogYXBwbHkuYzo0OTA0IGFwcGx5LmM6NDkxOQogIywgYy1mb3JtYXQKIG1zZ2lkICIlZCBsaW5lIGFkZHMgd2hpdGVzcGFjZSBlcnJvcnMuIgogbXNnaWRfcGx1cmFsICIlZCBsaW5lcyBhZGQgd2hpdGVzcGFjZSBlcnJvcnMuIgogbXNnc3RyWzBdICIlZCDRgNC10LQg0LTQvtCx0LDQstGPINCz0YDQtdGI0LrQuCDQsiDQt9C90LDRhtC40YLQtSDQt9CwINC40L3RgtC10YDQstCw0LvQuC4iCiBtc2dzdHJbMV0gIiVkINGA0LXQtNCwINC00L7QsdCw0LLRj9GCINCz0YDQtdGI0LrQuCDQsiDQt9C90LDRhtC40YLQtSDQt9CwINC40L3RgtC10YDQstCw0LvQuC4iCiAKLSM6IGFwcGx5LmM6NDkwMAorIzogYXBwbHkuYzo0OTEyCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVkIGxpbmUgYXBwbGllZCBhZnRlciBmaXhpbmcgd2hpdGVzcGFjZSBlcnJvcnMuIgogbXNnaWRfcGx1cmFsICIlZCBsaW5lcyBhcHBsaWVkIGFmdGVyIGZpeGluZyB3aGl0ZXNwYWNlIGVycm9ycy4iCkBAIC03ODcsMTQ0ICs3ODcsMTQ0IEBACiBtc2dzdHJbMV0gIiIKICLQlNC+0LHQsNCy0LXQvdC4INGB0LAgJWQg0YDQtdC00LAg0YHQu9C10LQg0LrQvtGA0LXQutGG0LjRj9GC0LAg0L3QsCDQs9GA0LXRiNC60LjRgtC1INCyINC30L3QsNGG0LjRgtC1INC30LAg0LjQvdGC0LXRgNCy0LDQu9C4LiIKIAotIzogYXBwbHkuYzo0OTE2IGJ1aWx0aW4vYWRkLmM6NTQwIGJ1aWx0aW4vbXYuYzozMDEgYnVpbHRpbi9ybS5jOjM5MAorIzogYXBwbHkuYzo0OTI4IGJ1aWx0aW4vYWRkLmM6NTQwIGJ1aWx0aW4vbXYuYzozMDEgYnVpbHRpbi9ybS5jOjM5MAogbXNnaWQgIlVuYWJsZSB0byB3cml0ZSBuZXcgaW5kZXggZmlsZSIKIG1zZ3N0ciAi0J3QvtCy0LjRj9GCINC40L3QtNC10LrRgSDQvdC1INC80L7QttC1INC00LAg0LHRitC00LUg0LfQsNC/0LjRgdCw0L0iCiAKLSM6IGFwcGx5LmM6NDk0MyBhcHBseS5jOjQ5NDYgYnVpbHRpbi9hbS5jOjIyMDggYnVpbHRpbi9hbS5jOjIyMTEKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMjMgYnVpbHRpbi9mZXRjaC5jOjEyOCBidWlsdGluL21lcmdlLmM6MjczCi0jOiBidWlsdGluL3B1bGwuYzoyMDggYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjQwNworIzogYXBwbHkuYzo0OTU1IGFwcGx5LmM6NDk1OCBidWlsdGluL2FtLmM6MjE5NyBidWlsdGluL2FtLmM6MjIwMAorIzogYnVpbHRpbi9jbG9uZS5jOjEyMiBidWlsdGluL2ZldGNoLmM6MTQzIGJ1aWx0aW4vbWVyZ2UuYzoyNzMKKyM6IGJ1aWx0aW4vcHVsbC5jOjIwOSBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6NDA3CiAjOiBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6MTM2NyBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6MTM3MAogIzogYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjE4NTAgYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjE4NTMKICM6IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoyMDkyIGdpdC1hZGQtLWludGVyYWN0aXZlLnBlcmw6MjExCiBtc2dpZCAicGF0aCIKIG1zZ3N0ciAi0L/RitGCIgogCi0jOiBhcHBseS5jOjQ5NDQKKyM6IGFwcGx5LmM6NDk1NgogbXNnaWQgImRvbid0IGFwcGx5IGNoYW5nZXMgbWF0Y2hpbmcgdGhlIGdpdmVuIHBhdGgiCiBtc2dzdHIgItCx0LXQtyDQv9GA0LjQu9Cw0LPQsNC90LUg0L3QsCDQv9GA0L7QvNC10L3QuNGC0LUg0L3QsNC/0LDRgdCy0LDRidC4INC90LAg0LTQsNC00LXQvdC40Y8g0L/RitGCIgogCi0jOiBhcHBseS5jOjQ5NDcKKyM6IGFwcGx5LmM6NDk1OQogbXNnaWQgImFwcGx5IGNoYW5nZXMgbWF0Y2hpbmcgdGhlIGdpdmVuIHBhdGgiCiBtc2dzdHIgItC/0YDQuNC70LDQs9Cw0L3QtSDQvdCwINC/0YDQvtC80LXQvdC40YLQtSDQvdCw0L/QsNGB0LLQsNGJ0Lgg0L3QsCDQtNCw0LTQtdC90LjRjyDQv9GK0YIiCiAKLSM6IGFwcGx5LmM6NDk0OSBidWlsdGluL2FtLmM6MjIxNworIzogYXBwbHkuYzo0OTYxIGJ1aWx0aW4vYW0uYzoyMjA2CiBtc2dpZCAibnVtIgogbXNnc3RyICLQkdCg0J7QmSIKIAotIzogYXBwbHkuYzo0OTUwCisjOiBhcHBseS5jOjQ5NjIKIG1zZ2lkICJyZW1vdmUgPG51bT4gbGVhZGluZyBzbGFzaGVzIGZyb20gdHJhZGl0aW9uYWwgZGlmZiBwYXRocyIKIG1zZ3N0ciAi0L/RgNC10LzQsNGF0LLQsNC90LUg0L3QsCDRgtC+0LfQuCDQkdCg0J7QmSDQstC+0LTQtdGJ0Lgg0LXQu9C10LzQtdC90YLQuCDQvtGCINC/0YrRgtC40YnQsNGC0LAg0LIg0YDQsNC30LvQuNC60LDRgtCwIgogCi0jOiBhcHBseS5jOjQ5NTMKKyM6IGFwcGx5LmM6NDk2NQogbXNnaWQgImlnbm9yZSBhZGRpdGlvbnMgbWFkZSBieSB0aGUgcGF0Y2giCiBtc2dzdHIgItC40LPQvdC+0YDQuNGA0LDQvdC1INC90LAg0YDQtdC00L7QstC10YLQtSDQtNC+0LHQsNCy0LXQvdC4INC+0YIg0YLQsNC30Lgg0LrRgNGK0L/QutCwIgogCi0jOiBhcHBseS5jOjQ5NTUKKyM6IGFwcGx5LmM6NDk2NwogbXNnaWQgImluc3RlYWQgb2YgYXBwbHlpbmcgdGhlIHBhdGNoLCBvdXRwdXQgZGlmZnN0YXQgZm9yIHRoZSBpbnB1dCIKIG1zZ3N0ciAi0LjQt9Cy0LXQttC00LDQvdC1INC90LAg0YHRgtCw0YLQuNGB0YLQuNC60LAg0L3QsCDQv9GA0L7QvNC10L3QuNGC0LUg0LHQtdC3INC/0YDQuNC70LDQs9Cw0L3QtSDQvdCwINC60YDRitC/0LrQsNGC0LAiCiAKLSM6IGFwcGx5LmM6NDk1OQorIzogYXBwbHkuYzo0OTcxCiBtc2dpZCAic2hvdyBudW1iZXIgb2YgYWRkZWQgYW5kIGRlbGV0ZWQgbGluZXMgaW4gZGVjaW1hbCBub3RhdGlvbiIKIG1zZ3N0ciAi0LjQt9Cy0LXQttC00LDQvdC1INC90LAg0LHRgNC+0Y8g0L3QsCDQtNC+0LHQsNCy0LXQvdC40YLQtSDQuCDQuNC30YLRgNC40YLQuNGC0LUg0YDQtdC00L7QstC1IgogCi0jOiBhcHBseS5jOjQ5NjEKKyM6IGFwcGx5LmM6NDk3MwogbXNnaWQgImluc3RlYWQgb2YgYXBwbHlpbmcgdGhlIHBhdGNoLCBvdXRwdXQgYSBzdW1tYXJ5IGZvciB0aGUgaW5wdXQiCiBtc2dzdHIgItC40LfQstC10LbQtNCw0L3QtSDQvdCwINGB0YLQsNGC0LjRgdGC0LjQutCwINC90LAg0LLRhdC+0LTQvdC40YLQtSDQtNCw0L3QvdC4INCx0LXQtyDQv9GA0LjQu9Cw0LPQsNC90LUg0L3QsCDQutGA0YrQv9C60LDRgtCwIgogCi0jOiBhcHBseS5jOjQ5NjMKKyM6IGFwcGx5LmM6NDk3NQogbXNnaWQgImluc3RlYWQgb2YgYXBwbHlpbmcgdGhlIHBhdGNoLCBzZWUgaWYgdGhlIHBhdGNoIGlzIGFwcGxpY2FibGUiCiBtc2dzdHIgItC/0YDQvtCy0LXRgNC60LAg0LTQsNC70Lgg0LrRgNGK0L/QutCw0YLQsCDQvNC+0LbQtSDQtNCwINGB0LUg0L/RgNC40LvQvtC20LgsINCx0LXQtyDQtNC10LnRgdGC0LLQuNGC0LXQu9C90L4g0L/RgNC40LvQsNCz0LDQvdC1IgogCi0jOiBhcHBseS5jOjQ5NjUKKyM6IGFwcGx5LmM6NDk3NwogbXNnaWQgIm1ha2Ugc3VyZSB0aGUgcGF0Y2ggaXMgYXBwbGljYWJsZSB0byB0aGUgY3VycmVudCBpbmRleCIKIG1zZ3N0ciAi0L/RgNC+0LLQtdGA0LrQsCDQtNCw0LvQuCDQutGA0YrQv9C60LDRgtCwINC80L7QttC1INC00LAg0LHRitC00LUg0L/RgNC40LvQvtC20LXQvdCwINC60YrQvCDRgtC10LrRg9GJ0LjRjyDQuNC90LTQtdC60YEiCiAKLSM6IGFwcGx5LmM6NDk2NworIzogYXBwbHkuYzo0OTc5CiBtc2dpZCAibWFyayBuZXcgZmlsZXMgd2l0aCBgZ2l0IGFkZCAtLWludGVudC10by1hZGRgIgogbXNnc3RyICLQvtGC0LHQtdC70Y/Qt9Cy0LDQvdC1INC90LAg0L3QvtCy0LjRgtC1INGE0LDQudC70L7QstC1INGBIOKAnmdpdCBhZGQgLS1pbnRlbnQtdG8tYWRk4oCcIgogCi0jOiBhcHBseS5jOjQ5NjkKKyM6IGFwcGx5LmM6NDk4MQogbXNnaWQgImFwcGx5IGEgcGF0Y2ggd2l0aG91dCB0b3VjaGluZyB0aGUgd29ya2luZyB0cmVlIgogbXNnc3RyICLQv9GA0LjQu9Cw0LPQsNC90LUg0L3QsCDQutGA0YrQv9C60LDRgtCwINCx0LXQtyDQv9GA0L7QvNGP0L3QsCDQvdCwINGA0LDQsdC+0YLQvdC+0YLQviDQtNGK0YDQstC+IgogCi0jOiBhcHBseS5jOjQ5NzEKKyM6IGFwcGx5LmM6NDk4MwogbXNnaWQgImFjY2VwdCBhIHBhdGNoIHRoYXQgdG91Y2hlcyBvdXRzaWRlIHRoZSB3b3JraW5nIGFyZWEiCiBtc2dzdHIgItC/0YDQuNC70LDQs9Cw0L3QtSDQvdCwINC60YDRitC/0LrQsCwg0LrQvtGP0YLQviDQv9GA0L7QvNC10L3RjyDQuCDRhNCw0LnQu9C+0LLQtSDQuNC30LLRitC9INGA0LDQsdC+0YLQvdC+0YLQviDQtNGK0YDQstC+IgogCi0jOiBhcHBseS5jOjQ5NzQKKyM6IGFwcGx5LmM6NDk4NgogbXNnaWQgImFsc28gYXBwbHkgdGhlIHBhdGNoICh1c2Ugd2l0aCAtLXN0YXQvLS1zdW1tYXJ5Ly0tY2hlY2spIgogbXNnc3RyICIiCiAi0LrRgNGK0L/QutCw0YLQsCDQtNCwINCx0YrQtNC1INC/0YDQuNC70L7QttC10L3QsC4gINCe0L/RhtC40Y/RgtCwINGB0LUg0LrQvtC80LHQuNC90LjRgNCwINGBIOKAni0tY2hlY2vigJwv4oCeLS1zdGF04oCcL+KAni0tIgogInN1bW1hcnnigJwiCiAKLSM6IGFwcGx5LmM6NDk3NgorIzogYXBwbHkuYzo0OTg4CiBtc2dpZCAiYXR0ZW1wdCB0aHJlZS13YXkgbWVyZ2UgaWYgYSBwYXRjaCBkb2VzIG5vdCBhcHBseSIKIG1zZ3N0ciAi0L/RgNC+0LHQstCw0L3QtSDRgSDRgtGA0L7QudC90L4g0YHQu9C40LLQsNC90LUsINCw0LrQviDQutGA0YrQv9C60LDRgtCwINC90LUg0LzQvtC20LUg0LTQsCDRgdC1INC/0YDQuNC70L7QttC4INC00LjRgNC10LrRgtC90L4iCiAKLSM6IGFwcGx5LmM6NDk3OAorIzogYXBwbHkuYzo0OTkwCiBtc2dpZCAiYnVpbGQgYSB0ZW1wb3JhcnkgaW5kZXggYmFzZWQgb24gZW1iZWRkZWQgaW5kZXggaW5mb3JtYXRpb24iCiBtc2dzdHIgIiIKICLRgdGK0LfQtNCw0LLQsNC90LUg0L3QsCDQstGA0LXQvNC10L3QtdC9INC40L3QtNC10LrRgSDQvdCwINCx0LDQt9CwINC90LAg0LLQutC70Y7Rh9C10L3QsNGC0LAg0LjQvdGE0L7RgNC80LDRhtC40Y8g0LfQsCDQuNC90LTQtdC60YHQsCIKIAotIzogYXBwbHkuYzo0OTgxIGJ1aWx0aW4vY2hlY2tvdXQtaW5kZXguYzoxNzMgYnVpbHRpbi9scy1maWxlcy5jOjUyNAorIzogYXBwbHkuYzo0OTkzIGJ1aWx0aW4vY2hlY2tvdXQtaW5kZXguYzoxNzMgYnVpbHRpbi9scy1maWxlcy5jOjUyNAogbXNnaWQgInBhdGhzIGFyZSBzZXBhcmF0ZWQgd2l0aCBOVUwgY2hhcmFjdGVyIgogbXNnc3RyICLRgNCw0LfQtNC10LvRj9C90LUg0L3QsCDQv9GK0YLQuNGJ0LDRgtCwINGBINC90YPQu9C10LLQuNGPINC30L3QsNC6IOKAnk5VTOKAnCIKIAotIzogYXBwbHkuYzo0OTgzCisjOiBhcHBseS5jOjQ5OTUKIG1zZ2lkICJlbnN1cmUgYXQgbGVhc3QgPG4+IGxpbmVzIG9mIGNvbnRleHQgbWF0Y2giCiBtc2dzdHIgItC00LAg0YHQtSDQvtGB0LjQs9GD0YDQuCDQutC+0L3RgtC10LrRgdGCINC+0YIg0L/QvtC90LUg0YLQsNC60YrQsiDQkdCg0J7QmSDRgdGK0LLQv9Cw0LTQsNGJ0Lgg0YDQtdC00L7QstC1IgogCi0jOiBhcHBseS5jOjQ5ODQgYnVpbHRpbi9hbS5jOjIxOTYgYnVpbHRpbi9pbnRlcnByZXQtdHJhaWxlcnMuYzo5OAorIzogYXBwbHkuYzo0OTk2IGJ1aWx0aW4vYW0uYzoyMTg1IGJ1aWx0aW4vaW50ZXJwcmV0LXRyYWlsZXJzLmM6OTgKICM6IGJ1aWx0aW4vaW50ZXJwcmV0LXRyYWlsZXJzLmM6MTAwIGJ1aWx0aW4vaW50ZXJwcmV0LXRyYWlsZXJzLmM6MTAyCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMzAgYnVpbHRpbi9yZWJhc2UuYzoxNDIxCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMTAgYnVpbHRpbi9yZWJhc2UuYzoxNDQ1CiBtc2dpZCAiYWN0aW9uIgogbXNnc3RyICLQtNC10LnRgdGC0LLQuNC1IgogCi0jOiBhcHBseS5jOjQ5ODUKKyM6IGFwcGx5LmM6NDk5NwogbXNnaWQgImRldGVjdCBuZXcgb3IgbW9kaWZpZWQgbGluZXMgdGhhdCBoYXZlIHdoaXRlc3BhY2UgZXJyb3JzIgogbXNnc3RyICLQt9Cw0YHQuNGH0LDQvdC1INC90LAg0L3QvtCy0Lgg0LjQu9C4INC/0YDQvtC80LXQvdC10L3QuCDRgNC10LTQvtCy0LUg0YEg0LPRgNC10YjQutC4INCyINC30L3QsNGG0LjRgtC1INC30LAg0LjQvdGC0LXRgNCy0LDQu9C4IgogCi0jOiBhcHBseS5jOjQ5ODggYXBwbHkuYzo0OTkxCisjOiBhcHBseS5jOjUwMDAgYXBwbHkuYzo1MDAzCiBtc2dpZCAiaWdub3JlIGNoYW5nZXMgaW4gd2hpdGVzcGFjZSB3aGVuIGZpbmRpbmcgY29udGV4dCIKIG1zZ3N0ciAiIgogItC40LPQvdC+0YDQuNGA0LDQvdC1INC90LAg0L/RgNC+0LzQtdC90LjRgtC1INCyINC30L3QsNGG0LjRgtC1INC30LAg0LjQvdGC0LXRgNCy0LDQu9C4INC/0YDQuCDQvtGC0LrRgNC40LLQsNC90LUg0L3QsCDQutC+0L3RgtC10LrRgdGC0LAiCiAKLSM6IGFwcGx5LmM6NDk5NAorIzogYXBwbHkuYzo1MDA2CiBtc2dpZCAiYXBwbHkgdGhlIHBhdGNoIGluIHJldmVyc2UiCiBtc2dzdHIgItC/0YDQuNC70LDQs9Cw0L3QtSDQvdCwINC60YDRitC/0LrQsNGC0LAg0LIg0L7QsdGA0LDRgtC90LAg0L/QvtGB0L7QutCwIgogCi0jOiBhcHBseS5jOjQ5OTYKKyM6IGFwcGx5LmM6NTAwOAogbXNnaWQgImRvbid0IGV4cGVjdCBhdCBsZWFzdCBvbmUgbGluZSBvZiBjb250ZXh0IgogbXNnc3RyICLQsdC10Lcg0LjQt9C40YHQutCy0LDQvdC1INC90LAg0LTQvtGA0Lgg0Lgg0LXQtNC40L0g0YDQtdC0INC60L7QvdGC0LXQutGB0YIiCiAKLSM6IGFwcGx5LmM6NDk5OAorIzogYXBwbHkuYzo1MDEwCiBtc2dpZCAibGVhdmUgdGhlIHJlamVjdGVkIGh1bmtzIGluIGNvcnJlc3BvbmRpbmcgKi5yZWogZmlsZXMiCiBtc2dzdHIgItC+0YHRgtCw0LLRj9C90LUg0L3QsCDQvtGC0YXQstGK0YDQu9C10L3QuNGC0LUg0L/QsNGA0YfQtdGC0LAg0LLRitCyINGE0LDQudC70L7QstC1INGBINGA0LDQt9GI0LjRgNC10L3QuNC1IOKAni5yZWrigJwiCiAKLSM6IGFwcGx5LmM6NTAwMAorIzogYXBwbHkuYzo1MDEyCiBtc2dpZCAiYWxsb3cgb3ZlcmxhcHBpbmcgaHVua3MiCiBtc2dzdHIgItC/0L7Qt9Cy0L7Qu9GP0LLQsNC90LUg0L3QsCDQt9Cw0YHRgtGK0L/QstCw0YnQuCDRgdC1INC/0LDRgNGH0LXRgtCwIgogCi0jOiBhcHBseS5jOjUwMDEgYnVpbHRpbi9hZGQuYzoyOTEgYnVpbHRpbi9jaGVjay1pZ25vcmUuYzoyMgorIzogYXBwbHkuYzo1MDEzIGJ1aWx0aW4vYWRkLmM6MjkxIGJ1aWx0aW4vY2hlY2staWdub3JlLmM6MjIKICM6IGJ1aWx0aW4vY29tbWl0LmM6MTMzNyBidWlsdGluL2NvdW50LW9iamVjdHMuYzo5OCBidWlsdGluL2ZzY2suYzo3ODYKLSM6IGJ1aWx0aW4vbG9nLmM6MjA2OCBidWlsdGluL212LmM6MTIzIGJ1aWx0aW4vcmVhZC10cmVlLmM6MTI4CisjOiBidWlsdGluL2xvZy5jOjIwODUgYnVpbHRpbi9tdi5jOjEyMyBidWlsdGluL3JlYWQtdHJlZS5jOjEyOAogbXNnaWQgImJlIHZlcmJvc2UiCiBtc2dzdHIgItC/0L7QstC10YfQtSDQv9C+0LTRgNC+0LHQvdC+0YHRgtC4IgogCi0jOiBhcHBseS5jOjUwMDMKKyM6IGFwcGx5LmM6NTAxNQogbXNnaWQgInRvbGVyYXRlIGluY29ycmVjdGx5IGRldGVjdGVkIG1pc3NpbmcgbmV3LWxpbmUgYXQgdGhlIGVuZCBvZiBmaWxlIgogbXNnc3RyICLQv9GA0LXQvdC10LHRgNC10LPQstCw0L3QtSDQvdCwINC90LXQv9GA0LDQstC40LvQvdC+INC70LjQv9GB0LLQsNGJINC30L3QsNC6INC30LAg0L3QvtCyINGA0LXQtCDQsiDQutGA0LDRjyDQvdCwINGE0LDQudC7IgogCi0jOiBhcHBseS5jOjUwMDYKKyM6IGFwcGx5LmM6NTAxOAogbXNnaWQgImRvIG5vdCB0cnVzdCB0aGUgbGluZSBjb3VudHMgaW4gdGhlIGh1bmsgaGVhZGVycyIKIG1zZ3N0ciAi0LHQtdC3INC00L7QstC10YDRj9Cy0LDQvdC1INC90LAg0L3QvtC80LXRgNCw0YLQsCDQvdCwINGA0LXQtNC+0LLQtdGC0LUg0LIg0LfQsNCz0LvQsNCy0L3QuNGC0LUg0YfQsNGB0YLQuCDQvdCwINC/0LDRgNGH0LXRgtCw0YLQsCIKIAotIzogYXBwbHkuYzo1MDA4IGJ1aWx0aW4vYW0uYzoyMjA1CisjOiBhcHBseS5jOjUwMjAgYnVpbHRpbi9hbS5jOjIxOTQKIG1zZ2lkICJyb290IgogbXNnc3RyICLQndCQ0KfQkNCb0J3QkF/QlNCY0KDQldCa0KLQntCg0JjQryIKIAotIzogYXBwbHkuYzo1MDA5CisjOiBhcHBseS5jOjUwMjEKIG1zZ2lkICJwcmVwZW5kIDxyb290PiB0byBhbGwgZmlsZW5hbWVzIgogbXNnc3RyICLQtNC+0LHQsNCy0Y/QvdC1INC90LAg0YLQsNC30Lgg0J3QkNCn0JDQm9Cd0JBf0JTQmNCg0JXQmtCi0J7QoNCY0K8g0LrRitC8INC40LzQtdC90LDRgtCwINC90LAg0LLRgdC40YfQutC4INGE0LDQudC70L7QstC1IgogCkBAIC05NzksNyArOTc5LDcgQEAKIG1zZ2lkICJhcmNoaXZlIGZvcm1hdCIKIG1zZ3N0ciAi0KTQntCg0JzQkNCiINC90LAg0LDRgNGF0LjQstCwIgogCi0jOiBhcmNoaXZlLmM6NDU4IGJ1aWx0aW4vbG9nLmM6MTU4MAorIzogYXJjaGl2ZS5jOjQ1OCBidWlsdGluL2xvZy5jOjE1ODEKIG1zZ2lkICJwcmVmaXgiCiBtc2dzdHIgItCf0KDQldCk0JjQmtChIgogCkBAIC05ODcsMTEgKzk4NywxMiBAQAogbXNnaWQgInByZXBlbmQgcHJlZml4IHRvIGVhY2ggcGF0aG5hbWUgaW4gdGhlIGFyY2hpdmUiCiBtc2dzdHIgItC00L7QsdCw0LLRj9C90LUg0L3QsCDRgtC+0LfQuCDQn9Cg0JXQpNCY0JrQoSDQutGK0Lwg0LLRgdC10LrQuCDQv9GK0YIg0LIg0LDRgNGF0LjQstCwIgogCi0jOiBhcmNoaXZlLmM6NDYwIGJ1aWx0aW4vYmxhbWUuYzo4NjIgYnVpbHRpbi9ibGFtZS5jOjg3NCBidWlsdGluL2JsYW1lLmM6ODc1Ci0jOiBidWlsdGluL2NvbW1pdC10cmVlLmM6MTE3IGJ1aWx0aW4vY29uZmlnLmM6MTI5IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTM0Ci0jOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTEzNiBidWlsdGluL2dyZXAuYzo4OTcgYnVpbHRpbi9oYXNoLW9iamVjdC5jOjEwNQotIzogYnVpbHRpbi9scy1maWxlcy5jOjU2MCBidWlsdGluL2xzLWZpbGVzLmM6NTYzIGJ1aWx0aW4vbm90ZXMuYzo0MTIKLSM6IGJ1aWx0aW4vbm90ZXMuYzo1NzggYnVpbHRpbi9yZWFkLXRyZWUuYzoxMjMgcGFyc2Utb3B0aW9ucy5oOjE3NworIzogYXJjaGl2ZS5jOjQ2MCBidWlsdGluL2JsYW1lLmM6ODYxIGJ1aWx0aW4vYmxhbWUuYzo4NzMgYnVpbHRpbi9ibGFtZS5jOjg3NAorIzogYnVpbHRpbi9jb21taXQtdHJlZS5jOjExNyBidWlsdGluL2NvbmZpZy5jOjEyOSBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE2MgorIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNjQgYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNjggYnVpbHRpbi9ncmVwLmM6ODk5CisjOiBidWlsdGluL2hhc2gtb2JqZWN0LmM6MTA1IGJ1aWx0aW4vbHMtZmlsZXMuYzo1NjAgYnVpbHRpbi9scy1maWxlcy5jOjU2MworIzogYnVpbHRpbi9ub3Rlcy5jOjQxMiBidWlsdGluL25vdGVzLmM6NTc4IGJ1aWx0aW4vcmVhZC10cmVlLmM6MTIzCisjOiBwYXJzZS1vcHRpb25zLmg6MTg2CiBtc2dpZCAiZmlsZSIKIG1zZ3N0ciAi0KTQkNCZ0JsiCiAKQEAgLTEwMjMsNyArMTAyNCw3IEBACiBtc2dpZCAibGlzdCBzdXBwb3J0ZWQgYXJjaGl2ZSBmb3JtYXRzIgogbXNnc3RyICLQuNC30LLQtdC20LTQsNC90LUg0L3QsCDRgdC/0LjRgdGK0LrQsCDRgSDQv9C+0LTQtNGK0YDQttCw0L3QuNGC0LUg0YTQvtGA0LzQsNGC0LgiCiAKLSM6IGFyY2hpdmUuYzo0NzkgYnVpbHRpbi9hcmNoaXZlLmM6OTEgYnVpbHRpbi9jbG9uZS5jOjExMyBidWlsdGluL2Nsb25lLmM6MTE2CisjOiBhcmNoaXZlLmM6NDc5IGJ1aWx0aW4vYXJjaGl2ZS5jOjkxIGJ1aWx0aW4vY2xvbmUuYzoxMTIgYnVpbHRpbi9jbG9uZS5jOjExNQogIzogYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjEzNzkgYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjE4NTkKIG1zZ2lkICJyZXBvIgogbXNnc3RyICLRhdGA0LDQvdC40LvQuNGJ0LUiCkBAIC0xMDMyLDcgKzEwMzMsNyBAQAogbXNnaWQgInJldHJpZXZlIHRoZSBhcmNoaXZlIGZyb20gcmVtb3RlIHJlcG9zaXRvcnkgPHJlcG8+IgogbXNnc3RyICLQuNC30YLQtdCz0LvRj9C90LUg0L3QsCDQsNGA0YXQuNCy0LAg0L7RgiDQvtGC0LTQsNC70LXRh9C10L3QvtGC0L4g0KXQoNCQ0J3QmNCb0JjQqdCVIgogCi0jOiBhcmNoaXZlLmM6NDgxIGJ1aWx0aW4vYXJjaGl2ZS5jOjkzIGJ1aWx0aW4vZGlmZnRvb2wuYzo3MDcKKyM6IGFyY2hpdmUuYzo0ODEgYnVpbHRpbi9hcmNoaXZlLmM6OTMgYnVpbHRpbi9kaWZmdG9vbC5jOjcxNQogIzogYnVpbHRpbi9ub3Rlcy5jOjQ5OAogbXNnaWQgImNvbW1hbmQiCiBtc2dzdHIgItC60L7QvNCw0L3QtNCwIgpAQCAtMTA2OCwyNiArMTA2OSwyNiBAQAogbXNnaWQgImNhbm5vdCBzdHJlYW0gYmxvYiAlcyIKIG1zZ3N0ciAi0L7QsdC10LrRgtGK0YItQkxPQiDigJ4lc+KAnCDQvdC1INC80L7QttC1INC00LAg0LHRitC00LUg0L7QsdGA0LDQsdC+0YLQtdC9IgogCi0jOiBhcmNoaXZlLXRhci5jOjI2MCBhcmNoaXZlLXppcC5jOjM2MworIzogYXJjaGl2ZS10YXIuYzoyNjYgYXJjaGl2ZS16aXAuYzozNjMKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5zdXBwb3J0ZWQgZmlsZSBtb2RlOiAwJW8gKFNIQTE6ICVzKSIKIG1zZ3N0ciAi0L3QtdC/0L7QtNC00YrRgNC20LDQvdC4INC/0YDQsNCy0LAg0LfQsCDQtNC+0YHRgtGK0L8g0LTQviDRhNCw0LnQuzogMCVvIChTSEExOiAlcykiCiAKLSM6IGFyY2hpdmUtdGFyLmM6Mjg3IGFyY2hpdmUtemlwLmM6MzUzCisjOiBhcmNoaXZlLXRhci5jOjI5MyBhcmNoaXZlLXppcC5jOjM1MwogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgcmVhZCAlcyIKIG1zZ3N0ciAi0L7QsdC10LrRgtGK0YIg4oCeJXPigJwg0L3QtSDQvNC+0LbQtSDQtNCwINCx0YrQtNC1INC/0YDQvtGH0LXRgtC10L0iCiAKLSM6IGFyY2hpdmUtdGFyLmM6NDU5CisjOiBhcmNoaXZlLXRhci5jOjQ2NQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gc3RhcnQgJyVzJyBmaWx0ZXIiCiBtc2dzdHIgItGE0LjQu9GC0YrRgNGK0YIg4oCeJXPigJwg0L3QtSDQvNC+0LbQtSDQtNCwINCx0YrQtNC1INGB0YLQsNGA0YLQuNGA0LDQvSIKIAotIzogYXJjaGl2ZS10YXIuYzo0NjIKKyM6IGFyY2hpdmUtdGFyLmM6NDY4CiBtc2dpZCAidW5hYmxlIHRvIHJlZGlyZWN0IGRlc2NyaXB0b3IiCiBtc2dzdHIgItC00LXRgdC60YDQuNC/0YLQvtGA0YrRgiDQvdC1INC80L7QttC1INC00LAg0LHRitC00LUg0L/RgNC10L3QsNGB0L7Rh9C10L0iCiAKLSM6IGFyY2hpdmUtdGFyLmM6NDY5CisjOiBhcmNoaXZlLXRhci5jOjQ3NQogIywgYy1mb3JtYXQKIG1zZ2lkICInJXMnIGZpbHRlciByZXBvcnRlZCBlcnJvciIKIG1zZ3N0ciAi0YTQuNC70YLRitGA0YrRgiDigJ4lc+KAnCDQstGK0YDQvdCwINCz0YDQtdGI0LrQsCIKQEAgLTExMTIsMTcgKzExMTMsMTcgQEAKIG1zZ2lkICJ0aW1lc3RhbXAgdG9vIGxhcmdlIGZvciB0aGlzIHN5c3RlbTogJTxQUkl1TUFYPiIKIG1zZ3N0ciAi0LLRgNC10LzQtdCy0LDRgtCwINGB0YLQvtC50L3QvtGB0YIg0LUg0YLQstGK0YDQtNC1INCz0L7Qu9GP0LzQsCDQt9CwINGC0LDQt9C4INGB0LjRgdGC0LXQvNCwOiAlPFBSSXVNQVg+IgogCi0jOiBhdHRyLmM6MjExCisjOiBhdHRyLmM6MjEzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiUuKnMgaXMgbm90IGEgdmFsaWQgYXR0cmlidXRlIG5hbWUiCiBtc2dzdHIgIuKAniUuKnPigJwg0LUg0L3QtdC/0YDQsNCy0LjQu9C90L4g0LjQvNC1INC30LAg0LDRgtGA0LjQsdGD0YIiCiAKLSM6IGF0dHIuYzozNjgKKyM6IGF0dHIuYzozNzAKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgbm90IGFsbG93ZWQ6ICVzOiVkIgogbXNnc3RyICIlczog0LrQvtC80LDQvdC00LDRgtCwINC90LUg0LUg0L/QvtC30LLQvtC70LXQvdCwOiDigJ4lczolZOKAnCIKIAotIzogYXR0ci5jOjQwOAorIzogYXR0ci5jOjQxMAogbXNnaWQgIiIKICJOZWdhdGl2ZSBwYXR0ZXJucyBhcmUgaWdub3JlZCBpbiBnaXQgYXR0cmlidXRlc1xuIgogIlVzZSAnXFwhJyBmb3IgbGl0ZXJhbCBsZWFkaW5nIGV4Y2xhbWF0aW9uLiIKQEAgLTEyNDksNDEgKzEyNTAsNDEgQEAKIG1zZ3N0clswXSAi0JTQstC+0LjRh9C90L4g0YLRitGA0YHQtdC90LU6INC+0YHRgtCw0LLQsCAlZCDQstC10YDRgdC40Y8g0YHQu9C10LQg0YLQsNC30LggJXNcbiIKIG1zZ3N0clsxXSAi0JTQstC+0LjRh9C90L4g0YLRitGA0YHQtdC90LU6INC+0YHRgtCw0LLQsNGCICVkINCy0LXRgNGB0LjQuCDRgdC70LXQtCDRgtCw0LfQuCAlc1xuIgogCi0jOiBibGFtZS5jOjI2OTcKKyM6IGJsYW1lLmM6MjcwMAogbXNnaWQgIi0tY29udGVudHMgYW5kIC0tcmV2ZXJzZSBkbyBub3QgYmxlbmQgd2VsbC4iCiBtc2dzdHIgItCe0L/RhtC40LjRgtC1IOKAni0tY29udGVudHPigJwg0Lgg4oCeLS1yZXZlcnNl4oCcINGB0LAg0L3QtdGB0YrQstC80LXRgdGC0LjQvNC4IgogCi0jOiBibGFtZS5jOjI3MTEKKyM6IGJsYW1lLmM6MjcxNAogbXNnaWQgImNhbm5vdCB1c2UgLS1jb250ZW50cyB3aXRoIGZpbmFsIGNvbW1pdCBvYmplY3QgbmFtZSIKIG1zZ3N0ciAi0J7Qv9GG0LjRj9GC0LAg4oCeLS1jb250ZW50c+KAnCDQtSDQvdC10YHRitCy0LzQtdGB0YLQuNC80LAg0YEg0LjQvNC1INC90LAg0L7QsdC10LrRgiDQvtGCINC60YDQsNC50L3QviDQv9C+0LTQsNCy0LDQvdC1IgogCi0jOiBibGFtZS5jOjI3MzIKKyM6IGJsYW1lLmM6MjczNQogbXNnaWQgIi0tcmV2ZXJzZSBhbmQgLS1maXJzdC1wYXJlbnQgdG9nZXRoZXIgcmVxdWlyZSBzcGVjaWZpZWQgbGF0ZXN0IGNvbW1pdCIKIG1zZ3N0ciAiIgogItCV0LTQvdC+0LLRgNC10LzQtdC90L3QvtGC0L4g0LfQsNC00LDQstCw0L3QtSDQvdCwINC+0L/RhtC40LjRgtC1IOKAni0tcmV2ZXJzZeKAnCDQuCDigJ4tLWZpcnN0LXBhcmVudOKAnCDQuNC30LjRgdC60LLQsCAiCiAi0YPQutCw0LfQstCw0L3QtdGC0L4g0L3QsCDQutGA0LDQudC90L4g0L/QvtC00LDQstCw0L3QtSIKIAotIzogYmxhbWUuYzoyNzQxIGJ1bmRsZS5jOjE2NyByZWYtZmlsdGVyLmM6MjE5NiByZW1vdGUuYzoxOTM4IHNlcXVlbmNlci5jOjIwMzMKLSM6IHNlcXVlbmNlci5jOjQzNDggYnVpbHRpbi9jb21taXQuYzoxMDIwIGJ1aWx0aW4vbG9nLmM6Mzg3IGJ1aWx0aW4vbG9nLmM6OTYzCi0jOiBidWlsdGluL2xvZy5jOjE0NTEgYnVpbHRpbi9sb2cuYzoxODI3IGJ1aWx0aW4vbG9nLmM6MjExNyBidWlsdGluL21lcmdlLmM6NDExCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMxNDggYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMTYzCisjOiBibGFtZS5jOjI3NDQgYnVuZGxlLmM6MTY3IHJlZi1maWx0ZXIuYzoyMjAzIHJlbW90ZS5jOjE5NDEgc2VxdWVuY2VyLmM6MTk3MQorIzogc2VxdWVuY2VyLmM6NDMwNSBidWlsdGluL2NvbW1pdC5jOjEwMjAgYnVpbHRpbi9sb2cuYzozODcgYnVpbHRpbi9sb2cuYzo5NjQKKyM6IGJ1aWx0aW4vbG9nLmM6MTQ1MiBidWlsdGluL2xvZy5jOjE4NDQgYnVpbHRpbi9sb2cuYzoyMTM0IGJ1aWx0aW4vbWVyZ2UuYzo0MTEKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzEyOCBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMxNDMKICM6IGJ1aWx0aW4vc2hvcnRsb2cuYzoxOTIKIG1zZ2lkICJyZXZpc2lvbiB3YWxrIHNldHVwIGZhaWxlZCIKIG1zZ3N0ciAi0L3QtdGD0YHQv9C10YjQvdC+INC90LDRgdGC0YDQvtC50LLQsNC90LUg0L3QsCDQvtCx0YXQvtC20LTQsNC90LXRgtC+INC90LAg0LLQtdGA0YHQuNC40YLQtSIKIAotIzogYmxhbWUuYzoyNzU5CisjOiBibGFtZS5jOjI3NjIKIG1zZ2lkICIiCiAiLS1yZXZlcnNlIC0tZmlyc3QtcGFyZW50IHRvZ2V0aGVyIHJlcXVpcmUgcmFuZ2UgYWxvbmcgZmlyc3QtcGFyZW50IGNoYWluIgogbXNnc3RyICIiCiAi0JXQtNC90L7QstGA0LXQvNC10L3QvdC+0YLQviDQt9Cw0LTQsNCy0LDQvdC1INC90LAg0L7Qv9GG0LjQuNGC0LUg4oCeLS1yZXZlcnNl4oCcINC4IOKAni0tZmlyc3QtcGFyZW504oCcINC40LfQuNGB0LrQstCwICIKICLRg9C60LDQt9Cy0LDQvdC10YLQviDQvdCwINC00LjQsNC/0LDQt9C+0L0g0L/QviDQstC10YDQuNCz0LDRgtCwINC90LAg0L/RitGA0LLQuNGC0LUg0L3QsNGB0LvQtdC00L3QuNGG0LgiCiAKLSM6IGJsYW1lLmM6Mjc3MAorIzogYmxhbWUuYzoyNzczCiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vIHN1Y2ggcGF0aCAlcyBpbiAlcyIKIG1zZ3N0ciAi0L3Rj9C80LAg0L/RitGCINC90LAg0LjQvNC1IOKAniVz4oCcINCyIOKAniVz4oCcIgogCi0jOiBibGFtZS5jOjI3ODEKKyM6IGJsYW1lLmM6Mjc4NAogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgcmVhZCBibG9iICVzIGZvciBwYXRoICVzIgogbXNnc3RyICLQvtCx0LXQutGC0YrRgi1CTE9CIOKAniVz4oCcINCyINC/0YrRgtGPICVzINC90LUg0LzQvtC20LUg0LTQsCDQsdGK0LTQtSDQv9GA0L7Rh9C10YLQtdC9IgpAQCAtMTQzNiw3ICsxNDM3LDcgQEAKIG1zZ2lkICJ1bnJlY29nbml6ZWQgaGVhZGVyOiAlcyVzICglZCkiCiBtc2dzdHIgItC90LXQv9C+0LfQvdCw0YLQsCDQt9Cw0LPQu9Cw0LLQvdCwINGH0LDRgdGCOiAlcyVzICglZCkiCiAKLSM6IGJ1bmRsZS5jOjkwIHJlcmVyZS5jOjQ4MCByZXJlcmUuYzo2OTAgc2VxdWVuY2VyLmM6MjI4MyBzZXF1ZW5jZXIuYzozMDI0CisjOiBidW5kbGUuYzo5MCByZXJlcmUuYzo0ODAgcmVyZXJlLmM6NjkwIHNlcXVlbmNlci5jOjIyMjEgc2VxdWVuY2VyLmM6Mjk2MgogIzogYnVpbHRpbi9jb21taXQuYzo3OTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IG9wZW4gJyVzJyIKQEAgLTE0OTAsNyArMTQ5MSw3IEBACiBtc2dzdHIgIiIKICLRg9C60LDQt9Cw0YLQtdC70Y/RgiDigJ4lc+KAnCDQvdC1INC1INCx0LjQuyDQstC60LvRjtGH0LXQvSDQv9C+0YDQsNC00Lgg0L7Qv9GG0LjQuNGC0LUg0LfQsNC00LDQtNC10L3QuCDQvdCwIOKAnmdpdCByZXYtbGlzdOKAnCIKIAotIzogYnVuZGxlLmM6NDYwIGJ1aWx0aW4vbG9nLmM6MjAyIGJ1aWx0aW4vbG9nLmM6MTczMiBidWlsdGluL3Nob3J0bG9nLmM6MzA2CisjOiBidW5kbGUuYzo0NjAgYnVpbHRpbi9sb2cuYzoyMDIgYnVpbHRpbi9sb2cuYzoxNzMzIGJ1aWx0aW4vc2hvcnRsb2cuYzozMDYKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5yZWNvZ25pemVkIGFyZ3VtZW50OiAlcyIKIG1zZ3N0ciAi0L3QtdC/0L7Qt9C90LDRgiDQsNGA0LPRg9C80LXQvdGCOiAlcyIKQEAgLTE1MTMsOCArMTUxNCw4IEBACiBtc2dpZCAiaW52YWxpZCBjb2xvciB2YWx1ZTogJS4qcyIKIG1zZ3N0ciAi0L3QtdC/0YDQsNCy0LjQu9C90LAg0YHRgtC+0LnQvdC+0YHRgiDQt9CwINGG0LLRj9GCOiAlLipzIgogCi0jOiBjb21taXQuYzo1MCBzZXF1ZW5jZXIuYzoyNzI3IGJ1aWx0aW4vYW0uYzozNTUgYnVpbHRpbi9hbS5jOjM5OQotIzogYnVpbHRpbi9hbS5jOjEzNzggYnVpbHRpbi9hbS5jOjIwMjAgYnVpbHRpbi9yZXBsYWNlLmM6NDU1CisjOiBjb21taXQuYzo1MCBzZXF1ZW5jZXIuYzoyNjY1IGJ1aWx0aW4vYW0uYzozNTQgYnVpbHRpbi9hbS5jOjM5OAorIzogYnVpbHRpbi9hbS5jOjEzNjYgYnVpbHRpbi9hbS5jOjIwMDkgYnVpbHRpbi9yZXBsYWNlLmM6NDU2CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBwYXJzZSAlcyIKIG1zZ3N0ciAi4oCeJXPigJwg0L3QtSDQvNC+0LbQtSDQtNCwINGB0LUg0LDQvdCw0LvQuNC30LjRgNCwIgpAQCAtMTU0NywyOSArMTU0OCwyOSBAQAogIlxuIgogIiAgICBnaXQgY29uZmlnIGFkdmljZS5ncmFmdEZpbGVEZXByZWNhdGVkIGZhbHNlIgogCi0jOiBjb21taXQuYzoxMTI3CisjOiBjb21taXQuYzoxMTI4CiAjLCBjLWZvcm1hdAogbXNnaWQgIkNvbW1pdCAlcyBoYXMgYW4gdW50cnVzdGVkIEdQRyBzaWduYXR1cmUsIGFsbGVnZWRseSBieSAlcy4iCiBtc2dzdHIgIiIKICLQn9C+0LTQsNCy0LDQvdC10YLQviDigJ4lc+KAnCDQtSDRgSDQvdC10LTQvtCy0LXRgNC10L0g0L/QvtC00L/QuNGBINC+0YIgR1BHLCDQutC+0LnRgtC+INGC0LLRitGA0LTQuCwg0YfQtSDQtSDQvdCwIOKAniVz4oCcLiIKIAotIzogY29tbWl0LmM6MTEzMAorIzogY29tbWl0LmM6MTEzMQogIywgYy1mb3JtYXQKIG1zZ2lkICJDb21taXQgJXMgaGFzIGEgYmFkIEdQRyBzaWduYXR1cmUgYWxsZWdlZGx5IGJ5ICVzLiIKIG1zZ3N0ciAiIgogItCf0L7QtNCw0LLQsNC90LXRgtC+IOKAniVz4oCcINC1INGBINC90LXQv9GA0LDQstC40LvQtdC9INC/0L7QtNC/0LjRgSDQvtGCIEdQRywg0LrQvtC50YLQviDRgtCy0YrRgNC00LgsINGH0LUg0LUg0L3QsCDigJ4lc+KAnC4iCiAKLSM6IGNvbW1pdC5jOjExMzMKKyM6IGNvbW1pdC5jOjExMzQKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ29tbWl0ICVzIGRvZXMgbm90IGhhdmUgYSBHUEcgc2lnbmF0dXJlLiIKIG1zZ3N0ciAi0J/QvtC00LDQstCw0L3QtdGC0L4g4oCeJXPigJwg0LUg0LHQtdC3INC/0L7QtNC/0LjRgSDQvtGCIEdQRy4iCiAKLSM6IGNvbW1pdC5jOjExMzYKKyM6IGNvbW1pdC5jOjExMzcKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ29tbWl0ICVzIGhhcyBhIGdvb2QgR1BHIHNpZ25hdHVyZSBieSAlc1xuIgogbXNnc3RyICLQn9C+0LTQsNCy0LDQvdC10YLQviDigJ4lc+KAnCDQtSDRgSDQutC+0YDQtdC60YLQtdC9INC/0L7QtNC/0LjRgSDQvtGCIEdQRyDQvdCwIOKAniVz4oCcLlxuIgogCi0jOiBjb21taXQuYzoxMzkwCisjOiBjb21taXQuYzoxMzkxCiBtc2dpZCAiIgogIldhcm5pbmc6IGNvbW1pdCBtZXNzYWdlIGRpZCBub3QgY29uZm9ybSB0byBVVEYtOC5cbiIKICJZb3UgbWF5IHdhbnQgdG8gYW1lbmQgaXQgYWZ0ZXIgZml4aW5nIHRoZSBtZXNzYWdlLCBvciBzZXQgdGhlIGNvbmZpZ1xuIgpAQCAtMTYzMSwxODUgKzE2MzIsMjAwIEBACiBtc2dpZCAidW5hYmxlIHRvIGZpbmQgYWxsIGNvbW1pdC1ncmFwaCBmaWxlcyIKIG1zZ3N0ciAi0L3Rj9C60L7QuCDRhNCw0LnQu9C+0LLQtSDQvdCwINCz0YDQsMyA0YTQsCDRgSDQv9C+0LTQsNCy0LDQvdC40Y/RgtCwINC90LUg0LzQvtCz0LDRgiDQtNCwINCx0YrQtNCw0YIg0L7RgtC60YDQuNGC0LgiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjU1NCBjb21taXQtZ3JhcGguYzo2MTQKKyM6IGNvbW1pdC1ncmFwaC5jOjU2MSBjb21taXQtZ3JhcGguYzo2MjEKIG1zZ2lkICJpbnZhbGlkIGNvbW1pdCBwb3NpdGlvbi4gY29tbWl0LWdyYXBoIGlzIGxpa2VseSBjb3JydXB0IgogbXNnc3RyICIiCiAi0L3QtdC/0YDQsNCy0LjQu9C90LAg0L/QvtC30LjRhtC40Y8g0L3QsCDQv9C+0LTQsNCy0LDQvdC10YLQvi4gINCS0LXRgNC+0Y/RgtC90L4g0LPRgNCw0YTRitGCINGBINC/0L7QtNCw0LLQsNC90LjRj9GC0LAg0LUg0L/QvtCy0YDQtdC00LXQvSIKIAotIzogY29tbWl0LWdyYXBoLmM6NTc1CisjOiBjb21taXQtZ3JhcGguYzo1ODIKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGZpbmQgY29tbWl0ICVzIgogbXNnc3RyICLQv9C+0LTQsNCy0LDQvdC10YLQviDigJ4lc+KAnCDQvdC1INC80L7QttC1INC00LAg0LHRitC00LUg0L7RgtC60YDQuNGC0L4iCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjEwMDIgYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNjU3CisjOiBjb21taXQtZ3JhcGguYzo4NTUgYnVpbHRpbi9hbS5jOjEyODcKKyMsIGMtZm9ybWF0Cittc2dpZCAidW5hYmxlIHRvIHBhcnNlIGNvbW1pdCAlcyIKK21zZ3N0ciAi0L/QvtC00LDQstCw0L3QtdGC0L4g0L3QtSDQvNC+0LbQtSDQtNCwINCx0YrQtNC1INCw0L3QsNC70LjQt9C40YDQsNC90L46ICVzIgorCisjOiBjb21taXQtZ3JhcGguYzo4NTkKKyMsIGMtZm9ybWF0Cittc2dpZCAidW5hYmxlIHRvIGdldCB0cmVlIGZvciAlcyIKK21zZ3N0ciAi0LTRitGA0LLQvtGC0L4g0L3QsCDigJ4lc+KAnCDQvdC1INC80L7QttC1INC00LAg0LHRitC00LUg0L/QvtC70YPRh9C10L3QviIKKworIzogY29tbWl0LWdyYXBoLmM6MTAxNyBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI2NDEKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGdldCB0eXBlIG9mIG9iamVjdCAlcyIKIG1zZ3N0ciAi0LLQuNC00YrRgiDQvdCwINC+0LHQtdC60YLQsCDigJ4lc+KAnCDQvdC1INC80L7QttC1INC00LAg0LHRitC00LUg0L7Qv9GA0LXQtNC10LvQtdC9IgogCi0jOiBjb21taXQtZ3JhcGguYzoxMDM0CisjOiBjb21taXQtZ3JhcGguYzoxMDQ5CiBtc2dpZCAiTG9hZGluZyBrbm93biBjb21taXRzIGluIGNvbW1pdCBncmFwaCIKIG1zZ3N0ciAi0JfQsNGA0LXQttC00LDQvdC1INC90LAg0L/QvtC30L3QsNGC0LjRgtC1INC/0L7QtNCw0LLQsNC90LjRjyDQsiDQs9GA0LDMgNGE0LAg0YEg0L/QvtC00LDQstCw0L3QuNGP0YLQsCIKIAotIzogY29tbWl0LWdyYXBoLmM6MTA1MQorIzogY29tbWl0LWdyYXBoLmM6MTA2NgogbXNnaWQgIkV4cGFuZGluZyByZWFjaGFibGUgY29tbWl0cyBpbiBjb21taXQgZ3JhcGgiCiBtc2dzdHIgItCg0LDQt9GI0LjRgNGP0LLQsNC90LUg0L3QsCDQtNC+0YHRgtC40LbQuNC80LjRgtC1INC/0L7QtNCw0LLQsNC90LjRjyDQsiDQs9GA0LDMgNGE0LAiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjEwNzAKKyM6IGNvbW1pdC1ncmFwaC5jOjEwODUKIG1zZ2lkICJDbGVhcmluZyBjb21taXQgbWFya3MgaW4gY29tbWl0IGdyYXBoIgogbXNnc3RyICLQmNC30YfQuNGB0YLQstCw0L3QtSDQvdCwINC+0YLQsdC10LvRj9C30LLQsNC90LjRj9GC0LAg0L3QsCDQv9C+0LTQsNCy0LDQvdC40Y/RgtCwINCyINCz0YDQsMyA0YTQsCDRgSDQv9C+0LTQsNCy0LDQvdC40Y/RgtCwIgogCi0jOiBjb21taXQtZ3JhcGguYzoxMDg5CisjOiBjb21taXQtZ3JhcGguYzoxMTA0CiBtc2dpZCAiQ29tcHV0aW5nIGNvbW1pdCBncmFwaCBnZW5lcmF0aW9uIG51bWJlcnMiCiBtc2dzdHIgItCY0LfRh9C40YHQu9GP0LLQsNC90LUg0L3QsCDQvdC+0LzQtdGA0LDRgtCwINC90LAg0L/QvtC60L7Qu9C10L3QuNGP0YLQsCDQsiDQs9GA0LDMgNGE0LAg0YEg0L/QvtC00LDQstCw0L3QuNGP0YLQsCIKIAotIzogY29tbWl0LWdyYXBoLmM6MTE2MworIzogY29tbWl0LWdyYXBoLmM6MTE3OQogIywgYy1mb3JtYXQKIG1zZ2lkICJGaW5kaW5nIGNvbW1pdHMgZm9yIGNvbW1pdCBncmFwaCBpbiAlZCBwYWNrIgogbXNnaWRfcGx1cmFsICJGaW5kaW5nIGNvbW1pdHMgZm9yIGNvbW1pdCBncmFwaCBpbiAlZCBwYWNrcyIKIG1zZ3N0clswXSAi0J7RgtC60YDQuNCy0LDQvdC1INC90LAg0L/QvtC00LDQstCw0L3QuNGP0YLQsCDQsiDQs9GA0LDMgNGE0LAg0LIgJWQg0L/QsNC60LXRgtC10L0g0YTQsNC50LsiCiBtc2dzdHJbMV0gItCe0YLQutGA0LjQstCw0L3QtSDQvdCwINC/0L7QtNCw0LLQsNC90LjRj9GC0LAg0LIg0LPRgNCwzIDRhNCwINCyICVkINC/0LDQutC10YLQvdC4INGE0LDQudC70LAiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjExNzYKKyM6IGNvbW1pdC1ncmFwaC5jOjExOTIKICMsIGMtZm9ybWF0CiBtc2dpZCAiZXJyb3IgYWRkaW5nIHBhY2sgJXMiCiBtc2dzdHIgItCz0YDQtdGI0LrQsCDQv9GA0Lgg0LTQvtCx0LDQstGP0L3QtSDQvdCwINC/0LDQutC10YLQtdC9INGE0LDQudC7IOKAniVz4oCcIgogCi0jOiBjb21taXQtZ3JhcGguYzoxMTgwCisjOiBjb21taXQtZ3JhcGguYzoxMTk2CiAjLCBjLWZvcm1hdAogbXNnaWQgImVycm9yIG9wZW5pbmcgaW5kZXggZm9yICVzIgogbXNnc3RyICLQs9GA0LXRiNC60LAg0L/RgNC4INC+0YLQstCw0YDRj9C90LUg0L3QsCDQuNC90LTQtdC60YHQsCDQvdCwIOKAniVz4oCcIgogCi0jOiBjb21taXQtZ3JhcGguYzoxMjA0CisjOiBjb21taXQtZ3JhcGguYzoxMjIwCiAjLCBjLWZvcm1hdAogbXNnaWQgIkZpbmRpbmcgY29tbWl0cyBmb3IgY29tbWl0IGdyYXBoIGZyb20gJWQgcmVmIgogbXNnaWRfcGx1cmFsICJGaW5kaW5nIGNvbW1pdHMgZm9yIGNvbW1pdCBncmFwaCBmcm9tICVkIHJlZnMiCiBtc2dzdHJbMF0gItCe0YLQutGA0LjQstCw0L3QtSDQvdCwINC/0L7QtNCw0LLQsNC90LjRj9GC0LAg0LIg0LPRgNCwzIDRhNCwINC40LfQvNC10LbQtNGDICVkINGD0LrQsNC30LDRgtC10LsiCiBtc2dzdHJbMV0gItCe0YLQutGA0LjQstCw0L3QtSDQvdCwINC/0L7QtNCw0LLQsNC90LjRj9GC0LAg0LIg0LPRgNCwzIDRhNCwINC40LfQvNC10LbQtNGDICVkINGD0LrQsNC30LDRgtC10LvQuCIKIAotIzogY29tbWl0LWdyYXBoLmM6MTIzOAorIzogY29tbWl0LWdyYXBoLmM6MTI0MAorIywgYy1mb3JtYXQKK21zZ2lkICJpbnZhbGlkIGNvbW1pdCBvYmplY3QgaWQ6ICVzIgorbXNnc3RyICLQvdC10L/RgNCw0LLQuNC70LXQvSDQuNC00LXQvdGC0LjRhNC40LrQsNGC0L7RgCDQvdCwINC+0LHQtdC60YIt0L/QvtC00LDQstCw0L3QtTog4oCeJXPigJwiCisKKyM6IGNvbW1pdC1ncmFwaC5jOjEyNTUKIG1zZ2lkICJGaW5kaW5nIGNvbW1pdHMgZm9yIGNvbW1pdCBncmFwaCBhbW9uZyBwYWNrZWQgb2JqZWN0cyIKIG1zZ3N0ciAi0J7RgtC60YDQuNCy0LDQvdC1INC90LAg0L/QvtC00LDQstCw0L3QuNGP0YLQsCDQsiDQs9GA0LDMgNGE0LAg0LjQt9C80LXQttC00YMg0L/QsNC60LXRgtC40YDQsNC90LjRgtC1INC+0LHQtdC60YLQuCIKIAotIzogY29tbWl0LWdyYXBoLmM6MTI1MworIzogY29tbWl0LWdyYXBoLmM6MTI3MAogbXNnaWQgIkNvdW50aW5nIGRpc3RpbmN0IGNvbW1pdHMgaW4gY29tbWl0IGdyYXBoIgogbXNnc3RyICLQn9GA0LXQsdGA0L7Rj9Cy0LDQvdC1INC90LAg0YDQsNC30LvQuNGH0L3QuNGC0LUg0L/QvtC00LDQstCw0L3QuNGPINCyINCz0YDQsMyA0YTQsCIKIAotIzogY29tbWl0LWdyYXBoLmM6MTI4NAorIzogY29tbWl0LWdyYXBoLmM6MTMwMAogbXNnaWQgIkZpbmRpbmcgZXh0cmEgZWRnZXMgaW4gY29tbWl0IGdyYXBoIgogbXNnc3RyICLQntGC0LrRgNC40LLQsNC90LUg0L3QsCDQvtGJ0LUg0LLRitGA0YXQvtCy0LUg0LIg0LPRgNCwzIDRhNCwINGBINC/0L7QtNCw0LLQsNC90LjRj9GC0LAiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjEzMzIKKyM6IGNvbW1pdC1ncmFwaC5jOjEzNDYKIG1zZ2lkICJmYWlsZWQgdG8gd3JpdGUgY29ycmVjdCBudW1iZXIgb2YgYmFzZSBncmFwaCBpZHMiCiBtc2dzdHIgItC/0YDQsNCy0LjQu9C90LjRj9GCINCx0YDQvtC5INC90LAg0LHQsNC30L7QstC40YLQtSDQuNC00LXQvdGC0LjRhNC40LrQsNGC0L7RgNC4INC90LUg0LzQvtC20LUg0LTQsCDRgdC1INC30LDQv9C40YjQtSIKIAotIzogY29tbWl0LWdyYXBoLmM6MTM2NSBtaWR4LmM6ODExCisjOiBjb21taXQtZ3JhcGguYzoxMzc5IG1pZHguYzo4MTAKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGNyZWF0ZSBsZWFkaW5nIGRpcmVjdG9yaWVzIG9mICVzIgogbXNnc3RyICLRgNC+0LTQuNGC0LXQu9GB0LrQuNGC0LUg0LTQuNGA0LXQutGC0L7RgNC40Lgg0L3QsCDigJ4lc+KAnCDQvdC1INC80L7Qs9Cw0YIg0LTQsCDQsdGK0LTQsNGCINGB0YrQt9C00LDQtNC10L3QuCIKIAotIzogY29tbWl0LWdyYXBoLmM6MTM3NyBidWlsdGluL2luZGV4LXBhY2suYzozMDYgYnVpbHRpbi9yZXBhY2suYzoyNDAKKyM6IGNvbW1pdC1ncmFwaC5jOjEzOTEgYnVpbHRpbi9pbmRleC1wYWNrLmM6MzA2IGJ1aWx0aW4vcmVwYWNrLmM6MjQxCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBjcmVhdGUgJyVzJyIKIG1zZ3N0ciAi0L/QsNC60LXRgtC90LjRj9GCINGE0LDQudC7IOKAniVz4oCcINC90LUg0LzQvtC20LUg0LTQsCDQsdGK0LTQtSDRgdGK0LfQtNCw0LTQtdC9IgogCi0jOiBjb21taXQtZ3JhcGguYzoxNDM3CisjOiBjb21taXQtZ3JhcGguYzoxNDUxCiAjLCBjLWZvcm1hdAogbXNnaWQgIldyaXRpbmcgb3V0IGNvbW1pdCBncmFwaCBpbiAlZCBwYXNzIgogbXNnaWRfcGx1cmFsICJXcml0aW5nIG91dCBjb21taXQgZ3JhcGggaW4gJWQgcGFzc2VzIgogbXNnc3RyWzBdICLQl9Cw0L/QsNC30LLQsNC90LUg0L3QsCDQs9GA0LDMgNGE0LAg0YEg0L/QvtC00LDQstCw0L3QuNGP0YLQsCDQsiAlZCDQv9Cw0YEiCiBtc2dzdHJbMV0gItCX0LDQv9Cw0LfQstCw0L3QtSDQvdCwINCz0YDQsMyA0YTQsCDRgSDQv9C+0LTQsNCy0LDQvdC40Y/RgtCwINCyICVkINC/0LDRgdCwIgogCi0jOiBjb21taXQtZ3JhcGguYzoxNDc4CisjOiBjb21taXQtZ3JhcGguYzoxNDkyCiBtc2dpZCAidW5hYmxlIHRvIG9wZW4gY29tbWl0LWdyYXBoIGNoYWluIGZpbGUiCiBtc2dzdHIgItGE0LDQudC70YrRgiDRgSDQstC10YDQuNCz0LDRgtCwINC90LAg0LPRgNCwzIDRhNCwINGBINC/0L7QtNCw0LLQsNC90LjRj9GC0LAg0L3QtSDQvNC+0LbQtSDQtNCwINGB0LUg0L7RgtCy0L7RgNC4IgogCi0jOiBjb21taXQtZ3JhcGguYzoxNDkwCisjOiBjb21taXQtZ3JhcGguYzoxNTA0CiBtc2dpZCAiZmFpbGVkIHRvIHJlbmFtZSBiYXNlIGNvbW1pdC1ncmFwaCBmaWxlIgogbXNnc3RyICLQvtGB0L3QvtCy0L3QuNGP0YIg0YTQsNC50Lsg0L3QsCDQs9GA0LDMgNGE0LAg0YEg0L/QvtC00LDQstCw0L3QuNGP0YLQsCDQvdC1INC80L7QttC1INC00LAg0LHRitC00LUg0L/RgNC10LjQvNC10L3Rg9Cy0LDQvSIKIAotIzogY29tbWl0LWdyYXBoLmM6MTUxMAorIzogY29tbWl0LWdyYXBoLmM6MTUyNAogbXNnaWQgImZhaWxlZCB0byByZW5hbWUgdGVtcG9yYXJ5IGNvbW1pdC1ncmFwaCBmaWxlIgogbXNnc3RyICLQstGA0LXQvNC10L3QvdC40Y/RgiDRhNCw0LnQuyDQvdCwINCz0YDQsMyA0YTQsCDRgSDQv9C+0LTQsNCy0LDQvdC40Y/RgtCwINC90LUg0LzQvtC20LUg0LTQsCDQsdGK0LTQtSDQv9GA0LXQuNC80LXQvdGD0LLQsNC9IgogCi0jOiBjb21taXQtZ3JhcGguYzoxNjIxCisjOiBjb21taXQtZ3JhcGguYzoxNjM1CiBtc2dpZCAiU2Nhbm5pbmcgbWVyZ2VkIGNvbW1pdHMiCiBtc2dzdHIgItCi0YrRgNGB0LXQvdC1INC90LAg0L/QvtC00LDQstCw0L3QuNGP0YLQsCDRgdGK0YEg0YHQu9C40LLQsNC90LjRjyIKIAotIzogY29tbWl0LWdyYXBoLmM6MTYzMgorIzogY29tbWl0LWdyYXBoLmM6MTY0NgogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmV4cGVjdGVkIGR1cGxpY2F0ZSBjb21taXQgaWQgJXMiCiBtc2dzdHIgItC90LXQvtGH0LDQutCy0LDQvSwg0L/QvtCy0YLQsNGA0Y/RiSDRgdC1INC40LTQtdC90YLQuNGE0LjQutCw0YLQvtGAINC90LAg0L/QvtC00LDQstCw0L3QtTogJXMiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjE2NTcKKyM6IGNvbW1pdC1ncmFwaC5jOjE2NzAKIG1zZ2lkICJNZXJnaW5nIGNvbW1pdC1ncmFwaCIKIG1zZ3N0ciAi0KHQu9C40LLQsNC90LUg0L3QsCDQs9GA0LDMgNGE0LAg0YEg0L/QvtC00LDQstCw0L3QuNGP0YLQsCIKIAotIzogY29tbWl0LWdyYXBoLmM6MTg0NAorIzogY29tbWl0LWdyYXBoLmM6MTg2MAogIywgYy1mb3JtYXQKIG1zZ2lkICJ0aGUgY29tbWl0IGdyYXBoIGZvcm1hdCBjYW5ub3Qgd3JpdGUgJWQgY29tbWl0cyIKIG1zZ3N0ciAi0YTQvtGA0LzQsNGC0YrRgiDQvdCwINCz0YDQsMyA0YTQsCDRgSDQv9C+0LTQsNCy0LDQvdC40Y/RgtCwINC90LUg0LzQvtC20LUg0LTQsCDQt9Cw0L/QuNGI0LUgJWQg0L/QvtC00LDQstCw0L3QuNGPIgogCi0jOiBjb21taXQtZ3JhcGguYzoxODU1CisjOiBjb21taXQtZ3JhcGguYzoxODcxCiBtc2dpZCAidG9vIG1hbnkgY29tbWl0cyB0byB3cml0ZSBncmFwaCIKIG1zZ3N0ciAi0L/RgNC10LrQsNC70LXQvdC+INC80L3QvtCz0L4g0L/QvtC00LDQstCw0L3QuNGPINC30LAg0LfQsNC/0LjRgdCy0LDQvdC1INC90LAg0LPRgNCwzIDRhNCwIgogCi0jOiBjb21taXQtZ3JhcGguYzoxOTQ1CisjOiBjb21taXQtZ3JhcGguYzoxOTYxCiBtc2dpZCAidGhlIGNvbW1pdC1ncmFwaCBmaWxlIGhhcyBpbmNvcnJlY3QgY2hlY2tzdW0gYW5kIGlzIGxpa2VseSBjb3JydXB0IgogbXNnc3RyICLQs9GA0LDRhNGK0YIg0YEg0L/QvtC00LDQstCw0L3QuNGP0YLQsCDQtSDRgSDQs9GA0LXRiNC90LAg0YHRg9C80LAg0LfQsCDQv9GA0L7QstC10YDQutCwIOKAlCDQstC10YDQvtGP0YLQvdC+INC1INC/0L7QstGA0LXQtNC10L0iCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjE5NTUKKyM6IGNvbW1pdC1ncmFwaC5jOjE5NzEKICMsIGMtZm9ybWF0CiBtc2dpZCAiY29tbWl0LWdyYXBoIGhhcyBpbmNvcnJlY3QgT0lEIG9yZGVyOiAlcyB0aGVuICVzIgogbXNnc3RyICIiCiAi0L3QtdC/0YDQsNCy0LjQu9C90LAg0L/QvtC00YDQtdC00LHQsCDQvdCwINC+0LHQtdC60YLQuNGC0LUg0L/QviDQuNC00LXQvdGC0LjRhNC40LrQsNGC0L7RgCDQsiDQs9GA0LDMgNGE0LAg0YEg0L/QvtC00LDQstCw0L3QuNGP0YLQsDog4oCeJXPigJwgIgogItC1INC/0YDQtdC00Lgg4oCeJXPigJwsINCwINC90LUg0YLRgNGP0LHQstCwIgogCi0jOiBjb21taXQtZ3JhcGguYzoxOTY1IGNvbW1pdC1ncmFwaC5jOjE5ODAKKyM6IGNvbW1pdC1ncmFwaC5jOjE5ODEgY29tbWl0LWdyYXBoLmM6MTk5NgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb21taXQtZ3JhcGggaGFzIGluY29ycmVjdCBmYW5vdXQgdmFsdWU6IGZhbm91dFslZF0gPSAldSAhPSAldSIKIG1zZ3N0ciAiIgogItC90LXQv9GA0LDQstC40LvQvdCwINGB0YLQvtC50L3QvtGB0YIg0LfQsCDQvtGC0LrRitGBINCyINCz0YDQsMyA0YTQsCDRgSDQv9C+0LTQsNCy0LDQvdC40Y/RgtCwOiBmYW5vdXRbJWRdID0gJXUsINCwICIKICLRgtGA0Y/QsdCy0LAg0LTQsCDQtSAldSIKIAotIzogY29tbWl0LWdyYXBoLmM6MTk3MgorIzogY29tbWl0LWdyYXBoLmM6MTk4OAogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gcGFyc2UgY29tbWl0ICVzIGZyb20gY29tbWl0LWdyYXBoIgogbXNnc3RyICLQv9C+0LTQsNCy0LDQvdC1IOKAniVz4oCcINCyINCz0YDQsMyA0YTQsCDRgSDQv9C+0LTQsNCy0LDQvdC40Y/RgtCwINC90LUg0LzQvtC20LUg0LTQsCDRgdC1INCw0L3QsNC70LjQt9C40YDQsCIKIAotIzogY29tbWl0LWdyYXBoLmM6MTk4OQorIzogY29tbWl0LWdyYXBoLmM6MjAwNgogbXNnaWQgIlZlcmlmeWluZyBjb21taXRzIGluIGNvbW1pdCBncmFwaCIKIG1zZ3N0ciAi0J/RgNC+0LLQtdGA0LrQsCDQvdCwINC/0L7QtNCw0LLQsNC90LjRj9GC0LAg0LIg0LPRgNCwzIDRhNCwIgogCi0jOiBjb21taXQtZ3JhcGguYzoyMDAyCisjOiBjb21taXQtZ3JhcGguYzoyMDIwCiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBwYXJzZSBjb21taXQgJXMgZnJvbSBvYmplY3QgZGF0YWJhc2UgZm9yIGNvbW1pdC1ncmFwaCIKIG1zZ3N0ciAiIgogItC/0L7QtNCw0LLQsNC90LUg4oCeJXPigJwg0LIg0LHQsNC30LDRgtCwINC+0YIg0LTQsNC90L3QuCDQutGK0Lwg0LPRgNCwzIDRhNCwINGBINC/0L7QtNCw0LLQsNC90LjRj9GC0LAg0L3QtSDQvNC+0LbQtSDQtNCwINGB0LUgIgogItCw0L3QsNC70LjQt9C40YDQsCIKIAotIzogY29tbWl0LWdyYXBoLmM6MjAwOQorIzogY29tbWl0LWdyYXBoLmM6MjAyNwogIywgYy1mb3JtYXQKIG1zZ2lkICJyb290IHRyZWUgT0lEIGZvciBjb21taXQgJXMgaW4gY29tbWl0LWdyYXBoIGlzICVzICE9ICVzIgogbXNnc3RyICIiCiAi0LjQtNC10L3RgtC40YTQuNC60LDRgtC+0YDRitGCINC90LAg0L7QsdC10LrRgiDQt9CwINC60L7RgNC10L3QvtCy0L7RgtC+INC00YrRgNCy0L4g0LfQsCDQv9C+0LTQsNCy0LDQvdC1IOKAniVz4oCcINCyINCz0YDQsMyA0YTQsCDRgSAiCiAi0L/QvtC00LDQstCw0L3QuNGP0YLQsCDQtSDigJ4lc+KAnCwg0LAg0YLRgNGP0LHQstCwINC00LAg0LUg4oCeJXPigJwiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjIwMTkKKyM6IGNvbW1pdC1ncmFwaC5jOjIwMzcKICMsIGMtZm9ybWF0CiBtc2dpZCAiY29tbWl0LWdyYXBoIHBhcmVudCBsaXN0IGZvciBjb21taXQgJXMgaXMgdG9vIGxvbmciCiBtc2dzdHIgItGB0L/QuNGB0YrQutGK0YIg0YEg0YDQvtC00LjRgtC10LvQuCDQvdCwIOKAniVz4oCcINCyINCz0YDQsMyA0YTQsCDRgSDQv9C+0LTQsNCy0LDQvdC40Y/RgtCwINC1INC/0YDQtdC60LDQu9C10L3QviDQtNGK0LvRitCzIgogCi0jOiBjb21taXQtZ3JhcGguYzoyMDI4CisjOiBjb21taXQtZ3JhcGguYzoyMDQ2CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvbW1pdC1ncmFwaCBwYXJlbnQgZm9yICVzIGlzICVzICE9ICVzIgogbXNnc3RyICLRgNC+0LTQuNGC0LXQu9GP0YIg0L3QsCDigJ4lc+KAnCDQsiDQs9GA0LDMgNGE0LAg0YEg0L/QvtC00LDQstCw0L3QuNGP0YLQsCDQtSDigJ4lc+KAnCwg0LAg0YLRgNGP0LHQstCwINC00LAg0LUg4oCeJXPigJwiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjIwNDEKKyM6IGNvbW1pdC1ncmFwaC5jOjIwNTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiY29tbWl0LWdyYXBoIHBhcmVudCBsaXN0IGZvciBjb21taXQgJXMgdGVybWluYXRlcyBlYXJseSIKIG1zZ3N0ciAi0YHQv9C40YHRitC60YrRgiDRgSDRgNC+0LTQuNGC0LXQu9C4INC90LAg4oCeJXPigJwg0LIg0LPRgNCwzIDRhNCwINGBINC/0L7QtNCw0LLQsNC90LjRj9GC0LAg0LUg0L/RgNC10LrQsNC70LXQvdC+INC60YrRgSIKIAotIzogY29tbWl0LWdyYXBoLmM6MjA0NgorIzogY29tbWl0LWdyYXBoLmM6MjA2NAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiY29tbWl0LWdyYXBoIGhhcyBnZW5lcmF0aW9uIG51bWJlciB6ZXJvIGZvciBjb21taXQgJXMsIGJ1dCBub24temVybyBlbHNld2hlcmUiCkBAIC0xODE3LDcgKzE4MzMsNyBAQAogItC90L7QvNC10YDRitGCINC90LAg0L/QvtC60L7Qu9C10L3QuNC10YLQviDQvdCwINC/0L7QtNCw0LLQsNC90LUg4oCeJXPigJwg0LIg0LPRgNCwzIDRhNCwINGBINC/0L7QtNCw0LLQsNC90LjRj9GC0LAg0LUgMCwg0LAg0LTRgNGD0LPQsNC00LUgIgogItC90LUg0LUiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjIwNTAKKyM6IGNvbW1pdC1ncmFwaC5jOjIwNjgKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogImNvbW1pdC1ncmFwaCBoYXMgbm9uLXplcm8gZ2VuZXJhdGlvbiBudW1iZXIgZm9yIGNvbW1pdCAlcywgYnV0IHplcm8gZWxzZXdoZXJlIgpAQCAtMTgyNSwxNCArMTg0MSwxNCBAQAogItC90L7QvNC10YDRitGCINC90LAg0L/QvtC60L7Qu9C10L3QuNC10YLQviDQvdCwINC/0L7QtNCw0LLQsNC90LUg4oCeJXPigJwg0LIg0LPRgNCwzIDRhNCwINGBINC/0L7QtNCw0LLQsNC90LjRj9GC0LAg0L3QtSDQtSAwLCDQsCAiCiAi0LTRgNGD0LPQsNC00LUg0LUiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjIwNjUKKyM6IGNvbW1pdC1ncmFwaC5jOjIwODMKICMsIGMtZm9ybWF0CiBtc2dpZCAiY29tbWl0LWdyYXBoIGdlbmVyYXRpb24gZm9yIGNvbW1pdCAlcyBpcyAldSAhPSAldSIKIG1zZ3N0ciAiIgogItC90L7QvNC10YDRitGCINC90LAg0L/QvtC60L7Qu9C10L3QuNC10YLQviDQvdCwINC/0L7QtNCw0LLQsNC90LUg4oCeJXPigJwg0LIg0LPRgNCwzIDRhNCwINGBINC/0L7QtNCw0LLQsNC90LjRj9GC0LAg0LUgJXUsINCwICIKICLQtNGA0YPQs9Cw0LTQtSDQtSAldSIKIAotIzogY29tbWl0LWdyYXBoLmM6MjA3MQorIzogY29tbWl0LWdyYXBoLmM6MjA4OQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb21taXQgZGF0ZSBmb3IgY29tbWl0ICVzIGluIGNvbW1pdC1ncmFwaCBpcyAlPFBSSXVNQVg+ICE9ICU8UFJJdU1BWD4iCiBtc2dzdHIgIiIKQEAgLTE4ODEsNyArMTg5Nyw3IEBACiBtc2dpZCAia2V5IGRvZXMgbm90IGNvbnRhaW4gdmFyaWFibGUgbmFtZTogJXMiCiBtc2dzdHIgItC60LvRjtGH0YrRgiDQvdC1INGB0YrQtNGK0YDQttCwINC40LzQtSDQvdCwINC/0YDQvtC80LXQvdC70LjQstCwOiDigJ4lc+KAnCIKIAotIzogY29uZmlnLmM6NDA2IHNlcXVlbmNlci5jOjI0NjMKKyM6IGNvbmZpZy5jOjQwNiBzZXF1ZW5jZXIuYzoyNDAxCiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQga2V5OiAlcyIKIG1zZ3N0ciAi0L3QtdC/0YDQsNCy0LjQu9C10L0g0LrQu9GO0Yc6IOKAniVz4oCcIgpAQCAtMjAwMywxNyArMjAxOSwxNyBAQAogbXNnaWQgImludmFsaWQgbW9kZSBmb3Igb2JqZWN0IGNyZWF0aW9uOiAlcyIKIG1zZ3N0ciAi0L3QtdC/0YDQsNCy0LjQu9C10L0g0YDQtdC20LjQvCDQt9CwINGB0YrQt9C00LDQstCw0L3QtdGC0L4g0L3QsCDQvtCx0LXQutGC0Lg6ICVzIgogCi0jOiBjb25maWcuYzoxNDMwCisjOiBjb25maWcuYzoxNDI1CiAjLCBjLWZvcm1hdAogbXNnaWQgIm1hbGZvcm1lZCB2YWx1ZSBmb3IgJXMiCiBtc2dzdHIgItC90LXQv9GA0LDQstC40LvQvdCwINGB0YLQvtC50L3QvtGB0YIg0LfQsCDigJ4lc+KAnCIKIAotIzogY29uZmlnLmM6MTQ1NgorIzogY29uZmlnLmM6MTQ1MQogIywgYy1mb3JtYXQKIG1zZ2lkICJtYWxmb3JtZWQgdmFsdWUgZm9yICVzOiAlcyIKIG1zZ3N0ciAi0L3QtdC/0YDQsNCy0LjQu9C90LAg0YHRgtC+0LnQvdC+0YHRgiDQt9CwIOKAniVz4oCcOiDigJ4lc+KAnCIKIAotIzogY29uZmlnLmM6MTQ1NworIzogY29uZmlnLmM6MTQ1MgogbXNnaWQgIm11c3QgYmUgb25lIG9mIG5vdGhpbmcsIG1hdGNoaW5nLCBzaW1wbGUsIHVwc3RyZWFtIG9yIGN1cnJlbnQiCiBtc2dzdHIgIiIKICLRgtGA0Y/QsdCy0LAg0LTQsCDQtSDQtdC00L3QsCDQvtGCINGB0LvQtdC00L3QuNGC0LUg0YHRgtC+0LnQvdC+0YHRgtC4OiDigJ5ub3RoaW5n4oCcICjQsdC10Lcg0LjQt9GC0LvQsNGB0LrQstCw0L3QtSDQv9GA0Lgg0LvQuNC/0YHQsCAiCkBAIC0yMDIxLDEzOSArMjAzNywxMzIgQEAKICLigJ5zaW1wbGXigJwgKNC60LvQvtC90YrRgiDRgdGK0YEg0YHRitGJ0L7RgtC+INC40LzQtSwg0L7RgiDQutC+0LnRgtC+INGB0LUg0LjQt9C00YrRgNC/0LLQsCksIOKAnnVwc3RyZWFt4oCcICjQutC70L7QvdGK0YIsICIKICLQvtGCINC60L7QudGC0L4g0YHQtSDQuNC30LTRitGA0L/QstCwKSDQuNC70Lgg4oCeY3VycmVudOKAnCAo0LrQu9C+0L3RitGCINGB0YrRgSDRgdGK0YnQvtGC0L4g0LjQvNC1KSIKIAotIzogY29uZmlnLmM6MTUxOCBidWlsdGluL3BhY2stb2JqZWN0cy5jOjM0MTAKKyM6IGNvbmZpZy5jOjE1MTMgYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzk0CiAjLCBjLWZvcm1hdAogbXNnaWQgImJhZCBwYWNrIGNvbXByZXNzaW9uIGxldmVsICVkIgogbXNnc3RyICLQvdC10L/RgNCw0LLQuNC70L3QviDQvdC40LLQviDQvdCwINC60L7QvNC/0YDQtdGB0LjRgNCw0L3QtSDQv9GA0Lgg0L/QsNC60LXRgtC40YDQsNC90LU6ICVkIgogCi0jOiBjb25maWcuYzoxNjM5CisjOiBjb25maWcuYzoxNjM0CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBsb2FkIGNvbmZpZyBibG9iIG9iamVjdCAnJXMnIgogbXNnc3RyICLQvtCx0LXQutGC0YrRgi1CTE9CIOKAniVz4oCcINGBINC60L7QvdGE0LjQs9GD0YDQsNGG0LjQuCDQvdC1INC80L7QttC1INC00LAg0YHQtSDQt9Cw0YDQtdC00LgiCiAKLSM6IGNvbmZpZy5jOjE2NDIKKyM6IGNvbmZpZy5jOjE2MzcKICMsIGMtZm9ybWF0CiBtc2dpZCAicmVmZXJlbmNlICclcycgZG9lcyBub3QgcG9pbnQgdG8gYSBibG9iIgogbXNnc3RyICLRg9C60LDQt9Cw0YLQtdC70Y/RgiDigJ4lc+KAnCDQvdC1INGB0L7Rh9C4INC60YrQvCDQvtCx0LXQutGCLUJMT0IiCiAKLSM6IGNvbmZpZy5jOjE2NTkKKyM6IGNvbmZpZy5jOjE2NTQKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHJlc29sdmUgY29uZmlnIGJsb2IgJyVzJyIKIG1zZ3N0ciAi0L7QsdC10LrRgtGK0YItQkxPQiDigJ4lc+KAnCDRgSDQutC+0L3RhNC40LPRg9GA0LDRhtC40Lgg0L3QtSDQvNC+0LbQtSDQtNCwINCx0YrQtNC1INC+0YLQutGA0LjRgiIKIAotIzogY29uZmlnLmM6MTY4OQorIzogY29uZmlnLmM6MTY4NAogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gcGFyc2UgJXMiCiBtc2dzdHIgIuKAniVz4oCcINC90LUg0LzQvtC20LUg0LTQsCDQsdGK0LTQtSDQsNC90LDQu9C40LfQuNGA0LDQvSIKIAotIzogY29uZmlnLmM6MTc0NQorIzogY29uZmlnLmM6MTc0MAogbXNnaWQgInVuYWJsZSB0byBwYXJzZSBjb21tYW5kLWxpbmUgY29uZmlnIgogbXNnc3RyICLQvdC10L/RgNCw0LLQuNC70L3QuCDQvdCw0YHRgtGA0L7QudC60Lgg0L7RgiDQutC+0LzQsNC90LTQvdC40Y8g0YDQtdC0IgogCi0jOiBjb25maWcuYzoyMDk0CisjOiBjb25maWcuYzoyMDkxCiBtc2dpZCAidW5rbm93biBlcnJvciBvY2N1cnJlZCB3aGlsZSByZWFkaW5nIHRoZSBjb25maWd1cmF0aW9uIGZpbGVzIgogbXNnc3RyICLQvdC10L7Rh9Cw0LrQstCw0L3QsCDQs9GA0LXRiNC60LAg0L/RgNC4INC40LfRh9C40YLQsNC90LXRgtC+INC90LAg0LrQvtC90YTQuNCz0YPRgNCw0YbQuNC+0L3QvdC40YLQtSDRhNCw0LnQu9C+0LLQtSIKIAotIzogY29uZmlnLmM6MjI2NAorIzogY29uZmlnLmM6MjI2MQogIywgYy1mb3JtYXQKIG1zZ2lkICJJbnZhbGlkICVzOiAnJXMnIgogbXNnc3RyICLQndC10L/RgNCw0LLQuNC70LXQvSAlczog4oCeJXPigJwiCiAKLSM6IGNvbmZpZy5jOjIzMDcKLSMsIGMtZm9ybWF0Ci1tc2dpZCAidW5rbm93biBjb3JlLnVudHJhY2tlZENhY2hlIHZhbHVlICclcyc7IHVzaW5nICdrZWVwJyBkZWZhdWx0IHZhbHVlIgotbXNnc3RyICIiCi0i0L3QtdC/0L7Qt9C90LDRgtCwINGB0YLQvtC50L3QvtGB0YIg4oCeJXPigJwg0LfQsCDQvdCw0YHRgtGA0L7QudC60LDRgtCwIOKAnmNvcmUudW50cmFja2VkQ2FjaGXigJwuICDQqdC1INGB0LUg0L/QvtC70LfQstCwICIKLSLRgdGC0LDQvdC00LDRgNGC0L3QsNGC0LAg0YHRgtC+0LnQvdC+0YHRgiDigJ5rZWVw4oCcICjQt9Cw0L/QsNC30LLQsNC90LUpIgotCi0jOiBjb25maWcuYzoyMzMzCisjOiBjb25maWcuYzoyMzA2CiAjLCBjLWZvcm1hdAogbXNnaWQgInNwbGl0SW5kZXgubWF4UGVyY2VudENoYW5nZSB2YWx1ZSAnJWQnIHNob3VsZCBiZSBiZXR3ZWVuIDAgYW5kIDEwMCIKIG1zZ3N0ciAiIgogItGB0YLQvtC50L3QvtGB0YLRgtCwINC90LAg4oCec3BsaXRJbmRleC5tYXhQZXJjZW50Q2hhbmdl4oCcINGC0YDRj9Cx0LLQsCDQtNCwINC1INC80LXQttC00YMgMSDQuCAxMDAsINCwINC90LUgIgogIiVkIgogCi0jOiBjb25maWcuYzoyMzc5CisjOiBjb25maWcuYzoyMzUyCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBwYXJzZSAnJXMnIGZyb20gY29tbWFuZC1saW5lIGNvbmZpZyIKIG1zZ3N0ciAi0L3QtdGA0LDQt9C/0L7Qt9C90LDRgtCwINGB0YLQvtC50L3QvtGB0YIg4oCeJXPigJwg0L7RgiDQutC+0LzQsNC90LTQvdC40Y8g0YDQtdC0IgogCi0jOiBjb25maWcuYzoyMzgxCisjOiBjb25maWcuYzoyMzU0CiAjLCBjLWZvcm1hdAogbXNnaWQgImJhZCBjb25maWcgdmFyaWFibGUgJyVzJyBpbiBmaWxlICclcycgYXQgbGluZSAlZCIKIG1zZ3N0ciAi0L3QtdC/0YDQsNCy0LjQu9C90LAg0L3QsNGB0YLRgNC+0LnQutCwIOKAniVz4oCcINCy0YrQsiDRhNCw0LnQu9CwIOKAniVz4oCcINC90LAg0YDQtdC0IOKEliVkIgogCi0jOiBjb25maWcuYzoyNDYyCisjOiBjb25maWcuYzoyNDM1CiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgc2VjdGlvbiBuYW1lICclcyciCiBtc2dzdHIgItC90LXQv9GA0LDQstC40LvQvdC+INC40LzQtSDQvdCwINGA0LDQt9C00LXQuzog4oCeJXPigJwiCiAKLSM6IGNvbmZpZy5jOjI0OTQKKyM6IGNvbmZpZy5jOjI0NjcKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgaGFzIG11bHRpcGxlIHZhbHVlcyIKIG1zZ3N0ciAi0LfQsNC00LDQtNC10L3QuCDRgdCwINC90Y/QutC+0LvQutC+INGB0YLQvtC50L3QvtGB0YLQuCDQt9CwIOKAniVz4oCcIgogCi0jOiBjb25maWcuYzoyNTIzCisjOiBjb25maWcuYzoyNDk2CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byB3cml0ZSBuZXcgY29uZmlndXJhdGlvbiBmaWxlICVzIgogbXNnc3RyICLQvdC+0LLQuNGP0YIg0LrQvtC90YTQuNCz0YPRgNCw0YbQuNC+0L3QtdC9INGE0LDQudC7IOKAniVz4oCcINC90LUg0LzQvtC20LUg0LTQsCDQsdGK0LTQtSDQt9Cw0L/QsNC30LXQvSIKIAotIzogY29uZmlnLmM6Mjc3NSBjb25maWcuYzozMDk5CisjOiBjb25maWcuYzoyNzQ4IGNvbmZpZy5jOjMwNzIKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGxvY2sgY29uZmlnIGZpbGUgJXMiCiBtc2dzdHIgItC60L7QvdGE0LjQs9GD0YDQsNGG0LjQvtC90L3QuNGP0YIg0YTQsNC50Lsg4oCeJXPigJwg0L3QtSDQvNC+0LbQtSDQtNCwINCx0YrQtNC1INC30LDQutC70Y7Rh9C10L0iCiAKLSM6IGNvbmZpZy5jOjI3ODYKKyM6IGNvbmZpZy5jOjI3NTkKICMsIGMtZm9ybWF0CiBtc2dpZCAib3BlbmluZyAlcyIKIG1zZ3N0ciAi0L7RgtCy0LDRgNGP0L3QtSDQvdCwIOKAniVz4oCcIgogCi0jOiBjb25maWcuYzoyODIxIGJ1aWx0aW4vY29uZmlnLmM6MzI4CisjOiBjb25maWcuYzoyNzk0IGJ1aWx0aW4vY29uZmlnLmM6MzI4CiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgcGF0dGVybjogJXMiCiBtc2dzdHIgItC90LXQv9GA0LDQstC40LvQtdC9INGI0LDQsdC70L7QvTogJXMiCiAKLSM6IGNvbmZpZy5jOjI4NDYKKyM6IGNvbmZpZy5jOjI4MTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBjb25maWcgZmlsZSAlcyIKIG1zZ3N0ciAi0L3QtdC/0YDQsNCy0LjQu9C10L0g0LrQvtC90YTQuNCz0YPRgNCw0YbQuNC+0L3QtdC9INGE0LDQudC7OiDigJ4lc+KAnCIKIAotIzogY29uZmlnLmM6Mjg1OSBjb25maWcuYzozMTEyCisjOiBjb25maWcuYzoyODMyIGNvbmZpZy5jOjMwODUKICMsIGMtZm9ybWF0CiBtc2dpZCAiZnN0YXQgb24gJXMgZmFpbGVkIgogbXNnc3RyICLQvdC10YPRgdC/0LXRiNC90L4g0LjQt9C/0YrQu9C90LXQvdC40LUg0L3QsCDigJ5mc3RhdOKAnCDQstGK0YDRhdGDIOKAniVz4oCcIgogCi0jOiBjb25maWcuYzoyODcwCisjOiBjb25maWcuYzoyODQzCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBtbWFwICclcyciCiBtc2dzdHIgItC90LXRg9GB0L/QtdGI0L3QviDQuNC30L/RitC70L3QtdC90LjQtSDQvdCwIOKAnm1tYXDigJwg0LLRitGA0YXRgyDigJ4lc+KAnCIKIAotIzogY29uZmlnLmM6Mjg3OSBjb25maWcuYzozMTE3CisjOiBjb25maWcuYzoyODUyIGNvbmZpZy5jOjMwOTAKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2htb2Qgb24gJXMgZmFpbGVkIgogbXNnc3RyICLQvdC10YPRgdC/0LXRiNC90LAg0YHQvNGP0L3QsCDQvdCwINC/0YDQsNCy0LAg0YEg4oCeY2htb2TigJwg0LLRitGA0YXRgyDigJ4lc+KAnCIKIAotIzogY29uZmlnLmM6Mjk2NCBjb25maWcuYzozMjE0CisjOiBjb25maWcuYzoyOTM3IGNvbmZpZy5jOjMxODcKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHdyaXRlIGNvbmZpZyBmaWxlICVzIgogbXNnc3RyICLQutC+0L3RhNC40LPRg9GA0LDRhtC40L7QvdC90LjRj9GCINGE0LDQudC7IOKAniVz4oCcINC90LUg0LzQvtC20LUg0LTQsCDQsdGK0LTQtSDQt9Cw0L/QuNGB0LDQvSIKIAotIzogY29uZmlnLmM6Mjk5OAorIzogY29uZmlnLmM6Mjk3MQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3Qgc2V0ICclcycgdG8gJyVzJyIKIG1zZ3N0ciAi4oCeJXPigJwg0L3QtSDQvNC+0LbQtSDQtNCwINGB0LUg0LfQsNC00LDQtNC1INC00LAg0LUg4oCeJXPigJwiCiAKLSM6IGNvbmZpZy5jOjMwMDAgYnVpbHRpbi9yZW1vdGUuYzo3ODIKKyM6IGNvbmZpZy5jOjI5NzMgYnVpbHRpbi9yZW1vdGUuYzo3ODIKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHVuc2V0ICclcyciCiBtc2dzdHIgIuKAniVz4oCcINC90LUg0LzQvtC20LUg0LTQsCDRgdC1INC/0YDQtdC80LDRhdC90LUiCiAKLSM6IGNvbmZpZy5jOjMwOTAKKyM6IGNvbmZpZy5jOjMwNjMKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBzZWN0aW9uIG5hbWU6ICVzIgogbXNnc3RyICLQvdC10L/RgNCw0LLQuNC70L3QviDQuNC80LUg0L3QsCDRgNCw0LfQtNC10Ls6ICVzIgogCi0jOiBjb25maWcuYzozMjU3CisjOiBjb25maWcuYzozMjMwCiAjLCBjLWZvcm1hdAogbXNnaWQgIm1pc3NpbmcgdmFsdWUgZm9yICclcyciCiBtc2dzdHIgItC70LjQv9GB0LLQsCDRgdGC0L7QudC90L7RgdGCINC30LAg4oCeJXPigJwiCkBAIC0yMjc4LDcgKzIyODcsNyBAQAogbXNnaWQgInVua25vd24gcG9ydCAlcyIKIG1zZ3N0ciAi0L3QtdC/0L7Qt9C90LDRgiDQv9C+0YDRgiDigJ4lc+KAnCIKIAotIzogY29ubmVjdC5jOjg0NSBjb25uZWN0LmM6MTE3MQorIzogY29ubmVjdC5jOjg0NSBjb25uZWN0LmM6MTE3NQogIywgYy1mb3JtYXQKIG1zZ2lkICJzdHJhbmdlIGhvc3RuYW1lICclcycgYmxvY2tlZCIKIG1zZ3N0ciAi0L3QtdC+0LHQuNGH0LDQudC90L7RgtC+INC40LzQtSDQvdCwINGF0L7RgdGCIOKAniVz4oCcINC1INCx0LvQvtC60LjRgNCw0L3QviIKQEAgLTIyOTMsNjIgKzIzMDIsNjIgQEAKIG1zZ2lkICJjYW5ub3Qgc3RhcnQgcHJveHkgJXMiCiBtc2dzdHIgItC/0L7RgdGA0LXQtNC90LjQutGK0YIg4oCeJXPigJwg0L3QtSDQvNC+0LbQtSDQtNCwINGB0LUg0YHRgtCw0YDRgtC40YDQsCIKIAotIzogY29ubmVjdC5jOjkyNAorIzogY29ubmVjdC5jOjkyOAogbXNnaWQgIm5vIHBhdGggc3BlY2lmaWVkOyBzZWUgJ2dpdCBoZWxwIHB1bGwnIGZvciB2YWxpZCB1cmwgc3ludGF4IgogbXNnc3RyICIiCiAi0L3QtSDQtSDRg9C60LDQt9Cw0L0g0L/RitGCLiDQn9GA0L7QstC10YDQtdGC0LUg0YHQuNC90YLQsNC60YHQuNGB0LAg0YEg0LrQvtC80LDQvdC00LDRgtCwOlxuIgogIlxuIgogIiAgICBnaXQgaGVscCBwdWxsIgogCi0jOiBjb25uZWN0LmM6MTExOQorIzogY29ubmVjdC5jOjExMjMKIG1zZ2lkICJzc2ggdmFyaWFudCAnc2ltcGxlJyBkb2VzIG5vdCBzdXBwb3J0IC00IgogbXNnc3RyICLQstCw0YDQuNCw0L3RgtGK0YIg0LfQsCDigJ5zc2jigJwg4oCUIOKAnnNpbXBsZeKAnCAo0L7Qv9GA0L7RgdGC0LXQvSksINC90LUg0L/QvtC00LTRitGA0LbQsCDQvtC/0YbQuNGP0YLQsCDigJ4tNOKAnCIKIAotIzogY29ubmVjdC5jOjExMzEKKyM6IGNvbm5lY3QuYzoxMTM1CiBtc2dpZCAic3NoIHZhcmlhbnQgJ3NpbXBsZScgZG9lcyBub3Qgc3VwcG9ydCAtNiIKIG1zZ3N0ciAi0LLQsNGA0LjQsNC90YLRitGCINC30LAg4oCec3No4oCcIOKAlCDigJ5zaW1wbGXigJwgKNC+0L/RgNC+0YHRgtC10L0pLCDQvdC1INC/0L7QtNC00YrRgNC20LAg0L7Qv9GG0LjRj9GC0LAg4oCeLTbigJwiCiAKLSM6IGNvbm5lY3QuYzoxMTQ4CisjOiBjb25uZWN0LmM6MTE1MgogbXNnaWQgInNzaCB2YXJpYW50ICdzaW1wbGUnIGRvZXMgbm90IHN1cHBvcnQgc2V0dGluZyBwb3J0IgogbXNnc3RyICIiCiAi0LLQsNGA0LjQsNC90YLRitGCINC30LAg4oCec3No4oCcIOKAlCDigJ5zaW1wbGXigJwgKNC+0L/RgNC+0YHRgtC10L0pLCDQvdC1INC/0L7QtNC00YrRgNC20LAg0LfQsNC00LDQstCw0L3QtdGC0L4g0L3QsCDQv9C+0YDRgiIKIAotIzogY29ubmVjdC5jOjEyNjAKKyM6IGNvbm5lY3QuYzoxMjY0CiAjLCBjLWZvcm1hdAogbXNnaWQgInN0cmFuZ2UgcGF0aG5hbWUgJyVzJyBibG9ja2VkIgogbXNnc3RyICLQvdC10L7QsdC40YfQsNC50L3QuNGP0YIg0L/RitGCIOKAniVz4oCcINC1INCx0LvQvtC60LjRgNCw0L0iCiAKLSM6IGNvbm5lY3QuYzoxMzA3CisjOiBjb25uZWN0LmM6MTMxMQogbXNnaWQgInVuYWJsZSB0byBmb3JrIgogbXNnc3RyICLQvdC10YPRgdC/0LXRiNC90L4g0YHRitC30LTQsNCy0LDQvdC1INC90LAg0L/RgNC+0YbQtdGBIgogCi0jOiBjb25uZWN0ZWQuYzo4NiBidWlsdGluL2ZzY2suYzoyMjEgYnVpbHRpbi9wcnVuZS5jOjQzCisjOiBjb25uZWN0ZWQuYzo4OCBidWlsdGluL2ZzY2suYzoyMjEgYnVpbHRpbi9wcnVuZS5jOjQzCiBtc2dpZCAiQ2hlY2tpbmcgY29ubmVjdGl2aXR5IgogbXNnc3RyICLQn9GA0L7QstC10YDQutCwINC90LAg0YHQstGK0YDQt9Cw0L3QvtGB0YLRgtCwIgogCi0jOiBjb25uZWN0ZWQuYzo5OAorIzogY29ubmVjdGVkLmM6MTAwCiBtc2dpZCAiQ291bGQgbm90IHJ1biAnZ2l0IHJldi1saXN0JyIKIG1zZ3N0ciAi0JrQvtC80LDQvdC00LDRgtCwIOKAnmdpdCByZXYtbGlzdOKAnCDQvdC1INC80L7QttC1INC00LAg0LHRitC00LUg0LjQt9C/0YrQu9C90LXQvdCwLiIKIAotIzogY29ubmVjdGVkLmM6MTE4CisjOiBjb25uZWN0ZWQuYzoxMjAKIG1zZ2lkICJmYWlsZWQgd3JpdGUgdG8gcmV2LWxpc3QiCiBtc2dzdHIgItC90LXRg9GB0L/QtdGI0LXQvSDQt9Cw0L/QuNGBINC90LAg0YHQv9C40YHRitC60LAg0YEg0LLQtdGA0YHQuNC40YLQtSIKIAotIzogY29ubmVjdGVkLmM6MTI1CisjOiBjb25uZWN0ZWQuYzoxMjcKIG1zZ2lkICJmYWlsZWQgdG8gY2xvc2UgcmV2LWxpc3QncyBzdGRpbiIKIG1zZ3N0ciAi0YHRgtCw0L3QtNCw0YDRgtC90LjRj9GCINCy0YXQvtC0INC90LAg0YHQv9C40YHRitC60LAg0YEg0LLQtdGA0YHQuNC40YLQtSDQvdC1INC80L7QttC1INC00LAg0LHRitC00LUg0LfQsNGC0LLQvtGA0LXQvSIKIAotIzogY29udmVydC5jOjE5MworIzogY29udmVydC5jOjE5NAogIywgYy1mb3JtYXQKIG1zZ2lkICJpbGxlZ2FsIGNybGZfYWN0aW9uICVkIgogbXNnc3RyICLQvdC10L/RgNCw0LLQuNC70L3QviDQtNC10LnRgdGC0LLQuNC1INC30LAg0LrRgNCw0Lkg0L3QsCDRgNC10LQ6ICVkIgogCi0jOiBjb252ZXJ0LmM6MjA2CisjOiBjb252ZXJ0LmM6MjA3CiAjLCBjLWZvcm1hdAogbXNnaWQgIkNSTEYgd291bGQgYmUgcmVwbGFjZWQgYnkgTEYgaW4gJXMiCiBtc2dzdHIgItCS0YHRj9C60LAg0L/QvtGB0LvQtdC00L7QstCw0YLQtdC70L3QvtGB0YIg0L7RgiDQt9C90LDRhtC4IOKAnkNSTEbigJwg0YnQtSDQsdGK0LRlINC30LDQvNC10L3QtdC90LAg0YEg4oCeTEbigJwg0LIg4oCeJXPigJwuIgogCi0jOiBjb252ZXJ0LmM6MjA4CisjOiBjb252ZXJ0LmM6MjA5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJDUkxGIHdpbGwgYmUgcmVwbGFjZWQgYnkgTEYgaW4gJXMuXG4iCkBAIC0yMzU4LDEzICsyMzY3LDEzIEBACiAi0KTQsNC50LvRitGCINGJ0LUg0L7RgdGC0LDQvdC1INGBINC/0YrRgNCy0L7QvdCw0YfQsNC70L3QuNGC0LUg0LfQvdCw0YbQuCDQt9CwINC60YDQsNC5INC90LAg0YDQtdC0INCyINGA0LDQsdC+0YLQvdCw0YLQsCDQstC4ICIKICLQtNC40YDQtdC60YLQvtGA0LjRjy4iCiAKLSM6IGNvbnZlcnQuYzoyMTYKKyM6IGNvbnZlcnQuYzoyMTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiTEYgd291bGQgYmUgcmVwbGFjZWQgYnkgQ1JMRiBpbiAlcyIKIG1zZ3N0ciAiIgogItCS0YHQtdC60Lgg0LfQvdCw0Log4oCeTEbigJwg0YnQtSDQsdGK0LRlINC30LDQvNC10L3QtdC9INGBINC/0L7RgdC70LXQtNC+0LLQsNGC0LXQu9C90L7RgdGC0YLQsCDQvtGCINC30L3QsNGG0Lgg4oCeQ1JMRuKAnCDQsiDigJ4lc+KAnC4iCiAKLSM6IGNvbnZlcnQuYzoyMTgKKyM6IGNvbnZlcnQuYzoyMTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkxGIHdpbGwgYmUgcmVwbGFjZWQgYnkgQ1JMRiBpbiAlcy5cbiIKQEAgLTIzNzUsMTQgKzIzODQsMTQgQEAKICLQpNCw0LnQu9GK0YIg0YnQtSDQvtGB0YLQsNC90LUg0YEg0L/RitGA0LLQvtC90LDRh9Cw0LvQvdC40YLQtSDQt9C90LDRhtC4INC30LAg0LrRgNCw0Lkg0L3QsCDRgNC10LQg0LIg0YDQsNCx0L7RgtC90LDRgtCwINCy0LggIgogItC00LjRgNC10LrRgtC+0YDQuNGPLiIKIAotIzogY29udmVydC5jOjI3OQorIzogY29udmVydC5jOjI4MAogIywgYy1mb3JtYXQKIG1zZ2lkICJCT00gaXMgcHJvaGliaXRlZCBpbiAnJXMnIGlmIGVuY29kZWQgYXMgJXMiCiBtc2dzdHIgIiIKICLigJ4lc+KAnCDQvdC1INGC0YDRj9Cx0LLQsCDQtNCwINGB0YrQtNGK0YDQttCwINC80LDRgNC60LXRgCDQt9CwINC/0L7RgNC10LTQvdC+0YHRgtGC0LAg0L3QsCDQsdCw0LnRgtC+0LLQtdGC0LUgKEJPTSkg0L/RgNC4ICIKICLQutC+0LTQuNGA0LDQvdC1IOKAniVz4oCcIgogCi0jOiBjb252ZXJ0LmM6Mjg2CisjOiBjb252ZXJ0LmM6Mjg3CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgZmlsZSAnJXMnIGNvbnRhaW5zIGEgYnl0ZSBvcmRlciBtYXJrIChCT00pLiBQbGVhc2UgdXNlIFVURi0lcyBhcyB3b3JraW5nLSIKQEAgLTIzOTEsMTQgKzI0MDAsMTQgQEAKICLQpNCw0LnQu9GK0YIg4oCeJXPigJwg0YHRitC00YrRgNC20LAg0LzQsNGA0LrQtdGAINC30LAg0L/QvtGA0LXQtNC90L7RgdGC0YLQsCDQvdCwINCx0LDQudGC0L7QstC10YLQtSAoQk9NKS4gINCY0LfQv9C+0LvQt9Cy0LDQudGC0LUgIgogIuKAnlVURi0lc+KAnCDQutCw0YLQviDQutC+0LTQuNGA0LDQvdC1INC30LAg0YDQsNCx0L7RgtC90L7RgtC+INC00YrRgNCy0L4uIgogCi0jOiBjb252ZXJ0LmM6MzA0CisjOiBjb252ZXJ0LmM6MzA1CiAjLCBjLWZvcm1hdAogbXNnaWQgIkJPTSBpcyByZXF1aXJlZCBpbiAnJXMnIGlmIGVuY29kZWQgYXMgJXMiCiBtc2dzdHIgIiIKICLigJ4lc+KAnCDRgtGA0Y/QsdCy0LAg0LTQsCDRgdGK0LTRitGA0LbQsCDQvNCw0YDQutC10YAg0LfQsCDQv9C+0YDQtdC00L3QvtGB0YLRgtCwINC90LAg0LHQsNC50YLQvtCy0LXRgtC1IChCT00pINC/0YDQuCDQutC+0LTQuNGA0LDQvdC1ICIKICLigJ4lc+KAnCIKIAotIzogY29udmVydC5jOjMwNgorIzogY29udmVydC5jOjMwNwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiVGhlIGZpbGUgJyVzJyBpcyBtaXNzaW5nIGEgYnl0ZSBvcmRlciBtYXJrIChCT00pLiBQbGVhc2UgdXNlIFVURi0lc0JFIG9yIFVURi0iCkBAIC0yNDA4LDUwICsyNDE3LDUwIEBACiAi0L3QsCDRgNCw0LHQvtGC0L3QvtGC0L4g0LTRitGA0LLQviDQuNC30L/QvtC70LfQstCw0LnRgtC1IFVURi0lc0JFINC40LvQuCBVVEYtJXNMRSAo0LIg0LfQsNCy0LjRgdC40LzQvtGB0YIg0L7RgiAiCiAi0L/QvtGA0LXQtNC90L7RgdGC0YLQsCDQvdCwINCx0LDQudGC0L7QstC10YLQtSkuIgogCi0jOiBjb252ZXJ0LmM6NDI0IGNvbnZlcnQuYzo0OTUKKyM6IGNvbnZlcnQuYzo0MjUgY29udmVydC5jOjQ5NgogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gZW5jb2RlICclcycgZnJvbSAlcyB0byAlcyIKIG1zZ3N0ciAi0L3QtdGD0YHQv9C10YjQvdC+INC/0YDQtdC60L7QtNC40YDQsNC90LUg0L3QsCDigJ4lc+KAnCDQvtGCIOKAniVz4oCcINC60YrQvCDigJ4lc+KAnCIKIAotIzogY29udmVydC5jOjQ2NworIzogY29udmVydC5jOjQ2OAogIywgYy1mb3JtYXQKIG1zZ2lkICJlbmNvZGluZyAnJXMnIGZyb20gJXMgdG8gJXMgYW5kIGJhY2sgaXMgbm90IHRoZSBzYW1lIgogbXNnc3RyICLQn9GA0LXQutC+0LTQuNGA0LDQvdC10YLQviDQvdCwIOKAniVz4oCcINC+0YIg4oCeJXPigJwg0LrRitC8IOKAniVz4oCcINC4INC+0LHRgNCw0YLQvdC+INC/0YDQvtC80LXQvdGPINGE0LDQudC70LAiCiAKLSM6IGNvbnZlcnQuYzo2NzMKKyM6IGNvbnZlcnQuYzo2NzQKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IGZvcmsgdG8gcnVuIGV4dGVybmFsIGZpbHRlciAnJXMnIgogbXNnc3RyICLQvdC10YPRgdC/0LXRiNC90L4g0YHRitC30LTQsNCy0LDQvdC1INC90LAg0L/RgNC+0YbQtdGBINC30LAg0LLRitC90YjQtdC9INGE0LjQu9GC0YrRgCDigJ4lc+KAnCIKIAotIzogY29udmVydC5jOjY5MworIzogY29udmVydC5jOjY5NAogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgZmVlZCB0aGUgaW5wdXQgdG8gZXh0ZXJuYWwgZmlsdGVyICclcyciCiBtc2dzdHIgItCy0YXQvtC00YrRgiDQvdC1INC80L7QttC1INC00LAg0LHRitC00LUg0L/QvtC00LDQtNC10L0g0L3QsCDQstGK0L3RiNC90LjRjyDRhNC40LvRgtGK0YAg4oCeJXPigJwiCiAKLSM6IGNvbnZlcnQuYzo3MDAKKyM6IGNvbnZlcnQuYzo3MDEKICMsIGMtZm9ybWF0CiBtc2dpZCAiZXh0ZXJuYWwgZmlsdGVyICclcycgZmFpbGVkICVkIgogbXNnc3RyICLQvdC10YPRgdC/0LXRiNC90L4g0LjQt9C/0YrQu9C90LXQvdC40LUg0L3QsCDQstGK0L3RiNC90LjRjyDRhNC40LvRgtGK0YAg4oCeJXPigJw6ICVkIgogCi0jOiBjb252ZXJ0LmM6NzM1IGNvbnZlcnQuYzo3MzgKKyM6IGNvbnZlcnQuYzo3MzYgY29udmVydC5jOjczOQogIywgYy1mb3JtYXQKIG1zZ2lkICJyZWFkIGZyb20gZXh0ZXJuYWwgZmlsdGVyICclcycgZmFpbGVkIgogbXNnc3RyICLQvdC10YPRgdC/0LXRiNC90L4g0YfQtdGC0LXQvdC1INC+0YIg0LLRitC90YjQvdC40Y8g0YTQuNC70YLRitGAIOKAniVz4oCcIgogCi0jOiBjb252ZXJ0LmM6NzQxIGNvbnZlcnQuYzo3OTYKKyM6IGNvbnZlcnQuYzo3NDIgY29udmVydC5jOjc5NwogIywgYy1mb3JtYXQKIG1zZ2lkICJleHRlcm5hbCBmaWx0ZXIgJyVzJyBmYWlsZWQiCiBtc2dzdHIgItC90LXRg9GB0L/QtdGI0L3QviDQuNC30L/RitC70L3QtdC90LjQtSDQvdCwINCy0YrQvdGI0L3QuNGPINGE0LjQu9GC0YrRgCDigJ4lc+KAnCIKIAotIzogY29udmVydC5jOjg0NAorIzogY29udmVydC5jOjg0NQogbXNnaWQgInVuZXhwZWN0ZWQgZmlsdGVyIHR5cGUiCiBtc2dzdHIgItC90LXQvtGH0LDQutCy0LDQvSDQstC40LQg0YTQuNC70YLRitGAIgogCi0jOiBjb252ZXJ0LmM6ODU1CisjOiBjb252ZXJ0LmM6ODU2CiBtc2dpZCAicGF0aCBuYW1lIHRvbyBsb25nIGZvciBleHRlcm5hbCBmaWx0ZXIiCiBtc2dzdHIgItC/0YrRgtGP0YIg0LUg0L/RgNC10LrQsNC70LXQvdC+INC00YrQu9GK0LMg0LfQsCDQstGK0L3RiNC10L0g0YTQuNC70YLRitGAIgogCi0jOiBjb252ZXJ0LmM6OTI5CisjOiBjb252ZXJ0LmM6OTMwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJleHRlcm5hbCBmaWx0ZXIgJyVzJyBpcyBub3QgYXZhaWxhYmxlIGFueW1vcmUgYWx0aG91Z2ggbm90IGFsbCBwYXRocyBoYXZlICIKQEAgLTI0NjAsNjcgKzI0NjksNjcgQEAKICLQstGK0L3RiNC90LjRj9GCINGE0LjQu9GC0YrRgCDigJ4lc+KAnCDQstC10YfQtSDQvdC1INC1INC90LDQu9C40YfQtdC9LCDQstGK0L/RgNC10LrQuCDRh9C1INC90LUg0LLRgdC40YfQutC4INC/0YrRgtC40YnQsCDRgdCwICIKICLRhNC40LvRgtGA0LjRgNCw0L3QuCIKIAotIzogY29udmVydC5jOjEyMjgKKyM6IGNvbnZlcnQuYzoxMjI5CiBtc2dpZCAidHJ1ZS9mYWxzZSBhcmUgbm8gdmFsaWQgd29ya2luZy10cmVlLWVuY29kaW5ncyIKIG1zZ3N0ciAi4oCedHJ1ZeKAnC/igJ5mYWxzZeKAnCDQvdC1INC80L7QttC1INC00LAg0YHQsCDQutC+0LTQuNGA0LDQvdC40Y8g0L3QsCDRgNCw0LHQvtGC0L3QvtGC0L4g0LTRitGA0LLQviIKIAotIzogY29udmVydC5jOjEzOTggY29udmVydC5jOjE0MzIKKyM6IGNvbnZlcnQuYzoxNDE3IGNvbnZlcnQuYzoxNDUxCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiBjbGVhbiBmaWx0ZXIgJyVzJyBmYWlsZWQiCiBtc2dzdHIgIiVzOiDQvdC10YPRgdC/0LXRiNC90L4g0LjQt9C/0YrQu9C90LXQvdC40LUg0L3QsCDQtNC10LrQvtC00LjRgNCw0Ykg0YTQuNC70YLRitGAIOKAniVz4oCcIgogCi0jOiBjb252ZXJ0LmM6MTQ3NgorIzogY29udmVydC5jOjE0OTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXM6IHNtdWRnZSBmaWx0ZXIgJXMgZmFpbGVkIgogbXNnc3RyICIlczog0L3QtdGD0YHQv9C10YjQvdC+INC40LfQv9GK0LvQvdC10L3QuNC1INC90LAg0LrQvtC00LjRgNCw0Ykg0YTQuNC70YLRitGAIOKAniVz4oCcIgogCi0jOiBkYXRlLmM6MTM3CisjOiBkYXRlLmM6MTM4CiBtc2dpZCAiaW4gdGhlIGZ1dHVyZSIKIG1zZ3N0ciAi0LIg0LHRitC00LXRidC10YLQviIKIAotIzogZGF0ZS5jOjE0MworIzogZGF0ZS5jOjE0NAogIywgYy1mb3JtYXQKIG1zZ2lkICIlPFBSSXVNQVg+IHNlY29uZCBhZ28iCiBtc2dpZF9wbHVyYWwgIiU8UFJJdU1BWD4gc2Vjb25kcyBhZ28iCiBtc2dzdHJbMF0gItC/0YDQtdC00LggJTxQUkl1TUFYPiDRgdC10LrRg9C90LTQsCIKIG1zZ3N0clsxXSAi0L/RgNC10LTQuCAlPFBSSXVNQVg+INGB0LXQutGD0L3QtNC4IgogCi0jOiBkYXRlLmM6MTUwCisjOiBkYXRlLmM6MTUxCiAjLCBjLWZvcm1hdAogbXNnaWQgIiU8UFJJdU1BWD4gbWludXRlIGFnbyIKIG1zZ2lkX3BsdXJhbCAiJTxQUkl1TUFYPiBtaW51dGVzIGFnbyIKIG1zZ3N0clswXSAi0L/RgNC10LTQuCAlPFBSSXVNQVg+INC80LjQvdGD0YLQsCIKIG1zZ3N0clsxXSAi0L/RgNC10LTQuCAlPFBSSXVNQVg+INC80LjQvdGD0YLQuCIKIAotIzogZGF0ZS5jOjE1NworIzogZGF0ZS5jOjE1OAogIywgYy1mb3JtYXQKIG1zZ2lkICIlPFBSSXVNQVg+IGhvdXIgYWdvIgogbXNnaWRfcGx1cmFsICIlPFBSSXVNQVg+IGhvdXJzIGFnbyIKIG1zZ3N0clswXSAi0L/RgNC10LTQuCAlPFBSSXVNQVg+INGH0LDRgSIKIG1zZ3N0clsxXSAi0L/RgNC10LTQuCAlPFBSSXVNQVg+INGH0LDRgdCwIgogCi0jOiBkYXRlLmM6MTY0CisjOiBkYXRlLmM6MTY1CiAjLCBjLWZvcm1hdAogbXNnaWQgIiU8UFJJdU1BWD4gZGF5IGFnbyIKIG1zZ2lkX3BsdXJhbCAiJTxQUkl1TUFYPiBkYXlzIGFnbyIKIG1zZ3N0clswXSAi0L/RgNC10LTQuCAlPFBSSXVNQVg+INC00LXQvSIKIG1zZ3N0clsxXSAi0L/RgNC10LTQuCAlPFBSSXVNQVg+INC00LXQvdCwIgogCi0jOiBkYXRlLmM6MTcwCisjOiBkYXRlLmM6MTcxCiAjLCBjLWZvcm1hdAogbXNnaWQgIiU8UFJJdU1BWD4gd2VlayBhZ28iCiBtc2dpZF9wbHVyYWwgIiU8UFJJdU1BWD4gd2Vla3MgYWdvIgogbXNnc3RyWzBdICLQv9GA0LXQtNC4ICU8UFJJdU1BWD4g0YHQtdC00LzQuNGG0LAiCiBtc2dzdHJbMV0gItC/0YDQtdC00LggJTxQUkl1TUFYPiDRgdC10LTQvNC40YbQuCIKIAotIzogZGF0ZS5jOjE3NworIzogZGF0ZS5jOjE3OAogIywgYy1mb3JtYXQKIG1zZ2lkICIlPFBSSXVNQVg+IG1vbnRoIGFnbyIKIG1zZ2lkX3BsdXJhbCAiJTxQUkl1TUFYPiBtb250aHMgYWdvIgogbXNnc3RyWzBdICLQv9GA0LXQtNC4ICU8UFJJdU1BWD4g0LzQtdGB0LXRhiIKIG1zZ3N0clsxXSAi0L/RgNC10LTQuCAlPFBSSXVNQVg+INC80LXRgdC10YbQsCIKIAotIzogZGF0ZS5jOjE4OAorIzogZGF0ZS5jOjE4OQogIywgYy1mb3JtYXQKIG1zZ2lkICIlPFBSSXVNQVg+IHllYXIiCiBtc2dpZF9wbHVyYWwgIiU8UFJJdU1BWD4geWVhcnMiCkBAIC0yNTI4LDE0ICsyNTM3LDE0IEBACiBtc2dzdHJbMV0gIiU8UFJJdU1BWD4g0LPQvtC00LjQvdC4IgogCiAjLiBUUkFOU0xBVE9SUzogIiVzIiBpcyAiPG4+IHllYXJzIgotIzogZGF0ZS5jOjE5MQorIzogZGF0ZS5jOjE5MgogIywgYy1mb3JtYXQKIG1zZ2lkICIlcywgJTxQUkl1TUFYPiBtb250aCBhZ28iCiBtc2dpZF9wbHVyYWwgIiVzLCAlPFBSSXVNQVg+IG1vbnRocyBhZ28iCiBtc2dzdHJbMF0gItC/0YDQtdC00LggJXMg0LggJTxQUkl1TUFYPiDQvNC10YHQtdGGIgogbXNnc3RyWzFdICLQv9GA0LXQtNC4ICVzINC4ICU8UFJJdU1BWD4g0LzQtdGB0LXRhtCwIgogCi0jOiBkYXRlLmM6MTk2IGRhdGUuYzoyMDEKKyM6IGRhdGUuYzoxOTcgZGF0ZS5jOjIwMgogIywgYy1mb3JtYXQKIG1zZ2lkICIlPFBSSXVNQVg+IHllYXIgYWdvIgogbXNnaWRfcGx1cmFsICIlPFBSSXVNQVg+IHllYXJzIGFnbyIKQEAgLTI1NzMsNyArMjU4Miw3IEBACiBtc2dpZCAiZmFpbGVkIHRvIHJlYWQgb3JkZXJmaWxlICclcyciCiBtc2dzdHIgItGE0LDQudC70YrRgiDRgSDQv9C+0LTRgNC10LTQsdCw0YLQsCDQvdCwINGB0YrQvtGC0LLQtdGC0YHRgtCy0LjRj9GC0LAg4oCeJXPigJwg0L3QtSDQvNC+0LbQtSDQtNCwINCx0YrQtNC1INC/0YDQvtGH0LXRgtC10L0iCiAKLSM6IGRpZmZjb3JlLXJlbmFtZS5jOjU0NAorIzogZGlmZmNvcmUtcmVuYW1lLmM6NTQzCiBtc2dpZCAiUGVyZm9ybWluZyBpbmV4YWN0IHJlbmFtZSBkZXRlY3Rpb24iCiBtc2dzdHIgItCi0YrRgNGB0LXQvdC1INC90LAg0L/RgNC10LjQvNC10L3Rg9Cy0LDQvdC40Y8g0L3QsCDQvtCx0LXQutGC0Lgg0YHRitGH0LXRgtCw0L3QuCDRgSDQv9GA0L7QvNC10L3QuCIKIApAQCAtMjY0NSwzOCArMjY1NCwzOCBAQAogItCT0YDQtdGI0LrQuCDQsiDQvdCw0YHRgtGA0L7QudC60LDRgtCwIOKAnmRpZmYuZGlyc3RhdOKAnDpcbiIKICIlcyIKIAotIzogZGlmZi5jOjQyMTUKKyM6IGRpZmYuYzo0MjE4CiAjLCBjLWZvcm1hdAogbXNnaWQgImV4dGVybmFsIGRpZmYgZGllZCwgc3RvcHBpbmcgYXQgJXMiCiBtc2dzdHIgIiIKICLQstGK0L3RiNC90LDRgtCwINC/0YDQvtCz0YDQsNC80LAg0LfQsCDRgNCw0LfQu9C40LrQuCDQt9Cw0LLRitGA0YjQuCDQvdC10YPRgdC/0LXRiNC90L4uICDQodC/0LjRgNCw0L3QtSDQvdCwINGA0LDQsdC+0YLQsNGC0LAg0L/RgNC4IOKAniVz4oCcIgogCi0jOiBkaWZmLmM6NDU2MAorIzogZGlmZi5jOjQ1NjMKIG1zZ2lkICItLW5hbWUtb25seSwgLS1uYW1lLXN0YXR1cywgLS1jaGVjayBhbmQgLXMgYXJlIG11dHVhbGx5IGV4Y2x1c2l2ZSIKIG1zZ3N0ciAiIgogItCe0L/RhtC40LjRgtC1IOKAni0tbmFtZS1vbmx54oCcLCDigJ4tLW5hbWUtc3RhdHVz4oCcLCDigJ4tLWNoZWNr4oCcINC4IOKAni1z4oCcINGB0LAg0L3QtdGB0YrQstC80LXRgdGC0LjQvNC4ICIKICLQtdC00L3QsCDRgSDQtNGA0YPQs9CwIgogCi0jOiBkaWZmLmM6NDU2MworIzogZGlmZi5jOjQ1NjYKIG1zZ2lkICItRywgLVMgYW5kIC0tZmluZC1vYmplY3QgYXJlIG11dHVhbGx5IGV4Y2x1c2l2ZSIKIG1zZ3N0ciAi0J7Qv9GG0LjQuNGC0LUg4oCeLUfigJwsIOKAni1T4oCcINC4IOKAni0tZmluZC1vYmplY3TigJwg0YHQsCDQvdC10YHRitCy0LzQtdGB0YLQuNC80Lgg0LXQtNC90LAg0YEg0LTRgNGD0LPQsCIKIAotIzogZGlmZi5jOjQ2NDEKKyM6IGRpZmYuYzo0NjQ0CiBtc2dpZCAiLS1mb2xsb3cgcmVxdWlyZXMgZXhhY3RseSBvbmUgcGF0aHNwZWMiCiBtc2dzdHIgItCe0L/RhtC40Y/RgtCwIOKAni0tZm9sbG934oCcINC40LfQuNGB0LrQstCwINGC0L7Rh9C90L4g0LXQtNC40L0g0L/RitGCIgogCi0jOiBkaWZmLmM6NDY4OQorIzogZGlmZi5jOjQ2OTIKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCAtLXN0YXQgdmFsdWU6ICVzIgogbXNnc3RyICLQvdC10L/RgNCw0LLQuNC70L3QsCDRgdGC0L7QudC90L7RgdGCINC30LAg4oCeLS1zdGF04oCcOiAlcyIKIAotIzogZGlmZi5jOjQ2OTQgZGlmZi5jOjQ2OTkgZGlmZi5jOjQ3MDQgZGlmZi5jOjQ3MDkgZGlmZi5jOjUyMjIKKyM6IGRpZmYuYzo0Njk3IGRpZmYuYzo0NzAyIGRpZmYuYzo0NzA3IGRpZmYuYzo0NzEyIGRpZmYuYzo1MjI1CiAjOiBwYXJzZS1vcHRpb25zLmM6MTk5IHBhcnNlLW9wdGlvbnMuYzoyMDMKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgZXhwZWN0cyBhIG51bWVyaWNhbCB2YWx1ZSIKIG1zZ3N0ciAi0L7Qv9GG0LjRj9GC0LAg4oCeJXPigJwg0L7Rh9Cw0LrQstCwINGH0LjRgdC70L4g0LfQsCDQsNGA0LPRg9C80LXQvdGCIgogCi0jOiBkaWZmLmM6NDcyNgorIzogZGlmZi5jOjQ3MjkKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkZhaWxlZCB0byBwYXJzZSAtLWRpcnN0YXQvLVggb3B0aW9uIHBhcmFtZXRlcjpcbiIKQEAgLTI2ODUsNDQgKzI2OTQsNDQgQEAKICLQndC10YDQsNC30L/QvtC30L3QsNGCINC/0LDRgNCw0LzQtdGC0YrRgCDQutGK0Lwg0L7Qv9GG0LjRj9GC0LAg4oCeLS1kaXJzdGF0Ly1Y4oCcOlxuIgogIiVzIgogCi0jOiBkaWZmLmM6NDgxMQorIzogZGlmZi5jOjQ4MTQKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5rbm93biBjaGFuZ2UgY2xhc3MgJyVjJyBpbiAtLWRpZmYtZmlsdGVyPSVzIgogbXNnc3RyICLQvdC10L/QvtC30L3QsNGCINCy0LjQtCDQv9GA0L7QvNGP0L3QsDog4oCeJWPigJwg0LIg4oCeLS1kaWZmLWZpbHRlcj0lc+KAnCIKIAotIzogZGlmZi5jOjQ4MzUKKyM6IGRpZmYuYzo0ODM4CiAjLCBjLWZvcm1hdAogbXNnaWQgInVua25vd24gdmFsdWUgYWZ0ZXIgd3MtZXJyb3ItaGlnaGxpZ2h0PSUuKnMiCiBtc2dzdHIgItC90LXQv9C+0LfQvdCw0YLQsCDRgdGC0L7QudC90L7RgdGCINGB0LvQtdC0IOKAnndzLWVycm9yLWhpZ2hsaWdodD0lLipz4oCcIgogCi0jOiBkaWZmLmM6NDg0OQorIzogZGlmZi5jOjQ4NTIKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHJlc29sdmUgJyVzJyIKIG1zZ3N0ciAi4oCeJXPigJwg0L3QtSDQvNC+0LbQtSDQtNCwINGB0LUg0L7RgtC60YDQuNC1IgogCi0jOiBkaWZmLmM6NDg5OSBkaWZmLmM6NDkwNQorIzogZGlmZi5jOjQ5MDIgZGlmZi5jOjQ5MDgKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgZXhwZWN0cyA8bj4vPG0+IGZvcm0iCiBtc2dzdHIgIiIKICLQvtC/0YbQuNGP0YLQsCDigJ4lc+KAnCDQuNC30LjRgdC60LLQsCDRgdGC0L7QudC90L7RgdGC0Lgg0LfQsCDQnNCY0J3QmNCc0JDQm9CV0J1fJSVf0J/QoNCe0JzQr9Cd0JBf0JfQkF/QmNCX0KLQntCn0J3QmNCaXy8iCiAi0JzQkNCa0KHQmNCc0JDQm9CV0J1fJSVf0J/QoNCe0JzQr9Cd0JBf0JfQkF/Ql9CQ0JzQr9Cd0JAg0L7RgiIKIAotIzogZGlmZi5jOjQ5MTcKKyM6IGRpZmYuYzo0OTIwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIGV4cGVjdHMgYSBjaGFyYWN0ZXIsIGdvdCAnJXMnIgogbXNnc3RyICLQvtC/0YbQuNGP0YLQsCDigJ4lc+KAnCDQuNC30LjRgdC60LLQsCDQt9C90LDQuiwg0LAg0L3QtTog4oCeJXPigJwiCiAKLSM6IGRpZmYuYzo0OTM4CisjOiBkaWZmLmM6NDk0MQogIywgYy1mb3JtYXQKIG1zZ2lkICJiYWQgLS1jb2xvci1tb3ZlZCBhcmd1bWVudDogJXMiCiBtc2dzdHIgItC90LXQv9GA0LDQstC40LvQtdC9INCw0YDQs9GD0LzQtdC90YIg0LfQsCDigJ4tLWNvbG9yLW1vdmVk4oCcOiDigJ4lc+KAnCIKIAotIzogZGlmZi5jOjQ5NTcKKyM6IGRpZmYuYzo0OTYwCiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgbW9kZSAnJXMnIGluIC0tY29sb3ItbW92ZWQtd3MiCiBtc2dzdHIgItC90LXQv9GA0LDQstC40LvQtdC9INGA0LXQttC40Lwg4oCeJXPigJwg0LfQsCDigJ4gLS1jb2xvci1tb3ZlZC13c+KAnCIKIAotIzogZGlmZi5jOjQ5OTcKKyM6IGRpZmYuYzo1MDAwCiBtc2dpZCAiIgogIm9wdGlvbiBkaWZmLWFsZ29yaXRobSBhY2NlcHRzIFwibXllcnNcIiwgXCJtaW5pbWFsXCIsIFwicGF0aWVuY2VcIiBhbmQgIgogIlwiaGlzdG9ncmFtXCIiCkBAIC0yNzMxLDE1MyArMjc0MCwxNTMgQEAKICLQnNCw0LnQtdGA0YEpLCDigJ5taW5pbWFs4oCcICjQvNC40L3QuNC80LjQt9C40YDQsNC90LUg0L3QsCDRgNCw0LfQu9C40LrQuNGC0LUpLCDigJ5wYXRpZW5jZeKAnCAo0L/QsNGB0LjQsNC90YEpINC4ICIKICLigJ5oaXN0b2dyYW3igJwgKNGF0LjRgdGC0L7Qs9GA0LDQvNC10L0pIgogCi0jOiBkaWZmLmM6NTAzMyBkaWZmLmM6NTA1MworIzogZGlmZi5jOjUwMzYgZGlmZi5jOjUwNTYKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBhcmd1bWVudCB0byAlcyIKIG1zZ3N0ciAi0L3QtdC/0YDQsNCy0LjQu9C10L0g0LDRgNCz0YPQvNC10L3RgiDQutGK0Lwg4oCeJXPigJwiCiAKLSM6IGRpZmYuYzo1MTkxCisjOiBkaWZmLmM6NTE5NAogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gcGFyc2UgLS1zdWJtb2R1bGUgb3B0aW9uIHBhcmFtZXRlcjogJyVzJyIKIG1zZ3N0ciAi0L3QtdGA0LDQt9C/0L7Qt9C90LDRgiDQv9Cw0YDQsNC80LXRgtGK0YAg0LrRitC8INC+0L/RhtC40Y/RgtCwIOKAni0tc3VibW9kdWxl4oCcOiDigJ4lc+KAnCIKIAotIzogZGlmZi5jOjUyNDcKKyM6IGRpZmYuYzo1MjUwCiAjLCBjLWZvcm1hdAogbXNnaWQgImJhZCAtLXdvcmQtZGlmZiBhcmd1bWVudDogJXMiCiBtc2dzdHIgItC90LXQv9GA0LDQstC40LvQtdC9INCw0YDQs9GD0LzQtdC90YIg0LrRitC8IOKAni0td29yZC1kaWZm4oCcOiDigJ4lc+KAnCIKIAotIzogZGlmZi5jOjUyNzAKKyM6IGRpZmYuYzo1MjczCiBtc2dpZCAiRGlmZiBvdXRwdXQgZm9ybWF0IG9wdGlvbnMiCiBtc2dzdHIgItCk0L7RgNC80LDRgiDQvdCwINC40LfRhdC+0LTQsCDQt9CwINGA0LDQt9C70LjQutC40YLQtSIKIAotIzogZGlmZi5jOjUyNzIgZGlmZi5jOjUyNzgKKyM6IGRpZmYuYzo1Mjc1IGRpZmYuYzo1MjgxCiBtc2dpZCAiZ2VuZXJhdGUgcGF0Y2giCiBtc2dzdHIgItGB0YrQt9C00LDQstCw0L3QtSDQvdCwINC60YDRitC/0LrQuCIKIAotIzogZGlmZi5jOjUyNzUgYnVpbHRpbi9sb2cuYzoxNzIKKyM6IGRpZmYuYzo1Mjc4IGJ1aWx0aW4vbG9nLmM6MTcyCiBtc2dpZCAic3VwcHJlc3MgZGlmZiBvdXRwdXQiCiBtc2dzdHIgItCx0LXQtyDQuNC30LLQtdC20LTQsNC90LUg0L3QsCDRgNCw0LfQu9C40LrQuNGC0LUiCiAKLSM6IGRpZmYuYzo1MjgwIGRpZmYuYzo1Mzk0IGRpZmYuYzo1NDAxCisjOiBkaWZmLmM6NTI4MyBkaWZmLmM6NTM5NyBkaWZmLmM6NTQwNAogbXNnaWQgIjxuPiIKIG1zZ3N0ciAi0JHQoNCe0JkiCiAKLSM6IGRpZmYuYzo1MjgxIGRpZmYuYzo1Mjg0CisjOiBkaWZmLmM6NTI4NCBkaWZmLmM6NTI4NwogbXNnaWQgImdlbmVyYXRlIGRpZmZzIHdpdGggPG4+IGxpbmVzIGNvbnRleHQiCiBtc2dzdHIgItGE0LDQudC70L7QstC10YLQtSDRgSDRgNCw0LfQu9C40LrQuCDQtNCwINGB0LAg0YEg0LrQvtC90YLQtdC60YHRgiDRgSDRgtCw0LrRitCyINCR0KDQntCZINGA0LXQtNC+0LLQtSIKIAotIzogZGlmZi5jOjUyODYKKyM6IGRpZmYuYzo1Mjg5CiBtc2dpZCAiZ2VuZXJhdGUgdGhlIGRpZmYgaW4gcmF3IGZvcm1hdCIKIG1zZ3N0ciAi0YTQsNC50LvQvtCy0LXRgtC1INGBINGA0LDQt9C70LjQutC4INC00LAg0YHQsCDQsiDRgdGD0YDQvtCyINGE0L7RgNC80LDRgiIKIAotIzogZGlmZi5jOjUyODkKKyM6IGRpZmYuYzo1MjkyCiBtc2dpZCAic3lub255bSBmb3IgJy1wIC0tcmF3JyIKIG1zZ3N0ciAi0L/RgdC10LLQtNC+0L3QuNC8INC90LAg4oCeLXAgLS1zdGF04oCcIgogCi0jOiBkaWZmLmM6NTI5MworIzogZGlmZi5jOjUyOTYKIG1zZ2lkICJzeW5vbnltIGZvciAnLXAgLS1zdGF0JyIKIG1zZ3N0ciAi0L/RgdC10LLQtNC+0L3QuNC8INC90LAg4oCeLXAgLS1zdGF04oCcIgogCi0jOiBkaWZmLmM6NTI5NworIzogZGlmZi5jOjUzMDAKIG1zZ2lkICJtYWNoaW5lIGZyaWVuZGx5IC0tc3RhdCIKIG1zZ3N0ciAi4oCeLS1zdGF04oCcINCy0YrQsiDRhNC+0YDQvNCw0YIg0LfQsCDRh9C10YLQtdC90LUg0L7RgiDQv9GA0L7Qs9GA0LDQvNCwIgogCi0jOiBkaWZmLmM6NTMwMAorIzogZGlmZi5jOjUzMDMKIG1zZ2lkICJvdXRwdXQgb25seSB0aGUgbGFzdCBsaW5lIG9mIC0tc3RhdCIKIG1zZ3N0ciAi0LjQt9Cy0LXQttC00LDQvdC1INGB0LDQvNC+INC90LAg0L/QvtGB0LvQtdC00L3QuNGPINGA0LXQtCDQvdCwIOKAni0tc3RhdOKAnCIKIAotIzogZGlmZi5jOjUzMDIgZGlmZi5jOjUzMTAKKyM6IGRpZmYuYzo1MzA1IGRpZmYuYzo1MzEzCiBtc2dpZCAiPHBhcmFtMSxwYXJhbTI+Li4uIgogbXNnc3RyICLQn9CQ0KDQkNCc0JXQotCq0KBfMSwg0J/QkNCg0JDQnNCV0KLQqtCgXzIsIOKApiIKIAotIzogZGlmZi5jOjUzMDMKKyM6IGRpZmYuYzo1MzA2CiBtc2dpZCAiIgogIm91dHB1dCB0aGUgZGlzdHJpYnV0aW9uIG9mIHJlbGF0aXZlIGFtb3VudCBvZiBjaGFuZ2VzIGZvciBlYWNoIHN1Yi1kaXJlY3RvcnkiCiBtc2dzdHIgItC40LfQstC10LbQtNCw0L3QtSDQvdCwINGA0LDQt9C/0YDQtdC00LXQu9C10L3QuNC10YLQviDQvdCwINC/0YDQvtC80LXQvdC40YLQtSDQt9CwINCy0YHRj9C60LAg0L/QvtC00LTQuNGA0LXQutGC0L7RgNC40Y8iCiAKLSM6IGRpZmYuYzo1MzA3CisjOiBkaWZmLmM6NTMxMAogbXNnaWQgInN5bm9ueW0gZm9yIC0tZGlyc3RhdD1jdW11bGF0aXZlIgogbXNnc3RyICLQv9GB0LXQstC00L7QvdC40Lwg0L3QsCDigJ4tLWRpcnN0YXQ9Y3VtdWxhdGl2ZeKAnCIKIAotIzogZGlmZi5jOjUzMTEKKyM6IGRpZmYuYzo1MzE0CiBtc2dpZCAic3lub255bSBmb3IgLS1kaXJzdGF0PWZpbGVzLHBhcmFtMSxwYXJhbTIuLi4iCiBtc2dzdHIgItC/0YHQtdCy0LTQvtC90LjQvCDQvdCwIOKAni0tZGlyc3RhdD3QpNCQ0JnQm9Ce0JLQlSzQn9CQ0KDQkNCc0JXQotCq0KBfMSzQn9CQ0KDQkNCc0JXQotCq0KBfMizigKbigJwiCiAKLSM6IGRpZmYuYzo1MzE1CisjOiBkaWZmLmM6NTMxOAogbXNnaWQgIndhcm4gaWYgY2hhbmdlcyBpbnRyb2R1Y2UgY29uZmxpY3QgbWFya2VycyBvciB3aGl0ZXNwYWNlIGVycm9ycyIKIG1zZ3N0ciAiIgogItC/0YDQtdC00YPQv9GA0LXQttC00LDQstCw0L3QtSwg0LDQutC+INC/0YDQvtC80LXQvdC40YLQtSDQstC+0LTRj9GCINC00L4g0LzQsNGA0LrQtdGA0Lgg0LfQsCDQutC+0L3RhNC70LjQutGCINC40LvQuCDQs9GA0LXRiNC60Lgg0LIgIgogItC/0YDQsNC30L3QuNGC0LUg0LfQvdCw0YbQuCIKIAotIzogZGlmZi5jOjUzMTgKKyM6IGRpZmYuYzo1MzIxCiBtc2dpZCAiY29uZGVuc2VkIHN1bW1hcnkgc3VjaCBhcyBjcmVhdGlvbnMsIHJlbmFtZXMgYW5kIG1vZGUgY2hhbmdlcyIKIG1zZ3N0ciAiIgogItGB0YrQutGA0LDRgtC10L3QviDRgNC10LfRjtC80LUg0L3QsCDRgdGK0LfQtNCw0LTQtdC90LjRgtC1LCDQv9GA0LXQuNC80LXQvdGD0LLQsNC90LjRgtC1INC4INGE0LDQudC70L7QstC10YLQtSDRgSDQv9GA0L7QvNGP0L3QsCDQvdCwICIKICLRgNC10LbQuNC80LAg0L3QsCDQtNC+0YHRgtGK0L8iCiAKLSM6IGRpZmYuYzo1MzIxCisjOiBkaWZmLmM6NTMyNAogbXNnaWQgInNob3cgb25seSBuYW1lcyBvZiBjaGFuZ2VkIGZpbGVzIgogbXNnc3RyICLQuNC30LLQtdC20LTQsNC90LUg0YHQsNC80L4g0L3QsCDQuNC80LXQvdCw0YLQsCDQvdCwINC/0YDQvtC80LXQvdC10L3QuNGC0LUg0YTQsNC50LvQvtCy0LUiCiAKLSM6IGRpZmYuYzo1MzI0CisjOiBkaWZmLmM6NTMyNwogbXNnaWQgInNob3cgb25seSBuYW1lcyBhbmQgc3RhdHVzIG9mIGNoYW5nZWQgZmlsZXMiCiBtc2dzdHIgItC40LfQstC10LbQtNCw0L3QtSDRgdCw0LzQviDQvdCwINC40LzQtdC90LDRgtCwINC4INGB0YLQsNGC0LjRgdGC0LjQutCw0YLQsCDQt9CwINC/0YDQvtC80LXQvdC10L3QuNGC0LUg0YTQsNC50LvQvtCy0LUiCiAKLSM6IGRpZmYuYzo1MzI2CisjOiBkaWZmLmM6NTMyOQogbXNnaWQgIjx3aWR0aD5bLDxuYW1lLXdpZHRoPlssPGNvdW50Pl1dIgogbXNnc3RyICLQqNCY0KDQntCn0JjQndCQWyzQmNCc0JUt0KjQmNCg0J7Qp9CY0J3QkFss0JHQoNCe0JldXSIKIAotIzogZGlmZi5jOjUzMjcKKyM6IGRpZmYuYzo1MzMwCiBtc2dpZCAiZ2VuZXJhdGUgZGlmZnN0YXQiCiBtc2dzdHIgItC40LfQstC10LbQtNCw0L3QtSDQvdCwINGB0YLQsNGC0LjRgdGC0LjQutCwINC30LAg0L/RgNC+0LzQtdC90LjRgtC1IgogCi0jOiBkaWZmLmM6NTMyOSBkaWZmLmM6NTMzMiBkaWZmLmM6NTMzNQorIzogZGlmZi5jOjUzMzIgZGlmZi5jOjUzMzUgZGlmZi5jOjUzMzgKIG1zZ2lkICI8d2lkdGg+IgogbXNnc3RyICLQqNCY0KDQntCn0JjQndCQIgogCi0jOiBkaWZmLmM6NTMzMAorIzogZGlmZi5jOjUzMzMKIG1zZ2lkICJnZW5lcmF0ZSBkaWZmc3RhdCB3aXRoIGEgZ2l2ZW4gd2lkdGgiCiBtc2dzdHIgItGB0YLQsNGC0LjRgdGC0LjQutCwINGBINGC0LDQutCw0LLQsCDQqNCY0KDQntCn0JjQndCQINC30LAg0L/RgNC+0LzQtdC90LjRgtC1IgogCi0jOiBkaWZmLmM6NTMzMworIzogZGlmZi5jOjUzMzYKIG1zZ2lkICJnZW5lcmF0ZSBkaWZmc3RhdCB3aXRoIGEgZ2l2ZW4gbmFtZSB3aWR0aCIKIG1zZ3N0ciAi0YHRgtCw0YLQuNGB0YLQuNC60LAg0LfQsCDQv9GA0L7QvNC10L3QuNGC0LUg0YEg0YLQsNC60LDQstCwINCo0JjQoNCe0KfQmNCd0JAg0L3QsCDQuNC80LXQvdCw0YLQsCIKIAotIzogZGlmZi5jOjUzMzYKKyM6IGRpZmYuYzo1MzM5CiBtc2dpZCAiZ2VuZXJhdGUgZGlmZnN0YXQgd2l0aCBhIGdpdmVuIGdyYXBoIHdpZHRoIgogbXNnc3RyICLRgdGC0LDRgtC40YHRgtC40LrQsCDQt9CwINC/0YDQvtC80LXQvdC40YLQtSDRgSDRgtCw0LrQsNCy0LAg0KjQmNCg0J7Qp9CY0J3QkCDQvdCwINCz0YDQsMyA0YTQsCIKIAotIzogZGlmZi5jOjUzMzgKKyM6IGRpZmYuYzo1MzQxCiBtc2dpZCAiPGNvdW50PiIKIG1zZ3N0ciAi0JHQoNCe0JkiCiAKLSM6IGRpZmYuYzo1MzM5CisjOiBkaWZmLmM6NTM0MgogbXNnaWQgImdlbmVyYXRlIGRpZmZzdGF0IHdpdGggbGltaXRlZCBsaW5lcyIKIG1zZ3N0ciAi0L7Qs9GA0LDQvdC40YfQsNCy0LDQvdC1INC90LAg0JHQoNCe0Y8g0L3QsCDRgNC10LTQvtCy0LXRgtC1INCyINGB0YLQsNGC0LjRgdGC0LjQutCw0YLQsCDQt9CwINC/0YDQvtC80LXQvdC40YLQtSIKIAotIzogZGlmZi5jOjUzNDIKKyM6IGRpZmYuYzo1MzQ1CiBtc2dpZCAiZ2VuZXJhdGUgY29tcGFjdCBzdW1tYXJ5IGluIGRpZmZzdGF0IgogbXNnc3RyICLQutGA0LDRgtC60L4g0YDQtdC30Y7QvNC1INCyINGB0YLQsNGC0LjRgdGC0LjQutCw0YLQsCDQt9CwINC/0YDQvtC80LXQvdC40YLQtSIKIAotIzogZGlmZi5jOjUzNDUKKyM6IGRpZmYuYzo1MzQ4CiBtc2dpZCAib3V0cHV0IGEgYmluYXJ5IGRpZmYgdGhhdCBjYW4gYmUgYXBwbGllZCIKIG1zZ3N0ciAi0LjQt9Cy0LXQttC00LDQvdC1INC90LAg0LTQstC+0LjRh9C90LAg0YDQsNC30LvQuNC60LAg0LLRitCyINCy0LjQtCDQt9CwINC/0YDQuNC70LDQs9Cw0L3QtSIKIAotIzogZGlmZi5jOjUzNDgKKyM6IGRpZmYuYzo1MzUxCiBtc2dpZCAic2hvdyBmdWxsIHByZS0gYW5kIHBvc3QtaW1hZ2Ugb2JqZWN0IG5hbWVzIG9uIHRoZSBcImluZGV4XCIgbGluZXMiCiBtc2dzdHIgIiIKICLQv9C+0LrQsNC30LLQsNC90LUg0L3QsCDQv9GK0LvQvdC40YLQtSDQuNC80LXQvdCwINC90LAg0L7QsdC10LrRgtC4INCyINGA0LXQtNC+0LLQtdGC0LUg0LfQsCDQuNC90LTQtdC60YHQsCDQv9GA0Lgg0LLQsNGA0LjQsNC90YLQuNGC0LUgIgogItC/0YDQtdC00Lgg0Lgg0YHQu9C10LQg0L/RgNC+0LzRj9C90LDRgtCwIgogCi0jOiBkaWZmLmM6NTM1MAorIzogZGlmZi5jOjUzNTMKIG1zZ2lkICJzaG93IGNvbG9yZWQgZGlmZiIKIG1zZ3N0ciAi0YDQsNC30LvQuNC60Lgg0LIg0YbQstGP0YIiCiAKLSM6IGRpZmYuYzo1MzUxCisjOiBkaWZmLmM6NTM1NAogbXNnaWQgIjxraW5kPiIKIG1zZ3N0ciAi0JLQmNCUIgogCi0jOiBkaWZmLmM6NTM1MgorIzogZGlmZi5jOjUzNTUKIG1zZ2lkICIiCiAiaGlnaGxpZ2h0IHdoaXRlc3BhY2UgZXJyb3JzIGluIHRoZSAnY29udGV4dCcsICdvbGQnIG9yICduZXcnIGxpbmVzIGluIHRoZSAiCiAiZGlmZiIKQEAgLTI4ODUsNyArMjg5NCw3IEBACiAi0LPRgNC10YjQutC40YLQtSDQsiDQv9GA0LDQt9C90LjRgtC1INC30L3QsNGG0Lgg0LTQsCDRgdC1INGD0LrQsNC30LLQsNGCINCyINGA0LXQtNC+0LLQtdGC0LUg0LfQsCDQutC+0L3RgtC10LrRgdGC0LAsINCy0LDRgNC40LDQvdGC0LjRgtC1ICIKICLQv9GA0LXQtNC4INC4INGB0LvQtdC0INGA0LDQt9C70LjQutCw0YLQsCwiCiAKLSM6IGRpZmYuYzo1MzU1CisjOiBkaWZmLmM6NTM1OAogbXNnaWQgIiIKICJkbyBub3QgbXVuZ2UgcGF0aG5hbWVzIGFuZCB1c2UgTlVMcyBhcyBvdXRwdXQgZmllbGQgdGVybWluYXRvcnMgaW4gLS1yYXcgb3IgIgogIi0tbnVtc3RhdCIKQEAgLTI4OTMsMjU3ICsyOTAyLDI1NyBAQAogItCx0LXQtyDQv9GA0LXQuNC80LXQvdGD0LLQsNC90LUg0L3QsCDQv9GK0YLQuNGJ0LDRgtCwLiAg0JTQsCDRgdC1INC40LfQv9C+0LvQt9Cy0LDRgiDQvdGD0LvQtdCy0Lgg0LHQsNC50YLQvtCy0LUg0LfQsCDRgNCw0LfQtNC10LvQuNGC0LXQu9C4ICIKICLQvdCwINC/0L7Qu9C10YLQsCDQsiDQuNC30YXQvtC00LAg0L/RgNC4INC/0L7Qu9C30LLQsNC90LUg0L3QsCDQvtC/0YbQuNGP0YLQsCDigJ4tLXJhd+KAnCDQuNC70Lgg4oCeLS1udW1zdGF04oCcIgogCi0jOiBkaWZmLmM6NTM1OCBkaWZmLmM6NTM2MSBkaWZmLmM6NTM2NCBkaWZmLmM6NTQ3MAorIzogZGlmZi5jOjUzNjEgZGlmZi5jOjUzNjQgZGlmZi5jOjUzNjcgZGlmZi5jOjU0NzMKIG1zZ2lkICI8cHJlZml4PiIKIG1zZ3N0ciAi0J/QoNCV0KTQmNCa0KEiCiAKLSM6IGRpZmYuYzo1MzU5CisjOiBkaWZmLmM6NTM2MgogbXNnaWQgInNob3cgdGhlIGdpdmVuIHNvdXJjZSBwcmVmaXggaW5zdGVhZCBvZiBcImEvXCIiCiBtc2dzdHIgItC/0YDQtdGE0LjQutGBINCy0LzQtdGB0YLQviDigJ5hL+KAnCDQt9CwINC40LfRgtC+0YfQvdC40LoiCiAKLSM6IGRpZmYuYzo1MzYyCisjOiBkaWZmLmM6NTM2NQogbXNnaWQgInNob3cgdGhlIGdpdmVuIGRlc3RpbmF0aW9uIHByZWZpeCBpbnN0ZWFkIG9mIFwiYi9cIiIKIG1zZ3N0ciAi0L/RgNC10YTQuNC60YEg0LLQvNC10YHRgtC+IOKAnmIv4oCcINC30LAg0YbQtdC7IgogCi0jOiBkaWZmLmM6NTM2NQorIzogZGlmZi5jOjUzNjgKIG1zZ2lkICJwcmVwZW5kIGFuIGFkZGl0aW9uYWwgcHJlZml4IHRvIGV2ZXJ5IGxpbmUgb2Ygb3V0cHV0IgogbXNnc3RyICLQtNC+0LHQsNCy0Y/QvdC1INC90LAg0LTQvtC/0YrQu9C90LjRgtC10LvQtdC9INC/0YDQtdGE0LjQutGBINC30LAg0LLRgdC10LrQuCDRgNC10LQg0L3QsCDQuNC30YXQvtC00LAiCiAKLSM6IGRpZmYuYzo1MzY4CisjOiBkaWZmLmM6NTM3MQogbXNnaWQgImRvIG5vdCBzaG93IGFueSBzb3VyY2Ugb3IgZGVzdGluYXRpb24gcHJlZml4IgogbXNnc3RyICLQsdC10Lcg0L/RgNC10YTQuNC60YEg0LfQsCDQuNC30YLQvtGH0L3QuNC60LAg0Lgg0YbQtdC70YLQsCIKIAotIzogZGlmZi5jOjUzNzEKKyM6IGRpZmYuYzo1Mzc0CiBtc2dpZCAic2hvdyBjb250ZXh0IGJldHdlZW4gZGlmZiBodW5rcyB1cCB0byB0aGUgc3BlY2lmaWVkIG51bWJlciBvZiBsaW5lcyIKIG1zZ3N0ciAiIgogItC40LfQstC10LbQtNCw0L3QtSDQvdCwINC60L7QvdGC0LXQutGB0YIg0LzQtdC20LTRgyDQv9C+0YHQu9C10LTQvtCy0LDRgtC10LvQvdC40YLQtSDQv9Cw0YDRh9C10YLQsCDRgSDRgNCw0LfQu9C40LrQuCDQvtGCINGD0LrQsNC30LDQvdC40Y8gIgogItCR0KDQntCZINGA0LXQtNC+0LLQtSIKIAotIzogZGlmZi5jOjUzNzUgZGlmZi5jOjUzODAgZGlmZi5jOjUzODUKKyM6IGRpZmYuYzo1Mzc4IGRpZmYuYzo1MzgzIGRpZmYuYzo1Mzg4CiBtc2dpZCAiPGNoYXI+IgogbXNnc3RyICLQl9Cd0JDQmiIKIAotIzogZGlmZi5jOjUzNzYKKyM6IGRpZmYuYzo1Mzc5CiBtc2dpZCAic3BlY2lmeSB0aGUgY2hhcmFjdGVyIHRvIGluZGljYXRlIGEgbmV3IGxpbmUgaW5zdGVhZCBvZiAnKyciCiBtc2dzdHIgItC30L3QsNC6INCy0LzQtdGB0YLQviDigJ4r4oCcINC30LAg0L3QvtCyINCy0LDRgNC40LDQvdGCINC90LAg0YDQtdC0IgogCi0jOiBkaWZmLmM6NTM4MQorIzogZGlmZi5jOjUzODQKIG1zZ2lkICJzcGVjaWZ5IHRoZSBjaGFyYWN0ZXIgdG8gaW5kaWNhdGUgYW4gb2xkIGxpbmUgaW5zdGVhZCBvZiAnLSciCiBtc2dzdHIgItC30L3QsNC6INCy0LzQtdGB0YLQviDigJ4t4oCcINC30LAg0YHRgtCw0YAg0LLQsNGA0LjQsNC90YIg0L3QsCDRgNC10LQiCiAKLSM6IGRpZmYuYzo1Mzg2CisjOiBkaWZmLmM6NTM4OQogbXNnaWQgInNwZWNpZnkgdGhlIGNoYXJhY3RlciB0byBpbmRpY2F0ZSBhIGNvbnRleHQgaW5zdGVhZCBvZiAnICciCiBtc2dzdHIgItC30L3QsNC6INCy0LzQtdGB0YLQviDigJ4g4oCcINC30LAg0LrQvtC90YLQtdC60YHRgiIKIAotIzogZGlmZi5jOjUzODkKKyM6IGRpZmYuYzo1MzkyCiBtc2dpZCAiRGlmZiByZW5hbWUgb3B0aW9ucyIKIG1zZ3N0ciAi0J3QsNGB0YLRgNC+0LnQutC4INC30LAg0YDQsNC30LvQuNC60Lgg0YEg0L/RgNC10LjQvNC10L3Rg9Cy0LDQvdC1IgogCi0jOiBkaWZmLmM6NTM5MAorIzogZGlmZi5jOjUzOTMKIG1zZ2lkICI8bj5bLzxtPl0iCiBtc2dzdHIgItCc0JjQndCY0JzQkNCb0JXQnV8lX9Cf0KDQntCc0K/QndCQX9CX0JBf0JjQl9Ci0J7Qp9Cd0JjQmlsv0JzQkNCa0KHQmNCc0JDQm0XQnV8lX9Cf0KDQntCc0K/QndCQX9CX0JBf0JfQkNCc0K/QndCQXSIKIAotIzogZGlmZi5jOjUzOTEKKyM6IGRpZmYuYzo1Mzk0CiBtc2dpZCAiYnJlYWsgY29tcGxldGUgcmV3cml0ZSBjaGFuZ2VzIGludG8gcGFpcnMgb2YgZGVsZXRlIGFuZCBjcmVhdGUiCiBtc2dzdHIgIiIKICLQt9Cw0LzQtdGB0YLQstCw0L3QtSDQvdCwINC/0YrQu9C90LjRgtC1INC/0YDQvtC80LXQvdC4INGBINC/0L7RgdC70LXQtNC+0LLQsNGC0LXQu9C90L7RgdGCINC+0YIg0LjQt9GC0YDQuNCy0LDQvdC1INC4INGB0YrQt9C00LDQstCw0L3QtSIKIAotIzogZGlmZi5jOjUzOTUKKyM6IGRpZmYuYzo1Mzk4CiBtc2dpZCAiZGV0ZWN0IHJlbmFtZXMiCiBtc2dzdHIgItC30LDRgdC40YfQsNC90LUg0L3QsCDQv9GA0LXQuNC80LXQvdGD0LLQsNC90LjRj9GC0LAiCiAKLSM6IGRpZmYuYzo1Mzk5CisjOiBkaWZmLmM6NTQwMgogbXNnaWQgIm9taXQgdGhlIHByZWltYWdlIGZvciBkZWxldGVzIgogbXNnc3RyICLQsdC10Lcg0L/RgNC10LTQstCw0YDQuNGC0LXQu9C10L0g0LLQsNGA0LjQsNC90YIg0L/RgNC4INC40LfRgtGA0LjQstCw0L3QtSIKIAotIzogZGlmZi5jOjU0MDIKKyM6IGRpZmYuYzo1NDA1CiBtc2dpZCAiZGV0ZWN0IGNvcGllcyIKIG1zZ3N0ciAi0LfQsNGB0LjRh9Cw0L3QtSDQvdCwINC60L7Qv9C40YDQsNC90LjRj9GC0LAiCiAKLSM6IGRpZmYuYzo1NDA2CisjOiBkaWZmLmM6NTQwOQogbXNnaWQgInVzZSB1bm1vZGlmaWVkIGZpbGVzIGFzIHNvdXJjZSB0byBmaW5kIGNvcGllcyIKIG1zZ3N0ciAi0YLRitGA0YHQtdC90LUg0L3QsCDQutC+0L/QuNGA0LDQvdC+INC4INC+0YIg0L3QtdC/0YDQvtC80LXQvdC10L3QuNGC0LUg0YTQsNC50LvQvtCy0LUiCiAKLSM6IGRpZmYuYzo1NDA4CisjOiBkaWZmLmM6NTQxMQogbXNnaWQgImRpc2FibGUgcmVuYW1lIGRldGVjdGlvbiIKIG1zZ3N0ciAi0LHQtdC3INGC0YrRgNGB0LXQvdC1INC90LAg0L/RgNC10LjQvNC10L3Rg9Cy0LDQvdC40Y8iCiAKLSM6IGRpZmYuYzo1NDExCisjOiBkaWZmLmM6NTQxNAogbXNnaWQgInVzZSBlbXB0eSBibG9icyBhcyByZW5hbWUgc291cmNlIgogbXNnc3RyICLQv9GA0LDQt9C90Lgg0L7QsdC10LrRgtC4INC60LDRgtC+INC40LfRgtC+0YfQvdC40Log0L/RgNC4INC/0YDQtdC40LzQtdC90YPQstCw0L3QuNGPIgogCi0jOiBkaWZmLmM6NTQxMworIzogZGlmZi5jOjU0MTYKIG1zZ2lkICJjb250aW51ZSBsaXN0aW5nIHRoZSBoaXN0b3J5IG9mIGEgZmlsZSBiZXlvbmQgcmVuYW1lcyIKIG1zZ3N0ciAiIgogItC/0YDQvtC00YrQu9C20LDQstCw0L3QtSDQvdCwINC40LfQstC10LbQtNCw0L3QtdGC0L4g0L3QsCDQuNGB0YLQvtGA0LjRj9GC0LAg4oCUINCx0LXQtyDQvtGC0YDRj9C30LLQsNC90LXRgtC+INC/0YDQuCDQv9GA0LXQuNC80LXQvdGD0LLQsNC90LjRjyAiCiAi0L3QsCDRhNCw0LnQuyIKIAotIzogZGlmZi5jOjU0MTYKKyM6IGRpZmYuYzo1NDE5CiBtc2dpZCAiIgogInByZXZlbnQgcmVuYW1lL2NvcHkgZGV0ZWN0aW9uIGlmIHRoZSBudW1iZXIgb2YgcmVuYW1lL2NvcHkgdGFyZ2V0cyBleGNlZWRzICIKICJnaXZlbiBsaW1pdCIKIG1zZ3N0ciAiIgogItCx0LXQtyDQt9Cw0YHQuNGH0LDQvdC1INC90LAg0L/RgNC10LjQvNC10L3Rg9Cy0LDQvdC40Y8v0LrQvtC/0LjRgNCw0L3QuNGPLCDQsNC60L4g0LHRgNC+0Y/RgiDQuNC8INC90LDQtNCy0LjRiNCw0LLQsCDRgtCw0LfQuCDRgdGC0L7QudC90L7RgdGCIgogCi0jOiBkaWZmLmM6NTQxOAorIzogZGlmZi5jOjU0MjEKIG1zZ2lkICJEaWZmIGFsZ29yaXRobSBvcHRpb25zIgogbXNnc3RyICLQntC/0YbQuNC4INC60YrQvCDQsNC70LPQvtGA0LjRgtGK0LzQsCDQt9CwINGA0LDQt9C70LjQutC4IgogCi0jOiBkaWZmLmM6NTQyMAorIzogZGlmZi5jOjU0MjMKIG1zZ2lkICJwcm9kdWNlIHRoZSBzbWFsbGVzdCBwb3NzaWJsZSBkaWZmIgogbXNnc3RyICLRgtGK0YDRgdC10L3QtSDQvdCwINCy0YrQt9C80L7QttC90L4g0L3QsNC5LdC80LDQu9C60LAg0YDQsNC30LvQuNC60LAiCiAKLSM6IGRpZmYuYzo1NDIzCisjOiBkaWZmLmM6NTQyNgogbXNnaWQgImlnbm9yZSB3aGl0ZXNwYWNlIHdoZW4gY29tcGFyaW5nIGxpbmVzIgogbXNnc3RyICLQsdC10Lcg0L/RgNC+0LzQtdC90Lgg0LIg0L/RgNCw0LfQvdC40YLQtSDQt9C90LDRhtC4INC/0YDQuCDRgdGA0LDQstC90Y/QstCw0L3QtSDQvdCwINGA0LXQtNC+0LLQtSIKIAotIzogZGlmZi5jOjU0MjYKKyM6IGRpZmYuYzo1NDI5CiBtc2dpZCAiaWdub3JlIGNoYW5nZXMgaW4gYW1vdW50IG9mIHdoaXRlc3BhY2UiCiBtc2dzdHIgItCx0LXQtyDQv9GA0L7QvNC10L3QuCDQsiDQv9GA0LDQt9C90LjRgtC1INC30L3QsNGG0LgiCiAKLSM6IGRpZmYuYzo1NDI5CisjOiBkaWZmLmM6NTQzMgogbXNnaWQgImlnbm9yZSBjaGFuZ2VzIGluIHdoaXRlc3BhY2UgYXQgRU9MIgogbXNnc3RyICLQsdC10Lcg0L/RgNC+0LzQtdC90Lgg0LIg0L/RgNCw0LfQvdC40YLQtSDQt9C90LDRhtC4INCyINC60YDQsNGPINC90LAg0YDQtdC00L7QstC10YLQtSIKIAotIzogZGlmZi5jOjU0MzIKKyM6IGRpZmYuYzo1NDM1CiBtc2dpZCAiaWdub3JlIGNhcnJpZXItcmV0dXJuIGF0IHRoZSBlbmQgb2YgbGluZSIKIG1zZ3N0ciAi0LHQtdC3INC/0YDQvtC80LXQvdC4INCyINC30L3QsNGG0LjRgtC1INC30LAg0LrRgNCw0Lkg0L3QsCDRgNC10LQiCiAKLSM6IGRpZmYuYzo1NDM1CisjOiBkaWZmLmM6NTQzOAogbXNnaWQgImlnbm9yZSBjaGFuZ2VzIHdob3NlIGxpbmVzIGFyZSBhbGwgYmxhbmsiCiBtc2dzdHIgItCx0LXQtyDQv9GA0L7QvNC10L3QuCDQsiDRgNC10LTQvtCy0LXRgtC1LCDQutC+0LjRgtC+INGB0LAg0LjQt9GG0Y/Qu9C+INC+0YIg0L/RgNCw0LfQvdC4INC30L3QsNGG0LgiCiAKLSM6IGRpZmYuYzo1NDM4CisjOiBkaWZmLmM6NTQ0MQogbXNnaWQgImhldXJpc3RpYyB0byBzaGlmdCBkaWZmIGh1bmsgYm91bmRhcmllcyBmb3IgZWFzeSByZWFkaW5nIgogbXNnc3RyICIiCiAi0LXQstGA0LjRgdGC0LjQutCwINC30LAg0L/RgNC10LzQtdGB0YLQstCw0L3QtSDQvdCwINCz0YDQsNC90LjRhtC40YLQtSDQvdCwINC/0LDRgNGH0LXRgtCw0YLQsCDQt9CwINGD0LvQtdGB0L3Rj9Cy0LDQvdC1INC90LAg0YfQtdGC0LXQvdC10YLQviIKIAotIzogZGlmZi5jOjU0NDEKKyM6IGRpZmYuYzo1NDQ0CiBtc2dpZCAiZ2VuZXJhdGUgZGlmZiB1c2luZyB0aGUgXCJwYXRpZW5jZSBkaWZmXCIgYWxnb3JpdGhtIgogbXNnc3RyICLRgNCw0LfQu9C40LrQsCDRh9GA0LXQtyDQsNC70LPQvtGA0LjRgtGK0Lwg0LfQsCDQv9C+0LTRgNC10LTQsdCwINC60LDRgtC+INC/0LDRgdC40LDQvdGBIgogCi0jOiBkaWZmLmM6NTQ0NQorIzogZGlmZi5jOjU0NDgKIG1zZ2lkICJnZW5lcmF0ZSBkaWZmIHVzaW5nIHRoZSBcImhpc3RvZ3JhbSBkaWZmXCIgYWxnb3JpdGhtIgogbXNnc3RyICLRgNCw0LfQu9C40LrQsCDQv9C+INGF0LjRgdGC0L7Qs9GA0LDQvNC90LjRjyDQsNC70LPQvtGA0LjRgtGK0LwiCiAKLSM6IGRpZmYuYzo1NDQ3CisjOiBkaWZmLmM6NTQ1MAogbXNnaWQgIjxhbGdvcml0aG0+IgogbXNnc3RyICLQkNCb0JPQntCg0JjQotCq0JwiCiAKLSM6IGRpZmYuYzo1NDQ4CisjOiBkaWZmLmM6NTQ1MQogbXNnaWQgImNob29zZSBhIGRpZmYgYWxnb3JpdGhtIgogbXNnc3RyICLQuNC30LHQvtGAINC90LAg0JDQm9CT0J7QoNCY0KLQqtCc0LAg0LfQsCDRgNCw0LfQu9C40LrQuCIKIAotIzogZGlmZi5jOjU0NTAKKyM6IGRpZmYuYzo1NDUzCiBtc2dpZCAiPHRleHQ+IgogbXNnc3RyICLQotCV0JrQodCiIgogCi0jOiBkaWZmLmM6NTQ1MQorIzogZGlmZi5jOjU0NTQKIG1zZ2lkICJnZW5lcmF0ZSBkaWZmIHVzaW5nIHRoZSBcImFuY2hvcmVkIGRpZmZcIiBhbGdvcml0aG0iCiBtc2dzdHIgItGA0LDQt9C70LjQutCwINGH0YDQtdC3INCw0LvQs9C+0YDQuNGC0YrQvNCwINGB0YrRgSDQt9Cw0LrQvtGC0LLRj9C90LUiCiAKLSM6IGRpZmYuYzo1NDUzIGRpZmYuYzo1NDYyIGRpZmYuYzo1NDY1CisjOiBkaWZmLmM6NTQ1NiBkaWZmLmM6NTQ2NSBkaWZmLmM6NTQ2OAogbXNnaWQgIjxtb2RlPiIKIG1zZ3N0ciAi0KDQldCW0JjQnCIKIAotIzogZGlmZi5jOjU0NTQKKyM6IGRpZmYuYzo1NDU3CiBtc2dpZCAic2hvdyB3b3JkIGRpZmYsIHVzaW5nIDxtb2RlPiB0byBkZWxpbWl0IGNoYW5nZWQgd29yZHMiCiBtc2dzdHIgIiIKICLRgNCw0LfQu9C40LrQsCDQv9C+INC00YPQvNC4LCDQutCw0YLQviDRgdC1INC/0L7Qu9C30LLQsCDRgtC+0LfQuCDQoNCV0JbQmNCcINC30LAg0L7RgtC00LXQu9GP0L3QtdGC0L4g0L3QsCDQv9GA0L7QvNC10L3QtdC90LjRgtC1INC00YPQvNC4IgogCi0jOiBkaWZmLmM6NTQ1NiBkaWZmLmM6NTQ1OSBkaWZmLmM6NTUwNAorIzogZGlmZi5jOjU0NTkgZGlmZi5jOjU0NjIgZGlmZi5jOjU1MDcKIG1zZ2lkICI8cmVnZXg+IgogbXNnc3RyICLQoNCV0JPQo9Cb0K/QoNCV0J1f0JjQl9Cg0JDQlyIKIAotIzogZGlmZi5jOjU0NTcKKyM6IGRpZmYuYzo1NDYwCiBtc2dpZCAidXNlIDxyZWdleD4gdG8gZGVjaWRlIHdoYXQgYSB3b3JkIGlzIgogbXNnc3RyICLQoNCV0JPQo9Cb0K/QoNCV0J1f0JjQl9Cg0JDQlyDQt9CwINGA0LDQt9C00LXQu9GP0L3QtSDQv9C+INC00YPQvNC4IgogCi0jOiBkaWZmLmM6NTQ2MAorIzogZGlmZi5jOjU0NjMKIG1zZ2lkICJlcXVpdmFsZW50IHRvIC0td29yZC1kaWZmPWNvbG9yIC0td29yZC1kaWZmLXJlZ2V4PTxyZWdleD4iCiBtc2dzdHIgItC/0YHQtdCy0LTQvtC90LjQvCDQvdCwIOKAni0td29yZC1kaWZmPWNvbG9yIC0td29yZC1kaWZmLXJlZ2V4PdCg0JXQk9Cj0JvQr9Cg0JXQnV/QmNCX0KDQkNCX4oCcIgogCi0jOiBkaWZmLmM6NTQ2MworIzogZGlmZi5jOjU0NjYKIG1zZ2lkICJtb3ZlZCBsaW5lcyBvZiBjb2RlIGFyZSBjb2xvcmVkIGRpZmZlcmVudGx5IgogbXNnc3RyICLRgNCw0LfQu9C40YfQtdC9INGG0LLRj9GCINC30LAg0LjQt9Cy0LXQttC00LDQvdC1INC90LAg0L/RgNC10LzQtdGB0YLQtdC90LjRgtC1INGA0LXQtNC+0LLQtSIKIAotIzogZGlmZi5jOjU0NjYKKyM6IGRpZmYuYzo1NDY5CiBtc2dpZCAiaG93IHdoaXRlIHNwYWNlcyBhcmUgaWdub3JlZCBpbiAtLWNvbG9yLW1vdmVkIgogbXNnc3RyICIiCiAi0YDQtdC20LjQvCDQt9CwINC/0YDQtdGB0LrQsNGH0LDQvdC10YLQviDQvdCwINC/0YDQsNC30L3QuNGC0LUg0LfQvdCw0YbQuCDQv9GA0Lgg0LfQsNC00LDQstCw0L3QtdGC0L4g0L3QsCDigJ4tLWNvbG9yLW1vdmVk4oCcIgogCi0jOiBkaWZmLmM6NTQ2OQorIzogZGlmZi5jOjU0NzIKIG1zZ2lkICJPdGhlciBkaWZmIG9wdGlvbnMiCiBtc2dzdHIgItCU0YDRg9Cz0Lgg0L7Qv9GG0LjQuCDQt9CwINGA0LDQt9C70LjQutC4IgogCi0jOiBkaWZmLmM6NTQ3MQorIzogZGlmZi5jOjU0NzQKIG1zZ2lkICJ3aGVuIHJ1biBmcm9tIHN1YmRpciwgZXhjbHVkZSBjaGFuZ2VzIG91dHNpZGUgYW5kIHNob3cgcmVsYXRpdmUgcGF0aHMiCiBtc2dzdHIgIiIKICLQv9GA0Lgg0LjQt9C/0YrQu9C90LXQvdC40LUg0L7RgiDQv9C+0LTQtNC40YDQtdC60YLQvtGA0LjRjyDQtNCwINGB0LUg0L/RgNC10L3QtdCx0YDQtdCz0LLQsNGCINGA0LDQt9C70LjQutC40YLQtSDQuNC30LLRitC9INC90LXRjyDQuCDQtNCwICIKICLRgdC1INC/0L7Qu9C30LLQsNGCINC+0YLQvdC+0YHQuNGC0LXQu9C90Lgg0L/RitGC0LjRidCwIgogCi0jOiBkaWZmLmM6NTQ3NQorIzogZGlmZi5jOjU0NzgKIG1zZ2lkICJ0cmVhdCBhbGwgZmlsZXMgYXMgdGV4dCIKIG1zZ3N0ciAi0L7QsdGA0LDQsdC+0YLQutCwINC90LAg0LLRgdC40YfQutC4INGE0LDQudC70L7QstC1INC60LDRgtC+INGC0LXQutGB0YLQvtCy0LgiCiAKLSM6IGRpZmYuYzo1NDc3CisjOiBkaWZmLmM6NTQ4MAogbXNnaWQgInN3YXAgdHdvIGlucHV0cywgcmV2ZXJzZSB0aGUgZGlmZiIKIG1zZ3N0ciAi0YDQsNC30LzRj9C90LAg0L3QsCDQtNCy0LDRgtCwINCy0YXQvtC00LAg4oCUINC+0LHRgNGK0YnQsNC90LUg0L3QsCDRgNCw0LfQu9C40LrQsNGC0LAiCiAKLSM6IGRpZmYuYzo1NDc5CisjOiBkaWZmLmM6NTQ4MgogbXNnaWQgImV4aXQgd2l0aCAxIGlmIHRoZXJlIHdlcmUgZGlmZmVyZW5jZXMsIDAgb3RoZXJ3aXNlIgogbXNnc3RyICIiCiAi0LfQsNCy0YrRgNGI0LLQsNC90LUg0YEg0LrQvtC0INC30LAg0YHRitGB0YLQvtGP0L3QuNC1IDEg0L/RgNC4INC90LDQu9C40YfQuNC10YLQviDQvdCwINGA0LDQt9C70LjQutC4LCDQsCDQsiDQv9GA0L7RgtC40LLQtdC9ICIKICLRgdC70YPRh9Cw0Lkg4oCUINGBIDAiCiAKLSM6IGRpZmYuYzo1NDgxCisjOiBkaWZmLmM6NTQ4NAogbXNnaWQgImRpc2FibGUgYWxsIG91dHB1dCBvZiB0aGUgcHJvZ3JhbSIKIG1zZ3N0ciAi0LHQtdC3INCy0YHRj9C60LDQutGK0LIg0LjQt9GF0L7QtCDQvtGCINC/0YDQvtCz0YDQsNC80LDRgtCwIgogCi0jOiBkaWZmLmM6NTQ4MworIzogZGlmZi5jOjU0ODYKIG1zZ2lkICJhbGxvdyBhbiBleHRlcm5hbCBkaWZmIGhlbHBlciB0byBiZSBleGVjdXRlZCIKIG1zZ3N0ciAi0L/QvtC30LLQvtC70Y/QstCw0L3QtSDQvdCwINC40LfQv9GK0LvQvdC10L3QuNC1INC90LAg0LLRitC90YjQvdCwINC/0L7QvNC+0YnQvdCwINC/0YDQvtCz0YDQsNC80LAg0LfQsCDRgNCw0LfQu9C40LrQuCIKIAotIzogZGlmZi5jOjU0ODUKKyM6IGRpZmYuYzo1NDg4CiBtc2dpZCAicnVuIGV4dGVybmFsIHRleHQgY29udmVyc2lvbiBmaWx0ZXJzIHdoZW4gY29tcGFyaW5nIGJpbmFyeSBmaWxlcyIKIG1zZ3N0ciAiIgogItC40LfQv9GK0LvQvdC10L3QuNC1INC90LAg0LLRitC90YjQvdC4INC/0YDQvtCz0YDQsNC80Lgt0YTQuNC70YLRgNC4INC/0YDQuCDRgdGA0LDQstC90LXQvdC40LXRgtC+INC90LAg0LTQstC+0LjRh9C90Lgg0YTQsNC50LvQvtCy0LUiCiAKLSM6IGRpZmYuYzo1NDg3CisjOiBkaWZmLmM6NTQ5MAogbXNnaWQgIjx3aGVuPiIKIG1zZ3N0ciAi0JrQntCT0JAiCiAKLSM6IGRpZmYuYzo1NDg4CisjOiBkaWZmLmM6NTQ5MQogbXNnaWQgImlnbm9yZSBjaGFuZ2VzIHRvIHN1Ym1vZHVsZXMgaW4gdGhlIGRpZmYgZ2VuZXJhdGlvbiIKIG1zZ3N0ciAi0LjQs9C90L7RgNC40YDQsNC90LUg0L3QsCDQv9GA0L7QvNC10L3QuNGC0LUg0LIg0L/QvtC00LzQvtC00YPQu9C40YLQtSDQv9GA0Lgg0LjQt9Cy0LXQttC00LDQvdC10YLQviDQvdCwINGA0LDQt9C70LjQutC40YLQtSIKIAotIzogZGlmZi5jOjU0OTEKKyM6IGRpZmYuYzo1NDk0CiBtc2dpZCAiPGZvcm1hdD4iCiBtc2dzdHIgItCk0J7QoNCc0JDQoiIKIAotIzogZGlmZi5jOjU0OTIKKyM6IGRpZmYuYzo1NDk1CiBtc2dpZCAic3BlY2lmeSBob3cgZGlmZmVyZW5jZXMgaW4gc3VibW9kdWxlcyBhcmUgc2hvd24iCiBtc2dzdHIgItC90LDRh9C40L0g0LfQsCDQuNC30LLQtdC20LTQsNC90LUg0L3QsCDQv9GA0L7QvNC10L3QuNGC0LUg0LIg0L/QvtC00LzQvtC00YPQu9C40YLQtSIKIAotIzogZGlmZi5jOjU0OTYKKyM6IGRpZmYuYzo1NDk5CiBtc2dpZCAiaGlkZSAnZ2l0IGFkZCAtTicgZW50cmllcyBmcm9tIHRoZSBpbmRleCIKIG1zZ3N0ciAi0LHQtdC3INCy0LrQu9GO0YfQstCw0L3QtSDQsiDQuNC90LTQtdC60YHQsCDQvdCwINC30LDQv9C40YHQuNGC0LUsINC00L7QsdCw0LLQtdC90Lgg0YEg4oCeZ2l0IGFkZCAtTuKAnCIKIAotIzogZGlmZi5jOjU0OTkKKyM6IGRpZmYuYzo1NTAyCiBtc2dpZCAidHJlYXQgJ2dpdCBhZGQgLU4nIGVudHJpZXMgYXMgcmVhbCBpbiB0aGUgaW5kZXgiCiBtc2dzdHIgItCy0LrQu9GO0YfQstCw0L3QtSDQsiDQuNC90LTQtdC60YHQsCDQvdCwINC30LDQv9C40YHQuNGC0LUsINC00L7QsdCw0LLQtdC90Lgg0YEg4oCeZ2l0IGFkZCAtTuKAnCIKIAotIzogZGlmZi5jOjU1MDEKKyM6IGRpZmYuYzo1NTA0CiBtc2dpZCAiPHN0cmluZz4iCiBtc2dzdHIgItCd0JjQlyIKIAotIzogZGlmZi5jOjU1MDIKKyM6IGRpZmYuYzo1NTA1CiBtc2dpZCAiIgogImxvb2sgZm9yIGRpZmZlcmVuY2VzIHRoYXQgY2hhbmdlIHRoZSBudW1iZXIgb2Ygb2NjdXJyZW5jZXMgb2YgdGhlIHNwZWNpZmllZCAiCiAic3RyaW5nIgogbXNnc3RyICLRgtGK0YDRgdC10L3QtSDQvdCwINGA0LDQt9C70LjQutC4LCDQutC+0LjRgtC+INC/0YDQvtC80LXQvdGP0YIg0LHRgNC+0Y8g0L3QsCDQv9C+0Y/QstCwINC90LAg0YPQutCw0LfQsNC90LjRgtC1INC90LjQt9C+0LLQtSIKIAotIzogZGlmZi5jOjU1MDUKKyM6IGRpZmYuYzo1NTA4CiBtc2dpZCAiIgogImxvb2sgZm9yIGRpZmZlcmVuY2VzIHRoYXQgY2hhbmdlIHRoZSBudW1iZXIgb2Ygb2NjdXJyZW5jZXMgb2YgdGhlIHNwZWNpZmllZCAiCiAicmVnZXgiCkBAIC0zMTUxLDk3ICszMTYwLDk3IEBACiAi0YLRitGA0YHQtdC90LUg0L3QsCDRgNCw0LfQu9C40LrQuCwg0LrQvtC40YLQviDQv9GA0L7QvNC10L3Rj9GCINCx0YDQvtGPINC90LAg0L/QvtGP0LLQsCDQvdCwINC90LjQt9C+0LLQtdGC0LUsINC60L7QuNGC0L4g0L3QsNC/0LDRgdCy0LDRgiAiCiAi0L3QsCDRgNC10LPRg9C70Y/RgNC90LjRjyDQuNC30YDQsNC3IgogCi0jOiBkaWZmLmM6NTUwOAorIzogZGlmZi5jOjU1MTEKIG1zZ2lkICJzaG93IGFsbCBjaGFuZ2VzIGluIHRoZSBjaGFuZ2VzZXQgd2l0aCAtUyBvciAtRyIKIG1zZ3N0ciAi0LjQt9Cy0LXQttC00LDQvdC1INC90LAg0LLRgdC40YfQutC4INC/0YDQvtC80LXQvdC4INGBIOKAni1H4oCcL+KAni1T4oCcIgogCi0jOiBkaWZmLmM6NTUxMQorIzogZGlmZi5jOjU1MTQKIG1zZ2lkICJ0cmVhdCA8c3RyaW5nPiBpbiAtUyBhcyBleHRlbmRlZCBQT1NJWCByZWd1bGFyIGV4cHJlc3Npb24iCiBtc2dzdHIgItCd0JjQl9GK0YIg0LrRitC8IOKAni1T4oCcINC00LAg0YHQtSDRgtGK0LvQutGD0LLQsCDQutCw0YLQviDRgNCw0LfRiNC40YDQtdC9INGA0LXQs9GD0LvRj9GA0LXQvSDQuNC30YDQsNC3INC/0L4gUE9TSVgiCiAKLSM6IGRpZmYuYzo1NTE0CisjOiBkaWZmLmM6NTUxNwogbXNnaWQgImNvbnRyb2wgdGhlIG9yZGVyIGluIHdoaWNoIGZpbGVzIGFwcGVhciBpbiB0aGUgb3V0cHV0IgogbXNnc3RyICLRg9C/0YDQsNCy0LvQtdC90LjQtSDQvdCwINC/0L7QtNGA0LXQtNCx0LDRgtCwINC90LAg0YTQsNC50LvQvtCy0LXRgtC1INCyINC40LfRhdC+0LTQsCIKIAotIzogZGlmZi5jOjU1MTUKKyM6IGRpZmYuYzo1NTE4CiBtc2dpZCAiPG9iamVjdC1pZD4iCiBtc2dzdHIgItCY0JTQldCd0KLQmNCk0JjQmtCQ0KLQntCgX9Cd0JBf0J7QkdCV0JrQoiIKIAotIzogZGlmZi5jOjU1MTYKKyM6IGRpZmYuYzo1NTE5CiBtc2dpZCAiIgogImxvb2sgZm9yIGRpZmZlcmVuY2VzIHRoYXQgY2hhbmdlIHRoZSBudW1iZXIgb2Ygb2NjdXJyZW5jZXMgb2YgdGhlIHNwZWNpZmllZCAiCiAib2JqZWN0IgogbXNnc3RyICLRgtGK0YDRgdC10L3QtSDQvdCwINGA0LDQt9C70LjQutC4LCDQutC+0LjRgtC+INC/0YDQvtC80LXQvdGP0YIg0LHRgNC+0Y8g0L3QsCDQv9C+0Y/QstCwINC90LAg0YPQutCw0LfQsNC90LjRjyDQvtCx0LXQutGCIgogCi0jOiBkaWZmLmM6NTUxOAorIzogZGlmZi5jOjU1MjEKIG1zZ2lkICJbKEF8Q3xEfE18UnxUfFV8WHxCKS4uLlsqXV0iCiBtc2dzdHIgIlsoQXxDfER8TXxSfFR8VXxYfEIp4oCmWypdXSIKIAotIzogZGlmZi5jOjU1MTkKKyM6IGRpZmYuYzo1NTIyCiBtc2dpZCAic2VsZWN0IGZpbGVzIGJ5IGRpZmYgdHlwZSIKIG1zZ3N0ciAi0LjQt9Cx0L7RgCDQvdCwINGE0LDQudC70L7QstC10YLQtSDQv9C+INCy0LjQtCDRgNCw0LfQu9C40LrQsCIKIAotIzogZGlmZi5jOjU1MjEKKyM6IGRpZmYuYzo1NTI0CiBtc2dpZCAiPGZpbGU+IgogbXNnc3RyICLQpNCQ0JnQmyIKIAotIzogZGlmZi5jOjU1MjIKKyM6IGRpZmYuYzo1NTI1CiBtc2dpZCAiT3V0cHV0IHRvIGEgc3BlY2lmaWMgZmlsZSIKIG1zZ3N0ciAi0JjQt9GF0L7QtCDQutGK0Lwg0YPQutCw0LfQsNC90LjRjyDRhNCw0LnQuyIKIAotIzogZGlmZi5jOjYxNzcKKyM6IGRpZmYuYzo2MTgwCiBtc2dpZCAiaW5leGFjdCByZW5hbWUgZGV0ZWN0aW9uIHdhcyBza2lwcGVkIGR1ZSB0byB0b28gbWFueSBmaWxlcy4iCiBtc2dzdHIgIiIKICLRgtGK0YDRgdC10L3QtdGC0L4g0L3QsCDQv9GA0LXQuNC80LXQvdGD0LLQsNC90LjRjyDQvdCwINC+0LHQtdC60YLQuCDRgdGK0YfQtdGC0LDQvdC4INGBINC/0YDQvtC80LXQvdC4INGB0LUg0L/RgNC10YHQutCw0YfQsCDQv9C+0YDQsNC00LggIgogItC80L3QvtCz0L7RgtC+INGE0LDQudC70L7QstC1LiIKIAotIzogZGlmZi5jOjYxODAKKyM6IGRpZmYuYzo2MTgzCiBtc2dpZCAib25seSBmb3VuZCBjb3BpZXMgZnJvbSBtb2RpZmllZCBwYXRocyBkdWUgdG8gdG9vIG1hbnkgZmlsZXMuIgogbXNnc3RyICIiCiAi0YPRgdGC0LDQvdC+0LLQtdC90Lgg0YHQsCDRgdCw0LzQviDRgtC+0YfQvdC40YLQtSDQutC+0L/QuNGPINC90LAg0L/RgNC+0LzQtdC90LXQvdC40YLQtSDQv9GK0YLQuNGJ0LAg0L/QvtGA0LDQtNC4INC80L3QvtCz0L7RgtC+ICIKICLRhNCw0LnQu9C+0LLQtS4iCiAKLSM6IGRpZmYuYzo2MTgzCisjOiBkaWZmLmM6NjE4NgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAieW91IG1heSB3YW50IHRvIHNldCB5b3VyICVzIHZhcmlhYmxlIHRvIGF0IGxlYXN0ICVkIGFuZCByZXRyeSB0aGUgY29tbWFuZC4iCiBtc2dzdHIgItC30LDQtNCw0LnRgtC1INC/0YDQvtC80LXQvdC70LjQstCw0YLQsCDigJ4lc+KAnCDQtNCwINC1INC/0L7QvdC1ICVkINC4INC+0YLQvdC+0LLQviDQuNC30L/RitC70L3QtdGC0LUg0LrQvtC80LDQvdC00LDRgtCwLiIKIAotIzogZGlyLmM6NTM3CisjOiBkaXIuYzo1NDkKICMsIGMtZm9ybWF0CiBtc2dpZCAicGF0aHNwZWMgJyVzJyBkaWQgbm90IG1hdGNoIGFueSBmaWxlKHMpIGtub3duIHRvIGdpdCIKIG1zZ3N0ciAi0L/RitGC0Y/RgiDigJ4lc+KAnCDQvdC1INGB0YrQstC/0LDQtNCwINGBINC90LjQutC+0Lkg0YTQsNC50Lsg0LIgZ2l0IgogCi0jOiBkaXIuYzo5MjYKKyM6IGRpci5jOjkzOAogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgdXNlICVzIGFzIGFuIGV4Y2x1ZGUgZmlsZSIKIG1zZ3N0ciAi4oCeJXPigJwg0L3QtSDQvNC+0LbQtSDQtNCwINGB0LUg0L/QvtC70LfQstCwINC30LAg0LjQs9C90L7RgNC40YDQsNC90LjRgtC1INGE0LDQudC70L7QstC1ICjQutCw0YLQviBnaXRpZ25vcmUpIgogCi0jOiBkaXIuYzoxODQzCisjOiBkaXIuYzoxODc3CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBvcGVuIGRpcmVjdG9yeSAnJXMnIgogbXNnc3RyICLQtNC40YDQtdC60YLQvtGA0LjRj9GC0LAg4oCeJXPigJwg0L3QtSDQvNC+0LbQtSDQtNCwINCx0YrQtNC1INC+0YLQstC+0YDQtdC90LAiCiAKLSM6IGRpci5jOjIwODUKKyM6IGRpci5jOjIxMjgKIG1zZ2lkICJmYWlsZWQgdG8gZ2V0IGtlcm5lbCBuYW1lIGFuZCBpbmZvcm1hdGlvbiIKIG1zZ3N0ciAi0LjQvNC10YLQviDQuCDQstC10YDRgdC40Y/RgtCwINC90LAg0Y/QtNGA0L7RgtC+INC90LUg0LHRj9GF0LAg0L/QvtC70YPRh9C10L3QuCIKIAotIzogZGlyLmM6MjIwOQorIzogZGlyLmM6MjI1MgogbXNnaWQgInVudHJhY2tlZCBjYWNoZSBpcyBkaXNhYmxlZCBvbiB0aGlzIHN5c3RlbSBvciBsb2NhdGlvbiIKIG1zZ3N0ciAiIgogItC60LXRiNGK0YIg0LfQsCDQvdC10YHQu9C10LTQtdC90LjRgtC1INGE0LDQudC70L7QstC1INC1INC40LfQutC70Y7Rh9C10L0g0L3QsCDRgtCw0LfQuCDRgdC40YHRgtC10LzQsCDQuNC70Lgg0LzQtdGB0YLQvtC/0L7Qu9C+0LbQtdC90LjQtSIKIAotIzogZGlyLmM6MzAxMworIzogZGlyLmM6MzA1NgogIywgYy1mb3JtYXQKIG1zZ2lkICJpbmRleCBmaWxlIGNvcnJ1cHQgaW4gcmVwbyAlcyIKIG1zZ3N0ciAi0YTQsNC50LvRitGCINGBINC40L3QtNC10LrRgdCwINC1INC/0L7QstGA0LXQtNC10L0g0LIg0YXRgNCw0L3QuNC70LjRidC10YLQviDigJ4lc+KAnCIKIAotIzogZGlyLmM6MzA1OCBkaXIuYzozMDYzCisjOiBkaXIuYzozMTAxIGRpci5jOjMxMDYKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGNyZWF0ZSBkaXJlY3RvcmllcyBmb3IgJXMiCiBtc2dzdHIgItC00LjRgNC10LrRgtC+0YDQuNC40YLQtSDQt9CwIOKAniVz4oCcINC90LUg0LzQvtC20LUg0LTQsCDQsdGK0LTQsNGCINGB0YrQt9C00LDQtNC10L3QuCIKIAotIzogZGlyLmM6MzA5MgorIzogZGlyLmM6MzEzNQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgbWlncmF0ZSBnaXQgZGlyZWN0b3J5IGZyb20gJyVzJyB0byAnJXMnIgogbXNnc3RyICLQtNC40YDQtdC60YLQvtGA0LjRj9GC0LAg0L3QsCBnaXQg0L3QtSDQvNC+0LbQtSDQtNCwINGB0LUg0LzQuNCz0YDQuNGA0LAg0L7RgiDigJ4lc+KAnCDQtNC+IOKAniVz4oCcIgpAQCAtMzI2MCwxMiArMzI2OSwxMiBAQAogbXNnaWQgImNvdWxkIG5vdCBzdGF0IGZpbGUgJyVzJyIKIG1zZ3N0ciAi0L3QtdGD0YHQv9C10YjQvdC+INC40LfQv9GK0LvQvdC10L3QuNC1INC90LAg4oCec3RhdOKAnCDQstGK0YDRhdGDINGE0LDQudC70LAg4oCeJXPigJwiCiAKLSM6IGVudmlyb25tZW50LmM6MTUwCisjOiBlbnZpcm9ubWVudC5jOjE0OAogIywgYy1mb3JtYXQKIG1zZ2lkICJiYWQgZ2l0IG5hbWVzcGFjZSBwYXRoIFwiJXNcIiIKIG1zZ3N0ciAi0L3QtdC/0YDQsNCy0LjQu9C10L0g0L/RitGCINC60YrQvCDQv9GA0L7RgdGC0YDQsNC90YHRgtCy0LAg0L7RgiDQuNC80LXQvdCwIOKAniVz4oCcIgogCi0jOiBlbnZpcm9ubWVudC5jOjMzMgorIzogZW52aXJvbm1lbnQuYzozMzAKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHNldCBHSVRfRElSIHRvICclcyciCiBtc2dzdHIgIkdJVF9ESVIg0L3QtSDQvNC+0LbQtSDQtNCwINGB0LUg0LfQsNC00LDQtNC1INC00LAg0LUg4oCeJXPigJwiCkBAIC0zMjc1LDE1OSArMzI4NCwxNTUgQEAKIG1zZ2lkICJ0b28gbWFueSBhcmdzIHRvIHJ1biAlcyIKIG1zZ3N0ciAi0L/RgNC10LrQsNC70LXQvdC+INC80L3QvtCz0L4g0LDRgNCz0YPQvNC10L3RgtC4INC30LAg0LjQt9C/0YrQu9C90LXQvdC40LUg4oCeJXPigJwiCiAKLSM6IGZldGNoLW9iamVjdC5jOjE3Ci1tc2dpZCAiUmVtb3RlIHdpdGggbm8gVVJMIgotbXNnc3RyICLQm9C40L/RgdCy0LAg0LDQtNGA0LXRgSDQt9CwINC+0YLQtNCw0LvQtdGH0LXQvdC+0YLQviDRhdGA0LDQvdC40LvQuNGJ0LUiCi0KLSM6IGZldGNoLXBhY2suYzoxNTEKKyM6IGZldGNoLXBhY2suYzoxNTAKIG1zZ2lkICJnaXQgZmV0Y2gtcGFjazogZXhwZWN0ZWQgc2hhbGxvdyBsaXN0IgogbXNnc3RyICJnaXQgZmV0Y2gtcGFjazog0L7Rh9Cw0LrQstCwINGB0LUg0L/Qu9C40YLRitC6INGB0L/QuNGB0YrQuiIKIAotIzogZmV0Y2gtcGFjay5jOjE1NAorIzogZmV0Y2gtcGFjay5jOjE1MwogbXNnaWQgImdpdCBmZXRjaC1wYWNrOiBleHBlY3RlZCBhIGZsdXNoIHBhY2tldCBhZnRlciBzaGFsbG93IGxpc3QiCiBtc2dzdHIgImdpdCBmZXRjaC1wYWNrOiDRgdC70LXQtCDQv9C70LjRgtGK0Log0YHQv9C40YHRitC6INGB0LUg0L7Rh9Cw0LrQstCwINC40LfRh9C40YHRgtCy0LDRiSDQv9Cw0LrQtdGCIOKAnmZsdXNo4oCcIgogCi0jOiBmZXRjaC1wYWNrLmM6MTY1CisjOiBmZXRjaC1wYWNrLmM6MTY0CiBtc2dpZCAiZ2l0IGZldGNoLXBhY2s6IGV4cGVjdGVkIEFDSy9OQUssIGdvdCBhIGZsdXNoIHBhY2tldCIKIG1zZ3N0ciAiIgogImdpdCBmZXRjaC1wYWNrOiDQvtGH0LDQutCy0LAg0YHQtSDigJ5BQ0vigJwv4oCeTkFL4oCcLCDQsCDQsdC1INC/0L7Qu9GD0YfQtdC9INC40LfRh9C40YHRgtCy0LDRiSDQv9Cw0LrQtdGCIOKAnmZsdXNo4oCcIgogCi0jOiBmZXRjaC1wYWNrLmM6MTg1CisjOiBmZXRjaC1wYWNrLmM6MTg0CiAjLCBjLWZvcm1hdAogbXNnaWQgImdpdCBmZXRjaC1wYWNrOiBleHBlY3RlZCBBQ0svTkFLLCBnb3QgJyVzJyIKIG1zZ3N0ciAiZ2l0IGZldGNoLXBhY2s6INC+0YfQsNC60LLQsCDRgdC1IOKAnkFDS+KAnC/igJ5OQUvigJwsINCwINCx0LUg0L/QvtC70YPRh9C10L3QviDigJ4lc+KAnCIKIAotIzogZmV0Y2gtcGFjay5jOjE5NgorIzogZmV0Y2gtcGFjay5jOjE5NQogbXNnaWQgInVuYWJsZSB0byB3cml0ZSB0byByZW1vdGUiCiBtc2dzdHIgItC90LXQstGK0LfQvNC+0LbQvdC+INC/0LjRgdCw0L3QtSDQutGK0Lwg0L7RgtC00LDQu9C10YfQtdC90L4g0YXRgNCw0L3QuNC70LjRidC1IgogCi0jOiBmZXRjaC1wYWNrLmM6MjU4CisjOiBmZXRjaC1wYWNrLmM6MjU3CiBtc2dpZCAiLS1zdGF0ZWxlc3MtcnBjIHJlcXVpcmVzIG11bHRpX2Fja19kZXRhaWxlZCIKIG1zZ3N0ciAi0L7Qv9GG0LjRj9GC0LAg4oCeLS1zdGF0ZWxlc3MtcnBj4oCcINC40LfQuNGB0LrQstCwICDigJ5tdWx0aV9hY2tfZGV0YWlsZWTigJwiCiAKLSM6IGZldGNoLXBhY2suYzozNjAgZmV0Y2gtcGFjay5jOjEyODQKKyM6IGZldGNoLXBhY2suYzozNTYgZmV0Y2gtcGFjay5jOjEyODAKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBzaGFsbG93IGxpbmU6ICVzIgogbXNnc3RyICLQvdC10L/RgNCw0LLQuNC70LXQvSDQv9C70LjRgtGK0Log0YDQtdC0OiDigJ4lc+KAnCIKIAotIzogZmV0Y2gtcGFjay5jOjM2NiBmZXRjaC1wYWNrLmM6MTI5MAorIzogZmV0Y2gtcGFjay5jOjM2MiBmZXRjaC1wYWNrLmM6MTI4NgogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIHVuc2hhbGxvdyBsaW5lOiAlcyIKIG1zZ3N0ciAi0L3QtdC/0YDQsNCy0LjQu9C10L0g0L3QtdC/0LvQuNGC0YrQuiDRgNC10LQ6IOKAniVz4oCcIgogCi0jOiBmZXRjaC1wYWNrLmM6MzY4IGZldGNoLXBhY2suYzoxMjkyCisjOiBmZXRjaC1wYWNrLmM6MzY0IGZldGNoLXBhY2suYzoxMjg4CiAjLCBjLWZvcm1hdAogbXNnaWQgIm9iamVjdCBub3QgZm91bmQ6ICVzIgogbXNnc3RyICLQvtCx0LXQutGC0YrRgiDigJ4lc+KAnCDQu9C40L/RgdCy0LAiCiAKLSM6IGZldGNoLXBhY2suYzozNzEgZmV0Y2gtcGFjay5jOjEyOTUKKyM6IGZldGNoLXBhY2suYzozNjcgZmV0Y2gtcGFjay5jOjEyOTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiZXJyb3IgaW4gb2JqZWN0OiAlcyIKIG1zZ3N0ciAi0LPRgNC10YjQutCwINCyINC+0LHQtdC60YLQsDog4oCeJXPigJwiCiAKLSM6IGZldGNoLXBhY2suYzozNzMgZmV0Y2gtcGFjay5jOjEyOTcKKyM6IGZldGNoLXBhY2suYzozNjkgZmV0Y2gtcGFjay5jOjEyOTMKICMsIGMtZm9ybWF0CiBtc2dpZCAibm8gc2hhbGxvdyBmb3VuZDogJXMiCiBtc2dzdHIgItC90LUg0LUg0L7RgtC60YDQuNGCINC/0LvQuNGC0YrQuiDQvtCx0LXQutGCOiAlcyIKIAotIzogZmV0Y2gtcGFjay5jOjM3NiBmZXRjaC1wYWNrLmM6MTMwMQorIzogZmV0Y2gtcGFjay5jOjM3MiBmZXRjaC1wYWNrLmM6MTI5NwogIywgYy1mb3JtYXQKIG1zZ2lkICJleHBlY3RlZCBzaGFsbG93L3Vuc2hhbGxvdywgZ290ICVzIgogbXNnc3RyICLQvtGH0LDQutCy0LAg0YHQtSDQv9C70LjRgtGK0Log0LjQu9C4INC90LUg0L7QsdC10LrRgiwg0LAg0LHQtSDQv9C+0LvRg9GH0LXQvdC+OiDigJ4lc+KAnCIKIAotIzogZmV0Y2gtcGFjay5jOjQxNworIzogZmV0Y2gtcGFjay5jOjQxNAogIywgYy1mb3JtYXQKIG1zZ2lkICJnb3QgJXMgJWQgJXMiCiBtc2dzdHIgItC/0L7Qu9GD0YfQtdC90L4g0LHQtSAlcyAlZCAlcyIKIAotIzogZmV0Y2gtcGFjay5jOjQzNAorIzogZmV0Y2gtcGFjay5jOjQzMQogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIGNvbW1pdCAlcyIKIG1zZ3N0ciAi0L3QtdC/0YDQsNCy0LjQu9C90L4g0L/QvtC00LDQstCw0L3QtTog4oCeJXPigJwiCiAKLSM6IGZldGNoLXBhY2suYzo0NjUKKyM6IGZldGNoLXBhY2suYzo0NjIKIG1zZ2lkICJnaXZpbmcgdXAiCiBtc2dzdHIgItC/0YDQtdGD0YHRgtCw0L3QvtCy0Y/QstCw0L3QtSIKIAotIzogZmV0Y2gtcGFjay5jOjQ3NyBwcm9ncmVzcy5jOjI3NworIzogZmV0Y2gtcGFjay5jOjQ3NSBwcm9ncmVzcy5jOjMxMgogbXNnaWQgImRvbmUiCiBtc2dzdHIgItC00LXQudGB0YLQstC40LXRgtC+INC30LDQstGK0YDRiNC4IgogCi0jOiBmZXRjaC1wYWNrLmM6NDg5CisjOiBmZXRjaC1wYWNrLmM6NDg3CiAjLCBjLWZvcm1hdAogbXNnaWQgImdvdCAlcyAoJWQpICVzIgogbXNnc3RyICLQv9C+0LvRg9GH0LXQvdC+INCx0LUgJXMgKCVkKSAlcyIKIAotIzogZmV0Y2gtcGFjay5jOjUzNQorIzogZmV0Y2gtcGFjay5jOjUzMwogIywgYy1mb3JtYXQKIG1zZ2lkICJNYXJraW5nICVzIGFzIGNvbXBsZXRlIgogbXNnc3RyICLQntGC0LHQtdC70Y/Qt9Cy0LDQvdC1INC90LAg4oCeJXPigJwg0LrQsNGC0L4g0L/RitC70L3QviIKIAotIzogZmV0Y2gtcGFjay5jOjc0NAorIzogZmV0Y2gtcGFjay5jOjc0MgogIywgYy1mb3JtYXQKIG1zZ2lkICJhbHJlYWR5IGhhdmUgJXMgKCVzKSIKIG1zZ3N0ciAi0LLQtdGH0LUg0LjQvNCwIOKAniVz4oCcICglcykiCiAKLSM6IGZldGNoLXBhY2suYzo3ODMKKyM6IGZldGNoLXBhY2suYzo3ODEKIG1zZ2lkICJmZXRjaC1wYWNrOiB1bmFibGUgdG8gZm9yayBvZmYgc2lkZWJhbmQgZGVtdWx0aXBsZXhlciIKIG1zZ3N0ciAiZmV0Y2gtcGFjazog0L3QtSDQvNC+0LbQtSDQtNCwINGB0LUg0YHRitC30LTQsNC00LUg0L/RgNC+0YbQtdGBINC30LAg0LTQtdC80YPQu9GC0LjQv9C70LXQutGB0L7RgNCwIgogCi0jOiBmZXRjaC1wYWNrLmM6NzkxCisjOiBmZXRjaC1wYWNrLmM6Nzg5CiBtc2dpZCAicHJvdG9jb2wgZXJyb3I6IGJhZCBwYWNrIGhlYWRlciIKIG1zZ3N0ciAi0L/RgNC+0YLQvtC60L7Qu9C90LAg0LPRgNC10YjQutCwOiDQvdC10L/RgNCw0LLQuNC70L3QsCDQt9Cw0LPQu9Cw0LLQvdCwINGH0LDRgdGCINC90LAg0L/QsNC60LXRgiIKIAotIzogZmV0Y2gtcGFjay5jOjg1OQorIzogZmV0Y2gtcGFjay5jOjg1NwogIywgYy1mb3JtYXQKIG1zZ2lkICJmZXRjaC1wYWNrOiB1bmFibGUgdG8gZm9yayBvZmYgJXMiCiBtc2dzdHIgImZldGNoLXBhY2s6INC90LUg0LzQvtC20LUg0LTQsCDRgdC1INGB0YrQt9C00LDQtNC1INC/0YDQvtGG0LXRgSDQt9CwIOKAniVz4oCcIgogCi0jOiBmZXRjaC1wYWNrLmM6ODc1CisjOiBmZXRjaC1wYWNrLmM6ODczCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIGZhaWxlZCIKIG1zZ3N0ciAi0L3QtdGD0YHQv9C10YjQvdC+INC40LfQv9GK0LvQvdC10L3QuNC1INC90LAg4oCeJXPigJwiCiAKLSM6IGZldGNoLXBhY2suYzo4NzcKKyM6IGZldGNoLXBhY2suYzo4NzUKIG1zZ2lkICJlcnJvciBpbiBzaWRlYmFuZCBkZW11bHRpcGxleGVyIgogbXNnc3RyICLQs9GA0LXRiNC60LAg0LIg0LTQtdC80YPQu9GC0LjQv9C70LXQutGB0L7RgNCwIgogCi0jOiBmZXRjaC1wYWNrLmM6OTA4CisjOiBmZXRjaC1wYWNrLmM6OTA3CiAjLCBjLWZvcm1hdAogbXNnaWQgIlNlcnZlciB2ZXJzaW9uIGlzICUuKnMiCiBtc2dzdHIgItCS0LXRgNGB0LjRj9GC0LAg0L3QsCDRgdGK0YDQstGK0YDQsCDQtTogJS4qcyIKIAotIzogZmV0Y2gtcGFjay5jOjkxMyBmZXRjaC1wYWNrLmM6OTE5IGZldGNoLXBhY2suYzo5MjIgZmV0Y2gtcGFjay5jOjkyOAotIzogZmV0Y2gtcGFjay5jOjkzMiBmZXRjaC1wYWNrLmM6OTM2IGZldGNoLXBhY2suYzo5NDAgZmV0Y2gtcGFjay5jOjk0NAotIzogZmV0Y2gtcGFjay5jOjk0OCBmZXRjaC1wYWNrLmM6OTUyIGZldGNoLXBhY2suYzo5NTYgZmV0Y2gtcGFjay5jOjk2MAotIzogZmV0Y2gtcGFjay5jOjk2NiBmZXRjaC1wYWNrLmM6OTcyIGZldGNoLXBhY2suYzo5NzcgZmV0Y2gtcGFjay5jOjk4MgorIzogZmV0Y2gtcGFjay5jOjkxMiBmZXRjaC1wYWNrLmM6OTE4IGZldGNoLXBhY2suYzo5MjEgZmV0Y2gtcGFjay5jOjkyNworIzogZmV0Y2gtcGFjay5jOjkzMSBmZXRjaC1wYWNrLmM6OTM1IGZldGNoLXBhY2suYzo5MzkgZmV0Y2gtcGFjay5jOjk0MworIzogZmV0Y2gtcGFjay5jOjk0NyBmZXRjaC1wYWNrLmM6OTUxIGZldGNoLXBhY2suYzo5NTUgZmV0Y2gtcGFjay5jOjk1OQorIzogZmV0Y2gtcGFjay5jOjk2NSBmZXRjaC1wYWNrLmM6OTcxIGZldGNoLXBhY2suYzo5NzYgZmV0Y2gtcGFjay5jOjk4MQogIywgYy1mb3JtYXQKIG1zZ2lkICJTZXJ2ZXIgc3VwcG9ydHMgJXMiCiBtc2dzdHIgItCh0YrRgNCy0YrRgNGK0YIg0L/QvtC00LTRitGA0LbQsCDigJ4lc+KAnCIKIAotIzogZmV0Y2gtcGFjay5jOjkxNQorIzogZmV0Y2gtcGFjay5jOjkxNAogbXNnaWQgIlNlcnZlciBkb2VzIG5vdCBzdXBwb3J0IHNoYWxsb3cgY2xpZW50cyIKIG1zZ3N0ciAi0KHRitGA0LLRitGA0YrRgiDQvdC1INC/0L7QtNC00YrRgNC20LAg0L/Qu9C40YLQutC4INC60LvQuNC10L3RgtC4IgogCi0jOiBmZXRjaC1wYWNrLmM6OTc1CisjOiBmZXRjaC1wYWNrLmM6OTc0CiBtc2dpZCAiU2VydmVyIGRvZXMgbm90IHN1cHBvcnQgLS1zaGFsbG93LXNpbmNlIgogbXNnc3RyICLQodGK0YDQstGK0YDRitGCINC90LUg0L/QvtC00LTRitGA0LbQsCDQvtC/0YbQuNGP0YLQsCDigJ4tLXNoYWxsb3ctc2luY2XigJwiCiAKLSM6IGZldGNoLXBhY2suYzo5ODAKKyM6IGZldGNoLXBhY2suYzo5NzkKIG1zZ2lkICJTZXJ2ZXIgZG9lcyBub3Qgc3VwcG9ydCAtLXNoYWxsb3ctZXhjbHVkZSIKIG1zZ3N0ciAi0KHRitGA0LLRitGA0YrRgiDQvdC1INC/0L7QtNC00YrRgNC20LAg0L7Qv9GG0LjRj9GC0LAg4oCeLS1zaGFsbG93LWV4Y2x1ZGXigJwiCiAKLSM6IGZldGNoLXBhY2suYzo5ODQKKyM6IGZldGNoLXBhY2suYzo5ODMKIG1zZ2lkICJTZXJ2ZXIgZG9lcyBub3Qgc3VwcG9ydCAtLWRlZXBlbiIKIG1zZ3N0ciAi0KHRitGA0LLRitGA0YrRgiDQvdC1INC/0L7QtNC00YrRgNC20LAg0L7Qv9GG0LjRj9GC0LAg4oCeLS1kZWVwZW7igJwiCiAKLSM6IGZldGNoLXBhY2suYzoxMDAxCisjOiBmZXRjaC1wYWNrLmM6MTAwMAogbXNnaWQgIm5vIGNvbW1vbiBjb21taXRzIgogbXNnc3RyICLQvdGP0LzQsCDQvtCx0YnQuCDQv9C+0LTQsNCy0LDQvdC40Y8iCiAKLSM6IGZldGNoLXBhY2suYzoxMDEzIGZldGNoLXBhY2suYzoxNDYyCisjOiBmZXRjaC1wYWNrLmM6MTAxMiBmZXRjaC1wYWNrLmM6MTQ2OAogbXNnaWQgImdpdCBmZXRjaC1wYWNrOiBmZXRjaCBmYWlsZWQuIgogbXNnc3RyICJnaXQgZmV0Y2gtcGFjazog0L3QtdGD0YHQv9C10YjQvdC+INC00L7RgdGC0LDQstGP0L3QtS4iCiAKLSM6IGZldGNoLXBhY2suYzoxMTUxCisjOiBmZXRjaC1wYWNrLmM6MTE1MAogbXNnaWQgIlNlcnZlciBkb2VzIG5vdCBzdXBwb3J0IHNoYWxsb3cgcmVxdWVzdHMiCiBtc2dzdHIgItCh0YrRgNCy0YrRgNGK0YIg0L3QtSDQv9C+0LTQtNGK0YDQttCwINC/0LvQuNGC0LrQuCDQt9Cw0Y/QstC60LgiCiAKQEAgLTM0MzUsNzUgKzM0NDAsNzUgQEAKIG1zZ2lkICJTZXJ2ZXIgc3VwcG9ydHMgZmlsdGVyIgogbXNnc3RyICLQodGK0YDQstGK0YDRitGCINC/0L7QtNC00YrRgNC20LAg0YTQuNC70YLRgNC4IgogCi0jOiBmZXRjaC1wYWNrLmM6MTE4NAorIzogZmV0Y2gtcGFjay5jOjExODAKIG1zZ2lkICJ1bmFibGUgdG8gd3JpdGUgcmVxdWVzdCB0byByZW1vdGUiCiBtc2dzdHIgItC90LXQstGK0LfQvNC+0LbQvdC+INC/0LjRgdCw0L3QtSDQutGK0Lwg0L7RgtC00LDQu9C10YfQtdC90L4g0YXRgNCw0L3QuNC70LjRidC1IgogCi0jOiBmZXRjaC1wYWNrLmM6MTIwMgorIzogZmV0Y2gtcGFjay5jOjExOTgKICMsIGMtZm9ybWF0CiBtc2dpZCAiZXJyb3IgcmVhZGluZyBzZWN0aW9uIGhlYWRlciAnJXMnIgogbXNnc3RyICLQs9GA0LXRiNC60LAg0L/RgNC4INC/0YDQvtGH0LjRgtCw0L3QtSDQvdCwINC30LDQs9C70LDQstC90LDRgtCwINGH0LDRgdGCINC90LAg0YDQsNC30LTQtdC7IOKAniVz4oCcIgogCi0jOiBmZXRjaC1wYWNrLmM6MTIwOAorIzogZmV0Y2gtcGFjay5jOjEyMDQKICMsIGMtZm9ybWF0CiBtc2dpZCAiZXhwZWN0ZWQgJyVzJywgcmVjZWl2ZWQgJyVzJyIKIG1zZ3N0ciAi0L7Rh9Cw0LrQstCwINGB0LUg4oCeJXPigJwsINCwINCx0LUg0L/QvtC70YPRh9C10L3QviDigJ4lc+KAnCIKIAotIzogZmV0Y2gtcGFjay5jOjEyNDcKKyM6IGZldGNoLXBhY2suYzoxMjQzCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuZXhwZWN0ZWQgYWNrbm93bGVkZ21lbnQgbGluZTogJyVzJyIKIG1zZ3N0ciAi0L3QtdC+0YfQsNC60LLQsNC9INGA0LXQtCDQt9CwINC/0L7RgtCy0YrRgNC20LTQtdC90LjQtTog4oCeJXPigJwiCiAKLSM6IGZldGNoLXBhY2suYzoxMjUyCisjOiBmZXRjaC1wYWNrLmM6MTI0OAogIywgYy1mb3JtYXQKIG1zZ2lkICJlcnJvciBwcm9jZXNzaW5nIGFja3M6ICVkIgogbXNnc3RyICLQs9GA0LXRiNC60LAg0L/RgNC4INC+0LHRgNCw0LHQvtGC0LrQsCDQvdCwINC/0L7RgtCy0YrRgNC20LTQtdC90LjRj9GC0LA6ICVkIgogCi0jOiBmZXRjaC1wYWNrLmM6MTI2MgorIzogZmV0Y2gtcGFjay5jOjEyNTgKIG1zZ2lkICJleHBlY3RlZCBwYWNrZmlsZSB0byBiZSBzZW50IGFmdGVyICdyZWFkeSciCiBtc2dzdHIgIiIKICLQvtGH0LDQutCy0LDRiNC1INGB0LUg0L/QsNC60LXRgtC90LjRj9GCINGE0LDQudC7INC00LAg0LHRitC00LUg0LjQt9C/0YDQsNGC0LXQvSDRgdC70LXQtCDQvtGC0LPQvtCy0L7RgCDQt9CwINCz0L7RgtC+0LLQvdC+0YHRgiAocmVhZHkpIgogCi0jOiBmZXRjaC1wYWNrLmM6MTI2NAorIzogZmV0Y2gtcGFjay5jOjEyNjAKIG1zZ2lkICJleHBlY3RlZCBubyBvdGhlciBzZWN0aW9ucyB0byBiZSBzZW50IGFmdGVyIG5vICdyZWFkeSciCiBtc2dzdHIgIiIKICLQvtGH0LDQutCy0LDRiNC1INGB0LUg0YHQu9C10LQg0LvQuNC/0YHQsCDQvdCwINC+0YLQs9C+0LLQvtGAINC30LAg0LPQvtGC0L7QstC90L7RgdGCIChyZWFkeSkg0LTQsCDQvdC1INGB0LUg0YHQtSDQv9GA0LDRidCw0YIgIgogItC00YDRg9Cz0Lgg0YDQsNC30LTQtdC70LgiCiAKLSM6IGZldGNoLXBhY2suYzoxMzA2CisjOiBmZXRjaC1wYWNrLmM6MTMwMgogIywgYy1mb3JtYXQKIG1zZ2lkICJlcnJvciBwcm9jZXNzaW5nIHNoYWxsb3cgaW5mbzogJWQiCiBtc2dzdHIgItCz0YDQtdGI0LrQsCDQv9GA0Lgg0L7QsdGA0LDQsdC+0YLQutCwINC90LAg0LjQvdGE0L7RgNC80LDRhtC40Y8g0LfQsCDQtNGK0LvQsdC+0YfQuNC90LDRgtCwL9C/0LvQuNGC0LrQvtGB0YLRgtCwOiAlZCIKIAotIzogZmV0Y2gtcGFjay5jOjEzNTMKKyM6IGZldGNoLXBhY2suYzoxMzQ5CiAjLCBjLWZvcm1hdAogbXNnaWQgImV4cGVjdGVkIHdhbnRlZC1yZWYsIGdvdCAnJXMnIgogbXNnc3RyICLQvtGH0LDQutCy0LAg0YHQtSDQuNGB0LrQsNC9INGD0LrQsNC30LDRgtC10LssINCwINCx0LUg0L/QvtC70YPRh9C10L3Qvjog4oCeJXPigJwiCiAKLSM6IGZldGNoLXBhY2suYzoxMzU4CisjOiBmZXRjaC1wYWNrLmM6MTM1NAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmV4cGVjdGVkIHdhbnRlZC1yZWY6ICclcyciCiBtc2dzdHIgItC90LXQvtGH0LDQutCy0LDQvSDQuNGB0LrQsNC9INGD0LrQsNC30LDRgtC10Ls6IOKAniVz4oCcIgogCi0jOiBmZXRjaC1wYWNrLmM6MTM2MworIzogZmV0Y2gtcGFjay5jOjEzNTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiZXJyb3IgcHJvY2Vzc2luZyB3YW50ZWQgcmVmczogJWQiCiBtc2dzdHIgItCz0YDQtdGI0LrQsCDQv9GA0Lgg0L7QsdGA0LDQsdC+0YLQutCw0YLQsCDQvdCwINC40YHQutCw0L3QuNGC0LUg0YPQutCw0LfQsNGC0LXQu9C4OiAlZCIKIAotIzogZmV0Y2gtcGFjay5jOjE2ODkKKyM6IGZldGNoLXBhY2suYzoxNjkzCiBtc2dpZCAibm8gbWF0Y2hpbmcgcmVtb3RlIGhlYWQiCiBtc2dzdHIgItC90LUg0LzQvtC20LUg0LTQsCDQsdGK0LTQtSDQvtGC0LrRgNC40YIg0L/QvtC00YXQvtC00Y/RiSDQstGA0YrRhSDQvtGCINC+0YLQtNCw0LvQtdGH0LXQvdC+0YLQviDRhdGA0LDQvdC40LvQuNGJ0LUiCiAKLSM6IGZldGNoLXBhY2suYzoxNzEyIGJ1aWx0aW4vY2xvbmUuYzo2ODYKKyM6IGZldGNoLXBhY2suYzoxNzE2IGJ1aWx0aW4vY2xvbmUuYzo2ODUKIG1zZ2lkICJyZW1vdGUgZGlkIG5vdCBzZW5kIGFsbCBuZWNlc3Nhcnkgb2JqZWN0cyIKIG1zZ3N0ciAi0L7RgtC00LDQu9C10YfQtdC90L7RgtC+INGF0YDQsNC90LjQu9C40YnQtSDQvdC1INC40LfQv9GA0LDRgtC4INCy0YHQuNGH0LrQuCDQvdC10L7QsdGF0L7QtNC40LzQuCDQvtCx0LXQutGC0LguIgogCi0jOiBmZXRjaC1wYWNrLmM6MTczOQorIzogZmV0Y2gtcGFjay5jOjE3NDMKICMsIGMtZm9ybWF0CiBtc2dpZCAibm8gc3VjaCByZW1vdGUgcmVmICVzIgogbXNnc3RyICLRgtCw0LrRitCyINC+0YLQtNCw0LvQtdGH0LXQvSDRg9C60LDQt9Cw0YLQtdC7INC90Y/QvNCwOiAlcyIKIAotIzogZmV0Y2gtcGFjay5jOjE3NDIKKyM6IGZldGNoLXBhY2suYzoxNzQ2CiAjLCBjLWZvcm1hdAogbXNnaWQgIlNlcnZlciBkb2VzIG5vdCBhbGxvdyByZXF1ZXN0IGZvciB1bmFkdmVydGlzZWQgb2JqZWN0ICVzIgogbXNnc3RyICLQodGK0YDQstGK0YDRitGCINC90LUg0L/QvtC30LLQvtC70Y/QstCwINC30LDRj9Cy0LrQsCDQt9CwINC90LXQvtCx0Y/QstC10L0g0L7QsdC10LrRgiDigJ4lc+KAnCIKQEAgLTM1MjYsMTggKzM1MzEsMjYgQEAKIG1zZ2lkICJpZ25vcmUgaW52YWxpZCBjb2xvciAnJS4qcycgaW4gbG9nLmdyYXBoQ29sb3JzIgogbXNnc3RyICLQv9GA0LXRgdC60LDRh9Cw0L3QtSDQvdCwINC90LXQv9GA0LDQstC40LvQvdC40Y8g0YbQstGP0YIg4oCeJS4qc+KAnCDQsiDigJ5sb2cuZ3JhcGhDb2xvcnPigJwiCiAKLSM6IGdyZXAuYzoyMTE3CisjOiBncmVwLmM6NjY4Cittc2dpZCAiIgorImdpdmVuIHBhdHRlcm4gY29udGFpbnMgTlVMTCBieXRlICh2aWEgLWYgPGZpbGU+KS4gVGhpcyBpcyBvbmx5IHN1cHBvcnRlZCAiCisid2l0aCAtUCB1bmRlciBQQ1JFIHYyIgorbXNnc3RyICIiCisi0LfQsNC00LDQtNC10L3QuNGP0YIg0YjQsNCx0LvQvtC9INGB0YrQtNGK0YDQttCwINC90YPQu9C10LIg0LfQvdCw0LogKNC40LTQstCwINC+0YIgLWYg4oCe0KTQkNCZ0JvigJwpLiAg0KLQvtCy0LAg0YHQtSDQv9C+0LTQtNGK0YDQttCwICIKKyLQsiDQutC+0LzQsdC40L3QsNGG0LjRjyDRgSDigJ4tUOKAnCDRgdCw0LzQviDQv9GA0Lgg0L/QvtC70LfQstCw0L3QtdGC0L4g0L3QsCDigJ5QQ1JFIHYy4oCcIgorCisjOiBncmVwLmM6MjEyNAogIywgYy1mb3JtYXQKIG1zZ2lkICInJXMnOiB1bmFibGUgdG8gcmVhZCAlcyIKIG1zZ3N0ciAi4oCeJXPigJw6INGE0LDQudC70YrRgiDRgdC+0YfQtdC9INC+0YIg4oCeJXPigJwg0L3QtSDQvNC+0LbQtSDQtNCwINCx0YrQtNC1INC/0YDQvtGH0LXRgtC10L0iCiAKLSM6IGdyZXAuYzoyMTM0IHNldHVwLmM6MTY0IGJ1aWx0aW4vY2xvbmUuYzo0MDkgYnVpbHRpbi9kaWZmLmM6ODIKKyM6IGdyZXAuYzoyMTQxIHNldHVwLmM6MTY1IGJ1aWx0aW4vY2xvbmUuYzo0MDggYnVpbHRpbi9kaWZmLmM6ODIKICM6IGJ1aWx0aW4vcm0uYzoxMzUKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIHN0YXQgJyVzJyIKIG1zZ3N0ciAi0L3QtSDQvNC+0LbQtSDQtNCwINCx0YrQtNC1INC/0L7Qu9GD0YfQtdC90LAg0LjQvdGE0L7RgNC80LDRhtC40Y8g0YfRgNC10Lcg4oCec3RhdOKAnCDQt9CwIOKAniVz4oCcIgogCi0jOiBncmVwLmM6MjE0NQorIzogZ3JlcC5jOjIxNTIKICMsIGMtZm9ybWF0CiBtc2dpZCAiJyVzJzogc2hvcnQgcmVhZCIKIG1zZ3N0ciAi4oCeJXPigJw6INC40LfRh9C40YLQsNC90LXRgtC+INCy0YrRgNC90LAg0L/Qvi3QvNCw0LvQutC+INCx0LDQudGC0L7QstC1INC+0YIg0L7Rh9Cw0LrQstCw0L3QvtGC0L4iCkBAIC0zNjg0LDEyICszNjk3LDEyIEBACiBtc2dpZCAiZ2l0IHZlcnNpb24gWzxvcHRpb25zPl0iCiBtc2dzdHIgImdpdCB2ZXJzaW9uIFvQntCf0KbQmNCv4oCmXSIKIAotIzogaGVscC5jOjc4MgorIzogaGVscC5jOjc4MwogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogJXMgLSAlcyIKIG1zZ3N0ciAiJXM6ICVzIOKAlCAlcyIKIAotIzogaGVscC5jOjc4NgorIzogaGVscC5jOjc4NwogbXNnaWQgIiIKICJcbiIKICJEaWQgeW91IG1lYW4gdGhpcz8iCkBAIC0zNzY1LDQxICszNzc4LDU3IEBACiBtc2dpZCAiaW52YWxpZCBkYXRlIGZvcm1hdDogJXMiCiBtc2dzdHIgItC90LXQv9GA0LDQstC40LvQtdC9INGE0L7RgNC80LDRgiDQvdCwINC00LDRgtCwOiAlcyIKIAotIzogbGlzdC1vYmplY3RzLmM6MTI5CisjOiBsaXN0LW9iamVjdHMuYzoxMjcKICMsIGMtZm9ybWF0CiBtc2dpZCAiZW50cnkgJyVzJyBpbiB0cmVlICVzIGhhcyB0cmVlIG1vZGUsIGJ1dCBpcyBub3QgYSB0cmVlIgogbXNnc3RyICLQvtCx0LXQutGCIOKAniVz4oCcINCyINC00YrRgNCy0L7RgtC+IOKAniVz4oCcINC1INC+0YLQsdC10LvRj9C30LDQvSDQutCw0YLQviDQtNGK0YDQstC+LCDQvdC+INC90LUg0LUiCiAKLSM6IGxpc3Qtb2JqZWN0cy5jOjE0MgorIzogbGlzdC1vYmplY3RzLmM6MTQwCiAjLCBjLWZvcm1hdAogbXNnaWQgImVudHJ5ICclcycgaW4gdHJlZSAlcyBoYXMgYmxvYiBtb2RlLCBidXQgaXMgbm90IGEgYmxvYiIKIG1zZ3N0ciAi0L7QsdC10LrRgiDigJ4lc+KAnCDQsiDQtNGK0YDQstC+0YLQviDigJ4lc+KAnCDQtSDQvtGC0LHQtdC70Y/Qt9Cw0L0g0LrQsNGC0L4gQkxPQiwg0L3QviDQvdC1INC1IgogCi0jOiBsaXN0LW9iamVjdHMuYzozNzgKKyM6IGxpc3Qtb2JqZWN0cy5jOjM3NQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gbG9hZCByb290IHRyZWUgZm9yIGNvbW1pdCAlcyIKIG1zZ3N0ciAi0LrQvtGA0LXQvdC+0LLQvtGC0L4g0LTRitGA0LLQviDQt9CwINC/0L7QtNCw0LLQsNC90LUg4oCeJXPigJwg0L3QtSDQvNC+0LbQtSDQtNCwINGB0LUg0LfQsNGA0LXQtNC4IgogCi0jOiBsaXN0LW9iamVjdHMtZmlsdGVyLW9wdGlvbnMuYzozNgotbXNnaWQgIm11bHRpcGxlIGZpbHRlci1zcGVjcyBjYW5ub3QgYmUgY29tYmluZWQiCi1tc2dzdHIgItC90LUg0LzQvtC20LUg0LTQsCDQutC+0LzQsdC40L3QuNGA0LDRgtC1INC80L3QvtC20LXRgdGC0LLQviDRhNC40LvRgtGA0LgiCisjOiBsaXN0LW9iamVjdHMtZmlsdGVyLmM6NDkyCisjLCBjLWZvcm1hdAorbXNnaWQgInVuYWJsZSB0byBhY2Nlc3Mgc3BhcnNlIGJsb2IgaW4gJyVzJyIKK21zZ3N0ciAi0L3Rj9C80LAg0LTQvtGB0YLRitC/INC00L4g0YfQsNGB0YLQuNGH0L3QviDQuNC30YLQtdCz0LvQtdC90LjRjyDQvtCx0LXQutGCLUJMT0Ig0LIg4oCeJXPigJwiCisKKyM6IGxpc3Qtb2JqZWN0cy1maWx0ZXIuYzo0OTUKKyMsIGMtZm9ybWF0Cittc2dpZCAidW5hYmxlIHRvIHBhcnNlIHNwYXJzZSBmaWx0ZXIgZGF0YSBpbiAlcyIKK21zZ3N0ciAiIgorItC00LDQvdC90LjRgtC1INC+0YIg0YTQuNC70YLRitGA0LAg0LfQsCDRh9Cw0YHRgtC40YfQvdC4INC40LfRgtC10LPQu9Cw0L3QuNGPINCyIOKAniVz4oCcINC90LUg0LzQvtC20LUg0LTQsCDQsdGK0LTQsNGCINCw0L3QsNC70LjQt9C40YDQsNC90LgiCiAKICM6IGxpc3Qtb2JqZWN0cy1maWx0ZXItb3B0aW9ucy5jOjU4CiBtc2dpZCAiZXhwZWN0ZWQgJ3RyZWU6PGRlcHRoPiciCiBtc2dzdHIgItC+0YfQsNC60LLQsCDRgdC1IOKAnnRyZWU60JTQqtCb0JHQntCn0JjQndCQ4oCcIgogCi0jOiBsaXN0LW9iamVjdHMtZmlsdGVyLW9wdGlvbnMuYzo4NAorIzogbGlzdC1vYmplY3RzLWZpbHRlci1vcHRpb25zLmM6NzMKIG1zZ2lkICJzcGFyc2U6cGF0aCBmaWx0ZXJzIHN1cHBvcnQgaGFzIGJlZW4gZHJvcHBlZCIKIG1zZ3N0ciAi0L/QvtC00LTRgNGK0LbQutCw0YLQsCDQvdCwINGE0LjQu9GC0YDQuCDRgdGK0YEg4oCec3BhcnNlOnBhdGjigJwg0LUg0L/RgNC10LzQsNGF0L3QsNGC0LAiCiAKLSM6IGxpc3Qtb2JqZWN0cy1maWx0ZXItb3B0aW9ucy5jOjk0CisjOiBsaXN0LW9iamVjdHMtZmlsdGVyLW9wdGlvbnMuYzo4NgogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIGZpbHRlci1zcGVjICclcyciCiBtc2dzdHIgItC90LXQv9GA0LDQstC40LvQtdC9INGE0LjQu9GC0YrRgDog4oCeJXPigJwiCiAKLSM6IGxpc3Qtb2JqZWN0cy1maWx0ZXItb3B0aW9ucy5jOjE1OAotbXNnaWQgImNhbm5vdCBjaGFuZ2UgcGFydGlhbCBjbG9uZSBwcm9taXNvciByZW1vdGUiCi1tc2dzdHIgItC90LUg0LzQvtC20LUg0LTQsCDQv9GA0L7QvNC10L3QuNGC0LUg0YXRgNCw0L3QuNC70LjRidC10YLQvi3Qs9Cw0YDQsNC90YIg0L3QsCDQvdC10L/RitC70L3QviDRhdGA0LDQvdC40LvQuNGJ0LUiCisjOiBsaXN0LW9iamVjdHMtZmlsdGVyLW9wdGlvbnMuYzoxMDIKKyMsIGMtZm9ybWF0Cittc2dpZCAibXVzdCBlc2NhcGUgY2hhciBpbiBzdWItZmlsdGVyLXNwZWM6ICclYyciCittc2dzdHIgItC30L3QsNC6INC30LAg0LXQutGA0LDQvdC40YDQsNC90LUg0LIg0L/QvtC00YTQuNC70YLRitGAOiDigJ4lY+KAnCIKKworIzogbGlzdC1vYmplY3RzLWZpbHRlci1vcHRpb25zLmM6MTQ0Cittc2dpZCAiZXhwZWN0ZWQgc29tZXRoaW5nIGFmdGVyIGNvbWJpbmU6IgorbXNnc3RyICLQtNC+0LHQsNCy0LXRgtC1INC90LXRidC+INGB0LvQtdC0INC60L7QvNCx0LjQvdC40YDQsNC90LXRgtC+OiIKKworIzogbGlzdC1vYmplY3RzLWZpbHRlci1vcHRpb25zLmM6MjI2Cittc2dpZCAibXVsdGlwbGUgZmlsdGVyLXNwZWNzIGNhbm5vdCBiZSBjb21iaW5lZCIKK21zZ3N0ciAi0L3QtSDQvNC+0LbQtSDQtNCwINC60L7QvNCx0LjQvdC40YDQsNGC0LUg0LzQvdC+0LbQtdGB0YLQstC+INGE0LjQu9GC0YDQuCIKIAogIzogbG9ja2ZpbGUuYzoxNTEKICMsIGMtZm9ybWF0CkBAIC0zODI5LDEyNiArMzg1OCwxMjIgQEAKIG1zZ2lkICJmYWlsZWQgdG8gcmVhZCB0aGUgY2FjaGUiCiBtc2dzdHIgItC60LXRiNGK0YIg0L3QtSDQvNC+0LbQtSDQtNCwINCx0YrQtNC1INC/0YDQvtGH0LXRgtC10L0iCiAKLSM6IG1lcmdlLmM6MTA3IHJlcmVyZS5jOjcyMCBidWlsdGluL2FtLmM6MTg4NSBidWlsdGluL2FtLmM6MTkxOQotIzogYnVpbHRpbi9jaGVja291dC5jOjUzNiBidWlsdGluL2NoZWNrb3V0LmM6Nzk2IGJ1aWx0aW4vY2xvbmUuYzo3ODYKKyM6IG1lcmdlLmM6MTA3IHJlcmVyZS5jOjcyMCBidWlsdGluL2FtLmM6MTg3NCBidWlsdGluL2FtLmM6MTkwOAorIzogYnVpbHRpbi9jaGVja291dC5jOjUzNyBidWlsdGluL2NoZWNrb3V0LmM6Nzk2IGJ1aWx0aW4vY2xvbmUuYzo3ODUKICM6IGJ1aWx0aW4vc3Rhc2guYzoyNjQKIG1zZ2lkICJ1bmFibGUgdG8gd3JpdGUgbmV3IGluZGV4IGZpbGUiCiBtc2dzdHIgItC90LXRg9GB0L/QtdGI0L3QviDQt9Cw0L/QuNGB0LLQsNC90LUg0L3QsCDQvdC+0LLQuNGPINC40L3QtNC10LrRgSIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzIyCisjOiBtZXJnZS1yZWN1cnNpdmUuYzozNjcKIG1zZ2lkICIoYmFkIGNvbW1pdClcbiIKIG1zZ3N0ciAiKNC70L7RiNC+INC/0L7QtNCw0LLQsNC90LUpXG4iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjM0NQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzkwCiAjLCBjLWZvcm1hdAogbXNnaWQgImFkZF9jYWNoZWluZm8gZmFpbGVkIGZvciBwYXRoICclcyc7IG1lcmdlIGFib3J0aW5nLiIKIG1zZ3N0ciAiIgogItC90LXRg9GB0L/QtdGI0L3QviDQuNC30L/RitC70L3QtdC90LjQtSDQvdCwIOKAnmFkZF9jYWNoZWluZm/igJwg0LfQsCDQv9GK0YLRjyDigJ4lc+KAnC4gINCh0LvQuNCy0LDQvdC10YLQviDQtSAiCiAi0L/RgNC10YPRgdGC0LDQvdC+0LLQtdC90L4uIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozNTQKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjM5OQogIywgYy1mb3JtYXQKIG1zZ2lkICJhZGRfY2FjaGVpbmZvIGZhaWxlZCB0byByZWZyZXNoIGZvciBwYXRoICclcyc7IG1lcmdlIGFib3J0aW5nLiIKIG1zZ3N0ciAiIgogItC90LXRg9GB0L/QtdGI0L3QviDQuNC30L/RitC70L3QtdC90LjQtSDQvdCwIOKAnmFkZF9jYWNoZWluZm/igJwg0LfQsCDQvtCx0L3QvtCy0Y/QstCw0L3QtdGC0L4g0L3QsCDQv9GK0YLRjyDigJ4lc+KAnC4gICIKICLQodC70LjQstCw0L3QtdGC0L4g0LUg0L/RgNC10YPRgdGC0LDQvdC+0LLQtdC90L4uIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzo0MzcKLW1zZ2lkICJlcnJvciBidWlsZGluZyB0cmVlcyIKLW1zZ3N0ciAi0LPRgNC10YjQutCwINC/0YDQuCDQuNC30LPRgNCw0LbQtNCw0L3QtSDQvdCwINC00YrRgNCy0LXRgtCw0YLQsCIKLQotIzogbWVyZ2UtcmVjdXJzaXZlLmM6ODYzCisjOiBtZXJnZS1yZWN1cnNpdmUuYzo4ODUKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIGNyZWF0ZSBwYXRoICclcyclcyIKIG1zZ3N0ciAi0LPRgNC10YjQutCwINC/0YDQuCDRgdGK0LfQtNCw0LLQsNC90LXRgtC+INC90LAg0L/RitGC0Y8g4oCeJXPigJwlcyIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6ODc0CisjOiBtZXJnZS1yZWN1cnNpdmUuYzo4OTYKICMsIGMtZm9ybWF0CiBtc2dpZCAiUmVtb3ZpbmcgJXMgdG8gbWFrZSByb29tIGZvciBzdWJkaXJlY3RvcnlcbiIKIG1zZ3N0ciAi0JjQt9GC0YDQuNCy0LDQvdC1INC90LAg4oCeJXPigJwsINC30LAg0LTQsCDRgdC1INC+0YHQstC+0LHQvtC00Lgg0LzRj9GB0YLQviDQt9CwINC/0L7QtNC00LjRgNC10LrRgtC+0YDQuNGPXG4iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjg4OCBtZXJnZS1yZWN1cnNpdmUuYzo5MDcKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjkxMCBtZXJnZS1yZWN1cnNpdmUuYzo5MjkKIG1zZ2lkICI6IHBlcmhhcHMgYSBEL0YgY29uZmxpY3Q/IgogbXNnc3RyICI6INCy0YrQt9C80L7QttC90L4g0LUg0LTQsCDQuNC80LAg0LrQvtC90YTQu9C40LrRgiDQtNC40YDQtdC60YLQvtGA0LjRjy/RhNCw0LnQuy4iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjg5NworIzogbWVyZ2UtcmVjdXJzaXZlLmM6OTE5CiAjLCBjLWZvcm1hdAogbXNnaWQgInJlZnVzaW5nIHRvIGxvc2UgdW50cmFja2VkIGZpbGUgYXQgJyVzJyIKIG1zZ3N0ciAiIgogItC/0YDQtdGD0YHRgtCw0L3QvtCy0Y/QstCw0L3QtSDQvdCwINC00LXQudGB0YLQstC40LXRgtC+LCDQt9CwINC00LAg0L3QtSDRgdC1INC40LfRgtGA0LjQtSDQvdC10YHQu9C10LTQtdC90LjRj9GCINGE0LDQudC7IOKAniVz4oCcIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzo5MzggYnVpbHRpbi9jYXQtZmlsZS5jOjQwCisjOiBtZXJnZS1yZWN1cnNpdmUuYzo5NjAgYnVpbHRpbi9jYXQtZmlsZS5jOjQxCiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCByZWFkIG9iamVjdCAlcyAnJXMnIgogbXNnc3RyICLQvtCx0LXQutGC0YrRgiDigJ4lc+KAnCAoJXMpINC90LUg0LzQvtC20LUg0LTQsCDQsdGK0LTQtSDQv9GA0L7Rh9C10YLQtdC9IgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzo5NDEKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjk2NQogIywgYy1mb3JtYXQKIG1zZ2lkICJibG9iIGV4cGVjdGVkIGZvciAlcyAnJXMnIgogbXNnc3RyICLQvtCx0LXQutGC0YrRgiDigJ4lc+KAnCAoJXMpINGB0LUg0L7Rh9Cw0LrQstCw0YjQtSDQtNCwINC1IEJMT0IsINCwINC90LUg0LUiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjk2NQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6OTkwCiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBvcGVuICclcyc6ICVzIgogbXNnc3RyICLigJ4lc+KAnCDQvdC1INC80L7QttC1INC00LAg0YHQtSDQvtGC0LLQvtGA0Lg6ICVzIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzo5NzYKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEwMDEKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIHN5bWxpbmsgJyVzJzogJXMiCiBtc2dzdHIgItC90LXRg9GB0L/QtdGI0L3QviDRgdGK0LfQtNCw0LLQsNC90LUg0L3QsCDRgdC40LzQstC+0LvQvdCw0YLQsCDQstGA0YrQt9C60LAg4oCeJXPigJw6ICVzIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzo5ODEKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEwMDYKICMsIGMtZm9ybWF0CiBtc2dpZCAiZG8gbm90IGtub3cgd2hhdCB0byBkbyB3aXRoICUwNm8gJXMgJyVzJyIKIG1zZ3N0ciAiIgogItC90LUg0LUg0Y/RgdC90L4g0LrQsNC60LLQviDQtNCwINGB0LUg0L/RgNCw0LLQuCDRgSDQvtCx0LXQutGC0LAg4oCeJTIkc+KAnCAoJTMkcykg0YEg0L/RgNCw0LLQsCDQt9CwINC00L7RgdGC0YrQvyDigJ4lMSQwNm/igJwiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjExNzcKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjExOTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiRmFpbGVkIHRvIG1lcmdlIHN1Ym1vZHVsZSAlcyAobm90IGNoZWNrZWQgb3V0KSIKIG1zZ3N0ciAi0J3QtdGD0YHQv9C10YjQvdC+INGB0LvQuNCy0LDQvdC1INC90LAg0L/QvtC00LzQvtC00YPQu9CwIOKAniVz4oCcICjQvdC1INC1INC40LfRgtC10LPQu9C10L0pIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxMTg0CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxMjA2CiAjLCBjLWZvcm1hdAogbXNnaWQgIkZhaWxlZCB0byBtZXJnZSBzdWJtb2R1bGUgJXMgKGNvbW1pdHMgbm90IHByZXNlbnQpIgogbXNnc3RyICLQndC10YPRgdC/0LXRiNC90L4g0YHQu9C40LLQsNC90LUg0L3QsCDQv9C+0LTQvNC+0LTRg9C70LAg4oCeJXPigJwgKNC90Y/QvNCwINC/0L7QtNCw0LLQsNC90LjRjykiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjExOTEKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEyMTMKICMsIGMtZm9ybWF0CiBtc2dpZCAiRmFpbGVkIHRvIG1lcmdlIHN1Ym1vZHVsZSAlcyAoY29tbWl0cyBkb24ndCBmb2xsb3cgbWVyZ2UtYmFzZSkiCiBtc2dzdHIgIiIKICLQn9C+0LTQvNC+0LTRg9C70YrRgiDigJ4lc+KAnCDQvdC1INC80L7QttC1INC00LAg0LHRitC00LUg0YHQu9GP0YIgKNCx0LDQt9Cw0YLQsCDQt9CwINGB0LvQuNCy0LDQvdC1INC90LUg0L/RgNC10LTRiNC10YHRgtCy0LAgIgogItC/0L7QtNCw0LLQsNC90LjRj9GC0LApIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxMTk5IG1lcmdlLXJlY3Vyc2l2ZS5jOjEyMTEKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEyMjEgbWVyZ2UtcmVjdXJzaXZlLmM6MTIzMwogIywgYy1mb3JtYXQKIG1zZ2lkICJGYXN0LWZvcndhcmRpbmcgc3VibW9kdWxlICVzIHRvIHRoZSBmb2xsb3dpbmcgY29tbWl0OiIKIG1zZ3N0ciAi0J/RgNC10LLRitGA0YLQsNC90LUg0L3QsCDQv9C+0LTQvNC+0LTRg9C70LAg4oCeJXPigJwg0LTQviDRgdC70LXQtNC90L7RgtC+INC/0L7QtNCw0LLQsNC90LU6IgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxMjAyIG1lcmdlLXJlY3Vyc2l2ZS5jOjEyMTQKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEyMjQgbWVyZ2UtcmVjdXJzaXZlLmM6MTIzNgogIywgYy1mb3JtYXQKIG1zZ2lkICJGYXN0LWZvcndhcmRpbmcgc3VibW9kdWxlICVzIgogbXNnc3RyICLQn9GA0LXQstGK0YDRgtCw0L3QtSDQvdCwINC/0L7QtNC80L7QtNGD0LvQsCDigJ4lc+KAnCIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTIzNworIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTI1OQogIywgYy1mb3JtYXQKIG1zZ2lkICJGYWlsZWQgdG8gbWVyZ2Ugc3VibW9kdWxlICVzIChtZXJnZSBmb2xsb3dpbmcgY29tbWl0cyBub3QgZm91bmQpIgogbXNnc3RyICIiCiAi0J3QtdGD0YHQv9C10YjQvdC+INGB0LvQuNCy0LDQvdC1INC90LAg0L/QvtC00LzQvtC00YPQu9CwIOKAniVz4oCcICjQu9C40L/RgdCy0LAg0YHQu9C40LLQsNC90LXRgtC+LCDQutC+0LXRgtC+INGB0LUg0L/RgNC10LTRiNC10YHRgtCy0LAgIgogItC+0YIg0L/QvtC00LDQstCw0L3QuNGP0YLQsCkiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEyNDEKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEyNjMKICMsIGMtZm9ybWF0CiBtc2dpZCAiRmFpbGVkIHRvIG1lcmdlIHN1Ym1vZHVsZSAlcyAobm90IGZhc3QtZm9yd2FyZCkiCiBtc2dzdHIgItCd0LXRg9GB0L/QtdGI0L3QviDRgdC70LjQstCw0L3QtSDQvdCwINC/0L7QtNC80L7QtNGD0LvQsCDigJ4lc+KAnCAo0L3QtSDQtSDQv9GA0LXQstGK0YDRgtCw0L3QtSkiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEyNDIKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEyNjQKIG1zZ2lkICJGb3VuZCBhIHBvc3NpYmxlIG1lcmdlIHJlc29sdXRpb24gZm9yIHRoZSBzdWJtb2R1bGU6XG4iCiBtc2dzdHIgIiIKICLQntGC0LrRgNC40YLQviDQtSDRgdC70LjQstCw0L3QtSwg0LrQvtC10YLQviDQvNC+0LbQtSDQtNCwINGA0LXRiNCw0LLQsCDQv9GA0L7QsdC70LXQvNCwINGB0YrRgSDRgdC70LjQstCw0L3QtdGC0L4g0L3QsCAiCiAi0L/QvtC00LzQvtC00YPQu9CwOlxuIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxMjQ1CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxMjY3CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJJZiB0aGlzIGlzIGNvcnJlY3Qgc2ltcGx5IGFkZCBpdCB0byB0aGUgaW5kZXggZm9yIGV4YW1wbGVcbiIKQEAgLTM5NjQsMzEgKzM5ODksMzEgQEAKICJcbiIKICLQotC+0LLQsCDQv9GA0LjQtdC80LAg0L/RgNC10LTQu9C+0LbQtdC90L7RgtC+LlxuIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxMjU0CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxMjc2CiAjLCBjLWZvcm1hdAogbXNnaWQgIkZhaWxlZCB0byBtZXJnZSBzdWJtb2R1bGUgJXMgKG11bHRpcGxlIG1lcmdlcyBmb3VuZCkiCiBtc2dzdHIgItCd0LXRg9GB0L/QtdGI0L3QviDRgdC70LjQstCw0L3QtSDQvdCwINC/0L7QtNC80L7QtNGD0LvQsCDigJ4lc+KAnCAo0L7RgtC60YDQuNGC0Lgg0YHQsCDQvNC90L7QttC10YHRgtCy0L4g0YHQu9C40LLQsNC90LjRjykiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEzMjcKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEzNDkKIG1zZ2lkICJGYWlsZWQgdG8gZXhlY3V0ZSBpbnRlcm5hbCBtZXJnZSIKIG1zZ3N0ciAi0J3QtdGD0YHQv9C10YjQvdC+INCy0YrRgtGA0LXRiNC90L4g0YHQu9C40LLQsNC90LUiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEzMzIKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEzNTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiVW5hYmxlIHRvIGFkZCAlcyB0byBkYXRhYmFzZSIKIG1zZ3N0ciAi4oCeJXPigJwg0L3QtSDQvNC+0LbQtSDQtNCwINGB0LUg0LTQvtCx0LDQstC4INCyINCx0LDQt9Cw0YLQsCDRgSDQtNCw0L3QvdC4IgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxMzY0CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxMzg2CiAjLCBjLWZvcm1hdAogbXNnaWQgIkF1dG8tbWVyZ2luZyAlcyIKIG1zZ3N0ciAi0JDQstGC0L7QvNCw0YLQuNGH0L3QviDRgdC70LjQstCw0L3QtSDQvdCwIOKAniVz4oCcIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxMzg3CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxNDEwCiAjLCBjLWZvcm1hdAogbXNnaWQgIkVycm9yOiBSZWZ1c2luZyB0byBsb3NlIHVudHJhY2tlZCBmaWxlIGF0ICVzOyB3cml0aW5nIHRvICVzIGluc3RlYWQuIgogbXNnc3RyICLQk9GA0LXRiNC60LA6INC30LAg0LTQsCDQvdC1INGB0LUg0LjQt9GC0YDQuNC1INC90LXRgdC70LXQtNC10L3QuNGP0YIg0YTQsNC50Lsg4oCeJXPigJwsINGB0LUg0LfQsNC/0LjRgdCy0LAg0LIg4oCeJXPigJwuIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxNDU5CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxNDgyCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJDT05GTElDVCAoJXMvZGVsZXRlKTogJXMgZGVsZXRlZCBpbiAlcyBhbmQgJXMgaW4gJXMuIFZlcnNpb24gJXMgb2YgJXMgbGVmdCAiCkBAIC0zOTk3LDcgKzQwMjIsNyBAQAogItCa0J7QndCk0JvQmNCa0KIgKCVzL9C40LfRgtGA0LjQstCw0L3QtSk6IOKAniVz4oCcINC1INC40LfRgtGA0LjRgiDQsiAlcywg0LAg4oCeJXPigJwg0LIgJXMuICDQktC10YDRgdC40Y8gJXMg0L3QsCDigJ4lc+KAnCAiCiAi0LUg0L7RgdGC0LDQstC10L3QsCDQsiDQtNGK0YDQstC+0YLQvi4iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE0NjQKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE0ODcKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkNPTkZMSUNUICglcy9kZWxldGUpOiAlcyBkZWxldGVkIGluICVzIGFuZCAlcyB0byAlcyBpbiAlcy4gVmVyc2lvbiAlcyBvZiAlcyAiCkBAIC00MDA2LDcgKzQwMzEsNyBAQAogItCa0J7QndCk0JvQmNCa0KIgKCVzL9C40LfRgtGA0LjQstCw0L3QtSk6IOKAniVz4oCcINC1INC40LfRgtGA0LjRgiDQsiAlcywg0LAg4oCeJXPigJwg0LUg0L/RgNC10LjQvNC10L3Rg9Cy0LDQvSDQvdCwIOKAniVz4oCcINCyICIKICIlcy4gINCS0LXRgNGB0LjRjyAlcyDQvdCwIOKAniVz4oCcINC1INC+0YHRgtCw0LLQtdC90LAg0LIg0LTRitGA0LLQvtGC0L4uIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxNDcxCisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxNDk0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJDT05GTElDVCAoJXMvZGVsZXRlKTogJXMgZGVsZXRlZCBpbiAlcyBhbmQgJXMgaW4gJXMuIFZlcnNpb24gJXMgb2YgJXMgbGVmdCAiCkBAIC00MDE1LDcgKzQwNDAsNyBAQAogItCa0J7QndCk0JvQmNCa0KIgKCVzL9C40LfRgtGA0LjQstCw0L3QtSk6IOKAniVz4oCcINC1INC40LfRgtGA0LjRgiDQsiAlcywg0LAg4oCeJXPigJwg0LIgJXMuICDQktC10YDRgdC40Y8gJXMg0L3QsCDigJ4lc+KAnCAiCiAi0LUg0L7RgdGC0LDQstC10L3QsCDQsiDQtNGK0YDQstC+0YLQvjogJXMuIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxNDc2CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxNDk5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJDT05GTElDVCAoJXMvZGVsZXRlKTogJXMgZGVsZXRlZCBpbiAlcyBhbmQgJXMgdG8gJXMgaW4gJXMuIFZlcnNpb24gJXMgb2YgJXMgIgpAQCAtNDAyNCw0NSArNDA0OSw0NSBAQAogItCa0J7QndCk0JvQmNCa0KIgKCVzL9C40LfRgtGA0LjQstCw0L3QtSk6IOKAniVz4oCcINC1INC40LfRgtGA0LjRgiDQsiAlcywg0LAg4oCeJXPigJwg0LUg0L/RgNC10LjQvNC10L3Rg9Cy0LDQvSDQvdCwIOKAniVz4oCcINCyICIKICIlcy4gINCS0LXRgNGB0LjRjyAlcyDQvdCwIOKAniVz4oCcINC1INC+0YHRgtCw0LLQtdC90LAg0LIg0LTRitGA0LLQvtGC0L46ICVzLiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTUxMQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTUzNAogbXNnaWQgInJlbmFtZSIKIG1zZ3N0ciAi0L/RgNC10LjQvNC10L3Rg9Cy0LDQvdC1IgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxNTExCisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxNTM0CiBtc2dpZCAicmVuYW1lZCIKIG1zZ3N0ciAi0L/RgNC10LjQvNC10L3Rg9Cy0LDQvSIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTU5MSBtZXJnZS1yZWN1cnNpdmUuYzoyNDUwIG1lcmdlLXJlY3Vyc2l2ZS5jOjMwOTQKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE2MTQgbWVyZ2UtcmVjdXJzaXZlLmM6MjQ3MiBtZXJnZS1yZWN1cnNpdmUuYzozMTE3CiAjLCBjLWZvcm1hdAogbXNnaWQgIlJlZnVzaW5nIHRvIGxvc2UgZGlydHkgZmlsZSBhdCAlcyIKIG1zZ3N0ciAi0J/RgNC10YPRgdGC0LDQvdC+0LLRj9Cy0LDQvdC1INC90LAg0LTQtdC50YHRgtCy0LjQtdGC0L4sINC30LAg0LTQsCDQvdC1INGB0LUg0LjQt9Cz0YPQsdC4INC/0YDQvtC80LXQvdC10L3QuNGP0YIg4oCeJXPigJwiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE2MDEKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE2MjQKICMsIGMtZm9ybWF0CiBtc2dpZCAiUmVmdXNpbmcgdG8gbG9zZSB1bnRyYWNrZWQgZmlsZSBhdCAlcywgZXZlbiB0aG91Z2ggaXQncyBpbiB0aGUgd2F5LiIKIG1zZ3N0ciAiIgogItCe0YLQutCw0Lcg0LTQsCDRgdC1INC30LDQs9GD0LHQuCDQvdC10YHQu9C10LTQtdC90LjRj9GCINGE0LDQudC7IOKAniVz4oCcLCDQt9Cw0YnQvtGC0L4g0LUg0L3QsCDQvNGP0YHRgtC+LCDQutGK0LTQtdGC0L4g0L/RgNC10YfQuC4iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE2NTkKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE2ODIKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ09ORkxJQ1QgKHJlbmFtZS9hZGQpOiBSZW5hbWUgJXMtPiVzIGluICVzLiAgQWRkZWQgJXMgaW4gJXMiCiBtc2dzdHIgIiIKICLQmtCe0J3QpNCb0JjQmtCiICjQv9GA0LXQuNC80LXQvdGD0LLQsNC90LUv0LTQvtCx0LDQstGP0L3QtSk6IOKAniVz4oCcINC1INC/0YDQtdC40LzQtdC90YPQstCw0L0g0L3QsCDigJ4lc+KAnCDQsiDQutC70L7QvSDigJ4lc+KAnCwg0LAgIgogIuKAniVz4oCcINC1INC00L7QsdCw0LLQtdC9INCyIOKAniVz4oCcIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxNjkwCisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxNzEzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIGlzIGEgZGlyZWN0b3J5IGluICVzIGFkZGluZyBhcyAlcyBpbnN0ZWFkIgogbXNnc3RyICLigJ4lc+KAnCDQtSDQtNC40YDQtdC60YLQvtGA0LjRjyDQsiDigJ4lc+KAnCwg0LfQsNGC0L7QstCwINGB0LUg0LTQvtCx0LDQstGPINC60LDRgtC+IOKAniVz4oCcIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxNjk1CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxNzE4CiAjLCBjLWZvcm1hdAogbXNnaWQgIlJlZnVzaW5nIHRvIGxvc2UgdW50cmFja2VkIGZpbGUgYXQgJXM7IGFkZGluZyBhcyAlcyBpbnN0ZWFkIgogbXNnc3RyICIiCiAi0J/RgNC10YPRgdGC0LDQvdC+0LLRj9Cy0LDQvdC1INC90LAg0LTQtdC50YHRgtCy0LjQtdGC0L4sINC30LAg0LTQsCDQvdC1INGB0LUg0LjQt9Cz0YPQsdC4INC90LXRgdC70LXQtNC10L3QuNGP0YIg0YTQsNC50Lsg4oCeJXPigJwuICAiCiAi0JLQvNC10YHRgtC+INC90LXQs9C+INGB0LUg0LTQvtCx0LDQstGPIOKAniVz4oCcIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxNzE0CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxNzM3CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJDT05GTElDVCAocmVuYW1lL3JlbmFtZSk6IFJlbmFtZSBcIiVzXCItPlwiJXNcIiBpbiBicmFuY2ggXCIlc1wiIHJlbmFtZSBcIiVzIgpAQCAtNDA3MSwxOCArNDA5NiwxOCBAQAogItCa0J7QndCk0JvQmNCa0KIgKNC/0YDQtdC40LzQtdC90YPQstCw0L3QtS/Qv9GA0LXQuNC80LXQvdGD0LLQsNC90LUpOiDigJ4lc+KAnCDQtSDQv9GA0LXQuNC80LXQvdGD0LLQsNC9INC90LAg4oCeJXPigJwg0LIg0LrQu9C+0L0gIgogIuKAniVz4oCcLCDQsCDigJ4lc+KAnCDQtSDQv9GA0LXQuNC80LXQvdGD0LLQsNC9INC90LAg4oCeJXPigJwg0LIg4oCeJXPigJwvJXMuIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxNzE5CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxNzQyCiBtc2dpZCAiIChsZWZ0IHVucmVzb2x2ZWQpIgogbXNnc3RyICIgKNC90LXQutC+0YDQuNCz0LjRgNCw0L0g0LrQvtC90YTQu9C40LrRgikiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE4MjgKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE4NTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ09ORkxJQ1QgKHJlbmFtZS9yZW5hbWUpOiBSZW5hbWUgJXMtPiVzIGluICVzLiBSZW5hbWUgJXMtPiVzIGluICVzIgogbXNnc3RyICIiCiAi0JrQntCd0KTQm9CY0JrQoiAo0L/RgNC10LjQvNC10L3Rg9Cy0LDQvdC1L9C/0YDQtdC40LzQtdC90YPQstCw0L3QtSk6IOKAniVz4oCcINC1INC/0YDQtdC40LzQtdC90YPQstCw0L0g0L3QsCDigJ4lc+KAnCDQsiDQutC70L7QvSAiCiAi4oCeJXPigJwsINCwIOKAniVz4oCcINC1INC/0YDQtdC40LzQtdC90YPQstCw0L0g0L3QsCDigJ4lc+KAnCDQsiDigJ4lc+KAnCIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MjAzNQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MjA1NgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiQ09ORkxJQ1QgKGRpcmVjdG9yeSByZW5hbWUgc3BsaXQpOiBVbmNsZWFyIHdoZXJlIHRvIHBsYWNlICVzIGJlY2F1c2UgIgpAQCAtNDA5Myw3ICs0MTE4LDcgQEAKICLQv9C+0YHRgtCw0LLQuCDigJ4lc+KAnCwg0LfQsNGJ0L7RgtC+INC90Y/QutC+0LvQutC+INC90L7QstC4INC00LjRgNC10LrRgtC+0YDQuNC4INC/0L7QtNC10LvRj9GCINGB0YrQtNGK0YDQttCw0L3QuNC10YLQviDQvdCwICIKICLQtNC40YDQtdC60YLQvtGA0LjRjyDigJ4lc+KAnCwg0LrQsNGC0L4g0L3QuNC60L7RjyDQvdC1INGB0YrQtNGK0YDQttCwINC80L3QvtC30LjQvdGB0YLQstC+INC+0YIg0YTQsNC50LvQvtCy0LXRgtC1INGdLiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MjA2NworIzogbWVyZ2UtcmVjdXJzaXZlLmM6MjA4OAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiQ09ORkxJQ1QgKGltcGxpY2l0IGRpciByZW5hbWUpOiBFeGlzdGluZyBmaWxlL2RpciBhdCAlcyBpbiB0aGUgd2F5IG9mICIKQEAgLTQxMDIsNyArNDEyNyw3IEBACiAi0JrQntCd0KTQm9CY0JrQoiAo0LrQvtGB0LLQtdC90L4g0L/RgNC10LjQvNC10L3Rg9Cy0LDQvdC1INC90LAg0LTQuNGA0LXQutGC0L7RgNC40Y8pOiDRgdC70LXQtNC90LjRj9GCINGE0LDQudC7INC40LvQuCDQtNC40YDQtdC60YLQvtGA0LjRjyAiCiAi4oCeJXPigJwg0L3QtSDQv9C+0LfQstC+0LvRj9Cy0LDRgiDQutC+0YHQstC10L3QvtGC0L4g0L/RgNC10LjQvNC10L3Rg9Cy0LDQvdC1INC90LAg0YHQu9C10LTQvdC40Y8g0L/RitGCL9C40YnQsDogJXMuIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoyMDc3CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoyMDk4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJDT05GTElDVCAoaW1wbGljaXQgZGlyIHJlbmFtZSk6IENhbm5vdCBtYXAgbW9yZSB0aGFuIG9uZSBwYXRoIHRvICVzOyAiCkBAIC00MTEyLDcgKzQxMzcsNyBAQAogItGB0YrQvtGC0LLQtdGC0YHRgtCy0LAg0L3QsCDigJ4lc+KAnC4gINCa0L7RgdCy0LXQvdC+INC/0YDQtdC40LzQtdC90YPQstCw0L3QtSDQvdCwINC00LjRgNC10LrRgtC+0YDQuNGPINCy0L7QtNC4INC00L4g0L/QvtGB0YLQsNCy0Y/QvdC10YLQviAiCiAi0L3QsCDRgtC10LfQuCDQv9GK0YLQuNGJ0LAg0YLQsNC8OiAlcy4iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjIxNjkKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjIxOTAKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkNPTkZMSUNUIChyZW5hbWUvcmVuYW1lKTogUmVuYW1lIGRpcmVjdG9yeSAlcy0+JXMgaW4gJXMuIFJlbmFtZSBkaXJlY3RvcnkgJXMtIgpAQCAtNDEyMSw3ICs0MTQ2LDcgQEAKICLQmtCe0J3QpNCb0JjQmtCiICjQv9GA0LXQuNC80LXQvdGD0LLQsNC90LUv0L/RgNC10LjQvNC10L3Rg9Cy0LDQvdC1KTog4oCeJXPigJwg0LUg0L/RgNC10LjQvNC10L3Rg9Cy0LDQvSDQvdCwIOKAniVz4oCcINCyINC60LvQvtC9ICIKICLigJ4lc+KAnCwg0LAg4oCeJXPigJwg0LUg0L/RgNC10LjQvNC10L3Rg9Cy0LDQvSDQvdCwIOKAniVz4oCcINCyIOKAniVz4oCcIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoyNDEzCisjOiBtZXJnZS1yZWN1cnNpdmUuYzoyNDM1CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJXQVJOSU5HOiBBdm9pZGluZyBhcHBseWluZyAlcyAtPiAlcyByZW5hbWUgdG8gJXMsIGJlY2F1c2UgJXMgaXRzZWxmIHdhcyAiCkBAIC00MTMwLDUyICs0MTU1LDUyIEBACiAi0J/QoNCV0JTQo9Cf0KDQldCW0JTQldCd0JjQlTog0L/RgNC10YHQutCw0YfQsNC90LUg0L3QsCDQv9GA0LXQuNC80LXQvdGD0LLQsNC90LXRgtC+INC90LAg4oCeJXPigJwg0L3QsCDigJ4lc+KAnCDQsiDigJ4lc+KAnCwg0LfQsNGJ0L7RgtC+ICIKICLigJ4lc+KAnCDRgdGK0YnQviDQtSDRgSDQv9GA0L7QvNC10L3QtdC90L4g0LjQvNC1LiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MjkzOAorIzogbWVyZ2UtcmVjdXJzaXZlLmM6Mjk2MQogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgcmVhZCBvYmplY3QgJXMiCiBtc2dzdHIgItC+0LHQtdC60YLRitGCIOKAniVz4oCcINC90LUg0LzQvtC20LUg0LTQsCDRgdC1INC/0YDQvtGH0LXRgtC1IgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoyOTQxCisjOiBtZXJnZS1yZWN1cnNpdmUuYzoyOTY0CiAjLCBjLWZvcm1hdAogbXNnaWQgIm9iamVjdCAlcyBpcyBub3QgYSBibG9iIgogbXNnc3RyICLQvtCx0LXQutGC0YrRgiDigJ4lc+KAnCDQvdC1INC1IEJMT0IiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMwMDUKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMwMjgKIG1zZ2lkICJtb2RpZnkiCiBtc2dzdHIgItC/0YDQvtC80Y/QvdCwIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozMDA1CisjOiBtZXJnZS1yZWN1cnNpdmUuYzozMDI4CiBtc2dpZCAibW9kaWZpZWQiCiBtc2dzdHIgItC/0YDQvtC80LXQvdC10L0iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMwMTcKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMwNDAKIG1zZ2lkICJjb250ZW50IgogbXNnc3RyICLRgdGK0LTRitGA0LbQsNC90LjQtSIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzAyMQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzA0NAogbXNnaWQgImFkZC9hZGQiCiBtc2dzdHIgItC00L7QsdCw0LLRj9C90LUv0LTQvtCx0LDQstGP0L3QtSIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzA0NAorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzA2NwogIywgYy1mb3JtYXQKIG1zZ2lkICJTa2lwcGVkICVzIChtZXJnZWQgc2FtZSBhcyBleGlzdGluZykiCiBtc2dzdHIgItCf0YDQtdGB0LrQsNGH0LDQvdC1INC90LAg4oCeJXPigJwgKNGB0LvQtdGC0LjRj9GCINGA0LXQt9GD0LvRgtCw0YIg0LUg0LjQtNC10L3RgtC40YfQtdC9INGB0YrRgSDRgdC10LPQsNGI0L3QuNGPKSIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzA2NiBnaXQtc3VibW9kdWxlLnNoOjkzNworIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzA4OSBnaXQtc3VibW9kdWxlLnNoOjkzNwogbXNnaWQgInN1Ym1vZHVsZSIKIG1zZ3N0ciAi0J/QntCU0JzQntCU0KPQmyIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzA2NworIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzA5MAogIywgYy1mb3JtYXQKIG1zZ2lkICJDT05GTElDVCAoJXMpOiBNZXJnZSBjb25mbGljdCBpbiAlcyIKIG1zZ3N0ciAi0JrQntCd0KTQm9CY0JrQoiAoJXMpOiDQmtC+0L3RhNC70LjQutGCINC/0YDQuCDRgdC70LjQstCw0L3QtSDQvdCwIOKAniVz4oCcIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozMDk3CisjOiBtZXJnZS1yZWN1cnNpdmUuYzozMTIwCiAjLCBjLWZvcm1hdAogbXNnaWQgIkFkZGluZyBhcyAlcyBpbnN0ZWFkIgogbXNnc3RyICLQlNC+0LHQsNCy0Y/QvdC1INC60LDRgtC+IOKAniVz4oCcIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozMTc5CisjOiBtZXJnZS1yZWN1cnNpdmUuYzozMjAzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJQYXRoIHVwZGF0ZWQ6ICVzIGFkZGVkIGluICVzIGluc2lkZSBhIGRpcmVjdG9yeSB0aGF0IHdhcyByZW5hbWVkIGluICVzOyAiCkBAIC00MTg0LDcgKzQyMDksNyBAQAogItCe0LHQvdC+0LLQtdC9INC/0YrRgjog4oCeJXPigJwg0LUg0LTQvtCx0LDQstC10L0g0LIg4oCeJXPigJwg0LIg0LTQuNGA0LXQutGC0L7RgNC40Y8sINC60L7Rj9GC0L4g0LUg0L/RgNC10LjQvNC10L3Rg9Cy0LDQvdCwINCyICIKICLigJ4lc+KAnC4gINCe0LHQtdC60YLRitGCINGB0LUg0LzQtdGB0YLQuCDQsiDigJ4lc+KAnC4iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMxODIKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMyMDYKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkNPTkZMSUNUIChmaWxlIGxvY2F0aW9uKTogJXMgYWRkZWQgaW4gJXMgaW5zaWRlIGEgZGlyZWN0b3J5IHRoYXQgd2FzIHJlbmFtZWQgIgpAQCAtNDE5Myw3ICs0MjE4LDcgQEAKICLQmtCe0J3QpNCb0JjQmtCiICjQvNC10YHRgtCwINC90LAg0YTQsNC50LvQvtCy0LUpOiDigJ4lc+KAnCDQtSDQtNC+0LHQsNCy0LXQvSDQsiDigJ4lc+KAnCDQsiDQtNC40YDQtdC60YLQvtGA0LjRjywg0LrQvtGP0YLQviDQtSAiCiAi0L/RgNC10LjQvNC10L3Rg9Cy0LDQvdCwINCyIOKAniVz4oCcLiAg0J/RgNC10LTQu9C+0LbQtdC90LjQtdGC0L4g0LUg0LTQsCDQv9GA0LXQvNC10YHRgtC40YLQtSDQvtCx0LXQutGC0LAg0LIg4oCeJXPigJwuIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozMTg2CisjOiBtZXJnZS1yZWN1cnNpdmUuYzozMjEwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJQYXRoIHVwZGF0ZWQ6ICVzIHJlbmFtZWQgdG8gJXMgaW4gJXMsIGluc2lkZSBhIGRpcmVjdG9yeSB0aGF0IHdhcyByZW5hbWVkIGluICIKQEAgLTQyMDIsNyArNDIyNyw3IEBACiAi0J7QsdC90L7QstC10L0g0L/RitGCOiDigJ4lc+KAnCDQtSDQv9GA0LXQuNC80LXQvdGD0LLQsNC9INC90LAg4oCeJXPigJwg0LIg4oCeJXPigJwg0LIg0LTQuNGA0LXQutGC0L7RgNC40Y8sINC60L7Rj9GC0L4g0LUgIgogItC/0YDQtdC40LzQtdC90YPQstCw0L3QsCDQsiDigJ4lc+KAnC4gINCe0LHQtdC60YLRitGCINGB0LUg0LzQtdGB0YLQuCDQsiDigJ4lc+KAnC4iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMxODkKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMyMTMKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkNPTkZMSUNUIChmaWxlIGxvY2F0aW9uKTogJXMgcmVuYW1lZCB0byAlcyBpbiAlcywgaW5zaWRlIGEgZGlyZWN0b3J5IHRoYXQgIgpAQCAtNDIxMSwzNyArNDIzNiw2MSBAQAogItCa0J7QndCk0JvQmNCa0KIgKNC80LXRgdGC0LAg0L3QsCDRhNCw0LnQu9C+0LLQtSk6IOKAniVz4oCcINC1INC/0YDQtdC40LzQtdC90YPQstCw0L0g0L3QsCDigJ4lc+KAnCDQsiDigJ4lc+KAnCDQsiDQtNC40YDQtdC60YLQvtGA0LjRjywgIgogItC60L7Rj9GC0L4g0LUg0L/RgNC10LjQvNC10L3Rg9Cy0LDQvdCwINCyIOKAniVz4oCcLiAg0J/RgNC10LTQu9C+0LbQtdC90LjQtdGC0L4g0LUg0LTQsCDQv9GA0LXQvNC10YHRgtC40YLQtSDQvtCx0LXQutGC0LAg0LIg4oCeJXPigJwuIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozMzAzCisjOiBtZXJnZS1yZWN1cnNpdmUuYzozMzI3CiAjLCBjLWZvcm1hdAogbXNnaWQgIlJlbW92aW5nICVzIgogbXNnc3RyICLQmNC30YLRgNC40LLQsNC90LUg0L3QsCDigJ4lc+KAnCIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzMyNgorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzM1MAogbXNnaWQgImZpbGUvZGlyZWN0b3J5IgogbXNnc3RyICLRhNCw0LnQuy/QtNC40YDQtdC60YLQvtGA0LjRjyIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzMzMQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzM1NQogbXNnaWQgImRpcmVjdG9yeS9maWxlIgogbXNnc3RyICLQtNC40YDQtdC60YLQvtGA0LjRjy/RhNCw0LnQuyIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzMzOAorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzM2MgogIywgYy1mb3JtYXQKIG1zZ2lkICJDT05GTElDVCAoJXMpOiBUaGVyZSBpcyBhIGRpcmVjdG9yeSB3aXRoIG5hbWUgJXMgaW4gJXMuIEFkZGluZyAlcyBhcyAlcyIKIG1zZ3N0ciAiIgogItCa0J7QndCk0JvQmNCa0KIgKCVzKTog0KHRitGJ0LXRgdGC0LLRg9Cy0LAg0LTQuNGA0LXQutGC0L7RgNC40Y8g0L3QsCDQuNC80LUg4oCeJXPigJwg0LIg4oCeJXPigJwuICDQlNC+0LHQsNCy0Y/QvdC1INC90LAg4oCeJXPigJwgIgogItC60LDRgtC+IOKAniVz4oCcIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozMzQ3CisjOiBtZXJnZS1yZWN1cnNpdmUuYzozMzcxCiAjLCBjLWZvcm1hdAogbXNnaWQgIkFkZGluZyAlcyIKIG1zZ3N0ciAi0JTQvtCx0LDQstGP0L3QtSDQvdCwIOKAniVz4oCcIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozMzU2CisjOiBtZXJnZS1yZWN1cnNpdmUuYzozMzgwCiAjLCBjLWZvcm1hdAogbXNnaWQgIkNPTkZMSUNUIChhZGQvYWRkKTogTWVyZ2UgY29uZmxpY3QgaW4gJXMiCiBtc2dzdHIgItCa0J7QndCk0JvQmNCa0KIgKNC00L7QsdCw0LLRj9C90LUv0LTQvtCx0LDQstGP0L3QtSk6INCa0L7QvdGE0LvQuNC60YIg0L/RgNC4INGB0LvQuNCy0LDQvdC1INC90LAg4oCeJXPigJwiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMzOTQKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjM0MjQKK21zZ2lkICJBbHJlYWR5IHVwIHRvIGRhdGUhIgorbXNnc3RyICLQktC10YfQtSDQtSDQvtCx0L3QvtCy0LXQvdC+ISIKKworIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzQzMworIywgYy1mb3JtYXQKK21zZ2lkICJtZXJnaW5nIG9mIHRyZWVzICVzIGFuZCAlcyBmYWlsZWQiCittc2dzdHIgItC90LXRg9GB0L/QtdGI0L3QviDRgdC70LjQstCw0L3QtSDQvdCwINC00YrRgNCy0LXRgtCw0YLQsCDigJ4lc+KAnCDQuCDigJ4lc+KAnCIKKworIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzUzNworbXNnaWQgIk1lcmdpbmc6IgorbXNnc3RyICLQodC70LjQstCw0L3QtToiCisKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjM1NTAKKyMsIGMtZm9ybWF0Cittc2dpZCAiZm91bmQgJXUgY29tbW9uIGFuY2VzdG9yOiIKK21zZ2lkX3BsdXJhbCAiZm91bmQgJXUgY29tbW9uIGFuY2VzdG9yczoiCittc2dzdHJbMF0gItC+0YLQutGA0LjRgiDQtSAldSDQvtCx0Ykg0L/RgNC10LTRiNC10YHRgtCy0LXQvdC40Lo6IgorbXNnc3RyWzFdICLQvtGC0LrRgNC40YLQuCDRgdCwICV1INC+0LHRidC4INC/0YDQtdC00YjQtdGB0YLQstC10L3QuNGG0Lg6IgorCisjOiBtZXJnZS1yZWN1cnNpdmUuYzozNjAwCittc2dpZCAibWVyZ2UgcmV0dXJuZWQgbm8gY29tbWl0IgorbXNnc3RyICLRgdC70LjQstCw0L3QtdGC0L4g0L3QtSDQstGK0YDQvdCwINC/0L7QtNCw0LLQsNC90LUiCisKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjM2NTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIllvdXIgbG9jYWwgY2hhbmdlcyB0byB0aGUgZm9sbG93aW5nIGZpbGVzIHdvdWxkIGJlIG92ZXJ3cml0dGVuIGJ5IG1lcmdlOlxuIgpAQCAtNDI1MCwxNDAgKzQyOTksMTE2IEBACiAi0KHQu9C40LLQsNC90LXRgtC+INGJ0LUg0L/RgNC10LfQsNC/0LjRiNC1INC70L7QutCw0LvQvdC40YLQtSDQv9GA0L7QvNC10L3QuCDQvdCwINGC0LXQt9C4INGE0LDQudC70L7QstC1OlxuIgogIiAgICAlcyIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzQwNQotbXNnaWQgIkFscmVhZHkgdXAgdG8gZGF0ZSEiCi1tc2dzdHIgItCS0LXRh9C1INC1INC+0LHQvdC+0LLQtdC90L4hIgotCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozNDE0Ci0jLCBjLWZvcm1hdAotbXNnaWQgIm1lcmdpbmcgb2YgdHJlZXMgJXMgYW5kICVzIGZhaWxlZCIKLW1zZ3N0ciAi0L3QtdGD0YHQv9C10YjQvdC+INGB0LvQuNCy0LDQvdC1INC90LAg0LTRitGA0LLQtdGC0LDRgtCwIOKAniVz4oCcINC4IOKAniVz4oCcIgotCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozNTEzCi1tc2dpZCAiTWVyZ2luZzoiCi1tc2dzdHIgItCh0LvQuNCy0LDQvdC1OiIKLQotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzUyNgotIywgYy1mb3JtYXQKLW1zZ2lkICJmb3VuZCAldSBjb21tb24gYW5jZXN0b3I6IgotbXNnaWRfcGx1cmFsICJmb3VuZCAldSBjb21tb24gYW5jZXN0b3JzOiIKLW1zZ3N0clswXSAi0L7RgtC60YDQuNGCINC1ICV1INC+0LHRiSDQv9GA0LXQtNGI0LXRgdGC0LLQtdC90LjQujoiCi1tc2dzdHJbMV0gItC+0YLQutGA0LjRgtC4INGB0LAgJXUg0L7QsdGJ0Lgg0L/RgNC10LTRiNC10YHRgtCy0LXQvdC40YbQuDoiCi0KLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjM1NjUKLW1zZ2lkICJtZXJnZSByZXR1cm5lZCBubyBjb21taXQiCi1tc2dzdHIgItGB0LvQuNCy0LDQvdC10YLQviDQvdC1INCy0YrRgNC90LAg0L/QvtC00LDQstCw0L3QtSIKLQotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzYzMQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6Mzc1NgogIywgYy1mb3JtYXQKIG1zZ2lkICJDb3VsZCBub3QgcGFyc2Ugb2JqZWN0ICclcyciCiBtc2dzdHIgItCd0LXRg9GB0L/QtdGI0LXQvSDQsNC90LDQu9C40Lcg0L3QsCDQvtCx0LXQutGC0LAg4oCeJXPigJwiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjM2NDcgYnVpbHRpbi9tZXJnZS5jOjY5OCBidWlsdGluL21lcmdlLmM6ODY5CisjOiBtZXJnZS1yZWN1cnNpdmUuYzozNzc0IGJ1aWx0aW4vbWVyZ2UuYzo2OTQgYnVpbHRpbi9tZXJnZS5jOjg3NAogbXNnaWQgIlVuYWJsZSB0byB3cml0ZSBpbmRleC4iCiBtc2dzdHIgItCY0L3QtNC10LrRgdGK0YIg0L3QtSDQvNC+0LbQtSDQtNCwINCx0YrQtNC1INC/0YDQvtGH0LXRgtC10L0iCiAKLSM6IG1pZHguYzo2OQorIzogbWlkeC5jOjY4CiAjLCBjLWZvcm1hdAogbXNnaWQgIm11bHRpLXBhY2staW5kZXggZmlsZSAlcyBpcyB0b28gc21hbGwiCiBtc2dzdHIgItGE0LDQudC70YrRgiDRgSDQuNC90LTQtdC60YHQsCDQt9CwINC80L3QvtC20LXRgdGC0LLQviDQv9Cw0LrQtdGC0Lgg4oCeJXPigJwg0LUg0YLQstGK0YDQtNC1INC80LDQu9GK0LoiCiAKLSM6IG1pZHguYzo4NQorIzogbWlkeC5jOjg0CiAjLCBjLWZvcm1hdAogbXNnaWQgIm11bHRpLXBhY2staW5kZXggc2lnbmF0dXJlIDB4JTA4eCBkb2VzIG5vdCBtYXRjaCBzaWduYXR1cmUgMHglMDh4IgogbXNnc3RyICLQvtGC0L/QtdGH0LDRgtGK0LrRitGCINC90LAg0LjQvdC00LXQutGB0LAg0LfQsCDQvNC90L7QttC10YHRgtCy0L4g0L/QsNC60LXRgtC4IDB4JTA4eCDQvdC1INGB0YrQstC/0LDQtNCwINGBIDB4JTA4eCIKIAotIzogbWlkeC5jOjkwCisjOiBtaWR4LmM6ODkKICMsIGMtZm9ybWF0CiBtc2dpZCAibXVsdGktcGFjay1pbmRleCB2ZXJzaW9uICVkIG5vdCByZWNvZ25pemVkIgogbXNnc3RyICLQvdC10L/QvtC30L3QsNGC0LAg0LLQtdGA0YHQuNGPINC90LAg0LjQvdC00LXQutGBINC30LAg0LzQvdC+0LbQtdGB0YLQstC+INC/0LDQutC10YLQuCDigJQgJWQiCiAKLSM6IG1pZHguYzo5NQorIzogbWlkeC5jOjk0CiAjLCBjLWZvcm1hdAogbXNnaWQgImhhc2ggdmVyc2lvbiAldSBkb2VzIG5vdCBtYXRjaCIKIG1zZ3N0ciAi0LLQtdGA0YHQuNGP0YLQsCDQvdCwINC+0YLQv9C10YfQsNGC0YrQutCwICV1INC90LUg0YHRitCy0L/QsNC00LAiCiAKLSM6IG1pZHguYzoxMDkKKyM6IG1pZHguYzoxMDgKIG1zZ2lkICJpbnZhbGlkIGNodW5rIG9mZnNldCAodG9vIGxhcmdlKSIKIG1zZ3N0ciAi0L3QtdC/0YDQsNCy0LjQu9C90L4gKNC/0YDQtdC60LDQu9C10L3QviDQs9C+0LvRj9C80L4pINC+0YLQvNC10YHRgtCy0LDQvdC1INC90LAg0L7RgtC60YrRgSIKIAotIzogbWlkeC5jOjEzMworIzogbWlkeC5jOjEzMgogbXNnaWQgInRlcm1pbmF0aW5nIG11bHRpLXBhY2staW5kZXggY2h1bmsgaWQgYXBwZWFycyBlYXJsaWVyIHRoYW4gZXhwZWN0ZWQiCiBtc2dzdHIgIiIKICLQuNC00LXQvdGC0LjRhNC40LrQsNGC0L7RgNGK0YIg0LfQsCDQutGA0LDQtdC9INC+0YLQutGK0YEg0L3QsCDQuNC90LTQtdC60YEg0LfQsCDQvNC90L7QttC10YHRgtCy0L4g0L/QsNC60LXRgtC4INGB0LUg0Y/QstGP0LLQsCDQv9C+LSIKICLRgNCw0L3QviDQvtGCINC+0YfQsNC60LLQsNC90L7RgtC+IgogCi0jOiBtaWR4LmM6MTQ2CisjOiBtaWR4LmM6MTQ1CiBtc2dpZCAibXVsdGktcGFjay1pbmRleCBtaXNzaW5nIHJlcXVpcmVkIHBhY2stbmFtZSBjaHVuayIKIG1zZ3N0ciAi0LvQuNC/0YHQstCwINC+0YLQutGK0YEgKHBhY2stbmFtZSkg0L7RgiDQuNC90LTQtdC60YEg0LfQsCDQvNC90L7QttC10YHRgtCy0L4g0L/QsNC60LXRgtC4IgogCi0jOiBtaWR4LmM6MTQ4CisjOiBtaWR4LmM6MTQ3CiBtc2dpZCAibXVsdGktcGFjay1pbmRleCBtaXNzaW5nIHJlcXVpcmVkIE9JRCBmYW5vdXQgY2h1bmsiCiBtc2dzdHIgItC70LjQv9GB0LLQsCDQvtGC0LrRitGBIChPSUQgZmFub3V0KSDQvtGCINC40L3QtNC10LrRgSDQt9CwINC80L3QvtC20LXRgdGC0LLQviDQv9Cw0LrQtdGC0LgiCiAKLSM6IG1pZHguYzoxNTAKKyM6IG1pZHguYzoxNDkKIG1zZ2lkICJtdWx0aS1wYWNrLWluZGV4IG1pc3NpbmcgcmVxdWlyZWQgT0lEIGxvb2t1cCBjaHVuayIKIG1zZ3N0ciAi0LvQuNC/0YHQstCwINC+0YLQutGK0YEgKE9JRCBsb29rdXApINC+0YIg0LjQvdC00LXQutGBINC30LAg0LzQvdC+0LbQtdGB0YLQstC+INC/0LDQutC10YLQuCIKIAotIzogbWlkeC5jOjE1MgorIzogbWlkeC5jOjE1MQogbXNnaWQgIm11bHRpLXBhY2staW5kZXggbWlzc2luZyByZXF1aXJlZCBvYmplY3Qgb2Zmc2V0cyBjaHVuayIKIG1zZ3N0ciAi0LvQuNC/0YHQstCwINC+0YLQutGK0YEg0LfQsCDQvtGC0LzQtdGB0YLQstCw0L3QuNGP0YLQsCDQvdCwINC+0LHQtdC60YLQuCDQvtGCINC40L3QtNC10LrRgSDQt9CwINC80L3QvtC20LXRgdGC0LLQviDQv9Cw0LrQtdGC0LgiCiAKLSM6IG1pZHguYzoxNjYKKyM6IG1pZHguYzoxNjUKICMsIGMtZm9ybWF0CiBtc2dpZCAibXVsdGktcGFjay1pbmRleCBwYWNrIG5hbWVzIG91dCBvZiBvcmRlcjogJyVzJyBiZWZvcmUgJyVzJyIKIG1zZ3N0ciAiIgogItC90LXQv9GA0LDQstC40LvQvdCwINC/0L7QtNGA0LXQtNCx0LAg0L3QsCDQuNC80LXQvdCw0YLQsCDQsiDQuNC90LTQtdC60YEg0LfQsCDQvNC90L7QttC10YHRgtCy0L4g0L/QsNC60LXRgtC4OiDigJ4lc+KAnCDRgdC1INC/0L7Rj9Cy0LggIgogItC/0YDQtdC00Lgg4oCeJXPigJwiCiAKLSM6IG1pZHguYzoyMTEKKyM6IG1pZHguYzoyMTAKICMsIGMtZm9ybWF0CiBtc2dpZCAiYmFkIHBhY2staW50LWlkOiAldSAoJXUgdG90YWwgcGFja3MpIgogbXNnc3RyICIiCiAi0L3QtdC/0YDQsNCy0LjQu9C10L0g0LjQtNC10L3RgtC40YTQuNC60LDRgtC+0YAg0L3QsCDQv9Cw0LrQtdGCIChwYWNrLWludC1pZCk6ICV1ICjQvtGCINC+0LHRidC+ICV1INC/0LDQutC10YLQuCkiCiAKLSM6IG1pZHguYzoyNjEKKyM6IG1pZHguYzoyNjAKIG1zZ2lkICJtdWx0aS1wYWNrLWluZGV4IHN0b3JlcyBhIDY0LWJpdCBvZmZzZXQsIGJ1dCBvZmZfdCBpcyB0b28gc21hbGwiCiBtc2dzdHIgIiIKICLQuNC90LTQtdC60YHRitGCINC30LAg0LzQvdC+0LbQtdGB0YLQstC+INC/0LDQutC10YLQuCDRgdGK0LTRitGA0LbQsCA2NC3QsdC40YLQvtCy0Lgg0L7RgtC80LXRgdGC0LLQsNC90LjRjywg0L3QviDRgNCw0LfQvNC10YDRitGCINC90LAgIgogIuKAnm9mZl904oCcINC1INC90LXQtNC+0YHRgtCw0YLRitGH0LXQvSIKIAotIzogbWlkeC5jOjI4OQorIzogbWlkeC5jOjI4OAogbXNnaWQgImVycm9yIHByZXBhcmluZyBwYWNrZmlsZSBmcm9tIG11bHRpLXBhY2staW5kZXgiCiBtc2dzdHIgIiIKICLQs9GA0LXRiNC60LAg0L/RgNC4INGB0YrQt9C00LDQstCw0L3QtdGC0L4g0L3QsCDQv9Cw0LrQtdGC0LXQvSDRhNCw0LnQuyDQvdCwINCx0LDQt9Cw0YLQsCDQvdCwINC40L3QtNC10LrRgSDQt9CwINC80L3QvtC20LXRgdGC0LLQviAiCiAi0L/QsNC60LXRgtC4IgogCi0jOiBtaWR4LmM6NDcwCisjOiBtaWR4LmM6NDY5CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBhZGQgcGFja2ZpbGUgJyVzJyIKIG1zZ3N0ciAi0L/QsNC60LXRgtC90LjRj9GCINGE0LDQudC7IOKAniVz4oCcINC90LUg0LzQvtC20LUg0LTQsCDQsdGK0LTQtSDQtNC+0LHQsNCy0LXQvSIKIAotIzogbWlkeC5jOjQ3NgorIzogbWlkeC5jOjQ3NQogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gb3BlbiBwYWNrLWluZGV4ICclcyciCiBtc2dzdHIgItC40L3QtNC10LrRgdGK0YIg0LfQsCDQv9Cw0LrQtdGC0Lgg4oCeJXPigJwg0L3QtSDQvNC+0LbQtSDQtNCwINCx0YrQtNC1INC+0YLQstC+0YDQtdC9IgogCi0jOiBtaWR4LmM6NTM2CisjOiBtaWR4LmM6NTM1CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBsb2NhdGUgb2JqZWN0ICVkIGluIHBhY2tmaWxlIgogbXNnc3RyICLQvtCx0LXQutGCICVkINCyINC/0LDQutC10YLQvdC40Y8g0YTQsNC50Lsg0LvQuNC/0YHQstCwIgogCi0jOiBtaWR4LmM6ODY1CisjOiBtaWR4LmM6ODY0CiAjLCBjLWZvcm1hdAogbXNnaWQgImRpZCBub3Qgc2VlIHBhY2stZmlsZSAlcyB0byBkcm9wIgogbXNnc3RyICLQv9Cw0LrQtdGC0L3QuNGP0YIg0YTQsNC50Lsg0LfQsCDRgtGA0LjQtdC90LUg4oCeJXPigJwg0L3QtSDQvNC+0LbQtSDQtNCwINGB0LUg0L7RgtC60YDQuNC1IgogCi0jOiBtaWR4LmM6MTAzNgorIzogbWlkeC5jOjEwMzUKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIGNsZWFyIG11bHRpLXBhY2staW5kZXggYXQgJXMiCiBtc2dzdHIgItC40L3QtNC10LrRgdGK0YIg0LfQsCDQvNC90L7QttC10YHRgtCy0L4g0L/QsNC60LXRgtC4INC90LUg0LzQvtC20LUg0LTQsCDQsdGK0LTQtSDQuNC30YfQuNGB0YLQtdC9INC/0YDQuCDigJ4lc+KAnCIKIAotIzogbWlkeC5jOjEwOTEKKyM6IG1pZHguYzoxMDkwCiBtc2dpZCAiTG9va2luZyBmb3IgcmVmZXJlbmNlZCBwYWNrZmlsZXMiCiBtc2dzdHIgItCi0YrRgNGB0LXQvdC1INC90LAg0YPQutCw0LfQsNC90LjRgtC1INC/0LDQutC10YLQvdC4INGE0LDQudC70L7QstC1IgogCi0jOiBtaWR4LmM6MTEwNgorIzogbWlkeC5jOjExMDUKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIm9pZCBmYW5vdXQgb3V0IG9mIG9yZGVyOiBmYW5vdXRbJWRdID0gJTxQUkl4MzI+ID4gJTxQUkl4MzI+ID0gZmFub3V0WyVkXSIKQEAgLTQzOTEsNjAgKzQ0MTYsNjAgQEAKICLQvdC10L/RgNCw0LLQuNC70L3QsCDQv9C+0LTRgNC10LTQsdCwINC90LAg0L7RgtC60YrRgdC4IChPSUQgZmFub3V0KTogZmFub3V0WyVkXSA9ICU8UFJJeDMyPiA+ICIKICIlPFBSSXgzMj4gPSBmYW5vdXRbJWRdIgogCi0jOiBtaWR4LmM6MTExMAorIzogbWlkeC5jOjExMDkKIG1zZ2lkICJWZXJpZnlpbmcgT0lEIG9yZGVyIGluIE1JRFgiCiBtc2dzdHIgIiIKICLQn9GA0L7QstC10YDQutCwINC90LAg0L/QvtC00YDQtdC00LHQsNGC0LAg0L3QsCDQuNC00LXQvdGC0LjRhNC40LrQsNGC0L7RgNC4INC90LAg0L7QsdC10LrRgtC4INCyIE1JRFggKNGE0LDQudC7INGBINC40L3QtNC10LrRgSDQutGK0LwgIgogItC80L3QvtC20LXRgdGC0LLQviDQv9Cw0LrQtdGC0L3QuCDRhNCw0LnQu9C+0LLQtSkiCiAKLSM6IG1pZHguYzoxMTE5CisjOiBtaWR4LmM6MTExOAogIywgYy1mb3JtYXQKIG1zZ2lkICJvaWQgbG9va3VwIG91dCBvZiBvcmRlcjogb2lkWyVkXSA9ICVzID49ICVzID0gb2lkWyVkXSIKIG1zZ3N0ciAiIgogItC90LXQv9GA0LDQstC40LvQvdCwINC/0L7QtNGA0LXQtNCx0LAg0L3QsCDQvtGC0LrRitGB0LggKE9JRCBsb29rdXApOiBvaWRbJWRdID0gJXMgPj0gJXMgPSBvaWRbJWRdIgogCi0jOiBtaWR4LmM6MTEzOAorIzogbWlkeC5jOjExMzcKIG1zZ2lkICJTb3J0aW5nIG9iamVjdHMgYnkgcGFja2ZpbGUiCiBtc2dzdHIgItCf0L7QtNGA0LXQtNCx0LAg0L3QsCDQvtCx0LXQutGC0LjRgtC1INC/0L4g0L/QsNC60LXRgtC90Lgg0YTQsNC50LvQvtCy0LUiCiAKLSM6IG1pZHguYzoxMTQ0CisjOiBtaWR4LmM6MTE0MwogbXNnaWQgIlZlcmlmeWluZyBvYmplY3Qgb2Zmc2V0cyIKIG1zZ3N0ciAi0J/RgNC+0LLQtdGA0LrQsCDQvdCwINC+0YLQvNC10YHRgtCy0LDQvdC10YLQviDQvdCwINC+0LHQtdC60YLQuCIKIAotIzogbWlkeC5jOjExNjAKKyM6IG1pZHguYzoxMTU5CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBsb2FkIHBhY2sgZW50cnkgZm9yIG9pZFslZF0gPSAlcyIKIG1zZ3N0ciAi0LfQsNC/0LjRgdGK0YIg0LIg0L/QsNC60LXRgtCwINC30LAg0L7QsdC10LrRgtCwIG9pZFslZF0gPSAlcyDQvdC1INC80L7QttC1INC00LAg0LHRitC00LUg0LfQsNGA0LXQtNC10L0iCiAKLSM6IG1pZHguYzoxMTY2CisjOiBtaWR4LmM6MTE2NQogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gbG9hZCBwYWNrLWluZGV4IGZvciBwYWNrZmlsZSAlcyIKIG1zZ3N0ciAi0LjQvdC00LXQutGB0YrRgiDQvdCwINC/0LDQutC10YLQsCDigJ4lc+KAnCDQvdC1INC80L7QttC1INC00LAg0LHRitC00LUg0LfQsNGA0LXQtNC10L0iCiAKLSM6IG1pZHguYzoxMTc1CisjOiBtaWR4LmM6MTE3NAogIywgYy1mb3JtYXQKIG1zZ2lkICJpbmNvcnJlY3Qgb2JqZWN0IG9mZnNldCBmb3Igb2lkWyVkXSA9ICVzOiAlPFBSSXg2ND4gIT0gJTxQUkl4NjQ+IgogbXNnc3RyICLQvdC10L/RgNCw0LLQuNC70L3QviDQvtGC0LzQtdGB0YLQstCw0L3QtSDQvdCwINC+0LHQtdC60YIg0LfQsCBvaWRbJWRdID0gJXM6ICU8UFJJeDY0PiAhPSAlPFBSSXg2ND4iCiAKLSM6IG1pZHguYzoxMzUwCisjOiBtaWR4LmM6MTM0OQogbXNnaWQgImNvdWxkIG5vdCBzdGFydCBwYWNrLW9iamVjdHMiCiBtc2dzdHIgItC60L7QvNCw0L3QtNCw0YLQsCDigJ5wYWNrLW9iamVjdHPigJwg0L3QtSDQvNC+0LbQtSDQtNCwINCx0YrQtNC1INGB0YLQsNGA0YLQuNGA0LDQvdCwIgogCi0jOiBtaWR4LmM6MTM2OQorIzogbWlkeC5jOjEzNjgKIG1zZ2lkICJjb3VsZCBub3QgZmluaXNoIHBhY2stb2JqZWN0cyIKIG1zZ3N0ciAi0LrQvtC80LDQvdC00LDRgtCwIOKAnnBhY2stb2JqZWN0c+KAnCDQvdC1INC80L7QttC1INC00LAg0LHRitC00LUg0LfQsNCy0YrRgNGI0LXQvdCwIgogCi0jOiBuYW1lLWhhc2guYzo1MzIKKyM6IG5hbWUtaGFzaC5jOjUzNwogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gY3JlYXRlIGxhenlfZGlyIHRocmVhZDogJXMiCiBtc2dzdHIgItC90LUg0LzQvtC20LUg0LTQsCDRgdC1INGB0YrQt9C00LDQtNC1INC90LjRiNC60LAg0LfQsCDQtNC40YDQtdC60YLQvtGA0LjQuDogJXMiCiAKLSM6IG5hbWUtaGFzaC5jOjU1NAorIzogbmFtZS1oYXNoLmM6NTU5CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBjcmVhdGUgbGF6eV9uYW1lIHRocmVhZDogJXMiCiBtc2dzdHIgItC90LUg0LzQvtC20LUg0LTQsCDRgdC1INGB0YrQt9C00LDQtNC1INC90LjRiNC60LAg0LfQsCDQuNC80LXQvdCwOiAlcyIKIAotIzogbmFtZS1oYXNoLmM6NTYwCisjOiBuYW1lLWhhc2guYzo1NjUKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGpvaW4gbGF6eV9uYW1lIHRocmVhZDogJXMiCiBtc2dzdHIgItC90LUg0LzQvtC20LUg0LTQsCDRgdC1INC40LfRh9Cw0LrQsCDQvdC40YjQutCwINC30LAg0LjQvNC10L3QsDogJXMiCkBAIC00NDk3LDQ0ICs0NTIyLDQ0IEBACiBtc2dpZCAiQmFkICVzIHZhbHVlOiAnJXMnIgogbXNnc3RyICLQl9Cw0LTQsNC00LXQvdCwINC1INC70L7RiNCwINGB0YLQvtC50L3QvtGB0YIg0L3QsCDQv9GA0L7QvNC10L3Qu9C40LLQsNGC0LAg4oCeJXPigJw6IOKAniVz4oCcIgogCi0jOiBvYmplY3QuYzo1NAorIzogb2JqZWN0LmM6NTMKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBvYmplY3QgdHlwZSBcIiVzXCIiCiBtc2dzdHIgItC90LXQv9GA0LDQstC40LvQtdC9INCy0LjQtCDQvtCx0LXQutGCOiDigJ4lc+KAnCIKIAotIzogb2JqZWN0LmM6MTc0CisjOiBvYmplY3QuYzoxNzMKICMsIGMtZm9ybWF0CiBtc2dpZCAib2JqZWN0ICVzIGlzIGEgJXMsIG5vdCBhICVzIgogbXNnc3RyICLQvtCx0LXQutGC0YrRgiDigJ4lc+KAnCDQtSAlcywg0LAg0L3QtSAlcyIKIAotIzogb2JqZWN0LmM6MjM0CisjOiBvYmplY3QuYzoyMzMKICMsIGMtZm9ybWF0CiBtc2dpZCAib2JqZWN0ICVzIGhhcyB1bmtub3duIHR5cGUgaWQgJWQiCiBtc2dzdHIgItC+0LHQtdC60YLRitGCIOKAniVz4oCcINC1INC90LXQv9C+0LfQvdCw0YIg0LLQuNC0OiAlZCIKIAotIzogb2JqZWN0LmM6MjQ3CisjOiBvYmplY3QuYzoyNDYKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHBhcnNlIG9iamVjdDogJXMiCiBtc2dzdHIgItC+0LHQtdC60YLRitGCIOKAniVz4oCcINC90LUg0LzQvtC20LUg0LTQsCDQsdGK0LTQtSDQsNC90LDQu9C40LfQuNGA0LDQvSIKIAotIzogb2JqZWN0LmM6MjY3IG9iamVjdC5jOjI3OAorIzogb2JqZWN0LmM6MjY2IG9iamVjdC5jOjI3NwogIywgYy1mb3JtYXQKIG1zZ2lkICJoYXNoIG1pc21hdGNoICVzIgogbXNnc3RyICLRgNCw0LfQu9C40LrQsCDQsiDQutC+0L3RgtGA0L7Qu9C90LDRgtCwINGB0YPQvNCwOiDigJ4lc+KAnCIKIAotIzogcGFja2ZpbGUuYzo2NDgKKyM6IHBhY2tmaWxlLmM6NjQxCiBtc2dpZCAib2Zmc2V0IGJlZm9yZSBlbmQgb2YgcGFja2ZpbGUgKGJyb2tlbiAuaWR4PykiCiBtc2dzdHIgIiIKICLQvtGC0LzQtdGB0YLQstCw0L3QtSDQv9GA0LXQtNC4INC60YDQsNGPINC90LAg0L/QsNC60LXRgtC90LjRjyDRhNCw0LnQuyAo0LLRitC30LzQvtC20L3QviDQtSDQuNC90LTQtdC60YHRitGCINC00LAg0LUg0L/QvtCy0YDQtdC00LXQvSkiCiAKLSM6IHBhY2tmaWxlLmM6MTg5OQorIzogcGFja2ZpbGUuYzoxODg3CiAjLCBjLWZvcm1hdAogbXNnaWQgIm9mZnNldCBiZWZvcmUgc3RhcnQgb2YgcGFjayBpbmRleCBmb3IgJXMgKGNvcnJ1cHQgaW5kZXg/KSIKIG1zZ3N0ciAiIgogItC+0YLQvNC10YHRgtCy0LDQvdC1INC/0YDQtdC00Lgg0L3QsNGH0LDQu9C+0YLQviDQvdCwINC40L3QtNC10LrRgdCwINC90LAg0L/QsNC60LXRgtC90LjRjyDRhNCw0LnQuyDigJ4lc+KAnCAo0LLRitC30LzQvtC20L3QviDQtSAiCiAi0LjQvdC00LXQutGB0YrRgiDQtNCwINC1INC/0L7QstGA0LXQtNC10L0pIgogCi0jOiBwYWNrZmlsZS5jOjE5MDMKKyM6IHBhY2tmaWxlLmM6MTg5MQogIywgYy1mb3JtYXQKIG1zZ2lkICJvZmZzZXQgYmV5b25kIGVuZCBvZiBwYWNrIGluZGV4IGZvciAlcyAodHJ1bmNhdGVkIGluZGV4PykiCiBtc2dzdHIgIiIKQEAgLTQ1ODIsMjYgKzQ2MDcsMjYgQEAKIG1zZ2lkICJkaWQgeW91IG1lYW4gYC0tJXNgICh3aXRoIHR3byBkYXNoZXMgPykiCiBtc2dzdHIgIuKAni0tJXPigJwgKNGBIDIg0YLQuNGA0LXRgtCwKSDQu9C4INC40LzQsNGF0YLQtSDQv9GA0LXQtNCy0LjQtD8iCiAKLSM6IHBhcnNlLW9wdGlvbnMuYzo4NTkKKyM6IHBhcnNlLW9wdGlvbnMuYzo4NjAKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5rbm93biBvcHRpb24gYCVzJyIKIG1zZ3N0ciAi0L3QtdC/0L7Qt9C90LDRgtCwINC+0L/RhtC40Y86IOKAniVz4oCcIgogCi0jOiBwYXJzZS1vcHRpb25zLmM6ODYxCisjOiBwYXJzZS1vcHRpb25zLmM6ODYyCiAjLCBjLWZvcm1hdAogbXNnaWQgInVua25vd24gc3dpdGNoIGAlYyciCiBtc2dzdHIgItC90LXQv9C+0LfQvdCw0YIg0YTQu9Cw0LMg4oCeJWPigJwiCiAKLSM6IHBhcnNlLW9wdGlvbnMuYzo4NjMKKyM6IHBhcnNlLW9wdGlvbnMuYzo4NjQKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5rbm93biBub24tYXNjaWkgb3B0aW9uIGluIHN0cmluZzogYCVzJyIKIG1zZ3N0ciAi0L3QtdC/0L7Qt9C90LDRgtCwINGB0YLQvtC50L3QvtGB0YIg0LjQt9Cy0YrQvSDigJ5hc2NpaeKAnCDQsiDQvdC40LfQsDog4oCeJXPigJwiCiAKLSM6IHBhcnNlLW9wdGlvbnMuYzo4ODcKKyM6IHBhcnNlLW9wdGlvbnMuYzo4ODgKIG1zZ2lkICIuLi4iCiBtc2dzdHIgIuKApiIKIAotIzogcGFyc2Utb3B0aW9ucy5jOjkwNgorIzogcGFyc2Utb3B0aW9ucy5jOjkwNwogIywgYy1mb3JtYXQKIG1zZ2lkICJ1c2FnZTogJXMiCiBtc2dzdHIgItGD0L/QvtGC0YDQtdCx0LA6ICVzIgpAQCAtNDYwOSwyMSArNDYzNCwyMSBAQAogIy4gVFJBTlNMQVRPUlM6IHRoZSBjb2xvbiBoZXJlIHNob3VsZCBhbGlnbiB3aXRoIHRoZQogIy4gb25lIGluICJ1c2FnZTogJXMiIHRyYW5zbGF0aW9uLgogIy4KLSM6IHBhcnNlLW9wdGlvbnMuYzo5MTIKKyM6IHBhcnNlLW9wdGlvbnMuYzo5MTMKICMsIGMtZm9ybWF0CiBtc2dpZCAiICAgb3I6ICVzIgogbXNnc3RyICIgICAgINC40LvQuDogJXMiCiAKLSM6IHBhcnNlLW9wdGlvbnMuYzo5MTUKKyM6IHBhcnNlLW9wdGlvbnMuYzo5MTYKICMsIGMtZm9ybWF0CiBtc2dpZCAiICAgICVzIgogbXNnc3RyICIgICAgJXMiCiAKLSM6IHBhcnNlLW9wdGlvbnMuYzo5NTQKKyM6IHBhcnNlLW9wdGlvbnMuYzo5NTUKIG1zZ2lkICItTlVNIgogbXNnc3RyICIt0KfQmNCh0JvQniIKIAotIzogcGFyc2Utb3B0aW9ucy5jOjk2OAorIzogcGFyc2Utb3B0aW9ucy5jOjk2OQogIywgYy1mb3JtYXQKIG1zZ2lkICJhbGlhcyBvZiAtLSVzIgogbXNnc3RyICLQv9GB0LXQstC00L7QvdC40Lwg0L3QsCDigJ4tLSVz4oCcIgpAQCAtNDc5NSwzMCArNDgyMCw0MCBAQAogbXNnaWQgInVuYWJsZSB0byBwYXJzZSAtLXByZXR0eSBmb3JtYXQiCiBtc2dzdHIgItCw0YDQs9GD0LzQtdC90YLRitGCINC60YrQvCDQvtC/0YbQuNGP0YLQsCDigJ4tLXByZXR0eeKAnCDQvdC1INC80L7QttC1INC00LAg0YHQtSDQsNC90LDQu9C40LfQuNGA0LAiCiAKLSM6IHJhbmdlLWRpZmYuYzo3MAorIzogcHJvbWlzb3ItcmVtb3RlLmM6MjUKK21zZ2lkICJSZW1vdGUgd2l0aCBubyBVUkwiCittc2dzdHIgItCb0LjQv9GB0LLQsCDQsNC00YDQtdGBINC30LAg0L7RgtC00LDQu9C10YfQtdC90L7RgtC+INGF0YDQsNC90LjQu9C40YnQtSIKKworIzogcHJvbWlzb3ItcmVtb3RlLmM6NjEKKyMsIGMtZm9ybWF0Cittc2dpZCAicHJvbWlzb3IgcmVtb3RlIG5hbWUgY2Fubm90IGJlZ2luIHdpdGggJy8nOiAlcyIKK21zZ3N0ciAiIgorItC40LzQtdGC0L4g0L7RgtC00LDQu9C10YfQtdC90L7RgtC+INGF0YDQsNC90LjQu9C40YnQtS3Qs9Cw0YDQsNC90YIg0L3QtSDQvNC+0LbQtSDQt9CwINC30LDQv9C+0YfQstCwINGB0YrRgSDQt9C90LDQutCwIOKAni/igJw6ICVzIgorCisjOiByYW5nZS1kaWZmLmM6NzEKIG1zZ2lkICJjb3VsZCBub3Qgc3RhcnQgYGxvZ2AiCiBtc2dzdHIgItC60L7QvNCw0L3QtNCw0YLQsCDQt9CwINC20YPRgNC90LDQu9CwINGBINC/0L7QtNCw0LLQsNC90LjRjyDigJ5sb2figJwg0L3QtSDQvNC+0LbQtSDQtNCwINGB0LUg0YHRgtCw0YDRgtC40YDQsCIKIAotIzogcmFuZ2UtZGlmZi5jOjcyCisjOiByYW5nZS1kaWZmLmM6NzMKIG1zZ2lkICJjb3VsZCBub3QgcmVhZCBgbG9nYCBvdXRwdXQiCiBtc2dzdHIgIiIKICLQuNC30YXQvtC00YrRgiDQvtGCINC60L7QvNCw0L3QtNCw0YLQsCDQt9CwINC20YPRgNC90LDQu9CwINGBINC/0L7QtNCw0LLQsNC90LjRjyDigJ5sb2figJwg0L3QtSDQvNC+0LbQtSDQtNCwINGB0LUg0L/RgNC+0YfQtdGC0LUiCiAKLSM6IHJhbmdlLWRpZmYuYzo5MSBzZXF1ZW5jZXIuYzo1MDIxCisjOiByYW5nZS1kaWZmLmM6OTIgc2VxdWVuY2VyLmM6NDk4NQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcGFyc2UgY29tbWl0ICclcyciCiBtc2dzdHIgItC/0L7QtNCw0LLQsNC90LXRgtC+IOKAniVz4oCcINC90LUg0LzQvtC20LUg0LTQsCDQsdGK0LTQtSDQsNC90LDQu9C40LfQuNGA0LDQvdC+IgogCi0jOiByYW5nZS1kaWZmLmM6MTE3CisjOiByYW5nZS1kaWZmLmM6MTE4CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBwYXJzZSBnaXQgaGVhZGVyICclLipzJyIKIG1zZ3N0ciAi0LfQsNCz0LvQsNCy0L3QsNGC0LAg0YfQsNGB0YIg0L3QsCBnaXQg4oCeJS4qc+KAnCDQvdC1INC80L7QttC1INC00LAg0YHQtSDQsNC90LDQu9C40LfQuNGA0LAiCiAKLSM6IHJhbmdlLWRpZmYuYzoyNzQKKyM6IHJhbmdlLWRpZmYuYzoyNzUKIG1zZ2lkICJmYWlsZWQgdG8gZ2VuZXJhdGUgZGlmZiIKIG1zZ3N0ciAi0L3QtdGD0YHQv9C10YjQvdC+INGC0YrRgNGB0LXQvdC1INC90LAg0YDQsNC30LvQuNC60LAiCiAKLSM6IHJhbmdlLWRpZmYuYzo1MDYgcmFuZ2UtZGlmZi5jOjUwOAorIzogcmFuZ2UtZGlmZi5jOjUwNyByYW5nZS1kaWZmLmM6NTA5CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBwYXJzZSBsb2cgZm9yICclcyciCiBtc2dzdHIgItC20YPRgNC90LDQu9GK0YIg0YEg0L/QvtC00LDQstCw0L3QuNGP0YLQsCDQvdCwIOKAniVz4oCcINC90LUg0LzQvtC20LUg0LTQsCDQsdGK0LTQtSDQsNC90LDQu9C40LfQuNGA0LDQvSIKQEAgLTQ4NjUsMTEgKzQ5MDAsMTEgQEAKIG1zZ2lkICInJXMnIGFwcGVhcnMgYXMgYm90aCBhIGZpbGUgYW5kIGFzIGEgZGlyZWN0b3J5IgogbXNnc3RyICLigJ4lc+KAnCDRgdGK0YnQtdGB0YLQstGD0LLQsCDQuCDQutCw0YLQviDRhNCw0LnQuywg0Lgg0LrQsNGC0L4g0LTQuNGA0LXQutGC0L7RgNC40Y8iCiAKLSM6IHJlYWQtY2FjaGUuYzoxNDk5CisjOiByZWFkLWNhY2hlLmM6MTUyMAogbXNnaWQgIlJlZnJlc2ggaW5kZXgiCiBtc2dzdHIgItCe0LHQvdC+0LLRj9Cy0LDQvdC1INC90LAg0LjQvdC00LXQutGB0LAiCiAKLSM6IHJlYWQtY2FjaGUuYzoxNjEzCisjOiByZWFkLWNhY2hlLmM6MTYzNQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiaW5kZXgudmVyc2lvbiBzZXQsIGJ1dCB0aGUgdmFsdWUgaXMgaW52YWxpZC5cbiIKQEAgLTQ4NzgsNyArNDkxMyw3IEBACiAi0JfQsNC00LDQtNC10L3QsCDQtSDQvdC10L/RgNCw0LLQuNC70L3QsCDRgdGC0L7QudC90L7RgdGCINC90LAg0L3QsNGB0YLRgNC+0LnQutCw0YLQsCDigJ5pbmRleC52ZXJzaW9u4oCcLlxuIgogItCp0LUg0YHQtSDQv9C+0LvQt9Cy0LAg0LLQtdGA0YHQuNGPICVpIgogCi0jOiByZWFkLWNhY2hlLmM6MTYyMworIzogcmVhZC1jYWNoZS5jOjE2NDUKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkdJVF9JTkRFWF9WRVJTSU9OIHNldCwgYnV0IHRoZSB2YWx1ZSBpcyBpbnZhbGlkLlxuIgpAQCAtNDg4OCwxNDEgKzQ5MjMsMTQxIEBACiAi4oCeR0lUX0lOREVYX1ZFUlNJT07igJwuXG4iCiAi0KnQtSDRgdC1INC/0L7Qu9C30LLQsCDQstC10YDRgdC40Y8gJWkiCiAKLSM6IHJlYWQtY2FjaGUuYzoxNjc5CisjOiByZWFkLWNhY2hlLmM6MTcwMQogIywgYy1mb3JtYXQKIG1zZ2lkICJiYWQgc2lnbmF0dXJlIDB4JTA4eCIKIG1zZ3N0ciAi0L3QtdC/0YDQsNCy0LjQu9C10L0g0L/QvtC00L/QuNGBOiDigJ4weCUwOHjigJwiCiAKLSM6IHJlYWQtY2FjaGUuYzoxNjgyCisjOiByZWFkLWNhY2hlLmM6MTcwNAogIywgYy1mb3JtYXQKIG1zZ2lkICJiYWQgaW5kZXggdmVyc2lvbiAlZCIKIG1zZ3N0ciAi0L3QtdC/0YDQsNCy0LjQu9C90LAg0LLQtdGA0YHQuNGPINC90LAg0LjQvdC00LXQutGB0LAgJWQiCiAKLSM6IHJlYWQtY2FjaGUuYzoxNjkxCisjOiByZWFkLWNhY2hlLmM6MTcxMwogbXNnaWQgImJhZCBpbmRleCBmaWxlIHNoYTEgc2lnbmF0dXJlIgogbXNnc3RyICLQvdC10L/RgNCw0LLQuNC70LXQvSDQv9C+0LTQv9C40YEg0LfQsCDQutC+0L3RgtGA0L7Qu9C90LAg0YHRg9C80LAg0L/QviBTSEExINC90LAg0YTQsNC50LvQsCDQvdCwINC40L3QtNC10LrRgdCwIgogCi0jOiByZWFkLWNhY2hlLmM6MTcyMQorIzogcmVhZC1jYWNoZS5jOjE3NDMKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW5kZXggdXNlcyAlLjRzIGV4dGVuc2lvbiwgd2hpY2ggd2UgZG8gbm90IHVuZGVyc3RhbmQiCiBtc2dzdHIgIiIKICLQuNC90LTQtdC60YHRitGCINC/0L7Qu9C30LLQsCDRgNCw0LfRiNC40YDQtdC90LjQtSDigJ4lLjRz4oCcLCDQutC+0LXRgtC+INC90LUg0YHQtSDQv9C+0LTQtNGK0YDQttCwINC+0YIg0YLQsNC30Lgg0LLQtdGA0YHQuNGPINC90LAgZ2l0IgogCi0jOiByZWFkLWNhY2hlLmM6MTcyMworIzogcmVhZC1jYWNoZS5jOjE3NDUKICMsIGMtZm9ybWF0CiBtc2dpZCAiaWdub3JpbmcgJS40cyBleHRlbnNpb24iCiBtc2dzdHIgItC40LPQvdC+0YDQuNGA0LDQvdC1INC90LAg0YDQsNC30YjQuNGA0LXQvdC40LXRgtC+IOKAniUuNHPigJwiCiAKLSM6IHJlYWQtY2FjaGUuYzoxNzYwCisjOiByZWFkLWNhY2hlLmM6MTc4MgogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmtub3duIGluZGV4IGVudHJ5IGZvcm1hdCAweCUwOHgiCiBtc2dzdHIgItC90LXQv9C+0LfQvdCw0YIg0YTQvtGA0LzQsNGCINC90LAg0LfQsNC/0LjRgSDQsiDQuNC90LTQtdC60YHQsDog4oCeMHglMDh44oCcIgogCi0jOiByZWFkLWNhY2hlLmM6MTc3NgorIzogcmVhZC1jYWNoZS5jOjE3OTgKICMsIGMtZm9ybWF0CiBtc2dpZCAibWFsZm9ybWVkIG5hbWUgZmllbGQgaW4gdGhlIGluZGV4LCBuZWFyIHBhdGggJyVzJyIKIG1zZ3N0ciAi0L3QtdC/0YDQsNCy0LjQu9C90L4g0LjQvNC1INC90LAg0L/QvtC70LUg0LIg0LjQvdC00LXQutGB0LAg0LHQu9C40LfQviDQtNC+INC/0YrRgtGPIOKAniVz4oCcIgogCi0jOiByZWFkLWNhY2hlLmM6MTgzMworIzogcmVhZC1jYWNoZS5jOjE4NTUKIG1zZ2lkICJ1bm9yZGVyZWQgc3RhZ2UgZW50cmllcyBpbiBpbmRleCIKIG1zZ3N0ciAi0L3QtdC/0L7QtNGA0LXQtNC10L3QuCDQt9Cw0L/QuNGB0Lgg0LIg0LjQvdC00LXQutGB0LAiCiAKLSM6IHJlYWQtY2FjaGUuYzoxODM2CisjOiByZWFkLWNhY2hlLmM6MTg1OAogIywgYy1mb3JtYXQKIG1zZ2lkICJtdWx0aXBsZSBzdGFnZSBlbnRyaWVzIGZvciBtZXJnZWQgZmlsZSAnJXMnIgogbXNnc3RyICLQvNC90L7QttC10YHRgtCy0L4g0LfQsNC/0LjRgdC4INC30LAg0YHQu9C10YLQuNGPINGE0LDQudC7IOKAniVz4oCcIgogCi0jOiByZWFkLWNhY2hlLmM6MTgzOQorIzogcmVhZC1jYWNoZS5jOjE4NjEKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5vcmRlcmVkIHN0YWdlIGVudHJpZXMgZm9yICclcyciCiBtc2dzdHIgItC90LXQv9C+0LTRgNC10LTQtdC90Lgg0LfQsNC/0LjRgdC4INC30LAg4oCeJXPigJwiCiAKLSM6IHJlYWQtY2FjaGUuYzoxOTQ2IHJlYWQtY2FjaGUuYzoyMjM0IHJlcmVyZS5jOjU2NSByZXJlcmUuYzo1OTkgcmVyZXJlLmM6MTExMQotIzogYnVpbHRpbi9hZGQuYzo0NjAgYnVpbHRpbi9jaGVjay1pZ25vcmUuYzoxNzggYnVpbHRpbi9jaGVja291dC5jOjQ2NwotIzogYnVpbHRpbi9jaGVja291dC5jOjY1MSBidWlsdGluL2NsZWFuLmM6OTU2IGJ1aWx0aW4vY29tbWl0LmM6MzQ3CisjOiByZWFkLWNhY2hlLmM6MTk2NyByZWFkLWNhY2hlLmM6MjI1NSByZXJlcmUuYzo1NjUgcmVyZXJlLmM6NTk5IHJlcmVyZS5jOjExMTEKKyM6IGJ1aWx0aW4vYWRkLmM6NDYwIGJ1aWx0aW4vY2hlY2staWdub3JlLmM6MTc4IGJ1aWx0aW4vY2hlY2tvdXQuYzo0NjgKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo2NTIgYnVpbHRpbi9jbGVhbi5jOjk2NyBidWlsdGluL2NvbW1pdC5jOjM0NwogIzogYnVpbHRpbi9kaWZmLXRyZWUuYzoxMjAgYnVpbHRpbi9ncmVwLmM6NDk5IGJ1aWx0aW4vbXYuYzoxNDUKICM6IGJ1aWx0aW4vcmVzZXQuYzoyNDUgYnVpbHRpbi9ybS5jOjI3MSBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6MzMwCiBtc2dpZCAiaW5kZXggZmlsZSBjb3JydXB0IgogbXNnc3RyICLRhNCw0LnQu9GK0YIg0YEg0LjQvdC00LXQutGB0LAg0LUg0L/QvtCy0YDQtdC00LXQvSIKIAotIzogcmVhZC1jYWNoZS5jOjIwODcKKyM6IHJlYWQtY2FjaGUuYzoyMTA4CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBjcmVhdGUgbG9hZF9jYWNoZV9lbnRyaWVzIHRocmVhZDogJXMiCiBtc2dzdHIgItC90LUg0LzQvtC20LUg0LTQsCDRgdC1INGB0YrQt9C00LDQtNC1INC90LjRiNC60LAg0LfQsCDQt9Cw0YDQtdC20LTQsNC90LUg0L3QsCDQvtCx0LXQutGC0LjRgtC1INC+0YIg0LrQtdGI0LA6ICVzIgogCi0jOiByZWFkLWNhY2hlLmM6MjEwMAorIzogcmVhZC1jYWNoZS5jOjIxMjEKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGpvaW4gbG9hZF9jYWNoZV9lbnRyaWVzIHRocmVhZDogJXMiCiBtc2dzdHIgItC90LUg0LzQvtC20LUg0LTQsCDRgdC1INC40LfRh9Cw0LrQsCDQvdC40YjQutCwINC30LAg0LfQsNGA0LXQttC00LDQvdC1INC90LAg0L7QsdC10LrRgtC40YLQtSDQvtGCINC60LXRiNCwOiAlcyIKIAotIzogcmVhZC1jYWNoZS5jOjIxMzMKKyM6IHJlYWQtY2FjaGUuYzoyMTU0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiBpbmRleCBmaWxlIG9wZW4gZmFpbGVkIgogbXNnc3RyICIlczog0L3QtdGD0YHQv9C10YjQvdC+INC+0YLQstCw0YDRj9C90LUg0L3QsCDRhNCw0LnQu9CwINC90LAg0LjQvdC00LXQutGB0LAiCiAKLSM6IHJlYWQtY2FjaGUuYzoyMTM3CisjOiByZWFkLWNhY2hlLmM6MjE1OAogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogY2Fubm90IHN0YXQgdGhlIG9wZW4gaW5kZXgiCiBtc2dzdHIgIiVzOiDQvdC1INC80L7QttC1INC00LAg0YHQtSDQv9C+0LvRg9GH0Lgg0LjQvdGE0L7RgNC80LDRhtC40Y8g0LfQsCDQvtGC0LLQvtGA0LXQvdC40Y8g0LjQvdC00LXQutGBINGB0YrRgSDigJ5zdGF04oCcIgogCi0jOiByZWFkLWNhY2hlLmM6MjE0MQorIzogcmVhZC1jYWNoZS5jOjIxNjIKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXM6IGluZGV4IGZpbGUgc21hbGxlciB0aGFuIGV4cGVjdGVkIgogbXNnc3RyICIlczog0YTQsNC50LvRitGCINC90LAg0LjQvdC00LXQutGB0LAg0LUg0L/Qvi3QvNCw0LvRitC6INC+0YIg0L7Rh9Cw0LrQstCw0L3QvtGC0L4iCiAKLSM6IHJlYWQtY2FjaGUuYzoyMTQ1CisjOiByZWFkLWNhY2hlLmM6MjE2NgogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogdW5hYmxlIHRvIG1hcCBpbmRleCBmaWxlIgogbXNnc3RyICIlczog0L3QtdGD0YHQv9C10YjQvdC+INC30LDQtNC10LvRj9C90LUg0L3QsCDRgdGK0L7RgtCy0LXRgtGB0YLQstCw0YnQsCDQv9Cw0LzQtdGCINGH0YDQtdC3IOKAnm1tYXDigJwg0L3QsCDQuNC90LTQtdC60YHQsCIKIAotIzogcmVhZC1jYWNoZS5jOjIxODcKKyM6IHJlYWQtY2FjaGUuYzoyMjA4CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBjcmVhdGUgbG9hZF9pbmRleF9leHRlbnNpb25zIHRocmVhZDogJXMiCiBtc2dzdHIgIiIKICLQvdC1INC80L7QttC1INC00LAg0YHQtSDRgdGK0LfQtNCw0LTQtSDQvdC40YjQutCwINC30LAg0LfQsNGA0LXQttC00LDQvdC1INC90LAg0YDQsNC30YjQuNGA0LXQvdC40Y/RgtCwINC90LAg0LjQvdC00LXQutGB0LA6ICVzIgogCi0jOiByZWFkLWNhY2hlLmM6MjIxNAorIzogcmVhZC1jYWNoZS5jOjIyMzUKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGpvaW4gbG9hZF9pbmRleF9leHRlbnNpb25zIHRocmVhZDogJXMiCiBtc2dzdHIgIiIKICLQvdC1INC80L7QttC1INC00LAg0YHQtSDRgdGK0LfQtNCw0LTQtSDQvdC40YjQutCwINC30LAg0LfQsNGA0LXQttC00LDQvdC1INC90LAg0YDQsNC30YjQuNGA0LXQvdC40Y/RgtCwINC90LAg0LjQvdC00LXQutGB0LA6ICVzIgogCi0jOiByZWFkLWNhY2hlLmM6MjI0NgorIzogcmVhZC1jYWNoZS5jOjIyNjcKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGZyZXNoZW4gc2hhcmVkIGluZGV4ICclcyciCiBtc2dzdHIgItGB0L/QvtC00LXQu9C10L3QuNGP0YIg0LjQvdC00LXQutGBIOKAniVz4oCcINC90LUg0LzQvtC20LUg0LTQsCDRgdC1INC+0LHQvdC+0LLQuCIKIAotIzogcmVhZC1jYWNoZS5jOjIyOTMKKyM6IHJlYWQtY2FjaGUuYzoyMzE0CiAjLCBjLWZvcm1hdAogbXNnaWQgImJyb2tlbiBpbmRleCwgZXhwZWN0ICVzIGluICVzLCBnb3QgJXMiCiBtc2dzdHIgItCz0YDQtdGI0LrQuCDQsiDQuNC90LTQtdC60YHQsCDigJQg0LIg4oCeJTIkc+KAnCDRgdC1INC+0YfQsNC60LLQsCDigJ4lMSRz4oCcLCDQsCDQsdC1INC/0L7Qu9GD0YfQtdC90L4g4oCeJTMkc+KAnCIKIAotIzogcmVhZC1jYWNoZS5jOjI5ODkgd3JhcHBlci5jOjY1OCBidWlsdGluL21lcmdlLmM6MTExNAorIzogcmVhZC1jYWNoZS5jOjMwMTAgd3JhcHBlci5jOjYyMiBidWlsdGluL21lcmdlLmM6MTExOQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgY2xvc2UgJyVzJyIKIG1zZ3N0ciAi4oCeJXPigJwg0L3QtSDQvNC+0LbQtSDQtNCwINGB0LUg0LfQsNGC0LLQvtGA0LgiCiAKLSM6IHJlYWQtY2FjaGUuYzozMDkyIHNlcXVlbmNlci5jOjIzNTggc2VxdWVuY2VyLmM6MzkyOAorIzogcmVhZC1jYWNoZS5jOjMxMTMgc2VxdWVuY2VyLmM6MjI5NiBzZXF1ZW5jZXIuYzozOTE3CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBzdGF0ICclcyciCiBtc2dzdHIgItC90LXRg9GB0L/QtdGI0L3QviDQuNC30L/RitC70L3QtdC90LjQtSDQvdCwIOKAnnN0YXTigJwg0LLRitGA0YXRgyDigJ4lc+KAnCIKIAotIzogcmVhZC1jYWNoZS5jOjMxMDUKKyM6IHJlYWQtY2FjaGUuYzozMTI2CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBvcGVuIGdpdCBkaXI6ICVzIgogbXNnc3RyICLQvdC1INC80L7QttC1INC00LAg0YHQtSDQvtGC0LLQvtGA0Lgg0LTQuNGA0LXQutGC0L7RgNC40Y/RgtCwINC90LAgZ2l0OiAlcyIKIAotIzogcmVhZC1jYWNoZS5jOjMxMTcKKyM6IHJlYWQtY2FjaGUuYzozMTM4CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byB1bmxpbms6ICVzIgogbXNnc3RyICLQvdC10YPRgdC/0LXRiNC90L4g0LjQt9GC0YDQuNCy0LDQvdC1INC90LAg4oCeJXPigJwiCiAKLSM6IHJlYWQtY2FjaGUuYzozMTQyCisjOiByZWFkLWNhY2hlLmM6MzE2MwogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgZml4IHBlcm1pc3Npb24gYml0cyBvbiAnJXMnIgogbXNnc3RyICLQv9GA0LDQstCw0YLQsCDQt9CwINC00L7RgdGC0YrQvyDQtNC+IOKAniVz4oCcINC90LUg0LzQvtCz0LDRgiDQtNCwINCx0YrQtNCw0YIg0L/QvtC/0YDQsNCy0LXQvdC4IgogCi0jOiByZWFkLWNhY2hlLmM6MzI5MQorIzogcmVhZC1jYWNoZS5jOjMzMTIKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXM6IGNhbm5vdCBkcm9wIHRvIHN0YWdlICMwIgogbXNnc3RyICIlczog0L3QtSDQvNC+0LbQtSDQtNCwINGB0LUg0L/RgNC10LzQuNC90LUg0LrRitC8INC10YLQsNC/IOKEljAiCkBAIC01MTM1LDggKzUxNzAsOCBAQAogbXNnaWQgIk5vdGUgdGhhdCBlbXB0eSBjb21taXRzIGFyZSBjb21tZW50ZWQgb3V0IgogbXNnc3RyICLQn9GA0LDQt9C90LjRgtC1INC/0L7QtNCw0LLQsNC90LjRjyDRgdCwINC60L7QvNC10L3RgtC40YDQsNC90LgiCiAKLSM6IHJlYmFzZS1pbnRlcmFjdGl2ZS5jOjEwNSByZXJlcmUuYzo0ODUgcmVyZXJlLmM6NjkyIHNlcXVlbmNlci5jOjM0NDcKLSM6IHNlcXVlbmNlci5jOjM0NzMgc2VxdWVuY2VyLmM6NTEyMCBidWlsdGluL2ZzY2suYzozNTYgYnVpbHRpbi9yZWJhc2UuYzoyMzUKKyM6IHJlYmFzZS1pbnRlcmFjdGl2ZS5jOjEwNSByZXJlcmUuYzo0ODUgcmVyZXJlLmM6NjkyIHNlcXVlbmNlci5jOjMzODgKKyM6IHNlcXVlbmNlci5jOjM0MTQgc2VxdWVuY2VyLmM6NTA4NCBidWlsdGluL2ZzY2suYzozNTYgYnVpbHRpbi9yZWJhc2UuYzoyMzUKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHdyaXRlICclcyciCiBtc2dzdHIgIuKAniVz4oCcINC90LUg0LzQvtC20LUg0LTQsCDRgdC1INC30LDQv9C40YjQtSIKQEAgLTUxODIsNyArNTIxNyw3IEBACiBtc2dpZCAiaWdub3JpbmcgZGFuZ2xpbmcgc3ltcmVmICVzIgogbXNnc3RyICLQuNCz0L3QvtGA0LjRgNCw0L3QtSDQvdCwINGD0LrQsNC30LDRgtC10Lsg0L3QsCDQvtCx0LXQutGCINC40LfQstGK0L0g0LrQu9C+0L0g4oCeJXPigJwiCiAKLSM6IHJlZnMuYzo2NjkgcmVmLWZpbHRlci5jOjIwOTIKKyM6IHJlZnMuYzo2NjkgcmVmLWZpbHRlci5jOjIwOTgKICMsIGMtZm9ybWF0CiBtc2dpZCAiaWdub3JpbmcgYnJva2VuIHJlZiAlcyIKIG1zZ3N0ciAi0LjQs9C90L7RgNC40YDQsNC90LUg0L3QsCDQv9C+0LLRgNC10LTQtdC90LjRjyDRg9C60LDQt9Cw0YLQtdC7IOKAniVz4oCcIgpAQCAtNTIwNywxNCArNTI0MiwxNCBAQAogbXNnaWQgInVuZXhwZWN0ZWQgb2JqZWN0IElEIHdoZW4gd3JpdGluZyAnJXMnIgogbXNnc3RyICLQvdC10L7Rh9Cw0LrQstCw0L0g0LjQtNC10L3RgtC40YTQuNC60LDRgtC+0YAg0L3QsCDQvtCx0LXQutGCINC/0YDQuCDQt9Cw0L/QuNGB0LLQsNC90LXRgtC+INC90LAg4oCeJXPigJwiCiAKLSM6IHJlZnMuYzo4MzMgc2VxdWVuY2VyLmM6NDAzIHNlcXVlbmNlci5jOjI3MDkgc2VxdWVuY2VyLmM6MjkxMwotIzogc2VxdWVuY2VyLmM6MjkyNyBzZXF1ZW5jZXIuYzozMTg0IHNlcXVlbmNlci5jOjUwMzcgd3JhcHBlci5jOjY1NgorIzogcmVmcy5jOjgzMyBzZXF1ZW5jZXIuYzo0MDMgc2VxdWVuY2VyLmM6MjY0NyBzZXF1ZW5jZXIuYzoyODUxCisjOiBzZXF1ZW5jZXIuYzoyODY1IHNlcXVlbmNlci5jOjMxMjIgc2VxdWVuY2VyLmM6NTAwMSB3cmFwcGVyLmM6NjIwCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCB3cml0ZSB0byAnJXMnIgogbXNnc3RyICLQsiDigJ4lc+KAnCDQvdC1INC80L7QttC1INC00LAg0YHQtSDQv9C40YjQtSIKIAotIzogcmVmcy5jOjg2MCB3cmFwcGVyLmM6MjI1IHdyYXBwZXIuYzozOTUgYnVpbHRpbi9hbS5jOjcxNQotIzogYnVpbHRpbi9yZWJhc2UuYzoxMDAzCisjOiByZWZzLmM6ODYwIHdyYXBwZXIuYzoxODggd3JhcHBlci5jOjM1OCBidWlsdGluL2FtLmM6NzE0CisjOiBidWlsdGluL3JlYmFzZS5jOjEwMDQKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IG9wZW4gJyVzJyBmb3Igd3JpdGluZyIKIG1zZ3N0ciAi4oCeJXPigJwg0L3QtSDQvNC+0LbQtSDQtNCwINCx0YrQtNC1INC+0YLQstC+0YDQtdC9INC30LAg0LfQsNC/0LjRgSIKQEAgLTUyNDksMjEgKzUyODQsMjEgQEAKIG1zZ2lkICJ1cGRhdGVfcmVmIGZhaWxlZCBmb3IgcmVmICclcyc6ICVzIgogbXNnc3RyICLQvdC10YPRgdC/0LXRiNC90L4g0L7QsdC90L7QstGP0LLQsNC90LUg0L3QsCDRg9C60LDQt9Cw0YLQtdC70Y8g4oCeJXPigJw6ICVzIgogCi0jOiByZWZzLmM6MjAxMgorIzogcmVmcy5jOjIwMjMKICMsIGMtZm9ybWF0CiBtc2dpZCAibXVsdGlwbGUgdXBkYXRlcyBmb3IgcmVmICclcycgbm90IGFsbG93ZWQiCiBtc2dzdHIgItC90LUg0YHQsCDQv9C+0LfQstC+0LvQtdC90Lgg0L/QvtCy0LXRh9C1INC+0YIg0LXQtNC90LAg0L/RgNC+0LzQtdC90Lgg0L3QsCDRg9C60LDQt9Cw0YLQtdC70Y8g4oCeJXPigJwiCiAKLSM6IHJlZnMuYzoyMDQ0CisjOiByZWZzLmM6MjA1NQogbXNnaWQgInJlZiB1cGRhdGVzIGZvcmJpZGRlbiBpbnNpZGUgcXVhcmFudGluZSBlbnZpcm9ubWVudCIKIG1zZ3N0ciAi0L7QsdC90L7QstGP0LLQsNC90LjRj9GC0LAg0L3QsCDRg9C60LDQt9Cw0YLQtdC70Lgg0YHQsCDQt9Cw0LHRgNCw0L3QtdC90Lgg0LIg0YHRgNC10LTQuCDQv9C+0LQg0LrQsNGA0LDQvdGC0LjQvdCwIgogCi0jOiByZWZzLmM6MjE0MCByZWZzLmM6MjE3MAorIzogcmVmcy5jOjIxNTEgcmVmcy5jOjIxODEKICMsIGMtZm9ybWF0CiBtc2dpZCAiJyVzJyBleGlzdHM7IGNhbm5vdCBjcmVhdGUgJyVzJyIKIG1zZ3N0ciAi4oCeJXPigJwg0YHRitGJ0LXRgdGC0LLRg9Cy0LAsINC90LUg0LzQvtC20LUg0LTQsCDRgdC1INGB0YrQt9C00LDQtNC1IOKAniVz4oCcIgogCi0jOiByZWZzLmM6MjE0NiByZWZzLmM6MjE4MQorIzogcmVmcy5jOjIxNTcgcmVmcy5jOjIxOTIKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IHByb2Nlc3MgJyVzJyBhbmQgJyVzJyBhdCB0aGUgc2FtZSB0aW1lIgogbXNnc3RyICLQvdC10LLRitC30LzQvtC20L3QviDQtSDQtdC00L3QvtCy0YDQtdC80LXQvdC90L4g0LTQsCDRgdC1INC+0LHRgNCw0LHQvtGC0LLQsNGCIOKAniVz4oCcINC4IOKAniVz4oCcIgpAQCAtNTI3MywxMyArNTMwOCwxMyBAQAogbXNnaWQgImNvdWxkIG5vdCByZW1vdmUgcmVmZXJlbmNlICVzIgogbXNnc3RyICLQo9C60LDQt9Cw0YLQtdC70Y/RgiDigJ4lc+KAnCDQvdC1INC80L7QttC1INC00LAg0LHRitC00LUg0LjQt9GC0YDQuNGCIgogCi0jOiByZWZzL2ZpbGVzLWJhY2tlbmQuYzoxMjQ4IHJlZnMvcGFja2VkLWJhY2tlbmQuYzoxNTMyCi0jOiByZWZzL3BhY2tlZC1iYWNrZW5kLmM6MTU0MgorIzogcmVmcy9maWxlcy1iYWNrZW5kLmM6MTI0OCByZWZzL3BhY2tlZC1iYWNrZW5kLmM6MTU0MQorIzogcmVmcy9wYWNrZWQtYmFja2VuZC5jOjE1NTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGRlbGV0ZSByZWZlcmVuY2UgJXM6ICVzIgogbXNnc3RyICLQo9C60LDQt9Cw0YLQtdC70Y/RgiDigJ4lc+KAnCDQvdC1INC80L7QttC1INC00LAg0LHRitC00LUg0LjQt9GC0YDQuNGCOiAlcyIKIAotIzogcmVmcy9maWxlcy1iYWNrZW5kLmM6MTI1MSByZWZzL3BhY2tlZC1iYWNrZW5kLmM6MTU0NQorIzogcmVmcy9maWxlcy1iYWNrZW5kLmM6MTI1MSByZWZzL3BhY2tlZC1iYWNrZW5kLmM6MTU1NAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgZGVsZXRlIHJlZmVyZW5jZXM6ICVzIgogbXNnc3RyICLQo9C60LDQt9Cw0YLQtdC70LjRgtC1INC90LUg0LzQvtC20LUg0LTQsCDQsdGK0LTQsNGCINC40LfRgtGA0LjRgtC4OiAlcyIKQEAgLTUyODksNyArNTMyNCw3IEBACiBtc2dpZCAiaW52YWxpZCByZWZzcGVjICclcyciCiBtc2dzdHIgItC90LXQv9GA0LDQstC40LvQtdC9INGD0LrQsNC30LDRgtC10Ls6IOKAniVz4oCcIgogCi0jOiByZWYtZmlsdGVyLmM6NDIgd3Qtc3RhdHVzLmM6MTkzNAorIzogcmVmLWZpbHRlci5jOjQyIHd0LXN0YXR1cy5jOjE5MzgKIG1zZ2lkICJnb25lIgogbXNnc3RyICLQuNC30YLRgNC40YIiCiAKQEAgLTUzMDgsMjgxICs1MzQzLDI4MSBAQAogbXNnaWQgImFoZWFkICVkLCBiZWhpbmQgJWQiCiBtc2dzdHIgItC90LDQv9GA0LXQtCDRgSAlZCwg0L3QsNC30LDQtCDRgSAlZCIKIAotIzogcmVmLWZpbHRlci5jOjE2MgorIzogcmVmLWZpbHRlci5jOjE2NQogIywgYy1mb3JtYXQKIG1zZ2lkICJleHBlY3RlZCBmb3JtYXQ6ICUlKGNvbG9yOjxjb2xvcj4pIgogbXNnc3RyICLQvtGH0LDQutCy0LDQvSDRhNC+0YDQvNCw0YI6ICUlKGNvbG9yOtCm0JLQr9CiKSIKIAotIzogcmVmLWZpbHRlci5jOjE2NAorIzogcmVmLWZpbHRlci5jOjE2NwogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bnJlY29nbml6ZWQgY29sb3I6ICUlKGNvbG9yOiVzKSIKIG1zZ3N0ciAi0L3QtdC/0L7Qt9C90LDRgiDRhtCy0Y/RgjogJSUoY29sb3I6JXMpIgogCi0jOiByZWYtZmlsdGVyLmM6MTg2CisjOiByZWYtZmlsdGVyLmM6MTg5CiAjLCBjLWZvcm1hdAogbXNnaWQgIkludGVnZXIgdmFsdWUgZXhwZWN0ZWQgcmVmbmFtZTpsc3RyaXA9JXMiCiBtc2dzdHIgItC+0YfQsNC60LLQsCDRgdC1INGG0Y/Qu9C+INGH0LjRgdC70L4g0LfQsCDigJ5yZWZuYW1lOmxzdHJpcD0lc+KAnCIKIAotIzogcmVmLWZpbHRlci5jOjE5MAorIzogcmVmLWZpbHRlci5jOjE5MwogIywgYy1mb3JtYXQKIG1zZ2lkICJJbnRlZ2VyIHZhbHVlIGV4cGVjdGVkIHJlZm5hbWU6cnN0cmlwPSVzIgogbXNnc3RyICLQvtGH0LDQutCy0LAg0YHQtSDRhtGP0LvQviDRh9C40YHQu9C+INC30LAg4oCecmVmbmFtZTpyc3RyaXA9JXPigJwiCiAKLSM6IHJlZi1maWx0ZXIuYzoxOTIKKyM6IHJlZi1maWx0ZXIuYzoxOTUKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5yZWNvZ25pemVkICUlKCVzKSBhcmd1bWVudDogJXMiCiBtc2dzdHIgItC90LXQv9C+0LfQvdCw0YIg0LDRgNCz0YPQvNC10L3RgiDQt9CwIOKAniUlKCVzKeKAnDogJXMiCiAKLSM6IHJlZi1maWx0ZXIuYzoyNDcKKyM6IHJlZi1maWx0ZXIuYzoyNTAKICMsIGMtZm9ybWF0CiBtc2dpZCAiJSUob2JqZWN0dHlwZSkgZG9lcyBub3QgdGFrZSBhcmd1bWVudHMiCiBtc2dzdHIgIiUlKG9iamVjdHR5cGUpINC90LUg0L/RgNC40LXQvNCwINCw0YDQs9GD0LzQtdC90YLQuCIKIAotIzogcmVmLWZpbHRlci5jOjI2OQorIzogcmVmLWZpbHRlci5jOjI3MgogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bnJlY29nbml6ZWQgJSUob2JqZWN0c2l6ZSkgYXJndW1lbnQ6ICVzIgogbXNnc3RyICLQvdC10L/QvtC30L3QsNGCINCw0YDQs9GD0LzQtdC90YIg0LfQsCAlJShvYmplY3RzaXplKTogJXMiCiAKLSM6IHJlZi1maWx0ZXIuYzoyNzcKKyM6IHJlZi1maWx0ZXIuYzoyODAKICMsIGMtZm9ybWF0CiBtc2dpZCAiJSUoZGVsdGFiYXNlKSBkb2VzIG5vdCB0YWtlIGFyZ3VtZW50cyIKIG1zZ3N0ciAiJSUoZGVsdGFiYXNlKSDQvdC1INC/0YDQuNC10LzQsCDQsNGA0LPRg9C80LXQvdGC0LgiCiAKLSM6IHJlZi1maWx0ZXIuYzoyODkKKyM6IHJlZi1maWx0ZXIuYzoyOTIKICMsIGMtZm9ybWF0CiBtc2dpZCAiJSUoYm9keSkgZG9lcyBub3QgdGFrZSBhcmd1bWVudHMiCiBtc2dzdHIgIiUlKGJvZHkpINC90LUg0L/RgNC40LXQvNCwINCw0YDQs9GD0LzQtdC90YLQuCIKIAotIzogcmVmLWZpbHRlci5jOjI5OAorIzogcmVmLWZpbHRlci5jOjMwMQogIywgYy1mb3JtYXQKIG1zZ2lkICIlJShzdWJqZWN0KSBkb2VzIG5vdCB0YWtlIGFyZ3VtZW50cyIKIG1zZ3N0ciAiJSUoc3ViamVjdCkg0L3QtSDQv9GA0LjQtdC80LAg0LDRgNCz0YPQvNC10L3RgtC4IgogCi0jOiByZWYtZmlsdGVyLmM6MzIwCisjOiByZWYtZmlsdGVyLmM6MzIzCiAjLCBjLWZvcm1hdAogbXNnaWQgInVua25vd24gJSUodHJhaWxlcnMpIGFyZ3VtZW50OiAlcyIKIG1zZ3N0ciAi0L3QtdC/0L7Qt9C90LDRgiDQsNGA0LPRg9C80LXQvdGCIOKAniUlKHRyYWlsZXJzKeKAnDogJXMiCiAKLSM6IHJlZi1maWx0ZXIuYzozNDkKKyM6IHJlZi1maWx0ZXIuYzozNTIKICMsIGMtZm9ybWF0CiBtc2dpZCAicG9zaXRpdmUgdmFsdWUgZXhwZWN0ZWQgY29udGVudHM6bGluZXM9JXMiCiBtc2dzdHIgItC+0YfQsNC60LLQsCDRgdC1INC/0L7Qu9C+0LbQuNGC0LXQu9C90LAg0YHRgtC+0LnQvdC+0YHRgiDQt9CwIOKAnmNvbnRlbnRzOmxpbmVzPSVz4oCcIgogCi0jOiByZWYtZmlsdGVyLmM6MzUxCisjOiByZWYtZmlsdGVyLmM6MzU0CiAjLCBjLWZvcm1hdAogbXNnaWQgInVucmVjb2duaXplZCAlJShjb250ZW50cykgYXJndW1lbnQ6ICVzIgogbXNnc3RyICLQvdC10L/QvtC30L3QsNGCINCw0YDQs9GD0LzQtdC90YIg0LfQsCAlJShjb250ZW50cyk6ICVzIgogCi0jOiByZWYtZmlsdGVyLmM6MzY2CisjOiByZWYtZmlsdGVyLmM6MzY5CiAjLCBjLWZvcm1hdAogbXNnaWQgInBvc2l0aXZlIHZhbHVlIGV4cGVjdGVkIG9iamVjdG5hbWU6c2hvcnQ9JXMiCiBtc2dzdHIgItC+0YfQsNC60LLQsCDRgdC1INC/0L7Qu9C+0LbQuNGC0LXQu9C90LAg0YHRgtC+0LnQvdC+0YHRgiDQt9CwIOKAnm9iamVjdG5hbWU6c2hvcnQ9JXPigJwiCiAKLSM6IHJlZi1maWx0ZXIuYzozNzAKKyM6IHJlZi1maWx0ZXIuYzozNzMKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5yZWNvZ25pemVkICUlKG9iamVjdG5hbWUpIGFyZ3VtZW50OiAlcyIKIG1zZ3N0ciAi0L3QtdC/0L7Qt9C90LDRgiDQsNGA0LPRg9C80LXQvdGCINC30LAgJSUob2JqZWN0bmFtZSk6ICVzIgogCi0jOiByZWYtZmlsdGVyLmM6NDAwCisjOiByZWYtZmlsdGVyLmM6NDAzCiAjLCBjLWZvcm1hdAogbXNnaWQgImV4cGVjdGVkIGZvcm1hdDogJSUoYWxpZ246PHdpZHRoPiw8cG9zaXRpb24+KSIKIG1zZ3N0ciAi0L7Rh9Cw0LrQstCw0L0g0YTQvtGA0LzQsNGCOiAlJShhbGlnbjrQqNCY0KDQntCn0JjQndCQLNCf0J7Ql9CY0KbQmNCvKSIKIAotIzogcmVmLWZpbHRlci5jOjQxMgorIzogcmVmLWZpbHRlci5jOjQxNQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bnJlY29nbml6ZWQgcG9zaXRpb246JXMiCiBtc2dzdHIgItC90LXQv9C+0LfQvdCw0YLQsCDQv9C+0LfQuNGG0LjRjzogJXMiCiAKLSM6IHJlZi1maWx0ZXIuYzo0MTkKKyM6IHJlZi1maWx0ZXIuYzo0MjIKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5yZWNvZ25pemVkIHdpZHRoOiVzIgogbXNnc3RyICLQvdC10L/QvtC30L3QsNGC0LAg0YjQuNGA0L7Rh9C40L3QsDogJXMiCiAKLSM6IHJlZi1maWx0ZXIuYzo0MjgKKyM6IHJlZi1maWx0ZXIuYzo0MzEKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5yZWNvZ25pemVkICUlKGFsaWduKSBhcmd1bWVudDogJXMiCiBtc2dzdHIgItC90LXQv9C+0LfQvdCw0YIg0LDRgNCz0YPQvNC10L3RgiDQt9CwICUlKGFsaWduKTogJXMiCiAKLSM6IHJlZi1maWx0ZXIuYzo0MzYKKyM6IHJlZi1maWx0ZXIuYzo0MzkKICMsIGMtZm9ybWF0CiBtc2dpZCAicG9zaXRpdmUgd2lkdGggZXhwZWN0ZWQgd2l0aCB0aGUgJSUoYWxpZ24pIGF0b20iCiBtc2dzdHIgItC+0YfQsNC60LLQsCDRgdC1INC/0L7Qu9C+0LbQuNGC0LXQu9C90LAg0YjQuNGA0L7Rh9C40L3QsCDRgSDQu9C10LrRgdC10LzQsNGC0LAg4oCeJSUoYWxpZ24p4oCcIgogCi0jOiByZWYtZmlsdGVyLmM6NDU0CisjOiByZWYtZmlsdGVyLmM6NDU3CiAjLCBjLWZvcm1hdAogbXNnaWQgInVucmVjb2duaXplZCAlJShpZikgYXJndW1lbnQ6ICVzIgogbXNnc3RyICLQvdC10L/QvtC30L3QsNGCINCw0YDQs9GD0LzQtdC90YIg0LfQsCDigJ4lJShpZinigJw6ICVzIgogCi0jOiByZWYtZmlsdGVyLmM6NTU2CisjOiByZWYtZmlsdGVyLmM6NTU5CiAjLCBjLWZvcm1hdAogbXNnaWQgIm1hbGZvcm1lZCBmaWVsZCBuYW1lOiAlLipzIgogbXNnc3RyICLQvdC10L/RgNCw0LLQuNC70L3QviDQuNC80LUg0L3QsCDQvtCx0LXQutGCOiDigJ4lLipz4oCcIgogCi0jOiByZWYtZmlsdGVyLmM6NTgzCisjOiByZWYtZmlsdGVyLmM6NTg2CiAjLCBjLWZvcm1hdAogbXNnaWQgInVua25vd24gZmllbGQgbmFtZTogJS4qcyIKIG1zZ3N0ciAi0L3QtdC/0L7Qt9C90LDRgtC+INC40LzQtSDQvdCwINC+0LHQtdC60YI6IOKAniUuKnPigJwiCiAKLSM6IHJlZi1maWx0ZXIuYzo1ODcKKyM6IHJlZi1maWx0ZXIuYzo1OTAKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIm5vdCBhIGdpdCByZXBvc2l0b3J5LCBidXQgdGhlIGZpZWxkICclLipzJyByZXF1aXJlcyBhY2Nlc3MgdG8gb2JqZWN0IGRhdGEiCiBtc2dzdHIgItC90LUg0LUg0YXRgNCw0L3QuNC70LjRidC1INC90LAgZ2l0LCDQsCDQv9C+0LvQtdGC0L4g4oCeJS4qc+KAnCDQuNC30LjRgdC60LLQsCDQtNC+0YHRgtGK0L8g0LTQsNC90L3QuCDQvdCwINC+0LHQtdC60YLQvdC4IgogCi0jOiByZWYtZmlsdGVyLmM6NzExCisjOiByZWYtZmlsdGVyLmM6NzE0CiAjLCBjLWZvcm1hdAogbXNnaWQgImZvcm1hdDogJSUoaWYpIGF0b20gdXNlZCB3aXRob3V0IGEgJSUodGhlbikgYXRvbSIKIG1zZ3N0ciAi0YTQvtGA0LzQsNGCOiDQu9C10LrRgdC10LzQsNGC0LAgJSUoaWYpINC1INC40LfQv9C+0LvQt9Cy0LDQvdCwINCx0LXQtyDRgdGK0L7RgtCy0LXRgtC90LDRgtCwINGdICUlKHRoZW4pIgogCi0jOiByZWYtZmlsdGVyLmM6Nzc0CisjOiByZWYtZmlsdGVyLmM6Nzc3CiAjLCBjLWZvcm1hdAogbXNnaWQgImZvcm1hdDogJSUodGhlbikgYXRvbSB1c2VkIHdpdGhvdXQgYW4gJSUoaWYpIGF0b20iCiBtc2dzdHIgItGE0L7RgNC80LDRgjog0LvQtdC60YHQtdC80LDRgtCwICUlKHRoZW4pINC1INC40LfQv9C+0LvQt9Cy0LDQvdCwINCx0LXQtyDRgdGK0L7RgtCy0LXRgtC90LDRgtCwINGdICUlKGlmKSIKIAotIzogcmVmLWZpbHRlci5jOjc3NgorIzogcmVmLWZpbHRlci5jOjc3OQogIywgYy1mb3JtYXQKIG1zZ2lkICJmb3JtYXQ6ICUlKHRoZW4pIGF0b20gdXNlZCBtb3JlIHRoYW4gb25jZSIKIG1zZ3N0ciAi0YTQvtGA0LzQsNGCOiDQu9C10LrRgdC10LzQsNGC0LAgJSUodGhlbikg0LUg0LjQt9C/0L7Qu9C30LLQsNC90LAg0L/QvtCy0LXRh9C1INC+0YIg0LXQtNC40L0g0L/RitGCIgogCi0jOiByZWYtZmlsdGVyLmM6Nzc4CisjOiByZWYtZmlsdGVyLmM6NzgxCiAjLCBjLWZvcm1hdAogbXNnaWQgImZvcm1hdDogJSUodGhlbikgYXRvbSB1c2VkIGFmdGVyICUlKGVsc2UpIgogbXNnc3RyICLRhNC+0YDQvNCw0YI6INC70LXQutGB0LXQvNCw0YLQsCAlJSh0aGVuKSDQtSDQuNC30L/QvtC70LfQstCw0L3QsCDRgdC70LXQtCAlJShlbHNlKSIKIAotIzogcmVmLWZpbHRlci5jOjgwNgorIzogcmVmLWZpbHRlci5jOjgwOQogIywgYy1mb3JtYXQKIG1zZ2lkICJmb3JtYXQ6ICUlKGVsc2UpIGF0b20gdXNlZCB3aXRob3V0IGFuICUlKGlmKSBhdG9tIgogbXNnc3RyICLRhNC+0YDQvNCw0YI6INC70LXQutGB0LXQvNCw0YLQsCAlJShlbHNlKSDQtSDQuNC30L/QvtC70LfQstCw0L3QsCDQsdC10Lcg0YHRitC+0YLQstC10YLQvdCw0YLQsCDRnSAlJShpZikiCiAKLSM6IHJlZi1maWx0ZXIuYzo4MDgKKyM6IHJlZi1maWx0ZXIuYzo4MTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiZm9ybWF0OiAlJShlbHNlKSBhdG9tIHVzZWQgd2l0aG91dCBhICUlKHRoZW4pIGF0b20iCiBtc2dzdHIgItGE0L7RgNC80LDRgjog0LvQtdC60YHQtdC80LDRgtCwICUlKGVsc2UpINC1INC40LfQv9C+0LvQt9Cy0LDQvdCwINCx0LXQtyDRgdGK0L7RgtCy0LXRgtC90LDRgtCwINGdICUlKHRoZW4pIgogCi0jOiByZWYtZmlsdGVyLmM6ODEwCisjOiByZWYtZmlsdGVyLmM6ODEzCiAjLCBjLWZvcm1hdAogbXNnaWQgImZvcm1hdDogJSUoZWxzZSkgYXRvbSB1c2VkIG1vcmUgdGhhbiBvbmNlIgogbXNnc3RyICLRhNC+0YDQvNCw0YI6INC70LXQutGB0LXQvNCw0YLQsCAlJShlbHNlKSDQtSDQuNC30L/QvtC70LfQstCw0L3QsCDQv9C+0LLQtdGH0LUg0L7RgiDQtdC00LjQvSDQv9GK0YIiCiAKLSM6IHJlZi1maWx0ZXIuYzo4MjUKKyM6IHJlZi1maWx0ZXIuYzo4MjgKICMsIGMtZm9ybWF0CiBtc2dpZCAiZm9ybWF0OiAlJShlbmQpIGF0b20gdXNlZCB3aXRob3V0IGNvcnJlc3BvbmRpbmcgYXRvbSIKIG1zZ3N0ciAi0YTQvtGA0LzQsNGCOiDQu9C10LrRgdC10LzQsNGC0LAgJSUoZW5kKSDQtSDQuNC30L/QvtC70LfQstCw0L3QsCDQsdC10Lcg0YHRitC+0YLQstC10YLQvdCw0YLQsCDRnSIKIAotIzogcmVmLWZpbHRlci5jOjg4MgorIzogcmVmLWZpbHRlci5jOjg4NQogIywgYy1mb3JtYXQKIG1zZ2lkICJtYWxmb3JtZWQgZm9ybWF0IHN0cmluZyAlcyIKIG1zZ3N0ciAi0L3QtdC/0YDQsNCy0LjQu9C10L0g0YTQvtGA0LzQsNGC0LjRgNCw0Ykg0L3QuNC3IOKAniVz4oCcIgogCi0jOiByZWYtZmlsdGVyLmM6MTQ4NQorIzogcmVmLWZpbHRlci5jOjE0ODgKICMsIGMtZm9ybWF0CiBtc2dpZCAibm8gYnJhbmNoLCByZWJhc2luZyAlcyIKIG1zZ3N0ciAi0LjQt9Cy0YrQvSDQutC70L7QvSwg0L/RgNC10LHQsNC30LjRgNCw0L3QtSDQvdCwIOKAniVz4oCcIgogCi0jOiByZWYtZmlsdGVyLmM6MTQ4OAorIzogcmVmLWZpbHRlci5jOjE0OTEKICMsIGMtZm9ybWF0CiBtc2dpZCAibm8gYnJhbmNoLCByZWJhc2luZyBkZXRhY2hlZCBIRUFEICVzIgogbXNnc3RyICLQuNC30LLRitC9INC60LvQvtC9LCDQv9GA0LXQsdCw0LfQuNGA0LDQvdC1INC90LAg0L3QtdGB0LLRitGA0LfQsNC9INGD0LrQsNC30LDRgtC10Lsg4oCeSEVBROKAnCDQv9GA0Lgg4oCeJXPigJwiCiAKLSM6IHJlZi1maWx0ZXIuYzoxNDkxCisjOiByZWYtZmlsdGVyLmM6MTQ5NAogIywgYy1mb3JtYXQKIG1zZ2lkICJubyBicmFuY2gsIGJpc2VjdCBzdGFydGVkIG9uICVzIgogbXNnc3RyICLQuNC30LLRitC9INC60LvQvtC9LCDQtNCy0L7QuNGH0L3QviDRgtGK0YDRgdC10L3QtSDQvtGCIOKAniVz4oCcIgogCi0jOiByZWYtZmlsdGVyLmM6MTUwMQorIzogcmVmLWZpbHRlci5jOjE1MDQKIG1zZ2lkICJubyBicmFuY2giCiBtc2dzdHIgItC40LfQstGK0L0g0LrQu9C+0L0iCiAKLSM6IHJlZi1maWx0ZXIuYzoxNTM3IHJlZi1maWx0ZXIuYzoxNzQzCisjOiByZWYtZmlsdGVyLmM6MTU0MCByZWYtZmlsdGVyLmM6MTc0OQogIywgYy1mb3JtYXQKIG1zZ2lkICJtaXNzaW5nIG9iamVjdCAlcyBmb3IgJXMiCiBtc2dzdHIgItC+0LHQtdC60YLRitGCIOKAniVz4oCcINC70LjQv9GB0LLQsCDQt9CwIOKAniVz4oCcIgogCi0jOiByZWYtZmlsdGVyLmM6MTU0NworIzogcmVmLWZpbHRlci5jOjE1NTAKICMsIGMtZm9ybWF0CiBtc2dpZCAicGFyc2Vfb2JqZWN0X2J1ZmZlciBmYWlsZWQgb24gJXMgZm9yICVzIgogbXNnc3RyICLQvdC10YPRgdC/0LXRiNC90L4g0LDQvdCw0LvQuNC30LjRgNCw0L3QtSDRh9GA0LXQtyDigJ5wYXJzZV9vYmplY3RfYnVmZmVy4oCcINC90LAg4oCeJXPigJwg0LfQsCDigJ4lc+KAnCIKIAotIzogcmVmLWZpbHRlci5jOjE5OTgKKyM6IHJlZi1maWx0ZXIuYzoyMDA0CiAjLCBjLWZvcm1hdAogbXNnaWQgIm1hbGZvcm1lZCBvYmplY3QgYXQgJyVzJyIKIG1zZ3N0ciAi0L7QsdC10LrRgiDRgdGK0YEg0YHQs9GA0LXRiNC10L0g0YTQvtGA0LzQsNGCINC/0YDQuCDigJ4lc+KAnCIKIAotIzogcmVmLWZpbHRlci5jOjIwODcKKyM6IHJlZi1maWx0ZXIuYzoyMDkzCiAjLCBjLWZvcm1hdAogbXNnaWQgImlnbm9yaW5nIHJlZiB3aXRoIGJyb2tlbiBuYW1lICVzIgogbXNnc3RyICLQuNCz0L3QvtGA0LjRgNCw0L3QtSDQvdCwINGD0LrQsNC30LDRgtC10LvRjyDRgSDQs9GA0LXRiNC90L4g0LjQvNC1IOKAniVz4oCcIgogCi0jOiByZWYtZmlsdGVyLmM6MjM4MgorIzogcmVmLWZpbHRlci5jOjIzODkKICMsIGMtZm9ybWF0CiBtc2dpZCAiZm9ybWF0OiAlJShlbmQpIGF0b20gbWlzc2luZyIKIG1zZ3N0ciAi0LPRgNC10YjQutCwINCy0YrQsiDRhNC+0YDQvNCwzIDRgtCwOiDQu9C40L/RgdCy0LAg0LvQtdC60YHQtdC80LDRgtCwICUlKGVuZCkiCiAKLSM6IHJlZi1maWx0ZXIuYzoyNDgyCisjOiByZWYtZmlsdGVyLmM6MjQ4OQogIywgYy1mb3JtYXQKIG1zZ2lkICJvcHRpb24gYCVzJyBpcyBpbmNvbXBhdGlibGUgd2l0aCAtLW1lcmdlZCIKIG1zZ3N0ciAi0L7Qv9GG0LjQuNGC0LUg4oCeJXPigJwg0Lgg4oCeLS1tZXJnZWTigJwg0YHQsCDQvdC10YHRitCy0LzQtdGB0YLQuNC80LgiCiAKLSM6IHJlZi1maWx0ZXIuYzoyNDg1CisjOiByZWYtZmlsdGVyLmM6MjQ5MgogIywgYy1mb3JtYXQKIG1zZ2lkICJvcHRpb24gYCVzJyBpcyBpbmNvbXBhdGlibGUgd2l0aCAtLW5vLW1lcmdlZCIKIG1zZ3N0ciAi0L7Qv9GG0LjQuNGC0LUg4oCeJXPigJwg0Lgg4oCeLS1uby1tZXJnZWTigJwg0YHQsCDQvdC10YHRitCy0LzQtdGB0YLQuNC80LgiCiAKLSM6IHJlZi1maWx0ZXIuYzoyNDk1CisjOiByZWYtZmlsdGVyLmM6MjUwMgogIywgYy1mb3JtYXQKIG1zZ2lkICJtYWxmb3JtZWQgb2JqZWN0IG5hbWUgJXMiCiBtc2dzdHIgItC90LXQv9GA0LDQstC40LvQvdC+INC40LzQtSDQvdCwINC+0LHQtdC60YIg4oCeJXPigJwiCiAKLSM6IHJlZi1maWx0ZXIuYzoyNTAwCisjOiByZWYtZmlsdGVyLmM6MjUwNwogIywgYy1mb3JtYXQKIG1zZ2lkICJvcHRpb24gYCVzJyBtdXN0IHBvaW50IHRvIGEgY29tbWl0IgogbXNnc3RyICLQvtC/0YbQuNGP0YLQsCDigJ4lc+KAnCDQvdC1INGB0L7Rh9C4INC60YrQvCDQv9C+0LTQsNCy0LDQvdC1IgogCi0jOiByZW1vdGUuYzozNjMKKyM6IHJlbW90ZS5jOjM2NgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb25maWcgcmVtb3RlIHNob3J0aGFuZCBjYW5ub3QgYmVnaW4gd2l0aCAnLyc6ICVzIgogbXNnc3RyICIiCiAi0YHRitC60YDQsNGJ0LXQvdC40LXRgtC+INC30LAg0L7RgtC00LDQu9C10YfQtdC90L4g0YXRgNCw0L3QuNC70LjRidC1INC90LUg0LzQvtC20LUg0LfQsCDQt9Cw0L/QvtGH0LLQsCDRgdGK0YEg0LfQvdCw0LrQsCDigJ4v4oCcOiAlcyIKIAotIzogcmVtb3RlLmM6NDEwCisjOiByZW1vdGUuYzo0MTMKIG1zZ2lkICJtb3JlIHRoYW4gb25lIHJlY2VpdmVwYWNrIGdpdmVuLCB1c2luZyB0aGUgZmlyc3QiCiBtc2dzdHIgItC30LDQtNCw0LTQtdC9INC1INC/0L7QstC10YfQtSDQvtGCINC10LTQuNC9INC/0LDQutC10YIg0LfQsCDQv9C+0LvRg9GH0LDQstCw0L3QtSwg0YnQtSDRgdC1INC/0L7Qu9C30LLQsCDQv9GK0YDQstC40Y/RgiIKIAotIzogcmVtb3RlLmM6NDE4CisjOiByZW1vdGUuYzo0MjEKIG1zZ2lkICJtb3JlIHRoYW4gb25lIHVwbG9hZHBhY2sgZ2l2ZW4sIHVzaW5nIHRoZSBmaXJzdCIKIG1zZ3N0ciAi0LfQsNC00LDQtNC10L0g0LUg0L/QvtCy0LXRh9C1INC+0YIg0LXQtNC40L0g0L/QsNC60LXRgiDQt9CwINC40LfQv9GA0LDRidCw0L3QtSwg0YnQtSDRgdC1INC/0L7Qu9C30LLQsCDQv9GK0YDQstC40Y/RgiIKIAotIzogcmVtb3RlLmM6NjA4CisjOiByZW1vdGUuYzo2MTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ2Fubm90IGZldGNoIGJvdGggJXMgYW5kICVzIHRvICVzIgogbXNnc3RyICLQndC10LLRitC30LzQvtC20L3QviDQtSDQtNCwINGB0LUg0LTQvtGB0YLQsNCy0Y/RgiDQtdC00L3QvtCy0YDQtdC80LXQvdC90L4g0Lgg4oCeJXPigJwsINC4IOKAniVz4oCcINC60YrQvCDigJ4lc+KAnCIKIAotIzogcmVtb3RlLmM6NjEyCisjOiByZW1vdGUuYzo2MTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgdXN1YWxseSB0cmFja3MgJXMsIG5vdCAlcyIKIG1zZ3N0ciAi4oCeJXPigJwg0L7QsdC40LrQvdC+0LLQtdC90L4g0YHQu9C10LTQuCDigJ4lc+KAnCwg0LAg0L3QtSDigJ4lc+KAnCIKIAotIzogcmVtb3RlLmM6NjE2CisjOiByZW1vdGUuYzo2MTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgdHJhY2tzIGJvdGggJXMgYW5kICVzIgogbXNnc3RyICLigJ4lc+KAnCDRgdC70LXQtNC4INC60LDQutGC0L4g4oCeJXPigJwsINGC0LDQutCwINC4IOKAniVz4oCcIgogCi0jOiByZW1vdGUuYzo2ODQKKyM6IHJlbW90ZS5jOjY4NwogIywgYy1mb3JtYXQKIG1zZ2lkICJrZXkgJyVzJyBvZiBwYXR0ZXJuIGhhZCBubyAnKiciCiBtc2dzdHIgItC60LvRjtGHIOKAniVz4oCcINC90LAg0YjQsNCx0LvQvtC90LAg0L3QtSDRgdGK0LTRitGA0LbQsCDigJ4q4oCcIgogCi0jOiByZW1vdGUuYzo2OTQKKyM6IHJlbW90ZS5jOjY5NwogIywgYy1mb3JtYXQKIG1zZ2lkICJ2YWx1ZSAnJXMnIG9mIHBhdHRlcm4gaGFzIG5vICcqJyIKIG1zZ3N0ciAi0YHRgtC+0LnQvdC+0YHRgiDigJ4lc+KAnCDQvdCwINGI0LDQsdC70L7QvdCwINC90LUg0YHRitC00YrRgNC20LAg4oCeKuKAnCIKIAotIzogcmVtb3RlLmM6MTAwMAorIzogcmVtb3RlLmM6MTAwMwogIywgYy1mb3JtYXQKIG1zZ2lkICJzcmMgcmVmc3BlYyAlcyBkb2VzIG5vdCBtYXRjaCBhbnkiCiBtc2dzdHIgItGD0LrQsNC30LDRgtC10LvRj9GCINC90LAg0LLQtdGA0YHQuNGPLdC40LfRgtC+0YfQvdC40Log4oCeJXPigJwg0L3QtSDRgdGK0LLQv9Cw0LTQsCDRgSDQvdC40LrQvtC5INC+0LHQtdC60YIiCiAKLSM6IHJlbW90ZS5jOjEwMDUKKyM6IHJlbW90ZS5jOjEwMDgKICMsIGMtZm9ybWF0CiBtc2dpZCAic3JjIHJlZnNwZWMgJXMgbWF0Y2hlcyBtb3JlIHRoYW4gb25lIgogbXNnc3RyICLRg9C60LDQt9Cw0YLQtdC70Y/RgiDQvdCwINCy0LXRgNGB0LjRjy3QuNC30YLQvtGH0L3QuNC6IOKAniVz4oCcINGB0YrQstC/0LDQtNCwINGBINC/0L7QstC10YfQtSDQvtGCINC10LTQuNC9INC+0LHQtdC60YIiCkBAIC01NTkxLDcgKzU2MjYsNyBAQAogIy4gPHJlbW90ZT4gPHNyYz46PGRzdD4iIHB1c2gsIGFuZCAiYmVpbmcgcHVzaGVkICgnJXMnKSIgaXMKICMuIHRoZSA8c3JjPi4KICMuCi0jOiByZW1vdGUuYzoxMDIwCisjOiByZW1vdGUuYzoxMDIzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgZGVzdGluYXRpb24geW91IHByb3ZpZGVkIGlzIG5vdCBhIGZ1bGwgcmVmbmFtZSAoaS5lLixcbiIKQEAgLTU2MTUsNyArNTY1MCw3IEBACiAi0J3QuNC60L7QuSDQvtGCINCy0LDRgNC40LDQvdGC0LjRgtC1INC90LUg0YHRgNCw0LHQvtGC0LguICDQotGA0Y/QsdCy0LAg0YHQsNC80Lgg0LTQsCDRg9C60LDQttC10YLQtSDQv9GK0LvQvdC+0YLQviDQuNC80LUg0L3QsFxuIgogItGD0LrQsNC30LDRgtC10LvRjy4iCiAKLSM6IHJlbW90ZS5jOjEwNDAKKyM6IHJlbW90ZS5jOjEwNDMKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlRoZSA8c3JjPiBwYXJ0IG9mIHRoZSByZWZzcGVjIGlzIGEgY29tbWl0IG9iamVjdC5cbiIKQEAgLTU2MjYsNyArNTY2MSw3IEBACiAi0LrQsNGC0L5cbiIKICLQuNC30YLQu9Cw0YHQutCw0YLQtSDQutGK0Lwg4oCeJXM6cmVmcy9oZWFkcy8lc+KAnD8iCiAKLSM6IHJlbW90ZS5jOjEwNDUKKyM6IHJlbW90ZS5jOjEwNDgKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlRoZSA8c3JjPiBwYXJ0IG9mIHRoZSByZWZzcGVjIGlzIGEgdGFnIG9iamVjdC5cbiIKQEAgLTU2MzcsNyArNTY3Miw3IEBACiAi0LrQsNGC0L5cbiIKICLQuNC30YLQu9Cw0YHQutCw0YLQtSDQutGK0Lwg4oCeJXM6cmVmcy90YWdzLyVz4oCcPyIKIAotIzogcmVtb3RlLmM6MTA1MAorIzogcmVtb3RlLmM6MTA1MwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiVGhlIDxzcmM+IHBhcnQgb2YgdGhlIHJlZnNwZWMgaXMgYSB0cmVlIG9iamVjdC5cbiIKQEAgLTU2NDcsNyArNTY4Miw3IEBACiAi0JjQl9Ci0J7Qp9Cd0JjQmtGK0YIg0LUg0L7QsdC10LrRgi3QtNGK0YDQstC+LiAg0J3QtSDRhtC10LvQuNGC0LUg0LvQuCDQstGB0YrRidC90L7RgdGCINC00LAg0YHRitC30LTQsNC00LXRgtC1INC90L7QsiDQutC70L7QvSDQutCw0YLQvlxuIgogItC40LfRgtC70LDRgdC60LDRgtC1INC60YrQvCDigJ4lczpyZWZzL3RhZ3MvJXPigJw/IgogCi0jOiByZW1vdGUuYzoxMDU1CisjOiByZW1vdGUuYzoxMDU4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgPHNyYz4gcGFydCBvZiB0aGUgcmVmc3BlYyBpcyBhIGJsb2Igb2JqZWN0LlxuIgpAQCAtNTY1NywxMTggKzU2OTIsMTE4IEBACiAi0JjQl9Ci0J7Qp9Cd0JjQmtGK0YIg0LUg0L7QsdC10LrRgi1CTE9CLiAg0J3QtSDRhtC10LvQuNGC0LUg0LvQuCDQstGB0YrRidC90L7RgdGCINC00LAg0YHRitC30LTQsNC00LXRgtC1INC90L7QsiDQutC70L7QvSDQutCw0YLQvlxuIgogItC40LfRgtC70LDRgdC60LDRgtC1INC60YrQvCDigJ4lczpyZWZzL3RhZ3MvJXPigJw/IgogCi0jOiByZW1vdGUuYzoxMDkxCisjOiByZW1vdGUuYzoxMDk0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIGNhbm5vdCBiZSByZXNvbHZlZCB0byBicmFuY2giCiBtc2dzdHIgItC90LUg0LUg0L7RgtC60YDQuNGCINC60LvQvtC9INGB0YrQvtGC0LLQtdGC0YHRgtCy0LDRiSDQvdCwIOKAniVz4oCcIgogCi0jOiByZW1vdGUuYzoxMTAyCisjOiByZW1vdGUuYzoxMTA1CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBkZWxldGUgJyVzJzogcmVtb3RlIHJlZiBkb2VzIG5vdCBleGlzdCIKIG1zZ3N0ciAi4oCeJXPigJwg0L3QtSDQvNC+0LbQtSDQtNCwINGB0LUg0LjQt9GC0YDQuNC1OiDQvtGC0LTQsNC70LXRh9C10L3QuNGPINGD0LrQsNC30LDRgtC10Lsg0L3QtSDRgdGK0YnQtdGB0YLQstGD0LLQsCIKIAotIzogcmVtb3RlLmM6MTExNAorIzogcmVtb3RlLmM6MTExNwogIywgYy1mb3JtYXQKIG1zZ2lkICJkc3QgcmVmc3BlYyAlcyBtYXRjaGVzIG1vcmUgdGhhbiBvbmUiCiBtc2dzdHIgItGD0LrQsNC30LDRgtC10LvRj9GCINC90LAg0LLQtdGA0YHQuNGPLdGG0LXQuyDigJ4lc+KAnCDRgdGK0LLQv9Cw0LTQsCDRgSDQv9C+0LLQtdGH0LUg0L7RgiDQtdC00LjQvSDQvtCx0LXQutGCIgogCi0jOiByZW1vdGUuYzoxMTIxCisjOiByZW1vdGUuYzoxMTI0CiAjLCBjLWZvcm1hdAogbXNnaWQgImRzdCByZWYgJXMgcmVjZWl2ZXMgZnJvbSBtb3JlIHRoYW4gb25lIHNyYyIKIG1zZ3N0ciAiIgogItGD0LrQsNC30LDRgtC10LvRj9GCINC90LAg0LLQtdGA0YHQuNGPLdGG0LXQuyDigJ4lc+KAnCDRgdGK0L7RgtCy0LXRgtGB0YLQstCwINC4INGJ0LUg0L/QvtC70YPRh9Cw0LLQsCDQvtGCINC/0L7QstC10YfQtSDQvtGCINC10LTQuNC9ICIKICLQuNC30YLQvtGH0L3QuNC6IgogCi0jOiByZW1vdGUuYzoxNjI0IHJlbW90ZS5jOjE3MjUKKyM6IHJlbW90ZS5jOjE2MjcgcmVtb3RlLmM6MTcyOAogbXNnaWQgIkhFQUQgZG9lcyBub3QgcG9pbnQgdG8gYSBicmFuY2giCiBtc2dzdHIgItCj0LrQsNC30LDRgtC10LvRj9GCIOKAnkhFQUTigJwg0L3QtSDRgdC+0YfQuCDQutGK0Lwg0LrQu9C+0L0iCiAKLSM6IHJlbW90ZS5jOjE2MzMKKyM6IHJlbW90ZS5jOjE2MzYKICMsIGMtZm9ybWF0CiBtc2dpZCAibm8gc3VjaCBicmFuY2g6ICclcyciCiBtc2dzdHIgItC90Y/QvNCwINC60LvQvtC9INC90LAg0LjQvNC1IOKAniVz4oCcIgogCi0jOiByZW1vdGUuYzoxNjM2CisjOiByZW1vdGUuYzoxNjM5CiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vIHVwc3RyZWFtIGNvbmZpZ3VyZWQgZm9yIGJyYW5jaCAnJXMnIgogbXNnc3RyICLQvdC1INC1INC30LDQtNCw0LTQtdC9INC60LvQvtC9LdC40LfRgtC+0YfQvdC40Log0LfQsCDQutC70L7QvdCwIOKAniVz4oCcIgogCi0jOiByZW1vdGUuYzoxNjQyCisjOiByZW1vdGUuYzoxNjQ1CiAjLCBjLWZvcm1hdAogbXNnaWQgInVwc3RyZWFtIGJyYW5jaCAnJXMnIG5vdCBzdG9yZWQgYXMgYSByZW1vdGUtdHJhY2tpbmcgYnJhbmNoIgogbXNnc3RyICLQutC70L7QvdGK0YIt0LjQt9GC0L7Rh9C90LjQuiDigJ4lc+KAnCDQvdC1INC1INGB0YrRhdGA0LDQvdC10L0g0LrQsNGC0L4g0YHQu9C10LTRj9GJINC60LvQvtC9IgogCi0jOiByZW1vdGUuYzoxNjU3CisjOiByZW1vdGUuYzoxNjYwCiAjLCBjLWZvcm1hdAogbXNnaWQgInB1c2ggZGVzdGluYXRpb24gJyVzJyBvbiByZW1vdGUgJyVzJyBoYXMgbm8gbG9jYWwgdHJhY2tpbmcgYnJhbmNoIgogbXNnc3RyICIiCiAi0LvQuNC/0YHQstCwINC70L7QutCw0LvQtdC9INGB0LvQtdC00Y/RiSDQutC70L7QvSDQt9CwINC80LXRgdGC0L7Qv9C+0LvQvtC20LXQvdC40LXRgtC+INC30LAg0LjQt9GC0LvQsNGB0LrQstCw0L3QtSDigJ4lc+KAnCDQsiAiCiAi0YXRgNCw0L3QuNC70LjRidC10YLQviDigJ4lc+KAnCIKIAotIzogcmVtb3RlLmM6MTY2OQorIzogcmVtb3RlLmM6MTY3MgogIywgYy1mb3JtYXQKIG1zZ2lkICJicmFuY2ggJyVzJyBoYXMgbm8gcmVtb3RlIGZvciBwdXNoaW5nIgogbXNnc3RyICLQvdGP0LzQsCDQuNC90YTQvtGA0LzQsNGG0LjRjyDQutC70L7QvdGK0YIg4oCeJXPigJwg0LTQsCDRgdC70LXQtNC4INC90Y/QutC+0Lkg0LTRgNGD0LMiCiAKLSM6IHJlbW90ZS5jOjE2NzkKKyM6IHJlbW90ZS5jOjE2ODIKICMsIGMtZm9ybWF0CiBtc2dpZCAicHVzaCByZWZzcGVjcyBmb3IgJyVzJyBkbyBub3QgaW5jbHVkZSAnJXMnIgogbXNnc3RyICLRg9C60LDQt9Cw0YLQtdC70Y/RgiDQt9CwINC40LfRgtC70LDRgdC60LLQsNC90LUg0L3QsCDigJ4lc+KAnCDQvdC1INCy0LrQu9GO0YfQstCwIOKAniVz4oCcIgogCi0jOiByZW1vdGUuYzoxNjkyCisjOiByZW1vdGUuYzoxNjk1CiBtc2dpZCAicHVzaCBoYXMgbm8gZGVzdGluYXRpb24gKHB1c2guZGVmYXVsdCBpcyAnbm90aGluZycpIgogbXNnc3RyICLRg9C60LDQt9Cw0YLQtdC70Y/RgiDQt9CwINC40LfRgtC70LDRgdC60LLQsNC90LUg0L3QtSDQstC60LvRjtGH0LLQsCDRhtC10LsgKOKAnnB1c2guZGVmYXVsdOKAnCDQtSDigJ5ub3RoaW5n4oCcKSIKIAotIzogcmVtb3RlLmM6MTcxNAorIzogcmVtb3RlLmM6MTcxNwogbXNnaWQgImNhbm5vdCByZXNvbHZlICdzaW1wbGUnIHB1c2ggdG8gYSBzaW5nbGUgZGVzdGluYXRpb24iCiBtc2dzdHIgItC/0YDQvtGB0YLQvtGC0L4gKHNpbXBsZSkg0LjQt9GC0LvQsNGB0LrQstCw0L3QtSDQvdC1INGB0YrQvtGC0LLQtdGC0YHRgtCy0LAg0L3QsCDQtdC00L3QsCDRhtC10LsiCiAKLSM6IHJlbW90ZS5jOjE4NDAKKyM6IHJlbW90ZS5jOjE4NDMKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGRuJ3QgZmluZCByZW1vdGUgcmVmICVzIgogbXNnc3RyICLQvtGC0LTQsNC70LXRh9C10L3QuNGP0YIg0YPQutCw0LfQsNGC0LXQuyDigJ4lc+KAnCDQvdC1INC80L7QttC1INC00LAg0LHRitC00LUg0L7RgtC60YDQuNGCIgogCi0jOiByZW1vdGUuYzoxODUzCisjOiByZW1vdGUuYzoxODU2CiAjLCBjLWZvcm1hdAogbXNnaWQgIiogSWdub3JpbmcgZnVubnkgcmVmICclcycgbG9jYWxseSIKIG1zZ3N0ciAi4oCiINC/0YDQtdGB0LrQsNGH0LDQvdC1INC90LAg0L3QtdC+0YfQsNC60LLQsNC90LjRjyDQu9C+0LrQsNC70LXQvSDRg9C60LDQt9Cw0YLQtdC7IOKAniVz4oCcIgogCi0jOiByZW1vdGUuYzoyMDE2CisjOiByZW1vdGUuYzoyMDE5CiAjLCBjLWZvcm1hdAogbXNnaWQgIllvdXIgYnJhbmNoIGlzIGJhc2VkIG9uICclcycsIGJ1dCB0aGUgdXBzdHJlYW0gaXMgZ29uZS5cbiIKIG1zZ3N0ciAi0KLQvtC30Lgg0LrQu9C+0L0g0YHQu9C10LTQuCDigJ4lc+KAnCwg0L3QviDRgdC70LXQtNC10L3QuNGP0YIg0LrQu9C+0L0g0LUg0LjQt9GC0YDQuNGCLlxuIgogCi0jOiByZW1vdGUuYzoyMDIwCisjOiByZW1vdGUuYzoyMDIzCiBtc2dpZCAiICAodXNlIFwiZ2l0IGJyYW5jaCAtLXVuc2V0LXVwc3RyZWFtXCIgdG8gZml4dXApXG4iCiBtc2dzdHIgIiAgKNC30LAg0LTQsCDQutC+0YDQuNCz0LjRgNCw0YLQtSDRgtC+0LLQsCwg0LjQt9C/0L7Qu9C30LLQsNC50YLQtSDigJ5naXQgYnJhbmNoIC0tdW5zZXQtdXBzdHJlYW3igJwpXG4iCiAKLSM6IHJlbW90ZS5jOjIwMjMKKyM6IHJlbW90ZS5jOjIwMjYKICMsIGMtZm9ybWF0CiBtc2dpZCAiWW91ciBicmFuY2ggaXMgdXAgdG8gZGF0ZSB3aXRoICclcycuXG4iCiBtc2dzdHIgItCa0LvQvtC90YrRgiDQtSDQsNC60YLRg9Cw0LvQuNC30LjRgNCw0L0g0LrRitC8IOKAniVz4oCcLlxuIgogCi0jOiByZW1vdGUuYzoyMDI3CisjOiByZW1vdGUuYzoyMDMwCiAjLCBjLWZvcm1hdAogbXNnaWQgIllvdXIgYnJhbmNoIGFuZCAnJXMnIHJlZmVyIHRvIGRpZmZlcmVudCBjb21taXRzLlxuIgogbXNnc3RyICLQmtC70L7QvdGK0YIg0LLQuCDQuCDigJ4lc+KAnCDRgdC+0YfQsNGCINC60YrQvCDRgNCw0LfQu9C40YfQvdC4INC/0L7QtNCw0LLQsNC90LjRjy5cbiIKIAotIzogcmVtb3RlLmM6MjAzMAorIzogcmVtb3RlLmM6MjAzMwogIywgYy1mb3JtYXQKIG1zZ2lkICIgICh1c2UgXCIlc1wiIGZvciBkZXRhaWxzKVxuIgogbXNnc3RyICIgICjQt9CwINC/0L7QstC10YfQtSDQuNC90YTQvtGA0LzQsNGG0LjRjyDQv9C+0LvQt9Cy0LDQudGC0LUg4oCeJXPigJwpXG4iCiAKLSM6IHJlbW90ZS5jOjIwMzQKKyM6IHJlbW90ZS5jOjIwMzcKICMsIGMtZm9ybWF0CiBtc2dpZCAiWW91ciBicmFuY2ggaXMgYWhlYWQgb2YgJyVzJyBieSAlZCBjb21taXQuXG4iCiBtc2dpZF9wbHVyYWwgIllvdXIgYnJhbmNoIGlzIGFoZWFkIG9mICclcycgYnkgJWQgY29tbWl0cy5cbiIKIG1zZ3N0clswXSAi0JrQu9C+0L3RitGCINCy0Lgg0LUg0YEgJTIkZCDQv9C+0LTQsNCy0LDQvdC1INC/0YDQtdC0IOKAniUxJHPigJwuXG4iCiBtc2dzdHJbMV0gItCa0LvQvtC90YrRgiDQstC4INC1INGBICUyJGQg0L/QvtC00LDQstCw0L3QuNGPINC/0YDQtdC0IOKAniUxJHPigJwuXG4iCiAKLSM6IHJlbW90ZS5jOjIwNDAKKyM6IHJlbW90ZS5jOjIwNDMKIG1zZ2lkICIgICh1c2UgXCJnaXQgcHVzaFwiIHRvIHB1Ymxpc2ggeW91ciBsb2NhbCBjb21taXRzKVxuIgogbXNnc3RyICIgICjQv9GD0LHQu9C40LrRg9Cy0LDQudGC0LUg0LvQvtC60LDQu9C90LjRgtC1INGB0Lgg0L/RgNC+0LzQtdC90Lgg0YfRgNC10Lcg4oCeZ2l0IHB1c2jigJwpXG4iCiAKLSM6IHJlbW90ZS5jOjIwNDMKKyM6IHJlbW90ZS5jOjIwNDYKICMsIGMtZm9ybWF0CiBtc2dpZCAiWW91ciBicmFuY2ggaXMgYmVoaW5kICclcycgYnkgJWQgY29tbWl0LCBhbmQgY2FuIGJlIGZhc3QtZm9yd2FyZGVkLlxuIgogbXNnaWRfcGx1cmFsICIiCkBAIC01Nzc2LDExICs1ODExLDExIEBACiBtc2dzdHJbMF0gItCa0LvQvtC90YrRgiDQstC4INC1INGBICUyJGQg0L/QvtC00LDQstCw0L3QtSDQt9Cw0LQg4oCeJTEkc+KAnCDQuCDQvNC+0LbQtSDQtNCwINCx0YrQtNC1INC/0YDQtdCy0YrRgNGC0Y/QvS5cbiIKIG1zZ3N0clsxXSAi0JrQu9C+0L3RitGCINCy0Lgg0LUg0YEgJTIkZCDQv9C+0LTQsNCy0LDQvdC40Y8g0LfQsNC0IOKAniUxJHPigJwg0Lgg0LzQvtC20LUg0LTQsCDQsdGK0LTQtSDQv9GA0LXQstGK0YDRgtGP0L0uXG4iCiAKLSM6IHJlbW90ZS5jOjIwNTEKKyM6IHJlbW90ZS5jOjIwNTQKIG1zZ2lkICIgICh1c2UgXCJnaXQgcHVsbFwiIHRvIHVwZGF0ZSB5b3VyIGxvY2FsIGJyYW5jaClcbiIKIG1zZ3N0ciAiICAo0L7QsdC90L7QstC10YLQtSDQu9C+0LrQsNC70L3QuNGPINGB0Lgg0LrQu9C+0L0g0YfRgNC10Lcg4oCeZ2l0IHB1bGzigJwpXG4iCiAKLSM6IHJlbW90ZS5jOjIwNTQKKyM6IHJlbW90ZS5jOjIwNTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIllvdXIgYnJhbmNoIGFuZCAnJXMnIGhhdmUgZGl2ZXJnZWQsXG4iCkBAIC01Nzk1LDExICs1ODMwLDExIEBACiAi0KLQtdC60YPRidC40Y/RgiDQutC70L7QvSDRgdC1INC1INC+0YLQtNC10LvQuNC7INC+0YIg4oCeJXPigJwsXG4iCiAi0LTQstCw0YLQsCDQuNC80LDRgiDRgdGK0L7RgtCy0LXRgtC90L4g0L/QviAlZCDQuCAlZCDQvdC10YHRitCy0L/QsNC00LDRidC4INC/0L7QtNCw0LLQsNC90LjRjy5cbiIKIAotIzogcmVtb3RlLmM6MjA2NAorIzogcmVtb3RlLmM6MjA2NwogbXNnaWQgIiAgKHVzZSBcImdpdCBwdWxsXCIgdG8gbWVyZ2UgdGhlIHJlbW90ZSBicmFuY2ggaW50byB5b3VycylcbiIKIG1zZ3N0ciAiICAo0YHQu9C10LnRgtC1INC+0YLQtNCw0LvQtdGH0LXQvdC40Y8g0LrQu9C+0L0g0LIg0LvQvtC60LDQu9C90LjRjyDRh9GA0LXQtyDigJ5naXQgcHVsbOKAnClcbiIKIAotIzogcmVtb3RlLmM6MjI0NworIzogcmVtb3RlLmM6MjI1MAogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgcGFyc2UgZXhwZWN0ZWQgb2JqZWN0IG5hbWUgJyVzJyIKIG1zZ3N0ciAi0L7Rh9Cw0LrQstCw0L3QvtGC0L4g0LjQvNC1INC90LAg0L7QsdC10LrRgiDigJ4lc+KAnCDQvdC1INC80L7QttC1INC00LAg0LHRitC00LUg0LDQvdCw0LvQuNC30LjRgNCw0L3QviIKQEAgLTU4ODAsNyArNTkxNSw3IEBACiBtc2dpZCAiUmVjb3JkZWQgcHJlaW1hZ2UgZm9yICclcyciCiBtc2dzdHIgItCf0YDQtdC00LLQsNGA0LjRgtC10LvQvdC40Y/RgiDQstCw0YDQuNCw0L3RgiDQvdCwIOKAniVz4oCcINC1INC30LDQv9Cw0LfQtdC9IgogCi0jOiByZXJlcmUuYzo4ODEgc3VibW9kdWxlLmM6MjAyMyBidWlsdGluL2xvZy5jOjE3NzMKKyM6IHJlcmVyZS5jOjg4MSBzdWJtb2R1bGUuYzoyMDIzIGJ1aWx0aW4vbG9nLmM6MTc5MAogIzogYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjE0MTggYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjE0MjgKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGNyZWF0ZSBkaXJlY3RvcnkgJyVzJyIKQEAgLTU5MTUsMjAgKzU5NTAsMjAgQEAKIG1zZ2lkICJ1bmFibGUgdG8gb3BlbiByci1jYWNoZSBkaXJlY3RvcnkiCiBtc2dzdHIgItC00LjRgNC10LrRgtC+0YDQuNGP0YLQsCDigJ5yci1jYWNoZeKAnCDQvdC1INC80L7QttC1INC00LAg0YHQtSDQvtGC0LLQvtGA0LgiCiAKLSM6IHJldmlzaW9uLmM6MjUwNworIzogcmV2aXNpb24uYzoyNTA5CiBtc2dpZCAieW91ciBjdXJyZW50IGJyYW5jaCBhcHBlYXJzIHRvIGJlIGJyb2tlbiIKIG1zZ3N0ciAi0KLQtdC60YPRidC40Y/RgiDQutC70L7QvSDQtSDQv9C+0LLRgNC10LTQtdC9IgogCi0jOiByZXZpc2lvbi5jOjI1MTAKKyM6IHJldmlzaW9uLmM6MjUxMgogIywgYy1mb3JtYXQKIG1zZ2lkICJ5b3VyIGN1cnJlbnQgYnJhbmNoICclcycgZG9lcyBub3QgaGF2ZSBhbnkgY29tbWl0cyB5ZXQiCiBtc2dzdHIgItCi0LXQutGD0YnQuNGP0YIg0LrQu9C+0L0g4oCeJXPigJwg0LUg0LHQtdC3INC/0L7QtNCw0LLQsNC90LjRjyAiCiAKLSM6IHJldmlzaW9uLmM6MjcxMAorIzogcmV2aXNpb24uYzoyNzIwCiBtc2dpZCAiLS1maXJzdC1wYXJlbnQgaXMgaW5jb21wYXRpYmxlIHdpdGggLS1iaXNlY3QiCiBtc2dzdHIgItC+0L/RhtC40LjRgtC1IOKAni0tZmlyc3QtcGFyZW504oCcINC4IOKAni0tYmlzZWN04oCcINGB0LAg0L3QtdGB0YrQstC80LXRgdGC0LjQvNC4IgogCi0jOiByZXZpc2lvbi5jOjI3MTQKKyM6IHJldmlzaW9uLmM6MjcyNAogbXNnaWQgIi1MIGRvZXMgbm90IHlldCBzdXBwb3J0IGRpZmYgZm9ybWF0cyBiZXNpZGVzIC1wIGFuZCAtcyIKIG1zZ3N0ciAiIgogItC+0L/RhtC40Y/RgtCwIOKAni1M4oCcINC/0L7QtNC00YrRgNC20LAg0LXQtNC40L3RgdGC0LLQtdC90L4g0YTQvtGA0LzQsNGC0LjRgNCw0L3QtdGC0L4g0L3QsCDRgNCw0LfQu9C40LrQuNGC0LUg0YHQv9C+0YDQtdC0INC+0L/RhtC40LjRgtC1IOKAni0iCkBAIC01OTUzLDMyICs1OTg4LDMyIEBACiAi0JfQsCDQtNCwINC40LfQutC70Y7Rh9C40YLQtSDRgtC+0LLQsCDQv9GA0LXQtNGD0L/RgNC10LbQtNC10L3QuNC1LCDQuNC30L/RitC70L3QtdGC0LU6XG4iCiAiICAgIGdpdCBjb25maWcgYWR2aWNlLmlnbm9yZWRIb29rIGZhbHNlIgogCi0jOiBzZW5kLXBhY2suYzoxNDEKKyM6IHNlbmQtcGFjay5jOjE0MgogbXNnaWQgInVuZXhwZWN0ZWQgZmx1c2ggcGFja2V0IHdoaWxlIHJlYWRpbmcgcmVtb3RlIHVucGFjayBzdGF0dXMiCiBtc2dzdHIgIiIKICLQvdC10L7Rh9Cw0LrQstCw0L0g0LjQt9GH0LjRgdGC0LLQsNGJINC/0LDQutC10YIg4oCeZmx1c2jigJwg0L/RgNC4INC40LfRh9C40YLQsNC90LUg0L3QsCDRgdGK0YHRgtC+0Y/QvdC40LXRgtC+INC+0YIgIgogItC+0YLQtNCw0LvQtdGH0LXQvdC+0YLQviDRgNCw0LfQv9Cw0LrQtdGC0LjRgNCw0L3QtSIKIAotIzogc2VuZC1wYWNrLmM6MTQzCisjOiBzZW5kLXBhY2suYzoxNDQKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHBhcnNlIHJlbW90ZSB1bnBhY2sgc3RhdHVzOiAlcyIKIG1zZ3N0ciAiIgogItGB0YrRgdGC0L7Rj9C90LjQtdGC0L4g0L7RgiDQvtGC0LTQsNC70LXRh9C10L3QvtGC0L4g0YDQsNC30L/QsNC60LXRgtC40YDQsNC90LUg0L3QtSDQvNC+0LbQtSDQtNCwINCx0YrQtNC1INCw0L3QsNC70LjQt9C40YDQsNC90L46ICVzIgogCi0jOiBzZW5kLXBhY2suYzoxNDUKKyM6IHNlbmQtcGFjay5jOjE0NgogIywgYy1mb3JtYXQKIG1zZ2lkICJyZW1vdGUgdW5wYWNrIGZhaWxlZDogJXMiCiBtc2dzdHIgItC90LXRg9GB0L/QtdGI0L3QviDQvtGC0LTQsNC70LXRh9C10L3QviDRgNCw0LfQv9Cw0LrQtdGC0LjRgNCw0L3QtTogJXMiCiAKLSM6IHNlbmQtcGFjay5jOjMwNgorIzogc2VuZC1wYWNrLmM6MzA3CiBtc2dpZCAiZmFpbGVkIHRvIHNpZ24gdGhlIHB1c2ggY2VydGlmaWNhdGUiCiBtc2dzdHIgItGB0LXRgNGC0LjRhNC40LrQsNGC0YrRgiDQt9CwINC40LfRgtC70LDRgdC60LLQsNC90LUg0L3QtSDQvNC+0LbQtSDQtNCwINCx0YrQtNC1INC/0L7QtNC/0LjRgdCw0L0iCiAKLSM6IHNlbmQtcGFjay5jOjQyMAorIzogc2VuZC1wYWNrLmM6NDIxCiBtc2dpZCAidGhlIHJlY2VpdmluZyBlbmQgZG9lcyBub3Qgc3VwcG9ydCAtLXNpZ25lZCBwdXNoIgogbXNnc3RyICLQvtGC0YHRgNC10YnQvdCw0YLQsCDRgdGC0YDQsNC90LAg0L3QtSDQv9C+0LTQtNGK0YDQttCwINC40LfRgtC70LDRgdC60LLQsNC90LUg0YEg0L7Qv9GG0LjRj9GC0LAg4oCeLS1zaWduZWTigJwiCiAKLSM6IHNlbmQtcGFjay5jOjQyMgorIzogc2VuZC1wYWNrLmM6NDIzCiBtc2dpZCAiIgogIm5vdCBzZW5kaW5nIGEgcHVzaCBjZXJ0aWZpY2F0ZSBzaW5jZSB0aGUgcmVjZWl2aW5nIGVuZCBkb2VzIG5vdCBzdXBwb3J0IC0tIgogInNpZ25lZCBwdXNoIgpAQCAtNTk4NiwxMSArNjAyMSwxMSBAQAogItC+0YLRgdGA0LXRidC90LDRgtCwINGB0YLRgNCw0L3QsCDQvdC1INC/0L7QtNC00YrRgNC20LAg0LjQt9GC0LvQsNGB0LrQstCw0L3QtSDRgSDQvtC/0YbQuNGP0YLQsCDigJ4tLXNpZ25lZOKAnCwg0LfQsNGC0L7QstCwINC90LUg0YHQtSAiCiAi0LjQt9C/0L7Qu9C30LLQsCDRgdC10YDRgtC40YTQuNC60LDRgiIKIAotIzogc2VuZC1wYWNrLmM6NDM0CisjOiBzZW5kLXBhY2suYzo0MzUKIG1zZ2lkICJ0aGUgcmVjZWl2aW5nIGVuZCBkb2VzIG5vdCBzdXBwb3J0IC0tYXRvbWljIHB1c2giCiBtc2dzdHIgItC/0L7Qu9GD0YfQsNCy0LDRidCw0YLQsCDRgdGC0YDQsNC90LAg0L3QtSDQv9C+0LTQtNGK0YDQttCwINC40LfRgtC70LDRgdC60LLQsNC90LUg0YEg0L7Qv9GG0LjRj9GC0LAg4oCeLS1hdG9taWPigJwiCiAKLSM6IHNlbmQtcGFjay5jOjQzOQorIzogc2VuZC1wYWNrLmM6NDQwCiBtc2dpZCAidGhlIHJlY2VpdmluZyBlbmQgZG9lcyBub3Qgc3VwcG9ydCBwdXNoIG9wdGlvbnMiCiBtc2dzdHIgItC+0YLRgdGA0LXRidC90LDRgtCwINGB0YLRgNCw0L3QsCDQvdC1INC/0L7QtNC00YrRgNC20LAg0L7Qv9GG0LjQuCDQv9GA0Lgg0LjQt9GC0LvQsNGB0LrQstCw0L3QtSIKIApAQCAtNjAwNCw3ICs2MDM5LDcgQEAKIG1zZ2lkICJjb3VsZCBub3QgZGVsZXRlICclcyciCiBtc2dzdHIgIuKAniVz4oCcINC90LUg0LzQvtC20LUg0LTQsCDQsdGK0LTQtSDQuNC30YLRgNC40YIiCiAKLSM6IHNlcXVlbmNlci5jOjMxMSBidWlsdGluL3JlYmFzZS5jOjc1OSBidWlsdGluL3JlYmFzZS5jOjE2NDUgYnVpbHRpbi9ybS5jOjM2OQorIzogc2VxdWVuY2VyLmM6MzExIGJ1aWx0aW4vcmViYXNlLmM6NzYwIGJ1aWx0aW4vcmViYXNlLmM6MTY3NiBidWlsdGluL3JtLmM6MzY5CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCByZW1vdmUgJyVzJyIKIG1zZ3N0ciAi4oCeJXPigJwg0L3QtSDQvNC+0LbQtSDQtNCwINCx0YrQtNC1INC40LfRgtGA0LjRgiIKQEAgLTYwNDQsNyArNjA3OSw3IEBACiAi0L/RitGC0LjRidCwINGBIOKAnmdpdCBhZGQg0J/QqtCi4oCm4oCcINC40LvQuCDigJ5naXQgcm0g0J/QqtCi4oCm4oCcLCDRgdC70LXQtCDQutC+0LXRgtC+XG4iCiAi0L/QvtC00LDQudGC0LUg0YDQtdC30YPQu9GC0LDRgtCwINGBINC60L7QvNCw0L3QtNCw0YLQsCDigJ5naXQgY29tbWl0J+KAnC4iCiAKLSM6IHNlcXVlbmNlci5jOjQwMSBzZXF1ZW5jZXIuYzoyOTA5CisjOiBzZXF1ZW5jZXIuYzo0MDEgc2VxdWVuY2VyLmM6Mjg0NwogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgbG9jayAnJXMnIgogbXNnc3RyICLigJ4lc+KAnCDQvdC1INC80L7QttC1INC00LAg0YHQtSDQt9Cw0LrQu9GO0YfQuCIKQEAgLTYwNTQsMTUgKzYwODksMTUgQEAKIG1zZ2lkICJjb3VsZCBub3Qgd3JpdGUgZW9sIHRvICclcyciCiBtc2dzdHIgItC60YDQsNGP0YIg0L3QsCDRgNC10LQg0L3QtSDQvNC+0LbQtSDQtNCwINGB0LUg0LfQsNC/0LjRiNC1INCyIOKAniVz4oCcIgogCi0jOiBzZXF1ZW5jZXIuYzo0MTMgc2VxdWVuY2VyLmM6MjcxNCBzZXF1ZW5jZXIuYzoyOTE1IHNlcXVlbmNlci5jOjI5MjkKLSM6IHNlcXVlbmNlci5jOjMxOTIKKyM6IHNlcXVlbmNlci5jOjQxMyBzZXF1ZW5jZXIuYzoyNjUyIHNlcXVlbmNlci5jOjI4NTMgc2VxdWVuY2VyLmM6Mjg2NworIzogc2VxdWVuY2VyLmM6MzEzMAogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gZmluYWxpemUgJyVzJyIKIG1zZ3N0ciAi4oCeJXPigJwg0L3QtSDQvNC+0LbQtSDQtNCwINGB0LUg0LfQsNCy0YrRgNGI0LgiCiAKLSM6IHNlcXVlbmNlci5jOjQzNiBzZXF1ZW5jZXIuYzo5ODEgc2VxdWVuY2VyLmM6MTY1NSBzZXF1ZW5jZXIuYzoyNzM0Ci0jOiBzZXF1ZW5jZXIuYzozMTc0IHNlcXVlbmNlci5jOjMyODMgYnVpbHRpbi9hbS5jOjI0NSBidWlsdGluL2NvbW1pdC5jOjc2MwotIzogYnVpbHRpbi9tZXJnZS5jOjExMTIgYnVpbHRpbi9yZWJhc2UuYzo1NjcKKyM6IHNlcXVlbmNlci5jOjQzNiBzZXF1ZW5jZXIuYzoxNTg1IHNlcXVlbmNlci5jOjI2NzIgc2VxdWVuY2VyLmM6MzExMgorIzogc2VxdWVuY2VyLmM6MzIyMSBidWlsdGluL2FtLmM6MjQ0IGJ1aWx0aW4vY29tbWl0LmM6NzYzIGJ1aWx0aW4vbWVyZ2UuYzoxMTE3CisjOiBidWlsdGluL3JlYmFzZS5jOjU2OAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcmVhZCAnJXMnIgogbXNnc3RyICLRhNCw0LnQu9GK0YIg4oCeJXPigJwg0L3QtSDQvNC+0LbQtSDQtNCwINCx0YrQtNC1INC/0YDQvtGH0LXRgtC10L0iCkBAIC02MDg5LDcwICs2MTI0LDY1IEBACiAjLiBUUkFOU0xBVE9SUzogJXMgd2lsbCBiZSAicmV2ZXJ0IiwgImNoZXJyeS1waWNrIiBvcgogIy4gInJlYmFzZSAtaSIuCiAjLgotIzogc2VxdWVuY2VyLmM6NjMyCisjOiBzZXF1ZW5jZXIuYzo2MzEKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXM6IFVuYWJsZSB0byB3cml0ZSBuZXcgaW5kZXggZmlsZSIKIG1zZ3N0ciAiJXM6INC90L7QstC40Y/RgiDQuNC90LTQtdC60YEg0L3QtSDQvNC+0LbQtSDQtNCwINCx0YrQtNC1INC30LDQv9Cw0LfQtdC9IgogCi0jOiBzZXF1ZW5jZXIuYzo2NDkKKyM6IHNlcXVlbmNlci5jOjY0OAogbXNnaWQgInVuYWJsZSB0byB1cGRhdGUgY2FjaGUgdHJlZSIKIG1zZ3N0ciAi0LTRitGA0LLQvtGC0L4g0L3QsCDQutC10YjQsCDQvdC1INC80L7QttC1INC00LAg0LHRitC00LUg0L7QsdC90L7QstC10L3QviIKIAotIzogc2VxdWVuY2VyLmM6NjYzCisjOiBzZXF1ZW5jZXIuYzo2NjIKIG1zZ2lkICJjb3VsZCBub3QgcmVzb2x2ZSBIRUFEIGNvbW1pdCIKIG1zZ3N0ciAi0L/QvtC00LDQstCw0L3QtdGC0L4sINGB0L7Rh9C10L3QviDQvtGCINGD0LrQsNC30LDRgtC10LvRjyDigJ5IRUFE4oCcLCDQvdC1INC80L7QttC1INC00LAg0LHRitC00LUg0L7RgtC60YDQuNGC0L4iCiAKLSM6IHNlcXVlbmNlci5jOjc0MworIzogc2VxdWVuY2VyLmM6NzQyCiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vIGtleSBwcmVzZW50IGluICclLipzJyIKIG1zZ3N0ciAi0LIg4oCeJS4qc+KAnCDQvdGP0LzQsCDQutC70Y7Rh9C+0LLQtSIKIAotIzogc2VxdWVuY2VyLmM6NzU0CisjOiBzZXF1ZW5jZXIuYzo3NTMKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGRlcXVvdGUgdmFsdWUgb2YgJyVzJyIKIG1zZ3N0ciAi0YbQuNGC0LjRgNCw0L3QtdGC0L4g0L3QsCDRgdGC0L7QudC90L7RgdGC0YLQsCDQvdCwIOKAniVz4oCcINC90LUg0LzQvtC20LUg0LTQsCDQsdGK0LTQtSDQuNC30YfQuNGB0YLQtdC90L4iCiAKLSM6IHNlcXVlbmNlci5jOjc5MSB3cmFwcGVyLmM6MjI3IHdyYXBwZXIuYzozOTcgYnVpbHRpbi9hbS5jOjcwNgotIzogYnVpbHRpbi9hbS5jOjc5OCBidWlsdGluL21lcmdlLmM6MTEwOSBidWlsdGluL3JlYmFzZS5jOjEwNDUKKyM6IHNlcXVlbmNlci5jOjc5MCB3cmFwcGVyLmM6MTkwIHdyYXBwZXIuYzozNjAgYnVpbHRpbi9hbS5jOjcwNQorIzogYnVpbHRpbi9hbS5jOjc5NyBidWlsdGluL21lcmdlLmM6MTExNCBidWlsdGluL3JlYmFzZS5jOjEwNDYKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IG9wZW4gJyVzJyBmb3IgcmVhZGluZyIKIG1zZ3N0ciAi0YTQsNC50LvRitGCINC90LUg0LzQvtC20LUg0LTQsCDQsdGK0LTQtSDQv9GA0L7Rh9C10YLQtdC9OiDigJ4lc+KAnCIKIAotIzogc2VxdWVuY2VyLmM6ODAxCisjOiBzZXF1ZW5jZXIuYzo4MDAKIG1zZ2lkICInR0lUX0FVVEhPUl9OQU1FJyBhbHJlYWR5IGdpdmVuIgogbXNnc3RyICLQvdCw0YHRgtGA0L7QudC60LDRgtCwINC30LAg0LDQstGC0L7RgCDigJ5HSVRfQVVUSE9SX05BTUXigJwg0LLQtdGH0LUg0LUg0LfQsNC00LDQtNC10L3QsCIKIAotIzogc2VxdWVuY2VyLmM6ODA2CisjOiBzZXF1ZW5jZXIuYzo4MDUKIG1zZ2lkICInR0lUX0FVVEhPUl9FTUFJTCcgYWxyZWFkeSBnaXZlbiIKIG1zZ3N0ciAi0L3QsNGB0YLRgNC+0LnQutCw0YLQsCDQt9CwINC1LdC/0L7RidCwIOKAnkdJVF9BVVRIT1JfRU1BSUzigJwg0LLQtdGH0LUg0LUg0LfQsNC00LDQtNC10L3QsCIKIAotIzogc2VxdWVuY2VyLmM6ODExCisjOiBzZXF1ZW5jZXIuYzo4MTAKIG1zZ2lkICInR0lUX0FVVEhPUl9EQVRFJyBhbHJlYWR5IGdpdmVuIgogbXNnc3RyICLQvdCw0YHRgtGA0L7QudC60LDRgtCwINC30LAg0LTQsNGC0LAg4oCeR0lUX0FVVEhPUl9EQVRF4oCcINCy0LXRh9C1INC1INC30LDQtNCw0LTQtdC90LAiCiAKLSM6IHNlcXVlbmNlci5jOjgxNQorIzogc2VxdWVuY2VyLmM6ODE0CiAjLCBjLWZvcm1hdAogbXNnaWQgInVua25vd24gdmFyaWFibGUgJyVzJyIKIG1zZ3N0ciAi0L3QtdC/0L7Qt9C90LDRgtCwINC/0YDQvtC80LXQvdC70LjQstCwIOKAniVz4oCcIgogCi0jOiBzZXF1ZW5jZXIuYzo4MjAKKyM6IHNlcXVlbmNlci5jOjgxOQogbXNnaWQgIm1pc3NpbmcgJ0dJVF9BVVRIT1JfTkFNRSciCiBtc2dzdHIgItC90LDRgdGC0YDQvtC50LrQsNGC0LAg0LfQsCDQsNCy0YLQvtGAIOKAnkdJVF9BVVRIT1JfTkFNReKAnCDQu9C40L/RgdCy0LAiCiAKLSM6IHNlcXVlbmNlci5jOjgyMgorIzogc2VxdWVuY2VyLmM6ODIxCiBtc2dpZCAibWlzc2luZyAnR0lUX0FVVEhPUl9FTUFJTCciCiBtc2dzdHIgItC90LDRgdGC0YDQvtC50LrQsNGC0LAg0LfQsCDQtS3Qv9C+0YnQsCDigJ5HSVRfQVVUSE9SX0VNQUlM4oCcINC70LjQv9GB0LLQsCIKIAotIzogc2VxdWVuY2VyLmM6ODI0CisjOiBzZXF1ZW5jZXIuYzo4MjMKIG1zZ2lkICJtaXNzaW5nICdHSVRfQVVUSE9SX0RBVEUnIgogbXNnc3RyICLQvdCw0YHRgtGA0L7QudC60LDRgtCwINC30LAg0LTQsNGC0LAg4oCeR0lUX0FVVEhPUl9EQVRF4oCcINC70LjQv9GB0LLQsCIKIAotIzogc2VxdWVuY2VyLmM6ODg0Ci0jLCBjLWZvcm1hdAotbXNnaWQgImludmFsaWQgZGF0ZSBmb3JtYXQgJyVzJyBpbiAnJXMnIgotbXNnc3RyICLQvdC10L/RgNCw0LLQuNC70LXQvSDRhNC+0YDQvNCw0YIg0L3QsCDQtNCw0YLQsCDigJ4lc+KAnCDQsiDigJ4lc+KAnCIKLQotIzogc2VxdWVuY2VyLmM6OTAxCisjOiBzZXF1ZW5jZXIuYzo4NzIKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogInlvdSBoYXZlIHN0YWdlZCBjaGFuZ2VzIGluIHlvdXIgd29ya2luZyB0cmVlXG4iCkBAIC02MTgxLDE3ICs2MjExLDEzIEBACiAiXG4iCiAiICAgIGdpdCByZWJhc2UgLS1jb250aW51ZVxuIgogCi0jOiBzZXF1ZW5jZXIuYzo5OTUKLW1zZ2lkICJ3cml0aW5nIHJvb3QgY29tbWl0IgotbXNnc3RyICLQt9Cw0L/QsNC30LLQsNC90LUg0L3QsCDQvdCw0YfQsNC70L3QviDQv9C+0LTQsNCy0LDQvdC1IgotCi0jOiBzZXF1ZW5jZXIuYzoxMjE2CisjOiBzZXF1ZW5jZXIuYzoxMTQ2CiBtc2dpZCAiJ3ByZXBhcmUtY29tbWl0LW1zZycgaG9vayBmYWlsZWQiCiBtc2dzdHIgIiIKICLQvdC10YPRgdC/0LXRiNC90L4g0LjQt9C/0YrQu9C90LXQvdC40LUg0L3QsCDQutGD0LrQsNGC0LAg0L/RgNC4INC/0YDQvtC80Y/QvdCwINC90LAg0YHRitC+0LHRidC10L3QuNC10YLQviDQv9GA0Lgg0L/QvtC00LDQstCw0L3QtSAiCiAiKHByZXBhcmUtY29tbWl0LW1zZykiCiAKLSM6IHNlcXVlbmNlci5jOjEyMjMKKyM6IHNlcXVlbmNlci5jOjExNTMKIG1zZ2lkICIiCiAiWW91ciBuYW1lIGFuZCBlbWFpbCBhZGRyZXNzIHdlcmUgY29uZmlndXJlZCBhdXRvbWF0aWNhbGx5IGJhc2VkXG4iCiAib24geW91ciB1c2VybmFtZSBhbmQgaG9zdG5hbWUuIFBsZWFzZSBjaGVjayB0aGF0IHRoZXkgYXJlIGFjY3VyYXRlLlxuIgpAQCAtNjIyMCw3ICs2MjQ2LDcgQEAKICJcbiIKICIgICAgZ2l0IGNvbW1pdCAtLWFtZW5kIC0tcmVzZXQtYXV0aG9yXG4iCiAKLSM6IHNlcXVlbmNlci5jOjEyMzYKKyM6IHNlcXVlbmNlci5jOjExNjYKIG1zZ2lkICIiCiAiWW91ciBuYW1lIGFuZCBlbWFpbCBhZGRyZXNzIHdlcmUgY29uZmlndXJlZCBhdXRvbWF0aWNhbGx5IGJhc2VkXG4iCiAib24geW91ciB1c2VybmFtZSBhbmQgaG9zdG5hbWUuIFBsZWFzZSBjaGVjayB0aGF0IHRoZXkgYXJlIGFjY3VyYXRlLlxuIgpAQCAtNjI0NiwzMzggKzYyNzIsMzM4IEBACiAiXG4iCiAiICAgIGdpdCBjb21taXQgLS1hbWVuZCAtLXJlc2V0LWF1dGhvclxuIgogCi0jOiBzZXF1ZW5jZXIuYzoxMjc4CisjOiBzZXF1ZW5jZXIuYzoxMjA4CiBtc2dpZCAiY291bGRuJ3QgbG9vayB1cCBuZXdseSBjcmVhdGVkIGNvbW1pdCIKIG1zZ3N0ciAi0YLQvtC60YMg0YnQviDRgdGK0LfQtNCw0LTQtdC90L7RgtC+INC/0L7QtNCw0LLQsNC90LUg0L3QtSDQvNC+0LbQtSDQtNCwINCx0YrQtNC1INC+0YLQutGA0LjRgtC+IgogCi0jOiBzZXF1ZW5jZXIuYzoxMjgwCisjOiBzZXF1ZW5jZXIuYzoxMjEwCiBtc2dpZCAiY291bGQgbm90IHBhcnNlIG5ld2x5IGNyZWF0ZWQgY29tbWl0IgogbXNnc3RyICLRgtC+0LrRgyDRidC+INGB0YrQt9C00LDQtNC10L3QvtGC0L4g0L/QvtC00LDQstCw0L3QtSDQvdC1INC80L7QttC1INC00LAg0LHRitC00LUg0LDQvdCw0LvQuNC30LjRgNCw0L3QviIKIAotIzogc2VxdWVuY2VyLmM6MTMyNgorIzogc2VxdWVuY2VyLmM6MTI1NgogbXNnaWQgInVuYWJsZSB0byByZXNvbHZlIEhFQUQgYWZ0ZXIgY3JlYXRpbmcgY29tbWl0IgogbXNnc3RyICIiCiAi0YHRitGB0YLQvtGP0L3QuNC10YLQviDRgdC+0YfQtdC90L4g0L7RgiDRg9C60LDQt9Cw0YLQtdC70Y8g4oCeSEVBROKAnCDQvdC1INC80L7QttC1INC00LAg0LHRitC00LUg0L7RgtC60YDQuNGC0L4g0YHQu9C10LQgIgogItC/0L7QtNCw0LLQsNC90LXRgtC+IgogCi0jOiBzZXF1ZW5jZXIuYzoxMzI4CisjOiBzZXF1ZW5jZXIuYzoxMjU4CiBtc2dpZCAiZGV0YWNoZWQgSEVBRCIKIG1zZ3N0ciAi0L3QtdGB0LLRitGA0LfQsNC9INCy0YDRitGFIOKAnkhFQUTigJwiCiAKLSM6IHNlcXVlbmNlci5jOjEzMzIKKyM6IHNlcXVlbmNlci5jOjEyNjIKIG1zZ2lkICIgKHJvb3QtY29tbWl0KSIKIG1zZ3N0ciAiICjQvdCw0YfQsNC70L3QviDQv9C+0LTQsNCy0LDQvdC1KSIKIAotIzogc2VxdWVuY2VyLmM6MTM1MworIzogc2VxdWVuY2VyLmM6MTI4MwogbXNnaWQgImNvdWxkIG5vdCBwYXJzZSBIRUFEIgogbXNnc3RyICLRg9C60LDQt9Cw0YLQtdC70Y/RgiDigJ5IRUFE4oCcINC90LUg0LzQvtC20LUg0LTQsCDQsdGK0LTQtSDQsNC90LDQu9C40LfQuNGA0LDQvSIKIAotIzogc2VxdWVuY2VyLmM6MTM1NQorIzogc2VxdWVuY2VyLmM6MTI4NQogIywgYy1mb3JtYXQKIG1zZ2lkICJIRUFEICVzIGlzIG5vdCBhIGNvbW1pdCEiCiBtc2dzdHIgItGD0LrQsNC30LDRgtC10LvRj9GCIOKAnkhFQUTigJwg4oCeJXPigJwg0YHQvtGH0Lgg0LrRitC8INC90LXRidC+LCDQutC+0LXRgtC+INC90LUg0LUg0L/QvtC00LDQstCw0L3QtSEiCiAKLSM6IHNlcXVlbmNlci5jOjEzNTkgYnVpbHRpbi9jb21taXQuYzoxNTcxCisjOiBzZXF1ZW5jZXIuYzoxMjg5IGJ1aWx0aW4vY29tbWl0LmM6MTU3MQogbXNnaWQgImNvdWxkIG5vdCBwYXJzZSBIRUFEIGNvbW1pdCIKIG1zZ3N0ciAi0LLRitGA0YXQvtCy0L7RgtC+INC/0L7QtNCw0LLQsNC90LUg4oCeSEVBROKAnCDQvdC1INC80L7QttC1INC00LAg0LHRitC00LUg0L/RgNC+0YfQtdGC0LXQvdC+IgogCi0jOiBzZXF1ZW5jZXIuYzoxNDExIHNlcXVlbmNlci5jOjIwMDQKKyM6IHNlcXVlbmNlci5jOjEzNDEgc2VxdWVuY2VyLmM6MTkzMwogbXNnaWQgInVuYWJsZSB0byBwYXJzZSBjb21taXQgYXV0aG9yIgogbXNnc3RyICLQsNCy0YLQvtGA0YrRgiDQvdCwINC/0L7QtNCw0LLQsNC90LXRgtC+INC90LUg0LzQvtC20LUg0LTQsCDQsdGK0LTQtSDQsNC90LDQu9C40LfQuNGA0LDQvSIKIAotIzogc2VxdWVuY2VyLmM6MTQyMSBidWlsdGluL2FtLmM6MTU3MyBidWlsdGluL21lcmdlLmM6Njg0CisjOiBzZXF1ZW5jZXIuYzoxMzUyIGJ1aWx0aW4vYW0uYzoxNTYxIGJ1aWx0aW4vbWVyZ2UuYzo2ODQKIG1zZ2lkICJnaXQgd3JpdGUtdHJlZSBmYWlsZWQgdG8gd3JpdGUgYSB0cmVlIgogbXNnc3RyICLQmtC+0LzQsNC90LTQsNGC0LAg4oCeZ2l0IHdyaXRlLXRyZWXigJwg0L3QtSDRg9GB0L/RjyDQtNCwINC30LDQv9C40YjQtSDQvtCx0LXQutGCLdC00YrRgNCy0L4iCiAKLSM6IHNlcXVlbmNlci5jOjE0Mzggc2VxdWVuY2VyLmM6MTQ5OQorIzogc2VxdWVuY2VyLmM6MTM2OSBzZXF1ZW5jZXIuYzoxNDI5CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byByZWFkIGNvbW1pdCBtZXNzYWdlIGZyb20gJyVzJyIKIG1zZ3N0ciAi0YHRitC+0LHRidC10L3QuNC10YLQviDQt9CwINC/0L7QtNCw0LLQsNC90LUg0L3QtSDQvNC+0LbQtSDQtNCwINCx0YrQtNC1INC/0YDQvtGH0LXRgtC10L3QviDQvtGCIOKAniVz4oCcIgogCi0jOiBzZXF1ZW5jZXIuYzoxNDY1IGJ1aWx0aW4vYW0uYzoxNTk1IGJ1aWx0aW4vY29tbWl0LmM6MTY3MCBidWlsdGluL21lcmdlLmM6ODc4Ci0jOiBidWlsdGluL21lcmdlLmM6OTAzCisjOiBzZXF1ZW5jZXIuYzoxMzk2IGJ1aWx0aW4vYW0uYzoxNTgzIGJ1aWx0aW4vY29tbWl0LmM6MTY3MCBidWlsdGluL21lcmdlLmM6ODgzCisjOiBidWlsdGluL21lcmdlLmM6OTA4CiBtc2dpZCAiZmFpbGVkIHRvIHdyaXRlIGNvbW1pdCBvYmplY3QiCiBtc2dzdHIgItC+0LHQtdC60YLRitGCINC30LAg0L/QvtC00LDQstCw0L3QtdGC0L4g0L3QtSDQvNC+0LbQtSDQtNCwINCx0YrQtNC1INC30LDQv9C40YHQsNC9IgogCi0jOiBzZXF1ZW5jZXIuYzoxNTI2CisjOiBzZXF1ZW5jZXIuYzoxNDU2CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBwYXJzZSBjb21taXQgJXMiCiBtc2dzdHIgItC/0L7QtNCw0LLQsNC90LXRgtC+IOKAniVz4oCcINC90LUg0LzQvtC20LUg0LTQsCDQsdGK0LTQtSDQsNC90LDQu9C40LfQuNGA0LDQvdC+IgogCi0jOiBzZXF1ZW5jZXIuYzoxNTMxCisjOiBzZXF1ZW5jZXIuYzoxNDYxCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBwYXJzZSBwYXJlbnQgY29tbWl0ICVzIgogbXNnc3RyICLRgNC+0LTQuNGC0LXQu9GB0LrQvtGC0L4g0L/QvtC00LDQstCw0L3QtSDigJ4lc+KAnCDQvdC1INC80L7QttC1INC00LAg0LHRitC00LUg0LDQvdCw0LvQuNC30LjRgNCw0L3QviIKIAotIzogc2VxdWVuY2VyLmM6MTYwNSBzZXF1ZW5jZXIuYzoxNzE1CisjOiBzZXF1ZW5jZXIuYzoxNTM1IHNlcXVlbmNlci5jOjE2NDUKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5rbm93biBjb21tYW5kOiAlZCIKIG1zZ3N0ciAi0L3QtdC/0L7Qt9C90LDRgtCwINC60L7QvNCw0L3QtNCwOiAlZCIKIAotIzogc2VxdWVuY2VyLmM6MTY2MiBzZXF1ZW5jZXIuYzoxNjg3CisjOiBzZXF1ZW5jZXIuYzoxNTkyIHNlcXVlbmNlci5jOjE2MTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiVGhpcyBpcyBhIGNvbWJpbmF0aW9uIG9mICVkIGNvbW1pdHMuIgogbXNnc3RyICLQotC+0LLQsCDQtSDQvtCx0LXQtNC40L3QtdC90LjQtSDQvtGCICVkINC/0L7QtNCw0LLQsNC90LjRjyIKIAotIzogc2VxdWVuY2VyLmM6MTY3MgorIzogc2VxdWVuY2VyLmM6MTYwMgogbXNnaWQgIm5lZWQgYSBIRUFEIHRvIGZpeHVwIgogbXNnc3RyICLQl9CwINCy0LrQsNGA0LLQsNC90LUg0LIg0L/RgNC10LTRhdC+0LTQvdC+0YLQviDQv9C+0LTQsNCy0LDQvdC1INCy0Lgg0YLRgNGP0LHQstCwINGD0LrQsNC30LDRgtC10Lsg4oCeSEVBROKAnCIKIAotIzogc2VxdWVuY2VyLmM6MTY3NCBzZXF1ZW5jZXIuYzozMjE5CisjOiBzZXF1ZW5jZXIuYzoxNjA0IHNlcXVlbmNlci5jOjMxNTcKIG1zZ2lkICJjb3VsZCBub3QgcmVhZCBIRUFEIgogbXNnc3RyICLRg9C60LDQt9Cw0YLQtdC70Y/RgiDigJ5IRUFE4oCcINC90LUg0LzQvtC20LUg0LTQsCDRgdC1INC/0YDQvtGH0LXRgtC1IgogCi0jOiBzZXF1ZW5jZXIuYzoxNjc2CisjOiBzZXF1ZW5jZXIuYzoxNjA2CiBtc2dpZCAiY291bGQgbm90IHJlYWQgSEVBRCdzIGNvbW1pdCBtZXNzYWdlIgogbXNnc3RyICIiCiAi0YHRitC+0LHRidC10L3QuNC10YLQviDQt9CwINC/0L7QtNCw0LLQsNC90LUg0LrRitC8INGD0LrQsNC30LDRgtC10LvRjyDigJ5IRUFE4oCcINC90LUg0LzQvtC20LUg0LTQsCDQsdGK0LTQtSDQv9GA0L7Rh9C10YLQtdC90L46ICVzIgogCi0jOiBzZXF1ZW5jZXIuYzoxNjgyCisjOiBzZXF1ZW5jZXIuYzoxNjEyCiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCB3cml0ZSAnJXMnIgogbXNnc3RyICLigJ4lc+KAnCDQvdC1INC80L7QttC1INC00LAg0YHQtSDQt9Cw0L/QsNC30LgiCiAKLSM6IHNlcXVlbmNlci5jOjE2ODkgZ2l0LXJlYmFzZS0tcHJlc2VydmUtbWVyZ2VzLnNoOjQ5NgorIzogc2VxdWVuY2VyLmM6MTYxOSBnaXQtcmViYXNlLS1wcmVzZXJ2ZS1tZXJnZXMuc2g6NDk2CiBtc2dpZCAiVGhpcyBpcyB0aGUgMXN0IGNvbW1pdCBtZXNzYWdlOiIKIG1zZ3N0ciAi0KLQvtCy0LAg0LUgMS3RgtC+INGB0YrQvtCx0YnQtdC90LjQtSDQv9GA0Lgg0L/QvtC00LDQstCw0L3QtToiCiAKLSM6IHNlcXVlbmNlci5jOjE2OTcKKyM6IHNlcXVlbmNlci5jOjE2MjcKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHJlYWQgY29tbWl0IG1lc3NhZ2Ugb2YgJXMiCiBtc2dzdHIgItGB0YrQvtCx0YnQtdC90LjQtdGC0L4g0LfQsCDQv9C+0LTQsNCy0LDQvdC1INC60YrQvCDigJ4lc+KAnCDQvdC1INC80L7QttC1INC00LAg0LHRitC00LUg0L/RgNC+0YfQtdGC0LXQvdC+IgogCi0jOiBzZXF1ZW5jZXIuYzoxNzA0CisjOiBzZXF1ZW5jZXIuYzoxNjM0CiAjLCBjLWZvcm1hdAogbXNnaWQgIlRoaXMgaXMgdGhlIGNvbW1pdCBtZXNzYWdlICMlZDoiCiBtc2dzdHIgItCi0L7QstCwINC1INGB0YrQvtCx0YnQtdC90LjQtSDQv9GA0Lgg0L/QvtC00LDQstCw0L3QtSDihJYlZDoiCiAKLSM6IHNlcXVlbmNlci5jOjE3MTAKKyM6IHNlcXVlbmNlci5jOjE2NDAKICMsIGMtZm9ybWF0CiBtc2dpZCAiVGhlIGNvbW1pdCBtZXNzYWdlICMlZCB3aWxsIGJlIHNraXBwZWQ6IgogbXNnc3RyICLQodGK0L7QsdGJ0LXQvdC40LUg0L/RgNC4INC/0L7QtNCw0LLQsNC90LUg4oSWJWQg0YnQtSDQsdGK0LTQtSDQv9GA0LXRgdC60L7Rh9C10L3QvjoiCiAKLSM6IHNlcXVlbmNlci5jOjE3OTgKKyM6IHNlcXVlbmNlci5jOjE3MjgKIG1zZ2lkICJ5b3VyIGluZGV4IGZpbGUgaXMgdW5tZXJnZWQuIgogbXNnc3RyICLQuNC90LTQtdC60YHRitGCINC90LUg0LUg0YHQu9GP0YIuIgogCi0jOiBzZXF1ZW5jZXIuYzoxODA1CisjOiBzZXF1ZW5jZXIuYzoxNzM1CiBtc2dpZCAiY2Fubm90IGZpeHVwIHJvb3QgY29tbWl0IgogbXNnc3RyICLQvdCw0YfQsNC70L3QvtGC0L4g0L/QvtC00LDQstCw0L3QtSDQvdC1INC80L7QttC1INC00LAg0YHQtSDQstC60LDRgNCwINCyINC/0YDQtdC00YXQvtC00L3QvtGC0L4g0LzRgyIKIAotIzogc2VxdWVuY2VyLmM6MTgyNAorIzogc2VxdWVuY2VyLmM6MTc1NAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb21taXQgJXMgaXMgYSBtZXJnZSBidXQgbm8gLW0gb3B0aW9uIHdhcyBnaXZlbi4iCiBtc2dzdHIgItC/0L7QtNCw0LLQsNC90LXRgtC+IOKAniVz4oCcINC1INGB0LvQuNCy0LDQvdC1LCDQvdC+INC90LUg0LUg0LTQsNC00LXQvdCwINC+0L/RhtC40Y/RgtCwIOKAni1t4oCcIgogCi0jOiBzZXF1ZW5jZXIuYzoxODMyIHNlcXVlbmNlci5jOjE4NDAKKyM6IHNlcXVlbmNlci5jOjE3NjIgc2VxdWVuY2VyLmM6MTc3MAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb21taXQgJXMgZG9lcyBub3QgaGF2ZSBwYXJlbnQgJWQiCiBtc2dzdHIgItC/0L7QtNCw0LLQsNC90LXRgtC+IOKAniVz4oCcINC90Y/QvNCwINGA0L7QtNC40YLQtdC7ICVkIgogCi0jOiBzZXF1ZW5jZXIuYzoxODQ2CisjOiBzZXF1ZW5jZXIuYzoxNzc2CiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCBnZXQgY29tbWl0IG1lc3NhZ2UgZm9yICVzIgogbXNnc3RyICLQvdC10YPRgdC/0LXRiNC90L4g0LjQt9Cy0LvQuNGH0LDQvdC1INC90LAg0YHRitC+0LHRidC10L3QuNC10YLQviDQt9CwINC/0L7QtNCw0LLQsNC90LUg0L3QsCDigJ4lc+KAnCIKIAogIy4gVFJBTlNMQVRPUlM6IFRoZSBmaXJzdCAlcyB3aWxsIGJlIGEgInRvZG8iIGNvbW1hbmQgbGlrZQogIy4gInJldmVydCIgb3IgInBpY2siLCB0aGUgc2Vjb25kICVzIGEgU0hBMS4KLSM6IHNlcXVlbmNlci5jOjE4NjUKKyM6IHNlcXVlbmNlci5jOjE3OTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXM6IGNhbm5vdCBwYXJzZSBwYXJlbnQgY29tbWl0ICVzIgogbXNnc3RyICIlczog0L3QtdGA0LDQt9C/0L7Qt9C90LDRgtCwINGB0YLQvtC50L3QvtGB0YIg0LfQsCDRgNC+0LTQuNGC0LXQu9GB0LrQvtGC0L4g0L/QvtC00LDQstCw0L3QtSDigJ4lc+KAnCIKIAotIzogc2VxdWVuY2VyLmM6MTkzMAorIzogc2VxdWVuY2VyLmM6MTg2MAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcmVuYW1lICclcycgdG8gJyVzJyIKIG1zZ3N0ciAi4oCeJXPigJwg0L3QtSDQvNC+0LbQtSDQtNCwINGB0LUg0L/RgNC10LjQvNC10L3Rg9Cy0LAg0L3QsCDigJ4lc+KAnCIKIAotIzogc2VxdWVuY2VyLmM6MTk4NQorIzogc2VxdWVuY2VyLmM6MTkxNQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcmV2ZXJ0ICVzLi4uICVzIgogbXNnc3RyICLQv9C+0LTQsNCy0LDQvdC10YLQviDigJ4lc+KAnOKApiDQvdC1INC80L7QttC1INC00LAg0LHRitC00LUg0L7RgtC80LXQvdC10L3Qvjog4oCeJXPigJwiCiAKLSM6IHNlcXVlbmNlci5jOjE5ODYKKyM6IHNlcXVlbmNlci5jOjE5MTYKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGFwcGx5ICVzLi4uICVzIgogbXNnc3RyICLQv9C+0LTQsNCy0LDQvdC10YLQviDigJ4lc+KAnOKApiDQvdC1INC80L7QttC1INC00LAg0LHRitC00LUg0L/RgNC40LvQvtC20LXQvdC+OiDigJ4lc+KAnCIKIAotIzogc2VxdWVuY2VyLmM6MjA0NQorIzogc2VxdWVuY2VyLmM6MTk4MwogIywgYy1mb3JtYXQKIG1zZ2lkICJnaXQgJXM6IGZhaWxlZCB0byByZWFkIHRoZSBpbmRleCIKIG1zZ3N0ciAiZ2l0ICVzOiDQvdC10YPRgdC/0LXRiNC90L4g0LjQt9GH0LjRgtCw0L3QtSDQvdCwINC40L3QtNC10LrRgdCwIgogCi0jOiBzZXF1ZW5jZXIuYzoyMDUyCisjOiBzZXF1ZW5jZXIuYzoxOTkwCiAjLCBjLWZvcm1hdAogbXNnaWQgImdpdCAlczogZmFpbGVkIHRvIHJlZnJlc2ggdGhlIGluZGV4IgogbXNnc3RyICJnaXQgJXM6INC90LXRg9GB0L/QtdGI0L3QviDQvtCx0L3QvtCy0Y/QstCw0L3QtSDQvdCwINC40L3QtNC10LrRgdCwIgogCi0jOiBzZXF1ZW5jZXIuYzoyMTI4CisjOiBzZXF1ZW5jZXIuYzoyMDY2CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIGRvZXMgbm90IGFjY2VwdCBhcmd1bWVudHM6ICclcyciCiBtc2dzdHIgIuKAniVz4oCcINC90LUg0L/RgNC40LXQvNCwINCw0YDQs9GD0LzQtdC90YLQuDog4oCeJXPigJwiCiAKLSM6IHNlcXVlbmNlci5jOjIxMzcKKyM6IHNlcXVlbmNlci5jOjIwNzUKICMsIGMtZm9ybWF0CiBtc2dpZCAibWlzc2luZyBhcmd1bWVudHMgZm9yICVzIgogbXNnc3RyICLigJ4lc+KAnCDQuNC30LjRgdC60LLQsCDQsNGA0LPRg9C80LXQvdGC0LgiCiAKLSM6IHNlcXVlbmNlci5jOjIxNzQKKyM6IHNlcXVlbmNlci5jOjIxMTIKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHBhcnNlICclLipzJyIKIG1zZ3N0ciAi4oCeJS4qc+KAnCDQvdC1INC80L7QttC1INC00LAg0YHQtSDQsNC90LDQu9C40LfQuNGA0LAiCiAKLSM6IHNlcXVlbmNlci5jOjIyMjgKKyM6IHNlcXVlbmNlci5jOjIxNjYKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBsaW5lICVkOiAlLipzIgogbXNnc3RyICLQvdC10L/RgNCw0LLQuNC70LXQvSDRgNC10LQgJWQ6ICUuKnMiCiAKLSM6IHNlcXVlbmNlci5jOjIyMzkKKyM6IHNlcXVlbmNlci5jOjIxNzcKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90ICclcycgd2l0aG91dCBhIHByZXZpb3VzIGNvbW1pdCIKIG1zZ3N0ciAi0JHQtdC3INC/0YDQtdC00LjRiNC90L4g0L/QvtC00LDQstCw0L3QtSDQvdC1INC80L7QttC1INC00LAg0YHQtSDQuNC30L/RitC70L3QuCDigJ4lc+KAnCIKIAotIzogc2VxdWVuY2VyLmM6MjI4NyBidWlsdGluL3JlYmFzZS5jOjE1MyBidWlsdGluL3JlYmFzZS5jOjE3OAorIzogc2VxdWVuY2VyLmM6MjIyNSBidWlsdGluL3JlYmFzZS5jOjE1MyBidWlsdGluL3JlYmFzZS5jOjE3OAogIzogYnVpbHRpbi9yZWJhc2UuYzoyMDQgYnVpbHRpbi9yZWJhc2UuYzoyMjkKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHJlYWQgJyVzJy4iCiBtc2dzdHIgItC+0YIg4oCeJXPigJwg0L3QtSDQvNC+0LbQtSDQtNCwINGB0LUg0YfQtdGC0LUuIgogCi0jOiBzZXF1ZW5jZXIuYzoyMzIzCisjOiBzZXF1ZW5jZXIuYzoyMjYxCiBtc2dpZCAiY2FuY2VsbGluZyBhIGNoZXJyeSBwaWNraW5nIGluIHByb2dyZXNzIgogbXNnc3RyICLQv9GA0LXRg9GB0YLQsNC90L7QstGP0LLQsNC90LUg0L3QsCDQuNC30LLRitGA0YjQstCw0L3QvtGC0L4g0LIg0LzQvtC80LXQvdGC0LAg0L7RgtCx0LjRgNCw0L3QtSDQvdCwINC/0L7QtNCw0LLQsNC90LjRjyIKIAotIzogc2VxdWVuY2VyLmM6MjMzMAorIzogc2VxdWVuY2VyLmM6MjI2OAogbXNnaWQgImNhbmNlbGxpbmcgYSByZXZlcnQgaW4gcHJvZ3Jlc3MiCiBtc2dzdHIgItC/0YDQtdGD0YHRgtCw0L3QvtCy0Y/QstCw0L3QtSDQvdCwINC40LfQstGK0YDRiNCy0LDQvdC+0YLQviDQsiDQvNC+0LzQtdC90YLQsCDQvtGC0LzRj9C90LAg0L3QsCDQv9C+0LTQsNCy0LDQvdC1IgogCi0jOiBzZXF1ZW5jZXIuYzoyMzY0CisjOiBzZXF1ZW5jZXIuYzoyMzAyCiBtc2dpZCAicGxlYXNlIGZpeCB0aGlzIHVzaW5nICdnaXQgcmViYXNlIC0tZWRpdC10b2RvJy4iCiBtc2dzdHIgItC60L7RgNC40LPQuNGA0LDQudGC0LUg0YLQvtCy0LAg0YfRgNC10Lcg4oCeZ2l0IHJlYmFzZSAtLWVkaXQtdG9kb+KAnC4iCiAKLSM6IHNlcXVlbmNlci5jOjIzNjYKKyM6IHNlcXVlbmNlci5jOjIzMDQKICMsIGMtZm9ybWF0CiBtc2dpZCAidW51c2FibGUgaW5zdHJ1Y3Rpb24gc2hlZXQ6ICclcyciCiBtc2dzdHIgItC90LXQuNC30L/QvtC70LfQstCw0LXQvCDRhNCw0LnQuyDRgSDQvtC/0LjRgdCw0L3QuNC1INC90LAg0L/RgNC10LTRgdGC0L7Rj9GJ0LjRgtC1INC00LXQudGB0YLQstC40Y86IOKAniVz4oCcIgogCi0jOiBzZXF1ZW5jZXIuYzoyMzcxCisjOiBzZXF1ZW5jZXIuYzoyMzA5CiBtc2dpZCAibm8gY29tbWl0cyBwYXJzZWQuIgogbXNnc3RyICLQvdC40LrQvtC1INC+0YIg0L/QvtC00LDQstCw0L3QuNGP0YLQsCDQvdC1INC80L7QttC1INC00LAg0YHQtSDRgNCw0LfQv9C+0LfQvdCw0LUuIgogCi0jOiBzZXF1ZW5jZXIuYzoyMzgyCisjOiBzZXF1ZW5jZXIuYzoyMzIwCiBtc2dpZCAiY2Fubm90IGNoZXJyeS1waWNrIGR1cmluZyBhIHJldmVydC4iCiBtc2dzdHIgIiIKICLQv9C+INCy0YDQtdC80LUg0L3QsCDQvtGC0LzRj9C90LAg0L3QsCDQv9C+0LTQsNCy0LDQvdC1INC90LUg0LzQvtC20LUg0LTQsCDRgdC1INC40LfQstGK0YDRiNC4INC+0YLQsdC40YDQsNC90LUg0L3QsCDQv9C+0LTQsNCy0LDQvdC1LiIKIAotIzogc2VxdWVuY2VyLmM6MjM4NAorIzogc2VxdWVuY2VyLmM6MjMyMgogbXNnaWQgImNhbm5vdCByZXZlcnQgZHVyaW5nIGEgY2hlcnJ5LXBpY2suIgogbXNnc3RyICLQv9C+INCy0YDQtdC80LUg0L3QsCDQvtGC0LHQuNGA0LDQvdC1INC90LUg0LzQvtC20LUg0LTQsCDRgdC1INC40LfQstGK0YDRiNC4INC+0YLQvNGP0L3QsCDQvdCwINC/0L7QtNCw0LLQsNC90LUuIgogCi0jOiBzZXF1ZW5jZXIuYzoyNDY2CisjOiBzZXF1ZW5jZXIuYzoyNDA0CiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgdmFsdWUgZm9yICVzOiAlcyIKIG1zZ3N0ciAi0L3QtdC/0YDQsNCy0LjQu9C90LAg0YHRgtC+0LnQvdC+0YHRgiDQt9CwIOKAniVz4oCcOiDigJ4lc+KAnCIKIAotIzogc2VxdWVuY2VyLmM6MjU1MworIzogc2VxdWVuY2VyLmM6MjQ5MQogbXNnaWQgInVudXNhYmxlIHNxdWFzaC1vbnRvIgogbXNnc3RyICLQv9C+0LTQsNCy0LDQvdC10YLQviwg0LIg0LrQvtC10YLQviDQtNGA0YPQs9C40YLQtSDQtNCwINGB0LUg0LLQutCw0YDQsNGCLCDQvdC1INC80L7QttC1INC00LAg0YHQtSDQuNC30L/QvtC70LfQstCwIgogCi0jOiBzZXF1ZW5jZXIuYzoyNTY5CisjOiBzZXF1ZW5jZXIuYzoyNTA3CiAjLCBjLWZvcm1hdAogbXNnaWQgIm1hbGZvcm1lZCBvcHRpb25zIHNoZWV0OiAnJXMnIgogbXNnc3RyICLQvdC10L/RgNCw0LLQuNC70LXQvSDRhNCw0LnQuyDRgSDQvtC/0YbQuNC4OiDigJ4lc+KAnCIKIAotIzogc2VxdWVuY2VyLmM6MjY1MiBzZXF1ZW5jZXIuYzo0MzUxCisjOiBzZXF1ZW5jZXIuYzoyNTkwIHNlcXVlbmNlci5jOjQzMDgKIG1zZ2lkICJlbXB0eSBjb21taXQgc2V0IHBhc3NlZCIKIG1zZ3N0ciAi0LfQsNC00LDQtNC10L3QviDQtSDQv9GA0LDQt9C90L4g0LzQvdC+0LbQtdGB0YLQstC+INC+0YIg0L/QvtC00LDQstCw0L3QuNGPIgogCi0jOiBzZXF1ZW5jZXIuYzoyNjY4CisjOiBzZXF1ZW5jZXIuYzoyNjA2CiBtc2dpZCAicmV2ZXJ0IGlzIGFscmVhZHkgaW4gcHJvZ3Jlc3MiCiBtc2dzdHIgItCyINC80L7QvNC10L3RgtCwINCy0LXRh9C1INGB0LUg0LjQt9Cy0YrRgNGI0LLQsCDQvtGC0LzRj9C90LAg0L3QsCDQv9C+0LTQsNCy0LDQvdC40Y8iCiAKLSM6IHNlcXVlbmNlci5jOjI2NzAKKyM6IHNlcXVlbmNlci5jOjI2MDgKICMsIGMtZm9ybWF0CiBtc2dpZCAidHJ5IFwiZ2l0IHJldmVydCAoLS1jb250aW51ZSB8ICVzLS1hYm9ydCB8IC0tcXVpdClcIiIKIG1zZ3N0ciAi0LjQt9C/0L7Qu9C30LLQsNC50YLQtSDigJ5naXQgY2hlcnJ5LXBpY2sgKC0tY29udGludWUgfCAlcy0tYWJvcnQgfCAtLXF1aXQp4oCcIgogCi0jOiBzZXF1ZW5jZXIuYzoyNjczCisjOiBzZXF1ZW5jZXIuYzoyNjExCiBtc2dpZCAiY2hlcnJ5LXBpY2sgaXMgYWxyZWFkeSBpbiBwcm9ncmVzcyIKIG1zZ3N0ciAi0LIg0LzQvtC80LXQvdGC0LAg0LLQtdGH0LUg0YHQtSDQuNC30LLRitGA0YjQstCwINC+0YLQsdC40YDQsNC90LUg0L3QsCDQv9C+0LTQsNCy0LDQvdC40Y8iCiAKLSM6IHNlcXVlbmNlci5jOjI2NzUKKyM6IHNlcXVlbmNlci5jOjI2MTMKICMsIGMtZm9ybWF0CiBtc2dpZCAidHJ5IFwiZ2l0IGNoZXJyeS1waWNrICgtLWNvbnRpbnVlIHwgJXMtLWFib3J0IHwgLS1xdWl0KVwiIgogbXNnc3RyICLQuNC30L/QvtC70LfQstCw0LnRgtC1IOKAnmdpdCBjaGVycnktcGljayAoLS1jb250aW51ZSB8ICVzLS1hYm9ydCB8IC0tcXVpdCnigJwiCiAKLSM6IHNlcXVlbmNlci5jOjI2ODkKKyM6IHNlcXVlbmNlci5jOjI2MjcKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGNyZWF0ZSBzZXF1ZW5jZXIgZGlyZWN0b3J5ICclcyciCiBtc2dzdHIgIiIKICLQtNC40YDQtdC60YLQvtGA0LjRj9GC0LAg0LfQsCDQvtC/0YDQtdC00LXQu9GP0L3QtdGC0L4g0L3QsCDQv9C+0YHQu9C10LTQvtCy0LDRgtC10LvQvdC+0YHRgtGC0LAg4oCeJXPigJwg0L3QtSDQvNC+0LbQtSDQtNCwINCx0YrQtNC1ICIKICLRgdGK0LfQtNCw0LTQtdC90LAiCiAKLSM6IHNlcXVlbmNlci5jOjI3MDQKKyM6IHNlcXVlbmNlci5jOjI2NDIKIG1zZ2lkICJjb3VsZCBub3QgbG9jayBIRUFEIgogbXNnc3RyICLRg9C60LDQt9Cw0YLQtdC70Y/RgiDigJ5IRUFE4oCcINC90LUg0LzQvtC20LUg0LTQsCDRgdC1INC30LDQutC70Y7Rh9C4IgogCi0jOiBzZXF1ZW5jZXIuYzoyNzY0IHNlcXVlbmNlci5jOjQxMDMKKyM6IHNlcXVlbmNlci5jOjI3MDIgc2VxdWVuY2VyLmM6NDA1NwogbXNnaWQgIm5vIGNoZXJyeS1waWNrIG9yIHJldmVydCBpbiBwcm9ncmVzcyIKIG1zZ3N0ciAiIgogItCyINC80L7QvNC10L3RgtCwINC90LUg0YHQtSDQuNC30LLRitGA0YjQstCwINC+0YLQsdC40YDQsNC90LUg0L3QsCDQv9C+0LTQsNCy0LDQvdC40Y8g0LjQu9C4INC/0YDQtdCx0LDQt9C40YDQsNC90LUg0L3QsCDQutC70L7QvdCwIgogCi0jOiBzZXF1ZW5jZXIuYzoyNzY2IHNlcXVlbmNlci5jOjI3NzcKKyM6IHNlcXVlbmNlci5jOjI3MDQgc2VxdWVuY2VyLmM6MjcxNQogbXNnaWQgImNhbm5vdCByZXNvbHZlIEhFQUQiCiBtc2dzdHIgItCf0L7QtNCw0LLQsNC90LXRgtC+INGB0L7Rh9C10L3QviDQvtGCINGD0LrQsNC30LDRgtC10LvRjyDigJ5IRUFE4oCcINC90LUg0LzQvtC20LUg0LTQsCDQsdGK0LTQtSDQvtGC0LrRgNC40YLQviIKIAotIzogc2VxdWVuY2VyLmM6Mjc2OCBzZXF1ZW5jZXIuYzoyODEyCisjOiBzZXF1ZW5jZXIuYzoyNzA2IHNlcXVlbmNlci5jOjI3NTAKIG1zZ2lkICJjYW5ub3QgYWJvcnQgZnJvbSBhIGJyYW5jaCB5ZXQgdG8gYmUgYm9ybiIKIG1zZ3N0ciAiIgogItC00LXQudGB0YLQstC40LXRgtC+INC90LUg0LzQvtC20LUg0LTQsCDQsdGK0LTQtSDQv9GA0LXRg9GB0YLQsNC90L7QstC10L3Qviwg0LrQvtCz0LDRgtC+INGB0YLQtSDQvdCwINC60LvQvtC9LCDQutC+0LnRgtC+INGC0LXQv9GK0YDQstCwICIKICLQv9GA0LXQtNGB0YLQvtC4INC00LAg0LHRitC00LUg0YHRitC30LTQsNC00LXQvSIKIAotIzogc2VxdWVuY2VyLmM6Mjc5OCBidWlsdGluL2dyZXAuYzo3MzQKKyM6IHNlcXVlbmNlci5jOjI3MzYgYnVpbHRpbi9ncmVwLmM6NzM2CiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCBvcGVuICclcyciCiBtc2dzdHIgIuKAniVz4oCcINC90LUg0LzQvtC20LUg0LTQsCDQsdGK0LTQtSDQvtGC0LLQvtGA0LXQvSIKIAotIzogc2VxdWVuY2VyLmM6MjgwMAorIzogc2VxdWVuY2VyLmM6MjczOAogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgcmVhZCAnJXMnOiAlcyIKIG1zZ3N0ciAi4oCeJXPigJwg0L3QtSDQvNC+0LbQtSDQtNCwINCx0YrQtNC1INC/0YDQvtGH0LXRgtC10L06ICVzIgogCi0jOiBzZXF1ZW5jZXIuYzoyODAxCisjOiBzZXF1ZW5jZXIuYzoyNzM5CiBtc2dpZCAidW5leHBlY3RlZCBlbmQgb2YgZmlsZSIKIG1zZ3N0ciAi0L3QtdC+0YfQsNC60LLQsNC9INC60YDQsNC5INC90LAg0YTQsNC50LsiCiAKLSM6IHNlcXVlbmNlci5jOjI4MDcKKyM6IHNlcXVlbmNlci5jOjI3NDUKICMsIGMtZm9ybWF0CiBtc2dpZCAic3RvcmVkIHByZS1jaGVycnktcGljayBIRUFEIGZpbGUgJyVzJyBpcyBjb3JydXB0IgogbXNnc3RyICIiCiAi0LfQsNC/0LDQt9C10L3QuNGP0YIg0L/RgNC10LTQuCDQt9Cw0L/QvtGH0LLQsNC90LXRgtC+INC90LAg0L7RgtCx0LjRgNCw0L3QtdGC0L4g0YTQsNC50Lsg0LfQsCDRg9C60LDQt9Cw0YLQtdC70Y8g4oCeSEVBROKAnCDigJQg4oCeJXPigJwg0LUgIgogItC/0L7QstGA0LXQtNC10L0iCiAKLSM6IHNlcXVlbmNlci5jOjI4MTgKKyM6IHNlcXVlbmNlci5jOjI3NTYKIG1zZ2lkICJZb3Ugc2VlbSB0byBoYXZlIG1vdmVkIEhFQUQuIE5vdCByZXdpbmRpbmcsIGNoZWNrIHlvdXIgSEVBRCEiCiBtc2dzdHIgIiIKICLQmNC30LPQu9C10LbQtNCwINGD0LrQsNC30LDRgtC10LvRj9GCIOKAnkhFQUTigJwg0LUg0L/RgNC+0LzQtdC90LXQvS4gINCf0YDQvtCy0LXRgNC10YLQtSDQutGK0Lwg0LrQsNC60LLQviDRgdC+0YfQuC5cbiIKICLQndC1INGB0LUg0L/RgNCw0LLRj9GCINC/0YDQvtC80LXQvdC4LiIKIAotIzogc2VxdWVuY2VyLmM6Mjg1OQorIzogc2VxdWVuY2VyLmM6Mjc5NwogbXNnaWQgIm5vIHJldmVydCBpbiBwcm9ncmVzcyIKIG1zZ3N0ciAi0LIg0LzQvtC80LXQvdGC0LAg0L3QtSDRgtC10YfQtSDQv9GA0LXQsdCw0LfQuNGA0LDQvdC1IgogCi0jOiBzZXF1ZW5jZXIuYzoyODY3CisjOiBzZXF1ZW5jZXIuYzoyODA1CiBtc2dpZCAibm8gY2hlcnJ5LXBpY2sgaW4gcHJvZ3Jlc3MiCiBtc2dzdHIgItCyINC80L7QvNC10L3RgtCwINC90LUg0YHQtSDQuNC30LLRitGA0YjQstCwINC+0YLQsdC40YDQsNC90LUg0L3QsCDQv9C+0LTQsNCy0LDQvdC40Y8iCiAKLSM6IHNlcXVlbmNlci5jOjI4NzcKKyM6IHNlcXVlbmNlci5jOjI4MTUKIG1zZ2lkICJmYWlsZWQgdG8gc2tpcCB0aGUgY29tbWl0IgogbXNnc3RyICLQvdC10YPRgdC/0LXRiNC90L4g0L/RgNC10YHQutCw0YfQsNC90LUg0L3QsCDQv9C+0LTQsNCy0LDQvdC10YLQviIKIAotIzogc2VxdWVuY2VyLmM6Mjg4NAorIzogc2VxdWVuY2VyLmM6MjgyMgogbXNnaWQgInRoZXJlIGlzIG5vdGhpbmcgdG8gc2tpcCIKIG1zZ3N0ciAi0L3Rj9C80LAg0LrQsNC60LLQviDQtNCwINGB0LUg0L/RgNC10YHQutC+0YfQuCIKIAotIzogc2VxdWVuY2VyLmM6Mjg4NworIzogc2VxdWVuY2VyLmM6MjgyNQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiaGF2ZSB5b3UgY29tbWl0dGVkIGFscmVhZHk/XG4iCkBAIC02NTg3LDIxICs2NjEzLDIxIEBACiAiXG4iCiAiICAgIGdpdCAlcyAtLWNvbnRpbnVlIgogCi0jOiBzZXF1ZW5jZXIuYzozMDExIHNlcXVlbmNlci5jOjQwMTUKKyM6IHNlcXVlbmNlci5jOjI5NDkgc2VxdWVuY2VyLmM6Mzk2OQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgdXBkYXRlICVzIgogbXNnc3RyICLigJ4lc+KAnCDQvdC1INC80L7QttC1INC00LAg0YHQtSDQvtCx0L3QvtCy0LgiCiAKLSM6IHNlcXVlbmNlci5jOjMwNDkgc2VxdWVuY2VyLmM6Mzk5NQorIzogc2VxdWVuY2VyLmM6Mjk4NyBzZXF1ZW5jZXIuYzozOTQ5CiBtc2dpZCAiY2Fubm90IHJlYWQgSEVBRCIKIG1zZ3N0ciAi0YPQutCw0LfQsNGC0LXQu9GP0YIg4oCeSEVBROKAnCDQvdC1INC80L7QttC1INC00LAg0LHRitC00LUg0L/RgNC+0YfQtdGC0LXQvSIKIAotIzogc2VxdWVuY2VyLmM6MzA2NgorIzogc2VxdWVuY2VyLmM6MzAwNAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gY29weSAnJXMnIHRvICclcyciCiBtc2dzdHIgIuKAniVz4oCcINC90LUg0LzQvtC20LUg0LTQsCDRgdC1INC60L7Qv9C40YDQsCDQutCw0YLQviDigJ4lc+KAnCIKIAotIzogc2VxdWVuY2VyLmM6MzA3NAorIzogc2VxdWVuY2VyLmM6MzAxMgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiWW91IGNhbiBhbWVuZCB0aGUgY29tbWl0IG5vdywgd2l0aFxuIgpAQCAtNjYyMCwyNyArNjY0NiwyNyBAQAogIlxuIgogIiAgICBnaXQgcmViYXNlIC0tY29udGludWVcbiIKIAotIzogc2VxdWVuY2VyLmM6MzA4NAorIzogc2VxdWVuY2VyLmM6MzAyMgogIywgYy1mb3JtYXQKIG1zZ2lkICJDb3VsZCBub3QgYXBwbHkgJXMuLi4gJS4qcyIKIG1zZ3N0ciAi0J/QvtC00LDQstCw0L3QtdGC0L4g4oCeJXPigJzigKYg0L3QtSDQvNC+0LbQtSDQtNCwINCx0YrQtNC1INC/0YDQuNC70L7QttC10L3Qvjog4oCeJS4qc+KAnCIKIAotIzogc2VxdWVuY2VyLmM6MzA5MQorIzogc2VxdWVuY2VyLmM6MzAyOQogIywgYy1mb3JtYXQKIG1zZ2lkICJDb3VsZCBub3QgbWVyZ2UgJS4qcyIKIG1zZ3N0ciAi0J3QtdCy0YrQt9C80L7QttC90L4g0YHQu9C40LLQsNC90LUg0L3QsCDigJ4lLipz4oCcIgogCi0jOiBzZXF1ZW5jZXIuYzozMTA1IHNlcXVlbmNlci5jOjMxMDkgYnVpbHRpbi9kaWZmdG9vbC5jOjYzMworIzogc2VxdWVuY2VyLmM6MzA0MyBzZXF1ZW5jZXIuYzozMDQ3IGJ1aWx0aW4vZGlmZnRvb2wuYzo2NDEKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGNvcHkgJyVzJyB0byAnJXMnIgogbXNnc3RyICLigJ4lc+KAnCDQvdC1INC80L7QttC1INC00LAg0YHQtSDQutC+0L/QuNGA0LAg0LrQsNGC0L4g4oCeJXPigJwiCiAKLSM6IHNlcXVlbmNlci5jOjMxMzEgc2VxdWVuY2VyLmM6MzU1OCBidWlsdGluL3JlYmFzZS5jOjg0OSBidWlsdGluL3JlYmFzZS5jOjE1ODIKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTk1MyBidWlsdGluL3JlYmFzZS5jOjIwMDgKKyM6IHNlcXVlbmNlci5jOjMwNjkgc2VxdWVuY2VyLmM6MzUwNiBidWlsdGluL3JlYmFzZS5jOjg1MCBidWlsdGluL3JlYmFzZS5jOjE2MTMKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTk4NyBidWlsdGluL3JlYmFzZS5jOjIwMzEKIG1zZ2lkICJjb3VsZCBub3QgcmVhZCBpbmRleCIKIG1zZ3N0ciAi0LjQvdC00LXQutGB0YrRgiDQvdC1INC80L7QttC1INC00LAg0LHRitC00LUg0L/RgNC+0YfQtdGC0LXQvSIKIAotIzogc2VxdWVuY2VyLmM6MzEzNgorIzogc2VxdWVuY2VyLmM6MzA3NAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiZXhlY3V0aW9uIGZhaWxlZDogJXNcbiIKQEAgLTY2NTUsMTEgKzY2ODEsMTEgQEAKICIgICAgZ2l0IHJlYmFzZSAtLWNvbnRpbnVlXG4iCiAiXG4iCiAKLSM6IHNlcXVlbmNlci5jOjMxNDIKKyM6IHNlcXVlbmNlci5jOjMwODAKIG1zZ2lkICJhbmQgbWFkZSBjaGFuZ2VzIHRvIHRoZSBpbmRleCBhbmQvb3IgdGhlIHdvcmtpbmcgdHJlZVxuIgogbXNnc3RyICLQuCDQv9GA0L7QvNC10L3RnSDQuNC90LTQtdC60YHQsCDQuC/QuNC70Lgg0YDQsNCx0L7RgtC90L7RgtC+INC00YrRgNCy0L5cbiIKIAotIzogc2VxdWVuY2VyLmM6MzE0OAorIzogc2VxdWVuY2VyLmM6MzA4NgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiZXhlY3V0aW9uIHN1Y2NlZWRlZDogJXNcbiIKQEAgLTY2NzYsNzYgKzY3MDIsNzYgQEAKICIgICAgZ2l0IHJlYmFzZSAtLWNvbnRpbnVlXG4iCiAiXG4iCiAKLSM6IHNlcXVlbmNlci5jOjMyMDkKKyM6IHNlcXVlbmNlci5jOjMxNDcKICMsIGMtZm9ybWF0CiBtc2dpZCAiaWxsZWdhbCBsYWJlbCBuYW1lOiAnJS4qcyciCiBtc2dzdHIgItC90LXQv9GA0LDQstC40LvQvdC+INC40LzQtSDQvdCwINC10YLQuNC60LXRgjog4oCeJS4qc+KAnCIKIAotIzogc2VxdWVuY2VyLmM6MzI2MworIzogc2VxdWVuY2VyLmM6MzIwMQogbXNnaWQgIndyaXRpbmcgZmFrZSByb290IGNvbW1pdCIKIG1zZ3N0ciAi0LfQsNC/0LDQt9Cy0LDQvdC1INC90LAg0YTQsNC70YjQuNCy0L4g0L3QsNGH0LDQu9C90L4g0L/QvtC00LDQstCw0L3QtSIKIAotIzogc2VxdWVuY2VyLmM6MzI2OAorIzogc2VxdWVuY2VyLmM6MzIwNgogbXNnaWQgIndyaXRpbmcgc3F1YXNoLW9udG8iCiBtc2dzdHIgItC30LDQv9Cw0LfQstCw0L3QtSDQvdCwINC/0L7QtNCw0LLQsNC90LXRgtC+LCDQsiDQutC+0LXRgtC+INC00YDRg9Cz0LjRgtC1INC00LAg0YHQtSDQstC60LDRgNCw0YIiCiAKLSM6IHNlcXVlbmNlci5jOjMzMDYgYnVpbHRpbi9yZWJhc2UuYzo4NTQgYnVpbHRpbi9yZWJhc2UuYzo4NjAKKyM6IHNlcXVlbmNlci5jOjMyNDQgYnVpbHRpbi9yZWJhc2UuYzo4NTUgYnVpbHRpbi9yZWJhc2UuYzo4NjEKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIGZpbmQgdHJlZSBvZiAlcyIKIG1zZ3N0ciAi0LTRitGA0LLQvtGC0L4sINGB0L7Rh9C10L3QviDQvtGCIOKAniVz4oCcLCDQvdC1INC80L7QttC1INC00LAg0LHRitC00LUg0L7RgtC60YDQuNGC0L4iCiAKLSM6IHNlcXVlbmNlci5jOjMzMjQgYnVpbHRpbi9yZWJhc2UuYzo4NzMKKyM6IHNlcXVlbmNlci5jOjMyNjIgYnVpbHRpbi9yZWJhc2UuYzo4NzQKIG1zZ2lkICJjb3VsZCBub3Qgd3JpdGUgaW5kZXgiCiBtc2dzdHIgItC40L3QtNC10LrRgdGK0YIg0L3QtSDQvNC+0LbQtSDQtNCwINCx0YrQtNC1INC30LDQv9C40YHQsNC9IgogCi0jOiBzZXF1ZW5jZXIuYzozMzUxCisjOiBzZXF1ZW5jZXIuYzozMjg5CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCByZXNvbHZlICclcyciCiBtc2dzdHIgIuKAniVz4oCcINC90LUg0LzQvtC20LUg0LTQsCDQsdGK0LTQtSDQvtGC0LrRgNC40YIiCiAKLSM6IHNlcXVlbmNlci5jOjMzNzkKKyM6IHNlcXVlbmNlci5jOjMzMjAKIG1zZ2lkICJjYW5ub3QgbWVyZ2Ugd2l0aG91dCBhIGN1cnJlbnQgcmV2aXNpb24iCiBtc2dzdHIgItCx0LXQtyDRgtC10LrRg9GJ0L4g0L/QvtC00LDQstCw0L3QtSDQvdC1INC80L7QttC1INC00LAg0YHQtSDRgdC70LjQstCwIgogCi0jOiBzZXF1ZW5jZXIuYzozNDAxCisjOiBzZXF1ZW5jZXIuYzozMzQyCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBwYXJzZSAnJS4qcyciCiBtc2dzdHIgIuKAniUuKnPigJwg0L3QtSDQvNC+0LbQtSDQtNCwINGB0LUg0LDQvdCw0LvQuNC30LjRgNCwIgogCi0jOiBzZXF1ZW5jZXIuYzozNDEwCisjOiBzZXF1ZW5jZXIuYzozMzUxCiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vdGhpbmcgdG8gbWVyZ2U6ICclLipzJyIKIG1zZ3N0ciAi0L3Rj9C80LAg0L3QuNGJ0L4g0LfQsCDRgdC70LjQstCw0L3QtTog4oCeJS4qc+KAnCIKIAotIzogc2VxdWVuY2VyLmM6MzQyMgorIzogc2VxdWVuY2VyLmM6MzM2MwogbXNnaWQgIm9jdG9wdXMgbWVyZ2UgY2Fubm90IGJlIGV4ZWN1dGVkIG9uIHRvcCBvZiBhIFtuZXcgcm9vdF0iCiBtc2dzdHIgItCy0YrRgNGF0YMg0L3QsNGH0LDQu9C90L4g0L/QvtC00LDQstCw0L3QtSDQvdC1INC80L7QttC1INC00LAg0YHQtSDQuNC30LLRitGA0YjQuCDQvNC90L7QttC10YHRgtCy0LXQvdC+INGB0LvQuNCy0LDQvdC1IgogCi0jOiBzZXF1ZW5jZXIuYzozNDM3CisjOiBzZXF1ZW5jZXIuYzozMzc4CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBnZXQgY29tbWl0IG1lc3NhZ2Ugb2YgJyVzJyIKIG1zZ3N0ciAi0YHRitC+0LHRidC10L3QuNC10YLQviDQt9CwINC/0L7QtNCw0LLQsNC90LUg0LrRitC8IOKAniVz4oCcINC90LUg0LzQvtC20LUg0LTQsCDQsdGK0LTQtSDQv9C+0LvRg9GH0LXQvdC+IgogCi0jOiBzZXF1ZW5jZXIuYzozNTkwCisjOiBzZXF1ZW5jZXIuYzozNTM4CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBldmVuIGF0dGVtcHQgdG8gbWVyZ2UgJyUuKnMnIgogbXNnc3RyICLRgdC70LjQstCw0L3QtdGC0L4g0L3QsCDigJ4lLipz4oCcINC90LUg0LzQvtC20LUg0LTQsNC20LUg0LTQsCDQt9Cw0L/QvtGH0L3QtSIKIAotIzogc2VxdWVuY2VyLmM6MzYwNgorIzogc2VxdWVuY2VyLmM6MzU1NAogbXNnaWQgIm1lcmdlOiBVbmFibGUgdG8gd3JpdGUgbmV3IGluZGV4IGZpbGUiCiBtc2dzdHIgItGB0LvQuNCy0LDQvdC1OiDQvdC+0LLQuNGP0YIg0LjQvdC00LXQutGBINC90LUg0LzQvtC20LUg0LTQsCDQsdGK0LTQtSDQt9Cw0L/QsNC30LXQvSIKIAotIzogc2VxdWVuY2VyLmM6MzY3NSBidWlsdGluL3JlYmFzZS5jOjcxMQorIzogc2VxdWVuY2VyLmM6MzYyMyBidWlsdGluL3JlYmFzZS5jOjcxMgogIywgYy1mb3JtYXQKIG1zZ2lkICJBcHBsaWVkIGF1dG9zdGFzaC5cbiIKIG1zZ3N0ciAi0JDQstGC0L7QvNCw0YLQuNGH0L3QviDRgdC60LDRgtCw0L3QvtGC0L4g0LUg0L/RgNC40LvQvtC20LXQvdC+LlxuIgogCi0jOiBzZXF1ZW5jZXIuYzozNjg3CisjOiBzZXF1ZW5jZXIuYzozNjM1CiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCBzdG9yZSAlcyIKIG1zZ3N0ciAi4oCeJXPigJwg0L3QtSDQvNC+0LbQtSDQtNCwINCx0YrQtNC1INC30LDQv9Cw0LfQtdC9IgogCi0jOiBzZXF1ZW5jZXIuYzozNjkwIGJ1aWx0aW4vcmViYXNlLmM6NzI3IGdpdC1yZWJhc2UtLXByZXNlcnZlLW1lcmdlcy5zaDoxMTMKKyM6IHNlcXVlbmNlci5jOjM2MzggYnVpbHRpbi9yZWJhc2UuYzo3MjggZ2l0LXJlYmFzZS0tcHJlc2VydmUtbWVyZ2VzLnNoOjExMwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiQXBwbHlpbmcgYXV0b3N0YXNoIHJlc3VsdGVkIGluIGNvbmZsaWN0cy5cbiIKQEAgLTY3NTYsMzEgKzY3ODIsMzEgQEAKICLQvdCw0LTQtdC20LTQvdC+INGB0LrQsNGC0LDQvdC4LiAg0JzQvtC20LXRgtC1INC00LAg0L/RgNC+0LHQstCw0YLQtSDQtNCwINCz0Lgg0L/RgNC40LvQvtC20LjRgtC1INGH0YDQtdC3IOKAnmdpdCBzdGFzaCBwb3DigJxcbiIKICLQuNC70Lgg0LTQsCDQs9C4INC40LfRhdCy0YrRgNC70LjRgtC1INGH0YDQtdC3IOKAnmdpdCBzdGFzaCBkcm9w4oCcLCDQutC+0LPQsNGC0L4g0L/QvtC40YHQutCw0YLQtS5cbiIKIAotIzogc2VxdWVuY2VyLmM6Mzc1MQorIzogc2VxdWVuY2VyLmM6MzY5OQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgY2hlY2tvdXQgJXMiCiBtc2dzdHIgIuKAniVz4oCcINC90LUg0LzQvtC20LUg0LTQsCDRgdC1INC40LfRgtC10LPQu9C4IgogCi0jOiBzZXF1ZW5jZXIuYzozNzY1CisjOiBzZXF1ZW5jZXIuYzozNzEzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiBub3QgYSB2YWxpZCBPSUQiCiBtc2dzdHIgIuKAniVz4oCcINC1INC90LXQv9GA0LDQstC40LvQtdC9INC40LTQtdC90YLQuNGE0LjQutCw0YLQvtGAINC90LAg0L7QsdC10LrRgiIKIAotIzogc2VxdWVuY2VyLmM6Mzc3MCBnaXQtcmViYXNlLS1wcmVzZXJ2ZS1tZXJnZXMuc2g6Nzc5CisjOiBzZXF1ZW5jZXIuYzozNzE4IGdpdC1yZWJhc2UtLXByZXNlcnZlLW1lcmdlcy5zaDo3NzkKIG1zZ2lkICJjb3VsZCBub3QgZGV0YWNoIEhFQUQiCiBtc2dzdHIgItGD0LrQsNC30LDRgtC10LvRj9GCIOKAnkhFQUTigJwg0L3QtSDQvNC+0LbQtSDQtNCwINGB0LUg0L7RgtC00LXQu9C4IgogCi0jOiBzZXF1ZW5jZXIuYzozNzg1CisjOiBzZXF1ZW5jZXIuYzozNzMzCiAjLCBjLWZvcm1hdAogbXNnaWQgIlN0b3BwZWQgYXQgSEVBRFxuIgogbXNnc3RyICLQkdC1INGB0L/RgNGP0L3QviDQv9GA0Lgg4oCeSEVBROKAnFxuIgogCi0jOiBzZXF1ZW5jZXIuYzozNzg3CisjOiBzZXF1ZW5jZXIuYzozNzM1CiAjLCBjLWZvcm1hdAogbXNnaWQgIlN0b3BwZWQgYXQgJXNcbiIKIG1zZ3N0ciAi0JHQtSDRgdC/0YDRj9C90L4g0L/RgNC4IOKAniVz4oCcXG4iCiAKLSM6IHNlcXVlbmNlci5jOjM3OTUKKyM6IHNlcXVlbmNlci5jOjM3NDMKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkNvdWxkIG5vdCBleGVjdXRlIHRoZSB0b2RvIGNvbW1hbmRcbiIKQEAgLTY4MDMsNDggKzY4MjksNDggQEAKICIgICAgZ2l0IHJlYmFzZSAtLWVkaXQtdG9kb1xuIgogIiAgICBnaXQgcmViYXNlIC0tY29udGludWVcbiIKIAotIzogc2VxdWVuY2VyLmM6Mzg3NworIzogc2VxdWVuY2VyLmM6MzgyNwogIywgYy1mb3JtYXQKIG1zZ2lkICJTdG9wcGVkIGF0ICVzLi4uICAlLipzXG4iCiBtc2dzdHIgItCh0L/QuNGA0LDQvdC1INC/0YDQuCDigJ4lc+KAnOKApiAgJS4qc1xuIgogCi0jOiBzZXF1ZW5jZXIuYzozOTU4CisjOiBzZXF1ZW5jZXIuYzozODk4CiAjLCBjLWZvcm1hdAogbXNnaWQgInVua25vd24gY29tbWFuZCAlZCIKIG1zZ3N0ciAi0L3QtdC/0L7Qt9C90LDRgtCwINC60L7QvNCw0L3QtNCwICVkIgogCi0jOiBzZXF1ZW5jZXIuYzo0MDAzCisjOiBzZXF1ZW5jZXIuYzozOTU3CiBtc2dpZCAiY291bGQgbm90IHJlYWQgb3JpZy1oZWFkIgogbXNnc3RyICLRg9C60LDQt9Cw0YLQtdC70Y/RgiDQt9CwIOKAnm9yaWctaGVhZOKAnCDQvdC1INC80L7QttC1INC00LAg0YHQtSDQv9GA0L7Rh9C10YLQtSIKIAotIzogc2VxdWVuY2VyLmM6NDAwOAorIzogc2VxdWVuY2VyLmM6Mzk2MgogbXNnaWQgImNvdWxkIG5vdCByZWFkICdvbnRvJyIKIG1zZ3N0ciAi0YPQutCw0LfQsNGC0LXQu9GP0YIg0LfQsCDigJ5vbnRv4oCcINC90LUg0LzQvtC20LUg0LTQsCDRgdC1INC/0YDQvtGH0LXRgtC1IgogCi0jOiBzZXF1ZW5jZXIuYzo0MDIyCisjOiBzZXF1ZW5jZXIuYzozOTc2CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCB1cGRhdGUgSEVBRCB0byAlcyIKIG1zZ3N0ciAi4oCeSEVBROKAnCDQvdC1INC80L7QttC1INC00LAg0LHRitC00LUg0L7QsdC90L7QstC10L0g0LTQviDigJ4lc+KAnCIKIAotIzogc2VxdWVuY2VyLmM6NDExNQorIzogc2VxdWVuY2VyLmM6NDA2OQogbXNnaWQgImNhbm5vdCByZWJhc2U6IFlvdSBoYXZlIHVuc3RhZ2VkIGNoYW5nZXMuIgogbXNnc3RyICLQvdC1INC80L7QttC1INC00LAg0L/RgNC10LHQsNC30LjRgNCw0YLQtSwg0LfQsNGJ0L7RgtC+INC40LzQsCDQv9GA0L7QvNC10L3QuCwg0LrQvtC40YLQviDQvdC1INGB0LAg0LIg0LjQvdC00LXQutGB0LAuIgogCi0jOiBzZXF1ZW5jZXIuYzo0MTI0CisjOiBzZXF1ZW5jZXIuYzo0MDc4CiBtc2dpZCAiY2Fubm90IGFtZW5kIG5vbi1leGlzdGluZyBjb21taXQiCiBtc2dzdHIgItC90LXRgdGK0YnQtdGB0YLQstGD0LLQsNGJ0L4g0L/QvtC00LDQstCw0L3QtSDQvdC1INC80L7QttC1INC00LAg0YHQtSDQv9C+0L/RgNCw0LLQuCIKIAotIzogc2VxdWVuY2VyLmM6NDEyNgorIzogc2VxdWVuY2VyLmM6NDA4MAogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIGZpbGU6ICclcyciCiBtc2dzdHIgItC90LXQv9GA0LDQstC40LvQtdC9INGE0LDQudC7OiDigJ4lc+KAnCIKIAotIzogc2VxdWVuY2VyLmM6NDEyOAorIzogc2VxdWVuY2VyLmM6NDA4MgogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIGNvbnRlbnRzOiAnJXMnIgogbXNnc3RyICLQvdC10L/RgNCw0LLQuNC70L3QviDRgdGK0LTRitGA0LbQsNC90LjQtTog4oCeJXPigJwiCiAKLSM6IHNlcXVlbmNlci5jOjQxMzEKKyM6IHNlcXVlbmNlci5jOjQwODUKIG1zZ2lkICIiCiAiXG4iCiAiWW91IGhhdmUgdW5jb21taXR0ZWQgY2hhbmdlcyBpbiB5b3VyIHdvcmtpbmcgdHJlZS4gUGxlYXNlLCBjb21taXQgdGhlbVxuIgpAQCAtNjg1NCw0MiArNjg4MCw0MiBAQAogItCSINGA0LDQsdC+0YLQvdC+0YLQviDQtNGK0YDQstC+INC40LzQsCDQvdC10L/QvtC00LDQtNC10L3QuCDQv9GA0L7QvNC10L3QuC4gINCf0YrRgNCy0L4g0LPQuCDQv9C+0LTQsNC50YLQtSwg0LAg0YHQu9C10LQg0YLQvtCy0LBcbiIKICLQvtGC0L3QvtCy0L4g0LjQt9C/0YrQu9C90LXRgtC1IOKAnmdpdCByZWJhc2UgLS1jb250aW51ZeKAnC4iCiAKLSM6IHNlcXVlbmNlci5jOjQxNjcgc2VxdWVuY2VyLmM6NDIwNQorIzogc2VxdWVuY2VyLmM6NDEyMSBzZXF1ZW5jZXIuYzo0MTU5CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCB3cml0ZSBmaWxlOiAnJXMnIgogbXNnc3RyICLRhNCw0LnQu9GK0YIg4oCeJXPigJwg0L3QtSDQvNC+0LbQtSDQtNCwINCx0YrQtNC1INC30LDQv9C40YHQsNC9IgogCi0jOiBzZXF1ZW5jZXIuYzo0MjIwCisjOiBzZXF1ZW5jZXIuYzo0MTc0CiBtc2dpZCAiY291bGQgbm90IHJlbW92ZSBDSEVSUllfUElDS19IRUFEIgogbXNnc3RyICLRg9C60LDQt9Cw0YLQtdC70Y/RgiDigJ5DSEVSUllfUElDS19IRUFE4oCcINC90LUg0LzQvtC20LUg0LTQsCDQsdGK0LTQtSDQuNC30YLRgNC40YIiCiAKLSM6IHNlcXVlbmNlci5jOjQyMjcKKyM6IHNlcXVlbmNlci5jOjQxODEKIG1zZ2lkICJjb3VsZCBub3QgY29tbWl0IHN0YWdlZCBjaGFuZ2VzLiIKIG1zZ3N0ciAi0L/RgNC+0LzQtdC90LjRgtC1INCyINC40L3QtNC10LrRgdCwINC90LUg0LzQvtCz0LDRgiDQtNCwINCx0YrQtNCw0YIg0L/QvtC00LDQtNC10L3QuC4iCiAKLSM6IHNlcXVlbmNlci5jOjQzMjgKKyM6IHNlcXVlbmNlci5jOjQyODUKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXM6IGNhbid0IGNoZXJyeS1waWNrIGEgJXMiCiBtc2dzdHIgIiVzOiDQvdC1INC80L7QttC1INC00LAg0YHQtSDQvtGC0LHQtdGA0LUg4oCeJXPigJwiCiAKLSM6IHNlcXVlbmNlci5jOjQzMzIKKyM6IHNlcXVlbmNlci5jOjQyODkKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXM6IGJhZCByZXZpc2lvbiIKIG1zZ3N0ciAiJXM6INC90LXQv9GA0LDQstC40LvQvdCwINCy0LXRgNGB0LjRjyIKIAotIzogc2VxdWVuY2VyLmM6NDM2NworIzogc2VxdWVuY2VyLmM6NDMyNAogbXNnaWQgImNhbid0IHJldmVydCBhcyBpbml0aWFsIGNvbW1pdCIKIG1zZ3N0ciAi0L/RitGA0LLQvtC90LDRh9Cw0LvQvdC+0YLQviDQv9C+0LTQsNCy0LDQvdC1INC90LUg0LzQvtC20LUg0LTQsCDQsdGK0LTQtSDQvtGC0LzQtdC90LXQvdC+IgogCi0jOiBzZXF1ZW5jZXIuYzo0ODEwCisjOiBzZXF1ZW5jZXIuYzo0Nzc0CiBtc2dpZCAibWFrZV9zY3JpcHQ6IHVuaGFuZGxlZCBvcHRpb25zIgogbXNnc3RyICJtYWtlX3NjcmlwdDog0L3QtdC/0L7QtNC00YrRgNC20LDQvdC4INC+0L/RhtC40LgiCiAKLSM6IHNlcXVlbmNlci5jOjQ4MTMKKyM6IHNlcXVlbmNlci5jOjQ3NzcKIG1zZ2lkICJtYWtlX3NjcmlwdDogZXJyb3IgcHJlcGFyaW5nIHJldmlzaW9ucyIKIG1zZ3N0ciAibWFrZV9zY3JpcHQ6INCz0YDQtdGI0LrQsCDQv9GA0Lgg0L/QvtC00LPQvtGC0L7QstC60LDRgtCwINC90LAg0LLQtdGA0YHQuNC4IgogCi0jOiBzZXF1ZW5jZXIuYzo0OTcxCisjOiBzZXF1ZW5jZXIuYzo0OTM1CiBtc2dpZCAiIgogIllvdSBjYW4gZml4IHRoaXMgd2l0aCAnZ2l0IHJlYmFzZSAtLWVkaXQtdG9kbycgYW5kIHRoZW4gcnVuICdnaXQgcmViYXNlIC0tIgogImNvbnRpbnVlJy5cbiIKQEAgLTY4OTksMjQgKzY5MjUsMjQgQEAKICJjb250aW51ZeKAnCDRgdC70LXQtCDRgtC+0LLQsC5cbiIKICLQnNC+0LbQtSDQuCDQtNCwINC/0YDQtdGD0YHRgtCw0L3QvtCy0LjRgtC1INC/0YDQtdCx0LDQt9C40YDQsNC90LXRgtC+INGBINC60L7QvNCw0L3QtNCw0YLQsCDigJ5naXQgcmViYXNlIC0tYWJvcnTigJwuXG4iCiAKLSM6IHNlcXVlbmNlci5jOjUwODMgc2VxdWVuY2VyLmM6NTEwMAorIzogc2VxdWVuY2VyLmM6NTA0NyBzZXF1ZW5jZXIuYzo1MDY0CiBtc2dpZCAibm90aGluZyB0byBkbyIKIG1zZ3N0ciAi0L3Rj9C80LAg0LrQsNC60LLQviDQtNCwINGB0LUg0L/RgNCw0LLQuCIKIAotIzogc2VxdWVuY2VyLmM6NTExNAorIzogc2VxdWVuY2VyLmM6NTA3OAogbXNnaWQgImNvdWxkIG5vdCBza2lwIHVubmVjZXNzYXJ5IHBpY2sgY29tbWFuZHMiCiBtc2dzdHIgItC40LfQu9C40YjQvdC40YLQtSDQutC+0LzQsNC90LTQuCDQt9CwINC+0YLQsdC40YDQsNC90LUg0L3QtSDQsdGP0YXQsCDQv9GA0LXRgdC60L7Rh9C10L3QuCIKIAotIzogc2VxdWVuY2VyLmM6NTE5NworIzogc2VxdWVuY2VyLmM6NTE2NgogbXNnaWQgInRoZSBzY3JpcHQgd2FzIGFscmVhZHkgcmVhcnJhbmdlZC4iCiBtc2dzdHIgItGB0LrRgNC40L/RgtGK0YIg0LLQtdGH0LUg0LUg0L/RgNC10L/QvtC00YDQtdC00LXQvS4iCiAKLSM6IHNldHVwLmM6MTIzCisjOiBzZXR1cC5jOjEyNAogIywgYy1mb3JtYXQKIG1zZ2lkICInJXMnIGlzIG91dHNpZGUgcmVwb3NpdG9yeSIKIG1zZ3N0ciAi4oCeJXPigJwg0LUg0LjQt9Cy0YrQvSDRhdGA0LDQvdC40LvQuNGJ0LXRgtC+IgogCi0jOiBzZXR1cC5jOjE3MworIzogc2V0dXAuYzoxNzQKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIiVzOiBubyBzdWNoIHBhdGggaW4gdGhlIHdvcmtpbmcgdHJlZS5cbiIKQEAgLTY5MjcsNyArNjk1Myw3IEBACiAiXG4iCiAiICAgIGdpdCDQmtCe0JzQkNCd0JTQkCAtLSDQn9Cq0KLigKYiCiAKLSM6IHNldHVwLmM6MTg2CisjOiBzZXR1cC5jOjE4NwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiYW1iaWd1b3VzIGFyZ3VtZW50ICclcyc6IHVua25vd24gcmV2aXNpb24gb3IgcGF0aCBub3QgaW4gdGhlIHdvcmtpbmcgdHJlZS5cbiIKQEAgLTY5NDAsMTIgKzY5NjYsMTIgQEAKICJcbiIKICIgICAgZ2l0INCa0J7QnNCQ0J3QlNCQIFvQktCV0KDQodCY0K/igKZdIC0tIFvQpNCQ0JnQm+KApl0iCiAKLSM6IHNldHVwLmM6MjM1CisjOiBzZXR1cC5jOjIzNgogIywgYy1mb3JtYXQKIG1zZ2lkICJvcHRpb24gJyVzJyBtdXN0IGNvbWUgYmVmb3JlIG5vbi1vcHRpb24gYXJndW1lbnRzIgogbXNnc3RyICLQvtC/0YbQuNGP0YLQsCDigJ4lc+KAnCDRgtGA0Y/QsdCy0LAg0LTQsCDQtSDQv9GA0LXQtNC4INC/0YrRgNCy0LjRjyDQsNGA0LPRg9C80LXQvdGCLCDQutC+0LnRgtC+INC90LUg0LUg0L7Qv9GG0LjRjyIKIAotIzogc2V0dXAuYzoyNTQKKyM6IHNldHVwLmM6MjU1CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJhbWJpZ3VvdXMgYXJndW1lbnQgJyVzJzogYm90aCByZXZpc2lvbiBhbmQgZmlsZW5hbWVcbiIKQEAgLTY5NTcsOTUgKzY5ODMsOTUgQEAKICJcbiIKICIgICAgZ2l0INCa0J7QnNCQ0J3QlNCQIFvQktCV0KDQodCY0K/igKZdIC0tIFvQpNCQ0JnQm+KApl0iCiAKLSM6IHNldHVwLmM6MzkwCisjOiBzZXR1cC5jOjM5MQogbXNnaWQgInVuYWJsZSB0byBzZXQgdXAgd29yayB0cmVlIHVzaW5nIGludmFsaWQgY29uZmlnIgogbXNnc3RyICIiCiAi0L3QtSDQvNC+0LbQtSDQtNCwINGB0LUg0LfQsNC00LDQtNC1INGC0LXQutGD0YnQsCDRgNCw0LHQvtGC0L3QsCDQtNC40YDQtdC60YLQvtGA0LjRjyDQv9GA0Lgg0L3QtdC/0YDQsNCy0LjQu9C90Lgg0L3QsNGB0YLRgNC+0LnQutC4IgogCi0jOiBzZXR1cC5jOjM5NAorIzogc2V0dXAuYzozOTUKIG1zZ2lkICJ0aGlzIG9wZXJhdGlvbiBtdXN0IGJlIHJ1biBpbiBhIHdvcmsgdHJlZSIKIG1zZ3N0ciAi0YLQsNC30Lgg0LrQvtC80LDQvdC00LAg0YLRgNGP0LHQstCwINC00LAg0YHQtSDQuNC30L/RitC70L3QuCDQsiDRgNCw0LHQvtGC0L3QviDQtNGK0YDQstC+IgogCi0jOiBzZXR1cC5jOjU0MAorIzogc2V0dXAuYzo1NDEKICMsIGMtZm9ybWF0CiBtc2dpZCAiRXhwZWN0ZWQgZ2l0IHJlcG8gdmVyc2lvbiA8PSAlZCwgZm91bmQgJWQiCiBtc2dzdHIgItCe0YfQsNC60LLQsCDRgdC1INCy0LXRgNGB0LjRjyDQvdCwINGF0YDQsNC90LjQu9C40YnQtdGC0L4g0L3QsCBnaXQgPD0gJWQsINCwINC90LUgJWQiCiAKLSM6IHNldHVwLmM6NTQ4CisjOiBzZXR1cC5jOjU0OQogbXNnaWQgInVua25vd24gcmVwb3NpdG9yeSBleHRlbnNpb25zIGZvdW5kOiIKIG1zZ3N0ciAi0L7RgtC60YDQuNGC0Lgg0YHQsCDQvdC10L/QvtC30L3QsNGC0Lgg0YDQsNC30YjQuNGA0LXQvdC40Y8g0LIg0YXRgNCw0L3QuNC70LjRidC10YLQvjoiCiAKLSM6IHNldHVwLmM6NTY3CisjOiBzZXR1cC5jOjU2OAogIywgYy1mb3JtYXQKIG1zZ2lkICJlcnJvciBvcGVuaW5nICclcyciCiBtc2dzdHIgIuKAniVz4oCcINC90LUg0LzQvtC20LUg0LTQsCDRgdC1INC+0YLQstC+0YDQuCIKIAotIzogc2V0dXAuYzo1NjkKKyM6IHNldHVwLmM6NTcwCiAjLCBjLWZvcm1hdAogbXNnaWQgInRvbyBsYXJnZSB0byBiZSBhIC5naXQgZmlsZTogJyVzJyIKIG1zZ3N0ciAi0L/RgNC10LrQsNC70LXQvdC+INCz0L7Qu9GP0Lwg0YTQsNC50Lsg4oCeLmdpdOKAnDog4oCeJXPigJwiCiAKLSM6IHNldHVwLmM6NTcxCisjOiBzZXR1cC5jOjU3MgogIywgYy1mb3JtYXQKIG1zZ2lkICJlcnJvciByZWFkaW5nICVzIgogbXNnc3RyICLQs9GA0LXRiNC60LAg0L/RgNC4INC/0YDQvtGH0LjRgtCw0L3QtSDQvdCwIOKAniVz4oCcIgogCi0jOiBzZXR1cC5jOjU3MworIzogc2V0dXAuYzo1NzQKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBnaXRmaWxlIGZvcm1hdDogJXMiCiBtc2dzdHIgItC90LXQv9GA0LDQstC40LvQtdC9INGE0L7RgNC80LDRgiDQvdCwIGdpdGZpbGU6ICVzIgogCi0jOiBzZXR1cC5jOjU3NQorIzogc2V0dXAuYzo1NzYKICMsIGMtZm9ybWF0CiBtc2dpZCAibm8gcGF0aCBpbiBnaXRmaWxlOiAlcyIKIG1zZ3N0ciAi0LvQuNC/0YHQstCwINC/0YrRgiDQsiBnaXRmaWxlOiDigJ4lc+KAnCIKIAotIzogc2V0dXAuYzo1NzcKKyM6IHNldHVwLmM6NTc4CiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vdCBhIGdpdCByZXBvc2l0b3J5OiAlcyIKIG1zZ3N0ciAi0L3QtSDQtSDRhdGA0LDQvdC40LvQuNGJ0LUg0L3QsCBHaXQ6ICVzIgogCi0jOiBzZXR1cC5jOjY3NgorIzogc2V0dXAuYzo2NzcKICMsIGMtZm9ybWF0CiBtc2dpZCAiJyQlcycgdG9vIGJpZyIKIG1zZ3N0ciAi4oCeJXPigJwg0LUg0L/RgNC10LrQsNC70LXQvdC+INCz0L7Qu9GP0LwiCiAKLSM6IHNldHVwLmM6NjkwCisjOiBzZXR1cC5jOjY5MQogIywgYy1mb3JtYXQKIG1zZ2lkICJub3QgYSBnaXQgcmVwb3NpdG9yeTogJyVzJyIKIG1zZ3N0ciAi0L3QtSDQtSDRhdGA0LDQvdC40LvQuNGJ0LUg0L3QsCBnaXQ6IOKAniVz4oCcIgogCi0jOiBzZXR1cC5jOjcxOSBzZXR1cC5jOjcyMSBzZXR1cC5jOjc1MgorIzogc2V0dXAuYzo3MjAgc2V0dXAuYzo3MjIgc2V0dXAuYzo3NTMKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IGNoZGlyIHRvICclcyciCiBtc2dzdHIgItC90LUg0LzQvtC20LUg0LTQsCDRgdC1INCy0LvQtdC30LUg0LIg0LTQuNGA0LXQutGC0L7RgNC40Y/RgtCwIOKAniVz4oCcIgogCi0jOiBzZXR1cC5jOjcyNCBzZXR1cC5jOjc4MCBzZXR1cC5jOjc5MCBzZXR1cC5jOjgyOSBzZXR1cC5jOjgzNworIzogc2V0dXAuYzo3MjUgc2V0dXAuYzo3ODEgc2V0dXAuYzo3OTEgc2V0dXAuYzo4MzAgc2V0dXAuYzo4MzgKIG1zZ2lkICJjYW5ub3QgY29tZSBiYWNrIHRvIGN3ZCIKIG1zZ3N0ciAi0L/RgNC+0YbQtdGB0YrRgiDQvdC1INC80L7QttC1INC00LAg0YHQtSDQstGK0YDQvdC1INC60YrQvCDQv9GA0LXQtNC40YjQvdCw0YLQsCDRgNCw0LHQvtGC0L3QsCDQtNC40YDQtdC60YLQvtGA0LjRjyIKIAotIzogc2V0dXAuYzo4NTEKKyM6IHNldHVwLmM6ODUyCiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBzdGF0ICclKnMlcyVzJyIKIG1zZ3N0ciAi0L3QtSDQvNC+0LbQtSDQtNCwINCx0YrQtNC1INC/0L7Qu9GD0YfQtdC90LAg0LjQvdGE0L7RgNC80LDRhtC40Y8g0YfRgNC10Lcg4oCec3RhdOKAnCDQt9CwIOKAniUqcyVzJXPigJwiCiAKLSM6IHNldHVwLmM6MTA4MworIzogc2V0dXAuYzoxMDkwCiBtc2dpZCAiVW5hYmxlIHRvIHJlYWQgY3VycmVudCB3b3JraW5nIGRpcmVjdG9yeSIKIG1zZ3N0ciAi0KLQtdC60YPRidCw0YLQsCDRgNCw0LHQvtGC0L3QsCDQtNC40YDQtdC60YLQvtGA0LjRjyDQvdC1INC80L7QttC1INC00LAg0LHRitC00LUg0L/RgNC+0YfQtdGC0LXQvdCwIgogCi0jOiBzZXR1cC5jOjEwOTIgc2V0dXAuYzoxMDk4CisjOiBzZXR1cC5jOjEwOTkgc2V0dXAuYzoxMTA1CiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCBjaGFuZ2UgdG8gJyVzJyIKIG1zZ3N0ciAi0L3QtSDQvNC+0LbQtSDQtNCwINGB0LUg0LLQu9C10LfQtSDQsiDQtNC40YDQtdC60YLQvtGA0LjRj9GC0LAg4oCeJXPigJwiCiAKLSM6IHNldHVwLmM6MTEwMworIzogc2V0dXAuYzoxMTEwCiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vdCBhIGdpdCByZXBvc2l0b3J5IChvciBhbnkgb2YgdGhlIHBhcmVudCBkaXJlY3Rvcmllcyk6ICVzIgogbXNnc3RyICIiCiAi0L3QuNGC0L4g0YLQsNC30LgsINC90LjRgtC+INC60L7Rj9GC0L4g0Lgg0LTQsCDQtSDQvtGCINC/0L4t0LPQvtGA0L3QuNGC0LUg0LTQuNGA0LXQutGC0L7RgNC40LgsINC90LUg0LUg0YXRgNCw0L3QuNC70LjRidC1INC90LAgIgogImdpdDogJXMiCiAKLSM6IHNldHVwLmM6MTEwOQorIzogc2V0dXAuYzoxMTE2CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJub3QgYSBnaXQgcmVwb3NpdG9yeSAob3IgYW55IHBhcmVudCB1cCB0byBtb3VudCBwb2ludCAlcylcbiIKQEAgLTcwNTYsNyArNzA4Miw3IEBACiAiR2l0INGA0LDQsdC+0YLQuCDQsiDRgNCw0LzQutC40YLQtSDQvdCwINC10LTQvdCwINGE0LDQudC70L7QstCwINGB0LjRgdGC0LXQvNCwLCDQt9Cw0YnQvtGC0L4g0L/RgNC+0LzQtdC90LvQuNCy0LDRgtCwINC90LAg0YHRgNC10LTQsNGC0LAgIgogIuKAnkdJVF9ESVNDT1ZFUllfQUNST1NTX0ZJTEVTWVNURU3igJwg0L3QtSDQtSDQt9Cw0LTQsNC00LXQvdCwLiIKIAotIzogc2V0dXAuYzoxMjIwCisjOiBzZXR1cC5jOjEyMjcKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogInByb2JsZW0gd2l0aCBjb3JlLnNoYXJlZFJlcG9zaXRvcnkgZmlsZW1vZGUgdmFsdWUgKDAlLjNvKS5cbiIKQEAgLTcwNjYsMjkxICs3MDkyLDI5MSBAQAogIigwJS4zbykuXG4iCiAi0KHQvtCx0YHRgtCy0LXQvdC40LrRitGCINC90LAg0YTQsNC50LvQsCDRgtGA0Y/QsdCy0LAg0LTQsCDQuNC80LAg0L/RgNCw0LLQsCDQt9CwINC/0LjRgdCw0L3QtSDQuCDRh9C10YLQtdC90LUuIgogCi0jOiBzZXR1cC5jOjEyNjQKKyM6IHNldHVwLmM6MTI3MQogbXNnaWQgIm9wZW4gL2Rldi9udWxsIG9yIGR1cCBmYWlsZWQiCiBtc2dzdHIgItC90LXRg9GB0L/QtdGI0L3QviDQuNC30L/RitC70L3QtdC90LjQtSDQvdCwIOKAnm9wZW7igJwg0LjQu9C4IOKAnmR1cOKAnCDQstGK0YDRhdGDIOKAni9kZXYvbnVsbOKAnCIKIAotIzogc2V0dXAuYzoxMjc5CisjOiBzZXR1cC5jOjEyODYKIG1zZ2lkICJmb3JrIGZhaWxlZCIKIG1zZ3N0ciAi0L3QtdGD0YHQv9C10YjQvdC+INGB0YrQt9C00LDQstCw0L3QtSDQvdCwINC/0YDQvtGG0LXRgSDRh9GA0LXQtyDigJ5mb3Jr4oCcIgogCi0jOiBzZXR1cC5jOjEyODQKKyM6IHNldHVwLmM6MTI5MQogbXNnaWQgInNldHNpZCBmYWlsZWQiCiBtc2dzdHIgItC90LXRg9GB0L/QtdGI0L3QviDQuNC30L/RitC70L3QtdC90LjQtSDQvdCwIOKAnnNldHNpZOKAnCIKIAotIzogc2hhMS1maWxlLmM6NDUzCisjOiBzaGExLWZpbGUuYzo0NTIKICMsIGMtZm9ybWF0CiBtc2dpZCAib2JqZWN0IGRpcmVjdG9yeSAlcyBkb2VzIG5vdCBleGlzdDsgY2hlY2sgLmdpdC9vYmplY3RzL2luZm8vYWx0ZXJuYXRlcyIKIG1zZ3N0ciAiIgogItC00LjRgNC10LrRgtC+0YDQuNGP0YLQsCDQt9CwINC+0LHQtdC60YLQuCDigJ4lc+KAnCDQvdC1INGB0YrRidC10YHRgtCy0YPQstCwLCDQv9GA0L7QstC10YDQtdGC0LUg4oCeLmdpdC9vYmplY3RzL2luZm8vIgogImFsdGVybmF0ZXPigJwiCiAKLSM6IHNoYTEtZmlsZS5jOjUwNAorIzogc2hhMS1maWxlLmM6NTAzCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBub3JtYWxpemUgYWx0ZXJuYXRlIG9iamVjdCBwYXRoOiAlcyIKIG1zZ3N0ciAi0LDQu9GC0LXRgNC90LDRgtC40LLQvdC40Y/RgiDQv9GK0YIg0LrRitC8INC+0LHQtdC60YLQuCDQvdC1INC80L7QttC1INC00LAg0LHRitC00LUg0L3QvtGA0LzQsNC70LjQt9C40YDQsNC9OiDigJ4lc+KAnCIKIAotIzogc2hhMS1maWxlLmM6NTc2CisjOiBzaGExLWZpbGUuYzo1NzUKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXM6IGlnbm9yaW5nIGFsdGVybmF0ZSBvYmplY3Qgc3RvcmVzLCBuZXN0aW5nIHRvbyBkZWVwIgogbXNnc3RyICIiCiAiJXM6INCw0LvRgtC10YDQvdCw0YLQuNCy0L3QuNGC0LUg0YXRgNCw0L3QuNC70LjRidCwINC30LAg0L7QsdC10LrRgtC4INGB0LUg0L/RgNC10L3QtdCx0YDQtdCz0LLQsNGCINC/0L7RgNCw0LTQuCDQv9GA0LXQutCw0LvQtdC90L4gIgogItC00YrQu9Cx0L7QutC+INCy0LvQsNCz0LDQvdC1IgogCi0jOiBzaGExLWZpbGUuYzo1ODMKKyM6IHNoYTEtZmlsZS5jOjU4MgogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gbm9ybWFsaXplIG9iamVjdCBkaXJlY3Rvcnk6ICVzIgogbXNnc3RyICLQtNC40YDQtdC60YLQvtGA0LjRj9GC0LAg0LfQsCDQvtCx0LXQutGC0Lgg4oCeJXPigJwg0L3QtSDQvNC+0LbQtSDQtNCwINCx0YrQtNC1INC90L7RgNC80LDQu9C40LfQuNGA0LDQvdCwIgogCi0jOiBzaGExLWZpbGUuYzo2MjYKKyM6IHNoYTEtZmlsZS5jOjYyNQogbXNnaWQgInVuYWJsZSB0byBmZG9wZW4gYWx0ZXJuYXRlcyBsb2NrZmlsZSIKIG1zZ3N0ciAi0LfQsNC60LvRjtGH0LLQsNGJ0LjRj9GCINGE0LDQudC7INC30LAg0LDQu9GC0LXRgNC90LDRgtC40LLQuNGC0LUg0L3QtSDQvNC+0LbQtSDQtNCwINGB0LUg0L7RgtCy0L7RgNC4INGBIOKAnmZkb3BlbuKAnCIKIAotIzogc2hhMS1maWxlLmM6NjQ0CisjOiBzaGExLWZpbGUuYzo2NDMKIG1zZ2lkICJ1bmFibGUgdG8gcmVhZCBhbHRlcm5hdGVzIGZpbGUiCiBtc2dzdHIgItGE0LDQudC70YrRgiDRgSDQsNC70YLQtdGA0L3QsNGC0LjQstC40YLQtSDQvdC1INC80L7QttC1INC00LAg0LHRitC00LUg0L/RgNC+0YfQtdGC0LXQvSIKIAotIzogc2hhMS1maWxlLmM6NjUxCisjOiBzaGExLWZpbGUuYzo2NTAKIG1zZ2lkICJ1bmFibGUgdG8gbW92ZSBuZXcgYWx0ZXJuYXRlcyBmaWxlIGludG8gcGxhY2UiCiBtc2dzdHIgItC90L7QstC40Y/RgiDRhNCw0LnQuyDRgSDQsNC70YLQtdGA0L3QsNGC0LjQstC40YLQtSDQvdC1INC80L7QttC1INC00LAg0LHRitC00LUg0L/RgNC10LzQtdGB0YLQtdC9INC90LAg0LzRj9GB0YLQvtGC0L4g0LzRgyIKIAotIzogc2hhMS1maWxlLmM6Njg2CisjOiBzaGExLWZpbGUuYzo2ODUKICMsIGMtZm9ybWF0CiBtc2dpZCAicGF0aCAnJXMnIGRvZXMgbm90IGV4aXN0IgogbXNnc3RyICLQv9GK0YLRj9GCIOKAniVz4oCcINC90LUg0YHRitGJ0LXRgdGC0LLRg9Cy0LAuIgogCi0jOiBzaGExLWZpbGUuYzo3MTIKKyM6IHNoYTEtZmlsZS5jOjcxMQogIywgYy1mb3JtYXQKIG1zZ2lkICJyZWZlcmVuY2UgcmVwb3NpdG9yeSAnJXMnIGFzIGEgbGlua2VkIGNoZWNrb3V0IGlzIG5vdCBzdXBwb3J0ZWQgeWV0LiIKIG1zZ3N0ciAi0LLRgdC1INC+0YnQtSDQvdC1INGB0LUg0L/QvtC00LTRitGA0LbQsCDQtdGC0LDQu9C+0L3QvdC+INGF0YDQsNC90LjQu9C40YnQtSDigJ4lc+KAnCDQutCw0YLQviDRgdCy0YrRgNC30LDQvdC+LiIKIAotIzogc2hhMS1maWxlLmM6NzE4CisjOiBzaGExLWZpbGUuYzo3MTcKICMsIGMtZm9ybWF0CiBtc2dpZCAicmVmZXJlbmNlIHJlcG9zaXRvcnkgJyVzJyBpcyBub3QgYSBsb2NhbCByZXBvc2l0b3J5LiIKIG1zZ3N0ciAi0LXRgtCw0LvQvtC90L3QvtGC0L4g0YXRgNCw0L3QuNC70LjRidC1IOKAniVz4oCcINC90LUg0LUg0LvQvtC60LDQu9C90L4iCiAKLSM6IHNoYTEtZmlsZS5jOjcyNAorIzogc2hhMS1maWxlLmM6NzIzCiAjLCBjLWZvcm1hdAogbXNnaWQgInJlZmVyZW5jZSByZXBvc2l0b3J5ICclcycgaXMgc2hhbGxvdyIKIG1zZ3N0ciAi0LXRgtCw0LvQvtC90L3QvtGC0L4g0YXRgNCw0L3QuNC70LjRidC1IOKAniVz4oCcINC1INC/0LvQuNGC0LrQviIKIAotIzogc2hhMS1maWxlLmM6NzMyCisjOiBzaGExLWZpbGUuYzo3MzEKICMsIGMtZm9ybWF0CiBtc2dpZCAicmVmZXJlbmNlIHJlcG9zaXRvcnkgJyVzJyBpcyBncmFmdGVkIgogbXNnc3RyICLQtdGC0LDQu9C+0L3QvdC+0YLQviDRhdGA0LDQvdC40LvQuNGJ0LUg4oCeJXPigJwg0LUg0YEg0L/RgNC40YHQsNC20LTQsNC90LUiCiAKLSM6IHNoYTEtZmlsZS5jOjc5MgorIzogc2hhMS1maWxlLmM6NzkxCiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgbGluZSB3aGlsZSBwYXJzaW5nIGFsdGVybmF0ZSByZWZzOiAlcyIKIG1zZ3N0ciAi0L3QtdC/0YDQsNCy0LjQu9C10L0g0YDQtdC0INC/0YDQuCDQsNC90LDQu9C40LfQsCDQvdCwINCw0LvRgtC10YDQvdCw0YLQuNCy0L3QuNGC0LUg0YPQutCw0LfQsNGC0LXQu9C4OiDigJ4lc+KAnCIKIAotIzogc2hhMS1maWxlLmM6OTQ0CisjOiBzaGExLWZpbGUuYzo5NDMKICMsIGMtZm9ybWF0CiBtc2dpZCAiYXR0ZW1wdGluZyB0byBtbWFwICU8UFJJdU1BWD4gb3ZlciBsaW1pdCAlPFBSSXVNQVg+IgogbXNnc3RyICIiCiAi0L3QtdGD0YHQv9C10YjQtdC9INC+0L/QuNGCINC30LAg4oCebW1hcOKAnCAlPFBSSXVNQVg+LCDQutC+0LXRgtC+INC1INC90LDQtCDQv9C+0LfQstC+0LvQtdC90L7RgtC+ICU8UFJJdU1BWD4iCiAKLSM6IHNoYTEtZmlsZS5jOjk2OQorIzogc2hhMS1maWxlLmM6OTY0CiBtc2dpZCAibW1hcCBmYWlsZWQiCiBtc2dzdHIgItC90LXRg9GB0L/QtdGI0L3QviDQuNC30L/RitC70L3QtdC90LjQtSDQvdCwIOKAnm1tYXDigJwiCiAKLSM6IHNoYTEtZmlsZS5jOjExMzMKKyM6IHNoYTEtZmlsZS5jOjExMjgKICMsIGMtZm9ybWF0CiBtc2dpZCAib2JqZWN0IGZpbGUgJXMgaXMgZW1wdHkiCiBtc2dzdHIgItGE0LDQudC70YrRgiDRgSDQvtCx0LXQutGC0LjRgtC1IOKAniVz4oCcINC1INC/0YDQsNC30LXQvSIKIAotIzogc2hhMS1maWxlLmM6MTI1NyBzaGExLWZpbGUuYzoyMzk2CisjOiBzaGExLWZpbGUuYzoxMjUyIHNoYTEtZmlsZS5jOjIzOTIKICMsIGMtZm9ybWF0CiBtc2dpZCAiY29ycnVwdCBsb29zZSBvYmplY3QgJyVzJyIKIG1zZ3N0ciAi0L3QtdC/0LDQutC10YLQuNGA0LDQvdC40Y/RgiDQvtCx0LXQutGCIOKAniVz4oCcINC1INC/0L7QstGA0LXQtNC10L0iCiAKLSM6IHNoYTEtZmlsZS5jOjEyNTkgc2hhMS1maWxlLmM6MjQwMAorIzogc2hhMS1maWxlLmM6MTI1NCBzaGExLWZpbGUuYzoyMzk2CiAjLCBjLWZvcm1hdAogbXNnaWQgImdhcmJhZ2UgYXQgZW5kIG9mIGxvb3NlIG9iamVjdCAnJXMnIgogbXNnc3RyICLQs9GA0LXRiNC90Lgg0LTQsNC90L3QuCDQsiDQutGA0LDRjyDQvdCwINC90LXQv9Cw0LrQtdGC0LjRgNCw0L3QuNGPINC+0LHQtdC60YIg4oCeJXPigJwiCiAKLSM6IHNoYTEtZmlsZS5jOjEzMDEKKyM6IHNoYTEtZmlsZS5jOjEyOTYKIG1zZ2lkICJpbnZhbGlkIG9iamVjdCB0eXBlIgogbXNnc3RyICLQvdC10L/RgNCw0LLQuNC70LXQvSDQstC40LQg0L7QsdC10LrRgiIKIAotIzogc2hhMS1maWxlLmM6MTM4NQorIzogc2hhMS1maWxlLmM6MTM4MAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gdW5wYWNrICVzIGhlYWRlciB3aXRoIC0tYWxsb3ctdW5rbm93bi10eXBlIgogbXNnc3RyICIiCiAi0LfQsNCz0LvQsNCy0L3QsNGC0LAg0YfQsNGB0YIg4oCeJXPigJwg0L3QtSDQvNC+0LbQtSDQtNCwINGB0LUg0YDQsNC30L/QsNC60LXRgtC40YDQsCDRgSDQvtC/0YbQuNGP0YLQsCDigJ4tLWFsbG93LXVua25vd24tIgogInR5cGXigJwiCiAKLSM6IHNoYTEtZmlsZS5jOjEzODgKKyM6IHNoYTEtZmlsZS5jOjEzODMKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHVucGFjayAlcyBoZWFkZXIiCiBtc2dzdHIgItC30LDQs9C70LDQstC90LDRgtCwINGH0LDRgdGCINC90LAg4oCeJXPigJwg0L3QtSDQvNC+0LbQtSDQtNCwINCx0YrQtNC1INGA0LDQt9C/0LDQutC10YLQuNGA0LDQvdCwIgogCi0jOiBzaGExLWZpbGUuYzoxMzk0CisjOiBzaGExLWZpbGUuYzoxMzg5CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBwYXJzZSAlcyBoZWFkZXIgd2l0aCAtLWFsbG93LXVua25vd24tdHlwZSIKIG1zZ3N0ciAiIgogItC30LDQs9C70LDQstC90LDRgtCwINGH0LDRgdGCIOKAniVz4oCcINC90LUg0LzQvtC20LUg0LTQsCDRgdC1INCw0L3QsNC70LjQt9C40YDQsCDRgSDQvtC/0YbQuNGP0YLQsCDigJ4tLWFsbG93LXVua25vd24tdHlwZeKAnCIKIAotIzogc2hhMS1maWxlLmM6MTM5NworIzogc2hhMS1maWxlLmM6MTM5MgogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gcGFyc2UgJXMgaGVhZGVyIgogbXNnc3RyICLQt9Cw0LPQu9Cw0LLQvdCw0YLQsCDRh9Cw0YHRgiDQvdCwIOKAniVz4oCcINC90LUg0LzQvtC20LUg0LTQsCDQsdGK0LTQtSDQsNC90LDQu9C40LfQuNGA0LDQvdCwIgogCi0jOiBzaGExLWZpbGUuYzoxNTg4CisjOiBzaGExLWZpbGUuYzoxNTg0CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byByZWFkIG9iamVjdCAlcyIKIG1zZ3N0ciAi0L7QsdC10LrRgtGK0YIg4oCeJXPigJwg0L3QtSDQvNC+0LbQtSDQtNCwINCx0YrQtNC1INC/0YDQvtGH0LXRgtC10L0iCiAKLSM6IHNoYTEtZmlsZS5jOjE1OTIKKyM6IHNoYTEtZmlsZS5jOjE1ODgKICMsIGMtZm9ybWF0CiBtc2dpZCAicmVwbGFjZW1lbnQgJXMgbm90IGZvdW5kIGZvciAlcyIKIG1zZ3N0ciAi0LfQsNC80LXRgdGC0LjRgtC10LvRj9GCIOKAniVz4oCcINC90LAg4oCeJXPigJwg0L3QtSDQvNC+0LbQtSDQtNCwINCx0YrQtNC1INC+0YLQutGA0LjRgiIKIAotIzogc2hhMS1maWxlLmM6MTU5NgorIzogc2hhMS1maWxlLmM6MTU5MgogIywgYy1mb3JtYXQKIG1zZ2lkICJsb29zZSBvYmplY3QgJXMgKHN0b3JlZCBpbiAlcykgaXMgY29ycnVwdCIKIG1zZ3N0ciAi0L3QtdC/0LDQutC10YLQuNGA0LDQvdC40Y/RgiDQvtCx0LXQutGCIOKAniVz4oCcICjQsiDigJ4lc+KAnCkg0LUg0L/QvtCy0YDQtdC00LXQvSIKIAotIzogc2hhMS1maWxlLmM6MTYwMAorIzogc2hhMS1maWxlLmM6MTU5NgogIywgYy1mb3JtYXQKIG1zZ2lkICJwYWNrZWQgb2JqZWN0ICVzIChzdG9yZWQgaW4gJXMpIGlzIGNvcnJ1cHQiCiBtc2dzdHIgItC/0LDQutC10YLQuNGA0LDQvdC40Y/RgiDQvtCx0LXQutGCIOKAniVz4oCcICjQsiDigJ4lc+KAnCkg0LUg0L/QvtCy0YDQtdC00LXQvSIKIAotIzogc2hhMS1maWxlLmM6MTcwMworIzogc2hhMS1maWxlLmM6MTY5OQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gd3JpdGUgZmlsZSAlcyIKIG1zZ3N0ciAi0YTQsNC50LvRitGCIOKAniVz4oCcINC90LUg0LzQvtC20LUg0LTQsCDQsdGK0LTQtSDQt9Cw0L/QuNGB0LDQvSIKIAotIzogc2hhMS1maWxlLmM6MTcxMAorIzogc2hhMS1maWxlLmM6MTcwNgogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gc2V0IHBlcm1pc3Npb24gdG8gJyVzJyIKIG1zZ3N0ciAi0L/RgNCw0LLQsNGC0LAg0LfQsCDQtNC+0YHRgtGK0L8g0LTQviDigJ4lc+KAnCDQvdC1INC80L7Qs9Cw0YIg0LTQsCDQsdGK0LTQsNGCINC30LDQtNCw0LTQtdC90LgiCiAKLSM6IHNoYTEtZmlsZS5jOjE3MTcKKyM6IHNoYTEtZmlsZS5jOjE3MTMKIG1zZ2lkICJmaWxlIHdyaXRlIGVycm9yIgogbXNnc3RyICLQs9GA0LXRiNC60LAg0L/RgNC4INC30LDQv9C40YEg0L3QsCDRhNCw0LnQuyIKIAotIzogc2hhMS1maWxlLmM6MTczNgorIzogc2hhMS1maWxlLmM6MTczMgogbXNnaWQgImVycm9yIHdoZW4gY2xvc2luZyBsb29zZSBvYmplY3QgZmlsZSIKIG1zZ3N0ciAi0LPRgNC10YjQutCwINC/0YDQuCDQt9Cw0YLQstCw0YDRj9C90LXRgtC+INC90LAg0YTQsNC50LvQsCDRgSDQvdC10L/QsNC60LXRgtC40YDQsNC9INC+0LHQtdC60YIiCiAKLSM6IHNoYTEtZmlsZS5jOjE4MDEKKyM6IHNoYTEtZmlsZS5jOjE3OTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW5zdWZmaWNpZW50IHBlcm1pc3Npb24gZm9yIGFkZGluZyBhbiBvYmplY3QgdG8gcmVwb3NpdG9yeSBkYXRhYmFzZSAlcyIKIG1zZ3N0ciAiIgogItC90Y/QvNCwINC/0YDQsNCy0LAg0LfQsCDQtNC+0LHQsNCy0Y/QvdC1INC90LAg0L7QsdC10LrRgiDQutGK0Lwg0LHQsNC30LDRgtCwINC+0YIg0LTQsNC90L3QuCDQvdCwINGF0YDQsNC90LjQu9C40YnQtdGC0L4g4oCeJXPigJwiCiAKLSM6IHNoYTEtZmlsZS5jOjE4MDMKKyM6IHNoYTEtZmlsZS5jOjE3OTkKIG1zZ2lkICJ1bmFibGUgdG8gY3JlYXRlIHRlbXBvcmFyeSBmaWxlIgogbXNnc3RyICLQvdC1INC80L7QttC1INC00LAg0LHRitC00LUg0YHRitC30LTQsNC00LXQvSDQstGA0LXQvNC10L3QtdC9INGE0LDQudC7IgogCi0jOiBzaGExLWZpbGUuYzoxODI3CisjOiBzaGExLWZpbGUuYzoxODIzCiBtc2dpZCAidW5hYmxlIHRvIHdyaXRlIGxvb3NlIG9iamVjdCBmaWxlIgogbXNnc3RyICLQs9GA0LXRiNC60LAg0L/RgNC4INC30LDQv9C40YHQsCDQvdCwINGE0LDQudC70LAg0YEg0L3QtdC/0LDQutC10YLQuNGA0LDQvSDQvtCx0LXQutGCIgogCi0jOiBzaGExLWZpbGUuYzoxODMzCisjOiBzaGExLWZpbGUuYzoxODI5CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBkZWZsYXRlIG5ldyBvYmplY3QgJXMgKCVkKSIKIG1zZ3N0ciAi0L3QvtCy0LjRj9GCINC+0LHQtdC60YIg4oCeJXPigJwg0L3QtSDQvNC+0LbQtSDQtNCwINGB0LUg0LrQvtC80L/RgNC10YHQuNGA0LAg0YEg4oCeZGVmbGF0ZeKAnDogJWQiCiAKLSM6IHNoYTEtZmlsZS5jOjE4MzcKKyM6IHNoYTEtZmlsZS5jOjE4MzMKICMsIGMtZm9ybWF0CiBtc2dpZCAiZGVmbGF0ZUVuZCBvbiBvYmplY3QgJXMgZmFpbGVkICglZCkiCiBtc2dzdHIgItC90LXRg9GB0L/QtdGI0L3QviDQv9GA0LjQutC70Y7Rh9Cy0LDQvdC1INC90LAg4oCeZGVmbGF0ZeKAnCDQstGK0YDRhdGDIOKAniVz4oCcOiAlZCIKIAotIzogc2hhMS1maWxlLmM6MTg0MQorIzogc2hhMS1maWxlLmM6MTgzNwogIywgYy1mb3JtYXQKIG1zZ2lkICJjb25mdXNlZCBieSB1bnN0YWJsZSBvYmplY3Qgc291cmNlIGRhdGEgZm9yICVzIgogbXNnc3RyICLQs9GA0LXRiNC60LAg0L/QvtGA0LDQtNC4INC90LXRgdGC0LDQsdC40LvQvdC40Y8g0LjQt9GC0L7Rh9C90LjQuiDQtNCw0L3QvdC4INC30LAg0L7QsdC10LrRgtC40YLQtSDigJ4lc+KAnCIKIAotIzogc2hhMS1maWxlLmM6MTg1MSBidWlsdGluL3BhY2stb2JqZWN0cy5jOjkyNQorIzogc2hhMS1maWxlLmM6MTg0NyBidWlsdGluL3BhY2stb2JqZWN0cy5jOjkyNQogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdXRpbWUoKSBvbiAlcyIKIG1zZ3N0ciAi0L3QtdGD0YHQv9C10YjQvdC+INC30LDQtNCw0LLQsNC90LUg0L3QsCDQstGA0LXQvNC1INC90LAg0LTQvtGB0YLRitC/L9GB0YrQt9C00LDQstCw0L3QtSDRh9GA0LXQtyDigJ51dGltZeKAnCDQvdCwIOKAniVz4oCcIgogCi0jOiBzaGExLWZpbGUuYzoxOTI2CisjOiBzaGExLWZpbGUuYzoxOTIyCiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCByZWFkIG9iamVjdCBmb3IgJXMiCiBtc2dzdHIgItC+0LHQtdC60YLRitGCINC30LAg4oCeJXPigJwg0L3QtSDQvNC+0LbQtSDQtNCwINGB0LUg0L/RgNC+0YfQtdGC0LUiCiAKLSM6IHNoYTEtZmlsZS5jOjE5NjYKKyM6IHNoYTEtZmlsZS5jOjE5NjIKIG1zZ2lkICJjb3JydXB0IGNvbW1pdCIKIG1zZ3N0ciAi0L/QvtCy0YDQtdC00LXQvdC+INC/0L7QtNCw0LLQsNC90LUiCiAKLSM6IHNoYTEtZmlsZS5jOjE5NzQKKyM6IHNoYTEtZmlsZS5jOjE5NzAKIG1zZ2lkICJjb3JydXB0IHRhZyIKIG1zZ3N0ciAi0L/QvtCy0YDQtdC00LXQvSDQtdGC0LjQutC10YIiCiAKLSM6IHNoYTEtZmlsZS5jOjIwNzMKKyM6IHNoYTEtZmlsZS5jOjIwNjkKICMsIGMtZm9ybWF0CiBtc2dpZCAicmVhZCBlcnJvciB3aGlsZSBpbmRleGluZyAlcyIKIG1zZ3N0ciAi0LPRgNC10YjQutCwINC/0YDQuCDRh9C10YLQtdC90LUg0L/QviDQstGA0LXQvNC1INC90LAg0LjQvdC00LXQutGB0LjRgNCw0L3QtSDQvdCwIOKAniVz4oCcIgogCi0jOiBzaGExLWZpbGUuYzoyMDc2CisjOiBzaGExLWZpbGUuYzoyMDcyCiAjLCBjLWZvcm1hdAogbXNnaWQgInNob3J0IHJlYWQgd2hpbGUgaW5kZXhpbmcgJXMiCiBtc2dzdHIgItC90LXQv9GK0LvQvdC+INC/0YDQvtGH0LjRgtCw0L3QtSDQv9C+INCy0YDQtdC80LUg0L3QsCDQuNC90LTQtdC60YHQuNGA0LDQvdC1INC90LAg4oCeJXPigJwiCiAKLSM6IHNoYTEtZmlsZS5jOjIxNDkgc2hhMS1maWxlLmM6MjE1OAorIzogc2hhMS1maWxlLmM6MjE0NSBzaGExLWZpbGUuYzoyMTU0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiBmYWlsZWQgdG8gaW5zZXJ0IGludG8gZGF0YWJhc2UiCiBtc2dzdHIgIuKAniVz4oCcINC90LUg0LzQvtC20LUg0LTQsCDRgdC1INCy0LzRitC60L3QtSDQsiDQsdCw0LfQsNGC0LAg0L7RgiDQtNCw0L3QvdC4IgogCi0jOiBzaGExLWZpbGUuYzoyMTY0CisjOiBzaGExLWZpbGUuYzoyMTYwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiB1bnN1cHBvcnRlZCBmaWxlIHR5cGUiCiBtc2dzdHIgItC90LXQv9C+0LTQtNGK0YDQttCw0L0g0LLQuNC0INGE0LDQudC7OiDigJ4lc+KAnCIKIAotIzogc2hhMS1maWxlLmM6MjE4OAorIzogc2hhMS1maWxlLmM6MjE4NAogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyBpcyBub3QgYSB2YWxpZCBvYmplY3QiCiBtc2dzdHIgIuKAniVz4oCcINC1INC90LXQv9GA0LDQstC40LvQtdC9INC+0LHQtdC60YIiCiAKLSM6IHNoYTEtZmlsZS5jOjIxOTAKKyM6IHNoYTEtZmlsZS5jOjIxODYKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgaXMgbm90IGEgdmFsaWQgJyVzJyBvYmplY3QiCiBtc2dzdHIgIuKAniVz4oCcINC1INC90LXQv9GA0LDQstC40LvQtdC9INC+0LHQtdC60YIg0L7RgiDQstC40LQg4oCeJXPigJwiCiAKLSM6IHNoYTEtZmlsZS5jOjIyMTcgYnVpbHRpbi9pbmRleC1wYWNrLmM6MTU1CisjOiBzaGExLWZpbGUuYzoyMjEzIGJ1aWx0aW4vaW5kZXgtcGFjay5jOjE1NQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gb3BlbiAlcyIKIG1zZ3N0ciAi0L7QsdC10LrRgtGK0YIg4oCeJXPigJwg0L3QtSDQvNC+0LbQtSDQtNCwINCx0YrQtNC1INC+0YLQstC+0YDQtdC9IgogCi0jOiBzaGExLWZpbGUuYzoyNDA3IHNoYTEtZmlsZS5jOjI0NTkKKyM6IHNoYTEtZmlsZS5jOjI0MDMgc2hhMS1maWxlLmM6MjQ1NQogIywgYy1mb3JtYXQKIG1zZ2lkICJoYXNoIG1pc21hdGNoIGZvciAlcyAoZXhwZWN0ZWQgJXMpIgogbXNnc3RyICLQvdC10L/RgNCw0LLQuNC70L3QsCDQutC+0L3RgtGA0L7Qu9C90LAg0YHRg9C80LAg0LfQsCDigJ4lc+KAnCAo0YLRgNGP0LHQstCwINC00LAg0LUgJXMpIgogCi0jOiBzaGExLWZpbGUuYzoyNDMxCisjOiBzaGExLWZpbGUuYzoyNDI3CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBtbWFwICVzIgogbXNnc3RyICLQvdC10YPRgdC/0LXRiNC90L4g0LjQt9C/0YrQu9C90LXQvdC40LUg0L3QsCDigJ5tbWFw4oCcINCy0YrRgNGF0YMg4oCeJXPigJwiCiAKLSM6IHNoYTEtZmlsZS5jOjI0MzYKKyM6IHNoYTEtZmlsZS5jOjI0MzIKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHVucGFjayBoZWFkZXIgb2YgJXMiCiBtc2dzdHIgItC30LDQs9C70LDQstC90LDRgtCwINGH0LDRgdGCINC90LAg4oCeJXPigJwg0L3QtSDQvNC+0LbQtSDQtNCwINCx0YrQtNC1INGA0LDQt9C/0LDQutC10YLQuNGA0LDQvdCwIgogCi0jOiBzaGExLWZpbGUuYzoyNDQyCisjOiBzaGExLWZpbGUuYzoyNDM4CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBwYXJzZSBoZWFkZXIgb2YgJXMiCiBtc2dzdHIgItC30LDQs9C70LDQstC90LDRgtCwINGH0LDRgdGCINC90LAg4oCeJXPigJwg0L3QtSDQvNC+0LbQtSDQtNCwINCx0YrQtNC1INCw0L3QsNC70LjQt9C40YDQsNC90LAiCiAKLSM6IHNoYTEtZmlsZS5jOjI0NTMKKyM6IHNoYTEtZmlsZS5jOjI0NDkKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHVucGFjayBjb250ZW50cyBvZiAlcyIKIG1zZ3N0ciAi0YHRitC00YrRgNC20LDQvdC40LXRgtC+INC90LAg4oCeJXPigJwg0L3QtSDQvNC+0LbQtSDQtNCwINCx0YrQtNC1INGA0LDQt9C/0LDQutC10YLQuNGA0LDQvdC+IgogCi0jOiBzaGExLW5hbWUuYzo0OTAKKyM6IHNoYTEtbmFtZS5jOjQ4NwogIywgYy1mb3JtYXQKIG1zZ2lkICJzaG9ydCBTSEExICVzIGlzIGFtYmlndW91cyIKIG1zZ3N0ciAi0LrRitGB0LjRj9GCIFNIQTEg4oCeJXPigJwg0L3QtSDQtSDQtdC00L3QvtC30L3QsNGH0LXQvSIKIAotIzogc2hhMS1uYW1lLmM6NTAxCisjOiBzaGExLW5hbWUuYzo0OTgKIG1zZ2lkICJUaGUgY2FuZGlkYXRlcyBhcmU6IgogbXNnc3RyICLQktGK0LfQvNC+0LbQvdC+0YHRgtC40YLQtSDRgdCwOiIKIAotIzogc2hhMS1uYW1lLmM6ODAwCisjOiBzaGExLW5hbWUuYzo3OTcKIG1zZ2lkICIiCiAiR2l0IG5vcm1hbGx5IG5ldmVyIGNyZWF0ZXMgYSByZWYgdGhhdCBlbmRzIHdpdGggNDAgaGV4IGNoYXJhY3RlcnNcbiIKICJiZWNhdXNlIGl0IHdpbGwgYmUgaWdub3JlZCB3aGVuIHlvdSBqdXN0IHNwZWNpZnkgNDAtaGV4LiBUaGVzZSByZWZzXG4iCkBAIC03Mzc2LDQzICs3NDAyLDQzIEBACiAiICAgIGdpdCBjb25maWcgYWR2aWNlLm9iamVjdE5hbWVXYXJuaW5nIGZhbHNlIgogCiAjLiBUUkFOU0xBVE9SUzogSUVDIDgwMDAwLTEzOjIwMDggZ2liaWJ5dGUKLSM6IHN0cmJ1Zi5jOjgyMQorIzogc3RyYnVmLmM6ODIyCiAjLCBjLWZvcm1hdAogbXNnaWQgIiV1LiUyLjJ1IEdpQiIKIG1zZ3N0ciAiJXUuJTIuMnUgR2lCIgogCiAjLiBUUkFOU0xBVE9SUzogSUVDIDgwMDAwLTEzOjIwMDggZ2liaWJ5dGUvc2Vjb25kCi0jOiBzdHJidWYuYzo4MjMKKyM6IHN0cmJ1Zi5jOjgyNAogIywgYy1mb3JtYXQKIG1zZ2lkICIldS4lMi4ydSBHaUIvcyIKIG1zZ3N0ciAiJXUuJTIuMnUgR2lCL3MiCiAKICMuIFRSQU5TTEFUT1JTOiBJRUMgODAwMDAtMTM6MjAwOCBtZWJpYnl0ZQotIzogc3RyYnVmLmM6ODMxCisjOiBzdHJidWYuYzo4MzIKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXUuJTIuMnUgTWlCIgogbXNnc3RyICIldS4lMi4ydSBNaUIiCiAKICMuIFRSQU5TTEFUT1JTOiBJRUMgODAwMDAtMTM6MjAwOCBtZWJpYnl0ZS9zZWNvbmQKLSM6IHN0cmJ1Zi5jOjgzMworIzogc3RyYnVmLmM6ODM0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiV1LiUyLjJ1IE1pQi9zIgogbXNnc3RyICIldS4lMi4ydSBNaUIvcyIKIAogIy4gVFJBTlNMQVRPUlM6IElFQyA4MDAwMC0xMzoyMDA4IGtpYmlieXRlCi0jOiBzdHJidWYuYzo4NDAKKyM6IHN0cmJ1Zi5jOjg0MQogIywgYy1mb3JtYXQKIG1zZ2lkICIldS4lMi4ydSBLaUIiCiBtc2dzdHIgIiV1LiUyLjJ1IEtpQiIKIAogIy4gVFJBTlNMQVRPUlM6IElFQyA4MDAwMC0xMzoyMDA4IGtpYmlieXRlL3NlY29uZAotIzogc3RyYnVmLmM6ODQyCisjOiBzdHJidWYuYzo4NDMKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXUuJTIuMnUgS2lCL3MiCiBtc2dzdHIgIiV1LiUyLjJ1IEtpQi9zIgogCiAjLiBUUkFOU0xBVE9SUzogSUVDIDgwMDAwLTEzOjIwMDggYnl0ZQotIzogc3RyYnVmLmM6ODQ4CisjOiBzdHJidWYuYzo4NDkKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXUgYnl0ZSIKIG1zZ2lkX3BsdXJhbCAiJXUgYnl0ZXMiCkBAIC03NDIwLDcgKzc0NDYsNyBAQAogbXNnc3RyWzFdICIldSDQsdCw0LnRgtCwIgogCiAjLiBUUkFOU0xBVE9SUzogSUVDIDgwMDAwLTEzOjIwMDggYnl0ZS9zZWNvbmQKLSM6IHN0cmJ1Zi5jOjg1MAorIzogc3RyYnVmLmM6ODUxCiAjLCBjLWZvcm1hdAogbXNnaWQgIiV1IGJ5dGUvcyIKIG1zZ2lkX3BsdXJhbCAiJXUgYnl0ZXMvcyIKQEAgLTc1MzksMjggKzc1NjUsMjggQEAKIG1zZ2lkICJscy10cmVlIHJldHVybmVkIHVuZXhwZWN0ZWQgcmV0dXJuIGNvZGUgJWQiCiBtc2dzdHIgIuKAnmxzLXRyZWXigJwg0LfQsNCy0YrRgNGI0Lgg0YEg0L3QtdC+0YfQsNC60LLQsNC9INC40LfRhdC+0LTQtdC9INC60L7QtDogJWQiCiAKLSM6IHN1Ym1vZHVsZS1jb25maWcuYzoyMzIKKyM6IHN1Ym1vZHVsZS1jb25maWcuYzoyMzYKICMsIGMtZm9ybWF0CiBtc2dpZCAiaWdub3Jpbmcgc3VzcGljaW91cyBzdWJtb2R1bGUgbmFtZTogJXMiCiBtc2dzdHIgItC40LPQvdC+0YDQuNGA0LDQvdC1INC90LAg0L/QvtC00L7Qt9GA0LjRgtC10LvQvdC+INC40LzQtSDQvdCwINC/0L7QtNC80L7QtNGD0Ls6IOKAniVz4oCcIgogCi0jOiBzdWJtb2R1bGUtY29uZmlnLmM6Mjk5CisjOiBzdWJtb2R1bGUtY29uZmlnLmM6MzAzCiBtc2dpZCAibmVnYXRpdmUgdmFsdWVzIG5vdCBhbGxvd2VkIGZvciBzdWJtb2R1bGUuZmV0Y2hqb2JzIgogbXNnc3RyICLQvdCw0YHRgtGA0L7QudC60LDRgtCwIOKAnnN1Ym1vZHVsZS5mZXRjaGpvYnPigJwg0L3QtSDQv9GA0LjQtdC80LAg0L7RgtGA0LjRhtCw0YLQtdC70L3QuCDRgdGC0L7QudC90L7RgdGC0LgiCiAKLSM6IHN1Ym1vZHVsZS1jb25maWcuYzozOTcKKyM6IHN1Ym1vZHVsZS1jb25maWcuYzo0MDEKICMsIGMtZm9ybWF0CiBtc2dpZCAiaWdub3JpbmcgJyVzJyB3aGljaCBtYXkgYmUgaW50ZXJwcmV0ZWQgYXMgYSBjb21tYW5kLWxpbmUgb3B0aW9uOiAlcyIKIG1zZ3N0ciAiIgogIuKAniVz4oCcINGB0LUg0L/RgNC10YHQutCw0YfQsCwg0LfQsNGJ0L7RgtC+INC1INCy0YrQt9C80L7QttC90L4g0LTQsCDRgdC1INGC0YrQu9C60YPQstCwINC60LDRgtC+INC+0L/RhtC40Y8g0LfQsCDQutC+0LzQsNC90LTQvdC40Y8gIgogItGA0LXQtDogJXMiCiAKLSM6IHN1Ym1vZHVsZS1jb25maWcuYzo0ODYKKyM6IHN1Ym1vZHVsZS1jb25maWcuYzo0OTAKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCB2YWx1ZSBmb3IgJXMiCiBtc2dzdHIgItCd0LXQv9GA0LDQstC40LvQvdCwINGB0YLQvtC50L3QvtGB0YIg0LfQsCDigJ4lc+KAnCIKIAotIzogc3VibW9kdWxlLWNvbmZpZy5jOjc1NQorIzogc3VibW9kdWxlLWNvbmZpZy5jOjc2MQogIywgYy1mb3JtYXQKIG1zZ2lkICJDb3VsZCBub3QgdXBkYXRlIC5naXRtb2R1bGVzIGVudHJ5ICVzIgogbXNnc3RyICLQl9Cw0L/QuNGB0YrRgiDigJ4lc+KAnCDQstGK0LIg0YTQsNC50LvQsCDigJ4uZ2l0bW9kdWxlc+KAnCDQvdC1INC80L7QttC1INC00LAg0LHRitC00LUg0L/RgNC+0LzQtdC90LXQvSIKQEAgLTc1OTUsNyArNzYyMSw3IEBACiBtc2dpZCAiY291bGQgbm90IHJlYWQgZnJvbSBzdGRpbiIKIG1zZ3N0ciAi0L7RgiDRgdGC0LDQvdC00LDRgNGC0L3QuNGPINCy0YXQvtC0INC90LUg0LzQvtC20LUg0LTQsCDRgdC1INGH0LXRgtC1IgogCi0jOiB0cmFpbGVyLmM6MTAxMSB3cmFwcGVyLmM6NzAxCisjOiB0cmFpbGVyLmM6MTAxMSB3cmFwcGVyLmM6NjY1CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBzdGF0ICVzIgogbXNnc3RyICLQndC1INC80L7QttC1INC00LAg0YHQtSDQv9C+0LvRg9GH0Lgg0LjQvdGE0L7RgNC80LDRhtC40Y8g0YfRgNC10Lcg4oCec3RhdOKAnCDQt9CwIOKAniVz4oCcIgpAQCAtNzYyNCw0OCArNzY1MCw0OCBAQAogbXNnaWQgIldvdWxkIHNldCB1cHN0cmVhbSBvZiAnJXMnIHRvICclcycgb2YgJyVzJ1xuIgogbXNnc3RyICLQmtC70L7QvdGK0YIg4oCeJXPigJwg0YnQtSDRgdC70LXQtNC4IOKAniVz4oCcINC+0YIg4oCeJXPigJxcbiIKIAotIzogdHJhbnNwb3J0LmM6MTQyCisjOiB0cmFuc3BvcnQuYzoxNDUKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHJlYWQgYnVuZGxlICclcyciCiBtc2dzdHIgItC/0YDQsNGC0LrQsNGC0LAg0L3QsCBnaXQg4oCeJXPigJwg0L3QtSDQvNC+0LbQtSDQtNCwINCx0YrQtNC1INC/0YDQvtGH0LXRgtC10L3QsCIKIAotIzogdHJhbnNwb3J0LmM6MjA4CisjOiB0cmFuc3BvcnQuYzoyMTQKICMsIGMtZm9ybWF0CiBtc2dpZCAidHJhbnNwb3J0OiBpbnZhbGlkIGRlcHRoIG9wdGlvbiAnJXMnIgogbXNnc3RyICJ0cmFuc3BvcnQ6INC90LXQv9GA0LDQstC40LvQvdCwINC+0L/RhtC40Y8g0LfQsCDQtNGK0LvQsdC+0YfQuNC90LA6ICVzIgogCi0jOiB0cmFuc3BvcnQuYzoyNTkKKyM6IHRyYW5zcG9ydC5jOjI2NgogbXNnaWQgInNlZSBwcm90b2NvbC52ZXJzaW9uIGluICdnaXQgaGVscCBjb25maWcnIGZvciBtb3JlIGRldGFpbHMiCiBtc2dzdHIgIiIKICLQl9CwINC/0L7QstC10YfQtSDQuNC90YTQvtGA0LzQsNGG0LjRjyDQstC40LbRgtC1INGA0LDQt9C00LXQu9CwIOKAnnByb3RvY29sLnZlcnNpb27igJwg0LIg4oCeZ2l0IGhlbHAgY29uZmln4oCcIgogCi0jOiB0cmFuc3BvcnQuYzoyNjAKKyM6IHRyYW5zcG9ydC5jOjI2NwogbXNnaWQgInNlcnZlciBvcHRpb25zIHJlcXVpcmUgcHJvdG9jb2wgdmVyc2lvbiAyIG9yIGxhdGVyIgogbXNnc3RyICLQvtC/0YbQuNC40YLQtSDQvdCwINGB0YrRgNCy0YrRgNCwINC40LfQuNGB0LrQstCw0YIg0L/QvtC90LUg0LLQtdGA0YHQuNGPIDIg0L3QsCDQv9GA0L7RgtC+0LrQvtC70LAiCiAKLSM6IHRyYW5zcG9ydC5jOjYyNQorIzogdHJhbnNwb3J0LmM6NjMyCiBtc2dpZCAiY291bGQgbm90IHBhcnNlIHRyYW5zcG9ydC5jb2xvci4qIGNvbmZpZyIKIG1zZ3N0ciAi0YHRgtC+0LnQvdC+0YHRgtGC0LAg0L3QsCDQvdCw0YHRgtGA0L7QudC60LDRgtCwIOKAnnRyYW5zcG9ydC5jb2xvci4q4oCcINC90LUg0LzQvtC20LUg0LTQsCDRgdC1INGA0LDQt9C/0L7Qt9C90LDQtSIKIAotIzogdHJhbnNwb3J0LmM6Njk4CisjOiB0cmFuc3BvcnQuYzo3MDUKIG1zZ2lkICJzdXBwb3J0IGZvciBwcm90b2NvbCB2MiBub3QgaW1wbGVtZW50ZWQgeWV0IgogbXNnc3RyICLQv9GA0L7RgtC+0LrQvtC7INCy0LXRgNGB0LjRjyAyINCy0YHQtSDQvtGJ0LUg0L3QtSDRgdC1INC/0L7QtNC00YrRgNC20LAiCiAKLSM6IHRyYW5zcG9ydC5jOjgyNQorIzogdHJhbnNwb3J0LmM6ODMxCiAjLCBjLWZvcm1hdAogbXNnaWQgInVua25vd24gdmFsdWUgZm9yIGNvbmZpZyAnJXMnOiAlcyIKIG1zZ3N0ciAi0L3QtdC/0L7Qt9C90LDRgtCwINGB0YLQvtC50L3QvtGB0YIg0LfQsCDQvdCw0YHRgtGA0L7QudC60LDRgtCwIOKAniVz4oCcOiDigJ4lc+KAnCIKIAotIzogdHJhbnNwb3J0LmM6ODkxCisjOiB0cmFuc3BvcnQuYzo4OTcKICMsIGMtZm9ybWF0CiBtc2dpZCAidHJhbnNwb3J0ICclcycgbm90IGFsbG93ZWQiCiBtc2dzdHIgItC/0YDQtdC90L7RgdGK0YIg0L/QviDigJ4lc+KAnCDQvdC1INC1INC/0L7Qt9Cy0L7Qu9C10L0iCiAKLSM6IHRyYW5zcG9ydC5jOjk0NQorIzogdHJhbnNwb3J0LmM6OTQ5CiBtc2dpZCAiZ2l0LW92ZXItcnN5bmMgaXMgbm8gbG9uZ2VyIHN1cHBvcnRlZCIKIG1zZ3N0ciAi0LrQvtC80LDQvdC00LDRgtCwIOKAnmdpdC1vdmVyLXJzeW5j4oCcINCy0LXRh9C1INC90LUg0YHQtSDQv9C+0LTQtNGK0YDQttCwIgogCi0jOiB0cmFuc3BvcnQuYzoxMDQwCisjOiB0cmFuc3BvcnQuYzoxMDQ0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgZm9sbG93aW5nIHN1Ym1vZHVsZSBwYXRocyBjb250YWluIGNoYW5nZXMgdGhhdCBjYW5cbiIKQEAgLTc2NzQsNyArNzcwMCw3IEBACiAi0KHQu9C10LTQvdC40YLQtSDQv9GK0YLQuNGJ0LAg0LfQsCDQv9C+0LTQvNC+0LTRg9C70Lgg0YHRitC00YrRgNC20LDRgiDQv9GA0L7QvNC10L3QuCxcbiIKICLQutC+0LjRgtC+INC70LjQv9GB0LLQsNGCINC+0YIg0LLRgdC40YfQutC4INC+0YLQtNCw0LvQtdGH0LXQvdC4INGF0YDQsNC90LjQu9C40YnQsDpcbiIKIAotIzogdHJhbnNwb3J0LmM6MTA0NAorIzogdHJhbnNwb3J0LmM6MTA0OAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiXG4iCkBAIC03Njk5LDM0ICs3NzI1LDM0IEBACiAiICAgIGdpdCBwdXNoXG4iCiAiXG4iCiAKLSM6IHRyYW5zcG9ydC5jOjEwNTIKKyM6IHRyYW5zcG9ydC5jOjEwNTYKIG1zZ2lkICJBYm9ydGluZy4iCiBtc2dzdHIgItCf0YDQtdGD0YHRgtCw0L3QvtCy0Y/QstCw0L3QtSDQvdCwINC00LXQudGB0YLQstC40LXRgtC+LiIKIAotIzogdHJhbnNwb3J0LmM6MTE5MworIzogdHJhbnNwb3J0LmM6MTIwMQogbXNnaWQgImZhaWxlZCB0byBwdXNoIGFsbCBuZWVkZWQgc3VibW9kdWxlcyIKIG1zZ3N0ciAi0L3QtdGD0YHQv9C10YjQvdC+INC40LfRgtC70LDRgdC60LLQsNC90LUg0L3QsCDQstGB0LjRh9C60Lgg0L3QtdC+0LHRhdC+0LTQuNC80Lgg0L/QvtC00LzQvtC00YPQu9C4IgogCi0jOiB0cmFuc3BvcnQuYzoxMzQwIHRyYW5zcG9ydC1oZWxwZXIuYzo2NDUKKyM6IHRyYW5zcG9ydC5jOjEzNDUgdHJhbnNwb3J0LWhlbHBlci5jOjY1NQogbXNnaWQgIm9wZXJhdGlvbiBub3Qgc3VwcG9ydGVkIGJ5IHByb3RvY29sIgogbXNnc3RyICLQvtC/0YbQuNGP0YLQsCDQvdC1INGB0LUg0L/QvtC00LTRitGA0LbQsCDQvtGCINC/0YDQvtGC0L7QutC+0LvQsCIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjUxIHRyYW5zcG9ydC1oZWxwZXIuYzo4MAorIzogdHJhbnNwb3J0LWhlbHBlci5jOjYxIHRyYW5zcG9ydC1oZWxwZXIuYzo5MAogbXNnaWQgImZ1bGwgd3JpdGUgdG8gcmVtb3RlIGhlbHBlciBmYWlsZWQiCiBtc2dzdHIgItC90LXRg9GB0L/QtdGI0LXQvSDQv9GK0LvQtdC9INC30LDQv9C40YEg0LrRitC8INC90LDRgdGA0LXRidC90LDRgtCwINC/0L7QvNC+0YnQvdCwINC/0YDQvtCz0YDQsNC80LAiCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxMzQKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxNDQKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGZpbmQgcmVtb3RlIGhlbHBlciBmb3IgJyVzJyIKIG1zZ3N0ciAi0L3QsNGB0YDQtdGJ0L3QsNGC0LAg0L/QvtC80L7RidC90LAg0L/RgNC+0LPRgNCw0LzQsCDQt9CwIOKAniVz4oCcINC90LUg0LzQvtC20LUg0LTQsCDQsdGK0LTQtSDQvtGC0LrRgNC40YLQsCIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjE1MCB0cmFuc3BvcnQtaGVscGVyLmM6NTU5CisjOiB0cmFuc3BvcnQtaGVscGVyLmM6MTYwIHRyYW5zcG9ydC1oZWxwZXIuYzo1NjkKIG1zZ2lkICJjYW4ndCBkdXAgaGVscGVyIG91dHB1dCBmZCIKIG1zZ3N0ciAiIgogItGE0LDQudC70L7QstC40Y/RgiDQtNC10YHQutGA0LjQv9GC0L7RgCDQvtGCINC90LDRgdGA0LXRidC90LDRgtCwINC/0L7QvNC+0YnQvdCwINC/0YDQvtCz0YDQsNC80LAg0L3QtSDQvNC+0LbQtSDQtNCwINGB0LUg0LTRg9Cx0LvQuNGA0LAg0YEgIgogIuKAnmR1cOKAnCIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjIwMQorIzogdHJhbnNwb3J0LWhlbHBlci5jOjIxMQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAidW5rbm93biBtYW5kYXRvcnkgY2FwYWJpbGl0eSAlczsgdGhpcyByZW1vdGUgaGVscGVyIHByb2JhYmx5IG5lZWRzIG5ld2VyICIKQEAgLTc3MzUsMTA2ICs3NzYxLDExMSBAQAogItC90LXQv9C+0LfQvdCw0YLQsCDQt9Cw0LTRitC70LbQuNGC0LXQu9C90LAg0YHQv9C+0YHQvtCx0L3QvtGB0YIg4oCeJXPigJwuICDQndCw0YHRgNC10YnQvdCw0YLQsCDQv9C+0LzQvtGJ0L3QsCDQv9GA0L7Qs9GA0LDQvNCwICIKICLQstC10YDQvtGP0YLQvdC+INC40LfQuNGB0LrQstCwINC90L7QstCwINCy0LXRgNGB0LjRjyDQvdCwIEdpdCIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjIwNworIzogdHJhbnNwb3J0LWhlbHBlci5jOjIxNwogbXNnaWQgInRoaXMgcmVtb3RlIGhlbHBlciBzaG91bGQgaW1wbGVtZW50IHJlZnNwZWMgY2FwYWJpbGl0eSIKIG1zZ3N0ciAiIgogItC90LDRgdGA0LXRidC90LDRgtCwINC/0L7QvNC+0YnQvdCwINC/0YDQvtCz0YDQsNC80LAg0YLRgNGP0LHQstCwINC00LAg0L/QvtC00LTRitGA0LbQsCDRgdC/0L7RgdC+0LHQvdC+0YHRgiDQt9CwINC40LfQsdGA0L7Rj9Cy0LDQvdC1INC90LAgIgogItGD0LrQsNC30LDRgtC10LvQuCIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjI3NCB0cmFuc3BvcnQtaGVscGVyLmM6NDE0CisjOiB0cmFuc3BvcnQtaGVscGVyLmM6Mjg0IHRyYW5zcG9ydC1oZWxwZXIuYzo0MjQKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgdW5leHBlY3RlZGx5IHNhaWQ6ICclcyciCiBtc2dzdHIgIuKAniVz4oCcINC90LXQvtGH0LDQutCy0LDQvdC+INCy0YrRgNC90LA6IOKAniVz4oCcIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6NDAzCisjOiB0cmFuc3BvcnQtaGVscGVyLmM6NDEzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIGFsc28gbG9ja2VkICVzIgogbXNnc3RyICLigJ4lc+KAnCDQt9Cw0LrQu9GO0YfQuCDQuCDigJ4lc+KAnCIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjQ4MQorIzogdHJhbnNwb3J0LWhlbHBlci5jOjQ5MQogbXNnaWQgImNvdWxkbid0IHJ1biBmYXN0LWltcG9ydCIKIG1zZ3N0ciAi0L3QtdGD0YHQv9C10YjQvdC+INC40LfQv9GK0LvQvdC10L3QuNC1INC90LAg0LHRitGA0LfQviDQstC90LDRgdGP0L3QtSIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjUwNAorIzogdHJhbnNwb3J0LWhlbHBlci5jOjUxNAogbXNnaWQgImVycm9yIHdoaWxlIHJ1bm5pbmcgZmFzdC1pbXBvcnQiCiBtc2dzdHIgItCz0YDQtdGI0LrQsCDQv9GA0Lgg0LjQt9C/0YrQu9C90LXQvdC40LXRgtC+INC90LAg0LHRitGA0LfQviDQstC90LDRgdGP0L3QtSIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjUzMyB0cmFuc3BvcnQtaGVscGVyLmM6MTEwNQorIzogdHJhbnNwb3J0LWhlbHBlci5jOjU0MyB0cmFuc3BvcnQtaGVscGVyLmM6MTEzMgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcmVhZCByZWYgJXMiCiBtc2dzdHIgItGD0LrQsNC30LDRgtC10LvRj9GCIOKAniVz4oCcINC90LUg0LzQvtC20LUg0LTQsCDRgdC1INC/0YDQvtGH0LXRgtC1IgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6NTc4CisjOiB0cmFuc3BvcnQtaGVscGVyLmM6NTg4CiAjLCBjLWZvcm1hdAogbXNnaWQgInVua25vd24gcmVzcG9uc2UgdG8gY29ubmVjdDogJXMiCiBtc2dzdHIgItC90LXQvtGH0LDQutCy0LDQvSDQvtGC0LPQvtCy0L7RgCDQv9GA0Lgg0YHQstGK0YDQt9Cy0LDQvdC1OiDigJ4lc+KAnCIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjYwMAorIzogdHJhbnNwb3J0LWhlbHBlci5jOjYxMAogbXNnaWQgInNldHRpbmcgcmVtb3RlIHNlcnZpY2UgcGF0aCBub3Qgc3VwcG9ydGVkIGJ5IHByb3RvY29sIgogbXNnc3RyICLQv9GA0L7RgtC+0LrQvtC70YrRgiDQvdC1INC/0L7QtNC00YrRgNC20LAg0LfQsNC00LDQstCw0L3QtdGC0L4g0L3QsCDQv9GK0YIg0L3QsCDQvtGC0LTQsNC70LXRh9C10L3QsNGC0LAg0YPRgdC70YPQs9CwIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6NjAyCisjOiB0cmFuc3BvcnQtaGVscGVyLmM6NjEyCiBtc2dpZCAiaW52YWxpZCByZW1vdGUgc2VydmljZSBwYXRoIgogbXNnc3RyICLQvdC10L/RgNCw0LLQuNC70LXQvSDQv9GK0YIg0L3QsCDQvtGC0LTQsNC70LXRh9C10L3QsNGC0LAg0YPRgdC70YPQs9CwIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6NjQ4CisjOiB0cmFuc3BvcnQtaGVscGVyLmM6NjU4CiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbid0IGNvbm5lY3QgdG8gc3Vic2VydmljZSAlcyIKIG1zZ3N0ciAi0L3QtdGD0YHQv9C10YjQvdC+INGB0LLRitGA0LfQstCw0L3QtSDQutGK0Lwg0L/QvtC00YPRgdC70YPQs9Cw0YLQsCDigJ4lc+KAnCIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjcyMAorIzogdHJhbnNwb3J0LWhlbHBlci5jOjczNAogIywgYy1mb3JtYXQKIG1zZ2lkICJleHBlY3RlZCBvay9lcnJvciwgaGVscGVyIHNhaWQgJyVzJyIKIG1zZ3N0ciAiIgogItC+0YfQsNC60LLQsCDRgdC1INC40LvQuCDRg9GB0L/QtdGFLCDQuNC70Lgg0LPRgNC10YjQutCwLCDQvdC+INC90LDRgdGA0LXRidC90LDRgtCwINC/0L7QvNC+0YnQvdCwINC/0YDQvtCz0YDQsNC80LAg0LLRitGA0L3QsCDigJ4lc+KAnCIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjc3MworIzogdHJhbnNwb3J0LWhlbHBlci5jOjc4NwogIywgYy1mb3JtYXQKIG1zZ2lkICJoZWxwZXIgcmVwb3J0ZWQgdW5leHBlY3RlZCBzdGF0dXMgb2YgJXMiCiBtc2dzdHIgItC90LDRgdGA0LXRidC90LDRgtCwINC/0L7QvNC+0YnQvdCwINC/0YDQvtCz0YDQsNC80LAg0LfQsNCy0YrRgNGI0Lgg0YEg0L3QtdC+0YfQsNC60LLQsNC9INC40LfRhdC+0LTQtdC9INC60L7QtDog4oCeJXPigJwiCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzo4MzQKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzo4NDgKICMsIGMtZm9ybWF0CiBtc2dpZCAiaGVscGVyICVzIGRvZXMgbm90IHN1cHBvcnQgZHJ5LXJ1biIKIG1zZ3N0ciAi0L3QsNGB0YDQtdGJ0L3QsNGC0LAg0L/QvtC80L7RidC90LAg0L/RgNC+0LPRgNCw0LzQsCDigJ4lc+KAnCDQvdC1INC/0L7QtNC00YrRgNC20LAg0L/RgNC+0LHQuCDigJ5kcnktcnVu4oCcIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6ODM3CisjOiB0cmFuc3BvcnQtaGVscGVyLmM6ODUxCiAjLCBjLWZvcm1hdAogbXNnaWQgImhlbHBlciAlcyBkb2VzIG5vdCBzdXBwb3J0IC0tc2lnbmVkIgogbXNnc3RyICLQvdCw0YHRgNC10YnQvdCw0YLQsCDQv9C+0LzQvtGJ0L3QsCDQv9GA0L7Qs9GA0LDQvNCwIOKAniVz4oCcINC90LUg0L/QvtC00LTRitGA0LbQsCDQvtC/0YbQuNGP0YLQsCDigJ4tLXNpZ25lZOKAnCIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjg0MAorIzogdHJhbnNwb3J0LWhlbHBlci5jOjg1NAogIywgYy1mb3JtYXQKIG1zZ2lkICJoZWxwZXIgJXMgZG9lcyBub3Qgc3VwcG9ydCAtLXNpZ25lZD1pZi1hc2tlZCIKIG1zZ3N0ciAiIgogItC90LDRgdGA0LXRidC90LDRgtCwINC/0L7QvNC+0YnQvdCwINC/0YDQvtCz0YDQsNC80LAg4oCeJXPigJwg0L3QtSDQv9C+0LTQtNGK0YDQttCwINC+0L/RhtC40Y/RgtCwIOKAni0tc2lnbmVkPWlmLWFza2Vk4oCcIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6ODQ3CisjOiB0cmFuc3BvcnQtaGVscGVyLmM6ODU5CisjLCBjLWZvcm1hdAorbXNnaWQgImhlbHBlciAlcyBkb2VzIG5vdCBzdXBwb3J0IC0tYXRvbWljIgorbXNnc3RyICLQvdCw0YHRgNC10YnQvdCw0YLQsCDQv9C+0LzQvtGJ0L3QsCDQv9GA0L7Qs9GA0LDQvNCwIOKAniVz4oCcINC90LUg0L/QvtC00LTRitGA0LbQsCDQvtC/0YbQuNGP0YLQsCDigJ4tLWF0b21pY+KAnCIKKworIzogdHJhbnNwb3J0LWhlbHBlci5jOjg2NQogIywgYy1mb3JtYXQKIG1zZ2lkICJoZWxwZXIgJXMgZG9lcyBub3Qgc3VwcG9ydCAncHVzaC1vcHRpb24nIgogbXNnc3RyICLQvdCw0YHRgNC10YnQvdCw0YLQsCDQv9C+0LzQvtGJ0L3QsCDQv9GA0L7Qs9GA0LDQvNCwIOKAniVz4oCcINC90LUg0L/QvtC00LTRitGA0LbQsCDQvtC/0YbQuNC4INC30LAg0LjQt9GC0LvQsNGB0LrQstCw0L3QtSIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjk0NQorIzogdHJhbnNwb3J0LWhlbHBlci5jOjk2MwogbXNnaWQgInJlbW90ZS1oZWxwZXIgZG9lc24ndCBzdXBwb3J0IHB1c2g7IHJlZnNwZWMgbmVlZGVkIgogbXNnc3RyICIiCiAi0L3QsNGB0YDQtdGJ0L3QsNGC0LAg0L/QvtC80L7RidC90LAg0L/RgNC+0LPRgNCw0LzQsCDQvdC1INC/0L7QtNC00YrRgNC20LAg0LjQt9GC0LvQsNGB0LrQstCw0L3QtS4gINCd0LXQvtCx0YXQvtC00LjQvNC+INC1ICIKICLQuNC30LHRgNC+0Y/QstCw0L3QtSDQvdCwINGD0LrQsNC30LDRgtC10LvQuNGC0LUiCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzo5NTAKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzo5NjgKICMsIGMtZm9ybWF0CiBtc2dpZCAiaGVscGVyICVzIGRvZXMgbm90IHN1cHBvcnQgJ2ZvcmNlJyIKIG1zZ3N0ciAiIgogItC90LDRgdGA0LXRidC90LDRgtCwINC/0L7QvNC+0YnQvdCwINC/0YDQvtCz0YDQsNC80LAg0L3QtSDQv9C+0LTQtNGK0YDQttCwIOKAniVz4oCcINC/0L7QtNC00YrRgNC20LAg0L7Qv9GG0LjRj9GC0LAg4oCeLS1mb3JjZeKAnCIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjk5NworIzogdHJhbnNwb3J0LWhlbHBlci5jOjEwMTUKIG1zZ2lkICJjb3VsZG4ndCBydW4gZmFzdC1leHBvcnQiCiBtc2dzdHIgItC90LUg0LzQvtC20LUg0LTQsCDRgdC1INC40LfQstGK0YDRiNC4INCx0YrRgNC30L4g0LjQt9C90LDRgdGP0L3QtSIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjEwMDIKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxMDIwCiBtc2dpZCAiZXJyb3Igd2hpbGUgcnVubmluZyBmYXN0LWV4cG9ydCIKIG1zZ3N0ciAi0LPRgNC10YjQutCwINC/0YDQuCDQuNC30L/RitC70L3QtdC90LjQtdGC0L4g0L3QsCDQutC+0LzQsNC90LTQsNGC0LAg0LfQsCDQsdGK0YDQt9C+INC40LfQvdCw0YHRj9C90LUiCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxMDI3CisjOiB0cmFuc3BvcnQtaGVscGVyLmM6MTA0NQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiTm8gcmVmcyBpbiBjb21tb24gYW5kIG5vbmUgc3BlY2lmaWVkOyBkb2luZyBub3RoaW5nLlxuIgpAQCAtNzg0Myw0NyArNzg3NCw0NyBAQAogItCd0Y/QvNCwINC+0LHRidC4INGD0LrQsNC30LDRgtC10LvQuCwg0L3QtSDRgdCwINGD0LrQsNC30LDQvdC4INC90LjQutCw0LrQstC4INGD0LrQsNC30LDRgtC10LvQuCDigJQg0L3QuNGJ0L4g0L3Rj9C80LAg0LTQsCDQsdGK0LTQtVxuIgogItC90LDQv9GA0LDQstC10L3Qvi4gINCf0YDQvtCx0LLQsNC50YLQtSDQtNCwINGD0LrQsNC20LXRgtC1INC60LvQvtC9LCDQvdCw0L/RgC4g4oCcbWFzdGVy4oCcLlxuIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6MTA5MQorIzogdHJhbnNwb3J0LWhlbHBlci5jOjExMTgKICMsIGMtZm9ybWF0CiBtc2dpZCAibWFsZm9ybWVkIHJlc3BvbnNlIGluIHJlZiBsaXN0OiAlcyIKIG1zZ3N0ciAi0L3QtdC/0YDQsNCy0LjQu9C10L0g0L7RgtCz0L7QstC+0YAg0LIg0YHQv9C40YHRitC60LAg0YEg0YPQutCw0LfQsNGC0LXQu9C4OiDigJ4lc+KAnCIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjEyNDQKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxMjcwCiAjLCBjLWZvcm1hdAogbXNnaWQgInJlYWQoJXMpIGZhaWxlZCIKIG1zZ3N0ciAi0L3QtdGD0YHQv9C10YjQvdC+INGH0LXRgtC10L3QtSDQvdCwIOKAniVz4oCcIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6MTI3MQorIzogdHJhbnNwb3J0LWhlbHBlci5jOjEyOTcKICMsIGMtZm9ybWF0CiBtc2dpZCAid3JpdGUoJXMpIGZhaWxlZCIKIG1zZ3N0ciAi0L3QtdGD0YHQv9C10YjQtdC9INC30LDQv9C40YEg0LIg4oCeJXPigJwiCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxMzIwCisjOiB0cmFuc3BvcnQtaGVscGVyLmM6MTM0NgogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyB0aHJlYWQgZmFpbGVkIgogbXNnc3RyICLQvdC10YPRgdC/0LXRiNC90L4g0LjQt9C/0YrQu9C90LXQvdC40LUg0L3QsCDQvdC40YjQutCw0YLQsCDigJ4lc+KAnCIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjEzMjQKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxMzUwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIHRocmVhZCBmYWlsZWQgdG8gam9pbjogJXMiCiBtc2dzdHIgItC30LDQstGK0YDRiNCy0LDQvdC10YLQviDQvdCwINC90LjRiNC60LDRgtCwIOKAniVz4oCcINC90LUg0LzQvtC20LUg0LTQsCDRgdC1INC40LfRh9Cw0LrQsDog4oCeJXPigJwiCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxMzQzIHRyYW5zcG9ydC1oZWxwZXIuYzoxMzQ3CisjOiB0cmFuc3BvcnQtaGVscGVyLmM6MTM2OSB0cmFuc3BvcnQtaGVscGVyLmM6MTM3MwogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW4ndCBzdGFydCB0aHJlYWQgZm9yIGNvcHlpbmcgZGF0YTogJXMiCiBtc2dzdHIgItC90LXRg9GB0L/QtdGI0L3QviDRgdGC0LDRgNGC0LjRgNCw0L3QtSDQvdCwINC90LjRiNC60LAg0LfQsCDQutC+0L/QuNGA0LDQvdC1INC90LAg0LTQsNC90L3QuNGC0LU6IOKAniVz4oCcIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6MTM4NAorIzogdHJhbnNwb3J0LWhlbHBlci5jOjE0MTAKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgcHJvY2VzcyBmYWlsZWQgdG8gd2FpdCIKIG1zZ3N0ciAi0L/RgNC+0YbQtdGB0YrRgiDQvdCwIOKAniVz4oCcINC90LUg0YPRgdC/0Y8g0LTQsCDQuNC30YfQsNC60LAg0YfRgNC10Lcg4oCed2FpdHBpZOKAnCIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjEzODgKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxNDE0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIHByb2Nlc3MgZmFpbGVkIgogbXNnc3RyICLQvdC10YPRgdC/0LXRiNC90L4g0LjQt9C/0YrQu9C90LXQvdC40LUg0L3QsCDigJ4lc+KAnCIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjE0MDYgdHJhbnNwb3J0LWhlbHBlci5jOjE0MTUKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxNDMyIHRyYW5zcG9ydC1oZWxwZXIuYzoxNDQxCiBtc2dpZCAiY2FuJ3Qgc3RhcnQgdGhyZWFkIGZvciBjb3B5aW5nIGRhdGEiCiBtc2dzdHIgItC90LXRg9GB0L/QtdGI0L3QviDRgdGC0LDRgNGC0LjRgNCw0L3QtSDQvdCwINC90LjRiNC60LAg0LfQsCDQutC+0L/QuNGA0LDQvdC1INC90LAg0LTQsNC90L3QuNGC0LUiCiAKQEAgLTc5MDMsNyArNzkzNCw3IEBACiBtc2dpZCAidG9vLXNob3J0IHRyZWUgZmlsZSIKIG1zZ3N0ciAi0L/RgNC10LrQsNC70LXQvdC+INC60YDQsNGC0YrQuiDRhNCw0LnQuy3QtNGK0YDQstC+IgogCi0jOiB1bnBhY2stdHJlZXMuYzoxMTEKKyM6IHVucGFjay10cmVlcy5jOjExMAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiWW91ciBsb2NhbCBjaGFuZ2VzIHRvIHRoZSBmb2xsb3dpbmcgZmlsZXMgd291bGQgYmUgb3ZlcndyaXR0ZW4gYnkgY2hlY2tvdXQ6XG4iCkBAIC03OTEyLDcgKzc5NDMsNyBAQAogItCY0LfRgtC10LPQu9GP0L3QtdGC0L4g0YnQtSDQv9GA0LXQt9Cw0L/QuNGI0LUg0LvQvtC60LDQu9C90LjRgtC1INC/0YDQvtC80LXQvdC4INC90LAg0YLQtdC30Lgg0YTQsNC50LvQvtCy0LU6XG4iCiAiJSVz0J/QvtC00LDQudGC0LUg0LjQu9C4INGB0LrQsNGC0LDQudGC0LUg0L/RgNC+0LzQtdC90LjRgtC1LCDQt9CwINC00LAg0L/RgNC10LzQuNC90LXRgtC1INC60YrQvCDQvdC+0LIg0LrQu9C+0L0uIgogCi0jOiB1bnBhY2stdHJlZXMuYzoxMTMKKyM6IHVucGFjay10cmVlcy5jOjExMgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiWW91ciBsb2NhbCBjaGFuZ2VzIHRvIHRoZSBmb2xsb3dpbmcgZmlsZXMgd291bGQgYmUgb3ZlcndyaXR0ZW4gYnkgY2hlY2tvdXQ6XG4iCkBAIC03OTIxLDcgKzc5NTIsNyBAQAogItCY0LfRgtC10LPQu9GP0L3QtdGC0L4g0YnQtSDQv9GA0LXQt9Cw0L/QuNGI0LUg0LvQvtC60LDQu9C90LjRgtC1INC/0YDQvtC80LXQvdC4INC90LAg0YLQtdC30Lgg0YTQsNC50LvQvtCy0LU6XG4iCiAiJSVzIgogCi0jOiB1bnBhY2stdHJlZXMuYzoxMTYKKyM6IHVucGFjay10cmVlcy5jOjExNQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiWW91ciBsb2NhbCBjaGFuZ2VzIHRvIHRoZSBmb2xsb3dpbmcgZmlsZXMgd291bGQgYmUgb3ZlcndyaXR0ZW4gYnkgbWVyZ2U6XG4iCkBAIC03OTMwLDcgKzc5NjEsNyBAQAogItCh0LvQuNCy0LDQvdC10YLQviDRidC1INC/0YDQtdC30LDQv9C40YjQtSDQu9C+0LrQsNC70L3QuNGC0LUg0L/RgNC+0LzQtdC90Lgg0L3QsCDRgtC10LfQuCDRhNCw0LnQu9C+0LLQtTpcbiIKICIlJXPQn9C+0LTQsNC50YLQtSDQuNC70Lgg0YHQutCw0YLQsNC50YLQtSDQv9GA0L7QvNC10L3QuNGC0LUsINC30LAg0LTQsCDRgdC70LXQtdGC0LUuIgogCi0jOiB1bnBhY2stdHJlZXMuYzoxMTgKKyM6IHVucGFjay10cmVlcy5jOjExNwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiWW91ciBsb2NhbCBjaGFuZ2VzIHRvIHRoZSBmb2xsb3dpbmcgZmlsZXMgd291bGQgYmUgb3ZlcndyaXR0ZW4gYnkgbWVyZ2U6XG4iCkBAIC03OTM5LDcgKzc5NzAsNyBAQAogItCh0LvQuNCy0LDQvdC10YLQviDRidC1INC/0YDQtdC30LDQv9C40YjQtSDQu9C+0LrQsNC70L3QuNGC0LUg0L/RgNC+0LzQtdC90Lgg0L3QsCDRgtC10LfQuCDRhNCw0LnQu9C+0LLQtTpcbiIKICIlJXMiCiAKLSM6IHVucGFjay10cmVlcy5jOjEyMQorIzogdW5wYWNrLXRyZWVzLmM6MTIwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJZb3VyIGxvY2FsIGNoYW5nZXMgdG8gdGhlIGZvbGxvd2luZyBmaWxlcyB3b3VsZCBiZSBvdmVyd3JpdHRlbiBieSAlczpcbiIKQEAgLTc5NDgsNyArNzk3OSw3IEBACiAi4oCeJXPigJwg0YnQtSDQv9GA0LXQt9Cw0L/QuNGI0LUg0LvQvtC60LDQu9C90LjRgtC1INC/0YDQvtC80LXQvdC4INC90LAg0YLQtdC30Lgg0YTQsNC50LvQvtCy0LU6XG4iCiAiJSVz0J/QvtC00LDQudGC0LUg0LjQu9C4INGB0LrQsNGC0LDQudGC0LUg0L/RgNC+0LzQtdC90LjRgtC1LCDQt9CwINC00LAg0LjQt9Cy0YrRgNGI0LjRgtC1IOKAniVz4oCcLiIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTIzCisjOiB1bnBhY2stdHJlZXMuYzoxMjIKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIllvdXIgbG9jYWwgY2hhbmdlcyB0byB0aGUgZm9sbG93aW5nIGZpbGVzIHdvdWxkIGJlIG92ZXJ3cml0dGVuIGJ5ICVzOlxuIgpAQCAtNzk1Nyw3ICs3OTg4LDcgQEAKICLigJ4lc+KAnCDRidC1INC/0YDQtdC30LDQv9C40YjQtSDQu9C+0LrQsNC70L3QuNGC0LUg0L/RgNC+0LzQtdC90Lgg0L3QsCDRgtC10LfQuCDRhNCw0LnQu9C+0LLQtTpcbiIKICIlJXMiCiAKLSM6IHVucGFjay10cmVlcy5jOjEyOAorIzogdW5wYWNrLXRyZWVzLmM6MTI3CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJVcGRhdGluZyB0aGUgZm9sbG93aW5nIGRpcmVjdG9yaWVzIHdvdWxkIGxvc2UgdW50cmFja2VkIGZpbGVzIGluIHRoZW06XG4iCkBAIC03OTY2LDcgKzc5OTcsNyBAQAogItCe0LHQvdC+0LLRj9Cy0LDQvdC10YLQviDQvdCwINGB0LvQtdC00L3QuNGC0LUg0LTQuNGA0LXQutGC0L7RgNC40Lgg0YnQtSDQuNC30YLRgNC40LUg0L3QtdGB0LvQtdC00LXQvdC40YLQtSDRhNCw0LnQu9C+0LLQtSDQsiDRgtGP0YU6XG4iCiAiJXMiCiAKLSM6IHVucGFjay10cmVlcy5jOjEzMgorIzogdW5wYWNrLXRyZWVzLmM6MTMxCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgZm9sbG93aW5nIHVudHJhY2tlZCB3b3JraW5nIHRyZWUgZmlsZXMgd291bGQgYmUgcmVtb3ZlZCBieSBjaGVja291dDpcbiIKQEAgLTc5NzUsNyArODAwNiw3IEBACiAi0JjQt9GC0LXQs9C70Y/QvdC10YLQviDRidC1INC40LfRgtGA0LjQtSDRgtC10LfQuCDQvdC10YHQu9C10LTQtdC90Lgg0YTQsNC50LvQvtCy0LUg0LIg0YDQsNCx0L7RgtC90L7RgtC+INC00YrRgNCy0L46XG4iCiAiJSVz0J/RgNC10LzQtdGB0YLQtdGC0LUg0LPQuCDQuNC70Lgg0LPQuCDQuNC30YLRgNC40LnRgtC1LCDQt9CwINC00LAg0L/RgNC10LzQuNC90LXRgtC1INC90LAg0LTRgNGD0LMg0LrQu9C+0L0uIgogCi0jOiB1bnBhY2stdHJlZXMuYzoxMzQKKyM6IHVucGFjay10cmVlcy5jOjEzMwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiVGhlIGZvbGxvd2luZyB1bnRyYWNrZWQgd29ya2luZyB0cmVlIGZpbGVzIHdvdWxkIGJlIHJlbW92ZWQgYnkgY2hlY2tvdXQ6XG4iCkBAIC03OTg0LDcgKzgwMTUsNyBAQAogItCY0LfRgtC10LPQu9GP0L3QtdGC0L4g0YnQtSDQuNC30YLRgNC40LUg0YLQtdC30Lgg0L3QtdGB0LvQtdC00LXQvdC4INGE0LDQudC70L7QstC1INCyINGA0LDQsdC+0YLQvdC+0YLQviDQtNGK0YDQstC+OlxuIgogIiUlcyIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTM3CisjOiB1bnBhY2stdHJlZXMuYzoxMzYKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlRoZSBmb2xsb3dpbmcgdW50cmFja2VkIHdvcmtpbmcgdHJlZSBmaWxlcyB3b3VsZCBiZSByZW1vdmVkIGJ5IG1lcmdlOlxuIgpAQCAtNzk5Myw3ICs4MDI0LDcgQEAKICLQodC70LjQstCw0L3QtdGC0L4g0YnQtSDQuNC30YLRgNC40LUg0YLQtdC30Lgg0L3QtdGB0LvQtdC00LXQvdC4INGE0LDQudC70L7QstC1INCyINGA0LDQsdC+0YLQvdC+0YLQviDQtNGK0YDQstC+OlxuIgogIiUlc9Cf0YDQtdC80LXRgdGC0LXRgtC1INCz0Lgg0LjQu9C4INCz0Lgg0LjQt9GC0YDQuNC50YLQtSwg0LfQsCDQtNCwINGB0LvQtdC10YLQtS4iCiAKLSM6IHVucGFjay10cmVlcy5jOjEzOQorIzogdW5wYWNrLXRyZWVzLmM6MTM4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgZm9sbG93aW5nIHVudHJhY2tlZCB3b3JraW5nIHRyZWUgZmlsZXMgd291bGQgYmUgcmVtb3ZlZCBieSBtZXJnZTpcbiIKQEAgLTgwMDIsNyArODAzMyw3IEBACiAi0KHQu9C40LLQsNC90LXRgtC+INGJ0LUg0LjQt9GC0YDQuNC1INGC0LXQt9C4INC90LXRgdC70LXQtNC10L3QuCDRhNCw0LnQu9C+0LLQtSDQsiDRgNCw0LHQvtGC0L3QvtGC0L4g0LTRitGA0LLQvjpcbiIKICIlJXMiCiAKLSM6IHVucGFjay10cmVlcy5jOjE0MgorIzogdW5wYWNrLXRyZWVzLmM6MTQxCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgZm9sbG93aW5nIHVudHJhY2tlZCB3b3JraW5nIHRyZWUgZmlsZXMgd291bGQgYmUgcmVtb3ZlZCBieSAlczpcbiIKQEAgLTgwMTEsNyArODA0Miw3IEBACiAi4oCeJXPigJwg0YnQtSDQuNC30YLRgNC40LUg0YLQtdC30Lgg0L3QtdGB0LvQtdC00LXQvdC4INGE0LDQudC70L7QstC1INCyINGA0LDQsdC+0YLQvdC+0YLQviDQtNGK0YDQstC+OlxuIgogIiUlc9Cf0YDQtdC80LXRgdGC0LXRgtC1INCz0Lgg0LjQu9C4INCz0Lgg0LjQt9GC0YDQuNC50YLQtSwg0LfQsCDQtNCwINC40LfQstGK0YDRiNC40YLQtSDigJ4lc+KAnC4iCiAKLSM6IHVucGFjay10cmVlcy5jOjE0NAorIzogdW5wYWNrLXRyZWVzLmM6MTQzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgZm9sbG93aW5nIHVudHJhY2tlZCB3b3JraW5nIHRyZWUgZmlsZXMgd291bGQgYmUgcmVtb3ZlZCBieSAlczpcbiIKQEAgLTgwMjAsNyArODA1MSw3IEBACiAi4oCeJXPigJwg0YnQtSDQuNC30YLRgNC40LUg0YLQtdC30Lgg0L3QtdGB0LvQtdC00LXQvdC4INGE0LDQudC70L7QstC1INCyINGA0LDQsdC+0YLQvdC+0YLQviDQtNGK0YDQstC+OlxuIgogIiUlcyIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTUwCisjOiB1bnBhY2stdHJlZXMuYzoxNDkKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlRoZSBmb2xsb3dpbmcgdW50cmFja2VkIHdvcmtpbmcgdHJlZSBmaWxlcyB3b3VsZCBiZSBvdmVyd3JpdHRlbiBieSAiCkBAIC04MDMwLDcgKzgwNjEsNyBAQAogItCY0LfRgtC10LPQu9GP0L3QtdGC0L4g0YnQtSDQv9GA0LXQt9Cw0L/QuNGI0LUg0YLQtdC30Lgg0L3QtdGB0LvQtdC00LXQvdC4INGE0LDQudC70L7QstC1INCyINGA0LDQsdC+0YLQvdC+0YLQviDQtNGK0YDQstC+OlxuIgogIiUlc9Cf0YDQtdC80LXRgdGC0LXRgtC1INCz0Lgg0LjQu9C4INCz0Lgg0LjQt9GC0YDQuNC50YLQtSwg0LfQsCDQtNCwINGB0LzQtdC90LjRgtC1INC60LvQvtC9LiIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTUyCisjOiB1bnBhY2stdHJlZXMuYzoxNTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlRoZSBmb2xsb3dpbmcgdW50cmFja2VkIHdvcmtpbmcgdHJlZSBmaWxlcyB3b3VsZCBiZSBvdmVyd3JpdHRlbiBieSAiCkBAIC04MDQwLDcgKzgwNzEsNyBAQAogItCY0LfRgtC10LPQu9GP0L3QtdGC0L4g0YnQtSDQv9GA0LXQt9Cw0L/QuNGI0LUg0YLQtdC30Lgg0L3QtdGB0LvQtdC00LXQvdC4INGE0LDQudC70L7QstC1INCyINGA0LDQsdC+0YLQvdC+0YLQviDQtNGK0YDQstC+OlxuIgogIiUlcyIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTU1CisjOiB1bnBhY2stdHJlZXMuYzoxNTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlRoZSBmb2xsb3dpbmcgdW50cmFja2VkIHdvcmtpbmcgdHJlZSBmaWxlcyB3b3VsZCBiZSBvdmVyd3JpdHRlbiBieSBtZXJnZTpcbiIKQEAgLTgwNDksNyArODA4MCw3IEBACiAi0KHQu9C40LLQsNC90LXRgtC+INGJ0LUg0L/RgNC10LfQsNC/0LjRiNC1INGC0LXQt9C4INC90LXRgdC70LXQtNC10L3QuCDRhNCw0LnQu9C+0LLQtSDQsiDRgNCw0LHQvtGC0L3QvtGC0L4g0LTRitGA0LLQvjpcbiIKICIlJXPQn9GA0LXQvNC10YHRgtC10YLQtSDQs9C4INC40LvQuCDQs9C4INC40LfRgtGA0LjQudGC0LUsINC30LAg0LTQsCDRgdC70LXQtdGC0LUuIgogCi0jOiB1bnBhY2stdHJlZXMuYzoxNTcKKyM6IHVucGFjay10cmVlcy5jOjE1NgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiVGhlIGZvbGxvd2luZyB1bnRyYWNrZWQgd29ya2luZyB0cmVlIGZpbGVzIHdvdWxkIGJlIG92ZXJ3cml0dGVuIGJ5IG1lcmdlOlxuIgpAQCAtODA1OCw3ICs4MDg5LDcgQEAKICLQodC70LjQstCw0L3QtdGC0L4g0YnQtSDQv9GA0LXQt9Cw0L/QuNGI0LUg0YLQtdC30Lgg0L3QtdGB0LvQtdC00LXQvdC4INGE0LDQudC70L7QstC1INCyINGA0LDQsdC+0YLQvdC+0YLQviDQtNGK0YDQstC+OlxuIgogIiUlcyIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTYwCisjOiB1bnBhY2stdHJlZXMuYzoxNTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlRoZSBmb2xsb3dpbmcgdW50cmFja2VkIHdvcmtpbmcgdHJlZSBmaWxlcyB3b3VsZCBiZSBvdmVyd3JpdHRlbiBieSAlczpcbiIKQEAgLTgwNjcsNyArODA5OCw3IEBACiAi4oCeJXPigJwg0YnQtSDQv9GA0LXQt9Cw0L/QuNGI0LUg0YLQtdC30Lgg0L3QtdGB0LvQtdC00LXQvdC4INGE0LDQudC70L7QstC1INCyINGA0LDQsdC+0YLQvdC+0YLQviDQtNGK0YDQstC+OlxuIgogIiUlc9Cf0YDQtdC80LXRgdGC0LXRgtC1INCz0Lgg0LjQu9C4INCz0Lgg0LjQt9GC0YDQuNC50YLQtSwg0LfQsCDQtNCwINC40LfQstGK0YDRiNC40YLQtSDigJ4lc+KAnC4iCiAKLSM6IHVucGFjay10cmVlcy5jOjE2MgorIzogdW5wYWNrLXRyZWVzLmM6MTYxCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgZm9sbG93aW5nIHVudHJhY2tlZCB3b3JraW5nIHRyZWUgZmlsZXMgd291bGQgYmUgb3ZlcndyaXR0ZW4gYnkgJXM6XG4iCkBAIC04MDc2LDEyICs4MTA3LDEyIEBACiAi4oCeJXPigJwg0YnQtSDQv9GA0LXQt9Cw0L/QuNGI0LUg0YLQtdC30Lgg0L3QtdGB0LvQtdC00LXQvdC4INGE0LDQudC70L7QstC1INCyINGA0LDQsdC+0YLQvdC+0YLQviDQtNGK0YDQstC+OlxuIgogIiUlcyIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTcwCisjOiB1bnBhY2stdHJlZXMuYzoxNjkKICMsIGMtZm9ybWF0CiBtc2dpZCAiRW50cnkgJyVzJyBvdmVybGFwcyB3aXRoICclcycuICBDYW5ub3QgYmluZC4iCiBtc2dzdHIgItCX0LDQv9C40YHRitGCINC30LAg4oCeJXPigJwg0YHRitCy0L/QsNC00LAg0YEg0YLQvtC30Lgg0LfQsCDigJ4lc+KAnC4gINCd0LUg0LzQvtC20LUg0LTQsCDRgdC1INC/0YDQuNGB0LLQvtC4LiIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTczCisjOiB1bnBhY2stdHJlZXMuYzoxNzIKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkNhbm5vdCB1cGRhdGUgc3BhcnNlIGNoZWNrb3V0OiB0aGUgZm9sbG93aW5nIGVudHJpZXMgYXJlIG5vdCB1cCB0byBkYXRlOlxuIgpAQCAtODA5MSw3ICs4MTIyLDcgQEAKICLQsNC60YLRg9Cw0LvQvdC4OlxuIgogIiVzIgogCi0jOiB1bnBhY2stdHJlZXMuYzoxNzUKKyM6IHVucGFjay10cmVlcy5jOjE3NAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiVGhlIGZvbGxvd2luZyB3b3JraW5nIHRyZWUgZmlsZXMgd291bGQgYmUgb3ZlcndyaXR0ZW4gYnkgc3BhcnNlIGNoZWNrb3V0ICIKQEAgLTgxMDIsNyArODEzMyw3IEBACiAi0LTRitGA0LLQvjpcbiIKICIlcyIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTc3CisjOiB1bnBhY2stdHJlZXMuYzoxNzYKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlRoZSBmb2xsb3dpbmcgd29ya2luZyB0cmVlIGZpbGVzIHdvdWxkIGJlIHJlbW92ZWQgYnkgc3BhcnNlIGNoZWNrb3V0ICIKQEAgLTgxMTMsNyArODE0NCw3IEBACiAi0LTRitGA0LLQvjpcbiIKICIlcyIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTc5CisjOiB1bnBhY2stdHJlZXMuYzoxNzgKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkNhbm5vdCB1cGRhdGUgc3VibW9kdWxlOlxuIgpAQCAtODEyMiwxNiArODE1MywxNiBAQAogItCf0L7QtNC80L7QtNGD0LvRitGCINC90LUg0LzQvtC20LUg0LTQsCDQsdGK0LTQtSDQvtCx0L3QvtCy0LXQvTpcbiIKICLigJ4lc+KAnCIKIAotIzogdW5wYWNrLXRyZWVzLmM6MjU2CisjOiB1bnBhY2stdHJlZXMuYzoyNTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiQWJvcnRpbmdcbiIKIG1zZ3N0ciAi0J/RgNC10YPRgdGC0LDQvdC+0LLRj9Cy0LDQvdC1INC90LAg0LTQtdC50YHRgtCy0LjQtdGC0L5cbiIKIAotIzogdW5wYWNrLXRyZWVzLmM6MzE4CisjOiB1bnBhY2stdHJlZXMuYzozMTcKIG1zZ2lkICJVcGRhdGluZyBmaWxlcyIKIG1zZ3N0ciAi0J7QsdC90L7QstGP0LLQsNC90LUg0L3QsCDRhNCw0LnQu9C+0LLQtSIKIAotIzogdW5wYWNrLXRyZWVzLmM6MzUwCisjOiB1bnBhY2stdHJlZXMuYzozNDkKIG1zZ2lkICIiCiAidGhlIGZvbGxvd2luZyBwYXRocyBoYXZlIGNvbGxpZGVkIChlLmcuIGNhc2Utc2Vuc2l0aXZlIHBhdGhzXG4iCiAib24gYSBjYXNlLWluc2Vuc2l0aXZlIGZpbGVzeXN0ZW0pIGFuZCBvbmx5IG9uZSBmcm9tIHRoZSBzYW1lXG4iCkBAIC04MTcwLDcgKzgyMDEsNyBAQAogbXNnaWQgImludmFsaWQgJy4uJyBwYXRoIHNlZ21lbnQiCiBtc2dzdHIgItC90LXQv9GA0LDQstC40LvQvdCwINGH0LDRgdGCINC+0YIg0L/RitGC0Y8g4oCeLi7igJwiCiAKLSM6IHdvcmt0cmVlLmM6MjU4IGJ1aWx0aW4vYW0uYzoyMDk1CisjOiB3b3JrdHJlZS5jOjI1OCBidWlsdGluL2FtLmM6MjA4NAogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gcmVhZCAnJXMnIgogbXNnc3RyICLigJ4lc+KAnCDQvdC1INC80L7QttC1INC00LAg0LHRitC00LUg0L/RgNC+0YfQtdGC0LXQvSIKQEAgLTgyMDEsMTcgKzgyMzIsMTcgQEAKIG1zZ2lkICInJXMnIGRvZXMgbm90IHBvaW50IGJhY2sgdG8gJyVzJyIKIG1zZ3N0ciAi4oCeJXPigJwg0L3QtSDRgdC+0YfQuCDQutGK0Lwg0L7QsdGA0LDRgtC90L4g0LrRitC8IOKAniVz4oCcIgogCi0jOiB3cmFwcGVyLmM6MjIzIHdyYXBwZXIuYzozOTMKKyM6IHdyYXBwZXIuYzoxODYgd3JhcHBlci5jOjM1NgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3Qgb3BlbiAnJXMnIGZvciByZWFkaW5nIGFuZCB3cml0aW5nIgogbXNnc3RyICLigJ4lc+KAnCDQvdC1INC80L7QttC1INC00LAg0LHRitC00LUg0L7RgtCy0L7RgNC10L0g0Lgg0LfQsCDRh9C10YLQtdC90LUsINC4INC30LAg0LfQsNC/0LjRgSIKIAotIzogd3JhcHBlci5jOjQyNCB3cmFwcGVyLmM6NjI0CisjOiB3cmFwcGVyLmM6Mzg3IHdyYXBwZXIuYzo1ODgKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGFjY2VzcyAnJXMnIgogbXNnc3RyICLQvdGP0LzQsCDQtNC+0YHRgtGK0L8g0LTQviDigJ4lc+KAnCIKIAotIzogd3JhcHBlci5jOjYzMgorIzogd3JhcHBlci5jOjU5NgogbXNnaWQgInVuYWJsZSB0byBnZXQgY3VycmVudCB3b3JraW5nIGRpcmVjdG9yeSIKIG1zZ3N0ciAi0YLQtdC60YPRidCw0YLQsCDRgNCw0LHQvtGC0L3QsCDQtNC40YDQtdC60YLQvtGA0LjRjyDQtSDQvdC10LTQvtGB0YLRitC/0L3QsCIKIApAQCAtODU1OCw4NiArODU4OSw5NCBAQAogIiAgKNCy0YHQuNGH0LrQuCDQutC+0L3RhNC70LjQutGC0Lgg0YHQsCDQutC+0YDQuNCz0LjRgNCw0L3QuCwg0LjQt9C/0YrQu9C90LXRgtC1IOKAnmdpdCBjaGVycnktcGljayAtLWNvbnRpbnVl4oCcKSIKIAogIzogd3Qtc3RhdHVzLmM6MTQzNworbXNnaWQgIiAgKHVzZSBcImdpdCBjaGVycnktcGljayAtLXNraXBcIiB0byBza2lwIHRoaXMgcGF0Y2gpIgorbXNnc3RyICIgICjQuNC30L/QvtC70LfQstCw0LnRgtC1IOKAnmdpdCBjaGVycnktcGljayAtLXNraXDigJwsINC30LAg0LTQsCDQv9GA0L7Qv9GD0YHQvdC10YLQtSDRgtCw0LfQuCDQutGA0YrQv9C60LApIgorCisjOiB3dC1zdGF0dXMuYzoxNDM5CiBtc2dpZCAiICAodXNlIFwiZ2l0IGNoZXJyeS1waWNrIC0tYWJvcnRcIiB0byBjYW5jZWwgdGhlIGNoZXJyeS1waWNrIG9wZXJhdGlvbikiCiBtc2dzdHIgIiIKICIgICjQuNC30L/QvtC70LfQstCw0LnRgtC1IOKAnmdpdCBjaGVycnktcGljayAtLWFib3J04oCcLCDQt9CwINC00LAg0L7RgtC80LXQvdC40YLQtSDQstGB0LjRh9C60Lgg0LTQtdC50YHRgtCy0LjRjyDRgSAiCiAi0L7RgtCx0LjRgNCw0L3QtSkiCiAKLSM6IHd0LXN0YXR1cy5jOjE0NDcKKyM6IHd0LXN0YXR1cy5jOjE0NDkKIG1zZ2lkICJSZXZlcnQgY3VycmVudGx5IGluIHByb2dyZXNzLiIKIG1zZ3N0ciAi0JIg0LzQvtC80LXQvdGC0LAg0YLQtdGH0LUg0L7RgtC80Y/QvdCwINC90LAg0L/QvtC00LDQstCw0L3QtS4iCiAKLSM6IHd0LXN0YXR1cy5jOjE0NTAKKyM6IHd0LXN0YXR1cy5jOjE0NTIKICMsIGMtZm9ybWF0CiBtc2dpZCAiWW91IGFyZSBjdXJyZW50bHkgcmV2ZXJ0aW5nIGNvbW1pdCAlcy4iCiBtc2dzdHIgItCSINC80L7QvNC10L3RgtCwINC+0YLQvNC10L3Rj9GC0LUg0L/QvtC00LDQstCw0L3QtSDigJ4lc+KAnC4iCiAKLSM6IHd0LXN0YXR1cy5jOjE0NTYKKyM6IHd0LXN0YXR1cy5jOjE0NTgKIG1zZ2lkICIgIChmaXggY29uZmxpY3RzIGFuZCBydW4gXCJnaXQgcmV2ZXJ0IC0tY29udGludWVcIikiCiBtc2dzdHIgIiAgKNC60L7RgNC40LPQuNGA0LDQudGC0LUg0LrQvtC90YTQu9C40LrRgtC40YLQtSDQuCDQuNC30L/RitC70L3QtdGC0LUg4oCeZ2l0IHJldmVydCAtLWNvbnRpbnVl4oCcKSIKIAotIzogd3Qtc3RhdHVzLmM6MTQ1OQorIzogd3Qtc3RhdHVzLmM6MTQ2MQogbXNnaWQgIiAgKHJ1biBcImdpdCByZXZlcnQgLS1jb250aW51ZVwiIHRvIGNvbnRpbnVlKSIKIG1zZ3N0ciAiICAo0LfQsCDQtNCwINC/0YDQvtC00YrQu9C20LjRgtC1LCDQuNC30L/RitC70L3QtdGC0LUg4oCeZ2l0IHJldmVydCAtLWNvbnRpbnVl4oCcKSIKIAotIzogd3Qtc3RhdHVzLmM6MTQ2MgorIzogd3Qtc3RhdHVzLmM6MTQ2NAogbXNnaWQgIiAgKGFsbCBjb25mbGljdHMgZml4ZWQ6IHJ1biBcImdpdCByZXZlcnQgLS1jb250aW51ZVwiKSIKIG1zZ3N0ciAiICAo0LLRgdC40YfQutC4INC60L7QvdGE0LvQuNC60YLQuCDRgdCwINC60L7RgNC40LPQuNGA0LDQvdC4LCDQuNC30L/RitC70L3QtdGC0LUg4oCeZ2l0IHJldmVydCAtLWNvbnRpbnVl4oCcKSIKIAotIzogd3Qtc3RhdHVzLmM6MTQ2NAorIzogd3Qtc3RhdHVzLmM6MTQ2NgorbXNnaWQgIiAgKHVzZSBcImdpdCByZXZlcnQgLS1za2lwXCIgdG8gc2tpcCB0aGlzIHBhdGNoKSIKK21zZ3N0ciAiICAo0LjQt9C/0L7Qu9C30LLQsNC50YLQtSDigJ5naXQgcmV2ZXJ0IC0tc2tpcOKAnCwg0LfQsCDQtNCwINC/0YDQvtC/0YPRgdC90LXRgtC1INGC0LDQt9C4INC60YDRitC/0LrQsCkiCisKKyM6IHd0LXN0YXR1cy5jOjE0NjgKIG1zZ2lkICIgICh1c2UgXCJnaXQgcmV2ZXJ0IC0tYWJvcnRcIiB0byBjYW5jZWwgdGhlIHJldmVydCBvcGVyYXRpb24pIgogbXNnc3RyICIiCiAiICAo0LjQt9C/0L7Qu9C30LLQsNC50YLQtSDigJ5naXQgcmV2ZXJ0IC0tYWJvcnTigJwsINC30LAg0LTQsCDQv9GA0LXRg9GB0YLQsNC90L7QstC40YLQtSDQvtGC0LzRj9C90LDRgtCwINC90LAgIgogItC/0L7QtNCw0LLQsNC90LUpIgogCi0jOiB3dC1zdGF0dXMuYzoxNDc0CisjOiB3dC1zdGF0dXMuYzoxNDc4CiAjLCBjLWZvcm1hdAogbXNnaWQgIllvdSBhcmUgY3VycmVudGx5IGJpc2VjdGluZywgc3RhcnRlZCBmcm9tIGJyYW5jaCAnJXMnLiIKIG1zZ3N0ciAi0JIg0LzQvtC80LXQvdGC0LAg0YLRitGA0YHQuNGC0LUg0LTQstC+0LjRh9C90L4sINC60LDRgtC+INGB0YLQtSDRgdGC0LDRgNGC0LjRgNCw0LvQuCDQvtGCINC60LvQvtC9IOKAniVz4oCcLiIKIAotIzogd3Qtc3RhdHVzLmM6MTQ3OAorIzogd3Qtc3RhdHVzLmM6MTQ4MgogbXNnaWQgIllvdSBhcmUgY3VycmVudGx5IGJpc2VjdGluZy4iCiBtc2dzdHIgItCSINC80L7QvNC10L3RgtCwINGC0YrRgNGB0LjRgtC1INC00LLQvtC40YfQvdC+LiIKIAotIzogd3Qtc3RhdHVzLmM6MTQ4MQorIzogd3Qtc3RhdHVzLmM6MTQ4NQogbXNnaWQgIiAgKHVzZSBcImdpdCBiaXNlY3QgcmVzZXRcIiB0byBnZXQgYmFjayB0byB0aGUgb3JpZ2luYWwgYnJhbmNoKSIKIG1zZ3N0ciAiIgogIiAgKNC40LfQv9C+0LvQt9Cy0LDQudGC0LUg4oCeZ2l0IGJpc2VjdCByZXNldOKAnCwg0LfQsCDQtNCwINGB0LUg0LLRitGA0L3QtdGC0LUg0LrRitC8INC/0YrRgNCy0L7QvdCw0YfQsNC70L3QvtGC0L4gIgogItGB0YrRgdGC0L7Rj9C90LjQtSDQuCDQutC70L7QvSkiCiAKLSM6IHd0LXN0YXR1cy5jOjE2OTAKKyM6IHd0LXN0YXR1cy5jOjE2OTQKIG1zZ2lkICJPbiBicmFuY2ggIgogbXNnc3RyICLQndCwINC60LvQvtC9ICIKIAotIzogd3Qtc3RhdHVzLmM6MTY5NworIzogd3Qtc3RhdHVzLmM6MTcwMQogbXNnaWQgImludGVyYWN0aXZlIHJlYmFzZSBpbiBwcm9ncmVzczsgb250byAiCiBtc2dzdHIgItC40LfQstGK0YDRiNCy0LDRgtC1INC40L3RgtC10YDQsNC60YLQuNCy0L3QviDQv9GA0LXQsdCw0LfQuNGA0LDQvdC1INCy0YrRgNGF0YMgIgogCi0jOiB3dC1zdGF0dXMuYzoxNjk5CisjOiB3dC1zdGF0dXMuYzoxNzAzCiBtc2dpZCAicmViYXNlIGluIHByb2dyZXNzOyBvbnRvICIKIG1zZ3N0ciAi0LjQt9Cy0YrRgNGI0LLQsNGC0LUg0L/RgNC10LHQsNC30LjRgNCw0L3QtSDQstGK0YDRhdGDICIKIAotIzogd3Qtc3RhdHVzLmM6MTcwOQorIzogd3Qtc3RhdHVzLmM6MTcxMwogbXNnaWQgIk5vdCBjdXJyZW50bHkgb24gYW55IGJyYW5jaC4iCiBtc2dzdHIgItCY0LfQstGK0L0g0LLRgdC40YfQutC4INC60LvQvtC90LguIgogCi0jOiB3dC1zdGF0dXMuYzoxNzI2CisjOiB3dC1zdGF0dXMuYzoxNzMwCiBtc2dpZCAiSW5pdGlhbCBjb21taXQiCiBtc2dzdHIgItCf0YrRgNCy0L7QvdCw0YfQsNC70L3QviDQv9C+0LTQsNCy0LDQvdC1IgogCi0jOiB3dC1zdGF0dXMuYzoxNzI3CisjOiB3dC1zdGF0dXMuYzoxNzMxCiBtc2dpZCAiTm8gY29tbWl0cyB5ZXQiCiBtc2dzdHIgItCS0YHQtSDQvtGJ0LUg0LvQuNC/0YHQstCw0YIg0L/QvtC00LDQstCw0L3QuNGPIgogCi0jOiB3dC1zdGF0dXMuYzoxNzQxCisjOiB3dC1zdGF0dXMuYzoxNzQ1CiBtc2dpZCAiVW50cmFja2VkIGZpbGVzIgogbXNnc3RyICLQndC10YHQu9C10LTQtdC90Lgg0YTQsNC50LvQvtCy0LUiCiAKLSM6IHd0LXN0YXR1cy5jOjE3NDMKKyM6IHd0LXN0YXR1cy5jOjE3NDcKIG1zZ2lkICJJZ25vcmVkIGZpbGVzIgogbXNnc3RyICLQmNCz0L3QvtGA0LjRgNCw0L3QuCDRhNCw0LnQu9C+0LLQtSIKIAotIzogd3Qtc3RhdHVzLmM6MTc0NworIzogd3Qtc3RhdHVzLmM6MTc1MQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiSXQgdG9vayAlLjJmIHNlY29uZHMgdG8gZW51bWVyYXRlIHVudHJhY2tlZCBmaWxlcy4gJ3N0YXR1cyAtdW5vJ1xuIgpAQCAtODY0OSwzMiArODY4OCwzMiBAQAogItC40LfQv9GK0LvQvdC10L3QuNC10YLQviwg0L3QviDRidC1INGC0YDRj9Cx0LLQsCDQtNCwINC00L7QsdCw0LLRj9GC0LUg0L3QvtCy0LjRgtC1INGE0LDQudC70L7QstC1INGA0YrRh9C90L4uXG4iCiAi0JfQsCDQv9C+0LLQtdGH0LUg0L/QvtC00YDQvtCx0L3QvtGB0YLQuCDQv9C+0LPQu9C10LTQvdC10YLQtSDigJ5naXQgc3RhdHVzIGhlbHDigJwuIgogCi0jOiB3dC1zdGF0dXMuYzoxNzUzCisjOiB3dC1zdGF0dXMuYzoxNzU3CiAjLCBjLWZvcm1hdAogbXNnaWQgIlVudHJhY2tlZCBmaWxlcyBub3QgbGlzdGVkJXMiCiBtc2dzdHIgItCd0LXRgdC70LXQtNC10L3QuNGC0LUg0YTQsNC50LvQvtCy0LUg0L3QtSDRgdCwINC40LfQstC10LTQtdC90LglcyIKIAotIzogd3Qtc3RhdHVzLmM6MTc1NQorIzogd3Qtc3RhdHVzLmM6MTc1OQogbXNnaWQgIiAodXNlIC11IG9wdGlvbiB0byBzaG93IHVudHJhY2tlZCBmaWxlcykiCiBtc2dzdHIgIiAo0LjQt9C/0L7Qu9C30LLQsNC50YLQtSDQvtC/0YbQuNGP0YLQsCDigJ4tdeKAnCwg0LfQsCDQtNCwINC40LfQstC10LTQtdGC0LUg0L3QtdGB0LvQtdC00LXQvdC40YLQtSDRhNCw0LnQu9C+0LLQtSkiCiAKLSM6IHd0LXN0YXR1cy5jOjE3NjEKKyM6IHd0LXN0YXR1cy5jOjE3NjUKIG1zZ2lkICJObyBjaGFuZ2VzIgogbXNnc3RyICLQndGP0LzQsCDQv9GA0L7QvNC10L3QuCIKIAotIzogd3Qtc3RhdHVzLmM6MTc2NgorIzogd3Qtc3RhdHVzLmM6MTc3MAogIywgYy1mb3JtYXQKIG1zZ2lkICJubyBjaGFuZ2VzIGFkZGVkIHRvIGNvbW1pdCAodXNlIFwiZ2l0IGFkZFwiIGFuZC9vciBcImdpdCBjb21taXQgLWFcIilcbiIKIG1zZ3N0ciAiIgogItC60YrQvCDQuNC90LTQtdC60YHQsCDQt9CwINC/0L7QtNCw0LLQsNC90LUg0L3QtSDRgdCwINC00L7QsdCw0LLQtdC90Lgg0L/RgNC+0LzQtdC90LggKNC40LfQv9C+0LvQt9Cy0LDQudGC0LUg4oCeZ2l0IGFkZOKAnCDQuC/QuNC70LggIgogIuKAnmdpdCBjb21taXQgLWHigJwpXG4iCiAKLSM6IHd0LXN0YXR1cy5jOjE3NjkKKyM6IHd0LXN0YXR1cy5jOjE3NzMKICMsIGMtZm9ybWF0CiBtc2dpZCAibm8gY2hhbmdlcyBhZGRlZCB0byBjb21taXRcbiIKIG1zZ3N0ciAi0LrRitC8INC40L3QtNC10LrRgdCwINC30LAg0L/QvtC00LDQstCw0L3QtSDQvdC1INGB0LAg0LTQvtCx0LDQstC10L3QuCDQv9GA0L7QvNC10L3QuFxuIgogCi0jOiB3dC1zdGF0dXMuYzoxNzcyCisjOiB3dC1zdGF0dXMuYzoxNzc2CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJub3RoaW5nIGFkZGVkIHRvIGNvbW1pdCBidXQgdW50cmFja2VkIGZpbGVzIHByZXNlbnQgKHVzZSBcImdpdCBhZGRcIiB0byAiCkBAIC04NjgzLDcxICs4NzIyLDcxIEBACiAi0LrRitC8INC40L3QtNC10LrRgdCwINC30LAg0L/QvtC00LDQstCw0L3QtSDQvdC1INGB0LAg0LTQvtCx0LDQstC10L3QuCDQv9GA0L7QvNC10L3QuCwg0L3QviDQuNC80LAg0L3QvtCy0Lgg0YTQsNC50LvQvtCy0LUgIgogIijQuNC30L/QvtC70LfQstCw0LnRgtC1IOKAnmdpdCBhZGTigJwsINC30LAg0LTQsCDQt9Cw0L/QvtGH0L3QtSDRgtGP0YXQvdC+0YLQviDRgdC70LXQtNC10L3QtSlcbiIKIAotIzogd3Qtc3RhdHVzLmM6MTc3NQorIzogd3Qtc3RhdHVzLmM6MTc3OQogIywgYy1mb3JtYXQKIG1zZ2lkICJub3RoaW5nIGFkZGVkIHRvIGNvbW1pdCBidXQgdW50cmFja2VkIGZpbGVzIHByZXNlbnRcbiIKIG1zZ3N0ciAi0LrRitC8INC40L3QtNC10LrRgdCwINC30LAg0L/QvtC00LDQstCw0L3QtSDQvdC1INGB0LAg0LTQvtCx0LDQstC10L3QuCDQv9GA0L7QvNC10L3QuCwg0L3QviDQuNC80LAg0L3QvtCy0Lgg0YTQsNC50LvQvtCy0LVcbiIKIAotIzogd3Qtc3RhdHVzLmM6MTc3OAorIzogd3Qtc3RhdHVzLmM6MTc4MgogIywgYy1mb3JtYXQKIG1zZ2lkICJub3RoaW5nIHRvIGNvbW1pdCAoY3JlYXRlL2NvcHkgZmlsZXMgYW5kIHVzZSBcImdpdCBhZGRcIiB0byB0cmFjaylcbiIKIG1zZ3N0ciAiIgogItC70LjQv9GB0LLQsNGCINC60LDQutCy0LjRgtC+INC4INC00LAg0LUg0L/RgNC+0LzQtdC90LggKNGB0YrQt9C00LDQudGC0LUg0LjQu9C4INC60L7Qv9C40YDQsNC50YLQtSDRhNCw0LnQu9C+0LLQtSDQuCDQuNC30L/QvtC70LfQstCw0LnRgtC1ICIKICLigJ5naXQgYWRk4oCcLCDQt9CwINC00LAg0LfQsNC/0L7Rh9C90LUg0YLRj9GF0L3QvtGC0L4g0YHQu9C10LTQtdC90LUpXG4iCiAKLSM6IHd0LXN0YXR1cy5jOjE3ODEgd3Qtc3RhdHVzLmM6MTc4NgorIzogd3Qtc3RhdHVzLmM6MTc4NSB3dC1zdGF0dXMuYzoxNzkwCiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vdGhpbmcgdG8gY29tbWl0XG4iCiBtc2dzdHIgItC70LjQv9GB0LLQsNGCINC60LDQutCy0LjRgtC+INC4INC00LAg0LUg0L/RgNC+0LzQtdC90LhcbiIKIAotIzogd3Qtc3RhdHVzLmM6MTc4NAorIzogd3Qtc3RhdHVzLmM6MTc4OAogIywgYy1mb3JtYXQKIG1zZ2lkICJub3RoaW5nIHRvIGNvbW1pdCAodXNlIC11IHRvIHNob3cgdW50cmFja2VkIGZpbGVzKVxuIgogbXNnc3RyICIiCiAi0LvQuNC/0YHQstCw0YIg0LrQsNC60LLQuNGC0L4g0Lgg0LTQsCDQtSDQv9GA0L7QvNC10L3QuCAo0LjQt9C/0L7Qu9C30LLQsNC50YLQtSDQvtC/0YbQuNGP0YLQsCDigJ4tdeKAnCwg0LfQsCDQtNCwINGB0LUg0LjQt9Cy0LXQtNCw0YIg0LggIgogItC90LXRgdC70LXQtNC10L3QuNGC0LUg0YTQsNC50LvQvtCy0LUpXG4iCiAKLSM6IHd0LXN0YXR1cy5jOjE3ODgKKyM6IHd0LXN0YXR1cy5jOjE3OTIKICMsIGMtZm9ybWF0CiBtc2dpZCAibm90aGluZyB0byBjb21taXQsIHdvcmtpbmcgdHJlZSBjbGVhblxuIgogbXNnc3RyICLQu9C40L/RgdCy0LDRgiDQutCw0LrQstC40YLQviDQuCDQtNCwINC1INC/0YDQvtC80LXQvdC4LCDRgNCw0LHQvtGC0L3QvtGC0L4g0LTRitGA0LLQviDQtSDRh9C40YHRgtC+XG4iCiAKLSM6IHd0LXN0YXR1cy5jOjE5MDEKKyM6IHd0LXN0YXR1cy5jOjE5MDUKIG1zZ2lkICJObyBjb21taXRzIHlldCBvbiAiCiBtc2dzdHIgItCS0YHQtSDQvtGJ0LUg0LvQuNC/0YHQstCw0YIg0L/QvtC00LDQstCw0L3QuNGPINCyICIKIAotIzogd3Qtc3RhdHVzLmM6MTkwNQorIzogd3Qtc3RhdHVzLmM6MTkwOQogbXNnaWQgIkhFQUQgKG5vIGJyYW5jaCkiCiBtc2dzdHIgIkhFQUQgKNC40LfQstGK0L0g0LrQu9C+0L0pIgogCi0jOiB3dC1zdGF0dXMuYzoxOTM2CisjOiB3dC1zdGF0dXMuYzoxOTQwCiBtc2dpZCAiZGlmZmVyZW50IgogbXNnc3RyICLRgNCw0LfQu9C40YfQtdC9IgogCi0jOiB3dC1zdGF0dXMuYzoxOTM4IHd0LXN0YXR1cy5jOjE5NDYKKyM6IHd0LXN0YXR1cy5jOjE5NDIgd3Qtc3RhdHVzLmM6MTk1MAogbXNnaWQgImJlaGluZCAiCiBtc2dzdHIgItC90LDQt9Cw0LQg0YEgIgogCi0jOiB3dC1zdGF0dXMuYzoxOTQxIHd0LXN0YXR1cy5jOjE5NDQKKyM6IHd0LXN0YXR1cy5jOjE5NDUgd3Qtc3RhdHVzLmM6MTk0OAogbXNnaWQgImFoZWFkICIKIG1zZ3N0ciAi0L3QsNC/0YDQtdC0INGBICIKIAogIy4gVFJBTlNMQVRPUlM6IHRoZSBhY3Rpb24gaXMgZS5nLiAicHVsbCB3aXRoIHJlYmFzZSIKLSM6IHd0LXN0YXR1cy5jOjI0NjYKKyM6IHd0LXN0YXR1cy5jOjI0NzAKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90ICVzOiBZb3UgaGF2ZSB1bnN0YWdlZCBjaGFuZ2VzLiIKIG1zZ3N0ciAi0L3QtSDQvNC+0LbQtSDQtNCwINC40LfQstGK0YDRiNC40YLQtSDigJ4lc+KAnCwg0LfQsNGJ0L7RgtC+INC40LzQsCDQv9GA0L7QvNC10L3QuCwg0LrQvtC40YLQviDQvdC1INGB0LAg0LIg0LjQvdC00LXQutGB0LAuIgogCi0jOiB3dC1zdGF0dXMuYzoyNDcyCisjOiB3dC1zdGF0dXMuYzoyNDc2CiBtc2dpZCAiYWRkaXRpb25hbGx5LCB5b3VyIGluZGV4IGNvbnRhaW5zIHVuY29tbWl0dGVkIGNoYW5nZXMuIgogbXNnc3RyICLQvtGB0LLQtdC9INGC0L7QstCwINCyINC40L3QtNC10LrRgdCwINC40LzQsCDQvdC10L/QvtC00LDQtNC10L3QuCDQv9GA0L7QvNC10L3QuC4iCiAKLSM6IHd0LXN0YXR1cy5jOjI0NzQKKyM6IHd0LXN0YXR1cy5jOjI0NzgKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90ICVzOiBZb3VyIGluZGV4IGNvbnRhaW5zIHVuY29tbWl0dGVkIGNoYW5nZXMuIgogbXNnc3RyICLQvdC1INC80L7QttC1INC00LAg0LjQt9Cy0YrRgNGI0LjRgtC1IOKAniVz4oCcLCDQt9Cw0YnQvtGC0L4g0LIg0LjQvdC00LXQutGB0LAg0LjQvNCwINC90LXQv9C+0LTQsNC00LXQvdC4INC/0YDQvtC80LXQvdC4LiIKIAotIzogY29tcGF0L3ByZWNvbXBvc2VfdXRmOC5jOjU4IGJ1aWx0aW4vY2xvbmUuYzo0NTMKKyM6IGNvbXBhdC9wcmVjb21wb3NlX3V0ZjguYzo1OCBidWlsdGluL2Nsb25lLmM6NDUyCiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byB1bmxpbmsgJyVzJyIKIG1zZ3N0ciAi0L3QtdGD0YHQv9C10YjQvdC+INC40LfRgtGA0LjQstCw0L3QtSDQvdCwIOKAniVz4oCcIgpAQCAtODc3NCw3ICs4ODEzLDcgQEAKIG1zZ2lkICJVbnN0YWdlZCBjaGFuZ2VzIGFmdGVyIHJlZnJlc2hpbmcgdGhlIGluZGV4OiIKIG1zZ3N0ciAi0J/RgNC+0LzQtdC90LgsINC60L7QuNGC0L4g0Lgg0YHQu9C10LQg0L7QsdC90L7QstGP0LLQsNC90LXRgtC+INC90LAg0LjQvdC00LXQutGB0LAg0L3QtSDRgdCwINC00L7QsdCw0LLQtdC90Lgg0LrRitC8INC90LXQs9C+OiIKIAotIzogYnVpbHRpbi9hZGQuYzoyMzQgYnVpbHRpbi9yZXYtcGFyc2UuYzo4OTYKKyM6IGJ1aWx0aW4vYWRkLmM6MjM0IGJ1aWx0aW4vcmV2LXBhcnNlLmM6ODk3CiBtc2dpZCAiQ291bGQgbm90IHJlYWQgdGhlIGluZGV4IgogbXNnc3RyICLQmNC90LTQtdC60YHRitGCINC90LUg0LzQvtC20LUg0LTQsCDQsdGK0LTQtSDQv9GA0L7Rh9C10YLQtdC9IgogCkBAIC04ODEwLDggKzg4NDksOCBAQAogbXNnc3RyICIiCiAi0KHQu9C10LTQvdC40YLQtSDQv9GK0YLQuNGJ0LAg0YnQtSDQsdGK0LTQsNGCINC40LPQvdC+0YDQuNGA0LDQvdC4INGB0L/QvtGA0LXQtCDQvdGP0LrQvtC5INC+0YIg0YTQsNC50LvQvtCy0LXRgtC1IOKAni5naXRpZ25vcmXigJw6XG4iCiAKLSM6IGJ1aWx0aW4vYWRkLmM6MjkwIGJ1aWx0aW4vY2xlYW4uYzo5MDkgYnVpbHRpbi9mZXRjaC5jOjE0NyBidWlsdGluL212LmM6MTI0Ci0jOiBidWlsdGluL3BydW5lLXBhY2tlZC5jOjU2IGJ1aWx0aW4vcHVsbC5jOjIyMiBidWlsdGluL3B1c2guYzo1NjAKKyM6IGJ1aWx0aW4vYWRkLmM6MjkwIGJ1aWx0aW4vY2xlYW4uYzo5MTAgYnVpbHRpbi9mZXRjaC5jOjE2MiBidWlsdGluL212LmM6MTI0CisjOiBidWlsdGluL3BydW5lLXBhY2tlZC5jOjU2IGJ1aWx0aW4vcHVsbC5jOjIyMyBidWlsdGluL3B1c2guYzo1NDcKICM6IGJ1aWx0aW4vcmVtb3RlLmM6MTM0NSBidWlsdGluL3JtLmM6MjQxIGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTY1CiBtc2dpZCAiZHJ5IHJ1biIKIG1zZ3N0ciAi0L/RgNC+0LHQvdC+INC40LfQv9GK0LvQvdC10L3QuNC1IgpAQCAtODg2OSw3ICs4OTA4LDcgQEAKICLQv9GA0L7QstC10YDQutCwLCDRh9C1INC/0YDQuCDQv9GA0L7QsdC90L4g0LjQt9C/0YrQu9C90LXQvdC40LUg0LLRgdC40YfQutC4INGE0LDQudC70L7QstC1LCDQtNC+0YDQuCDQuCDQuNC30YLRgNC40YLQuNGC0LUsINGB0LUgIgogItC40LPQvdC+0YDQuNGA0LDRgiIKIAotIzogYnVpbHRpbi9hZGQuYzozMDkgYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDAxCisjOiBidWlsdGluL2FkZC5jOjMwOSBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMDIKIG1zZ2lkICJvdmVycmlkZSB0aGUgZXhlY3V0YWJsZSBiaXQgb2YgdGhlIGxpc3RlZCBmaWxlcyIKIG1zZ3N0ciAi0LjQt9GA0LjRh9C90L4g0LfQsNC00LDQstCw0L3QtSDQvdCwINGB0YLQvtC50L3QvtGB0YLRgtCwINC90LAg0YTQu9Cw0LPQsCDQtNCw0LvQuCDRhNCw0LnQu9GK0YIg0LUg0LjQt9C/0YrQu9C90LjQvCIKIApAQCAtODk0NSwxMTQgKzg5ODQsMTEwIEBACiBtc2dpZCAiTWF5YmUgeW91IHdhbnRlZCB0byBzYXkgJ2dpdCBhZGQgLic/XG4iCiBtc2dzdHIgItCS0LXRgNC+0Y/RgtC90L4g0LjRgdC60LDRhdGC0LUg0LTQsCDQuNC30L/QvtC70LfQstCw0YLQtSDigJ5naXQgYWRkIC7igJw/XG4iCiAKLSM6IGJ1aWx0aW4vYW0uYzozNDgKKyM6IGJ1aWx0aW4vYW0uYzozNDcKIG1zZ2lkICJjb3VsZCBub3QgcGFyc2UgYXV0aG9yIHNjcmlwdCIKIG1zZ3N0ciAi0YHQutGA0LjQv9GC0YrRgiDQt9CwINCw0LLRgtC+0YAg0L3QtSDQvNC+0LbQtSDQtNCwINGB0LUg0LDQvdCw0LvQuNC30LjRgNCwIgogCi0jOiBidWlsdGluL2FtLmM6NDMyCisjOiBidWlsdGluL2FtLmM6NDMxCiAjLCBjLWZvcm1hdAogbXNnaWQgIiclcycgd2FzIGRlbGV0ZWQgYnkgdGhlIGFwcGx5cGF0Y2gtbXNnIGhvb2siCiBtc2dzdHIgIuKAniVz4oCcINCx0LUg0LjQt9GC0YDQuNGCINC+0YIg0LrRg9C60LDRgtCwIOKAnmFwcGx5cGF0Y2gtbXNn4oCcIgogCi0jOiBidWlsdGluL2FtLmM6NDc0CisjOiBidWlsdGluL2FtLmM6NDczCiAjLCBjLWZvcm1hdAogbXNnaWQgIk1hbGZvcm1lZCBpbnB1dCBsaW5lOiAnJXMnLiIKIG1zZ3N0ciAi0JTQsNC00LXQvdC40Y/RgiDQstGF0L7QtNC10L0g0YDQtdC0INC1INGBINC90LXQv9GA0LDQstC40LvQtdC9INGE0L7RgNC80LDRgjog4oCeJXPigJwuIgogCi0jOiBidWlsdGluL2FtLmM6NTEyCisjOiBidWlsdGluL2FtLmM6NTExCiAjLCBjLWZvcm1hdAogbXNnaWQgIkZhaWxlZCB0byBjb3B5IG5vdGVzIGZyb20gJyVzJyB0byAnJXMnIgogbXNnc3RyICLQkdC10LvQtdC20LrQsNGC0LAg0L3QtSDQvNC+0LbQtSDQtNCwINGB0LUg0LrQvtC/0LjRgNCwINC+0YIg4oCeJXPigJwg0LrRitC8IOKAniVz4oCcIgogCi0jOiBidWlsdGluL2FtLmM6NTM4CisjOiBidWlsdGluL2FtLmM6NTM3CiBtc2dpZCAiZnNlZWsgZmFpbGVkIgogbXNnc3RyICLQvdC10YPRgdC/0LXRiNC90L4g0LjQt9C/0YrQu9C90LXQvdC40LUg0L3QsCDigJ5mc2Vla+KAnCIKIAotIzogYnVpbHRpbi9hbS5jOjcyNgorIzogYnVpbHRpbi9hbS5jOjcyNQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcGFyc2UgcGF0Y2ggJyVzJyIKIG1zZ3N0ciAi0LrRgNGK0L/QutCw0YLQsCDigJ4lc+KAnCDQvdC1INC80L7QttC1INC00LAg0YHQtSDQsNC90LDQu9C40LfQuNGA0LAiCiAKLSM6IGJ1aWx0aW4vYW0uYzo3OTEKKyM6IGJ1aWx0aW4vYW0uYzo3OTAKIG1zZ2lkICJPbmx5IG9uZSBTdEdJVCBwYXRjaCBzZXJpZXMgY2FuIGJlIGFwcGxpZWQgYXQgb25jZSIKIG1zZ3N0ciAiIgogItCh0LDQvNC+INC10LTQvdCwINC/0L7RgNC10LTQuNGG0LAg0L7RgiDQutGA0YrQv9C60Lgg0L7RgiDigJ5TdEdJVOKAnCDQvNC+0LbQtSDQtNCwINCx0YrQtNC1INC/0YDQuNC70LDQs9Cw0L3QsCDQsiDQtNCw0LTQtdC9INC80L7QvNC10L3RgiIKIAotIzogYnVpbHRpbi9hbS5jOjgzOQorIzogYnVpbHRpbi9hbS5jOjgzOAogbXNnaWQgImludmFsaWQgdGltZXN0YW1wIgogbXNnc3RyICLQvdC10L/RgNCw0LLQuNC70L3QsCDRgdGC0L7QudC90L7RgdGCINC30LAg0LLRgNC10LzQtSIKIAotIzogYnVpbHRpbi9hbS5jOjg0NCBidWlsdGluL2FtLmM6ODU2CisjOiBidWlsdGluL2FtLmM6ODQzIGJ1aWx0aW4vYW0uYzo4NTUKIG1zZ2lkICJpbnZhbGlkIERhdGUgbGluZSIKIG1zZ3N0ciAi0L3QtdC/0YDQsNCy0LjQu9C10L0g0YDQtdC0INC30LAg0LTQsNGC0LAg4oCeRGF0ZeKAnCIKIAotIzogYnVpbHRpbi9hbS5jOjg1MQorIzogYnVpbHRpbi9hbS5jOjg1MAogbXNnaWQgImludmFsaWQgdGltZXpvbmUgb2Zmc2V0IgogbXNnc3RyICLQvdC10L/RgNCw0LLQuNC70L3QviDQvtGC0LzQtdGB0YLQstCw0L3QtSDQvdCwINGH0LDRgdC+0LLQuNGPINC/0L7Rj9GBIgogCi0jOiBidWlsdGluL2FtLmM6OTQ0CisjOiBidWlsdGluL2FtLmM6OTQzCiBtc2dpZCAiUGF0Y2ggZm9ybWF0IGRldGVjdGlvbiBmYWlsZWQuIgogbXNnc3RyICLQpNC+0YDQvNCw0YLRitGCINC90LAg0LrRgNGK0L/QutCw0YLQsCDQvdC1INC80L7QttC1INC00LAg0LHRitC00LUg0L7Qv9GA0LXQtNC10LvQtdC9LiIKIAotIzogYnVpbHRpbi9hbS5jOjk0OSBidWlsdGluL2Nsb25lLmM6NDA3CisjOiBidWlsdGluL2FtLmM6OTQ4IGJ1aWx0aW4vY2xvbmUuYzo0MDYKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIGNyZWF0ZSBkaXJlY3RvcnkgJyVzJyIKIG1zZ3N0ciAi0LTQuNGA0LXQutGC0L7RgNC40Y/RgtCwIOKAniVz4oCcINC90LUg0LzQvtC20LUg0LTQsCDQsdGK0LTQtSDRgdGK0LfQtNCw0LTQtdC90LAiCiAKLSM6IGJ1aWx0aW4vYW0uYzo5NTQKKyM6IGJ1aWx0aW4vYW0uYzo5NTMKIG1zZ2lkICJGYWlsZWQgdG8gc3BsaXQgcGF0Y2hlcy4iCiBtc2dzdHIgItCa0YDRitC/0LrQuNGC0LUg0L3QtSDQvNC+0LPQsNGCINC00LAg0LHRitC00LDRgiDRgNCw0LfQtNC10LvQtdC90LguIgogCi0jOiBidWlsdGluL2FtLmM6MTA4NCBidWlsdGluL2NvbW1pdC5jOjM3NAotbXNnaWQgInVuYWJsZSB0byB3cml0ZSBpbmRleCBmaWxlIgotbXNnc3RyICLQuNC90LTQtdC60YHRitGCINC90LUg0LzQvtC20LUg0LTQsCDQsdGK0LTQtSDQt9Cw0L/QuNGB0LDQvSIKLQotIzogYnVpbHRpbi9hbS5jOjEwOTgKKyM6IGJ1aWx0aW4vYW0uYzoxMDg0CiAjLCBjLWZvcm1hdAogbXNnaWQgIldoZW4geW91IGhhdmUgcmVzb2x2ZWQgdGhpcyBwcm9ibGVtLCBydW4gXCIlcyAtLWNvbnRpbnVlXCIuIgogbXNnc3RyICLQodC70LXQtCDQutC+0YDQuNCz0LjRgNCw0L3QtdGC0L4g0L3QsCDRgtC+0LfQuCDQv9GA0L7QsdC70LXQvCDQuNC30L/RitC70L3QtdGC0LUg4oCeJXMgLS1jb250aW51ZeKAnC4iCiAKLSM6IGJ1aWx0aW4vYW0uYzoxMDk5CisjOiBidWlsdGluL2FtLmM6MTA4NQogIywgYy1mb3JtYXQKIG1zZ2lkICJJZiB5b3UgcHJlZmVyIHRvIHNraXAgdGhpcyBwYXRjaCwgcnVuIFwiJXMgLS1za2lwXCIgaW5zdGVhZC4iCiBtc2dzdHIgItCQ0LrQviDQv9GA0LXQtNC/0L7Rh9C40YLQsNGC0LUg0LTQsCDQv9GA0LXRgdC60L7Rh9C40YLQtSDRgtCw0LfQuCDQutGA0YrQv9C60LAsINC40LfQv9GK0LvQvdC10YLQtSDigJ4lcyAtLXNraXDigJwuIgogCi0jOiBidWlsdGluL2FtLmM6MTEwMAorIzogYnVpbHRpbi9hbS5jOjEwODYKICMsIGMtZm9ybWF0CiBtc2dpZCAiVG8gcmVzdG9yZSB0aGUgb3JpZ2luYWwgYnJhbmNoIGFuZCBzdG9wIHBhdGNoaW5nLCBydW4gXCIlcyAtLWFib3J0XCIuIgogbXNnc3RyICLQl9CwINC00LAg0YHQtSDQstGK0YDQvdC10YLQtSDQutGK0Lwg0L/RitGA0LLQvtC90LDRh9Cw0LvQvdC+0YLQviDRgdGK0YHRgtC+0Y/QvdC40LUsINC40LfQv9GK0LvQvdC10YLQtSDigJ4lcyAtLWFib3J04oCcLiIKIAotIzogYnVpbHRpbi9hbS5jOjExODMKKyM6IGJ1aWx0aW4vYW0uYzoxMTY5CiBtc2dpZCAiUGF0Y2ggc2VudCB3aXRoIGZvcm1hdD1mbG93ZWQ7IHNwYWNlIGF0IHRoZSBlbmQgb2YgbGluZXMgbWlnaHQgYmUgbG9zdC4iCiBtc2dzdHIgIiIKICLQmtGA0YrQv9C60LDRgtCwINC1INC/0YDQsNGC0LXQvdCwINGBINGE0L7RgNC80LDRgtC40YDQsNC90LUg4oCeZm9ybWF0PWZsb3dlZOKAnC4gINCf0YDQsNC30L3QuNGC0LUg0LfQvdCw0YbQuCDQsiDQutGA0LDRjyDQvdCwICIKICLRgNC10LTQvtCy0LXRgtC1INC80L7QttC1INC00LAg0YHQtSDQt9Cw0LPRg9Cx0Y/Rgi4iCiAKLSM6IGJ1aWx0aW4vYW0uYzoxMjExCisjOiBidWlsdGluL2FtLmM6MTE5NwogbXNnaWQgIlBhdGNoIGlzIGVtcHR5LiIKIG1zZ3N0ciAi0JrRgNGK0L/QutCw0YLQsCDQtSDQv9GA0LDQt9C90LAuIgogCi0jOiBidWlsdGluL2FtLmM6MTI3NworIzogYnVpbHRpbi9hbS5jOjEyNjIKKyMsIGMtZm9ybWF0Cittc2dpZCAibWlzc2luZyBhdXRob3IgbGluZSBpbiBjb21taXQgJXMiCittc2dzdHIgItC70LjQv9GB0LLQsCDRgNC10LQg0LfQsCDQsNCy0YLQvtGA0YHRgtCy0L4g0LIg0L/QvtC00LDQstCw0L3QtdGC0L4g4oCeJXPigJwiCisKKyM6IGJ1aWx0aW4vYW0uYzoxMjY1CiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgaWRlbnQgbGluZTogJS4qcyIKIG1zZ3N0ciAi0LPRgNC10YjQtdC9INGA0LXQtCDRgSDQuNC00LXQvdGC0LjRh9C90L7RgdGCOiAlLipzIgogCi0jOiBidWlsdGluL2FtLmM6MTI5OQotIywgYy1mb3JtYXQKLW1zZ2lkICJ1bmFibGUgdG8gcGFyc2UgY29tbWl0ICVzIgotbXNnc3RyICLQv9C+0LTQsNCy0LDQvdC10YLQviDQvdC1INC80L7QttC1INC00LAg0LHRitC00LUg0LDQvdCw0LvQuNC30LjRgNCw0L3QvjogJXMiCi0KLSM6IGJ1aWx0aW4vYW0uYzoxNDk2CisjOiBidWlsdGluL2FtLmM6MTQ4NAogbXNnaWQgIlJlcG9zaXRvcnkgbGFja3MgbmVjZXNzYXJ5IGJsb2JzIHRvIGZhbGwgYmFjayBvbiAzLXdheSBtZXJnZS4iCiBtc2dzdHIgIiIKICLQkiDRhdGA0LDQvdC40LvQuNGJ0LXRgtC+INC70LjQv9GB0LLQsNGCINC90LXQvtCx0YXQvtC00LjQvNC40YLQtSDQvtCx0LXQutGC0LgtQkxPQiwg0LfQsCDQtNCwINGB0LUg0L/RgNC10LzQuNC90LUg0LrRitC8INGC0YDQvtC50L3QviAiCiAi0YHQu9C40LLQsNC90LUuIgogCi0jOiBidWlsdGluL2FtLmM6MTQ5OAorIzogYnVpbHRpbi9hbS5jOjE0ODYKIG1zZ2lkICJVc2luZyBpbmRleCBpbmZvIHRvIHJlY29uc3RydWN0IGEgYmFzZSB0cmVlLi4uIgogbXNnc3RyICLQkdCw0LfQvtCy0L7RgtC+INC00YrRgNCy0L4g0YHQtSDRgNC10LrQvtC90YHRgtGA0YPQuNGA0LAg0L7RgiDQuNC90YTQvtGA0LzQsNGG0LjRj9GC0LAg0LIg0LjQvdC00LXQutGB0LDigKYiCiAKLSM6IGJ1aWx0aW4vYW0uYzoxNTE3CisjOiBidWlsdGluL2FtLmM6MTUwNQogbXNnaWQgIiIKICJEaWQgeW91IGhhbmQgZWRpdCB5b3VyIHBhdGNoP1xuIgogIkl0IGRvZXMgbm90IGFwcGx5IHRvIGJsb2JzIHJlY29yZGVkIGluIGl0cyBpbmRleC4iCkBAIC05MDYwLDI0ICs5MDk1LDI0IEBACiAi0JrRgNGK0L/QutCw0YLQsCDQvdC1INC80L7QttC1INC00LAg0YHQtSDQv9GA0LjQu9C+0LbQuCDQutGK0Lwg0L7QsdC10LrRgtC40YLQtS1CTE9CINCyINC40L3QtNC10LrRgdCwLlxuIgogItCU0LAg0L3QtSDQsdC4INC00LAg0YHRgtC1INGPINGA0LXQtNCw0LrRgtC40YDQsNC70Lgg0L3QsCDRgNGK0LrQsD8iCiAKLSM6IGJ1aWx0aW4vYW0uYzoxNTIzCisjOiBidWlsdGluL2FtLmM6MTUxMQogbXNnaWQgIkZhbGxpbmcgYmFjayB0byBwYXRjaGluZyBiYXNlIGFuZCAzLXdheSBtZXJnZS4uLiIKIG1zZ3N0ciAi0J/RgNC10LzQuNC90LDQstCw0L3QtSDQutGK0Lwg0L/RgNC40LvQsNCz0LDQvdC1INC90LAg0LrRgNGK0L/QutCwINC60YrQvCDQsdCw0LfQsNGC0LAg0Lgg0YLRgNC+0LnQvdC+INGB0LvQuNCy0LDQvdC14oCmIgogCi0jOiBidWlsdGluL2FtLmM6MTU0OQorIzogYnVpbHRpbi9hbS5jOjE1MzcKIG1zZ2lkICJGYWlsZWQgdG8gbWVyZ2UgaW4gdGhlIGNoYW5nZXMuIgogbXNnc3RyICLQndC10YPRgdC/0LXRiNC90L4g0YHQu9C40LLQsNC90LUg0L3QsCDQv9GA0L7QvNC10L3QuNGC0LUuIgogCi0jOiBidWlsdGluL2FtLmM6MTU4MQorIzogYnVpbHRpbi9hbS5jOjE1NjkKIG1zZ2lkICJhcHBseWluZyB0byBhbiBlbXB0eSBoaXN0b3J5IgogbXNnc3RyICLQv9GA0LjQu9Cw0LPQsNC90LUg0LLRitGA0YXRgyDQv9GA0LDQt9C90LAg0LjRgdGC0L7RgNC40Y8iCiAKLSM6IGJ1aWx0aW4vYW0uYzoxNjI4IGJ1aWx0aW4vYW0uYzoxNjMyCisjOiBidWlsdGluL2FtLmM6MTYxNiBidWlsdGluL2FtLmM6MTYyMAogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgcmVzdW1lOiAlcyBkb2VzIG5vdCBleGlzdC4iCiBtc2dzdHIgItC90LUg0LzQvtC20LUg0LTQsCDRgdC1INC/0YDQvtC00YrQu9C20Lgg4oCUIOKAniVz4oCcINC90LUg0YHRitGJ0LXRgdGC0LLRg9Cy0LAuIgogCi0jOiBidWlsdGluL2FtLmM6MTY1MAorIzogYnVpbHRpbi9hbS5jOjE2MzgKIG1zZ2lkICJDb21taXQgQm9keSBpczoiCiBtc2dzdHIgItCi0Y/Qu9C+0YLQviDQvdCwINC60YDRitC/0LrQsNGC0LAg0LfQsCDQv9GA0LjQu9Cw0LPQsNC90LUg0LU6IgogCkBAIC05MDg1LDQwICs5MTIwLDQ0IEBACiAjLiBpbiB5b3VyIHRyYW5zbGF0aW9uLiBUaGUgcHJvZ3JhbSB3aWxsIG9ubHkgYWNjZXB0IEVuZ2xpc2gKICMuIGlucHV0IGF0IHRoaXMgcG9pbnQuCiAjLgotIzogYnVpbHRpbi9hbS5jOjE2NjAKKyM6IGJ1aWx0aW4vYW0uYzoxNjQ4CiAjLCBjLWZvcm1hdAogbXNnaWQgIkFwcGx5PyBbeV1lcy9bbl1vL1tlXWRpdC9bdl1pZXcgcGF0Y2gvW2FdY2NlcHQgYWxsOiAiCiBtc2dzdHIgIiIKICLQn9GA0LjQu9Cw0LPQsNC90LU/IOKAnnnigJwg4oCUINC00LAv4oCebuKAnCDigJQg0L3QtS/igJ5l4oCcIOKAlCDRgNC10LTQsNC60YLQuNGA0LDQvdC1L+KAnnbigJwg4oCUINC/0YDQtdCz0LvQtdC0L+KAnmHigJwg4oCUINC/0YDQuNC10LzQsNC90LUgIgogItC90LAg0LLRgdC40YfQutC+OiIKIAotIzogYnVpbHRpbi9hbS5jOjE3MTAKKyM6IGJ1aWx0aW4vYW0uYzoxNjk1IGJ1aWx0aW4vY29tbWl0LmM6Mzc0Cittc2dpZCAidW5hYmxlIHRvIHdyaXRlIGluZGV4IGZpbGUiCittc2dzdHIgItC40L3QtNC10LrRgdGK0YIg0L3QtSDQvNC+0LbQtSDQtNCwINCx0YrQtNC1INC30LDQv9C40YHQsNC9IgorCisjOiBidWlsdGluL2FtLmM6MTY5OQogIywgYy1mb3JtYXQKIG1zZ2lkICJEaXJ0eSBpbmRleDogY2Fubm90IGFwcGx5IHBhdGNoZXMgKGRpcnR5OiAlcykiCiBtc2dzdHIgIiIKICLQmNC90LTQtdC60YHRitGCINC90LUg0LUg0YfQuNGB0YI6INC60YDRitC/0LrQuNGC0LUg0L3QtSDQvNC+0LPQsNGCINC00LAg0LHRitC00LDRgiDQv9GA0LjQu9C+0LbQtdC90LggKNC30LDQvNGK0YDRgdC10L3QuCDRgdCwOiAlcykiCiAKLSM6IGJ1aWx0aW4vYW0uYzoxNzUwIGJ1aWx0aW4vYW0uYzoxODE4CisjOiBidWlsdGluL2FtLmM6MTczOSBidWlsdGluL2FtLmM6MTgwNwogIywgYy1mb3JtYXQKIG1zZ2lkICJBcHBseWluZzogJS4qcyIKIG1zZ3N0ciAi0J/RgNC40LvQsNCz0LDQvdC1OiAlLipzIgogCi0jOiBidWlsdGluL2FtLmM6MTc2NworIzogYnVpbHRpbi9hbS5jOjE3NTYKIG1zZ2lkICJObyBjaGFuZ2VzIC0tIFBhdGNoIGFscmVhZHkgYXBwbGllZC4iCiBtc2dzdHIgItCR0LXQtyDQv9GA0L7QvNC10L3QuCDigJQg0LrRgNGK0L/QutCw0YLQsCDQstC10YfQtSDQtSDQv9GA0LjQu9C+0LbQtdC90LAuIgogCi0jOiBidWlsdGluL2FtLmM6MTc3MworIzogYnVpbHRpbi9hbS5jOjE3NjIKICMsIGMtZm9ybWF0CiBtc2dpZCAiUGF0Y2ggZmFpbGVkIGF0ICVzICUuKnMiCiBtc2dzdHIgItCd0LXRg9GB0L/QtdGI0L3QviDQv9GA0LjQu9Cw0LPQsNC90LUg0L3QsCDQutGA0YrQv9C60LAg0L/RgNC4ICVzICUuKnPigJwiCiAKLSM6IGJ1aWx0aW4vYW0uYzoxNzc3CisjOiBidWlsdGluL2FtLmM6MTc2NgogbXNnaWQgIlVzZSAnZ2l0IGFtIC0tc2hvdy1jdXJyZW50LXBhdGNoJyB0byBzZWUgdGhlIGZhaWxlZCBwYXRjaCIKIG1zZ3N0ciAiIgogItCX0LAg0LTQsCDQstC40LTQuNGC0LUg0L3QtdGD0YHQv9C10YjQvdC+INC/0YDQuNC70L7QttC10L3QuCDQutGA0YrQv9C60LgsINC40LfQv9C+0LvQt9Cy0LDQudGC0LUg0L7Qv9GG0LjRj9GC0LAg4oCeZ2l0IGFtIC0tc2hvdy0iCiAiY3VycmVudC1wYXRjaOKAnCB0byBzZWUgdGhlIGZhaWxlZCBwYXRjaCIKIAotIzogYnVpbHRpbi9hbS5jOjE4MjEKKyM6IGJ1aWx0aW4vYW0uYzoxODEwCiBtc2dpZCAiIgogIk5vIGNoYW5nZXMgLSBkaWQgeW91IGZvcmdldCB0byB1c2UgJ2dpdCBhZGQnP1xuIgogIklmIHRoZXJlIGlzIG5vdGhpbmcgbGVmdCB0byBzdGFnZSwgY2hhbmNlcyBhcmUgdGhhdCBzb21ldGhpbmcgZWxzZVxuIgpAQCAtOTEyOCw3ICs5MTY3LDcgQEAKICLQkNC60L4g0L3Rj9C80LAg0LTRgNGD0LPQsCDQv9GA0L7QvNGP0L3QsCDQt9CwINCy0LrQu9GO0YfQstCw0L3QtSDQsiDQuNC90LTQtdC60YHQsCwg0L3QsNC5LdCy0LXRgNC+0Y/RgtC90L4g0L3Rj9C60L7RjyDQtNGA0YPQs9CwXG4iCiAi0LrRgNGK0L/QutCwINC1INC00L7QstC10LvQsCDQtNC+INGB0YrRidC40YLQtSDQv9GA0L7QvNC10L3QuCDQuCDQsiDRgtCw0LrRitCyINGB0LvRg9GH0LDQuSDQv9GA0L7RgdGC0L4g0L/RgNC+0L/Rg9GB0L3QtdGC0LUg0YLQsNC30LguIgogCi0jOiBidWlsdGluL2FtLmM6MTgyOAorIzogYnVpbHRpbi9hbS5jOjE4MTcKIG1zZ2lkICIiCiAiWW91IHN0aWxsIGhhdmUgdW5tZXJnZWQgcGF0aHMgaW4geW91ciBpbmRleC5cbiIKICJZb3Ugc2hvdWxkICdnaXQgYWRkJyBlYWNoIGZpbGUgd2l0aCByZXNvbHZlZCBjb25mbGljdHMgdG8gbWFyayB0aGVtIGFzICIKQEAgLTkxMzksMTcgKzkxNzgsMTcgQEAKICLQodC70LXQtCDQutC+0YDQtdC60YbQuNGPINC90LAg0LrQvtC90YTQu9C40LrRgtC40YLQtSDQuNC30L/RitC70L3QtdGC0LUg4oCeZ2l0IGFkZOKAnCDQstGK0YDRhdGDINC/0L7Qv9GA0LDQstC10L3QuNGC0LUg0YTQsNC50LvQvtCy0LUuXG4iCiAi0JfQsCDQtNCwINC/0YDQuNC10LzQtdGC0LUg4oCe0LjQt9GC0YDQuNGC0Lgg0L7RgiDRgtGP0YXigJwsINC40LfQv9GK0LvQvdC10YLQtSDigJ5naXQgcm3igJwg0LLRitGA0YXRgyDQuNC30YLRgNC40YLQuNGC0LUg0YTQsNC50LvQvtCy0LUuIgogCi0jOiBidWlsdGluL2FtLmM6MTkzNSBidWlsdGluL2FtLmM6MTkzOSBidWlsdGluL2FtLmM6MTk1MSBidWlsdGluL3Jlc2V0LmM6MzI5CisjOiBidWlsdGluL2FtLmM6MTkyNCBidWlsdGluL2FtLmM6MTkyOCBidWlsdGluL2FtLmM6MTk0MCBidWlsdGluL3Jlc2V0LmM6MzI5CiAjOiBidWlsdGluL3Jlc2V0LmM6MzM3CiAjLCBjLWZvcm1hdAogbXNnaWQgIkNvdWxkIG5vdCBwYXJzZSBvYmplY3QgJyVzJy4iCiBtc2dzdHIgIuKAniVz4oCcINC90LUg0LUg0YDQsNC30L/QvtC30L3QsNGCINC60LDRgtC+INC+0LHQtdC60YIuIgogCi0jOiBidWlsdGluL2FtLmM6MTk4NworIzogYnVpbHRpbi9hbS5jOjE5NzYKIG1zZ2lkICJmYWlsZWQgdG8gY2xlYW4gaW5kZXgiCiBtc2dzdHIgItC40L3QtNC10LrRgdGK0YIg0L3QtSDQvNC+0LbQtSDQtNCwINCx0YrQtNC1INC40LfRh9C40YHRgtC10L0iCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMDMxCisjOiBidWlsdGluL2FtLmM6MjAyMAogbXNnaWQgIiIKICJZb3Ugc2VlbSB0byBoYXZlIG1vdmVkIEhFQUQgc2luY2UgdGhlIGxhc3QgJ2FtJyBmYWlsdXJlLlxuIgogIk5vdCByZXdpbmRpbmcgdG8gT1JJR19IRUFEIgpAQCAtOTE2MCwxNDkgKzkxOTksMTQ5IEBACiAi0YHQvtGH0Lgg0LrRitC8XG4iCiAi4oCeT1JJR19IRUFE4oCcIgogCi0jOiBidWlsdGluL2FtLmM6MjEyOAorIzogYnVpbHRpbi9hbS5jOjIxMTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiSW52YWxpZCB2YWx1ZSBmb3IgLS1wYXRjaC1mb3JtYXQ6ICVzIgogbXNnc3RyICLQndC10L/RgNCw0LLQuNC70L3QsCDRgdGC0L7QudC90L7RgdGCINC30LAg4oCeLS1wYXRjaC1mb3JtYXTigJw6IOKAniVz4oCcIgogCi0jOiBidWlsdGluL2FtLmM6MjE2NAorIzogYnVpbHRpbi9hbS5jOjIxNTMKIG1zZ2lkICJnaXQgYW0gWzxvcHRpb25zPl0gWyg8bWJveD4gfCA8TWFpbGRpcj4pLi4uXSIKIG1zZ3N0ciAiZ2l0IGFtIFvQntCf0KbQmNCv4oCmXSBbKNCk0JDQmdCbX9ChX9Cf0J7QqdCQfNCU0JjQoNCV0JrQotCe0KDQmNCvX9ChX9Cf0J7QqdCQKeKApl0iCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMTY1CisjOiBidWlsdGluL2FtLmM6MjE1NAogbXNnaWQgImdpdCBhbSBbPG9wdGlvbnM+XSAoLS1jb250aW51ZSB8IC0tc2tpcCB8IC0tYWJvcnQpIgogbXNnc3RyICJnaXQgYW0gW9Ce0J/QptCY0K/igKZdICgtLWNvbnRpbnVlIHwgLS1xdWl0IHwgLS1hYm9ydCkiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMTcxCisjOiBidWlsdGluL2FtLmM6MjE2MAogbXNnaWQgInJ1biBpbnRlcmFjdGl2ZWx5IgogbXNnc3RyICLQuNC90YLQtdGA0LDQutGC0LjQstC90LAg0YDQsNCx0L7RgtCwIgogCi0jOiBidWlsdGluL2FtLmM6MjE3MworIzogYnVpbHRpbi9hbS5jOjIxNjIKIG1zZ2lkICJoaXN0b3JpY2FsIG9wdGlvbiAtLSBuby1vcCIKIG1zZ3N0ciAi0LjQt9C+0YHRgtCw0LLQtdC90LAg0L7Qv9GG0LjRjywg0YHRitGJ0LXRgdGC0LLRg9Cy0LAg0L/QviDQuNGB0YLQvtGA0LjRh9C10YHQutC4INC/0YDQuNGH0LjQvdC4LCDQvdC40YnQviDQvdC1INC/0YDQsNCy0LgiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMTc1CisjOiBidWlsdGluL2FtLmM6MjE2NAogbXNnaWQgImFsbG93IGZhbGwgYmFjayBvbiAzd2F5IG1lcmdpbmcgaWYgbmVlZGVkIgogbXNnc3RyICLQtNCwINGB0LUg0L/RgNC10LzQuNC90LDQstCwINC60YrQvCDRgtGA0L7QudC90L4g0YHQu9C40LLQsNC90LUg0L/RgNC4INC90YPQttC00LAuIgogCi0jOiBidWlsdGluL2FtLmM6MjE3NiBidWlsdGluL2luaXQtZGIuYzo0OTQgYnVpbHRpbi9wcnVuZS1wYWNrZWQuYzo1OAotIzogYnVpbHRpbi9yZXBhY2suYzoyOTYgYnVpbHRpbi9zdGFzaC5jOjgwNgorIzogYnVpbHRpbi9hbS5jOjIxNjUgYnVpbHRpbi9pbml0LWRiLmM6NDk0IGJ1aWx0aW4vcHJ1bmUtcGFja2VkLmM6NTgKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6Mjk3IGJ1aWx0aW4vc3Rhc2guYzo4MTIKIG1zZ2lkICJiZSBxdWlldCIKIG1zZ3N0ciAi0LHQtdC3INC40LfQstC10LbQtNCw0L3QtSDQvdCwINC40L3RhNC+0YDQvNCw0YbQuNGPIgogCi0jOiBidWlsdGluL2FtLmM6MjE3OAorIzogYnVpbHRpbi9hbS5jOjIxNjcKIG1zZ2lkICJhZGQgYSBTaWduZWQtb2ZmLWJ5IGxpbmUgdG8gdGhlIGNvbW1pdCBtZXNzYWdlIgogbXNnc3RyICLQtNC+0LHQsNCy0Y/QvdC1INC90LAg0YDQtdC0INC30LAg0L/QvtC00L/QuNGBIOKAnlNpZ25lZC1vZmYtYnnigJwg0LIg0YHRitC+0LHRidC10L3QuNC10YLQviDQt9CwINC/0L7QtNCw0LLQsNC90LUiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMTgxCisjOiBidWlsdGluL2FtLmM6MjE3MAogbXNnaWQgInJlY29kZSBpbnRvIHV0ZjggKGRlZmF1bHQpIgogbXNnc3RyICLQv9GA0LXQutC+0LTQuNGA0LDQvdC1INCyIFVURi04ICjRgdGC0LDQvdC00LDRgNGC0L3QvikiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMTgzCisjOiBidWlsdGluL2FtLmM6MjE3MgogbXNnaWQgInBhc3MgLWsgZmxhZyB0byBnaXQtbWFpbGluZm8iCiBtc2dzdHIgItC/0L7QtNCw0LLQsNC90LUg0L3QsCDQvtC/0YbQuNGP0YLQsCDigJ4ta+KAnCDQvdCwINC60L7QvNCw0L3QtNCw0YLQsCDigJ5naXQtbWFpbGluZm/igJwiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMTg1CisjOiBidWlsdGluL2FtLmM6MjE3NAogbXNnaWQgInBhc3MgLWIgZmxhZyB0byBnaXQtbWFpbGluZm8iCiBtc2dzdHIgItC/0L7QtNCw0LLQsNC90LUg0L3QsCDQvtC/0YbQuNGP0YLQsCDigJ4tYuKAnCDQvdCwINC60L7QvNCw0L3QtNCw0YLQsCDigJ5naXQtbWFpbGluZm/igJwiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMTg3CisjOiBidWlsdGluL2FtLmM6MjE3NgogbXNnaWQgInBhc3MgLW0gZmxhZyB0byBnaXQtbWFpbGluZm8iCiBtc2dzdHIgItC/0L7QtNCw0LLQsNC90LUg0L3QsCDQvtC/0YbQuNGP0YLQsCDigJ4tbeKAnCDQvdCwINC60L7QvNCw0L3QtNCw0YLQsCDigJ5naXQtbWFpbGluZm/igJwiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMTg5CisjOiBidWlsdGluL2FtLmM6MjE3OAogbXNnaWQgInBhc3MgLS1rZWVwLWNyIGZsYWcgdG8gZ2l0LW1haWxzcGxpdCBmb3IgbWJveCBmb3JtYXQiCiBtc2dzdHIgIiIKICLQv9C+0LTQsNCy0LDQvdC1INC90LAg0L7Qv9GG0LjRj9GC0LAg4oCeLS1rZWVwLWNy4oCcINC90LAg0LrQvtC80LDQvdC00LDRgtCwIOKAnmdpdC1tYWlsc3BsaXTigJwg0LfQsCDRhNC+0YDQvNCw0YIg4oCebWJveOKAnCIKIAotIzogYnVpbHRpbi9hbS5jOjIxOTIKKyM6IGJ1aWx0aW4vYW0uYzoyMTgxCiBtc2dpZCAiZG8gbm90IHBhc3MgLS1rZWVwLWNyIGZsYWcgdG8gZ2l0LW1haWxzcGxpdCBpbmRlcGVuZGVudCBvZiBhbS5rZWVwY3IiCiBtc2dzdHIgIiIKICLQsdC10Lcg0L/QvtC00LDQstCw0L3QtSDQvdCwINC+0L/RhtC40Y/RgtCwIOKAni0ta2VlcC1jcuKAnCDQvdCwINC60L7QvNCw0L3QtNCw0YLQsCDigJ5naXQtbWFpbHNwbGl04oCcINC90LXQt9Cw0LLQuNGB0LjQvNC+ICIKICLQvtGCIOKAnmFtLmtlZXBjcuKAnCIKIAotIzogYnVpbHRpbi9hbS5jOjIxOTUKKyM6IGJ1aWx0aW4vYW0uYzoyMTg0CiBtc2dpZCAic3RyaXAgZXZlcnl0aGluZyBiZWZvcmUgYSBzY2lzc29ycyBsaW5lIgogbXNnc3RyICLQv9GA0L7Qv9GD0YHQutCw0L3QtSDQvdCwINCy0YHQuNGH0LrQviDQv9GA0LXQtNC4INGA0LXQtNCwINC30LAg0L7RgtGA0Y/Qt9Cy0LDQvdC1IgogCi0jOiBidWlsdGluL2FtLmM6MjE5NyBidWlsdGluL2FtLmM6MjIwMCBidWlsdGluL2FtLmM6MjIwMyBidWlsdGluL2FtLmM6MjIwNgotIzogYnVpbHRpbi9hbS5jOjIyMDkgYnVpbHRpbi9hbS5jOjIyMTIgYnVpbHRpbi9hbS5jOjIyMTUgYnVpbHRpbi9hbS5jOjIyMTgKLSM6IGJ1aWx0aW4vYW0uYzoyMjI0CisjOiBidWlsdGluL2FtLmM6MjE4NiBidWlsdGluL2FtLmM6MjE4OSBidWlsdGluL2FtLmM6MjE5MiBidWlsdGluL2FtLmM6MjE5NQorIzogYnVpbHRpbi9hbS5jOjIxOTggYnVpbHRpbi9hbS5jOjIyMDEgYnVpbHRpbi9hbS5jOjIyMDQgYnVpbHRpbi9hbS5jOjIyMDcKKyM6IGJ1aWx0aW4vYW0uYzoyMjEzCiBtc2dpZCAicGFzcyBpdCB0aHJvdWdoIGdpdC1hcHBseSIKIG1zZ3N0ciAi0L/RgNC10LrQsNGA0LLQsNC90LUg0L/RgNC10Lcg4oCeZ2l0LWFwcGx54oCcIgogCi0jOiBidWlsdGluL2FtLmM6MjIxNCBidWlsdGluL2NvbW1pdC5jOjEzNjggYnVpbHRpbi9mbXQtbWVyZ2UtbXNnLmM6NjcxCi0jOiBidWlsdGluL2ZtdC1tZXJnZS1tc2cuYzo2NzQgYnVpbHRpbi9ncmVwLmM6ODgxIGJ1aWx0aW4vbWVyZ2UuYzoyNDkKLSM6IGJ1aWx0aW4vcHVsbC5jOjE1OSBidWlsdGluL3B1bGwuYzoyMTggYnVpbHRpbi9yZWJhc2UuYzoxNDE4Ci0jOiBidWlsdGluL3JlcGFjay5jOjMwNyBidWlsdGluL3JlcGFjay5jOjMxMSBidWlsdGluL3JlcGFjay5jOjMxMworIzogYnVpbHRpbi9hbS5jOjIyMDMgYnVpbHRpbi9jb21taXQuYzoxMzY4IGJ1aWx0aW4vZm10LW1lcmdlLW1zZy5jOjY3MQorIzogYnVpbHRpbi9mbXQtbWVyZ2UtbXNnLmM6Njc0IGJ1aWx0aW4vZ3JlcC5jOjg4MyBidWlsdGluL21lcmdlLmM6MjQ5CisjOiBidWlsdGluL3B1bGwuYzoxNjAgYnVpbHRpbi9wdWxsLmM6MjE5IGJ1aWx0aW4vcmViYXNlLmM6MTQ0MgorIzogYnVpbHRpbi9yZXBhY2suYzozMDggYnVpbHRpbi9yZXBhY2suYzozMTIgYnVpbHRpbi9yZXBhY2suYzozMTQKICM6IGJ1aWx0aW4vc2hvdy1icmFuY2guYzo2NTAgYnVpbHRpbi9zaG93LXJlZi5jOjE3MiBidWlsdGluL3RhZy5jOjQwMwotIzogcGFyc2Utb3B0aW9ucy5oOjE0MSBwYXJzZS1vcHRpb25zLmg6MTYyIHBhcnNlLW9wdGlvbnMuaDozMTIKKyM6IHBhcnNlLW9wdGlvbnMuaDoxNTAgcGFyc2Utb3B0aW9ucy5oOjE3MSBwYXJzZS1vcHRpb25zLmg6MzEyCiBtc2dpZCAibiIKIG1zZ3N0ciAi0JHQoNCe0JkiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMjIwIGJ1aWx0aW4vYnJhbmNoLmM6NjYxIGJ1aWx0aW4vZm9yLWVhY2gtcmVmLmM6MzgKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU1NCBidWlsdGluL3RhZy5jOjQzNyBidWlsdGluL3ZlcmlmeS10YWcuYzozOAorIzogYnVpbHRpbi9hbS5jOjIyMDkgYnVpbHRpbi9icmFuY2guYzo2NjEgYnVpbHRpbi9mb3ItZWFjaC1yZWYuYzozOAorIzogYnVpbHRpbi9yZXBsYWNlLmM6NTU1IGJ1aWx0aW4vdGFnLmM6NDM3IGJ1aWx0aW4vdmVyaWZ5LXRhZy5jOjM4CiBtc2dpZCAiZm9ybWF0IgogbXNnc3RyICLQpNCe0KDQnNCQ0KIiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMjIxCisjOiBidWlsdGluL2FtLmM6MjIxMAogbXNnaWQgImZvcm1hdCB0aGUgcGF0Y2goZXMpIGFyZSBpbiIKIG1zZ3N0ciAi0YTQvtGA0LzQsNGCINC90LAg0LrRgNGK0L/QutC40YLQtSIKIAotIzogYnVpbHRpbi9hbS5jOjIyMjcKKyM6IGJ1aWx0aW4vYW0uYzoyMjE2CiBtc2dpZCAib3ZlcnJpZGUgZXJyb3IgbWVzc2FnZSB3aGVuIHBhdGNoIGZhaWx1cmUgb2NjdXJzIgogbXNnc3RyICLQuNC30LHRgNCw0L3QviDQvtGCINCy0LDRgSDRgdGK0L7QsdGJ0LXQvdC40LUg0LfQsCDQs9GA0LXRiNC60LAg0L/RgNC4INC/0YDQuNC70LDQs9Cw0L3QtSDQvdCwINC60YDRitC/0LrQuCIKIAotIzogYnVpbHRpbi9hbS5jOjIyMjkKKyM6IGJ1aWx0aW4vYW0uYzoyMjE4CiBtc2dpZCAiY29udGludWUgYXBwbHlpbmcgcGF0Y2hlcyBhZnRlciByZXNvbHZpbmcgYSBjb25mbGljdCIKIG1zZ3N0ciAi0L/RgNC+0LTRitC70LbQsNCy0LDQvdC1INC90LAg0L/RgNC40LvQsNCz0LDQvdC10YLQviDQvdCwINC60YDRitC/0LrQuCDRgdC70LXQtCDQutC+0YDQuNCz0LjRgNCw0L3QtdGC0L4g0L3QsCDQutC+0L3RhNC70LjQutGCIgogCi0jOiBidWlsdGluL2FtLmM6MjIzMgorIzogYnVpbHRpbi9hbS5jOjIyMjEKIG1zZ2lkICJzeW5vbnltcyBmb3IgLS1jb250aW51ZSIKIG1zZ3N0ciAi0L/RgdC10LLQtNC+0L3QuNC80Lgg0L3QsCDigJ4tLWNvbnRpbnVl4oCcIgogCi0jOiBidWlsdGluL2FtLmM6MjIzNQorIzogYnVpbHRpbi9hbS5jOjIyMjQKIG1zZ2lkICJza2lwIHRoZSBjdXJyZW50IHBhdGNoIgogbXNnc3RyICLQv9GA0LXRgdC60LDRh9Cw0L3QtSDQvdCwINGC0LXQutGD0YnQsNGC0LAg0LrRgNGK0L/QutCwIgogCi0jOiBidWlsdGluL2FtLmM6MjIzOAorIzogYnVpbHRpbi9hbS5jOjIyMjcKIG1zZ2lkICJyZXN0b3JlIHRoZSBvcmlnaW5hbCBicmFuY2ggYW5kIGFib3J0IHRoZSBwYXRjaGluZyBvcGVyYXRpb24uIgogbXNnc3RyICIiCiAi0LLRitC30YHRgtCw0L3QvtCy0Y/QstCw0L3QtSDQvdCwINC/0YrRgNCy0L7QvdCw0YfQsNC70L3QvtGC0L4g0YHRitGB0YLQvtGP0L3QuNC1INC90LAg0LrQu9C+0L3QsCDQuCDQv9GA0LXRg9GB0YLQsNC90L7QstGP0LLQsNC90LUg0L3QsCAiCiAi0L/RgNC40LvQsNCz0LDQvdC10YLQviDQvdCwINC60YDRitC/0LrQsNGC0LAuIgogCi0jOiBidWlsdGluL2FtLmM6MjI0MQorIzogYnVpbHRpbi9hbS5jOjIyMzAKIG1zZ2lkICJhYm9ydCB0aGUgcGF0Y2hpbmcgb3BlcmF0aW9uIGJ1dCBrZWVwIEhFQUQgd2hlcmUgaXQgaXMuIgogbXNnc3RyICIiCiAi0L/RgNC10YPRgdGC0LDQvdC+0LLRj9Cy0LDQvdC1INC90LAg0L/RgNC40LvQsNCz0LDQvdC10YLQviDQvdCwINC60YDRitC/0LrQsNGC0LAg0LHQtdC3INC/0YDQvtC80Y/QvdCwINC60YrQvCDQutC+0LUg0YHQvtGH0Lgg4oCeSEVBROKAnC4iCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMjQ0CisjOiBidWlsdGluL2FtLmM6MjIzMwogbXNnaWQgInNob3cgdGhlIHBhdGNoIGJlaW5nIGFwcGxpZWQuIgogbXNnc3RyICLQv9C+0LrQsNC30LLQsNC90LUg0L3QsCDQv9GA0LjQu9Cw0LPQsNC90LDRgtCwINC60YDRitC/0LrQsC4iCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMjQ4CisjOiBidWlsdGluL2FtLmM6MjIzNwogbXNnaWQgImxpZSBhYm91dCBjb21taXR0ZXIgZGF0ZSIKIG1zZ3N0ciAi0LTQsNGC0LAg0LfQsCDQv9C+0LTQsNCy0LDQvdC1INGA0LDQt9C70LjRh9C90LAg0L7RgiDQv9GK0YDQstC+0L3QsNGH0LDQu9C90LDRgtCwIgogCi0jOiBidWlsdGluL2FtLmM6MjI1MAorIzogYnVpbHRpbi9hbS5jOjIyMzkKIG1zZ2lkICJ1c2UgY3VycmVudCB0aW1lc3RhbXAgZm9yIGF1dGhvciBkYXRlIgogbXNnc3RyICLQuNC30L/QvtC70LfQstCw0L3QtSDQvdCwINGC0LXQutGD0YnQvtGC0L4g0LLRgNC10LzQtSDQutCw0YLQviDRgtC+0LLQsCDQt9CwINCw0LLRgtC+0YAiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMjUyIGJ1aWx0aW4vY29tbWl0LXRyZWUuYzoxMjAgYnVpbHRpbi9jb21taXQuYzoxNTExCi0jOiBidWlsdGluL21lcmdlLmM6Mjg2IGJ1aWx0aW4vcHVsbC5jOjE5MyBidWlsdGluL3JlYmFzZS5jOjQ4OQotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDU5IGJ1aWx0aW4vcmV2ZXJ0LmM6MTE3IGJ1aWx0aW4vdGFnLmM6NDE4CisjOiBidWlsdGluL2FtLmM6MjI0MSBidWlsdGluL2NvbW1pdC10cmVlLmM6MTIwIGJ1aWx0aW4vY29tbWl0LmM6MTUxMQorIzogYnVpbHRpbi9tZXJnZS5jOjI4NiBidWlsdGluL3B1bGwuYzoxOTQgYnVpbHRpbi9yZWJhc2UuYzo0OTAKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ4MyBidWlsdGluL3JldmVydC5jOjExNyBidWlsdGluL3RhZy5jOjQxOAogbXNnaWQgImtleS1pZCIKIG1zZ3N0ciAi0JjQlNCV0J3QotCY0KTQmNCa0JDQotCe0KBf0J3QkF/QmtCb0K7QpyIKIAotIzogYnVpbHRpbi9hbS5jOjIyNTMgYnVpbHRpbi9yZWJhc2UuYzo0OTAgYnVpbHRpbi9yZWJhc2UuYzoxNDYwCisjOiBidWlsdGluL2FtLmM6MjI0MiBidWlsdGluL3JlYmFzZS5jOjQ5MSBidWlsdGluL3JlYmFzZS5jOjE0ODQKIG1zZ2lkICJHUEctc2lnbiBjb21taXRzIgogbXNnc3RyICLQv9C+0LTQv9C40YHQstCw0L3QtSDQvdCwINC/0L7QtNCw0LLQsNC90LjRj9GC0LAg0YEgR1BHIgogCi0jOiBidWlsdGluL2FtLmM6MjI1NgorIzogYnVpbHRpbi9hbS5jOjIyNDUKIG1zZ2lkICIoaW50ZXJuYWwgdXNlIGZvciBnaXQtcmViYXNlKSIKIG1zZ3N0ciAiKNC/0L7Qu9C30LLQsCDRgdC1INCy0YrRgtGA0LXRiNC90L4g0LfQsCDigJ5naXQtcmViYXNl4oCcKSIKIAotIzogYnVpbHRpbi9hbS5jOjIyNzQKKyM6IGJ1aWx0aW4vYW0uYzoyMjYzCiBtc2dpZCAiIgogIlRoZSAtYi8tLWJpbmFyeSBvcHRpb24gaGFzIGJlZW4gYSBuby1vcCBmb3IgbG9uZyB0aW1lLCBhbmRcbiIKICJpdCB3aWxsIGJlIHJlbW92ZWQuIFBsZWFzZSBkbyBub3QgdXNlIGl0IGFueW1vcmUuIgpAQCAtOTMxMCwxOCArOTM0OSwxOCBAQAogItCe0L/RhtC40LjRgtC1IOKAni1i4oCcL+KAni0tYmluYXJ54oCcINC+0YLQtNCw0LLQvdCwINC90LUg0L/RgNCw0LLRj9GCINC90LjRidC+INC4XG4iCiAi0YnQtSDQsdGK0LTQsNGCINC/0YDQtdC80LDRhdC90LDRgtC4INCyINCx0YrQtNC10YnQtS4gINCd0LUg0LPQuCDQv9C+0LvQt9Cy0LDQudGC0LUuIgogCi0jOiBidWlsdGluL2FtLmM6MjI4MQorIzogYnVpbHRpbi9hbS5jOjIyNzAKIG1zZ2lkICJmYWlsZWQgdG8gcmVhZCB0aGUgaW5kZXgiCiBtc2dzdHIgItC90LXRg9GB0L/QtdGI0L3QviDQuNC30YfQuNGC0LDQvdC1INC90LAg0LjQvdC00LXQutGB0LAiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMjk2CisjOiBidWlsdGluL2FtLmM6MjI4NQogIywgYy1mb3JtYXQKIG1zZ2lkICJwcmV2aW91cyByZWJhc2UgZGlyZWN0b3J5ICVzIHN0aWxsIGV4aXN0cyBidXQgbWJveCBnaXZlbi4iCiBtc2dzdHIgIiIKICLQv9GA0LXQtNC40YjQvdCw0YLQsCDQtNC40YDQtdC60YLQvtGA0LjRjyDQt9CwINC/0YDQtdCx0LDQt9C40YDQsNC90LUg4oCeJXPigJwg0LLRgdC1INC+0YnQtSDRgdGK0YnQtdGB0YLQstGD0LLQsCwg0LAg0LUg0LfQsNC00LDQtNC10L0gIgogItGE0LDQudC7IOKAnm1ib3jigJwuIgogCi0jOiBidWlsdGluL2FtLmM6MjMyMAorIzogYnVpbHRpbi9hbS5jOjIzMDkKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlN0cmF5ICVzIGRpcmVjdG9yeSBmb3VuZC5cbiIKQEAgLTkzMzAsMTEgKzkzNjksMTEgQEAKICLQntGC0LrRgNC40YLQsCDQtSDQuNC30LvQuNGI0L3QsCDQtNC40YDQtdC60YLQvtGA0LjRjyDigJ4lc+KAnC5cbiIKICLQnNC+0LbQtdGC0LUg0LTQsCDRjyDQuNC30YLRgNC40LXRgtC1INGBINC60L7QvNCw0L3QtNCw0YLQsCDigJ5naXQgYW0gLS1hYm9ydOKAnC4iCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMzI2CisjOiBidWlsdGluL2FtLmM6MjMxNQogbXNnaWQgIlJlc29sdmUgb3BlcmF0aW9uIG5vdCBpbiBwcm9ncmVzcywgd2UgYXJlIG5vdCByZXN1bWluZy4iCiBtc2dzdHIgItCSINC80L7QvNC10L3RgtCwINC90LUg0YLQtdGH0LUg0L7Qv9C10YDQsNGG0LjRjyDQv9C+INC60L7RgNC40LPQuNGA0LDQvdC1INC4INC90Y/QvNCwINC60LDQuiDQtNCwINGB0LUg0L/RgNC+0LTRitC70LbQuC4iCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMzM2CisjOiBidWlsdGluL2FtLmM6MjMyNQogbXNnaWQgImludGVyYWN0aXZlIG1vZGUgcmVxdWlyZXMgcGF0Y2hlcyBvbiB0aGUgY29tbWFuZCBsaW5lIgogbXNnc3RyICLQuNC90YLQtdGA0LDQutGC0LjQstC90LjRj9GCINGA0LXQttC40Lwg0LjQt9C40YHQutCy0LAg0LrRgNGK0L/QutC4INC90LAg0LrQvtC80LDQvdC00L3QuNGPINGA0LXQtCIKIApAQCAtOTY1MiwxNzEgKzk2OTEsMTcxIEBACiBtc2dpZCAiLS1iaXNlY3QtdGVybXMgcmVxdWlyZXMgMCBvciAxIGFyZ3VtZW50IgogbXNnc3RyICLQvtC/0YbQuNGP0YLQsCDigJ4tLWJpc2VjdC10ZXJtc+KAnCDQuNC30LjRgdC60LLQsCAwINC40LvQuCAxINCw0YDQs9GD0LzQtdC90YLQsCIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjMyCisjOiBidWlsdGluL2JsYW1lLmM6MzEKIG1zZ2lkICJnaXQgYmxhbWUgWzxvcHRpb25zPl0gWzxyZXYtb3B0cz5dIFs8cmV2Pl0gWy0tXSA8ZmlsZT4iCiBtc2dzdHIgImdpdCBibGFtZSBb0J7Qn9Cm0JjQr+KApl0gW9Ce0J/QptCY0K9f0JfQkF/QktCV0KDQodCY0K/QotCQ4oCmXSBb0JLQldCg0KHQmNCvXSBbLS1dINCk0JDQmdCbIgogCi0jOiBidWlsdGluL2JsYW1lLmM6MzcKKyM6IGJ1aWx0aW4vYmxhbWUuYzozNgogbXNnaWQgIjxyZXYtb3B0cz4gYXJlIGRvY3VtZW50ZWQgaW4gZ2l0LXJldi1saXN0KDEpIgogbXNnc3RyICLQntCf0KbQmNCY0YLQtV/Ql9CQX9CS0JXQoNCh0JjQr9Ci0JAg0YHQsCDQtNC+0LrRg9C80LXQvdGC0LjRgNCw0L3QuCDQsiDRgNGK0LrQvtCy0L7QtNGB0YLQstC+0YLQviBnaXQtcmV2LWxpc3QoMSkiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo0MTAKKyM6IGJ1aWx0aW4vYmxhbWUuYzo0MDkKICMsIGMtZm9ybWF0CiBtc2dpZCAiZXhwZWN0aW5nIGEgY29sb3I6ICVzIgogbXNnc3RyICLRgtGA0Y/QsdCy0LAg0LTQsCDQtSDRhtCy0Y/RgjogJXMiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo0MTcKKyM6IGJ1aWx0aW4vYmxhbWUuYzo0MTYKIG1zZ2lkICJtdXN0IGVuZCB3aXRoIGEgY29sb3IiCiBtc2dzdHIgItGC0YDRj9Cx0LLQsCDQtNCwINC30LDQstGK0YDRiNCy0LAg0YEg0YbQstGP0YIiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo3MzAKKyM6IGJ1aWx0aW4vYmxhbWUuYzo3MjkKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBjb2xvciAnJXMnIGluIGNvbG9yLmJsYW1lLnJlcGVhdGVkTGluZXMiCiBtc2dzdHIgItC90LXQv9GA0LDQstC40LvQtdC9INGG0LLRj9GCIOKAniVz4oCcINCyIOKAnmNvbG9yLmJsYW1lLnJlcGVhdGVkTGluZXPigJwiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo3NDgKKyM6IGJ1aWx0aW4vYmxhbWUuYzo3NDcKIG1zZ2lkICJpbnZhbGlkIHZhbHVlIGZvciBibGFtZS5jb2xvcmluZyIKIG1zZ3N0ciAi0L3QtdC/0YDQsNCy0LjQu9C90LAg0YHRgtC+0LnQvdC+0YHRgiDQt9CwIOKAnmJsYW1lLmNvbG9yaW5n4oCcIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODIzCisjOiBidWlsdGluL2JsYW1lLmM6ODIyCiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCBmaW5kIHJldmlzaW9uICVzIHRvIGlnbm9yZSIKIG1zZ3N0ciAi0LLQtdGA0YHQuNGP0YLQsCDQt9CwINC/0YDQtdGB0LrQsNGH0LDQvdC1IOKAniVz4oCcINC90LUg0LzQvtC20LUg0LTQsCDQsdGK0LTQtSDQvtGC0LrRgNC40YLQsCIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg0NQorIzogYnVpbHRpbi9ibGFtZS5jOjg0NAogbXNnaWQgIlNob3cgYmxhbWUgZW50cmllcyBhcyB3ZSBmaW5kIHRoZW0sIGluY3JlbWVudGFsbHkiCiBtc2dzdHIgItCY0LfQstC10LbQtNCw0L3QtSDQvdCwINCw0LLRgtC+0YDRgdGC0LLQvtGC0L4g0YEg0L3QsNC80LjRgNCw0L3QtdGC0L4g0LzRgywg0L/QvtGB0LvQtdC00L7QstCw0YLQtdC70L3QviIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg0NgorIzogYnVpbHRpbi9ibGFtZS5jOjg0NQogbXNnaWQgIlNob3cgYmxhbmsgU0hBLTEgZm9yIGJvdW5kYXJ5IGNvbW1pdHMgKERlZmF1bHQ6IG9mZikiCiBtc2dzdHIgIiIKICLQmNC30LLQtdC20LTQsNC90LUg0L3QsCDQv9GA0LDQt9C90Lgg0YHRg9C80Lgg0L/QviBTSEExINC30LAg0LPRgNCw0L3QuNGH0L3QuNGC0LUg0L/QvtC00LDQstCw0L3QuNGPICjRgdGC0LDQvdC00LDRgNGC0L3QviDQvtC/0YbQuNGP0YLQsCAiCiAi0LUg0LjQt9C60LvRjtGH0LXQvdCwKSIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg0NworIzogYnVpbHRpbi9ibGFtZS5jOjg0NgogbXNnaWQgIkRvIG5vdCB0cmVhdCByb290IGNvbW1pdHMgYXMgYm91bmRhcmllcyAoRGVmYXVsdDogb2ZmKSIKIG1zZ3N0ciAiIgogItCd0LDRh9Cw0LvQvdC40YLQtSDQv9C+0LTQsNCy0LDQvdC40Y8g0LTQsCDQvdC1INGB0LUg0YHRh9C40YLQsNGCINC30LAg0LPRgNCw0L3QuNGH0L3QuCAo0YHRgtCw0L3QtNCw0YDRgtC90L4g0L7Qv9GG0LjRj9GC0LAg0LUgIgogItC40LfQutC70Y7Rh9C10L3QsCkiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NDgKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NDcKIG1zZ2lkICJTaG93IHdvcmsgY29zdCBzdGF0aXN0aWNzIgogbXNnc3RyICLQmNC30LLQtdC20LTQsNC90LUg0L3QsCDRgdGC0LDRgtC40YHRgtC40LrQsCDQt9CwINC40LfQstGK0YDRiNC10L3QuNGC0LUg0LTQtdC50YHRgtCy0LjRjyIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg0OQorIzogYnVpbHRpbi9ibGFtZS5jOjg0OAogbXNnaWQgIkZvcmNlIHByb2dyZXNzIHJlcG9ydGluZyIKIG1zZ3N0ciAi0J/RgNC40L3Rg9C00LjRgtC10LvQvdC+INC40LfQstC10LbQtNCw0L3QtSDQvdCwINC90LDQv9GA0LXQtNGK0LrQsCIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg1MAorIzogYnVpbHRpbi9ibGFtZS5jOjg0OQogbXNnaWQgIlNob3cgb3V0cHV0IHNjb3JlIGZvciBibGFtZSBlbnRyaWVzIgogbXNnc3RyICLQmNC30LLQtdC20LTQsNC90LUg0L3QsCDQtNC+0L/RitC70L3QuNGC0LXQu9C90LAg0LjQvdGE0L7RgNC80LDRhtC40Y8g0LfQsCDQvtC/0YDQtdC00LXQu9GP0L3QtdGC0L4g0L3QsCDQsNCy0YLQvtGA0YHRgtCy0L7RgtC+IgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODUxCisjOiBidWlsdGluL2JsYW1lLmM6ODUwCiBtc2dpZCAiU2hvdyBvcmlnaW5hbCBmaWxlbmFtZSAoRGVmYXVsdDogYXV0bykiCiBtc2dzdHIgIiIKICLQmNC30LLQtdC20LTQsNC90LUg0L3QsCDQv9GK0YDQstC+0L3QsNGH0LDQu9C90L7RgtC+INC40LzQtSDQvdCwINGE0LDQudC7ICjRgdGC0LDQvdC00LDRgNGC0L3QviDRgtC+0LLQsCDQtSDQsNCy0YLQvtC80LDRgtC40YfQvdC+KSIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg1MgorIzogYnVpbHRpbi9ibGFtZS5jOjg1MQogbXNnaWQgIlNob3cgb3JpZ2luYWwgbGluZW51bWJlciAoRGVmYXVsdDogb2ZmKSIKIG1zZ3N0ciAiIgogItCY0LfQstC10LbQtNCw0L3QtSDQvdCwINC/0YrRgNCy0L7QvdCw0YfQsNC70L3QuNGP0YIg0L3QvtC80LXRgCDQvdCwINGA0LXQtCAo0YHRgtCw0L3QtNCw0YDRgtC90L4g0L7Qv9GG0LjRj9GC0LAg0LUg0LjQt9C60LvRjtGH0LXQvdCwKSIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg1MworIzogYnVpbHRpbi9ibGFtZS5jOjg1MgogbXNnaWQgIlNob3cgaW4gYSBmb3JtYXQgZGVzaWduZWQgZm9yIG1hY2hpbmUgY29uc3VtcHRpb24iCiBtc2dzdHIgItCY0LfQstC10LbQtNCw0L3QtSDQstGK0LIg0YTQvtGA0LzQsNGCINC30LAg0L/Qvi3QvdCw0YLQsNGC0YrRiNC90LAg0L7QsdGA0LDQsdC+0YLQutCwIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODU0CisjOiBidWlsdGluL2JsYW1lLmM6ODUzCiBtc2dpZCAiU2hvdyBwb3JjZWxhaW4gZm9ybWF0IHdpdGggcGVyLWxpbmUgY29tbWl0IGluZm9ybWF0aW9uIgogbXNnc3RyICIiCiAi0JjQt9Cy0LXQttC00LDQvdC1INCy0YrQsiDRhNC+0YDQvNCw0YIg0LfQsCDQutC+0LzQsNC90LTQuCDQvtGCINC/0L7RgtGA0LXQsdC40YLQtdC70YHQutC+INC90LjQstC+INGBINC40L3RhNC+0YDQvNCw0YbQuNGPINC90LAg0LLRgdC10LrQuCAiCiAi0YDQtdC0IgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODU1CisjOiBidWlsdGluL2JsYW1lLmM6ODU0CiBtc2dpZCAiVXNlIHRoZSBzYW1lIG91dHB1dCBtb2RlIGFzIGdpdC1hbm5vdGF0ZSAoRGVmYXVsdDogb2ZmKSIKIG1zZ3N0ciAiIgogItCY0LfQv9C+0LvQt9Cy0LDQvdC1INC90LAg0YHRitGJ0LjRjyDRhNC+0YDQvNCw0YIg0LrQsNGC0L4g4oCeZ2l0LWFubm90YXRl4oCcICjRgdGC0LDQvdC00LDRgNGC0L3QviDQvtC/0YbQuNGP0YLQsCDQtSAiCiAi0LjQt9C60LvRjtGH0LXQvdCwKSIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg1NgorIzogYnVpbHRpbi9ibGFtZS5jOjg1NQogbXNnaWQgIlNob3cgcmF3IHRpbWVzdGFtcCAoRGVmYXVsdDogb2ZmKSIKIG1zZ3N0ciAi0JjQt9Cy0LXQttC00LDQvdC1INC90LAg0L3QtdGE0L7RgNC80LDRgtC40YDQsNC90Lgg0LLRgNC10LzQtdC90LAgKNGB0YLQsNC90LTQsNGA0YLQvdC+INC+0L/RhtC40Y/RgtCwINC1INC40LfQutC70Y7Rh9C10L3QsCkiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NTcKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NTYKIG1zZ2lkICJTaG93IGxvbmcgY29tbWl0IFNIQTEgKERlZmF1bHQ6IG9mZikiCiBtc2dzdHIgItCY0LfQstC10LbQtNCw0L3QtSDQvdCwINC/0YrQu9C90LjRgtC1INGB0YPQvNC4INC/0L4gU0hBMSAo0YHRgtCw0L3QtNCw0YDRgtC90L4g0L7Qv9GG0LjRj9GC0LAg0LUg0LjQt9C60LvRjtGH0LXQvdCwKSIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg1OAorIzogYnVpbHRpbi9ibGFtZS5jOjg1NwogbXNnaWQgIlN1cHByZXNzIGF1dGhvciBuYW1lIGFuZCB0aW1lc3RhbXAgKERlZmF1bHQ6IG9mZikiCiBtc2dzdHIgItCR0LXQtyDQuNC80LUg0L3QsCDQsNCy0YLQvtGAINC4INCy0YDQtdC80LUg0L3QsCDQv9GA0L7QvNGP0L3QsCAo0YHRgtCw0L3QtNCw0YDRgtC90L4g0L7Qv9GG0LjRj9GC0LAg0LUg0LjQt9C60LvRjtGH0LXQvdCwKSIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg1OQorIzogYnVpbHRpbi9ibGFtZS5jOjg1OAogbXNnaWQgIlNob3cgYXV0aG9yIGVtYWlsIGluc3RlYWQgb2YgbmFtZSAoRGVmYXVsdDogb2ZmKSIKIG1zZ3N0ciAiIgogItCY0LfQstC10LbQtNCw0L3QtSDQvdCwINC1LdC/0L7RidCw0YLQsCDQvdCwINCw0LLRgtC+0YDQsCwg0LAg0L3QtSDQuNC80LXRgtC+INC80YMgKNGB0YLQsNC90LTQsNGA0YLQvdC+INC+0L/RhtC40Y/RgtCwINC1ICIKICLQuNC30LrQu9GO0YfQtdC90LApIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODYwCisjOiBidWlsdGluL2JsYW1lLmM6ODU5CiBtc2dpZCAiSWdub3JlIHdoaXRlc3BhY2UgZGlmZmVyZW5jZXMiCiBtc2dzdHIgItCR0LXQtyDRgNCw0LfQu9C40LrQuCDQsiDQt9C90LDRhtC40YLQtSDQt9CwINC40L3RgtC10YDQstCw0LvQuCIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg2MSBidWlsdGluL2xvZy5jOjE2MjkKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NjAgYnVpbHRpbi9sb2cuYzoxNjMwCiBtc2dpZCAicmV2IgogbXNnc3RyICLQktCV0KDQoSIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg2MQorIzogYnVpbHRpbi9ibGFtZS5jOjg2MAogbXNnaWQgIklnbm9yZSA8cmV2PiB3aGVuIGJsYW1pbmciCiBtc2dzdHIgItCf0YDQtdGB0LrQsNGH0LDQvdC1INC90LAg0JLQldCg0KHQuNGP0YLQsCDQv9GA0Lgg0LjQt9Cy0LXQttC00LDQvdC1INC90LAg0LDQstGC0L7RgNGB0YLQstC+0YLQviIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg2MgorIzogYnVpbHRpbi9ibGFtZS5jOjg2MQogbXNnaWQgIklnbm9yZSByZXZpc2lvbnMgZnJvbSA8ZmlsZT4iCiBtc2dzdHIgItCf0YDQtdGB0LrQsNGH0LDQvdC1INC90LAg0LLQtdGA0YHQuNC40YLQtSDRg9C60LDQt9Cw0L3QuCDQstGK0LIg0KTQkNCZ0JvQsCDQv9GA0Lgg0LjQt9Cy0LXQttC00LDQvdC1INC90LAg0LDQstGC0L7RgNGB0YLQstC+0YLQviIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg2MworIzogYnVpbHRpbi9ibGFtZS5jOjg2MgogbXNnaWQgImNvbG9yIHJlZHVuZGFudCBtZXRhZGF0YSBmcm9tIHByZXZpb3VzIGxpbmUgZGlmZmVyZW50bHkiCiBtc2dzdHIgIiIKICLQvtGG0LLQtdGC0Y/QstCw0L3QtSDQvdCwINC/0L7QstGC0LDRgNGP0YnQuNGC0LUg0YHQtSDQvNC10YLQsNC00LDQvdC90Lgg0L7RgiDQv9GA0LXQtNC40YjQvdC40Y8g0YDQtdC0INCyINGA0LDQt9C70LjRh9C10L0g0YbQstGP0YIiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NjQKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NjMKIG1zZ2lkICJjb2xvciBsaW5lcyBieSBhZ2UiCiBtc2dzdHIgItC+0YbQstC10YLRj9Cy0LDQvdC1INC90LAg0YDQtdC00L7QstC10YLQtSDQv9C+INCy0YrQt9GA0LDRgdGCIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODcxCisjOiBidWlsdGluL2JsYW1lLmM6ODcwCiBtc2dpZCAiVXNlIGFuIGV4cGVyaW1lbnRhbCBoZXVyaXN0aWMgdG8gaW1wcm92ZSBkaWZmcyIKIG1zZ3N0ciAi0J/QvtC00L7QsdGA0Y/QstCw0L3QtSDQvdCwINGA0LDQt9C70LjQutC40YLQtSDRh9GA0LXQtyDQtdC60YHQv9C10YDQuNC80LXQvdGC0LDQu9C90LAg0LXQstGA0LjRgdGC0LjQutCwIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODczCisjOiBidWlsdGluL2JsYW1lLmM6ODcyCiBtc2dpZCAiU3BlbmQgZXh0cmEgY3ljbGVzIHRvIGZpbmQgYmV0dGVyIG1hdGNoIgogbXNnc3RyICLQlNC+0L/RitC70L3QuNGC0LXQu9C90Lgg0LjQt9GH0LjRgdC70LXQvdC40Y8g0LfQsCDQv9C+LdC00L7QsdGA0Lgg0YDQtdC30YPQu9GC0LDRgtC4IgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODc0CisjOiBidWlsdGluL2JsYW1lLmM6ODczCiBtc2dpZCAiVXNlIHJldmlzaW9ucyBmcm9tIDxmaWxlPiBpbnN0ZWFkIG9mIGNhbGxpbmcgZ2l0LXJldi1saXN0IgogbXNnc3RyICLQmNC30YfQuNGC0LDQvdC1INC90LAg0LLQtdGA0YHQuNC40YLQtSDQvtGCINCk0JDQmdCbLCDQsCDQvdC1INGH0YDQtdC3INC40LfQv9GK0LvQvdC10L3QuNC1INC90LAg4oCeZ2l0LXJldi1saXN04oCcIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODc1CisjOiBidWlsdGluL2JsYW1lLmM6ODc0CiBtc2dpZCAiVXNlIDxmaWxlPidzIGNvbnRlbnRzIGFzIHRoZSBmaW5hbCBpbWFnZSIKIG1zZ3N0ciAi0JjQt9C/0L7Qu9C30LLQsNC90LUg0L3QsCDRgdGK0LTRitGA0LbQsNC90LjQtdGC0L4g0L3QsCDQpNCQ0JnQm9CwINC60LDRgtC+INC60YDQsNC50L3QviDQv9C+0LvQvtC20LXQvdC40LUiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NzYgYnVpbHRpbi9ibGFtZS5jOjg3NworIzogYnVpbHRpbi9ibGFtZS5jOjg3NSBidWlsdGluL2JsYW1lLmM6ODc2CiBtc2dpZCAic2NvcmUiCiBtc2dzdHIgItC90LDQv9Cw0YHQstCw0L3QtSDQvdCwINGA0LXQtNC+0LLQtdGC0LUiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NzYKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NzUKIG1zZ2lkICJGaW5kIGxpbmUgY29waWVzIHdpdGhpbiBhbmQgYWNyb3NzIGZpbGVzIgogbXNnc3RyICIiCiAi0KLRitGA0YHQtdC90LUg0L3QsCDQutC+0L/QuNGA0LDQvdC4INGA0LXQtNC+0LLQtSDQutCw0LrRgtC+INCyINGA0LDQvNC60LjRgtC1INC90LAg0LXQtNC40L0g0YTQsNC50LssINGC0LDQutCwINC4INC+0YIg0LXQtNC40L0g0YTQsNC50LsgIgogItC60YrQvCDQtNGA0YPQsyIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg3NworIzogYnVpbHRpbi9ibGFtZS5jOjg3NgogbXNnaWQgIkZpbmQgbGluZSBtb3ZlbWVudHMgd2l0aGluIGFuZCBhY3Jvc3MgZmlsZXMiCiBtc2dzdHIgIiIKICLQotGK0YDRgdC10L3QtSDQvdCwINC/0YDQtdC80LXRgdGC0LXQvdC4INGA0LXQtNC+0LLQtSDQutCw0LrRgtC+INCyINGA0LDQvNC60LjRgtC1INC90LAg0LXQtNC40L0g0YTQsNC50LssINGC0LDQutCwINC4INC+0YIg0LXQtNC40L0gIgogItGE0LDQudC7INC60YrQvCDQtNGA0YPQsyIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg3OAorIzogYnVpbHRpbi9ibGFtZS5jOjg3NwogbXNnaWQgIm4sbSIKIG1zZ3N0ciAibixtIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODc4CisjOiBidWlsdGluL2JsYW1lLmM6ODc3CiBtc2dpZCAiUHJvY2VzcyBvbmx5IGxpbmUgcmFuZ2UgbixtLCBjb3VudGluZyBmcm9tIDEiCiBtc2dzdHIgIiIKICLQmNC90YTQvtGA0LzQsNGG0LjRjyDRgdCw0LzQviDQt9CwINGA0LXQtNC+0LLQtdGC0LUg0LIg0LTQuNCw0L/QsNC30L7QvdCwINC+0YIgbiDQtNC+IG0g0LLQutC70Y7Rh9C40YLQtdC70L3Qvi4gINCR0YDQvtC10L3QtdGC0L4gIgpAQCAtMTAwNTksNyArMTAwOTgsNyBAQAogbXNnaWQgImRvIG5vdCB1c2UiCiBtc2dzdHIgItC00LAg0L3QtSDRgdC1INC/0L7Qu9C30LLQsCIKIAotIzogYnVpbHRpbi9icmFuY2guYzo2MjYgYnVpbHRpbi9yZWJhc2UuYzo0ODUKKyM6IGJ1aWx0aW4vYnJhbmNoLmM6NjI2IGJ1aWx0aW4vcmViYXNlLmM6NDg2CiBtc2dpZCAidXBzdHJlYW0iCiBtc2dzdHIgItC60LvQvtC9LdC40LfRgtC+0YfQvdC40LoiCiAKQEAgLTEwMTcxLDcgKzEwMjEwLDcgQEAKIG1zZ2lkICJmb3JtYXQgdG8gdXNlIGZvciB0aGUgb3V0cHV0IgogbXNnc3RyICLQpNCe0KDQnNCQ0KIg0LfQsCDQuNC30YXQvtC00LAiCiAKLSM6IGJ1aWx0aW4vYnJhbmNoLmM6Njg0IGJ1aWx0aW4vY2xvbmUuYzo3NjEKKyM6IGJ1aWx0aW4vYnJhbmNoLmM6Njg0IGJ1aWx0aW4vY2xvbmUuYzo3NjAKIG1zZ2lkICJIRUFEIG5vdCBmb3VuZCBiZWxvdyByZWZzL2hlYWRzISIKIG1zZ3N0ciAi0JIg0LTQuNGA0LXQutGC0L7RgNC40Y/RgtCwIOKAnnJlZnMvaGVhZHPigJwg0LvQuNC/0YHQstCwINGE0LDQudC7IOKAnkhFQUTigJwiCiAKQEAgLTEwMjc0LDcgKzEwMzEzLDcgQEAKIG1zZ2lkICJOZWVkIGEgcmVwb3NpdG9yeSB0byB1bmJ1bmRsZS4iCiBtc2dzdHIgItCX0LAg0L/RgNC40LXQvNCw0L3QtdGC0L4g0L3QsCDQv9GA0LDRgtC60LAg0LUg0L3QtdC+0LHRhdC+0LTQuNC80L4g0YXRgNCw0L3QuNC70LjRidC1LiIKIAotIzogYnVpbHRpbi9jYXQtZmlsZS5jOjU5NAorIzogYnVpbHRpbi9jYXQtZmlsZS5jOjU5NQogbXNnaWQgIiIKICJnaXQgY2F0LWZpbGUgKC10IFstLWFsbG93LXVua25vd24tdHlwZV0gfCAtcyBbLS1hbGxvdy11bmtub3duLXR5cGVdIHwgLWUgfCAtIgogInAgfCA8dHlwZT4gfCAtLXRleHRjb252IHwgLS1maWx0ZXJzKSBbLS1wYXRoPTxwYXRoPl0gPG9iamVjdD4iCkBAIC0xMDI4Miw3ICsxMDMyMSw3IEBACiAiZ2l0IGNhdC1maWxlICgtdCBbLS1hbGxvdy11bmtub3duLXR5cGVdIHwgLXMgWy0tYWxsb3ctdW5rbm93bi10eXBlXSB8IC1lIHwgLSIKICJwIHwg0JLQmNCUIHwgLS10ZXh0Y29udiAtLWZpbHRlcnMpIFstLXBhdGg90J/QqtCiXSDQntCR0JXQmtCiIgogCi0jOiBidWlsdGluL2NhdC1maWxlLmM6NTk1CisjOiBidWlsdGluL2NhdC1maWxlLmM6NTk2CiBtc2dpZCAiIgogImdpdCBjYXQtZmlsZSAoLS1iYXRjaCB8IC0tYmF0Y2gtY2hlY2spIFstLWZvbGxvdy1zeW1saW5rc10gWy0tdGV4dGNvbnYgfCAtLSIKICJmaWx0ZXJzXSIKQEAgLTEwMjkwLDc5ICsxMDMyOSw3OSBAQAogImdpdCBjYXQtZmlsZSAoLS1iYXRjaCB8IC0tYmF0Y2gtY2hlY2spIFstLWZvbGxvdy1zeW1saW5rc10gWy0tdGV4dGNvbnYgfCAtLSIKICJmaWx0ZXJzXSIKIAotIzogYnVpbHRpbi9jYXQtZmlsZS5jOjYxNgorIzogYnVpbHRpbi9jYXQtZmlsZS5jOjYxNwogbXNnaWQgIm9ubHkgb25lIGJhdGNoIG9wdGlvbiBtYXkgYmUgc3BlY2lmaWVkIgogbXNnc3RyICLQvNC+0LbQtSDQtNCwINGD0LrQsNC20LXRgtC1INGB0LDQvNC+INC10LTQvdCwINC/0LDQutC10YLQvdCwINC+0L/RhtC40Y8iCiAKLSM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2MzQKKyM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2MzUKIG1zZ2lkICI8dHlwZT4gY2FuIGJlIG9uZSBvZjogYmxvYiwgdHJlZSwgY29tbWl0LCB0YWciCiBtc2dzdHIgIiIKICLQktCY0JTRitGCINC80L7QttC1INC00LAg0LU6IOKAnmJsb2LigJwgKEJMT0IpLCDigJ50cmVl4oCcICjQtNGK0YDQstC+KSwg4oCeY29tbWl04oCcICjQv9C+0LTQsNCy0LDQvdC1KSwgIgogIuKAnnRhZ+KAnCAo0LXRgtC40LrQtdGCKSIKIAotIzogYnVpbHRpbi9jYXQtZmlsZS5jOjYzNQorIzogYnVpbHRpbi9jYXQtZmlsZS5jOjYzNgogbXNnaWQgInNob3cgb2JqZWN0IHR5cGUiCiBtc2dzdHIgItC40LfQstC10LbQtNCw0L3QtSDQvdCwINCy0LjQtNCwINC90LAg0L7QsdC10LrRgiIKIAotIzogYnVpbHRpbi9jYXQtZmlsZS5jOjYzNgorIzogYnVpbHRpbi9jYXQtZmlsZS5jOjYzNwogbXNnaWQgInNob3cgb2JqZWN0IHNpemUiCiBtc2dzdHIgItC40LfQstC10LbQtNCw0L3QtSDQvdCwINGA0LDQt9C80LXRgNCwINC90LAg0L7QsdC10LrRgiIKIAotIzogYnVpbHRpbi9jYXQtZmlsZS5jOjYzOAorIzogYnVpbHRpbi9jYXQtZmlsZS5jOjYzOQogbXNnaWQgImV4aXQgd2l0aCB6ZXJvIHdoZW4gdGhlcmUncyBubyBlcnJvciIKIG1zZ3N0ciAi0LjQt9GF0L7QtCDRgSAwLCDQutC+0LPQsNGC0L4g0L3Rj9C80LAg0LPRgNC10YjQutCwIgogCi0jOiBidWlsdGluL2NhdC1maWxlLmM6NjM5CisjOiBidWlsdGluL2NhdC1maWxlLmM6NjQwCiBtc2dpZCAicHJldHR5LXByaW50IG9iamVjdCdzIGNvbnRlbnQiCiBtc2dzdHIgItGE0L7RgNC80LDRgtC40YDQsNC90L4g0LjQt9Cy0LXQttC00LDQvdC1INC90LAg0YHRitC00YrRgNC20LDQvdC40LXRgtC+INC90LAg0L7QsdC10LrRgtCwIgogCi0jOiBidWlsdGluL2NhdC1maWxlLmM6NjQxCisjOiBidWlsdGluL2NhdC1maWxlLmM6NjQyCiBtc2dpZCAiZm9yIGJsb2Igb2JqZWN0cywgcnVuIHRleHRjb252IG9uIG9iamVjdCdzIGNvbnRlbnQiCiBtc2dzdHIgIiIKICLQtNCwINGB0LUg0YHRgtCw0YDRgtC40YDQsCDQv9GA0L7Qs9GA0LDQvNCw0YLQsCDQt9Cw0LTQsNC00LXQvdCwINCyINC90LDRgdGC0YDQvtC50LrQsNGC0LAg4oCedGV4dGNvbnbigJwg0LfQsCDQv9GA0LXQvtCx0YDQsNC30YPQstCw0L3QtSAiCiAi0L3QsCDRgdGK0LTRitGA0LbQsNC90LjQtdGC0L4g0L3QsCDQvtCx0LXQutGC0LAtQkxPQiIKIAotIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY0MworIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY0NAogbXNnaWQgImZvciBibG9iIG9iamVjdHMsIHJ1biBmaWx0ZXJzIG9uIG9iamVjdCdzIGNvbnRlbnQiCiBtc2dzdHIgIiIKICLQtNCwINGB0LUg0YHRgtCw0YDRgtC40YDQsNGCINC/0YDQvtCz0YDQsNC80LjRgtC1INC30LAg0L/RgNC10L7QsdGA0LDQt9GD0LLQsNC90LUg0L3QsCDRgdGK0LTRitGA0LbQsNC90LjQtdGC0L4g0L3QsCDQvtCx0LXQutGC0LjRgtC1LUJMT0IiCiAKLSM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NDQgZ2l0LXN1Ym1vZHVsZS5zaDo5MzYKKyM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NDUgZ2l0LXN1Ym1vZHVsZS5zaDo5MzYKIG1zZ2lkICJibG9iIgogbXNnc3RyICLQvtCx0LXQutGCLUJMT0IiCiAKLSM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NDUKKyM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NDYKIG1zZ2lkICJ1c2UgYSBzcGVjaWZpYyBwYXRoIGZvciAtLXRleHRjb252Ly0tZmlsdGVycyIKIG1zZ3N0ciAi0L7Qv9GG0LjQuNGC0LUg4oCeLS10ZXh0Y29uduKAnC/igJ4tLWZpbHRlcnPigJwg0LjQt9C40YHQutCy0LDRgiDQv9GK0YIiCiAKLSM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NDcKKyM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NDgKIG1zZ2lkICJhbGxvdyAtcyBhbmQgLXQgdG8gd29yayB3aXRoIGJyb2tlbi9jb3JydXB0IG9iamVjdHMiCiBtc2dzdHIgItC/0L7Qt9Cy0L7Qu9GP0LLQsNC90LUg0L3QsCDQvtC/0YbQuNC40YLQtSDigJ4tc+KAnCDQuCDigJ4tdOKAnCDQtNCwINGA0LDQsdC+0YLRj9GCINGBINC/0L7QstGA0LXQtNC10L3QuCDQvtCx0LXQutGC0LgiCiAKLSM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NDgKKyM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NDkKIG1zZ2lkICJidWZmZXIgLS1iYXRjaCBvdXRwdXQiCiBtc2dzdHIgItCx0YPRhNC10YDQuNGA0LDQvdC1INC90LAg0LjQt9GF0L7QtNCwINC+0YIg4oCeLS1iYXRjaOKAnCIKIAotIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY1MAorIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY1MQogbXNnaWQgInNob3cgaW5mbyBhbmQgY29udGVudCBvZiBvYmplY3RzIGZlZCBmcm9tIHRoZSBzdGFuZGFyZCBpbnB1dCIKIG1zZ3N0ciAiIgogItC40LfQstC10LbQtNCw0L3QtSDQvdCwINC40L3RhNC+0YDQvNCw0YbQuNGPINC4INGB0YrQtNGK0YDQttCw0L3QuNC1INC90LAg0L7QsdC10LrRgtC40YLQtSDQv9C+0LTQsNC00LXQvdC4INC90LAg0YHRgtCw0L3QtNCw0YDRgtC90LjRjyDQstGF0L7QtCIKIAotIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY1NAorIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY1NQogbXNnaWQgInNob3cgaW5mbyBhYm91dCBvYmplY3RzIGZlZCBmcm9tIHRoZSBzdGFuZGFyZCBpbnB1dCIKIG1zZ3N0ciAi0LjQt9Cy0LXQttC00LDQvdC1INC90LAg0LjQvdGE0L7RgNC80LDRhtC40Y8g0LfQsCDQvtCx0LXQutGC0LjRgtC1INC/0L7QtNCw0LTQtdC90Lgg0L3QsCDRgdGC0LDQvdC00LDRgNGC0L3QuNGPINCy0YXQvtC0IgogCi0jOiBidWlsdGluL2NhdC1maWxlLmM6NjU4CisjOiBidWlsdGluL2NhdC1maWxlLmM6NjU5CiBtc2dpZCAiZm9sbG93IGluLXRyZWUgc3ltbGlua3MgKHVzZWQgd2l0aCAtLWJhdGNoIG9yIC0tYmF0Y2gtY2hlY2spIgogbXNnc3RyICIiCiAi0YHQu9C10LTQstCw0L3QtSDQvdCwINGB0LjQvNCy0L7Qu9C90LjRgtC1INCy0YDRitC30LrQuCDRgdC+0YfQtdGJ0Lgg0LIg0LTRitGA0LLQvtGC0L4gKNC/0L7Qu9C30LLQsCDRgdC1INGBIOKAni0tYmF0Y2jigJwg0LjQu9C4IOKAni0tIgogImJhdGNoLWNoZWNr4oCcKSIKIAotIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY2MAorIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY2MQogbXNnaWQgInNob3cgYWxsIG9iamVjdHMgd2l0aCAtLWJhdGNoIG9yIC0tYmF0Y2gtY2hlY2siCiBtc2dzdHIgItC40LfQstC10LbQtNCw0L3QtSDQvdCwINCy0YHQuNGH0LrQuCDQvtCx0LXQutGC0Lgg0YEg4oCeLS1iYXRjaOKAnCDQuNC70Lgg4oCeLS1iYXRjaC1jaGVja+KAnCIKIAotIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY2MgorIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY2MwogbXNnaWQgImRvIG5vdCBvcmRlciAtLWJhdGNoLWFsbC1vYmplY3RzIG91dHB1dCIKIG1zZ3N0ciAi0LHQtdC3INC/0L7QtNGA0LXQttC00LDQvdC1INC90LAg0LjQt9GF0L7QtNCwINC+0YIg4oCeLS1iYXRjaC1hbGwtb2JqZWN0c+KAnCIKIApAQCAtMTAzOTAsOCArMTA0MjksOCBAQAogbXNnaWQgInRlcm1pbmF0ZSBpbnB1dCBhbmQgb3V0cHV0IHJlY29yZHMgYnkgYSBOVUwgY2hhcmFjdGVyIgogbXNnc3RyICLRgNCw0LfQtNC10LvRj9C90LUg0L3QsCDQstGF0L7QtNC90LjRgtC1INC4INC40LfRhdC+0LTQvdC40YLQtSDQt9Cw0L/QuNGB0Lgg0YEg0L3Rg9C70LXQstC40Y8g0LfQvdCw0Log4oCeTlVM4oCcIgogCi0jOiBidWlsdGluL2NoZWNrLWlnbm9yZS5jOjIxIGJ1aWx0aW4vY2hlY2tvdXQuYzoxNDMzIGJ1aWx0aW4vZ2MuYzo1MzgKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo1MDcKKyM6IGJ1aWx0aW4vY2hlY2staWdub3JlLmM6MjEgYnVpbHRpbi9jaGVja291dC5jOjE0MzMgYnVpbHRpbi9nYy5jOjUzNworIzogYnVpbHRpbi93b3JrdHJlZS5jOjUwNgogbXNnaWQgInN1cHByZXNzIHByb2dyZXNzIHJlcG9ydGluZyIKIG1zZ3N0ciAi0LHQtdC3INC/0L7QutCw0LfQstCw0L3QtSDQvdCwINC90LDQv9GA0LXQtNGK0LrQsCIKIApAQCAtMTA0ODMsNyArMTA1MjIsNyBAQAogIzogYnVpbHRpbi9jaGVja291dC1pbmRleC5jOjE3OCBidWlsdGluL2NvbHVtbi5jOjMxCiAjOiBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6MTM3MyBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6MTM3NgogIzogYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjEzODQgYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjE4NTcKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo2ODAKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo2NzkKIG1zZ2lkICJzdHJpbmciCiBtc2dzdHIgItCd0JjQlyIKIApAQCAtMTA1MTEsOTkgKzEwNTUwLDk5IEBACiBtc2dpZCAiZ2l0IHJlc3RvcmUgWzxvcHRpb25zPl0gWy0tc291cmNlPTxicmFuY2g+XSA8ZmlsZT4uLi4iCiBtc2dzdHIgImdpdCByZXN0b3JlIFvQntCf0KbQmNCv4oCmXSBbLS1zb3VyY2U90JrQm9Ce0J1dINCk0JDQmdCb4oCmIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6MTcyIGJ1aWx0aW4vY2hlY2tvdXQuYzoyMTEKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzMgYnVpbHRpbi9jaGVja291dC5jOjIxMgogIywgYy1mb3JtYXQKIG1zZ2lkICJwYXRoICclcycgZG9lcyBub3QgaGF2ZSBvdXIgdmVyc2lvbiIKIG1zZ3N0ciAi0LLQsNGI0LDRgtCwINCy0LXRgNGB0LjRjyDQu9C40L/RgdCy0LAg0LIg0L/RitGC0Y8g4oCeJXPigJwiCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzQgYnVpbHRpbi9jaGVja291dC5jOjIxMworIzogYnVpbHRpbi9jaGVja291dC5jOjE3NSBidWlsdGluL2NoZWNrb3V0LmM6MjE0CiAjLCBjLWZvcm1hdAogbXNnaWQgInBhdGggJyVzJyBkb2VzIG5vdCBoYXZlIHRoZWlyIHZlcnNpb24iCiBtc2dzdHIgItGH0YPQttC00LDRgtCwINCy0LXRgNGB0LjRjyDQu9C40L/RgdCy0LAg0LIg0L/RitGC0Y8g4oCeJXPigJwiCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxOTAKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxOTEKICMsIGMtZm9ybWF0CiBtc2dpZCAicGF0aCAnJXMnIGRvZXMgbm90IGhhdmUgYWxsIG5lY2Vzc2FyeSB2ZXJzaW9ucyIKIG1zZ3N0ciAi0L3Rj9C60L7RjyDQvtGCINC90LXQvtCx0YXQvtC00LjQvNC40YLQtSDQstC10YDRgdC40Lgg0LvQuNC/0YHQstCwINCyINC/0YrRgtGPIOKAniVz4oCcIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6MjQwCisjOiBidWlsdGluL2NoZWNrb3V0LmM6MjQxCiAjLCBjLWZvcm1hdAogbXNnaWQgInBhdGggJyVzJyBkb2VzIG5vdCBoYXZlIG5lY2Vzc2FyeSB2ZXJzaW9ucyIKIG1zZ3N0ciAi0L3Rj9C60L7RjyDQvtGCINC90LXQvtCx0YXQvtC00LjQvNC40YLQtSDQstC10YDRgdC40Lgg0LvQuNC/0YHQstCwINCyINC/0YrRgtGPIOKAniVz4oCcIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6MjU4CisjOiBidWlsdGluL2NoZWNrb3V0LmM6MjU5CiAjLCBjLWZvcm1hdAogbXNnaWQgInBhdGggJyVzJzogY2Fubm90IG1lcmdlIgogbXNnc3RyICLQv9GK0YLRj9GCIOKAniVz4oCcINC90LUg0LzQvtC20LUg0LTQsCDQsdGK0LTQtSDRgdC70Y/QvSIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjI3NAorIzogYnVpbHRpbi9jaGVja291dC5jOjI3NQogIywgYy1mb3JtYXQKIG1zZ2lkICJVbmFibGUgdG8gYWRkIG1lcmdlIHJlc3VsdCBmb3IgJyVzJyIKIG1zZ3N0ciAi0KDQtdC30YPQu9GC0LDRgtGK0YIg0LfQsCDigJ4lc+KAnCDQvdC1INC80L7QttC1INC00LAg0LHRitC00LUg0YHQu9GP0L0iCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzozNzQKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzozNzUKICMsIGMtZm9ybWF0CiBtc2dpZCAiUmVjcmVhdGVkICVkIG1lcmdlIGNvbmZsaWN0IgogbXNnaWRfcGx1cmFsICJSZWNyZWF0ZWQgJWQgbWVyZ2UgY29uZmxpY3RzIgogbXNnc3RyWzBdICLQn9GA0LXRgdGK0LfQtNCw0LTQtdC9INC1ICVkINC60L7QvdGE0LvQuNC60YIg0L/RgNC4INGB0LvQuNCy0LDQvdC1IgogbXNnc3RyWzFdICLQn9GA0LXRgdGK0LfQtNCw0LTQtdC90Lgg0YHQsCAlZCDQutC+0L3RhNC70LjQutGC0LAg0L/RgNC4INGB0LvQuNCy0LDQvdC1IgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6Mzc5CisjOiBidWlsdGluL2NoZWNrb3V0LmM6MzgwCiAjLCBjLWZvcm1hdAogbXNnaWQgIlVwZGF0ZWQgJWQgcGF0aCBmcm9tICVzIgogbXNnaWRfcGx1cmFsICJVcGRhdGVkICVkIHBhdGhzIGZyb20gJXMiCiBtc2dzdHJbMF0gItCe0LHQvdC+0LLQtdC9INC1ICVkINC/0YrRgiDQvtGCIOKAniVz4oCcIgogbXNnc3RyWzFdICLQntCx0L3QvtCy0LXQvdC4INGB0LAgJWQg0L/RitGC0Y8g0L7RgiDigJ4lc+KAnCIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjM4NgorIzogYnVpbHRpbi9jaGVja291dC5jOjM4NwogIywgYy1mb3JtYXQKIG1zZ2lkICJVcGRhdGVkICVkIHBhdGggZnJvbSB0aGUgaW5kZXgiCiBtc2dpZF9wbHVyYWwgIlVwZGF0ZWQgJWQgcGF0aHMgZnJvbSB0aGUgaW5kZXgiCiBtc2dzdHJbMF0gItCe0LHQvdC+0LLQtdC9INC1ICVkINC/0YrRgiDQvtGCINC40L3QtNC10LrRgdCwIgogbXNnc3RyWzFdICLQntCx0L3QvtCy0LXQvdC4INGB0LAgJWQg0L/RitGC0Y8g0L7RgiDQuNC90LTQtdC60YHQsCIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjQwOSBidWlsdGluL2NoZWNrb3V0LmM6NDEyIGJ1aWx0aW4vY2hlY2tvdXQuYzo0MTUKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo0MTkKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo0MTAgYnVpbHRpbi9jaGVja291dC5jOjQxMyBidWlsdGluL2NoZWNrb3V0LmM6NDE2CisjOiBidWlsdGluL2NoZWNrb3V0LmM6NDIwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiclcycgY2Fubm90IGJlIHVzZWQgd2l0aCB1cGRhdGluZyBwYXRocyIKIG1zZ3N0ciAi0L7Qv9GG0LjRj9GC0LAg4oCeJXPigJwg0LUg0L3QtdGB0YrQstC80LXRgdGC0LjQvNCwINGBINC+0LHQvdC+0LLRj9Cy0LDQvdC10YLQviDQvdCwINC/0YrRgtC40YnQsCIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjQyMiBidWlsdGluL2NoZWNrb3V0LmM6NDI1CisjOiBidWlsdGluL2NoZWNrb3V0LmM6NDIzIGJ1aWx0aW4vY2hlY2tvdXQuYzo0MjYKICMsIGMtZm9ybWF0CiBtc2dpZCAiJyVzJyBjYW5ub3QgYmUgdXNlZCB3aXRoICVzIgogbXNnc3RyICLQvtC/0YbQuNGP0YLQsCDigJ4lc+KAnCDQtSDQvdC10YHRitCy0LzQtdGB0YLQuNC80LAg0YEg4oCeJXPigJwiCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo0MjkKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo0MzAKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ2Fubm90IHVwZGF0ZSBwYXRocyBhbmQgc3dpdGNoIHRvIGJyYW5jaCAnJXMnIGF0IHRoZSBzYW1lIHRpbWUuIgogbXNnc3RyICIiCiAi0J3QtdCy0YrQt9C80L7QttC90L4g0LUg0LXQtNC90L7QstGA0LXQvNC10L3QvdC+INC00LAg0L7QsdC90L7QstGP0LLQsNGC0LUg0L/RitGC0LjRidCwINC4INC00LAg0L/RgNC10LzQuNC90LXRgtC1INC60YrQvCDQutC70L7QvdCwIOKAniVz4oCcLiIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjQzMworIzogYnVpbHRpbi9jaGVja291dC5jOjQzNAogIywgYy1mb3JtYXQKIG1zZ2lkICJuZWl0aGVyICclcycgb3IgJyVzJyBpcyBzcGVjaWZpZWQiCiBtc2dzdHIgItC90LUg0LUg0YPQutCw0LfQsNC90L4g0L3QuNGC0L4g4oCeJXPigJwsINC90LjRgtC+IOKAniVz4oCcIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6NDM3CisjOiBidWlsdGluL2NoZWNrb3V0LmM6NDM4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiclcycgbXVzdCBiZSB1c2VkIHdoZW4gJyVzJyBpcyBub3Qgc3BlY2lmaWVkIgogbXNnc3RyICLQvtC/0YbQuNGP0YLQsCDigJ4lc+KAnCDQtSDQt9Cw0LTRitC70LbQuNGC0LXQu9C90LAsINC60L7Qs9Cw0YLQviDigJ4lc+KAnCDQvdC1INC1INC30LDQtNCw0LTQtdC90LAiCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo0NDIgYnVpbHRpbi9jaGVja291dC5jOjQ0NworIzogYnVpbHRpbi9jaGVja291dC5jOjQ0MyBidWlsdGluL2NoZWNrb3V0LmM6NDQ4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiclcycgb3IgJyVzJyBjYW5ub3QgYmUgdXNlZCB3aXRoICVzIgogbXNnc3RyICLQvtC/0YbQuNGP0YLQsCDigJ4lMyRz4oCcINC1INC90LXRgdGK0LLQvNC10YHRgtC40LzQsCDQutCw0LrRgtC+INGBIOKAniUxJHPigJwsINGC0LDQutCwINC4INGBIOKAniUyJHPigJwiCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo1MDYgYnVpbHRpbi9jaGVja291dC5jOjUxMworIzogYnVpbHRpbi9jaGVja291dC5jOjUwNyBidWlsdGluL2NoZWNrb3V0LmM6NTE0CiAjLCBjLWZvcm1hdAogbXNnaWQgInBhdGggJyVzJyBpcyB1bm1lcmdlZCIKIG1zZ3N0ciAi0L/RitGC0Y/RgiDigJ4lc+KAnCDQvdC1INC1INGB0LvRj9GCIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6Njc5CisjOiBidWlsdGluL2NoZWNrb3V0LmM6NjgwCiBtc2dpZCAieW91IG5lZWQgdG8gcmVzb2x2ZSB5b3VyIGN1cnJlbnQgaW5kZXggZmlyc3QiCiBtc2dzdHIgItC/0YrRgNCy0L4g0YLRgNGP0LHQstCwINC00LAg0LrQvtGA0LjQs9C40YDQsNGC0LUg0LjQvdC00LXQutGB0LAg0YHQuCIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjcyOQorIzogYnVpbHRpbi9jaGVja291dC5jOjczMAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiY2Fubm90IGNvbnRpbnVlIHdpdGggc3RhZ2VkIGNoYW5nZXMgaW4gdGhlIGZvbGxvd2luZyBmaWxlczpcbiIKQEAgLTEwNjEzLDExICsxMDY1Miw2IEBACiAi0LjQvdC00LXQutGB0LA6XG4iCiAiJXMiCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo3MzYKLSMsIGMtZm9ybWF0Ci1tc2dpZCAic3RhZ2VkIGNoYW5nZXMgaW4gdGhlIGZvbGxvd2luZyBmaWxlcyBtYXkgYmUgbG9zdDogJXMiCi1tc2dzdHIgItC70L7QutCw0LvQvdC40YLQtSDQv9GA0L7QvNC10L3QuCDQsiDRgtC10LfQuCDRhNCw0LnQu9C+0LLQtSDRidC1INGB0LUg0L/RgNC10LfQsNC/0LjRiNCw0YI6ICVzIgotCiAjOiBidWlsdGluL2NoZWNrb3V0LmM6ODMzCiAjLCBjLWZvcm1hdAogbXNnaWQgIkNhbiBub3QgZG8gcmVmbG9nIGZvciAnJXMnOiAlc1xuIgpAQCAtMTA2MjcsNyArMTA2NjEsNyBAQAogbXNnaWQgIkhFQUQgaXMgbm93IGF0IgogbXNnc3RyICLQo9C60LDQt9Cw0YLQtdC70Y/RgiDigJ5IRUFE4oCcINCyINC80L7QvNC10L3RgtCwINGB0L7Rh9C4INC60YrQvCIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjg3OSBidWlsdGluL2Nsb25lLmM6NzE0CisjOiBidWlsdGluL2NoZWNrb3V0LmM6ODc5IGJ1aWx0aW4vY2xvbmUuYzo3MTMKIG1zZ2lkICJ1bmFibGUgdG8gdXBkYXRlIEhFQUQiCiBtc2dzdHIgItCj0LrQsNC30LDRgtC10LvRj9GCIOKAnkhFQUTigJwg0L3QtSDQvNC+0LbQtSDQtNCwINCx0YrQtNC1INC+0LHQvdC+0LLQtdC9IgogCkBAIC0xMDc0MCw3ICsxMDc3NCw3IEBACiAi4oCeJXPigJwg0LzQvtC20LUg0LTQsCDQtSDQutCw0LrRgtC+INC70L7QutCw0LvQtdC9INGE0LDQudC7LCDRgtCw0LrQsCDQuCDRgdC70LXQtNGP0Ykg0LrQu9C+0L0uICDQl9CwINGD0YLQvtGH0L3Rj9Cy0LDQvdC1XG4iCiAi0L/QvtC70LfQstCw0LnRgtC1INGA0LDQt9C00LXQu9C40YLQtdC70Y8g4oCeLS3igJwgKNC4INC10LLQtdC90YLRg9Cw0LvQvdC+INC+0L/RhtC40Y/RgtCwIOKAni0tbm8tZ3Vlc3PigJwpIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6MTI0MyBidWlsdGluL3dvcmt0cmVlLmM6MjkxIGJ1aWx0aW4vd29ya3RyZWUuYzo0NTYKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxMjQzIGJ1aWx0aW4vd29ya3RyZWUuYzoyOTAgYnVpbHRpbi93b3JrdHJlZS5jOjQ1NQogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIHJlZmVyZW5jZTogJXMiCiBtc2dzdHIgItC90LXQv9GA0LDQstC40LvQtdC9INGD0LrQsNC30LDRgtC10Ls6ICVzIgpAQCAtMTA4NDYsOSArMTA4ODAsOSBAQAogbXNnaWQgIm1pc3NpbmcgYnJhbmNoIG9yIGNvbW1pdCBhcmd1bWVudCIKIG1zZ3N0ciAi0LvQuNC/0YHQstCwINCw0YDQs9GD0LzQtdC90YIg4oCUINC60LvQvtC9INC40LvQuCDQv9C+0LTQsNCy0LDQvdC1IgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6MTQzNyBidWlsdGluL2Nsb25lLmM6OTEgYnVpbHRpbi9mZXRjaC5jOjE1MQotIzogYnVpbHRpbi9tZXJnZS5jOjI4NSBidWlsdGluL3B1bGwuYzoxMzcgYnVpbHRpbi9wdXNoLmM6NTc1Ci0jOiBidWlsdGluL3NlbmQtcGFjay5jOjE3NAorIzogYnVpbHRpbi9jaGVja291dC5jOjE0MzcgYnVpbHRpbi9jbG9uZS5jOjkwIGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6NTkKKyM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTgwIGJ1aWx0aW4vZmV0Y2guYzoxNjYgYnVpbHRpbi9tZXJnZS5jOjI4NQorIzogYnVpbHRpbi9wdWxsLmM6MTM4IGJ1aWx0aW4vcHVzaC5jOjU2MiBidWlsdGluL3NlbmQtcGFjay5jOjE3NAogbXNnaWQgImZvcmNlIHByb2dyZXNzIHJlcG9ydGluZyIKIG1zZ3N0ciAi0LjQt9Cy0LXQttC00LDQvdC1INC90LAg0L3QsNC/0YDQtdC00YrQutCwIgogCkBAIC0xMDg1Niw3ICsxMDg5MCw3IEBACiBtc2dpZCAicGVyZm9ybSBhIDMtd2F5IG1lcmdlIHdpdGggdGhlIG5ldyBicmFuY2giCiBtc2dzdHIgItC40LfQstGK0YDRiNCy0LDQvdC1INC90LAg0YLRgNC+0LnQvdC+INGB0LvQuNCy0LDQvdC1INGBINC90L7QstC40Y8g0LrQu9C+0L0iCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNDM5IGJ1aWx0aW4vbG9nLmM6MTYxNyBwYXJzZS1vcHRpb25zLmg6MzE4CisjOiBidWlsdGluL2NoZWNrb3V0LmM6MTQzOSBidWlsdGluL2xvZy5jOjE2MTggcGFyc2Utb3B0aW9ucy5oOjMxOAogbXNnaWQgInN0eWxlIgogbXNnc3RyICLQodCi0JjQmyIKIApAQCAtMTA4NjQsNyArMTA4OTgsNyBAQAogbXNnaWQgImNvbmZsaWN0IHN0eWxlIChtZXJnZSBvciBkaWZmMykiCiBtc2dzdHIgItC00LXQudGB0YLQstC40LUg0L/RgNC4INC60L7QvdGE0LvQuNC60YIgKNGB0LvQuNCy0LDQvdC1INC40LvQuCDRgtGA0L7QudC90LAg0YDQsNC30LvQuNC60LApIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6MTQ1MiBidWlsdGluL3dvcmt0cmVlLmM6NTA0CisjOiBidWlsdGluL2NoZWNrb3V0LmM6MTQ1MiBidWlsdGluL3dvcmt0cmVlLmM6NTAzCiBtc2dpZCAiZGV0YWNoIEhFQUQgYXQgbmFtZWQgY29tbWl0IgogbXNnc3RyICLQvtGC0LTQtdC70Y/QvdC1INC90LAg0YPQutCw0LfQsNGC0LXQu9GPIOKAnkhFQUTigJwg0LrRitC8INGD0LrQsNC30LDQvdC+0YLQviDQv9C+0LTQsNCy0LDQvdC1IgogCkBAIC0xMDk4MSw5ICsxMTAxNSw5IEBACiAiXG4iCiAiICAgIGNoZWNrb3V0LmRlZmF1bHRSZW1vdGU9b3JpZ2luIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6MTY5MSBidWlsdGluL2NoZWNrb3V0LmM6MTY5MyBidWlsdGluL2NoZWNrb3V0LmM6MTczMwotIzogYnVpbHRpbi9jaGVja291dC5jOjE3MzUgYnVpbHRpbi9jbG9uZS5jOjEyMSBidWlsdGluL3JlbW90ZS5jOjE2OQotIzogYnVpbHRpbi9yZW1vdGUuYzoxNzEgYnVpbHRpbi93b3JrdHJlZS5jOjUwMCBidWlsdGluL3dvcmt0cmVlLmM6NTAyCisjOiBidWlsdGluL2NoZWNrb3V0LmM6MTY5MSBidWlsdGluL2NoZWNrb3V0LmM6MTY5MyBidWlsdGluL2NoZWNrb3V0LmM6MTc0MgorIzogYnVpbHRpbi9jaGVja291dC5jOjE3NDQgYnVpbHRpbi9jbG9uZS5jOjEyMCBidWlsdGluL3JlbW90ZS5jOjE2OQorIzogYnVpbHRpbi9yZW1vdGUuYzoxNzEgYnVpbHRpbi93b3JrdHJlZS5jOjQ5OSBidWlsdGluL3dvcmt0cmVlLmM6NTAxCiBtc2dpZCAiYnJhbmNoIgogbXNnc3RyICLQutC70L7QvSIKIApAQCAtMTEwMDksNDEgKzExMDQzLDQxIEBACiBtc2dpZCAidXNlIG92ZXJsYXkgbW9kZSAoZGVmYXVsdCkiCiBtc2dzdHIgItC40LfQv9C+0LvQt9Cy0LDQvdC1INC90LAg0L/RgNC40L/QvtC60YDQuNCy0LDRiSDRgNC10LbQuNC8ICjRgdGC0LDQvdC00LDRgNGC0L3QvikiCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzM0CisjOiBidWlsdGluL2NoZWNrb3V0LmM6MTc0MwogbXNnaWQgImNyZWF0ZSBhbmQgc3dpdGNoIHRvIGEgbmV3IGJyYW5jaCIKIG1zZ3N0ciAi0YHRitC30LTQsNCy0LDQvdC1INC4INC/0YDQtdC80LjQvdCw0LLQsNC90LUg0LrRitC8INC90L7QsiDQutC70L7QvSIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjE3MzYKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzQ1CiBtc2dpZCAiY3JlYXRlL3Jlc2V0IGFuZCBzd2l0Y2ggdG8gYSBicmFuY2giCiBtc2dzdHIgItGB0YrQt9C00LDQstCw0L3QtS/Qt9Cw0L3Rg9C70Y/QstCw0L3QtSDQvdCwINC60LvQvtC9INC4INC/0YDQtdC80LjQvdCw0LLQsNC90LUg0LrRitC8INC90LXQs9C+IgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6MTczOAorIzogYnVpbHRpbi9jaGVja291dC5jOjE3NDcKIG1zZ2lkICJzZWNvbmQgZ3Vlc3MgJ2dpdCBzd2l0Y2ggPG5vLXN1Y2gtYnJhbmNoPiciCiBtc2dzdHIgIiIKICLQvtC/0LjRgiDQt9CwINC+0YLQs9Cw0YLQstCw0L3QtSDQvdCwINC40LzQtSDQvdCwINC60LvQvtC9INGB0LvQtdC0INC90LXRg9GB0L/QtdGI0LXQvSDQvtC/0LjRgiDRgSDigJ5naXQgc3dpdGNoICIKICLQndCV0KHQqtCp0JXQodCi0JLQo9CS0JDQqV/QmtCb0J7QneKAnCIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjE3NDAKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzQ5CiBtc2dpZCAidGhyb3cgYXdheSBsb2NhbCBtb2RpZmljYXRpb25zIgogbXNnc3RyICLQt9Cw0L3Rg9C70Y/QstCw0L3QtSDQvdCwINC70L7QutCw0LvQvdC40YLQtSDQv9GA0L7QvNC10L3QuCIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjE3NzIKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzgxCiBtc2dpZCAid2hpY2ggdHJlZS1pc2ggdG8gY2hlY2tvdXQgZnJvbSIKIG1zZ3N0ciAi0LrRitC8INC60L7QuSDRg9C60LDQt9Cw0YLQtdC7INC60YrQvCDQtNGK0YDQstC+INC00LAg0YHQtSDQv9GA0LXQvNC40L3QtSIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjE3NzQKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzgzCiBtc2dpZCAicmVzdG9yZSB0aGUgaW5kZXgiCiBtc2dzdHIgItCy0YrQt9GB0YLQsNC90L7QstGP0LLQsNC90LUg0L3QsCDQuNC90LTQtdC60YHQsCIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjE3NzYKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzg1CiBtc2dpZCAicmVzdG9yZSB0aGUgd29ya2luZyB0cmVlIChkZWZhdWx0KSIKIG1zZ3N0ciAi0LLRitC30YHRgtCw0L3QvtCy0Y/QstCw0L3QtSDQvdCwINGA0LDQsdC+0YLQvdC+0YLQviDQtNGK0YDQstC+ICjRgdGC0LDQvdC00LDRgNGC0L3QvikiCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzc4CisjOiBidWlsdGluL2NoZWNrb3V0LmM6MTc4NwogbXNnaWQgImlnbm9yZSB1bm1lcmdlZCBlbnRyaWVzIgogbXNnc3RyICLQv9GA0LXQvdC10LHRgNC10LPQstCw0L3QtSDQvdCwINC90LXRgdC70LXRgtC40YLQtSDQtdC70LXQvNC10L3RgtC4IgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6MTc3OQorIzogYnVpbHRpbi9jaGVja291dC5jOjE3ODgKIG1zZ2lkICJ1c2Ugb3ZlcmxheSBtb2RlIgogbXNnc3RyICLQuNC30L/QvtC70LfQstCw0L3QtSDQvdCwINC/0YDQuNC/0L7QutGA0LjQstCw0Ykg0YDQtdC20LjQvCIKIApAQCAtMTEwODIsNyArMTExMTYsNyBAQAogbXNnaWQgImNvdWxkIG5vdCBsc3RhdCAlc1xuIgogbXNnc3RyICLQvdC1INC80L7QttC1INC00LAg0YHQtSDQv9C+0LvRg9GH0Lgg0LjQvdGE0L7RgNC80LDRhtC40Y8g0YfRgNC10Lcg4oCebHN0YXTigJwg0LfQsCDigJ4lc+KAnFxuIgogCi0jOiBidWlsdGluL2NsZWFuLmM6MzAwIGdpdC1hZGQtLWludGVyYWN0aXZlLnBlcmw6NTkzCisjOiBidWlsdGluL2NsZWFuLmM6MzAxIGdpdC1hZGQtLWludGVyYWN0aXZlLnBlcmw6NTkzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJQcm9tcHQgaGVscDpcbiIKQEAgLTExMDk1LDcgKzExMTI5LDcgQEAKICLQn9Cg0JXQpNCY0JrQoSAgICDigJQg0LjQt9Cx0L7RgCDQvdCwINC10LTQuNC90YHRgtCy0LXQvSDQvtCx0LXQutGCINC/0L4g0YLQvtC30Lgg0YPQvdC40LrQsNC70LXQvSDQv9GA0LXRhNC40LrRgVxuIgogIiAgICAgICAgICAg4oCUICjQv9GA0LDQt9C90L4pINC90LjRidC+INC00LAg0L3QtSDRgdC1INC40LfQsdC40YDQsFxuIgogCi0jOiBidWlsdGluL2NsZWFuLmM6MzA0IGdpdC1hZGQtLWludGVyYWN0aXZlLnBlcmw6NjAyCisjOiBidWlsdGluL2NsZWFuLmM6MzA1IGdpdC1hZGQtLWludGVyYWN0aXZlLnBlcmw6NjAyCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJQcm9tcHQgaGVscDpcbiIKQEAgLTExMTE2LDM5ICsxMTE1MCwzOSBAQAogIiogICAgICAgICAg4oCUINC40LfQsdC40YDQsNC90LUg0L3QsCDQstGB0LjRh9C60Lgg0L7QsdC10LrRgtC4XG4iCiAiICAgICAgICAgICDigJQgKNC/0YDQsNC30L3Qvikg0LfQsNCy0YrRgNGI0LLQsNC90LUg0L3QsCDQuNC30LHQuNGA0LDQvdC10YLQvlxuIgogCi0jOiBidWlsdGluL2NsZWFuLmM6NTIwIGdpdC1hZGQtLWludGVyYWN0aXZlLnBlcmw6NTY4CisjOiBidWlsdGluL2NsZWFuLmM6NTIxIGdpdC1hZGQtLWludGVyYWN0aXZlLnBlcmw6NTY4CiAjOiBnaXQtYWRkLS1pbnRlcmFjdGl2ZS5wZXJsOjU3MwogIywgYy1mb3JtYXQsIHBlcmwtZm9ybWF0CiBtc2dpZCAiSHVoICglcyk/XG4iCiBtc2dzdHIgItCd0LXQv9GA0LDQstC40LvQtdC9INC40LfQsdC+0YAgKCVzKS5cbiIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjY2MgorIzogYnVpbHRpbi9jbGVhbi5jOjY2MwogIywgYy1mb3JtYXQKIG1zZ2lkICJJbnB1dCBpZ25vcmUgcGF0dGVybnM+PiAiCiBtc2dzdHIgItCo0LDQsdC70L7QvdC4INC30LAg0LjQs9C90L7RgNC40YDQsNC90Lgg0LXQu9C10LzQtdC90YLQuOKJqyAiCiAKLSM6IGJ1aWx0aW4vY2xlYW4uYzo2OTkKKyM6IGJ1aWx0aW4vY2xlYW4uYzo3MDAKICMsIGMtZm9ybWF0CiBtc2dpZCAiV0FSTklORzogQ2Fubm90IGZpbmQgaXRlbXMgbWF0Y2hlZCBieTogJXMiCiBtc2dzdHIgItCf0KDQldCU0KPQn9Cg0JXQltCU0JXQndCY0JU6INCd0LjQutC+0Lkg0L7QsdC10LrRgiDQvdC1INC90LDQv9Cw0YHQstCwINC90LAg4oCeJXPigJwiCiAKLSM6IGJ1aWx0aW4vY2xlYW4uYzo3MjAKKyM6IGJ1aWx0aW4vY2xlYW4uYzo3MjEKIG1zZ2lkICJTZWxlY3QgaXRlbXMgdG8gZGVsZXRlIgogbXNnc3RyICLQmNC30LHQuNGA0LDQvdC1INC90LAg0L7QsdC10LrRgtC4INC30LAg0LjQt9GC0YDQuNCy0LDQvdC1IgogCiAjLiBUUkFOU0xBVE9SUzogTWFrZSBzdXJlIHRvIGtlZXAgW3kvTl0gYXMgaXMKLSM6IGJ1aWx0aW4vY2xlYW4uYzo3NjEKKyM6IGJ1aWx0aW4vY2xlYW4uYzo3NjIKICMsIGMtZm9ybWF0CiBtc2dpZCAiUmVtb3ZlICVzIFt5L05dPyAiCiBtc2dzdHIgItCU0LAg0YHQtSDQuNC30YLRgNC40LUg0LvQuCDigJ4lc+KAnD8g4oCeeeKAnCDigJQgINC00LAsIOKAnk7igJwg4oCUINCd0JUiCiAKICMKLSM6IGJ1aWx0aW4vY2xlYW4uYzo3ODYgZ2l0LWFkZC0taW50ZXJhY3RpdmUucGVybDoxNzYzCisjOiBidWlsdGluL2NsZWFuLmM6Nzg3IGdpdC1hZGQtLWludGVyYWN0aXZlLnBlcmw6MTc2MwogIywgYy1mb3JtYXQKIG1zZ2lkICJCeWUuXG4iCiBtc2dzdHIgItCY0LfRhdC+0LQuXG4iCiAKLSM6IGJ1aWx0aW4vY2xlYW4uYzo3OTQKKyM6IGJ1aWx0aW4vY2xlYW4uYzo3OTUKIG1zZ2lkICIiCiAiY2xlYW4gICAgICAgICAgICAgICAtIHN0YXJ0IGNsZWFuaW5nXG4iCiAiZmlsdGVyIGJ5IHBhdHRlcm4gICAtIGV4Y2x1ZGUgaXRlbXMgZnJvbSBkZWxldGlvblxuIgpAQCAtMTExNjYsNjQgKzExMjAwLDY0IEBACiAiaGVscCAgICAgICAgICAgICAgICDigJQg0YLQvtC30Lgg0LrRgNCw0LlcbiIKICI/ICAgICAgICAgICAgICAgICAgIOKAlCDQv9C+0LTRgdC60LDQt9C60LAg0LfQsCDRiNCw0LHQu9C+0L3QuNGC0LUiCiAKLSM6IGJ1aWx0aW4vY2xlYW4uYzo4MjEgZ2l0LWFkZC0taW50ZXJhY3RpdmUucGVybDoxODQ5CisjOiBidWlsdGluL2NsZWFuLmM6ODIyIGdpdC1hZGQtLWludGVyYWN0aXZlLnBlcmw6MTg0OQogbXNnaWQgIioqKiBDb21tYW5kcyAqKioiCiBtc2dzdHIgIuKXj+KXj+KXjyDQmtC+0LzQsNC90LTQuCDil4/il4/il48iCiAKLSM6IGJ1aWx0aW4vY2xlYW4uYzo4MjIgZ2l0LWFkZC0taW50ZXJhY3RpdmUucGVybDoxODQ2CisjOiBidWlsdGluL2NsZWFuLmM6ODIzIGdpdC1hZGQtLWludGVyYWN0aXZlLnBlcmw6MTg0NgogbXNnaWQgIldoYXQgbm93IgogbXNnc3RyICLQmNC30LHQvtGAINC90LAg0YHQu9C10LTQstCw0YnQviDQtNC10LnRgdGC0LLQuNC1IgogCi0jOiBidWlsdGluL2NsZWFuLmM6ODMwCisjOiBidWlsdGluL2NsZWFuLmM6ODMxCiBtc2dpZCAiV291bGQgcmVtb3ZlIHRoZSBmb2xsb3dpbmcgaXRlbToiCiBtc2dpZF9wbHVyYWwgIldvdWxkIHJlbW92ZSB0aGUgZm9sbG93aW5nIGl0ZW1zOiIKIG1zZ3N0clswXSAi0KHQu9C10LTQvdC40Y/RgiDQvtCx0LXQutGCINGJ0LUg0LHRitC00LUg0LjQt9GC0YDQuNGCOiIKIG1zZ3N0clsxXSAi0KHQu9C10LTQvdC40YLQtSDQvtCx0LXQutGC0Lgg0YnQtSDQsdGK0LTQsNGCINC40LfRgtGA0LjRgtC4OiIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjg0NgorIzogYnVpbHRpbi9jbGVhbi5jOjg0NwogbXNnaWQgIk5vIG1vcmUgZmlsZXMgdG8gY2xlYW4sIGV4aXRpbmcuIgogbXNnc3RyICLQpNCw0LnQu9C+0LLQtdGC0LUg0LfQsCDQuNC30YfQuNGB0YLQstCw0L3QtSDRgdCy0YrRgNGI0LjRhdCwLiAg0JjQt9GF0L7QtCDQvtGCINC/0YDQvtCz0YDQsNC80LDRgtCwLiIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjkwOAorIzogYnVpbHRpbi9jbGVhbi5jOjkwOQogbXNnaWQgImRvIG5vdCBwcmludCBuYW1lcyBvZiBmaWxlcyByZW1vdmVkIgogbXNnc3RyICLQsdC10Lcg0LjQt9Cy0LXQttC00LDQvdC1INC90LAg0LjQvNC10L3QsNGC0LAg0L3QsCDRhNCw0LnQu9C+0LLQtdGC0LUsINC60L7QuNGC0L4g0YnQtSDQsdGK0LTQsNGCINC40LfRgtGA0LjRgtC4IgogCi0jOiBidWlsdGluL2NsZWFuLmM6OTEwCisjOiBidWlsdGluL2NsZWFuLmM6OTExCiBtc2dpZCAiZm9yY2UiCiBtc2dzdHIgItC/0YDQuNC90YPQtNC40YLQtdC70L3QviDQuNC30YLRgNC40LLQsNC90LUiCiAKLSM6IGJ1aWx0aW4vY2xlYW4uYzo5MTEKKyM6IGJ1aWx0aW4vY2xlYW4uYzo5MTIKIG1zZ2lkICJpbnRlcmFjdGl2ZSBjbGVhbmluZyIKIG1zZ3N0ciAi0LjQvdGC0LXRgNCw0LrRgtC40LLQvdC+INC40LfRgtGA0LjQstCw0L3QtSIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjkxMworIzogYnVpbHRpbi9jbGVhbi5jOjkxNAogbXNnaWQgInJlbW92ZSB3aG9sZSBkaXJlY3RvcmllcyIKIG1zZ3N0ciAi0LjQt9GC0YDQuNCy0LDQvdC1INC90LAg0YbQtdC70Lgg0LTQuNGA0LXQutGC0L7RgNC40LgiCiAKLSM6IGJ1aWx0aW4vY2xlYW4uYzo5MTQgYnVpbHRpbi9kZXNjcmliZS5jOjU0NiBidWlsdGluL2Rlc2NyaWJlLmM6NTQ4Ci0jOiBidWlsdGluL2dyZXAuYzo4OTkgYnVpbHRpbi9sb2cuYzoxNzYgYnVpbHRpbi9sb2cuYzoxNzgKLSM6IGJ1aWx0aW4vbHMtZmlsZXMuYzo1NTcgYnVpbHRpbi9uYW1lLXJldi5jOjQxMyBidWlsdGluL25hbWUtcmV2LmM6NDE1CisjOiBidWlsdGluL2NsZWFuLmM6OTE1IGJ1aWx0aW4vZGVzY3JpYmUuYzo1NDggYnVpbHRpbi9kZXNjcmliZS5jOjU1MAorIzogYnVpbHRpbi9ncmVwLmM6OTAxIGJ1aWx0aW4vbG9nLmM6MTc2IGJ1aWx0aW4vbG9nLmM6MTc4CisjOiBidWlsdGluL2xzLWZpbGVzLmM6NTU3IGJ1aWx0aW4vbmFtZS1yZXYuYzo0MTcgYnVpbHRpbi9uYW1lLXJldi5jOjQxOQogIzogYnVpbHRpbi9zaG93LXJlZi5jOjE3OQogbXNnaWQgInBhdHRlcm4iCiBtc2dzdHIgItCo0JDQkdCb0J7QnSIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjkxNQorIzogYnVpbHRpbi9jbGVhbi5jOjkxNgogbXNnaWQgImFkZCA8cGF0dGVybj4gdG8gaWdub3JlIHJ1bGVzIgogbXNnc3RyICLQtNC+0LHQsNCy0Y/QvdC1INC90LAg0KjQkNCR0JvQntCdINC+0YIg0YTQsNC50LvQvtCy0LUsINC60L7QuNGC0L4g0LTQsCDQvdC1INGB0LUg0YLRgNC40Y/RgiIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjkxNgorIzogYnVpbHRpbi9jbGVhbi5jOjkxNwogbXNnaWQgInJlbW92ZSBpZ25vcmVkIGZpbGVzLCB0b28iCiBtc2dzdHIgItC40LfRgtGA0LjQstCw0L3QtSDQuCDQvdCwINC40LPQvdC+0YDQuNGA0LDQvdC40YLQtSDRhNCw0LnQu9C+0LLQtSIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjkxOAorIzogYnVpbHRpbi9jbGVhbi5jOjkxOQogbXNnaWQgInJlbW92ZSBvbmx5IGlnbm9yZWQgZmlsZXMiCiBtc2dzdHIgItC40LfRgtGA0LjQstCw0L3QtSDRgdCw0LzQviDQvdCwINC40LPQvdC+0YDQuNGA0LDQvdC4INGE0LDQudC70L7QstC1IgogCi0jOiBidWlsdGluL2NsZWFuLmM6OTM2CisjOiBidWlsdGluL2NsZWFuLmM6OTM3CiBtc2dpZCAiLXggYW5kIC1YIGNhbm5vdCBiZSB1c2VkIHRvZ2V0aGVyIgogbXNnc3RyICLQvtC/0YbQuNC40YLQtSDigJ4teOKAnCDQuCDigJ4tWOKAnCDRgdCwINC90LXRgdGK0LLQvNC10YHRgtC40LzQuCIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjk0MAorIzogYnVpbHRpbi9jbGVhbi5jOjk0MQogbXNnaWQgIiIKICJjbGVhbi5yZXF1aXJlRm9yY2Ugc2V0IHRvIHRydWUgYW5kIG5laXRoZXIgLWksIC1uLCBub3IgLWYgZ2l2ZW47IHJlZnVzaW5nIHRvICIKICJjbGVhbiIKQEAgLTExMjMxLDcgKzExMjY1LDcgQEAKICLQndCw0YHRgtGA0L7QudC60LDRgtCwIOKAnmNsZWFuLnJlcXVpcmVGb3JjZeKAnCDQtSDQt9Cw0LTQsNC00LXQvdCwINC60LDRgtC+INC40YHRgtC40L3QsCwg0LrQvtC10YLQviDQuNC30LjRgdC60LLQsCDQvdGP0LrQvtGPICIKICLQvtGCINC+0L/RhtC40LjRgtC1IOKAni1p4oCcLCDigJ4tbuKAnCDQuNC70Lgg4oCeLWbigJwuICDQndGP0LzQsCDQtNCwINGB0LUg0LjQt9Cy0YrRgNGI0Lgg0LjQt9GH0LjRgdGC0LLQsNC90LUiCiAKLSM6IGJ1aWx0aW4vY2xlYW4uYzo5NDMKKyM6IGJ1aWx0aW4vY2xlYW4uYzo5NDQKIG1zZ2lkICIiCiAiY2xlYW4ucmVxdWlyZUZvcmNlIGRlZmF1bHRzIHRvIHRydWUgYW5kIG5laXRoZXIgLWksIC1uLCBub3IgLWYgZ2l2ZW47ICIKICJyZWZ1c2luZyB0byBjbGVhbiIKQEAgLTExMjQwLDE2NCArMTEyNzQsMTY0IEBACiAi0LrQvtC10YLQviDQuNC30LjRgdC60LLQsCDQvdGP0LrQvtGPINC+0YIg0L7Qv9GG0LjQuNGC0LUg4oCeLWnigJwsIOKAni1u4oCcINC40LvQuCDigJ4tZuKAnC4gINCd0Y/QvNCwINC00LAg0YHQtSDQuNC30LLRitGA0YjQuCAiCiAi0LjQt9GH0LjRgdGC0LLQsNC90LUiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo0NgorIzogYnVpbHRpbi9jbG9uZS5jOjQ1CiBtc2dpZCAiZ2l0IGNsb25lIFs8b3B0aW9ucz5dIFstLV0gPHJlcG8+IFs8ZGlyPl0iCiBtc2dzdHIgImdpdCBjbG9uZSBb0J7Qn9Cm0JjQr+KApl0gWy0tXSDQpdCg0JDQndCY0JvQmNCp0JUgW9CU0JjQoNCV0JrQotCe0KDQmNCvXSIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjkzCisjOiBidWlsdGluL2Nsb25lLmM6OTIKIG1zZ2lkICJkb24ndCBjcmVhdGUgYSBjaGVja291dCIKIG1zZ3N0ciAi0LHQtdC3INGB0YrQt9C00LDQstCw0L3QtSDQvdCwINGA0LDQsdC+0YLQvdC+INC00YrRgNCy0L4iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo5NCBidWlsdGluL2Nsb25lLmM6OTYgYnVpbHRpbi9pbml0LWRiLmM6NDg5CisjOiBidWlsdGluL2Nsb25lLmM6OTMgYnVpbHRpbi9jbG9uZS5jOjk1IGJ1aWx0aW4vaW5pdC1kYi5jOjQ4OQogbXNnaWQgImNyZWF0ZSBhIGJhcmUgcmVwb3NpdG9yeSIKIG1zZ3N0ciAi0YHRitC30LTQsNCy0LDQvdC1INC90LAg0LPQvtC70L4g0YXRgNCw0L3QuNC70LjRidC1IgogCi0jOiBidWlsdGluL2Nsb25lLmM6OTgKKyM6IGJ1aWx0aW4vY2xvbmUuYzo5NwogbXNnaWQgImNyZWF0ZSBhIG1pcnJvciByZXBvc2l0b3J5IChpbXBsaWVzIGJhcmUpIgogbXNnc3RyICIiCiAi0YHRitC30LTQsNCy0LDQvdC1INC90LAg0YXRgNCw0L3QuNC70LjRidC1LdC+0LPQu9C10LTQsNC70L4gKNCy0LrQu9GO0YfQstCwINC+0L/RhtC40Y/RgtCwIOKAni0tYmFyZeKAnCDQt9CwINCz0L7Qu9C+INGF0YDQsNC90LjQu9C40YnQtSkiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMDAKKyM6IGJ1aWx0aW4vY2xvbmUuYzo5OQogbXNnaWQgInRvIGNsb25lIGZyb20gYSBsb2NhbCByZXBvc2l0b3J5IgogbXNnc3RyICLQutC70L7QvdC40YDQsNC90LUg0L7RgiDQu9C+0LrQsNC70L3QviDRhdGA0LDQvdC40LvQuNGJ0LUiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMDIKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMDEKIG1zZ2lkICJkb24ndCB1c2UgbG9jYWwgaGFyZGxpbmtzLCBhbHdheXMgY29weSIKIG1zZ3N0ciAi0LHQtdC3INGC0LLRitGA0LTQuCDQstGA0YrQt9C60LgsINGE0LDQudC70L7QstC10YLQtSDQstC40L3QsNCz0Lgg0LTQsCDRgdC1INC60L7Qv9C40YDQsNGCIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTA0CisjOiBidWlsdGluL2Nsb25lLmM6MTAzCiBtc2dpZCAic2V0dXAgYXMgc2hhcmVkIHJlcG9zaXRvcnkiCiBtc2dzdHIgItC90LDRgdGC0YDQvtC50LLQsNC90LUg0LfQsCDRgdC/0L7QtNC10LvQtdC90L4g0YXRgNCw0L3QuNC70LjRidC1IgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTA3CisjOiBidWlsdGluL2Nsb25lLmM6MTA2CiBtc2dpZCAicGF0aHNwZWMiCiBtc2dzdHIgItC/0YrRgiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEwNworIzogYnVpbHRpbi9jbG9uZS5jOjEwNgogbXNnaWQgImluaXRpYWxpemUgc3VibW9kdWxlcyBpbiB0aGUgY2xvbmUiCiBtc2dzdHIgItC40L3QuNGG0LjQsNC70LjQt9C40YDQsNC90LUg0L3QsCDQv9C+0LTQvNC+0LTRg9C70LjRgtC1INC/0YDQuCDRgtC+0LLQsCDQutC70L7QvdC40YDQsNC90LUiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMTAKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMDkKIG1zZ2lkICJudW1iZXIgb2Ygc3VibW9kdWxlcyBjbG9uZWQgaW4gcGFyYWxsZWwiCiBtc2dzdHIgItCx0YDQvtC5INC/0L7QtNC80L7QtNGD0LvQuCwg0LrQu9C+0L3QuNGA0LDQvdC4INC/0LDRgNCw0LvQtdC70L3QviIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjExMSBidWlsdGluL2luaXQtZGIuYzo0ODYKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMTAgYnVpbHRpbi9pbml0LWRiLmM6NDg2CiBtc2dpZCAidGVtcGxhdGUtZGlyZWN0b3J5IgogbXNnc3RyICLQtNC40YDQtdC60YLQvtGA0LjRjyDRgSDRiNCw0LHQu9C+0L3QuCIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjExMiBidWlsdGluL2luaXQtZGIuYzo0ODcKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMTEgYnVpbHRpbi9pbml0LWRiLmM6NDg3CiBtc2dpZCAiZGlyZWN0b3J5IGZyb20gd2hpY2ggdGVtcGxhdGVzIHdpbGwgYmUgdXNlZCIKIG1zZ3N0ciAi0LTQuNGA0LXQutGC0L7RgNC40Y8sINC60L7Rj9GC0L4g0YHRitC00YrRgNC20LAg0YjQsNCx0LvQvtC90LjRgtC1LCDQutC+0LjRgtC+INC00LAg0YHQtSDQv9C+0LvQt9Cy0LDRgiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjExNCBidWlsdGluL2Nsb25lLmM6MTE2IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxMzgwCisjOiBidWlsdGluL2Nsb25lLmM6MTEzIGJ1aWx0aW4vY2xvbmUuYzoxMTUgYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjEzODAKICM6IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxODYwCiBtc2dpZCAicmVmZXJlbmNlIHJlcG9zaXRvcnkiCiBtc2dzdHIgItC10YLQsNC70L7QvdC90L4g0YXRgNCw0L3QuNC70LjRidC1IgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTE4IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxMzgyCisjOiBidWlsdGluL2Nsb25lLmM6MTE3IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxMzgyCiAjOiBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6MTg2MgogbXNnaWQgInVzZSAtLXJlZmVyZW5jZSBvbmx5IHdoaWxlIGNsb25pbmciCiBtc2dzdHIgItC+0L/RhtC40Y/RgtCwIOKAni0tcmVmZXJlbmNl4oCcINC80L7QttC1INC00LAg0YHQtSDQuNC30L/QvtC70LfQstCwINGB0LDQvNC+INC/0YDQuCDQutC70L7QvdC40YDQsNC90LUiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMTkgYnVpbHRpbi9jb2x1bW4uYzoyNyBidWlsdGluL21lcmdlLWZpbGUuYzo0NgotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzE0IGJ1aWx0aW4vcmVwYWNrLmM6MzE5CisjOiBidWlsdGluL2Nsb25lLmM6MTE4IGJ1aWx0aW4vY29sdW1uLmM6MjcgYnVpbHRpbi9tZXJnZS1maWxlLmM6NDYKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI5NCBidWlsdGluL3JlcGFjay5jOjMyMAogbXNnaWQgIm5hbWUiCiBtc2dzdHIgItCY0JzQlSIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEyMAorIzogYnVpbHRpbi9jbG9uZS5jOjExOQogbXNnaWQgInVzZSA8bmFtZT4gaW5zdGVhZCBvZiAnb3JpZ2luJyB0byB0cmFjayB1cHN0cmVhbSIKIG1zZ3N0ciAi0LjQt9C/0L7Qu9C30LLQsNC90LUg0L3QsCDRgtC+0LLQsCDQmNCc0JUg0LLQvNC10YHRgtC+IOKAnm9yaWdpbuKAnCDQv9GA0Lgg0L/RgNC+0YHQu9C10LTRj9Cy0LDQvdC1INC90LAg0LrQu9C+0L3QuCIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEyMgorIzogYnVpbHRpbi9jbG9uZS5jOjEyMQogbXNnaWQgImNoZWNrb3V0IDxicmFuY2g+IGluc3RlYWQgb2YgdGhlIHJlbW90ZSdzIEhFQUQiCiBtc2dzdHIgItC40LfRgtC10LPQu9GP0L3QtSDQvdCwINGC0L7Qt9C4INCa0JvQntCdLCDQsCDQvdC1INGB0L7Rh9C10L3QuNGP0YIg0L7RgiDQvtGC0LTQsNC70LXRh9C10L3QuNGPINGD0LrQsNC30LDRgtC10Lsg4oCeSEVBROKAnCIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEyNAorIzogYnVpbHRpbi9jbG9uZS5jOjEyMwogbXNnaWQgInBhdGggdG8gZ2l0LXVwbG9hZC1wYWNrIG9uIHRoZSByZW1vdGUiCiBtc2dzdHIgItC/0YrRgiDQutGK0Lwg0LrQvtC80LDQvdC00LDRgtCwIOKAnmdpdC11cGxvYWQtcGFja+KAnCDQvdCwINC+0YLQtNCw0LvQtdGH0LXQvdC+0YLQviDRhdGA0LDQvdC40LvQuNGJ0LUiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMjUgYnVpbHRpbi9mZXRjaC5jOjE1MiBidWlsdGluL2dyZXAuYzo4MzgKLSM6IGJ1aWx0aW4vcHVsbC5jOjIyNgorIzogYnVpbHRpbi9jbG9uZS5jOjEyNCBidWlsdGluL2ZldGNoLmM6MTY3IGJ1aWx0aW4vZ3JlcC5jOjg0MAorIzogYnVpbHRpbi9wdWxsLmM6MjI3CiBtc2dpZCAiZGVwdGgiCiBtc2dzdHIgItCU0KrQm9CR0J7Qp9CY0J3QkCIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEyNgorIzogYnVpbHRpbi9jbG9uZS5jOjEyNQogbXNnaWQgImNyZWF0ZSBhIHNoYWxsb3cgY2xvbmUgb2YgdGhhdCBkZXB0aCIKIG1zZ3N0ciAi0L/Qu9C40YLQutC+INC60LvQvtC90LjRgNCw0L3QtSDQtNC+INGC0LDQt9C4INCU0KrQm9CR0J7Qp9CY0J3QkCIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEyNyBidWlsdGluL2ZldGNoLmM6MTU0IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMwMworIzogYnVpbHRpbi9jbG9uZS5jOjEyNiBidWlsdGluL2ZldGNoLmM6MTY5IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI4MwogbXNnaWQgInRpbWUiCiBtc2dzdHIgItCS0KDQldCc0JUiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMjgKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMjcKIG1zZ2lkICJjcmVhdGUgYSBzaGFsbG93IGNsb25lIHNpbmNlIGEgc3BlY2lmaWMgdGltZSIKIG1zZ3N0ciAi0L/Qu9C40YLQutC+INC60LvQvtC90LjRgNCw0L3QtSDQtNC+INC80L7QvNC10L3RgiDQstGK0LIg0LLRgNC10LzQtdGC0L4iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMjkgYnVpbHRpbi9mZXRjaC5jOjE1NiBidWlsdGluL2ZldGNoLmM6MTc5Ci0jOiBidWlsdGluL3JlYmFzZS5jOjEzOTUKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMjggYnVpbHRpbi9mZXRjaC5jOjE3MSBidWlsdGluL2ZldGNoLmM6MTk0CisjOiBidWlsdGluL3JlYmFzZS5jOjE0MTcKIG1zZ2lkICJyZXZpc2lvbiIKIG1zZ3N0ciAi0JLQldCg0KHQmNCvIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTMwIGJ1aWx0aW4vZmV0Y2guYzoxNTcKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMjkgYnVpbHRpbi9mZXRjaC5jOjE3MgogbXNnaWQgImRlZXBlbiBoaXN0b3J5IG9mIHNoYWxsb3cgY2xvbmUsIGV4Y2x1ZGluZyByZXYiCiBtc2dzdHIgItC30LDQtNGK0LvQsdC+0YfQsNCy0LDQvdC1INC90LAg0LjRgdGC0L7RgNC40Y/RgtCwINC90LAg0L/Qu9C40YLQutC+INGF0YDQsNC90LjQu9C40YnQtSDQtNC+INC40LfQutC70Y7Rh9Cy0LDRiSDRg9C60LDQt9Cw0YLQtdC7IgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTMyCisjOiBidWlsdGluL2Nsb25lLmM6MTMxCiBtc2dpZCAiY2xvbmUgb25seSBvbmUgYnJhbmNoLCBIRUFEIG9yIC0tYnJhbmNoIgogbXNnc3RyICIiCiAi0LrQu9C+0L3QuNGA0LDQvdC1INGB0LDQvNC+INC90LAg0LXQtNC40L0g0LrQu9C+0L0g4oCUINC40LvQuCDRgdC+0YfQtdC90LjRjyDQvtGCINC+0YLQtNCw0LvQtdGH0LXQvdC40Y8g4oCeSEVBROKAnCwg0LjQu9C4INC40LfRgNC40YfQvdC+ICIKICLQt9Cw0LTQsNC00LXQvdC40Y8g0YEg4oCeLS1icmFuY2jigJwiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMzQKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMzMKIG1zZ2lkICJkb24ndCBjbG9uZSBhbnkgdGFncywgYW5kIG1ha2UgbGF0ZXIgZmV0Y2hlcyBub3QgdG8gZm9sbG93IHRoZW0iCiBtc2dzdHIgIiIKICLQsdC10Lcg0LrQu9C+0L3QuNGA0LDQvdC1INC90LAg0LXRgtC40LrQtdGC0LgsINC60LDRgtC+INC/0L7RgdC70LXQtNCy0LDRidC40YLQtSDQtNC+0YHRgtCw0LLRj9C90LjRjyDQvdGP0LzQsCDQtNCwINCz0Lgg0YHQu9C10LTRj9GCIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTM2CisjOiBidWlsdGluL2Nsb25lLmM6MTM1CiBtc2dpZCAiYW55IGNsb25lZCBzdWJtb2R1bGVzIHdpbGwgYmUgc2hhbGxvdyIKIG1zZ3N0ciAi0LLRgdC40YfQutC4INC60LvQvtC90LjRgNCw0L3QuCDQv9C+0LTQvNC+0LTRg9C70Lgg0YnQtSDRgdCwINC/0LvQuNGC0LrQuCIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEzNyBidWlsdGluL2luaXQtZGIuYzo0OTUKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMzYgYnVpbHRpbi9pbml0LWRiLmM6NDk1CiBtc2dpZCAiZ2l0ZGlyIgogbXNnc3RyICLQodCb0KPQltCV0JHQndCQX9CU0JjQoNCV0JrQotCe0KDQmNCvIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTM4IGJ1aWx0aW4vaW5pdC1kYi5jOjQ5NgorIzogYnVpbHRpbi9jbG9uZS5jOjEzNyBidWlsdGluL2luaXQtZGIuYzo0OTYKIG1zZ2lkICJzZXBhcmF0ZSBnaXQgZGlyIGZyb20gd29ya2luZyB0cmVlIgogbXNnc3RyICLQvtGC0LTQtdC70L3QsCDQodCb0KPQltCV0JHQndCQX9CU0JjQoNCV0JrQotCe0KDQmNCvINC30LAgZ2l0INC40LfQstGK0L0g0YDQsNCx0L7RgtC90L7RgtC+INC00YrRgNCy0L4iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMzkKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMzgKIG1zZ2lkICJrZXk9dmFsdWUiCiBtc2dzdHIgItCa0JvQrtCnPdCh0KLQntCZ0J3QntCh0KIiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxNDAKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMzkKIG1zZ2lkICJzZXQgY29uZmlnIGluc2lkZSB0aGUgbmV3IHJlcG9zaXRvcnkiCiBtc2dzdHIgItC30LDQtNCw0LLQsNC90LUg0L3QsCDQvdCw0YHRgtGA0L7QudC60LjRgtC1INC90LAg0L3QvtCy0L7RgtC+INGF0YDQsNC90LjQu9C40YnQtSIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjE0MiBidWlsdGluL2ZldGNoLmM6MTc0IGJ1aWx0aW4vbHMtcmVtb3RlLmM6NzYKLSM6IGJ1aWx0aW4vcHVzaC5jOjU4NSBidWlsdGluL3NlbmQtcGFjay5jOjE3MgorIzogYnVpbHRpbi9jbG9uZS5jOjE0MSBidWlsdGluL2ZldGNoLmM6MTg5IGJ1aWx0aW4vbHMtcmVtb3RlLmM6NzYKKyM6IGJ1aWx0aW4vcHVzaC5jOjU3MiBidWlsdGluL3NlbmQtcGFjay5jOjE3MgogbXNnaWQgInNlcnZlci1zcGVjaWZpYyIKIG1zZ3N0ciAi0YHQv9C10YbQuNGE0LjRh9C90Lgg0LfQsCDRgdGK0YDQstGK0YDQsCIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjE0MiBidWlsdGluL2ZldGNoLmM6MTc0IGJ1aWx0aW4vbHMtcmVtb3RlLmM6NzYKLSM6IGJ1aWx0aW4vcHVzaC5jOjU4NSBidWlsdGluL3NlbmQtcGFjay5jOjE3MworIzogYnVpbHRpbi9jbG9uZS5jOjE0MSBidWlsdGluL2ZldGNoLmM6MTg5IGJ1aWx0aW4vbHMtcmVtb3RlLmM6NzYKKyM6IGJ1aWx0aW4vcHVzaC5jOjU3MiBidWlsdGluL3NlbmQtcGFjay5jOjE3MwogbXNnaWQgIm9wdGlvbiB0byB0cmFuc21pdCIKIG1zZ3N0ciAi0L7Qv9GG0LjRjyDQt9CwINC/0YDQtdC90L7RgSIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjE0MyBidWlsdGluL2ZldGNoLmM6MTc1IGJ1aWx0aW4vcHVsbC5jOjIzOQotIzogYnVpbHRpbi9wdXNoLmM6NTg2CisjOiBidWlsdGluL2Nsb25lLmM6MTQyIGJ1aWx0aW4vZmV0Y2guYzoxOTAgYnVpbHRpbi9wdWxsLmM6MjQwCisjOiBidWlsdGluL3B1c2guYzo1NzMKIG1zZ2lkICJ1c2UgSVB2NCBhZGRyZXNzZXMgb25seSIKIG1zZ3N0ciAi0YHQsNC80L4g0LDQtNGA0LXRgdC4IElQdjQiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxNDUgYnVpbHRpbi9mZXRjaC5jOjE3NyBidWlsdGluL3B1bGwuYzoyNDIKLSM6IGJ1aWx0aW4vcHVzaC5jOjU4OAorIzogYnVpbHRpbi9jbG9uZS5jOjE0NCBidWlsdGluL2ZldGNoLmM6MTkyIGJ1aWx0aW4vcHVsbC5jOjI0MworIzogYnVpbHRpbi9wdXNoLmM6NTc1CiBtc2dpZCAidXNlIElQdjYgYWRkcmVzc2VzIG9ubHkiCiBtc2dzdHIgItGB0LDQvNC+INCw0LTRgNC10YHQuCBJUHY2IgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTQ5CisjOiBidWlsdGluL2Nsb25lLmM6MTQ4CiBtc2dpZCAiYW55IGNsb25lZCBzdWJtb2R1bGVzIHdpbGwgdXNlIHRoZWlyIHJlbW90ZS10cmFja2luZyBicmFuY2giCiBtc2dzdHIgItCy0YHQuNGH0LrQuCDQutC70L7QvdC40YDQsNC90Lgg0L/QvtC00LzQvtC00YPQu9C4INGJ0LUg0L/QvtC70LfQstCw0YIg0YHQu9C10LTRj9GJ0LjRgtC1INGB0Lgg0LrQu9C+0L3QuCIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjI4NQorIzogYnVpbHRpbi9jbG9uZS5jOjI4NAogbXNnaWQgIiIKICJObyBkaXJlY3RvcnkgbmFtZSBjb3VsZCBiZSBndWVzc2VkLlxuIgogIlBsZWFzZSBzcGVjaWZ5IGEgZGlyZWN0b3J5IG9uIHRoZSBjb21tYW5kIGxpbmUiCkBAIC0xMTQwNSw0MyArMTE0MzksNDMgQEAKICLQmNC80LXRgtC+INC90LAg0LTQuNGA0LXQutGC0L7RgNC40Y/RgtCwINC90LUg0LzQvtC20LUg0LTQsCDQsdGK0LTQtSDQvtGC0LPQsNGC0L3QsNGC0L4uXG4iCiAi0JfQsNC00LDQudGC0LUg0LTQuNGA0LXQutGC0L7RgNC40Y/RgtCwINC40LfRgNC40YfQvdC+INC90LAg0LrQvtC80LDQvdC00L3QuNGPINGA0LXQtCIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjMzOAorIzogYnVpbHRpbi9jbG9uZS5jOjMzNwogIywgYy1mb3JtYXQKIG1zZ2lkICJpbmZvOiBDb3VsZCBub3QgYWRkIGFsdGVybmF0ZSBmb3IgJyVzJzogJXNcbiIKIG1zZ3N0ciAiIgogItCf0KDQldCU0KPQn9Cg0JXQltCU0JXQndCY0JU6INC90LUg0LzQvtC20LUg0LTQsCDRgdC1INC00L7QsdCw0LLQuCDQsNC70YLQtdGA0L3QsNGC0LjQstC10L0g0LjQt9GC0L7Rh9C90LjQuiDQvdCwIOKAniVz4oCcOiAlc1xuIgogCi0jOiBidWlsdGluL2Nsb25lLmM6NDExCisjOiBidWlsdGluL2Nsb25lLmM6NDEwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIGV4aXN0cyBhbmQgaXMgbm90IGEgZGlyZWN0b3J5IgogbXNnc3RyICLigJ4lc+KAnCDRgdGK0YnQtdGB0YLQstGD0LLQsCDQuCDQvdC1INC1INC00LjRgNC10LrRgtC+0YDQuNGPIgogCi0jOiBidWlsdGluL2Nsb25lLmM6NDI4CisjOiBidWlsdGluL2Nsb25lLmM6NDI3CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBzdGFydCBpdGVyYXRvciBvdmVyICclcyciCiBtc2dzdHIgItC90LXRg9GB0L/QtdGI0L3QviDQuNGC0LXRgNC40YDQsNC90LUg0L/QviDigJ4lc+KAnCIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjQ1OAorIzogYnVpbHRpbi9jbG9uZS5jOjQ1NwogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gY3JlYXRlIGxpbmsgJyVzJyIKIG1zZ3N0ciAi0LLRgNGK0LfQutCw0YLQsCDigJ4lc+KAnCDQvdC1INC80L7QttC1INC00LAg0LHRitC00LUg0YHRitC30LTQsNC00LXQvdCwIgogCi0jOiBidWlsdGluL2Nsb25lLmM6NDYyCisjOiBidWlsdGluL2Nsb25lLmM6NDYxCiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBjb3B5IGZpbGUgdG8gJyVzJyIKIG1zZ3N0ciAi0YTQsNC50LvRitGCINC90LUg0LzQvtC20LUg0LTQsCDQsdGK0LTQtSDQutC+0L/QuNGA0LDQvSDQutCw0YLQviDigJ4lc+KAnCIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjQ2NworIzogYnVpbHRpbi9jbG9uZS5jOjQ2NgogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gaXRlcmF0ZSBvdmVyICclcyciCiBtc2dzdHIgItC90LXRg9GB0L/QtdGI0L3QviDQuNGC0LXRgNC40YDQsNC90LUg0L/QviDigJ4lc+KAnCIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjQ5MgorIzogYnVpbHRpbi9jbG9uZS5jOjQ5MQogIywgYy1mb3JtYXQKIG1zZ2lkICJkb25lLlxuIgogbXNnc3RyICLQtNC10LnRgdGC0LLQuNC10YLQviDQt9Cw0LLRitGA0YjQuC5cbiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjUwNgorIzogYnVpbHRpbi9jbG9uZS5jOjUwNQogbXNnaWQgIiIKICJDbG9uZSBzdWNjZWVkZWQsIGJ1dCBjaGVja291dCBmYWlsZWQuXG4iCiAiWW91IGNhbiBpbnNwZWN0IHdoYXQgd2FzIGNoZWNrZWQgb3V0IHdpdGggJ2dpdCBzdGF0dXMnXG4iCkBAIC0xMTQ1NCw5OSArMTE0ODgsOTkgQEAKICJcbiIKICIgICAgZ2l0IHJlc3RvcmUgLS1zb3VyY2U9SEVBRCA6L1xuIgogCi0jOiBidWlsdGluL2Nsb25lLmM6NTgzCisjOiBidWlsdGluL2Nsb25lLmM6NTgyCiAjLCBjLWZvcm1hdAogbXNnaWQgIkNvdWxkIG5vdCBmaW5kIHJlbW90ZSBicmFuY2ggJXMgdG8gY2xvbmUuIgogbXNnc3RyICIiCiAi0JrQu9C+0L3RitGCIOKAniVz4oCcINC+0YIg0L7RgtC00LDQu9C10YfQtdC90L7RgtC+INGF0YDQsNC90LjQu9C40YnQtSwg0LrQvtC10YLQviDQutC70L7QvdC40YDQsNGC0LUsXG4iCiAi0Lgg0LrQvtC50YLQviDRgdC70LXQtNCy0LAg0LTQsCDQsdGK0LTQtSDQuNC30YLQtdCz0LvQtdC9LCDQvdC1INGB0YrRidC10YHRgtCy0YPQstCwLiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjcwMgorIzogYnVpbHRpbi9jbG9uZS5jOjcwMQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gdXBkYXRlICVzIgogbXNnc3RyICLQvtCx0LXQutGC0YrRgiDigJ4lc+KAnCDQvdC1INC80L7QttC1INC00LAg0LHRitC00LUg0L7QsdC90L7QstC10L0iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo3NTIKKyM6IGJ1aWx0aW4vY2xvbmUuYzo3NTEKIG1zZ2lkICJyZW1vdGUgSEVBRCByZWZlcnMgdG8gbm9uZXhpc3RlbnQgcmVmLCB1bmFibGUgdG8gY2hlY2tvdXQuXG4iCiBtc2dzdHIgIiIKICLRg9C60LDQt9Cw0YLQtdC70Y/RgiDigJ5IRUFE4oCcINC+0YIg0L7RgtC00LDQu9C10YfQtdC90L7RgtC+INGF0YDQsNC90LjQu9C40YnQtSDRgdC+0YfQuCDQutGK0Lwg0L3QtdGJ0L4sXG4iCiAi0LrQvtC10YLQviDQvdC1INGB0YrRidC10YHRgtCy0YPQstCwLiAg0J3QtSDQvNC+0LbQtSDQtNCwINGB0LUg0LjQt9GC0LXQs9C70Lgg0L7Qv9GA0LXQtNC10LvQtdC9INC60LvQvtC9LlxuIgogCi0jOiBidWlsdGluL2Nsb25lLmM6NzgzCisjOiBidWlsdGluL2Nsb25lLmM6NzgyCiBtc2dpZCAidW5hYmxlIHRvIGNoZWNrb3V0IHdvcmtpbmcgdHJlZSIKIG1zZ3N0ciAi0YDQsNCx0L7RgtC90L7RgtC+INC00YrRgNCy0L4g0L3QtSDQvNC+0LbQtSDQtNCwINCx0YrQtNC1INC/0L7QtNCz0L7RgtCy0LXQvdC+IgogCi0jOiBidWlsdGluL2Nsb25lLmM6ODMzCisjOiBidWlsdGluL2Nsb25lLmM6ODMyCiBtc2dpZCAidW5hYmxlIHRvIHdyaXRlIHBhcmFtZXRlcnMgdG8gY29uZmlnIGZpbGUiCiBtc2dzdHIgItC90LDRgdGC0YDQvtC50LrQuNGC0LUg0L3QtSDQvNC+0LPQsNGCINC00LAg0LHRitC00LDRgiDQt9Cw0L/QuNGB0LDQvdC4INCyINC60L7QvdGE0LjQs9GD0YDQsNGG0LjQvtC90L3QuNGPINGE0LDQudC7IgogCi0jOiBidWlsdGluL2Nsb25lLmM6ODk2CisjOiBidWlsdGluL2Nsb25lLmM6ODk1CiBtc2dpZCAiY2Fubm90IHJlcGFjayB0byBjbGVhbiB1cCIKIG1zZ3N0ciAi0L3QtSDQvNC+0LbQtSDQtNCwINGB0LUg0LjQt9Cy0YrRgNGI0Lgg0L/QsNC60LXRgtC40YDQsNC90LUg0LfQsCDQuNC30YfQuNGB0YLQstCw0L3QtSDQvdCwINGE0LDQudC70L7QstC10YLQtSIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjg5OAorIzogYnVpbHRpbi9jbG9uZS5jOjg5NwogbXNnaWQgImNhbm5vdCB1bmxpbmsgdGVtcG9yYXJ5IGFsdGVybmF0ZXMgZmlsZSIKIG1zZ3N0ciAi0LLRgNC10LzQtdC90L3QuNGP0YIg0YTQsNC50Lsg0LfQsCDQsNC70YLQtdGA0L3QsNGC0LjQstC90Lgg0L7QsdC10LrRgtC4INC90LUg0LzQvtC20LUg0LTQsCDQsdGK0LTQtSDQuNC30YLRgNC40YIiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo5MzggYnVpbHRpbi9yZWNlaXZlLXBhY2suYzoxOTUwCisjOiBidWlsdGluL2Nsb25lLmM6OTM3IGJ1aWx0aW4vcmVjZWl2ZS1wYWNrLmM6MTk0OAogbXNnaWQgIlRvbyBtYW55IGFyZ3VtZW50cy4iCiBtc2dzdHIgItCf0YDQtdC60LDQu9C10L3QviDQvNC90L7Qs9C+INCw0YDQs9GD0LzQtdC90YLQuC4iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo5NDIKKyM6IGJ1aWx0aW4vY2xvbmUuYzo5NDEKIG1zZ2lkICJZb3UgbXVzdCBzcGVjaWZ5IGEgcmVwb3NpdG9yeSB0byBjbG9uZS4iCiBtc2dzdHIgItCi0YDRj9Cx0LLQsCDQtNCwINGD0LrQsNC20LXRgtC1INC60L7QtSDRhdGA0LDQvdC40LvQuNGJ0LUg0LjRgdC60LDRgtC1INC00LAg0LrQu9C+0L3QuNGA0LDRgtC1LiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjk1NQorIzogYnVpbHRpbi9jbG9uZS5jOjk1NAogIywgYy1mb3JtYXQKIG1zZ2lkICItLWJhcmUgYW5kIC0tb3JpZ2luICVzIG9wdGlvbnMgYXJlIGluY29tcGF0aWJsZS4iCiBtc2dzdHIgItC+0L/RhtC40LjRgtC1IOKAni0tYmFyZeKAnCDQuCDigJ4tLW9yaWdpbiAlc+KAnCDRgdCwINC90LXRgdGK0LLQvNC10YHRgtC40LzQuC4iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo5NTgKKyM6IGJ1aWx0aW4vY2xvbmUuYzo5NTcKIG1zZ2lkICItLWJhcmUgYW5kIC0tc2VwYXJhdGUtZ2l0LWRpciBhcmUgaW5jb21wYXRpYmxlLiIKIG1zZ3N0ciAi0L7Qv9GG0LjQuNGC0LUg4oCeLS1iYXJl4oCcINC4IOKAni0tc2VwYXJhdGUtZ2l0LWRpcuKAnCDRgdCwINC90LXRgdGK0LLQvNC10YHRgtC40LzQuC4iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo5NzEKKyM6IGJ1aWx0aW4vY2xvbmUuYzo5NzAKICMsIGMtZm9ybWF0CiBtc2dpZCAicmVwb3NpdG9yeSAnJXMnIGRvZXMgbm90IGV4aXN0IgogbXNnc3RyICLQvdC1INGB0YrRidC10YHRgtCy0YPQstCwINGF0YDQsNC90LjQu9C40YnQtSDigJ4lc+KAnCIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjk3NyBidWlsdGluL2ZldGNoLmM6MTY2MAorIzogYnVpbHRpbi9jbG9uZS5jOjk3NiBidWlsdGluL2ZldGNoLmM6MTc5MAogIywgYy1mb3JtYXQKIG1zZ2lkICJkZXB0aCAlcyBpcyBub3QgYSBwb3NpdGl2ZSBudW1iZXIiCiBtc2dzdHIgItC00YrQu9Cx0L7Rh9C40L3QsNGC0LAg0YLRgNGP0LHQstCwINC00LAg0LUg0L/QvtC70L7QttC40YLQtdC70L3QviDRhtGP0LvQviDRh9C40YHQu9C+LCDQsCDQvdC1IOKAniVz4oCcIgogCi0jOiBidWlsdGluL2Nsb25lLmM6OTg3CisjOiBidWlsdGluL2Nsb25lLmM6OTg2CiAjLCBjLWZvcm1hdAogbXNnaWQgImRlc3RpbmF0aW9uIHBhdGggJyVzJyBhbHJlYWR5IGV4aXN0cyBhbmQgaXMgbm90IGFuIGVtcHR5IGRpcmVjdG9yeS4iCiBtc2dzdHIgItGG0LXQu9C10LLQuNGP0YIg0L/RitGCIOKAniVz4oCcINGB0YrRidC10YHRgtCy0YPQstCwINC4INC90LUg0LUg0L/RgNCw0LfQvdCwINC00LjRgNC10LrRgtC+0YDQuNGPLiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjk5NworIzogYnVpbHRpbi9jbG9uZS5jOjk5NgogIywgYy1mb3JtYXQKIG1zZ2lkICJ3b3JraW5nIHRyZWUgJyVzJyBhbHJlYWR5IGV4aXN0cy4iCiBtc2dzdHIgItCyIOKAniVz4oCcINCy0LXRh9C1INGB0YrRidC10YHRgtCy0YPQstCwINGA0LDQsdC+0YLQvdC+INC00YrRgNCy0L4uIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTAxMiBidWlsdGluL2Nsb25lLmM6MTAzMyBidWlsdGluL2RpZmZ0b29sLmM6MjY0Ci0jOiBidWlsdGluL3dvcmt0cmVlLmM6MzAzIGJ1aWx0aW4vd29ya3RyZWUuYzozMzUKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMDExIGJ1aWx0aW4vY2xvbmUuYzoxMDMyIGJ1aWx0aW4vZGlmZnRvb2wuYzoyNzEKKyM6IGJ1aWx0aW4vbG9nLmM6MTc4NSBidWlsdGluL3dvcmt0cmVlLmM6MzAyIGJ1aWx0aW4vd29ya3RyZWUuYzozMzQKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGNyZWF0ZSBsZWFkaW5nIGRpcmVjdG9yaWVzIG9mICclcyciCiBtc2dzdHIgItGA0L7QtNC40YLQtdC70YHQutC40YLQtSDQtNC40YDQtdC60YLQvtGA0LjQuCDQvdCwIOKAniVz4oCcINC90LUg0LzQvtCz0LDRgiDQtNCwINCx0YrQtNCw0YIg0YHRitC30LTQsNC00LXQvdC4IgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTAxNworIzogYnVpbHRpbi9jbG9uZS5jOjEwMTYKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGNyZWF0ZSB3b3JrIHRyZWUgZGlyICclcyciCiBtc2dzdHIgItGA0LDQsdC+0YLQvdC+0YLQviDQtNGK0YDQstC+INCyIOKAniVz4oCcINC90LUg0LzQvtC20LUg0LTQsCDQsdGK0LTQtSDRgdGK0LfQtNCw0LTQtdC90L4uIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTAzNworIzogYnVpbHRpbi9jbG9uZS5jOjEwMzYKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ2xvbmluZyBpbnRvIGJhcmUgcmVwb3NpdG9yeSAnJXMnLi4uXG4iCiBtc2dzdHIgItCa0LvQvtC90LjRgNCw0L3QtSDQuCDRgdGK0LfQtNCw0LLQsNC90LUg0L3QsCDQs9C+0LvQviDRhdGA0LDQvdC40LvQuNGJ0LUg0LIg4oCeJXPigJzigKZcbiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEwMzkKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMDM4CiAjLCBjLWZvcm1hdAogbXNnaWQgIkNsb25pbmcgaW50byAnJXMnLi4uXG4iCiBtc2dzdHIgItCa0LvQvtC90LjRgNCw0L3QtSDQuCDRgdGK0LfQtNCw0LLQsNC90LUg0L3QsCDRhdGA0LDQvdC40LvQuNGJ0LUg0LIg4oCeJXPigJzigKZcbiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEwNjMKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMDYyCiBtc2dpZCAiIgogImNsb25lIC0tcmVjdXJzaXZlIGlzIG5vdCBjb21wYXRpYmxlIHdpdGggYm90aCAtLXJlZmVyZW5jZSBhbmQgLS1yZWZlcmVuY2UtaWYtIgogImFibGUiCkBAIC0xMTU1NCw0NCArMTE1ODgsNDQgQEAKICLQntC/0YbQuNGP0YLQsCDigJ4tLXJlY3Vyc2l2ZeKAnCDQtSDQvdC10YHRitCy0LzQtdGB0YLQuNC80LAg0YEg0L7Qv9GG0LjQuNGC0LUg4oCeLS1yZWZlcmVuY2XigJwg0Lgg4oCeLS1yZWZlcmVuY2UtIgogImlmLWFibGXigJwiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMTI0CisjOiBidWlsdGluL2Nsb25lLmM6MTEyMwogbXNnaWQgIi0tZGVwdGggaXMgaWdub3JlZCBpbiBsb2NhbCBjbG9uZXM7IHVzZSBmaWxlOi8vIGluc3RlYWQuIgogbXNnc3RyICIiCiAi0J/RgNC4INC70L7QutCw0LvQvdC+INC60LvQvtC90LjRgNCw0L3QtSDQvtC/0YbQuNGP0YLQsCDigJ4tLWRlcHRo4oCcINGB0LUg0L/RgNC10YHQutCw0YfQsC4gINCf0L7Qu9C30LLQsNC50YLQtSDRgdGF0LXQvNCw0YLQsCAiCiAi4oCeZmlsZTovL+KAnC4iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMTI2CisjOiBidWlsdGluL2Nsb25lLmM6MTEyNQogbXNnaWQgIi0tc2hhbGxvdy1zaW5jZSBpcyBpZ25vcmVkIGluIGxvY2FsIGNsb25lczsgdXNlIGZpbGU6Ly8gaW5zdGVhZC4iCiBtc2dzdHIgIiIKICLQn9GA0Lgg0LvQvtC60LDQu9C90L4g0LrQu9C+0L3QuNGA0LDQvdC1INC+0L/RhtC40Y/RgtCwIOKAni0tc2hhbGxvdy1zaW5jZeKAnCDRgdC1INC/0YDQtdGB0LrQsNGH0LAuICDQn9C+0LvQt9Cy0LDQudGC0LUgIgogItGB0YXQtdC80LDRgtCwIOKAnmZpbGU6Ly/igJwuIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTEyOAorIzogYnVpbHRpbi9jbG9uZS5jOjExMjcKIG1zZ2lkICItLXNoYWxsb3ctZXhjbHVkZSBpcyBpZ25vcmVkIGluIGxvY2FsIGNsb25lczsgdXNlIGZpbGU6Ly8gaW5zdGVhZC4iCiBtc2dzdHIgIiIKICLQn9GA0Lgg0LvQvtC60LDQu9C90L4g0LrQu9C+0L3QuNGA0LDQvdC1INC+0L/RhtC40Y/RgtCwIOKAni0tc2hhbGxvdy1leGNsdWRl4oCcINGB0LUg0L/RgNC10YHQutCw0YfQsC4gINCf0L7Qu9C30LLQsNC50YLQtSAiCiAi0YHRhdC10LzQsNGC0LAg4oCeZmlsZTovL+KAnC4iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMTMwCisjOiBidWlsdGluL2Nsb25lLmM6MTEyOQogbXNnaWQgIi0tZmlsdGVyIGlzIGlnbm9yZWQgaW4gbG9jYWwgY2xvbmVzOyB1c2UgZmlsZTovLyBpbnN0ZWFkLiIKIG1zZ3N0ciAiIgogItCf0YDQuCDQu9C+0LrQsNC70L3QviDQutC70L7QvdC40YDQsNC90LUg0L7Qv9GG0LjRj9GC0LAg4oCeLS1maWx0ZXLigJwg0YHQtSDQv9GA0LXRgdC60LDRh9CwLiAg0J/QvtC70LfQstCw0LnRgtC1INGB0YXQtdC80LDRgtCwICIKICLigJ5maWxlOi8v4oCcLiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjExMzMKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMTMyCiBtc2dpZCAic291cmNlIHJlcG9zaXRvcnkgaXMgc2hhbGxvdywgaWdub3JpbmcgLS1sb2NhbCIKIG1zZ3N0ciAi0LrQu9C+0L3QuNGA0LDQvdC+0YLQviDRhdGA0LDQvdC40LvQuNGJ0LUg0LUg0L/Qu9C40YLQutC+LCDQt9Cw0YLQvtCy0LAg0L7Qv9GG0LjRj9GC0LAg4oCeLS1sb2NhbOKAnCDRgdC1INC/0YDQtdGB0LrQsNGH0LAiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMTM4CisjOiBidWlsdGluL2Nsb25lLmM6MTEzNwogbXNnaWQgIi0tbG9jYWwgaXMgaWdub3JlZCIKIG1zZ3N0ciAi0L7Qv9GG0LjRj9GC0LAg4oCeLS1sb2NhbOKAnCDRgdC1INC/0YDQtdGB0LrQsNGH0LAiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMjE1IGJ1aWx0aW4vY2xvbmUuYzoxMjIzCisjOiBidWlsdGluL2Nsb25lLmM6MTIxMiBidWlsdGluL2Nsb25lLmM6MTIyMAogIywgYy1mb3JtYXQKIG1zZ2lkICJSZW1vdGUgYnJhbmNoICVzIG5vdCBmb3VuZCBpbiB1cHN0cmVhbSAlcyIKIG1zZ3N0ciAi0J7RgtC00LDQu9C10YfQtdC90LjRj9GCINC60LvQvtC9IOKAniVz4oCcINC70LjQv9GB0LLQsCDQsiDQutC70L7QvdC40YDQsNC90L7RgtC+INGF0YDQsNC90LjQu9C40YnQtSDigJ4lc+KAnCIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEyMjYKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMjIzCiBtc2dpZCAiWW91IGFwcGVhciB0byBoYXZlIGNsb25lZCBhbiBlbXB0eSByZXBvc2l0b3J5LiIKIG1zZ3N0ciAi0JjQt9Cz0LvQtdC20LTQsCDQutC70L7QvdC40YDQsNGF0YLQtSDQv9GA0LDQt9C90L4g0YXRgNCw0L3QuNC70LjRidC1LiIKIApAQCAtMTE2NjksNyArMTE3MDMsNyBAQAogbXNnc3RyICLQmNCU0JXQndCi0JjQpNCY0JrQkNCi0J7QoCDQvdCwINC+0LHQtdC60YLQsCDQt9CwINC/0L7QtNCw0LLQsNC90LXRgtC+LdGA0L7QtNC40YLQtdC7IgogCiAjOiBidWlsdGluL2NvbW1pdC10cmVlLmM6MTE0IGJ1aWx0aW4vY29tbWl0LmM6MTUwMCBidWlsdGluL21lcmdlLmM6MjcwCi0jOiBidWlsdGluL25vdGVzLmM6NDA5IGJ1aWx0aW4vbm90ZXMuYzo1NzUgYnVpbHRpbi9zdGFzaC5jOjE0NjAKKyM6IGJ1aWx0aW4vbm90ZXMuYzo0MDkgYnVpbHRpbi9ub3Rlcy5jOjU3NSBidWlsdGluL3N0YXNoLmM6MTQ2OQogIzogYnVpbHRpbi90YWcuYzo0MTIKIG1zZ2lkICJtZXNzYWdlIgogbXNnc3RyICLQodCq0J7QkdCp0JXQndCY0JUiCkBAIC0xMTY4Myw3ICsxMTcxNyw3IEBACiBtc2dzdHIgItC40LfRh9C40YLQsNC90LUg0L3QsCDRgdGK0L7QsdGJ0LXQvdC40LXRgtC+INC30LAg0L/QvtC00LDQstCw0L3QtSDQvtGCINCk0JDQmdCbIgogCiAjOiBidWlsdGluL2NvbW1pdC10cmVlLmM6MTIxIGJ1aWx0aW4vY29tbWl0LmM6MTUxMiBidWlsdGluL21lcmdlLmM6Mjg3Ci0jOiBidWlsdGluL3B1bGwuYzoxOTQgYnVpbHRpbi9yZXZlcnQuYzoxMTgKKyM6IGJ1aWx0aW4vcHVsbC5jOjE5NSBidWlsdGluL3JldmVydC5jOjExOAogbXNnaWQgIkdQRyBzaWduIGNvbW1pdCIKIG1zZ3N0ciAi0L/QvtC00L/QuNGB0LLQsNC90LUg0L3QsCDQv9C+0LTQsNCy0LDQvdC10YLQviDRgSBHUEciCiAKQEAgLTEyMDIxLDggKzEyMDU1LDggQEAKIG1zZ2lkICJ2ZXJzaW9uIgogbXNnc3RyICLQstC10YDRgdC40Y8iCiAKLSM6IGJ1aWx0aW4vY29tbWl0LmM6MTM0NyBidWlsdGluL2NvbW1pdC5jOjE1MjkgYnVpbHRpbi9wdXNoLmM6NTYxCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NjUxCisjOiBidWlsdGluL2NvbW1pdC5jOjEzNDcgYnVpbHRpbi9jb21taXQuYzoxNTI5IGJ1aWx0aW4vcHVzaC5jOjU0OAorIzogYnVpbHRpbi93b3JrdHJlZS5jOjY1MAogbXNnaWQgIm1hY2hpbmUtcmVhZGFibGUgb3V0cHV0IgogbXNnc3RyICLRhNC+0YDQvNCw0YIg0L3QsCDQuNC30YXQvtC00LAg0LfQsCDRh9C10YLQtdC90LUg0L7RgiDQv9GA0L7Qs9GA0LDQvNCwIgogCkBAIC0xMjAzNSw4ICsxMjA2OSw4IEBACiBtc2dzdHIgItGA0LDQt9C00LXQu9GP0L3QtSDQvdCwINC10LvQtdC80LXQvdGC0LjRgtC1INGBINC90YPQu9C10LLQuNGPINC30L3QsNC6IOKAnk5VTOKAnCIKIAogIzogYnVpbHRpbi9jb21taXQuYzoxMzU1IGJ1aWx0aW4vY29tbWl0LmM6MTM1OSBidWlsdGluL2NvbW1pdC5jOjE1MzcKLSM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTI1IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTI4Ci0jOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTEzMSBidWlsdGluL3JlYmFzZS5jOjE0NzEgcGFyc2Utb3B0aW9ucy5oOjMzMgorIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNTMgYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNTYKKyM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTU5IGJ1aWx0aW4vcmViYXNlLmM6MTQ5NSBwYXJzZS1vcHRpb25zLmg6MzMyCiBtc2dpZCAibW9kZSIKIG1zZ3N0ciAi0KDQldCW0JjQnCIKIApAQCAtMTIwNTYsNyArMTIwOTAsNyBAQAogIuKAnnRyYWRpdGlvbmFs4oCcICjRgtGA0LDQtNC40YbQuNC+0L3QtdC9KSwg4oCebWF0Y2hpbmfigJwgKNC90LDQv9Cw0YHQstCw0YnQuCksIOKAnm5v4oCcICjQsdC10Lcg0LjQs9C90L7RgNC40YDQsNC90LjRgtC1ICIKICLRhNCw0LnQu9C+0LLQtSkuICDQodGC0LDQvdC00LDRgNGC0L3QuNGP0YIg0KDQldCW0JjQnCDQtTog4oCedHJhZGl0aW9uYWzigJwuIgogCi0jOiBidWlsdGluL2NvbW1pdC5jOjEzNjIgcGFyc2Utb3B0aW9ucy5oOjE3OQorIzogYnVpbHRpbi9jb21taXQuYzoxMzYyIHBhcnNlLW9wdGlvbnMuaDoxODgKIG1zZ2lkICJ3aGVuIgogbXNnc3RyICLQmtCe0JPQkCIKIApAQCAtMTIxMDksNyArMTIxNDMsNyBAQAogbXNnaWQgIm92ZXJyaWRlIGF1dGhvciBmb3IgY29tbWl0IgogbXNnc3RyICLQt9Cw0LTQsNCy0LDQvdC1INC90LAg0JDQktCi0J7QoCDQt9CwINC/0L7QtNCw0LLQsNC90LXRgtC+IgogCi0jOiBidWlsdGluL2NvbW1pdC5jOjE0OTkgYnVpbHRpbi9nYy5jOjUzOQorIzogYnVpbHRpbi9jb21taXQuYzoxNDk5IGJ1aWx0aW4vZ2MuYzo1MzgKIG1zZ2lkICJkYXRlIgogbXNnc3RyICLQlNCQ0KLQkCIKIApAQCAtMTIxNDcsOCArMTIxODEsOCBAQAogbXNnc3RyICIiCiAi0YHQvNGP0L3QsCDQvdCwINCw0LLRgtC+0YDQsCDQtNCwINGB0YrQstC/0LDQtNCwINGBINC/0L7QtNCw0LLQsNGJ0LjRjyAo0LjQt9C/0L7Qu9C30LLQsCDRgdC1INGBIOKAni1D4oCcL+KAni1j4oCcL+KAni0tYW1lbmTigJwpIgogCi0jOiBidWlsdGluL2NvbW1pdC5jOjE1MDYgYnVpbHRpbi9sb2cuYzoxNTY0IGJ1aWx0aW4vbWVyZ2UuYzoyODkKLSM6IGJ1aWx0aW4vcHVsbC5jOjE2MyBidWlsdGluL3JldmVydC5jOjExMAorIzogYnVpbHRpbi9jb21taXQuYzoxNTA2IGJ1aWx0aW4vbG9nLmM6MTU2NSBidWlsdGluL21lcmdlLmM6Mjg5CisjOiBidWlsdGluL3B1bGwuYzoxNjQgYnVpbHRpbi9yZXZlcnQuYzoxMTAKIG1zZ2lkICJhZGQgU2lnbmVkLW9mZi1ieToiCiBtc2dzdHIgItC00L7QsdCw0LLRj9C90LUg0L3QsCDQv9C+0LvQtSDQt9CwINC/0L7QtNC/0LjRgSDigJQg4oCeU2lnbmVkLW9mZi1ieTrigJwiCiAKQEAgLTEyMjU5LDcxICsxMjI5Myw3NCBAQAogbXNnc3RyICJnaXQgY29tbWl0LWdyYXBoIHJlYWQgWy0tb2JqZWN0LWRpciDQlNCY0KBf0J7QkdCV0JrQotCYXSIKIAogIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxMyBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE5Ci1tc2dpZCAiZ2l0IGNvbW1pdC1ncmFwaCB2ZXJpZnkgWy0tb2JqZWN0LWRpciA8b2JqZGlyPl0gWy0tc2hhbGxvd10iCi1tc2dzdHIgImdpdCBjb21taXQtZ3JhcGggdmVyaWZ5IFstLW9iamVjdC1kaXIg0JTQmNCgX9Ce0JHQldCa0KLQmF0gWy0tc2hhbGxvd10iCittc2dpZCAiIgorImdpdCBjb21taXQtZ3JhcGggdmVyaWZ5IFstLW9iamVjdC1kaXIgPG9iamRpcj5dIFstLXNoYWxsb3ddIFstLVtuby1dcHJvZ3Jlc3NdIgorbXNnc3RyICIiCisiZ2l0IGNvbW1pdC1ncmFwaCB2ZXJpZnkgWy0tb2JqZWN0LWRpciDQlNCY0KBf0J7QkdCV0JrQotCYXSBbLS1zaGFsbG93XSBbLS0iCisiW25vLV1wcm9ncmVzc10iCiAKICM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTQgYnVpbHRpbi9jb21taXQtZ3JhcGguYzoyOQogbXNnaWQgIiIKICJnaXQgY29tbWl0LWdyYXBoIHdyaXRlIFstLW9iamVjdC1kaXIgPG9iamRpcj5dIFstLWFwcGVuZHwtLXNwbGl0XSBbLS0iCi0icmVhY2hhYmxlfC0tc3RkaW4tcGFja3N8LS1zdGRpbi1jb21taXRzXSA8c3BsaXQgb3B0aW9ucz4iCisicmVhY2hhYmxlfC0tc3RkaW4tcGFja3N8LS1zdGRpbi1jb21taXRzXSBbLS1bbm8tXXByb2dyZXNzXSA8c3BsaXQgb3B0aW9ucz4iCiBtc2dzdHIgIiIKICJnaXQgY29tbWl0LWdyYXBoIHdyaXRlIFstLW9iamVjdC1kaXIg0JTQmNCgX9Ce0JHQldCa0KLQmF0gWy0tYXBwZW5kfC0tc3BsaXRdIFstLSIKLSJyZWFjaGFibGV8LS1zdGRpbi1wYWNrc3wtLXN0ZGluLWNvbW1pdHNdINCe0J/QptCY0Jhf0JfQkF/QoNCQ0JfQlNCV0JvQr9Cd0JUiCisicmVhY2hhYmxlfC0tc3RkaW4tcGFja3N8LS1zdGRpbi1jb21taXRzXSBbLS1bbm8tXXByb2dyZXNzXSDQntCf0KbQmNCYX9CX0JBf0KDQkNCX0JTQldCb0K/QndCVIgogCi0jOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjU0IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTAwCi0jOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE2MSBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjIzNyBidWlsdGluL2ZldGNoLmM6MTYzCi0jOiBidWlsdGluL2xvZy5jOjE1ODQKKyM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6NTUgYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxMDcKKyM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTcwIGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MjU0IGJ1aWx0aW4vZmV0Y2guYzoxNzgKKyM6IGJ1aWx0aW4vbG9nLmM6MTU4NQogbXNnaWQgImRpciIKIG1zZ3N0ciAi0LTQuNGA0LXQutGC0L7RgNC40Y8iCiAKLSM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6NTUgYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxMDEKLSM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTYyIGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MjM4CisjOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjU2IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTA4CisjOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE3MSBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjI1NQogbXNnaWQgIlRoZSBvYmplY3QgZGlyZWN0b3J5IHRvIHN0b3JlIHRoZSBncmFwaCIKIG1zZ3N0ciAi0JTQmNCg0LXQutGC0L7RgNC40Y/RgtCwX9GBX9Ce0JHQldCa0KLQmCDQt9CwINC30LDQv9Cw0LfQstCw0L3QtSDQvdCwINCz0YDQsMyA0YTQsCIKIAotIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzo1NworIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzo1OAogbXNnaWQgImlmIHRoZSBjb21taXQtZ3JhcGggaXMgc3BsaXQsIG9ubHkgdmVyaWZ5IHRoZSB0aXAgZmlsZSIKIG1zZ3N0ciAiIgogItCw0LrQviDQs9GA0LDMgNGE0LAg0YEg0L/QvtC00LDQstCw0L3QuNGP0YLQsCDQtSDRgNCw0LfQtNGA0L7QsdC10L0sINC00LAg0YHQtSDQv9GA0L7QstC10YDRj9Cy0LAg0YHQsNC80L4g0YTQsNC50LvRitGCINC90LAg0LLRitGA0YXQsCIKIAotIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzo3MyBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjExNgorIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzo4MCBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjEyNQogIywgYy1mb3JtYXQKIG1zZ2lkICJDb3VsZCBub3Qgb3BlbiBjb21taXQtZ3JhcGggJyVzJyIKIG1zZ3N0ciAi0JPRgNCw0YTRitGCINGBINC/0L7QtNCw0LLQsNC90LjRj9GC0LAg0L3QtSDQvNC+0LbQtSDQtNCwINGB0LUg0L7RgtCy0L7RgNC4OiDigJ4lc+KAnCIKIAotIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxNjQKKyM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTczCiBtc2dpZCAic3RhcnQgd2FsayBhdCBhbGwgcmVmcyIKIG1zZ3N0ciAi0L7QsdGF0L7QttC00LDQvdC10YLQviDQtNCwINC30LDQv9C+0YfQvdC1INC+0YIg0LLRgdC40YfQutC4INGD0LrQsNC30LDRgtC10LvQuCIKIAotIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxNjYKKyM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTc1CiBtc2dpZCAic2NhbiBwYWNrLWluZGV4ZXMgbGlzdGVkIGJ5IHN0ZGluIGZvciBjb21taXRzIgogbXNnc3RyICIiCiAi0L/RgNC+0LLQtdGA0LrQsCDQvdCwINC/0L7QtNCw0LLQsNC90LjRj9GC0LAg0LfQsCDQuNC90LTQtdC60YHQuNGC0LUg0L3QsCDQv9Cw0LrQtdGC0LjRgtC1INC40LfQsdGA0L7QtdC90Lgg0L3QsCDQutC+0LzQsNC90LTQvdC40Y8g0YDQtdC0IgogCi0jOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE2OAorIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxNzcKIG1zZ2lkICJzdGFydCB3YWxrIGF0IGNvbW1pdHMgbGlzdGVkIGJ5IHN0ZGluIgogbXNnc3RyICLQt9Cw0L/QvtGH0LLQsNC90LUg0L3QsCDQvtCx0YXQvtC20LTQsNC90LXRgtC+INC/0YDQuCDQv9C+0LTQsNCy0LDQvdC40Y/RgtCwINC/0L7QtNCw0LTQtdC90Lgg0L3QsCDRgdGC0LDQvdC00LDRgNGC0L3QuNGPINCy0YXQvtC0IgogCi0jOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE3MAorIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxNzkKIG1zZ2lkICJpbmNsdWRlIGFsbCBjb21taXRzIGFscmVhZHkgaW4gdGhlIGNvbW1pdC1ncmFwaCBmaWxlIgogbXNnc3RyICIiCiAi0LLQutC70Y7Rh9Cy0LDQvdC1INC90LAg0LLRgdC40YfQutC4INC/0L7QtNCw0LLQsNC90LjRjywg0LrQvtC40YLQviDQstC10YfQtSDRgdCwINCy0YrQsiDRhNCw0LnQu9CwINGBINCz0YDQsMyA0YTQsCDQvdCwINC/0L7QtNCw0LLQsNC90LjRj9GC0LAiCiAKLSM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTcyCisjOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE4MgogbXNnaWQgImFsbG93IHdyaXRpbmcgYW4gaW5jcmVtZW50YWwgY29tbWl0LWdyYXBoIGZpbGUiCiBtc2dzdHIgItC/0L7Qt9Cy0L7Qu9GP0LLQsNC90LUg0L3QsCDQt9Cw0L/QuNGBINC90LAg0L3QsNGA0LDRgdGC0LLQsNGJINGE0LDQudC7INGBINCz0YDQsMyA0YTQsCDQvdCwINC/0L7QtNCw0LLQsNC90LjRj9GC0LAiCiAKLSM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTc0IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTc4CisjOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE4NCBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE4OAogbXNnaWQgIm1heGltdW0gbnVtYmVyIG9mIGNvbW1pdHMgaW4gYSBub24tYmFzZSBzcGxpdCBjb21taXQtZ3JhcGgiCiBtc2dzdHIgItC80LDQutGB0LjQvNCw0LvQtdC9INCx0YDQvtC5INC/0L7QtNCw0LLQsNC90LjRjyDQsiDQvdC10LHQsNC30L7QstC+INC90LjQstC+INC90LAg0YDQsNC30LTRgNC+0LHQtdC9INCz0YDQsNGEIgogCi0jOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE3NgorIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxODYKIG1zZ2lkICJtYXhpbXVtIHJhdGlvIGJldHdlZW4gdHdvIGxldmVscyBvZiBhIHNwbGl0IGNvbW1pdC1ncmFwaCIKIG1zZ3N0ciAiIgogItC80LDQutGB0LjQvNCw0LvQvdC+INC+0YLQvdC+0YjQtdC90LjQtSDQvdCwINCx0YDQvtGPINC/0L7QtNCw0LLQsNC90LjRjyDQsiDQtNCy0LUg0L/QvtGB0LvQtdC00L7QstCw0YLQtdC70L3QuCDQvdC40LLQsCDQsiDRgNCw0LfQtNGA0L7QsdC10L0gIgogItCz0YDQsNGEIgogCi0jOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE5MQorIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoyMDQKIG1zZ2lkICJ1c2UgYXQgbW9zdCBvbmUgb2YgLS1yZWFjaGFibGUsIC0tc3RkaW4tY29tbWl0cywgb3IgLS1zdGRpbi1wYWNrcyIKIG1zZ3N0ciAiIgogItC+0L/RhtC40LjRgtC1IOKAni0tcmVhY2hhYmxl4oCcLCDigJ4tLXN0ZGluLWNvbW1pdHPigJwg0Lgg4oCeLS1zdGRpbi1wYWNrc+KAnCDRgdCwINC90LXRgdGK0LLQvNC10YHRgtC40LzQuCIKQEAgLTEyNjQ5LDU3ICsxMjY4Niw1NyBAQAogbXNnaWQgInByaW50IHNpemVzIGluIGh1bWFuIHJlYWRhYmxlIGZvcm1hdCIKIG1zZ3N0ciAi0LjQt9Cy0LXQttC00LDQvdC1INC90LAg0YDQsNC30LzQtdGA0LjRgtC1INC90LAg0L7QsdC10LrRgtC40YLQtSDQstGK0LIg0YTQvtGA0LzQsNGCINC70LXRgdC90L4g0YfQtdGC0LjQvCDQvtGCINGF0L7RgNCwIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6MjcKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzoyNgogbXNnaWQgImdpdCBkZXNjcmliZSBbPG9wdGlvbnM+XSBbPGNvbW1pdC1pc2g+Li4uXSIKIG1zZ3N0ciAiZ2l0IGRlc2NyaWJlIFvQntCf0KbQmNCv4oCmXSBb0KPQmtCQ0JfQkNCi0JXQm1/QmtCq0Jxf0J/QntCU0JDQktCQ0J3QleKApl0iCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzoyOAorIzogYnVpbHRpbi9kZXNjcmliZS5jOjI3CiBtc2dpZCAiZ2l0IGRlc2NyaWJlIFs8b3B0aW9ucz5dIC0tZGlydHkiCiBtc2dzdHIgImdpdCBkZXNjcmliZSBb0J7Qn9Cm0JjQr+KApl0gLS1kaXJ0eSIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjYzCisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NjIKIG1zZ2lkICJoZWFkIgogbXNnc3RyICLQvtGB0L3QvtCy0L3QviIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjYzCisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NjIKIG1zZ2lkICJsaWdodHdlaWdodCIKIG1zZ3N0ciAi0LrRgNCw0YLQutC+IgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NjMKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo2MgogbXNnaWQgImFubm90YXRlZCIKIG1zZ3N0ciAi0LDQvdC+0YLQuNGA0LDQvdC+IgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6MjczCisjOiBidWlsdGluL2Rlc2NyaWJlLmM6Mjc1CiAjLCBjLWZvcm1hdAogbXNnaWQgImFubm90YXRlZCB0YWcgJXMgbm90IGF2YWlsYWJsZSIKIG1zZ3N0ciAi0L3QtSDRgdGK0YnQtdGB0YLQstGD0LLQsCDQsNC90L7RgtC40YDQsNC9INC10YLQuNC60LXRgiDigJ4lc+KAnCIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjI3NworIzogYnVpbHRpbi9kZXNjcmliZS5jOjI3OQogIywgYy1mb3JtYXQKIG1zZ2lkICJhbm5vdGF0ZWQgdGFnICVzIGhhcyBubyBlbWJlZGRlZCBuYW1lIgogbXNnc3RyICLQsiDQsNC90L7RgtC40YDQsNC90LjRjyDQtdGC0LjQutC10YIg4oCeJXPigJwg0LvQuNC/0YHQstCwINCy0LPRgNCw0LTQtdC90L4g0LjQvNC1IgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6Mjc5CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6MjgxCiAjLCBjLWZvcm1hdAogbXNnaWQgInRhZyAnJXMnIGlzIHJlYWxseSAnJXMnIGhlcmUiCiBtc2dzdHIgItC10YLQuNC60LXRgtGK0YIg4oCeJXPigJwg0YLRg9C6INC1INCy0YHRitGJ0L3QvtGB0YIg4oCeJXPigJwiCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzozMjMKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzozMjUKICMsIGMtZm9ybWF0CiBtc2dpZCAibm8gdGFnIGV4YWN0bHkgbWF0Y2hlcyAnJXMnIgogbXNnc3RyICLQvdC40LrQvtC5INC10YLQuNC60LXRgiDQvdC1INC90LDQv9Cw0YHQstCwINGC0L7Rh9C90L4g4oCeJXPigJwiCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzozMjUKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzozMjcKICMsIGMtZm9ybWF0CiBtc2dpZCAiTm8gZXhhY3QgbWF0Y2ggb24gcmVmcyBvciB0YWdzLCBzZWFyY2hpbmcgdG8gZGVzY3JpYmVcbiIKIG1zZ3N0ciAi0J3QuNC60L7RjyDQstC10YDRgdC40Y8g0Lgg0LXRgtC40LrQtdGCINC90LUg0L3QsNC/0LDRgdCy0LDRgiDRgtC+0YfQvdC+LiAg0KLRitGA0YHQuCDRgdC1INC/0L4g0L7Qv9C40YHQsNC90LjQtVxuIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6Mzc5CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6MzgxCiAjLCBjLWZvcm1hdAogbXNnaWQgImZpbmlzaGVkIHNlYXJjaCBhdCAlc1xuIgogbXNnc3RyICLRgtGK0YDRgdC10L3QtdGC0L4g0L/RgNC40LrQu9GO0YfQuCDQv9GA0Lgg4oCeJXPigJxcbiIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjQwNQorIzogYnVpbHRpbi9kZXNjcmliZS5jOjQwNwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiTm8gYW5ub3RhdGVkIHRhZ3MgY2FuIGRlc2NyaWJlICclcycuXG4iCkBAIC0xMjcwOCw3ICsxMjc0NSw3IEBACiAi0J3QuNC60L7QuSDQsNC90L7RgtC40YDQsNC9INC10YLQuNC60LXRgiDQvdC1INC+0L/QuNGB0LLQsCDigJ4lc+KAnC5cbiIKICLQodGK0YnQtdGB0YLQstGD0LLQsNGCINC4INC90LXQsNC90L7RgtC40YDQsNC90Lgg0LXRgtC40LrQtdGC0LguICDQn9GA0L7QsdCy0LDQudGC0LUg0YEg0L7Qv9GG0LjRj9GC0LAg4oCeLS10YWdz4oCcLiIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjQwOQorIzogYnVpbHRpbi9kZXNjcmliZS5jOjQxMQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiTm8gdGFncyBjYW4gZGVzY3JpYmUgJyVzJy5cbiIKQEAgLTEyNzE3LDEyICsxMjc1NCwxMiBAQAogItCd0LjQutC+0Lkg0LXRgtC40LrQtdGCINC90LUg0L7Qv9C40YHQstCwIOKAniVz4oCcLlxuIgogItCf0YDQvtCx0LLQsNC50YLQtSDRgSDQvtC/0YbQuNGP0YLQsCDigJ4tLWFsd2F5c+KAnCDQuNC70Lgg0YHRitC30LTQsNC50YLQtSDQtdGC0LjQutC10YLQuC4iCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo0MzkKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo0NDEKICMsIGMtZm9ybWF0CiBtc2dpZCAidHJhdmVyc2VkICVsdSBjb21taXRzXG4iCiBtc2dzdHIgItC/0YDQtdGC0YrRgNGB0LXQvdC4INGB0LAgJWx1INC/0L7QtNCw0LLQsNC90LjRj1xuIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NDQyCisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NDQ0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJtb3JlIHRoYW4gJWkgdGFncyBmb3VuZDsgbGlzdGVkICVpIG1vc3QgcmVjZW50XG4iCkBAIC0xMjczMSw5MyArMTI3NjgsOTMgQEAKICLQvtGC0LrRgNC40YLQuCDRgdCwINC90LDQtCAlaSDQtdGC0LjQutC10YLQsCwg0LjQt9Cy0LXQtNC10L3QuCDRgdCwINC/0L7RgdC70LXQtNC90LjRgtC1ICVpLFxuIgogItGC0YrRgNGB0LXQvdC10YLQviDQsdC1INC/0YDQtdC60YDQsNGC0LXQvdC+INC/0YDQuCDigJ4lc+KAnC5cbiIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjUxMAorIzogYnVpbHRpbi9kZXNjcmliZS5jOjUxMgogIywgYy1mb3JtYXQKIG1zZ2lkICJkZXNjcmliZSAlc1xuIgogbXNnc3RyICLQvtC/0LjRgdCw0L3QuNC1INC90LAg4oCeJXPigJxcbiIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjUxMworIzogYnVpbHRpbi9kZXNjcmliZS5jOjUxNQogIywgYy1mb3JtYXQKIG1zZ2lkICJOb3QgYSB2YWxpZCBvYmplY3QgbmFtZSAlcyIKIG1zZ3N0ciAi0J3QtdC/0YDQsNCy0LjQu9C90L4g0LjQvNC1INC90LAg0L7QsdC10LrRgiDigJ4lc+KAnCIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjUyMQorIzogYnVpbHRpbi9kZXNjcmliZS5jOjUyMwogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyBpcyBuZWl0aGVyIGEgY29tbWl0IG5vciBibG9iIgogbXNnc3RyICLigJ4lc+KAnCDQvdC1INC1INC90LjRgtC+INC/0L7QtNCw0LLQsNC90LUsINC90LjRgtC+INC+0LHQtdC60YItQkxPQiIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjUzNQorIzogYnVpbHRpbi9kZXNjcmliZS5jOjUzNwogbXNnaWQgImZpbmQgdGhlIHRhZyB0aGF0IGNvbWVzIGFmdGVyIHRoZSBjb21taXQiCiBtc2dzdHIgItC+0YLQutGA0LjQstCw0L3QtSDQvdCwINC10YLQuNC60LXRgtCwLCDQutC+0LnRgtC+INGB0LvQtdC00LLQsCDQv9C+0LTQsNCy0LDQvdC1IgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NTM2CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NTM4CiBtc2dpZCAiZGVidWcgc2VhcmNoIHN0cmF0ZWd5IG9uIHN0ZGVyciIKIG1zZ3N0ciAiIgogItC40LfQstC10LbQtNCw0L3QtSDQvdCwINC40L3RhNC+0YDQvNCw0YbQuNGPINC30LAg0YLRgNCw0YHQuNGA0LDQvdC1INC90LAg0YHRgtGA0LDRgtC10LPQuNGP0YLQsCDQt9CwINGC0YrRgNGB0LXQvdC1INC90LAgIgogItGB0YLQsNC90LTQsNGA0YLQvdCw0YLQsCDQs9GA0LXRiNC60LAiCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1MzcKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1MzkKIG1zZ2lkICJ1c2UgYW55IHJlZiIKIG1zZ3N0ciAi0LjQt9C/0L7Qu9C30LLQsNC90LUg0L3QsCDQv9GA0L7QuNC30LLQvtC70LXQvSDRg9C60LDQt9Cw0YLQtdC7IgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NTM4CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NTQwCiBtc2dpZCAidXNlIGFueSB0YWcsIGV2ZW4gdW5hbm5vdGF0ZWQiCiBtc2dzdHIgItC40LfQv9C+0LvQt9Cy0LDQvdC1INC90LAg0LLRgdC10LrQuCDQtdGC0LjQutC10YIg4oCUINCy0LrQu9GO0YfQuNGC0LXQu9C90L4g0Lgg0L3QtdCw0L3QvtGC0LjRgNCw0L3QuNGC0LUiCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1MzkKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1NDEKIG1zZ2lkICJhbHdheXMgdXNlIGxvbmcgZm9ybWF0IgogbXNnc3RyICLQstC40L3QsNCz0Lgg0LTQsCDRgdC1INC/0L7Qu9C30LLQsCDQtNGK0LvQs9C40Y/RgiDRhNC+0YDQvNCw0YIiCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1NDAKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1NDIKIG1zZ2lkICJvbmx5IGZvbGxvdyBmaXJzdCBwYXJlbnQiCiBtc2dzdHIgItC/0YDQvtGB0LvQtdC00Y/QstCw0L3QtSDRgdCw0LzQviDQvdCwINC/0YrRgNCy0LjRjyDRgNC+0LTQuNGC0LXQuyIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjU0MworIzogYnVpbHRpbi9kZXNjcmliZS5jOjU0NQogbXNnaWQgIm9ubHkgb3V0cHV0IGV4YWN0IG1hdGNoZXMiCiBtc2dzdHIgItC40LfQstC10LbQtNCw0L3QtSDRgdCw0LzQviDQvdCwINGC0L7Rh9C90LjRgtC1INGB0YrQstC/0LDQtNC10L3QuNGPIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NTQ1CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NTQ3CiBtc2dpZCAiY29uc2lkZXIgPG4+IG1vc3QgcmVjZW50IHRhZ3MgKGRlZmF1bHQ6IDEwKSIKIG1zZ3N0ciAi0LTQsCDRgdC1INGC0YrRgNGB0Lgg0YHQsNC80L4g0LIg0YLQvtC30Lgg0JHQoNCe0Jkg0L/QvtGB0LvQtdC00L3QuCDQtdGC0LjQutC10YLQuCAo0YHRgtCw0L3QtNCw0YDRgtC90L46IDEwKSIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjU0NworIzogYnVpbHRpbi9kZXNjcmliZS5jOjU0OQogbXNnaWQgIm9ubHkgY29uc2lkZXIgdGFncyBtYXRjaGluZyA8cGF0dGVybj4iCiBtc2dzdHIgItC00LAg0YHQtSDRgtGK0YDRgdC4INGB0LDQvNC+INC40LfQvNC10LbQtNGDINC10YLQuNC60LXRgtC40YLQtSDQvdCw0L/QsNGB0LLQsNGJ0Lgg0YLQvtC30Lgg0KjQkNCR0JvQntCdIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NTQ5CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NTUxCiBtc2dpZCAiZG8gbm90IGNvbnNpZGVyIHRhZ3MgbWF0Y2hpbmcgPHBhdHRlcm4+IgogbXNnc3RyICLQtNCwINC90LUg0YHQtSDRgtGK0YDRgdC4INC40LfQvNC10LbQtNGDINC10YLQuNC60LXRgtC40YLQtSDQvdCw0L/QsNGB0LLQsNGJ0Lgg0YLQvtC30Lgg0KjQkNCR0JvQntCdIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NTUxIGJ1aWx0aW4vbmFtZS1yZXYuYzo0MjIKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1NTMgYnVpbHRpbi9uYW1lLXJldi5jOjQyNgogbXNnaWQgInNob3cgYWJicmV2aWF0ZWQgY29tbWl0IG9iamVjdCBhcyBmYWxsYmFjayIKIG1zZ3N0ciAi0LjQt9Cy0LXQttC00LDQvdC1INC90LAg0YHRitC60YDQsNGC0LXQvdC+INC40LzQtSDQvdCwINC+0LHQtdC60YIg0LrQsNGC0L4g0YDQtdC30LXRgNCy0LXQvSDQstCw0YDQuNCw0L3RgiIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjU1MiBidWlsdGluL2Rlc2NyaWJlLmM6NTU1CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NTU0IGJ1aWx0aW4vZGVzY3JpYmUuYzo1NTcKIG1zZ2lkICJtYXJrIgogbXNnc3RyICLQnNCQ0KDQmtCV0KAiCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1NTMKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1NTUKIG1zZ2lkICJhcHBlbmQgPG1hcms+IG9uIGRpcnR5IHdvcmtpbmcgdHJlZSAoZGVmYXVsdDogXCItZGlydHlcIikiCiBtc2dzdHIgItC00L7QsdCw0LLRj9C90LUg0L3QsCDRgtCw0LrRitCyINCc0JDQoNCa0JXQoCDQvdCwINGA0LDQsdC+0YLQvdC+0YLQviDQtNGK0YDQstC+ICjRgdGC0LDQvdC00LDRgNGC0L3QviDQtSDigJ4tZGlydHnigJwpIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NTU2CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NTU4CiBtc2dpZCAiYXBwZW5kIDxtYXJrPiBvbiBicm9rZW4gd29ya2luZyB0cmVlIChkZWZhdWx0OiBcIi1icm9rZW5cIikiCiBtc2dzdHIgIiIKICLQtNC+0LHQsNCy0Y/QvdC1INC90LAg0YLQsNC60YrQsiDQnNCQ0KDQmtCV0KAg0L3QsCDRgdGH0YPQv9C10L3QvtGC0L4g0YDQsNCx0L7RgtC90L4g0LTRitGA0LLQviAo0YHRgtCw0L3QtNCw0YDRgtC90L4g0LUg4oCeLWJyb2tlbuKAnCkiCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1NzQKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1NzYKIG1zZ2lkICItLWxvbmcgaXMgaW5jb21wYXRpYmxlIHdpdGggLS1hYmJyZXY9MCIKIG1zZ3N0ciAi0J7Qv9GG0LjQuNGC0LUg4oCeLS1sb25n4oCcINC4IOKAni0tYWJicmV2PTDigJwg0YHQsCDQvdC10YHRitCy0LzQtdGB0YLQuNC80LgiCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo2MDMKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo2MDUKIG1zZ2lkICJObyBuYW1lcyBmb3VuZCwgY2Fubm90IGRlc2NyaWJlIGFueXRoaW5nLiIKIG1zZ3N0ciAi0J3QtSDRgdCwINC+0YLQutGA0LjRgtC4INC40LzQtdC90LAg4oCUINC90LjRidC+INC90LUg0LzQvtC20LUg0LTQsCDQsdGK0LTQtSDQvtC/0LjRgdCw0L3Qvi4iCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo2NTQKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo2NTYKIG1zZ2lkICItLWRpcnR5IGlzIGluY29tcGF0aWJsZSB3aXRoIGNvbW1pdC1pc2hlcyIKIG1zZ3N0ciAi0L7Qv9GG0LjRj9GC0LAg4oCeLS1kaXJ0eeKAnCDQtSDQvdC10YHRitCy0LzQtdGB0YLQuNC80LAg0YEg0YPQutCw0LfQsNGC0LXQuyDQutGK0Lwg0L/QvtC00LDQstCw0L3QtSIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjY1NgorIzogYnVpbHRpbi9kZXNjcmliZS5jOjY1OAogbXNnaWQgIi0tYnJva2VuIGlzIGluY29tcGF0aWJsZSB3aXRoIGNvbW1pdC1pc2hlcyIKIG1zZ3N0ciAi0L7Qv9GG0LjRj9GC0LAg4oCeLS1icm9rZW7igJwg0LUg0L3QtdGB0YrQstC80LXRgdGC0LjQvNCwINGBINGD0LrQsNC30LDRgtC10Lsg0LrRitC8INC/0L7QtNCw0LLQsNC90LUiCiAKQEAgLTEyODU0LDI3ICsxMjg5MSwyNyBAQAogbXNnaWQgImdpdCBkaWZmdG9vbCBbPG9wdGlvbnM+XSBbPGNvbW1pdD4gWzxjb21taXQ+XV0gWy0tXSBbPHBhdGg+Li4uXSIKIG1zZ3N0ciAiZ2l0IGRpZmZ0b29sIFvQntCf0KbQmNCv4oCmXSBb0J/QntCU0JDQktCQ0J3QlSBb0J/QntCU0JDQktCQ0J3QlV1dIFtbLS1dINCf0KrQouKApl0iCiAKLSM6IGJ1aWx0aW4vZGlmZnRvb2wuYzoyNTMKKyM6IGJ1aWx0aW4vZGlmZnRvb2wuYzoyNjAKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkOiAlZCIKIG1zZ3N0ciAi0L3QtdGD0YHQv9C10YjQvdC+INC00LXQudGB0YLQstC40LUg0YEg0LjQt9GF0L7QtNC10L0g0LrQvtC0OiAlZCIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjI5NQorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjMwMgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcmVhZCBzeW1saW5rICVzIgogbXNnc3RyICLRgdC40LzQstC+0LvQvdCw0YLQsCDQstGA0YrQt9C60LAg4oCeJXPigJwg0L3QtSDQvNC+0LbQtSDQtNCwINCx0YrQtNC1INC/0YDQvtGH0LXRgtC10L3QsCIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjI5NworIzogYnVpbHRpbi9kaWZmdG9vbC5jOjMwNAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcmVhZCBzeW1saW5rIGZpbGUgJXMiCiBtc2dzdHIgItGE0LDQudC70YrRgiwg0YHQvtGH0LXQvSDQvtGCINGB0LjQvNCy0L7Qu9C90LDRgtCwINCy0YDRitC30LrQsCDigJ4lc+KAnCwg0L3QtSDQvNC+0LbQtSDQtNCwINCx0YrQtNC1INC/0YDQvtGH0LXRgtC10L0iCiAKLSM6IGJ1aWx0aW4vZGlmZnRvb2wuYzozMDUKKyM6IGJ1aWx0aW4vZGlmZnRvb2wuYzozMTIKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHJlYWQgb2JqZWN0ICVzIGZvciBzeW1saW5rICVzIgogbXNnc3RyICLQvtCx0LXQutGC0YrRgiDigJ4lc+KAnCDQt9CwINGB0LjQvNCy0L7Qu9C90LDRgtCwINCy0YDRitC30LrQsCDigJ4lc+KAnCDQvdC1INC80L7QttC1INC00LAg0LHRitC00LUg0L/RgNC+0YfQtdGC0LXQvSIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjQwNgorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjQxMwogbXNnaWQgIiIKICJjb21iaW5lZCBkaWZmIGZvcm1hdHMoJy1jJyBhbmQgJy0tY2MnKSBhcmUgbm90IHN1cHBvcnRlZCBpblxuIgogImRpcmVjdG9yeSBkaWZmIG1vZGUoJy1kJyBhbmQgJy0tZGlyLWRpZmYnKS4iCkBAIC0xMjg4Miw1NSArMTI5MTksNTUgQEAKICLQutC+0LzQsdC40L3QuNGA0LDQvdC40YLQtSDRhNC+0YDQvNCw0YLQuCDQvdCwINGA0LDQt9C70LjQutC40YLQtSAo4oCeLWPigJwg0Lgg4oCeLS1jY+KAnCkg0L3QtSDRgdC1INC/0L7QtNC00YrRgNC20LDRglxuIgogItCyINGA0LXQttC40LzQsCDQt9CwINGA0LDQt9C70LjQutC4INCy0YrRgNGF0YMg0LTQuNGA0LXQutGC0L7RgNC40LggKOKAni1k4oCcINC4IOKAni0tZGlyLWRpZmbigJwpLiIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjYyNgorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjYzNAogIywgYy1mb3JtYXQKIG1zZ2lkICJib3RoIGZpbGVzIG1vZGlmaWVkOiAnJXMnIGFuZCAnJXMnLiIKIG1zZ3N0ciAi0Lgg0LTQstCw0YLQsCDRhNCw0LnQu9CwINGB0LAg0L/RgNC+0LzQtdC90LXQvdC4OiDigJ4lc+KAnCDQuCDigJ4lc+KAnC4iCiAKLSM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo2MjgKKyM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo2MzYKIG1zZ2lkICJ3b3JraW5nIHRyZWUgZmlsZSBoYXMgYmVlbiBsZWZ0LiIKIG1zZ3N0ciAi0YDQsNCx0L7RgtC90L7RgtC+INC00YrRgNCy0L4g0LUg0LjQt9C+0YHRgtCw0LLQtdC90L4uIgogCi0jOiBidWlsdGluL2RpZmZ0b29sLmM6NjM5CisjOiBidWlsdGluL2RpZmZ0b29sLmM6NjQ3CiAjLCBjLWZvcm1hdAogbXNnaWQgInRlbXBvcmFyeSBmaWxlcyBleGlzdCBpbiAnJXMnLiIKIG1zZ3N0ciAi0LIg4oCeJXPigJwg0LjQvNCwINCy0YDQtdC80LXQvdC90Lgg0YTQsNC50LvQvtCy0LUuIgogCi0jOiBidWlsdGluL2RpZmZ0b29sLmM6NjQwCisjOiBidWlsdGluL2RpZmZ0b29sLmM6NjQ4CiBtc2dpZCAieW91IG1heSB3YW50IHRvIGNsZWFudXAgb3IgcmVjb3ZlciB0aGVzZS4iCiBtc2dzdHIgItCy0YrQt9C80L7QttC90L4g0LUg0LTQsCDQs9C4INC40LfRh9C40YHRgtC40YLQtSDQuNC70Lgg0LLRitC30YHRgtCw0L3QvtCy0LjRgtC1IgogCi0jOiBidWlsdGluL2RpZmZ0b29sLmM6Njg5CisjOiBidWlsdGluL2RpZmZ0b29sLmM6Njk3CiBtc2dpZCAidXNlIGBkaWZmLmd1aXRvb2xgIGluc3RlYWQgb2YgYGRpZmYudG9vbGAiCiBtc2dzdHIgItC40LfQv9C+0LvQt9Cy0LDQudGC0LUg4oCeZGlmZi5ndWl0b29s4oCcINCy0LzQtdGB0YLQviDigJ5kaWZmLnRvb2zigJwiCiAKLSM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo2OTEKKyM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo2OTkKIG1zZ2lkICJwZXJmb3JtIGEgZnVsbC1kaXJlY3RvcnkgZGlmZiIKIG1zZ3N0ciAi0YDQsNC30LvQuNC60LAg0L/QviDQtNC40YDQtdC60YLQvtGA0LjQuCIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjY5MworIzogYnVpbHRpbi9kaWZmdG9vbC5jOjcwMQogbXNnaWQgImRvIG5vdCBwcm9tcHQgYmVmb3JlIGxhdW5jaGluZyBhIGRpZmYgdG9vbCIKIG1zZ3N0ciAi0YHRgtCw0YDRgtC40YDQsNC90LUg0L3QsCDQn9Cg0J7Qk9Cg0JDQnNCQ0YLQsCDQt9CwINGA0LDQt9C70LjQutC4INCx0LXQtyDQv9GA0LXQtNGD0L/RgNC10LbQtNC10L3QuNC1IgogCi0jOiBidWlsdGluL2RpZmZ0b29sLmM6Njk4CisjOiBidWlsdGluL2RpZmZ0b29sLmM6NzA2CiBtc2dpZCAidXNlIHN5bWxpbmtzIGluIGRpci1kaWZmIG1vZGUiCiBtc2dzdHIgItGB0LvQtdC00LLQsNC90LUg0L3QsCDRgdC40LzQstC+0LvQvdC40YLQtSDQstGA0YrQt9C60Lgg0L/RgNC4INGA0LDQt9C70LjQutCwINC/0L4g0LTQuNGA0LXQutGC0L7RgNC40LgiCiAKLSM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo2OTkKKyM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo3MDcKIG1zZ2lkICJ0b29sIgogbXNnc3RyICLQn9Cg0J7Qk9Cg0JDQnNCQIgogCi0jOiBidWlsdGluL2RpZmZ0b29sLmM6NzAwCisjOiBidWlsdGluL2RpZmZ0b29sLmM6NzA4CiBtc2dpZCAidXNlIHRoZSBzcGVjaWZpZWQgZGlmZiB0b29sIgogbXNnc3RyICLQuNC30L/QvtC70LfQstCw0L3QtSDQvdCwINGD0LrQsNC30LDQvdCw0YLQsCDQn9Cg0J7Qk9Cg0JDQnNCQIgogCi0jOiBidWlsdGluL2RpZmZ0b29sLmM6NzAyCisjOiBidWlsdGluL2RpZmZ0b29sLmM6NzEwCiBtc2dpZCAicHJpbnQgYSBsaXN0IG9mIGRpZmYgdG9vbHMgdGhhdCBtYXkgYmUgdXNlZCB3aXRoIGAtLXRvb2xgIgogbXNnc3RyICIiCiAi0LjQt9Cy0LXQttC00LDQvdC1INC90LAg0YHQv9C40YHRitC6INGBINCy0YHQuNGH0LrQuCDQn9Cg0J7Qk9Cg0JDQnNC4LCDQutC+0LjRgtC+INC80L7QttC1INC00LAg0YHQtSDQv9C+0LvQt9Cy0LDRgiDRgSDQvtC/0YbQuNGP0YLQsCDigJ4tLSIKICJ0b29s4oCcIgogCi0jOiBidWlsdGluL2RpZmZ0b29sLmM6NzA1CisjOiBidWlsdGluL2RpZmZ0b29sLmM6NzEzCiBtc2dpZCAiIgogIm1ha2UgJ2dpdC1kaWZmdG9vbCcgZXhpdCB3aGVuIGFuIGludm9rZWQgZGlmZiB0b29sIHJldHVybnMgYSBub24gLSB6ZXJvIGV4aXQgIgogImNvZGUiCkBAIC0xMjkzOCwzMSArMTI5NzUsMzEgQEAKICLigJ5naXQtZGlmZnRvb2zigJwg0LTQsCDRgdC/0YDQtSDRgNCw0LHQvtGC0LAsINC60L7Qs9Cw0YLQviDRgdGC0LDRgNGC0LjRgNCw0L3QsNGC0LAg0J/QoNCe0JPQoNCQ0JzQkCDQt9Cw0LLRitGA0YjQuCDRgSAiCiAi0L3QtdC90YPQu9C10LIg0LrQvtC0IgogCi0jOiBidWlsdGluL2RpZmZ0b29sLmM6NzA4CisjOiBidWlsdGluL2RpZmZ0b29sLmM6NzE2CiBtc2dpZCAic3BlY2lmeSBhIGN1c3RvbSBjb21tYW5kIGZvciB2aWV3aW5nIGRpZmZzIgogbXNnc3RyICLQutC+0LzQsNC90LTQsCDQt9CwINGA0LDQt9Cz0LvQtdC20LTQsNC90LUg0L3QsCDRgNCw0LfQu9C40LrQuCIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjcwOQorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjcxNwogbXNnaWQgInBhc3NlZCB0byBgZGlmZmAiCiBtc2dzdHIgItC/0L7QtNCw0LLQsCDRgdC1INC60YrQvCDigJ5kaWZm4oCcIgogCi0jOiBidWlsdGluL2RpZmZ0b29sLmM6NzI0CisjOiBidWlsdGluL2RpZmZ0b29sLmM6NzMyCiBtc2dpZCAiZGlmZnRvb2wgcmVxdWlyZXMgd29ya3RyZWUgb3IgLS1uby1pbmRleCIKIG1zZ3N0ciAi4oCeZ2l0LWRpZmZ0b29s4oCcINC40LfQuNGB0LrQstCwINGA0LDQsdC+0YLQvdC+INC00YrRgNCy0L4g0LjQu9C4INC+0L/RhtC40Y/RgtCwIOKAni0tbm8taW5kZXjigJwiCiAKLSM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo3MzEKKyM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo3MzkKIG1zZ2lkICItLWRpci1kaWZmIGlzIGluY29tcGF0aWJsZSB3aXRoIC0tbm8taW5kZXgiCiBtc2dzdHIgItC+0L/RhtC40LjRgtC1IOKAni0tZGlyLWRpZmbigJwg0Lgg4oCeLS1uby1pbmRleOKAnCDRgdCwINC90LXRgdGK0LLQvNC10YHRgtC40LzQuCIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjczNAorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjc0MgogbXNnaWQgIi0tZ3VpLCAtLXRvb2wgYW5kIC0tZXh0Y21kIGFyZSBtdXR1YWxseSBleGNsdXNpdmUiCiBtc2dzdHIgItC+0L/RhtC40LjRgtC1IOKAni0tZ3Vp4oCcLCDigJ4tLXRvb2zigJwg0Lgg4oCeLS1leHRjbWTigJwg0YHQsCDQvdC10YHRitCy0LzQtdGB0YLQuNC80Lgg0LXQtNC90LAg0YEg0LTRgNGD0LPQsCIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjc0MgorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjc1MAogbXNnaWQgIm5vIDx0b29sPiBnaXZlbiBmb3IgLS10b29sPTx0b29sPiIKIG1zZ3N0ciAi0L3QtSDQtSDQt9Cw0LTQsNC00LXQvdCwINC/0YDQvtCz0YDQsNC80LAg0LfQsCDigJ4tLXRvb2w90J/QoNCe0JPQoNCQ0JzQkOKAnCIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjc0OQorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjc1NwogbXNnaWQgIm5vIDxjbWQ+IGdpdmVuIGZvciAtLWV4dGNtZD08Y21kPiIKIG1zZ3N0ciAi0L3QtSDQtSDQt9Cw0LTQsNC00LXQvdCwINC60L7QvNCw0L3QtNCwINC30LAg4oCeLS1leHRjbWQ90JrQntCc0JDQndCU0JDigJwiCiAKQEAgLTEzMDAyLDE2MCArMTMwMzksMTg1IEBACiBtc2dpZCAiZ2l0IGZhc3QtZXhwb3J0IFtyZXYtbGlzdC1vcHRzXSIKIG1zZ3N0ciAiZ2l0IGZhc3QtZXhwb3J0IFvQntCf0KbQmNCYX9CX0JBf0KHQn9CY0KHQqtCa0JBf0KFf0JLQldCg0KHQmNCYXSIKIAotIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExMjQKKyM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzo4NTIKK21zZ2lkICJFcnJvcjogQ2Fubm90IGV4cG9ydCBuZXN0ZWQgdGFncyB1bmxlc3MgLS1tYXJrLXRhZ3MgaXMgc3BlY2lmaWVkLiIKK21zZ3N0ciAiIgorItCT0YDQtdGI0LrQsDog0L3QtdC/0YDQtdC60LjRgtC1INC10YLQuNC60LXRgtC4INC90LUg0YHQtSDQuNC30L3QsNGB0Y/Rgiwg0L7RgdCy0LXQvSDQsNC60L4g0L3QtSDQt9Cw0LTQsNC00LXRgtC1IOKAni0tbWFyay10YWdz4oCcLiIKKworIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNTIKIG1zZ2lkICJzaG93IHByb2dyZXNzIGFmdGVyIDxuPiBvYmplY3RzIgogbXNnc3RyICLQodGK0L7QsdGJ0LXQvdC40LUg0LfQsCDQvdCw0L/RgNC10LTRitC60LAg0L3QsCDQstGB0LXQutC4INGC0LDQutGK0LIg0JHQoNCe0Jkg0L7QsdC10LrRgtCwIgogCi0jOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTEyNgorIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNTQKIG1zZ2lkICJzZWxlY3QgaGFuZGxpbmcgb2Ygc2lnbmVkIHRhZ3MiCiBtc2dzdHIgItCa0LDQuiDQtNCwINGB0LUg0L7QsdGA0LDQsdC+0YLQstCw0YIg0L/QvtC00L/QuNGB0LDQvdC40YLQtSDQtdGC0LjQutC10YLQuCIKIAotIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExMjkKKyM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTU3CiBtc2dpZCAic2VsZWN0IGhhbmRsaW5nIG9mIHRhZ3MgdGhhdCB0YWcgZmlsdGVyZWQgb2JqZWN0cyIKIG1zZ3N0ciAi0JrQsNC6INC00LAg0YHQtSDQvtCx0YDQsNCx0L7RgtCy0LDRgiDQtdGC0LjQutC10YLQuNGC0LUg0L3QsCDRhNC40LvRgtGA0LjRgNCw0L3QuNGC0LUg0L7QsdC10LrRgtC4IgogCi0jOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTEzMgorIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNjAKIG1zZ2lkICJzZWxlY3QgaGFuZGxpbmcgb2YgY29tbWl0IG1lc3NhZ2VzIGluIGFuIGFsdGVybmF0ZSBlbmNvZGluZyIKIG1zZ3N0ciAiIgogItC60LDQuiDQtNCwINGB0LUg0L7QsdGA0LDQsdC+0YLQstCw0YIg0YHRitC+0LHRidC10L3QuNGP0YLQsCDQt9CwINC/0L7QtNCw0LLQsNC90LUsINC60L7QuNGC0L4g0YHQsCDQsiDQtNGA0YPQs9C+INC60L7QtNC40YDQsNC90LUiCiAKLSM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTM1CisjOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE2MwogbXNnaWQgIkR1bXAgbWFya3MgdG8gdGhpcyBmaWxlIgogbXNnc3RyICLQl9Cw0L/QsNC30LLQsNC90LUg0L3QsCDQvNCw0YDQutC10YDQuNGC0LUg0LIg0YLQvtC30Lgg0KTQkNCZ0JsiCiAKLSM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTM3CisjOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE2NQogbXNnaWQgIkltcG9ydCBtYXJrcyBmcm9tIHRoaXMgZmlsZSIKIG1zZ3N0ciAi0JLQvdCw0YHRj9C90LUg0L3QsCDQvNCw0YDQutC10YDQuNGC0LUg0L7RgiDRgtC+0LfQuCDQpNCQ0JnQmyIKIAotIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExMzkKKyM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTY5Cittc2dpZCAiSW1wb3J0IG1hcmtzIGZyb20gdGhpcyBmaWxlIGlmIGl0IGV4aXN0cyIKK21zZ3N0ciAi0JLQvdCw0YHRj9C90LUg0L3QsCDQvNCw0YDQutC10YDQuNGC0LUg0L7RgiDRgtC+0LfQuCDQpNCQ0JnQmywg0LDQutC+INGB0YrRidC10YHRgtCy0YPQstCwIgorCisjOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE3MQogbXNnaWQgIkZha2UgYSB0YWdnZXIgd2hlbiB0YWdzIGxhY2sgb25lIgogbXNnc3RyICLQlNCwINGB0LUg0LjQt9C/0L7Qu9C30LLQsCDQuNC30LrRg9GB0YLQstC10L3QviDQuNC80LUg0L3QsCDRh9C+0LLQtdC6INC/0YDQuCDQu9C40L/RgdCwINC90LAg0LfQsNC00LDQstCw0Ykg0LXRgtC40LrQtdGC0LAiCiAKLSM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTQxCisjOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE3MwogbXNnaWQgIk91dHB1dCBmdWxsIHRyZWUgZm9yIGVhY2ggY29tbWl0IgogbXNnc3RyICLQmNC30LLQtdC20LTQsNC90LUg0L3QsCDRhtGP0LvQvtGC0L4g0LTRitGA0LLQviDQt9CwINCy0YHRj9C60L4g0L/QvtC00LDQstCw0L3QtSIKIAotIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNDMKKyM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTc1CiBtc2dpZCAiVXNlIHRoZSBkb25lIGZlYXR1cmUgdG8gdGVybWluYXRlIHRoZSBzdHJlYW0iCiBtc2dzdHIgItCY0LfQv9C+0LvQt9Cy0LDQvdC1INC90LAg0LzQsNGA0LrQtdGAINC30LAg0LfQsNCy0YrRgNGI0LLQsNC90LUg0L3QsCDQv9C+0YLQvtC60LAiCiAKLSM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTQ0CisjOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE3NgogbXNnaWQgIlNraXAgb3V0cHV0IG9mIGJsb2IgZGF0YSIKIG1zZ3N0ciAi0JHQtdC3INC40LfQstC10LbQtNCw0L3QtSDQvdCwINGB0YrQtNGK0YDQttCw0L3QuNC10YLQviDQvdCwINC+0LHQtdC60YLQuNGC0LUtQkxPQiIKIAotIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNDUgYnVpbHRpbi9sb2cuYzoxNjMyCisjOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE3NyBidWlsdGluL2xvZy5jOjE2MzMKIG1zZ2lkICJyZWZzcGVjIgogbXNnc3RyICLQo9Ca0JDQl9CQ0KLQldCbX9Cd0JBf0JLQldCg0KHQmNCvIgogCi0jOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE0NgorIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNzgKIG1zZ2lkICJBcHBseSByZWZzcGVjIHRvIGV4cG9ydGVkIHJlZnMiCiBtc2dzdHIgItCf0YDQuNC70LDQs9Cw0L3QtSDQvdCwINCj0JrQkNCX0JDQotCV0JvRj1/QndCQX9CS0JXQoNCh0JjQryDQutGK0Lwg0LjQt9C90LXRgdC10L3QuNGC0LUg0YPQutCw0LfQsNGC0LXQu9C4IgogCi0jOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE0NworIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNzkKIG1zZ2lkICJhbm9ueW1pemUgb3V0cHV0IgogbXNnc3RyICLQsNC90L7QvdC40LzQuNC30LjRgNCw0L3QtSDQvdCwINC40LfQstC10LbQtNCw0L3QsNGC0LAg0LjQvdGE0L7RgNC80LDRhtC40Y8iCiAKLSM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTQ5CisjOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE4MQogbXNnaWQgIlJlZmVyZW5jZSBwYXJlbnRzIHdoaWNoIGFyZSBub3QgaW4gZmFzdC1leHBvcnQgc3RyZWFtIGJ5IG9iamVjdCBpZCIKIG1zZ3N0ciAiIgogItCj0LrQsNC30LLQsNC90LUg0L3QsCDRgNC+0LTQuNGC0LXQu9C40YLQtSwg0LrQvtC40YLQviDQvdC1INGB0LAg0LIg0L/QvtGC0L7QutCwINC90LAg0LHRitGA0LfQviDQuNC30L3QsNGB0Y/QvdC1LCDRgSAiCiAi0LjQtNC10L3RgtC40YTQuNC60LDRgtC+0YAg0L3QsCDQvtCx0LXQutGCIgogCi0jOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE1MQorIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExODMKIG1zZ2lkICJTaG93IG9yaWdpbmFsIG9iamVjdCBpZHMgb2YgYmxvYnMvY29tbWl0cyIKIG1zZ3N0ciAi0JjQt9Cy0LXQttC00LDQvdC1INC90LAg0L/RitGA0LLQvtC90LDRh9Cw0LvQvdC40YLQtSDQuNC00LXQvdGC0LjRhNC40LrQsNGC0L7RgNC4INC90LAg0L7QsdC10LrRgtC40YLQtSBCTE9CL9C/0L7QtNCw0LLRj9C90LjRjyIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjMwCisjOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE4NQorbXNnaWQgIkxhYmVsIHRhZ3Mgd2l0aCBtYXJrIGlkcyIKK21zZ3N0ciAi0JfQsNC00LDQstCw0L3QtSDQvdCwINC40LTQtdC90YLQuNGE0LjQutCw0YLQvtGA0Lgg0L3QsCDQvNCw0YDQutC10YDQuCDQvdCwINC10YLQuNC60LXRgtC40YLQtSIKKworIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjEyMjAKK21zZ2lkICJDYW5ub3QgcGFzcyBib3RoIC0taW1wb3J0LW1hcmtzIGFuZCAtLWltcG9ydC1tYXJrcy1pZi1leGlzdHMiCittc2dzdHIgItC+0L/RhtC40LjRgtC1IOKAni0taW1wb3J0LW1hcmtz4oCcINC4IOKAni0taW1wb3J0LW1hcmtzLWlmLWV4aXN0c+KAnCDRgdCwINC90LXRgdGK0LLQvNC10YHRgtC40LzQuCIKKworIzogYnVpbHRpbi9mZXRjaC5jOjM0CiBtc2dpZCAiZ2l0IGZldGNoIFs8b3B0aW9ucz5dIFs8cmVwb3NpdG9yeT4gWzxyZWZzcGVjPi4uLl1dIgogbXNnc3RyICJnaXQgZmV0Y2ggW9Ce0J/QptCY0K/igKZdIFvQpdCg0JDQndCY0JvQmNCp0JUgW9Cj0JrQkNCX0JDQotCV0JvigKZdXSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjMxCisjOiBidWlsdGluL2ZldGNoLmM6MzUKIG1zZ2lkICJnaXQgZmV0Y2ggWzxvcHRpb25zPl0gPGdyb3VwPiIKIG1zZ3N0ciAiZ2l0IGZldGNoIFvQntCf0KbQmNCv4oCmXSDQk9Cg0KPQn9CQIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MzIKKyM6IGJ1aWx0aW4vZmV0Y2guYzozNgogbXNnaWQgImdpdCBmZXRjaCAtLW11bHRpcGxlIFs8b3B0aW9ucz5dIFsoPHJlcG9zaXRvcnk+IHwgPGdyb3VwPikuLi5dIgogbXNnc3RyICJnaXQgZmV0Y2ggLS1tdWx0aXBsZSBb0J7Qn9Cm0JjQr+KApl0gWyjQpdCg0JDQndCY0JvQmNCp0JUgfCDQk9Cg0KPQn9CQKeKApl0iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzozMworIzogYnVpbHRpbi9mZXRjaC5jOjM3CiBtc2dpZCAiZ2l0IGZldGNoIC0tYWxsIFs8b3B0aW9ucz5dIgogbXNnc3RyICJnaXQgZmV0Y2ggLS1hbGwgW9Ce0J/QptCY0K/igKZdIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTI1IGJ1aWx0aW4vcHVsbC5jOjIwMworIzogYnVpbHRpbi9mZXRjaC5jOjExNQorbXNnaWQgImZldGNoLnBhcmFsbGVsIGNhbm5vdCBiZSBuZWdhdGl2ZSIKK21zZ3N0ciAi0L7Qv9GG0LjRj9GC0LAg4oCeZmV0Y2gucGFyYWxsZWzigJwg0YLRgNGP0LHQstCwINC00LAg0LUg0L3QtdC+0YLRgNC40YbQsNGC0LXQu9C90LAiCisKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxMzggYnVpbHRpbi9wdWxsLmM6MjA0CiBtc2dpZCAiZmV0Y2ggZnJvbSBhbGwgcmVtb3RlcyIKIG1zZ3N0ciAi0LTQvtGB0YLQsNCy0Y/QvdC1INC+0YIg0LLRgdC40YfQutC4INC+0YLQtNCw0LvQtdGH0LXQvdC4INGF0YDQsNC90LjQu9C40YnQsCIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjEyNyBidWlsdGluL3B1bGwuYzoyMDYKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNDAgYnVpbHRpbi9wdWxsLmM6MjQ4Cittc2dpZCAic2V0IHVwc3RyZWFtIGZvciBnaXQgcHVsbC9mZXRjaCIKK21zZ3N0ciAi0LfQsNC00LDQstCw0L3QtSDQvdCwINC60LvQvtC9INC30LAg0YHQu9C10LTQtdC90LUg0LfQsCDQuNC30LTRitGA0L/QstCw0L3QtS/QtNC+0YHRgtCw0LLRj9C90LUiCisKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNDIgYnVpbHRpbi9wdWxsLmM6MjA3CiBtc2dpZCAiYXBwZW5kIHRvIC5naXQvRkVUQ0hfSEVBRCBpbnN0ZWFkIG9mIG92ZXJ3cml0aW5nIgogbXNnc3RyICLQtNC+0LHQsNCy0Y/QvdC1INC60YrQvCDigJ4uZ2l0L0ZFVENIX0hFQUTigJwg0LLQvNC10YHRgtC+INC30LDQvNGP0L3QsCIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjEyOSBidWlsdGluL3B1bGwuYzoyMDkKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNDQgYnVpbHRpbi9wdWxsLmM6MjEwCiBtc2dpZCAicGF0aCB0byB1cGxvYWQgcGFjayBvbiByZW1vdGUgZW5kIgogbXNnc3RyICLQvtGC0LTQsNC70LXRh9C10L0g0L/RitGCLCDQutGK0LTQtdGC0L4g0LTQsCDRgdC1INC60LDRh9C4INC/0LDQutC10YLRitGCIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTMwCisjOiBidWlsdGluL2ZldGNoLmM6MTQ1CiBtc2dpZCAiZm9yY2Ugb3ZlcndyaXRlIG9mIGxvY2FsIHJlZmVyZW5jZSIKIG1zZ3N0ciAi0L/RgNC40L3Rg9C00LjRgtC10LvQvdC+INC/0YDQtdC30LDQv9C40YHQstCw0L3QtSDQvdCwINC70L7QutCw0LvQtdC9INGD0LrQsNC30LDRgtC10LsiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxMzIKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNDcKIG1zZ2lkICJmZXRjaCBmcm9tIG11bHRpcGxlIHJlbW90ZXMiCiBtc2dzdHIgItC00L7RgdGC0LDQstGP0L3QtSDQvtGCINC80L3QvtC20LXRgdGC0LLQviDQvtGC0LTQsNC70LXRh9C10L3QuCDRhdGA0LDQvdC40LvQuNGJ0LAiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxMzQgYnVpbHRpbi9wdWxsLmM6MjEzCisjOiBidWlsdGluL2ZldGNoLmM6MTQ5IGJ1aWx0aW4vcHVsbC5jOjIxNAogbXNnaWQgImZldGNoIGFsbCB0YWdzIGFuZCBhc3NvY2lhdGVkIG9iamVjdHMiCiBtc2dzdHIgItC00L7RgdGC0LDQstGP0L3QtSDQvdCwINCy0YHQuNGH0LrQuCDQtdGC0LjQutC10YLQuCDQuCDQv9GA0LjQvdCw0LTQu9C10LbQsNGJ0Lgg0L7QsdC10LrRgtC4IgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTM2CisjOiBidWlsdGluL2ZldGNoLmM6MTUxCiBtc2dpZCAiZG8gbm90IGZldGNoIGFsbCB0YWdzICgtLW5vLXRhZ3MpIgogbXNnc3RyICLQsdC10Lcg0LTQvtGB0YLQsNCy0Y/QvdC10YLQviDQvdCwINCy0YHQuNGH0LrQuCDQtdGC0LjQutC10YLQuCDigJ4tLW5vLXRhZ3PigJwiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxMzgKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNTMKIG1zZ2lkICJudW1iZXIgb2Ygc3VibW9kdWxlcyBmZXRjaGVkIGluIHBhcmFsbGVsIgogbXNnc3RyICLQsdGA0L7QuSDQv9C+0LTQvNC+0LTRg9C70Lgg0LTQvtGB0YLQsNCy0LXQvdC4INC/0LDRgNCw0LvQtdC70L3QviIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE0MCBidWlsdGluL3B1bGwuYzoyMTYKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNTUgYnVpbHRpbi9wdWxsLmM6MjE3CiBtc2dpZCAicHJ1bmUgcmVtb3RlLXRyYWNraW5nIGJyYW5jaGVzIG5vIGxvbmdlciBvbiByZW1vdGUiCiBtc2dzdHIgItC+0LrQsNGB0YLRgNGP0L3QtSDQvdCwINC60LvQvtC90LjRgtC1INGB0LvQtdC00Y/RidC4INCy0LXRh9C1INC90LXRgdGK0YnQtdGB0YLQstGD0LLQsNGJ0Lgg0L7RgtC00LDQu9C10YfQtdC90Lgg0LrQu9C+0L3QuCIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE0MgorIzogYnVpbHRpbi9mZXRjaC5jOjE1NwogbXNnaWQgInBydW5lIGxvY2FsIHRhZ3Mgbm8gbG9uZ2VyIG9uIHJlbW90ZSBhbmQgY2xvYmJlciBjaGFuZ2VkIHRhZ3MiCiBtc2dzdHIgIiIKICLQvtC60LDRgdGC0YDRj9C90LUg0L3QsCDQu9C+0LrQsNC70L3QuNGC0LUg0LXRgtC40LrQtdGC0LgsINC60L7QuNGC0L4g0LLQtdGH0LUg0L3QtSDRgdGK0YnQtdGB0YLQstGD0LLQsNGCINCyINC+0YLQtNCw0LvQtdGH0LXQvdC+0YLQviAiCiAi0YXRgNCw0L3QuNC70LjRidC1INC4INC/0YDQtdC30LDQv9C40YHQstCw0L3QtSDQvdCwINC/0YDQvtC80LXQvdC10L3QuNGC0LUiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNDMgYnVpbHRpbi9mZXRjaC5jOjE2NiBidWlsdGluL3B1bGwuYzoxNDAKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNTggYnVpbHRpbi9mZXRjaC5jOjE4MSBidWlsdGluL3B1bGwuYzoxNDEKIG1zZ2lkICJvbi1kZW1hbmQiCiBtc2dzdHIgItCf0KDQmCDQndCj0JbQlNCQIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTQ0CisjOiBidWlsdGluL2ZldGNoLmM6MTU5CiBtc2dpZCAiY29udHJvbCByZWN1cnNpdmUgZmV0Y2hpbmcgb2Ygc3VibW9kdWxlcyIKIG1zZ3N0ciAi0YPQv9GA0LDQstC70LXQvdC40LUg0L3QsCDRgNC10LrRg9GA0YHQuNCy0L3QvtGC0L4g0LTQvtGB0YLQsNCy0Y/QvdC1INC90LAg0L/QvtC00LzQvtC00YPQu9C40YLQtSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE0OCBidWlsdGluL3B1bGwuYzoyMjQKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNjMgYnVpbHRpbi9wdWxsLmM6MjI1CiBtc2dpZCAia2VlcCBkb3dubG9hZGVkIHBhY2siCiBtc2dzdHIgItC30LDQv9Cw0LfQstCw0L3QtSDQvdCwINC40LfRgtC10LPQu9C10L3QuNGC0LUg0L/QsNC60LXRgtC4INGBINC+0LHQtdC60YLQuCIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE1MAorIzogYnVpbHRpbi9mZXRjaC5jOjE2NQogbXNnaWQgImFsbG93IHVwZGF0aW5nIG9mIEhFQUQgcmVmIgogbXNnc3RyICLQv9C+0LfQstC+0LvRj9Cy0LDQvdC1INC90LAg0L7QsdC90L7QstGP0LLQsNC90LXRgtC+INC90LAg0YPQutCw0LfQsNGC0LXQu9GPIOKAnkhFQUTigJwiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNTMgYnVpbHRpbi9mZXRjaC5jOjE1OSBidWlsdGluL3B1bGwuYzoyMjcKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNjggYnVpbHRpbi9mZXRjaC5jOjE3NCBidWlsdGluL3B1bGwuYzoyMjgKIG1zZ2lkICJkZWVwZW4gaGlzdG9yeSBvZiBzaGFsbG93IGNsb25lIgogbXNnc3RyICLQt9Cw0LTRitC70LHQvtGH0LDQstCw0L3QtSDQvdCwINC40YHRgtC+0YDQuNGP0YLQsCDQvdCwINC/0LvQuNGC0LrQviDRhdGA0LDQvdC40LvQuNGJ0LUiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNTUKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNzAKIG1zZ2lkICJkZWVwZW4gaGlzdG9yeSBvZiBzaGFsbG93IHJlcG9zaXRvcnkgYmFzZWQgb24gdGltZSIKIG1zZ3N0ciAi0LfQsNC00YrQu9Cx0L7Rh9Cw0LLQsNC90LUg0L3QsCDQuNGB0YLQvtGA0LjRj9GC0LAg0L3QsCDQv9C70LjRgtC60L4g0YXRgNCw0L3QuNC70LjRidC1INC00L4g0L7Qv9GA0LXQtNC10LvQtdC90L4g0LLRgNC10LzQtSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE2MSBidWlsdGluL3B1bGwuYzoyMzAKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNzYgYnVpbHRpbi9wdWxsLmM6MjMxCiBtc2dpZCAiY29udmVydCB0byBhIGNvbXBsZXRlIHJlcG9zaXRvcnkiCiBtc2dzdHIgItC/0YDQtdCy0YDRitGJ0LDQvdC1INCyINC/0YrQu9C90L4g0YXRgNCw0L3QuNC70LjRidC1IgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTY0CisjOiBidWlsdGluL2ZldGNoLmM6MTc5CiBtc2dpZCAicHJlcGVuZCB0aGlzIHRvIHN1Ym1vZHVsZSBwYXRoIG91dHB1dCIKIG1zZ3N0ciAi0LTQvtCx0LDQstGP0L3QtSDQvdCwINGC0L7QstCwINC/0YDQtdC0INC/0YrRgtGPINC90LAg0L/QvtC00LzQvtC00YPQu9CwIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTY3CisjOiBidWlsdGluL2ZldGNoLmM6MTgyCiBtc2dpZCAiIgogImRlZmF1bHQgZm9yIHJlY3Vyc2l2ZSBmZXRjaGluZyBvZiBzdWJtb2R1bGVzIChsb3dlciBwcmlvcml0eSB0aGFuIGNvbmZpZyAiCiAiZmlsZXMpIgpAQCAtMTMxNjMsOTAgKzEzMjI1LDkwIEBACiAi0YHRgtCw0L3QtNCw0YDRgtC90L4g0YDQtdC60YPRgNGB0LjQstC90L4g0LjQt9GC0LXQs9C70Y/QvdC1INC90LAg0L/QvtC00LzQvtC00YPQu9C40YLQtSAo0YTQsNC50LvQvtCy0LXRgtC1INGBINC90LDRgdGC0YDQvtC50LrQuCDRgdCwINGBICIKICLQv9GA0LjQvtGA0LjRgtC10YIpIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTcxIGJ1aWx0aW4vcHVsbC5jOjIzMworIzogYnVpbHRpbi9mZXRjaC5jOjE4NiBidWlsdGluL3B1bGwuYzoyMzQKIG1zZ2lkICJhY2NlcHQgcmVmcyB0aGF0IHVwZGF0ZSAuZ2l0L3NoYWxsb3ciCiBtc2dzdHIgItC/0YDQuNC10LzQsNC90LUg0L3QsCDRg9C60LDQt9Cw0YLQtdC70LgsINC60L7QuNGC0L4g0L7QsdC90L7QstGP0LLQsNGCIOKAni5naXQvc2hhbGxvd+KAnCIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE3MiBidWlsdGluL3B1bGwuYzoyMzUKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxODcgYnVpbHRpbi9wdWxsLmM6MjM2CiBtc2dpZCAicmVmbWFwIgogbXNnc3RyICLQmtCQ0KDQotCQX9ChX9Cj0JrQkNCX0JDQotCV0JvQmCIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE3MyBidWlsdGluL3B1bGwuYzoyMzYKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxODggYnVpbHRpbi9wdWxsLmM6MjM3CiBtc2dpZCAic3BlY2lmeSBmZXRjaCByZWZtYXAiCiBtc2dzdHIgItGD0LrQsNC30LLQsNC90LUg0L3QsCDQmtCQ0KDQotCQ0YLQsF/QoV/Qo9Ca0JDQl9CQ0KLQldCb0Jgg0LfQsCDQtNC+0YHRgtCw0LLRj9C90LUiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxODAKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxOTUKIG1zZ2lkICJyZXBvcnQgdGhhdCB3ZSBoYXZlIG9ubHkgb2JqZWN0cyByZWFjaGFibGUgZnJvbSB0aGlzIG9iamVjdCIKIG1zZ3N0ciAi0LTQvtC60LvQsNC00LLQsNC90LUsINGH0LUg0LLRgdC40YfQutC4INC+0LHQtdC60YLQuCDQvNC+0LPQsNGCINGB0LAg0LTQvtGB0YLQuNC20LjQvNC4INC/0YDQuCDQt9Cw0L/QvtGH0LLQsNC90LUg0L7RgiDRgtC+0LfQuCIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE4MworIzogYnVpbHRpbi9mZXRjaC5jOjE5OAogbXNnaWQgInJ1biAnZ2MgLS1hdXRvJyBhZnRlciBmZXRjaGluZyIKIG1zZ3N0ciAi0LjQt9C/0YrQu9C90Y/QstCw0L3QtSDQvdCwIOKAnmdjIC0tYXV0b+KAnCDRgdC70LXQtCDQtNC+0YHRgtCw0LLRj9C90LUiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxODUgYnVpbHRpbi9wdWxsLmM6MjQ1CisjOiBidWlsdGluL2ZldGNoLmM6MjAwIGJ1aWx0aW4vcHVsbC5jOjI0NgogbXNnaWQgImNoZWNrIGZvciBmb3JjZWQtdXBkYXRlcyBvbiBhbGwgdXBkYXRlZCBicmFuY2hlcyIKIG1zZ3N0ciAi0L/RgNC+0LLQtdGA0LrQsCDQt9CwINC/0YDQuNC90YPQtNC40YLQtdC70L3QuCDQvtCx0L3QvtCy0Y/QstCw0L3QuNGPINC90LAg0LLRgdC40YfQutC4INC60LvQvtC90LgiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzo0OTEKKyM6IGJ1aWx0aW4vZmV0Y2guYzo1MTAKIG1zZ2lkICJDb3VsZG4ndCBmaW5kIHJlbW90ZSByZWYgSEVBRCIKIG1zZ3N0ciAi0KPQutCw0LfQsNGC0LXQu9GP0YIg4oCeSEVBROKAnCDQsiDQvtGC0LTQsNC70LXRh9C10L3QvtGC0L4g0YXRgNCw0L3QuNC70LjRidC1INC90LUg0LzQvtC20LUg0LTQsCDQsdGK0LTQtSDQvtGC0LrRgNC40YIiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzo2MzAKKyM6IGJ1aWx0aW4vZmV0Y2guYzo2NTAKICMsIGMtZm9ybWF0CiBtc2dpZCAiY29uZmlndXJhdGlvbiBmZXRjaC5vdXRwdXQgY29udGFpbnMgaW52YWxpZCB2YWx1ZSAlcyIKIG1zZ3N0ciAi0L3QsNGB0YLRgNC+0LnQutCw0YLQsCDigJ5mZXRjaC5vdXRwdXTigJwg0LUg0YEg0L3QtdC/0YDQsNCy0LjQu9C90LAg0YHRgtC+0LnQvdC+0YHRgiDigJ4lc+KAnCIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjcyOAorIzogYnVpbHRpbi9mZXRjaC5jOjc0OAogIywgYy1mb3JtYXQKIG1zZ2lkICJvYmplY3QgJXMgbm90IGZvdW5kIgogbXNnc3RyICLQvtCx0LXQutGC0YrRgiDigJ4lc+KAnCDQu9C40L/RgdCy0LAiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzo3MzIKKyM6IGJ1aWx0aW4vZmV0Y2guYzo3NTIKIG1zZ2lkICJbdXAgdG8gZGF0ZV0iCiBtc2dzdHIgIlvQsNC60YLRg9Cw0LvQuNC30LjRgNCw0L1dIgogCi0jOiBidWlsdGluL2ZldGNoLmM6NzQ1IGJ1aWx0aW4vZmV0Y2guYzo3NjEgYnVpbHRpbi9mZXRjaC5jOjgzMworIzogYnVpbHRpbi9mZXRjaC5jOjc2NSBidWlsdGluL2ZldGNoLmM6NzgxIGJ1aWx0aW4vZmV0Y2guYzo4NTMKIG1zZ2lkICJbcmVqZWN0ZWRdIgogbXNnc3RyICJb0L7RgtGF0LLRitGA0LvQtdC9XSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjc0NgorIzogYnVpbHRpbi9mZXRjaC5jOjc2NgogbXNnaWQgImNhbid0IGZldGNoIGluIGN1cnJlbnQgYnJhbmNoIgogbXNnc3RyICLQsiDRgtC10LrRg9GJ0LjRjyDQutC70L7QvSDQvdC1INC80L7QttC1INC00LAg0YHQtSDQtNC+0YHRgtCw0LLRjyIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjc1NgorIzogYnVpbHRpbi9mZXRjaC5jOjc3NgogbXNnaWQgIlt0YWcgdXBkYXRlXSIKIG1zZ3N0ciAiW9C+0LHQvdC+0LLRj9Cy0LDQvdC1INC90LAg0LXRgtC40LrQtdGC0LjRgtC1XSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjc1NyBidWlsdGluL2ZldGNoLmM6Nzk0IGJ1aWx0aW4vZmV0Y2guYzo4MTYKLSM6IGJ1aWx0aW4vZmV0Y2guYzo4MjgKKyM6IGJ1aWx0aW4vZmV0Y2guYzo3NzcgYnVpbHRpbi9mZXRjaC5jOjgxNCBidWlsdGluL2ZldGNoLmM6ODM2CisjOiBidWlsdGluL2ZldGNoLmM6ODQ4CiBtc2dpZCAidW5hYmxlIHRvIHVwZGF0ZSBsb2NhbCByZWYiCiBtc2dzdHIgItC70L7QutCw0LvQtdC9INGD0LrQsNC30LDRgtC10Lsg0L3QtSDQvNC+0LbQtSDQtNCwINCx0YrQtNC1INC+0LHQvdC+0LLQtdC9IgogCi0jOiBidWlsdGluL2ZldGNoLmM6NzYxCisjOiBidWlsdGluL2ZldGNoLmM6NzgxCiBtc2dpZCAid291bGQgY2xvYmJlciBleGlzdGluZyB0YWciCiBtc2dzdHIgItGB0YrRidC10YHRgtCy0YPQstCw0Ykg0LXRgtC40LrQtdGCINGJ0LUg0LHRitC00LUg0L/RgNC10LfQsNC/0LjRgdCw0L0iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzo3ODMKKyM6IGJ1aWx0aW4vZmV0Y2guYzo4MDMKIG1zZ2lkICJbbmV3IHRhZ10iCiBtc2dzdHIgIlvQvdC+0LIg0LXRgtC40LrQtdGCXSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjc4NgorIzogYnVpbHRpbi9mZXRjaC5jOjgwNgogbXNnaWQgIltuZXcgYnJhbmNoXSIKIG1zZ3N0ciAiW9C90L7QsiDQutC70L7QvV0iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzo3ODkKKyM6IGJ1aWx0aW4vZmV0Y2guYzo4MDkKIG1zZ2lkICJbbmV3IHJlZl0iCiBtc2dzdHIgIlvQvdC+0LIg0YPQutCw0LfQsNGC0LXQu10iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzo4MjgKKyM6IGJ1aWx0aW4vZmV0Y2guYzo4NDgKIG1zZ2lkICJmb3JjZWQgdXBkYXRlIgogbXNnc3RyICLQv9GA0LjQvdGD0LTQuNGC0LXQu9C90L4g0L7QsdC90L7QstGP0LLQsNC90LUiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzo4MzMKKyM6IGJ1aWx0aW4vZmV0Y2guYzo4NTMKIG1zZ2lkICJub24tZmFzdC1mb3J3YXJkIgogbXNnc3RyICLRgdGK0YnQuNC90YHQutC+INGB0LvQuNCy0LDQvdC1IgogCi0jOiBidWlsdGluL2ZldGNoLmM6ODU0CisjOiBidWlsdGluL2ZldGNoLmM6ODc0CiBtc2dpZCAiIgogIkZldGNoIG5vcm1hbGx5IGluZGljYXRlcyB3aGljaCBicmFuY2hlcyBoYWQgYSBmb3JjZWQgdXBkYXRlLFxuIgogImJ1dCB0aGF0IGNoZWNrIGhhcyBiZWVuIGRpc2FibGVkLiBUbyByZS1lbmFibGUsIHVzZSAnLS1zaG93LWZvcmNlZC11cGRhdGVzJ1xuIgpAQCAtMTMyNTcsNyArMTMzMTksNyBAQAogIlxuIgogIiAgICBnaXQgY29uZmlnIGZldGNoLnNob3dGb3JjZWRVcGRhdGVzIHRydWUiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzo4NTgKKyM6IGJ1aWx0aW4vZmV0Y2guYzo4NzgKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkl0IHRvb2sgJS4yZiBzZWNvbmRzIHRvIGNoZWNrIGZvcmNlZCB1cGRhdGVzLiBZb3UgY2FuIHVzZVxuIgpAQCAtMTMyNzEsMjQgKzEzMzMzLDI0IEBACiAiXG4iCiAiICAgIGdpdCBjb25maWcgZmV0Y2guc2hvd0ZvcmNlZFVwZGF0ZXMgZmFsc2VcbiIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjg4OAorIzogYnVpbHRpbi9mZXRjaC5jOjkwOAogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyBkaWQgbm90IHNlbmQgYWxsIG5lY2Vzc2FyeSBvYmplY3RzXG4iCiBtc2dzdHIgItGF0YDQsNC90LjQu9C40YnQtdGC0L4g4oCeJXPigJwg0L3QtSDQuNC30L/RgNCw0YLQuCDQstGB0LjRh9C60Lgg0L3QtdC+0LHRhdC+0LTQuNC80Lgg0L7QsdC10LrRgtC4XG4iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzo5MDkKKyM6IGJ1aWx0aW4vZmV0Y2guYzo5MjkKICMsIGMtZm9ybWF0CiBtc2dpZCAicmVqZWN0ICVzIGJlY2F1c2Ugc2hhbGxvdyByb290cyBhcmUgbm90IGFsbG93ZWQgdG8gYmUgdXBkYXRlZCIKIG1zZ3N0ciAiIgogItC+0YLRhdCy0YrRgNC70Y/QvdC1INC90LAg0LLRitGA0YXQsCDigJ4lc+KAnCwg0LfQsNGJ0L7RgtC+INC/0LvQuNGC0LrQuNGC0LUg0YXRgNCw0L3QuNC70LjRidCwINC90LUg0LzQvtCz0LDRgiDQtNCwINCx0YrQtNCw0YIgIgogItC+0LHQvdC+0LLRj9Cy0LDQvdC4IgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTAwMCBidWlsdGluL2ZldGNoLmM6MTEzMQorIzogYnVpbHRpbi9mZXRjaC5jOjEwMjAgYnVpbHRpbi9mZXRjaC5jOjExNTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiRnJvbSAlLipzXG4iCiBtc2dzdHIgItCe0YIgJS4qc1xuIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTAxMQorIzogYnVpbHRpbi9mZXRjaC5jOjEwMzEKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogInNvbWUgbG9jYWwgcmVmcyBjb3VsZCBub3QgYmUgdXBkYXRlZDsgdHJ5IHJ1bm5pbmdcbiIKQEAgLTEzMjk4LDU4ICsxMzM2MCw4MCBAQAogIuKAnmdpdCByZW1vdGUgcHJ1bmUgJXPigJwsINC30LAg0LTQsCDQv9GA0LXQvNCw0YXQvdC10YLQtSDQvtGB0YLQsNGA0LXQu9C40YLQtSDQutC70L7QvdC4LCDQutC+0LjRgtC+XG4iCiAi0L/RgNC10LTQuNC30LLQuNC60LLQsNGCINC60L7QvdGE0LvQuNC60YLQsCIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjExMDEKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxMTI3CiAjLCBjLWZvcm1hdAogbXNnaWQgIiAgICglcyB3aWxsIGJlY29tZSBkYW5nbGluZykiCiBtc2dzdHIgIiAgICjQvtCx0LXQutGC0YrRgiDigJ4lc+KAnCDRidC1INGB0LUg0L7QutCw0LbQtSDQuNC30LLRitC9INC60LvQvtC9KSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjExMDIKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxMTI4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiAgICglcyBoYXMgYmVjb21lIGRhbmdsaW5nKSIKIG1zZ3N0ciAiICAgKNC+0LHQtdC60YLRitGCIOKAniVz4oCcINCy0LXRh9C1INC1INC40LfQstGK0L0g0LrQu9C+0L0pIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTEzNAorIzogYnVpbHRpbi9mZXRjaC5jOjExNjAKIG1zZ2lkICJbZGVsZXRlZF0iCiBtc2dzdHIgIlvQuNC30YLRgNC40YJdIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTEzNSBidWlsdGluL3JlbW90ZS5jOjEwMzYKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxMTYxIGJ1aWx0aW4vcmVtb3RlLmM6MTAzNgogbXNnaWQgIihub25lKSIKIG1zZ3N0ciAiKNC90LjRidC+KSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjExNTgKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxMTg0CiAjLCBjLWZvcm1hdAogbXNnaWQgIlJlZnVzaW5nIHRvIGZldGNoIGludG8gY3VycmVudCBicmFuY2ggJXMgb2Ygbm9uLWJhcmUgcmVwb3NpdG9yeSIKIG1zZ3N0ciAi0J3QtSDQvNC+0LbQtSDQtNCwINC00L7RgdGC0LDQstC40YLQtSDQsiDRgtC10LrRg9GJ0LjRjyDQutC70L7QvSDigJ4lc+KAnCDQvdCwINGF0YDQsNC90LjQu9C40YnQtSwg0LrQvtC10YLQviDQvdC1INC1INCz0L7Qu9C+IgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTE3NworIzogYnVpbHRpbi9mZXRjaC5jOjEyMDMKICMsIGMtZm9ybWF0CiBtc2dpZCAiT3B0aW9uIFwiJXNcIiB2YWx1ZSBcIiVzXCIgaXMgbm90IHZhbGlkIGZvciAlcyIKIG1zZ3N0ciAi0KHRgtC+0LnQvdC+0YHRgtGC0LAg4oCeJTIkc+KAnCDQt9CwINC+0L/RhtC40Y/RgtCwIOKAniUxJHPigJwg0L3QtSDQtSDRgdGK0LLQvNC10YHRgtC40LzQsCDRgSDigJ4lMyRz4oCcIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTE4MAorIzogYnVpbHRpbi9mZXRjaC5jOjEyMDYKICMsIGMtZm9ybWF0CiBtc2dpZCAiT3B0aW9uIFwiJXNcIiBpcyBpZ25vcmVkIGZvciAlc1xuIgogbXNnc3RyICLQntC/0YbQuNGP0YLQsCDigJ4lc+KAnCDRgdC1INC/0YDQtdGB0LrQsNGH0LAg0L/RgNC4IOKAniVz4oCcXG4iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNDg0CisjOiBidWlsdGluL2ZldGNoLmM6MTQxNAorbXNnaWQgIm11bHRpcGxlIGJyYW5jaCBkZXRlY3RlZCwgaW5jb21wYXRpYmxlIHdpdGggLS1zZXQtdXBzdHJlYW0iCittc2dzdHIgIiIKKyLQt9Cw0YHQtdGH0LXQvdC4INGB0LAg0LzQvdC+0LbQtdGB0YLQstC+INC60LvQvtC90LgsINGC0L7QstCwINC1INC90LXRgdGK0LLQvNC10YHRgtC40LzQviDRgSDQvtC/0YbQuNGP0YLQsCDigJ4tLXNldC11cHN0cmVhbeKAnCIKKworIzogYnVpbHRpbi9mZXRjaC5jOjE0MjkKK21zZ2lkICJub3Qgc2V0dGluZyB1cHN0cmVhbSBmb3IgYSByZW1vdGUgcmVtb3RlLXRyYWNraW5nIGJyYW5jaCIKK21zZ3N0ciAi0L3QtSDQvNC+0LbQtSDQtNCwINGD0LrQsNC30LLQsNGC0LUg0LrQu9C+0L0g0LfQsCDRgdC70LXQtNC10L3QtSDQvdCwINC+0YLQtNCw0LvQtdGH0LXQvSDQtdGC0LjQutC10YIiCisKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNDMxCittc2dpZCAibm90IHNldHRpbmcgdXBzdHJlYW0gZm9yIGEgcmVtb3RlIHRhZyIKK21zZ3N0ciAi0L3QtSDQvNC+0LbQtSDQtNCwINGD0LrQsNC30LLQsNGC0LUg0LrQu9C+0L0g0LfQsCDRgdC70LXQtNC10L3QtSDQvdCwINC+0YLQtNCw0LvQtdGH0LXQvSDQtdGC0LjQutC10YIiCisKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNDMzCittc2dpZCAidW5rbm93biBicmFuY2ggdHlwZSIKK21zZ3N0ciAi0L3QtdC/0L7Qt9C90LDRgiDQstC40LQg0LrQu9C+0L0iCisKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNDM1Cittc2dpZCAiIgorIm5vIHNvdXJjZSBicmFuY2ggZm91bmQuXG4iCisieW91IG5lZWQgdG8gc3BlY2lmeSBleGFjdGx5IG9uZSBicmFuY2ggd2l0aCB0aGUgLS1zZXQtdXBzdHJlYW0gb3B0aW9uLiIKK21zZ3N0ciAiIgorItC90LUg0LUg0L7RgtC60YDQuNGCINC60LvQvtC9INC30LAg0YHQu9C10LTQtdC90LUuXG4iCisi0KLRgNGP0LHQstCwINC40LfRgNC40YfQvdC+INC00LAg0LfQsNC00LDQtNC10YLQtSDQtdC00LjQvSDQutC70L7QvSDRgSDQvtC/0YbQuNGP0YLQsCDigJ4tLXNldC11cHN0cmVhbSBvcHRpb27igJwuIgorCisjOiBidWlsdGluL2ZldGNoLmM6MTU2MSBidWlsdGluL2ZldGNoLmM6MTYyMwogIywgYy1mb3JtYXQKIG1zZ2lkICJGZXRjaGluZyAlc1xuIgogbXNnc3RyICLQlNC+0YHRgtCw0LLRj9C90LUg0L3QsCDigJ4lc+KAnFxuIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTQ4NiBidWlsdGluL3JlbW90ZS5jOjEwMAorIzogYnVpbHRpbi9mZXRjaC5jOjE1NzEgYnVpbHRpbi9mZXRjaC5jOjE2MjUgYnVpbHRpbi9yZW1vdGUuYzoxMDAKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ291bGQgbm90IGZldGNoICVzIgogbXNnc3RyICLigJ4lc+KAnCDQvdC1INC80L7QttC1INC00LAg0YHQtSDQtNC+0YHRgtCw0LLQuCIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE1MzIKLW1zZ2lkICIiCi0iLS1maWx0ZXIgY2FuIG9ubHkgYmUgdXNlZCB3aXRoIHRoZSByZW1vdGUgY29uZmlndXJlZCBpbiBleHRlbnNpb25zLiIKLSJwYXJ0aWFsQ2xvbmUiCi1tc2dzdHIgIiIKLSLQvtC/0YbQuNGP0YLQsCDigJ4tLWZpbHRlcuKAnCDQvNC+0LbQtSDQtNCwINGB0LUg0L/QvtC70LfQstCwINGB0LDQvNC+INGBINC+0YLQtNCw0LvQtdGH0LXQvdC+0YLQviDRhdGA0LDQvdC40LvQuNGJ0LUg0YPQutCw0LfQsNC90L4g0LIgIgotItC90LDRgdGC0YDQvtC50LrQsNGC0LAg4oCeZXh0ZW5zaW9ucy5wYXJ0aWFsQ2xvbmXigJwiCisjOiBidWlsdGluL2ZldGNoLmM6MTU4MworIywgYy1mb3JtYXQKK21zZ2lkICJjb3VsZCBub3QgZmV0Y2ggJyVzJyAoZXhpdCBjb2RlOiAlZClcbiIKK21zZ3N0ciAi4oCeJXPigJwg0L3QtSDQvNC+0LbQtSDQtNCwINGB0LUg0LTQvtGB0YLQsNCy0LggKNC40LfRhdC+0LTQvdC40Y/RgiDQutC+0LQg0LU6ICVkKVxuIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTU1NgorIzogYnVpbHRpbi9mZXRjaC5jOjE2ODUKIG1zZ2lkICIiCiAiTm8gcmVtb3RlIHJlcG9zaXRvcnkgc3BlY2lmaWVkLiAgUGxlYXNlLCBzcGVjaWZ5IGVpdGhlciBhIFVSTCBvciBhXG4iCiAicmVtb3RlIG5hbWUgZnJvbSB3aGljaCBuZXcgcmV2aXNpb25zIHNob3VsZCBiZSBmZXRjaGVkLiIKQEAgLTEzMzU3LDQ1ICsxMzQ0MSw0NSBAQAogItCd0LUg0YHRgtC1INGD0LrQsNC30LDQu9C4INC+0YLQtNCw0LvQtdGH0LXQvdC+INGF0YDQsNC90LjQu9C40YnQtS4gINCX0LDQtNCw0LnRgtC1INC40LvQuCDQsNC00YDQtdGBLCDQuNC70Lgg0LjQvNC1XG4iCiAi0L3QsCDQvtGC0LTQsNC70LXRh9C10L3QviDRhdGA0LDQvdC40LvQuNGJ0LUsINC+0YLQutGK0LTQtdGC0L4g0LTQsCDRgdC1INC00L7RgdGC0LDQstGP0YIg0L3QvtCy0LjRgtC1INCy0LXRgNGB0LjQuC4iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNTkzCisjOiBidWlsdGluL2ZldGNoLmM6MTcyMgogbXNnaWQgIllvdSBuZWVkIHRvIHNwZWNpZnkgYSB0YWcgbmFtZS4iCiBtc2dzdHIgItCi0YDRj9Cx0LLQsCDQtNCwINGD0LrQsNC20LXRgtC1INC40LzQtSDQvdCwINC10YLQuNC60LXRgi4iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNjQ0CisjOiBidWlsdGluL2ZldGNoLmM6MTc3NAogbXNnaWQgIk5lZ2F0aXZlIGRlcHRoIGluIC0tZGVlcGVuIGlzIG5vdCBzdXBwb3J0ZWQiCiBtc2dzdHIgItCe0YLRgNC40YbQsNGC0LXQu9C90LAg0LTRitC70LHQvtGH0LjQvdCwINC60LDRgtC+INCw0YDQs9GD0LzQtdC90YIg0L3QsCDigJ4tLWRlZXBlbuKAnCDQvdC1INGB0LUg0L/QvtC00LTRitGA0LbQsCIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE2NDYKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNzc2CiBtc2dpZCAiLS1kZWVwZW4gYW5kIC0tZGVwdGggYXJlIG11dHVhbGx5IGV4Y2x1c2l2ZSIKLW1zZ3N0ciAi0J7Qv9GG0LjQuNGC0LUg4oCeLS1kZWVwZW7igJwg0Lgg4oCeLS1kZXB0aOKAnCDRgdCwINC90LXRgdGK0LLQvNC10YHRgtC40LzQuCDQtdC00L3QsCDRgSDQtNGA0YPQs9CwIgorbXNnc3RyICLQvtC/0YbQuNC40YLQtSDigJ4tLWRlZXBlbuKAnCDQuCDigJ4tLWRlcHRo4oCcINGB0LAg0L3QtdGB0YrQstC80LXRgdGC0LjQvNC4IgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTY1MQorIzogYnVpbHRpbi9mZXRjaC5jOjE3ODEKIG1zZ2lkICItLWRlcHRoIGFuZCAtLXVuc2hhbGxvdyBjYW5ub3QgYmUgdXNlZCB0b2dldGhlciIKIG1zZ3N0ciAi0L7Qv9GG0LjQuNGC0LUg4oCeLS1kZXB0aOKAnCDQuCDigJ4tLXVuc2hhbGxvd+KAnCDRgdCwINC90LXRgdGK0LLQvNC10YHRgtC40LzQuCIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE2NTMKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNzgzCiBtc2dpZCAiLS11bnNoYWxsb3cgb24gYSBjb21wbGV0ZSByZXBvc2l0b3J5IGRvZXMgbm90IG1ha2Ugc2Vuc2UiCiBtc2dzdHIgItC90LUg0LzQvtC20LXRgtC1INC00LAg0LjQt9C/0L7Qu9C30LLQsNGC0LUg0L7Qv9GG0LjRj9GC0LAg4oCeLS11bnNoYWxsb3figJwg0LLRitGA0YXRgyDQv9GK0LvQvdC+INGF0YDQsNC90LjQu9C40YnQtSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE2NjkKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNzk5CiBtc2dpZCAiZmV0Y2ggLS1hbGwgZG9lcyBub3QgdGFrZSBhIHJlcG9zaXRvcnkgYXJndW1lbnQiCiBtc2dzdHIgItC60YrQvCDigJ5naXQgZmV0Y2ggLS1hbGzigJwg0L3QtSDQvNC+0LbQtdGC0LUg0LTQsCDQtNC+0LHQsNCy0LjRgtC1INCw0YDQs9GD0LzQtdC90YIg4oCUINGF0YDQsNC90LjQu9C40YnQtSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE2NzEKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxODAxCiBtc2dpZCAiZmV0Y2ggLS1hbGwgZG9lcyBub3QgbWFrZSBzZW5zZSB3aXRoIHJlZnNwZWNzIgogbXNnc3RyICIiCiAi0LrRitC8IOKAnmdpdCBmZXRjaCAtLWFsbOKAnCDQvdC1INC80L7QttC10YLQtSDQtNCwINC00L7QsdCw0LLQuNGC0LUg0LDRgNCz0YPQvNC10L3RgiDigJQg0YPQutCw0LfQsNGC0LXQuyDQvdCwINCy0LXRgNGB0LjRjyIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE2ODAKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxODEwCiAjLCBjLWZvcm1hdAogbXNnaWQgIk5vIHN1Y2ggcmVtb3RlIG9yIHJlbW90ZSBncm91cDogJXMiCiBtc2dzdHIgItCd0Y/QvNCwINC90LjRgtC+INC+0YLQtNCw0LvQtdGH0LXQvdC+INGF0YDQsNC90LjQu9C40YnQtSwg0L3QuNGC0L4g0LPRgNGD0L/QsCDQvtGCINGF0YDQsNC90LjQu9C40YnQsCDQvdCwINC40LzQtSDigJ4lc+KAnCIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE2ODcKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxODE3CiBtc2dpZCAiRmV0Y2hpbmcgYSBncm91cCBhbmQgc3BlY2lmeWluZyByZWZzcGVjcyBkb2VzIG5vdCBtYWtlIHNlbnNlIgogbXNnc3RyICLQo9C60LDQt9Cy0LDQvdC10YLQviDQvdCwINCz0YDRg9C/0LAg0Lgg0YPQutCw0LfQstCw0L3QtdGC0L4g0L3QsCDQstC10YDRgdC40Y8g0YHQsCDQvdC10YHRitCy0LzQtdGB0YLQuNC80LgiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNzAzCisjOiBidWlsdGluL2ZldGNoLmM6MTgzNQogbXNnaWQgIiIKICItLWZpbHRlciBjYW4gb25seSBiZSB1c2VkIHdpdGggdGhlIHJlbW90ZSBjb25maWd1cmVkIGluIGV4dGVuc2lvbnMuIgogInBhcnRpYWxjbG9uZSIKQEAgLTEzNzM1LDcgKzEzODE5LDcgQEAKIG1zZ2lkICJpbnZhbGlkIHBhcmFtZXRlcjogZXhwZWN0ZWQgc2hhMSwgZ290ICclcyciCiBtc2dzdHIgItC90LXQv9GA0LDQstC40LvQtdC9INC/0LDRgNCw0LzQtdGC0YrRgDog0L7Rh9Cw0LrQstCwINGB0LUgU0hBMSwg0LAg0LHQtSDQv9C+0LvRg9GH0LXQvdC+OiDigJ4lc+KAnCIKIAotIzogYnVpbHRpbi9nYy5jOjM0CisjOiBidWlsdGluL2djLmM6MzUKIG1zZ2lkICJnaXQgZ2MgWzxvcHRpb25zPl0iCiBtc2dzdHIgImdpdCBnYyBb0J7Qn9Cm0JjQr+KApl0iCiAKQEAgLTEzNzQ5LDE3ICsxMzgzMywxNyBAQAogbXNnaWQgImZhaWxlZCB0byBwYXJzZSAnJXMnIHZhbHVlICclcyciCiBtc2dzdHIgItGB0YLQvtC50L3QvtGB0YLRgtCwINC90LAg4oCeJXPigJwg4oCUIOKAniVz4oCcINC90LUg0LzQvtC20LUg0LTQsCDRgdC1INCw0L3QsNC70LjQt9C40YDQsCIKIAotIzogYnVpbHRpbi9nYy5jOjQ3NiBidWlsdGluL2luaXQtZGIuYzo1NQorIzogYnVpbHRpbi9nYy5jOjQ3NSBidWlsdGluL2luaXQtZGIuYzo1NQogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3Qgc3RhdCAnJXMnIgogbXNnc3RyICLQvdC1INC80L7QttC1INC00LAg0YHQtSDQv9C+0LvRg9GH0Lgg0LjQvdGE0L7RgNC80LDRhtC40Y8g0YfRgNC10Lcg4oCec3RhdOKAnCDQt9CwINC00LjRgNC10LrRgtC+0YDQuNGP0YLQsCDigJ4lc+KAnCIKIAotIzogYnVpbHRpbi9nYy5jOjQ4NSBidWlsdGluL25vdGVzLmM6MjQwIGJ1aWx0aW4vdGFnLmM6NTI5CisjOiBidWlsdGluL2djLmM6NDg0IGJ1aWx0aW4vbm90ZXMuYzoyNDAgYnVpbHRpbi90YWcuYzo1MjkKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IHJlYWQgJyVzJyIKIG1zZ3N0ciAi0YTQsNC50LvRitGCIOKAniVz4oCcINC90LUg0LzQvtC20LUg0LTQsCDQsdGK0LTQtSDQv9GA0L7Rh9C10YLQtdC9IgogCi0jOiBidWlsdGluL2djLmM6NDkyCisjOiBidWlsdGluL2djLmM6NDkxCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgbGFzdCBnYyBydW4gcmVwb3J0ZWQgdGhlIGZvbGxvd2luZy4gUGxlYXNlIGNvcnJlY3QgdGhlIHJvb3QgY2F1c2VcbiIKQEAgLTEzNzc2LDU4ICsxMzg2MCw1OCBAQAogIlxuIgogIiVzIgogCi0jOiBidWlsdGluL2djLmM6NTQwCisjOiBidWlsdGluL2djLmM6NTM5CiBtc2dpZCAicHJ1bmUgdW5yZWZlcmVuY2VkIG9iamVjdHMiCiBtc2dzdHIgItC+0LrQsNGB0YLRgNGP0L3QtSDQvdCwINC+0LHQtdC60YLQuNGC0LUsINC60YrQvCDQutC+0LjRgtC+INC90LjRidC+INC90LUg0YHQvtGH0LgiCiAKLSM6IGJ1aWx0aW4vZ2MuYzo1NDIKKyM6IGJ1aWx0aW4vZ2MuYzo1NDEKIG1zZ2lkICJiZSBtb3JlIHRob3JvdWdoIChpbmNyZWFzZWQgcnVudGltZSkiCiBtc2dzdHIgItC40LfRh9C10YDQv9Cw0YLQtdC70L3QviDRgtGK0YDRgdC10L3QtSDQvdCwINCx0L7QutC70YPQutCwICjQt9CwINGB0LzQtdGC0LrQsCDQvdCwINC/0L7QstC10YfQtSDQstGA0LXQvNC1INGA0LDQsdC+0YLQsCkiCiAKLSM6IGJ1aWx0aW4vZ2MuYzo1NDMKKyM6IGJ1aWx0aW4vZ2MuYzo1NDIKIG1zZ2lkICJlbmFibGUgYXV0by1nYyBtb2RlIgogbXNnc3RyICLQstC60LvRjtGH0LLQsNC90LUg0L3QsCDQsNCy0YLQvtC80LDRgtC40YfQvdC+0YLQviDRgdGK0LHQuNGA0LDQvdC1INC90LAg0LHQvtC60LvRg9C60LAgKGF1dG8tZ2MpIgogCi0jOiBidWlsdGluL2djLmM6NTQ2CisjOiBidWlsdGluL2djLmM6NTQ1CiBtc2dpZCAiZm9yY2UgcnVubmluZyBnYyBldmVuIGlmIHRoZXJlIG1heSBiZSBhbm90aGVyIGdjIHJ1bm5pbmciCiBtc2dzdHIgIiIKICLQuNC30YDQuNGH0L3QviDRgdGC0LDRgNGC0LjRgNCw0L3QtSDQvdCwINGB0YrQsdC40YDQsNC90LXRgtC+INC90LAg0LHQvtC60LvRg9C60LAsINC00L7RgNC4INC4INCw0LrQviDQstC10YfQtSDRgNCw0LHQvtGC0Lgg0LTRgNGD0LPQviAiCiAi0YHRitCx0LjRgNCw0L3QtSIKIAotIzogYnVpbHRpbi9nYy5jOjU0OQorIzogYnVpbHRpbi9nYy5jOjU0OAogbXNnaWQgInJlcGFjayBhbGwgb3RoZXIgcGFja3MgZXhjZXB0IHRoZSBsYXJnZXN0IHBhY2siCiBtc2dzdHIgItC/0YDQtdC/0LDQutC10YLQuNGA0LDQvdC1INC90LAg0LLRgdC40YfQutC+INCx0LXQtyDQvdCw0Lkt0LPQvtC70LXQvNC40Y8g0L/QsNC60LXRgiIKIAotIzogYnVpbHRpbi9nYy5jOjU2NgorIzogYnVpbHRpbi9nYy5jOjU2NQogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gcGFyc2UgZ2MubG9nZXhwaXJ5IHZhbHVlICVzIgogbXNnc3RyICLQvdC10YDQsNC30L/QvtC30L3QsNGC0LAg0YHRgtC+0LnQvdC+0YHRgiDQvdCwIOKAnmdjLmxvZ2V4cGlyeeKAnCAlcyIKIAotIzogYnVpbHRpbi9nYy5jOjU3NworIzogYnVpbHRpbi9nYy5jOjU3NgogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gcGFyc2UgcHJ1bmUgZXhwaXJ5IHZhbHVlICVzIgogbXNnc3RyICLQvdC10YDQsNC30L/QvtC30L3QsNGC0LAg0YHRgtC+0LnQvdC+0YHRgiDQvdCwINC/0LXRgNC40L7QtNCwINC30LAg0L7QutCw0YHRgtGA0Y/QvdC1OiAlcyIKIAotIzogYnVpbHRpbi9nYy5jOjU5NworIzogYnVpbHRpbi9nYy5jOjU5NgogIywgYy1mb3JtYXQKIG1zZ2lkICJBdXRvIHBhY2tpbmcgdGhlIHJlcG9zaXRvcnkgaW4gYmFja2dyb3VuZCBmb3Igb3B0aW11bSBwZXJmb3JtYW5jZS5cbiIKIG1zZ3N0ciAiIgogItCQ0LLRgtC+0LzQsNGC0LjRh9C90L4g0L/QsNC60LXRgtC40YDQsNC90LUg0L3QsCDQt9Cw0LTQtdC9INGE0L7QvSDQvdCwINGF0YDQsNC90LjQu9C40YnQtdGC0L4g0LfQsCDQv9C+LdC00L7QsdGA0LAgIgogItC/0YDQvtC40LfQstC+0LTQuNGC0LXQu9C90L7RgdGCLlxuIgogCi0jOiBidWlsdGluL2djLmM6NTk5CisjOiBidWlsdGluL2djLmM6NTk4CiAjLCBjLWZvcm1hdAogbXNnaWQgIkF1dG8gcGFja2luZyB0aGUgcmVwb3NpdG9yeSBmb3Igb3B0aW11bSBwZXJmb3JtYW5jZS5cbiIKIG1zZ3N0ciAi0JDQstGC0L7QvNCw0YLQuNGH0L3QviDQv9Cw0LrQtdGC0LjRgNCw0L3QtSDQvdCwINGF0YDQsNC90LjQu9C40YnQtdGC0L4g0LfQsCDQv9C+LdC00L7QsdGA0LAg0L/RgNC+0LjQt9Cy0L7QtNC40YLQtdC70L3QvtGB0YIuXG4iCiAKLSM6IGJ1aWx0aW4vZ2MuYzo2MDAKKyM6IGJ1aWx0aW4vZ2MuYzo1OTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiU2VlIFwiZ2l0IGhlbHAgZ2NcIiBmb3IgbWFudWFsIGhvdXNla2VlcGluZy5cbiIKIG1zZ3N0ciAiIgogItCf0L7Qs9C70LXQtNC90LXRgtC1INGA0YrQutC+0LLQvtC00YHRgtCy0L7RgtC+INC30LAg0L/QvtCy0LXRh9C1INC40L3RhNC+0YDQvNCw0YbQuNGPINC60LDQuiDQtNCwINC40LfQv9GK0LvQvdC40YLQtSDigJ5naXQgaGVscCAiCiAiZ2PigJwuXG4iCiAKLSM6IGJ1aWx0aW4vZ2MuYzo2NDAKKyM6IGJ1aWx0aW4vZ2MuYzo2MzkKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogImdjIGlzIGFscmVhZHkgcnVubmluZyBvbiBtYWNoaW5lICclcycgcGlkICU8UFJJdU1BWD4gKHVzZSAtLWZvcmNlIGlmIG5vdCkiCkBAIC0xMzgzNiw3ICsxMzkyMCw3IEBACiAi0L/RgNC+0YbQtdGB0LA6ICU8UFJJdU1BWD4gKNCw0LrQviDRgdGC0LUg0YHQuNCz0YPRgNC90LgsINGH0LUg0YLQvtCy0LAg0L3QtSDQtSDQstGP0YDQvdC+LCDRgtC+0LLQsCDQuNC30L/QvtC70LfQstCw0LnRgtC1XG4iCiAi0L7Qv9GG0LjRj9GC0LAg4oCeLS1mb3JjZeKAnCkiCiAKLSM6IGJ1aWx0aW4vZ2MuYzo2OTUKKyM6IGJ1aWx0aW4vZ2MuYzo2OTQKIG1zZ2lkICIiCiAiVGhlcmUgYXJlIHRvbyBtYW55IHVucmVhY2hhYmxlIGxvb3NlIG9iamVjdHM7IHJ1biAnZ2l0IHBydW5lJyB0byByZW1vdmUgdGhlbS4iCiBtc2dzdHIgIiIKQEAgLTEzODYyLDI3MSArMTM5NDYsMjcxIEBACiAjLiBncmVwLnRocmVhZHMKICMuCiAjOiBidWlsdGluL2dyZXAuYzoyODcgYnVpbHRpbi9pbmRleC1wYWNrLmM6MTUzNCBidWlsdGluL2luZGV4LXBhY2suYzoxNzI3Ci0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI3MjgKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjcwOAogIywgYy1mb3JtYXQKIG1zZ2lkICJubyB0aHJlYWRzIHN1cHBvcnQsIGlnbm9yaW5nICVzIgogbXNnc3RyICLQu9C40L/RgdCy0LAg0L/QvtC00LTRgNGK0LbQutCwINC30LAg0L3QuNGI0LrQuC4gIOKAniVz4oCcINGJ0LUg0YHQtSDQv9GA0LXQvdC10LHRgNC10LPQvdC1IgogCi0jOiBidWlsdGluL2dyZXAuYzo0NjcgYnVpbHRpbi9ncmVwLmM6NTkxIGJ1aWx0aW4vZ3JlcC5jOjYzMworIzogYnVpbHRpbi9ncmVwLmM6NDY3IGJ1aWx0aW4vZ3JlcC5jOjU5MiBidWlsdGluL2dyZXAuYzo2MzUKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHJlYWQgdHJlZSAoJXMpIgogbXNnc3RyICLQtNGK0YDQstC+0YLQviDQvdC1INC80L7QttC1INC00LAg0LHRitC00LUg0L/RgNC+0YfQtdGC0LXQvdC+ICglcykiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjY0OAorIzogYnVpbHRpbi9ncmVwLmM6NjUwCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBncmVwIGZyb20gb2JqZWN0IG9mIHR5cGUgJXMiCiBtc2dzdHIgItC90LUg0LzQvtC20LUg0LTQsCDRgdC1INC40LfQv9GK0LvQvdC4IOKAnmdyZXDigJwg0L7RgiDQvtCx0LXQutGCINC+0YIg0LLQuNC00LAgJXMiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjcxNAorIzogYnVpbHRpbi9ncmVwLmM6NzE2CiAjLCBjLWZvcm1hdAogbXNnaWQgInN3aXRjaCBgJWMnIGV4cGVjdHMgYSBudW1lcmljYWwgdmFsdWUiCiBtc2dzdHIgItC+0L/RhtC40Y/RgtCwIOKAniVj4oCcINC+0YfQsNC60LLQsCDRh9C40YHQu9C+INC30LAg0LDRgNCz0YPQvNC10L3RgiIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODEzCisjOiBidWlsdGluL2dyZXAuYzo4MTUKIG1zZ2lkICJzZWFyY2ggaW4gaW5kZXggaW5zdGVhZCBvZiBpbiB0aGUgd29yayB0cmVlIgogbXNnc3RyICLRgtGK0YDRgdC10L3QtSDQsiDQuNC90LTQtdC60YHQsCwg0LAg0L3QtSDQsiDRgNCw0LHQvtGC0L3QvtGC0L4g0LTRitGA0LLQviIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODE1CisjOiBidWlsdGluL2dyZXAuYzo4MTcKIG1zZ2lkICJmaW5kIGluIGNvbnRlbnRzIG5vdCBtYW5hZ2VkIGJ5IGdpdCIKIG1zZ3N0ciAi0YLRitGA0YHQtdC90LUg0Lgg0LLRitCyINGE0LDQudC70L7QstC10YLQtSwg0LrQvtC40YLQviDQvdC1INGB0LAg0L/QvtC0INGD0L/RgNCw0LLQu9C10L3QuNC10YLQviDQvdCwIGdpdCIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODE3CisjOiBidWlsdGluL2dyZXAuYzo4MTkKIG1zZ2lkICJzZWFyY2ggaW4gYm90aCB0cmFja2VkIGFuZCB1bnRyYWNrZWQgZmlsZXMiCiBtc2dzdHIgItGC0YrRgNGB0LXQvdC1INC4INCyINGB0LvQtdC00LXQvdC40YLQtSwg0Lgg0LIg0L3QtdGB0LvQtdC00LXQvdC40YLQtSDRhNCw0LnQu9C+0LLQtSIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODE5CisjOiBidWlsdGluL2dyZXAuYzo4MjEKIG1zZ2lkICJpZ25vcmUgZmlsZXMgc3BlY2lmaWVkIHZpYSAnLmdpdGlnbm9yZSciCiBtc2dzdHIgItC40LPQvdC+0YDQuNGA0LDQvdC1INC90LAg0YTQsNC50LvQvtCy0LXRgtC1INGD0LrQsNC30LDQvdC4INCyIOKAni5naXRpZ25vcmXigJwiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjgyMQorIzogYnVpbHRpbi9ncmVwLmM6ODIzCiBtc2dpZCAicmVjdXJzaXZlbHkgc2VhcmNoIGluIGVhY2ggc3VibW9kdWxlIgogbXNnc3RyICLRgNC10LrRg9GA0YHQuNCy0L3QviDRgtGK0YDRgdC10L3QtSDQstGK0LIg0LLRgdC40YfQutC4INC/0L7QtNC80L7QtNGD0LvQuCIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODI0CisjOiBidWlsdGluL2dyZXAuYzo4MjYKIG1zZ2lkICJzaG93IG5vbi1tYXRjaGluZyBsaW5lcyIKIG1zZ3N0ciAi0LjQt9Cy0LXQttC00LDQvdC1INC90LAg0YDQtdC00L7QstC10YLQtSwg0LrQvtC40YLQviDQvdC1INGB0YrQstC/0LDQtNCw0YIiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjgyNgorIzogYnVpbHRpbi9ncmVwLmM6ODI4CiBtc2dpZCAiY2FzZSBpbnNlbnNpdGl2ZSBtYXRjaGluZyIKIG1zZ3N0ciAi0LHQtdC3INC30L3QsNGH0LXQvdC40LUg0L3QsCDRgNC10LPQuNGB0YLRitGA0LAg0L3QsCDQsdGD0LrQstC40YLQtSAo0LPQu9Cw0LLQvdC4L9C80LDQu9C60LgpIgogCi0jOiBidWlsdGluL2dyZXAuYzo4MjgKKyM6IGJ1aWx0aW4vZ3JlcC5jOjgzMAogbXNnaWQgIm1hdGNoIHBhdHRlcm5zIG9ubHkgYXQgd29yZCBib3VuZGFyaWVzIgogbXNnc3RyICLQvdCw0L/QsNGB0LLQsNC90LUg0L3QsCDRiNCw0LHQu9C+0L3QuNGC0LUg0YHQsNC80L4g0L/QviDQs9GA0LDQvdC40YbQuNGC0LUg0L3QsCDQtNGD0LzQuNGC0LUiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjgzMAorIzogYnVpbHRpbi9ncmVwLmM6ODMyCiBtc2dpZCAicHJvY2VzcyBiaW5hcnkgZmlsZXMgYXMgdGV4dCIKIG1zZ3N0ciAi0L7QsdGA0LDQsdC+0YLQstCw0L3QtSDQvdCwINC00LLQvtC40YfQvdC40YLQtSDRhNCw0LnQu9C+0LLQtSDQutCw0YLQviDRgtC10LrRgdGC0L7QstC4IgogCi0jOiBidWlsdGluL2dyZXAuYzo4MzIKKyM6IGJ1aWx0aW4vZ3JlcC5jOjgzNAogbXNnaWQgImRvbid0IG1hdGNoIHBhdHRlcm5zIGluIGJpbmFyeSBmaWxlcyIKIG1zZ3N0ciAi0L/RgNC10YHQutCw0YfQsNC90LUg0L3QsCDQtNCy0L7QuNGH0L3QuNGC0LUg0YTQsNC50LvQvtCy0LUiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjgzNQorIzogYnVpbHRpbi9ncmVwLmM6ODM3CiBtc2dpZCAicHJvY2VzcyBiaW5hcnkgZmlsZXMgd2l0aCB0ZXh0Y29udiBmaWx0ZXJzIgogbXNnc3RyICIiCiAi0L7QsdGA0LDQsdC+0YLQstCw0L3QtSDQvdCwINC00LLQvtC40YfQvdC40YLQtSDRhNCw0LnQu9C+0LLQtSDRh9GA0LXQtyDRhNC40LvRgtGA0Lgg0LfQsCDQv9GA0LXQvtCx0YDQsNC30YPQstCw0L3QtSDQutGK0Lwg0YLQtdC60YHRgiIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODM3CisjOiBidWlsdGluL2dyZXAuYzo4MzkKIG1zZ2lkICJzZWFyY2ggaW4gc3ViZGlyZWN0b3JpZXMgKGRlZmF1bHQpIgogbXNnc3RyICLRgtGK0YDRgdC10L3QtSDQsiDQv9C+0LTQtNC40YDQtdC60YLQvtGA0LjQuNGC0LUgKNGB0YLQsNC90LTQsNGA0YLQvdC+KSIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODM5CisjOiBidWlsdGluL2dyZXAuYzo4NDEKIG1zZ2lkICJkZXNjZW5kIGF0IG1vc3QgPGRlcHRoPiBsZXZlbHMiCiBtc2dzdHIgItC90LDQstC70LjQt9Cw0L3QtSDQvNCw0LrRgdC40LzQsNC70L3QviDQvdCwINGC0LDQt9C4INCU0KrQm9CR0J7Qp9CY0J3QkCDQsiDQtNGK0YDQstC+0YLQviIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODQzCisjOiBidWlsdGluL2dyZXAuYzo4NDUKIG1zZ2lkICJ1c2UgZXh0ZW5kZWQgUE9TSVggcmVndWxhciBleHByZXNzaW9ucyIKIG1zZ3N0ciAi0YDQsNC30YjQuNGA0LXQvdC4INGA0LXQs9GD0LvRj9GA0L3QuCDQuNC30YDQsNC30Lgg0L/QviBQT1NJWCIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODQ2CisjOiBidWlsdGluL2dyZXAuYzo4NDgKIG1zZ2lkICJ1c2UgYmFzaWMgUE9TSVggcmVndWxhciBleHByZXNzaW9ucyAoZGVmYXVsdCkiCiBtc2dzdHIgItC+0YHQvdC+0LLQvdC4INGA0LXQs9GD0LvRj9GA0L3QuCDQuNC30YDQsNC30Lgg0L/QviBQT1NJWCAo0YHRgtCw0L3QtNCw0YDRgtC90L4pIgogCi0jOiBidWlsdGluL2dyZXAuYzo4NDkKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg1MQogbXNnaWQgImludGVycHJldCBwYXR0ZXJucyBhcyBmaXhlZCBzdHJpbmdzIgogbXNnc3RyICLRiNCw0LHQu9C+0L3QuNGC0LUg0YHQsCDQtNC+0YHQu9C+0LLQvdC4INC90LjQt9C+0LLQtSIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODUyCisjOiBidWlsdGluL2dyZXAuYzo4NTQKIG1zZ2lkICJ1c2UgUGVybC1jb21wYXRpYmxlIHJlZ3VsYXIgZXhwcmVzc2lvbnMiCiBtc2dzdHIgItGA0LXQs9GD0LvRj9GA0L3QuCDQuNC30YDQsNC30Lgg0L3QsCBQZXJsIgogCi0jOiBidWlsdGluL2dyZXAuYzo4NTUKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg1NwogbXNnaWQgInNob3cgbGluZSBudW1iZXJzIgogbXNnc3RyICLQuNC30LLQtdC20LTQsNC90LUg0L3QsCDQvdC+0LzQtdGA0LDRgtCwINC90LAg0YDQtdC00L7QstC10YLQtSIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODU2CisjOiBidWlsdGluL2dyZXAuYzo4NTgKIG1zZ2lkICJzaG93IGNvbHVtbiBudW1iZXIgb2YgZmlyc3QgbWF0Y2giCiBtc2dzdHIgItC40LfQstC10LbQtNCw0L3QtSDQvdCwINC90L7QvNC10YDQsCDQvdCwINC60L7Qu9C+0L3QsNGC0LAg0L3QsCDQv9GK0YDQstC+0YLQviDQvdCw0L/QsNGB0LLQsNC90LUiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg1NworIzogYnVpbHRpbi9ncmVwLmM6ODU5CiBtc2dpZCAiZG9uJ3Qgc2hvdyBmaWxlbmFtZXMiCiBtc2dzdHIgItCx0LXQtyDQuNC30LLQtdC20LTQsNC90LUg0L3QsCDQuNC80LXQvdCw0YLQsCDQvdCwINGE0LDQudC70L7QstC10YLQtSIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODU4CisjOiBidWlsdGluL2dyZXAuYzo4NjAKIG1zZ2lkICJzaG93IGZpbGVuYW1lcyIKIG1zZ3N0ciAi0LjQt9Cy0LXQttC00LDQvdC1INC90LAg0LjQvNC10L3QsNGC0LAg0L3QsCDRhNCw0LnQu9C+0LLQtdGC0LUiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg2MAorIzogYnVpbHRpbi9ncmVwLmM6ODYyCiBtc2dpZCAic2hvdyBmaWxlbmFtZXMgcmVsYXRpdmUgdG8gdG9wIGRpcmVjdG9yeSIKIG1zZ3N0ciAiIgogItC40LfQstC10LbQtNCw0L3QtSDQvdCwINC+0YLQvdC+0YHQuNGC0LXQu9C90LjRgtC1INC40LzQtdC90LAg0L3QsCDRhNCw0LnQu9C+0LLQtdGC0LUg0YHQv9GA0Y/QvNC+INC+0YHQvdC+0LLQvdCw0YLQsCDQtNC40YDQtdC60YLQvtGA0LjRjyDQvdCwICIKICLRhdGA0LDQvdC40LvQuNGJ0LXRgtC+IgogCi0jOiBidWlsdGluL2dyZXAuYzo4NjIKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg2NAogbXNnaWQgInNob3cgb25seSBmaWxlbmFtZXMgaW5zdGVhZCBvZiBtYXRjaGluZyBsaW5lcyIKIG1zZ3N0ciAi0LjQt9Cy0LXQttC00LDQvdC1INGB0LDQvNC+INC90LAg0LjQvNC10L3QsNGC0LAg0L3QsCDRhNCw0LnQu9C+0LLQtdGC0LUg0LHQtdC3INC90LDQv9Cw0YHQstCw0YnQuNGC0LUg0YDQtdC00L7QstC1IgogCi0jOiBidWlsdGluL2dyZXAuYzo4NjQKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg2NgogbXNnaWQgInN5bm9ueW0gZm9yIC0tZmlsZXMtd2l0aC1tYXRjaGVzIgogbXNnc3RyICLQv9GB0LXQstC00L7QvdC40Lwg0L3QsCDigJ4tLWZpbGVzLXdpdGgtbWF0Y2hlc+KAnCIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODY3CisjOiBidWlsdGluL2dyZXAuYzo4NjkKIG1zZ2lkICJzaG93IG9ubHkgdGhlIG5hbWVzIG9mIGZpbGVzIHdpdGhvdXQgbWF0Y2giCiBtc2dzdHIgIiIKICLQuNC30LLQtdC20LTQsNC90LUg0YHQsNC80L4g0L3QsCDQuNC80LXQvdCw0YLQsCDQvdCwINGE0LDQudC70L7QstC10YLQtSwg0LrQvtC40YLQviDQvdC1INGB0YrQtNGK0YDQttCw0YIg0YDQtdC0LCDQvdCw0L/QsNGB0LLQsNGJINC90LAgIgogItGI0LDQsdC70L7QvdCwIgogCi0jOiBidWlsdGluL2dyZXAuYzo4NjkKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg3MQogbXNnaWQgInByaW50IE5VTCBhZnRlciBmaWxlbmFtZXMiCiBtc2dzdHIgItC40LfQstC10LbQtNCw0L3QtSDQvdCwINC90YPQu9C10LLQuNGPINC30L3QsNC6IOKAnk5VTOKAnCDRgdC70LXQtCDQstGB0Y/QutC+INC40LzQtSDQvdCwINGE0LDQudC7IgogCi0jOiBidWlsdGluL2dyZXAuYzo4NzIKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg3NAogbXNnaWQgInNob3cgb25seSBtYXRjaGluZyBwYXJ0cyBvZiBhIGxpbmUiCiBtc2dzdHIgItC40LfQstC10LbQtNCw0L3QtSDRgdCw0LzQviDQvdCwINGH0LDRgdGC0LjRgtC1INC90LAg0YDQtdC00L7QstC10YLQtSwg0LrQvtC40YLQviDRgdGK0LLQv9Cw0LTQsNGCIgogCi0jOiBidWlsdGluL2dyZXAuYzo4NzQKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg3NgogbXNnaWQgInNob3cgdGhlIG51bWJlciBvZiBtYXRjaGVzIGluc3RlYWQgb2YgbWF0Y2hpbmcgbGluZXMiCiBtc2dzdHIgItC40LfQstC10LbQtNCw0L3QtSDQvdCwINCx0YDQvtGPINC90LAg0YHRitCy0L/QsNC00LXQvdC40Y/RgtCwINCy0LzQtdGB0YLQviDQvdCw0L/QsNGB0LLQsNGJ0LjRgtC1INGA0LXQtNC+0LLQtSIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODc1CisjOiBidWlsdGluL2dyZXAuYzo4NzcKIG1zZ2lkICJoaWdobGlnaHQgbWF0Y2hlcyIKIG1zZ3N0ciAi0L7RhtCy0LXRgtGP0LLQsNC90LUg0L3QsCDQvdCw0L/QsNGB0LLQsNC90LjRj9GC0LAiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg3NworIzogYnVpbHRpbi9ncmVwLmM6ODc5CiBtc2dpZCAicHJpbnQgZW1wdHkgbGluZSBiZXR3ZWVuIG1hdGNoZXMgZnJvbSBkaWZmZXJlbnQgZmlsZXMiCiBtc2dzdHIgItC40LfQstC10LbQtNCw0L3QtSDQvdCwINC/0YDQsNC30LXQvSDRgNC10LQg0LzQtdC20LTRgyDQvdCw0L/QsNGB0LLQsNC90LjRj9GC0LAg0L7RgiDRgNCw0LfQu9C40YfQvdC4INGE0LDQudC70L7QstC1IgogCi0jOiBidWlsdGluL2dyZXAuYzo4NzkKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg4MQogbXNnaWQgInNob3cgZmlsZW5hbWUgb25seSBvbmNlIGFib3ZlIG1hdGNoZXMgZnJvbSBzYW1lIGZpbGUiCiBtc2dzdHIgIiIKICLQuNC30LLQtdC20LTQsNC90LUg0L3QsCDQuNC80LXRgtC+INC90LAg0YTQsNC50LvQsCDRgdCw0LzQviDQstC10LTQvdGK0LYg0LfQsCDQstGB0LjRh9C60Lgg0L3QsNC/0LDRgdCy0LDQvdC40Y8g0L7RgiDRgtC+0LfQuCDRhNCw0LnQuyIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODgyCisjOiBidWlsdGluL2dyZXAuYzo4ODQKIG1zZ2lkICJzaG93IDxuPiBjb250ZXh0IGxpbmVzIGJlZm9yZSBhbmQgYWZ0ZXIgbWF0Y2hlcyIKIG1zZ3N0ciAi0LjQt9Cy0LXQttC00LDQvdC1INC90LAg0YLQsNC60YrQsiDQkdCg0J7QmSDRgNC10LTQvtCy0LUg0L/RgNC10LTQuCDQuCDRgdC70LXQtCDQvdCw0L/QsNGB0LLQsNC90LjRj9GC0LAiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg4NQorIzogYnVpbHRpbi9ncmVwLmM6ODg3CiBtc2dpZCAic2hvdyA8bj4gY29udGV4dCBsaW5lcyBiZWZvcmUgbWF0Y2hlcyIKIG1zZ3N0ciAi0LjQt9Cy0LXQttC00LDQvdC1INC90LAg0YLQsNC60YrQsiDQkdCg0J7QmSDRgNC10LTQvtCy0LUg0L/RgNC10LTQuCDQvdCw0L/QsNGB0LLQsNC90LjRj9GC0LAiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg4NworIzogYnVpbHRpbi9ncmVwLmM6ODg5CiBtc2dpZCAic2hvdyA8bj4gY29udGV4dCBsaW5lcyBhZnRlciBtYXRjaGVzIgogbXNnc3RyICLQuNC30LLQtdC20LTQsNC90LUg0L3QsCDRgtCw0LrRitCyINCR0KDQntCZINGA0LXQtNC+0LLQtSDRgdC70LXQtCDQvdCw0L/QsNGB0LLQsNC90LjRj9GC0LAiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg4OQorIzogYnVpbHRpbi9ncmVwLmM6ODkxCiBtc2dpZCAidXNlIDxuPiB3b3JrZXIgdGhyZWFkcyIKIG1zZ3N0ciAi0LjQt9C/0L7Qu9C30LLQsNC90LUg0L3QsCDRgtCw0LrRitCyINCR0KDQntCZINGA0LDQsdC+0YLQtdGJ0Lgg0L3QuNGI0LrQuCIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODkwCisjOiBidWlsdGluL2dyZXAuYzo4OTIKIG1zZ2lkICJzaG9ydGN1dCBmb3IgLUMgTlVNIgogbXNnc3RyICLQv9GB0LXQstC00L7QvdC40Lwg0L3QsCDigJ4tQyDQkdCg0J7QmeKAnCIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODkzCisjOiBidWlsdGluL2dyZXAuYzo4OTUKIG1zZ2lkICJzaG93IGEgbGluZSB3aXRoIHRoZSBmdW5jdGlvbiBuYW1lIGJlZm9yZSBtYXRjaGVzIgogbXNnc3RyICLQuNC30LLQtdC20LTQsNC90LUg0L3QsCDRgNC10LQg0YEg0LjQvNC10YLQviDQvdCwINGE0YPQvdC60YbQuNGP0YLQsCwg0LIg0LrQvtGP0YLQviDQtSDQvdCw0L/QsNGB0L3QsNGCINGI0LDQsdC70L7QvdCwIgogCi0jOiBidWlsdGluL2dyZXAuYzo4OTUKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg5NwogbXNnaWQgInNob3cgdGhlIHN1cnJvdW5kaW5nIGZ1bmN0aW9uIgogbXNnc3RyICLQuNC30LLQtdC20LTQsNC90LUg0L3QsCDQvtCx0YXQstCw0YnQsNGJ0LDRgtCwINGE0YPQvdC60YbQuNGPIgogCi0jOiBidWlsdGluL2dyZXAuYzo4OTgKKyM6IGJ1aWx0aW4vZ3JlcC5jOjkwMAogbXNnaWQgInJlYWQgcGF0dGVybnMgZnJvbSBmaWxlIgogbXNnc3RyICLQuNC30YfQuNGC0LDQvdC1INC90LAg0YjQsNCx0LvQvtC90LjRgtC1INC+0YIg0KTQkNCZ0JsiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjkwMAorIzogYnVpbHRpbi9ncmVwLmM6OTAyCiBtc2dpZCAibWF0Y2ggPHBhdHRlcm4+IgogbXNnc3RyICLQvdCw0L/QsNGB0LLQsNC90LUg0L3QsCDQqNCQ0JHQm9Ce0J0iCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjkwMgorIzogYnVpbHRpbi9ncmVwLmM6OTA0CiBtc2dpZCAiY29tYmluZSBwYXR0ZXJucyBzcGVjaWZpZWQgd2l0aCAtZSIKIG1zZ3N0ciAi0LrQvtC80LHQuNC90LjRgNCw0L3QtSDQvdCwINGI0LDQsdC70L7QvdC40YLQtSDRg9C60LDQt9Cw0L3QuCDRgSDQvtC/0YbQuNGP0YLQsCDigJ4tZeKAnCIKIAotIzogYnVpbHRpbi9ncmVwLmM6OTE0CisjOiBidWlsdGluL2dyZXAuYzo5MTYKIG1zZ2lkICJpbmRpY2F0ZSBoaXQgd2l0aCBleGl0IHN0YXR1cyB3aXRob3V0IG91dHB1dCIKIG1zZ3N0ciAiIgogItCx0LXQtyDQuNC30LLQtdC20LTQsNC90LUg0L3QsCDRgdGC0LDQvdC00LDRgNGC0L3QuNGPINC40LfRhdC+0LQuICDQmNC30YXQvtC00L3QuNGP0YIg0LrQvtC0INGD0LrQsNC30LLQsCDQvdCw0LvQuNGH0LjQtdGC0L4g0L3QsCAiCiAi0L3QsNC/0LDRgdCy0LDQvdC1IgogCi0jOiBidWlsdGluL2dyZXAuYzo5MTYKKyM6IGJ1aWx0aW4vZ3JlcC5jOjkxOAogbXNnaWQgInNob3cgb25seSBtYXRjaGVzIGZyb20gZmlsZXMgdGhhdCBtYXRjaCBhbGwgcGF0dGVybnMiCiBtc2dzdHIgIiIKICLQuNC30LLQtdC20LTQsNC90LUg0L3QsCDRgNC10LTQvtCy0LUg0YHQsNC80L4g0L7RgiDRhNCw0LnQu9C+0LLQtdGC0LUsINC60L7QuNGC0L4g0L3QsNC/0LDRgdCy0LDRgiDQvdCwINCy0YHQuNGH0LrQuCDRiNCw0LHQu9C+0L3QuCIKIAotIzogYnVpbHRpbi9ncmVwLmM6OTE4CisjOiBidWlsdGluL2dyZXAuYzo5MjAKIG1zZ2lkICJzaG93IHBhcnNlIHRyZWUgZm9yIGdyZXAgZXhwcmVzc2lvbiIKIG1zZ3N0ciAi0LjQt9Cy0LXQttC00LDQvdC1INC90LAg0LTRitGA0LLQvtGC0L4g0LfQsCDQsNC90LDQu9C40Lcg0L3QsCDRgNC10LPRg9C70Y/RgNC90LjRjyDQuNC30YDQsNC3IgogCi0jOiBidWlsdGluL2dyZXAuYzo5MjIKKyM6IGJ1aWx0aW4vZ3JlcC5jOjkyNAogbXNnaWQgInBhZ2VyIgogbXNnc3RyICLQv9GA0L7Qs9GA0LDQvNCwINC30LAg0L/RgNC10LPQu9C10LQg0L/QviDRgdGC0YDQsNC90LjRhtC4IgogCi0jOiBidWlsdGluL2dyZXAuYzo5MjIKKyM6IGJ1aWx0aW4vZ3JlcC5jOjkyNAogbXNnaWQgInNob3cgbWF0Y2hpbmcgZmlsZXMgaW4gdGhlIHBhZ2VyIgogbXNnc3RyICLQuNC30LLQtdC20LTQsNC90LUg0L3QsCDRgdGK0LLQv9Cw0LTQsNGJ0LjRgtC1INGE0LDQudC70L7QstC1INCyINC/0YDQvtCz0YDQsNC80LAg0LfQsCDQv9GA0LXQs9C70LXQtCDQv9C+INGB0YLRgNCw0L3QuNGG0LgiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjkyNgorIzogYnVpbHRpbi9ncmVwLmM6OTI4CiBtc2dpZCAiYWxsb3cgY2FsbGluZyBvZiBncmVwKDEpIChpZ25vcmVkIGJ5IHRoaXMgYnVpbGQpIgogbXNnc3RyICIiCiAi0L/QvtC30LLQvtC70Y/QstCw0L3QtSDQvdCwINGB0YLQsNGA0YLQuNGA0LDQvdC10YLQviDQvdCwIGdyZXAoMSkgKNGC0LXQutGD0YnQuNGP0YIg0LrQvtC80L/QuNC70LDRgiDQv9GA0LXQvdC10LHRgNC10LPQstCwINGC0LDQt9C4ICIKICLQvtC/0YbQuNGPKSIKIAotIzogYnVpbHRpbi9ncmVwLmM6OTkwCisjOiBidWlsdGluL2dyZXAuYzo5OTIKIG1zZ2lkICJubyBwYXR0ZXJuIGdpdmVuIgogbXNnc3RyICLQvdC1INGB0YLQtSDQt9Cw0LTQsNC70Lgg0YjQsNCx0LvQvtC9IgogCi0jOiBidWlsdGluL2dyZXAuYzoxMDI2CisjOiBidWlsdGluL2dyZXAuYzoxMDI4CiBtc2dpZCAiLS1uby1pbmRleCBvciAtLXVudHJhY2tlZCBjYW5ub3QgYmUgdXNlZCB3aXRoIHJldnMiCiBtc2dzdHIgItC+0L/RhtC40LjRgtC1IOKAni0tY2FjaGVk4oCcINC4IOKAni0tdW50cmFja2Vk4oCcINGB0LAg0L3QtdGB0YrQstC80LXRgdGC0LjQvNC4INGBINCy0LXRgNGB0LjQuC4iCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjEwMzQKKyM6IGJ1aWx0aW4vZ3JlcC5jOjEwMzYKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHJlc29sdmUgcmV2aXNpb246ICVzIgogbXNnc3RyICLQstC10YDRgdC40Y/RgtCwIOKAniVz4oCcINC90LUg0LzQvtC20LUg0LHRitC00LUg0L7RgtC60YDQuNGC0LAiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjEwNjUKKyM6IGJ1aWx0aW4vZ3JlcC5jOjEwNjcKIG1zZ2lkICJpbnZhbGlkIG9wdGlvbiBjb21iaW5hdGlvbiwgaWdub3JpbmcgLS10aHJlYWRzIgogbXNnc3RyICLQvdC10L/RgNCw0LLQuNC70L3QsCDQutC+0LzQsdC40L3QsNGG0LjRjyDQvtGCINC+0L/RhtC40LgsIOKAni0tdGhyZWFkc+KAnCDRidC1INGB0LUg0L/RgNC10L3QtdCx0YDQtdCz0L3QtSIKIAotIzogYnVpbHRpbi9ncmVwLmM6MTA2OCBidWlsdGluL3BhY2stb2JqZWN0cy5jOjM0MTYKKyM6IGJ1aWx0aW4vZ3JlcC5jOjEwNzAgYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozNDAwCiBtc2dpZCAibm8gdGhyZWFkcyBzdXBwb3J0LCBpZ25vcmluZyAtLXRocmVhZHMiCiBtc2dzdHIgItC70LjQv9GB0LLQsCDQv9C+0LTQtNGA0YrQttC60LAg0LfQsCDQvdC40YjQutC4LiAg4oCeLS10aHJlYWRz4oCcINGJ0LUg0YHQtSDQv9GA0LXQvdC10LHRgNC10LPQvdC1IgogCi0jOiBidWlsdGluL2dyZXAuYzoxMDcxIGJ1aWx0aW4vaW5kZXgtcGFjay5jOjE1MzEgYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNzI1CisjOiBidWlsdGluL2dyZXAuYzoxMDczIGJ1aWx0aW4vaW5kZXgtcGFjay5jOjE1MzEgYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNzA1CiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgbnVtYmVyIG9mIHRocmVhZHMgc3BlY2lmaWVkICglZCkiCiBtc2dzdHIgItC30LDQtNCw0LTQtdC9INC1INC90LXQv9GA0LDQstC40LvQtdC9INCx0YDQvtC5INC90LjRiNC60Lg6ICVkIgogCi0jOiBidWlsdGluL2dyZXAuYzoxMDk0CisjOiBidWlsdGluL2dyZXAuYzoxMDk2CiBtc2dpZCAiLS1vcGVuLWZpbGVzLWluLXBhZ2VyIG9ubHkgd29ya3Mgb24gdGhlIHdvcmt0cmVlIgogbXNnc3RyICIiCiAi0L7Qv9GG0LjRj9GC0LAg4oCeLS1vcGVuLWZpbGVzLWluLXBhZ2Vy4oCcINC1INGB0YrQstC80LXRgdGC0LjQvNCwINGB0LDQvNC+INGBINGC0YrRgNGB0LXQvdC1INCyINGA0LDQsdC+0YLQvdC+0YLQviDQtNGK0YDQstC+IgogCi0jOiBidWlsdGluL2dyZXAuYzoxMTE3CisjOiBidWlsdGluL2dyZXAuYzoxMTE5CiBtc2dpZCAib3B0aW9uIG5vdCBzdXBwb3J0ZWQgd2l0aCAtLXJlY3Vyc2Utc3VibW9kdWxlcyIKIG1zZ3N0ciAi0L7Qv9GG0LjRj9GC0LAg0LUg0L3QtdGB0YrQstC80LXRgdGC0LjQvNCwINGBIOKAni0tcmVjdXJzZS1zdWJtb2R1bGVz4oCcIgogCi0jOiBidWlsdGluL2dyZXAuYzoxMTIzCisjOiBidWlsdGluL2dyZXAuYzoxMTI1CiBtc2dpZCAiLS1jYWNoZWQgb3IgLS11bnRyYWNrZWQgY2Fubm90IGJlIHVzZWQgd2l0aCAtLW5vLWluZGV4IgogbXNnc3RyICLQvtC/0YbQuNC40YLQtSDigJ4tLWNhY2hlZOKAnCDQuCDigJ4tLXVudHJhY2tlZOKAnCDRgdCwINC90LXRgdGK0LLQvNC10YHRgtC40LzQuCDRgSDigJ4tLW5vLWluZGV44oCcIgogCi0jOiBidWlsdGluL2dyZXAuYzoxMTI5CisjOiBidWlsdGluL2dyZXAuYzoxMTMxCiBtc2dpZCAiLS1bbm8tXWV4Y2x1ZGUtc3RhbmRhcmQgY2Fubm90IGJlIHVzZWQgZm9yIHRyYWNrZWQgY29udGVudHMiCiBtc2dzdHIgIiIKICLQvtC/0YbQuNC40YLQtSDigJ4tLShuby0pZXhjbHVkZS1zdGFuZGFyZOKAnCDRgdCwINC90LXRgdGK0LLQvNC10YHRgtC40LzQuCDRgSDRgtGK0YDRgdC10L3QtSDQv9C+INGB0LvQtdC00LXQvdC4ICIKICLRhNCw0LnQu9C+0LLQtSIKIAotIzogYnVpbHRpbi9ncmVwLmM6MTEzNworIzogYnVpbHRpbi9ncmVwLmM6MTEzOQogbXNnaWQgImJvdGggLS1jYWNoZWQgYW5kIHRyZWVzIGFyZSBnaXZlbiIKIG1zZ3N0ciAi0L7Qv9GG0LjRj9GC0LAg4oCeLS1jYWNoZWTigJwg0LUg0L3QtdGB0YrQstC80LXRgdGC0LjQvNCwINGB0YrRgSDQt9Cw0LTQsNCy0LDQvdC1INC90LAg0LTRitGA0LLQviIKIApAQCAtMTQ0NDYsNyArMTQ1MzAsNyBAQAogbXNnaWQgIlJlc29sdmluZyBkZWx0YXMiCiBtc2dzdHIgItCe0YLQutGA0LjQstCw0L3QtSDQvdCwINGB0YrQvtGC0LLQtdGC0L3QuNGC0LUg0YDQsNC30LvQuNC60LgiCiAKLSM6IGJ1aWx0aW4vaW5kZXgtcGFjay5jOjEyMDUgYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNDk3CisjOiBidWlsdGluL2luZGV4LXBhY2suYzoxMjA1IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjQ4MQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gY3JlYXRlIHRocmVhZDogJXMiCiBtc2dzdHIgItC90LUg0LzQvtC20LUg0LTQsCDRgdC1INGB0YrQt9C00LDQtNC1INC90LjRiNC60LA6ICVzIgpAQCAtMTQ1MTYsNyArMTQ2MDAsNyBAQAogbXNnaWQgImNhbm5vdCBzdG9yZSBpbmRleCBmaWxlIgogbXNnc3RyICLRhNCw0LnQu9GK0YIg0LfQsCDQuNC90LTQtdC60YHQsCDQvdC1INC80L7QttC1INC00LAg0LHRitC00LUg0YHRitGF0YDQsNC90LXQvSIKIAotIzogYnVpbHRpbi9pbmRleC1wYWNrLmM6MTUyNSBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI3MzYKKyM6IGJ1aWx0aW4vaW5kZXgtcGFjay5jOjE1MjUgYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNzE2CiAjLCBjLWZvcm1hdAogbXNnaWQgImJhZCBwYWNrLmluZGV4dmVyc2lvbj0lPFBSSXUzMj4iCiBtc2dzdHIgItC30LDQtNCw0LTQtdC90LAg0LUg0L3QtdC/0YDQsNCy0LjQu9C90LAg0LLQtdGA0YHQuNGPINC/0LDQutC10YLQuNGA0LDQvdC1OiDigJ5wYWNrLmluZGV4dmVyc2lvbj0lPFBSSXUzMj7igJwiCkBAIC0xNDgwNCw3NCArMTQ4ODgsNzQgQEAKIG1zZ2lkICJnaXQgc2hvdyAlczogYmFkIGZpbGUiCiBtc2dzdHIgImdpdCBzaG93ICVzOiDQv9C+0LLRgNC10LTQtdC9INGE0LDQudC7IgogCi0jOiBidWlsdGluL2xvZy5jOjU0OSBidWlsdGluL2xvZy5jOjY0MworIzogYnVpbHRpbi9sb2cuYzo1NDkgYnVpbHRpbi9sb2cuYzo2NDQKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHJlYWQgb2JqZWN0ICVzIgogbXNnc3RyICLQvtCx0LXQutGC0YrRgiDQvdC1INC80L7QttC1INC00LAg0LHRitC00LUg0L/RgNC+0YfQtdGC0LXQvTogJXMiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6NjY4CisjOiBidWlsdGluL2xvZy5jOjY2OQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmtub3duIHR5cGU6ICVkIgogbXNnc3RyICLQvdC10LjQt9Cy0LXRgdGC0LXQvSDQstC40LQ6ICVkIgogCi0jOiBidWlsdGluL2xvZy5jOjc5MQorIzogYnVpbHRpbi9sb2cuYzo3OTIKIG1zZ2lkICJmb3JtYXQuaGVhZGVycyB3aXRob3V0IHZhbHVlIgogbXNnc3RyICLQvdC1INC1INC30LDQtNCw0LTQtdC90LAg0YHRgtC+0LnQvdC+0YHRgiDQvdCwIOKAnmZvcm1hdC5oZWFkZXJz4oCcIgogCi0jOiBidWlsdGluL2xvZy5jOjkwOAorIzogYnVpbHRpbi9sb2cuYzo5MDkKIG1zZ2lkICJuYW1lIG9mIG91dHB1dCBkaXJlY3RvcnkgaXMgdG9vIGxvbmciCiBtc2dzdHIgItC/0YDQtdC60LDQu9C10L3QviDQtNGK0LvQs9C+INC40LzQtSDQvdCwINC00LjRgNC10LrRgtC+0YDQuNGP0YLQsCDQt9CwINC40LfRhdC+0LTQvdCw0YLQsCDQuNC90YTQvtGA0LzQsNGG0LjRjyIKIAotIzogYnVpbHRpbi9sb2cuYzo5MjQKKyM6IGJ1aWx0aW4vbG9nLmM6OTI1CiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCBvcGVuIHBhdGNoIGZpbGUgJXMiCiBtc2dzdHIgItGE0LDQudC70YrRgi3QutGA0YrQv9C60LAg4oCeJXPigJwg0L3QtSDQvNC+0LbQtSDQtNCwINCx0YrQtNC1INC+0YLQstC+0YDQtdC9IgogCi0jOiBidWlsdGluL2xvZy5jOjk0MQorIzogYnVpbHRpbi9sb2cuYzo5NDIKIG1zZ2lkICJuZWVkIGV4YWN0bHkgb25lIHJhbmdlIgogbXNnc3RyICLRgtGA0Y/QsdCy0LAg0LTQsCDQt9Cw0LTQsNC00LXRgtC1INGC0L7Rh9C90L4g0LXQtNC40L0g0LTQuNCw0L/QsNC30L7QvSIKIAotIzogYnVpbHRpbi9sb2cuYzo5NTEKKyM6IGJ1aWx0aW4vbG9nLmM6OTUyCiBtc2dpZCAibm90IGEgcmFuZ2UiCiBtc2dzdHIgItC90LUg0LUg0LTQuNCw0L/QsNC30L7QvSIKIAotIzogYnVpbHRpbi9sb2cuYzoxMDc0CisjOiBidWlsdGluL2xvZy5jOjEwNzUKIG1zZ2lkICJjb3ZlciBsZXR0ZXIgbmVlZHMgZW1haWwgZm9ybWF0IgogbXNnc3RyICLQv9GA0LjQtNGA0YPQttCw0LLQsNGJ0L7RgtC+INC/0LjRgdC80L4g0YLRgNGP0LHQstCwINC00LAg0LUg0YTQvtGA0LzQsNGC0LjRgNCw0L3QviDQutCw0YLQviDQtS3Qv9C40YHQvNC+IgogCi0jOiBidWlsdGluL2xvZy5jOjEwODAKKyM6IGJ1aWx0aW4vbG9nLmM6MTA4MQogbXNnaWQgImZhaWxlZCB0byBjcmVhdGUgY292ZXItbGV0dGVyIGZpbGUiCiBtc2dzdHIgItC90LXRg9GB0L/QtdGI0L3QviDRgdGK0LfQtNCw0LLQsNC90LUg0L3QsCDQv9GA0LjQtNGA0YPQttCw0LLQsNGJ0L4g0L/QuNGB0LzQviIKIAotIzogYnVpbHRpbi9sb2cuYzoxMTU5CisjOiBidWlsdGluL2xvZy5jOjExNjAKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW5zYW5lIGluLXJlcGx5LXRvOiAlcyIKIG1zZ3N0ciAi0L3QtdC/0YDQsNCy0LjQu9C10L0g0YTQvtGA0LzQsNGCINC90LAg0LfQsNCz0LvQsNCy0L3QsNGC0LAg0YfQsNGB0YIg0LfQsCDQvtGC0LPQvtCy0L7RgCDigJ5pbi1yZXBseS10b+KAnDogJXMiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTE4NgorIzogYnVpbHRpbi9sb2cuYzoxMTg3CiBtc2dpZCAiZ2l0IGZvcm1hdC1wYXRjaCBbPG9wdGlvbnM+XSBbPHNpbmNlPiB8IDxyZXZpc2lvbi1yYW5nZT5dIgogbXNnc3RyICJnaXQgZm9ybWF0LXBhdGNoIFvQntCf0KbQmNCv4oCmXSBb0J7QoiB8INCU0JjQkNCf0JDQl9Ce0J1f0J3QkF/QktCV0KDQodCY0JjQotCVXSIKIAotIzogYnVpbHRpbi9sb2cuYzoxMjQ0CisjOiBidWlsdGluL2xvZy5jOjEyNDUKIG1zZ2lkICJ0d28gb3V0cHV0IGRpcmVjdG9yaWVzPyIKIG1zZ3N0ciAi0LzQvtC20LUg0LTQsCDRg9C60LDQttC10YLQtSDQvNCw0LrRgdC40LzRg9C8INC10LTQvdCwINC00LjRgNC10LrRgtC+0YDQuNGPINC30LAg0LjQt9GF0L7QtCIKIAotIzogYnVpbHRpbi9sb2cuYzoxMzU1IGJ1aWx0aW4vbG9nLmM6MjA5OSBidWlsdGluL2xvZy5jOjIxMDEgYnVpbHRpbi9sb2cuYzoyMTEzCisjOiBidWlsdGluL2xvZy5jOjEzNTYgYnVpbHRpbi9sb2cuYzoyMTE2IGJ1aWx0aW4vbG9nLmM6MjExOCBidWlsdGluL2xvZy5jOjIxMzAKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5rbm93biBjb21taXQgJXMiCiBtc2dzdHIgItC90LXQv9C+0LfQvdCw0YLQviDQv9C+0LTQsNCy0LDQvdC1OiDigJ4lc+KAnCIKIAotIzogYnVpbHRpbi9sb2cuYzoxMzY1IGJ1aWx0aW4vcmVwbGFjZS5jOjU4IGJ1aWx0aW4vcmVwbGFjZS5jOjIwNworIzogYnVpbHRpbi9sb2cuYzoxMzY2IGJ1aWx0aW4vcmVwbGFjZS5jOjU4IGJ1aWx0aW4vcmVwbGFjZS5jOjIwNwogIzogYnVpbHRpbi9yZXBsYWNlLmM6MjEwCiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byByZXNvbHZlICclcycgYXMgYSB2YWxpZCByZWYiCiBtc2dzdHIgIuKAniVz4oCcINC90LUg0LUg0YPQutCw0LfQsNGC0LXQuyDQuNC70Lgg0L3QtSDRgdC+0YfQuCDQutGK0Lwg0L3QuNGJ0L4iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTM3MAorIzogYnVpbHRpbi9sb2cuYzoxMzcxCiBtc2dpZCAiY291bGQgbm90IGZpbmQgZXhhY3QgbWVyZ2UgYmFzZSIKIG1zZ3N0ciAi0YLQvtGH0L3QsNGC0LAg0LHQsNC30LAg0LfQsCDRgdC70LjQstCw0L3QtSDQvdC1INC80L7QttC1INC00LAg0LHRitC00LUg0L7RgtC60YDQuNGC0LAiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTM3NAorIzogYnVpbHRpbi9sb2cuYzoxMzc1CiBtc2dpZCAiIgogImZhaWxlZCB0byBnZXQgdXBzdHJlYW0sIGlmIHlvdSB3YW50IHRvIHJlY29yZCBiYXNlIGNvbW1pdCBhdXRvbWF0aWNhbGx5LFxuIgogInBsZWFzZSB1c2UgZ2l0IGJyYW5jaCAtLXNldC11cHN0cmVhbS10byB0byB0cmFjayBhIHJlbW90ZSBicmFuY2guXG4iCkBAIC0xNDg4MSwyODEgKzE0OTY1LDI4MSBAQAogItC30LDQtNCw0LTQtdGC0LUsINC40LfQv9C+0LvQt9Cy0LDQudGC0LUg4oCeZ2l0IGJyYW5jaCAtLXNldC11cHN0cmVhbS10b+KAnC5cbiIKICLQnNC+0LbQtdGC0LUg0YDRitGH0L3QviDQtNCwINC30LDQtNCw0LTQtdGC0LUg0LHQsNC30L7QstC+INC/0L7QtNCw0LLQsNC90LUg0YfRgNC10Lcg4oCeLS1iYXNlPTxiYXNlLWNvbW1pdC1pZD7igJwuIgogCi0jOiBidWlsdGluL2xvZy5jOjEzOTQKKyM6IGJ1aWx0aW4vbG9nLmM6MTM5NQogbXNnaWQgImZhaWxlZCB0byBmaW5kIGV4YWN0IG1lcmdlIGJhc2UiCiBtc2dzdHIgItGC0L7Rh9C90LDRgtCwINCx0LDQt9CwINC/0YDQuCDRgdC70LjQstCw0L3QtSDQvdC1INC80L7QttC1INC00LAg0LHRitC00LUg0L7RgtC60YDQuNGC0LAiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTQwNQorIzogYnVpbHRpbi9sb2cuYzoxNDA2CiBtc2dpZCAiYmFzZSBjb21taXQgc2hvdWxkIGJlIHRoZSBhbmNlc3RvciBvZiByZXZpc2lvbiBsaXN0IgogbXNnc3RyICLQsdCw0LfQvtCy0L7RgtC+INC/0L7QtNCw0LLQsNC90LUg0YLRgNGP0LHQstCwINC00LAg0LUg0L/RgNC10LTRiNC10YHRgtCy0LXQvdC40LrRitGCINC90LAg0YHQv9C40YHRitC60LAg0YEg0LLQtdGA0YHQuNC40YLQtSIKIAotIzogYnVpbHRpbi9sb2cuYzoxNDA5CisjOiBidWlsdGluL2xvZy5jOjE0MTAKIG1zZ2lkICJiYXNlIGNvbW1pdCBzaG91bGRuJ3QgYmUgaW4gcmV2aXNpb24gbGlzdCIKIG1zZ3N0ciAi0LHQsNC30L7QstC+0YLQviDQv9C+0LTQsNCy0LDQvdC1INC90LUg0LzQvtC20LUg0LTQsCDQtSDQsiDRgdC/0LjRgdGK0LrQsCDRgSDQstC10YDRgdC40LjRgtC1IgogCi0jOiBidWlsdGluL2xvZy5jOjE0NjIKKyM6IGJ1aWx0aW4vbG9nLmM6MTQ2MwogbXNnaWQgImNhbm5vdCBnZXQgcGF0Y2ggaWQiCiBtc2dzdHIgItC40LTQtdC90YLQuNGE0LjQutCw0YLQvtGA0YrRgiDQvdCwINC60YDRitC/0LrQsNGC0LAg0L3QtSDQvNC+0LbQtSDQtNCwINCx0YrQtNC1INC/0L7Qu9GD0YfQtdC9IgogCi0jOiBidWlsdGluL2xvZy5jOjE1MTQKKyM6IGJ1aWx0aW4vbG9nLmM6MTUxNQogbXNnaWQgImZhaWxlZCB0byBpbmZlciByYW5nZS1kaWZmIHJhbmdlcyIKIG1zZ3N0ciAi0L3QtdGD0YHQv9C10YjQvdC+INC+0L/RgNC10LTQtdC70Y/QvdC1INC90LAg0LTQuNCw0L/QsNC30L7QvdC40YLQtSDQt9CwINGA0LDQt9C70LjQutCwIgogCi0jOiBidWlsdGluL2xvZy5jOjE1NTkKKyM6IGJ1aWx0aW4vbG9nLmM6MTU2MAogbXNnaWQgInVzZSBbUEFUQ0ggbi9tXSBldmVuIHdpdGggYSBzaW5nbGUgcGF0Y2giCiBtc2dzdHIgItC90L7QvNC10YDQsNGG0LjRjyDigJ5bUEFUQ0ggbi9tXeKAnCDQtNC+0YDQuCDQuCDQv9GA0Lgg0LXQtNC40L3RgdGC0LLQtdC90LAg0LrRgNGK0L/QutCwIgogCi0jOiBidWlsdGluL2xvZy5jOjE1NjIKKyM6IGJ1aWx0aW4vbG9nLmM6MTU2MwogbXNnaWQgInVzZSBbUEFUQ0hdIGV2ZW4gd2l0aCBtdWx0aXBsZSBwYXRjaGVzIgogbXNnc3RyICLQvdC+0LzQtdGA0LDRhtC40Y8g4oCeW1BBVENIXeKAnCDQtNC+0YDQuCDQuCDQv9GA0Lgg0LzQvdC+0LbQtdGB0YLQstC+INC60YDRitC/0LrQuCIKIAotIzogYnVpbHRpbi9sb2cuYzoxNTY2CisjOiBidWlsdGluL2xvZy5jOjE1NjcKIG1zZ2lkICJwcmludCBwYXRjaGVzIHRvIHN0YW5kYXJkIG91dCIKIG1zZ3N0ciAi0LjQt9Cy0LXQttC00LDQvdC1INC90LAg0LrRgNGK0L/QutC40YLQtSDQvdCwINGB0YLQsNC90LTQsNGA0YLQvdC40Y8g0LjQt9GF0L7QtCIKIAotIzogYnVpbHRpbi9sb2cuYzoxNTY4CisjOiBidWlsdGluL2xvZy5jOjE1NjkKIG1zZ2lkICJnZW5lcmF0ZSBhIGNvdmVyIGxldHRlciIKIG1zZ3N0ciAi0YHRitC30LTQsNCy0LDQvdC1INC90LAg0L/RgNC40LTRgNGD0LbQsNCy0LDRidC+INC/0LjRgdC80L4iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTU3MAorIzogYnVpbHRpbi9sb2cuYzoxNTcxCiBtc2dpZCAidXNlIHNpbXBsZSBudW1iZXIgc2VxdWVuY2UgZm9yIG91dHB1dCBmaWxlIG5hbWVzIgogbXNnc3RyICLQv9GA0L7RgdGC0LAg0YfQuNGB0LvQvtCy0LAg0L/QvtGB0LvQtdC00L7QstCw0YLQtdC70L3QvtGB0YIg0LfQsCDQuNC80LXQvdCw0YLQsCDQvdCwINGE0LDQudC70L7QstC10YLQtS3QutGA0YrQv9C60LgiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTU3MQorIzogYnVpbHRpbi9sb2cuYzoxNTcyCiBtc2dpZCAic2Z4IgogbXNnc3RyICLQl9Cd0JDQptCYIgogCi0jOiBidWlsdGluL2xvZy5jOjE1NzIKKyM6IGJ1aWx0aW4vbG9nLmM6MTU3MwogbXNnaWQgInVzZSA8c2Z4PiBpbnN0ZWFkIG9mICcucGF0Y2gnIgogbXNnc3RyICLQuNC30L/QvtC70LfQstCw0L3QtSDQvdCwINGC0LXQt9C4INCX0J3QkNCm0Jgg0LfQsCDRgdGD0YTQuNC60YEg0LLQvNC10YHRgtC+IOKAni5wYXRjaOKAnCIKIAotIzogYnVpbHRpbi9sb2cuYzoxNTc0CisjOiBidWlsdGluL2xvZy5jOjE1NzUKIG1zZ2lkICJzdGFydCBudW1iZXJpbmcgcGF0Y2hlcyBhdCA8bj4gaW5zdGVhZCBvZiAxIgogbXNnc3RyICLQvdC+0LzQtdGA0LjRgNCw0L3QtdGC0L4g0L3QsCDQutGA0YrQv9C60LjRgtC1INC00LAg0LfQsNC/0L7Rh9Cy0LAg0L7RgiDRgtC+0LfQuCDQkdCg0J7QmSwg0LAg0L3QtSDRgSAxIgogCi0jOiBidWlsdGluL2xvZy5jOjE1NzYKKyM6IGJ1aWx0aW4vbG9nLmM6MTU3NwogbXNnaWQgIm1hcmsgdGhlIHNlcmllcyBhcyBOdGggcmUtcm9sbCIKIG1zZ3N0ciAi0L7RgtCx0LXQu9GP0LfQstCw0L3QtSwg0YfQtSDRgtC+0LLQsCDQtSBOLdGC0LDRgtCwINC/0L7RgNC10LTQvdCwINGA0LXQtNCw0LrRhtC40Y8g0L3QsCDQv9C+0YDQtdC00LjRhtCw0YLQsCDQvtGCINC60YDRitC/0LrQuCIKIAotIzogYnVpbHRpbi9sb2cuYzoxNTc4CisjOiBidWlsdGluL2xvZy5jOjE1NzkKIG1zZ2lkICJVc2UgW1JGQyBQQVRDSF0gaW5zdGVhZCBvZiBbUEFUQ0hdIgogbXNnc3RyICLQmNC30L/QvtC70LfQstCw0L3QtSDQvdCwIOKAnltSRkMgUEFUQ0hd4oCcINCy0LzQtdGB0YLQviDigJ5bUEFUQ0hd4oCcIgogCi0jOiBidWlsdGluL2xvZy5jOjE1ODEKKyM6IGJ1aWx0aW4vbG9nLmM6MTU4MgogbXNnaWQgIlVzZSBbPHByZWZpeD5dIGluc3RlYWQgb2YgW1BBVENIXSIKIG1zZ3N0ciAi0JjQt9C/0L7Qu9C30LLQsNC90LUg0L3QsCDRgtC+0LfQuCDigJ5b0J/QoNCV0KTQmNCa0KFd4oCcINCy0LzQtdGB0YLQviDigJ5bUEFUQ0hd4oCcIgogCi0jOiBidWlsdGluL2xvZy5jOjE1ODQKKyM6IGJ1aWx0aW4vbG9nLmM6MTU4NQogbXNnaWQgInN0b3JlIHJlc3VsdGluZyBmaWxlcyBpbiA8ZGlyPiIKIG1zZ3N0ciAi0LfQsNC/0LDQt9Cy0LDQvdC1INC90LAg0LjQt9GF0L7QtNC90LjRgtC1INGE0LDQudC70L7QstC1INCyINGC0LDQt9C4INCU0JjQoNCV0JrQotCe0KDQmNCvIgogCi0jOiBidWlsdGluL2xvZy5jOjE1ODcKKyM6IGJ1aWx0aW4vbG9nLmM6MTU4OAogbXNnaWQgImRvbid0IHN0cmlwL2FkZCBbUEFUQ0hdIgogbXNnc3RyICLQsdC10Lcg0LTQvtCx0LDQstGP0L3QtS/QvNCw0YXQsNC90LUg0L3QsCDQv9GA0LXRhNC40LrRgdCwIOKAnltQQVRDSF3igJwiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTU5MAorIzogYnVpbHRpbi9sb2cuYzoxNTkxCiBtc2dpZCAiZG9uJ3Qgb3V0cHV0IGJpbmFyeSBkaWZmcyIKIG1zZ3N0ciAi0LHQtdC3INC40LfQstC10LbQtNCw0L3QtSDQvdCwINGA0LDQt9C70LjQutC4INC80LXQttC00YMg0LTQstC+0LjRh9C90Lgg0YTQsNC50LvQvtCy0LUiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTU5MgorIzogYnVpbHRpbi9sb2cuYzoxNTkzCiBtc2dpZCAib3V0cHV0IGFsbC16ZXJvIGhhc2ggaW4gRnJvbSBoZWFkZXIiCiBtc2dzdHIgItCyINC30LDQs9C70LDQstC90LDRgtCwINGH0LDRgdGCIOKAnkZyb2064oCcICjQvtGCKSDQutC+0L3RgtGA0L7Qu9C90LDRgtCwINGB0YPQvNCwINC00LAg0LUg0YHQsNC80L4g0L7RgiDQvdGD0LvQuCIKIAotIzogYnVpbHRpbi9sb2cuYzoxNTk0CisjOiBidWlsdGluL2xvZy5jOjE1OTUKIG1zZ2lkICJkb24ndCBpbmNsdWRlIGEgcGF0Y2ggbWF0Y2hpbmcgYSBjb21taXQgdXBzdHJlYW0iCiBtc2dzdHIgItCx0LXQtyDQutGA0YrQv9C60LgsINC60L7QuNGC0L4g0L/RgNC40YHRitGB0YLQstCw0YIg0LIg0YHQu9C10LTQtdC90LjRjyDQutC70L7QvSIKIAotIzogYnVpbHRpbi9sb2cuYzoxNTk2CisjOiBidWlsdGluL2xvZy5jOjE1OTcKIG1zZ2lkICJzaG93IHBhdGNoIGZvcm1hdCBpbnN0ZWFkIG9mIGRlZmF1bHQgKHBhdGNoICsgc3RhdCkiCiBtc2dzdHIgIiIKICLQuNC30LLQtdC20LTQsNC90LUg0LLRitCyINGE0L7RgNC80LDRgiDQt9CwINC60YDRitC/0LrQuCwg0LAg0L3QsCDQsiDRgdGC0LDQvdC00LDRgNGC0L3QuNGPICjQutGA0YrQv9C60LAg0Lgg0YHRgtCw0YLQuNGB0YLQuNC60LApIgogCi0jOiBidWlsdGluL2xvZy5jOjE1OTgKKyM6IGJ1aWx0aW4vbG9nLmM6MTU5OQogbXNnaWQgIk1lc3NhZ2luZyIKIG1zZ3N0ciAi0J7Qv9GG0LjQuCDQv9GA0Lgg0LjQt9C/0YDQsNGJ0LDQvdC1IgogCi0jOiBidWlsdGluL2xvZy5jOjE1OTkKKyM6IGJ1aWx0aW4vbG9nLmM6MTYwMAogbXNnaWQgImhlYWRlciIKIG1zZ3N0ciAi0JfQkNCT0JvQkNCS0J3QkF/Qp9CQ0KHQoiIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjAwCisjOiBidWlsdGluL2xvZy5jOjE2MDEKIG1zZ2lkICJhZGQgZW1haWwgaGVhZGVyIgogbXNnc3RyICLQtNC+0LHQsNCy0Y/QvdC1INC90LAg0YLQsNC30Lgg0JfQkNCT0JvQkNCS0J3QkF/Qp9CQ0KHQoiIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjAxIGJ1aWx0aW4vbG9nLmM6MTYwMworIzogYnVpbHRpbi9sb2cuYzoxNjAyIGJ1aWx0aW4vbG9nLmM6MTYwNAogbXNnaWQgImVtYWlsIgogbXNnc3RyICLQlS3Qn9Ce0KnQkCIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjAxCisjOiBidWlsdGluL2xvZy5jOjE2MDIKIG1zZ2lkICJhZGQgVG86IGhlYWRlciIKIG1zZ3N0ciAi0LTQvtCx0LDQstGP0L3QtSDQvdCwINC30LDQs9C70LDQstC90LAg0YfQsNGB0YIg4oCeVG864oCcICjQtNC+KSIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjAzCisjOiBidWlsdGluL2xvZy5jOjE2MDQKIG1zZ2lkICJhZGQgQ2M6IGhlYWRlciIKIG1zZ3N0ciAi0LTQvtCx0LDQstGP0L3QtSDQvdCwINC30LDQs9C70LDQstC90LAg0YfQsNGB0YIg4oCeQ2M64oCcICjQuCDQtNC+KSIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjA1CisjOiBidWlsdGluL2xvZy5jOjE2MDYKIG1zZ2lkICJpZGVudCIKIG1zZ3N0ciAi0JjQlNCV0J3QotCY0KfQndCe0KHQoiIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjA2CisjOiBidWlsdGluL2xvZy5jOjE2MDcKIG1zZ2lkICJzZXQgRnJvbSBhZGRyZXNzIHRvIDxpZGVudD4gKG9yIGNvbW1pdHRlciBpZGVudCBpZiBhYnNlbnQpIgogbXNnc3RyICIiCiAi0LfQsNC00LDQstCw0L3QtSDQvdCwINCw0LTRgNC10YHQsCDQsiDQt9Cw0LPQu9Cw0LLQvdCw0YLQsCDRh9Cw0YHRgiDigJ5Gcm9t4oCcICjQvtGCKSDQtNCwINC1INGC0LDQt9C4INCY0JTQldCd0KLQmNCn0J3QntCh0KIuICDQkNC60L4gIgogItC90LUg0LUg0LfQsNC00LDQtNC10L3QsCDRgtCw0LrQsNCy0LAsINGB0LUg0LLQt9C40LzQsCDQsNC00YDQtdGB0LAg0L3QsCDQv9C+0LTQsNCy0LDRidC40Y8iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTYwOAorIzogYnVpbHRpbi9sb2cuYzoxNjA5CiBtc2dpZCAibWVzc2FnZS1pZCIKIG1zZ3N0ciAi0JjQlNCV0J3QotCY0KTQmNCa0JDQotCe0KBf0J3QkF/QodCq0J7QkdCp0JXQndCY0JUiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTYwOQorIzogYnVpbHRpbi9sb2cuYzoxNjEwCiBtc2dpZCAibWFrZSBmaXJzdCBtYWlsIGEgcmVwbHkgdG8gPG1lc3NhZ2UtaWQ+IgogbXNnc3RyICIiCiAi0L/RitGA0LLQvtGC0L4g0YHRitC+0LHRidC10L3QuNC1INC00LAg0LUg0LIg0L7RgtCz0L7QstC+0YAg0L3QsCDQtS3Qv9C40YHQvNC+0YLQviDRgSDRgtC+0LfQuCAiCiAi0JjQlNCV0J3QotCY0KTQmNCa0JDQotCe0KBf0J3QkF/QodCq0J7QkdCp0JXQndCY0JUiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTYxMCBidWlsdGluL2xvZy5jOjE2MTMKKyM6IGJ1aWx0aW4vbG9nLmM6MTYxMSBidWlsdGluL2xvZy5jOjE2MTQKIG1zZ2lkICJib3VuZGFyeSIKIG1zZ3N0ciAi0LPRgNCw0L3QuNGG0LAiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTYxMQorIzogYnVpbHRpbi9sb2cuYzoxNjEyCiBtc2dpZCAiYXR0YWNoIHRoZSBwYXRjaCIKIG1zZ3N0ciAi0L/RgNC40LrRgNC10L/Rj9C90LUg0L3QsCDQutGA0YrQv9C60LDRgtCwIgogCi0jOiBidWlsdGluL2xvZy5jOjE2MTQKKyM6IGJ1aWx0aW4vbG9nLmM6MTYxNQogbXNnaWQgImlubGluZSB0aGUgcGF0Y2giCiBtc2dzdHIgItCy0LrQu9GO0YfQstCw0L3QtSDQvdCwINC60YDRitC/0LrQsNGC0LAg0LIg0YLQtdC60YHRgtCwINC90LAg0L/QuNGB0LzQsNGC0LAiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTYxOAorIzogYnVpbHRpbi9sb2cuYzoxNjE5CiBtc2dpZCAiZW5hYmxlIG1lc3NhZ2UgdGhyZWFkaW5nLCBzdHlsZXM6IHNoYWxsb3csIGRlZXAiCiBtc2dzdHIgIiIKICLQuNC30L/QvtC70LfQstCw0L3QtSDQvdCwINC90LjRiNC60Lgg0LfQsCDRgdGK0L7QsdGJ0LXQvdC40Y/RgtCwLiAg0KHQotCY0JvRitGCINC1IOKAnnNoYWxsb3figJwgKNC/0LvQuNGC0YrQuikg0LjQu9C4ICIKICLigJ5kZWVw4oCcICjQtNGK0LvQsdC+0LopIgogCi0jOiBidWlsdGluL2xvZy5jOjE2MjAKKyM6IGJ1aWx0aW4vbG9nLmM6MTYyMQogbXNnaWQgInNpZ25hdHVyZSIKIG1zZ3N0ciAi0L/QvtC00L/QuNGBIgogCi0jOiBidWlsdGluL2xvZy5jOjE2MjEKKyM6IGJ1aWx0aW4vbG9nLmM6MTYyMgogbXNnaWQgImFkZCBhIHNpZ25hdHVyZSIKIG1zZ3N0ciAi0LTQvtCx0LDQstGP0L3QtSDQvdCwINC/0L7Qu9C1INC30LAg0L/QvtC00L/QuNGBIgogCi0jOiBidWlsdGluL2xvZy5jOjE2MjIKKyM6IGJ1aWx0aW4vbG9nLmM6MTYyMwogbXNnaWQgImJhc2UtY29tbWl0IgogbXNnc3RyICLQkdCQ0JfQntCS0J5f0J/QntCU0JDQktCQ0J3QlSIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjIzCisjOiBidWlsdGluL2xvZy5jOjE2MjQKIG1zZ2lkICJhZGQgcHJlcmVxdWlzaXRlIHRyZWUgaW5mbyB0byB0aGUgcGF0Y2ggc2VyaWVzIgogbXNnc3RyICLQtNC+0LHQsNCy0Y/QvdC1INC90LAg0L3QtdC+0LHRhdC+0LTQuNC80L7RgtC+INCR0JDQl9C+0LLQviDQtNGK0YDQstC+INC60YrQvCDQv9C+0YDQtdC00LjRhtCw0YLQsCDQvtGCINC60YDRitC/0LrQuCIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjI1CisjOiBidWlsdGluL2xvZy5jOjE2MjYKIG1zZ2lkICJhZGQgYSBzaWduYXR1cmUgZnJvbSBhIGZpbGUiCiBtc2dzdHIgItC00L7QsdCw0LLRj9C90LUg0L3QsCDQv9C+0LTQv9C40YEg0L7RgiDRhNCw0LnQuyIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjI2CisjOiBidWlsdGluL2xvZy5jOjE2MjcKIG1zZ2lkICJkb24ndCBwcmludCB0aGUgcGF0Y2ggZmlsZW5hbWVzIgogbXNnc3RyICLQsdC10Lcg0LjQt9Cy0LXQttC00LDQvdC1INC90LAg0LjQvNC10L3QsNGC0LAg0L3QsCDQutGA0YrQv9C60LjRgtC1IgogCi0jOiBidWlsdGluL2xvZy5jOjE2MjgKKyM6IGJ1aWx0aW4vbG9nLmM6MTYyOQogbXNnaWQgInNob3cgcHJvZ3Jlc3Mgd2hpbGUgZ2VuZXJhdGluZyBwYXRjaGVzIgogbXNnc3RyICLQuNC30LLQtdC20LTQsNC90LUg0L3QsCDQvdCw0L/RgNC10LTRitC60LAg0LLRitCyINGE0LDQt9Cw0YLQsCDQvdCwINGB0YrQt9C00LDQstCw0L3QtSDQvdCwINC60YDRitC/0LrQuNGC0LUiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTYzMAorIzogYnVpbHRpbi9sb2cuYzoxNjMxCiBtc2dpZCAic2hvdyBjaGFuZ2VzIGFnYWluc3QgPHJldj4gaW4gY292ZXIgbGV0dGVyIG9yIHNpbmdsZSBwYXRjaCIKIG1zZ3N0ciAiIgogItC/0L7QutCw0LfQstCw0L3QtSDQvdCwINC/0YDQvtC80LXQvdC40YLQtSDRgdC/0YDRj9C80L4g0JLQldCg0KHQuNGP0YLQsCDQsiDQv9GA0LjQtNGA0YPQttCw0LLQsNGJ0L7RgtC+INC/0LjRgdC80L4g0LjQu9C4INC10LTQuNC90YHRgtCy0LXQvdCwICIKICLQutGA0YrQv9C60LAiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTYzMworIzogYnVpbHRpbi9sb2cuYzoxNjM0CiBtc2dpZCAic2hvdyBjaGFuZ2VzIGFnYWluc3QgPHJlZnNwZWM+IGluIGNvdmVyIGxldHRlciBvciBzaW5nbGUgcGF0Y2giCiBtc2dzdHIgIiIKICLQv9C+0LrQsNC30LLQsNC90LUg0L3QsCDQv9GA0L7QvNC10L3QuNGC0LUg0YHQv9GA0Y/QvNC+INGD0LrQsNC30LDRgtC10LvRjyDQvdCwINCS0JXQoNCh0LjRj9GC0LAg0LIg0L/RgNC40LTRgNGD0LbQsNCy0LDRidC+0YLQviDQv9C40YHQvNC+ICIKICLQuNC70Lgg0LXQtNC40L3RgdGC0LLQtdC90LAg0LrRgNGK0L/QutCwIgogCi0jOiBidWlsdGluL2xvZy5jOjE2MzUKKyM6IGJ1aWx0aW4vbG9nLmM6MTYzNgogbXNnaWQgInBlcmNlbnRhZ2UgYnkgd2hpY2ggY3JlYXRpb24gaXMgd2VpZ2h0ZWQiCiBtc2dzdHIgItC/0YDQvtGG0LXQvdGCINC30LAg0L/RgNC10YLQtdCz0LvRj9C90LUg0L/RgNC4INC+0YbQtdC90LrQsCDQvdCwINGB0YrQt9C00LDQstCw0L3QtdGC0L4iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTcxMAorIzogYnVpbHRpbi9sb2cuYzoxNzExCiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgaWRlbnQgbGluZTogJXMiCiBtc2dzdHIgItCz0YDQtdGI0L3QsCDQuNC00LXQvdGC0LjRh9C90L7RgdGCOiAlcyIKIAotIzogYnVpbHRpbi9sb2cuYzoxNzI1CisjOiBidWlsdGluL2xvZy5jOjE3MjYKIG1zZ2lkICItbiBhbmQgLWsgYXJlIG11dHVhbGx5IGV4Y2x1c2l2ZSIKIG1zZ3N0ciAi0L7Qv9GG0LjQuNGC0LUg4oCeLW7igJwg0Lgg4oCeLWvigJwg0YHQsCDQvdC10YHRitCy0LzQtdGB0YLQuNC80LgiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTcyNworIzogYnVpbHRpbi9sb2cuYzoxNzI4CiBtc2dpZCAiLS1zdWJqZWN0LXByZWZpeC8tLXJmYyBhbmQgLWsgYXJlIG11dHVhbGx5IGV4Y2x1c2l2ZSIKIG1zZ3N0ciAi0L7Qv9GG0LjQuNGC0LUg4oCeLS1zdWJqZWN0LXByZWZpeOKAnC/igJ4tcmZj4oCcINC4IOKAni1r4oCcINGB0LAg0L3QtdGB0YrQstC80LXRgdGC0LjQvNC4IgogCi0jOiBidWlsdGluL2xvZy5jOjE3MzUKKyM6IGJ1aWx0aW4vbG9nLmM6MTczNgogbXNnaWQgIi0tbmFtZS1vbmx5IGRvZXMgbm90IG1ha2Ugc2Vuc2UiCiBtc2dzdHIgItC+0L/RhtC40Y/RgtCwIOKAni0tbmFtZS1vbmx54oCcINC1INC90LXRgdGK0LLQvNC10YHRgtC40LzQsCDRgSDQs9C10L3QtdGA0LjRgNCw0L3QtdGC0L4g0L3QsCDQutGA0YrQv9C60LgiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTczNworIzogYnVpbHRpbi9sb2cuYzoxNzM4CiBtc2dpZCAiLS1uYW1lLXN0YXR1cyBkb2VzIG5vdCBtYWtlIHNlbnNlIgogbXNnc3RyICLQvtC/0YbQuNGP0YLQsCDigJ4tLW5hbWUtc3RhdHVz4oCcINC1INC90LXRgdGK0LLQvNC10YHRgtC40LzQsCDRgSDQs9C10L3QtdGA0LjRgNCw0L3QtdGC0L4g0L3QsCDQutGA0YrQv9C60LgiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTczOQorIzogYnVpbHRpbi9sb2cuYzoxNzQwCiBtc2dpZCAiLS1jaGVjayBkb2VzIG5vdCBtYWtlIHNlbnNlIgogbXNnc3RyICLQvtC/0YbQuNGP0YLQsCDigJ4tLWNoZWNr4oCcINC1INC90LXRgdGK0LLQvNC10YHRgtC40LzQsCDRgSDQs9C10L3QtdGA0LjRgNCw0L3QtdGC0L4g0L3QsCDQutGA0YrQv9C60LgiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTc3MQorIzogYnVpbHRpbi9sb2cuYzoxNzczCiBtc2dpZCAic3RhbmRhcmQgb3V0cHV0LCBvciBkaXJlY3RvcnksIHdoaWNoIG9uZT8iCiBtc2dzdHIgIiIKICLQuNC30YXQvtC00YrRgiDQvNC+0LbQtSDQtNCwINC40LvQuCDRgdGC0LDQvdC00LDRgNGC0L3QuNGP0YIsINC40LvQuCDQtNCwINC1INCyINC00LjRgNC10LrRgtC+0YDQuNGPLCDQvdC+INC90LUg0Lgg0LTQstC10YLQtS4iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTg2MAorIzogYnVpbHRpbi9sb2cuYzoxODc3CiBtc2dpZCAiLS1pbnRlcmRpZmYgcmVxdWlyZXMgLS1jb3Zlci1sZXR0ZXIgb3Igc2luZ2xlIHBhdGNoIgogbXNnc3RyICIiCiAi0L7Qv9GG0LjRj9GC0LAg4oCeLS1pbnRlcmRpZmbigJwg0LjQt9C40YHQutCy0LAg0L7Qv9GG0LjRjyDigJ4tLWNvdmVyLWxldHRlcuKAnCDQuNC70Lgg0LXQtNC40L3RgdGC0LLQtdC90LAg0LrRgNGK0L/QutCwIgogCi0jOiBidWlsdGluL2xvZy5jOjE4NjQKKyM6IGJ1aWx0aW4vbG9nLmM6MTg4MQogbXNnaWQgIkludGVyZGlmZjoiCiBtc2dzdHIgItCg0LDQt9C70LjQutCwINCyINGA0LDQt9C70LjQutC40YLQtToiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTg2NQorIzogYnVpbHRpbi9sb2cuYzoxODgyCiAjLCBjLWZvcm1hdAogbXNnaWQgIkludGVyZGlmZiBhZ2FpbnN0IHYlZDoiCiBtc2dzdHIgItCg0LDQt9C70LjQutCwINCyINGA0LDQt9C70LjQutC40YLQtSDRgdC/0YDRj9C80L4gdiVkOiIKIAotIzogYnVpbHRpbi9sb2cuYzoxODcxCisjOiBidWlsdGluL2xvZy5jOjE4ODgKIG1zZ2lkICItLWNyZWF0aW9uLWZhY3RvciByZXF1aXJlcyAtLXJhbmdlLWRpZmYiCiBtc2dzdHIgItC+0L/RhtC40Y/RgtCwIOKAni0tY3JlYXRpb24tZmFjdG9y4oCcINC40LfQuNGB0LrQstCwINC+0L/RhtC40Y8g4oCeLS1yYW5nZS1kaWZm4oCcIgogCi0jOiBidWlsdGluL2xvZy5jOjE4NzUKKyM6IGJ1aWx0aW4vbG9nLmM6MTg5MgogbXNnaWQgIi0tcmFuZ2UtZGlmZiByZXF1aXJlcyAtLWNvdmVyLWxldHRlciBvciBzaW5nbGUgcGF0Y2giCiBtc2dzdHIgIiIKICLQvtC/0YbQuNGP0YLQsCDigJ4tLXJhbmdlLWRpZmbigJwg0LjQt9C40YHQutCy0LAg0L7Qv9GG0LjRjyDigJ4tLWNvdmVyLWxldHRlcuKAnCDQuNC70Lgg0LXQtNC40L3RgdGC0LLQtdC90LAg0LrRgNGK0L/QutCwIgogCi0jOiBidWlsdGluL2xvZy5jOjE4ODMKKyM6IGJ1aWx0aW4vbG9nLmM6MTkwMAogbXNnaWQgIlJhbmdlLWRpZmY6IgogbXNnc3RyICLQlNC40LDQv9Cw0LfQvtC90L3QsCDRgNCw0LfQu9C40LrQsDoiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTg4NAorIzogYnVpbHRpbi9sb2cuYzoxOTAxCiAjLCBjLWZvcm1hdAogbXNnaWQgIlJhbmdlLWRpZmYgYWdhaW5zdCB2JWQ6IgogbXNnc3RyICLQlNC40LDQv9Cw0LfQvtC90L3QsCDRgNCw0LfQu9C40LrQsCDRgdC/0YDRj9C80L4gdiVkOiIKIAotIzogYnVpbHRpbi9sb2cuYzoxODk1CisjOiBidWlsdGluL2xvZy5jOjE5MTIKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHJlYWQgc2lnbmF0dXJlIGZpbGUgJyVzJyIKIG1zZ3N0ciAi0YTQsNC50LvRitGCIOKAniVz4oCcINGBINC/0L7QtNC/0LjRgSDQvdC1INC80L7QttC1INC00LAg0LHRitC00LUg0L/RgNC+0YfQtdGC0LXQvSIKIAotIzogYnVpbHRpbi9sb2cuYzoxOTMxCisjOiBidWlsdGluL2xvZy5jOjE5NDgKIG1zZ2lkICJHZW5lcmF0aW5nIHBhdGNoZXMiCiBtc2dzdHIgItCh0YrQt9C00LDQstCw0L3QtSDQvdCwINC60YDRitC/0LrQuCIKIAotIzogYnVpbHRpbi9sb2cuYzoxOTc1CisjOiBidWlsdGluL2xvZy5jOjE5OTIKIG1zZ2lkICJmYWlsZWQgdG8gY3JlYXRlIG91dHB1dCBmaWxlcyIKIG1zZ3N0ciAi0L3QtdGD0YHQv9C10YjQvdC+INGB0YrQt9C00LDQstCw0L3QtSDQvdCwINC40LfRhdC+0LTQvdC4INGE0LDQudC70L7QstC1IgogCi0jOiBidWlsdGluL2xvZy5jOjIwMzQKKyM6IGJ1aWx0aW4vbG9nLmM6MjA1MQogbXNnaWQgImdpdCBjaGVycnkgWy12XSBbPHVwc3RyZWFtPiBbPGhlYWQ+IFs8bGltaXQ+XV1dIgogbXNnc3RyICJnaXQgY2hlcnJ5IFstdl0gW9Ce0KLQlNCQ0JvQldCn0JXQnV/QmtCb0J7QnSBb0JLQoNCq0KUgW9Cf0KDQldCU0JXQm11dXSIKIAotIzogYnVpbHRpbi9sb2cuYzoyMDg4CisjOiBidWlsdGluL2xvZy5jOjIxMDUKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkNvdWxkIG5vdCBmaW5kIGEgdHJhY2tlZCByZW1vdGUgYnJhbmNoLCBwbGVhc2Ugc3BlY2lmeSA8dXBzdHJlYW0+IG1hbnVhbGx5LlxuIgpAQCAtMTUyODMsNyArMTUzNjcsNyBAQAogbXNnaWQgImRvIG5vdCBwcmludCByZW1vdGUgVVJMIgogbXNnc3RyICLQsdC10Lcg0LjQt9Cy0LXQttC00LDQvdC1INC90LAg0LDQtNGA0LXRgdC40YLQtSDQvdCwINC+0YLQtNCw0LvQtdGH0LXQvdC40YLQtSDRhdGA0LDQvdC40LvQuNGJ0LAiCiAKLSM6IGJ1aWx0aW4vbHMtcmVtb3RlLmM6NjAgYnVpbHRpbi9scy1yZW1vdGUuYzo2MiBidWlsdGluL3JlYmFzZS5jOjE0NjQKKyM6IGJ1aWx0aW4vbHMtcmVtb3RlLmM6NjAgYnVpbHRpbi9scy1yZW1vdGUuYzo2MiBidWlsdGluL3JlYmFzZS5jOjE0ODgKIG1zZ2lkICJleGVjIgogbXNnc3RyICLQmtCe0JzQkNCd0JTQkCIKIApAQCAtMTUzOTQsMzMgKzE1NDc4LDMzIEBACiBtc2dpZCAiQXZhaWxhYmxlIGN1c3RvbSBzdHJhdGVnaWVzIGFyZToiCiBtc2dzdHIgItCU0L7Qv9GK0LvQvdC40YLQtdC70L3QuNGC0LUg0YHRgtGA0LDRgtC10LPQuNC4INGB0LA6IgogCi0jOiBidWlsdGluL21lcmdlLmM6MjQ0IGJ1aWx0aW4vcHVsbC5jOjE1MQorIzogYnVpbHRpbi9tZXJnZS5jOjI0NCBidWlsdGluL3B1bGwuYzoxNTIKIG1zZ2lkICJkbyBub3Qgc2hvdyBhIGRpZmZzdGF0IGF0IHRoZSBlbmQgb2YgdGhlIG1lcmdlIgogbXNnc3RyICLQsdC10Lcg0LjQt9Cy0LXQttC00LDQvdC1INC90LAg0YHRgtCw0YLQuNGB0YLQuNC60LDRgtCwINGB0LvQtdC0INC30LDQstGK0YDRiNCy0LDQvdC1INC90LAg0YHQu9C40LLQsNC90LUiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoyNDcgYnVpbHRpbi9wdWxsLmM6MTU0CisjOiBidWlsdGluL21lcmdlLmM6MjQ3IGJ1aWx0aW4vcHVsbC5jOjE1NQogbXNnaWQgInNob3cgYSBkaWZmc3RhdCBhdCB0aGUgZW5kIG9mIHRoZSBtZXJnZSIKIG1zZ3N0ciAi0LjQt9Cy0LXQttC00LDQvdC1INC90LAg0YHRgtCw0YLQuNGB0YLQuNC60LDRgtCwINGB0LvQtdC0INC30LDQstGK0YDRiNCy0LDQvdC1INC90LAg0YHQu9C40LLQsNC90LUiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoyNDggYnVpbHRpbi9wdWxsLmM6MTU3CisjOiBidWlsdGluL21lcmdlLmM6MjQ4IGJ1aWx0aW4vcHVsbC5jOjE1OAogbXNnaWQgIihzeW5vbnltIHRvIC0tc3RhdCkiCiBtc2dzdHIgIijQv9GB0LXQstC00L7QvdC40Lwg0L3QsCDigJ4tLXN0YXTigJwpIgogCi0jOiBidWlsdGluL21lcmdlLmM6MjUwIGJ1aWx0aW4vcHVsbC5jOjE2MAorIzogYnVpbHRpbi9tZXJnZS5jOjI1MCBidWlsdGluL3B1bGwuYzoxNjEKIG1zZ2lkICJhZGQgKGF0IG1vc3QgPG4+KSBlbnRyaWVzIGZyb20gc2hvcnRsb2cgdG8gbWVyZ2UgY29tbWl0IG1lc3NhZ2UiCiBtc2dzdHIgIiIKICLQtNC+0LHQsNCy0Y/QvdC1ICjQvdCwINC80LDQutGB0LjQvNGD0Lwg0YLQsNC60YrQsiDQkdCg0J7QmSkg0LfQsNC/0LjRgdC4INC+0YIg0YHRitC60YDQsNGC0LXQvdC40Y8g0LbRg9GA0L3QsNC7INCyINGB0YrQvtCx0YnQtdC90LjQtdGC0L4gIgogItC30LAg0L/QvtC00LDQstCw0L3QtSIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjI1MyBidWlsdGluL3B1bGwuYzoxNjYKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoyNTMgYnVpbHRpbi9wdWxsLmM6MTY3CiBtc2dpZCAiY3JlYXRlIGEgc2luZ2xlIGNvbW1pdCBpbnN0ZWFkIG9mIGRvaW5nIGEgbWVyZ2UiCiBtc2dzdHIgItGB0YrQt9C00LDQstCw0L3QtSDQvdCwINC10LTQvdC+INC/0L7QtNCw0LLQsNC90LUg0LLQvNC10YHRgtC+INC40LfQstGK0YDRiNCy0LDQvdC1INC90LAg0YHQu9C40LLQsNC90LUiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoyNTUgYnVpbHRpbi9wdWxsLmM6MTY5CisjOiBidWlsdGluL21lcmdlLmM6MjU1IGJ1aWx0aW4vcHVsbC5jOjE3MAogbXNnaWQgInBlcmZvcm0gYSBjb21taXQgaWYgdGhlIG1lcmdlIHN1Y2NlZWRzIChkZWZhdWx0KSIKIG1zZ3N0ciAi0LjQt9Cy0YrRgNGI0LLQsNC90LUg0L3QsCDQv9C+0LTQsNCy0LDQvdC1INC/0YDQuCDRg9GB0L/QtdGI0L3QviDRgdC70LjQstCw0L3QtSAo0YHRgtCw0L3QtNCw0YDRgtC90L4g0LTQtdC50YHRgtCy0LjQtSkiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoyNTcgYnVpbHRpbi9wdWxsLmM6MTcyCisjOiBidWlsdGluL21lcmdlLmM6MjU3IGJ1aWx0aW4vcHVsbC5jOjE3MwogbXNnaWQgImVkaXQgbWVzc2FnZSBiZWZvcmUgY29tbWl0dGluZyIKIG1zZ3N0ciAi0YDQtdC00LDQutGC0LjRgNCw0L3QtSDQvdCwINGB0YrQvtCx0YnQtdC90LjQtdGC0L4g0L/RgNC10LTQuCDQv9C+0LTQsNCy0LDQvdC1IgogCkBAIC0xNTQyOCwyOCArMTU1MTIsMjggQEAKIG1zZ2lkICJhbGxvdyBmYXN0LWZvcndhcmQgKGRlZmF1bHQpIgogbXNnc3RyICLQv9C+0LfQstC+0LvRj9Cy0LDQvdC1INC90LAg0L/RgNC10LLRitGA0YLQsNC90LUgKNGB0YLQsNC90LTQsNGA0YLQvdC+INC00LXQudGB0YLQstC40LUpIgogCi0jOiBidWlsdGluL21lcmdlLmM6MjYxIGJ1aWx0aW4vcHVsbC5jOjE3OQorIzogYnVpbHRpbi9tZXJnZS5jOjI2MSBidWlsdGluL3B1bGwuYzoxODAKIG1zZ2lkICJhYm9ydCBpZiBmYXN0LWZvcndhcmQgaXMgbm90IHBvc3NpYmxlIgogbXNnc3RyICLQv9GA0LXRg9GB0YLQsNC90L7QstGP0LLQsNC90LUsINCw0LrQviDQv9GA0LXQstGK0YDRgtCw0L3QtdGC0L4g0LUg0L3QtdCy0YrQt9C80L7QttC90L4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoyNjUgYnVpbHRpbi9wdWxsLmM6MTgyCisjOiBidWlsdGluL21lcmdlLmM6MjY1IGJ1aWx0aW4vcHVsbC5jOjE4MwogbXNnaWQgInZlcmlmeSB0aGF0IHRoZSBuYW1lZCBjb21taXQgaGFzIGEgdmFsaWQgR1BHIHNpZ25hdHVyZSIKIG1zZ3N0ciAi0L/RgNC+0LLQtdGA0LrQsCwg0YfQtSDRg9C60LDQt9Cw0L3QvtGC0L4g0L/QvtC00LDQstCw0L3QtSDQtSDRgSDQv9GA0LDQstC40LvQtdC9INC/0L7QtNC/0LjRgSDQvdCwIEdQRyIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjI2NiBidWlsdGluL25vdGVzLmM6Nzg3IGJ1aWx0aW4vcHVsbC5jOjE4NgotIzogYnVpbHRpbi9yZWJhc2UuYzo0OTIgYnVpbHRpbi9yZWJhc2UuYzoxNDc3IGJ1aWx0aW4vcmV2ZXJ0LmM6MTE0CisjOiBidWlsdGluL21lcmdlLmM6MjY2IGJ1aWx0aW4vbm90ZXMuYzo3ODcgYnVpbHRpbi9wdWxsLmM6MTg3CisjOiBidWlsdGluL3JlYmFzZS5jOjQ5MyBidWlsdGluL3JlYmFzZS5jOjE1MDEgYnVpbHRpbi9yZXZlcnQuYzoxMTQKIG1zZ2lkICJzdHJhdGVneSIKIG1zZ3N0ciAi0KHQotCg0JDQotCV0JPQmNCvIgogCi0jOiBidWlsdGluL21lcmdlLmM6MjY3IGJ1aWx0aW4vcHVsbC5jOjE4NworIzogYnVpbHRpbi9tZXJnZS5jOjI2NyBidWlsdGluL3B1bGwuYzoxODgKIG1zZ2lkICJtZXJnZSBzdHJhdGVneSB0byB1c2UiCiBtc2dzdHIgItCh0KLQoNCQ0KLQldCT0JjQryDQt9CwINGB0LvQuNCy0LDQvdC1LCDQutC+0Y/RgtC+INC00LAg0YHQtSDQv9C+0LvQt9Cy0LAiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoyNjggYnVpbHRpbi9wdWxsLmM6MTkwCisjOiBidWlsdGluL21lcmdlLmM6MjY4IGJ1aWx0aW4vcHVsbC5jOjE5MQogbXNnaWQgIm9wdGlvbj12YWx1ZSIKIG1zZ3N0ciAi0J7Qn9Cm0JjQrz3QodCi0J7QmdCd0J7QodCiIgogCi0jOiBidWlsdGluL21lcmdlLmM6MjY5IGJ1aWx0aW4vcHVsbC5jOjE5MQorIzogYnVpbHRpbi9tZXJnZS5jOjI2OSBidWlsdGluL3B1bGwuYzoxOTIKIG1zZ2lkICJvcHRpb24gZm9yIHNlbGVjdGVkIG1lcmdlIHN0cmF0ZWd5IgogbXNnc3RyICLQntCf0KbQmNCvINC30LAg0LjQt9Cx0YDQsNC90LDRgtCwINGB0YLRgNCw0YLQtdCz0LjRjyDQt9CwINGB0LvQuNCy0LDQvdC1IgogCkBAIC0xNTQ2OSwxNCArMTU1NTMsMTUgQEAKIG1zZ2lkICJjb250aW51ZSB0aGUgY3VycmVudCBpbi1wcm9ncmVzcyBtZXJnZSIKIG1zZ3N0ciAi0L/RgNC+0LTRitC70LbQsNCy0LDQvdC1INC90LAg0YLQtdC60YPRidC+0YLQviDRgdC70LjQstCw0L3QtSIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjI4NCBidWlsdGluL3B1bGwuYzoxOTgKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoyODQgYnVpbHRpbi9wdWxsLmM6MTk5CiBtc2dpZCAiYWxsb3cgbWVyZ2luZyB1bnJlbGF0ZWQgaGlzdG9yaWVzIgogbXNnc3RyICLQv9C+0LfQstC+0LvRj9Cy0LDQvdC1INC90LAg0YHQu9C40LLQsNC90LUg0L3QsCDQvdC10LfQsNCy0LjRgdC40LzQuCDQuNGB0YLQvtGA0LjQuCIKIAogIzogYnVpbHRpbi9tZXJnZS5jOjI5MAotbXNnaWQgInZlcmlmeSBjb21taXQtbXNnIGhvb2siCittc2dpZCAiYnlwYXNzIHByZS1tZXJnZS1jb21taXQgYW5kIGNvbW1pdC1tc2cgaG9va3MiCiBtc2dzdHIgIiIKLSLQv9GA0L7QstC10YDQutCwINC90LAg0LrRg9C60LDRgtCwINC/0YDQuCDQv9GA0L7QvNGP0L3QsCDQvdCwINGB0YrQvtCx0YnQtdC90LjQtdGC0L4g0L/RgNC4INC/0L7QtNCw0LLQsNC90LUgKGNvbW1pdC1tc2cpIgorItCx0LXQtyDQuNC30L/RitC70L3QtdC90LjQtSDQvdCwINC60YPQutC40YLQtSDQv9GA0LXQtNC4INC/0L7QtNCw0LLQsNC90LUg0Lgg0YHQu9C40LLQsNC90LUg0Lgg0L/RgNC4INC/0YDQvtC80Y/QvdCwINC90LAgIgorItGB0YrQvtCx0YnQtdC90LjQtdGC0L4g0LfQsCDQv9C+0LTQsNCy0LDQvdC1IChwcmUtbWVyZ2UtY29tbWl0INC4IGNvbW1pdC1tc2cpIgogCiAjOiBidWlsdGluL21lcmdlLmM6MzA3CiBtc2dpZCAiY291bGQgbm90IHJ1biBzdGFzaC4iCkBAIC0xNTUyMCwzMyArMTU2MDUsMzMgQEAKIG1zZ2lkICJCYWQgYnJhbmNoLiVzLm1lcmdlb3B0aW9ucyBzdHJpbmc6ICVzIgogbXNnc3RyICLQndC10L/RgNCw0LLQuNC70LXQvSDQvdC40Lcg0LfQsCDQvdCw0YHRgtGA0L7QudC60LDRgtCwIOKAnmJyYW5jaC4lcy5tZXJnZW9wdGlvbnPigJw6IOKAniVz4oCcIgogCi0jOiBidWlsdGluL21lcmdlLmM6NzA4CisjOiBidWlsdGluL21lcmdlLmM6NzA1CiBtc2dpZCAiTm90IGhhbmRsaW5nIGFueXRoaW5nIG90aGVyIHRoYW4gdHdvIGhlYWRzIG1lcmdlLiIKIG1zZ3N0ciAi0J/QvtC00LTRitGA0LbQsCDRgdC1INGB0LDQvNC+INGB0LvQuNCy0LDQvdC1INC90LAg0YLQvtGH0L3QviDQtNCy0LUg0LjRgdGC0L7RgNC40LguIgogCi0jOiBidWlsdGluL21lcmdlLmM6NzIyCisjOiBidWlsdGluL21lcmdlLmM6NzE5CiAjLCBjLWZvcm1hdAogbXNnaWQgIlVua25vd24gb3B0aW9uIGZvciBtZXJnZS1yZWN1cnNpdmU6IC1YJXMiCiBtc2dzdHIgItCd0LXQv9C+0LfQvdCw0YLQsCDQvtC/0YbQuNGPINC30LAg0YDQtdC60YPRgNGB0LjQstC90L7RgtC+INGB0LvQuNCy0LDQvdC1IOKAnm1lcmdlLXJlY3Vyc2l2ZeKAnDog4oCeLVglc+KAnCIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjczNworIzogYnVpbHRpbi9tZXJnZS5jOjczNAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gd3JpdGUgJXMiCiBtc2dzdHIgIuKAniVz4oCcINC90LUg0LzQvtC20LUg0LTQsCDQsdGK0LTQtSDQt9Cw0L/QuNGB0LDQvSIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjc4OQorIzogYnVpbHRpbi9tZXJnZS5jOjc4NgogIywgYy1mb3JtYXQKIG1zZ2lkICJDb3VsZCBub3QgcmVhZCBmcm9tICclcyciCiBtc2dzdHIgItCe0YIg4oCeJXPigJwg0L3QtSDQvNC+0LbQtSDQtNCwINGB0LUg0YfQtdGC0LUiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzo3OTgKKyM6IGJ1aWx0aW4vbWVyZ2UuYzo3OTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiTm90IGNvbW1pdHRpbmcgbWVyZ2U7IHVzZSAnZ2l0IGNvbW1pdCcgdG8gY29tcGxldGUgdGhlIG1lcmdlLlxuIgogbXNnc3RyICIiCiAi0KHQu9C40LLQsNC90LXRgtC+INC90Y/QvNCwINC00LAg0LHRitC00LUg0L/QvtC00LDQtNC10L3Qvi4gINCX0LAg0LfQsNCy0YrRgNGI0LLQsNC90LXRgtC+INC80YMg0Lgg0L/QvtC00LDQstCw0L3QtdGC0L4g0LzRgyAiCiAi0LjQt9C/0L7Qu9C30LLQsNC50YLQtSDQutC+0LzQsNC90LTQsNGC0LAg4oCeZ2l0IGNvbW1pdOKAnC5cbiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjgwNAorIzogYnVpbHRpbi9tZXJnZS5jOjgwMQogbXNnaWQgIiIKICJQbGVhc2UgZW50ZXIgYSBjb21taXQgbWVzc2FnZSB0byBleHBsYWluIHdoeSB0aGlzIG1lcmdlIGlzIG5lY2Vzc2FyeSxcbiIKICJlc3BlY2lhbGx5IGlmIGl0IG1lcmdlcyBhbiB1cGRhdGVkIHVwc3RyZWFtIGludG8gYSB0b3BpYyBicmFuY2guXG4iCkBAIC0xNTU1NSwxMSArMTU2NDAsMTEgQEAKICLQkiDRgdGK0L7QsdGJ0LXQvdC40LXRgtC+INC/0YDQuCDQv9C+0LTQsNCy0LDQvdC1INC00L7QsdCw0LLQtdGC0LUg0LjQvdGE0L7RgNC80LDRhtC40Y8g0LfQsCDQv9GA0LjRh9C40L3QsNGC0LAg0LfQsFxuIgogItGB0LvQuNCy0LDQvdC10YLQviwg0L7RgdC+0LHQtdC90L4g0LDQutC+INGB0LvQuNCy0LDRgtC1INC+0LHQvdC+0LLQtdC9INC+0YLQtNCw0LvQtdGH0LXQvSDQutC70L7QvSDQsiDRgtC10LzQsNGC0LjRh9C10L0g0LrQu9C+0L0uXG4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzo4MDkKKyM6IGJ1aWx0aW4vbWVyZ2UuYzo4MDYKIG1zZ2lkICJBbiBlbXB0eSBtZXNzYWdlIGFib3J0cyB0aGUgY29tbWl0LlxuIgogbXNnc3RyICLQn9GA0LDQt9C90L4g0YHRitC+0LHRidC10L3QuNC1INC/0YDQtdC00L7RgtCy0YDQsNGC0Y/QstCwINC/0L7QtNCw0LLQsNC90LXRgtC+LlxuIgogCi0jOiBidWlsdGluL21lcmdlLmM6ODEyCisjOiBidWlsdGluL21lcmdlLmM6ODA5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJMaW5lcyBzdGFydGluZyB3aXRoICclYycgd2lsbCBiZSBpZ25vcmVkLCBhbmQgYW4gZW1wdHkgbWVzc2FnZSBhYm9ydHNcbiIKQEAgLTE1NTY4LDc2ICsxNTY1Myw3NiBAQAogItCg0LXQtNC+0LLQtdGC0LUsINC60L7QuNGC0L4g0LfQsNC/0L7Rh9Cy0LDRgiDRgSDigJ4lY+KAnCwg0YnQtSDQsdGK0LTQsNGCINC/0YDQvtC/0YPRgdC90LDRgtC4LCDQsCDQv9GA0LDQt9C90L5cbiIKICLRgdGK0L7QsdGJ0LXQvdC40LUg0L/RgNC10YPRgdGC0LDQvdC+0LLRj9Cy0LAg0L/QvtC00LDQstCw0L3QtdGC0L4uXG4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzo4NTMKKyM6IGJ1aWx0aW4vbWVyZ2UuYzo4NjIKIG1zZ2lkICJFbXB0eSBjb21taXQgbWVzc2FnZS4iCiBtc2dzdHIgItCf0YDQsNC30L3QviDRgdGK0L7QsdGJ0LXQvdC40LUg0L/RgNC4INC/0L7QtNCw0LLQsNC90LUuIgogCi0jOiBidWlsdGluL21lcmdlLmM6ODcyCisjOiBidWlsdGluL21lcmdlLmM6ODc3CiAjLCBjLWZvcm1hdAogbXNnaWQgIldvbmRlcmZ1bC5cbiIKIG1zZ3N0ciAi0J/RitGA0LLQuNGP0YIg0LXRgtCw0L8g0L3QsCDRgdC70LjQstCw0L3QtdGC0L4g0LfQsNCy0YrRgNGI0LguXG4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzo5MzMKKyM6IGJ1aWx0aW4vbWVyZ2UuYzo5MzgKICMsIGMtZm9ybWF0CiBtc2dpZCAiQXV0b21hdGljIG1lcmdlIGZhaWxlZDsgZml4IGNvbmZsaWN0cyBhbmQgdGhlbiBjb21taXQgdGhlIHJlc3VsdC5cbiIKIG1zZ3N0ciAiIgogItCd0LXRg9GB0L/QtdGI0L3QviDQsNCy0YLQvtC80LDRgtC40YfQvdC+INGB0LvQuNCy0LDQvdC1IOKAlCDQutC+0YDQuNCz0LjRgNCw0LnRgtC1INC60L7QvdGE0LvQuNC60YLQuNGC0LUg0Lgg0L/QvtC00LDQudGC0LUgIgogItGA0LXQt9GD0LvRgtCw0YLQsC5cbiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjk3MgorIzogYnVpbHRpbi9tZXJnZS5jOjk3NwogbXNnaWQgIk5vIGN1cnJlbnQgYnJhbmNoLiIKIG1zZ3N0ciAi0J3Rj9C80LAg0YLQtdC60YPRiSDQutC70L7QvS4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzo5NzQKKyM6IGJ1aWx0aW4vbWVyZ2UuYzo5NzkKIG1zZ2lkICJObyByZW1vdGUgZm9yIHRoZSBjdXJyZW50IGJyYW5jaC4iCiBtc2dzdHIgItCi0LXQutGD0YnQuNGP0YIg0LrQu9C+0L0g0L3QtSDRgdC70LXQtNC4INC90LjQutC+0LkuIgogCi0jOiBidWlsdGluL21lcmdlLmM6OTc2CisjOiBidWlsdGluL21lcmdlLmM6OTgxCiBtc2dpZCAiTm8gZGVmYXVsdCB1cHN0cmVhbSBkZWZpbmVkIGZvciB0aGUgY3VycmVudCBicmFuY2guIgogbXNnc3RyICLQotC10LrRg9GJ0LjRj9GCINC60LvQvtC9INC90LUg0YHQu9C10LTQuCDQvdC40LrQvtC5INC60LvQvtC9LiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjk4MQorIzogYnVpbHRpbi9tZXJnZS5jOjk4NgogIywgYy1mb3JtYXQKIG1zZ2lkICJObyByZW1vdGUtdHJhY2tpbmcgYnJhbmNoIGZvciAlcyBmcm9tICVzIgogbXNnc3RyICLQndC40LrQvtC5INC60LvQvtC9INC90LUg0YHQu9C10LTQuCDQutC70L7QvdCwIOKAniVz4oCcINC+0YIg0YXRgNCw0L3QuNC70LjRidC10YLQviDigJ4lc+KAnCIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjEwMzgKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxMDQzCiAjLCBjLWZvcm1hdAogbXNnaWQgIkJhZCB2YWx1ZSAnJXMnIGluIGVudmlyb25tZW50ICclcyciCiBtc2dzdHIgItCd0LXQv9GA0LDQstC40LvQvdCwINGB0YLQvtC50L3QvtGB0YIg4oCeJXPigJwg0LIg0YHRgNC10LTQsNGC0LAg4oCeJXPigJwiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxMTQxCisjOiBidWlsdGluL21lcmdlLmM6MTE0NgogIywgYy1mb3JtYXQKIG1zZ2lkICJub3Qgc29tZXRoaW5nIHdlIGNhbiBtZXJnZSBpbiAlczogJXMiCiBtc2dzdHIgItC90LUg0LzQvtC20LUg0LTQsCDRgdC1INGB0LvQtdC1INCyIOKAniVz4oCcOiAlcyIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjExNzUKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxMTgwCiBtc2dpZCAibm90IHNvbWV0aGluZyB3ZSBjYW4gbWVyZ2UiCiBtc2dzdHIgItC90LUg0LzQvtC20LUg0LTQsCDRgdC1INGB0LvQtdC1IgogCi0jOiBidWlsdGluL21lcmdlLmM6MTI3OAorIzogYnVpbHRpbi9tZXJnZS5jOjEyODMKIG1zZ2lkICItLWFib3J0IGV4cGVjdHMgbm8gYXJndW1lbnRzIgogbXNnc3RyICLQvtC/0YbQuNGP0YLQsCDigJ4tLWFib3J04oCcINC90LUg0L/RgNC40LXQvNCwINCw0YDQs9GD0LzQtdC90YLQuCIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjEyODIKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxMjg3CiBtc2dpZCAiVGhlcmUgaXMgbm8gbWVyZ2UgdG8gYWJvcnQgKE1FUkdFX0hFQUQgbWlzc2luZykuIgogbXNnc3RyICIiCiAi0J3QtSDQvNC+0LbQtSDQtNCwINC/0YDQtdGD0YHRgtCw0L3QvtCy0LjRgtC1INGB0LvQuNCy0LDQvdC1LCDQt9Cw0YnQvtGC0L4g0LIg0LzQvtC80LXQvdGC0LAg0L3QtSDRgdC1INC40LfQstGK0YDRiNCy0LAg0YLQsNC60L7QstCwICIKICIo0LvQuNC/0YHQstCwINGD0LrQsNC30LDRgtC10Lsg4oCeTUVSR0VfSEVBROKAnCkuIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTI5MQorIzogYnVpbHRpbi9tZXJnZS5jOjEyOTYKIG1zZ2lkICItLXF1aXQgZXhwZWN0cyBubyBhcmd1bWVudHMiCiBtc2dzdHIgItC+0L/RhtC40Y/RgtCwIOKAni0tcXVpdOKAnCDQvdC1INC/0YDQuNC10LzQsCDQsNGA0LPRg9C80LXQvdGC0LgiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzA0CisjOiBidWlsdGluL21lcmdlLmM6MTMwOQogbXNnaWQgIi0tY29udGludWUgZXhwZWN0cyBubyBhcmd1bWVudHMiCiBtc2dzdHIgItC+0L/RhtC40Y/RgtCwIOKAni0tY29udGludWXigJwg0L3QtSDQv9GA0LjQtdC80LAg0LDRgNCz0YPQvNC10L3RgtC4IgogCi0jOiBidWlsdGluL21lcmdlLmM6MTMwOAorIzogYnVpbHRpbi9tZXJnZS5jOjEzMTMKIG1zZ2lkICJUaGVyZSBpcyBubyBtZXJnZSBpbiBwcm9ncmVzcyAoTUVSR0VfSEVBRCBtaXNzaW5nKS4iCiBtc2dzdHIgItCSINC80L7QvNC10L3RgtCwINC90LUg0YHQtSDQuNC30LLRitGA0YjQstCwINGB0LvQuNCy0LDQvdC1ICjQu9C40L/RgdCy0LAg0YPQutCw0LfQsNGC0LXQuyDigJ5NRVJHRV9IRUFE4oCcKS4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzI0CisjOiBidWlsdGluL21lcmdlLmM6MTMyOQogbXNnaWQgIiIKICJZb3UgaGF2ZSBub3QgY29uY2x1ZGVkIHlvdXIgbWVyZ2UgKE1FUkdFX0hFQUQgZXhpc3RzKS5cbiIKICJQbGVhc2UsIGNvbW1pdCB5b3VyIGNoYW5nZXMgYmVmb3JlIHlvdSBtZXJnZS4iCkBAIC0xNTY0NSw3ICsxNTczMCw3IEBACiAi0J3QtSDRgdGC0LUg0LfQsNCy0YrRgNGI0LjQu9C4INGB0LvQuNCy0LDQvdC1LiAgKNCj0LrQsNC30LDRgtC10LvRj9GCIOKAnk1FUkdFX0hFQUTigJwg0YHRitGJ0LXRgdGC0LLRg9Cy0LApLlxuIgogItCf0L7QtNCw0LnRgtC1INC/0YDQvtC80LXQvdC40YLQtSDRgdC4LCDQv9GA0LXQtNC4INC00LAg0LfQsNC/0L7Rh9C90LXRgtC1INC90L7QstC+INGB0LvQuNCy0LDQvdC1LiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjEzMzEKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzM2CiBtc2dpZCAiIgogIllvdSBoYXZlIG5vdCBjb25jbHVkZWQgeW91ciBjaGVycnktcGljayAoQ0hFUlJZX1BJQ0tfSEVBRCBleGlzdHMpLlxuIgogIlBsZWFzZSwgY29tbWl0IHlvdXIgY2hhbmdlcyBiZWZvcmUgeW91IG1lcmdlLiIKQEAgLTE1NjUzLDEwMyArMTU3MzgsMTAzIEBACiAi0J3QtSDRgdGC0LUg0LfQsNCy0YrRgNGI0LjQu9C4INC+0YLQsdC40YDQsNC90LUg0L3QsCDQv9C+0LTQsNCy0LDQvdC1ICjRg9C60LDQt9Cw0YLQtdC70Y/RgiDigJ5DSEVSUllfUElDS19IRUFE4oCcXG4iCiAi0YHRitGJ0LXRgdGC0LLRg9Cy0LApLiAg0J/QvtC00LDQudGC0LUg0L/RgNC+0LzQtdC90LjRgtC1INGB0LgsINC/0YDQtdC00Lgg0LTQsCDQt9Cw0L/QvtGH0L3QtdGC0LUg0L3QvtCy0L4g0YHQu9C40LLQsNC90LUuIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTMzNAorIzogYnVpbHRpbi9tZXJnZS5jOjEzMzkKIG1zZ2lkICJZb3UgaGF2ZSBub3QgY29uY2x1ZGVkIHlvdXIgY2hlcnJ5LXBpY2sgKENIRVJSWV9QSUNLX0hFQUQgZXhpc3RzKS4iCiBtc2dzdHIgIiIKICLQndC1INGB0YLQtSDQt9Cw0LLRitGA0YjQuNC70Lgg0L7RgtCx0LjRgNCw0L3QtSDQvdCwINC/0L7QtNCw0LLQsNC90LUgKNGD0LrQsNC30LDRgtC10LvRj9GCIOKAnkNIRVJSWV9QSUNLX0hFQUTigJxcbiIKICLRgdGK0YnQtdGB0YLQstGD0LLQsCkuIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTM0OAorIzogYnVpbHRpbi9tZXJnZS5jOjEzNTMKIG1zZ2lkICJZb3UgY2Fubm90IGNvbWJpbmUgLS1zcXVhc2ggd2l0aCAtLW5vLWZmLiIKIG1zZ3N0ciAi0J7Qv9GG0LjRj9GC0LAg4oCeLS1zcXVhc2jigJwg0LUg0L3QtdGB0YrQstC80LXRgdGC0LjQvNCwINGBIOKAni0tbm8tZmbigJwuIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTM1MAorIzogYnVpbHRpbi9tZXJnZS5jOjEzNTUKIG1zZ2lkICJZb3UgY2Fubm90IGNvbWJpbmUgLS1zcXVhc2ggd2l0aCAtLWNvbW1pdC4iCiBtc2dzdHIgItCe0L/RhtC40Y/RgtCwIOKAni0tc3F1YXNo4oCcINC1INC90LXRgdGK0LLQvNC10YHRgtC40LzQsCDRgSDigJ4tLWNvbW1pdOKAnC4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzY2CisjOiBidWlsdGluL21lcmdlLmM6MTM3MQogbXNnaWQgIk5vIGNvbW1pdCBzcGVjaWZpZWQgYW5kIG1lcmdlLmRlZmF1bHRUb1Vwc3RyZWFtIG5vdCBzZXQuIgogbXNnc3RyICIiCiAi0J3QtSDQtSDRg9C60LDQt9Cw0L3QviDQv9C+0LTQsNCy0LDQvdC1INC4INC90LDRgdGC0YDQvtC50LrQsNGC0LAg4oCebWVyZ2UuZGVmYXVsdFRvVXBzdHJlYW3igJwg0L3QtSDQtSDQt9Cw0LTQsNC00LXQvdCwLiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjEzODMKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzg4CiBtc2dpZCAiU3F1YXNoIGNvbW1pdCBpbnRvIGVtcHR5IGhlYWQgbm90IHN1cHBvcnRlZCB5ZXQiCiBtc2dzdHIgItCS0LrQsNGA0LLQsNC90LUg0L3QsCDQv9C+0LTQsNCy0LDQvdC1INCy0YrQsiDQstGA0YrRhSDQsdC10Lcg0LjRgdGC0L7RgNC40Y8g0LLRgdC1INC+0YnQtSDQvdC1INGB0LUg0L/QvtC00LTRitGA0LbQsCIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjEzODUKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzkwCiBtc2dpZCAiTm9uLWZhc3QtZm9yd2FyZCBjb21taXQgZG9lcyBub3QgbWFrZSBzZW5zZSBpbnRvIGFuIGVtcHR5IGhlYWQiCiBtc2dzdHIgIiIKICLQn9C+0L3QtdC20LUg0LLRitGA0YXRitGCINC1INCx0LXQtyDQuNGB0YLQvtGA0LjRjywg0LLRgdC40YfQutC4INGB0LvQuNCy0LDQvdC40Y8g0YHQsCDQv9GA0LXQstGK0YDRgtCw0L3QuNGPLCDQvdC1INC80L7QttC1INC00LAg0YHQtSAiCiAi0LjQt9Cy0YrRgNGI0Lgg0YHRitGJ0LjQvdGB0LrQviDRgdC70LjQstCw0L3QtSDQuNC30LjRgdC60LLQsNC90L4g0L7RgiDQvtC/0YbQuNGP0YLQsCDigJ4tLW5vLWZm4oCcIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTM5MAorIzogYnVpbHRpbi9tZXJnZS5jOjEzOTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgLSBub3Qgc29tZXRoaW5nIHdlIGNhbiBtZXJnZSIKIG1zZ3N0ciAi4oCeJXPigJwg4oCUINC90LUg0LUg0L3QtdGJ0L4sINC60L7QtdGC0L4g0LzQvtC20LUg0LTQsCDRgdC1INGB0LvQtdC1IgogCi0jOiBidWlsdGluL21lcmdlLmM6MTM5MgorIzogYnVpbHRpbi9tZXJnZS5jOjEzOTcKIG1zZ2lkICJDYW4gbWVyZ2Ugb25seSBleGFjdGx5IG9uZSBjb21taXQgaW50byBlbXB0eSBoZWFkIgogbXNnc3RyICLQnNC+0LbQtdGC0LUg0LTQsCDRgdC70LXQtdGC0LUg0YLQvtGH0L3QviDQtdC00L3QviDQv9C+0LTQsNCy0LDQvdC1INCy0YrQsiDQstGA0YrRhSDQsdC10Lcg0LjRgdGC0L7RgNC40Y8iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxNDcxCisjOiBidWlsdGluL21lcmdlLmM6MTQ3NgogbXNnaWQgInJlZnVzaW5nIHRvIG1lcmdlIHVucmVsYXRlZCBoaXN0b3JpZXMiCiBtc2dzdHIgItC90LXQt9Cw0LLQuNGB0LjQvNC4INC40YHRgtC+0YDQuNC4INC90LUg0LzQvtC20LUg0LTQsCDRgdC1INGB0LvQtdGP0YIiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxNDgwCisjOiBidWlsdGluL21lcmdlLmM6MTQ4NQogbXNnaWQgIkFscmVhZHkgdXAgdG8gZGF0ZS4iCiBtc2dzdHIgItCS0LXRh9C1INC1INC+0LHQvdC+0LLQtdC90L4uIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTQ5MAorIzogYnVpbHRpbi9tZXJnZS5jOjE0OTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiVXBkYXRpbmcgJXMuLiVzXG4iCiBtc2dzdHIgItCe0LHQvdC+0LLRj9Cy0LDQvdC1IOKAniVzLi4lc+KAnFxuIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTUzMgorIzogYnVpbHRpbi9tZXJnZS5jOjE1MzcKICMsIGMtZm9ybWF0CiBtc2dpZCAiVHJ5aW5nIHJlYWxseSB0cml2aWFsIGluLWluZGV4IG1lcmdlLi4uXG4iCiBtc2dzdHIgItCf0YDQvtCx0LAg0YHRitGBINGB0LvQuNCy0LDQvdC1INCyINGA0LDQvNC60LjRgtC1INC90LAg0LjQvdC00LXQutGB0LDigKZcbiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjE1MzkKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxNTQ0CiAjLCBjLWZvcm1hdAogbXNnaWQgIk5vcGUuXG4iCiBtc2dzdHIgItCd0LXRg9GB0L/QtdGI0L3QviDRgdC70LjQstCw0L3QtS5cbiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjE1NjQKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxNTY5CiBtc2dpZCAiQWxyZWFkeSB1cCB0byBkYXRlLiBZZWVhaCEiCiBtc2dzdHIgItCS0LXRh9C1INC1INC+0LHQvdC+0LLQtdC90L4hIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTU3MAorIzogYnVpbHRpbi9tZXJnZS5jOjE1NzUKIG1zZ2lkICJOb3QgcG9zc2libGUgdG8gZmFzdC1mb3J3YXJkLCBhYm9ydGluZy4iCiBtc2dzdHIgItCd0LUg0LzQvtC20LUg0LTQsCDRgdC1INC40LfQstGK0YDRiNC4INC/0YDQtdCy0YrRgNGC0LDQvdC1LCDQv9GA0LXRg9GB0YLQsNC90L7QstGP0LLQsNC90LUg0L3QsCDQtNC10LnRgdGC0LLQuNC10YLQvi4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxNTkzIGJ1aWx0aW4vbWVyZ2UuYzoxNjU4CisjOiBidWlsdGluL21lcmdlLmM6MTU5OCBidWlsdGluL21lcmdlLmM6MTY2MwogIywgYy1mb3JtYXQKIG1zZ2lkICJSZXdpbmRpbmcgdGhlIHRyZWUgdG8gcHJpc3RpbmUuLi5cbiIKIG1zZ3N0ciAi0J/RgNC40LLQtdC20LTQsNC90LUg0L3QsCDQtNGK0YDQstC+0YLQviDQutGK0Lwg0L/RitGA0LLQvtC90LDRh9Cw0LvQvdC+0YLQvuKAplxuIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTU5NworIzogYnVpbHRpbi9tZXJnZS5jOjE2MDIKICMsIGMtZm9ybWF0CiBtc2dpZCAiVHJ5aW5nIG1lcmdlIHN0cmF0ZWd5ICVzLi4uXG4iCiBtc2dzdHIgItCf0YDQvtCx0LLQsNC90LUg0YHRitGBINGB0YLRgNCw0YLQtdCz0LjRj9GC0LAg0LfQsCDRgdC70LjQstCw0L3QtSDigJ4lc+KAnOKAplxuIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTY0OQorIzogYnVpbHRpbi9tZXJnZS5jOjE2NTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiTm8gbWVyZ2Ugc3RyYXRlZ3kgaGFuZGxlZCB0aGUgbWVyZ2UuXG4iCiBtc2dzdHIgItCd0LjQutC+0Y8g0YHRgtGA0LDRgtC10LPQuNGPINC30LAg0YHQu9C40LLQsNC90LUg0L3QtSDQvNC+0LbQtSDQtNCwINC40LfQstGK0YDRiNC4INGB0LvQuNCy0LDQvdC10YLQvi5cbiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjE2NTEKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxNjU2CiAjLCBjLWZvcm1hdAogbXNnaWQgIk1lcmdlIHdpdGggc3RyYXRlZ3kgJXMgZmFpbGVkLlxuIgogbXNnc3RyICLQndC10YPRgdC/0LXRiNC90L4g0YHQu9C40LLQsNC90LUg0YHRitGBINGB0YLRgNCw0YLQtdCz0LjRjyDigJ4lc+KAnC5cbiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjE2NjAKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxNjY1CiAjLCBjLWZvcm1hdAogbXNnaWQgIlVzaW5nIHRoZSAlcyB0byBwcmVwYXJlIHJlc29sdmluZyBieSBoYW5kLlxuIgogbXNnc3RyICIiCiAi0J/QvtC70LfQstCwINGB0LUg0YHRgtGA0LDRgtC10LPQuNGP0YLQsCDigJ4lc+KAnCwg0LrQvtGP0YLQviDRidC1INC/0L7QtNCz0L7RgtCy0Lgg0LTRitGA0LLQvtGC0L4g0LfQsCDQutC+0YDQuNCz0LjRgNCw0L3QtSDQvdCwICIKICLRgNGK0LrQsC5cbiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjE2NzIKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxNjc3CiAjLCBjLWZvcm1hdAogbXNnaWQgIkF1dG9tYXRpYyBtZXJnZSB3ZW50IHdlbGw7IHN0b3BwZWQgYmVmb3JlIGNvbW1pdHRpbmcgYXMgcmVxdWVzdGVkXG4iCiBtc2dzdHIgIiIKQEAgLTE1ODM3LDMzICsxNTkyMiwzMyBAQAogbXNnaWQgInNldCBsYWJlbHMgZm9yIGZpbGUxL29yaWctZmlsZS9maWxlMiIKIG1zZ3N0ciAi0LfQsNC00LDQstCw0L3QtSDQvdCwINC10YLQuNC60LXRgtC4INC30LAg0KTQkNCZ0JtfMS/QntCg0JjQk9CY0J3QkNCbL9Ck0JDQmdCbXzIiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UtcmVjdXJzaXZlLmM6NDYKKyM6IGJ1aWx0aW4vbWVyZ2UtcmVjdXJzaXZlLmM6NDcKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5rbm93biBvcHRpb24gJXMiCiBtc2dzdHIgItC90LXQv9C+0LfQvdCw0YLQsCDQvtC/0YbQuNGPOiDigJ4lc+KAnCIKIAotIzogYnVpbHRpbi9tZXJnZS1yZWN1cnNpdmUuYzo1MgorIzogYnVpbHRpbi9tZXJnZS1yZWN1cnNpdmUuYzo1MwogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcGFyc2Ugb2JqZWN0ICclcyciCiBtc2dzdHIgItC90LXRg9GB0L/QtdGI0LXQvSDQsNC90LDQu9C40Lcg0L3QsCDQvtCx0LXQutGC0LAg4oCeJXPigJwiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UtcmVjdXJzaXZlLmM6NTYKKyM6IGJ1aWx0aW4vbWVyZ2UtcmVjdXJzaXZlLmM6NTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IGhhbmRsZSBtb3JlIHRoYW4gJWQgYmFzZS4gSWdub3JpbmcgJXMuIgogbXNnaWRfcGx1cmFsICJjYW5ub3QgaGFuZGxlIG1vcmUgdGhhbiAlZCBiYXNlcy4gSWdub3JpbmcgJXMuIgogbXNnc3RyWzBdICLQvdC1INGB0LUg0L/QvtC00LTRitGA0LbQsCDQv9C+0LLQtdGH0LUg0L7RgiAlZCDQsdCw0LfQsC4gIOKAniVz4oCcINGB0LUg0L/RgNC10YHQutCw0YfQsC4iCiBtc2dzdHJbMV0gItC90LUg0YHQtSDQv9C+0LTQtNGK0YDQttCw0YIg0L/QvtCy0LXRh9C1INC+0YIgJWQg0LHQsNC30LguICDigJ4lc+KAnCDRgdC1INC/0YDQtdGB0LrQsNGH0LAuIgogCi0jOiBidWlsdGluL21lcmdlLXJlY3Vyc2l2ZS5jOjY0CisjOiBidWlsdGluL21lcmdlLXJlY3Vyc2l2ZS5jOjY1CiBtc2dpZCAibm90IGhhbmRsaW5nIGFueXRoaW5nIG90aGVyIHRoYW4gdHdvIGhlYWRzIG1lcmdlLiIKIG1zZ3N0ciAi0L/QvtC00LTRitGA0LbQsCDRgdC1INGB0LDQvNC+INGB0LvQuNCy0LDQvdC1INC90LAg0YLQvtGH0L3QviDQtNCy0LUg0LjRgdGC0L7RgNC40LguIgogCi0jOiBidWlsdGluL21lcmdlLXJlY3Vyc2l2ZS5jOjcwIGJ1aWx0aW4vbWVyZ2UtcmVjdXJzaXZlLmM6NzIKKyM6IGJ1aWx0aW4vbWVyZ2UtcmVjdXJzaXZlLmM6NzQgYnVpbHRpbi9tZXJnZS1yZWN1cnNpdmUuYzo3NgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcmVzb2x2ZSByZWYgJyVzJyIKIG1zZ3N0ciAi0YPQutCw0LfQsNGC0LXQu9GP0YIg4oCeJXPigJwg0L3QtSDQvNC+0LbQtSDQtNCwINCx0YrQtNC1INC40LfRgtGA0LjRgiIKIAotIzogYnVpbHRpbi9tZXJnZS1yZWN1cnNpdmUuYzo3OAorIzogYnVpbHRpbi9tZXJnZS1yZWN1cnNpdmUuYzo4MgogIywgYy1mb3JtYXQKIG1zZ2lkICJNZXJnaW5nICVzIHdpdGggJXNcbiIKIG1zZ3N0ciAi0KHQu9C40LLQsNC90LUg0L3QsCDigJ4lc+KAnCDRgSDigJ4lc+KAnFxuIgpAQCAtMTYwMDgsNTQgKzE2MDkzLDU0IEBACiBtc2dpZCAiUmVuYW1pbmcgJXMgdG8gJXNcbiIKIG1zZ3N0ciAi0J/RgNC10LjQvNC10L3Rg9Cy0LDQvdC1INC90LAg4oCeJXPigJwg0L3QsCDigJ4lc+KAnFxuIgogCi0jOiBidWlsdGluL212LmM6Mjc3IGJ1aWx0aW4vcmVtb3RlLmM6NzE3IGJ1aWx0aW4vcmVwYWNrLmM6NTEwCisjOiBidWlsdGluL212LmM6Mjc3IGJ1aWx0aW4vcmVtb3RlLmM6NzE3IGJ1aWx0aW4vcmVwYWNrLmM6NTExCiAjLCBjLWZvcm1hdAogbXNnaWQgInJlbmFtaW5nICclcycgZmFpbGVkIgogbXNnc3RyICLQvdC10YPRgdC/0LXRiNC90L4g0L/RgNC10LjQvNC10L3Rg9Cy0LDQvdC1INC90LAg4oCeJXPigJwiCiAKLSM6IGJ1aWx0aW4vbmFtZS1yZXYuYzozNTIKKyM6IGJ1aWx0aW4vbmFtZS1yZXYuYzozNTYKIG1zZ2lkICJnaXQgbmFtZS1yZXYgWzxvcHRpb25zPl0gPGNvbW1pdD4uLi4iCiBtc2dzdHIgImdpdCBuYW1lLXJldiBb0J7Qn9Cm0JjQr+KApl0g0J/QntCU0JDQktCQ0J3QleKApiIKIAotIzogYnVpbHRpbi9uYW1lLXJldi5jOjM1MworIzogYnVpbHRpbi9uYW1lLXJldi5jOjM1NwogbXNnaWQgImdpdCBuYW1lLXJldiBbPG9wdGlvbnM+XSAtLWFsbCIKIG1zZ3N0ciAiZ2l0IG5hbWUtcmV2IFvQntCf0KbQmNCv4oCmXSAtLWFsbCIKIAotIzogYnVpbHRpbi9uYW1lLXJldi5jOjM1NAorIzogYnVpbHRpbi9uYW1lLXJldi5jOjM1OAogbXNnaWQgImdpdCBuYW1lLXJldiBbPG9wdGlvbnM+XSAtLXN0ZGluIgogbXNnc3RyICJnaXQgbmFtZS1yZXYgW9Ce0J/QptCY0K/igKZdIC0tc3RkaW4iCiAKLSM6IGJ1aWx0aW4vbmFtZS1yZXYuYzo0MTEKKyM6IGJ1aWx0aW4vbmFtZS1yZXYuYzo0MTUKIG1zZ2lkICJwcmludCBvbmx5IG5hbWVzIChubyBTSEEtMSkiCiBtc2dzdHIgItC40LfQstC10LbQtNCw0L3QtSDRgdCw0LzQviDQvdCwINC40LzQtdC90LDRgtCwICjQsdC10Lcg0YHRg9C80LjRgtC1INC/0L4gU0hBMSkiCiAKLSM6IGJ1aWx0aW4vbmFtZS1yZXYuYzo0MTIKKyM6IGJ1aWx0aW4vbmFtZS1yZXYuYzo0MTYKIG1zZ2lkICJvbmx5IHVzZSB0YWdzIHRvIG5hbWUgdGhlIGNvbW1pdHMiCiBtc2dzdHIgItC40LfQv9C+0LvQt9Cy0LDQvdC1INGB0LDQvNC+INC90LAg0LXRgtC40LrQtdGC0LjRgtC1INC30LAg0LjQvNC10L3Rg9Cy0LDQvdC1INC90LAg0L/QvtC00LDQstCw0L3QuNGP0YLQsCIKIAotIzogYnVpbHRpbi9uYW1lLXJldi5jOjQxNAorIzogYnVpbHRpbi9uYW1lLXJldi5jOjQxOAogbXNnaWQgIm9ubHkgdXNlIHJlZnMgbWF0Y2hpbmcgPHBhdHRlcm4+IgogbXNnc3RyICLQuNC30L/QvtC70LfQstCw0L3QtSDRgdCw0LzQviDQvdCwINGD0LrQsNC30LDRgtC10LvQuNGC0LUg0L3QsNC/0LDRgdCy0LDRidC4INC90LAg0KjQkNCR0JvQntCd0LAiCiAKLSM6IGJ1aWx0aW4vbmFtZS1yZXYuYzo0MTYKKyM6IGJ1aWx0aW4vbmFtZS1yZXYuYzo0MjAKIG1zZ2lkICJpZ25vcmUgcmVmcyBtYXRjaGluZyA8cGF0dGVybj4iCiBtc2dzdHIgItC40LPQvdC+0YDQuNGA0LDQvdC1INC90LAg0YPQutCw0LfQsNGC0LXQu9C40YLQtSDQvdCw0L/QsNGB0LLQsNGJ0Lgg0L3QsCDQqNCQ0JHQm9Ce0J3QsCIKIAotIzogYnVpbHRpbi9uYW1lLXJldi5jOjQxOAorIzogYnVpbHRpbi9uYW1lLXJldi5jOjQyMgogbXNnaWQgImxpc3QgYWxsIGNvbW1pdHMgcmVhY2hhYmxlIGZyb20gYWxsIHJlZnMiCiBtc2dzdHIgIiIKICLQuNC30LLQtdC20LTQsNC90LUg0L3QsCDQstGB0LjRh9C60Lgg0L/QvtC00LDQstCw0L3QuNGPLCDQutC+0LjRgtC+INC80L7Qs9Cw0YIg0LTQsCDQsdGK0LTQsNGCINC00L7RgdGC0LjQs9C90LDRgtC4INC+0YIg0LLRgdC40YfQutC4ICIKICLRg9C60LDQt9Cw0YLQtdC70LgiCiAKLSM6IGJ1aWx0aW4vbmFtZS1yZXYuYzo0MTkKKyM6IGJ1aWx0aW4vbmFtZS1yZXYuYzo0MjMKIG1zZ2lkICJyZWFkIGZyb20gc3RkaW4iCiBtc2dzdHIgItGH0LXRgtC10L3QtSDQvtGCINGB0YLQsNC90LTQsNGA0YLQvdC40Y8g0LLRhdC+0LQiCiAKLSM6IGJ1aWx0aW4vbmFtZS1yZXYuYzo0MjAKKyM6IGJ1aWx0aW4vbmFtZS1yZXYuYzo0MjQKIG1zZ2lkICJhbGxvdyB0byBwcmludCBgdW5kZWZpbmVkYCBuYW1lcyAoZGVmYXVsdCkiCiBtc2dzdHIgItC00LAg0YHQtSDQuNC30LLQtdC20LTQsNGCINC4INC90LXQtNC10YTQuNC90LjRgNCw0L3QuNGC0LUg0LjQvNC10L3QsCAo0YHRgtCw0L3QtNCw0YDRgtC90LAg0YHRgtC+0LnQvdC+0YHRgiDQvdCwINC+0L/RhtC40Y/RgtCwKSIKIAotIzogYnVpbHRpbi9uYW1lLXJldi5jOjQyNgorIzogYnVpbHRpbi9uYW1lLXJldi5jOjQzMAogbXNnaWQgImRlcmVmZXJlbmNlIHRhZ3MgaW4gdGhlIGlucHV0IChpbnRlcm5hbCB1c2UpIgogbXNnc3RyICLQuNC30LLQtdC20LTQsNC90LUg0L3QsCDQuNC00LXQvdGC0LjRhNC40LrQsNGC0L7RgNC40YLQtSDQvdCwINC+0LHQtdC60YLQuC3QtdGC0LjQutC10YLQuCAo0LfQsCDQstGK0YLRgNC10YjQvdC4INC90YPQttC00LgpIgogCkBAIC0xNjQ2MSw3ICsxNjU0Niw3IEBACiBtc2dpZCAicmVhZCBvYmplY3QgbmFtZXMgZnJvbSB0aGUgc3RhbmRhcmQgaW5wdXQiCiBtc2dzdHIgItC40LfRh9C40YLQsNC90LUg0L3QsCDQuNC80LXQvdCw0YLQsCDQvdCwINC+0LHQtdC60YLQuNGC0LUg0L7RgiDRgdGC0LDQvdC00LDRgNGC0L3QuNGPINCy0YXQvtC0IgogCi0jOiBidWlsdGluL25vdGVzLmM6OTU0IGJ1aWx0aW4vcHJ1bmUuYzoxMzAgYnVpbHRpbi93b3JrdHJlZS5jOjE2NQorIzogYnVpbHRpbi9ub3Rlcy5jOjk1NCBidWlsdGluL3BydW5lLmM6MTMwIGJ1aWx0aW4vd29ya3RyZWUuYzoxNjQKIG1zZ2lkICJkbyBub3QgcmVtb3ZlLCBzaG93IG9ubHkiCiBtc2dzdHIgItGB0LDQvNC+INC40LfQstC10LbQtNCw0L3QtSDQsdC10Lcg0LTQtdC50YHRgtCy0LjRgtC10LvQvdC+INC+0LrQsNGB0YLRgNGP0L3QtSIKIApAQCAtMTY0NzcsNyArMTY1NjIsNyBAQAogbXNnaWQgInVzZSBub3RlcyBmcm9tIDxub3Rlcy1yZWY+IgogbXNnc3RyICLQtNCwINGB0LUg0LjQt9C/0L7Qu9C30LLQsCDQsdC10LvQtdC20LrQsNGC0LAg0YHQvtGH0LXQvdCwINC+0YIg0YLQvtC30Lgg0KPQmtCQ0JfQkNCi0JXQm1/Ql9CQX9CR0JXQm9CV0JbQmtCQIgogCi0jOiBidWlsdGluL25vdGVzLmM6MTAzNCBidWlsdGluL3N0YXNoLmM6MTU5OAorIzogYnVpbHRpbi9ub3Rlcy5jOjEwMzQgYnVpbHRpbi9zdGFzaC5jOjE2MDcKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5rbm93biBzdWJjb21tYW5kOiAlcyIKIG1zZ3N0ciAi0L3QtdC/0L7Qt9C90LDRgtCwINC/0L7QtNC60L7QvNCw0L3QtNCwOiAlcyIKQEAgLTE2NTUzLDcyICsxNjYzOCw3MiBAQAogbXNnaWQgIndyb3RlICU8UFJJdTMyPiBvYmplY3RzIHdoaWxlIGV4cGVjdGluZyAlPFBSSXUzMj4iCiBtc2dzdHIgItCx0Y/RhdCwINC30LDQv9C40YHQsNC90LggJTxQUkl1MzI+INC+0LHQtdC60YLQuCwg0LAg0YHQtSDQvtGH0LDQutCy0LDRhdCwICU8UFJJdTMyPiIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoxMTY2CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjExNjQKIG1zZ2lkICJkaXNhYmxpbmcgYml0bWFwIHdyaXRpbmcsIGFzIHNvbWUgb2JqZWN0cyBhcmUgbm90IGJlaW5nIHBhY2tlZCIKIG1zZ3N0ciAiIgogItC40LfQutC70Y7Rh9Cy0LDQvdC1INC90LAg0LfQsNC/0LjRgdCy0LDQvdC10YLQviDQvdCwINCx0LjRgtC+0LLQsNGC0LAg0LzQsNGB0LrQsCwg0LfQsNGJ0L7RgtC+INC90Y/QutC+0Lgg0L7QsdC10LrRgtC4INC90Y/QvNCwINC00LAg0YHQtSAiCiAi0L/QsNC60LXRgtC40YDQsNGCIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjE1OTcKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MTU5MgogIywgYy1mb3JtYXQKIG1zZ2lkICJkZWx0YSBiYXNlIG9mZnNldCBvdmVyZmxvdyBpbiBwYWNrIGZvciAlcyIKIG1zZ3N0ciAi0L/RgNC10LrQsNC70LXQvdC+INC00LDQu9C10YfQvdC+INC90LDRh9Cw0LvQviDQvdCwINC+0YLQvNC10YHRgtCy0LDQvdC10YLQviDQt9CwINC+0LHQtdC60YLQuNGC0LUt0YDQsNC30LvQuNC60LAg0LfQsCDigJ4lc+KAnCIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoxNjA2CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjE2MDEKICMsIGMtZm9ybWF0CiBtc2dpZCAiZGVsdGEgYmFzZSBvZmZzZXQgb3V0IG9mIGJvdW5kIGZvciAlcyIKIG1zZ3N0ciAi0L3QtdC00L7RgdGC0LjQttC40LzQviDQvdCw0YfQsNC70L4g0L3QsCDQvtGC0LzQtdGB0YLQstCw0L3QtdGC0L4g0LfQsCDQvtCx0LXQutGC0LjRgtC1LdGA0LDQt9C70LjQutCwINC30LAg4oCeJXPigJwiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MTg3NQorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoxODcwCiBtc2dpZCAiQ291bnRpbmcgb2JqZWN0cyIKIG1zZ3N0ciAi0J/RgNC10LHRgNC+0Y/QstCw0L3QtSDQvdCwINC+0LHQtdC60YLQuNGC0LUiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjAwNQorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyMDAwCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBnZXQgc2l6ZSBvZiAlcyIKIG1zZ3N0ciAi0YDQsNC30LzQtdGA0YrRgiDQvdCwIOKAniVz4oCcINC90LUg0LzQvtC20LUg0LTQsCDQsdGK0LTQtSDQv9C+0LvRg9GH0LXQvSIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyMDIwCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjIwMTUKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHBhcnNlIG9iamVjdCBoZWFkZXIgb2YgJXMiCiBtc2dzdHIgItC30LDQs9C70LDQstC90LDRgtCwINGH0LDRgdGCINC90LAg4oCeJXPigJwg0L3QtSDQvNC+0LbQtSDQtNCwINCx0YrQtNC1INCw0L3QsNC70LjQt9C40YDQsNC90LAiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjA5MCBidWlsdGluL3BhY2stb2JqZWN0cy5jOjIxMDYKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjExNgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyMDg1IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjEwMQorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyMTExCiAjLCBjLWZvcm1hdAogbXNnaWQgIm9iamVjdCAlcyBjYW5ub3QgYmUgcmVhZCIKIG1zZ3N0ciAi0L7QsdC10LrRgtGK0YIg4oCeJXPigJwg0L3QtSDQvNC+0LbQtSDQtNCwINGB0LUg0L/RgNC+0YfQtdGC0LUiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjA5MyBidWlsdGluL3BhY2stb2JqZWN0cy5jOjIxMjAKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjA4OCBidWlsdGluL3BhY2stb2JqZWN0cy5jOjIxMTUKICMsIGMtZm9ybWF0CiBtc2dpZCAib2JqZWN0ICVzIGluY29uc2lzdGVudCBvYmplY3QgbGVuZ3RoICglPFBSSXVNQVg+IHZzICU8UFJJdU1BWD4pIgogbXNnc3RyICLQvtCx0LXQutGC0YrRgiDigJ4lc+KAnCDQtSDRgSDQvdC10L/RgNCw0LLQuNC70L3QsCDQtNGK0LvQttC40L3QsCAoJTxQUkl1TUFYPiwg0LAg0L3QtSAlPFBSSXVNQVg+KSIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyMTMwCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjIxMjUKIG1zZ2lkICJzdWJvcHRpbWFsIHBhY2sgLSBvdXQgb2YgbWVtb3J5IgogbXNnc3RyICLQvdC10L7Qv9GC0LjQvNC40LfQuNGA0LDQvSDQv9Cw0LrQtdGCIOKAlCDQv9Cw0LzQtdGC0YLQsCDRgdCy0YrRgNGI0LgiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjQ1NgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNDQwCiAjLCBjLWZvcm1hdAogbXNnaWQgIkRlbHRhIGNvbXByZXNzaW9uIHVzaW5nIHVwIHRvICVkIHRocmVhZHMiCiBtc2dzdHIgItCU0LXQu9GC0LAg0LrQvtC80L/RgNC10YHQuNGP0YLQsCDRidC1INC40LfQv9C+0LvQt9Cy0LAg0LTQviAlZCDQvdC40YjQutC4IgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI1ODgKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjU3MgogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gcGFjayBvYmplY3RzIHJlYWNoYWJsZSBmcm9tIHRhZyAlcyIKIG1zZ3N0ciAiIgogItC+0LHQtdC60YLQuNGC0LUsINC60L7QuNGC0L4g0LzQvtCz0LDRgiDQtNCwINCx0YrQtNCw0YIg0LTQvtGB0YLQuNCz0L3QsNGC0Lgg0L7RgiDQtdGC0LjQutC10YLQsCDigJ4lc+KAnCwg0L3QtSDQvNC+0LbQtSDQtNCwINCx0YrQtNCw0YIgIgogItC/0LDQutC10YLQuNGA0LDQvdC4IgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI2NzUKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjY1OQogbXNnaWQgIkNvbXByZXNzaW5nIG9iamVjdHMiCiBtc2dzdHIgItCa0L7QvNC/0YDQtdGB0LjRgNCw0L3QtSDQvdCwINC+0LHQtdC60YLQuNGC0LUiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjY4MQorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNjY1CiBtc2dpZCAiaW5jb25zaXN0ZW5jeSB3aXRoIGRlbHRhIGNvdW50IgogbXNnc3RyICLQvdC10L/RgNCw0LLQuNC70LXQvSDQsdGA0L7QuSDRgNCw0LfQu9C40LrQuCIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNzYyCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI3NDIKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogImV4cGVjdGVkIGVkZ2Ugb2JqZWN0IElELCBnb3QgZ2FyYmFnZTpcbiIKQEAgLTE2NjI3LDcgKzE2NzEyLDcgQEAKICLQvtGH0LDQutCy0LAg0YHQtSDQuNC00LXQvdGC0LjRhNC40LrQsNGC0L7RgCDQvdCwINC60YDQsNC10L0g0L7QsdC10LrRgiwg0LAg0L3QtTpcbiIKICIgJXMiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6Mjc2OAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNzQ4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJleHBlY3RlZCBvYmplY3QgSUQsIGdvdCBnYXJiYWdlOlxuIgpAQCAtMTY2MzYsMjYyICsxNjcyMSwyNjIgQEAKICLQvtGH0LDQutCy0LAg0YHQtSDQuNC00LXQvdGC0LjRhNC40LrQsNGC0L7RgCDQvdCwINC+0LHQtdC60YIsINCwINC90LU6XG4iCiAiICVzIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI4NjYKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6Mjg0NgogbXNnaWQgImludmFsaWQgdmFsdWUgZm9yIC0tbWlzc2luZyIKIG1zZ3N0ciAi0L3QtdC/0YDQsNCy0LjQu9C90LAg0YHRgtC+0LnQvdC+0YHRgiDQt9CwIOKAni0tbWlzc2luZ+KAnCIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyOTI1IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzAzMworIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyOTA1IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzAxMwogbXNnaWQgImNhbm5vdCBvcGVuIHBhY2sgaW5kZXgiCiBtc2dzdHIgItC40L3QtNC10LrRgdGK0YIg0L3QsCDQv9Cw0LrQtdGC0L3QuNGPINGE0LDQudC7INC90LUg0LzQvtC20LUg0LTQsCDQsdGK0LTQtSDQvtGC0LLQvtGA0LXQvSIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyOTU2CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI5MzYKICMsIGMtZm9ybWF0CiBtc2dpZCAibG9vc2Ugb2JqZWN0IGF0ICVzIGNvdWxkIG5vdCBiZSBleGFtaW5lZCIKIG1zZ3N0ciAi0L3QtdC/0LDQutC10YLQuNGA0LDQvdC40Y/RgiDQvtCx0LXQutGCINCyIOKAniVz4oCcINC90LUg0LzQvtC20LUg0LTQsCDQsdGK0LTQtSDQsNC90LDQu9C40LfQuNGA0LDQvSIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMDQxCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMwMjEKIG1zZ2lkICJ1bmFibGUgdG8gZm9yY2UgbG9vc2Ugb2JqZWN0IgogbXNnc3RyICLQvtGB0YLQsNCy0LDQvdC10YLQviDQvdCwINC+0LHQtdC60YLQsCDQvdC10L/QsNC60LXRgtC40YDQsNC9INC90LUg0LzQvtC20LUg0LTQsCDQsdGK0LTQtSDQvdCw0LvQvtC20LXQvdC+IgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMxMzMKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzExMwogIywgYy1mb3JtYXQKIG1zZ2lkICJub3QgYSByZXYgJyVzJyIKIG1zZ3N0ciAi4oCeJXPigJwg0L3QtSDQtSDQstC10YDRgdC40Y8iCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzEzNgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMTE2CiAjLCBjLWZvcm1hdAogbXNnaWQgImJhZCByZXZpc2lvbiAnJXMnIgogbXNnc3RyICLQvdC10L/RgNCw0LLQuNC70L3QsCDQstC10YDRgdC40Y8g4oCeJXPigJwiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzE2MQorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMTQxCiBtc2dpZCAidW5hYmxlIHRvIGFkZCByZWNlbnQgb2JqZWN0cyIKIG1zZ3N0ciAi0YHQutC+0YDQvtGI0L3QuNGC0LUg0L7QsdC10LrRgtC4INC90LUg0LzQvtCz0LDRgiDQtNCwINCx0YrQtNCw0YIg0LTQvtCx0LDQstC10L3QuCIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjE0CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMxOTQKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5zdXBwb3J0ZWQgaW5kZXggdmVyc2lvbiAlcyIKIG1zZ3N0ciAi0L3QtdC/0L7QtNC00YrRgNC20LDQvdCwINCy0LXRgNGB0LjRjyDQvdCwINC40L3QtNC10LrRgdCwIOKAniVz4oCcIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyMTgKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzE5OAogIywgYy1mb3JtYXQKIG1zZ2lkICJiYWQgaW5kZXggdmVyc2lvbiAnJXMnIgogbXNnc3RyICLQvdC10L/RgNCw0LLQuNC70L3QsCDQstC10YDRgdC40Y8g0L3QsCDQuNC90LTQtdC60YHQsCDigJ4lc+KAnCIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjQ4CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyMjgKIG1zZ2lkICJkbyBub3Qgc2hvdyBwcm9ncmVzcyBtZXRlciIKIG1zZ3N0ciAi0LHQtdC3INC40LfQstC10LbQtNCw0L3QtSDQvdCwINC90LDQv9GA0LXQtNGK0LrQsCIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjUwCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyMzAKIG1zZ2lkICJzaG93IHByb2dyZXNzIG1ldGVyIgogbXNnc3RyICLQuNC30LLQtdC20LTQsNC90LUg0L3QsCDQvdCw0L/RgNC10LTRitC60LAiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI1MgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjMyCiBtc2dpZCAic2hvdyBwcm9ncmVzcyBtZXRlciBkdXJpbmcgb2JqZWN0IHdyaXRpbmcgcGhhc2UiCiBtc2dzdHIgItC40LfQstC10LbQtNCw0L3QtSDQvdCwINC90LDQv9GA0LXQtNGK0LrQsCDQstGK0LIg0YTQsNC30LDRgtCwINC90LAg0LfQsNC/0LDQt9Cy0LDQvdC1INC90LAg0L7QsdC10LrRgtC40YLQtSIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjU1CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyMzUKIG1zZ2lkICJzaW1pbGFyIHRvIC0tYWxsLXByb2dyZXNzIHdoZW4gcHJvZ3Jlc3MgbWV0ZXIgaXMgc2hvd24iCiBtc2dzdHIgIiIKICLRgdGK0YnQvtGC0L4g0LTQtdC50YHRgtCy0LjQtSDQutCw0YLQviDQvtC/0YbQuNGP0YLQsCDigJ4tLWFsbC1wcm9ncmVzc+KAnCDQv9GA0Lgg0LjQt9Cy0LXQttC00LDQvdC10YLQviDQvdCwINC90LDQv9GA0LXQtNGK0LrQsCIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjU2CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyMzYKIG1zZ2lkICI8dmVyc2lvbj5bLDxvZmZzZXQ+XSIKIG1zZ3N0ciAi0JLQldCg0KHQmNCvWyzQntCi0JzQldCh0KLQktCQ0J3QlV0iCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI1NworIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjM3CiBtc2dpZCAid3JpdGUgdGhlIHBhY2sgaW5kZXggZmlsZSBpbiB0aGUgc3BlY2lmaWVkIGlkeCBmb3JtYXQgdmVyc2lvbiIKIG1zZ3N0ciAiIgogItC30LDQv9Cw0LfQstCw0L3QtSDQvdCwINC40L3QtNC10LrRgdCwINC90LAg0L/QsNC60LXRgtC90LjRgtC1INGE0LDQudC70L7QstC1INCy0YrQsiDRhNC+0YDQvNCwzIDRgtCwINGBINGD0LrQsNC30LDQvdCw0YLQsCDQstC10YDRgdC40Y8iCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI2MAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjQwCiBtc2dpZCAibWF4aW11bSBzaXplIG9mIGVhY2ggb3V0cHV0IHBhY2sgZmlsZSIKIG1zZ3N0ciAi0LzQsNC60YHQuNC80LDQu9C10L0g0YDQsNC30LzQtdGAINC90LAg0LLRgdC10LrQuCDQv9Cw0LrQtdGC0LXQvSDRhNCw0LnQuyIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjYyCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNDIKIG1zZ2lkICJpZ25vcmUgYm9ycm93ZWQgb2JqZWN0cyBmcm9tIGFsdGVybmF0ZSBvYmplY3Qgc3RvcmUiCiBtc2dzdHIgItC40LPQvdC+0YDQuNGA0LDQvdC1INC90LAg0L7QsdC10LrRgtC40YLQtSDQt9Cw0LXRgtC4INC+0YIg0LTRgNGD0LPQuCDRhdGA0LDQvdC40LvQuNGJ0LAg0L3QsCDQvtCx0LXQutGC0LgiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI2NAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjQ0CiBtc2dpZCAiaWdub3JlIHBhY2tlZCBvYmplY3RzIgogbXNnc3RyICLQuNCz0L3QvtGA0LjRgNCw0L3QtSDQvdCwINC/0LDQutC10YLQuNGA0LDQvdC40YLQtSDQvtCx0LXQutGC0LgiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI2NgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjQ2CiBtc2dpZCAibGltaXQgcGFjayB3aW5kb3cgYnkgb2JqZWN0cyIKIG1zZ3N0ciAi0L7Qs9GA0LDQvdC40YfQsNCy0LDQvdC1INC90LAg0L/RgNC+0LfQvtGA0LXRhtCwINC30LAg0L/QsNC60LXRgtC40YDQsNC90LUg0L/QviDQsdGA0L7QuSDQvtCx0LXQutGC0LgiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI2OAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjQ4CiBtc2dpZCAibGltaXQgcGFjayB3aW5kb3cgYnkgbWVtb3J5IGluIGFkZGl0aW9uIHRvIG9iamVjdCBsaW1pdCIKIG1zZ3N0ciAiIgogItC+0LPRgNCw0L3QuNGH0LDQstCw0L3QtSDQvdCwINC/0YDQvtC30L7RgNC10YbQsCDQt9CwINC/0LDQutC10YLQuNGA0LDQvdC1INC4INC/0L4g0L/QsNC80LXRgiDQvtGB0LLQtdC9INC/0L4g0LHRgNC+0Lkg0L7QsdC10LrRgtC4IgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNzAKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI1MAogbXNnaWQgIm1heGltdW0gbGVuZ3RoIG9mIGRlbHRhIGNoYWluIGFsbG93ZWQgaW4gdGhlIHJlc3VsdGluZyBwYWNrIgogbXNnc3RyICIiCiAi0LzQsNC60YHQuNC80LDQu9C90LAg0LTRitC70LbQuNC90LAg0L3QsCDQstC10YDQuNCz0LDRgtCwINC+0YIg0YDQsNC30LvQuNC60LgsINC60L7Rj9GC0L4g0LUg0L/QvtC30LLQvtC70LXQvdCwINCyINC/0LDQutC10YLQvdC40Y8g0YTQsNC50LsiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI3MgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjUyCiBtc2dpZCAicmV1c2UgZXhpc3RpbmcgZGVsdGFzIgogbXNnc3RyICLQv9GA0LXQuNC30L/QvtC70LfQstCw0L3QtSDQvdCwINGB0YrRidC10YHRgtCy0YPQstCw0YnQuNGC0LUg0YDQsNC30LvQuNC60LgiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI3NAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjU0CiBtc2dpZCAicmV1c2UgZXhpc3Rpbmcgb2JqZWN0cyIKIG1zZ3N0ciAi0L/RgNC10LjQt9C/0L7Qu9C30LLQsNC90LUg0L3QsCDRgdGK0YnQtdGB0YLQstGD0LLQsNGJ0LjRgtC1INC+0LHQtdC60YLQuCIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjc2CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNTYKIG1zZ2lkICJ1c2UgT0ZTX0RFTFRBIG9iamVjdHMiCiBtc2dzdHIgItC40LfQv9C+0LvQt9Cy0LDQvdC1INC90LAg0L7QsdC10LrRgtC4IOKAnk9GU19ERUxUQeKAnCIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjc4CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNTgKIG1zZ2lkICJ1c2UgdGhyZWFkcyB3aGVuIHNlYXJjaGluZyBmb3IgYmVzdCBkZWx0YSBtYXRjaGVzIgogbXNnc3RyICIiCiAi0YHRgtCw0YDRgtC40YDQsNC90LUg0L3QsCDQvdC40YjQutC4INC30LAg0L/RgNC10YLRitGA0YHQstCw0L3QtSDQvdCwINC90LDQuS3QtNC+0LHRgNC40YLQtSDRgdGK0LLQv9Cw0LTQtdC90LjRjyDQvdCwINGA0LDQt9C70LjQutC40YLQtSIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjgwCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNjAKIG1zZ2lkICJkbyBub3QgY3JlYXRlIGFuIGVtcHR5IHBhY2sgb3V0cHV0IgogbXNnc3RyICLQsdC10Lcg0YHRitC30LTQsNCy0LDQvdC1INC90LAg0L/RgNCw0LfQtdC9INC/0LDQutC10YLQtdC9INGE0LDQudC7IgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyODIKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI2MgogbXNnaWQgInJlYWQgcmV2aXNpb24gYXJndW1lbnRzIGZyb20gc3RhbmRhcmQgaW5wdXQiCiBtc2dzdHIgItC40LfRh9C40YLQsNC90LUg0L3QsCDQstC10YDRgdC40LjRgtC1INC+0YIg0YHRgtCw0L3QtNCw0YDRgtC90LjRjyDQstGF0L7QtCIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjg0CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNjQKIG1zZ2lkICJsaW1pdCB0aGUgb2JqZWN0cyB0byB0aG9zZSB0aGF0IGFyZSBub3QgeWV0IHBhY2tlZCIKIG1zZ3N0ciAi0L7Qs9GA0LDQvdC40YfQsNCy0LDQvdC1INC00L4g0LLRgdC1INC+0YnQtSDQvdC10L/QsNC60LXRgtC40YDQsNC90LjRgtC1INC+0LHQtdC60YLQuCIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjg3CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNjcKIG1zZ2lkICJpbmNsdWRlIG9iamVjdHMgcmVhY2hhYmxlIGZyb20gYW55IHJlZmVyZW5jZSIKIG1zZ3N0ciAiIgogItCy0LrQu9GO0YfQstCw0L3QtSDQvdCwINCy0YHQuNGH0LrQuCDQvtCx0LXQutGC0LgsINC60L7QuNGC0L4g0LzQvtCz0LDRgiDQtNCwINGB0LUg0LTQvtGB0YLQuNCz0L3QsNGCINC+0YIg0L/RgNC+0LjQt9Cy0L7Qu9C10L0gIgogItGD0LrQsNC30LDRgtC10LsiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI5MAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjcwCiBtc2dpZCAiaW5jbHVkZSBvYmplY3RzIHJlZmVycmVkIGJ5IHJlZmxvZyBlbnRyaWVzIgogbXNnc3RyICLQstC60LvRjtGH0LLQsNC90LUg0Lgg0L3QsCDQvtCx0LXQutGC0LjRgtC1INGB0L7Rh9C10L3QuCDQvtGCINC30LDQv9C40YHQuNGC0LUg0LIg0LbRg9GA0L3QsNC70LAg0L3QsCDRg9C60LDQt9Cw0YLQtdC70LjRgtC1IgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyOTMKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI3MwogbXNnaWQgImluY2x1ZGUgb2JqZWN0cyByZWZlcnJlZCB0byBieSB0aGUgaW5kZXgiCiBtc2dzdHIgItCy0LrQu9GO0YfQstCw0L3QtSDQuCDQvdCwINC+0LHQtdC60YLQuNGC0LUg0YHQvtGH0LXQvdC4INC+0YIg0LjQvdC00LXQutGB0LAiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI5NgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjc2CiBtc2dpZCAib3V0cHV0IHBhY2sgdG8gc3Rkb3V0IgogbXNnc3RyICLQuNC30LLQtdC20LTQsNC90LUg0L3QsCDQv9Cw0LrQtdGC0LAg0L3QsCDRgdGC0LDQvdC00LDRgNGC0L3QuNGPINC40LfRhdC+0LQiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI5OAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjc4CiBtc2dpZCAiaW5jbHVkZSB0YWcgb2JqZWN0cyB0aGF0IHJlZmVyIHRvIG9iamVjdHMgdG8gYmUgcGFja2VkIgogbXNnc3RyICIiCiAi0LLQutC70Y7Rh9Cy0LDQvdC1INC4INC90LAg0L7QsdC10LrRgtC40YLQtS3QtdGC0LjQutC10YLQuCwg0LrQvtC40YLQviDRgdC+0YfQsNGCINC60YrQvCDQvtCx0LXQutGC0LjRgtC1LCDQutC+0LjRgtC+INGJ0LUg0LHRitC00LDRgiAiCiAi0L/QsNC60LXRgtC40YDQsNC90LgiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMwMAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjgwCiBtc2dpZCAia2VlcCB1bnJlYWNoYWJsZSBvYmplY3RzIgogbXNnc3RyICLQt9Cw0L/QsNC30LLQsNC90LUg0L3QsCDQvdC10LTQvtGB0YLQuNC20LjQvNC40YLQtSDQvtCx0LXQutGC0LgiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMwMgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjgyCiBtc2dpZCAicGFjayBsb29zZSB1bnJlYWNoYWJsZSBvYmplY3RzIgogbXNnc3RyICLQv9Cw0LrQtdGC0LjRgNCw0L3QtSDQuCDQvdCwINC90LXQtNC+0YHRgtC40LbQuNC80LjRgtC1INC+0LHQtdC60YLQuCIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzA0CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyODQKIG1zZ2lkICJ1bnBhY2sgdW5yZWFjaGFibGUgb2JqZWN0cyBuZXdlciB0aGFuIDx0aW1lPiIKIG1zZ3N0ciAi0YDQsNC30L/QsNC60LXRgtC40YDQsNC90LUg0L3QsCDQvdC10LTQvtGB0YLQuNC20LjQvNC40YLQtSDQvtCx0LXQutGC0LgsINC60L7QuNGC0L4g0YHQsCDQv9C+LdC90L7QstC4INC+0YIg0YLQvtCy0LAg0JLQoNCV0JzQlSIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzA3CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyODcKIG1zZ2lkICJ1c2UgdGhlIHNwYXJzZSByZWFjaGFiaWxpdHkgYWxnb3JpdGhtIgogbXNnc3RyICLQuNC30L/QvtC70LfQstCw0L3QtSDQvdCwINCw0LvQs9C+0YDQuNGC0YrQvCDQt9CwINGH0LDRgdGC0LjRh9C90LAg0LTQvtGB0YLQuNC20LjQvNC+0YHRgiIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzA5CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyODkKIG1zZ2lkICJjcmVhdGUgdGhpbiBwYWNrcyIKIG1zZ3N0ciAi0YHRitC30LTQsNCy0LDQvdC1INC90LAg0YHRitC60YDQsNGC0LXQvdC4INC/0LDQutC10YLQuCIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzExCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyOTEKIG1zZ2lkICJjcmVhdGUgcGFja3Mgc3VpdGFibGUgZm9yIHNoYWxsb3cgZmV0Y2hlcyIKIG1zZ3N0ciAi0L/QsNC60LXRgtC40YDQsNC90LUg0L/QvtC00YXQvtC00Y/RidC+INC30LAg0L/Qu9C40YLQutC+INC00L7RgdGC0LDQstGP0L3QtSIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzEzCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyOTMKIG1zZ2lkICJpZ25vcmUgcGFja3MgdGhhdCBoYXZlIGNvbXBhbmlvbiAua2VlcCBmaWxlIgogbXNnc3RyICLQuNCz0L3QvtGA0LjRgNCw0L3QtSDQvdCwINC/0LDQutC10YLQuNGC0LUsINC60L7QuNGC0L4g0YHQsCDQv9GA0LjQtNGA0YPQttC10L3QuCDQvtGCINGE0LDQudC7IOKAni5rZWVw4oCcIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMTUKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI5NQogbXNnaWQgImlnbm9yZSB0aGlzIHBhY2siCiBtc2dzdHIgItC/0YDQvtC/0YPRgdC60LDQvdC1INC90LAg0YLQvtC30Lgg0L/QsNC60LXRgiIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzE3CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyOTcKIG1zZ2lkICJwYWNrIGNvbXByZXNzaW9uIGxldmVsIgogbXNnc3RyICLQvdC40LLQviDQvdCwINC60L7QvNC/0YDQtdGB0LjRgNCw0L3QtSDQv9GA0Lgg0L/QsNC60LXRgtC40YDQsNC90LUiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMxOQorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjk5CiBtc2dpZCAiZG8gbm90IGhpZGUgY29tbWl0cyBieSBncmFmdHMiCiBtc2dzdHIgIiIKICLQuNC30LLQtdC20LTQsNC90LUg0L3QsCDQstGB0LjRh9C60Lgg0YDQvtC00LjRgtC10LvQuCDigJQg0LTQvtGA0Lgg0Lgg0YLQtdC30LgsINC60L7QuNGC0L4g0L3QvtGA0LzQsNC70L3QviDRgdCwINGB0LrRgNC40YLQuCDQv9GA0LggIgogItC/0YDQuNGB0LDQttC00LDQvdC40Y/RgtCwIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMjEKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMwMQogbXNnaWQgInVzZSBhIGJpdG1hcCBpbmRleCBpZiBhdmFpbGFibGUgdG8gc3BlZWQgdXAgY291bnRpbmcgb2JqZWN0cyIKIG1zZ3N0ciAiIgogItC40LfQv9C+0LvQt9Cy0LDQvdC1INC90LAg0YHRitGJ0LXRgdGC0LLRg9Cy0LDRidC4INC40L3QtNC10LrRgdC4INC90LAg0LHQsNC30LAg0LHQuNGC0L7QstC4INC80LDRgdC60Lgg0LfQsCDRg9GB0LrQvtGA0Y/QstCw0L3QtSDQvdCwICIKICLQv9GA0LXQsdGA0L7Rj9Cy0LDQvdC10YLQviDQvdCwINC+0LHQtdC60YLQuNGC0LUiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMyMworIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzAzCiBtc2dpZCAid3JpdGUgYSBiaXRtYXAgaW5kZXggdG9nZXRoZXIgd2l0aCB0aGUgcGFjayBpbmRleCIKIG1zZ3N0ciAiIgogItC30LDQv9Cw0LfQstCw0L3QtSDQuCDQvdCwINC40L3QtNC10LrRgSDQvdCwINCx0LDQt9CwINC/0L7QsdC40YLQvtCy0LAg0LzQsNGB0LrQsCwg0LfQsNC10LTQvdC+INGBINC40L3QtNC10LrRgdCwINC30LAg0L/QsNC60LXRgtCwIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMjcKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMwNwogbXNnaWQgIndyaXRlIGEgYml0bWFwIGluZGV4IGlmIHBvc3NpYmxlIgogbXNnc3RyICLQt9Cw0L/QuNGB0LLQsNC90LUg0L3QsCDQuNC90LTQtdC60YHQuCDQvdCwINCx0LDQt9CwINCx0LjRgtC+0LLQuCDQvNCw0YHQutC4INC/0YDQuCDQstGK0LfQvNC+0LbQvdC+0YHRgiIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzMxCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMTEKIG1zZ2lkICJoYW5kbGluZyBmb3IgbWlzc2luZyBvYmplY3RzIgogbXNnc3RyICLQutCw0Log0LTQsCDRgdC1INC+0LHRgNCw0LHQvtGC0LLQsNGCINC70LjQv9GB0LLQsNGJ0LjRgtC1INC+0LHQtdC60YLQuCIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzM0CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMTQKIG1zZ2lkICJkbyBub3QgcGFjayBvYmplY3RzIGluIHByb21pc29yIHBhY2tmaWxlcyIKIG1zZ3N0ciAi0LHQtdC3INC/0LDQutC10YLQuNGA0LDQvdC1INC90LAg0L7QsdC10LrRgtC4INCyINCz0LDRgNCw0L3RgtC40YDQsNGJ0Lgg0L/QsNC60LXRgtC4IgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMzYKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMxNgogbXNnaWQgInJlc3BlY3QgaXNsYW5kcyBkdXJpbmcgZGVsdGEgY29tcHJlc3Npb24iCiBtc2dzdHIgItCx0LXQtyDQv9GA0L7QvNGP0L3QsCDQvdCwINCz0YDRg9C/0LjRgtC1INC/0YDQuCDQtNC10LvRgtCwINC60L7QvNC/0YDQtdGB0LjRjyIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzYxCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzNDUKICMsIGMtZm9ybWF0CiBtc2dpZCAiZGVsdGEgY2hhaW4gZGVwdGggJWQgaXMgdG9vIGRlZXAsIGZvcmNpbmcgJWQiCiBtc2dzdHIgItCy0LXRgNC40LPQsNGC0LAg0YEg0YDQsNC30LvQuNC60Lgg0LUg0L/RgNC10LrQsNC70LXQvdC+INC00YrQu9Cx0L7QutCwIOKAlCAlZCwg0YnQtSDRgdC1INC/0L7Qu9C30LLQsCAlZCIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzY2CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzNTAKICMsIGMtZm9ybWF0CiBtc2dpZCAicGFjay5kZWx0YUNhY2hlTGltaXQgaXMgdG9vIGhpZ2gsIGZvcmNpbmcgJWQiCiBtc2dzdHIgIiIKICLQodGC0L7QudC90L7RgdGC0YLQsCDQvdCwINC90LDRgdGC0YDQvtC50LrQsNGC0LAg4oCecGFjay5kZWx0YUNhY2hlTGltaXTigJwg0LUg0L/RgNC10LrQsNC70LXQvdC+INCz0L7Qu9GP0LzQsC4gINCp0LUg0YHQtSAiCiAi0L/QvtC70LfQstCwICVkIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjM0MjAKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzQwNAogbXNnaWQgIi0tbWF4LXBhY2stc2l6ZSBjYW5ub3QgYmUgdXNlZCB0byBidWlsZCBhIHBhY2sgZm9yIHRyYW5zZmVyIgogbXNnc3RyICIiCiAi0L7Qv9GG0LjRj9GC0LAg4oCeLS1tYXgtcGFjay1zaXpl4oCcINC90LUg0LzQvtC20LUg0LTQsCDRgdC1INC40LfQv9C+0LvQt9Cy0LAg0LfQsCDRgdGK0LfQtNCw0LLQsNC90LUg0L3QsCDQv9Cw0LrQtdGC0L3QuCAiCiAi0YTQsNC50LvQvtCy0LUg0LfQsCDQv9GA0LXQvdC+0YEiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzQyMgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozNDA2CiBtc2dpZCAibWluaW11bSBwYWNrIHNpemUgbGltaXQgaXMgMSBNaUIiCiBtc2dzdHIgItC80LjQvdC40LzQsNC70L3QuNGP0YIg0YDQsNC30LzQtdGAINC90LAg0L/QsNC60LXRgtC40YLQtSDQtSAx4oCKTWlCIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjM0MjcKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzQxMQogbXNnaWQgIi0tdGhpbiBjYW5ub3QgYmUgdXNlZCB0byBidWlsZCBhbiBpbmRleGFibGUgcGFjayIKIG1zZ3N0ciAiIgogItC+0L/RhtC40Y/RgtCwIOKAni0tdGhpbuKAnNC90LUg0LzQvtC20LUg0LTQsCDRgdC1INC40LfQv9C+0LvQt9Cy0LAg0LfQsCDRgdGK0LfQtNCw0LLQsNC90LUg0L3QsCDQv9Cw0LrQtdGC0L3QuCDRhNCw0LnQu9C+0LLQtSDRgSAiCiAi0LjQvdC00LXQutGBIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjM0MzAKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzQxNAogbXNnaWQgIi0ta2VlcC11bnJlYWNoYWJsZSBhbmQgLS11bnBhY2stdW5yZWFjaGFibGUgYXJlIGluY29tcGF0aWJsZSIKIG1zZ3N0ciAi0L7Qv9GG0LjQuNGC0LUg4oCeLS1rZWVwLXVucmVhY2hhYmxl4oCcINC4IOKAni0tdW5wYWNrLXVucmVhY2hhYmxl4oCcINGB0LAg0L3QtdGB0YrQstC80LXRgdGC0LjQvNC4IgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjM0MzYKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzQyMAogbXNnaWQgImNhbm5vdCB1c2UgLS1maWx0ZXIgd2l0aG91dCAtLXN0ZG91dCIKIG1zZ3N0ciAi0L7Qv9GG0LjRj9GC0LAg4oCeLWZpbHRlcuKAnCDQuNC30LjRgdC60LLQsCDigJ4tc3Rkb3V04oCcIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjM0OTcKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzQ4MQogbXNnaWQgIkVudW1lcmF0aW5nIG9iamVjdHMiCiBtc2dzdHIgItCY0LfQsdGA0L7Rj9Cy0LDQvdC1INC90LAg0L7QsdC10LrRgtC40YLQtSIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozNTI3CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjM1MTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiVG90YWwgJTxQUkl1MzI+IChkZWx0YSAlPFBSSXUzMj4pLCByZXVzZWQgJTxQUkl1MzI+IChkZWx0YSAlPFBSSXUzMj4pIgogbXNnc3RyICIiCkBAIC0xNjk0Nyw0NCArMTcwMzIsNDQgQEAKIG1zZ2lkICJnaXQgcHVsbCBbPG9wdGlvbnM+XSBbPHJlcG9zaXRvcnk+IFs8cmVmc3BlYz4uLi5dXSIKIG1zZ3N0ciAiZ2l0IHB1c2ggW9Ce0J/QptCY0K/igKZdIFvQpdCg0JDQndCY0JvQmNCp0JUgW9Cj0JrQkNCX0JDQotCV0Jtf0J3QkF/QktCV0KDQodCY0K/igKZdXSIKIAotIzogYnVpbHRpbi9wdWxsLmM6MTQxCisjOiBidWlsdGluL3B1bGwuYzoxNDIKIG1zZ2lkICJjb250cm9sIGZvciByZWN1cnNpdmUgZmV0Y2hpbmcgb2Ygc3VibW9kdWxlcyIKIG1zZ3N0ciAi0YPQv9GA0LDQstC70LXQvdC40LUg0L3QsCDRgNC10LrRg9GA0YHQuNCy0L3QvtGC0L4g0LTQvtGB0YLQsNCy0Y/QvdC1INC90LAg0L/QvtC00LzQvtC00YPQu9C40YLQtSIKIAotIzogYnVpbHRpbi9wdWxsLmM6MTQ1CisjOiBidWlsdGluL3B1bGwuYzoxNDYKIG1zZ2lkICJPcHRpb25zIHJlbGF0ZWQgdG8gbWVyZ2luZyIKIG1zZ3N0ciAi0J7Qv9GG0LjQuCDQv9GA0Lgg0YHQu9C40LLQsNC90LUiCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjE0OAorIzogYnVpbHRpbi9wdWxsLmM6MTQ5CiBtc2dpZCAiaW5jb3Jwb3JhdGUgY2hhbmdlcyBieSByZWJhc2luZyByYXRoZXIgdGhhbiBtZXJnaW5nIgogbXNnc3RyICLQstC90LDRgdGP0L3QtSDQvdCwINC/0YDQvtC80LXQvdC40YLQtSDRh9GA0LXQtyDQv9GA0LXQsdCw0LfQuNGA0LDQvdC1LCDQsCDQvdC1INGH0YDQtdC3INGB0LvQuNCy0LDQvdC1IgogCi0jOiBidWlsdGluL3B1bGwuYzoxNzYgYnVpbHRpbi9yZWJhc2UuYzo0NDcgYnVpbHRpbi9yZXZlcnQuYzoxMjYKKyM6IGJ1aWx0aW4vcHVsbC5jOjE3NyBidWlsdGluL3JlYmFzZS5jOjQ0OCBidWlsdGluL3JldmVydC5jOjEyNgogbXNnaWQgImFsbG93IGZhc3QtZm9yd2FyZCIKIG1zZ3N0ciAi0L/QvtC30LLQvtC70Y/QstCw0L3QtSDQvdCwINC/0YDQtdCy0YrRgNGC0LDQvdC40Y8iCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjE4NQorIzogYnVpbHRpbi9wdWxsLmM6MTg2CiBtc2dpZCAiYXV0b21hdGljYWxseSBzdGFzaC9zdGFzaCBwb3AgYmVmb3JlIGFuZCBhZnRlciByZWJhc2UiCiBtc2dzdHIgItCw0LLRgtC+0LzQsNGC0LjRh9C90L4g0YHQutCw0YLQsNCy0LDQvdC1L9C/0YDQuNC70LDQs9Cw0L3QtSDQvdCwINGB0LrQsNGC0LDQvdC+0YLQviDQv9GA0LXQtNC4INC4INGB0LvQtdC0INC/0YDQtdCx0LDQt9C40YDQsNC90LUiCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjIwMQorIzogYnVpbHRpbi9wdWxsLmM6MjAyCiBtc2dpZCAiT3B0aW9ucyByZWxhdGVkIHRvIGZldGNoaW5nIgogbXNnc3RyICLQntC/0YbQuNC4INC/0YDQuCDQtNC+0YHRgtCw0LLRj9C90LUiCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjIxMQorIzogYnVpbHRpbi9wdWxsLmM6MjEyCiBtc2dpZCAiZm9yY2Ugb3ZlcndyaXRlIG9mIGxvY2FsIGJyYW5jaCIKIG1zZ3N0ciAi0L/RgNC40L3Rg9C00LjRgtC10LvQvdC+INC/0YDQtdC30LDQv9C40YHQstCw0L3QtSDQvdCwINC70L7QutCw0LvQvdC40Y8g0LrQu9C+0L0iCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjIxOQorIzogYnVpbHRpbi9wdWxsLmM6MjIwCiBtc2dpZCAibnVtYmVyIG9mIHN1Ym1vZHVsZXMgcHVsbGVkIGluIHBhcmFsbGVsIgogbXNnc3RyICLQsdGA0L7QuSDQv9C+0LTQvNC+0LTRg9C70Lgg0LjQt9C00YrRgNC/0LDQvdC4INC/0LDRgNCw0LvQtdC70L3QviIKIAotIzogYnVpbHRpbi9wdWxsLmM6MzE2CisjOiBidWlsdGluL3B1bGwuYzozMjAKICMsIGMtZm9ybWF0CiBtc2dpZCAiSW52YWxpZCB2YWx1ZSBmb3IgcHVsbC5mZjogJXMiCiBtc2dzdHIgItCd0LXQv9GA0LDQstC40LvQvdCwINGB0YLQvtC50L3QvtGB0YIg0LfQsCDigJ5wdWxsLmZm4oCcOiDigJ4lc+KAnCIKIAotIzogYnVpbHRpbi9wdWxsLmM6NDMzCisjOiBidWlsdGluL3B1bGwuYzo0MzcKIG1zZ2lkICIiCiAiVGhlcmUgaXMgbm8gY2FuZGlkYXRlIGZvciByZWJhc2luZyBhZ2FpbnN0IGFtb25nIHRoZSByZWZzIHRoYXQgeW91IGp1c3QgIgogImZldGNoZWQuIgpAQCAtMTY5OTIsMTQgKzE3MDc3LDE0IEBACiAi0JzQtdC20LTRgyDRg9C60LDQt9Cw0YLQtdC70LjRgtC1LCDQutC+0LjRgtC+INGC0L7QutGDINGJ0L4g0LTQvtGB0YLQsNCy0LjRhdGC0LUsINC90Y/QvNCwINC/0L7QtNGF0L7QtNGP0Ykg0LrQsNC90LTQuNC00LDRgiwg0LLRitGA0YXRgyAiCiAi0LrQvtC50YLQviDQtNCwINC/0YDQtdCx0LDQt9C40YDQsNGC0LUuIgogCi0jOiBidWlsdGluL3B1bGwuYzo0MzUKKyM6IGJ1aWx0aW4vcHVsbC5jOjQzOQogbXNnaWQgIiIKICJUaGVyZSBhcmUgbm8gY2FuZGlkYXRlcyBmb3IgbWVyZ2luZyBhbW9uZyB0aGUgcmVmcyB0aGF0IHlvdSBqdXN0IGZldGNoZWQuIgogbXNnc3RyICIiCiAi0JzQtdC20LTRgyDRg9C60LDQt9Cw0YLQtdC70LjRgtC1LCDQutC+0LjRgtC+INGC0L7QutGDINGJ0L4g0LTQvtGB0YLQsNCy0LjRhdGC0LUsINC90Y/QvNCwINC/0L7QtNGF0L7QtNGP0Ykg0LrQsNC90LTQuNC00LDRgiwg0LrQvtC50YLQviAiCiAi0LTQsCDRgdC70LXQtdGC0LUuIgogCi0jOiBidWlsdGluL3B1bGwuYzo0MzYKKyM6IGJ1aWx0aW4vcHVsbC5jOjQ0MAogbXNnaWQgIiIKICJHZW5lcmFsbHkgdGhpcyBtZWFucyB0aGF0IHlvdSBwcm92aWRlZCBhIHdpbGRjYXJkIHJlZnNwZWMgd2hpY2ggaGFkIG5vXG4iCiAibWF0Y2hlcyBvbiB0aGUgcmVtb3RlIGVuZC4iCkBAIC0xNzAwNyw3ICsxNzA5Miw3IEBACiAi0J3QsNC5INCy0LXRgNC+0Y/RgtC90L4g0YHRgtC1INC/0L7QtNCw0LvQuCDRiNCw0LHQu9C+0L0g0LfQsCDRg9C60LDQt9Cw0YLQtdC70LgsINC60L7QudGC0L4g0L3QtSDQtSDQvdCw0L/QsNGB0L3QsNC7INGBINC90LjRidC+INCyICIKICLQvtGC0LTQsNC70LXRh9C10L3QvtGC0L4g0YXRgNCw0L3QuNC70LjRidC1LiIKIAotIzogYnVpbHRpbi9wdWxsLmM6NDM5CisjOiBidWlsdGluL3B1bGwuYzo0NDMKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIllvdSBhc2tlZCB0byBwdWxsIGZyb20gdGhlIHJlbW90ZSAnJXMnLCBidXQgZGlkIG5vdCBzcGVjaWZ5XG4iCkBAIC0xNzAxOCw0NCArMTcxMDMsNDQgQEAKICLQn9C+0L3QtdC20LUg0YLQvtCy0LAg0L3QtSDQtSDRhdGA0LDQvdC40LvQuNGJ0LXRgtC+INC/0L4g0L/QvtC00YDQsNC30LHQuNGA0LDQvdC1INC90LAg0YLQtdC60YPRidC40Y8g0LrQu9C+0L0sINGC0YDRj9Cx0LLQsFxuIgogItC00LAg0YPQutCw0LbQtdGC0LUg0L7RgtC00LDQu9C10YfQtdC90LjRjyDQutC70L7QvSDQvdCwINC60L7QvNCw0L3QtNC90LjRjyDRgNC10LQuIgogCi0jOiBidWlsdGluL3B1bGwuYzo0NDQgYnVpbHRpbi9yZWJhc2UuYzoxMzI2IGdpdC1wYXJzZS1yZW1vdGUuc2g6NzMKKyM6IGJ1aWx0aW4vcHVsbC5jOjQ0OCBidWlsdGluL3JlYmFzZS5jOjEzNDcgZ2l0LXBhcnNlLXJlbW90ZS5zaDo3MwogbXNnaWQgIllvdSBhcmUgbm90IGN1cnJlbnRseSBvbiBhIGJyYW5jaC4iCiBtc2dzdHIgItCY0LfQstGK0L0g0LLRgdC40YfQutC4INC60LvQvtC90LguIgogCi0jOiBidWlsdGluL3B1bGwuYzo0NDYgYnVpbHRpbi9wdWxsLmM6NDYxIGdpdC1wYXJzZS1yZW1vdGUuc2g6NzkKKyM6IGJ1aWx0aW4vcHVsbC5jOjQ1MCBidWlsdGluL3B1bGwuYzo0NjUgZ2l0LXBhcnNlLXJlbW90ZS5zaDo3OQogbXNnaWQgIlBsZWFzZSBzcGVjaWZ5IHdoaWNoIGJyYW5jaCB5b3Ugd2FudCB0byByZWJhc2UgYWdhaW5zdC4iCiBtc2dzdHIgItCj0LrQsNC20LXRgtC1INCy0YrRgNGF0YMg0LrQvtC5INC60LvQvtC9INC40YHQutCw0YLQtSDQtNCwINC/0YDQtdCx0LDQt9C40YDQsNGC0LUuIgogCi0jOiBidWlsdGluL3B1bGwuYzo0NDggYnVpbHRpbi9wdWxsLmM6NDYzIGdpdC1wYXJzZS1yZW1vdGUuc2g6ODIKKyM6IGJ1aWx0aW4vcHVsbC5jOjQ1MiBidWlsdGluL3B1bGwuYzo0NjcgZ2l0LXBhcnNlLXJlbW90ZS5zaDo4MgogbXNnaWQgIlBsZWFzZSBzcGVjaWZ5IHdoaWNoIGJyYW5jaCB5b3Ugd2FudCB0byBtZXJnZSB3aXRoLiIKIG1zZ3N0ciAi0KPQutCw0LbQtdGC0LUg0LrQvtC5INC60LvQvtC9INC40YHQutCw0YLQtSDQtNCwINGB0LvQtdC10YLQtS4iCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjQ0OSBidWlsdGluL3B1bGwuYzo0NjQKKyM6IGJ1aWx0aW4vcHVsbC5jOjQ1MyBidWlsdGluL3B1bGwuYzo0NjgKIG1zZ2lkICJTZWUgZ2l0LXB1bGwoMSkgZm9yIGRldGFpbHMuIgogbXNnc3RyICLQl9CwINC/0L7QstC10YfQtSDQuNC90YTQvtGA0LzQsNGG0LjRjyDQv9C+0LPQu9C10LTQvdC10YLQtSDRgNGK0LrQvtCy0L7QtNGB0YLQstC+0YLQviDigJ5naXQtcHVsbCgxKeKAnCIKIAotIzogYnVpbHRpbi9wdWxsLmM6NDUxIGJ1aWx0aW4vcHVsbC5jOjQ1NyBidWlsdGluL3B1bGwuYzo0NjYKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTMzMiBnaXQtcGFyc2UtcmVtb3RlLnNoOjY0CisjOiBidWlsdGluL3B1bGwuYzo0NTUgYnVpbHRpbi9wdWxsLmM6NDYxIGJ1aWx0aW4vcHVsbC5jOjQ3MAorIzogYnVpbHRpbi9yZWJhc2UuYzoxMzUzIGdpdC1wYXJzZS1yZW1vdGUuc2g6NjQKIG1zZ2lkICI8cmVtb3RlPiIKIG1zZ3N0ciAi0J7QotCU0JDQm9CV0KfQldCd0J5f0KXQoNCQ0J3QmNCb0JjQqdCVIgogCi0jOiBidWlsdGluL3B1bGwuYzo0NTEgYnVpbHRpbi9wdWxsLmM6NDY2IGJ1aWx0aW4vcHVsbC5jOjQ3MQorIzogYnVpbHRpbi9wdWxsLmM6NDU1IGJ1aWx0aW4vcHVsbC5jOjQ3MCBidWlsdGluL3B1bGwuYzo0NzUKICM6IGdpdC1wYXJzZS1yZW1vdGUuc2g6NjUKIG1zZ2lkICI8YnJhbmNoPiIKIG1zZ3N0ciAi0JrQm9Ce0J0iCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjQ1OSBidWlsdGluL3JlYmFzZS5jOjEzMjQgZ2l0LXBhcnNlLXJlbW90ZS5zaDo3NQorIzogYnVpbHRpbi9wdWxsLmM6NDYzIGJ1aWx0aW4vcmViYXNlLmM6MTM0NSBnaXQtcGFyc2UtcmVtb3RlLnNoOjc1CiBtc2dpZCAiVGhlcmUgaXMgbm8gdHJhY2tpbmcgaW5mb3JtYXRpb24gZm9yIHRoZSBjdXJyZW50IGJyYW5jaC4iCiBtc2dzdHIgItCi0LXQutGD0YnQuNGP0YIg0LrQu9C+0L0g0L3QtSDRgdC70LXQtNC4INC90LjQutC+0LkuIgogCi0jOiBidWlsdGluL3B1bGwuYzo0NjggZ2l0LXBhcnNlLXJlbW90ZS5zaDo5NQorIzogYnVpbHRpbi9wdWxsLmM6NDcyIGdpdC1wYXJzZS1yZW1vdGUuc2g6OTUKIG1zZ2lkICIiCiAiSWYgeW91IHdpc2ggdG8gc2V0IHRyYWNraW5nIGluZm9ybWF0aW9uIGZvciB0aGlzIGJyYW5jaCB5b3UgY2FuIGRvIHNvIHdpdGg6IgogbXNnc3RyICIiCiAi0JDQutC+INC40YHQutCw0YLQtSDQtNCwINC30LDQtNCw0LTQtdGC0LUg0LjQvdGE0L7RgNC80LDRhtC40Y8g0LfQsCDRgdC70LXQtNC10L0g0LrQu9C+0L0sINC80L7QttC10YLQtSDQtNCwINC90LDQv9GA0LDQstC40YLQtSDRgtC+0LLQsCDRgSAiCiAi0LrQvtC80LDQvdC00LDRgtCwOiIKIAotIzogYnVpbHRpbi9wdWxsLmM6NDczCisjOiBidWlsdGluL3B1bGwuYzo0NzcKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIllvdXIgY29uZmlndXJhdGlvbiBzcGVjaWZpZXMgdG8gbWVyZ2Ugd2l0aCB0aGUgcmVmICclcydcbiIKQEAgLTE3MDY0LDMyICsxNzE0OSwzMiBAQAogItCX0LAg0YHQu9C40LLQsNC90LUg0LUg0YPQutCw0LfQsNC9INC+0YLQtNCw0LvQtdGH0LXQvdC40Y/RgiDRg9C60LDQt9Cw0YLQtdC7IOKAniVz4oCcLFxuIgogItC90L4g0YLQsNC60YrQsiDQvdC1INC1INC00L7RgdGC0LDQstC10L0uIgogCi0jOiBidWlsdGluL3B1bGwuYzo1ODEKKyM6IGJ1aWx0aW4vcHVsbC5jOjU4NwogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gYWNjZXNzIGNvbW1pdCAlcyIKIG1zZ3N0ciAi0L3QtdC00L7RgdGC0YrQv9C90L4g0L/QvtC00LDQstCw0L3QtTogJXMiCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjg2MQorIzogYnVpbHRpbi9wdWxsLmM6ODY3CiBtc2dpZCAiaWdub3JpbmcgLS12ZXJpZnktc2lnbmF0dXJlcyBmb3IgcmViYXNlIgogbXNnc3RyICLQsdC10Lcg4oCeLS12ZXJpZnktc2lnbmF0dXJlc+KAnCDQv9GA0Lgg0L/RgNC10LHQsNC30LjRgNCw0L3QtSIKIAotIzogYnVpbHRpbi9wdWxsLmM6OTE2CisjOiBidWlsdGluL3B1bGwuYzo5MjIKIG1zZ2lkICItLVtuby1dYXV0b3N0YXNoIG9wdGlvbiBpcyBvbmx5IHZhbGlkIHdpdGggLS1yZWJhc2UuIgogbXNnc3RyICLQvtC/0YbQuNGP0YLQsCDigJ4tLVtuby1dYXV0b3N0YXNo4oCcINC40LfQuNGB0LrQstCwIOKAni0tcmViYXNl4oCcIgogCi0jOiBidWlsdGluL3B1bGwuYzo5MjQKKyM6IGJ1aWx0aW4vcHVsbC5jOjkzMAogbXNnaWQgIlVwZGF0aW5nIGFuIHVuYm9ybiBicmFuY2ggd2l0aCBjaGFuZ2VzIGFkZGVkIHRvIHRoZSBpbmRleC4iCiBtc2dzdHIgItCe0LHQvdC+0LLRj9Cy0LDQvdC1INC90LAg0LLRgdC1INC+0YnQtSDQvdC10YHRitC30LTQsNC00LXQvSDQutC70L7QvSDRgSDQv9GA0L7QvNC10L3QuNGC0LUg0L7RgiDQuNC90LTQtdC60YHQsCIKIAotIzogYnVpbHRpbi9wdWxsLmM6OTI4CisjOiBidWlsdGluL3B1bGwuYzo5MzQKIG1zZ2lkICJwdWxsIHdpdGggcmViYXNlIgogbXNnc3RyICLQuNC30LTRitGA0L/QstCw0L3QtSDRgSDQv9GA0LXQsdCw0LfQuNGA0LDQvdC1IgogCi0jOiBidWlsdGluL3B1bGwuYzo5MjkKKyM6IGJ1aWx0aW4vcHVsbC5jOjkzNQogbXNnaWQgInBsZWFzZSBjb21taXQgb3Igc3Rhc2ggdGhlbS4iCiBtc2dzdHIgItGC0YDRj9Cx0LLQsCDQtNCwINC/0L7QtNCw0LTQtdGC0LUg0LjQu9C4INGB0LrQsNGC0LDQtdGC0LUg0L/RgNC+0LzQtdC90LjRgtC1LiIKIAotIzogYnVpbHRpbi9wdWxsLmM6OTU0CisjOiBidWlsdGluL3B1bGwuYzo5NjAKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogImZldGNoIHVwZGF0ZWQgdGhlIGN1cnJlbnQgYnJhbmNoIGhlYWQuXG4iCkBAIC0xNzA5OSw3ICsxNzE4NCw3IEBACiAi0LTQvtGB0YLQsNCy0Y/QvdC10YLQviDQvtCx0L3QvtCy0Lgg0LLRitGA0YXQsCDQvdCwINGC0LXQutGD0YnQuNGPINC60LvQvtC9LiAg0KDQsNCx0L7RgtC90L7RgtC+XG4iCiAi0LLQuCDQutC+0L/QuNC1INCx0LUg0L/RgNC10LLRitGA0YLRj9C90L4g0L7RgiDQv9C+0LTQsNCy0LDQvdC1IOKAniVz4oCcLiIKIAotIzogYnVpbHRpbi9wdWxsLmM6OTYwCisjOiBidWlsdGluL3B1bGwuYzo5NjYKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkNhbm5vdCBmYXN0LWZvcndhcmQgeW91ciB3b3JraW5nIHRyZWUuXG4iCkBAIC0xNzExNiwxNSArMTcyMDEsMTUgQEAKICIgICAgZ2l0IHJlc2V0IC0taGFyZFxuIgogItC30LAg0LLRgNGK0YnQsNC90LUg0LrRitC8INC90L7RgNC80LDQu9C90L4g0YHRitGB0YLQvtGP0L3QuNC1LiIKIAotIzogYnVpbHRpbi9wdWxsLmM6OTc1CisjOiBidWlsdGluL3B1bGwuYzo5ODEKIG1zZ2lkICJDYW5ub3QgbWVyZ2UgbXVsdGlwbGUgYnJhbmNoZXMgaW50byBlbXB0eSBoZWFkLiIKIG1zZ3N0ciAi0J3QtSDQvNC+0LbQtSDQtNCwINGB0LvQuNCy0LDRgtC1INC80L3QvtC20LXRgdGC0LLQviDQutC70L7QvdC4INCyINC/0YDQsNC30LXQvSDQstGK0YDRhdC+0LIg0YPQutCw0LfQsNGC0LXQuy4iCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjk3OQorIzogYnVpbHRpbi9wdWxsLmM6OTg1CiBtc2dpZCAiQ2Fubm90IHJlYmFzZSBvbnRvIG11bHRpcGxlIGJyYW5jaGVzLiIKIG1zZ3N0ciAi0J3QtSDQvNC+0LbQtSDQtNCwINC/0YDQtdCx0LDQt9C40YDQsNGC0LUg0LLRitGA0YXRgyDQv9C+0LLQtdGH0LUg0L7RgiDQtdC00LjQvSDQutC70L7QvS4iCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjk4NgorIzogYnVpbHRpbi9wdWxsLmM6OTkyCiBtc2dpZCAiY2Fubm90IHJlYmFzZSB3aXRoIGxvY2FsbHkgcmVjb3JkZWQgc3VibW9kdWxlIG1vZGlmaWNhdGlvbnMiCiBtc2dzdHIgIiIKICLQv9GA0LXQsdCw0LfQuNGA0LDQvdC10YLQviDQtSDQvdC10LLRitC30LzQvtC20L3QviDQt9Cw0YDQsNC00Lgg0LvQvtC60LDQu9C90L4g0LfQsNC/0LjRgdCw0L3QuNGC0LUg0L/RgNC+0LzQtdC90Lgg0L/QviDQv9C+0LTQvNC+0LTRg9C70LjRgtC1IgpAQCAtMTcyOTgsMTcgKzE3MzgzLDk3IEBACiBtc2dpZCAiUHVzaGluZyB0byAlc1xuIgogbXNnc3RyICLQmNC30YLQu9Cw0YHQutCy0LDQvdC1INC60YrQvCDigJ4lc+KAnFxuIgogCi0jOiBidWlsdGluL3B1c2guYzozNjQKKyM6IGJ1aWx0aW4vcHVzaC5jOjM2NgogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gcHVzaCBzb21lIHJlZnMgdG8gJyVzJyIKIG1zZ3N0ciAi0YfQsNGB0YIg0L7RgiDRg9C60LDQt9Cw0YLQtdC70LjRgtC1INC90LUg0LHRj9GF0LAg0LjQt9GC0LvQsNGB0LrQsNC90Lgg0LrRitC8IOKAniVz4oCcIgogCi0jOiBidWlsdGluL3B1c2guYzozOTgKKyM6IGJ1aWx0aW4vcHVzaC5jOjU0MQorbXNnaWQgInJlcG9zaXRvcnkiCittc2dzdHIgItGF0YDQsNC90LjQu9C40YnQtSIKKworIzogYnVpbHRpbi9wdXNoLmM6NTQyIGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTY0Cittc2dpZCAicHVzaCBhbGwgcmVmcyIKK21zZ3N0ciAi0LjQt9GC0LvQsNGB0LrQstCw0L3QtSDQvdCwINCy0YHQuNGH0LrQuCDRg9C60LDQt9Cw0YLQtdC70LgiCisKKyM6IGJ1aWx0aW4vcHVzaC5jOjU0MyBidWlsdGluL3NlbmQtcGFjay5jOjE2NgorbXNnaWQgIm1pcnJvciBhbGwgcmVmcyIKK21zZ3N0ciAi0L7Qs9C70LXQtNCw0LvQvdC+INC60L7Qv9C40LUg0L3QsCDQstGB0LjRh9C60Lgg0YPQutCw0LfQsNGC0LXQu9C4IgorCisjOiBidWlsdGluL3B1c2guYzo1NDUKK21zZ2lkICJkZWxldGUgcmVmcyIKK21zZ3N0ciAi0LjQt9GC0YDQuNCy0LDQvdC1INC90LAg0YPQutCw0LfQsNGC0LXQu9C40YLQtSIKKworIzogYnVpbHRpbi9wdXNoLmM6NTQ2Cittc2dpZCAicHVzaCB0YWdzIChjYW4ndCBiZSB1c2VkIHdpdGggLS1hbGwgb3IgLS1taXJyb3IpIgorbXNnc3RyICLQuNC30YLQu9Cw0YHQutCy0LDQvdC1INC90LAg0LXRgtC40LrQtdGC0LjRgtC1ICjQvdC10YHRitCy0LzQtdGB0YLQuNC80L4g0YEg0L7Qv9GG0LjQuNGC0LUg4oCeLS1hbGzigJwg0Lgg4oCeLS1taXJyb3LigJwpIgorCisjOiBidWlsdGluL3B1c2guYzo1NDkgYnVpbHRpbi9zZW5kLXBhY2suYzoxNjcKK21zZ2lkICJmb3JjZSB1cGRhdGVzIgorbXNnc3RyICLQv9GA0LjQvdGD0LTQuNGC0LXQu9C90L4g0L7QsdC90L7QstGP0LLQsNC90LUiCisKKyM6IGJ1aWx0aW4vcHVzaC5jOjU1MSBidWlsdGluL3NlbmQtcGFjay5jOjE4MQorbXNnaWQgIjxyZWZuYW1lPjo8ZXhwZWN0PiIKK21zZ3N0ciAi0KPQmtCQ0JfQkNCi0JXQmzrQntCn0JDQmtCS0JDQndCQX9Ch0KLQntCZ0J3QntCh0KIiCisKKyM6IGJ1aWx0aW4vcHVzaC5jOjU1MiBidWlsdGluL3NlbmQtcGFjay5jOjE4MgorbXNnaWQgInJlcXVpcmUgb2xkIHZhbHVlIG9mIHJlZiB0byBiZSBhdCB0aGlzIHZhbHVlIgorbXNnc3RyICLQo9Ca0JDQl9CQ0KLQldCb0Y/RgiDRgtGA0Y/QsdCy0LAg0L/RitGA0LLQvtC90LDRh9Cw0LvQvdC+INC00LAg0LUg0YEg0YLQsNC30Lgg0J7Qp9CQ0JrQktCQ0J3QkF/QodCi0J7QmdCd0J7QodCiIgorCisjOiBidWlsdGluL3B1c2guYzo1NTUKK21zZ2lkICJjb250cm9sIHJlY3Vyc2l2ZSBwdXNoaW5nIG9mIHN1Ym1vZHVsZXMiCittc2dzdHIgItGD0L/RgNCw0LLQu9C10L3QuNC1INC90LAg0YDQtdC60YPRgNGB0LjQstC90L7RgtC+INC40LfRgtC70LDRgdC60LLQsNC90LUg0L3QsCDQv9C+0LTQvNC+0LTRg9C70LjRgtC1IgorCisjOiBidWlsdGluL3B1c2guYzo1NTcgYnVpbHRpbi9zZW5kLXBhY2suYzoxNzUKK21zZ2lkICJ1c2UgdGhpbiBwYWNrIgorbXNnc3RyICLQuNC30L/QvtC70LfQstCw0L3QtSDQvdCwINGB0YrQutGA0LDRgtC10L3QuCDQv9Cw0LrQtdGC0LgiCisKKyM6IGJ1aWx0aW4vcHVzaC5jOjU1OCBidWlsdGluL3B1c2guYzo1NTkgYnVpbHRpbi9zZW5kLXBhY2suYzoxNjEKKyM6IGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTYyCittc2dpZCAicmVjZWl2ZSBwYWNrIHByb2dyYW0iCittc2dzdHIgItC/0YDQvtCz0YDQsNC80LAg0LfQsCDQv9C+0LvRg9GH0LDQstCw0L3QtdGC0L4g0L3QsCDQv9Cw0LrQtdGC0LgiCisKKyM6IGJ1aWx0aW4vcHVzaC5jOjU2MAorbXNnaWQgInNldCB1cHN0cmVhbSBmb3IgZ2l0IHB1bGwvc3RhdHVzIgorbXNnc3RyICLQt9Cw0LTQsNCy0LDQvdC1INC90LAg0L7RgtC00LDQu9C10YfQtdC90L7RgtC+INGF0YDQsNC90LjQu9C40YnQtSDQt9CwINC60L7QvNCw0L3QtNC40YLQtSDigJ5naXQgcHVsbC9zdGF0dXPigJwiCisKKyM6IGJ1aWx0aW4vcHVzaC5jOjU2MworbXNnaWQgInBydW5lIGxvY2FsbHkgcmVtb3ZlZCByZWZzIgorbXNnc3RyICLQvtC60LDRgdGC0YDRj9C90LUg0L3QsCDRg9C60LDQt9Cw0YLQtdC70LjRgtC1LCDQutC+0LjRgtC+INGB0LAg0L/RgNC10LzQsNGF0L3QsNGC0Lgg0L7RgiDQu9C+0LrQsNC70L3QvtGC0L4g0YXRgNCw0L3QuNC70LjRidC1IgorCisjOiBidWlsdGluL3B1c2guYzo1NjUKK21zZ2lkICJieXBhc3MgcHJlLXB1c2ggaG9vayIKK21zZ3N0ciAi0LHQtdC3INC40LfQv9GK0LvQvdC10L3QuNC1INC90LAg0LrRg9C60LDRgtCwINC/0YDQtdC00Lgg0LjQt9GC0LvQsNGB0LrQstCw0L3QtSAocHJlLXB1c2gpIgorCisjOiBidWlsdGluL3B1c2guYzo1NjYKK21zZ2lkICJwdXNoIG1pc3NpbmcgYnV0IHJlbGV2YW50IHRhZ3MiCittc2dzdHIgIiIKKyLQuNC30YLQu9Cw0YHQutCy0LDQvdC1INC90LAg0LvQuNC/0YHQstCw0YnQuNGC0LUg0LIg0L7RgtC00LDQu9C10YfQtdC90L7RgtC+INGF0YDQsNC90LjQu9C40YnQtSwg0L3QviDRgdCy0YrRgNC30LDQvdC4INGBINGC0LXQutGD0YnQvtGC0L4gIgorItC40LfRgtC70LDRgdC60LLQsNC90LUsINC10YLQuNC60LXRgtC4IgorCisjOiBidWlsdGluL3B1c2guYzo1NjkgYnVpbHRpbi9zZW5kLXBhY2suYzoxNjkKK21zZ2lkICJHUEcgc2lnbiB0aGUgcHVzaCIKK21zZ3N0ciAi0L/QvtC00L/QuNGB0LLQsNC90LUg0L3QsCDQuNC30YLQu9Cw0YHQutCy0LDQvdC10YLQviDRgSBHUEciCisKKyM6IGJ1aWx0aW4vcHVzaC5jOjU3MSBidWlsdGluL3NlbmQtcGFjay5jOjE3NgorbXNnaWQgInJlcXVlc3QgYXRvbWljIHRyYW5zYWN0aW9uIG9uIHJlbW90ZSBzaWRlIgorbXNnc3RyICLQuNC30LjRgdC60LLQsNC90LUg0L3QsCDQsNGC0L7QvNCw0YDQvdC4INC+0L/QtdGA0LDRhtC40Lgg0L7RgiDQvtGC0YHRgNC10YnQvdCw0YLQsCDRgdGC0YDQsNC90LAiCisKKyM6IGJ1aWx0aW4vcHVzaC5jOjU4OQorbXNnaWQgIi0tZGVsZXRlIGlzIGluY29tcGF0aWJsZSB3aXRoIC0tYWxsLCAtLW1pcnJvciBhbmQgLS10YWdzIgorbXNnc3RyICIiCisi0L7Qv9GG0LjRj9GC0LAg4oCeLS1kZWxldGXigJwg0LUg0L3QtdGB0YrQstC80LXRgdGC0LjQvNCwINGBINC+0L/RhtC40LjRgtC1ICDigJ4tLWFsbOKAnCwg4oCeLS1taXJyb3LigJwg0Lgg4oCeLS10YWdz4oCcIgorCisjOiBidWlsdGluL3B1c2guYzo1OTEKK21zZ2lkICItLWRlbGV0ZSBkb2Vzbid0IG1ha2Ugc2Vuc2Ugd2l0aG91dCBhbnkgcmVmcyIKK21zZ3N0ciAi0L7Qv9GG0LjRj9GC0LAg4oCeLS1kZWxldGXigJwg0LjQt9C40YHQutCy0LAg0L/QvtC90LUg0LXQtNC40L0g0YPQutCw0LfQsNGC0LXQuyDQvdCwINCy0LXRgNGB0LjRjyIKKworIzogYnVpbHRpbi9wdXNoLmM6NjExCiAjLCBjLWZvcm1hdAogbXNnaWQgImJhZCByZXBvc2l0b3J5ICclcyciCiBtc2dzdHIgItC90LXQv9GA0LDQstC40LvQvdC+INGD0LrQsNC30LDQvdC+INGF0YDQsNC90LjQu9C40YnQtSDigJ4lc+KAnCIKIAotIzogYnVpbHRpbi9wdXNoLmM6Mzk5CisjOiBidWlsdGluL3B1c2guYzo2MTIKIG1zZ2lkICIiCiAiTm8gY29uZmlndXJlZCBwdXNoIGRlc3RpbmF0aW9uLlxuIgogIkVpdGhlciBzcGVjaWZ5IHRoZSBVUkwgZnJvbSB0aGUgY29tbWFuZC1saW5lIG9yIGNvbmZpZ3VyZSBhIHJlbW90ZSAiCkBAIC0xNzMzMCwxMDcgKzE3NDk1LDI3IEBACiAiXG4iCiAiICAgIGdpdCBwdXNoINCY0JzQlVxuIgogCi0jOiBidWlsdGluL3B1c2guYzo1NTQKLW1zZ2lkICJyZXBvc2l0b3J5IgotbXNnc3RyICLRhdGA0LDQvdC40LvQuNGJ0LUiCi0KLSM6IGJ1aWx0aW4vcHVzaC5jOjU1NSBidWlsdGluL3NlbmQtcGFjay5jOjE2NAotbXNnaWQgInB1c2ggYWxsIHJlZnMiCi1tc2dzdHIgItC40LfRgtC70LDRgdC60LLQsNC90LUg0L3QsCDQstGB0LjRh9C60Lgg0YPQutCw0LfQsNGC0LXQu9C4IgotCi0jOiBidWlsdGluL3B1c2guYzo1NTYgYnVpbHRpbi9zZW5kLXBhY2suYzoxNjYKLW1zZ2lkICJtaXJyb3IgYWxsIHJlZnMiCi1tc2dzdHIgItC+0LPQu9C10LTQsNC70L3QviDQutC+0L/QuNC1INC90LAg0LLRgdC40YfQutC4INGD0LrQsNC30LDRgtC10LvQuCIKLQotIzogYnVpbHRpbi9wdXNoLmM6NTU4Ci1tc2dpZCAiZGVsZXRlIHJlZnMiCi1tc2dzdHIgItC40LfRgtGA0LjQstCw0L3QtSDQvdCwINGD0LrQsNC30LDRgtC10LvQuNGC0LUiCi0KLSM6IGJ1aWx0aW4vcHVzaC5jOjU1OQotbXNnaWQgInB1c2ggdGFncyAoY2FuJ3QgYmUgdXNlZCB3aXRoIC0tYWxsIG9yIC0tbWlycm9yKSIKLW1zZ3N0ciAi0LjQt9GC0LvQsNGB0LrQstCw0L3QtSDQvdCwINC10YLQuNC60LXRgtC40YLQtSAo0L3QtdGB0YrQstC80LXRgdGC0LjQvNC+INGBINC+0L/RhtC40LjRgtC1IOKAni0tYWxs4oCcINC4IOKAni0tbWlycm9y4oCcKSIKLQotIzogYnVpbHRpbi9wdXNoLmM6NTYyIGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTY3Ci1tc2dpZCAiZm9yY2UgdXBkYXRlcyIKLW1zZ3N0ciAi0L/RgNC40L3Rg9C00LjRgtC10LvQvdC+INC+0LHQvdC+0LLRj9Cy0LDQvdC1IgotCi0jOiBidWlsdGluL3B1c2guYzo1NjQgYnVpbHRpbi9zZW5kLXBhY2suYzoxODEKLW1zZ2lkICI8cmVmbmFtZT46PGV4cGVjdD4iCi1tc2dzdHIgItCj0JrQkNCX0JDQotCV0Js60J7Qp9CQ0JrQktCQ0J3QkF/QodCi0J7QmdCd0J7QodCiIgotCi0jOiBidWlsdGluL3B1c2guYzo1NjUgYnVpbHRpbi9zZW5kLXBhY2suYzoxODIKLW1zZ2lkICJyZXF1aXJlIG9sZCB2YWx1ZSBvZiByZWYgdG8gYmUgYXQgdGhpcyB2YWx1ZSIKLW1zZ3N0ciAi0KPQmtCQ0JfQkNCi0JXQm9GP0YIg0YLRgNGP0LHQstCwINC/0YrRgNCy0L7QvdCw0YfQsNC70L3QviDQtNCwINC1INGBINGC0LDQt9C4INCe0KfQkNCa0JLQkNCd0JBf0KHQotCe0JnQndCe0KHQoiIKLQotIzogYnVpbHRpbi9wdXNoLmM6NTY4Ci1tc2dpZCAiY29udHJvbCByZWN1cnNpdmUgcHVzaGluZyBvZiBzdWJtb2R1bGVzIgotbXNnc3RyICLRg9C/0YDQsNCy0LvQtdC90LjQtSDQvdCwINGA0LXQutGD0YDRgdC40LLQvdC+0YLQviDQuNC30YLQu9Cw0YHQutCy0LDQvdC1INC90LAg0L/QvtC00LzQvtC00YPQu9C40YLQtSIKLQotIzogYnVpbHRpbi9wdXNoLmM6NTcwIGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTc1Ci1tc2dpZCAidXNlIHRoaW4gcGFjayIKLW1zZ3N0ciAi0LjQt9C/0L7Qu9C30LLQsNC90LUg0L3QsCDRgdGK0LrRgNCw0YLQtdC90Lgg0L/QsNC60LXRgtC4IgotCi0jOiBidWlsdGluL3B1c2guYzo1NzEgYnVpbHRpbi9wdXNoLmM6NTcyIGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTYxCi0jOiBidWlsdGluL3NlbmQtcGFjay5jOjE2MgotbXNnaWQgInJlY2VpdmUgcGFjayBwcm9ncmFtIgotbXNnc3RyICLQv9GA0L7Qs9GA0LDQvNCwINC30LAg0L/QvtC70YPRh9Cw0LLQsNC90LXRgtC+INC90LAg0L/QsNC60LXRgtC4IgotCi0jOiBidWlsdGluL3B1c2guYzo1NzMKLW1zZ2lkICJzZXQgdXBzdHJlYW0gZm9yIGdpdCBwdWxsL3N0YXR1cyIKLW1zZ3N0ciAi0LfQsNC00LDQstCw0L3QtSDQvdCwINC+0YLQtNCw0LvQtdGH0LXQvdC+0YLQviDRhdGA0LDQvdC40LvQuNGJ0LUg0LfQsCDQutC+0LzQsNC90LTQuNGC0LUg4oCeZ2l0IHB1bGwvc3RhdHVz4oCcIgotCi0jOiBidWlsdGluL3B1c2guYzo1NzYKLW1zZ2lkICJwcnVuZSBsb2NhbGx5IHJlbW92ZWQgcmVmcyIKLW1zZ3N0ciAi0L7QutCw0YHRgtGA0Y/QvdC1INC90LAg0YPQutCw0LfQsNGC0LXQu9C40YLQtSwg0LrQvtC40YLQviDRgdCwINC/0YDQtdC80LDRhdC90LDRgtC4INC+0YIg0LvQvtC60LDQu9C90L7RgtC+INGF0YDQsNC90LjQu9C40YnQtSIKLQotIzogYnVpbHRpbi9wdXNoLmM6NTc4Ci1tc2dpZCAiYnlwYXNzIHByZS1wdXNoIGhvb2siCi1tc2dzdHIgItCx0LXQtyDQuNC30L/RitC70L3QtdC90LjQtSDQvdCwINC60YPQutCw0YLQsCDQv9GA0LXQtNC4INC40LfRgtC70LDRgdC60LLQsNC90LUgKHByZS1wdXNoKSIKLQotIzogYnVpbHRpbi9wdXNoLmM6NTc5Ci1tc2dpZCAicHVzaCBtaXNzaW5nIGJ1dCByZWxldmFudCB0YWdzIgotbXNnc3RyICIiCi0i0LjQt9GC0LvQsNGB0LrQstCw0L3QtSDQvdCwINC70LjQv9GB0LLQsNGJ0LjRgtC1INCyINC+0YLQtNCw0LvQtdGH0LXQvdC+0YLQviDRhdGA0LDQvdC40LvQuNGJ0LUsINC90L4g0YHQstGK0YDQt9Cw0L3QuCDRgSDRgtC10LrRg9GJ0L7RgtC+ICIKLSLQuNC30YLQu9Cw0YHQutCy0LDQvdC1LCDQtdGC0LjQutC10YLQuCIKLQotIzogYnVpbHRpbi9wdXNoLmM6NTgyIGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTY5Ci1tc2dpZCAiR1BHIHNpZ24gdGhlIHB1c2giCi1tc2dzdHIgItC/0L7QtNC/0LjRgdCy0LDQvdC1INC90LAg0LjQt9GC0LvQsNGB0LrQstCw0L3QtdGC0L4g0YEgR1BHIgotCi0jOiBidWlsdGluL3B1c2guYzo1ODQgYnVpbHRpbi9zZW5kLXBhY2suYzoxNzYKLW1zZ2lkICJyZXF1ZXN0IGF0b21pYyB0cmFuc2FjdGlvbiBvbiByZW1vdGUgc2lkZSIKLW1zZ3N0ciAi0LjQt9C40YHQutCy0LDQvdC1INC90LAg0LDRgtC+0LzQsNGA0L3QuCDQvtC/0LXRgNCw0YbQuNC4INC+0YIg0L7RgtGB0YDQtdGJ0L3QsNGC0LAg0YHRgtGA0LDQvdCwIgotCi0jOiBidWlsdGluL3B1c2guYzo2MDIKLW1zZ2lkICItLWRlbGV0ZSBpcyBpbmNvbXBhdGlibGUgd2l0aCAtLWFsbCwgLS1taXJyb3IgYW5kIC0tdGFncyIKLW1zZ3N0ciAiIgotItC+0L/RhtC40Y/RgtCwIOKAni0tZGVsZXRl4oCcINC1INC90LXRgdGK0LLQvNC10YHRgtC40LzQsCDRgSDQvtC/0YbQuNC40YLQtSAg4oCeLS1hbGzigJwsIOKAni0tbWlycm9y4oCcINC4IOKAni0tdGFnc+KAnCIKLQotIzogYnVpbHRpbi9wdXNoLmM6NjA0Ci1tc2dpZCAiLS1kZWxldGUgZG9lc24ndCBtYWtlIHNlbnNlIHdpdGhvdXQgYW55IHJlZnMiCi1tc2dzdHIgItC+0L/RhtC40Y/RgtCwIOKAni0tZGVsZXRl4oCcINC40LfQuNGB0LrQstCwINC/0L7QvdC1INC10LTQuNC9INGD0LrQsNC30LDRgtC10Lsg0L3QsCDQstC10YDRgdC40Y8iCi0KLSM6IGJ1aWx0aW4vcHVzaC5jOjYwNworIzogYnVpbHRpbi9wdXNoLmM6NjI3CiBtc2dpZCAiLS1hbGwgYW5kIC0tdGFncyBhcmUgaW5jb21wYXRpYmxlIgogbXNnc3RyICLQvtC/0YbQuNC40YLQtSDigJ4tLWFsbOKAnCDQuCDigJ4tLXRhZ3PigJwg0YHQsCDQvdC10YHRitCy0LzQtdGB0YLQuNC80LgiCiAKLSM6IGJ1aWx0aW4vcHVzaC5jOjYwOQorIzogYnVpbHRpbi9wdXNoLmM6NjI5CiBtc2dpZCAiLS1hbGwgY2FuJ3QgYmUgY29tYmluZWQgd2l0aCByZWZzcGVjcyIKIG1zZ3N0ciAi0L7Qv9GG0LjRj9GC0LAg4oCeLS1hbGzigJwg0LUg0L3QtdGB0YrQstC80LXRgdGC0LjQvNCwINGBINGD0LrQsNC30LLQsNC90LXRgtC+INC90LAg0LLQtdGA0YHQuNGPIgogCi0jOiBidWlsdGluL3B1c2guYzo2MTMKKyM6IGJ1aWx0aW4vcHVzaC5jOjYzMwogbXNnaWQgIi0tbWlycm9yIGFuZCAtLXRhZ3MgYXJlIGluY29tcGF0aWJsZSIKIG1zZ3N0ciAi0L7Qv9GG0LjQuNGC0LUg4oCeLS1taXJyb3LigJwg0Lgg4oCeLS10YWdz4oCcINGB0LAg0L3QtdGB0YrQstC80LXRgdGC0LjQvNC4IgogCi0jOiBidWlsdGluL3B1c2guYzo2MTUKKyM6IGJ1aWx0aW4vcHVzaC5jOjYzNQogbXNnaWQgIi0tbWlycm9yIGNhbid0IGJlIGNvbWJpbmVkIHdpdGggcmVmc3BlY3MiCiBtc2dzdHIgItC+0L/RhtC40Y/RgtCwIOKAni0tbWlycm9y4oCcINC1INC90LXRgdGK0LLQvNC10YHRgtC40LzQsCDRgSDRg9C60LDQt9Cy0LDQvdC10YLQviDQvdCwINCy0LXRgNGB0LjRjyIKIAotIzogYnVpbHRpbi9wdXNoLmM6NjE4CisjOiBidWlsdGluL3B1c2guYzo2MzgKIG1zZ2lkICItLWFsbCBhbmQgLS1taXJyb3IgYXJlIGluY29tcGF0aWJsZSIKIG1zZ3N0ciAi0L7Qv9GG0LjQuNGC0LUg4oCeLS1hbGzigJwg0Lgg4oCeLS1taXJyb3LigJwg0YHQsCDQvdC10YHRitCy0LzQtdGB0YLQuNC80LgiCiAKLSM6IGJ1aWx0aW4vcHVzaC5jOjYzNworIzogYnVpbHRpbi9wdXNoLmM6NjQyCiBtc2dpZCAicHVzaCBvcHRpb25zIG11c3Qgbm90IGhhdmUgbmV3IGxpbmUgY2hhcmFjdGVycyIKIG1zZ3N0ciAi0L7Qv9GG0LjQuNGC0LUg0LfQsCDQuNC30YLQu9Cw0YHQutCy0LDQvdC1INC90LUg0YLRgNGP0LHQstCwINC00LAg0YHRitC00YrRgNC20LDRgiDQt9C90LDQuiDQt9CwINC90L7QsiDRgNC10LQiCiAKQEAgLTE3NTQ4LDExICsxNzYzMywxMSBAQAogCiAjOiBidWlsdGluL3JlYmFzZS5jOjMyCiBtc2dpZCAiIgotImdpdCByZWJhc2UgWy1pXSBbb3B0aW9uc10gWy0tZXhlYyA8Y21kPl0gWy0tb250byA8bmV3YmFzZT5dIFs8dXBzdHJlYW0+XSAiCi0iWzxicmFuY2g+XSIKKyJnaXQgcmViYXNlIFstaV0gW29wdGlvbnNdIFstLWV4ZWMgPGNtZD5dIFstLW9udG8gPG5ld2Jhc2U+IHwgLS1rZWVwLWJhc2VdICIKKyJbPHVwc3RyZWFtPiBbPGJyYW5jaD5dXSIKIG1zZ3N0ciAiIgotImdpdCByZWJhc2UgWy1pXSBb0J7Qn9Cm0JjQr+KApl0gWy0tZXhlYyDQmtCe0JzQkNCd0JTQkF0gWy0tb250byDQndCe0JLQkF/QkdCQ0JfQkF0gW9Ca0JvQntCdX9CY0JfQotCe0KfQndCY0JpdICIKLSJb0JrQm9Ce0J1dIgorImdpdCByZWJhc2UgWy1pXSBb0J7Qn9Cm0JjQr+KApl0gWy0tZXhlYyDQmtCe0JzQkNCd0JTQkF0gWy0tb250byDQndCe0JLQkF/QkdCQ0JfQkCB8IC0ta2VlcC1iYXNlXSAiCisiW9Ca0JvQntCdX9CY0JfQotCe0KfQndCY0JogW9Ca0JvQntCdXV0iCiAKICM6IGJ1aWx0aW4vcmViYXNlLmM6MzQKIG1zZ2lkICIiCkBAIC0xNzU5MSwxOTMgKzE3Njc2LDE5MyBAQAogbXNnaWQgImNvdWxkIG5vdCBnZW5lcmF0ZSB0b2RvIGxpc3QiCiBtc2dzdHIgItGE0LDQudC70YrRgiDRgSDQutC+0LzQsNC90LTQuNGC0LUg0L3QtSDQvNC+0LbQtSDQtNCwINGB0LUg0LPQtdC90LXRgNC40YDQsCIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzozODIKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MzgzCiBtc2dpZCAiYSBiYXNlIGNvbW1pdCBtdXN0IGJlIHByb3ZpZGVkIHdpdGggLS11cHN0cmVhbSBvciAtLW9udG8iCiBtc2dzdHIgItC+0L/RhtC40LjRgtC1IOKAni0tdXBzdHJlYW3igJwg0Lgg4oCeLS1vbnRv4oCcINC40LfQuNGB0LrQstCw0YIg0LHQsNC30L7QstC+INC/0L7QtNCw0LLQsNC90LUiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDM3CisjOiBidWlsdGluL3JlYmFzZS5jOjQzOAogbXNnaWQgImdpdCByZWJhc2UtLWludGVyYWN0aXZlIFs8b3B0aW9ucz5dIgogbXNnc3RyICJnaXQgcmViYXNlLS1pbnRlcmFjdGl2ZSBb0J7Qn9Cm0JjQr+KApl0iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDQ5CisjOiBidWlsdGluL3JlYmFzZS5jOjQ1MAogbXNnaWQgImtlZXAgZW1wdHkgY29tbWl0cyIKIG1zZ3N0ciAi0LfQsNC/0LDQt9Cy0LDQvdC1INC90LAg0L/RgNCw0LfQvdC40YLQtSDQv9C+0LTQsNCy0LDQvdC40Y8iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDUxIGJ1aWx0aW4vcmV2ZXJ0LmM6MTI4CisjOiBidWlsdGluL3JlYmFzZS5jOjQ1MiBidWlsdGluL3JldmVydC5jOjEyOAogbXNnaWQgImFsbG93IGNvbW1pdHMgd2l0aCBlbXB0eSBtZXNzYWdlcyIKIG1zZ3N0ciAi0L/QvtC30LLQvtC70Y/QstCw0L3QtSDQvdCwINC/0YDQsNC30L3QuCDRgdGK0L7QsdGJ0LXQvdC40Y8g0L/RgNC4INC/0L7QtNCw0LLQsNC90LUiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDUyCisjOiBidWlsdGluL3JlYmFzZS5jOjQ1MwogbXNnaWQgInJlYmFzZSBtZXJnZSBjb21taXRzIgogbXNnc3RyICLQv9GA0LXQsdCw0LfQuNGA0LDQvdC1INC90LAg0L/QvtC00LDQstCw0L3QuNGP0YLQsCDRgdGK0YEg0YHQu9C40LLQsNC90LjRjyIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0NTQKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDU1CiBtc2dpZCAia2VlcCBvcmlnaW5hbCBicmFuY2ggcG9pbnRzIG9mIGNvdXNpbnMiCiBtc2dzdHIgIiIKICLQt9Cw0L/QsNC30LLQsNC90LUg0L3QsCDQv9GK0YDQstC+0L3QsNGH0LDQu9C90LjRgtC1INGC0L7Rh9C60Lgg0L3QsCDRgNCw0LfQutC70L7QvdGP0LLQsNC90LUg0L3QsCDRgdC10YHRgtGA0LjQvdGB0LrQuNGC0LUg0LrQu9C+0L3QuCIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0NTYKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDU3CiBtc2dpZCAibW92ZSBjb21taXRzIHRoYXQgYmVnaW4gd2l0aCBzcXVhc2ghL2ZpeHVwISIKIG1zZ3N0ciAi0L/RgNC10LzQtdGB0YLQstCw0L3QtSDQvdCwINC/0L7QtNCw0LLQsNC90LjRj9GC0LAsINC60L7QuNGC0L4g0LfQsNC/0L7Rh9Cy0LDRgiDRgdGK0YEg4oCec3F1YXNoIeKAnC/igJxmaXh1cCHigJwiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDU3CisjOiBidWlsdGluL3JlYmFzZS5jOjQ1OAogbXNnaWQgInNpZ24gY29tbWl0cyIKIG1zZ3N0ciAi0L/QvtC00L/QuNGB0LLQsNC90LUg0L3QsCDQv9C+0LTQsNCy0LDQvdC40Y/RgtCwIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ1OSBidWlsdGluL3JlYmFzZS5jOjE0MDMKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDYwIGJ1aWx0aW4vcmViYXNlLmM6MTQyNwogbXNnaWQgImRpc3BsYXkgYSBkaWZmc3RhdCBvZiB3aGF0IGNoYW5nZWQgdXBzdHJlYW0iCiBtc2dzdHIgItC40LfQstC10LbQtNCw0L3QtSDQvdCwINGB0YLQsNGC0LjRgdGC0LjQutCwINGBINC/0YDQvtC80LXQvdC40YLQtSDQsiDRgdC70LXQtNC10L3QuNGPINC60LvQvtC9IgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ2MQorIzogYnVpbHRpbi9yZWJhc2UuYzo0NjIKIG1zZ2lkICJjb250aW51ZSByZWJhc2UiCiBtc2dzdHIgItC/0YDQvtC00YrQu9C20LDQstCw0L3QtSDQvdCwINC/0YDQtdCx0LDQt9C40YDQsNC90LXRgtC+IgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ2MworIzogYnVpbHRpbi9yZWJhc2UuYzo0NjQKIG1zZ2lkICJza2lwIGNvbW1pdCIKIG1zZ3N0ciAi0L/RgNC10YHQutCw0YfQsNC90LUg0L3QsCDQv9C+0LTQsNCy0LDQvdC1IgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ2NAorIzogYnVpbHRpbi9yZWJhc2UuYzo0NjUKIG1zZ2lkICJlZGl0IHRoZSB0b2RvIGxpc3QiCiBtc2dzdHIgItGA0LXQtNCw0LrRgtC40YDQsNC90LUg0L3QsCDRgdC/0LjRgdGK0LrQsCDRgSDQutC+0LzQsNC90LTQuCDQt9CwINC40LfQv9GK0LvQvdC10L3QuNC1IgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ2NgorIzogYnVpbHRpbi9yZWJhc2UuYzo0NjcKIG1zZ2lkICJzaG93IHRoZSBjdXJyZW50IHBhdGNoIgogbXNnc3RyICLQuNC30LLQtdC20LTQsNC90LUg0L3QsCDRgtC10LrRg9GJ0LDRgtCwINC60YDRitC/0LrQsCIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0NjkKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDcwCiBtc2dpZCAic2hvcnRlbiBjb21taXQgaWRzIGluIHRoZSB0b2RvIGxpc3QiCiBtc2dzdHIgItGB0YrQutGA0LDRgtC10L3QuCDQuNC00LXQvdGC0LjRhNC40LrQsNGC0L7RgNC4INCyINGB0L/QuNGB0YrQutCwINC30LAg0LjQt9C/0YrQu9C90LXQvdC40LUiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDcxCisjOiBidWlsdGluL3JlYmFzZS5jOjQ3MgogbXNnaWQgImV4cGFuZCBjb21taXQgaWRzIGluIHRoZSB0b2RvIGxpc3QiCiBtc2dzdHIgItC/0YrQu9C90Lgg0LjQtNC10L3RgtC40YTQuNC60LDRgtC+0YDQuCDQsiDRgdC/0LjRgdGK0LrQsCDQt9CwINC40LfQv9GK0LvQvdC10L3QuNC1IgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ3MworIzogYnVpbHRpbi9yZWJhc2UuYzo0NzQKIG1zZ2lkICJjaGVjayB0aGUgdG9kbyBsaXN0IgogbXNnc3RyICLQv9GA0L7QstC10YDQutCwINC90LAg0YHQv9C40YHRitC60LAg0LfQsCDQuNC30L/RitC70L3QtdC90LjQtSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0NzUKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDc2CiBtc2dpZCAicmVhcnJhbmdlIGZpeHVwL3NxdWFzaCBsaW5lcyIKIG1zZ3N0ciAiIgogItC/0YDQtdC/0L7QtNGA0LXQttC00LDQvdC1INC90LAg0YDQtdC00L7QstC10YLQtSDQt9CwINCy0LrQsNGA0LLQsNC90LUg0L3QsCDQv9C+0LTQsNCy0LDQvdC40Y/RgtCwINC/0L7QtNCw0LLQsNC90LjRj9GC0LAg0LIgIgogItC/0YDQtdC00YXQvtC00L3QuNGC0LUg0LjQvCDRgdGK0YEg0Lgg0LHQtdC3INGB0LzQtdC90Lgg0L3QsCDRgdGK0L7QsdGJ0LXQvdC40LXRgtC+IgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ3NworIzogYnVpbHRpbi9yZWJhc2UuYzo0NzgKIG1zZ2lkICJpbnNlcnQgZXhlYyBjb21tYW5kcyBpbiB0b2RvIGxpc3QiCiBtc2dzdHIgItCy0LzRitC60LLQsNC90LUg0L3QsCDQutC+0LzQsNC90LTQuNGC0LUg0LfQsCDQuNC30L/RitC70L3QtdC90LjQtSDQsiDRgdC/0LjRgdGK0LrQsCDQt9CwINC40LfQv9GK0LvQvdC10L3QuNC1IgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ3OAorIzogYnVpbHRpbi9yZWJhc2UuYzo0NzkKIG1zZ2lkICJvbnRvIgogbXNnc3RyICLQstGK0YDRhdGDIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ4MQorIzogYnVpbHRpbi9yZWJhc2UuYzo0ODIKIG1zZ2lkICJyZXN0cmljdC1yZXZpc2lvbiIKIG1zZ3N0ciAi0L7Qs9GA0LDQvdC40YfQtdC90LAg0LLQtdGA0YHQuNGPIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ4MQorIzogYnVpbHRpbi9yZWJhc2UuYzo0ODIKIG1zZ2lkICJyZXN0cmljdCByZXZpc2lvbiIKIG1zZ3N0ciAi0L7Qs9GA0LDQvdC40YfQtdC90LAg0LLQtdGA0YHQuNGPIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ4MworIzogYnVpbHRpbi9yZWJhc2UuYzo0ODQKIG1zZ2lkICJzcXVhc2gtb250byIKIG1zZ3N0ciAi0L/QvtC00LDQstCw0L3QtSwg0LIg0LrQvtC10YLQviDQtNGA0YPQs9C40YLQtSDQtNCwINGB0LUg0LLQutCw0YDQsNGCIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ4NAorIzogYnVpbHRpbi9yZWJhc2UuYzo0ODUKIG1zZ2lkICJzcXVhc2ggb250byIKIG1zZ3N0ciAi0L/QvtC00LDQstCw0L3QtSwg0LIg0LrQvtC10YLQviDQtNGA0YPQs9C40YLQtSDQtNCwINGB0LUg0LLQutCw0YDQsNGCIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ4NgorIzogYnVpbHRpbi9yZWJhc2UuYzo0ODcKIG1zZ2lkICJ0aGUgdXBzdHJlYW0gY29tbWl0IgogbXNnc3RyICLQv9C+0LTQsNCy0LDQvdC1INC90LAg0LjQt9GC0L7Rh9C90LjQutCwIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ4OAorIzogYnVpbHRpbi9yZWJhc2UuYzo0ODkKIG1zZ2lkICJoZWFkLW5hbWUiCiBtc2dzdHIgItC40LzQtSDQvdCwINCy0YrRgNGF0LAiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDg4CisjOiBidWlsdGluL3JlYmFzZS5jOjQ4OQogbXNnaWQgImhlYWQgbmFtZSIKIG1zZ3N0ciAi0LjQvNC1INC90LAg0LLRitGA0YXQsCIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0OTMKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDk0CiBtc2dpZCAicmViYXNlIHN0cmF0ZWd5IgogbXNnc3RyICLRgdGC0YDQsNGC0LXQs9C40Y8g0L3QsCDQv9GA0LXQsdCw0LfQuNGA0LDQvdC1IgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ5NAorIzogYnVpbHRpbi9yZWJhc2UuYzo0OTUKIG1zZ2lkICJzdHJhdGVneS1vcHRzIgogbXNnc3RyICLQvtC/0YbQuNC4INC90LAg0YHRgtGA0LDRgtC10LPQuNGP0YLQsCIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0OTUKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDk2CiBtc2dpZCAic3RyYXRlZ3kgb3B0aW9ucyIKIG1zZ3N0ciAi0L7Qv9GG0LjQuCDQvdCwINGB0YLRgNCw0YLQtdCz0LjRj9GC0LAiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDk2CisjOiBidWlsdGluL3JlYmFzZS5jOjQ5NwogbXNnaWQgInN3aXRjaC10byIKIG1zZ3N0ciAi0L/RgNC10LzQuNC90LDQstCw0L3QtSDQutGK0LwiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDk3CisjOiBidWlsdGluL3JlYmFzZS5jOjQ5OAogbXNnaWQgInRoZSBicmFuY2ggb3IgY29tbWl0IHRvIGNoZWNrb3V0IgogbXNnc3RyICLQutC70L7QvdGK0YIsINC60YrQvCDQutC+0LnRgtC+INC00LAg0YHQtSDQv9GA0LXQvNC40L3QtSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0OTgKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDk5CiBtc2dpZCAib250by1uYW1lIgogbXNnc3RyICLQuNC80LUg0L3QsCDQsdCw0LfQsCIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0OTgKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDk5CiBtc2dpZCAib250byBuYW1lIgogbXNnc3RyICLQuNC80LUg0L3QsCDQsdCw0LfQsCIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0OTkKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NTAwCiBtc2dpZCAiY21kIgogbXNnc3RyICLQutC+0LzQsNC90LTQsCIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0OTkKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NTAwCiBtc2dpZCAidGhlIGNvbW1hbmQgdG8gcnVuIgogbXNnc3RyICLQutC+0LzQsNC90LTQsCDQt9CwINC40LfQv9GK0LvQvdC10L3QuNC1IgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjUwMiBidWlsdGluL3JlYmFzZS5jOjE0ODYKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NTAzIGJ1aWx0aW4vcmViYXNlLmM6MTUxMAogbXNnaWQgImF1dG9tYXRpY2FsbHkgcmUtc2NoZWR1bGUgYW55IGBleGVjYCB0aGF0IGZhaWxzIgogbXNnc3RyICIiCiAi0LDQstGC0L7QvNCw0YLQuNGH0L3QviDQv9C+0LTQsNCy0LDQvdC1INC30LAg0L/QvtCy0YLQvtGA0L3QviDQuNC30L/RitC70L3QtdC90LjQtSDQvdCwINC60L7QvNCw0L3QtNC40YLQtSDQt9Cw0LLRitGA0YjQuNC70Lgg0YEg0L3QtdGD0YHQv9C10YUiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NTE4CisjOiBidWlsdGluL3JlYmFzZS5jOjUxOQogbXNnaWQgIi0tW25vLV1yZWJhc2UtY291c2lucyBoYXMgbm8gZWZmZWN0IHdpdGhvdXQgLS1yZWJhc2UtbWVyZ2VzIgogbXNnc3RyICLQvtC/0YbQuNC40YLQtSDigJ4tLVtuby1dcmViYXNlLWNvdXNpbnPigJwg0LjQt9C40YHQutCy0LDRgiDQvtC/0YbQuNGP0YLQsCDigJ4tLXJlYmFzZS1tZXJnZXPigJwiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NTM0CisjOiBidWlsdGluL3JlYmFzZS5jOjUzNQogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyByZXF1aXJlcyBhbiBpbnRlcmFjdGl2ZSByZWJhc2UiCiBtc2dzdHIgIuKAniVz4oCcINC40LfQuNGB0LrQstCwINC40L3RgtC10YDQsNC60YLQuNCy0L3QviDQv9GA0LXQsdCw0LfQuNGA0LDQvdC1IgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjU4NgorIzogYnVpbHRpbi9yZWJhc2UuYzo1ODcKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGdldCAnb250byc6ICclcyciCiBtc2dzdHIgItC90LUg0LzQvtC20LUg0LTQsCDRgdC1INC/0YDQtdC80LjQvdC1INC60YrQvCDQvdC+0LLQsNGC0LAg0LHQsNC30LAsINC30LDQtNCw0LTQtdC90LAg0YEg4oCeb250b+KAnDog4oCeJXPigJwiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NjAxCisjOiBidWlsdGluL3JlYmFzZS5jOjYwMgogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIG9yaWctaGVhZDogJyVzJyIKIG1zZ3N0ciAi0L3QtdC/0YDQsNCy0LjQu9C10L0g0YPQutCw0LfQsNGC0LXQuyDQutGK0Lwg0L/RitGA0LLQvtC90LDRh9Cw0LvQtdC9INCy0YDRitGFIOKAnm9yaWctaGVhZOKAnDog4oCeJXPigJwiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NjI2CisjOiBidWlsdGluL3JlYmFzZS5jOjYyNwogIywgYy1mb3JtYXQKIG1zZ2lkICJpZ25vcmluZyBpbnZhbGlkIGFsbG93X3JlcmVyZV9hdXRvdXBkYXRlOiAnJXMnIgogbXNnc3RyICLQvdC10L/RgNCw0LLQuNC70L3QsNGC0LAg0YHRgtC+0LnQvdC+0YHRgiDQvdCwIOKAnmFsbG93X3JlcmVyZV9hdXRvdXBkYXRl4oCcINGB0LUg0L/RgNC10YHQutCw0YfQsDog4oCeJXPigJwiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NzAyCisjOiBidWlsdGluL3JlYmFzZS5jOjcwMwogIywgYy1mb3JtYXQKIG1zZ2lkICJDb3VsZCBub3QgcmVhZCAnJXMnIgogbXNnc3RyICLQn9GK0YLRj9GCIOKAniVz4oCcINC90LUg0LzQvtC20LUg0LTQsCDQsdGK0LTQtSDQv9GA0L7Rh9C10YLQtdC9IgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjcyMAorIzogYnVpbHRpbi9yZWJhc2UuYzo3MjEKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ2Fubm90IHN0b3JlICVzIgogbXNnc3RyICLigJ4lc+KAnCDQvdC1INC80L7QttC1INC00LAg0LHRitC00LUg0LfQsNC/0LDQt9C10L0iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6ODI3CisjOiBidWlsdGluL3JlYmFzZS5jOjgyOAogbXNnaWQgImNvdWxkIG5vdCBkZXRlcm1pbmUgSEVBRCByZXZpc2lvbiIKIG1zZ3N0ciAi0L3QtSDQvNC+0LbQtSDQtNCwINGB0LUg0L7Qv9GA0LXQtNC10LvQuCDQutGK0Lwg0LrQsNC60LLQviDQtNCwINGB0L7Rh9C4INGD0LrQsNC30LDRgtC10LvRj9GCIOKAnkhFQUTigJwiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6OTUwIGdpdC1yZWJhc2UtLXByZXNlcnZlLW1lcmdlcy5zaDo4MQorIzogYnVpbHRpbi9yZWJhc2UuYzo5NTEgZ2l0LXJlYmFzZS0tcHJlc2VydmUtbWVyZ2VzLnNoOjgxCiBtc2dpZCAiIgogIlJlc29sdmUgYWxsIGNvbmZsaWN0cyBtYW51YWxseSwgbWFyayB0aGVtIGFzIHJlc29sdmVkIHdpdGhcbiIKICJcImdpdCBhZGQvcm0gPGNvbmZsaWN0ZWRfZmlsZXM+XCIsIHRoZW4gcnVuIFwiZ2l0IHJlYmFzZSAtLWNvbnRpbnVlXCIuXG4iCkBAIC0xNzc5MSw3ICsxNzg3Niw3IEBACiAi0JfQsCDQtNCwINC+0YLQutCw0LbQtdGC0LUg0L/RgNC10LHQsNC30LjRgNCw0L3QtdGC0L4g0Lgg0LTQsCDRgdC1INCy0YrRgNC90LXRgtC1INC60YrQvCDQv9GK0YDQstC+0L3QsNGH0LDQu9C90L7RgtC+INGB0YrRgdGC0L7Rj9C90LjQtSxcbiIKICLQuNC30L/RitC70L3QtdGC0LUg4oCeZ2l0IHJlYmFzZSAtLWFib3J04oCcLiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxMDMxCisjOiBidWlsdGluL3JlYmFzZS5jOjEwMzIKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlxuIgpAQCAtMTc4MDksNyArMTc4OTQsNyBAQAogIlxuIgogItCSINGA0LXQt9GD0LvRgtCw0YIg0YLQtSDQvdC1INC80L7Qs9Cw0YIg0LTQsCDRgdC1INC/0YDQtdCx0LDQt9C40YDQsNGCLiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxMzE4CisjOiBidWlsdGluL3JlYmFzZS5jOjEzMzkKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIiVzXG4iCkBAIC0xNzgyNiw3ICsxNzkxMSw3IEBACiAiICAgIGdpdCByZWJhc2Ug0JrQm9Ce0J1cbiIKICJcbiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxMzM0CisjOiBidWlsdGluL3JlYmFzZS5jOjEzNTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIklmIHlvdSB3aXNoIHRvIHNldCB0cmFja2luZyBpbmZvcm1hdGlvbiBmb3IgdGhpcyBicmFuY2ggeW91IGNhbiBkbyBzbyB3aXRoOlxuIgpAQCAtMTc4MzksMTM1ICsxNzkyNCwxMzkgQEAKICJcbiIKICIgICAgZ2l0IGJyYW5jaCAtLXNldC11cHN0cmVhbS10bz0lcy/QmtCb0J7QnSAlc1xuIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjEzNjQKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTM4NQogbXNnaWQgImV4ZWMgY29tbWFuZHMgY2Fubm90IGNvbnRhaW4gbmV3bGluZXMiCiBtc2dzdHIgItC60L7QvNCw0L3QtNC40YLQtSDQt9CwINC40LfQv9GK0LvQvdC10L3QuNC1INC90LUg0LzQvtC20LUg0LTQsCDRgdGK0LTRitGA0LbQsNGCINC90L7QstC4INGA0LXQtNC+0LLQtSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxMzY4CisjOiBidWlsdGluL3JlYmFzZS5jOjEzODkKIG1zZ2lkICJlbXB0eSBleGVjIGNvbW1hbmQiCiBtc2dzdHIgItC/0YDQsNC30L3QsCDQutC+0LzQsNC90LTQsCDQt9CwINC40LfQv9GK0LvQvdC10L3QuNC1IgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjEzOTYKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQxOAogbXNnaWQgInJlYmFzZSBvbnRvIGdpdmVuIGJyYW5jaCBpbnN0ZWFkIG9mIHVwc3RyZWFtIgogbXNnc3RyICLQv9GA0LXQsdCw0LfQuNGA0LDQvdC1INCy0YrRgNGF0YMg0LfQsNC00LDQtNC10L3QuNGPLCDQsCDQvdC1INGB0LvQtdC00LXQvdC40Y8g0LrQu9C+0L0iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTM5OAorIzogYnVpbHRpbi9yZWJhc2UuYzoxNDIwCittc2dpZCAidXNlIHRoZSBtZXJnZS1iYXNlIG9mIHVwc3RyZWFtIGFuZCBicmFuY2ggYXMgdGhlIGN1cnJlbnQgYmFzZSIKK21zZ3N0ciAi0LfQsCDRgtC10LrRg9GJ0LAg0LHQsNC30LAg0LTQsCDRgdC1INC/0L7Qu9C30LLQsCDQsdCw0LfQsNGC0LAg0LfQsCDRgdC70LjQstCw0L3QtSDQvdCwINC60LvQvtC90LAg0Lgg0YHQu9C10LTQtdC90L7RgtC+IgorCisjOiBidWlsdGluL3JlYmFzZS5jOjE0MjIKIG1zZ2lkICJhbGxvdyBwcmUtcmViYXNlIGhvb2sgdG8gcnVuIgogbXNnc3RyICLQv9C+0LfQstC+0LvRj9Cy0LDQvdC1INC90LAg0LrRg9C60LDRgtCwINC/0YDQtdC00Lgg0L/RgNC10LHQsNC30LjRgNCw0L3QtSDQtNCwINGB0LUg0LjQt9C/0YrQu9C90LgiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQwMAorIzogYnVpbHRpbi9yZWJhc2UuYzoxNDI0CiBtc2dpZCAiYmUgcXVpZXQuIGltcGxpZXMgLS1uby1zdGF0IgogbXNnc3RyICLQsdC10Lcg0LjQt9Cy0LXQttC00LDQvdC1INC90LAg0LjQvdGE0L7RgNC80LDRhtC40Y8uICDQktC60LvRjtGH0LLQsCDQvtC/0YbQuNGP0YLQsCDigJ4tLW5vLXN0YXTigJwiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQwNgorIzogYnVpbHRpbi9yZWJhc2UuYzoxNDMwCiBtc2dpZCAiZG8gbm90IHNob3cgZGlmZnN0YXQgb2Ygd2hhdCBjaGFuZ2VkIHVwc3RyZWFtIgogbXNnc3RyICLQsdC10Lcg0LjQt9Cy0LXQttC00LDQvdC1INC90LAg0YHRgtCw0YLQuNGB0YLQuNC60LAg0YEg0L/RgNC+0LzQtdC90LjRgtC1INCyINGB0LvQtdC00LXQvdC40Y8g0LrQu9C+0L0iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQwOQorIzogYnVpbHRpbi9yZWJhc2UuYzoxNDMzCiBtc2dpZCAiYWRkIGEgU2lnbmVkLW9mZi1ieTogbGluZSB0byBlYWNoIGNvbW1pdCIKIG1zZ3N0ciAiIgogItC00L7QsdCw0LLRj9C90LUg0L3QsCDRgNC10LQg0LfQsCDQv9C+0LTQv9C40YEg4oCeU2lnbmVkLW9mZi1ieeKAnCDQsiDRgdGK0L7QsdGJ0LXQvdC40LXRgtC+INC90LAg0LLRgdGP0LrQviDQv9C+0LTQsNCy0LDQvdC1IgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0MTEgYnVpbHRpbi9yZWJhc2UuYzoxNDE1IGJ1aWx0aW4vcmViYXNlLmM6MTQxNworIzogYnVpbHRpbi9yZWJhc2UuYzoxNDM1IGJ1aWx0aW4vcmViYXNlLmM6MTQzOSBidWlsdGluL3JlYmFzZS5jOjE0NDEKIG1zZ2lkICJwYXNzZWQgdG8gJ2dpdCBhbSciCiBtc2dzdHIgItC/0L7QtNCw0LLQsCDRgdC1INC90LAg0LrQvtC80LDQvdC00LDRgtCwIOKAnmdpdCBhbeKAnCIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDE5IGJ1aWx0aW4vcmViYXNlLmM6MTQyMQorIzogYnVpbHRpbi9yZWJhc2UuYzoxNDQzIGJ1aWx0aW4vcmViYXNlLmM6MTQ0NQogbXNnaWQgInBhc3NlZCB0byAnZ2l0IGFwcGx5JyIKIG1zZ3N0ciAi0L/QvtC00LDQstCwINGB0LUg0L3QsCDQutC+0LzQsNC90LTQsNGC0LAg4oCeZ2l0IGFwcGx54oCcIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0MjMgYnVpbHRpbi9yZWJhc2UuYzoxNDI2CisjOiBidWlsdGluL3JlYmFzZS5jOjE0NDcgYnVpbHRpbi9yZWJhc2UuYzoxNDUwCiBtc2dpZCAiY2hlcnJ5LXBpY2sgYWxsIGNvbW1pdHMsIGV2ZW4gaWYgdW5jaGFuZ2VkIgogbXNnc3RyICLQvtGC0LHQuNGA0LDQvdC1INC90LAg0LLRgdC40YfQutC4INC/0L7QtNCw0LLQsNC90LjRjyDQtNC+0YDQuCDQtNCwINC90Y/QvNCwINC/0YDQvtC80LXQvdC4IgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0MjgKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ1MgogbXNnaWQgImNvbnRpbnVlIgogbXNnc3RyICLQv9GA0L7QtNGK0LvQttCw0LLQsNC90LUiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQzMQorIzogYnVpbHRpbi9yZWJhc2UuYzoxNDU1CiBtc2dpZCAic2tpcCBjdXJyZW50IHBhdGNoIGFuZCBjb250aW51ZSIKIG1zZ3N0ciAi0L/RgNC10YHQutCw0YfQsNC90LUg0L3QsCDRgtC10LrRg9GJ0LDRgtCwINC60YDRitC/0LrQsCDQuCDQv9GA0L7QtNGK0LvQttCw0LLQsNC90LUiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQzMworIzogYnVpbHRpbi9yZWJhc2UuYzoxNDU3CiBtc2dpZCAiYWJvcnQgYW5kIGNoZWNrIG91dCB0aGUgb3JpZ2luYWwgYnJhbmNoIgogbXNnc3RyICLQv9GA0LXRg9GB0YLQsNC90L7QstGP0LLQsNC90LUg0Lgg0LLRitC30YHRgtCw0L3QvtCy0Y/QstCw0L3QtSDQvdCwINC/0YrRgNCy0L7QvdCw0YfQsNC70L3QuNGPINC60LvQvtC9IgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0MzYKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ2MAogbXNnaWQgImFib3J0IGJ1dCBrZWVwIEhFQUQgd2hlcmUgaXQgaXMiCiBtc2dzdHIgItC/0YDQtdGD0YHRgtCw0L3QvtCy0Y/QstCw0L3QtSDQsdC10Lcg0L/RgNC+0LzRj9C90LAg0LrRitC8INC60LDQutCy0L4g0YHQvtGH0Lgg4oCeSEVBROKAnCIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDM3CisjOiBidWlsdGluL3JlYmFzZS5jOjE0NjEKIG1zZ2lkICJlZGl0IHRoZSB0b2RvIGxpc3QgZHVyaW5nIGFuIGludGVyYWN0aXZlIHJlYmFzZSIKIG1zZ3N0ciAi0YDQtdC00LDQutGC0LjRgNCw0L3QtSDQvdCwINGE0LDQudC70LAg0YEg0LrQvtC80LDQvdC00Lgg0L/RgNC4INC40L3RgtC10YDQsNC60YLQuNCy0L3QviDQv9GA0LXQsdCw0LfQuNGA0LDQvdC1IgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0NDAKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ2NAogbXNnaWQgInNob3cgdGhlIHBhdGNoIGZpbGUgYmVpbmcgYXBwbGllZCBvciBtZXJnZWQiCiBtc2dzdHIgItC/0L7QutCw0LfQstCw0L3QtSDQvdCwINC60YDRitC/0LrQsNGC0LAsINC60L7Rj9GC0L4g0YHQtSDQv9GA0LjQu9Cw0LPQsCDQuNC70Lgg0YHQu9C40LLQsCIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDQzCisjOiBidWlsdGluL3JlYmFzZS5jOjE0NjcKIG1zZ2lkICJ1c2UgbWVyZ2luZyBzdHJhdGVnaWVzIHRvIHJlYmFzZSIKIG1zZ3N0ciAi0L/RgNC4INC/0YDQtdCx0LDQt9C40YDQsNC90LUg0LTQsCDRgdC1INC/0L7Qu9C30LLQsCDRgdGC0YDQsNGC0LXQs9C40Y8g0LfQsCDRgdC70LjQstCw0L3QtSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDQ3CisjOiBidWlsdGluL3JlYmFzZS5jOjE0NzEKIG1zZ2lkICJsZXQgdGhlIHVzZXIgZWRpdCB0aGUgbGlzdCBvZiBjb21taXRzIHRvIHJlYmFzZSIKIG1zZ3N0ciAiIgogItC/0L7Qt9Cy0L7Qu9GP0LLQsNC90LUg0L3QsCDQv9C+0YLRgNC10LHQuNGC0LXQu9GPINC00LAg0YDQtdC00LDQutGC0LjRgNCwINGB0L/QuNGB0YrQutCwINGBINC/0L7QtNCw0LLQsNC90LjRjyDQt9CwINC/0YDQtdCx0LDQt9C40YDQsNC90LUiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ1MQorIzogYnVpbHRpbi9yZWJhc2UuYzoxNDc1CiBtc2dpZCAiKERFUFJFQ0FURUQpIHRyeSB0byByZWNyZWF0ZSBtZXJnZXMgaW5zdGVhZCBvZiBpZ25vcmluZyB0aGVtIgogbXNnc3RyICIo0L7RgdGC0LDRgNGP0LvQvikg0L/RgNC10YHRitC30LTQsNCy0LDQvdC1INC90LAg0YHQu9C40LLQsNC90LjRj9GC0LAg0LLQvNC10YHRgtC+INC00LAg0YHQtSDQv9GA0LXRgdC60LDRh9Cw0YIiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ1NQorIzogYnVpbHRpbi9yZWJhc2UuYzoxNDc5CiBtc2dpZCAicHJlc2VydmUgZW1wdHkgY29tbWl0cyBkdXJpbmcgcmViYXNlIgogbXNnc3RyICLQt9Cw0L/QsNC30LLQsNC90LUg0L3QsCDQv9GA0LDQt9C90LjRgtC1INC/0L7QtNCw0LLQsNC90LjRjyDQv9GA0Lgg0L/RgNC10LHQsNC30LjRgNCw0L3QtSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDU3CisjOiBidWlsdGluL3JlYmFzZS5jOjE0ODEKIG1zZ2lkICJtb3ZlIGNvbW1pdHMgdGhhdCBiZWdpbiB3aXRoIHNxdWFzaCEvZml4dXAhIHVuZGVyIC1pIgogbXNnc3RyICIiCiAi0L/RgNC10LzQtdGB0YLQstCw0L3QtSDQvdCwINC/0L7QtNCw0LLQsNC90LjRj9GC0LAsINC60L7QuNGC0L4g0LfQsNC/0L7Rh9Cy0LDRgiDRgdGK0YEg4oCec3F1YXNoIeKAnC/igJxmaXh1cCHigJwg0L/RgNC4IOKAni1p4oCcIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0NjMKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ4NwogbXNnaWQgImF1dG9tYXRpY2FsbHkgc3Rhc2gvc3Rhc2ggcG9wIGJlZm9yZSBhbmQgYWZ0ZXIiCiBtc2dzdHIgItCw0LLRgtC+0LzQsNGC0LjRh9C90L4g0YHQutCw0YLQsNCy0LDQvdC1L9C/0YDQuNC70LDQs9Cw0L3QtSDQvdCwINGB0LrQsNGC0LDQvdC+0YLQviDQv9GA0LXQtNC4INC4INGB0LvQtdC0INC/0YDQtdCx0LDQt9C40YDQsNC90LUiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ2NQorIzogYnVpbHRpbi9yZWJhc2UuYzoxNDg5CiBtc2dpZCAiYWRkIGV4ZWMgbGluZXMgYWZ0ZXIgZWFjaCBjb21taXQgb2YgdGhlIGVkaXRhYmxlIGxpc3QiCiBtc2dzdHIgIiIKICLQtNC+0LHQsNCy0Y/QvdC1INC90LAg0YDQtdC00L7QstC1INGBINC60L7QvNCw0L3QtNC4INC30LAg0LjQt9C/0YrQu9C90LXQvdC40LUg0YHQu9C10LQg0LLRgdGP0LrQviDQv9C+0LTQsNCy0LDQvdC1INCyICIKICLRgNC10LTQsNC60YLQuNGA0LDQvdC40Y8g0YHQv9C40YHRitC6IgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0NjkKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ5MwogbXNnaWQgImFsbG93IHJlYmFzaW5nIGNvbW1pdHMgd2l0aCBlbXB0eSBtZXNzYWdlcyIKIG1zZ3N0ciAi0L/QvtC30LLQvtC70Y/QstCw0L3QtSDQvdCwINC/0YDQtdCx0LDQt9C40YDQsNC90LUg0L3QsCDQv9C+0LTQsNCy0LDQvdC40Y8g0YEg0L/RgNCw0LfQvdC4INGB0YrQvtCx0YnQtdC90LjRjyIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDcyCisjOiBidWlsdGluL3JlYmFzZS5jOjE0OTYKIG1zZ2lkICJ0cnkgdG8gcmViYXNlIG1lcmdlcyBpbnN0ZWFkIG9mIHNraXBwaW5nIHRoZW0iCiBtc2dzdHIgItC+0L/QuNGCINC30LAg0L/RgNC10LHQsNC30LjRgNCw0L3QtSDQvdCwINGB0LvQuNCy0LDQvdC40Y/RgtCwINCy0LzQtdGB0YLQviDRgtC1INC00LAg0YHQtSDQv9GA0LXRgdC60LDRh9Cw0YIiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ3NQorIzogYnVpbHRpbi9yZWJhc2UuYzoxNDk5CiBtc2dpZCAidXNlICdtZXJnZS1iYXNlIC0tZm9yay1wb2ludCcgdG8gcmVmaW5lIHVwc3RyZWFtIgogbXNnc3RyICIiCiAi0LfQsCDQtNC+0YPRgtC+0YfQvdGP0LLQsNC90LXRgtC+INC90LAg0YHQu9C10LTQtdC90LjRjyDQutC70L7QvSwg0LjQt9C/0L7Qu9C30LLQsNC50YLQtTpcbiIKICJcbiIKICIgICAgZ2l0IG1lcmdlLWJhc2UgLS1mb3JrLXBvaW50IgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0NzcKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTUwMQogbXNnaWQgInVzZSB0aGUgZ2l2ZW4gbWVyZ2Ugc3RyYXRlZ3kiCiBtc2dzdHIgItC40LfQv9C+0LvQt9Cy0LDQvdC1INC90LAg0LfQsNC00LDQtNC10L3QsNGC0LAg0YHRgtGA0LDRgtC10LPQuNGP0YLQsCDQvdCwINGB0LvQuNCy0LDQvdC1IgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0NzkgYnVpbHRpbi9yZXZlcnQuYzoxMTUKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTUwMyBidWlsdGluL3JldmVydC5jOjExNQogbXNnaWQgIm9wdGlvbiIKIG1zZ3N0ciAi0L7Qv9GG0LjRjyIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDgwCisjOiBidWlsdGluL3JlYmFzZS5jOjE1MDQKIG1zZ2lkICJwYXNzIHRoZSBhcmd1bWVudCB0aHJvdWdoIHRvIHRoZSBtZXJnZSBzdHJhdGVneSIKIG1zZ3N0ciAi0LDRgNCz0YPQvNC10L3RgtGK0YIg0LTQsCDRgdC1INC/0L7QtNCw0LTQtSDQvdCwINGB0YLRgNCw0YLQtdCz0LjRj9GC0LAg0LfQsCDRgdC70LjQstCw0L3QtSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDgzCisjOiBidWlsdGluL3JlYmFzZS5jOjE1MDcKIG1zZ2lkICJyZWJhc2UgYWxsIHJlYWNoYWJsZSBjb21taXRzIHVwIHRvIHRoZSByb290KHMpIgogbXNnc3RyICLQv9GA0LXQsdCw0LfQuNGA0LDQvdC1INC90LAg0LLRgdC40YfQutC4INC00L7RgdGC0LjQttC40LzQuCDQv9C+0LTQsNCy0LDQvdC40Y8g0LTQviDQvdCw0YfQsNC70L3QvtGC0L4g0LjQvCDQv9C+0LTQsNCy0LDQvdC1IgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE1MDAKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTUyNAogbXNnaWQgIiIKICJ0aGUgcmViYXNlLnVzZUJ1aWx0aW4gc3VwcG9ydCBoYXMgYmVlbiByZW1vdmVkIVxuIgogIlNlZSBpdHMgZW50cnkgaW4gJ2dpdCBoZWxwIGNvbmZpZycgZm9yIGRldGFpbHMuIgpAQCAtMTc5NzUsMzMgKzE4MDY0LDQxIEBACiAi0L/QvtC00LTRgNGK0LbQutCw0YLQsCDQvdCwIOKAnnJlYmFzZS51c2VCdWlsdGlu4oCcINC1INC/0YDQtdC80LDRhdC90LDRgtCwLlxuIgogItCX0LAg0L/QvtCy0LXRh9C1INC40L3RhNC+0YDQvNCw0YbQuNGPINCy0LjQttGC0LUg4oCeZ2l0IGhlbHAgY29uZmln4oCcLiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNTA2CisjOiBidWlsdGluL3JlYmFzZS5jOjE1MzAKIG1zZ2lkICJJdCBsb29rcyBsaWtlICdnaXQgYW0nIGlzIGluIHByb2dyZXNzLiBDYW5ub3QgcmViYXNlLiIKIG1zZ3N0ciAiIgogItCY0LfQs9C70LXQttC00LAsINGH0LUg0YHQtdCz0LAg0YHQtSDQv9GA0LjQu9Cw0LPQsNGCINC60YDRitC/0LrQuCDRh9GA0LXQtyDQutC+0LzQsNC90LTQsNGC0LAg4oCeZ2l0LWFt4oCcLiAg0J3QtSDQvNC+0LbQtSDQtNCwICIKICLQv9GA0LXQsdCw0LfQuNGA0LDRgtC1INCyINC80L7QvNC10L3RgtCwLiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNTQ3CisjOiBidWlsdGluL3JlYmFzZS5jOjE1NzEKIG1zZ2lkICIiCiAiZ2l0IHJlYmFzZSAtLXByZXNlcnZlLW1lcmdlcyBpcyBkZXByZWNhdGVkLiBVc2UgLS1yZWJhc2UtbWVyZ2VzIGluc3RlYWQuIgogbXNnc3RyICIiCiAi0J7Qv9GG0LjRj9GC0LAg4oCeLS1wcmVzZXJ2ZS1tZXJnZXPigJwg0LUg0L7RgdGC0LDRgNGP0LvQsC4gINCf0L7Qu9C30LLQsNC50YLQtSDigJ4tLXJlYmFzZS1tZXJnZXPigJwg0LLQvNC10YHRgtC+ICIKICLQvdC10Y8uIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE1NTEKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTU3NgorbXNnaWQgImNhbm5vdCBjb21iaW5lICctLWtlZXAtYmFzZScgd2l0aCAnLS1vbnRvJyIKK21zZ3N0ciAi0L7Qv9GG0LjQuNGC0LUg4oCeLS1rZWVwLWJhc2XigJwg0Lgg4oCeLS1vbnRv4oCcINGB0LAg0L3QtdGB0YrQstC80LXRgdGC0LjQvNC4IgorCisjOiBidWlsdGluL3JlYmFzZS5jOjE1NzgKK21zZ2lkICJjYW5ub3QgY29tYmluZSAnLS1rZWVwLWJhc2UnIHdpdGggJy0tcm9vdCciCittc2dzdHIgItC+0L/RhtC40LjRgtC1IOKAni0ta2VlcC1iYXNl4oCcINC4IOKAni0tcm9vdOKAnCDRgdCwINC90LXRgdGK0LLQvNC10YHRgtC40LzQuCIKKworIzogYnVpbHRpbi9yZWJhc2UuYzoxNTgyCiBtc2dpZCAiTm8gcmViYXNlIGluIHByb2dyZXNzPyIKIG1zZ3N0ciAi0JjQt9Cz0LvQtdC20LTQsCDQsiDQvNC+0LzQtdC90YLQsCDQvdC1INGC0LXRh9C1INC/0YDQtdCx0LDQt9C40YDQsNC90LUiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTU1NQorIzogYnVpbHRpbi9yZWJhc2UuYzoxNTg2CiBtc2dpZCAiVGhlIC0tZWRpdC10b2RvIGFjdGlvbiBjYW4gb25seSBiZSB1c2VkIGR1cmluZyBpbnRlcmFjdGl2ZSByZWJhc2UuIgogbXNnc3RyICIiCiAi0J7Qv9GG0LjRj9GC0LAg4oCeLS1lZGl0LXRvZG/igJwg0LUg0LTQvtGB0YLRitC/0L3QsCDRgdCw0LzQviDQv9C+INCy0YDQtdC80LUg0L3QsCDQuNC90YLQtdGA0LDQutGC0LjQstC90L4g0L/RgNC10LHQsNC30LjRgNCw0L3QtS4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTU3OAorIzogYnVpbHRpbi9yZWJhc2UuYzoxNjA5CiBtc2dpZCAiQ2Fubm90IHJlYWQgSEVBRCIKIG1zZ3N0ciAi0KPQutCw0LfQsNGC0LXQu9GP0YIg4oCeSEVBROKAnCDQvdC1INC80L7QttC1INC00LAg0LHRitC00LUg0L/RgNC+0YfQtdGC0LXQvSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNTkwCisjOiBidWlsdGluL3JlYmFzZS5jOjE2MjEKIG1zZ2lkICIiCiAiWW91IG11c3QgZWRpdCBhbGwgbWVyZ2UgY29uZmxpY3RzIGFuZCB0aGVuXG4iCiAibWFyayB0aGVtIGFzIHJlc29sdmVkIHVzaW5nIGdpdCBhZGQiCkBAIC0xODAwOSwxNiArMTgxMDYsMTYgQEAKICLQotGA0Y/QsdCy0LAg0LTQsCDRgNC10LTQsNC60YLQuNGA0LDRgtC1INCy0YHQuNGH0LrQuCDQutC+0L3RhNC70LjQutGC0Lgg0L/RgNC4INGB0LvQuNCy0LDQvdC10YLQvi4gINCh0LvQtdC0INGC0L7QstCwXG4iCiAi0L7RgtCx0LXQu9C10LbQtdGC0LUg0LrQvtGA0LjQs9C40YDQsNC90LXRgtC+INC40Lwg0YfRgNC10Lcg0LrQvtC80LDQvdC00LDRgtCwIOKAnmdpdCBhZGTigJwiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTYwOQorIzogYnVpbHRpbi9yZWJhc2UuYzoxNjQwCiBtc2dpZCAiY291bGQgbm90IGRpc2NhcmQgd29ya3RyZWUgY2hhbmdlcyIKIG1zZ3N0ciAi0L/RgNC+0LzQtdC90LjRgtC1INCyINGA0LDQsdC+0YLQvdC+0YLQviDQtNGK0YDQstC+INC90LUg0LzQvtCz0LDRgiDQtNCwINCx0YrQtNCw0YIg0LfQsNC90YPQu9C10L3QuCIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNjI4CisjOiBidWlsdGluL3JlYmFzZS5jOjE2NTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IG1vdmUgYmFjayB0byAlcyIKIG1zZ3N0ciAi0LLRgNGK0YnQsNC90LXRgtC+INC60YrQvCDigJ4lc+KAnCDQtSDQvdC10LLRitC30LzQvtC20L3QviIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNjczCisjOiBidWlsdGluL3JlYmFzZS5jOjE3MDQKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkl0IHNlZW1zIHRoYXQgdGhlcmUgaXMgYWxyZWFkeSBhICVzIGRpcmVjdG9yeSwgYW5kXG4iCkBAIC0xODAzOSwxNzEgKzE4MTM2LDE2MyBAQAogItC30LBcbiIKICLQtNCwINC90LUg0LfQsNCz0YPQsdC40YLQtSDRgdC70YPRh9Cw0LnQvdC+INC/0YDQvtC80LXQvdC4LlxuIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE2OTQKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTcyNQogbXNnaWQgInN3aXRjaCBgQycgZXhwZWN0cyBhIG51bWVyaWNhbCB2YWx1ZSIKIG1zZ3N0ciAi0L7Qv9GG0LjRj9GC0LAg4oCeQ+KAnCDQvtGH0LDQutCy0LAg0YfQuNGB0LvQviDQt9CwINCw0YDQs9GD0LzQtdC90YIiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTczNQorIzogYnVpbHRpbi9yZWJhc2UuYzoxNzY2CiAjLCBjLWZvcm1hdAogbXNnaWQgIlVua25vd24gbW9kZTogJXMiCiBtc2dzdHIgItCd0LXQuNC30LLQtdGB0YLQvdCwINGB0YLRgNCw0YLQtdCz0LjRjzog4oCeJXPigJwiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTc1NworIzogYnVpbHRpbi9yZWJhc2UuYzoxNzg4CiBtc2dpZCAiLS1zdHJhdGVneSByZXF1aXJlcyAtLW1lcmdlIG9yIC0taW50ZXJhY3RpdmUiCiBtc2dzdHIgIiIKICLQvtC/0YbQuNGP0YLQsCDigJ4tLXN0cmF0ZWd54oCcINC40LfQuNGB0LrQstCwINC90Y/QutC+0Y8g0L7RgiDQvtC/0YbQuNC40YLQtSDigJ4tLW1lcmdl4oCcINC40LvQuCDigJ4tLWludGVyYWN0aXZl4oCcIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE3OTcKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTgyOAogbXNnaWQgIi0tcmVzY2hlZHVsZS1mYWlsZWQtZXhlYyByZXF1aXJlcyAtLWV4ZWMgb3IgLS1pbnRlcmFjdGl2ZSIKIG1zZ3N0ciAiIgogItC+0L/RhtC40Y/RgtCwIOKAni0tcmVzY2hlZHVsZS1mYWlsZWQtZXhlY+KAnCDQuNC30LjRgdC60LLQsCDQvdGP0LrQvtGPINC+0YIg0L7Qv9GG0LjQuNGC0LUg4oCeLS1leGVj4oCcINC40LvQuCDigJ4tLSIKICJpbnRlcmFjdGl2ZeKAnCIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxODA5CisjOiBidWlsdGluL3JlYmFzZS5jOjE4NDAKIG1zZ2lkICJjYW5ub3QgY29tYmluZSBhbSBvcHRpb25zIHdpdGggZWl0aGVyIGludGVyYWN0aXZlIG9yIG1lcmdlIG9wdGlvbnMiCiBtc2dzdHIgIiIKICLQvtC/0YbQuNC40YLQtSDQt9CwIOKAnmFt4oCcINGB0LAg0L3QtdGB0YrQstC80LXRgdGC0LjQvNC4INGBINC+0L/RhtC40LjRgtC1INC30LAg0YHQu9C40LLQsNC90LUg0LjQu9C4INC30LAg0LjQvdGC0LXRgNCw0LrRgtC40LLQvdCwICIKICLRgNCw0LHQvtGC0LAiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTgyOAorIzogYnVpbHRpbi9yZWJhc2UuYzoxODU5CiBtc2dpZCAiY2Fubm90IGNvbWJpbmUgJy0tcHJlc2VydmUtbWVyZ2VzJyB3aXRoICctLXJlYmFzZS1tZXJnZXMnIgogbXNnc3RyICLQvtC/0YbQuNC40YLQtSDigJ4tLXByZXNlcnZlLW1lcmdlc+KAnCDQuCDigJ4tLXJlYmFzZS1tZXJnZXPigJwg0YHQsCDQvdC10YHRitCy0LzQtdGB0YLQuNC80LgiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTgzMgorIzogYnVpbHRpbi9yZWJhc2UuYzoxODYzCiBtc2dpZCAiIgogImVycm9yOiBjYW5ub3QgY29tYmluZSAnLS1wcmVzZXJ2ZS1tZXJnZXMnIHdpdGggJy0tcmVzY2hlZHVsZS1mYWlsZWQtZXhlYyciCiBtc2dzdHIgIiIKICLQk9Cg0JXQqNCa0JA6INC+0L/RhtC40LjRgtC1IOKAni0tcHJlc2VydmUtbWVyZ2Vz4oCcINC4IOKAni0tcmVzY2hlZHVsZS1mYWlsZWQtZXhlY+KAnCDRgdCwICIKICLQvdC10YHRitCy0LzQtdGB0YLQuNC80LgiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTgzOAotbXNnaWQgImNhbm5vdCBjb21iaW5lICctLXJlYmFzZS1tZXJnZXMnIHdpdGggJy0tc3RyYXRlZ3ktb3B0aW9uJyIKLW1zZ3N0ciAi0L7Qv9GG0LjQuNGC0LUg4oCeLS1yZWJhc2UtbWVyZ2Vz4oCcINC4IOKAni0tc3RyYXRlZ3ktb3B0aW9u4oCcINGB0LAg0L3QtdGB0YrQstC80LXRgdGC0LjQvNC4IgotCi0jOiBidWlsdGluL3JlYmFzZS5jOjE4NDEKLW1zZ2lkICJjYW5ub3QgY29tYmluZSAnLS1yZWJhc2UtbWVyZ2VzJyB3aXRoICctLXN0cmF0ZWd5JyIKLW1zZ3N0ciAi0L7Qv9GG0LjQuNGC0LUg4oCeLS1yZWJhc2UtbWVyZ2Vz4oCcINC4IOKAni0tc3RyYXRlZ3nigJwg0YHQsCDQvdC10YHRitCy0LzQtdGB0YLQuNC80LgiCi0KLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTg2NQorIzogYnVpbHRpbi9yZWJhc2UuYzoxODg3CiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgdXBzdHJlYW0gJyVzJyIKIG1zZ3N0ciAi0L3QtdC/0YDQsNCy0LjQu9C10L0g0YHQu9C10LTQtdC9INC60LvQvtC9OiDigJ4lc+KAnCIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxODcxCisjOiBidWlsdGluL3JlYmFzZS5jOjE4OTMKIG1zZ2lkICJDb3VsZCBub3QgY3JlYXRlIG5ldyByb290IGNvbW1pdCIKIG1zZ3N0ciAi0J3QtSDQvNC+0LbQtSDQtNCwINGB0LUg0YHRitC30LTQsNC00LUg0L3QvtCy0L4g0L3QsNGH0LDQu9C90L4g0L/QvtC00LDQstCw0L3QtSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxODg5CisjOiBidWlsdGluL3JlYmFzZS5jOjE5MTkKKyMsIGMtZm9ybWF0Cittc2dpZCAiJyVzJzogbmVlZCBleGFjdGx5IG9uZSBtZXJnZSBiYXNlIHdpdGggYnJhbmNoIgorbXNnc3RyICLigJ4lc+KAnDog0LjQt9C40YHQutCy0LAg0YHQtSDRgtC+0YfQvdC+INC10LTQvdCwINCx0LDQt9CwINC30LAg0YHQu9C40LLQsNC90LUg0YEg0LrQu9C+0L3QsCIKKworIzogYnVpbHRpbi9yZWJhc2UuYzoxOTIyCiAjLCBjLWZvcm1hdAogbXNnaWQgIiclcyc6IG5lZWQgZXhhY3RseSBvbmUgbWVyZ2UgYmFzZSIKIG1zZ3N0ciAi4oCeJXPigJw6INC40LfQuNGB0LrQstCwINGB0LUg0YLQvtGH0L3QviDQtdC00L3QsCDQsdCw0LfQsCDQt9CwINC/0YDQtdCx0LDQt9C40YDQsNC90LUiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTg5NgorIzogYnVpbHRpbi9yZWJhc2UuYzoxOTMwCiAjLCBjLWZvcm1hdAogbXNnaWQgIkRvZXMgbm90IHBvaW50IHRvIGEgdmFsaWQgY29tbWl0ICclcyciCiBtc2dzdHIgItCj0LrQsNC30LDRgtC10LvRj9GCIOKAniVz4oCcINC90LUg0YHQvtGH0Lgg0LrRitC8INC/0L7QtNCw0LLQsNC90LUiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTkyMQorIzogYnVpbHRpbi9yZWJhc2UuYzoxOTU1CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhdGFsOiBubyBzdWNoIGJyYW5jaC9jb21taXQgJyVzJyIKIG1zZ3N0ciAi0KTQkNCi0JDQm9Cd0JAg0JPQoNCV0KjQmtCQOiDQvdC1INGB0YrRidC10YHRgtCy0YPQstCwINC60LvQvtC9IOKAniVz4oCcIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE5MjkgYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjM4CisjOiBidWlsdGluL3JlYmFzZS5jOjE5NjMgYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjM4CiAjOiBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6MTkzNAogIywgYy1mb3JtYXQKIG1zZ2lkICJObyBzdWNoIHJlZjogJXMiCiBtc2dzdHIgItCi0LDQutGK0LIg0YPQutCw0LfQsNGC0LXQuyDQvdGP0LzQsDogJXMiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTk0MAorIzogYnVpbHRpbi9yZWJhc2UuYzoxOTc0CiBtc2dpZCAiQ291bGQgbm90IHJlc29sdmUgSEVBRCB0byBhIHJldmlzaW9uIgogbXNnc3RyICLQn9C+0LTQsNCy0LDQvdC10YLQviwg0YHQvtGH0LXQvdC+INC+0YIg0YPQutCw0LfQsNGC0LXQu9GPIOKAnkhFQUTigJwsINC90LUg0LzQvtC20LUg0LTQsCDQsdGK0LTQtSDQvtGC0LrRgNC40YLQviIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxOTgxCisjOiBidWlsdGluL3JlYmFzZS5jOjIwMTIKIG1zZ2lkICJDYW5ub3QgYXV0b3N0YXNoIgogbXNnc3RyICLQndC1INC80L7QttC1INC00LAg0YHQtSDRgdC60LDRgtCw0LUg0LDQstGC0L7QvNCw0YLQuNGH0L3QviIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxOTg0CisjOiBidWlsdGluL3JlYmFzZS5jOjIwMTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiVW5leHBlY3RlZCBzdGFzaCByZXNwb25zZTogJyVzJyIKIG1zZ3N0ciAi0J3QtdC+0YfQsNC60LLQsNC9INGA0LXQt9GD0LvRgtCw0YIg0L/RgNC4INGB0LrQsNGC0LDQstCw0L3QtTog4oCeJXPigJwiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTk5MAorIzogYnVpbHRpbi9yZWJhc2UuYzoyMDIxCiAjLCBjLWZvcm1hdAogbXNnaWQgIkNvdWxkIG5vdCBjcmVhdGUgZGlyZWN0b3J5IGZvciAnJXMnIgogbXNnc3RyICLQlNC40YDQtdC60YLQvtGA0LjRj9GC0LAg0LfQsCDigJ4lc+KAnCDQvdC1INC80L7QttC1INC00LAg0LHRitC00LUg0YHRitC30LTQsNC00LXQvdCwIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE5OTMKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MjAyNAogIywgYy1mb3JtYXQKIG1zZ2lkICJDcmVhdGVkIGF1dG9zdGFzaDogJXNcbiIKIG1zZ3N0ciAi0JDQstGC0L7QvNCw0YLQuNGH0L3QviDRgdC60LDRgtCw0L3Qvjog4oCeJXPigJxcbiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxOTk2CisjOiBidWlsdGluL3JlYmFzZS5jOjIwMjcKIG1zZ2lkICJjb3VsZCBub3QgcmVzZXQgLS1oYXJkIgogbXNnc3RyICLQvdC10YPRgdC/0LXRiNC90L4g0LjQt9C/0YrQu9C90LXQvdC40LUg0L3QsCDigJ5naXQgcmVzZXQgLS1oYXJk4oCcIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE5OTcgYnVpbHRpbi9yZXNldC5jOjExNAotIywgYy1mb3JtYXQKLW1zZ2lkICJIRUFEIGlzIG5vdyBhdCAlcyIKLW1zZ3N0ciAi0KPQutCw0LfQsNGC0LXQu9GP0YIg4oCeSEVBROKAnCDRgdC+0YfQuCDQutGK0Lwg4oCeJXPigJwiCi0KLSM6IGJ1aWx0aW4vcmViYXNlLmM6MjAxMworIzogYnVpbHRpbi9yZWJhc2UuYzoyMDM2CiBtc2dpZCAiUGxlYXNlIGNvbW1pdCBvciBzdGFzaCB0aGVtLiIKIG1zZ3N0ciAi0J/RgNC+0LzQtdC90LjRgtC1INGC0YDRj9Cx0LLQsCDQuNC70Lgg0LTQsCDRgdC1INC/0L7QtNCw0LTQsNGCLCDQuNC70Lgg0LTQsCDRgdC1INGB0LrQsNGC0LDRj9GCLiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoyMDQwCisjOiBidWlsdGluL3JlYmFzZS5jOjIwNjMKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHBhcnNlICclcyciCiBtc2dzdHIgIuKAniVz4oCcINC90LUg0LzQvtC20LUg0LTQsCDRgdC1INCw0L3QsNC70LjQt9C40YDQsCIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoyMDUzCisjOiBidWlsdGluL3JlYmFzZS5jOjIwNzYKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHN3aXRjaCB0byAlcyIKIG1zZ3N0ciAi0L3QtSDQvNC+0LbQtSDQtNCwINGB0LUg0L/RgNC10LzQuNC90LUg0LrRitC8IOKAniVz4oCcIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjIwNjQKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MjA4NwogbXNnaWQgIkhFQUQgaXMgdXAgdG8gZGF0ZS4iCiBtc2dzdHIgItCj0LrQsNC30LDRgtC10LvRj9GCIOKAnkhFQUTigJwg0LUg0L3QsNC/0YrQu9C90L4g0LDQutGC0YPQsNC70LXQvS4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MjA2NgorIzogYnVpbHRpbi9yZWJhc2UuYzoyMDg5CiAjLCBjLWZvcm1hdAogbXNnaWQgIkN1cnJlbnQgYnJhbmNoICVzIGlzIHVwIHRvIGRhdGUuXG4iCiBtc2dzdHIgItCi0LXQutGD0YnQuNGP0YIg0LrQu9C+0L0g4oCeJXPigJwg0LUg0L3QsNC/0YrQu9C90L4g0LDQutGC0YPQsNC70LXQvS5cbiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoyMDc0CisjOiBidWlsdGluL3JlYmFzZS5jOjIwOTcKIG1zZ2lkICJIRUFEIGlzIHVwIHRvIGRhdGUsIHJlYmFzZSBmb3JjZWQuIgogbXNnc3RyICLQo9C60LDQt9Cw0YLQtdC70Y/RgiDigJ5IRUFE4oCcINC1INC90LDQv9GK0LvQvdC+INCw0LrRgtGD0LDQu9C10L0g4oCUINC/0YDQuNC90YPQtNC40YLQtdC70L3QviDQv9GA0LXQsdCw0LfQuNGA0LDQvdC1IgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjIwNzYKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MjA5OQogIywgYy1mb3JtYXQKIG1zZ2lkICJDdXJyZW50IGJyYW5jaCAlcyBpcyB1cCB0byBkYXRlLCByZWJhc2UgZm9yY2VkLlxuIgogbXNnc3RyICLQotC10LrRg9GJ0LjRj9GCINC60LvQvtC9IOKAniVz4oCcINC1INC90LDQv9GK0LvQvdC+INCw0LrRgtGD0LDQu9C10L0g4oCUINC/0YDQuNC90YPQtNC40YLQtdC70L3QviDQv9GA0LXQsdCw0LfQuNGA0LDQvdC1XG4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MjA4NAorIzogYnVpbHRpbi9yZWJhc2UuYzoyMTA3CiBtc2dpZCAiVGhlIHByZS1yZWJhc2UgaG9vayByZWZ1c2VkIHRvIHJlYmFzZS4iCiBtc2dzdHIgItCa0YPQutCw0YLQsCDQt9CwINC40LfQv9GK0LvQvdC10L3QuNC1INC/0YDQtdC00Lgg0L/RgNC10LHQsNC30LjRgNCw0L3QtSDQvtGC0YXQstGK0YDQu9C4INC/0YDQtdCx0LDQt9C40YDQsNC90LXRgtC+LiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoyMDkxCisjOiBidWlsdGluL3JlYmFzZS5jOjIxMTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ2hhbmdlcyB0byAlczpcbiIKIG1zZ3N0ciAi0J/RgNC+0LzQtdC90LjRgtC1INCyIOKAniVz4oCcOlxuIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjIwOTQKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MjExNwogIywgYy1mb3JtYXQKIG1zZ2lkICJDaGFuZ2VzIGZyb20gJXMgdG8gJXM6XG4iCiBtc2dzdHIgItCf0YDQvtC80LXQvdC40YLQtSDQvtGCIOKAniVz4oCcINC60YrQvCDigJ4lc+KAnDpcbiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoyMTE5CisjOiBidWlsdGluL3JlYmFzZS5jOjIxNDIKICMsIGMtZm9ybWF0CiBtc2dpZCAiRmlyc3QsIHJld2luZGluZyBoZWFkIHRvIHJlcGxheSB5b3VyIHdvcmsgb24gdG9wIG9mIGl0Li4uXG4iCiBtc2dzdHIgIiIKICLQn9GK0YDQstC+LCDRg9C60LDQt9Cw0YLQtdC70Y/RgiDigJ5IRUFE4oCcINC30LDQv9C+0YfQstCwINC00LAg0YHQvtGH0Lgg0LrRitC8INCx0LDQt9Cw0YLQsCwg0LLRitGA0YXRgyDQutC+0Y/RgtC+ICIKICLQv9GA0LXQsdCw0LfQuNGA0LDRgtC14oCmXG4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MjEyOAorIzogYnVpbHRpbi9yZWJhc2UuYzoyMTUxCiBtc2dpZCAiQ291bGQgbm90IGRldGFjaCBIRUFEIgogbXNnc3RyICLQo9C60LDQt9Cw0YLQtdC70Y/RgiDigJ5IRUFE4oCcINC90LUg0LzQvtC20LUg0LTQsCDRgdC1INC+0YLQtNC10LvRnSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoyMTM3CisjOiBidWlsdGluL3JlYmFzZS5jOjIxNjAKICMsIGMtZm9ybWF0CiBtc2dpZCAiRmFzdC1mb3J3YXJkZWQgJXMgdG8gJXMuXG4iCiBtc2dzdHIgItCf0YDQtdCy0YrRgNGC0LDQvdC1INC90LAg4oCeJXPigJwg0LrRitC8IOKAniVz4oCcLlxuIgpAQCAtMTgyMTIsNyArMTgzMDEsNyBAQAogbXNnaWQgImdpdCByZWNlaXZlLXBhY2sgPGdpdC1kaXI+IgogbXNnc3RyICJnaXQgcmVjZWl2ZS1wYWNrINCU0JjQoNCV0JrQotCe0KDQmNCvX9Cd0JBfR0lUIgogCi0jOiBidWlsdGluL3JlY2VpdmUtcGFjay5jOjgzMgorIzogYnVpbHRpbi9yZWNlaXZlLXBhY2suYzo4MzAKIG1zZ2lkICIiCiAiQnkgZGVmYXVsdCwgdXBkYXRpbmcgdGhlIGN1cnJlbnQgYnJhbmNoIGluIGEgbm9uLWJhcmUgcmVwb3NpdG9yeVxuIgogImlzIGRlbmllZCwgYmVjYXVzZSBpdCB3aWxsIG1ha2UgdGhlIGluZGV4IGFuZCB3b3JrIHRyZWUgaW5jb25zaXN0ZW50XG4iCkBAIC0xODI0NSw3ICsxODMzNCw3IEBACiAi0JfQsCDQtNCwINC30LDQs9C70YPRiNC40YLQtSDRgtC+0LLQsCDRgdGK0L7QsdGJ0LXQvdC40LUsINC60LDRgtC+INC30LDQv9Cw0LfQuNGC0LUg0YHRgtCw0L3QtNCw0YDRgtC90L7RgtC+INC/0L7QstC10LTQtdC90LjQtSxcbiIKICLQt9Cw0LTQsNC50YLQtSDQvdCw0YHRgtGA0L7QudC60LDRgtCwIOKAnnJlY2VpdmUuZGVueUN1cnJlbnRCcmFuY2jigJwg0LTQsCDQtSDigJ5yZWZ1c2XigJwgKNC+0YLQutCw0LcpLiIKIAotIzogYnVpbHRpbi9yZWNlaXZlLXBhY2suYzo4NTIKKyM6IGJ1aWx0aW4vcmVjZWl2ZS1wYWNrLmM6ODUwCiBtc2dpZCAiIgogIkJ5IGRlZmF1bHQsIGRlbGV0aW5nIHRoZSBjdXJyZW50IGJyYW5jaCBpcyBkZW5pZWQsIGJlY2F1c2UgdGhlIG5leHRcbiIKICInZ2l0IGNsb25lJyB3b24ndCByZXN1bHQgaW4gYW55IGZpbGUgY2hlY2tlZCBvdXQsIGNhdXNpbmcgY29uZnVzaW9uLlxuIgpAQCAtMTgyNjYsMTEgKzE4MzU1LDExIEBACiAi0JfQsCDQtNCwINC30LDQs9C70YPRiNC40YLQtSDRgtC+0LLQsCDRgdGK0L7QsdGJ0LXQvdC40LUsINC30LDQtNCw0LnRgtC1INC90LDRgdGC0YDQvtC50LrQsNGC0LBcbiIKICLigJ5yZWNlaXZlLmRlbnlEZWxldGVDdXJyZW504oCcINC00LAg0LUg4oCecmVmdXNl4oCcICjQvtGC0LrQsNC3KS4iCiAKLSM6IGJ1aWx0aW4vcmVjZWl2ZS1wYWNrLmM6MTkzOAorIzogYnVpbHRpbi9yZWNlaXZlLXBhY2suYzoxOTM2CiBtc2dpZCAicXVpZXQiCiBtc2dzdHIgItCx0LXQtyDQuNC30LLQtdC20LTQsNC90LUg0L3QsCDQuNC90YTQvtGA0LzQsNGG0LjRjyIKIAotIzogYnVpbHRpbi9yZWNlaXZlLXBhY2suYzoxOTUyCisjOiBidWlsdGluL3JlY2VpdmUtcGFjay5jOjE5NTAKIG1zZ2lkICJZb3UgbXVzdCBzcGVjaWZ5IGEgZGlyZWN0b3J5LiIKIG1zZ3N0ciAi0KLRgNGP0LHQstCwINC00LAg0YPQutCw0LbQtdGC0LUg0LTQuNGA0LXQutGC0L7RgNC40Y8uIgogCkBAIC0xODg1MSwxMSArMTg5NDAsMTEgQEAKIG1zZ2lkICJVbmtub3duIHN1YmNvbW1hbmQ6ICVzIgogbXNnc3RyICLQndC10L/QvtC30L3QsNGC0LAg0L/QvtC00LrQvtC80LDQvdC00LA6ICVzIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjIyCisjOiBidWlsdGluL3JlcGFjay5jOjIzCiBtc2dpZCAiZ2l0IHJlcGFjayBbPG9wdGlvbnM+XSIKIG1zZ3N0ciAiZ2l0IHJlcGFjayBb0J7Qn9Cm0JjQr+KApl0iCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MjcKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6MjgKIG1zZ2lkICIiCiAiSW5jcmVtZW50YWwgcmVwYWNrcyBhcmUgaW5jb21wYXRpYmxlIHdpdGggYml0bWFwIGluZGV4ZXMuICBVc2VcbiIKICItLW5vLXdyaXRlLWJpdG1hcC1pbmRleCBvciBkaXNhYmxlIHRoZSBwYWNrLndyaXRlYml0bWFwcyBjb25maWd1cmF0aW9uLiIKQEAgLTE4ODY0LDEyNiArMTg5NTMsMTI2IEBACiAi0J/QvtC70LfQstCw0LnRgtC1INC+0L/RhtC40Y/RgtCwIC0tbm8td3JpdGUtYml0bWFwLWluZGV4INC40LvQuCDQuNC30LrQu9GO0YfQtdGC0LUg0L3QsNGB0YLRgNC+0LnQutCw0YLQsFxuIgogIuKAnnBhY2sud3JpdGViaXRtYXBz4oCcLiIKIAotIzogYnVpbHRpbi9yZXBhY2suYzoxOTAKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6MTkxCiBtc2dpZCAiY291bGQgbm90IHN0YXJ0IHBhY2stb2JqZWN0cyB0byByZXBhY2sgcHJvbWlzb3Igb2JqZWN0cyIKIG1zZ3N0ciAiIgogItC60L7QvNCw0L3QtNCw0YLQsCDigJ5wYWNrLW9iamVjdHPigJwg0L3QtSDQvNC+0LbQtSDQtNCwINGB0LUg0YHRgtCw0YDRgtC40YDQsCDQt9CwINC/0YDQtdC/0LDQutC10YLQuNGA0LDQvdC10YLQviDQvdCwICIKICLQs9Cw0YDQsNC90YLQuNGA0LDRidC40YLQtSDQvtCx0LXQutGC0LgiCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MjI5IGJ1aWx0aW4vcmVwYWNrLmM6NDA4CisjOiBidWlsdGluL3JlcGFjay5jOjIzMCBidWlsdGluL3JlcGFjay5jOjQwOQogbXNnaWQgInJlcGFjazogRXhwZWN0aW5nIGZ1bGwgaGV4IG9iamVjdCBJRCBsaW5lcyBvbmx5IGZyb20gcGFjay1vYmplY3RzLiIKIG1zZ3N0ciAiIgogInJlcGFjazog0L7RgiDigJ5wYWNrLW9iamVjdHPigJwg0YHQtSDQvtGH0LDQutCy0LDRgiDRgNC10LTQvtCy0LUg0YHQsNC80L4g0YEg0L/RitC70L3QuCDRiNC10YHRgtC90LDQudGB0LXRgtC40YfQvdC4ICIKICLRg9C60LDQt9Cw0YLQtdC70LguIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjI0NgorIzogYnVpbHRpbi9yZXBhY2suYzoyNDcKIG1zZ2lkICJjb3VsZCBub3QgZmluaXNoIHBhY2stb2JqZWN0cyB0byByZXBhY2sgcHJvbWlzb3Igb2JqZWN0cyIKIG1zZ3N0ciAiIgogItC60L7QvNCw0L3QtNCw0YLQsCDigJ5wYWNrLW9iamVjdHPigJwg0L3QtSDQvNC+0LbQtSDQtNCwINC30LDQstGK0YDRiNC4INC30LAg0L/RgNC10L/QsNC60LXRgtC40YDQsNC90LXRgtC+INC90LAgIgogItCz0LDRgNCw0L3RgtC40YDQsNGJ0LjRgtC1INC+0LHQtdC60YLQuCIKIAotIzogYnVpbHRpbi9yZXBhY2suYzoyODQKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6Mjg1CiBtc2dpZCAicGFjayBldmVyeXRoaW5nIGluIGEgc2luZ2xlIHBhY2siCiBtc2dzdHIgItC/0LDQutC10YLQuNGA0LDQvdC1INC90LAg0LLRgdC40YfQutC+INCyINC/0LDQutC10YIiCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6Mjg2CisjOiBidWlsdGluL3JlcGFjay5jOjI4NwogbXNnaWQgInNhbWUgYXMgLWEsIGFuZCB0dXJuIHVucmVhY2hhYmxlIG9iamVjdHMgbG9vc2UiCiBtc2dzdHIgIiIKICLRgdGK0YnQvtGC0L4g0LrQsNGC0L4g0L7Qv9GG0LjRj9GC0LAg4oCeLWHigJwuICDQlNC+0L/RitC70L3QuNGC0LXQu9C90L4g4oCUINC90LXQtNC+0YHRgtC40LbQuNC80LjRgtC1INC+0LHQtdC60YLQuCDQtNCwINGB0YLQsNC90LDRgiAiCiAi0L3QtdC/0LDQutC10YLQuNGA0LDQvdC4IgogCi0jOiBidWlsdGluL3JlcGFjay5jOjI4OQorIzogYnVpbHRpbi9yZXBhY2suYzoyOTAKIG1zZ2lkICJyZW1vdmUgcmVkdW5kYW50IHBhY2tzLCBhbmQgcnVuIGdpdC1wcnVuZS1wYWNrZWQiCiBtc2dzdHIgIiIKICLQv9GA0LXQvNCw0YXQstCw0L3QtSDQvdCwINC90LXQvdGD0LbQvdC40YLQtSDQv9Cw0LrQtdGC0LjRgNCw0L3QuCDRhNCw0LnQu9C+0LLQtSDQuCDQuNC30L/RitC70L3QtdC90LjQtSDQvdCwINC60L7QvNCw0L3QtNCw0YLQsCDigJ5naXQtIgogInBydW5lLXBhY2tlZOKAnCIKIAotIzogYnVpbHRpbi9yZXBhY2suYzoyOTEKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6MjkyCiBtc2dpZCAicGFzcyAtLW5vLXJldXNlLWRlbHRhIHRvIGdpdC1wYWNrLW9iamVjdHMiCiBtc2dzdHIgItC/0L7QtNCw0LLQsNC90LUg0L3QsCDQvtC/0YbQuNGP0YLQsCDigJ4tLW5vLXJldXNlLWRlbHRh4oCcINC90LAg0LrQvtC80LDQvdC00LDRgtCwIOKAnmdpdC1wYWNrLW9iamVjdHPigJwiCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MjkzCisjOiBidWlsdGluL3JlcGFjay5jOjI5NAogbXNnaWQgInBhc3MgLS1uby1yZXVzZS1vYmplY3QgdG8gZ2l0LXBhY2stb2JqZWN0cyIKIG1zZ3N0ciAiIgogItC/0L7QtNCw0LLQsNC90LUg0L3QsCDQvtC/0YbQuNGP0YLQsCDigJ4tLW5vLXJldXNlLW9iamVjdOKAnCDQvdCwINC60L7QvNCw0L3QtNCw0YLQsCDigJ5naXQtcGFjay1vYmplY3Rz4oCcIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjI5NQorIzogYnVpbHRpbi9yZXBhY2suYzoyOTYKIG1zZ2lkICJkbyBub3QgcnVuIGdpdC11cGRhdGUtc2VydmVyLWluZm8iCiBtc2dzdHIgItCx0LXQtyDQuNC30L/RitC70L3QtdC90LjQtSDQvdCwINC60L7QvNCw0L3QtNCw0YLQsCDigJ5naXQtdXBkYXRlLXNlcnZlci1pbmZv4oCcIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjI5OAorIzogYnVpbHRpbi9yZXBhY2suYzoyOTkKIG1zZ2lkICJwYXNzIC0tbG9jYWwgdG8gZ2l0LXBhY2stb2JqZWN0cyIKIG1zZ3N0ciAi0L/QvtC00LDQstCw0L3QtSDQvdCwINC+0L/RhtC40Y/RgtCwIOKAni0tbG9jYWzigJwg0L3QsCDQutC+0LzQsNC90LTQsNGC0LAg4oCeZ2l0LXBhY2stb2JqZWN0c+KAnCIKIAotIzogYnVpbHRpbi9yZXBhY2suYzozMDAKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6MzAxCiBtc2dpZCAid3JpdGUgYml0bWFwIGluZGV4IgogbXNnc3RyICLRgdGK0LfQtNCw0LLQsNC90LUg0Lgg0LfQsNC/0LjRgdCy0LDQvdC1INC90LAg0LjQvdC00LXQutGB0Lgg0L3QsCDQsdCw0LfQsCDQsdC40YLQvtCy0Lgg0LzQsNGB0LrQuCIKIAotIzogYnVpbHRpbi9yZXBhY2suYzozMDIKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6MzAzCiBtc2dpZCAicGFzcyAtLWRlbHRhLWlzbGFuZHMgdG8gZ2l0LXBhY2stb2JqZWN0cyIKIG1zZ3N0ciAi0L/QvtC00LDQstCw0L3QtSDQvdCwINC+0L/RhtC40Y/RgtCwIOKAni0tZGVsdGEtaXNsYW5kc+KAnCDQvdCwINC60L7QvNCw0L3QtNCw0YLQsCDigJ5naXQtcGFjay1vYmplY3Rz4oCcIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjMwMworIzogYnVpbHRpbi9yZXBhY2suYzozMDQKIG1zZ2lkICJhcHByb3hpZGF0ZSIKIG1zZ3N0ciAi0LXQstGA0LjRgdGC0LjRh9C90LAg0LTQsNGC0LAiCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MzA0CisjOiBidWlsdGluL3JlcGFjay5jOjMwNQogbXNnaWQgIndpdGggLUEsIGRvIG5vdCBsb29zZW4gb2JqZWN0cyBvbGRlciB0aGFuIHRoaXMiCiBtc2dzdHIgIiIKICLQv9GA0Lgg0LrQvtC80LHQuNC90LjRgNCw0L3QtdGC0L4g0YEg0L7Qv9GG0LjRj9GC0LAg4oCeLUHigJwg4oCUINCx0LXQtyDRgNCw0LfQv9Cw0LrQtdGC0LjRgNCw0L3QtSDQvdCwINC+0LHQtdC60YLQuNGC0LUg0L/QviDRgdGC0LDRgNC4INC+0YIgIgogItGC0L7QstCwIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjMwNgorIzogYnVpbHRpbi9yZXBhY2suYzozMDcKIG1zZ2lkICJ3aXRoIC1hLCByZXBhY2sgdW5yZWFjaGFibGUgb2JqZWN0cyIKIG1zZ3N0ciAi0YEg4oCeLWHigJwg4oCUINC/0YDQtdC/0LDQutC10YLQuNGA0LDQvdC1INC90LAg0L3QtdC00L7RgdGC0LjQttC40LzQuNGC0LUg0L7QsdC10LrRgtC4IgogCi0jOiBidWlsdGluL3JlcGFjay5jOjMwOAorIzogYnVpbHRpbi9yZXBhY2suYzozMDkKIG1zZ2lkICJzaXplIG9mIHRoZSB3aW5kb3cgdXNlZCBmb3IgZGVsdGEgY29tcHJlc3Npb24iCiBtc2dzdHIgItGA0LDQt9C80LXRgCDQvdCwINC/0YDQvtC30L7RgNC10YbQsCDQt9CwINC00LXQu9GC0LAg0LrQvtC80L/RgNC10YHQuNGP0YLQsCIKIAotIzogYnVpbHRpbi9yZXBhY2suYzozMDkgYnVpbHRpbi9yZXBhY2suYzozMTUKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6MzEwIGJ1aWx0aW4vcmVwYWNrLmM6MzE2CiBtc2dpZCAiYnl0ZXMiCiBtc2dzdHIgItCx0LDQudGC0L7QstC1IgogCi0jOiBidWlsdGluL3JlcGFjay5jOjMxMAorIzogYnVpbHRpbi9yZXBhY2suYzozMTEKIG1zZ2lkICJzYW1lIGFzIHRoZSBhYm92ZSwgYnV0IGxpbWl0IG1lbW9yeSBzaXplIGluc3RlYWQgb2YgZW50cmllcyBjb3VudCIKIG1zZ3N0ciAiIgogItGB0YrRidC+0YLQviDQutCw0YLQviDQs9C+0YDQvdCw0YLQsCDQvtC/0YbQuNGPLCDQvdC+INC+0LPRgNCw0L3QuNGH0LXQvdC40LXRgtC+INC00LAg0LUg0L/QviDRgNCw0LfQvNC10YAg0L3QsCDQv9Cw0LzQtdGC0YLQsCwg0LAg0L3QtSAiCiAi0L/QviDQsdGA0L7RjyDQvdCwINC+0LHQtdC60YLQuNGC0LUiCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MzEyCisjOiBidWlsdGluL3JlcGFjay5jOjMxMwogbXNnaWQgImxpbWl0cyB0aGUgbWF4aW11bSBkZWx0YSBkZXB0aCIKIG1zZ3N0ciAi0L7Qs9GA0LDQvdC40YfQsNCy0LDQvdC1INC90LAg0LzQsNC60YHQuNC80LDQu9C90LDRgtCwINC00YrQu9Cx0L7Rh9C40L3QsCDQvdCwINC00LXQu9GC0LDRgtCwIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjMxNAorIzogYnVpbHRpbi9yZXBhY2suYzozMTUKIG1zZ2lkICJsaW1pdHMgdGhlIG1heGltdW0gbnVtYmVyIG9mIHRocmVhZHMiCiBtc2dzdHIgItC+0LPRgNCw0L3QuNGH0LDQstCw0L3QtSDQvdCwINC80LDQutGB0LjQvNCw0LvQvdC40Y8g0LHRgNC+0Lkg0L3QuNGI0LrQuCIKIAotIzogYnVpbHRpbi9yZXBhY2suYzozMTYKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6MzE3CiBtc2dpZCAibWF4aW11bSBzaXplIG9mIGVhY2ggcGFja2ZpbGUiCiBtc2dzdHIgItC80LDQutGB0LjQvNCw0LvQtdC9INGA0LDQt9C80LXRgCDQvdCwINCy0YHQtdC60Lgg0L/QsNC60LXRgiIKIAotIzogYnVpbHRpbi9yZXBhY2suYzozMTgKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6MzE5CiBtc2dpZCAicmVwYWNrIG9iamVjdHMgaW4gcGFja3MgbWFya2VkIHdpdGggLmtlZXAiCiBtc2dzdHIgItC/0YDQtdC/0LDQutC10YLQuNGA0LDQvdC1INC90LAg0L7QsdC10LrRgtC40YLQtSDQsiDQv9Cw0LrQtdGC0Lgg0LHQtdC70Y/Qt9Cw0L3QuCDRgSDigJ4ua2VlcOKAnCIKIAotIzogYnVpbHRpbi9yZXBhY2suYzozMjAKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6MzIxCiBtc2dpZCAiZG8gbm90IHJlcGFjayB0aGlzIHBhY2siCiBtc2dzdHIgItCx0LXQtyDQv9GA0LXQv9Cw0LrQtdGC0LjRgNCw0L3QtSDQvdCwINGC0L7Qt9C4INC/0LDQutC10YIiCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MzMwCisjOiBidWlsdGluL3JlcGFjay5jOjMzMQogbXNnaWQgImNhbm5vdCBkZWxldGUgcGFja3MgaW4gYSBwcmVjaW91cy1vYmplY3RzIHJlcG8iCiBtc2dzdHIgItC/0LDQutC10YLQuNGC0LUg0LIg0YXRgNCw0L3QuNC70LjRidC1INGBINCy0LDQttC90Lgg0L7QsdC10LrRgtC4INC90LUg0LzQvtC20LUg0LTQsCDRgdC1INGC0YDQuNGP0YIiCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MzM0CisjOiBidWlsdGluL3JlcGFjay5jOjMzNQogbXNnaWQgIi0ta2VlcC11bnJlYWNoYWJsZSBhbmQgLUEgYXJlIGluY29tcGF0aWJsZSIKIG1zZ3N0ciAi0J7Qv9GG0LjQuNGC0LUg4oCeLS1rZWVwLXVucmVhY2hhYmxl4oCcINC4IOKAni1B4oCcINGB0LAg0L3QtdGB0YrQstC80LXRgdGC0LjQvNC4IgogCi0jOiBidWlsdGluL3JlcGFjay5jOjQxNworIzogYnVpbHRpbi9yZXBhY2suYzo0MTgKIG1zZ2lkICJOb3RoaW5nIG5ldyB0byBwYWNrLiIKIG1zZ3N0ciAi0J3QuNGJ0L4g0L3QvtCy0L4g0LfQsCDQv9Cw0LrQtdGC0LjRgNCw0L3QtSIKIAotIzogYnVpbHRpbi9yZXBhY2suYzo0NzgKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6NDc5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJXQVJOSU5HOiBTb21lIHBhY2tzIGluIHVzZSBoYXZlIGJlZW4gcmVuYW1lZCBieVxuIgpAQCAtMTkwMDEsNyArMTkwOTAsNyBAQAogItCf0KDQldCU0KPQn9Cg0JXQltCU0JXQndCY0JU6INC4zIAg4oCUINC30LAg0LLRgNGK0YnQsNC90LXRgtC+INC90LAg0L/RitGA0LLQvtC90LDRh9Cw0LvQvdC40YLQtSDQuNC80LXQvdCwLlxuIgogItCf0KDQldCU0KPQn9Cg0JXQltCU0JXQndCY0JU6INCf0YDQtdC40LzQtdC90YPQstCw0LnRgtC1INGE0LDQudC70L7QstC10YLQtSDQsiDigJ4lc+KAnCDRgNGK0YfQvdC+OlxuIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjUyNgorIzogYnVpbHRpbi9yZXBhY2suYzo1MjcKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIHJlbW92ZSAnJXMnIgogbXNnc3RyICLQtNC40YDQtdC60YLQvtGA0LjRj9GC0LAg4oCeJXPigJwg0L3QtSDQvNC+0LbQtSDQtNCwINCx0YrQtNC1INC40LfRgtGA0LjRgtCwIgpAQCAtMTkxMDksOCArMTkxOTgsOCBAQAogbXNnaWQgInVuYWJsZSB0byB3cml0ZSBvYmplY3QgdG8gZGF0YWJhc2UiCiBtc2dzdHIgItC+0LHQtdC60YLRitGCINC90LUg0LzQvtC20LUg0LTQsCDQsdGK0LTQtSDQt9Cw0L/QuNGB0LDQvSDQsiDQsdCw0LfQsNGC0LAg0L7RgiDQtNCw0L3QvdC4IgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzozMjIgYnVpbHRpbi9yZXBsYWNlLmM6Mzc3IGJ1aWx0aW4vcmVwbGFjZS5jOjQyMgotIzogYnVpbHRpbi9yZXBsYWNlLmM6NDUyCisjOiBidWlsdGluL3JlcGxhY2UuYzozMjIgYnVpbHRpbi9yZXBsYWNlLmM6Mzc4IGJ1aWx0aW4vcmVwbGFjZS5jOjQyMworIzogYnVpbHRpbi9yZXBsYWNlLmM6NDUzCiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vdCBhIHZhbGlkIG9iamVjdCBuYW1lOiAnJXMnIgogbXNnc3RyICLQvdC10L/RgNCw0LLQuNC70L3QviDQuNC80LUg0L3QsCDQvtCx0LXQutGCOiDigJ4lc+KAnCIKQEAgLTE5MTI5LDIyICsxOTIxOCwyMiBAQAogbXNnaWQgIm5ldyBvYmplY3QgaXMgdGhlIHNhbWUgYXMgdGhlIG9sZCBvbmU6ICclcyciCiBtc2dzdHIgItC90L7QstC40Y/RgiDQuCDRgdGC0LDRgNC40Y/RgiDQvtCx0LXQutGCINGB0LAg0LXQtNC40L0g0Lgg0YHRitGJOiDigJ4lc+KAnCIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6MzgzCisjOiBidWlsdGluL3JlcGxhY2UuYzozODQKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHBhcnNlICVzIGFzIGEgY29tbWl0IgogbXNnc3RyICLigJ4lc+KAnCDQvdC1INC80L7QttC1INC00LAg0YHQtSDQsNC90LDQu9C40LfQuNGA0LAg0LrQsNGC0L4g0L/QvtC00LDQstCw0L3QtSIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NDE0CisjOiBidWlsdGluL3JlcGxhY2UuYzo0MTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiYmFkIG1lcmdldGFnIGluIGNvbW1pdCAnJXMnIgogbXNnc3RyICLQtdGC0LjQutC10YLRitGCINC/0YDQuCDRgdC70LjQstCw0L3QtSDQsiDQv9C+0LTQsNCy0LDQvdC10YLQviDigJ4lc+KAnCBlINC90LXQv9GA0LDQstC40LvQtdC9IgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo0MTYKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjQxNwogIywgYy1mb3JtYXQKIG1zZ2lkICJtYWxmb3JtZWQgbWVyZ2V0YWcgaW4gY29tbWl0ICclcyciCiBtc2dzdHIgItC10YLQuNC60LXRgtGK0YIg0L/RgNC4INGB0LvQuNCy0LDQvdC1INCyINC/0L7QtNCw0LLQsNC90LXRgtC+IOKAniVz4oCcIGUg0L3QtdC/0YDQsNCy0LjQu9C10L0iCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjQyOAorIzogYnVpbHRpbi9yZXBsYWNlLmM6NDI5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJvcmlnaW5hbCBjb21taXQgJyVzJyBjb250YWlucyBtZXJnZXRhZyAnJXMnIHRoYXQgaXMgZGlzY2FyZGVkOyB1c2UgLS1lZGl0ICIKQEAgLTE5MTUzLDMxICsxOTI0MiwzMSBAQAogItCf0YrRgNCy0L7QvdCw0YfQsNC70L3QvtGC0L4g0L/QvtC00LDQstCw0L3QtSDigJ4lc+KAnCDRgdGK0LTRitGA0LbQsCDQtdGC0LjQutC10YLQsCDQv9GA0Lgg0YHQu9C40LLQsNC90LUg4oCeJXPigJwsINC60L7QudGC0L4g0LUgIgogItC40LfRhdCy0YrRgNC70LXQvSwg0LfQsNGC0L7QstCwINC40LfQv9C+0LvQt9Cy0LDQudGC0LUg0L7Qv9GG0LjRj9GC0LAg4oCeLS1lZGl04oCcLCDQsCDQvdC1IOKAni0tZ3JhZnTigJwuIgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo0NjcKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjQ2OAogIywgYy1mb3JtYXQKIG1zZ2lkICJ0aGUgb3JpZ2luYWwgY29tbWl0ICclcycgaGFzIGEgZ3BnIHNpZ25hdHVyZSIKIG1zZ3N0ciAi0L/RitGA0LLQvtC90LDRh9Cw0LvQvdC+0YLQviDQv9C+0LTQsNCy0LDQvdC1IOKAniVz4oCcINC1INGBINC/0L7QtNC/0LjRgSDQvdCwIEdQRyIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NDY4CisjOiBidWlsdGluL3JlcGxhY2UuYzo0NjkKIG1zZ2lkICJ0aGUgc2lnbmF0dXJlIHdpbGwgYmUgcmVtb3ZlZCBpbiB0aGUgcmVwbGFjZW1lbnQgY29tbWl0ISIKIG1zZ3N0ciAi0J/QvtC00L/QuNGB0YrRgiDRidC1INCx0YrQtNC1INC/0YDQtdC80LDRhdC90LDRgiDQsiDQt9Cw0LzQtdC90Y/RidC+0YLQviDQv9C+0LTQsNCy0LDQvdC1ISIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NDc4CisjOiBidWlsdGluL3JlcGxhY2UuYzo0NzkKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHdyaXRlIHJlcGxhY2VtZW50IGNvbW1pdCBmb3I6ICclcyciCiBtc2dzdHIgItC30LDQvNC10L3Rj9GJ0L7RgtC+INC/0L7QtNCw0LLQsNC90LUg0LfQsCDigJ4lc+KAnCDQvdC1INC80L7QttC1INC00LAg0LHRitC00LUg0LfQsNC/0LjRgdCw0L3QviIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NDg2CisjOiBidWlsdGluL3JlcGxhY2UuYzo0ODcKICMsIGMtZm9ybWF0CiBtc2dpZCAiZ3JhZnQgZm9yICclcycgdW5uZWNlc3NhcnkiCiBtc2dzdHIgItC/0YDQuNGB0LDQtNC60LDRgtCwINC30LAg4oCeJXPigJwg0LUg0LjQt9C70LjRiNC90LAiCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjQ5MAorIzogYnVpbHRpbi9yZXBsYWNlLmM6NDkxCiAjLCBjLWZvcm1hdAogbXNnaWQgIm5ldyBjb21taXQgaXMgdGhlIHNhbWUgYXMgdGhlIG9sZCBvbmU6ICclcyciCiBtc2dzdHIgItC90L7QstC+0YLQviDQuCDRgdGC0LDRgNC+0YLQviDQv9C+0LTQsNCy0LDQvdC1INGB0LAg0LXQtNC90L4g0Lgg0YHRitGJ0L46IOKAniVz4oCcIgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo1MjUKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjUyNgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiY291bGQgbm90IGNvbnZlcnQgdGhlIGZvbGxvd2luZyBncmFmdChzKTpcbiIKQEAgLTE5MTg2LDcxICsxOTI3NSw3MSBAQAogItGB0LvQtdC00L3QuNGC0LUg0L/RgNC40YHQsNC00LrQuCDQvdC1INC80L7Qs9Cw0YIg0LTQsCDRgdC1INC/0YDQtdC+0LHRgNCw0LfRg9Cy0LDRgjpcbiIKICIlcyIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NTQ2CisjOiBidWlsdGluL3JlcGxhY2UuYzo1NDcKIG1zZ2lkICJsaXN0IHJlcGxhY2UgcmVmcyIKIG1zZ3N0ciAi0LjQt9Cy0LXQttC00LDQvdC1INC90LAg0YHQv9C40YHRitC60LAg0YEg0YPQutCw0LfQsNGC0LXQu9C40YLQtSDQt9CwINC30LDQvNGP0L3QsCIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NTQ3CisjOiBidWlsdGluL3JlcGxhY2UuYzo1NDgKIG1zZ2lkICJkZWxldGUgcmVwbGFjZSByZWZzIgogbXNnc3RyICLQuNC30YLRgNC40LLQsNC90LUg0L3QsCDRg9C60LDQt9Cw0YLQtdC70LjRgtC1INC30LAg0LfQsNC80Y/QvdCwIgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo1NDgKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU0OQogbXNnaWQgImVkaXQgZXhpc3Rpbmcgb2JqZWN0IgogbXNnc3RyICLRgNC10LTQsNC60YLQuNGA0LDQvdC1INC90LAg0YHRitGJ0LXRgdGC0LLRg9Cy0LDRiSDQvtCx0LXQutGCIgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo1NDkKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU1MAogbXNnaWQgImNoYW5nZSBhIGNvbW1pdCdzIHBhcmVudHMiCiBtc2dzdHIgItGB0LzRj9C90LAg0L3QsCDRgNC+0LTQuNGC0LXQu9C40YLQtSDQvdCwINC/0L7QtNCw0LLQsNC90LUiCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU1MAorIzogYnVpbHRpbi9yZXBsYWNlLmM6NTUxCiBtc2dpZCAiY29udmVydCBleGlzdGluZyBncmFmdCBmaWxlIgogbXNnc3RyICLQv9GA0LXQvtCx0YDQsNC30YPQstCw0L3QtSDQvdCwINGE0LDQudC70LAg0LfQsCDQv9GA0LjRgdCw0LTQutC40YLQtSIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NTUxCisjOiBidWlsdGluL3JlcGxhY2UuYzo1NTIKIG1zZ2lkICJyZXBsYWNlIHRoZSByZWYgaWYgaXQgZXhpc3RzIgogbXNnc3RyICLQt9Cw0LzRj9C90LAg0L3QsCDRg9C60LDQt9Cw0YLQtdC70Y8sINCw0LrQviDRgdGK0YnQtdGB0YLQstGD0LLQsCIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NTUzCisjOiBidWlsdGluL3JlcGxhY2UuYzo1NTQKIG1zZ2lkICJkbyBub3QgcHJldHR5LXByaW50IGNvbnRlbnRzIGZvciAtLWVkaXQiCiBtc2dzdHIgItCx0LXQtyDRhNC+0YDQvNCw0YLQuNGA0LDQvdC+INC40LfQstC10LbQtNCw0L3QtSDQvdCwINGB0YrQtNGK0YDQttCw0L3QuNC10YLQviDigJQg0LfQsCDQvtC/0YbQuNGP0YLQsCDigJ4tLWVkaXTigJwiCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU1NAorIzogYnVpbHRpbi9yZXBsYWNlLmM6NTU1CiBtc2dpZCAidXNlIHRoaXMgZm9ybWF0IgogbXNnc3RyICLQuNC30L/QvtC70LfQstCw0L3QtSDQvdCwINGC0L7Qt9C4INCk0J7QoNCc0JDQoiIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NTY3CisjOiBidWlsdGluL3JlcGxhY2UuYzo1NjgKIG1zZ2lkICItLWZvcm1hdCBjYW5ub3QgYmUgdXNlZCB3aGVuIG5vdCBsaXN0aW5nIgogbXNnc3RyICLQvtC/0YbQuNGP0YLQsCDigJ4tLWZvcm1hdOKAnCDQuNC30LjRgdC60LLQsCDQuNC30LLQtdC20LTQsNC90LUg0L3QsCDRgdC/0LjRgdGK0LoiCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU3NQorIzogYnVpbHRpbi9yZXBsYWNlLmM6NTc2CiBtc2dpZCAiLWYgb25seSBtYWtlcyBzZW5zZSB3aGVuIHdyaXRpbmcgYSByZXBsYWNlbWVudCIKIG1zZ3N0ciAi0L7Qv9GG0LjRj9GC0LAg4oCeLWbigJwg0LjQt9C40YHQutCy0LAg0LfQsNC/0LDQt9Cy0LDQvdC10YLQviDQvdCwINC30LDQvNC10YHRgtC40YLQtdC7IgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo1NzkKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU4MAogbXNnaWQgIi0tcmF3IG9ubHkgbWFrZXMgc2Vuc2Ugd2l0aCAtLWVkaXQiCiBtc2dzdHIgItC+0L/RhtC40Y/RgtCwIOKAni0tcmF34oCcINC40LfQuNGB0LrQstCwIOKAni0tZWRpdOKAnCIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NTg1CisjOiBidWlsdGluL3JlcGxhY2UuYzo1ODYKIG1zZ2lkICItZCBuZWVkcyBhdCBsZWFzdCBvbmUgYXJndW1lbnQiCiBtc2dzdHIgItC+0L/RhtC40Y/RgtCwIOKAni1k4oCcINC40LfQuNGB0LrQstCwINC/0L7QvdC1INC10LTQuNC9INCw0YDQs9GD0LzQtdC90YIiCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU5MQorIzogYnVpbHRpbi9yZXBsYWNlLmM6NTkyCiBtc2dpZCAiYmFkIG51bWJlciBvZiBhcmd1bWVudHMiCiBtc2dzdHIgItC90LXQv9GA0LDQstC40LvQtdC9INCx0YDQvtC5INCw0YDQs9GD0LzQtdC90YLQuCIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NTk3CisjOiBidWlsdGluL3JlcGxhY2UuYzo1OTgKIG1zZ2lkICItZSBuZWVkcyBleGFjdGx5IG9uZSBhcmd1bWVudCIKIG1zZ3N0ciAi0L7Qv9GG0LjRj9GC0LAg4oCeLWXigJwg0LjQt9C40YHQutCy0LAg0L/QvtC90LUg0LXQtNC40L0g0LDRgNCz0YPQvNC10L3RgiIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NjAzCisjOiBidWlsdGluL3JlcGxhY2UuYzo2MDQKIG1zZ2lkICItZyBuZWVkcyBhdCBsZWFzdCBvbmUgYXJndW1lbnQiCiBtc2dzdHIgItC+0L/RhtC40Y/RgtCwIOKAni1n4oCcINC40LfQuNGB0LrQstCwINC/0L7QvdC1INC10LTQuNC9INCw0YDQs9GD0LzQtdC90YIiCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjYwOQorIzogYnVpbHRpbi9yZXBsYWNlLmM6NjEwCiBtc2dpZCAiLS1jb252ZXJ0LWdyYWZ0LWZpbGUgdGFrZXMgbm8gYXJndW1lbnQiCiBtc2dzdHIgItC+0L/RhtC40Y/RgtCwIOKAni0tY29udmVydC1ncmFmdC1maWxl4oCcINC90LUg0L/RgNC40LXQvNCwINCw0YDQs9GD0LzQtdC90YLQuCIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NjE1CisjOiBidWlsdGluL3JlcGxhY2UuYzo2MTYKIG1zZ2lkICJvbmx5IG9uZSBwYXR0ZXJuIGNhbiBiZSBnaXZlbiB3aXRoIC1sIgogbXNnc3RyICLQvtC/0YbQuNGP0YLQsCDigJ4tbOKAnCDQv9GA0LjQtdC80LAg0YLQvtGH0L3QviDQtdC00LjQvSDRiNCw0LHQu9C+0L0iCiAKQEAgLTE5MzE4LDEzICsxOTQwNywxOCBAQAogbXNnaWQgIkZhaWxlZCB0byBmaW5kIHRyZWUgb2YgJXMuIgogbXNnc3RyICLQlNGK0YDQstC+0YLQviwg0YHQvtGH0LXQvdC+INC+0YIg4oCeJXPigJwsINC90LUg0LzQvtC20LUg0LTQsCDQsdGK0LTQtSDQvtGC0LrRgNC40YLQvi4iCiAKKyM6IGJ1aWx0aW4vcmVzZXQuYzoxMTQKKyMsIGMtZm9ybWF0Cittc2dpZCAiSEVBRCBpcyBub3cgYXQgJXMiCittc2dzdHIgItCj0LrQsNC30LDRgtC10LvRj9GCIOKAnkhFQUTigJwg0YHQvtGH0Lgg0LrRitC8IOKAniVz4oCcIgorCiAjOiBidWlsdGluL3Jlc2V0LmM6MTkzCiAjLCBjLWZvcm1hdAogbXNnaWQgIkNhbm5vdCBkbyBhICVzIHJlc2V0IGluIHRoZSBtaWRkbGUgb2YgYSBtZXJnZS4iCiBtc2dzdHIgItCd0LUg0LzQvtC20LUg0LTQsCDRgdC1INC40LfQstGK0YDRiNC4ICVzINC30LDQvdGD0LvRj9Cy0LDQvdC1INC/0L4g0LLRgNC10LzQtSDQvdCwINGB0LvQuNCy0LDQvdC1LiIKIAotIzogYnVpbHRpbi9yZXNldC5jOjI5MyBidWlsdGluL3N0YXNoLmM6NTE0IGJ1aWx0aW4vc3Rhc2guYzo1ODkKLSM6IGJ1aWx0aW4vc3Rhc2guYzo2MTMKKyM6IGJ1aWx0aW4vcmVzZXQuYzoyOTMgYnVpbHRpbi9zdGFzaC5jOjUyMCBidWlsdGluL3N0YXNoLmM6NTk1CisjOiBidWlsdGluL3N0YXNoLmM6NjE5CiBtc2dpZCAiYmUgcXVpZXQsIG9ubHkgcmVwb3J0IGVycm9ycyIKIG1zZ3N0ciAi0L/Qvi3QvNCw0LvQutC+INC/0L7QtNGA0L7QsdC90L7RgdGC0LgsINC00LAg0YHQtSDQuNC30LLQtdC20LTQsNGCINGB0LDQvNC+INCz0YDQtdGI0LrQuNGC0LUiCiAKQEAgLTE5NDEwLDI0ICsxOTUwNCwxOSBAQAogbXNnaWQgIkNvdWxkIG5vdCB3cml0ZSBuZXcgaW5kZXggZmlsZS4iCiBtc2dzdHIgItCd0L7QstC40Y/RgiDQuNC90LTQtdC60YEg0L3QtSDQvNC+0LbQtSDQtNCwINCx0YrQtNC1INC30LDQv9C40YHQsNC9LiIKIAotIzogYnVpbHRpbi9yZXYtbGlzdC5jOjQxMgorIzogYnVpbHRpbi9yZXYtbGlzdC5jOjQxMQogbXNnaWQgImNhbm5vdCBjb21iaW5lIC0tZXhjbHVkZS1wcm9taXNvci1vYmplY3RzIGFuZCAtLW1pc3NpbmciCiBtc2dzdHIgItC+0L/RhtC40LjRgtC1IOKAni0tZXhjbHVkZS1wcm9taXNvci1vYmplY3Rz4oCcINC4IOKAni0tbWlzc2luZ+KAnCDQuCDRgdCwINC90LXRgdGK0LLQvNC10YHRgtC40LzQuCIKIAotIzogYnVpbHRpbi9yZXYtbGlzdC5jOjQ3MworIzogYnVpbHRpbi9yZXYtbGlzdC5jOjQ3MgogbXNnaWQgIm9iamVjdCBmaWx0ZXJpbmcgcmVxdWlyZXMgLS1vYmplY3RzIgogbXNnc3RyICLRhNC40LvRgtGA0LjRgNCw0L3QtdGC0L4g0L3QsCDQvtCx0LXQutGC0Lgg0LjQt9C40YHQutCy0LAg0L7Qv9GG0LjRj9GC0LAg4oCeLS1vYmplY3Rz4oCcIgogCi0jOiBidWlsdGluL3Jldi1saXN0LmM6NDc2Ci0jLCBjLWZvcm1hdAotbXNnaWQgImludmFsaWQgc3BhcnNlIHZhbHVlICclcyciCi1tc2dzdHIgItC90LXQv9GA0LDQstC40LvQvdCwINGH0LDRgdGC0LjRh9C90LAg0YHRgtC+0LnQvdC+0YHRgjogJXMiCi0KLSM6IGJ1aWx0aW4vcmV2LWxpc3QuYzo1MjcKKyM6IGJ1aWx0aW4vcmV2LWxpc3QuYzo1MjIKIG1zZ2lkICJyZXYtbGlzdCBkb2VzIG5vdCBzdXBwb3J0IGRpc3BsYXkgb2Ygbm90ZXMiCiBtc2dzdHIgItC60L7QvNCw0L3QtNCw0YLQsCDigJ5yZXYtbGlzdOKAnCDQvdC1INC/0L7QtNC00YrRgNC20LAg0LjQt9Cy0LXQttC00LDQvdC10YLQviDQvdCwINCx0LXQu9C10LbQutC4IgogCi0jOiBidWlsdGluL3Jldi1saXN0LmM6NTMwCisjOiBidWlsdGluL3Jldi1saXN0LmM6NTI1CiBtc2dpZCAiY2Fubm90IGNvbWJpbmUgLS11c2UtYml0bWFwLWluZGV4IHdpdGggb2JqZWN0IGZpbHRlcmluZyIKIG1zZ3N0ciAi0L7Qv9GG0LjRj9GC0LAg4oCeLS11c2UtYml0bWFwLWluZGV44oCcINC1INC90LXRgdGK0LLQvNC10YHRgtC40LzQsCDRgSDRhNC40LvRgtGA0LjRgNCw0L3QtSDQvdCwINC+0LHQtdC60YLQuNGC0LUiCiAKQEAgLTE5OTgyLDEzNCArMjAwNzEsMTM0IEBACiBtc2dpZCAiY291bGQgbm90IHNhdmUgaW5kZXggdHJlZSIKIG1zZ3N0ciAi0LTRitGA0LLQvtGC0L4g0YHQvtGH0LXQvdC+INC+0YIg0LjQvdC00LXQutGB0LAg0L3QtSDQvNC+0LbQtSDQtNCwINCx0YrQtNC1INC30LDQv9Cw0LfQtdC90L4iCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzo0MzQKKyM6IGJ1aWx0aW4vc3Rhc2guYzo0MzYKIG1zZ2lkICJjb3VsZCBub3QgcmVzdG9yZSB1bnRyYWNrZWQgZmlsZXMgZnJvbSBzdGFzaCIKIG1zZ3N0ciAi0L3QtdGB0LvQtdC00LXQvdC4INGE0LDQudC70L7QstC1INC90LUg0LzQvtCz0LDRgiDQtNCwINGB0LUg0LLRitC30YHRgtCw0L3QvtCy0Y/RgiDQvtGCINGB0LrQsNGC0LDQvdC+0YLQviIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjQ0OAorIzogYnVpbHRpbi9zdGFzaC5jOjQ1MAogIywgYy1mb3JtYXQKIG1zZ2lkICJNZXJnaW5nICVzIHdpdGggJXMiCiBtc2dzdHIgItCh0LvQuNCy0LDQvdC1INC90LAg4oCeJXPigJwg0YEg4oCeJXPigJwiCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzo0NTggZ2l0LWxlZ2FjeS1zdGFzaC5zaDo2ODAKKyM6IGJ1aWx0aW4vc3Rhc2guYzo0NjAgZ2l0LWxlZ2FjeS1zdGFzaC5zaDo2ODAKIG1zZ2lkICJJbmRleCB3YXMgbm90IHVuc3Rhc2hlZC4iCiBtc2dzdHIgItCY0L3QtNC10LrRgdGK0YIg0L3QtSDQtSDQuNC30LLQsNC00LXQvSDQvtGCINGB0LrQsNGC0LDQvdC+0YLQvi4iCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzo1MTYgYnVpbHRpbi9zdGFzaC5jOjYxNQorIzogYnVpbHRpbi9zdGFzaC5jOjUyMiBidWlsdGluL3N0YXNoLmM6NjIxCiBtc2dpZCAiYXR0ZW1wdCB0byByZWNyZWF0ZSB0aGUgaW5kZXgiCiBtc2dzdHIgItC+0L/QuNGCINC30LAg0L/QvtCy0YLQvtGA0L3QviDRgdGK0LfQtNCw0LLQsNC90LUg0L3QsCDQuNC90LTQtdC60YHQsCIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjU0OQorIzogYnVpbHRpbi9zdGFzaC5jOjU1NQogIywgYy1mb3JtYXQKIG1zZ2lkICJEcm9wcGVkICVzICglcykiCiBtc2dzdHIgItCY0LfRgtGA0LjRgtC+OiDigJ4lc+KAnCAoJXMpIgogCi0jOiBidWlsdGluL3N0YXNoLmM6NTUyCisjOiBidWlsdGluL3N0YXNoLmM6NTU4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiBDb3VsZCBub3QgZHJvcCBzdGFzaCBlbnRyeSIKIG1zZ3N0ciAi0KHQutCw0YLQsNC90L7RgtC+IOKAniVz4oCcINC90LUg0LzQvtC20LUg0LTQsCDQsdGK0LTQtSDQuNC30YLRgNC40YLQviIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjU3NworIzogYnVpbHRpbi9zdGFzaC5jOjU4MwogIywgYy1mb3JtYXQKIG1zZ2lkICInJXMnIGlzIG5vdCBhIHN0YXNoIHJlZmVyZW5jZSIKIG1zZ3N0ciAi4oCeJXPigJwg0L3QtSDQtSDRg9C60LDQt9Cw0YLQtdC7INC60YrQvCDQvdC10YnQviDRgdC60LDRgtCw0L3QviIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjYyNyBnaXQtbGVnYWN5LXN0YXNoLnNoOjY5NAorIzogYnVpbHRpbi9zdGFzaC5jOjYzMyBnaXQtbGVnYWN5LXN0YXNoLnNoOjY5NAogbXNnaWQgIlRoZSBzdGFzaCBlbnRyeSBpcyBrZXB0IGluIGNhc2UgeW91IG5lZWQgaXQgYWdhaW4uIgogbXNnc3RyICLQodC60LDRgtCw0L3QvtGC0L4g0LUg0LfQsNC/0LDQt9C10L3QviDQsiDRgdC70YPRh9Cw0LksINGH0LUg0LLQuCDQv9C+0YLRgNGP0LHQstCwINC+0YLQvdC+0LLQvi4iCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzo2NTAgZ2l0LWxlZ2FjeS1zdGFzaC5zaDo3MTIKKyM6IGJ1aWx0aW4vc3Rhc2guYzo2NTYgZ2l0LWxlZ2FjeS1zdGFzaC5zaDo3MTIKIG1zZ2lkICJObyBicmFuY2ggbmFtZSBzcGVjaWZpZWQiCiBtc2dzdHIgItCd0LUg0LUg0YPQutCw0LfQsNC90L4g0LjQvNC1INC90LAg0LrQu9C+0L0iCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzo3OTAgYnVpbHRpbi9zdGFzaC5jOjgyNworIzogYnVpbHRpbi9zdGFzaC5jOjc5NiBidWlsdGluL3N0YXNoLmM6ODMzCiAjLCBjLWZvcm1hdAogbXNnaWQgIkNhbm5vdCB1cGRhdGUgJXMgd2l0aCAlcyIKIG1zZ3N0ciAi0KPQutCw0LfQsNGC0LXQu9GP0YIg4oCeJXPigJwg0L3QtSDQvNC+0LbQtSDQtNCwINCx0YrQtNC1INC+0LHQvdC+0LLQtdC9INC00LAg0YHQvtGH0Lgg0LrRitC8IOKAniVz4oCcIgogCi0jOiBidWlsdGluL3N0YXNoLmM6ODA4IGJ1aWx0aW4vc3Rhc2guYzoxNDYxIGJ1aWx0aW4vc3Rhc2guYzoxNDk3CisjOiBidWlsdGluL3N0YXNoLmM6ODE0IGJ1aWx0aW4vc3Rhc2guYzoxNDcwIGJ1aWx0aW4vc3Rhc2guYzoxNTA2CiBtc2dpZCAic3Rhc2ggbWVzc2FnZSIKIG1zZ3N0ciAi0YHRitC+0LHRidC10L3QuNC1INC/0YDQuCDRgdC60LDRgtCw0LLQsNC90LUiCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzo4MTgKKyM6IGJ1aWx0aW4vc3Rhc2guYzo4MjQKIG1zZ2lkICJcImdpdCBzdGFzaCBzdG9yZVwiIHJlcXVpcmVzIG9uZSA8Y29tbWl0PiBhcmd1bWVudCIKIG1zZ3N0ciAi0LrQvtC80LDQvdC00LDRgtCwIOKAnmdpdCBzdGFzaCBzdG9yZeKAnCDQuNC30LjRgdC60LLQsCDRgtC+0YfQvdC+INC10LTQuNC9INCw0YDQs9GD0LzQtdC90YIt0J/QntCU0JDQktCQ0J3QlSIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjEwNDAgZ2l0LWxlZ2FjeS1zdGFzaC5zaDoyMTcKKyM6IGJ1aWx0aW4vc3Rhc2guYzoxMDQ2IGdpdC1sZWdhY3ktc3Rhc2guc2g6MjE3CiBtc2dpZCAiTm8gY2hhbmdlcyBzZWxlY3RlZCIKIG1zZ3N0ciAi0J3QtSDRgdCwINC40LfQsdGA0LDQvdC4INC90LjQutCw0LrQstC4INC/0YDQvtC80LXQvdC4IgogCi0jOiBidWlsdGluL3N0YXNoLmM6MTEzNiBnaXQtbGVnYWN5LXN0YXNoLnNoOjE1MAorIzogYnVpbHRpbi9zdGFzaC5jOjExNDUgZ2l0LWxlZ2FjeS1zdGFzaC5zaDoxNTAKIG1zZ2lkICJZb3UgZG8gbm90IGhhdmUgdGhlIGluaXRpYWwgY29tbWl0IHlldCIKIG1zZ3N0ciAi0JLRgdC1INC+0YnQtSDQu9C40L/RgdCy0LAg0L/RitGA0LLQvtC90LDRh9Cw0LvQvdC+INC/0L7QtNCw0LLQsNC90LUiCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzoxMTYzIGdpdC1sZWdhY3ktc3Rhc2guc2g6MTY1CisjOiBidWlsdGluL3N0YXNoLmM6MTE3MiBnaXQtbGVnYWN5LXN0YXNoLnNoOjE2NQogbXNnaWQgIkNhbm5vdCBzYXZlIHRoZSBjdXJyZW50IGluZGV4IHN0YXRlIgogbXNnc3RyICLQodGK0YHRgtC+0Y/QvdC40LXRgtC+INC90LAg0YLQtdC60YPRidC40Y8g0LjQvdC00LXQutGBINC90LUg0LzQvtC20LUg0LTQsCDQsdGK0LTQtSDQt9Cw0L/QsNC30LXQvdC+IgogCi0jOiBidWlsdGluL3N0YXNoLmM6MTE3MiBnaXQtbGVnYWN5LXN0YXNoLnNoOjE4MAorIzogYnVpbHRpbi9zdGFzaC5jOjExODEgZ2l0LWxlZ2FjeS1zdGFzaC5zaDoxODAKIG1zZ2lkICJDYW5ub3Qgc2F2ZSB0aGUgdW50cmFja2VkIGZpbGVzIgogbXNnc3RyICLQndC10YHQu9C10LTQtdC90LjRgtC1INGE0LDQudC70L7QstC1INC90LUg0LzQvtCz0LDRgiDQtNCwINGB0LUg0LfQsNC/0LDQt9GP0YIiCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzoxMTgzIGJ1aWx0aW4vc3Rhc2guYzoxMTkyIGdpdC1sZWdhY3ktc3Rhc2guc2g6MjAwCisjOiBidWlsdGluL3N0YXNoLmM6MTE5MiBidWlsdGluL3N0YXNoLmM6MTIwMSBnaXQtbGVnYWN5LXN0YXNoLnNoOjIwMAogIzogZ2l0LWxlZ2FjeS1zdGFzaC5zaDoyMTMKIG1zZ2lkICJDYW5ub3Qgc2F2ZSB0aGUgY3VycmVudCB3b3JrdHJlZSBzdGF0ZSIKIG1zZ3N0ciAi0KHRitGB0YLQvtGP0L3QuNC10YLQviDQvdCwINGA0LDQsdC+0YLQvdC+0YLQviDQtNGK0YDQstC+INC90LUg0LzQvtC20LUg0LTQsCDQsdGK0LTQtSDQt9Cw0L/QsNC30LXQvdC+IgogCi0jOiBidWlsdGluL3N0YXNoLmM6MTIyMCBnaXQtbGVnYWN5LXN0YXNoLnNoOjIzMworIzogYnVpbHRpbi9zdGFzaC5jOjEyMjkgZ2l0LWxlZ2FjeS1zdGFzaC5zaDoyMzMKIG1zZ2lkICJDYW5ub3QgcmVjb3JkIHdvcmtpbmcgdHJlZSBzdGF0ZSIKIG1zZ3N0ciAi0KHRitGB0YLQvtGP0L3QuNC10YLQviDQvdCwINGA0LDQsdC+0YLQvdC+0YLQviDQtNGK0YDQstC+INC90LUg0LzQvtC20LUg0LTQsCDQsdGK0LTQtSDQt9Cw0L/QsNC30LXQvdC+IgogCi0jOiBidWlsdGluL3N0YXNoLmM6MTI2OSBnaXQtbGVnYWN5LXN0YXNoLnNoOjMzNworIzogYnVpbHRpbi9zdGFzaC5jOjEyNzggZ2l0LWxlZ2FjeS1zdGFzaC5zaDozMzcKIG1zZ2lkICJDYW4ndCB1c2UgLS1wYXRjaCBhbmQgLS1pbmNsdWRlLXVudHJhY2tlZCBvciAtLWFsbCBhdCB0aGUgc2FtZSB0aW1lIgogbXNnc3RyICLQntC/0YbQuNGP0YLQsCDigJ4tLXBhdGNo4oCcINC1INC90LXRgdGK0LLQvNC10YHRgtC40LzQsCDRgSDigJ4tLWluY2x1ZGUtdW50cmFja2Vk4oCcINC4IOKAni0tYWxs4oCcIgogCi0jOiBidWlsdGluL3N0YXNoLmM6MTI4NQorIzogYnVpbHRpbi9zdGFzaC5jOjEyOTQKIG1zZ2lkICJEaWQgeW91IGZvcmdldCB0byAnZ2l0IGFkZCc/IgogbXNnc3RyICLQn9GA0L7QsdCy0LDQudGC0LUg0LTQsCDQuNC30L/QvtC70LfQstCw0YLQtSDigJ5naXQgYWRk4oCcIgogCi0jOiBidWlsdGluL3N0YXNoLmM6MTMwMCBnaXQtbGVnYWN5LXN0YXNoLnNoOjM0NQorIzogYnVpbHRpbi9zdGFzaC5jOjEzMDkgZ2l0LWxlZ2FjeS1zdGFzaC5zaDozNDUKIG1zZ2lkICJObyBsb2NhbCBjaGFuZ2VzIHRvIHNhdmUiCiBtc2dzdHIgItCd0Y/QvNCwINC90LjQutCw0LrQstC4INC70L7QutCw0LvQvdC4INC/0YDQvtC80LXQvdC4INC30LAg0YHQutCw0YLQsNCy0LDQvdC1IgogCi0jOiBidWlsdGluL3N0YXNoLmM6MTMwNyBnaXQtbGVnYWN5LXN0YXNoLnNoOjM1MAorIzogYnVpbHRpbi9zdGFzaC5jOjEzMTYgZ2l0LWxlZ2FjeS1zdGFzaC5zaDozNTAKIG1zZ2lkICJDYW5ub3QgaW5pdGlhbGl6ZSBzdGFzaCIKIG1zZ3N0ciAi0KHQutCw0YLQsNCy0LDQvdC10YLQviDQvdC1INC80L7QttC1INC00LAg0YHRgtCw0YDRgtC40YDQsCIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjEzMjIgZ2l0LWxlZ2FjeS1zdGFzaC5zaDozNTQKKyM6IGJ1aWx0aW4vc3Rhc2guYzoxMzMxIGdpdC1sZWdhY3ktc3Rhc2guc2g6MzU0CiBtc2dpZCAiQ2Fubm90IHNhdmUgdGhlIGN1cnJlbnQgc3RhdHVzIgogbXNnc3RyICLQotC10LrRg9GJ0L7RgtC+INGB0YrRgdGC0L7Rj9C90LjQtSDQvdC1INC80L7QttC1INC00LAg0LHRitC00LUg0LfQsNC/0LDQt9C10L3QviIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjEzMjcKKyM6IGJ1aWx0aW4vc3Rhc2guYzoxMzM2CiAjLCBjLWZvcm1hdAogbXNnaWQgIlNhdmVkIHdvcmtpbmcgZGlyZWN0b3J5IGFuZCBpbmRleCBzdGF0ZSAlcyIKIG1zZ3N0ciAi0KHRitGB0YLQvtGP0L3QuNC10YLQviDQvdCwINGA0LDQsdC+0YLQvdCw0YLQsCDQtNC40YDQtdC60YLQvtGA0LjRjyDQuCDQuNC90LTQtdC60YHQsCBlINC30LDQv9Cw0LfQtdC90L46IOKAniVz4oCcIgogCi0jOiBidWlsdGluL3N0YXNoLmM6MTQxNyBnaXQtbGVnYWN5LXN0YXNoLnNoOjM4NAorIzogYnVpbHRpbi9zdGFzaC5jOjE0MjYgZ2l0LWxlZ2FjeS1zdGFzaC5zaDozODQKIG1zZ2lkICJDYW5ub3QgcmVtb3ZlIHdvcmt0cmVlIGNoYW5nZXMiCiBtc2dzdHIgItCf0YDQvtC80LXQvdC40YLQtSDQsiDRgNCw0LHQvtGC0L3QvtGC0L4g0LTRitGA0LLQviDQvdC1INC80L7Qs9Cw0YIg0LTQsCDQsdGK0LTQsNGCINC30LDQvdGD0LvQtdC90LgiCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzoxNDUyIGJ1aWx0aW4vc3Rhc2guYzoxNDg4CisjOiBidWlsdGluL3N0YXNoLmM6MTQ2MSBidWlsdGluL3N0YXNoLmM6MTQ5NwogbXNnaWQgImtlZXAgaW5kZXgiCiBtc2dzdHIgItC30LDQv9Cw0LfQstCw0L3QtSDQvdCwINC40L3QtNC10LrRgdCwIgogCi0jOiBidWlsdGluL3N0YXNoLmM6MTQ1NCBidWlsdGluL3N0YXNoLmM6MTQ5MAorIzogYnVpbHRpbi9zdGFzaC5jOjE0NjMgYnVpbHRpbi9zdGFzaC5jOjE0OTkKIG1zZ2lkICJzdGFzaCBpbiBwYXRjaCBtb2RlIgogbXNnc3RyICLRgdC60LDRgtCw0LLQsNC90LUg0LIg0YDQtdC20LjQvCDQt9CwINC60YDRitC/0LrQuCIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjE0NTUgYnVpbHRpbi9zdGFzaC5jOjE0OTEKKyM6IGJ1aWx0aW4vc3Rhc2guYzoxNDY0IGJ1aWx0aW4vc3Rhc2guYzoxNTAwCiBtc2dpZCAicXVpZXQgbW9kZSIKIG1zZ3N0ciAi0LHQtdC3INC40LfQstC10LbQtNCw0L3QtSDQvdCwINC40L3RhNC+0YDQvNCw0YbQuNGPIgogCi0jOiBidWlsdGluL3N0YXNoLmM6MTQ1NyBidWlsdGluL3N0YXNoLmM6MTQ5MworIzogYnVpbHRpbi9zdGFzaC5jOjE0NjYgYnVpbHRpbi9zdGFzaC5jOjE1MDIKIG1zZ2lkICJpbmNsdWRlIHVudHJhY2tlZCBmaWxlcyBpbiBzdGFzaCIKIG1zZ3N0ciAi0YHQutCw0YLQsNCy0LDQvdC1INC4INC90LAg0L3QtdGB0LvQtdC00LXQvdC40YLQtSDRhNCw0LnQu9C+0LLQtSIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjE0NTkgYnVpbHRpbi9zdGFzaC5jOjE0OTUKKyM6IGJ1aWx0aW4vc3Rhc2guYzoxNDY4IGJ1aWx0aW4vc3Rhc2guYzoxNTA0CiBtc2dpZCAiaW5jbHVkZSBpZ25vcmUgZmlsZXMiCiBtc2dzdHIgItGB0LrQsNGC0LDQstCw0L3QtSDQuCDQvdCwINC40LPQvdC+0YDQuNGA0LDQvdC40YLQtSDRhNCw0LnQu9C+0LLQtSIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjE1NTUKKyM6IGJ1aWx0aW4vc3Rhc2guYzoxNTY0CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBleGVjICVzIgogbXNnc3RyICLigJ4lc+KAnCDQvdC1INC80L7QttC1INC00LAg0YHQtSDQuNC30L/RitC70L3QuCIKQEAgLTIwNDg1LDggKzIwNTc0LDggQEAKIG1zZ3N0ciAi0LHQtdC3INC40LfQstC10LbQtNCw0L3QtSDQvdCwINC90LDQv9GA0LXQtNGK0LrQsCDQvdCwINC60LvQvtC90LjRgNCw0L3QtdGC0L4iCiAKICM6IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxODc3Ci1tc2dpZCAiZ2l0IHN1Ym1vZHVsZS0taGVscGVyIHVwZGF0ZV9jbG9uZSBbLS1wcmVmaXg9PHBhdGg+XSBbPHBhdGg+Li4uXSIKLW1zZ3N0ciAiZ2l0IHN1Ym1vZHVsZS0taGVscGVyIHVwZGF0ZV9jbG9uZSBbLS1wcmVmaXg90J/QqtCiXSBb0J/QqtCi4oCmXSIKK21zZ2lkICJnaXQgc3VibW9kdWxlLS1oZWxwZXIgdXBkYXRlLWNsb25lIFstLXByZWZpeD08cGF0aD5dIFs8cGF0aD4uLi5dIgorbXNnc3RyICJnaXQgc3VibW9kdWxlLS1oZWxwZXIgdXBkYXRlLWNsb25lIFstLXByZWZpeD3Qn9Cq0KJdIFvQn9Cq0KLigKZdIgogCiAjOiBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6MTg5MAogbXNnaWQgImJhZCB2YWx1ZSBmb3IgdXBkYXRlIHBhcmFtZXRlciIKQEAgLTIwNTM5LDcgKzIwNjI4LDcgQEAKIG1zZ2lkICJwbGVhc2UgbWFrZSBzdXJlIHRoYXQgdGhlIC5naXRtb2R1bGVzIGZpbGUgaXMgaW4gdGhlIHdvcmtpbmcgdHJlZSIKIG1zZ3N0ciAi0YTQsNC50LvRitGCIOKAni5naXRtb2R1bGVz4oCcINGC0YDRj9Cx0LLQsCDQtNCwINC1INCyINGA0LDQsdC+0YLQvdC+0YLQviDQtNGK0YDQstC+IgogCi0jOiBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6MjIzNSBnaXQuYzo0MzQgZ2l0LmM6Njg0CisjOiBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6MjIzNSBnaXQuYzo0MzMgZ2l0LmM6NjgzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIGRvZXNuJ3Qgc3VwcG9ydCAtLXN1cGVyLXByZWZpeCIKIG1zZ3N0ciAi4oCeJXPigJwg0L3QtSDQv9C+0LTQtNGK0YDQttCwINC+0L/RhtC40Y/RgtCwIOKAni0tc3VwZXItcHJlZml44oCcIgpAQCAtMjA4NzEsMTQ5ICsyMDk2MCwxNDkgQEAKIG1zZ2lkICJnaXQgdXBkYXRlLWluZGV4IFs8b3B0aW9ucz5dIFstLV0gWzxmaWxlPi4uLl0iCiBtc2dzdHIgImdpdCB1cGRhdGUtaW5kZXggW9Ce0J/QptCY0K/igKZdIFstLV0gW9Ck0JDQmdCb4oCmXSIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzo5NzEKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6OTcyCiBtc2dpZCAiY29udGludWUgcmVmcmVzaCBldmVuIHdoZW4gaW5kZXggbmVlZHMgdXBkYXRlIgogbXNnc3RyICIiCiAi0L/RgNC+0LTRitC70LbQsNCy0LDQvdC1INGBINC+0LHQvdC+0LLRj9Cy0LDQvdC10YLQviwg0LTQvtGA0Lgg0LrQvtCz0LDRgtC+INC40L3QtNC10LrRgdGK0YIg0YLRgNGP0LHQstCwINC00LAg0LHRitC00LUg0L7QsdC90L7QstC10L0iCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6OTc0CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjk3NQogbXNnaWQgInJlZnJlc2g6IGlnbm9yZSBzdWJtb2R1bGVzIgogbXNnc3RyICLQv9C+0LTQvNC+0LTRg9C70LjRgtC1INC00LAg0YHQtSDQuNCz0L3QvtGA0LjRgNCw0YIg0L/RgNC4INC+0LHQvdC+0LLRj9Cy0LDQvdC10YLQviIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzo5NzcKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6OTc4CiBtc2dpZCAiZG8gbm90IGlnbm9yZSBuZXcgZmlsZXMiCiBtc2dzdHIgItC90L7QstC40YLQtSDRhNCw0LnQu9C+0LLQtSDQtNCwINC90LUg0YHQtSDQuNCz0L3QvtGA0LjRgNCw0YIiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6OTc5CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjk4MAogbXNnaWQgImxldCBmaWxlcyByZXBsYWNlIGRpcmVjdG9yaWVzIGFuZCB2aWNlLXZlcnNhIgogbXNnc3RyICLRhNCw0LnQu9C+0LLQtSDQtNCwINC80L7Qs9Cw0YIg0LTQsCDQt9Cw0LzQtdC90Y/RgiDQtNC40YDQtdC60YLQvtGA0LjQuCDQuCDQvtCx0YDQsNGC0L3QviIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzo5ODEKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6OTgyCiBtc2dpZCAibm90aWNlIGZpbGVzIG1pc3NpbmcgZnJvbSB3b3JrdHJlZSIKIG1zZ3N0ciAi0L/RgNC10LTRg9C/0YDQtdC20LTQsNCy0LDQvdC1INC/0YDQuCDQu9C40L/RgdCy0LDRidC4INCyINGA0LDQsdC+0YLQvdC+0YLQviDQtNGK0YDQstC+INGE0LDQudC70L7QstC1IgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjk4MworIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzo5ODQKIG1zZ2lkICJyZWZyZXNoIGV2ZW4gaWYgaW5kZXggY29udGFpbnMgdW5tZXJnZWQgZW50cmllcyIKIG1zZ3N0ciAi0L7QsdC90L7QstGP0LLQsNC90LUg0LTQvtGA0Lgg0Lgg0LjQvdC00LXQutGB0YrRgiDQtNCwINGB0YrQtNGK0YDQttCwINC90LXRgdC70LXRgtC4INC+0LHQtdC60YLQuCIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzo5ODYKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6OTg3CiBtc2dpZCAicmVmcmVzaCBzdGF0IGluZm9ybWF0aW9uIgogbXNnc3RyICLQvtCx0L3QvtCy0Y/QstCw0L3QtSDQvdCwINC40L3RhNC+0YDQvNCw0YbQuNGP0YLQsCDQvtGCINGE0YPQvdC60YbQuNGP0YLQsCDigJ5zdGF04oCcIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjk5MAorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzo5OTEKIG1zZ2lkICJsaWtlIC0tcmVmcmVzaCwgYnV0IGlnbm9yZSBhc3N1bWUtdW5jaGFuZ2VkIHNldHRpbmciCiBtc2dzdHIgIiIKICLQutCw0YLQviDQvtC/0YbQuNGP0YLQsCDigJ4tLXJlZnJlc2jigJwsINC90L4g0LTQsCDRgdC1INC/0YDQvtCy0LXRgNGP0YIg0Lgg0L7QsdC10LrRgtC40YLQtSwg0LrQvtC40YLQviDRgdCwINCx0LjQu9C4INC/0YDQuNC10YLQuCAiCiAi0LfQsCDQvdC10L/RgNC+0LzQtdC90LXQvdC4IgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjk5NAorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzo5OTUKIG1zZ2lkICI8bW9kZT4sPG9iamVjdD4sPHBhdGg+IgogbXNnc3RyICLQoNCV0JbQmNCcLNCe0JHQldCa0KIs0J/QqtCiIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjk5NQorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzo5OTYKIG1zZ2lkICJhZGQgdGhlIHNwZWNpZmllZCBlbnRyeSB0byB0aGUgaW5kZXgiCiBtc2dzdHIgItC00L7QsdCw0LLRj9C90LUg0L3QsCDQuNC30LHRgNC+0LXQvdC40YLQtSDQvtCx0LXQutGC0Lgg0LrRitC8INC40L3QtNC10LrRgdCwIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMDUKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAwNgogbXNnaWQgIm1hcmsgZmlsZXMgYXMgXCJub3QgY2hhbmdpbmdcIiIKIG1zZ3N0ciAi0LfQsNC00LDQstCw0L3QtSDQvdCwINGE0LvQsNCzLCDRh9C1INGE0LDQudC70YrRgiDQvdC1INGB0LUg0L/RgNC+0LzQtdC90Y8iCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAwOAorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDA5CiBtc2dpZCAiY2xlYXIgYXNzdW1lZC11bmNoYW5nZWQgYml0IgogbXNnc3RyICLQuNC30YfQuNGB0YLQstCw0L3QtSDQvdCwINGE0LvQsNCz0LAsINGH0LUg0YTQsNC50LvRitGCINC90LUg0YHQtSDQv9GA0L7QvNC10L3RjyIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDExCisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMTIKIG1zZ2lkICJtYXJrIGZpbGVzIGFzIFwiaW5kZXgtb25seVwiIgogbXNnc3RyICLQt9Cw0LTQsNCy0LDQvdC1INC90LAg0YTQu9Cw0LMsINGH0LUg0YTQsNC50LvQvtCy0LXRgtC1INGB0LAg0YHQsNC80L4g0LfQsCDQuNC90LTQtdC60YHQsCIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDE0CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMTUKIG1zZ2lkICJjbGVhciBza2lwLXdvcmt0cmVlIGJpdCIKIG1zZ3N0ciAi0LjQt9GH0LjRgdGC0LLQsNC90LUg0L3QsCDRhNC70LDQs9CwLCAg0YfQtSDRhNCw0LnQu9C+0LLQtdGC0LUg0YHQsCDRgdCw0LzQviDQt9CwINC40L3QtNC10LrRgdCwIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMTcKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAxOAogbXNnaWQgImFkZCB0byBpbmRleCBvbmx5OyBkbyBub3QgYWRkIGNvbnRlbnQgdG8gb2JqZWN0IGRhdGFiYXNlIgogbXNnc3RyICLQtNC+0LHQsNCy0Y/QvdC1INGB0LDQvNC+INC60YrQvCDQuNC90LTQtdC60YHQsCDQsdC10Lcg0LTQvtCx0LDQstGP0L3QtSDQutGK0Lwg0LHQsNC30LDRgtCwINC+0YIg0LTQsNC90L3QuCDQt9CwINC+0LHQtdC60YLQuNGC0LUiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAxOQorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDIwCiBtc2dpZCAicmVtb3ZlIG5hbWVkIHBhdGhzIGV2ZW4gaWYgcHJlc2VudCBpbiB3b3JrdHJlZSIKIG1zZ3N0ciAi0LjQt9GC0YDQuNCy0LDQvdC1INC90LAg0YPQutCw0LfQsNC90LjRgtC1INC/0YrRgtC40YnQsCwg0LTQvtGA0Lgg0Lgg0LTQsCDRgdGK0YnQtdGB0YLQstGD0LLQsNGCINCyINGA0LDQsdC+0YLQvdC+0YLQviDQtNGK0YDQstC+IgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMjEKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAyMgogbXNnaWQgIndpdGggLS1zdGRpbjogaW5wdXQgbGluZXMgYXJlIHRlcm1pbmF0ZWQgYnkgbnVsbCBieXRlcyIKIG1zZ3N0ciAiIgogItC/0YDQuCDQutC+0LzQsdC40L3QuNGA0LDQvdC1INGBINC+0L/RhtC40Y/RgtCwIOKAni0tc3RkaW7igJwg4oCUINCy0YXQvtC00L3QuNGC0LUg0YDQtdC00L7QstC1INGB0LAg0YDQsNC30LTQtdC70LXQvdC4INGBINC90YPQu9C10LLQuNGPICIKICLQsdCw0LnRgiIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDIzCisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMjQKIG1zZ2lkICJyZWFkIGxpc3Qgb2YgcGF0aHMgdG8gYmUgdXBkYXRlZCBmcm9tIHN0YW5kYXJkIGlucHV0IgogbXNnc3RyICLQuNC30YfQuNGC0LDQvdC1INC90LAg0YHQv9C40YHRitC60LAg0YEg0L/RitGC0LjRidCwINC30LAg0L7QsdC90L7QstGP0LLQsNC90LUg0L7RgiDRgdGC0LDQvdC00LDRgNGC0L3QuNGPINCy0YXQvtC0IgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMjcKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAyOAogbXNnaWQgImFkZCBlbnRyaWVzIGZyb20gc3RhbmRhcmQgaW5wdXQgdG8gdGhlIGluZGV4IgogbXNnc3RyICLQtNC+0LHQsNCy0Y/QvdC1INC90LAg0LXQu9C10LzQtdC90YLQuNGC0LUg0L7RgiDRgdGC0LDQvdC00LDRgNGC0L3QuNGPINCy0YXQvtC0INC60YrQvCDQuNC90LTQtdC60YHQsCIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDMxCisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMzIKIG1zZ2lkICJyZXBvcHVsYXRlIHN0YWdlcyAjMiBhbmQgIzMgZm9yIHRoZSBsaXN0ZWQgcGF0aHMiCiBtc2dzdHIgIiIKICLQstGK0LfRgdGC0LDQvdC+0LLRj9Cy0LDQvdC1INC90LAg0YHRitGB0YLQvtGP0L3QuNC10YLQviDQv9GA0LXQtNC4INGB0LvQuNCy0LDQvdC1INC40LvQuCDQvdGD0LbQtNCwINC+0YIg0L7QsdC90L7QstGP0LLQsNC90LUg0LfQsCAiCiAi0LjQt9Cx0YDQvtC10L3QuNGC0LUg0L/RitGC0LjRidCwIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMzUKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAzNgogbXNnaWQgIm9ubHkgdXBkYXRlIGVudHJpZXMgdGhhdCBkaWZmZXIgZnJvbSBIRUFEIgogbXNnc3RyICLQtNC+0LHQsNCy0Y/QvdC1INGB0LDQvNC+INC90LAg0YHRitC00YrRgNC20LDQvdC40LXRgtC+LCDQutC+0LXRgtC+INGB0LUg0YDQsNC30LvQuNGH0LDQstCwINC+0YIg0YLQvtCy0LAg0LIg4oCeSEVBROKAnCIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDM5CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwNDAKIG1zZ2lkICJpZ25vcmUgZmlsZXMgbWlzc2luZyBmcm9tIHdvcmt0cmVlIgogbXNnc3RyICLQuNCz0L3QvtGA0LjRgNCw0L3QtSDQvdCwINGE0LDQudC70L7QstC10YLQtSwg0LrQvtC40YLQviDQu9C40L/RgdCy0LDRgiDQsiDRgNCw0LHQvtGC0L3QvtGC0L4g0LTRitGA0LLQviIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDQyCisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwNDMKIG1zZ2lkICJyZXBvcnQgYWN0aW9ucyB0byBzdGFuZGFyZCBvdXRwdXQiCiBtc2dzdHIgItC40LfQstC10LbQtNCw0L3QtSDQvdCwINC00LXQudGB0YLQstC40Y/RgtCwINC90LAg0YHRgtCw0L3QtNCw0YDRgtC90LjRjyDQuNC30YXQvtC0IgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwNDQKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTA0NQogbXNnaWQgIihmb3IgcG9yY2VsYWlucykgZm9yZ2V0IHNhdmVkIHVucmVzb2x2ZWQgY29uZmxpY3RzIgogbXNnc3RyICIiCiAi0LfQsNCx0YDQsNCy0Y/QvdC1INC90LAg0LfQsNC/0LjRgdCw0L3QsNGC0LAg0LjQvdGE0L7RgNC80LDRhtC40Y8g0LfQsCDQvdC10YDQsNC30YDQtdGI0LXQvdC4INC60L7QvdGE0LvQuNC60YLQuCDigJQg0LfQsCDQutC+0LzQsNC90LTQuNGC0LUgIgogItC+0YIg0L/QvtGC0YDQtdCx0LjRgtC10LvRgdC60L4g0L3QuNCy0L4iCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTA0OAorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDQ5CiBtc2dpZCAid3JpdGUgaW5kZXggaW4gdGhpcyBmb3JtYXQiCiBtc2dzdHIgItC30LDQv9C40YHQstCw0L3QtSDQvdCwINC40L3QtNC10LrRgdCwINCyINGC0L7Qt9C4INGE0L7RgNC80LDRgiIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDUwCisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwNTEKIG1zZ2lkICJlbmFibGUgb3IgZGlzYWJsZSBzcGxpdCBpbmRleCIKIG1zZ3N0ciAi0LLQutC70Y7Rh9Cy0LDQvdC1INC40LvQuCDQuNC30LrQu9GO0YfQstCw0L3QtSDQvdCwINGA0LDQt9C00LXQu9GP0L3QtdGC0L4g0L3QsCDQuNC90LTQtdC60YHQsCIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDUyCisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwNTMKIG1zZ2lkICJlbmFibGUvZGlzYWJsZSB1bnRyYWNrZWQgY2FjaGUiCiBtc2dzdHIgItCy0LrQu9GO0YfQstCw0L3QtS/QuNC30LrQu9GO0YfQstCw0L3QtSDQvdCwINC60LXRiNCwINC30LAg0L3QtdGB0LvQtdC00LXQvdC40YLQtSDRhNCw0LnQu9C+0LLQtSIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDU0CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwNTUKIG1zZ2lkICJ0ZXN0IGlmIHRoZSBmaWxlc3lzdGVtIHN1cHBvcnRzIHVudHJhY2tlZCBjYWNoZSIKIG1zZ3N0ciAi0L/RgNC+0LLQtdGA0LrQsCDQtNCw0LvQuCDRhNCw0LnQu9C+0LLQsNGC0LAg0YHQuNGB0YLQtdC80LAg0L/QvtC00LTRitGA0LbQsCDQutC10Ygg0LfQsCDQvdC10YHQu9C10LTQtdC90Lgg0YTQsNC50LvQvtCy0LUiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTA1NgorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDU3CiBtc2dpZCAiZW5hYmxlIHVudHJhY2tlZCBjYWNoZSB3aXRob3V0IHRlc3RpbmcgdGhlIGZpbGVzeXN0ZW0iCiBtc2dzdHIgIiIKICLQstC60LvRjtGH0LLQsNC90LUg0L3QsCDQutC10YjQsCDQt9CwINC90LXRgdC70LXQtNC10L3QuNGC0LUg0YTQsNC50LvQvtCy0LUg0LHQtdC3INC/0YDQvtCy0LXRgNC60LAg0L3QsCDRhNCw0LnQu9C+0LLQsNGC0LAg0YHQuNGB0YLQtdC80LAiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTA1OAorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDU5CiBtc2dpZCAid3JpdGUgb3V0IHRoZSBpbmRleCBldmVuIGlmIGlzIG5vdCBmbGFnZ2VkIGFzIGNoYW5nZWQiCiBtc2dzdHIgItC30LDQv9C40YEg0L3QsCDQuNC90LTQtdC60YHQsCwg0LTQvtGA0Lgg0LTQsCDQvdC1INC1INC+0YLQsdC10LvRj9C30LDQvSDQutCw0YLQviDQv9GA0L7QvNC10L3QtdC9IgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwNjAKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTA2MQogbXNnaWQgImVuYWJsZSBvciBkaXNhYmxlIGZpbGUgc3lzdGVtIG1vbml0b3IiCiBtc2dzdHIgItCy0LrQu9GO0YfQstCw0L3QtSDQuNC70Lgg0LjQt9C60LvRjtGH0LLQsNC90LUg0L3QsCDQvdCw0LHQu9GO0LTQtdC90LjQtdGC0L4g0L3QsCDRhNCw0LnQu9C+0LLQsNGC0LAg0YHQuNGB0YLQtdC80LAiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTA2MgorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDYzCiBtc2dpZCAibWFyayBmaWxlcyBhcyBmc21vbml0b3IgdmFsaWQiCiBtc2dzdHIgItC+0YLQsdC10LvRj9C30LLQsNC90LUg0L3QsCDRhNCw0LnQu9C+0LLQtdGC0LUsINGH0LUg0LzQvtCz0LDRgiDQtNCwINGB0LUg0YHQu9C10LTRj9GCINGH0YDQtdC3INGE0LDQudC70L7QstCw0YLQsCDRgdC40YHRgtC10LzQsCIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDY1CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwNjYKIG1zZ2lkICJjbGVhciBmc21vbml0b3IgdmFsaWQgYml0IgogbXNnc3RyICLQuNC30YfQuNGB0YLQstCw0L3QtSDQvdCwINGE0LvQsNCz0LAg0LfQsCDRgdC70LXQtNC10L3QtdGC0L4g0YfRgNC10Lcg0YTQsNC50LvQvtCy0LDRgtCwINGB0LjRgdGC0LXQvNCwIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjExNjgKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTE2OQogbXNnaWQgIiIKICJjb3JlLnNwbGl0SW5kZXggaXMgc2V0IHRvIGZhbHNlOyByZW1vdmUgb3IgY2hhbmdlIGl0LCBpZiB5b3UgcmVhbGx5IHdhbnQgdG8gIgogImVuYWJsZSBzcGxpdCBpbmRleCIKQEAgLTIxMDIxLDcgKzIxMTEwLDcgQEAKICLQndCw0YHRgtGA0L7QudC60LDRgtCwIOKAnmNvcmUuc3BsaXRJbmRleOKAnCDQtSDQt9Cw0LTQsNC00LXQvdCwINC90LAg4oCeZmFsc2XigJwgKNC70YrQttCwKS4gINCh0LzQtdC90LXRgtC1INGPINC40LvQuCDRjyAiCiAi0LjQt9GC0YDQuNC50YLQtSwg0LfQsCDQtNCwINCy0LrQu9GO0YfQuNGC0LUg0YDQsNC30LTQtdC70Y/QvdC10YLQviDQvdCwINC40L3QtNC10LrRgdCwIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjExNzcKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTE3OAogbXNnaWQgIiIKICJjb3JlLnNwbGl0SW5kZXggaXMgc2V0IHRvIHRydWU7IHJlbW92ZSBvciBjaGFuZ2UgaXQsIGlmIHlvdSByZWFsbHkgd2FudCB0byAiCiAiZGlzYWJsZSBzcGxpdCBpbmRleCIKQEAgLTIxMDI5LDcgKzIxMTE4LDcgQEAKICLQndCw0YHRgtGA0L7QudC60LDRgtCwIOKAnmNvcmUuc3BsaXRJbmRleOKAnCDQtSDQt9Cw0LTQsNC00LXQvdCwINC90LAg4oCedHJ1ZeKAnCAo0LjRgdGC0LjQvdCwKS4gINCh0LzQtdC90LXRgtC1INGPINC40LvQuCAiCiAi0Y8g0LjQt9GC0YDQuNC50YLQtSwg0LfQsCDQtNCwINC40LfQutC70Y7Rh9C40YLQtSDRgNCw0LfQtNC10LvRj9C90LXRgtC+INC90LAg0LjQvdC00LXQutGB0LAuIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjExODgKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTE5MAogbXNnaWQgIiIKICJjb3JlLnVudHJhY2tlZENhY2hlIGlzIHNldCB0byB0cnVlOyByZW1vdmUgb3IgY2hhbmdlIGl0LCBpZiB5b3UgcmVhbGx5IHdhbnQgIgogInRvIGRpc2FibGUgdGhlIHVudHJhY2tlZCBjYWNoZSIKQEAgLTIxMDM3LDExICsyMTEyNiwxMSBAQAogItCd0LDRgdGC0YDQvtC50LrQsNGC0LAg4oCeY29yZS51bnRyYWNrZWRDYWNoZeKAnCDQtSDQt9Cw0LTQsNC00LXQvdCwINC90LAg4oCedHJ1ZeKAnCAo0LjRgdGC0LjQvdCwKS4gINCh0LzQtdC90LXRgtC1INGPICIKICLQuNC70Lgg0Y8g0LjQt9GC0YDQuNC50YLQtSwg0LfQsCDQtNCwINC40LfQutC70Y7Rh9C40YLQtSDQutC10YjQsCDQt9CwINC90LXRgdC70LXQtNC10L3QuNGC0LUg0YTQsNC50LvQvtCy0LUiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTE5MgorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMTk0CiBtc2dpZCAiVW50cmFja2VkIGNhY2hlIGRpc2FibGVkIgogbXNnc3RyICLQmtC10YjRitGCINC30LAg0L3QtdGB0LvQtdC00LXQvdC40YLQtSDRhNCw0LnQu9C+0LLQtSDQtSDQuNC30LrQu9GO0YfQtdC9IgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEyMDAKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTIwMgogbXNnaWQgIiIKICJjb3JlLnVudHJhY2tlZENhY2hlIGlzIHNldCB0byBmYWxzZTsgcmVtb3ZlIG9yIGNoYW5nZSBpdCwgaWYgeW91IHJlYWxseSB3YW50ICIKICJ0byBlbmFibGUgdGhlIHVudHJhY2tlZCBjYWNoZSIKQEAgLTIxMDQ5LDI5ICsyMTEzOCwyOSBAQAogItCd0LDRgdGC0YDQvtC50LrQsNGC0LAg4oCeY29yZS51bnRyYWNrZWRDYWNoZeKAnCDQtSDQt9Cw0LTQsNC00LXQvdCwINC90LAg4oCeZmFsc2XigJwgKNC70YrQttCwKS4gINCh0LzQtdC90LXRgtC1INGPICIKICLQuNC70Lgg0Y8g0LjQt9GC0YDQuNC50YLQtSwg0LfQsCDQtNCwINCy0LrQu9GO0YfQuNGC0LUg0LrQtdGI0LAg0LfQsCDQvdC10YHQu9C10LTQtdC90LjRgtC1INGE0LDQudC70L7QstC1IgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEyMDQKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTIwNgogIywgYy1mb3JtYXQKIG1zZ2lkICJVbnRyYWNrZWQgY2FjaGUgZW5hYmxlZCBmb3IgJyVzJyIKIG1zZ3N0ciAi0JrQtdGI0YrRgiDQt9CwINC90LXRgdC70LXQtNC10L3QuNGC0LUg0YTQsNC50LvQvtCy0LUg0LUg0LLQutC70Y7Rh9C10L0g0LfQsCDigJ4lc+KAnCIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMjEyCisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEyMTQKIG1zZ2lkICJjb3JlLmZzbW9uaXRvciBpcyB1bnNldDsgc2V0IGl0IGlmIHlvdSByZWFsbHkgd2FudCB0byBlbmFibGUgZnNtb25pdG9yIgogbXNnc3RyICIiCiAi0J3QsNGB0YLRgNC+0LnQutCw0YLQsCDigJ5jb3JlLmZzbW9uaXRvcuKAnCDQvdC1INC1INC30LDQtNCw0LTQtdC90LAuICDQl9Cw0LTQsNC50YLQtSDRjywg0LfQsCDQtNCwINCy0LrQu9GO0YfQuNGC0LUgIgogItGB0LvQtdC00LXQvdC10YLQviDRh9GA0LXQtyDRhNCw0LnQu9C+0LLQsNGC0LAg0YHQuNGB0YLQtdC80LAuIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEyMTYKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTIxOAogbXNnaWQgImZzbW9uaXRvciBlbmFibGVkIgogbXNnc3RyICLRgdC70LXQtNC10L3QtdGC0L4g0YfRgNC10Lcg0YTQsNC50LvQvtCy0LDRgtCwINGB0LjRgdGC0LXQvNCwINC1INCy0LrQu9GO0YfQtdC90L4iCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTIxOQorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMjIxCiBtc2dpZCAiIgogImNvcmUuZnNtb25pdG9yIGlzIHNldDsgcmVtb3ZlIGl0IGlmIHlvdSByZWFsbHkgd2FudCB0byBkaXNhYmxlIGZzbW9uaXRvciIKIG1zZ3N0ciAiIgogItCd0LDRgdGC0YDQvtC50LrQsNGC0LAg4oCeY29yZS5mc21vbml0b3LigJwg0LUg0LfQsNC00LDQtNC10L3QsC4gINCY0LfRgtGA0LjQudGC0LUg0Y8sINC30LAg0LTQsCDQuNC30LrQu9GO0YfQuNGC0LUgIgogItGB0LvQtdC00LXQvdC10YLQviDRh9GA0LXQtyDRhNCw0LnQu9C+0LLQsNGC0LAg0YHQuNGB0YLQtdC80LAuIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEyMjMKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTIyNQogbXNnaWQgImZzbW9uaXRvciBkaXNhYmxlZCIKIG1zZ3N0ciAi0YHQu9C10LTQtdC90LXRgtC+INGH0YDQtdC3INGE0LDQudC70L7QstCw0YLQsCDRgdC40YHRgtC10LzQsCDQtSDQuNC30LrQu9GO0YfQtdC90L4iCiAKQEAgLTIxMTY2LDU2ICsyMTI1NSw1NiBAQAogbXNnaWQgInByaW50IHRhZyBjb250ZW50cyIKIG1zZ3N0ciAi0LjQt9Cy0LXQttC00LDQvdC1INC90LAg0YHRitC00YrRgNC20LDQvdC40LXRgtC+INC90LAg0JXQotCY0JrQldCi0LgiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzoxOAorIzogYnVpbHRpbi93b3JrdHJlZS5jOjE3CiBtc2dpZCAiZ2l0IHdvcmt0cmVlIGFkZCBbPG9wdGlvbnM+XSA8cGF0aD4gWzxjb21taXQtaXNoPl0iCiBtc2dzdHIgImdpdCB3b3JrdHJlZSBhZGQgW9Ce0J/QptCY0K/igKZdINCf0KrQoiBb0KPQmtCQ0JfQkNCi0JXQm1/QmtCq0Jxf0J/QntCU0JDQktCQ0J3QlV0iCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzoxOQorIzogYnVpbHRpbi93b3JrdHJlZS5jOjE4CiBtc2dpZCAiZ2l0IHdvcmt0cmVlIGxpc3QgWzxvcHRpb25zPl0iCiBtc2dzdHIgImdpdCB3b3JrdHJlZSBsaXN0IFvQntCf0KbQmNCv4oCmXSIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjIwCisjOiBidWlsdGluL3dvcmt0cmVlLmM6MTkKIG1zZ2lkICJnaXQgd29ya3RyZWUgbG9jayBbPG9wdGlvbnM+XSA8cGF0aD4iCiBtc2dzdHIgImdpdCB3b3JrdHJlZSBsb2NrIFvQntCf0KbQmNCv4oCmXSBb0J/QqtCiXSIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjIxCisjOiBidWlsdGluL3dvcmt0cmVlLmM6MjAKIG1zZ2lkICJnaXQgd29ya3RyZWUgbW92ZSA8d29ya3RyZWU+IDxuZXctcGF0aD4iCiBtc2dzdHIgImdpdCB3b3JrdHJlZSBtb3ZlIFvQlNCq0KDQktCeXSBb0J3QntCSX9Cf0KrQol0iCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzoyMgorIzogYnVpbHRpbi93b3JrdHJlZS5jOjIxCiBtc2dpZCAiZ2l0IHdvcmt0cmVlIHBydW5lIFs8b3B0aW9ucz5dIgogbXNnc3RyICJnaXQgd29ya3RyZWUgcHJ1bmUgW9Ce0J/QptCY0K/igKZdIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6MjMKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzoyMgogbXNnaWQgImdpdCB3b3JrdHJlZSByZW1vdmUgWzxvcHRpb25zPl0gPHdvcmt0cmVlPiIKIG1zZ3N0ciAiZ2l0IHdvcmt0cmVlIHJlbW92ZSBb0J7Qn9Cm0JjQr+KApl0gW9CU0KrQoNCS0J5dIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6MjQKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzoyMwogbXNnaWQgImdpdCB3b3JrdHJlZSB1bmxvY2sgPHBhdGg+IgogbXNnc3RyICJnaXQgd29ya3RyZWUgdW5sb2NrIFvQn9Cq0KJdIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NjEgYnVpbHRpbi93b3JrdHJlZS5jOjg5OQorIzogYnVpbHRpbi93b3JrdHJlZS5jOjYwIGJ1aWx0aW4vd29ya3RyZWUuYzo4OTgKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIGRlbGV0ZSAnJXMnIgogbXNnc3RyICLQvdC10YPRgdC/0LXRiNC90L4g0LjQt9GC0YDQuNCy0LDQvdC1INC90LAg4oCeJXPigJwiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4MAorIzogYnVpbHRpbi93b3JrdHJlZS5jOjc5CiAjLCBjLWZvcm1hdAogbXNnaWQgIlJlbW92aW5nIHdvcmt0cmVlcy8lczogbm90IGEgdmFsaWQgZGlyZWN0b3J5IgogbXNnc3RyICLQmNC30YLRgNC40LLQsNC90LUg0L3QsCDigJ53b3JrdHJlZXMvJXPigJw6INC90LUg0LUg0L/RgNCw0LLQuNC70L3QsCDQv9C+0LTQtNC40YDQtdC60YLQvtGA0LjRjyIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjg2CisjOiBidWlsdGluL3dvcmt0cmVlLmM6ODUKICMsIGMtZm9ybWF0CiBtc2dpZCAiUmVtb3Zpbmcgd29ya3RyZWVzLyVzOiBnaXRkaXIgZmlsZSBkb2VzIG5vdCBleGlzdCIKIG1zZ3N0ciAi0JjQt9GC0YDQuNCy0LDQvdC1INC90LAg4oCed29ya3RyZWVzLyVz4oCcOiDRhNCw0LnQu9GK0YIg4oCeZ2l0ZGly4oCcINC90LUg0YHRitGJ0LXRgdGC0LLRg9Cy0LAiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo5MSBidWlsdGluL3dvcmt0cmVlLmM6MTAwCisjOiBidWlsdGluL3dvcmt0cmVlLmM6OTAgYnVpbHRpbi93b3JrdHJlZS5jOjk5CiAjLCBjLWZvcm1hdAogbXNnaWQgIlJlbW92aW5nIHdvcmt0cmVlcy8lczogdW5hYmxlIHRvIHJlYWQgZ2l0ZGlyIGZpbGUgKCVzKSIKIG1zZ3N0ciAiIgogItCY0LfRgtGA0LjQstCw0L3QtSDQvdCwIOKAnndvcmt0cmVlcy8lc+KAnDog0YTQsNC50LvRitGCIOKAnmdpdGRpcuKAnCAoJXMpINC90LUg0LzQvtC20LUg0LTQsCDQsdGK0LTQtSDQv9GA0L7Rh9C10YLQtdC9IgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6MTEwCisjOiBidWlsdGluL3dvcmt0cmVlLmM6MTA5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJSZW1vdmluZyB3b3JrdHJlZXMvJXM6IHNob3J0IHJlYWQgKGV4cGVjdGVkICU8UFJJdU1BWD4gYnl0ZXMsIHJlYWQgIgpAQCAtMjEyMjQsMzcgKzIxMzEzLDM3IEBACiAi0JjQt9GC0YDQuNCy0LDQvdC1INC90LAg4oCed29ya3RyZWVzLyVz4oCcOiDQuNC30YfQuNGC0LDQvdC10YLQviDQstGK0YDQvdCwINC/0L4t0LzQsNC70LrQviDQsdCw0LnRgtC+0LLQtSDQvtGCINC+0YfQsNC60LLQsNC90L7RgtC+ICIKICIo0L7Rh9Cw0LrQstCw0L3QuDogJTxQUkl1TUFYPiDQsdCw0LnRgtCwLCDQv9C+0LvRg9GH0LXQvdC4OiAlPFBSSXVNQVg+KSIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjExOAorIzogYnVpbHRpbi93b3JrdHJlZS5jOjExNwogIywgYy1mb3JtYXQKIG1zZ2lkICJSZW1vdmluZyB3b3JrdHJlZXMvJXM6IGludmFsaWQgZ2l0ZGlyIGZpbGUiCiBtc2dzdHIgItCY0LfRgtGA0LjQstCw0L3QtSDQvdCwIOKAnndvcmt0cmVlcy8lc+KAnDog0L3QtdC/0YDQsNCy0LjQu9C10L0g0YTQsNC50Lsg4oCeZ2l0ZGly4oCcIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6MTI3CisjOiBidWlsdGluL3dvcmt0cmVlLmM6MTI2CiAjLCBjLWZvcm1hdAogbXNnaWQgIlJlbW92aW5nIHdvcmt0cmVlcy8lczogZ2l0ZGlyIGZpbGUgcG9pbnRzIHRvIG5vbi1leGlzdGVudCBsb2NhdGlvbiIKIG1zZ3N0ciAiIgogItCY0LfRgtGA0LjQstCw0L3QtSDQvdCwIOKAnndvcmt0cmVlcy8lc+KAnDog0YTQsNC50LvRitGCIOKAnmdpdGRpcuKAnCDRgdC+0YfQuCDQvdC10YHRitGJ0LXRgdGC0LLRg9Cy0LDRidC+ICIKICLQvNC10YHRgtC+0L/QvtC70L7QttC10L3QuNC1IgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6MTY2CisjOiBidWlsdGluL3dvcmt0cmVlLmM6MTY1CiBtc2dpZCAicmVwb3J0IHBydW5lZCB3b3JraW5nIHRyZWVzIgogbXNnc3RyICLQtNC+0LrQu9Cw0LTQstCw0L3QtSDQvdCwINC+0LrQsNGB0YLRgNC10L3QuNGC0LUg0YDQsNCx0L7RgtC90Lgg0LTRitGA0LLQtdGC0LAiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzoxNjgKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzoxNjcKIG1zZ2lkICJleHBpcmUgd29ya2luZyB0cmVlcyBvbGRlciB0aGFuIDx0aW1lPiIKIG1zZ3N0ciAi0L7QsdGP0LLRj9Cy0LDQvdC1INC90LAg0YDQsNCx0L7RgtC90LjRgtC1INC60L7Qv9C40Y8g0L/Qvi3RgdGC0LDRgNC4INC+0YIg0YLQvtCy0LAg0JLQoNCV0JzQlSDQt9CwINC+0YHRgtCw0YDQtdC70LgiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzoyMzUKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzoyMzQKICMsIGMtZm9ybWF0CiBtc2dpZCAiJyVzJyBhbHJlYWR5IGV4aXN0cyIKIG1zZ3N0ciAi4oCeJXPigJwg0LLQtdGH0LUg0YHRitGJ0LXRgdGC0LLRg9Cy0LAiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzoyNTIKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzoyNTEKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHJlLWFkZCB3b3JrdHJlZSAnJXMnIgogbXNnc3RyICLQtNGK0YDQstC+0YLQviDigJ4lc+KAnCDQvdC1INC80L7QttC1INC00LAg0LHRitC00LUg0LTQvtCx0LDQstC10L3QviDQvdCw0L3QvtCy0L4iCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzoyNTcKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzoyNTYKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIiclcycgaXMgYSBtaXNzaW5nIGJ1dCBsb2NrZWQgd29ya3RyZWU7XG4iCkBAIC0yMTI2NCw3ICsyMTM1Myw3IEBACiAi0JfQsCDQuNC30YDQuNGH0L3QviDQt9Cw0LTQsNCy0LDQvdC1INC/0L7Qu9C30LLQsNC50YLQtSDigJ5hZGQgLWbigJwsINCwINC30LAg0LjQt9GH0LjRgdGC0LLQsNC90LUg4oCUIOKAnnBydW5l4oCcINC40LvQuCAiCiAi4oCecmVtb3Zl4oCcIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6MjU5CisjOiBidWlsdGluL3dvcmt0cmVlLmM6MjU4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICInJXMnIGlzIGEgbWlzc2luZyBidXQgYWxyZWFkeSByZWdpc3RlcmVkIHdvcmt0cmVlO1xuIgpAQCAtMjEyNzQsMTI1ICsyMTM2MywxMjUgQEAKICLQl9CwINC40LfRgNC40YfQvdC+INC30LDQtNCw0LLQsNC90LUg0L/QvtC70LfQstCw0LnRgtC1IOKAnmFkZCAtZuKAnCwg0LAg0LfQsCDQuNC30YfQuNGB0YLQstCw0L3QtSDigJQg4oCecHJ1bmXigJwg0LjQu9C4ICIKICLigJ5yZW1vdmXigJwiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzozMDkKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzozMDgKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGNyZWF0ZSBkaXJlY3Rvcnkgb2YgJyVzJyIKIG1zZ3N0ciAi0LTQuNGA0LXQutGC0L7RgNC40Y/RgtCwIOKAniVz4oCcINC90LUg0LzQvtC20LUg0LTQsCDQsdGK0LTQtSDRgdGK0LfQtNCw0LTQtdC90LAiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo0NDAgYnVpbHRpbi93b3JrdHJlZS5jOjQ0NgorIzogYnVpbHRpbi93b3JrdHJlZS5jOjQzOSBidWlsdGluL3dvcmt0cmVlLmM6NDQ1CiAjLCBjLWZvcm1hdAogbXNnaWQgIlByZXBhcmluZyB3b3JrdHJlZSAobmV3IGJyYW5jaCAnJXMnKSIKIG1zZ3N0ciAi0J/RgNC40LPQvtGC0LLRj9C90LUg0L3QsCDRgNCw0LHQvtGC0L3QvtGC0L4g0LTRitGA0LLQviAo0L3QvtCyINC60LvQvtC9IOKAniVz4oCcKSIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjQ0MgorIzogYnVpbHRpbi93b3JrdHJlZS5jOjQ0MQogIywgYy1mb3JtYXQKIG1zZ2lkICJQcmVwYXJpbmcgd29ya3RyZWUgKHJlc2V0dGluZyBicmFuY2ggJyVzJzsgd2FzIGF0ICVzKSIKIG1zZ3N0ciAiIgogItCf0YDQuNCz0L7RgtCy0Y/QvdC1INC90LAg0YDQsNCx0L7RgtC90L7RgtC+INC00YrRgNCy0L4gKNC30LDQvdGD0LvRj9Cy0LDQvdC1INC90LAg0LrQu9C+0L3QsCDigJ4lc+KAnCwg0LrQvtC50YLQviDRgdC+0YfQtdGI0LUg0LrRitC8ICIKICLigJ4lc+KAnCkiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo0NTEKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo0NTAKICMsIGMtZm9ybWF0CiBtc2dpZCAiUHJlcGFyaW5nIHdvcmt0cmVlIChjaGVja2luZyBvdXQgJyVzJykiCiBtc2dzdHIgItCf0YDQuNCz0L7RgtCy0Y/QvdC1INC90LAg0YDQsNCx0L7RgtC90L7RgtC+INC00YrRgNCy0L4gKNC40LfRgtC10LPQu9GP0L3QtSDQvdCwIOKAniVz4oCcKSIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjQ1NworIzogYnVpbHRpbi93b3JrdHJlZS5jOjQ1NgogIywgYy1mb3JtYXQKIG1zZ2lkICJQcmVwYXJpbmcgd29ya3RyZWUgKGRldGFjaGVkIEhFQUQgJXMpIgogbXNnc3RyICLQn9C+0LTQs9C+0YLQstGP0L3QtSDQvdCwINGA0LDQsdC+0YLQvdC+INC00YrRgNCy0L4gKNGD0LrQsNC30LDRgtC10LvRj9GCIOKAnkhFQUTigJwg0L3QtSDRgdCy0YrRgNC30LDQvTogJXMpIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NDk4CisjOiBidWlsdGluL3dvcmt0cmVlLmM6NDk3CiBtc2dpZCAiY2hlY2tvdXQgPGJyYW5jaD4gZXZlbiBpZiBhbHJlYWR5IGNoZWNrZWQgb3V0IGluIG90aGVyIHdvcmt0cmVlIgogbXNnc3RyICLQmNC30YLQtdCz0LvRj9C90LUg0JrQm9Ce0J3QsCwg0LTQvtGA0Lgg0Lgg0LTQsCDQtSDQuNC30YLQtdCz0LvQtdC9INCyINC00YDRg9Cz0L4g0YDQsNCx0L7RgtC90L4g0LTRitGA0LLQviIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjUwMQorIzogYnVpbHRpbi93b3JrdHJlZS5jOjUwMAogbXNnaWQgImNyZWF0ZSBhIG5ldyBicmFuY2giCiBtc2dzdHIgItGB0YrQt9C00LDQstCw0L3QtSDQvdCwINC90L7QsiDQutC70L7QvSIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjUwMworIzogYnVpbHRpbi93b3JrdHJlZS5jOjUwMgogbXNnaWQgImNyZWF0ZSBvciByZXNldCBhIGJyYW5jaCIKIG1zZ3N0ciAi0YHRitC30LTQsNCy0LDQvdC1INC40LvQuCDQt9Cw0L3Rg9C70Y/QstCw0L3QtSDQvdCwINC60LvQvtC90LgiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo1MDUKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo1MDQKIG1zZ2lkICJwb3B1bGF0ZSB0aGUgbmV3IHdvcmtpbmcgdHJlZSIKIG1zZ3N0ciAi0L/QvtC00LPQvtGC0LLRj9C90LUg0L3QsCDQvdC+0LLQvtGC0L4g0YDQsNCx0L7RgtC90L4g0LTRitGA0LLQviIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjUwNgorIzogYnVpbHRpbi93b3JrdHJlZS5jOjUwNQogbXNnaWQgImtlZXAgdGhlIG5ldyB3b3JraW5nIHRyZWUgbG9ja2VkIgogbXNnc3RyICLQvdC+0LLQvtGC0L4g0YDQsNCx0L7RgtC90L4g0LTRitGA0LLQviDQtNCwINC+0YHRgtCw0L3QtSDQt9Cw0LrQu9GO0YfQtdC90L4iCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo1MDkKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo1MDgKIG1zZ2lkICJzZXQgdXAgdHJhY2tpbmcgbW9kZSAoc2VlIGdpdC1icmFuY2goMSkpIgogbXNnc3RyICLQt9Cw0LTQsNCy0LDQvdC1INC90LAg0YDQtdC20LjQvNCwINC90LAg0YHQu9C10LTQtdC90LUgKNCy0LjQtiBnaXQtYnJhbmNoKDEpKSIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjUxMgorIzogYnVpbHRpbi93b3JrdHJlZS5jOjUxMQogbXNnaWQgInRyeSB0byBtYXRjaCB0aGUgbmV3IGJyYW5jaCBuYW1lIHdpdGggYSByZW1vdGUtdHJhY2tpbmcgYnJhbmNoIgogbXNnc3RyICLQvtC/0LjRgiDQt9CwINC90LDQv9Cw0YHQstCw0L3QtSDQvdCwINC40LzQtdGC0L4g0L3QsCDQvdC+0LLQuNGPINC60LvQvtC9INGBINGC0L7QstCwINC90LAg0YHQu9C10LTRj9GJINC60LvQvtC9IgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NTIwCisjOiBidWlsdGluL3dvcmt0cmVlLmM6NTE5CiBtc2dpZCAiLWIsIC1CLCBhbmQgLS1kZXRhY2ggYXJlIG11dHVhbGx5IGV4Y2x1c2l2ZSIKIG1zZ3N0ciAi0J7Qv9GG0LjQuNGC0LUg4oCeLWLigJwsIOKAni1C4oCcINC4IOKAni0tZGV0YWNo4oCcINGB0LAg0L3QtdGB0YrQstC80LXRgdGC0LjQvNC4INC10LTQvdCwINGBINC00YDRg9Cz0LAiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo1ODEKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo1ODAKIG1zZ2lkICItLVtuby1ddHJhY2sgY2FuIG9ubHkgYmUgdXNlZCBpZiBhIG5ldyBicmFuY2ggaXMgY3JlYXRlZCIKIG1zZ3N0ciAi4oCeLS1bbm8tXXRyYWNr4oCcINC80L7QttC1INC00LAg0YHQtSDQuNC30L/QvtC70LfQstCwINGB0LDQvNC+INC/0YDQuCDRgdGK0LfQtNCw0LLQsNC90LXRgtC+INC90LAg0L3QvtCyINC60LvQvtC9IgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NjgxCisjOiBidWlsdGluL3dvcmt0cmVlLmM6NjgwCiBtc2dpZCAicmVhc29uIGZvciBsb2NraW5nIgogbXNnc3RyICLQv9GA0LjRh9C40L3QsCDQt9CwINC30LDQutC70Y7Rh9Cy0LDQvdC1IgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NjkzIGJ1aWx0aW4vd29ya3RyZWUuYzo3MjYgYnVpbHRpbi93b3JrdHJlZS5jOjgwMAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjkyNworIzogYnVpbHRpbi93b3JrdHJlZS5jOjY5MiBidWlsdGluL3dvcmt0cmVlLmM6NzI1IGJ1aWx0aW4vd29ya3RyZWUuYzo3OTkKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo5MjYKICMsIGMtZm9ybWF0CiBtc2dpZCAiJyVzJyBpcyBub3QgYSB3b3JraW5nIHRyZWUiCiBtc2dzdHIgIuKAniVz4oCcINC90LUg0LUg0YDQsNCx0L7RgtC90L4g0LTRitGA0LLQviIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjY5NSBidWlsdGluL3dvcmt0cmVlLmM6NzI4CisjOiBidWlsdGluL3dvcmt0cmVlLmM6Njk0IGJ1aWx0aW4vd29ya3RyZWUuYzo3MjcKIG1zZ2lkICJUaGUgbWFpbiB3b3JraW5nIHRyZWUgY2Fubm90IGJlIGxvY2tlZCBvciB1bmxvY2tlZCIKIG1zZ3N0ciAi0J7RgdC90L7QstC90L7RgtC+INC00YrRgNCy0L4g0L3QtSDQvNC+0LbQtSDQtNCwINGB0LUg0L7RgtC60LvRjtGH0Lgg0LjQu9C4INC30LDQutC70Y7Rh9C4IgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NzAwCisjOiBidWlsdGluL3dvcmt0cmVlLmM6Njk5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiclcycgaXMgYWxyZWFkeSBsb2NrZWQsIHJlYXNvbjogJXMiCiBtc2dzdHIgIuKAniVz4oCcINCy0LXRh9C1INC1INC30LDQutC70Y7Rh9C10L3Qviwg0LfQsNGJ0L7RgtC+IOKAniVz4oCcIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NzAyCisjOiBidWlsdGluL3dvcmt0cmVlLmM6NzAxCiAjLCBjLWZvcm1hdAogbXNnaWQgIiclcycgaXMgYWxyZWFkeSBsb2NrZWQiCiBtc2dzdHIgIuKAniVz4oCcINCy0LXRh9C1INC1INC30LDQutC70Y7Rh9C10L3QviIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjczMAorIzogYnVpbHRpbi93b3JrdHJlZS5jOjcyOQogIywgYy1mb3JtYXQKIG1zZ2lkICInJXMnIGlzIG5vdCBsb2NrZWQiCiBtc2dzdHIgIuKAniVz4oCcINC90LUg0LUg0LfQsNC60LvRjtGH0LXQvdC+IgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NzcxCisjOiBidWlsdGluL3dvcmt0cmVlLmM6NzcwCiBtc2dpZCAid29ya2luZyB0cmVlcyBjb250YWluaW5nIHN1Ym1vZHVsZXMgY2Fubm90IGJlIG1vdmVkIG9yIHJlbW92ZWQiCiBtc2dzdHIgIiIKICLQvdC1INC80L7QttC1INC00LAg0LzQtdGB0YLQuNGC0LUg0LjQu9C4INC40LfRgtGA0LjQstCw0YLQtSDRgNCw0LHQvtGC0L3QuCDQtNGK0YDQstC10YLQsCwg0LIg0LrQvtC40YLQviDQuNC80LAg0L/QvtC00LzQvtC00YPQu9C4IgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6Nzc5CisjOiBidWlsdGluL3dvcmt0cmVlLmM6Nzc4CiBtc2dpZCAiZm9yY2UgbW92ZSBldmVuIGlmIHdvcmt0cmVlIGlzIGRpcnR5IG9yIGxvY2tlZCIKIG1zZ3N0ciAiIgogItC/0YDQuNC90YPQtNC40YLQtdC70L3QviDQv9GA0LXQvNC10YHRgtCy0LDQvdC1LCDQtNC+0YDQuCDRgNCw0LHQvtGC0L3QvtGC0L4g0LTRitGA0LLQviDQtNCwINC90LUg0LUg0YfQuNGB0YLQviDQuNC70Lgg0LTQsCDQtSAiCiAi0LfQsNC60LvRjtGH0LXQvdC+IgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6ODAyIGJ1aWx0aW4vd29ya3RyZWUuYzo5MjkKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4MDEgYnVpbHRpbi93b3JrdHJlZS5jOjkyOAogIywgYy1mb3JtYXQKIG1zZ2lkICInJXMnIGlzIGEgbWFpbiB3b3JraW5nIHRyZWUiCiBtc2dzdHIgIuKAniVz4oCcINC1INC+0YHQvdC+0LLQvdC+INGA0LDQsdC+0YLQvdC+INC00YrRgNCy0L4iCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4MDcKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4MDYKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGZpZ3VyZSBvdXQgZGVzdGluYXRpb24gbmFtZSBmcm9tICclcyciCiBtc2dzdHIgItC40LzQtdGC0L4g0L3QsCDRhtC10LvRgtCwINC90LUg0LzQvtC20LUg0LTQsCDRgdC1INC+0L/RgNC10LTQtdC70Lgg0L7RgiDigJ4lc+KAnCIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjgxMworIzogYnVpbHRpbi93b3JrdHJlZS5jOjgxMgogIywgYy1mb3JtYXQKIG1zZ2lkICJ0YXJnZXQgJyVzJyBhbHJlYWR5IGV4aXN0cyIKIG1zZ3N0ciAi0YbQtdC70YLQsCDigJ4lc+KAnCDQstC10YfQtSDRgdGK0YnQtdGB0YLQstGD0LLQsCIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjgyMQorIzogYnVpbHRpbi93b3JrdHJlZS5jOjgyMAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiY2Fubm90IG1vdmUgYSBsb2NrZWQgd29ya2luZyB0cmVlLCBsb2NrIHJlYXNvbjogJXNcbiIKQEAgLTIxNDAxLDcgKzIxNDkwLDcgQEAKICLQvdC1INC80L7QttC1INC00LAg0L/RgNC10LzQtdGB0YLQuNGC0LUg0LfQsNC60LvRjtGH0LXQvdC+INGA0LDQsdC+0YLQvdC+INC00YrRgNCy0L4sINC/0YDQuNGH0LjQvdCwINC30LAg0LfQsNC60LvRjtGH0LLQsNC90LXRgtC+OiAlc1xuIgogItC40LvQuCDQs9C+INC+0YLQutC70Y7Rh9C10YLQtSwg0LjQu9C4INCz0L4g0L/RgNC10LzQtdGB0YLQtdGC0LUg0L/RgNC40L3Rg9C00LjRgtC10LvQvdC+INGBIOKAnm1vdmUgLWYgLWbigJwiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4MjMKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4MjIKIG1zZ2lkICIiCiAiY2Fubm90IG1vdmUgYSBsb2NrZWQgd29ya2luZyB0cmVlO1xuIgogInVzZSAnbW92ZSAtZiAtZicgdG8gb3ZlcnJpZGUgb3IgdW5sb2NrIGZpcnN0IgpAQCAtMjE0MDksNDEgKzIxNDk4LDQxIEBACiAi0L3QtSDQvNC+0LbQtSDQtNCwINC/0YDQtdC80LXRgdGC0LjRgtC1INC30LDQutC70Y7Rh9C10L3QviDRgNCw0LHQvtGC0L3QviDQtNGK0YDQstC+OlxuIgogItC40LvQuCDQs9C+INC+0YLQutC70Y7Rh9C10YLQtSwg0LjQu9C4INCz0L4g0L/RgNC10LzQtdGB0YLQtdGC0LUg0L/RgNC40L3Rg9C00LjRgtC10LvQvdC+INGBIOKAnm1vdmUgLWYgLWbigJwiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4MjYKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4MjUKICMsIGMtZm9ybWF0CiBtc2dpZCAidmFsaWRhdGlvbiBmYWlsZWQsIGNhbm5vdCBtb3ZlIHdvcmtpbmcgdHJlZTogJXMiCiBtc2dzdHIgIiIKICLQv9GA0L7QstC10YDQutC40YLQtSDRgdCwINC90LXRg9GB0L/QtdGI0L3QuCwg0YDQsNCx0L7RgtC90L7RgtC+INC00YrRgNCy0L4g0L3QtSDQvNC+0LbQtSDQtNCwINCx0YrQtNC1INC/0YDQtdC80LXRgdGC0LXQvdC+OiAlcyIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjgzMQorIzogYnVpbHRpbi93b3JrdHJlZS5jOjgzMAogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gbW92ZSAnJXMnIHRvICclcyciCiBtc2dzdHIgIuKAniVz4oCcINC90LUg0LzQvtC20LUg0LTQsCDRgdC1INC/0YDQtdC80LXRgdGC0Lgg0LIg4oCeJXPigJwiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4NzkKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4NzgKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIHJ1biAnZ2l0IHN0YXR1cycgb24gJyVzJyIKIG1zZ3N0ciAi0L3QtSDQvNC+0LbQtSDQtNCwINC40LfQv9GK0LvQvdC4IOKAnmdpdCBzdGF0dXPigJwg0LLRitGA0YXRgyDigJ4lc+KAnCIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjg4MworIzogYnVpbHRpbi93b3JrdHJlZS5jOjg4MgogIywgYy1mb3JtYXQKLW1zZ2lkICInJXMnIGlzIGRpcnR5LCB1c2UgLS1mb3JjZSB0byBkZWxldGUgaXQiCittc2dpZCAiJyVzJyBjb250YWlucyBtb2RpZmllZCBvciB1bnRyYWNrZWQgZmlsZXMsIHVzZSAtLWZvcmNlIHRvIGRlbGV0ZSBpdCIKIG1zZ3N0ciAiIgotItGA0LDQsdC+0YLQvdC+0YLQviDQtNGK0YDQstC+IOKAniVz4oCcINC90LUg0LUg0YfQuNGB0YLQviwg0LfQsCDQv9GA0LjQvdGD0LTQuNGC0LXQu9C90L4g0LjQt9GC0YDQuNCy0LDQvdC1INC1INC90LXQvtCx0YXQvtC00LjQvNCwICIKLSLQvtC/0YbQuNGP0YLQsCDigJ4tLWZvcmNl4oCcICIKKyLigJ4lc+KAnCDRgdGK0LTRitGA0LbQsCDQv9GA0L7QstC10L3QtdC90Lgg0LjQu9C4INC90L7QstC4INGE0LDQudC70L7QstC1LCDQt9CwINC/0YDQuNC90YPQtNC40YLQtdC70L3QviDQuNC30YLRgNC40LLQsNC90LUg0LUgIgorItC90LXQvtCx0YXQvtC00LjQvNCwINC+0L/RhtC40Y/RgtCwIOKAni0tZm9yY2XigJwiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4ODgKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4ODcKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIHJ1biAnZ2l0IHN0YXR1cycgb24gJyVzJywgY29kZSAlZCIKIG1zZ3N0ciAiIgogItC60L7QvNCw0L3QtNCw0YLQsCDigJ5naXQgc3RhdHVz4oCcINC90LUg0LzQvtC20LUg0LTQsCDRgdC1INC40LfQv9GK0LvQvdC4INC30LAg4oCeJXPigJwsINC60L7QtCDQt9CwINCz0YDQtdGI0LrQsDogJWQiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo5MTEKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo5MTAKIG1zZ2lkICJmb3JjZSByZW1vdmFsIGV2ZW4gaWYgd29ya3RyZWUgaXMgZGlydHkgb3IgbG9ja2VkIgogbXNnc3RyICIiCiAi0L/RgNC40L3Rg9C00LjRgtC10LvQvdC+INC40LfRgtGA0LjQstCw0L3QtSwg0LTQvtGA0Lgg0YDQsNCx0L7RgtC90L7RgtC+INC00YrRgNCy0L4g0LTQsCDQvdC1INC1INGH0LjRgdGC0L4g0LjQu9C4INC00LAg0LUg0LfQsNC60LvRjtGH0LXQvdC+IgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6OTM0CisjOiBidWlsdGluL3dvcmt0cmVlLmM6OTMzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJjYW5ub3QgcmVtb3ZlIGEgbG9ja2VkIHdvcmtpbmcgdHJlZSwgbG9jayByZWFzb246ICVzXG4iCkBAIC0yMTQ1Miw3ICsyMTU0MSw3IEBACiAi0L3QtSDQvNC+0LbQtSDQtNCwINC40LfRgtGA0LjQtdGC0LUg0LfQsNC60LvRjtGH0LXQvdC+INGA0LDQsdC+0YLQvdC+INC00YrRgNCy0L4sINC/0YDQuNGH0LjQvdCwINC30LAg0LfQsNC60LvRjtGH0LLQsNC90LXRgtC+OiAlc1xuIgogItC40LvQuCDQs9C+INC+0YLQutC70Y7Rh9C10YLQtSwg0LjQu9C4INCz0L4g0LjQt9GC0YDQuNC50YLQtSDQv9GA0LjQvdGD0LTQuNGC0LXQu9C90L4g0YEg4oCecmVtb3ZlIC1mIC1m4oCcIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6OTM2CisjOiBidWlsdGluL3dvcmt0cmVlLmM6OTM1CiBtc2dpZCAiIgogImNhbm5vdCByZW1vdmUgYSBsb2NrZWQgd29ya2luZyB0cmVlO1xuIgogInVzZSAncmVtb3ZlIC1mIC1mJyB0byBvdmVycmlkZSBvciB1bmxvY2sgZmlyc3QiCkBAIC0yMTQ2MCw3ICsyMTU0OSw3IEBACiAi0L3QtSDQvNC+0LbQtSDQtNCwINC40LfRgtGA0LjQtdGC0LUg0LfQsNC60LvRjtGH0LXQvdC+INGA0LDQsdC+0YLQvdC+INC00YrRgNCy0L46XG4iCiAi0LjQu9C4INCz0L4g0L7RgtC60LvRjtGH0LXRgtC1LCDQuNC70Lgg0LPQviDQuNC30YLRgNC40LnRgtC1INC/0YDQuNC90YPQtNC40YLQtdC70L3QviDRgSDigJ5yZW1vdmUgLWYgLWbigJwiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo5MzkKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo5MzgKICMsIGMtZm9ybWF0CiBtc2dpZCAidmFsaWRhdGlvbiBmYWlsZWQsIGNhbm5vdCByZW1vdmUgd29ya2luZyB0cmVlOiAlcyIKIG1zZ3N0ciAi0L/RgNC+0LLQtdGA0LrQuNGC0LUg0YHQsCDQvdC10YPRgdC/0LXRiNC90LgsINGA0LDQsdC+0YLQvdC+0YLQviDQtNGK0YDQstC+INC90LUg0LzQvtC20LUg0LTQsCDQsdGK0LTQtSDQuNC30YLRgNC40YLQvjogJXMiCkBAIC0yMTQ4MSw2ICsyMTU3MCwxNiBAQAogbXNnaWQgIm9ubHkgdXNlZnVsIGZvciBkZWJ1Z2dpbmciCiBtc2dzdHIgItGB0LDQvNC+INC30LAg0LjQt9GH0LjRgdGC0LLQsNC90LUg0L3QsCDQs9GA0LXRiNC60LgiCiAKKyM6IGZhc3QtaW1wb3J0LmM6MzExOAorIywgYy1mb3JtYXQKK21zZ2lkICJFeHBlY3RlZCAnbWFyaycgY29tbWFuZCwgZ290ICVzIgorbXNnc3RyICLQvtGH0LDQutCy0LAg0YHQtSDQutC+0LzQsNC90LTQsCDigJ5tYXJr4oCcLCDQsCDQsdC1INC/0L7Qu9GD0YfQtdC90LA6IOKAniVz4oCcIgorCisjOiBmYXN0LWltcG9ydC5jOjMxMjMKKyMsIGMtZm9ybWF0Cittc2dpZCAiRXhwZWN0ZWQgJ3RvJyBjb21tYW5kLCBnb3QgJXMiCittc2dzdHIgItC+0YfQsNC60LLQsCDRgdC1INC60L7QvNCw0L3QtNCwIOKAnnRv4oCcLCDQsCDQsdC1INC/0L7Qu9GD0YfQtdC90LA6IOKAniVz4oCcIgorCiAjOiBjcmVkZW50aWFsLWNhY2hlLS1kYWVtb24uYzoyMjMKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgpAQCAtMjE1OTgsMzkgKzIxNjk3LDM5IEBACiAi0L/RgdC10LLQtNC+0L3QuNC80YrRgiDigJ4lc+KAnCDQv9GA0L7QvNC10L3RjyDQv9GA0L7QvNC10L3Qu9C40LLQuCDQvdCwINGB0YDQtdC00LDRgtCwLlxuIgogItCX0LAg0YLQvtCy0LAg0LzQvtC20LUg0LTQsCDQv9C+0LvQt9Cy0LDRgtC1IOKAniFnaXTigJwg0LIg0L/RgdC10LLQtNC+0L3QuNC80LAiCiAKLSM6IGdpdC5jOjM3NworIzogZ2l0LmM6Mzc2CiAjLCBjLWZvcm1hdAogbXNnaWQgImVtcHR5IGFsaWFzIGZvciAlcyIKIG1zZ3N0ciAi0L/RgNCw0LfQtdC9INC/0YHQtdCy0LTQvtC90LjQvCDQt9CwIOKAniVz4oCcIgogCi0jOiBnaXQuYzozODAKKyM6IGdpdC5jOjM3OQogIywgYy1mb3JtYXQKIG1zZ2lkICJyZWN1cnNpdmUgYWxpYXM6ICVzIgogbXNnc3RyICLQt9Cw0YbQuNC60LvQtdC9INC/0YHQtdCy0LTQvtC90LjQvDog4oCeJXPigJwiCiAKLSM6IGdpdC5jOjQ2MAorIzogZ2l0LmM6NDU5CiBtc2dpZCAid3JpdGUgZmFpbHVyZSBvbiBzdGFuZGFyZCBvdXRwdXQiCiBtc2dzdHIgItCz0YDQtdGI0LrQsCDQv9GA0Lgg0LfQsNC/0LjRgSDQvdCwINGB0YLQsNC90LTQsNGA0YLQvdC40Y8g0LjQt9GF0L7QtCIKIAotIzogZ2l0LmM6NDYyCisjOiBnaXQuYzo0NjEKIG1zZ2lkICJ1bmtub3duIHdyaXRlIGZhaWx1cmUgb24gc3RhbmRhcmQgb3V0cHV0IgogbXNnc3RyICLQvdC10LjQt9Cy0LXRgdGC0L3QsCDQs9GA0LXRiNC60LAg0L/RgNC4INC30LDQv9C40YEg0L3QsCDRgdGC0LDQvdC00LDRgNGC0L3QuNGPINC40LfRhdC+0LQiCiAKLSM6IGdpdC5jOjQ2NAorIzogZ2l0LmM6NDYzCiBtc2dpZCAiY2xvc2UgZmFpbGVkIG9uIHN0YW5kYXJkIG91dHB1dCIKIG1zZ3N0ciAi0LPRgNC10YjQutCwINC/0YDQuCDQt9Cw0YLQstCw0YDRj9C90LUg0L3QsCDRgdGC0LDQvdC00LDRgNGC0L3QuNGPINC40LfRhdC+0LQiCiAKLSM6IGdpdC5jOjc5MworIzogZ2l0LmM6NzkyCiAjLCBjLWZvcm1hdAogbXNnaWQgImFsaWFzIGxvb3AgZGV0ZWN0ZWQ6IGV4cGFuc2lvbiBvZiAnJXMnIGRvZXMgbm90IHRlcm1pbmF0ZTolcyIKIG1zZ3N0ciAi0LfQsNGG0LjQutC70Y/QvdC1INCyINC/0YHQtdCy0LTQvtC90LjQvNC40YLQtTog0LfQsNC80LXRgdGC0LLQsNC90LjRj9GC0LAg0L3QsCDigJ4lc+KAnCDQvdC1INC/0YDQuNC60LvRjtGH0LLQsNGCOiVzIgogCi0jOiBnaXQuYzo4NDMKKyM6IGdpdC5jOjg0MgogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgaGFuZGxlICVzIGFzIGEgYnVpbHRpbiIKIG1zZ3N0ciAi4oCeJXPigJwg0L3QtSDQvNC+0LbQtSDQtNCwINGB0LUg0L7QsdGA0LDQsdC+0YLQuCDQutCw0YLQviDQstCz0YDQsNC00LXQvdCwINC60L7QvNCw0L3QtNCwIgogCi0jOiBnaXQuYzo4NTYKKyM6IGdpdC5jOjg1NQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAidXNhZ2U6ICVzXG4iCkBAIC0yMTYzOSwxNCArMjE3MzgsMTQgQEAKICLRg9C/0L7RgtGA0LXQsdCwOiAlc1xuIgogIlxuIgogCi0jOiBnaXQuYzo4NzYKKyM6IGdpdC5jOjg3NQogIywgYy1mb3JtYXQKIG1zZ2lkICJleHBhbnNpb24gb2YgYWxpYXMgJyVzJyBmYWlsZWQ7ICclcycgaXMgbm90IGEgZ2l0IGNvbW1hbmRcbiIKIG1zZ3N0ciAiIgogItC90LXRg9GB0L/QtdGI0L3QviDQt9Cw0LzQtdGB0YLQstCw0L3QtSDQvdCwINC/0YHQtdCy0LTQvtC90LjQvNCwIOKAniVz4oCcIOKAlCDRgNC10LfRg9C70YLQsNGC0YrRgiDigJ4lc+KAnCDQvdC1INC1INC60L7QvNCw0L3QtNCwINC90LAgIgogImdpdFxuIgogCi0jOiBnaXQuYzo4ODgKKyM6IGdpdC5jOjg4NwogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gcnVuIGNvbW1hbmQgJyVzJzogJXNcbiIKIG1zZ3N0ciAi0LrQvtC80LDQvdC00LDRgtCwIOKAniVz4oCcINC90LUg0LzQvtC20LUg0LTQsCDRgdC1INC40LfQv9GK0LvQvdC4OiAlc1xuIgpAQCAtMjE2NjUsMzQgKzIxNzY0LDM0IEBACiBtc2dpZCAiUHVibGljIGtleSBwaW5uaW5nIG5vdCBzdXBwb3J0ZWQgd2l0aCBjVVJMIDwgNy40NC4wIgogbXNnc3RyICLQl9Cw0LTQsNCy0LDQvdC10YLQviDQvdCwINC/0L7RgdGC0L7Rj9C90LXQvSDQv9GD0LHQu9C40YfQtdC9INC60LvRjtGHINC90LUg0YHQtSDQv9C+0LTQtNGK0YDQttCwINC+0YIgY1VSTCA8IDcuNDQuMCIKIAotIzogaHR0cC5jOjg3NgorIzogaHR0cC5jOjg3OAogbXNnaWQgIkNVUkxTU0xPUFRfTk9fUkVWT0tFIG5vdCBzdXBwb3J0ZWQgd2l0aCBjVVJMIDwgNy40NC4wIgogbXNnc3RyICLigJ5DVVJMU1NMT1BUX05PX1JFVk9LReKAnCDQvdC1INGB0LUg0L/QvtC00LTRitGA0LbQsCDQvtGCIGNVUkwgPCA3LjQ0LjAiCiAKLSM6IGh0dHAuYzo5NDkKKyM6IGh0dHAuYzo5NTEKIG1zZ2lkICJQcm90b2NvbCByZXN0cmljdGlvbnMgbm90IHN1cHBvcnRlZCB3aXRoIGNVUkwgPCA3LjE5LjQiCiBtc2dzdHIgItCe0LPRgNCw0L3QuNGH0LDQstCw0L3QtdGC0L4g0L3QsCDQv9GA0L7RgtC+0LrQvtC70LjRgtC1INC90LUg0YHQtSDQv9C+0LTQtNGK0YDQttCwINC+0YIgY1VSTCA8IDcuNDQuMCIKIAotIzogaHR0cC5jOjEwODUKKyM6IGh0dHAuYzoxMDg4CiAjLCBjLWZvcm1hdAogbXNnaWQgIlVuc3VwcG9ydGVkIFNTTCBiYWNrZW5kICclcycuIFN1cHBvcnRlZCBTU0wgYmFja2VuZHM6IgogbXNnc3RyICLQndC10L/QvtC00LTRitGA0LbQsNC90LAg0YDQtdCw0LvQuNC30LDRhtC40Y8g0L3QsCBTU0wg4oCeJXPigJwuINCf0L7QtNC00YrRgNC20LDRgiDRgdC1OiIKIAotIzogaHR0cC5jOjEwOTIKKyM6IGh0dHAuYzoxMDk1CiAjLCBjLWZvcm1hdAogbXNnaWQgIkNvdWxkIG5vdCBzZXQgU1NMIGJhY2tlbmQgdG8gJyVzJzogY1VSTCB3YXMgYnVpbHQgd2l0aG91dCBTU0wgYmFja2VuZHMiCiBtc2dzdHIgIiIKICLQoNC10LDQu9C40LfQsNGG0LjRj9GC0LAg0L3QsCBTU0wg0L3QtSDQvNC+0LbQtSDQtNCwINGB0LUg0LfQsNC00LDQtNC1INC00LAg0LUg4oCeJXPigJw6IGNVUkwg0LUg0LrQvtC80L/QuNC70LjRgNCw0L0g0LHQtdC3ICIKICLQv9C+0LTQtNGA0YrQttC60LAg0L3QsCBTU0wiCiAKLSM6IGh0dHAuYzoxMDk2CisjOiBodHRwLmM6MTA5OQogIywgYy1mb3JtYXQKIG1zZ2lkICJDb3VsZCBub3Qgc2V0IFNTTCBiYWNrZW5kIHRvICclcyc6IGFscmVhZHkgc2V0IgogbXNnc3RyICIiCiAi0KDQtdCw0LvQuNC30LDRhtC40Y/RgtCwINC90LAgU1NMINC90LUg0LzQvtC20LUg0LTQsCDRgdC1INC30LDQtNCw0LTQtSDQtNCwINC1IOKAniVz4oCcLCDQt9Cw0YnQvtGC0L4g0LLQtdGH0LUg0LUg0LfQsNC00LDQtNC10L3QsCAiCiAi0LTRgNGD0LPQsCIKIAotIzogaHR0cC5jOjE5NjUKKyM6IGh0dHAuYzoxOTY4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJ1bmFibGUgdG8gdXBkYXRlIHVybCBiYXNlIGZyb20gcmVkaXJlY3Rpb246XG4iCkBAIC0yMTcwMywxMzcgKzIxODAyLDEzNyBAQAogIiAgICDil48g0LfQsNGP0LLQtdC9INCw0LTRgNC10YE6ICVzXG4iCiAiICAgIOKXjyDQv9GA0LXQvdCw0YHQvtGH0LLQsNC90LU6ICVzIgogCi0jOiByZW1vdGUtY3VybC5jOjE1NworIzogcmVtb3RlLWN1cmwuYzoxNjYKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBxdW90aW5nIGluIHB1c2gtb3B0aW9uIHZhbHVlOiAnJXMnIgogbXNnc3RyICIiCiAi0L3QtdC/0YDQsNCy0LjQu9C90L4g0LXQutGA0LDQvdC40YDQsNC90LUg0LjQu9C4INGG0LjRgtC40YDQsNC90LUg0LIg0YHRgtC+0LnQvdC+0YHRgtGC0LAg0LrRitC8INC+0L/RhtC40Y8g0LfQsCDQuNC30YLQu9Cw0YHQutCy0LDQvdC1OiAiCiAi4oCeJXPigJwiCiAKLSM6IHJlbW90ZS1jdXJsLmM6MjU0CisjOiByZW1vdGUtY3VybC5jOjI2MwogIywgYy1mb3JtYXQKIG1zZ2lkICIlc2luZm8vcmVmcyBub3QgdmFsaWQ6IGlzIHRoaXMgYSBnaXQgcmVwb3NpdG9yeT8iCiBtc2dzdHIgIuKAniVzaW5mby9yZWZz4oCcINC1INC90LXQuNC30L/QvtC70LfQstCw0LXQvNC+LCDQv9GA0L7QstC10YDQtdGC0LUg0LTQsNC70Lgg0LUg0YXRgNCw0L3QuNC70LjRidC1INC90LAgZ2l0IgogCi0jOiByZW1vdGUtY3VybC5jOjM1NQorIzogcmVtb3RlLWN1cmwuYzozNjQKIG1zZ2lkICJpbnZhbGlkIHNlcnZlciByZXNwb25zZTsgZXhwZWN0ZWQgc2VydmljZSwgZ290IGZsdXNoIHBhY2tldCIKIG1zZ3N0ciAiIgogItC90LXQv9GA0LDQstC40LvQtdC9INC+0YLQs9C+0LLQvtGAINC+0YIg0YHRitGA0LLRitGA0LA6INC+0YfQsNC60LLQsNGI0LUg0YHQtSDRg9GB0LvRg9Cz0LAsINCwINCx0LUg0L/QvtC70YPRh9C10L0g0LjQt9GH0LjRgdGC0LLQsNGJICIKICLQv9Cw0LrQtdGCIOKAnmZsdXNo4oCcIgogCi0jOiByZW1vdGUtY3VybC5jOjM4NgorIzogcmVtb3RlLWN1cmwuYzozOTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBzZXJ2ZXIgcmVzcG9uc2U7IGdvdCAnJXMnIgogbXNnc3RyICLQvdC10L/RgNCw0LLQuNC70LXQvSDQvtGC0LPQvtCy0L7RgCDQvtGCINGB0YrRgNCy0YrRgNCwLCDQsdC1INC/0L7Qu9GD0YfQtdC90L46IOKAniVz4oCcIgogCi0jOiByZW1vdGUtY3VybC5jOjQ0NgorIzogcmVtb3RlLWN1cmwuYzo0NTUKICMsIGMtZm9ybWF0CiBtc2dpZCAicmVwb3NpdG9yeSAnJXMnIG5vdCBmb3VuZCIKIG1zZ3N0ciAi0YXRgNCw0L3QuNC70LjRidC10YLQviDigJ4lc+KAnCDQu9C40L/RgdCy0LAiCiAKLSM6IHJlbW90ZS1jdXJsLmM6NDUwCisjOiByZW1vdGUtY3VybC5jOjQ1OQogIywgYy1mb3JtYXQKIG1zZ2lkICJBdXRoZW50aWNhdGlvbiBmYWlsZWQgZm9yICclcyciCiBtc2dzdHIgItCd0LXRg9GB0L/QtdGI0L3QsCDQuNC00LXQvdGC0LjRhNC40LrQsNGG0LjRjyDQutGK0Lwg4oCeJXPigJwiCiAKLSM6IHJlbW90ZS1jdXJsLmM6NDU0CisjOiByZW1vdGUtY3VybC5jOjQ2MwogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gYWNjZXNzICclcyc6ICVzIgogbXNnc3RyICLQvdGP0LzQsCDQtNC+0YHRgtGK0L8g0LTQviDigJ4lc+KAnDogJXMiCiAKLSM6IHJlbW90ZS1jdXJsLmM6NDYwCisjOiByZW1vdGUtY3VybC5jOjQ2OQogIywgYy1mb3JtYXQKIG1zZ2lkICJyZWRpcmVjdGluZyB0byAlcyIKIG1zZ3N0ciAi0L/RgNC10L3QsNGB0L7Rh9Cy0LDQvdC1INC60YrQvCDigJ4lc+KAnCIKIAotIzogcmVtb3RlLWN1cmwuYzo1ODQKKyM6IHJlbW90ZS1jdXJsLmM6NTkzCiBtc2dpZCAic2hvdWxkbid0IGhhdmUgRU9GIHdoZW4gbm90IGdlbnRsZSBvbiBFT0YiCiBtc2dzdHIgItC/0L7Qu9GD0YfQtdC9INC1IEVPRiwg0LIg0YDQtdC20LjQvCDQsdC10Lcg0L/QvtC00LTRgNGK0LbQutCwINC30LAg0YLQvtCy0LAiCiAKLSM6IHJlbW90ZS1jdXJsLmM6NjY0CisjOiByZW1vdGUtY3VybC5jOjY3MwogbXNnaWQgInVuYWJsZSB0byByZXdpbmQgcnBjIHBvc3QgZGF0YSAtIHRyeSBpbmNyZWFzaW5nIGh0dHAucG9zdEJ1ZmZlciIKIG1zZ3N0ciAiIgogItC00LDQvdC90LjRgtC1INC30LAgUE9TVCDQvdC1INC80L7Qs9Cw0YIg0LTQsCDRgdC1INC/0YDQvtGH0LXRgtCw0YIg0L3QsNC90L7QstC+LCDQv9GA0L7QsdCy0LDQudGC0LUg0LTQsCDRg9Cy0LXQu9C40YfQuNGC0LUgIgogItC90LDRgdGC0YDQvtC50LrQsNGC0LAg4oCeaHR0cC5wb3N0QnVmZmVy4oCcIgogCi0jOiByZW1vdGUtY3VybC5jOjcyNAorIzogcmVtb3RlLWN1cmwuYzo3MzMKICMsIGMtZm9ybWF0CiBtc2dpZCAiUlBDIGZhaWxlZDsgJXMiCiBtc2dzdHIgItCd0LXRg9GB0L/QtdGI0L3QviDQvtGC0LTQsNC70LXRh9C10L3QviDQuNC30LLQuNC60LLQsNC90LUuICAlcyIKIAotIzogcmVtb3RlLWN1cmwuYzo3NjQKKyM6IHJlbW90ZS1jdXJsLmM6NzczCiBtc2dpZCAiY2Fubm90IGhhbmRsZSBwdXNoZXMgdGhpcyBiaWciCiBtc2dzdHIgItGC0L7Qu9C60L7QstCwINCz0L7Qu9C10LzQuCDQuNC30YLQu9Cw0YHQutCy0LDQvdC40Y8g0L3QtSDQvNC+0LbQtSDQtNCwINGB0LUg0LjQt9C/0YrQu9C90Y/RgiIKIAotIzogcmVtb3RlLWN1cmwuYzo4NzkKKyM6IHJlbW90ZS1jdXJsLmM6ODg4CiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCBkZWZsYXRlIHJlcXVlc3Q7IHpsaWIgZGVmbGF0ZSBlcnJvciAlZCIKIG1zZ3N0ciAiIgogItC30LDRj9Cy0LrQsNGC0LAg0L3QtSDQvNC+0LbQtSDQtNCwINCx0YrQtNC1INC00LXQutC+0LzQv9GA0LXRgdC40YDQsNC90LAsINCz0YDQtdGI0LrQsCDQvtGCIOKAnnpsaWLigJwg0L/RgNC4ICIKICLQtNC10LrQvtC80L/RgNC10YHQuNGA0LDQvdC1OiAlZCIKIAotIzogcmVtb3RlLWN1cmwuYzo4ODMKKyM6IHJlbW90ZS1jdXJsLmM6ODkyCiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCBkZWZsYXRlIHJlcXVlc3Q7IHpsaWIgZW5kIGVycm9yICVkIgogbXNnc3RyICIiCiAi0LfQsNGP0LLQutCw0YLQsCDQvdC1INC80L7QttC1INC00LAg0LHRitC00LUg0LTQtdC60L7QvNC/0YDQtdGB0LjRgNCw0L3QsDsg0LPRgNC10YjQutCwINC+0YIg4oCeemxpYuKAnCDQv9GA0Lgg0LfQsNCy0YrRgNGI0LLQsNC90LU6ICVkPCIKIAotIzogcmVtb3RlLWN1cmwuYzoxMDE0CisjOiByZW1vdGUtY3VybC5jOjEwMjMKIG1zZ2lkICJkdW1iIGh0dHAgdHJhbnNwb3J0IGRvZXMgbm90IHN1cHBvcnQgc2hhbGxvdyBjYXBhYmlsaXRpZXMiCiBtc2dzdHIgItC+0L/RgNC+0YHRgtC10L3QuNGP0YIg0YLRgNCw0L3RgdC/0L7RgNGCINC/0L4gaHR0cCDQvdC1INC/0L7QtNC00YrRgNC20LAg0L/Qu9C40YLQutC4INC60LvQuNC10L3RgtC4IgogCi0jOiByZW1vdGUtY3VybC5jOjEwMjgKKyM6IHJlbW90ZS1jdXJsLmM6MTAzNwogbXNnaWQgImZldGNoIGZhaWxlZC4iCiBtc2dzdHIgItC90LXRg9GB0L/QtdGI0L3QviDQtNC+0YHRgtCw0LLRj9C90LUuIgogCi0jOiByZW1vdGUtY3VybC5jOjEwNzYKKyM6IHJlbW90ZS1jdXJsLmM6MTA4NQogbXNnaWQgImNhbm5vdCBmZXRjaCBieSBzaGExIG92ZXIgc21hcnQgaHR0cCIKIG1zZ3N0ciAi0YPQvNC90LjRj9GCINCy0LDRgNC40LDQvdGCINC90LAgaHR0cCDQvdC1INC80L7QttC1INC00LAg0LTQvtGB0YLQsNCy0Y8g0L/QviBTSEExIgogCi0jOiByZW1vdGUtY3VybC5jOjExMjAgcmVtb3RlLWN1cmwuYzoxMTI2CisjOiByZW1vdGUtY3VybC5jOjExMjkgcmVtb3RlLWN1cmwuYzoxMTM1CiAjLCBjLWZvcm1hdAogbXNnaWQgInByb3RvY29sIGVycm9yOiBleHBlY3RlZCBzaGEvcmVmLCBnb3QgJyVzJyIKIG1zZ3N0ciAi0L/RgNC+0YLQvtC60L7Qu9C90LAg0LPRgNC10YjQutCwOiDQvtGH0LDQutCy0LAg0YHQtSBTSEExINC40LvQuCDRg9C60LDQt9Cw0YLQtdC7LCDQsCDQsdC1INC/0L7Qu9GD0YfQtdC90L46IOKAniVz4oCcIgogCi0jOiByZW1vdGUtY3VybC5jOjExMzggcmVtb3RlLWN1cmwuYzoxMjUyCisjOiByZW1vdGUtY3VybC5jOjExNDcgcmVtb3RlLWN1cmwuYzoxMjYxCiAjLCBjLWZvcm1hdAogbXNnaWQgImh0dHAgdHJhbnNwb3J0IGRvZXMgbm90IHN1cHBvcnQgJXMiCiBtc2dzdHIgItGC0YDQsNC90YHQv9C+0YDRgtGK0YIg0L/QviBodHRwINC90LUg0L/QvtC00LTRitGA0LbQsCDigJ4lc+KAnCIKIAotIzogcmVtb3RlLWN1cmwuYzoxMTc0CisjOiByZW1vdGUtY3VybC5jOjExODMKIG1zZ2lkICJnaXQtaHR0cC1wdXNoIGZhaWxlZCIKIG1zZ3N0ciAi0L3QtdGD0YHQv9C10YjQvdC+INC40LfQv9GK0LvQvdC10L3QuNC1INC90LAg4oCeZ2l0LWh0dHAtcHVzaOKAnCIKIAotIzogcmVtb3RlLWN1cmwuYzoxMzYwCisjOiByZW1vdGUtY3VybC5jOjEzNjcKIG1zZ2lkICJyZW1vdGUtY3VybDogdXNhZ2U6IGdpdCByZW1vdGUtY3VybCA8cmVtb3RlPiBbPHVybD5dIgogbXNnc3RyICJyZW1vdGUtY3VybDog0YPQv9C+0YLRgNC10LHQsDogZ2l0IHJlbW90ZS1jdXJsINCl0KDQkNCd0JjQm9CY0KnQlSBb0JDQlNCg0JXQoV0iCiAKLSM6IHJlbW90ZS1jdXJsLmM6MTM5MgorIzogcmVtb3RlLWN1cmwuYzoxMzk5CiBtc2dpZCAicmVtb3RlLWN1cmw6IGVycm9yIHJlYWRpbmcgY29tbWFuZCBzdHJlYW0gZnJvbSBnaXQiCiBtc2dzdHIgInJlbW90ZS1jdXJsOiDQs9GA0LXRiNC60LAg0L/RgNC4INC40LfRh9C40YLQsNC90LXRgtC+INC90LAg0L/QvtGC0L7QutCwINC60L7QvNCw0L3QtNC4INC+0YIgZ2l0IgogCi0jOiByZW1vdGUtY3VybC5jOjEzOTkKKyM6IHJlbW90ZS1jdXJsLmM6MTQwNgogbXNnaWQgInJlbW90ZS1jdXJsOiBmZXRjaCBhdHRlbXB0ZWQgd2l0aG91dCBhIGxvY2FsIHJlcG8iCiBtc2dzdHIgInJlbW90ZS1jdXJsOiDQvtC/0LjRgiDQt9CwINC00L7RgdGC0LDQstGP0L3QtSDQsdC10Lcg0LvQvtC60LDQu9C90L4g0YXRgNCw0L3QuNC70LjRidC1IgogCi0jOiByZW1vdGUtY3VybC5jOjE0MzkKKyM6IHJlbW90ZS1jdXJsLmM6MTQ0NgogIywgYy1mb3JtYXQKIG1zZ2lkICJyZW1vdGUtY3VybDogdW5rbm93biBjb21tYW5kICclcycgZnJvbSBnaXQiCiBtc2dzdHIgInJlbW90ZS1jdXJsOiDQvdC10L/QvtC30L3QsNGC0LAg0LrQvtC80LDQvdC00LAg4oCeJXPigJwg0L7RgiBnaXQiCiAKLSM6IGxpc3Qtb2JqZWN0cy1maWx0ZXItb3B0aW9ucy5oOjYxCisjOiBsaXN0LW9iamVjdHMtZmlsdGVyLW9wdGlvbnMuaDo4NQogbXNnaWQgImFyZ3MiCiBtc2dzdHIgItCQ0KDQk9Cj0JzQldCd0KLQmCIKIAotIzogbGlzdC1vYmplY3RzLWZpbHRlci1vcHRpb25zLmg6NjIKKyM6IGxpc3Qtb2JqZWN0cy1maWx0ZXItb3B0aW9ucy5oOjg2CiBtc2dpZCAib2JqZWN0IGZpbHRlcmluZyIKIG1zZ3N0ciAi0YTQuNC70YLRgNC40YDQsNC90LUg0L/QviDQstC40LQg0L3QsCDQvtCx0LXQutGC0LAiCiAKLSM6IHBhcnNlLW9wdGlvbnMuaDoxNzAKKyM6IHBhcnNlLW9wdGlvbnMuaDoxNzkKIG1zZ2lkICJleHBpcnktZGF0ZSIKIG1zZ3N0ciAi0L/QtdGA0LjQvtC0INC90LAg0LLQsNC70LjQtNC90L7RgdGCL9C30LDQv9Cw0LfQstCw0L3QtSIKIAotIzogcGFyc2Utb3B0aW9ucy5oOjE4NAorIzogcGFyc2Utb3B0aW9ucy5oOjE5MwogbXNnaWQgIm5vLW9wIChiYWNrd2FyZCBjb21wYXRpYmlsaXR5KSIKIG1zZ3N0ciAi0L3Rg9C70LXQstCwINC+0L/QtdGA0LDRhtC40Y8gKNC30LAg0YHRitCy0LzQtdGB0YLQuNC80L7RgdGCINGBINC/0YDQtdC00LjRiNC90Lgg0LLQtdGA0YHQuNC4KSIKIApkaWZmIC0tZ2l0IGEvcG8vY2EucG8gYi9wby9jYS5wbwppbmRleCA3M2EwODI0Li4zYzg3OGNlIDEwMDY0NAotLS0gYS9wby9jYS5wbworKysgYi9wby9jYS5wbwpAQCAtMTMzMiw3ICsxMzMyLDcgQEAKIAogIzogYnVuZGxlLmM6MTQzCiBtc2dpZCAiUmVwb3NpdG9yeSBsYWNrcyB0aGVzZSBwcmVyZXF1aXNpdGUgY29tbWl0czoiCi1tc2dzdHIgIkFsIGRpcMOyc2l0IGxpIG1hbnF1ZW4gYXF1ZXN0ZXMgY29taXNzaW9ucyBwcmVyZXF1aXNpdHM6IgorbXNnc3RyICJBbCBkaXDDsnNpdCBsaSBtYW5xdWVuIGFxdWVzdGVzIGNvbWlzc2lvbnMgcHJlcmVxdWVyaWRlczoiCiAKICM6IGJ1bmRsZS5jOjE0NgogbXNnaWQgIm5lZWQgYSByZXBvc2l0b3J5IHRvIHZlcmlmeSBhIGJ1bmRsZSIKQEAgLTI1NTIsNyArMjU1Miw3IEBACiAib3B0aW9uIGRpZmYtYWxnb3JpdGhtIGFjY2VwdHMgXCJteWVyc1wiLCBcIm1pbmltYWxcIiwgXCJwYXRpZW5jZVwiIGFuZCAiCiAiXCJoaXN0b2dyYW1cIiIKIG1zZ3N0ciAiIgotImwnb3BjacOzIGRpZmYtYWxnb3JpdGhtIGFjY2VwdGEgwqtteWVyc8K7LCDCq21pbmltYWxtaW5pbWFswrssIFwicGF0aWVuY2VcIiBhbmQgIgorImwnb3BjacOzIGRpZmYtYWxnb3JpdGhtIGFjY2VwdGEgwqtteWVyc8K7LCDCq21pbmltYWzCuywgwqtwYXRpZW5jZcK7IGkgIgogIsKraGlzdG9ncmFtwrsiCiAKICM6IGRpZmYuYzo1MDMzIGRpZmYuYzo1MDUzCkBAIC00NTgyLDcgKzQ1ODIsNyBAQAogIzogcmVhZC1jYWNoZS5jOjcxOAogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogY2FuIG9ubHkgYWRkIHJlZ3VsYXIgZmlsZXMsIHN5bWJvbGljIGxpbmtzIG9yIGdpdC1kaXJlY3RvcmllcyIKLW1zZ3N0ciAiJXM6IG5vbcOpcyBwb3QgYWZlZ2lyIGZpdHhlcnMgbm9ybWFscywgZW5sbGHDp29zIHNpbWJvbGljcyBvIGRpcmVjdG9yaXMgZ2l0IgorbXNnc3RyICIlczogbm9tw6lzIHBvdCBhZmVnaXIgZml0eGVycyBub3JtYWxzLCBlbmxsYcOnb3Mgc2ltYsOybGljcyBvIGRpcmVjdG9yaXMgZ2l0IgogCiAjOiByZWFkLWNhY2hlLmM6NzIzCiAjLCBmdXp6eSwgYy1mb3JtYXQKQEAgLTc4MTcsOSArNzgxNyw4IEBACiBtc2dzdHIgIlMnZXN0w6AgYXZvcnRhbnRcbiIKIAogIzogdW5wYWNrLXRyZWVzLmM6MzE4Ci0jLCBmdXp6eQogbXNnaWQgIlVwZGF0aW5nIGZpbGVzIgotbXNnc3RyICJTJ2VzdMOgIGFjdHVhbGl0emFudCAlcyIKK21zZ3N0ciAiUydlc3RhbiBhY3R1YWxpdHphbnQgZWxzIGZpdHhlcnMiCiAKICM6IHVucGFjay10cmVlcy5jOjM1MAogbXNnaWQgIiIKQEAgLTgzMDcsNyArODMwNiw3IEBACiAKICM6IHd0LXN0YXR1cy5jOjE3MjcKIG1zZ2lkICJObyBjb21taXRzIHlldCIKLW1zZ3N0ciAiTm8gcydoYSBmZXQgY2FwIGNvbWlzc2nDsyBlbmNhcmEuIgorbXNnc3RyICJObyBzJ2hhIGZldCBjYXAgY29taXNzacOzIGVuY2FyYSIKIAogIzogd3Qtc3RhdHVzLmM6MTc0MQogbXNnaWQgIlVudHJhY2tlZCBmaWxlcyIKQEAgLTEwMjE1LDExICsxMDIxNCwxMSBAQAogbXNnc3RyWzFdICJhY3R1YWxpdHphdHMgJWQgY2FtaW5zXG4iCiAKICM6IGJ1aWx0aW4vY2hlY2tvdXQuYzozODYKLSMsIGZ1enp5LCBjLWZvcm1hdAorIywgYy1mb3JtYXQKIG1zZ2lkICJVcGRhdGVkICVkIHBhdGggZnJvbSB0aGUgaW5kZXgiCiBtc2dpZF9wbHVyYWwgIlVwZGF0ZWQgJWQgcGF0aHMgZnJvbSB0aGUgaW5kZXgiCi1tc2dzdHJbMF0gIlMnaGEgcHJvZHXDr3QgdW4gZXJyb3IgZW4gbGxlZ2lyIGwnw61uZGV4IgotbXNnc3RyWzFdICJTJ2hhIHByb2R1w690IHVuIGVycm9yIGVuIGxsZWdpciBsJ8OtbmRleCIKK21zZ3N0clswXSAiUydoYSBhY3R1YWxpdHphdCB1biBjYW3DrSBkZXMgZGUgbCfDrW5kZXgiCittc2dzdHJbMV0gIlMnaGEgYWN0dWFsaXR6YXQgJWQgY2FtaW5zIGRlcyBkZSBsJ8OtbmRleCIKIAogIzogYnVpbHRpbi9jaGVja291dC5jOjQwOSBidWlsdGluL2NoZWNrb3V0LmM6NDEyIGJ1aWx0aW4vY2hlY2tvdXQuYzo0MTUKICM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo0MTkKQEAgLTE1ODQ4LDcgKzE1ODQ3LDcgQEAKICJleGlzdGluZyBub3RlcyIKIG1zZ3N0ciAiIgogIk5vIGVzIHBvZGVuIGFmZWdpciBsZXMgbm90ZXMuIFMnaGFuIHRyb2JhdCBub3RlcyBleGlzdGVudHMgZGUgbCdvYmplY3RlICVzLiAiCi0iVXNldSAnLWYnIHBlciBhIHNvYnJlZXNjcml1cmUgbGVzIG5vdGVzIGV4aXN0ZW50cy4iCisiVXNldSAnLWYnIHBlciBhIHNvYnJlZXNjcml1cmUgbGVzIG5vdGVzIGV4aXN0ZW50cyIKIAogIzogYnVpbHRpbi9ub3Rlcy5jOjQ2MyBidWlsdGluL25vdGVzLmM6NTQ0CiAjLCBjLWZvcm1hdApAQCAtMTk1NzAsNyArMTk1NjksNyBAQAogCiAjOiBidWlsdGluL3N0YXNoLmM6MTI2OSBnaXQtbGVnYWN5LXN0YXNoLnNoOjMzNwogbXNnaWQgIkNhbid0IHVzZSAtLXBhdGNoIGFuZCAtLWluY2x1ZGUtdW50cmFja2VkIG9yIC0tYWxsIGF0IHRoZSBzYW1lIHRpbWUiCi1tc2dzdHIgIk5vIGVzIHBvZGVuIHVzYXIgLS1wYXRjaCBpIC0taW5jbHVkZS11bnRyYWNrZWQgbyAtLWFsbCBhIGxhIHZlZ2FkYS4iCittc2dzdHIgIk5vIGVzIHBvZGVuIHVzYXIgLS1wYXRjaCBpIC0taW5jbHVkZS11bnRyYWNrZWQgbyAtLWFsbCBhIGxhIHZlZ2FkYSIKIAogIzogYnVpbHRpbi9zdGFzaC5jOjEyODUKICMsIGZ1enp5CkBAIC0xOTY5OCw3ICsxOTY5Nyw3IEBACiAKICM6IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzo1NjUgYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjEwNTAKIG1zZ2lkICJSZWN1cnNlIGludG8gbmVzdGVkIHN1Ym1vZHVsZXMiCi1tc2dzdHIgIkluY2xvdSByZWN1cnNpdmFtZW50IGVscyBzdWJtw7JkdWxzIGltYnJpbmNhdHMiCittc2dzdHIgIkluY2xvdSByZWN1cnNpdmFtZW50IGVscyBzdWJtw7JkdWxzIGltYnJpY2F0cyIKIAogIzogYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjU3MAogIywgZnV6enkKQEAgLTIxNDg3LDcgKzIxNDg2LDcgQEAKICM6IGNvbW1hbmQtbGlzdC5oOjg2CiBtc2dpZCAiU2hvdyBjaGFuZ2VzIGJldHdlZW4gY29tbWl0cywgY29tbWl0IGFuZCB3b3JraW5nIHRyZWUsIGV0YyIKIG1zZ3N0ciAiIgotIk1vc3RyYSBlbHMgY2FudmlzIGVudHJlIGNvbWlzc2lvbnMsIGxhIGNvbWlzc2nDsyBpIGwnYXJicmUgZGUgdHJlYmFsbCwgZXRjLiIKKyJNb3N0cmEgZWxzIGNhbnZpcyBlbnRyZSBjb21pc3Npb25zLCBsYSBjb21pc3Npw7MgaSBsJ2FyYnJlIGRlIHRyZWJhbGwsIGV0YyIKIAogIzogY29tbWFuZC1saXN0Lmg6ODcKIG1zZ2lkICJDb21wYXJlcyBmaWxlcyBpbiB0aGUgd29ya2luZyB0cmVlIGFuZCB0aGUgaW5kZXgiCkBAIC0yMTgwMCw3ICsyMTc5OSw3IEBACiAKICM6IGNvbW1hbmQtbGlzdC5oOjE2MQogbXNnaWQgIlNlbmQgYSBjb2xsZWN0aW9uIG9mIHBhdGNoZXMgYXMgZW1haWxzIgotbXNnc3RyICJFbnZpYSB1bmEgY29swrdsZWNpw7MgZGUgcGVkYcOnb3MgY29tIGEgY29ycmV1cyBlbGVjdHLDsm5pY3MiCittc2dzdHIgIkVudmlhIHVuYSBjb2zCt2xlY2Npw7MgZGUgcGVkYcOnb3MgY29tIGEgY29ycmV1cyBlbGVjdHLDsm5pY3MiCiAKICM6IGNvbW1hbmQtbGlzdC5oOjE2MgogbXNnaWQgIlB1c2ggb2JqZWN0cyBvdmVyIEdpdCBwcm90b2NvbCB0byBhbm90aGVyIHJlcG9zaXRvcnkiCkBAIC0yMjMyMSwxMSArMjIzMjAsMTIgQEAKICJjYW3DrSBkZSBzdWJtw7JkdWwgJyRzbV9wYXRoJyIKIAogIzogZ2l0LXN1Ym1vZHVsZS5zaDo2MDYKLSMsIGZ1enp5LCBzaC1mb3JtYXQKKyMsIHNoLWZvcm1hdAogbXNnaWQgIiIKICJVbmFibGUgdG8gZmV0Y2ggaW4gc3VibW9kdWxlIHBhdGggJyRkaXNwbGF5cGF0aCc7IHRyeWluZyB0byBkaXJlY3RseSBmZXRjaCAiCiAiJHNoYTE6IgotbXNnc3RyICJObyBzJ2hhIHBvZ3V0IG9idGVuaXIgZW4gZWwgY2Ftw60gZGUgc3VibcOyZHVsICckZGlzcGxheXBhdGgnIgorbXNnc3RyICJObyBzJ2hhIHBvZ3V0IG9idGVuaXIgZW4gZWwgY2Ftw60gZGUgc3VibcOyZHVsIMKrJGRpc3BsYXlwYXRowrs7IHMnZXN0w6AgaW50ZW50YW50ICIKKyJvYnRlbmlyIGRpcmVjdGFtZW50ICRzaGExOiIKIAogIzogZ2l0LXN1Ym1vZHVsZS5zaDo2MTIKICMsIHNoLWZvcm1hdApAQCAtMjIzMzMsNTggKzIyMzMzLDU4IEBACiAiRmV0Y2hlZCBpbiBzdWJtb2R1bGUgcGF0aCAnJGRpc3BsYXlwYXRoJywgYnV0IGl0IGRpZCBub3QgY29udGFpbiAkc2hhMS4gIgogIkRpcmVjdCBmZXRjaGluZyBvZiB0aGF0IGNvbW1pdCBmYWlsZWQuIgogbXNnc3RyICIiCi0iUydoYSBvYnRpbmd1dCBlbiBlbCBjYW3DrSBkZSBzdWJtw7JkdWwgJyRkaXNwbGF5cGF0aCcsIHBlcsOyIG5vIGNvbnRlbmlhICRzaGExLiAiCisiUydoYSBvYnRpbmd1dCBlbiBlbCBjYW3DrSBkZSBzdWJtw7JkdWwgwqskZGlzcGxheXBhdGjCuywgcGVyw7Igbm8gY29udGVuaWEgJHNoYTEuICIKICJMJ29idGVuY2nDsyBkaXJlY3RhIGQnYXF1ZWxsYSBjb21pc3Npw7MgaGEgZmFsbGF0LiIKIAogIzogZ2l0LXN1Ym1vZHVsZS5zaDo2MTkKICMsIHNoLWZvcm1hdAogbXNnaWQgIlVuYWJsZSB0byBjaGVja291dCAnJHNoYTEnIGluIHN1Ym1vZHVsZSBwYXRoICckZGlzcGxheXBhdGgnIgotbXNnc3RyICJObyBzJ2hhIHBvZ3V0IGFnYWZhciAnJHNoYTEnIGVuIGVsIGNhbcOtIGRlIHN1Ym3DsmR1bCAnJGRpc3BsYXlwYXRoJyIKK21zZ3N0ciAiTm8gcydoYSBwb2d1dCBhZ2FmYXIgwqskc2hhMcK7IGVuIGVsIGNhbcOtIGRlIHN1Ym3DsmR1bCDCqyRkaXNwbGF5cGF0aMK7IgogCiAjOiBnaXQtc3VibW9kdWxlLnNoOjYyMAogIywgc2gtZm9ybWF0CiBtc2dpZCAiU3VibW9kdWxlIHBhdGggJyRkaXNwbGF5cGF0aCc6IGNoZWNrZWQgb3V0ICckc2hhMSciCi1tc2dzdHIgIkNhbcOtIGRlIHN1Ym3DsmR1bCAnJGRpc3BsYXlwYXRoJzogcydoYSBhZ2FmYXQgJyRzaGExJyIKK21zZ3N0ciAiQ2Ftw60gZGUgc3VibcOyZHVsIMKrJGRpc3BsYXlwYXRowrs6IHMnaGEgYWdhZmF0IMKrJHNoYTHCuyIKIAogIzogZ2l0LXN1Ym1vZHVsZS5zaDo2MjQKICMsIHNoLWZvcm1hdAogbXNnaWQgIlVuYWJsZSB0byByZWJhc2UgJyRzaGExJyBpbiBzdWJtb2R1bGUgcGF0aCAnJGRpc3BsYXlwYXRoJyIKIG1zZ3N0ciAiIgotIk5vIHMnaGEgcG9ndXQgZmVyIMKrcmViYXNlwrsgJyRzaGExJyBlbiBlbCBjYW3DrSBkZSBzdWJtw7JkdWwgJyRkaXNwbGF5cGF0aCciCisiTm8gcydoYSBwb2d1dCBmZXIgwqtyZWJhc2XCuyDCqyRzaGExwrsnIGVuIGVsIGNhbcOtIGRlIHN1Ym3DsmR1bCDCqyRkaXNwbGF5cGF0aMK7IgogCiAjOiBnaXQtc3VibW9kdWxlLnNoOjYyNQogIywgc2gtZm9ybWF0CiBtc2dpZCAiU3VibW9kdWxlIHBhdGggJyRkaXNwbGF5cGF0aCc6IHJlYmFzZWQgaW50byAnJHNoYTEnIgotbXNnc3RyICJDYW3DrSBkZSBzdWJtw7JkdWwgJyRkaXNwbGF5cGF0aCc6IHMnaGEgZmV0IMKrcmViYXNlwrsgZW4gJyRzaGExJyIKK21zZ3N0ciAiQ2Ftw60gZGUgc3VibcOyZHVsIMKrJGRpc3BsYXlwYXRowrs6IHMnaGEgZmV0IMKrcmViYXNlwrsgZW4gwqskc2hhMcK7IgogCiAjOiBnaXQtc3VibW9kdWxlLnNoOjYzMAogIywgc2gtZm9ybWF0CiBtc2dpZCAiVW5hYmxlIHRvIG1lcmdlICckc2hhMScgaW4gc3VibW9kdWxlIHBhdGggJyRkaXNwbGF5cGF0aCciCi1tc2dzdHIgIk5vIHMnaGEgcG9ndXQgZnVzaW9uYXIgJyRzaGExJyBlbiBlbCBjYW3DrSBkZSBzdWJtw7JkdWwgJyRkaXNwbGF5cGF0aCciCittc2dzdHIgIk5vIHMnaGEgcG9ndXQgZnVzaW9uYXIgwqskc2hhMcK7IGVuIGVsIGNhbcOtIGRlIHN1Ym3DsmR1bCDCqyRkaXNwbGF5cGF0aMK7IgogCiAjOiBnaXQtc3VibW9kdWxlLnNoOjYzMQogIywgc2gtZm9ybWF0CiBtc2dpZCAiU3VibW9kdWxlIHBhdGggJyRkaXNwbGF5cGF0aCc6IG1lcmdlZCBpbiAnJHNoYTEnIgotbXNnc3RyICJDYW3DrSBkZSBzdWJtw7JkdWwgJyRkaXNwbGF5cGF0aCc6IHMnaGEgZnVzaW9uYXQgZW4gJyRzaGExJyIKK21zZ3N0ciAiQ2Ftw60gZGUgc3VibcOyZHVsIMKrJGRpc3BsYXlwYXRowrs6IHMnaGEgZnVzaW9uYXQgZW4gwqskc2hhMcK7IgogCiAjOiBnaXQtc3VibW9kdWxlLnNoOjYzNgogIywgc2gtZm9ybWF0CiBtc2dpZCAiRXhlY3V0aW9uIG9mICckY29tbWFuZCAkc2hhMScgZmFpbGVkIGluIHN1Ym1vZHVsZSBwYXRoICckZGlzcGxheXBhdGgnIgogbXNnc3RyICIiCi0iTCdleGVjdWNpw7MgZGUgJyRjb21tYW5kICRzaGExJyBoYSBmYWxsYXQgZW4gZWwgY2Ftw60gZGUgc3VibcOyZHVsICIKLSInJGRpc3BsYXlwYXRoJyIKKyJMJ2V4ZWN1Y2nDsyBkZSDCqyRjb21tYW5kICRzaGExwrsgaGEgZmFsbGF0IGVuIGVsIGNhbcOtIGRlIHN1Ym3DsmR1bCAiCisiwqskZGlzcGxheXBhdGjCuyIKIAogIzogZ2l0LXN1Ym1vZHVsZS5zaDo2MzcKICMsIHNoLWZvcm1hdAogbXNnaWQgIlN1Ym1vZHVsZSBwYXRoICckZGlzcGxheXBhdGgnOiAnJGNvbW1hbmQgJHNoYTEnIgotbXNnc3RyICJDYW3DrSBkZSBzdWJtw7JkdWwgJyRkaXNwbGF5cGF0aCc6ICckY29tbWFuZCAkc2hhMSciCittc2dzdHIgIkNhbcOtIGRlIHN1Ym3DsmR1bCDCqyRkaXNwbGF5cGF0aMK7OiDCqyRjb21tYW5kICRzaGExwrsiCiAKICM6IGdpdC1zdWJtb2R1bGUuc2g6NjY4CiAjLCBzaC1mb3JtYXQKIG1zZ2lkICJGYWlsZWQgdG8gcmVjdXJzZSBpbnRvIHN1Ym1vZHVsZSBwYXRoICckZGlzcGxheXBhdGgnIgogbXNnc3RyICIiCiAiUydoYSBwcm9kdcOvdCB1biBlcnJvciBlbiByZWNvcnJlIHJlY3Vyc2l2YW1lbnQgZGlucyBkZWwgY2Ftw60gZGUgc3VibcOyZHVsICIKLSInJGRpc3BsYXlwYXRoJyIKKyLCqyRkaXNwbGF5cGF0aMK7IgogCiAjOiBnaXQtc3VibW9kdWxlLnNoOjgzMAogbXNnaWQgIlRoZSAtLWNhY2hlZCBvcHRpb24gY2Fubm90IGJlIHVzZWQgd2l0aCB0aGUgLS1maWxlcyBvcHRpb24iCkBAIC0yMjQyMSw3ICsyMjQyMSw3IEBACiBtc2dzdHIgIlMnaGEgYXBsaWNhdCBlbCBtYWdhdHplbSBhdXRvbcOgdGljLiIKIAogIzogZ2l0LXJlYmFzZS0tcHJlc2VydmUtbWVyZ2VzLnNoOjExMgotIywgZnV6enksIHNoLWZvcm1hdAorIywgc2gtZm9ybWF0CiBtc2dpZCAiQ2Fubm90IHN0b3JlICRzdGFzaF9zaGExIgogbXNnc3RyICJObyBlcyBwb3QgZW1tYWdhdHplbWFyICRzdGFzaF9zaGExIgogCkBAIC0yMjcxOSw4ICsyMjcxOSw4IEBACiAjLCBzaC1mb3JtYXQKIG1zZ2lkICJSZWJhc2UgJHNob3J0cmV2aXNpb25zIG9udG8gJHNob3J0b250byAoJHRvZG9jb3VudCBjb21tYW5kKSIKIG1zZ2lkX3BsdXJhbCAiUmViYXNlICRzaG9ydHJldmlzaW9ucyBvbnRvICRzaG9ydG9udG8gKCR0b2RvY291bnQgY29tbWFuZHMpIgotbXNnc3RyWzBdICJSZWJhc2EgJHNob3J0cmV2aXNpb25zIHNvYnJlICRzaG9ydG9udG8gKCR0b2RvY291bnQgb3JkcmUpIgotbXNnc3RyWzFdICJSZWJhc2EgJHNob3J0cmV2aXNpb25zIHNvYnJlICRzaG9ydG9udG8gKCR0b2RvY291bnQgb3JkcmVzKSIKK21zZ3N0clswXSAiRmVzIMKrcmViYXNlwrsgJHNob3J0cmV2aXNpb25zIHNvYnJlICRzaG9ydG9udG8gKCR0b2RvY291bnQgb3JkcmUpIgorbXNnc3RyWzFdICJGZXMgwqtyZWJhc2XCuyAkc2hvcnRyZXZpc2lvbnMgc29icmUgJHNob3J0b250byAoJHRvZG9jb3VudCBvcmRyZXMpIgogCiAjOiBnaXQtcmViYXNlLS1wcmVzZXJ2ZS1tZXJnZXMuc2g6OTk3IGdpdC1yZWJhc2UtLXByZXNlcnZlLW1lcmdlcy5zaDoxMDAyCiBtc2dpZCAiQ291bGQgbm90IGluaXQgcmV3cml0dGVuIGNvbW1pdHMiCmRpZmYgLS1naXQgYS9wby9kZS5wbyBiL3BvL2RlLnBvCmluZGV4IDZkODBjZmIuLjA2NjMyNmEgMTAwNjQ0Ci0tLSBhL3BvL2RlLnBvCisrKyBiL3BvL2RlLnBvCkBAIC04LDcgKzgsNyBAQAogbXNnc3RyICIiCiAiUHJvamVjdC1JZC1WZXJzaW9uOiBHaXRcbiIKICJSZXBvcnQtTXNnaWQtQnVncy1UbzogR2l0IE1haWxpbmcgTGlzdCA8Z2l0QHZnZXIua2VybmVsLm9yZz5cbiIKLSJQT1QtQ3JlYXRpb24tRGF0ZTogMjAxOS0wOC0xMCAyMDoxMiswODAwXG4iCisiUE9ULUNyZWF0aW9uLURhdGU6IDIwMTktMTAtMjggMTM6MTkrMDgwMFxuIgogIlBPLVJldmlzaW9uLURhdGU6IDIwMTYtMTEtMjggMTg6MTArMDEwMFxuIgogIkxhc3QtVHJhbnNsYXRvcjogTWF0dGhpYXMgUsO8c3RlciA8bWF0dGhpYXMucnVlc3RlckBnbWFpbC5jb20+XG4iCiAiTGFuZ3VhZ2UtVGVhbTogTWF0dGhpYXMgUsO8c3RlciA8bWF0dGhpYXMucnVlc3RlckBnbWFpbC5jb20+XG4iCkBAIC02Nyw3ICs2Nyw3IEBACiBtc2dpZCAiRXhpdGluZyBiZWNhdXNlIG9mIGFuIHVucmVzb2x2ZWQgY29uZmxpY3QuIgogbXNnc3RyICJCZWVuZGUgd2VnZW4gdW5hdWZnZWzDtnN0ZW0gS29uZmxpa3QuIgogCi0jOiBhZHZpY2UuYzoxOTMgYnVpbHRpbi9tZXJnZS5jOjEzMjcKKyM6IGFkdmljZS5jOjE5MyBidWlsdGluL21lcmdlLmM6MTMzMgogbXNnaWQgIllvdSBoYXZlIG5vdCBjb25jbHVkZWQgeW91ciBtZXJnZSAoTUVSR0VfSEVBRCBleGlzdHMpLiIKIG1zZ3N0ciAiU2llIGhhYmVuIElocmVuIE1lcmdlIG5pY2h0IGFiZ2VzY2hsb3NzZW4gKE1FUkdFX0hFQUQgZXhpc3RpZXJ0KS4iCiAKQEAgLTIxMiwxNyArMjEyLDcgQEAKIG1zZ2lkICJpbmNvbnNpc3RlbnQgaGVhZGVyIGxpbmVzICVkIGFuZCAlZCIKIG1zZ3N0ciAiSW5rb25zaXN0ZW50ZSBLb3BmemVpbGVuICVkIHVuZCAlZC4iCiAKLSM6IGFwcGx5LmM6MTQ2MAotIywgYy1mb3JtYXQKLW1zZ2lkICJyZWNvdW50OiB1bmV4cGVjdGVkIGxpbmU6ICUuKnMiCi1tc2dzdHIgInJlY291bnQ6IHVuZXJ3YXJ0ZXRlIFplaWxlOiAlLipzIgotCi0jOiBhcHBseS5jOjE1MjkKLSMsIGMtZm9ybWF0Ci1tc2dpZCAicGF0Y2ggZnJhZ21lbnQgd2l0aG91dCBoZWFkZXIgYXQgbGluZSAlZDogJS4qcyIKLW1zZ3N0ciAiUGF0Y2gtRnJhZ21lbnQgb2huZSBLb3BmYmVyZWljaCBiZWkgWmVpbGUgJWQ6ICUuKnMiCi0KLSM6IGFwcGx5LmM6MTU1MQorIzogYXBwbHkuYzoxMzcyCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJnaXQgZGlmZiBoZWFkZXIgbGFja3MgZmlsZW5hbWUgaW5mb3JtYXRpb24gd2hlbiByZW1vdmluZyAlZCBsZWFkaW5nIHBhdGhuYW1lICIKQEAgLTIzNyw3MiArMjI3LDgyIEBACiAiRGVtIEtvcGZiZXJlaWNoIHZvbiBcImdpdCBkaWZmXCIgZmVobGVuIEluZm9ybWF0aW9uZW4genVtIERhdGVpbmFtZW4sIHdlbm4gIgogIiVkIHZvcmFuZ2VzdGVsbHRlIFRlaWxlIGRlcyBQZmFkZXMgZW50ZmVybnQgd2VyZGVuIChaZWlsZSAlZCkiCiAKLSM6IGFwcGx5LmM6MTU2NAorIzogYXBwbHkuYzoxMzg1CiAjLCBjLWZvcm1hdAogbXNnaWQgImdpdCBkaWZmIGhlYWRlciBsYWNrcyBmaWxlbmFtZSBpbmZvcm1hdGlvbiAobGluZSAlZCkiCiBtc2dzdHIgIiIKICJEZW0gS29wZmJlcmVpY2ggdm9uIFwiZ2l0IGRpZmZcIiBmZWhsZW4gSW5mb3JtYXRpb25lbiB6dW0gRGF0ZWluYW1lbiAoWmVpbGUgIgogIiVkKSIKIAotIzogYXBwbHkuYzoxNzUyCisjOiBhcHBseS5jOjE0ODEKKyMsIGMtZm9ybWF0Cittc2dpZCAicmVjb3VudDogdW5leHBlY3RlZCBsaW5lOiAlLipzIgorbXNnc3RyICJyZWNvdW50OiB1bmVyd2FydGV0ZSBaZWlsZTogJS4qcyIKKworIzogYXBwbHkuYzoxNTUwCisjLCBjLWZvcm1hdAorbXNnaWQgInBhdGNoIGZyYWdtZW50IHdpdGhvdXQgaGVhZGVyIGF0IGxpbmUgJWQ6ICUuKnMiCittc2dzdHIgIlBhdGNoLUZyYWdtZW50IG9obmUgS29wZmJlcmVpY2ggYmVpIFplaWxlICVkOiAlLipzIgorCisjOiBhcHBseS5jOjE3NTMKIG1zZ2lkICJuZXcgZmlsZSBkZXBlbmRzIG9uIG9sZCBjb250ZW50cyIKIG1zZ3N0ciAibmV1ZSBEYXRlaSBow6RuZ3Qgdm9uIGFsdGVuIEluaGFsdGVuIGFiIgogCi0jOiBhcHBseS5jOjE3NTQKKyM6IGFwcGx5LmM6MTc1NQogbXNnaWQgImRlbGV0ZWQgZmlsZSBzdGlsbCBoYXMgY29udGVudHMiCiBtc2dzdHIgImVudGZlcm50ZSBEYXRlaSBoYXQgbm9jaCBJbmhhbHRlIgogCi0jOiBhcHBseS5jOjE3ODgKKyM6IGFwcGx5LmM6MTc4OQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3JydXB0IHBhdGNoIGF0IGxpbmUgJWQiCiBtc2dzdHIgImZlaGxlcmhhZnRlciBQYXRjaCBiZWkgWmVpbGUgJWQiCiAKLSM6IGFwcGx5LmM6MTgyNQorIzogYXBwbHkuYzoxODI2CiAjLCBjLWZvcm1hdAogbXNnaWQgIm5ldyBmaWxlICVzIGRlcGVuZHMgb24gb2xkIGNvbnRlbnRzIgogbXNnc3RyICJuZXVlIERhdGVpICVzIGjDpG5ndCB2b24gYWx0ZW4gSW5oYWx0ZW4gYWIiCiAKLSM6IGFwcGx5LmM6MTgyNworIzogYXBwbHkuYzoxODI4CiAjLCBjLWZvcm1hdAogbXNnaWQgImRlbGV0ZWQgZmlsZSAlcyBzdGlsbCBoYXMgY29udGVudHMiCiBtc2dzdHIgImVudGZlcm50ZSBEYXRlaSAlcyBoYXQgbm9jaCBJbmhhbHRlIgogCi0jOiBhcHBseS5jOjE4MzAKKyM6IGFwcGx5LmM6MTgzMQogIywgYy1mb3JtYXQKIG1zZ2lkICIqKiB3YXJuaW5nOiBmaWxlICVzIGJlY29tZXMgZW1wdHkgYnV0IGlzIG5vdCBkZWxldGVkIgogbXNnc3RyICIqKiBXYXJudW5nOiBEYXRlaSAlcyB3aXJkIGxlZXIsIGFiZXIgbmljaHQgZW50ZmVybnQuIgogCi0jOiBhcHBseS5jOjE5NzcKKyM6IGFwcGx5LmM6MTk3OAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3JydXB0IGJpbmFyeSBwYXRjaCBhdCBsaW5lICVkOiAlLipzIgogbXNnc3RyICJmZWhsZXJoYWZ0ZXIgQmluw6RyLVBhdGNoIGJlaSBaZWlsZSAlZDogJS4qcyIKIAotIzogYXBwbHkuYzoyMDE0CisjOiBhcHBseS5jOjIwMTUKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5yZWNvZ25pemVkIGJpbmFyeSBwYXRjaCBhdCBsaW5lICVkIgogbXNnc3RyICJuaWNodCBlcmthbm50ZXIgQmluw6RyLVBhdGNoIGJlaSBaZWlsZSAlZCIKIAotIzogYXBwbHkuYzoyMTc2CisjOiBhcHBseS5jOjIxNzcKICMsIGMtZm9ybWF0CiBtc2dpZCAicGF0Y2ggd2l0aCBvbmx5IGdhcmJhZ2UgYXQgbGluZSAlZCIKIG1zZ3N0ciAiUGF0Y2ggbWl0IG51dHpsb3NlbiBJbmZvcm1hdGlvbmVuIGJlaSBaZWlsZSAlZCIKIAotIzogYXBwbHkuYzoyMjYyCisjOiBhcHBseS5jOjIyNjMKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHJlYWQgc3ltbGluayAlcyIKIG1zZ3N0ciAia29ubnRlIHN5bWJvbGlzY2hlIFZlcmtuw7xwZnVuZyAlcyBuaWNodCBsZXNlbiIKIAotIzogYXBwbHkuYzoyMjY2CisjOiBhcHBseS5jOjIyNjcKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIG9wZW4gb3IgcmVhZCAlcyIKIG1zZ3N0ciAia29ubnRlICVzIG5pY2h0IMO2ZmZuZW4gb2RlciBsZXNlbiIKIAotIzogYXBwbHkuYzoyOTI1CisjOiBhcHBseS5jOjI5MjYKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBzdGFydCBvZiBsaW5lOiAnJWMnIgogbXNnc3RyICJVbmfDvGx0aWdlciBaZWlsZW5hbmZhbmc6ICclYyciCiAKLSM6IGFwcGx5LmM6MzA0NgorIzogYXBwbHkuYzozMDQ3CiAjLCBjLWZvcm1hdAogbXNnaWQgIkh1bmsgIyVkIHN1Y2NlZWRlZCBhdCAlZCAob2Zmc2V0ICVkIGxpbmUpLiIKIG1zZ2lkX3BsdXJhbCAiSHVuayAjJWQgc3VjY2VlZGVkIGF0ICVkIChvZmZzZXQgJWQgbGluZXMpLiIKQEAgLTMxMCwxMiArMzEwLDEyIEBACiBtc2dzdHJbMV0gIiIKICJQYXRjaC1CZXJlaWNoICMlZCBlcmZvbGdyZWljaCBhbmdld2VuZGV0IGJlaSAlZCAoJWQgWmVpbGVuIHZlcnNldHp0KSIKIAotIzogYXBwbHkuYzozMDU4CisjOiBhcHBseS5jOjMwNTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ29udGV4dCByZWR1Y2VkIHRvICglbGQvJWxkKSB0byBhcHBseSBmcmFnbWVudCBhdCAlZCIKIG1zZ3N0ciAiS29udGV4dCByZWR1emllcnQgenUgKCVsZC8lbGQpLCB1bSBQYXRjaC1CZXJlaWNoIGJlaSAlZCBhbnp1d2VuZGVuIgogCi0jOiBhcHBseS5jOjMwNjQKKyM6IGFwcGx5LmM6MzA2NQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAid2hpbGUgc2VhcmNoaW5nIGZvcjpcbiIKQEAgLTMyNCwyNSArMzI0LDI1IEBACiAiYmVpIGRlciBTdWNoZSBuYWNoOlxuIgogIiUuKnMiCiAKLSM6IGFwcGx5LmM6MzA4NgorIzogYXBwbHkuYzozMDg3CiAjLCBjLWZvcm1hdAogbXNnaWQgIm1pc3NpbmcgYmluYXJ5IHBhdGNoIGRhdGEgZm9yICclcyciCiBtc2dzdHIgImtlaW5lIERhdGVuIGluIEJpbsOkci1QYXRjaCBmw7xyICclcyciCiAKLSM6IGFwcGx5LmM6MzA5NAorIzogYXBwbHkuYzozMDk1CiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCByZXZlcnNlLWFwcGx5IGEgYmluYXJ5IHBhdGNoIHdpdGhvdXQgdGhlIHJldmVyc2UgaHVuayB0byAnJXMnIgogbXNnc3RyICIiCiAia2FubiBiaW7DpHJlbiBQYXRjaCBuaWNodCBpbiB1bWdla2VocnRlciBSZWloZW5mb2xnZSBhbndlbmRlbiBvaG5lIGVpbmVuXG4iCiAidW1nZWtlaHJ0ZW4gUGF0Y2gtQmxvY2sgYXVmICclcyciCiAKLSM6IGFwcGx5LmM6MzE0MQorIzogYXBwbHkuYzozMTQyCiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCBhcHBseSBiaW5hcnkgcGF0Y2ggdG8gJyVzJyB3aXRob3V0IGZ1bGwgaW5kZXggbGluZSIKIG1zZ3N0ciAiIgogImthbm4gYmluw6RyZW4gUGF0Y2ggYXVmICclcycgbmljaHQgb2huZSBlaW5lIHZvbGxzdMOkbmRpZ2UgSW5kZXgtWmVpbGUgYW53ZW5kZW4iCiAKLSM6IGFwcGx5LmM6MzE1MQorIzogYXBwbHkuYzozMTUyCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJ0aGUgcGF0Y2ggYXBwbGllcyB0byAnJXMnICglcyksIHdoaWNoIGRvZXMgbm90IG1hdGNoIHRoZSBjdXJyZW50IGNvbnRlbnRzLiIKQEAgLTM1MCw0NDEgKzM1MCw0NDEgQEAKICJkZXIgUGF0Y2ggd2lyZCBhbmdld2VuZGV0IGF1ZiAnJXMnICglcyksIHdhcyBuaWNodCBkZW4gYWt0dWVsbGVuIEluaGFsdGVuXG4iCiAiZW50c3ByaWNodCIKIAotIzogYXBwbHkuYzozMTU5CisjOiBhcHBseS5jOjMxNjAKICMsIGMtZm9ybWF0CiBtc2dpZCAidGhlIHBhdGNoIGFwcGxpZXMgdG8gYW4gZW1wdHkgJyVzJyBidXQgaXQgaXMgbm90IGVtcHR5IgogbXNnc3RyICJkZXIgUGF0Y2ggd2lyZCBhdWYgZWluIGxlZXJlcyAnJXMnIGFuZ2V3ZW5kZXQsIHdhcyBhYmVyIG5pY2h0IGxlZXIgaXN0IgogCi0jOiBhcHBseS5jOjMxNzcKKyM6IGFwcGx5LmM6MzE3OAogIywgYy1mb3JtYXQKIG1zZ2lkICJ0aGUgbmVjZXNzYXJ5IHBvc3RpbWFnZSAlcyBmb3IgJyVzJyBjYW5ub3QgYmUgcmVhZCIKIG1zZ3N0ciAiZGFzIGVyZm9yZGVybGljaGUgUG9zdGltYWdlICVzIGbDvHIgJyVzJyBrYW5uIG5pY2h0IGdlbGVzZW4gd2VyZGVuIgogCi0jOiBhcHBseS5jOjMxOTAKKyM6IGFwcGx5LmM6MzE5MQogIywgYy1mb3JtYXQKIG1zZ2lkICJiaW5hcnkgcGF0Y2ggZG9lcyBub3QgYXBwbHkgdG8gJyVzJyIKIG1zZ3N0ciAiS29ubnRlIEJpbsOkci1QYXRjaCBuaWNodCBhdWYgJyVzJyBhbndlbmRlbiIKIAotIzogYXBwbHkuYzozMTk2CisjOiBhcHBseS5jOjMxOTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiYmluYXJ5IHBhdGNoIHRvICclcycgY3JlYXRlcyBpbmNvcnJlY3QgcmVzdWx0IChleHBlY3RpbmcgJXMsIGdvdCAlcykiCiBtc2dzdHIgIiIKICJCaW7DpHItUGF0Y2ggZsO8ciAnJXMnIGVyemV1Z3QgZmFsc2NoZXMgRXJnZWJuaXMgKGVyd2FydGV0ZSAlcywgYmVrYW0gJXMpIgogCi0jOiBhcHBseS5jOjMyMTcKKyM6IGFwcGx5LmM6MzIxOAogIywgYy1mb3JtYXQKIG1zZ2lkICJwYXRjaCBmYWlsZWQ6ICVzOiVsZCIKIG1zZ3N0ciAiQW53ZW5kdW5nIGRlcyBQYXRjaGVzIGZlaGxnZXNjaGxhZ2VuOiAlczolbGQiCiAKLSM6IGFwcGx5LmM6MzM0MAorIzogYXBwbHkuYzozMzQxCiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCBjaGVja291dCAlcyIKIG1zZ3N0ciAia2FubiAlcyBuaWNodCBhdXNjaGVja2VuIgogCi0jOiBhcHBseS5jOjMzOTIgYXBwbHkuYzozNDAzIGFwcGx5LmM6MzQ0OSBtaWR4LmM6NjIgc2V0dXAuYzoyNzkKKyM6IGFwcGx5LmM6MzM5MyBhcHBseS5jOjM0MDQgYXBwbHkuYzozNDUwIG1pZHguYzo2MSBzZXR1cC5jOjI4MAogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gcmVhZCAlcyIKIG1zZ3N0ciAiRmVobGVyIGJlaW0gTGVzZW4gdm9uICVzIgogCi0jOiBhcHBseS5jOjM0MDAKKyM6IGFwcGx5LmM6MzQwMQogIywgYy1mb3JtYXQKIG1zZ2lkICJyZWFkaW5nIGZyb20gJyVzJyBiZXlvbmQgYSBzeW1ib2xpYyBsaW5rIgogbXNnc3RyICInJXMnIGlzdCBoaW50ZXIgZWluZXIgc3ltYm9saXNjaGVuIFZlcmtuw7xwZnVuZyIKIAotIzogYXBwbHkuYzozNDI5IGFwcGx5LmM6MzY3MgorIzogYXBwbHkuYzozNDMwIGFwcGx5LmM6MzY3MwogIywgYy1mb3JtYXQKIG1zZ2lkICJwYXRoICVzIGhhcyBiZWVuIHJlbmFtZWQvZGVsZXRlZCIKIG1zZ3N0ciAiUGZhZCAlcyB3dXJkZSB1bWJlbmFubnQvZ2Vsw7ZzY2h0IgogCi0jOiBhcHBseS5jOjM1MTUgYXBwbHkuYzozNjg3CisjOiBhcHBseS5jOjM1MTYgYXBwbHkuYzozNjg4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiBkb2VzIG5vdCBleGlzdCBpbiBpbmRleCIKIG1zZ3N0ciAiJXMgaXN0IG5pY2h0IGltIEluZGV4IgogCi0jOiBhcHBseS5jOjM1MjQgYXBwbHkuYzozNjk1CisjOiBhcHBseS5jOjM1MjUgYXBwbHkuYzozNjk2CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiBkb2VzIG5vdCBtYXRjaCBpbmRleCIKIG1zZ3N0ciAiJXMgZW50c3ByaWNodCBuaWNodCBkZXIgVmVyc2lvbiBpbSBJbmRleCIKIAotIzogYXBwbHkuYzozNTU5CisjOiBhcHBseS5jOjM1NjAKIG1zZ2lkICJyZXBvc2l0b3J5IGxhY2tzIHRoZSBuZWNlc3NhcnkgYmxvYiB0byBmYWxsIGJhY2sgb24gMy13YXkgbWVyZ2UuIgogbXNnc3RyICIiCiAiRGVtIFJlcG9zaXRvcnkgZmVobHQgZGVyIG5vdHdlbmRpZ2UgQmxvYiwgdW0gYXVmIGVpbmVuIDMtV2VnZS1NZXJnZVxuIgogInp1csO8Y2t6dWZhbGxlbi4iCiAKLSM6IGFwcGx5LmM6MzU2MgorIzogYXBwbHkuYzozNTYzCiAjLCBjLWZvcm1hdAogbXNnaWQgIkZhbGxpbmcgYmFjayB0byB0aHJlZS13YXkgbWVyZ2UuLi5cbiIKIG1zZ3N0ciAiRmFsbGUgenVyw7xjayBhdWYgMy1XZWdlLU1lcmdlIC4uLlxuIgogCi0jOiBhcHBseS5jOjM1NzggYXBwbHkuYzozNTgyCisjOiBhcHBseS5jOjM1NzkgYXBwbHkuYzozNTgzCiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCByZWFkIHRoZSBjdXJyZW50IGNvbnRlbnRzIG9mICclcyciCiBtc2dzdHIgImthbm4gYWt0dWVsbGUgSW5oYWx0ZSB2b24gJyVzJyBuaWNodCBsZXNlbiIKIAotIzogYXBwbHkuYzozNTk0CisjOiBhcHBseS5jOjM1OTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiRmFpbGVkIHRvIGZhbGwgYmFjayBvbiB0aHJlZS13YXkgbWVyZ2UuLi5cbiIKIG1zZ3N0ciAiRmVobGVyIGJlaW0gWnVyw7xja2ZhbGxlbiBhdWYgMy1XZWdlLU1lcmdlLi4uXG4iCiAKLSM6IGFwcGx5LmM6MzYwOAorIzogYXBwbHkuYzozNjA5CiAjLCBjLWZvcm1hdAogbXNnaWQgIkFwcGxpZWQgcGF0Y2ggdG8gJyVzJyB3aXRoIGNvbmZsaWN0cy5cbiIKIG1zZ3N0ciAiUGF0Y2ggYXVmICclcycgbWl0IEtvbmZsaWt0ZW4gYW5nZXdlbmRldC5cbiIKIAotIzogYXBwbHkuYzozNjEzCisjOiBhcHBseS5jOjM2MTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiQXBwbGllZCBwYXRjaCB0byAnJXMnIGNsZWFubHkuXG4iCiBtc2dzdHIgIlBhdGNoIGF1ZiAnJXMnIHNhdWJlciBhbmdld2VuZGV0LlxuIgogCi0jOiBhcHBseS5jOjM2MzkKKyM6IGFwcGx5LmM6MzY0MAogbXNnaWQgInJlbW92YWwgcGF0Y2ggbGVhdmVzIGZpbGUgY29udGVudHMiCiBtc2dzdHIgIkzDtnNjaC1QYXRjaCBoaW50ZXJsw6Rzc3QgRGF0ZWlpbmhhbHRlIgogCi0jOiBhcHBseS5jOjM3MTIKKyM6IGFwcGx5LmM6MzcxMwogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogd3JvbmcgdHlwZSIKIG1zZ3N0ciAiJXM6IGZhbHNjaGVyIFR5cCIKIAotIzogYXBwbHkuYzozNzE0CisjOiBhcHBseS5jOjM3MTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgaGFzIHR5cGUgJW8sIGV4cGVjdGVkICVvIgogbXNnc3RyICIlcyBpc3Qgdm9tIFR5cCAlbywgZXJ3YXJ0ZXRlICVvIgogCi0jOiBhcHBseS5jOjM4NjUgYXBwbHkuYzozODY3IHJlYWQtY2FjaGUuYzo4MzAgcmVhZC1jYWNoZS5jOjg1NgorIzogYXBwbHkuYzozODY2IGFwcGx5LmM6Mzg2OCByZWFkLWNhY2hlLmM6ODMwIHJlYWQtY2FjaGUuYzo4NTYKICM6IHJlYWQtY2FjaGUuYzoxMzA5CiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgcGF0aCAnJXMnIgogbXNnc3RyICJVbmfDvGx0aWdlciBQZmFkICclcyciCiAKLSM6IGFwcGx5LmM6MzkyMworIzogYXBwbHkuYzozOTI0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiBhbHJlYWR5IGV4aXN0cyBpbiBpbmRleCIKIG1zZ3N0ciAiJXMgaXN0IGJlcmVpdHMgYmVyZWl0Z2VzdGVsbHQiCiAKLSM6IGFwcGx5LmM6MzkyNgorIzogYXBwbHkuYzozOTI3CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiBhbHJlYWR5IGV4aXN0cyBpbiB3b3JraW5nIGRpcmVjdG9yeSIKIG1zZ3N0ciAiJXMgZXhpc3RpZXJ0IGJlcmVpdHMgaW0gQXJiZWl0c3ZlcnplaWNobmlzIgogCi0jOiBhcHBseS5jOjM5NDYKKyM6IGFwcGx5LmM6Mzk0NwogIywgYy1mb3JtYXQKIG1zZ2lkICJuZXcgbW9kZSAoJW8pIG9mICVzIGRvZXMgbm90IG1hdGNoIG9sZCBtb2RlICglbykiCiBtc2dzdHIgIm5ldWVyIE1vZHVzICglbykgdm9uICVzIGVudHNwcmljaHQgbmljaHQgZGVtIGFsdGVuIE1vZHVzICglbykiCiAKLSM6IGFwcGx5LmM6Mzk1MQorIzogYXBwbHkuYzozOTUyCiAjLCBjLWZvcm1hdAogbXNnaWQgIm5ldyBtb2RlICglbykgb2YgJXMgZG9lcyBub3QgbWF0Y2ggb2xkIG1vZGUgKCVvKSBvZiAlcyIKIG1zZ3N0ciAibmV1ZXIgTW9kdXMgKCVvKSB2b24gJXMgZW50c3ByaWNodCBuaWNodCBkZW0gYWx0ZW4gTW9kdXMgKCVvKSB2b24gJXMiCiAKLSM6IGFwcGx5LmM6Mzk3MQorIzogYXBwbHkuYzozOTcyCiAjLCBjLWZvcm1hdAogbXNnaWQgImFmZmVjdGVkIGZpbGUgJyVzJyBpcyBiZXlvbmQgYSBzeW1ib2xpYyBsaW5rIgogbXNnc3RyICJiZXRyb2ZmZW5lIERhdGVpICclcycgaXN0IGhpbnRlciBlaW5lciBzeW1ib2xpc2NoZW4gVmVya27DvHBmdW5nIgogCi0jOiBhcHBseS5jOjM5NzUKKyM6IGFwcGx5LmM6Mzk3NgogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogcGF0Y2ggZG9lcyBub3QgYXBwbHkiCiBtc2dzdHIgIiVzOiBQYXRjaCBrb25udGUgbmljaHQgYW5nZXdlbmRldCB3ZXJkZW4iCiAKLSM6IGFwcGx5LmM6Mzk5MAorIzogYXBwbHkuYzozOTkxCiAjLCBjLWZvcm1hdAogbXNnaWQgIkNoZWNraW5nIHBhdGNoICVzLi4uIgogbXNnc3RyICJQcsO8ZmUgUGF0Y2ggJXMgLi4uIgogCi0jOiBhcHBseS5jOjQwODIKKyM6IGFwcGx5LmM6NDA4MwogIywgYy1mb3JtYXQKIG1zZ2lkICJzaGExIGluZm9ybWF0aW9uIGlzIGxhY2tpbmcgb3IgdXNlbGVzcyBmb3Igc3VibW9kdWxlICVzIgogbXNnc3RyICJTSEEtMSBJbmZvcm1hdGlvbiBmZWhsdCBvZGVyIGlzdCB1bmJyYXVjaGJhciBmw7xyIFN1Ym1vZHVsICVzIgogCi0jOiBhcHBseS5jOjQwODkKKyM6IGFwcGx5LmM6NDA5MAogIywgYy1mb3JtYXQKIG1zZ2lkICJtb2RlIGNoYW5nZSBmb3IgJXMsIHdoaWNoIGlzIG5vdCBpbiBjdXJyZW50IEhFQUQiCiBtc2dzdHIgIk1vZHVzw6RuZGVydW5nIGbDvHIgJXMsIHdhcyBzaWNoIG5pY2h0IGltIGFrdHVlbGxlbiBIRUFEIGJlZmluZGV0IgogCi0jOiBhcHBseS5jOjQwOTIKKyM6IGFwcGx5LmM6NDA5MwogIywgYy1mb3JtYXQKIG1zZ2lkICJzaGExIGluZm9ybWF0aW9uIGlzIGxhY2tpbmcgb3IgdXNlbGVzcyAoJXMpLiIKIG1zZ3N0ciAiU0hBLTEgSW5mb3JtYXRpb24gZmVobHQgb2RlciBpc3QgdW5icmF1Y2hiYXIgKCVzKS4iCiAKLSM6IGFwcGx5LmM6NDA5NyBidWlsdGluL2NoZWNrb3V0LmM6Mjc4IGJ1aWx0aW4vcmVzZXQuYzoxNDMKKyM6IGFwcGx5LmM6NDA5OCBidWlsdGluL2NoZWNrb3V0LmM6Mjc5IGJ1aWx0aW4vcmVzZXQuYzoxNDMKICMsIGMtZm9ybWF0CiBtc2dpZCAibWFrZV9jYWNoZV9lbnRyeSBmYWlsZWQgZm9yIHBhdGggJyVzJyIKIG1zZ3N0ciAibWFrZV9jYWNoZV9lbnRyeSBmw7xyIFBmYWQgJyVzJyBmZWhsZ2VzY2hsYWdlbiIKIAotIzogYXBwbHkuYzo0MTAxCisjOiBhcHBseS5jOjQxMDIKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGFkZCAlcyB0byB0ZW1wb3JhcnkgaW5kZXgiCiBtc2dzdHIgImtvbm50ZSAlcyBuaWNodCB6dW0gdGVtcG9yw6RyZW4gSW5kZXggaGluenVmw7xnZW4iCiAKLSM6IGFwcGx5LmM6NDExMQorIzogYXBwbHkuYzo0MTEyCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCB3cml0ZSB0ZW1wb3JhcnkgaW5kZXggdG8gJXMiCiBtc2dzdHIgImtvbm50ZSB0ZW1wb3LDpHJlbiBJbmRleCBuaWNodCBuYWNoICVzIHNjaHJlaWJlbiIKIAotIzogYXBwbHkuYzo0MjQ5CisjOiBhcHBseS5jOjQyNTAKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHJlbW92ZSAlcyBmcm9tIGluZGV4IgogbXNnc3RyICJrb25udGUgJXMgbmljaHQgYXVzIGRlbSBJbmRleCBlbnRmZXJuZW4iCiAKLSM6IGFwcGx5LmM6NDI4MworIzogYXBwbHkuYzo0Mjg0CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvcnJ1cHQgcGF0Y2ggZm9yIHN1Ym1vZHVsZSAlcyIKIG1zZ3N0ciAiZmVobGVyaGFmdGVyIFBhdGNoIGbDvHIgU3VibW9kdWwgJXMiCiAKLSM6IGFwcGx5LmM6NDI4OQorIzogYXBwbHkuYzo0MjkwCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBzdGF0IG5ld2x5IGNyZWF0ZWQgZmlsZSAnJXMnIgogbXNnc3RyICJrb25udGUgbmV1IGVyc3RlbGx0ZSBEYXRlaSAnJXMnIG5pY2h0IGxlc2VuIgogCi0jOiBhcHBseS5jOjQyOTcKKyM6IGFwcGx5LmM6NDI5OAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gY3JlYXRlIGJhY2tpbmcgc3RvcmUgZm9yIG5ld2x5IGNyZWF0ZWQgZmlsZSAlcyIKIG1zZ3N0ciAia2FubiBpbnRlcm5lbiBTcGVpY2hlciBmw7xyIGViZW4gZXJzdGVsbHRlIERhdGVpICVzIG5pY2h0IGVyemV1Z2VuIgogCi0jOiBhcHBseS5jOjQzMDMgYXBwbHkuYzo0NDQ4CisjOiBhcHBseS5jOjQzMDQgYXBwbHkuYzo0NDQ5CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBhZGQgY2FjaGUgZW50cnkgZm9yICVzIgogbXNnc3RyICJrYW5uIGbDvHIgJXMga2VpbmVuIEVpbnRyYWcgaW4gZGVuIFp3aXNjaGVuc3BlaWNoZXIgaGluenVmw7xnZW4iCiAKLSM6IGFwcGx5LmM6NDM0NgorIzogYXBwbHkuYzo0MzQ3CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byB3cml0ZSB0byAnJXMnIgogbXNnc3RyICJGZWhsZXIgYmVpbSBTY2hyZWliZW4gbmFjaCAnJXMnIgogCi0jOiBhcHBseS5jOjQzNTAKKyM6IGFwcGx5LmM6NDM1MQogIywgYy1mb3JtYXQKIG1zZ2lkICJjbG9zaW5nIGZpbGUgJyVzJyIKIG1zZ3N0ciAic2NobGllw59lIERhdGVpICclcyciCiAKLSM6IGFwcGx5LmM6NDQyMAorIzogYXBwbHkuYzo0NDIxCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byB3cml0ZSBmaWxlICclcycgbW9kZSAlbyIKIG1zZ3N0ciAia29ubnRlIERhdGVpICclcycgbWl0IE1vZHVzICVvIG5pY2h0IHNjaHJlaWJlbiIKIAotIzogYXBwbHkuYzo0NTE4CisjOiBhcHBseS5jOjQ1MTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiQXBwbGllZCBwYXRjaCAlcyBjbGVhbmx5LiIKIG1zZ3N0ciAiUGF0Y2ggJXMgc2F1YmVyIGFuZ2V3ZW5kZXQiCiAKLSM6IGFwcGx5LmM6NDUyNgorIzogYXBwbHkuYzo0NTI3CiBtc2dpZCAiaW50ZXJuYWwgZXJyb3IiCiBtc2dzdHIgImludGVybmVyIEZlaGxlciIKIAotIzogYXBwbHkuYzo0NTI5CisjOiBhcHBseS5jOjQ1MzAKICMsIGMtZm9ybWF0CiBtc2dpZCAiQXBwbHlpbmcgcGF0Y2ggJSVzIHdpdGggJWQgcmVqZWN0Li4uIgogbXNnaWRfcGx1cmFsICJBcHBseWluZyBwYXRjaCAlJXMgd2l0aCAlZCByZWplY3RzLi4uIgogbXNnc3RyWzBdICJXZW5kZSBQYXRjaCAlJXMgbWl0ICVkIFp1csO8Y2t3ZWlzdW5nIGFuLi4uIgogbXNnc3RyWzFdICJXZW5kZSBQYXRjaCAlJXMgbWl0ICVkIFp1csO8Y2t3ZWlzdW5nZW4gYW4uLi4iCiAKLSM6IGFwcGx5LmM6NDU0MAorIzogYXBwbHkuYzo0NTQxCiAjLCBjLWZvcm1hdAogbXNnaWQgInRydW5jYXRpbmcgLnJlaiBmaWxlbmFtZSB0byAlLipzLnJlaiIKIG1zZ3N0ciAiVmVya8O8cnplIE5hbWUgdm9uIC5yZWogRGF0ZWkgenUgJS4qcy5yZWoiCiAKLSM6IGFwcGx5LmM6NDU0OCBidWlsdGluL2ZldGNoLmM6ODc4IGJ1aWx0aW4vZmV0Y2guYzoxMTY4CisjOiBhcHBseS5jOjQ1NDkgYnVpbHRpbi9mZXRjaC5jOjg5OCBidWlsdGluL2ZldGNoLmM6MTE5NAogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3Qgb3BlbiAlcyIKIG1zZ3N0ciAia2FubiAnJXMnIG5pY2h0IMO2ZmZuZW4iCiAKLSM6IGFwcGx5LmM6NDU2MgorIzogYXBwbHkuYzo0NTYzCiAjLCBjLWZvcm1hdAogbXNnaWQgIkh1bmsgIyVkIGFwcGxpZWQgY2xlYW5seS4iCiBtc2dzdHIgIlBhdGNoLUJlcmVpY2ggIyVkIHNhdWJlciBhbmdld2VuZGV0LiIKIAotIzogYXBwbHkuYzo0NTY2CisjOiBhcHBseS5jOjQ1NjcKICMsIGMtZm9ybWF0CiBtc2dpZCAiUmVqZWN0ZWQgaHVuayAjJWQuIgogbXNnc3RyICJQYXRjaC1CbG9jayAjJWQgenVyw7xja2dld2llc2VuLiIKIAotIzogYXBwbHkuYzo0Njc2CisjOiBhcHBseS5jOjQ2ODYKICMsIGMtZm9ybWF0CiBtc2dpZCAiU2tpcHBlZCBwYXRjaCAnJXMnLiIKIG1zZ3N0ciAiUGF0Y2ggJyVzJyBhdXNnZWxhc3Nlbi4iCiAKLSM6IGFwcGx5LmM6NDY4NAorIzogYXBwbHkuYzo0Njk0CiBtc2dpZCAidW5yZWNvZ25pemVkIGlucHV0IgogbXNnc3RyICJuaWNodCBlcmthbm50ZSBFaW5nYWJlIgogCi0jOiBhcHBseS5jOjQ3MDQKKyM6IGFwcGx5LmM6NDcxNAogbXNnaWQgInVuYWJsZSB0byByZWFkIGluZGV4IGZpbGUiCiBtc2dzdHIgIktvbm50ZSBJbmRleC1EYXRlaSBuaWNodCBsZXNlbiIKIAotIzogYXBwbHkuYzo0ODU5CisjOiBhcHBseS5jOjQ4NzEKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2FuJ3Qgb3BlbiBwYXRjaCAnJXMnOiAlcyIKIG1zZ3N0ciAia2FubiBQYXRjaCAnJXMnIG5pY2h0IMO2ZmZuZW46ICVzIgogCi0jOiBhcHBseS5jOjQ4ODYKKyM6IGFwcGx5LmM6NDg5OAogIywgYy1mb3JtYXQKIG1zZ2lkICJzcXVlbGNoZWQgJWQgd2hpdGVzcGFjZSBlcnJvciIKIG1zZ2lkX3BsdXJhbCAic3F1ZWxjaGVkICVkIHdoaXRlc3BhY2UgZXJyb3JzIgogbXNnc3RyWzBdICJ1bnRlcmRyw7xja3RlICVkIFdoaXRlc3BhY2UtRmVobGVyIgogbXNnc3RyWzFdICJ1bnRlcmRyw7xja3RlICVkIFdoaXRlc3BhY2UtRmVobGVyIgogCi0jOiBhcHBseS5jOjQ4OTIgYXBwbHkuYzo0OTA3CisjOiBhcHBseS5jOjQ5MDQgYXBwbHkuYzo0OTE5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVkIGxpbmUgYWRkcyB3aGl0ZXNwYWNlIGVycm9ycy4iCiBtc2dpZF9wbHVyYWwgIiVkIGxpbmVzIGFkZCB3aGl0ZXNwYWNlIGVycm9ycy4iCiBtc2dzdHJbMF0gIiVkIFplaWxlIGbDvGd0IFdoaXRlc3BhY2UtRmVobGVyIGhpbnp1LiIKIG1zZ3N0clsxXSAiJWQgWmVpbGVuIGbDvGdlbiBXaGl0ZXNwYWNlLUZlaGxlciBoaW56dS4iCiAKLSM6IGFwcGx5LmM6NDkwMAorIzogYXBwbHkuYzo0OTEyCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVkIGxpbmUgYXBwbGllZCBhZnRlciBmaXhpbmcgd2hpdGVzcGFjZSBlcnJvcnMuIgogbXNnaWRfcGx1cmFsICIlZCBsaW5lcyBhcHBsaWVkIGFmdGVyIGZpeGluZyB3aGl0ZXNwYWNlIGVycm9ycy4iCiBtc2dzdHJbMF0gIiVkIFplaWxlIG5hY2ggQmVoZWJ1bmcgdm9uIFdoaXRlc3BhY2UtRmVobGVybiBhbmdld2VuZGV0LiIKIG1zZ3N0clsxXSAiJWQgWmVpbGVuIG5hY2ggQmVoZWJ1bmcgdm9uIFdoaXRlc3BhY2UtRmVobGVybiBhbmdld2VuZGV0LiIKIAotIzogYXBwbHkuYzo0OTE2IGJ1aWx0aW4vYWRkLmM6NTQwIGJ1aWx0aW4vbXYuYzozMDEgYnVpbHRpbi9ybS5jOjM5MAorIzogYXBwbHkuYzo0OTI4IGJ1aWx0aW4vYWRkLmM6NTQwIGJ1aWx0aW4vbXYuYzozMDEgYnVpbHRpbi9ybS5jOjM5MAogbXNnaWQgIlVuYWJsZSB0byB3cml0ZSBuZXcgaW5kZXggZmlsZSIKIG1zZ3N0ciAiS29ubnRlIG5ldWUgSW5kZXgtRGF0ZWkgbmljaHQgc2NocmVpYmVuLiIKIAotIzogYXBwbHkuYzo0OTQzIGFwcGx5LmM6NDk0NiBidWlsdGluL2FtLmM6MjIwOCBidWlsdGluL2FtLmM6MjIxMQotIzogYnVpbHRpbi9jbG9uZS5jOjEyMyBidWlsdGluL2ZldGNoLmM6MTI4IGJ1aWx0aW4vbWVyZ2UuYzoyNzMKLSM6IGJ1aWx0aW4vcHVsbC5jOjIwOCBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6NDA3CisjOiBhcHBseS5jOjQ5NTUgYXBwbHkuYzo0OTU4IGJ1aWx0aW4vYW0uYzoyMTk3IGJ1aWx0aW4vYW0uYzoyMjAwCisjOiBidWlsdGluL2Nsb25lLmM6MTIyIGJ1aWx0aW4vZmV0Y2guYzoxNDMgYnVpbHRpbi9tZXJnZS5jOjI3MworIzogYnVpbHRpbi9wdWxsLmM6MjA5IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzo0MDcKICM6IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxMzY3IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxMzcwCiAjOiBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6MTg1MCBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6MTg1MwogIzogYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjIwOTIgZ2l0LWFkZC0taW50ZXJhY3RpdmUucGVybDoyMTEKIG1zZ2lkICJwYXRoIgogbXNnc3RyICJQZmFkIgogCi0jOiBhcHBseS5jOjQ5NDQKKyM6IGFwcGx5LmM6NDk1NgogbXNnaWQgImRvbid0IGFwcGx5IGNoYW5nZXMgbWF0Y2hpbmcgdGhlIGdpdmVuIHBhdGgiCiBtc2dzdHIgImtlaW5lIMOEbmRlcnVuZ2VuIGltIGFuZ2VnZWJlbmVuIFBmYWQgYW53ZW5kZW4iCiAKLSM6IGFwcGx5LmM6NDk0NworIzogYXBwbHkuYzo0OTU5CiBtc2dpZCAiYXBwbHkgY2hhbmdlcyBtYXRjaGluZyB0aGUgZ2l2ZW4gcGF0aCIKIG1zZ3N0ciAiw4RuZGVydW5nZW4gbnVyIGltIGFuZ2VnZWJlbmVuIFBmYWQgYW53ZW5kZW4iCiAKLSM6IGFwcGx5LmM6NDk0OSBidWlsdGluL2FtLmM6MjIxNworIzogYXBwbHkuYzo0OTYxIGJ1aWx0aW4vYW0uYzoyMjA2CiBtc2dpZCAibnVtIgogbXNnc3RyICJBbnphaGwiCiAKLSM6IGFwcGx5LmM6NDk1MAorIzogYXBwbHkuYzo0OTYyCiBtc2dpZCAicmVtb3ZlIDxudW0+IGxlYWRpbmcgc2xhc2hlcyBmcm9tIHRyYWRpdGlvbmFsIGRpZmYgcGF0aHMiCiBtc2dzdHIgIiIKICI8QW56YWhsPiB2b3Jhbmdlc3RlbGx0ZSBTY2hyw6Rnc3RyaWNoZSB2b24gaGVya8O2bW1saWNoZW4gRGlmZmVyZW56cGZhZGVuICIKICJlbnRmZXJuZW4iCiAKLSM6IGFwcGx5LmM6NDk1MworIzogYXBwbHkuYzo0OTY1CiBtc2dpZCAiaWdub3JlIGFkZGl0aW9ucyBtYWRlIGJ5IHRoZSBwYXRjaCIKIG1zZ3N0ciAiaGluenVnZWbDvGd0ZSBaZWlsZW4gZGVzIFBhdGNoZXMgaWdub3JpZXJlbiIKIAotIzogYXBwbHkuYzo0OTU1CisjOiBhcHBseS5jOjQ5NjcKIG1zZ2lkICJpbnN0ZWFkIG9mIGFwcGx5aW5nIHRoZSBwYXRjaCwgb3V0cHV0IGRpZmZzdGF0IGZvciB0aGUgaW5wdXQiCiBtc2dzdHIgIiIKICJhbnN0YXR0IGRlciBBbndlbmR1bmcgZGVzIFBhdGNoZXMsIGRlbiBcImRpZmZzdGF0XCIgZsO8ciBkaWUgRWluZ2FiZSAiCiAiYXVzZ2VnZWJlbiIKIAotIzogYXBwbHkuYzo0OTU5CisjOiBhcHBseS5jOjQ5NzEKIG1zZ2lkICJzaG93IG51bWJlciBvZiBhZGRlZCBhbmQgZGVsZXRlZCBsaW5lcyBpbiBkZWNpbWFsIG5vdGF0aW9uIgogbXNnc3RyICIiCiAiZGllIEFuemFobCB2b24gaGluenVnZWbDvGd0ZW4vZW50ZmVybnRlbiBaZWlsZW4gaW4gRGV6aW1hbG5vdGF0aW9uIGFuemVpZ2VuIgogCi0jOiBhcHBseS5jOjQ5NjEKKyM6IGFwcGx5LmM6NDk3MwogbXNnaWQgImluc3RlYWQgb2YgYXBwbHlpbmcgdGhlIHBhdGNoLCBvdXRwdXQgYSBzdW1tYXJ5IGZvciB0aGUgaW5wdXQiCiBtc2dzdHIgIiIKICJhbnN0YXR0IGRlciBBbndlbmR1bmcgZGVzIFBhdGNoZXMsIGVpbmUgWnVzYW1tZW5mYXNzdW5nIGbDvHIgZGllIEVpbmdhYmUgIgogImF1c2dlYmVuIgogCi0jOiBhcHBseS5jOjQ5NjMKKyM6IGFwcGx5LmM6NDk3NQogbXNnaWQgImluc3RlYWQgb2YgYXBwbHlpbmcgdGhlIHBhdGNoLCBzZWUgaWYgdGhlIHBhdGNoIGlzIGFwcGxpY2FibGUiCiBtc2dzdHIgIiIKICJhbnN0YXR0IGRlciBBbndlbmR1bmcgZGVzIFBhdGNoZXMsIHplaWdlIG9iIFBhdGNoIGFuZ2V3ZW5kZXQgd2VyZGVuIGthbm4iCiAKLSM6IGFwcGx5LmM6NDk2NQorIzogYXBwbHkuYzo0OTc3CiBtc2dpZCAibWFrZSBzdXJlIHRoZSBwYXRjaCBpcyBhcHBsaWNhYmxlIHRvIHRoZSBjdXJyZW50IGluZGV4IgogbXNnc3RyICIiCiAic2ljaGVyc3RlbGxlbiwgZGFzcyBkZXIgUGF0Y2ggbWl0IGRlbSBha3R1ZWxsZW4gSW5kZXggYW5nZXdlbmRldCB3ZXJkZW4ga2FubiIKIAotIzogYXBwbHkuYzo0OTY3CisjOiBhcHBseS5jOjQ5NzkKIG1zZ2lkICJtYXJrIG5ldyBmaWxlcyB3aXRoIGBnaXQgYWRkIC0taW50ZW50LXRvLWFkZGAiCiBtc2dzdHIgIm5ldWUgRGF0ZWllbiBtaXQgYGdpdCBhZGQgLS1pbnRlbnQtdG8tYWRkYCBtYXJraWVyZW4iCiAKLSM6IGFwcGx5LmM6NDk2OQorIzogYXBwbHkuYzo0OTgxCiBtc2dpZCAiYXBwbHkgYSBwYXRjaCB3aXRob3V0IHRvdWNoaW5nIHRoZSB3b3JraW5nIHRyZWUiCiBtc2dzdHIgIlBhdGNoIGFud2VuZGVuLCBvaG5lIMOEbmRlcnVuZ2VuIGltIEFyYmVpdHN2ZXJ6ZWljaG5pcyB2b3J6dW5laG1lbiIKIAotIzogYXBwbHkuYzo0OTcxCisjOiBhcHBseS5jOjQ5ODMKIG1zZ2lkICJhY2NlcHQgYSBwYXRjaCB0aGF0IHRvdWNoZXMgb3V0c2lkZSB0aGUgd29ya2luZyBhcmVhIgogbXNnc3RyICIiCiAiUGF0Y2ggYW53ZW5kZW4sIGRlciDDhG5kZXJ1bmdlbiBhdcOfZXJoYWxiIGRlcyBBcmJlaXRzdmVyemVpY2huaXNzZXMgdm9ybmltbXQiCiAKLSM6IGFwcGx5LmM6NDk3NAorIzogYXBwbHkuYzo0OTg2CiBtc2dpZCAiYWxzbyBhcHBseSB0aGUgcGF0Y2ggKHVzZSB3aXRoIC0tc3RhdC8tLXN1bW1hcnkvLS1jaGVjaykiCiBtc2dzdHIgIlBhdGNoIGFud2VuZGVuIChCZW51dHp1bmcgbWl0IC0tc3RhdC8tLXN1bW1hcnkvLS1jaGVjaykiCiAKLSM6IGFwcGx5LmM6NDk3NgorIzogYXBwbHkuYzo0OTg4CiBtc2dpZCAiYXR0ZW1wdCB0aHJlZS13YXkgbWVyZ2UgaWYgYSBwYXRjaCBkb2VzIG5vdCBhcHBseSIKIG1zZ3N0ciAidmVyc3VjaGUgMy1XZWdlLU1lcmdlLCB3ZW5uIGRlciBQYXRjaCBuaWNodCBhbmdld2VuZGV0IHdlcmRlbiBrb25udGUiCiAKLSM6IGFwcGx5LmM6NDk3OAorIzogYXBwbHkuYzo0OTkwCiBtc2dpZCAiYnVpbGQgYSB0ZW1wb3JhcnkgaW5kZXggYmFzZWQgb24gZW1iZWRkZWQgaW5kZXggaW5mb3JtYXRpb24iCiBtc2dzdHIgIiIKICJlaW5lbiB0ZW1wb3LDpHJlbiBJbmRleCwgYmFzaWVyZW5kIGF1ZiBkZW4gaW50ZWdyaWVydGVuIEluZGV4LUluZm9ybWF0aW9uZW4sICIKICJlcnN0ZWxsZW4iCiAKLSM6IGFwcGx5LmM6NDk4MSBidWlsdGluL2NoZWNrb3V0LWluZGV4LmM6MTczIGJ1aWx0aW4vbHMtZmlsZXMuYzo1MjQKKyM6IGFwcGx5LmM6NDk5MyBidWlsdGluL2NoZWNrb3V0LWluZGV4LmM6MTczIGJ1aWx0aW4vbHMtZmlsZXMuYzo1MjQKIG1zZ2lkICJwYXRocyBhcmUgc2VwYXJhdGVkIHdpdGggTlVMIGNoYXJhY3RlciIKIG1zZ3N0ciAiUGZhZGUgc2luZCBnZXRyZW5udCBkdXJjaCBOVUwgWmVpY2hlbiIKIAotIzogYXBwbHkuYzo0OTgzCisjOiBhcHBseS5jOjQ5OTUKIG1zZ2lkICJlbnN1cmUgYXQgbGVhc3QgPG4+IGxpbmVzIG9mIGNvbnRleHQgbWF0Y2giCiBtc2dzdHIgIiIKICJzaWNoZXIgc3RlbGxlbiwgZGFzcyBtaW5kZXN0ZW5zIDxuPiBaZWlsZW4gZGVzIEtvbnRleHRlcyDDvGJlcmVpbnN0aW1tZW4iCiAKLSM6IGFwcGx5LmM6NDk4NCBidWlsdGluL2FtLmM6MjE5NiBidWlsdGluL2ludGVycHJldC10cmFpbGVycy5jOjk4CisjOiBhcHBseS5jOjQ5OTYgYnVpbHRpbi9hbS5jOjIxODUgYnVpbHRpbi9pbnRlcnByZXQtdHJhaWxlcnMuYzo5OAogIzogYnVpbHRpbi9pbnRlcnByZXQtdHJhaWxlcnMuYzoxMDAgYnVpbHRpbi9pbnRlcnByZXQtdHJhaWxlcnMuYzoxMDIKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMzMCBidWlsdGluL3JlYmFzZS5jOjE0MjEKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMxMCBidWlsdGluL3JlYmFzZS5jOjE0NDUKIG1zZ2lkICJhY3Rpb24iCiBtc2dzdHIgIkFrdGlvbiIKIAotIzogYXBwbHkuYzo0OTg1CisjOiBhcHBseS5jOjQ5OTcKIG1zZ2lkICJkZXRlY3QgbmV3IG9yIG1vZGlmaWVkIGxpbmVzIHRoYXQgaGF2ZSB3aGl0ZXNwYWNlIGVycm9ycyIKIG1zZ3N0ciAibmV1ZSBvZGVyIGdlw6RuZGVydGUgWmVpbGVuLCBkaWUgV2hpdGVzcGFjZS1GZWhsZXIgaGFiZW4sIGVybWl0dGVsbiIKIAotIzogYXBwbHkuYzo0OTg4IGFwcGx5LmM6NDk5MQorIzogYXBwbHkuYzo1MDAwIGFwcGx5LmM6NTAwMwogbXNnaWQgImlnbm9yZSBjaGFuZ2VzIGluIHdoaXRlc3BhY2Ugd2hlbiBmaW5kaW5nIGNvbnRleHQiCiBtc2dzdHIgIsOEbmRlcnVuZ2VuIGltIFdoaXRlc3BhY2UgYmVpIGRlciBTdWNoZSBkZXMgS29udGV4dGVzIGlnbm9yaWVyZW4iCiAKLSM6IGFwcGx5LmM6NDk5NAorIzogYXBwbHkuYzo1MDA2CiBtc2dpZCAiYXBwbHkgdGhlIHBhdGNoIGluIHJldmVyc2UiCiBtc2dzdHIgImRlbiBQYXRjaCBpbiB1bWdla2VocnRlciBSZWloZW5mb2xnZSBhbndlbmRlbiIKIAotIzogYXBwbHkuYzo0OTk2CisjOiBhcHBseS5jOjUwMDgKIG1zZ2lkICJkb24ndCBleHBlY3QgYXQgbGVhc3Qgb25lIGxpbmUgb2YgY29udGV4dCIKIG1zZ3N0ciAia2VpbmVuIEtvbnRleHQgZXJ3YXJ0ZW4iCiAKLSM6IGFwcGx5LmM6NDk5OAorIzogYXBwbHkuYzo1MDEwCiBtc2dpZCAibGVhdmUgdGhlIHJlamVjdGVkIGh1bmtzIGluIGNvcnJlc3BvbmRpbmcgKi5yZWogZmlsZXMiCiBtc2dzdHIgIiIKICJ6dXLDvGNrZ2V3aWVzZW5lIFBhdGNoLUJsw7Zja2UgaW4gZW50c3ByZWNoZW5kZW4gKi5yZWogRGF0ZWllbiBoaW50ZXJsYXNzZW4iCiAKLSM6IGFwcGx5LmM6NTAwMAorIzogYXBwbHkuYzo1MDEyCiBtc2dpZCAiYWxsb3cgb3ZlcmxhcHBpbmcgaHVua3MiCiBtc2dzdHIgInNpY2ggw7xiZXJsYXBwZW5kZSBQYXRjaC1CbMO2Y2tlIGVybGF1YmVuIgogCi0jOiBhcHBseS5jOjUwMDEgYnVpbHRpbi9hZGQuYzoyOTEgYnVpbHRpbi9jaGVjay1pZ25vcmUuYzoyMgorIzogYXBwbHkuYzo1MDEzIGJ1aWx0aW4vYWRkLmM6MjkxIGJ1aWx0aW4vY2hlY2staWdub3JlLmM6MjIKICM6IGJ1aWx0aW4vY29tbWl0LmM6MTMzNyBidWlsdGluL2NvdW50LW9iamVjdHMuYzo5OCBidWlsdGluL2ZzY2suYzo3ODYKLSM6IGJ1aWx0aW4vbG9nLmM6MjA2OCBidWlsdGluL212LmM6MTIzIGJ1aWx0aW4vcmVhZC10cmVlLmM6MTI4CisjOiBidWlsdGluL2xvZy5jOjIwODUgYnVpbHRpbi9tdi5jOjEyMyBidWlsdGluL3JlYWQtdHJlZS5jOjEyOAogbXNnaWQgImJlIHZlcmJvc2UiCiBtc2dzdHIgImVyd2VpdGVydGUgQXVzZ2FiZW4iCiAKLSM6IGFwcGx5LmM6NTAwMworIzogYXBwbHkuYzo1MDE1CiBtc2dpZCAidG9sZXJhdGUgaW5jb3JyZWN0bHkgZGV0ZWN0ZWQgbWlzc2luZyBuZXctbGluZSBhdCB0aGUgZW5kIG9mIGZpbGUiCiBtc2dzdHIgImZlaGxlcmhhZnQgZXJrYW5udGVuIGZlaGxlbmRlbiBaZWlsZW51bWJydWNoIGFtIERhdGVpZW5kZSB0b2xlcmllcmVuIgogCi0jOiBhcHBseS5jOjUwMDYKKyM6IGFwcGx5LmM6NTAxOAogbXNnaWQgImRvIG5vdCB0cnVzdCB0aGUgbGluZSBjb3VudHMgaW4gdGhlIGh1bmsgaGVhZGVycyIKIG1zZ3N0ciAiZGVuIFplaWxlbm51bW1lcm4gaW0gS29wZiBkZXMgUGF0Y2gtQmxvY2tzIG5pY2h0IHZlcnRyYXVlbiIKIAotIzogYXBwbHkuYzo1MDA4IGJ1aWx0aW4vYW0uYzoyMjA1CisjOiBhcHBseS5jOjUwMjAgYnVpbHRpbi9hbS5jOjIxOTQKIG1zZ2lkICJyb290IgogbXNnc3RyICJXdXJ6ZWx2ZXJ6ZWljaG5pcyIKIAotIzogYXBwbHkuYzo1MDA5CisjOiBhcHBseS5jOjUwMjEKIG1zZ2lkICJwcmVwZW5kIDxyb290PiB0byBhbGwgZmlsZW5hbWVzIgogbXNnc3RyICI8V3VyemVsdmVyemVpY2huaXM+IHZvciBhbGxlIERhdGVpbmFtZW4gc3RlbGxlbiIKIApAQCAtODM5LDcgKzgzOSw3IEBACiBtc2dpZCAiYXJjaGl2ZSBmb3JtYXQiCiBtc2dzdHIgIkFyY2hpdmZvcm1hdCIKIAotIzogYXJjaGl2ZS5jOjQ1OCBidWlsdGluL2xvZy5jOjE1ODAKKyM6IGFyY2hpdmUuYzo0NTggYnVpbHRpbi9sb2cuYzoxNTgxCiBtc2dpZCAicHJlZml4IgogbXNnc3RyICJQcsOkZml4IgogCkBAIC04NDcsMTEgKzg0NywxMiBAQAogbXNnaWQgInByZXBlbmQgcHJlZml4IHRvIGVhY2ggcGF0aG5hbWUgaW4gdGhlIGFyY2hpdmUiCiBtc2dzdHIgImVpbmVuIFByw6RmaXggdm9yIGplZGVuIFBmYWRuYW1lbiBpbiBkZW0gQXJjaGl2IHN0ZWxsZW4iCiAKLSM6IGFyY2hpdmUuYzo0NjAgYnVpbHRpbi9ibGFtZS5jOjg2MiBidWlsdGluL2JsYW1lLmM6ODc0IGJ1aWx0aW4vYmxhbWUuYzo4NzUKLSM6IGJ1aWx0aW4vY29tbWl0LXRyZWUuYzoxMTcgYnVpbHRpbi9jb25maWcuYzoxMjkgYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExMzQKLSM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTM2IGJ1aWx0aW4vZ3JlcC5jOjg5NyBidWlsdGluL2hhc2gtb2JqZWN0LmM6MTA1Ci0jOiBidWlsdGluL2xzLWZpbGVzLmM6NTYwIGJ1aWx0aW4vbHMtZmlsZXMuYzo1NjMgYnVpbHRpbi9ub3Rlcy5jOjQxMgotIzogYnVpbHRpbi9ub3Rlcy5jOjU3OCBidWlsdGluL3JlYWQtdHJlZS5jOjEyMyBwYXJzZS1vcHRpb25zLmg6MTc3CisjOiBhcmNoaXZlLmM6NDYwIGJ1aWx0aW4vYmxhbWUuYzo4NjEgYnVpbHRpbi9ibGFtZS5jOjg3MyBidWlsdGluL2JsYW1lLmM6ODc0CisjOiBidWlsdGluL2NvbW1pdC10cmVlLmM6MTE3IGJ1aWx0aW4vY29uZmlnLmM6MTI5IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTYyCisjOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE2NCBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE2OCBidWlsdGluL2dyZXAuYzo4OTkKKyM6IGJ1aWx0aW4vaGFzaC1vYmplY3QuYzoxMDUgYnVpbHRpbi9scy1maWxlcy5jOjU2MCBidWlsdGluL2xzLWZpbGVzLmM6NTYzCisjOiBidWlsdGluL25vdGVzLmM6NDEyIGJ1aWx0aW4vbm90ZXMuYzo1NzggYnVpbHRpbi9yZWFkLXRyZWUuYzoxMjMKKyM6IHBhcnNlLW9wdGlvbnMuaDoxODYKIG1zZ2lkICJmaWxlIgogbXNnc3RyICJEYXRlaSIKIApAQCAtODgzLDcgKzg4NCw3IEBACiBtc2dpZCAibGlzdCBzdXBwb3J0ZWQgYXJjaGl2ZSBmb3JtYXRzIgogbXNnc3RyICJ1bnRlcnN0w7x0enRlIEFyY2hpdmZvcm1hdGUgYXVmbGlzdGVuIgogCi0jOiBhcmNoaXZlLmM6NDc5IGJ1aWx0aW4vYXJjaGl2ZS5jOjkxIGJ1aWx0aW4vY2xvbmUuYzoxMTMgYnVpbHRpbi9jbG9uZS5jOjExNgorIzogYXJjaGl2ZS5jOjQ3OSBidWlsdGluL2FyY2hpdmUuYzo5MSBidWlsdGluL2Nsb25lLmM6MTEyIGJ1aWx0aW4vY2xvbmUuYzoxMTUKICM6IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxMzc5IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxODU5CiBtc2dpZCAicmVwbyIKIG1zZ3N0ciAiUmVwb3NpdG9yeSIKQEAgLTg5Miw3ICs4OTMsNyBAQAogbXNnaWQgInJldHJpZXZlIHRoZSBhcmNoaXZlIGZyb20gcmVtb3RlIHJlcG9zaXRvcnkgPHJlcG8+IgogbXNnc3RyICJBcmNoaXYgdm9tIFJlbW90ZS1SZXBvc2l0b3J5IDxSZXBvc2l0b3J5PiBhYnJ1ZmVuIgogCi0jOiBhcmNoaXZlLmM6NDgxIGJ1aWx0aW4vYXJjaGl2ZS5jOjkzIGJ1aWx0aW4vZGlmZnRvb2wuYzo3MDcKKyM6IGFyY2hpdmUuYzo0ODEgYnVpbHRpbi9hcmNoaXZlLmM6OTMgYnVpbHRpbi9kaWZmdG9vbC5jOjcxNQogIzogYnVpbHRpbi9ub3Rlcy5jOjQ5OAogbXNnaWQgImNvbW1hbmQiCiBtc2dzdHIgIlByb2dyYW1tIgpAQCAtOTI4LDI2ICs5MjksMjYgQEAKIG1zZ2lkICJjYW5ub3Qgc3RyZWFtIGJsb2IgJXMiCiBtc2dzdHIgIkthbm4gQmxvYiAlcyBuaWNodCBzdHJlYW1lbi4iCiAKLSM6IGFyY2hpdmUtdGFyLmM6MjYwIGFyY2hpdmUtemlwLmM6MzYzCisjOiBhcmNoaXZlLXRhci5jOjI2NiBhcmNoaXZlLXppcC5jOjM2MwogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bnN1cHBvcnRlZCBmaWxlIG1vZGU6IDAlbyAoU0hBMTogJXMpIgogbXNnc3RyICJOaWNodCB1bnRlcnN0w7x0enRlciBEYXRlaW1vZHVzOiAwJW8gKFNIQTE6ICVzKSIKIAotIzogYXJjaGl2ZS10YXIuYzoyODcgYXJjaGl2ZS16aXAuYzozNTMKKyM6IGFyY2hpdmUtdGFyLmM6MjkzIGFyY2hpdmUtemlwLmM6MzUzCiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCByZWFkICVzIgogbXNnc3RyICJLYW5uICVzIG5pY2h0IGxlc2VuLiIKIAotIzogYXJjaGl2ZS10YXIuYzo0NTkKKyM6IGFyY2hpdmUtdGFyLmM6NDY1CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBzdGFydCAnJXMnIGZpbHRlciIKIG1zZ3N0ciAiS29ubnRlICclcycgRmlsdGVyIG5pY2h0IHN0YXJ0ZW4uIgogCi0jOiBhcmNoaXZlLXRhci5jOjQ2MgorIzogYXJjaGl2ZS10YXIuYzo0NjgKIG1zZ2lkICJ1bmFibGUgdG8gcmVkaXJlY3QgZGVzY3JpcHRvciIKIG1zZ3N0ciAiS29ubnRlIERlc2NyaXB0b3IgbmljaHQgdW1sZWl0ZW4uIgogCi0jOiBhcmNoaXZlLXRhci5jOjQ2OQorIzogYXJjaGl2ZS10YXIuYzo0NzUKICMsIGMtZm9ybWF0CiBtc2dpZCAiJyVzJyBmaWx0ZXIgcmVwb3J0ZWQgZXJyb3IiCiBtc2dzdHIgIiclcycgRmlsdGVyIG1lbGRldGUgRmVobGVyLiIKQEAgLTk3MiwxNyArOTczLDE3IEBACiBtc2dpZCAidGltZXN0YW1wIHRvbyBsYXJnZSBmb3IgdGhpcyBzeXN0ZW06ICU8UFJJdU1BWD4iCiBtc2dzdHIgIlRpbWVzdGFtcCB6dSBncm/DnyBmw7xyIGRpZXNlcyBTeXN0ZW06ICU8UFJJdU1BWD4iCiAKLSM6IGF0dHIuYzoyMTEKKyM6IGF0dHIuYzoyMTMKICMsIGMtZm9ybWF0CiBtc2dpZCAiJS4qcyBpcyBub3QgYSB2YWxpZCBhdHRyaWJ1dGUgbmFtZSIKIG1zZ3N0ciAiJS4qcyBpc3Qga2VpbiBnw7xsdGlnZXIgQXR0cmlidXRuYW1lIgogCi0jOiBhdHRyLmM6MzY4CisjOiBhdHRyLmM6MzcwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIG5vdCBhbGxvd2VkOiAlczolZCIKIG1zZ3N0ciAiJXMgbmljaHQgZXJsYXVidDogJXM6JWQiCiAKLSM6IGF0dHIuYzo0MDgKKyM6IGF0dHIuYzo0MTAKIG1zZ2lkICIiCiAiTmVnYXRpdmUgcGF0dGVybnMgYXJlIGlnbm9yZWQgaW4gZ2l0IGF0dHJpYnV0ZXNcbiIKICJVc2UgJ1xcIScgZm9yIGxpdGVyYWwgbGVhZGluZyBleGNsYW1hdGlvbi4iCkBAIC0xMTEwLDQzICsxMTExLDQzIEBACiBtc2dzdHJbMF0gImJpbsOkcmUgU3VjaGU6IGRhbmFjaCBub2NoICVkIENvbW1pdCB6dW0gVGVzdGVuIMO8YnJpZyAlc1xuIgogbXNnc3RyWzFdICJiaW7DpHJlIFN1Y2hlOiBkYW5hY2ggbm9jaCAlZCBDb21taXRzIHp1bSBUZXN0ZW4gw7xicmlnICVzXG4iCiAKLSM6IGJsYW1lLmM6MjY5NworIzogYmxhbWUuYzoyNzAwCiBtc2dpZCAiLS1jb250ZW50cyBhbmQgLS1yZXZlcnNlIGRvIG5vdCBibGVuZCB3ZWxsLiIKIG1zZ3N0ciAiLS1jb250ZW50cyB1bmQgLS1yZXZlcnNlIGZ1bmt0aW9uaWVyZW4gZ2VtZWluc2FtIG5pY2h0LiIKIAotIzogYmxhbWUuYzoyNzExCisjOiBibGFtZS5jOjI3MTQKIG1zZ2lkICJjYW5ub3QgdXNlIC0tY29udGVudHMgd2l0aCBmaW5hbCBjb21taXQgb2JqZWN0IG5hbWUiCiBtc2dzdHIgIiIKICJrYW5uIC0tY29udGVudHMgbmljaHQgbWl0IGVuZGfDvGx0aWdlbSBOYW1lbiBkZXMgQ29tbWl0LU9iamVrdGVzIGJlbnV0emVuIgogCi0jOiBibGFtZS5jOjI3MzIKKyM6IGJsYW1lLmM6MjczNQogbXNnaWQgIi0tcmV2ZXJzZSBhbmQgLS1maXJzdC1wYXJlbnQgdG9nZXRoZXIgcmVxdWlyZSBzcGVjaWZpZWQgbGF0ZXN0IGNvbW1pdCIKIG1zZ3N0ciAiIgogIi0tcmV2ZXJzZSB1bmQgLS1maXJzdC1wYXJlbnQgenVzYW1tZW4gZXJmb3JkZXJuIGRpZSBBbmdhYmUgZWluZXMgIgogImVuZGfDvGx0aWdlblxuIgogIkNvbW1pdHMiCiAKLSM6IGJsYW1lLmM6Mjc0MSBidW5kbGUuYzoxNjcgcmVmLWZpbHRlci5jOjIxOTYgcmVtb3RlLmM6MTkzOCBzZXF1ZW5jZXIuYzoyMDMzCi0jOiBzZXF1ZW5jZXIuYzo0MzQ4IGJ1aWx0aW4vY29tbWl0LmM6MTAyMCBidWlsdGluL2xvZy5jOjM4NyBidWlsdGluL2xvZy5jOjk2MwotIzogYnVpbHRpbi9sb2cuYzoxNDUxIGJ1aWx0aW4vbG9nLmM6MTgyNyBidWlsdGluL2xvZy5jOjIxMTcgYnVpbHRpbi9tZXJnZS5jOjQxMQotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMTQ4IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzE2MworIzogYmxhbWUuYzoyNzQ0IGJ1bmRsZS5jOjE2NyByZWYtZmlsdGVyLmM6MjIwMyByZW1vdGUuYzoxOTQxIHNlcXVlbmNlci5jOjE5NzEKKyM6IHNlcXVlbmNlci5jOjQzMDUgYnVpbHRpbi9jb21taXQuYzoxMDIwIGJ1aWx0aW4vbG9nLmM6Mzg3IGJ1aWx0aW4vbG9nLmM6OTY0CisjOiBidWlsdGluL2xvZy5jOjE0NTIgYnVpbHRpbi9sb2cuYzoxODQ0IGJ1aWx0aW4vbG9nLmM6MjEzNCBidWlsdGluL21lcmdlLmM6NDExCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMxMjggYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMTQzCiAjOiBidWlsdGluL3Nob3J0bG9nLmM6MTkyCiBtc2dpZCAicmV2aXNpb24gd2FsayBzZXR1cCBmYWlsZWQiCiBtc2dzdHIgIkVpbnJpY2h0dW5nIGRlcyBSZXZpc2lvbnNnYW5ncyBmZWhsZ2VzY2hsYWdlbiIKIAotIzogYmxhbWUuYzoyNzU5CisjOiBibGFtZS5jOjI3NjIKIG1zZ2lkICIiCiAiLS1yZXZlcnNlIC0tZmlyc3QtcGFyZW50IHRvZ2V0aGVyIHJlcXVpcmUgcmFuZ2UgYWxvbmcgZmlyc3QtcGFyZW50IGNoYWluIgogbXNnc3RyICIiCiAiLS1yZXZlcnNlIHVuZCAtLWZpcnN0LXBhcmVudCB6dXNhbW1lbiBlcmZvcmRlcm4gZWluZW4gQmVyZWljaCBlbnRsYW5nIGRlclxuIgogIlwiZmlyc3QtcGFyZW50XCItS2V0dGUiCiAKLSM6IGJsYW1lLmM6Mjc3MAorIzogYmxhbWUuYzoyNzczCiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vIHN1Y2ggcGF0aCAlcyBpbiAlcyIKIG1zZ3N0ciAiUGZhZCAlcyBuaWNodCBpbiAlcyIKIAotIzogYmxhbWUuYzoyNzgxCisjOiBibGFtZS5jOjI3ODQKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IHJlYWQgYmxvYiAlcyBmb3IgcGF0aCAlcyIKIG1zZ3N0ciAia2FubiBCbG9iICVzIGbDvHIgUGZhZCAnJXMnIG5pY2h0IGxlc2VuIgpAQCAtMTMwMyw3ICsxMzA0LDcgQEAKIG1zZ2lkICJ1bnJlY29nbml6ZWQgaGVhZGVyOiAlcyVzICglZCkiCiBtc2dzdHIgIm5pY2h0IGVya2FubnRlciBLb3BmYmVyZWljaDogJXMlcyAoJWQpIgogCi0jOiBidW5kbGUuYzo5MCByZXJlcmUuYzo0ODAgcmVyZXJlLmM6NjkwIHNlcXVlbmNlci5jOjIyODMgc2VxdWVuY2VyLmM6MzAyNAorIzogYnVuZGxlLmM6OTAgcmVyZXJlLmM6NDgwIHJlcmVyZS5jOjY5MCBzZXF1ZW5jZXIuYzoyMjIxIHNlcXVlbmNlci5jOjI5NjIKICM6IGJ1aWx0aW4vY29tbWl0LmM6NzkxCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBvcGVuICclcyciCkBAIC0xMzU2LDcgKzEzNTcsNyBAQAogbXNnaWQgInJlZiAnJXMnIGlzIGV4Y2x1ZGVkIGJ5IHRoZSByZXYtbGlzdCBvcHRpb25zIgogbXNnc3RyICJSZWZlcmVueiAnJXMnIHdpcmQgZHVyY2ggXCJyZXYtbGlzdFwiIE9wdGlvbmVuIGF1c2dlc2NobG9zc2VuIgogCi0jOiBidW5kbGUuYzo0NjAgYnVpbHRpbi9sb2cuYzoyMDIgYnVpbHRpbi9sb2cuYzoxNzMyIGJ1aWx0aW4vc2hvcnRsb2cuYzozMDYKKyM6IGJ1bmRsZS5jOjQ2MCBidWlsdGluL2xvZy5jOjIwMiBidWlsdGluL2xvZy5jOjE3MzMgYnVpbHRpbi9zaG9ydGxvZy5jOjMwNgogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bnJlY29nbml6ZWQgYXJndW1lbnQ6ICVzIgogbXNnc3RyICJuaWNodCBlcmthbm50ZXMgQXJndW1lbnQ6ICVzIgpAQCAtMTM3OSw4ICsxMzgwLDggQEAKIG1zZ2lkICJpbnZhbGlkIGNvbG9yIHZhbHVlOiAlLipzIgogbXNnc3RyICJVbmfDvGx0aWdlciBGYXJid2VydDogJS4qcyIKIAotIzogY29tbWl0LmM6NTAgc2VxdWVuY2VyLmM6MjcyNyBidWlsdGluL2FtLmM6MzU1IGJ1aWx0aW4vYW0uYzozOTkKLSM6IGJ1aWx0aW4vYW0uYzoxMzc4IGJ1aWx0aW4vYW0uYzoyMDIwIGJ1aWx0aW4vcmVwbGFjZS5jOjQ1NQorIzogY29tbWl0LmM6NTAgc2VxdWVuY2VyLmM6MjY2NSBidWlsdGluL2FtLmM6MzU0IGJ1aWx0aW4vYW0uYzozOTgKKyM6IGJ1aWx0aW4vYW0uYzoxMzY2IGJ1aWx0aW4vYW0uYzoyMDA5IGJ1aWx0aW4vcmVwbGFjZS5jOjQ1NgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcGFyc2UgJXMiCiBtc2dzdHIgImtvbm50ZSAlcyBuaWNodCBwYXJzZW4iCkBAIC0xNDExLDI4ICsxNDEyLDI4IEBACiAiU2llIGvDtm5uZW4gZGllc2UgTWVsZHVuZyB1bnRlcmRyw7xja2VuLCBpbmRlbSBTaWVcbiIKICJcImdpdCBjb25maWcgYWR2aWNlLmdyYWZ0RmlsZURlcHJlY2F0ZWQgZmFsc2VcIiBhdXNmw7xocmVuLiIKIAotIzogY29tbWl0LmM6MTEyNworIzogY29tbWl0LmM6MTEyOAogIywgYy1mb3JtYXQKIG1zZ2lkICJDb21taXQgJXMgaGFzIGFuIHVudHJ1c3RlZCBHUEcgc2lnbmF0dXJlLCBhbGxlZ2VkbHkgYnkgJXMuIgogbXNnc3RyICIiCiAiQ29tbWl0ICVzIGhhdCBlaW5lIG5pY2h0IHZlcnRyYXVlbnN3w7xyZGlnZSBHUEctU2lnbmF0dXIsIGFuZ2VibGljaCB2b24gJXMuIgogCi0jOiBjb21taXQuYzoxMTMwCisjOiBjb21taXQuYzoxMTMxCiAjLCBjLWZvcm1hdAogbXNnaWQgIkNvbW1pdCAlcyBoYXMgYSBiYWQgR1BHIHNpZ25hdHVyZSBhbGxlZ2VkbHkgYnkgJXMuIgogbXNnc3RyICJDb21taXQgJXMgaGF0IGVpbmUgdW5nw7xsdGlnZSBHUEctU2lnbmF0dXIsIGFuZ2VibGljaCB2b24gJXMuIgogCi0jOiBjb21taXQuYzoxMTMzCisjOiBjb21taXQuYzoxMTM0CiAjLCBjLWZvcm1hdAogbXNnaWQgIkNvbW1pdCAlcyBkb2VzIG5vdCBoYXZlIGEgR1BHIHNpZ25hdHVyZS4iCiBtc2dzdHIgIkNvbW1pdCAlcyBoYXQga2VpbmUgR1BHLVNpZ25hdHVyLiIKIAotIzogY29tbWl0LmM6MTEzNgorIzogY29tbWl0LmM6MTEzNwogIywgYy1mb3JtYXQKIG1zZ2lkICJDb21taXQgJXMgaGFzIGEgZ29vZCBHUEcgc2lnbmF0dXJlIGJ5ICVzXG4iCiBtc2dzdHIgIkNvbW1pdCAlcyBoYXQgZWluZSBnw7xsdGlnZSBHUEctU2lnbmF0dXIgdm9uICVzXG4iCiAKLSM6IGNvbW1pdC5jOjEzOTAKKyM6IGNvbW1pdC5jOjEzOTEKIG1zZ2lkICIiCiAiV2FybmluZzogY29tbWl0IG1lc3NhZ2UgZGlkIG5vdCBjb25mb3JtIHRvIFVURi04LlxuIgogIllvdSBtYXkgd2FudCB0byBhbWVuZCBpdCBhZnRlciBmaXhpbmcgdGhlIG1lc3NhZ2UsIG9yIHNldCB0aGUgY29uZmlnXG4iCkBAIC0xNDk2LDE4MCArMTQ5NywxOTUgQEAKIG1zZ2lkICJ1bmFibGUgdG8gZmluZCBhbGwgY29tbWl0LWdyYXBoIGZpbGVzIgogbXNnc3RyICJLb25udGUgbmljaHQgYWxsZSBDb21taXQtR3JhcGgtRGF0ZWllbiBmaW5kZW4uIgogCi0jOiBjb21taXQtZ3JhcGguYzo1NTQgY29tbWl0LWdyYXBoLmM6NjE0CisjOiBjb21taXQtZ3JhcGguYzo1NjEgY29tbWl0LWdyYXBoLmM6NjIxCiBtc2dpZCAiaW52YWxpZCBjb21taXQgcG9zaXRpb24uIGNvbW1pdC1ncmFwaCBpcyBsaWtlbHkgY29ycnVwdCIKIG1zZ3N0ciAiVW5nw7xsdGlnZSBDb21taXQtUG9zaXRpb24uIENvbW1pdC1HcmFwaCBpc3Qgd2FocnNjaGVpbmxpY2ggYmVzY2jDpGRpZ3QuIgogCi0jOiBjb21taXQtZ3JhcGguYzo1NzUKKyM6IGNvbW1pdC1ncmFwaC5jOjU4MgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgZmluZCBjb21taXQgJXMiCiBtc2dzdHIgIktvbm50ZSBDb21taXQgJXMgbmljaHQgZmluZGVuLiIKIAotIzogY29tbWl0LWdyYXBoLmM6MTAwMiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI2NTcKKyM6IGNvbW1pdC1ncmFwaC5jOjg1NSBidWlsdGluL2FtLmM6MTI4NworIywgYy1mb3JtYXQKK21zZ2lkICJ1bmFibGUgdG8gcGFyc2UgY29tbWl0ICVzIgorbXNnc3RyICJLb25udGUgQ29tbWl0ICclcycgbmljaHQgcGFyc2VuLiIKKworIzogY29tbWl0LWdyYXBoLmM6ODU5CisjLCBjLWZvcm1hdAorbXNnaWQgInVuYWJsZSB0byBnZXQgdHJlZSBmb3IgJXMiCittc2dzdHIgIktvbm50ZSBWZXJ6ZWljaG5pcyBmw7xyICVzIG5pY2h0IGJlc3RpbW1lbi4iCisKKyM6IGNvbW1pdC1ncmFwaC5jOjEwMTcgYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNjQxCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBnZXQgdHlwZSBvZiBvYmplY3QgJXMiCiBtc2dzdHIgIktvbm50ZSBBcnQgdm9uIE9iamVrdCAnJXMnIG5pY2h0IGJlc3RpbW1lbi4iCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjEwMzQKKyM6IGNvbW1pdC1ncmFwaC5jOjEwNDkKIG1zZ2lkICJMb2FkaW5nIGtub3duIGNvbW1pdHMgaW4gY29tbWl0IGdyYXBoIgogbXNnc3RyICJMYWRlIGJla2FubnRlIENvbW1pdHMgaW4gQ29tbWl0LUdyYXBoIgogCi0jOiBjb21taXQtZ3JhcGguYzoxMDUxCisjOiBjb21taXQtZ3JhcGguYzoxMDY2CiBtc2dpZCAiRXhwYW5kaW5nIHJlYWNoYWJsZSBjb21taXRzIGluIGNvbW1pdCBncmFwaCIKIG1zZ3N0ciAiRXJ3ZWl0ZXJlIGVycmVpY2hiYXJlIENvbW1pdHMgaW4gQ29tbWl0LUdyYXBoIgogCi0jOiBjb21taXQtZ3JhcGguYzoxMDcwCisjOiBjb21taXQtZ3JhcGguYzoxMDg1CiBtc2dpZCAiQ2xlYXJpbmcgY29tbWl0IG1hcmtzIGluIGNvbW1pdCBncmFwaCIKIG1zZ3N0ciAiTMO2c2NoZSBDb21taXQtTWFya2llcnVuZ2VuIGluIENvbW1pdC1HcmFwaCIKIAotIzogY29tbWl0LWdyYXBoLmM6MTA4OQorIzogY29tbWl0LWdyYXBoLmM6MTEwNAogbXNnaWQgIkNvbXB1dGluZyBjb21taXQgZ3JhcGggZ2VuZXJhdGlvbiBudW1iZXJzIgogbXNnc3RyICJDb21taXQtR3JhcGggR2VuZXJpZXJ1bmdzbnVtbWVybiBiZXJlY2huZW4iCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjExNjMKKyM6IGNvbW1pdC1ncmFwaC5jOjExNzkKICMsIGMtZm9ybWF0CiBtc2dpZCAiRmluZGluZyBjb21taXRzIGZvciBjb21taXQgZ3JhcGggaW4gJWQgcGFjayIKIG1zZ2lkX3BsdXJhbCAiRmluZGluZyBjb21taXRzIGZvciBjb21taXQgZ3JhcGggaW4gJWQgcGFja3MiCiBtc2dzdHJbMF0gIlN1Y2hlIENvbW1pdHMgZsO8ciBDb21taXQtR3JhcGggaW4gJWQgUGFrZXQiCiBtc2dzdHJbMV0gIlN1Y2hlIENvbW1pdHMgZsO8ciBDb21taXQtR3JhcGggaW4gJWQgUGFrZXRlbiIKIAotIzogY29tbWl0LWdyYXBoLmM6MTE3NgorIzogY29tbWl0LWdyYXBoLmM6MTE5MgogIywgYy1mb3JtYXQKIG1zZ2lkICJlcnJvciBhZGRpbmcgcGFjayAlcyIKIG1zZ3N0ciAiRmVobGVyIGJlaW0gSGluenVmw7xnZW4gdm9uIFBha2V0ICVzLiIKIAotIzogY29tbWl0LWdyYXBoLmM6MTE4MAorIzogY29tbWl0LWdyYXBoLmM6MTE5NgogIywgYy1mb3JtYXQKIG1zZ2lkICJlcnJvciBvcGVuaW5nIGluZGV4IGZvciAlcyIKIG1zZ3N0ciAiRmVobGVyIGJlaW0gw5ZmZm5lbiBkZXMgSW5kZXggZsO8ciAlcy4iCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjEyMDQKKyM6IGNvbW1pdC1ncmFwaC5jOjEyMjAKICMsIGMtZm9ybWF0CiBtc2dpZCAiRmluZGluZyBjb21taXRzIGZvciBjb21taXQgZ3JhcGggZnJvbSAlZCByZWYiCiBtc2dpZF9wbHVyYWwgIkZpbmRpbmcgY29tbWl0cyBmb3IgY29tbWl0IGdyYXBoIGZyb20gJWQgcmVmcyIKIG1zZ3N0clswXSAiU3VjaGUgQ29tbWl0cyBmw7xyIENvbW1pdC1HcmFwaCBpbiAlZCBSZWZlcmVueiIKIG1zZ3N0clsxXSAiU3VjaGUgQ29tbWl0cyBmw7xyIENvbW1pdC1HcmFwaCBpbiAlZCBSZWZlcmVuemVuIgogCi0jOiBjb21taXQtZ3JhcGguYzoxMjM4CisjOiBjb21taXQtZ3JhcGguYzoxMjQwCisjLCBjLWZvcm1hdAorbXNnaWQgImludmFsaWQgY29tbWl0IG9iamVjdCBpZDogJXMiCittc2dzdHIgInVuZ8O8bHRpZ2UgQ29tbWl0LU9iamVrdC1JRDogJXMiCisKKyM6IGNvbW1pdC1ncmFwaC5jOjEyNTUKIG1zZ2lkICJGaW5kaW5nIGNvbW1pdHMgZm9yIGNvbW1pdCBncmFwaCBhbW9uZyBwYWNrZWQgb2JqZWN0cyIKIG1zZ3N0ciAiU3VjaGUgQ29tbWl0cyBmw7xyIENvbW1pdC1HcmFwaCBpbiBnZXBhY2t0ZW4gT2JqZWt0ZW4iCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjEyNTMKKyM6IGNvbW1pdC1ncmFwaC5jOjEyNzAKIG1zZ2lkICJDb3VudGluZyBkaXN0aW5jdCBjb21taXRzIGluIGNvbW1pdCBncmFwaCIKIG1zZ3N0ciAiWsOkaGxlIENvbW1pdHMgaW4gQ29tbWl0LUdyYXBoIgogCi0jOiBjb21taXQtZ3JhcGguYzoxMjg0CisjOiBjb21taXQtZ3JhcGguYzoxMzAwCiBtc2dpZCAiRmluZGluZyBleHRyYSBlZGdlcyBpbiBjb21taXQgZ3JhcGgiCiBtc2dzdHIgIlN1Y2hlIHp1c8OkdHpsaWNoZSBSw6RuZGVyIGluIENvbW1pdC1HcmFwaCIKIAotIzogY29tbWl0LWdyYXBoLmM6MTMzMgorIzogY29tbWl0LWdyYXBoLmM6MTM0NgogbXNnaWQgImZhaWxlZCB0byB3cml0ZSBjb3JyZWN0IG51bWJlciBvZiBiYXNlIGdyYXBoIGlkcyIKIG1zZ3N0ciAiRmVobGVyIGJlaW0gU2NocmVpYmVuIGRlciBrb3JyZWt0ZW4gQW56YWhsIHZvbiBCYXNpcy1HcmFwaC1JRHMuIgogCi0jOiBjb21taXQtZ3JhcGguYzoxMzY1IG1pZHguYzo4MTEKKyM6IGNvbW1pdC1ncmFwaC5jOjEzNzkgbWlkeC5jOjgxMAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gY3JlYXRlIGxlYWRpbmcgZGlyZWN0b3JpZXMgb2YgJXMiCiBtc2dzdHIgIktvbm50ZSBmw7xocmVuZGUgVmVyemVpY2huaXNzZSB2b24gJyVzJyBuaWNodCBlcnN0ZWxsZW4uIgogCi0jOiBjb21taXQtZ3JhcGguYzoxMzc3IGJ1aWx0aW4vaW5kZXgtcGFjay5jOjMwNiBidWlsdGluL3JlcGFjay5jOjI0MAorIzogY29tbWl0LWdyYXBoLmM6MTM5MSBidWlsdGluL2luZGV4LXBhY2suYzozMDYgYnVpbHRpbi9yZXBhY2suYzoyNDEKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGNyZWF0ZSAnJXMnIgogbXNnc3RyICJrb25udGUgJyVzJyBuaWNodCBlcnN0ZWxsZW4iCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjE0MzcKKyM6IGNvbW1pdC1ncmFwaC5jOjE0NTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiV3JpdGluZyBvdXQgY29tbWl0IGdyYXBoIGluICVkIHBhc3MiCiBtc2dpZF9wbHVyYWwgIldyaXRpbmcgb3V0IGNvbW1pdCBncmFwaCBpbiAlZCBwYXNzZXMiCiBtc2dzdHJbMF0gIlNjaHJlaWJlIENvbW1pdC1HcmFwaCBpbiAlZCBEdXJjaGdhbmciCiBtc2dzdHJbMV0gIlNjaHJlaWJlIENvbW1pdC1HcmFwaCBpbiAlZCBEdXJjaGfDpG5nZW4iCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjE0NzgKKyM6IGNvbW1pdC1ncmFwaC5jOjE0OTIKIG1zZ2lkICJ1bmFibGUgdG8gb3BlbiBjb21taXQtZ3JhcGggY2hhaW4gZmlsZSIKIG1zZ3N0ciAiS29ubnRlIENvbW1pdC1HcmFwaCBDaGFpbi1EYXRlaSBuaWNodCDDtmZmbmVuLiIKIAotIzogY29tbWl0LWdyYXBoLmM6MTQ5MAorIzogY29tbWl0LWdyYXBoLmM6MTUwNAogbXNnaWQgImZhaWxlZCB0byByZW5hbWUgYmFzZSBjb21taXQtZ3JhcGggZmlsZSIKIG1zZ3N0ciAiS29ubnRlIEJhc2lzLUNvbW1pdC1HcmFwaC1EYXRlaSBuaWNodCB1bWJlbmVubmVuLiIKIAotIzogY29tbWl0LWdyYXBoLmM6MTUxMAorIzogY29tbWl0LWdyYXBoLmM6MTUyNAogbXNnaWQgImZhaWxlZCB0byByZW5hbWUgdGVtcG9yYXJ5IGNvbW1pdC1ncmFwaCBmaWxlIgogbXNnc3RyICJLb25udGUgdGVtcG9yw6RyZSBDb21taXQtR3JhcGgtRGF0ZWkgbmljaHQgdW1iZW5lbm5lbi4iCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjE2MjEKKyM6IGNvbW1pdC1ncmFwaC5jOjE2MzUKIG1zZ2lkICJTY2FubmluZyBtZXJnZWQgY29tbWl0cyIKIG1zZ3N0ciAiRHVyY2hzdWNoZSB6dXNhbW1lbmdlZsO8aHJ0ZSBDb21taXRzIgogCi0jOiBjb21taXQtZ3JhcGguYzoxNjMyCisjOiBjb21taXQtZ3JhcGguYzoxNjQ2CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuZXhwZWN0ZWQgZHVwbGljYXRlIGNvbW1pdCBpZCAlcyIKIG1zZ3N0ciAiVW5lcndhcnRldGUgZG9wcGVsdGUgQ29tbWl0LUlEICVzIgogCi0jOiBjb21taXQtZ3JhcGguYzoxNjU3CisjOiBjb21taXQtZ3JhcGguYzoxNjcwCiBtc2dpZCAiTWVyZ2luZyBjb21taXQtZ3JhcGgiCiBtc2dzdHIgIlp1c2FtbWVuZsO8aHJlbiB2b24gQ29tbWl0LUdyYXBoIgogCi0jOiBjb21taXQtZ3JhcGguYzoxODQ0CisjOiBjb21taXQtZ3JhcGguYzoxODYwCiAjLCBjLWZvcm1hdAogbXNnaWQgInRoZSBjb21taXQgZ3JhcGggZm9ybWF0IGNhbm5vdCB3cml0ZSAlZCBjb21taXRzIgogbXNnc3RyICJEYXMgQ29tbWl0LUdyYXBoIEZvcm1hdCBrYW5uIG5pY2h0ICVkIENvbW1pdHMgc2NocmVpYmVuLiIKIAotIzogY29tbWl0LWdyYXBoLmM6MTg1NQorIzogY29tbWl0LWdyYXBoLmM6MTg3MQogbXNnaWQgInRvbyBtYW55IGNvbW1pdHMgdG8gd3JpdGUgZ3JhcGgiCiBtc2dzdHIgIlp1IHZpZWxlIENvbW1pdHMgenVtIFNjaHJlaWJlbiBkZXMgR3JhcGhlbi4iCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjE5NDUKKyM6IGNvbW1pdC1ncmFwaC5jOjE5NjEKIG1zZ2lkICJ0aGUgY29tbWl0LWdyYXBoIGZpbGUgaGFzIGluY29ycmVjdCBjaGVja3N1bSBhbmQgaXMgbGlrZWx5IGNvcnJ1cHQiCiBtc2dzdHIgIiIKICJEaWUgQ29tbWl0LUdyYXBoLURhdGVpIGhhdCBlaW5lIGZhbHNjaGUgUHLDvGZzdW1tZSB1bmQgaXN0IHdhaHJzY2hlaW5saWNoICIKICJiZXNjaMOkZGlndC4iCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjE5NTUKKyM6IGNvbW1pdC1ncmFwaC5jOjE5NzEKICMsIGMtZm9ybWF0CiBtc2dpZCAiY29tbWl0LWdyYXBoIGhhcyBpbmNvcnJlY3QgT0lEIG9yZGVyOiAlcyB0aGVuICVzIgogbXNnc3RyICJDb21taXQtR3JhcGggaGF0IGZlaGxlcmhhZnRlIE9JRC1SZWloZW5mb2xnZTogJXMgZGFubiAlcyIKIAotIzogY29tbWl0LWdyYXBoLmM6MTk2NSBjb21taXQtZ3JhcGguYzoxOTgwCisjOiBjb21taXQtZ3JhcGguYzoxOTgxIGNvbW1pdC1ncmFwaC5jOjE5OTYKICMsIGMtZm9ybWF0CiBtc2dpZCAiY29tbWl0LWdyYXBoIGhhcyBpbmNvcnJlY3QgZmFub3V0IHZhbHVlOiBmYW5vdXRbJWRdID0gJXUgIT0gJXUiCiBtc2dzdHIgIkNvbW1pdC1HcmFwaCBoYXQgZmVobGVyaGFmdGVuIEZhbm91dC1XZXJ0OiBmYW5vdXRbJWRdID0gJXUgIT0gJXUiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjE5NzIKKyM6IGNvbW1pdC1ncmFwaC5jOjE5ODgKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIHBhcnNlIGNvbW1pdCAlcyBmcm9tIGNvbW1pdC1ncmFwaCIKIG1zZ3N0ciAiS29ubnRlIENvbW1pdCAlcyB2b24gQ29tbWl0LUdyYXBoIG5pY2h0IHBhcnNlbi4iCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjE5ODkKKyM6IGNvbW1pdC1ncmFwaC5jOjIwMDYKIG1zZ2lkICJWZXJpZnlpbmcgY29tbWl0cyBpbiBjb21taXQgZ3JhcGgiCiBtc2dzdHIgIkNvbW1pdCBpbiBDb21taXQtR3JhcGggw7xiZXJwcsO8ZmVuIgogCi0jOiBjb21taXQtZ3JhcGguYzoyMDAyCisjOiBjb21taXQtZ3JhcGguYzoyMDIwCiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBwYXJzZSBjb21taXQgJXMgZnJvbSBvYmplY3QgZGF0YWJhc2UgZm9yIGNvbW1pdC1ncmFwaCIKIG1zZ3N0ciAiIgogIkZlaGxlciBiZWltIFBhcnNlbiBkZXMgQ29tbWl0cyAlcyB2b24gT2JqZWt0LURhdGVuYmFuayBmw7xyIENvbW1pdC1HcmFwaCIKIAotIzogY29tbWl0LWdyYXBoLmM6MjAwOQorIzogY29tbWl0LWdyYXBoLmM6MjAyNwogIywgYy1mb3JtYXQKIG1zZ2lkICJyb290IHRyZWUgT0lEIGZvciBjb21taXQgJXMgaW4gY29tbWl0LWdyYXBoIGlzICVzICE9ICVzIgogbXNnc3RyICIiCiAiT0lEIGRlcyBXdXJ6ZWx2ZXJ6ZWljaG5pc3NlcyBmw7xyIENvbW1pdCAlcyBpbiBDb21taXQtR3JhcGggaXN0ICVzICE9ICVzIgogCi0jOiBjb21taXQtZ3JhcGguYzoyMDE5CisjOiBjb21taXQtZ3JhcGguYzoyMDM3CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvbW1pdC1ncmFwaCBwYXJlbnQgbGlzdCBmb3IgY29tbWl0ICVzIGlzIHRvbyBsb25nIgogbXNnc3RyICJDb21taXQtR3JhcGggVm9yZ8Okbmdlci1MaXN0ZSBmw7xyIENvbW1pdCAlcyBpc3QgenUgbGFuZyIKIAotIzogY29tbWl0LWdyYXBoLmM6MjAyOAorIzogY29tbWl0LWdyYXBoLmM6MjA0NgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb21taXQtZ3JhcGggcGFyZW50IGZvciAlcyBpcyAlcyAhPSAlcyIKIG1zZ3N0ciAiQ29tbWl0LUdyYXBoLVZvcmfDpG5nZXIgZsO8ciAlcyBpc3QgJXMgIT0gJXMiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjIwNDEKKyM6IGNvbW1pdC1ncmFwaC5jOjIwNTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiY29tbWl0LWdyYXBoIHBhcmVudCBsaXN0IGZvciBjb21taXQgJXMgdGVybWluYXRlcyBlYXJseSIKIG1zZ3N0ciAiQ29tbWl0LUdyYXBoIFZvcmfDpG5nZXItTGlzdGUgZsO8ciBDb21taXQgJXMgZW5kZXQgenUgZnLDvGgiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjIwNDYKKyM6IGNvbW1pdC1ncmFwaC5jOjIwNjQKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogImNvbW1pdC1ncmFwaCBoYXMgZ2VuZXJhdGlvbiBudW1iZXIgemVybyBmb3IgY29tbWl0ICVzLCBidXQgbm9uLXplcm8gZWxzZXdoZXJlIgpAQCAtMTY3Nyw3ICsxNjkzLDcgQEAKICJDb21taXQtR3JhcGggaGF0IEdlbmVyYXRpb25zbnVtbWVyIG51bGwgZsO8ciBDb21taXQgJXMsIGFiZXIgc29uc3QgdW5nbGVpY2ggIgogIm51bGwiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjIwNTAKKyM6IGNvbW1pdC1ncmFwaC5jOjIwNjgKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogImNvbW1pdC1ncmFwaCBoYXMgbm9uLXplcm8gZ2VuZXJhdGlvbiBudW1iZXIgZm9yIGNvbW1pdCAlcywgYnV0IHplcm8gZWxzZXdoZXJlIgpAQCAtMTY4NSwxMiArMTcwMSwxMiBAQAogIkNvbW1pdC1HcmFwaCBoYXQgR2VuZXJhdGlvbnNudW1tZXIgdW5nbGVpY2ggbnVsbCBmw7xyIENvbW1pdCAlcywgYWJlciBzb25zdCAiCiAibnVsbCIKIAotIzogY29tbWl0LWdyYXBoLmM6MjA2NQorIzogY29tbWl0LWdyYXBoLmM6MjA4MwogIywgYy1mb3JtYXQKIG1zZ2lkICJjb21taXQtZ3JhcGggZ2VuZXJhdGlvbiBmb3IgY29tbWl0ICVzIGlzICV1ICE9ICV1IgogbXNnc3RyICJDb21taXQtR3JhcGggRXJzdGVsbHVuZyBmw7xyIENvbW1pdCAlcyBpc3QgJXUgIT0gJXUiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjIwNzEKKyM6IGNvbW1pdC1ncmFwaC5jOjIwODkKICMsIGMtZm9ybWF0CiBtc2dpZCAiY29tbWl0IGRhdGUgZm9yIGNvbW1pdCAlcyBpbiBjb21taXQtZ3JhcGggaXMgJTxQUkl1TUFYPiAhPSAlPFBSSXVNQVg+IgogbXNnc3RyICIiCkBAIC0xNzQyLDcgKzE3NTgsNyBAQAogbXNnaWQgImtleSBkb2VzIG5vdCBjb250YWluIHZhcmlhYmxlIG5hbWU6ICVzIgogbXNnc3RyICJTY2hsw7xzc2VsIGVudGjDpGx0IGtlaW5lbiBWYXJpYWJsZW5uYW1lbjogJXMiCiAKLSM6IGNvbmZpZy5jOjQwNiBzZXF1ZW5jZXIuYzoyNDYzCisjOiBjb25maWcuYzo0MDYgc2VxdWVuY2VyLmM6MjQwMQogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIGtleTogJXMiCiBtc2dzdHIgIlVuZ8O8bHRpZ2VyIFNjaGzDvHNzZWw6ICVzIgpAQCAtMTg3MSwxNTcgKzE4ODcsMTUxIEBACiBtc2dpZCAiaW52YWxpZCBtb2RlIGZvciBvYmplY3QgY3JlYXRpb246ICVzIgogbXNnc3RyICJVbmfDvGx0aWdlciBNb2R1cyBmw7xyIE9iamVrdGVyc3RlbGx1bmc6ICVzIgogCi0jOiBjb25maWcuYzoxNDMwCisjOiBjb25maWcuYzoxNDI1CiAjLCBjLWZvcm1hdAogbXNnaWQgIm1hbGZvcm1lZCB2YWx1ZSBmb3IgJXMiCiBtc2dzdHIgIlVuZ8O8bHRpZ2VyIFdlcnQgZsO8ciAlcy4iCiAKLSM6IGNvbmZpZy5jOjE0NTYKKyM6IGNvbmZpZy5jOjE0NTEKICMsIGMtZm9ybWF0CiBtc2dpZCAibWFsZm9ybWVkIHZhbHVlIGZvciAlczogJXMiCiBtc2dzdHIgIlVuZ8O8bHRpZ2VyIFdlcnQgZsO8ciAlczogJXMiCiAKLSM6IGNvbmZpZy5jOjE0NTcKKyM6IGNvbmZpZy5jOjE0NTIKIG1zZ2lkICJtdXN0IGJlIG9uZSBvZiBub3RoaW5nLCBtYXRjaGluZywgc2ltcGxlLCB1cHN0cmVhbSBvciBjdXJyZW50IgogbXNnc3RyICIiCiAiTXVzcyBlaW5lciB2b24gZGllc2VuIHNlaW46IG5vdGhpbmcsIG1hdGNoaW5nLCBzaW1wbGUsIHVwc3RyZWFtLCBjdXJyZW50IgogCi0jOiBjb25maWcuYzoxNTE4IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzQxMAorIzogY29uZmlnLmM6MTUxMyBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzOTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiYmFkIHBhY2sgY29tcHJlc3Npb24gbGV2ZWwgJWQiCiBtc2dzdHIgInVuZ8O8bHRpZ2VyIEtvbXByaW1pZXJ1bmdzZ3JhZCAoJWQpIGbDvHIgUGFrZXRpZXJ1bmciCiAKLSM6IGNvbmZpZy5jOjE2MzkKKyM6IGNvbmZpZy5jOjE2MzQKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGxvYWQgY29uZmlnIGJsb2Igb2JqZWN0ICclcyciCiBtc2dzdHIgIktvbm50ZSBCbG9iLU9iamVrdCAnJXMnIGbDvHIgS29uZmlndXJhdGlvbiBuaWNodCBsYWRlbi4iCiAKLSM6IGNvbmZpZy5jOjE2NDIKKyM6IGNvbmZpZy5jOjE2MzcKICMsIGMtZm9ybWF0CiBtc2dpZCAicmVmZXJlbmNlICclcycgZG9lcyBub3QgcG9pbnQgdG8gYSBibG9iIgogbXNnc3RyICJSZWZlcmVueiAnJXMnIHplaWd0IGF1ZiBrZWluZW4gQmxvYi4iCiAKLSM6IGNvbmZpZy5jOjE2NTkKKyM6IGNvbmZpZy5jOjE2NTQKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHJlc29sdmUgY29uZmlnIGJsb2IgJyVzJyIKIG1zZ3N0ciAiS29ubnRlIEJsb2IgJyVzJyBmw7xyIEtvbmZpZ3VyYXRpb24gbmljaHQgYXVmbMO2c2VuLiIKIAotIzogY29uZmlnLmM6MTY4OQorIzogY29uZmlnLmM6MTY4NAogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gcGFyc2UgJXMiCiBtc2dzdHIgIkZlaGxlciBiZWltIFBhcnNlbiB2b24gJXMuIgogCi0jOiBjb25maWcuYzoxNzQ1CisjOiBjb25maWcuYzoxNzQwCiBtc2dpZCAidW5hYmxlIHRvIHBhcnNlIGNvbW1hbmQtbGluZSBjb25maWciCiBtc2dzdHIgIiIKICJLb25udGUgZGllIMO8YmVyIGRpZSBCZWZlaGxzemVpbGUgYW5nZWdlYmVuZSBLb25maWd1cmF0aW9uIG5pY2h0IHBhcnNlbi4iCiAKLSM6IGNvbmZpZy5jOjIwOTQKKyM6IGNvbmZpZy5jOjIwOTEKIG1zZ2lkICJ1bmtub3duIGVycm9yIG9jY3VycmVkIHdoaWxlIHJlYWRpbmcgdGhlIGNvbmZpZ3VyYXRpb24gZmlsZXMiCiBtc2dzdHIgIiIKICJFcyB0cmF0IGVpbiB1bmJla2FubnRlciBGZWhsZXIgYmVpbSBMZXNlbiBkZXIgS29uZmlndXJhdGlvbnNkYXRlaWVuIGF1Zi4iCiAKLSM6IGNvbmZpZy5jOjIyNjQKKyM6IGNvbmZpZy5jOjIyNjEKICMsIGMtZm9ybWF0CiBtc2dpZCAiSW52YWxpZCAlczogJyVzJyIKIG1zZ3N0ciAiVW5nw7xsdGlnZXIgJXM6ICclcyciCiAKLSM6IGNvbmZpZy5jOjIzMDcKLSMsIGMtZm9ybWF0Ci1tc2dpZCAidW5rbm93biBjb3JlLnVudHJhY2tlZENhY2hlIHZhbHVlICclcyc7IHVzaW5nICdrZWVwJyBkZWZhdWx0IHZhbHVlIgotbXNnc3RyICIiCi0iVW5iZWthbm50ZXIgV2VydCAnJXMnIGluIGNvcmUudW50cmFja2VkQ2FjaGU7IGJlbnV0emUgU3RhbmRhcmR3ZXJ0ICdrZWVwJyIKLQotIzogY29uZmlnLmM6MjMzMworIzogY29uZmlnLmM6MjMwNgogIywgYy1mb3JtYXQKIG1zZ2lkICJzcGxpdEluZGV4Lm1heFBlcmNlbnRDaGFuZ2UgdmFsdWUgJyVkJyBzaG91bGQgYmUgYmV0d2VlbiAwIGFuZCAxMDAiCiBtc2dzdHIgIiIKICJEZXIgV2VydCAnJWQnIHZvbiBzcGxpdEluZGV4Lm1heFBlcmNlbnRDaGFuZ2Ugc29sbHRlIHp3aXNjaGVuIDAgdW5kIDEwMCAiCiAibGllZ2VuLiIKIAotIzogY29uZmlnLmM6MjM3OQorIzogY29uZmlnLmM6MjM1MgogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gcGFyc2UgJyVzJyBmcm9tIGNvbW1hbmQtbGluZSBjb25maWciCiBtc2dzdHIgIiIKICJLb25udGUgV2VydCAnJXMnIGF1cyBkZXIgw7xiZXIgZGllIEJlZmVobHN6ZWlsZSBhbmdlZ2ViZW5lbiBLb25maWd1cmF0aW9uXG4iCiAibmljaHQgcGFyc2VuLiIKIAotIzogY29uZmlnLmM6MjM4MQorIzogY29uZmlnLmM6MjM1NAogIywgYy1mb3JtYXQKIG1zZ2lkICJiYWQgY29uZmlnIHZhcmlhYmxlICclcycgaW4gZmlsZSAnJXMnIGF0IGxpbmUgJWQiCiBtc2dzdHIgInVuZ8O8bHRpZ2UgS29uZmlndXJhdGlvbnN2YXJpYWJsZSAnJXMnIGluIERhdGVpICclcycgYmVpIFplaWxlICVkIgogCi0jOiBjb25maWcuYzoyNDYyCisjOiBjb25maWcuYzoyNDM1CiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgc2VjdGlvbiBuYW1lICclcyciCiBtc2dzdHIgIlVuZ8O8bHRpZ2VyIFNla3Rpb25zbmFtZSAnJXMnIgogCi0jOiBjb25maWcuYzoyNDk0CisjOiBjb25maWcuYzoyNDY3CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIGhhcyBtdWx0aXBsZSB2YWx1ZXMiCiBtc2dzdHIgIiVzIGhhdCBtZWhyZXJlIFdlcnRlIgogCi0jOiBjb25maWcuYzoyNTIzCisjOiBjb25maWcuYzoyNDk2CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byB3cml0ZSBuZXcgY29uZmlndXJhdGlvbiBmaWxlICVzIgogbXNnc3RyICJLb25udGUgbmV1ZSBLb25maWd1cmF0aW9uc2RhdGVpICclcycgbmljaHQgc2NocmVpYmVuLiIKIAotIzogY29uZmlnLmM6Mjc3NSBjb25maWcuYzozMDk5CisjOiBjb25maWcuYzoyNzQ4IGNvbmZpZy5jOjMwNzIKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGxvY2sgY29uZmlnIGZpbGUgJXMiCiBtc2dzdHIgIktvbm50ZSBLb25maWd1cmF0aW9uc2RhdGVpICclcycgbmljaHQgc3BlcnJlbi4iCiAKLSM6IGNvbmZpZy5jOjI3ODYKKyM6IGNvbmZpZy5jOjI3NTkKICMsIGMtZm9ybWF0CiBtc2dpZCAib3BlbmluZyAlcyIKIG1zZ3N0ciAiw5ZmZm5lICVzIgogCi0jOiBjb25maWcuYzoyODIxIGJ1aWx0aW4vY29uZmlnLmM6MzI4CisjOiBjb25maWcuYzoyNzk0IGJ1aWx0aW4vY29uZmlnLmM6MzI4CiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgcGF0dGVybjogJXMiCiBtc2dzdHIgIlVuZ8O8bHRpZ2VzIE11c3RlcjogJXMiCiAKLSM6IGNvbmZpZy5jOjI4NDYKKyM6IGNvbmZpZy5jOjI4MTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBjb25maWcgZmlsZSAlcyIKIG1zZ3N0ciAiVW5nw7xsdGlnZSBLb25maWd1cmF0aW9uc2RhdGVpICVzIgogCi0jOiBjb25maWcuYzoyODU5IGNvbmZpZy5jOjMxMTIKKyM6IGNvbmZpZy5jOjI4MzIgY29uZmlnLmM6MzA4NQogIywgYy1mb3JtYXQKIG1zZ2lkICJmc3RhdCBvbiAlcyBmYWlsZWQiCiBtc2dzdHIgImZzdGF0IGF1ZiAlcyBmZWhsZ2VzY2hsYWdlbiIKIAotIzogY29uZmlnLmM6Mjg3MAorIzogY29uZmlnLmM6Mjg0MwogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gbW1hcCAnJXMnIgogbXNnc3RyICJtbWFwIGbDvHIgJyVzJyBmZWhsZ2VzY2hsYWdlbiIKIAotIzogY29uZmlnLmM6Mjg3OSBjb25maWcuYzozMTE3CisjOiBjb25maWcuYzoyODUyIGNvbmZpZy5jOjMwOTAKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2htb2Qgb24gJXMgZmFpbGVkIgogbXNnc3RyICJjaG1vZCBhdWYgJXMgZmVobGdlc2NobGFnZW4iCiAKLSM6IGNvbmZpZy5jOjI5NjQgY29uZmlnLmM6MzIxNAorIzogY29uZmlnLmM6MjkzNyBjb25maWcuYzozMTg3CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCB3cml0ZSBjb25maWcgZmlsZSAlcyIKIG1zZ3N0ciAiS29ubnRlIEtvbmZpZ3VyYXRpb25zZGF0ZWkgJXMgbmljaHQgc2NocmVpYmVuLiIKIAotIzogY29uZmlnLmM6Mjk5OAorIzogY29uZmlnLmM6Mjk3MQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3Qgc2V0ICclcycgdG8gJyVzJyIKIG1zZ3N0ciAiS29ubnRlICclcycgbmljaHQgenUgJyVzJyBzZXR6ZW4uIgogCi0jOiBjb25maWcuYzozMDAwIGJ1aWx0aW4vcmVtb3RlLmM6NzgyCisjOiBjb25maWcuYzoyOTczIGJ1aWx0aW4vcmVtb3RlLmM6NzgyCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCB1bnNldCAnJXMnIgogbXNnc3RyICJLb25udGUgJyVzJyBuaWNodCBhdWZoZWJlbi4iCiAKLSM6IGNvbmZpZy5jOjMwOTAKKyM6IGNvbmZpZy5jOjMwNjMKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBzZWN0aW9uIG5hbWU6ICVzIgogbXNnc3RyICJVbmfDvGx0aWdlciBTZWt0aW9uc25hbWU6ICVzIgogCi0jOiBjb25maWcuYzozMjU3CisjOiBjb25maWcuYzozMjMwCiAjLCBjLWZvcm1hdAogbXNnaWQgIm1pc3NpbmcgdmFsdWUgZm9yICclcyciCiBtc2dzdHIgIkZlaGxlbmRlciBXZXJ0IGbDvHIgJyVzJyIKQEAgLTIxNDgsNyArMjE1OCw3IEBACiBtc2dpZCAidW5rbm93biBwb3J0ICVzIgogbXNnc3RyICJVbmJla2FubnRlciBQb3J0ICVzIgogCi0jOiBjb25uZWN0LmM6ODQ1IGNvbm5lY3QuYzoxMTcxCisjOiBjb25uZWN0LmM6ODQ1IGNvbm5lY3QuYzoxMTc1CiAjLCBjLWZvcm1hdAogbXNnaWQgInN0cmFuZ2UgaG9zdG5hbWUgJyVzJyBibG9ja2VkIgogbXNnc3RyICJNZXJrd8O8cmRpZ2VuIEhvc3RuYW1lbiAnJXMnIGJsb2NraWVydC4iCkBAIC0yMTYzLDU5ICsyMTczLDU5IEBACiBtc2dpZCAiY2Fubm90IHN0YXJ0IHByb3h5ICVzIgogbXNnc3RyICJLYW5uIFByb3h5ICVzIG5pY2h0IHN0YXJ0ZW4uIgogCi0jOiBjb25uZWN0LmM6OTI0CisjOiBjb25uZWN0LmM6OTI4CiBtc2dpZCAibm8gcGF0aCBzcGVjaWZpZWQ7IHNlZSAnZ2l0IGhlbHAgcHVsbCcgZm9yIHZhbGlkIHVybCBzeW50YXgiCiBtc2dzdHIgIiIKICJLZWluIFBmYWQgYW5nZWdlYmVuOyBzaWVoZSAnZ2l0IGhlbHAgcHVsbCcgZsO8ciBlaW5lIGfDvGx0aWdlIFVSTC1TeW50YXguIgogCi0jOiBjb25uZWN0LmM6MTExOQorIzogY29ubmVjdC5jOjExMjMKIG1zZ2lkICJzc2ggdmFyaWFudCAnc2ltcGxlJyBkb2VzIG5vdCBzdXBwb3J0IC00IgogbXNnc3RyICJTU0gtVmFyaWFudGUgJ3NpbXBsZScgdW50ZXJzdMO8dHp0IGtlaW4gLTQuIgogCi0jOiBjb25uZWN0LmM6MTEzMQorIzogY29ubmVjdC5jOjExMzUKIG1zZ2lkICJzc2ggdmFyaWFudCAnc2ltcGxlJyBkb2VzIG5vdCBzdXBwb3J0IC02IgogbXNnc3RyICJTU0gtVmFyaWFudGUgJ3NpbXBsZScgdW50ZXJzdMO8dHp0IGtlaW4gLTYuIgogCi0jOiBjb25uZWN0LmM6MTE0OAorIzogY29ubmVjdC5jOjExNTIKIG1zZ2lkICJzc2ggdmFyaWFudCAnc2ltcGxlJyBkb2VzIG5vdCBzdXBwb3J0IHNldHRpbmcgcG9ydCIKIG1zZ3N0ciAiU1NILVZhcmlhbnRlICdzaW1wbGUnIHVudGVyc3TDvHR6dCBuaWNodCBkYXMgU2V0emVuIGVpbmVzIFBvcnRzLiIKIAotIzogY29ubmVjdC5jOjEyNjAKKyM6IGNvbm5lY3QuYzoxMjY0CiAjLCBjLWZvcm1hdAogbXNnaWQgInN0cmFuZ2UgcGF0aG5hbWUgJyVzJyBibG9ja2VkIgogbXNnc3RyICJNZXJrd8O8cmRpZ2VuIFBmYWRuYW1lbiAnJXMnIGJsb2NraWVydC4iCiAKLSM6IGNvbm5lY3QuYzoxMzA3CisjOiBjb25uZWN0LmM6MTMxMQogbXNnaWQgInVuYWJsZSB0byBmb3JrIgogbXNnc3RyICJLYW5uIFByb3plc3MgbmljaHQgc3RhcnRlbi4iCiAKLSM6IGNvbm5lY3RlZC5jOjg2IGJ1aWx0aW4vZnNjay5jOjIyMSBidWlsdGluL3BydW5lLmM6NDMKKyM6IGNvbm5lY3RlZC5jOjg4IGJ1aWx0aW4vZnNjay5jOjIyMSBidWlsdGluL3BydW5lLmM6NDMKIG1zZ2lkICJDaGVja2luZyBjb25uZWN0aXZpdHkiCiBtc2dzdHIgIlByw7xmZSBLb25uZWt0aXZpdMOkdCIKIAotIzogY29ubmVjdGVkLmM6OTgKKyM6IGNvbm5lY3RlZC5jOjEwMAogbXNnaWQgIkNvdWxkIG5vdCBydW4gJ2dpdCByZXYtbGlzdCciCiBtc2dzdHIgIktvbm50ZSAnZ2l0IHJldi1saXN0JyBuaWNodCBhdXNmw7xocmVuIgogCi0jOiBjb25uZWN0ZWQuYzoxMTgKKyM6IGNvbm5lY3RlZC5jOjEyMAogbXNnaWQgImZhaWxlZCB3cml0ZSB0byByZXYtbGlzdCIKIG1zZ3N0ciAiRmVobGVyIGJlaW0gU2NocmVpYmVuIG5hY2ggcmV2LWxpc3QiCiAKLSM6IGNvbm5lY3RlZC5jOjEyNQorIzogY29ubmVjdGVkLmM6MTI3CiBtc2dpZCAiZmFpbGVkIHRvIGNsb3NlIHJldi1saXN0J3Mgc3RkaW4iCiBtc2dzdHIgIkZlaGxlciBiZWltIFNjaGxpZcOfZW4gdm9uIHJldi1saXN0J3MgU3RhbmRhcmQtRWluZ2FiZSIKIAotIzogY29udmVydC5jOjE5MworIzogY29udmVydC5jOjE5NAogIywgYy1mb3JtYXQKIG1zZ2lkICJpbGxlZ2FsIGNybGZfYWN0aW9uICVkIgogbXNnc3RyICJVbmVybGF1YnRlIGNybGZfYWN0aW9uICVkIgogCi0jOiBjb252ZXJ0LmM6MjA2CisjOiBjb252ZXJ0LmM6MjA3CiAjLCBjLWZvcm1hdAogbXNnaWQgIkNSTEYgd291bGQgYmUgcmVwbGFjZWQgYnkgTEYgaW4gJXMiCiBtc2dzdHIgIkNSTEYgd8O8cmRlIGluICVzIGR1cmNoIExGIGVyc2V0enQgd2VyZGVuLiIKIAotIzogY29udmVydC5jOjIwOAorIzogY29udmVydC5jOjIwOQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiQ1JMRiB3aWxsIGJlIHJlcGxhY2VkIGJ5IExGIGluICVzLlxuIgpAQCAtMjIyNSwxMiArMjIzNSwxMiBAQAogIkRpZSBEYXRlaSB3aXJkIGlocmUgdXJzcHLDvG5nbGljaGVuIFplaWxlbmVuZGVuIGltIEFyYmVpdHN2ZXJ6ZWljaG5pcyAiCiAiYmVoYWx0ZW4uIgogCi0jOiBjb252ZXJ0LmM6MjE2CisjOiBjb252ZXJ0LmM6MjE3CiAjLCBjLWZvcm1hdAogbXNnaWQgIkxGIHdvdWxkIGJlIHJlcGxhY2VkIGJ5IENSTEYgaW4gJXMiCiBtc2dzdHIgIkxGIHfDvHJkZSBpbiAlcyBkdXJjaCBDUkxGIGVyc2V0enQgd2VyZGVuLiIKIAotIzogY29udmVydC5jOjIxOAorIzogY29udmVydC5jOjIxOQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiTEYgd2lsbCBiZSByZXBsYWNlZCBieSBDUkxGIGluICVzLlxuIgpAQCAtMjI0MCwxMiArMjI1MCwxMiBAQAogIkRpZSBEYXRlaSB3aXJkIGlocmUgdXJzcHLDvG5nbGljaGVuIFplaWxlbmVuZGVuIGltIEFyYmVpdHN2ZXJ6ZWljaG5pcyAiCiAiYmVoYWx0ZW4uIgogCi0jOiBjb252ZXJ0LmM6Mjc5CisjOiBjb252ZXJ0LmM6MjgwCiAjLCBjLWZvcm1hdAogbXNnaWQgIkJPTSBpcyBwcm9oaWJpdGVkIGluICclcycgaWYgZW5jb2RlZCBhcyAlcyIKIG1zZ3N0ciAiQk9NIGlzdCBpbiAnJXMnIHVuenVsw6Rzc2lnLCB3ZW5uIGFscyAlcyBjb2RpZXJ0LiIKIAotIzogY29udmVydC5jOjI4NgorIzogY29udmVydC5jOjI4NwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiVGhlIGZpbGUgJyVzJyBjb250YWlucyBhIGJ5dGUgb3JkZXIgbWFyayAoQk9NKS4gUGxlYXNlIHVzZSBVVEYtJXMgYXMgd29ya2luZy0iCkBAIC0yMjU0LDEyICsyMjY0LDEyIEBACiAiRGllIERhdGVpICclcycgZW50aMOkbHQgZWluIEJ5dGUtT3JkZXItTWFyayAoQk9NKS4gQml0dGUgYmVudXR6ZW4gU2llIFVURi0lc1xuIgogImFscyBDb2RpZXJ1bmcgaW0gQXJiZWl0c3ZlcnplaWNobmlzLiIKIAotIzogY29udmVydC5jOjMwNAorIzogY29udmVydC5jOjMwNQogIywgYy1mb3JtYXQKIG1zZ2lkICJCT00gaXMgcmVxdWlyZWQgaW4gJyVzJyBpZiBlbmNvZGVkIGFzICVzIgogbXNnc3RyICJCT00gaXN0IGVyZm9yZGVybGljaCBpbiAnJXMnLCB3ZW5uIGFscyAlcyBjb2RpZXJ0LiIKIAotIzogY29udmVydC5jOjMwNgorIzogY29udmVydC5jOjMwNwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiVGhlIGZpbGUgJyVzJyBpcyBtaXNzaW5nIGEgYnl0ZSBvcmRlciBtYXJrIChCT00pLiBQbGVhc2UgdXNlIFVURi0lc0JFIG9yIFVURi0iCkBAIC0yMjY5LDUwICsyMjc5LDUwIEBACiAib2RlciBVVEYtJXNMRSAoYWJow6RuZ2lnIHZvbiBkZXIgQnl0ZS1SZWloZW5mb2xnZSkgYWxzIENvZGllcnVuZyBpbVxuIgogIkFyYmVpdHN2ZXJ6ZWljaG5pcy4iCiAKLSM6IGNvbnZlcnQuYzo0MjQgY29udmVydC5jOjQ5NQorIzogY29udmVydC5jOjQyNSBjb252ZXJ0LmM6NDk2CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBlbmNvZGUgJyVzJyBmcm9tICVzIHRvICVzIgogbXNnc3RyICJGZWhsZXIgYmVpbSBDb2RpZXJlbiB2b24gJyVzJyB2b24gJXMgbmFjaCAlcy4iCiAKLSM6IGNvbnZlcnQuYzo0NjcKKyM6IGNvbnZlcnQuYzo0NjgKICMsIGMtZm9ybWF0CiBtc2dpZCAiZW5jb2RpbmcgJyVzJyBmcm9tICVzIHRvICVzIGFuZCBiYWNrIGlzIG5vdCB0aGUgc2FtZSIKIG1zZ3N0ciAiRGllIENvZGllcnVuZyAnJXMnIHZvbiAlcyBuYWNoICVzIHVuZCB6dXLDvGNrIGlzdCBuaWNodCBkYXNzZWxiZS4iCiAKLSM6IGNvbnZlcnQuYzo2NzMKKyM6IGNvbnZlcnQuYzo2NzQKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IGZvcmsgdG8gcnVuIGV4dGVybmFsIGZpbHRlciAnJXMnIgogbXNnc3RyICJLYW5uIGV4dGVybmVuIEZpbHRlciAnJXMnIG5pY2h0IHN0YXJ0ZW4uIgogCi0jOiBjb252ZXJ0LmM6NjkzCisjOiBjb252ZXJ0LmM6Njk0CiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCBmZWVkIHRoZSBpbnB1dCB0byBleHRlcm5hbCBmaWx0ZXIgJyVzJyIKIG1zZ3N0ciAiS2FubiBFaW5nYWJlbiBuaWNodCBhbiBleHRlcm5lbiBGaWx0ZXIgJyVzJyDDvGJlcmdlYmVuLiIKIAotIzogY29udmVydC5jOjcwMAorIzogY29udmVydC5jOjcwMQogIywgYy1mb3JtYXQKIG1zZ2lkICJleHRlcm5hbCBmaWx0ZXIgJyVzJyBmYWlsZWQgJWQiCiBtc2dzdHIgIkV4dGVybmVyIEZpbHRlciAnJXMnIGZlaGxnZXNjaGxhZ2VuICVkIgogCi0jOiBjb252ZXJ0LmM6NzM1IGNvbnZlcnQuYzo3MzgKKyM6IGNvbnZlcnQuYzo3MzYgY29udmVydC5jOjczOQogIywgYy1mb3JtYXQKIG1zZ2lkICJyZWFkIGZyb20gZXh0ZXJuYWwgZmlsdGVyICclcycgZmFpbGVkIgogbXNnc3RyICJMZXNlbiB2b24gZXh0ZXJuZW0gRmlsdGVyICclcycgZmVobGdlc2NobGFnZW4uIgogCi0jOiBjb252ZXJ0LmM6NzQxIGNvbnZlcnQuYzo3OTYKKyM6IGNvbnZlcnQuYzo3NDIgY29udmVydC5jOjc5NwogIywgYy1mb3JtYXQKIG1zZ2lkICJleHRlcm5hbCBmaWx0ZXIgJyVzJyBmYWlsZWQiCiBtc2dzdHIgIkV4dGVybmVyIEZpbHRlciAnJXMnIGZlaGxnZXNjaGxhZ2VuLiIKIAotIzogY29udmVydC5jOjg0NAorIzogY29udmVydC5jOjg0NQogbXNnaWQgInVuZXhwZWN0ZWQgZmlsdGVyIHR5cGUiCiBtc2dzdHIgIlVuZXJ3YXJ0ZXRlIEZpbHRlcmFydC4iCiAKLSM6IGNvbnZlcnQuYzo4NTUKKyM6IGNvbnZlcnQuYzo4NTYKIG1zZ2lkICJwYXRoIG5hbWUgdG9vIGxvbmcgZm9yIGV4dGVybmFsIGZpbHRlciIKIG1zZ3N0ciAiUGZhZG5hbWUgenUgbGFuZyBmw7xyIGV4dGVybmVuIEZpbHRlci4iCiAKLSM6IGNvbnZlcnQuYzo5MjkKKyM6IGNvbnZlcnQuYzo5MzAKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogImV4dGVybmFsIGZpbHRlciAnJXMnIGlzIG5vdCBhdmFpbGFibGUgYW55bW9yZSBhbHRob3VnaCBub3QgYWxsIHBhdGhzIGhhdmUgIgpAQCAtMjMyMCw2NyArMjMzMCw2NyBAQAogbXNnc3RyICIiCiAiRXh0ZXJuZXIgRmlsdGVyICclcycgbmljaHQgbWVociB2ZXJmw7xnYmFyLiBOaWNodCBhbGxlIFBmYWRlIHd1cmRlbiBnZWZpbHRlcnQuIgogCi0jOiBjb252ZXJ0LmM6MTIyOAorIzogY29udmVydC5jOjEyMjkKIG1zZ2lkICJ0cnVlL2ZhbHNlIGFyZSBubyB2YWxpZCB3b3JraW5nLXRyZWUtZW5jb2RpbmdzIgogbXNnc3RyICJ0cnVlL2ZhbHNlIHNpbmQga2VpbmUgZ8O8bHRpZ2VuIENvZGllcnVuZ2VuIGltIEFyYmVpdHN2ZXJ6ZWljaG5pcy4iCiAKLSM6IGNvbnZlcnQuYzoxMzk4IGNvbnZlcnQuYzoxNDMyCisjOiBjb252ZXJ0LmM6MTQxNyBjb252ZXJ0LmM6MTQ1MQogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogY2xlYW4gZmlsdGVyICclcycgZmFpbGVkIgogbXNnc3RyICIlczogY2xlYW4tRmlsdGVyICclcycgZmVobGdlc2NobGFnZW4uIgogCi0jOiBjb252ZXJ0LmM6MTQ3NgorIzogY29udmVydC5jOjE0OTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXM6IHNtdWRnZSBmaWx0ZXIgJXMgZmFpbGVkIgogbXNnc3RyICIlczogc211ZGdlLUZpbHRlciAnJXMnIGZlaGxnZXNjaGxhZ2VuLiIKIAotIzogZGF0ZS5jOjEzNworIzogZGF0ZS5jOjEzOAogbXNnaWQgImluIHRoZSBmdXR1cmUiCiBtc2dzdHIgImluIGRlciBadWt1bmZ0IgogCi0jOiBkYXRlLmM6MTQzCisjOiBkYXRlLmM6MTQ0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiU8UFJJdU1BWD4gc2Vjb25kIGFnbyIKIG1zZ2lkX3BsdXJhbCAiJTxQUkl1TUFYPiBzZWNvbmRzIGFnbyIKIG1zZ3N0clswXSAidm9yICU8UFJJdU1BWD4gU2VrdW5kZSIKIG1zZ3N0clsxXSAidm9yICU8UFJJdU1BWD4gU2VrdW5kZW4iCiAKLSM6IGRhdGUuYzoxNTAKKyM6IGRhdGUuYzoxNTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiJTxQUkl1TUFYPiBtaW51dGUgYWdvIgogbXNnaWRfcGx1cmFsICIlPFBSSXVNQVg+IG1pbnV0ZXMgYWdvIgogbXNnc3RyWzBdICJ2b3IgJTxQUkl1TUFYPiBNaW51dGUiCiBtc2dzdHJbMV0gInZvciAlPFBSSXVNQVg+IE1pbnV0ZW4iCiAKLSM6IGRhdGUuYzoxNTcKKyM6IGRhdGUuYzoxNTgKICMsIGMtZm9ybWF0CiBtc2dpZCAiJTxQUkl1TUFYPiBob3VyIGFnbyIKIG1zZ2lkX3BsdXJhbCAiJTxQUkl1TUFYPiBob3VycyBhZ28iCiBtc2dzdHJbMF0gInZvciAlPFBSSXVNQVg+IFN0dW5kZSIKIG1zZ3N0clsxXSAidm9yICU8UFJJdU1BWD4gU3R1bmRlbiIKIAotIzogZGF0ZS5jOjE2NAorIzogZGF0ZS5jOjE2NQogIywgYy1mb3JtYXQKIG1zZ2lkICIlPFBSSXVNQVg+IGRheSBhZ28iCiBtc2dpZF9wbHVyYWwgIiU8UFJJdU1BWD4gZGF5cyBhZ28iCiBtc2dzdHJbMF0gInZvciAlPFBSSXVNQVg+IFRhZyIKIG1zZ3N0clsxXSAidm9yICU8UFJJdU1BWD4gVGFnZW4iCiAKLSM6IGRhdGUuYzoxNzAKKyM6IGRhdGUuYzoxNzEKICMsIGMtZm9ybWF0CiBtc2dpZCAiJTxQUkl1TUFYPiB3ZWVrIGFnbyIKIG1zZ2lkX3BsdXJhbCAiJTxQUkl1TUFYPiB3ZWVrcyBhZ28iCiBtc2dzdHJbMF0gInZvciAlPFBSSXVNQVg+IFdvY2hlIgogbXNnc3RyWzFdICJ2b3IgJTxQUkl1TUFYPiBXb2NoZW4iCiAKLSM6IGRhdGUuYzoxNzcKKyM6IGRhdGUuYzoxNzgKICMsIGMtZm9ybWF0CiBtc2dpZCAiJTxQUkl1TUFYPiBtb250aCBhZ28iCiBtc2dpZF9wbHVyYWwgIiU8UFJJdU1BWD4gbW9udGhzIGFnbyIKIG1zZ3N0clswXSAidm9yICU8UFJJdU1BWD4gTW9uYXQiCiBtc2dzdHJbMV0gInZvciAlPFBSSXVNQVg+IE1vbmF0ZW4iCiAKLSM6IGRhdGUuYzoxODgKKyM6IGRhdGUuYzoxODkKICMsIGMtZm9ybWF0CiBtc2dpZCAiJTxQUkl1TUFYPiB5ZWFyIgogbXNnaWRfcGx1cmFsICIlPFBSSXVNQVg+IHllYXJzIgpAQCAtMjM4OCwxNCArMjM5OCwxNCBAQAogbXNnc3RyWzFdICJ2b3IgJTxQUkl1TUFYPiBKYWhyZW4iCiAKICMuIFRSQU5TTEFUT1JTOiAiJXMiIGlzICI8bj4geWVhcnMiCi0jOiBkYXRlLmM6MTkxCisjOiBkYXRlLmM6MTkyCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzLCAlPFBSSXVNQVg+IG1vbnRoIGFnbyIKIG1zZ2lkX3BsdXJhbCAiJXMsICU8UFJJdU1BWD4gbW9udGhzIGFnbyIKIG1zZ3N0clswXSAiJXMsIHVuZCAlPFBSSXVNQVg+IE1vbmF0IgogbXNnc3RyWzFdICIlcywgdW5kICU8UFJJdU1BWD4gTW9uYXRlbiIKIAotIzogZGF0ZS5jOjE5NiBkYXRlLmM6MjAxCisjOiBkYXRlLmM6MTk3IGRhdGUuYzoyMDIKICMsIGMtZm9ybWF0CiBtc2dpZCAiJTxQUkl1TUFYPiB5ZWFyIGFnbyIKIG1zZ2lkX3BsdXJhbCAiJTxQUkl1TUFYPiB5ZWFycyBhZ28iCkBAIC0yNDM0LDcgKzI0NDQsNyBAQAogbXNnaWQgImZhaWxlZCB0byByZWFkIG9yZGVyZmlsZSAnJXMnIgogbXNnc3RyICJGZWhsZXIgYmVpbSBMZXNlbiBkZXIgUmVpaGVuZm9sZ2VkYXRlaSAnJXMnLiIKIAotIzogZGlmZmNvcmUtcmVuYW1lLmM6NTQ0CisjOiBkaWZmY29yZS1yZW5hbWUuYzo1NDMKIG1zZ2lkICJQZXJmb3JtaW5nIGluZXhhY3QgcmVuYW1lIGRldGVjdGlvbiIKIG1zZ3N0ciAiRsO8aHJlIEVya2VubnVuZyBmw7xyIHVuZ2VuYXVlIFVtYmVuZW5udW5nIGF1cyIKIApAQCAtMjUwMCwzNiArMjUxMCwzNiBAQAogIkZlaGxlciBpbiAnZGlmZi5kaXJzdGF0JyBLb25maWd1cmF0aW9uc3ZhcmlhYmxlIGdlZnVuZGVuOlxuIgogIiVzIgogCi0jOiBkaWZmLmM6NDIxNQorIzogZGlmZi5jOjQyMTgKICMsIGMtZm9ybWF0CiBtc2dpZCAiZXh0ZXJuYWwgZGlmZiBkaWVkLCBzdG9wcGluZyBhdCAlcyIKIG1zZ3N0ciAiZXh0ZXJuZXMgRGlmZi1Qcm9ncmFtbSB1bmVyd2FydGV0IGJlZW5kZXQsIGFuZ2VoYWx0ZW4gYmVpICVzIgogCi0jOiBkaWZmLmM6NDU2MAorIzogZGlmZi5jOjQ1NjMKIG1zZ2lkICItLW5hbWUtb25seSwgLS1uYW1lLXN0YXR1cywgLS1jaGVjayBhbmQgLXMgYXJlIG11dHVhbGx5IGV4Y2x1c2l2ZSIKIG1zZ3N0ciAiIgogIi0tbmFtZS1vbmx5LCAtLW5hbWUtc3RhdHVzLCAtLWNoZWNrIHVuZCAtcyBzY2hsaWXDn2VuIHNpY2ggZ2VnZW5zZWl0aWcgYXVzIgogCi0jOiBkaWZmLmM6NDU2MworIzogZGlmZi5jOjQ1NjYKIG1zZ2lkICItRywgLVMgYW5kIC0tZmluZC1vYmplY3QgYXJlIG11dHVhbGx5IGV4Y2x1c2l2ZSIKIG1zZ3N0ciAiLUcsIC1TIHVuZCAtLWZpbmQtb2JqZWN0IHNjaGxpZcOfZW4gc2ljaCBnZWdlbnNlaXRpZyBhdXMiCiAKLSM6IGRpZmYuYzo0NjQxCisjOiBkaWZmLmM6NDY0NAogbXNnaWQgIi0tZm9sbG93IHJlcXVpcmVzIGV4YWN0bHkgb25lIHBhdGhzcGVjIgogbXNnc3RyICItLWZvbGxvdyBlcmZvcmRlcnQgZ2VuYXUgZWluZSBQZmFkc3BlemlmaWthdGlvbiIKIAotIzogZGlmZi5jOjQ2ODkKKyM6IGRpZmYuYzo0NjkyCiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgLS1zdGF0IHZhbHVlOiAlcyIKIG1zZ3N0ciAiVW5nw7xsdGlnZXIgLS1zdGF0IFdlcnQ6ICVzIgogCi0jOiBkaWZmLmM6NDY5NCBkaWZmLmM6NDY5OSBkaWZmLmM6NDcwNCBkaWZmLmM6NDcwOSBkaWZmLmM6NTIyMgorIzogZGlmZi5jOjQ2OTcgZGlmZi5jOjQ3MDIgZGlmZi5jOjQ3MDcgZGlmZi5jOjQ3MTIgZGlmZi5jOjUyMjUKICM6IHBhcnNlLW9wdGlvbnMuYzoxOTkgcGFyc2Utb3B0aW9ucy5jOjIwMwogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyBleHBlY3RzIGEgbnVtZXJpY2FsIHZhbHVlIgogbXNnc3RyICIlcyBlcndhcnRldCBlaW5lbiBudW1lcmlzY2hlbiBXZXJ0LiIKIAotIzogZGlmZi5jOjQ3MjYKKyM6IGRpZmYuYzo0NzI5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJGYWlsZWQgdG8gcGFyc2UgLS1kaXJzdGF0Ly1YIG9wdGlvbiBwYXJhbWV0ZXI6XG4iCkBAIC0yNTM4LDQyICsyNTQ4LDQyIEBACiAiRmVobGVyIGJlaW0gUGFyc2VuIGRlcyAtLWRpcnN0YXQvLVggT3B0aW9uc3BhcmFtZXRlcnM6XG4iCiAiJXMiCiAKLSM6IGRpZmYuYzo0ODExCisjOiBkaWZmLmM6NDgxNAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmtub3duIGNoYW5nZSBjbGFzcyAnJWMnIGluIC0tZGlmZi1maWx0ZXI9JXMiCiBtc2dzdHIgIlVuYmVrYW5udGUgw4RuZGVydW5nc2tsYXNzZSAnJWMnIGluIC0tZGlmZi1maWx0ZXI9JXMiCiAKLSM6IGRpZmYuYzo0ODM1CisjOiBkaWZmLmM6NDgzOAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmtub3duIHZhbHVlIGFmdGVyIHdzLWVycm9yLWhpZ2hsaWdodD0lLipzIgogbXNnc3RyICJVbmJla2FubnRlciBXZXJ0IG5hY2ggd3MtZXJyb3ItaGlnaGxpZ2h0PSUuKnMiCiAKLSM6IGRpZmYuYzo0ODQ5CisjOiBkaWZmLmM6NDg1MgogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gcmVzb2x2ZSAnJXMnIgogbXNnc3RyICJrb25udGUgJyVzJyBuaWNodCBhdWZsw7ZzZW4iCiAKLSM6IGRpZmYuYzo0ODk5IGRpZmYuYzo0OTA1CisjOiBkaWZmLmM6NDkwMiBkaWZmLmM6NDkwOAogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyBleHBlY3RzIDxuPi88bT4gZm9ybSIKIG1zZ3N0ciAiJXMgZXJ3YXJ0ZXQgZGllIEZvcm0gPG4+LzxtPiIKIAotIzogZGlmZi5jOjQ5MTcKKyM6IGRpZmYuYzo0OTIwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIGV4cGVjdHMgYSBjaGFyYWN0ZXIsIGdvdCAnJXMnIgogbXNnc3RyICIlcyBlcndhcnRldCBlaW4gWmVpY2hlbiwgJyVzJyBiZWtvbW1lbiIKIAotIzogZGlmZi5jOjQ5MzgKKyM6IGRpZmYuYzo0OTQxCiAjLCBjLWZvcm1hdAogbXNnaWQgImJhZCAtLWNvbG9yLW1vdmVkIGFyZ3VtZW50OiAlcyIKIG1zZ3N0ciAiVW5nw7xsdGlnZXMgLS1jb2xvci1tb3ZlZCBBcmd1bWVudDogJXMiCiAKLSM6IGRpZmYuYzo0OTU3CisjOiBkaWZmLmM6NDk2MAogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIG1vZGUgJyVzJyBpbiAtLWNvbG9yLW1vdmVkLXdzIgogbXNnc3RyICJVbmfDvGx0aWdlciBNb2R1cyAnJXMnIGluIC0tY29sb3ItbW92ZWQtd3MiCiAKLSM6IGRpZmYuYzo0OTk3CisjOiBkaWZmLmM6NTAwMAogbXNnaWQgIiIKICJvcHRpb24gZGlmZi1hbGdvcml0aG0gYWNjZXB0cyBcIm15ZXJzXCIsIFwibWluaW1hbFwiLCBcInBhdGllbmNlXCIgYW5kICIKICJcImhpc3RvZ3JhbVwiIgpAQCAtMjU4MSwxNTIgKzI1OTEsMTUyIEBACiAiT3B0aW9uIGRpZmYtYWxnb3JpdGhtIGFremVwdGllcnQ6IFwibXllcnNcIiwgXCJtaW5pbWFsXCIsIFwicGF0aWVuY2VcIiBhbmQgIgogIlwiaGlzdG9ncmFtXCIiCiAKLSM6IGRpZmYuYzo1MDMzIGRpZmYuYzo1MDUzCisjOiBkaWZmLmM6NTAzNiBkaWZmLmM6NTA1NgogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIGFyZ3VtZW50IHRvICVzIgogbXNnc3RyICJVbmfDvGx0aWdlcyBBcmd1bWVudCBmw7xyICVzIgogCi0jOiBkaWZmLmM6NTE5MQorIzogZGlmZi5jOjUxOTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIHBhcnNlIC0tc3VibW9kdWxlIG9wdGlvbiBwYXJhbWV0ZXI6ICclcyciCiBtc2dzdHIgIkZlaGxlciBiZWltIFBhcnNlbiBkZXMgLS1zdWJtb2R1bGUgT3B0aW9uc3BhcmFtZXRlcnM6ICclcyciCiAKLSM6IGRpZmYuYzo1MjQ3CisjOiBkaWZmLmM6NTI1MAogIywgYy1mb3JtYXQKIG1zZ2lkICJiYWQgLS13b3JkLWRpZmYgYXJndW1lbnQ6ICVzIgogbXNnc3RyICJVbmfDvGx0aWdlcyAtLXdvcmQtZGlmZiBBcmd1bWVudDogJXMiCiAKLSM6IGRpZmYuYzo1MjcwCisjOiBkaWZmLmM6NTI3MwogbXNnaWQgIkRpZmYgb3V0cHV0IGZvcm1hdCBvcHRpb25zIgogbXNnc3RyICJEaWZmLU9wdGlvbmVuIHp1IEF1c2dhYmVmb3JtYXRlbiIKIAotIzogZGlmZi5jOjUyNzIgZGlmZi5jOjUyNzgKKyM6IGRpZmYuYzo1Mjc1IGRpZmYuYzo1MjgxCiBtc2dpZCAiZ2VuZXJhdGUgcGF0Y2giCiBtc2dzdHIgIkVyemV1Z2UgUGF0Y2giCiAKLSM6IGRpZmYuYzo1Mjc1IGJ1aWx0aW4vbG9nLmM6MTcyCisjOiBkaWZmLmM6NTI3OCBidWlsdGluL2xvZy5jOjE3MgogbXNnaWQgInN1cHByZXNzIGRpZmYgb3V0cHV0IgogbXNnc3RyICJBdXNnYWJlIGRlciBVbnRlcnNjaGllZGUgdW50ZXJkcsO8Y2tlbiIKIAotIzogZGlmZi5jOjUyODAgZGlmZi5jOjUzOTQgZGlmZi5jOjU0MDEKKyM6IGRpZmYuYzo1MjgzIGRpZmYuYzo1Mzk3IGRpZmYuYzo1NDA0CiBtc2dpZCAiPG4+IgogbXNnc3RyICI8bj4iCiAKLSM6IGRpZmYuYzo1MjgxIGRpZmYuYzo1Mjg0CisjOiBkaWZmLmM6NTI4NCBkaWZmLmM6NTI4NwogbXNnaWQgImdlbmVyYXRlIGRpZmZzIHdpdGggPG4+IGxpbmVzIGNvbnRleHQiCiBtc2dzdHIgIkVyc3RlbGxlIFVudGVyc2NoaWVkZSBtaXQgPG4+IFplaWxlbiBkZXMgS29udGV4dGVzIgogCi0jOiBkaWZmLmM6NTI4NgorIzogZGlmZi5jOjUyODkKIG1zZ2lkICJnZW5lcmF0ZSB0aGUgZGlmZiBpbiByYXcgZm9ybWF0IgogbXNnc3RyICJFcnN0ZWxsZSBVbnRlcnNjaGllZGUgaW0gUm9oZm9ybWF0IgogCi0jOiBkaWZmLmM6NTI4OQorIzogZGlmZi5jOjUyOTIKIG1zZ2lkICJzeW5vbnltIGZvciAnLXAgLS1yYXcnIgogbXNnc3RyICJTeW5vbnltIGbDvHIgJy1wIC0tcmF3JyIKIAotIzogZGlmZi5jOjUyOTMKKyM6IGRpZmYuYzo1Mjk2CiBtc2dpZCAic3lub255bSBmb3IgJy1wIC0tc3RhdCciCiBtc2dzdHIgIlN5bm9ueW0gZsO8ciAnLXAgLS1zdGF0JyIKIAotIzogZGlmZi5jOjUyOTcKKyM6IGRpZmYuYzo1MzAwCiBtc2dpZCAibWFjaGluZSBmcmllbmRseSAtLXN0YXQiCiBtc2dzdHIgIm1hc2NoaW5lbmxlc2JhcmUgQXVzZ2FiZSB2b24gLS1zdGF0IgogCi0jOiBkaWZmLmM6NTMwMAorIzogZGlmZi5jOjUzMDMKIG1zZ2lkICJvdXRwdXQgb25seSB0aGUgbGFzdCBsaW5lIG9mIC0tc3RhdCIKIG1zZ3N0ciAibnVyIGRpZSBsZXR6dGUgWmVpbGUgdm9uIC0tc3RhdCBhdXNnZWJlbiIKIAotIzogZGlmZi5jOjUzMDIgZGlmZi5jOjUzMTAKKyM6IGRpZmYuYzo1MzA1IGRpZmYuYzo1MzEzCiBtc2dpZCAiPHBhcmFtMSxwYXJhbTI+Li4uIgogbXNnc3RyICI8UGFyYW1ldGVyMSxQYXJhbWV0ZXIyPi4uLiIKIAotIzogZGlmZi5jOjUzMDMKKyM6IGRpZmYuYzo1MzA2CiBtc2dpZCAiIgogIm91dHB1dCB0aGUgZGlzdHJpYnV0aW9uIG9mIHJlbGF0aXZlIGFtb3VudCBvZiBjaGFuZ2VzIGZvciBlYWNoIHN1Yi1kaXJlY3RvcnkiCiBtc2dzdHIgIiIKICJHZWJlIGRpZSBWZXJ0ZWlsdW5nIGRlcyByZWxhdGl2ZW4gVW1mYW5ncyBkZXIgw4RuZGVydW5nZW4gZsO8ciBqZWRlcyAiCiAiVW50ZXJ2ZXJ6ZWljaG5pcyBhdXMiCiAKLSM6IGRpZmYuYzo1MzA3CisjOiBkaWZmLmM6NTMxMAogbXNnaWQgInN5bm9ueW0gZm9yIC0tZGlyc3RhdD1jdW11bGF0aXZlIgogbXNnc3RyICJTeW5vbnltIGbDvHIgLS1kaXJzdGF0PWN1bXVsYXRpdmUiCiAKLSM6IGRpZmYuYzo1MzExCisjOiBkaWZmLmM6NTMxNAogbXNnaWQgInN5bm9ueW0gZm9yIC0tZGlyc3RhdD1maWxlcyxwYXJhbTEscGFyYW0yLi4uIgogbXNnc3RyICJTeW5vbnltIGbDvHIgLS1kaXJzdGF0PWZpbGVzLFBhcmFtZXRlcjEsUGFyYW1ldGVyMi4uLiIKIAotIzogZGlmZi5jOjUzMTUKKyM6IGRpZmYuYzo1MzE4CiBtc2dpZCAid2FybiBpZiBjaGFuZ2VzIGludHJvZHVjZSBjb25mbGljdCBtYXJrZXJzIG9yIHdoaXRlc3BhY2UgZXJyb3JzIgogbXNnc3RyICIiCiAiV2FybmVuLCB3ZW5uIMOEbmRlcnVuZ2VuIEtvbmZsaWt0bWFya2VyIG9kZXIgV2hpdGVzcGFjZS1GZWhsZXIgZWluYnJpbmdlbiIKIAotIzogZGlmZi5jOjUzMTgKKyM6IGRpZmYuYzo1MzIxCiBtc2dpZCAiY29uZGVuc2VkIHN1bW1hcnkgc3VjaCBhcyBjcmVhdGlvbnMsIHJlbmFtZXMgYW5kIG1vZGUgY2hhbmdlcyIKIG1zZ3N0ciAiIgogIkdla8O8cnp0ZSBadXNhbW1lbmZhc3N1bmcsIHdpZSB6LkIuIEVyc3RlbGx1bmdlbiwgVW1iZW5lbm51bmdlbiB1bmQgIgogIsOEbmRlcnVuZ2VuIGRlciBEYXRlaS1SZWNodGUiCiAKLSM6IGRpZmYuYzo1MzIxCisjOiBkaWZmLmM6NTMyNAogbXNnaWQgInNob3cgb25seSBuYW1lcyBvZiBjaGFuZ2VkIGZpbGVzIgogbXNnc3RyICJudXIgRGF0ZWluYW1lbiBkZXIgZ2XDpG5kZXJ0ZW4gRGF0ZWllbiBhbnplaWdlbiIKIAotIzogZGlmZi5jOjUzMjQKKyM6IGRpZmYuYzo1MzI3CiBtc2dpZCAic2hvdyBvbmx5IG5hbWVzIGFuZCBzdGF0dXMgb2YgY2hhbmdlZCBmaWxlcyIKIG1zZ3N0ciAibnVyIERhdGVpbmFtZW4gdW5kIFN0YXR1cyBkZXIgZ2XDpG5kZXJ0ZW4gRGF0ZWllbiBhbnplaWdlbiIKIAotIzogZGlmZi5jOjUzMjYKKyM6IGRpZmYuYzo1MzI5CiBtc2dpZCAiPHdpZHRoPlssPG5hbWUtd2lkdGg+Wyw8Y291bnQ+XV0iCiBtc2dzdHIgIjxCcmVpdGU+Wyw8TmFtZW5zLUJyZWl0ZT5bLDxBbnphaGw+XV0iCiAKLSM6IGRpZmYuYzo1MzI3CisjOiBkaWZmLmM6NTMzMAogbXNnaWQgImdlbmVyYXRlIGRpZmZzdGF0IgogbXNnc3RyICJHZW5lcmllcmUgWnVzYW1tZW5mYXNzdW5nIGRlciBVbnRlcnNjaGllZGUiCiAKLSM6IGRpZmYuYzo1MzI5IGRpZmYuYzo1MzMyIGRpZmYuYzo1MzM1CisjOiBkaWZmLmM6NTMzMiBkaWZmLmM6NTMzNSBkaWZmLmM6NTMzOAogbXNnaWQgIjx3aWR0aD4iCiBtc2dzdHIgIjxCcmVpdGU+IgogCi0jOiBkaWZmLmM6NTMzMAorIzogZGlmZi5jOjUzMzMKIG1zZ2lkICJnZW5lcmF0ZSBkaWZmc3RhdCB3aXRoIGEgZ2l2ZW4gd2lkdGgiCiBtc2dzdHIgIkVyemV1Z2UgWnVzYW1tZW5mYXNzdW5nIGRlciBVbnRlcnNjaGllZGUgbWl0IGdlZ2ViZW5lciBCcmVpdGUiCiAKLSM6IGRpZmYuYzo1MzMzCisjOiBkaWZmLmM6NTMzNgogbXNnaWQgImdlbmVyYXRlIGRpZmZzdGF0IHdpdGggYSBnaXZlbiBuYW1lIHdpZHRoIgogbXNnc3RyICJFcnpldWdlIFp1c2FtbWVuZmFzc3VuZyBkZXIgVW50ZXJzY2hpZWRlIG1pdCBnZWdlYmVuZXIgTmFtZW5zLUJyZWl0ZSIKIAotIzogZGlmZi5jOjUzMzYKKyM6IGRpZmYuYzo1MzM5CiBtc2dpZCAiZ2VuZXJhdGUgZGlmZnN0YXQgd2l0aCBhIGdpdmVuIGdyYXBoIHdpZHRoIgogbXNnc3RyICJFcnpldWdlIFp1c2FtbWVuZmFzc3VuZyBkZXIgVW50ZXJzY2hpZWRlIG1pdCBnZWdlYmVuZXIgR3JhcGgtQnJlaXRlIgogCi0jOiBkaWZmLmM6NTMzOAorIzogZGlmZi5jOjUzNDEKIG1zZ2lkICI8Y291bnQ+IgogbXNnc3RyICI8QW56YWhsPiIKIAotIzogZGlmZi5jOjUzMzkKKyM6IGRpZmYuYzo1MzQyCiBtc2dpZCAiZ2VuZXJhdGUgZGlmZnN0YXQgd2l0aCBsaW1pdGVkIGxpbmVzIgogbXNnc3RyICJFcnpldWdlIFp1c2FtbWVuZmFzc3VuZyBkZXIgVW50ZXJzY2hpZWRlIG1pdCBiZWdyZW56dGVuIFplaWxlbiIKIAotIzogZGlmZi5jOjUzNDIKKyM6IGRpZmYuYzo1MzQ1CiBtc2dpZCAiZ2VuZXJhdGUgY29tcGFjdCBzdW1tYXJ5IGluIGRpZmZzdGF0IgogbXNnc3RyICJFcnpldWdlIGtvbXBha3RlIFp1c2FtbWVuc3RlbGx1bmcgaW4gWnVzYW1tZW5mYXNzdW5nIGRlciBVbnRlcnNjaGllZGUiCiAKLSM6IGRpZmYuYzo1MzQ1CisjOiBkaWZmLmM6NTM0OAogbXNnaWQgIm91dHB1dCBhIGJpbmFyeSBkaWZmIHRoYXQgY2FuIGJlIGFwcGxpZWQiCiBtc2dzdHIgIkdlYmUgZWluZSBiaW7DpHJlIERpZmZlcmVueiBhdXMsIGRhc3MgYW5nZXdlbmRldCB3ZXJkZW4ga2FubiIKIAotIzogZGlmZi5jOjUzNDgKKyM6IGRpZmYuYzo1MzUxCiBtc2dpZCAic2hvdyBmdWxsIHByZS0gYW5kIHBvc3QtaW1hZ2Ugb2JqZWN0IG5hbWVzIG9uIHRoZSBcImluZGV4XCIgbGluZXMiCiBtc2dzdHIgIlplaWdlIHZvbGxzdMOkbmRpZ2UgT2JqZWt0LU5hbWVuIGluIGRlbiBcImluZGV4XCItWmVpbGVuIgogCi0jOiBkaWZmLmM6NTM1MAorIzogZGlmZi5jOjUzNTMKIG1zZ2lkICJzaG93IGNvbG9yZWQgZGlmZiIKIG1zZ3N0ciAiWmVpZ2UgZmFyYmlnZSBVbnRlcnNjaGllZGUiCiAKLSM6IGRpZmYuYzo1MzUxCisjOiBkaWZmLmM6NTM1NAogbXNnaWQgIjxraW5kPiIKIG1zZ3N0ciAiPEFydD4iCiAKLSM6IGRpZmYuYzo1MzUyCisjOiBkaWZmLmM6NTM1NQogbXNnaWQgIiIKICJoaWdobGlnaHQgd2hpdGVzcGFjZSBlcnJvcnMgaW4gdGhlICdjb250ZXh0JywgJ29sZCcgb3IgJ25ldycgbGluZXMgaW4gdGhlICIKICJkaWZmIgpAQCAtMjczNCw3ICsyNzQ0LDcgQEAKICJIZWJlIFdoaXRlc3BhY2UtRmVobGVyIGluIGRlbiBaZWlsZW4gJ2NvbnRleHQnLCAnb2xkJyBvZGVyICduZXcnIGJlaSBkZW4gIgogIlVudGVyc2NoaWVkZW4gaGVydm9yIgogCi0jOiBkaWZmLmM6NTM1NQorIzogZGlmZi5jOjUzNTgKIG1zZ2lkICIiCiAiZG8gbm90IG11bmdlIHBhdGhuYW1lcyBhbmQgdXNlIE5VTHMgYXMgb3V0cHV0IGZpZWxkIHRlcm1pbmF0b3JzIGluIC0tcmF3IG9yICIKICItLW51bXN0YXQiCkBAIC0yNzQyLDkxICsyNzUyLDkxIEBACiAiVmVyc2NobGVpZXJlIG5pY2h0IGRpZSBQZmFkbmFtZW4gdW5kIG51dHplIE5VTC1aZWljaGVuIGFscyBTY2hsdXNzemVpY2hlbiBpbiAiCiAiQXVzZ2FiZWZlbGRlcm4gYmVpIC0tcmF3IG9kZXIgLS1udW1zdGF0IgogCi0jOiBkaWZmLmM6NTM1OCBkaWZmLmM6NTM2MSBkaWZmLmM6NTM2NCBkaWZmLmM6NTQ3MAorIzogZGlmZi5jOjUzNjEgZGlmZi5jOjUzNjQgZGlmZi5jOjUzNjcgZGlmZi5jOjU0NzMKIG1zZ2lkICI8cHJlZml4PiIKIG1zZ3N0ciAiPFByw6RmaXg+IgogCi0jOiBkaWZmLmM6NTM1OQorIzogZGlmZi5jOjUzNjIKIG1zZ2lkICJzaG93IHRoZSBnaXZlbiBzb3VyY2UgcHJlZml4IGluc3RlYWQgb2YgXCJhL1wiIgogbXNnc3RyICJaZWlnZSBkZW4gZ2VnZWJlbmVuIFF1ZWxsLVByw6RmaXggc3RhdHQgXCJhL1wiIgogCi0jOiBkaWZmLmM6NTM2MgorIzogZGlmZi5jOjUzNjUKIG1zZ2lkICJzaG93IHRoZSBnaXZlbiBkZXN0aW5hdGlvbiBwcmVmaXggaW5zdGVhZCBvZiBcImIvXCIiCiBtc2dzdHIgIlplaWdlIGRlbiBnZWdlYmVuZW4gWmllbC1QcsOkZml4IHN0YXR0IFwiYi9cIiIKIAotIzogZGlmZi5jOjUzNjUKKyM6IGRpZmYuYzo1MzY4CiBtc2dpZCAicHJlcGVuZCBhbiBhZGRpdGlvbmFsIHByZWZpeCB0byBldmVyeSBsaW5lIG9mIG91dHB1dCIKIG1zZ3N0ciAiU3RlbGxlIGVpbmVuIHp1c8OkdHpsaWNoZW4gUHLDpGZpeCBiZWkgamVkZXIgQXVzZ2FiZXplaWxlIHZvcmFuIgogCi0jOiBkaWZmLmM6NTM2OAorIzogZGlmZi5jOjUzNzEKIG1zZ2lkICJkbyBub3Qgc2hvdyBhbnkgc291cmNlIG9yIGRlc3RpbmF0aW9uIHByZWZpeCIKIG1zZ3N0ciAiWmVpZ2Uga2VpbmUgUXVlbGwtIG9kZXIgWmllbC1QcsOkZml4ZSBhbiIKIAotIzogZGlmZi5jOjUzNzEKKyM6IGRpZmYuYzo1Mzc0CiBtc2dpZCAic2hvdyBjb250ZXh0IGJldHdlZW4gZGlmZiBodW5rcyB1cCB0byB0aGUgc3BlY2lmaWVkIG51bWJlciBvZiBsaW5lcyIKIG1zZ3N0ciAiIgogIlplaWdlIEtvbnRleHQgendpc2NoZW4gVW50ZXJzY2hpZWQtQmzDtmNrZW4gYmlzIHp1ciBhbmdlZ2ViZW5lbiBBbnphaGwgdm9uICIKICJaZWlsZW4uIgogCi0jOiBkaWZmLmM6NTM3NSBkaWZmLmM6NTM4MCBkaWZmLmM6NTM4NQorIzogZGlmZi5jOjUzNzggZGlmZi5jOjUzODMgZGlmZi5jOjUzODgKIG1zZ2lkICI8Y2hhcj4iCiBtc2dzdHIgIjxaZWljaGVuPiIKIAotIzogZGlmZi5jOjUzNzYKKyM6IGRpZmYuYzo1Mzc5CiBtc2dpZCAic3BlY2lmeSB0aGUgY2hhcmFjdGVyIHRvIGluZGljYXRlIGEgbmV3IGxpbmUgaW5zdGVhZCBvZiAnKyciCiBtc2dzdHIgIkRhcyBaZWljaGVuIGZlc3RsZWdlbiwgZGFzIGVpbmUgbmV1ZSBaZWlsZSBrZW5uemVpY2huZXQgKHN0YXR0ICcrJykiCiAKLSM6IGRpZmYuYzo1MzgxCisjOiBkaWZmLmM6NTM4NAogbXNnaWQgInNwZWNpZnkgdGhlIGNoYXJhY3RlciB0byBpbmRpY2F0ZSBhbiBvbGQgbGluZSBpbnN0ZWFkIG9mICctJyIKIG1zZ3N0ciAiRGFzIFplaWNoZW4gZmVzdGxlZ2VuLCBkYXMgZWluZSBhbHRlIFplaWxlIGtlbm56ZWljaG5ldCAoc3RhdHQgJy0nKSIKIAotIzogZGlmZi5jOjUzODYKKyM6IGRpZmYuYzo1Mzg5CiBtc2dpZCAic3BlY2lmeSB0aGUgY2hhcmFjdGVyIHRvIGluZGljYXRlIGEgY29udGV4dCBpbnN0ZWFkIG9mICcgJyIKIG1zZ3N0ciAiRGFzIFplaWNoZW4gZmVzdGxlZ2VuLCBkYXMgZGVuIEtvbnRleHQga2VubnplaWNobmV0IChzdGF0dCAnICcpIgogCi0jOiBkaWZmLmM6NTM4OQorIzogZGlmZi5jOjUzOTIKIG1zZ2lkICJEaWZmIHJlbmFtZSBvcHRpb25zIgogbXNnc3RyICJEaWZmLU9wdGlvbmVuIHp1ciBVbWJlbmVubnVuZyIKIAotIzogZGlmZi5jOjUzOTAKKyM6IGRpZmYuYzo1MzkzCiBtc2dpZCAiPG4+Wy88bT5dIgogbXNnc3RyICI8bj5bLzxtPl0iCiAKLSM6IGRpZmYuYzo1MzkxCisjOiBkaWZmLmM6NTM5NAogbXNnaWQgImJyZWFrIGNvbXBsZXRlIHJld3JpdGUgY2hhbmdlcyBpbnRvIHBhaXJzIG9mIGRlbGV0ZSBhbmQgY3JlYXRlIgogbXNnc3RyICIiCiAiVGVpbGUga29tcGxldHRlIFJld3JpdGUtw4RuZGVydW5nZW4gaW4gw4RuZGVydW5nZW4gbWl0IFwibMO2c2NoZW5cIiB1bmQgIgogIlwiZXJzdGVsbGVuXCIiCiAKLSM6IGRpZmYuYzo1Mzk1CisjOiBkaWZmLmM6NTM5OAogbXNnaWQgImRldGVjdCByZW5hbWVzIgogbXNnc3RyICJVbWJlbmVubnVuZ2VuIGVya2VubmVuIgogCi0jOiBkaWZmLmM6NTM5OQorIzogZGlmZi5jOjU0MDIKIG1zZ2lkICJvbWl0IHRoZSBwcmVpbWFnZSBmb3IgZGVsZXRlcyIKIG1zZ3N0ciAiUHJlaW1hZ2UgZsO8ciBMw7ZzY2h1bmdlbiB3ZWdsYXNzZW4uIgogCi0jOiBkaWZmLmM6NTQwMgorIzogZGlmZi5jOjU0MDUKIG1zZ2lkICJkZXRlY3QgY29waWVzIgogbXNnc3RyICJLb3BpZW4gZXJrZW5uZW4iCiAKLSM6IGRpZmYuYzo1NDA2CisjOiBkaWZmLmM6NTQwOQogbXNnaWQgInVzZSB1bm1vZGlmaWVkIGZpbGVzIGFzIHNvdXJjZSB0byBmaW5kIGNvcGllcyIKIG1zZ3N0ciAiTnV0emUgdW5nZcOkbmRlcnRlIERhdGVpZW4gYWxzIFF1ZWxsZSB6dW0gRmluZGVuIHZvbiBLb3BpZW4iCiAKLSM6IGRpZmYuYzo1NDA4CisjOiBkaWZmLmM6NTQxMQogbXNnaWQgImRpc2FibGUgcmVuYW1lIGRldGVjdGlvbiIKIG1zZ3N0ciAiRXJrZW5udW5nIHZvbiBVbWJlbmVubnVuZ2VuIGRlYWt0aXZpZXJlbiIKIAotIzogZGlmZi5jOjU0MTEKKyM6IGRpZmYuYzo1NDE0CiBtc2dpZCAidXNlIGVtcHR5IGJsb2JzIGFzIHJlbmFtZSBzb3VyY2UiCiBtc2dzdHIgIk51dHplIGxlZXJlIEJsb2JzIGFscyBRdWVsbGUgdm9uIFVtYmVubnVuZ2VuIgogCi0jOiBkaWZmLmM6NTQxMworIzogZGlmZi5jOjU0MTYKIG1zZ2lkICJjb250aW51ZSBsaXN0aW5nIHRoZSBoaXN0b3J5IG9mIGEgZmlsZSBiZXlvbmQgcmVuYW1lcyIKIG1zZ3N0ciAiRm9ydGbDvGhyZW4gZGVyIEF1Zmxpc3R1bmcgZGVyIEhpc3RvcmllIGVpbmVyIERhdGVpIG5hY2ggVW1iZW5udW5nIgogCi0jOiBkaWZmLmM6NTQxNgorIzogZGlmZi5jOjU0MTkKIG1zZ2lkICIiCiAicHJldmVudCByZW5hbWUvY29weSBkZXRlY3Rpb24gaWYgdGhlIG51bWJlciBvZiByZW5hbWUvY29weSB0YXJnZXRzIGV4Y2VlZHMgIgogImdpdmVuIGxpbWl0IgpAQCAtMjgzNCwxNTkgKzI4NDQsMTU5IEBACiAiVmVyaGluZGVyZSBkaWUgRXJrZW5udW5nIHZvbiBVbWJlbm51bmdlbiB1bmQgS29waWVuLCB3ZW5uIGRpZSBBbnphaGwgZGVyICIKICJaaWVsZSBmw7xyIFVtYmVubnVuZ2VuIHVuZCBLb3BpZW4gZGFzIGdlZ2ViZW5lIExpbWl0IMO8YmVyc2NocmVpdGV0IgogCi0jOiBkaWZmLmM6NTQxOAorIzogZGlmZi5jOjU0MjEKIG1zZ2lkICJEaWZmIGFsZ29yaXRobSBvcHRpb25zIgogbXNnc3RyICJEaWZmIEFsZ29yaXRobXVzLU9wdGlvbmVuIgogCi0jOiBkaWZmLmM6NTQyMAorIzogZGlmZi5jOjU0MjMKIG1zZ2lkICJwcm9kdWNlIHRoZSBzbWFsbGVzdCBwb3NzaWJsZSBkaWZmIgogbXNnc3RyICJFcnpldWdlIGRpZSBrbGVpbnN0bcO2Z2xpY2hlbiDDhG5kZXJ1bmdlbiIKIAotIzogZGlmZi5jOjU0MjMKKyM6IGRpZmYuYzo1NDI2CiBtc2dpZCAiaWdub3JlIHdoaXRlc3BhY2Ugd2hlbiBjb21wYXJpbmcgbGluZXMiCiBtc2dzdHIgIldoaXRlc3BhY2Utw4RuZGVydW5nZW4gYmVpbSBWZXJnbGVpY2ggdm9uIFplaWxlbiBpZ25vcmllcmVuIgogCi0jOiBkaWZmLmM6NTQyNgorIzogZGlmZi5jOjU0MjkKIG1zZ2lkICJpZ25vcmUgY2hhbmdlcyBpbiBhbW91bnQgb2Ygd2hpdGVzcGFjZSIKIG1zZ3N0ciAiw4RuZGVydW5nZW4gYmVpIGRlciBBbnphaGwgdm9uIFdoaXRlc3BhY2UgaWdub3JpZXJlbiIKIAotIzogZGlmZi5jOjU0MjkKKyM6IGRpZmYuYzo1NDMyCiBtc2dpZCAiaWdub3JlIGNoYW5nZXMgaW4gd2hpdGVzcGFjZSBhdCBFT0wiCiBtc2dzdHIgIldoaXRlc3BhY2Utw4RuZGVydW5nZW4gYW0gWmVpbGVuZW5kZSBpZ25vcmllcmVuIgogCi0jOiBkaWZmLmM6NTQzMgorIzogZGlmZi5jOjU0MzUKIG1zZ2lkICJpZ25vcmUgY2Fycmllci1yZXR1cm4gYXQgdGhlIGVuZCBvZiBsaW5lIgogbXNnc3RyICJJZ25vcmllcmUgZGVuIFplaWxlbnVtYnJ1Y2ggYW0gRW5kZSBkZXIgWmVpbGUiCiAKLSM6IGRpZmYuYzo1NDM1CisjOiBkaWZmLmM6NTQzOAogbXNnaWQgImlnbm9yZSBjaGFuZ2VzIHdob3NlIGxpbmVzIGFyZSBhbGwgYmxhbmsiCiBtc2dzdHIgIklnbm9yaWVyZSDDhG5kZXJ1bmdlbiBpbiBsZWVyZW4gWmVpbGVuIgogCi0jOiBkaWZmLmM6NTQzOAorIzogZGlmZi5jOjU0NDEKIG1zZ2lkICJoZXVyaXN0aWMgdG8gc2hpZnQgZGlmZiBodW5rIGJvdW5kYXJpZXMgZm9yIGVhc3kgcmVhZGluZyIKIG1zZ3N0ciAiIgogIkhldXJpc3RpaywgdW0gR3JlbnplbiBkZXIgw4RuZGVydW5nc2Jsw7Zja2UgZsO8ciBiZXNzZXJlIExlc2JhcmtlaXQgenUgIgogInZlcnNjaGllYmVuIgogCi0jOiBkaWZmLmM6NTQ0MQorIzogZGlmZi5jOjU0NDQKIG1zZ2lkICJnZW5lcmF0ZSBkaWZmIHVzaW5nIHRoZSBcInBhdGllbmNlIGRpZmZcIiBhbGdvcml0aG0iCiBtc2dzdHIgIkVyemV1Z2Ugw4RuZGVydW5nZW4gZHVyY2ggTnV0enVuZyBkZXMgQWxnb3JpdGhtdXMgXCJQYXRpZW5jZSBEaWZmXCIiCiAKLSM6IGRpZmYuYzo1NDQ1CisjOiBkaWZmLmM6NTQ0OAogbXNnaWQgImdlbmVyYXRlIGRpZmYgdXNpbmcgdGhlIFwiaGlzdG9ncmFtIGRpZmZcIiBhbGdvcml0aG0iCiBtc2dzdHIgIkVyemV1Z2Ugw4RuZGVydW5nZW4gZHVyY2ggTnV0enVuZyBkZXMgQWxnb3JpdGhtdXMgXCJIaXN0b2dyYW0gRGlmZlwiIgogCi0jOiBkaWZmLmM6NTQ0NworIzogZGlmZi5jOjU0NTAKIG1zZ2lkICI8YWxnb3JpdGhtPiIKIG1zZ3N0ciAiPEFsZ29yaXRobXVzPiIKIAotIzogZGlmZi5jOjU0NDgKKyM6IGRpZmYuYzo1NDUxCiBtc2dpZCAiY2hvb3NlIGEgZGlmZiBhbGdvcml0aG0iCiBtc2dzdHIgIkVpbiBBbGdvcml0aG11cyBmw7xyIMOEbmRlcnVuZ2VuIHfDpGhsZW4iCiAKLSM6IGRpZmYuYzo1NDUwCisjOiBkaWZmLmM6NTQ1MwogbXNnaWQgIjx0ZXh0PiIKIG1zZ3N0ciAiPFRleHQ+IgogCi0jOiBkaWZmLmM6NTQ1MQorIzogZGlmZi5jOjU0NTQKIG1zZ2lkICJnZW5lcmF0ZSBkaWZmIHVzaW5nIHRoZSBcImFuY2hvcmVkIGRpZmZcIiBhbGdvcml0aG0iCiBtc2dzdHIgIkVyemV1Z2Ugw4RuZGVydW5nZW4gZHVyY2ggTnV0enVuZyBkZXMgQWxnb3JpdGhtdXMgXCJBbmNob3JlZCBEaWZmXCIiCiAKLSM6IGRpZmYuYzo1NDUzIGRpZmYuYzo1NDYyIGRpZmYuYzo1NDY1CisjOiBkaWZmLmM6NTQ1NiBkaWZmLmM6NTQ2NSBkaWZmLmM6NTQ2OAogbXNnaWQgIjxtb2RlPiIKIG1zZ3N0ciAiPE1vZHVzPiIKIAotIzogZGlmZi5jOjU0NTQKKyM6IGRpZmYuYzo1NDU3CiBtc2dpZCAic2hvdyB3b3JkIGRpZmYsIHVzaW5nIDxtb2RlPiB0byBkZWxpbWl0IGNoYW5nZWQgd29yZHMiCiBtc2dzdHIgIlplaWdlIFdvcnQtw4RuZGVydW5nZW4sIG51dHplIDxNb2R1cz4sIHVtIFfDtnJ0ZXIgYWJ6dWdyZW56ZW4iCiAKLSM6IGRpZmYuYzo1NDU2IGRpZmYuYzo1NDU5IGRpZmYuYzo1NTA0CisjOiBkaWZmLmM6NTQ1OSBkaWZmLmM6NTQ2MiBkaWZmLmM6NTUwNwogbXNnaWQgIjxyZWdleD4iCiBtc2dzdHIgIjxSZWdleD4iCiAKLSM6IGRpZmYuYzo1NDU3CisjOiBkaWZmLmM6NTQ2MAogbXNnaWQgInVzZSA8cmVnZXg+IHRvIGRlY2lkZSB3aGF0IGEgd29yZCBpcyIKIG1zZ3N0ciAiTnV0emUgPFJlZ2V4PiwgdW0genUgZW50c2NoZWlkZW4sIHdhcyBlaW4gV29ydCBpc3QiCiAKLSM6IGRpZmYuYzo1NDYwCisjOiBkaWZmLmM6NTQ2MwogbXNnaWQgImVxdWl2YWxlbnQgdG8gLS13b3JkLWRpZmY9Y29sb3IgLS13b3JkLWRpZmYtcmVnZXg9PHJlZ2V4PiIKIG1zZ3N0ciAiRW50c3ByZWNoZW5kIHdpZSAtLXdvcmQtZGlmZj1jb2xvciAtLXdvcmQtZGlmZi1yZWdleD08UmVnZXg+IgogCi0jOiBkaWZmLmM6NTQ2MworIzogZGlmZi5jOjU0NjYKIG1zZ2lkICJtb3ZlZCBsaW5lcyBvZiBjb2RlIGFyZSBjb2xvcmVkIGRpZmZlcmVudGx5IgogbXNnc3RyICJWZXJzY2hvYmVuZSBDb2RlemVpbGVuIHNpbmQgYW5kZXJzZmFyYmlnIgogCi0jOiBkaWZmLmM6NTQ2NgorIzogZGlmZi5jOjU0NjkKIG1zZ2lkICJob3cgd2hpdGUgc3BhY2VzIGFyZSBpZ25vcmVkIGluIC0tY29sb3ItbW92ZWQiCiBtc2dzdHIgIldpZSBXaGl0ZXNwYWNlcyBpbiAtLWNvbG9yLW1vdmVkIGlnbm9yaWVydCB3ZXJkZW4iCiAKLSM6IGRpZmYuYzo1NDY5CisjOiBkaWZmLmM6NTQ3MgogbXNnaWQgIk90aGVyIGRpZmYgb3B0aW9ucyIKIG1zZ3N0ciAiQW5kZXJlIERpZmYtT3B0aW9uZW4iCiAKLSM6IGRpZmYuYzo1NDcxCisjOiBkaWZmLmM6NTQ3NAogbXNnaWQgIndoZW4gcnVuIGZyb20gc3ViZGlyLCBleGNsdWRlIGNoYW5nZXMgb3V0c2lkZSBhbmQgc2hvdyByZWxhdGl2ZSBwYXRocyIKIG1zZ3N0ciAiIgogIldlbm4gdm9tIFVudGVydmVyemVpY2huaXMgYXVmZ2VydWZlbiwgc2NobGllw59lIMOEbmRlcnVuZ2VuIGF1w59lcmhhbGIgYXVzIHVuZCAiCiAiemVpZ2UgcmVsYXRpdmUgUGZhZGUgYW4iCiAKLSM6IGRpZmYuYzo1NDc1CisjOiBkaWZmLmM6NTQ3OAogbXNnaWQgInRyZWF0IGFsbCBmaWxlcyBhcyB0ZXh0IgogbXNnc3RyICJhbGxlIERhdGVpZW4gYWxzIFRleHQgYmVoYW5kZWxuIgogCi0jOiBkaWZmLmM6NTQ3NworIzogZGlmZi5jOjU0ODAKIG1zZ2lkICJzd2FwIHR3byBpbnB1dHMsIHJldmVyc2UgdGhlIGRpZmYiCiBtc2dzdHIgIlZlcnRhdXNjaGUgZGllIGJlaWRlbiBFaW5nYWJlbiB1bmQgZHJlaGUgZGllIMOEbmRlcnVuZ2VuIHVtIgogCi0jOiBkaWZmLmM6NTQ3OQorIzogZGlmZi5jOjU0ODIKIG1zZ2lkICJleGl0IHdpdGggMSBpZiB0aGVyZSB3ZXJlIGRpZmZlcmVuY2VzLCAwIG90aGVyd2lzZSIKIG1zZ3N0ciAiIgogIkJlZW5kZSBtaXQgRXhpdC1TdGF0dXMgMSwgd2VubiDDhG5kZXJ1bmdlbiB2b3JoYW5kZW4gc2luZCwgYW5kZXJuZmFsbHMgbWl0IDAiCiAKLSM6IGRpZmYuYzo1NDgxCisjOiBkaWZmLmM6NTQ4NAogbXNnaWQgImRpc2FibGUgYWxsIG91dHB1dCBvZiB0aGUgcHJvZ3JhbSIKIG1zZ3N0ciAiS2VpbmUgQXVzZ2FiZW4gdm9tIFByb2dyYW1tIgogCi0jOiBkaWZmLmM6NTQ4MworIzogZGlmZi5jOjU0ODYKIG1zZ2lkICJhbGxvdyBhbiBleHRlcm5hbCBkaWZmIGhlbHBlciB0byBiZSBleGVjdXRlZCIKIG1zZ3N0ciAiRXJsYXViZSBkaWUgQXVzZsO8aHJ1bmcgZWluZXMgZXh0ZXJuZXMgUHJvZ3JhbW1zIGbDvHIgw4RuZGVydW5nZW4iCiAKLSM6IGRpZmYuYzo1NDg1CisjOiBkaWZmLmM6NTQ4OAogbXNnaWQgInJ1biBleHRlcm5hbCB0ZXh0IGNvbnZlcnNpb24gZmlsdGVycyB3aGVuIGNvbXBhcmluZyBiaW5hcnkgZmlsZXMiCiBtc2dzdHIgIiIKICJGw7xocmUgZXh0ZXJuZSBUZXh0LUtvbnZlcnRpZXJ1bmdzZmlsdGVyIGF1cywgd2VubiBiaW7DpHJlIERhdGVpZW4gdmVyZ2xlaWNodCAiCiAid2VyZGVuIgogCi0jOiBkaWZmLmM6NTQ4NworIzogZGlmZi5jOjU0OTAKIG1zZ2lkICI8d2hlbj4iCiBtc2dzdHIgIjx3YW5uPiIKIAotIzogZGlmZi5jOjU0ODgKKyM6IGRpZmYuYzo1NDkxCiBtc2dpZCAiaWdub3JlIGNoYW5nZXMgdG8gc3VibW9kdWxlcyBpbiB0aGUgZGlmZiBnZW5lcmF0aW9uIgogbXNnc3RyICIiCiAiw4RuZGVydW5nZW4gaW4gU3VibW9kdWxlbiB3w6RocmVuZCBkZXIgRXJzdGVsbHVuZyBkZXIgVW50ZXJzY2hpZWRlIGlnbm9yaWVyZW4iCiAKLSM6IGRpZmYuYzo1NDkxCisjOiBkaWZmLmM6NTQ5NAogbXNnaWQgIjxmb3JtYXQ+IgogbXNnc3RyICI8Rm9ybWF0PiIKIAotIzogZGlmZi5jOjU0OTIKKyM6IGRpZmYuYzo1NDk1CiBtc2dpZCAic3BlY2lmeSBob3cgZGlmZmVyZW5jZXMgaW4gc3VibW9kdWxlcyBhcmUgc2hvd24iCiBtc2dzdHIgIkFuZ2ViZW4sIHdpZSBVbnRlcnNjaGllZGUgaW4gU3VibW9kdWxlbiBnZXplaWd0IHdlcmRlbiIKIAotIzogZGlmZi5jOjU0OTYKKyM6IGRpZmYuYzo1NDk5CiBtc2dpZCAiaGlkZSAnZ2l0IGFkZCAtTicgZW50cmllcyBmcm9tIHRoZSBpbmRleCIKIG1zZ3N0ciAidmVyc3RlY2tlICdnaXQgYWRkIC1OJyBFaW50csOkZ2Ugdm9tIEluZGV4IgogCi0jOiBkaWZmLmM6NTQ5OQorIzogZGlmZi5jOjU1MDIKIG1zZ2lkICJ0cmVhdCAnZ2l0IGFkZCAtTicgZW50cmllcyBhcyByZWFsIGluIHRoZSBpbmRleCIKIG1zZ3N0ciAiQmVoYW5kbGUgJ2dpdCBhZGQgLU4nIEVpbnRyw6RnZSBpbSBJbmRleCBhbHMgZWNodCIKIAotIzogZGlmZi5jOjU1MDEKKyM6IGRpZmYuYzo1NTA0CiBtc2dpZCAiPHN0cmluZz4iCiBtc2dzdHIgIjxaZWljaGVua2V0dGU+IgogCi0jOiBkaWZmLmM6NTUwMgorIzogZGlmZi5jOjU1MDUKIG1zZ2lkICIiCiAibG9vayBmb3IgZGlmZmVyZW5jZXMgdGhhdCBjaGFuZ2UgdGhlIG51bWJlciBvZiBvY2N1cnJlbmNlcyBvZiB0aGUgc3BlY2lmaWVkICIKICJzdHJpbmciCkBAIC0yOTk0LDcgKzMwMDQsNyBAQAogIlN1Y2hlIG5hY2ggVW50ZXJzY2hpZWRlbiwgd2VsY2hlIGRpZSBBbnphaGwgZGVzIFZvcmtvbW1lbnMgZGVyIGFuZ2VnZWJlbmVuICIKICJaZWljaGVua2V0dGUgdmVyw6RuZGVybiIKIAotIzogZGlmZi5jOjU1MDUKKyM6IGRpZmYuYzo1NTA4CiBtc2dpZCAiIgogImxvb2sgZm9yIGRpZmZlcmVuY2VzIHRoYXQgY2hhbmdlIHRoZSBudW1iZXIgb2Ygb2NjdXJyZW5jZXMgb2YgdGhlIHNwZWNpZmllZCAiCiAicmVnZXgiCkBAIC0zMDAyLDI1ICszMDEyLDI1IEBACiAiU3VjaGUgbmFjaCBVbnRlcnNjaGllZGVuLCB3ZWxjaGUgZGllIEFuemFobCBkZXMgVm9ya29tbWVucyBkZXMgYW5nZWdlYmVuZW4gIgogInJlZ3Vsw6RyZW4gQXVzZHJ1Y2tzIHZlcsOkbmRlcm4iCiAKLSM6IGRpZmYuYzo1NTA4CisjOiBkaWZmLmM6NTUxMQogbXNnaWQgInNob3cgYWxsIGNoYW5nZXMgaW4gdGhlIGNoYW5nZXNldCB3aXRoIC1TIG9yIC1HIgogbXNnc3RyICJ6ZWlnZSBhbGxlIMOEbmRlcnVuZ2VuIGltIENoYW5nZXNldCBtaXQgLVMgb2RlciAtRyIKIAotIzogZGlmZi5jOjU1MTEKKyM6IGRpZmYuYzo1NTE0CiBtc2dpZCAidHJlYXQgPHN0cmluZz4gaW4gLVMgYXMgZXh0ZW5kZWQgUE9TSVggcmVndWxhciBleHByZXNzaW9uIgogbXNnc3RyICIiCiAiYmVoYW5kbGUgPFplaWNoZW5rZXR0ZT4gYmVpIC1TIGFscyBlcndlaXRlcnRlbiBQT1NJWCByZWd1bMOkcmVuIEF1c2RydWNrIgogCi0jOiBkaWZmLmM6NTUxNAorIzogZGlmZi5jOjU1MTcKIG1zZ2lkICJjb250cm9sIHRoZSBvcmRlciBpbiB3aGljaCBmaWxlcyBhcHBlYXIgaW4gdGhlIG91dHB1dCIKIG1zZ3N0ciAiIgogImtvbnRyb2xsaWVyZSBkaWUgUmVpaGVuZm9sZ2UsIGluIGRlciBkaWUgRGF0ZWllbiBpbiBkZXIgQXVzZ2FiZSBlcnNjaGVpbmVuIgogCi0jOiBkaWZmLmM6NTUxNQorIzogZGlmZi5jOjU1MTgKIG1zZ2lkICI8b2JqZWN0LWlkPiIKIG1zZ3N0ciAiPE9iamVrdC1JRD4iCiAKLSM6IGRpZmYuYzo1NTE2CisjOiBkaWZmLmM6NTUxOQogbXNnaWQgIiIKICJsb29rIGZvciBkaWZmZXJlbmNlcyB0aGF0IGNoYW5nZSB0aGUgbnVtYmVyIG9mIG9jY3VycmVuY2VzIG9mIHRoZSBzcGVjaWZpZWQgIgogIm9iamVjdCIKQEAgLTMwMjgsMzMgKzMwMzgsMzMgQEAKICJTdWNoZSBuYWNoIFVudGVyc2NoaWVkZW4sIHdlbGNoZSBkaWUgQW56YWhsIGRlcyBWb3Jrb21tZW5zIGRlcyBhbmdlZ2ViZW5lbiAiCiAiT2JqZWt0ZXMgdmVyw6RuZGVybiIKIAotIzogZGlmZi5jOjU1MTgKKyM6IGRpZmYuYzo1NTIxCiBtc2dpZCAiWyhBfEN8RHxNfFJ8VHxVfFh8QikuLi5bKl1dIgogbXNnc3RyICJbKEF8Q3xEfE18UnxUfFV8WHxCKS4uLlsqXV0iCiAKLSM6IGRpZmYuYzo1NTE5CisjOiBkaWZmLmM6NTUyMgogbXNnaWQgInNlbGVjdCBmaWxlcyBieSBkaWZmIHR5cGUiCiBtc2dzdHIgIlfDpGhsZSBEYXRlaWVuIGFuaGFuZCBkZXIgQXJ0IGRlciDDhG5kZXJ1bmciCiAKLSM6IGRpZmYuYzo1NTIxCisjOiBkaWZmLmM6NTUyNAogbXNnaWQgIjxmaWxlPiIKIG1zZ3N0ciAiPERhdGVpPiIKIAotIzogZGlmZi5jOjU1MjIKKyM6IGRpZmYuYzo1NTI1CiBtc2dpZCAiT3V0cHV0IHRvIGEgc3BlY2lmaWMgZmlsZSIKIG1zZ3N0ciAiQXVzZ2FiZSB6dSBlaW5lciBiZXN0aW1tdGVuIERhdGVpIgogCi0jOiBkaWZmLmM6NjE3NworIzogZGlmZi5jOjYxODAKIG1zZ2lkICJpbmV4YWN0IHJlbmFtZSBkZXRlY3Rpb24gd2FzIHNraXBwZWQgZHVlIHRvIHRvbyBtYW55IGZpbGVzLiIKIG1zZ3N0ciAiIgogIlVuZ2VuYXVlIEVya2VubnVuZyBmw7xyIFVtYmVuZW5udW5nZW4gd3VyZGUgYXVmZ3J1bmQgenUgdmllbGVyIERhdGVpZW5cbiIKICLDvGJlcnNwcnVuZ2VuLiIKIAotIzogZGlmZi5jOjYxODAKKyM6IGRpZmYuYzo2MTgzCiBtc2dpZCAib25seSBmb3VuZCBjb3BpZXMgZnJvbSBtb2RpZmllZCBwYXRocyBkdWUgdG8gdG9vIG1hbnkgZmlsZXMuIgogbXNnc3RyICJudXIgS29waWVuIHZvbiBnZcOkbmRlcnRlbiBQZmFkZW4sIGF1ZmdydW5kIHp1IHZpZWxlciBEYXRlaWVuLCBnZWZ1bmRlbiIKIAotIzogZGlmZi5jOjYxODMKKyM6IGRpZmYuYzo2MTg2CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJ5b3UgbWF5IHdhbnQgdG8gc2V0IHlvdXIgJXMgdmFyaWFibGUgdG8gYXQgbGVhc3QgJWQgYW5kIHJldHJ5IHRoZSBjb21tYW5kLiIKQEAgLTMwNjIsNDMgKzMwNzIsNDMgQEAKICJTaWUga8O2bm50ZW4gZGllIFZhcmlhYmxlICVzIGF1ZiBtaW5kZXN0ZW5zICVkIHNldHplbiB1bmQgZGVuIEJlZmVobFxuIgogImVybmV1dCB2ZXJzdWNoZW4uIgogCi0jOiBkaXIuYzo1MzcKKyM6IGRpci5jOjU0OQogIywgYy1mb3JtYXQKIG1zZ2lkICJwYXRoc3BlYyAnJXMnIGRpZCBub3QgbWF0Y2ggYW55IGZpbGUocykga25vd24gdG8gZ2l0IgogbXNnc3RyICIiCiAiUGZhZHNwZXppZmlrYXRpb24gJyVzJyBzdGltbXQgbWl0IGtlaW5lbiBnaXQtYmVrYW5udGVuIERhdGVpZW4gw7xiZXJlaW4uIgogCi0jOiBkaXIuYzo5MjYKKyM6IGRpci5jOjkzOAogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgdXNlICVzIGFzIGFuIGV4Y2x1ZGUgZmlsZSIKIG1zZ3N0ciAiS2FubiAlcyBuaWNodCBhbHMgZXhjbHVkZS1GaWx0ZXIgYmVudXR6ZW4uIgogCi0jOiBkaXIuYzoxODQzCisjOiBkaXIuYzoxODc3CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBvcGVuIGRpcmVjdG9yeSAnJXMnIgogbXNnc3RyICJLb25udGUgVmVyemVpY2huaXMgJyVzJyBuaWNodCDDtmZmbmVuLiIKIAotIzogZGlyLmM6MjA4NQorIzogZGlyLmM6MjEyOAogbXNnaWQgImZhaWxlZCB0byBnZXQga2VybmVsIG5hbWUgYW5kIGluZm9ybWF0aW9uIgogbXNnc3RyICJGZWhsZXIgYmVpbSBTYW1tZWxuIHZvbiBOYW1lbiB1bmQgSW5mb3JtYXRpb25lbiB6dW0gS2VybmVsIgogCi0jOiBkaXIuYzoyMjA5CisjOiBkaXIuYzoyMjUyCiBtc2dpZCAidW50cmFja2VkIGNhY2hlIGlzIGRpc2FibGVkIG9uIHRoaXMgc3lzdGVtIG9yIGxvY2F0aW9uIgogbXNnc3RyICIiCiAiQ2FjaGUgZsO8ciB1bnZlcnNpb25pZXJ0ZSBEYXRlaWVuIGlzdCBhdWYgZGllc2VtIFN5c3RlbSBvZGVyXG4iCiAiZsO8ciBkaWVzZXMgVmVyemVpY2huaXMgZGVha3RpdmllcnQuIgogCi0jOiBkaXIuYzozMDEzCisjOiBkaXIuYzozMDU2CiAjLCBjLWZvcm1hdAogbXNnaWQgImluZGV4IGZpbGUgY29ycnVwdCBpbiByZXBvICVzIgogbXNnc3RyICJJbmRleC1EYXRlaSBpbiBSZXBvc2l0b3J5ICVzIGJlc2Now6RkaWd0LiIKIAotIzogZGlyLmM6MzA1OCBkaXIuYzozMDYzCisjOiBkaXIuYzozMTAxIGRpci5jOjMxMDYKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGNyZWF0ZSBkaXJlY3RvcmllcyBmb3IgJXMiCiBtc2dzdHIgIktvbm50ZSBWZXJ6ZWljaG5pc3NlIGbDvHIgJyVzJyBuaWNodCBlcnN0ZWxsZW4uIgogCi0jOiBkaXIuYzozMDkyCisjOiBkaXIuYzozMTM1CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBtaWdyYXRlIGdpdCBkaXJlY3RvcnkgZnJvbSAnJXMnIHRvICclcyciCiBtc2dzdHIgIktvbm50ZSBHaXQtVmVyemVpY2huaXMgbmljaHQgdm9uICclcycgbmFjaCAnJXMnIG1pZ3JpZXJlbi4iCkBAIC0zMTE3LDEyICszMTI3LDEyIEBACiBtc2dpZCAiY291bGQgbm90IHN0YXQgZmlsZSAnJXMnIgogbXNnc3RyICJLb25udGUgRGF0ZWkgJyVzJyBuaWNodCBsZXNlbi4iCiAKLSM6IGVudmlyb25tZW50LmM6MTUwCisjOiBlbnZpcm9ubWVudC5jOjE0OAogIywgYy1mb3JtYXQKIG1zZ2lkICJiYWQgZ2l0IG5hbWVzcGFjZSBwYXRoIFwiJXNcIiIKIG1zZ3N0ciAiVW5nw7xsdGlnZXIgR2l0LU5hbWVzcGFjZS1QZmFkIFwiJXNcIiIKIAotIzogZW52aXJvbm1lbnQuYzozMzIKKyM6IGVudmlyb25tZW50LmM6MzMwCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBzZXQgR0lUX0RJUiB0byAnJXMnIgogbXNnc3RyICJLb25udGUgR0lUX0RJUiBuaWNodCB6dSAnJXMnIHNldHplbi4iCkBAIC0zMTMyLDE1OCArMzE0MiwxNTQgQEAKIG1zZ2lkICJ0b28gbWFueSBhcmdzIHRvIHJ1biAlcyIKIG1zZ3N0ciAiWnUgdmllbGUgQXJndW1lbnRlIGFuZ2VnZWJlbiwgdW0gJXMgYXVzenVmw7xocmVuLiIKIAotIzogZmV0Y2gtb2JqZWN0LmM6MTcKLW1zZ2lkICJSZW1vdGUgd2l0aCBubyBVUkwiCi1tc2dzdHIgIlJlbW90ZS1SZXBvc2l0b3J5IG9obmUgVVJMIgotCi0jOiBmZXRjaC1wYWNrLmM6MTUxCisjOiBmZXRjaC1wYWNrLmM6MTUwCiBtc2dpZCAiZ2l0IGZldGNoLXBhY2s6IGV4cGVjdGVkIHNoYWxsb3cgbGlzdCIKIG1zZ3N0ciAiZ2l0IGZldGNoLXBhY2s6IGVyd2FydGV0ZSBzaGFsbG93LUxpc3RlIgogCi0jOiBmZXRjaC1wYWNrLmM6MTU0CisjOiBmZXRjaC1wYWNrLmM6MTUzCiBtc2dpZCAiZ2l0IGZldGNoLXBhY2s6IGV4cGVjdGVkIGEgZmx1c2ggcGFja2V0IGFmdGVyIHNoYWxsb3cgbGlzdCIKIG1zZ3N0ciAiZ2l0IGZldGNoLXBhY2s6IGVyd2FydGV0ZSBlaW4gRmx1c2gtUGFrZXQgbmFjaCBkZXIgc2hhbGxvdy1MaXN0ZSIKIAotIzogZmV0Y2gtcGFjay5jOjE2NQorIzogZmV0Y2gtcGFjay5jOjE2NAogbXNnaWQgImdpdCBmZXRjaC1wYWNrOiBleHBlY3RlZCBBQ0svTkFLLCBnb3QgYSBmbHVzaCBwYWNrZXQiCiBtc2dzdHIgImdpdCBmZXRjaC1wYWNrOiBBQ0svTkFLIGVyd2FydGV0LCBGbHVzaC1QYWtldCBiZWtvbW1lbiIKIAotIzogZmV0Y2gtcGFjay5jOjE4NQorIzogZmV0Y2gtcGFjay5jOjE4NAogIywgYy1mb3JtYXQKIG1zZ2lkICJnaXQgZmV0Y2gtcGFjazogZXhwZWN0ZWQgQUNLL05BSywgZ290ICclcyciCiBtc2dzdHIgImdpdCBmZXRjaC1wYWNrOiBBQ0svTkFLIGVyd2FydGV0LCAnJXMnIGJla29tbWVuIgogCi0jOiBmZXRjaC1wYWNrLmM6MTk2CisjOiBmZXRjaC1wYWNrLmM6MTk1CiBtc2dpZCAidW5hYmxlIHRvIHdyaXRlIHRvIHJlbW90ZSIKIG1zZ3N0ciAia29ubnRlIG5pY2h0IHp1bSBSZW1vdGUgc2NocmVpYmVuIgogCi0jOiBmZXRjaC1wYWNrLmM6MjU4CisjOiBmZXRjaC1wYWNrLmM6MjU3CiBtc2dpZCAiLS1zdGF0ZWxlc3MtcnBjIHJlcXVpcmVzIG11bHRpX2Fja19kZXRhaWxlZCIKIG1zZ3N0ciAiLS1zdGF0ZWxlc3MtcnBjIGJlbsO2dGlndCBtdWx0aV9hY2tfZGV0YWlsZWQiCiAKLSM6IGZldGNoLXBhY2suYzozNjAgZmV0Y2gtcGFjay5jOjEyODQKKyM6IGZldGNoLXBhY2suYzozNTYgZmV0Y2gtcGFjay5jOjEyODAKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBzaGFsbG93IGxpbmU6ICVzIgogbXNnc3RyICJVbmfDvGx0aWdlIHNoYWxsb3ctWmVpbGU6ICVzIgogCi0jOiBmZXRjaC1wYWNrLmM6MzY2IGZldGNoLXBhY2suYzoxMjkwCisjOiBmZXRjaC1wYWNrLmM6MzYyIGZldGNoLXBhY2suYzoxMjg2CiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgdW5zaGFsbG93IGxpbmU6ICVzIgogbXNnc3RyICJVbmfDvGx0aWdlIHVuc2hhbGxvdy1aZWlsZTogJXMiCiAKLSM6IGZldGNoLXBhY2suYzozNjggZmV0Y2gtcGFjay5jOjEyOTIKKyM6IGZldGNoLXBhY2suYzozNjQgZmV0Y2gtcGFjay5jOjEyODgKICMsIGMtZm9ybWF0CiBtc2dpZCAib2JqZWN0IG5vdCBmb3VuZDogJXMiCiBtc2dzdHIgIk9iamVrdCBuaWNodCBnZWZ1bmRlbjogJXMiCiAKLSM6IGZldGNoLXBhY2suYzozNzEgZmV0Y2gtcGFjay5jOjEyOTUKKyM6IGZldGNoLXBhY2suYzozNjcgZmV0Y2gtcGFjay5jOjEyOTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiZXJyb3IgaW4gb2JqZWN0OiAlcyIKIG1zZ3N0ciAiRmVobGVyIGluIE9iamVrdDogJXMiCiAKLSM6IGZldGNoLXBhY2suYzozNzMgZmV0Y2gtcGFjay5jOjEyOTcKKyM6IGZldGNoLXBhY2suYzozNjkgZmV0Y2gtcGFjay5jOjEyOTMKICMsIGMtZm9ybWF0CiBtc2dpZCAibm8gc2hhbGxvdyBmb3VuZDogJXMiCiBtc2dzdHIgIktlaW4gc2hhbGxvdy1PYmpla3QgZ2VmdW5kZW46ICVzIgogCi0jOiBmZXRjaC1wYWNrLmM6Mzc2IGZldGNoLXBhY2suYzoxMzAxCisjOiBmZXRjaC1wYWNrLmM6MzcyIGZldGNoLXBhY2suYzoxMjk3CiAjLCBjLWZvcm1hdAogbXNnaWQgImV4cGVjdGVkIHNoYWxsb3cvdW5zaGFsbG93LCBnb3QgJXMiCiBtc2dzdHIgInNoYWxsb3cvdW5zaGFsbG93IGVyd2FydGV0LCAlcyBiZWtvbW1lbiIKIAotIzogZmV0Y2gtcGFjay5jOjQxNworIzogZmV0Y2gtcGFjay5jOjQxNAogIywgYy1mb3JtYXQKIG1zZ2lkICJnb3QgJXMgJWQgJXMiCiBtc2dzdHIgIiVzICVkICVzIGJla29tbWVuIgogCi0jOiBmZXRjaC1wYWNrLmM6NDM0CisjOiBmZXRjaC1wYWNrLmM6NDMxCiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgY29tbWl0ICVzIgogbXNnc3RyICJVbmfDvGx0aWdlciBDb21taXQgJXMiCiAKLSM6IGZldGNoLXBhY2suYzo0NjUKKyM6IGZldGNoLXBhY2suYzo0NjIKIG1zZ2lkICJnaXZpbmcgdXAiCiBtc2dzdHIgIkdlYmUgYXVmIgogCi0jOiBmZXRjaC1wYWNrLmM6NDc3IHByb2dyZXNzLmM6Mjc3CisjOiBmZXRjaC1wYWNrLmM6NDc1IHByb2dyZXNzLmM6MzEyCiBtc2dpZCAiZG9uZSIKIG1zZ3N0ciAiRmVydGlnIgogCi0jOiBmZXRjaC1wYWNrLmM6NDg5CisjOiBmZXRjaC1wYWNrLmM6NDg3CiAjLCBjLWZvcm1hdAogbXNnaWQgImdvdCAlcyAoJWQpICVzIgogbXNnc3RyICIlcyAoJWQpICVzIGJla29tbWVuIgogCi0jOiBmZXRjaC1wYWNrLmM6NTM1CisjOiBmZXRjaC1wYWNrLmM6NTMzCiAjLCBjLWZvcm1hdAogbXNnaWQgIk1hcmtpbmcgJXMgYXMgY29tcGxldGUiCiBtc2dzdHIgIk1hcmtpZXJlICVzIGFscyB2b2xsc3TDpG5kaWciCiAKLSM6IGZldGNoLXBhY2suYzo3NDQKKyM6IGZldGNoLXBhY2suYzo3NDIKICMsIGMtZm9ybWF0CiBtc2dpZCAiYWxyZWFkeSBoYXZlICVzICglcykiCiBtc2dzdHIgImhhYmUgJXMgKCVzKSBiZXJlaXRzIgogCi0jOiBmZXRjaC1wYWNrLmM6NzgzCisjOiBmZXRjaC1wYWNrLmM6NzgxCiBtc2dpZCAiZmV0Y2gtcGFjazogdW5hYmxlIHRvIGZvcmsgb2ZmIHNpZGViYW5kIGRlbXVsdGlwbGV4ZXIiCiBtc2dzdHIgImZldGNoLXBhY2s6IEZlaGxlciBiZWltIFN0YXJ0ZW4gZGVzIHNpZGViYW5kIGRlbXVsdGlwbGV4ZXIiCiAKLSM6IGZldGNoLXBhY2suYzo3OTEKKyM6IGZldGNoLXBhY2suYzo3ODkKIG1zZ2lkICJwcm90b2NvbCBlcnJvcjogYmFkIHBhY2sgaGVhZGVyIgogbXNnc3RyICJQcm90b2tvbGxmZWhsZXI6IHVuZ8O8bHRpZ2VyIFBhY2stSGVhZGVyIgogCi0jOiBmZXRjaC1wYWNrLmM6ODU5CisjOiBmZXRjaC1wYWNrLmM6ODU3CiAjLCBjLWZvcm1hdAogbXNnaWQgImZldGNoLXBhY2s6IHVuYWJsZSB0byBmb3JrIG9mZiAlcyIKIG1zZ3N0ciAiZmV0Y2gtcGFjazoga29ubnRlICVzIG5pY2h0IHN0YXJ0ZW4iCiAKLSM6IGZldGNoLXBhY2suYzo4NzUKKyM6IGZldGNoLXBhY2suYzo4NzMKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgZmFpbGVkIgogbXNnc3RyICIlcyBmZWhsZ2VzY2hsYWdlbiIKIAotIzogZmV0Y2gtcGFjay5jOjg3NworIzogZmV0Y2gtcGFjay5jOjg3NQogbXNnaWQgImVycm9yIGluIHNpZGViYW5kIGRlbXVsdGlwbGV4ZXIiCiBtc2dzdHIgIkZlaGxlciBpbiBzaWRlYmFuZCBkZW11bHRpcGxleGVyIgogCi0jOiBmZXRjaC1wYWNrLmM6OTA4CisjOiBmZXRjaC1wYWNrLmM6OTA3CiAjLCBjLWZvcm1hdAogbXNnaWQgIlNlcnZlciB2ZXJzaW9uIGlzICUuKnMiCiBtc2dzdHIgIlNlcnZlci1WZXJzaW9uIGlzdCAlLipzIgogCi0jOiBmZXRjaC1wYWNrLmM6OTEzIGZldGNoLXBhY2suYzo5MTkgZmV0Y2gtcGFjay5jOjkyMiBmZXRjaC1wYWNrLmM6OTI4Ci0jOiBmZXRjaC1wYWNrLmM6OTMyIGZldGNoLXBhY2suYzo5MzYgZmV0Y2gtcGFjay5jOjk0MCBmZXRjaC1wYWNrLmM6OTQ0Ci0jOiBmZXRjaC1wYWNrLmM6OTQ4IGZldGNoLXBhY2suYzo5NTIgZmV0Y2gtcGFjay5jOjk1NiBmZXRjaC1wYWNrLmM6OTYwCi0jOiBmZXRjaC1wYWNrLmM6OTY2IGZldGNoLXBhY2suYzo5NzIgZmV0Y2gtcGFjay5jOjk3NyBmZXRjaC1wYWNrLmM6OTgyCisjOiBmZXRjaC1wYWNrLmM6OTEyIGZldGNoLXBhY2suYzo5MTggZmV0Y2gtcGFjay5jOjkyMSBmZXRjaC1wYWNrLmM6OTI3CisjOiBmZXRjaC1wYWNrLmM6OTMxIGZldGNoLXBhY2suYzo5MzUgZmV0Y2gtcGFjay5jOjkzOSBmZXRjaC1wYWNrLmM6OTQzCisjOiBmZXRjaC1wYWNrLmM6OTQ3IGZldGNoLXBhY2suYzo5NTEgZmV0Y2gtcGFjay5jOjk1NSBmZXRjaC1wYWNrLmM6OTU5CisjOiBmZXRjaC1wYWNrLmM6OTY1IGZldGNoLXBhY2suYzo5NzEgZmV0Y2gtcGFjay5jOjk3NiBmZXRjaC1wYWNrLmM6OTgxCiAjLCBjLWZvcm1hdAogbXNnaWQgIlNlcnZlciBzdXBwb3J0cyAlcyIKIG1zZ3N0ciAiU2VydmVyIHVudGVyc3TDvHR6dCAlcyIKIAotIzogZmV0Y2gtcGFjay5jOjkxNQorIzogZmV0Y2gtcGFjay5jOjkxNAogbXNnaWQgIlNlcnZlciBkb2VzIG5vdCBzdXBwb3J0IHNoYWxsb3cgY2xpZW50cyIKIG1zZ3N0ciAiU2VydmVyIHVudGVyc3TDvHR6dCBrZWluZSBzaGFsbG93LUNsaWVudHMiCiAKLSM6IGZldGNoLXBhY2suYzo5NzUKKyM6IGZldGNoLXBhY2suYzo5NzQKIG1zZ2lkICJTZXJ2ZXIgZG9lcyBub3Qgc3VwcG9ydCAtLXNoYWxsb3ctc2luY2UiCiBtc2dzdHIgIlNlcnZlciB1bnRlcnN0w7x0enQga2VpbiAtLXNoYWxsb3ctc2luY2UiCiAKLSM6IGZldGNoLXBhY2suYzo5ODAKKyM6IGZldGNoLXBhY2suYzo5NzkKIG1zZ2lkICJTZXJ2ZXIgZG9lcyBub3Qgc3VwcG9ydCAtLXNoYWxsb3ctZXhjbHVkZSIKIG1zZ3N0ciAiU2VydmVyIHVudGVyc3TDvHR6dCBrZWluIC0tc2hhbGxvdy1leGNsdWRlIgogCi0jOiBmZXRjaC1wYWNrLmM6OTg0CisjOiBmZXRjaC1wYWNrLmM6OTgzCiBtc2dpZCAiU2VydmVyIGRvZXMgbm90IHN1cHBvcnQgLS1kZWVwZW4iCiBtc2dzdHIgIlNlcnZlciB1bnRlcnN0w7x0enQga2VpbiAtLWRlZXBlbiIKIAotIzogZmV0Y2gtcGFjay5jOjEwMDEKKyM6IGZldGNoLXBhY2suYzoxMDAwCiBtc2dpZCAibm8gY29tbW9uIGNvbW1pdHMiCiBtc2dzdHIgImtlaW5lIGdlbWVpbnNhbWVuIENvbW1pdHMiCiAKLSM6IGZldGNoLXBhY2suYzoxMDEzIGZldGNoLXBhY2suYzoxNDYyCisjOiBmZXRjaC1wYWNrLmM6MTAxMiBmZXRjaC1wYWNrLmM6MTQ2OAogbXNnaWQgImdpdCBmZXRjaC1wYWNrOiBmZXRjaCBmYWlsZWQuIgogbXNnc3RyICJnaXQgZmV0Y2gtcGFjazogQWJob2xlbiBmZWhsZ2VzY2hsYWdlbi4iCiAKLSM6IGZldGNoLXBhY2suYzoxMTUxCisjOiBmZXRjaC1wYWNrLmM6MTE1MAogbXNnaWQgIlNlcnZlciBkb2VzIG5vdCBzdXBwb3J0IHNoYWxsb3cgcmVxdWVzdHMiCiBtc2dzdHIgIlNlcnZlciB1bnRlcnN0w7x0enQga2VpbmUgc2hhbGxvdy1BbmZyYWdlbi4iCiAKQEAgLTMyOTEsNzIgKzMyOTcsNzIgQEAKIG1zZ2lkICJTZXJ2ZXIgc3VwcG9ydHMgZmlsdGVyIgogbXNnc3RyICJTZXJ2ZXIgdW50ZXJzdMO8dHp0IEZpbHRlciIKIAotIzogZmV0Y2gtcGFjay5jOjExODQKKyM6IGZldGNoLXBhY2suYzoxMTgwCiBtc2dpZCAidW5hYmxlIHRvIHdyaXRlIHJlcXVlc3QgdG8gcmVtb3RlIgogbXNnc3RyICJrb25udGUgQW5mcmFnZSBuaWNodCB6dW0gUmVtb3RlIHNjaHJlaWJlbiIKIAotIzogZmV0Y2gtcGFjay5jOjEyMDIKKyM6IGZldGNoLXBhY2suYzoxMTk4CiAjLCBjLWZvcm1hdAogbXNnaWQgImVycm9yIHJlYWRpbmcgc2VjdGlvbiBoZWFkZXIgJyVzJyIKIG1zZ3N0ciAiRmVobGVyIGJlaW0gTGVzZW4gdm9uIFNla3Rpb25za29wZiAnJXMnLiIKIAotIzogZmV0Y2gtcGFjay5jOjEyMDgKKyM6IGZldGNoLXBhY2suYzoxMjA0CiAjLCBjLWZvcm1hdAogbXNnaWQgImV4cGVjdGVkICclcycsIHJlY2VpdmVkICclcyciCiBtc2dzdHIgIiclcycgZXJ3YXJ0ZXQsICclcycgZW1wZmFuZ2VuIgogCi0jOiBmZXRjaC1wYWNrLmM6MTI0NworIzogZmV0Y2gtcGFjay5jOjEyNDMKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5leHBlY3RlZCBhY2tub3dsZWRnbWVudCBsaW5lOiAnJXMnIgogbXNnc3RyICJVbmVyd2FydGV0ZSBBY2tub3dsZWRnbWVudC1aZWlsZTogJyVzJyIKIAotIzogZmV0Y2gtcGFjay5jOjEyNTIKKyM6IGZldGNoLXBhY2suYzoxMjQ4CiAjLCBjLWZvcm1hdAogbXNnaWQgImVycm9yIHByb2Nlc3NpbmcgYWNrczogJWQiCiBtc2dzdHIgIkZlaGxlciBiZWltIFZlcmFyYmVpdGVuIHZvbiBBQ0tTOiAlZCIKIAotIzogZmV0Y2gtcGFjay5jOjEyNjIKKyM6IGZldGNoLXBhY2suYzoxMjU4CiBtc2dpZCAiZXhwZWN0ZWQgcGFja2ZpbGUgdG8gYmUgc2VudCBhZnRlciAncmVhZHknIgogbXNnc3RyICJFcndhcnRldGUgVmVyc2FuZCBlaW5lciBQYWNrZGF0ZWkgbmFjaCAncmVhZHknLiIKIAotIzogZmV0Y2gtcGFjay5jOjEyNjQKKyM6IGZldGNoLXBhY2suYzoxMjYwCiBtc2dpZCAiZXhwZWN0ZWQgbm8gb3RoZXIgc2VjdGlvbnMgdG8gYmUgc2VudCBhZnRlciBubyAncmVhZHknIgogbXNnc3RyICJFcndhcnRldGUga2VpbmVuIFZlcnNhbmQgZWluZXIgYW5kZXJlbiBTZWt0aW9uIG9obmUgJ3JlYWR5Jy4iCiAKLSM6IGZldGNoLXBhY2suYzoxMzA2CisjOiBmZXRjaC1wYWNrLmM6MTMwMgogIywgYy1mb3JtYXQKIG1zZ2lkICJlcnJvciBwcm9jZXNzaW5nIHNoYWxsb3cgaW5mbzogJWQiCiBtc2dzdHIgIkZlaGxlciBiZWltIFZlcmFyYmVpdGVuIHZvbiBTaGFsbG93LUluZm9ybWF0aW9uZW46ICVkIgogCi0jOiBmZXRjaC1wYWNrLmM6MTM1MworIzogZmV0Y2gtcGFjay5jOjEzNDkKICMsIGMtZm9ybWF0CiBtc2dpZCAiZXhwZWN0ZWQgd2FudGVkLXJlZiwgZ290ICclcyciCiBtc2dzdHIgIndhbnRlZC1yZWYgZXJ3YXJ0ZXQsICclcycgYmVrb21tZW4iCiAKLSM6IGZldGNoLXBhY2suYzoxMzU4CisjOiBmZXRjaC1wYWNrLmM6MTM1NAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmV4cGVjdGVkIHdhbnRlZC1yZWY6ICclcyciCiBtc2dzdHIgIlVuZXJ3YXJ0ZXRlcyB3YW50ZWQtcmVmOiAnJXMnIgogCi0jOiBmZXRjaC1wYWNrLmM6MTM2MworIzogZmV0Y2gtcGFjay5jOjEzNTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiZXJyb3IgcHJvY2Vzc2luZyB3YW50ZWQgcmVmczogJWQiCiBtc2dzdHIgIkZlaGxlciBiZWltIFZlcmFyYmVpdGVuIHZvbiB3YW50ZWQtcmVmczogJWQiCiAKLSM6IGZldGNoLXBhY2suYzoxNjg5CisjOiBmZXRjaC1wYWNrLmM6MTY5MwogbXNnaWQgIm5vIG1hdGNoaW5nIHJlbW90ZSBoZWFkIgogbXNnc3RyICJrZWluIMO8YmVyZWluc3RpbW1lbmRlciBSZW1vdGUtQnJhbmNoIgogCi0jOiBmZXRjaC1wYWNrLmM6MTcxMiBidWlsdGluL2Nsb25lLmM6Njg2CisjOiBmZXRjaC1wYWNrLmM6MTcxNiBidWlsdGluL2Nsb25lLmM6Njg1CiBtc2dpZCAicmVtb3RlIGRpZCBub3Qgc2VuZCBhbGwgbmVjZXNzYXJ5IG9iamVjdHMiCiBtc2dzdHIgIlJlbW90ZS1SZXBvc2l0b3J5IGhhdCBuaWNodCBhbGxlIGVyZm9yZGVybGljaGVuIE9iamVrdGUgZ2VzZW5kZXQuIgogCi0jOiBmZXRjaC1wYWNrLmM6MTczOQorIzogZmV0Y2gtcGFjay5jOjE3NDMKICMsIGMtZm9ybWF0CiBtc2dpZCAibm8gc3VjaCByZW1vdGUgcmVmICVzIgogbXNnc3RyICJrZWluZSBzb2xjaGUgUmVtb3RlLVJlZmVyZW56ICVzIgogCi0jOiBmZXRjaC1wYWNrLmM6MTc0MgorIzogZmV0Y2gtcGFjay5jOjE3NDYKICMsIGMtZm9ybWF0CiBtc2dpZCAiU2VydmVyIGRvZXMgbm90IGFsbG93IHJlcXVlc3QgZm9yIHVuYWR2ZXJ0aXNlZCBvYmplY3QgJXMiCiBtc2dzdHIgIkRlciBTZXJ2ZXIgbGVobnQgQW5mcmFnZSBuYWNoIG5pY2h0IGFuZ2Vib3RlbmVtIE9iamVrdCAlcyBhYi4iCkBAIC0zMzc5LDE4ICszMzg1LDI2IEBACiBtc2dpZCAiaWdub3JlIGludmFsaWQgY29sb3IgJyUuKnMnIGluIGxvZy5ncmFwaENvbG9ycyIKIG1zZ3N0ciAiSWdub3JpZXJlIHVuZ8O8bHRpZ2UgRmFyYmUgJyUuKnMnIGluIGxvZy5ncmFwaENvbG9ycyIKIAotIzogZ3JlcC5jOjIxMTcKKyM6IGdyZXAuYzo2NjgKK21zZ2lkICIiCisiZ2l2ZW4gcGF0dGVybiBjb250YWlucyBOVUxMIGJ5dGUgKHZpYSAtZiA8ZmlsZT4pLiBUaGlzIGlzIG9ubHkgc3VwcG9ydGVkICIKKyJ3aXRoIC1QIHVuZGVyIFBDUkUgdjIiCittc2dzdHIgIiIKKyJBbmdlZ2ViZW5lcyBNdXN0ZXIgZW50aMOkbHQgTlVMTCBCeXRlICjDvGJlciAtZiA8RGF0ZWk+KS4gRGFzIHdpcmQgbnVyIG1pdCAtUCIKKyJ1bnRlciBQQ1JFIHYyIHVudGVyc3TDvHR6dC4iCisKKyM6IGdyZXAuYzoyMTI0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiclcyc6IHVuYWJsZSB0byByZWFkICVzIgogbXNnc3RyICInJXMnOiBrb25udGUgJXMgbmljaHQgbGVzZW4iCiAKLSM6IGdyZXAuYzoyMTM0IHNldHVwLmM6MTY0IGJ1aWx0aW4vY2xvbmUuYzo0MDkgYnVpbHRpbi9kaWZmLmM6ODIKKyM6IGdyZXAuYzoyMTQxIHNldHVwLmM6MTY1IGJ1aWx0aW4vY2xvbmUuYzo0MDggYnVpbHRpbi9kaWZmLmM6ODIKICM6IGJ1aWx0aW4vcm0uYzoxMzUKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIHN0YXQgJyVzJyIKIG1zZ3N0ciAiS29ubnRlICclcycgbmljaHQgbGVzZW4iCiAKLSM6IGdyZXAuYzoyMTQ1CisjOiBncmVwLmM6MjE1MgogIywgYy1mb3JtYXQKIG1zZ2lkICInJXMnOiBzaG9ydCByZWFkIgogbXNnc3RyICInJXMnOiByZWFkKCkgenUga3VyeiIKQEAgLTM1MzUsMTIgKzM1NDksMTIgQEAKIG1zZ2lkICJnaXQgdmVyc2lvbiBbPG9wdGlvbnM+XSIKIG1zZ3N0ciAiZ2l0IHZlcnNpb24gWzxPcHRpb25lbj5dIgogCi0jOiBoZWxwLmM6NzgyCisjOiBoZWxwLmM6NzgzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiAlcyAtICVzIgogbXNnc3RyICIlczogJXMgLSAlcyIKIAotIzogaGVscC5jOjc4NgorIzogaGVscC5jOjc4NwogbXNnaWQgIiIKICJcbiIKICJEaWQgeW91IG1lYW4gdGhpcz8iCkBAIC0zNjEzLDQyICszNjI3LDU3IEBACiBtc2dpZCAiaW52YWxpZCBkYXRlIGZvcm1hdDogJXMiCiBtc2dzdHIgIlVuZ8O8bHRpZ2VzIERhdHVtc2Zvcm1hdDogJXMiCiAKLSM6IGxpc3Qtb2JqZWN0cy5jOjEyOQorIzogbGlzdC1vYmplY3RzLmM6MTI3CiAjLCBjLWZvcm1hdAogbXNnaWQgImVudHJ5ICclcycgaW4gdHJlZSAlcyBoYXMgdHJlZSBtb2RlLCBidXQgaXMgbm90IGEgdHJlZSIKIG1zZ3N0ciAiIgogIkVpbnRyYWcgJyVzJyBpbSBUcmVlLU9iamVrdCAlcyBoYXQgVHJlZS1Nb2R1cywgYWJlciBpc3Qga2VpbiBUcmVlLU9iamVrdCIKIAotIzogbGlzdC1vYmplY3RzLmM6MTQyCisjOiBsaXN0LW9iamVjdHMuYzoxNDAKICMsIGMtZm9ybWF0CiBtc2dpZCAiZW50cnkgJyVzJyBpbiB0cmVlICVzIGhhcyBibG9iIG1vZGUsIGJ1dCBpcyBub3QgYSBibG9iIgogbXNnc3RyICJFaW50cmFnICclcycgaW0gVHJlZS1PYmpla3QgJXMgaGF0IEJsb2ItTW9kdXMsIGFiZXIgaXN0IGtlaW4gQmxvYiIKIAotIzogbGlzdC1vYmplY3RzLmM6Mzc4CisjOiBsaXN0LW9iamVjdHMuYzozNzUKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGxvYWQgcm9vdCB0cmVlIGZvciBjb21taXQgJXMiCiBtc2dzdHIgIktvbm50ZSBSb290LVRyZWUtT2JqZWt0IGbDvHIgQ29tbWl0ICVzIG5pY2h0IGxhZGVuLiIKIAotIzogbGlzdC1vYmplY3RzLWZpbHRlci1vcHRpb25zLmM6MzYKLW1zZ2lkICJtdWx0aXBsZSBmaWx0ZXItc3BlY3MgY2Fubm90IGJlIGNvbWJpbmVkIgotbXNnc3RyICJNZWhyZXJlIGZpbHRlci1zcGVjcyBrw7ZubmVuIG5pY2h0IGtvbWJpbmllcnQgd2VyZGVuLiIKKyM6IGxpc3Qtb2JqZWN0cy1maWx0ZXIuYzo0OTIKKyMsIGMtZm9ybWF0Cittc2dpZCAidW5hYmxlIHRvIGFjY2VzcyBzcGFyc2UgYmxvYiBpbiAnJXMnIgorbXNnc3RyICJrb25udGUgbmljaHQgYXVmIHBhcnRpZWxsZW4gQmxvYiAnJXMnIHp1Z3JlaWZlbiIKKworIzogbGlzdC1vYmplY3RzLWZpbHRlci5jOjQ5NQorIywgYy1mb3JtYXQKK21zZ2lkICJ1bmFibGUgdG8gcGFyc2Ugc3BhcnNlIGZpbHRlciBkYXRhIGluICVzIgorbXNnc3RyICJLb25udGUgcGFydGllbGxlIEZpbHRlci1EYXRlbiBpbiAlcyBuaWNodCBwYXJzZW4uIgogCiAjOiBsaXN0LW9iamVjdHMtZmlsdGVyLW9wdGlvbnMuYzo1OAogbXNnaWQgImV4cGVjdGVkICd0cmVlOjxkZXB0aD4nIgogbXNnc3RyICIndHJlZTo8VGllZmU+JyBlcndhcnRldCIKIAotIzogbGlzdC1vYmplY3RzLWZpbHRlci1vcHRpb25zLmM6ODQKKyM6IGxpc3Qtb2JqZWN0cy1maWx0ZXItb3B0aW9ucy5jOjczCiBtc2dpZCAic3BhcnNlOnBhdGggZmlsdGVycyBzdXBwb3J0IGhhcyBiZWVuIGRyb3BwZWQiCiBtc2dzdHIgIktlaW5lIFVudGVyc3TDvHR6dW5nIGbDvHIgc3BhcnNlOnBhdGggRmlsdGVyIG1laHIiCiAKLSM6IGxpc3Qtb2JqZWN0cy1maWx0ZXItb3B0aW9ucy5jOjk0CisjOiBsaXN0LW9iamVjdHMtZmlsdGVyLW9wdGlvbnMuYzo4NgogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIGZpbHRlci1zcGVjICclcyciCiBtc2dzdHIgIlVuZ8O8bHRpZ2UgZmlsdGVyLXNwZWMgJyVzJyIKIAotIzogbGlzdC1vYmplY3RzLWZpbHRlci1vcHRpb25zLmM6MTU4Ci1tc2dpZCAiY2Fubm90IGNoYW5nZSBwYXJ0aWFsIGNsb25lIHByb21pc29yIHJlbW90ZSIKLW1zZ3N0ciAiS2FubiBSZW1vdGUtUmVwb3NpdG9yeSBmw7xyIHBhcnRpZWxsZXMgS2xvbmVuIG5pY2h0IMOkbmRlcm4uIgorIzogbGlzdC1vYmplY3RzLWZpbHRlci1vcHRpb25zLmM6MTAyCisjLCBjLWZvcm1hdAorbXNnaWQgIm11c3QgZXNjYXBlIGNoYXIgaW4gc3ViLWZpbHRlci1zcGVjOiAnJWMnIgorbXNnc3RyICJaZWljaGVuIGluIHN1Yi1maWx0ZXItc3BlYyBtdXNzIG1hc2tpZXJ0IHdlcmRlbjogJyVjJyIKKworIzogbGlzdC1vYmplY3RzLWZpbHRlci1vcHRpb25zLmM6MTQ0Cittc2dpZCAiZXhwZWN0ZWQgc29tZXRoaW5nIGFmdGVyIGNvbWJpbmU6IgorbXNnc3RyICJlcndhcnRldGUgZXR3YXMgbmFjaCAnY29tYmluZTonIgorCisjOiBsaXN0LW9iamVjdHMtZmlsdGVyLW9wdGlvbnMuYzoyMjYKK21zZ2lkICJtdWx0aXBsZSBmaWx0ZXItc3BlY3MgY2Fubm90IGJlIGNvbWJpbmVkIgorbXNnc3RyICJNZWhyZXJlIGZpbHRlci1zcGVjcyBrw7ZubmVuIG5pY2h0IGtvbWJpbmllcnQgd2VyZGVuLiIKIAogIzogbG9ja2ZpbGUuYzoxNTEKICMsIGMtZm9ybWF0CkBAIC0zNjc5LDExOCArMzcwOCwxMTQgQEAKIG1zZ2lkICJmYWlsZWQgdG8gcmVhZCB0aGUgY2FjaGUiCiBtc2dzdHIgIkxlc2VuIGRlcyBad2lzY2hlbnNwZWljaGVycyBmZWhsZ2VzY2hsYWdlbiIKIAotIzogbWVyZ2UuYzoxMDcgcmVyZXJlLmM6NzIwIGJ1aWx0aW4vYW0uYzoxODg1IGJ1aWx0aW4vYW0uYzoxOTE5Ci0jOiBidWlsdGluL2NoZWNrb3V0LmM6NTM2IGJ1aWx0aW4vY2hlY2tvdXQuYzo3OTYgYnVpbHRpbi9jbG9uZS5jOjc4NgorIzogbWVyZ2UuYzoxMDcgcmVyZXJlLmM6NzIwIGJ1aWx0aW4vYW0uYzoxODc0IGJ1aWx0aW4vYW0uYzoxOTA4CisjOiBidWlsdGluL2NoZWNrb3V0LmM6NTM3IGJ1aWx0aW4vY2hlY2tvdXQuYzo3OTYgYnVpbHRpbi9jbG9uZS5jOjc4NQogIzogYnVpbHRpbi9zdGFzaC5jOjI2NAogbXNnaWQgInVuYWJsZSB0byB3cml0ZSBuZXcgaW5kZXggZmlsZSIKIG1zZ3N0ciAiS29ubnRlIG5ldWUgSW5kZXgtRGF0ZWkgbmljaHQgc2NocmVpYmVuLiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzIyCisjOiBtZXJnZS1yZWN1cnNpdmUuYzozNjcKIG1zZ2lkICIoYmFkIGNvbW1pdClcbiIKIG1zZ3N0ciAiKHVuZ8O8bHRpZ2VyIENvbW1pdClcbiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzQ1CisjOiBtZXJnZS1yZWN1cnNpdmUuYzozOTAKICMsIGMtZm9ybWF0CiBtc2dpZCAiYWRkX2NhY2hlaW5mbyBmYWlsZWQgZm9yIHBhdGggJyVzJzsgbWVyZ2UgYWJvcnRpbmcuIgogbXNnc3RyICJhZGRfY2FjaGVpbmZvIGbDvHIgUGZhZCAnJXMnIGZlaGxnZXNjaGxhZ2VuOyBNZXJnZSB3aXJkIGFiZ2Vicm9jaGVuLiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzU0CisjOiBtZXJnZS1yZWN1cnNpdmUuYzozOTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiYWRkX2NhY2hlaW5mbyBmYWlsZWQgdG8gcmVmcmVzaCBmb3IgcGF0aCAnJXMnOyBtZXJnZSBhYm9ydGluZy4iCiBtc2dzdHIgIiIKICJhZGRfY2FjaGVpbmZvIHp1ciBBa3R1YWxpc2llcnVuZyBmw7xyIFBmYWQgJyVzJyBmZWhsZ2VzY2hsYWdlbjtcbiIKICJNZXJnZSB3aXJkIGFiZ2Vicm9jaGVuLiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6NDM3Ci1tc2dpZCAiZXJyb3IgYnVpbGRpbmcgdHJlZXMiCi1tc2dzdHIgIkZlaGxlciBiZWltIEVyc3RlbGxlbiBkZXIgXCJUcmVlXCItT2JqZWt0ZSIKLQotIzogbWVyZ2UtcmVjdXJzaXZlLmM6ODYzCisjOiBtZXJnZS1yZWN1cnNpdmUuYzo4ODUKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIGNyZWF0ZSBwYXRoICclcyclcyIKIG1zZ3N0ciAiRmVobGVyIGJlaW0gRXJzdGVsbGVuIGRlcyBQZmFkZXMgJyVzJyVzIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzo4NzQKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjg5NgogIywgYy1mb3JtYXQKIG1zZ2lkICJSZW1vdmluZyAlcyB0byBtYWtlIHJvb20gZm9yIHN1YmRpcmVjdG9yeVxuIgogbXNnc3RyICJFbnRmZXJuZSAlcywgdW0gUGxhdHogZsO8ciBVbnRlcnZlcnplaWNobmlzIHp1IHNjaGFmZmVuXG4iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjg4OCBtZXJnZS1yZWN1cnNpdmUuYzo5MDcKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjkxMCBtZXJnZS1yZWN1cnNpdmUuYzo5MjkKIG1zZ2lkICI6IHBlcmhhcHMgYSBEL0YgY29uZmxpY3Q/IgogbXNnc3RyICI6IHZpZWxsZWljaHQgZWluIFZlcnplaWNobmlzL0RhdGVpLUtvbmZsaWt0PyIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6ODk3CisjOiBtZXJnZS1yZWN1cnNpdmUuYzo5MTkKICMsIGMtZm9ybWF0CiBtc2dpZCAicmVmdXNpbmcgdG8gbG9zZSB1bnRyYWNrZWQgZmlsZSBhdCAnJXMnIgogbXNnc3RyICJ2ZXJ3ZWlnZXJlLCBkYSB1bnZlcnNpb25pZXJ0ZSBEYXRlaWVuIGluICclcycgdmVybG9yZW4gZ2VoZW4gd8O8cmRlbiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6OTM4IGJ1aWx0aW4vY2F0LWZpbGUuYzo0MAorIzogbWVyZ2UtcmVjdXJzaXZlLmM6OTYwIGJ1aWx0aW4vY2F0LWZpbGUuYzo0MQogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgcmVhZCBvYmplY3QgJXMgJyVzJyIKIG1zZ3N0ciAia2FubiBPYmpla3QgJXMgJyVzJyBuaWNodCBsZXNlbiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6OTQxCisjOiBtZXJnZS1yZWN1cnNpdmUuYzo5NjUKICMsIGMtZm9ybWF0CiBtc2dpZCAiYmxvYiBleHBlY3RlZCBmb3IgJXMgJyVzJyIKIG1zZ3N0ciAiQmxvYiBlcndhcnRldCBmw7xyICVzICclcyciCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjk2NQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6OTkwCiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBvcGVuICclcyc6ICVzIgogbXNnc3RyICJGZWhsZXIgYmVpbSDDlmZmbmVuIHZvbiAnJXMnOiAlcyIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6OTc2CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxMDAxCiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBzeW1saW5rICclcyc6ICVzIgogbXNnc3RyICJGZWhsZXIgYmVpbSBFcnN0ZWxsZW4gZWluZXIgc3ltYm9saXNjaGVuIFZlcmtuw7xwZnVuZyBmw7xyICclcyc6ICVzIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzo5ODEKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEwMDYKICMsIGMtZm9ybWF0CiBtc2dpZCAiZG8gbm90IGtub3cgd2hhdCB0byBkbyB3aXRoICUwNm8gJXMgJyVzJyIKIG1zZ3N0ciAid2Vpw58gbmljaHQgd2FzIG1pdCAlMDZvICVzICclcycgenUgbWFjaGVuIGlzdCIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTE3NworIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTE5OQogIywgYy1mb3JtYXQKIG1zZ2lkICJGYWlsZWQgdG8gbWVyZ2Ugc3VibW9kdWxlICVzIChub3QgY2hlY2tlZCBvdXQpIgogbXNnc3RyICJGZWhsZXIgYmVpbSBNZXJnZSB2b24gU3VibW9kdWwgJXMgKG5pY2h0IGF1c2dlY2hlY2t0KS4iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjExODQKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEyMDYKICMsIGMtZm9ybWF0CiBtc2dpZCAiRmFpbGVkIHRvIG1lcmdlIHN1Ym1vZHVsZSAlcyAoY29tbWl0cyBub3QgcHJlc2VudCkiCiBtc2dzdHIgIkZlaGxlciBiZWltIE1lcmdlIHZvbiBTdWJtb2R1bCAlcyAoQ29tbWl0cyBuaWNodCB2b3JoYW5kZW4pLiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTE5MQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTIxMwogIywgYy1mb3JtYXQKIG1zZ2lkICJGYWlsZWQgdG8gbWVyZ2Ugc3VibW9kdWxlICVzIChjb21taXRzIGRvbid0IGZvbGxvdyBtZXJnZS1iYXNlKSIKIG1zZ3N0ciAiRmVobGVyIGJlaW0gTWVyZ2Ugdm9uIFN1Ym1vZHVsICVzIChDb21taXRzIGZvbGdlbiBrZWluZXIgTWVyZ2UtQmFzaXMpIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxMTk5IG1lcmdlLXJlY3Vyc2l2ZS5jOjEyMTEKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEyMjEgbWVyZ2UtcmVjdXJzaXZlLmM6MTIzMwogIywgYy1mb3JtYXQKIG1zZ2lkICJGYXN0LWZvcndhcmRpbmcgc3VibW9kdWxlICVzIHRvIHRoZSBmb2xsb3dpbmcgY29tbWl0OiIKIG1zZ3N0ciAiU3B1bGUgU3VibW9kdWwgJXMgenUgZGVtIGZvbGdlbmRlbiBDb21taXQgdm9yOiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTIwMiBtZXJnZS1yZWN1cnNpdmUuYzoxMjE0CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxMjI0IG1lcmdlLXJlY3Vyc2l2ZS5jOjEyMzYKICMsIGMtZm9ybWF0CiBtc2dpZCAiRmFzdC1mb3J3YXJkaW5nIHN1Ym1vZHVsZSAlcyIKIG1zZ3N0ciAiU3B1bGUgU3VibW9kdWwgJXMgdm9yIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxMjM3CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxMjU5CiAjLCBjLWZvcm1hdAogbXNnaWQgIkZhaWxlZCB0byBtZXJnZSBzdWJtb2R1bGUgJXMgKG1lcmdlIGZvbGxvd2luZyBjb21taXRzIG5vdCBmb3VuZCkiCiBtc2dzdHIgIiIKICJGZWhsZXIgYmVpbSBNZXJnZSB2b24gU3VibW9kdWxlICVzIChkZW0gTWVyZ2UgbmFjaGZvbGdlbmRlIENvbW1pdHMgbmljaHQgIgogImdlZnVuZGVuKSIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTI0MQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTI2MwogIywgYy1mb3JtYXQKIG1zZ2lkICJGYWlsZWQgdG8gbWVyZ2Ugc3VibW9kdWxlICVzIChub3QgZmFzdC1mb3J3YXJkKSIKIG1zZ3N0ciAiRmVobGVyIGJlaW0gTWVyZ2Ugdm9uIFN1Ym1vZHVsICVzIChrZWluIFZvcnNwdWxlbikiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEyNDIKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEyNjQKIG1zZ2lkICJGb3VuZCBhIHBvc3NpYmxlIG1lcmdlIHJlc29sdXRpb24gZm9yIHRoZSBzdWJtb2R1bGU6XG4iCiBtc2dzdHIgIk3DtmdsaWNoZSBBdWZsw7ZzdW5nIGRlcyBNZXJnZXMgZsO8ciBTdWJtb2R1bCBnZWZ1bmRlbjpcbiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTI0NQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTI2NwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiSWYgdGhpcyBpcyBjb3JyZWN0IHNpbXBseSBhZGQgaXQgdG8gdGhlIGluZGV4IGZvciBleGFtcGxlXG4iCkBAIC0zODA3LDMzICszODMyLDMzIEBACiAiXG4iCiAiaGluenUsIHVtIGRpZXNlbiBWb3JzY2hsYWcgenUgYWt6ZXB0aWVyZW4uXG4iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEyNTQKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEyNzYKICMsIGMtZm9ybWF0CiBtc2dpZCAiRmFpbGVkIHRvIG1lcmdlIHN1Ym1vZHVsZSAlcyAobXVsdGlwbGUgbWVyZ2VzIGZvdW5kKSIKIG1zZ3N0ciAiRmVobGVyIGJlaW0gTWVyZ2Ugdm9uIFN1Ym1vZHVsICVzIChtZWhyZXJlIE1lcmdlcyBnZWZ1bmRlbikiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEzMjcKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEzNDkKIG1zZ2lkICJGYWlsZWQgdG8gZXhlY3V0ZSBpbnRlcm5hbCBtZXJnZSIKIG1zZ3N0ciAiRmVobGVyIGJlaSBBdXNmw7xocnVuZyBkZXMgaW50ZXJuZW4gTWVyZ2VzIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxMzMyCisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxMzU0CiAjLCBjLWZvcm1hdAogbXNnaWQgIlVuYWJsZSB0byBhZGQgJXMgdG8gZGF0YWJhc2UiCiBtc2dzdHIgIktvbm50ZSAlcyBuaWNodCB6dXIgRGF0ZW5iYW5rIGhpbnp1ZsO8Z2VuIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxMzY0CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxMzg2CiAjLCBjLWZvcm1hdAogbXNnaWQgIkF1dG8tbWVyZ2luZyAlcyIKIG1zZ3N0ciAiYXV0b21hdGlzY2hlciBNZXJnZSB2b24gJXMiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEzODcKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE0MTAKICMsIGMtZm9ybWF0CiBtc2dpZCAiRXJyb3I6IFJlZnVzaW5nIHRvIGxvc2UgdW50cmFja2VkIGZpbGUgYXQgJXM7IHdyaXRpbmcgdG8gJXMgaW5zdGVhZC4iCiBtc2dzdHIgIiIKICJGZWhsZXI6IFZlcndlaWdlcmUgdW52ZXJzaW9uaWVydGUgRGF0ZWkgYmVpICVzIHp1IHZlcmxpZXJlbjtcbiIKICJzY2hyZWliZSBzdGF0dGRlc3NlbiBuYWNoICVzLiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTQ1OQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTQ4MgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiQ09ORkxJQ1QgKCVzL2RlbGV0ZSk6ICVzIGRlbGV0ZWQgaW4gJXMgYW5kICVzIGluICVzLiBWZXJzaW9uICVzIG9mICVzIGxlZnQgIgpAQCAtMzg0Miw3ICszODY3LDcgQEAKICJLT05GTElLVCAoJXMvbMO2c2NoZW4pOiAlcyBnZWzDtnNjaHQgaW4gJXMgdW5kICVzIGluICVzLiBTdGFuZCAlcyB2b24gJXMgd3VyZGUgIgogImltIEFyYmVpdHNiZXJlaWNoIGdlbGFzc2VuLiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTQ2NAorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTQ4NwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiQ09ORkxJQ1QgKCVzL2RlbGV0ZSk6ICVzIGRlbGV0ZWQgaW4gJXMgYW5kICVzIHRvICVzIGluICVzLiBWZXJzaW9uICVzIG9mICVzICIKQEAgLTM4NTEsNyArMzg3Niw3IEBACiAiS09ORkxJS1QgKCVzL2zDtnNjaGVuKTogJXMgZ2Vsw7ZzY2h0IGluICVzIHVuZCAlcyBuYWNoICVzIGluICVzLiBTdGFuZCAlcyB2b24gIgogIiVzIHd1cmRlIGltIEFyYmVpdHNiZXJlaWNoIGdlbGFzc2VuLiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTQ3MQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTQ5NAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiQ09ORkxJQ1QgKCVzL2RlbGV0ZSk6ICVzIGRlbGV0ZWQgaW4gJXMgYW5kICVzIGluICVzLiBWZXJzaW9uICVzIG9mICVzIGxlZnQgIgpAQCAtMzg2MCw3ICszODg1LDcgQEAKICJLT05GTElLVCAoJXMvbMO2c2NoZW4pOiAlcyBnZWzDtnNjaHQgaW4gJXMgdW5kICVzIGluICVzLiBTdGFuZCAlcyB2b24gJXMgd3VyZGUgIgogImltIEFyYmVpdHNiZXJlaWNoIGJlaSAlcyBnZWxhc3Nlbi4iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE0NzYKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE0OTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkNPTkZMSUNUICglcy9kZWxldGUpOiAlcyBkZWxldGVkIGluICVzIGFuZCAlcyB0byAlcyBpbiAlcy4gVmVyc2lvbiAlcyBvZiAlcyAiCkBAIC0zODY5LDQ2ICszODk0LDQ2IEBACiAiS09ORkxJS1QgKCVzL2zDtnNjaGVuKTogJXMgZ2Vsw7ZzY2h0IGluICVzIHVuZCAlcyBuYWNoICVzIGluICVzLiBTdGFuZCAlcyB2b24gIgogIiVzIHd1cmRlIGltIEFyYmVpdHNiZXJlaWNoIGJlaSAlcyBnZWxhc3Nlbi4iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE1MTEKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE1MzQKIG1zZ2lkICJyZW5hbWUiCiBtc2dzdHIgInVtYmVuZW5uZW4iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE1MTEKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE1MzQKIG1zZ2lkICJyZW5hbWVkIgogbXNnc3RyICJ1bWJlbmFubnQiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE1OTEgbWVyZ2UtcmVjdXJzaXZlLmM6MjQ1MCBtZXJnZS1yZWN1cnNpdmUuYzozMDk0CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxNjE0IG1lcmdlLXJlY3Vyc2l2ZS5jOjI0NzIgbWVyZ2UtcmVjdXJzaXZlLmM6MzExNwogIywgYy1mb3JtYXQKIG1zZ2lkICJSZWZ1c2luZyB0byBsb3NlIGRpcnR5IGZpbGUgYXQgJXMiCiBtc2dzdHIgIlZlcndlaWdlcmUgZ2XDpG5kZXJ0ZSBEYXRlaSBiZWkgJXMgenUgdmVybGllcmVuLiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTYwMQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTYyNAogIywgYy1mb3JtYXQKIG1zZ2lkICJSZWZ1c2luZyB0byBsb3NlIHVudHJhY2tlZCBmaWxlIGF0ICVzLCBldmVuIHRob3VnaCBpdCdzIGluIHRoZSB3YXkuIgogbXNnc3RyICIiCiAiVmVyd2VpZ2VyZSB1bnZlcnNpb25pZXJ0ZSBEYXRlaSBiZWkgJXMgenUgdmVybGllcmVuLCBhdWNoIHdlbm4gZGllc2UgaW0gV2VnICIKICJpc3QuIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxNjU5CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxNjgyCiAjLCBjLWZvcm1hdAogbXNnaWQgIkNPTkZMSUNUIChyZW5hbWUvYWRkKTogUmVuYW1lICVzLT4lcyBpbiAlcy4gIEFkZGVkICVzIGluICVzIgogbXNnc3RyICIiCiAiS09ORkxJS1QgKHVtYmVuZW5uZW4vaGluenVmw7xnZW4pOiBCZW5lbm5lIHVtICVzLT4lcyBpbiAlcy4gJXMgaGluenVnZWbDvGd0IGluICIKICIlcyIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTY5MAorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTcxMwogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyBpcyBhIGRpcmVjdG9yeSBpbiAlcyBhZGRpbmcgYXMgJXMgaW5zdGVhZCIKIG1zZ3N0ciAiJXMgaXN0IGVpbiBWZXJ6ZWljaG5pcyBpbiAlcywgZsO8Z2UgZXMgc3RhdHRkZXNzZW4gYWxzICVzIGhpbnp1IgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxNjk1CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxNzE4CiAjLCBjLWZvcm1hdAogbXNnaWQgIlJlZnVzaW5nIHRvIGxvc2UgdW50cmFja2VkIGZpbGUgYXQgJXM7IGFkZGluZyBhcyAlcyBpbnN0ZWFkIgogbXNnc3RyICIiCiAiVmVyd2VpZ2VyZSB1bnZlcnNpb25pZXJ0ZSBEYXRlaSBiZWkgJXMgenUgdmVybGllcmVuOyBmw7xnZSBzdGF0dGRlc3NlbiAlcyAiCiAiaGluenUiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE3MTQKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE3MzcKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkNPTkZMSUNUIChyZW5hbWUvcmVuYW1lKTogUmVuYW1lIFwiJXNcIi0+XCIlc1wiIGluIGJyYW5jaCBcIiVzXCIgcmVuYW1lIFwiJXMiCkBAIC0zOTE3LDE4ICszOTQyLDE4IEBACiAiS09ORkxJS1QgKHVtYmVuZW5uZW4vdW1iZW5lbm5lbik6IEJlbmVubmUgdW0gXCIlc1wiLT5cIiVzXCIgaW4gQnJhbmNoIFwiJXNcIiAiCiAidW5kIFwiJXNcIi0+XCIlc1wiIGluIEJyYW5jaCBcIiVzXCIlcyIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTcxOQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTc0MgogbXNnaWQgIiAobGVmdCB1bnJlc29sdmVkKSIKIG1zZ3N0ciAiIChibGVpYnQgdW5hdWZnZWzDtnN0KSIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTgyOAorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTg1MQogIywgYy1mb3JtYXQKIG1zZ2lkICJDT05GTElDVCAocmVuYW1lL3JlbmFtZSk6IFJlbmFtZSAlcy0+JXMgaW4gJXMuIFJlbmFtZSAlcy0+JXMgaW4gJXMiCiBtc2dzdHIgIiIKICJLT05GTElLVCAodW1iZW5lbm5lbi91bWJlbmVubmVuKTogQmVuZW5uZSB1bSAlcy0+JXMgaW4gJXMuIEJlbmVubmUgdW0gJXMtPiVzICIKICJpbiAlcyIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MjAzNQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MjA1NgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiQ09ORkxJQ1QgKGRpcmVjdG9yeSByZW5hbWUgc3BsaXQpOiBVbmNsZWFyIHdoZXJlIHRvIHBsYWNlICVzIGJlY2F1c2UgIgpAQCAtMzk0MSw3ICszOTY2LDcgQEAKICJ3b2JlaVxuIgogImtlaW5lcyBkaWVzZXIgWmllbGUgZGllIE1laHJoZWl0IGRlciBEYXRlaWVuIGVyaGllbHQuIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoyMDY3CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoyMDg4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJDT05GTElDVCAoaW1wbGljaXQgZGlyIHJlbmFtZSk6IEV4aXN0aW5nIGZpbGUvZGlyIGF0ICVzIGluIHRoZSB3YXkgb2YgIgpAQCAtMzk1Miw3ICszOTc3LDcgQEAKICJXZWcgdm9uIGltcGxpeml0ZXIgVmVyemVpY2huaXN1bWJlbmVubnVuZywgZGllIHZlcnN1Y2h0LCBlaW5lbiBvZGVyIG1laHJlcmVcbiIKICJQZmFkZSBkYWhpbiB6dSBzZXR6ZW46ICVzLiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MjA3NworIzogbWVyZ2UtcmVjdXJzaXZlLmM6MjA5OAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiQ09ORkxJQ1QgKGltcGxpY2l0IGRpciByZW5hbWUpOiBDYW5ub3QgbWFwIG1vcmUgdGhhbiBvbmUgcGF0aCB0byAlczsgIgpAQCAtMzk2Myw3ICszOTg4LDcgQEAKICIlcyBtYXBwZW47IGltcGxpeml0ZSBWZXJ6ZWljaG5pc3VtYmVuZW5udW5nZW4gdmVyc3VjaHRlbiBkaWVzZSBQZmFkZSBkYWhpblxuIgogInp1IHNldHplbjogJXMiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjIxNjkKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjIxOTAKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkNPTkZMSUNUIChyZW5hbWUvcmVuYW1lKTogUmVuYW1lIGRpcmVjdG9yeSAlcy0+JXMgaW4gJXMuIFJlbmFtZSBkaXJlY3RvcnkgJXMtIgpAQCAtMzk3Miw3ICszOTk3LDcgQEAKICJLT05GTElLVCAodW1iZW5lbm5lbi91bWJlbmVubmVuKTogQmVuZW5uZSBWZXJ6ZWljaG5pcyB1bSAlcy0+JXMgaW4gJXMuXG4iCiAiQmVuZW5uZSBWZXJ6ZWljaG5pcyB1bSAlcy0+JXMgaW4gJXMiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjI0MTMKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjI0MzUKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIldBUk5JTkc6IEF2b2lkaW5nIGFwcGx5aW5nICVzIC0+ICVzIHJlbmFtZSB0byAlcywgYmVjYXVzZSAlcyBpdHNlbGYgd2FzICIKQEAgLTM5ODEsNTIgKzQwMDYsNTIgQEAKICJXQVJOVU5HOiBWZXJtZWlkZSBVbWJlbmVubnVuZyAlcyAtPiAlcyB2b24gJXMsIHdlaWwgJXMgc2VsYnN0IHVtYmVuYW5udCAiCiAid3VyZGUuIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoyOTM4CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoyOTYxCiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCByZWFkIG9iamVjdCAlcyIKIG1zZ3N0ciAia2FubiBPYmpla3QgJXMgbmljaHQgbGVzZW4iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjI5NDEKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjI5NjQKICMsIGMtZm9ybWF0CiBtc2dpZCAib2JqZWN0ICVzIGlzIG5vdCBhIGJsb2IiCiBtc2dzdHIgIk9iamVrdCAlcyBpc3Qga2VpbiBCbG9iIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozMDA1CisjOiBtZXJnZS1yZWN1cnNpdmUuYzozMDI4CiBtc2dpZCAibW9kaWZ5IgogbXNnc3RyICLDpG5kZXJuIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozMDA1CisjOiBtZXJnZS1yZWN1cnNpdmUuYzozMDI4CiBtc2dpZCAibW9kaWZpZWQiCiBtc2dzdHIgImdlw6RuZGVydCIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzAxNworIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzA0MAogbXNnaWQgImNvbnRlbnQiCiBtc2dzdHIgIkluaGFsdCIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzAyMQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzA0NAogbXNnaWQgImFkZC9hZGQiCiBtc2dzdHIgImhpbnp1ZsO8Z2VuL2hpbnp1ZsO8Z2VuIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozMDQ0CisjOiBtZXJnZS1yZWN1cnNpdmUuYzozMDY3CiAjLCBjLWZvcm1hdAogbXNnaWQgIlNraXBwZWQgJXMgKG1lcmdlZCBzYW1lIGFzIGV4aXN0aW5nKSIKIG1zZ3N0ciAiJXMgYXVzZ2VsYXNzZW4gKEVyZ2VibmlzIGRlcyBNZXJnZXMgZXhpc3RpZXJ0IGJlcmVpdHMpIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozMDY2IGdpdC1zdWJtb2R1bGUuc2g6OTM3CisjOiBtZXJnZS1yZWN1cnNpdmUuYzozMDg5IGdpdC1zdWJtb2R1bGUuc2g6OTM3CiBtc2dpZCAic3VibW9kdWxlIgogbXNnc3RyICJTdWJtb2R1bCIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzA2NworIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzA5MAogIywgYy1mb3JtYXQKIG1zZ2lkICJDT05GTElDVCAoJXMpOiBNZXJnZSBjb25mbGljdCBpbiAlcyIKIG1zZ3N0ciAiS09ORkxJS1QgKCVzKTogTWVyZ2UtS29uZmxpa3QgaW4gJXMiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMwOTcKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMxMjAKICMsIGMtZm9ybWF0CiBtc2dpZCAiQWRkaW5nIGFzICVzIGluc3RlYWQiCiBtc2dzdHIgIkbDvGdlIHN0YXR0ZGVzc2VuIGFscyAlcyBoaW56dSIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzE3OQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzIwMwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiUGF0aCB1cGRhdGVkOiAlcyBhZGRlZCBpbiAlcyBpbnNpZGUgYSBkaXJlY3RvcnkgdGhhdCB3YXMgcmVuYW1lZCBpbiAlczsgIgpAQCAtNDAzNSw3ICs0MDYwLDcgQEAKICJQZmFkIGFrdHVhbGlzaWVydDogJXMgaGluenVnZWbDvGd0IGluICVzIGlubmVyaGFsYiBlaW5lcyBWZXJ6ZWljaG5pc3NlcywgZGFzICIKICJ1bWJlbmFubnQgd3VyZGUgaW4gJXM7IFZlcnNjaGllYmUgZXMgbmFjaCAlcy4iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMxODIKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMyMDYKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkNPTkZMSUNUIChmaWxlIGxvY2F0aW9uKTogJXMgYWRkZWQgaW4gJXMgaW5zaWRlIGEgZGlyZWN0b3J5IHRoYXQgd2FzIHJlbmFtZWQgIgpAQCAtNDA0NCw3ICs0MDY5LDcgQEAKICJLT05GTElLVCAoU3BlaWNoZXJvcnQpOiAlcyBoaW56dWdlZsO8Z3QgaW4gJXMgaW5uZXJoYWxiIGVpbmVzIFZlcnplaWNobmlzc2VzLCAiCiAiZGFzIHVtYmVuYW5udCB3dXJkZSBpbiAlcywgZXMgc29sbHRlIHZpZWxsZWljaHQgbmFjaCAlcyB2ZXJzY2hvYmVuIHdlcmRlbi4iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMxODYKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMyMTAKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlBhdGggdXBkYXRlZDogJXMgcmVuYW1lZCB0byAlcyBpbiAlcywgaW5zaWRlIGEgZGlyZWN0b3J5IHRoYXQgd2FzIHJlbmFtZWQgaW4gIgpAQCAtNDA1Myw3ICs0MDc4LDcgQEAKICJQZmFkIGFrdHVhbGlzaWVydDogJXMgdW1iZW5hbm50IG5hY2ggJXMgaW4gJXMsIGlubmVyaGFsYiBlaW5lcyAiCiAiVmVyemVpY2huaXNzZXMsIGRhcyB1bWJlbmFubnQgd3VyZGUgaW4gJXM7IFZlcnNjaGllYmUgZXMgbmFjaCAlcy4iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMxODkKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMyMTMKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkNPTkZMSUNUIChmaWxlIGxvY2F0aW9uKTogJXMgcmVuYW1lZCB0byAlcyBpbiAlcywgaW5zaWRlIGEgZGlyZWN0b3J5IHRoYXQgIgpAQCAtNDA2MywzNyArNDA4OCw2MSBAQAogIlZlcnplaWNobmlzc2VzLCBkYXMgdW1iZW5hbm50IHd1cmRlIGluICVzLCBlcyBzb2xsdGUgdmllbGxlaWNodCBuYWNoICVzICIKICJ2ZXJzY2hvYmVuIHdlcmRlbi4iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMzMDMKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMzMjcKICMsIGMtZm9ybWF0CiBtc2dpZCAiUmVtb3ZpbmcgJXMiCiBtc2dzdHIgIkVudGZlcm5lICVzIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozMzI2CisjOiBtZXJnZS1yZWN1cnNpdmUuYzozMzUwCiBtc2dpZCAiZmlsZS9kaXJlY3RvcnkiCiBtc2dzdHIgIkRhdGVpL1ZlcnplaWNobmlzIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozMzMxCisjOiBtZXJnZS1yZWN1cnNpdmUuYzozMzU1CiBtc2dpZCAiZGlyZWN0b3J5L2ZpbGUiCiBtc2dzdHIgIlZlcnplaWNobmlzL0RhdGVpIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozMzM4CisjOiBtZXJnZS1yZWN1cnNpdmUuYzozMzYyCiAjLCBjLWZvcm1hdAogbXNnaWQgIkNPTkZMSUNUICglcyk6IFRoZXJlIGlzIGEgZGlyZWN0b3J5IHdpdGggbmFtZSAlcyBpbiAlcy4gQWRkaW5nICVzIGFzICVzIgogbXNnc3RyICIiCiAiS09ORkxJS1QgKCVzKTogRXMgZXhpc3RpZXJ0IGJlcmVpdHMgZWluIFZlcnplaWNobmlzICVzIGluICVzLiBGw7xnZSAlcyBhbHMgJXMgIgogImhpbnp1LiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzM0NworIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzM3MQogIywgYy1mb3JtYXQKIG1zZ2lkICJBZGRpbmcgJXMiCiBtc2dzdHIgIkbDvGdlICVzIGhpbnp1IgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozMzU2CisjOiBtZXJnZS1yZWN1cnNpdmUuYzozMzgwCiAjLCBjLWZvcm1hdAogbXNnaWQgIkNPTkZMSUNUIChhZGQvYWRkKTogTWVyZ2UgY29uZmxpY3QgaW4gJXMiCiBtc2dzdHIgIktPTkZMSUtUIChoaW56dWbDvGdlbi9oaW56dWbDvGdlbik6IE1lcmdlLUtvbmZsaWt0IGluICVzIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozMzk0CisjOiBtZXJnZS1yZWN1cnNpdmUuYzozNDI0Cittc2dpZCAiQWxyZWFkeSB1cCB0byBkYXRlISIKK21zZ3N0ciAiQmVyZWl0cyBha3R1ZWxsISIKKworIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzQzMworIywgYy1mb3JtYXQKK21zZ2lkICJtZXJnaW5nIG9mIHRyZWVzICVzIGFuZCAlcyBmYWlsZWQiCittc2dzdHIgIlp1c2FtbWVuZsO8aHJlbiBkZXIgXCJUcmVlXCItT2JqZWt0ZSAlcyB1bmQgJXMgZmVobGdlc2NobGFnZW4iCisKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjM1MzcKK21zZ2lkICJNZXJnaW5nOiIKK21zZ3N0ciAiTWVyZ2U6IgorCisjOiBtZXJnZS1yZWN1cnNpdmUuYzozNTUwCisjLCBjLWZvcm1hdAorbXNnaWQgImZvdW5kICV1IGNvbW1vbiBhbmNlc3RvcjoiCittc2dpZF9wbHVyYWwgImZvdW5kICV1IGNvbW1vbiBhbmNlc3RvcnM6IgorbXNnc3RyWzBdICIldSBnZW1laW5zYW1lbiBWb3Jnw6RuZ2VyLUNvbW1pdCBnZWZ1bmRlbiIKK21zZ3N0clsxXSAiJXUgZ2VtZWluc2FtZSBWb3Jnw6RuZ2VyLUNvbW1pdHMgZ2VmdW5kZW4iCisKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjM2MDAKK21zZ2lkICJtZXJnZSByZXR1cm5lZCBubyBjb21taXQiCittc2dzdHIgIk1lcmdlIGhhdCBrZWluZW4gQ29tbWl0IHp1csO8Y2tnZWdlYmVuIgorCisjOiBtZXJnZS1yZWN1cnNpdmUuYzozNjU5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJZb3VyIGxvY2FsIGNoYW5nZXMgdG8gdGhlIGZvbGxvd2luZyBmaWxlcyB3b3VsZCBiZSBvdmVyd3JpdHRlbiBieSBtZXJnZTpcbiIKQEAgLTQxMDMsMTMzICs0MTUyLDEwOSBAQAogIsO8YmVyc2NocmllYmVuIHdlcmRlbjpcbiIKICIgICVzIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozNDA1Ci1tc2dpZCAiQWxyZWFkeSB1cCB0byBkYXRlISIKLW1zZ3N0ciAiQmVyZWl0cyBha3R1ZWxsISIKLQotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzQxNAotIywgYy1mb3JtYXQKLW1zZ2lkICJtZXJnaW5nIG9mIHRyZWVzICVzIGFuZCAlcyBmYWlsZWQiCi1tc2dzdHIgIlp1c2FtbWVuZsO8aHJlbiBkZXIgXCJUcmVlXCItT2JqZWt0ZSAlcyB1bmQgJXMgZmVobGdlc2NobGFnZW4iCi0KLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjM1MTMKLW1zZ2lkICJNZXJnaW5nOiIKLW1zZ3N0ciAiTWVyZ2U6IgotCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozNTI2Ci0jLCBjLWZvcm1hdAotbXNnaWQgImZvdW5kICV1IGNvbW1vbiBhbmNlc3RvcjoiCi1tc2dpZF9wbHVyYWwgImZvdW5kICV1IGNvbW1vbiBhbmNlc3RvcnM6IgotbXNnc3RyWzBdICIldSBnZW1laW5zYW1lbiBWb3Jnw6RuZ2VyLUNvbW1pdCBnZWZ1bmRlbiIKLW1zZ3N0clsxXSAiJXUgZ2VtZWluc2FtZSBWb3Jnw6RuZ2VyLUNvbW1pdHMgZ2VmdW5kZW4iCi0KLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjM1NjUKLW1zZ2lkICJtZXJnZSByZXR1cm5lZCBubyBjb21taXQiCi1tc2dzdHIgIk1lcmdlIGhhdCBrZWluZW4gQ29tbWl0IHp1csO8Y2tnZWdlYmVuIgotCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozNjMxCisjOiBtZXJnZS1yZWN1cnNpdmUuYzozNzU2CiAjLCBjLWZvcm1hdAogbXNnaWQgIkNvdWxkIG5vdCBwYXJzZSBvYmplY3QgJyVzJyIKIG1zZ3N0ciAiS29ubnRlIE9iamVrdCAnJXMnIG5pY2h0IHBhcnNlbi4iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjM2NDcgYnVpbHRpbi9tZXJnZS5jOjY5OCBidWlsdGluL21lcmdlLmM6ODY5CisjOiBtZXJnZS1yZWN1cnNpdmUuYzozNzc0IGJ1aWx0aW4vbWVyZ2UuYzo2OTQgYnVpbHRpbi9tZXJnZS5jOjg3NAogbXNnaWQgIlVuYWJsZSB0byB3cml0ZSBpbmRleC4iCiBtc2dzdHIgIktvbm50ZSBJbmRleCBuaWNodCBzY2hyZWliZW4uIgogCi0jOiBtaWR4LmM6NjkKKyM6IG1pZHguYzo2OAogIywgYy1mb3JtYXQKIG1zZ2lkICJtdWx0aS1wYWNrLWluZGV4IGZpbGUgJXMgaXMgdG9vIHNtYWxsIgogbXNnc3RyICJtdWx0aS1wYWNrLWluZGV4LURhdGVpICVzIGlzdCB6dSBrbGVpbi4iCiAKLSM6IG1pZHguYzo4NQorIzogbWlkeC5jOjg0CiAjLCBjLWZvcm1hdAogbXNnaWQgIm11bHRpLXBhY2staW5kZXggc2lnbmF0dXJlIDB4JTA4eCBkb2VzIG5vdCBtYXRjaCBzaWduYXR1cmUgMHglMDh4IgogbXNnc3RyICIiCiAibXVsdGktcGFjay1pbmRleC1TaWduYXR1ciAweCUwOHggc3RpbW10IG5pY2h0IG1pdCBTaWduYXR1ciAweCUwOHggw7xiZXJlaW4uIgogCi0jOiBtaWR4LmM6OTAKKyM6IG1pZHguYzo4OQogIywgYy1mb3JtYXQKIG1zZ2lkICJtdWx0aS1wYWNrLWluZGV4IHZlcnNpb24gJWQgbm90IHJlY29nbml6ZWQiCiBtc2dzdHIgIm11bHRpLXBhY2staW5kZXgtVmVyc2lvbiAlZCBuaWNodCBlcmthbm50LiIKIAotIzogbWlkeC5jOjk1CisjOiBtaWR4LmM6OTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiaGFzaCB2ZXJzaW9uICV1IGRvZXMgbm90IG1hdGNoIgogbXNnc3RyICJIYXNoLVZlcnNpb24gJXUgc3RpbW10IG5pY2h0IMO8YmVyZWluLiIKIAotIzogbWlkeC5jOjEwOQorIzogbWlkeC5jOjEwOAogbXNnaWQgImludmFsaWQgY2h1bmsgb2Zmc2V0ICh0b28gbGFyZ2UpIgogbXNnc3RyICJVbmfDvGx0aWdlciBDaHVuay1PZmZzZXQgKHp1IGdyb8OfKSIKIAotIzogbWlkeC5jOjEzMworIzogbWlkeC5jOjEzMgogbXNnaWQgInRlcm1pbmF0aW5nIG11bHRpLXBhY2staW5kZXggY2h1bmsgaWQgYXBwZWFycyBlYXJsaWVyIHRoYW4gZXhwZWN0ZWQiCiBtc2dzdHIgIkFic2NobGllw59lbmRlIG11bHRpLXBhY2staW5kZXggQ2h1bmstSWQgZXJzY2hlaW50IGVoZXIgYWxzIGVyd2FydGV0LiIKIAotIzogbWlkeC5jOjE0NgorIzogbWlkeC5jOjE0NQogbXNnaWQgIm11bHRpLXBhY2staW5kZXggbWlzc2luZyByZXF1aXJlZCBwYWNrLW5hbWUgY2h1bmsiCiBtc2dzdHIgIm11bHRpLXBhY2staW5kZXggZmVobHQgZXJmb3JkZXJsaWNoZXIgcGFjay1uYW1lIENodW5rLiIKIAotIzogbWlkeC5jOjE0OAorIzogbWlkeC5jOjE0NwogbXNnaWQgIm11bHRpLXBhY2staW5kZXggbWlzc2luZyByZXF1aXJlZCBPSUQgZmFub3V0IGNodW5rIgogbXNnc3RyICJtdWx0aS1wYWNrLWluZGV4IGZlaGx0IGVyZm9yZGVybGljaGVyIE9JRCBmYW5vdXQgQ2h1bmsuIgogCi0jOiBtaWR4LmM6MTUwCisjOiBtaWR4LmM6MTQ5CiBtc2dpZCAibXVsdGktcGFjay1pbmRleCBtaXNzaW5nIHJlcXVpcmVkIE9JRCBsb29rdXAgY2h1bmsiCiBtc2dzdHIgIm11bHRpLXBhY2staW5kZXggZmVobHQgZXJmb3JkZXJsaWNoZXIgT0lEIGxvb2t1cCBDaHVuay4iCiAKLSM6IG1pZHguYzoxNTIKKyM6IG1pZHguYzoxNTEKIG1zZ2lkICJtdWx0aS1wYWNrLWluZGV4IG1pc3NpbmcgcmVxdWlyZWQgb2JqZWN0IG9mZnNldHMgY2h1bmsiCiBtc2dzdHIgIm11bHRpLXBhY2staW5kZXggZmVobHQgZXJmb3JkZXJsaWNoZXIgb2JqZWN0IG9mZnNldCBDaHVuay4iCiAKLSM6IG1pZHguYzoxNjYKKyM6IG1pZHguYzoxNjUKICMsIGMtZm9ybWF0CiBtc2dpZCAibXVsdGktcGFjay1pbmRleCBwYWNrIG5hbWVzIG91dCBvZiBvcmRlcjogJyVzJyBiZWZvcmUgJyVzJyIKIG1zZ3N0ciAiRmFsc2NoZSBSZWloZW5mb2xnZSBiZWkgbXVsdGktcGFjay1pbmRleCBQYWNrLU5hbWVuOiAnJXMnIHZvciAnJXMnIgogCi0jOiBtaWR4LmM6MjExCisjOiBtaWR4LmM6MjEwCiAjLCBjLWZvcm1hdAogbXNnaWQgImJhZCBwYWNrLWludC1pZDogJXUgKCV1IHRvdGFsIHBhY2tzKSIKIG1zZ3N0ciAiVW5nw7xsdGlnZSBwYWNrLWludC1pZDogJXUgKCV1IFBha2V0ZSBpbnNnZXNhbXQpIgogCi0jOiBtaWR4LmM6MjYxCisjOiBtaWR4LmM6MjYwCiBtc2dpZCAibXVsdGktcGFjay1pbmRleCBzdG9yZXMgYSA2NC1iaXQgb2Zmc2V0LCBidXQgb2ZmX3QgaXMgdG9vIHNtYWxsIgogbXNnc3RyICIiCiAibXVsdGktcGFjay1pbmRleCBzcGVpY2hlcnQgZWluZW4gNjQtQml0IE9mZnNldCwgYWJlciBvZmZfdCBpc3QgenUga2xlaW4uIgogCi0jOiBtaWR4LmM6Mjg5CisjOiBtaWR4LmM6Mjg4CiBtc2dpZCAiZXJyb3IgcHJlcGFyaW5nIHBhY2tmaWxlIGZyb20gbXVsdGktcGFjay1pbmRleCIKIG1zZ3N0ciAiRmVobGVyIGJlaSBWb3JiZXJlaXR1bmcgZGVyIFBhY2tkYXRlaSBhdXMgbXVsdGktcGFjay1pbmRleC4iCiAKLSM6IG1pZHguYzo0NzAKKyM6IG1pZHguYzo0NjkKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIGFkZCBwYWNrZmlsZSAnJXMnIgogbXNnc3RyICJGZWhsZXIgYmVpbSBIaW56dWbDvGdlbiB2b24gUGFja2RhdGVpICclcycuIgogCi0jOiBtaWR4LmM6NDc2CisjOiBtaWR4LmM6NDc1CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBvcGVuIHBhY2staW5kZXggJyVzJyIKIG1zZ3N0ciAiRmVobGVyIGJlaW0gw5ZmZm5lbiB2b24gcGFjay1pbmRleCAnJXMnIgogCi0jOiBtaWR4LmM6NTM2CisjOiBtaWR4LmM6NTM1CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBsb2NhdGUgb2JqZWN0ICVkIGluIHBhY2tmaWxlIgogbXNnc3RyICJGZWhsZXIgYmVpbSBMb2thbGlzaWVyZW4gdm9uIE9iamVrdCAlZCBpbiBQYWNrZGF0ZWkuIgogCi0jOiBtaWR4LmM6ODY1CisjOiBtaWR4LmM6ODY0CiAjLCBjLWZvcm1hdAogbXNnaWQgImRpZCBub3Qgc2VlIHBhY2stZmlsZSAlcyB0byBkcm9wIgogbXNnc3RyICJQYWNrLURhdGVpICVzIHp1bSBXZWdsYXNzZW4gbmljaHQgZ2VmdW5kZW4iCiAKLSM6IG1pZHguYzoxMDM2CisjOiBtaWR4LmM6MTAzNQogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gY2xlYXIgbXVsdGktcGFjay1pbmRleCBhdCAlcyIKIG1zZ3N0ciAiRmVobGVyIGJlaW0gTMO2c2NoZW4gZGVzIG11bHRpLXBhY2staW5kZXggYmVpICVzIgogCi0jOiBtaWR4LmM6MTA5MQorIzogbWlkeC5jOjEwOTAKIG1zZ2lkICJMb29raW5nIGZvciByZWZlcmVuY2VkIHBhY2tmaWxlcyIKIG1zZ3N0ciAiU3VjaGUgbmFjaCByZWZlcmVuemllcnRlbiBQYWNrLURhdGVpZW4iCiAKLSM6IG1pZHguYzoxMTA2CisjOiBtaWR4LmM6MTEwNQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAib2lkIGZhbm91dCBvdXQgb2Ygb3JkZXI6IGZhbm91dFslZF0gPSAlPFBSSXgzMj4gPiAlPFBSSXgzMj4gPSBmYW5vdXRbJWRdIgpAQCAtNDIzNyw1NyArNDI2Miw1NyBAQAogIlVuZ8O8bHRpZ2Ugb2lkIGZhbm91dCBSZWloZW5mb2xnZTogZmFub3V0WyVkXSA9ICU8UFJJeDMyPiA+ICU8UFJJeDMyPiA9ICIKICJmYW5vdXRbJWRdIgogCi0jOiBtaWR4LmM6MTExMAorIzogbWlkeC5jOjExMDkKIG1zZ2lkICJWZXJpZnlpbmcgT0lEIG9yZGVyIGluIE1JRFgiCiBtc2dzdHIgIlZlcmlmaXppZXJlIE9JRC1SZWloZW5mb2xnZSBpbiBNSURYIgogCi0jOiBtaWR4LmM6MTExOQorIzogbWlkeC5jOjExMTgKICMsIGMtZm9ybWF0CiBtc2dpZCAib2lkIGxvb2t1cCBvdXQgb2Ygb3JkZXI6IG9pZFslZF0gPSAlcyA+PSAlcyA9IG9pZFslZF0iCiBtc2dzdHIgIlVuZ8O8bHRpZ2Ugb2lkIGxvb2t1cCBSZWloZW5mb2xnZTogb2lkWyVkXSA9ICVzID49ICVzID0gb2lkWyVkXSIKIAotIzogbWlkeC5jOjExMzgKKyM6IG1pZHguYzoxMTM3CiBtc2dpZCAiU29ydGluZyBvYmplY3RzIGJ5IHBhY2tmaWxlIgogbXNnc3RyICJTb3J0aWVyZSBPYmpla3RlIG5hY2ggUGFjay1EYXRlaSIKIAotIzogbWlkeC5jOjExNDQKKyM6IG1pZHguYzoxMTQzCiBtc2dpZCAiVmVyaWZ5aW5nIG9iamVjdCBvZmZzZXRzIgogbXNnc3RyICLDnGJlcnByw7xmZSBPYmpla3QtT2Zmc2V0cyIKIAotIzogbWlkeC5jOjExNjAKKyM6IG1pZHguYzoxMTU5CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBsb2FkIHBhY2sgZW50cnkgZm9yIG9pZFslZF0gPSAlcyIKIG1zZ3N0ciAiRmVobGVyIGJlaW0gTGFkZW4gZGVzIFBhY2stRWludHJhZ3MgZsO8ciBvaWRbJWRdID0gJXMiCiAKLSM6IG1pZHguYzoxMTY2CisjOiBtaWR4LmM6MTE2NQogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gbG9hZCBwYWNrLWluZGV4IGZvciBwYWNrZmlsZSAlcyIKIG1zZ3N0ciAiRmVobGVyIGJlaW0gTGFkZW4gZGVzIFBhY2stSW5kZXggZsO8ciBQYWNrZGF0ZWkgJXMiCiAKLSM6IG1pZHguYzoxMTc1CisjOiBtaWR4LmM6MTE3NAogIywgYy1mb3JtYXQKIG1zZ2lkICJpbmNvcnJlY3Qgb2JqZWN0IG9mZnNldCBmb3Igb2lkWyVkXSA9ICVzOiAlPFBSSXg2ND4gIT0gJTxQUkl4NjQ+IgogbXNnc3RyICJGYWxzY2hlciBPYmpla3QtT2Zmc2V0IGbDvHIgb2lkWyVkXSA9ICVzOiAlPFBSSXg2ND4gIT0gJTxQUkl4NjQ+IgogCi0jOiBtaWR4LmM6MTM1MAorIzogbWlkeC5jOjEzNDkKIG1zZ2lkICJjb3VsZCBub3Qgc3RhcnQgcGFjay1vYmplY3RzIgogbXNnc3RyICJLb25udGUgJ3BhY2stb2JqZWN0cycgbmljaHQgYXVzZsO8aHJlbiIKIAotIzogbWlkeC5jOjEzNjkKKyM6IG1pZHguYzoxMzY4CiBtc2dpZCAiY291bGQgbm90IGZpbmlzaCBwYWNrLW9iamVjdHMiCiBtc2dzdHIgIktvbm50ZSAncGFjay1vYmplY3RzJyBuaWNodCBiZWVuZGVuIgogCi0jOiBuYW1lLWhhc2guYzo1MzIKKyM6IG5hbWUtaGFzaC5jOjUzNwogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gY3JlYXRlIGxhenlfZGlyIHRocmVhZDogJXMiCiBtc2dzdHIgIkthbm4gbGF6eV9kaXIgVGhyZWFkIG5pY2h0IGVyemV1Z2VuOiAlcyIKIAotIzogbmFtZS1oYXNoLmM6NTU0CisjOiBuYW1lLWhhc2guYzo1NTkKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGNyZWF0ZSBsYXp5X25hbWUgdGhyZWFkOiAlcyIKIG1zZ3N0ciAiS2FubiBsYXp5X25hbWUgVGhyZWFkIG5pY2h0IGVyemV1Z2VuOiAlcyIKIAotIzogbmFtZS1oYXNoLmM6NTYwCisjOiBuYW1lLWhhc2guYzo1NjUKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGpvaW4gbGF6eV9uYW1lIHRocmVhZDogJXMiCiBtc2dzdHIgIkthbm4gbGF6eV9uYW1lIFRocmVhZCBuaWNodCBiZWl0cmV0ZW46ICVzIgpAQCAtNDMzNyw0MSArNDM2Miw0MSBAQAogbXNnaWQgIkJhZCAlcyB2YWx1ZTogJyVzJyIKIG1zZ3N0ciAiVW5nw7xsdGlnZXIgJXMgV2VydDogJyVzJyIKIAotIzogb2JqZWN0LmM6NTQKKyM6IG9iamVjdC5jOjUzCiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgb2JqZWN0IHR5cGUgXCIlc1wiIgogbXNnc3RyICJVbmfDvGx0aWdlciBPYmpla3R0eXAgXCIlc1wiIgogCi0jOiBvYmplY3QuYzoxNzQKKyM6IG9iamVjdC5jOjE3MwogIywgYy1mb3JtYXQKIG1zZ2lkICJvYmplY3QgJXMgaXMgYSAlcywgbm90IGEgJXMiCiBtc2dzdHIgIk9iamVrdCAlcyBpc3QgZWluICVzLCBrZWluICVzIgogCi0jOiBvYmplY3QuYzoyMzQKKyM6IG9iamVjdC5jOjIzMwogIywgYy1mb3JtYXQKIG1zZ2lkICJvYmplY3QgJXMgaGFzIHVua25vd24gdHlwZSBpZCAlZCIKIG1zZ3N0ciAiT2JqZWt0ICVzIGhhdCBlaW5lIHVuYmVrYW5udGUgVHlwLUlkZW50aWZpa2F0aW9uICVkIgogCi0jOiBvYmplY3QuYzoyNDcKKyM6IG9iamVjdC5jOjI0NgogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gcGFyc2Ugb2JqZWN0OiAlcyIKIG1zZ3N0ciAiS29ubnRlIE9iamVrdCAnJXMnIG5pY2h0IHBhcnNlbi4iCiAKLSM6IG9iamVjdC5jOjI2NyBvYmplY3QuYzoyNzgKKyM6IG9iamVjdC5jOjI2NiBvYmplY3QuYzoyNzcKICMsIGMtZm9ybWF0CiBtc2dpZCAiaGFzaCBtaXNtYXRjaCAlcyIKIG1zZ3N0ciAiSGFzaCBzdGltbXQgbmljaHQgbWl0ICVzIMO8YmVyZWluLiIKIAotIzogcGFja2ZpbGUuYzo2NDgKKyM6IHBhY2tmaWxlLmM6NjQxCiBtc2dpZCAib2Zmc2V0IGJlZm9yZSBlbmQgb2YgcGFja2ZpbGUgKGJyb2tlbiAuaWR4PykiCiBtc2dzdHIgIk9mZnNldCB2b3IgRW5kZSBkZXIgUGFja2RhdGVpIChmZWhsZXJoYWZ0ZSBJbmRleGRhdGVpPykiCiAKLSM6IHBhY2tmaWxlLmM6MTg5OQorIzogcGFja2ZpbGUuYzoxODg3CiAjLCBjLWZvcm1hdAogbXNnaWQgIm9mZnNldCBiZWZvcmUgc3RhcnQgb2YgcGFjayBpbmRleCBmb3IgJXMgKGNvcnJ1cHQgaW5kZXg/KSIKIG1zZ3N0ciAiT2Zmc2V0IHZvciBCZWdpbm4gZGVzIFBhY2stSW5kZXggZsO8ciAlcyAoYmVzY2jDpGRpZ3RlciBJbmRleD8pIgogCi0jOiBwYWNrZmlsZS5jOjE5MDMKKyM6IHBhY2tmaWxlLmM6MTg5MQogIywgYy1mb3JtYXQKIG1zZ2lkICJvZmZzZXQgYmV5b25kIGVuZCBvZiBwYWNrIGluZGV4IGZvciAlcyAodHJ1bmNhdGVkIGluZGV4PykiCiBtc2dzdHIgIk9mZnNldCBoaW50ZXIgRW5kZSBkZXMgUGFjay1JbmRleCBmw7xyICVzIChhYmdlc2Nobml0dGVuZXIgSW5kZXg/KSIKQEAgLTQ0MTgsMjYgKzQ0NDMsMjYgQEAKIG1zZ2lkICJkaWQgeW91IG1lYW4gYC0tJXNgICh3aXRoIHR3byBkYXNoZXMgPykiCiBtc2dzdHIgIk1laW50ZW4gU2llIGAtLSVzYCAobWl0IHp3ZWkgU3RyaWNoZW4/KSIKIAotIzogcGFyc2Utb3B0aW9ucy5jOjg1OQorIzogcGFyc2Utb3B0aW9ucy5jOjg2MAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmtub3duIG9wdGlvbiBgJXMnIgogbXNnc3RyICJVbmJla2FubnRlIE9wdGlvbjogYCVzJyIKIAotIzogcGFyc2Utb3B0aW9ucy5jOjg2MQorIzogcGFyc2Utb3B0aW9ucy5jOjg2MgogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmtub3duIHN3aXRjaCBgJWMnIgogbXNnc3RyICJVbmJla2FubnRlciBTY2hhbHRlciBgJWMnIgogCi0jOiBwYXJzZS1vcHRpb25zLmM6ODYzCisjOiBwYXJzZS1vcHRpb25zLmM6ODY0CiAjLCBjLWZvcm1hdAogbXNnaWQgInVua25vd24gbm9uLWFzY2lpIG9wdGlvbiBpbiBzdHJpbmc6IGAlcyciCiBtc2dzdHIgIlVuYmVrYW5udGUgbmljaHQtQXNjaWkgT3B0aW9uIGluIFN0cmluZzogYCVzJyIKIAotIzogcGFyc2Utb3B0aW9ucy5jOjg4NworIzogcGFyc2Utb3B0aW9ucy5jOjg4OAogbXNnaWQgIi4uLiIKIG1zZ3N0ciAiLi4uIgogCi0jOiBwYXJzZS1vcHRpb25zLmM6OTA2CisjOiBwYXJzZS1vcHRpb25zLmM6OTA3CiAjLCBjLWZvcm1hdAogbXNnaWQgInVzYWdlOiAlcyIKIG1zZ3N0ciAiVmVyd2VuZHVuZzogJXMiCkBAIC00NDQ1LDIxICs0NDcwLDIxIEBACiAjLiBUUkFOU0xBVE9SUzogdGhlIGNvbG9uIGhlcmUgc2hvdWxkIGFsaWduIHdpdGggdGhlCiAjLiBvbmUgaW4gInVzYWdlOiAlcyIgdHJhbnNsYXRpb24uCiAjLgotIzogcGFyc2Utb3B0aW9ucy5jOjkxMgorIzogcGFyc2Utb3B0aW9ucy5jOjkxMwogIywgYy1mb3JtYXQKIG1zZ2lkICIgICBvcjogJXMiCiBtc2dzdHIgIiAgICAgIG9kZXI6ICVzIgogCi0jOiBwYXJzZS1vcHRpb25zLmM6OTE1CisjOiBwYXJzZS1vcHRpb25zLmM6OTE2CiAjLCBjLWZvcm1hdAogbXNnaWQgIiAgICAlcyIKIG1zZ3N0ciAiICAgICVzIgogCi0jOiBwYXJzZS1vcHRpb25zLmM6OTU0CisjOiBwYXJzZS1vcHRpb25zLmM6OTU1CiBtc2dpZCAiLU5VTSIKIG1zZ3N0ciAiLU5VTSIKIAotIzogcGFyc2Utb3B0aW9ucy5jOjk2OAorIzogcGFyc2Utb3B0aW9ucy5jOjk2OQogIywgYy1mb3JtYXQKIG1zZ2lkICJhbGlhcyBvZiAtLSVzIgogbXNnc3RyICJBbGlhcyBmw7xyIC0tJXMiCkBAIC00NjMwLDI5ICs0NjU1LDM4IEBACiBtc2dpZCAidW5hYmxlIHRvIHBhcnNlIC0tcHJldHR5IGZvcm1hdCIKIG1zZ3N0ciAiS29ubnRlIC0tcHJldHR5IEZvcm1hdCBuaWNodCBwYXJzZW4uIgogCi0jOiByYW5nZS1kaWZmLmM6NzAKKyM6IHByb21pc29yLXJlbW90ZS5jOjI1Cittc2dpZCAiUmVtb3RlIHdpdGggbm8gVVJMIgorbXNnc3RyICJSZW1vdGUtUmVwb3NpdG9yeSBvaG5lIFVSTCIKKworIzogcHJvbWlzb3ItcmVtb3RlLmM6NjEKKyMsIGMtZm9ybWF0Cittc2dpZCAicHJvbWlzb3IgcmVtb3RlIG5hbWUgY2Fubm90IGJlZ2luIHdpdGggJy8nOiAlcyIKK21zZ3N0ciAiUHJvbWlzb3ItUmVtb3RlLU5hbWUga2FubiBuaWNodCBtaXQgJy8nIGJlZ2lubmVuOiAlcyIKKworIzogcmFuZ2UtZGlmZi5jOjcxCiBtc2dpZCAiY291bGQgbm90IHN0YXJ0IGBsb2dgIgogbXNnc3RyICJLb25udGUgYGxvZ2AgbmljaHQgc3RhcnRlbi4iCiAKLSM6IHJhbmdlLWRpZmYuYzo3MgorIzogcmFuZ2UtZGlmZi5jOjczCiBtc2dpZCAiY291bGQgbm90IHJlYWQgYGxvZ2Agb3V0cHV0IgogbXNnc3RyICJLb25udGUgQXVzZ2FiZSB2b24gYGxvZ2AgbmljaHQgbGVzZW4uIgogCi0jOiByYW5nZS1kaWZmLmM6OTEgc2VxdWVuY2VyLmM6NTAyMQorIzogcmFuZ2UtZGlmZi5jOjkyIHNlcXVlbmNlci5jOjQ5ODUKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHBhcnNlIGNvbW1pdCAnJXMnIgogbXNnc3RyICJLb25udGUgQ29tbWl0ICclcycgbmljaHQgcGFyc2VuLiIKIAotIzogcmFuZ2UtZGlmZi5jOjExNworIzogcmFuZ2UtZGlmZi5jOjExOAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcGFyc2UgZ2l0IGhlYWRlciAnJS4qcyciCiBtc2dzdHIgIktvbm50ZSBHaXQtSGVhZGVyICclLipzJyBuaWNodCBwYXJzZW4uIgogCi0jOiByYW5nZS1kaWZmLmM6Mjc0CisjOiByYW5nZS1kaWZmLmM6Mjc1CiBtc2dpZCAiZmFpbGVkIHRvIGdlbmVyYXRlIGRpZmYiCiBtc2dzdHIgIkZlaGxlciBiZWltIEdlbmVyaWVyZW4gZGVzIERpZmZzLiIKIAotIzogcmFuZ2UtZGlmZi5jOjUwNiByYW5nZS1kaWZmLmM6NTA4CisjOiByYW5nZS1kaWZmLmM6NTA3IHJhbmdlLWRpZmYuYzo1MDkKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHBhcnNlIGxvZyBmb3IgJyVzJyIKIG1zZ3N0ciAiS29ubnRlIExvZyBmw7xyICclcycgbmljaHQgcGFyc2VuLiIKQEAgLTQ2OTksMTEgKzQ3MzMsMTEgQEAKIG1zZ2lkICInJXMnIGFwcGVhcnMgYXMgYm90aCBhIGZpbGUgYW5kIGFzIGEgZGlyZWN0b3J5IgogbXNnc3RyICInJXMnIHNjaGVpbnQgZWluZSBEYXRlaSB1bmQgZWluIFZlcnplaWNobmlzIHp1IHNlaW4uIgogCi0jOiByZWFkLWNhY2hlLmM6MTQ5OQorIzogcmVhZC1jYWNoZS5jOjE1MjAKIG1zZ2lkICJSZWZyZXNoIGluZGV4IgogbXNnc3RyICJBa3R1YWxpc2llcmUgSW5kZXgiCiAKLSM6IHJlYWQtY2FjaGUuYzoxNjEzCisjOiByZWFkLWNhY2hlLmM6MTYzNQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiaW5kZXgudmVyc2lvbiBzZXQsIGJ1dCB0aGUgdmFsdWUgaXMgaW52YWxpZC5cbiIKQEAgLTQ3MTIsNyArNDc0Niw3IEBACiAiaW5kZXgudmVyc2lvbiBnZXNldHp0LCBhYmVyIFdlcnQgdW5nw7xsdGlnLlxuIgogIlZlcndlbmRlIFZlcnNpb24gJWkiCiAKLSM6IHJlYWQtY2FjaGUuYzoxNjIzCisjOiByZWFkLWNhY2hlLmM6MTY0NQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiR0lUX0lOREVYX1ZFUlNJT04gc2V0LCBidXQgdGhlIHZhbHVlIGlzIGludmFsaWQuXG4iCkBAIC00NzIxLDEzOCArNDc1NSwxMzggQEAKICJHSVRfSU5ERVhfVkVSU0lPTiBnZXNldHp0LCBhYmVyIFdlcnQgdW5nw7xsdGlnLlxuIgogIlZlcndlbmRlIFZlcnNpb24gJWkiCiAKLSM6IHJlYWQtY2FjaGUuYzoxNjc5CisjOiByZWFkLWNhY2hlLmM6MTcwMQogIywgYy1mb3JtYXQKIG1zZ2lkICJiYWQgc2lnbmF0dXJlIDB4JTA4eCIKIG1zZ3N0ciAiVW5nw7xsdGlnZSBTaWduYXR1ciAweCUwOHgiCiAKLSM6IHJlYWQtY2FjaGUuYzoxNjgyCisjOiByZWFkLWNhY2hlLmM6MTcwNAogIywgYy1mb3JtYXQKIG1zZ2lkICJiYWQgaW5kZXggdmVyc2lvbiAlZCIKIG1zZ3N0ciAiVW5nw7xsdGlnZSBJbmRleC1WZXJzaW9uICVkIgogCi0jOiByZWFkLWNhY2hlLmM6MTY5MQorIzogcmVhZC1jYWNoZS5jOjE3MTMKIG1zZ2lkICJiYWQgaW5kZXggZmlsZSBzaGExIHNpZ25hdHVyZSIKIG1zZ3N0ciAiVW5nw7xsdGlnZSBTSEExLVNpZ25hdHVyIGRlciBJbmRleC1EYXRlaS4iCiAKLSM6IHJlYWQtY2FjaGUuYzoxNzIxCisjOiByZWFkLWNhY2hlLmM6MTc0MwogIywgYy1mb3JtYXQKIG1zZ2lkICJpbmRleCB1c2VzICUuNHMgZXh0ZW5zaW9uLCB3aGljaCB3ZSBkbyBub3QgdW5kZXJzdGFuZCIKIG1zZ3N0ciAiSW5kZXggdmVyd2VuZGV0IEVyd2VpdGVydW5nICUuNHMsIHdlbGNoZSB3aXIgbmljaHQgdW50ZXJzdMO8dHplbi4iCiAKLSM6IHJlYWQtY2FjaGUuYzoxNzIzCisjOiByZWFkLWNhY2hlLmM6MTc0NQogIywgYy1mb3JtYXQKIG1zZ2lkICJpZ25vcmluZyAlLjRzIGV4dGVuc2lvbiIKIG1zZ3N0ciAiSWdub3JpZXJlIEVyd2VpdGVydW5nICUuNHMiCiAKLSM6IHJlYWQtY2FjaGUuYzoxNzYwCisjOiByZWFkLWNhY2hlLmM6MTc4MgogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmtub3duIGluZGV4IGVudHJ5IGZvcm1hdCAweCUwOHgiCiBtc2dzdHIgIlVuYmVrYW5udGVzIEZvcm1hdCBmw7xyIEluZGV4LUVpbnRyYWcgMHglMDh4IgogCi0jOiByZWFkLWNhY2hlLmM6MTc3NgorIzogcmVhZC1jYWNoZS5jOjE3OTgKICMsIGMtZm9ybWF0CiBtc2dpZCAibWFsZm9ybWVkIG5hbWUgZmllbGQgaW4gdGhlIGluZGV4LCBuZWFyIHBhdGggJyVzJyIKIG1zZ3N0ciAiVW5nw7xsdGlnZXMgTmFtZW5zZmVsZCBpbSBJbmRleCwgaW4gZGVyIE7DpGhlIHZvbiBQZmFkICclcycuIgogCi0jOiByZWFkLWNhY2hlLmM6MTgzMworIzogcmVhZC1jYWNoZS5jOjE4NTUKIG1zZ2lkICJ1bm9yZGVyZWQgc3RhZ2UgZW50cmllcyBpbiBpbmRleCIKIG1zZ3N0ciAiVW5nZW9yZG5ldGUgU3RhZ2UtRWludHLDpGdlIGltIEluZGV4LiIKIAotIzogcmVhZC1jYWNoZS5jOjE4MzYKKyM6IHJlYWQtY2FjaGUuYzoxODU4CiAjLCBjLWZvcm1hdAogbXNnaWQgIm11bHRpcGxlIHN0YWdlIGVudHJpZXMgZm9yIG1lcmdlZCBmaWxlICclcyciCiBtc2dzdHIgIk1laHJlcmUgU3RhZ2UtRWludHLDpGdlIGbDvHIgenVzYW1tZW5nZWbDvGhydGUgRGF0ZWkgJyVzJy4iCiAKLSM6IHJlYWQtY2FjaGUuYzoxODM5CisjOiByZWFkLWNhY2hlLmM6MTg2MQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bm9yZGVyZWQgc3RhZ2UgZW50cmllcyBmb3IgJyVzJyIKIG1zZ3N0ciAiVW5nZW9yZG5ldGUgU3RhZ2UtRWludHLDpGdlIGbDvHIgJyVzJy4iCiAKLSM6IHJlYWQtY2FjaGUuYzoxOTQ2IHJlYWQtY2FjaGUuYzoyMjM0IHJlcmVyZS5jOjU2NSByZXJlcmUuYzo1OTkgcmVyZXJlLmM6MTExMQotIzogYnVpbHRpbi9hZGQuYzo0NjAgYnVpbHRpbi9jaGVjay1pZ25vcmUuYzoxNzggYnVpbHRpbi9jaGVja291dC5jOjQ2NwotIzogYnVpbHRpbi9jaGVja291dC5jOjY1MSBidWlsdGluL2NsZWFuLmM6OTU2IGJ1aWx0aW4vY29tbWl0LmM6MzQ3CisjOiByZWFkLWNhY2hlLmM6MTk2NyByZWFkLWNhY2hlLmM6MjI1NSByZXJlcmUuYzo1NjUgcmVyZXJlLmM6NTk5IHJlcmVyZS5jOjExMTEKKyM6IGJ1aWx0aW4vYWRkLmM6NDYwIGJ1aWx0aW4vY2hlY2staWdub3JlLmM6MTc4IGJ1aWx0aW4vY2hlY2tvdXQuYzo0NjgKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo2NTIgYnVpbHRpbi9jbGVhbi5jOjk2NyBidWlsdGluL2NvbW1pdC5jOjM0NwogIzogYnVpbHRpbi9kaWZmLXRyZWUuYzoxMjAgYnVpbHRpbi9ncmVwLmM6NDk5IGJ1aWx0aW4vbXYuYzoxNDUKICM6IGJ1aWx0aW4vcmVzZXQuYzoyNDUgYnVpbHRpbi9ybS5jOjI3MSBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6MzMwCiBtc2dpZCAiaW5kZXggZmlsZSBjb3JydXB0IgogbXNnc3RyICJJbmRleC1EYXRlaSBiZXNjaMOkZGlndCIKIAotIzogcmVhZC1jYWNoZS5jOjIwODcKKyM6IHJlYWQtY2FjaGUuYzoyMTA4CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBjcmVhdGUgbG9hZF9jYWNoZV9lbnRyaWVzIHRocmVhZDogJXMiCiBtc2dzdHIgIkthbm4gVGhyZWFkIGbDvHIgbG9hZF9jYWNoZV9lbnRyaWVzIG5pY2h0IGVyemV1Z2VuOiAlcyIKIAotIzogcmVhZC1jYWNoZS5jOjIxMDAKKyM6IHJlYWQtY2FjaGUuYzoyMTIxCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBqb2luIGxvYWRfY2FjaGVfZW50cmllcyB0aHJlYWQ6ICVzIgogbXNnc3RyICJLYW5uIFRocmVhZCBmw7xyIGxvYWRfY2FjaGVfZW50cmllcyBuaWNodCBlcnpldWdlbjogJXMiCiAKLSM6IHJlYWQtY2FjaGUuYzoyMTMzCisjOiByZWFkLWNhY2hlLmM6MjE1NAogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogaW5kZXggZmlsZSBvcGVuIGZhaWxlZCIKIG1zZ3N0ciAiJXM6IMOWZmZuZW4gZGVyIEluZGV4LURhdGVpIGZlaGxnZXNjaGxhZ2VuLiIKIAotIzogcmVhZC1jYWNoZS5jOjIxMzcKKyM6IHJlYWQtY2FjaGUuYzoyMTU4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiBjYW5ub3Qgc3RhdCB0aGUgb3BlbiBpbmRleCIKIG1zZ3N0ciAiJXM6IEthbm4gZ2XDtmZmbmV0ZW4gSW5kZXggbmljaHQgbGVzZW4uIgogCi0jOiByZWFkLWNhY2hlLmM6MjE0MQorIzogcmVhZC1jYWNoZS5jOjIxNjIKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXM6IGluZGV4IGZpbGUgc21hbGxlciB0aGFuIGV4cGVjdGVkIgogbXNnc3RyICIlczogSW5kZXgtRGF0ZWkgaXN0IGtsZWluZXIgYWxzIGVyd2FydGV0LiIKIAotIzogcmVhZC1jYWNoZS5jOjIxNDUKKyM6IHJlYWQtY2FjaGUuYzoyMTY2CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiB1bmFibGUgdG8gbWFwIGluZGV4IGZpbGUiCiBtc2dzdHIgIiVzOiBLb25udGUgSW5kZXgtRGF0ZWkgbmljaHQgZWlubGVzZW4uIgogCi0jOiByZWFkLWNhY2hlLmM6MjE4NworIzogcmVhZC1jYWNoZS5jOjIyMDgKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGNyZWF0ZSBsb2FkX2luZGV4X2V4dGVuc2lvbnMgdGhyZWFkOiAlcyIKIG1zZ3N0ciAiS2FubiBUaHJlYWQgZsO8ciBsb2FkX2luZGV4X2V4dGVuc2lvbnMgbmljaHQgZXJ6ZXVnZW46ICVzIgogCi0jOiByZWFkLWNhY2hlLmM6MjIxNAorIzogcmVhZC1jYWNoZS5jOjIyMzUKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGpvaW4gbG9hZF9pbmRleF9leHRlbnNpb25zIHRocmVhZDogJXMiCiBtc2dzdHIgIkthbm4gVGhyZWFkIGbDvHIgbG9hZF9pbmRleF9leHRlbnNpb25zIG5pY2h0IGJlaXRyZXRlbjogJXMiCiAKLSM6IHJlYWQtY2FjaGUuYzoyMjQ2CisjOiByZWFkLWNhY2hlLmM6MjI2NwogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgZnJlc2hlbiBzaGFyZWQgaW5kZXggJyVzJyIKIG1zZ3N0ciAiS29ubnRlIGdldGVpbHRlbiBJbmRleCAnJXMnIG5pY2h0IGFrdHVhbGlzaWVyZW4uIgogCi0jOiByZWFkLWNhY2hlLmM6MjI5MworIzogcmVhZC1jYWNoZS5jOjIzMTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiYnJva2VuIGluZGV4LCBleHBlY3QgJXMgaW4gJXMsIGdvdCAlcyIKIG1zZ3N0ciAiRmVobGVyaGFmdGVyIEluZGV4LiBFcndhcnRldGUgJXMgaW4gJXMsIGVyaGllbHQgJXMuIgogCi0jOiByZWFkLWNhY2hlLmM6Mjk4OSB3cmFwcGVyLmM6NjU4IGJ1aWx0aW4vbWVyZ2UuYzoxMTE0CisjOiByZWFkLWNhY2hlLmM6MzAxMCB3cmFwcGVyLmM6NjIyIGJ1aWx0aW4vbWVyZ2UuYzoxMTE5CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBjbG9zZSAnJXMnIgogbXNnc3RyICJLb25udGUgJyVzJyBuaWNodCBzY2hsaWXDn2VuLiIKIAotIzogcmVhZC1jYWNoZS5jOjMwOTIgc2VxdWVuY2VyLmM6MjM1OCBzZXF1ZW5jZXIuYzozOTI4CisjOiByZWFkLWNhY2hlLmM6MzExMyBzZXF1ZW5jZXIuYzoyMjk2IHNlcXVlbmNlci5jOjM5MTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHN0YXQgJyVzJyIKIG1zZ3N0ciAiS29ubnRlICclcycgbmljaHQgbGVzZW4uIgogCi0jOiByZWFkLWNhY2hlLmM6MzEwNQorIzogcmVhZC1jYWNoZS5jOjMxMjYKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIG9wZW4gZ2l0IGRpcjogJXMiCiBtc2dzdHIgImtvbm50ZSBHaXQtVmVyemVpY2huaXMgbmljaHQgw7ZmZm5lbjogJXMiCiAKLSM6IHJlYWQtY2FjaGUuYzozMTE3CisjOiByZWFkLWNhY2hlLmM6MzEzOAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gdW5saW5rOiAlcyIKIG1zZ3N0ciAiS29ubnRlICclcycgbmljaHQgZW50ZmVybmVuLiIKIAotIzogcmVhZC1jYWNoZS5jOjMxNDIKKyM6IHJlYWQtY2FjaGUuYzozMTYzCiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCBmaXggcGVybWlzc2lvbiBiaXRzIG9uICclcyciCiBtc2dzdHIgIktvbm50ZSBadWdyaWZmc2JlcmVjaHRpZ3VuZyBhdWYgJyVzJyBuaWNodCBzZXR6ZW4uIgogCi0jOiByZWFkLWNhY2hlLmM6MzI5MQorIzogcmVhZC1jYWNoZS5jOjMzMTIKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXM6IGNhbm5vdCBkcm9wIHRvIHN0YWdlICMwIgogbXNnc3RyICIlczogS2FubiBuaWNodCBhdWYgU3R1ZmUgIzAgd2VjaHNlbG4uIgpAQCAtNDk2Miw4ICs0OTk2LDggQEAKIG1zZ2lkICJOb3RlIHRoYXQgZW1wdHkgY29tbWl0cyBhcmUgY29tbWVudGVkIG91dCIKIG1zZ3N0ciAiTGVlcmUgQ29tbWl0cyBzaW5kIGF1c2tvbW1lbnRpZXJ0LiIKIAotIzogcmViYXNlLWludGVyYWN0aXZlLmM6MTA1IHJlcmVyZS5jOjQ4NSByZXJlcmUuYzo2OTIgc2VxdWVuY2VyLmM6MzQ0NwotIzogc2VxdWVuY2VyLmM6MzQ3MyBzZXF1ZW5jZXIuYzo1MTIwIGJ1aWx0aW4vZnNjay5jOjM1NiBidWlsdGluL3JlYmFzZS5jOjIzNQorIzogcmViYXNlLWludGVyYWN0aXZlLmM6MTA1IHJlcmVyZS5jOjQ4NSByZXJlcmUuYzo2OTIgc2VxdWVuY2VyLmM6MzM4OAorIzogc2VxdWVuY2VyLmM6MzQxNCBzZXF1ZW5jZXIuYzo1MDg0IGJ1aWx0aW4vZnNjay5jOjM1NiBidWlsdGluL3JlYmFzZS5jOjIzNQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3Qgd3JpdGUgJyVzJyIKIG1zZ3N0ciAiS29ubnRlICclcycgbmljaHQgc2NocmVpYmVuLiIKQEAgLTUwMDksNyArNTA0Myw3IEBACiBtc2dpZCAiaWdub3JpbmcgZGFuZ2xpbmcgc3ltcmVmICVzIgogbXNnc3RyICJJZ25vcmllcmUgdW5yZWZlcmVuemllcnRlIHN5bWJvbGlzY2hlIFJlZmVyZW56ICVzIgogCi0jOiByZWZzLmM6NjY5IHJlZi1maWx0ZXIuYzoyMDkyCisjOiByZWZzLmM6NjY5IHJlZi1maWx0ZXIuYzoyMDk4CiAjLCBjLWZvcm1hdAogbXNnaWQgImlnbm9yaW5nIGJyb2tlbiByZWYgJXMiCiBtc2dzdHIgIklnbm9yaWVyZSBmZWhsZXJoYWZ0ZSBSZWZlcmVueiAlcyIKQEAgLTUwMzQsMTQgKzUwNjgsMTQgQEAKIG1zZ2lkICJ1bmV4cGVjdGVkIG9iamVjdCBJRCB3aGVuIHdyaXRpbmcgJyVzJyIKIG1zZ3N0ciAiVW5lcndhcnRldGUgT2JqZWt0LUlEIGJlaW0gU2NocmVpYmVuIHZvbiAnJXMnLiIKIAotIzogcmVmcy5jOjgzMyBzZXF1ZW5jZXIuYzo0MDMgc2VxdWVuY2VyLmM6MjcwOSBzZXF1ZW5jZXIuYzoyOTEzCi0jOiBzZXF1ZW5jZXIuYzoyOTI3IHNlcXVlbmNlci5jOjMxODQgc2VxdWVuY2VyLmM6NTAzNyB3cmFwcGVyLmM6NjU2CisjOiByZWZzLmM6ODMzIHNlcXVlbmNlci5jOjQwMyBzZXF1ZW5jZXIuYzoyNjQ3IHNlcXVlbmNlci5jOjI4NTEKKyM6IHNlcXVlbmNlci5jOjI4NjUgc2VxdWVuY2VyLmM6MzEyMiBzZXF1ZW5jZXIuYzo1MDAxIHdyYXBwZXIuYzo2MjAKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHdyaXRlIHRvICclcyciCiBtc2dzdHIgIktvbm50ZSBuaWNodCBuYWNoICclcycgc2NocmVpYmVuLiIKIAotIzogcmVmcy5jOjg2MCB3cmFwcGVyLmM6MjI1IHdyYXBwZXIuYzozOTUgYnVpbHRpbi9hbS5jOjcxNQotIzogYnVpbHRpbi9yZWJhc2UuYzoxMDAzCisjOiByZWZzLmM6ODYwIHdyYXBwZXIuYzoxODggd3JhcHBlci5jOjM1OCBidWlsdGluL2FtLmM6NzE0CisjOiBidWlsdGluL3JlYmFzZS5jOjEwMDQKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IG9wZW4gJyVzJyBmb3Igd3JpdGluZyIKIG1zZ3N0ciAiS29ubnRlICclcycgbmljaHQgenVtIFNjaHJlaWJlbiDDtmZmbmVuLiIKQEAgLTUwNzYsMjMgKzUxMTAsMjMgQEAKIG1zZ2lkICJ1cGRhdGVfcmVmIGZhaWxlZCBmb3IgcmVmICclcyc6ICVzIgogbXNnc3RyICJ1cGRhdGVfcmVmIGbDvHIgUmVmZXJlbnogJyVzJyBmZWhsZ2VzY2hsYWdlbjogJXMiCiAKLSM6IHJlZnMuYzoyMDEyCisjOiByZWZzLmM6MjAyMwogIywgYy1mb3JtYXQKIG1zZ2lkICJtdWx0aXBsZSB1cGRhdGVzIGZvciByZWYgJyVzJyBub3QgYWxsb3dlZCIKIG1zZ3N0ciAiTWVocmVyZSBBa3R1YWxpc2llcnVuZ2VuIGbDvHIgUmVmZXJlbnogJyVzJyBuaWNodCBlcmxhdWJ0LiIKIAotIzogcmVmcy5jOjIwNDQKKyM6IHJlZnMuYzoyMDU1CiBtc2dpZCAicmVmIHVwZGF0ZXMgZm9yYmlkZGVuIGluc2lkZSBxdWFyYW50aW5lIGVudmlyb25tZW50IgogbXNnc3RyICIiCiAiQWt0dWFsaXNpZXJ1bmdlbiB2b24gUmVmZXJlbnplbiBpc3QgaW5uZXJoYWxiIGRlciBRdWFyYW50w6RuZS1VbWdlYnVuZyAiCiAidmVyYm90ZW4uIgogCi0jOiByZWZzLmM6MjE0MCByZWZzLmM6MjE3MAorIzogcmVmcy5jOjIxNTEgcmVmcy5jOjIxODEKICMsIGMtZm9ybWF0CiBtc2dpZCAiJyVzJyBleGlzdHM7IGNhbm5vdCBjcmVhdGUgJyVzJyIKIG1zZ3N0ciAiJyVzJyBleGlzdGllcnQ7IGthbm4gJyVzJyBuaWNodCBlcnN0ZWxsZW4iCiAKLSM6IHJlZnMuYzoyMTQ2IHJlZnMuYzoyMTgxCisjOiByZWZzLmM6MjE1NyByZWZzLmM6MjE5MgogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgcHJvY2VzcyAnJXMnIGFuZCAnJXMnIGF0IHRoZSBzYW1lIHRpbWUiCiBtc2dzdHIgIkthbm4gJyVzJyB1bmQgJyVzJyBuaWNodCB6dXIgc2VsYmVuIFplaXQgdmVyYXJiZWl0ZW4uIgpAQCAtNTEwMiwxMyArNTEzNiwxMyBAQAogbXNnaWQgImNvdWxkIG5vdCByZW1vdmUgcmVmZXJlbmNlICVzIgogbXNnc3RyICJLb25udGUgUmVmZXJlbnogJXMgbmljaHQgbMO2c2NoZW4iCiAKLSM6IHJlZnMvZmlsZXMtYmFja2VuZC5jOjEyNDggcmVmcy9wYWNrZWQtYmFja2VuZC5jOjE1MzIKLSM6IHJlZnMvcGFja2VkLWJhY2tlbmQuYzoxNTQyCisjOiByZWZzL2ZpbGVzLWJhY2tlbmQuYzoxMjQ4IHJlZnMvcGFja2VkLWJhY2tlbmQuYzoxNTQxCisjOiByZWZzL3BhY2tlZC1iYWNrZW5kLmM6MTU1MQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgZGVsZXRlIHJlZmVyZW5jZSAlczogJXMiCiBtc2dzdHIgIktvbm50ZSBSZWZlcmVueiAlcyBuaWNodCBlbnRmZXJuZW46ICVzIgogCi0jOiByZWZzL2ZpbGVzLWJhY2tlbmQuYzoxMjUxIHJlZnMvcGFja2VkLWJhY2tlbmQuYzoxNTQ1CisjOiByZWZzL2ZpbGVzLWJhY2tlbmQuYzoxMjUxIHJlZnMvcGFja2VkLWJhY2tlbmQuYzoxNTU0CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBkZWxldGUgcmVmZXJlbmNlczogJXMiCiBtc2dzdHIgIktvbm50ZSBSZWZlcmVuemVuIG5pY2h0IGVudGZlcm5lbjogJXMiCkBAIC01MTE4LDcgKzUxNTIsNyBAQAogbXNnaWQgImludmFsaWQgcmVmc3BlYyAnJXMnIgogbXNnc3RyICJVbmfDvGx0aWdlIFJlZnNwZWMgJyVzJyIKIAotIzogcmVmLWZpbHRlci5jOjQyIHd0LXN0YXR1cy5jOjE5MzQKKyM6IHJlZi1maWx0ZXIuYzo0MiB3dC1zdGF0dXMuYzoxOTM4CiBtc2dpZCAiZ29uZSIKIG1zZ3N0ciAiZW50ZmVybnQiCiAKQEAgLTUxMzcsMjgzICs1MTcxLDI4MyBAQAogbXNnaWQgImFoZWFkICVkLCBiZWhpbmQgJWQiCiBtc2dzdHIgIiVkIHZvcmF1cywgJWQgaGludGVyaGVyIgogCi0jOiByZWYtZmlsdGVyLmM6MTYyCisjOiByZWYtZmlsdGVyLmM6MTY1CiAjLCBjLWZvcm1hdAogbXNnaWQgImV4cGVjdGVkIGZvcm1hdDogJSUoY29sb3I6PGNvbG9yPikiCiBtc2dzdHIgIkVyd2FydGV0ZXMgRm9ybWF0OiAlJShjb2xvcjo8RmFyYmU+KSIKIAotIzogcmVmLWZpbHRlci5jOjE2NAorIzogcmVmLWZpbHRlci5jOjE2NwogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bnJlY29nbml6ZWQgY29sb3I6ICUlKGNvbG9yOiVzKSIKIG1zZ3N0ciAibmljaHQgZXJrYW5udGUgRmFyYmU6ICUlKGNvbG9yOiVzKSIKIAotIzogcmVmLWZpbHRlci5jOjE4NgorIzogcmVmLWZpbHRlci5jOjE4OQogIywgYy1mb3JtYXQKIG1zZ2lkICJJbnRlZ2VyIHZhbHVlIGV4cGVjdGVkIHJlZm5hbWU6bHN0cmlwPSVzIgogbXNnc3RyICJQb3NpdGl2ZXIgV2VydCBlcndhcnRldCByZWZuYW1lOmxzdHJpcD0lcyIKIAotIzogcmVmLWZpbHRlci5jOjE5MAorIzogcmVmLWZpbHRlci5jOjE5MwogIywgYy1mb3JtYXQKIG1zZ2lkICJJbnRlZ2VyIHZhbHVlIGV4cGVjdGVkIHJlZm5hbWU6cnN0cmlwPSVzIgogbXNnc3RyICJQb3NpdGl2ZXIgV2VydCBlcndhcnRldCByZWZuYW1lOnJzdHJpcD0lcyIKIAotIzogcmVmLWZpbHRlci5jOjE5MgorIzogcmVmLWZpbHRlci5jOjE5NQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bnJlY29nbml6ZWQgJSUoJXMpIGFyZ3VtZW50OiAlcyIKIG1zZ3N0ciAibmljaHQgZXJrYW5udGVzICUlKCVzKSBBcmd1bWVudDogJXMiCiAKLSM6IHJlZi1maWx0ZXIuYzoyNDcKKyM6IHJlZi1maWx0ZXIuYzoyNTAKICMsIGMtZm9ybWF0CiBtc2dpZCAiJSUob2JqZWN0dHlwZSkgZG9lcyBub3QgdGFrZSBhcmd1bWVudHMiCiBtc2dzdHIgIiUlKG9iamVjdHR5cGUpIGFremVwdGllcnQga2VpbmUgQXJndW1lbnRlIgogCi0jOiByZWYtZmlsdGVyLmM6MjY5CisjOiByZWYtZmlsdGVyLmM6MjcyCiAjLCBjLWZvcm1hdAogbXNnaWQgInVucmVjb2duaXplZCAlJShvYmplY3RzaXplKSBhcmd1bWVudDogJXMiCiBtc2dzdHIgIm5pY2h0IGVya2FubnRlcyAlJShvYmplY3RzaXplKSBBcmd1bWVudDogJXMiCiAKLSM6IHJlZi1maWx0ZXIuYzoyNzcKKyM6IHJlZi1maWx0ZXIuYzoyODAKICMsIGMtZm9ybWF0CiBtc2dpZCAiJSUoZGVsdGFiYXNlKSBkb2VzIG5vdCB0YWtlIGFyZ3VtZW50cyIKIG1zZ3N0ciAiJSUoZGVsdGFiYXNlKSBha3plcHRpZXJ0IGtlaW5lIEFyZ3VtZW50ZSIKIAotIzogcmVmLWZpbHRlci5jOjI4OQorIzogcmVmLWZpbHRlci5jOjI5MgogIywgYy1mb3JtYXQKIG1zZ2lkICIlJShib2R5KSBkb2VzIG5vdCB0YWtlIGFyZ3VtZW50cyIKIG1zZ3N0ciAiJSUoYm9keSkgYWt6ZXB0aWVydCBrZWluZSBBcmd1bWVudGUiCiAKLSM6IHJlZi1maWx0ZXIuYzoyOTgKKyM6IHJlZi1maWx0ZXIuYzozMDEKICMsIGMtZm9ybWF0CiBtc2dpZCAiJSUoc3ViamVjdCkgZG9lcyBub3QgdGFrZSBhcmd1bWVudHMiCiBtc2dzdHIgIiUlKHN1YmplY3QpIGFremVwdGllcnQga2VpbmUgQXJndW1lbnRlIgogCi0jOiByZWYtZmlsdGVyLmM6MzIwCisjOiByZWYtZmlsdGVyLmM6MzIzCiAjLCBjLWZvcm1hdAogbXNnaWQgInVua25vd24gJSUodHJhaWxlcnMpIGFyZ3VtZW50OiAlcyIKIG1zZ3N0ciAidW5iZWthbm50ZXMgJSUodHJhaWxlcnMpIEFyZ3VtZW50OiAlcyIKIAotIzogcmVmLWZpbHRlci5jOjM0OQorIzogcmVmLWZpbHRlci5jOjM1MgogIywgYy1mb3JtYXQKIG1zZ2lkICJwb3NpdGl2ZSB2YWx1ZSBleHBlY3RlZCBjb250ZW50czpsaW5lcz0lcyIKIG1zZ3N0ciAiUG9zaXRpdmVyIFdlcnQgZXJ3YXJ0ZXQgY29udGVudHM6bGluZXM9JXMiCiAKLSM6IHJlZi1maWx0ZXIuYzozNTEKKyM6IHJlZi1maWx0ZXIuYzozNTQKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5yZWNvZ25pemVkICUlKGNvbnRlbnRzKSBhcmd1bWVudDogJXMiCiBtc2dzdHIgIm5pY2h0IGVya2FubnRlcyAlJShjb250ZW50cykgQXJndW1lbnQ6ICVzIgogCi0jOiByZWYtZmlsdGVyLmM6MzY2CisjOiByZWYtZmlsdGVyLmM6MzY5CiAjLCBjLWZvcm1hdAogbXNnaWQgInBvc2l0aXZlIHZhbHVlIGV4cGVjdGVkIG9iamVjdG5hbWU6c2hvcnQ9JXMiCiBtc2dzdHIgIlBvc2l0aXZlciBXZXJ0IGVyd2FydGV0IG9iamVjdG5hbWU6c2hvcnQ9JXMiCiAKLSM6IHJlZi1maWx0ZXIuYzozNzAKKyM6IHJlZi1maWx0ZXIuYzozNzMKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5yZWNvZ25pemVkICUlKG9iamVjdG5hbWUpIGFyZ3VtZW50OiAlcyIKIG1zZ3N0ciAibmljaHQgZXJrYW5udGVzICUlKG9iamVjdG5hbWUpIEFyZ3VtZW50OiAlcyIKIAotIzogcmVmLWZpbHRlci5jOjQwMAorIzogcmVmLWZpbHRlci5jOjQwMwogIywgYy1mb3JtYXQKIG1zZ2lkICJleHBlY3RlZCBmb3JtYXQ6ICUlKGFsaWduOjx3aWR0aD4sPHBvc2l0aW9uPikiCiBtc2dzdHIgIkVyd2FydGV0ZXMgRm9ybWF0OiAlJShhbGlnbjo8QnJlaXRlPiw8UG9zaXRpb24+KSIKIAotIzogcmVmLWZpbHRlci5jOjQxMgorIzogcmVmLWZpbHRlci5jOjQxNQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bnJlY29nbml6ZWQgcG9zaXRpb246JXMiCiBtc2dzdHIgIm5pY2h0IGVya2FubnRlIFBvc2l0aW9uOiVzIgogCi0jOiByZWYtZmlsdGVyLmM6NDE5CisjOiByZWYtZmlsdGVyLmM6NDIyCiAjLCBjLWZvcm1hdAogbXNnaWQgInVucmVjb2duaXplZCB3aWR0aDolcyIKIG1zZ3N0ciAibmljaHQgZXJrYW5udGUgQnJlaXRlOiVzIgogCi0jOiByZWYtZmlsdGVyLmM6NDI4CisjOiByZWYtZmlsdGVyLmM6NDMxCiAjLCBjLWZvcm1hdAogbXNnaWQgInVucmVjb2duaXplZCAlJShhbGlnbikgYXJndW1lbnQ6ICVzIgogbXNnc3RyICJuaWNodCBlcmthbm50ZXMgJSUoYWxpZ24pIEFyZ3VtZW50OiAlcyIKIAotIzogcmVmLWZpbHRlci5jOjQzNgorIzogcmVmLWZpbHRlci5jOjQzOQogIywgYy1mb3JtYXQKIG1zZ2lkICJwb3NpdGl2ZSB3aWR0aCBleHBlY3RlZCB3aXRoIHRoZSAlJShhbGlnbikgYXRvbSIKIG1zZ3N0ciAiUG9zaXRpdmUgQnJlaXRlbmFuZ2FiZSBmw7xyICUlKGFsaWduKSBlcndhcnRldCIKIAotIzogcmVmLWZpbHRlci5jOjQ1NAorIzogcmVmLWZpbHRlci5jOjQ1NwogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bnJlY29nbml6ZWQgJSUoaWYpIGFyZ3VtZW50OiAlcyIKIG1zZ3N0ciAibmljaHQgZXJrYW5udGVzICUlKGlmKSBBcmd1bWVudDogJXMiCiAKLSM6IHJlZi1maWx0ZXIuYzo1NTYKKyM6IHJlZi1maWx0ZXIuYzo1NTkKICMsIGMtZm9ybWF0CiBtc2dpZCAibWFsZm9ybWVkIGZpZWxkIG5hbWU6ICUuKnMiCiBtc2dzdHIgIkZlaGxlcmhhZnRlciBGZWxkbmFtZTogJS4qcyIKIAotIzogcmVmLWZpbHRlci5jOjU4MworIzogcmVmLWZpbHRlci5jOjU4NgogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmtub3duIGZpZWxkIG5hbWU6ICUuKnMiCiBtc2dzdHIgIlVuYmVrYW5udGVyIEZlbGRuYW1lOiAlLipzIgogCi0jOiByZWYtZmlsdGVyLmM6NTg3CisjOiByZWYtZmlsdGVyLmM6NTkwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJub3QgYSBnaXQgcmVwb3NpdG9yeSwgYnV0IHRoZSBmaWVsZCAnJS4qcycgcmVxdWlyZXMgYWNjZXNzIHRvIG9iamVjdCBkYXRhIgogbXNnc3RyICIiCiAiS2VpbiBHaXQtUmVwb3NpdG9yeSwgYWJlciBkYXMgRmVsZCAnJS4qcycgZXJmb3JkZXJ0IFp1Z3JpZmYgYXVmIE9iamVrdGRhdGVuLiIKIAotIzogcmVmLWZpbHRlci5jOjcxMQorIzogcmVmLWZpbHRlci5jOjcxNAogIywgYy1mb3JtYXQKIG1zZ2lkICJmb3JtYXQ6ICUlKGlmKSBhdG9tIHVzZWQgd2l0aG91dCBhICUlKHRoZW4pIGF0b20iCiBtc2dzdHIgImZvcm1hdDogJSUoaWYpIEF0b20gb2huZSBlaW4gJSUodGhlbikgQXRvbSB2ZXJ3ZW5kZXQiCiAKLSM6IHJlZi1maWx0ZXIuYzo3NzQKKyM6IHJlZi1maWx0ZXIuYzo3NzcKICMsIGMtZm9ybWF0CiBtc2dpZCAiZm9ybWF0OiAlJSh0aGVuKSBhdG9tIHVzZWQgd2l0aG91dCBhbiAlJShpZikgYXRvbSIKIG1zZ3N0ciAiZm9ybWF0OiAlJSh0aGVuKSBBdG9tIG9obmUgZWluICUlKGlmKSBBdG9tIHZlcndlbmRldCIKIAotIzogcmVmLWZpbHRlci5jOjc3NgorIzogcmVmLWZpbHRlci5jOjc3OQogIywgYy1mb3JtYXQKIG1zZ2lkICJmb3JtYXQ6ICUlKHRoZW4pIGF0b20gdXNlZCBtb3JlIHRoYW4gb25jZSIKIG1zZ3N0ciAiZm9ybWF0OiAlJSh0aGVuKSBBdG9tIG1laHIgYWxzIGVpbm1hbCB2ZXJ3ZW5kZXQiCiAKLSM6IHJlZi1maWx0ZXIuYzo3NzgKKyM6IHJlZi1maWx0ZXIuYzo3ODEKICMsIGMtZm9ybWF0CiBtc2dpZCAiZm9ybWF0OiAlJSh0aGVuKSBhdG9tIHVzZWQgYWZ0ZXIgJSUoZWxzZSkiCiBtc2dzdHIgImZvcm1hdDogJSUodGhlbikgQXRvbSBuYWNoICUlKGVsc2UpIHZlcndlbmRldCIKIAotIzogcmVmLWZpbHRlci5jOjgwNgorIzogcmVmLWZpbHRlci5jOjgwOQogIywgYy1mb3JtYXQKIG1zZ2lkICJmb3JtYXQ6ICUlKGVsc2UpIGF0b20gdXNlZCB3aXRob3V0IGFuICUlKGlmKSBhdG9tIgogbXNnc3RyICJmb3JtYXQ6ICUlKGVsc2UpIEF0b20gb2huZSBlaW4gJSUoaWYpIEF0b20gdmVyd2VuZGV0IgogCi0jOiByZWYtZmlsdGVyLmM6ODA4CisjOiByZWYtZmlsdGVyLmM6ODExCiAjLCBjLWZvcm1hdAogbXNnaWQgImZvcm1hdDogJSUoZWxzZSkgYXRvbSB1c2VkIHdpdGhvdXQgYSAlJSh0aGVuKSBhdG9tIgogbXNnc3RyICJGb3JtYXQ6ICUlKGVsc2UpIEF0b20gb2huZSBlaW4gJSUodGhlbikgQXRvbSB2ZXJ3ZW5kZXQiCiAKLSM6IHJlZi1maWx0ZXIuYzo4MTAKKyM6IHJlZi1maWx0ZXIuYzo4MTMKICMsIGMtZm9ybWF0CiBtc2dpZCAiZm9ybWF0OiAlJShlbHNlKSBhdG9tIHVzZWQgbW9yZSB0aGFuIG9uY2UiCiBtc2dzdHIgIkZvcm1hdDogJSUoZW5kKSBBdG9tIG1laHIgYWxzIGVpbm1hbCB2ZXJ3ZW5kZXQiCiAKLSM6IHJlZi1maWx0ZXIuYzo4MjUKKyM6IHJlZi1maWx0ZXIuYzo4MjgKICMsIGMtZm9ybWF0CiBtc2dpZCAiZm9ybWF0OiAlJShlbmQpIGF0b20gdXNlZCB3aXRob3V0IGNvcnJlc3BvbmRpbmcgYXRvbSIKIG1zZ3N0ciAiRm9ybWF0OiAlJShlbmQpIEF0b20gb2huZSB6dWdlaMO2cmlnZXMgQXRvbSB2ZXJ3ZW5kZXQiCiAKLSM6IHJlZi1maWx0ZXIuYzo4ODIKKyM6IHJlZi1maWx0ZXIuYzo4ODUKICMsIGMtZm9ybWF0CiBtc2dpZCAibWFsZm9ybWVkIGZvcm1hdCBzdHJpbmcgJXMiCiBtc2dzdHIgIkZlaGxlcmhhZnRlciBGb3JtYXRpZXJ1bmdzc3RyaW5nICVzIgogCi0jOiByZWYtZmlsdGVyLmM6MTQ4NQorIzogcmVmLWZpbHRlci5jOjE0ODgKICMsIGMtZm9ybWF0CiBtc2dpZCAibm8gYnJhbmNoLCByZWJhc2luZyAlcyIKIG1zZ3N0ciAia2VpbiBCcmFuY2gsIFJlYmFzZSB2b24gJXMiCiAKLSM6IHJlZi1maWx0ZXIuYzoxNDg4CisjOiByZWYtZmlsdGVyLmM6MTQ5MQogIywgYy1mb3JtYXQKIG1zZ2lkICJubyBicmFuY2gsIHJlYmFzaW5nIGRldGFjaGVkIEhFQUQgJXMiCiBtc2dzdHIgImtlaW4gQnJhbmNoLCBSZWJhc2Ugdm9uIGxvc2dlbMO2c3RlbSBIRUFEICVzIgogCi0jOiByZWYtZmlsdGVyLmM6MTQ5MQorIzogcmVmLWZpbHRlci5jOjE0OTQKICMsIGMtZm9ybWF0CiBtc2dpZCAibm8gYnJhbmNoLCBiaXNlY3Qgc3RhcnRlZCBvbiAlcyIKIG1zZ3N0ciAia2VpbiBCcmFuY2gsIGJpbsOkcmUgU3VjaGUgYmVnb25uZW4gYmVpICVzIgogCi0jOiByZWYtZmlsdGVyLmM6MTUwMQorIzogcmVmLWZpbHRlci5jOjE1MDQKIG1zZ2lkICJubyBicmFuY2giCiBtc2dzdHIgImtlaW4gQnJhbmNoIgogCi0jOiByZWYtZmlsdGVyLmM6MTUzNyByZWYtZmlsdGVyLmM6MTc0MworIzogcmVmLWZpbHRlci5jOjE1NDAgcmVmLWZpbHRlci5jOjE3NDkKICMsIGMtZm9ybWF0CiBtc2dpZCAibWlzc2luZyBvYmplY3QgJXMgZm9yICVzIgogbXNnc3RyICJPYmpla3QgJXMgZmVobHQgZsO8ciAlcyIKIAotIzogcmVmLWZpbHRlci5jOjE1NDcKKyM6IHJlZi1maWx0ZXIuYzoxNTUwCiAjLCBjLWZvcm1hdAogbXNnaWQgInBhcnNlX29iamVjdF9idWZmZXIgZmFpbGVkIG9uICVzIGZvciAlcyIKIG1zZ3N0ciAicGFyc2Vfb2JqZWN0X2J1ZmZlciBiZWkgJXMgZsO8ciAlcyBmZWhsZ2VzY2hsYWdlbiIKIAotIzogcmVmLWZpbHRlci5jOjE5OTgKKyM6IHJlZi1maWx0ZXIuYzoyMDA0CiAjLCBjLWZvcm1hdAogbXNnaWQgIm1hbGZvcm1lZCBvYmplY3QgYXQgJyVzJyIKIG1zZ3N0ciAiZmVobGVyaGFmdGVzIE9iamVrdCBiZWkgJyVzJyIKIAotIzogcmVmLWZpbHRlci5jOjIwODcKKyM6IHJlZi1maWx0ZXIuYzoyMDkzCiAjLCBjLWZvcm1hdAogbXNnaWQgImlnbm9yaW5nIHJlZiB3aXRoIGJyb2tlbiBuYW1lICVzIgogbXNnc3RyICJJZ25vcmllcmUgUmVmZXJlbnogbWl0IGZlaGxlcmhhZnRlbSBOYW1lbiAlcyIKIAotIzogcmVmLWZpbHRlci5jOjIzODIKKyM6IHJlZi1maWx0ZXIuYzoyMzg5CiAjLCBjLWZvcm1hdAogbXNnaWQgImZvcm1hdDogJSUoZW5kKSBhdG9tIG1pc3NpbmciCiBtc2dzdHIgIkZvcm1hdDogJSUoZW5kKSBBdG9tIGZlaGx0IgogCi0jOiByZWYtZmlsdGVyLmM6MjQ4MgorIzogcmVmLWZpbHRlci5jOjI0ODkKICMsIGMtZm9ybWF0CiBtc2dpZCAib3B0aW9uIGAlcycgaXMgaW5jb21wYXRpYmxlIHdpdGggLS1tZXJnZWQiCiBtc2dzdHIgIkRpZSBPcHRpb24gYCVzJyBpc3QgaW5rb21wYXRpYmVsIG1pdCAtLW1lcmdlZC4iCiAKLSM6IHJlZi1maWx0ZXIuYzoyNDg1CisjOiByZWYtZmlsdGVyLmM6MjQ5MgogIywgYy1mb3JtYXQKIG1zZ2lkICJvcHRpb24gYCVzJyBpcyBpbmNvbXBhdGlibGUgd2l0aCAtLW5vLW1lcmdlZCIKIG1zZ3N0ciAiRGllIE9wdGlvbiBgJXMnIGlzdCBpbmtvbXBhdGliZWwgbWl0IC0tbm8tbWVyZ2VkLiIKIAotIzogcmVmLWZpbHRlci5jOjI0OTUKKyM6IHJlZi1maWx0ZXIuYzoyNTAyCiAjLCBjLWZvcm1hdAogbXNnaWQgIm1hbGZvcm1lZCBvYmplY3QgbmFtZSAlcyIKIG1zZ3N0ciAiTWlzc2dlYmlsZGV0ZXIgT2JqZWt0bmFtZSAlcyIKIAotIzogcmVmLWZpbHRlci5jOjI1MDAKKyM6IHJlZi1maWx0ZXIuYzoyNTA3CiAjLCBjLWZvcm1hdAogbXNnaWQgIm9wdGlvbiBgJXMnIG11c3QgcG9pbnQgdG8gYSBjb21taXQiCiBtc2dzdHIgIkRpZSBPcHRpb24gYCVzJyBtdXNzIGF1ZiBlaW5lbiBDb21taXQgemVpZ2VuLiIKIAotIzogcmVtb3RlLmM6MzYzCisjOiByZW1vdGUuYzozNjYKICMsIGMtZm9ybWF0CiBtc2dpZCAiY29uZmlnIHJlbW90ZSBzaG9ydGhhbmQgY2Fubm90IGJlZ2luIHdpdGggJy8nOiAlcyIKIG1zZ3N0ciAiIgogIkvDvHJ6ZWwgZsO8ciBSZW1vdGUtUmVwb3NpdG9yeSBpbiBkZXIgS29uZmlndXJhdGlvbiBrYW5uIG5pY2h0IG1pdCAnLycgIgogImJlZ2lubmVuOiAlcyIKIAotIzogcmVtb3RlLmM6NDEwCisjOiByZW1vdGUuYzo0MTMKIG1zZ2lkICJtb3JlIHRoYW4gb25lIHJlY2VpdmVwYWNrIGdpdmVuLCB1c2luZyB0aGUgZmlyc3QiCiBtc2dzdHIgIk1laHIgYWxzIGVpbiByZWNlaXZlcGFjay1CZWZlaGwgYW5nZWdlYmVuLCBiZW51dHplIGRlbiBlcnN0ZW4uIgogCi0jOiByZW1vdGUuYzo0MTgKKyM6IHJlbW90ZS5jOjQyMQogbXNnaWQgIm1vcmUgdGhhbiBvbmUgdXBsb2FkcGFjayBnaXZlbiwgdXNpbmcgdGhlIGZpcnN0IgogbXNnc3RyICJNZWhyIGFscyBlaW4gdXBsb2FkcGFjay1CZWZlaGwgYW5nZWdlYmVuLCBiZW51dHplIGRlbiBlcnN0ZW4uIgogCi0jOiByZW1vdGUuYzo2MDgKKyM6IHJlbW90ZS5jOjYxMQogIywgYy1mb3JtYXQKIG1zZ2lkICJDYW5ub3QgZmV0Y2ggYm90aCAlcyBhbmQgJXMgdG8gJXMiCiBtc2dzdHIgIkthbm4gJ2ZldGNoJyBuaWNodCBmw7xyIHNvd29obCAlcyBhbHMgYXVjaCAlcyBuYWNoICVzIGF1c2bDvGhyZW4uIgogCi0jOiByZW1vdGUuYzo2MTIKKyM6IHJlbW90ZS5jOjYxNQogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyB1c3VhbGx5IHRyYWNrcyAlcywgbm90ICVzIgogbXNnc3RyICIlcyBmb2xndCDDvGJsaWNoZXJ3ZWlzZSAlcywgbmljaHQgJXMiCiAKLSM6IHJlbW90ZS5jOjYxNgorIzogcmVtb3RlLmM6NjE5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIHRyYWNrcyBib3RoICVzIGFuZCAlcyIKIG1zZ3N0ciAiJXMgZm9sZ3Qgc293b2hsICVzIGFscyBhdWNoICVzIgogCi0jOiByZW1vdGUuYzo2ODQKKyM6IHJlbW90ZS5jOjY4NwogIywgYy1mb3JtYXQKIG1zZ2lkICJrZXkgJyVzJyBvZiBwYXR0ZXJuIGhhZCBubyAnKiciCiBtc2dzdHIgIlNjaGzDvHNzZWwgJyVzJyBkZXMgTXVzdGVycyBoYXR0ZSBrZWluICcqJy4iCiAKLSM6IHJlbW90ZS5jOjY5NAorIzogcmVtb3RlLmM6Njk3CiAjLCBjLWZvcm1hdAogbXNnaWQgInZhbHVlICclcycgb2YgcGF0dGVybiBoYXMgbm8gJyonIgogbXNnc3RyICJXZXJ0ICclcycgZGVzIE11c3RlcnMgaGF0IGtlaW4gJyonLiIKIAotIzogcmVtb3RlLmM6MTAwMAorIzogcmVtb3RlLmM6MTAwMwogIywgYy1mb3JtYXQKIG1zZ2lkICJzcmMgcmVmc3BlYyAlcyBkb2VzIG5vdCBtYXRjaCBhbnkiCiBtc2dzdHIgIlNyYy1SZWZzcGVjICVzIGVudHNwcmljaHQga2VpbmVyIFJlZmVyZW56LiIKIAotIzogcmVtb3RlLmM6MTAwNQorIzogcmVtb3RlLmM6MTAwOAogIywgYy1mb3JtYXQKIG1zZ2lkICJzcmMgcmVmc3BlYyAlcyBtYXRjaGVzIG1vcmUgdGhhbiBvbmUiCiBtc2dzdHIgIlNyYy1SZWZzcGVjICVzIGVudHNwcmljaHQgbWVociBhbHMgZWluZXIgUmVmZXJlbnouIgpAQCAtNTQyMiw3ICs1NDU2LDcgQEAKICMuIDxyZW1vdGU+IDxzcmM+Ojxkc3Q+IiBwdXNoLCBhbmQgImJlaW5nIHB1c2hlZCAoJyVzJykiIGlzCiAjLiB0aGUgPHNyYz4uCiAjLgotIzogcmVtb3RlLmM6MTAyMAorIzogcmVtb3RlLmM6MTAyMwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiVGhlIGRlc3RpbmF0aW9uIHlvdSBwcm92aWRlZCBpcyBub3QgYSBmdWxsIHJlZm5hbWUgKGkuZS4sXG4iCkBAIC01NDQ5LDcgKzU0ODMsNyBAQAogIktlaW5lcyBoYXQgZnVua3Rpb25pZXJ0LCBzb2Rhc3Mgd2lyIGF1ZmdlZ2ViZW4gaGFiZW4uIFNpZSBtw7xzc2VuIGRpZVxuIgogIlJlZmVyZW56IG1pdCB2b2xscXVhbGlmaXppZXJ0ZW4gTmFtZW4gYW5nZWJlbi4iCiAKLSM6IHJlbW90ZS5jOjEwNDAKKyM6IHJlbW90ZS5jOjEwNDMKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlRoZSA8c3JjPiBwYXJ0IG9mIHRoZSByZWZzcGVjIGlzIGEgY29tbWl0IG9iamVjdC5cbiIKQEAgLTU0NjAsNyArNTQ5NCw3IEBACiAiTWVpbnRlbiBTaWUsIGVpbmVuIG5ldWVuIEJyYW5jaCBtaXR0ZWxzIFB1c2ggbmFjaFxuIgogIiclczpyZWZzL2hlYWRzLyVzJyB6dSBlcnN0ZWxsZW4/IgogCi0jOiByZW1vdGUuYzoxMDQ1CisjOiByZW1vdGUuYzoxMDQ4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgPHNyYz4gcGFydCBvZiB0aGUgcmVmc3BlYyBpcyBhIHRhZyBvYmplY3QuXG4iCkBAIC01NDcxLDcgKzU1MDUsNyBAQAogIk1laW50ZW4gU2llLCBlaW5lbiBuZXVlbiBUYWcgbWl0dGVscyBQdXNoIG5hY2hcbiIKICInJXM6cmVmcy90YWdzLyVzJyB6dSBlcnN0ZWxsZW4/IgogCi0jOiByZW1vdGUuYzoxMDUwCisjOiByZW1vdGUuYzoxMDUzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgPHNyYz4gcGFydCBvZiB0aGUgcmVmc3BlYyBpcyBhIHRyZWUgb2JqZWN0LlxuIgpAQCAtNTQ4Miw3ICs1NTE2LDcgQEAKICJNZWludGVuIFNpZSwgZWluZW4gVGFnIGbDvHIgZWluIG5ldWVzIFRyZWUtT2JqZWt0XG4iCiAibWl0dGVscyBQdXNoIG5hY2ggJyVzOnJlZnMvdGFncy8nJXMnIHp1IGVyc3RlbGxlbj8iCiAKLSM6IHJlbW90ZS5jOjEwNTUKKyM6IHJlbW90ZS5jOjEwNTgKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlRoZSA8c3JjPiBwYXJ0IG9mIHRoZSByZWZzcGVjIGlzIGEgYmxvYiBvYmplY3QuXG4iCkBAIC01NDkzLDExNyArNTUyNywxMTcgQEAKICJNZWludGVuIFNpZSwgZWluZW4gVGFnIGbDvHIgZWluIG5ldWVzIEJsb2ItT2JqZWt0XG4iCiAibWl0dGVscyBQdXNoIG5hY2ggJyVzOnJlZnMvdGFncy8lcycgenUgZXJzdGVsbGVuPyIKIAotIzogcmVtb3RlLmM6MTA5MQorIzogcmVtb3RlLmM6MTA5NAogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyBjYW5ub3QgYmUgcmVzb2x2ZWQgdG8gYnJhbmNoIgogbXNnc3RyICIlcyBrYW5uIG5pY2h0IHp1IEJyYW5jaCBhdWZnZWzDtnN0IHdlcmRlbi4iCiAKLSM6IHJlbW90ZS5jOjExMDIKKyM6IHJlbW90ZS5jOjExMDUKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGRlbGV0ZSAnJXMnOiByZW1vdGUgcmVmIGRvZXMgbm90IGV4aXN0IgogbXNnc3RyICJLb25udGUgJyVzJyBuaWNodCBsw7ZzY2hlbjogUmVtb3RlLVJlZmVyZW56IGV4aXN0aWVydCBuaWNodC4iCiAKLSM6IHJlbW90ZS5jOjExMTQKKyM6IHJlbW90ZS5jOjExMTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiZHN0IHJlZnNwZWMgJXMgbWF0Y2hlcyBtb3JlIHRoYW4gb25lIgogbXNnc3RyICJEc3QtUmVmc3BlYyAlcyBlbnRzcHJpY2h0IG1laHIgYWxzIGVpbmVyIFJlZmVyZW56LiIKIAotIzogcmVtb3RlLmM6MTEyMQorIzogcmVtb3RlLmM6MTEyNAogIywgYy1mb3JtYXQKIG1zZ2lkICJkc3QgcmVmICVzIHJlY2VpdmVzIGZyb20gbW9yZSB0aGFuIG9uZSBzcmMiCiBtc2dzdHIgIkRzdC1SZWZlcmVueiAlcyBlbXBmw6RuZ3Qgdm9uIG1laHIgYWxzIGVpbmVyIFF1ZWxsZSIKIAotIzogcmVtb3RlLmM6MTYyNCByZW1vdGUuYzoxNzI1CisjOiByZW1vdGUuYzoxNjI3IHJlbW90ZS5jOjE3MjgKIG1zZ2lkICJIRUFEIGRvZXMgbm90IHBvaW50IHRvIGEgYnJhbmNoIgogbXNnc3RyICJIRUFEIHplaWd0IGF1ZiBrZWluZW4gQnJhbmNoIgogCi0jOiByZW1vdGUuYzoxNjMzCisjOiByZW1vdGUuYzoxNjM2CiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vIHN1Y2ggYnJhbmNoOiAnJXMnIgogbXNnc3RyICJLZWluIHNvbGNoZXIgQnJhbmNoOiAnJXMnIgogCi0jOiByZW1vdGUuYzoxNjM2CisjOiByZW1vdGUuYzoxNjM5CiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vIHVwc3RyZWFtIGNvbmZpZ3VyZWQgZm9yIGJyYW5jaCAnJXMnIgogbXNnc3RyICJLZWluIFVwc3RyZWFtLUJyYW5jaCBmw7xyIEJyYW5jaCAnJXMnIGtvbmZpZ3VyaWVydC4iCiAKLSM6IHJlbW90ZS5jOjE2NDIKKyM6IHJlbW90ZS5jOjE2NDUKICMsIGMtZm9ybWF0CiBtc2dpZCAidXBzdHJlYW0gYnJhbmNoICclcycgbm90IHN0b3JlZCBhcyBhIHJlbW90ZS10cmFja2luZyBicmFuY2giCiBtc2dzdHIgIlVwc3RyZWFtLUJyYW5jaCAnJXMnIG5pY2h0IGFscyBSZW1vdGUtVHJhY2tpbmctQnJhbmNoIGdlc3BlaWNoZXJ0IgogCi0jOiByZW1vdGUuYzoxNjU3CisjOiByZW1vdGUuYzoxNjYwCiAjLCBjLWZvcm1hdAogbXNnaWQgInB1c2ggZGVzdGluYXRpb24gJyVzJyBvbiByZW1vdGUgJyVzJyBoYXMgbm8gbG9jYWwgdHJhY2tpbmcgYnJhbmNoIgogbXNnc3RyICIiCiAiWmllbCBmw7xyIFwicHVzaFwiICclcycgYXVmIFJlbW90ZS1SZXBvc2l0b3J5ICclcycgaGF0IGtlaW5lbiBsb2thbCBnZWZvbGd0ZW4gIgogIkJyYW5jaCIKIAotIzogcmVtb3RlLmM6MTY2OQorIzogcmVtb3RlLmM6MTY3MgogIywgYy1mb3JtYXQKIG1zZ2lkICJicmFuY2ggJyVzJyBoYXMgbm8gcmVtb3RlIGZvciBwdXNoaW5nIgogbXNnc3RyICJCcmFuY2ggJyVzJyBoYXQga2VpbmVuIFVwc3RyZWFtLUJyYW5jaCBnZXNldHp0IgogCi0jOiByZW1vdGUuYzoxNjc5CisjOiByZW1vdGUuYzoxNjgyCiAjLCBjLWZvcm1hdAogbXNnaWQgInB1c2ggcmVmc3BlY3MgZm9yICclcycgZG8gbm90IGluY2x1ZGUgJyVzJyIKIG1zZ3N0ciAiUHVzaC1SZWZzcGVjcyBmw7xyICclcycgYmVpbmhhbHRlbiBuaWNodCAnJXMnIgogCi0jOiByZW1vdGUuYzoxNjkyCisjOiByZW1vdGUuYzoxNjk1CiBtc2dpZCAicHVzaCBoYXMgbm8gZGVzdGluYXRpb24gKHB1c2guZGVmYXVsdCBpcyAnbm90aGluZycpIgogbXNnc3RyICJrZWluIFppZWwgZsO8ciBcInB1c2hcIiAocHVzaC5kZWZhdWx0IGlzdCAnbm90aGluZycpIgogCi0jOiByZW1vdGUuYzoxNzE0CisjOiByZW1vdGUuYzoxNzE3CiBtc2dpZCAiY2Fubm90IHJlc29sdmUgJ3NpbXBsZScgcHVzaCB0byBhIHNpbmdsZSBkZXN0aW5hdGlvbiIKIG1zZ3N0ciAia2FubiBlaW56ZWxuZXMgWmllbCBmw7xyIFwicHVzaFwiIGltIE1vZHVzICdzaW1wbGUnIG5pY2h0IGF1ZmzDtnNlbiIKIAotIzogcmVtb3RlLmM6MTg0MAorIzogcmVtb3RlLmM6MTg0MwogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZG4ndCBmaW5kIHJlbW90ZSByZWYgJXMiCiBtc2dzdHIgIktvbm50ZSBSZW1vdGUtUmVmZXJlbnogJXMgbmljaHQgZmluZGVuLiIKIAotIzogcmVtb3RlLmM6MTg1MworIzogcmVtb3RlLmM6MTg1NgogIywgYy1mb3JtYXQKIG1zZ2lkICIqIElnbm9yaW5nIGZ1bm55IHJlZiAnJXMnIGxvY2FsbHkiCiBtc2dzdHIgIiogSWdub3JpZXJlIHNvbmRlcmJhcmUgUmVmZXJlbnogJyVzJyBsb2thbCIKIAotIzogcmVtb3RlLmM6MjAxNgorIzogcmVtb3RlLmM6MjAxOQogIywgYy1mb3JtYXQKIG1zZ2lkICJZb3VyIGJyYW5jaCBpcyBiYXNlZCBvbiAnJXMnLCBidXQgdGhlIHVwc3RyZWFtIGlzIGdvbmUuXG4iCiBtc2dzdHIgIiIKICJJaHIgQnJhbmNoIGJhc2llcnQgYXVmICclcycsIGFiZXIgZGVyIFVwc3RyZWFtLUJyYW5jaCB3dXJkZSBlbnRmZXJudC5cbiIKIAotIzogcmVtb3RlLmM6MjAyMAorIzogcmVtb3RlLmM6MjAyMwogbXNnaWQgIiAgKHVzZSBcImdpdCBicmFuY2ggLS11bnNldC11cHN0cmVhbVwiIHRvIGZpeHVwKVxuIgogbXNnc3RyICIgIChiZW51dHplbiBTaWUgXCJnaXQgYnJhbmNoIC0tdW5zZXQtdXBzdHJlYW1cIiB6dW0gQmVoZWJlbilcbiIKIAotIzogcmVtb3RlLmM6MjAyMworIzogcmVtb3RlLmM6MjAyNgogIywgYy1mb3JtYXQKIG1zZ2lkICJZb3VyIGJyYW5jaCBpcyB1cCB0byBkYXRlIHdpdGggJyVzJy5cbiIKIG1zZ3N0ciAiSWhyIEJyYW5jaCBpc3QgYXVmIGRlbXNlbGJlbiBTdGFuZCB3aWUgJyVzJy5cbiIKIAotIzogcmVtb3RlLmM6MjAyNworIzogcmVtb3RlLmM6MjAzMAogIywgYy1mb3JtYXQKIG1zZ2lkICJZb3VyIGJyYW5jaCBhbmQgJyVzJyByZWZlciB0byBkaWZmZXJlbnQgY29tbWl0cy5cbiIKIG1zZ3N0ciAiSWhyIEJyYW5jaCB1bmQgJyVzJyB6ZWlnZW4gYXVmIHVudGVyc2NoaWVkbGljaGUgQ29tbWl0cy5cbiIKIAotIzogcmVtb3RlLmM6MjAzMAorIzogcmVtb3RlLmM6MjAzMwogIywgYy1mb3JtYXQKIG1zZ2lkICIgICh1c2UgXCIlc1wiIGZvciBkZXRhaWxzKVxuIgogbXNnc3RyICIgIChiZW51dHplbiBTaWUgXCIlc1wiIGbDvHIgRGV0YWlscylcbiIKIAotIzogcmVtb3RlLmM6MjAzNAorIzogcmVtb3RlLmM6MjAzNwogIywgYy1mb3JtYXQKIG1zZ2lkICJZb3VyIGJyYW5jaCBpcyBhaGVhZCBvZiAnJXMnIGJ5ICVkIGNvbW1pdC5cbiIKIG1zZ2lkX3BsdXJhbCAiWW91ciBicmFuY2ggaXMgYWhlYWQgb2YgJyVzJyBieSAlZCBjb21taXRzLlxuIgogbXNnc3RyWzBdICJJaHIgQnJhbmNoIGlzdCAlMiRkIENvbW1pdCB2b3IgJyUxJHMnLlxuIgogbXNnc3RyWzFdICJJaHIgQnJhbmNoIGlzdCAlMiRkIENvbW1pdHMgdm9yICclMSRzJy5cbiIKIAotIzogcmVtb3RlLmM6MjA0MAorIzogcmVtb3RlLmM6MjA0MwogbXNnaWQgIiAgKHVzZSBcImdpdCBwdXNoXCIgdG8gcHVibGlzaCB5b3VyIGxvY2FsIGNvbW1pdHMpXG4iCiBtc2dzdHIgIiAgKGJlbnV0emVuIFNpZSBcImdpdCBwdXNoXCIsIHVtIGxva2FsZSBDb21taXRzIHp1IHB1YmxpemllcmVuKVxuIgogCi0jOiByZW1vdGUuYzoyMDQzCisjOiByZW1vdGUuYzoyMDQ2CiAjLCBjLWZvcm1hdAogbXNnaWQgIllvdXIgYnJhbmNoIGlzIGJlaGluZCAnJXMnIGJ5ICVkIGNvbW1pdCwgYW5kIGNhbiBiZSBmYXN0LWZvcndhcmRlZC5cbiIKIG1zZ2lkX3BsdXJhbCAiIgpAQCAtNTYxMywxMiArNTY0NywxMiBAQAogbXNnc3RyWzFdICIiCiAiSWhyIEJyYW5jaCBpc3QgJTIkZCBDb21taXRzIGhpbnRlciAnJTEkcycsIHVuZCBrYW5uIHZvcmdlc3B1bHQgd2VyZGVuLlxuIgogCi0jOiByZW1vdGUuYzoyMDUxCisjOiByZW1vdGUuYzoyMDU0CiBtc2dpZCAiICAodXNlIFwiZ2l0IHB1bGxcIiB0byB1cGRhdGUgeW91ciBsb2NhbCBicmFuY2gpXG4iCiBtc2dzdHIgIiIKICIgIChiZW51dHplbiBTaWUgXCJnaXQgcHVsbFwiLCB1bSBJaHJlbiBsb2thbGVuIEJyYW5jaCB6dSBha3R1YWxpc2llcmVuKVxuIgogCi0jOiByZW1vdGUuYzoyMDU0CisjOiByZW1vdGUuYzoyMDU3CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJZb3VyIGJyYW5jaCBhbmQgJyVzJyBoYXZlIGRpdmVyZ2VkLFxuIgpAQCAtNTYzMywxMyArNTY2NywxMyBAQAogIklociBCcmFuY2ggdW5kICclcycgc2luZCBkaXZlcmdpZXJ0LFxuIgogInVuZCBoYWJlbiBqZXdlaWxzICVkIHVuZCAlZCB1bnRlcnNjaGllZGxpY2hlIENvbW1pdHMuXG4iCiAKLSM6IHJlbW90ZS5jOjIwNjQKKyM6IHJlbW90ZS5jOjIwNjcKIG1zZ2lkICIgICh1c2UgXCJnaXQgcHVsbFwiIHRvIG1lcmdlIHRoZSByZW1vdGUgYnJhbmNoIGludG8geW91cnMpXG4iCiBtc2dzdHIgIiIKICIgIChiZW51dHplbiBTaWUgXCJnaXQgcHVsbFwiLCB1bSBJaHJlbiBCcmFuY2ggbWl0IGRlbSBSZW1vdGUtQnJhbmNoICIKICJ6dXNhbW1lbnp1ZsO8aHJlbilcbiIKIAotIzogcmVtb3RlLmM6MjI0NworIzogcmVtb3RlLmM6MjI1MAogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgcGFyc2UgZXhwZWN0ZWQgb2JqZWN0IG5hbWUgJyVzJyIKIG1zZ3N0ciAiS2FubiBlcndhcnRldGVuIE9iamVrdG5hbWVuICclcycgbmljaHQgcGFyc2VuLiIKQEAgLTU3MTcsNyArNTc1MSw3IEBACiBtc2dpZCAiUmVjb3JkZWQgcHJlaW1hZ2UgZm9yICclcyciCiBtc2dzdHIgIlByZWltYWdlIGbDvHIgJyVzJyBhdWZnZXplaWNobmV0LiIKIAotIzogcmVyZXJlLmM6ODgxIHN1Ym1vZHVsZS5jOjIwMjMgYnVpbHRpbi9sb2cuYzoxNzczCisjOiByZXJlcmUuYzo4ODEgc3VibW9kdWxlLmM6MjAyMyBidWlsdGluL2xvZy5jOjE3OTAKICM6IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxNDE4IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxNDI4CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBjcmVhdGUgZGlyZWN0b3J5ICclcyciCkBAIC01NzUyLDIwICs1Nzg2LDIwIEBACiBtc2dpZCAidW5hYmxlIHRvIG9wZW4gcnItY2FjaGUgZGlyZWN0b3J5IgogbXNnc3RyICJLb25udGUgcnItY2FjaGUgVmVyemVpY2huaXMgbmljaHQgw7ZmZm5lbi4iCiAKLSM6IHJldmlzaW9uLmM6MjUwNworIzogcmV2aXNpb24uYzoyNTA5CiBtc2dpZCAieW91ciBjdXJyZW50IGJyYW5jaCBhcHBlYXJzIHRvIGJlIGJyb2tlbiIKIG1zZ3N0ciAiSWhyIGFrdHVlbGxlciBCcmFuY2ggc2NoZWludCBmZWhsZXJoYWZ0IHp1IHNlaW4uIgogCi0jOiByZXZpc2lvbi5jOjI1MTAKKyM6IHJldmlzaW9uLmM6MjUxMgogIywgYy1mb3JtYXQKIG1zZ2lkICJ5b3VyIGN1cnJlbnQgYnJhbmNoICclcycgZG9lcyBub3QgaGF2ZSBhbnkgY29tbWl0cyB5ZXQiCiBtc2dzdHIgIklociBha3R1ZWxsZXIgQnJhbmNoICclcycgaGF0IG5vY2gga2VpbmUgQ29tbWl0cy4iCiAKLSM6IHJldmlzaW9uLmM6MjcxMAorIzogcmV2aXNpb24uYzoyNzIwCiBtc2dpZCAiLS1maXJzdC1wYXJlbnQgaXMgaW5jb21wYXRpYmxlIHdpdGggLS1iaXNlY3QiCiBtc2dzdHIgIkRpZSBPcHRpb25lbiAtLWZpcnN0LXBhcmVudCB1bmQgLS1iaXNlY3Qgc2luZCBpbmtvbXBhdGliZWwuIgogCi0jOiByZXZpc2lvbi5jOjI3MTQKKyM6IHJldmlzaW9uLmM6MjcyNAogbXNnaWQgIi1MIGRvZXMgbm90IHlldCBzdXBwb3J0IGRpZmYgZm9ybWF0cyBiZXNpZGVzIC1wIGFuZCAtcyIKIG1zZ3N0ciAiLUwgdW50ZXJzdMO8dHp0IG5vY2gga2VpbmUgYW5kZXJlbiBEaWZmLUZvcm1hdGUgYXXDn2VyIC1wIHVuZCAtcyIKIApAQCAtNTc4OCwzMCArNTgyMiwzMCBAQAogIlNpZSBrw7ZubmVuIGRpZXNlIFdhcm51bmcgbWl0IGBnaXQgY29uZmlnIGFkdmljZS5pZ25vcmVkSG9vayBmYWxzZWAgIgogImRlYWt0aXZpZXJlbi4iCiAKLSM6IHNlbmQtcGFjay5jOjE0MQorIzogc2VuZC1wYWNrLmM6MTQyCiBtc2dpZCAidW5leHBlY3RlZCBmbHVzaCBwYWNrZXQgd2hpbGUgcmVhZGluZyByZW1vdGUgdW5wYWNrIHN0YXR1cyIKIG1zZ3N0ciAiVW5lcndhcnRldGVzIEZsdXNoLVBha2V0IGJlaW0gTGVzZW4gZGVzIFJlbW90ZS1VbnBhY2stU3RhdHVzLiIKIAotIzogc2VuZC1wYWNrLmM6MTQzCisjOiBzZW5kLXBhY2suYzoxNDQKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHBhcnNlIHJlbW90ZSB1bnBhY2sgc3RhdHVzOiAlcyIKIG1zZ3N0ciAiS29ubnRlIFN0YXR1cyBkZXMgRW50cGFja2VucyBkZXIgR2VnZW5zZWl0ZSBuaWNodCBwYXJzZW46ICVzIgogCi0jOiBzZW5kLXBhY2suYzoxNDUKKyM6IHNlbmQtcGFjay5jOjE0NgogIywgYy1mb3JtYXQKIG1zZ2lkICJyZW1vdGUgdW5wYWNrIGZhaWxlZDogJXMiCiBtc2dzdHIgIkVudHBhY2tlbiBhdWYgZGVyIEdlZ2Vuc2VpdGUgZmVobGdlc2NobGFnZW46ICVzIgogCi0jOiBzZW5kLXBhY2suYzozMDYKKyM6IHNlbmQtcGFjay5jOjMwNwogbXNnaWQgImZhaWxlZCB0byBzaWduIHRoZSBwdXNoIGNlcnRpZmljYXRlIgogbXNnc3RyICJGZWhsZXIgYmVpbSBTaWduaWVyZW4gZGVzIFwicHVzaFwiLVplcnRpZmlrYXRlcyIKIAotIzogc2VuZC1wYWNrLmM6NDIwCisjOiBzZW5kLXBhY2suYzo0MjEKIG1zZ2lkICJ0aGUgcmVjZWl2aW5nIGVuZCBkb2VzIG5vdCBzdXBwb3J0IC0tc2lnbmVkIHB1c2giCiBtc2dzdHIgIiIKICJkaWUgR2VnZW5zZWl0ZSB1bnRlcnN0w7x0enQga2VpbmVuIHNpZ25pZXJ0ZW4gVmVyc2FuZCAoXCItLXNpZ25lZCBwdXNoXCIpIgogCi0jOiBzZW5kLXBhY2suYzo0MjIKKyM6IHNlbmQtcGFjay5jOjQyMwogbXNnaWQgIiIKICJub3Qgc2VuZGluZyBhIHB1c2ggY2VydGlmaWNhdGUgc2luY2UgdGhlIHJlY2VpdmluZyBlbmQgZG9lcyBub3Qgc3VwcG9ydCAtLSIKICJzaWduZWQgcHVzaCIKQEAgLTU4MTksMTEgKzU4NTMsMTEgQEAKICJrZWluIFZlcnNhbmQgZGVzIFwicHVzaFwiLVplcnRpZmlrYXRlcywgZGEgZGllIEdlZ2Vuc2VpdGUga2VpbmVuIHNpZ25pZXJ0ZW5cbiIKICJWZXJzYW5kIChcIi0tc2lnbmVkIHB1c2hcIikgdW50ZXJzdMO8dHp0IgogCi0jOiBzZW5kLXBhY2suYzo0MzQKKyM6IHNlbmQtcGFjay5jOjQzNQogbXNnaWQgInRoZSByZWNlaXZpbmcgZW5kIGRvZXMgbm90IHN1cHBvcnQgLS1hdG9taWMgcHVzaCIKIG1zZ3N0ciAiZGllIEdlZ2Vuc2VpdGUgdW50ZXJzdMO8dHp0IGtlaW5lbiBhdG9tYXJlbiBWZXJzYW5kIChcIi0tYXRvbWljIHB1c2hcIikiCiAKLSM6IHNlbmQtcGFjay5jOjQzOQorIzogc2VuZC1wYWNrLmM6NDQwCiBtc2dpZCAidGhlIHJlY2VpdmluZyBlbmQgZG9lcyBub3Qgc3VwcG9ydCBwdXNoIG9wdGlvbnMiCiBtc2dzdHIgImRpZSBHZWdlbnNlaXRlIHVudGVyc3TDvHR6dCBrZWluZSBQdXNoLU9wdGlvbmVuIgogCkBAIC01ODM3LDcgKzU4NzEsNyBAQAogbXNnaWQgImNvdWxkIG5vdCBkZWxldGUgJyVzJyIKIG1zZ3N0ciAiS29ubnRlICclcycgbmljaHQgbMO2c2NoZW4uIgogCi0jOiBzZXF1ZW5jZXIuYzozMTEgYnVpbHRpbi9yZWJhc2UuYzo3NTkgYnVpbHRpbi9yZWJhc2UuYzoxNjQ1IGJ1aWx0aW4vcm0uYzozNjkKKyM6IHNlcXVlbmNlci5jOjMxMSBidWlsdGluL3JlYmFzZS5jOjc2MCBidWlsdGluL3JlYmFzZS5jOjE2NzYgYnVpbHRpbi9ybS5jOjM2OQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcmVtb3ZlICclcyciCiBtc2dzdHIgIktvbm50ZSAnJXMnIG5pY2h0IGzDtnNjaGVuIgpAQCAtNTg3Nyw3ICs1OTExLDcgQEAKICJtaXQgJ2dpdCBhZGQgPFBmYWRlPicgb2RlciAnZ2l0IHJtIDxQZmFkZT4nIHVuZCB0cmFnZW4gU2llIGRhcyBFcmdlYm5pcyBtaXRcbiIKICInZ2l0IGNvbW1pdCcgZWluIgogCi0jOiBzZXF1ZW5jZXIuYzo0MDEgc2VxdWVuY2VyLmM6MjkwOQorIzogc2VxdWVuY2VyLmM6NDAxIHNlcXVlbmNlci5jOjI4NDcKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGxvY2sgJyVzJyIKIG1zZ3N0ciAiS29ubnRlICclcycgbmljaHQgc3BlcnJlbiIKQEAgLTU4ODcsMTUgKzU5MjEsMTUgQEAKIG1zZ2lkICJjb3VsZCBub3Qgd3JpdGUgZW9sIHRvICclcyciCiBtc2dzdHIgIktvbm50ZSBFT0wgbmljaHQgbmFjaCAnJXMnIHNjaHJlaWJlbi4iCiAKLSM6IHNlcXVlbmNlci5jOjQxMyBzZXF1ZW5jZXIuYzoyNzE0IHNlcXVlbmNlci5jOjI5MTUgc2VxdWVuY2VyLmM6MjkyOQotIzogc2VxdWVuY2VyLmM6MzE5MgorIzogc2VxdWVuY2VyLmM6NDEzIHNlcXVlbmNlci5jOjI2NTIgc2VxdWVuY2VyLmM6Mjg1MyBzZXF1ZW5jZXIuYzoyODY3CisjOiBzZXF1ZW5jZXIuYzozMTMwCiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBmaW5hbGl6ZSAnJXMnIgogbXNnc3RyICJGZWhsZXIgYmVpbSBGZXJ0aWdzdGVsbGVuIHZvbiAnJXMnLiIKIAotIzogc2VxdWVuY2VyLmM6NDM2IHNlcXVlbmNlci5jOjk4MSBzZXF1ZW5jZXIuYzoxNjU1IHNlcXVlbmNlci5jOjI3MzQKLSM6IHNlcXVlbmNlci5jOjMxNzQgc2VxdWVuY2VyLmM6MzI4MyBidWlsdGluL2FtLmM6MjQ1IGJ1aWx0aW4vY29tbWl0LmM6NzYzCi0jOiBidWlsdGluL21lcmdlLmM6MTExMiBidWlsdGluL3JlYmFzZS5jOjU2NworIzogc2VxdWVuY2VyLmM6NDM2IHNlcXVlbmNlci5jOjE1ODUgc2VxdWVuY2VyLmM6MjY3MiBzZXF1ZW5jZXIuYzozMTEyCisjOiBzZXF1ZW5jZXIuYzozMjIxIGJ1aWx0aW4vYW0uYzoyNDQgYnVpbHRpbi9jb21taXQuYzo3NjMgYnVpbHRpbi9tZXJnZS5jOjExMTcKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NTY4CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCByZWFkICclcyciCiBtc2dzdHIgIktvbm50ZSAnJXMnIG5pY2h0IGxlc2VuIgpAQCAtNTkyMyw3MCArNTk1Nyw2NSBAQAogIy4gVFJBTlNMQVRPUlM6ICVzIHdpbGwgYmUgInJldmVydCIsICJjaGVycnktcGljayIgb3IKICMuICJyZWJhc2UgLWkiLgogIy4KLSM6IHNlcXVlbmNlci5jOjYzMgorIzogc2VxdWVuY2VyLmM6NjMxCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiBVbmFibGUgdG8gd3JpdGUgbmV3IGluZGV4IGZpbGUiCiBtc2dzdHIgIiVzOiBLb25udGUgbmV1ZSBJbmRleC1EYXRlaSBuaWNodCBzY2hyZWliZW4iCiAKLSM6IHNlcXVlbmNlci5jOjY0OQorIzogc2VxdWVuY2VyLmM6NjQ4CiBtc2dpZCAidW5hYmxlIHRvIHVwZGF0ZSBjYWNoZSB0cmVlIgogbXNnc3RyICJLb25udGUgQ2FjaGUtVmVyemVpY2huaXMgbmljaHQgYWt0dWFsaXNpZXJlbi4iCiAKLSM6IHNlcXVlbmNlci5jOjY2MworIzogc2VxdWVuY2VyLmM6NjYyCiBtc2dpZCAiY291bGQgbm90IHJlc29sdmUgSEVBRCBjb21taXQiCiBtc2dzdHIgIktvbm50ZSBIRUFELUNvbW1pdCBuaWNodCBhdWZsw7ZzZW4uIgogCi0jOiBzZXF1ZW5jZXIuYzo3NDMKKyM6IHNlcXVlbmNlci5jOjc0MgogIywgYy1mb3JtYXQKIG1zZ2lkICJubyBrZXkgcHJlc2VudCBpbiAnJS4qcyciCiBtc2dzdHIgIktlaW4gU2NobMO8c3NlbCBpbiAnJS4qcycgdm9yaGFuZGVuLiIKIAotIzogc2VxdWVuY2VyLmM6NzU0CisjOiBzZXF1ZW5jZXIuYzo3NTMKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGRlcXVvdGUgdmFsdWUgb2YgJyVzJyIKIG1zZ3N0ciAiS29ubnRlIEFuZsO8aHJ1bmdzemVpY2hlbiB2b24gJyVzJyBuaWNodCBlbnRmZXJuZW4uIgogCi0jOiBzZXF1ZW5jZXIuYzo3OTEgd3JhcHBlci5jOjIyNyB3cmFwcGVyLmM6Mzk3IGJ1aWx0aW4vYW0uYzo3MDYKLSM6IGJ1aWx0aW4vYW0uYzo3OTggYnVpbHRpbi9tZXJnZS5jOjExMDkgYnVpbHRpbi9yZWJhc2UuYzoxMDQ1CisjOiBzZXF1ZW5jZXIuYzo3OTAgd3JhcHBlci5jOjE5MCB3cmFwcGVyLmM6MzYwIGJ1aWx0aW4vYW0uYzo3MDUKKyM6IGJ1aWx0aW4vYW0uYzo3OTcgYnVpbHRpbi9tZXJnZS5jOjExMTQgYnVpbHRpbi9yZWJhc2UuYzoxMDQ2CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBvcGVuICclcycgZm9yIHJlYWRpbmciCiBtc2dzdHIgIktvbm50ZSAnJXMnIG5pY2h0IHp1bSBMZXNlbiDDtmZmbmVuLiIKIAotIzogc2VxdWVuY2VyLmM6ODAxCisjOiBzZXF1ZW5jZXIuYzo4MDAKIG1zZ2lkICInR0lUX0FVVEhPUl9OQU1FJyBhbHJlYWR5IGdpdmVuIgogbXNnc3RyICInR0lUX0FVVEhPUl9OQU1FJyBiZXJlaXRzIGFuZ2VnZWJlbi4iCiAKLSM6IHNlcXVlbmNlci5jOjgwNgorIzogc2VxdWVuY2VyLmM6ODA1CiBtc2dpZCAiJ0dJVF9BVVRIT1JfRU1BSUwnIGFscmVhZHkgZ2l2ZW4iCiBtc2dzdHIgIidHSVRfQVVUSE9SX0VNQUlMJyBiZXJlaXRzIGFuZ2VnZWJlbi4iCiAKLSM6IHNlcXVlbmNlci5jOjgxMQorIzogc2VxdWVuY2VyLmM6ODEwCiBtc2dpZCAiJ0dJVF9BVVRIT1JfREFURScgYWxyZWFkeSBnaXZlbiIKIG1zZ3N0ciAiJ0dJVF9BVVRIT1JfREFURScgYmVyZWl0cyBhbmdlZ2ViZW4uIgogCi0jOiBzZXF1ZW5jZXIuYzo4MTUKKyM6IHNlcXVlbmNlci5jOjgxNAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmtub3duIHZhcmlhYmxlICclcyciCiBtc2dzdHIgIlVuYmVrYW5udGUgVmFyaWFibGUgJyVzJyIKIAotIzogc2VxdWVuY2VyLmM6ODIwCisjOiBzZXF1ZW5jZXIuYzo4MTkKIG1zZ2lkICJtaXNzaW5nICdHSVRfQVVUSE9SX05BTUUnIgogbXNnc3RyICInR0lUX0FVVEhPUl9OQU1FJyBmZWhsdC4iCiAKLSM6IHNlcXVlbmNlci5jOjgyMgorIzogc2VxdWVuY2VyLmM6ODIxCiBtc2dpZCAibWlzc2luZyAnR0lUX0FVVEhPUl9FTUFJTCciCiBtc2dzdHIgIidHSVRfQVVUSE9SX0VNQUlMJyBmZWhsdC4iCiAKLSM6IHNlcXVlbmNlci5jOjgyNAorIzogc2VxdWVuY2VyLmM6ODIzCiBtc2dpZCAibWlzc2luZyAnR0lUX0FVVEhPUl9EQVRFJyIKIG1zZ3N0ciAiJ0dJVF9BVVRIT1JfREFURScgZmVobHQuIgogCi0jOiBzZXF1ZW5jZXIuYzo4ODQKLSMsIGMtZm9ybWF0Ci1tc2dpZCAiaW52YWxpZCBkYXRlIGZvcm1hdCAnJXMnIGluICclcyciCi1tc2dzdHIgIlVuZ8O8bHRpZ2VzIERhdHVtc2Zvcm1hdCAnJXMnIGluICclcyciCi0KLSM6IHNlcXVlbmNlci5jOjkwMQorIzogc2VxdWVuY2VyLmM6ODcyCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJ5b3UgaGF2ZSBzdGFnZWQgY2hhbmdlcyBpbiB5b3VyIHdvcmtpbmcgdHJlZVxuIgpAQCAtNjAxNywxNSArNjA0NiwxMSBAQAogIlxuIgogIiAgZ2l0IHJlYmFzZSAtLWNvbnRpbnVlXG4iCiAKLSM6IHNlcXVlbmNlci5jOjk5NQotbXNnaWQgIndyaXRpbmcgcm9vdCBjb21taXQiCi1tc2dzdHIgIlJvb3QtQ29tbWl0IHNjaHJlaWJlbiIKLQotIzogc2VxdWVuY2VyLmM6MTIxNgorIzogc2VxdWVuY2VyLmM6MTE0NgogbXNnaWQgIidwcmVwYXJlLWNvbW1pdC1tc2cnIGhvb2sgZmFpbGVkIgogbXNnc3RyICIncHJlcGFyZS1jb21taXQtbXNnJyBIb29rIGZlaGxnZXNjaGxhZ2VuLiIKIAotIzogc2VxdWVuY2VyLmM6MTIyMworIzogc2VxdWVuY2VyLmM6MTE1MwogbXNnaWQgIiIKICJZb3VyIG5hbWUgYW5kIGVtYWlsIGFkZHJlc3Mgd2VyZSBjb25maWd1cmVkIGF1dG9tYXRpY2FsbHkgYmFzZWRcbiIKICJvbiB5b3VyIHVzZXJuYW1lIGFuZCBob3N0bmFtZS4gUGxlYXNlIGNoZWNrIHRoYXQgdGhleSBhcmUgYWNjdXJhdGUuXG4iCkBAIC02MDUzLDcgKzYwNzgsNyBAQAogIlxuIgogIiAgICBnaXQgY29tbWl0IC0tYW1lbmQgLS1yZXNldC1hdXRob3JcbiIKIAotIzogc2VxdWVuY2VyLmM6MTIzNgorIzogc2VxdWVuY2VyLmM6MTE2NgogbXNnaWQgIiIKICJZb3VyIG5hbWUgYW5kIGVtYWlsIGFkZHJlc3Mgd2VyZSBjb25maWd1cmVkIGF1dG9tYXRpY2FsbHkgYmFzZWRcbiIKICJvbiB5b3VyIHVzZXJuYW1lIGFuZCBob3N0bmFtZS4gUGxlYXNlIGNoZWNrIHRoYXQgdGhleSBhcmUgYWNjdXJhdGUuXG4iCkBAIC02MDc5LDMyNyArNjEwNCwzMjcgQEAKICJcbiIKICIgICAgZ2l0IGNvbW1pdCAtLWFtZW5kIC0tcmVzZXQtYXV0aG9yXG4iCiAKLSM6IHNlcXVlbmNlci5jOjEyNzgKKyM6IHNlcXVlbmNlci5jOjEyMDgKIG1zZ2lkICJjb3VsZG4ndCBsb29rIHVwIG5ld2x5IGNyZWF0ZWQgY29tbWl0IgogbXNnc3RyICJLb25udGUgbmV1IGVyc3RlbGx0ZW4gQ29tbWl0IG5pY2h0IG5hY2hzY2hsYWdlbi4iCiAKLSM6IHNlcXVlbmNlci5jOjEyODAKKyM6IHNlcXVlbmNlci5jOjEyMTAKIG1zZ2lkICJjb3VsZCBub3QgcGFyc2UgbmV3bHkgY3JlYXRlZCBjb21taXQiCiBtc2dzdHIgIktvbm50ZSBuZXUgZXJzdGVsbHRlbiBDb21taXQgbmljaHQgYW5hbHlzaWVyZW4uIgogCi0jOiBzZXF1ZW5jZXIuYzoxMzI2CisjOiBzZXF1ZW5jZXIuYzoxMjU2CiBtc2dpZCAidW5hYmxlIHRvIHJlc29sdmUgSEVBRCBhZnRlciBjcmVhdGluZyBjb21taXQiCiBtc2dzdHIgIktvbm50ZSBIRUFEIG5pY2h0IGF1ZmzDtnNlbiwgbmFjaGRlbSBkZXIgQ29tbWl0IGVyc3RlbGx0IHd1cmRlLiIKIAotIzogc2VxdWVuY2VyLmM6MTMyOAorIzogc2VxdWVuY2VyLmM6MTI1OAogbXNnaWQgImRldGFjaGVkIEhFQUQiCiBtc2dzdHIgImxvc2dlbMO2c3RlciBIRUFEIgogCi0jOiBzZXF1ZW5jZXIuYzoxMzMyCisjOiBzZXF1ZW5jZXIuYzoxMjYyCiBtc2dpZCAiIChyb290LWNvbW1pdCkiCiBtc2dzdHIgIiAoUm9vdC1Db21taXQpIgogCi0jOiBzZXF1ZW5jZXIuYzoxMzUzCisjOiBzZXF1ZW5jZXIuYzoxMjgzCiBtc2dpZCAiY291bGQgbm90IHBhcnNlIEhFQUQiCiBtc2dzdHIgIktvbm50ZSBIRUFEIG5pY2h0IHBhcnNlbi4iCiAKLSM6IHNlcXVlbmNlci5jOjEzNTUKKyM6IHNlcXVlbmNlci5jOjEyODUKICMsIGMtZm9ybWF0CiBtc2dpZCAiSEVBRCAlcyBpcyBub3QgYSBjb21taXQhIgogbXNnc3RyICJIRUFEICVzIGlzdCBrZWluIENvbW1pdCEiCiAKLSM6IHNlcXVlbmNlci5jOjEzNTkgYnVpbHRpbi9jb21taXQuYzoxNTcxCisjOiBzZXF1ZW5jZXIuYzoxMjg5IGJ1aWx0aW4vY29tbWl0LmM6MTU3MQogbXNnaWQgImNvdWxkIG5vdCBwYXJzZSBIRUFEIGNvbW1pdCIKIG1zZ3N0ciAiS29ubnRlIENvbW1pdCB2b24gSEVBRCBuaWNodCBhbmFseXNpZXJlbi4iCiAKLSM6IHNlcXVlbmNlci5jOjE0MTEgc2VxdWVuY2VyLmM6MjAwNAorIzogc2VxdWVuY2VyLmM6MTM0MSBzZXF1ZW5jZXIuYzoxOTMzCiBtc2dpZCAidW5hYmxlIHRvIHBhcnNlIGNvbW1pdCBhdXRob3IiCiBtc2dzdHIgIktvbm50ZSBDb21taXQtQXV0b3IgbmljaHQgcGFyc2VuLiIKIAotIzogc2VxdWVuY2VyLmM6MTQyMSBidWlsdGluL2FtLmM6MTU3MyBidWlsdGluL21lcmdlLmM6Njg0CisjOiBzZXF1ZW5jZXIuYzoxMzUyIGJ1aWx0aW4vYW0uYzoxNTYxIGJ1aWx0aW4vbWVyZ2UuYzo2ODQKIG1zZ2lkICJnaXQgd3JpdGUtdHJlZSBmYWlsZWQgdG8gd3JpdGUgYSB0cmVlIgogbXNnc3RyICJcImdpdCB3cml0ZS10cmVlXCIgc2NobHVnIGJlaW0gU2NocmVpYmVuIGVpbmVzIFwiVHJlZVwiLU9iamVrdGVzIGZlaGwiCiAKLSM6IHNlcXVlbmNlci5jOjE0Mzggc2VxdWVuY2VyLmM6MTQ5OQorIzogc2VxdWVuY2VyLmM6MTM2OSBzZXF1ZW5jZXIuYzoxNDI5CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byByZWFkIGNvbW1pdCBtZXNzYWdlIGZyb20gJyVzJyIKIG1zZ3N0ciAiS29ubnRlIENvbW1pdC1CZXNjaHJlaWJ1bmcgdm9uICclcycgbmljaHQgbGVzZW4uIgogCi0jOiBzZXF1ZW5jZXIuYzoxNDY1IGJ1aWx0aW4vYW0uYzoxNTk1IGJ1aWx0aW4vY29tbWl0LmM6MTY3MCBidWlsdGluL21lcmdlLmM6ODc4Ci0jOiBidWlsdGluL21lcmdlLmM6OTAzCisjOiBzZXF1ZW5jZXIuYzoxMzk2IGJ1aWx0aW4vYW0uYzoxNTgzIGJ1aWx0aW4vY29tbWl0LmM6MTY3MCBidWlsdGluL21lcmdlLmM6ODgzCisjOiBidWlsdGluL21lcmdlLmM6OTA4CiBtc2dpZCAiZmFpbGVkIHRvIHdyaXRlIGNvbW1pdCBvYmplY3QiCiBtc2dzdHIgIkZlaGxlciBiZWltIFNjaHJlaWJlbiBkZXMgQ29tbWl0LU9iamVrdGVzLiIKIAotIzogc2VxdWVuY2VyLmM6MTUyNgorIzogc2VxdWVuY2VyLmM6MTQ1NgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcGFyc2UgY29tbWl0ICVzIgogbXNnc3RyICJLb25udGUgQ29tbWl0ICVzIG5pY2h0IHBhcnNlbi4iCiAKLSM6IHNlcXVlbmNlci5jOjE1MzEKKyM6IHNlcXVlbmNlci5jOjE0NjEKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHBhcnNlIHBhcmVudCBjb21taXQgJXMiCiBtc2dzdHIgIktvbm50ZSBFbHRlcm4tQ29tbWl0ICVzIG5pY2h0IHBhcnNlbi4iCiAKLSM6IHNlcXVlbmNlci5jOjE2MDUgc2VxdWVuY2VyLmM6MTcxNQorIzogc2VxdWVuY2VyLmM6MTUzNSBzZXF1ZW5jZXIuYzoxNjQ1CiAjLCBjLWZvcm1hdAogbXNnaWQgInVua25vd24gY29tbWFuZDogJWQiCiBtc2dzdHIgIlVuYmVrYW5udGVyIEJlZmVobDogJWQiCiAKLSM6IHNlcXVlbmNlci5jOjE2NjIgc2VxdWVuY2VyLmM6MTY4NworIzogc2VxdWVuY2VyLmM6MTU5MiBzZXF1ZW5jZXIuYzoxNjE3CiAjLCBjLWZvcm1hdAogbXNnaWQgIlRoaXMgaXMgYSBjb21iaW5hdGlvbiBvZiAlZCBjb21taXRzLiIKIG1zZ3N0ciAiRGFzIGlzdCBlaW5lIEtvbWJpbmF0aW9uIGF1cyAlZCBDb21taXRzLiIKIAotIzogc2VxdWVuY2VyLmM6MTY3MgorIzogc2VxdWVuY2VyLmM6MTYwMgogbXNnaWQgIm5lZWQgYSBIRUFEIHRvIGZpeHVwIgogbXNnc3RyICJiZW7DtnRpZ2UgSEVBRCBmw7xyIGZpeHVwIgogCi0jOiBzZXF1ZW5jZXIuYzoxNjc0IHNlcXVlbmNlci5jOjMyMTkKKyM6IHNlcXVlbmNlci5jOjE2MDQgc2VxdWVuY2VyLmM6MzE1NwogbXNnaWQgImNvdWxkIG5vdCByZWFkIEhFQUQiCiBtc2dzdHIgIktvbm50ZSBIRUFEIG5pY2h0IGxlc2VuIgogCi0jOiBzZXF1ZW5jZXIuYzoxNjc2CisjOiBzZXF1ZW5jZXIuYzoxNjA2CiBtc2dpZCAiY291bGQgbm90IHJlYWQgSEVBRCdzIGNvbW1pdCBtZXNzYWdlIgogbXNnc3RyICJLb25udGUgQ29tbWl0LUJlc2NocmVpYnVuZyB2b24gSEVBRCBuaWNodCBsZXNlbiIKIAotIzogc2VxdWVuY2VyLmM6MTY4MgorIzogc2VxdWVuY2VyLmM6MTYxMgogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3Qgd3JpdGUgJyVzJyIKIG1zZ3N0ciAia2FubiAnJXMnIG5pY2h0IHNjaHJlaWJlbiIKIAotIzogc2VxdWVuY2VyLmM6MTY4OSBnaXQtcmViYXNlLS1wcmVzZXJ2ZS1tZXJnZXMuc2g6NDk2CisjOiBzZXF1ZW5jZXIuYzoxNjE5IGdpdC1yZWJhc2UtLXByZXNlcnZlLW1lcmdlcy5zaDo0OTYKIG1zZ2lkICJUaGlzIGlzIHRoZSAxc3QgY29tbWl0IG1lc3NhZ2U6IgogbXNnc3RyICJEYXMgaXN0IGRpZSBlcnN0ZSBDb21taXQtQmVzY2hyZWlidW5nOiIKIAotIzogc2VxdWVuY2VyLmM6MTY5NworIzogc2VxdWVuY2VyLmM6MTYyNwogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcmVhZCBjb21taXQgbWVzc2FnZSBvZiAlcyIKIG1zZ3N0ciAiS29ubnRlIENvbW1pdC1CZXNjaHJlaWJ1bmcgdm9uICVzIG5pY2h0IGxlc2VuLiIKIAotIzogc2VxdWVuY2VyLmM6MTcwNAorIzogc2VxdWVuY2VyLmM6MTYzNAogIywgYy1mb3JtYXQKIG1zZ2lkICJUaGlzIGlzIHRoZSBjb21taXQgbWVzc2FnZSAjJWQ6IgogbXNnc3RyICJEYXMgaXN0IENvbW1pdC1CZXNjaHJlaWJ1bmcgIyVkOiIKIAotIzogc2VxdWVuY2VyLmM6MTcxMAorIzogc2VxdWVuY2VyLmM6MTY0MAogIywgYy1mb3JtYXQKIG1zZ2lkICJUaGUgY29tbWl0IG1lc3NhZ2UgIyVkIHdpbGwgYmUgc2tpcHBlZDoiCiBtc2dzdHIgIkRpZSBDb21taXQtQmVzY2hyZWlidW5nICMlZCB3aXJkIGF1c2dlbGFzc2VuOiIKIAotIzogc2VxdWVuY2VyLmM6MTc5OAorIzogc2VxdWVuY2VyLmM6MTcyOAogbXNnaWQgInlvdXIgaW5kZXggZmlsZSBpcyB1bm1lcmdlZC4iCiBtc2dzdHIgIklocmUgSW5kZXgtRGF0ZWkgaXN0IG5pY2h0IHp1c2FtbWVuZ2Vmw7xocnQuIgogCi0jOiBzZXF1ZW5jZXIuYzoxODA1CisjOiBzZXF1ZW5jZXIuYzoxNzM1CiBtc2dpZCAiY2Fubm90IGZpeHVwIHJvb3QgY29tbWl0IgogbXNnc3RyICJrYW5uIGZpeHVwIG5pY2h0IGF1ZiBSb290LUNvbW1pdCBhbndlbmRlbiIKIAotIzogc2VxdWVuY2VyLmM6MTgyNAorIzogc2VxdWVuY2VyLmM6MTc1NAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb21taXQgJXMgaXMgYSBtZXJnZSBidXQgbm8gLW0gb3B0aW9uIHdhcyBnaXZlbi4iCiBtc2dzdHIgIkNvbW1pdCAlcyBpc3QgZWluIE1lcmdlLCBhYmVyIGRpZSBPcHRpb24gLW0gd3VyZGUgbmljaHQgYW5nZWdlYmVuLiIKIAotIzogc2VxdWVuY2VyLmM6MTgzMiBzZXF1ZW5jZXIuYzoxODQwCisjOiBzZXF1ZW5jZXIuYzoxNzYyIHNlcXVlbmNlci5jOjE3NzAKICMsIGMtZm9ybWF0CiBtc2dpZCAiY29tbWl0ICVzIGRvZXMgbm90IGhhdmUgcGFyZW50ICVkIgogbXNnc3RyICJDb21taXQgJXMgaGF0IGtlaW5lbiBFbHRlcm4tQ29tbWl0ICVkIgogCi0jOiBzZXF1ZW5jZXIuYzoxODQ2CisjOiBzZXF1ZW5jZXIuYzoxNzc2CiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCBnZXQgY29tbWl0IG1lc3NhZ2UgZm9yICVzIgogbXNnc3RyICJLYW5uIGtlaW5lIENvbW1pdC1CZXNjaHJlaWJ1bmcgZsO8ciAlcyBiZWtvbW1lbi4iCiAKICMuIFRSQU5TTEFUT1JTOiBUaGUgZmlyc3QgJXMgd2lsbCBiZSBhICJ0b2RvIiBjb21tYW5kIGxpa2UKICMuICJyZXZlcnQiIG9yICJwaWNrIiwgdGhlIHNlY29uZCAlcyBhIFNIQTEuCi0jOiBzZXF1ZW5jZXIuYzoxODY1CisjOiBzZXF1ZW5jZXIuYzoxNzk1CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiBjYW5ub3QgcGFyc2UgcGFyZW50IGNvbW1pdCAlcyIKIG1zZ3N0ciAiJXM6IGthbm4gRWx0ZXJuLUNvbW1pdCAlcyBuaWNodCBwYXJzZW4iCiAKLSM6IHNlcXVlbmNlci5jOjE5MzAKKyM6IHNlcXVlbmNlci5jOjE4NjAKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHJlbmFtZSAnJXMnIHRvICclcyciCiBtc2dzdHIgIktvbm50ZSAnJXMnIG5pY2h0IHp1ICclcycgdW1iZW5lbm5lbi4iCiAKLSM6IHNlcXVlbmNlci5jOjE5ODUKKyM6IHNlcXVlbmNlci5jOjE5MTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHJldmVydCAlcy4uLiAlcyIKIG1zZ3N0ciAiS29ubnRlIFwicmV2ZXJ0XCIgbmljaHQgYXVmICVzLi4uICglcykgYXVzZsO8aHJlbiIKIAotIzogc2VxdWVuY2VyLmM6MTk4NgorIzogc2VxdWVuY2VyLmM6MTkxNgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgYXBwbHkgJXMuLi4gJXMiCiBtc2dzdHIgIktvbm50ZSAlcy4uLiAoJXMpIG5pY2h0IGFud2VuZGVuIgogCi0jOiBzZXF1ZW5jZXIuYzoyMDQ1CisjOiBzZXF1ZW5jZXIuYzoxOTgzCiAjLCBjLWZvcm1hdAogbXNnaWQgImdpdCAlczogZmFpbGVkIHRvIHJlYWQgdGhlIGluZGV4IgogbXNnc3RyICJnaXQgJXM6IEZlaGxlciBiZWltIExlc2VuIGRlcyBJbmRleCIKIAotIzogc2VxdWVuY2VyLmM6MjA1MgorIzogc2VxdWVuY2VyLmM6MTk5MAogIywgYy1mb3JtYXQKIG1zZ2lkICJnaXQgJXM6IGZhaWxlZCB0byByZWZyZXNoIHRoZSBpbmRleCIKIG1zZ3N0ciAiZ2l0ICVzOiBGZWhsZXIgYmVpbSBBa3R1YWxpc2llcmVuIGRlcyBJbmRleCIKIAotIzogc2VxdWVuY2VyLmM6MjEyOAorIzogc2VxdWVuY2VyLmM6MjA2NgogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyBkb2VzIG5vdCBhY2NlcHQgYXJndW1lbnRzOiAnJXMnIgogbXNnc3RyICIlcyBha3plcHRpZXJ0IGtlaW5lIEFyZ3VtZW50ZTogJyVzJyIKIAotIzogc2VxdWVuY2VyLmM6MjEzNworIzogc2VxdWVuY2VyLmM6MjA3NQogIywgYy1mb3JtYXQKIG1zZ2lkICJtaXNzaW5nIGFyZ3VtZW50cyBmb3IgJXMiCiBtc2dzdHIgIkZlaGxlbmRlIEFyZ3VtZW50ZSBmw7xyICVzLiIKIAotIzogc2VxdWVuY2VyLmM6MjE3NAorIzogc2VxdWVuY2VyLmM6MjExMgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcGFyc2UgJyUuKnMnIgogbXNnc3RyICJLb25udGUgJyUuKnMnIG5pY2h0IHBhcnNlbi4iCiAKLSM6IHNlcXVlbmNlci5jOjIyMjgKKyM6IHNlcXVlbmNlci5jOjIxNjYKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBsaW5lICVkOiAlLipzIgogbXNnc3RyICJVbmfDvGx0aWdlIFplaWxlICVkOiAlLipzIgogCi0jOiBzZXF1ZW5jZXIuYzoyMjM5CisjOiBzZXF1ZW5jZXIuYzoyMTc3CiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCAnJXMnIHdpdGhvdXQgYSBwcmV2aW91cyBjb21taXQiCiBtc2dzdHIgIkthbm4gJyVzJyBuaWNodCBvaG5lIHZvcmhlcmlnZW4gQ29tbWl0IGF1c2bDvGhyZW4iCiAKLSM6IHNlcXVlbmNlci5jOjIyODcgYnVpbHRpbi9yZWJhc2UuYzoxNTMgYnVpbHRpbi9yZWJhc2UuYzoxNzgKKyM6IHNlcXVlbmNlci5jOjIyMjUgYnVpbHRpbi9yZWJhc2UuYzoxNTMgYnVpbHRpbi9yZWJhc2UuYzoxNzgKICM6IGJ1aWx0aW4vcmViYXNlLmM6MjA0IGJ1aWx0aW4vcmViYXNlLmM6MjI5CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCByZWFkICclcycuIgogbXNnc3RyICJLb25udGUgJyVzJyBuaWNodCBsZXNlbi4iCiAKLSM6IHNlcXVlbmNlci5jOjIzMjMKKyM6IHNlcXVlbmNlci5jOjIyNjEKIG1zZ2lkICJjYW5jZWxsaW5nIGEgY2hlcnJ5IHBpY2tpbmcgaW4gcHJvZ3Jlc3MiCiBtc2dzdHIgIkFiYnJlY2hlbiBlaW5lcyBsYXVmZW5kZW4gXCJjaGVycnktcGlja1wiIgogCi0jOiBzZXF1ZW5jZXIuYzoyMzMwCisjOiBzZXF1ZW5jZXIuYzoyMjY4CiBtc2dpZCAiY2FuY2VsbGluZyBhIHJldmVydCBpbiBwcm9ncmVzcyIKIG1zZ3N0ciAiQWJicmVjaGVuIGVpbmVzIGxhdWZlbmRlbiBcInJldmVydFwiIgogCi0jOiBzZXF1ZW5jZXIuYzoyMzY0CisjOiBzZXF1ZW5jZXIuYzoyMzAyCiBtc2dpZCAicGxlYXNlIGZpeCB0aGlzIHVzaW5nICdnaXQgcmViYXNlIC0tZWRpdC10b2RvJy4iCiBtc2dzdHIgIiIKICJCaXR0ZSBiZWhlYmVuIFNpZSBkaWVzZXMsIGluZGVtIFNpZSAnZ2l0IHJlYmFzZSAtLWVkaXQtdG9kbycgYXVzZsO8aHJlbi4iCiAKLSM6IHNlcXVlbmNlci5jOjIzNjYKKyM6IHNlcXVlbmNlci5jOjIzMDQKICMsIGMtZm9ybWF0CiBtc2dpZCAidW51c2FibGUgaW5zdHJ1Y3Rpb24gc2hlZXQ6ICclcyciCiBtc2dzdHIgIlVuYmVudXR6YmFyZXMgSW5zdHJ1a3Rpb25zYmxhdHQ6ICclcyciCiAKLSM6IHNlcXVlbmNlci5jOjIzNzEKKyM6IHNlcXVlbmNlci5jOjIzMDkKIG1zZ2lkICJubyBjb21taXRzIHBhcnNlZC4iCiBtc2dzdHIgIktlaW5lIENvbW1pdHMgZ2VwYXJzdC4iCiAKLSM6IHNlcXVlbmNlci5jOjIzODIKKyM6IHNlcXVlbmNlci5jOjIzMjAKIG1zZ2lkICJjYW5ub3QgY2hlcnJ5LXBpY2sgZHVyaW5nIGEgcmV2ZXJ0LiIKIG1zZ3N0ciAiS2FubiBDaGVycnktUGljayBuaWNodCB3w6RocmVuZCBlaW5lcyBSZXZlcnRzIGF1c2bDvGhyZW4uIgogCi0jOiBzZXF1ZW5jZXIuYzoyMzg0CisjOiBzZXF1ZW5jZXIuYzoyMzIyCiBtc2dpZCAiY2Fubm90IHJldmVydCBkdXJpbmcgYSBjaGVycnktcGljay4iCiBtc2dzdHIgIkthbm4gUmV2ZXJ0IG5pY2h0IHfDpGhyZW5kIGVpbmVzIENoZXJyeS1QaWNrcyBhdXNmw7xocmVuLiIKIAotIzogc2VxdWVuY2VyLmM6MjQ2NgorIzogc2VxdWVuY2VyLmM6MjQwNAogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIHZhbHVlIGZvciAlczogJXMiCiBtc2dzdHIgIlVuZ8O8bHRpZ2VyIFdlcnQgZsO8ciAlczogJXMiCiAKLSM6IHNlcXVlbmNlci5jOjI1NTMKKyM6IHNlcXVlbmNlci5jOjI0OTEKIG1zZ2lkICJ1bnVzYWJsZSBzcXVhc2gtb250byIKIG1zZ3N0ciAiVW5iZW51dHpiYXJlcyBzcXVhc2gtb250by4iCiAKLSM6IHNlcXVlbmNlci5jOjI1NjkKKyM6IHNlcXVlbmNlci5jOjI1MDcKICMsIGMtZm9ybWF0CiBtc2dpZCAibWFsZm9ybWVkIG9wdGlvbnMgc2hlZXQ6ICclcyciCiBtc2dzdHIgIkZlaGxlcmhhZnRlcyBPcHRpb25zYmxhdHQ6ICclcyciCiAKLSM6IHNlcXVlbmNlci5jOjI2NTIgc2VxdWVuY2VyLmM6NDM1MQorIzogc2VxdWVuY2VyLmM6MjU5MCBzZXF1ZW5jZXIuYzo0MzA4CiBtc2dpZCAiZW1wdHkgY29tbWl0IHNldCBwYXNzZWQiCiBtc2dzdHIgImxlZXJlIE1lbmdlIHZvbiBDb21taXRzIMO8YmVyZ2ViZW4iCiAKLSM6IHNlcXVlbmNlci5jOjI2NjgKKyM6IHNlcXVlbmNlci5jOjI2MDYKIG1zZ2lkICJyZXZlcnQgaXMgYWxyZWFkeSBpbiBwcm9ncmVzcyIKIG1zZ3N0ciAiXCJyZXZlcnRcIiBpc3QgYmVyZWl0cyBpbSBHYW5nZSIKIAotIzogc2VxdWVuY2VyLmM6MjY3MAorIzogc2VxdWVuY2VyLmM6MjYwOAogIywgYy1mb3JtYXQKIG1zZ2lkICJ0cnkgXCJnaXQgcmV2ZXJ0ICgtLWNvbnRpbnVlIHwgJXMtLWFib3J0IHwgLS1xdWl0KVwiIgogbXNnc3RyICJWZXJzdWNoZW4gU2llIFwiZ2l0IHJldmVydCAoLS1jb250aW51ZSB8ICVzLS1hYm9ydCB8IC0tcXVpdClcIiIKIAotIzogc2VxdWVuY2VyLmM6MjY3MworIzogc2VxdWVuY2VyLmM6MjYxMQogbXNnaWQgImNoZXJyeS1waWNrIGlzIGFscmVhZHkgaW4gcHJvZ3Jlc3MiCiBtc2dzdHIgIlwiY2hlcnJ5LXBpY2tcIiB3aXJkIGJlcmVpdHMgZHVyY2hnZWbDvGhydCIKIAotIzogc2VxdWVuY2VyLmM6MjY3NQorIzogc2VxdWVuY2VyLmM6MjYxMwogIywgYy1mb3JtYXQKIG1zZ2lkICJ0cnkgXCJnaXQgY2hlcnJ5LXBpY2sgKC0tY29udGludWUgfCAlcy0tYWJvcnQgfCAtLXF1aXQpXCIiCiBtc2dzdHIgIlZlcnN1Y2hlbiBTaWUgXCJnaXQgY2hlcnJ5LXBpY2sgKC0tY29udGludWUgfCAlcy0tYWJvcnQgfCAtLXF1aXQpXCIiCiAKLSM6IHNlcXVlbmNlci5jOjI2ODkKKyM6IHNlcXVlbmNlci5jOjI2MjcKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGNyZWF0ZSBzZXF1ZW5jZXIgZGlyZWN0b3J5ICclcyciCiBtc2dzdHIgIktvbm50ZSBcInNlcXVlbmNlclwiLVZlcnplaWNobmlzICclcycgbmljaHQgZXJzdGVsbGVuLiIKIAotIzogc2VxdWVuY2VyLmM6MjcwNAorIzogc2VxdWVuY2VyLmM6MjY0MgogbXNnaWQgImNvdWxkIG5vdCBsb2NrIEhFQUQiCiBtc2dzdHIgIktvbm50ZSBIRUFEIG5pY2h0IHNwZXJyZW4iCiAKLSM6IHNlcXVlbmNlci5jOjI3NjQgc2VxdWVuY2VyLmM6NDEwMworIzogc2VxdWVuY2VyLmM6MjcwMiBzZXF1ZW5jZXIuYzo0MDU3CiBtc2dpZCAibm8gY2hlcnJ5LXBpY2sgb3IgcmV2ZXJ0IGluIHByb2dyZXNzIgogbXNnc3RyICJrZWluIFwiY2hlcnJ5LXBpY2tcIiBvZGVyIFwicmV2ZXJ0XCIgaW0gR2FuZ2UiCiAKLSM6IHNlcXVlbmNlci5jOjI3NjYgc2VxdWVuY2VyLmM6Mjc3NworIzogc2VxdWVuY2VyLmM6MjcwNCBzZXF1ZW5jZXIuYzoyNzE1CiBtc2dpZCAiY2Fubm90IHJlc29sdmUgSEVBRCIKIG1zZ3N0ciAia2FubiBIRUFEIG5pY2h0IGF1ZmzDtnNlbiIKIAotIzogc2VxdWVuY2VyLmM6Mjc2OCBzZXF1ZW5jZXIuYzoyODEyCisjOiBzZXF1ZW5jZXIuYzoyNzA2IHNlcXVlbmNlci5jOjI3NTAKIG1zZ2lkICJjYW5ub3QgYWJvcnQgZnJvbSBhIGJyYW5jaCB5ZXQgdG8gYmUgYm9ybiIKIG1zZ3N0ciAia2FubiBuaWNodCBhYmJyZWNoZW46IGJpbiBhdWYgZWluZW0gQnJhbmNoLCBkZXIgbm9jaCBuaWNodCBnZWJvcmVuIGlzdCIKIAotIzogc2VxdWVuY2VyLmM6Mjc5OCBidWlsdGluL2dyZXAuYzo3MzQKKyM6IHNlcXVlbmNlci5jOjI3MzYgYnVpbHRpbi9ncmVwLmM6NzM2CiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCBvcGVuICclcyciCiBtc2dzdHIgImthbm4gJyVzJyBuaWNodCDDtmZmbmVuIgogCi0jOiBzZXF1ZW5jZXIuYzoyODAwCisjOiBzZXF1ZW5jZXIuYzoyNzM4CiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCByZWFkICclcyc6ICVzIgogbXNnc3RyICJLYW5uICclcycgbmljaHQgbGVzZW46ICVzIgogCi0jOiBzZXF1ZW5jZXIuYzoyODAxCisjOiBzZXF1ZW5jZXIuYzoyNzM5CiBtc2dpZCAidW5leHBlY3RlZCBlbmQgb2YgZmlsZSIKIG1zZ3N0ciAiVW5lcndhcnRldGVzIERhdGVpZW5kZSIKIAotIzogc2VxdWVuY2VyLmM6MjgwNworIzogc2VxdWVuY2VyLmM6Mjc0NQogIywgYy1mb3JtYXQKIG1zZ2lkICJzdG9yZWQgcHJlLWNoZXJyeS1waWNrIEhFQUQgZmlsZSAnJXMnIGlzIGNvcnJ1cHQiCiBtc2dzdHIgImdlc3BlaWNoZXJ0ZSBcInByZS1jaGVycnktcGlja1wiIEhFQUQgRGF0ZWkgJyVzJyBpc3QgYmVzY2jDpGRpZ3QiCiAKLSM6IHNlcXVlbmNlci5jOjI4MTgKKyM6IHNlcXVlbmNlci5jOjI3NTYKIG1zZ2lkICJZb3Ugc2VlbSB0byBoYXZlIG1vdmVkIEhFQUQuIE5vdCByZXdpbmRpbmcsIGNoZWNrIHlvdXIgSEVBRCEiCiBtc2dzdHIgIiIKICJTaWUgc2NoZWluZW4gSEVBRCB2ZXLDpG5kZXJ0IHp1IGhhYmVuLiBLZWluZSBSw7xja3NwdWx1bmcsIHByw7xmZW4gU2llIEhFQUQuIgogCi0jOiBzZXF1ZW5jZXIuYzoyODU5CisjOiBzZXF1ZW5jZXIuYzoyNzk3CiBtc2dpZCAibm8gcmV2ZXJ0IGluIHByb2dyZXNzIgogbXNnc3RyICJLZWluIFJldmVydCBpbSBHYW5nZSIKIAotIzogc2VxdWVuY2VyLmM6Mjg2NworIzogc2VxdWVuY2VyLmM6MjgwNQogbXNnaWQgIm5vIGNoZXJyeS1waWNrIGluIHByb2dyZXNzIgogbXNnc3RyICJrZWluIFwiY2hlcnJ5LXBpY2tcIiBpbSBHYW5nZSIKIAotIzogc2VxdWVuY2VyLmM6Mjg3NworIzogc2VxdWVuY2VyLmM6MjgxNQogbXNnaWQgImZhaWxlZCB0byBza2lwIHRoZSBjb21taXQiCiBtc2dzdHIgIsOcYmVyc3ByaW5nZW4gZGVzIENvbW1pdHMgZmVobGdlc2NobGFnZW4iCiAKLSM6IHNlcXVlbmNlci5jOjI4ODQKKyM6IHNlcXVlbmNlci5jOjI4MjIKIG1zZ2lkICJ0aGVyZSBpcyBub3RoaW5nIHRvIHNraXAiCiBtc2dzdHIgIk5pY2h0cyB6dW0gw5xiZXJzcHJpbmdlbiB2b3JoYW5kZW4iCiAKLSM6IHNlcXVlbmNlci5jOjI4ODcKKyM6IHNlcXVlbmNlci5jOjI4MjUKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogImhhdmUgeW91IGNvbW1pdHRlZCBhbHJlYWR5P1xuIgpAQCAtNjQwOCwyMSArNjQzMywyMSBAQAogIkhhYmVuIFNpZSBiZXJlaXRzIGNvbW1pdHRldD9cbiIKICJWZXJzdWNoZW4gU2llIFwiZ2l0ICVzIC0tY29udGludWVcIiIKIAotIzogc2VxdWVuY2VyLmM6MzAxMSBzZXF1ZW5jZXIuYzo0MDE1CisjOiBzZXF1ZW5jZXIuYzoyOTQ5IHNlcXVlbmNlci5jOjM5NjkKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHVwZGF0ZSAlcyIKIG1zZ3N0ciAiS29ubnRlICVzIG5pY2h0IGFrdHVhbGlzaWVyZW4uIgogCi0jOiBzZXF1ZW5jZXIuYzozMDQ5IHNlcXVlbmNlci5jOjM5OTUKKyM6IHNlcXVlbmNlci5jOjI5ODcgc2VxdWVuY2VyLmM6Mzk0OQogbXNnaWQgImNhbm5vdCByZWFkIEhFQUQiCiBtc2dzdHIgIkthbm4gSEVBRCBuaWNodCBsZXNlbiIKIAotIzogc2VxdWVuY2VyLmM6MzA2NgorIzogc2VxdWVuY2VyLmM6MzAwNAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gY29weSAnJXMnIHRvICclcyciCiBtc2dzdHIgIktvbm50ZSAnJXMnIG5pY2h0IG5hY2ggJyVzJyBrb3BpZXJlbi4iCiAKLSM6IHNlcXVlbmNlci5jOjMwNzQKKyM6IHNlcXVlbmNlci5jOjMwMTIKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIllvdSBjYW4gYW1lbmQgdGhlIGNvbW1pdCBub3csIHdpdGhcbiIKQEAgLTY0NDEsMjcgKzY0NjYsMjcgQEAKICJcbiIKICIgIGdpdCByZWJhc2UgLS1jb250aW51ZVxuIgogCi0jOiBzZXF1ZW5jZXIuYzozMDg0CisjOiBzZXF1ZW5jZXIuYzozMDIyCiAjLCBjLWZvcm1hdAogbXNnaWQgIkNvdWxkIG5vdCBhcHBseSAlcy4uLiAlLipzIgogbXNnc3RyICJLb25udGUgJXMuLi4gKCUuKnMpIG5pY2h0IGFud2VuZGVuIgogCi0jOiBzZXF1ZW5jZXIuYzozMDkxCisjOiBzZXF1ZW5jZXIuYzozMDI5CiAjLCBjLWZvcm1hdAogbXNnaWQgIkNvdWxkIG5vdCBtZXJnZSAlLipzIgogbXNnc3RyICJLb25udGUgXCIlLipzXCIgbmljaHQgenVzYW1tZW5mw7xocmVuLiIKIAotIzogc2VxdWVuY2VyLmM6MzEwNSBzZXF1ZW5jZXIuYzozMTA5IGJ1aWx0aW4vZGlmZnRvb2wuYzo2MzMKKyM6IHNlcXVlbmNlci5jOjMwNDMgc2VxdWVuY2VyLmM6MzA0NyBidWlsdGluL2RpZmZ0b29sLmM6NjQxCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBjb3B5ICclcycgdG8gJyVzJyIKIG1zZ3N0ciAiS29ubnRlICclcycgbmljaHQgbmFjaCAnJXMnIGtvcGllcmVuLiIKIAotIzogc2VxdWVuY2VyLmM6MzEzMSBzZXF1ZW5jZXIuYzozNTU4IGJ1aWx0aW4vcmViYXNlLmM6ODQ5IGJ1aWx0aW4vcmViYXNlLmM6MTU4MgotIzogYnVpbHRpbi9yZWJhc2UuYzoxOTUzIGJ1aWx0aW4vcmViYXNlLmM6MjAwOAorIzogc2VxdWVuY2VyLmM6MzA2OSBzZXF1ZW5jZXIuYzozNTA2IGJ1aWx0aW4vcmViYXNlLmM6ODUwIGJ1aWx0aW4vcmViYXNlLmM6MTYxMworIzogYnVpbHRpbi9yZWJhc2UuYzoxOTg3IGJ1aWx0aW4vcmViYXNlLmM6MjAzMQogbXNnaWQgImNvdWxkIG5vdCByZWFkIGluZGV4IgogbXNnc3RyICJLb25udGUgZGVuIEluZGV4IG5pY2h0IGxlc2VuLiIKIAotIzogc2VxdWVuY2VyLmM6MzEzNgorIzogc2VxdWVuY2VyLmM6MzA3NAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiZXhlY3V0aW9uIGZhaWxlZDogJXNcbiIKQEAgLTY0NzcsMTEgKzY1MDIsMTEgQEAKICJcbiIKICJhdXNmw7xocmVuLlxuIgogCi0jOiBzZXF1ZW5jZXIuYzozMTQyCisjOiBzZXF1ZW5jZXIuYzozMDgwCiBtc2dpZCAiYW5kIG1hZGUgY2hhbmdlcyB0byB0aGUgaW5kZXggYW5kL29yIHRoZSB3b3JraW5nIHRyZWVcbiIKIG1zZ3N0ciAiRGVyIEluZGV4IHVuZC9vZGVyIGRhcyBBcmJlaXRzdmVyemVpY2huaXMgd3VyZGUgZ2XDpG5kZXJ0LlxuIgogCi0jOiBzZXF1ZW5jZXIuYzozMTQ4CisjOiBzZXF1ZW5jZXIuYzozMDg2CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJleGVjdXRpb24gc3VjY2VlZGVkOiAlc1xuIgpAQCAtNjQ5OSw3NyArNjUyNCw3NyBAQAogIiAgZ2l0IHJlYmFzZSAtLWNvbnRpbnVlXG4iCiAiXG4iCiAKLSM6IHNlcXVlbmNlci5jOjMyMDkKKyM6IHNlcXVlbmNlci5jOjMxNDcKICMsIGMtZm9ybWF0CiBtc2dpZCAiaWxsZWdhbCBsYWJlbCBuYW1lOiAnJS4qcyciCiBtc2dzdHIgIlVuZXJsYXVidGVyIEJlc2NocmlmdHVuZ3NuYW1lOiAnJS4qcyciCiAKLSM6IHNlcXVlbmNlci5jOjMyNjMKKyM6IHNlcXVlbmNlci5jOjMyMDEKIG1zZ2lkICJ3cml0aW5nIGZha2Ugcm9vdCBjb21taXQiCiBtc2dzdHIgInVuZWNodGVuIFJvb3QtQ29tbWl0IHNjaHJlaWJlbiIKIAotIzogc2VxdWVuY2VyLmM6MzI2OAorIzogc2VxdWVuY2VyLmM6MzIwNgogbXNnaWQgIndyaXRpbmcgc3F1YXNoLW9udG8iCiBtc2dzdHIgInNxdWFzaC1vbnRvIHNjaHJlaWJlbiIKIAotIzogc2VxdWVuY2VyLmM6MzMwNiBidWlsdGluL3JlYmFzZS5jOjg1NCBidWlsdGluL3JlYmFzZS5jOjg2MAorIzogc2VxdWVuY2VyLmM6MzI0NCBidWlsdGluL3JlYmFzZS5jOjg1NSBidWlsdGluL3JlYmFzZS5jOjg2MQogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gZmluZCB0cmVlIG9mICVzIgogbXNnc3RyICJGZWhsZXIgYmVpbSBGaW5kZW4gZGVzIFwiVHJlZVwiLU9iamVrdGVzIHZvbiAlcy4iCiAKLSM6IHNlcXVlbmNlci5jOjMzMjQgYnVpbHRpbi9yZWJhc2UuYzo4NzMKKyM6IHNlcXVlbmNlci5jOjMyNjIgYnVpbHRpbi9yZWJhc2UuYzo4NzQKIG1zZ2lkICJjb3VsZCBub3Qgd3JpdGUgaW5kZXgiCiBtc2dzdHIgIktvbm50ZSBJbmRleCBuaWNodCBzY2hyZWliZW4uIgogCi0jOiBzZXF1ZW5jZXIuYzozMzUxCisjOiBzZXF1ZW5jZXIuYzozMjg5CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCByZXNvbHZlICclcyciCiBtc2dzdHIgIktvbm50ZSAnJXMnIG5pY2h0IGF1ZmzDtnNlbi4iCiAKLSM6IHNlcXVlbmNlci5jOjMzNzkKKyM6IHNlcXVlbmNlci5jOjMzMjAKIG1zZ2lkICJjYW5ub3QgbWVyZ2Ugd2l0aG91dCBhIGN1cnJlbnQgcmV2aXNpb24iCiBtc2dzdHIgIkthbm4gbmljaHQgb2huZSBlaW5lbiBha3R1ZWxsZW4gQ29tbWl0IG1lcmdlbi4iCiAKLSM6IHNlcXVlbmNlci5jOjM0MDEKKyM6IHNlcXVlbmNlci5jOjMzNDIKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHBhcnNlICclLipzJyIKIG1zZ3N0ciAiS29ubnRlICclLipzJyBuaWNodCBwYXJzZW4uIgogCi0jOiBzZXF1ZW5jZXIuYzozNDEwCisjOiBzZXF1ZW5jZXIuYzozMzUxCiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vdGhpbmcgdG8gbWVyZ2U6ICclLipzJyIKIG1zZ3N0ciAiTmljaHRzIHp1bSBadXNhbW1lbmbDvGhyZW46ICclLipzJyIKIAotIzogc2VxdWVuY2VyLmM6MzQyMgorIzogc2VxdWVuY2VyLmM6MzM2MwogbXNnaWQgIm9jdG9wdXMgbWVyZ2UgY2Fubm90IGJlIGV4ZWN1dGVkIG9uIHRvcCBvZiBhIFtuZXcgcm9vdF0iCiBtc2dzdHIgIiIKICJPY3R1cHVzLU1lcmdlIGthbm4gbmljaHQgYXVmIEJhc2lzIHZvbiBbbmV1ZW0gUm9vdC1Db21taXRdIGF1c2dlZsO8aHJ0IHdlcmRlbi4iCiAKLSM6IHNlcXVlbmNlci5jOjM0MzcKKyM6IHNlcXVlbmNlci5jOjMzNzgKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGdldCBjb21taXQgbWVzc2FnZSBvZiAnJXMnIgogbXNnc3RyICJLb25udGUga2VpbmUgQ29tbWl0LUJlc2NocmVpYnVuZyB2b24gJyVzJyBiZWtvbW1lbi4iCiAKLSM6IHNlcXVlbmNlci5jOjM1OTAKKyM6IHNlcXVlbmNlci5jOjM1MzgKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGV2ZW4gYXR0ZW1wdCB0byBtZXJnZSAnJS4qcyciCiBtc2dzdHIgIktvbm50ZSBuaWNodCBlaW5tYWwgdmVyc3VjaGVuICclLipzJyB6dSBtZXJnZW4uIgogCi0jOiBzZXF1ZW5jZXIuYzozNjA2CisjOiBzZXF1ZW5jZXIuYzozNTU0CiBtc2dpZCAibWVyZ2U6IFVuYWJsZSB0byB3cml0ZSBuZXcgaW5kZXggZmlsZSIKIG1zZ3N0ciAibWVyZ2U6IEtvbm50ZSBuZXVlIEluZGV4LURhdGVpIG5pY2h0IHNjaHJlaWJlbi4iCiAKLSM6IHNlcXVlbmNlci5jOjM2NzUgYnVpbHRpbi9yZWJhc2UuYzo3MTEKKyM6IHNlcXVlbmNlci5jOjM2MjMgYnVpbHRpbi9yZWJhc2UuYzo3MTIKICMsIGMtZm9ybWF0CiBtc2dpZCAiQXBwbGllZCBhdXRvc3Rhc2guXG4iCiBtc2dzdHIgIkF1dG9tYXRpc2NoZW4gU3Rhc2ggYW5nZXdlbmRldC5cbiIKIAotIzogc2VxdWVuY2VyLmM6MzY4NworIzogc2VxdWVuY2VyLmM6MzYzNQogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3Qgc3RvcmUgJXMiCiBtc2dzdHIgImthbm4gJXMgbmljaHQgc3BlaWNoZXJuIgogCi0jOiBzZXF1ZW5jZXIuYzozNjkwIGJ1aWx0aW4vcmViYXNlLmM6NzI3IGdpdC1yZWJhc2UtLXByZXNlcnZlLW1lcmdlcy5zaDoxMTMKKyM6IHNlcXVlbmNlci5jOjM2MzggYnVpbHRpbi9yZWJhc2UuYzo3MjggZ2l0LXJlYmFzZS0tcHJlc2VydmUtbWVyZ2VzLnNoOjExMwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiQXBwbHlpbmcgYXV0b3N0YXNoIHJlc3VsdGVkIGluIGNvbmZsaWN0cy5cbiIKQEAgLTY1ODAsMzEgKzY2MDUsMzEgQEAKICJJaHJlIMOEbmRlcnVuZ2VuIHNpbmQgaW0gU3Rhc2ggc2ljaGVyLlxuIgogIlNpZSBrw7ZubmVuIGplZGVyemVpdCBcImdpdCBzdGFzaCBwb3BcIiBvZGVyIFwiZ2l0IHN0YXNoIGRyb3BcIiBhdXNmw7xocmVuLlxuIgogCi0jOiBzZXF1ZW5jZXIuYzozNzUxCisjOiBzZXF1ZW5jZXIuYzozNjk5CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBjaGVja291dCAlcyIKIG1zZ3N0ciAiS29ubnRlICVzIG5pY2h0IGF1c2NoZWNrZW4uIgogCi0jOiBzZXF1ZW5jZXIuYzozNzY1CisjOiBzZXF1ZW5jZXIuYzozNzEzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiBub3QgYSB2YWxpZCBPSUQiCiBtc2dzdHIgIiVzOiBrZWluZSBnw7xsdGlnZSBPSUQiCiAKLSM6IHNlcXVlbmNlci5jOjM3NzAgZ2l0LXJlYmFzZS0tcHJlc2VydmUtbWVyZ2VzLnNoOjc3OQorIzogc2VxdWVuY2VyLmM6MzcxOCBnaXQtcmViYXNlLS1wcmVzZXJ2ZS1tZXJnZXMuc2g6Nzc5CiBtc2dpZCAiY291bGQgbm90IGRldGFjaCBIRUFEIgogbXNnc3RyICJLb25udGUgSEVBRCBuaWNodCBsb3Nsw7ZzZW4iCiAKLSM6IHNlcXVlbmNlci5jOjM3ODUKKyM6IHNlcXVlbmNlci5jOjM3MzMKICMsIGMtZm9ybWF0CiBtc2dpZCAiU3RvcHBlZCBhdCBIRUFEXG4iCiBtc2dzdHIgIkFuZ2VoYWx0ZW4gYmVpIEhFQURcbiIKIAotIzogc2VxdWVuY2VyLmM6Mzc4NworIzogc2VxdWVuY2VyLmM6MzczNQogIywgYy1mb3JtYXQKIG1zZ2lkICJTdG9wcGVkIGF0ICVzXG4iCiBtc2dzdHIgIkFuZ2VoYWx0ZW4gYmVpICVzXG4iCiAKLSM6IHNlcXVlbmNlci5jOjM3OTUKKyM6IHNlcXVlbmNlci5jOjM3NDMKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkNvdWxkIG5vdCBleGVjdXRlIHRoZSB0b2RvIGNvbW1hbmRcbiIKQEAgLTY2MjYsNTAgKzY2NTEsNTAgQEAKICIgICAgZ2l0IHJlYmFzZSAtLWVkaXQtdG9kb1xuIgogIiAgICBnaXQgcmViYXNlIC0tY29udGludWVcbiIKIAotIzogc2VxdWVuY2VyLmM6Mzg3NworIzogc2VxdWVuY2VyLmM6MzgyNwogIywgYy1mb3JtYXQKIG1zZ2lkICJTdG9wcGVkIGF0ICVzLi4uICAlLipzXG4iCiBtc2dzdHIgIkFuZ2VoYWx0ZW4gYmVpICVzLi4uICUuKnNcbiIKIAotIzogc2VxdWVuY2VyLmM6Mzk1OAorIzogc2VxdWVuY2VyLmM6Mzg5OAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmtub3duIGNvbW1hbmQgJWQiCiBtc2dzdHIgIlVuYmVrYW5udGVyIEJlZmVobCAlZCIKIAotIzogc2VxdWVuY2VyLmM6NDAwMworIzogc2VxdWVuY2VyLmM6Mzk1NwogbXNnaWQgImNvdWxkIG5vdCByZWFkIG9yaWctaGVhZCIKIG1zZ3N0ciAiS29ubnRlIG9yaWctaGVhZCBuaWNodCBsZXNlbi4iCiAKLSM6IHNlcXVlbmNlci5jOjQwMDgKKyM6IHNlcXVlbmNlci5jOjM5NjIKIG1zZ2lkICJjb3VsZCBub3QgcmVhZCAnb250byciCiBtc2dzdHIgIktvbm50ZSAnb250bycgbmljaHQgbGVzZW4uIgogCi0jOiBzZXF1ZW5jZXIuYzo0MDIyCisjOiBzZXF1ZW5jZXIuYzozOTc2CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCB1cGRhdGUgSEVBRCB0byAlcyIKIG1zZ3N0ciAiS29ubnRlIEhFQUQgbmljaHQgYXVmICVzIGFrdHVhbGlzaWVyZW4uIgogCi0jOiBzZXF1ZW5jZXIuYzo0MTE1CisjOiBzZXF1ZW5jZXIuYzo0MDY5CiBtc2dpZCAiY2Fubm90IHJlYmFzZTogWW91IGhhdmUgdW5zdGFnZWQgY2hhbmdlcy4iCiBtc2dzdHIgIiIKICJSZWJhc2UgbmljaHQgbcO2Z2xpY2g6IFNpZSBoYWJlbiDDhG5kZXJ1bmdlbiwgZGllIG5pY2h0IHp1bSBDb21taXRcbiIKICJ2b3JnZW1lcmt0IHNpbmQuIgogCi0jOiBzZXF1ZW5jZXIuYzo0MTI0CisjOiBzZXF1ZW5jZXIuYzo0MDc4CiBtc2dpZCAiY2Fubm90IGFtZW5kIG5vbi1leGlzdGluZyBjb21taXQiCiBtc2dzdHIgIkthbm4gbmljaHQgZXhpc3RpZXJlbmRlbiBDb21taXQgbmljaHQgbmFjaGJlc3Nlcm4uIgogCi0jOiBzZXF1ZW5jZXIuYzo0MTI2CisjOiBzZXF1ZW5jZXIuYzo0MDgwCiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgZmlsZTogJyVzJyIKIG1zZ3N0ciAiVW5nw7xsdGlnZSBEYXRlaTogJyVzJyIKIAotIzogc2VxdWVuY2VyLmM6NDEyOAorIzogc2VxdWVuY2VyLmM6NDA4MgogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIGNvbnRlbnRzOiAnJXMnIgogbXNnc3RyICJVbmfDvGx0aWdlIEluaGFsdGU6ICclcyciCiAKLSM6IHNlcXVlbmNlci5jOjQxMzEKKyM6IHNlcXVlbmNlci5jOjQwODUKIG1zZ2lkICIiCiAiXG4iCiAiWW91IGhhdmUgdW5jb21taXR0ZWQgY2hhbmdlcyBpbiB5b3VyIHdvcmtpbmcgdHJlZS4gUGxlYXNlLCBjb21taXQgdGhlbVxuIgpAQCAtNjY4MCw0MiArNjcwNSw0MiBAQAogImNvbW1pdHRlbiBTaWUgZGllc2UgenVlcnN0IHVuZCBmw7xocmVuIFNpZSBkYW5uICdnaXQgcmViYXNlIC0tY29udGludWUnXG4iCiAiZXJuZXV0IGF1cy4iCiAKLSM6IHNlcXVlbmNlci5jOjQxNjcgc2VxdWVuY2VyLmM6NDIwNQorIzogc2VxdWVuY2VyLmM6NDEyMSBzZXF1ZW5jZXIuYzo0MTU5CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCB3cml0ZSBmaWxlOiAnJXMnIgogbXNnc3RyICJLb25udGUgRGF0ZWkgbmljaHQgc2NocmVpYmVuOiAnJXMnIgogCi0jOiBzZXF1ZW5jZXIuYzo0MjIwCisjOiBzZXF1ZW5jZXIuYzo0MTc0CiBtc2dpZCAiY291bGQgbm90IHJlbW92ZSBDSEVSUllfUElDS19IRUFEIgogbXNnc3RyICJLb25udGUgQ0hFUlJZX1BJQ0tfSEVBRCBuaWNodCBsw7ZzY2hlbi4iCiAKLSM6IHNlcXVlbmNlci5jOjQyMjcKKyM6IHNlcXVlbmNlci5jOjQxODEKIG1zZ2lkICJjb3VsZCBub3QgY29tbWl0IHN0YWdlZCBjaGFuZ2VzLiIKIG1zZ3N0ciAiS29ubnRlIMOEbmRlcnVuZ2VuIGF1cyBkZXIgU3RhZ2luZy1BcmVhIG5pY2h0IGNvbW1pdHRlbi4iCiAKLSM6IHNlcXVlbmNlci5jOjQzMjgKKyM6IHNlcXVlbmNlci5jOjQyODUKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXM6IGNhbid0IGNoZXJyeS1waWNrIGEgJXMiCiBtc2dzdHIgIiVzOiAlcyBrYW5uIG5pY2h0IGluIFwiY2hlcnJ5LXBpY2tcIiBiZW51dHp0IHdlcmRlbiIKIAotIzogc2VxdWVuY2VyLmM6NDMzMgorIzogc2VxdWVuY2VyLmM6NDI4OQogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogYmFkIHJldmlzaW9uIgogbXNnc3RyICIlczogdW5nw7xsdGlnZXIgQ29tbWl0IgogCi0jOiBzZXF1ZW5jZXIuYzo0MzY3CisjOiBzZXF1ZW5jZXIuYzo0MzI0CiBtc2dpZCAiY2FuJ3QgcmV2ZXJ0IGFzIGluaXRpYWwgY29tbWl0IgogbXNnc3RyICJLYW5uIG5pY2h0IGFscyBhbGxlcmVyc3RlbiBDb21taXQgZWluZW4gUmV2ZXJ0IGF1c2bDvGhyZW4uIgogCi0jOiBzZXF1ZW5jZXIuYzo0ODEwCisjOiBzZXF1ZW5jZXIuYzo0Nzc0CiBtc2dpZCAibWFrZV9zY3JpcHQ6IHVuaGFuZGxlZCBvcHRpb25zIgogbXNnc3RyICJtYWtlX3NjcmlwdDogdW5iZWhhbmRlbHRlIE9wdGlvbmVuIgogCi0jOiBzZXF1ZW5jZXIuYzo0ODEzCisjOiBzZXF1ZW5jZXIuYzo0Nzc3CiBtc2dpZCAibWFrZV9zY3JpcHQ6IGVycm9yIHByZXBhcmluZyByZXZpc2lvbnMiCiBtc2dzdHIgIm1ha2Vfc2NyaXB0OiBGZWhsZXIgYmVpbSBWb3JiZXJlaXRlbiBkZXIgQ29tbWl0cyIKIAotIzogc2VxdWVuY2VyLmM6NDk3MQorIzogc2VxdWVuY2VyLmM6NDkzNQogbXNnaWQgIiIKICJZb3UgY2FuIGZpeCB0aGlzIHdpdGggJ2dpdCByZWJhc2UgLS1lZGl0LXRvZG8nIGFuZCB0aGVuIHJ1biAnZ2l0IHJlYmFzZSAtLSIKICJjb250aW51ZScuXG4iCkBAIC02NzI1LDI0ICs2NzUwLDI0IEBACiAiJ2dpdCByZWJhc2UgLS1jb250aW51ZScgYXVzLlxuIgogIk9kZXIgU2llIGvDtm5uZW4gZGVuIFJlYmFzZSBtaXQgJ2dpdCByZWJhc2UgLS1hYm9ydCcgYWJicmVjaGVuLlxuIgogCi0jOiBzZXF1ZW5jZXIuYzo1MDgzIHNlcXVlbmNlci5jOjUxMDAKKyM6IHNlcXVlbmNlci5jOjUwNDcgc2VxdWVuY2VyLmM6NTA2NAogbXNnaWQgIm5vdGhpbmcgdG8gZG8iCiBtc2dzdHIgIk5pY2h0cyB6dSB0dW4uIgogCi0jOiBzZXF1ZW5jZXIuYzo1MTE0CisjOiBzZXF1ZW5jZXIuYzo1MDc4CiBtc2dpZCAiY291bGQgbm90IHNraXAgdW5uZWNlc3NhcnkgcGljayBjb21tYW5kcyIKIG1zZ3N0ciAiS29ubnRlIHVubsO2dGlnZSBcInBpY2tcIi1CZWZlaGxlIG5pY2h0IGF1c2xhc3Nlbi4iCiAKLSM6IHNlcXVlbmNlci5jOjUxOTcKKyM6IHNlcXVlbmNlci5jOjUxNjYKIG1zZ2lkICJ0aGUgc2NyaXB0IHdhcyBhbHJlYWR5IHJlYXJyYW5nZWQuIgogbXNnc3RyICJEYXMgU2NyaXB0IHd1cmRlIGJlcmVpdHMgdW1nZW9yZG5ldC4iCiAKLSM6IHNldHVwLmM6MTIzCisjOiBzZXR1cC5jOjEyNAogIywgYy1mb3JtYXQKIG1zZ2lkICInJXMnIGlzIG91dHNpZGUgcmVwb3NpdG9yeSIKIG1zZ3N0ciAiJyVzJyBsaWVndCBhdcOfZXJoYWxiIGRlcyBSZXBvc2l0b3JpZXMuIgogCi0jOiBzZXR1cC5jOjE3MworIzogc2V0dXAuYzoxNzQKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIiVzOiBubyBzdWNoIHBhdGggaW4gdGhlIHdvcmtpbmcgdHJlZS5cbiIKQEAgLTY3NTIsNyArNjc3Nyw3IEBACiAiQmVudXR6ZW4gU2llICdnaXQgPEJlZmVobD4gLS0gPFBmYWQ+Li4uJyB6dXIgQW5nYWJlIHZvbiBQZmFkZW4sIGRpZSBsb2thbFxuIgogIm5pY2h0IGV4aXN0aWVyZW4uIgogCi0jOiBzZXR1cC5jOjE4NgorIzogc2V0dXAuYzoxODcKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogImFtYmlndW91cyBhcmd1bWVudCAnJXMnOiB1bmtub3duIHJldmlzaW9uIG9yIHBhdGggbm90IGluIHRoZSB3b3JraW5nIHRyZWUuXG4iCkBAIC02NzY0LDEzICs2Nzg5LDEzIEBACiAiQmVudXR6ZW4gU2llICctLScsIHVtIFBmYWRlIHVuZCBDb21taXRzIHp1IHRyZW5uZW4sIMOkaG5saWNoIHdpZTpcbiIKICInZ2l0IDxCZWZlaGw+IFs8Q29tbWl0Pi4uLl0gLS0gWzxEYXRlaT4uLi5dJyIKIAotIzogc2V0dXAuYzoyMzUKKyM6IHNldHVwLmM6MjM2CiAjLCBjLWZvcm1hdAogbXNnaWQgIm9wdGlvbiAnJXMnIG11c3QgY29tZSBiZWZvcmUgbm9uLW9wdGlvbiBhcmd1bWVudHMiCiBtc2dzdHIgIiIKICJEaWUgT3B0aW9uICclcycgbXVzcyB2b3IgZGVuIEFyZ3VtZW50ZW4ga29tbWVuLCBkaWUga2VpbmUgT3B0aW9uZW4gc2luZC4iCiAKLSM6IHNldHVwLmM6MjU0CisjOiBzZXR1cC5jOjI1NQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiYW1iaWd1b3VzIGFyZ3VtZW50ICclcyc6IGJvdGggcmV2aXNpb24gYW5kIGZpbGVuYW1lXG4iCkBAIC02NzgxLDkzICs2ODA2LDkzIEBACiAiQmVudXR6ZW4gU2llICctLScsIHVtIFBmYWRlIHVuZCBDb21taXRzIHp1IHRyZW5uZW4sIMOkaG5saWNoIHdpZTpcbiIKICInZ2l0IDxCZWZlaGw+IFs8Q29tbWl0Pi4uLl0gLS0gWzxEYXRlaT4uLi5dJyIKIAotIzogc2V0dXAuYzozOTAKKyM6IHNldHVwLmM6MzkxCiBtc2dpZCAidW5hYmxlIHRvIHNldCB1cCB3b3JrIHRyZWUgdXNpbmcgaW52YWxpZCBjb25maWciCiBtc2dzdHIgIiIKICJLb25udGUgQXJiZWl0c3ZlcnplaWNobmlzIG1pdCB1bmfDvGx0aWdlciBLb25maWd1cmF0aW9uIG5pY2h0IGVpbnJpY2h0ZW4uIgogCi0jOiBzZXR1cC5jOjM5NAorIzogc2V0dXAuYzozOTUKIG1zZ2lkICJ0aGlzIG9wZXJhdGlvbiBtdXN0IGJlIHJ1biBpbiBhIHdvcmsgdHJlZSIKIG1zZ3N0ciAiRGllc2UgT3BlcmF0aW9uIG11c3MgaW4gZWluZW0gQXJiZWl0c3ZlcnplaWNobmlzIGF1c2dlZsO8aHJ0IHdlcmRlbi4iCiAKLSM6IHNldHVwLmM6NTQwCisjOiBzZXR1cC5jOjU0MQogIywgYy1mb3JtYXQKIG1zZ2lkICJFeHBlY3RlZCBnaXQgcmVwbyB2ZXJzaW9uIDw9ICVkLCBmb3VuZCAlZCIKIG1zZ3N0ciAiRXJ3YXJ0ZXRlIEdpdC1SZXBvc2l0b3J5LVZlcnNpb24gPD0gJWQsICVkIGdlZnVuZGVuIgogCi0jOiBzZXR1cC5jOjU0OAorIzogc2V0dXAuYzo1NDkKIG1zZ2lkICJ1bmtub3duIHJlcG9zaXRvcnkgZXh0ZW5zaW9ucyBmb3VuZDoiCiBtc2dzdHIgIlVuYmVrYW5udGUgUmVwb3NpdG9yeS1FcndlaXRlcnVuZ2VuIGdlZnVuZGVuOiIKIAotIzogc2V0dXAuYzo1NjcKKyM6IHNldHVwLmM6NTY4CiAjLCBjLWZvcm1hdAogbXNnaWQgImVycm9yIG9wZW5pbmcgJyVzJyIKIG1zZ3N0ciAiRmVobGVyIGJlaW0gw5ZmZm5lbiB2b24gJyVzJy4iCiAKLSM6IHNldHVwLmM6NTY5CisjOiBzZXR1cC5jOjU3MAogIywgYy1mb3JtYXQKIG1zZ2lkICJ0b28gbGFyZ2UgdG8gYmUgYSAuZ2l0IGZpbGU6ICclcyciCiBtc2dzdHIgIlp1IGdyb8OfLCB1bSBlaW5lIC5naXQtRGF0ZWkgenUgc2VpbjogJyVzJyIKIAotIzogc2V0dXAuYzo1NzEKKyM6IHNldHVwLmM6NTcyCiAjLCBjLWZvcm1hdAogbXNnaWQgImVycm9yIHJlYWRpbmcgJXMiCiBtc2dzdHIgIkZlaGxlciBiZWltIExlc2VuIHZvbiAnJXMnLiIKIAotIzogc2V0dXAuYzo1NzMKKyM6IHNldHVwLmM6NTc0CiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgZ2l0ZmlsZSBmb3JtYXQ6ICVzIgogbXNnc3RyICJVbmfDvGx0aWdlcyBnaXRmaWxlLUZvcm1hdDogJXMiCiAKLSM6IHNldHVwLmM6NTc1CisjOiBzZXR1cC5jOjU3NgogIywgYy1mb3JtYXQKIG1zZ2lkICJubyBwYXRoIGluIGdpdGZpbGU6ICVzIgogbXNnc3RyICJLZWluIFBmYWQgaW4gZ2l0ZmlsZTogJXMiCiAKLSM6IHNldHVwLmM6NTc3CisjOiBzZXR1cC5jOjU3OAogIywgYy1mb3JtYXQKIG1zZ2lkICJub3QgYSBnaXQgcmVwb3NpdG9yeTogJXMiCiBtc2dzdHIgIktlaW4gR2l0LVJlcG9zaXRvcnk6ICVzIgogCi0jOiBzZXR1cC5jOjY3NgorIzogc2V0dXAuYzo2NzcKICMsIGMtZm9ybWF0CiBtc2dpZCAiJyQlcycgdG9vIGJpZyIKIG1zZ3N0ciAiJyQlcycgenUgZ3Jvw58iCiAKLSM6IHNldHVwLmM6NjkwCisjOiBzZXR1cC5jOjY5MQogIywgYy1mb3JtYXQKIG1zZ2lkICJub3QgYSBnaXQgcmVwb3NpdG9yeTogJyVzJyIKIG1zZ3N0ciAiS2VpbiBHaXQtUmVwb3NpdG9yeTogJyVzJyIKIAotIzogc2V0dXAuYzo3MTkgc2V0dXAuYzo3MjEgc2V0dXAuYzo3NTIKKyM6IHNldHVwLmM6NzIwIHNldHVwLmM6NzIyIHNldHVwLmM6NzUzCiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCBjaGRpciB0byAnJXMnIgogbXNnc3RyICJLYW5uIG5pY2h0IGluIFZlcnplaWNobmlzICclcycgd2VjaHNlbG4uIgogCi0jOiBzZXR1cC5jOjcyNCBzZXR1cC5jOjc4MCBzZXR1cC5jOjc5MCBzZXR1cC5jOjgyOSBzZXR1cC5jOjgzNworIzogc2V0dXAuYzo3MjUgc2V0dXAuYzo3ODEgc2V0dXAuYzo3OTEgc2V0dXAuYzo4MzAgc2V0dXAuYzo4MzgKIG1zZ2lkICJjYW5ub3QgY29tZSBiYWNrIHRvIGN3ZCIKIG1zZ3N0ciAiS2FubiBuaWNodCB6dW0gYWt0dWVsbGVuIEFyYmVpdHN2ZXJ6ZWljaG5pcyB6dXLDvGNrd2VjaHNlbG4uIgogCi0jOiBzZXR1cC5jOjg1MQorIzogc2V0dXAuYzo4NTIKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIHN0YXQgJyUqcyVzJXMnIgogbXNnc3RyICJLb25udGUgJyUqcyVzJXMnIG5pY2h0IGxlc2VuLiIKIAotIzogc2V0dXAuYzoxMDgzCisjOiBzZXR1cC5jOjEwOTAKIG1zZ2lkICJVbmFibGUgdG8gcmVhZCBjdXJyZW50IHdvcmtpbmcgZGlyZWN0b3J5IgogbXNnc3RyICJLb25udGUgYWt0dWVsbGVzIEFyYmVpdHN2ZXJ6ZWljaG5pcyBuaWNodCBsZXNlbi4iCiAKLSM6IHNldHVwLmM6MTA5MiBzZXR1cC5jOjEwOTgKKyM6IHNldHVwLmM6MTA5OSBzZXR1cC5jOjExMDUKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IGNoYW5nZSB0byAnJXMnIgogbXNnc3RyICJLYW5uIG5pY2h0IG5hY2ggJyVzJyB3ZWNoc2Vsbi4iCiAKLSM6IHNldHVwLmM6MTEwMworIzogc2V0dXAuYzoxMTEwCiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vdCBhIGdpdCByZXBvc2l0b3J5IChvciBhbnkgb2YgdGhlIHBhcmVudCBkaXJlY3Rvcmllcyk6ICVzIgogbXNnc3RyICJLZWluIEdpdC1SZXBvc2l0b3J5IChvZGVyIGlyZ2VuZGVpbmVzIGRlciBFbHRlcm52ZXJ6ZWljaG5pc3NlKTogJXMiCiAKLSM6IHNldHVwLmM6MTEwOQorIzogc2V0dXAuYzoxMTE2CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJub3QgYSBnaXQgcmVwb3NpdG9yeSAob3IgYW55IHBhcmVudCB1cCB0byBtb3VudCBwb2ludCAlcylcbiIKQEAgLTY4NzcsNyArNjkwMiw3IEBACiAiJXMpXG4iCiAiU3RvcHBlIGJlaSBEYXRlaXN5c3RlbWdyZW56ZSAoR0lUX0RJU0NPVkVSWV9BQ1JPU1NfRklMRVNZU1RFTSBuaWNodCBnZXNldHp0KS4iCiAKLSM6IHNldHVwLmM6MTIyMAorIzogc2V0dXAuYzoxMjI3CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJwcm9ibGVtIHdpdGggY29yZS5zaGFyZWRSZXBvc2l0b3J5IGZpbGVtb2RlIHZhbHVlICgwJS4zbykuXG4iCkBAIC02ODg2LDI5MCArNjkxMSwyOTAgQEAKICJQcm9ibGVtIG1pdCBXZXJ0IGbDvHIgRGF0ZWltb2R1cyAoMCUuM28pIHZvbiBjb3JlLnNoYXJlZFJlcG9zaXRvcnkuXG4iCiAiRGVyIEJlc2l0emVyIGRlciBEYXRlaWVuIG11c3MgaW1tZXIgTGVzZS0gdW5kIFNjaHJlaWJyZWNodGUgaGFiZW4uIgogCi0jOiBzZXR1cC5jOjEyNjQKKyM6IHNldHVwLmM6MTI3MQogbXNnaWQgIm9wZW4gL2Rldi9udWxsIG9yIGR1cCBmYWlsZWQiCiBtc2dzdHIgIsOWZmZuZW4gdm9uIC9kZXYvbnVsbCBvZGVyIGR1cCBmZWhsZ2VzY2hsYWdlbi4iCiAKLSM6IHNldHVwLmM6MTI3OQorIzogc2V0dXAuYzoxMjg2CiBtc2dpZCAiZm9yayBmYWlsZWQiCiBtc2dzdHIgImZvcmsgZmVobGdlc2NobGFnZW4iCiAKLSM6IHNldHVwLmM6MTI4NAorIzogc2V0dXAuYzoxMjkxCiBtc2dpZCAic2V0c2lkIGZhaWxlZCIKIG1zZ3N0ciAic2V0c2lkIGZlaGxnZXNjaGxhZ2VuIgogCi0jOiBzaGExLWZpbGUuYzo0NTMKKyM6IHNoYTEtZmlsZS5jOjQ1MgogIywgYy1mb3JtYXQKIG1zZ2lkICJvYmplY3QgZGlyZWN0b3J5ICVzIGRvZXMgbm90IGV4aXN0OyBjaGVjayAuZ2l0L29iamVjdHMvaW5mby9hbHRlcm5hdGVzIgogbXNnc3RyICIiCiAiT2JqZWt0dmVyemVpY2huaXMgJXMgZXhpc3RpZXJ0IG5pY2h0OyBwcsO8ZmUgLmdpdC9vYmplY3RzL2luZm8vYWx0ZXJuYXRlcyIKIAotIzogc2hhMS1maWxlLmM6NTA0CisjOiBzaGExLWZpbGUuYzo1MDMKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIG5vcm1hbGl6ZSBhbHRlcm5hdGUgb2JqZWN0IHBhdGg6ICVzIgogbXNnc3RyICJLb25udGUgYWx0ZXJuYXRpdmVuIE9iamVrdHBmYWQgJyVzJyBuaWNodCBub3JtYWxpc2llcmVuLiIKIAotIzogc2hhMS1maWxlLmM6NTc2CisjOiBzaGExLWZpbGUuYzo1NzUKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXM6IGlnbm9yaW5nIGFsdGVybmF0ZSBvYmplY3Qgc3RvcmVzLCBuZXN0aW5nIHRvbyBkZWVwIgogbXNnc3RyICIlczogaWdub3JpZXJlIGFsdGVybmF0aXZlIE9iamVrdHNwZWljaGVyIC0gVmVyc2NoYWNodGVsdW5nIHp1IHRpZWYiCiAKLSM6IHNoYTEtZmlsZS5jOjU4MworIzogc2hhMS1maWxlLmM6NTgyCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBub3JtYWxpemUgb2JqZWN0IGRpcmVjdG9yeTogJXMiCiBtc2dzdHIgIktvbm50ZSBPYmpla3R2ZXJ6ZWljaG5pcyAnJXMnIG5pY2h0IG5vcm1hbGlzaWVyZW4uIgogCi0jOiBzaGExLWZpbGUuYzo2MjYKKyM6IHNoYTEtZmlsZS5jOjYyNQogbXNnaWQgInVuYWJsZSB0byBmZG9wZW4gYWx0ZXJuYXRlcyBsb2NrZmlsZSIKIG1zZ3N0ciAiS29ubnRlIGZkb3BlbiBuaWNodCBhdWYgTG9jay1EYXRlaSBmw7xyIFwiYWx0ZXJuYXRlc1wiIGF1ZnJ1ZmVuLiIKIAotIzogc2hhMS1maWxlLmM6NjQ0CisjOiBzaGExLWZpbGUuYzo2NDMKIG1zZ2lkICJ1bmFibGUgdG8gcmVhZCBhbHRlcm5hdGVzIGZpbGUiCiBtc2dzdHIgIktvbm50ZSBcImFsdGVybmF0ZXNcIi1EYXRlaSBuaWNodCBsZXNlbi4iCiAKLSM6IHNoYTEtZmlsZS5jOjY1MQorIzogc2hhMS1maWxlLmM6NjUwCiBtc2dpZCAidW5hYmxlIHRvIG1vdmUgbmV3IGFsdGVybmF0ZXMgZmlsZSBpbnRvIHBsYWNlIgogbXNnc3RyICJLb25udGUgbmV1ZSBcImFsdGVybmF0ZXNcIi1EYXRlaSBuaWNodCDDvGJlcm5laG1lbi4iCiAKLSM6IHNoYTEtZmlsZS5jOjY4NgorIzogc2hhMS1maWxlLmM6Njg1CiAjLCBjLWZvcm1hdAogbXNnaWQgInBhdGggJyVzJyBkb2VzIG5vdCBleGlzdCIKIG1zZ3N0ciAiUGZhZCAnJXMnIGV4aXN0aWVydCBuaWNodCIKIAotIzogc2hhMS1maWxlLmM6NzEyCisjOiBzaGExLWZpbGUuYzo3MTEKICMsIGMtZm9ybWF0CiBtc2dpZCAicmVmZXJlbmNlIHJlcG9zaXRvcnkgJyVzJyBhcyBhIGxpbmtlZCBjaGVja291dCBpcyBub3Qgc3VwcG9ydGVkIHlldC4iCiBtc2dzdHIgIiIKICJSZWZlcmVuemllcnRlcyBSZXBvc2l0b3J5ICclcycgd2lyZCBub2NoIG5pY2h0IGFscyB2ZXJrbsO8cGZ0ZXNcbiIKICJBcmJlaXRzdmVyemVpY2huaXMgdW50ZXJzdMO8dHp0LiIKIAotIzogc2hhMS1maWxlLmM6NzE4CisjOiBzaGExLWZpbGUuYzo3MTcKICMsIGMtZm9ybWF0CiBtc2dpZCAicmVmZXJlbmNlIHJlcG9zaXRvcnkgJyVzJyBpcyBub3QgYSBsb2NhbCByZXBvc2l0b3J5LiIKIG1zZ3N0ciAiUmVmZXJlbnppZXJ0ZXMgUmVwb3NpdG9yeSAnJXMnIGlzdCBrZWluIGxva2FsZXMgUmVwb3NpdG9yeS4iCiAKLSM6IHNoYTEtZmlsZS5jOjcyNAorIzogc2hhMS1maWxlLmM6NzIzCiAjLCBjLWZvcm1hdAogbXNnaWQgInJlZmVyZW5jZSByZXBvc2l0b3J5ICclcycgaXMgc2hhbGxvdyIKIG1zZ3N0ciAiIgogIlJlZmVyZW56aWVydGVzIFJlcG9zaXRvcnkgJyVzJyBoYXQgZWluZSB1bnZvbGxzdMOkbmRpZ2UgSGlzdG9yaWUgKHNoYWxsb3cpLiIKIAotIzogc2hhMS1maWxlLmM6NzMyCisjOiBzaGExLWZpbGUuYzo3MzEKICMsIGMtZm9ybWF0CiBtc2dpZCAicmVmZXJlbmNlIHJlcG9zaXRvcnkgJyVzJyBpcyBncmFmdGVkIgogbXNnc3RyICIiCiAiUmVmZXJlbnppZXJ0ZXMgUmVwb3NpdG9yeSAnJXMnIGlzdCBtaXQga8O8bnN0bGljaGVuIFZvcmfDpG5nZXJuIChcImdyYWZ0c1wiKSAiCiAiZWluZ2Vow6RuZ3QuIgogCi0jOiBzaGExLWZpbGUuYzo3OTIKKyM6IHNoYTEtZmlsZS5jOjc5MQogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIGxpbmUgd2hpbGUgcGFyc2luZyBhbHRlcm5hdGUgcmVmczogJXMiCiBtc2dzdHIgIlVuZ8O8bHRpZ2UgWmVpbGUgYmVpbSBQYXJzZW4gYWx0ZXJuYXRpdmVyIFJlZmVyZW56ZW46ICVzIgogCi0jOiBzaGExLWZpbGUuYzo5NDQKKyM6IHNoYTEtZmlsZS5jOjk0MwogIywgYy1mb3JtYXQKIG1zZ2lkICJhdHRlbXB0aW5nIHRvIG1tYXAgJTxQUkl1TUFYPiBvdmVyIGxpbWl0ICU8UFJJdU1BWD4iCiBtc2dzdHIgIlZlcnN1Y2hlIG1tYXAgJTxQUkl1TUFYPiDDvGJlciBMaW1pdCAlPFBSSXVNQVg+LiIKIAotIzogc2hhMS1maWxlLmM6OTY5CisjOiBzaGExLWZpbGUuYzo5NjQKIG1zZ2lkICJtbWFwIGZhaWxlZCIKIG1zZ3N0ciAibW1hcCBmZWhsZ2VzY2hsYWdlbiIKIAotIzogc2hhMS1maWxlLmM6MTEzMworIzogc2hhMS1maWxlLmM6MTEyOAogIywgYy1mb3JtYXQKIG1zZ2lkICJvYmplY3QgZmlsZSAlcyBpcyBlbXB0eSIKIG1zZ3N0ciAiT2JqZWt0ZGF0ZWkgJXMgaXN0IGxlZXIuIgogCi0jOiBzaGExLWZpbGUuYzoxMjU3IHNoYTEtZmlsZS5jOjIzOTYKKyM6IHNoYTEtZmlsZS5jOjEyNTIgc2hhMS1maWxlLmM6MjM5MgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3JydXB0IGxvb3NlIG9iamVjdCAnJXMnIgogbXNnc3RyICJGZWhsZXJoYWZ0ZXMgbG9zZXMgT2JqZWt0ICclcycuIgogCi0jOiBzaGExLWZpbGUuYzoxMjU5IHNoYTEtZmlsZS5jOjI0MDAKKyM6IHNoYTEtZmlsZS5jOjEyNTQgc2hhMS1maWxlLmM6MjM5NgogIywgYy1mb3JtYXQKIG1zZ2lkICJnYXJiYWdlIGF0IGVuZCBvZiBsb29zZSBvYmplY3QgJyVzJyIKIG1zZ3N0ciAiTnV0emxvc2UgRGF0ZW4gYW0gRW5kZSB2b24gbG9zZW0gT2JqZWt0ICclcycuIgogCi0jOiBzaGExLWZpbGUuYzoxMzAxCisjOiBzaGExLWZpbGUuYzoxMjk2CiBtc2dpZCAiaW52YWxpZCBvYmplY3QgdHlwZSIKIG1zZ3N0ciAidW5nw7xsdGlnZXIgT2JqZWt0LVR5cCIKIAotIzogc2hhMS1maWxlLmM6MTM4NQorIzogc2hhMS1maWxlLmM6MTM4MAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gdW5wYWNrICVzIGhlYWRlciB3aXRoIC0tYWxsb3ctdW5rbm93bi10eXBlIgogbXNnc3RyICJLb25udGUgJXMgS29wZmJlcmVpY2ggbmljaHQgbWl0IC0tYWxsb3ctdW5rbm93bi10eXBlIGVudHBhY2tlbi4iCiAKLSM6IHNoYTEtZmlsZS5jOjEzODgKKyM6IHNoYTEtZmlsZS5jOjEzODMKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHVucGFjayAlcyBoZWFkZXIiCiBtc2dzdHIgIktvbm50ZSAlcyBLb3BmYmVyZWljaCBuaWNodCBlbnRwYWNrZW4uIgogCi0jOiBzaGExLWZpbGUuYzoxMzk0CisjOiBzaGExLWZpbGUuYzoxMzg5CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBwYXJzZSAlcyBoZWFkZXIgd2l0aCAtLWFsbG93LXVua25vd24tdHlwZSIKIG1zZ3N0ciAiS29ubnRlICVzIEtvcGZiZXJlaWNoIG1pdCAtLWFsbG93LXVua25vd24tdHlwZSBuaWNodCBwYXJzZW4uIgogCi0jOiBzaGExLWZpbGUuYzoxMzk3CisjOiBzaGExLWZpbGUuYzoxMzkyCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBwYXJzZSAlcyBoZWFkZXIiCiBtc2dzdHIgIktvbm50ZSAlcyBLb3BmYmVyZWljaCBuaWNodCBwYXJzZW4uIgogCi0jOiBzaGExLWZpbGUuYzoxNTg4CisjOiBzaGExLWZpbGUuYzoxNTg0CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byByZWFkIG9iamVjdCAlcyIKIG1zZ3N0ciAiS29ubnRlIE9iamVrdCAlcyBuaWNodCBsZXNlbi4iCiAKLSM6IHNoYTEtZmlsZS5jOjE1OTIKKyM6IHNoYTEtZmlsZS5jOjE1ODgKICMsIGMtZm9ybWF0CiBtc2dpZCAicmVwbGFjZW1lbnQgJXMgbm90IGZvdW5kIGZvciAlcyIKIG1zZ3N0ciAiRXJzZXR6dW5nICVzIGbDvHIgJXMgbmljaHQgZ2VmdW5kZW4uIgogCi0jOiBzaGExLWZpbGUuYzoxNTk2CisjOiBzaGExLWZpbGUuYzoxNTkyCiAjLCBjLWZvcm1hdAogbXNnaWQgImxvb3NlIG9iamVjdCAlcyAoc3RvcmVkIGluICVzKSBpcyBjb3JydXB0IgogbXNnc3RyICJMb3NlcyBPYmpla3QgJXMgKGdlc3BlaWNoZXJ0IGluICVzKSBpc3QgYmVzY2jDpGRpZ3QuIgogCi0jOiBzaGExLWZpbGUuYzoxNjAwCisjOiBzaGExLWZpbGUuYzoxNTk2CiAjLCBjLWZvcm1hdAogbXNnaWQgInBhY2tlZCBvYmplY3QgJXMgKHN0b3JlZCBpbiAlcykgaXMgY29ycnVwdCIKIG1zZ3N0ciAiR2VwYWNrdGVzIE9iamVrdCAlcyAoZ2VzcGVpY2hlcnQgaW4gJXMpIGlzdCBiZXNjaMOkZGlndC4iCiAKLSM6IHNoYTEtZmlsZS5jOjE3MDMKKyM6IHNoYTEtZmlsZS5jOjE2OTkKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHdyaXRlIGZpbGUgJXMiCiBtc2dzdHIgIktvbm50ZSBEYXRlaSAlcyBuaWNodCBzY2hyZWliZW4uIgogCi0jOiBzaGExLWZpbGUuYzoxNzEwCisjOiBzaGExLWZpbGUuYzoxNzA2CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBzZXQgcGVybWlzc2lvbiB0byAnJXMnIgogbXNnc3RyICJLb25udGUgWnVncmlmZnNiZXJlY2h0aWd1bmcgYXVmICclcycgbmljaHQgc2V0emVuLiIKIAotIzogc2hhMS1maWxlLmM6MTcxNworIzogc2hhMS1maWxlLmM6MTcxMwogbXNnaWQgImZpbGUgd3JpdGUgZXJyb3IiCiBtc2dzdHIgIkZlaGxlciBiZWltIFNjaHJlaWJlbiBlaW5lciBEYXRlaS4iCiAKLSM6IHNoYTEtZmlsZS5jOjE3MzYKKyM6IHNoYTEtZmlsZS5jOjE3MzIKIG1zZ2lkICJlcnJvciB3aGVuIGNsb3NpbmcgbG9vc2Ugb2JqZWN0IGZpbGUiCiBtc2dzdHIgIkZlaGxlciBiZWltIFNjaGxpZcOfZW4gZGVyIERhdGVpIGbDvHIgbG9zZSBPYmpla3RlLiIKIAotIzogc2hhMS1maWxlLmM6MTgwMQorIzogc2hhMS1maWxlLmM6MTc5NwogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnN1ZmZpY2llbnQgcGVybWlzc2lvbiBmb3IgYWRkaW5nIGFuIG9iamVjdCB0byByZXBvc2l0b3J5IGRhdGFiYXNlICVzIgogbXNnc3RyICIiCiAiVW56dXJlaWNoZW5kZSBCZXJlY2h0aWd1bmcgenVtIEhpbnp1ZsO8Z2VuIGVpbmVzIE9iamVrdGVzIHp1ciBSZXBvc2l0b3J5LSIKICJEYXRlbmJhbmsgJXMiCiAKLSM6IHNoYTEtZmlsZS5jOjE4MDMKKyM6IHNoYTEtZmlsZS5jOjE3OTkKIG1zZ2lkICJ1bmFibGUgdG8gY3JlYXRlIHRlbXBvcmFyeSBmaWxlIgogbXNnc3RyICJLb25udGUgdGVtcG9yw6RyZSBEYXRlaSBuaWNodCBlcnN0ZWxsZW4uIgogCi0jOiBzaGExLWZpbGUuYzoxODI3CisjOiBzaGExLWZpbGUuYzoxODIzCiBtc2dpZCAidW5hYmxlIHRvIHdyaXRlIGxvb3NlIG9iamVjdCBmaWxlIgogbXNnc3RyICJGZWhsZXIgYmVpbSBTY2hyZWliZW4gZGVyIERhdGVpIGbDvHIgbG9zZSBPYmpla3RlLiIKIAotIzogc2hhMS1maWxlLmM6MTgzMworIzogc2hhMS1maWxlLmM6MTgyOQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gZGVmbGF0ZSBuZXcgb2JqZWN0ICVzICglZCkiCiBtc2dzdHIgIktvbm50ZSBuZXVlcyBPYmpla3QgJXMgKCVkKSBuaWNodCBrb21wcmltaWVyZW4uIgogCi0jOiBzaGExLWZpbGUuYzoxODM3CisjOiBzaGExLWZpbGUuYzoxODMzCiAjLCBjLWZvcm1hdAogbXNnaWQgImRlZmxhdGVFbmQgb24gb2JqZWN0ICVzIGZhaWxlZCAoJWQpIgogbXNnc3RyICJkZWZsYXRlRW5kIGF1ZiBPYmpla3QgJXMgZmVobGdlc2NobGFnZW4gKCVkKSIKIAotIzogc2hhMS1maWxlLmM6MTg0MQorIzogc2hhMS1maWxlLmM6MTgzNwogIywgYy1mb3JtYXQKIG1zZ2lkICJjb25mdXNlZCBieSB1bnN0YWJsZSBvYmplY3Qgc291cmNlIGRhdGEgZm9yICVzIgogbXNnc3RyICJGZWhsZXIgd2VnZW4gaW5zdGFiaWxlbiBPYmpla3RxdWVsbGRhdGVuIGbDvHIgJXMiCiAKLSM6IHNoYTEtZmlsZS5jOjE4NTEgYnVpbHRpbi9wYWNrLW9iamVjdHMuYzo5MjUKKyM6IHNoYTEtZmlsZS5jOjE4NDcgYnVpbHRpbi9wYWNrLW9iamVjdHMuYzo5MjUKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHV0aW1lKCkgb24gJXMiCiBtc2dzdHIgIkZlaGxlciBiZWltIEF1ZnJ1ZiB2b24gdXRpbWUoKSBhdWYgJyVzJy4iCiAKLSM6IHNoYTEtZmlsZS5jOjE5MjYKKyM6IHNoYTEtZmlsZS5jOjE5MjIKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IHJlYWQgb2JqZWN0IGZvciAlcyIKIG1zZ3N0ciAiS2FubiBPYmpla3QgZsO8ciAlcyBuaWNodCBsZXNlbi4iCiAKLSM6IHNoYTEtZmlsZS5jOjE5NjYKKyM6IHNoYTEtZmlsZS5jOjE5NjIKIG1zZ2lkICJjb3JydXB0IGNvbW1pdCIKIG1zZ3N0ciAiZmVobGVyaGFmdGVyIENvbW1pdCIKIAotIzogc2hhMS1maWxlLmM6MTk3NAorIzogc2hhMS1maWxlLmM6MTk3MAogbXNnaWQgImNvcnJ1cHQgdGFnIgogbXNnc3RyICJmZWhsZXJoYWZ0ZXMgVGFnIgogCi0jOiBzaGExLWZpbGUuYzoyMDczCisjOiBzaGExLWZpbGUuYzoyMDY5CiAjLCBjLWZvcm1hdAogbXNnaWQgInJlYWQgZXJyb3Igd2hpbGUgaW5kZXhpbmcgJXMiCiBtc2dzdHIgIkxlc2VmZWhsZXIgYmVpbSBJbmRpemllcmVuIHZvbiAnJXMnLiIKIAotIzogc2hhMS1maWxlLmM6MjA3NgorIzogc2hhMS1maWxlLmM6MjA3MgogIywgYy1mb3JtYXQKIG1zZ2lkICJzaG9ydCByZWFkIHdoaWxlIGluZGV4aW5nICVzIgogbXNnc3RyICJyZWFkKCkgenUga3VyeiBiZWltIEluZGl6aWVyZW4gdm9uICclcycuIgogCi0jOiBzaGExLWZpbGUuYzoyMTQ5IHNoYTEtZmlsZS5jOjIxNTgKKyM6IHNoYTEtZmlsZS5jOjIxNDUgc2hhMS1maWxlLmM6MjE1NAogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogZmFpbGVkIHRvIGluc2VydCBpbnRvIGRhdGFiYXNlIgogbXNnc3RyICIlczogRmVobGVyIGJlaW0gRWluZsO8Z2VuIGluIGRpZSBEYXRlbmJhbmsiCiAKLSM6IHNoYTEtZmlsZS5jOjIxNjQKKyM6IHNoYTEtZmlsZS5jOjIxNjAKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXM6IHVuc3VwcG9ydGVkIGZpbGUgdHlwZSIKIG1zZ3N0ciAiJXM6IG5pY2h0IHVudGVyc3TDvHR6dGUgRGF0ZWlhcnQiCiAKLSM6IHNoYTEtZmlsZS5jOjIxODgKKyM6IHNoYTEtZmlsZS5jOjIxODQKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgaXMgbm90IGEgdmFsaWQgb2JqZWN0IgogbXNnc3RyICIlcyBpc3Qga2VpbiBnw7xsdGlnZXMgT2JqZWt0IgogCi0jOiBzaGExLWZpbGUuYzoyMTkwCisjOiBzaGExLWZpbGUuYzoyMTg2CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIGlzIG5vdCBhIHZhbGlkICclcycgb2JqZWN0IgogbXNnc3RyICIlcyBpc3Qga2VpbiBnw7xsdGlnZXMgJyVzJyBPYmpla3QiCiAKLSM6IHNoYTEtZmlsZS5jOjIyMTcgYnVpbHRpbi9pbmRleC1wYWNrLmM6MTU1CisjOiBzaGExLWZpbGUuYzoyMjEzIGJ1aWx0aW4vaW5kZXgtcGFjay5jOjE1NQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gb3BlbiAlcyIKIG1zZ3N0ciAia2FubiAlcyBuaWNodCDDtmZmbmVuIgogCi0jOiBzaGExLWZpbGUuYzoyNDA3IHNoYTEtZmlsZS5jOjI0NTkKKyM6IHNoYTEtZmlsZS5jOjI0MDMgc2hhMS1maWxlLmM6MjQ1NQogIywgYy1mb3JtYXQKIG1zZ2lkICJoYXNoIG1pc21hdGNoIGZvciAlcyAoZXhwZWN0ZWQgJXMpIgogbXNnc3RyICJIYXNoIGbDvHIgJXMgc3RpbW10IG5pY2h0IMO8YmVyZWluICglcyBlcndhcnRldCkuIgogCi0jOiBzaGExLWZpbGUuYzoyNDMxCisjOiBzaGExLWZpbGUuYzoyNDI3CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBtbWFwICVzIgogbXNnc3RyICJLb25udGUgbW1hcCBuaWNodCBhdWYgJXMgYXVzZsO8aHJlbi4iCiAKLSM6IHNoYTEtZmlsZS5jOjI0MzYKKyM6IHNoYTEtZmlsZS5jOjI0MzIKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHVucGFjayBoZWFkZXIgb2YgJXMiCiBtc2dzdHIgIktvbm50ZSBLb3BmYmVyZWljaCB2b24gJXMgbmljaHQgZW50cGFja2VuLiIKIAotIzogc2hhMS1maWxlLmM6MjQ0MgorIzogc2hhMS1maWxlLmM6MjQzOAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gcGFyc2UgaGVhZGVyIG9mICVzIgogbXNnc3RyICJLb25udGUgS29wZmJlcmVpY2ggdm9uICVzIG5pY2h0IHBhcnNlbi4iCiAKLSM6IHNoYTEtZmlsZS5jOjI0NTMKKyM6IHNoYTEtZmlsZS5jOjI0NDkKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHVucGFjayBjb250ZW50cyBvZiAlcyIKIG1zZ3N0ciAiS29ubnRlIEluaGFsdCB2b24gJXMgbmljaHQgZW50cGFja2VuLiIKIAotIzogc2hhMS1uYW1lLmM6NDkwCisjOiBzaGExLW5hbWUuYzo0ODcKICMsIGMtZm9ybWF0CiBtc2dpZCAic2hvcnQgU0hBMSAlcyBpcyBhbWJpZ3VvdXMiCiBtc2dzdHIgIkt1cnplciBTSEEtMSAlcyBpc3QgbWVocmRldXRpZy4iCiAKLSM6IHNoYTEtbmFtZS5jOjUwMQorIzogc2hhMS1uYW1lLmM6NDk4CiBtc2dpZCAiVGhlIGNhbmRpZGF0ZXMgYXJlOiIKIG1zZ3N0ciAiRGllIEthbmRpZGF0ZW4gc2luZDoiCiAKLSM6IHNoYTEtbmFtZS5jOjgwMAorIzogc2hhMS1uYW1lLmM6Nzk3CiBtc2dpZCAiIgogIkdpdCBub3JtYWxseSBuZXZlciBjcmVhdGVzIGEgcmVmIHRoYXQgZW5kcyB3aXRoIDQwIGhleCBjaGFyYWN0ZXJzXG4iCiAiYmVjYXVzZSBpdCB3aWxsIGJlIGlnbm9yZWQgd2hlbiB5b3UganVzdCBzcGVjaWZ5IDQwLWhleC4gVGhlc2UgcmVmc1xuIgpAQCAtNzE5NSw0MyArNzIyMCw0MyBAQAogImF1c2bDvGhyZW4uIgogCiAjLiBUUkFOU0xBVE9SUzogSUVDIDgwMDAwLTEzOjIwMDggZ2liaWJ5dGUKLSM6IHN0cmJ1Zi5jOjgyMQorIzogc3RyYnVmLmM6ODIyCiAjLCBjLWZvcm1hdAogbXNnaWQgIiV1LiUyLjJ1IEdpQiIKIG1zZ3N0ciAiJXUuJTIuMnUgR2lCIgogCiAjLiBUUkFOU0xBVE9SUzogSUVDIDgwMDAwLTEzOjIwMDggZ2liaWJ5dGUvc2Vjb25kCi0jOiBzdHJidWYuYzo4MjMKKyM6IHN0cmJ1Zi5jOjgyNAogIywgYy1mb3JtYXQKIG1zZ2lkICIldS4lMi4ydSBHaUIvcyIKIG1zZ3N0ciAiJXUuJTIuMnUgR2lCL3MiCiAKICMuIFRSQU5TTEFUT1JTOiBJRUMgODAwMDAtMTM6MjAwOCBtZWJpYnl0ZQotIzogc3RyYnVmLmM6ODMxCisjOiBzdHJidWYuYzo4MzIKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXUuJTIuMnUgTWlCIgogbXNnc3RyICIldS4lMi4ydSBNaUIiCiAKICMuIFRSQU5TTEFUT1JTOiBJRUMgODAwMDAtMTM6MjAwOCBtZWJpYnl0ZS9zZWNvbmQKLSM6IHN0cmJ1Zi5jOjgzMworIzogc3RyYnVmLmM6ODM0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiV1LiUyLjJ1IE1pQi9zIgogbXNnc3RyICIldS4lMi4ydSBNaUIvcyIKIAogIy4gVFJBTlNMQVRPUlM6IElFQyA4MDAwMC0xMzoyMDA4IGtpYmlieXRlCi0jOiBzdHJidWYuYzo4NDAKKyM6IHN0cmJ1Zi5jOjg0MQogIywgYy1mb3JtYXQKIG1zZ2lkICIldS4lMi4ydSBLaUIiCiBtc2dzdHIgIiV1LiUyLjJ1IEtpQiIKIAogIy4gVFJBTlNMQVRPUlM6IElFQyA4MDAwMC0xMzoyMDA4IGtpYmlieXRlL3NlY29uZAotIzogc3RyYnVmLmM6ODQyCisjOiBzdHJidWYuYzo4NDMKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXUuJTIuMnUgS2lCL3MiCiBtc2dzdHIgIiV1LiUyLjJ1IEtpQi9zIgogCiAjLiBUUkFOU0xBVE9SUzogSUVDIDgwMDAwLTEzOjIwMDggYnl0ZQotIzogc3RyYnVmLmM6ODQ4CisjOiBzdHJidWYuYzo4NDkKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXUgYnl0ZSIKIG1zZ2lkX3BsdXJhbCAiJXUgYnl0ZXMiCkBAIC03MjM5LDcgKzcyNjQsNyBAQAogbXNnc3RyWzFdICIldSBCeXRlcyIKIAogIy4gVFJBTlNMQVRPUlM6IElFQyA4MDAwMC0xMzoyMDA4IGJ5dGUvc2Vjb25kCi0jOiBzdHJidWYuYzo4NTAKKyM6IHN0cmJ1Zi5jOjg1MQogIywgYy1mb3JtYXQKIG1zZ2lkICIldSBieXRlL3MiCiBtc2dpZF9wbHVyYWwgIiV1IGJ5dGVzL3MiCkBAIC03MzU4LDI4ICs3MzgzLDI4IEBACiBtc2dpZCAibHMtdHJlZSByZXR1cm5lZCB1bmV4cGVjdGVkIHJldHVybiBjb2RlICVkIgogbXNnc3RyICJscy10cmVlIG1pdCB1bmVyd2FydGV0ZW0gUsO8Y2tnYWJld2VydCAlZCBiZWVuZGV0IgogCi0jOiBzdWJtb2R1bGUtY29uZmlnLmM6MjMyCisjOiBzdWJtb2R1bGUtY29uZmlnLmM6MjM2CiAjLCBjLWZvcm1hdAogbXNnaWQgImlnbm9yaW5nIHN1c3BpY2lvdXMgc3VibW9kdWxlIG5hbWU6ICVzIgogbXNnc3RyICJJZ25vcmllcmUgdmVyZMOkY2h0aWdlbiBTdWJtb2R1bG5hbWVuOiAlcyIKIAotIzogc3VibW9kdWxlLWNvbmZpZy5jOjI5OQorIzogc3VibW9kdWxlLWNvbmZpZy5jOjMwMwogbXNnaWQgIm5lZ2F0aXZlIHZhbHVlcyBub3QgYWxsb3dlZCBmb3Igc3VibW9kdWxlLmZldGNoam9icyIKIG1zZ3N0ciAiTmVnYXRpdmUgV2VydGUgZsO8ciBzdWJtb2R1bGUuZmV0Y2hqb2JzIG5pY2h0IGVybGF1YnQuIgogCi0jOiBzdWJtb2R1bGUtY29uZmlnLmM6Mzk3CisjOiBzdWJtb2R1bGUtY29uZmlnLmM6NDAxCiAjLCBjLWZvcm1hdAogbXNnaWQgImlnbm9yaW5nICclcycgd2hpY2ggbWF5IGJlIGludGVycHJldGVkIGFzIGEgY29tbWFuZC1saW5lIG9wdGlvbjogJXMiCiBtc2dzdHIgIiIKICJJZ25vcmllcmUgJyVzJywgd2FzIGFscyBlaW5lIEJlZmVobHN6ZWlsZW5vcHRpb24gJyVzJyBpbnRlcnByZXRpZXJ0IHdlcmRlbiAiCiAid8O8cmRlLiIKIAotIzogc3VibW9kdWxlLWNvbmZpZy5jOjQ4NgorIzogc3VibW9kdWxlLWNvbmZpZy5jOjQ5MAogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIHZhbHVlIGZvciAlcyIKIG1zZ3N0ciAiVW5nw7xsdGlnZXIgV2VydCBmw7xyICVzIgogCi0jOiBzdWJtb2R1bGUtY29uZmlnLmM6NzU1CisjOiBzdWJtb2R1bGUtY29uZmlnLmM6NzYxCiAjLCBjLWZvcm1hdAogbXNnaWQgIkNvdWxkIG5vdCB1cGRhdGUgLmdpdG1vZHVsZXMgZW50cnkgJXMiCiBtc2dzdHIgIktvbm50ZSBFaW50cmFnICclcycgaW4gLmdpdG1vZHVsZXMgbmljaHQgYWt0dWFsaXNpZXJlbiIKQEAgLTc0MTQsNyArNzQzOSw3IEBACiBtc2dpZCAiY291bGQgbm90IHJlYWQgZnJvbSBzdGRpbiIKIG1zZ3N0ciAia29ubnRlIG5pY2h0IHZvbiBkZXIgU3RhbmRhcmQtRWluZ2FiZSBsZXNlbiIKIAotIzogdHJhaWxlci5jOjEwMTEgd3JhcHBlci5jOjcwMQorIzogdHJhaWxlci5jOjEwMTEgd3JhcHBlci5jOjY2NQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3Qgc3RhdCAlcyIKIG1zZ3N0ciAiS29ubnRlICclcycgbmljaHQgbGVzZW4iCkBAIC03NDQzLDQ3ICs3NDY4LDQ3IEBACiBtc2dpZCAiV291bGQgc2V0IHVwc3RyZWFtIG9mICclcycgdG8gJyVzJyBvZiAnJXMnXG4iCiBtc2dzdHIgIlfDvHJkZSBVcHN0cmVhbS1CcmFuY2ggdm9uICclcycgenUgJyVzJyB2b24gJyVzJyBzZXR6ZW5cbiIKIAotIzogdHJhbnNwb3J0LmM6MTQyCisjOiB0cmFuc3BvcnQuYzoxNDUKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHJlYWQgYnVuZGxlICclcyciCiBtc2dzdHIgIktvbm50ZSBQYWtldCAnJXMnIG5pY2h0IGxlc2VuLiIKIAotIzogdHJhbnNwb3J0LmM6MjA4CisjOiB0cmFuc3BvcnQuYzoyMTQKICMsIGMtZm9ybWF0CiBtc2dpZCAidHJhbnNwb3J0OiBpbnZhbGlkIGRlcHRoIG9wdGlvbiAnJXMnIgogbXNnc3RyICJ0cmFuc3BvcnQ6IHVuZ8O8bHRpZ2UgLS1kZXB0aCBPcHRpb24gJyVzJyIKIAotIzogdHJhbnNwb3J0LmM6MjU5CisjOiB0cmFuc3BvcnQuYzoyNjYKIG1zZ2lkICJzZWUgcHJvdG9jb2wudmVyc2lvbiBpbiAnZ2l0IGhlbHAgY29uZmlnJyBmb3IgbW9yZSBkZXRhaWxzIgogbXNnc3RyICJTaWVoZSBwcm90b2NvbC52ZXJzaW9uIGluICdnaXQgaGVscCBjb25maWcnIGbDvHIgd2VpdGVyZSBJbmZvcm1hdGlvbmVuIgogCi0jOiB0cmFuc3BvcnQuYzoyNjAKKyM6IHRyYW5zcG9ydC5jOjI2NwogbXNnaWQgInNlcnZlciBvcHRpb25zIHJlcXVpcmUgcHJvdG9jb2wgdmVyc2lvbiAyIG9yIGxhdGVyIgogbXNnc3RyICJTZXJ2ZXItT3B0aW9uZW4gYmVuw7Z0aWdlbiBQcm90b2tvbGwtVmVyc2lvbiAyIG9kZXIgaMO2aGVyIgogCi0jOiB0cmFuc3BvcnQuYzo2MjUKKyM6IHRyYW5zcG9ydC5jOjYzMgogbXNnaWQgImNvdWxkIG5vdCBwYXJzZSB0cmFuc3BvcnQuY29sb3IuKiBjb25maWciCiBtc2dzdHIgIktvbm50ZSB0cmFuc3BvcnQuY29sb3IuKiBLb25maWd1cmF0aW9uIG5pY2h0IHBhcnNlbi4iCiAKLSM6IHRyYW5zcG9ydC5jOjY5OAorIzogdHJhbnNwb3J0LmM6NzA1CiBtc2dpZCAic3VwcG9ydCBmb3IgcHJvdG9jb2wgdjIgbm90IGltcGxlbWVudGVkIHlldCIKIG1zZ3N0ciAiVW50ZXJzdMO8dHp1bmcgZsO8ciBQcm90b2tvbGwgdjIgbm9jaCBuaWNodCBpbXBsZW1lbnRpZXJ0LiIKIAotIzogdHJhbnNwb3J0LmM6ODI1CisjOiB0cmFuc3BvcnQuYzo4MzEKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5rbm93biB2YWx1ZSBmb3IgY29uZmlnICclcyc6ICVzIgogbXNnc3RyICJVbmJla2FubnRlciBXZXJ0IGbDvHIgS29uZmlndXJhdGlvbiAnJXMnOiAlcyIKIAotIzogdHJhbnNwb3J0LmM6ODkxCisjOiB0cmFuc3BvcnQuYzo4OTcKICMsIGMtZm9ybWF0CiBtc2dpZCAidHJhbnNwb3J0ICclcycgbm90IGFsbG93ZWQiCiBtc2dzdHIgIsOcYmVydHJhZ3VuZ3NhcnQgJyVzJyBuaWNodCBlcmxhdWJ0LiIKIAotIzogdHJhbnNwb3J0LmM6OTQ1CisjOiB0cmFuc3BvcnQuYzo5NDkKIG1zZ2lkICJnaXQtb3Zlci1yc3luYyBpcyBubyBsb25nZXIgc3VwcG9ydGVkIgogbXNnc3RyICJnaXQtb3Zlci1yc3luYyB3aXJkIG5pY2h0IGzDpG5nZXIgdW50ZXJzdMO8dHp0LiIKIAotIzogdHJhbnNwb3J0LmM6MTA0MAorIzogdHJhbnNwb3J0LmM6MTA0NAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiVGhlIGZvbGxvd2luZyBzdWJtb2R1bGUgcGF0aHMgY29udGFpbiBjaGFuZ2VzIHRoYXQgY2FuXG4iCkBAIC03NDkyLDcgKzc1MTcsNyBAQAogIkRpZSBmb2xnZW5kZW4gU3VibW9kdWwtUGZhZGUgZW50aGFsdGVuIMOEbmRlcnVuZ2VuLCBkaWUgaW4ga2VpbmVtXG4iCiAiUmVtb3RlLVJlcG9zaXRvcnkgZ2VmdW5kZW4gd3VyZGVuOlxuIgogCi0jOiB0cmFuc3BvcnQuYzoxMDQ0CisjOiB0cmFuc3BvcnQuYzoxMDQ4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJcbiIKQEAgLTc1MTksMzQgKzc1NDQsMzQgQEAKICJ6dW0gVmVyc2VuZGVuIHp1IGVpbmVtIFJlbW90ZS1SZXBvc2l0b3J5LlxuIgogIlxuIgogCi0jOiB0cmFuc3BvcnQuYzoxMDUyCisjOiB0cmFuc3BvcnQuYzoxMDU2CiBtc2dpZCAiQWJvcnRpbmcuIgogbXNnc3RyICJBYmJydWNoLiIKIAotIzogdHJhbnNwb3J0LmM6MTE5MworIzogdHJhbnNwb3J0LmM6MTIwMQogbXNnaWQgImZhaWxlZCB0byBwdXNoIGFsbCBuZWVkZWQgc3VibW9kdWxlcyIKIG1zZ3N0ciAiRmVobGVyIGJlaW0gVmVyc2FuZCBhbGxlciBlcmZvcmRlcmxpY2hlbiBTdWJtb2R1bGUuIgogCi0jOiB0cmFuc3BvcnQuYzoxMzQwIHRyYW5zcG9ydC1oZWxwZXIuYzo2NDUKKyM6IHRyYW5zcG9ydC5jOjEzNDUgdHJhbnNwb3J0LWhlbHBlci5jOjY1NQogbXNnaWQgIm9wZXJhdGlvbiBub3Qgc3VwcG9ydGVkIGJ5IHByb3RvY29sIgogbXNnc3RyICJEaWUgT3BlcmF0aW9uIHdpcmQgdm9uIGRlbSBQcm90b2tvbGwgbmljaHQgdW50ZXJzdMO8dHp0LiIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjUxIHRyYW5zcG9ydC1oZWxwZXIuYzo4MAorIzogdHJhbnNwb3J0LWhlbHBlci5jOjYxIHRyYW5zcG9ydC1oZWxwZXIuYzo5MAogbXNnaWQgImZ1bGwgd3JpdGUgdG8gcmVtb3RlIGhlbHBlciBmYWlsZWQiCiBtc2dzdHIgIlZvbGxzdMOkbmRpZ2VzIFNjaHJlaWJlbiB6dSBSZW1vdGUtSGVscGVyIGZlaGxnZXNjaGxhZ2VuLiIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjEzNAorIzogdHJhbnNwb3J0LWhlbHBlci5jOjE0NAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gZmluZCByZW1vdGUgaGVscGVyIGZvciAnJXMnIgogbXNnc3RyICJLb25udGUgUmVtb3RlLUhlbHBlciBmw7xyICclcycgbmljaHQgZmluZGVuLiIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjE1MCB0cmFuc3BvcnQtaGVscGVyLmM6NTU5CisjOiB0cmFuc3BvcnQtaGVscGVyLmM6MTYwIHRyYW5zcG9ydC1oZWxwZXIuYzo1NjkKIG1zZ2lkICJjYW4ndCBkdXAgaGVscGVyIG91dHB1dCBmZCIKIG1zZ3N0ciAiIgogIktvbm50ZSBkdXAoKSBhdWYgRGF0ZWlkZXNrcmlwdG9yIGbDvHIgQXVzZ2FiZW4gZGVzIFJlbW90ZS1IZWxwZXJzIG5pY2h0ICIKICJhdXNmw7xocmVuLiIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjIwMQorIzogdHJhbnNwb3J0LWhlbHBlci5jOjIxMQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAidW5rbm93biBtYW5kYXRvcnkgY2FwYWJpbGl0eSAlczsgdGhpcyByZW1vdGUgaGVscGVyIHByb2JhYmx5IG5lZWRzIG5ld2VyICIKQEAgLTc1NTUsMTAwICs3NTgwLDEwNSBAQAogIlVuYmVrYW5udGUgZXJmb3JkZXJsaWNoZSBGw6RoaWdrZWl0ICVzOyBkaWVzZXIgUmVtb3RlLUhlbHBlciBiZW7DtnRpZ3RcbiIKICJ3YWhyc2NoZWlubGljaCBlaW5lIG5ldWVyZSBWZXJzaW9uIHZvbiBHaXQuIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6MjA3CisjOiB0cmFuc3BvcnQtaGVscGVyLmM6MjE3CiBtc2dpZCAidGhpcyByZW1vdGUgaGVscGVyIHNob3VsZCBpbXBsZW1lbnQgcmVmc3BlYyBjYXBhYmlsaXR5IgogbXNnc3RyICJEaWVzZXIgUmVtb3RlLUhlbHBlciBzb2xsdGUgZGllIFwicmVmc3BlY1wiLUbDpGhpZ2tlaXQgaW1wbGVtZW50aWVyZW4uIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6Mjc0IHRyYW5zcG9ydC1oZWxwZXIuYzo0MTQKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzoyODQgdHJhbnNwb3J0LWhlbHBlci5jOjQyNAogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyB1bmV4cGVjdGVkbHkgc2FpZDogJyVzJyIKIG1zZ3N0ciAidW5lcndhcnRldGUgQXVzZ2FiZSB2b24gJXM6ICclcyciCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzo0MDMKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzo0MTMKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgYWxzbyBsb2NrZWQgJXMiCiBtc2dzdHIgIiVzIHNwZXJydGUgYXVjaCAlcyIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjQ4MQorIzogdHJhbnNwb3J0LWhlbHBlci5jOjQ5MQogbXNnaWQgImNvdWxkbid0IHJ1biBmYXN0LWltcG9ydCIKIG1zZ3N0ciAiS29ubnRlIFwiZmFzdC1pbXBvcnRcIiBuaWNodCBhdXNmw7xocmVuLiIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjUwNAorIzogdHJhbnNwb3J0LWhlbHBlci5jOjUxNAogbXNnaWQgImVycm9yIHdoaWxlIHJ1bm5pbmcgZmFzdC1pbXBvcnQiCiBtc2dzdHIgIkZlaGxlciBiZWltIEF1c2bDvGhyZW4gdm9uICdmYXN0LWltcG9ydCcuIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6NTMzIHRyYW5zcG9ydC1oZWxwZXIuYzoxMTA1CisjOiB0cmFuc3BvcnQtaGVscGVyLmM6NTQzIHRyYW5zcG9ydC1oZWxwZXIuYzoxMTMyCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCByZWFkIHJlZiAlcyIKIG1zZ3N0ciAiS29ubnRlIFJlZmVyZW56ICVzIG5pY2h0IGxlc2VuLiIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjU3OAorIzogdHJhbnNwb3J0LWhlbHBlci5jOjU4OAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmtub3duIHJlc3BvbnNlIHRvIGNvbm5lY3Q6ICVzIgogbXNnc3RyICJVbmJla2FubnRlIEFudHdvcnQgYXVmICdjb25uZWN0JzogJXMiCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzo2MDAKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzo2MTAKIG1zZ2lkICJzZXR0aW5nIHJlbW90ZSBzZXJ2aWNlIHBhdGggbm90IHN1cHBvcnRlZCBieSBwcm90b2NvbCIKIG1zZ3N0ciAiIgogIlNldHplbiBkZXMgUmVtb3RlLVNlcnZpY2UgUGZhZHMgd2lyZCB2b24gZGVtIFByb3Rva29sbCBuaWNodCB1bnRlcnN0w7x0enQuIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6NjAyCisjOiB0cmFuc3BvcnQtaGVscGVyLmM6NjEyCiBtc2dpZCAiaW52YWxpZCByZW1vdGUgc2VydmljZSBwYXRoIgogbXNnc3RyICJVbmfDvGx0aWdlciBSZW1vdGUtU2VydmljZSBQZmFkLiIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjY0OAorIzogdHJhbnNwb3J0LWhlbHBlci5jOjY1OAogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW4ndCBjb25uZWN0IHRvIHN1YnNlcnZpY2UgJXMiCiBtc2dzdHIgIkthbm4ga2VpbmUgVmVyYmluZHVuZyB6dSBTdWJzZXJ2aWNlICVzIGhlcnN0ZWxsZW4uIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6NzIwCisjOiB0cmFuc3BvcnQtaGVscGVyLmM6NzM0CiAjLCBjLWZvcm1hdAogbXNnaWQgImV4cGVjdGVkIG9rL2Vycm9yLCBoZWxwZXIgc2FpZCAnJXMnIgogbXNnc3RyICJFcndhcnRldGUgb2svZXJyb3IsIFJlbW90ZS1IZWxwZXIgZ2FiICclcycgYXVzLiIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjc3MworIzogdHJhbnNwb3J0LWhlbHBlci5jOjc4NwogIywgYy1mb3JtYXQKIG1zZ2lkICJoZWxwZXIgcmVwb3J0ZWQgdW5leHBlY3RlZCBzdGF0dXMgb2YgJXMiCiBtc2dzdHIgIlJlbW90ZS1IZWxwZXIgbWVsZGV0ZSB1bmVyd2FydGV0ZW4gU3RhdHVzIHZvbiAlcy4iCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzo4MzQKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzo4NDgKICMsIGMtZm9ybWF0CiBtc2dpZCAiaGVscGVyICVzIGRvZXMgbm90IHN1cHBvcnQgZHJ5LXJ1biIKIG1zZ3N0ciAiUmVtb3RlLUhlbHBlciAlcyB1bnRlcnN0w7x0enQga2VpbiBUcm9ja2VubGF1Zi4iCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzo4MzcKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzo4NTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiaGVscGVyICVzIGRvZXMgbm90IHN1cHBvcnQgLS1zaWduZWQiCiBtc2dzdHIgIlJlbW90ZS1IZWxwZXIgJXMgdW50ZXJzdMO8dHp0IGtlaW4gLS1zaWduZWQuIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6ODQwCisjOiB0cmFuc3BvcnQtaGVscGVyLmM6ODU0CiAjLCBjLWZvcm1hdAogbXNnaWQgImhlbHBlciAlcyBkb2VzIG5vdCBzdXBwb3J0IC0tc2lnbmVkPWlmLWFza2VkIgogbXNnc3RyICJSZW1vdGUtSGVscGVyICVzIHVudGVyc3TDvHR6dCBrZWluIC0tc2lnbmVkPWlmLWFza2VkLiIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjg0NworIzogdHJhbnNwb3J0LWhlbHBlci5jOjg1OQorIywgYy1mb3JtYXQKK21zZ2lkICJoZWxwZXIgJXMgZG9lcyBub3Qgc3VwcG9ydCAtLWF0b21pYyIKK21zZ3N0ciAiUmVtb3RlLUhlbHBlciAlcyB1bnRlcnN0w7x0enQga2VpbiAtLWF0b21pYy4iCisKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzo4NjUKICMsIGMtZm9ybWF0CiBtc2dpZCAiaGVscGVyICVzIGRvZXMgbm90IHN1cHBvcnQgJ3B1c2gtb3B0aW9uJyIKIG1zZ3N0ciAiUmVtb3RlLUhlbHBlciAlcyB1bnRlcnN0w7x0enQgbmljaHQgJ3B1c2gtb3B0aW9uJy4iCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzo5NDUKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzo5NjMKIG1zZ2lkICJyZW1vdGUtaGVscGVyIGRvZXNuJ3Qgc3VwcG9ydCBwdXNoOyByZWZzcGVjIG5lZWRlZCIKIG1zZ3N0ciAiUmVtb3RlLUhlbHBlciB1bnRlcnN0w7x0enQga2VpbiBQdXNoOyBSZWZzcGVjIGJlbsO2dGlndCIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjk1MAorIzogdHJhbnNwb3J0LWhlbHBlci5jOjk2OAogIywgYy1mb3JtYXQKIG1zZ2lkICJoZWxwZXIgJXMgZG9lcyBub3Qgc3VwcG9ydCAnZm9yY2UnIgogbXNnc3RyICJSZW1vdGUtSGVscGVyICVzIHVudGVyc3TDvHR6dCBrZWluICdmb3JjZScuIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6OTk3CisjOiB0cmFuc3BvcnQtaGVscGVyLmM6MTAxNQogbXNnaWQgImNvdWxkbid0IHJ1biBmYXN0LWV4cG9ydCIKIG1zZ3N0ciAiS29ubnRlIFwiZmFzdC1leHBvcnRcIiBuaWNodCBhdXNmw7xocmVuLiIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjEwMDIKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxMDIwCiBtc2dpZCAiZXJyb3Igd2hpbGUgcnVubmluZyBmYXN0LWV4cG9ydCIKIG1zZ3N0ciAiRmVobGVyIGJlaW0gQXVzZsO8aHJlbiB2b24gXCJmYXN0LWV4cG9ydFwiLiIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjEwMjcKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxMDQ1CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJObyByZWZzIGluIGNvbW1vbiBhbmQgbm9uZSBzcGVjaWZpZWQ7IGRvaW5nIG5vdGhpbmcuXG4iCkBAIC03NjU3LDQ3ICs3Njg3LDQ3IEBACiAiS2VpbmUgZ2VtZWluc2FtZW4gUmVmZXJlbnplbiB1bmQgbmljaHRzIHNwZXppZml6aWVydDsga2VpbmUgQXVzZsO8aHJ1bmcuXG4iCiAiVmllbGxlaWNodCBzb2xsdGVuIFNpZSBlaW5lbiBCcmFuY2ggd2llICdtYXN0ZXInIGFuZ2ViZW4uXG4iCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxMDkxCisjOiB0cmFuc3BvcnQtaGVscGVyLmM6MTExOAogIywgYy1mb3JtYXQKIG1zZ2lkICJtYWxmb3JtZWQgcmVzcG9uc2UgaW4gcmVmIGxpc3Q6ICVzIgogbXNnc3RyICJVbmfDvGx0aWdlIEFudHdvcnQgaW4gUmVmZXJlbnpsaXN0ZTogJXMiCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxMjQ0CisjOiB0cmFuc3BvcnQtaGVscGVyLmM6MTI3MAogIywgYy1mb3JtYXQKIG1zZ2lkICJyZWFkKCVzKSBmYWlsZWQiCiBtc2dzdHIgIkxlc2VuIHZvbiAlcyBmZWhsZ2VzY2hsYWdlbi4iCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxMjcxCisjOiB0cmFuc3BvcnQtaGVscGVyLmM6MTI5NwogIywgYy1mb3JtYXQKIG1zZ2lkICJ3cml0ZSglcykgZmFpbGVkIgogbXNnc3RyICJTY2hyZWliZW4gdm9uICVzIGZlaGxnZXNjaGxhZ2VuLiIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjEzMjAKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxMzQ2CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIHRocmVhZCBmYWlsZWQiCiBtc2dzdHIgIlRocmVhZCAlcyBmZWhsZ2VzY2hsYWdlbi4iCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxMzI0CisjOiB0cmFuc3BvcnQtaGVscGVyLmM6MTM1MAogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyB0aHJlYWQgZmFpbGVkIHRvIGpvaW46ICVzIgogbXNnc3RyICJGZWhsZXIgYmVpbSBCZWl0cmV0ZW4genUgVGhyZWFkICVzOiAlcyIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjEzNDMgdHJhbnNwb3J0LWhlbHBlci5jOjEzNDcKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxMzY5IHRyYW5zcG9ydC1oZWxwZXIuYzoxMzczCiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbid0IHN0YXJ0IHRocmVhZCBmb3IgY29weWluZyBkYXRhOiAlcyIKIG1zZ3N0ciAiS2FubiBUaHJlYWQgenVtIEtvcGllcmVuIHZvbiBEYXRlbiBuaWNodCBzdGFydGVuOiAlcyIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjEzODQKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxNDEwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIHByb2Nlc3MgZmFpbGVkIHRvIHdhaXQiCiBtc2dzdHIgIkZlaGxlciBiZWltIFdhcnRlbiB2b24gUHJvemVzcyAlcy4iCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxMzg4CisjOiB0cmFuc3BvcnQtaGVscGVyLmM6MTQxNAogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyBwcm9jZXNzIGZhaWxlZCIKIG1zZ3N0ciAiUHJvemVzcyAlcyBmZWhsZ2VzY2hsYWdlbiIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjE0MDYgdHJhbnNwb3J0LWhlbHBlci5jOjE0MTUKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxNDMyIHRyYW5zcG9ydC1oZWxwZXIuYzoxNDQxCiBtc2dpZCAiY2FuJ3Qgc3RhcnQgdGhyZWFkIGZvciBjb3B5aW5nIGRhdGEiCiBtc2dzdHIgIkthbm4gVGhyZWFkIHp1bSBLb3BpZXJlbiB2b24gRGF0ZW4gbmljaHQgc3RhcnRlbi4iCiAKQEAgLTc3MTcsNyArNzc0Nyw3IEBACiBtc2dpZCAidG9vLXNob3J0IHRyZWUgZmlsZSIKIG1zZ3N0ciAienUga3VyemUgVHJlZS1EYXRlaSIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTExCisjOiB1bnBhY2stdHJlZXMuYzoxMTAKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIllvdXIgbG9jYWwgY2hhbmdlcyB0byB0aGUgZm9sbG93aW5nIGZpbGVzIHdvdWxkIGJlIG92ZXJ3cml0dGVuIGJ5IGNoZWNrb3V0OlxuIgpAQCAtNzcyOCw3ICs3NzU4LDcgQEAKICIlJXNCaXR0ZSBjb21taXR0ZW4gb2RlciBzdGFzaGVuIFNpZSBJaHJlIMOEbmRlcnVuZ2VuLCBiZXZvciBTaWUgQnJhbmNoZXNcbiIKICJ3ZWNoc2Vsbi4iCiAKLSM6IHVucGFjay10cmVlcy5jOjExMworIzogdW5wYWNrLXRyZWVzLmM6MTEyCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJZb3VyIGxvY2FsIGNoYW5nZXMgdG8gdGhlIGZvbGxvd2luZyBmaWxlcyB3b3VsZCBiZSBvdmVyd3JpdHRlbiBieSBjaGVja291dDpcbiIKQEAgLTc3MzgsNyArNzc2OCw3IEBACiAiw7xiZXJzY2hyaWViZW4gd2VyZGVuOlxuIgogIiUlcyIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTE2CisjOiB1bnBhY2stdHJlZXMuYzoxMTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIllvdXIgbG9jYWwgY2hhbmdlcyB0byB0aGUgZm9sbG93aW5nIGZpbGVzIHdvdWxkIGJlIG92ZXJ3cml0dGVuIGJ5IG1lcmdlOlxuIgpAQCAtNzc0OCw3ICs3Nzc4LDcgQEAKICLDvGJlcnNjaHJpZWJlbiB3ZXJkZW46XG4iCiAiJSVzQml0dGUgY29tbWl0dGVuIG9kZXIgc3Rhc2hlbiBTaWUgSWhyZSDDhG5kZXJ1bmdlbiwgYmV2b3IgU2llIG1lcmdlbi4iCiAKLSM6IHVucGFjay10cmVlcy5jOjExOAorIzogdW5wYWNrLXRyZWVzLmM6MTE3CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJZb3VyIGxvY2FsIGNoYW5nZXMgdG8gdGhlIGZvbGxvd2luZyBmaWxlcyB3b3VsZCBiZSBvdmVyd3JpdHRlbiBieSBtZXJnZTpcbiIKQEAgLTc3NTgsNyArNzc4OCw3IEBACiAiw7xiZXJzY2hyaWViZW4gd2VyZGVuOlxuIgogIiUlcyIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTIxCisjOiB1bnBhY2stdHJlZXMuYzoxMjAKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIllvdXIgbG9jYWwgY2hhbmdlcyB0byB0aGUgZm9sbG93aW5nIGZpbGVzIHdvdWxkIGJlIG92ZXJ3cml0dGVuIGJ5ICVzOlxuIgpAQCAtNzc2OCw3ICs3Nzk4LDcgQEAKICLDvGJlcnNjaHJpZWJlbiB3ZXJkZW46XG4iCiAiJSVzQml0dGUgY29tbWl0dGVuIG9kZXIgc3Rhc2hlbiBTaWUgSWhyZSDDhG5kZXJ1bmdlbiwgYmV2b3IgU2llICVzIGF1c2bDvGhyZW4uIgogCi0jOiB1bnBhY2stdHJlZXMuYzoxMjMKKyM6IHVucGFjay10cmVlcy5jOjEyMgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiWW91ciBsb2NhbCBjaGFuZ2VzIHRvIHRoZSBmb2xsb3dpbmcgZmlsZXMgd291bGQgYmUgb3ZlcndyaXR0ZW4gYnkgJXM6XG4iCkBAIC03Nzc3LDcgKzc4MDcsNyBAQAogIklocmUgbG9rYWxlbiDDhG5kZXJ1bmdlbiB3w7xyZGVuIGR1cmNoICVzIMO8YmVyc2NocmllYmVuIHdlcmRlbi5cbiIKICIlJXMiCiAKLSM6IHVucGFjay10cmVlcy5jOjEyOAorIzogdW5wYWNrLXRyZWVzLmM6MTI3CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJVcGRhdGluZyB0aGUgZm9sbG93aW5nIGRpcmVjdG9yaWVzIHdvdWxkIGxvc2UgdW50cmFja2VkIGZpbGVzIGluIHRoZW06XG4iCkBAIC03Nzg3LDcgKzc4MTcsNyBAQAogIkRhdGVpZW4gaW4gZGllc2VuIFZlcnplaWNobmlzc2VuIHZlcmxvcmVuIGdlaGVuOlxuIgogIiVzIgogCi0jOiB1bnBhY2stdHJlZXMuYzoxMzIKKyM6IHVucGFjay10cmVlcy5jOjEzMQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiVGhlIGZvbGxvd2luZyB1bnRyYWNrZWQgd29ya2luZyB0cmVlIGZpbGVzIHdvdWxkIGJlIHJlbW92ZWQgYnkgY2hlY2tvdXQ6XG4iCkBAIC03Nzk3LDcgKzc4MjcsNyBAQAogImRlbiBDaGVja291dCBlbnRmZXJudCB3ZXJkZW46XG4iCiAiJSVzQml0dGUgdmVyc2NoaWViZW4gb2RlciBlbnRmZXJuZW4gU2llIGRpZXNlLCBiZXZvciBTaWUgQnJhbmNoZXMgd2VjaHNlbG4uIgogCi0jOiB1bnBhY2stdHJlZXMuYzoxMzQKKyM6IHVucGFjay10cmVlcy5jOjEzMwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiVGhlIGZvbGxvd2luZyB1bnRyYWNrZWQgd29ya2luZyB0cmVlIGZpbGVzIHdvdWxkIGJlIHJlbW92ZWQgYnkgY2hlY2tvdXQ6XG4iCkBAIC03ODA4LDcgKzc4MzgsNyBAQAogIkNoZWNrb3V0IGVudGZlcm50IHdlcmRlbjpcbiIKICIlJXMiCiAKLSM6IHVucGFjay10cmVlcy5jOjEzNworIzogdW5wYWNrLXRyZWVzLmM6MTM2CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgZm9sbG93aW5nIHVudHJhY2tlZCB3b3JraW5nIHRyZWUgZmlsZXMgd291bGQgYmUgcmVtb3ZlZCBieSBtZXJnZTpcbiIKQEAgLTc4MTgsNyArNzg0OCw3IEBACiAiZGVuIE1lcmdlIGVudGZlcm50IHdlcmRlbjpcbiIKICIlJXNCaXR0ZSB2ZXJzY2hpZWJlbiBvZGVyIGVudGZlcm5lbiBTaWUgZGllc2UsIGJldm9yIHNpZSBtZXJnZW4uIgogCi0jOiB1bnBhY2stdHJlZXMuYzoxMzkKKyM6IHVucGFjay10cmVlcy5jOjEzOAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiVGhlIGZvbGxvd2luZyB1bnRyYWNrZWQgd29ya2luZyB0cmVlIGZpbGVzIHdvdWxkIGJlIHJlbW92ZWQgYnkgbWVyZ2U6XG4iCkBAIC03ODI5LDcgKzc4NTksNyBAQAogIk1lcmdlIGVudGZlcm50IHdlcmRlbjpcbiIKICIlJXMiCiAKLSM6IHVucGFjay10cmVlcy5jOjE0MgorIzogdW5wYWNrLXRyZWVzLmM6MTQxCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgZm9sbG93aW5nIHVudHJhY2tlZCB3b3JraW5nIHRyZWUgZmlsZXMgd291bGQgYmUgcmVtb3ZlZCBieSAlczpcbiIKQEAgLTc4MzksNyArNzg2OSw3IEBACiAiZGVuICVzIGVudGZlcm50IHdlcmRlbjpcbiIKICIlJXNCaXR0ZSB2ZXJzY2hpZWJlbiBvZGVyIGVudGZlcm5lbiBTaWUgZGllc2UsIGJldm9yIHNpZSAlcyBhdXNmw7xocmVuLiIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTQ0CisjOiB1bnBhY2stdHJlZXMuYzoxNDMKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlRoZSBmb2xsb3dpbmcgdW50cmFja2VkIHdvcmtpbmcgdHJlZSBmaWxlcyB3b3VsZCBiZSByZW1vdmVkIGJ5ICVzOlxuIgpAQCAtNzg0OSw3ICs3ODc5LDcgQEAKICJkZW4gJXMgZW50ZmVybnQgd2VyZGVuOlxuIgogIiUlcyIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTUwCisjOiB1bnBhY2stdHJlZXMuYzoxNDkKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlRoZSBmb2xsb3dpbmcgdW50cmFja2VkIHdvcmtpbmcgdHJlZSBmaWxlcyB3b3VsZCBiZSBvdmVyd3JpdHRlbiBieSAiCkBAIC03ODYwLDcgKzc4OTAsNyBAQAogImRlbiBDaGVja291dCDDvGJlcnNjaHJpZWJlbiB3ZXJkZW46XG4iCiAiJSVzQml0dGUgdmVyc2NoaWViZW4gb2RlciBlbnRmZXJuZW4gU2llIGRpZXNlLCBiZXZvciBTaWUgQnJhbmNoZXMgd2VjaHNlbG4uIgogCi0jOiB1bnBhY2stdHJlZXMuYzoxNTIKKyM6IHVucGFjay10cmVlcy5jOjE1MQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiVGhlIGZvbGxvd2luZyB1bnRyYWNrZWQgd29ya2luZyB0cmVlIGZpbGVzIHdvdWxkIGJlIG92ZXJ3cml0dGVuIGJ5ICIKQEAgLTc4NzIsNyArNzkwMiw3IEBACiAiQ2hlY2tvdXQgw7xiZXJzY2hyaWViZW4gd2VyZGVuOlxuIgogIiUlcyIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTU1CisjOiB1bnBhY2stdHJlZXMuYzoxNTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlRoZSBmb2xsb3dpbmcgdW50cmFja2VkIHdvcmtpbmcgdHJlZSBmaWxlcyB3b3VsZCBiZSBvdmVyd3JpdHRlbiBieSBtZXJnZTpcbiIKQEAgLTc4ODIsNyArNzkxMiw3IEBACiAiZGVuIE1lcmdlIMO8YmVyc2NocmllYmVuIHdlcmRlbjpcbiIKICIlJXNCaXR0ZSB2ZXJzY2hpZWJlbiBvZGVyIGVudGZlcm5lbiBTaWUgZGllc2UsIGJldm9yIFNpZSBtZXJnZW4uIgogCi0jOiB1bnBhY2stdHJlZXMuYzoxNTcKKyM6IHVucGFjay10cmVlcy5jOjE1NgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiVGhlIGZvbGxvd2luZyB1bnRyYWNrZWQgd29ya2luZyB0cmVlIGZpbGVzIHdvdWxkIGJlIG92ZXJ3cml0dGVuIGJ5IG1lcmdlOlxuIgpAQCAtNzg5Miw3ICs3OTIyLDcgQEAKICJkZW4gTWVyZ2Ugw7xiZXJzY2hyaWViZW4gd2VyZGVuOlxuIgogIiUlcyIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTYwCisjOiB1bnBhY2stdHJlZXMuYzoxNTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlRoZSBmb2xsb3dpbmcgdW50cmFja2VkIHdvcmtpbmcgdHJlZSBmaWxlcyB3b3VsZCBiZSBvdmVyd3JpdHRlbiBieSAlczpcbiIKQEAgLTc5MDIsNyArNzkzMiw3IEBACiAiZGVuICVzIMO8YmVyc2NocmllYmVuIHdlcmRlbjpcbiIKICIlJXNCaXR0ZSB2ZXJzY2hpZWJlbiBvZGVyIGVudGZlcm5lbiBTaWUgZGllc2UsIGJldm9yIHNpZSAlcyBhdXNmw7xocmVuLiIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTYyCisjOiB1bnBhY2stdHJlZXMuYzoxNjEKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlRoZSBmb2xsb3dpbmcgdW50cmFja2VkIHdvcmtpbmcgdHJlZSBmaWxlcyB3b3VsZCBiZSBvdmVyd3JpdHRlbiBieSAlczpcbiIKQEAgLTc5MTMsMTIgKzc5NDMsMTIgQEAKICIlcyDDvGJlcnNjaHJpZWJlbiB3ZXJkZW46XG4iCiAiJSVzIgogCi0jOiB1bnBhY2stdHJlZXMuYzoxNzAKKyM6IHVucGFjay10cmVlcy5jOjE2OQogIywgYy1mb3JtYXQKIG1zZ2lkICJFbnRyeSAnJXMnIG92ZXJsYXBzIHdpdGggJyVzJy4gIENhbm5vdCBiaW5kLiIKIG1zZ3N0ciAiRWludHJhZyAnJXMnIMO8YmVyc2NobmVpZGV0IHNpY2ggbWl0ICclcycuIEthbm4gbmljaHQgdmVyYmluZGVuLiIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTczCisjOiB1bnBhY2stdHJlZXMuYzoxNzIKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkNhbm5vdCB1cGRhdGUgc3BhcnNlIGNoZWNrb3V0OiB0aGUgZm9sbG93aW5nIGVudHJpZXMgYXJlIG5vdCB1cCB0byBkYXRlOlxuIgpAQCAtNzkyOCw3ICs3OTU4LDcgQEAKICJzaW5kIG5pY2h0IGFrdHVlbGw6XG4iCiAiJXMiCiAKLSM6IHVucGFjay10cmVlcy5jOjE3NQorIzogdW5wYWNrLXRyZWVzLmM6MTc0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgZm9sbG93aW5nIHdvcmtpbmcgdHJlZSBmaWxlcyB3b3VsZCBiZSBvdmVyd3JpdHRlbiBieSBzcGFyc2UgY2hlY2tvdXQgIgpAQCAtNzkzOSw3ICs3OTY5LDcgQEAKICLDvGJlciBlaW5lbiBwYXJ0aWVsbGVuIENoZWNrb3V0IMO8YmVyc2NocmllYmVuIHdlcmRlbjpcbiIKICIlcyIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTc3CisjOiB1bnBhY2stdHJlZXMuYzoxNzYKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlRoZSBmb2xsb3dpbmcgd29ya2luZyB0cmVlIGZpbGVzIHdvdWxkIGJlIHJlbW92ZWQgYnkgc3BhcnNlIGNoZWNrb3V0ICIKQEAgLTc5NTAsNyArNzk4MCw3IEBACiAiw7xiZXIgZWluZW4gcGFydGllbGxlbiBDaGVja291dCBlbnRmZXJudCB3ZXJkZW46XG4iCiAiJXMiCiAKLSM6IHVucGFjay10cmVlcy5jOjE3OQorIzogdW5wYWNrLXRyZWVzLmM6MTc4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJDYW5ub3QgdXBkYXRlIHN1Ym1vZHVsZTpcbiIKQEAgLTc5NTksMTYgKzc5ODksMTYgQEAKICJLYW5uIFN1Ym1vZHVsIG5pY2h0IGFrdHVhbGlzaWVyZW46XG4iCiAiJXMiCiAKLSM6IHVucGFjay10cmVlcy5jOjI1NgorIzogdW5wYWNrLXRyZWVzLmM6MjU1CiAjLCBjLWZvcm1hdAogbXNnaWQgIkFib3J0aW5nXG4iCiBtc2dzdHIgIkFiYnJ1Y2hcbiIKIAotIzogdW5wYWNrLXRyZWVzLmM6MzE4CisjOiB1bnBhY2stdHJlZXMuYzozMTcKIG1zZ2lkICJVcGRhdGluZyBmaWxlcyIKIG1zZ3N0ciAiQWt0dWFsaXNpZXJlIERhdGVpZW4iCiAKLSM6IHVucGFjay10cmVlcy5jOjM1MAorIzogdW5wYWNrLXRyZWVzLmM6MzQ5CiBtc2dpZCAiIgogInRoZSBmb2xsb3dpbmcgcGF0aHMgaGF2ZSBjb2xsaWRlZCAoZS5nLiBjYXNlLXNlbnNpdGl2ZSBwYXRoc1xuIgogIm9uIGEgY2FzZS1pbnNlbnNpdGl2ZSBmaWxlc3lzdGVtKSBhbmQgb25seSBvbmUgZnJvbSB0aGUgc2FtZVxuIgpAQCAtODAwNyw3ICs4MDM3LDcgQEAKIG1zZ2lkICJpbnZhbGlkICcuLicgcGF0aCBzZWdtZW50IgogbXNnc3RyICJ1bmfDvGx0aWdlcyAnLi4nIFBmYWRzZWdtZW50IgogCi0jOiB3b3JrdHJlZS5jOjI1OCBidWlsdGluL2FtLmM6MjA5NQorIzogd29ya3RyZWUuYzoyNTggYnVpbHRpbi9hbS5jOjIwODQKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIHJlYWQgJyVzJyIKIG1zZ3N0ciAiRmVobGVyIGJlaW0gTGVzZW4gdm9uICclcyciCkBAIC04MDM3LDE3ICs4MDY3LDE3IEBACiBtc2dpZCAiJyVzJyBkb2VzIG5vdCBwb2ludCBiYWNrIHRvICclcyciCiBtc2dzdHIgIiclcycgemVpZ3QgbmljaHQgenVyw7xjayBhdWYgJyVzJyIKIAotIzogd3JhcHBlci5jOjIyMyB3cmFwcGVyLmM6MzkzCisjOiB3cmFwcGVyLmM6MTg2IHdyYXBwZXIuYzozNTYKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IG9wZW4gJyVzJyBmb3IgcmVhZGluZyBhbmQgd3JpdGluZyIKIG1zZ3N0ciAiS29ubnRlICclcycgbmljaHQgenVtIExlc2VuIHVuZCBTY2hyZWliZW4gw7ZmZm5lbi4iCiAKLSM6IHdyYXBwZXIuYzo0MjQgd3JhcHBlci5jOjYyNAorIzogd3JhcHBlci5jOjM4NyB3cmFwcGVyLmM6NTg4CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBhY2Nlc3MgJyVzJyIKIG1zZ3N0ciAia29ubnRlIG5pY2h0IGF1ZiAnJXMnIHp1Z3JlaWZlbiIKIAotIzogd3JhcHBlci5jOjYzMgorIzogd3JhcHBlci5jOjU5NgogbXNnaWQgInVuYWJsZSB0byBnZXQgY3VycmVudCB3b3JraW5nIGRpcmVjdG9yeSIKIG1zZ3N0ciAiS29ubnRlIGFrdHVlbGxlcyBBcmJlaXRzdmVyemVpY2huaXMgbmljaHQgYmVrb21tZW4uIgogCkBAIC04NDExLDg3ICs4NDQxLDk2IEBACiAiICAoYWxsZSBLb25mbGlrdGUgYmVob2JlbjogZsO8aHJlbiBTaWUgXCJnaXQgY2hlcnJ5LXBpY2sgLS1jb250aW51ZVwiIGF1cykiCiAKICM6IHd0LXN0YXR1cy5jOjE0MzcKK21zZ2lkICIgICh1c2UgXCJnaXQgY2hlcnJ5LXBpY2sgLS1za2lwXCIgdG8gc2tpcCB0aGlzIHBhdGNoKSIKK21zZ3N0ciAiIgorIiAgKGJlbnV0emVuIFNpZSBcImdpdCBjaGVycnktcGljayAtLXNraXBcIiwgdW0gZGllc2VuIFBhdGNoIGF1c3p1bGFzc2VuKSIKKworIzogd3Qtc3RhdHVzLmM6MTQzOQogbXNnaWQgIiAgKHVzZSBcImdpdCBjaGVycnktcGljayAtLWFib3J0XCIgdG8gY2FuY2VsIHRoZSBjaGVycnktcGljayBvcGVyYXRpb24pIgogbXNnc3RyICIiCiAiICAoYmVudXR6ZW4gU2llIFwiZ2l0IGNoZXJyeS1waWNrIC0tYWJvcnRcIiwgdW0gZGllIENoZXJyeS1QaWNrLU9wZXJhdGlvbiAiCiAiYWJ6dWJyZWNoZW4pIgogCi0jOiB3dC1zdGF0dXMuYzoxNDQ3CisjOiB3dC1zdGF0dXMuYzoxNDQ5CiBtc2dpZCAiUmV2ZXJ0IGN1cnJlbnRseSBpbiBwcm9ncmVzcy4iCiBtc2dzdHIgIlJldmVydCB6dXJ6ZWl0IGltIEdhbmdlLiIKIAotIzogd3Qtc3RhdHVzLmM6MTQ1MAorIzogd3Qtc3RhdHVzLmM6MTQ1MgogIywgYy1mb3JtYXQKIG1zZ2lkICJZb3UgYXJlIGN1cnJlbnRseSByZXZlcnRpbmcgY29tbWl0ICVzLiIKIG1zZ3N0ciAiU2llIHNpbmQgZ2VyYWRlIGJlaW0gUmV2ZXJ0IHZvbiBDb21taXQgJyVzJy4iCiAKLSM6IHd0LXN0YXR1cy5jOjE0NTYKKyM6IHd0LXN0YXR1cy5jOjE0NTgKIG1zZ2lkICIgIChmaXggY29uZmxpY3RzIGFuZCBydW4gXCJnaXQgcmV2ZXJ0IC0tY29udGludWVcIikiCiBtc2dzdHIgIiIKICIgIChiZWhlYmVuIFNpZSBkaWUgS29uZmxpa3RlIHVuZCBmw7xocmVuIFNpZSBkYW5uIFwiZ2l0IHJldmVydCAtLWNvbnRpbnVlXCIgIgogImF1cykiCiAKLSM6IHd0LXN0YXR1cy5jOjE0NTkKKyM6IHd0LXN0YXR1cy5jOjE0NjEKIG1zZ2lkICIgIChydW4gXCJnaXQgcmV2ZXJ0IC0tY29udGludWVcIiB0byBjb250aW51ZSkiCiBtc2dzdHIgIiAgKEbDvGhyZW4gU2llIFwiZ2l0IHJldmVydCAtLWNvbnRpbnVlXCIsIHVtIHdlaXRlcnp1bWFjaGVuKSIKIAotIzogd3Qtc3RhdHVzLmM6MTQ2MgorIzogd3Qtc3RhdHVzLmM6MTQ2NAogbXNnaWQgIiAgKGFsbCBjb25mbGljdHMgZml4ZWQ6IHJ1biBcImdpdCByZXZlcnQgLS1jb250aW51ZVwiKSIKIG1zZ3N0ciAiICAoYWxsZSBLb25mbGlrdGUgYmVob2JlbjogZsO8aHJlbiBTaWUgXCJnaXQgcmV2ZXJ0IC0tY29udGludWVcIiBhdXMpIgogCi0jOiB3dC1zdGF0dXMuYzoxNDY0CisjOiB3dC1zdGF0dXMuYzoxNDY2Cittc2dpZCAiICAodXNlIFwiZ2l0IHJldmVydCAtLXNraXBcIiB0byBza2lwIHRoaXMgcGF0Y2gpIgorbXNnc3RyICIgIChiZW51dHplbiBTaWUgXCJnaXQgcmV2ZXJ0IC0tc2tpcFwiLCB1bSBkaWVzZW4gUGF0Y2ggYXVzenVsYXNzZW4pIgorCisjOiB3dC1zdGF0dXMuYzoxNDY4CiBtc2dpZCAiICAodXNlIFwiZ2l0IHJldmVydCAtLWFib3J0XCIgdG8gY2FuY2VsIHRoZSByZXZlcnQgb3BlcmF0aW9uKSIKIG1zZ3N0ciAiIgogIiAgKGJlbnV0emVuIFNpZSBcImdpdCByZXZlcnQgLS1hYm9ydFwiLCB1bSBkaWUgUmV2ZXJ0LU9wZXJhdGlvbiBhYnp1YnJlY2hlbikiCiAKLSM6IHd0LXN0YXR1cy5jOjE0NzQKKyM6IHd0LXN0YXR1cy5jOjE0NzgKICMsIGMtZm9ybWF0CiBtc2dpZCAiWW91IGFyZSBjdXJyZW50bHkgYmlzZWN0aW5nLCBzdGFydGVkIGZyb20gYnJhbmNoICclcycuIgogbXNnc3RyICJTaWUgc2luZCBnZXJhZGUgYmVpIGVpbmVyIGJpbsOkcmVuIFN1Y2hlLCBnZXN0YXJ0ZXQgdm9uIEJyYW5jaCAnJXMnLiIKIAotIzogd3Qtc3RhdHVzLmM6MTQ3OAorIzogd3Qtc3RhdHVzLmM6MTQ4MgogbXNnaWQgIllvdSBhcmUgY3VycmVudGx5IGJpc2VjdGluZy4iCiBtc2dzdHIgIlNpZSBzaW5kIGdlcmFkZSBiZWkgZWluZXIgYmluw6RyZW4gU3VjaGUuIgogCi0jOiB3dC1zdGF0dXMuYzoxNDgxCisjOiB3dC1zdGF0dXMuYzoxNDg1CiBtc2dpZCAiICAodXNlIFwiZ2l0IGJpc2VjdCByZXNldFwiIHRvIGdldCBiYWNrIHRvIHRoZSBvcmlnaW5hbCBicmFuY2gpIgogbXNnc3RyICIiCiAiICAoYmVudXR6ZW4gU2llIFwiZ2l0IGJpc2VjdCByZXNldFwiLCB1bSB6dW0gdXJzcHLDvG5nbGljaGVuIEJyYW5jaCAiCiAienVyw7xja3p1a2VocmVuKSIKIAotIzogd3Qtc3RhdHVzLmM6MTY5MAorIzogd3Qtc3RhdHVzLmM6MTY5NAogbXNnaWQgIk9uIGJyYW5jaCAiCiBtc2dzdHIgIkF1ZiBCcmFuY2ggIgogCi0jOiB3dC1zdGF0dXMuYzoxNjk3CisjOiB3dC1zdGF0dXMuYzoxNzAxCiBtc2dpZCAiaW50ZXJhY3RpdmUgcmViYXNlIGluIHByb2dyZXNzOyBvbnRvICIKIG1zZ3N0ciAiaW50ZXJha3RpdmVzIFJlYmFzZSBpbSBHYW5nZTsgYXVmICIKIAotIzogd3Qtc3RhdHVzLmM6MTY5OQorIzogd3Qtc3RhdHVzLmM6MTcwMwogbXNnaWQgInJlYmFzZSBpbiBwcm9ncmVzczsgb250byAiCiBtc2dzdHIgIlJlYmFzZSBpbSBHYW5nZTsgYXVmICIKIAotIzogd3Qtc3RhdHVzLmM6MTcwOQorIzogd3Qtc3RhdHVzLmM6MTcxMwogbXNnaWQgIk5vdCBjdXJyZW50bHkgb24gYW55IGJyYW5jaC4iCiBtc2dzdHIgIkltIE1vbWVudCBhdWYga2VpbmVtIEJyYW5jaC4iCiAKLSM6IHd0LXN0YXR1cy5jOjE3MjYKKyM6IHd0LXN0YXR1cy5jOjE3MzAKIG1zZ2lkICJJbml0aWFsIGNvbW1pdCIKIG1zZ3N0ciAiSW5pdGlhbGVyIENvbW1pdCIKIAotIzogd3Qtc3RhdHVzLmM6MTcyNworIzogd3Qtc3RhdHVzLmM6MTczMQogbXNnaWQgIk5vIGNvbW1pdHMgeWV0IgogbXNnc3RyICJOb2NoIGtlaW5lIENvbW1pdHMiCiAKLSM6IHd0LXN0YXR1cy5jOjE3NDEKKyM6IHd0LXN0YXR1cy5jOjE3NDUKIG1zZ2lkICJVbnRyYWNrZWQgZmlsZXMiCiBtc2dzdHIgIlVudmVyc2lvbmllcnRlIERhdGVpZW4iCiAKLSM6IHd0LXN0YXR1cy5jOjE3NDMKKyM6IHd0LXN0YXR1cy5jOjE3NDcKIG1zZ2lkICJJZ25vcmVkIGZpbGVzIgogbXNnc3RyICJJZ25vcmllcnRlIERhdGVpZW4iCiAKLSM6IHd0LXN0YXR1cy5jOjE3NDcKKyM6IHd0LXN0YXR1cy5jOjE3NTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkl0IHRvb2sgJS4yZiBzZWNvbmRzIHRvIGVudW1lcmF0ZSB1bnRyYWNrZWQgZmlsZXMuICdzdGF0dXMgLXVubydcbiIKQEAgLTg1MDIsMzIgKzg1NDEsMzIgQEAKICInc3RhdHVzIC11bm8nIGvDtm5udGUgZGFzIGJlc2NobGV1bmlnZW4sIGFiZXIgU2llIG3DvHNzZW4gZGFyYXVmIGFjaHRlbixcbiIKICJuZXVlIERhdGVpZW4gc2VsYnN0c3TDpG5kaWcgaGluenV6dWbDvGdlbiAoc2llaGUgJ2dpdCBoZWxwIHN0YXR1cycpLiIKIAotIzogd3Qtc3RhdHVzLmM6MTc1MworIzogd3Qtc3RhdHVzLmM6MTc1NwogIywgYy1mb3JtYXQKIG1zZ2lkICJVbnRyYWNrZWQgZmlsZXMgbm90IGxpc3RlZCVzIgogbXNnc3RyICJVbnZlcnNpb25pZXJ0ZSBEYXRlaWVuIG5pY2h0IGF1ZmdlbGlzdGV0JXMiCiAKLSM6IHd0LXN0YXR1cy5jOjE3NTUKKyM6IHd0LXN0YXR1cy5jOjE3NTkKIG1zZ2lkICIgKHVzZSAtdSBvcHRpb24gdG8gc2hvdyB1bnRyYWNrZWQgZmlsZXMpIgogbXNnc3RyICIgKGJlbnV0emVuIFNpZSBkaWUgT3B0aW9uIC11LCB1bSB1bnZlcnNpb25pZXJ0ZSBEYXRlaWVuIGFuenV6ZWlnZW4pIgogCi0jOiB3dC1zdGF0dXMuYzoxNzYxCisjOiB3dC1zdGF0dXMuYzoxNzY1CiBtc2dpZCAiTm8gY2hhbmdlcyIKIG1zZ3N0ciAiS2VpbmUgw4RuZGVydW5nZW4iCiAKLSM6IHd0LXN0YXR1cy5jOjE3NjYKKyM6IHd0LXN0YXR1cy5jOjE3NzAKICMsIGMtZm9ybWF0CiBtc2dpZCAibm8gY2hhbmdlcyBhZGRlZCB0byBjb21taXQgKHVzZSBcImdpdCBhZGRcIiBhbmQvb3IgXCJnaXQgY29tbWl0IC1hXCIpXG4iCiBtc2dzdHIgIiIKICJrZWluZSDDhG5kZXJ1bmdlbiB6dW0gQ29tbWl0IHZvcmdlbWVya3QgKGJlbnV0emVuIFNpZSBcImdpdCBhZGRcIiB1bmQvb2RlciAiCiAiXCJnaXQgY29tbWl0IC1hXCIpXG4iCiAKLSM6IHd0LXN0YXR1cy5jOjE3NjkKKyM6IHd0LXN0YXR1cy5jOjE3NzMKICMsIGMtZm9ybWF0CiBtc2dpZCAibm8gY2hhbmdlcyBhZGRlZCB0byBjb21taXRcbiIKIG1zZ3N0ciAia2VpbmUgw4RuZGVydW5nZW4genVtIENvbW1pdCB2b3JnZW1lcmt0XG4iCiAKLSM6IHd0LXN0YXR1cy5jOjE3NzIKKyM6IHd0LXN0YXR1cy5jOjE3NzYKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIm5vdGhpbmcgYWRkZWQgdG8gY29tbWl0IGJ1dCB1bnRyYWNrZWQgZmlsZXMgcHJlc2VudCAodXNlIFwiZ2l0IGFkZFwiIHRvICIKQEAgLTg1MzYsNzIgKzg1NzUsNzcgQEAKICJuaWNodHMgenVtIENvbW1pdCB2b3JnZW1lcmt0LCBhYmVyIGVzIGdpYnQgdW52ZXJzaW9uaWVydGUgRGF0ZWllblxuIgogIihiZW51dHplbiBTaWUgXCJnaXQgYWRkXCIgenVtIFZlcnNpb25pZXJlbilcbiIKIAotIzogd3Qtc3RhdHVzLmM6MTc3NQorIzogd3Qtc3RhdHVzLmM6MTc3OQogIywgYy1mb3JtYXQKIG1zZ2lkICJub3RoaW5nIGFkZGVkIHRvIGNvbW1pdCBidXQgdW50cmFja2VkIGZpbGVzIHByZXNlbnRcbiIKIG1zZ3N0ciAibmljaHRzIHp1bSBDb21taXQgdm9yZ2VtZXJrdCwgYWJlciBlcyBnaWJ0IHVudmVyc2lvbmllcnRlIERhdGVpZW5cbiIKIAotIzogd3Qtc3RhdHVzLmM6MTc3OAorIzogd3Qtc3RhdHVzLmM6MTc4MgogIywgYy1mb3JtYXQKIG1zZ2lkICJub3RoaW5nIHRvIGNvbW1pdCAoY3JlYXRlL2NvcHkgZmlsZXMgYW5kIHVzZSBcImdpdCBhZGRcIiB0byB0cmFjaylcbiIKIG1zZ3N0ciAiIgogIm5pY2h0cyB6dSBjb21taXR0ZW4gKGVyc3RlbGxlbi9rb3BpZXJlbiBTaWUgRGF0ZWllbiB1bmQgYmVudXR6ZW5cbiIKICJTaWUgXCJnaXQgYWRkXCIgenVtIFZlcnNpb25pZXJlbilcbiIKIAotIzogd3Qtc3RhdHVzLmM6MTc4MSB3dC1zdGF0dXMuYzoxNzg2CisjOiB3dC1zdGF0dXMuYzoxNzg1IHd0LXN0YXR1cy5jOjE3OTAKICMsIGMtZm9ybWF0CiBtc2dpZCAibm90aGluZyB0byBjb21taXRcbiIKIG1zZ3N0ciAibmljaHRzIHp1IGNvbW1pdHRlblxuIgogCi0jOiB3dC1zdGF0dXMuYzoxNzg0CisjOiB3dC1zdGF0dXMuYzoxNzg4CiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vdGhpbmcgdG8gY29tbWl0ICh1c2UgLXUgdG8gc2hvdyB1bnRyYWNrZWQgZmlsZXMpXG4iCiBtc2dzdHIgIiIKICJuaWNodHMgenUgY29tbWl0dGVuIChiZW51dHplbiBTaWUgZGllIE9wdGlvbiAtdSwgdW0gdW52ZXJzaW9uaWVydGUgRGF0ZWllbiAiCiAiYW56dXplaWdlbilcbiIKIAotIzogd3Qtc3RhdHVzLmM6MTc4OAorIzogd3Qtc3RhdHVzLmM6MTc5MgogIywgYy1mb3JtYXQKIG1zZ2lkICJub3RoaW5nIHRvIGNvbW1pdCwgd29ya2luZyB0cmVlIGNsZWFuXG4iCiBtc2dzdHIgIm5pY2h0cyB6dSBjb21taXR0ZW4sIEFyYmVpdHN2ZXJ6ZWljaG5pcyB1bnZlcsOkbmRlcnRcbiIKIAotIzogd3Qtc3RhdHVzLmM6MTkwMQorIzogd3Qtc3RhdHVzLmM6MTkwNQogbXNnaWQgIk5vIGNvbW1pdHMgeWV0IG9uICIKIG1zZ3N0ciAiTm9jaCBrZWluZSBDb21taXRzIGluICIKIAotIzogd3Qtc3RhdHVzLmM6MTkwNQorIzogd3Qtc3RhdHVzLmM6MTkwOQogbXNnaWQgIkhFQUQgKG5vIGJyYW5jaCkiCiBtc2dzdHIgIkhFQUQgKGtlaW4gQnJhbmNoKSIKIAotIzogd3Qtc3RhdHVzLmM6MTkzNgorIzogd3Qtc3RhdHVzLmM6MTk0MAogbXNnaWQgImRpZmZlcmVudCIKIG1zZ3N0ciAidW50ZXJzY2hpZWRsaWNoIgogCi0jOiB3dC1zdGF0dXMuYzoxOTM4IHd0LXN0YXR1cy5jOjE5NDYKKyM6IHd0LXN0YXR1cy5jOjE5NDIgd3Qtc3RhdHVzLmM6MTk1MAogbXNnaWQgImJlaGluZCAiCiBtc2dzdHIgImhpbnRlcmhlciAiCiAKLSM6IHd0LXN0YXR1cy5jOjE5NDEgd3Qtc3RhdHVzLmM6MTk0NAorIzogd3Qtc3RhdHVzLmM6MTk0NSB3dC1zdGF0dXMuYzoxOTQ4CiBtc2dpZCAiYWhlYWQgIgogbXNnc3RyICJ2b3JhdXMgIgogCiAjLiBUUkFOU0xBVE9SUzogdGhlIGFjdGlvbiBpcyBlLmcuICJwdWxsIHdpdGggcmViYXNlIgotIzogd3Qtc3RhdHVzLmM6MjQ2NgorIzogd3Qtc3RhdHVzLmM6MjQ3MAogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgJXM6IFlvdSBoYXZlIHVuc3RhZ2VkIGNoYW5nZXMuIgogbXNnc3RyICIiCiAiJXMgbmljaHQgbcO2Z2xpY2g6IFNpZSBoYWJlbiDDhG5kZXJ1bmdlbiwgZGllIG5pY2h0IHp1bSBDb21taXQgdm9yZ2VtZXJrdCBzaW5kLiIKIAotIzogd3Qtc3RhdHVzLmM6MjQ3MgorIzogd3Qtc3RhdHVzLmM6MjQ3NgogbXNnaWQgImFkZGl0aW9uYWxseSwgeW91ciBpbmRleCBjb250YWlucyB1bmNvbW1pdHRlZCBjaGFuZ2VzLiIKIG1zZ3N0ciAiWnVzw6R0emxpY2ggZW50aMOkbHQgZGllIFN0YWdpbmctQXJlYSBuaWNodCBjb21taXR0ZXRlIMOEbmRlcnVuZ2VuLiIKIAotIzogd3Qtc3RhdHVzLmM6MjQ3NAorIzogd3Qtc3RhdHVzLmM6MjQ3OAogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgJXM6IFlvdXIgaW5kZXggY29udGFpbnMgdW5jb21taXR0ZWQgY2hhbmdlcy4iCiBtc2dzdHIgIiIKICIlcyBuaWNodCBtw7ZnbGljaDogRGllIFN0YWdpbmctQXJlYSBlbnRow6RsdCBuaWNodCBjb21taXR0ZXRlIMOEbmRlcnVuZ2VuLiIKIAorIzogY29tcGF0L3ByZWNvbXBvc2VfdXRmOC5jOjU4IGJ1aWx0aW4vY2xvbmUuYzo0NTIKKyMsIGMtZm9ybWF0Cittc2dpZCAiZmFpbGVkIHRvIHVubGluayAnJXMnIgorbXNnc3RyICJLb25udGUgJyVzJyBuaWNodCBlbnRmZXJuZW4uIgorCiAjOiBidWlsdGluL2FkZC5jOjI1CiBtc2dpZCAiZ2l0IGFkZCBbPG9wdGlvbnM+XSBbLS1dIDxwYXRoc3BlYz4uLi4iCiBtc2dzdHIgImdpdCBhZGQgWzxPcHRpb25lbj5dIFstLV0gPFBmYWRzcGV6aWZpa2F0aW9uPi4uLiIKQEAgLTg2MjUsNyArODY2OSw3IEBACiBtc2dzdHIgIiIKICJOaWNodCB6dW0gQ29tbWl0IHZvcmdlbWVya3RlIMOEbmRlcnVuZ2VuIG5hY2ggQWt0dWFsaXNpZXJ1bmcgZGVyIFN0YWdpbmctQXJlYToiCiAKLSM6IGJ1aWx0aW4vYWRkLmM6MjM0IGJ1aWx0aW4vcmV2LXBhcnNlLmM6ODk2CisjOiBidWlsdGluL2FkZC5jOjIzNCBidWlsdGluL3Jldi1wYXJzZS5jOjg5NwogbXNnaWQgIkNvdWxkIG5vdCByZWFkIHRoZSBpbmRleCIKIG1zZ3N0ciAiS29ubnRlIGRlbiBJbmRleCBuaWNodCBsZXNlbiIKIApAQCAtODY2Miw4ICs4NzA2LDggQEAKICJEaWUgZm9sZ2VuZGVuIFBmYWRlIHdlcmRlbiBkdXJjaCBlaW5lIElocmVyIFwiLmdpdGlnbm9yZVwiIERhdGVpZW4gIgogImlnbm9yaWVydDpcbiIKIAotIzogYnVpbHRpbi9hZGQuYzoyOTAgYnVpbHRpbi9jbGVhbi5jOjkwOSBidWlsdGluL2ZldGNoLmM6MTQ3IGJ1aWx0aW4vbXYuYzoxMjQKLSM6IGJ1aWx0aW4vcHJ1bmUtcGFja2VkLmM6NTYgYnVpbHRpbi9wdWxsLmM6MjIyIGJ1aWx0aW4vcHVzaC5jOjU2MAorIzogYnVpbHRpbi9hZGQuYzoyOTAgYnVpbHRpbi9jbGVhbi5jOjkxMCBidWlsdGluL2ZldGNoLmM6MTYyIGJ1aWx0aW4vbXYuYzoxMjQKKyM6IGJ1aWx0aW4vcHJ1bmUtcGFja2VkLmM6NTYgYnVpbHRpbi9wdWxsLmM6MjIzIGJ1aWx0aW4vcHVzaC5jOjU0NwogIzogYnVpbHRpbi9yZW1vdGUuYzoxMzQ1IGJ1aWx0aW4vcm0uYzoyNDEgYnVpbHRpbi9zZW5kLXBhY2suYzoxNjUKIG1zZ2lkICJkcnkgcnVuIgogbXNnc3RyICJQcm9iZWxhdWYiCkBAIC04NzIxLDcgKzg3NjUsNyBAQAogbXNnaWQgImNoZWNrIGlmIC0gZXZlbiBtaXNzaW5nIC0gZmlsZXMgYXJlIGlnbm9yZWQgaW4gZHJ5IHJ1biIKIG1zZ3N0ciAicHLDvGZlbiBvYiAtIGF1Y2ggZmVobGVuZGUgLSBEYXRlaWVuIGltIFByb2JlbGF1ZiBpZ25vcmllcnQgd2VyZGVuIgogCi0jOiBidWlsdGluL2FkZC5jOjMwOSBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMDEKKyM6IGJ1aWx0aW4vYWRkLmM6MzA5IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAwMgogbXNnaWQgIm92ZXJyaWRlIHRoZSBleGVjdXRhYmxlIGJpdCBvZiB0aGUgbGlzdGVkIGZpbGVzIgogbXNnc3RyICJkYXMgXCJhdXNmw7xocmJhclwiLUJpdCBkZXIgYXVmZ2VsaXN0ZXRlbiBEYXRlaWVuIMO8YmVyc2NocmVpYmVuIgogCkBAIC04ODAxLDEyMCArODg0NSwxMTYgQEAKIG1zZ2lkICJNYXliZSB5b3Ugd2FudGVkIHRvIHNheSAnZ2l0IGFkZCAuJz9cbiIKIG1zZ3N0ciAiTWVpbnRlbiBTaWUgdmllbGxlaWNodCAnZ2l0IGFkZCAuJz9cbiIKIAotIzogYnVpbHRpbi9hbS5jOjM0OAorIzogYnVpbHRpbi9hbS5jOjM0NwogbXNnaWQgImNvdWxkIG5vdCBwYXJzZSBhdXRob3Igc2NyaXB0IgogbXNnc3RyICJrb25udGUgQXV0b3ItU2tyaXB0IG5pY2h0IHBhcnNlbiIKIAotIzogYnVpbHRpbi9hbS5jOjQzMgorIzogYnVpbHRpbi9hbS5jOjQzMQogIywgYy1mb3JtYXQKIG1zZ2lkICInJXMnIHdhcyBkZWxldGVkIGJ5IHRoZSBhcHBseXBhdGNoLW1zZyBob29rIgogbXNnc3RyICInJXMnIHd1cmRlIGR1cmNoIGRlbiBhcHBseXBhdGNoLW1zZyBIb29rIGVudGZlcm50IgogCi0jOiBidWlsdGluL2FtLmM6NDc0CisjOiBidWlsdGluL2FtLmM6NDczCiAjLCBjLWZvcm1hdAogbXNnaWQgIk1hbGZvcm1lZCBpbnB1dCBsaW5lOiAnJXMnLiIKIG1zZ3N0ciAiRmVobGVyaGFmdGUgRWluZ2FiZXplaWxlOiAnJXMnLiIKIAotIzogYnVpbHRpbi9hbS5jOjUxMgorIzogYnVpbHRpbi9hbS5jOjUxMQogIywgYy1mb3JtYXQKIG1zZ2lkICJGYWlsZWQgdG8gY29weSBub3RlcyBmcm9tICclcycgdG8gJyVzJyIKIG1zZ3N0ciAiRmVobGVyIGJlaW0gS29waWVyZW4gZGVyIE5vdGl6ZW4gdm9uICclcycgbmFjaCAnJXMnIgogCi0jOiBidWlsdGluL2FtLmM6NTM4CisjOiBidWlsdGluL2FtLmM6NTM3CiBtc2dpZCAiZnNlZWsgZmFpbGVkIgogbXNnc3RyICJcImZzZWVrXCIgZmVobGdlc2NobGFnZW4iCiAKLSM6IGJ1aWx0aW4vYW0uYzo3MjYKKyM6IGJ1aWx0aW4vYW0uYzo3MjUKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHBhcnNlIHBhdGNoICclcyciCiBtc2dzdHIgImtvbm50ZSBQYXRjaCAnJXMnIG5pY2h0IHBhcnNlbiIKIAotIzogYnVpbHRpbi9hbS5jOjc5MQorIzogYnVpbHRpbi9hbS5jOjc5MAogbXNnaWQgIk9ubHkgb25lIFN0R0lUIHBhdGNoIHNlcmllcyBjYW4gYmUgYXBwbGllZCBhdCBvbmNlIgogbXNnc3RyICJFcyBrYW5uIG51ciBlaW5lIFN0R0lUIFBhdGNoLVNlcmllIGF1ZiBlaW5tYWwgYW5nZXdlbmRldCB3ZXJkZW4uIgogCi0jOiBidWlsdGluL2FtLmM6ODM5CisjOiBidWlsdGluL2FtLmM6ODM4CiBtc2dpZCAiaW52YWxpZCB0aW1lc3RhbXAiCiBtc2dzdHIgInVuZ8O8bHRpZ2VyIFplaXRzdGVtcGVsIgogCi0jOiBidWlsdGluL2FtLmM6ODQ0IGJ1aWx0aW4vYW0uYzo4NTYKKyM6IGJ1aWx0aW4vYW0uYzo4NDMgYnVpbHRpbi9hbS5jOjg1NQogbXNnaWQgImludmFsaWQgRGF0ZSBsaW5lIgogbXNnc3RyICJVbmfDvGx0aWdlIFwiRGF0ZVwiLVplaWxlIgogCi0jOiBidWlsdGluL2FtLmM6ODUxCisjOiBidWlsdGluL2FtLmM6ODUwCiBtc2dpZCAiaW52YWxpZCB0aW1lem9uZSBvZmZzZXQiCiBtc2dzdHIgIlVuZ8O8bHRpZ2VyIE9mZnNldCBpbiBkZXIgWmVpdHpvbmUiCiAKLSM6IGJ1aWx0aW4vYW0uYzo5NDQKKyM6IGJ1aWx0aW4vYW0uYzo5NDMKIG1zZ2lkICJQYXRjaCBmb3JtYXQgZGV0ZWN0aW9uIGZhaWxlZC4iCiBtc2dzdHIgIlBhdGNoLUZvcm1hdGVya2VubnVuZyBmZWhsZ2VzY2hsYWdlbi4iCiAKLSM6IGJ1aWx0aW4vYW0uYzo5NDkgYnVpbHRpbi9jbG9uZS5jOjQwNworIzogYnVpbHRpbi9hbS5jOjk0OCBidWlsdGluL2Nsb25lLmM6NDA2CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBjcmVhdGUgZGlyZWN0b3J5ICclcyciCiBtc2dzdHIgIkZlaGxlciBiZWltIEVyc3RlbGxlbiB2b24gVmVyemVpY2huaXMgJyVzJyIKIAotIzogYnVpbHRpbi9hbS5jOjk1NAorIzogYnVpbHRpbi9hbS5jOjk1MwogbXNnaWQgIkZhaWxlZCB0byBzcGxpdCBwYXRjaGVzLiIKIG1zZ3N0ciAiRmVobGVyIGJlaW0gQXVmdGVpbGVuIGRlciBQYXRjaGVzLiIKIAotIzogYnVpbHRpbi9hbS5jOjEwODQgYnVpbHRpbi9jb21taXQuYzozNzQKLW1zZ2lkICJ1bmFibGUgdG8gd3JpdGUgaW5kZXggZmlsZSIKLW1zZ3N0ciAiS29ubnRlIEluZGV4LURhdGVpIG5pY2h0IHNjaHJlaWJlbi4iCi0KLSM6IGJ1aWx0aW4vYW0uYzoxMDk4CisjOiBidWlsdGluL2FtLmM6MTA4NAogIywgYy1mb3JtYXQKIG1zZ2lkICJXaGVuIHlvdSBoYXZlIHJlc29sdmVkIHRoaXMgcHJvYmxlbSwgcnVuIFwiJXMgLS1jb250aW51ZVwiLiIKIG1zZ3N0ciAiIgogIldlbm4gU2llIGRhcyBQcm9ibGVtIGF1ZmdlbMO2c3QgaGFiZW4sIGbDvGhyZW4gU2llIFwiJXMgLS1jb250aW51ZVwiIGF1cy4iCiAKLSM6IGJ1aWx0aW4vYW0uYzoxMDk5CisjOiBidWlsdGluL2FtLmM6MTA4NQogIywgYy1mb3JtYXQKIG1zZ2lkICJJZiB5b3UgcHJlZmVyIHRvIHNraXAgdGhpcyBwYXRjaCwgcnVuIFwiJXMgLS1za2lwXCIgaW5zdGVhZC4iCiBtc2dzdHIgIiIKICJGYWxscyBTaWUgZGllc2VuIFBhdGNoIGF1c2xhc3NlbiBtw7ZjaHRlbiwgZsO8aHJlbiBTaWUgc3RhdHRkZXNzZW4gXCIlcyAtLXNraXAiCiAiXCIgYXVzLiIKIAotIzogYnVpbHRpbi9hbS5jOjExMDAKKyM6IGJ1aWx0aW4vYW0uYzoxMDg2CiAjLCBjLWZvcm1hdAogbXNnaWQgIlRvIHJlc3RvcmUgdGhlIG9yaWdpbmFsIGJyYW5jaCBhbmQgc3RvcCBwYXRjaGluZywgcnVuIFwiJXMgLS1hYm9ydFwiLiIKIG1zZ3N0ciAiIgogIlVtIGRlbiB1cnNwcsO8bmdsaWNoZW4gQnJhbmNoIHdpZWRlcmhlcnp1c3RlbGxlbiB1bmQgZGllIEFud2VuZHVuZyBkZXIgIgogIlBhdGNoZXMgYWJ6dWJyZWNoZW4sIGbDvGhyZW4gU2llIFwiJXMgLS1hYm9ydFwiIGF1cy4iCiAKLSM6IGJ1aWx0aW4vYW0uYzoxMTgzCisjOiBidWlsdGluL2FtLmM6MTE2OQogbXNnaWQgIlBhdGNoIHNlbnQgd2l0aCBmb3JtYXQ9Zmxvd2VkOyBzcGFjZSBhdCB0aGUgZW5kIG9mIGxpbmVzIG1pZ2h0IGJlIGxvc3QuIgogbXNnc3RyICIiCiAiUGF0Y2ggbWl0IGZvcm1hdD1mbG93ZWQgdmVyc2VuZGV0OyBMZWVyemVpY2hlbiBhbSBFbmRlIHZvbiBaZWlsZW4ga8O2bm50ZSAiCiAidmVybG9yZW4gZ2VoZW4uIgogCi0jOiBidWlsdGluL2FtLmM6MTIxMQorIzogYnVpbHRpbi9hbS5jOjExOTcKIG1zZ2lkICJQYXRjaCBpcyBlbXB0eS4iCiBtc2dzdHIgIlBhdGNoIGlzdCBsZWVyLiIKIAotIzogYnVpbHRpbi9hbS5jOjEyNzcKKyM6IGJ1aWx0aW4vYW0uYzoxMjYyCisjLCBjLWZvcm1hdAorbXNnaWQgIm1pc3NpbmcgYXV0aG9yIGxpbmUgaW4gY29tbWl0ICVzIgorbXNnc3RyICJBdXRvci1aZWlsZSBmZWhsdCBpbiBDb21taXQgJXMiCisKKyM6IGJ1aWx0aW4vYW0uYzoxMjY1CiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgaWRlbnQgbGluZTogJS4qcyIKIG1zZ3N0ciAiVW5nw7xsdGlnZSBJZGVudGlmaWthdGlvbnN6ZWlsZTogJS4qcyIKIAotIzogYnVpbHRpbi9hbS5jOjEyOTkKLSMsIGMtZm9ybWF0Ci1tc2dpZCAidW5hYmxlIHRvIHBhcnNlIGNvbW1pdCAlcyIKLW1zZ3N0ciAiS29ubnRlIENvbW1pdCAnJXMnIG5pY2h0IHBhcnNlbi4iCi0KLSM6IGJ1aWx0aW4vYW0uYzoxNDk2CisjOiBidWlsdGluL2FtLmM6MTQ4NAogbXNnaWQgIlJlcG9zaXRvcnkgbGFja3MgbmVjZXNzYXJ5IGJsb2JzIHRvIGZhbGwgYmFjayBvbiAzLXdheSBtZXJnZS4iCiBtc2dzdHIgIiIKICJEZW0gUmVwb3NpdG9yeSBmZWhsZW4gbm90d2VuZGlnZSBCbG9icyB1bSBhdWYgZWluZW4gMy1XZWdlLU1lcmdlICIKICJ6dXLDvGNrenVmYWxsZW4uIgogCi0jOiBidWlsdGluL2FtLmM6MTQ5OAorIzogYnVpbHRpbi9hbS5jOjE0ODYKIG1zZ2lkICJVc2luZyBpbmRleCBpbmZvIHRvIHJlY29uc3RydWN0IGEgYmFzZSB0cmVlLi4uIgogbXNnc3RyICIiCiAiVmVyd2VuZGUgSW5mb3JtYXRpb25lbiBhdXMgZGVyIFN0YWdpbmctQXJlYSwgdW0gZWluIEJhc2lzdmVyemVpY2huaXMgIgogIm5hY2h6dXN0ZWxsZW4gLi4uIgogCi0jOiBidWlsdGluL2FtLmM6MTUxNworIzogYnVpbHRpbi9hbS5jOjE1MDUKIG1zZ2lkICIiCiAiRGlkIHlvdSBoYW5kIGVkaXQgeW91ciBwYXRjaD9cbiIKICJJdCBkb2VzIG5vdCBhcHBseSB0byBibG9icyByZWNvcmRlZCBpbiBpdHMgaW5kZXguIgpAQCAtODkyMiwyNCArODk2MiwyNCBAQAogIkhhYmVuIFNpZSBkZW4gUGF0Y2ggcGVyIEhhbmQgZWRpdGllcnQ/XG4iCiAiRXIga2FubiBuaWNodCBhdWYgZGllIEJsb2JzIGluIHNlaW5lciAnaW5kZXgnIFplaWxlIGFuZ2V3ZW5kZXQgd2VyZGVuLiIKIAotIzogYnVpbHRpbi9hbS5jOjE1MjMKKyM6IGJ1aWx0aW4vYW0uYzoxNTExCiBtc2dpZCAiRmFsbGluZyBiYWNrIHRvIHBhdGNoaW5nIGJhc2UgYW5kIDMtd2F5IG1lcmdlLi4uIgogbXNnc3RyICJGYWxsZSB6dXLDvGNrIHp1bSBQYXRjaGVuIGRlciBCYXNpcyB1bmQgenVtIDMtV2VnZS1NZXJnZSAuLi4iCiAKLSM6IGJ1aWx0aW4vYW0uYzoxNTQ5CisjOiBidWlsdGluL2FtLmM6MTUzNwogbXNnaWQgIkZhaWxlZCB0byBtZXJnZSBpbiB0aGUgY2hhbmdlcy4iCiBtc2dzdHIgIk1lcmdlIGRlciDDhG5kZXJ1bmdlbiBmZWhsZ2VzY2hsYWdlbi4iCiAKLSM6IGJ1aWx0aW4vYW0uYzoxNTgxCisjOiBidWlsdGluL2FtLmM6MTU2OQogbXNnaWQgImFwcGx5aW5nIHRvIGFuIGVtcHR5IGhpc3RvcnkiCiBtc2dzdHIgImF1ZiBsZWVyZSBIaXN0b3JpZSBhbndlbmRlbiIKIAotIzogYnVpbHRpbi9hbS5jOjE2MjggYnVpbHRpbi9hbS5jOjE2MzIKKyM6IGJ1aWx0aW4vYW0uYzoxNjE2IGJ1aWx0aW4vYW0uYzoxNjIwCiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCByZXN1bWU6ICVzIGRvZXMgbm90IGV4aXN0LiIKIG1zZ3N0ciAiS2FubiBuaWNodCBmb3J0c2V0emVuOiAlcyBleGlzdGllcnQgbmljaHQiCiAKLSM6IGJ1aWx0aW4vYW0uYzoxNjUwCisjOiBidWlsdGluL2FtLmM6MTYzOAogbXNnaWQgIkNvbW1pdCBCb2R5IGlzOiIKIG1zZ3N0ciAiQ29tbWl0LUJlc2NocmVpYnVuZyBpc3Q6IgogCkBAIC04OTQ3LDM3ICs4OTg3LDQxIEBACiAjLiBpbiB5b3VyIHRyYW5zbGF0aW9uLiBUaGUgcHJvZ3JhbSB3aWxsIG9ubHkgYWNjZXB0IEVuZ2xpc2gKICMuIGlucHV0IGF0IHRoaXMgcG9pbnQuCiAjLgotIzogYnVpbHRpbi9hbS5jOjE2NjAKKyM6IGJ1aWx0aW4vYW0uYzoxNjQ4CiAjLCBjLWZvcm1hdAogbXNnaWQgIkFwcGx5PyBbeV1lcy9bbl1vL1tlXWRpdC9bdl1pZXcgcGF0Y2gvW2FdY2NlcHQgYWxsOiAiCiBtc2dzdHIgIkFud2VuZGVuPyBbeV1lcy9bbl1vL1tlXWRpdC9bdl1pZXcgcGF0Y2gvW2FdY2NlcHQgYWxsOiAiCiAKLSM6IGJ1aWx0aW4vYW0uYzoxNzEwCisjOiBidWlsdGluL2FtLmM6MTY5NSBidWlsdGluL2NvbW1pdC5jOjM3NAorbXNnaWQgInVuYWJsZSB0byB3cml0ZSBpbmRleCBmaWxlIgorbXNnc3RyICJLb25udGUgSW5kZXgtRGF0ZWkgbmljaHQgc2NocmVpYmVuLiIKKworIzogYnVpbHRpbi9hbS5jOjE2OTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiRGlydHkgaW5kZXg6IGNhbm5vdCBhcHBseSBwYXRjaGVzIChkaXJ0eTogJXMpIgogbXNnc3RyICJHZcOkbmRlcnRlciBJbmRleDoga2FubiBQYXRjaGVzIG5pY2h0IGFud2VuZGVuIChnZcOkbmRlcnQ6ICVzKSIKIAotIzogYnVpbHRpbi9hbS5jOjE3NTAgYnVpbHRpbi9hbS5jOjE4MTgKKyM6IGJ1aWx0aW4vYW0uYzoxNzM5IGJ1aWx0aW4vYW0uYzoxODA3CiAjLCBjLWZvcm1hdAogbXNnaWQgIkFwcGx5aW5nOiAlLipzIgogbXNnc3RyICJXZW5kZSBhbjogJS4qcyIKIAotIzogYnVpbHRpbi9hbS5jOjE3NjcKKyM6IGJ1aWx0aW4vYW0uYzoxNzU2CiBtc2dpZCAiTm8gY2hhbmdlcyAtLSBQYXRjaCBhbHJlYWR5IGFwcGxpZWQuIgogbXNnc3RyICJLZWluZSDDhG5kZXJ1bmdlbiAtLSBQYXRjaGVzIGJlcmVpdHMgYW5nZXdlbmRldC4iCiAKLSM6IGJ1aWx0aW4vYW0uYzoxNzczCisjOiBidWlsdGluL2FtLmM6MTc2MgogIywgYy1mb3JtYXQKIG1zZ2lkICJQYXRjaCBmYWlsZWQgYXQgJXMgJS4qcyIKIG1zZ3N0ciAiQW53ZW5kdW5nIGRlcyBQYXRjaGVzIGZlaGxnZXNjaGxhZ2VuIGJlaSAlcyAlLipzIgogCi0jOiBidWlsdGluL2FtLmM6MTc3NworIzogYnVpbHRpbi9hbS5jOjE3NjYKIG1zZ2lkICJVc2UgJ2dpdCBhbSAtLXNob3ctY3VycmVudC1wYXRjaCcgdG8gc2VlIHRoZSBmYWlsZWQgcGF0Y2giCiBtc2dzdHIgIiIKICJCZW51dHplbiBTaWUgJ2dpdCBhbSAtLXNob3ctY3VycmVudC1wYXRjaCcsIHVtIGRlblxuIgogImZlaGxnZXNjaGxhZ2VuZW4gUGF0Y2ggenUgc2VoZW4uIgogCi0jOiBidWlsdGluL2FtLmM6MTgyMQorIzogYnVpbHRpbi9hbS5jOjE4MTAKIG1zZ2lkICIiCiAiTm8gY2hhbmdlcyAtIGRpZCB5b3UgZm9yZ2V0IHRvIHVzZSAnZ2l0IGFkZCc/XG4iCiAiSWYgdGhlcmUgaXMgbm90aGluZyBsZWZ0IHRvIHN0YWdlLCBjaGFuY2VzIGFyZSB0aGF0IHNvbWV0aGluZyBlbHNlXG4iCkBAIC04OTg4LDcgKzkwMzIsNyBAQAogImRpZXNlIGJlcmVpdHMgYW5kZXJ3ZWl0aWcgZWluZ2Vmw7xndCB3b3JkZW4gc2VpbjsgU2llIGvDtm5udGVuIGRpZXNlbiBQYXRjaFxuIgogImF1c2xhc3Nlbi4iCiAKLSM6IGJ1aWx0aW4vYW0uYzoxODI4CisjOiBidWlsdGluL2FtLmM6MTgxNwogbXNnaWQgIiIKICJZb3Ugc3RpbGwgaGF2ZSB1bm1lcmdlZCBwYXRocyBpbiB5b3VyIGluZGV4LlxuIgogIllvdSBzaG91bGQgJ2dpdCBhZGQnIGVhY2ggZmlsZSB3aXRoIHJlc29sdmVkIGNvbmZsaWN0cyB0byBtYXJrIHRoZW0gYXMgIgpAQCAtOTAwMSwxNyArOTA0NSwxNyBAQAogIlNpZSBrw7ZubmVuICdnaXQgcm0nIGF1ZiBEYXRlaWVuIGF1c2bDvGhyZW4sIHVtIFwidm9uIGRlbmVuIGdlbMO2c2NodFwiIGbDvHJcbiIKICJkaWVzZSB6dSBha3plcHRpZXJlbi4iCiAKLSM6IGJ1aWx0aW4vYW0uYzoxOTM1IGJ1aWx0aW4vYW0uYzoxOTM5IGJ1aWx0aW4vYW0uYzoxOTUxIGJ1aWx0aW4vcmVzZXQuYzozMjkKKyM6IGJ1aWx0aW4vYW0uYzoxOTI0IGJ1aWx0aW4vYW0uYzoxOTI4IGJ1aWx0aW4vYW0uYzoxOTQwIGJ1aWx0aW4vcmVzZXQuYzozMjkKICM6IGJ1aWx0aW4vcmVzZXQuYzozMzcKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ291bGQgbm90IHBhcnNlIG9iamVjdCAnJXMnLiIKIG1zZ3N0ciAiS29ubnRlIE9iamVrdCAnJXMnIG5pY2h0IHBhcnNlbi4iCiAKLSM6IGJ1aWx0aW4vYW0uYzoxOTg3CisjOiBidWlsdGluL2FtLmM6MTk3NgogbXNnaWQgImZhaWxlZCB0byBjbGVhbiBpbmRleCIKIG1zZ3N0ciAiRmVobGVyIGJlaW0gQmVyZWluaWdlbiBkZXMgSW5kZXgiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMDMxCisjOiBidWlsdGluL2FtLmM6MjAyMAogbXNnaWQgIiIKICJZb3Ugc2VlbSB0byBoYXZlIG1vdmVkIEhFQUQgc2luY2UgdGhlIGxhc3QgJ2FtJyBmYWlsdXJlLlxuIgogIk5vdCByZXdpbmRpbmcgdG8gT1JJR19IRUFEIgpAQCAtOTAxOSwxNDQgKzkwNjMsMTQ0IEBACiAiU2llIHNjaGVpbmVuIHNlaXQgZGVtIGxldHp0ZW4gZ2VzY2hlaXRlcnRlbiAnYW0nIEhFQUQgZ2XDpG5kZXJ0IHp1IGhhYmVuLlxuIgogIktlaW5lIFp1csO8Y2tzZXR6dW5nIHp1IE9SSUdfSEVBRC4iCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMTI4CisjOiBidWlsdGluL2FtLmM6MjExNwogIywgYy1mb3JtYXQKIG1zZ2lkICJJbnZhbGlkIHZhbHVlIGZvciAtLXBhdGNoLWZvcm1hdDogJXMiCiBtc2dzdHIgIlVuZ8O8bHRpZ2VyIFdlcnQgZsO8ciAtLXBhdGNoLWZvcm1hdDogJXMiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMTY0CisjOiBidWlsdGluL2FtLmM6MjE1MwogbXNnaWQgImdpdCBhbSBbPG9wdGlvbnM+XSBbKDxtYm94PiB8IDxNYWlsZGlyPikuLi5dIgogbXNnc3RyICJnaXQgYW0gWzxPcHRpb25lbj5dIFsoPG1ib3g+IHwgPEUtTWFpbC1WZXJ6ZWljaG5pcz4pLi4uXSIKIAotIzogYnVpbHRpbi9hbS5jOjIxNjUKKyM6IGJ1aWx0aW4vYW0uYzoyMTU0CiBtc2dpZCAiZ2l0IGFtIFs8b3B0aW9ucz5dICgtLWNvbnRpbnVlIHwgLS1za2lwIHwgLS1hYm9ydCkiCiBtc2dzdHIgImdpdCBhbSBbPE9wdGlvbmVuPl0gKC0tY29udGludWUgfCAtLXNraXAgfCAtLWFib3J0KSIKIAotIzogYnVpbHRpbi9hbS5jOjIxNzEKKyM6IGJ1aWx0aW4vYW0uYzoyMTYwCiBtc2dpZCAicnVuIGludGVyYWN0aXZlbHkiCiBtc2dzdHIgImludGVyYWt0aXYgYXVzZsO8aHJlbiIKIAotIzogYnVpbHRpbi9hbS5jOjIxNzMKKyM6IGJ1aWx0aW4vYW0uYzoyMTYyCiBtc2dpZCAiaGlzdG9yaWNhbCBvcHRpb24gLS0gbm8tb3AiCiBtc2dzdHIgImhpc3RvcmlzY2hlIE9wdGlvbiAtLSBrZWluIEVmZmVrdCIKIAotIzogYnVpbHRpbi9hbS5jOjIxNzUKKyM6IGJ1aWx0aW4vYW0uYzoyMTY0CiBtc2dpZCAiYWxsb3cgZmFsbCBiYWNrIG9uIDN3YXkgbWVyZ2luZyBpZiBuZWVkZWQiCiBtc2dzdHIgImVybGF1YmUsIGZhbGxzIG5vdHdlbmRpZywgZGFzIFp1csO8Y2tmYWxsZW4gYXVmIGVpbmVuIDMtV2VnZS1NZXJnZSIKIAotIzogYnVpbHRpbi9hbS5jOjIxNzYgYnVpbHRpbi9pbml0LWRiLmM6NDk0IGJ1aWx0aW4vcHJ1bmUtcGFja2VkLmM6NTgKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6Mjk2IGJ1aWx0aW4vc3Rhc2guYzo4MDYKKyM6IGJ1aWx0aW4vYW0uYzoyMTY1IGJ1aWx0aW4vaW5pdC1kYi5jOjQ5NCBidWlsdGluL3BydW5lLXBhY2tlZC5jOjU4CisjOiBidWlsdGluL3JlcGFjay5jOjI5NyBidWlsdGluL3N0YXNoLmM6ODEyCiBtc2dpZCAiYmUgcXVpZXQiCiBtc2dzdHIgIndlbmlnZXIgQXVzZ2FiZW4iCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMTc4CisjOiBidWlsdGluL2FtLmM6MjE2NwogbXNnaWQgImFkZCBhIFNpZ25lZC1vZmYtYnkgbGluZSB0byB0aGUgY29tbWl0IG1lc3NhZ2UiCiBtc2dzdHIgImRlciBDb21taXQtQmVzY2hyZWlidW5nIGVpbmUgU2lnbmVkLW9mZi1ieSBaZWlsZSBoaW56dWbDvGdlbiIKIAotIzogYnVpbHRpbi9hbS5jOjIxODEKKyM6IGJ1aWx0aW4vYW0uYzoyMTcwCiBtc2dpZCAicmVjb2RlIGludG8gdXRmOCAoZGVmYXVsdCkiCiBtc2dzdHIgIm5hY2ggVVRGLTggdW1rb2RpZXJlbiAoU3RhbmRhcmQpIgogCi0jOiBidWlsdGluL2FtLmM6MjE4MworIzogYnVpbHRpbi9hbS5jOjIxNzIKIG1zZ2lkICJwYXNzIC1rIGZsYWcgdG8gZ2l0LW1haWxpbmZvIgogbXNnc3RyICItayBhbiBnaXQtbWFpbGluZm8gw7xiZXJnZWJlbiIKIAotIzogYnVpbHRpbi9hbS5jOjIxODUKKyM6IGJ1aWx0aW4vYW0uYzoyMTc0CiBtc2dpZCAicGFzcyAtYiBmbGFnIHRvIGdpdC1tYWlsaW5mbyIKIG1zZ3N0ciAiLWIgYW4gZ2l0LW1haWxpbmZvIMO8YmVyZ2ViZW4iCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMTg3CisjOiBidWlsdGluL2FtLmM6MjE3NgogbXNnaWQgInBhc3MgLW0gZmxhZyB0byBnaXQtbWFpbGluZm8iCiBtc2dzdHIgIi1tIGFuIGdpdC1tYWlsaW5mbyDDvGJlcmdlYmVuIgogCi0jOiBidWlsdGluL2FtLmM6MjE4OQorIzogYnVpbHRpbi9hbS5jOjIxNzgKIG1zZ2lkICJwYXNzIC0ta2VlcC1jciBmbGFnIHRvIGdpdC1tYWlsc3BsaXQgZm9yIG1ib3ggZm9ybWF0IgogbXNnc3RyICItLWtlZXAtY3IgYW4gZ2l0LW1haWxzcGxpdCBmw7xyIG1ib3gtRm9ybWF0IMO8YmVyZ2ViZW4iCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMTkyCisjOiBidWlsdGluL2FtLmM6MjE4MQogbXNnaWQgImRvIG5vdCBwYXNzIC0ta2VlcC1jciBmbGFnIHRvIGdpdC1tYWlsc3BsaXQgaW5kZXBlbmRlbnQgb2YgYW0ua2VlcGNyIgogbXNnc3RyICJrZWluIC0ta2VlcC1jciBhbiBnaXQtbWFpbHNwbGl0IMO8YmVyZ2ViZW4sIHVuYWJow6RuZ2lnIHZvbiBhbS5rZWVwY3IiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMTk1CisjOiBidWlsdGluL2FtLmM6MjE4NAogbXNnaWQgInN0cmlwIGV2ZXJ5dGhpbmcgYmVmb3JlIGEgc2Npc3NvcnMgbGluZSIKIG1zZ3N0ciAiYWxsZXMgdm9yIGVpbmVyIFNjaGVyZW4tWmVpbGUgZW50ZmVybmVuIgogCi0jOiBidWlsdGluL2FtLmM6MjE5NyBidWlsdGluL2FtLmM6MjIwMCBidWlsdGluL2FtLmM6MjIwMyBidWlsdGluL2FtLmM6MjIwNgotIzogYnVpbHRpbi9hbS5jOjIyMDkgYnVpbHRpbi9hbS5jOjIyMTIgYnVpbHRpbi9hbS5jOjIyMTUgYnVpbHRpbi9hbS5jOjIyMTgKLSM6IGJ1aWx0aW4vYW0uYzoyMjI0CisjOiBidWlsdGluL2FtLmM6MjE4NiBidWlsdGluL2FtLmM6MjE4OSBidWlsdGluL2FtLmM6MjE5MiBidWlsdGluL2FtLmM6MjE5NQorIzogYnVpbHRpbi9hbS5jOjIxOTggYnVpbHRpbi9hbS5jOjIyMDEgYnVpbHRpbi9hbS5jOjIyMDQgYnVpbHRpbi9hbS5jOjIyMDcKKyM6IGJ1aWx0aW4vYW0uYzoyMjEzCiBtc2dpZCAicGFzcyBpdCB0aHJvdWdoIGdpdC1hcHBseSIKIG1zZ3N0ciAiYW4gZ2l0LWFwcGx5IMO8YmVyZ2ViZW4iCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMjE0IGJ1aWx0aW4vY29tbWl0LmM6MTM2OCBidWlsdGluL2ZtdC1tZXJnZS1tc2cuYzo2NzEKLSM6IGJ1aWx0aW4vZm10LW1lcmdlLW1zZy5jOjY3NCBidWlsdGluL2dyZXAuYzo4ODEgYnVpbHRpbi9tZXJnZS5jOjI0OQotIzogYnVpbHRpbi9wdWxsLmM6MTU5IGJ1aWx0aW4vcHVsbC5jOjIxOCBidWlsdGluL3JlYmFzZS5jOjE0MTgKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MzA3IGJ1aWx0aW4vcmVwYWNrLmM6MzExIGJ1aWx0aW4vcmVwYWNrLmM6MzEzCisjOiBidWlsdGluL2FtLmM6MjIwMyBidWlsdGluL2NvbW1pdC5jOjEzNjggYnVpbHRpbi9mbXQtbWVyZ2UtbXNnLmM6NjcxCisjOiBidWlsdGluL2ZtdC1tZXJnZS1tc2cuYzo2NzQgYnVpbHRpbi9ncmVwLmM6ODgzIGJ1aWx0aW4vbWVyZ2UuYzoyNDkKKyM6IGJ1aWx0aW4vcHVsbC5jOjE2MCBidWlsdGluL3B1bGwuYzoyMTkgYnVpbHRpbi9yZWJhc2UuYzoxNDQyCisjOiBidWlsdGluL3JlcGFjay5jOjMwOCBidWlsdGluL3JlcGFjay5jOjMxMiBidWlsdGluL3JlcGFjay5jOjMxNAogIzogYnVpbHRpbi9zaG93LWJyYW5jaC5jOjY1MCBidWlsdGluL3Nob3ctcmVmLmM6MTcyIGJ1aWx0aW4vdGFnLmM6NDAzCi0jOiBwYXJzZS1vcHRpb25zLmg6MTQxIHBhcnNlLW9wdGlvbnMuaDoxNjIgcGFyc2Utb3B0aW9ucy5oOjMxMgorIzogcGFyc2Utb3B0aW9ucy5oOjE1MCBwYXJzZS1vcHRpb25zLmg6MTcxIHBhcnNlLW9wdGlvbnMuaDozMTIKIG1zZ2lkICJuIgogbXNnc3RyICJBbnphaGwiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMjIwIGJ1aWx0aW4vYnJhbmNoLmM6NjYxIGJ1aWx0aW4vZm9yLWVhY2gtcmVmLmM6MzgKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU1NCBidWlsdGluL3RhZy5jOjQzNyBidWlsdGluL3ZlcmlmeS10YWcuYzozOAorIzogYnVpbHRpbi9hbS5jOjIyMDkgYnVpbHRpbi9icmFuY2guYzo2NjEgYnVpbHRpbi9mb3ItZWFjaC1yZWYuYzozOAorIzogYnVpbHRpbi9yZXBsYWNlLmM6NTU1IGJ1aWx0aW4vdGFnLmM6NDM3IGJ1aWx0aW4vdmVyaWZ5LXRhZy5jOjM4CiBtc2dpZCAiZm9ybWF0IgogbXNnc3RyICJGb3JtYXQiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMjIxCisjOiBidWlsdGluL2FtLmM6MjIxMAogbXNnaWQgImZvcm1hdCB0aGUgcGF0Y2goZXMpIGFyZSBpbiIKIG1zZ3N0ciAiUGF0Y2gtRm9ybWF0IgogCi0jOiBidWlsdGluL2FtLmM6MjIyNworIzogYnVpbHRpbi9hbS5jOjIyMTYKIG1zZ2lkICJvdmVycmlkZSBlcnJvciBtZXNzYWdlIHdoZW4gcGF0Y2ggZmFpbHVyZSBvY2N1cnMiCiBtc2dzdHIgIk1lbGR1bmcgYmVpIGZlaGxlcmhhZnRlciBQYXRjaC1BbndlbmR1bmcgw7xiZXJzY2hyZWliZW4iCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMjI5CisjOiBidWlsdGluL2FtLmM6MjIxOAogbXNnaWQgImNvbnRpbnVlIGFwcGx5aW5nIHBhdGNoZXMgYWZ0ZXIgcmVzb2x2aW5nIGEgY29uZmxpY3QiCiBtc2dzdHIgIkFud2VuZHVuZyBkZXIgUGF0Y2hlcyBuYWNoIEF1ZmzDtnN1bmcgZWluZXMgS29uZmxpa3RlcyBmb3J0c2V0emVuIgogCi0jOiBidWlsdGluL2FtLmM6MjIzMgorIzogYnVpbHRpbi9hbS5jOjIyMjEKIG1zZ2lkICJzeW5vbnltcyBmb3IgLS1jb250aW51ZSIKIG1zZ3N0ciAiU3lub255bWUgZsO8ciAtLWNvbnRpbnVlIgogCi0jOiBidWlsdGluL2FtLmM6MjIzNQorIzogYnVpbHRpbi9hbS5jOjIyMjQKIG1zZ2lkICJza2lwIHRoZSBjdXJyZW50IHBhdGNoIgogbXNnc3RyICJkZW4gYWt0dWVsbGVuIFBhdGNoIGF1c2xhc3NlbiIKIAotIzogYnVpbHRpbi9hbS5jOjIyMzgKKyM6IGJ1aWx0aW4vYW0uYzoyMjI3CiBtc2dpZCAicmVzdG9yZSB0aGUgb3JpZ2luYWwgYnJhbmNoIGFuZCBhYm9ydCB0aGUgcGF0Y2hpbmcgb3BlcmF0aW9uLiIKIG1zZ3N0ciAiIgogInVyc3Byw7xuZ2xpY2hlbiBCcmFuY2ggd2llZGVyaGVyc3RlbGxlbiB1bmQgQW53ZW5kdW5nIGRlciBQYXRjaGVzIGFiYnJlY2hlbiIKIAotIzogYnVpbHRpbi9hbS5jOjIyNDEKKyM6IGJ1aWx0aW4vYW0uYzoyMjMwCiBtc2dpZCAiYWJvcnQgdGhlIHBhdGNoaW5nIG9wZXJhdGlvbiBidXQga2VlcCBIRUFEIHdoZXJlIGl0IGlzLiIKIG1zZ3N0ciAiUGF0Y2gtT3BlcmF0aW9uIGFiYnJlY2hlbiwgYWJlciBIRUFEIGFuIGFrdHVlbGxlciBTdGVsbGUgYmVsYXNzZW4iCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMjQ0CisjOiBidWlsdGluL2FtLmM6MjIzMwogbXNnaWQgInNob3cgdGhlIHBhdGNoIGJlaW5nIGFwcGxpZWQuIgogbXNnc3RyICJkZW4gUGF0Y2gsIGRlciBnZXJhZGUgYW5nZXdlbmRldCB3aXJkLCBhbnplaWdlbiIKIAotIzogYnVpbHRpbi9hbS5jOjIyNDgKKyM6IGJ1aWx0aW4vYW0uYzoyMjM3CiBtc2dpZCAibGllIGFib3V0IGNvbW1pdHRlciBkYXRlIgogbXNnc3RyICJBdXRvci1EYXR1bSBhbHMgQ29tbWl0LURhdHVtIHZlcndlbmRlbiIKIAotIzogYnVpbHRpbi9hbS5jOjIyNTAKKyM6IGJ1aWx0aW4vYW0uYzoyMjM5CiBtc2dpZCAidXNlIGN1cnJlbnQgdGltZXN0YW1wIGZvciBhdXRob3IgZGF0ZSIKIG1zZ3N0ciAiYWt0dWVsbGVuIFplaXRzdGVtcGVsIGFscyBBdXRvci1EYXR1bSB2ZXJ3ZW5kZW4iCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMjUyIGJ1aWx0aW4vY29tbWl0LXRyZWUuYzoxMjAgYnVpbHRpbi9jb21taXQuYzoxNTExCi0jOiBidWlsdGluL21lcmdlLmM6Mjg2IGJ1aWx0aW4vcHVsbC5jOjE5MyBidWlsdGluL3JlYmFzZS5jOjQ4OQotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDU5IGJ1aWx0aW4vcmV2ZXJ0LmM6MTE3IGJ1aWx0aW4vdGFnLmM6NDE4CisjOiBidWlsdGluL2FtLmM6MjI0MSBidWlsdGluL2NvbW1pdC10cmVlLmM6MTIwIGJ1aWx0aW4vY29tbWl0LmM6MTUxMQorIzogYnVpbHRpbi9tZXJnZS5jOjI4NiBidWlsdGluL3B1bGwuYzoxOTQgYnVpbHRpbi9yZWJhc2UuYzo0OTAKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ4MyBidWlsdGluL3JldmVydC5jOjExNyBidWlsdGluL3RhZy5jOjQxOAogbXNnaWQgImtleS1pZCIKIG1zZ3N0ciAiR1BHLVNjaGzDvHNzZWxrZW5udW5nIgogCi0jOiBidWlsdGluL2FtLmM6MjI1MyBidWlsdGluL3JlYmFzZS5jOjQ5MCBidWlsdGluL3JlYmFzZS5jOjE0NjAKKyM6IGJ1aWx0aW4vYW0uYzoyMjQyIGJ1aWx0aW4vcmViYXNlLmM6NDkxIGJ1aWx0aW4vcmViYXNlLmM6MTQ4NAogbXNnaWQgIkdQRy1zaWduIGNvbW1pdHMiCiBtc2dzdHIgIkNvbW1pdHMgbWl0IEdQRyBzaWduaWVyZW4iCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMjU2CisjOiBidWlsdGluL2FtLmM6MjI0NQogbXNnaWQgIihpbnRlcm5hbCB1c2UgZm9yIGdpdC1yZWJhc2UpIgogbXNnc3RyICIoaW50ZXJuIGbDvHIgZ2l0LXJlYmFzZSB2ZXJ3ZW5kZXQpIgogCi0jOiBidWlsdGluL2FtLmM6MjI3NAorIzogYnVpbHRpbi9hbS5jOjIyNjMKIG1zZ2lkICIiCiAiVGhlIC1iLy0tYmluYXJ5IG9wdGlvbiBoYXMgYmVlbiBhIG5vLW9wIGZvciBsb25nIHRpbWUsIGFuZFxuIgogIml0IHdpbGwgYmUgcmVtb3ZlZC4gUGxlYXNlIGRvIG5vdCB1c2UgaXQgYW55bW9yZS4iCkBAIC05MTY0LDE2ICs5MjA4LDE2IEBACiAiRGllIC1iLy0tYmluYXJ5IE9wdGlvbiBoYXQgc2VpdCBMYW5nZW0ga2VpbmVuIEVmZmVrdCB1bmQgd2lyZFxuIgogImVudGZlcm50LiBCaXR0ZSB2ZXJ3ZW5kZW4gU2llIGRpZXNlIG5pY2h0IG1laHIuIgogCi0jOiBidWlsdGluL2FtLmM6MjI4MQorIzogYnVpbHRpbi9hbS5jOjIyNzAKIG1zZ2lkICJmYWlsZWQgdG8gcmVhZCB0aGUgaW5kZXgiCiBtc2dzdHIgIkZlaGxlciBiZWltIExlc2VuIGRlcyBJbmRleCIKIAotIzogYnVpbHRpbi9hbS5jOjIyOTYKKyM6IGJ1aWx0aW4vYW0uYzoyMjg1CiAjLCBjLWZvcm1hdAogbXNnaWQgInByZXZpb3VzIHJlYmFzZSBkaXJlY3RvcnkgJXMgc3RpbGwgZXhpc3RzIGJ1dCBtYm94IGdpdmVuLiIKIG1zZ3N0ciAiVm9yaGVyaWdlcyBSZWJhc2UtVmVyemVpY2huaXMgJXMgZXhpc3RpZXJ0IG5vY2gsIGFiZXIgbWJveCBnZWdlYmVuLiIKIAotIzogYnVpbHRpbi9hbS5jOjIzMjAKKyM6IGJ1aWx0aW4vYW0uYzoyMzA5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJTdHJheSAlcyBkaXJlY3RvcnkgZm91bmQuXG4iCkBAIC05MTgyLDExICs5MjI2LDExIEBACiAiU3RyYXkgJXMgVmVyemVpY2huaXMgZ2VmdW5kZW4uXG4iCiAiQmVudXR6ZW4gU2llIFwiZ2l0IGFtIC0tYWJvcnRcIiwgdW0gZXMgenUgZW50ZmVybmVuLiIKIAotIzogYnVpbHRpbi9hbS5jOjIzMjYKKyM6IGJ1aWx0aW4vYW0uYzoyMzE1CiBtc2dpZCAiUmVzb2x2ZSBvcGVyYXRpb24gbm90IGluIHByb2dyZXNzLCB3ZSBhcmUgbm90IHJlc3VtaW5nLiIKIG1zZ3N0ciAiRXMgaXN0IGtlaW5lIEF1ZmzDtnN1bmcgaW0gR2FuZ2UsIGVzIHdpcmQgbmljaHQgZm9ydGdlc2V0enQuIgogCi0jOiBidWlsdGluL2FtLmM6MjMzNgorIzogYnVpbHRpbi9hbS5jOjIzMjUKIG1zZ2lkICJpbnRlcmFjdGl2ZSBtb2RlIHJlcXVpcmVzIHBhdGNoZXMgb24gdGhlIGNvbW1hbmQgbGluZSIKIG1zZ3N0ciAiSW50ZXJha3RpdmVyIE1vZHVzIGJlbsO2dGlndCBQYXRjaGVzIMO8YmVyIGRpZSBLb21tYW5kb3plaWxlIgogCkBAIC05NTA1LDE1OSArOTU0OSwxNTkgQEAKIG1zZ2lkICItLWJpc2VjdC10ZXJtcyByZXF1aXJlcyAwIG9yIDEgYXJndW1lbnQiCiBtc2dzdHIgIi0tYmlzZWN0LXRlcm1zIGJlbsO2dGlndCAwIG9kZXIgMSBBcmd1bWVudC4iCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzozMgorIzogYnVpbHRpbi9ibGFtZS5jOjMxCiBtc2dpZCAiZ2l0IGJsYW1lIFs8b3B0aW9ucz5dIFs8cmV2LW9wdHM+XSBbPHJldj5dIFstLV0gPGZpbGU+IgogbXNnc3RyICJnaXQgYmxhbWUgWzxPcHRpb25lbj5dIFs8cmV2LW9wdHM+XSBbPENvbW1pdD5dIFstLV0gPERhdGVpPiIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjM3CisjOiBidWlsdGluL2JsYW1lLmM6MzYKIG1zZ2lkICI8cmV2LW9wdHM+IGFyZSBkb2N1bWVudGVkIGluIGdpdC1yZXYtbGlzdCgxKSIKIG1zZ3N0ciAiPHJldi1vcHRzPiBzaW5kIGRva3VtZW50aWVydCBpbiBnaXQtcmV2LWxpc3QoMSkiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo0MTAKKyM6IGJ1aWx0aW4vYmxhbWUuYzo0MDkKICMsIGMtZm9ybWF0CiBtc2dpZCAiZXhwZWN0aW5nIGEgY29sb3I6ICVzIgogbXNnc3RyICJFcndhcnRlIGVpbmUgRmFyYmU6ICVzIgogCi0jOiBidWlsdGluL2JsYW1lLmM6NDE3CisjOiBidWlsdGluL2JsYW1lLmM6NDE2CiBtc2dpZCAibXVzdCBlbmQgd2l0aCBhIGNvbG9yIgogbXNnc3RyICJNdXNzIG1pdCBlaW5lciBGYXJiZSBlbmRlbi4iCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo3MzAKKyM6IGJ1aWx0aW4vYmxhbWUuYzo3MjkKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBjb2xvciAnJXMnIGluIGNvbG9yLmJsYW1lLnJlcGVhdGVkTGluZXMiCiBtc2dzdHIgIlVuZ8O8bHRpZ2UgRmFyYmUgJyVzJyBpbiBjb2xvci5ibGFtZS5yZXBlYXRlZExpbmVzLiIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjc0OAorIzogYnVpbHRpbi9ibGFtZS5jOjc0NwogbXNnaWQgImludmFsaWQgdmFsdWUgZm9yIGJsYW1lLmNvbG9yaW5nIgogbXNnc3RyICJVbmfDvGx0aWdlciBXZXJ0IGbDvHIgYmxhbWUuY29sb3JpbmcuIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODIzCisjOiBidWlsdGluL2JsYW1lLmM6ODIyCiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCBmaW5kIHJldmlzaW9uICVzIHRvIGlnbm9yZSIKIG1zZ3N0ciAiS29ubnRlIENvbW1pdCAlcyB6dW0gSWdub3JpZXJlbiBuaWNodCBmaW5kZW4iCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NDUKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NDQKIG1zZ2lkICJTaG93IGJsYW1lIGVudHJpZXMgYXMgd2UgZmluZCB0aGVtLCBpbmNyZW1lbnRhbGx5IgogbXNnc3RyICJcImJsYW1lXCItRWludHLDpGdlIHNjaHJpdHR3ZWlzZSBhbnplaWdlbiwgd8OkaHJlbmQgd2lyIHNpZSBnZW5lcmllcmVuIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODQ2CisjOiBidWlsdGluL2JsYW1lLmM6ODQ1CiBtc2dpZCAiU2hvdyBibGFuayBTSEEtMSBmb3IgYm91bmRhcnkgY29tbWl0cyAoRGVmYXVsdDogb2ZmKSIKIG1zZ3N0ciAibGVlcmUgU0hBLTEgZsO8ciBHcmVuei1Db21taXRzIGFuemVpZ2VuIChTdGFuZGFyZDogYXVzKSIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg0NworIzogYnVpbHRpbi9ibGFtZS5jOjg0NgogbXNnaWQgIkRvIG5vdCB0cmVhdCByb290IGNvbW1pdHMgYXMgYm91bmRhcmllcyAoRGVmYXVsdDogb2ZmKSIKIG1zZ3N0ciAiUm9vdC1Db21taXRzIG5pY2h0IGFscyBHcmVuemVuIGJlaGFuZGVsbiAoU3RhbmRhcmQ6IGF1cykiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NDgKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NDcKIG1zZ2lkICJTaG93IHdvcmsgY29zdCBzdGF0aXN0aWNzIgogbXNnc3RyICJTdGF0aXN0aWtlbiB6dW0gQXJiZWl0c2F1ZndhbmQgYW56ZWlnZW4iCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NDkKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NDgKIG1zZ2lkICJGb3JjZSBwcm9ncmVzcyByZXBvcnRpbmciCiBtc2dzdHIgIkZvcnRzY2hyaXR0c2FuemVpZ2UgZXJ6d2luZ2VuIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODUwCisjOiBidWlsdGluL2JsYW1lLmM6ODQ5CiBtc2dpZCAiU2hvdyBvdXRwdXQgc2NvcmUgZm9yIGJsYW1lIGVudHJpZXMiCiBtc2dzdHIgIkF1c2dhYmViZXdlcnR1bmcgZsO8ciBcImJsYW1lXCItRWludHLDpGdlIGFuemVpZ2VuIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODUxCisjOiBidWlsdGluL2JsYW1lLmM6ODUwCiBtc2dpZCAiU2hvdyBvcmlnaW5hbCBmaWxlbmFtZSAoRGVmYXVsdDogYXV0bykiCiBtc2dzdHIgInVyc3Byw7xuZ2xpY2hlbiBEYXRlaW5hbWVuIGFuemVpZ2VuIChTdGFuZGFyZDogYXV0bykiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NTIKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NTEKIG1zZ2lkICJTaG93IG9yaWdpbmFsIGxpbmVudW1iZXIgKERlZmF1bHQ6IG9mZikiCiBtc2dzdHIgInVyc3Byw7xuZ2xpY2hlIFplaWxlbm51bW1lciBhbnplaWdlbiAoU3RhbmRhcmQ6IGF1cykiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NTMKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NTIKIG1zZ2lkICJTaG93IGluIGEgZm9ybWF0IGRlc2lnbmVkIGZvciBtYWNoaW5lIGNvbnN1bXB0aW9uIgogbXNnc3RyICJBbnplaWdlIGluIGVpbmVtIEZvcm1hdCBmw7xyIG1hc2NoaW5lbGxlIEF1c3dlcnR1bmciCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NTQKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NTMKIG1zZ2lkICJTaG93IHBvcmNlbGFpbiBmb3JtYXQgd2l0aCBwZXItbGluZSBjb21taXQgaW5mb3JtYXRpb24iCiBtc2dzdHIgIiIKICJBbnplaWdlIGluIEZvcm1hdCBmw7xyIEZyZW1kcHJvZ3JhbW1lIG1pdCBDb21taXQtSW5mb3JtYXRpb25lbiBwcm8gWmVpbGUiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NTUKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NTQKIG1zZ2lkICJVc2UgdGhlIHNhbWUgb3V0cHV0IG1vZGUgYXMgZ2l0LWFubm90YXRlIChEZWZhdWx0OiBvZmYpIgogbXNnc3RyICIiCiAiRGVuIGdsZWljaGVuIEF1c2dhYmVtb2R1cyBiZW51dHplbiB3aWUgXCJnaXQtYW5ub3RhdGVcIiAoU3RhbmRhcmQ6IGF1cykiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NTYKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NTUKIG1zZ2lkICJTaG93IHJhdyB0aW1lc3RhbXAgKERlZmF1bHQ6IG9mZikiCiBtc2dzdHIgIlVuYmVhcmJlaXRldGVuIFplaXRzdGVtcGVsIGFuemVpZ2VuIChTdGFuZGFyZDogYXVzKSIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg1NworIzogYnVpbHRpbi9ibGFtZS5jOjg1NgogbXNnaWQgIlNob3cgbG9uZyBjb21taXQgU0hBMSAoRGVmYXVsdDogb2ZmKSIKIG1zZ3N0ciAiTGFuZ2VuIENvbW1pdC1TSEExIGFuemVpZ2VuIChTdGFuZGFyZDogYXVzKSIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg1OAorIzogYnVpbHRpbi9ibGFtZS5jOjg1NwogbXNnaWQgIlN1cHByZXNzIGF1dGhvciBuYW1lIGFuZCB0aW1lc3RhbXAgKERlZmF1bHQ6IG9mZikiCiBtc2dzdHIgIkRlbiBOYW1lbiBkZXMgQXV0b3JzIHVuZCBkZW4gWmVpdHN0ZW1wZWwgdW50ZXJkcsO8Y2tlbiAoU3RhbmRhcmQ6IGF1cykiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NTkKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NTgKIG1zZ2lkICJTaG93IGF1dGhvciBlbWFpbCBpbnN0ZWFkIG9mIG5hbWUgKERlZmF1bHQ6IG9mZikiCiBtc2dzdHIgIiIKICJBbnN0YXR0IGRlcyBOYW1lbnMgZGllIEUtTWFpbC1BZHJlc3NlIGRlcyBBdXRvcnMgYW56ZWlnZW4gKFN0YW5kYXJkOiBhdXMpIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODYwCisjOiBidWlsdGluL2JsYW1lLmM6ODU5CiBtc2dpZCAiSWdub3JlIHdoaXRlc3BhY2UgZGlmZmVyZW5jZXMiCiBtc2dzdHIgIlVudGVyc2NoaWVkZSBpbSBXaGl0ZXNwYWNlIGlnbm9yaWVyZW4iCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NjEgYnVpbHRpbi9sb2cuYzoxNjI5CisjOiBidWlsdGluL2JsYW1lLmM6ODYwIGJ1aWx0aW4vbG9nLmM6MTYzMAogbXNnaWQgInJldiIKIG1zZ3N0ciAiQ29tbWl0IgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODYxCisjOiBidWlsdGluL2JsYW1lLmM6ODYwCiBtc2dpZCAiSWdub3JlIDxyZXY+IHdoZW4gYmxhbWluZyIKIG1zZ3N0ciAiSWdub3JpZXJlIDxyZXY+IGJlaW0gQXVzZsO8aHJlbiB2b24gJ2JsYW1lJyIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg2MgorIzogYnVpbHRpbi9ibGFtZS5jOjg2MQogbXNnaWQgIklnbm9yZSByZXZpc2lvbnMgZnJvbSA8ZmlsZT4iCiBtc2dzdHIgIklnbm9yaWVyZSBDb21taXRzIGF1cyA8RGF0ZWk+IgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODYzCisjOiBidWlsdGluL2JsYW1lLmM6ODYyCiBtc2dpZCAiY29sb3IgcmVkdW5kYW50IG1ldGFkYXRhIGZyb20gcHJldmlvdXMgbGluZSBkaWZmZXJlbnRseSIKIG1zZ3N0ciAicmVkdW5kYW50ZSBNZXRhZGF0ZW4gZGVyIHZvcmhlcmlnZW4gWmVpbGUgdW50ZXJzY2hpZWRsaWNoIGVpbmbDpHJiZW4iCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NjQKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NjMKIG1zZ2lkICJjb2xvciBsaW5lcyBieSBhZ2UiCiBtc2dzdHIgIlplaWxlbiBuYWNoIEFsdGVyIGVpbmbDpHJiZW4iCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NzEKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NzAKIG1zZ2lkICJVc2UgYW4gZXhwZXJpbWVudGFsIGhldXJpc3RpYyB0byBpbXByb3ZlIGRpZmZzIgogbXNnc3RyICIiCiAiZWluZSBleHBlcmltZW50ZWxsZSBIZXVyaXN0aWsgenVyIFZlcmJlc3NlcnVuZyBkZXIgRGFyc3RlbGx1bmdcbiIKICJ2b24gVW50ZXJzY2hpZWRlbiB2ZXJ3ZW5kZW4iCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NzMKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NzIKIG1zZ2lkICJTcGVuZCBleHRyYSBjeWNsZXMgdG8gZmluZCBiZXR0ZXIgbWF0Y2giCiBtc2dzdHIgIkzDpG5nZXIgYXJiZWl0ZW4sIHVtIGJlc3NlcmUgw5xiZXJlaW5zdGltbXVuZ2VuIHp1IGZpbmRlbiIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg3NAorIzogYnVpbHRpbi9ibGFtZS5jOjg3MwogbXNnaWQgIlVzZSByZXZpc2lvbnMgZnJvbSA8ZmlsZT4gaW5zdGVhZCBvZiBjYWxsaW5nIGdpdC1yZXYtbGlzdCIKIG1zZ3N0ciAiQ29tbWl0cyB2b24gPERhdGVpPiBiZW51dHplbiwgYW5zdGF0dCBcImdpdC1yZXYtbGlzdFwiIGF1Znp1cnVmZW4iCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NzUKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NzQKIG1zZ2lkICJVc2UgPGZpbGU+J3MgY29udGVudHMgYXMgdGhlIGZpbmFsIGltYWdlIgogbXNnc3RyICJJbmhhbHRlIGRlciA8RGF0ZWk+ZW4gYWxzIGVuZGfDvGx0aWdlcyBBYmJpbGQgYmVudXR6ZW4iCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NzYgYnVpbHRpbi9ibGFtZS5jOjg3NworIzogYnVpbHRpbi9ibGFtZS5jOjg3NSBidWlsdGluL2JsYW1lLmM6ODc2CiBtc2dpZCAic2NvcmUiCiBtc2dzdHIgIkJld2VydHVuZyIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg3NgorIzogYnVpbHRpbi9ibGFtZS5jOjg3NQogbXNnaWQgIkZpbmQgbGluZSBjb3BpZXMgd2l0aGluIGFuZCBhY3Jvc3MgZmlsZXMiCiBtc2dzdHIgImtvcGllcnRlIFplaWxlbiBpbm5lcmhhbGIgb2RlciB6d2lzY2hlbiBEYXRlaWVuIGZpbmRlbiIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg3NworIzogYnVpbHRpbi9ibGFtZS5jOjg3NgogbXNnaWQgIkZpbmQgbGluZSBtb3ZlbWVudHMgd2l0aGluIGFuZCBhY3Jvc3MgZmlsZXMiCiBtc2dzdHIgInZlcnNjaG9iZW5lIFplaWxlbiBpbm5lcmhhbGIgb2RlciB6d2lzY2hlbiBEYXRlaWVuIGZpbmRlbiIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg3OAorIzogYnVpbHRpbi9ibGFtZS5jOjg3NwogbXNnaWQgIm4sbSIKIG1zZ3N0ciAibixtIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODc4CisjOiBidWlsdGluL2JsYW1lLmM6ODc3CiBtc2dpZCAiUHJvY2VzcyBvbmx5IGxpbmUgcmFuZ2UgbixtLCBjb3VudGluZyBmcm9tIDEiCiBtc2dzdHIgIm51ciBaZWlsZW4gaW0gQmVyZWljaCBuLG0gdmVyYXJiZWl0ZW4sIGdlesOkaGx0IHZvbiAxIgogCkBAIC05OTAzLDcgKzk5NDcsNyBAQAogbXNnaWQgImRvIG5vdCB1c2UiCiBtc2dzdHIgIm5pY2h0IHZlcndlbmRlbiIKIAotIzogYnVpbHRpbi9icmFuY2guYzo2MjYgYnVpbHRpbi9yZWJhc2UuYzo0ODUKKyM6IGJ1aWx0aW4vYnJhbmNoLmM6NjI2IGJ1aWx0aW4vcmViYXNlLmM6NDg2CiBtc2dpZCAidXBzdHJlYW0iCiBtc2dzdHIgIlVwc3RyZWFtIgogCkBAIC0xMDAxNSw3ICsxMDA1OSw3IEBACiBtc2dpZCAiZm9ybWF0IHRvIHVzZSBmb3IgdGhlIG91dHB1dCIKIG1zZ3N0ciAiZsO8ciBkaWUgQXVzZ2FiZSB6dSB2ZXJ3ZW5kZW5kZXMgRm9ybWF0IgogCi0jOiBidWlsdGluL2JyYW5jaC5jOjY4NCBidWlsdGluL2Nsb25lLmM6NzYxCisjOiBidWlsdGluL2JyYW5jaC5jOjY4NCBidWlsdGluL2Nsb25lLmM6NzYwCiBtc2dpZCAiSEVBRCBub3QgZm91bmQgYmVsb3cgcmVmcy9oZWFkcyEiCiBtc2dzdHIgIkhFQUQgd3VyZGUgbmljaHQgdW50ZXIgXCJyZWZzL2hlYWRzXCIgZ2VmdW5kZW4hIgogCkBAIC0xMDEyMiw3ICsxMDE2Niw3IEBACiBtc2dpZCAiTmVlZCBhIHJlcG9zaXRvcnkgdG8gdW5idW5kbGUuIgogbXNnc3RyICJadW0gRW50cGFja2VuIHdpcmQgZWluIFJlcG9zaXRvcnkgYmVuw7Z0aWd0LiIKIAotIzogYnVpbHRpbi9jYXQtZmlsZS5jOjU5NAorIzogYnVpbHRpbi9jYXQtZmlsZS5jOjU5NQogbXNnaWQgIiIKICJnaXQgY2F0LWZpbGUgKC10IFstLWFsbG93LXVua25vd24tdHlwZV0gfCAtcyBbLS1hbGxvdy11bmtub3duLXR5cGVdIHwgLWUgfCAtIgogInAgfCA8dHlwZT4gfCAtLXRleHRjb252IHwgLS1maWx0ZXJzKSBbLS1wYXRoPTxwYXRoPl0gPG9iamVjdD4iCkBAIC0xMDEzMCw3ICsxMDE3NCw3IEBACiAiZ2l0IGNhdC1maWxlICgtdCBbLS1hbGxvdy11bmtub3duLXR5cGVdIHwgLXMgWy0tYWxsb3ctdW5rbm93bi10eXBlXSB8IC1lIHwgLSIKICJwIHwgPEFydD4gfCAtLXRleHRjb252IHwgLS1maWx0ZXJzKSBbLS1wYXRoPTxQZmFkPl0gPE9iamVrdD4iCiAKLSM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo1OTUKKyM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo1OTYKIG1zZ2lkICIiCiAiZ2l0IGNhdC1maWxlICgtLWJhdGNoIHwgLS1iYXRjaC1jaGVjaykgWy0tZm9sbG93LXN5bWxpbmtzXSBbLS10ZXh0Y29udiB8IC0tIgogImZpbHRlcnNdIgpAQCAtMTAxMzgsNzYgKzEwMTgyLDc2IEBACiAiZ2l0IGNhdC1maWxlICgtLWJhdGNoIHwgLS1iYXRjaC1jaGVjaykgWy0tZm9sbG93LXN5bWxpbmtzXSBbLS10ZXh0Y29udiB8IC0tIgogImZpbHRlcnNdIgogCi0jOiBidWlsdGluL2NhdC1maWxlLmM6NjE2CisjOiBidWlsdGluL2NhdC1maWxlLmM6NjE3CiBtc2dpZCAib25seSBvbmUgYmF0Y2ggb3B0aW9uIG1heSBiZSBzcGVjaWZpZWQiCiBtc2dzdHIgIk51ciBlaW5lIEJhdGNoLU9wdGlvbiBlcmxhdWJ0LiIKIAotIzogYnVpbHRpbi9jYXQtZmlsZS5jOjYzNAorIzogYnVpbHRpbi9jYXQtZmlsZS5jOjYzNQogbXNnaWQgIjx0eXBlPiBjYW4gYmUgb25lIG9mOiBibG9iLCB0cmVlLCBjb21taXQsIHRhZyIKIG1zZ3N0ciAiPEFydD4ga2FubiBzZWluOiBibG9iLCB0cmVlLCBjb21taXQsIHRhZyIKIAotIzogYnVpbHRpbi9jYXQtZmlsZS5jOjYzNQorIzogYnVpbHRpbi9jYXQtZmlsZS5jOjYzNgogbXNnaWQgInNob3cgb2JqZWN0IHR5cGUiCiBtc2dzdHIgIk9iamVrdGFydCBhbnplaWdlbiIKIAotIzogYnVpbHRpbi9jYXQtZmlsZS5jOjYzNgorIzogYnVpbHRpbi9jYXQtZmlsZS5jOjYzNwogbXNnaWQgInNob3cgb2JqZWN0IHNpemUiCiBtc2dzdHIgIk9iamVrdGdyw7bDn2UgYW56ZWlnZW4iCiAKLSM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2MzgKKyM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2MzkKIG1zZ2lkICJleGl0IHdpdGggemVybyB3aGVuIHRoZXJlJ3Mgbm8gZXJyb3IiCiBtc2dzdHIgIm1pdCBSw7xja2dhYmV3ZXJ0IDAgYmVlbmRlbiwgd2VubiBrZWluIEZlaGxlciBhdWZnZXRyZXRlbiBpc3QiCiAKLSM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2MzkKKyM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NDAKIG1zZ2lkICJwcmV0dHktcHJpbnQgb2JqZWN0J3MgY29udGVudCIKIG1zZ3N0ciAiYW5zcHJlY2hlbmRlIEFuemVpZ2UgZGVzIE9iamVrdGluaGFsdGVzIgogCi0jOiBidWlsdGluL2NhdC1maWxlLmM6NjQxCisjOiBidWlsdGluL2NhdC1maWxlLmM6NjQyCiBtc2dpZCAiZm9yIGJsb2Igb2JqZWN0cywgcnVuIHRleHRjb252IG9uIG9iamVjdCdzIGNvbnRlbnQiCiBtc2dzdHIgImVpbmUgVGV4dGtvbnZlcnRpZXJ1bmcgYXVmIGRlbiBJbmhhbHQgdm9uIEJsb2ItT2JqZWt0ZW4gYXVzZsO8aHJlbiIKIAotIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY0MworIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY0NAogbXNnaWQgImZvciBibG9iIG9iamVjdHMsIHJ1biBmaWx0ZXJzIG9uIG9iamVjdCdzIGNvbnRlbnQiCiBtc2dzdHIgImbDvHIgQmxvYi1PYmpla3RlLCBGaWx0ZXIgYXVmIE9iamVrdC1JbmhhbHRlIGF1c2bDvGhyZW4iCiAKLSM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NDQgZ2l0LXN1Ym1vZHVsZS5zaDo5MzYKKyM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NDUgZ2l0LXN1Ym1vZHVsZS5zaDo5MzYKIG1zZ2lkICJibG9iIgogbXNnc3RyICJCbG9iIgogCi0jOiBidWlsdGluL2NhdC1maWxlLmM6NjQ1CisjOiBidWlsdGluL2NhdC1maWxlLmM6NjQ2CiBtc2dpZCAidXNlIGEgc3BlY2lmaWMgcGF0aCBmb3IgLS10ZXh0Y29udi8tLWZpbHRlcnMiCiBtc2dzdHIgImVpbmVuIGJlc3RpbW10ZW4gUGZhZCBmw7xyIC0tdGV4dGNvbnYvLS1maWx0ZXJzIHZlcndlbmRlbiIKIAotIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY0NworIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY0OAogbXNnaWQgImFsbG93IC1zIGFuZCAtdCB0byB3b3JrIHdpdGggYnJva2VuL2NvcnJ1cHQgb2JqZWN0cyIKIG1zZ3N0ciAiLXMgdW5kIC10IG1pdCBiZXNjaMOkZGlndGVuIE9iamVrdGVuIGVybGF1YmVuIgogCi0jOiBidWlsdGluL2NhdC1maWxlLmM6NjQ4CisjOiBidWlsdGluL2NhdC1maWxlLmM6NjQ5CiBtc2dpZCAiYnVmZmVyIC0tYmF0Y2ggb3V0cHV0IgogbXNnc3RyICJBdXNnYWJlIHZvbiAtLWJhdGNoIHB1ZmZlcm4iCiAKLSM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NTAKKyM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NTEKIG1zZ2lkICJzaG93IGluZm8gYW5kIGNvbnRlbnQgb2Ygb2JqZWN0cyBmZWQgZnJvbSB0aGUgc3RhbmRhcmQgaW5wdXQiCiBtc2dzdHIgIiIKICJBbnplaWdlIHZvbiBJbmZvcm1hdGlvbmVuIHVuZCBJbmhhbHQgdm9uIE9iamVrdGVuLCBnZWxlc2VuIHZvbiBkZXIgU3RhbmRhcmQtIgogIkVpbmdhYmUiCiAKLSM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NTQKKyM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NTUKIG1zZ2lkICJzaG93IGluZm8gYWJvdXQgb2JqZWN0cyBmZWQgZnJvbSB0aGUgc3RhbmRhcmQgaW5wdXQiCiBtc2dzdHIgIiIKICJBbnplaWdlIHZvbiBJbmZvcm1hdGlvbmVuIMO8YmVyIE9iamVrdGUsIGdlbGVzZW4gdm9uIGRlciBTdGFuZGFyZC1FaW5nYWJlIgogCi0jOiBidWlsdGluL2NhdC1maWxlLmM6NjU4CisjOiBidWlsdGluL2NhdC1maWxlLmM6NjU5CiBtc2dpZCAiZm9sbG93IGluLXRyZWUgc3ltbGlua3MgKHVzZWQgd2l0aCAtLWJhdGNoIG9yIC0tYmF0Y2gtY2hlY2spIgogbXNnc3RyICIiCiAic3ltYm9saXNjaGVuIFZlcmtuw7xwZnVuZ2VuIGlubmVyaGFsYiBkZXMgUmVwb3NpdG9yaWVzIGZvbGdlbiAodmVyd2VuZGV0IG1pdCAiCiAiLS1iYXRjaCBvZGVyIC0tYmF0Y2gtY2hlY2spIgogCi0jOiBidWlsdGluL2NhdC1maWxlLmM6NjYwCisjOiBidWlsdGluL2NhdC1maWxlLmM6NjYxCiBtc2dpZCAic2hvdyBhbGwgb2JqZWN0cyB3aXRoIC0tYmF0Y2ggb3IgLS1iYXRjaC1jaGVjayIKIG1zZ3N0ciAiYWxsZSBPYmpla3RlIG1pdCAtLWJhdGNoIG9kZXIgLS1iYXRjaC1jaGVjayBhbnplaWdlbiIKIAotIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY2MgorIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY2MwogbXNnaWQgImRvIG5vdCBvcmRlciAtLWJhdGNoLWFsbC1vYmplY3RzIG91dHB1dCIKIG1zZ3N0ciAiQXVzZ2FiZSB2b24gLS1iYXRjaC1hbGwtb2JqZWN0cyBuaWNodCBvcmRuZW4iCiAKQEAgLTEwMjM1LDggKzEwMjc5LDggQEAKIG1zZ2lkICJ0ZXJtaW5hdGUgaW5wdXQgYW5kIG91dHB1dCByZWNvcmRzIGJ5IGEgTlVMIGNoYXJhY3RlciIKIG1zZ3N0ciAiRWludHLDpGdlIHZvbiBFaW4tIHVuZCBBdXNnYWJlIG1pdCBOVUwtWmVpY2hlbiBhYnNjaGxpZcOfZW4iCiAKLSM6IGJ1aWx0aW4vY2hlY2staWdub3JlLmM6MjEgYnVpbHRpbi9jaGVja291dC5jOjE0MzMgYnVpbHRpbi9nYy5jOjUzOAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjUwNworIzogYnVpbHRpbi9jaGVjay1pZ25vcmUuYzoyMSBidWlsdGluL2NoZWNrb3V0LmM6MTQzMyBidWlsdGluL2djLmM6NTM3CisjOiBidWlsdGluL3dvcmt0cmVlLmM6NTA2CiBtc2dpZCAic3VwcHJlc3MgcHJvZ3Jlc3MgcmVwb3J0aW5nIgogbXNnc3RyICJGb3J0c2Nocml0dHNhbnplaWdlIHVudGVyZHLDvGNrZW4iCiAKQEAgLTEwMzMxLDcgKzEwMzc1LDcgQEAKICM6IGJ1aWx0aW4vY2hlY2tvdXQtaW5kZXguYzoxNzggYnVpbHRpbi9jb2x1bW4uYzozMQogIzogYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjEzNzMgYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjEzNzYKICM6IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxMzg0IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxODU3Ci0jOiBidWlsdGluL3dvcmt0cmVlLmM6NjgwCisjOiBidWlsdGluL3dvcmt0cmVlLmM6Njc5CiBtc2dpZCAic3RyaW5nIgogbXNnc3RyICJaZWljaGVua2V0dGUiCiAKQEAgLTEwMzYwLDk5ICsxMDQwNCw5OSBAQAogbXNnaWQgImdpdCByZXN0b3JlIFs8b3B0aW9ucz5dIFstLXNvdXJjZT08YnJhbmNoPl0gPGZpbGU+Li4uIgogbXNnc3RyICJnaXQgcmVzdG9yZSBbPE9wdGlvbmVuPl0gWy0tc291cmNlPTxCcmFuY2g+XSA8RGF0ZWk+Li4uIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6MTcyIGJ1aWx0aW4vY2hlY2tvdXQuYzoyMTEKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzMgYnVpbHRpbi9jaGVja291dC5jOjIxMgogIywgYy1mb3JtYXQKIG1zZ2lkICJwYXRoICclcycgZG9lcyBub3QgaGF2ZSBvdXIgdmVyc2lvbiIKIG1zZ3N0ciAiUGZhZCAnJXMnIGhhdCBuaWNodCB1bnNlcmUgVmVyc2lvbi4iCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzQgYnVpbHRpbi9jaGVja291dC5jOjIxMworIzogYnVpbHRpbi9jaGVja291dC5jOjE3NSBidWlsdGluL2NoZWNrb3V0LmM6MjE0CiAjLCBjLWZvcm1hdAogbXNnaWQgInBhdGggJyVzJyBkb2VzIG5vdCBoYXZlIHRoZWlyIHZlcnNpb24iCiBtc2dzdHIgIlBmYWQgJyVzJyBoYXQgbmljaHQgZGVyZW4gVmVyc2lvbi4iCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxOTAKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxOTEKICMsIGMtZm9ybWF0CiBtc2dpZCAicGF0aCAnJXMnIGRvZXMgbm90IGhhdmUgYWxsIG5lY2Vzc2FyeSB2ZXJzaW9ucyIKIG1zZ3N0ciAiUGZhZCAnJXMnIGhhdCBuaWNodCBhbGxlIG5vdHdlbmRpZ2VuIFZlcnNpb25lbi4iCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoyNDAKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoyNDEKICMsIGMtZm9ybWF0CiBtc2dpZCAicGF0aCAnJXMnIGRvZXMgbm90IGhhdmUgbmVjZXNzYXJ5IHZlcnNpb25zIgogbXNnc3RyICJQZmFkICclcycgaGF0IG5pY2h0IGRpZSBub3R3ZW5kaWdlbiBWZXJzaW9uZW4uIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6MjU4CisjOiBidWlsdGluL2NoZWNrb3V0LmM6MjU5CiAjLCBjLWZvcm1hdAogbXNnaWQgInBhdGggJyVzJzogY2Fubm90IG1lcmdlIgogbXNnc3RyICJQZmFkICclcyc6IGthbm4gbmljaHQgenVzYW1tZW5mw7xocmVuIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6Mjc0CisjOiBidWlsdGluL2NoZWNrb3V0LmM6Mjc1CiAjLCBjLWZvcm1hdAogbXNnaWQgIlVuYWJsZSB0byBhZGQgbWVyZ2UgcmVzdWx0IGZvciAnJXMnIgogbXNnc3RyICJLb25udGUgTWVyZ2UtRXJnZWJuaXMgdm9uICclcycgbmljaHQgaGluenVmw7xnZW4uIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6Mzc0CisjOiBidWlsdGluL2NoZWNrb3V0LmM6Mzc1CiAjLCBjLWZvcm1hdAogbXNnaWQgIlJlY3JlYXRlZCAlZCBtZXJnZSBjb25mbGljdCIKIG1zZ2lkX3BsdXJhbCAiUmVjcmVhdGVkICVkIG1lcmdlIGNvbmZsaWN0cyIKIG1zZ3N0clswXSAiJWQgTWVyZ2UtS29uZmxpa3Qgd2llZGVyIGVyc3RlbGx0IgogbXNnc3RyWzFdICIlZCBNZXJnZS1Lb25mbGlrdGUgd2llZGVyIGVyc3RlbGx0IgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6Mzc5CisjOiBidWlsdGluL2NoZWNrb3V0LmM6MzgwCiAjLCBjLWZvcm1hdAogbXNnaWQgIlVwZGF0ZWQgJWQgcGF0aCBmcm9tICVzIgogbXNnaWRfcGx1cmFsICJVcGRhdGVkICVkIHBhdGhzIGZyb20gJXMiCiBtc2dzdHJbMF0gIiVkIFBmYWQgdm9uICVzIGFrdHVhbGlzaWVydCIKIG1zZ3N0clsxXSAiJWQgUGZhZGUgdm9uICVzIGFrdHVhbGlzaWVydCIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjM4NgorIzogYnVpbHRpbi9jaGVja291dC5jOjM4NwogIywgYy1mb3JtYXQKIG1zZ2lkICJVcGRhdGVkICVkIHBhdGggZnJvbSB0aGUgaW5kZXgiCiBtc2dpZF9wbHVyYWwgIlVwZGF0ZWQgJWQgcGF0aHMgZnJvbSB0aGUgaW5kZXgiCiBtc2dzdHJbMF0gIiVkIFBmYWQgdm9tIEluZGV4IGFrdHVhbGlzaWVydCIKIG1zZ3N0clsxXSAiJWQgUGZhZGUgdm9tIEluZGV4IGFrdHVhbGlzaWVydCIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjQwOSBidWlsdGluL2NoZWNrb3V0LmM6NDEyIGJ1aWx0aW4vY2hlY2tvdXQuYzo0MTUKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo0MTkKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo0MTAgYnVpbHRpbi9jaGVja291dC5jOjQxMyBidWlsdGluL2NoZWNrb3V0LmM6NDE2CisjOiBidWlsdGluL2NoZWNrb3V0LmM6NDIwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiclcycgY2Fubm90IGJlIHVzZWQgd2l0aCB1cGRhdGluZyBwYXRocyIKIG1zZ3N0ciAiJyVzJyBrYW5uIG5pY2h0IG1pdCBkZXIgQWt0dWFsaXNpZXJ1bmcgdm9uIFBmYWRlbiB2ZXJ3ZW5kZXQgd2VyZGVuIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6NDIyIGJ1aWx0aW4vY2hlY2tvdXQuYzo0MjUKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo0MjMgYnVpbHRpbi9jaGVja291dC5jOjQyNgogIywgYy1mb3JtYXQKIG1zZ2lkICInJXMnIGNhbm5vdCBiZSB1c2VkIHdpdGggJXMiCiBtc2dzdHIgIiclcycga2FubiBuaWNodCBtaXQgJyVzJyB2ZXJ3ZW5kZXQgd2VyZGVuIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6NDI5CisjOiBidWlsdGluL2NoZWNrb3V0LmM6NDMwCiAjLCBjLWZvcm1hdAogbXNnaWQgIkNhbm5vdCB1cGRhdGUgcGF0aHMgYW5kIHN3aXRjaCB0byBicmFuY2ggJyVzJyBhdCB0aGUgc2FtZSB0aW1lLiIKIG1zZ3N0ciAiIgogIkthbm4gbmljaHQgZ2xlaWNoemVpdGlnIFBmYWRlIGFrdHVhbGlzaWVyZW4gdW5kIHp1IEJyYW5jaCAnJXMnIHdlY2hzZWxuIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6NDMzCisjOiBidWlsdGluL2NoZWNrb3V0LmM6NDM0CiAjLCBjLWZvcm1hdAogbXNnaWQgIm5laXRoZXIgJyVzJyBvciAnJXMnIGlzIHNwZWNpZmllZCIKIG1zZ3N0ciAiV2VkZXIgJyVzJyBub2NoICclcycgaXN0IGFuZ2VnZWJlbiIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjQzNworIzogYnVpbHRpbi9jaGVja291dC5jOjQzOAogIywgYy1mb3JtYXQKIG1zZ2lkICInJXMnIG11c3QgYmUgdXNlZCB3aGVuICclcycgaXMgbm90IHNwZWNpZmllZCIKIG1zZ3N0ciAiJyVzJyBrYW5uIG51ciBnZW51dHp0IHdlcmRlbiwgd2VubiAnJXMnIG5pY2h0IHZlcndlbmRldCB3aXJkIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6NDQyIGJ1aWx0aW4vY2hlY2tvdXQuYzo0NDcKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo0NDMgYnVpbHRpbi9jaGVja291dC5jOjQ0OAogIywgYy1mb3JtYXQKIG1zZ2lkICInJXMnIG9yICclcycgY2Fubm90IGJlIHVzZWQgd2l0aCAlcyIKIG1zZ3N0ciAiJyVzJyBvZGVyICclcycga2FubiBuaWNodCBtaXQgJXMgdmVyd2VuZGV0IHdlcmRlbiIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjUwNiBidWlsdGluL2NoZWNrb3V0LmM6NTEzCisjOiBidWlsdGluL2NoZWNrb3V0LmM6NTA3IGJ1aWx0aW4vY2hlY2tvdXQuYzo1MTQKICMsIGMtZm9ybWF0CiBtc2dpZCAicGF0aCAnJXMnIGlzIHVubWVyZ2VkIgogbXNnc3RyICJQZmFkICclcycgaXN0IG5pY2h0IHp1c2FtbWVuZ2Vmw7xocnQuIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6Njc5CisjOiBidWlsdGluL2NoZWNrb3V0LmM6NjgwCiBtc2dpZCAieW91IG5lZWQgdG8gcmVzb2x2ZSB5b3VyIGN1cnJlbnQgaW5kZXggZmlyc3QiCiBtc2dzdHIgIlNpZSBtw7xzc2VuIHp1ZXJzdCBkaWUgS29uZmxpa3RlIGluIElocmVtIGFrdHVlbGxlbiBJbmRleCBhdWZsw7ZzZW4uIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6NzI5CisjOiBidWlsdGluL2NoZWNrb3V0LmM6NzMwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJjYW5ub3QgY29udGludWUgd2l0aCBzdGFnZWQgY2hhbmdlcyBpbiB0aGUgZm9sbG93aW5nIGZpbGVzOlxuIgpAQCAtMTA0NjEsMTMgKzEwNTA1LDYgQEAKICJLYW5uIG5pY2h0IG1pdCB2b3JnZW1lcmt0ZW4gw4RuZGVydW5nZW4gaW4gZm9sZ2VuZGVuIERhdGVpZW4gZm9ydHNldHplbjpcbiIKICIlcyIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjczNgotIywgYy1mb3JtYXQKLW1zZ2lkICJzdGFnZWQgY2hhbmdlcyBpbiB0aGUgZm9sbG93aW5nIGZpbGVzIG1heSBiZSBsb3N0OiAlcyIKLW1zZ3N0ciAiIgotIlp1bSBDb21taXQgdm9yZ2VtZXJrdGUgw4RuZGVydW5nZW4gaW4gZGVuIGZvbGdlbmRlbiBEYXRlaWVuIGdlaGVuIGV2ZW50dWVsbCAiCi0idmVybG9yZW46ICVzIgotCiAjOiBidWlsdGluL2NoZWNrb3V0LmM6ODMzCiAjLCBjLWZvcm1hdAogbXNnaWQgIkNhbiBub3QgZG8gcmVmbG9nIGZvciAnJXMnOiAlc1xuIgpAQCAtMTA0NzcsNyArMTA1MTQsNyBAQAogbXNnaWQgIkhFQUQgaXMgbm93IGF0IgogbXNnc3RyICJIRUFEIGlzdCBqZXR6dCBiZWkiCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo4NzkgYnVpbHRpbi9jbG9uZS5jOjcxNAorIzogYnVpbHRpbi9jaGVja291dC5jOjg3OSBidWlsdGluL2Nsb25lLmM6NzEzCiBtc2dpZCAidW5hYmxlIHRvIHVwZGF0ZSBIRUFEIgogbXNnc3RyICJLb25udGUgSEVBRCBuaWNodCBha3R1YWxpc2llcmVuLiIKIApAQCAtMTA1OTIsNyArMTA2MjksNyBAQAogIkJpdHRlIGJlbnV0emVuIFNpZSAtLSAodW5kIG9wdGlvbmFsIC0tbm8tZ3Vlc3MpLCB1bSBkaWVzZVxuIgogImVpbmRldXRpZyB2b25laW5hbmRlciB6dSB1bnRlcnNjaGVpZGVuLiIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjEyNDMgYnVpbHRpbi93b3JrdHJlZS5jOjI5MSBidWlsdGluL3dvcmt0cmVlLmM6NDU2CisjOiBidWlsdGluL2NoZWNrb3V0LmM6MTI0MyBidWlsdGluL3dvcmt0cmVlLmM6MjkwIGJ1aWx0aW4vd29ya3RyZWUuYzo0NTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCByZWZlcmVuY2U6ICVzIgogbXNnc3RyICJVbmfDvGx0aWdlIFJlZmVyZW56OiAlcyIKQEAgLTEwNjk5LDkgKzEwNzM2LDkgQEAKIG1zZ2lkICJtaXNzaW5nIGJyYW5jaCBvciBjb21taXQgYXJndW1lbnQiCiBtc2dzdHIgIkJyYW5jaC0gb2RlciBDb21taXQtQXJndW1lbnQgZmVobHQiCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNDM3IGJ1aWx0aW4vY2xvbmUuYzo5MSBidWlsdGluL2ZldGNoLmM6MTUxCi0jOiBidWlsdGluL21lcmdlLmM6Mjg1IGJ1aWx0aW4vcHVsbC5jOjEzNyBidWlsdGluL3B1c2guYzo1NzUKLSM6IGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTc0CisjOiBidWlsdGluL2NoZWNrb3V0LmM6MTQzNyBidWlsdGluL2Nsb25lLmM6OTAgYnVpbHRpbi9jb21taXQtZ3JhcGguYzo1OQorIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxODAgYnVpbHRpbi9mZXRjaC5jOjE2NiBidWlsdGluL21lcmdlLmM6Mjg1CisjOiBidWlsdGluL3B1bGwuYzoxMzggYnVpbHRpbi9wdXNoLmM6NTYyIGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTc0CiBtc2dpZCAiZm9yY2UgcHJvZ3Jlc3MgcmVwb3J0aW5nIgogbXNnc3RyICJGb3J0c2Nocml0dHNhbnplaWdlIGVyendpbmdlbiIKIApAQCAtMTA3MDksNyArMTA3NDYsNyBAQAogbXNnaWQgInBlcmZvcm0gYSAzLXdheSBtZXJnZSB3aXRoIHRoZSBuZXcgYnJhbmNoIgogbXNnc3RyICJlaW5lbiAzLVdlZ2UtTWVyZ2UgbWl0IGRlbSBuZXVlbiBCcmFuY2ggYXVzZsO8aHJlbiIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjE0MzkgYnVpbHRpbi9sb2cuYzoxNjE3IHBhcnNlLW9wdGlvbnMuaDozMTgKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNDM5IGJ1aWx0aW4vbG9nLmM6MTYxOCBwYXJzZS1vcHRpb25zLmg6MzE4CiBtc2dpZCAic3R5bGUiCiBtc2dzdHIgIlN0aWwiCiAKQEAgLTEwNzE3LDcgKzEwNzU0LDcgQEAKIG1zZ2lkICJjb25mbGljdCBzdHlsZSAobWVyZ2Ugb3IgZGlmZjMpIgogbXNnc3RyICJLb25mbGlrdHN0aWwgKG1lcmdlIG9kZXIgZGlmZjMpIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6MTQ1MiBidWlsdGluL3dvcmt0cmVlLmM6NTA0CisjOiBidWlsdGluL2NoZWNrb3V0LmM6MTQ1MiBidWlsdGluL3dvcmt0cmVlLmM6NTAzCiBtc2dpZCAiZGV0YWNoIEhFQUQgYXQgbmFtZWQgY29tbWl0IgogbXNnc3RyICJIRUFEIGJlaSBiZW5hbm50ZW0gQ29tbWl0IGxvc2zDtnNlbiIKIApAQCAtMTA4MzksOSArMTA4NzYsOSBAQAogImJldm9yenVnZW4gbcO2Y2h0ZW4sIHouQi4gJ29yaWdpbicsIGvDtm5udGVuIFNpZSBkaWUgRWluc3RlbGx1bmdcbiIKICJjaGVja291dC5kZWZhdWx0UmVtb3RlPW9yaWdpbiBpbiBJaHJlciBLb25maWd1cmF0aW9uIHNldHplbi4iCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNjkxIGJ1aWx0aW4vY2hlY2tvdXQuYzoxNjkzIGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzMzCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6MTczNSBidWlsdGluL2Nsb25lLmM6MTIxIGJ1aWx0aW4vcmVtb3RlLmM6MTY5Ci0jOiBidWlsdGluL3JlbW90ZS5jOjE3MSBidWlsdGluL3dvcmt0cmVlLmM6NTAwIGJ1aWx0aW4vd29ya3RyZWUuYzo1MDIKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNjkxIGJ1aWx0aW4vY2hlY2tvdXQuYzoxNjkzIGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzQyCisjOiBidWlsdGluL2NoZWNrb3V0LmM6MTc0NCBidWlsdGluL2Nsb25lLmM6MTIwIGJ1aWx0aW4vcmVtb3RlLmM6MTY5CisjOiBidWlsdGluL3JlbW90ZS5jOjE3MSBidWlsdGluL3dvcmt0cmVlLmM6NDk5IGJ1aWx0aW4vd29ya3RyZWUuYzo1MDEKIG1zZ2lkICJicmFuY2giCiBtc2dzdHIgIkJyYW5jaCIKIApAQCAtMTA4NTksNDYgKzEwODk2LDQ1IEBACiAKICM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNjk3CiBtc2dpZCAic2Vjb25kIGd1ZXNzICdnaXQgY2hlY2tvdXQgPG5vLXN1Y2gtYnJhbmNoPicgKGRlZmF1bHQpIgotbXNnc3RyICIiCi0iWndlaXRlIFZlcm11dHVuZyAnZ2l0IGNoZWNrb3V0IDxrZWluLXNvbGNoZXItQnJhbmNoPicgKFN0YW5kYXJkKSIKK21zZ3N0ciAiWndlaXRlIFZlcm11dHVuZyAnZ2l0IGNoZWNrb3V0IDxrZWluLXNvbGNoZXItQnJhbmNoPicgKFN0YW5kYXJkKSIKIAogIzogYnVpbHRpbi9jaGVja291dC5jOjE2OTgKIG1zZ2lkICJ1c2Ugb3ZlcmxheSBtb2RlIChkZWZhdWx0KSIKIG1zZ3N0ciAiYmVudXR6ZSBPdmVybGF5LU1vZHVzIChTdGFuZGFyZCkiCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzM0CisjOiBidWlsdGluL2NoZWNrb3V0LmM6MTc0MwogbXNnaWQgImNyZWF0ZSBhbmQgc3dpdGNoIHRvIGEgbmV3IGJyYW5jaCIKIG1zZ3N0ciAiZWluZW4gbmV1ZW4gQnJhbmNoIGVyemV1Z2VuIHVuZCBkYWhpbiB3ZWNoc2VsbiIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjE3MzYKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzQ1CiBtc2dpZCAiY3JlYXRlL3Jlc2V0IGFuZCBzd2l0Y2ggdG8gYSBicmFuY2giCiBtc2dzdHIgImVpbmVuIEJyYW5jaCBlcnN0ZWxsZW4vdW1zZXR6ZW4gdW5kIGRhaGluIHdlY2hzZWxuIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6MTczOAorIzogYnVpbHRpbi9jaGVja291dC5jOjE3NDcKIG1zZ2lkICJzZWNvbmQgZ3Vlc3MgJ2dpdCBzd2l0Y2ggPG5vLXN1Y2gtYnJhbmNoPiciCiBtc2dzdHIgIlp3ZWl0ZSBWZXJtdXR1bmcgJ2dpdCBzd2l0Y2ggPGtlaW4tc29sY2hlci1CcmFuY2g+JyIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjE3NDAKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzQ5CiBtc2dpZCAidGhyb3cgYXdheSBsb2NhbCBtb2RpZmljYXRpb25zIgogbXNnc3RyICJsb2thbGUgw4RuZGVydW5nZW4gdmVyd2VyZmVuIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6MTc3MgorIzogYnVpbHRpbi9jaGVja291dC5jOjE3ODEKIG1zZ2lkICJ3aGljaCB0cmVlLWlzaCB0byBjaGVja291dCBmcm9tIgogbXNnc3RyICJWb24gd2VsY2hlciBDb21taXQtUmVmZXJlbnogYXVzZ2VjaGVja3Qgd2VyZGVuIHNvbGwiCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzc0CisjOiBidWlsdGluL2NoZWNrb3V0LmM6MTc4MwogbXNnaWQgInJlc3RvcmUgdGhlIGluZGV4IgogbXNnc3RyICJJbmRleCB3aWVkZXJoZXJzdGVsbGVuIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6MTc3NgorIzogYnVpbHRpbi9jaGVja291dC5jOjE3ODUKIG1zZ2lkICJyZXN0b3JlIHRoZSB3b3JraW5nIHRyZWUgKGRlZmF1bHQpIgogbXNnc3RyICJkYXMgQXJiZWl0c3ZlcnplaWNobmlzIHdpZWRlcmhlcnN0ZWxsZW4gKFN0YW5kYXJkKSIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjE3NzgKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzg3CiBtc2dpZCAiaWdub3JlIHVubWVyZ2VkIGVudHJpZXMiCiBtc2dzdHIgImlnbm9yaWVyZSBuaWNodCB6dXNhbW1lbmdlZsO8aHJ0ZSBFaW50csOkZ2UiCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzc5CisjOiBidWlsdGluL2NoZWNrb3V0LmM6MTc4OAogbXNnaWQgInVzZSBvdmVybGF5IG1vZGUiCiBtc2dzdHIgImJlbnV0emUgT3ZlcmxheS1Nb2R1cyIKIApAQCAtMTA5MzgsNyArMTA5NzQsNyBAQAogbXNnaWQgImNvdWxkIG5vdCBsc3RhdCAlc1xuIgogbXNnc3RyICJLb25udGUgJ2xzdGF0JyBuaWNodCBmw7xyICVzIGF1c2bDvGhyZW5cbiIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjMwMCBnaXQtYWRkLS1pbnRlcmFjdGl2ZS5wZXJsOjU5MworIzogYnVpbHRpbi9jbGVhbi5jOjMwMSBnaXQtYWRkLS1pbnRlcmFjdGl2ZS5wZXJsOjU5MwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiUHJvbXB0IGhlbHA6XG4iCkBAIC0xMDk1MSw3ICsxMDk4Nyw3IEBACiAiZm9vICAgICAgICAtIEVsZW1lbnQgYW5oYW5kIGVpbmVzIGVpbmRldXRpZ2VuIFByw6RmaXggYXVzd8OkaGxlblxuIgogIiAgICAgICAgICAgLSAobGVlcikgbmljaHRzIGF1c3fDpGhsZW5cbiIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjMwNCBnaXQtYWRkLS1pbnRlcmFjdGl2ZS5wZXJsOjYwMgorIzogYnVpbHRpbi9jbGVhbi5jOjMwNSBnaXQtYWRkLS1pbnRlcmFjdGl2ZS5wZXJsOjYwMgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiUHJvbXB0IGhlbHA6XG4iCkBAIC0xMDk3MiwzOCArMTEwMDgsMzggQEAKICIqICAgICAgICAgIC0gYWxsZSBFbGVtZW50ZSBhdXN3w6RobGVuXG4iCiAiICAgICAgICAgICAtIChsZWVyKSBBdXN3YWhsIGJlZW5kZW5cbiIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjUyMCBnaXQtYWRkLS1pbnRlcmFjdGl2ZS5wZXJsOjU2OAorIzogYnVpbHRpbi9jbGVhbi5jOjUyMSBnaXQtYWRkLS1pbnRlcmFjdGl2ZS5wZXJsOjU2OAogIzogZ2l0LWFkZC0taW50ZXJhY3RpdmUucGVybDo1NzMKICMsIGMtZm9ybWF0LCBwZXJsLWZvcm1hdAogbXNnaWQgIkh1aCAoJXMpP1xuIgogbXNnc3RyICJXaWUgYml0dGUgKCVzKT9cbiIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjY2MgorIzogYnVpbHRpbi9jbGVhbi5jOjY2MwogIywgYy1mb3JtYXQKIG1zZ2lkICJJbnB1dCBpZ25vcmUgcGF0dGVybnM+PiAiCiBtc2dzdHIgIklnbm9yaWVyLU11c3RlciBlaW5nZWJlbj4+ICIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjY5OQorIzogYnVpbHRpbi9jbGVhbi5jOjcwMAogIywgYy1mb3JtYXQKIG1zZ2lkICJXQVJOSU5HOiBDYW5ub3QgZmluZCBpdGVtcyBtYXRjaGVkIGJ5OiAlcyIKIG1zZ3N0ciAiV0FSTlVORzogS2FubiBrZWluZSBFaW50csOkZ2UgZmluZGVuIGRpZSBNdXN0ZXIgZW50c3ByZWNoZW46ICVzIgogCi0jOiBidWlsdGluL2NsZWFuLmM6NzIwCisjOiBidWlsdGluL2NsZWFuLmM6NzIxCiBtc2dpZCAiU2VsZWN0IGl0ZW1zIHRvIGRlbGV0ZSIKIG1zZ3N0ciAiV8OkaGxlbiBTaWUgRWludHLDpGdlIHp1bSBMw7ZzY2hlbiIKIAogIy4gVFJBTlNMQVRPUlM6IE1ha2Ugc3VyZSB0byBrZWVwIFt5L05dIGFzIGlzCi0jOiBidWlsdGluL2NsZWFuLmM6NzYxCisjOiBidWlsdGluL2NsZWFuLmM6NzYyCiAjLCBjLWZvcm1hdAogbXNnaWQgIlJlbW92ZSAlcyBbeS9OXT8gIgogbXNnc3RyICInJXMnIGzDtnNjaGVuIFt5L05dPyAiCiAKLSM6IGJ1aWx0aW4vY2xlYW4uYzo3ODYgZ2l0LWFkZC0taW50ZXJhY3RpdmUucGVybDoxNzYzCisjOiBidWlsdGluL2NsZWFuLmM6Nzg3IGdpdC1hZGQtLWludGVyYWN0aXZlLnBlcmw6MTc2MwogIywgYy1mb3JtYXQKIG1zZ2lkICJCeWUuXG4iCiBtc2dzdHIgIlRzY2jDvHNzLlxuIgogCi0jOiBidWlsdGluL2NsZWFuLmM6Nzk0CisjOiBidWlsdGluL2NsZWFuLmM6Nzk1CiBtc2dpZCAiIgogImNsZWFuICAgICAgICAgICAgICAgLSBzdGFydCBjbGVhbmluZ1xuIgogImZpbHRlciBieSBwYXR0ZXJuICAgLSBleGNsdWRlIGl0ZW1zIGZyb20gZGVsZXRpb25cbiIKQEAgLTExMDIxLDY0ICsxMTA1Nyw2NCBAQAogImhlbHAgICAgICAgICAgICAgICAgLSBkaWVzZSBNZWxkdW5nIGFuemVpZ2VuXG4iCiAiPyAgICAgICAgICAgICAgICAgICAtIEhpbGZlIHp1ciBBdXN3YWhsIG1pdHRlbHMgRWluZ2FiZSBhbnplaWdlbiIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjgyMSBnaXQtYWRkLS1pbnRlcmFjdGl2ZS5wZXJsOjE4NDkKKyM6IGJ1aWx0aW4vY2xlYW4uYzo4MjIgZ2l0LWFkZC0taW50ZXJhY3RpdmUucGVybDoxODQ5CiBtc2dpZCAiKioqIENvbW1hbmRzICoqKiIKIG1zZ3N0ciAiKioqIEJlZmVobGUgKioqIgogCi0jOiBidWlsdGluL2NsZWFuLmM6ODIyIGdpdC1hZGQtLWludGVyYWN0aXZlLnBlcmw6MTg0NgorIzogYnVpbHRpbi9jbGVhbi5jOjgyMyBnaXQtYWRkLS1pbnRlcmFjdGl2ZS5wZXJsOjE4NDYKIG1zZ2lkICJXaGF0IG5vdyIKIG1zZ3N0ciAiV2FzIG51biIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjgzMAorIzogYnVpbHRpbi9jbGVhbi5jOjgzMQogbXNnaWQgIldvdWxkIHJlbW92ZSB0aGUgZm9sbG93aW5nIGl0ZW06IgogbXNnaWRfcGx1cmFsICJXb3VsZCByZW1vdmUgdGhlIGZvbGxvd2luZyBpdGVtczoiCiBtc2dzdHJbMF0gIlfDvHJkZSBkYXMgZm9sZ2VuZGUgRWxlbWVudCBlbnRmZXJuZW46IgogbXNnc3RyWzFdICJXw7xyZGUgZGllIGZvbGdlbmRlbiBFbGVtZW50ZSBlbnRmZXJuZW46IgogCi0jOiBidWlsdGluL2NsZWFuLmM6ODQ2CisjOiBidWlsdGluL2NsZWFuLmM6ODQ3CiBtc2dpZCAiTm8gbW9yZSBmaWxlcyB0byBjbGVhbiwgZXhpdGluZy4iCiBtc2dzdHIgIktlaW5lIERhdGVpZW4gbWVociB6dW0gTMO2c2NoZW4sIGJlZW5kZS4iCiAKLSM6IGJ1aWx0aW4vY2xlYW4uYzo5MDgKKyM6IGJ1aWx0aW4vY2xlYW4uYzo5MDkKIG1zZ2lkICJkbyBub3QgcHJpbnQgbmFtZXMgb2YgZmlsZXMgcmVtb3ZlZCIKIG1zZ3N0ciAia2VpbmUgTmFtZW4gdm9uIGdlbMO2c2NodGVuIERhdGVpZW4gYXVzZ2ViZW4iCiAKLSM6IGJ1aWx0aW4vY2xlYW4uYzo5MTAKKyM6IGJ1aWx0aW4vY2xlYW4uYzo5MTEKIG1zZ2lkICJmb3JjZSIKIG1zZ3N0ciAiQWt0aW9uIGVyendpbmdlbiIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjkxMQorIzogYnVpbHRpbi9jbGVhbi5jOjkxMgogbXNnaWQgImludGVyYWN0aXZlIGNsZWFuaW5nIgogbXNnc3RyICJpbnRlcmFrdGl2ZXMgQ2xlYW4iCiAKLSM6IGJ1aWx0aW4vY2xlYW4uYzo5MTMKKyM6IGJ1aWx0aW4vY2xlYW4uYzo5MTQKIG1zZ2lkICJyZW1vdmUgd2hvbGUgZGlyZWN0b3JpZXMiCiBtc2dzdHIgImdhbnplIFZlcnplaWNobmlzc2UgbMO2c2NoZW4iCiAKLSM6IGJ1aWx0aW4vY2xlYW4uYzo5MTQgYnVpbHRpbi9kZXNjcmliZS5jOjU0NiBidWlsdGluL2Rlc2NyaWJlLmM6NTQ4Ci0jOiBidWlsdGluL2dyZXAuYzo4OTkgYnVpbHRpbi9sb2cuYzoxNzYgYnVpbHRpbi9sb2cuYzoxNzgKLSM6IGJ1aWx0aW4vbHMtZmlsZXMuYzo1NTcgYnVpbHRpbi9uYW1lLXJldi5jOjQxMyBidWlsdGluL25hbWUtcmV2LmM6NDE1CisjOiBidWlsdGluL2NsZWFuLmM6OTE1IGJ1aWx0aW4vZGVzY3JpYmUuYzo1NDggYnVpbHRpbi9kZXNjcmliZS5jOjU1MAorIzogYnVpbHRpbi9ncmVwLmM6OTAxIGJ1aWx0aW4vbG9nLmM6MTc2IGJ1aWx0aW4vbG9nLmM6MTc4CisjOiBidWlsdGluL2xzLWZpbGVzLmM6NTU3IGJ1aWx0aW4vbmFtZS1yZXYuYzo0MTcgYnVpbHRpbi9uYW1lLXJldi5jOjQxOQogIzogYnVpbHRpbi9zaG93LXJlZi5jOjE3OQogbXNnaWQgInBhdHRlcm4iCiBtc2dzdHIgIk11c3RlciIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjkxNQorIzogYnVpbHRpbi9jbGVhbi5jOjkxNgogbXNnaWQgImFkZCA8cGF0dGVybj4gdG8gaWdub3JlIHJ1bGVzIgogbXNnc3RyICI8TXVzdGVyPiB6dSBkZW4gUmVnZWxuIGbDvHIgaWdub3JpZXJ0ZSBQZmFkZSBoaW56dWbDvGdlbiIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjkxNgorIzogYnVpbHRpbi9jbGVhbi5jOjkxNwogbXNnaWQgInJlbW92ZSBpZ25vcmVkIGZpbGVzLCB0b28iCiBtc2dzdHIgImF1Y2ggaWdub3JpZXJ0ZSBEYXRlaWVuIGzDtnNjaGVuIgogCi0jOiBidWlsdGluL2NsZWFuLmM6OTE4CisjOiBidWlsdGluL2NsZWFuLmM6OTE5CiBtc2dpZCAicmVtb3ZlIG9ubHkgaWdub3JlZCBmaWxlcyIKIG1zZ3N0ciAibnVyIGlnbm9yaWVydGUgRGF0ZWllbiBsw7ZzY2hlbiIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjkzNgorIzogYnVpbHRpbi9jbGVhbi5jOjkzNwogbXNnaWQgIi14IGFuZCAtWCBjYW5ub3QgYmUgdXNlZCB0b2dldGhlciIKIG1zZ3N0ciAiRGllIE9wdGlvbmVuIC14IHVuZCAtWCBrw7ZubmVuIG5pY2h0IGdlbWVpbnNhbSB2ZXJ3ZW5kZXQgd2VyZGVuLiIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjk0MAorIzogYnVpbHRpbi9jbGVhbi5jOjk0MQogbXNnaWQgIiIKICJjbGVhbi5yZXF1aXJlRm9yY2Ugc2V0IHRvIHRydWUgYW5kIG5laXRoZXIgLWksIC1uLCBub3IgLWYgZ2l2ZW47IHJlZnVzaW5nIHRvICIKICJjbGVhbiIKQEAgLTExMDg2LDcgKzExMTIyLDcgQEAKICJjbGVhbi5yZXF1aXJlRm9yY2UgYXVmIFwidHJ1ZVwiIGdlc2V0enQgdW5kIHdlZGVyIC1pLCAtbiBub2NoIC1mIGdlZ2ViZW47ICIKICJcImNsZWFuXCIgdmVyd2VpZ2VydCIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjk0MworIzogYnVpbHRpbi9jbGVhbi5jOjk0NAogbXNnaWQgIiIKICJjbGVhbi5yZXF1aXJlRm9yY2UgZGVmYXVsdHMgdG8gdHJ1ZSBhbmQgbmVpdGhlciAtaSwgLW4sIG5vciAtZiBnaXZlbjsgIgogInJlZnVzaW5nIHRvIGNsZWFuIgpAQCAtMTEwOTQsMTY2ICsxMTEzMCwxNjYgQEAKICJjbGVhbi5yZXF1aXJlRm9yY2Ugc3RhbmRhcmRtw6TDn2lnIGF1ZiBcInRydWVcIiBnZXNldHp0IHVuZCB3ZWRlciAtaSwgLW4gbm9jaCAtIgogImYgZ2VnZWJlbjsgXCJjbGVhblwiIHZlcndlaWdlcnQiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo0NgorIzogYnVpbHRpbi9jbG9uZS5jOjQ1CiBtc2dpZCAiZ2l0IGNsb25lIFs8b3B0aW9ucz5dIFstLV0gPHJlcG8+IFs8ZGlyPl0iCiBtc2dzdHIgImdpdCBjbG9uZSBbPE9wdGlvbmVuPl0gWy0tXSA8UmVwb3NpdG9yeT4gWzxWZXJ6ZWljaG5pcz5dIgogCi0jOiBidWlsdGluL2Nsb25lLmM6OTMKKyM6IGJ1aWx0aW4vY2xvbmUuYzo5MgogbXNnaWQgImRvbid0IGNyZWF0ZSBhIGNoZWNrb3V0IgogbXNnc3RyICJrZWluIEF1c2NoZWNrZW4iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo5NCBidWlsdGluL2Nsb25lLmM6OTYgYnVpbHRpbi9pbml0LWRiLmM6NDg5CisjOiBidWlsdGluL2Nsb25lLmM6OTMgYnVpbHRpbi9jbG9uZS5jOjk1IGJ1aWx0aW4vaW5pdC1kYi5jOjQ4OQogbXNnaWQgImNyZWF0ZSBhIGJhcmUgcmVwb3NpdG9yeSIKIG1zZ3N0ciAiZWluIEJhcmUtUmVwb3NpdG9yeSBlcnN0ZWxsZW4iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo5OAorIzogYnVpbHRpbi9jbG9uZS5jOjk3CiBtc2dpZCAiY3JlYXRlIGEgbWlycm9yIHJlcG9zaXRvcnkgKGltcGxpZXMgYmFyZSkiCiBtc2dzdHIgImVpbiBTcGllZ2VsYXJjaGl2IGVyc3RlbGxlbiAoaW1wbGl6aWVydCAtLWJhcmUpIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTAwCisjOiBidWlsdGluL2Nsb25lLmM6OTkKIG1zZ2lkICJ0byBjbG9uZSBmcm9tIGEgbG9jYWwgcmVwb3NpdG9yeSIKIG1zZ3N0ciAidm9uIGVpbmVtIGxva2FsZW4gUmVwb3NpdG9yeSBrbG9uZW4iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMDIKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMDEKIG1zZ2lkICJkb24ndCB1c2UgbG9jYWwgaGFyZGxpbmtzLCBhbHdheXMgY29weSIKIG1zZ3N0ciAibG9rYWwga2VpbmUgaGFydGVuIFZlcndlaXNlIHZlcndlbmRlbiwgaW1tZXIgS29waWVuIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTA0CisjOiBidWlsdGluL2Nsb25lLmM6MTAzCiBtc2dpZCAic2V0dXAgYXMgc2hhcmVkIHJlcG9zaXRvcnkiCiBtc2dzdHIgImFscyB2ZXJ0ZWlsdGVzIFJlcG9zaXRvcnkgZWlucmljaHRlbiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEwNworIzogYnVpbHRpbi9jbG9uZS5jOjEwNgogbXNnaWQgInBhdGhzcGVjIgogbXNnc3RyICJQZmFkc3BlemlmaWthdGlvbiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEwNworIzogYnVpbHRpbi9jbG9uZS5jOjEwNgogbXNnaWQgImluaXRpYWxpemUgc3VibW9kdWxlcyBpbiB0aGUgY2xvbmUiCiBtc2dzdHIgIlN1Ym1vZHVsZSBpbSBLbG9uIGluaXRpYWxpc2llcmVuIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTEwCisjOiBidWlsdGluL2Nsb25lLmM6MTA5CiBtc2dpZCAibnVtYmVyIG9mIHN1Ym1vZHVsZXMgY2xvbmVkIGluIHBhcmFsbGVsIgogbXNnc3RyICJBbnphaGwgZGVyIHBhcmFsbGVsIHp1IGtsb25lbmRlbiBTdWJtb2R1bGUiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMTEgYnVpbHRpbi9pbml0LWRiLmM6NDg2CisjOiBidWlsdGluL2Nsb25lLmM6MTEwIGJ1aWx0aW4vaW5pdC1kYi5jOjQ4NgogbXNnaWQgInRlbXBsYXRlLWRpcmVjdG9yeSIKIG1zZ3N0ciAiVm9ybGFnZW52ZXJ6ZWljaG5pcyIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjExMiBidWlsdGluL2luaXQtZGIuYzo0ODcKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMTEgYnVpbHRpbi9pbml0LWRiLmM6NDg3CiBtc2dpZCAiZGlyZWN0b3J5IGZyb20gd2hpY2ggdGVtcGxhdGVzIHdpbGwgYmUgdXNlZCIKIG1zZ3N0ciAiVmVyemVpY2huaXMsIHZvbiB3ZWxjaGVtIGRpZSBWb3JsYWdlbiB2ZXJ3ZW5kZXQgd2VyZGVuIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTE0IGJ1aWx0aW4vY2xvbmUuYzoxMTYgYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjEzODAKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMTMgYnVpbHRpbi9jbG9uZS5jOjExNSBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6MTM4MAogIzogYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjE4NjAKIG1zZ2lkICJyZWZlcmVuY2UgcmVwb3NpdG9yeSIKIG1zZ3N0ciAiUmVwb3NpdG9yeSByZWZlcmVuemllcmVuIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTE4IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxMzgyCisjOiBidWlsdGluL2Nsb25lLmM6MTE3IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxMzgyCiAjOiBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6MTg2MgogbXNnaWQgInVzZSAtLXJlZmVyZW5jZSBvbmx5IHdoaWxlIGNsb25pbmciCiBtc2dzdHIgIi0tcmVmZXJlbmNlIG51ciB3w6RocmVuZCBkZXMgS2xvbmVucyBiZW51dHplbiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjExOSBidWlsdGluL2NvbHVtbi5jOjI3IGJ1aWx0aW4vbWVyZ2UtZmlsZS5jOjQ2Ci0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMTQgYnVpbHRpbi9yZXBhY2suYzozMTkKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMTggYnVpbHRpbi9jb2x1bW4uYzoyNyBidWlsdGluL21lcmdlLWZpbGUuYzo0NgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjk0IGJ1aWx0aW4vcmVwYWNrLmM6MzIwCiBtc2dpZCAibmFtZSIKIG1zZ3N0ciAiTmFtZSIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEyMAorIzogYnVpbHRpbi9jbG9uZS5jOjExOQogbXNnaWQgInVzZSA8bmFtZT4gaW5zdGVhZCBvZiAnb3JpZ2luJyB0byB0cmFjayB1cHN0cmVhbSIKIG1zZ3N0ciAiPE5hbWU+IHN0YXR0ICdvcmlnaW4nIGbDvHIgVXBzdHJlYW0tUmVwb3NpdG9yeSB2ZXJ3ZW5kZW4iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMjIKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMjEKIG1zZ2lkICJjaGVja291dCA8YnJhbmNoPiBpbnN0ZWFkIG9mIHRoZSByZW1vdGUncyBIRUFEIgogbXNnc3RyICI8QnJhbmNoPiBhdXNjaGVja2VuLCBhbnN0YXR0IEhFQUQgZGVzIFJlbW90ZS1SZXBvc2l0b3JpZXMiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMjQKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMjMKIG1zZ2lkICJwYXRoIHRvIGdpdC11cGxvYWQtcGFjayBvbiB0aGUgcmVtb3RlIgogbXNnc3RyICJQZmFkIHp1IFwiZ2l0LXVwbG9hZC1wYWNrXCIgYXVmIGRlciBHZWdlbnNlaXRlIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTI1IGJ1aWx0aW4vZmV0Y2guYzoxNTIgYnVpbHRpbi9ncmVwLmM6ODM4Ci0jOiBidWlsdGluL3B1bGwuYzoyMjYKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMjQgYnVpbHRpbi9mZXRjaC5jOjE2NyBidWlsdGluL2dyZXAuYzo4NDAKKyM6IGJ1aWx0aW4vcHVsbC5jOjIyNwogbXNnaWQgImRlcHRoIgogbXNnc3RyICJUaWVmZSIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEyNgorIzogYnVpbHRpbi9jbG9uZS5jOjEyNQogbXNnaWQgImNyZWF0ZSBhIHNoYWxsb3cgY2xvbmUgb2YgdGhhdCBkZXB0aCIKIG1zZ3N0ciAiIgogImVpbmVuIEtsb24gbWl0IHVudm9sbHN0w6RuZGlnZXIgSGlzdG9yaWUgKHNoYWxsb3cpIGluIGRpZXNlciBUaWVmZSBlcnN0ZWxsZW4iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMjcgYnVpbHRpbi9mZXRjaC5jOjE1NCBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMDMKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMjYgYnVpbHRpbi9mZXRjaC5jOjE2OSBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyODMKIG1zZ2lkICJ0aW1lIgogbXNnc3RyICJaZWl0IgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTI4CisjOiBidWlsdGluL2Nsb25lLmM6MTI3CiBtc2dpZCAiY3JlYXRlIGEgc2hhbGxvdyBjbG9uZSBzaW5jZSBhIHNwZWNpZmljIHRpbWUiCiBtc2dzdHIgIiIKICJlaW5lbiBLbG9uIG1pdCB1bnZvbGxzdMOkbmRpZ2VyIEhpc3RvcmllIChzaGFsbG93KSBzZWl0IGVpbmVyIGJlc3RpbW10ZW4gIgogIlplaXRcbiIKICJlcnN0ZWxsZW4iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMjkgYnVpbHRpbi9mZXRjaC5jOjE1NiBidWlsdGluL2ZldGNoLmM6MTc5Ci0jOiBidWlsdGluL3JlYmFzZS5jOjEzOTUKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMjggYnVpbHRpbi9mZXRjaC5jOjE3MSBidWlsdGluL2ZldGNoLmM6MTk0CisjOiBidWlsdGluL3JlYmFzZS5jOjE0MTcKIG1zZ2lkICJyZXZpc2lvbiIKIG1zZ3N0ciAiQ29tbWl0IgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTMwIGJ1aWx0aW4vZmV0Y2guYzoxNTcKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMjkgYnVpbHRpbi9mZXRjaC5jOjE3MgogbXNnaWQgImRlZXBlbiBoaXN0b3J5IG9mIHNoYWxsb3cgY2xvbmUsIGV4Y2x1ZGluZyByZXYiCiBtc2dzdHIgIiIKICJkaWUgSGlzdG9yaWUgZWluZXMgS2xvbnMgbWl0IHVudm9sbHN0w6RuZGlnZXIgSGlzdG9yaWUgKHNoYWxsb3cpIG1pdHRlbHNcbiIKICJBdXNzY2hsdXNzIGVpbmVzIENvbW1pdHMgdmVydGllZmVuIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTMyCisjOiBidWlsdGluL2Nsb25lLmM6MTMxCiBtc2dpZCAiY2xvbmUgb25seSBvbmUgYnJhbmNoLCBIRUFEIG9yIC0tYnJhbmNoIgogbXNnc3RyICJudXIgZWluZW4gQnJhbmNoIGtsb25lbiwgSEVBRCBvZGVyIC0tYnJhbmNoIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTM0CisjOiBidWlsdGluL2Nsb25lLmM6MTMzCiBtc2dpZCAiZG9uJ3QgY2xvbmUgYW55IHRhZ3MsIGFuZCBtYWtlIGxhdGVyIGZldGNoZXMgbm90IHRvIGZvbGxvdyB0aGVtIgogbXNnc3RyICJrZWluZSBUYWdzIGtsb25lbiwgdW5kIGF1Y2ggYmVpIHNww6R0ZXJlbiBBYnJ1ZmVuIG5pY2h0IGJlYWNodGVuIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTM2CisjOiBidWlsdGluL2Nsb25lLmM6MTM1CiBtc2dpZCAiYW55IGNsb25lZCBzdWJtb2R1bGVzIHdpbGwgYmUgc2hhbGxvdyIKIG1zZ3N0ciAiamVkZXMgZ2VrbG9udGUgU3VibW9kdWwgbWl0IHVudm9sbHN0w6RuZGlnZXIgSGlzdG9yaWUgKHNoYWxsb3cpIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTM3IGJ1aWx0aW4vaW5pdC1kYi5jOjQ5NQorIzogYnVpbHRpbi9jbG9uZS5jOjEzNiBidWlsdGluL2luaXQtZGIuYzo0OTUKIG1zZ2lkICJnaXRkaXIiCiBtc2dzdHIgIi5naXQtVmVyemVpY2huaXMiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMzggYnVpbHRpbi9pbml0LWRiLmM6NDk2CisjOiBidWlsdGluL2Nsb25lLmM6MTM3IGJ1aWx0aW4vaW5pdC1kYi5jOjQ5NgogbXNnaWQgInNlcGFyYXRlIGdpdCBkaXIgZnJvbSB3b3JraW5nIHRyZWUiCiBtc2dzdHIgIkdpdC1WZXJ6ZWljaG5pcyB2b20gQXJiZWl0c3ZlcnplaWNobmlzIHNlcGFyaWVyZW4iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMzkKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMzgKIG1zZ2lkICJrZXk9dmFsdWUiCiBtc2dzdHIgIlNjaGzDvHNzZWw9V2VydCIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjE0MAorIzogYnVpbHRpbi9jbG9uZS5jOjEzOQogbXNnaWQgInNldCBjb25maWcgaW5zaWRlIHRoZSBuZXcgcmVwb3NpdG9yeSIKIG1zZ3N0ciAiS29uZmlndXJhdGlvbiBpbm5lcmhhbGIgZGVzIG5ldWVuIFJlcG9zaXRvcmllcyBzZXR6ZW4iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxNDIgYnVpbHRpbi9mZXRjaC5jOjE3NCBidWlsdGluL2xzLXJlbW90ZS5jOjc2Ci0jOiBidWlsdGluL3B1c2guYzo1ODUgYnVpbHRpbi9zZW5kLXBhY2suYzoxNzIKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxNDEgYnVpbHRpbi9mZXRjaC5jOjE4OSBidWlsdGluL2xzLXJlbW90ZS5jOjc2CisjOiBidWlsdGluL3B1c2guYzo1NzIgYnVpbHRpbi9zZW5kLXBhY2suYzoxNzIKIG1zZ2lkICJzZXJ2ZXItc3BlY2lmaWMiCiBtc2dzdHIgInNlcnZlcnNwZXppZmlzY2giCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxNDIgYnVpbHRpbi9mZXRjaC5jOjE3NCBidWlsdGluL2xzLXJlbW90ZS5jOjc2Ci0jOiBidWlsdGluL3B1c2guYzo1ODUgYnVpbHRpbi9zZW5kLXBhY2suYzoxNzMKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxNDEgYnVpbHRpbi9mZXRjaC5jOjE4OSBidWlsdGluL2xzLXJlbW90ZS5jOjc2CisjOiBidWlsdGluL3B1c2guYzo1NzIgYnVpbHRpbi9zZW5kLXBhY2suYzoxNzMKIG1zZ2lkICJvcHRpb24gdG8gdHJhbnNtaXQiCiBtc2dzdHIgIk9wdGlvbiDDvGJlcnRyYWdlbiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjE0MyBidWlsdGluL2ZldGNoLmM6MTc1IGJ1aWx0aW4vcHVsbC5jOjIzOQotIzogYnVpbHRpbi9wdXNoLmM6NTg2CisjOiBidWlsdGluL2Nsb25lLmM6MTQyIGJ1aWx0aW4vZmV0Y2guYzoxOTAgYnVpbHRpbi9wdWxsLmM6MjQwCisjOiBidWlsdGluL3B1c2guYzo1NzMKIG1zZ2lkICJ1c2UgSVB2NCBhZGRyZXNzZXMgb25seSIKIG1zZ3N0ciAibnVyIElQdjQtQWRyZXNzZW4gYmVudXR6ZW4iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxNDUgYnVpbHRpbi9mZXRjaC5jOjE3NyBidWlsdGluL3B1bGwuYzoyNDIKLSM6IGJ1aWx0aW4vcHVzaC5jOjU4OAorIzogYnVpbHRpbi9jbG9uZS5jOjE0NCBidWlsdGluL2ZldGNoLmM6MTkyIGJ1aWx0aW4vcHVsbC5jOjI0MworIzogYnVpbHRpbi9wdXNoLmM6NTc1CiBtc2dpZCAidXNlIElQdjYgYWRkcmVzc2VzIG9ubHkiCiBtc2dzdHIgIm51ciBJUHY2LUFkcmVzc2VuIGJlbnV0emVuIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTQ5CisjOiBidWlsdGluL2Nsb25lLmM6MTQ4CiBtc2dpZCAiYW55IGNsb25lZCBzdWJtb2R1bGVzIHdpbGwgdXNlIHRoZWlyIHJlbW90ZS10cmFja2luZyBicmFuY2giCiBtc2dzdHIgImplZGVzIGdla2xvbnRlIFN1Ym1vZHVsIG51dHp0IHNlaW5lbiBSZW1vdGUtVHJhY2tpbmctQnJhbmNoIgogCi0jOiBidWlsdGluL2Nsb25lLmM6Mjg1CisjOiBidWlsdGluL2Nsb25lLmM6Mjg0CiBtc2dpZCAiIgogIk5vIGRpcmVjdG9yeSBuYW1lIGNvdWxkIGJlIGd1ZXNzZWQuXG4iCiAiUGxlYXNlIHNwZWNpZnkgYSBkaXJlY3Rvcnkgb24gdGhlIGNvbW1hbmQgbGluZSIKQEAgLTExMjYxLDQ3ICsxMTI5Nyw0MiBAQAogIktvbm50ZSBrZWluZW4gVmVyemVpY2huaXNuYW1lbiBlcnJhdGVuLlxuIgogIkJpdHRlIGdlYmVuIFNpZSBlaW4gVmVyemVpY2huaXMgYXVmIGRlciBCZWZlaGxzemVpbGUgYW4uIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MzM4CisjOiBidWlsdGluL2Nsb25lLmM6MzM3CiAjLCBjLWZvcm1hdAogbXNnaWQgImluZm86IENvdWxkIG5vdCBhZGQgYWx0ZXJuYXRlIGZvciAnJXMnOiAlc1xuIgogbXNnc3RyICJpbmZvOiBLb25udGUgQWx0ZXJuYXRpdmUgZsO8ciAnJXMnIG5pY2h0IGhpbnp1ZsO8Z2VuOiAlc1xuIgogCi0jOiBidWlsdGluL2Nsb25lLmM6NDExCisjOiBidWlsdGluL2Nsb25lLmM6NDEwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIGV4aXN0cyBhbmQgaXMgbm90IGEgZGlyZWN0b3J5IgogbXNnc3RyICIlcyBleGlzdGllcnQgdW5kIGlzdCBrZWluIFZlcnplaWNobmlzIgogCi0jOiBidWlsdGluL2Nsb25lLmM6NDI4CisjOiBidWlsdGluL2Nsb25lLmM6NDI3CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBzdGFydCBpdGVyYXRvciBvdmVyICclcyciCiBtc2dzdHIgIkZlaGxlciBiZWltIFN0YXJ0ZW4gZGVyIEl0ZXJhdGlvbiDDvGJlciAnJXMnIgogCi0jOiBidWlsdGluL2Nsb25lLmM6NDUzCi0jLCBjLWZvcm1hdAotbXNnaWQgImZhaWxlZCB0byB1bmxpbmsgJyVzJyIKLW1zZ3N0ciAiS29ubnRlICclcycgbmljaHQgZW50ZmVybmVuLiIKLQotIzogYnVpbHRpbi9jbG9uZS5jOjQ1OAorIzogYnVpbHRpbi9jbG9uZS5jOjQ1NwogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gY3JlYXRlIGxpbmsgJyVzJyIKIG1zZ3N0ciAiS29ubnRlIFZlcndlaXMgJyVzJyBuaWNodCBlcnN0ZWxsZW4iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo0NjIKKyM6IGJ1aWx0aW4vY2xvbmUuYzo0NjEKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIGNvcHkgZmlsZSB0byAnJXMnIgogbXNnc3RyICJLb25udGUgRGF0ZWkgbmljaHQgbmFjaCAnJXMnIGtvcGllcmVuIgogCi0jOiBidWlsdGluL2Nsb25lLmM6NDY3CisjOiBidWlsdGluL2Nsb25lLmM6NDY2CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBpdGVyYXRlIG92ZXIgJyVzJyIKIG1zZ3N0ciAiRmVobGVyIGJlaW0gSXRlcmllcmVuIMO8YmVyICclcyciCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo0OTIKKyM6IGJ1aWx0aW4vY2xvbmUuYzo0OTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiZG9uZS5cbiIKIG1zZ3N0ciAiRmVydGlnLlxuIgogCi0jOiBidWlsdGluL2Nsb25lLmM6NTA2CisjOiBidWlsdGluL2Nsb25lLmM6NTA1CiBtc2dpZCAiIgogIkNsb25lIHN1Y2NlZWRlZCwgYnV0IGNoZWNrb3V0IGZhaWxlZC5cbiIKICJZb3UgY2FuIGluc3BlY3Qgd2hhdCB3YXMgY2hlY2tlZCBvdXQgd2l0aCAnZ2l0IHN0YXR1cydcbiIKQEAgLTExMzExLDk3ICsxMTM0Miw5NyBAQAogIlNpZSBrw7ZubmVuIG1pdCAnZ2l0IHN0YXR1cycgcHLDvGZlbiwgd2FzIGF1c2dlY2hlY2t0IHdvcmRlbiBpc3RcbiIKICJ1bmQgZGFzIEF1c2NoZWNrZW4gbWl0ICdnaXQgcmVzdG9yZSAtLXNvdXJjZT1IRUFEIDovJyBlcm5ldXQgdmVyc3VjaGVuLlxuIgogCi0jOiBidWlsdGluL2Nsb25lLmM6NTgzCisjOiBidWlsdGluL2Nsb25lLmM6NTgyCiAjLCBjLWZvcm1hdAogbXNnaWQgIkNvdWxkIG5vdCBmaW5kIHJlbW90ZSBicmFuY2ggJXMgdG8gY2xvbmUuIgogbXNnc3RyICJLb25udGUgenUga2xvbmVuZGVuIFJlbW90ZS1CcmFuY2ggJXMgbmljaHQgZmluZGVuLiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjcwMgorIzogYnVpbHRpbi9jbG9uZS5jOjcwMQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gdXBkYXRlICVzIgogbXNnc3RyICJrYW5uICVzIG5pY2h0IGFrdHVhbGlzaWVyZW4iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo3NTIKKyM6IGJ1aWx0aW4vY2xvbmUuYzo3NTEKIG1zZ2lkICJyZW1vdGUgSEVBRCByZWZlcnMgdG8gbm9uZXhpc3RlbnQgcmVmLCB1bmFibGUgdG8gY2hlY2tvdXQuXG4iCiBtc2dzdHIgIiIKICJFeHRlcm5lciBIRUFEIGJlemllaHQgc2ljaCBhdWYgZWluZSBuaWNodCBleGlzdGllcmVuZGUgUmVmZXJlbnogdW5kIGthbm4gIgogIm5pY2h0IGF1c2dlY2hlY2t0IHdlcmRlbi5cbiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjc4MworIzogYnVpbHRpbi9jbG9uZS5jOjc4MgogbXNnaWQgInVuYWJsZSB0byBjaGVja291dCB3b3JraW5nIHRyZWUiCiBtc2dzdHIgIkFyYmVpdHN2ZXJ6ZWljaG5pcyBrb25udGUgbmljaHQgYXVzZ2VjaGVja3Qgd2VyZGVuIgogCi0jOiBidWlsdGluL2Nsb25lLmM6ODMzCisjOiBidWlsdGluL2Nsb25lLmM6ODMyCiBtc2dpZCAidW5hYmxlIHRvIHdyaXRlIHBhcmFtZXRlcnMgdG8gY29uZmlnIGZpbGUiCiBtc2dzdHIgImtvbm50ZSBQYXJhbWV0ZXIgbmljaHQgaW4gS29uZmlndXJhdGlvbnNkYXRlaSBzY2hyZWliZW4iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo4OTYKKyM6IGJ1aWx0aW4vY2xvbmUuYzo4OTUKIG1zZ2lkICJjYW5ub3QgcmVwYWNrIHRvIGNsZWFuIHVwIgogbXNnc3RyICJLYW5uIFwicmVwYWNrXCIgenVtIEF1ZnLDpHVtZW4gbmljaHQgYXVmcnVmZW4iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo4OTgKKyM6IGJ1aWx0aW4vY2xvbmUuYzo4OTcKIG1zZ2lkICJjYW5ub3QgdW5saW5rIHRlbXBvcmFyeSBhbHRlcm5hdGVzIGZpbGUiCiBtc2dzdHIgIkthbm4gdGVtcG9yw6RyZSBcImFsdGVybmF0ZXNcIi1EYXRlaSBuaWNodCBlbnRmZXJuZW4iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo5MzggYnVpbHRpbi9yZWNlaXZlLXBhY2suYzoxOTUwCisjOiBidWlsdGluL2Nsb25lLmM6OTM3IGJ1aWx0aW4vcmVjZWl2ZS1wYWNrLmM6MTk0OAogbXNnaWQgIlRvbyBtYW55IGFyZ3VtZW50cy4iCiBtc2dzdHIgIlp1IHZpZWxlIEFyZ3VtZW50ZS4iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo5NDIKKyM6IGJ1aWx0aW4vY2xvbmUuYzo5NDEKIG1zZ2lkICJZb3UgbXVzdCBzcGVjaWZ5IGEgcmVwb3NpdG9yeSB0byBjbG9uZS4iCiBtc2dzdHIgIlNpZSBtw7xzc2VuIGVpbiBSZXBvc2l0b3J5IHp1bSBLbG9uZW4gYW5nZWJlbi4iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo5NTUKKyM6IGJ1aWx0aW4vY2xvbmUuYzo5NTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiLS1iYXJlIGFuZCAtLW9yaWdpbiAlcyBvcHRpb25zIGFyZSBpbmNvbXBhdGlibGUuIgogbXNnc3RyICJEaWUgT3B0aW9uZW4gLS1iYXJlIHVuZCAtLW9yaWdpbiAlcyBzaW5kIGlua29tcGF0aWJlbC4iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo5NTgKKyM6IGJ1aWx0aW4vY2xvbmUuYzo5NTcKIG1zZ2lkICItLWJhcmUgYW5kIC0tc2VwYXJhdGUtZ2l0LWRpciBhcmUgaW5jb21wYXRpYmxlLiIKIG1zZ3N0ciAiRGllIE9wdGlvbmVuIC0tYmFyZSB1bmQgLS1zZXBhcmF0ZS1naXQtZGlyIHNpbmQgaW5rb21wYXRpYmVsLiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjk3MQorIzogYnVpbHRpbi9jbG9uZS5jOjk3MAogIywgYy1mb3JtYXQKIG1zZ2lkICJyZXBvc2l0b3J5ICclcycgZG9lcyBub3QgZXhpc3QiCiBtc2dzdHIgIlJlcG9zaXRvcnkgJyVzJyBleGlzdGllcnQgbmljaHQuIgogCi0jOiBidWlsdGluL2Nsb25lLmM6OTc3IGJ1aWx0aW4vZmV0Y2guYzoxNjYwCisjOiBidWlsdGluL2Nsb25lLmM6OTc2IGJ1aWx0aW4vZmV0Y2guYzoxNzkwCiAjLCBjLWZvcm1hdAogbXNnaWQgImRlcHRoICVzIGlzIG5vdCBhIHBvc2l0aXZlIG51bWJlciIKIG1zZ3N0ciAiVGllZmUgJXMgaXN0IGtlaW5lIHBvc2l0aXZlIFphaGwiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo5ODcKKyM6IGJ1aWx0aW4vY2xvbmUuYzo5ODYKICMsIGMtZm9ybWF0CiBtc2dpZCAiZGVzdGluYXRpb24gcGF0aCAnJXMnIGFscmVhZHkgZXhpc3RzIGFuZCBpcyBub3QgYW4gZW1wdHkgZGlyZWN0b3J5LiIKIG1zZ3N0ciAiWmllbHBmYWQgJyVzJyBleGlzdGllcnQgYmVyZWl0cyB1bmQgaXN0IGtlaW4gbGVlcmVzIFZlcnplaWNobmlzLiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjk5NworIzogYnVpbHRpbi9jbG9uZS5jOjk5NgogIywgYy1mb3JtYXQKIG1zZ2lkICJ3b3JraW5nIHRyZWUgJyVzJyBhbHJlYWR5IGV4aXN0cy4iCiBtc2dzdHIgIkFyYmVpdHN2ZXJ6ZWljaG5pcyAnJXMnIGV4aXN0aWVydCBiZXJlaXRzLiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEwMTIgYnVpbHRpbi9jbG9uZS5jOjEwMzMgYnVpbHRpbi9kaWZmdG9vbC5jOjI2NAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjMwMyBidWlsdGluL3dvcmt0cmVlLmM6MzM1CisjOiBidWlsdGluL2Nsb25lLmM6MTAxMSBidWlsdGluL2Nsb25lLmM6MTAzMiBidWlsdGluL2RpZmZ0b29sLmM6MjcxCisjOiBidWlsdGluL2xvZy5jOjE3ODUgYnVpbHRpbi93b3JrdHJlZS5jOjMwMiBidWlsdGluL3dvcmt0cmVlLmM6MzM0CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBjcmVhdGUgbGVhZGluZyBkaXJlY3RvcmllcyBvZiAnJXMnIgogbXNnc3RyICJLb25udGUgZsO8aHJlbmRlIFZlcnplaWNobmlzc2Ugdm9uICclcycgbmljaHQgZXJzdGVsbGVuLiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEwMTcKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMDE2CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBjcmVhdGUgd29yayB0cmVlIGRpciAnJXMnIgogbXNnc3RyICJLb25udGUgQXJiZWl0c3ZlcnplaWNobmlzICclcycgbmljaHQgZXJzdGVsbGVuIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTAzNworIzogYnVpbHRpbi9jbG9uZS5jOjEwMzYKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ2xvbmluZyBpbnRvIGJhcmUgcmVwb3NpdG9yeSAnJXMnLi4uXG4iCiBtc2dzdHIgIktsb25lIGluIEJhcmUtUmVwb3NpdG9yeSAnJXMnIC4uLlxuIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTAzOQorIzogYnVpbHRpbi9jbG9uZS5jOjEwMzgKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ2xvbmluZyBpbnRvICclcycuLi5cbiIKIG1zZ3N0ciAiS2xvbmUgbmFjaCAnJXMnIC4uLlxuIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTA2MworIzogYnVpbHRpbi9jbG9uZS5jOjEwNjIKIG1zZ2lkICIiCiAiY2xvbmUgLS1yZWN1cnNpdmUgaXMgbm90IGNvbXBhdGlibGUgd2l0aCBib3RoIC0tcmVmZXJlbmNlIGFuZCAtLXJlZmVyZW5jZS1pZi0iCiAiYWJsZSIKQEAgLTExNDA5LDQ1ICsxMTQ0MCw0NSBAQAogIidjbG9uZSAtLXJlY3Vyc2l2ZScgaXN0IG5pY2h0IGtvbXBhdGliZWwgbWl0IC0tcmVmZXJlbmNlIHVuZCAtLXJlZmVyZW5jZS1pZi0iCiAiYWJsZSIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjExMjQKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMTIzCiBtc2dpZCAiLS1kZXB0aCBpcyBpZ25vcmVkIGluIGxvY2FsIGNsb25lczsgdXNlIGZpbGU6Ly8gaW5zdGVhZC4iCiBtc2dzdHIgIiIKICJEaWUgT3B0aW9uIC0tZGVwdGggd2lyZCBpbiBsb2thbGVuIEtsb25lbiBpZ25vcmllcnQ7IGJlbnV0emVuIFNpZSAiCiAic3RhdHRkZXNzZW4gZmlsZTovLyIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjExMjYKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMTI1CiBtc2dpZCAiLS1zaGFsbG93LXNpbmNlIGlzIGlnbm9yZWQgaW4gbG9jYWwgY2xvbmVzOyB1c2UgZmlsZTovLyBpbnN0ZWFkLiIKIG1zZ3N0ciAiIgogIi0tc2hhbGxvdy1zaW5jZSB3aXJkIGluIGxva2FsZW4gS2xvbmVuIGlnbm9yaWVydDsgYmVudXR6ZW4gU2llIHN0YXR0ZGVzc2VuICIKICJmaWxlOi8vIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTEyOAorIzogYnVpbHRpbi9jbG9uZS5jOjExMjcKIG1zZ2lkICItLXNoYWxsb3ctZXhjbHVkZSBpcyBpZ25vcmVkIGluIGxvY2FsIGNsb25lczsgdXNlIGZpbGU6Ly8gaW5zdGVhZC4iCiBtc2dzdHIgIiIKICItLXNoYWxsb3ctZXhjbHVkZSB3aXJkIGluIGxva2FsZW4gS2xvbmVuIGlnbm9yaWVydDsgYmVudXR6ZW4gU2llIHN0YXR0ZGVzc2VuICIKICJmaWxlOi8vIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTEzMAorIzogYnVpbHRpbi9jbG9uZS5jOjExMjkKIG1zZ2lkICItLWZpbHRlciBpcyBpZ25vcmVkIGluIGxvY2FsIGNsb25lczsgdXNlIGZpbGU6Ly8gaW5zdGVhZC4iCiBtc2dzdHIgIiIKICItLWZpbHRlciB3aXJkIGluIGxva2FsZW4gS2xvbmVuIGlnbm9yaWVydDsgYmVudXR6ZW4gU2llIHN0YXR0ZGVzc2VuIGZpbGU6Ly8iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMTMzCisjOiBidWlsdGluL2Nsb25lLmM6MTEzMgogbXNnaWQgInNvdXJjZSByZXBvc2l0b3J5IGlzIHNoYWxsb3csIGlnbm9yaW5nIC0tbG9jYWwiCiBtc2dzdHIgIiIKICJRdWVsbGUgaXN0IGVpbiBSZXBvc2l0b3J5IG1pdCB1bnZvbGxzdMOkbmRpZ2VyIEhpc3RvcmllIChzaGFsbG93KSxcbiIKICJpZ25vcmllcmUgLS1sb2NhbCIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjExMzgKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMTM3CiBtc2dpZCAiLS1sb2NhbCBpcyBpZ25vcmVkIgogbXNnc3RyICItLWxvY2FsIHdpcmQgaWdub3JpZXJ0IgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTIxNSBidWlsdGluL2Nsb25lLmM6MTIyMworIzogYnVpbHRpbi9jbG9uZS5jOjEyMTIgYnVpbHRpbi9jbG9uZS5jOjEyMjAKICMsIGMtZm9ybWF0CiBtc2dpZCAiUmVtb3RlIGJyYW5jaCAlcyBub3QgZm91bmQgaW4gdXBzdHJlYW0gJXMiCiBtc2dzdHIgIlJlbW90ZS1CcmFuY2ggJXMgbmljaHQgaW0gVXBzdHJlYW0tUmVwb3NpdG9yeSAlcyBnZWZ1bmRlbiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEyMjYKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMjIzCiBtc2dpZCAiWW91IGFwcGVhciB0byBoYXZlIGNsb25lZCBhbiBlbXB0eSByZXBvc2l0b3J5LiIKIG1zZ3N0ciAiU2llIHNjaGVpbmVuIGVpbiBsZWVyZXMgUmVwb3NpdG9yeSBnZWtsb250IHp1IGhhYmVuLiIKIApAQCAtMTE1MjUsNyArMTE1NTYsNyBAQAogbXNnc3RyICJJRCBlaW5lcyBFbHRlcm4tQ29tbWl0LU9iamVrdGVzLiIKIAogIzogYnVpbHRpbi9jb21taXQtdHJlZS5jOjExNCBidWlsdGluL2NvbW1pdC5jOjE1MDAgYnVpbHRpbi9tZXJnZS5jOjI3MAotIzogYnVpbHRpbi9ub3Rlcy5jOjQwOSBidWlsdGluL25vdGVzLmM6NTc1IGJ1aWx0aW4vc3Rhc2guYzoxNDYwCisjOiBidWlsdGluL25vdGVzLmM6NDA5IGJ1aWx0aW4vbm90ZXMuYzo1NzUgYnVpbHRpbi9zdGFzaC5jOjE0NjkKICM6IGJ1aWx0aW4vdGFnLmM6NDEyCiBtc2dpZCAibWVzc2FnZSIKIG1zZ3N0ciAiQmVzY2hyZWlidW5nIgpAQCAtMTE1MzksNyArMTE1NzAsNyBAQAogbXNnc3RyICJDb21taXQtQmVzY2hyZWlidW5nIHZvbiBEYXRlaSBsZXNlbiIKIAogIzogYnVpbHRpbi9jb21taXQtdHJlZS5jOjEyMSBidWlsdGluL2NvbW1pdC5jOjE1MTIgYnVpbHRpbi9tZXJnZS5jOjI4NwotIzogYnVpbHRpbi9wdWxsLmM6MTk0IGJ1aWx0aW4vcmV2ZXJ0LmM6MTE4CisjOiBidWlsdGluL3B1bGwuYzoxOTUgYnVpbHRpbi9yZXZlcnQuYzoxMTgKIG1zZ2lkICJHUEcgc2lnbiBjb21taXQiCiBtc2dzdHIgIkNvbW1pdCBtaXQgR1BHIHNpZ25pZXJlbiIKIApAQCAtMTE4ODAsOCArMTE5MTEsOCBAQAogbXNnaWQgInZlcnNpb24iCiBtc2dzdHIgIlZlcnNpb24iCiAKLSM6IGJ1aWx0aW4vY29tbWl0LmM6MTM0NyBidWlsdGluL2NvbW1pdC5jOjE1MjkgYnVpbHRpbi9wdXNoLmM6NTYxCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NjUxCisjOiBidWlsdGluL2NvbW1pdC5jOjEzNDcgYnVpbHRpbi9jb21taXQuYzoxNTI5IGJ1aWx0aW4vcHVzaC5jOjU0OAorIzogYnVpbHRpbi93b3JrdHJlZS5jOjY1MAogbXNnaWQgIm1hY2hpbmUtcmVhZGFibGUgb3V0cHV0IgogbXNnc3RyICJtYXNjaGluZW5sZXNiYXJlIEF1c2dhYmUiCiAKQEAgLTExODk0LDggKzExOTI1LDggQEAKIG1zZ3N0ciAiRWludHLDpGdlIG1pdCBOVUwtWmVpY2hlbiBhYnNjaGxpZcOfZW4iCiAKICM6IGJ1aWx0aW4vY29tbWl0LmM6MTM1NSBidWlsdGluL2NvbW1pdC5jOjEzNTkgYnVpbHRpbi9jb21taXQuYzoxNTM3Ci0jOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTEyNSBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTEyOAotIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExMzEgYnVpbHRpbi9yZWJhc2UuYzoxNDcxIHBhcnNlLW9wdGlvbnMuaDozMzIKKyM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTUzIGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTU2CisjOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE1OSBidWlsdGluL3JlYmFzZS5jOjE0OTUgcGFyc2Utb3B0aW9ucy5oOjMzMgogbXNnaWQgIm1vZGUiCiBtc2dzdHIgIk1vZHVzIgogCkBAIC0xMTkxMyw3ICsxMTk0NCw3IEBACiAiaWdub3JpZXJ0ZSBEYXRlaWVuIGFuemVpZ2VuLCBvcHRpb25hbGUgTW9kaTogdHJhZGl0aW9uYWwsIG1hdGNoaW5nLCBuby4gIgogIihTdGFuZGFyZDogdHJhZGl0aW9uYWwpIgogCi0jOiBidWlsdGluL2NvbW1pdC5jOjEzNjIgcGFyc2Utb3B0aW9ucy5oOjE3OQorIzogYnVpbHRpbi9jb21taXQuYzoxMzYyIHBhcnNlLW9wdGlvbnMuaDoxODgKIG1zZ2lkICJ3aGVuIgogbXNnc3RyICJ3YW5uIgogCkBAIC0xMTk2Niw3ICsxMTk5Nyw3IEBACiBtc2dpZCAib3ZlcnJpZGUgYXV0aG9yIGZvciBjb21taXQiCiBtc2dzdHIgIkF1dG9yIGVpbmVzIENvbW1pdHMgw7xiZXJzY2hyZWliZW4iCiAKLSM6IGJ1aWx0aW4vY29tbWl0LmM6MTQ5OSBidWlsdGluL2djLmM6NTM5CisjOiBidWlsdGluL2NvbW1pdC5jOjE0OTkgYnVpbHRpbi9nYy5jOjUzOAogbXNnaWQgImRhdGUiCiBtc2dzdHIgIkRhdHVtIgogCkBAIC0xMjAwMyw4ICsxMjAzNCw4IEBACiBtc2dpZCAidGhlIGNvbW1pdCBpcyBhdXRob3JlZCBieSBtZSBub3cgKHVzZWQgd2l0aCAtQy8tYy8tLWFtZW5kKSIKIG1zZ3N0ciAiU2llIGFscyBBdXRvciBkZXMgQ29tbWl0cyBzZXR6ZW4gKHZlcndlbmRldCBtaXQgLUMvLWMvLS1hbWVuZCkiCiAKLSM6IGJ1aWx0aW4vY29tbWl0LmM6MTUwNiBidWlsdGluL2xvZy5jOjE1NjQgYnVpbHRpbi9tZXJnZS5jOjI4OQotIzogYnVpbHRpbi9wdWxsLmM6MTYzIGJ1aWx0aW4vcmV2ZXJ0LmM6MTEwCisjOiBidWlsdGluL2NvbW1pdC5jOjE1MDYgYnVpbHRpbi9sb2cuYzoxNTY1IGJ1aWx0aW4vbWVyZ2UuYzoyODkKKyM6IGJ1aWx0aW4vcHVsbC5jOjE2NCBidWlsdGluL3JldmVydC5jOjExMAogbXNnaWQgImFkZCBTaWduZWQtb2ZmLWJ5OiIKIG1zZ3N0ciAiJ1NpZ25lZC1vZmYtYnk6Jy1aZWlsZSBoaW56dWbDvGdlbiIKIApAQCAtMTIxMTIsNzEgKzEyMTQzLDc1IEBACiBtc2dzdHIgImdpdCBjb21taXQtZ3JhcGggcmVhZCBbLS1vYmplY3QtZGlyIDxPYmpla3R2ZXJ6ZWljaG5pcz5dIgogCiAjOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjEzIGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTkKLW1zZ2lkICJnaXQgY29tbWl0LWdyYXBoIHZlcmlmeSBbLS1vYmplY3QtZGlyIDxvYmpkaXI+XSBbLS1zaGFsbG93XSIKLW1zZ3N0ciAiZ2l0IGNvbW1pdC1ncmFwaCB2ZXJpZnkgWy0tb2JqZWN0LWRpciA8T2JqZWt0dmVyemVpY2huaXM+XSBbLS1zaGFsbG93XSIKK21zZ2lkICIiCisiZ2l0IGNvbW1pdC1ncmFwaCB2ZXJpZnkgWy0tb2JqZWN0LWRpciA8b2JqZGlyPl0gWy0tc2hhbGxvd10gWy0tW25vLV1wcm9ncmVzc10iCittc2dzdHIgIiIKKyJnaXQgY29tbWl0LWdyYXBoIHZlcmlmeSBbLS1vYmplY3QtZGlyIDxPYmpla3R2ZXJ6ZWljaG5pcz5dIFstLXNoYWxsb3ddIFstLSIKKyJbbm8tXXByb2dyZXNzXSIKIAogIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxNCBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjI5CiBtc2dpZCAiIgogImdpdCBjb21taXQtZ3JhcGggd3JpdGUgWy0tb2JqZWN0LWRpciA8b2JqZGlyPl0gWy0tYXBwZW5kfC0tc3BsaXRdIFstLSIKLSJyZWFjaGFibGV8LS1zdGRpbi1wYWNrc3wtLXN0ZGluLWNvbW1pdHNdIDxzcGxpdCBvcHRpb25zPiIKKyJyZWFjaGFibGV8LS1zdGRpbi1wYWNrc3wtLXN0ZGluLWNvbW1pdHNdIFstLVtuby1dcHJvZ3Jlc3NdIDxzcGxpdCBvcHRpb25zPiIKIG1zZ3N0ciAiIgogImdpdCBjb21taXQtZ3JhcGggd3JpdGUgWy0tb2JqZWN0LWRpciA8T2JqZWt0dmVyemVpY2huaXM+XSBbLS1hcHBlbmR8c3BsaXRdICIKLSJbLS1yZWFjaGFibGV8LS1zdGRpbi1wYWNrc3wtLXN0ZGluLWNvbW1pdHNdIDxTcGxpdC1PcHRpb25lbj4iCisiWy0tcmVhY2hhYmxlfC0tc3RkaW4tcGFja3N8LS1zdGRpbi1jb21taXRzXSBbLS1bbm8tXXByb2dyZXNzXSA8U3BsaXQtIgorIk9wdGlvbmVuPiIKIAotIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzo1NCBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjEwMAotIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxNjEgYnVpbHRpbi9jb21taXQtZ3JhcGguYzoyMzcgYnVpbHRpbi9mZXRjaC5jOjE2MwotIzogYnVpbHRpbi9sb2cuYzoxNTg0CisjOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjU1IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTA3CisjOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE3MCBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjI1NCBidWlsdGluL2ZldGNoLmM6MTc4CisjOiBidWlsdGluL2xvZy5jOjE1ODUKIG1zZ2lkICJkaXIiCiBtc2dzdHIgIlZlcnplaWNobmlzIgogCi0jOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjU1IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTAxCi0jOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE2MiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjIzOAorIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzo1NiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjEwOAorIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxNzEgYnVpbHRpbi9jb21taXQtZ3JhcGguYzoyNTUKIG1zZ2lkICJUaGUgb2JqZWN0IGRpcmVjdG9yeSB0byBzdG9yZSB0aGUgZ3JhcGgiCiBtc2dzdHIgIkRhcyBPYmpla3R2ZXJ6ZWljaG5pcyB6dW0gU3BlaWNoZXJuIGRlcyBHcmFwaGVuLiIKIAotIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzo1NworIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzo1OAogbXNnaWQgImlmIHRoZSBjb21taXQtZ3JhcGggaXMgc3BsaXQsIG9ubHkgdmVyaWZ5IHRoZSB0aXAgZmlsZSIKIG1zZ3N0ciAiIgogIldlbm4gZGVyIENvbW1pdC1HcmFwaCBhdWZnZXRlaWx0IGlzdCwgbnVyIGRpZSBEYXRlaSBhbiBkZXIgU3BpdHplIMO8YmVycHLDvGZlbiIKIAotIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzo3MyBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjExNgorIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzo4MCBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjEyNQogIywgYy1mb3JtYXQKIG1zZ2lkICJDb3VsZCBub3Qgb3BlbiBjb21taXQtZ3JhcGggJyVzJyIKIG1zZ3N0ciAiS29ubnRlIENvbW1pdC1HcmFwaCAnJXMnIG5pY2h0IMO2ZmZuZW4uIgogCi0jOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE2NAorIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxNzMKIG1zZ2lkICJzdGFydCB3YWxrIGF0IGFsbCByZWZzIgogbXNnc3RyICJEdXJjaGxhdWYgYXVmIGFsbGVuIFJlZmVyZW56ZW4gYmVnaW5uZW4iCiAKLSM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTY2CisjOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE3NQogbXNnaWQgInNjYW4gcGFjay1pbmRleGVzIGxpc3RlZCBieSBzdGRpbiBmb3IgY29tbWl0cyIKIG1zZ3N0ciAiZHVyY2ggU3RhbmRhcmQtRWluZ2FiZSBnZWxpc3RldGUgUGFjay1JbmRleGUgbmFjaCBDb21taXRzIHNjYW5uZW4iCiAKLSM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTY4CisjOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE3NwogbXNnaWQgInN0YXJ0IHdhbGsgYXQgY29tbWl0cyBsaXN0ZWQgYnkgc3RkaW4iCiBtc2dzdHIgIkxhdWYgYmVpIENvbW1pdHMgYmVnaW5uZW4sIGRpZSDDvGJlciBkaWUgU3RhbmRhcmQtRWluZ2FiZSBnZWxpc3RldCBzaW5kIgogCi0jOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE3MAorIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxNzkKIG1zZ2lkICJpbmNsdWRlIGFsbCBjb21taXRzIGFscmVhZHkgaW4gdGhlIGNvbW1pdC1ncmFwaCBmaWxlIgogbXNnc3RyICIiCiAiYWxsZSBDb21taXRzIGVpbnNjaGxpZcOfZW4sIGRpZSBzaWNoIGJlcmVpdHMgaW4gZGVyIENvbW1pdC1HcmFwaC1EYXRlaSAiCiAiYmVmaW5kZW4iCiAKLSM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTcyCisjOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE4MgogbXNnaWQgImFsbG93IHdyaXRpbmcgYW4gaW5jcmVtZW50YWwgY29tbWl0LWdyYXBoIGZpbGUiCiBtc2dzdHIgIkVybGF1YmUgZGFzIFNjaHJlaWJlbiBlaW5lciBpbmtyZW1lbnRlbGxlbiBDb21taXQtR3JhcGgtRGF0ZWkiCiAKLSM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTc0IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTc4CisjOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE4NCBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE4OAogbXNnaWQgIm1heGltdW0gbnVtYmVyIG9mIGNvbW1pdHMgaW4gYSBub24tYmFzZSBzcGxpdCBjb21taXQtZ3JhcGgiCiBtc2dzdHIgIiIKICJNYXhpbWFsZSBBbnphaGwgdm9uIENvbW1pdHMgaW4gZWluZW0gYXVmZ2V0ZWlsdGVuIENvbW1pdC1HcmFwaCBvaG5lIEJhc2lzIgogCi0jOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE3NgorIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxODYKIG1zZ2lkICJtYXhpbXVtIHJhdGlvIGJldHdlZW4gdHdvIGxldmVscyBvZiBhIHNwbGl0IGNvbW1pdC1ncmFwaCIKIG1zZ3N0ciAiIgogIk1heGltYWxlcyBWZXJow6RsdG5pcyB6d2lzY2hlbiB6d2VpIEViZW5lbiBlaW5lcyBhdWZnZXRlaWx0ZW4gQ29tbWl0LUdyYXBoIgogCi0jOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE5MQorIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoyMDQKIG1zZ2lkICJ1c2UgYXQgbW9zdCBvbmUgb2YgLS1yZWFjaGFibGUsIC0tc3RkaW4tY29tbWl0cywgb3IgLS1zdGRpbi1wYWNrcyIKIG1zZ3N0ciAiIgogIkJlbnV0emVuIFNpZSBtaW5kZXN0ZW5zIGVpbnMgdm9uIC0tcmVhY2hhYmxlLCAtLXN0ZGluLWNvbW1pdHMsIG9kZXIgLS1zdGRpbi0iCkBAIC0xMjQ5Nyw1OSArMTI1MzIsNTkgQEAKIG1zZ2lkICJwcmludCBzaXplcyBpbiBodW1hbiByZWFkYWJsZSBmb3JtYXQiCiBtc2dzdHIgImdpYnQgR3LDtsOfZW5hbmdhYmVuIGluIG1lbnNjaGVubGVzYmFyZW4gRm9ybWF0IGF1cyIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjI3CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6MjYKIG1zZ2lkICJnaXQgZGVzY3JpYmUgWzxvcHRpb25zPl0gWzxjb21taXQtaXNoPi4uLl0iCiBtc2dzdHIgImdpdCBkZXNjcmliZSBbPE9wdGlvbmVuPl0gWzxDb21taXQtQW5nYWJlPi4uLl0iCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzoyOAorIzogYnVpbHRpbi9kZXNjcmliZS5jOjI3CiBtc2dpZCAiZ2l0IGRlc2NyaWJlIFs8b3B0aW9ucz5dIC0tZGlydHkiCiBtc2dzdHIgImdpdCBkZXNjcmliZSBbPE9wdGlvbmVuPl0gLS1kaXJ0eSIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjYzCisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NjIKIG1zZ2lkICJoZWFkIgogbXNnc3RyICJCcmFuY2giCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo2MworIzogYnVpbHRpbi9kZXNjcmliZS5jOjYyCiBtc2dpZCAibGlnaHR3ZWlnaHQiCiBtc2dzdHIgIm5pY2h0LWFubm90aWVydCIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjYzCisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NjIKIG1zZ2lkICJhbm5vdGF0ZWQiCiBtc2dzdHIgImFubm90aWVydCIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjI3MworIzogYnVpbHRpbi9kZXNjcmliZS5jOjI3NQogIywgYy1mb3JtYXQKIG1zZ2lkICJhbm5vdGF0ZWQgdGFnICVzIG5vdCBhdmFpbGFibGUiCiBtc2dzdHIgImFubm90aWVydGVzIFRhZyAlcyBpc3QgbmljaHQgdmVyZsO8Z2JhciIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjI3NworIzogYnVpbHRpbi9kZXNjcmliZS5jOjI3OQogIywgYy1mb3JtYXQKIG1zZ2lkICJhbm5vdGF0ZWQgdGFnICVzIGhhcyBubyBlbWJlZGRlZCBuYW1lIgogbXNnc3RyICJhbm5vdGllcnRlcyBUYWcgJXMgaGF0IGtlaW5lbiBlaW5nZWJldHRldGVuIE5hbWVuIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6Mjc5CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6MjgxCiAjLCBjLWZvcm1hdAogbXNnaWQgInRhZyAnJXMnIGlzIHJlYWxseSAnJXMnIGhlcmUiCiBtc2dzdHIgIlRhZyAnJXMnIGlzdCBlaWdlbnRsaWNoICclcycgaGllciIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjMyMworIzogYnVpbHRpbi9kZXNjcmliZS5jOjMyNQogIywgYy1mb3JtYXQKIG1zZ2lkICJubyB0YWcgZXhhY3RseSBtYXRjaGVzICclcyciCiBtc2dzdHIgImtlaW4gVGFnIGVudHNwcmljaHQgZXhha3QgJyVzJyIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjMyNQorIzogYnVpbHRpbi9kZXNjcmliZS5jOjMyNwogIywgYy1mb3JtYXQKIG1zZ2lkICJObyBleGFjdCBtYXRjaCBvbiByZWZzIG9yIHRhZ3MsIHNlYXJjaGluZyB0byBkZXNjcmliZVxuIgogbXNnc3RyICIiCiAiS2VpbmUgZXhha3RlIMOcYmVyZWluc3RpbW11bmcgYmVpIFJlZmVyZW56ZW4gb2RlciBUYWdzLCBTdWNoZSB6dW0gIgogIkJlc2NocmVpYmVuXG4iCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzozNzkKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzozODEKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmluaXNoZWQgc2VhcmNoIGF0ICVzXG4iCiBtc2dzdHIgImJlZW5kZXRlIFN1Y2hlIGJlaSAlc1xuIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NDA1CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NDA3CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJObyBhbm5vdGF0ZWQgdGFncyBjYW4gZGVzY3JpYmUgJyVzJy5cbiIKQEAgLTEyNTU4LDcgKzEyNTkzLDcgQEAKICJLZWluZSBhbm5vdGllcnRlbiBUYWdzIGvDtm5uZW4gJyVzJyBiZXNjaHJlaWJlbi5cbiIKICJKZWRvY2ggZ2FiIGVzIG5pY2h0LWFubm90aWVydGUgVGFnczogdmVyc3VjaGVuIFNpZSAtLXRhZ3MuIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NDA5CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NDExCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJObyB0YWdzIGNhbiBkZXNjcmliZSAnJXMnLlxuIgpAQCAtMTI1NjcsMTIgKzEyNjAyLDEyIEBACiAiS2VpbmUgVGFncyBrw7ZubmVuICclcycgYmVzY2hyZWliZW4uXG4iCiAiVmVyc3VjaGVuIFNpZSAtLWFsd2F5cyBvZGVyIGVyc3RlbGxlbiBTaWUgZWluaWdlIFRhZ3MuIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NDM5CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NDQxCiAjLCBjLWZvcm1hdAogbXNnaWQgInRyYXZlcnNlZCAlbHUgY29tbWl0c1xuIgogbXNnc3RyICIlbHUgQ29tbWl0cyBkdXJjaGxhdWZlblxuIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NDQyCisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NDQ0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJtb3JlIHRoYW4gJWkgdGFncyBmb3VuZDsgbGlzdGVkICVpIG1vc3QgcmVjZW50XG4iCkBAIC0xMjU4MSw5NCArMTI2MTYsOTMgQEAKICJtZWhyIGFscyAlaSBUYWdzIGdlZnVuZGVuOyBmw7xocmUgZGllIGVyc3RlbiAlaSBhdWZcbiIKICJTdWNoZSBiZWkgJXMgYXVmZ2VnZWJlblxuIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NTEwCisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NTEyCiAjLCBjLWZvcm1hdAogbXNnaWQgImRlc2NyaWJlICVzXG4iCiBtc2dzdHIgIkJlc2NocmVpYmUgJXNcbiIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjUxMworIzogYnVpbHRpbi9kZXNjcmliZS5jOjUxNQogIywgYy1mb3JtYXQKIG1zZ2lkICJOb3QgYSB2YWxpZCBvYmplY3QgbmFtZSAlcyIKIG1zZ3N0ciAiJXMgaXN0IGtlaW4gZ8O8bHRpZ2VyIE9iamVrdC1OYW1lIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NTIxCisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NTIzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIGlzIG5laXRoZXIgYSBjb21taXQgbm9yIGJsb2IiCiBtc2dzdHIgIiVzIGlzdCB3ZWRlciBlaW4gQ29tbWl0LCBub2NoIGVpbiBCbG9iLiIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjUzNQorIzogYnVpbHRpbi9kZXNjcmliZS5jOjUzNwogbXNnaWQgImZpbmQgdGhlIHRhZyB0aGF0IGNvbWVzIGFmdGVyIHRoZSBjb21taXQiCiBtc2dzdHIgImRhcyBUYWcgZmluZGVuLCBkYXMgbmFjaCBkZW0gQ29tbWl0IGtvbW10IgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NTM2CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NTM4CiBtc2dpZCAiZGVidWcgc2VhcmNoIHN0cmF0ZWd5IG9uIHN0ZGVyciIKIG1zZ3N0ciAiZGllIFN1Y2hzdHJhdGVnaWUgaW4gZGVyIFN0YW5kYXJkLUZlaGxlcmF1c2dhYmUgcHJvdG9rb2xsaWVyZW4iCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1MzcKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1MzkKIG1zZ2lkICJ1c2UgYW55IHJlZiIKIG1zZ3N0ciAiYWxsZSBSZWZlcmVuemVuIHZlcndlbmRlbiIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjUzOAorIzogYnVpbHRpbi9kZXNjcmliZS5jOjU0MAogbXNnaWQgInVzZSBhbnkgdGFnLCBldmVuIHVuYW5ub3RhdGVkIgogbXNnc3RyICJqZWRlcyBUYWcgdmVyd2VuZGVuLCBhdWNoIG5pY2h0LWFubm90aWVydGUiCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1MzkKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1NDEKIG1zZ2lkICJhbHdheXMgdXNlIGxvbmcgZm9ybWF0IgogbXNnc3RyICJpbW1lciBsYW5nZXMgRm9ybWF0IHZlcndlbmRlbiIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjU0MAorIzogYnVpbHRpbi9kZXNjcmliZS5jOjU0MgogbXNnaWQgIm9ubHkgZm9sbG93IGZpcnN0IHBhcmVudCIKIG1zZ3N0ciAibnVyIGVyc3RlbSBFbHRlcm50ZWlsIGZvbGdlbiIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjU0MworIzogYnVpbHRpbi9kZXNjcmliZS5jOjU0NQogbXNnaWQgIm9ubHkgb3V0cHV0IGV4YWN0IG1hdGNoZXMiCiBtc2dzdHIgIm51ciBleGFrdGUgw5xiZXJlaW5zdGltbXVuZ2VuIGF1c2dlYmVuIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NTQ1CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NTQ3CiBtc2dpZCAiY29uc2lkZXIgPG4+IG1vc3QgcmVjZW50IHRhZ3MgKGRlZmF1bHQ6IDEwKSIKIG1zZ3N0ciAiZGllIGrDvG5nc3RlbiA8bj4gVGFncyBiZXRyYWNodGVuIChTdGFuZGFyZDogMTApIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NTQ3CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NTQ5CiBtc2dpZCAib25seSBjb25zaWRlciB0YWdzIG1hdGNoaW5nIDxwYXR0ZXJuPiIKIG1zZ3N0ciAibnVyIFRhZ3MsIGRpZSA8TXVzdGVyPiBlbnRzcHJlY2hlbiwgYmV0cmFjaHRlbiIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjU0OQorIzogYnVpbHRpbi9kZXNjcmliZS5jOjU1MQogbXNnaWQgImRvIG5vdCBjb25zaWRlciB0YWdzIG1hdGNoaW5nIDxwYXR0ZXJuPiIKIG1zZ3N0ciAia2VpbmUgVGFncyBiZXRyYWNodGVuLCBkaWUgPE11c3Rlcj4gZW50c3ByZWNoZW4iCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1NTEgYnVpbHRpbi9uYW1lLXJldi5jOjQyMgorIzogYnVpbHRpbi9kZXNjcmliZS5jOjU1MyBidWlsdGluL25hbWUtcmV2LmM6NDI2CiBtc2dpZCAic2hvdyBhYmJyZXZpYXRlZCBjb21taXQgb2JqZWN0IGFzIGZhbGxiYWNrIgogbXNnc3RyICJnZWvDvHJ6dGVzIENvbW1pdC1PYmpla3QgYW56ZWlnZW4sIHdlbm4gc29uc3QgbmljaHRzIHp1dHJpZmZ0IgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NTUyIGJ1aWx0aW4vZGVzY3JpYmUuYzo1NTUKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1NTQgYnVpbHRpbi9kZXNjcmliZS5jOjU1NwogbXNnaWQgIm1hcmsiCi1tc2dzdHIgIktlbm56ZWljaGVuIgorbXNnc3RyICJNYXJraWVydW5nIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NTUzCisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NTU1CiBtc2dpZCAiYXBwZW5kIDxtYXJrPiBvbiBkaXJ0eSB3b3JraW5nIHRyZWUgKGRlZmF1bHQ6IFwiLWRpcnR5XCIpIgogbXNnc3RyICIiCi0iPEtlbm56ZWljaGVuPiBiZWkgZ2XDpG5kZXJ0ZW0gQXJiZWl0c3ZlcnplaWNobmlzIGFuaMOkbmdlbiAoU3RhbmRhcmQ6IFwiLWRpcnR5IgorIjxNYXJraWVydW5nPiBiZWkgZ2XDpG5kZXJ0ZW0gQXJiZWl0c3ZlcnplaWNobmlzIGFuaMOkbmdlbiAoU3RhbmRhcmQ6IFwiLWRpcnR5IgogIlwiKSIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjU1NgorIzogYnVpbHRpbi9kZXNjcmliZS5jOjU1OAogbXNnaWQgImFwcGVuZCA8bWFyaz4gb24gYnJva2VuIHdvcmtpbmcgdHJlZSAoZGVmYXVsdDogXCItYnJva2VuXCIpIgogbXNnc3RyICIiCi0iPEtlbm56ZWljaGVuPiBiZWkgZGVmZWt0ZW0gQXJiZWl0c3ZlcnplaWNobmlzIGFuaMOkbmdlbiAoU3RhbmRhcmQ6IFwiLWJyb2tlbiIKLSJcIikiCisiPE1hcmtpZXJ1bmc+IGJlaSBkZWZla3RlbSBBcmJlaXRzdmVyemVpY2huaXMgYW5ow6RuZ2VuIChTdGFuZGFyZDogXCItYnJva2VuXCIpIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NTc0CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NTc2CiBtc2dpZCAiLS1sb25nIGlzIGluY29tcGF0aWJsZSB3aXRoIC0tYWJicmV2PTAiCiBtc2dzdHIgIkRpZSBPcHRpb25lbiAtLWxvbmcgdW5kIC0tYWJicmV2PTAgc2luZCBpbmtvbXBhdGliZWwuIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NjAzCisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NjA1CiBtc2dpZCAiTm8gbmFtZXMgZm91bmQsIGNhbm5vdCBkZXNjcmliZSBhbnl0aGluZy4iCiBtc2dzdHIgIktlaW5lIE5hbWVuIGdlZnVuZGVuLCBrYW5uIG5pY2h0cyBiZXNjaHJlaWJlbi4iCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo2NTQKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo2NTYKIG1zZ2lkICItLWRpcnR5IGlzIGluY29tcGF0aWJsZSB3aXRoIGNvbW1pdC1pc2hlcyIKIG1zZ3N0ciAiRGllIE9wdGlvbiAtLWRpcnR5IGthbm4gbmljaHQgbWl0IENvbW1pdHMgdmVyd2VuZGV0IHdlcmRlbi4iCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo2NTYKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo2NTgKIG1zZ2lkICItLWJyb2tlbiBpcyBpbmNvbXBhdGlibGUgd2l0aCBjb21taXQtaXNoZXMiCiBtc2dzdHIgIkRpZSBPcHRpb24gLS1icm9rZW4ga2FubiBuaWNodCBtaXQgQ29tbWl0cyB2ZXJ3ZW5kZXQgd2VyZGVuLiIKIApAQCAtMTI3MDUsMjcgKzEyNzM5LDI3IEBACiBtc2dpZCAiZ2l0IGRpZmZ0b29sIFs8b3B0aW9ucz5dIFs8Y29tbWl0PiBbPGNvbW1pdD5dXSBbLS1dIFs8cGF0aD4uLi5dIgogbXNnc3RyICJnaXQgZGlmZnRvb2wgWzxPcHRpb25lbj5dIFs8Q29tbWl0PiBbPENvbW1pdD5dXSBbLS1dIFs8UGZhZD4uLi5dIgogCi0jOiBidWlsdGluL2RpZmZ0b29sLmM6MjUzCisjOiBidWlsdGluL2RpZmZ0b29sLmM6MjYwCiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZDogJWQiCiBtc2dzdHIgImZlaGxnZXNjaGxhZ2VuOiAlZCIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjI5NQorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjMwMgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcmVhZCBzeW1saW5rICVzIgogbXNnc3RyICJrb25udGUgc3ltYm9saXNjaGUgVmVya27DvHBmdW5nICVzIG5pY2h0IGxlc2VuIgogCi0jOiBidWlsdGluL2RpZmZ0b29sLmM6Mjk3CisjOiBidWlsdGluL2RpZmZ0b29sLmM6MzA0CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCByZWFkIHN5bWxpbmsgZmlsZSAlcyIKIG1zZ3N0ciAiS29ubnRlIERhdGVpIHZvbiBzeW1ib2xpc2NoZXIgVmVya27DvHBmdW5nICclcycgbmljaHQgbGVzZW4uIgogCi0jOiBidWlsdGluL2RpZmZ0b29sLmM6MzA1CisjOiBidWlsdGluL2RpZmZ0b29sLmM6MzEyCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCByZWFkIG9iamVjdCAlcyBmb3Igc3ltbGluayAlcyIKIG1zZ3N0ciAiS29ubnRlIE9iamVrdCAnJXMnIGbDvHIgc3ltYm9saXNjaGUgVmVya27DvHBmdW5nICclcycgbmljaHQgbGVzZW4uIgogCi0jOiBidWlsdGluL2RpZmZ0b29sLmM6NDA2CisjOiBidWlsdGluL2RpZmZ0b29sLmM6NDEzCiBtc2dpZCAiIgogImNvbWJpbmVkIGRpZmYgZm9ybWF0cygnLWMnIGFuZCAnLS1jYycpIGFyZSBub3Qgc3VwcG9ydGVkIGluXG4iCiAiZGlyZWN0b3J5IGRpZmYgbW9kZSgnLWQnIGFuZCAnLS1kaXItZGlmZicpLiIKQEAgLTEyNzMzLDU0ICsxMjc2Nyw1NCBAQAogIktvbWJpbmllcnRlIERpZmYtRm9ybWF0ZSgnLWMnIHVuZCAnLS1jYycpIHdlcmRlbiBpbSBWZXJ6ZWljaG5pcy1cbiIKICJEaWZmLU1vZHVzKCctZCcgdW5kICctLWRpci1kaWZmJykgbmljaHQgdW50ZXJzdMO8dHp0LiIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjYyNgorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjYzNAogIywgYy1mb3JtYXQKIG1zZ2lkICJib3RoIGZpbGVzIG1vZGlmaWVkOiAnJXMnIGFuZCAnJXMnLiIKIG1zZ3N0ciAiYmVpZGUgRGF0ZWllbiBnZcOkbmRlcnQ6ICclcycgdW5kICclcycuIgogCi0jOiBidWlsdGluL2RpZmZ0b29sLmM6NjI4CisjOiBidWlsdGluL2RpZmZ0b29sLmM6NjM2CiBtc2dpZCAid29ya2luZyB0cmVlIGZpbGUgaGFzIGJlZW4gbGVmdC4iCiBtc2dzdHIgIkRhdGVpIGltIEFyYmVpdHN2ZXJ6ZWljaG5pcyBiZWxhc3Nlbi4iCiAKLSM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo2MzkKKyM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo2NDcKICMsIGMtZm9ybWF0CiBtc2dpZCAidGVtcG9yYXJ5IGZpbGVzIGV4aXN0IGluICclcycuIgogbXNnc3RyICJFcyBleGlzdGllcmVuIHRlbXBvcsOkcmUgRGF0ZWllbiBpbiAnJXMnLiIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjY0MAorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjY0OAogbXNnaWQgInlvdSBtYXkgd2FudCB0byBjbGVhbnVwIG9yIHJlY292ZXIgdGhlc2UuIgogbXNnc3RyICJTaWUga8O2bm50ZW4gZGllc2UgYXVmcsOkdW1lbiBvZGVyIHdpZWRlcmhlcnN0ZWxsZW4uIgogCi0jOiBidWlsdGluL2RpZmZ0b29sLmM6Njg5CisjOiBidWlsdGluL2RpZmZ0b29sLmM6Njk3CiBtc2dpZCAidXNlIGBkaWZmLmd1aXRvb2xgIGluc3RlYWQgb2YgYGRpZmYudG9vbGAiCiBtc2dzdHIgImBkaWZmLmd1aXRvb2xgIGFuc3RhdHQgYGRpZmYudG9vbGAgYmVudXR6ZW4iCiAKLSM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo2OTEKKyM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo2OTkKIG1zZ2lkICJwZXJmb3JtIGEgZnVsbC1kaXJlY3RvcnkgZGlmZiIKIG1zZ3N0ciAiRGlmZiDDvGJlciBnYW56ZXMgVmVyemVpY2huaXMgYXVzZsO8aHJlbiIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjY5MworIzogYnVpbHRpbi9kaWZmdG9vbC5jOjcwMQogbXNnaWQgImRvIG5vdCBwcm9tcHQgYmVmb3JlIGxhdW5jaGluZyBhIGRpZmYgdG9vbCIKIG1zZ3N0ciAia2VpbmUgRWluZ2FiZWF1ZmZvcmRlcnVuZyB2b3IgQXVzZsO8aHJ1bmcgZWluZXMgRGlmZi1Ub29scyIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjY5OAorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjcwNgogbXNnaWQgInVzZSBzeW1saW5rcyBpbiBkaXItZGlmZiBtb2RlIgogbXNnc3RyICJzeW1ib2xpc2NoZSBWZXJrbsO8cGZ1bmdlbiBpbSBkaXItZGlmZiBNb2R1cyB2ZXJ3ZW5kZW4iCiAKLSM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo2OTkKKyM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo3MDcKIG1zZ2lkICJ0b29sIgogbXNnc3RyICJUb29sIgogCi0jOiBidWlsdGluL2RpZmZ0b29sLmM6NzAwCisjOiBidWlsdGluL2RpZmZ0b29sLmM6NzA4CiBtc2dpZCAidXNlIHRoZSBzcGVjaWZpZWQgZGlmZiB0b29sIgogbXNnc3RyICJkYXMgYW5nZWdlYmVuZSBEaWZmLVRvb2wgYmVudXR6ZW4iCiAKLSM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo3MDIKKyM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo3MTAKIG1zZ2lkICJwcmludCBhIGxpc3Qgb2YgZGlmZiB0b29scyB0aGF0IG1heSBiZSB1c2VkIHdpdGggYC0tdG9vbGAiCiBtc2dzdHIgIiIKICJlaW5lIExpc3RlIG1pdCBEaWZmLVRvb2xzIGRhcnN0ZWxsZW4sIGRpZSBtaXQgYC0tdG9vbGAgYmVudXR6dCB3ZXJkZW4ga8O2bm5lbiIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjcwNQorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjcxMwogbXNnaWQgIiIKICJtYWtlICdnaXQtZGlmZnRvb2wnIGV4aXQgd2hlbiBhbiBpbnZva2VkIGRpZmYgdG9vbCByZXR1cm5zIGEgbm9uIC0gemVybyBleGl0ICIKICJjb2RlIgpAQCAtMTI3ODksMzEgKzEyODIzLDMxIEBACiAiUsO8Y2trZWhyd2VydFxuIgogInZlcnNjaGllZGVuIDAgYXVzZ2Vmw7xocnQgd3VyZGUiCiAKLSM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo3MDgKKyM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo3MTYKIG1zZ2lkICJzcGVjaWZ5IGEgY3VzdG9tIGNvbW1hbmQgZm9yIHZpZXdpbmcgZGlmZnMiCiBtc2dzdHIgImVpZ2VuZW4gQmVmZWhsIHp1ciBBbnplaWdlIHZvbiBVbnRlcnNjaGllZGVuIGFuZ2ViZW4iCiAKLSM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo3MDkKKyM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo3MTcKIG1zZ2lkICJwYXNzZWQgdG8gYGRpZmZgIgogbXNnc3RyICJhbiAnZGlmZicgw7xiZXJnZWJlbiIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjcyNAorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjczMgogbXNnaWQgImRpZmZ0b29sIHJlcXVpcmVzIHdvcmt0cmVlIG9yIC0tbm8taW5kZXgiCiBtc2dzdHIgImRpZmZ0b29sIGJlbsO2dGlndCBBcmJlaXRzdmVyemVpY2huaXMgb2RlciAtLW5vLWluZGV4IgogCi0jOiBidWlsdGluL2RpZmZ0b29sLmM6NzMxCisjOiBidWlsdGluL2RpZmZ0b29sLmM6NzM5CiBtc2dpZCAiLS1kaXItZGlmZiBpcyBpbmNvbXBhdGlibGUgd2l0aCAtLW5vLWluZGV4IgogbXNnc3RyICItLWRpci1kaWZmIGthbm4gbmljaHQgbWl0IC0tbm8taW5kZXggdmVyd2VuZGV0IHdlcmRlbiIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjczNAorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjc0MgogbXNnaWQgIi0tZ3VpLCAtLXRvb2wgYW5kIC0tZXh0Y21kIGFyZSBtdXR1YWxseSBleGNsdXNpdmUiCiBtc2dzdHIgIi0tZ3VpLCAtLXRvb2wgdW5kIC0tZXh0Y21kIHNjaGxpZcOfZW4gc2ljaCBnZWdlbnNlaXRpZyBhdXMiCiAKLSM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo3NDIKKyM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo3NTAKIG1zZ2lkICJubyA8dG9vbD4gZ2l2ZW4gZm9yIC0tdG9vbD08dG9vbD4iCiBtc2dzdHIgImtlaW4gPFRvb2w+IGbDvHIgLS10b29sPTxUb29sPiBhbmdlZ2ViZW4iCiAKLSM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo3NDkKKyM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo3NTcKIG1zZ2lkICJubyA8Y21kPiBnaXZlbiBmb3IgLS1leHRjbWQ9PGNtZD4iCiBtc2dzdHIgImtlaW4gPFByb2dyYW1tPiBmw7xyIC0tZXh0Y21kPTxQcm9ncmFtbT4gYW5nZWdlYmVuIgogCkBAIC0xMjg1MywxNjYgKzEyODg3LDE5NCBAQAogbXNnaWQgImdpdCBmYXN0LWV4cG9ydCBbcmV2LWxpc3Qtb3B0c10iCiBtc2dzdHIgImdpdCBmYXN0LWV4cG9ydCBbcmV2LWxpc3Qtb3B0c10iCiAKLSM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTI0CisjOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6ODUyCittc2dpZCAiRXJyb3I6IENhbm5vdCBleHBvcnQgbmVzdGVkIHRhZ3MgdW5sZXNzIC0tbWFyay10YWdzIGlzIHNwZWNpZmllZC4iCittc2dzdHIgIiIKKyJGZWhsZXI6IFZlcnNjaGFjaHRlbHRlIFRhZ3Mga8O2bm5lbiBuaWNodCBleHBvcnRpZXJ0IHdlcmRlbiwgYXXDn2VyIC0tbWFyay0iCisidGFncyB3dXJkZSBhbmdlZ2ViZW4uIgorCisjOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE1MgogbXNnaWQgInNob3cgcHJvZ3Jlc3MgYWZ0ZXIgPG4+IG9iamVjdHMiCiBtc2dzdHIgIkZvcnRzY2hyaXR0IG5hY2ggPG4+IE9iamVrdGVuIGFuemVpZ2VuIgogCi0jOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTEyNgorIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNTQKIG1zZ2lkICJzZWxlY3QgaGFuZGxpbmcgb2Ygc2lnbmVkIHRhZ3MiCiBtc2dzdHIgIkJlaGFuZGx1bmcgdm9uIHNpZ25pZXJ0ZW4gVGFncyB3w6RobGVuIgogCi0jOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTEyOQorIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNTcKIG1zZ2lkICJzZWxlY3QgaGFuZGxpbmcgb2YgdGFncyB0aGF0IHRhZyBmaWx0ZXJlZCBvYmplY3RzIgogbXNnc3RyICJCZWhhbmRsdW5nIHZvbiBUYWdzIHfDpGhsZW4sIGRpZSBnZWZpbHRlcnRlIE9iamVrdGUgbWFya2llcmVuIgogCi0jOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTEzMgorIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNjAKIG1zZ2lkICJzZWxlY3QgaGFuZGxpbmcgb2YgY29tbWl0IG1lc3NhZ2VzIGluIGFuIGFsdGVybmF0ZSBlbmNvZGluZyIKIG1zZ3N0ciAiIgogIkF1c3fDpGhsZW4gZGVyIEJlaGFuZGx1bmcgdm9uIENvbW1pdC1CZXNjaHJlaWJ1bmdlbiBiZWkgd2VjaHNlbG5kZW0gRW5jb2RpbmciCiAKLSM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTM1CisjOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE2MwogbXNnaWQgIkR1bXAgbWFya3MgdG8gdGhpcyBmaWxlIgotbXNnc3RyICJLZW5uemVpY2hlbiBpbiBkaWVzZSBEYXRlaSBzY2hyZWliZW4iCittc2dzdHIgIk1hcmtpZXJ1bmdlbiBpbiBkaWVzZSBEYXRlaSBzY2hyZWliZW4iCiAKLSM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTM3CisjOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE2NQogbXNnaWQgIkltcG9ydCBtYXJrcyBmcm9tIHRoaXMgZmlsZSIKLW1zZ3N0ciAiS2VubnplaWNoZW4gdm9uIGRpZXNlciBEYXRlaSBpbXBvcnRpZXJlbiIKK21zZ3N0ciAiTWFya2llcnVuZ2VuIHZvbiBkaWVzZXIgRGF0ZWkgaW1wb3J0aWVyZW4iCiAKLSM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTM5CisjOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE2OQorbXNnaWQgIkltcG9ydCBtYXJrcyBmcm9tIHRoaXMgZmlsZSBpZiBpdCBleGlzdHMiCittc2dzdHIgIk1hcmtpZXJ1bmdlbiB2b24gZGllc2VyIERhdGVpIGltcG9ydGllcmVuLCB3ZW5uIGRpZXNlIGV4aXN0aWVydCIKKworIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNzEKIG1zZ2lkICJGYWtlIGEgdGFnZ2VyIHdoZW4gdGFncyBsYWNrIG9uZSIKIG1zZ3N0ciAia8O8bnN0bGljaCBlaW5lbiBUYWctRXJzdGVsbGVyIGVyemV1Z2VuLCB3ZW5uIGRhcyBUYWcga2VpbmVuIGhhdCIKIAotIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNDEKKyM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTczCiBtc2dpZCAiT3V0cHV0IGZ1bGwgdHJlZSBmb3IgZWFjaCBjb21taXQiCiBtc2dzdHIgImbDvHIgamVkZW4gQ29tbWl0IGRhcyBnZXNhbXRlIFZlcnplaWNobmlzIGF1c2dlYmVuIgogCi0jOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE0MworIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNzUKIG1zZ2lkICJVc2UgdGhlIGRvbmUgZmVhdHVyZSB0byB0ZXJtaW5hdGUgdGhlIHN0cmVhbSIKIG1zZ3N0ciAiZGllIFwiZG9uZVwiLUZ1bmt0aW9uIGJlbnV0emVuLCB1bSBkZW4gRGF0ZW5zdHJvbSBhYnp1c2NobGllw59lbiIKIAotIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNDQKKyM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTc2CiBtc2dpZCAiU2tpcCBvdXRwdXQgb2YgYmxvYiBkYXRhIgogbXNnc3RyICJBdXNnYWJlIHZvbiBCbG9iLURhdGVuIMO8YmVyc3ByaW5nZW4iCiAKLSM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTQ1IGJ1aWx0aW4vbG9nLmM6MTYzMgorIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNzcgYnVpbHRpbi9sb2cuYzoxNjMzCiBtc2dpZCAicmVmc3BlYyIKIG1zZ3N0ciAiUmVmc3BlYyIKIAotIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNDYKKyM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTc4CiBtc2dpZCAiQXBwbHkgcmVmc3BlYyB0byBleHBvcnRlZCByZWZzIgogbXNnc3RyICJSZWZzcGVjIGF1ZiBleHBvcnRpZXJ0ZSBSZWZlcmVuemVuIGFud2VuZGVuIgogCi0jOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE0NworIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNzkKIG1zZ2lkICJhbm9ueW1pemUgb3V0cHV0IgogbXNnc3RyICJBdXNnYWJlIGFub255bWlzaWVyZW4iCiAKLSM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTQ5CisjOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE4MQogbXNnaWQgIlJlZmVyZW5jZSBwYXJlbnRzIHdoaWNoIGFyZSBub3QgaW4gZmFzdC1leHBvcnQgc3RyZWFtIGJ5IG9iamVjdCBpZCIKIG1zZ3N0ciAiIgogIkVsdGVybiwgZGllIG5pY2h0IGltIEZhc3QtRXhwb3J0LVN0cmVhbSBzaW5kLCBhbmhhbmQgaWhyZXIgT2JqZWt0LUlEICIKICJyZWZlcmVuemllcmVuIgogCi0jOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE1MQorIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExODMKIG1zZ2lkICJTaG93IG9yaWdpbmFsIG9iamVjdCBpZHMgb2YgYmxvYnMvY29tbWl0cyIKIG1zZ3N0ciAib3JpZ2luYWxlIE9iamVrdC1JRHMgdm9uIEJsb2JzL0NvbW1pdHMgYW56ZWlnZW4iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzozMAorIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExODUKK21zZ2lkICJMYWJlbCB0YWdzIHdpdGggbWFyayBpZHMiCittc2dzdHIgIlRhZ3MgbWl0IE1hcmtpZXJ1bmdzLUlEcyBiZXNjaHJpZnRlbiIKKworIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjEyMjAKK21zZ2lkICJDYW5ub3QgcGFzcyBib3RoIC0taW1wb3J0LW1hcmtzIGFuZCAtLWltcG9ydC1tYXJrcy1pZi1leGlzdHMiCittc2dzdHIgIiIKKyItLWltcG9ydC1tYXJrcyB1bmQgLS1pbXBvcnQtbWFya3MtaWYtZXhpc3RzIGvDtm5uZW4gbmljaHQgenVzYW1tZW4gIgorIndlaXRlcmdlZ2ViZW4gd2VyZGVuIgorCisjOiBidWlsdGluL2ZldGNoLmM6MzQKIG1zZ2lkICJnaXQgZmV0Y2ggWzxvcHRpb25zPl0gWzxyZXBvc2l0b3J5PiBbPHJlZnNwZWM+Li4uXV0iCiBtc2dzdHIgImdpdCBmZXRjaCBbPE9wdGlvbmVuPl0gWzxSZXBvc2l0b3J5PiBbPFJlZnNwZWM+Li4uXV0iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzozMQorIzogYnVpbHRpbi9mZXRjaC5jOjM1CiBtc2dpZCAiZ2l0IGZldGNoIFs8b3B0aW9ucz5dIDxncm91cD4iCiBtc2dzdHIgImdpdCBmZXRjaCBbPE9wdGlvbmVuPl0gPEdydXBwZT4iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzozMgorIzogYnVpbHRpbi9mZXRjaC5jOjM2CiBtc2dpZCAiZ2l0IGZldGNoIC0tbXVsdGlwbGUgWzxvcHRpb25zPl0gWyg8cmVwb3NpdG9yeT4gfCA8Z3JvdXA+KS4uLl0iCiBtc2dzdHIgImdpdCBmZXRjaCAtLW11bHRpcGxlIFs8T3B0aW9uZW4+XSBbKDxSZXBvc2l0b3J5PiB8IDxHcnVwcGU+KS4uLl0iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzozMworIzogYnVpbHRpbi9mZXRjaC5jOjM3CiBtc2dpZCAiZ2l0IGZldGNoIC0tYWxsIFs8b3B0aW9ucz5dIgogbXNnc3RyICJnaXQgZmV0Y2ggLS1hbGwgWzxPcHRpb25lbj5dIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTI1IGJ1aWx0aW4vcHVsbC5jOjIwMworIzogYnVpbHRpbi9mZXRjaC5jOjExNQorbXNnaWQgImZldGNoLnBhcmFsbGVsIGNhbm5vdCBiZSBuZWdhdGl2ZSIKK21zZ3N0ciAiZmV0Y2gucGFyYWxsZWwga2FubiBuaWNodCBuZWdhdGl2IHNlaW4iCisKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxMzggYnVpbHRpbi9wdWxsLmM6MjA0CiBtc2dpZCAiZmV0Y2ggZnJvbSBhbGwgcmVtb3RlcyIKIG1zZ3N0ciAiZm9yZGVydCB2b24gYWxsZW4gUmVtb3RlLVJlcG9zaXRvcmllcyBhbiIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjEyNyBidWlsdGluL3B1bGwuYzoyMDYKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNDAgYnVpbHRpbi9wdWxsLmM6MjQ4Cittc2dpZCAic2V0IHVwc3RyZWFtIGZvciBnaXQgcHVsbC9mZXRjaCIKK21zZ3N0ciAiVXBzdHJlYW0gZsO8ciBcImdpdCBwdWxsL2ZldGNoXCIgc2V0emVuIgorCisjOiBidWlsdGluL2ZldGNoLmM6MTQyIGJ1aWx0aW4vcHVsbC5jOjIwNwogbXNnaWQgImFwcGVuZCB0byAuZ2l0L0ZFVENIX0hFQUQgaW5zdGVhZCBvZiBvdmVyd3JpdGluZyIKIG1zZ3N0ciAiYW4gLmdpdC9GRVRDSF9IRUFEIGFuaMOkbmdlbiwgYW5zdGF0dCB6dSDDvGJlcnNjaHJlaWJlbiIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjEyOSBidWlsdGluL3B1bGwuYzoyMDkKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNDQgYnVpbHRpbi9wdWxsLmM6MjEwCiBtc2dpZCAicGF0aCB0byB1cGxvYWQgcGFjayBvbiByZW1vdGUgZW5kIgogbXNnc3RyICJQZmFkIGRlcyBQcm9ncmFtbXMgenVtIEhvY2hsYWRlbiB2b24gUGFrZXRlbiBhdWYgZGVyIEdlZ2Vuc2VpdGUiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxMzAKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNDUKIG1zZ2lkICJmb3JjZSBvdmVyd3JpdGUgb2YgbG9jYWwgcmVmZXJlbmNlIgogbXNnc3RyICJkYXMgw5xiZXJzY2hyZWliZW4gZWluZXIgbG9rYWxlbiBSZWZlcmVueiBlcnp3aW5nZW4iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxMzIKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNDcKIG1zZ2lkICJmZXRjaCBmcm9tIG11bHRpcGxlIHJlbW90ZXMiCiBtc2dzdHIgInZvbiBtZWhyZXJlbiBSZW1vdGUtUmVwb3NpdG9yaWVzIGFuZm9yZGVybiIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjEzNCBidWlsdGluL3B1bGwuYzoyMTMKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNDkgYnVpbHRpbi9wdWxsLmM6MjE0CiBtc2dpZCAiZmV0Y2ggYWxsIHRhZ3MgYW5kIGFzc29jaWF0ZWQgb2JqZWN0cyIKIG1zZ3N0ciAiYWxsZSBUYWdzIHVuZCB2ZXJidW5kZW5lIE9iamVrdGUgYW5mb3JkZXJuIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTM2CisjOiBidWlsdGluL2ZldGNoLmM6MTUxCiBtc2dpZCAiZG8gbm90IGZldGNoIGFsbCB0YWdzICgtLW5vLXRhZ3MpIgogbXNnc3RyICJuaWNodCBhbGxlIFRhZ3MgYW5mb3JkZXJuICgtLW5vLXRhZ3MpIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTM4CisjOiBidWlsdGluL2ZldGNoLmM6MTUzCiBtc2dpZCAibnVtYmVyIG9mIHN1Ym1vZHVsZXMgZmV0Y2hlZCBpbiBwYXJhbGxlbCIKIG1zZ3N0ciAiQW56YWhsIGRlciBwYXJhbGxlbCBhbnp1Zm9yZGVybmRlbiBTdWJtb2R1bGUiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNDAgYnVpbHRpbi9wdWxsLmM6MjE2CisjOiBidWlsdGluL2ZldGNoLmM6MTU1IGJ1aWx0aW4vcHVsbC5jOjIxNwogbXNnaWQgInBydW5lIHJlbW90ZS10cmFja2luZyBicmFuY2hlcyBubyBsb25nZXIgb24gcmVtb3RlIgogbXNnc3RyICIiCiAiUmVtb3RlLVRyYWNraW5nLUJyYW5jaGVzIGVudGZlcm5lbiwgZGllIHNpY2ggbmljaHQgbWVociBpbSBSZW1vdGUtUmVwb3NpdG9yeSAiCiAiYmVmaW5kZW4iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNDIKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNTcKIG1zZ2lkICJwcnVuZSBsb2NhbCB0YWdzIG5vIGxvbmdlciBvbiByZW1vdGUgYW5kIGNsb2JiZXIgY2hhbmdlZCB0YWdzIgogbXNnc3RyICIiCiAibG9rYWxlIFRhZ3MgZW50ZmVybmVuLCBkaWUgc2ljaCBuaWNodCBtZWhyIGltIFJlbW90ZS1SZXBvc2l0b3J5IGJlZmluZGVuLCAiCiAidW5kIGdlw6RuZGVydGUgVGFncyBha3R1YWxpc2llcmVuIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTQzIGJ1aWx0aW4vZmV0Y2guYzoxNjYgYnVpbHRpbi9wdWxsLmM6MTQwCisjOiBidWlsdGluL2ZldGNoLmM6MTU4IGJ1aWx0aW4vZmV0Y2guYzoxODEgYnVpbHRpbi9wdWxsLmM6MTQxCiBtc2dpZCAib24tZGVtYW5kIgogbXNnc3RyICJiZWktQmVkYXJmIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTQ0CisjOiBidWlsdGluL2ZldGNoLmM6MTU5CiBtc2dpZCAiY29udHJvbCByZWN1cnNpdmUgZmV0Y2hpbmcgb2Ygc3VibW9kdWxlcyIKIG1zZ3N0ciAicmVrdXJzaXZlIEFuZm9yZGVydW5nZW4gdm9uIFN1Ym1vZHVsZW4ga29udHJvbGxpZXJlbiIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE0OCBidWlsdGluL3B1bGwuYzoyMjQKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNjMgYnVpbHRpbi9wdWxsLmM6MjI1CiBtc2dpZCAia2VlcCBkb3dubG9hZGVkIHBhY2siCiBtc2dzdHIgImhlcnVudGVyZ2VsYWRlbmVzIFBha2V0IGJlaGFsdGVuIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTUwCisjOiBidWlsdGluL2ZldGNoLmM6MTY1CiBtc2dpZCAiYWxsb3cgdXBkYXRpbmcgb2YgSEVBRCByZWYiCiBtc2dzdHIgIkFrdHVhbGlzaWVydW5nIGRlciBcIkhFQURcIi1SZWZlcmVueiBlcmxhdWJlbiIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE1MyBidWlsdGluL2ZldGNoLmM6MTU5IGJ1aWx0aW4vcHVsbC5jOjIyNworIzogYnVpbHRpbi9mZXRjaC5jOjE2OCBidWlsdGluL2ZldGNoLmM6MTc0IGJ1aWx0aW4vcHVsbC5jOjIyOAogbXNnaWQgImRlZXBlbiBoaXN0b3J5IG9mIHNoYWxsb3cgY2xvbmUiCiBtc2dzdHIgIiIKICJkaWUgSGlzdG9yaWUgZWluZXMgS2xvbnMgbWl0IHVudm9sbHN0w6RuZGlnZXIgSGlzdG9yaWUgKHNoYWxsb3cpIHZlcnRpZWZlbiIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE1NQorIzogYnVpbHRpbi9mZXRjaC5jOjE3MAogbXNnaWQgImRlZXBlbiBoaXN0b3J5IG9mIHNoYWxsb3cgcmVwb3NpdG9yeSBiYXNlZCBvbiB0aW1lIgogbXNnc3RyICIiCiAiZGllIEhpc3RvcmllIGVpbmVzIEtsb25zIG1pdCB1bnZvbGxzdMOkbmRpZ2VyIEhpc3RvcmllIChzaGFsbG93KSBhdWYgIgogIlplaXRiYXNpc1xuIgogInZlcnRpZWZlbiIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE2MSBidWlsdGluL3B1bGwuYzoyMzAKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNzYgYnVpbHRpbi9wdWxsLmM6MjMxCiBtc2dpZCAiY29udmVydCB0byBhIGNvbXBsZXRlIHJlcG9zaXRvcnkiCiBtc2dzdHIgInp1IGVpbmVtIHZvbGxzdMOkbmRpZ2VuIFJlcG9zaXRvcnkga29udmVydGllcmVuIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTY0CisjOiBidWlsdGluL2ZldGNoLmM6MTc5CiBtc2dpZCAicHJlcGVuZCB0aGlzIHRvIHN1Ym1vZHVsZSBwYXRoIG91dHB1dCIKIG1zZ3N0ciAiZGllcyBhbiBkaWUgQXVzZ2FiZSBkZXIgU3VibW9kdWwtUGZhZGUgdm9yYW5zdGVsbGVuIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTY3CisjOiBidWlsdGluL2ZldGNoLmM6MTgyCiBtc2dpZCAiIgogImRlZmF1bHQgZm9yIHJlY3Vyc2l2ZSBmZXRjaGluZyBvZiBzdWJtb2R1bGVzIChsb3dlciBwcmlvcml0eSB0aGFuIGNvbmZpZyAiCiAiZmlsZXMpIgpAQCAtMTMwMjAsOTIgKzEzMDgyLDkyIEBACiAiU3RhbmRhcmQgZsO8ciBkaWUgcmVrdXJzaXZlIEFuZm9yZGVydW5nIHZvbiBTdWJtb2R1bGVuIChnZXJpbmdlcmUgUHJpb3JpdMOkdFxuIgogImFscyBLb25maWd1cmF0aW9uc2RhdGVpZW4pIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTcxIGJ1aWx0aW4vcHVsbC5jOjIzMworIzogYnVpbHRpbi9mZXRjaC5jOjE4NiBidWlsdGluL3B1bGwuYzoyMzQKIG1zZ2lkICJhY2NlcHQgcmVmcyB0aGF0IHVwZGF0ZSAuZ2l0L3NoYWxsb3ciCiBtc2dzdHIgIlJlZmVyZW56ZW4sIGRpZSAuZ2l0L3NoYWxsb3cgYWt0dWFsaXNpZXJlbiwgYWt6ZXB0aWVyZW4iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNzIgYnVpbHRpbi9wdWxsLmM6MjM1CisjOiBidWlsdGluL2ZldGNoLmM6MTg3IGJ1aWx0aW4vcHVsbC5jOjIzNgogbXNnaWQgInJlZm1hcCIKIG1zZ3N0ciAiUmVmbWFwIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTczIGJ1aWx0aW4vcHVsbC5jOjIzNgorIzogYnVpbHRpbi9mZXRjaC5jOjE4OCBidWlsdGluL3B1bGwuYzoyMzcKIG1zZ2lkICJzcGVjaWZ5IGZldGNoIHJlZm1hcCIKIG1zZ3N0ciAiUmVmbWFwIGbDvHIgJ2ZldGNoJyBhbmdlYmVuIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTgwCisjOiBidWlsdGluL2ZldGNoLmM6MTk1CiBtc2dpZCAicmVwb3J0IHRoYXQgd2UgaGF2ZSBvbmx5IG9iamVjdHMgcmVhY2hhYmxlIGZyb20gdGhpcyBvYmplY3QiCiBtc2dzdHIgIiIKICJhdXNnZWJlbiwgZGFzcyB3aXIgbnVyIE9iamVrdGUgaGFiZW4sIGRpZSB2b24gZGllc2VtIE9iamVrdCBhdXMgZXJyZWljaGJhciAiCiAic2luZCIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE4MworIzogYnVpbHRpbi9mZXRjaC5jOjE5OAogbXNnaWQgInJ1biAnZ2MgLS1hdXRvJyBhZnRlciBmZXRjaGluZyIKIG1zZ3N0ciAiRsO8aHJlICdnYyAtLWF1dG8nIG5hY2ggXCJmZXRjaFwiIGF1cyIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE4NSBidWlsdGluL3B1bGwuYzoyNDUKKyM6IGJ1aWx0aW4vZmV0Y2guYzoyMDAgYnVpbHRpbi9wdWxsLmM6MjQ2CiBtc2dpZCAiY2hlY2sgZm9yIGZvcmNlZC11cGRhdGVzIG9uIGFsbCB1cGRhdGVkIGJyYW5jaGVzIgogbXNnc3RyICJQcsO8ZmUgYXVmIGVyend1bmdlbmUgQWt0dWFsaXNpZXJ1bmdlbiBpbiBhbGxlbiBha3R1YWxpc2llcnRlbiBCcmFuY2hlcyIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjQ5MQorIzogYnVpbHRpbi9mZXRjaC5jOjUxMAogbXNnaWQgIkNvdWxkbid0IGZpbmQgcmVtb3RlIHJlZiBIRUFEIgogbXNnc3RyICJLb25udGUgUmVtb3RlLVJlZmVyZW56IHZvbiBIRUFEIG5pY2h0IGZpbmRlbi4iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzo2MzAKKyM6IGJ1aWx0aW4vZmV0Y2guYzo2NTAKICMsIGMtZm9ybWF0CiBtc2dpZCAiY29uZmlndXJhdGlvbiBmZXRjaC5vdXRwdXQgY29udGFpbnMgaW52YWxpZCB2YWx1ZSAlcyIKIG1zZ3N0ciAiS29uZmlndXJhdGlvbiBmZXRjaC5vdXRwdXQgZW50aMOkbHQgdW5nw7xsdGlnZW4gV2VydCAlcyIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjcyOAorIzogYnVpbHRpbi9mZXRjaC5jOjc0OAogIywgYy1mb3JtYXQKIG1zZ2lkICJvYmplY3QgJXMgbm90IGZvdW5kIgogbXNnc3RyICJPYmpla3QgJXMgbmljaHQgZ2VmdW5kZW4iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzo3MzIKKyM6IGJ1aWx0aW4vZmV0Y2guYzo3NTIKIG1zZ2lkICJbdXAgdG8gZGF0ZV0iCiBtc2dzdHIgIltha3R1ZWxsXSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjc0NSBidWlsdGluL2ZldGNoLmM6NzYxIGJ1aWx0aW4vZmV0Y2guYzo4MzMKKyM6IGJ1aWx0aW4vZmV0Y2guYzo3NjUgYnVpbHRpbi9mZXRjaC5jOjc4MSBidWlsdGluL2ZldGNoLmM6ODUzCiBtc2dpZCAiW3JlamVjdGVkXSIKIG1zZ3N0ciAiW3p1csO8Y2tnZXdpZXNlbl0iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzo3NDYKKyM6IGJ1aWx0aW4vZmV0Y2guYzo3NjYKIG1zZ2lkICJjYW4ndCBmZXRjaCBpbiBjdXJyZW50IGJyYW5jaCIKIG1zZ3N0ciAia2FubiBcImZldGNoXCIgaW0gYWt0dWVsbGVuIEJyYW5jaCBuaWNodCBhdXNmw7xocmVuIgogCi0jOiBidWlsdGluL2ZldGNoLmM6NzU2CisjOiBidWlsdGluL2ZldGNoLmM6Nzc2CiBtc2dpZCAiW3RhZyB1cGRhdGVdIgogbXNnc3RyICJbVGFnIEFrdHVhbGlzaWVydW5nXSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjc1NyBidWlsdGluL2ZldGNoLmM6Nzk0IGJ1aWx0aW4vZmV0Y2guYzo4MTYKLSM6IGJ1aWx0aW4vZmV0Y2guYzo4MjgKKyM6IGJ1aWx0aW4vZmV0Y2guYzo3NzcgYnVpbHRpbi9mZXRjaC5jOjgxNCBidWlsdGluL2ZldGNoLmM6ODM2CisjOiBidWlsdGluL2ZldGNoLmM6ODQ4CiBtc2dpZCAidW5hYmxlIHRvIHVwZGF0ZSBsb2NhbCByZWYiCiBtc2dzdHIgImthbm4gbG9rYWxlIFJlZmVyZW56IG5pY2h0IGFrdHVhbGlzaWVyZW4iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzo3NjEKKyM6IGJ1aWx0aW4vZmV0Y2guYzo3ODEKIG1zZ2lkICJ3b3VsZCBjbG9iYmVyIGV4aXN0aW5nIHRhZyIKIG1zZ3N0ciAid8O8cmRlIGJlc3RlaGVuZGUgVGFncyB2ZXLDpG5kZXJuIgogCi0jOiBidWlsdGluL2ZldGNoLmM6NzgzCisjOiBidWlsdGluL2ZldGNoLmM6ODAzCiBtc2dpZCAiW25ldyB0YWddIgogbXNnc3RyICJbbmV1ZXMgVGFnXSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjc4NgorIzogYnVpbHRpbi9mZXRjaC5jOjgwNgogbXNnaWQgIltuZXcgYnJhbmNoXSIKIG1zZ3N0ciAiW25ldWVyIEJyYW5jaF0iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzo3ODkKKyM6IGJ1aWx0aW4vZmV0Y2guYzo4MDkKIG1zZ2lkICJbbmV3IHJlZl0iCiBtc2dzdHIgIltuZXVlIFJlZmVyZW56XSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjgyOAorIzogYnVpbHRpbi9mZXRjaC5jOjg0OAogbXNnaWQgImZvcmNlZCB1cGRhdGUiCiBtc2dzdHIgIkFrdHVhbGlzaWVydW5nIGVyend1bmdlbiIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjgzMworIzogYnVpbHRpbi9mZXRjaC5jOjg1MwogbXNnaWQgIm5vbi1mYXN0LWZvcndhcmQiCiBtc2dzdHIgImtlaW4gVm9yc3B1bGVuIgogCi0jOiBidWlsdGluL2ZldGNoLmM6ODU0CisjOiBidWlsdGluL2ZldGNoLmM6ODc0CiBtc2dpZCAiIgogIkZldGNoIG5vcm1hbGx5IGluZGljYXRlcyB3aGljaCBicmFuY2hlcyBoYWQgYSBmb3JjZWQgdXBkYXRlLFxuIgogImJ1dCB0aGF0IGNoZWNrIGhhcyBiZWVuIGRpc2FibGVkLiBUbyByZS1lbmFibGUsIHVzZSAnLS1zaG93LWZvcmNlZC11cGRhdGVzJ1xuIgpAQCAtMTMxMTYsNyArMTMxNzgsNyBAQAogImFrdGl2aWVyZW4sIG51dHplbiBTaWUgZGllIE9wdGlvbiAnLS1zaG93LWZvcmNlZC11cGRhdGVkJyBvZGVyIGbDvGhyZW5cbiIKICJTaWUgJ2dpdCBjb25maWcgZmV0Y2guc2hvd0ZvcmNlZFVwZGF0ZXMgdHJ1ZScgYXVzLiIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjg1OAorIzogYnVpbHRpbi9mZXRjaC5jOjg3OAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiSXQgdG9vayAlLjJmIHNlY29uZHMgdG8gY2hlY2sgZm9yY2VkIHVwZGF0ZXMuIFlvdSBjYW4gdXNlXG4iCkBAIC0xMzEyOSwxMiArMTMxOTEsMTIgQEAKICInZ2l0IGNvbmZpZyBmZXRjaC5zaG93Rm9yY2VkVXBkYXRlcyBmYWxzZScgYXVzZsO8aHJlbiwgdW0gZGllc2Ugw5xiZXJwcsO8ZnVuZ1xuIgogInp1IHVtZ2VoZW4uXG4iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzo4ODgKKyM6IGJ1aWx0aW4vZmV0Y2guYzo5MDgKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgZGlkIG5vdCBzZW5kIGFsbCBuZWNlc3Nhcnkgb2JqZWN0c1xuIgogbXNnc3RyICIlcyBoYXQgbmljaHQgYWxsZSBlcmZvcmRlcmxpY2hlbiBPYmpla3RlIGdlc2VuZGV0XG4iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzo5MDkKKyM6IGJ1aWx0aW4vZmV0Y2guYzo5MjkKICMsIGMtZm9ybWF0CiBtc2dpZCAicmVqZWN0ICVzIGJlY2F1c2Ugc2hhbGxvdyByb290cyBhcmUgbm90IGFsbG93ZWQgdG8gYmUgdXBkYXRlZCIKIG1zZ3N0ciAiIgpAQCAtMTMxNDIsMTIgKzEzMjA0LDEyIEBACiAidW52b2xsc3TDpG5kaWdlclxuIgogIkhpc3RvcmllIChzaGFsbG93KSBuaWNodCBha3R1YWxpc2llcnQgd2VyZGVuIGTDvHJmZW4uIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTAwMCBidWlsdGluL2ZldGNoLmM6MTEzMQorIzogYnVpbHRpbi9mZXRjaC5jOjEwMjAgYnVpbHRpbi9mZXRjaC5jOjExNTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiRnJvbSAlLipzXG4iCiBtc2dzdHIgIlZvbiAlLipzXG4iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxMDExCisjOiBidWlsdGluL2ZldGNoLmM6MTAzMQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAic29tZSBsb2NhbCByZWZzIGNvdWxkIG5vdCBiZSB1cGRhdGVkOyB0cnkgcnVubmluZ1xuIgpAQCAtMTMxNTYsNjAgKzEzMjE4LDgxIEBACiAiRWluaWdlIGxva2FsZSBSZWZlcmVuemVuIGtvbm50ZW4gbmljaHQgYWt0dWFsaXNpZXJ0IHdlcmRlbjsgdmVyc3VjaGVuIFNpZVxuIgogIidnaXQgcmVtb3RlIHBydW5lICVzJywgdW0gamVkZW4gw6RsdGVyZW4sIHdpZGVyc3Byw7xjaGxpY2hlbiBCcmFuY2ggenUgbMO2c2NoZW4uIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTEwMQorIzogYnVpbHRpbi9mZXRjaC5jOjExMjcKICMsIGMtZm9ybWF0CiBtc2dpZCAiICAgKCVzIHdpbGwgYmVjb21lIGRhbmdsaW5nKSIKIG1zZ3N0ciAiICAgKCVzIHdpcmQgdW5yZWZlcmVuemllcnQpIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTEwMgorIzogYnVpbHRpbi9mZXRjaC5jOjExMjgKICMsIGMtZm9ybWF0CiBtc2dpZCAiICAgKCVzIGhhcyBiZWNvbWUgZGFuZ2xpbmcpIgogbXNnc3RyICIgICAoJXMgd3VyZGUgdW5yZWZlcmVuemllcnQpIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTEzNAorIzogYnVpbHRpbi9mZXRjaC5jOjExNjAKIG1zZ2lkICJbZGVsZXRlZF0iCiBtc2dzdHIgIltnZWzDtnNjaHRdIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTEzNSBidWlsdGluL3JlbW90ZS5jOjEwMzYKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxMTYxIGJ1aWx0aW4vcmVtb3RlLmM6MTAzNgogbXNnaWQgIihub25lKSIKIG1zZ3N0ciAiKG5pY2h0cykiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxMTU4CisjOiBidWlsdGluL2ZldGNoLmM6MTE4NAogIywgYy1mb3JtYXQKIG1zZ2lkICJSZWZ1c2luZyB0byBmZXRjaCBpbnRvIGN1cnJlbnQgYnJhbmNoICVzIG9mIG5vbi1iYXJlIHJlcG9zaXRvcnkiCiBtc2dzdHIgIiIKICJEZXIgXCJmZXRjaFwiIGluIGRlbiBha3R1ZWxsZW4gQnJhbmNoICVzIHZvbiBlaW5lbSBOaWNodC1CYXJlLVJlcG9zaXRvcnkgIgogInd1cmRlIHZlcndlaWdlcnQuIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTE3NworIzogYnVpbHRpbi9mZXRjaC5jOjEyMDMKICMsIGMtZm9ybWF0CiBtc2dpZCAiT3B0aW9uIFwiJXNcIiB2YWx1ZSBcIiVzXCIgaXMgbm90IHZhbGlkIGZvciAlcyIKIG1zZ3N0ciAiT3B0aW9uIFwiJXNcIiBXZXJ0IFwiJXNcIiBpc3QgbmljaHQgZ8O8bHRpZyBmw7xyICVzIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTE4MAorIzogYnVpbHRpbi9mZXRjaC5jOjEyMDYKICMsIGMtZm9ybWF0CiBtc2dpZCAiT3B0aW9uIFwiJXNcIiBpcyBpZ25vcmVkIGZvciAlc1xuIgogbXNnc3RyICJPcHRpb24gXCIlc1wiIHdpcmQgaWdub3JpZXJ0IGbDvHIgJXNcbiIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE0ODQKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNDE0Cittc2dpZCAibXVsdGlwbGUgYnJhbmNoIGRldGVjdGVkLCBpbmNvbXBhdGlibGUgd2l0aCAtLXNldC11cHN0cmVhbSIKK21zZ3N0ciAibWVocmVyZSBCcmFuY2hlcyBlcmthbm50LCBpbmtvbXBhdGliZWwgbWl0IC0tc2V0LXVwc3RyZWFtIgorCisjOiBidWlsdGluL2ZldGNoLmM6MTQyOQorbXNnaWQgIm5vdCBzZXR0aW5nIHVwc3RyZWFtIGZvciBhIHJlbW90ZSByZW1vdGUtdHJhY2tpbmcgYnJhbmNoIgorbXNnc3RyICJTZXR6ZSBrZWluZW4gVXBzdHJlYW0gZsO8ciBlaW5lbiBlbnRmZXJudGVuIFJlbW90ZS1UcmFja2luZy1CcmFuY2guIgorCisjOiBidWlsdGluL2ZldGNoLmM6MTQzMQorbXNnaWQgIm5vdCBzZXR0aW5nIHVwc3RyZWFtIGZvciBhIHJlbW90ZSB0YWciCittc2dzdHIgIlNldHplIGtlaW5lbiBVcHN0cmVhbSBmw7xyIGVpbmVuIFRhZyBlaW5lcyBSZW1vdGUtUmVwb3NpdG9yaWVzLiIKKworIzogYnVpbHRpbi9mZXRjaC5jOjE0MzMKK21zZ2lkICJ1bmtub3duIGJyYW5jaCB0eXBlIgorbXNnc3RyICJVbmJla2FubnRlciBCcmFuY2gtVHlwIgorCisjOiBidWlsdGluL2ZldGNoLmM6MTQzNQorbXNnaWQgIiIKKyJubyBzb3VyY2UgYnJhbmNoIGZvdW5kLlxuIgorInlvdSBuZWVkIHRvIHNwZWNpZnkgZXhhY3RseSBvbmUgYnJhbmNoIHdpdGggdGhlIC0tc2V0LXVwc3RyZWFtIG9wdGlvbi4iCittc2dzdHIgIiIKKyJLZWluZW4gUXVlbGwtQnJhbmNoIGdlZnVuZGVuLlxuIgorIlNpZSBtw7xzc2VuIGJlaSBkZXIgT3B0aW9uIC0tc2V0LXVwc3RyZWFtIGdlbmF1IGVpbmVuIEJyYW5jaCBhbmdlYmVuLiIKKworIzogYnVpbHRpbi9mZXRjaC5jOjE1NjEgYnVpbHRpbi9mZXRjaC5jOjE2MjMKICMsIGMtZm9ybWF0CiBtc2dpZCAiRmV0Y2hpbmcgJXNcbiIKIG1zZ3N0ciAiRm9yZGVyZSBhbiB2b24gJXNcbiIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE0ODYgYnVpbHRpbi9yZW1vdGUuYzoxMDAKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNTcxIGJ1aWx0aW4vZmV0Y2guYzoxNjI1IGJ1aWx0aW4vcmVtb3RlLmM6MTAwCiAjLCBjLWZvcm1hdAogbXNnaWQgIkNvdWxkIG5vdCBmZXRjaCAlcyIKIG1zZ3N0ciAiS29ubnRlIG5pY2h0IHZvbiAlcyBhbmZvcmRlcm4iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNTMyCi1tc2dpZCAiIgotIi0tZmlsdGVyIGNhbiBvbmx5IGJlIHVzZWQgd2l0aCB0aGUgcmVtb3RlIGNvbmZpZ3VyZWQgaW4gZXh0ZW5zaW9ucy4iCi0icGFydGlhbENsb25lIgotbXNnc3RyICIiCi0iLS1maWx0ZXIga2FubiBudXIgbWl0IGRlbiBSZW1vdGUtUmVwb3NpdG9yaWVzIHZlcndlbmRldCB3ZXJkZW4sXG4iCi0iZGllIGluIGNvcmUucGFydGlhbENsb25lIGtvbmZpZ3VyaWVydCBzaW5kLiIKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNTgzCisjLCBjLWZvcm1hdAorbXNnaWQgImNvdWxkIG5vdCBmZXRjaCAnJXMnIChleGl0IGNvZGU6ICVkKVxuIgorbXNnc3RyICJLb25udGUgJyVzJyBuaWNodCBhbmZvcmRlcm4gKEV4aXQtQ29kZTogJWQpXG4iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNTU2CisjOiBidWlsdGluL2ZldGNoLmM6MTY4NQogbXNnaWQgIiIKICJObyByZW1vdGUgcmVwb3NpdG9yeSBzcGVjaWZpZWQuICBQbGVhc2UsIHNwZWNpZnkgZWl0aGVyIGEgVVJMIG9yIGFcbiIKICJyZW1vdGUgbmFtZSBmcm9tIHdoaWNoIG5ldyByZXZpc2lvbnMgc2hvdWxkIGJlIGZldGNoZWQuIgpAQCAtMTMyMTgsNDkgKzEzMzAxLDQ5IEBACiAib2RlciBkZW4gTmFtZW4gZGVzIFJlbW90ZS1SZXBvc2l0b3JpZXMgYW4sIHZvbiB3ZWxjaGVtIG5ldWVcbiIKICJDb21taXRzIGFuZ2Vmb3JkZXJ0IHdlcmRlbiBzb2xsZW4uIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTU5MworIzogYnVpbHRpbi9mZXRjaC5jOjE3MjIKIG1zZ2lkICJZb3UgbmVlZCB0byBzcGVjaWZ5IGEgdGFnIG5hbWUuIgogbXNnc3RyICJTaWUgbcO8c3NlbiBkZW4gTmFtZW4gZGVzIFRhZ3MgYW5nZWJlbi4iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNjQ0CisjOiBidWlsdGluL2ZldGNoLmM6MTc3NAogbXNnaWQgIk5lZ2F0aXZlIGRlcHRoIGluIC0tZGVlcGVuIGlzIG5vdCBzdXBwb3J0ZWQiCiBtc2dzdHIgIk5lZ2F0aXZlIFRpZWZlIHdpcmQgdm9uIC0tZGVlcGVuIG5pY2h0IHVudGVyc3TDvHR6dC4iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNjQ2CisjOiBidWlsdGluL2ZldGNoLmM6MTc3NgogbXNnaWQgIi0tZGVlcGVuIGFuZCAtLWRlcHRoIGFyZSBtdXR1YWxseSBleGNsdXNpdmUiCiBtc2dzdHIgIi0tZGVlcGVuIHVuZCAtLWRlcHRoIHNjaGxpZcOfZW4gc2ljaCBnZWdlbnNlaXRpZyBhdXMiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNjUxCisjOiBidWlsdGluL2ZldGNoLmM6MTc4MQogbXNnaWQgIi0tZGVwdGggYW5kIC0tdW5zaGFsbG93IGNhbm5vdCBiZSB1c2VkIHRvZ2V0aGVyIgogbXNnc3RyICIiCiAiRGllIE9wdGlvbmVuIC0tZGVwdGggdW5kIC0tdW5zaGFsbG93IGvDtm5uZW4gbmljaHQgZ2VtZWluc2FtIHZlcndlbmRldCB3ZXJkZW4uIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTY1MworIzogYnVpbHRpbi9mZXRjaC5jOjE3ODMKIG1zZ2lkICItLXVuc2hhbGxvdyBvbiBhIGNvbXBsZXRlIHJlcG9zaXRvcnkgZG9lcyBub3QgbWFrZSBzZW5zZSIKIG1zZ3N0ciAiIgogIkRpZSBPcHRpb24gLS11bnNoYWxsb3cga2FubiBuaWNodCBpbiBlaW5lbSBSZXBvc2l0b3J5IG1pdCB2b2xsc3TDpG5kaWdlciAiCiAiSGlzdG9yaWUgdmVyd2VuZGV0IHdlcmRlbi4iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNjY5CisjOiBidWlsdGluL2ZldGNoLmM6MTc5OQogbXNnaWQgImZldGNoIC0tYWxsIGRvZXMgbm90IHRha2UgYSByZXBvc2l0b3J5IGFyZ3VtZW50IgogbXNnc3RyICJmZXRjaCAtLWFsbCBha3plcHRpZXJ0IGtlaW4gUmVwb3NpdG9yeSBhbHMgQXJndW1lbnQiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNjcxCisjOiBidWlsdGluL2ZldGNoLmM6MTgwMQogbXNnaWQgImZldGNoIC0tYWxsIGRvZXMgbm90IG1ha2Ugc2Vuc2Ugd2l0aCByZWZzcGVjcyIKIG1zZ3N0ciAiZmV0Y2ggLS1hbGwga2FubiBuaWNodCBtaXQgUmVmc3BlY3MgdmVyd2VuZGV0IHdlcmRlbi4iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNjgwCisjOiBidWlsdGluL2ZldGNoLmM6MTgxMAogIywgYy1mb3JtYXQKIG1zZ2lkICJObyBzdWNoIHJlbW90ZSBvciByZW1vdGUgZ3JvdXA6ICVzIgogbXNnc3RyICJLZWluIFJlbW90ZS1SZXBvc2l0b3J5IChlaW56ZWxuIG9kZXIgR3J1cHBlKTogJXMiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNjg3CisjOiBidWlsdGluL2ZldGNoLmM6MTgxNwogbXNnaWQgIkZldGNoaW5nIGEgZ3JvdXAgYW5kIHNwZWNpZnlpbmcgcmVmc3BlY3MgZG9lcyBub3QgbWFrZSBzZW5zZSIKIG1zZ3N0ciAiIgogIkRhcyBBYmhvbGVuIGVpbmVyIEdydXBwZSB2b24gUmVtb3RlLVJlcG9zaXRvcmllcyBrYW5uIG5pY2h0IG1pdCBkZXIgQW5nYWJlXG4iCiAidm9uIFJlZnNwZWNzIHZlcndlbmRldCB3ZXJkZW4uIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTcwMworIzogYnVpbHRpbi9mZXRjaC5jOjE4MzUKIG1zZ2lkICIiCiAiLS1maWx0ZXIgY2FuIG9ubHkgYmUgdXNlZCB3aXRoIHRoZSByZW1vdGUgY29uZmlndXJlZCBpbiBleHRlbnNpb25zLiIKICJwYXJ0aWFsY2xvbmUiCkBAIC0xMzU5OCw3ICsxMzY4MSw3IEBACiBtc2dpZCAiaW52YWxpZCBwYXJhbWV0ZXI6IGV4cGVjdGVkIHNoYTEsIGdvdCAnJXMnIgogbXNnc3RyICJVbmfDvGx0aWdlciBQYXJhbWV0ZXI6IFNIQS0xIGVyd2FydGV0LCAnJXMnIGJla29tbWVuIgogCi0jOiBidWlsdGluL2djLmM6MzQKKyM6IGJ1aWx0aW4vZ2MuYzozNQogbXNnaWQgImdpdCBnYyBbPG9wdGlvbnM+XSIKIG1zZ3N0ciAiZ2l0IGdjIFs8T3B0aW9uZW4+XSIKIApAQCAtMTM2MTIsMTcgKzEzNjk1LDE3IEBACiBtc2dpZCAiZmFpbGVkIHRvIHBhcnNlICclcycgdmFsdWUgJyVzJyIKIG1zZ3N0ciAiRmVobGVyIGJlaW0gUGFyc2VuIHZvbiAnJXMnIG1pdCBkZW0gV2VydCAnJXMnIgogCi0jOiBidWlsdGluL2djLmM6NDc2IGJ1aWx0aW4vaW5pdC1kYi5jOjU1CisjOiBidWlsdGluL2djLmM6NDc1IGJ1aWx0aW4vaW5pdC1kYi5jOjU1CiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCBzdGF0ICclcyciCiBtc2dzdHIgIkthbm4gJyVzJyBuaWNodCBsZXNlbiIKIAotIzogYnVpbHRpbi9nYy5jOjQ4NSBidWlsdGluL25vdGVzLmM6MjQwIGJ1aWx0aW4vdGFnLmM6NTI5CisjOiBidWlsdGluL2djLmM6NDg0IGJ1aWx0aW4vbm90ZXMuYzoyNDAgYnVpbHRpbi90YWcuYzo1MjkKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IHJlYWQgJyVzJyIKIG1zZ3N0ciAia2FubiAnJXMnIG5pY2h0IGxlc2VuIgogCi0jOiBidWlsdGluL2djLmM6NDkyCisjOiBidWlsdGluL2djLmM6NDkxCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgbGFzdCBnYyBydW4gcmVwb3J0ZWQgdGhlIGZvbGxvd2luZy4gUGxlYXNlIGNvcnJlY3QgdGhlIHJvb3QgY2F1c2VcbiIKQEAgLTEzNjM4LDU4ICsxMzcyMSw1OCBAQAogIlxuIgogIiVzIgogCi0jOiBidWlsdGluL2djLmM6NTQwCisjOiBidWlsdGluL2djLmM6NTM5CiBtc2dpZCAicHJ1bmUgdW5yZWZlcmVuY2VkIG9iamVjdHMiCiBtc2dzdHIgInVucmVmZXJlbnppZXJ0ZSBPYmpla3RlIGVudGZlcm5lbiIKIAotIzogYnVpbHRpbi9nYy5jOjU0MgorIzogYnVpbHRpbi9nYy5jOjU0MQogbXNnaWQgImJlIG1vcmUgdGhvcm91Z2ggKGluY3JlYXNlZCBydW50aW1lKSIKIG1zZ3N0ciAibWVociBHcsO8bmRsaWNoa2VpdCAoZXJow7ZodCBMYXVmemVpdCkiCiAKLSM6IGJ1aWx0aW4vZ2MuYzo1NDMKKyM6IGJ1aWx0aW4vZ2MuYzo1NDIKIG1zZ2lkICJlbmFibGUgYXV0by1nYyBtb2RlIgogbXNnc3RyICJcImF1dG8tZ2NcIiBNb2R1cyBha3RpdmllcmVuIgogCi0jOiBidWlsdGluL2djLmM6NTQ2CisjOiBidWlsdGluL2djLmM6NTQ1CiBtc2dpZCAiZm9yY2UgcnVubmluZyBnYyBldmVuIGlmIHRoZXJlIG1heSBiZSBhbm90aGVyIGdjIHJ1bm5pbmciCiBtc2dzdHIgIiIKICJBdXNmw7xocnVuZyB2b24gXCJnaXQgZ2NcIiBlcnp3aW5nZW4sIHNlbGJzdCB3ZW5uIGVpbiBhbmRlcmVzXG4iCiAiXCJnaXQgZ2NcIiBiZXJlaXRzIGF1c2dlZsO8aHJ0IHdpcmQiCiAKLSM6IGJ1aWx0aW4vZ2MuYzo1NDkKKyM6IGJ1aWx0aW4vZ2MuYzo1NDgKIG1zZ2lkICJyZXBhY2sgYWxsIG90aGVyIHBhY2tzIGV4Y2VwdCB0aGUgbGFyZ2VzdCBwYWNrIgogbXNnc3RyICJhbGxlIGFuZGVyZW4gUGFrZXRlLCBhdcOfZXIgZGFzIGdyw7bDn3RlIFBha2V0LCBuZXUgcGFja2VuIgogCi0jOiBidWlsdGluL2djLmM6NTY2CisjOiBidWlsdGluL2djLmM6NTY1CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBwYXJzZSBnYy5sb2dleHBpcnkgdmFsdWUgJXMiCiBtc2dzdHIgIkZlaGxlciBiZWltIFBhcnNlbiBkZXMgV2VydGVzICclcycgdm9uIGdjLmxvZ2V4cGlyeS4iCiAKLSM6IGJ1aWx0aW4vZ2MuYzo1NzcKKyM6IGJ1aWx0aW4vZ2MuYzo1NzYKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIHBhcnNlIHBydW5lIGV4cGlyeSB2YWx1ZSAlcyIKIG1zZ3N0ciAiRmVobGVyIGJlaW0gUGFyc2VuIGRlcyBcInBydW5lIGV4cGlyeVwiIFdlcnRlcyAlcyIKIAotIzogYnVpbHRpbi9nYy5jOjU5NworIzogYnVpbHRpbi9nYy5jOjU5NgogIywgYy1mb3JtYXQKIG1zZ2lkICJBdXRvIHBhY2tpbmcgdGhlIHJlcG9zaXRvcnkgaW4gYmFja2dyb3VuZCBmb3Igb3B0aW11bSBwZXJmb3JtYW5jZS5cbiIKIG1zZ3N0ciAiIgogIkRpZSBEYXRlbmJhbmsgZGVzIFJlcG9zaXRvcmllcyB3aXJkIGbDvHIgZWluZSBvcHRpbWFsZSBQZXJmb3JtYW5jZSBpbVxuIgogIkhpbnRlcmdydW5kIGtvbXByaW1pZXJ0LlxuIgogCi0jOiBidWlsdGluL2djLmM6NTk5CisjOiBidWlsdGluL2djLmM6NTk4CiAjLCBjLWZvcm1hdAogbXNnaWQgIkF1dG8gcGFja2luZyB0aGUgcmVwb3NpdG9yeSBmb3Igb3B0aW11bSBwZXJmb3JtYW5jZS5cbiIKIG1zZ3N0ciAiIgogIkRpZSBEYXRlbmJhbmsgZGVzIFByb2pla3RhcmNoaXZzIHdpcmQgZsO8ciBlaW5lIG9wdGltYWxlIFBlcmZvcm1hbmNlICIKICJrb21wcmltaWVydC5cbiIKIAotIzogYnVpbHRpbi9nYy5jOjYwMAorIzogYnVpbHRpbi9nYy5jOjU5OQogIywgYy1mb3JtYXQKIG1zZ2lkICJTZWUgXCJnaXQgaGVscCBnY1wiIGZvciBtYW51YWwgaG91c2VrZWVwaW5nLlxuIgogbXNnc3RyICJTaWVoZSBcImdpdCBoZWxwIGdjXCIgZsO8ciBtYW51ZWxsZXMgQXVmcsOkdW1lbi5cbiIKIAotIzogYnVpbHRpbi9nYy5jOjY0MAorIzogYnVpbHRpbi9nYy5jOjYzOQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiZ2MgaXMgYWxyZWFkeSBydW5uaW5nIG9uIG1hY2hpbmUgJyVzJyBwaWQgJTxQUkl1TUFYPiAodXNlIC0tZm9yY2UgaWYgbm90KSIKQEAgLTEzNjk3LDcgKzEzNzgwLDcgQEAKICJcImdpdCBnY1wiIHdpcmQgYmVyZWl0cyBhdWYgTWFzY2hpbmUgJyVzJyBwaWQgJTxQUkl1TUFYPiBhdXNnZWbDvGhydFxuIgogIihiZW51dHplbiBTaWUgLS1mb3JjZSBmYWxscyBuaWNodCkiCiAKLSM6IGJ1aWx0aW4vZ2MuYzo2OTUKKyM6IGJ1aWx0aW4vZ2MuYzo2OTQKIG1zZ2lkICIiCiAiVGhlcmUgYXJlIHRvbyBtYW55IHVucmVhY2hhYmxlIGxvb3NlIG9iamVjdHM7IHJ1biAnZ2l0IHBydW5lJyB0byByZW1vdmUgdGhlbS4iCiBtc2dzdHIgIiIKQEAgLTEzNzIzLDI2NSArMTM4MDYsMjY1IEBACiAjLiBncmVwLnRocmVhZHMKICMuCiAjOiBidWlsdGluL2dyZXAuYzoyODcgYnVpbHRpbi9pbmRleC1wYWNrLmM6MTUzNCBidWlsdGluL2luZGV4LXBhY2suYzoxNzI3Ci0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI3MjgKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjcwOAogIywgYy1mb3JtYXQKIG1zZ2lkICJubyB0aHJlYWRzIHN1cHBvcnQsIGlnbm9yaW5nICVzIgogbXNnc3RyICJrZWluZSBVbnRlcnN0w7x0enVuZyB2b24gVGhyZWFkcywgJyVzJyB3aXJkIGlnbm9yaWVydCIKIAotIzogYnVpbHRpbi9ncmVwLmM6NDY3IGJ1aWx0aW4vZ3JlcC5jOjU5MSBidWlsdGluL2dyZXAuYzo2MzMKKyM6IGJ1aWx0aW4vZ3JlcC5jOjQ2NyBidWlsdGluL2dyZXAuYzo1OTIgYnVpbHRpbi9ncmVwLmM6NjM1CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byByZWFkIHRyZWUgKCVzKSIKIG1zZ3N0ciAia29ubnRlIFwiVHJlZVwiLU9iamVrdCAoJXMpIG5pY2h0IGxlc2VuIgogCi0jOiBidWlsdGluL2dyZXAuYzo2NDgKKyM6IGJ1aWx0aW4vZ3JlcC5jOjY1MAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gZ3JlcCBmcm9tIG9iamVjdCBvZiB0eXBlICVzIgogbXNnc3RyICJrYW5uIFwiZ3JlcFwiIG5pY2h0IG1pdCBPYmpla3RlbiBkZXMgVHlwcyAlcyBkdXJjaGbDvGhyZW4iCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjcxNAorIzogYnVpbHRpbi9ncmVwLmM6NzE2CiAjLCBjLWZvcm1hdAogbXNnaWQgInN3aXRjaCBgJWMnIGV4cGVjdHMgYSBudW1lcmljYWwgdmFsdWUiCiBtc2dzdHIgIlNjaGFsdGVyICclYycgZXJ3YXJ0ZXQgZWluZW4gbnVtZXJpc2NoZW4gV2VydCIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODEzCisjOiBidWlsdGluL2dyZXAuYzo4MTUKIG1zZ2lkICJzZWFyY2ggaW4gaW5kZXggaW5zdGVhZCBvZiBpbiB0aGUgd29yayB0cmVlIgogbXNnc3RyICJpbSBJbmRleCBhbnN0YXR0IGltIEFyYmVpdHN2ZXJ6ZWljaG5pcyBzdWNoZW4iCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjgxNQorIzogYnVpbHRpbi9ncmVwLmM6ODE3CiBtc2dpZCAiZmluZCBpbiBjb250ZW50cyBub3QgbWFuYWdlZCBieSBnaXQiCiBtc2dzdHIgImF1Y2ggaW4gSW5oYWx0ZW4gZmluZGVuLCBkaWUgbmljaHQgdm9uIEdpdCB2ZXJ3YWx0ZXQgd2VyZGVuIgogCi0jOiBidWlsdGluL2dyZXAuYzo4MTcKKyM6IGJ1aWx0aW4vZ3JlcC5jOjgxOQogbXNnaWQgInNlYXJjaCBpbiBib3RoIHRyYWNrZWQgYW5kIHVudHJhY2tlZCBmaWxlcyIKIG1zZ3N0ciAiaW4gdmVyc2lvbmllcnRlbiB1bmQgdW52ZXJzaW9uaWVydGVuIERhdGVpZW4gc3VjaGVuIgogCi0jOiBidWlsdGluL2dyZXAuYzo4MTkKKyM6IGJ1aWx0aW4vZ3JlcC5jOjgyMQogbXNnaWQgImlnbm9yZSBmaWxlcyBzcGVjaWZpZWQgdmlhICcuZ2l0aWdub3JlJyIKIG1zZ3N0ciAiRGF0ZWllbiwgZGllIMO8YmVyICcuZ2l0aWdub3JlJyBhbmdlZ2ViZW4gc2luZCwgaWdub3JpZXJlbiIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODIxCisjOiBidWlsdGluL2dyZXAuYzo4MjMKIG1zZ2lkICJyZWN1cnNpdmVseSBzZWFyY2ggaW4gZWFjaCBzdWJtb2R1bGUiCiBtc2dzdHIgInJla3Vyc2l2ZSBTdWNoZSBpbiBqZWRlbSBTdWJtb2R1bCIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODI0CisjOiBidWlsdGluL2dyZXAuYzo4MjYKIG1zZ2lkICJzaG93IG5vbi1tYXRjaGluZyBsaW5lcyIKIG1zZ3N0ciAiWmVpbGVuIG9obmUgw5xiZXJlaW5zdGltbXVuZ2VuIGFuemVpZ2VuIgogCi0jOiBidWlsdGluL2dyZXAuYzo4MjYKKyM6IGJ1aWx0aW4vZ3JlcC5jOjgyOAogbXNnaWQgImNhc2UgaW5zZW5zaXRpdmUgbWF0Y2hpbmciCiBtc2dzdHIgIsOcYmVyZWluc3RpbW11bmdlbiB1bmFiaMOkbmdpZyB2b24gR3Jvw58tIHVuZCBLbGVpbnNjaHJlaWJ1bmcgZmluZGVuIgogCi0jOiBidWlsdGluL2dyZXAuYzo4MjgKKyM6IGJ1aWx0aW4vZ3JlcC5jOjgzMAogbXNnaWQgIm1hdGNoIHBhdHRlcm5zIG9ubHkgYXQgd29yZCBib3VuZGFyaWVzIgogbXNnc3RyICJudXIgZ2FuemUgV8O2cnRlciBzdWNoZW4iCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjgzMAorIzogYnVpbHRpbi9ncmVwLmM6ODMyCiBtc2dpZCAicHJvY2VzcyBiaW5hcnkgZmlsZXMgYXMgdGV4dCIKIG1zZ3N0ciAiYmluw6RyZSBEYXRlaWVuIGFscyBUZXh0IHZlcmFyYmVpdGVuIgogCi0jOiBidWlsdGluL2dyZXAuYzo4MzIKKyM6IGJ1aWx0aW4vZ3JlcC5jOjgzNAogbXNnaWQgImRvbid0IG1hdGNoIHBhdHRlcm5zIGluIGJpbmFyeSBmaWxlcyIKIG1zZ3N0ciAia2VpbmUgTXVzdGVyIGluIEJpbsOkcmRhdGVpZW4gZmluZGVuIgogCi0jOiBidWlsdGluL2dyZXAuYzo4MzUKKyM6IGJ1aWx0aW4vZ3JlcC5jOjgzNwogbXNnaWQgInByb2Nlc3MgYmluYXJ5IGZpbGVzIHdpdGggdGV4dGNvbnYgZmlsdGVycyIKIG1zZ3N0ciAiYmluw6RyZSBEYXRlaWVuIG1pdCBcInRleHRjb252XCItRmlsdGVybiB2ZXJhcmJlaXRlbiIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODM3CisjOiBidWlsdGluL2dyZXAuYzo4MzkKIG1zZ2lkICJzZWFyY2ggaW4gc3ViZGlyZWN0b3JpZXMgKGRlZmF1bHQpIgogbXNnc3RyICJpbiBVbnRlcnZlcnplaWNobmlzc2VuIHN1Y2hlbiAoU3RhbmRhcmQpIgogCi0jOiBidWlsdGluL2dyZXAuYzo4MzkKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg0MQogbXNnaWQgImRlc2NlbmQgYXQgbW9zdCA8ZGVwdGg+IGxldmVscyIKIG1zZ3N0ciAiaMO2Y2hzdGVucyA8VGllZmU+IEViZW5lbiBkdXJjaGxhdWZlbiIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODQzCisjOiBidWlsdGluL2dyZXAuYzo4NDUKIG1zZ2lkICJ1c2UgZXh0ZW5kZWQgUE9TSVggcmVndWxhciBleHByZXNzaW9ucyIKIG1zZ3N0ciAiZXJ3ZWl0ZXJ0ZSByZWd1bMOkcmUgQXVzZHLDvGNrZSBhdXMgUE9TSVggdmVyd2VuZGVuIgogCi0jOiBidWlsdGluL2dyZXAuYzo4NDYKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg0OAogbXNnaWQgInVzZSBiYXNpYyBQT1NJWCByZWd1bGFyIGV4cHJlc3Npb25zIChkZWZhdWx0KSIKIG1zZ3N0ciAiZ3J1bmRsZWdlbmRlIHJlZ3Vsw6RyZSBBdXNkcsO8Y2tlIGF1cyBQT1NJWCB2ZXJ3ZW5kZW4gKFN0YW5kYXJkKSIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODQ5CisjOiBidWlsdGluL2dyZXAuYzo4NTEKIG1zZ2lkICJpbnRlcnByZXQgcGF0dGVybnMgYXMgZml4ZWQgc3RyaW5ncyIKIG1zZ3N0ciAiTXVzdGVyIGFscyBmZXN0ZSBaZWljaGVua2V0dGVuIGludGVycHJldGllcmVuIgogCi0jOiBidWlsdGluL2dyZXAuYzo4NTIKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg1NAogbXNnaWQgInVzZSBQZXJsLWNvbXBhdGlibGUgcmVndWxhciBleHByZXNzaW9ucyIKIG1zZ3N0ciAiUGVybC1rb21wYXRpYmxlIHJlZ3Vsw6RyZSBBdXNkcsO8Y2tlIHZlcndlbmRlbiIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODU1CisjOiBidWlsdGluL2dyZXAuYzo4NTcKIG1zZ2lkICJzaG93IGxpbmUgbnVtYmVycyIKIG1zZ3N0ciAiWmVpbGVubnVtbWVybiBhbnplaWdlbiIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODU2CisjOiBidWlsdGluL2dyZXAuYzo4NTgKIG1zZ2lkICJzaG93IGNvbHVtbiBudW1iZXIgb2YgZmlyc3QgbWF0Y2giCiBtc2dzdHIgIk51bW1lciBkZXIgU3BhbHRlIGRlcyBlcnN0ZW4gVHJlZmZlcnMgYW56ZWlnZW4iCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg1NworIzogYnVpbHRpbi9ncmVwLmM6ODU5CiBtc2dpZCAiZG9uJ3Qgc2hvdyBmaWxlbmFtZXMiCiBtc2dzdHIgImtlaW5lIERhdGVpbmFtZW4gYW56ZWlnZW4iCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg1OAorIzogYnVpbHRpbi9ncmVwLmM6ODYwCiBtc2dpZCAic2hvdyBmaWxlbmFtZXMiCiBtc2dzdHIgIkRhdGVpbmFtZW4gYW56ZWlnZW4iCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg2MAorIzogYnVpbHRpbi9ncmVwLmM6ODYyCiBtc2dpZCAic2hvdyBmaWxlbmFtZXMgcmVsYXRpdmUgdG8gdG9wIGRpcmVjdG9yeSIKIG1zZ3N0ciAiRGF0ZWluYW1lbiByZWxhdGl2IHp1bSBQcm9qZWt0dmVyemVpY2huaXMgYW56ZWlnZW4iCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg2MgorIzogYnVpbHRpbi9ncmVwLmM6ODY0CiBtc2dpZCAic2hvdyBvbmx5IGZpbGVuYW1lcyBpbnN0ZWFkIG9mIG1hdGNoaW5nIGxpbmVzIgogbXNnc3RyICJudXIgRGF0ZWluYW1lbiBhbnplaWdlbiBhbnN0YXR0IMO8YmVyZWluc3RpbW1lbmRlIFplaWxlbiIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODY0CisjOiBidWlsdGluL2dyZXAuYzo4NjYKIG1zZ2lkICJzeW5vbnltIGZvciAtLWZpbGVzLXdpdGgtbWF0Y2hlcyIKIG1zZ3N0ciAiU3lub255bSBmw7xyIC0tZmlsZXMtd2l0aC1tYXRjaGVzIgogCi0jOiBidWlsdGluL2dyZXAuYzo4NjcKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg2OQogbXNnaWQgInNob3cgb25seSB0aGUgbmFtZXMgb2YgZmlsZXMgd2l0aG91dCBtYXRjaCIKIG1zZ3N0ciAibnVyIGRpZSBEYXRlaW5hbWVuIG9obmUgw5xiZXJlaW5zdGltbXVuZ2VuIGFuemVpZ2VuIgogCi0jOiBidWlsdGluL2dyZXAuYzo4NjkKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg3MQogbXNnaWQgInByaW50IE5VTCBhZnRlciBmaWxlbmFtZXMiCiBtc2dzdHIgIk5VTC1aZWljaGVuIG5hY2ggRGF0ZWluYW1lbiBhdXNnZWJlbiIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODcyCisjOiBidWlsdGluL2dyZXAuYzo4NzQKIG1zZ2lkICJzaG93IG9ubHkgbWF0Y2hpbmcgcGFydHMgb2YgYSBsaW5lIgogbXNnc3RyICJudXIgw7xiZXJlaW5zdGltbWVuZGUgVGVpbGUgZGVyIFplaWxlIGFuemVpZ2VuIgogCi0jOiBidWlsdGluL2dyZXAuYzo4NzQKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg3NgogbXNnaWQgInNob3cgdGhlIG51bWJlciBvZiBtYXRjaGVzIGluc3RlYWQgb2YgbWF0Y2hpbmcgbGluZXMiCiBtc2dzdHIgImFuc3RhdHQgZGVyIFplaWxlbiwgZGllIEFuemFobCBkZXIgw7xiZXJlaW5zdGltbWVuZGVuIFplaWxlbiBhbnplaWdlbiIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODc1CisjOiBidWlsdGluL2dyZXAuYzo4NzcKIG1zZ2lkICJoaWdobGlnaHQgbWF0Y2hlcyIKIG1zZ3N0ciAiw5xiZXJlaW5zdGltbXVuZ2VuIGhlcnZvcmhlYmVuIgogCi0jOiBidWlsdGluL2dyZXAuYzo4NzcKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg3OQogbXNnaWQgInByaW50IGVtcHR5IGxpbmUgYmV0d2VlbiBtYXRjaGVzIGZyb20gZGlmZmVyZW50IGZpbGVzIgogbXNnc3RyICIiCiAiZWluZSBMZWVyemVpbGUgendpc2NoZW4gw5xiZXJlaW5zdGltbXVuZ2VuIGluIHZlcnNjaGllZGVuZW4gRGF0ZWllbiBhdXNnZWJlbiIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODc5CisjOiBidWlsdGluL2dyZXAuYzo4ODEKIG1zZ2lkICJzaG93IGZpbGVuYW1lIG9ubHkgb25jZSBhYm92ZSBtYXRjaGVzIGZyb20gc2FtZSBmaWxlIgogbXNnc3RyICIiCiAiZGVuIERhdGVpbmFtZW4gbnVyIGVpbm1hbCBvYmVyaGFsYiBkZXIgw5xiZXJlaW5zdGltbXVuZ2VuIGF1cyBkaWVzZXIgRGF0ZWkgIgogImFuemVpZ2VuIgogCi0jOiBidWlsdGluL2dyZXAuYzo4ODIKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg4NAogbXNnaWQgInNob3cgPG4+IGNvbnRleHQgbGluZXMgYmVmb3JlIGFuZCBhZnRlciBtYXRjaGVzIgogbXNnc3RyICI8bj4gWmVpbGVuIHZvciB1bmQgbmFjaCBkZW4gw5xiZXJlaW5zdGltbXVuZ2VuIGFuemVpZ2VuIgogCi0jOiBidWlsdGluL2dyZXAuYzo4ODUKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg4NwogbXNnaWQgInNob3cgPG4+IGNvbnRleHQgbGluZXMgYmVmb3JlIG1hdGNoZXMiCiBtc2dzdHIgIjxuPiBaZWlsZW4gdm9yIGRlbiDDnGJlcmVpbnN0aW1tdW5nZW4gYW56ZWlnZW4iCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg4NworIzogYnVpbHRpbi9ncmVwLmM6ODg5CiBtc2dpZCAic2hvdyA8bj4gY29udGV4dCBsaW5lcyBhZnRlciBtYXRjaGVzIgogbXNnc3RyICI8bj4gWmVpbGVuIG5hY2ggZGVuIMOcYmVyZWluc3RpbW11bmdlbiBhbnplaWdlbiIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODg5CisjOiBidWlsdGluL2dyZXAuYzo4OTEKIG1zZ2lkICJ1c2UgPG4+IHdvcmtlciB0aHJlYWRzIgogbXNnc3RyICI8bj4gVGhyZWFkcyBiZW51dHplbiIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODkwCisjOiBidWlsdGluL2dyZXAuYzo4OTIKIG1zZ2lkICJzaG9ydGN1dCBmb3IgLUMgTlVNIgogbXNnc3RyICJLdXJ6Zm9ybSBmw7xyIC1DIE5VTSIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODkzCisjOiBidWlsdGluL2dyZXAuYzo4OTUKIG1zZ2lkICJzaG93IGEgbGluZSB3aXRoIHRoZSBmdW5jdGlvbiBuYW1lIGJlZm9yZSBtYXRjaGVzIgogbXNnc3RyICJlaW5lIFplaWxlIG1pdCBkZW0gRnVua3Rpb25zbmFtZW4gdm9yIMOcYmVyZWluc3RpbW11bmdlbiBhbnplaWdlbiIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODk1CisjOiBidWlsdGluL2dyZXAuYzo4OTcKIG1zZ2lkICJzaG93IHRoZSBzdXJyb3VuZGluZyBmdW5jdGlvbiIKIG1zZ3N0ciAiZGllIHVtZ2ViZW5kZSBGdW5rdGlvbiBhbnplaWdlbiIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODk4CisjOiBidWlsdGluL2dyZXAuYzo5MDAKIG1zZ2lkICJyZWFkIHBhdHRlcm5zIGZyb20gZmlsZSIKIG1zZ3N0ciAiTXVzdGVyIHZvbiBlaW5lciBEYXRlaSBsZXNlbiIKIAotIzogYnVpbHRpbi9ncmVwLmM6OTAwCisjOiBidWlsdGluL2dyZXAuYzo5MDIKIG1zZ2lkICJtYXRjaCA8cGF0dGVybj4iCiBtc2dzdHIgIjxNdXN0ZXI+IGZpbmRlbiIKIAotIzogYnVpbHRpbi9ncmVwLmM6OTAyCisjOiBidWlsdGluL2dyZXAuYzo5MDQKIG1zZ2lkICJjb21iaW5lIHBhdHRlcm5zIHNwZWNpZmllZCB3aXRoIC1lIgogbXNnc3RyICJNdXN0ZXIga29tYmluaWVyZW4sIGRpZSBtaXQgLWUgYW5nZWdlYmVuIHd1cmRlbiIKIAotIzogYnVpbHRpbi9ncmVwLmM6OTE0CisjOiBidWlsdGluL2dyZXAuYzo5MTYKIG1zZ2lkICJpbmRpY2F0ZSBoaXQgd2l0aCBleGl0IHN0YXR1cyB3aXRob3V0IG91dHB1dCIKIG1zZ3N0ciAiw5xiZXJlaW5zdGltbXVuZ2VuIG51ciBkdXJjaCBCZWVuZGlndW5nc3N0YXR1cyBhbnplaWdlbiIKIAotIzogYnVpbHRpbi9ncmVwLmM6OTE2CisjOiBidWlsdGluL2dyZXAuYzo5MTgKIG1zZ2lkICJzaG93IG9ubHkgbWF0Y2hlcyBmcm9tIGZpbGVzIHRoYXQgbWF0Y2ggYWxsIHBhdHRlcm5zIgogbXNnc3RyICIiCiAibnVyIMOcYmVyZWluc3RpbW11bmdlbiB2b24gRGF0ZWllbiBhbnplaWdlbiwgZGllIGFsbGVuIE11c3Rlcm4gZW50c3ByZWNoZW4iCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjkxOAorIzogYnVpbHRpbi9ncmVwLmM6OTIwCiBtc2dpZCAic2hvdyBwYXJzZSB0cmVlIGZvciBncmVwIGV4cHJlc3Npb24iCiBtc2dzdHIgImdlcGFyc3RlcyBWZXJ6ZWljaG5pcyBmw7xyIFwiZ3JlcFwiLUF1c2RydWNrIGFuemVpZ2VuIgogCi0jOiBidWlsdGluL2dyZXAuYzo5MjIKKyM6IGJ1aWx0aW4vZ3JlcC5jOjkyNAogbXNnaWQgInBhZ2VyIgogbXNnc3RyICJBbnplaWdlcHJvZ3JhbW0iCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjkyMgorIzogYnVpbHRpbi9ncmVwLmM6OTI0CiBtc2dpZCAic2hvdyBtYXRjaGluZyBmaWxlcyBpbiB0aGUgcGFnZXIiCiBtc2dzdHIgIkRhdGVpZW4gbWl0IMOcYmVyZWluc3RpbW11bmdlbiBpbSBBbnplaWdlcHJvZ3JhbW0gYW56ZWlnZW4iCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjkyNgorIzogYnVpbHRpbi9ncmVwLmM6OTI4CiBtc2dpZCAiYWxsb3cgY2FsbGluZyBvZiBncmVwKDEpIChpZ25vcmVkIGJ5IHRoaXMgYnVpbGQpIgogbXNnc3RyICJkZW4gQXVmcnVmIHZvbiBncmVwKDEpIGVybGF1YmVuICh2b24gZGllc2VyIFByb2dyYW1tdmVyc2lvbiBpZ25vcmllcnQpIgogCi0jOiBidWlsdGluL2dyZXAuYzo5OTAKKyM6IGJ1aWx0aW4vZ3JlcC5jOjk5MgogbXNnaWQgIm5vIHBhdHRlcm4gZ2l2ZW4iCiBtc2dzdHIgIktlaW4gTXVzdGVyIGFuZ2VnZWJlbi4iCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjEwMjYKKyM6IGJ1aWx0aW4vZ3JlcC5jOjEwMjgKIG1zZ2lkICItLW5vLWluZGV4IG9yIC0tdW50cmFja2VkIGNhbm5vdCBiZSB1c2VkIHdpdGggcmV2cyIKIG1zZ3N0ciAiLS1uby1pbmRleCBvZGVyIC0tdW50cmFja2VkIGvDtm5uZW4gbmljaHQgbWl0IENvbW1pdHMgdmVyd2VuZGV0IHdlcmRlbiIKIAotIzogYnVpbHRpbi9ncmVwLmM6MTAzNAorIzogYnVpbHRpbi9ncmVwLmM6MTAzNgogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gcmVzb2x2ZSByZXZpc2lvbjogJXMiCiBtc2dzdHIgIktvbm50ZSBDb21taXQgbmljaHQgYXVmbMO2c2VuOiAlcyIKIAotIzogYnVpbHRpbi9ncmVwLmM6MTA2NQorIzogYnVpbHRpbi9ncmVwLmM6MTA2NwogbXNnaWQgImludmFsaWQgb3B0aW9uIGNvbWJpbmF0aW9uLCBpZ25vcmluZyAtLXRocmVhZHMiCiBtc2dzdHIgIlVuZ8O8bHRpZ2UgS29tYmluYXRpb24gdm9uIE9wdGlvbmVuLCAtLXRocmVhZHMgd2lyZCBpZ25vcmllcnQuIgogCi0jOiBidWlsdGluL2dyZXAuYzoxMDY4IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzQxNgorIzogYnVpbHRpbi9ncmVwLmM6MTA3MCBidWlsdGluL3BhY2stb2JqZWN0cy5jOjM0MDAKIG1zZ2lkICJubyB0aHJlYWRzIHN1cHBvcnQsIGlnbm9yaW5nIC0tdGhyZWFkcyIKIG1zZ3N0ciAiS2VpbmUgVW50ZXJzdMO8dHp1bmcgZsO8ciBUaHJlYWRzLCAtLXRocmVhZHMgd2lyZCBpZ25vcmllcnQuIgogCi0jOiBidWlsdGluL2dyZXAuYzoxMDcxIGJ1aWx0aW4vaW5kZXgtcGFjay5jOjE1MzEgYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNzI1CisjOiBidWlsdGluL2dyZXAuYzoxMDczIGJ1aWx0aW4vaW5kZXgtcGFjay5jOjE1MzEgYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNzA1CiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgbnVtYmVyIG9mIHRocmVhZHMgc3BlY2lmaWVkICglZCkiCiBtc2dzdHIgInVuZ8O8bHRpZ2UgQW56YWhsIHZvbiBUaHJlYWRzIGFuZ2VnZWJlbiAoJWQpIgogCi0jOiBidWlsdGluL2dyZXAuYzoxMDk0CisjOiBidWlsdGluL2dyZXAuYzoxMDk2CiBtc2dpZCAiLS1vcGVuLWZpbGVzLWluLXBhZ2VyIG9ubHkgd29ya3Mgb24gdGhlIHdvcmt0cmVlIgogbXNnc3RyICIiCiAiRGllIE9wdGlvbiAtLW9wZW4tZmlsZXMtaW4tcGFnZXIga2FubiBudXIgaW5uZXJoYWxiIGRlcyAiCiAiQXJiZWl0c3ZlcnplaWNobmlzc2VzIHZlcndlbmRldCB3ZXJkZW4uIgogCi0jOiBidWlsdGluL2dyZXAuYzoxMTE3CisjOiBidWlsdGluL2dyZXAuYzoxMTE5CiBtc2dpZCAib3B0aW9uIG5vdCBzdXBwb3J0ZWQgd2l0aCAtLXJlY3Vyc2Utc3VibW9kdWxlcyIKIG1zZ3N0ciAiRGllIE9wdGlvbiB3aXJkIG1pdCAtLXJlY3Vyc2Utc3VibW9kdWxlcyBuaWNodCB1bnRlcnN0w7x0enQuIgogCi0jOiBidWlsdGluL2dyZXAuYzoxMTIzCisjOiBidWlsdGluL2dyZXAuYzoxMTI1CiBtc2dpZCAiLS1jYWNoZWQgb3IgLS11bnRyYWNrZWQgY2Fubm90IGJlIHVzZWQgd2l0aCAtLW5vLWluZGV4IgogbXNnc3RyICItLWNhY2hlZCB1bmQgLS11bnRyYWNrZWQga8O2bm5lbiBuaWNodCBtaXQgLS1uby1pbmRleCB2ZXJ3ZW5kZXQgd2VyZGVuLiIKIAotIzogYnVpbHRpbi9ncmVwLmM6MTEyOQorIzogYnVpbHRpbi9ncmVwLmM6MTEzMQogbXNnaWQgIi0tW25vLV1leGNsdWRlLXN0YW5kYXJkIGNhbm5vdCBiZSB1c2VkIGZvciB0cmFja2VkIGNvbnRlbnRzIgogbXNnc3RyICIiCiAiLS1bbm8tXWV4Y2x1ZGUtc3RhbmRhcmQga2FubiBuaWNodCBtaXQgdmVyc2lvbmllcnRlbiBJbmhhbHRlbiB2ZXJ3ZW5kZXQgIgogIndlcmRlbi4iCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjExMzcKKyM6IGJ1aWx0aW4vZ3JlcC5jOjExMzkKIG1zZ2lkICJib3RoIC0tY2FjaGVkIGFuZCB0cmVlcyBhcmUgZ2l2ZW4iCiBtc2dzdHIgIi0tY2FjaGVkIHVuZCBcIlRyZWVcIi1PYmpla3RlIGFuZ2VnZWJlbiIKIApAQCAtMTQyOTYsNyArMTQzNzksNyBAQAogbXNnaWQgIlJlc29sdmluZyBkZWx0YXMiCiBtc2dzdHIgIkzDtnNlIFVudGVyc2NoaWVkZSBhdWYiCiAKLSM6IGJ1aWx0aW4vaW5kZXgtcGFjay5jOjEyMDUgYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNDk3CisjOiBidWlsdGluL2luZGV4LXBhY2suYzoxMjA1IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjQ4MQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gY3JlYXRlIHRocmVhZDogJXMiCiBtc2dzdHIgImthbm4gVGhyZWFkIG5pY2h0IGVyemV1Z2VuOiAlcyIKQEAgLTE0MzYxLDcgKzE0NDQ0LDcgQEAKIG1zZ2lkICJjYW5ub3Qgc3RvcmUgaW5kZXggZmlsZSIKIG1zZ3N0ciAiS2FubiBJbmRleGRhdGVpIG5pY2h0IHNwZWljaGVybiIKIAotIzogYnVpbHRpbi9pbmRleC1wYWNrLmM6MTUyNSBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI3MzYKKyM6IGJ1aWx0aW4vaW5kZXgtcGFjay5jOjE1MjUgYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNzE2CiAjLCBjLWZvcm1hdAogbXNnaWQgImJhZCBwYWNrLmluZGV4dmVyc2lvbj0lPFBSSXUzMj4iCiBtc2dzdHIgIlwicGFjay5pbmRleHZlcnNpb249JTxQUkl1MzI+XCIgaXN0IHVuZ8O8bHRpZyIKQEAgLTE0NjQ0LDc0ICsxNDcyNyw3NCBAQAogbXNnaWQgImdpdCBzaG93ICVzOiBiYWQgZmlsZSIKIG1zZ3N0ciAiZ2l0IHNob3cgJXM6IHVuZ8O8bHRpZ2UgRGF0ZWkiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6NTQ5IGJ1aWx0aW4vbG9nLmM6NjQzCisjOiBidWlsdGluL2xvZy5jOjU0OSBidWlsdGluL2xvZy5jOjY0NAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcmVhZCBvYmplY3QgJXMiCiBtc2dzdHIgIktvbm50ZSBPYmpla3QgJXMgbmljaHQgbGVzZW4uIgogCi0jOiBidWlsdGluL2xvZy5jOjY2OAorIzogYnVpbHRpbi9sb2cuYzo2NjkKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5rbm93biB0eXBlOiAlZCIKIG1zZ3N0ciAiVW5iZWthbm50ZXIgVHlwOiAlZCIKIAotIzogYnVpbHRpbi9sb2cuYzo3OTEKKyM6IGJ1aWx0aW4vbG9nLmM6NzkyCiBtc2dpZCAiZm9ybWF0LmhlYWRlcnMgd2l0aG91dCB2YWx1ZSIKIG1zZ3N0ciAiZm9ybWF0LmhlYWRlcnMgb2huZSBXZXJ0IgogCi0jOiBidWlsdGluL2xvZy5jOjkwOAorIzogYnVpbHRpbi9sb2cuYzo5MDkKIG1zZ2lkICJuYW1lIG9mIG91dHB1dCBkaXJlY3RvcnkgaXMgdG9vIGxvbmciCiBtc2dzdHIgIk5hbWUgZGVzIEF1c2dhYmV2ZXJ6ZWljaG5pc3NlcyBpc3QgenUgbGFuZy4iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6OTI0CisjOiBidWlsdGluL2xvZy5jOjkyNQogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3Qgb3BlbiBwYXRjaCBmaWxlICVzIgogbXNnc3RyICJLYW5uIFBhdGNoLURhdGVpICVzIG5pY2h0IMO2ZmZuZW4iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6OTQxCisjOiBidWlsdGluL2xvZy5jOjk0MgogbXNnaWQgIm5lZWQgZXhhY3RseSBvbmUgcmFuZ2UiCiBtc2dzdHIgIkJyYXVjaGUgZ2VuYXUgZWluZW4gQ29tbWl0LUJlcmVpY2guIgogCi0jOiBidWlsdGluL2xvZy5jOjk1MQorIzogYnVpbHRpbi9sb2cuYzo5NTIKIG1zZ2lkICJub3QgYSByYW5nZSIKIG1zZ3N0ciAiS2VpbiBDb21taXQtQmVyZWljaC4iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTA3NAorIzogYnVpbHRpbi9sb2cuYzoxMDc1CiBtc2dpZCAiY292ZXIgbGV0dGVyIG5lZWRzIGVtYWlsIGZvcm1hdCIKIG1zZ3N0ciAiQW5zY2hyZWliZW4gYmVuw7Z0aWd0IEUtTWFpbC1Gb3JtYXQiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTA4MAorIzogYnVpbHRpbi9sb2cuYzoxMDgxCiBtc2dpZCAiZmFpbGVkIHRvIGNyZWF0ZSBjb3Zlci1sZXR0ZXIgZmlsZSIKIG1zZ3N0ciAiRmVobGVyIGJlaW0gRXJzdGVsbGVuIGRlciBEYXRlaSBmw7xyIGRhcyBBbnNjaHJlaWJlbi4iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTE1OQorIzogYnVpbHRpbi9sb2cuYzoxMTYwCiAjLCBjLWZvcm1hdAogbXNnaWQgImluc2FuZSBpbi1yZXBseS10bzogJXMiCiBtc2dzdHIgInVuZ8O8bHRpZ2VzIGluLXJlcGx5LXRvOiAlcyIKIAotIzogYnVpbHRpbi9sb2cuYzoxMTg2CisjOiBidWlsdGluL2xvZy5jOjExODcKIG1zZ2lkICJnaXQgZm9ybWF0LXBhdGNoIFs8b3B0aW9ucz5dIFs8c2luY2U+IHwgPHJldmlzaW9uLXJhbmdlPl0iCiBtc2dzdHIgImdpdCBmb3JtYXQtcGF0Y2ggWzxPcHRpb25lbj5dIFs8c2VpdD4gfCA8Q29tbWl0YmVyZWljaD5dIgogCi0jOiBidWlsdGluL2xvZy5jOjEyNDQKKyM6IGJ1aWx0aW4vbG9nLmM6MTI0NQogbXNnaWQgInR3byBvdXRwdXQgZGlyZWN0b3JpZXM/IgogbXNnc3RyICJad2VpIEF1c2dhYmV2ZXJ6ZWljaG5pc3NlPyIKIAotIzogYnVpbHRpbi9sb2cuYzoxMzU1IGJ1aWx0aW4vbG9nLmM6MjA5OSBidWlsdGluL2xvZy5jOjIxMDEgYnVpbHRpbi9sb2cuYzoyMTEzCisjOiBidWlsdGluL2xvZy5jOjEzNTYgYnVpbHRpbi9sb2cuYzoyMTE2IGJ1aWx0aW4vbG9nLmM6MjExOCBidWlsdGluL2xvZy5jOjIxMzAKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5rbm93biBjb21taXQgJXMiCiBtc2dzdHIgIlVuYmVrYW5udGVyIENvbW1pdCAlcyIKIAotIzogYnVpbHRpbi9sb2cuYzoxMzY1IGJ1aWx0aW4vcmVwbGFjZS5jOjU4IGJ1aWx0aW4vcmVwbGFjZS5jOjIwNworIzogYnVpbHRpbi9sb2cuYzoxMzY2IGJ1aWx0aW4vcmVwbGFjZS5jOjU4IGJ1aWx0aW4vcmVwbGFjZS5jOjIwNwogIzogYnVpbHRpbi9yZXBsYWNlLmM6MjEwCiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byByZXNvbHZlICclcycgYXMgYSB2YWxpZCByZWYiCiBtc2dzdHIgIktvbm50ZSAnJXMnIG5pY2h0IGFscyBnw7xsdGlnZSBSZWZlcmVueiBhdWZsw7ZzZW4uIgogCi0jOiBidWlsdGluL2xvZy5jOjEzNzAKKyM6IGJ1aWx0aW4vbG9nLmM6MTM3MQogbXNnaWQgImNvdWxkIG5vdCBmaW5kIGV4YWN0IG1lcmdlIGJhc2UiCiBtc2dzdHIgIktvbm50ZSBrZWluZSBleGFrdGUgTWVyZ2UtQmFzaXMgZmluZGVuLiIKIAotIzogYnVpbHRpbi9sb2cuYzoxMzc0CisjOiBidWlsdGluL2xvZy5jOjEzNzUKIG1zZ2lkICIiCiAiZmFpbGVkIHRvIGdldCB1cHN0cmVhbSwgaWYgeW91IHdhbnQgdG8gcmVjb3JkIGJhc2UgY29tbWl0IGF1dG9tYXRpY2FsbHksXG4iCiAicGxlYXNlIHVzZSBnaXQgYnJhbmNoIC0tc2V0LXVwc3RyZWFtLXRvIHRvIHRyYWNrIGEgcmVtb3RlIGJyYW5jaC5cbiIKQEAgLTE0NzIyLDI3MiArMTQ4MDUsMjcyIEBACiAiJ2dpdCBicmFuY2ggLS1zZXQtdXBzdHJlYW0tdG8nLCB1bSBlaW5lbSBSZW1vdGUtQnJhbmNoIHp1IGZvbGdlbi5cbiIKICJPZGVyIGdlYmVuIFNpZSBkZW4gQmFzaXMtQ29tbWl0IG1pdCAnLS1iYXNlPTxCYXNpcy1Db21taXQtSWQ+JyBtYW51ZWxsIGFuLiIKIAotIzogYnVpbHRpbi9sb2cuYzoxMzk0CisjOiBidWlsdGluL2xvZy5jOjEzOTUKIG1zZ2lkICJmYWlsZWQgdG8gZmluZCBleGFjdCBtZXJnZSBiYXNlIgogbXNnc3RyICJGZWhsZXIgYmVpbSBGaW5kZW4gZWluZXIgZXhha3RlbiBNZXJnZS1CYXNpcy4iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTQwNQorIzogYnVpbHRpbi9sb2cuYzoxNDA2CiBtc2dpZCAiYmFzZSBjb21taXQgc2hvdWxkIGJlIHRoZSBhbmNlc3RvciBvZiByZXZpc2lvbiBsaXN0IgogbXNnc3RyICJCYXNpcy1Db21taXQgc29sbHRlIGRlciBWb3Jnw6RuZ2VyIGRlciBSZXZpc2lvbnNsaXN0ZSBzZWluLiIKIAotIzogYnVpbHRpbi9sb2cuYzoxNDA5CisjOiBidWlsdGluL2xvZy5jOjE0MTAKIG1zZ2lkICJiYXNlIGNvbW1pdCBzaG91bGRuJ3QgYmUgaW4gcmV2aXNpb24gbGlzdCIKIG1zZ3N0ciAiQmFzaXMtQ29tbWl0IHNvbGx0ZSBuaWNodCBpbiBkZXIgUmV2aXNpb25zbGlzdGUgZW50aGFsdGVuIHNlaW4uIgogCi0jOiBidWlsdGluL2xvZy5jOjE0NjIKKyM6IGJ1aWx0aW4vbG9nLmM6MTQ2MwogbXNnaWQgImNhbm5vdCBnZXQgcGF0Y2ggaWQiCiBtc2dzdHIgImthbm4gUGF0Y2gtSWQgbmljaHQgbGVzZW4iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTUxNAorIzogYnVpbHRpbi9sb2cuYzoxNTE1CiBtc2dpZCAiZmFpbGVkIHRvIGluZmVyIHJhbmdlLWRpZmYgcmFuZ2VzIgogbXNnc3RyICJGZWhsZXIgYmVpbSBBYmxlaXRlbiBkZXMgcmFuZ2UtZGlmZi1CZXJlaWNocy4iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTU1OQorIzogYnVpbHRpbi9sb2cuYzoxNTYwCiBtc2dpZCAidXNlIFtQQVRDSCBuL21dIGV2ZW4gd2l0aCBhIHNpbmdsZSBwYXRjaCIKIG1zZ3N0ciAiW1BBVENIIG4vbV0gYXVjaCBtaXQgZWluemVsbmVtIFBhdGNoIHZlcndlbmRlbiIKIAotIzogYnVpbHRpbi9sb2cuYzoxNTYyCisjOiBidWlsdGluL2xvZy5jOjE1NjMKIG1zZ2lkICJ1c2UgW1BBVENIXSBldmVuIHdpdGggbXVsdGlwbGUgcGF0Y2hlcyIKIG1zZ3N0ciAiW1BBVENIXSBhdWNoIG1pdCBtZWhyZXJlbiBQYXRjaGVzIHZlcndlbmRlbiIKIAotIzogYnVpbHRpbi9sb2cuYzoxNTY2CisjOiBidWlsdGluL2xvZy5jOjE1NjcKIG1zZ2lkICJwcmludCBwYXRjaGVzIHRvIHN0YW5kYXJkIG91dCIKIG1zZ3N0ciAiQXVzZ2FiZSBkZXIgUGF0Y2hlcyBpbiBTdGFuZGFyZC1BdXNnYWJlIgogCi0jOiBidWlsdGluL2xvZy5jOjE1NjgKKyM6IGJ1aWx0aW4vbG9nLmM6MTU2OQogbXNnaWQgImdlbmVyYXRlIGEgY292ZXIgbGV0dGVyIgogbXNnc3RyICJlaW4gRGVja2JsYXR0IGVyemV1Z2VuIgogCi0jOiBidWlsdGluL2xvZy5jOjE1NzAKKyM6IGJ1aWx0aW4vbG9nLmM6MTU3MQogbXNnaWQgInVzZSBzaW1wbGUgbnVtYmVyIHNlcXVlbmNlIGZvciBvdXRwdXQgZmlsZSBuYW1lcyIKIG1zZ3N0ciAiZWluZmFjaGUgTnVtbWVybmZvbGdlIGbDvHIgZGllIE5hbWVuIGRlciBBdXNnYWJlZGF0ZWllbiB2ZXJ3ZW5kZW4iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTU3MQorIzogYnVpbHRpbi9sb2cuYzoxNTcyCiBtc2dpZCAic2Z4IgogbXNnc3RyICJEYXRlaWVuZHVuZyIKIAotIzogYnVpbHRpbi9sb2cuYzoxNTcyCisjOiBidWlsdGluL2xvZy5jOjE1NzMKIG1zZ2lkICJ1c2UgPHNmeD4gaW5zdGVhZCBvZiAnLnBhdGNoJyIKIG1zZ3N0ciAiPERhdGVpZW5kdW5nPiBhbnN0YXR0ICcucGF0Y2gnIHZlcndlbmRlbiIKIAotIzogYnVpbHRpbi9sb2cuYzoxNTc0CisjOiBidWlsdGluL2xvZy5jOjE1NzUKIG1zZ2lkICJzdGFydCBudW1iZXJpbmcgcGF0Y2hlcyBhdCA8bj4gaW5zdGVhZCBvZiAxIgogbXNnc3RyICJkaWUgTnVtbWVyaWVydW5nIGRlciBQYXRjaGVzIGJlaSA8bj4gYW5zdGF0dCBiZWkgMSBiZWdpbm5lbiIKIAotIzogYnVpbHRpbi9sb2cuYzoxNTc2CisjOiBidWlsdGluL2xvZy5jOjE1NzcKIG1zZ2lkICJtYXJrIHRoZSBzZXJpZXMgYXMgTnRoIHJlLXJvbGwiCiBtc2dzdHIgImRpZSBTZXJpZSBhbHMgbi10ZSBGYXNzdW5nIGtlbm56ZWljaG5lbiIKIAotIzogYnVpbHRpbi9sb2cuYzoxNTc4CisjOiBidWlsdGluL2xvZy5jOjE1NzkKIG1zZ2lkICJVc2UgW1JGQyBQQVRDSF0gaW5zdGVhZCBvZiBbUEFUQ0hdIgogbXNnc3RyICJbUkZDIFBBVENIXSBhbnN0YXR0IFtQQVRDSF0gdmVyd2VuZGVuIgogCi0jOiBidWlsdGluL2xvZy5jOjE1ODEKKyM6IGJ1aWx0aW4vbG9nLmM6MTU4MgogbXNnaWQgIlVzZSBbPHByZWZpeD5dIGluc3RlYWQgb2YgW1BBVENIXSIKIG1zZ3N0ciAiWzxQcsOkZml4Pl0gYW5zdGF0dCBbUEFUQ0hdIHZlcndlbmRlbiIKIAotIzogYnVpbHRpbi9sb2cuYzoxNTg0CisjOiBidWlsdGluL2xvZy5jOjE1ODUKIG1zZ2lkICJzdG9yZSByZXN1bHRpbmcgZmlsZXMgaW4gPGRpcj4iCiBtc2dzdHIgImVyemV1Z3RlIERhdGVpZW4gaW4gPFZlcnplaWNobmlzPiBzcGVpY2hlcm4iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTU4NworIzogYnVpbHRpbi9sb2cuYzoxNTg4CiBtc2dpZCAiZG9uJ3Qgc3RyaXAvYWRkIFtQQVRDSF0iCiBtc2dzdHIgIltQQVRDSF0gbmljaHQgZW50ZmVybmVuL2hpbnp1ZsO8Z2VuIgogCi0jOiBidWlsdGluL2xvZy5jOjE1OTAKKyM6IGJ1aWx0aW4vbG9nLmM6MTU5MQogbXNnaWQgImRvbid0IG91dHB1dCBiaW5hcnkgZGlmZnMiCiBtc2dzdHIgImtlaW5lIGJpbsOkcmVuIFVudGVyc2NoaWVkZSBhdXNnZWJlbiIKIAotIzogYnVpbHRpbi9sb2cuYzoxNTkyCisjOiBidWlsdGluL2xvZy5jOjE1OTMKIG1zZ2lkICJvdXRwdXQgYWxsLXplcm8gaGFzaCBpbiBGcm9tIGhlYWRlciIKIG1zZ3N0ciAiSGFzaCBtaXQgTnVsbGVuIGluIFwiRnJvbVwiLUhlYWRlciBhdXNnZWJlbiIKIAotIzogYnVpbHRpbi9sb2cuYzoxNTk0CisjOiBidWlsdGluL2xvZy5jOjE1OTUKIG1zZ2lkICJkb24ndCBpbmNsdWRlIGEgcGF0Y2ggbWF0Y2hpbmcgYSBjb21taXQgdXBzdHJlYW0iCiBtc2dzdHIgIiIKICJrZWluZSBQYXRjaGVzIGVpbnNjaGxpZcOfZW4sIGRpZSBlaW5lbSBDb21taXQgaW0gVXBzdHJlYW0tQnJhbmNoIGVudHNwcmVjaGVuIgogCi0jOiBidWlsdGluL2xvZy5jOjE1OTYKKyM6IGJ1aWx0aW4vbG9nLmM6MTU5NwogbXNnaWQgInNob3cgcGF0Y2ggZm9ybWF0IGluc3RlYWQgb2YgZGVmYXVsdCAocGF0Y2ggKyBzdGF0KSIKIG1zZ3N0ciAiUGF0Y2hmb3JtYXQgYW5zdGF0dCBkZXMgU3RhbmRhcmRzIGFuemVpZ2VuIChQYXRjaCArIFp1c2FtbWVuZmFzc3VuZykiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTU5OAorIzogYnVpbHRpbi9sb2cuYzoxNTk5CiBtc2dpZCAiTWVzc2FnaW5nIgogbXNnc3RyICJFLU1haWwtRWluc3RlbGx1bmdlbiIKIAotIzogYnVpbHRpbi9sb2cuYzoxNTk5CisjOiBidWlsdGluL2xvZy5jOjE2MDAKIG1zZ2lkICJoZWFkZXIiCiBtc2dzdHIgIkhlYWRlciIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjAwCisjOiBidWlsdGluL2xvZy5jOjE2MDEKIG1zZ2lkICJhZGQgZW1haWwgaGVhZGVyIgogbXNnc3RyICJFLU1haWwtSGVhZGVyIGhpbnp1ZsO8Z2VuIgogCi0jOiBidWlsdGluL2xvZy5jOjE2MDEgYnVpbHRpbi9sb2cuYzoxNjAzCisjOiBidWlsdGluL2xvZy5jOjE2MDIgYnVpbHRpbi9sb2cuYzoxNjA0CiBtc2dpZCAiZW1haWwiCiBtc2dzdHIgIkUtTWFpbCIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjAxCisjOiBidWlsdGluL2xvZy5jOjE2MDIKIG1zZ2lkICJhZGQgVG86IGhlYWRlciIKIG1zZ3N0ciAiXCJUbzpcIi1IZWFkZXIgaGluenVmw7xnZW4iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTYwMworIzogYnVpbHRpbi9sb2cuYzoxNjA0CiBtc2dpZCAiYWRkIENjOiBoZWFkZXIiCiBtc2dzdHIgIlwiQ2M6XCItSGVhZGVyIGhpbnp1ZsO8Z2VuIgogCi0jOiBidWlsdGluL2xvZy5jOjE2MDUKKyM6IGJ1aWx0aW4vbG9nLmM6MTYwNgogbXNnaWQgImlkZW50IgogbXNnc3RyICJJZGVudCIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjA2CisjOiBidWlsdGluL2xvZy5jOjE2MDcKIG1zZ2lkICJzZXQgRnJvbSBhZGRyZXNzIHRvIDxpZGVudD4gKG9yIGNvbW1pdHRlciBpZGVudCBpZiBhYnNlbnQpIgogbXNnc3RyICIiCiAiXCJGcm9tXCItQWRyZXNzZSBhdWYgPElkZW50PiBzZXR6ZW4gKG9kZXIgSWRlbnQgZGVzIENvbW1pdC1FcnN0ZWxsZXJzLCB3ZW5uICIKICJmZWhsZW5kKSIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjA4CisjOiBidWlsdGluL2xvZy5jOjE2MDkKIG1zZ2lkICJtZXNzYWdlLWlkIgogbXNnc3RyICJtZXNzYWdlLWlkIgogCi0jOiBidWlsdGluL2xvZy5jOjE2MDkKKyM6IGJ1aWx0aW4vbG9nLmM6MTYxMAogbXNnaWQgIm1ha2UgZmlyc3QgbWFpbCBhIHJlcGx5IHRvIDxtZXNzYWdlLWlkPiIKIG1zZ3N0ciAiYXVzIGVyc3RlciBFLU1haWwgZWluZSBBbnR3b3J0IHp1IDxtZXNzYWdlLWlkPiBtYWNoZW4iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTYxMCBidWlsdGluL2xvZy5jOjE2MTMKKyM6IGJ1aWx0aW4vbG9nLmM6MTYxMSBidWlsdGluL2xvZy5jOjE2MTQKIG1zZ2lkICJib3VuZGFyeSIKIG1zZ3N0ciAiR3JlbnplIgogCi0jOiBidWlsdGluL2xvZy5jOjE2MTEKKyM6IGJ1aWx0aW4vbG9nLmM6MTYxMgogbXNnaWQgImF0dGFjaCB0aGUgcGF0Y2giCiBtc2dzdHIgImRlbiBQYXRjaCBhbmjDpG5nZW4iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTYxNAorIzogYnVpbHRpbi9sb2cuYzoxNjE1CiBtc2dpZCAiaW5saW5lIHRoZSBwYXRjaCIKIG1zZ3N0ciAiZGVuIFBhdGNoIGRpcmVrdCBpbiBkaWUgTmFjaHJpY2h0IGVpbmbDvGdlbiIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjE4CisjOiBidWlsdGluL2xvZy5jOjE2MTkKIG1zZ2lkICJlbmFibGUgbWVzc2FnZSB0aHJlYWRpbmcsIHN0eWxlczogc2hhbGxvdywgZGVlcCIKIG1zZ3N0ciAiTmFjaHJpY2h0ZW52ZXJrZXR0dW5nIGFrdGl2aWVyZW4sIFN0aWxlOiBzaGFsbG93LCBkZWVwIgogCi0jOiBidWlsdGluL2xvZy5jOjE2MjAKKyM6IGJ1aWx0aW4vbG9nLmM6MTYyMQogbXNnaWQgInNpZ25hdHVyZSIKIG1zZ3N0ciAiU2lnbmF0dXIiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTYyMQorIzogYnVpbHRpbi9sb2cuYzoxNjIyCiBtc2dpZCAiYWRkIGEgc2lnbmF0dXJlIgogbXNnc3RyICJlaW5lIFNpZ25hdHVyIGhpbnp1ZsO8Z2VuIgogCi0jOiBidWlsdGluL2xvZy5jOjE2MjIKKyM6IGJ1aWx0aW4vbG9nLmM6MTYyMwogbXNnaWQgImJhc2UtY29tbWl0IgogbXNnc3RyICJCYXNpcy1Db21taXQiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTYyMworIzogYnVpbHRpbi9sb2cuYzoxNjI0CiBtc2dpZCAiYWRkIHByZXJlcXVpc2l0ZSB0cmVlIGluZm8gdG8gdGhlIHBhdGNoIHNlcmllcyIKIG1zZ3N0ciAiZXJmb3JkZXJsaWNoZSBSZXZpc2lvbnMtSW5mb3JtYXRpb25lbiBkZXIgUGF0Y2gtU2VyaWUgaGluenVmw7xnZW4iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTYyNQorIzogYnVpbHRpbi9sb2cuYzoxNjI2CiBtc2dpZCAiYWRkIGEgc2lnbmF0dXJlIGZyb20gYSBmaWxlIgogbXNnc3RyICJlaW5lIFNpZ25hdHVyIGF1cyBlaW5lciBEYXRlaSBoaW56dWbDvGdlbiIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjI2CisjOiBidWlsdGluL2xvZy5jOjE2MjcKIG1zZ2lkICJkb24ndCBwcmludCB0aGUgcGF0Y2ggZmlsZW5hbWVzIgogbXNnc3RyICJrZWluZSBEYXRlaW5hbWVuIGRlciBQYXRjaGVzIGFuemVpZ2VuIgogCi0jOiBidWlsdGluL2xvZy5jOjE2MjgKKyM6IGJ1aWx0aW4vbG9nLmM6MTYyOQogbXNnaWQgInNob3cgcHJvZ3Jlc3Mgd2hpbGUgZ2VuZXJhdGluZyBwYXRjaGVzIgogbXNnc3RyICJGb3JzY2hyaXR0c2FuemVpZ2Ugd8OkaHJlbmQgZGVyIEVyemV1Z3VuZyBkZXIgUGF0Y2hlcyIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjMwCisjOiBidWlsdGluL2xvZy5jOjE2MzEKIG1zZ2lkICJzaG93IGNoYW5nZXMgYWdhaW5zdCA8cmV2PiBpbiBjb3ZlciBsZXR0ZXIgb3Igc2luZ2xlIHBhdGNoIgogbXNnc3RyICIiCiAiw4RuZGVydW5nZW4gZ2VnZW7DvGJlciA8Q29tbWl0PiBpbSBEZWNrYmxhdHQgb2RlciBlaW56ZWxuZW0gUGF0Y2ggYW56ZWlnZW4iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTYzMworIzogYnVpbHRpbi9sb2cuYzoxNjM0CiBtc2dpZCAic2hvdyBjaGFuZ2VzIGFnYWluc3QgPHJlZnNwZWM+IGluIGNvdmVyIGxldHRlciBvciBzaW5nbGUgcGF0Y2giCiBtc2dzdHIgIiIKICLDhG5kZXJ1bmdlbiBnZWdlbsO8YmVyIDxSZWZzcGVjPiBpbSBEZWNrYmxhdHQgb2RlciBlaW56ZWxuZW0gUGF0Y2ggYW56ZWlnZW4iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTYzNQorIzogYnVpbHRpbi9sb2cuYzoxNjM2CiBtc2dpZCAicGVyY2VudGFnZSBieSB3aGljaCBjcmVhdGlvbiBpcyB3ZWlnaHRlZCIKIG1zZ3N0ciAiUHJvemVudHNhdHogbWl0IHdlbGNoZW0gRXJ6ZXVndW5nIGdld2ljaHRldCB3aXJkIgogCi0jOiBidWlsdGluL2xvZy5jOjE3MTAKKyM6IGJ1aWx0aW4vbG9nLmM6MTcxMQogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIGlkZW50IGxpbmU6ICVzIgogbXNnc3RyICJVbmfDvGx0aWdlIElkZW50aWZpa2F0aW9uc3plaWxlOiAlcyIKIAotIzogYnVpbHRpbi9sb2cuYzoxNzI1CisjOiBidWlsdGluL2xvZy5jOjE3MjYKIG1zZ2lkICItbiBhbmQgLWsgYXJlIG11dHVhbGx5IGV4Y2x1c2l2ZSIKIG1zZ3N0ciAiLW4gdW5kIC1rIHNjaGxpZcOfZW4gc2ljaCBnZWdlbnNlaXRpZyBhdXMuIgogCi0jOiBidWlsdGluL2xvZy5jOjE3MjcKKyM6IGJ1aWx0aW4vbG9nLmM6MTcyOAogbXNnaWQgIi0tc3ViamVjdC1wcmVmaXgvLS1yZmMgYW5kIC1rIGFyZSBtdXR1YWxseSBleGNsdXNpdmUiCiBtc2dzdHIgIi0tc3ViamVjdC1wcmVmaXgvLS1yZmMgdW5kIC1rIHNjaGxpZcOfZW4gc2ljaCBnZWdlbnNlaXRpZyBhdXMuIgogCi0jOiBidWlsdGluL2xvZy5jOjE3MzUKKyM6IGJ1aWx0aW4vbG9nLmM6MTczNgogbXNnaWQgIi0tbmFtZS1vbmx5IGRvZXMgbm90IG1ha2Ugc2Vuc2UiCiBtc2dzdHIgIkRpZSBPcHRpb24gLS1uYW1lLW9ubHkga2FubiBuaWNodCB2ZXJ3ZW5kZXQgd2VyZGVuLiIKIAotIzogYnVpbHRpbi9sb2cuYzoxNzM3CisjOiBidWlsdGluL2xvZy5jOjE3MzgKIG1zZ2lkICItLW5hbWUtc3RhdHVzIGRvZXMgbm90IG1ha2Ugc2Vuc2UiCiBtc2dzdHIgIkRpZSBPcHRpb24gLS1uYW1lLXN0YXR1cyBrYW5uIG5pY2h0IHZlcndlbmRldCB3ZXJkZW4uIgogCi0jOiBidWlsdGluL2xvZy5jOjE3MzkKKyM6IGJ1aWx0aW4vbG9nLmM6MTc0MAogbXNnaWQgIi0tY2hlY2sgZG9lcyBub3QgbWFrZSBzZW5zZSIKIG1zZ3N0ciAiRGllIE9wdGlvbiAtLWNoZWNrIGthbm4gbmljaHQgdmVyd2VuZGV0IHdlcmRlbi4iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTc3MQorIzogYnVpbHRpbi9sb2cuYzoxNzczCiBtc2dpZCAic3RhbmRhcmQgb3V0cHV0LCBvciBkaXJlY3RvcnksIHdoaWNoIG9uZT8iCiBtc2dzdHIgIlN0YW5kYXJkLUF1c2dhYmUgb2RlciBWZXJ6ZWljaG5pcywgd2VsY2hlcyB2b24gYmVpZGVtPyIKIAotIzogYnVpbHRpbi9sb2cuYzoxODYwCisjOiBidWlsdGluL2xvZy5jOjE4NzcKIG1zZ2lkICItLWludGVyZGlmZiByZXF1aXJlcyAtLWNvdmVyLWxldHRlciBvciBzaW5nbGUgcGF0Y2giCiBtc2dzdHIgIi0taW50ZXJkaWZmIGVyZm9yZGVydCAtLWNvdmVyLWxldHRlciBvZGVyIGVpbnplbG5lbiBQYXRjaC4iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTg2NAorIzogYnVpbHRpbi9sb2cuYzoxODgxCiBtc2dpZCAiSW50ZXJkaWZmOiIKIG1zZ3N0ciAiSW50ZXJkaWZmOiIKIAotIzogYnVpbHRpbi9sb2cuYzoxODY1CisjOiBidWlsdGluL2xvZy5jOjE4ODIKICMsIGMtZm9ybWF0CiBtc2dpZCAiSW50ZXJkaWZmIGFnYWluc3QgdiVkOiIKIG1zZ3N0ciAiSW50ZXJkaWZmIGdlZ2VuIHYlZDoiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTg3MQorIzogYnVpbHRpbi9sb2cuYzoxODg4CiBtc2dpZCAiLS1jcmVhdGlvbi1mYWN0b3IgcmVxdWlyZXMgLS1yYW5nZS1kaWZmIgogbXNnc3RyICItLWNyZWF0aW9uLWZhY3RvciBlcmZvcmRlcnQgLS1yYW5nZS1kaWZmIgogCi0jOiBidWlsdGluL2xvZy5jOjE4NzUKKyM6IGJ1aWx0aW4vbG9nLmM6MTg5MgogbXNnaWQgIi0tcmFuZ2UtZGlmZiByZXF1aXJlcyAtLWNvdmVyLWxldHRlciBvciBzaW5nbGUgcGF0Y2giCiBtc2dzdHIgIi0tcmFuZ2UtZGlmZiBlcmZvcmRlcnQgLS1jb3Zlci1sZXR0ZXIgb2RlciBlaW56ZWxuZW4gUGF0Y2guIgogCi0jOiBidWlsdGluL2xvZy5jOjE4ODMKKyM6IGJ1aWx0aW4vbG9nLmM6MTkwMAogbXNnaWQgIlJhbmdlLWRpZmY6IgogbXNnc3RyICJSYW5nZS1EaWZmOiIKIAotIzogYnVpbHRpbi9sb2cuYzoxODg0CisjOiBidWlsdGluL2xvZy5jOjE5MDEKICMsIGMtZm9ybWF0CiBtc2dpZCAiUmFuZ2UtZGlmZiBhZ2FpbnN0IHYlZDoiCiBtc2dzdHIgIlJhbmdlLURpZmYgZ2VnZW4gdiVkOiIKIAotIzogYnVpbHRpbi9sb2cuYzoxODk1CisjOiBidWlsdGluL2xvZy5jOjE5MTIKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHJlYWQgc2lnbmF0dXJlIGZpbGUgJyVzJyIKIG1zZ3N0ciAiS29ubnRlIFNpZ25hdHVyLURhdGVpICclcycgbmljaHQgbGVzZW4iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTkzMQorIzogYnVpbHRpbi9sb2cuYzoxOTQ4CiBtc2dpZCAiR2VuZXJhdGluZyBwYXRjaGVzIgogbXNnc3RyICJFcnpldWdlIFBhdGNoZXMiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTk3NQorIzogYnVpbHRpbi9sb2cuYzoxOTkyCiBtc2dpZCAiZmFpbGVkIHRvIGNyZWF0ZSBvdXRwdXQgZmlsZXMiCiBtc2dzdHIgIkZlaGxlciBiZWltIEVyc3RlbGxlbiBkZXIgQXVzZ2FiZWRhdGVpZW4uIgogCi0jOiBidWlsdGluL2xvZy5jOjIwMzQKKyM6IGJ1aWx0aW4vbG9nLmM6MjA1MQogbXNnaWQgImdpdCBjaGVycnkgWy12XSBbPHVwc3RyZWFtPiBbPGhlYWQ+IFs8bGltaXQ+XV1dIgogbXNnc3RyICJnaXQgY2hlcnJ5IFstdl0gWzxVcHN0cmVhbT4gWzxCcmFuY2g+IFs8TGltaXQ+XV1dIgogCi0jOiBidWlsdGluL2xvZy5jOjIwODgKKyM6IGJ1aWx0aW4vbG9nLmM6MjEwNQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiQ291bGQgbm90IGZpbmQgYSB0cmFja2VkIHJlbW90ZSBicmFuY2gsIHBsZWFzZSBzcGVjaWZ5IDx1cHN0cmVhbT4gbWFudWFsbHkuXG4iCkBAIC0xNTExOCw3ICsxNTIwMSw3IEBACiBtc2dpZCAiZG8gbm90IHByaW50IHJlbW90ZSBVUkwiCiBtc2dzdHIgIlVSTCBkZXMgUmVtb3RlLVJlcG9zaXRvcmllcyBuaWNodCBhdXNnZWJlbiIKIAotIzogYnVpbHRpbi9scy1yZW1vdGUuYzo2MCBidWlsdGluL2xzLXJlbW90ZS5jOjYyIGJ1aWx0aW4vcmViYXNlLmM6MTQ2NAorIzogYnVpbHRpbi9scy1yZW1vdGUuYzo2MCBidWlsdGluL2xzLXJlbW90ZS5jOjYyIGJ1aWx0aW4vcmViYXNlLmM6MTQ4OAogbXNnaWQgImV4ZWMiCiBtc2dzdHIgIlByb2dyYW1tIgogCkBAIC0xNTIzMSwzMyArMTUzMTQsMzMgQEAKIG1zZ2lkICJBdmFpbGFibGUgY3VzdG9tIHN0cmF0ZWdpZXMgYXJlOiIKIG1zZ3N0ciAiVmVyZsO8Z2JhcmUgYmVudXR6ZXJkZWZpbmllcnRlIFN0cmF0ZWdpZW4gc2luZDoiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoyNDQgYnVpbHRpbi9wdWxsLmM6MTUxCisjOiBidWlsdGluL21lcmdlLmM6MjQ0IGJ1aWx0aW4vcHVsbC5jOjE1MgogbXNnaWQgImRvIG5vdCBzaG93IGEgZGlmZnN0YXQgYXQgdGhlIGVuZCBvZiB0aGUgbWVyZ2UiCiBtc2dzdHIgImtlaW5lIFp1c2FtbWVuZmFzc3VuZyBkZXIgVW50ZXJzY2hpZWRlIGFtIFNjaGx1c3MgZGVzIE1lcmdlcyBhbnplaWdlbiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjI0NyBidWlsdGluL3B1bGwuYzoxNTQKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoyNDcgYnVpbHRpbi9wdWxsLmM6MTU1CiBtc2dpZCAic2hvdyBhIGRpZmZzdGF0IGF0IHRoZSBlbmQgb2YgdGhlIG1lcmdlIgogbXNnc3RyICJlaW5lIFp1c2FtbWVuZmFzc3VuZyBkZXIgVW50ZXJzY2hpZWRlIGFtIFNjaGx1c3MgZGVzIE1lcmdlcyBhbnplaWdlbiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjI0OCBidWlsdGluL3B1bGwuYzoxNTcKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoyNDggYnVpbHRpbi9wdWxsLmM6MTU4CiBtc2dpZCAiKHN5bm9ueW0gdG8gLS1zdGF0KSIKIG1zZ3N0ciAiKFN5bm9ueW0gZsO8ciAtLXN0YXQpIgogCi0jOiBidWlsdGluL21lcmdlLmM6MjUwIGJ1aWx0aW4vcHVsbC5jOjE2MAorIzogYnVpbHRpbi9tZXJnZS5jOjI1MCBidWlsdGluL3B1bGwuYzoxNjEKIG1zZ2lkICJhZGQgKGF0IG1vc3QgPG4+KSBlbnRyaWVzIGZyb20gc2hvcnRsb2cgdG8gbWVyZ2UgY29tbWl0IG1lc3NhZ2UiCiBtc2dzdHIgIiIKICIoaMO2Y2hzdGVucyA8bj4pIEVpbnRyw6RnZSB2b24gXCJzaG9ydGxvZ1wiIHp1ciBCZXNjaHJlaWJ1bmcgZGVzIE1lcmdlLUNvbW1pdHMgIgogImhpbnp1ZsO8Z2VuIgogCi0jOiBidWlsdGluL21lcmdlLmM6MjUzIGJ1aWx0aW4vcHVsbC5jOjE2NgorIzogYnVpbHRpbi9tZXJnZS5jOjI1MyBidWlsdGluL3B1bGwuYzoxNjcKIG1zZ2lkICJjcmVhdGUgYSBzaW5nbGUgY29tbWl0IGluc3RlYWQgb2YgZG9pbmcgYSBtZXJnZSIKIG1zZ3N0ciAiZWluZW4gZWluemVsbmVuIENvbW1pdCBhbnN0YXR0IGVpbmVzIE1lcmdlcyBlcnpldWdlbiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjI1NSBidWlsdGluL3B1bGwuYzoxNjkKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoyNTUgYnVpbHRpbi9wdWxsLmM6MTcwCiBtc2dpZCAicGVyZm9ybSBhIGNvbW1pdCBpZiB0aGUgbWVyZ2Ugc3VjY2VlZHMgKGRlZmF1bHQpIgogbXNnc3RyICJlaW5lbiBDb21taXQgZHVyY2hmw7xocmVuLCB3ZW5uIGRlciBNZXJnZSBlcmZvbGdyZWljaCB3YXIgKFN0YW5kYXJkKSIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjI1NyBidWlsdGluL3B1bGwuYzoxNzIKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoyNTcgYnVpbHRpbi9wdWxsLmM6MTczCiBtc2dpZCAiZWRpdCBtZXNzYWdlIGJlZm9yZSBjb21taXR0aW5nIgogbXNnc3RyICJCZWFyYmVpdHVuZyBkZXIgQmVzY2hyZWlidW5nIHZvciBkZW0gQ29tbWl0IgogCkBAIC0xNTI2NSwyOCArMTUzNDgsMjggQEAKIG1zZ2lkICJhbGxvdyBmYXN0LWZvcndhcmQgKGRlZmF1bHQpIgogbXNnc3RyICJWb3JzcHVsZW4gZXJsYXViZW4gKFN0YW5kYXJkKSIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjI2MSBidWlsdGluL3B1bGwuYzoxNzkKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoyNjEgYnVpbHRpbi9wdWxsLmM6MTgwCiBtc2dpZCAiYWJvcnQgaWYgZmFzdC1mb3J3YXJkIGlzIG5vdCBwb3NzaWJsZSIKIG1zZ3N0ciAiYWJicmVjaGVuLCB3ZW5uIGtlaW4gVm9yc3B1bGVuIG3DtmdsaWNoIGlzdCIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjI2NSBidWlsdGluL3B1bGwuYzoxODIKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoyNjUgYnVpbHRpbi9wdWxsLmM6MTgzCiBtc2dpZCAidmVyaWZ5IHRoYXQgdGhlIG5hbWVkIGNvbW1pdCBoYXMgYSB2YWxpZCBHUEcgc2lnbmF0dXJlIgogbXNnc3RyICJkZW4gZ2VuYW5udGVuIENvbW1pdCBhdWYgZWluZSBnw7xsdGlnZSBHUEctU2lnbmF0dXIgw7xiZXJwcsO8ZmVuIgogCi0jOiBidWlsdGluL21lcmdlLmM6MjY2IGJ1aWx0aW4vbm90ZXMuYzo3ODcgYnVpbHRpbi9wdWxsLmM6MTg2Ci0jOiBidWlsdGluL3JlYmFzZS5jOjQ5MiBidWlsdGluL3JlYmFzZS5jOjE0NzcgYnVpbHRpbi9yZXZlcnQuYzoxMTQKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoyNjYgYnVpbHRpbi9ub3Rlcy5jOjc4NyBidWlsdGluL3B1bGwuYzoxODcKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDkzIGJ1aWx0aW4vcmViYXNlLmM6MTUwMSBidWlsdGluL3JldmVydC5jOjExNAogbXNnaWQgInN0cmF0ZWd5IgogbXNnc3RyICJTdHJhdGVnaWUiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoyNjcgYnVpbHRpbi9wdWxsLmM6MTg3CisjOiBidWlsdGluL21lcmdlLmM6MjY3IGJ1aWx0aW4vcHVsbC5jOjE4OAogbXNnaWQgIm1lcmdlIHN0cmF0ZWd5IHRvIHVzZSIKIG1zZ3N0ciAienUgdmVyd2VuZGVuZGUgTWVyZ2UtU3RyYXRlZ2llIgogCi0jOiBidWlsdGluL21lcmdlLmM6MjY4IGJ1aWx0aW4vcHVsbC5jOjE5MAorIzogYnVpbHRpbi9tZXJnZS5jOjI2OCBidWlsdGluL3B1bGwuYzoxOTEKIG1zZ2lkICJvcHRpb249dmFsdWUiCiBtc2dzdHIgIk9wdGlvbj1XZXJ0IgogCi0jOiBidWlsdGluL21lcmdlLmM6MjY5IGJ1aWx0aW4vcHVsbC5jOjE5MQorIzogYnVpbHRpbi9tZXJnZS5jOjI2OSBidWlsdGluL3B1bGwuYzoxOTIKIG1zZ2lkICJvcHRpb24gZm9yIHNlbGVjdGVkIG1lcmdlIHN0cmF0ZWd5IgogbXNnc3RyICJPcHRpb24gZsO8ciBhdXNnZXfDpGhsdGUgTWVyZ2UtU3RyYXRlZ2llIgogCkBAIC0xNTMwNywxMyArMTUzOTAsMTMgQEAKIG1zZ2lkICJjb250aW51ZSB0aGUgY3VycmVudCBpbi1wcm9ncmVzcyBtZXJnZSIKIG1zZ3N0ciAiZGVuIHNpY2ggaW0gR2FuZ2UgYmVmaW5kbGljaGVuIE1lcmdlIGZvcnRzZXR6ZW4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoyODQgYnVpbHRpbi9wdWxsLmM6MTk4CisjOiBidWlsdGluL21lcmdlLmM6Mjg0IGJ1aWx0aW4vcHVsbC5jOjE5OQogbXNnaWQgImFsbG93IG1lcmdpbmcgdW5yZWxhdGVkIGhpc3RvcmllcyIKIG1zZ3N0ciAiZXJsYXViZSBkYXMgWnVzYW1tZW5mw7xocmVuIHZvbiBuaWNodCB6dXNhbW1lbmjDpG5nZW5kZW4gSGlzdG9yaWVuIgogCiAjOiBidWlsdGluL21lcmdlLmM6MjkwCi1tc2dpZCAidmVyaWZ5IGNvbW1pdC1tc2cgaG9vayIKLW1zZ3N0ciAiY29tbWl0LW1zZyBIb29rIMO8YmVycHLDvGZlbiIKK21zZ2lkICJieXBhc3MgcHJlLW1lcmdlLWNvbW1pdCBhbmQgY29tbWl0LW1zZyBob29rcyIKK21zZ3N0ciAiSG9va3MgcHJlLW1lcmdlLWNvbW1pdCB1bmQgY29tbWl0LW1zZyB1bWdlaGVuIgogCiAjOiBidWlsdGluL21lcmdlLmM6MzA3CiBtc2dpZCAiY291bGQgbm90IHJ1biBzdGFzaC4iCkBAIC0xNTM1NiwzMyArMTU0MzksMzMgQEAKIG1zZ2lkICJCYWQgYnJhbmNoLiVzLm1lcmdlb3B0aW9ucyBzdHJpbmc6ICVzIgogbXNnc3RyICJVbmfDvGx0aWdlciBicmFuY2guJXMubWVyZ2VvcHRpb25zIFN0cmluZzogJXMiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzo3MDgKKyM6IGJ1aWx0aW4vbWVyZ2UuYzo3MDUKIG1zZ2lkICJOb3QgaGFuZGxpbmcgYW55dGhpbmcgb3RoZXIgdGhhbiB0d28gaGVhZHMgbWVyZ2UuIgogbXNnc3RyICJFcyB3aXJkIG51ciBkZXIgTWVyZ2Ugdm9uIHp3ZWkgQnJhbmNoZXMgYmVoYW5kZWx0LiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjcyMgorIzogYnVpbHRpbi9tZXJnZS5jOjcxOQogIywgYy1mb3JtYXQKIG1zZ2lkICJVbmtub3duIG9wdGlvbiBmb3IgbWVyZ2UtcmVjdXJzaXZlOiAtWCVzIgogbXNnc3RyICJVbmJla2FubnRlIE9wdGlvbiBmw7xyIG1lcmdlLXJlY3Vyc2l2ZTogLVglcyIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjczNworIzogYnVpbHRpbi9tZXJnZS5jOjczNAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gd3JpdGUgJXMiCiBtc2dzdHIgImtvbm50ZSAlcyBuaWNodCBzY2hyZWliZW4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzo3ODkKKyM6IGJ1aWx0aW4vbWVyZ2UuYzo3ODYKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ291bGQgbm90IHJlYWQgZnJvbSAnJXMnIgogbXNnc3RyICJrb25udGUgbmljaHQgdm9uICclcycgbGVzZW4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzo3OTgKKyM6IGJ1aWx0aW4vbWVyZ2UuYzo3OTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiTm90IGNvbW1pdHRpbmcgbWVyZ2U7IHVzZSAnZ2l0IGNvbW1pdCcgdG8gY29tcGxldGUgdGhlIG1lcmdlLlxuIgogbXNnc3RyICIiCiAiTWVyZ2Ugd3VyZGUgbmljaHQgY29tbWl0dGV0OyBiZW51dHplbiBTaWUgJ2dpdCBjb21taXQnLCB1bSBkZW4gTWVyZ2UgIgogImFienVzY2hsaWXDn2VuLlxuIgogCi0jOiBidWlsdGluL21lcmdlLmM6ODA0CisjOiBidWlsdGluL21lcmdlLmM6ODAxCiBtc2dpZCAiIgogIlBsZWFzZSBlbnRlciBhIGNvbW1pdCBtZXNzYWdlIHRvIGV4cGxhaW4gd2h5IHRoaXMgbWVyZ2UgaXMgbmVjZXNzYXJ5LFxuIgogImVzcGVjaWFsbHkgaWYgaXQgbWVyZ2VzIGFuIHVwZGF0ZWQgdXBzdHJlYW0gaW50byBhIHRvcGljIGJyYW5jaC5cbiIKQEAgLTE1MzkzLDExICsxNTQ3NiwxMSBAQAogIlVwc3RyZWFtLUJyYW5jaCBtaXQgZWluZW0gVGhlbWEtQnJhbmNoIHp1c2FtbWVuZsO8aHJ0LlxuIgogIlxuIgogCi0jOiBidWlsdGluL21lcmdlLmM6ODA5CisjOiBidWlsdGluL21lcmdlLmM6ODA2CiBtc2dpZCAiQW4gZW1wdHkgbWVzc2FnZSBhYm9ydHMgdGhlIGNvbW1pdC5cbiIKIG1zZ3N0ciAiRWluZSBsZWVyZSBDb21taXQtQmVzY2hyZWlidW5nIGJyaWNodCBkZW4gQ29tbWl0IGFiLlxuIgogCi0jOiBidWlsdGluL21lcmdlLmM6ODEyCisjOiBidWlsdGluL21lcmdlLmM6ODA5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJMaW5lcyBzdGFydGluZyB3aXRoICclYycgd2lsbCBiZSBpZ25vcmVkLCBhbmQgYW4gZW1wdHkgbWVzc2FnZSBhYm9ydHNcbiIKQEAgLTE1NDA2LDc1ICsxNTQ4OSw3NSBAQAogIlplaWxlbiwgZGllIG1pdCAnJWMnIGJlZ2lubmVuLCB3ZXJkZW4gaWdub3JpZXJ0LFxuIgogInVuZCBlaW5lIGxlZXJlIEJlc2NocmVpYnVuZyBicmljaHQgZGVuIENvbW1pdCBhYi5cbiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjg1MworIzogYnVpbHRpbi9tZXJnZS5jOjg2MgogbXNnaWQgIkVtcHR5IGNvbW1pdCBtZXNzYWdlLiIKIG1zZ3N0ciAiTGVlcmUgQ29tbWl0LUJlc2NocmVpYnVuZyIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjg3MgorIzogYnVpbHRpbi9tZXJnZS5jOjg3NwogIywgYy1mb3JtYXQKIG1zZ2lkICJXb25kZXJmdWwuXG4iCiBtc2dzdHIgIld1bmRlcmJhci5cbiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjkzMworIzogYnVpbHRpbi9tZXJnZS5jOjkzOAogIywgYy1mb3JtYXQKIG1zZ2lkICJBdXRvbWF0aWMgbWVyZ2UgZmFpbGVkOyBmaXggY29uZmxpY3RzIGFuZCB0aGVuIGNvbW1pdCB0aGUgcmVzdWx0LlxuIgogbXNnc3RyICIiCiAiQXV0b21hdGlzY2hlciBNZXJnZSBmZWhsZ2VzY2hsYWdlbjsgYmVoZWJlbiBTaWUgZGllIEtvbmZsaWt0ZSB1bmQgY29tbWl0dGVuICIKICJTaWUgZGFubiBkYXMgRXJnZWJuaXMuXG4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzo5NzIKKyM6IGJ1aWx0aW4vbWVyZ2UuYzo5NzcKIG1zZ2lkICJObyBjdXJyZW50IGJyYW5jaC4iCiBtc2dzdHIgIlNpZSBiZWZpbmRlbiBzaWNoIGF1ZiBrZWluZW0gQnJhbmNoLiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjk3NAorIzogYnVpbHRpbi9tZXJnZS5jOjk3OQogbXNnaWQgIk5vIHJlbW90ZSBmb3IgdGhlIGN1cnJlbnQgYnJhbmNoLiIKIG1zZ3N0ciAiS2VpbiBSZW1vdGUtUmVwb3NpdG9yeSBmw7xyIGRlbiBha3R1ZWxsZW4gQnJhbmNoLiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjk3NgorIzogYnVpbHRpbi9tZXJnZS5jOjk4MQogbXNnaWQgIk5vIGRlZmF1bHQgdXBzdHJlYW0gZGVmaW5lZCBmb3IgdGhlIGN1cnJlbnQgYnJhbmNoLiIKIG1zZ3N0ciAiIgogIkVzIGlzdCBrZWluIFN0YW5kYXJkLVVwc3RyZWFtLUJyYW5jaCBmw7xyIGRlbiBha3R1ZWxsZW4gQnJhbmNoIGRlZmluaWVydC4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzo5ODEKKyM6IGJ1aWx0aW4vbWVyZ2UuYzo5ODYKICMsIGMtZm9ybWF0CiBtc2dpZCAiTm8gcmVtb3RlLXRyYWNraW5nIGJyYW5jaCBmb3IgJXMgZnJvbSAlcyIKIG1zZ3N0ciAiS2VpbiBSZW1vdGUtVHJhY2tpbmctQnJhbmNoIGbDvHIgJXMgdm9uICVzIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTAzOAorIzogYnVpbHRpbi9tZXJnZS5jOjEwNDMKICMsIGMtZm9ybWF0CiBtc2dpZCAiQmFkIHZhbHVlICclcycgaW4gZW52aXJvbm1lbnQgJyVzJyIKIG1zZ3N0ciAiRmVobGVyaGFmdGVyIFdlcnQgJyVzJyBpbiBVbWdlYnVuZ3N2YXJpYWJsZSAnJXMnIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTE0MQorIzogYnVpbHRpbi9tZXJnZS5jOjExNDYKICMsIGMtZm9ybWF0CiBtc2dpZCAibm90IHNvbWV0aGluZyB3ZSBjYW4gbWVyZ2UgaW4gJXM6ICVzIgogbXNnc3RyICJuaWNodHMgd2FzIHdpciBpbiAlcyB6dXNhbW1lbmbDvGhyZW4ga8O2bm5lbjogJXMiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxMTc1CisjOiBidWlsdGluL21lcmdlLmM6MTE4MAogbXNnaWQgIm5vdCBzb21ldGhpbmcgd2UgY2FuIG1lcmdlIgogbXNnc3RyICJuaWNodHMgd2FzIHdpciB6dXNhbW1lbmbDvGhyZW4ga8O2bm5lbiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjEyNzgKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxMjgzCiBtc2dpZCAiLS1hYm9ydCBleHBlY3RzIG5vIGFyZ3VtZW50cyIKIG1zZ3N0ciAiLS1hYm9ydCBha3plcHRpZXJ0IGtlaW5lIEFyZ3VtZW50ZSIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjEyODIKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxMjg3CiBtc2dpZCAiVGhlcmUgaXMgbm8gbWVyZ2UgdG8gYWJvcnQgKE1FUkdFX0hFQUQgbWlzc2luZykuIgogbXNnc3RyICJFcyBnaWJ0IGtlaW5lbiBNZXJnZSBhYnp1YnJlY2hlbiAoTUVSR0VfSEVBRCBmZWhsdCkiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxMjkxCisjOiBidWlsdGluL21lcmdlLmM6MTI5NgogbXNnaWQgIi0tcXVpdCBleHBlY3RzIG5vIGFyZ3VtZW50cyIKIG1zZ3N0ciAiLS1xdWl0IGVyd2FydGV0IGtlaW5lIEFyZ3VtZW50ZSIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjEzMDQKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzA5CiBtc2dpZCAiLS1jb250aW51ZSBleHBlY3RzIG5vIGFyZ3VtZW50cyIKIG1zZ3N0ciAiLS1jb250aW51ZSBlcndhcnRldCBrZWluZSBBcmd1bWVudGUiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzA4CisjOiBidWlsdGluL21lcmdlLmM6MTMxMwogbXNnaWQgIlRoZXJlIGlzIG5vIG1lcmdlIGluIHByb2dyZXNzIChNRVJHRV9IRUFEIG1pc3NpbmcpLiIKIG1zZ3N0ciAiRXMgaXN0IGtlaW4gTWVyZ2UgaW0gR2FuZ2UgKE1FUkdFX0hFQUQgZmVobHQpLiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjEzMjQKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzI5CiBtc2dpZCAiIgogIllvdSBoYXZlIG5vdCBjb25jbHVkZWQgeW91ciBtZXJnZSAoTUVSR0VfSEVBRCBleGlzdHMpLlxuIgogIlBsZWFzZSwgY29tbWl0IHlvdXIgY2hhbmdlcyBiZWZvcmUgeW91IG1lcmdlLiIKQEAgLTE1NDgyLDcgKzE1NTY1LDcgQEAKICJTaWUgaGFiZW4gSWhyZW4gTWVyZ2UgbmljaHQgYWJnZXNjaGxvc3NlbiAoTUVSR0VfSEVBRCBleGlzdGllcnQpLlxuIgogIkJpdHRlIGNvbW1pdHRlbiBTaWUgSWhyZSDDhG5kZXJ1bmdlbiwgYmV2b3IgU2llIGRlbiBNZXJnZSBhdXNmw7xocmVuLiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjEzMzEKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzM2CiBtc2dpZCAiIgogIllvdSBoYXZlIG5vdCBjb25jbHVkZWQgeW91ciBjaGVycnktcGljayAoQ0hFUlJZX1BJQ0tfSEVBRCBleGlzdHMpLlxuIgogIlBsZWFzZSwgY29tbWl0IHlvdXIgY2hhbmdlcyBiZWZvcmUgeW91IG1lcmdlLiIKQEAgLTE1NDkwLDEwMCArMTU1NzMsMTAwIEBACiAiU2llIGhhYmVuIFwiY2hlcnJ5LXBpY2tcIiBuaWNodCBhYmdlc2NobG9zc2VuIChDSEVSUllfUElDS19IRUFEIGV4aXN0aWVydCkuXG4iCiAiQml0dGUgY29tbWl0dGVuIFNpZSBJaHJlIMOEbmRlcnVuZ2VuLCBiZXZvciBTaWUgZGVuIE1lcmdlIGF1c2bDvGhyZW4uIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTMzNAorIzogYnVpbHRpbi9tZXJnZS5jOjEzMzkKIG1zZ2lkICJZb3UgaGF2ZSBub3QgY29uY2x1ZGVkIHlvdXIgY2hlcnJ5LXBpY2sgKENIRVJSWV9QSUNLX0hFQUQgZXhpc3RzKS4iCiBtc2dzdHIgIiIKICJTaWUgaGFiZW4gXCJjaGVycnktcGlja1wiIG5pY2h0IGFiZ2VzY2hsb3NzZW4gKENIRVJSWV9QSUNLX0hFQUQgZXhpc3RpZXJ0KS4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzQ4CisjOiBidWlsdGluL21lcmdlLmM6MTM1MwogbXNnaWQgIllvdSBjYW5ub3QgY29tYmluZSAtLXNxdWFzaCB3aXRoIC0tbm8tZmYuIgogbXNnc3RyICJTaWUga8O2bm5lbiAtLXNxdWFzaCBuaWNodCBtaXQgLS1uby1mZiBrb21iaW5pZXJlbi4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzUwCisjOiBidWlsdGluL21lcmdlLmM6MTM1NQogbXNnaWQgIllvdSBjYW5ub3QgY29tYmluZSAtLXNxdWFzaCB3aXRoIC0tY29tbWl0LiIKIG1zZ3N0ciAiU2llIGvDtm5uZW4gLS1zcXVhc2ggbmljaHQgbWl0IC0tY29tbWl0IGtvbWJpbmllcmVuLiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjEzNjYKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzcxCiBtc2dpZCAiTm8gY29tbWl0IHNwZWNpZmllZCBhbmQgbWVyZ2UuZGVmYXVsdFRvVXBzdHJlYW0gbm90IHNldC4iCiBtc2dzdHIgIktlaW4gQ29tbWl0IGFuZ2VnZWJlbiB1bmQgbWVyZ2UuZGVmYXVsdFRvVXBzdHJlYW0gaXN0IG5pY2h0IGdlc2V0enQuIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTM4MworIzogYnVpbHRpbi9tZXJnZS5jOjEzODgKIG1zZ2lkICJTcXVhc2ggY29tbWl0IGludG8gZW1wdHkgaGVhZCBub3Qgc3VwcG9ydGVkIHlldCIKIG1zZ3N0ciAiIgogIkJpbiBhdWYgZWluZW0gQ29tbWl0LCBkZXIgbm9jaCBnZWJvcmVuIHdpcmQ7IGthbm4gXCJzcXVhc2hcIiBuaWNodCBhdXNmw7xocmVuLiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjEzODUKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzkwCiBtc2dpZCAiTm9uLWZhc3QtZm9yd2FyZCBjb21taXQgZG9lcyBub3QgbWFrZSBzZW5zZSBpbnRvIGFuIGVtcHR5IGhlYWQiCiBtc2dzdHIgIiIKICJOaWNodCB2b3J6dXNwdWxlbmRlciBDb21taXQga2FubiBuaWNodCBpbiBlaW5lbSBsZWVyZW4gQnJhbmNoIHZlcndlbmRldCAiCiAid2VyZGVuLiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjEzOTAKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzk1CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIC0gbm90IHNvbWV0aGluZyB3ZSBjYW4gbWVyZ2UiCiBtc2dzdHIgIiVzIC0gbmljaHRzIHdhcyB3aXIgenVzYW1tZW5mw7xocmVuIGvDtm5uZW4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzkyCisjOiBidWlsdGluL21lcmdlLmM6MTM5NwogbXNnaWQgIkNhbiBtZXJnZSBvbmx5IGV4YWN0bHkgb25lIGNvbW1pdCBpbnRvIGVtcHR5IGhlYWQiCiBtc2dzdHIgIkthbm4gbnVyIGV4YWt0IGVpbmVuIENvbW1pdCBpbiBlaW5lbSBsZWVyZW4gQnJhbmNoIHp1c2FtbWVuZsO8aHJlbi4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxNDcxCisjOiBidWlsdGluL21lcmdlLmM6MTQ3NgogbXNnaWQgInJlZnVzaW5nIHRvIG1lcmdlIHVucmVsYXRlZCBoaXN0b3JpZXMiCiBtc2dzdHIgIlZlcndlaWdlcmUgZGVuIE1lcmdlIHZvbiBuaWNodCB6dXNhbW1lbmjDpG5nZW5kZW4gSGlzdG9yaWVuLiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjE0ODAKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxNDg1CiBtc2dpZCAiQWxyZWFkeSB1cCB0byBkYXRlLiIKIG1zZ3N0ciAiQmVyZWl0cyBha3R1ZWxsLiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjE0OTAKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxNDk1CiAjLCBjLWZvcm1hdAogbXNnaWQgIlVwZGF0aW5nICVzLi4lc1xuIgogbXNnc3RyICJBa3R1YWxpc2llcmUgJXMuLiVzXG4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxNTMyCisjOiBidWlsdGluL21lcmdlLmM6MTUzNwogIywgYy1mb3JtYXQKIG1zZ2lkICJUcnlpbmcgcmVhbGx5IHRyaXZpYWwgaW4taW5kZXggbWVyZ2UuLi5cbiIKIG1zZ3N0ciAiUHJvYmllcmUgd2lya2xpY2ggdHJpdmlhbGVuIFwiaW4taW5kZXhcIi1NZXJnZSAuLi5cbiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjE1MzkKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxNTQ0CiAjLCBjLWZvcm1hdAogbXNnaWQgIk5vcGUuXG4iCiBtc2dzdHIgIk5laW4uXG4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxNTY0CisjOiBidWlsdGluL21lcmdlLmM6MTU2OQogbXNnaWQgIkFscmVhZHkgdXAgdG8gZGF0ZS4gWWVlYWghIgogbXNnc3RyICJCZXJlaXRzIGFrdHVlbGwuIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTU3MAorIzogYnVpbHRpbi9tZXJnZS5jOjE1NzUKIG1zZ2lkICJOb3QgcG9zc2libGUgdG8gZmFzdC1mb3J3YXJkLCBhYm9ydGluZy4iCiBtc2dzdHIgIlZvcnNwdWxlbiBuaWNodCBtw7ZnbGljaCwgYnJlY2hlIGFiLiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjE1OTMgYnVpbHRpbi9tZXJnZS5jOjE2NTgKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxNTk4IGJ1aWx0aW4vbWVyZ2UuYzoxNjYzCiAjLCBjLWZvcm1hdAogbXNnaWQgIlJld2luZGluZyB0aGUgdHJlZSB0byBwcmlzdGluZS4uLlxuIgogbXNnc3RyICJSw7xja2xhdWYgZGVzIFZlcnplaWNobmlzc2VzIGJpcyB6dW0gVXJzcHJ1bmcgLi4uXG4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxNTk3CisjOiBidWlsdGluL21lcmdlLmM6MTYwMgogIywgYy1mb3JtYXQKIG1zZ2lkICJUcnlpbmcgbWVyZ2Ugc3RyYXRlZ3kgJXMuLi5cbiIKIG1zZ3N0ciAiUHJvYmllcmUgTWVyZ2UtU3RyYXRlZ2llICVzIC4uLlxuIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTY0OQorIzogYnVpbHRpbi9tZXJnZS5jOjE2NTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiTm8gbWVyZ2Ugc3RyYXRlZ3kgaGFuZGxlZCB0aGUgbWVyZ2UuXG4iCiBtc2dzdHIgIktlaW5lIE1lcmdlLVN0cmF0ZWdpZSBiZWhhbmRlbHQgZGllc2VuIE1lcmdlLlxuIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTY1MQorIzogYnVpbHRpbi9tZXJnZS5jOjE2NTYKICMsIGMtZm9ybWF0CiBtc2dpZCAiTWVyZ2Ugd2l0aCBzdHJhdGVneSAlcyBmYWlsZWQuXG4iCiBtc2dzdHIgIk1lcmdlIG1pdCBTdHJhdGVnaWUgJXMgZmVobGdlc2NobGFnZW4uXG4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxNjYwCisjOiBidWlsdGluL21lcmdlLmM6MTY2NQogIywgYy1mb3JtYXQKIG1zZ2lkICJVc2luZyB0aGUgJXMgdG8gcHJlcGFyZSByZXNvbHZpbmcgYnkgaGFuZC5cbiIKIG1zZ3N0ciAiQmVudXR6ZW4gU2llIFwiJXNcIiwgdW0gZGllIEF1ZmzDtnN1bmcgcGVyIEhhbmQgdm9yenViZXJlaXRlbi5cbiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjE2NzIKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxNjc3CiAjLCBjLWZvcm1hdAogbXNnaWQgIkF1dG9tYXRpYyBtZXJnZSB3ZW50IHdlbGw7IHN0b3BwZWQgYmVmb3JlIGNvbW1pdHRpbmcgYXMgcmVxdWVzdGVkXG4iCiBtc2dzdHIgIiIKQEAgLTE1NjY5LDMzICsxNTc1MiwzMyBAQAogbXNnaWQgInNldCBsYWJlbHMgZm9yIGZpbGUxL29yaWctZmlsZS9maWxlMiIKIG1zZ3N0ciAiQmVzY2hyaWZ0dW5nIGbDvHIgRGF0ZWkxL29yaWctRGF0ZWkvRGF0ZWkyIHNldHplbiIKIAotIzogYnVpbHRpbi9tZXJnZS1yZWN1cnNpdmUuYzo0NgorIzogYnVpbHRpbi9tZXJnZS1yZWN1cnNpdmUuYzo0NwogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmtub3duIG9wdGlvbiAlcyIKIG1zZ3N0ciAidW5iZWthbm50ZSBPcHRpb246ICVzIgogCi0jOiBidWlsdGluL21lcmdlLXJlY3Vyc2l2ZS5jOjUyCisjOiBidWlsdGluL21lcmdlLXJlY3Vyc2l2ZS5jOjUzCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBwYXJzZSBvYmplY3QgJyVzJyIKIG1zZ3N0ciAiS29ubnRlIE9iamVrdCAnJXMnIG5pY2h0IHBhcnNlbi4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UtcmVjdXJzaXZlLmM6NTYKKyM6IGJ1aWx0aW4vbWVyZ2UtcmVjdXJzaXZlLmM6NTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IGhhbmRsZSBtb3JlIHRoYW4gJWQgYmFzZS4gSWdub3JpbmcgJXMuIgogbXNnaWRfcGx1cmFsICJjYW5ub3QgaGFuZGxlIG1vcmUgdGhhbiAlZCBiYXNlcy4gSWdub3JpbmcgJXMuIgogbXNnc3RyWzBdICJrYW5uIG5pY2h0IG1pdCBtZWhyIGFscyAlZCBNZXJnZS1CYXNpcyB1bWdlaGVuLiBJZ25vcmllcmUgJXMuIgogbXNnc3RyWzFdICJrYW5uIG5pY2h0IG1pdCBtZWhyIGFscyAlZCBNZXJnZS1CYXNlbiB1bWdlaGVuLiBJZ25vcmllcmUgJXMuIgogCi0jOiBidWlsdGluL21lcmdlLXJlY3Vyc2l2ZS5jOjY0CisjOiBidWlsdGluL21lcmdlLXJlY3Vyc2l2ZS5jOjY1CiBtc2dpZCAibm90IGhhbmRsaW5nIGFueXRoaW5nIG90aGVyIHRoYW4gdHdvIGhlYWRzIG1lcmdlLiIKIG1zZ3N0ciAiRXMgd2lyZCBudXIgZGVyIE1lcmdlIHZvbiB6d2VpIEJyYW5jaGVzIGJlaGFuZGVsdC4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UtcmVjdXJzaXZlLmM6NzAgYnVpbHRpbi9tZXJnZS1yZWN1cnNpdmUuYzo3MgorIzogYnVpbHRpbi9tZXJnZS1yZWN1cnNpdmUuYzo3NCBidWlsdGluL21lcmdlLXJlY3Vyc2l2ZS5jOjc2CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCByZXNvbHZlIHJlZiAnJXMnIgogbXNnc3RyICJLb25udGUgUmVmZXJlbnogJyVzJyBuaWNodCBhdWZsw7ZzZW4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UtcmVjdXJzaXZlLmM6NzgKKyM6IGJ1aWx0aW4vbWVyZ2UtcmVjdXJzaXZlLmM6ODIKICMsIGMtZm9ybWF0CiBtc2dpZCAiTWVyZ2luZyAlcyB3aXRoICVzXG4iCiBtc2dzdHIgIkbDvGhyZSAlcyBtaXQgJXMgenVzYW1tZW5cbiIKQEAgLTE1ODQwLDUyICsxNTkyMyw1MiBAQAogbXNnaWQgIlJlbmFtaW5nICVzIHRvICVzXG4iCiBtc2dzdHIgIkJlbmVubmUgJXMgbmFjaCAlcyB1bVxuIgogCi0jOiBidWlsdGluL212LmM6Mjc3IGJ1aWx0aW4vcmVtb3RlLmM6NzE3IGJ1aWx0aW4vcmVwYWNrLmM6NTEwCisjOiBidWlsdGluL212LmM6Mjc3IGJ1aWx0aW4vcmVtb3RlLmM6NzE3IGJ1aWx0aW4vcmVwYWNrLmM6NTExCiAjLCBjLWZvcm1hdAogbXNnaWQgInJlbmFtaW5nICclcycgZmFpbGVkIgogbXNnc3RyICJVbWJlbmVubnVuZyB2b24gJyVzJyBmZWhsZ2VzY2hsYWdlbiIKIAotIzogYnVpbHRpbi9uYW1lLXJldi5jOjM1MgorIzogYnVpbHRpbi9uYW1lLXJldi5jOjM1NgogbXNnaWQgImdpdCBuYW1lLXJldiBbPG9wdGlvbnM+XSA8Y29tbWl0Pi4uLiIKIG1zZ3N0ciAiZ2l0IG5hbWUtcmV2IFs8T3B0aW9uZW4+XSA8Q29tbWl0Pi4uLiIKIAotIzogYnVpbHRpbi9uYW1lLXJldi5jOjM1MworIzogYnVpbHRpbi9uYW1lLXJldi5jOjM1NwogbXNnaWQgImdpdCBuYW1lLXJldiBbPG9wdGlvbnM+XSAtLWFsbCIKIG1zZ3N0ciAiZ2l0IG5hbWUtcmV2IFs8T3B0aW9uZW4+XSAtLWFsbCIKIAotIzogYnVpbHRpbi9uYW1lLXJldi5jOjM1NAorIzogYnVpbHRpbi9uYW1lLXJldi5jOjM1OAogbXNnaWQgImdpdCBuYW1lLXJldiBbPG9wdGlvbnM+XSAtLXN0ZGluIgogbXNnc3RyICJnaXQgbmFtZS1yZXYgWzxPcHRpb25lbj5dIC0tc3RkaW4iCiAKLSM6IGJ1aWx0aW4vbmFtZS1yZXYuYzo0MTEKKyM6IGJ1aWx0aW4vbmFtZS1yZXYuYzo0MTUKIG1zZ2lkICJwcmludCBvbmx5IG5hbWVzIChubyBTSEEtMSkiCiBtc2dzdHIgIm51ciBOYW1lbiBhbnplaWdlbiAoa2VpbmUgU0hBLTEpIgogCi0jOiBidWlsdGluL25hbWUtcmV2LmM6NDEyCisjOiBidWlsdGluL25hbWUtcmV2LmM6NDE2CiBtc2dpZCAib25seSB1c2UgdGFncyB0byBuYW1lIHRoZSBjb21taXRzIgogbXNnc3RyICJudXIgVGFncyB2ZXJ3ZW5kZW4sIHVtIGRpZSBDb21taXRzIHp1IGJlbmVubmVuIgogCi0jOiBidWlsdGluL25hbWUtcmV2LmM6NDE0CisjOiBidWlsdGluL25hbWUtcmV2LmM6NDE4CiBtc2dpZCAib25seSB1c2UgcmVmcyBtYXRjaGluZyA8cGF0dGVybj4iCiBtc2dzdHIgIm51ciBSZWZlcmVuemVuIHZlcndlbmRlbiwgZGllIDxNdXN0ZXI+IGVudHNwcmVjaGVuIgogCi0jOiBidWlsdGluL25hbWUtcmV2LmM6NDE2CisjOiBidWlsdGluL25hbWUtcmV2LmM6NDIwCiBtc2dpZCAiaWdub3JlIHJlZnMgbWF0Y2hpbmcgPHBhdHRlcm4+IgogbXNnc3RyICJpZ25vcmllcmUgUmVmZXJlbnplbiBkaWUgPE11c3Rlcj4gZW50c3ByZWNoZW4iCiAKLSM6IGJ1aWx0aW4vbmFtZS1yZXYuYzo0MTgKKyM6IGJ1aWx0aW4vbmFtZS1yZXYuYzo0MjIKIG1zZ2lkICJsaXN0IGFsbCBjb21taXRzIHJlYWNoYWJsZSBmcm9tIGFsbCByZWZzIgogbXNnc3RyICJhbGxlIENvbW1pdHMgYXVmbGlzdGVuLCBkaWUgdm9uIGFsbGVuIFJlZmVyZW56ZW4gZXJyZWljaGJhciBzaW5kIgogCi0jOiBidWlsdGluL25hbWUtcmV2LmM6NDE5CisjOiBidWlsdGluL25hbWUtcmV2LmM6NDIzCiBtc2dpZCAicmVhZCBmcm9tIHN0ZGluIgogbXNnc3RyICJ2b24gZGVyIFN0YW5kYXJkLUVpbmdhYmUgbGVzZW4iCiAKLSM6IGJ1aWx0aW4vbmFtZS1yZXYuYzo0MjAKKyM6IGJ1aWx0aW4vbmFtZS1yZXYuYzo0MjQKIG1zZ2lkICJhbGxvdyB0byBwcmludCBgdW5kZWZpbmVkYCBuYW1lcyAoZGVmYXVsdCkiCiBtc2dzdHIgIkF1c2dhYmUgdm9uIGB1bmRlZmluaWVydGVuYCBOYW1lbiBlcmxhdWJlbiAoU3RhbmRhcmQpIgogCi0jOiBidWlsdGluL25hbWUtcmV2LmM6NDI2CisjOiBidWlsdGluL25hbWUtcmV2LmM6NDMwCiBtc2dpZCAiZGVyZWZlcmVuY2UgdGFncyBpbiB0aGUgaW5wdXQgKGludGVybmFsIHVzZSkiCiBtc2dzdHIgIlRhZ3MgaW4gZGVyIEVpbmdhYmUgZGVyZWZlcmVuemllcmVuIChpbnRlcm5lIFZlcndlbmR1bmcpIgogCkBAIC0xNjI5MSw3ICsxNjM3NCw3IEBACiBtc2dpZCAicmVhZCBvYmplY3QgbmFtZXMgZnJvbSB0aGUgc3RhbmRhcmQgaW5wdXQiCiBtc2dzdHIgIk9iamVrdG5hbWVuIHZvbiBkZXIgU3RhbmRhcmQtRWluZ2FiZSBsZXNlbiIKIAotIzogYnVpbHRpbi9ub3Rlcy5jOjk1NCBidWlsdGluL3BydW5lLmM6MTMwIGJ1aWx0aW4vd29ya3RyZWUuYzoxNjUKKyM6IGJ1aWx0aW4vbm90ZXMuYzo5NTQgYnVpbHRpbi9wcnVuZS5jOjEzMCBidWlsdGluL3dvcmt0cmVlLmM6MTY0CiBtc2dpZCAiZG8gbm90IHJlbW92ZSwgc2hvdyBvbmx5IgogbXNnc3RyICJuaWNodCBsw7ZzY2hlbiwgbnVyIGFuemVpZ2VuIgogCkBAIC0xNjMwNyw3ICsxNjM5MCw3IEBACiBtc2dpZCAidXNlIG5vdGVzIGZyb20gPG5vdGVzLXJlZj4iCiBtc2dzdHIgIk5vdGl6ZW4gdm9uIDxOb3Rpei1SZWZlcmVuej4gdmVyd2VuZGVuIgogCi0jOiBidWlsdGluL25vdGVzLmM6MTAzNCBidWlsdGluL3N0YXNoLmM6MTU5OAorIzogYnVpbHRpbi9ub3Rlcy5jOjEwMzQgYnVpbHRpbi9zdGFzaC5jOjE2MDcKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5rbm93biBzdWJjb21tYW5kOiAlcyIKIG1zZ3N0ciAiVW5iZWthbm50ZXIgVW50ZXJiZWZlaGw6ICVzIgpAQCAtMTYzODQsNzEgKzE2NDY3LDcxIEBACiBtc2dpZCAid3JvdGUgJTxQUkl1MzI+IG9iamVjdHMgd2hpbGUgZXhwZWN0aW5nICU8UFJJdTMyPiIKIG1zZ3N0ciAiU2NocmllYiAlPFBSSXUzMj4gT2JqZWt0ZSB3w6RocmVuZCAlPFBSSXUzMj4gZXJ3YXJ0ZXQgd2FyZW4uIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjExNjYKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MTE2NAogbXNnaWQgImRpc2FibGluZyBiaXRtYXAgd3JpdGluZywgYXMgc29tZSBvYmplY3RzIGFyZSBub3QgYmVpbmcgcGFja2VkIgogbXNnc3RyICIiCiAiRGVha3RpdmllcmUgU2NocmVpYmVuIGRlciBCaXRtYXAsIGRhIGVpbmlnZSBPYmpla3RlIG5pY2h0IGluIGVpbmUgUGFjay0iCiAiRGF0ZWlcbiIKICJnZXNjaHJpZWJlbiB3dXJkZW4uIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjE1OTcKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MTU5MgogIywgYy1mb3JtYXQKIG1zZ2lkICJkZWx0YSBiYXNlIG9mZnNldCBvdmVyZmxvdyBpbiBwYWNrIGZvciAlcyIKIG1zZ3N0ciAiXCJkZWx0YSBiYXNlIG9mZnNldFwiIMOcYmVybGF1ZiBpbiBQYWtldCBmw7xyICVzIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjE2MDYKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MTYwMQogIywgYy1mb3JtYXQKIG1zZ2lkICJkZWx0YSBiYXNlIG9mZnNldCBvdXQgb2YgYm91bmQgZm9yICVzIgogbXNnc3RyICJcImRlbHRhIGJhc2Ugb2Zmc2V0XCIgbGllZ3QgYXXDn2VyaGFsYiBkZXMgZ8O8bHRpZ2VuIEJlcmVpY2hzIGbDvHIgJXMiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MTg3NQorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoxODcwCiBtc2dpZCAiQ291bnRpbmcgb2JqZWN0cyIKIG1zZ3N0ciAiWsOkaGxlIE9iamVrdGUiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjAwNQorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyMDAwCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBnZXQgc2l6ZSBvZiAlcyIKIG1zZ3N0ciAiS29ubnRlIEdyw7bDn2Ugdm9uICVzIG5pY2h0IGJlc3RpbW1lbi4iCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjAyMAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyMDE1CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBwYXJzZSBvYmplY3QgaGVhZGVyIG9mICVzIgogbXNnc3RyICJLb25udGUgS29wZmJlcmVpY2ggdm9uIE9iamVrdCAnJXMnIG5pY2h0IHBhcnNlbi4iCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjA5MCBidWlsdGluL3BhY2stb2JqZWN0cy5jOjIxMDYKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjExNgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyMDg1IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjEwMQorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyMTExCiAjLCBjLWZvcm1hdAogbXNnaWQgIm9iamVjdCAlcyBjYW5ub3QgYmUgcmVhZCIKIG1zZ3N0ciAiT2JqZWt0ICVzIGthbm4gbmljaHQgZ2VsZXNlbiB3ZXJkZW4uIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjIwOTMgYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyMTIwCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjIwODggYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyMTE1CiAjLCBjLWZvcm1hdAogbXNnaWQgIm9iamVjdCAlcyBpbmNvbnNpc3RlbnQgb2JqZWN0IGxlbmd0aCAoJTxQUkl1TUFYPiB2cyAlPFBSSXVNQVg+KSIKIG1zZ3N0ciAiSW5rb25zaXN0ZW50ZSBPYmpla3Rsw6RuZ2UgYmVpIE9iamVrdCAlcyAoJTxQUkl1TUFYPiB2cyAlPFBSSXVNQVg+KSIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyMTMwCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjIxMjUKIG1zZ2lkICJzdWJvcHRpbWFsIHBhY2sgLSBvdXQgb2YgbWVtb3J5IgogbXNnc3RyICJ1bmfDvG5zdGlnZXMgUGFja2V0IC0gU3BlaWNoZXIgdm9sbCIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNDU2CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI0NDAKICMsIGMtZm9ybWF0CiBtc2dpZCAiRGVsdGEgY29tcHJlc3Npb24gdXNpbmcgdXAgdG8gJWQgdGhyZWFkcyIKIG1zZ3N0ciAiRGVsdGEtS29tcHJlc3Npb24gdmVyd2VuZGV0IGJpcyB6dSAlZCBUaHJlYWRzLiIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNTg4CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI1NzIKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHBhY2sgb2JqZWN0cyByZWFjaGFibGUgZnJvbSB0YWcgJXMiCiBtc2dzdHIgIktvbm50ZSBrZWluZSBPYmpla3RlIHBhY2tlbiwgZGllIHZvbiBUYWcgJXMgZXJyZWljaGJhciBzaW5kLiIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNjc1CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI2NTkKIG1zZ2lkICJDb21wcmVzc2luZyBvYmplY3RzIgogbXNnc3RyICJLb21wcmltaWVyZSBPYmpla3RlIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI2ODEKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjY2NQogbXNnaWQgImluY29uc2lzdGVuY3kgd2l0aCBkZWx0YSBjb3VudCIKIG1zZ3N0ciAiSW5rb25zaXN0ZW56IG1pdCBkZXIgQW56YWhsIHZvbiBEZWx0YXMiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6Mjc2MgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNzQyCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJleHBlY3RlZCBlZGdlIG9iamVjdCBJRCwgZ290IGdhcmJhZ2U6XG4iCkBAIC0xNjQ1Nyw3ICsxNjU0MCw3IEBACiAiRXJ3YXJ0ZXRlIFJhbmRvYmpla3QtSUQsIGVyaGllbHQgbnV0emxvc2UgRGF0ZW46XG4iCiAiICVzIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI3NjgKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6Mjc0OAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiZXhwZWN0ZWQgb2JqZWN0IElELCBnb3QgZ2FyYmFnZTpcbiIKQEAgLTE2NDY2LDI1NiArMTY1NDksMjU2IEBACiAiRXJ3YXJ0ZXRlIE9iamVrdC1JRCwgZXJoaWVsdCBudXR6bG9zZSBEYXRlbjpcbiIKICIgJXMiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6Mjg2NgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyODQ2CiBtc2dpZCAiaW52YWxpZCB2YWx1ZSBmb3IgLS1taXNzaW5nIgogbXNnc3RyICJVbmfDvGx0aWdlciBXZXJ0IGbDvHIgLS1taXNzaW5nLiIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyOTI1IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzAzMworIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyOTA1IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzAxMwogbXNnaWQgImNhbm5vdCBvcGVuIHBhY2sgaW5kZXgiCiBtc2dzdHIgIkthbm4gUGFrZXRpbmRleCBuaWNodCDDtmZmbmVuLiIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyOTU2CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI5MzYKICMsIGMtZm9ybWF0CiBtc2dpZCAibG9vc2Ugb2JqZWN0IGF0ICVzIGNvdWxkIG5vdCBiZSBleGFtaW5lZCIKIG1zZ3N0ciAiTG9zZXMgT2JqZWt0IGJlaSAlcyBrb25udGUgbmljaHQgdW50ZXJzdWNodCB3ZXJkZW4uIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMwNDEKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzAyMQogbXNnaWQgInVuYWJsZSB0byBmb3JjZSBsb29zZSBvYmplY3QiCiBtc2dzdHIgIktvbm50ZSBsb3NlcyBPYmpla3QgbmljaHQgZXJ6d2luZ2VuLiIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMTMzCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMxMTMKICMsIGMtZm9ybWF0CiBtc2dpZCAibm90IGEgcmV2ICclcyciCiBtc2dzdHIgIiclcycgaXN0IGtlaW4gQ29tbWl0LiIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMTM2CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMxMTYKICMsIGMtZm9ybWF0CiBtc2dpZCAiYmFkIHJldmlzaW9uICclcyciCiBtc2dzdHIgIlVuZ8O8bHRpZ2VyIENvbW1pdCAnJXMnLiIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMTYxCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMxNDEKIG1zZ2lkICJ1bmFibGUgdG8gYWRkIHJlY2VudCBvYmplY3RzIgogbXNnc3RyICJLb25udGUgasO8bmdzdGUgT2JqZWt0ZSBuaWNodCBoaW56dWbDvGdlbi4iCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzIxNAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMTk0CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuc3VwcG9ydGVkIGluZGV4IHZlcnNpb24gJXMiCiBtc2dzdHIgIk5pY2h0IHVudGVyc3TDvHR6dGUgSW5kZXgtVmVyc2lvbiAlcyIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjE4CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMxOTgKICMsIGMtZm9ybWF0CiBtc2dpZCAiYmFkIGluZGV4IHZlcnNpb24gJyVzJyIKIG1zZ3N0ciAiVW5nw7xsdGlnZSBJbmRleC1WZXJzaW9uICclcyciCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI0OAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjI4CiBtc2dpZCAiZG8gbm90IHNob3cgcHJvZ3Jlc3MgbWV0ZXIiCiBtc2dzdHIgImtlaW5lIEZvcnRzY2hyaXR0c2FuemVpZ2UgYW56ZWlnZW4iCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI1MAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjMwCiBtc2dpZCAic2hvdyBwcm9ncmVzcyBtZXRlciIKIG1zZ3N0ciAiRm9ydHNjaHJpdHRzYW56ZWlnZSBhbnplaWdlbiIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjUyCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyMzIKIG1zZ2lkICJzaG93IHByb2dyZXNzIG1ldGVyIGR1cmluZyBvYmplY3Qgd3JpdGluZyBwaGFzZSIKIG1zZ3N0ciAiRm9yc2Nocml0dHNhbnplaWdlIHfDpGhyZW5kIGRlcyBTY2hyZWliZW5zIHZvbiBPYmpla3RlbiBhbnplaWdlbiIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjU1CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyMzUKIG1zZ2lkICJzaW1pbGFyIHRvIC0tYWxsLXByb2dyZXNzIHdoZW4gcHJvZ3Jlc3MgbWV0ZXIgaXMgc2hvd24iCiBtc2dzdHIgIsOkaG5saWNoIHp1IC0tYWxsLXByb2dyZXNzIHdlbm4gRm9ydHNjaHJpdHRzYW56ZWlnZSBkYXJzdGVsbHQgd2lyZCIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjU2CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyMzYKIG1zZ2lkICI8dmVyc2lvbj5bLDxvZmZzZXQ+XSIKIG1zZ3N0ciAiPFZlcnNpb24+Wyw8T2Zmc2V0Pl0iCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI1NworIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjM3CiBtc2dpZCAid3JpdGUgdGhlIHBhY2sgaW5kZXggZmlsZSBpbiB0aGUgc3BlY2lmaWVkIGlkeCBmb3JtYXQgdmVyc2lvbiIKIG1zZ3N0ciAiIgogImRpZSBJbmRleC1EYXRlaSBkZXMgUGFrZXRlcyBpbiBkZXIgYW5nZWdlYmVuZW4gSW5kZXhmb3JtYXQtVmVyc2lvbiBzY2hyZWliZW4iCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI2MAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjQwCiBtc2dpZCAibWF4aW11bSBzaXplIG9mIGVhY2ggb3V0cHV0IHBhY2sgZmlsZSIKIG1zZ3N0ciAibWF4aW1hbGUgR3LDtsOfZSBmw7xyIGplZGUgYXVzZ2VnZWJlbmUgUGFrZXRkYXRlaSIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjYyCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNDIKIG1zZ2lkICJpZ25vcmUgYm9ycm93ZWQgb2JqZWN0cyBmcm9tIGFsdGVybmF0ZSBvYmplY3Qgc3RvcmUiCiBtc2dzdHIgImdlbGllaGVuZSBPYmpla3RlIHZvbiBhbHRlcm5hdGl2ZW0gT2JqZWt0c3BlaWNoZXIgaWdub3JpZXJlbiIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjY0CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNDQKIG1zZ2lkICJpZ25vcmUgcGFja2VkIG9iamVjdHMiCiBtc2dzdHIgImdlcGFja3RlIE9iamVrdGUgaWdub3JpZXJlbiIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjY2CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNDYKIG1zZ2lkICJsaW1pdCBwYWNrIHdpbmRvdyBieSBvYmplY3RzIgogbXNnc3RyICJQYWtldGZlbnN0ZXIgZHVyY2ggT2JqZWt0ZSBiZWdyZW56ZW4iCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI2OAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjQ4CiBtc2dpZCAibGltaXQgcGFjayB3aW5kb3cgYnkgbWVtb3J5IGluIGFkZGl0aW9uIHRvIG9iamVjdCBsaW1pdCIKIG1zZ3N0ciAiIgogIlBha2V0ZmVuc3RlciwgenVzw6R0emxpY2ggenVyIE9iamVrdGJlZ3Jlbnp1bmcsIGR1cmNoIFNwZWljaGVyIGJlZ3JlbnplbiIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjcwCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNTAKIG1zZ2lkICJtYXhpbXVtIGxlbmd0aCBvZiBkZWx0YSBjaGFpbiBhbGxvd2VkIGluIHRoZSByZXN1bHRpbmcgcGFjayIKIG1zZ3N0ciAiIgogIm1heGltYWxlIEzDpG5nZSBkZXIgZXJsYXVidGVuIERpZmZlcmVuenZlcmtldHR1bmcgaW0gcmVzdWx0aWVyZW5kZW4gUGFrZXQiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI3MgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjUyCiBtc2dpZCAicmV1c2UgZXhpc3RpbmcgZGVsdGFzIgogbXNnc3RyICJleGlzdGllcmVuZGUgVW50ZXJzY2hpZWRlIHdpZWRlcnZlcndlbmRlbiIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjc0CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNTQKIG1zZ2lkICJyZXVzZSBleGlzdGluZyBvYmplY3RzIgogbXNnc3RyICJleGlzdGllcmVuZGUgT2JqZWt0ZSB3aWVkZXJ2ZXJ3ZW5kZW4iCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI3NgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjU2CiBtc2dpZCAidXNlIE9GU19ERUxUQSBvYmplY3RzIgogbXNnc3RyICJPRlNfREVMVEEgT2JqZWt0ZSB2ZXJ3ZW5kZW4iCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI3OAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjU4CiBtc2dpZCAidXNlIHRocmVhZHMgd2hlbiBzZWFyY2hpbmcgZm9yIGJlc3QgZGVsdGEgbWF0Y2hlcyIKIG1zZ3N0ciAiIgogIlRocmVhZHMgYmVpIGRlciBTdWNoZSBuYWNoIGRlbiBiZXN0ZW4gw5xiZXJlaW5zdGltbXVuZ2VuIGJlaSBVbnRlcnNjaGllZGVuICIKICJ2ZXJ3ZW5kZW4iCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI4MAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjYwCiBtc2dpZCAiZG8gbm90IGNyZWF0ZSBhbiBlbXB0eSBwYWNrIG91dHB1dCIKIG1zZ3N0ciAia2VpbmUgbGVlcmVuIFBha2V0ZSBlcnpldWdlbiIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjgyCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNjIKIG1zZ2lkICJyZWFkIHJldmlzaW9uIGFyZ3VtZW50cyBmcm9tIHN0YW5kYXJkIGlucHV0IgogbXNnc3RyICJBcmd1bWVudGUgYmV6w7xnbGljaCBDb21taXRzIHZvbiBkZXIgU3RhbmRhcmQtRWluZ2FiZSBsZXNlbiIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjg0CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNjQKIG1zZ2lkICJsaW1pdCB0aGUgb2JqZWN0cyB0byB0aG9zZSB0aGF0IGFyZSBub3QgeWV0IHBhY2tlZCIKIG1zZ3N0ciAiZGllIE9iamVrdGUgenUgc29sY2hlbiwgZGllIG5vY2ggbmljaHQgZ2VwYWNrdCB3dXJkZW4sIGJlZ3JlbnplbiIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjg3CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNjcKIG1zZ2lkICJpbmNsdWRlIG9iamVjdHMgcmVhY2hhYmxlIGZyb20gYW55IHJlZmVyZW5jZSIKIG1zZ3N0ciAiT2JqZWt0ZSBlaW5zY2hsaWXDn2VuLCBkaWUgdm9uIGplZGVyIFJlZmVyZW56IGVycmVpY2hiYXIgc2luZCIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjkwCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNzAKIG1zZ2lkICJpbmNsdWRlIG9iamVjdHMgcmVmZXJyZWQgYnkgcmVmbG9nIGVudHJpZXMiCiBtc2dzdHIgIiIKICJPYmpla3RlIGVpbnNjaGxpZcOfZW4sIGRpZSB2b24gRWludHLDpGdlbiBkZXMgUmVmbG9ncyByZWZlcmVuemllcnQgd2VyZGVuIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyOTMKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI3MwogbXNnaWQgImluY2x1ZGUgb2JqZWN0cyByZWZlcnJlZCB0byBieSB0aGUgaW5kZXgiCiBtc2dzdHIgIk9iamVrdGUgZWluc2NobGllw59lbiwgZGllIHZvbSBJbmRleCByZWZlcmVuemllcnQgd2VyZGVuIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyOTYKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI3NgogbXNnaWQgIm91dHB1dCBwYWNrIHRvIHN0ZG91dCIKIG1zZ3N0ciAiUGFrZXQgaW4gZGllIFN0YW5kYXJkLUF1c2dhYmUgc2NocmVpYmVuIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyOTgKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI3OAogbXNnaWQgImluY2x1ZGUgdGFnIG9iamVjdHMgdGhhdCByZWZlciB0byBvYmplY3RzIHRvIGJlIHBhY2tlZCIKIG1zZ3N0ciAiVGFnLU9iamVrdGUgZWluc2NobGllw59lbiwgZGllIGF1ZiBnZXBhY2t0ZSBPYmpla3RlIHJlZmVyZW56aWVyZW4iCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMwMAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjgwCiBtc2dpZCAia2VlcCB1bnJlYWNoYWJsZSBvYmplY3RzIgogbXNnc3RyICJuaWNodCBlcnJlaWNoYmFyZSBPYmpla3RlIGJlaGFsdGVuIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMDIKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI4MgogbXNnaWQgInBhY2sgbG9vc2UgdW5yZWFjaGFibGUgb2JqZWN0cyIKIG1zZ3N0ciAibmljaHQgZXJyZWljaGJhcmUgbG9zZSBPYmpla3RlIHBhY2tlbiIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzA0CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyODQKIG1zZ2lkICJ1bnBhY2sgdW5yZWFjaGFibGUgb2JqZWN0cyBuZXdlciB0aGFuIDx0aW1lPiIKIG1zZ3N0ciAibmljaHQgZXJyZWljaGJhcmUgT2JqZWt0ZSBlbnRwYWNrZW4sIGRpZSBuZXVlciBhbHMgPFplaXQ+IHNpbmQiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMwNworIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjg3CiBtc2dpZCAidXNlIHRoZSBzcGFyc2UgcmVhY2hhYmlsaXR5IGFsZ29yaXRobSIKIG1zZ3N0ciAiZGVuIFwic3BhcnNlXCIgQWxnb3JpdGhtdXMgenVyIEJlc3RpbW11bmcgZGVyIEVycmVpY2hiYXJrZWl0IGJlbnV0emVuIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMDkKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI4OQogbXNnaWQgImNyZWF0ZSB0aGluIHBhY2tzIgogbXNnc3RyICJkw7xubmVyZSBQYWtldGUgZXJ6ZXVnZW4iCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMxMQorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjkxCiBtc2dpZCAiY3JlYXRlIHBhY2tzIHN1aXRhYmxlIGZvciBzaGFsbG93IGZldGNoZXMiCiBtc2dzdHIgIiIKICJQYWtldGUgZ2VlaWduZXQgZsO8ciBBYmhvbHVuZyBtaXQgdW52b2xsc3TDpG5kaWdlciBIaXN0b3JpZSAoc2hhbGxvdykgZXJ6ZXVnZW4iCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMxMworIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjkzCiBtc2dpZCAiaWdub3JlIHBhY2tzIHRoYXQgaGF2ZSBjb21wYW5pb24gLmtlZXAgZmlsZSIKIG1zZ3N0ciAiUGFrZXRlIGlnbm9yaWVyZW4sIGRpZSAua2VlcCBEYXRlaWVuIGhhYmVuIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMTUKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI5NQogbXNnaWQgImlnbm9yZSB0aGlzIHBhY2siCiBtc2dzdHIgImRpZXNlcyBQYWtldCBpZ25vcmllcmVuIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMTcKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI5NwogbXNnaWQgInBhY2sgY29tcHJlc3Npb24gbGV2ZWwiCiBtc2dzdHIgIktvbXByaW1pZXJ1bmdzZ3JhZCBmw7xyIFBha2V0aWVydW5nIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMTkKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI5OQogbXNnaWQgImRvIG5vdCBoaWRlIGNvbW1pdHMgYnkgZ3JhZnRzIgogbXNnc3RyICJrZWluZSBrw7xuc3RsaWNoZW4gVm9yZ8Okbmdlci1Db21taXRzIChcImdyYWZ0c1wiKSB2ZXJiZXJnZW4iCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMyMQorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzAxCiBtc2dpZCAidXNlIGEgYml0bWFwIGluZGV4IGlmIGF2YWlsYWJsZSB0byBzcGVlZCB1cCBjb3VudGluZyBvYmplY3RzIgogbXNnc3RyICIiCiAiQml0bWFwLUluZGV4IChmYWxscyB2ZXJmw7xnYmFyKSB6dXIgT3B0aW1pZXJ1bmcgZGVyIE9iamVrdHrDpGhsdW5nIGJlbnV0emVuIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMjMKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMwMwogbXNnaWQgIndyaXRlIGEgYml0bWFwIGluZGV4IHRvZ2V0aGVyIHdpdGggdGhlIHBhY2sgaW5kZXgiCiBtc2dzdHIgIkJpdG1hcC1JbmRleCB6dXNhbW1lbiBtaXQgUGFjay1JbmRleCBzY2hyZWliZW4iCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMyNworIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzA3CiBtc2dpZCAid3JpdGUgYSBiaXRtYXAgaW5kZXggaWYgcG9zc2libGUiCiBtc2dzdHIgIkJpdG1hcC1JbmRleCBzY2hyZWliZW4sIHdlbm4gbcO2Z2xpY2giCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMzMQorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzExCiBtc2dpZCAiaGFuZGxpbmcgZm9yIG1pc3Npbmcgb2JqZWN0cyIKIG1zZ3N0ciAiQmVoYW5kbHVuZyBmw7xyIGZlaGxlbmRlIE9iamVrdGUiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMzNAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzE0CiBtc2dpZCAiZG8gbm90IHBhY2sgb2JqZWN0cyBpbiBwcm9taXNvciBwYWNrZmlsZXMiCiBtc2dzdHIgIiIKICJrZWluZSBPYmpla3RlIGF1cyBQYWNrZGF0ZWllbiB2b24gcGFydGllbGwgZ2VrbG9udGVuIFJlbW90ZS1SZXBvc2l0b3JpZXMgIgogInBhY2tlbiIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzM2CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMTYKIG1zZ2lkICJyZXNwZWN0IGlzbGFuZHMgZHVyaW5nIGRlbHRhIGNvbXByZXNzaW9uIgogbXNnc3RyICJEZWx0YS1Jc2xhbmRzIGJlaSBEZWx0YS1Lb21wcmVzc2lvbiBiZWFjaHRlbiIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzYxCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzNDUKICMsIGMtZm9ybWF0CiBtc2dpZCAiZGVsdGEgY2hhaW4gZGVwdGggJWQgaXMgdG9vIGRlZXAsIGZvcmNpbmcgJWQiCiBtc2dzdHIgIlRpZWZlIGbDvHIgVmVya2V0dHVuZyB2b24gVW50ZXJzY2hpZWRlbiAlZCBpc3QgenUgdGllZiwgZXJ6d2luZ2UgJWQiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzM2NgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzUwCiAjLCBjLWZvcm1hdAogbXNnaWQgInBhY2suZGVsdGFDYWNoZUxpbWl0IGlzIHRvbyBoaWdoLCBmb3JjaW5nICVkIgogbXNnc3RyICJwYWNrLmRlbHRhQ2FjaGVMaW1pdCBpc3QgenUgaG9jaCwgZXJ6d2luZ2UgJWQiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzQyMAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozNDA0CiBtc2dpZCAiLS1tYXgtcGFjay1zaXplIGNhbm5vdCBiZSB1c2VkIHRvIGJ1aWxkIGEgcGFjayBmb3IgdHJhbnNmZXIiCiBtc2dzdHIgIiIKICItLW1heC1wYWNrLXNpemUga2FubiBuaWNodCBmw7xyIGRpZSBFcnN0ZWxsdW5nIGVpbmVzIFBha2V0cyBmw7xyIGVpbmUgIgogIsOcYmVydHJhZ3VuZ1xuIgogImJlbnV0enQgd2VyZGVuLiIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozNDIyCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjM0MDYKIG1zZ2lkICJtaW5pbXVtIHBhY2sgc2l6ZSBsaW1pdCBpcyAxIE1pQiIKIG1zZ3N0ciAiTWluaW1hbGVzIExpbWl0IGbDvHIgZGllIFBha2V0Z3LDtsOfZSBpc3QgMSBNaUIuIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjM0MjcKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzQxMQogbXNnaWQgIi0tdGhpbiBjYW5ub3QgYmUgdXNlZCB0byBidWlsZCBhbiBpbmRleGFibGUgcGFjayIKIG1zZ3N0ciAiIgogIi0tdGhpbiBrYW5uIG5pY2h0IGJlbnV0enQgd2VyZGVuLCB1bSBlaW4gaW5kaXppZXJiYXJlcyBQYWtldCB6dSBlcnN0ZWxsZW4uIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjM0MzAKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzQxNAogbXNnaWQgIi0ta2VlcC11bnJlYWNoYWJsZSBhbmQgLS11bnBhY2stdW5yZWFjaGFibGUgYXJlIGluY29tcGF0aWJsZSIKIG1zZ3N0ciAiLS1rZWVwLXVucmVhY2hhYmxlIHVuZCAtLXVucGFjay11bnJlYWNoYWJsZSBzaW5kIGlua29tcGF0aWJlbCIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozNDM2CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjM0MjAKIG1zZ2lkICJjYW5ub3QgdXNlIC0tZmlsdGVyIHdpdGhvdXQgLS1zdGRvdXQiCiBtc2dzdHIgIkthbm4gLS1maWx0ZXIgbmljaHQgb2huZSAtLXN0ZG91dCBiZW51dHplbi4iCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzQ5NworIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozNDgxCiBtc2dpZCAiRW51bWVyYXRpbmcgb2JqZWN0cyIKIG1zZ3N0ciAiT2JqZWt0ZSBhdWZ6w6RobGVuIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjM1MjcKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzUxMQogIywgYy1mb3JtYXQKIG1zZ2lkICJUb3RhbCAlPFBSSXUzMj4gKGRlbHRhICU8UFJJdTMyPiksIHJldXNlZCAlPFBSSXUzMj4gKGRlbHRhICU8UFJJdTMyPikiCiBtc2dzdHIgIiIKQEAgLTE2NzczLDQ0ICsxNjg1Niw0NCBAQAogbXNnaWQgImdpdCBwdWxsIFs8b3B0aW9ucz5dIFs8cmVwb3NpdG9yeT4gWzxyZWZzcGVjPi4uLl1dIgogbXNnc3RyICJnaXQgcHVsbCBbPE9wdGlvbmVuPl0gWzxSZXBvc2l0b3J5PiBbPFJlZnNwZWM+Li4uXV0iCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjE0MQorIzogYnVpbHRpbi9wdWxsLmM6MTQyCiBtc2dpZCAiY29udHJvbCBmb3IgcmVjdXJzaXZlIGZldGNoaW5nIG9mIHN1Ym1vZHVsZXMiCiBtc2dzdHIgInJla3Vyc2l2ZSBBbmZvcmRlcnVuZ2VuIHZvbiBTdWJtb2R1bGVuIGtvbnRyb2xsaWVyZW4iCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjE0NQorIzogYnVpbHRpbi9wdWxsLmM6MTQ2CiBtc2dpZCAiT3B0aW9ucyByZWxhdGVkIHRvIG1lcmdpbmciCiBtc2dzdHIgIk9wdGlvbmVuIGJlem9nZW4gYXVmIE1lcmdlIgogCi0jOiBidWlsdGluL3B1bGwuYzoxNDgKKyM6IGJ1aWx0aW4vcHVsbC5jOjE0OQogbXNnaWQgImluY29ycG9yYXRlIGNoYW5nZXMgYnkgcmViYXNpbmcgcmF0aGVyIHRoYW4gbWVyZ2luZyIKIG1zZ3N0ciAiSW50ZWdyYXRpb24gdm9uIMOEbmRlcnVuZ2VuIGR1cmNoIFJlYmFzZSBzdGF0dCBNZXJnZSIKIAotIzogYnVpbHRpbi9wdWxsLmM6MTc2IGJ1aWx0aW4vcmViYXNlLmM6NDQ3IGJ1aWx0aW4vcmV2ZXJ0LmM6MTI2CisjOiBidWlsdGluL3B1bGwuYzoxNzcgYnVpbHRpbi9yZWJhc2UuYzo0NDggYnVpbHRpbi9yZXZlcnQuYzoxMjYKIG1zZ2lkICJhbGxvdyBmYXN0LWZvcndhcmQiCiBtc2dzdHIgIlZvcnNwdWxlbiBlcmxhdWJlbiIKIAotIzogYnVpbHRpbi9wdWxsLmM6MTg1CisjOiBidWlsdGluL3B1bGwuYzoxODYKIG1zZ2lkICJhdXRvbWF0aWNhbGx5IHN0YXNoL3N0YXNoIHBvcCBiZWZvcmUgYW5kIGFmdGVyIHJlYmFzZSIKIG1zZ3N0ciAiYXV0b21hdGlzY2hlciBTdGFzaC9TdGFzaC1Qb3Agdm9yIHVuZCBuYWNoIGVpbmVzIFJlYmFzZSIKIAotIzogYnVpbHRpbi9wdWxsLmM6MjAxCisjOiBidWlsdGluL3B1bGwuYzoyMDIKIG1zZ2lkICJPcHRpb25zIHJlbGF0ZWQgdG8gZmV0Y2hpbmciCiBtc2dzdHIgIk9wdGlvbmVuIGJlem9nZW4gYXVmIEZldGNoIgogCi0jOiBidWlsdGluL3B1bGwuYzoyMTEKKyM6IGJ1aWx0aW4vcHVsbC5jOjIxMgogbXNnaWQgImZvcmNlIG92ZXJ3cml0ZSBvZiBsb2NhbCBicmFuY2giCiBtc2dzdHIgImRhcyDDnGJlcnNjaHJlaWJlbiB2b24gbG9rYWxlbiBCcmFuY2hlcyBlcnp3aW5nZW4iCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjIxOQorIzogYnVpbHRpbi9wdWxsLmM6MjIwCiBtc2dpZCAibnVtYmVyIG9mIHN1Ym1vZHVsZXMgcHVsbGVkIGluIHBhcmFsbGVsIgogbXNnc3RyICJBbnphaGwgZGVyIHBhcmFsbGVsIG1pdCAncHVsbCcgenUgdmVyYXJiZWl0ZW5kZW4gU3VibW9kdWxlIgogCi0jOiBidWlsdGluL3B1bGwuYzozMTYKKyM6IGJ1aWx0aW4vcHVsbC5jOjMyMAogIywgYy1mb3JtYXQKIG1zZ2lkICJJbnZhbGlkIHZhbHVlIGZvciBwdWxsLmZmOiAlcyIKIG1zZ3N0ciAiVW5nw7xsdGlnZXIgV2VydCBmw7xyIHB1bGwuZmY6ICVzIgogCi0jOiBidWlsdGluL3B1bGwuYzo0MzMKKyM6IGJ1aWx0aW4vcHVsbC5jOjQzNwogbXNnaWQgIiIKICJUaGVyZSBpcyBubyBjYW5kaWRhdGUgZm9yIHJlYmFzaW5nIGFnYWluc3QgYW1vbmcgdGhlIHJlZnMgdGhhdCB5b3UganVzdCAiCiAiZmV0Y2hlZC4iCkBAIC0xNjgxOCwxNCArMTY5MDEsMTQgQEAKICJFcyBnaWJ0IGtlaW5lbiBLYW5kaWRhdGVuIGbDvHIgUmViYXNlIGlubmVyaGFsYiBkZXIgUmVmZXJlbnplbiwgZGllIGViZW4gIgogImFuZ2Vmb3JkZXJ0IHd1cmRlbi4iCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjQzNQorIzogYnVpbHRpbi9wdWxsLmM6NDM5CiBtc2dpZCAiIgogIlRoZXJlIGFyZSBubyBjYW5kaWRhdGVzIGZvciBtZXJnaW5nIGFtb25nIHRoZSByZWZzIHRoYXQgeW91IGp1c3QgZmV0Y2hlZC4iCiBtc2dzdHIgIiIKICJFcyBnaWJ0IGtlaW5lIEthbmRpZGF0ZW4gZsO8ciBNZXJnZSBpbm5lcmhhbGIgZGVyIFJlZmVyZW56ZW4sIGRpZSBlYmVuICIKICJhbmdlZm9yZGVydCB3dXJkZW4uIgogCi0jOiBidWlsdGluL3B1bGwuYzo0MzYKKyM6IGJ1aWx0aW4vcHVsbC5jOjQ0MAogbXNnaWQgIiIKICJHZW5lcmFsbHkgdGhpcyBtZWFucyB0aGF0IHlvdSBwcm92aWRlZCBhIHdpbGRjYXJkIHJlZnNwZWMgd2hpY2ggaGFkIG5vXG4iCiAibWF0Y2hlcyBvbiB0aGUgcmVtb3RlIGVuZC4iCkBAIC0xNjgzMyw3ICsxNjkxNiw3IEBACiAiSW0gQWxsZ2VtZWluZW4gYmVkZXV0ZXQgZGFzLCBkYXNzIFNpZSBlaW5lbiBSZWZzcGVjIG1pdCBXaWxkY2FyZHMgYW5nZWdlYmVuXG4iCiAiaGFiZW4sIGRlciBhdWYgZGVyIEdlZ2Vuc2VpdGUgbWl0IGtlaW5lbiBSZWZlcmVuemVuIMO8YmVyZWluc3RpbW10LiIKIAotIzogYnVpbHRpbi9wdWxsLmM6NDM5CisjOiBidWlsdGluL3B1bGwuYzo0NDMKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIllvdSBhc2tlZCB0byBwdWxsIGZyb20gdGhlIHJlbW90ZSAnJXMnLCBidXQgZGlkIG5vdCBzcGVjaWZ5XG4iCkBAIC0xNjg0NSwzOSArMTY5MjgsMzkgQEAKICJSZXBvc2l0b3J5IGbDvHIgZGVuIGFrdHVlbGxlbiBCcmFuY2ggaXN0LCBtw7xzc2VuIFNpZSBlaW5lbiBCcmFuY2ggYXVmXG4iCiAiZGVyIEJlZmVobHN6ZWlsZSBhbmdlYmVuLiIKIAotIzogYnVpbHRpbi9wdWxsLmM6NDQ0IGJ1aWx0aW4vcmViYXNlLmM6MTMyNiBnaXQtcGFyc2UtcmVtb3RlLnNoOjczCisjOiBidWlsdGluL3B1bGwuYzo0NDggYnVpbHRpbi9yZWJhc2UuYzoxMzQ3IGdpdC1wYXJzZS1yZW1vdGUuc2g6NzMKIG1zZ2lkICJZb3UgYXJlIG5vdCBjdXJyZW50bHkgb24gYSBicmFuY2guIgogbXNnc3RyICJJbSBNb21lbnQgYXVmIGtlaW5lbSBCcmFuY2guIgogCi0jOiBidWlsdGluL3B1bGwuYzo0NDYgYnVpbHRpbi9wdWxsLmM6NDYxIGdpdC1wYXJzZS1yZW1vdGUuc2g6NzkKKyM6IGJ1aWx0aW4vcHVsbC5jOjQ1MCBidWlsdGluL3B1bGwuYzo0NjUgZ2l0LXBhcnNlLXJlbW90ZS5zaDo3OQogbXNnaWQgIlBsZWFzZSBzcGVjaWZ5IHdoaWNoIGJyYW5jaCB5b3Ugd2FudCB0byByZWJhc2UgYWdhaW5zdC4iCiBtc2dzdHIgIiIKICJCaXR0ZSBnZWJlbiBTaWUgZGVuIEJyYW5jaCBhbiwgZ2VnZW4gd2VsY2hlbiBTaWUgXCJyZWJhc2VcIiBhdXNmw7xocmVuICIKICJtw7ZjaHRlbi4iCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjQ0OCBidWlsdGluL3B1bGwuYzo0NjMgZ2l0LXBhcnNlLXJlbW90ZS5zaDo4MgorIzogYnVpbHRpbi9wdWxsLmM6NDUyIGJ1aWx0aW4vcHVsbC5jOjQ2NyBnaXQtcGFyc2UtcmVtb3RlLnNoOjgyCiBtc2dpZCAiUGxlYXNlIHNwZWNpZnkgd2hpY2ggYnJhbmNoIHlvdSB3YW50IHRvIG1lcmdlIHdpdGguIgogbXNnc3RyICJCaXR0ZSBnZWJlbiBTaWUgZGVuIEJyYW5jaCBhbiwgd2VsY2hlbiBTaWUgenVzYW1tZW5mw7xocmVuIG3DtmNodGVuLiIKIAotIzogYnVpbHRpbi9wdWxsLmM6NDQ5IGJ1aWx0aW4vcHVsbC5jOjQ2NAorIzogYnVpbHRpbi9wdWxsLmM6NDUzIGJ1aWx0aW4vcHVsbC5jOjQ2OAogbXNnaWQgIlNlZSBnaXQtcHVsbCgxKSBmb3IgZGV0YWlscy4iCiBtc2dzdHIgIlNpZWhlIGdpdC1wdWxsKDEpIGbDvHIgd2VpdGVyZSBEZXRhaWxzLiIKIAotIzogYnVpbHRpbi9wdWxsLmM6NDUxIGJ1aWx0aW4vcHVsbC5jOjQ1NyBidWlsdGluL3B1bGwuYzo0NjYKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTMzMiBnaXQtcGFyc2UtcmVtb3RlLnNoOjY0CisjOiBidWlsdGluL3B1bGwuYzo0NTUgYnVpbHRpbi9wdWxsLmM6NDYxIGJ1aWx0aW4vcHVsbC5jOjQ3MAorIzogYnVpbHRpbi9yZWJhc2UuYzoxMzUzIGdpdC1wYXJzZS1yZW1vdGUuc2g6NjQKIG1zZ2lkICI8cmVtb3RlPiIKIG1zZ3N0ciAiPFJlbW90ZS1SZXBvc2l0b3J5PiIKIAotIzogYnVpbHRpbi9wdWxsLmM6NDUxIGJ1aWx0aW4vcHVsbC5jOjQ2NiBidWlsdGluL3B1bGwuYzo0NzEKKyM6IGJ1aWx0aW4vcHVsbC5jOjQ1NSBidWlsdGluL3B1bGwuYzo0NzAgYnVpbHRpbi9wdWxsLmM6NDc1CiAjOiBnaXQtcGFyc2UtcmVtb3RlLnNoOjY1CiBtc2dpZCAiPGJyYW5jaD4iCiBtc2dzdHIgIjxCcmFuY2g+IgogCi0jOiBidWlsdGluL3B1bGwuYzo0NTkgYnVpbHRpbi9yZWJhc2UuYzoxMzI0IGdpdC1wYXJzZS1yZW1vdGUuc2g6NzUKKyM6IGJ1aWx0aW4vcHVsbC5jOjQ2MyBidWlsdGluL3JlYmFzZS5jOjEzNDUgZ2l0LXBhcnNlLXJlbW90ZS5zaDo3NQogbXNnaWQgIlRoZXJlIGlzIG5vIHRyYWNraW5nIGluZm9ybWF0aW9uIGZvciB0aGUgY3VycmVudCBicmFuY2guIgogbXNnc3RyICJFcyBnaWJ0IGtlaW5lIFRyYWNraW5nLUluZm9ybWF0aW9uZW4gZsO8ciBkZW4gYWt0dWVsbGVuIEJyYW5jaC4iCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjQ2OCBnaXQtcGFyc2UtcmVtb3RlLnNoOjk1CisjOiBidWlsdGluL3B1bGwuYzo0NzIgZ2l0LXBhcnNlLXJlbW90ZS5zaDo5NQogbXNnaWQgIiIKICJJZiB5b3Ugd2lzaCB0byBzZXQgdHJhY2tpbmcgaW5mb3JtYXRpb24gZm9yIHRoaXMgYnJhbmNoIHlvdSBjYW4gZG8gc28gd2l0aDoiCiBtc2dzdHIgIiIKQEAgLTE2ODg1LDcgKzE2OTY4LDcgQEAKICJTaWVcbiIKICJkaWVzIHR1biBtaXQ6IgogCi0jOiBidWlsdGluL3B1bGwuYzo0NzMKKyM6IGJ1aWx0aW4vcHVsbC5jOjQ3NwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiWW91ciBjb25maWd1cmF0aW9uIHNwZWNpZmllcyB0byBtZXJnZSB3aXRoIHRoZSByZWYgJyVzJ1xuIgpAQCAtMTY4OTUsMzQgKzE2OTc4LDM0IEBACiAiZGVzIFJlbW90ZS1SZXBvc2l0b3JpZXMgZHVyY2h6dWbDvGhyZW4sIGFiZXIgZGllc2UgUmVmZXJlbnpcbiIKICJ3dXJkZSBuaWNodCBhbmdlZm9yZGVydC4iCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjU4MQorIzogYnVpbHRpbi9wdWxsLmM6NTg3CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBhY2Nlc3MgY29tbWl0ICVzIgogbXNnc3RyICJLb25udGUgbmljaHQgYXVmIENvbW1pdCAnJXMnIHp1Z3JlaWZlbi4iCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjg2MQorIzogYnVpbHRpbi9wdWxsLmM6ODY3CiBtc2dpZCAiaWdub3JpbmcgLS12ZXJpZnktc2lnbmF0dXJlcyBmb3IgcmViYXNlIgogbXNnc3RyICJJZ25vcmllcmUgLS12ZXJpZnktc2lnbmF0dXJlcyBmw7xyIFJlYmFzZSIKIAotIzogYnVpbHRpbi9wdWxsLmM6OTE2CisjOiBidWlsdGluL3B1bGwuYzo5MjIKIG1zZ2lkICItLVtuby1dYXV0b3N0YXNoIG9wdGlvbiBpcyBvbmx5IHZhbGlkIHdpdGggLS1yZWJhc2UuIgogbXNnc3RyICItLVtuby1dYXV0b3N0YXNoIGlzdCBudXIgbWl0IC0tcmViYXNlIHp1bMOkc3NpZy4iCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjkyNAorIzogYnVpbHRpbi9wdWxsLmM6OTMwCiBtc2dpZCAiVXBkYXRpbmcgYW4gdW5ib3JuIGJyYW5jaCB3aXRoIGNoYW5nZXMgYWRkZWQgdG8gdGhlIGluZGV4LiIKIG1zZ3N0ciAiIgogIkFrdHVhbGlzaWVyZSBlaW5lbiB1bmdlYm9yZW5lbiBCcmFuY2ggbWl0IMOEbmRlcnVuZ2VuLCBkaWUgenVtIENvbW1pdCAiCiAidm9yZ2VtZXJrdCBzaW5kLiIKIAotIzogYnVpbHRpbi9wdWxsLmM6OTI4CisjOiBidWlsdGluL3B1bGwuYzo5MzQKIG1zZ2lkICJwdWxsIHdpdGggcmViYXNlIgogbXNnc3RyICJQdWxsIG1pdCBSZWJhc2UiCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjkyOQorIzogYnVpbHRpbi9wdWxsLmM6OTM1CiBtc2dpZCAicGxlYXNlIGNvbW1pdCBvciBzdGFzaCB0aGVtLiIKIG1zZ3N0ciAiQml0dGUgY29tbWl0dGVuIFNpZSBkaWUgw4RuZGVydW5nZW4gb2RlciBiZW51dHplbiBTaWUgXCJzdGFzaFwiLiIKIAotIzogYnVpbHRpbi9wdWxsLmM6OTU0CisjOiBidWlsdGluL3B1bGwuYzo5NjAKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogImZldGNoIHVwZGF0ZWQgdGhlIGN1cnJlbnQgYnJhbmNoIGhlYWQuXG4iCkBAIC0xNjkzMiw3ICsxNzAxNSw3IEBACiAiXCJmZXRjaFwiIGFrdHVhbGlzaWVydGUgZGllIFNwaXR6ZSBkZXMgYWt0dWVsbGVuIEJyYW5jaGVzLlxuIgogIlNwdWxlIElociBBcmJlaXRzdmVyemVpY2huaXMgdm9uIENvbW1pdCAlcyB2b3IuIgogCi0jOiBidWlsdGluL3B1bGwuYzo5NjAKKyM6IGJ1aWx0aW4vcHVsbC5jOjk2NgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiQ2Fubm90IGZhc3QtZm9yd2FyZCB5b3VyIHdvcmtpbmcgdHJlZS5cbiIKQEAgLTE2OTQ5LDE1ICsxNzAzMiwxNSBAQAogIiQgZ2l0IHJlc2V0IC0taGFyZFxuIgogInp1ciBXaWVkZXJoZXJzdGVsbHVuZyBhdXMuIgogCi0jOiBidWlsdGluL3B1bGwuYzo5NzUKKyM6IGJ1aWx0aW4vcHVsbC5jOjk4MQogbXNnaWQgIkNhbm5vdCBtZXJnZSBtdWx0aXBsZSBicmFuY2hlcyBpbnRvIGVtcHR5IGhlYWQuIgogbXNnc3RyICJLYW5uIG5pY2h0IG1laHJlcmUgQnJhbmNoZXMgaW4gZWluZW4gbGVlcmVuIEJyYW5jaCB6dXNhbW1lbmbDvGhyZW4uIgogCi0jOiBidWlsdGluL3B1bGwuYzo5NzkKKyM6IGJ1aWx0aW4vcHVsbC5jOjk4NQogbXNnaWQgIkNhbm5vdCByZWJhc2Ugb250byBtdWx0aXBsZSBicmFuY2hlcy4iCiBtc2dzdHIgIkthbm4gUmViYXNlIG5pY2h0IGF1ZiBtZWhyZXJlIEJyYW5jaGVzIGF1c2bDvGhyZW4uIgogCi0jOiBidWlsdGluL3B1bGwuYzo5ODYKKyM6IGJ1aWx0aW4vcHVsbC5jOjk5MgogbXNnaWQgImNhbm5vdCByZWJhc2Ugd2l0aCBsb2NhbGx5IHJlY29yZGVkIHN1Ym1vZHVsZSBtb2RpZmljYXRpb25zIgogbXNnc3RyICIiCiAiS2FubiBSZWJhc2UgbmljaHQgbWl0IGxva2FsIGF1ZmdlemVpY2huZXRlbiDDhG5kZXJ1bmdlbiBpbiBTdWJtb2R1bGVuICIKQEAgLTE3MTMxLDE3ICsxNzIxNCw5NCBAQAogbXNnaWQgIlB1c2hpbmcgdG8gJXNcbiIKIG1zZ3N0ciAiVmVyc2VuZGUgbmFjaCAlc1xuIgogCi0jOiBidWlsdGluL3B1c2guYzozNjQKKyM6IGJ1aWx0aW4vcHVzaC5jOjM2NgogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gcHVzaCBzb21lIHJlZnMgdG8gJyVzJyIKIG1zZ3N0ciAiRmVobGVyIGJlaW0gVmVyc2VuZGVuIGVpbmlnZXIgUmVmZXJlbnplbiBuYWNoICclcyciCiAKLSM6IGJ1aWx0aW4vcHVzaC5jOjM5OAorIzogYnVpbHRpbi9wdXNoLmM6NTQxCittc2dpZCAicmVwb3NpdG9yeSIKK21zZ3N0ciAiUmVwb3NpdG9yeSIKKworIzogYnVpbHRpbi9wdXNoLmM6NTQyIGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTY0Cittc2dpZCAicHVzaCBhbGwgcmVmcyIKK21zZ3N0ciAiYWxsZSBSZWZlcmVuemVuIHZlcnNlbmRlbiIKKworIzogYnVpbHRpbi9wdXNoLmM6NTQzIGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTY2Cittc2dpZCAibWlycm9yIGFsbCByZWZzIgorbXNnc3RyICJhbGxlIFJlZmVyZW56ZW4gc3BpZWdlbG4iCisKKyM6IGJ1aWx0aW4vcHVzaC5jOjU0NQorbXNnaWQgImRlbGV0ZSByZWZzIgorbXNnc3RyICJSZWZlcmVuemVuIGzDtnNjaGVuIgorCisjOiBidWlsdGluL3B1c2guYzo1NDYKK21zZ2lkICJwdXNoIHRhZ3MgKGNhbid0IGJlIHVzZWQgd2l0aCAtLWFsbCBvciAtLW1pcnJvcikiCittc2dzdHIgIlRhZ3MgdmVyc2VuZGVuIChrYW5uIG5pY2h0IG1pdCAtLWFsbCBvZGVyIC0tbWlycm9yIHZlcndlbmRldCB3ZXJkZW4pIgorCisjOiBidWlsdGluL3B1c2guYzo1NDkgYnVpbHRpbi9zZW5kLXBhY2suYzoxNjcKK21zZ2lkICJmb3JjZSB1cGRhdGVzIgorbXNnc3RyICJBa3R1YWxpc2llcnVuZyBlcnp3aW5nZW4iCisKKyM6IGJ1aWx0aW4vcHVzaC5jOjU1MSBidWlsdGluL3NlbmQtcGFjay5jOjE4MQorbXNnaWQgIjxyZWZuYW1lPjo8ZXhwZWN0PiIKK21zZ3N0ciAiPFJlZmVyZW56bmFtZT46PEVyd2FydHVuZ3N3ZXJ0PiIKKworIzogYnVpbHRpbi9wdXNoLmM6NTUyIGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTgyCittc2dpZCAicmVxdWlyZSBvbGQgdmFsdWUgb2YgcmVmIHRvIGJlIGF0IHRoaXMgdmFsdWUiCittc2dzdHIgIlJlZmVyZW56IG11c3Mgc2ljaCBhdWYgZGVtIGFuZ2VnZWJlbmVuIFdlcnQgYmVmaW5kZW4iCisKKyM6IGJ1aWx0aW4vcHVzaC5jOjU1NQorbXNnaWQgImNvbnRyb2wgcmVjdXJzaXZlIHB1c2hpbmcgb2Ygc3VibW9kdWxlcyIKK21zZ3N0ciAicmVrdXJzaXZlbiBcInB1c2hcIiB2b24gU3VibW9kdWxlbiBzdGV1ZXJuIgorCisjOiBidWlsdGluL3B1c2guYzo1NTcgYnVpbHRpbi9zZW5kLXBhY2suYzoxNzUKK21zZ2lkICJ1c2UgdGhpbiBwYWNrIgorbXNnc3RyICJrbGVpbmVyZSBQYWtldGUgdmVyd2VuZGVuIgorCisjOiBidWlsdGluL3B1c2guYzo1NTggYnVpbHRpbi9wdXNoLmM6NTU5IGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTYxCisjOiBidWlsdGluL3NlbmQtcGFjay5jOjE2MgorbXNnaWQgInJlY2VpdmUgcGFjayBwcm9ncmFtIgorbXNnc3RyICIncmVjZWl2ZSBwYWNrJyBQcm9ncmFtbSIKKworIzogYnVpbHRpbi9wdXNoLmM6NTYwCittc2dpZCAic2V0IHVwc3RyZWFtIGZvciBnaXQgcHVsbC9zdGF0dXMiCittc2dzdHIgIlVwc3RyZWFtIGbDvHIgXCJnaXQgcHVsbC9zdGF0dXNcIiBzZXR6ZW4iCisKKyM6IGJ1aWx0aW4vcHVzaC5jOjU2MworbXNnaWQgInBydW5lIGxvY2FsbHkgcmVtb3ZlZCByZWZzIgorbXNnc3RyICJsb2thbCBnZWzDtnNjaHRlIFJlZmVyZW56ZW4gZW50ZmVybmVuIgorCisjOiBidWlsdGluL3B1c2guYzo1NjUKK21zZ2lkICJieXBhc3MgcHJlLXB1c2ggaG9vayIKK21zZ3N0ciAiXCJwcmUtcHVzaCBob29rXCIgdW1nZWhlbiIKKworIzogYnVpbHRpbi9wdXNoLmM6NTY2Cittc2dpZCAicHVzaCBtaXNzaW5nIGJ1dCByZWxldmFudCB0YWdzIgorbXNnc3RyICJmZWhsZW5kZSwgYWJlciByZWxldmFudGUgVGFncyB2ZXJzZW5kZW4iCisKKyM6IGJ1aWx0aW4vcHVzaC5jOjU2OSBidWlsdGluL3NlbmQtcGFjay5jOjE2OQorbXNnaWQgIkdQRyBzaWduIHRoZSBwdXNoIgorbXNnc3RyICJzaWduaWVydCBcInB1c2hcIiBtaXQgR1BHIgorCisjOiBidWlsdGluL3B1c2guYzo1NzEgYnVpbHRpbi9zZW5kLXBhY2suYzoxNzYKK21zZ2lkICJyZXF1ZXN0IGF0b21pYyB0cmFuc2FjdGlvbiBvbiByZW1vdGUgc2lkZSIKK21zZ3N0ciAiUmVmZXJlbnplbiBhdG9tYXIgdmVyc2VuZGVuIgorCisjOiBidWlsdGluL3B1c2guYzo1ODkKK21zZ2lkICItLWRlbGV0ZSBpcyBpbmNvbXBhdGlibGUgd2l0aCAtLWFsbCwgLS1taXJyb3IgYW5kIC0tdGFncyIKK21zZ3N0ciAiRGllIE9wdGlvbiAtLWRlbGV0ZSBpc3QgaW5rb21wYXRpYmVsIG1pdCAtLWFsbCwgLS1taXJyb3IgdW5kIC0tdGFncy4iCisKKyM6IGJ1aWx0aW4vcHVzaC5jOjU5MQorbXNnaWQgIi0tZGVsZXRlIGRvZXNuJ3QgbWFrZSBzZW5zZSB3aXRob3V0IGFueSByZWZzIgorbXNnc3RyICJEaWUgT3B0aW9uIC0tZGVsZXRlIGthbm4gbnVyIG1pdCBSZWZlcmVuemVuIHZlcndlbmRldCB3ZXJkZW4uIgorCisjOiBidWlsdGluL3B1c2guYzo2MTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiYmFkIHJlcG9zaXRvcnkgJyVzJyIKIG1zZ3N0ciAidW5nw7xsdGlnZXMgUmVwb3NpdG9yeSAnJXMnIgogCi0jOiBidWlsdGluL3B1c2guYzozOTkKKyM6IGJ1aWx0aW4vcHVzaC5jOjYxMgogbXNnaWQgIiIKICJObyBjb25maWd1cmVkIHB1c2ggZGVzdGluYXRpb24uXG4iCiAiRWl0aGVyIHNwZWNpZnkgdGhlIFVSTCBmcm9tIHRoZSBjb21tYW5kLWxpbmUgb3IgY29uZmlndXJlIGEgcmVtb3RlICIKQEAgLTE3MTYzLDEwNCArMTczMjMsMjcgQEAKICJcbiIKICIgICAgZ2l0IHB1c2ggPE5hbWU+XG4iCiAKLSM6IGJ1aWx0aW4vcHVzaC5jOjU1NAotbXNnaWQgInJlcG9zaXRvcnkiCi1tc2dzdHIgIlJlcG9zaXRvcnkiCi0KLSM6IGJ1aWx0aW4vcHVzaC5jOjU1NSBidWlsdGluL3NlbmQtcGFjay5jOjE2NAotbXNnaWQgInB1c2ggYWxsIHJlZnMiCi1tc2dzdHIgImFsbGUgUmVmZXJlbnplbiB2ZXJzZW5kZW4iCi0KLSM6IGJ1aWx0aW4vcHVzaC5jOjU1NiBidWlsdGluL3NlbmQtcGFjay5jOjE2NgotbXNnaWQgIm1pcnJvciBhbGwgcmVmcyIKLW1zZ3N0ciAiYWxsZSBSZWZlcmVuemVuIHNwaWVnZWxuIgotCi0jOiBidWlsdGluL3B1c2guYzo1NTgKLW1zZ2lkICJkZWxldGUgcmVmcyIKLW1zZ3N0ciAiUmVmZXJlbnplbiBsw7ZzY2hlbiIKLQotIzogYnVpbHRpbi9wdXNoLmM6NTU5Ci1tc2dpZCAicHVzaCB0YWdzIChjYW4ndCBiZSB1c2VkIHdpdGggLS1hbGwgb3IgLS1taXJyb3IpIgotbXNnc3RyICJUYWdzIHZlcnNlbmRlbiAoa2FubiBuaWNodCBtaXQgLS1hbGwgb2RlciAtLW1pcnJvciB2ZXJ3ZW5kZXQgd2VyZGVuKSIKLQotIzogYnVpbHRpbi9wdXNoLmM6NTYyIGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTY3Ci1tc2dpZCAiZm9yY2UgdXBkYXRlcyIKLW1zZ3N0ciAiQWt0dWFsaXNpZXJ1bmcgZXJ6d2luZ2VuIgotCi0jOiBidWlsdGluL3B1c2guYzo1NjQgYnVpbHRpbi9zZW5kLXBhY2suYzoxODEKLW1zZ2lkICI8cmVmbmFtZT46PGV4cGVjdD4iCi1tc2dzdHIgIjxSZWZlcmVuem5hbWU+OjxFcndhcnR1bmdzd2VydD4iCi0KLSM6IGJ1aWx0aW4vcHVzaC5jOjU2NSBidWlsdGluL3NlbmQtcGFjay5jOjE4MgotbXNnaWQgInJlcXVpcmUgb2xkIHZhbHVlIG9mIHJlZiB0byBiZSBhdCB0aGlzIHZhbHVlIgotbXNnc3RyICJSZWZlcmVueiBtdXNzIHNpY2ggYXVmIGRlbSBhbmdlZ2ViZW5lbiBXZXJ0IGJlZmluZGVuIgotCi0jOiBidWlsdGluL3B1c2guYzo1NjgKLW1zZ2lkICJjb250cm9sIHJlY3Vyc2l2ZSBwdXNoaW5nIG9mIHN1Ym1vZHVsZXMiCi1tc2dzdHIgInJla3Vyc2l2ZW4gXCJwdXNoXCIgdm9uIFN1Ym1vZHVsZW4gc3RldWVybiIKLQotIzogYnVpbHRpbi9wdXNoLmM6NTcwIGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTc1Ci1tc2dpZCAidXNlIHRoaW4gcGFjayIKLW1zZ3N0ciAia2xlaW5lcmUgUGFrZXRlIHZlcndlbmRlbiIKLQotIzogYnVpbHRpbi9wdXNoLmM6NTcxIGJ1aWx0aW4vcHVzaC5jOjU3MiBidWlsdGluL3NlbmQtcGFjay5jOjE2MQotIzogYnVpbHRpbi9zZW5kLXBhY2suYzoxNjIKLW1zZ2lkICJyZWNlaXZlIHBhY2sgcHJvZ3JhbSIKLW1zZ3N0ciAiJ3JlY2VpdmUgcGFjaycgUHJvZ3JhbW0iCi0KLSM6IGJ1aWx0aW4vcHVzaC5jOjU3MwotbXNnaWQgInNldCB1cHN0cmVhbSBmb3IgZ2l0IHB1bGwvc3RhdHVzIgotbXNnc3RyICJVcHN0cmVhbSBmw7xyIFwiZ2l0IHB1bGwvc3RhdHVzXCIgc2V0emVuIgotCi0jOiBidWlsdGluL3B1c2guYzo1NzYKLW1zZ2lkICJwcnVuZSBsb2NhbGx5IHJlbW92ZWQgcmVmcyIKLW1zZ3N0ciAibG9rYWwgZ2Vsw7ZzY2h0ZSBSZWZlcmVuemVuIGVudGZlcm5lbiIKLQotIzogYnVpbHRpbi9wdXNoLmM6NTc4Ci1tc2dpZCAiYnlwYXNzIHByZS1wdXNoIGhvb2siCi1tc2dzdHIgIlwicHJlLXB1c2ggaG9va1wiIHVtZ2VoZW4iCi0KLSM6IGJ1aWx0aW4vcHVzaC5jOjU3OQotbXNnaWQgInB1c2ggbWlzc2luZyBidXQgcmVsZXZhbnQgdGFncyIKLW1zZ3N0ciAiZmVobGVuZGUsIGFiZXIgcmVsZXZhbnRlIFRhZ3MgdmVyc2VuZGVuIgotCi0jOiBidWlsdGluL3B1c2guYzo1ODIgYnVpbHRpbi9zZW5kLXBhY2suYzoxNjkKLW1zZ2lkICJHUEcgc2lnbiB0aGUgcHVzaCIKLW1zZ3N0ciAic2lnbmllcnQgXCJwdXNoXCIgbWl0IEdQRyIKLQotIzogYnVpbHRpbi9wdXNoLmM6NTg0IGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTc2Ci1tc2dpZCAicmVxdWVzdCBhdG9taWMgdHJhbnNhY3Rpb24gb24gcmVtb3RlIHNpZGUiCi1tc2dzdHIgIlJlZmVyZW56ZW4gYXRvbWFyIHZlcnNlbmRlbiIKLQotIzogYnVpbHRpbi9wdXNoLmM6NjAyCi1tc2dpZCAiLS1kZWxldGUgaXMgaW5jb21wYXRpYmxlIHdpdGggLS1hbGwsIC0tbWlycm9yIGFuZCAtLXRhZ3MiCi1tc2dzdHIgIkRpZSBPcHRpb24gLS1kZWxldGUgaXN0IGlua29tcGF0aWJlbCBtaXQgLS1hbGwsIC0tbWlycm9yIHVuZCAtLXRhZ3MuIgotCi0jOiBidWlsdGluL3B1c2guYzo2MDQKLW1zZ2lkICItLWRlbGV0ZSBkb2Vzbid0IG1ha2Ugc2Vuc2Ugd2l0aG91dCBhbnkgcmVmcyIKLW1zZ3N0ciAiRGllIE9wdGlvbiAtLWRlbGV0ZSBrYW5uIG51ciBtaXQgUmVmZXJlbnplbiB2ZXJ3ZW5kZXQgd2VyZGVuLiIKLQotIzogYnVpbHRpbi9wdXNoLmM6NjA3CisjOiBidWlsdGluL3B1c2guYzo2MjcKIG1zZ2lkICItLWFsbCBhbmQgLS10YWdzIGFyZSBpbmNvbXBhdGlibGUiCiBtc2dzdHIgIkRpZSBPcHRpb25lbiAtLWFsbCB1bmQgLS10YWdzIHNpbmQgaW5rb21wYXRpYmVsLiIKIAotIzogYnVpbHRpbi9wdXNoLmM6NjA5CisjOiBidWlsdGluL3B1c2guYzo2MjkKIG1zZ2lkICItLWFsbCBjYW4ndCBiZSBjb21iaW5lZCB3aXRoIHJlZnNwZWNzIgogbXNnc3RyICJEaWUgT3B0aW9uIC0tYWxsIGthbm4gbmljaHQgbWl0IFJlZnNwZWNzIGtvbWJpbmllcnQgd2VyZGVuLiIKIAotIzogYnVpbHRpbi9wdXNoLmM6NjEzCisjOiBidWlsdGluL3B1c2guYzo2MzMKIG1zZ2lkICItLW1pcnJvciBhbmQgLS10YWdzIGFyZSBpbmNvbXBhdGlibGUiCiBtc2dzdHIgIkRpZSBPcHRpb25lbiAtLW1pcnJvciB1bmQgLS10YWdzIHNpbmQgaW5rb21wYXRpYmVsLiIKIAotIzogYnVpbHRpbi9wdXNoLmM6NjE1CisjOiBidWlsdGluL3B1c2guYzo2MzUKIG1zZ2lkICItLW1pcnJvciBjYW4ndCBiZSBjb21iaW5lZCB3aXRoIHJlZnNwZWNzIgogbXNnc3RyICJEaWUgT3B0aW9uIC0tbWlycm9yIGthbm4gbmljaHQgbWl0IFJlZnNwZWNzIGtvbWJpbmllcnQgd2VyZGVuLiIKIAotIzogYnVpbHRpbi9wdXNoLmM6NjE4CisjOiBidWlsdGluL3B1c2guYzo2MzgKIG1zZ2lkICItLWFsbCBhbmQgLS1taXJyb3IgYXJlIGluY29tcGF0aWJsZSIKIG1zZ3N0ciAiRGllIE9wdGlvbmVuIC0tYWxsIHVuZCAtLW1pcnJvciBzaW5kIGlua29tcGF0aWJlbC4iCiAKLSM6IGJ1aWx0aW4vcHVzaC5jOjYzNworIzogYnVpbHRpbi9wdXNoLmM6NjQyCiBtc2dpZCAicHVzaCBvcHRpb25zIG11c3Qgbm90IGhhdmUgbmV3IGxpbmUgY2hhcmFjdGVycyIKIG1zZ3N0ciAiUHVzaC1PcHRpb25lbiBkw7xyZmVuIGtlaW5lIFplaWxlbnZvcnNjaHViemVpY2hlbiBoYWJlbiIKIApAQCAtMTczODAsMTEgKzE3NDYzLDExIEBACiAKICM6IGJ1aWx0aW4vcmViYXNlLmM6MzIKIG1zZ2lkICIiCi0iZ2l0IHJlYmFzZSBbLWldIFtvcHRpb25zXSBbLS1leGVjIDxjbWQ+XSBbLS1vbnRvIDxuZXdiYXNlPl0gWzx1cHN0cmVhbT5dICIKLSJbPGJyYW5jaD5dIgorImdpdCByZWJhc2UgWy1pXSBbb3B0aW9uc10gWy0tZXhlYyA8Y21kPl0gWy0tb250byA8bmV3YmFzZT4gfCAtLWtlZXAtYmFzZV0gIgorIls8dXBzdHJlYW0+IFs8YnJhbmNoPl1dIgogbXNnc3RyICIiCi0iZ2l0IHJlYmFzZSBbLWldIFs8T3B0aW9uZW4+XSBbLS1leGVjIDxQcm9ncmFtbT5dIFstLW9udG8gPG5ldWUtQmFzaXM+XSAiCi0iWzxVcHN0cmVhbT5dIFs8QnJhbmNoPl0iCisiZ2l0IHJlYmFzZSBbLWldIFs8T3B0aW9uZW4+XSBbLS1leGVjIDxQcm9ncmFtbT5dIFstLW9udG8gPG5ldWUtQmFzaXM+IHwgLS0iCisia2VlcC1iYXNlXSBbPFVwc3RyZWFtPiBbPEJyYW5jaD5dXSIKIAogIzogYnVpbHRpbi9yZWJhc2UuYzozNAogbXNnaWQgIiIKQEAgLTE3NDI0LDE5MCArMTc1MDcsMTkwIEBACiBtc2dpZCAiY291bGQgbm90IGdlbmVyYXRlIHRvZG8gbGlzdCIKIG1zZ3N0ciAiS29ubnRlIFRPRE8tTGlzdGUgbmljaHQgZXJ6ZXVnZW4uIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjM4MgorIzogYnVpbHRpbi9yZWJhc2UuYzozODMKIG1zZ2lkICJhIGJhc2UgY29tbWl0IG11c3QgYmUgcHJvdmlkZWQgd2l0aCAtLXVwc3RyZWFtIG9yIC0tb250byIKIG1zZ3N0ciAiRWluIEJhc2lzLUNvbW1pdCBtdXNzIG1pdCAtLXVwc3RyZWFtIG9kZXIgLS1vbnRvIGFuZ2VnZWJlbiB3ZXJkZW4uIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQzNworIzogYnVpbHRpbi9yZWJhc2UuYzo0MzgKIG1zZ2lkICJnaXQgcmViYXNlLS1pbnRlcmFjdGl2ZSBbPG9wdGlvbnM+XSIKIG1zZ3N0ciAiZ2l0IHJlYmFzZS0taW50ZXJhY3RpdmUgWzxPcHRpb25lbj5dIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ0OQorIzogYnVpbHRpbi9yZWJhc2UuYzo0NTAKIG1zZ2lkICJrZWVwIGVtcHR5IGNvbW1pdHMiCiBtc2dzdHIgImxlZXJlIENvbW1pdHMgYmVoYWx0ZW4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDUxIGJ1aWx0aW4vcmV2ZXJ0LmM6MTI4CisjOiBidWlsdGluL3JlYmFzZS5jOjQ1MiBidWlsdGluL3JldmVydC5jOjEyOAogbXNnaWQgImFsbG93IGNvbW1pdHMgd2l0aCBlbXB0eSBtZXNzYWdlcyIKIG1zZ3N0ciAiQ29tbWl0cyBtaXQgbGVlcmVyIEJlc2NocmVpYnVuZyBlcmxhdWJlbiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0NTIKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDUzCiBtc2dpZCAicmViYXNlIG1lcmdlIGNvbW1pdHMiCiBtc2dzdHIgIlJlYmFzZSBhdWYgTWVyZ2UtQ29tbWl0cyBhdXNmw7xocmVuIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ1NAorIzogYnVpbHRpbi9yZWJhc2UuYzo0NTUKIG1zZ2lkICJrZWVwIG9yaWdpbmFsIGJyYW5jaCBwb2ludHMgb2YgY291c2lucyIKIG1zZ3N0ciAib3JpZ2luYWxlIEJyYW5jaC1QdW5rdGUgZGVyIENvdXNpbnMgYmVoYWx0ZW4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDU2CisjOiBidWlsdGluL3JlYmFzZS5jOjQ1NwogbXNnaWQgIm1vdmUgY29tbWl0cyB0aGF0IGJlZ2luIHdpdGggc3F1YXNoIS9maXh1cCEiCiBtc2dzdHIgIkNvbW1pdHMgdmVyc2NoaWViZW4sIGRpZSBtaXQgc3F1YXNoIS9maXh1cCEgYmVnaW5uZW4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDU3CisjOiBidWlsdGluL3JlYmFzZS5jOjQ1OAogbXNnaWQgInNpZ24gY29tbWl0cyIKIG1zZ3N0ciAiQ29tbWl0cyBzaWduaWVyZW4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDU5IGJ1aWx0aW4vcmViYXNlLmM6MTQwMworIzogYnVpbHRpbi9yZWJhc2UuYzo0NjAgYnVpbHRpbi9yZWJhc2UuYzoxNDI3CiBtc2dpZCAiZGlzcGxheSBhIGRpZmZzdGF0IG9mIHdoYXQgY2hhbmdlZCB1cHN0cmVhbSIKIG1zZ3N0ciAiIgogIlp1c2FtbWVuZmFzc3VuZyBkZXIgVW50ZXJzY2hpZWRlIGdlZ2Vuw7xiZXIgZGVtIFVwc3RyZWFtLUJyYW5jaCBhbnplaWdlbiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0NjEKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDYyCiBtc2dpZCAiY29udGludWUgcmViYXNlIgogbXNnc3RyICJSZWJhc2UgZm9ydHNldHplbiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0NjMKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDY0CiBtc2dpZCAic2tpcCBjb21taXQiCiBtc2dzdHIgIkNvbW1pdCBhdXNsYXNzZW4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDY0CisjOiBidWlsdGluL3JlYmFzZS5jOjQ2NQogbXNnaWQgImVkaXQgdGhlIHRvZG8gbGlzdCIKIG1zZ3N0ciAiZGllIFRPRE8tTGlzdGUgYmVhcmJlaXRlbiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0NjYKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDY3CiBtc2dpZCAic2hvdyB0aGUgY3VycmVudCBwYXRjaCIKIG1zZ3N0ciAiZGVuIGFrdHVlbGxlbiBQYXRjaCBhbnplaWdlbiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0NjkKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDcwCiBtc2dpZCAic2hvcnRlbiBjb21taXQgaWRzIGluIHRoZSB0b2RvIGxpc3QiCiBtc2dzdHIgIkNvbW1pdC1JRHMgaW4gZGVyIFRPRE8tTGlzdGUgdmVya8O8cnplbiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0NzEKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDcyCiBtc2dpZCAiZXhwYW5kIGNvbW1pdCBpZHMgaW4gdGhlIHRvZG8gbGlzdCIKIG1zZ3N0ciAiQ29tbWl0LUlEcyBpbiBkZXIgVE9ETy1MaXN0ZSBlcndlaXRlcm4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDczCisjOiBidWlsdGluL3JlYmFzZS5jOjQ3NAogbXNnaWQgImNoZWNrIHRoZSB0b2RvIGxpc3QiCiBtc2dzdHIgImRpZSBUT0RPLUxpc3RlIHByw7xmZW4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDc1CisjOiBidWlsdGluL3JlYmFzZS5jOjQ3NgogbXNnaWQgInJlYXJyYW5nZSBmaXh1cC9zcXVhc2ggbGluZXMiCiBtc2dzdHIgImZpeHVwL3NxdWFzaC1aZWlsZW4gdW1vcmRuZW4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDc3CisjOiBidWlsdGluL3JlYmFzZS5jOjQ3OAogbXNnaWQgImluc2VydCBleGVjIGNvbW1hbmRzIGluIHRvZG8gbGlzdCIKIG1zZ3N0ciAiXCJleGVjXCItQmVmZWhsZSBpbiBUT0RPLUxpc3RlIGVpbmbDvGdlbiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0NzgKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDc5CiBtc2dpZCAib250byIKIG1zZ3N0ciAiYXVmIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ4MQorIzogYnVpbHRpbi9yZWJhc2UuYzo0ODIKIG1zZ2lkICJyZXN0cmljdC1yZXZpc2lvbiIKIG1zZ3N0ciAiQmVncmVuenVuZ3Njb21taXQiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDgxCisjOiBidWlsdGluL3JlYmFzZS5jOjQ4MgogbXNnaWQgInJlc3RyaWN0IHJldmlzaW9uIgogbXNnc3RyICJCZWdyZW56dW5nc2NvbW1pdCIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0ODMKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDg0CiBtc2dpZCAic3F1YXNoLW9udG8iCiBtc2dzdHIgInNxdWFzaC1vbnRvIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ4NAorIzogYnVpbHRpbi9yZWJhc2UuYzo0ODUKIG1zZ2lkICJzcXVhc2ggb250byIKIG1zZ3N0ciAic3F1YXNoIG9udG8iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDg2CisjOiBidWlsdGluL3JlYmFzZS5jOjQ4NwogbXNnaWQgInRoZSB1cHN0cmVhbSBjb21taXQiCiBtc2dzdHIgImRlciBVcHN0cmVhbS1Db21taXQiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDg4CisjOiBidWlsdGluL3JlYmFzZS5jOjQ4OQogbXNnaWQgImhlYWQtbmFtZSIKIG1zZ3N0ciAiaGVhZC1OYW1lIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ4OAorIzogYnVpbHRpbi9yZWJhc2UuYzo0ODkKIG1zZ2lkICJoZWFkIG5hbWUiCiBtc2dzdHIgImhlYWQtTmFtZSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0OTMKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDk0CiBtc2dpZCAicmViYXNlIHN0cmF0ZWd5IgogbXNnc3RyICJSZWJhc2UtU3RyYXRlZ2llIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ5NAorIzogYnVpbHRpbi9yZWJhc2UuYzo0OTUKIG1zZ2lkICJzdHJhdGVneS1vcHRzIgogbXNnc3RyICJTdHJhdGVnaWUtT3B0aW9uZW4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDk1CisjOiBidWlsdGluL3JlYmFzZS5jOjQ5NgogbXNnaWQgInN0cmF0ZWd5IG9wdGlvbnMiCiBtc2dzdHIgIlN0cmF0ZWdpZS1PcHRpb25lbiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0OTYKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDk3CiBtc2dpZCAic3dpdGNoLXRvIgogbXNnc3RyICJ3ZWNoc2VsbiB6dSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0OTcKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDk4CiBtc2dpZCAidGhlIGJyYW5jaCBvciBjb21taXQgdG8gY2hlY2tvdXQiCiBtc2dzdHIgImRlciBCcmFuY2ggb2RlciBDb21taXQgenVtIEF1c2NoZWNrZW4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDk4CisjOiBidWlsdGluL3JlYmFzZS5jOjQ5OQogbXNnaWQgIm9udG8tbmFtZSIKIG1zZ3N0ciAib250by1OYW1lIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ5OAorIzogYnVpbHRpbi9yZWJhc2UuYzo0OTkKIG1zZ2lkICJvbnRvIG5hbWUiCiBtc2dzdHIgIm9udG8tTmFtZSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0OTkKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NTAwCiBtc2dpZCAiY21kIgogbXNnc3RyICJCZWZlaGwiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDk5CisjOiBidWlsdGluL3JlYmFzZS5jOjUwMAogbXNnaWQgInRoZSBjb21tYW5kIHRvIHJ1biIKIG1zZ3N0ciAiYXVzenVmw7xocmVuZGVyIEJlZmVobCIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo1MDIgYnVpbHRpbi9yZWJhc2UuYzoxNDg2CisjOiBidWlsdGluL3JlYmFzZS5jOjUwMyBidWlsdGluL3JlYmFzZS5jOjE1MTAKIG1zZ2lkICJhdXRvbWF0aWNhbGx5IHJlLXNjaGVkdWxlIGFueSBgZXhlY2AgdGhhdCBmYWlscyIKIG1zZ3N0ciAiamVkZW4gZmVobGdlc2NobGFnZW5lbiBgZXhlY2AtQmVmZWhsIG5ldSBhbnNldHplbiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo1MTgKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NTE5CiBtc2dpZCAiLS1bbm8tXXJlYmFzZS1jb3VzaW5zIGhhcyBubyBlZmZlY3Qgd2l0aG91dCAtLXJlYmFzZS1tZXJnZXMiCiBtc2dzdHIgIi0tW25vLV1yZWJhc2UtY291c2lucyBoYXQgb2huZSAtLXJlYmFzZS1tZXJnZXMga2VpbmUgQXVzd2lya3VuZyIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo1MzQKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NTM1CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIHJlcXVpcmVzIGFuIGludGVyYWN0aXZlIHJlYmFzZSIKIG1zZ3N0ciAiJXMgZXJmb3JkZXJ0IGVpbiBpbnRlcmFrdGl2ZXMgUmViYXNlIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjU4NgorIzogYnVpbHRpbi9yZWJhc2UuYzo1ODcKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGdldCAnb250byc6ICclcyciCiBtc2dzdHIgIktvbm50ZSAnb250bycgbmljaHQgYmVzdGltbWVuOiAnJXMnIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjYwMQorIzogYnVpbHRpbi9yZWJhc2UuYzo2MDIKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBvcmlnLWhlYWQ6ICclcyciCiBtc2dzdHIgIlVuZ8O8bHRpZ2VzIG9yaWctaGVhZDogJyVzJyIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo2MjYKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NjI3CiAjLCBjLWZvcm1hdAogbXNnaWQgImlnbm9yaW5nIGludmFsaWQgYWxsb3dfcmVyZXJlX2F1dG91cGRhdGU6ICclcyciCiBtc2dzdHIgIklnbm9yaWVyZSB1bmfDvGx0aWdlcyBhbGxvd19yZXJlcmVfYXV0b3VwZGF0ZTogJyVzJyIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo3MDIKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NzAzCiAjLCBjLWZvcm1hdAogbXNnaWQgIkNvdWxkIG5vdCByZWFkICclcyciCiBtc2dzdHIgIktvbm50ZSAnJXMnIG5pY2h0IGxlc2VuLiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo3MjAKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NzIxCiAjLCBjLWZvcm1hdAogbXNnaWQgIkNhbm5vdCBzdG9yZSAlcyIKIG1zZ3N0ciAiS2FubiAlcyBuaWNodCBzcGVpY2hlcm4uIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjgyNworIzogYnVpbHRpbi9yZWJhc2UuYzo4MjgKIG1zZ2lkICJjb3VsZCBub3QgZGV0ZXJtaW5lIEhFQUQgcmV2aXNpb24iCiBtc2dzdHIgIktvbm50ZSBIRUFELUNvbW1pdCBuaWNodCBiZXN0aW1tZW4uIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjk1MCBnaXQtcmViYXNlLS1wcmVzZXJ2ZS1tZXJnZXMuc2g6ODEKKyM6IGJ1aWx0aW4vcmViYXNlLmM6OTUxIGdpdC1yZWJhc2UtLXByZXNlcnZlLW1lcmdlcy5zaDo4MQogbXNnaWQgIiIKICJSZXNvbHZlIGFsbCBjb25mbGljdHMgbWFudWFsbHksIG1hcmsgdGhlbSBhcyByZXNvbHZlZCB3aXRoXG4iCiAiXCJnaXQgYWRkL3JtIDxjb25mbGljdGVkX2ZpbGVzPlwiLCB0aGVuIHJ1biBcImdpdCByZWJhc2UgLS1jb250aW51ZVwiLlxuIgpAQCAtMTc2MjMsNyArMTc3MDYsNyBAQAogIlVtIGFienVicmVjaGVuIHVuZCB6dXLDvGNrIHp1bSBadXN0YW5kIHZvciBcImdpdCByZWJhc2VcIiB6dSBnZWxhbmdlbixcbiIKICJmw7xocmVuIFNpZSBcImdpdCByZWJhc2UgLS1hYm9ydFwiIGF1cy4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTAzMQorIzogYnVpbHRpbi9yZWJhc2UuYzoxMDMyCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJcbiIKQEAgLTE3NjQzLDcgKzE3NzI2LDcgQEAKICJJbmZvbGdlIGRlc3NlbiBrYW5uIEdpdCBhdWYgZGllc2VuIFJldmlzaW9uZW4gUmViYXNlIG5pY2h0XG4iCiAiYXVzZsO8aHJlbi4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTMxOAorIzogYnVpbHRpbi9yZWJhc2UuYzoxMzM5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICIlc1xuIgpAQCAtMTc2NjEsNyArMTc3NDQsNyBAQAogIiAgICBnaXQgcmViYXNlICc8QnJhbmNoPidcbiIKICJcbiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxMzM0CisjOiBidWlsdGluL3JlYmFzZS5jOjEzNTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIklmIHlvdSB3aXNoIHRvIHNldCB0cmFja2luZyBpbmZvcm1hdGlvbiBmb3IgdGhpcyBicmFuY2ggeW91IGNhbiBkbyBzbyB3aXRoOlxuIgpAQCAtMTc2NzUsMTMyICsxNzc1OCwxMzYgQEAKICIgICAgZ2l0IGJyYW5jaCAtLXNldC11cHN0cmVhbS10bz0lcy88QnJhbmNoPiAlc1xuIgogIlxuIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjEzNjQKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTM4NQogbXNnaWQgImV4ZWMgY29tbWFuZHMgY2Fubm90IGNvbnRhaW4gbmV3bGluZXMiCiBtc2dzdHIgIlwiZXhlY1wiLUJlZmVobGUga8O2bm5lbiBrZWluZSBuZXVlbiBaZWlsZW4gZW50aGFsdGVuIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjEzNjgKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTM4OQogbXNnaWQgImVtcHR5IGV4ZWMgY29tbWFuZCIKIG1zZ3N0ciAiTGVlcmVyIFwiZXhlY1wiLUJlZmVobC4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTM5NgorIzogYnVpbHRpbi9yZWJhc2UuYzoxNDE4CiBtc2dpZCAicmViYXNlIG9udG8gZ2l2ZW4gYnJhbmNoIGluc3RlYWQgb2YgdXBzdHJlYW0iCiBtc2dzdHIgIlJlYmFzZSBhdWYgYW5nZWdlYmVuZW4gQnJhbmNoIGFuc3RlbGxlIGRlcyBVcHN0cmVhbS1CcmFuY2hlcyBhdXNmw7xocmVuIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjEzOTgKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQyMAorbXNnaWQgInVzZSB0aGUgbWVyZ2UtYmFzZSBvZiB1cHN0cmVhbSBhbmQgYnJhbmNoIGFzIHRoZSBjdXJyZW50IGJhc2UiCittc2dzdHIgIk51dHplIGRpZSBNZXJnZS1CYXNpcyB2b24gVXBzdHJlYW0gdW5kIEJyYW5jaCBhbHMgZGllIGFrdHVlbGxlIEJhc2lzIgorCisjOiBidWlsdGluL3JlYmFzZS5jOjE0MjIKIG1zZ2lkICJhbGxvdyBwcmUtcmViYXNlIGhvb2sgdG8gcnVuIgogbXNnc3RyICJBdXNmw7xocnVuZyBkZXMgcHJlLXJlYmFzZS1Ib29rcyBlcmxhdWJlbiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDAwCisjOiBidWlsdGluL3JlYmFzZS5jOjE0MjQKIG1zZ2lkICJiZSBxdWlldC4gaW1wbGllcyAtLW5vLXN0YXQiCiBtc2dzdHIgIndlbmlnZXIgQXVzZ2FiZW4gKGltcGxpemllcnQgLS1uby1zdGF0KSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDA2CisjOiBidWlsdGluL3JlYmFzZS5jOjE0MzAKIG1zZ2lkICJkbyBub3Qgc2hvdyBkaWZmc3RhdCBvZiB3aGF0IGNoYW5nZWQgdXBzdHJlYW0iCiBtc2dzdHIgIiIKICJadXNhbW1lbmZhc3N1bmcgZGVyIFVudGVyc2NoaWVkZSBnZWdlbsO8YmVyIGRlbSBVcHN0cmVhbS1CcmFuY2ggdmVyYmVyZ2VuIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0MDkKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQzMwogbXNnaWQgImFkZCBhIFNpZ25lZC1vZmYtYnk6IGxpbmUgdG8gZWFjaCBjb21taXQiCiBtc2dzdHIgImVpbmUgXCJTaWduZWQtb2ZmLWJ5OlwiLVplaWxlIHp1IGplZGVtIENvbW1pdCBoaW56dWbDvGdlbiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDExIGJ1aWx0aW4vcmViYXNlLmM6MTQxNSBidWlsdGluL3JlYmFzZS5jOjE0MTcKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQzNSBidWlsdGluL3JlYmFzZS5jOjE0MzkgYnVpbHRpbi9yZWJhc2UuYzoxNDQxCiBtc2dpZCAicGFzc2VkIHRvICdnaXQgYW0nIgogbXNnc3RyICJhbiAnZ2l0IGFtJyDDvGJlcmdlYmVuIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0MTkgYnVpbHRpbi9yZWJhc2UuYzoxNDIxCisjOiBidWlsdGluL3JlYmFzZS5jOjE0NDMgYnVpbHRpbi9yZWJhc2UuYzoxNDQ1CiBtc2dpZCAicGFzc2VkIHRvICdnaXQgYXBwbHknIgogbXNnc3RyICJhbiAnZ2l0IGFwcGx5JyDDvGJlcmdlYmVuIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0MjMgYnVpbHRpbi9yZWJhc2UuYzoxNDI2CisjOiBidWlsdGluL3JlYmFzZS5jOjE0NDcgYnVpbHRpbi9yZWJhc2UuYzoxNDUwCiBtc2dpZCAiY2hlcnJ5LXBpY2sgYWxsIGNvbW1pdHMsIGV2ZW4gaWYgdW5jaGFuZ2VkIgogbXNnc3RyICIiCiAiQ2hlcnJ5LVBpY2sgYXVmIGFsbGUgQ29tbWl0cyBhdXNmw7xocmVuLCBhdWNoIHdlbm4gZGllc2UgdW52ZXLDpG5kZXJ0IHNpbmQiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQyOAorIzogYnVpbHRpbi9yZWJhc2UuYzoxNDUyCiBtc2dpZCAiY29udGludWUiCiBtc2dzdHIgImZvcnRzZXR6ZW4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQzMQorIzogYnVpbHRpbi9yZWJhc2UuYzoxNDU1CiBtc2dpZCAic2tpcCBjdXJyZW50IHBhdGNoIGFuZCBjb250aW51ZSIKIG1zZ3N0ciAiZGVuIGFrdHVlbGxlbiBQYXRjaCBhdXNsYXNzZW4gdW5kIGZvcnRmYWhyZW4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQzMworIzogYnVpbHRpbi9yZWJhc2UuYzoxNDU3CiBtc2dpZCAiYWJvcnQgYW5kIGNoZWNrIG91dCB0aGUgb3JpZ2luYWwgYnJhbmNoIgogbXNnc3RyICJhYmJyZWNoZW4gdW5kIGRlbiB1cnNwcsO8bmdsaWNoZW4gQnJhbmNoIGF1c2NoZWNrZW4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQzNgorIzogYnVpbHRpbi9yZWJhc2UuYzoxNDYwCiBtc2dpZCAiYWJvcnQgYnV0IGtlZXAgSEVBRCB3aGVyZSBpdCBpcyIKIG1zZ3N0ciAiYWJicmVjaGVuLCBhYmVyIEhFQUQgYW4gYWt0dWVsbGVyIFN0ZWxsZSBiZWxhc3NlbiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDM3CisjOiBidWlsdGluL3JlYmFzZS5jOjE0NjEKIG1zZ2lkICJlZGl0IHRoZSB0b2RvIGxpc3QgZHVyaW5nIGFuIGludGVyYWN0aXZlIHJlYmFzZSIKIG1zZ3N0ciAiVE9ETy1MaXN0ZSB3w6RocmVuZCBlaW5lcyBpbnRlcmFrdGl2ZW4gUmViYXNlIGJlYXJiZWl0ZW4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ0MAorIzogYnVpbHRpbi9yZWJhc2UuYzoxNDY0CiBtc2dpZCAic2hvdyB0aGUgcGF0Y2ggZmlsZSBiZWluZyBhcHBsaWVkIG9yIG1lcmdlZCIKIG1zZ3N0ciAiZGVuIFBhdGNoLCBkZXIgZ2VyYWRlIGFuZ2V3ZW5kZXQgb2RlciB6dXNhbW1lbmdlZsO8aHJ0IHdpcmQsIGFuemVpZ2VuIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0NDMKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ2NwogbXNnaWQgInVzZSBtZXJnaW5nIHN0cmF0ZWdpZXMgdG8gcmViYXNlIgogbXNnc3RyICJNZXJnZS1TdHJhdGVnaWVuIGJlaW0gUmViYXNlIHZlcndlbmRlbiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDQ3CisjOiBidWlsdGluL3JlYmFzZS5jOjE0NzEKIG1zZ2lkICJsZXQgdGhlIHVzZXIgZWRpdCB0aGUgbGlzdCBvZiBjb21taXRzIHRvIHJlYmFzZSIKIG1zZ3N0ciAiZGVuIEJlbnV0emVyIGRpZSBMaXN0ZSBkZXIgQ29tbWl0cyBmw7xyIGRlbiBSZWJhc2UgYmVhcmJlaXRlbiBsYXNzZW4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ1MQorIzogYnVpbHRpbi9yZWJhc2UuYzoxNDc1CiBtc2dpZCAiKERFUFJFQ0FURUQpIHRyeSB0byByZWNyZWF0ZSBtZXJnZXMgaW5zdGVhZCBvZiBpZ25vcmluZyB0aGVtIgogbXNnc3RyICIiCiAiKFZFUkFMVEVUKSBWZXJzdWNoZSwgTWVyZ2VzIHdpZWRlcmhlcnp1c3RlbGxlbiBhbnN0YXR0IHNpZSB6dSBpZ25vcmllcmVuIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0NTUKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ3OQogbXNnaWQgInByZXNlcnZlIGVtcHR5IGNvbW1pdHMgZHVyaW5nIHJlYmFzZSIKIG1zZ3N0ciAibGVlcmUgQ29tbWl0cyB3w6RocmVuZCBkZXMgUmViYXNlIGVyaGFsdGVuIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0NTcKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ4MQogbXNnaWQgIm1vdmUgY29tbWl0cyB0aGF0IGJlZ2luIHdpdGggc3F1YXNoIS9maXh1cCEgdW5kZXIgLWkiCiBtc2dzdHIgImJlaSAtaSBDb21taXRzIHZlcnNjaGllYmVuLCBkaWUgbWl0IHNxdWFzaCEvZml4dXAhIGJlZ2lubmVuIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0NjMKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ4NwogbXNnaWQgImF1dG9tYXRpY2FsbHkgc3Rhc2gvc3Rhc2ggcG9wIGJlZm9yZSBhbmQgYWZ0ZXIiCiBtc2dzdHIgImF1dG9tYXRpc2NoZXIgU3Rhc2gvU3Rhc2gtUG9wIGRhdm9yIHVuZCBkYW5hY2giCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ2NQorIzogYnVpbHRpbi9yZWJhc2UuYzoxNDg5CiBtc2dpZCAiYWRkIGV4ZWMgbGluZXMgYWZ0ZXIgZWFjaCBjb21taXQgb2YgdGhlIGVkaXRhYmxlIGxpc3QiCiBtc2dzdHIgImV4ZWMtWmVpbGVuIG5hY2ggamVkZW0gQ29tbWl0IGRlciBlZGl0aWVyYmFyZW4gTGlzdGUgaGluenVmw7xnZW4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ2OQorIzogYnVpbHRpbi9yZWJhc2UuYzoxNDkzCiBtc2dpZCAiYWxsb3cgcmViYXNpbmcgY29tbWl0cyB3aXRoIGVtcHR5IG1lc3NhZ2VzIgogbXNnc3RyICJSZWJhc2Ugdm9uIENvbW1pdHMgbWl0IGxlZXJlciBCZXNjaHJlaWJ1bmcgZXJsYXViZW4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ3MgorIzogYnVpbHRpbi9yZWJhc2UuYzoxNDk2CiBtc2dpZCAidHJ5IHRvIHJlYmFzZSBtZXJnZXMgaW5zdGVhZCBvZiBza2lwcGluZyB0aGVtIgogbXNnc3RyICIiCiAidmVyc3VjaGVuLCBSZWJhc2UgbWl0IE1lcmdlcyBhdXN6dWbDvGhyZW4sIGFuc3RhdHQgZGllc2UgenUgw7xiZXJzcHJpbmdlbiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDc1CisjOiBidWlsdGluL3JlYmFzZS5jOjE0OTkKIG1zZ2lkICJ1c2UgJ21lcmdlLWJhc2UgLS1mb3JrLXBvaW50JyB0byByZWZpbmUgdXBzdHJlYW0iCiBtc2dzdHIgIiIKICInZ2l0IG1lcmdlLWJhc2UgLS1mb3JrLXBvaW50JyBiZW51dHplbiwgdW0gVXBzdHJlYW0tQnJhbmNoIHp1IGJlc3RpbW1lbiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDc3CisjOiBidWlsdGluL3JlYmFzZS5jOjE1MDEKIG1zZ2lkICJ1c2UgdGhlIGdpdmVuIG1lcmdlIHN0cmF0ZWd5IgogbXNnc3RyICJhbmdlZ2ViZW5lIE1lcmdlLVN0cmF0ZWdpZSB2ZXJ3ZW5kZW4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ3OSBidWlsdGluL3JldmVydC5jOjExNQorIzogYnVpbHRpbi9yZWJhc2UuYzoxNTAzIGJ1aWx0aW4vcmV2ZXJ0LmM6MTE1CiBtc2dpZCAib3B0aW9uIgogbXNnc3RyICJPcHRpb24iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ4MAorIzogYnVpbHRpbi9yZWJhc2UuYzoxNTA0CiBtc2dpZCAicGFzcyB0aGUgYXJndW1lbnQgdGhyb3VnaCB0byB0aGUgbWVyZ2Ugc3RyYXRlZ3kiCiBtc2dzdHIgIkFyZ3VtZW50IHp1ciBNZXJnZS1TdHJhdGVnaWUgZHVyY2hyZWljaGVuIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0ODMKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTUwNwogbXNnaWQgInJlYmFzZSBhbGwgcmVhY2hhYmxlIGNvbW1pdHMgdXAgdG8gdGhlIHJvb3QocykiCiBtc2dzdHIgIlJlYmFzZSBhdWYgYWxsZSBlcnJlaWNoYmFyZW4gQ29tbWl0cyBiaXMgenVtIFJvb3QtQ29tbWl0IGF1c2bDvGhyZW4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTUwMAorIzogYnVpbHRpbi9yZWJhc2UuYzoxNTI0CiBtc2dpZCAiIgogInRoZSByZWJhc2UudXNlQnVpbHRpbiBzdXBwb3J0IGhhcyBiZWVuIHJlbW92ZWQhXG4iCiAiU2VlIGl0cyBlbnRyeSBpbiAnZ2l0IGhlbHAgY29uZmlnJyBmb3IgZGV0YWlscy4iCkBAIC0xNzgwOCwzMiArMTc4OTUsNDAgQEAKICJEaWUgVW50ZXJzdMO8dHp1bmcgZsO8ciByZWJhc2UudXNlQnVpbHRpbiB3dXJkZSBlbnRmZXJudCFcbiIKICJTaWVoZSBkZXNzZW4gRWludHJhZyBpbiAnZ2l0IGhlbHAgY29uZmlnJyBmw7xyIERldGFpbHMuIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE1MDYKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTUzMAogbXNnaWQgIkl0IGxvb2tzIGxpa2UgJ2dpdCBhbScgaXMgaW4gcHJvZ3Jlc3MuIENhbm5vdCByZWJhc2UuIgogbXNnc3RyICInZ2l0LWFtJyBzY2hlaW50IGltIEdhbmdlIHp1IHNlaW4uIEthbm4gUmViYXNlIG5pY2h0IGR1cmNoZsO8aHJlbi4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTU0NworIzogYnVpbHRpbi9yZWJhc2UuYzoxNTcxCiBtc2dpZCAiIgogImdpdCByZWJhc2UgLS1wcmVzZXJ2ZS1tZXJnZXMgaXMgZGVwcmVjYXRlZC4gVXNlIC0tcmViYXNlLW1lcmdlcyBpbnN0ZWFkLiIKIG1zZ3N0ciAiIgogIidnaXQgcmViYXNlIC0tcHJlc2VydmUtbWVyZ2VzJyBpc3QgdmVyYWx0ZXQuIEJlbnV0emVuIFNpZSBzdGF0dGRlc3NlbiAnLS0iCiAicmViYXNlLW1lcmdlcycuIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE1NTEKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTU3NgorbXNnaWQgImNhbm5vdCBjb21iaW5lICctLWtlZXAtYmFzZScgd2l0aCAnLS1vbnRvJyIKK21zZ3N0ciAiJy0ta2VlcC1iYXNlJyBrYW5uIG5pY2h0IG1pdCAnLS1vbnRvJyBrb21iaW5pZXJ0IHdlcmRlbiIKKworIzogYnVpbHRpbi9yZWJhc2UuYzoxNTc4Cittc2dpZCAiY2Fubm90IGNvbWJpbmUgJy0ta2VlcC1iYXNlJyB3aXRoICctLXJvb3QnIgorbXNnc3RyICInLS1rZWVwLWJhc2UnIGthbm4gbmljaHQgbWl0ICctLXJvb3QnIGtvbWJpbmllcnQgd2VyZGVuIgorCisjOiBidWlsdGluL3JlYmFzZS5jOjE1ODIKIG1zZ2lkICJObyByZWJhc2UgaW4gcHJvZ3Jlc3M/IgogbXNnc3RyICJLZWluIFJlYmFzZSBpbSBHYW5nZT8iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTU1NQorIzogYnVpbHRpbi9yZWJhc2UuYzoxNTg2CiBtc2dpZCAiVGhlIC0tZWRpdC10b2RvIGFjdGlvbiBjYW4gb25seSBiZSB1c2VkIGR1cmluZyBpbnRlcmFjdGl2ZSByZWJhc2UuIgogbXNnc3RyICIiCiAiRGllIC0tZWRpdC10b2RvIEFrdGlvbiBrYW5uIG51ciB3w6RocmVuZCBlaW5lcyBpbnRlcmFrdGl2ZW4gUmViYXNlIHZlcndlbmRldCAiCiAid2VyZGVuLiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNTc4CisjOiBidWlsdGluL3JlYmFzZS5jOjE2MDkKIG1zZ2lkICJDYW5ub3QgcmVhZCBIRUFEIgogbXNnc3RyICJLYW5uIEhFQUQgbmljaHQgbGVzZW4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTU5MAorIzogYnVpbHRpbi9yZWJhc2UuYzoxNjIxCiBtc2dpZCAiIgogIllvdSBtdXN0IGVkaXQgYWxsIG1lcmdlIGNvbmZsaWN0cyBhbmQgdGhlblxuIgogIm1hcmsgdGhlbSBhcyByZXNvbHZlZCB1c2luZyBnaXQgYWRkIgpAQCAtMTc4NDEsMTYgKzE3OTM2LDE2IEBACiAiU2llIG3DvHNzZW4gYWxsZSBNZXJnZS1Lb25mbGlrdGUgZWRpdGllcmVuIHVuZCBkaWVzZSBkYW5uXG4iCiAibWl0dGVscyBcImdpdCBhZGRcIiBhbHMgYXVmZ2Vsw7ZzdCBtYXJraWVyZW4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTYwOQorIzogYnVpbHRpbi9yZWJhc2UuYzoxNjQwCiBtc2dpZCAiY291bGQgbm90IGRpc2NhcmQgd29ya3RyZWUgY2hhbmdlcyIKIG1zZ3N0ciAiS29ubnRlIMOEbmRlcnVuZ2VuIGltIEFyYmVpdHN2ZXJ6ZWljaG5pcyBuaWNodCB2ZXJ3ZXJmZW4uIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE2MjgKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTY1OQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgbW92ZSBiYWNrIHRvICVzIgogbXNnc3RyICJLb25udGUgbmljaHQgenUgJXMgenVyw7xja2dlaGVuLiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNjczCisjOiBidWlsdGluL3JlYmFzZS5jOjE3MDQKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkl0IHNlZW1zIHRoYXQgdGhlcmUgaXMgYWxyZWFkeSBhICVzIGRpcmVjdG9yeSwgYW5kXG4iCkBAIC0xNzg3MSwxNzAgKzE3OTY2LDE2MSBAQAogInVuZCBmw7xocmVuIFNpZSBkaWVzZW4gQmVmZWhsIG5vY2htYWwgYXVzLiBFcyB3aXJkIGFuZ2VoYWx0ZW4sIGZhbGxzIG5vY2hcbiIKICJldHdhcyBTY2jDvHR6ZW5zd2VydGVzIHZvcmhhbmRlbiBpc3QuXG4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTY5NAorIzogYnVpbHRpbi9yZWJhc2UuYzoxNzI1CiBtc2dpZCAic3dpdGNoIGBDJyBleHBlY3RzIGEgbnVtZXJpY2FsIHZhbHVlIgogbXNnc3RyICJTY2hhbHRlciBgQycgZXJ3YXJ0ZXQgZWluZW4gbnVtZXJpc2NoZW4gV2VydC4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTczNQorIzogYnVpbHRpbi9yZWJhc2UuYzoxNzY2CiAjLCBjLWZvcm1hdAogbXNnaWQgIlVua25vd24gbW9kZTogJXMiCiBtc2dzdHIgIlVuYmVrYW5udGVyIE1vZHVzOiAlcyIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNzU3CisjOiBidWlsdGluL3JlYmFzZS5jOjE3ODgKIG1zZ2lkICItLXN0cmF0ZWd5IHJlcXVpcmVzIC0tbWVyZ2Ugb3IgLS1pbnRlcmFjdGl2ZSIKIG1zZ3N0ciAiLS1zdHJhdGVneSBlcmZvcmRlcnQgLS1tZXJnZSBvZGVyIC0taW50ZXJhY3RpdmUiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTc5NworIzogYnVpbHRpbi9yZWJhc2UuYzoxODI4CiBtc2dpZCAiLS1yZXNjaGVkdWxlLWZhaWxlZC1leGVjIHJlcXVpcmVzIC0tZXhlYyBvciAtLWludGVyYWN0aXZlIgogbXNnc3RyICItLXJlc2NoZWR1bGUtZmFpbGVkLWV4ZWMgZXJmb3JkZXJ0IC0tZXhlYyBvZGVyIC0taW50ZXJhY3RpdmUiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTgwOQorIzogYnVpbHRpbi9yZWJhc2UuYzoxODQwCiBtc2dpZCAiY2Fubm90IGNvbWJpbmUgYW0gb3B0aW9ucyB3aXRoIGVpdGhlciBpbnRlcmFjdGl2ZSBvciBtZXJnZSBvcHRpb25zIgogbXNnc3RyICIiCiAiT3B0aW9uZW4gZsO8ciBcImFtXCIga8O2bm5lbiBuaWNodCBtaXQgT3B0aW9uZW4gZsO8ciBcImludGVyYWN0aXZlXCIgb2RlciAiCiAiXCJtZXJnZVwiIGtvbWJpbmllcnQgd2VyZGVuLiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxODI4CisjOiBidWlsdGluL3JlYmFzZS5jOjE4NTkKIG1zZ2lkICJjYW5ub3QgY29tYmluZSAnLS1wcmVzZXJ2ZS1tZXJnZXMnIHdpdGggJy0tcmViYXNlLW1lcmdlcyciCiBtc2dzdHIgIiIKICInLS1wcmVzZXJ2ZS1tZXJnZXMnIGthbm4gbmljaHQgbWl0ICctLXJlYmFzZS1tZXJnZXMnIGtvbWJpbmllcnQgd2VyZGVuLiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxODMyCisjOiBidWlsdGluL3JlYmFzZS5jOjE4NjMKIG1zZ2lkICIiCiAiZXJyb3I6IGNhbm5vdCBjb21iaW5lICctLXByZXNlcnZlLW1lcmdlcycgd2l0aCAnLS1yZXNjaGVkdWxlLWZhaWxlZC1leGVjJyIKIG1zZ3N0ciAiIgogIkZlaGxlcjogJy0tcHJlc2VydmUtbWVyZ2VzJyBrYW5uIG5pY2h0IG1pdCAnLS1yZXNjaGVkdWxlLWZhaWxlZC1leGVjJyAiCiAia29tYmluaWVydCB3ZXJkZW4uIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE4MzgKLW1zZ2lkICJjYW5ub3QgY29tYmluZSAnLS1yZWJhc2UtbWVyZ2VzJyB3aXRoICctLXN0cmF0ZWd5LW9wdGlvbiciCi1tc2dzdHIgIiIKLSInLS1yZWJhc2UtbWVyZ2VzJyBrYW5uIG5pY2h0IG1pdCAnLS1zdHJhdGVneS1vcHRpb24nIGtvbWJpbmllcnQgd2VyZGVuLiIKLQotIzogYnVpbHRpbi9yZWJhc2UuYzoxODQxCi1tc2dpZCAiY2Fubm90IGNvbWJpbmUgJy0tcmViYXNlLW1lcmdlcycgd2l0aCAnLS1zdHJhdGVneSciCi1tc2dzdHIgIictLXJlYmFzZS1tZXJnZXMnIGthbm4gbmljaHQgbWl0ICctLXN0cmF0ZWd5JyBrb21iaW5pZXJ0IHdlcmRlbi4iCi0KLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTg2NQorIzogYnVpbHRpbi9yZWJhc2UuYzoxODg3CiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgdXBzdHJlYW0gJyVzJyIKIG1zZ3N0ciAiVW5nw7xsdGlnZXIgVXBzdHJlYW0gJyVzJyIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxODcxCisjOiBidWlsdGluL3JlYmFzZS5jOjE4OTMKIG1zZ2lkICJDb3VsZCBub3QgY3JlYXRlIG5ldyByb290IGNvbW1pdCIKIG1zZ3N0ciAiS29ubnRlIG5ldWVuIFJvb3QtQ29tbWl0IG5pY2h0IGVyc3RlbGxlbi4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTg4OQorIzogYnVpbHRpbi9yZWJhc2UuYzoxOTE5CisjLCBjLWZvcm1hdAorbXNnaWQgIiclcyc6IG5lZWQgZXhhY3RseSBvbmUgbWVyZ2UgYmFzZSB3aXRoIGJyYW5jaCIKK21zZ3N0ciAiJyVzJzogYmVuw7Z0aWdlIGdlbmF1IGVpbmUgTWVyZ2UtQmFzaXMgbWl0IGRlbSBCcmFuY2giCisKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTkyMgogIywgYy1mb3JtYXQKIG1zZ2lkICInJXMnOiBuZWVkIGV4YWN0bHkgb25lIG1lcmdlIGJhc2UiCiBtc2dzdHIgIiclcyc6IGJlbsO2dGlnZSBnZW5hdSBlaW5lIE1lcmdlLUJhc2lzIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE4OTYKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTkzMAogIywgYy1mb3JtYXQKIG1zZ2lkICJEb2VzIG5vdCBwb2ludCB0byBhIHZhbGlkIGNvbW1pdCAnJXMnIgogbXNnc3RyICInJXMnIHplaWd0IGF1ZiBrZWluZW4gZ8O8bHRpZ2VuIENvbW1pdC4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTkyMQorIzogYnVpbHRpbi9yZWJhc2UuYzoxOTU1CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhdGFsOiBubyBzdWNoIGJyYW5jaC9jb21taXQgJyVzJyIKIG1zZ3N0ciAiZmF0YWw6IEJyYW5jaC9Db21taXQgJyVzJyBuaWNodCBnZWZ1bmRlbiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxOTI5IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzozOAorIzogYnVpbHRpbi9yZWJhc2UuYzoxOTYzIGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzozOAogIzogYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjE5MzQKICMsIGMtZm9ybWF0CiBtc2dpZCAiTm8gc3VjaCByZWY6ICVzIgogbXNnc3RyICJSZWZlcmVueiBuaWNodCBnZWZ1bmRlbjogJXMiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTk0MAorIzogYnVpbHRpbi9yZWJhc2UuYzoxOTc0CiBtc2dpZCAiQ291bGQgbm90IHJlc29sdmUgSEVBRCB0byBhIHJldmlzaW9uIgogbXNnc3RyICJLb25udGUgSEVBRCB6dSBrZWluZW0gQ29tbWl0IGF1ZmzDtnNlbi4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTk4MQorIzogYnVpbHRpbi9yZWJhc2UuYzoyMDEyCiBtc2dpZCAiQ2Fubm90IGF1dG9zdGFzaCIKIG1zZ3N0ciAiS2FubiBhdXRvbWF0aXNjaGVuIFN0YXNoIG5pY2h0IGVyemV1Z2VuLiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxOTg0CisjOiBidWlsdGluL3JlYmFzZS5jOjIwMTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiVW5leHBlY3RlZCBzdGFzaCByZXNwb25zZTogJyVzJyIKIG1zZ3N0ciAiVW5lcndhcnRldGUgJ3N0YXNoJy1BbnR3b3J0OiAnJXMnIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE5OTAKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MjAyMQogIywgYy1mb3JtYXQKIG1zZ2lkICJDb3VsZCBub3QgY3JlYXRlIGRpcmVjdG9yeSBmb3IgJyVzJyIKIG1zZ3N0ciAiS29ubnRlIFZlcnplaWNobmlzIGbDvHIgJyVzJyBuaWNodCBlcnN0ZWxsZW4uIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE5OTMKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MjAyNAogIywgYy1mb3JtYXQKIG1zZ2lkICJDcmVhdGVkIGF1dG9zdGFzaDogJXNcbiIKIG1zZ3N0ciAiQXV0b21hdGlzY2hlbiBTdGFzaCBlcnpldWd0OiAlc1xuIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE5OTYKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MjAyNwogbXNnaWQgImNvdWxkIG5vdCByZXNldCAtLWhhcmQiCiBtc2dzdHIgIktvbm50ZSAncmVzZXQgLS1oYXJkJyBuaWNodCBhdXNmw7xocmVuLiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxOTk3IGJ1aWx0aW4vcmVzZXQuYzoxMTQKLSMsIGMtZm9ybWF0Ci1tc2dpZCAiSEVBRCBpcyBub3cgYXQgJXMiCi1tc2dzdHIgIkhFQUQgaXN0IGpldHp0IGJlaSAlcyIKLQotIzogYnVpbHRpbi9yZWJhc2UuYzoyMDEzCisjOiBidWlsdGluL3JlYmFzZS5jOjIwMzYKIG1zZ2lkICJQbGVhc2UgY29tbWl0IG9yIHN0YXNoIHRoZW0uIgogbXNnc3RyICJCaXR0ZSBjb21taXR0ZW4gU2llIGRpZSDDhG5kZXJ1bmdlbiBvZGVyIGJlbnV0emVuIFNpZSBcInN0YXNoXCIuIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjIwNDAKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MjA2MwogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcGFyc2UgJyVzJyIKIG1zZ3N0ciAiS29ubnRlICclcycgbmljaHQgcGFyc2VuLiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoyMDUzCisjOiBidWlsdGluL3JlYmFzZS5jOjIwNzYKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHN3aXRjaCB0byAlcyIKIG1zZ3N0ciAiS29ubnRlIG5pY2h0IHp1ICVzIHdlY2hzZWxuLiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoyMDY0CisjOiBidWlsdGluL3JlYmFzZS5jOjIwODcKIG1zZ2lkICJIRUFEIGlzIHVwIHRvIGRhdGUuIgogbXNnc3RyICJIRUFEIGlzdCBha3R1ZWxsLiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoyMDY2CisjOiBidWlsdGluL3JlYmFzZS5jOjIwODkKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ3VycmVudCBicmFuY2ggJXMgaXMgdXAgdG8gZGF0ZS5cbiIKIG1zZ3N0ciAiQWt0dWVsbGVyIEJyYW5jaCAlcyBpc3QgYXVmIGRlbSBuZXVlc3RlbiBTdGFuZC5cbiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoyMDc0CisjOiBidWlsdGluL3JlYmFzZS5jOjIwOTcKIG1zZ2lkICJIRUFEIGlzIHVwIHRvIGRhdGUsIHJlYmFzZSBmb3JjZWQuIgogbXNnc3RyICJIRUFEIGlzdCBha3R1ZWxsLCBSZWJhc2UgZXJ6d3VuZ2VuLiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoyMDc2CisjOiBidWlsdGluL3JlYmFzZS5jOjIwOTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ3VycmVudCBicmFuY2ggJXMgaXMgdXAgdG8gZGF0ZSwgcmViYXNlIGZvcmNlZC5cbiIKIG1zZ3N0ciAiQWt0dWVsbGVyIEJyYW5jaCAlcyBpc3QgYXVmIGRlbSBuZXVlc3RlbiBTdGFuZCwgUmViYXNlIGVyend1bmdlbi5cbiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoyMDg0CisjOiBidWlsdGluL3JlYmFzZS5jOjIxMDcKIG1zZ2lkICJUaGUgcHJlLXJlYmFzZSBob29rIHJlZnVzZWQgdG8gcmViYXNlLiIKIG1zZ3N0ciAiRGVyIFwicHJlLXJlYmFzZSBob29rXCIgaGF0IGRlbiBSZWJhc2UgenVyw7xja2dld2llc2VuLiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoyMDkxCisjOiBidWlsdGluL3JlYmFzZS5jOjIxMTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ2hhbmdlcyB0byAlczpcbiIKIG1zZ3N0ciAiw4RuZGVydW5nZW4genUgJXM6XG4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MjA5NAorIzogYnVpbHRpbi9yZWJhc2UuYzoyMTE3CiAjLCBjLWZvcm1hdAogbXNnaWQgIkNoYW5nZXMgZnJvbSAlcyB0byAlczpcbiIKIG1zZ3N0ciAiw4RuZGVydW5nZW4gdm9uICVzIHp1ICVzOlxuIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjIxMTkKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MjE0MgogIywgYy1mb3JtYXQKIG1zZ2lkICJGaXJzdCwgcmV3aW5kaW5nIGhlYWQgdG8gcmVwbGF5IHlvdXIgd29yayBvbiB0b3Agb2YgaXQuLi5cbiIKIG1zZ3N0ciAiIgogIlp1bsOkY2hzdCB3aXJkIGRlciBCcmFuY2ggenVyw7xja2dlc3B1bHQsIHVtIElocmUgw4RuZGVydW5nZW4gZGFyYXVmIG5ldSAiCiAiYW56dXdlbmRlbi4uLlxuIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjIxMjgKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MjE1MQogbXNnaWQgIkNvdWxkIG5vdCBkZXRhY2ggSEVBRCIKIG1zZ3N0ciAiS29ubnRlIEhFQUQgbmljaHQgbG9zbMO2c2VuLiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoyMTM3CisjOiBidWlsdGluL3JlYmFzZS5jOjIxNjAKICMsIGMtZm9ybWF0CiBtc2dpZCAiRmFzdC1mb3J3YXJkZWQgJXMgdG8gJXMuXG4iCiBtc2dzdHIgIlNwdWxlICVzIHZvciB6dSAlcy5cbiIKQEAgLTE4MDQzLDcgKzE4MTI5LDcgQEAKIG1zZ2lkICJnaXQgcmVjZWl2ZS1wYWNrIDxnaXQtZGlyPiIKIG1zZ3N0ciAiZ2l0IHJlY2VpdmUtcGFjayA8R2l0LVZlcnplaWNobmlzPiIKIAotIzogYnVpbHRpbi9yZWNlaXZlLXBhY2suYzo4MzIKKyM6IGJ1aWx0aW4vcmVjZWl2ZS1wYWNrLmM6ODMwCiBtc2dpZCAiIgogIkJ5IGRlZmF1bHQsIHVwZGF0aW5nIHRoZSBjdXJyZW50IGJyYW5jaCBpbiBhIG5vbi1iYXJlIHJlcG9zaXRvcnlcbiIKICJpcyBkZW5pZWQsIGJlY2F1c2UgaXQgd2lsbCBtYWtlIHRoZSBpbmRleCBhbmQgd29yayB0cmVlIGluY29uc2lzdGVudFxuIgpAQCAtMTgwNzUsNyArMTgxNjEsNyBAQAogInNldHplbiBTaWUgZGllIEtvbmZpZ3VyYXRpb25zdmFyaWFibGUgJ3JlY2VpdmUuZGVueUN1cnJlbnRCcmFuY2gnIGF1ZlxuIgogIidyZWZ1c2UnLiIKIAotIzogYnVpbHRpbi9yZWNlaXZlLXBhY2suYzo4NTIKKyM6IGJ1aWx0aW4vcmVjZWl2ZS1wYWNrLmM6ODUwCiBtc2dpZCAiIgogIkJ5IGRlZmF1bHQsIGRlbGV0aW5nIHRoZSBjdXJyZW50IGJyYW5jaCBpcyBkZW5pZWQsIGJlY2F1c2UgdGhlIG5leHRcbiIKICInZ2l0IGNsb25lJyB3b24ndCByZXN1bHQgaW4gYW55IGZpbGUgY2hlY2tlZCBvdXQsIGNhdXNpbmcgY29uZnVzaW9uLlxuIgpAQCAtMTgwOTYsMTEgKzE4MTgyLDExIEBACiAiXG4iCiAiVW0gZGllc2UgTWVsZHVuZyB6dSB1bnRlcmRyw7xja2VuLCBzZXR6ZW4gU2llIGRpZSBWYXJpYWJsZSBhdWYgJ3JlZnVzZScuIgogCi0jOiBidWlsdGluL3JlY2VpdmUtcGFjay5jOjE5MzgKKyM6IGJ1aWx0aW4vcmVjZWl2ZS1wYWNrLmM6MTkzNgogbXNnaWQgInF1aWV0IgogbXNnc3RyICJ3ZW5pZ2VyIEF1c2dhYmVuIgogCi0jOiBidWlsdGluL3JlY2VpdmUtcGFjay5jOjE5NTIKKyM6IGJ1aWx0aW4vcmVjZWl2ZS1wYWNrLmM6MTk1MAogbXNnaWQgIllvdSBtdXN0IHNwZWNpZnkgYSBkaXJlY3RvcnkuIgogbXNnc3RyICJTaWUgbcO8c3NlbiBlaW4gUmVwb3NpdG9yeSBhbmdlYmVuLiIKIApAQCAtMTg2ODMsMTEgKzE4NzY5LDExIEBACiBtc2dpZCAiVW5rbm93biBzdWJjb21tYW5kOiAlcyIKIG1zZ3N0ciAiVW5iZWthbm50ZXIgVW50ZXJiZWZlaGw6ICVzIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjIyCisjOiBidWlsdGluL3JlcGFjay5jOjIzCiBtc2dpZCAiZ2l0IHJlcGFjayBbPG9wdGlvbnM+XSIKIG1zZ3N0ciAiZ2l0IHJlcGFjayBbPE9wdGlvbmVuPl0iCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MjcKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6MjgKIG1zZ2lkICIiCiAiSW5jcmVtZW50YWwgcmVwYWNrcyBhcmUgaW5jb21wYXRpYmxlIHdpdGggYml0bWFwIGluZGV4ZXMuICBVc2VcbiIKICItLW5vLXdyaXRlLWJpdG1hcC1pbmRleCBvciBkaXNhYmxlIHRoZSBwYWNrLndyaXRlYml0bWFwcyBjb25maWd1cmF0aW9uLiIKQEAgLTE4Njk2LDExOSArMTg3ODIsMTE5IEBACiAiLS1uby13cml0ZS1iaXRtYXAtaW5kZXggb2RlciBkZWFrdGl2aWVyZW4gU2llIGRpZSBwYWNrLndyaXRlYml0bWFwc1xuIgogIktvbmZpZ3VyYXRpb24uIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjE5MAorIzogYnVpbHRpbi9yZXBhY2suYzoxOTEKIG1zZ2lkICJjb3VsZCBub3Qgc3RhcnQgcGFjay1vYmplY3RzIHRvIHJlcGFjayBwcm9taXNvciBvYmplY3RzIgogbXNnc3RyICIiCiAiS29ubnRlICdwYWNrLW9iamVjdHMnIGbDvHIgZGFzIE5ldXBhY2tlbiB2b24gT2JqZWt0ZW4gYXVzIHBhcnRpZWxsIGdla2xvbnRlblxuIgogIlJlbW90ZS1SZXBvc2l0b3JpZXMgbmljaHQgc3RhcnRlbi4iCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MjI5IGJ1aWx0aW4vcmVwYWNrLmM6NDA4CisjOiBidWlsdGluL3JlcGFjay5jOjIzMCBidWlsdGluL3JlcGFjay5jOjQwOQogbXNnaWQgInJlcGFjazogRXhwZWN0aW5nIGZ1bGwgaGV4IG9iamVjdCBJRCBsaW5lcyBvbmx5IGZyb20gcGFjay1vYmplY3RzLiIKIG1zZ3N0ciAiIgogInJlcGFjazogRXJ3YXJ0ZSBaZWlsZW4gbWl0IHZvbGxzdMOkbmRpZ2VyIEhleC1PYmpla3QtSUQgbnVyIHZvbiBwYWNrLW9iamVjdHMuIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjI0NgorIzogYnVpbHRpbi9yZXBhY2suYzoyNDcKIG1zZ2lkICJjb3VsZCBub3QgZmluaXNoIHBhY2stb2JqZWN0cyB0byByZXBhY2sgcHJvbWlzb3Igb2JqZWN0cyIKIG1zZ3N0ciAiIgogIktvbm50ZSAncGFjay1vYmplY3RzJyBmw7xyIGRhcyBOZXVwYWNrZW4gdm9uIE9iamVrdGVuIGF1cyBwYXJ0aWVsbCBnZWtsb250ZW5cbiIKICJSZW1vdGUtUmVwb3NpdG9yaWVzIG5pY2h0IGFic2NobGllw59lbi4iCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6Mjg0CisjOiBidWlsdGluL3JlcGFjay5jOjI4NQogbXNnaWQgInBhY2sgZXZlcnl0aGluZyBpbiBhIHNpbmdsZSBwYWNrIgogbXNnc3RyICJhbGxlcyBpbiBlaW5lIGVpbnppZ2UgUGFjay1EYXRlaSBwYWNrZW4iCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6Mjg2CisjOiBidWlsdGluL3JlcGFjay5jOjI4NwogbXNnaWQgInNhbWUgYXMgLWEsIGFuZCB0dXJuIHVucmVhY2hhYmxlIG9iamVjdHMgbG9vc2UiCiBtc2dzdHIgImdlbmF1IHdpZSAtYSwgdW5lcnJlaWNoYmFyZSBPYmpla3RlIHdlcmRlbiBhYmVyIG5pY2h0IGdlbMO2c2NodCIKIAotIzogYnVpbHRpbi9yZXBhY2suYzoyODkKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6MjkwCiBtc2dpZCAicmVtb3ZlIHJlZHVuZGFudCBwYWNrcywgYW5kIHJ1biBnaXQtcHJ1bmUtcGFja2VkIgogbXNnc3RyICJyZWR1bmRhbnRlIFBha2V0ZSBlbnRmZXJuZW4gdW5kIFwiZ2l0LXBydW5lLXBhY2tlZFwiIGF1c2bDvGhyZW4iCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MjkxCisjOiBidWlsdGluL3JlcGFjay5jOjI5MgogbXNnaWQgInBhc3MgLS1uby1yZXVzZS1kZWx0YSB0byBnaXQtcGFjay1vYmplY3RzIgogbXNnc3RyICItLW5vLXJldXNlLWRlbHRhIGFuIGdpdC1wYWNrLW9iamVjdHMgw7xiZXJnZWJlbiIKIAotIzogYnVpbHRpbi9yZXBhY2suYzoyOTMKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6Mjk0CiBtc2dpZCAicGFzcyAtLW5vLXJldXNlLW9iamVjdCB0byBnaXQtcGFjay1vYmplY3RzIgogbXNnc3RyICItLW5vLXJldXNlLW9iamVjdCBhbiBnaXQtcGFjay1vYmplY3RzIMO8YmVyZ2ViZW4iCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6Mjk1CisjOiBidWlsdGluL3JlcGFjay5jOjI5NgogbXNnaWQgImRvIG5vdCBydW4gZ2l0LXVwZGF0ZS1zZXJ2ZXItaW5mbyIKIG1zZ3N0ciAiZ2l0LXVwZGF0ZS1zZXJ2ZXItaW5mbyBuaWNodCBhdXNmw7xocmVuIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjI5OAorIzogYnVpbHRpbi9yZXBhY2suYzoyOTkKIG1zZ2lkICJwYXNzIC0tbG9jYWwgdG8gZ2l0LXBhY2stb2JqZWN0cyIKIG1zZ3N0ciAiLS1sb2NhbCBhbiBnaXQtcGFjay1vYmplY3RzIMO8YmVyZ2ViZW4iCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MzAwCisjOiBidWlsdGluL3JlcGFjay5jOjMwMQogbXNnaWQgIndyaXRlIGJpdG1hcCBpbmRleCIKIG1zZ3N0ciAiQml0bWFwLUluZGV4IHNjaHJlaWJlbiIKIAotIzogYnVpbHRpbi9yZXBhY2suYzozMDIKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6MzAzCiBtc2dpZCAicGFzcyAtLWRlbHRhLWlzbGFuZHMgdG8gZ2l0LXBhY2stb2JqZWN0cyIKIG1zZ3N0ciAiLS1kZWx0YS1pc2xhbmRzIGFuIGdpdC1wYWNrLW9iamVjdHMgw7xiZXJnZWJlbiIKIAotIzogYnVpbHRpbi9yZXBhY2suYzozMDMKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6MzA0CiBtc2dpZCAiYXBwcm94aWRhdGUiCiBtc2dzdHIgIkRhdHVtc2FuZ2FiZSIKIAotIzogYnVpbHRpbi9yZXBhY2suYzozMDQKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6MzA1CiBtc2dpZCAid2l0aCAtQSwgZG8gbm90IGxvb3NlbiBvYmplY3RzIG9sZGVyIHRoYW4gdGhpcyIKIG1zZ3N0ciAibWl0IC1BLCBrZWluZSBPYmpla3RlIMOkbHRlciBhbHMgZGllc2VzIERhdHVtIGzDtnNjaGVuIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjMwNgorIzogYnVpbHRpbi9yZXBhY2suYzozMDcKIG1zZ2lkICJ3aXRoIC1hLCByZXBhY2sgdW5yZWFjaGFibGUgb2JqZWN0cyIKIG1zZ3N0ciAibWl0IC1hLCBuaWNodCBlcnJlaWNoYmFyZSBPYmpla3RlIG5ldSBwYWNrZW4iCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MzA4CisjOiBidWlsdGluL3JlcGFjay5jOjMwOQogbXNnaWQgInNpemUgb2YgdGhlIHdpbmRvdyB1c2VkIGZvciBkZWx0YSBjb21wcmVzc2lvbiIKIG1zZ3N0ciAiR3LDtsOfZSBkZXMgRmVuc3RlcnMgZsO8ciBkaWUgRGVsdGEtS29tcHJlc3Npb24iCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MzA5IGJ1aWx0aW4vcmVwYWNrLmM6MzE1CisjOiBidWlsdGluL3JlcGFjay5jOjMxMCBidWlsdGluL3JlcGFjay5jOjMxNgogbXNnaWQgImJ5dGVzIgogbXNnc3RyICJCeXRlcyIKIAotIzogYnVpbHRpbi9yZXBhY2suYzozMTAKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6MzExCiBtc2dpZCAic2FtZSBhcyB0aGUgYWJvdmUsIGJ1dCBsaW1pdCBtZW1vcnkgc2l6ZSBpbnN0ZWFkIG9mIGVudHJpZXMgY291bnQiCiBtc2dzdHIgIiIKICJnbGVpY2hlcyB3aWUgb2JlbiwgYWJlciBkaWUgU3BlaWNoZXJncsO2w59lIGFuc3RhdHQgZGVyXG4iCiAiQW56YWhsIGRlciBFaW50csOkZ2UgbGltaXRpZXJlbiIKIAotIzogYnVpbHRpbi9yZXBhY2suYzozMTIKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6MzEzCiBtc2dpZCAibGltaXRzIHRoZSBtYXhpbXVtIGRlbHRhIGRlcHRoIgogbXNnc3RyICJkaWUgbWF4aW1hbGUgRGVsdGEtVGllZmUgbGltaXRpZXJlbiIKIAotIzogYnVpbHRpbi9yZXBhY2suYzozMTQKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6MzE1CiBtc2dpZCAibGltaXRzIHRoZSBtYXhpbXVtIG51bWJlciBvZiB0aHJlYWRzIgogbXNnc3RyICJtYXhpbWFsZSBBbnphaGwgdm9uIFRocmVhZHMgbGltaXRpZXJlbiIKIAotIzogYnVpbHRpbi9yZXBhY2suYzozMTYKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6MzE3CiBtc2dpZCAibWF4aW11bSBzaXplIG9mIGVhY2ggcGFja2ZpbGUiCiBtc2dzdHIgIm1heGltYWxlIEdyw7bDn2UgZsO8ciBqZWRlIFBha2V0ZGF0ZWkiCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MzE4CisjOiBidWlsdGluL3JlcGFjay5jOjMxOQogbXNnaWQgInJlcGFjayBvYmplY3RzIGluIHBhY2tzIG1hcmtlZCB3aXRoIC5rZWVwIgogbXNnc3RyICIiCiAiT2JqZWt0ZSB1bXBhY2tlbiwgZGllIHNpY2ggaW4gbWl0IC5rZWVwIG1hcmtpZXJ0ZW4gUGFjay1EYXRlaWVuIGJlZmluZGVuIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjMyMAorIzogYnVpbHRpbi9yZXBhY2suYzozMjEKIG1zZ2lkICJkbyBub3QgcmVwYWNrIHRoaXMgcGFjayIKIG1zZ3N0ciAiZGllc2VzIFBha2V0IG5pY2h0IG5ldSBwYWNrZW4iCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MzMwCisjOiBidWlsdGluL3JlcGFjay5jOjMzMQogbXNnaWQgImNhbm5vdCBkZWxldGUgcGFja3MgaW4gYSBwcmVjaW91cy1vYmplY3RzIHJlcG8iCiBtc2dzdHIgImthbm4gUGFjay1EYXRlaWVuIGluIHByZWNpb3VzLW9iamVjdHMgUmVwb3NpdG9yeSBuaWNodCBsw7ZzY2hlbiIKIAotIzogYnVpbHRpbi9yZXBhY2suYzozMzQKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6MzM1CiBtc2dpZCAiLS1rZWVwLXVucmVhY2hhYmxlIGFuZCAtQSBhcmUgaW5jb21wYXRpYmxlIgogbXNnc3RyICItLWtlZXAtdW5yZWFjaGFibGUgdW5kIC1BIHNpbmQgaW5rb21wYXRpYmVsIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjQxNworIzogYnVpbHRpbi9yZXBhY2suYzo0MTgKIG1zZ2lkICJOb3RoaW5nIG5ldyB0byBwYWNrLiIKIG1zZ3N0ciAiTmljaHRzIE5ldWVzIHp1bSBQYWNrZW4uIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjQ3OAorIzogYnVpbHRpbi9yZXBhY2suYzo0NzkKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIldBUk5JTkc6IFNvbWUgcGFja3MgaW4gdXNlIGhhdmUgYmVlbiByZW5hbWVkIGJ5XG4iCkBAIC0xODgyNyw3ICsxODkxMyw3IEBACiAiV0FSTlVORzogZWJlbmZhbGxzIGZlaGwuXG4iCiAiV0FSTlVORzogQml0dGUgYmVuZW5uZW4gU2llIGRpZXNlIG1hbnVlbGwgbmFjaCAlcyB1bTpcbiIKIAotIzogYnVpbHRpbi9yZXBhY2suYzo1MjYKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6NTI3CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byByZW1vdmUgJyVzJyIKIG1zZ3N0ciAiRmVobGVyIGJlaW0gTMO2c2NoZW4gdm9uICclcyciCkBAIC0xODkzNiw4ICsxOTAyMiw4IEBACiBtc2dpZCAidW5hYmxlIHRvIHdyaXRlIG9iamVjdCB0byBkYXRhYmFzZSIKIG1zZ3N0ciAiS29ubnRlIE9iamVrdCBuaWNodCBpbiBEYXRlbmJhbmsgc2NocmVpYmVuLiIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6MzIyIGJ1aWx0aW4vcmVwbGFjZS5jOjM3NyBidWlsdGluL3JlcGxhY2UuYzo0MjIKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjQ1MgorIzogYnVpbHRpbi9yZXBsYWNlLmM6MzIyIGJ1aWx0aW4vcmVwbGFjZS5jOjM3OCBidWlsdGluL3JlcGxhY2UuYzo0MjMKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjQ1MwogIywgYy1mb3JtYXQKIG1zZ2lkICJub3QgYSB2YWxpZCBvYmplY3QgbmFtZTogJyVzJyIKIG1zZ3N0ciAiS2VpbiBnw7xsdGlnZXIgT2JqZWt0bmFtZTogJyVzJyIKQEAgLTE4OTU2LDIyICsxOTA0MiwyMiBAQAogbXNnaWQgIm5ldyBvYmplY3QgaXMgdGhlIHNhbWUgYXMgdGhlIG9sZCBvbmU6ICclcyciCiBtc2dzdHIgIk5ldWVzIE9iamVrdCBpc3QgZGFzc2VsYmUgd2llIGRhcyBhbHRlOiAnJXMnIgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzozODMKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjM4NAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcGFyc2UgJXMgYXMgYSBjb21taXQiCiBtc2dzdHIgIktvbm50ZSBuaWNodCAlcyBhbHMgQ29tbWl0IHBhcnNlbi4iCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjQxNAorIzogYnVpbHRpbi9yZXBsYWNlLmM6NDE1CiAjLCBjLWZvcm1hdAogbXNnaWQgImJhZCBtZXJnZXRhZyBpbiBjb21taXQgJyVzJyIKIG1zZ3N0ciAidW5nw7xsdGlnZXIgTWVyZ2UtVGFnIGluIENvbW1pdCAnJXMnIgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo0MTYKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjQxNwogIywgYy1mb3JtYXQKIG1zZ2lkICJtYWxmb3JtZWQgbWVyZ2V0YWcgaW4gY29tbWl0ICclcyciCiBtc2dzdHIgImZlaGxlcmhhZnRlciBNZXJnZS1UYWcgaW4gQ29tbWl0ICclcyciCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjQyOAorIzogYnVpbHRpbi9yZXBsYWNlLmM6NDI5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJvcmlnaW5hbCBjb21taXQgJyVzJyBjb250YWlucyBtZXJnZXRhZyAnJXMnIHRoYXQgaXMgZGlzY2FyZGVkOyB1c2UgLS1lZGl0ICIKQEAgLTE4OTgwLDMxICsxOTA2NiwzMSBAQAogIkRlciB1cnNwcsO8bmdsaWNoZSBDb21taXQgJyVzJyBlbnRow6RsdCBNZXJnZS1UYWcgJyVzJywgZGVyIHZlcndvcmZlblxuIgogIndpcmQ7IGJlbnV0emVuIFNpZSAtLWVkaXQgYW5zdGF0dCAtLWdyYWZ0IgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo0NjcKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjQ2OAogIywgYy1mb3JtYXQKIG1zZ2lkICJ0aGUgb3JpZ2luYWwgY29tbWl0ICclcycgaGFzIGEgZ3BnIHNpZ25hdHVyZSIKIG1zZ3N0ciAiRGVyIG9yaWdpbmFsZSBDb21taXQgJyVzJyBoYXQgZWluZSBHUEctU2lnbmF0dXIuIgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo0NjgKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjQ2OQogbXNnaWQgInRoZSBzaWduYXR1cmUgd2lsbCBiZSByZW1vdmVkIGluIHRoZSByZXBsYWNlbWVudCBjb21taXQhIgogbXNnc3RyICJEaWUgU2lnbmF0dXIgd2lyZCBpbiBkZW0gRXJzZXR6dW5ncy1Db21taXQgZW50ZmVybnQhIgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo0NzgKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjQ3OQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3Qgd3JpdGUgcmVwbGFjZW1lbnQgY29tbWl0IGZvcjogJyVzJyIKIG1zZ3N0ciAiS29ubnRlIEVyc2V0enVuZ3MtQ29tbWl0IGbDvHIgJyVzJyBuaWNodCBzY2hyZWliZW4iCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjQ4NgorIzogYnVpbHRpbi9yZXBsYWNlLmM6NDg3CiAjLCBjLWZvcm1hdAogbXNnaWQgImdyYWZ0IGZvciAnJXMnIHVubmVjZXNzYXJ5IgogbXNnc3RyICJLw7xuc3RsaWNoZXIgVm9yZ8OkbmdlciAoXCJncmFmdFwiKSBmw7xyICclcycgbmljaHQgbm90d2VuZGlnLiIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NDkwCisjOiBidWlsdGluL3JlcGxhY2UuYzo0OTEKICMsIGMtZm9ybWF0CiBtc2dpZCAibmV3IGNvbW1pdCBpcyB0aGUgc2FtZSBhcyB0aGUgb2xkIG9uZTogJyVzJyIKIG1zZ3N0ciAiTmV1ZXIgQ29tbWl0IGlzdCBkZXJzZWxiZSB3aWUgZGVyIGFsdGU6ICclcyciCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjUyNQorIzogYnVpbHRpbi9yZXBsYWNlLmM6NTI2CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJjb3VsZCBub3QgY29udmVydCB0aGUgZm9sbG93aW5nIGdyYWZ0KHMpOlxuIgpAQCAtMTkwMTMsNzEgKzE5MDk5LDcxIEBACiAiS29ubnRlIGRpZSBmb2xnZW5kZW4ga8O8bnN0bGljaGVuIFZvcmfDpG5nZXIgKFwiZ3JhZnRzXCIpIG5pY2h0IGtvbnZlcnRpZXJlbjpcbiIKICIlcyIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NTQ2CisjOiBidWlsdGluL3JlcGxhY2UuYzo1NDcKIG1zZ2lkICJsaXN0IHJlcGxhY2UgcmVmcyIKIG1zZ3N0ciAiZXJzZXR6ZW5kZSBSZWZlcmVuemVuIGF1Zmxpc3RlbiIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NTQ3CisjOiBidWlsdGluL3JlcGxhY2UuYzo1NDgKIG1zZ2lkICJkZWxldGUgcmVwbGFjZSByZWZzIgogbXNnc3RyICJlcnNldHplbmRlIFJlZmVyZW56ZW4gbMO2c2NoZW4iCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU0OAorIzogYnVpbHRpbi9yZXBsYWNlLmM6NTQ5CiBtc2dpZCAiZWRpdCBleGlzdGluZyBvYmplY3QiCiBtc2dzdHIgImV4aXN0aWVyZW5kZXMgT2JqZWt0IGJlYXJiZWl0ZW4iCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU0OQorIzogYnVpbHRpbi9yZXBsYWNlLmM6NTUwCiBtc2dpZCAiY2hhbmdlIGEgY29tbWl0J3MgcGFyZW50cyIKIG1zZ3N0ciAiRWx0ZXJuLUNvbW1pdHMgZWluZXMgQ29tbWl0cyDDpG5kZXJuIgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo1NTAKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU1MQogbXNnaWQgImNvbnZlcnQgZXhpc3RpbmcgZ3JhZnQgZmlsZSIKIG1zZ3N0ciAiZXhpc3RpZXJlbmRlIERhdGVpIGRlcyBrw7xuc3RsaWNoZW4gVm9yZ8OkbmdlcnMgKFwiZ3JhZnRcIikga29udmVydGllcmVuIgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo1NTEKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU1MgogbXNnaWQgInJlcGxhY2UgdGhlIHJlZiBpZiBpdCBleGlzdHMiCiBtc2dzdHIgImRpZSBSZWZlcmVueiBlcnNldHplbiwgd2VubiBzaWUgZXhpc3RpZXJ0IgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo1NTMKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU1NAogbXNnaWQgImRvIG5vdCBwcmV0dHktcHJpbnQgY29udGVudHMgZm9yIC0tZWRpdCIKIG1zZ3N0ciAia2VpbmUgYW5zcHJlY2hlbmRlIEFuemVpZ2UgZGVzIE9iamVrdGluaGFsdGVzIGbDvHIgLS1lZGl0IgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo1NTQKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU1NQogbXNnaWQgInVzZSB0aGlzIGZvcm1hdCIKIG1zZ3N0ciAiZGFzIGFuZ2VnZWJlbmUgRm9ybWF0IGJlbnV0emVuIgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo1NjcKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU2OAogbXNnaWQgIi0tZm9ybWF0IGNhbm5vdCBiZSB1c2VkIHdoZW4gbm90IGxpc3RpbmciCiBtc2dzdHIgIi0tZm9ybWF0IGthbm4gbmljaHQgYmVpbSBBdWZsaXN0ZW4gdmVyd2VuZGV0IHdlcmRlbi4iCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU3NQorIzogYnVpbHRpbi9yZXBsYWNlLmM6NTc2CiBtc2dpZCAiLWYgb25seSBtYWtlcyBzZW5zZSB3aGVuIHdyaXRpbmcgYSByZXBsYWNlbWVudCIKIG1zZ3N0ciAiLWYgbWFjaHQgbnVyIGJlaW0gU2NocmVpYmVuIGVpbmVyIEVyc2V0enVuZyBTaW5uLiIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NTc5CisjOiBidWlsdGluL3JlcGxhY2UuYzo1ODAKIG1zZ2lkICItLXJhdyBvbmx5IG1ha2VzIHNlbnNlIHdpdGggLS1lZGl0IgogbXNnc3RyICItLXJhdyBtYWNodCBudXIgbWl0IC0tZWRpdCBTaW5uLiIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NTg1CisjOiBidWlsdGluL3JlcGxhY2UuYzo1ODYKIG1zZ2lkICItZCBuZWVkcyBhdCBsZWFzdCBvbmUgYXJndW1lbnQiCiBtc2dzdHIgIi1kIGJlbsO2dGlndCBtaW5kZXN0ZW5zIGVpbiBBcmd1bWVudC4iCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU5MQorIzogYnVpbHRpbi9yZXBsYWNlLmM6NTkyCiBtc2dpZCAiYmFkIG51bWJlciBvZiBhcmd1bWVudHMiCiBtc2dzdHIgIlVuZ8O8bHRpZ2UgQW56YWhsIHZvbiBBcmd1bWVudGVuLiIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NTk3CisjOiBidWlsdGluL3JlcGxhY2UuYzo1OTgKIG1zZ2lkICItZSBuZWVkcyBleGFjdGx5IG9uZSBhcmd1bWVudCIKIG1zZ3N0ciAiLWUgYmVuw7Z0aWd0IGdlbmF1IGVpbiBBcmd1bWVudC4iCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjYwMworIzogYnVpbHRpbi9yZXBsYWNlLmM6NjA0CiBtc2dpZCAiLWcgbmVlZHMgYXQgbGVhc3Qgb25lIGFyZ3VtZW50IgogbXNnc3RyICItZyBiZW7DtnRpZ3QgbWluZGVzdGVucyBlaW4gQXJndW1lbnQuIgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo2MDkKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjYxMAogbXNnaWQgIi0tY29udmVydC1ncmFmdC1maWxlIHRha2VzIG5vIGFyZ3VtZW50IgogbXNnc3RyICItLWNvbnZlcnQtZ3JhZnQtZmlsZSBlcndhcnRldCBrZWluZSBBcmd1bWVudGUiCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjYxNQorIzogYnVpbHRpbi9yZXBsYWNlLmM6NjE2CiBtc2dpZCAib25seSBvbmUgcGF0dGVybiBjYW4gYmUgZ2l2ZW4gd2l0aCAtbCIKIG1zZ3N0ciAiTWl0IC1sIGthbm4gbnVyIGVpbiBNdXN0ZXIgYW5nZWdlYmVuIHdlcmRlbi4iCiAKQEAgLTE5MTQ1LDEzICsxOTIzMSwxOCBAQAogbXNnaWQgIkZhaWxlZCB0byBmaW5kIHRyZWUgb2YgJXMuIgogbXNnc3RyICJGZWhsZXIgYmVpbSBGaW5kZW4gZGVzIFwiVHJlZVwiLU9iamVrdGVzIHZvbiAlcy4iCiAKKyM6IGJ1aWx0aW4vcmVzZXQuYzoxMTQKKyMsIGMtZm9ybWF0Cittc2dpZCAiSEVBRCBpcyBub3cgYXQgJXMiCittc2dzdHIgIkhFQUQgaXN0IGpldHp0IGJlaSAlcyIKKwogIzogYnVpbHRpbi9yZXNldC5jOjE5MwogIywgYy1mb3JtYXQKIG1zZ2lkICJDYW5ub3QgZG8gYSAlcyByZXNldCBpbiB0aGUgbWlkZGxlIG9mIGEgbWVyZ2UuIgogbXNnc3RyICJLYW5uIGtlaW5lbiAnJXMnLVJlc2V0IGR1cmNoZsO8aHJlbiwgd8OkaHJlbmQgZWluIE1lcmdlIGltIEdhbmdlIGlzdC4iCiAKLSM6IGJ1aWx0aW4vcmVzZXQuYzoyOTMgYnVpbHRpbi9zdGFzaC5jOjUxNCBidWlsdGluL3N0YXNoLmM6NTg5Ci0jOiBidWlsdGluL3N0YXNoLmM6NjEzCisjOiBidWlsdGluL3Jlc2V0LmM6MjkzIGJ1aWx0aW4vc3Rhc2guYzo1MjAgYnVpbHRpbi9zdGFzaC5jOjU5NQorIzogYnVpbHRpbi9zdGFzaC5jOjYxOQogbXNnaWQgImJlIHF1aWV0LCBvbmx5IHJlcG9ydCBlcnJvcnMiCiBtc2dzdHIgIndlbmlnZXIgQXVzZ2FiZW4sIG51ciBGZWhsZXIgbWVsZGVuIgogCkBAIC0xOTIzNiwyNSArMTkzMjcsMjAgQEAKIG1zZ2lkICJDb3VsZCBub3Qgd3JpdGUgbmV3IGluZGV4IGZpbGUuIgogbXNnc3RyICJLb25udGUgbmV1ZSBJbmRleC1EYXRlaSBuaWNodCBzY2hyZWliZW4uIgogCi0jOiBidWlsdGluL3Jldi1saXN0LmM6NDEyCisjOiBidWlsdGluL3Jldi1saXN0LmM6NDExCiBtc2dpZCAiY2Fubm90IGNvbWJpbmUgLS1leGNsdWRlLXByb21pc29yLW9iamVjdHMgYW5kIC0tbWlzc2luZyIKIG1zZ3N0ciAiIgogIi0tZXhjbHVkZS1wcm9taXNvci1vYmplY3RzIHVuZCAtLW1pc3Npbmcga8O2bm5lbiBuaWNodCBrb21iaW5pZXJ0IHdlcmRlbi4iCiAKLSM6IGJ1aWx0aW4vcmV2LWxpc3QuYzo0NzMKKyM6IGJ1aWx0aW4vcmV2LWxpc3QuYzo0NzIKIG1zZ2lkICJvYmplY3QgZmlsdGVyaW5nIHJlcXVpcmVzIC0tb2JqZWN0cyIKIG1zZ3N0ciAiRGFzIEZpbHRlcm4gdm9uIE9iamVrdGVuIGVyZm9yZGVydCAtLW9iamVjdHMuIgogCi0jOiBidWlsdGluL3Jldi1saXN0LmM6NDc2Ci0jLCBjLWZvcm1hdAotbXNnaWQgImludmFsaWQgc3BhcnNlIHZhbHVlICclcyciCi1tc2dzdHIgIlVuZ8O8bHRpZ2VyIFwic3BhcnNlXCItV2VydCAnJXMnLiIKLQotIzogYnVpbHRpbi9yZXYtbGlzdC5jOjUyNworIzogYnVpbHRpbi9yZXYtbGlzdC5jOjUyMgogbXNnaWQgInJldi1saXN0IGRvZXMgbm90IHN1cHBvcnQgZGlzcGxheSBvZiBub3RlcyIKIG1zZ3N0ciAicmV2LWxpc3QgdW50ZXJzdMO8dHp0IGtlaW5lIEFuemVpZ2Ugdm9uIE5vdGl6ZW4iCiAKLSM6IGJ1aWx0aW4vcmV2LWxpc3QuYzo1MzAKKyM6IGJ1aWx0aW4vcmV2LWxpc3QuYzo1MjUKIG1zZ2lkICJjYW5ub3QgY29tYmluZSAtLXVzZS1iaXRtYXAtaW5kZXggd2l0aCBvYmplY3QgZmlsdGVyaW5nIgogbXNnc3RyICIiCiAiLS11c2UtYml0bWFwLWluZGV4IGthbm4gbmljaHQgbWl0IGRlbSBGaWx0ZXJuIHZvbiBPYmpla3RlbiBrb21iaW5pZXJ0IHdlcmRlbi4iCkBAIC0xOTgwNSwxMzcgKzE5ODkxLDEzNyBAQAogbXNnaWQgImNvdWxkIG5vdCBzYXZlIGluZGV4IHRyZWUiCiBtc2dzdHIgIktvbm50ZSBJbmRleC1WZXJ6ZWljaG5pcyBuaWNodCBzcGVpY2hlcm4iCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzo0MzQKKyM6IGJ1aWx0aW4vc3Rhc2guYzo0MzYKIG1zZ2lkICJjb3VsZCBub3QgcmVzdG9yZSB1bnRyYWNrZWQgZmlsZXMgZnJvbSBzdGFzaCIKIG1zZ3N0ciAiS29ubnRlIHVudmVyc2lvbmllcnRlIERhdGVpZW4gdm9tIFN0YXNoIG5pY2h0IHdpZWRlcmhlcnN0ZWxsZW4uIgogCi0jOiBidWlsdGluL3N0YXNoLmM6NDQ4CisjOiBidWlsdGluL3N0YXNoLmM6NDUwCiAjLCBjLWZvcm1hdAogbXNnaWQgIk1lcmdpbmcgJXMgd2l0aCAlcyIKIG1zZ3N0ciAiRsO8aHJlICVzIG1pdCAlcyB6dXNhbW1lbiIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjQ1OCBnaXQtbGVnYWN5LXN0YXNoLnNoOjY4MAorIzogYnVpbHRpbi9zdGFzaC5jOjQ2MCBnaXQtbGVnYWN5LXN0YXNoLnNoOjY4MAogbXNnaWQgIkluZGV4IHdhcyBub3QgdW5zdGFzaGVkLiIKIG1zZ3N0ciAiSW5kZXggd3VyZGUgbmljaHQgYXVzIGRlbSBTdGFzaCB6dXLDvGNrZ2VsYWRlbi4iCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzo1MTYgYnVpbHRpbi9zdGFzaC5jOjYxNQorIzogYnVpbHRpbi9zdGFzaC5jOjUyMiBidWlsdGluL3N0YXNoLmM6NjIxCiBtc2dpZCAiYXR0ZW1wdCB0byByZWNyZWF0ZSB0aGUgaW5kZXgiCiBtc2dzdHIgIlZlcnN1Y2hlIEluZGV4IHdpZWRlcmhlcnp1c3RlbGxlbi4iCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzo1NDkKKyM6IGJ1aWx0aW4vc3Rhc2guYzo1NTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiRHJvcHBlZCAlcyAoJXMpIgogbXNnc3RyICIlcyAoJXMpIGdlbMO2c2NodCIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjU1MgorIzogYnVpbHRpbi9zdGFzaC5jOjU1OAogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogQ291bGQgbm90IGRyb3Agc3Rhc2ggZW50cnkiCiBtc2dzdHIgIiVzOiBLb25udGUgU3Rhc2gtRWludHJhZyBuaWNodCBsw7ZzY2hlbiIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjU3NworIzogYnVpbHRpbi9zdGFzaC5jOjU4MwogIywgYy1mb3JtYXQKIG1zZ2lkICInJXMnIGlzIG5vdCBhIHN0YXNoIHJlZmVyZW5jZSIKIG1zZ3N0ciAiJyVzJyBpc3Qga2VpbmUgU3Rhc2gtUmVmZXJlbnoiCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzo2MjcgZ2l0LWxlZ2FjeS1zdGFzaC5zaDo2OTQKKyM6IGJ1aWx0aW4vc3Rhc2guYzo2MzMgZ2l0LWxlZ2FjeS1zdGFzaC5zaDo2OTQKIG1zZ2lkICJUaGUgc3Rhc2ggZW50cnkgaXMga2VwdCBpbiBjYXNlIHlvdSBuZWVkIGl0IGFnYWluLiIKIG1zZ3N0ciAiIgogIkRlciBTdGFzaC1FaW50cmFnIHdpcmQgZsO8ciBkZW4gRmFsbCBiZWhhbHRlbiwgZGFzcyBTaWUgZGllc2VuIG5vY2htYWwgIgogImJlbsO2dGlnZW4uIgogCi0jOiBidWlsdGluL3N0YXNoLmM6NjUwIGdpdC1sZWdhY3ktc3Rhc2guc2g6NzEyCisjOiBidWlsdGluL3N0YXNoLmM6NjU2IGdpdC1sZWdhY3ktc3Rhc2guc2g6NzEyCiBtc2dpZCAiTm8gYnJhbmNoIG5hbWUgc3BlY2lmaWVkIgogbXNnc3RyICJLZWluIEJyYW5jaG5hbWUgc3BlemlmaXppZXJ0IgogCi0jOiBidWlsdGluL3N0YXNoLmM6NzkwIGJ1aWx0aW4vc3Rhc2guYzo4MjcKKyM6IGJ1aWx0aW4vc3Rhc2guYzo3OTYgYnVpbHRpbi9zdGFzaC5jOjgzMwogIywgYy1mb3JtYXQKIG1zZ2lkICJDYW5ub3QgdXBkYXRlICVzIHdpdGggJXMiCiBtc2dzdHIgIkthbm4gbmljaHQgJXMgbWl0ICVzIGFrdHVhbGlzaWVyZW4uIgogCi0jOiBidWlsdGluL3N0YXNoLmM6ODA4IGJ1aWx0aW4vc3Rhc2guYzoxNDYxIGJ1aWx0aW4vc3Rhc2guYzoxNDk3CisjOiBidWlsdGluL3N0YXNoLmM6ODE0IGJ1aWx0aW4vc3Rhc2guYzoxNDcwIGJ1aWx0aW4vc3Rhc2guYzoxNTA2CiBtc2dpZCAic3Rhc2ggbWVzc2FnZSIKIG1zZ3N0ciAiU3Rhc2gtQmVzY2hyZWlidW5nIgogCi0jOiBidWlsdGluL3N0YXNoLmM6ODE4CisjOiBidWlsdGluL3N0YXNoLmM6ODI0CiBtc2dpZCAiXCJnaXQgc3Rhc2ggc3RvcmVcIiByZXF1aXJlcyBvbmUgPGNvbW1pdD4gYXJndW1lbnQiCiBtc2dzdHIgIlwiZ2l0IHN0YXNoIHN0b3JlXCIgZXJ3YXJ0ZXQgZWluIEFyZ3VtZW50IDxDb21taXQ+IgogCi0jOiBidWlsdGluL3N0YXNoLmM6MTA0MCBnaXQtbGVnYWN5LXN0YXNoLnNoOjIxNworIzogYnVpbHRpbi9zdGFzaC5jOjEwNDYgZ2l0LWxlZ2FjeS1zdGFzaC5zaDoyMTcKIG1zZ2lkICJObyBjaGFuZ2VzIHNlbGVjdGVkIgogbXNnc3RyICJLZWluZSDDhG5kZXJ1bmdlbiBhdXNnZXfDpGhsdCIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjExMzYgZ2l0LWxlZ2FjeS1zdGFzaC5zaDoxNTAKKyM6IGJ1aWx0aW4vc3Rhc2guYzoxMTQ1IGdpdC1sZWdhY3ktc3Rhc2guc2g6MTUwCiBtc2dpZCAiWW91IGRvIG5vdCBoYXZlIHRoZSBpbml0aWFsIGNvbW1pdCB5ZXQiCiBtc2dzdHIgIlNpZSBoYWJlbiBiaXNoZXIgbm9jaCBrZWluZW4gaW5pdGlhbGVuIENvbW1pdCIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjExNjMgZ2l0LWxlZ2FjeS1zdGFzaC5zaDoxNjUKKyM6IGJ1aWx0aW4vc3Rhc2guYzoxMTcyIGdpdC1sZWdhY3ktc3Rhc2guc2g6MTY1CiBtc2dpZCAiQ2Fubm90IHNhdmUgdGhlIGN1cnJlbnQgaW5kZXggc3RhdGUiCiBtc2dzdHIgIkthbm4gZGVuIGFrdHVlbGxlbiBadXN0YW5kIGRlcyBJbmRleCBuaWNodCBzcGVpY2hlcm4iCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzoxMTcyIGdpdC1sZWdhY3ktc3Rhc2guc2g6MTgwCisjOiBidWlsdGluL3N0YXNoLmM6MTE4MSBnaXQtbGVnYWN5LXN0YXNoLnNoOjE4MAogbXNnaWQgIkNhbm5vdCBzYXZlIHRoZSB1bnRyYWNrZWQgZmlsZXMiCiBtc2dzdHIgIkthbm4gZGllIHVudmVyc2lvbmllcnRlbiBEYXRlaWVuIG5pY2h0IHNwZWljaGVybiIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjExODMgYnVpbHRpbi9zdGFzaC5jOjExOTIgZ2l0LWxlZ2FjeS1zdGFzaC5zaDoyMDAKKyM6IGJ1aWx0aW4vc3Rhc2guYzoxMTkyIGJ1aWx0aW4vc3Rhc2guYzoxMjAxIGdpdC1sZWdhY3ktc3Rhc2guc2g6MjAwCiAjOiBnaXQtbGVnYWN5LXN0YXNoLnNoOjIxMwogbXNnaWQgIkNhbm5vdCBzYXZlIHRoZSBjdXJyZW50IHdvcmt0cmVlIHN0YXRlIgogbXNnc3RyICJLYW5uIGRlbiBha3R1ZWxsZW4gWnVzdGFuZCBkZXMgQXJiZWl0c3ZlcnplaWNobmlzc2VzIG5pY2h0IHNwZWljaGVybiIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjEyMjAgZ2l0LWxlZ2FjeS1zdGFzaC5zaDoyMzMKKyM6IGJ1aWx0aW4vc3Rhc2guYzoxMjI5IGdpdC1sZWdhY3ktc3Rhc2guc2g6MjMzCiBtc2dpZCAiQ2Fubm90IHJlY29yZCB3b3JraW5nIHRyZWUgc3RhdGUiCiBtc2dzdHIgIkthbm4gWnVzdGFuZCBkZXMgQXJiZWl0c3ZlcnplaWNobmlzc2VzIG5pY2h0IGF1ZnplaWNobmVuIgogCi0jOiBidWlsdGluL3N0YXNoLmM6MTI2OSBnaXQtbGVnYWN5LXN0YXNoLnNoOjMzNworIzogYnVpbHRpbi9zdGFzaC5jOjEyNzggZ2l0LWxlZ2FjeS1zdGFzaC5zaDozMzcKIG1zZ2lkICJDYW4ndCB1c2UgLS1wYXRjaCBhbmQgLS1pbmNsdWRlLXVudHJhY2tlZCBvciAtLWFsbCBhdCB0aGUgc2FtZSB0aW1lIgogbXNnc3RyICIiCiAiS2FubiBuaWNodCBnbGVpY2h6ZWl0aWcgLS1wYXRjaCB1bmQgLS1pbmNsdWRlLXVudHJhY2tlZCBvZGVyIC0tYWxsIHZlcndlbmRlbiIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjEyODUKKyM6IGJ1aWx0aW4vc3Rhc2guYzoxMjk0CiBtc2dpZCAiRGlkIHlvdSBmb3JnZXQgdG8gJ2dpdCBhZGQnPyIKIG1zZ3N0ciAiSGFiZW4gU2llIHZpZWxsZWljaHQgJ2dpdCBhZGQnIHZlcmdlc3Nlbj8iCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzoxMzAwIGdpdC1sZWdhY3ktc3Rhc2guc2g6MzQ1CisjOiBidWlsdGluL3N0YXNoLmM6MTMwOSBnaXQtbGVnYWN5LXN0YXNoLnNoOjM0NQogbXNnaWQgIk5vIGxvY2FsIGNoYW5nZXMgdG8gc2F2ZSIKIG1zZ3N0ciAiS2VpbmUgbG9rYWxlbiDDhG5kZXJ1bmdlbiB6dW0gU3BlaWNoZXJuIgogCi0jOiBidWlsdGluL3N0YXNoLmM6MTMwNyBnaXQtbGVnYWN5LXN0YXNoLnNoOjM1MAorIzogYnVpbHRpbi9zdGFzaC5jOjEzMTYgZ2l0LWxlZ2FjeS1zdGFzaC5zaDozNTAKIG1zZ2lkICJDYW5ub3QgaW5pdGlhbGl6ZSBzdGFzaCIKIG1zZ3N0ciAiS2FubiBcInN0YXNoXCIgbmljaHQgaW5pdGlhbGlzaWVyZW4iCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzoxMzIyIGdpdC1sZWdhY3ktc3Rhc2guc2g6MzU0CisjOiBidWlsdGluL3N0YXNoLmM6MTMzMSBnaXQtbGVnYWN5LXN0YXNoLnNoOjM1NAogbXNnaWQgIkNhbm5vdCBzYXZlIHRoZSBjdXJyZW50IHN0YXR1cyIKIG1zZ3N0ciAiS2FubiBkZW4gYWt0dWVsbGVuIFN0YXR1cyBuaWNodCBzcGVpY2hlcm4iCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzoxMzI3CisjOiBidWlsdGluL3N0YXNoLmM6MTMzNgogIywgYy1mb3JtYXQKIG1zZ2lkICJTYXZlZCB3b3JraW5nIGRpcmVjdG9yeSBhbmQgaW5kZXggc3RhdGUgJXMiCiBtc2dzdHIgIkFyYmVpdHN2ZXJ6ZWljaG5pcyB1bmQgSW5kZXgtU3RhdHVzICVzIGdlc3BlaWNoZXJ0LiIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjE0MTcgZ2l0LWxlZ2FjeS1zdGFzaC5zaDozODQKKyM6IGJ1aWx0aW4vc3Rhc2guYzoxNDI2IGdpdC1sZWdhY3ktc3Rhc2guc2g6Mzg0CiBtc2dpZCAiQ2Fubm90IHJlbW92ZSB3b3JrdHJlZSBjaGFuZ2VzIgogbXNnc3RyICJLYW5uIMOEbmRlcnVuZ2VuIGltIEFyYmVpdHN2ZXJ6ZWljaG5pcyBuaWNodCBsw7ZzY2hlbiIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjE0NTIgYnVpbHRpbi9zdGFzaC5jOjE0ODgKKyM6IGJ1aWx0aW4vc3Rhc2guYzoxNDYxIGJ1aWx0aW4vc3Rhc2guYzoxNDk3CiBtc2dpZCAia2VlcCBpbmRleCIKIG1zZ3N0ciAiYmVoYWx0ZSBJbmRleCIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjE0NTQgYnVpbHRpbi9zdGFzaC5jOjE0OTAKKyM6IGJ1aWx0aW4vc3Rhc2guYzoxNDYzIGJ1aWx0aW4vc3Rhc2guYzoxNDk5CiBtc2dpZCAic3Rhc2ggaW4gcGF0Y2ggbW9kZSIKIG1zZ3N0ciAiU3Rhc2ggaW4gUGF0Y2gtTW9kdXMiCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzoxNDU1IGJ1aWx0aW4vc3Rhc2guYzoxNDkxCisjOiBidWlsdGluL3N0YXNoLmM6MTQ2NCBidWlsdGluL3N0YXNoLmM6MTUwMAogbXNnaWQgInF1aWV0IG1vZGUiCiBtc2dzdHIgIndlbmlnZXIgQXVzZ2FiZW4iCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzoxNDU3IGJ1aWx0aW4vc3Rhc2guYzoxNDkzCisjOiBidWlsdGluL3N0YXNoLmM6MTQ2NiBidWlsdGluL3N0YXNoLmM6MTUwMgogbXNnaWQgImluY2x1ZGUgdW50cmFja2VkIGZpbGVzIGluIHN0YXNoIgogbXNnc3RyICJ1bnZlcnNpb25pZXJ0ZSBEYXRlaWVuIGluIFN0YXNoIGVpbmJlemllaGVuIgogCi0jOiBidWlsdGluL3N0YXNoLmM6MTQ1OSBidWlsdGluL3N0YXNoLmM6MTQ5NQorIzogYnVpbHRpbi9zdGFzaC5jOjE0NjggYnVpbHRpbi9zdGFzaC5jOjE1MDQKIG1zZ2lkICJpbmNsdWRlIGlnbm9yZSBmaWxlcyIKIG1zZ3N0ciAiaWdub3JpZXJ0ZSBEYXRlaWVuIGVpbmJlemllaGVuIgogCi0jOiBidWlsdGluL3N0YXNoLmM6MTU1NQorIzogYnVpbHRpbi9zdGFzaC5jOjE1NjQKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGV4ZWMgJXMiCiBtc2dzdHIgIktvbm50ZSAnZXhlYyAlcycgbmljaHQgYXVzZsO8aHJlbi4iCkBAIC0yMDMyMiw4ICsyMDQwOCw4IEBACiBtc2dzdHIgImtlaW5lIEZvcnRzY2hyaXR0c2FuemVpZ2UgYmVpbSBLbG9uZW4iCiAKICM6IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxODc3Ci1tc2dpZCAiZ2l0IHN1Ym1vZHVsZS0taGVscGVyIHVwZGF0ZV9jbG9uZSBbLS1wcmVmaXg9PHBhdGg+XSBbPHBhdGg+Li4uXSIKLW1zZ3N0ciAiZ2l0IHN1Ym1vZHVsZS0taGVscGVyIHVwZGF0ZV9jbG9uZSBbLS1wcmVmaXg9PFBmYWQ+XSBbPFBmYWQ+Li4uXSIKK21zZ2lkICJnaXQgc3VibW9kdWxlLS1oZWxwZXIgdXBkYXRlLWNsb25lIFstLXByZWZpeD08cGF0aD5dIFs8cGF0aD4uLi5dIgorbXNnc3RyICJnaXQgc3VibW9kdWxlLS1oZWxwZXIgdXBkYXRlLWNsb25lIFstLXByZWZpeD08UGZhZD5dIFs8UGZhZD4uLi5dIgogCiAjOiBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6MTg5MAogbXNnaWQgImJhZCB2YWx1ZSBmb3IgdXBkYXRlIHBhcmFtZXRlciIKQEAgLTIwMzc4LDcgKzIwNDY0LDcgQEAKICJCaXR0ZSBzdGVsbGVuIFNpZSBzaWNoZXIsIGRhc3Mgc2ljaCBkaWUgRGF0ZWkgLmdpdG1vZHVsZXMgaW0gIgogIkFyYmVpdHN2ZXJ6ZWljaG5pcyBiZWZpbmRldC4iCiAKLSM6IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoyMjM1IGdpdC5jOjQzNCBnaXQuYzo2ODQKKyM6IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoyMjM1IGdpdC5jOjQzMyBnaXQuYzo2ODMKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgZG9lc24ndCBzdXBwb3J0IC0tc3VwZXItcHJlZml4IgogbXNnc3RyICIlcyB1bnRlcnN0w7x0enQga2VpbiAtLXN1cGVyLXByZWZpeCIKQEAgLTIwNzExLDE0NyArMjA3OTcsMTQ3IEBACiBtc2dpZCAiZ2l0IHVwZGF0ZS1pbmRleCBbPG9wdGlvbnM+XSBbLS1dIFs8ZmlsZT4uLi5dIgogbXNnc3RyICJnaXQgdXBkYXRlLWluZGV4IFs8T3B0aW9uZW4+XSBbLS1dIFs8RGF0ZWk+Li4uXSIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzo5NzEKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6OTcyCiBtc2dpZCAiY29udGludWUgcmVmcmVzaCBldmVuIHdoZW4gaW5kZXggbmVlZHMgdXBkYXRlIgogbXNnc3RyICIiCiAiQWt0dWFsaXNpZXJ1bmcgZm9ydHNldHplbiwgYXVjaCB3ZW5uIGRlciBJbmRleCBha3R1YWxpc2llcnQgd2VyZGVuIG11c3MiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6OTc0CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjk3NQogbXNnaWQgInJlZnJlc2g6IGlnbm9yZSBzdWJtb2R1bGVzIgogbXNnc3RyICJBa3R1YWxpc2llcnVuZzogaWdub3JpZXJ0IFN1Ym1vZHVsZSIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzo5NzcKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6OTc4CiBtc2dpZCAiZG8gbm90IGlnbm9yZSBuZXcgZmlsZXMiCiBtc2dzdHIgImtlaW5lIG5ldWVuIERhdGVpZW4gaWdub3JpZXJlbiIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzo5NzkKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6OTgwCiBtc2dpZCAibGV0IGZpbGVzIHJlcGxhY2UgZGlyZWN0b3JpZXMgYW5kIHZpY2UtdmVyc2EiCiBtc2dzdHIgIkRhdGVpZW4gVmVyemVpY2huaXNzZSBlcnNldHplbiBsYXNzZW4sIHVuZCB1bWdlZHJlaHQiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6OTgxCisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjk4MgogbXNnaWQgIm5vdGljZSBmaWxlcyBtaXNzaW5nIGZyb20gd29ya3RyZWUiCiBtc2dzdHIgImZlaGxlbmRlIERhdGVpZW4gaW0gQXJiZWl0c3ZlcnplaWNobmlzIGJlYWNodGVuIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjk4MworIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzo5ODQKIG1zZ2lkICJyZWZyZXNoIGV2ZW4gaWYgaW5kZXggY29udGFpbnMgdW5tZXJnZWQgZW50cmllcyIKIG1zZ3N0ciAiIgogImFrdHVhbGlzaWVyZW4sIGF1Y2ggd2VubiBkZXIgSW5kZXggbmljaHQgenVzYW1tZW5nZWbDvGhydGUgRWludHLDpGdlIGJlaW5oYWx0ZXQiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6OTg2CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjk4NwogbXNnaWQgInJlZnJlc2ggc3RhdCBpbmZvcm1hdGlvbiIKIG1zZ3N0ciAiRGF0ZWlpbmZvcm1hdGlvbmVuIGFrdHVhbGlzaWVyZW4iCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6OTkwCisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjk5MQogbXNnaWQgImxpa2UgLS1yZWZyZXNoLCBidXQgaWdub3JlIGFzc3VtZS11bmNoYW5nZWQgc2V0dGluZyIKIG1zZ3N0ciAid2llIC0tcmVmcmVzaCwgaWdub3JpZXJ0IGFiZXIgXCJhc3N1bWUtdW5jaGFuZ2VkXCIgRWluc3RlbGx1bmciCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6OTk0CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjk5NQogbXNnaWQgIjxtb2RlPiw8b2JqZWN0Piw8cGF0aD4iCiBtc2dzdHIgIjxNb2R1cz4sPE9iamVrdD4sPFBmYWQ+IgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjk5NQorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzo5OTYKIG1zZ2lkICJhZGQgdGhlIHNwZWNpZmllZCBlbnRyeSB0byB0aGUgaW5kZXgiCiBtc2dzdHIgImRlbiBhbmdlZ2ViZW5lbiBFaW50cmFnIHp1bSBDb21taXQgdm9ybWVya2VuIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMDUKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAwNgogbXNnaWQgIm1hcmsgZmlsZXMgYXMgXCJub3QgY2hhbmdpbmdcIiIKIG1zZ3N0ciAiZGllc2UgRGF0ZWkgaW1tZXIgYWxzIHVudmVyw6RuZGVydCBiZXRyYWNodGVuIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMDgKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAwOQogbXNnaWQgImNsZWFyIGFzc3VtZWQtdW5jaGFuZ2VkIGJpdCIKIG1zZ3N0ciAiXCJhc3N1bWVkLXVuY2hhbmdlZFwiLUJpdCBsw7ZzY2hlbiIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDExCisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMTIKIG1zZ2lkICJtYXJrIGZpbGVzIGFzIFwiaW5kZXgtb25seVwiIgogbXNnc3RyICJEYXRlaWVuIGFscyBcImluZGV4LW9ubHlcIiBtYXJraWVyZW4iCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAxNAorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDE1CiBtc2dpZCAiY2xlYXIgc2tpcC13b3JrdHJlZSBiaXQiCiBtc2dzdHIgIlwic2tpcC13b3JrdHJlZVwiLUJpdCBsw7ZzY2hlbiIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDE3CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMTgKIG1zZ2lkICJhZGQgdG8gaW5kZXggb25seTsgZG8gbm90IGFkZCBjb250ZW50IHRvIG9iamVjdCBkYXRhYmFzZSIKIG1zZ3N0ciAiIgogImRpZSDDhG5kZXJ1bmdlbiBudXIgenVtIENvbW1pdCB2b3JtZXJrZW47IEluaGFsdCB3aXJkIG5pY2h0IGRlciBPYmpla3QtIgogIkRhdGVuYmFuayBoaW56dWdlZsO8Z3QiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAxOQorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDIwCiBtc2dpZCAicmVtb3ZlIG5hbWVkIHBhdGhzIGV2ZW4gaWYgcHJlc2VudCBpbiB3b3JrdHJlZSIKIG1zZ3N0ciAiIgogImJlbmFubnRlIFBmYWRlIGzDtnNjaGVuLCBhdWNoIHdlbm4gc2llIHNpY2ggaW0gQXJiZWl0c3ZlcnplaWNobmlzIGJlZmluZGVuIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMjEKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAyMgogbXNnaWQgIndpdGggLS1zdGRpbjogaW5wdXQgbGluZXMgYXJlIHRlcm1pbmF0ZWQgYnkgbnVsbCBieXRlcyIKIG1zZ3N0ciAibWl0IC0tc3RkaW46IGVpbmdlZ2ViZW5lIFplaWxlbiBzaW5kIGR1cmNoIE5VTC1CeXRlcyBhYmdlc2NobG9zc2VuIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMjMKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAyNAogbXNnaWQgInJlYWQgbGlzdCBvZiBwYXRocyB0byBiZSB1cGRhdGVkIGZyb20gc3RhbmRhcmQgaW5wdXQiCiBtc2dzdHIgIkxpc3RlIGRlciB6dSBha3R1YWxpc2llcmVuZGVuIFBmYWRlIHZvbiBkZXIgU3RhbmRhcmQtRWluZ2FiZSBsZXNlbiIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDI3CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMjgKIG1zZ2lkICJhZGQgZW50cmllcyBmcm9tIHN0YW5kYXJkIGlucHV0IHRvIHRoZSBpbmRleCIKIG1zZ3N0ciAiRWludHLDpGdlIHZvbiBkZXIgU3RhbmRhcmQtRWluZ2FiZSB6dW0gQ29tbWl0IHZvcm1lcmtlbiIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDMxCisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMzIKIG1zZ2lkICJyZXBvcHVsYXRlIHN0YWdlcyAjMiBhbmQgIzMgZm9yIHRoZSBsaXN0ZWQgcGF0aHMiCiBtc2dzdHIgIiIKICJ3aWVkZXJob2x0ZXMgRWlucGZsZWdlbiBkZXIgWnVzdMOkbmRlICMyIHVuZCAjMyBmw7xyIGRpZSBhdWZnZWxpc3RldGVuIFBmYWRlIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMzUKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAzNgogbXNnaWQgIm9ubHkgdXBkYXRlIGVudHJpZXMgdGhhdCBkaWZmZXIgZnJvbSBIRUFEIgogbXNnc3RyICJudXIgRWludHLDpGdlIGFrdHVhbGlzaWVyZW4sIGRpZSB1bnRlcnNjaGllZGxpY2ggenUgSEVBRCBzaW5kIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMzkKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTA0MAogbXNnaWQgImlnbm9yZSBmaWxlcyBtaXNzaW5nIGZyb20gd29ya3RyZWUiCiBtc2dzdHIgImZlaGxlbmRlIERhdGVpZW4gaW0gQXJiZWl0c3ZlcnplaWNobmlzIGlnbm9yaWVyZW4iCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTA0MgorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDQzCiBtc2dpZCAicmVwb3J0IGFjdGlvbnMgdG8gc3RhbmRhcmQgb3V0cHV0IgogbXNnc3RyICJkaWUgQWt0aW9uZW4gaW4gZGVyIFN0YW5kYXJkLUF1c2dhYmUgYXVzZ2ViZW4iCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTA0NAorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDQ1CiBtc2dpZCAiKGZvciBwb3JjZWxhaW5zKSBmb3JnZXQgc2F2ZWQgdW5yZXNvbHZlZCBjb25mbGljdHMiCiBtc2dzdHIgIihmw7xyIEZyZW1kcHJvZ3JhbW1lKSBrZWluZSBnZXNwZWljaGVydGVuLCBuaWNodCBhdWZnZWzDtnN0ZSBLb25mbGlrdGUiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTA0OAorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDQ5CiBtc2dpZCAid3JpdGUgaW5kZXggaW4gdGhpcyBmb3JtYXQiCiBtc2dzdHIgIkluZGV4LURhdGVpIGluIGRpZXNlbSBGb3JtYXQgc2NocmVpYmVuIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwNTAKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTA1MQogbXNnaWQgImVuYWJsZSBvciBkaXNhYmxlIHNwbGl0IGluZGV4IgogbXNnc3RyICJTcGxpdHRpbmcgZGVzIEluZGV4IGFrdGl2aWVyZW4gb2RlciBkZWFrdGl2aWVyZW4iCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTA1MgorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDUzCiBtc2dpZCAiZW5hYmxlL2Rpc2FibGUgdW50cmFja2VkIGNhY2hlIgogbXNnc3RyICJDYWNoZSBmw7xyIHVudmVyc2lvbmllcnRlIERhdGVpZW4gYWt0aXZpZXJlbiBvZGVyIGRlYWt0aXZpZXJlbiIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDU0CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwNTUKIG1zZ2lkICJ0ZXN0IGlmIHRoZSBmaWxlc3lzdGVtIHN1cHBvcnRzIHVudHJhY2tlZCBjYWNoZSIKIG1zZ3N0ciAiIgogInByw7xmZW4sIG9iIGRhcyBEYXRlaXN5c3RlbSBlaW5lbiBDYWNoZSBmw7xyIHVudmVyc2lvbmllcnRlIERhdGVpZW4gdW50ZXJzdMO8dHp0IgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwNTYKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTA1NwogbXNnaWQgImVuYWJsZSB1bnRyYWNrZWQgY2FjaGUgd2l0aG91dCB0ZXN0aW5nIHRoZSBmaWxlc3lzdGVtIgogbXNnc3RyICIiCiAiQ2FjaGUgZsO8ciB1bnZlcnNpb25pZXJ0ZSBEYXRlaWVuIG9obmUgUHLDvGZ1bmcgZGVzIERhdGVpc3lzdGVtcyBha3RpdmllcmVuIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwNTgKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTA1OQogbXNnaWQgIndyaXRlIG91dCB0aGUgaW5kZXggZXZlbiBpZiBpcyBub3QgZmxhZ2dlZCBhcyBjaGFuZ2VkIgogbXNnc3RyICJJbmRleCByYXVzc2NocmVpYmVuLCBhdWNoIHdlbm4gZGllc2VyIG5pY2h0IGFscyBnZcOkbmRlcnQgbWFya2llcnQgaXN0IgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwNjAKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTA2MQogbXNnaWQgImVuYWJsZSBvciBkaXNhYmxlIGZpbGUgc3lzdGVtIG1vbml0b3IiCiBtc2dzdHIgIkRhdGVpc3lzdGVtLU1vbml0b3IgYWt0aXZpZXJlbiBvZGVyIGRlYWt0aXZpZXJlbiIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDYyCisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwNjMKIG1zZ2lkICJtYXJrIGZpbGVzIGFzIGZzbW9uaXRvciB2YWxpZCIKIG1zZ3N0ciAiRGF0ZWllbiBhbHMgXCJmc21vbml0b3IgdmFsaWRcIiBtYXJraWVyZW4iCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTA2NQorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDY2CiBtc2dpZCAiY2xlYXIgZnNtb25pdG9yIHZhbGlkIGJpdCIKIG1zZ3N0ciAiXCJmc21vbml0b3IgdmFsaWRcIi1CaXQgbMO2c2NoZW4iCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTE2OAorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMTY5CiBtc2dpZCAiIgogImNvcmUuc3BsaXRJbmRleCBpcyBzZXQgdG8gZmFsc2U7IHJlbW92ZSBvciBjaGFuZ2UgaXQsIGlmIHlvdSByZWFsbHkgd2FudCB0byAiCiAiZW5hYmxlIHNwbGl0IGluZGV4IgpAQCAtMjA4NTksNyArMjA5NDUsNyBAQAogImNvcmUuc3BsaXRJbmRleCBpc3QgYXVmICdmYWxzZScgZ2VzZXR6dC4gRW50ZmVybmVuIG9kZXIgw6RuZGVybiBTaWUgZGllcyxcbiIKICJ3ZW5uIHNpZSB3aXJrbGljaCBkYXMgU3BsaXR0aW5nIGRlcyBJbmRleCBha3RpdmllcmVuIG3DtmNodGVuLiIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMTc3CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjExNzgKIG1zZ2lkICIiCiAiY29yZS5zcGxpdEluZGV4IGlzIHNldCB0byB0cnVlOyByZW1vdmUgb3IgY2hhbmdlIGl0LCBpZiB5b3UgcmVhbGx5IHdhbnQgdG8gIgogImRpc2FibGUgc3BsaXQgaW5kZXgiCkBAIC0yMDg2Nyw3ICsyMDk1Myw3IEBACiAiY29yZS5zcGxpdEluZGV4IGlzdCBhdWYgJ3RydWUnIGdlc2V0enQuIEVudGZlcm5lbiBvZGVyIMOkbmRlcm4gU2llIGRpZXMsXG4iCiAid2VubiBTaWUgd2lya2xpY2ggZGFzIFNwbGl0dGluZyBkZXMgSW5kZXggZGVha3RpdmllcmVuIG3DtmNodGVuLiIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMTg4CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjExOTAKIG1zZ2lkICIiCiAiY29yZS51bnRyYWNrZWRDYWNoZSBpcyBzZXQgdG8gdHJ1ZTsgcmVtb3ZlIG9yIGNoYW5nZSBpdCwgaWYgeW91IHJlYWxseSB3YW50ICIKICJ0byBkaXNhYmxlIHRoZSB1bnRyYWNrZWQgY2FjaGUiCkBAIC0yMDg3NSwxMSArMjA5NjEsMTEgQEAKICJjb3JlLnVudHJhY2tlZENhY2hlIGlzdCBhdWYgJ3RydWUnIGdlc2V0enQuIEVudGZlcm5lbiBvZGVyIMOkbmRlcm4gU2llIGRpZXMsXG4iCiAid2VubiBTaWUgd2lya2xpY2ggZGVuIENhY2hlIGbDvHIgdW52ZXJzaW9uaWVydGUgRGF0ZWllbiBkZWFrdGl2aWVyZW4gbcO2Y2h0ZW4uIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjExOTIKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTE5NAogbXNnaWQgIlVudHJhY2tlZCBjYWNoZSBkaXNhYmxlZCIKIG1zZ3N0ciAiQ2FjaGUgZsO8ciB1bnZlcnNpb25pZXJ0ZSBEYXRlaWVuIGRlYWt0aXZpZXJ0IgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEyMDAKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTIwMgogbXNnaWQgIiIKICJjb3JlLnVudHJhY2tlZENhY2hlIGlzIHNldCB0byBmYWxzZTsgcmVtb3ZlIG9yIGNoYW5nZSBpdCwgaWYgeW91IHJlYWxseSB3YW50ICIKICJ0byBlbmFibGUgdGhlIHVudHJhY2tlZCBjYWNoZSIKQEAgLTIwODg4LDIzICsyMDk3NCwyMyBAQAogImRpZXMsXG4iCiAid2VubiBzaWUgd2lya2xpY2ggZGVuIENhY2hlIGbDvHIgdW52ZXJzaW9uaWVydGUgRGF0ZWllbiBha3RpdmllcmVuIG3DtmNodGVuLiIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMjA0CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEyMDYKICMsIGMtZm9ybWF0CiBtc2dpZCAiVW50cmFja2VkIGNhY2hlIGVuYWJsZWQgZm9yICclcyciCiBtc2dzdHIgIkNhY2hlIGbDvHIgdW52ZXJzaW9uaWVydGUgRGF0ZWllbiBmw7xyICclcycgYWt0aXZpZXJ0IgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEyMTIKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTIxNAogbXNnaWQgImNvcmUuZnNtb25pdG9yIGlzIHVuc2V0OyBzZXQgaXQgaWYgeW91IHJlYWxseSB3YW50IHRvIGVuYWJsZSBmc21vbml0b3IiCiBtc2dzdHIgIiIKICJjb3JlLmZzbW9uaXRvciBuaWNodCBnZXNldHp0LiBTZXR6ZW4gU2llIGVzLCB3ZW5uIFNpZSBkZW4gRGF0ZWlzeXN0ZW0tIgogIk1vbml0b3JcbiIKICJ3aXJrbGljaCBha3RpdmllcmVuIG3DtmNodGVuLiIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMjE2CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEyMTgKIG1zZ2lkICJmc21vbml0b3IgZW5hYmxlZCIKIG1zZ3N0ciAiRGF0ZWlzeXN0ZW0tTW9uaXRvciBha3RpdmllcnQiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTIxOQorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMjIxCiBtc2dpZCAiIgogImNvcmUuZnNtb25pdG9yIGlzIHNldDsgcmVtb3ZlIGl0IGlmIHlvdSByZWFsbHkgd2FudCB0byBkaXNhYmxlIGZzbW9uaXRvciIKIG1zZ3N0ciAiIgpAQCAtMjA5MTIsNyArMjA5OTgsNyBAQAogIk1vbml0b3JcbiIKICJ3aXJrbGljaCBkZWFrdGl2aWVyZW4gbcO2Y2h0ZW4uIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEyMjMKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTIyNQogbXNnaWQgImZzbW9uaXRvciBkaXNhYmxlZCIKIG1zZ3N0ciAiRGF0ZWlzeXN0ZW0tTW9uaXRvciBkZWFrdGl2aWVydCIKIApAQCAtMjEwMDcsNTUgKzIxMDkzLDU1IEBACiBtc2dpZCAicHJpbnQgdGFnIGNvbnRlbnRzIgogbXNnc3RyICJUYWctSW5oYWx0ZSBhdXNnZWJlbiIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjE4CisjOiBidWlsdGluL3dvcmt0cmVlLmM6MTcKIG1zZ2lkICJnaXQgd29ya3RyZWUgYWRkIFs8b3B0aW9ucz5dIDxwYXRoPiBbPGNvbW1pdC1pc2g+XSIKIG1zZ3N0ciAiZ2l0IHdvcmt0cmVlIGFkZCBbPE9wdGlvbmVuPl0gPFBmYWQ+IFs8Q29tbWl0LUFuZ2FiZT5dIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6MTkKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzoxOAogbXNnaWQgImdpdCB3b3JrdHJlZSBsaXN0IFs8b3B0aW9ucz5dIgogbXNnc3RyICJnaXQgd29ya3RyZWUgbGlzdCBbPE9wdGlvbmVuPl0iCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzoyMAorIzogYnVpbHRpbi93b3JrdHJlZS5jOjE5CiBtc2dpZCAiZ2l0IHdvcmt0cmVlIGxvY2sgWzxvcHRpb25zPl0gPHBhdGg+IgogbXNnc3RyICJnaXQgd29ya3RyZWUgbG9jayBbPE9wdGlvbmVuPl0gPFBmYWQ+IgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6MjEKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzoyMAogbXNnaWQgImdpdCB3b3JrdHJlZSBtb3ZlIDx3b3JrdHJlZT4gPG5ldy1wYXRoPiIKIG1zZ3N0ciAiZ2l0IHdvcmt0cmVlIG1vdmUgPEFyYmVpdHN2ZXJ6ZWljaG5pcz4gPG5ldWVyLVBmYWQ+IgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6MjIKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzoyMQogbXNnaWQgImdpdCB3b3JrdHJlZSBwcnVuZSBbPG9wdGlvbnM+XSIKIG1zZ3N0ciAiZ2l0IHdvcmt0cmVlIHBydW5lIFs8T3B0aW9uZW4+XSIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjIzCisjOiBidWlsdGluL3dvcmt0cmVlLmM6MjIKIG1zZ2lkICJnaXQgd29ya3RyZWUgcmVtb3ZlIFs8b3B0aW9ucz5dIDx3b3JrdHJlZT4iCiBtc2dzdHIgImdpdCB3b3JrdHJlZSByZW1vdmUgWzxPcHRpb25lbj5dIDxBcmJlaXRzdmVyemVpY2huaXM+IgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6MjQKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzoyMwogbXNnaWQgImdpdCB3b3JrdHJlZSB1bmxvY2sgPHBhdGg+IgogbXNnc3RyICJnaXQgd29ya3RyZWUgdW5sb2NrIDxQZmFkPiIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjYxIGJ1aWx0aW4vd29ya3RyZWUuYzo4OTkKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo2MCBidWlsdGluL3dvcmt0cmVlLmM6ODk4CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBkZWxldGUgJyVzJyIKIG1zZ3N0ciAiRmVobGVyIGJlaW0gTMO2c2NoZW4gdm9uICclcyciCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4MAorIzogYnVpbHRpbi93b3JrdHJlZS5jOjc5CiAjLCBjLWZvcm1hdAogbXNnaWQgIlJlbW92aW5nIHdvcmt0cmVlcy8lczogbm90IGEgdmFsaWQgZGlyZWN0b3J5IgogbXNnc3RyICJMw7ZzY2hlIHdvcmt0cmVlcy8lczoga2VpbiBnw7xsdGlnZXMgVmVyemVpY2huaXMiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4NgorIzogYnVpbHRpbi93b3JrdHJlZS5jOjg1CiAjLCBjLWZvcm1hdAogbXNnaWQgIlJlbW92aW5nIHdvcmt0cmVlcy8lczogZ2l0ZGlyIGZpbGUgZG9lcyBub3QgZXhpc3QiCiBtc2dzdHIgIkzDtnNjaGUgd29ya3RyZWVzLyVzOiBnaXRkaXItRGF0ZWkgZXhpc3RpZXJ0IG5pY2h0IgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6OTEgYnVpbHRpbi93b3JrdHJlZS5jOjEwMAorIzogYnVpbHRpbi93b3JrdHJlZS5jOjkwIGJ1aWx0aW4vd29ya3RyZWUuYzo5OQogIywgYy1mb3JtYXQKIG1zZ2lkICJSZW1vdmluZyB3b3JrdHJlZXMvJXM6IHVuYWJsZSB0byByZWFkIGdpdGRpciBmaWxlICglcykiCiBtc2dzdHIgIkzDtnNjaGUgd29ya3RyZWVzLyVzOiBrb25udGUgZ2l0ZGlyLURhdGVpICglcykgbmljaHQgbGVzZW4iCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzoxMTAKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzoxMDkKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlJlbW92aW5nIHdvcmt0cmVlcy8lczogc2hvcnQgcmVhZCAoZXhwZWN0ZWQgJTxQUkl1TUFYPiBieXRlcywgcmVhZCAiCkBAIC0yMTA2NCwzNSArMjExNTAsMzUgQEAKICJMw7ZzY2hlIHdvcmt0cmVlcy8lczogcmVhZCgpIHp1IGt1cnogKCU8UFJJdU1BWD4gQnl0ZXMgZXJ3YXJ0ZXQsICU8UFJJdU1BWD4gIgogImdlbGVzZW4pIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6MTE4CisjOiBidWlsdGluL3dvcmt0cmVlLmM6MTE3CiAjLCBjLWZvcm1hdAogbXNnaWQgIlJlbW92aW5nIHdvcmt0cmVlcy8lczogaW52YWxpZCBnaXRkaXIgZmlsZSIKIG1zZ3N0ciAiTMO2c2NoZSB3b3JrdHJlZXMvJXM6IHVuZ8O8bHRpZ2UgZ2l0ZGlyLURhdGVpIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6MTI3CisjOiBidWlsdGluL3dvcmt0cmVlLmM6MTI2CiAjLCBjLWZvcm1hdAogbXNnaWQgIlJlbW92aW5nIHdvcmt0cmVlcy8lczogZ2l0ZGlyIGZpbGUgcG9pbnRzIHRvIG5vbi1leGlzdGVudCBsb2NhdGlvbiIKIG1zZ3N0ciAiTMO2c2NoZSB3b3JrdHJlZXMvJXM6IGdpdGRpci1EYXRlaSB2ZXJ3ZWlzdCBhdWYgbmljaHQgZXhpc3RpZXJlbmRlbiBPcnQiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzoxNjYKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzoxNjUKIG1zZ2lkICJyZXBvcnQgcHJ1bmVkIHdvcmtpbmcgdHJlZXMiCiBtc2dzdHIgImVudGZlcm50ZSBBcmJlaXRzdmVyemVpY2huaXNzZSBhdXNnZWJlbiIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjE2OAorIzogYnVpbHRpbi93b3JrdHJlZS5jOjE2NwogbXNnaWQgImV4cGlyZSB3b3JraW5nIHRyZWVzIG9sZGVyIHRoYW4gPHRpbWU+IgogbXNnc3RyICJBcmJlaXRzdmVyemVpY2huaXNzZSDDpGx0ZXIgYWxzIDxaZWl0PiB2ZXJmYWxsZW4gbGFzc2VuIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6MjM1CisjOiBidWlsdGluL3dvcmt0cmVlLmM6MjM0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiclcycgYWxyZWFkeSBleGlzdHMiCiBtc2dzdHIgIiclcycgZXhpc3RpZXJ0IGJlcmVpdHMiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzoyNTIKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzoyNTEKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHJlLWFkZCB3b3JrdHJlZSAnJXMnIgogbXNnc3RyICJLb25udGUgQXJiZWl0c3ZlcnplaWNobmlzICclcycgbmljaHQgbmV1IGhpbnp1ZsO8Z2VuLiIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjI1NworIzogYnVpbHRpbi93b3JrdHJlZS5jOjI1NgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiJyVzJyBpcyBhIG1pc3NpbmcgYnV0IGxvY2tlZCB3b3JrdHJlZTtcbiIKQEAgLTIxMTAyLDcgKzIxMTg4LDcgQEAKICJCZW51dHplbiBTaWUgJ2FkZCAtZiAtZicgenVtIMOcYmVyc2NocmllYmVuLCBvZGVyICd1bmxvY2snIHVuZCAncHJ1bmUnXG4iCiAib2RlciAncmVtb3ZlJyB6dW0gTMO2c2NoZW4uIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6MjU5CisjOiBidWlsdGluL3dvcmt0cmVlLmM6MjU4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICInJXMnIGlzIGEgbWlzc2luZyBidXQgYWxyZWFkeSByZWdpc3RlcmVkIHdvcmt0cmVlO1xuIgpAQCAtMjExMTIsMTI5ICsyMTE5OCwxMjkgQEAKICJCZW51dHplbiBTaWUgJ2FkZCAtZicgenVtIMOcYmVyc2NocmVpYmVuLCBvZGVyICdwcnVuZScgb2RlciAncmVtb3ZlJyB6dW1cbiIKICJMw7ZzY2hlbi4iCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzozMDkKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzozMDgKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGNyZWF0ZSBkaXJlY3Rvcnkgb2YgJyVzJyIKIG1zZ3N0ciAiS29ubnRlIFZlcnplaWNobmlzICclcycgbmljaHQgZXJzdGVsbGVuLiIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjQ0MCBidWlsdGluL3dvcmt0cmVlLmM6NDQ2CisjOiBidWlsdGluL3dvcmt0cmVlLmM6NDM5IGJ1aWx0aW4vd29ya3RyZWUuYzo0NDUKICMsIGMtZm9ybWF0CiBtc2dpZCAiUHJlcGFyaW5nIHdvcmt0cmVlIChuZXcgYnJhbmNoICclcycpIgogbXNnc3RyICJCZXJlaXRlIEFyYmVpdHN2ZXJ6ZWljaG5pcyB2b3IgKG5ldWVyIEJyYW5jaCAnJXMnKSIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjQ0MgorIzogYnVpbHRpbi93b3JrdHJlZS5jOjQ0MQogIywgYy1mb3JtYXQKIG1zZ2lkICJQcmVwYXJpbmcgd29ya3RyZWUgKHJlc2V0dGluZyBicmFuY2ggJyVzJzsgd2FzIGF0ICVzKSIKIG1zZ3N0ciAiQmVyZWl0ZSBBcmJlaXRzdmVyemVpY2huaXMgdm9yIChzZXR6ZSBCcmFuY2ggJyVzJyB1bTsgd2FyIGJlaSAlcykiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo0NTEKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo0NTAKICMsIGMtZm9ybWF0CiBtc2dpZCAiUHJlcGFyaW5nIHdvcmt0cmVlIChjaGVja2luZyBvdXQgJyVzJykiCiBtc2dzdHIgIkJlcmVpdGUgQXJiZWl0c3ZlcnplaWNobmlzIHZvciAoY2hlY2tlICclcycgYXVzKSIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjQ1NworIzogYnVpbHRpbi93b3JrdHJlZS5jOjQ1NgogIywgYy1mb3JtYXQKIG1zZ2lkICJQcmVwYXJpbmcgd29ya3RyZWUgKGRldGFjaGVkIEhFQUQgJXMpIgogbXNnc3RyICJCZXJlaXRlIEFyYmVpdHN2ZXJ6ZWljaG5pcyB2b3IgKGxvc2dlbMO2c3RlciBIRUFEICVzKSIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjQ5OAorIzogYnVpbHRpbi93b3JrdHJlZS5jOjQ5NwogbXNnaWQgImNoZWNrb3V0IDxicmFuY2g+IGV2ZW4gaWYgYWxyZWFkeSBjaGVja2VkIG91dCBpbiBvdGhlciB3b3JrdHJlZSIKIG1zZ3N0ciAiIgogIjxCcmFuY2g+IGF1c2NoZWNrZW4sIGF1Y2ggd2VubiBkaWVzZXIgYmVyZWl0cyBpbiBlaW5lbSBhbmRlcmVuICIKICJBcmJlaXRzdmVyemVpY2huaXMgYXVzZ2VjaGVja3QgaXN0IgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NTAxCisjOiBidWlsdGluL3dvcmt0cmVlLmM6NTAwCiBtc2dpZCAiY3JlYXRlIGEgbmV3IGJyYW5jaCIKIG1zZ3N0ciAibmV1ZW4gQnJhbmNoIGVyc3RlbGxlbiIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjUwMworIzogYnVpbHRpbi93b3JrdHJlZS5jOjUwMgogbXNnaWQgImNyZWF0ZSBvciByZXNldCBhIGJyYW5jaCIKIG1zZ3N0ciAiQnJhbmNoIGVyc3RlbGxlbiBvZGVyIHVtc2V0emVuIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NTA1CisjOiBidWlsdGluL3dvcmt0cmVlLmM6NTA0CiBtc2dpZCAicG9wdWxhdGUgdGhlIG5ldyB3b3JraW5nIHRyZWUiCiBtc2dzdHIgImRhcyBuZXVlIEFyYmVpdHN2ZXJ6ZWljaG5pcyBhdXNjaGVja2VuIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NTA2CisjOiBidWlsdGluL3dvcmt0cmVlLmM6NTA1CiBtc2dpZCAia2VlcCB0aGUgbmV3IHdvcmtpbmcgdHJlZSBsb2NrZWQiCiBtc2dzdHIgImRhcyBuZXVlIEFyYmVpdHN2ZXJ6ZWljaG5pcyBnZXNwZXJydCBsYXNzZW4iCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo1MDkKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo1MDgKIG1zZ2lkICJzZXQgdXAgdHJhY2tpbmcgbW9kZSAoc2VlIGdpdC1icmFuY2goMSkpIgogbXNnc3RyICJNb2R1cyB6dW0gRm9sZ2VuIHZvbiBCcmFuY2hlcyBlaW5zdGVsbGVuIChzaWVoZSBnaXQtYnJhbmNoKDEpKSIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjUxMgorIzogYnVpbHRpbi93b3JrdHJlZS5jOjUxMQogbXNnaWQgInRyeSB0byBtYXRjaCB0aGUgbmV3IGJyYW5jaCBuYW1lIHdpdGggYSByZW1vdGUtdHJhY2tpbmcgYnJhbmNoIgogbXNnc3RyICIiCiAidmVyc3VjaGVuLCBlaW5lIMOcYmVyZWluc3RpbW11bmcgZGVzIEJyYW5jaC1OYW1lbnMgbWl0IGVpbmVtXG4iCiAiUmVtb3RlLVRyYWNraW5nLUJyYW5jaCBoZXJ6dXN0ZWxsZW4iCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo1MjAKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo1MTkKIG1zZ2lkICItYiwgLUIsIGFuZCAtLWRldGFjaCBhcmUgbXV0dWFsbHkgZXhjbHVzaXZlIgogbXNnc3RyICItYiwgLUIgdW5kIC0tZGV0YWNoIHNjaGxpZcOfZW4gc2ljaCBnZWdlbnNlaXRpZyBhdXMiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo1ODEKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo1ODAKIG1zZ2lkICItLVtuby1ddHJhY2sgY2FuIG9ubHkgYmUgdXNlZCBpZiBhIG5ldyBicmFuY2ggaXMgY3JlYXRlZCIKIG1zZ3N0ciAiIgogIi0tW25vXS10cmFjayBrYW5uIG51ciB2ZXJ3ZW5kZXQgd2VyZGVuLCB3ZW5uIGVpbiBuZXVlciBCcmFuY2ggZXJzdGVsbHQgd2lyZC4iCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo2ODEKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo2ODAKIG1zZ2lkICJyZWFzb24gZm9yIGxvY2tpbmciCiBtc2dzdHIgIlNwZXJyZ3J1bmQiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo2OTMgYnVpbHRpbi93b3JrdHJlZS5jOjcyNiBidWlsdGluL3dvcmt0cmVlLmM6ODAwCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6OTI3CisjOiBidWlsdGluL3dvcmt0cmVlLmM6NjkyIGJ1aWx0aW4vd29ya3RyZWUuYzo3MjUgYnVpbHRpbi93b3JrdHJlZS5jOjc5OQorIzogYnVpbHRpbi93b3JrdHJlZS5jOjkyNgogIywgYy1mb3JtYXQKIG1zZ2lkICInJXMnIGlzIG5vdCBhIHdvcmtpbmcgdHJlZSIKIG1zZ3N0ciAiJyVzJyBpc3Qga2VpbiBBcmJlaXRzdmVyemVpY2huaXMiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo2OTUgYnVpbHRpbi93b3JrdHJlZS5jOjcyOAorIzogYnVpbHRpbi93b3JrdHJlZS5jOjY5NCBidWlsdGluL3dvcmt0cmVlLmM6NzI3CiBtc2dpZCAiVGhlIG1haW4gd29ya2luZyB0cmVlIGNhbm5vdCBiZSBsb2NrZWQgb3IgdW5sb2NrZWQiCiBtc2dzdHIgIkRhcyBIYXVwdGFyYmVpdHN2ZXJ6ZWljaG5pcyBrYW5uIG5pY2h0IGdlc3BlcnJ0IG9kZXIgZW50c3BlcnJ0IHdlcmRlbi4iCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo3MDAKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo2OTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiJyVzJyBpcyBhbHJlYWR5IGxvY2tlZCwgcmVhc29uOiAlcyIKIG1zZ3N0ciAiJyVzJyBpc3QgYmVyZWl0cyBnZXNwZXJydCwgR3J1bmQ6ICVzIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NzAyCisjOiBidWlsdGluL3dvcmt0cmVlLmM6NzAxCiAjLCBjLWZvcm1hdAogbXNnaWQgIiclcycgaXMgYWxyZWFkeSBsb2NrZWQiCiBtc2dzdHIgIiclcycgaXN0IGJlcmVpdHMgZ2VzcGVycnQiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo3MzAKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo3MjkKICMsIGMtZm9ybWF0CiBtc2dpZCAiJyVzJyBpcyBub3QgbG9ja2VkIgogbXNnc3RyICInJXMnIGlzdCBuaWNodCBnZXNwZXJydCIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjc3MQorIzogYnVpbHRpbi93b3JrdHJlZS5jOjc3MAogbXNnaWQgIndvcmtpbmcgdHJlZXMgY29udGFpbmluZyBzdWJtb2R1bGVzIGNhbm5vdCBiZSBtb3ZlZCBvciByZW1vdmVkIgogbXNnc3RyICIiCiAiQXJiZWl0c3ZlcnplaWNobmlzc2UsIGRpZSBTdWJtb2R1bGUgZW50aGFsdGVuLCBrw7ZubmVuIG5pY2h0IHZlcnNjaG9iZW4gb2RlclxuIgogImVudGZlcm50IHdlcmRlbi4iCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo3NzkKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo3NzgKIG1zZ2lkICJmb3JjZSBtb3ZlIGV2ZW4gaWYgd29ya3RyZWUgaXMgZGlydHkgb3IgbG9ja2VkIgogbXNnc3RyICIiCiAiVmVyc2NoaWViZW4gZXJ6d2luZ2VuLCBhdWNoIHdlbm4gZGFzIEFyYmVpdHN2ZXJ6ZWljaG5pcyBnZcOkbmRlcnQgb2RlciAiCiAiZ2VzcGVycnQgaXN0IgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6ODAyIGJ1aWx0aW4vd29ya3RyZWUuYzo5MjkKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4MDEgYnVpbHRpbi93b3JrdHJlZS5jOjkyOAogIywgYy1mb3JtYXQKIG1zZ2lkICInJXMnIGlzIGEgbWFpbiB3b3JraW5nIHRyZWUiCiBtc2dzdHIgIiclcycgaXN0IGVpbiBIYXVwdGFyYmVpdHN2ZXJ6ZWljaG5pcyIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjgwNworIzogYnVpbHRpbi93b3JrdHJlZS5jOjgwNgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgZmlndXJlIG91dCBkZXN0aW5hdGlvbiBuYW1lIGZyb20gJyVzJyIKIG1zZ3N0ciAiS29ubnRlIFppZWxuYW1lIGF1cyAnJXMnIG5pY2h0IGJlc3RpbW1lbi4iCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4MTMKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4MTIKICMsIGMtZm9ybWF0CiBtc2dpZCAidGFyZ2V0ICclcycgYWxyZWFkeSBleGlzdHMiCiBtc2dzdHIgIlppZWwgJyVzJyBleGlzdGllcnQgYmVyZWl0cy4iCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4MjEKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4MjAKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogImNhbm5vdCBtb3ZlIGEgbG9ja2VkIHdvcmtpbmcgdHJlZSwgbG9jayByZWFzb246ICVzXG4iCkBAIC0yMTI0NCw3ICsyMTMzMCw3IEBACiAiQmVudXR6ZW4gU2llICdtb3ZlIC1mIC1mJyB6dW0gw5xiZXJzY2hyZWliZW4gb2RlciBlbnRzcGVycmVuIFNpZSB6dWVyc3RcbiIKICJkYXMgQXJiZWl0c3ZlcnplaWNobmlzLiIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjgyMworIzogYnVpbHRpbi93b3JrdHJlZS5jOjgyMgogbXNnaWQgIiIKICJjYW5ub3QgbW92ZSBhIGxvY2tlZCB3b3JraW5nIHRyZWU7XG4iCiAidXNlICdtb3ZlIC1mIC1mJyB0byBvdmVycmlkZSBvciB1bmxvY2sgZmlyc3QiCkBAIC0yMTI1MywzOCArMjEzMzksNDAgQEAKICJCZW51dHplbiBTaWUgJ21vdmUgLWYgLWYnIHp1bSDDnGJlcnNjaHJlaWJlbiBvZGVyIGVudHNwZXJyZW4gU2llIHp1ZXJzdFxuIgogImRhcyBBcmJlaXRzdmVyemVpY2huaXMuIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6ODI2CisjOiBidWlsdGluL3dvcmt0cmVlLmM6ODI1CiAjLCBjLWZvcm1hdAogbXNnaWQgInZhbGlkYXRpb24gZmFpbGVkLCBjYW5ub3QgbW92ZSB3b3JraW5nIHRyZWU6ICVzIgogbXNnc3RyICJWYWxpZGllcnVuZyBmZWhsZ2VzY2hsYWdlbiwga2FubiBBcmJlaXRzemVpY2huaXMgbmljaHQgdmVyc2NoaWViZW46ICVzIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6ODMxCisjOiBidWlsdGluL3dvcmt0cmVlLmM6ODMwCiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBtb3ZlICclcycgdG8gJyVzJyIKIG1zZ3N0ciAiRmVobGVyIGJlaW0gVmVyc2NoaWViZW4gdm9uICclcycgbmFjaCAnJXMnIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6ODc5CisjOiBidWlsdGluL3dvcmt0cmVlLmM6ODc4CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBydW4gJ2dpdCBzdGF0dXMnIG9uICclcyciCiBtc2dzdHIgIkZlaGxlciBiZWltIEF1c2bDvGhyZW4gdm9uICdnaXQgc3RhdHVzJyBhdWYgJyVzJyIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjg4MworIzogYnVpbHRpbi93b3JrdHJlZS5jOjg4MgogIywgYy1mb3JtYXQKLW1zZ2lkICInJXMnIGlzIGRpcnR5LCB1c2UgLS1mb3JjZSB0byBkZWxldGUgaXQiCi1tc2dzdHIgIiclcycgaXN0IHZlcsOkbmRlcnQsIGJlbnV0emVuIFNpZSAtLWZvcmNlIHp1bSBMw7ZzY2hlbiIKK21zZ2lkICInJXMnIGNvbnRhaW5zIG1vZGlmaWVkIG9yIHVudHJhY2tlZCBmaWxlcywgdXNlIC0tZm9yY2UgdG8gZGVsZXRlIGl0IgorbXNnc3RyICIiCisiJyVzJyBlbnRow6RsdCBnZcOkbmRlcnRlIG9kZXIgbmljaHQgdmVyc2lvbmllcnRlIERhdGVpZW4sIGJlbnV0emVuIFNpZSAtLWZvcmNlICIKKyJ6dW0gTMO2c2NoZW4iCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4ODgKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4ODcKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIHJ1biAnZ2l0IHN0YXR1cycgb24gJyVzJywgY29kZSAlZCIKIG1zZ3N0ciAiRmVobGVyIGJlaW0gQXVzZsO8aHJlbiB2b24gJ2dpdCBzdGF0dXMnIGF1ZiAnJXMnLiBDb2RlOiAlZCIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjkxMQorIzogYnVpbHRpbi93b3JrdHJlZS5jOjkxMAogbXNnaWQgImZvcmNlIHJlbW92YWwgZXZlbiBpZiB3b3JrdHJlZSBpcyBkaXJ0eSBvciBsb2NrZWQiCiBtc2dzdHIgIiIKICJMw7ZzY2hlbiBlcnp3aW5nZW4sIGF1Y2ggd2VubiBkYXMgQXJiZWl0c3ZlcnplaWNobmlzIGdlw6RuZGVydCBvZGVyIGdlc3BlcnJ0ICIKICJpc3QiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo5MzQKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo5MzMKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogImNhbm5vdCByZW1vdmUgYSBsb2NrZWQgd29ya2luZyB0cmVlLCBsb2NrIHJlYXNvbjogJXNcbiIKQEAgLTIxMjk0LDcgKzIxMzgyLDcgQEAKICJCZW51dHplbiBTaWUgJ3JlbW92ZSAtZiAtZicgenVtIMOcYmVyc2NocmVpYmVuIG9kZXIgZW50c3BlcnJlbiBTaWUgenVlcnN0XG4iCiAiZGFzIEFyYmVpdHN2ZXJ6ZWljaG5pcy4iCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo5MzYKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo5MzUKIG1zZ2lkICIiCiAiY2Fubm90IHJlbW92ZSBhIGxvY2tlZCB3b3JraW5nIHRyZWU7XG4iCiAidXNlICdyZW1vdmUgLWYgLWYnIHRvIG92ZXJyaWRlIG9yIHVubG9jayBmaXJzdCIKQEAgLTIxMzAzLDcgKzIxMzkxLDcgQEAKICJCZW51dHplbiBTaWUgJ3JlbW92ZSAtZiAtZicgenVtIMOcYmVyc2NocmVpYmVuIG9kZXIgZW50c3BlcnJlbiBTaWUgenVlcnN0XG4iCiAiZGFzIEFyYmVpdHN2ZXJ6ZWljaG5pcy4iCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo5MzkKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo5MzgKICMsIGMtZm9ybWF0CiBtc2dpZCAidmFsaWRhdGlvbiBmYWlsZWQsIGNhbm5vdCByZW1vdmUgd29ya2luZyB0cmVlOiAlcyIKIG1zZ3N0ciAiVmFsaWRpZXJ1bmcgZmVobGdlc2NobGFnZW4sIGthbm4gQXJiZWl0c3ZlcnplaWNobmlzIG5pY2h0IGzDtnNjaGVuOiAlcyIKQEAgLTIxMzI0LDYgKzIxNDEyLDE2IEBACiBtc2dpZCAib25seSB1c2VmdWwgZm9yIGRlYnVnZ2luZyIKIG1zZ3N0ciAibnVyIG7DvHR6bGljaCBmw7xyIEZlaGxlcnN1Y2hlIgogCisjOiBmYXN0LWltcG9ydC5jOjMxMTgKKyMsIGMtZm9ybWF0Cittc2dpZCAiRXhwZWN0ZWQgJ21hcmsnIGNvbW1hbmQsIGdvdCAlcyIKK21zZ3N0ciAiJ21hcmsnIEJlZmVobCBlcndhcnRldCwgJyVzJyBiZWtvbW1lbiIKKworIzogZmFzdC1pbXBvcnQuYzozMTIzCisjLCBjLWZvcm1hdAorbXNnaWQgIkV4cGVjdGVkICd0bycgY29tbWFuZCwgZ290ICVzIgorbXNnc3RyICIndG8nIEJlZmVobCBlcndhcnRldCwgJyVzJyBiZWtvbW1lbiIKKwogIzogY3JlZGVudGlhbC1jYWNoZS0tZGFlbW9uLmM6MjIzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKQEAgLTIxNDM5LDM5ICsyMTUzNywzOSBAQAogIkFsaWFzICclcycgw6RuZGVydCBVbWdlYnVuZ3N2YXJpYWJsZW4uXG4iCiAiU2llIGvDtm5uZW4gJyFnaXQnIGltIEFsaWFzIGJlbnV0emVuLCB1bSBkaWVzIHp1IHR1bi4iCiAKLSM6IGdpdC5jOjM3NworIzogZ2l0LmM6Mzc2CiAjLCBjLWZvcm1hdAogbXNnaWQgImVtcHR5IGFsaWFzIGZvciAlcyIKIG1zZ3N0ciAibGVlcmVyIEFsaWFzIGbDvHIgJXMiCiAKLSM6IGdpdC5jOjM4MAorIzogZ2l0LmM6Mzc5CiAjLCBjLWZvcm1hdAogbXNnaWQgInJlY3Vyc2l2ZSBhbGlhczogJXMiCiBtc2dzdHIgInJla3Vyc2l2ZXIgQWxpYXM6ICVzIgogCi0jOiBnaXQuYzo0NjAKKyM6IGdpdC5jOjQ1OQogbXNnaWQgIndyaXRlIGZhaWx1cmUgb24gc3RhbmRhcmQgb3V0cHV0IgogbXNnc3RyICJGZWhsZXIgYmVpbSBTY2hyZWliZW4gaW4gZGllIFN0YW5kYXJkLUF1c2dhYmUuIgogCi0jOiBnaXQuYzo0NjIKKyM6IGdpdC5jOjQ2MQogbXNnaWQgInVua25vd24gd3JpdGUgZmFpbHVyZSBvbiBzdGFuZGFyZCBvdXRwdXQiCiBtc2dzdHIgIlVuYmVrYW5udGVyIEZlaGxlciBiZWltIFNjaHJlaWJlbiBpbiBkaWUgU3RhbmRhcmQtQXVzZ2FiZS4iCiAKLSM6IGdpdC5jOjQ2NAorIzogZ2l0LmM6NDYzCiBtc2dpZCAiY2xvc2UgZmFpbGVkIG9uIHN0YW5kYXJkIG91dHB1dCIKIG1zZ3N0ciAiRmVobGVyIGJlaW0gU2NobGllw59lbiBkZXIgU3RhbmRhcmQtQXVzZ2FiZS4iCiAKLSM6IGdpdC5jOjc5MworIzogZ2l0LmM6NzkyCiAjLCBjLWZvcm1hdAogbXNnaWQgImFsaWFzIGxvb3AgZGV0ZWN0ZWQ6IGV4cGFuc2lvbiBvZiAnJXMnIGRvZXMgbm90IHRlcm1pbmF0ZTolcyIKIG1zZ3N0ciAiQWxpYXMtU2NobGVpZmUgZXJrYW5udDogRXJ3ZWl0ZXJ1bmcgdm9uICclcycgc2NobGllw590IG5pY2h0IGFiOiVzIgogCi0jOiBnaXQuYzo4NDMKKyM6IGdpdC5jOjg0MgogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgaGFuZGxlICVzIGFzIGEgYnVpbHRpbiIKIG1zZ3N0ciAiS2FubiAlcyBuaWNodCBhbHMgZWluZ2ViYXV0ZW4gQmVmZWhsIGJlaGFuZGVsbi4iCiAKLSM6IGdpdC5jOjg1NgorIzogZ2l0LmM6ODU1CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJ1c2FnZTogJXNcbiIKQEAgLTIxNDgwLDEyICsyMTU3OCwxMiBAQAogIlZlcndlbmR1bmc6ICVzXG4iCiAiXG4iCiAKLSM6IGdpdC5jOjg3NgorIzogZ2l0LmM6ODc1CiAjLCBjLWZvcm1hdAogbXNnaWQgImV4cGFuc2lvbiBvZiBhbGlhcyAnJXMnIGZhaWxlZDsgJyVzJyBpcyBub3QgYSBnaXQgY29tbWFuZFxuIgogbXNnc3RyICJFcndlaXRlcnVuZyB2b24gQWxpYXMgJyVzJyBmZWhsZ2VzY2hsYWdlbjsgJyVzJyBpc3Qga2VpbiBHaXQtQmVmZWhsLlxuIgogCi0jOiBnaXQuYzo4ODgKKyM6IGdpdC5jOjg4NwogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gcnVuIGNvbW1hbmQgJyVzJzogJXNcbiIKIG1zZ3N0ciAiRmVobGVyIGJlaW0gQXVzZsO8aHJlbiB2b24gQmVmZWhsICclcyc6ICVzXG4iCkBAIC0yMTUwNSwzMSArMjE2MDMsMzEgQEAKICJEYXMgQW5oZWZ0ZW4gZGVzIMO2ZmZlbnRsaWNoZW4gU2NobMO8c3NlbHMgd2lyZCBtaXQgY1VSTCA8IDcuNDQuMFxuIgogIm5pY2h0IHVudGVyc3TDvHR6dC4iCiAKLSM6IGh0dHAuYzo4NzYKKyM6IGh0dHAuYzo4NzgKIG1zZ2lkICJDVVJMU1NMT1BUX05PX1JFVk9LRSBub3Qgc3VwcG9ydGVkIHdpdGggY1VSTCA8IDcuNDQuMCIKIG1zZ3N0ciAiQ1VSTFNTTE9QVF9OT19SRVZPS0Ugd2lyZCBtaXQgY1VSTCA8IDcuNDQuMCBuaWNodCB1bnRlcnN0w7x0enQuIgogCi0jOiBodHRwLmM6OTQ5CisjOiBodHRwLmM6OTUxCiBtc2dpZCAiUHJvdG9jb2wgcmVzdHJpY3Rpb25zIG5vdCBzdXBwb3J0ZWQgd2l0aCBjVVJMIDwgNy4xOS40IgogbXNnc3RyICJQcm90b2tvbGxiZXNjaHLDpG5rdW5nZW4gd2VyZGVuIG1pdCBjVVJMIDwgNy4xOS40IG5pY2h0IHVudGVyc3TDvHR6dC4iCiAKLSM6IGh0dHAuYzoxMDg1CisjOiBodHRwLmM6MTA4OAogIywgYy1mb3JtYXQKIG1zZ2lkICJVbnN1cHBvcnRlZCBTU0wgYmFja2VuZCAnJXMnLiBTdXBwb3J0ZWQgU1NMIGJhY2tlbmRzOiIKIG1zZ3N0ciAiTmljaHQgdW50ZXJzdMO8dHp0ZXMgU1NMLUJhY2tlbmQgJyVzJy4gVW50ZXJzdMO8dHp0ZSBTU0wtQmFja2VuZHM6IgogCi0jOiBodHRwLmM6MTA5MgorIzogaHR0cC5jOjEwOTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ291bGQgbm90IHNldCBTU0wgYmFja2VuZCB0byAnJXMnOiBjVVJMIHdhcyBidWlsdCB3aXRob3V0IFNTTCBiYWNrZW5kcyIKIG1zZ3N0ciAiIgogIktvbm50ZSBTU0wtQmFja2VuZCBuaWNodCB6dSAnJXMnIHNldHplbjogY1VSTCB3dXJkZSBvaG5lIFNTTC1CYWNrZW5kcyBnZWJhdXQuIgogCi0jOiBodHRwLmM6MTA5NgorIzogaHR0cC5jOjEwOTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ291bGQgbm90IHNldCBTU0wgYmFja2VuZCB0byAnJXMnOiBhbHJlYWR5IHNldCIKIG1zZ3N0ciAiS29ubnRlIFNTTC1CYWNrZW5kIG5pY2h0IHp1ICclcycgc2V0emVuOiBiZXJlaXRzIGdlc2V0enQiCiAKLSM6IGh0dHAuYzoxOTY1CisjOiBodHRwLmM6MTk2OAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAidW5hYmxlIHRvIHVwZGF0ZSB1cmwgYmFzZSBmcm9tIHJlZGlyZWN0aW9uOlxuIgpAQCAtMjE1NDAsMTMwICsyMTYzOCwxMzAgQEAKICIgIGdlZnJhZ3QgbmFjaDogJXNcbiIKICIgICAgdW1nZWxlaXRldDogJXMiCiAKLSM6IHJlbW90ZS1jdXJsLmM6MTU3CisjOiByZW1vdGUtY3VybC5jOjE2NgogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIHF1b3RpbmcgaW4gcHVzaC1vcHRpb24gdmFsdWU6ICclcyciCiBtc2dzdHIgIlVuZ8O8bHRpZ2VzIFF1b3RpbmcgYmVpbSBcInB1c2gtb3B0aW9uXCItV2VydDogJyVzJyIKIAotIzogcmVtb3RlLWN1cmwuYzoyNTQKKyM6IHJlbW90ZS1jdXJsLmM6MjYzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzaW5mby9yZWZzIG5vdCB2YWxpZDogaXMgdGhpcyBhIGdpdCByZXBvc2l0b3J5PyIKIG1zZ3N0ciAiJXNpbmZvL3JlZnMgbmljaHQgZ8O8bHRpZzogSXN0IGRhcyBlaW4gR2l0LVJlcG9zaXRvcnk/IgogCi0jOiByZW1vdGUtY3VybC5jOjM1NQorIzogcmVtb3RlLWN1cmwuYzozNjQKIG1zZ2lkICJpbnZhbGlkIHNlcnZlciByZXNwb25zZTsgZXhwZWN0ZWQgc2VydmljZSwgZ290IGZsdXNoIHBhY2tldCIKIG1zZ3N0ciAiVW5nw7xsdGlnZSBBbnR3b3J0IGRlcyBTZXJ2ZXJzLiBTZXJ2aWNlIGVyd2FydGV0LCBGbHVzaC1QYWtldCBiZWtvbW1lbiIKIAotIzogcmVtb3RlLWN1cmwuYzozODYKKyM6IHJlbW90ZS1jdXJsLmM6Mzk1CiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgc2VydmVyIHJlc3BvbnNlOyBnb3QgJyVzJyIKIG1zZ3N0ciAiVW5nw7xsdGlnZSBTZXJ2ZXJhbnR3b3J0OyAnJXMnIGJla29tbWVuIgogCi0jOiByZW1vdGUtY3VybC5jOjQ0NgorIzogcmVtb3RlLWN1cmwuYzo0NTUKICMsIGMtZm9ybWF0CiBtc2dpZCAicmVwb3NpdG9yeSAnJXMnIG5vdCBmb3VuZCIKIG1zZ3N0ciAiUmVwb3NpdG9yeSAnJXMnIG5pY2h0IGdlZnVuZGVuLiIKIAotIzogcmVtb3RlLWN1cmwuYzo0NTAKKyM6IHJlbW90ZS1jdXJsLmM6NDU5CiAjLCBjLWZvcm1hdAogbXNnaWQgIkF1dGhlbnRpY2F0aW9uIGZhaWxlZCBmb3IgJyVzJyIKIG1zZ3N0ciAiQXV0aGVudGlmaXppZXJ1bmcgZmVobGdlc2NobGFnZW4gZsO8ciAnJXMnIgogCi0jOiByZW1vdGUtY3VybC5jOjQ1NAorIzogcmVtb3RlLWN1cmwuYzo0NjMKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGFjY2VzcyAnJXMnOiAlcyIKIG1zZ3N0ciAia29ubnRlIG5pY2h0IGF1ZiAnJXMnIHp1Z3JlaWZlbjogJXMiCiAKLSM6IHJlbW90ZS1jdXJsLmM6NDYwCisjOiByZW1vdGUtY3VybC5jOjQ2OQogIywgYy1mb3JtYXQKIG1zZ2lkICJyZWRpcmVjdGluZyB0byAlcyIKIG1zZ3N0ciAiTGVpdGUgbmFjaCAlcyB1bSIKIAotIzogcmVtb3RlLWN1cmwuYzo1ODQKKyM6IHJlbW90ZS1jdXJsLmM6NTkzCiBtc2dpZCAic2hvdWxkbid0IGhhdmUgRU9GIHdoZW4gbm90IGdlbnRsZSBvbiBFT0YiCiBtc2dzdHIgInNvbGx0ZSBrZWluIEVPRiBoYWJlbiwgd2VubiBuaWNodCBiZWh1dHNhbSBtaXQgRU9GIgogCi0jOiByZW1vdGUtY3VybC5jOjY2NAorIzogcmVtb3RlLWN1cmwuYzo2NzMKIG1zZ2lkICJ1bmFibGUgdG8gcmV3aW5kIHJwYyBwb3N0IGRhdGEgLSB0cnkgaW5jcmVhc2luZyBodHRwLnBvc3RCdWZmZXIiCiBtc2dzdHIgIiIKICJLb25udGUgbmljaHQgUlBDLVBPU1QtRGF0ZW4genVyw7xja3NwdWxlbiAtIFZlcnN1Y2hlbiBTaWUgaHR0cC5wb3N0QnVmZmVyIHp1ICIKICJlcmjDtmhlbiIKIAotIzogcmVtb3RlLWN1cmwuYzo3MjQKKyM6IHJlbW90ZS1jdXJsLmM6NzMzCiAjLCBjLWZvcm1hdAogbXNnaWQgIlJQQyBmYWlsZWQ7ICVzIgogbXNnc3RyICJSUEMgZmVobGdlc2NobGFnZW47ICVzIgogCi0jOiByZW1vdGUtY3VybC5jOjc2NAorIzogcmVtb3RlLWN1cmwuYzo3NzMKIG1zZ2lkICJjYW5ub3QgaGFuZGxlIHB1c2hlcyB0aGlzIGJpZyIKIG1zZ3N0ciAiS2FubiBzb2xjaGUgZ3Jvw59lbiDDnGJlcnRyYWd1bmdlbiBuaWNodCB2ZXJhcmJlaXRlbi4iCiAKLSM6IHJlbW90ZS1jdXJsLmM6ODc5CisjOiByZW1vdGUtY3VybC5jOjg4OAogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgZGVmbGF0ZSByZXF1ZXN0OyB6bGliIGRlZmxhdGUgZXJyb3IgJWQiCiBtc2dzdHIgIkthbm4gUmVxdWVzdCBuaWNodCBrb21wcmltaWVyZW47IFwiemxpYiBkZWZsYXRlXCItRmVobGVyICVkIgogCi0jOiByZW1vdGUtY3VybC5jOjg4MworIzogcmVtb3RlLWN1cmwuYzo4OTIKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IGRlZmxhdGUgcmVxdWVzdDsgemxpYiBlbmQgZXJyb3IgJWQiCiBtc2dzdHIgIkthbm4gUmVxdWVzdCBuaWNodCBrb21wcmltaWVyZW47IFwiemxpYiBlbmRcIi1GZWhsZXIgJWQiCiAKLSM6IHJlbW90ZS1jdXJsLmM6MTAxNAorIzogcmVtb3RlLWN1cmwuYzoxMDIzCiBtc2dpZCAiZHVtYiBodHRwIHRyYW5zcG9ydCBkb2VzIG5vdCBzdXBwb3J0IHNoYWxsb3cgY2FwYWJpbGl0aWVzIgogbXNnc3RyICJEdW1iIEhUVFAtVHJhbnNwb3J0IHVudGVyc3TDvHR6dCBrZWluZSBzaGFsbG93LUZ1bmt0aW9uZW4iCiAKLSM6IHJlbW90ZS1jdXJsLmM6MTAyOAorIzogcmVtb3RlLWN1cmwuYzoxMDM3CiBtc2dpZCAiZmV0Y2ggZmFpbGVkLiIKIG1zZ3N0ciAiXCJmZXRjaFwiIGZlaGxnZXNjaGxhZ2VuLiIKIAotIzogcmVtb3RlLWN1cmwuYzoxMDc2CisjOiByZW1vdGUtY3VybC5jOjEwODUKIG1zZ2lkICJjYW5ub3QgZmV0Y2ggYnkgc2hhMSBvdmVyIHNtYXJ0IGh0dHAiCiBtc2dzdHIgIkthbm4gU0hBLTEgbmljaHQgw7xiZXIgU21hcnQtSFRUUCBhbmZvcmRlcm4iCiAKLSM6IHJlbW90ZS1jdXJsLmM6MTEyMCByZW1vdGUtY3VybC5jOjExMjYKKyM6IHJlbW90ZS1jdXJsLmM6MTEyOSByZW1vdGUtY3VybC5jOjExMzUKICMsIGMtZm9ybWF0CiBtc2dpZCAicHJvdG9jb2wgZXJyb3I6IGV4cGVjdGVkIHNoYS9yZWYsIGdvdCAnJXMnIgogbXNnc3RyICJQcm90b2tvbGxmZWhsZXI6IFNIQS0xL1JlZmVyZW56IGVyd2FydGV0LCAnJXMnIGJla29tbWVuIgogCi0jOiByZW1vdGUtY3VybC5jOjExMzggcmVtb3RlLWN1cmwuYzoxMjUyCisjOiByZW1vdGUtY3VybC5jOjExNDcgcmVtb3RlLWN1cmwuYzoxMjYxCiAjLCBjLWZvcm1hdAogbXNnaWQgImh0dHAgdHJhbnNwb3J0IGRvZXMgbm90IHN1cHBvcnQgJXMiCiBtc2dzdHIgIkhUVFAtVHJhbnNwb3J0IHVudGVyc3TDvHR6dCBuaWNodCAlcyIKIAotIzogcmVtb3RlLWN1cmwuYzoxMTc0CisjOiByZW1vdGUtY3VybC5jOjExODMKIG1zZ2lkICJnaXQtaHR0cC1wdXNoIGZhaWxlZCIKIG1zZ3N0ciAiXCJnaXQtaHR0cC1wdXNoXCIgZmVobGdlc2NobGFnZW4iCiAKLSM6IHJlbW90ZS1jdXJsLmM6MTM2MAorIzogcmVtb3RlLWN1cmwuYzoxMzY3CiBtc2dpZCAicmVtb3RlLWN1cmw6IHVzYWdlOiBnaXQgcmVtb3RlLWN1cmwgPHJlbW90ZT4gWzx1cmw+XSIKIG1zZ3N0ciAicmVtb3RlLWN1cmw6IFZlcndlbmR1bmc6IGdpdCByZW1vdGUtY3VybCA8UmVtb3RlLVJlcG9zaXRvcnk+IFs8VVJMPl0iCiAKLSM6IHJlbW90ZS1jdXJsLmM6MTM5MgorIzogcmVtb3RlLWN1cmwuYzoxMzk5CiBtc2dpZCAicmVtb3RlLWN1cmw6IGVycm9yIHJlYWRpbmcgY29tbWFuZCBzdHJlYW0gZnJvbSBnaXQiCiBtc2dzdHIgInJlbW90ZS1jdXJsOiBGZWhsZXIgYmVpbSBMZXNlbiBkZXMgS29tbWFuZG8tU3RyZWFtcyB2b24gR2l0IgogCi0jOiByZW1vdGUtY3VybC5jOjEzOTkKKyM6IHJlbW90ZS1jdXJsLmM6MTQwNgogbXNnaWQgInJlbW90ZS1jdXJsOiBmZXRjaCBhdHRlbXB0ZWQgd2l0aG91dCBhIGxvY2FsIHJlcG8iCiBtc2dzdHIgInJlbW90ZS1jdXJsOiBcImZldGNoXCIgb2huZSBsb2thbGVzIFJlcG9zaXRvcnkgdmVyc3VjaHQiCiAKLSM6IHJlbW90ZS1jdXJsLmM6MTQzOQorIzogcmVtb3RlLWN1cmwuYzoxNDQ2CiAjLCBjLWZvcm1hdAogbXNnaWQgInJlbW90ZS1jdXJsOiB1bmtub3duIGNvbW1hbmQgJyVzJyBmcm9tIGdpdCIKIG1zZ3N0ciAicmVtb3RlLWN1cmw6IFVuYmVrYW5udGVyIEJlZmVobCAnJXMnIHZvbiBHaXQiCiAKLSM6IGxpc3Qtb2JqZWN0cy1maWx0ZXItb3B0aW9ucy5oOjYxCisjOiBsaXN0LW9iamVjdHMtZmlsdGVyLW9wdGlvbnMuaDo4NQogbXNnaWQgImFyZ3MiCiBtc2dzdHIgIkFyZ3VtZW50ZSIKIAotIzogbGlzdC1vYmplY3RzLWZpbHRlci1vcHRpb25zLmg6NjIKKyM6IGxpc3Qtb2JqZWN0cy1maWx0ZXItb3B0aW9ucy5oOjg2CiBtc2dpZCAib2JqZWN0IGZpbHRlcmluZyIKIG1zZ3N0ciAiRmlsdGVybiBuYWNoIE9iamVrdGVuIgogCi0jOiBwYXJzZS1vcHRpb25zLmg6MTcwCisjOiBwYXJzZS1vcHRpb25zLmg6MTc5CiBtc2dpZCAiZXhwaXJ5LWRhdGUiCiBtc2dzdHIgIlZlcmZhbGxzZGF0dW0iCiAKLSM6IHBhcnNlLW9wdGlvbnMuaDoxODQKKyM6IHBhcnNlLW9wdGlvbnMuaDoxOTMKIG1zZ2lkICJuby1vcCAoYmFja3dhcmQgY29tcGF0aWJpbGl0eSkiCiBtc2dzdHIgIktlaW4gRWZmZWt0IChSw7xja3fDpHJ0c2tvbXBhdGliaWxpdMOkdCkiCiAKQEAgLTI0MTYyLDYgKzI0MjYwLDQ0IEBACiBtc2dpZCAiRG8geW91IHJlYWxseSB3YW50IHRvIHNlbmQgJXM/IFt5fE5dOiAiCiBtc2dzdHIgIldvbGxlbiBTaWUgJXMgd2lya2xpY2ggdmVyc2VuZGVuPyBbeXxOXTogIgogCisjfiBtc2dpZCAidW5rbm93biBjb3JlLnVudHJhY2tlZENhY2hlIHZhbHVlICclcyc7IHVzaW5nICdrZWVwJyBkZWZhdWx0IHZhbHVlIgorI34gbXNnc3RyICIiCisjfiAiVW5iZWthbm50ZXIgV2VydCAnJXMnIGluIGNvcmUudW50cmFja2VkQ2FjaGU7IGJlbnV0emUgU3RhbmRhcmR3ZXJ0ICdrZWVwJyIKKworI34gbXNnaWQgImNhbm5vdCBjaGFuZ2UgcGFydGlhbCBjbG9uZSBwcm9taXNvciByZW1vdGUiCisjfiBtc2dzdHIgIkthbm4gUmVtb3RlLVJlcG9zaXRvcnkgZsO8ciBwYXJ0aWVsbGVzIEtsb25lbiBuaWNodCDDpG5kZXJuLiIKKworI34gbXNnaWQgImVycm9yIGJ1aWxkaW5nIHRyZWVzIgorI34gbXNnc3RyICJGZWhsZXIgYmVpbSBFcnN0ZWxsZW4gZGVyIFwiVHJlZVwiLU9iamVrdGUiCisKKyN+IG1zZ2lkICJpbnZhbGlkIGRhdGUgZm9ybWF0ICclcycgaW4gJyVzJyIKKyN+IG1zZ3N0ciAiVW5nw7xsdGlnZXMgRGF0dW1zZm9ybWF0ICclcycgaW4gJyVzJyIKKworI34gbXNnaWQgIndyaXRpbmcgcm9vdCBjb21taXQiCisjfiBtc2dzdHIgIlJvb3QtQ29tbWl0IHNjaHJlaWJlbiIKKworI34gbXNnaWQgInN0YWdlZCBjaGFuZ2VzIGluIHRoZSBmb2xsb3dpbmcgZmlsZXMgbWF5IGJlIGxvc3Q6ICVzIgorI34gbXNnc3RyICIiCisjfiAiWnVtIENvbW1pdCB2b3JnZW1lcmt0ZSDDhG5kZXJ1bmdlbiBpbiBkZW4gZm9sZ2VuZGVuIERhdGVpZW4gZ2VoZW4gIgorI34gImV2ZW50dWVsbCB2ZXJsb3JlbjogJXMiCisKKyN+IG1zZ2lkICIiCisjfiAiLS1maWx0ZXIgY2FuIG9ubHkgYmUgdXNlZCB3aXRoIHRoZSByZW1vdGUgY29uZmlndXJlZCBpbiBleHRlbnNpb25zLiIKKyN+ICJwYXJ0aWFsQ2xvbmUiCisjfiBtc2dzdHIgIiIKKyN+ICItLWZpbHRlciBrYW5uIG51ciBtaXQgZGVuIFJlbW90ZS1SZXBvc2l0b3JpZXMgdmVyd2VuZGV0IHdlcmRlbixcbiIKKyN+ICJkaWUgaW4gY29yZS5wYXJ0aWFsQ2xvbmUga29uZmlndXJpZXJ0IHNpbmQuIgorCisjfiBtc2dpZCAidmVyaWZ5IGNvbW1pdC1tc2cgaG9vayIKKyN+IG1zZ3N0ciAiY29tbWl0LW1zZyBIb29rIMO8YmVycHLDvGZlbiIKKworI34gbXNnaWQgImNhbm5vdCBjb21iaW5lICctLXJlYmFzZS1tZXJnZXMnIHdpdGggJy0tc3RyYXRlZ3ktb3B0aW9uJyIKKyN+IG1zZ3N0ciAiIgorI34gIictLXJlYmFzZS1tZXJnZXMnIGthbm4gbmljaHQgbWl0ICctLXN0cmF0ZWd5LW9wdGlvbicga29tYmluaWVydCB3ZXJkZW4uIgorCisjfiBtc2dpZCAiaW52YWxpZCBzcGFyc2UgdmFsdWUgJyVzJyIKKyN+IG1zZ3N0ciAiVW5nw7xsdGlnZXIgXCJzcGFyc2VcIi1XZXJ0ICclcycuIgorCiAjfiBtc2dpZCAiIgogI34gIkZldGNoIG5vcm1hbGx5IGluZGljYXRlcyB3aGljaCBicmFuY2hlcyBoYWQgYSBmb3JjZWQgdXBkYXRlLCBidXQgdGhhdCAiCiAjfiAiY2hlY2sgaGFzIGJlZW4gZGlzYWJsZWQuIgpkaWZmIC0tZ2l0IGEvcG8vZXMucG8gYi9wby9lcy5wbwppbmRleCA4N2M3N2ZmLi5hMDA2M2YwIDEwMDY0NAotLS0gYS9wby9lcy5wbworKysgYi9wby9lcy5wbwpAQCAtNyw4ICs3LDggQEAKIG1zZ3N0ciAiIgogIlByb2plY3QtSWQtVmVyc2lvbjogR2l0XG4iCiAiUmVwb3J0LU1zZ2lkLUJ1Z3MtVG86IEdpdCBNYWlsaW5nIExpc3QgPGdpdEB2Z2VyLmtlcm5lbC5vcmc+XG4iCi0iUE9ULUNyZWF0aW9uLURhdGU6IDIwMTktMDgtMTAgMjA6MTIrMDgwMFxuIgotIlBPLVJldmlzaW9uLURhdGU6IDIwMTktMDgtMTAgMTI6NTUtMDUwMFxuIgorIlBPVC1DcmVhdGlvbi1EYXRlOiAyMDE5LTEwLTI4IDEzOjE5KzA4MDBcbiIKKyJQTy1SZXZpc2lvbi1EYXRlOiAyMDE5LTEwLTI4IDE5OjIwLTA1MDBcbiIKICJMYXN0LVRyYW5zbGF0b3I6IGNocmlzdG9waGVyLmRpYXoucml2QGdtYWlsLmNvbVxuIgogIkxhbmd1YWdlLVRlYW06IENvZGVMYWJvcmEgPGNvZGVsYWJvcmFAZ21haWwuY29tPlxuIgogIkxhbmd1YWdlOiBlc1xuIgpAQCAtNjEsNyArNjEsNyBAQAogbXNnaWQgIkV4aXRpbmcgYmVjYXVzZSBvZiBhbiB1bnJlc29sdmVkIGNvbmZsaWN0LiIKIG1zZ3N0ciAiU2FsaWVuZG8gcG9ycXVlIGV4aXN0ZSB1biBjb25mbGljdG8gc2luIHJlc29sdmVyLiIKIAotIzogYWR2aWNlLmM6MTkzIGJ1aWx0aW4vbWVyZ2UuYzoxMzI3CisjOiBhZHZpY2UuYzoxOTMgYnVpbHRpbi9tZXJnZS5jOjEzMzIKIG1zZ2lkICJZb3UgaGF2ZSBub3QgY29uY2x1ZGVkIHlvdXIgbWVyZ2UgKE1FUkdFX0hFQUQgZXhpc3RzKS4iCiBtc2dzdHIgIk5vIGhhcyBjb25jbHVpZG8gdHUgZnVzacOzbiAoTUVSR0VfSEVBRCBleGlzdGUpLiIKIApAQCAtMjA2LDE3ICsyMDYsNyBAQAogbXNnaWQgImluY29uc2lzdGVudCBoZWFkZXIgbGluZXMgJWQgYW5kICVkIgogbXNnc3RyICJoZWFkZXIgaW5jb25zaXN0ZW50ZSBlbiBsYXMgbMOtbmVhcyAlZCB5ICVkIgogCi0jOiBhcHBseS5jOjE0NjAKLSMsIGMtZm9ybWF0Ci1tc2dpZCAicmVjb3VudDogdW5leHBlY3RlZCBsaW5lOiAlLipzIgotbXNnc3RyICJyZWNvdW50OiBsw61uZWEgaW5lc3BlcmFkYTogJS4qcyIKLQotIzogYXBwbHkuYzoxNTI5Ci0jLCBjLWZvcm1hdAotbXNnaWQgInBhdGNoIGZyYWdtZW50IHdpdGhvdXQgaGVhZGVyIGF0IGxpbmUgJWQ6ICUuKnMiCi1tc2dzdHIgImZyYWdtZW50byBkZSBwYXJjaGUgc2luIGhlYWRlciBlbiBsYSBsw61uZWEgJWQ6ICUuKnMiCi0KLSM6IGFwcGx5LmM6MTU1MQorIzogYXBwbHkuYzoxMzcyCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJnaXQgZGlmZiBoZWFkZXIgbGFja3MgZmlsZW5hbWUgaW5mb3JtYXRpb24gd2hlbiByZW1vdmluZyAlZCBsZWFkaW5nIHBhdGhuYW1lICIKQEAgLTIzMSw4MyArMjIxLDkzIEBACiAibG9zIGhlYWRlcnMgZGUgZ2l0IGRpZmYgY2FyZWNlbiBkZSBpbmZvcm1hY2nDs24gZGUgbG9zIG5vbWJyZXMgZGUgbG9zICIKICJhcmNoaXZvcyAlZCBjdWFuZG8gbG9zIGVsaW1pbmFuIGRlIGxhIHJ1dGEgcHJpbmNpcGFsIGNvbXBvbmVudGVzIChsw61uZWEgJWQpIgogCi0jOiBhcHBseS5jOjE1NjQKKyM6IGFwcGx5LmM6MTM4NQogIywgYy1mb3JtYXQKIG1zZ2lkICJnaXQgZGlmZiBoZWFkZXIgbGFja3MgZmlsZW5hbWUgaW5mb3JtYXRpb24gKGxpbmUgJWQpIgogbXNnc3RyICIiCiAiZWwgaGVhZGVyIGRlIGdpdCBkaWZmIGNhcmVjZSBkZSBpbmZvcm1hY2nDs24gZGVsIG5vbWJyZSBkZWwgYXJjaGl2byAobMOtbmVhICVkKSIKIAotIzogYXBwbHkuYzoxNzUyCisjOiBhcHBseS5jOjE0ODEKKyMsIGMtZm9ybWF0Cittc2dpZCAicmVjb3VudDogdW5leHBlY3RlZCBsaW5lOiAlLipzIgorbXNnc3RyICJyZWNvdW50OiBsw61uZWEgaW5lc3BlcmFkYTogJS4qcyIKKworIzogYXBwbHkuYzoxNTUwCisjLCBjLWZvcm1hdAorbXNnaWQgInBhdGNoIGZyYWdtZW50IHdpdGhvdXQgaGVhZGVyIGF0IGxpbmUgJWQ6ICUuKnMiCittc2dzdHIgImZyYWdtZW50byBkZSBwYXJjaGUgc2luIGhlYWRlciBlbiBsYSBsw61uZWEgJWQ6ICUuKnMiCisKKyM6IGFwcGx5LmM6MTc1MwogbXNnaWQgIm5ldyBmaWxlIGRlcGVuZHMgb24gb2xkIGNvbnRlbnRzIgogbXNnc3RyICJlbCBudWV2byBhcmNoaXZvIGRlcGVuZGUgZGUgY29udGVuaWRvcyB2aWVqb3MiCiAKLSM6IGFwcGx5LmM6MTc1NAorIzogYXBwbHkuYzoxNzU1CiBtc2dpZCAiZGVsZXRlZCBmaWxlIHN0aWxsIGhhcyBjb250ZW50cyIKIG1zZ3N0ciAiZWwgYXJjaGl2byBlbGltaW5hZG8gdG9kYXbDrWEgdGllbmUgY29udGVuaWRvIgogCi0jOiBhcHBseS5jOjE3ODgKKyM6IGFwcGx5LmM6MTc4OQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3JydXB0IHBhdGNoIGF0IGxpbmUgJWQiCiBtc2dzdHIgInBhcmNoZSBjb3JydXB0byBlbiBsYSBsw61uZWEgJWQiCiAKLSM6IGFwcGx5LmM6MTgyNQorIzogYXBwbHkuYzoxODI2CiAjLCBjLWZvcm1hdAogbXNnaWQgIm5ldyBmaWxlICVzIGRlcGVuZHMgb24gb2xkIGNvbnRlbnRzIgogbXNnc3RyICJudWV2byBhcmNoaXZvICVzIGRlcGVuZGUgZW4gY29udGVuaWRvcyB2aWVqb3MiCiAKLSM6IGFwcGx5LmM6MTgyNworIzogYXBwbHkuYzoxODI4CiAjLCBjLWZvcm1hdAogbXNnaWQgImRlbGV0ZWQgZmlsZSAlcyBzdGlsbCBoYXMgY29udGVudHMiCiBtc2dzdHIgImVsIGFyY2hpdm8gYm9ycmFkbyAlcyB0b2RhdsOtYSB0aWVuZSBjb250ZW5pZG8iCiAKLSM6IGFwcGx5LmM6MTgzMAorIzogYXBwbHkuYzoxODMxCiAjLCBjLWZvcm1hdAogbXNnaWQgIioqIHdhcm5pbmc6IGZpbGUgJXMgYmVjb21lcyBlbXB0eSBidXQgaXMgbm90IGRlbGV0ZWQiCiBtc2dzdHIgIioqIHBlbGlncm86IGVsIGFyY2hpdm8gJXMgZXN0w6EgdmFjw61vIHBlcm8gbm8gZXMgYm9ycmFkbyIKIAotIzogYXBwbHkuYzoxOTc3CisjOiBhcHBseS5jOjE5NzgKICMsIGMtZm9ybWF0CiBtc2dpZCAiY29ycnVwdCBiaW5hcnkgcGF0Y2ggYXQgbGluZSAlZDogJS4qcyIKIG1zZ3N0ciAicGFyY2hlIGJpbmFyaW8gY29ycnVwdG8gZW4gbGEgbMOtbmVhICVkOiAlLipzIgogCi0jOiBhcHBseS5jOjIwMTQKKyM6IGFwcGx5LmM6MjAxNQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bnJlY29nbml6ZWQgYmluYXJ5IHBhdGNoIGF0IGxpbmUgJWQiCiBtc2dzdHIgInBhcmNoZSBiaW5hcmlvIG5vIHJlY29ub2NpZG8gZW4gbGEgbMOtbmVhICVkIgogCi0jOiBhcHBseS5jOjIxNzYKKyM6IGFwcGx5LmM6MjE3NwogIywgYy1mb3JtYXQKIG1zZ2lkICJwYXRjaCB3aXRoIG9ubHkgZ2FyYmFnZSBhdCBsaW5lICVkIgogbXNnc3RyICJwYXJjaGUgcXVlIHNvbG8gY29udGllbmUgYmFzdXJhIGVuIGxhIGzDrW5lYSAlZCIKIAotIzogYXBwbHkuYzoyMjYyCisjOiBhcHBseS5jOjIyNjMKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHJlYWQgc3ltbGluayAlcyIKIG1zZ3N0ciAibm8gZXMgcG9zaWJsZSBsZWVyIGVsIGVubGFjZSBzaW1iw7NsaWNvICVzIgogCi0jOiBhcHBseS5jOjIyNjYKKyM6IGFwcGx5LmM6MjI2NwogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gb3BlbiBvciByZWFkICVzIgogbXNnc3RyICJubyBlcyBwb3NpYmxlIGFicmlyIG8gbGVlciAlcyIKIAotIzogYXBwbHkuYzoyOTI1CisjOiBhcHBseS5jOjI5MjYKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBzdGFydCBvZiBsaW5lOiAnJWMnIgogbXNnc3RyICJjb21pZW56byBpbnbDoWxpZG8gZGUgbMOtbmVhOiAnJWMnIgogCi0jOiBhcHBseS5jOjMwNDYKKyM6IGFwcGx5LmM6MzA0NwogIywgYy1mb3JtYXQKIG1zZ2lkICJIdW5rICMlZCBzdWNjZWVkZWQgYXQgJWQgKG9mZnNldCAlZCBsaW5lKS4iCiBtc2dpZF9wbHVyYWwgIkh1bmsgIyVkIHN1Y2NlZWRlZCBhdCAlZCAob2Zmc2V0ICVkIGxpbmVzKS4iCiBtc2dzdHJbMF0gIkh1bmsgIyVkIHR1dm8gw6l4aXRvIGVuICVkICglZCBsw61uZWEgY29tcGVuc2FkYSkuIgogbXNnc3RyWzFdICJIdW5rICMlZCB0dXZvIMOpeGl0byBlbiAlZCAoJWQgbMOtbmVhcyBjb21wZW5zYWRhcykuIgogCi0jOiBhcHBseS5jOjMwNTgKKyM6IGFwcGx5LmM6MzA1OQogIywgYy1mb3JtYXQKIG1zZ2lkICJDb250ZXh0IHJlZHVjZWQgdG8gKCVsZC8lbGQpIHRvIGFwcGx5IGZyYWdtZW50IGF0ICVkIgogbXNnc3RyICJDb250ZXh0byByZWR1Y2lkbyBhICglbGQvJWxkKSBwYXJhIGFwbGljYXIgZWwgZnJhZ21lbnRvIGVuICVkIgogCi0jOiBhcHBseS5jOjMwNjQKKyM6IGFwcGx5LmM6MzA2NQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAid2hpbGUgc2VhcmNoaW5nIGZvcjpcbiIKQEAgLTMxNiwyMyArMzE2LDIzIEBACiAibWllbnRyYXMgc2UgYnVzY2E6XG4iCiAiJS4qcyIKIAotIzogYXBwbHkuYzozMDg2CisjOiBhcHBseS5jOjMwODcKICMsIGMtZm9ybWF0CiBtc2dpZCAibWlzc2luZyBiaW5hcnkgcGF0Y2ggZGF0YSBmb3IgJyVzJyIKIG1zZ3N0ciAiZGF0YSBwZXJkaWRhIGVuIHBhcmNoZSBiaW5hcmlvIHBhcmEgJyVzJyIKIAotIzogYXBwbHkuYzozMDk0CisjOiBhcHBseS5jOjMwOTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IHJldmVyc2UtYXBwbHkgYSBiaW5hcnkgcGF0Y2ggd2l0aG91dCB0aGUgcmV2ZXJzZSBodW5rIHRvICclcyciCiBtc2dzdHIgIiIKICJubyBzZSBwdWVkZSByZXZlcnRpci1hcGxpY2FyIHVuIHBhcmNoZSBiaW5hcmlvIHNpbiBlbCBodW5rIHJldmVydGlkbyBhICclcyciCiAKLSM6IGFwcGx5LmM6MzE0MQorIzogYXBwbHkuYzozMTQyCiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCBhcHBseSBiaW5hcnkgcGF0Y2ggdG8gJyVzJyB3aXRob3V0IGZ1bGwgaW5kZXggbGluZSIKIG1zZ3N0ciAibm8gc2UgcHVlZGUgYXBsaWNhciBlbCBwYXJjaGUgYmluYXJpbyBhICclcycgc2luIHVuIMOtbmRpY2UgY29tcGxldG8iCiAKLSM6IGFwcGx5LmM6MzE1MQorIzogYXBwbHkuYzozMTUyCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJ0aGUgcGF0Y2ggYXBwbGllcyB0byAnJXMnICglcyksIHdoaWNoIGRvZXMgbm90IG1hdGNoIHRoZSBjdXJyZW50IGNvbnRlbnRzLiIKQEAgLTM0MCwyODkgKzM0MCwyODkgQEAKICJlbCBwYXJjaGUgYXBsaWNhIGEgJyVzJyAoJXMpLCBsbyBjdWFsIG5vIGNvbmN1ZXJkYSBjb24gbG9zIGNvbnRlbmlkb3MgIgogImFjdHVhbGVzLiIKIAotIzogYXBwbHkuYzozMTU5CisjOiBhcHBseS5jOjMxNjAKICMsIGMtZm9ybWF0CiBtc2dpZCAidGhlIHBhdGNoIGFwcGxpZXMgdG8gYW4gZW1wdHkgJyVzJyBidXQgaXQgaXMgbm90IGVtcHR5IgogbXNnc3RyICJlbCBwYXJjaGUgYXBsaWNhIGEgdW4gJyVzJyB2YWPDrW8sIHBlcm8gZXN0ZSBubyBsbyBlc3RhIgogCi0jOiBhcHBseS5jOjMxNzcKKyM6IGFwcGx5LmM6MzE3OAogIywgYy1mb3JtYXQKIG1zZ2lkICJ0aGUgbmVjZXNzYXJ5IHBvc3RpbWFnZSAlcyBmb3IgJyVzJyBjYW5ub3QgYmUgcmVhZCIKIG1zZ3N0ciAibGEgcG9zdGltYWdlbiBuZWNlc2FyaWEgJXMgcGFyYSAnJXMnIG5vIHNlIHB1ZWRlIGxlZXIiCiAKLSM6IGFwcGx5LmM6MzE5MAorIzogYXBwbHkuYzozMTkxCiAjLCBjLWZvcm1hdAogbXNnaWQgImJpbmFyeSBwYXRjaCBkb2VzIG5vdCBhcHBseSB0byAnJXMnIgogbXNnc3RyICJlbCBwYXJjaGUgYmluYXJpbyBubyBhcGxpY2EgcGFyYSAnJXMnIgogCi0jOiBhcHBseS5jOjMxOTYKKyM6IGFwcGx5LmM6MzE5NwogIywgYy1mb3JtYXQKIG1zZ2lkICJiaW5hcnkgcGF0Y2ggdG8gJyVzJyBjcmVhdGVzIGluY29ycmVjdCByZXN1bHQgKGV4cGVjdGluZyAlcywgZ290ICVzKSIKIG1zZ3N0ciAiIgogImVsIHBhcmNoZSBiaW5hcmlvIHBhcmEgJyVzJyBjcmVhIHVuIHJlc3VsdGFkbyBpbmNvcnJlY3RvIChzYWxpZW5kbyAlcywgc2UgIgogIm9idHV2byAlcykiCiAKLSM6IGFwcGx5LmM6MzIxNworIzogYXBwbHkuYzozMjE4CiAjLCBjLWZvcm1hdAogbXNnaWQgInBhdGNoIGZhaWxlZDogJXM6JWxkIgogbXNnc3RyICJlbCBwYXJjaGUgZmFsbMOzOiAlczolbGQiCiAKLSM6IGFwcGx5LmM6MzM0MAorIzogYXBwbHkuYzozMzQxCiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCBjaGVja291dCAlcyIKIG1zZ3N0ciAibm8gc2UgcHVlZGUgaGFjZXIgY2hlY2tvdXQgYSAlcyIKIAotIzogYXBwbHkuYzozMzkyIGFwcGx5LmM6MzQwMyBhcHBseS5jOjM0NDkgbWlkeC5jOjYyIHNldHVwLmM6Mjc5CisjOiBhcHBseS5jOjMzOTMgYXBwbHkuYzozNDA0IGFwcGx5LmM6MzQ1MCBtaWR4LmM6NjEgc2V0dXAuYzoyODAKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIHJlYWQgJXMiCiBtc2dzdHIgIm5vIHNlIHB1ZG8gbGVlciAlcyIKIAotIzogYXBwbHkuYzozNDAwCisjOiBhcHBseS5jOjM0MDEKICMsIGMtZm9ybWF0CiBtc2dpZCAicmVhZGluZyBmcm9tICclcycgYmV5b25kIGEgc3ltYm9saWMgbGluayIKIG1zZ3N0ciAibGV5ZW5kbyBkZSAnJXMnIHRyYXMgdW4gZW5sYWNlIHNpbWLDs2xpY28iCiAKLSM6IGFwcGx5LmM6MzQyOSBhcHBseS5jOjM2NzIKKyM6IGFwcGx5LmM6MzQzMCBhcHBseS5jOjM2NzMKICMsIGMtZm9ybWF0CiBtc2dpZCAicGF0aCAlcyBoYXMgYmVlbiByZW5hbWVkL2RlbGV0ZWQiCiBtc2dzdHIgImxhIHJ1dGEgJXMgaGEgc2lkbyByZW5vbWJyYWRhL3N1cHJpbWlkYSIKIAotIzogYXBwbHkuYzozNTE1IGFwcGx5LmM6MzY4NworIzogYXBwbHkuYzozNTE2IGFwcGx5LmM6MzY4OAogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogZG9lcyBub3QgZXhpc3QgaW4gaW5kZXgiCiBtc2dzdHIgIiVzOiBubyBleGlzdGUgZW4gZWwgw61uZGljZSIKIAotIzogYXBwbHkuYzozNTI0IGFwcGx5LmM6MzY5NQorIzogYXBwbHkuYzozNTI1IGFwcGx5LmM6MzY5NgogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogZG9lcyBub3QgbWF0Y2ggaW5kZXgiCiBtc2dzdHIgIiVzOiBubyBjb25jdWVyZGEgY29uIGVsIMOtbmRpY2UiCiAKLSM6IGFwcGx5LmM6MzU1OQorIzogYXBwbHkuYzozNTYwCiBtc2dpZCAicmVwb3NpdG9yeSBsYWNrcyB0aGUgbmVjZXNzYXJ5IGJsb2IgdG8gZmFsbCBiYWNrIG9uIDMtd2F5IG1lcmdlLiIKIG1zZ3N0ciAiIgogImVsIHJlcG9zaXRvcmlvIGNhcmVjZSBkZWwgYmxvYiBuZWNlc2FyaW8gcGFyYSByZWdyZXNhciBlbiB1biBtZXJnZSBkZSB0cmVzLSIKICJ2w61hcy4iCiAKLSM6IGFwcGx5LmM6MzU2MgorIzogYXBwbHkuYzozNTYzCiAjLCBjLWZvcm1hdAogbXNnaWQgIkZhbGxpbmcgYmFjayB0byB0aHJlZS13YXkgbWVyZ2UuLi5cbiIKIG1zZ3N0ciAiUmV0cm9jZWRpZW5kbyBlbiB1biBtZXJnZSBkZSB0cmVzLXbDrWFzLi4uXG4iCiAKLSM6IGFwcGx5LmM6MzU3OCBhcHBseS5jOjM1ODIKKyM6IGFwcGx5LmM6MzU3OSBhcHBseS5jOjM1ODMKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IHJlYWQgdGhlIGN1cnJlbnQgY29udGVudHMgb2YgJyVzJyIKIG1zZ3N0ciAibm8gc2UgcHVlZGVuIGxlZXIgbG9zIGNvbnRlbmlkb3MgYWN0dWFsZXMgZGUgJyVzJyIKIAotIzogYXBwbHkuYzozNTk0CisjOiBhcHBseS5jOjM1OTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiRmFpbGVkIHRvIGZhbGwgYmFjayBvbiB0aHJlZS13YXkgbWVyZ2UuLi5cbiIKIG1zZ3N0ciAiRmFsbMOzIGVsIG1lcmdlIGVuIHJldHJvY2VzbyBkZSB0cmVzLXbDrWFzLi4uXG4iCiAKLSM6IGFwcGx5LmM6MzYwOAorIzogYXBwbHkuYzozNjA5CiAjLCBjLWZvcm1hdAogbXNnaWQgIkFwcGxpZWQgcGF0Y2ggdG8gJyVzJyB3aXRoIGNvbmZsaWN0cy5cbiIKIG1zZ3N0ciAiUGFyY2hlIGFwbGljYWRvIGEgJyVzJyBjb24gY29uZmxpY3Rvcy5cbiIKIAotIzogYXBwbHkuYzozNjEzCisjOiBhcHBseS5jOjM2MTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiQXBwbGllZCBwYXRjaCB0byAnJXMnIGNsZWFubHkuXG4iCiBtc2dzdHIgIlBhcmNoZSBhcGxpY2FkbyBhICclcycgbGltcGlhbWVudGVcbiIKIAotIzogYXBwbHkuYzozNjM5CisjOiBhcHBseS5jOjM2NDAKIG1zZ2lkICJyZW1vdmFsIHBhdGNoIGxlYXZlcyBmaWxlIGNvbnRlbnRzIgotbXNnc3RyICJwYXJjaGUgZGUgcmVtb2Npw7NuIGRlamEgY29udGVuaWRvcyBlbiBlbCBhcmNoaXZvIgorbXNnc3RyICJwYXJjaGUgZGUgZWxpbWluYWNpw7NuIGRlamEgY29udGVuaWRvcyBlbiBlbCBhcmNoaXZvIgogCi0jOiBhcHBseS5jOjM3MTIKKyM6IGFwcGx5LmM6MzcxMwogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogd3JvbmcgdHlwZSIKIG1zZ3N0ciAiJXM6IHRpcG8gaW5jb3JyZWN0byIKIAotIzogYXBwbHkuYzozNzE0CisjOiBhcHBseS5jOjM3MTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgaGFzIHR5cGUgJW8sIGV4cGVjdGVkICVvIgogbXNnc3RyICIlcyB0aWVuZSB0aXBvICVvLCBzZSBlc3BlcmFiYSAlbyIKIAotIzogYXBwbHkuYzozODY1IGFwcGx5LmM6Mzg2NyByZWFkLWNhY2hlLmM6ODMwIHJlYWQtY2FjaGUuYzo4NTYKKyM6IGFwcGx5LmM6Mzg2NiBhcHBseS5jOjM4NjggcmVhZC1jYWNoZS5jOjgzMCByZWFkLWNhY2hlLmM6ODU2CiAjOiByZWFkLWNhY2hlLmM6MTMwOQogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIHBhdGggJyVzJyIKIG1zZ3N0ciAicnV0YSBpbnbDoWxpZGEgJyVzJyIKIAotIzogYXBwbHkuYzozOTIzCisjOiBhcHBseS5jOjM5MjQKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXM6IGFscmVhZHkgZXhpc3RzIGluIGluZGV4IgogbXNnc3RyICIlczogeWEgZXhpc3RlIGVuIGVsIMOtbmRpY2UiCiAKLSM6IGFwcGx5LmM6MzkyNgorIzogYXBwbHkuYzozOTI3CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiBhbHJlYWR5IGV4aXN0cyBpbiB3b3JraW5nIGRpcmVjdG9yeSIKIG1zZ3N0ciAiJXM6IHlhIGV4aXN0ZSBlbiBlbCBkaXJlY3RvcmlvIGRlIHRyYWJham8iCiAKLSM6IGFwcGx5LmM6Mzk0NgorIzogYXBwbHkuYzozOTQ3CiAjLCBjLWZvcm1hdAogbXNnaWQgIm5ldyBtb2RlICglbykgb2YgJXMgZG9lcyBub3QgbWF0Y2ggb2xkIG1vZGUgKCVvKSIKIG1zZ3N0ciAibnVldm8gbW9kbyAoJW8pIGRlICVzIG5vIGNvbmN1ZXJkYSBjb24gZWwgdmllam8gbW9kbyAoJW8pIgogCi0jOiBhcHBseS5jOjM5NTEKKyM6IGFwcGx5LmM6Mzk1MgogIywgYy1mb3JtYXQKIG1zZ2lkICJuZXcgbW9kZSAoJW8pIG9mICVzIGRvZXMgbm90IG1hdGNoIG9sZCBtb2RlICglbykgb2YgJXMiCiBtc2dzdHIgIm51ZXZvIG1vZG8gKCVvKSBkZSAlcyBubyBjb25jdWVyZGEgY29uIGVsIHZpZWpvIG1vZG8gKCVvKSBkZSAlcyIKIAotIzogYXBwbHkuYzozOTcxCisjOiBhcHBseS5jOjM5NzIKICMsIGMtZm9ybWF0CiBtc2dpZCAiYWZmZWN0ZWQgZmlsZSAnJXMnIGlzIGJleW9uZCBhIHN5bWJvbGljIGxpbmsiCiBtc2dzdHIgImFyY2hpdm8gYWZlY3RhZG8gJyVzJyBlc3TDoSB0cmFzIHVuIGVubGFjZSBzaW1iw7NsaWNvIgogCi0jOiBhcHBseS5jOjM5NzUKKyM6IGFwcGx5LmM6Mzk3NgogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogcGF0Y2ggZG9lcyBub3QgYXBwbHkiCiBtc2dzdHIgIiVzOiBlbCBwYXJjaGUgbm8gYXBsaWNhIgogCi0jOiBhcHBseS5jOjM5OTAKKyM6IGFwcGx5LmM6Mzk5MQogIywgYy1mb3JtYXQKIG1zZ2lkICJDaGVja2luZyBwYXRjaCAlcy4uLiIKIG1zZ3N0ciAiUmV2aXNhbmRvIGVsIHBhcmNoZSAlcy4uLiIKIAotIzogYXBwbHkuYzo0MDgyCisjOiBhcHBseS5jOjQwODMKICMsIGMtZm9ybWF0CiBtc2dpZCAic2hhMSBpbmZvcm1hdGlvbiBpcyBsYWNraW5nIG9yIHVzZWxlc3MgZm9yIHN1Ym1vZHVsZSAlcyIKIG1zZ3N0ciAiZmFsdGEgaW5mb3JtYWNpw7NuIGRlbCBzaGExIG8gZXMgaW7DunRpbCBwYXJhIGVsIHN1Ym3Ds2R1bG8gJXMiCiAKLSM6IGFwcGx5LmM6NDA4OQorIzogYXBwbHkuYzo0MDkwCiAjLCBjLWZvcm1hdAogbXNnaWQgIm1vZGUgY2hhbmdlIGZvciAlcywgd2hpY2ggaXMgbm90IGluIGN1cnJlbnQgSEVBRCIKIG1zZ3N0ciAibW9kbyBjYW1iaWFkbyBwYXJhICVzLCBlbCBjdWFsIG5vIHNlIGVuY3VlbnRyYSBlbiBlbCBIRUFEIGFjdHVhbCIKIAotIzogYXBwbHkuYzo0MDkyCisjOiBhcHBseS5jOjQwOTMKICMsIGMtZm9ybWF0CiBtc2dpZCAic2hhMSBpbmZvcm1hdGlvbiBpcyBsYWNraW5nIG9yIHVzZWxlc3MgKCVzKS4iCiBtc2dzdHIgImZhbHRhIGluZm9ybWFjacOzbiBzaGExIG8gZXMgaW7DunRpbCAoJXMpLiIKIAotIzogYXBwbHkuYzo0MDk3IGJ1aWx0aW4vY2hlY2tvdXQuYzoyNzggYnVpbHRpbi9yZXNldC5jOjE0MworIzogYXBwbHkuYzo0MDk4IGJ1aWx0aW4vY2hlY2tvdXQuYzoyNzkgYnVpbHRpbi9yZXNldC5jOjE0MwogIywgYy1mb3JtYXQKIG1zZ2lkICJtYWtlX2NhY2hlX2VudHJ5IGZhaWxlZCBmb3IgcGF0aCAnJXMnIgogbXNnc3RyICJtYWtlX2NhY2hlX2VudHJ5IGZhbGzDsyBwYXJhIGxhIHJ1dGEgJyVzJyIKIAotIzogYXBwbHkuYzo0MTAxCisjOiBhcHBseS5jOjQxMDIKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGFkZCAlcyB0byB0ZW1wb3JhcnkgaW5kZXgiCiBtc2dzdHIgIm5vIHNlIHB1ZG8gYcOxYWRpciAlcyBhbCDDrW5kaWNlIHRlbXBvcmFsIgogCi0jOiBhcHBseS5jOjQxMTEKKyM6IGFwcGx5LmM6NDExMgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3Qgd3JpdGUgdGVtcG9yYXJ5IGluZGV4IHRvICVzIgogbXNnc3RyICJubyBzZSBwdWRvIGVzY3JpYmlyIHVuIMOtbmRpY2UgdGVtcG9yYWwgcGFyYSAlcyIKIAotIzogYXBwbHkuYzo0MjQ5CisjOiBhcHBseS5jOjQyNTAKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHJlbW92ZSAlcyBmcm9tIGluZGV4IgogbXNnc3RyICJubyBzZSBwdWVkZSBlbGltaW5hciAlcyBkZWwgw61uZGljZSIKIAotIzogYXBwbHkuYzo0MjgzCisjOiBhcHBseS5jOjQyODQKICMsIGMtZm9ybWF0CiBtc2dpZCAiY29ycnVwdCBwYXRjaCBmb3Igc3VibW9kdWxlICVzIgogbXNnc3RyICJwYXJjaGUgY29ycnVwdG8gcGFyYSBlbCBzdWJtw7NkdWxvICVzIgogCi0jOiBhcHBseS5jOjQyODkKKyM6IGFwcGx5LmM6NDI5MAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gc3RhdCBuZXdseSBjcmVhdGVkIGZpbGUgJyVzJyIKIG1zZ3N0ciAibm8gZXMgcG9zaWJsZSBlc3RhYmxlY2VyIGVsIGFyY2hpdm8gcmVjacOpbiBjcmVhZG8gJyVzJyIKIAotIzogYXBwbHkuYzo0Mjk3CisjOiBhcHBseS5jOjQyOTgKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGNyZWF0ZSBiYWNraW5nIHN0b3JlIGZvciBuZXdseSBjcmVhdGVkIGZpbGUgJXMiCiBtc2dzdHIgIiIKICJubyBlcyBwb3NpYmxlIGNyZWFyIHVuYSBjb3BpYSBkZSBzZWd1cmlkYWQgcGFyYSBlbCBhcmNoaXZvIHJlY2nDqW4gY3JlYWRvICVzIgogCi0jOiBhcHBseS5jOjQzMDMgYXBwbHkuYzo0NDQ4CisjOiBhcHBseS5jOjQzMDQgYXBwbHkuYzo0NDQ5CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBhZGQgY2FjaGUgZW50cnkgZm9yICVzIgogbXNnc3RyICJubyBlcyBwb3NpYmxlIGFncmVnYXIgdW5hIGVudHJhZGEgZW4gZWwgY2FjaGUgcGFyYSAlcyIKIAotIzogYXBwbHkuYzo0MzQ2CisjOiBhcHBseS5jOjQzNDcKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIHdyaXRlIHRvICclcyciCiBtc2dzdHIgImZhbGzDsyBlc2NyaWJpciBwYXJhICclcyciCiAKLSM6IGFwcGx5LmM6NDM1MAorIzogYXBwbHkuYzo0MzUxCiAjLCBjLWZvcm1hdAogbXNnaWQgImNsb3NpbmcgZmlsZSAnJXMnIgogbXNnc3RyICJjZXJyYW5kbyBhcmNoaXZvICclcyciCiAKLSM6IGFwcGx5LmM6NDQyMAorIzogYXBwbHkuYzo0NDIxCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byB3cml0ZSBmaWxlICclcycgbW9kZSAlbyIKIG1zZ3N0ciAibm8gZXMgcG9zaWJsZSBlc2NyaWJpciBlbCBhcmNoaXZvICclcycgbW9kbyAlbyIKIAotIzogYXBwbHkuYzo0NTE4CisjOiBhcHBseS5jOjQ1MTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiQXBwbGllZCBwYXRjaCAlcyBjbGVhbmx5LiIKIG1zZ3N0ciAiUGFyY2hlICVzIGFwbGljYWRvIGxpbXBpYW1lbnRlLiIKIAotIzogYXBwbHkuYzo0NTI2CisjOiBhcHBseS5jOjQ1MjcKIG1zZ2lkICJpbnRlcm5hbCBlcnJvciIKIG1zZ3N0ciAiZXJyb3IgaW50ZXJubyIKIAotIzogYXBwbHkuYzo0NTI5CisjOiBhcHBseS5jOjQ1MzAKICMsIGMtZm9ybWF0CiBtc2dpZCAiQXBwbHlpbmcgcGF0Y2ggJSVzIHdpdGggJWQgcmVqZWN0Li4uIgogbXNnaWRfcGx1cmFsICJBcHBseWluZyBwYXRjaCAlJXMgd2l0aCAlZCByZWplY3RzLi4uIgogbXNnc3RyWzBdICJBcGxpY2FuZG8gcGFyY2hlICUlcyBjb24gJWQgcmVjaGF6by4uLiIKIG1zZ3N0clsxXSAiQXBsaWNhbmRvIHBhcmNoZSAlJXMgY29uICVkIHJlY2hhem9zLi4uIgogCi0jOiBhcHBseS5jOjQ1NDAKKyM6IGFwcGx5LmM6NDU0MQogIywgYy1mb3JtYXQKIG1zZ2lkICJ0cnVuY2F0aW5nIC5yZWogZmlsZW5hbWUgdG8gJS4qcy5yZWoiCiBtc2dzdHIgInRydW5jYW5kbyBlbCBub21icmUgZGUgYXJjaGl2byAucmVqIGEgJS4qcy5yZWoiCiAKLSM6IGFwcGx5LmM6NDU0OCBidWlsdGluL2ZldGNoLmM6ODc4IGJ1aWx0aW4vZmV0Y2guYzoxMTY4CisjOiBhcHBseS5jOjQ1NDkgYnVpbHRpbi9mZXRjaC5jOjg5OCBidWlsdGluL2ZldGNoLmM6MTE5NAogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3Qgb3BlbiAlcyIKIG1zZ3N0ciAibm8gc2UgcHVlZGUgYWJyaXIgJXMiCiAKLSM6IGFwcGx5LmM6NDU2MgorIzogYXBwbHkuYzo0NTYzCiAjLCBjLWZvcm1hdAogbXNnaWQgIkh1bmsgIyVkIGFwcGxpZWQgY2xlYW5seS4iCiBtc2dzdHIgIkh1bmsgIyVkIGFwbGljYWRvIGxpbXBpYW1lbnRlLiIKIAotIzogYXBwbHkuYzo0NTY2CisjOiBhcHBseS5jOjQ1NjcKICMsIGMtZm9ybWF0CiBtc2dpZCAiUmVqZWN0ZWQgaHVuayAjJWQuIgogbXNnc3RyICJIdW5rICMlZCByZWNoYXphZG8uIgogCi0jOiBhcHBseS5jOjQ2NzYKKyM6IGFwcGx5LmM6NDY4NgogIywgYy1mb3JtYXQKIG1zZ2lkICJTa2lwcGVkIHBhdGNoICclcycuIgogbXNnc3RyICJQYXJjaGUgJyVzJyBzYWx0YWRvLiIKIAotIzogYXBwbHkuYzo0Njg0CisjOiBhcHBseS5jOjQ2OTQKIG1zZ2lkICJ1bnJlY29nbml6ZWQgaW5wdXQiCiBtc2dzdHIgImlucHV0IG5vIHJlY29ub2NpZG8iCiAKLSM6IGFwcGx5LmM6NDcwNAorIzogYXBwbHkuYzo0NzE0CiBtc2dpZCAidW5hYmxlIHRvIHJlYWQgaW5kZXggZmlsZSIKIG1zZ3N0ciAibm8gZXMgcG9zaWJsZSBsZWVyIGVsIGFyY2hpdm8gw61uZGljZSIKIAotIzogYXBwbHkuYzo0ODU5CisjOiBhcHBseS5jOjQ4NzEKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2FuJ3Qgb3BlbiBwYXRjaCAnJXMnOiAlcyIKIG1zZ3N0ciAibm8gc2UgcHVlZGUgYWJyaXIgZWwgcGFyY2hlICclcyc6ICVzIgogCi0jOiBhcHBseS5jOjQ4ODYKKyM6IGFwcGx5LmM6NDg5OAogIywgYy1mb3JtYXQKIG1zZ2lkICJzcXVlbGNoZWQgJWQgd2hpdGVzcGFjZSBlcnJvciIKIG1zZ2lkX3BsdXJhbCAic3F1ZWxjaGVkICVkIHdoaXRlc3BhY2UgZXJyb3JzIgogbXNnc3RyWzBdICIlZCBlcnJvciBkZSBlc3BhY2lvcyBlbiBibGFuY28gYXBsYXN0YWRvIgogbXNnc3RyWzFdICIlZCBlcnJvcmVzIGRlIGVzcGFjaW9zIGVuIGJsYW5jbyBhcGxhc3RhZG9zIgogCi0jOiBhcHBseS5jOjQ4OTIgYXBwbHkuYzo0OTA3CisjOiBhcHBseS5jOjQ5MDQgYXBwbHkuYzo0OTE5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVkIGxpbmUgYWRkcyB3aGl0ZXNwYWNlIGVycm9ycy4iCiBtc2dpZF9wbHVyYWwgIiVkIGxpbmVzIGFkZCB3aGl0ZXNwYWNlIGVycm9ycy4iCiBtc2dzdHJbMF0gIiVkIGzDrW5lYSBhZ3JlZ2EgZXJyb3JlcyBkZSBlc3BhY2lvcyBlbiBibGFuY28uIgogbXNnc3RyWzFdICIlZCBsw61uZWFzIGFncmVnYW4gZXJyb3JlcyBkZSBlc3BhY2lvcyBlbiBibGFuY28uIgogCi0jOiBhcHBseS5jOjQ5MDAKKyM6IGFwcGx5LmM6NDkxMgogIywgYy1mb3JtYXQKIG1zZ2lkICIlZCBsaW5lIGFwcGxpZWQgYWZ0ZXIgZml4aW5nIHdoaXRlc3BhY2UgZXJyb3JzLiIKIG1zZ2lkX3BsdXJhbCAiJWQgbGluZXMgYXBwbGllZCBhZnRlciBmaXhpbmcgd2hpdGVzcGFjZSBlcnJvcnMuIgpAQCAtNjMxLDE0NiArNjMxLDE0NiBAQAogbXNnc3RyWzFdICIiCiAiJWQgbMOtbmVhcyBhcGxpY2FkYXMgZGVzcHXDqXMgZGUgYXJyZWdsYXIgbG9zIGVycm9yZXMgZGUgZXNwYWNpb3MgZW4gYmxhbmNvLiIKIAotIzogYXBwbHkuYzo0OTE2IGJ1aWx0aW4vYWRkLmM6NTQwIGJ1aWx0aW4vbXYuYzozMDEgYnVpbHRpbi9ybS5jOjM5MAorIzogYXBwbHkuYzo0OTI4IGJ1aWx0aW4vYWRkLmM6NTQwIGJ1aWx0aW4vbXYuYzozMDEgYnVpbHRpbi9ybS5jOjM5MAogbXNnaWQgIlVuYWJsZSB0byB3cml0ZSBuZXcgaW5kZXggZmlsZSIKIG1zZ3N0ciAiTm8gZXMgcG9zaWJsZSBlc2NyaWJpciBlbCBhcmNoaXZvIMOtbmRpY2UiCiAKLSM6IGFwcGx5LmM6NDk0MyBhcHBseS5jOjQ5NDYgYnVpbHRpbi9hbS5jOjIyMDggYnVpbHRpbi9hbS5jOjIyMTEKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMjMgYnVpbHRpbi9mZXRjaC5jOjEyOCBidWlsdGluL21lcmdlLmM6MjczCi0jOiBidWlsdGluL3B1bGwuYzoyMDggYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjQwNworIzogYXBwbHkuYzo0OTU1IGFwcGx5LmM6NDk1OCBidWlsdGluL2FtLmM6MjE5NyBidWlsdGluL2FtLmM6MjIwMAorIzogYnVpbHRpbi9jbG9uZS5jOjEyMiBidWlsdGluL2ZldGNoLmM6MTQzIGJ1aWx0aW4vbWVyZ2UuYzoyNzMKKyM6IGJ1aWx0aW4vcHVsbC5jOjIwOSBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6NDA3CiAjOiBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6MTM2NyBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6MTM3MAogIzogYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjE4NTAgYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjE4NTMKICM6IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoyMDkyIGdpdC1hZGQtLWludGVyYWN0aXZlLnBlcmw6MjExCiBtc2dpZCAicGF0aCIKIG1zZ3N0ciAicnV0YSIKIAotIzogYXBwbHkuYzo0OTQ0CisjOiBhcHBseS5jOjQ5NTYKIG1zZ2lkICJkb24ndCBhcHBseSBjaGFuZ2VzIG1hdGNoaW5nIHRoZSBnaXZlbiBwYXRoIgogbXNnc3RyICJubyBhcGxpY2FyIGNhbWJpb3MgcXVlIGNvbmN1ZXJkZW4gY29uIGxhIHJ1dGEgc3VtaW5pc3RyYWRhIgogCi0jOiBhcHBseS5jOjQ5NDcKKyM6IGFwcGx5LmM6NDk1OQogbXNnaWQgImFwcGx5IGNoYW5nZXMgbWF0Y2hpbmcgdGhlIGdpdmVuIHBhdGgiCiBtc2dzdHIgImFwbGljYXIgY2FtYmlvcyBxdWUgY29uY3VlcmRlbiBjb24gbGEgcnV0YSBzdW1pbmlzdHJhZGEiCiAKLSM6IGFwcGx5LmM6NDk0OSBidWlsdGluL2FtLmM6MjIxNworIzogYXBwbHkuYzo0OTYxIGJ1aWx0aW4vYW0uYzoyMjA2CiBtc2dpZCAibnVtIgogbXNnc3RyICJudW0iCiAKLSM6IGFwcGx5LmM6NDk1MAorIzogYXBwbHkuYzo0OTYyCiBtc2dpZCAicmVtb3ZlIDxudW0+IGxlYWRpbmcgc2xhc2hlcyBmcm9tIHRyYWRpdGlvbmFsIGRpZmYgcGF0aHMiCiBtc2dzdHIgImVsaW1pbmFyIDxudW0+IHNsYXNoZXMgaW5pY2lhbGVzIGRlIGxhcyBydXRhcyBkaWZmIHRyYWRpY2lvbmFsZXMiCiAKLSM6IGFwcGx5LmM6NDk1MworIzogYXBwbHkuYzo0OTY1CiBtc2dpZCAiaWdub3JlIGFkZGl0aW9ucyBtYWRlIGJ5IHRoZSBwYXRjaCIKIG1zZ3N0ciAiaWdub3JhciBhZGljaW9uZXMgaGVjaGFzIHBvciBlbCBwYXJjaGUiCiAKLSM6IGFwcGx5LmM6NDk1NQorIzogYXBwbHkuYzo0OTY3CiBtc2dpZCAiaW5zdGVhZCBvZiBhcHBseWluZyB0aGUgcGF0Y2gsIG91dHB1dCBkaWZmc3RhdCBmb3IgdGhlIGlucHV0IgogbXNnc3RyICJlbiBsdWdhciBkZSBhcGxpY2FyIGVsIHBhcmNoZSwgbW9zdHJhciBkaWZmc3RhdCBwYXJhIGxhIGVudHJhZGEiCiAKLSM6IGFwcGx5LmM6NDk1OQorIzogYXBwbHkuYzo0OTcxCiBtc2dpZCAic2hvdyBudW1iZXIgb2YgYWRkZWQgYW5kIGRlbGV0ZWQgbGluZXMgaW4gZGVjaW1hbCBub3RhdGlvbiIKIG1zZ3N0ciAibW9zdHJhciBlbCBudW1lcm8gZGUgbMOtbmVhcyBhZ3JlZ2FkYXMgeSBlbGltaW5hZGFzIGVuIG5vdGFjacOzbiBkZWNpbWFsIgogCi0jOiBhcHBseS5jOjQ5NjEKKyM6IGFwcGx5LmM6NDk3MwogbXNnaWQgImluc3RlYWQgb2YgYXBwbHlpbmcgdGhlIHBhdGNoLCBvdXRwdXQgYSBzdW1tYXJ5IGZvciB0aGUgaW5wdXQiCiBtc2dzdHIgImVuIGx1Z2FyIGRlIGFwbGljYXIgZWwgcGFyY2hlLCBtb3N0cmFyIHVuIHJlc3VtZW4gcGFyYSBsYSBlbnRyYWRhIgogCi0jOiBhcHBseS5jOjQ5NjMKKyM6IGFwcGx5LmM6NDk3NQogbXNnaWQgImluc3RlYWQgb2YgYXBwbHlpbmcgdGhlIHBhdGNoLCBzZWUgaWYgdGhlIHBhdGNoIGlzIGFwcGxpY2FibGUiCiBtc2dzdHIgImVuIGx1Z2FyIGRlIGFwbGljYXIgZWwgcGFyY2hlLCB2ZXIgc2kgZWwgcGFyY2hlIGVzIGFwbGljYWJsZSIKIAotIzogYXBwbHkuYzo0OTY1CisjOiBhcHBseS5jOjQ5NzcKIG1zZ2lkICJtYWtlIHN1cmUgdGhlIHBhdGNoIGlzIGFwcGxpY2FibGUgdG8gdGhlIGN1cnJlbnQgaW5kZXgiCiBtc2dzdHIgImFzZWd1cmFyIHF1ZSBlbCBwYXJjaGUgZXMgYXBsaWNhYmxlIGFsIMOtbmRpY2UgYWN0dWFsIgogCi0jOiBhcHBseS5jOjQ5NjcKKyM6IGFwcGx5LmM6NDk3OQogbXNnaWQgIm1hcmsgbmV3IGZpbGVzIHdpdGggYGdpdCBhZGQgLS1pbnRlbnQtdG8tYWRkYCIKIG1zZ3N0ciAibWFyY2EgbG9zIG51ZXZvcyBhcmNoaXZvcyBjb24gYGdpdCBhZGQgLS1pbnRlbnQtdG8tYWRkYCIKIAotIzogYXBwbHkuYzo0OTY5CisjOiBhcHBseS5jOjQ5ODEKIG1zZ2lkICJhcHBseSBhIHBhdGNoIHdpdGhvdXQgdG91Y2hpbmcgdGhlIHdvcmtpbmcgdHJlZSIKIG1zZ3N0ciAiYXBsaWNhciB1biBwYXJjaGUgc2luIHRvY2FyIGVsIMOhcmJvbCBkZSB0cmFiYWpvIgogCi0jOiBhcHBseS5jOjQ5NzEKKyM6IGFwcGx5LmM6NDk4MwogbXNnaWQgImFjY2VwdCBhIHBhdGNoIHRoYXQgdG91Y2hlcyBvdXRzaWRlIHRoZSB3b3JraW5nIGFyZWEiCiBtc2dzdHIgImFjZXB0YXIgdW4gcGFyY2hlIHF1ZSB0b2NhIGZ1ZXJhIGRlbCDDoXJlYSBkZSB0cmFiYWpvIgogCi0jOiBhcHBseS5jOjQ5NzQKKyM6IGFwcGx5LmM6NDk4NgogbXNnaWQgImFsc28gYXBwbHkgdGhlIHBhdGNoICh1c2Ugd2l0aCAtLXN0YXQvLS1zdW1tYXJ5Ly0tY2hlY2spIgogbXNnc3RyICJ0YW1iacOpbiBhcGxpY2FyIGVsIHBhcmNoZSAoIHVzYXIgY29uIC0tc3RhdC8tLXN1bW1hcnkvLS1jaGVjayIKIAotIzogYXBwbHkuYzo0OTc2CisjOiBhcHBseS5jOjQ5ODgKIG1zZ2lkICJhdHRlbXB0IHRocmVlLXdheSBtZXJnZSBpZiBhIHBhdGNoIGRvZXMgbm90IGFwcGx5IgogbXNnc3RyICJpbnRlbnRhciBtZXJnZSBkZSB0cmVzLXbDrWFzIHNpIGVsIHBhcmNoZSBubyBhcGxpY2EiCiAKLSM6IGFwcGx5LmM6NDk3OAorIzogYXBwbHkuYzo0OTkwCiBtc2dpZCAiYnVpbGQgYSB0ZW1wb3JhcnkgaW5kZXggYmFzZWQgb24gZW1iZWRkZWQgaW5kZXggaW5mb3JtYXRpb24iCiBtc2dzdHIgIiIKICJjb25zdHJ1aXIgdW4gw61uZGljZSB0ZW1wb3JhbCBiYXNhZG8gZW4gbGEgaW5mb3JtYWNpw7NuIGRlbCDDrW5kaWNlIGluY3J1c3RhZG8iCiAKLSM6IGFwcGx5LmM6NDk4MSBidWlsdGluL2NoZWNrb3V0LWluZGV4LmM6MTczIGJ1aWx0aW4vbHMtZmlsZXMuYzo1MjQKKyM6IGFwcGx5LmM6NDk5MyBidWlsdGluL2NoZWNrb3V0LWluZGV4LmM6MTczIGJ1aWx0aW4vbHMtZmlsZXMuYzo1MjQKIG1zZ2lkICJwYXRocyBhcmUgc2VwYXJhdGVkIHdpdGggTlVMIGNoYXJhY3RlciIKIG1zZ3N0ciAicnV0YXMgZXN0w6FuIHNlcGFyYWRhcyBjb24gdW4gY2Fyw6FjdGVyIE5VTEwiCiAKLSM6IGFwcGx5LmM6NDk4MworIzogYXBwbHkuYzo0OTk1CiBtc2dpZCAiZW5zdXJlIGF0IGxlYXN0IDxuPiBsaW5lcyBvZiBjb250ZXh0IG1hdGNoIgogbXNnc3RyICJhc2VndXJlIHF1ZSBwb3IgbG8gbWVub3MgPG4+IGzDrW5lYXMgZGVsIGNvbnRleHRvIGNvbmN1ZXJkZW4iCiAKLSM6IGFwcGx5LmM6NDk4NCBidWlsdGluL2FtLmM6MjE5NiBidWlsdGluL2ludGVycHJldC10cmFpbGVycy5jOjk4CisjOiBhcHBseS5jOjQ5OTYgYnVpbHRpbi9hbS5jOjIxODUgYnVpbHRpbi9pbnRlcnByZXQtdHJhaWxlcnMuYzo5OAogIzogYnVpbHRpbi9pbnRlcnByZXQtdHJhaWxlcnMuYzoxMDAgYnVpbHRpbi9pbnRlcnByZXQtdHJhaWxlcnMuYzoxMDIKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMzMCBidWlsdGluL3JlYmFzZS5jOjE0MjEKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMxMCBidWlsdGluL3JlYmFzZS5jOjE0NDUKIG1zZ2lkICJhY3Rpb24iCiBtc2dzdHIgImFjY2nDs24iCiAKLSM6IGFwcGx5LmM6NDk4NQorIzogYXBwbHkuYzo0OTk3CiBtc2dpZCAiZGV0ZWN0IG5ldyBvciBtb2RpZmllZCBsaW5lcyB0aGF0IGhhdmUgd2hpdGVzcGFjZSBlcnJvcnMiCiBtc2dzdHIgIiIKICJkZXRlY3RhciBsw61uZWFzIG51ZXZhcyBvIG1vZGlmaWNhZGFzIHF1ZSBjb250aWVuZW4gZXJyb3JlcyBkZSBlc3BhY2lvcyBlbiAiCiAiYmxhbmNvIgogCi0jOiBhcHBseS5jOjQ5ODggYXBwbHkuYzo0OTkxCisjOiBhcHBseS5jOjUwMDAgYXBwbHkuYzo1MDAzCiBtc2dpZCAiaWdub3JlIGNoYW5nZXMgaW4gd2hpdGVzcGFjZSB3aGVuIGZpbmRpbmcgY29udGV4dCIKIG1zZ3N0ciAiIgogImlnbm9yYXIgY2FtYmlvcyBlbiBsb3MgZXNwYWNpb3MgZW4gYmxhbmNvIGN1YW5kbyBzZSBlbmN1ZW50cmEgZWwgY29udGV4dG8iCiAKLSM6IGFwcGx5LmM6NDk5NAorIzogYXBwbHkuYzo1MDA2CiBtc2dpZCAiYXBwbHkgdGhlIHBhdGNoIGluIHJldmVyc2UiCiBtc2dzdHIgImFwbGljYXIgZWwgcGFyY2hlIGVuIHJldmVyc2EiCiAKLSM6IGFwcGx5LmM6NDk5NgorIzogYXBwbHkuYzo1MDA4CiBtc2dpZCAiZG9uJ3QgZXhwZWN0IGF0IGxlYXN0IG9uZSBsaW5lIG9mIGNvbnRleHQiCiBtc2dzdHIgIm5vIGVzcGVyYSBhbCBtZW5vcyB1bmEgbMOtbmVhIGRlbCBjb250ZXh0byIKIAotIzogYXBwbHkuYzo0OTk4CisjOiBhcHBseS5jOjUwMTAKIG1zZ2lkICJsZWF2ZSB0aGUgcmVqZWN0ZWQgaHVua3MgaW4gY29ycmVzcG9uZGluZyAqLnJlaiBmaWxlcyIKIG1zZ3N0ciAiZGVqYXIgbG9zIGh1bmtzIHJlY2hhemFkb3MgZW4gbG9zIGFyY2hpdm9zICoucmVqIGNvcnJlc3BvbnRpZW50ZXMiCiAKLSM6IGFwcGx5LmM6NTAwMAorIzogYXBwbHkuYzo1MDEyCiBtc2dpZCAiYWxsb3cgb3ZlcmxhcHBpbmcgaHVua3MiCiBtc2dzdHIgInBlcm1pdGlyIHNvbGFwYW1pZW50byBkZSBodW5rcyIKIAotIzogYXBwbHkuYzo1MDAxIGJ1aWx0aW4vYWRkLmM6MjkxIGJ1aWx0aW4vY2hlY2staWdub3JlLmM6MjIKKyM6IGFwcGx5LmM6NTAxMyBidWlsdGluL2FkZC5jOjI5MSBidWlsdGluL2NoZWNrLWlnbm9yZS5jOjIyCiAjOiBidWlsdGluL2NvbW1pdC5jOjEzMzcgYnVpbHRpbi9jb3VudC1vYmplY3RzLmM6OTggYnVpbHRpbi9mc2NrLmM6Nzg2Ci0jOiBidWlsdGluL2xvZy5jOjIwNjggYnVpbHRpbi9tdi5jOjEyMyBidWlsdGluL3JlYWQtdHJlZS5jOjEyOAorIzogYnVpbHRpbi9sb2cuYzoyMDg1IGJ1aWx0aW4vbXYuYzoxMjMgYnVpbHRpbi9yZWFkLXRyZWUuYzoxMjgKIG1zZ2lkICJiZSB2ZXJib3NlIgogbXNnc3RyICJzZXIgdmVyYm9zbyIKIAotIzogYXBwbHkuYzo1MDAzCisjOiBhcHBseS5jOjUwMTUKIG1zZ2lkICJ0b2xlcmF0ZSBpbmNvcnJlY3RseSBkZXRlY3RlZCBtaXNzaW5nIG5ldy1saW5lIGF0IHRoZSBlbmQgb2YgZmlsZSIKIG1zZ3N0ciAiIgogInRvbGVyYXIgbnVldmFzIGzDrW5lYXMgZmFsdGFudGVzIGRldGVjdGFkYXMgaW5jb3JyZWN0YW1lbnRlIGFsIGZpbmFsIGRlbCAiCiAiYXJjaGl2byIKIAotIzogYXBwbHkuYzo1MDA2CisjOiBhcHBseS5jOjUwMTgKIG1zZ2lkICJkbyBub3QgdHJ1c3QgdGhlIGxpbmUgY291bnRzIGluIHRoZSBodW5rIGhlYWRlcnMiCiBtc2dzdHIgIm5vIGNvbmZpYXIgZW4gZWwgY29udGVvIGRlIGzDrW5lYXMgZW4gbG9zIGhlYWRlcnMgZGVsIGh1bmsiCiAKLSM6IGFwcGx5LmM6NTAwOCBidWlsdGluL2FtLmM6MjIwNQorIzogYXBwbHkuYzo1MDIwIGJ1aWx0aW4vYW0uYzoyMTk0CiBtc2dpZCAicm9vdCIKIG1zZ3N0ciAicmHDrXoiCiAKLSM6IGFwcGx5LmM6NTAwOQorIzogYXBwbHkuYzo1MDIxCiBtc2dpZCAicHJlcGVuZCA8cm9vdD4gdG8gYWxsIGZpbGVuYW1lcyIKIG1zZ3N0ciAiYW50ZXBvbmVyIDxyb290PiBhIHRvZG9zIGxvcyBub21icmVzIGRlIGFyY2hpdm9zIgogCkBAIC04MjUsNyArODI1LDcgQEAKIG1zZ2lkICJhcmNoaXZlIGZvcm1hdCIKIG1zZ3N0ciAiZm9ybWF0byBkZWwgYXJjaGl2byIKIAotIzogYXJjaGl2ZS5jOjQ1OCBidWlsdGluL2xvZy5jOjE1ODAKKyM6IGFyY2hpdmUuYzo0NTggYnVpbHRpbi9sb2cuYzoxNTgxCiBtc2dpZCAicHJlZml4IgogbXNnc3RyICJwcmVmaWpvIgogCkBAIC04MzMsMTEgKzgzMywxMiBAQAogbXNnaWQgInByZXBlbmQgcHJlZml4IHRvIGVhY2ggcGF0aG5hbWUgaW4gdGhlIGFyY2hpdmUiCiBtc2dzdHIgImFudGVwb25lciBwcmVmaWpvIGEgY2FkYSBydXRhIGVuIGVsIGFyY2hpdm8iCiAKLSM6IGFyY2hpdmUuYzo0NjAgYnVpbHRpbi9ibGFtZS5jOjg2MiBidWlsdGluL2JsYW1lLmM6ODc0IGJ1aWx0aW4vYmxhbWUuYzo4NzUKLSM6IGJ1aWx0aW4vY29tbWl0LXRyZWUuYzoxMTcgYnVpbHRpbi9jb25maWcuYzoxMjkgYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExMzQKLSM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTM2IGJ1aWx0aW4vZ3JlcC5jOjg5NyBidWlsdGluL2hhc2gtb2JqZWN0LmM6MTA1Ci0jOiBidWlsdGluL2xzLWZpbGVzLmM6NTYwIGJ1aWx0aW4vbHMtZmlsZXMuYzo1NjMgYnVpbHRpbi9ub3Rlcy5jOjQxMgotIzogYnVpbHRpbi9ub3Rlcy5jOjU3OCBidWlsdGluL3JlYWQtdHJlZS5jOjEyMyBwYXJzZS1vcHRpb25zLmg6MTc3CisjOiBhcmNoaXZlLmM6NDYwIGJ1aWx0aW4vYmxhbWUuYzo4NjEgYnVpbHRpbi9ibGFtZS5jOjg3MyBidWlsdGluL2JsYW1lLmM6ODc0CisjOiBidWlsdGluL2NvbW1pdC10cmVlLmM6MTE3IGJ1aWx0aW4vY29uZmlnLmM6MTI5IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTYyCisjOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE2NCBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE2OCBidWlsdGluL2dyZXAuYzo4OTkKKyM6IGJ1aWx0aW4vaGFzaC1vYmplY3QuYzoxMDUgYnVpbHRpbi9scy1maWxlcy5jOjU2MCBidWlsdGluL2xzLWZpbGVzLmM6NTYzCisjOiBidWlsdGluL25vdGVzLmM6NDEyIGJ1aWx0aW4vbm90ZXMuYzo1NzggYnVpbHRpbi9yZWFkLXRyZWUuYzoxMjMKKyM6IHBhcnNlLW9wdGlvbnMuaDoxODYKIG1zZ2lkICJmaWxlIgogbXNnc3RyICJjYXJwZXRhIgogCkBAIC04NjksNyArODcwLDcgQEAKIG1zZ2lkICJsaXN0IHN1cHBvcnRlZCBhcmNoaXZlIGZvcm1hdHMiCiBtc2dzdHIgImxpc3RhciBsb3MgZm9ybWF0b3MgZGUgY2FycGV0YSBzb3BvcnRhZG9zIgogCi0jOiBhcmNoaXZlLmM6NDc5IGJ1aWx0aW4vYXJjaGl2ZS5jOjkxIGJ1aWx0aW4vY2xvbmUuYzoxMTMgYnVpbHRpbi9jbG9uZS5jOjExNgorIzogYXJjaGl2ZS5jOjQ3OSBidWlsdGluL2FyY2hpdmUuYzo5MSBidWlsdGluL2Nsb25lLmM6MTEyIGJ1aWx0aW4vY2xvbmUuYzoxMTUKICM6IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxMzc5IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxODU5CiBtc2dpZCAicmVwbyIKIG1zZ3N0ciAicmVwbyIKQEAgLTg3OCw3ICs4NzksNyBAQAogbXNnaWQgInJldHJpZXZlIHRoZSBhcmNoaXZlIGZyb20gcmVtb3RlIHJlcG9zaXRvcnkgPHJlcG8+IgogbXNnc3RyICJvYnRlbmVyIGxhIGNhcnBldGEgZGVsIHJlcG9zaXRvcmlvIHJlbW90byA8cmVwbz4iCiAKLSM6IGFyY2hpdmUuYzo0ODEgYnVpbHRpbi9hcmNoaXZlLmM6OTMgYnVpbHRpbi9kaWZmdG9vbC5jOjcwNworIzogYXJjaGl2ZS5jOjQ4MSBidWlsdGluL2FyY2hpdmUuYzo5MyBidWlsdGluL2RpZmZ0b29sLmM6NzE1CiAjOiBidWlsdGluL25vdGVzLmM6NDk4CiBtc2dpZCAiY29tbWFuZCIKIG1zZ3N0ciAiY29tYW5kbyIKQEAgLTkxNCwyNiArOTE1LDI2IEBACiBtc2dpZCAiY2Fubm90IHN0cmVhbSBibG9iICVzIgogbXNnc3RyICJubyBzZSBwdWVkZSB0cmFuc21pdGlyIGVsIGJsb2IgJXMiCiAKLSM6IGFyY2hpdmUtdGFyLmM6MjYwIGFyY2hpdmUtemlwLmM6MzYzCisjOiBhcmNoaXZlLXRhci5jOjI2NiBhcmNoaXZlLXppcC5jOjM2MwogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bnN1cHBvcnRlZCBmaWxlIG1vZGU6IDAlbyAoU0hBMTogJXMpIgogbXNnc3RyICJtb2RvIGRlIGFyY2hpdm8gbm8gc29wb3J0YWRvOiAwJW8gKFNIQTE6ICVzKSIKIAotIzogYXJjaGl2ZS10YXIuYzoyODcgYXJjaGl2ZS16aXAuYzozNTMKKyM6IGFyY2hpdmUtdGFyLmM6MjkzIGFyY2hpdmUtemlwLmM6MzUzCiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCByZWFkICVzIgogbXNnc3RyICJubyBzZSBwdWVkZSBsZWVyICVzIgogCi0jOiBhcmNoaXZlLXRhci5jOjQ1OQorIzogYXJjaGl2ZS10YXIuYzo0NjUKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHN0YXJ0ICclcycgZmlsdGVyIgogbXNnc3RyICJubyBzZSBwdWVkZSBjb21lbnphciBmaWx0cm8gJyVzJyIKIAotIzogYXJjaGl2ZS10YXIuYzo0NjIKKyM6IGFyY2hpdmUtdGFyLmM6NDY4CiBtc2dpZCAidW5hYmxlIHRvIHJlZGlyZWN0IGRlc2NyaXB0b3IiCiBtc2dzdHIgImluY2FwYXogZGUgcmVkaXJpZ2lyIGRlc2NyaXB0b3IiCiAKLSM6IGFyY2hpdmUtdGFyLmM6NDY5CisjOiBhcmNoaXZlLXRhci5jOjQ3NQogIywgYy1mb3JtYXQKIG1zZ2lkICInJXMnIGZpbHRlciByZXBvcnRlZCBlcnJvciIKIG1zZ3N0ciAiZmlsdHJvICclcycgcmVwb3J0w7MgdW4gZXJyb3IiCkBAIC05NTgsMTcgKzk1OSwxNyBAQAogbXNnaWQgInRpbWVzdGFtcCB0b28gbGFyZ2UgZm9yIHRoaXMgc3lzdGVtOiAlPFBSSXVNQVg+IgogbXNnc3RyICJ0aW1lc3RhbXAgbXV5IGxhcmdvIHBhcmEgZXN0ZSBzaXN0ZW1hOiAlPFBSSXVNQVg+IgogCi0jOiBhdHRyLmM6MjExCisjOiBhdHRyLmM6MjEzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiUuKnMgaXMgbm90IGEgdmFsaWQgYXR0cmlidXRlIG5hbWUiCiBtc2dzdHIgIiUuKnMgbm8gZXMgdW4gbm9tYnJlIGRlIGF0cmlidXRvIHbDoWxpZG8iCiAKLSM6IGF0dHIuYzozNjgKKyM6IGF0dHIuYzozNzAKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgbm90IGFsbG93ZWQ6ICVzOiVkIgogbXNnc3RyICIlcyBubyBwZXJtaXRpZG86ICVzOiVkIgogCi0jOiBhdHRyLmM6NDA4CisjOiBhdHRyLmM6NDEwCiBtc2dpZCAiIgogIk5lZ2F0aXZlIHBhdHRlcm5zIGFyZSBpZ25vcmVkIGluIGdpdCBhdHRyaWJ1dGVzXG4iCiAiVXNlICdcXCEnIGZvciBsaXRlcmFsIGxlYWRpbmcgZXhjbGFtYXRpb24uIgpAQCAtMTAyNyw3ICsxMDI4LDcgQEAKIG1zZ3N0ciAiIgogIkFsZ3VuYXMgJXMgcmV2aXNpb25lcyBubyBzb24gYW5jZXN0cm9zIGRlIGxhIHJldmlzacOzbiAlcy5cbiIKICJnaXQgYmlzZWN0IG5vIHB1ZWRlIHRyYWJhamFyIGJpZW4gZW4gZXN0ZSBjYXNvLlxuIgotIlRhbCB2ZXogY29uZnVuZGlzdGUgbGEgcmV2aXNpw7NuICVzIHkgJXM/XG4iCisiwr9UYWwgdmV6IGNvbmZ1bmRpc3RlIGxhIHJldmlzacOzbiAlcyB5ICVzP1xuIgogCiAjOiBiaXNlY3QuYzo3ODkKICMsIGMtZm9ybWF0CkBAIC0xMDk1LDQwICsxMDk2LDQwIEBACiBtc2dzdHJbMF0gIkJpc2VjY2lvbmFuZG86IGZhbHRhICVkIHJldmlzacOzbiBwb3IgcHJvYmFyIGRlc3B1w6lzIGRlIGVzdG8gJXNcbiIKIG1zZ3N0clsxXSAiQmlzZWNjaW9uYW5kbzogZmFsdGFuICVkIHJldmlzaW9uZXMgcG9yIHByb2JhciBkZXNwdcOpcyBkZSBlc3RvICVzXG4iCiAKLSM6IGJsYW1lLmM6MjY5NworIzogYmxhbWUuYzoyNzAwCiBtc2dpZCAiLS1jb250ZW50cyBhbmQgLS1yZXZlcnNlIGRvIG5vdCBibGVuZCB3ZWxsLiIKIG1zZ3N0ciAiLS1jb250ZW50cyB5IC0tcmV2ZXJzZSBubyBzZSBtZXpjbGFuIGJpZW4uIgogCi0jOiBibGFtZS5jOjI3MTEKKyM6IGJsYW1lLmM6MjcxNAogbXNnaWQgImNhbm5vdCB1c2UgLS1jb250ZW50cyB3aXRoIGZpbmFsIGNvbW1pdCBvYmplY3QgbmFtZSIKIG1zZ3N0ciAibm8gc2UgcHVlZGUgdXNhciAtLWNvbnRlbnRzIGNvbiBlbCBub21icmUgZGUgb2JqZXRvIGNvbW1pdCBmaW5hbCIKIAotIzogYmxhbWUuYzoyNzMyCisjOiBibGFtZS5jOjI3MzUKIG1zZ2lkICItLXJldmVyc2UgYW5kIC0tZmlyc3QtcGFyZW50IHRvZ2V0aGVyIHJlcXVpcmUgc3BlY2lmaWVkIGxhdGVzdCBjb21taXQiCiBtc2dzdHIgIiIKICItLXJldmVyc2UgeSAtLWZpcnN0LXBhcmVudCBqdW50b3MgcmVxdWllcmVuIGVzcGVjaWZpY2FyIGVsIMO6bHRpbW8gY29tbWl0IgogCi0jOiBibGFtZS5jOjI3NDEgYnVuZGxlLmM6MTY3IHJlZi1maWx0ZXIuYzoyMTk2IHJlbW90ZS5jOjE5Mzggc2VxdWVuY2VyLmM6MjAzMwotIzogc2VxdWVuY2VyLmM6NDM0OCBidWlsdGluL2NvbW1pdC5jOjEwMjAgYnVpbHRpbi9sb2cuYzozODcgYnVpbHRpbi9sb2cuYzo5NjMKLSM6IGJ1aWx0aW4vbG9nLmM6MTQ1MSBidWlsdGluL2xvZy5jOjE4MjcgYnVpbHRpbi9sb2cuYzoyMTE3IGJ1aWx0aW4vbWVyZ2UuYzo0MTEKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzE0OCBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMxNjMKKyM6IGJsYW1lLmM6Mjc0NCBidW5kbGUuYzoxNjcgcmVmLWZpbHRlci5jOjIyMDMgcmVtb3RlLmM6MTk0MSBzZXF1ZW5jZXIuYzoxOTcxCisjOiBzZXF1ZW5jZXIuYzo0MzA1IGJ1aWx0aW4vY29tbWl0LmM6MTAyMCBidWlsdGluL2xvZy5jOjM4NyBidWlsdGluL2xvZy5jOjk2NAorIzogYnVpbHRpbi9sb2cuYzoxNDUyIGJ1aWx0aW4vbG9nLmM6MTg0NCBidWlsdGluL2xvZy5jOjIxMzQgYnVpbHRpbi9tZXJnZS5jOjQxMQorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMTI4IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzE0MwogIzogYnVpbHRpbi9zaG9ydGxvZy5jOjE5MgogbXNnaWQgInJldmlzaW9uIHdhbGsgc2V0dXAgZmFpbGVkIgogbXNnc3RyICJmYWxsw7MgbGEgY29uZmlndXJhY2nDs24gZGVsIGNhbWlubyBkZSByZXZpc2nDs24iCiAKLSM6IGJsYW1lLmM6Mjc1OQorIzogYmxhbWUuYzoyNzYyCiBtc2dpZCAiIgogIi0tcmV2ZXJzZSAtLWZpcnN0LXBhcmVudCB0b2dldGhlciByZXF1aXJlIHJhbmdlIGFsb25nIGZpcnN0LXBhcmVudCBjaGFpbiIKIG1zZ3N0ciAiIgogIi0tcmV2ZXJzZSAtLWZpcnN0LXBhcmVudCBqdW50b3MgcmVxdWllcmVuIHVuIHJhbmdvIGEgbG8gbGFyZ28gZGUgbGEgY2FkZW5hICIKICJkZWwgcHJpbWVyIHBhZHJlIgogCi0jOiBibGFtZS5jOjI3NzAKKyM6IGJsYW1lLmM6Mjc3MwogIywgYy1mb3JtYXQKIG1zZ2lkICJubyBzdWNoIHBhdGggJXMgaW4gJXMiCiBtc2dzdHIgIm5vIGhheSB1bmEgcnV0YSAlcyBlbiAlcyIKIAotIzogYmxhbWUuYzoyNzgxCisjOiBibGFtZS5jOjI3ODQKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IHJlYWQgYmxvYiAlcyBmb3IgcGF0aCAlcyIKIG1zZ3N0ciAibm8gc2UgcHVlZGUgbGVlciBlbCBibG9iICVzIHBhcmEgbGEgcnV0YSAlcyIKQEAgLTEyOTIsNyArMTI5Myw3IEBACiBtc2dpZCAidW5yZWNvZ25pemVkIGhlYWRlcjogJXMlcyAoJWQpIgogbXNnc3RyICJoZWFkZXIgbm8gcmVjb25vY2lkbyAlcyVzICglZCkiCiAKLSM6IGJ1bmRsZS5jOjkwIHJlcmVyZS5jOjQ4MCByZXJlcmUuYzo2OTAgc2VxdWVuY2VyLmM6MjI4MyBzZXF1ZW5jZXIuYzozMDI0CisjOiBidW5kbGUuYzo5MCByZXJlcmUuYzo0ODAgcmVyZXJlLmM6NjkwIHNlcXVlbmNlci5jOjIyMjEgc2VxdWVuY2VyLmM6Mjk2MgogIzogYnVpbHRpbi9jb21taXQuYzo3OTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IG9wZW4gJyVzJyIKQEAgLTEzNDUsNyArMTM0Niw3IEBACiBtc2dpZCAicmVmICclcycgaXMgZXhjbHVkZWQgYnkgdGhlIHJldi1saXN0IG9wdGlvbnMiCiBtc2dzdHIgInJlZmVyZW5jaWEgJyVzJyBlcyBleGNsdWlkYSBwb3IgbGFzIG9wY2lvbmVzIGRlIHJldi1saXN0IgogCi0jOiBidW5kbGUuYzo0NjAgYnVpbHRpbi9sb2cuYzoyMDIgYnVpbHRpbi9sb2cuYzoxNzMyIGJ1aWx0aW4vc2hvcnRsb2cuYzozMDYKKyM6IGJ1bmRsZS5jOjQ2MCBidWlsdGluL2xvZy5jOjIwMiBidWlsdGluL2xvZy5jOjE3MzMgYnVpbHRpbi9zaG9ydGxvZy5jOjMwNgogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bnJlY29nbml6ZWQgYXJndW1lbnQ6ICVzIgogbXNnc3RyICJhcmd1bWVudG8gbm8gcmVjb25vY2lkbzogJXMiCkBAIC0xMzY4LDggKzEzNjksOCBAQAogbXNnaWQgImludmFsaWQgY29sb3IgdmFsdWU6ICUuKnMiCiBtc2dzdHIgImNvbG9yIGludsOhbGlkbzogJS4qcyIKIAotIzogY29tbWl0LmM6NTAgc2VxdWVuY2VyLmM6MjcyNyBidWlsdGluL2FtLmM6MzU1IGJ1aWx0aW4vYW0uYzozOTkKLSM6IGJ1aWx0aW4vYW0uYzoxMzc4IGJ1aWx0aW4vYW0uYzoyMDIwIGJ1aWx0aW4vcmVwbGFjZS5jOjQ1NQorIzogY29tbWl0LmM6NTAgc2VxdWVuY2VyLmM6MjY2NSBidWlsdGluL2FtLmM6MzU0IGJ1aWx0aW4vYW0uYzozOTgKKyM6IGJ1aWx0aW4vYW0uYzoxMzY2IGJ1aWx0aW4vYW0uYzoyMDA5IGJ1aWx0aW4vcmVwbGFjZS5jOjQ1NgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcGFyc2UgJXMiCiBtc2dzdHIgIm5vIHNlIHB1ZWRlIGFuYWxpemFyICVzIgpAQCAtMTM3Nyw3ICsxMzc4LDcgQEAKICM6IGNvbW1pdC5jOjUyCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzICVzIGlzIG5vdCBhIGNvbW1pdCEiCi1tc2dzdHIgIiVzICVzIG5vIGVzIHVuIGNvbW1pdCEiCittc2dzdHIgIsKhJXMgJXMgbm8gZXMgdW4gY29tbWl0ISIKIAogIzogY29tbWl0LmM6MTkyCiBtc2dpZCAiIgpAQCAtMTM5OSwyNyArMTQwMCwyNyBAQAogIkFwYXBhIGVzdGUgbWVuc2FqZSBlamVjdXRhbmRvXG4iCiAiXCJnaXQgY29uZmlnIGFkdmljZS5ncmFmdEZpbGVEZXByZWNhdGVkIGZhbHNlXCIiCiAKLSM6IGNvbW1pdC5jOjExMjcKKyM6IGNvbW1pdC5jOjExMjgKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ29tbWl0ICVzIGhhcyBhbiB1bnRydXN0ZWQgR1BHIHNpZ25hdHVyZSwgYWxsZWdlZGx5IGJ5ICVzLiIKIG1zZ3N0ciAiQ29tbWl0ICVzIHRpZW5lIHVuYSBmaXJtYSBHUEcgbm8gY29uZmlhYmxlLCBwcmV0ZW5kaWRhbWVudGUgcG9yICVzLiIKIAotIzogY29tbWl0LmM6MTEzMAorIzogY29tbWl0LmM6MTEzMQogIywgYy1mb3JtYXQKIG1zZ2lkICJDb21taXQgJXMgaGFzIGEgYmFkIEdQRyBzaWduYXR1cmUgYWxsZWdlZGx5IGJ5ICVzLiIKIG1zZ3N0ciAiQ29tbWl0ICVzIHRpZW5lIHVuYSBtYWxhIGZpcm1hIEdQRyBwcmV0ZW5kaWRhbWVudGUgcG9yICVzLiIKIAotIzogY29tbWl0LmM6MTEzMworIzogY29tbWl0LmM6MTEzNAogIywgYy1mb3JtYXQKIG1zZ2lkICJDb21taXQgJXMgZG9lcyBub3QgaGF2ZSBhIEdQRyBzaWduYXR1cmUuIgogbXNnc3RyICJDb21taXQgJXMgbm8gdGllbmUgdW5hIGZpcm1hIEdQRy4iCiAKLSM6IGNvbW1pdC5jOjExMzYKKyM6IGNvbW1pdC5jOjExMzcKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ29tbWl0ICVzIGhhcyBhIGdvb2QgR1BHIHNpZ25hdHVyZSBieSAlc1xuIgogbXNnc3RyICJFbCBDb21taXQgJXMgdGllbmUgdW5hIGJ1ZW5hIGZpcm1hIEdQRyBwb3IgJXNcbiIKIAotIzogY29tbWl0LmM6MTM5MAorIzogY29tbWl0LmM6MTM5MQogbXNnaWQgIiIKICJXYXJuaW5nOiBjb21taXQgbWVzc2FnZSBkaWQgbm90IGNvbmZvcm0gdG8gVVRGLTguXG4iCiAiWW91IG1heSB3YW50IHRvIGFtZW5kIGl0IGFmdGVyIGZpeGluZyB0aGUgbWVzc2FnZSwgb3Igc2V0IHRoZSBjb25maWdcbiIKQEAgLTE0ODIsMTk5ICsxNDgzLDIxNCBAQAogbXNnaWQgInVuYWJsZSB0byBmaW5kIGFsbCBjb21taXQtZ3JhcGggZmlsZXMiCiBtc2dzdHIgIm5vIGVzIHBvc2libGUgZW5jb250cmFyIGxvcyBhcmNoaXZvcyBjb21taXQtZ3JhcGgiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjU1NCBjb21taXQtZ3JhcGguYzo2MTQKKyM6IGNvbW1pdC1ncmFwaC5jOjU2MSBjb21taXQtZ3JhcGguYzo2MjEKIG1zZ2lkICJpbnZhbGlkIGNvbW1pdCBwb3NpdGlvbi4gY29tbWl0LWdyYXBoIGlzIGxpa2VseSBjb3JydXB0IgogbXNnc3RyICJwb3NpY2nDs24gZGUgY29tbWl0IGludsOhbGlkYS4gY29tbWl0LWdyYXBoIGVzdMOhIHByb2JhYmxlbWVudGUgY29ycnVwdG8iCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjU3NQorIzogY29tbWl0LWdyYXBoLmM6NTgyCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBmaW5kIGNvbW1pdCAlcyIKIG1zZ3N0ciAibm8gc2UgcHVkbyBlbmNvbnRyYXIgY29tbWl0ICVzIgogCi0jOiBjb21taXQtZ3JhcGguYzoxMDAyIGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjY1NworIzogY29tbWl0LWdyYXBoLmM6ODU1IGJ1aWx0aW4vYW0uYzoxMjg3CisjLCBjLWZvcm1hdAorbXNnaWQgInVuYWJsZSB0byBwYXJzZSBjb21taXQgJXMiCittc2dzdHIgIm5vIGVzIHBvc2libGUgYW5hbGl6YXIgZWwgY29tbWl0ICVzIgorCisjOiBjb21taXQtZ3JhcGguYzo4NTkKKyMsIGMtZm9ybWF0Cittc2dpZCAidW5hYmxlIHRvIGdldCB0cmVlIGZvciAlcyIKK21zZ3N0ciAibm8gc2UgcHVkbyBvYnRlbmVyIMOhcmJvbCBwYXJhICVzIgorCisjOiBjb21taXQtZ3JhcGguYzoxMDE3IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjY0MQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gZ2V0IHR5cGUgb2Ygb2JqZWN0ICVzIgogbXNnc3RyICJpbmNhcGF6IGRlIG9idGVuZXIgZWwgdGlwbyBkZSBvYmpldG86ICVzIgogCi0jOiBjb21taXQtZ3JhcGguYzoxMDM0CisjOiBjb21taXQtZ3JhcGguYzoxMDQ5CiBtc2dpZCAiTG9hZGluZyBrbm93biBjb21taXRzIGluIGNvbW1pdCBncmFwaCIKIG1zZ3N0ciAiQ2FyZ2FuZG8gY29tbWl0cyBjb25vY2lkb3MgZW4gY29tbWl0IGdyYXBoIgogCi0jOiBjb21taXQtZ3JhcGguYzoxMDUxCisjOiBjb21taXQtZ3JhcGguYzoxMDY2CiBtc2dpZCAiRXhwYW5kaW5nIHJlYWNoYWJsZSBjb21taXRzIGluIGNvbW1pdCBncmFwaCIKIG1zZ3N0ciAiRXhwYW5kaWVuZG8gY29tbWl0cyBhbGNhbnphYmxlcyBlbiBjb21taXQgZ3JhcGgiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjEwNzAKKyM6IGNvbW1pdC1ncmFwaC5jOjEwODUKIG1zZ2lkICJDbGVhcmluZyBjb21taXQgbWFya3MgaW4gY29tbWl0IGdyYXBoIgogbXNnc3RyICJMaW1waWFuZG8gbWFyY2FzIGRlIGNvbW1pdHMgZW4gY29tbWl0IGdyYXBoIgogCi0jOiBjb21taXQtZ3JhcGguYzoxMDg5CisjOiBjb21taXQtZ3JhcGguYzoxMTA0CiBtc2dpZCAiQ29tcHV0aW5nIGNvbW1pdCBncmFwaCBnZW5lcmF0aW9uIG51bWJlcnMiCiBtc2dzdHIgIkNhbGN1bGFuZG8gbsO6bWVyb3MgZGUgZ2VuZXJhY2nDs24gZGUgY29tbWl0IGdyYXBoIgogCi0jOiBjb21taXQtZ3JhcGguYzoxMTYzCisjOiBjb21taXQtZ3JhcGguYzoxMTc5CiAjLCBjLWZvcm1hdAogbXNnaWQgIkZpbmRpbmcgY29tbWl0cyBmb3IgY29tbWl0IGdyYXBoIGluICVkIHBhY2siCiBtc2dpZF9wbHVyYWwgIkZpbmRpbmcgY29tbWl0cyBmb3IgY29tbWl0IGdyYXBoIGluICVkIHBhY2tzIgogbXNnc3RyWzBdICJFbmNvbnRyYW5kbyBjb21taXRzIHBhcmEgY29tbWl0IGdyYXBoIGVuICVkIHBhY2siCiBtc2dzdHJbMV0gIkVuY29udHJhbmRvIGNvbW1pdHMgcGFyYSBjb21taXQgZ3JhcGggZW4gJWQgcGFja3MiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjExNzYKKyM6IGNvbW1pdC1ncmFwaC5jOjExOTIKICMsIGMtZm9ybWF0CiBtc2dpZCAiZXJyb3IgYWRkaW5nIHBhY2sgJXMiCiBtc2dzdHIgImVycm9yIGFncmVnYW5kbyBwYWNrICVzIgogCi0jOiBjb21taXQtZ3JhcGguYzoxMTgwCisjOiBjb21taXQtZ3JhcGguYzoxMTk2CiAjLCBjLWZvcm1hdAogbXNnaWQgImVycm9yIG9wZW5pbmcgaW5kZXggZm9yICVzIgogbXNnc3RyICJlcnJvciBhYnJpZW5kbyBpbmRleCBwYXJhICVzIgogCi0jOiBjb21taXQtZ3JhcGguYzoxMjA0CisjOiBjb21taXQtZ3JhcGguYzoxMjIwCiAjLCBjLWZvcm1hdAogbXNnaWQgIkZpbmRpbmcgY29tbWl0cyBmb3IgY29tbWl0IGdyYXBoIGZyb20gJWQgcmVmIgogbXNnaWRfcGx1cmFsICJGaW5kaW5nIGNvbW1pdHMgZm9yIGNvbW1pdCBncmFwaCBmcm9tICVkIHJlZnMiCiBtc2dzdHJbMF0gIkVuY29udHJhbmRvIGNvbW1pdHMgcGFyYSBjb21taXQgZ3JhcGggZGUgJWQgcmVmIgogbXNnc3RyWzFdICJFbmNvbnRyYW5kbyBjb21taXRzIHBhcmEgY29tbWl0IGdyYXBoIGRlICVkIHJlZnMiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjEyMzgKKyM6IGNvbW1pdC1ncmFwaC5jOjEyNDAKKyMsIGMtZm9ybWF0Cittc2dpZCAiaW52YWxpZCBjb21taXQgb2JqZWN0IGlkOiAlcyIKK21zZ3N0ciAiaWQgZGUgb2JqZXRvIGNvbW1pdDogJXMgaW52w6FsaWRvIgorCisjOiBjb21taXQtZ3JhcGguYzoxMjU1CiBtc2dpZCAiRmluZGluZyBjb21taXRzIGZvciBjb21taXQgZ3JhcGggYW1vbmcgcGFja2VkIG9iamVjdHMiCiBtc2dzdHIgIkVuY29udHJhbmRvIGNvbW1pdHMgcGFyYSBjb21taXQgZ3JhcGggZW50cmUgbG9zIG9iamV0b3MgZW1wYXF1ZXRhZG9zIgogCi0jOiBjb21taXQtZ3JhcGguYzoxMjUzCisjOiBjb21taXQtZ3JhcGguYzoxMjcwCiBtc2dpZCAiQ291bnRpbmcgZGlzdGluY3QgY29tbWl0cyBpbiBjb21taXQgZ3JhcGgiCiBtc2dzdHIgIkNvbnRhbmRvIGNvbW1pdHMgZGlzdGludG9zIGVuIGNvbW1pdCBncmFwaCIKIAotIzogY29tbWl0LWdyYXBoLmM6MTI4NAorIzogY29tbWl0LWdyYXBoLmM6MTMwMAogbXNnaWQgIkZpbmRpbmcgZXh0cmEgZWRnZXMgaW4gY29tbWl0IGdyYXBoIgogbXNnc3RyICJFbmNvbnRyYW5kbyBlc3F1aW5hcyBleHRyYSBlbiBjb21taXQgZ3JhcGgiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjEzMzIKKyM6IGNvbW1pdC1ncmFwaC5jOjEzNDYKIG1zZ2lkICJmYWlsZWQgdG8gd3JpdGUgY29ycmVjdCBudW1iZXIgb2YgYmFzZSBncmFwaCBpZHMiCiBtc2dzdHIgImZhbGzDsyBhbCBlc2NyaWJpciBlbCBuw7ptZXJvIGNvcnJlY3RvIGRlIGlkcyBkZSBiYXNlIGdyYXBoIgogCi0jOiBjb21taXQtZ3JhcGguYzoxMzY1IG1pZHguYzo4MTEKKyM6IGNvbW1pdC1ncmFwaC5jOjEzNzkgbWlkeC5jOjgxMAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gY3JlYXRlIGxlYWRpbmcgZGlyZWN0b3JpZXMgb2YgJXMiCiBtc2dzdHIgIm5vIHNlIHB1ZG8gY3JlYXIgZGlyZWN0b3Jpb3MgcHJpbmNpcGFsZXMgcGFyYSAlcyIKIAotIzogY29tbWl0LWdyYXBoLmM6MTM3NyBidWlsdGluL2luZGV4LXBhY2suYzozMDYgYnVpbHRpbi9yZXBhY2suYzoyNDAKKyM6IGNvbW1pdC1ncmFwaC5jOjEzOTEgYnVpbHRpbi9pbmRleC1wYWNrLmM6MzA2IGJ1aWx0aW4vcmVwYWNrLmM6MjQxCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBjcmVhdGUgJyVzJyIKIG1zZ3N0ciAibm8gc2UgcHVlZGUgY3JlYXIgJyVzJyIKIAotIzogY29tbWl0LWdyYXBoLmM6MTQzNworIzogY29tbWl0LWdyYXBoLmM6MTQ1MQogIywgYy1mb3JtYXQKIG1zZ2lkICJXcml0aW5nIG91dCBjb21taXQgZ3JhcGggaW4gJWQgcGFzcyIKIG1zZ2lkX3BsdXJhbCAiV3JpdGluZyBvdXQgY29tbWl0IGdyYXBoIGluICVkIHBhc3NlcyIKIG1zZ3N0clswXSAiRXNjcmliaWVuZG8gY29tbWl0IGdyYXBoIGVuICVkIHBhc28iCiBtc2dzdHJbMV0gIkVzY3JpYmllbmRvIGNvbW1pdCBncmFwaCBlbiAlZCBwYXNvcyIKIAotIzogY29tbWl0LWdyYXBoLmM6MTQ3OAorIzogY29tbWl0LWdyYXBoLmM6MTQ5MgogbXNnaWQgInVuYWJsZSB0byBvcGVuIGNvbW1pdC1ncmFwaCBjaGFpbiBmaWxlIgogbXNnc3RyICJubyBzZSBwdWRvIGFicmlyIGxhIGNhZGVuYSBkZSBhcmNoaXZvcyBjb21taXQtZ3JhcGgiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjE0OTAKKyM6IGNvbW1pdC1ncmFwaC5jOjE1MDQKIG1zZ2lkICJmYWlsZWQgdG8gcmVuYW1lIGJhc2UgY29tbWl0LWdyYXBoIGZpbGUiCiBtc2dzdHIgIm5vIHNlIHB1ZG8gcmVub21icmFyIGVsIGFyY2hpdm8gYmFzZSBjb21taXQtZ3JhcGgiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjE1MTAKKyM6IGNvbW1pdC1ncmFwaC5jOjE1MjQKIG1zZ2lkICJmYWlsZWQgdG8gcmVuYW1lIHRlbXBvcmFyeSBjb21taXQtZ3JhcGggZmlsZSIKIG1zZ3N0ciAiZmFsbMOzIGFsIHJlbm9tYnJhciBlbCBhcmNoaXZvIHRlbXBvcmFsIGNvbW1pdC1ncmFwaCIKIAotIzogY29tbWl0LWdyYXBoLmM6MTYyMQorIzogY29tbWl0LWdyYXBoLmM6MTYzNQogbXNnaWQgIlNjYW5uaW5nIG1lcmdlZCBjb21taXRzIgogbXNnc3RyICJFc2NhbmVhbmRvIGNvbW1pdHMgZnVzaW9uYWRvcyIKIAotIzogY29tbWl0LWdyYXBoLmM6MTYzMgorIzogY29tbWl0LWdyYXBoLmM6MTY0NgogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmV4cGVjdGVkIGR1cGxpY2F0ZSBjb21taXQgaWQgJXMiCiBtc2dzdHIgImlkIGRlIGNvbW1pdCBkdXBsaWNhZG8gaW5lc3BlcmFkbyAlcyIKIAotIzogY29tbWl0LWdyYXBoLmM6MTY1NworIzogY29tbWl0LWdyYXBoLmM6MTY3MAogbXNnaWQgIk1lcmdpbmcgY29tbWl0LWdyYXBoIgogbXNnc3RyICJGdXNpb25hbmRvIGNvbW1pdC1ncmFwaCIKIAotIzogY29tbWl0LWdyYXBoLmM6MTg0NAorIzogY29tbWl0LWdyYXBoLmM6MTg2MAogIywgYy1mb3JtYXQKIG1zZ2lkICJ0aGUgY29tbWl0IGdyYXBoIGZvcm1hdCBjYW5ub3Qgd3JpdGUgJWQgY29tbWl0cyIKIG1zZ3N0ciAiZWwgZm9ybWF0byBkZSBncsOhZmljb3MgZGUgY29tbWl0IG5vIHB1ZGVkZSBlc2NyaWJpciAlZCBjb21taXRzIgogCi0jOiBjb21taXQtZ3JhcGguYzoxODU1CisjOiBjb21taXQtZ3JhcGguYzoxODcxCiBtc2dpZCAidG9vIG1hbnkgY29tbWl0cyB0byB3cml0ZSBncmFwaCIKIG1zZ3N0ciAiZGVtYXNpYWRvcyBjb21taXRzIHBhcmEgZXNjcmliaXIgZWwgZ3LDoWZpY28iCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjE5NDUKKyM6IGNvbW1pdC1ncmFwaC5jOjE5NjEKIG1zZ2lkICJ0aGUgY29tbWl0LWdyYXBoIGZpbGUgaGFzIGluY29ycmVjdCBjaGVja3N1bSBhbmQgaXMgbGlrZWx5IGNvcnJ1cHQiCiBtc2dzdHIgIiIKICJlbCBhcmNoaXZvIGRlIGNvbW1pdC1ncmFwaCB0aWVuZSBjaGVja3N1bXMgaW5jb3JyZWN0b3MgeSBwcm9iYWJsZW1lbnRlIGVzdMOhICIKICJjb3JydXB0byIKIAotIzogY29tbWl0LWdyYXBoLmM6MTk1NQorIzogY29tbWl0LWdyYXBoLmM6MTk3MQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb21taXQtZ3JhcGggaGFzIGluY29ycmVjdCBPSUQgb3JkZXI6ICVzIHRoZW4gJXMiCiBtc2dzdHIgImNvbW1pdC1ncmFwaCB0aWVuZSB1biBvcmRlbiBkZSBPSUQgaW5jb3JyZWN0bzogJXMgbHVlZ28gJXMiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjE5NjUgY29tbWl0LWdyYXBoLmM6MTk4MAorIzogY29tbWl0LWdyYXBoLmM6MTk4MSBjb21taXQtZ3JhcGguYzoxOTk2CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvbW1pdC1ncmFwaCBoYXMgaW5jb3JyZWN0IGZhbm91dCB2YWx1ZTogZmFub3V0WyVkXSA9ICV1ICE9ICV1IgogbXNnc3RyICJjb21taXQtZ3JhcGggdGllbmUgdW4gdmFsb3IgZmFub3V0IGluY29ycmVjdG86IGZhbm91dFslZF0gPSAldSAhPSAldSIKIAotIzogY29tbWl0LWdyYXBoLmM6MTk3MgorIzogY29tbWl0LWdyYXBoLmM6MTk4OAogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gcGFyc2UgY29tbWl0ICVzIGZyb20gY29tbWl0LWdyYXBoIgogbXNnc3RyICJmYWxsw7MgYWwgYW5hbGl6YXIgY29tbWl0ICVzIHBhcmEgY29tbWl0LWdyYXBoIgogCi0jOiBjb21taXQtZ3JhcGguYzoxOTg5CisjOiBjb21taXQtZ3JhcGguYzoyMDA2CiBtc2dpZCAiVmVyaWZ5aW5nIGNvbW1pdHMgaW4gY29tbWl0IGdyYXBoIgogbXNnc3RyICJWZXJpZmljYW5kbyBjb21taXRzIGVuIGNvbW1pdCBncmFwaCIKIAotIzogY29tbWl0LWdyYXBoLmM6MjAwMgorIzogY29tbWl0LWdyYXBoLmM6MjAyMAogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gcGFyc2UgY29tbWl0ICVzIGZyb20gb2JqZWN0IGRhdGFiYXNlIGZvciBjb21taXQtZ3JhcGgiCiBtc2dzdHIgIiIKICJmYWxsw7MgYWwgYW5hbGl6YXIgZWwgY29tbWl0ICVzIGRlIGxhIGJhc2UgZGUgZGF0b3MgZGUgb2JqZXRvcyBwYXJhIGNvbW1pdC0iCiAiZ3JhcGgiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjIwMDkKKyM6IGNvbW1pdC1ncmFwaC5jOjIwMjcKICMsIGMtZm9ybWF0CiBtc2dpZCAicm9vdCB0cmVlIE9JRCBmb3IgY29tbWl0ICVzIGluIGNvbW1pdC1ncmFwaCBpcyAlcyAhPSAlcyIKIG1zZ3N0ciAiw6FyYm9sIHJhw616IE9JRCBwYXJhIGNvbW1pdCAlcyBlbiBjb21taXQtZ3JhcGggZXMgJXMgIT0gJXMiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjIwMTkKKyM6IGNvbW1pdC1ncmFwaC5jOjIwMzcKICMsIGMtZm9ybWF0CiBtc2dpZCAiY29tbWl0LWdyYXBoIHBhcmVudCBsaXN0IGZvciBjb21taXQgJXMgaXMgdG9vIGxvbmciCiBtc2dzdHIgImxpc3RhIHBhZHJlIGRlIGNvbW1pdC1ncmFwaCBwYXJhIGNvbW1pdCAlcyBlcyBtdXkgbGFyZ2EiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjIwMjgKKyM6IGNvbW1pdC1ncmFwaC5jOjIwNDYKICMsIGMtZm9ybWF0CiBtc2dpZCAiY29tbWl0LWdyYXBoIHBhcmVudCBmb3IgJXMgaXMgJXMgIT0gJXMiCiBtc2dzdHIgInBhZHJlIGRlIGNvbW1pdC1ncmFwaCBwYXJhICVzIGVzICVzICE9ICVzIgogCi0jOiBjb21taXQtZ3JhcGguYzoyMDQxCisjOiBjb21taXQtZ3JhcGguYzoyMDU5CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvbW1pdC1ncmFwaCBwYXJlbnQgbGlzdCBmb3IgY29tbWl0ICVzIHRlcm1pbmF0ZXMgZWFybHkiCiBtc2dzdHIgImxpc3RhIHBhZHJlIGRlIGNvbW1pdC1ncmFwaCBwYXJhIGNvbW1pdCAlcyB0ZXJtaW5hIGFudGVzIgogCi0jOiBjb21taXQtZ3JhcGguYzoyMDQ2CisjOiBjb21taXQtZ3JhcGguYzoyMDY0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJjb21taXQtZ3JhcGggaGFzIGdlbmVyYXRpb24gbnVtYmVyIHplcm8gZm9yIGNvbW1pdCAlcywgYnV0IG5vbi16ZXJvIGVsc2V3aGVyZSIKIG1zZ3N0ciAiIgogImNvbW1pdC1ncmFwaCBoYSBnZW5lcmFkbyBuw7ptZXJvIGNlcm8gcGFyYSAlcywgcGVybyBuby1jZXJvIHBhcmEgbG9zIGRlbcOhcyIKIAotIzogY29tbWl0LWdyYXBoLmM6MjA1MAorIzogY29tbWl0LWdyYXBoLmM6MjA2OAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiY29tbWl0LWdyYXBoIGhhcyBub24temVybyBnZW5lcmF0aW9uIG51bWJlciBmb3IgY29tbWl0ICVzLCBidXQgemVybyBlbHNld2hlcmUiCiBtc2dzdHIgIiIKICJjb21taXQtZ3JhcGggdGllbmUgZ2VuZXJhY2nDs24gbm8tY2VybyBwYXJhICVzLCBwZXJvIGNlcm8gcGFyYSBsb3MgZGVtw6FzIgogCi0jOiBjb21taXQtZ3JhcGguYzoyMDY1CisjOiBjb21taXQtZ3JhcGguYzoyMDgzCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvbW1pdC1ncmFwaCBnZW5lcmF0aW9uIGZvciBjb21taXQgJXMgaXMgJXUgIT0gJXUiCiBtc2dzdHIgImdlbmVyYWNpw7NuIGNvbW1pdC1ncmFwaCBwYXJhIGNvbW1pdCAlcyBlcyAldSAhPSAldSIKIAotIzogY29tbWl0LWdyYXBoLmM6MjA3MQorIzogY29tbWl0LWdyYXBoLmM6MjA4OQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb21taXQgZGF0ZSBmb3IgY29tbWl0ICVzIGluIGNvbW1pdC1ncmFwaCBpcyAlPFBSSXVNQVg+ICE9ICU8UFJJdU1BWD4iCiBtc2dzdHIgIiIKQEAgLTE3MjMsNyArMTczOSw3IEBACiBtc2dpZCAia2V5IGRvZXMgbm90IGNvbnRhaW4gdmFyaWFibGUgbmFtZTogJXMiCiBtc2dzdHIgImxsYXZlIG5vIGNvbnRpZW5lIGVsIG5vbWJyZSBkZSB2YXJpYWJsZTogJXMiCiAKLSM6IGNvbmZpZy5jOjQwNiBzZXF1ZW5jZXIuYzoyNDYzCisjOiBjb25maWcuYzo0MDYgc2VxdWVuY2VyLmM6MjQwMQogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIGtleTogJXMiCiBtc2dzdHIgImxsYXZlIGludsOhbGlkYTogJXMiCkBAIC0xODQ3LDE1MiArMTg2MywxNDUgQEAKIG1zZ2lkICJpbnZhbGlkIG1vZGUgZm9yIG9iamVjdCBjcmVhdGlvbjogJXMiCiBtc2dzdHIgIm1vZG8gaW52w6FsaWRvIGRlIGNyZWFjacOzbiBkZSBvYmpldG9zOiAlcyIKIAotIzogY29uZmlnLmM6MTQzMAorIzogY29uZmlnLmM6MTQyNQogIywgYy1mb3JtYXQKIG1zZ2lkICJtYWxmb3JtZWQgdmFsdWUgZm9yICVzIgogbXNnc3RyICJ2YWxvciBtYWxmb3JtYWRvIHBhcmEgJXMiCiAKLSM6IGNvbmZpZy5jOjE0NTYKKyM6IGNvbmZpZy5jOjE0NTEKICMsIGMtZm9ybWF0CiBtc2dpZCAibWFsZm9ybWVkIHZhbHVlIGZvciAlczogJXMiCiBtc2dzdHIgInZhbG9yIG1hbGZvcm1hZG8gcGFyYSAlczogJXMiCiAKLSM6IGNvbmZpZy5jOjE0NTcKKyM6IGNvbmZpZy5jOjE0NTIKIG1zZ2lkICJtdXN0IGJlIG9uZSBvZiBub3RoaW5nLCBtYXRjaGluZywgc2ltcGxlLCB1cHN0cmVhbSBvciBjdXJyZW50IgogbXNnc3RyICJkZWJlIHNlciB1bm8gZGUgbm90aGluZywgbWF0Y2hpbmcsIHNpbXBsZSwgdXBzdHJlYW0gbyBjdXJyZW50IgogCi0jOiBjb25maWcuYzoxNTE4IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzQxMAorIzogY29uZmlnLmM6MTUxMyBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzOTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiYmFkIHBhY2sgY29tcHJlc3Npb24gbGV2ZWwgJWQiCiBtc2dzdHIgIm5pdmVsIGRlIGNvbXByZXNpw7NuIGRlIHBhY2sgZXJyw7NuZW8gJWQiCiAKLSM6IGNvbmZpZy5jOjE2MzkKKyM6IGNvbmZpZy5jOjE2MzQKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGxvYWQgY29uZmlnIGJsb2Igb2JqZWN0ICclcyciCiBtc2dzdHIgImluY2FwYXogZGUgY2FyZ2FyIGNvbmZpZ3VyYWNpw7NuIGRlIG9iamV0byBibG9iICclcyciCiAKLSM6IGNvbmZpZy5jOjE2NDIKKyM6IGNvbmZpZy5jOjE2MzcKICMsIGMtZm9ybWF0CiBtc2dpZCAicmVmZXJlbmNlICclcycgZG9lcyBub3QgcG9pbnQgdG8gYSBibG9iIgogbXNnc3RyICJyZWZlcmVuY2lhICclcycgbm8gYXB1bnRhIGEgdW4gYmxvYiIKIAotIzogY29uZmlnLmM6MTY1OQorIzogY29uZmlnLmM6MTY1NAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gcmVzb2x2ZSBjb25maWcgYmxvYiAnJXMnIgogbXNnc3RyICJubyBzZSBwb3NpYmxlIHJlc29sdmVyIGNvbmZpZ3VyYWNpw7NuIGRlIGJsb2IgJyVzJyIKIAotIzogY29uZmlnLmM6MTY4OQorIzogY29uZmlnLmM6MTY4NAogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gcGFyc2UgJXMiCiBtc2dzdHIgIm5vIHNlIHB1ZG8gYW5hbGl6YXIgJXMiCiAKLSM6IGNvbmZpZy5jOjE3NDUKKyM6IGNvbmZpZy5jOjE3NDAKIG1zZ2lkICJ1bmFibGUgdG8gcGFyc2UgY29tbWFuZC1saW5lIGNvbmZpZyIKIG1zZ3N0ciAibm8gZXMgcG9zaWJsZSBhbmFsaXphciBsYSBjb25maWd1cmFjacOzbiBkZSBsYSBsw61uZWEgZGUgY29tYW5kbyIKIAotIzogY29uZmlnLmM6MjA5NAorIzogY29uZmlnLmM6MjA5MQogbXNnaWQgInVua25vd24gZXJyb3Igb2NjdXJyZWQgd2hpbGUgcmVhZGluZyB0aGUgY29uZmlndXJhdGlvbiBmaWxlcyIKIG1zZ3N0ciAiIgogImVycm9yIGRlc2Nvbm9jaWRvIG9jdXJyacOzIG1pZW50cmFzIHNlIGxlw61hbiBsb3MgYXJjaGl2b3MgZGUgY29uZmlndXJhY2nDs24iCiAKLSM6IGNvbmZpZy5jOjIyNjQKKyM6IGNvbmZpZy5jOjIyNjEKICMsIGMtZm9ybWF0CiBtc2dpZCAiSW52YWxpZCAlczogJyVzJyIKIG1zZ3N0ciAiSW52w6FsaWRvICVzOiAnJXMnIgogCi0jOiBjb25maWcuYzoyMzA3Ci0jLCBjLWZvcm1hdAotbXNnaWQgInVua25vd24gY29yZS51bnRyYWNrZWRDYWNoZSB2YWx1ZSAnJXMnOyB1c2luZyAna2VlcCcgZGVmYXVsdCB2YWx1ZSIKLW1zZ3N0ciAiIgotInZhbG9yIGNvcmUudW50cmFja2VkQ2FjaGUgJyVzJyBkZXNjb25vY2lkbzsgdXNhbmRvICdrZWVwJyBjb21vIHZhbG9yIHBvciAiCi0iZGVmZWN0byIKLQotIzogY29uZmlnLmM6MjMzMworIzogY29uZmlnLmM6MjMwNgogIywgYy1mb3JtYXQKIG1zZ2lkICJzcGxpdEluZGV4Lm1heFBlcmNlbnRDaGFuZ2UgdmFsdWUgJyVkJyBzaG91bGQgYmUgYmV0d2VlbiAwIGFuZCAxMDAiCiBtc2dzdHIgInZhbG9yIHNwbGl0SW5kZXgubWF4UGVyY2VudENoYW5nZSAnJWQnIGRlYmUgZXN0YXIgZW50cmUgMCB5IDEwMCIKIAotIzogY29uZmlnLmM6MjM3OQorIzogY29uZmlnLmM6MjM1MgogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gcGFyc2UgJyVzJyBmcm9tIGNvbW1hbmQtbGluZSBjb25maWciCiBtc2dzdHIgIm5vIGVzIHBvc2libGUgYW5hbGl6YXIgJyVzJyBkZSBsYSBjb25maWd1cmFjacOzbiBkZSBsYSBsw61uZWEgZGUgY29tYW5kbyIKIAotIzogY29uZmlnLmM6MjM4MQorIzogY29uZmlnLmM6MjM1NAogIywgYy1mb3JtYXQKIG1zZ2lkICJiYWQgY29uZmlnIHZhcmlhYmxlICclcycgaW4gZmlsZSAnJXMnIGF0IGxpbmUgJWQiCiBtc2dzdHIgIm1hbGEgdmFyaWFibGUgZGUgY29uZmlnICclcycgZW4gZWwgYXJjaGl2byAnJXMnIGVuIGxhIGzDrW5lYSAlZCIKIAotIzogY29uZmlnLmM6MjQ2MgorIzogY29uZmlnLmM6MjQzNQogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIHNlY3Rpb24gbmFtZSAnJXMnIgogbXNnc3RyICJub21icmUgZGUgc2VjY2nDs24gaW52w6FsaWRvICclcyciCiAKLSM6IGNvbmZpZy5jOjI0OTQKKyM6IGNvbmZpZy5jOjI0NjcKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgaGFzIG11bHRpcGxlIHZhbHVlcyIKIG1zZ3N0ciAiJXMgdGllbmUgbcO6bHRpcGxlcyB2YWxvcmVzIgogCi0jOiBjb25maWcuYzoyNTIzCisjOiBjb25maWcuYzoyNDk2CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byB3cml0ZSBuZXcgY29uZmlndXJhdGlvbiBmaWxlICVzIgogbXNnc3RyICJmYWxsw7MgYWwgZXNjcmliaXIgbnVldm8gYXJjaGl2byBkZSBjb25maWd1cmFjacOzbiAlcyIKIAotIzogY29uZmlnLmM6Mjc3NSBjb25maWcuYzozMDk5CisjOiBjb25maWcuYzoyNzQ4IGNvbmZpZy5jOjMwNzIKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGxvY2sgY29uZmlnIGZpbGUgJXMiCiBtc2dzdHIgIm5vIHNlIHB1ZG8gYmxvcXVlYXIgYXJjaGl2byBkZSBjb25maWd1cmFjacOzbiAlcyIKIAotIzogY29uZmlnLmM6Mjc4NgorIzogY29uZmlnLmM6Mjc1OQogIywgYy1mb3JtYXQKIG1zZ2lkICJvcGVuaW5nICVzIgogbXNnc3RyICJhYnJpZW5kbyAlcyIKIAotIzogY29uZmlnLmM6MjgyMSBidWlsdGluL2NvbmZpZy5jOjMyOAorIzogY29uZmlnLmM6Mjc5NCBidWlsdGluL2NvbmZpZy5jOjMyOAogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIHBhdHRlcm46ICVzIgogbXNnc3RyICJwYXRyw7NuIGludsOhbGlkbzogJXMiCiAKLSM6IGNvbmZpZy5jOjI4NDYKKyM6IGNvbmZpZy5jOjI4MTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBjb25maWcgZmlsZSAlcyIKIG1zZ3N0ciAiYXJjaGl2byBkZSBjb25maWd1cmFjacOzbiBpbnbDoWxpZG86ICVzIgogCi0jOiBjb25maWcuYzoyODU5IGNvbmZpZy5jOjMxMTIKKyM6IGNvbmZpZy5jOjI4MzIgY29uZmlnLmM6MzA4NQogIywgYy1mb3JtYXQKIG1zZ2lkICJmc3RhdCBvbiAlcyBmYWlsZWQiCiBtc2dzdHIgImZzdGF0IGVuICVzIGZhbGzDsyIKIAotIzogY29uZmlnLmM6Mjg3MAorIzogY29uZmlnLmM6Mjg0MwogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gbW1hcCAnJXMnIgogbXNnc3RyICJubyBlcyBwb3NpYmxlIGhhY2VyIG1tYXAgJyVzJyIKIAotIzogY29uZmlnLmM6Mjg3OSBjb25maWcuYzozMTE3CisjOiBjb25maWcuYzoyODUyIGNvbmZpZy5jOjMwOTAKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2htb2Qgb24gJXMgZmFpbGVkIgogbXNnc3RyICJjaG1vZCBlbiAlcyBmYWxsw7MiCiAKLSM6IGNvbmZpZy5jOjI5NjQgY29uZmlnLmM6MzIxNAorIzogY29uZmlnLmM6MjkzNyBjb25maWcuYzozMTg3CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCB3cml0ZSBjb25maWcgZmlsZSAlcyIKIG1zZ3N0ciAibm8gc2UgcHVkbyBlc2NyaWJpciBlbCBhcmNoaXZvIGRlIGNvbmZpZ3VyYWNpw7NuICVzIgogCi0jOiBjb25maWcuYzoyOTk4CisjOiBjb25maWcuYzoyOTcxCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBzZXQgJyVzJyB0byAnJXMnIgogbXNnc3RyICJubyBzZSBwdWRvIGNvbmZpZ3VyYXIgJyVzJyBhICclcyciCiAKLSM6IGNvbmZpZy5jOjMwMDAgYnVpbHRpbi9yZW1vdGUuYzo3ODIKKyM6IGNvbmZpZy5jOjI5NzMgYnVpbHRpbi9yZW1vdGUuYzo3ODIKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHVuc2V0ICclcyciCiBtc2dzdHIgIm5vIHNlIHB1ZG8gZGVzYWN0aXZhciAnJXMnIgogCi0jOiBjb25maWcuYzozMDkwCisjOiBjb25maWcuYzozMDYzCiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgc2VjdGlvbiBuYW1lOiAlcyIKIG1zZ3N0ciAic2VjY2nDs24gZGUgbm9tYnJlIGludsOhbGlkYTogJXMiCiAKLSM6IGNvbmZpZy5jOjMyNTcKKyM6IGNvbmZpZy5jOjMyMzAKICMsIGMtZm9ybWF0CiBtc2dpZCAibWlzc2luZyB2YWx1ZSBmb3IgJyVzJyIKIG1zZ3N0ciAidmFsb3IgZmFsdGFudGUgcGFyYSAnJXMnIgpAQCAtMjExNiw3ICsyMTI1LDcgQEAKIG1zZ2lkICJ1bmtub3duIHBvcnQgJXMiCiBtc2dzdHIgInB1ZXJ0byBkZXNjb25vY2lkbyAlcyIKIAotIzogY29ubmVjdC5jOjg0NSBjb25uZWN0LmM6MTE3MQorIzogY29ubmVjdC5jOjg0NSBjb25uZWN0LmM6MTE3NQogIywgYy1mb3JtYXQKIG1zZ2lkICJzdHJhbmdlIGhvc3RuYW1lICclcycgYmxvY2tlZCIKIG1zZ3N0ciAiaG9zdG5hbWUgZXh0cmHDsW8gJyVzJyBibG9xdWVhZG8iCkBAIC0yMTMxLDU5ICsyMTQwLDU5IEBACiBtc2dpZCAiY2Fubm90IHN0YXJ0IHByb3h5ICVzIgogbXNnc3RyICJubyBzZSBwdWVkZSBjb21lbnphciBwcm94eSAlcyIKIAotIzogY29ubmVjdC5jOjkyNAorIzogY29ubmVjdC5jOjkyOAogbXNnaWQgIm5vIHBhdGggc3BlY2lmaWVkOyBzZWUgJ2dpdCBoZWxwIHB1bGwnIGZvciB2YWxpZCB1cmwgc3ludGF4IgogbXNnc3RyICIiCiAibm8gaGF5IHJ1dGEgZXNwZWNpZmljYWRhOyB2ZWEgJ2dpdCBoZWxwIHB1bGwnIHBhcmEgc2ludGF4aXMgZGUgdXJsIHbDoWxpZGFzIgogCi0jOiBjb25uZWN0LmM6MTExOQorIzogY29ubmVjdC5jOjExMjMKIG1zZ2lkICJzc2ggdmFyaWFudCAnc2ltcGxlJyBkb2VzIG5vdCBzdXBwb3J0IC00IgogbXNnc3RyICJ2YXJpYW50ZSAnc2ltcGxlJyBkZSBzc2ggbm8gc29wb3J0YSAtNCIKIAotIzogY29ubmVjdC5jOjExMzEKKyM6IGNvbm5lY3QuYzoxMTM1CiBtc2dpZCAic3NoIHZhcmlhbnQgJ3NpbXBsZScgZG9lcyBub3Qgc3VwcG9ydCAtNiIKIG1zZ3N0ciAidmFyaWFudGUgJ3NpbXBsZScgZGUgc3NoIG5vIHNvcG9ydGEgLTYiCiAKLSM6IGNvbm5lY3QuYzoxMTQ4CisjOiBjb25uZWN0LmM6MTE1MgogbXNnaWQgInNzaCB2YXJpYW50ICdzaW1wbGUnIGRvZXMgbm90IHN1cHBvcnQgc2V0dGluZyBwb3J0IgogbXNnc3RyICJ2YXJpYW50ZSBzc2ggJ3NpbXBsZScgbm8gc29wb3J0YSBjb25maWd1cmFyIHB1ZXJ0byIKIAotIzogY29ubmVjdC5jOjEyNjAKKyM6IGNvbm5lY3QuYzoxMjY0CiAjLCBjLWZvcm1hdAogbXNnaWQgInN0cmFuZ2UgcGF0aG5hbWUgJyVzJyBibG9ja2VkIgogbXNnc3RyICJydXRhIGV4dHJhw7FhICclcycgYmxvcXVlYWRhIgogCi0jOiBjb25uZWN0LmM6MTMwNworIzogY29ubmVjdC5jOjEzMTEKIG1zZ2lkICJ1bmFibGUgdG8gZm9yayIKIG1zZ3N0ciAibm8gZXMgcG9zaWJsZSBoYWNlciBmb3JrIgogCi0jOiBjb25uZWN0ZWQuYzo4NiBidWlsdGluL2ZzY2suYzoyMjEgYnVpbHRpbi9wcnVuZS5jOjQzCisjOiBjb25uZWN0ZWQuYzo4OCBidWlsdGluL2ZzY2suYzoyMjEgYnVpbHRpbi9wcnVuZS5jOjQzCiBtc2dpZCAiQ2hlY2tpbmcgY29ubmVjdGl2aXR5IgogbXNnc3RyICJWZXJpZmljYW5kbyBjb25lY3RpdmlkYWQiCiAKLSM6IGNvbm5lY3RlZC5jOjk4CisjOiBjb25uZWN0ZWQuYzoxMDAKIG1zZ2lkICJDb3VsZCBub3QgcnVuICdnaXQgcmV2LWxpc3QnIgogbXNnc3RyICJObyBzZSBwdWRvIGNvcnJlciAnZ2l0IHJldi1saXN0JyIKIAotIzogY29ubmVjdGVkLmM6MTE4CisjOiBjb25uZWN0ZWQuYzoxMjAKIG1zZ2lkICJmYWlsZWQgd3JpdGUgdG8gcmV2LWxpc3QiCiBtc2dzdHIgImZhbGzDsyBlc2NyaWJpciBhIHJldi1saXN0IgogCi0jOiBjb25uZWN0ZWQuYzoxMjUKKyM6IGNvbm5lY3RlZC5jOjEyNwogbXNnaWQgImZhaWxlZCB0byBjbG9zZSByZXYtbGlzdCdzIHN0ZGluIgogbXNnc3RyICJmYWxsw7MgYWwgY2VycmFyIGxhIGVudHJhZGEgc3RhbmRhcmQgZGUgcmV2LWxpc3QiCiAKLSM6IGNvbnZlcnQuYzoxOTMKKyM6IGNvbnZlcnQuYzoxOTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiaWxsZWdhbCBjcmxmX2FjdGlvbiAlZCIKIG1zZ3N0ciAiY3JsZl9hY3Rpb24gJWQgaWxlZ2FsIgogCi0jOiBjb252ZXJ0LmM6MjA2CisjOiBjb252ZXJ0LmM6MjA3CiAjLCBjLWZvcm1hdAogbXNnaWQgIkNSTEYgd291bGQgYmUgcmVwbGFjZWQgYnkgTEYgaW4gJXMiCiBtc2dzdHIgIkNSTEYgc2Vyw6EgcmVlbXBsYXphZG8gcG9yIExGIGVuICVzIgogCi0jOiBjb252ZXJ0LmM6MjA4CisjOiBjb252ZXJ0LmM6MjA5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJDUkxGIHdpbGwgYmUgcmVwbGFjZWQgYnkgTEYgaW4gJXMuXG4iCkBAIC0yMTkyLDEyICsyMjAxLDEyIEBACiAiQ1JMRiBzZXLDoSByZW1wbGF6YWRvIHBvciBMRiBlbiAlcy5cbiIKICJFbCBhcmNoaXZvIHRlbmRyw6Egc3VzIGZpbmFsZXMgZGUgbMOtbmVhIG9yaWdpbmFsZXMgZW4gdHUgZGlyZWN0b3JpbyBkZSB0cmFiYWpvIgogCi0jOiBjb252ZXJ0LmM6MjE2CisjOiBjb252ZXJ0LmM6MjE3CiAjLCBjLWZvcm1hdAogbXNnaWQgIkxGIHdvdWxkIGJlIHJlcGxhY2VkIGJ5IENSTEYgaW4gJXMiCiBtc2dzdHIgIkxGIHNlcsOhIHJlZW1wbGF6YWRvIHBvciBDUkxGIGVuICVzIgogCi0jOiBjb252ZXJ0LmM6MjE4CisjOiBjb252ZXJ0LmM6MjE5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJMRiB3aWxsIGJlIHJlcGxhY2VkIGJ5IENSTEYgaW4gJXMuXG4iCkBAIC0yMjA2LDEyICsyMjE1LDEyIEBACiAiTEYgc2Vyw6EgcmVlbXBsYXphZG8gcG9yIENSTEYgZW4gJXMuXG4iCiAiRWwgYXJjaGl2byB0ZW5kcsOhIHN1cyBmaW5hbGVzIGRlIGzDrW5lYSBvcmlnaW5hbGVzIGVuIHR1IGRpcmVjdG9yaW8gZGUgdHJhYmFqbyIKIAotIzogY29udmVydC5jOjI3OQorIzogY29udmVydC5jOjI4MAogIywgYy1mb3JtYXQKIG1zZ2lkICJCT00gaXMgcHJvaGliaXRlZCBpbiAnJXMnIGlmIGVuY29kZWQgYXMgJXMiCiBtc2dzdHIgIkJPTSBlc3TDoSBwcm9oaWJpZG8gZW4gJyVzJyBzaSBlcyBjb2RpZmljYWRvIGNvbW8gJXMiCiAKLSM6IGNvbnZlcnQuYzoyODYKKyM6IGNvbnZlcnQuYzoyODcKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlRoZSBmaWxlICclcycgY29udGFpbnMgYSBieXRlIG9yZGVyIG1hcmsgKEJPTSkuIFBsZWFzZSB1c2UgVVRGLSVzIGFzIHdvcmtpbmctIgpAQCAtMjIyMCwxMiArMjIyOSwxMiBAQAogIkVsIGFyY2hpdm8gJyVzJyBjb250aWVuZSB1bmEgbWFyY2EgZGUgYnl0ZSAoQk9NKS4gUG9yIGZhdm9yIHVzYSBVVEYtJXMgY29tbyAiCiAid29ya2luZy10cmVlLWVuY29kaW5nLiIKIAotIzogY29udmVydC5jOjMwNAorIzogY29udmVydC5jOjMwNQogIywgYy1mb3JtYXQKIG1zZ2lkICJCT00gaXMgcmVxdWlyZWQgaW4gJyVzJyBpZiBlbmNvZGVkIGFzICVzIgogbXNnc3RyICJCT00gZXMgcmVxdWVyaWRvIGVuICclcycgc2kgZXMgY29kaWZpY2FkbyBjb21vICVzIgogCi0jOiBjb252ZXJ0LmM6MzA2CisjOiBjb252ZXJ0LmM6MzA3CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgZmlsZSAnJXMnIGlzIG1pc3NpbmcgYSBieXRlIG9yZGVyIG1hcmsgKEJPTSkuIFBsZWFzZSB1c2UgVVRGLSVzQkUgb3IgVVRGLSIKQEAgLTIyMzQsNTAgKzIyNDMsNTAgQEAKICJBbCBhcmNoaXZvICclcycgbGUgZmFsdGEgdW5hIG1hcmNhIGRlIGJ5dGUgKEJPTSkuIFBvciBmYXZvciB1c2EgVVRGLSVzQkUgbyAiCiAiVVRGLSVzTEUgKGRlcGVuZGllbmRvIGVuIGVsIG9yZGVuIGRlIGJ5dGUpIGNvbW8gd29ya2luZy10cmVlLWVuY29kaW5nLiIKIAotIzogY29udmVydC5jOjQyNCBjb252ZXJ0LmM6NDk1CisjOiBjb252ZXJ0LmM6NDI1IGNvbnZlcnQuYzo0OTYKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIGVuY29kZSAnJXMnIGZyb20gJXMgdG8gJXMiCiBtc2dzdHIgImZhbGzDsyBhbCBjb2RpZmljYXIgJyVzJyBkZSAlcyBhICVzIgogCi0jOiBjb252ZXJ0LmM6NDY3CisjOiBjb252ZXJ0LmM6NDY4CiAjLCBjLWZvcm1hdAogbXNnaWQgImVuY29kaW5nICclcycgZnJvbSAlcyB0byAlcyBhbmQgYmFjayBpcyBub3QgdGhlIHNhbWUiCiBtc2dzdHIgImNvZGlmaWNhY2nDs24gJyVzJyBkZSAlcyBhICVzIHkgZGUgdnVlbHRhIG5vIHNvbiBpZ3VhbGVzIgogCi0jOiBjb252ZXJ0LmM6NjczCisjOiBjb252ZXJ0LmM6Njc0CiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCBmb3JrIHRvIHJ1biBleHRlcm5hbCBmaWx0ZXIgJyVzJyIKIG1zZ3N0ciAibm8gc2UgcHVlZGUgaGFjZXIgZm9yayBwYXJhIGVqZWN1dGFyIGZpbHRyb3MgZXh0ZXJub3MgJyVzJyIKIAotIzogY29udmVydC5jOjY5MworIzogY29udmVydC5jOjY5NAogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgZmVlZCB0aGUgaW5wdXQgdG8gZXh0ZXJuYWwgZmlsdGVyICclcyciCiBtc2dzdHIgIm5vIHNlIHB1ZWRlbiBhbGltZW50YXIgZGUgaW5wdXQgYSBsb3MgZmlsdHJvcyBleHRlcm5vcyAnJXMnIgogCi0jOiBjb252ZXJ0LmM6NzAwCisjOiBjb252ZXJ0LmM6NzAxCiAjLCBjLWZvcm1hdAogbXNnaWQgImV4dGVybmFsIGZpbHRlciAnJXMnIGZhaWxlZCAlZCIKIG1zZ3N0ciAiZmlsdHJvIGV4dGVybm8gJyVzJyBmYWxsw7MgJWQiCiAKLSM6IGNvbnZlcnQuYzo3MzUgY29udmVydC5jOjczOAorIzogY29udmVydC5jOjczNiBjb252ZXJ0LmM6NzM5CiAjLCBjLWZvcm1hdAogbXNnaWQgInJlYWQgZnJvbSBleHRlcm5hbCBmaWx0ZXIgJyVzJyBmYWlsZWQiCiBtc2dzdHIgImxlY3R1cmEgZGUgZmlsdHJvIGV4dGVybm8gJyVzJyBmYWxsw7MiCiAKLSM6IGNvbnZlcnQuYzo3NDEgY29udmVydC5jOjc5NgorIzogY29udmVydC5jOjc0MiBjb252ZXJ0LmM6Nzk3CiAjLCBjLWZvcm1hdAogbXNnaWQgImV4dGVybmFsIGZpbHRlciAnJXMnIGZhaWxlZCIKIG1zZ3N0ciAiZmlsdHJvIGV4dGVybm8gJyVzJyBmYWxsw7MiCiAKLSM6IGNvbnZlcnQuYzo4NDQKKyM6IGNvbnZlcnQuYzo4NDUKIG1zZ2lkICJ1bmV4cGVjdGVkIGZpbHRlciB0eXBlIgogbXNnc3RyICJ0aXBvIGRlIGZpbHRybyBpbmVzcGVyYWRvIgogCi0jOiBjb252ZXJ0LmM6ODU1CisjOiBjb252ZXJ0LmM6ODU2CiBtc2dpZCAicGF0aCBuYW1lIHRvbyBsb25nIGZvciBleHRlcm5hbCBmaWx0ZXIiCiBtc2dzdHIgIm5vbWJyZSBkZSBydXRhIG11eSBsYXJnbyBwYXJhIGZpbHRybyBleHRlcm5vIgogCi0jOiBjb252ZXJ0LmM6OTI5CisjOiBjb252ZXJ0LmM6OTMwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJleHRlcm5hbCBmaWx0ZXIgJyVzJyBpcyBub3QgYXZhaWxhYmxlIGFueW1vcmUgYWx0aG91Z2ggbm90IGFsbCBwYXRocyBoYXZlICIKQEAgLTIyODYsNjcgKzIyOTUsNjcgQEAKICJmaWx0cm8gZXh0ZXJubyAnJXMnIHlhIG5vIGVzdMOhIGRpc3BvbmlibGUgYXVucXVlIG5vIHRvZGFzIGxhcyBydXRhcyBoYW4gc2lkbyAiCiAiZmlsdHJhZGFzIgogCi0jOiBjb252ZXJ0LmM6MTIyOAorIzogY29udmVydC5jOjEyMjkKIG1zZ2lkICJ0cnVlL2ZhbHNlIGFyZSBubyB2YWxpZCB3b3JraW5nLXRyZWUtZW5jb2RpbmdzIgogbXNnc3RyICJ0cnVlL2ZhbHNlIG5vIHNvbiB3b3JraW5nLXRyZWUtZW5jb2RpbmdzIHbDoWxpZG9zIgogCi0jOiBjb252ZXJ0LmM6MTM5OCBjb252ZXJ0LmM6MTQzMgorIzogY29udmVydC5jOjE0MTcgY29udmVydC5jOjE0NTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXM6IGNsZWFuIGZpbHRlciAnJXMnIGZhaWxlZCIKIG1zZ3N0ciAiJXM6IGZhbGzDsyBhbCBsaW1waWFyIGZpbHRybyAnJXMnIgogCi0jOiBjb252ZXJ0LmM6MTQ3NgorIzogY29udmVydC5jOjE0OTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXM6IHNtdWRnZSBmaWx0ZXIgJXMgZmFpbGVkIgogbXNnc3RyICIlczogZmlsdHJvIHNtdWRnZSAlcyBmYWxsw7MiCiAKLSM6IGRhdGUuYzoxMzcKKyM6IGRhdGUuYzoxMzgKIG1zZ2lkICJpbiB0aGUgZnV0dXJlIgogbXNnc3RyICJlbiBlbCBmdXR1cm8iCiAKLSM6IGRhdGUuYzoxNDMKKyM6IGRhdGUuYzoxNDQKICMsIGMtZm9ybWF0CiBtc2dpZCAiJTxQUkl1TUFYPiBzZWNvbmQgYWdvIgogbXNnaWRfcGx1cmFsICIlPFBSSXVNQVg+IHNlY29uZHMgYWdvIgogbXNnc3RyWzBdICJoYWNlICU8UFJJdU1BWD4gc2VndW5kbyIKIG1zZ3N0clsxXSAiaGFjZSAlPFBSSXVNQVg+IHNlZ3VuZG9zIgogCi0jOiBkYXRlLmM6MTUwCisjOiBkYXRlLmM6MTUxCiAjLCBjLWZvcm1hdAogbXNnaWQgIiU8UFJJdU1BWD4gbWludXRlIGFnbyIKIG1zZ2lkX3BsdXJhbCAiJTxQUkl1TUFYPiBtaW51dGVzIGFnbyIKIG1zZ3N0clswXSAiaGFjZSAlPFBSSXVNQVg+IG1pbnV0byIKIG1zZ3N0clsxXSAiaGFjZSAlPFBSSXVNQVg+IG1pbnV0b3MiCiAKLSM6IGRhdGUuYzoxNTcKKyM6IGRhdGUuYzoxNTgKICMsIGMtZm9ybWF0CiBtc2dpZCAiJTxQUkl1TUFYPiBob3VyIGFnbyIKIG1zZ2lkX3BsdXJhbCAiJTxQUkl1TUFYPiBob3VycyBhZ28iCiBtc2dzdHJbMF0gImhhY2UgJTxQUkl1TUFYPiBob3JhIgogbXNnc3RyWzFdICJoYWNlICU8UFJJdU1BWD4gaG9yYXMiCiAKLSM6IGRhdGUuYzoxNjQKKyM6IGRhdGUuYzoxNjUKICMsIGMtZm9ybWF0CiBtc2dpZCAiJTxQUkl1TUFYPiBkYXkgYWdvIgogbXNnaWRfcGx1cmFsICIlPFBSSXVNQVg+IGRheXMgYWdvIgogbXNnc3RyWzBdICJoYWNlICU8UFJJdU1BWD4gZMOtYSIKIG1zZ3N0clsxXSAiaGFjZSAlPFBSSXVNQVg+IGTDrWFzIgogCi0jOiBkYXRlLmM6MTcwCisjOiBkYXRlLmM6MTcxCiAjLCBjLWZvcm1hdAogbXNnaWQgIiU8UFJJdU1BWD4gd2VlayBhZ28iCiBtc2dpZF9wbHVyYWwgIiU8UFJJdU1BWD4gd2Vla3MgYWdvIgogbXNnc3RyWzBdICJoYWNlICU8UFJJdU1BWD4gc2VtYW5hIgogbXNnc3RyWzFdICJoYWNlICU8UFJJdU1BWD4gc2VtYW5hcyIKIAotIzogZGF0ZS5jOjE3NworIzogZGF0ZS5jOjE3OAogIywgYy1mb3JtYXQKIG1zZ2lkICIlPFBSSXVNQVg+IG1vbnRoIGFnbyIKIG1zZ2lkX3BsdXJhbCAiJTxQUkl1TUFYPiBtb250aHMgYWdvIgogbXNnc3RyWzBdICJoYWNlICU8UFJJdU1BWD4gbWVzIgogbXNnc3RyWzFdICJoYWNlICU8UFJJdU1BWD4gbWVzZXMiCiAKLSM6IGRhdGUuYzoxODgKKyM6IGRhdGUuYzoxODkKICMsIGMtZm9ybWF0CiBtc2dpZCAiJTxQUkl1TUFYPiB5ZWFyIgogbXNnaWRfcGx1cmFsICIlPFBSSXVNQVg+IHllYXJzIgpAQCAtMjM1NCwxNCArMjM2MywxNCBAQAogbXNnc3RyWzFdICIlPFBSSXVNQVg+IGHDsW9zIgogCiAjLiBUUkFOU0xBVE9SUzogIiVzIiBpcyAiPG4+IHllYXJzIgotIzogZGF0ZS5jOjE5MQorIzogZGF0ZS5jOjE5MgogIywgYy1mb3JtYXQKIG1zZ2lkICIlcywgJTxQUkl1TUFYPiBtb250aCBhZ28iCiBtc2dpZF9wbHVyYWwgIiVzLCAlPFBSSXVNQVg+IG1vbnRocyBhZ28iCiBtc2dzdHJbMF0gIiVzLCB5ICU8UFJJdU1BWD4gbWVzIGF0csOhcyIKIG1zZ3N0clsxXSAiJXMsIHkgJTxQUkl1TUFYPiBtZXNlcyBhdHLDoXMiCiAKLSM6IGRhdGUuYzoxOTYgZGF0ZS5jOjIwMQorIzogZGF0ZS5jOjE5NyBkYXRlLmM6MjAyCiAjLCBjLWZvcm1hdAogbXNnaWQgIiU8UFJJdU1BWD4geWVhciBhZ28iCiBtc2dpZF9wbHVyYWwgIiU8UFJJdU1BWD4geWVhcnMgYWdvIgpAQCAtMjM5Nyw3ICsyNDA2LDcgQEAKIG1zZ2lkICJmYWlsZWQgdG8gcmVhZCBvcmRlcmZpbGUgJyVzJyIKIG1zZ3N0ciAiZmFsbMOzIGFsIGxlZXIgb3JkZW4gZGUgYXJjaGl2b3MgJyVzJyIKIAotIzogZGlmZmNvcmUtcmVuYW1lLmM6NTQ0CisjOiBkaWZmY29yZS1yZW5hbWUuYzo1NDMKIG1zZ2lkICJQZXJmb3JtaW5nIGluZXhhY3QgcmVuYW1lIGRldGVjdGlvbiIKIG1zZ3N0ciAiUmVhbGl6YW5kbyB1bmEgZGV0ZWNjacOzbiBkZSBjYW1iaW9zIGRlIG5vbWJyZSBpbmV4YWN0YSIKIApAQCAtMjQ2NCwzNSArMjQ3MywzNSBAQAogIkVycm9yZXMgZW4gbGEgdmFyaWFibGUgZGUgY29uZmlnICdkaWZmLmRpcnN0YXQnIGVuY29udHJhZG9zOlxuIgogIiVzIgogCi0jOiBkaWZmLmM6NDIxNQorIzogZGlmZi5jOjQyMTgKICMsIGMtZm9ybWF0CiBtc2dpZCAiZXh0ZXJuYWwgZGlmZiBkaWVkLCBzdG9wcGluZyBhdCAlcyIKIG1zZ3N0ciAiZGlmZiBleHRlcm5vIG11cmnDsywgZGV0ZW5pZW5kbyBlbiAlcyIKIAotIzogZGlmZi5jOjQ1NjAKKyM6IGRpZmYuYzo0NTYzCiBtc2dpZCAiLS1uYW1lLW9ubHksIC0tbmFtZS1zdGF0dXMsIC0tY2hlY2sgYW5kIC1zIGFyZSBtdXR1YWxseSBleGNsdXNpdmUiCiBtc2dzdHIgIi0tbmFtZS1vbmx5LCAtLW5hbWUtc3RhdHVzLCAtLWNoZWNrIHkgLXMgc29uIG11dHVhbWVudGUgZXhjbHVzaXZhcyIKIAotIzogZGlmZi5jOjQ1NjMKKyM6IGRpZmYuYzo0NTY2CiBtc2dpZCAiLUcsIC1TIGFuZCAtLWZpbmQtb2JqZWN0IGFyZSBtdXR1YWxseSBleGNsdXNpdmUiCiBtc2dzdHIgIi1HLCAtUyB5IC0tZmluZC1vYmplY3Qgc29uIG11dHVhbWVudGUgZXhjbHVzaXZhcyIKIAotIzogZGlmZi5jOjQ2NDEKKyM6IGRpZmYuYzo0NjQ0CiBtc2dpZCAiLS1mb2xsb3cgcmVxdWlyZXMgZXhhY3RseSBvbmUgcGF0aHNwZWMiCiBtc2dzdHIgIi0tZm9sbG93IHJlcXVpZXJlIGV4YWN0YW1lbnRlIHVuIHBhdGhzcGVjIgogCi0jOiBkaWZmLmM6NDY4OQorIzogZGlmZi5jOjQ2OTIKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCAtLXN0YXQgdmFsdWU6ICVzIgogbXNnc3RyICJ2YWxvciAtLXN0YXQgaW52w6FsaWRvOiAlcyIKIAotIzogZGlmZi5jOjQ2OTQgZGlmZi5jOjQ2OTkgZGlmZi5jOjQ3MDQgZGlmZi5jOjQ3MDkgZGlmZi5jOjUyMjIKKyM6IGRpZmYuYzo0Njk3IGRpZmYuYzo0NzAyIGRpZmYuYzo0NzA3IGRpZmYuYzo0NzEyIGRpZmYuYzo1MjI1CiAjOiBwYXJzZS1vcHRpb25zLmM6MTk5IHBhcnNlLW9wdGlvbnMuYzoyMDMKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgZXhwZWN0cyBhIG51bWVyaWNhbCB2YWx1ZSIKIG1zZ3N0ciAiJXMgZXNwZXJhIHVuIHZhbG9yIG51bcOpcmljbyIKIAotIzogZGlmZi5jOjQ3MjYKKyM6IGRpZmYuYzo0NzI5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJGYWlsZWQgdG8gcGFyc2UgLS1kaXJzdGF0Ly1YIG9wdGlvbiBwYXJhbWV0ZXI6XG4iCkBAIC0yNTAxLDQyICsyNTEwLDQyIEBACiAiRmFsbMOzIGFsIGFuYWxpemFyIHBhcsOhbWV0cm8gZGUgb3BjacOzbiAtLWRpcnN0YXQvLVg6XG4iCiAiJXMiCiAKLSM6IGRpZmYuYzo0ODExCisjOiBkaWZmLmM6NDgxNAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmtub3duIGNoYW5nZSBjbGFzcyAnJWMnIGluIC0tZGlmZi1maWx0ZXI9JXMiCiBtc2dzdHIgImNhbWJpbyBkZSBjbGFzZSBkZXNjb25vY2lkbyAnJWMnIGVuIC0tZGlmZi1maWx0ZXI9JXMiCiAKLSM6IGRpZmYuYzo0ODM1CisjOiBkaWZmLmM6NDgzOAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmtub3duIHZhbHVlIGFmdGVyIHdzLWVycm9yLWhpZ2hsaWdodD0lLipzIgogbXNnc3RyICJ2YWxvciBkZXNjb25vY2lkbyBsdWVnbyBkZSB3cy1lcnJvci1oaWdobGlnaHQ9JS4qcyIKIAotIzogZGlmZi5jOjQ4NDkKKyM6IGRpZmYuYzo0ODUyCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byByZXNvbHZlICclcyciCiBtc2dzdHIgIm5vIHNlIHB1ZWRlIHJlc29sdmVyICclcyciCiAKLSM6IGRpZmYuYzo0ODk5IGRpZmYuYzo0OTA1CisjOiBkaWZmLmM6NDkwMiBkaWZmLmM6NDkwOAogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyBleHBlY3RzIDxuPi88bT4gZm9ybSIKIG1zZ3N0ciAiJXMgZXNwZXJhIGZvcm1hIDxuPi88bT4iCiAKLSM6IGRpZmYuYzo0OTE3CisjOiBkaWZmLmM6NDkyMAogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyBleHBlY3RzIGEgY2hhcmFjdGVyLCBnb3QgJyVzJyIKIG1zZ3N0ciAiJXMgZXNwZXJhYmEgdW4gY2hhciwgc2Ugb2J0dXZvICclcyciCiAKLSM6IGRpZmYuYzo0OTM4CisjOiBkaWZmLmM6NDk0MQogIywgYy1mb3JtYXQKIG1zZ2lkICJiYWQgLS1jb2xvci1tb3ZlZCBhcmd1bWVudDogJXMiCiBtc2dzdHIgIm1hbCBhcmd1bWVudG8gLS1jb2xvci1tb3ZlZDogJXMiCiAKLSM6IGRpZmYuYzo0OTU3CisjOiBkaWZmLmM6NDk2MAogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIG1vZGUgJyVzJyBpbiAtLWNvbG9yLW1vdmVkLXdzIgogbXNnc3RyICJtb2RvIGludsOhbGlkbyAnJXMnIGVuIC0tY29sb3ItbW92ZWQtd3MiCiAKLSM6IGRpZmYuYzo0OTk3CisjOiBkaWZmLmM6NTAwMAogbXNnaWQgIiIKICJvcHRpb24gZGlmZi1hbGdvcml0aG0gYWNjZXB0cyBcIm15ZXJzXCIsIFwibWluaW1hbFwiLCBcInBhdGllbmNlXCIgYW5kICIKICJcImhpc3RvZ3JhbVwiIgpAQCAtMjU0NCwxNTQgKzI1NTMsMTU0IEBACiAib3BjacOzbiBkaWZmLWFsZ29yaXRobSBhY2VwdGEgXCJteWVyc1wiLCBcIm1pbmltYWxcIiwgXCJwYXRpZW5jZVwiIGUgIgogIlwiaGlzdG9ncmFtXCIiCiAKLSM6IGRpZmYuYzo1MDMzIGRpZmYuYzo1MDUzCisjOiBkaWZmLmM6NTAzNiBkaWZmLmM6NTA1NgogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIGFyZ3VtZW50IHRvICVzIgogbXNnc3RyICJhcmd1bWVudG8gaW52w6FsaWRvIHBhcmEgJXMiCiAKLSM6IGRpZmYuYzo1MTkxCisjOiBkaWZmLmM6NTE5NAogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gcGFyc2UgLS1zdWJtb2R1bGUgb3B0aW9uIHBhcmFtZXRlcjogJyVzJyIKIG1zZ3N0ciAiZmFsbMOzIGFsIGFuYWxpemFyIHBhcsOhbWV0cm8gZGUgb3BjacOzbiAtLXN1Ym1vZHVsZTogJyVzJyIKIAotIzogZGlmZi5jOjUyNDcKKyM6IGRpZmYuYzo1MjUwCiAjLCBjLWZvcm1hdAogbXNnaWQgImJhZCAtLXdvcmQtZGlmZiBhcmd1bWVudDogJXMiCiBtc2dzdHIgIm1hbCBhcmd1bWVudG8gLS13b3JkLWRpZmY6ICVzIgogCi0jOiBkaWZmLmM6NTI3MAorIzogZGlmZi5jOjUyNzMKIG1zZ2lkICJEaWZmIG91dHB1dCBmb3JtYXQgb3B0aW9ucyIKIG1zZ3N0ciAiT3BjaW9uZXMgZGUgZm9ybWF0byBkZSBzYWxpZGEgcGFyYSBkaWZmIgogCi0jOiBkaWZmLmM6NTI3MiBkaWZmLmM6NTI3OAorIzogZGlmZi5jOjUyNzUgZGlmZi5jOjUyODEKIG1zZ2lkICJnZW5lcmF0ZSBwYXRjaCIKIG1zZ3N0ciAiZ2VuZXJhciBwYXJjaGUiCiAKLSM6IGRpZmYuYzo1Mjc1IGJ1aWx0aW4vbG9nLmM6MTcyCisjOiBkaWZmLmM6NTI3OCBidWlsdGluL2xvZy5jOjE3MgogbXNnaWQgInN1cHByZXNzIGRpZmYgb3V0cHV0IgogbXNnc3RyICJzdXByaW1pciBzYWxpZGEgZGUgZGlmZiIKIAotIzogZGlmZi5jOjUyODAgZGlmZi5jOjUzOTQgZGlmZi5jOjU0MDEKKyM6IGRpZmYuYzo1MjgzIGRpZmYuYzo1Mzk3IGRpZmYuYzo1NDA0CiBtc2dpZCAiPG4+IgogbXNnc3RyICI8bj4iCiAKLSM6IGRpZmYuYzo1MjgxIGRpZmYuYzo1Mjg0CisjOiBkaWZmLmM6NTI4NCBkaWZmLmM6NTI4NwogbXNnaWQgImdlbmVyYXRlIGRpZmZzIHdpdGggPG4+IGxpbmVzIGNvbnRleHQiCiBtc2dzdHIgImdlbmVyYSBkaWZmcyBjb24gPG4+IGzDrW5lYXMgZGUgY29udGV4dG8iCiAKLSM6IGRpZmYuYzo1Mjg2CisjOiBkaWZmLmM6NTI4OQogbXNnaWQgImdlbmVyYXRlIHRoZSBkaWZmIGluIHJhdyBmb3JtYXQiCiBtc2dzdHIgImdlbmVyYSBlbCBkaWZmIGVuIGZvcm1hdG8gcmF3IgogCi0jOiBkaWZmLmM6NTI4OQorIzogZGlmZi5jOjUyOTIKIG1zZ2lkICJzeW5vbnltIGZvciAnLXAgLS1yYXcnIgogbXNnc3RyICJzaW7Ds25pbW8gcGFyYSAnLXAgLS1zdGF0JyIKIAotIzogZGlmZi5jOjUyOTMKKyM6IGRpZmYuYzo1Mjk2CiBtc2dpZCAic3lub255bSBmb3IgJy1wIC0tc3RhdCciCiBtc2dzdHIgInNpbsOzbmltbyBwYXJhICctcCAtLXN0YXQnIgogCi0jOiBkaWZmLmM6NTI5NworIzogZGlmZi5jOjUzMDAKIG1zZ2lkICJtYWNoaW5lIGZyaWVuZGx5IC0tc3RhdCIKIG1zZ3N0ciAiLS1zdGF0IGFtaWdhYmxlIHBhcmEgbcOhcXVpbmEiCiAKLSM6IGRpZmYuYzo1MzAwCisjOiBkaWZmLmM6NTMwMwogbXNnaWQgIm91dHB1dCBvbmx5IHRoZSBsYXN0IGxpbmUgb2YgLS1zdGF0IgogbXNnc3RyICJtb3N0cmFyIHNvbG8gbGEgw7psdGltYSBsw61uZWEgcGFyYSAtLXN0YXQiCiAKLSM6IGRpZmYuYzo1MzAyIGRpZmYuYzo1MzEwCisjOiBkaWZmLmM6NTMwNSBkaWZmLmM6NTMxMwogbXNnaWQgIjxwYXJhbTEscGFyYW0yPi4uLiIKIG1zZ3N0ciAiPHBhcmFtMSxwYXJhbTI+Li4uIgogCi0jOiBkaWZmLmM6NTMwMworIzogZGlmZi5jOjUzMDYKIG1zZ2lkICIiCiAib3V0cHV0IHRoZSBkaXN0cmlidXRpb24gb2YgcmVsYXRpdmUgYW1vdW50IG9mIGNoYW5nZXMgZm9yIGVhY2ggc3ViLWRpcmVjdG9yeSIKIG1zZ3N0ciAiIgogIm11ZXN0cmEgbGEgZGlzdHJpYnVjacOzbiBkZSBjYW50aWRhZGVzIGRlIGNhbWJpb3MgcmVsYXRpdmEgcGFyYSBjYWRhICIKICJzdWJkaXJlY3RvcmlvIgogCi0jOiBkaWZmLmM6NTMwNworIzogZGlmZi5jOjUzMTAKIG1zZ2lkICJzeW5vbnltIGZvciAtLWRpcnN0YXQ9Y3VtdWxhdGl2ZSIKIG1zZ3N0ciAic2luw7NuaW1vIHBhcmEgLS1kaXJzdGF0PWN1bXVsYXRpdmUiCiAKLSM6IGRpZmYuYzo1MzExCisjOiBkaWZmLmM6NTMxNAogbXNnaWQgInN5bm9ueW0gZm9yIC0tZGlyc3RhdD1maWxlcyxwYXJhbTEscGFyYW0yLi4uIgogbXNnc3RyICJzaW5vbmltbyBwYXJhIC0tZGlyc3RhdD1hcmNoaXZvcyxwYXJhbTEscGFyYW0yLi4uIgogCi0jOiBkaWZmLmM6NTMxNQorIzogZGlmZi5jOjUzMTgKIG1zZ2lkICJ3YXJuIGlmIGNoYW5nZXMgaW50cm9kdWNlIGNvbmZsaWN0IG1hcmtlcnMgb3Igd2hpdGVzcGFjZSBlcnJvcnMiCiBtc2dzdHIgIiIKICJhZHZpZXJ0ZSBzaSBjYW1iaW9zIGludHJvZHVjZW4gY29uZmxpY3RvcyBkZSBtYXJrZXJzIG8gZXJyb3JlcyBkZSBlc3BhY2lvcyAiCiAiZW4gYmxhbmNvIgogCi0jOiBkaWZmLmM6NTMxOAorIzogZGlmZi5jOjUzMjEKIG1zZ2lkICJjb25kZW5zZWQgc3VtbWFyeSBzdWNoIGFzIGNyZWF0aW9ucywgcmVuYW1lcyBhbmQgbW9kZSBjaGFuZ2VzIgogbXNnc3RyICIiCiAicmVzdW1lbiBjb25kZW5zYWRvIGRlIGNyZWFjaW9uZXMsIGNhbWJpb3MgZGUgbm9tYnJlcyB5IGNhbWJpb3MgZGUgbW9kb3MiCiAKLSM6IGRpZmYuYzo1MzIxCisjOiBkaWZmLmM6NTMyNAogbXNnaWQgInNob3cgb25seSBuYW1lcyBvZiBjaGFuZ2VkIGZpbGVzIgogbXNnc3RyICJtb3N0cmFyIHNvbG8gbm9tYnJlcyBkZSBhcmNoaXZvcyBjYW1iaWFkb3MiCiAKLSM6IGRpZmYuYzo1MzI0CisjOiBkaWZmLmM6NTMyNwogbXNnaWQgInNob3cgb25seSBuYW1lcyBhbmQgc3RhdHVzIG9mIGNoYW5nZWQgZmlsZXMiCiBtc2dzdHIgIm1vc3RyYXIgc29sbyBub21icmVzIHkgZXN0YWRvcyBkZSBhcmNoaXZvcyBjYW1iaWFkb3MiCiAKLSM6IGRpZmYuYzo1MzI2CisjOiBkaWZmLmM6NTMyOQogbXNnaWQgIjx3aWR0aD5bLDxuYW1lLXdpZHRoPlssPGNvdW50Pl1dIgogbXNnc3RyICI8YW5jaG8+Wyw8bm9tYnJlLWFuY2hvPlssPGNhbnRpZGFkPl1dIgogCi0jOiBkaWZmLmM6NTMyNworIzogZGlmZi5jOjUzMzAKIG1zZ2lkICJnZW5lcmF0ZSBkaWZmc3RhdCIKIG1zZ3N0ciAiZ2VuZXJhciBkaWZmc3RhdCIKIAotIzogZGlmZi5jOjUzMjkgZGlmZi5jOjUzMzIgZGlmZi5jOjUzMzUKKyM6IGRpZmYuYzo1MzMyIGRpZmYuYzo1MzM1IGRpZmYuYzo1MzM4CiBtc2dpZCAiPHdpZHRoPiIKIG1zZ3N0ciAiPGFuY2hvPiIKIAotIzogZGlmZi5jOjUzMzAKKyM6IGRpZmYuYzo1MzMzCiBtc2dpZCAiZ2VuZXJhdGUgZGlmZnN0YXQgd2l0aCBhIGdpdmVuIHdpZHRoIgogbXNnc3RyICJnZW5lcmEgZGlmZnN0YXQgY29uIHVuIGFuY2hvIGRhZG8iCiAKLSM6IGRpZmYuYzo1MzMzCisjOiBkaWZmLmM6NTMzNgogbXNnaWQgImdlbmVyYXRlIGRpZmZzdGF0IHdpdGggYSBnaXZlbiBuYW1lIHdpZHRoIgogbXNnc3RyICJnZW5lcmEgZGlmZnN0YXQgY29uIHVuIG5vbWJyZSBkZSBhbmNobyBkYWRvIgogCi0jOiBkaWZmLmM6NTMzNgorIzogZGlmZi5jOjUzMzkKIG1zZ2lkICJnZW5lcmF0ZSBkaWZmc3RhdCB3aXRoIGEgZ2l2ZW4gZ3JhcGggd2lkdGgiCiBtc2dzdHIgImdlbmVyYSBkaWZmc3RhdCBjb24gdW4gYW5jaG8gZGUgZ3JhcGggZGFkbyIKIAotIzogZGlmZi5jOjUzMzgKKyM6IGRpZmYuYzo1MzQxCiBtc2dpZCAiPGNvdW50PiIKIG1zZ3N0ciAiPGNhbnRpZGFkPiIKIAotIzogZGlmZi5jOjUzMzkKKyM6IGRpZmYuYzo1MzQyCiBtc2dpZCAiZ2VuZXJhdGUgZGlmZnN0YXQgd2l0aCBsaW1pdGVkIGxpbmVzIgogbXNnc3RyICJnZW5lcmEgZGlmZnN0YXQgY29uIGzDrW5lYXMgbGltaXRhZGFzIgogCi0jOiBkaWZmLmM6NTM0MgorIzogZGlmZi5jOjUzNDUKIG1zZ2lkICJnZW5lcmF0ZSBjb21wYWN0IHN1bW1hcnkgaW4gZGlmZnN0YXQiCiBtc2dzdHIgImdlbmVyYSB1biByZXN1bWVuIGNvbXBhY3RvIGRlIGRpZmZzdGF0IgogCi0jOiBkaWZmLmM6NTM0NQorIzogZGlmZi5jOjUzNDgKIG1zZ2lkICJvdXRwdXQgYSBiaW5hcnkgZGlmZiB0aGF0IGNhbiBiZSBhcHBsaWVkIgogbXNnc3RyICJtdWVzdHJhIHVuIGRpZmYgYmluYXJpbyBxdWUgcHVlZGUgc2VyIGFwbGljYWRvIgogCi0jOiBkaWZmLmM6NTM0OAorIzogZGlmZi5jOjUzNTEKIG1zZ2lkICJzaG93IGZ1bGwgcHJlLSBhbmQgcG9zdC1pbWFnZSBvYmplY3QgbmFtZXMgb24gdGhlIFwiaW5kZXhcIiBsaW5lcyIKIG1zZ3N0ciAiIgogIm1vc3RyYXIgdG9kbyB1biBwcmUtIHkgcG9zdC1pbWFnZSBkZSBub21icmVzIGRlIG9iamV0b3MgZW4gbGFzIGzDrW5lYXMgXCJpbmRleCIKICJcIiIKIAotIzogZGlmZi5jOjUzNTAKKyM6IGRpZmYuYzo1MzUzCiBtc2dpZCAic2hvdyBjb2xvcmVkIGRpZmYiCiBtc2dzdHIgIm1vc3RyYXIgZGlmZiBjb2xvcmlkbyIKIAotIzogZGlmZi5jOjUzNTEKKyM6IGRpZmYuYzo1MzU0CiBtc2dpZCAiPGtpbmQ+IgogbXNnc3RyICI8dGlwbz4iCiAKLSM6IGRpZmYuYzo1MzUyCisjOiBkaWZmLmM6NTM1NQogbXNnaWQgIiIKICJoaWdobGlnaHQgd2hpdGVzcGFjZSBlcnJvcnMgaW4gdGhlICdjb250ZXh0JywgJ29sZCcgb3IgJ25ldycgbGluZXMgaW4gdGhlICIKICJkaWZmIgpAQCAtMjY5OSw3ICsyNzA4LDcgQEAKICJyZXNhbHRhciBlcnJvcmVzIGRlIGVzcGFjaW9zIGVuIGJsYW5jbyBlbiBsYXMgbMOtbmVhcyAnY29udGV4dCcsICdvbGQnIG8gIgogIiduZXcnIGRlbCBkaWZmIgogCi0jOiBkaWZmLmM6NTM1NQorIzogZGlmZi5jOjUzNTgKIG1zZ2lkICIiCiAiZG8gbm90IG11bmdlIHBhdGhuYW1lcyBhbmQgdXNlIE5VTHMgYXMgb3V0cHV0IGZpZWxkIHRlcm1pbmF0b3JzIGluIC0tcmF3IG9yICIKICItLW51bXN0YXQiCkBAIC0yNzA3LDg5ICsyNzE2LDg5IEBACiAibm8gY29uc29saWRhciBsb3MgcGF0aG5hbWVzIHkgdXNhciBOVUxzIGNvbW8gdGVybWluYWRvcmVzIGRlIGNhbXBvcyBlbiAtLXJhdyAiCiAibyAtLW51bXN0YXQiCiAKLSM6IGRpZmYuYzo1MzU4IGRpZmYuYzo1MzYxIGRpZmYuYzo1MzY0IGRpZmYuYzo1NDcwCisjOiBkaWZmLmM6NTM2MSBkaWZmLmM6NTM2NCBkaWZmLmM6NTM2NyBkaWZmLmM6NTQ3MwogbXNnaWQgIjxwcmVmaXg+IgogbXNnc3RyICI8cHJlZmlqbz4iCiAKLSM6IGRpZmYuYzo1MzU5CisjOiBkaWZmLmM6NTM2MgogbXNnaWQgInNob3cgdGhlIGdpdmVuIHNvdXJjZSBwcmVmaXggaW5zdGVhZCBvZiBcImEvXCIiCiBtc2dzdHIgIm1vc3RyYXIgZWwgcHJlZmlqbyBkZSBmdWVudGUgZGFkbyBlbiBsdWdhciBkZSBcImEvXCIiCiAKLSM6IGRpZmYuYzo1MzYyCisjOiBkaWZmLmM6NTM2NQogbXNnaWQgInNob3cgdGhlIGdpdmVuIGRlc3RpbmF0aW9uIHByZWZpeCBpbnN0ZWFkIG9mIFwiYi9cIiIKIG1zZ3N0ciAibW9zdHJhciBlbCBwcmVmaWpvIGRlIGRlc3Rpbm8gZW4gbHVnYXIgZGUgXCJiL1wiIgogCi0jOiBkaWZmLmM6NTM2NQorIzogZGlmZi5jOjUzNjgKIG1zZ2lkICJwcmVwZW5kIGFuIGFkZGl0aW9uYWwgcHJlZml4IHRvIGV2ZXJ5IGxpbmUgb2Ygb3V0cHV0IgogbXNnc3RyICJhbnRlcG9uZXIgdW4gcHJlZmlqbyBhZGljaW9uYWwgYSBjYWRhIGzDrW5lYSBtb3N0cmFkYSIKIAotIzogZGlmZi5jOjUzNjgKKyM6IGRpZmYuYzo1MzcxCiBtc2dpZCAiZG8gbm90IHNob3cgYW55IHNvdXJjZSBvciBkZXN0aW5hdGlvbiBwcmVmaXgiCiBtc2dzdHIgIm5vIG1vc3RyYXIgbmluZ8O6biBwcmVmaWpvIGRlIGZ1ZW50ZSBvIGRlc3Rpbm8iCiAKLSM6IGRpZmYuYzo1MzcxCisjOiBkaWZmLmM6NTM3NAogbXNnaWQgInNob3cgY29udGV4dCBiZXR3ZWVuIGRpZmYgaHVua3MgdXAgdG8gdGhlIHNwZWNpZmllZCBudW1iZXIgb2YgbGluZXMiCiBtc2dzdHIgIiIKICJtdWVzdHJhIGVsIGNvbnRleHRvIGVudHJlIGh1bmtzIGRlIGRpZmYgaGFzdGEgZWwgbsO6bWVybyBlc3BlY2lmaWNhZG8gZGUgIgogImzDrW5lYXMiCiAKLSM6IGRpZmYuYzo1Mzc1IGRpZmYuYzo1MzgwIGRpZmYuYzo1Mzg1CisjOiBkaWZmLmM6NTM3OCBkaWZmLmM6NTM4MyBkaWZmLmM6NTM4OAogbXNnaWQgIjxjaGFyPiIKIG1zZ3N0ciAiPGNoYXI+IgogCi0jOiBkaWZmLmM6NTM3NgorIzogZGlmZi5jOjUzNzkKIG1zZ2lkICJzcGVjaWZ5IHRoZSBjaGFyYWN0ZXIgdG8gaW5kaWNhdGUgYSBuZXcgbGluZSBpbnN0ZWFkIG9mICcrJyIKIG1zZ3N0ciAiZXNwZWNpZmljYSBlbCBjaGFyIHBhcmEgaW5kaWNhciB1bmEgbnVldmEgbMOtbmVhIGVuIGx1Z2FyIGRlICcrJyIKIAotIzogZGlmZi5jOjUzODEKKyM6IGRpZmYuYzo1Mzg0CiBtc2dpZCAic3BlY2lmeSB0aGUgY2hhcmFjdGVyIHRvIGluZGljYXRlIGFuIG9sZCBsaW5lIGluc3RlYWQgb2YgJy0nIgogbXNnc3RyICJlc3BlY2lmaWNhIGVsIGNoYXIgcGFyYSBpbmRpY2FyIHVuYSBsw61uZWEgdmllamEgZW4gbHVnYXIgZGUgJy0nIgogCi0jOiBkaWZmLmM6NTM4NgorIzogZGlmZi5jOjUzODkKIG1zZ2lkICJzcGVjaWZ5IHRoZSBjaGFyYWN0ZXIgdG8gaW5kaWNhdGUgYSBjb250ZXh0IGluc3RlYWQgb2YgJyAnIgogbXNnc3RyICJlc3BlY2lmaWNhIGVsIGNoYXIgcGFyYSBpbmRpY2FyIHVuIGNvbnRleHRvIGVuIGx1Z2FyIGRlICcgJyIKIAotIzogZGlmZi5jOjUzODkKKyM6IGRpZmYuYzo1MzkyCiBtc2dpZCAiRGlmZiByZW5hbWUgb3B0aW9ucyIKIG1zZ3N0ciAiT3BjaW9uZXMgZGUgZGlmZiByZW5hbWUiCiAKLSM6IGRpZmYuYzo1MzkwCisjOiBkaWZmLmM6NTM5MwogbXNnaWQgIjxuPlsvPG0+XSIKIG1zZ3N0ciAiPG4+Wy88bT5dIgogCi0jOiBkaWZmLmM6NTM5MQorIzogZGlmZi5jOjUzOTQKIG1zZ2lkICJicmVhayBjb21wbGV0ZSByZXdyaXRlIGNoYW5nZXMgaW50byBwYWlycyBvZiBkZWxldGUgYW5kIGNyZWF0ZSIKIG1zZ3N0ciAiZGVzY29tcG9uZXIgbG9zIGNhbWJpb3MgZGUgcmVlc2NyaXR1cmEgZW4gcGFyZXMgZGUgYm9ycmFyIHkgY3JlYXIiCiAKLSM6IGRpZmYuYzo1Mzk1CisjOiBkaWZmLmM6NTM5OAogbXNnaWQgImRldGVjdCByZW5hbWVzIgogbXNnc3RyICJkZXRlY3RhciByZW5vbWJyYWRvcyIKIAotIzogZGlmZi5jOjUzOTkKKyM6IGRpZmYuYzo1NDAyCiBtc2dpZCAib21pdCB0aGUgcHJlaW1hZ2UgZm9yIGRlbGV0ZXMiCiBtc2dzdHIgIm9taXRlIGxhIHByZWltYWdlIHBhcmEgYm9ycmFkb3MiCiAKLSM6IGRpZmYuYzo1NDAyCisjOiBkaWZmLmM6NTQwNQogbXNnaWQgImRldGVjdCBjb3BpZXMiCiBtc2dzdHIgImRldGVjdGFyIGNvcGlhcyIKIAotIzogZGlmZi5jOjU0MDYKKyM6IGRpZmYuYzo1NDA5CiBtc2dpZCAidXNlIHVubW9kaWZpZWQgZmlsZXMgYXMgc291cmNlIHRvIGZpbmQgY29waWVzIgogbXNnc3RyICJ1c2EgYXJjaGl2b3Mgbm8gbW9kaWZpY2Fkb3MgY29tbyBmdWVudGUgcGFyYSBlbmNvbnRyYXIgY29waWFzIgogCi0jOiBkaWZmLmM6NTQwOAorIzogZGlmZi5jOjU0MTEKIG1zZ2lkICJkaXNhYmxlIHJlbmFtZSBkZXRlY3Rpb24iCiBtc2dzdHIgImRlc2hhYmlsaXRhIGRldGVjY2nDs24gZGUgcmVub21icmVzIgogCi0jOiBkaWZmLmM6NTQxMQorIzogZGlmZi5jOjU0MTQKIG1zZ2lkICJ1c2UgZW1wdHkgYmxvYnMgYXMgcmVuYW1lIHNvdXJjZSIKIG1zZ3N0ciAidXNhIGJsb2JzIHZhY8Otb3MgY29tbyBmdWVudGUgZGUgcmVub21icmUiCiAKLSM6IGRpZmYuYzo1NDEzCisjOiBkaWZmLmM6NTQxNgogbXNnaWQgImNvbnRpbnVlIGxpc3RpbmcgdGhlIGhpc3Rvcnkgb2YgYSBmaWxlIGJleW9uZCByZW5hbWVzIgogbXNnc3RyICJjb250aW51YSBsaXN0YW5kbyBlbCBoaXN0b3JpYWwgZGUgdW4gYXJjaGl2byBtw6FzIGFsbMOhIGRlIHJlbm9tYnJlcyIKIAotIzogZGlmZi5jOjU0MTYKKyM6IGRpZmYuYzo1NDE5CiBtc2dpZCAiIgogInByZXZlbnQgcmVuYW1lL2NvcHkgZGV0ZWN0aW9uIGlmIHRoZSBudW1iZXIgb2YgcmVuYW1lL2NvcHkgdGFyZ2V0cyBleGNlZWRzICIKICJnaXZlbiBsaW1pdCIKQEAgLTI3OTcsMTU1ICsyODA2LDE1NSBAQAogInByZXZpZW5lIGRldGVjY2nDs24gZGUgcmVub21icmUvY29waWFzIHNpIGVsIG7Dum1lcm8gZGUgb2JqZXRpdm9zIHBhcmEgIgogInJlbm9tYnJlcy9jb3BpYXMgZXhjZWRlIGVsIGzDrW1pdGUgZGFkbyIKIAotIzogZGlmZi5jOjU0MTgKKyM6IGRpZmYuYzo1NDIxCiBtc2dpZCAiRGlmZiBhbGdvcml0aG0gb3B0aW9ucyIKIG1zZ3N0ciAiT3BjaW9uZXMgZGUgYWxnb3JpdG1vcyBkZSBkaWZmIgogCi0jOiBkaWZmLmM6NTQyMAorIzogZGlmZi5jOjU0MjMKIG1zZ2lkICJwcm9kdWNlIHRoZSBzbWFsbGVzdCBwb3NzaWJsZSBkaWZmIgogbXNnc3RyICJwcm9kdWNlIGVsIGRpZmYgbcOhcyBwZXF1ZcOxbyBwb3NpYmxlIgogCi0jOiBkaWZmLmM6NTQyMworIzogZGlmZi5jOjU0MjYKIG1zZ2lkICJpZ25vcmUgd2hpdGVzcGFjZSB3aGVuIGNvbXBhcmluZyBsaW5lcyIKIG1zZ3N0ciAiaWdub3JhciBlc3BhY2lvcyBlbiBibGFuY28gY3VhbmRvIGNvbXBhcmFuZG8gbMOtbmVhcyIKIAotIzogZGlmZi5jOjU0MjYKKyM6IGRpZmYuYzo1NDI5CiBtc2dpZCAiaWdub3JlIGNoYW5nZXMgaW4gYW1vdW50IG9mIHdoaXRlc3BhY2UiCiBtc2dzdHIgImlnbm9yYXIgY2FtYmlvcyBlbiBsYSBjYW50aWRhZCBkZSBsw61uZWFzIGVuIGJsYW5jbyIKIAotIzogZGlmZi5jOjU0MjkKKyM6IGRpZmYuYzo1NDMyCiBtc2dpZCAiaWdub3JlIGNoYW5nZXMgaW4gd2hpdGVzcGFjZSBhdCBFT0wiCiBtc2dzdHIgImlnbm9yYXIgY2FtYmlvcyBlbiBlc3BhY2lvcyBlbiBibGFuY28gZW4gRU9MIgogCi0jOiBkaWZmLmM6NTQzMgorIzogZGlmZi5jOjU0MzUKIG1zZ2lkICJpZ25vcmUgY2Fycmllci1yZXR1cm4gYXQgdGhlIGVuZCBvZiBsaW5lIgogbXNnc3RyICJpZ25vcmEgY2Fycmllci1yZXR1cm4gYWwgZmluYWwgZGUgbGEgbMOtbmVhIgogCi0jOiBkaWZmLmM6NTQzNQorIzogZGlmZi5jOjU0MzgKIG1zZ2lkICJpZ25vcmUgY2hhbmdlcyB3aG9zZSBsaW5lcyBhcmUgYWxsIGJsYW5rIgogbXNnc3RyICJpZ25vcmEgY2FtYmlvcyBjdXlhcyBsw61uZWFzIHNvbiB0b2RhcyBlbiBibGFuY28iCiAKLSM6IGRpZmYuYzo1NDM4CisjOiBkaWZmLmM6NTQ0MQogbXNnaWQgImhldXJpc3RpYyB0byBzaGlmdCBkaWZmIGh1bmsgYm91bmRhcmllcyBmb3IgZWFzeSByZWFkaW5nIgogbXNnc3RyICJoZXVyw61zdGljYSBwYXJhIGNhbWJpYXIgbG9zIGzDrW1pdGVzIGRlIGh1bmsgcGFyYSB1bmEgZsOhY2lsIGxlY3R1cmEiCiAKLSM6IGRpZmYuYzo1NDQxCisjOiBkaWZmLmM6NTQ0NAogbXNnaWQgImdlbmVyYXRlIGRpZmYgdXNpbmcgdGhlIFwicGF0aWVuY2UgZGlmZlwiIGFsZ29yaXRobSIKIG1zZ3N0ciAiZ2VuZXJhIHVuIGRpZmYgdXNhbmRvIGFsZ29yaXRtbyBcInBhdGllbmNlIGRpZmZcIiIKIAotIzogZGlmZi5jOjU0NDUKKyM6IGRpZmYuYzo1NDQ4CiBtc2dpZCAiZ2VuZXJhdGUgZGlmZiB1c2luZyB0aGUgXCJoaXN0b2dyYW0gZGlmZlwiIGFsZ29yaXRobSIKIG1zZ3N0ciAiZ2VuZXJhIHVuIGRpZmYgdXNhbmRvIGFsZ29yaXRtbyBcImhpc3RvZ3JhbSBkaWZmXCIiCiAKLSM6IGRpZmYuYzo1NDQ3CisjOiBkaWZmLmM6NTQ1MAogbXNnaWQgIjxhbGdvcml0aG0+IgogbXNnc3RyICI8YWxnb3JpdG1vPiIKIAotIzogZGlmZi5jOjU0NDgKKyM6IGRpZmYuYzo1NDUxCiBtc2dpZCAiY2hvb3NlIGEgZGlmZiBhbGdvcml0aG0iCiBtc2dzdHIgImVzY29nZSB1biBhbGdvcml0bW8gcGFyYSBkaWZmIgogCi0jOiBkaWZmLmM6NTQ1MAorIzogZGlmZi5jOjU0NTMKIG1zZ2lkICI8dGV4dD4iCiBtc2dzdHIgIjx0ZXh0bz4iCiAKLSM6IGRpZmYuYzo1NDUxCisjOiBkaWZmLmM6NTQ1NAogbXNnaWQgImdlbmVyYXRlIGRpZmYgdXNpbmcgdGhlIFwiYW5jaG9yZWQgZGlmZlwiIGFsZ29yaXRobSIKIG1zZ3N0ciAiZ2VuZXJhIHVuIGRpZmYgdXNhbmRvIGFsZ29yaXRtbyBcImFuY2hvcmVkIGRpZmZcIiIKIAotIzogZGlmZi5jOjU0NTMgZGlmZi5jOjU0NjIgZGlmZi5jOjU0NjUKKyM6IGRpZmYuYzo1NDU2IGRpZmYuYzo1NDY1IGRpZmYuYzo1NDY4CiBtc2dpZCAiPG1vZGU+IgogbXNnc3RyICI8bW9kbz4iCiAKLSM6IGRpZmYuYzo1NDU0CisjOiBkaWZmLmM6NTQ1NwogbXNnaWQgInNob3cgd29yZCBkaWZmLCB1c2luZyA8bW9kZT4gdG8gZGVsaW1pdCBjaGFuZ2VkIHdvcmRzIgogbXNnc3RyICIiCiAibXVlc3RyYSBkaWZmIHBvciBwYWxhYnJhcyB1c2FuZG8gPG1vZG8+IHBhcmEgZGVsaW1pdGFyIGxhcyBwYWxhYnJhcyBjYW1iaWFkYXMiCiAKLSM6IGRpZmYuYzo1NDU2IGRpZmYuYzo1NDU5IGRpZmYuYzo1NTA0CisjOiBkaWZmLmM6NTQ1OSBkaWZmLmM6NTQ2MiBkaWZmLmM6NTUwNwogbXNnaWQgIjxyZWdleD4iCiBtc2dzdHIgIjxyZWdleD4iCiAKLSM6IGRpZmYuYzo1NDU3CisjOiBkaWZmLmM6NTQ2MAogbXNnaWQgInVzZSA8cmVnZXg+IHRvIGRlY2lkZSB3aGF0IGEgd29yZCBpcyIKIG1zZ3N0ciAidXNhIDxyZWdleD4gcGFyYSBkZWNpZGlyIHF1ZSBwYWxhYnJhIGVzIgogCi0jOiBkaWZmLmM6NTQ2MAorIzogZGlmZi5jOjU0NjMKIG1zZ2lkICJlcXVpdmFsZW50IHRvIC0td29yZC1kaWZmPWNvbG9yIC0td29yZC1kaWZmLXJlZ2V4PTxyZWdleD4iCiBtc2dzdHIgImVxdWl2YWxlbnRlIGEgLS13b3JkLWRpZmY9Y29sb3IgLS13b3JkLWRpZmYtcmVnZXg9PHJlZ2V4PiIKIAotIzogZGlmZi5jOjU0NjMKKyM6IGRpZmYuYzo1NDY2CiBtc2dpZCAibW92ZWQgbGluZXMgb2YgY29kZSBhcmUgY29sb3JlZCBkaWZmZXJlbnRseSIKIG1zZ3N0ciAibMOtbmVhcyBtb3ZpZGFzIGRlIGPDs2RpZ28gZXN0w6FuIGNvbG9yZWFkYXMgZGlmZXJlbnRlIgogCi0jOiBkaWZmLmM6NTQ2NgorIzogZGlmZi5jOjU0NjkKIG1zZ2lkICJob3cgd2hpdGUgc3BhY2VzIGFyZSBpZ25vcmVkIGluIC0tY29sb3ItbW92ZWQiCiBtc2dzdHIgImNvbW8gZXNwYWNpb3MgZW4gYmxhbmNvIHNvbiBpZ25vcmFkb3MgZW4gLS1jb2xvci1tb3ZlZCIKIAotIzogZGlmZi5jOjU0NjkKKyM6IGRpZmYuYzo1NDcyCiBtc2dpZCAiT3RoZXIgZGlmZiBvcHRpb25zIgogbXNnc3RyICJPdHJhcyBvcGNpb25lcyBkZSBkaWZmIgogCi0jOiBkaWZmLmM6NTQ3MQorIzogZGlmZi5jOjU0NzQKIG1zZ2lkICJ3aGVuIHJ1biBmcm9tIHN1YmRpciwgZXhjbHVkZSBjaGFuZ2VzIG91dHNpZGUgYW5kIHNob3cgcmVsYXRpdmUgcGF0aHMiCiBtc2dzdHIgIiIKICJjdWFuZG8gZWplY3V0YWRvIGRlc2RlIHVuIHN1YmRpciwgZXhjbHV5ZSBjYW1iaW9zIGRlbCBleHRlcmlvciB5IG11ZXN0cmEgIgogInBhdGhzIHJlbGF0aXZvcyIKIAotIzogZGlmZi5jOjU0NzUKKyM6IGRpZmYuYzo1NDc4CiBtc2dpZCAidHJlYXQgYWxsIGZpbGVzIGFzIHRleHQiCiBtc2dzdHIgInRyYXRhciB0b2RvcyBsb3MgYXJjaGl2b3MgY29tbyB0ZXh0byIKIAotIzogZGlmZi5jOjU0NzcKKyM6IGRpZmYuYzo1NDgwCiBtc2dpZCAic3dhcCB0d28gaW5wdXRzLCByZXZlcnNlIHRoZSBkaWZmIgogbXNnc3RyICJjYW1iaWEgZG9zIGlucHV0cywgaW52aWVydGUgZWwgZGlmZiIKIAotIzogZGlmZi5jOjU0NzkKKyM6IGRpZmYuYzo1NDgyCiBtc2dpZCAiZXhpdCB3aXRoIDEgaWYgdGhlcmUgd2VyZSBkaWZmZXJlbmNlcywgMCBvdGhlcndpc2UiCiBtc2dzdHIgInRlcm1pbmEgY29uIDEgc2kgaHViaWVyb24gZGlmZXJlbmNpYXMsIGRlIGxvIGNvbnRyYXJpbyBjb24gMCIKIAotIzogZGlmZi5jOjU0ODEKKyM6IGRpZmYuYzo1NDg0CiBtc2dpZCAiZGlzYWJsZSBhbGwgb3V0cHV0IG9mIHRoZSBwcm9ncmFtIgogbXNnc3RyICJkZXNoYWJpbGl0YSB0b2RvIGVsIG91dHB1dCBkZWwgcHJvZ3JhbWEiCiAKLSM6IGRpZmYuYzo1NDgzCisjOiBkaWZmLmM6NTQ4NgogbXNnaWQgImFsbG93IGFuIGV4dGVybmFsIGRpZmYgaGVscGVyIHRvIGJlIGV4ZWN1dGVkIgogbXNnc3RyICJwZXJtaXRlIGxhIGVqZWN1Y2nDs24gZGUgdW4gZGlmZiBoZWxwZXIgZXh0ZXJubyIKIAotIzogZGlmZi5jOjU0ODUKKyM6IGRpZmYuYzo1NDg4CiBtc2dpZCAicnVuIGV4dGVybmFsIHRleHQgY29udmVyc2lvbiBmaWx0ZXJzIHdoZW4gY29tcGFyaW5nIGJpbmFyeSBmaWxlcyIKIG1zZ3N0ciAiIgogImVqZWN1dGEgZmlsdHJvcyBkZSBjb252ZXJzacOzbiBkZSB0ZXh0byBleHRlcm5vcyBjdWFuZG8gY29tcGFyYW5kbyBiaW5hcmlvcyIKIAotIzogZGlmZi5jOjU0ODcKKyM6IGRpZmYuYzo1NDkwCiBtc2dpZCAiPHdoZW4+IgogbXNnc3RyICI8Y3VhbmRvPiIKIAotIzogZGlmZi5jOjU0ODgKKyM6IGRpZmYuYzo1NDkxCiBtc2dpZCAiaWdub3JlIGNoYW5nZXMgdG8gc3VibW9kdWxlcyBpbiB0aGUgZGlmZiBnZW5lcmF0aW9uIgogbXNnc3RyICJpZ25vcmFyIGNhbWJpb3MgYSBzdWJtw7NkdWxvcyBlbiBsYSBnZW5lcmFjacOzbiBkZSBkaWZmIgogCi0jOiBkaWZmLmM6NTQ5MQorIzogZGlmZi5jOjU0OTQKIG1zZ2lkICI8Zm9ybWF0PiIKIG1zZ3N0ciAiPGZvcm1hdG8+IgogCi0jOiBkaWZmLmM6NTQ5MgorIzogZGlmZi5jOjU0OTUKIG1zZ2lkICJzcGVjaWZ5IGhvdyBkaWZmZXJlbmNlcyBpbiBzdWJtb2R1bGVzIGFyZSBzaG93biIKIG1zZ3N0ciAiZXNwZWNpZmljYSBjb21vIHNvbiBtb3N0cmFkYXMgbGFzIGRpZmVyZW5jaWFzIGVuIHN1Ym3Ds2R1bG9zIgogCi0jOiBkaWZmLmM6NTQ5NgorIzogZGlmZi5jOjU0OTkKIG1zZ2lkICJoaWRlICdnaXQgYWRkIC1OJyBlbnRyaWVzIGZyb20gdGhlIGluZGV4IgogbXNnc3RyICJvY3VsdGFyIGVudHJhZGFzICdnaXQgYWRkIC1OJyBkZWwgaW5kZXgiCiAKLSM6IGRpZmYuYzo1NDk5CisjOiBkaWZmLmM6NTUwMgogbXNnaWQgInRyZWF0ICdnaXQgYWRkIC1OJyBlbnRyaWVzIGFzIHJlYWwgaW4gdGhlIGluZGV4IgogbXNnc3RyICJ0cmF0YSBlbnRyYWRhcyAnZ2l0IGFkZCAtTicgY29tbyByZWFsZXMgZW4gZWwgaW5kZXgiCiAKLSM6IGRpZmYuYzo1NTAxCisjOiBkaWZmLmM6NTUwNAogbXNnaWQgIjxzdHJpbmc+IgogbXNnc3RyICI8c3RyaW5nPiIKIAotIzogZGlmZi5jOjU1MDIKKyM6IGRpZmYuYzo1NTA1CiBtc2dpZCAiIgogImxvb2sgZm9yIGRpZmZlcmVuY2VzIHRoYXQgY2hhbmdlIHRoZSBudW1iZXIgb2Ygb2NjdXJyZW5jZXMgb2YgdGhlIHNwZWNpZmllZCAiCiAic3RyaW5nIgpAQCAtMjk1Myw3ICsyOTYyLDcgQEAKICJidXNjYSBwb3IgZGlmZXJlbmNpYXMgcXVlIGNhbWJpZW4gZWwgbsO6bWVybyBkZSBvY3VycmVuY2lhcyBwYXJhIGVsIHN0cmluZyAiCiAiZXNwZWNpZmljYWRvIgogCi0jOiBkaWZmLmM6NTUwNQorIzogZGlmZi5jOjU1MDgKIG1zZ2lkICIiCiAibG9vayBmb3IgZGlmZmVyZW5jZXMgdGhhdCBjaGFuZ2UgdGhlIG51bWJlciBvZiBvY2N1cnJlbmNlcyBvZiB0aGUgc3BlY2lmaWVkICIKICJyZWdleCIKQEAgLTI5NjEsMjMgKzI5NzAsMjMgQEAKICJidXNjYSBwb3IgZGlmZXJlbmNpYXMgcXVlIGNhbWJpZW4gZWwgbsO6bWVybyBkZSBvY3VycmVuY2lhcyBwYXJhIGVsIHJlZ2V4ICIKICJlc3BlY2lmaWNhZG8iCiAKLSM6IGRpZmYuYzo1NTA4CisjOiBkaWZmLmM6NTUxMQogbXNnaWQgInNob3cgYWxsIGNoYW5nZXMgaW4gdGhlIGNoYW5nZXNldCB3aXRoIC1TIG9yIC1HIgogbXNnc3RyICJtb3N0cmFyIHRvZG9zIGxvcyBjYW1iaW9zIGVuIGVsIGNoYW5nZXNldCBjb24gLVMgbyAtRyIKIAotIzogZGlmZi5jOjU1MTEKKyM6IGRpZmYuYzo1NTE0CiBtc2dpZCAidHJlYXQgPHN0cmluZz4gaW4gLVMgYXMgZXh0ZW5kZWQgUE9TSVggcmVndWxhciBleHByZXNzaW9uIgogbXNnc3RyICJ0cmF0YXIgPHN0cmluZz4gZW4gLVMgY29tbyB1bmEgZXhwcmVzacOzbiByZWd1bGFyIGV4dGVuZGlkYSBkZSBQT1NJWCIKIAotIzogZGlmZi5jOjU1MTQKKyM6IGRpZmYuYzo1NTE3CiBtc2dpZCAiY29udHJvbCB0aGUgb3JkZXIgaW4gd2hpY2ggZmlsZXMgYXBwZWFyIGluIHRoZSBvdXRwdXQiCiBtc2dzdHIgImNvbnRyb2xhciBlbCBvcmRlbiBlbiBlbCBxdWUgbG9zIGFyY2hpdm9zIGFwYXJlY2VuIGVuIGxhIHNhbGlkYSIKIAotIzogZGlmZi5jOjU1MTUKKyM6IGRpZmYuYzo1NTE4CiBtc2dpZCAiPG9iamVjdC1pZD4iCiBtc2dzdHIgIjxpZC1vYmpldG8+IgogCi0jOiBkaWZmLmM6NTUxNgorIzogZGlmZi5jOjU1MTkKIG1zZ2lkICIiCiAibG9vayBmb3IgZGlmZmVyZW5jZXMgdGhhdCBjaGFuZ2UgdGhlIG51bWJlciBvZiBvY2N1cnJlbmNlcyBvZiB0aGUgc3BlY2lmaWVkICIKICJvYmplY3QiCkBAIC0yOTg1LDMzICsyOTk0LDMzIEBACiAiYnVzY2EgcG9yIGRpZmVyZW5jaWFzIHF1ZSBjYW1iaWVuIGVsIG7Dum1lcm8gZGUgb2N1cnJlbmNpYXMgcGFyYSBlbCBvYmpldG8gIgogImVzcGVjaWZpY2FkbyIKIAotIzogZGlmZi5jOjU1MTgKKyM6IGRpZmYuYzo1NTIxCiBtc2dpZCAiWyhBfEN8RHxNfFJ8VHxVfFh8QikuLi5bKl1dIgogbXNnc3RyICJbKEF8Q3xEfE18UnxUfFV8WHxCKS4uLlsqXV0iCiAKLSM6IGRpZmYuYzo1NTE5CisjOiBkaWZmLmM6NTUyMgogbXNnaWQgInNlbGVjdCBmaWxlcyBieSBkaWZmIHR5cGUiCiBtc2dzdHIgInNlbGVjY2lvbmEgYXJjaGl2b3MgcG9yIHRpcG8gZGUgZGlmZiIKIAotIzogZGlmZi5jOjU1MjEKKyM6IGRpZmYuYzo1NTI0CiBtc2dpZCAiPGZpbGU+IgogbXNnc3RyICI8YXJjaGl2bz4iCiAKLSM6IGRpZmYuYzo1NTIyCisjOiBkaWZmLmM6NTUyNQogbXNnaWQgIk91dHB1dCB0byBhIHNwZWNpZmljIGZpbGUiCiBtc2dzdHIgIk91dHB1dCBhIHVuIGFyY2hpdm8gZXNwZWPDrWZpY28iCiAKLSM6IGRpZmYuYzo2MTc3CisjOiBkaWZmLmM6NjE4MAogbXNnaWQgImluZXhhY3QgcmVuYW1lIGRldGVjdGlvbiB3YXMgc2tpcHBlZCBkdWUgdG8gdG9vIG1hbnkgZmlsZXMuIgogbXNnc3RyICIiCiAiZGV0ZWNjacOzbiBkZSBjYW1iaW8gZGUgbm9tYnJlIGluZXhhY3RhIGZ1ZSBzYWx0YWRhIHBvciBoYWJlciBtdWNob3MgYXJjaGl2b3MuIgogCi0jOiBkaWZmLmM6NjE4MAorIzogZGlmZi5jOjYxODMKIG1zZ2lkICJvbmx5IGZvdW5kIGNvcGllcyBmcm9tIG1vZGlmaWVkIHBhdGhzIGR1ZSB0byB0b28gbWFueSBmaWxlcy4iCiBtc2dzdHIgIiIKICJzb2xvIHNlIGVuY29udHJhcm9uIGNvcGlhcyBkZSBydXRhcyBtb2RpZmljYWRhcyBwb3IgaGFiZXIgbXVjaG9zIGFyY2hpdm9zLiIKIAotIzogZGlmZi5jOjYxODMKKyM6IGRpZmYuYzo2MTg2CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJ5b3UgbWF5IHdhbnQgdG8gc2V0IHlvdXIgJXMgdmFyaWFibGUgdG8gYXQgbGVhc3QgJWQgYW5kIHJldHJ5IHRoZSBjb21tYW5kLiIKQEAgLTMwMTksNDEgKzMwMjgsNDEgQEAKICJ0YWwgdmV6IHF1aWVyYXMgY29uZmlndXJhciBsYSB2YXJpYWJsZSAlcyBwYXJhIHBvciBsbyBtZW5vcyAlZCB5IHZvbHZlciBhICIKICJpbnRlbnRhciBlbCBjb21hbmRvLiIKIAotIzogZGlyLmM6NTM3CisjOiBkaXIuYzo1NDkKICMsIGMtZm9ybWF0CiBtc2dpZCAicGF0aHNwZWMgJyVzJyBkaWQgbm90IG1hdGNoIGFueSBmaWxlKHMpIGtub3duIHRvIGdpdCIKIG1zZ3N0ciAiIgogInJ1dGEgZXNwZWNpZmljYWRhICclcycgbm8gY29uY29yZMOzIGNvbiBuaW5nw7puIGFyY2hpdm8ocykgY29ub2NpZG8gcG9yIGdpdCIKIAotIzogZGlyLmM6OTI2CisjOiBkaXIuYzo5MzgKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IHVzZSAlcyBhcyBhbiBleGNsdWRlIGZpbGUiCiBtc2dzdHIgIm5vIHNlIHB1ZWRlIHVzYXIgJXMgY29tbyBhcmNoaXZvIGRlIGV4Y2x1c2nDs24iCiAKLSM6IGRpci5jOjE4NDMKKyM6IGRpci5jOjE4NzcKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IG9wZW4gZGlyZWN0b3J5ICclcyciCiBtc2dzdHIgIm5vIHNlIHB1ZG8gYWJyaXIgZWwgZGlyZWN0b3JpbyAnJXMnIgogCi0jOiBkaXIuYzoyMDg1CisjOiBkaXIuYzoyMTI4CiBtc2dpZCAiZmFpbGVkIHRvIGdldCBrZXJuZWwgbmFtZSBhbmQgaW5mb3JtYXRpb24iCiBtc2dzdHIgImZhbGzDsyBhbCBjb25zZWd1aXIgbGEgaW5mb3JtYWNpw7NuIHkgbm9tYnJlIGRlbCBrZXJuZWwiCiAKLSM6IGRpci5jOjIyMDkKKyM6IGRpci5jOjIyNTIKIG1zZ2lkICJ1bnRyYWNrZWQgY2FjaGUgaXMgZGlzYWJsZWQgb24gdGhpcyBzeXN0ZW0gb3IgbG9jYXRpb24iCiBtc2dzdHIgInVudHJhY2tlZCBjYWNoZSBlc3TDoSBkZXNhY3RpdmFkbyBlbiBlc3RlIHNpc3RlbWEgbyB1YmljYWNpw7NuIgogCi0jOiBkaXIuYzozMDEzCisjOiBkaXIuYzozMDU2CiAjLCBjLWZvcm1hdAogbXNnaWQgImluZGV4IGZpbGUgY29ycnVwdCBpbiByZXBvICVzIgogbXNnc3RyICJhcmNoaXZvIMOtbmRpY2UgY29ycm9tcGlkbyBlbiByZXBvc2l0b3JpbyAlcyIKIAotIzogZGlyLmM6MzA1OCBkaXIuYzozMDYzCisjOiBkaXIuYzozMTAxIGRpci5jOjMxMDYKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGNyZWF0ZSBkaXJlY3RvcmllcyBmb3IgJXMiCiBtc2dzdHIgIm5vIHNlIHB1ZG8gY3JlYXIgZGlyZWN0b3Jpb3MgcGFyYSAlcyIKIAotIzogZGlyLmM6MzA5MgorIzogZGlyLmM6MzEzNQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgbWlncmF0ZSBnaXQgZGlyZWN0b3J5IGZyb20gJyVzJyB0byAnJXMnIgogbXNnc3RyICJubyBzZSBwdWRvIG1pZ3JhciBlbCBkaXJlY3RvcmlvIGdpdCBkZSAnJXMnIGEgJyVzJyIKQEAgLTMwNzIsMTIgKzMwODEsMTIgQEAKIG1zZ2lkICJjb3VsZCBub3Qgc3RhdCBmaWxlICclcyciCiBtc2dzdHIgIm5vIHNlIHB1ZG8gZXN0YWJsZWNlciBlbCBhcmNoaXZvICclcyciCiAKLSM6IGVudmlyb25tZW50LmM6MTUwCisjOiBlbnZpcm9ubWVudC5jOjE0OAogIywgYy1mb3JtYXQKIG1zZ2lkICJiYWQgZ2l0IG5hbWVzcGFjZSBwYXRoIFwiJXNcIiIKIG1zZ3N0ciAicnV0YSBkZSBuYW1lc3BhY2UgZGUgZ2l0IG1hbGEgXCIlc1wiIgogCi0jOiBlbnZpcm9ubWVudC5jOjMzMgorIzogZW52aXJvbm1lbnQuYzozMzAKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHNldCBHSVRfRElSIHRvICclcyciCiBtc2dzdHIgIm5vIHNlIHB1ZG8gY29uZmlndXJhciBHSVRfRElSIGEgJyVzJyIKQEAgLTMwODcsMTU5ICszMDk2LDE1NSBAQAogbXNnaWQgInRvbyBtYW55IGFyZ3MgdG8gcnVuICVzIgogbXNnc3RyICJkZW1hc2lhZG9zIGFyZ3VtZW50b3MgcGFyYSBjb3JyZXIgJXMiCiAKLSM6IGZldGNoLW9iamVjdC5jOjE3Ci1tc2dpZCAiUmVtb3RlIHdpdGggbm8gVVJMIgotbXNnc3RyICJSZW1vdG8gc2luIFVSTCIKLQotIzogZmV0Y2gtcGFjay5jOjE1MQorIzogZmV0Y2gtcGFjay5jOjE1MAogbXNnaWQgImdpdCBmZXRjaC1wYWNrOiBleHBlY3RlZCBzaGFsbG93IGxpc3QiCiBtc2dzdHIgImdpdCBmZXRjaC1wYWNrOiBsaXN0YSBwb2NvIHByb2Z1bmRhIGVzcGVyYWRhIgogCi0jOiBmZXRjaC1wYWNrLmM6MTU0CisjOiBmZXRjaC1wYWNrLmM6MTUzCiBtc2dpZCAiZ2l0IGZldGNoLXBhY2s6IGV4cGVjdGVkIGEgZmx1c2ggcGFja2V0IGFmdGVyIHNoYWxsb3cgbGlzdCIKIG1zZ3N0ciAiIgogImdpdCBmZXRjaC1wYWNrOiBzZSBlc3BlcmFiYSB1biBmbHVzaCBwYWNrZXQgbHVlZ28gZGUgbGEgbGlzdGEgc3VwZXJmaWNpYWwiCiAKLSM6IGZldGNoLXBhY2suYzoxNjUKKyM6IGZldGNoLXBhY2suYzoxNjQKIG1zZ2lkICJnaXQgZmV0Y2gtcGFjazogZXhwZWN0ZWQgQUNLL05BSywgZ290IGEgZmx1c2ggcGFja2V0IgogbXNnc3RyICJnaXQgZmV0Y2gtcGFjazogc2UgZXNwZXJhYmEgQUNLL05BSywgc2Ugb2J0dXZvIHVuIGZsdXNoIHBhY2tldCIKIAotIzogZmV0Y2gtcGFjay5jOjE4NQorIzogZmV0Y2gtcGFjay5jOjE4NAogIywgYy1mb3JtYXQKIG1zZ2lkICJnaXQgZmV0Y2gtcGFjazogZXhwZWN0ZWQgQUNLL05BSywgZ290ICclcyciCiBtc2dzdHIgImdpdCBmZXRjaC1wYWNrOiBzZSBlc3BlcmFiYSBBQ0svTkFLLCBzZSBvYnR1dm8gJyVzJyIKIAotIzogZmV0Y2gtcGFjay5jOjE5NgorIzogZmV0Y2gtcGFjay5jOjE5NQogbXNnaWQgInVuYWJsZSB0byB3cml0ZSB0byByZW1vdGUiCiBtc2dzdHIgIm5vIHNlIHB1ZWRlIGVzY3JpYmlyIGFsIHJlbW90byIKIAotIzogZmV0Y2gtcGFjay5jOjI1OAorIzogZmV0Y2gtcGFjay5jOjI1NwogbXNnaWQgIi0tc3RhdGVsZXNzLXJwYyByZXF1aXJlcyBtdWx0aV9hY2tfZGV0YWlsZWQiCiBtc2dzdHIgIi0tc3RhdGVsZXNzLXJwYyByZXF1aWVyZSBtdWx0aV9hY2tfZGV0YWlsZWQiCiAKLSM6IGZldGNoLXBhY2suYzozNjAgZmV0Y2gtcGFjay5jOjEyODQKKyM6IGZldGNoLXBhY2suYzozNTYgZmV0Y2gtcGFjay5jOjEyODAKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBzaGFsbG93IGxpbmU6ICVzIgogbXNnc3RyICJsw61uZWEgcG9jbyBwcm9mdW5kYSBpbnbDoWxpZGE6ICVzIgogCi0jOiBmZXRjaC1wYWNrLmM6MzY2IGZldGNoLXBhY2suYzoxMjkwCisjOiBmZXRjaC1wYWNrLmM6MzYyIGZldGNoLXBhY2suYzoxMjg2CiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgdW5zaGFsbG93IGxpbmU6ICVzIgogbXNnc3RyICJsw61uZWEgc3VwZXJmaWNpYWwgaW52w6FsaWRhOiAlcyIKIAotIzogZmV0Y2gtcGFjay5jOjM2OCBmZXRjaC1wYWNrLmM6MTI5MgorIzogZmV0Y2gtcGFjay5jOjM2NCBmZXRjaC1wYWNrLmM6MTI4OAogIywgYy1mb3JtYXQKIG1zZ2lkICJvYmplY3Qgbm90IGZvdW5kOiAlcyIKIG1zZ3N0ciAib2JqZXRvIG5vIGVuY29udHJhZG86ICVzIgogCi0jOiBmZXRjaC1wYWNrLmM6MzcxIGZldGNoLXBhY2suYzoxMjk1CisjOiBmZXRjaC1wYWNrLmM6MzY3IGZldGNoLXBhY2suYzoxMjkxCiAjLCBjLWZvcm1hdAogbXNnaWQgImVycm9yIGluIG9iamVjdDogJXMiCiBtc2dzdHIgImVycm9yIGVuIG9iamV0bzogJXMiCiAKLSM6IGZldGNoLXBhY2suYzozNzMgZmV0Y2gtcGFjay5jOjEyOTcKKyM6IGZldGNoLXBhY2suYzozNjkgZmV0Y2gtcGFjay5jOjEyOTMKICMsIGMtZm9ybWF0CiBtc2dpZCAibm8gc2hhbGxvdyBmb3VuZDogJXMiCiBtc2dzdHIgInN1cGVyZmljaWUgbm8gZW5jb250cmFkYTogJXMiCiAKLSM6IGZldGNoLXBhY2suYzozNzYgZmV0Y2gtcGFjay5jOjEzMDEKKyM6IGZldGNoLXBhY2suYzozNzIgZmV0Y2gtcGFjay5jOjEyOTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiZXhwZWN0ZWQgc2hhbGxvdy91bnNoYWxsb3csIGdvdCAlcyIKIG1zZ3N0ciAic2UgZXNwZXJhYmEgc2hhbGxvdy91bnNoYWxsb3csIHNlIG9idHV2byAlcyIKIAotIzogZmV0Y2gtcGFjay5jOjQxNworIzogZmV0Y2gtcGFjay5jOjQxNAogIywgYy1mb3JtYXQKIG1zZ2lkICJnb3QgJXMgJWQgJXMiCiBtc2dzdHIgInNlIG9idHV2byAlcyAlZCAlcyIKIAotIzogZmV0Y2gtcGFjay5jOjQzNAorIzogZmV0Y2gtcGFjay5jOjQzMQogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIGNvbW1pdCAlcyIKIG1zZ3N0ciAiY29tbWl0IGludsOhbGlkbyAlcyIKIAotIzogZmV0Y2gtcGFjay5jOjQ2NQorIzogZmV0Y2gtcGFjay5jOjQ2MgogbXNnaWQgImdpdmluZyB1cCIKIG1zZ3N0ciAicmluZGnDqW5kb3NlIgogCi0jOiBmZXRjaC1wYWNrLmM6NDc3IHByb2dyZXNzLmM6Mjc3CisjOiBmZXRjaC1wYWNrLmM6NDc1IHByb2dyZXNzLmM6MzEyCiBtc2dpZCAiZG9uZSIKIG1zZ3N0ciAibGlzdG8iCiAKLSM6IGZldGNoLXBhY2suYzo0ODkKKyM6IGZldGNoLXBhY2suYzo0ODcKICMsIGMtZm9ybWF0CiBtc2dpZCAiZ290ICVzICglZCkgJXMiCiBtc2dzdHIgInNlIG9idHV2byAlcyAoJWQpICVzIgogCi0jOiBmZXRjaC1wYWNrLmM6NTM1CisjOiBmZXRjaC1wYWNrLmM6NTMzCiAjLCBjLWZvcm1hdAogbXNnaWQgIk1hcmtpbmcgJXMgYXMgY29tcGxldGUiCiBtc2dzdHIgIk1hcmNhbmRvICVzIGNvbW8gY29tcGxldGEiCiAKLSM6IGZldGNoLXBhY2suYzo3NDQKKyM6IGZldGNoLXBhY2suYzo3NDIKICMsIGMtZm9ybWF0CiBtc2dpZCAiYWxyZWFkeSBoYXZlICVzICglcykiCiBtc2dzdHIgInlhIHNlIHRpZW5lICVzICglcykiCiAKLSM6IGZldGNoLXBhY2suYzo3ODMKKyM6IGZldGNoLXBhY2suYzo3ODEKIG1zZ2lkICJmZXRjaC1wYWNrOiB1bmFibGUgdG8gZm9yayBvZmYgc2lkZWJhbmQgZGVtdWx0aXBsZXhlciIKIG1zZ3N0ciAiZmV0Y2gtcGFjazogbm8gc2UgcHVlZGUgZXh0cmFlciB1biBkZW11bHRpcGxleG9yIGRlIGJhbmRhIGxhdGVyYWwiCiAKLSM6IGZldGNoLXBhY2suYzo3OTEKKyM6IGZldGNoLXBhY2suYzo3ODkKIG1zZ2lkICJwcm90b2NvbCBlcnJvcjogYmFkIHBhY2sgaGVhZGVyIgogbXNnc3RyICJlcnJvciBkZSBwcm90b2NvbG86IHBhcXVldGUgZGUgaGVhZGVyIGVycsOzbmVvIgogCi0jOiBmZXRjaC1wYWNrLmM6ODU5CisjOiBmZXRjaC1wYWNrLmM6ODU3CiAjLCBjLWZvcm1hdAogbXNnaWQgImZldGNoLXBhY2s6IHVuYWJsZSB0byBmb3JrIG9mZiAlcyIKIG1zZ3N0ciAiZmV0Y2gtcGFjazogbm8gc2UgcHVlZGUgcXVpdGFyICVzIgogCi0jOiBmZXRjaC1wYWNrLmM6ODc1CisjOiBmZXRjaC1wYWNrLmM6ODczCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIGZhaWxlZCIKIG1zZ3N0ciAiJXMgZmFsbMOzIgogCi0jOiBmZXRjaC1wYWNrLmM6ODc3CisjOiBmZXRjaC1wYWNrLmM6ODc1CiBtc2dpZCAiZXJyb3IgaW4gc2lkZWJhbmQgZGVtdWx0aXBsZXhlciIKIG1zZ3N0ciAiZXJyb3IgZW4gZGVtdWx0aXBsZXhvciBkZSBiYW5kYSBsYXRlcmFsIgogCi0jOiBmZXRjaC1wYWNrLmM6OTA4CisjOiBmZXRjaC1wYWNrLmM6OTA3CiAjLCBjLWZvcm1hdAogbXNnaWQgIlNlcnZlciB2ZXJzaW9uIGlzICUuKnMiCiBtc2dzdHIgIlZlcnNpw7NuIGRlIHNlcnZpZG9yIGVzICUuKnMiCiAKLSM6IGZldGNoLXBhY2suYzo5MTMgZmV0Y2gtcGFjay5jOjkxOSBmZXRjaC1wYWNrLmM6OTIyIGZldGNoLXBhY2suYzo5MjgKLSM6IGZldGNoLXBhY2suYzo5MzIgZmV0Y2gtcGFjay5jOjkzNiBmZXRjaC1wYWNrLmM6OTQwIGZldGNoLXBhY2suYzo5NDQKLSM6IGZldGNoLXBhY2suYzo5NDggZmV0Y2gtcGFjay5jOjk1MiBmZXRjaC1wYWNrLmM6OTU2IGZldGNoLXBhY2suYzo5NjAKLSM6IGZldGNoLXBhY2suYzo5NjYgZmV0Y2gtcGFjay5jOjk3MiBmZXRjaC1wYWNrLmM6OTc3IGZldGNoLXBhY2suYzo5ODIKKyM6IGZldGNoLXBhY2suYzo5MTIgZmV0Y2gtcGFjay5jOjkxOCBmZXRjaC1wYWNrLmM6OTIxIGZldGNoLXBhY2suYzo5MjcKKyM6IGZldGNoLXBhY2suYzo5MzEgZmV0Y2gtcGFjay5jOjkzNSBmZXRjaC1wYWNrLmM6OTM5IGZldGNoLXBhY2suYzo5NDMKKyM6IGZldGNoLXBhY2suYzo5NDcgZmV0Y2gtcGFjay5jOjk1MSBmZXRjaC1wYWNrLmM6OTU1IGZldGNoLXBhY2suYzo5NTkKKyM6IGZldGNoLXBhY2suYzo5NjUgZmV0Y2gtcGFjay5jOjk3MSBmZXRjaC1wYWNrLmM6OTc2IGZldGNoLXBhY2suYzo5ODEKICMsIGMtZm9ybWF0CiBtc2dpZCAiU2VydmVyIHN1cHBvcnRzICVzIgogbXNnc3RyICJFbCBzZXJ2aWRvciBzb3BvcnRhICVzIgogCi0jOiBmZXRjaC1wYWNrLmM6OTE1CisjOiBmZXRjaC1wYWNrLmM6OTE0CiBtc2dpZCAiU2VydmVyIGRvZXMgbm90IHN1cHBvcnQgc2hhbGxvdyBjbGllbnRzIgogbXNnc3RyICJFbCBzZXJ2aWRvciBubyBzb3BvcnRhIGNsaWVudGVzIHN1cGVyZmljaWFsZXMiCiAKLSM6IGZldGNoLXBhY2suYzo5NzUKKyM6IGZldGNoLXBhY2suYzo5NzQKIG1zZ2lkICJTZXJ2ZXIgZG9lcyBub3Qgc3VwcG9ydCAtLXNoYWxsb3ctc2luY2UiCiBtc2dzdHIgIkVsIHNlcnZpZG9yIG5vIHNvcG9ydGEgLS1zaGFsb3ctc2luY2UiCiAKLSM6IGZldGNoLXBhY2suYzo5ODAKKyM6IGZldGNoLXBhY2suYzo5NzkKIG1zZ2lkICJTZXJ2ZXIgZG9lcyBub3Qgc3VwcG9ydCAtLXNoYWxsb3ctZXhjbHVkZSIKIG1zZ3N0ciAiRWwgc2Vydmlkb3Igbm8gc29wb3J0YSAtLXNoYWxvdy1leGNsdWRlIgogCi0jOiBmZXRjaC1wYWNrLmM6OTg0CisjOiBmZXRjaC1wYWNrLmM6OTgzCiBtc2dpZCAiU2VydmVyIGRvZXMgbm90IHN1cHBvcnQgLS1kZWVwZW4iCiBtc2dzdHIgIkVsIHNlcnZpZG9yIG5vIHNvcG9ydGEgLS1kZWVwZW4iCiAKLSM6IGZldGNoLXBhY2suYzoxMDAxCisjOiBmZXRjaC1wYWNrLmM6MTAwMAogbXNnaWQgIm5vIGNvbW1vbiBjb21taXRzIgogbXNnc3RyICJubyBoYXkgY29tbWl0cyBjb211bmVzIgogCi0jOiBmZXRjaC1wYWNrLmM6MTAxMyBmZXRjaC1wYWNrLmM6MTQ2MgorIzogZmV0Y2gtcGFjay5jOjEwMTIgZmV0Y2gtcGFjay5jOjE0NjgKIG1zZ2lkICJnaXQgZmV0Y2gtcGFjazogZmV0Y2ggZmFpbGVkLiIKIG1zZ3N0ciAiZ2l0IGZldGNoLXBhY2s6IGZldGNoIGZhbGzDsy4iCiAKLSM6IGZldGNoLXBhY2suYzoxMTUxCisjOiBmZXRjaC1wYWNrLmM6MTE1MAogbXNnaWQgIlNlcnZlciBkb2VzIG5vdCBzdXBwb3J0IHNoYWxsb3cgcmVxdWVzdHMiCiBtc2dzdHIgIkVsIHNlcnZpZG9yIG5vIHNvcG9ydGEgcGV0aWNpb25lcyBzdXBlcmZpY2lhbGVzIgogCkBAIC0zMjQ3LDcyICszMjUyLDcyIEBACiBtc2dpZCAiU2VydmVyIHN1cHBvcnRzIGZpbHRlciIKIG1zZ3N0ciAiRWwgc2Vydmlkb3Igc29wb3J0YSBmaWx0cm8iCiAKLSM6IGZldGNoLXBhY2suYzoxMTg0CisjOiBmZXRjaC1wYWNrLmM6MTE4MAogbXNnaWQgInVuYWJsZSB0byB3cml0ZSByZXF1ZXN0IHRvIHJlbW90ZSIKIG1zZ3N0ciAibm8gc2UgcHVlZGUgZXNjcmliaXIgcmVxdWVzdCBhbCByZW1vdG8iCiAKLSM6IGZldGNoLXBhY2suYzoxMjAyCisjOiBmZXRjaC1wYWNrLmM6MTE5OAogIywgYy1mb3JtYXQKIG1zZ2lkICJlcnJvciByZWFkaW5nIHNlY3Rpb24gaGVhZGVyICclcyciCiBtc2dzdHIgImVycm9yIGxleWVuZG8gc2VjY2nDs24gaGVhZGVyICclcyciCiAKLSM6IGZldGNoLXBhY2suYzoxMjA4CisjOiBmZXRjaC1wYWNrLmM6MTIwNAogIywgYy1mb3JtYXQKIG1zZ2lkICJleHBlY3RlZCAnJXMnLCByZWNlaXZlZCAnJXMnIgogbXNnc3RyICJzZSBlc3BlcmFiYSAnJXMnLCBzZSByZWNpYmnDsyAnJXMnIgogCi0jOiBmZXRjaC1wYWNrLmM6MTI0NworIzogZmV0Y2gtcGFjay5jOjEyNDMKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5leHBlY3RlZCBhY2tub3dsZWRnbWVudCBsaW5lOiAnJXMnIgogbXNnc3RyICJsw61uZWEgZGUgY29uZmlybWFjacOzbiBpbmVzcGVyYWRhOiAnJXMnIgogCi0jOiBmZXRjaC1wYWNrLmM6MTI1MgorIzogZmV0Y2gtcGFjay5jOjEyNDgKICMsIGMtZm9ybWF0CiBtc2dpZCAiZXJyb3IgcHJvY2Vzc2luZyBhY2tzOiAlZCIKIG1zZ3N0ciAiZXJyb3IgcHJvY2VzYW5kbyBhY2tzOiAlZCIKIAotIzogZmV0Y2gtcGFjay5jOjEyNjIKKyM6IGZldGNoLXBhY2suYzoxMjU4CiBtc2dpZCAiZXhwZWN0ZWQgcGFja2ZpbGUgdG8gYmUgc2VudCBhZnRlciAncmVhZHknIgogbXNnc3RyICJlc3BlcmUgcXVlIGVsIHBhY2tmaWxlIHNlYSBtYW5kYWRvIGx1ZWdvIGRlbCAnbGlzdG8nIgogCi0jOiBmZXRjaC1wYWNrLmM6MTI2NAorIzogZmV0Y2gtcGFjay5jOjEyNjAKIG1zZ2lkICJleHBlY3RlZCBubyBvdGhlciBzZWN0aW9ucyB0byBiZSBzZW50IGFmdGVyIG5vICdyZWFkeSciCiBtc2dzdHIgImVzcGVyZSBxdWUgbmluZ3VuYSBvdHJhIHNlY2Npw7NuIHNlYSBlbnZpYWRhIGx1ZWdvIGRlbCAnbGlzdG8nIgogCi0jOiBmZXRjaC1wYWNrLmM6MTMwNgorIzogZmV0Y2gtcGFjay5jOjEzMDIKICMsIGMtZm9ybWF0CiBtc2dpZCAiZXJyb3IgcHJvY2Vzc2luZyBzaGFsbG93IGluZm86ICVkIgogbXNnc3RyICJlcnJvciBwcm9jZXNhbmRvIGluZm9ybWFjacOzbiBzdXBlcmZpY2lhbDogJWQiCiAKLSM6IGZldGNoLXBhY2suYzoxMzUzCisjOiBmZXRjaC1wYWNrLmM6MTM0OQogIywgYy1mb3JtYXQKIG1zZ2lkICJleHBlY3RlZCB3YW50ZWQtcmVmLCBnb3QgJyVzJyIKIG1zZ3N0ciAic2UgZXNwZXJhYmEgd2FudGVkLXJlZiwgc2Ugb2J0dXZvICclcyciCiAKLSM6IGZldGNoLXBhY2suYzoxMzU4CisjOiBmZXRjaC1wYWNrLmM6MTM1NAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmV4cGVjdGVkIHdhbnRlZC1yZWY6ICclcyciCiBtc2dzdHIgIndhbnRlZC1yZWYgaW5lc3BlcmFkbzogJyVzJyIKIAotIzogZmV0Y2gtcGFjay5jOjEzNjMKKyM6IGZldGNoLXBhY2suYzoxMzU5CiAjLCBjLWZvcm1hdAogbXNnaWQgImVycm9yIHByb2Nlc3Npbmcgd2FudGVkIHJlZnM6ICVkIgogbXNnc3RyICJlcnJvciBwcm9jZXNhbmRvIHJlZnMgZGVzZWFkYXM6ICVkIgogCi0jOiBmZXRjaC1wYWNrLmM6MTY4OQorIzogZmV0Y2gtcGFjay5jOjE2OTMKIG1zZ2lkICJubyBtYXRjaGluZyByZW1vdGUgaGVhZCIKIG1zZ3N0ciAibm8gY29uY3VlcmRhIGVsIGhlYWQgcmVtb3RvIgogCi0jOiBmZXRjaC1wYWNrLmM6MTcxMiBidWlsdGluL2Nsb25lLmM6Njg2CisjOiBmZXRjaC1wYWNrLmM6MTcxNiBidWlsdGluL2Nsb25lLmM6Njg1CiBtc2dpZCAicmVtb3RlIGRpZCBub3Qgc2VuZCBhbGwgbmVjZXNzYXJ5IG9iamVjdHMiCiBtc2dzdHIgInJlbW90byBubyBtYW5kbyB0b2RvcyBsb3Mgb2JqZXRvcyBuZWNlc2FyaW9zIgogCi0jOiBmZXRjaC1wYWNrLmM6MTczOQorIzogZmV0Y2gtcGFjay5jOjE3NDMKICMsIGMtZm9ybWF0CiBtc2dpZCAibm8gc3VjaCByZW1vdGUgcmVmICVzIgogbXNnc3RyICJubyBleGlzdGUgcmVmIHJlbW90YSAlcyIKIAotIzogZmV0Y2gtcGFjay5jOjE3NDIKKyM6IGZldGNoLXBhY2suYzoxNzQ2CiAjLCBjLWZvcm1hdAogbXNnaWQgIlNlcnZlciBkb2VzIG5vdCBhbGxvdyByZXF1ZXN0IGZvciB1bmFkdmVydGlzZWQgb2JqZWN0ICVzIgogbXNnc3RyICJFbCBzZXJ2aWRvciBubyBwZXJtaXRlIHNvbGljaXR1ZGVzIGRlIG9iamV0b3MgaW5hZHZlcnRpZG9zICVzIgpAQCAtMzMzNSwxOCArMzM0MCwyNiBAQAogbXNnaWQgImlnbm9yZSBpbnZhbGlkIGNvbG9yICclLipzJyBpbiBsb2cuZ3JhcGhDb2xvcnMiCiBtc2dzdHIgImlnbm9yYSBjb2xvciBpbnbDoWxpZG8gJyUuKnMnIGVuIGxvZy5ncmFwaENvbG9ycyIKIAotIzogZ3JlcC5jOjIxMTcKKyM6IGdyZXAuYzo2NjgKK21zZ2lkICIiCisiZ2l2ZW4gcGF0dGVybiBjb250YWlucyBOVUxMIGJ5dGUgKHZpYSAtZiA8ZmlsZT4pLiBUaGlzIGlzIG9ubHkgc3VwcG9ydGVkICIKKyJ3aXRoIC1QIHVuZGVyIFBDUkUgdjIiCittc2dzdHIgIiIKKyJlbCBwYXRyw7NuIHByb3Zpc3RvIGNvbnRpZW5lIGJ5dGVzIE5VTEwgKHZpYSAtZiA8YXJjaGl2bz4pLiBFc3RvIHNvbG8gZXMgIgorInNvcG9ydGFkbyBjb24gLVAgYmFqbyBQQ1JFIHYyIgorCisjOiBncmVwLmM6MjEyNAogIywgYy1mb3JtYXQKIG1zZ2lkICInJXMnOiB1bmFibGUgdG8gcmVhZCAlcyIKIG1zZ3N0ciAiJyVzJzogbm8gZXMgcG9zaWJsZSBsZWVyICVzIgogCi0jOiBncmVwLmM6MjEzNCBzZXR1cC5jOjE2NCBidWlsdGluL2Nsb25lLmM6NDA5IGJ1aWx0aW4vZGlmZi5jOjgyCisjOiBncmVwLmM6MjE0MSBzZXR1cC5jOjE2NSBidWlsdGluL2Nsb25lLmM6NDA4IGJ1aWx0aW4vZGlmZi5jOjgyCiAjOiBidWlsdGluL3JtLmM6MTM1CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBzdGF0ICclcyciCiBtc2dzdHIgImZhbGzDsyBhbCBtYXJjYXIgJyVzJyIKIAotIzogZ3JlcC5jOjIxNDUKKyM6IGdyZXAuYzoyMTUyCiAjLCBjLWZvcm1hdAogbXNnaWQgIiclcyc6IHNob3J0IHJlYWQiCiBtc2dzdHIgIiclcyc6IGxlY3R1cmEgY29ydGEiCkBAIC0zNDQ0LDcgKzM0NTcsNyBAQAogImFibGUgdG8gZXhlY3V0ZSBpdC4gTWF5YmUgZ2l0LSVzIGlzIGJyb2tlbj8iCiBtc2dzdHIgIiIKICInJXMnIHBhcmVjZSBzZXIgdW4gY29tYW5kbyBkZSBnaXQsIHBlcm8gbm8gaGVtb3NcbiIKLSJwb2RpZG8gZWplY3V0YXJsby4gVGFsIHZleiBnaXQtJXMgc2UgaGEgcm90bz8iCisicG9kaWRvIGVqZWN1dGFybG8uIMK/VGFsIHZleiBnaXQtJXMgc2UgaGEgcm90bz8iCiAKICM6IGhlbHAuYzo2NTUKIG1zZ2lkICJVaCBvaC4gWW91ciBzeXN0ZW0gcmVwb3J0cyBubyBHaXQgY29tbWFuZHMgYXQgYWxsLiIKQEAgLTM0ODgsMTIgKzM1MDEsMTIgQEAKIG1zZ2lkICJnaXQgdmVyc2lvbiBbPG9wdGlvbnM+XSIKIG1zZ3N0ciAiZ2l0IHZlcnNpw7NuIFs8b3BjaW9uZXM+XSIKIAotIzogaGVscC5jOjc4MgorIzogaGVscC5jOjc4MwogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogJXMgLSAlcyIKIG1zZ3N0ciAiJXM6ICVzIC0gJXMiCiAKLSM6IGhlbHAuYzo3ODYKKyM6IGhlbHAuYzo3ODcKIG1zZ2lkICIiCiAiXG4iCiAiRGlkIHlvdSBtZWFuIHRoaXM/IgpAQCAtMzU2Niw0MSArMzU3OSw1NiBAQAogbXNnaWQgImludmFsaWQgZGF0ZSBmb3JtYXQ6ICVzIgogbXNnc3RyICJmb3JtYXRvIGRlIGZlY2hhIGludsOhbGlkbzogJXMiCiAKLSM6IGxpc3Qtb2JqZWN0cy5jOjEyOQorIzogbGlzdC1vYmplY3RzLmM6MTI3CiAjLCBjLWZvcm1hdAogbXNnaWQgImVudHJ5ICclcycgaW4gdHJlZSAlcyBoYXMgdHJlZSBtb2RlLCBidXQgaXMgbm90IGEgdHJlZSIKIG1zZ3N0ciAiZW50cmFkYSAnJXMnIGVuIMOhcmJvbCAlcyB0aWVuZSBtb2RvIMOhcmJvbCwgcGVybyBubyBlcyB1bm8iCiAKLSM6IGxpc3Qtb2JqZWN0cy5jOjE0MgorIzogbGlzdC1vYmplY3RzLmM6MTQwCiAjLCBjLWZvcm1hdAogbXNnaWQgImVudHJ5ICclcycgaW4gdHJlZSAlcyBoYXMgYmxvYiBtb2RlLCBidXQgaXMgbm90IGEgYmxvYiIKIG1zZ3N0ciAiZW50cmFkYSAnJXMnIGVuIMOhcmJvbCAlcyB0aWVuZSBtb2RvIGJsb2IsIHBlcm8gbm8gZXMgdW5vIgogCi0jOiBsaXN0LW9iamVjdHMuYzozNzgKKyM6IGxpc3Qtb2JqZWN0cy5jOjM3NQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gbG9hZCByb290IHRyZWUgZm9yIGNvbW1pdCAlcyIKIG1zZ3N0ciAibm8gc2UgcHVlZGUgY2FyZ2FyIMOhcmJvbCByYcOteiBwYXJhIGNvbW1pdCAlcyIKIAotIzogbGlzdC1vYmplY3RzLWZpbHRlci1vcHRpb25zLmM6MzYKLW1zZ2lkICJtdWx0aXBsZSBmaWx0ZXItc3BlY3MgY2Fubm90IGJlIGNvbWJpbmVkIgotbXNnc3RyICJubyBzZSBwdWVkZW4gY29tYmluYXIgbcO6bHRpcGxlcyB0aXBvcyBkZSBlc3BlY2lmaWNhY2lvbmVzIGRlIGZpbHRybyIKKyM6IGxpc3Qtb2JqZWN0cy1maWx0ZXIuYzo0OTIKKyMsIGMtZm9ybWF0Cittc2dpZCAidW5hYmxlIHRvIGFjY2VzcyBzcGFyc2UgYmxvYiBpbiAnJXMnIgorbXNnc3RyICJubyBlcyBwb3NpYmxlIGFjY2VkZXIgYWwgYmxvYiBlbiAnJXMnIgorCisjOiBsaXN0LW9iamVjdHMtZmlsdGVyLmM6NDk1CisjLCBjLWZvcm1hdAorbXNnaWQgInVuYWJsZSB0byBwYXJzZSBzcGFyc2UgZmlsdGVyIGRhdGEgaW4gJXMiCittc2dzdHIgImluY2FwYXogZGUgYW5hbGl6YXIgZmlsdHJvIGRlIGRhdGEgZW4gJXMiCiAKICM6IGxpc3Qtb2JqZWN0cy1maWx0ZXItb3B0aW9ucy5jOjU4CiBtc2dpZCAiZXhwZWN0ZWQgJ3RyZWU6PGRlcHRoPiciCiBtc2dzdHIgInNlIGVzcGVyYWJhICd0cmVlOjxkZXB0aD4nIgogCi0jOiBsaXN0LW9iamVjdHMtZmlsdGVyLW9wdGlvbnMuYzo4NAorIzogbGlzdC1vYmplY3RzLWZpbHRlci1vcHRpb25zLmM6NzMKIG1zZ2lkICJzcGFyc2U6cGF0aCBmaWx0ZXJzIHN1cHBvcnQgaGFzIGJlZW4gZHJvcHBlZCIKIG1zZ3N0ciAic29wb3J0ZSBwYXJhIGZpbHRyb3Mgc3BhcnNlOnBhdGggaGEgc2lkbyBkaXNjb250aW51YWRvIgogCi0jOiBsaXN0LW9iamVjdHMtZmlsdGVyLW9wdGlvbnMuYzo5NAorIzogbGlzdC1vYmplY3RzLWZpbHRlci1vcHRpb25zLmM6ODYKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBmaWx0ZXItc3BlYyAnJXMnIgogbXNnc3RyICJmaWx0cm8gLXNwZWMgaW52w6FsaWRvICclcyciCiAKLSM6IGxpc3Qtb2JqZWN0cy1maWx0ZXItb3B0aW9ucy5jOjE1OAotbXNnaWQgImNhbm5vdCBjaGFuZ2UgcGFydGlhbCBjbG9uZSBwcm9taXNvciByZW1vdGUiCi1tc2dzdHIgIm5vIHNlIHB1ZWRlIGNhbWJpYXIgdW4gY2xvbiBwYXJjaWFsIHJlbW90byBwcm9taXNvciIKKyM6IGxpc3Qtb2JqZWN0cy1maWx0ZXItb3B0aW9ucy5jOjEwMgorIywgYy1mb3JtYXQKK21zZ2lkICJtdXN0IGVzY2FwZSBjaGFyIGluIHN1Yi1maWx0ZXItc3BlYzogJyVjJyIKK21zZ3N0ciAidGllbmVzIHF1ZSBlc2NhcGFyIGVsIGNhcmFjdGVyIGVuIHN1Yi1maWx0ZXItc3BlYzogJyVjJyIKKworIzogbGlzdC1vYmplY3RzLWZpbHRlci1vcHRpb25zLmM6MTQ0Cittc2dpZCAiZXhwZWN0ZWQgc29tZXRoaW5nIGFmdGVyIGNvbWJpbmU6IgorbXNnc3RyICJzZSBlc3BlcmEgYWxnbyBsdWVnbyBkZSBjb21iaW5lOiIKKworIzogbGlzdC1vYmplY3RzLWZpbHRlci1vcHRpb25zLmM6MjI2Cittc2dpZCAibXVsdGlwbGUgZmlsdGVyLXNwZWNzIGNhbm5vdCBiZSBjb21iaW5lZCIKK21zZ3N0ciAibm8gc2UgcHVlZGVuIGNvbWJpbmFyIG3Dumx0aXBsZXMgdGlwb3MgZGUgZXNwZWNpZmljYWNpb25lcyBkZSBmaWx0cm8iCiAKICM6IGxvY2tmaWxlLmM6MTUxCiAjLCBjLWZvcm1hdApAQCAtMzYzMSwxMTUgKzM2NTksMTExIEBACiBtc2dpZCAiZmFpbGVkIHRvIHJlYWQgdGhlIGNhY2hlIgogbXNnc3RyICJmYWxsw7MgYWwgbGVlciBsYSBjYWNoZSIKIAotIzogbWVyZ2UuYzoxMDcgcmVyZXJlLmM6NzIwIGJ1aWx0aW4vYW0uYzoxODg1IGJ1aWx0aW4vYW0uYzoxOTE5Ci0jOiBidWlsdGluL2NoZWNrb3V0LmM6NTM2IGJ1aWx0aW4vY2hlY2tvdXQuYzo3OTYgYnVpbHRpbi9jbG9uZS5jOjc4NgorIzogbWVyZ2UuYzoxMDcgcmVyZXJlLmM6NzIwIGJ1aWx0aW4vYW0uYzoxODc0IGJ1aWx0aW4vYW0uYzoxOTA4CisjOiBidWlsdGluL2NoZWNrb3V0LmM6NTM3IGJ1aWx0aW4vY2hlY2tvdXQuYzo3OTYgYnVpbHRpbi9jbG9uZS5jOjc4NQogIzogYnVpbHRpbi9zdGFzaC5jOjI2NAogbXNnaWQgInVuYWJsZSB0byB3cml0ZSBuZXcgaW5kZXggZmlsZSIKIG1zZ3N0ciAibm8gZXMgcG9zaWJsZSBlc2NyaWJpciBlbCBhcmNoaXZvIMOtbmRpY2UiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMyMgorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzY3CiBtc2dpZCAiKGJhZCBjb21taXQpXG4iCiBtc2dzdHIgIihjb21taXQgZXJyw7NuZW8pXG4iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjM0NQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzkwCiAjLCBjLWZvcm1hdAogbXNnaWQgImFkZF9jYWNoZWluZm8gZmFpbGVkIGZvciBwYXRoICclcyc7IG1lcmdlIGFib3J0aW5nLiIKIG1zZ3N0ciAiYWRkX2NhY2hlaW5mbyBmYWxsw7MgcGFyYSBsYSBydXRhICclcyc7IGFib3J0YW5kbyBmdXNpw7NuLiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzU0CisjOiBtZXJnZS1yZWN1cnNpdmUuYzozOTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiYWRkX2NhY2hlaW5mbyBmYWlsZWQgdG8gcmVmcmVzaCBmb3IgcGF0aCAnJXMnOyBtZXJnZSBhYm9ydGluZy4iCiBtc2dzdHIgImFkZF9jYWNoZWluZm8gZmFsbMOzIHBhcmEgcmVmcmVzY2FyIGxhIHJ1dGEgJyVzJzsgYWJvcnRhbmRvIGZ1c2nDs24uIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzo0MzcKLW1zZ2lkICJlcnJvciBidWlsZGluZyB0cmVlcyIKLW1zZ3N0ciAiZXJyb3IgY29uc3RydXllbmRvIMOhcmJvbGVzIgotCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzo4NjMKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjg4NQogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gY3JlYXRlIHBhdGggJyVzJyVzIgogbXNnc3RyICJmYWxsw7MgYWwgY3JlYXIgbGEgcnV0YSAnJXMnJXMiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjg3NAorIzogbWVyZ2UtcmVjdXJzaXZlLmM6ODk2CiAjLCBjLWZvcm1hdAogbXNnaWQgIlJlbW92aW5nICVzIHRvIG1ha2Ugcm9vbSBmb3Igc3ViZGlyZWN0b3J5XG4iCiBtc2dzdHIgIlJlbW92aWVuZG8gJXMgcGFyYSBoYWNlciBlc3BhY2lvIHBhcmEgdW4gc3ViZGlyZWN0b3Jpb1xuIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzo4ODggbWVyZ2UtcmVjdXJzaXZlLmM6OTA3CisjOiBtZXJnZS1yZWN1cnNpdmUuYzo5MTAgbWVyZ2UtcmVjdXJzaXZlLmM6OTI5CiBtc2dpZCAiOiBwZXJoYXBzIGEgRC9GIGNvbmZsaWN0PyIKLW1zZ3N0ciAiOiB0YWwgdmV6IHVuIGNvbmZsaWN0byBEL0Y/IgorbXNnc3RyICI6IMK/dGFsIHZleiB1biBjb25mbGljdG8gRC9GPyIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6ODk3CisjOiBtZXJnZS1yZWN1cnNpdmUuYzo5MTkKICMsIGMtZm9ybWF0CiBtc2dpZCAicmVmdXNpbmcgdG8gbG9zZSB1bnRyYWNrZWQgZmlsZSBhdCAnJXMnIgogbXNnc3RyICJyZWh1c2FuZG8gcGVyZGVyIGVsIGFyY2hpdm8gcmFzdHJlYWRvIGVuICclcyciCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjkzOCBidWlsdGluL2NhdC1maWxlLmM6NDAKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjk2MCBidWlsdGluL2NhdC1maWxlLmM6NDEKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IHJlYWQgb2JqZWN0ICVzICclcyciCiBtc2dzdHIgIm5vIHNlIHB1ZWRlIGxlZXIgZWwgb2JqZXRvICVzICclcyciCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjk0MQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6OTY1CiAjLCBjLWZvcm1hdAogbXNnaWQgImJsb2IgZXhwZWN0ZWQgZm9yICVzICclcyciCiBtc2dzdHIgInNlIGVzcGVyYWJhIGJsb2IgcGFyYSAlcyAnJXMnIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzo5NjUKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjk5MAogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gb3BlbiAnJXMnOiAlcyIKIG1zZ3N0ciAiZmFsbMOzIGFsIGFicmlyICclcyc6ICVzIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzo5NzYKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEwMDEKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIHN5bWxpbmsgJyVzJzogJXMiCiBtc2dzdHIgImZhbGzDsyBhbCBjcmVhciBlbCBlbmxhY2Ugc2ltYsOzbGljbyAnJXMnOiAlcyIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6OTgxCisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxMDA2CiAjLCBjLWZvcm1hdAogbXNnaWQgImRvIG5vdCBrbm93IHdoYXQgdG8gZG8gd2l0aCAlMDZvICVzICclcyciCiBtc2dzdHIgIm5vIHNlIHF1ZSBoYWNlciBjb24gJTA2byAlcyAnJXMnIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxMTc3CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxMTk5CiAjLCBjLWZvcm1hdAogbXNnaWQgIkZhaWxlZCB0byBtZXJnZSBzdWJtb2R1bGUgJXMgKG5vdCBjaGVja2VkIG91dCkiCiBtc2dzdHIgIkZhbGzDsyBhbCBmdXNpb25hciBlbCBzdWJtw7NkdWxvICVzIChubyByZXZpc2FkbykiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjExODQKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEyMDYKICMsIGMtZm9ybWF0CiBtc2dpZCAiRmFpbGVkIHRvIG1lcmdlIHN1Ym1vZHVsZSAlcyAoY29tbWl0cyBub3QgcHJlc2VudCkiCiBtc2dzdHIgIkZhbGzDsyBhbCBmdXNpb25hciBlbCBzdWJtw7NkdWxvICVzIChjb21taXRzIG5vIHByZXNlbnRlcykiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjExOTEKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEyMTMKICMsIGMtZm9ybWF0CiBtc2dpZCAiRmFpbGVkIHRvIG1lcmdlIHN1Ym1vZHVsZSAlcyAoY29tbWl0cyBkb24ndCBmb2xsb3cgbWVyZ2UtYmFzZSkiCiBtc2dzdHIgIkZhbGzDsyBlbCBmdXNpb25hciBzdWJtw7NkdWxvICVzIChjb21taXRzIG5vIHNpZ3VlbiBsYSBmdXNpw7NuIGJhc2UpIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxMTk5IG1lcmdlLXJlY3Vyc2l2ZS5jOjEyMTEKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEyMjEgbWVyZ2UtcmVjdXJzaXZlLmM6MTIzMwogIywgYy1mb3JtYXQKIG1zZ2lkICJGYXN0LWZvcndhcmRpbmcgc3VibW9kdWxlICVzIHRvIHRoZSBmb2xsb3dpbmcgY29tbWl0OiIKIG1zZ3N0ciAiSGFjaWVuZG8gZmFzdC1mb3J3YXJkIGEgc3VibcOzZHVsbyAlcyBwYXJhIGVsIHNpZ3VpZW50ZSBjb21taXQ6IgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxMjAyIG1lcmdlLXJlY3Vyc2l2ZS5jOjEyMTQKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEyMjQgbWVyZ2UtcmVjdXJzaXZlLmM6MTIzNgogIywgYy1mb3JtYXQKIG1zZ2lkICJGYXN0LWZvcndhcmRpbmcgc3VibW9kdWxlICVzIgogbXNnc3RyICJBdmFuY2UgcsOhcGlkbyBlbiBzdWJtw7NkdWxvICVzIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxMjM3CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxMjU5CiAjLCBjLWZvcm1hdAogbXNnaWQgIkZhaWxlZCB0byBtZXJnZSBzdWJtb2R1bGUgJXMgKG1lcmdlIGZvbGxvd2luZyBjb21taXRzIG5vdCBmb3VuZCkiCiBtc2dzdHIgIiIKICJGYWxsw7MgYWwgZnVzaW9uYXIgc3VibcOzZHVsbyAlcyAobG9zIHNpZ3VlbnRlcyBjb21taXRzIG5vIGZ1ZXJvbiBlbmNvbnRyYWRvcykiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEyNDEKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEyNjMKICMsIGMtZm9ybWF0CiBtc2dpZCAiRmFpbGVkIHRvIG1lcmdlIHN1Ym1vZHVsZSAlcyAobm90IGZhc3QtZm9yd2FyZCkiCiBtc2dzdHIgIkZhbGzDsyBhbCBmdXNpb25hciBlbCBzdWJtw7NkdWxvICVzIChubyBlcyBwb3NpYmxlIGF2YW5jZSByw6FwaWRvKSIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTI0MgorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTI2NAogbXNnaWQgIkZvdW5kIGEgcG9zc2libGUgbWVyZ2UgcmVzb2x1dGlvbiBmb3IgdGhlIHN1Ym1vZHVsZTpcbiIKIG1zZ3N0ciAiU2UgZW5jb250csOzIHVuYSBwb3NpYmxlIHNvbHVjacOzbiBkZSBmdXNpw7NuIHBhcmEgZWwgc3VibcOzZHVsbzpcbiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTI0NQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTI2NwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiSWYgdGhpcyBpcyBjb3JyZWN0IHNpbXBseSBhZGQgaXQgdG8gdGhlIGluZGV4IGZvciBleGFtcGxlXG4iCkBAIC0zNzU2LDMzICszNzgwLDMzIEBACiAiXG4iCiAiZWwgY3VhbCBhY2VwdGFyw6EgZXN0YSBzdWdlcmVuY2lhLlxuIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxMjU0CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxMjc2CiAjLCBjLWZvcm1hdAogbXNnaWQgIkZhaWxlZCB0byBtZXJnZSBzdWJtb2R1bGUgJXMgKG11bHRpcGxlIG1lcmdlcyBmb3VuZCkiCiBtc2dzdHIgIkZhbGzDsyBhbCBmdXNpb25hciBlbCBzdWJtw7NkdWxvICVzIChmdXNpb25lcyBtw7psdGlwbGVzIGVuY29udHJhZGFzKSIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTMyNworIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTM0OQogbXNnaWQgIkZhaWxlZCB0byBleGVjdXRlIGludGVybmFsIG1lcmdlIgogbXNnc3RyICJGYWxsw7MgYWwgZWplY3V0YXIgbGEgZnVzacOzbiBpbnRlcm5hIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxMzMyCisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxMzU0CiAjLCBjLWZvcm1hdAogbXNnaWQgIlVuYWJsZSB0byBhZGQgJXMgdG8gZGF0YWJhc2UiCiBtc2dzdHIgIk5vIGVzIHBvc2libGUgYWdyZWdhciAlcyBhIGxhIGJhc2UgZGUgZGF0b3MiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEzNjQKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEzODYKICMsIGMtZm9ybWF0CiBtc2dpZCAiQXV0by1tZXJnaW5nICVzIgogbXNnc3RyICJBdXRvLWZ1c2lvbmFuZG8gJXMiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEzODcKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE0MTAKICMsIGMtZm9ybWF0CiBtc2dpZCAiRXJyb3I6IFJlZnVzaW5nIHRvIGxvc2UgdW50cmFja2VkIGZpbGUgYXQgJXM7IHdyaXRpbmcgdG8gJXMgaW5zdGVhZC4iCiBtc2dzdHIgIiIKICJFcnJvcjogUmVodXNhbmRvIHBlcmRlciBlbCBhcmNoaXZvIG5vIHJhc3RyZWFkbyBlbiAlczsgZXNjcmliacOpbmRvbG8gYSAlcyBlbiAiCiAiY2FtYmlvLiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTQ1OQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTQ4MgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiQ09ORkxJQ1QgKCVzL2RlbGV0ZSk6ICVzIGRlbGV0ZWQgaW4gJXMgYW5kICVzIGluICVzLiBWZXJzaW9uICVzIG9mICVzIGxlZnQgIgpAQCAtMzc5MSw3ICszODE1LDcgQEAKICJDT05GTElDVE8gKCVzL2JvcnJhcik6ICVzIGJvcnJhZG8gZW4gJXMgeSAlcyBlbiAlcy4gRmFsdGEgdmVyc2nDs24gJXMgZGUgJXMgIgogImVuIGVsIMOhcmJvbC4iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE0NjQKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE0ODcKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkNPTkZMSUNUICglcy9kZWxldGUpOiAlcyBkZWxldGVkIGluICVzIGFuZCAlcyB0byAlcyBpbiAlcy4gVmVyc2lvbiAlcyBvZiAlcyAiCkBAIC0zODAwLDcgKzM4MjQsNyBAQAogIkNPTkZMSUNUTyAoJXMvYm9ycmFyKTogJXMgYm9ycmFkbyBlbiAlcyB5ICVzIHBhcmEgJXMgZW4gJXMuIFZlcnNpw7NuICVzIGRlICVzICIKICJwZXJtYW5lY2UgZW4gZWwgw6FyYm9sLiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTQ3MQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTQ5NAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiQ09ORkxJQ1QgKCVzL2RlbGV0ZSk6ICVzIGRlbGV0ZWQgaW4gJXMgYW5kICVzIGluICVzLiBWZXJzaW9uICVzIG9mICVzIGxlZnQgIgpAQCAtMzgwOSw3ICszODMzLDcgQEAKICJDT05GTElDVE8gKCVzL2VsaW1pbmFyKTogJXMgZWxpbWluYWRvIGVuICVzIHkgJXMgZW4gJXMuIFZlcnNpw7NuICVzIGRlICVzICIKICJkZWphZGEgZW4gZWwgw6FyYm9sLCBlbiAlcy4iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE0NzYKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE0OTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkNPTkZMSUNUICglcy9kZWxldGUpOiAlcyBkZWxldGVkIGluICVzIGFuZCAlcyB0byAlcyBpbiAlcy4gVmVyc2lvbiAlcyBvZiAlcyAiCkBAIC0zODE4LDQ0ICszODQyLDQ0IEBACiAiQ09ORkxJQ1RPICglcy9ib3JyYXIpOiAlcyBib3JyYWRvIGVuICVzIHkgJXMgcGFyYSAlcyBlbiAlcy4gVmVyc2nDs24gJXMgZGUgJXMgIgogInBlcm1hbmVjZSBlbiBlbCDDoXJib2wgZW4gJXMuIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxNTExCisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxNTM0CiBtc2dpZCAicmVuYW1lIgogbXNnc3RyICJyZW5vbWJyYXIiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE1MTEKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE1MzQKIG1zZ2lkICJyZW5hbWVkIgogbXNnc3RyICJyZW5vbWJyYWRvIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxNTkxIG1lcmdlLXJlY3Vyc2l2ZS5jOjI0NTAgbWVyZ2UtcmVjdXJzaXZlLmM6MzA5NAorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTYxNCBtZXJnZS1yZWN1cnNpdmUuYzoyNDcyIG1lcmdlLXJlY3Vyc2l2ZS5jOjMxMTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiUmVmdXNpbmcgdG8gbG9zZSBkaXJ0eSBmaWxlIGF0ICVzIgogbXNnc3RyICJSZWh1c2FuZG8gcGVyZGVyIGVsIGFyY2hpdm8gc3VjaW8gZW4gJXMiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE2MDEKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE2MjQKICMsIGMtZm9ybWF0CiBtc2dpZCAiUmVmdXNpbmcgdG8gbG9zZSB1bnRyYWNrZWQgZmlsZSBhdCAlcywgZXZlbiB0aG91Z2ggaXQncyBpbiB0aGUgd2F5LiIKIG1zZ3N0ciAiIgogIlJlaHVzYW5kbyBwZXJkZXIgZWwgYXJjaGl2byBubyByYXN0cmVhZG8gZW4gJXMsIGluY2x1c28gYXVucXVlIHNlIGVzdMOhICIKICJpbnRlcnBvbmllbmRvLiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTY1OQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTY4MgogIywgYy1mb3JtYXQKIG1zZ2lkICJDT05GTElDVCAocmVuYW1lL2FkZCk6IFJlbmFtZSAlcy0+JXMgaW4gJXMuICBBZGRlZCAlcyBpbiAlcyIKIG1zZ3N0ciAiIgogIkNPTkZMSUNUTyAocmVub21icmFyL2FncmVnYXIpOiBSZW5vbWJyYXIgJXMtPiVzIGVuICVzLiAgJXMgYWdyZWdhZG8gZW4gJXMiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE2OTAKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE3MTMKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgaXMgYSBkaXJlY3RvcnkgaW4gJXMgYWRkaW5nIGFzICVzIGluc3RlYWQiCiBtc2dzdHIgIiVzIGVzIHVuIGRpcmVjdG9yaW8gZW4gJXMgYWdyZWdhbmRvIGNvbW8gJXMgbcOhcyBiaWVuIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxNjk1CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxNzE4CiAjLCBjLWZvcm1hdAogbXNnaWQgIlJlZnVzaW5nIHRvIGxvc2UgdW50cmFja2VkIGZpbGUgYXQgJXM7IGFkZGluZyBhcyAlcyBpbnN0ZWFkIgogbXNnc3RyICIiCiAiUmVodXNhbmRvIHBlcmRlciBlbCBhcmNoaXZvIG5vIHJhc3RyZWFkbyBlbiAlczsgYWdyZWfDoW5kb2xvIGNvbW8gJXMgZW4gY2FtYmlvIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxNzE0CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxNzM3CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJDT05GTElDVCAocmVuYW1lL3JlbmFtZSk6IFJlbmFtZSBcIiVzXCItPlwiJXNcIiBpbiBicmFuY2ggXCIlc1wiIHJlbmFtZSBcIiVzIgpAQCAtMzg2NCwxOCArMzg4OCwxOCBAQAogIkNPTkZMSUNUTyAocmVub21icmFyL3Jlbm9tYnJhcik6IFJlbm9tYnJhciBcIiVzXCItPlwiJXNcIiBlbiBsYSByYW1hIFwiJXNcIiAiCiAicmVub21icmFyIFwiJXNcIi0+XCIlc1wiIGVuIFwiJXNcIiVzIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxNzE5CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxNzQyCiBtc2dpZCAiIChsZWZ0IHVucmVzb2x2ZWQpIgogbXNnc3RyICIgKGRlamFkbyBzaW4gcmVzb2x2ZXIpIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxODI4CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxODUxCiAjLCBjLWZvcm1hdAogbXNnaWQgIkNPTkZMSUNUIChyZW5hbWUvcmVuYW1lKTogUmVuYW1lICVzLT4lcyBpbiAlcy4gUmVuYW1lICVzLT4lcyBpbiAlcyIKIG1zZ3N0ciAiIgogIkNPTkZMSUNUTyAocmVub21icmFyL3Jlbm9tYnJhcik6IFJlbm9tYnJhciAlcy0+JXMgZW4gJXMuIFJlbm9tYnJhciAlcy0+JXMgZW4gIgogIiVzIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoyMDM1CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoyMDU2CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJDT05GTElDVCAoZGlyZWN0b3J5IHJlbmFtZSBzcGxpdCk6IFVuY2xlYXIgd2hlcmUgdG8gcGxhY2UgJXMgYmVjYXVzZSAiCkBAIC0zODg2LDcgKzM5MTAsNyBAQAogImNvbG9jYXIgJXMgcG9ycXVlIGVsIGRpcmVjdG9yaW8gJXMgZnVlIHJlbm9tYnJhZG8gYSBvdHJvcyBtw7psdGlwbGVzICIKICJkaXJlY3Rvcmlvcywgc2luIG5pbmfDum4gcXVlIGNvbnRlbmdhIGxhIG1heW9yw61hIGRlIGFyY2hpdm9zLiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MjA2NworIzogbWVyZ2UtcmVjdXJzaXZlLmM6MjA4OAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiQ09ORkxJQ1QgKGltcGxpY2l0IGRpciByZW5hbWUpOiBFeGlzdGluZyBmaWxlL2RpciBhdCAlcyBpbiB0aGUgd2F5IG9mICIKQEAgLTM4OTYsNyArMzkyMCw3IEBACiAiZXhpc3RlbnRlIGVuICVzIHNlIGludGVycG9uZSBjb24gZWwgY2FtYmlvIGRlIG5vbWJyZXMgaW1wbMOtY2l0bywgcG9uaWVuZG8gIgogImxhKHMpIHNpZ3VpZW50ZShzKSBydXRhKHMpIGFxdcOtOiAlcy4iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjIwNzcKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjIwOTgKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkNPTkZMSUNUIChpbXBsaWNpdCBkaXIgcmVuYW1lKTogQ2Fubm90IG1hcCBtb3JlIHRoYW4gb25lIHBhdGggdG8gJXM7ICIKQEAgLTM5MDUsNyArMzkyOSw3IEBACiAiQ09ORkxJQ1RPIChjYW1iaW8gZGUgbm9tYnJlIGltcGzDrWNpdG8pOiBObyBzZSBwdWVkZSBtYXBlYXIgbcOhcyBkZSB1bmEgcnV0YSAiCiAicGFyYSAlczsgY2FtYmlvIGRlIG5vbWJyZSBpbXBsw61jaXRvIGludGVudMOzIHBvbmVyIGVzdGFzIHJ1dGFzOiAlcyIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MjE2OQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MjE5MAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiQ09ORkxJQ1QgKHJlbmFtZS9yZW5hbWUpOiBSZW5hbWUgZGlyZWN0b3J5ICVzLT4lcyBpbiAlcy4gUmVuYW1lIGRpcmVjdG9yeSAlcy0iCkBAIC0zOTE0LDcgKzM5MzgsNyBAQAogIkNPTkZMSUNUTyAocmVub21icmFyL3Jlbm9tYnJhcik6IFJlbm9tYnJhciBkaXJlY3RvcmlvICVzLT4lcyBlbiAlcy4gIgogIlJlbm9tYnJhciBkaXJlY3RvcmlvICVzLT4lcyBlbiAlcyIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MjQxMworIzogbWVyZ2UtcmVjdXJzaXZlLmM6MjQzNQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiV0FSTklORzogQXZvaWRpbmcgYXBwbHlpbmcgJXMgLT4gJXMgcmVuYW1lIHRvICVzLCBiZWNhdXNlICVzIGl0c2VsZiB3YXMgIgpAQCAtMzkyMyw1MiArMzk0Nyw1MiBAQAogIlBFTElHUk86IEV2aXRhbmRvIGFwbGljYXIgJXMgLT4gJXMgcmVub21icmFkbyBhICVzLCBwb3JxdWUgJXMgbWlzbW8gZnVlICIKICJyZW5vbWJyYWRvLiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MjkzOAorIzogbWVyZ2UtcmVjdXJzaXZlLmM6Mjk2MQogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgcmVhZCBvYmplY3QgJXMiCiBtc2dzdHIgIm5vIHNlIHB1ZG8gbGVlciBlbCBvYmpldG8gJXMiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjI5NDEKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjI5NjQKICMsIGMtZm9ybWF0CiBtc2dpZCAib2JqZWN0ICVzIGlzIG5vdCBhIGJsb2IiCiBtc2dzdHIgIm9iamV0byAlcyBubyBlcyB1biBibG9iIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozMDA1CisjOiBtZXJnZS1yZWN1cnNpdmUuYzozMDI4CiBtc2dpZCAibW9kaWZ5IgogbXNnc3RyICJtb2RpZmljYXIiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMwMDUKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMwMjgKIG1zZ2lkICJtb2RpZmllZCIKIG1zZ3N0ciAibW9kaWZpY2FkbyIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzAxNworIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzA0MAogbXNnaWQgImNvbnRlbnQiCiBtc2dzdHIgImNvbnRlbmlkbyIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzAyMQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzA0NAogbXNnaWQgImFkZC9hZGQiCiBtc2dzdHIgImFncmVnYXIvYWdyZWdhciIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzA0NAorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzA2NwogIywgYy1mb3JtYXQKIG1zZ2lkICJTa2lwcGVkICVzIChtZXJnZWQgc2FtZSBhcyBleGlzdGluZykiCiBtc2dzdHIgIlNhbHRhZG8gJXMgKGZ1c2lvbmFkbyBjb21vIGV4aXN0ZW50ZSkiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMwNjYgZ2l0LXN1Ym1vZHVsZS5zaDo5MzcKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMwODkgZ2l0LXN1Ym1vZHVsZS5zaDo5MzcKIG1zZ2lkICJzdWJtb2R1bGUiCiBtc2dzdHIgInN1Ym3Ds2R1bG8iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMwNjcKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMwOTAKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ09ORkxJQ1QgKCVzKTogTWVyZ2UgY29uZmxpY3QgaW4gJXMiCiBtc2dzdHIgIkNPTkZMSUNUTyAoJXMpOiBDb25mbGljdG8gZGUgZnVzacOzbiBlbiAlcyIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzA5NworIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzEyMAogIywgYy1mb3JtYXQKIG1zZ2lkICJBZGRpbmcgYXMgJXMgaW5zdGVhZCIKIG1zZ3N0ciAiQWdyZWdhbmRvIG3DoXMgYmllbiBjb21vICVzIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozMTc5CisjOiBtZXJnZS1yZWN1cnNpdmUuYzozMjAzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJQYXRoIHVwZGF0ZWQ6ICVzIGFkZGVkIGluICVzIGluc2lkZSBhIGRpcmVjdG9yeSB0aGF0IHdhcyByZW5hbWVkIGluICVzOyAiCkBAIC0zOTc3LDcgKzQwMDEsNyBAQAogIlBhdGggYWN0dWFsaXphZG86ICVzIGFncmVnYWRvIGVuICVzIGRlbnRybyBkZSB1biBkaXJlY3RvcmlvIHF1ZSBmdWUgIgogInJlbm9tYnJhZG8gZW4gJXM7IG1vdmnDqW5kb2xvIGEgJXMuIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozMTgyCisjOiBtZXJnZS1yZWN1cnNpdmUuYzozMjA2CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJDT05GTElDVCAoZmlsZSBsb2NhdGlvbik6ICVzIGFkZGVkIGluICVzIGluc2lkZSBhIGRpcmVjdG9yeSB0aGF0IHdhcyByZW5hbWVkICIKQEAgLTM5ODYsNyArNDAxMCw3IEBACiAiQ09ORkxJQ1RPICh1YmljYWNpw7NuIGRlIGFyY2hpdm8pOiAlcyBhZ3JlZ2FkbyBlbiAlcyBkZW50cm8gZGUgdW4gZGlyZWN0b3JpbyAiCiAicXVlIGZ1ZSByZW5vbWJyYWRvIGVuICVzLCBzdWdlcmltb3MgcXVlIGRlYmVyw61hIHNlciBtb3ZpZG8gYSAlcy4iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMxODYKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMyMTAKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlBhdGggdXBkYXRlZDogJXMgcmVuYW1lZCB0byAlcyBpbiAlcywgaW5zaWRlIGEgZGlyZWN0b3J5IHRoYXQgd2FzIHJlbmFtZWQgaW4gIgpAQCAtMzk5NSw3ICs0MDE5LDcgQEAKICJQYXRoIGFjdHVhbGl6YWRvOiAlcyByZW5vbWJyYWRvIGEgJXMgZW4gJXMsIGRlbnRybyBkZSB1biBkaXJlY3RvcmlvIHF1ZSBmdWUgIgogInJlbm9tYnJhZG8gZW4gJXM7IG1vdmnDqW5kb2xvIGEgJXMuIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozMTg5CisjOiBtZXJnZS1yZWN1cnNpdmUuYzozMjEzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJDT05GTElDVCAoZmlsZSBsb2NhdGlvbik6ICVzIHJlbmFtZWQgdG8gJXMgaW4gJXMsIGluc2lkZSBhIGRpcmVjdG9yeSB0aGF0ICIKQEAgLTQwMDUsMzcgKzQwMjksNjEgQEAKICJkaXJlY3RvcmlvIHF1ZSBmdWUgcmVub21icmFkbyBlbiAlcywgc3VnaXJpZW5kbyBxdWUgdGFsIHZleiBkZWJlcsOtYSBzZXIgIgogIm1vdmlkbyBhICVzLiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzMwMworIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzMyNwogIywgYy1mb3JtYXQKIG1zZ2lkICJSZW1vdmluZyAlcyIKIG1zZ3N0ciAiRWxpbWluYW5kbyAlcyIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzMyNgorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzM1MAogbXNnaWQgImZpbGUvZGlyZWN0b3J5IgogbXNnc3RyICJhcmNoaXZvL2RpcmVjdG9yaW8iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMzMzEKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMzNTUKIG1zZ2lkICJkaXJlY3RvcnkvZmlsZSIKIG1zZ3N0ciAiZGlyZWN0b3Jpby9hcmNoaXZvIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozMzM4CisjOiBtZXJnZS1yZWN1cnNpdmUuYzozMzYyCiAjLCBjLWZvcm1hdAogbXNnaWQgIkNPTkZMSUNUICglcyk6IFRoZXJlIGlzIGEgZGlyZWN0b3J5IHdpdGggbmFtZSAlcyBpbiAlcy4gQWRkaW5nICVzIGFzICVzIgogbXNnc3RyICIiCiAiQ09ORkxJQ1RPICglcyk6IEhheSB1biBkaXJlY3RvcmlvIGNvbiBlbCBub21icmUgJXMgZW4gJXMuIEFncmVnYW5kbyAlcyBjb21vICIKICIlcyIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzM0NworIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzM3MQogIywgYy1mb3JtYXQKIG1zZ2lkICJBZGRpbmcgJXMiCiBtc2dzdHIgIkFncmVnYW5kbyAlcyIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzM1NgorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzM4MAogIywgYy1mb3JtYXQKIG1zZ2lkICJDT05GTElDVCAoYWRkL2FkZCk6IE1lcmdlIGNvbmZsaWN0IGluICVzIgogbXNnc3RyICJDT05GTElDVE8gKGFkZC9hZGQpOiBDb25mbGljdG8gZGUgbWVyZ2UgZW4gJXMiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMzOTQKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjM0MjQKK21zZ2lkICJBbHJlYWR5IHVwIHRvIGRhdGUhIgorbXNnc3RyICLCoVlhIGVzdMOhIGFjdHVhbGl6YWRvISIKKworIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzQzMworIywgYy1mb3JtYXQKK21zZ2lkICJtZXJnaW5nIG9mIHRyZWVzICVzIGFuZCAlcyBmYWlsZWQiCittc2dzdHIgImZhbGzDsyBsYSBmdXNpw7NuIGRlIGxvcyDDoXJib2xlcyAlcyB5ICVzIgorCisjOiBtZXJnZS1yZWN1cnNpdmUuYzozNTM3Cittc2dpZCAiTWVyZ2luZzoiCittc2dzdHIgIkZ1c2lvbmFuZG86IgorCisjOiBtZXJnZS1yZWN1cnNpdmUuYzozNTUwCisjLCBjLWZvcm1hdAorbXNnaWQgImZvdW5kICV1IGNvbW1vbiBhbmNlc3RvcjoiCittc2dpZF9wbHVyYWwgImZvdW5kICV1IGNvbW1vbiBhbmNlc3RvcnM6IgorbXNnc3RyWzBdICJzZSBlbmNvbnRyw7MgJXUgYW5jZXN0cm8gY29tw7puOiIKK21zZ3N0clsxXSAic2UgZW5jb250cmFyb24gJXUgYW5jZXN0cm9zIGNvbXVuZXM6IgorCisjOiBtZXJnZS1yZWN1cnNpdmUuYzozNjAwCittc2dpZCAibWVyZ2UgcmV0dXJuZWQgbm8gY29tbWl0IgorbXNnc3RyICJsYSBmdXNpw7NuIG5vIGRldm9sdmnDsyBuaW5nw7puIGNvbW1pdCIKKworIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzY1OQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiWW91ciBsb2NhbCBjaGFuZ2VzIHRvIHRoZSBmb2xsb3dpbmcgZmlsZXMgd291bGQgYmUgb3ZlcndyaXR0ZW4gYnkgbWVyZ2U6XG4iCkBAIC00MDQ1LDE5MCArNDA5MywxNjYgQEAKICJtZXJnZTpcbiIKICIgICVzIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozNDA1Ci1tc2dpZCAiQWxyZWFkeSB1cCB0byBkYXRlISIKLW1zZ3N0ciAiwqFZYSBlc3TDoSBhY3R1YWxpemFkbyEiCi0KLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjM0MTQKLSMsIGMtZm9ybWF0Ci1tc2dpZCAibWVyZ2luZyBvZiB0cmVlcyAlcyBhbmQgJXMgZmFpbGVkIgotbXNnc3RyICJmYWxsw7MgbGEgZnVzacOzbiBkZSBsb3Mgw6FyYm9sZXMgJXMgeSAlcyIKLQotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzUxMwotbXNnaWQgIk1lcmdpbmc6IgotbXNnc3RyICJGdXNpb25hbmRvOiIKLQotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzUyNgotIywgYy1mb3JtYXQKLW1zZ2lkICJmb3VuZCAldSBjb21tb24gYW5jZXN0b3I6IgotbXNnaWRfcGx1cmFsICJmb3VuZCAldSBjb21tb24gYW5jZXN0b3JzOiIKLW1zZ3N0clswXSAic2UgZW5jb250csOzICV1IGFuY2VzdHJvIGNvbcO6bjoiCi1tc2dzdHJbMV0gInNlIGVuY29udHJhcm9uICV1IGFuY2VzdHJvcyBjb211bmVzOiIKLQotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzU2NQotbXNnaWQgIm1lcmdlIHJldHVybmVkIG5vIGNvbW1pdCIKLW1zZ3N0ciAibGEgZnVzacOzbiBubyBkZXZvbHZpw7MgbmluZ8O6biBjb21taXQiCi0KLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjM2MzEKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjM3NTYKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ291bGQgbm90IHBhcnNlIG9iamVjdCAnJXMnIgogbXNnc3RyICJObyBzZSBwdWRvIGFuYWxpemFyIGVsIG9iamV0byAnJXMnIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozNjQ3IGJ1aWx0aW4vbWVyZ2UuYzo2OTggYnVpbHRpbi9tZXJnZS5jOjg2OQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6Mzc3NCBidWlsdGluL21lcmdlLmM6Njk0IGJ1aWx0aW4vbWVyZ2UuYzo4NzQKIG1zZ2lkICJVbmFibGUgdG8gd3JpdGUgaW5kZXguIgogbXNnc3RyICJJbmNhcGF6IGRlIGVzY3JpYmlyIGVsIMOtbmRpY2UuIgogCi0jOiBtaWR4LmM6NjkKKyM6IG1pZHguYzo2OAogIywgYy1mb3JtYXQKIG1zZ2lkICJtdWx0aS1wYWNrLWluZGV4IGZpbGUgJXMgaXMgdG9vIHNtYWxsIgogbXNnc3RyICJhcmNoaXZvIG11bHRpLXBhY2staW5kZXggJXMgZXMgbXV5IHBlcXVlw7FvIgogCi0jOiBtaWR4LmM6ODUKKyM6IG1pZHguYzo4NAogIywgYy1mb3JtYXQKIG1zZ2lkICJtdWx0aS1wYWNrLWluZGV4IHNpZ25hdHVyZSAweCUwOHggZG9lcyBub3QgbWF0Y2ggc2lnbmF0dXJlIDB4JTA4eCIKIG1zZ3N0ciAiZmlybWEgZGUgbXVsdGktcGFjay1pbmRleCAweCUwOHggbm8gY29uY3VlcmRhIGNvbiBmaXJtYSAweCUwOHgiCiAKLSM6IG1pZHguYzo5MAorIzogbWlkeC5jOjg5CiAjLCBjLWZvcm1hdAogbXNnaWQgIm11bHRpLXBhY2staW5kZXggdmVyc2lvbiAlZCBub3QgcmVjb2duaXplZCIKIG1zZ3N0ciAidmVyc2nDs24gJWQgZGUgbXVsdGktcGFjay1pbmRleCBubyByZWNvbm9jaWRhIgogCi0jOiBtaWR4LmM6OTUKKyM6IG1pZHguYzo5NAogIywgYy1mb3JtYXQKIG1zZ2lkICJoYXNoIHZlcnNpb24gJXUgZG9lcyBub3QgbWF0Y2giCiBtc2dzdHIgInZlcnNpw7NuIGRlIGhhc2ggJXUgbm8gY29uY3VlcmRhIgogCi0jOiBtaWR4LmM6MTA5CisjOiBtaWR4LmM6MTA4CiBtc2dpZCAiaW52YWxpZCBjaHVuayBvZmZzZXQgKHRvbyBsYXJnZSkiCiBtc2dzdHIgIm9mZnNldCBpbnbDoWxpZG8gZGVsIGNvbmp1bnRvIChtdXkgZ3JhbmRlKSIKIAotIzogbWlkeC5jOjEzMworIzogbWlkeC5jOjEzMgogbXNnaWQgInRlcm1pbmF0aW5nIG11bHRpLXBhY2staW5kZXggY2h1bmsgaWQgYXBwZWFycyBlYXJsaWVyIHRoYW4gZXhwZWN0ZWQiCiBtc2dzdHIgIiIKICJ0ZXJtaW5hbmRvIG11bHRpLXBhY2staW5kZXggcG9ycXVlIGVsIGlkIGRlbCBjb25qdW50byBhcGFyZWNlIGFudGVzIGRlIGxvICIKICJlc3BlcmFkbyIKIAotIzogbWlkeC5jOjE0NgorIzogbWlkeC5jOjE0NQogbXNnaWQgIm11bHRpLXBhY2staW5kZXggbWlzc2luZyByZXF1aXJlZCBwYWNrLW5hbWUgY2h1bmsiCiBtc2dzdHIgIm11bHRpLXBhY2staW5kZXggbGUgZmFsdGEgZWwgY29uanVudG8gcGFjay1uYW1lIHJlcXVlcmlkbyIKIAotIzogbWlkeC5jOjE0OAorIzogbWlkeC5jOjE0NwogbXNnaWQgIm11bHRpLXBhY2staW5kZXggbWlzc2luZyByZXF1aXJlZCBPSUQgZmFub3V0IGNodW5rIgogbXNnc3RyICJtdWx0aS1wYWNrLWluZGV4IGxlIGZhbHRhIGVsIGNvbmp1bnRvIE9JRCBmYW5vdXQgcmVxdWVyaWRvIgogCi0jOiBtaWR4LmM6MTUwCisjOiBtaWR4LmM6MTQ5CiBtc2dpZCAibXVsdGktcGFjay1pbmRleCBtaXNzaW5nIHJlcXVpcmVkIE9JRCBsb29rdXAgY2h1bmsiCiBtc2dzdHIgIm11bHRpLXBhY2staW5kZXggbGUgZmFsdGEgZWwgY29uanVudG8gT0lEIGZhbm91dCByZXF1ZXJpZG8iCiAKLSM6IG1pZHguYzoxNTIKKyM6IG1pZHguYzoxNTEKIG1zZ2lkICJtdWx0aS1wYWNrLWluZGV4IG1pc3NpbmcgcmVxdWlyZWQgb2JqZWN0IG9mZnNldHMgY2h1bmsiCiBtc2dzdHIgIm11bHRpLXBhY2staW5kZXggbGUgZmFsdGEgZWwgY29uanVudG8gZGUgb2Zmc2V0IGRlbCBvYmpldG8gcmVxdWVyaWRvIgogCi0jOiBtaWR4LmM6MTY2CisjOiBtaWR4LmM6MTY1CiAjLCBjLWZvcm1hdAogbXNnaWQgIm11bHRpLXBhY2staW5kZXggcGFjayBuYW1lcyBvdXQgb2Ygb3JkZXI6ICclcycgYmVmb3JlICclcyciCiBtc2dzdHIgIm11bHRpLXBhY2staW5kZXggbm9tYnJlcyBkZSBwYXF1ZXRlIGZ1ZXJhIGRlIG9yZGVuOiclcycgYW50ZXMgJyVzJyIKIAotIzogbWlkeC5jOjIxMQorIzogbWlkeC5jOjIxMAogIywgYy1mb3JtYXQKIG1zZ2lkICJiYWQgcGFjay1pbnQtaWQ6ICV1ICgldSB0b3RhbCBwYWNrcykiCiBtc2dzdHIgIm1hbCBwYWNrLWludC1pZDogJXUgKCV1IHBhcXVldGVzIHRvdGFsZXMpIgogCi0jOiBtaWR4LmM6MjYxCisjOiBtaWR4LmM6MjYwCiBtc2dpZCAibXVsdGktcGFjay1pbmRleCBzdG9yZXMgYSA2NC1iaXQgb2Zmc2V0LCBidXQgb2ZmX3QgaXMgdG9vIHNtYWxsIgogbXNnc3RyICJtdWx0aS1wYWNrLWluZGV4IGd1YXJkYSB1biBvZmZzZXQgZGUgNjQtYml0LCBwZXJvIG9mZl90IGVzIG11eSBwZXF1ZcOxbyIKIAotIzogbWlkeC5jOjI4OQorIzogbWlkeC5jOjI4OAogbXNnaWQgImVycm9yIHByZXBhcmluZyBwYWNrZmlsZSBmcm9tIG11bHRpLXBhY2staW5kZXgiCiBtc2dzdHIgImVycm9yIHByZXBhcmFuZG8gcGFja2ZpbGUgZGUgbXVsdGktcGFjay1pbmRleCIKIAotIzogbWlkeC5jOjQ3MAorIzogbWlkeC5jOjQ2OQogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gYWRkIHBhY2tmaWxlICclcyciCiBtc2dzdHIgImZhbGzDsyBhbCBhZ3JlZ2FyIHBhY2tmaWxlICclcyciCiAKLSM6IG1pZHguYzo0NzYKKyM6IG1pZHguYzo0NzUKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIG9wZW4gcGFjay1pbmRleCAnJXMnIgogbXNnc3RyICJmYWxsw7MgYWwgYWJyaXIgcGFjay1pbmRleCAnJXMnIgogCi0jOiBtaWR4LmM6NTM2CisjOiBtaWR4LmM6NTM1CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBsb2NhdGUgb2JqZWN0ICVkIGluIHBhY2tmaWxlIgogbXNnc3RyICJmYWxsw7MgYWwgdWJpY2FyIG9iamV0byAlZCBlbiBwYWNrZmlsZSIKIAotIzogbWlkeC5jOjg2NQorIzogbWlkeC5jOjg2NAogIywgYy1mb3JtYXQKIG1zZ2lkICJkaWQgbm90IHNlZSBwYWNrLWZpbGUgJXMgdG8gZHJvcCIKIG1zZ3N0ciAibm8gc2UgdmnDsyBwYWNrLWZpbGUgJXMgY2FlciIKIAotIzogbWlkeC5jOjEwMzYKKyM6IG1pZHguYzoxMDM1CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBjbGVhciBtdWx0aS1wYWNrLWluZGV4IGF0ICVzIgogbXNnc3RyICJmYWxsw7MgYWwgbGltcGlhciBtdWx0aS1wYWNrLWluZGV4IGVuICVzIgogCi0jOiBtaWR4LmM6MTA5MQorIzogbWlkeC5jOjEwOTAKIG1zZ2lkICJMb29raW5nIGZvciByZWZlcmVuY2VkIHBhY2tmaWxlcyIKIG1zZ3N0ciAiQnVzY2FuZG8gcG9yIHBhY2tmaWxlcyByZWZlcmlkb3MiCiAKLSM6IG1pZHguYzoxMTA2CisjOiBtaWR4LmM6MTEwNQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAib2lkIGZhbm91dCBvdXQgb2Ygb3JkZXI6IGZhbm91dFslZF0gPSAlPFBSSXgzMj4gPiAlPFBSSXgzMj4gPSBmYW5vdXRbJWRdIgogbXNnc3RyICIiCiAib2lkIGZhbm91dCBmdWVyYSBkZSBvcmRlbjogZmFub3V0WyVkXSA9ICU8UFJJeDMyPiA+ICU8UFJJeDMyPiA9IGZhbm91dFslZF0iCiAKLSM6IG1pZHguYzoxMTEwCisjOiBtaWR4LmM6MTEwOQogbXNnaWQgIlZlcmlmeWluZyBPSUQgb3JkZXIgaW4gTUlEWCIKIG1zZ3N0ciAiVmVyaWZpY2FuZG8gb3JkZW4gZGUgT0lEIGVuIE1JRFgiCiAKLSM6IG1pZHguYzoxMTE5CisjOiBtaWR4LmM6MTExOAogIywgYy1mb3JtYXQKIG1zZ2lkICJvaWQgbG9va3VwIG91dCBvZiBvcmRlcjogb2lkWyVkXSA9ICVzID49ICVzID0gb2lkWyVkXSIKIG1zZ3N0ciAib2lkIGxvb2t1cCBmdWVyYSBkZSBvcmRlbjogb2lkWyVkXSA9ICVzID49ICVzID0gb2lkWyVkXSIKIAotIzogbWlkeC5jOjExMzgKKyM6IG1pZHguYzoxMTM3CiBtc2dpZCAiU29ydGluZyBvYmplY3RzIGJ5IHBhY2tmaWxlIgogbXNnc3RyICJPcmRlbmFuZG8gb2JqZXRvcyBwb3IgcGFja2ZpbGUiCiAKLSM6IG1pZHguYzoxMTQ0CisjOiBtaWR4LmM6MTE0MwogbXNnaWQgIlZlcmlmeWluZyBvYmplY3Qgb2Zmc2V0cyIKIG1zZ3N0ciAiVmVyaWZpY2FuZG8gb2Zmc2V0cyBkZSBvYmpldG9zIgogCi0jOiBtaWR4LmM6MTE2MAorIzogbWlkeC5jOjExNTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIGxvYWQgcGFjayBlbnRyeSBmb3Igb2lkWyVkXSA9ICVzIgogbXNnc3RyICJmYWxsbyBhbCBjYXJnYXIgZW50cmFkYSBwYWNrIHBhcmEgb2lkWyVkXSA9ICVzIgogCi0jOiBtaWR4LmM6MTE2NgorIzogbWlkeC5jOjExNjUKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIGxvYWQgcGFjay1pbmRleCBmb3IgcGFja2ZpbGUgJXMiCiBtc2dzdHIgImZhbGzDsyBhbCBjYXJnYXIgZWwgcGFjay1pbmRleCBwYXJhIHBhY2tmaWxlICVzIgogCi0jOiBtaWR4LmM6MTE3NQorIzogbWlkeC5jOjExNzQKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW5jb3JyZWN0IG9iamVjdCBvZmZzZXQgZm9yIG9pZFslZF0gPSAlczogJTxQUkl4NjQ+ICE9ICU8UFJJeDY0PiIKIG1zZ3N0ciAib2Zmc2V0IHBhcmEgb2JqZXRvIGluY29ycmVjdG8gb2lkWyVkXSA9ICVzOiAlPFBSSXg2ND4gIT0gJTxQUkl4NjQ+IgogCi0jOiBtaWR4LmM6MTM1MAorIzogbWlkeC5jOjEzNDkKIG1zZ2lkICJjb3VsZCBub3Qgc3RhcnQgcGFjay1vYmplY3RzIgogbXNnc3RyICJubyBzZSBwdWRvIGVtcGV6YXIgbG9zIHBhY2stb2JqZXRjdHMiCiAKLSM6IG1pZHguYzoxMzY5CisjOiBtaWR4LmM6MTM2OAogbXNnaWQgImNvdWxkIG5vdCBmaW5pc2ggcGFjay1vYmplY3RzIgogbXNnc3RyICJubyBzZSBwdWRvIGZpbmFsaXphciBwYWNrLW9iamV0Y3RzIgogCi0jOiBuYW1lLWhhc2guYzo1MzIKKyM6IG5hbWUtaGFzaC5jOjUzNwogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gY3JlYXRlIGxhenlfZGlyIHRocmVhZDogJXMiCiBtc2dzdHIgIm5vIGVzIHBvc2libGUgY3JlYXIgaGlsbyBsYXp5X2RpcjogJXMiCiAKLSM6IG5hbWUtaGFzaC5jOjU1NAorIzogbmFtZS1oYXNoLmM6NTU5CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBjcmVhdGUgbGF6eV9uYW1lIHRocmVhZDogJXMiCiBtc2dzdHIgIm5vIGVzIHBvc2libGUgY3JlYXIgaGlsbyBsYXp5X25hbWU6ICVzIgogCi0jOiBuYW1lLWhhc2guYzo1NjAKKyM6IG5hbWUtaGFzaC5jOjU2NQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gam9pbiBsYXp5X25hbWUgdGhyZWFkOiAlcyIKIG1zZ3N0ciAibm8gZXMgcG9zaWJsZSB1bmlyIGhpbG8gbGF6eV9uYW1lOiAlcyIKQEAgLTQyNzUsNDYgKzQyOTksNDYgQEAKIG1zZ2lkICJCYWQgJXMgdmFsdWU6ICclcyciCiBtc2dzdHIgIlZhbG9yIGVycsOzbmVvIHBhcmEgJXM6ICclcyciCiAKLSM6IG9iamVjdC5jOjU0CisjOiBvYmplY3QuYzo1MwogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIG9iamVjdCB0eXBlIFwiJXNcIiIKIG1zZ3N0ciAidGlwbyBkZSBvYmpldG8gXCIlc1wiIGludsOhbGlkbyIKIAotIzogb2JqZWN0LmM6MTc0CisjOiBvYmplY3QuYzoxNzMKICMsIGMtZm9ybWF0CiBtc2dpZCAib2JqZWN0ICVzIGlzIGEgJXMsIG5vdCBhICVzIgogbXNnc3RyICJvYmpldG8gJXMgZXMgdW4gJXMsIG5vIHVuICVzIgogCi0jOiBvYmplY3QuYzoyMzQKKyM6IG9iamVjdC5jOjIzMwogIywgYy1mb3JtYXQKIG1zZ2lkICJvYmplY3QgJXMgaGFzIHVua25vd24gdHlwZSBpZCAlZCIKIG1zZ3N0ciAiZWwgb2JqZXRvICVzIHRpZW5lIHVuIGlkIGRlIHRpcG8gZGVzY29ub2NpZG8gJWQiCiAKLSM6IG9iamVjdC5jOjI0NworIzogb2JqZWN0LmM6MjQ2CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBwYXJzZSBvYmplY3Q6ICVzIgogbXNnc3RyICJpbmNhcGF6IGRlIGFuYWxpemFyIG9iamV0bzogJXMiCiAKLSM6IG9iamVjdC5jOjI2NyBvYmplY3QuYzoyNzgKKyM6IG9iamVjdC5jOjI2NiBvYmplY3QuYzoyNzcKICMsIGMtZm9ybWF0CiBtc2dpZCAiaGFzaCBtaXNtYXRjaCAlcyIKIG1zZ3N0ciAiaGFzaCBubyBjb25jdWVyZGEgJXMiCiAKLSM6IHBhY2tmaWxlLmM6NjQ4CisjOiBwYWNrZmlsZS5jOjY0MQogbXNnaWQgIm9mZnNldCBiZWZvcmUgZW5kIG9mIHBhY2tmaWxlIChicm9rZW4gLmlkeD8pIgogbXNnc3RyICJvZmZzZXQgYW50ZXMgZGVsIGZpbmFsIGRlbCBwYXF1ZXRlIChicm9rZW4gLmlkeD8pIgogCi0jOiBwYWNrZmlsZS5jOjE4OTkKKyM6IHBhY2tmaWxlLmM6MTg4NwogIywgYy1mb3JtYXQKIG1zZ2lkICJvZmZzZXQgYmVmb3JlIHN0YXJ0IG9mIHBhY2sgaW5kZXggZm9yICVzIChjb3JydXB0IGluZGV4PykiCiBtc2dzdHIgIiIKLSJvZmZzZXQgYW50ZXMgZGVsIGNvbWllbnpvIGRlbCDDrW5kaWNlIGRlbCBwYXF1ZXRlIHBhcmEgJXMgKMOtbmRpY2UgY29ycnVwdG8/KSIKKyJvZmZzZXQgYW50ZXMgZGVsIGNvbWllbnpvIGRlbCDDrW5kaWNlIGRlbCBwYXF1ZXRlIHBhcmEgJXMgKMK/w61uZGljZSBjb3JydXB0bz8pIgogCi0jOiBwYWNrZmlsZS5jOjE5MDMKKyM6IHBhY2tmaWxlLmM6MTg5MQogIywgYy1mb3JtYXQKIG1zZ2lkICJvZmZzZXQgYmV5b25kIGVuZCBvZiBwYWNrIGluZGV4IGZvciAlcyAodHJ1bmNhdGVkIGluZGV4PykiCiBtc2dzdHIgIiIKLSJvZmZzZXQgbcOhcyBhbGzDoSBkZWwgw61uZGljZSBkZSBmaW4gZGUgcGFxdWV0ZSBwYXJhICVzICjDrW5kaWNlIHRydW5jYWRvPykiCisib2Zmc2V0IG3DoXMgYWxsw6EgZGVsIMOtbmRpY2UgZGUgZmluIGRlIHBhcXVldGUgcGFyYSAlcyAowr/DrW5kaWNlIHRydW5jYWRvPykiCiAKICM6IHBhcnNlLW9wdGlvbnMuYzozOAogIywgYy1mb3JtYXQKQEAgLTQzNTYsMjYgKzQzODAsMjYgQEAKIG1zZ2lkICJkaWQgeW91IG1lYW4gYC0tJXNgICh3aXRoIHR3byBkYXNoZXMgPykiCiBtc2dzdHIgIsK/cXVpc2lzdGUgZGVjaXIgYC0tJXNgIChjb24gZG9zIGd1aW9uZXMpPyIKIAotIzogcGFyc2Utb3B0aW9ucy5jOjg1OQorIzogcGFyc2Utb3B0aW9ucy5jOjg2MAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmtub3duIG9wdGlvbiBgJXMnIgogbXNnc3RyICJvcGNpw7NuIGAlcycgZGVzY29ub2NpZGEiCiAKLSM6IHBhcnNlLW9wdGlvbnMuYzo4NjEKKyM6IHBhcnNlLW9wdGlvbnMuYzo4NjIKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5rbm93biBzd2l0Y2ggYCVjJyIKIG1zZ3N0ciAic3dpdGNoIGRlc2Nvbm9jaWRvIGAlYyciCiAKLSM6IHBhcnNlLW9wdGlvbnMuYzo4NjMKKyM6IHBhcnNlLW9wdGlvbnMuYzo4NjQKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5rbm93biBub24tYXNjaWkgb3B0aW9uIGluIHN0cmluZzogYCVzJyIKIG1zZ3N0ciAib3BjacOzbiBkZXNjb25vY2lkYSBlbiBzdHJpbmcgbm8gYXNjaWk6IGAlcyciCiAKLSM6IHBhcnNlLW9wdGlvbnMuYzo4ODcKKyM6IHBhcnNlLW9wdGlvbnMuYzo4ODgKIG1zZ2lkICIuLi4iCiBtc2dzdHIgIi4uLiIKIAotIzogcGFyc2Utb3B0aW9ucy5jOjkwNgorIzogcGFyc2Utb3B0aW9ucy5jOjkwNwogIywgYy1mb3JtYXQKIG1zZ2lkICJ1c2FnZTogJXMiCiBtc2dzdHIgInVzbzogJXMiCkBAIC00MzgzLDIxICs0NDA3LDIxIEBACiAjLiBUUkFOU0xBVE9SUzogdGhlIGNvbG9uIGhlcmUgc2hvdWxkIGFsaWduIHdpdGggdGhlCiAjLiBvbmUgaW4gInVzYWdlOiAlcyIgdHJhbnNsYXRpb24uCiAjLgotIzogcGFyc2Utb3B0aW9ucy5jOjkxMgorIzogcGFyc2Utb3B0aW9ucy5jOjkxMwogIywgYy1mb3JtYXQKIG1zZ2lkICIgICBvcjogJXMiCiBtc2dzdHIgIiAgIG86ICVzIgogCi0jOiBwYXJzZS1vcHRpb25zLmM6OTE1CisjOiBwYXJzZS1vcHRpb25zLmM6OTE2CiAjLCBjLWZvcm1hdAogbXNnaWQgIiAgICAlcyIKIG1zZ3N0ciAiICAgICVzIgogCi0jOiBwYXJzZS1vcHRpb25zLmM6OTU0CisjOiBwYXJzZS1vcHRpb25zLmM6OTU1CiBtc2dpZCAiLU5VTSIKIG1zZ3N0ciAiLU5VTSIKIAotIzogcGFyc2Utb3B0aW9ucy5jOjk2OAorIzogcGFyc2Utb3B0aW9ucy5jOjk2OQogIywgYy1mb3JtYXQKIG1zZ2lkICJhbGlhcyBvZiAtLSVzIgogbXNnc3RyICJhbGlhcyBkZSAtLSVzIgpAQCAtNDU2NiwyOSArNDU5MCwzOCBAQAogbXNnaWQgInVuYWJsZSB0byBwYXJzZSAtLXByZXR0eSBmb3JtYXQiCiBtc2dzdHIgImluY2FwYXogZGUgYW5hbGl6YXIgZWwgZm9ybWF0byAtLXByZXR0eSIKIAotIzogcmFuZ2UtZGlmZi5jOjcwCisjOiBwcm9taXNvci1yZW1vdGUuYzoyNQorbXNnaWQgIlJlbW90ZSB3aXRoIG5vIFVSTCIKK21zZ3N0ciAiUmVtb3RvIHNpbiBVUkwiCisKKyM6IHByb21pc29yLXJlbW90ZS5jOjYxCisjLCBjLWZvcm1hdAorbXNnaWQgInByb21pc29yIHJlbW90ZSBuYW1lIGNhbm5vdCBiZWdpbiB3aXRoICcvJzogJXMiCittc2dzdHIgIm5vbWJyZSByZW1vdG8gcHJvbWlzb3Igbm8gcHVlZGUgY29tZW56YXIgY29uICcvJzogJXMiCisKKyM6IHJhbmdlLWRpZmYuYzo3MQogbXNnaWQgImNvdWxkIG5vdCBzdGFydCBgbG9nYCIKIG1zZ3N0ciAibm8gc2UgcHVkbyBjb21lbnphciBgbG9nYCIKIAotIzogcmFuZ2UtZGlmZi5jOjcyCisjOiByYW5nZS1kaWZmLmM6NzMKIG1zZ2lkICJjb3VsZCBub3QgcmVhZCBgbG9nYCBvdXRwdXQiCiBtc2dzdHIgIm5vIHNlIHB1ZG8gbGVlciBvdXRwdXQgZGUgYGxvZ2AiCiAKLSM6IHJhbmdlLWRpZmYuYzo5MSBzZXF1ZW5jZXIuYzo1MDIxCisjOiByYW5nZS1kaWZmLmM6OTIgc2VxdWVuY2VyLmM6NDk4NQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcGFyc2UgY29tbWl0ICclcyciCiBtc2dzdHIgIm5vIHNlIHB1ZG8gYW5hbGl6YXIgY29tbWl0ICclcyciCiAKLSM6IHJhbmdlLWRpZmYuYzoxMTcKKyM6IHJhbmdlLWRpZmYuYzoxMTgKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHBhcnNlIGdpdCBoZWFkZXIgJyUuKnMnIgogbXNnc3RyICJubyBzZSBwdWVkZSBhbmFsaXphciBnaXQgaGVhZGVyICclLipzJyIKIAotIzogcmFuZ2UtZGlmZi5jOjI3NAorIzogcmFuZ2UtZGlmZi5jOjI3NQogbXNnaWQgImZhaWxlZCB0byBnZW5lcmF0ZSBkaWZmIgogbXNnc3RyICJmYWxsw7MgYWwgZ2VuZXJhciBkaWZmIgogCi0jOiByYW5nZS1kaWZmLmM6NTA2IHJhbmdlLWRpZmYuYzo1MDgKKyM6IHJhbmdlLWRpZmYuYzo1MDcgcmFuZ2UtZGlmZi5jOjUwOQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcGFyc2UgbG9nIGZvciAnJXMnIgogbXNnc3RyICJubyBzZSBwdWRvIGxlZXIgZWwgbG9nIHBhcmEgJyVzJyIKQEAgLTQ2MzMsMTEgKzQ2NjYsMTEgQEAKIG1zZ2lkICInJXMnIGFwcGVhcnMgYXMgYm90aCBhIGZpbGUgYW5kIGFzIGEgZGlyZWN0b3J5IgogbXNnc3RyICInJXMnIHBhcmVjZSBzZXIgdW4gZGlyZWN0b3JpbyB5IHVuIGFyY2hpdm8gYSBsYSB2ZXoiCiAKLSM6IHJlYWQtY2FjaGUuYzoxNDk5CisjOiByZWFkLWNhY2hlLmM6MTUyMAogbXNnaWQgIlJlZnJlc2ggaW5kZXgiCiBtc2dzdHIgIlJlZnJlc2NhciBpbmRleCIKIAotIzogcmVhZC1jYWNoZS5jOjE2MTMKKyM6IHJlYWQtY2FjaGUuYzoxNjM1CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJpbmRleC52ZXJzaW9uIHNldCwgYnV0IHRoZSB2YWx1ZSBpcyBpbnZhbGlkLlxuIgpAQCAtNDY0Niw3ICs0Njc5LDcgQEAKICJpbmRleC52ZXJzaW9uIGNvbmZpZ3VyYWRvLCBwZXJvIGVsIHZhbG9yIG5vIGVzIHbDoWxpZG8uXG4iCiAiVXNhbmRvIHZlcnNpw7NuICVpIgogCi0jOiByZWFkLWNhY2hlLmM6MTYyMworIzogcmVhZC1jYWNoZS5jOjE2NDUKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkdJVF9JTkRFWF9WRVJTSU9OIHNldCwgYnV0IHRoZSB2YWx1ZSBpcyBpbnZhbGlkLlxuIgpAQCAtNDY1NSwxMzggKzQ2ODgsMTM4IEBACiAiR0lUX0lOREVYX1ZFUlNJT04gY29uZmlndXJhZG8sIHBlcm8gZWwgdmFsb3Igbm8gZXMgdsOhbGlkby5cbiIKICJVc2FuZG8gdmVyc2nDs24gJWkiCiAKLSM6IHJlYWQtY2FjaGUuYzoxNjc5CisjOiByZWFkLWNhY2hlLmM6MTcwMQogIywgYy1mb3JtYXQKIG1zZ2lkICJiYWQgc2lnbmF0dXJlIDB4JTA4eCIKIG1zZ3N0ciAibWFsYSBmaXJtYSAweCUwOHgiCiAKLSM6IHJlYWQtY2FjaGUuYzoxNjgyCisjOiByZWFkLWNhY2hlLmM6MTcwNAogIywgYy1mb3JtYXQKIG1zZ2lkICJiYWQgaW5kZXggdmVyc2lvbiAlZCIKIG1zZ3N0ciAibWFsYSB2ZXJzacOzbiBkZWwgw61uZGljZSAlZCIKIAotIzogcmVhZC1jYWNoZS5jOjE2OTEKKyM6IHJlYWQtY2FjaGUuYzoxNzEzCiBtc2dpZCAiYmFkIGluZGV4IGZpbGUgc2hhMSBzaWduYXR1cmUiCiBtc2dzdHIgIm1hbGEgZmlybWEgc2hhMSBkZWwgYXJjaGl2byBpbmRleCIKIAotIzogcmVhZC1jYWNoZS5jOjE3MjEKKyM6IHJlYWQtY2FjaGUuYzoxNzQzCiAjLCBjLWZvcm1hdAogbXNnaWQgImluZGV4IHVzZXMgJS40cyBleHRlbnNpb24sIHdoaWNoIHdlIGRvIG5vdCB1bmRlcnN0YW5kIgogbXNnc3RyICJpbmRleCB1c2EgJS40cyBleHRlbnNpb25lcywgY29zYSBxdWUgbm8gZW50ZW5kZW1vcyIKIAotIzogcmVhZC1jYWNoZS5jOjE3MjMKKyM6IHJlYWQtY2FjaGUuYzoxNzQ1CiAjLCBjLWZvcm1hdAogbXNnaWQgImlnbm9yaW5nICUuNHMgZXh0ZW5zaW9uIgogbXNnc3RyICJpZ25vcmFuZG8gZXh0ZW5zacOzbiAlLjRzIgogCi0jOiByZWFkLWNhY2hlLmM6MTc2MAorIzogcmVhZC1jYWNoZS5jOjE3ODIKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5rbm93biBpbmRleCBlbnRyeSBmb3JtYXQgMHglMDh4IgogbXNnc3RyICJmb3JtYXRvIGRlIGluZGV4IGRlc2Nvbm9jaWRvIDB4JTA4eCIKIAotIzogcmVhZC1jYWNoZS5jOjE3NzYKKyM6IHJlYWQtY2FjaGUuYzoxNzk4CiAjLCBjLWZvcm1hdAogbXNnaWQgIm1hbGZvcm1lZCBuYW1lIGZpZWxkIGluIHRoZSBpbmRleCwgbmVhciBwYXRoICclcyciCiBtc2dzdHIgImNhbXBvIG5vbWJyZSBtYWxmb3JtYWRvIGVuIGVsIGluZGV4LCBjZXJjYSBhIHJ1dGEgJyVzJyIKIAotIzogcmVhZC1jYWNoZS5jOjE4MzMKKyM6IHJlYWQtY2FjaGUuYzoxODU1CiBtc2dpZCAidW5vcmRlcmVkIHN0YWdlIGVudHJpZXMgaW4gaW5kZXgiCiBtc2dzdHIgImVudHJhZGFzIGVuIHN0YWdlIGRlc29yZGVuYWRhcyBlbiBpbmRleCIKIAotIzogcmVhZC1jYWNoZS5jOjE4MzYKKyM6IHJlYWQtY2FjaGUuYzoxODU4CiAjLCBjLWZvcm1hdAogbXNnaWQgIm11bHRpcGxlIHN0YWdlIGVudHJpZXMgZm9yIG1lcmdlZCBmaWxlICclcyciCiBtc2dzdHIgIm3Dumx0aXBsZXMgZW50cmFkYXMgZXh0cmHDsWFzIHBhcmEgYXJjaGl2byBmdXNpb25hZG8gJyVzJyIKIAotIzogcmVhZC1jYWNoZS5jOjE4MzkKKyM6IHJlYWQtY2FjaGUuYzoxODYxCiAjLCBjLWZvcm1hdAogbXNnaWQgInVub3JkZXJlZCBzdGFnZSBlbnRyaWVzIGZvciAnJXMnIgogbXNnc3RyICJlbnRyYWRhcyBkZSBzdGFnZSBkZXNvcmRlbmFkYXMgcGFyYSAnJXMnIgogCi0jOiByZWFkLWNhY2hlLmM6MTk0NiByZWFkLWNhY2hlLmM6MjIzNCByZXJlcmUuYzo1NjUgcmVyZXJlLmM6NTk5IHJlcmVyZS5jOjExMTEKLSM6IGJ1aWx0aW4vYWRkLmM6NDYwIGJ1aWx0aW4vY2hlY2staWdub3JlLmM6MTc4IGJ1aWx0aW4vY2hlY2tvdXQuYzo0NjcKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo2NTEgYnVpbHRpbi9jbGVhbi5jOjk1NiBidWlsdGluL2NvbW1pdC5jOjM0NworIzogcmVhZC1jYWNoZS5jOjE5NjcgcmVhZC1jYWNoZS5jOjIyNTUgcmVyZXJlLmM6NTY1IHJlcmVyZS5jOjU5OSByZXJlcmUuYzoxMTExCisjOiBidWlsdGluL2FkZC5jOjQ2MCBidWlsdGluL2NoZWNrLWlnbm9yZS5jOjE3OCBidWlsdGluL2NoZWNrb3V0LmM6NDY4CisjOiBidWlsdGluL2NoZWNrb3V0LmM6NjUyIGJ1aWx0aW4vY2xlYW4uYzo5NjcgYnVpbHRpbi9jb21taXQuYzozNDcKICM6IGJ1aWx0aW4vZGlmZi10cmVlLmM6MTIwIGJ1aWx0aW4vZ3JlcC5jOjQ5OSBidWlsdGluL212LmM6MTQ1CiAjOiBidWlsdGluL3Jlc2V0LmM6MjQ1IGJ1aWx0aW4vcm0uYzoyNzEgYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjMzMAogbXNnaWQgImluZGV4IGZpbGUgY29ycnVwdCIKIG1zZ3N0ciAiYXJjaGl2byDDrW5kaWNlIGNvcnJvbXBpZG8iCiAKLSM6IHJlYWQtY2FjaGUuYzoyMDg3CisjOiByZWFkLWNhY2hlLmM6MjEwOAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gY3JlYXRlIGxvYWRfY2FjaGVfZW50cmllcyB0aHJlYWQ6ICVzIgogbXNnc3RyICJubyBlcyBwb3NpYmxlIGNyZWFyIGhpbG8gbG9hZF9jYWNoZV9lbnRyaWVzOiAlcyIKIAotIzogcmVhZC1jYWNoZS5jOjIxMDAKKyM6IHJlYWQtY2FjaGUuYzoyMTIxCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBqb2luIGxvYWRfY2FjaGVfZW50cmllcyB0aHJlYWQ6ICVzIgogbXNnc3RyICJubyBlcyBwb3NpYmxlIHVuaXIgaGlsbyBsb2FkX2NhY2hlX2VudGlyZXM6ICVzIgogCi0jOiByZWFkLWNhY2hlLmM6MjEzMworIzogcmVhZC1jYWNoZS5jOjIxNTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXM6IGluZGV4IGZpbGUgb3BlbiBmYWlsZWQiCiBtc2dzdHIgIiVzOiBmYWxsw7MgYWwgYWJyaXIgZWwgYXJjaGl2byBpbmRleCIKIAotIzogcmVhZC1jYWNoZS5jOjIxMzcKKyM6IHJlYWQtY2FjaGUuYzoyMTU4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiBjYW5ub3Qgc3RhdCB0aGUgb3BlbiBpbmRleCIKIG1zZ3N0ciAiJXM6IG5vIHNlIHB1ZWRlIGhhY2VyIHN0YXQgZGVsIGluZGV4IGFiaWVydG8iCiAKLSM6IHJlYWQtY2FjaGUuYzoyMTQxCisjOiByZWFkLWNhY2hlLmM6MjE2MgogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogaW5kZXggZmlsZSBzbWFsbGVyIHRoYW4gZXhwZWN0ZWQiCiBtc2dzdHIgIiVzOiBhcmNoaXZvIGluZGV4IG3DoXMgcGVxdWXDsW8gZGUgbG8gZXNwZXJhZG8iCiAKLSM6IHJlYWQtY2FjaGUuYzoyMTQ1CisjOiByZWFkLWNhY2hlLmM6MjE2NgogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogdW5hYmxlIHRvIG1hcCBpbmRleCBmaWxlIgogbXNnc3RyICIlczogbm8gc2UgcHVkbyBtYXBlYXIgZWwgYXJjaGl2byBpbmRleCIKIAotIzogcmVhZC1jYWNoZS5jOjIxODcKKyM6IHJlYWQtY2FjaGUuYzoyMjA4CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBjcmVhdGUgbG9hZF9pbmRleF9leHRlbnNpb25zIHRocmVhZDogJXMiCiBtc2dzdHIgIm5vIGVzIHBvc2libGUgY3JlYXIgaGlsbyBsb2FkX2luZGV4X2V4dGVuc2lvbnM6ICVzIgogCi0jOiByZWFkLWNhY2hlLmM6MjIxNAorIzogcmVhZC1jYWNoZS5jOjIyMzUKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGpvaW4gbG9hZF9pbmRleF9leHRlbnNpb25zIHRocmVhZDogJXMiCiBtc2dzdHIgIm5vIGVzIHBvc2libGUgdW5pciBoaWxvIGxvYWRfaW5kZXhfZXh0ZW5zaW9uczogJXMiCiAKLSM6IHJlYWQtY2FjaGUuYzoyMjQ2CisjOiByZWFkLWNhY2hlLmM6MjI2NwogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgZnJlc2hlbiBzaGFyZWQgaW5kZXggJyVzJyIKIG1zZ3N0ciAibm8gc2UgcHVkbyByZWZyZXNjYXIgZWwgaW5kZXggY29tcGFydGlkbyAnJXMnIgogCi0jOiByZWFkLWNhY2hlLmM6MjI5MworIzogcmVhZC1jYWNoZS5jOjIzMTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiYnJva2VuIGluZGV4LCBleHBlY3QgJXMgaW4gJXMsIGdvdCAlcyIKIG1zZ3N0ciAiaW5kZXggcm90bywgc2UgZXNwZXJhYmEgJXMgZW4gJXMsIHNlIG9idHV2byAlcyIKIAotIzogcmVhZC1jYWNoZS5jOjI5ODkgd3JhcHBlci5jOjY1OCBidWlsdGluL21lcmdlLmM6MTExNAorIzogcmVhZC1jYWNoZS5jOjMwMTAgd3JhcHBlci5jOjYyMiBidWlsdGluL21lcmdlLmM6MTExOQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgY2xvc2UgJyVzJyIKIG1zZ3N0ciAibm8gc2UgcHVkbyBjZXJyYXIgJyVzJyIKIAotIzogcmVhZC1jYWNoZS5jOjMwOTIgc2VxdWVuY2VyLmM6MjM1OCBzZXF1ZW5jZXIuYzozOTI4CisjOiByZWFkLWNhY2hlLmM6MzExMyBzZXF1ZW5jZXIuYzoyMjk2IHNlcXVlbmNlci5jOjM5MTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHN0YXQgJyVzJyIKIG1zZ3N0ciAibm8gc2UgcHVkbyBkZWZpbmlyICclcyciCiAKLSM6IHJlYWQtY2FjaGUuYzozMTA1CisjOiByZWFkLWNhY2hlLmM6MzEyNgogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gb3BlbiBnaXQgZGlyOiAlcyIKIG1zZ3N0ciAibm8gZXMgcG9zaWJsZSBhYnJpciBlbCBkaXJlY3RvcmlvIGRlIGdpdDogJXMiCiAKLSM6IHJlYWQtY2FjaGUuYzozMTE3CisjOiByZWFkLWNhY2hlLmM6MzEzOAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gdW5saW5rOiAlcyIKIG1zZ3N0ciAibm8gZXMgcG9zaWJsZSBlbGltaW5hciBlbCB2aW5jdWxvOiAlcyIKIAotIzogcmVhZC1jYWNoZS5jOjMxNDIKKyM6IHJlYWQtY2FjaGUuYzozMTYzCiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCBmaXggcGVybWlzc2lvbiBiaXRzIG9uICclcyciCiBtc2dzdHIgIm5vIHNlIHB1ZG8gYXJyZWdsYXIgYml0cyBkZSBwZXJtaXNvcyBlbiAnJXMnIgogCi0jOiByZWFkLWNhY2hlLmM6MzI5MQorIzogcmVhZC1jYWNoZS5jOjMzMTIKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXM6IGNhbm5vdCBkcm9wIHRvIHN0YWdlICMwIgogbXNnc3RyICIlczogbm8gc2UgcHVlZGUgZWxpbWluYXIgYSBzdGFnZSAjMCIKQEAgLTQ4NjEsNyArNDg5NCw3IEBACiAiSWYgeW91IHJlbW92ZSBhIGxpbmUgaGVyZSBUSEFUIENPTU1JVCBXSUxMIEJFIExPU1QuXG4iCiBtc2dzdHIgIiIKICJcbiIKLSJTaSByZW11ZXZlcyB1bmEgbMOtbmVhIGFxdcOtIEVMIENPTU1JVCBTRSBQRVJERVLDgS5cbiIKKyJTaSBlbGltaW5hcyB1bmEgbMOtbmVhIGFxdcOtIEVMIENPTU1JVCBTRSBQRVJERVLDgS5cbiIKIAogIzogcmViYXNlLWludGVyYWN0aXZlLmM6NzQgZ2l0LXJlYmFzZS0tcHJlc2VydmUtbWVyZ2VzLnNoOjg3MQogbXNnaWQgIiIKQEAgLTQ4OTEsOCArNDkyNCw4IEBACiBtc2dpZCAiTm90ZSB0aGF0IGVtcHR5IGNvbW1pdHMgYXJlIGNvbW1lbnRlZCBvdXQiCiBtc2dzdHIgIlRlbmdhIGVuIGN1ZW50YSBxdWUgbG9zIGNvbW1pdHMgdmFjw61vcyBlc3TDoW4gY29tZW50YWRvcyIKIAotIzogcmViYXNlLWludGVyYWN0aXZlLmM6MTA1IHJlcmVyZS5jOjQ4NSByZXJlcmUuYzo2OTIgc2VxdWVuY2VyLmM6MzQ0NwotIzogc2VxdWVuY2VyLmM6MzQ3MyBzZXF1ZW5jZXIuYzo1MTIwIGJ1aWx0aW4vZnNjay5jOjM1NiBidWlsdGluL3JlYmFzZS5jOjIzNQorIzogcmViYXNlLWludGVyYWN0aXZlLmM6MTA1IHJlcmVyZS5jOjQ4NSByZXJlcmUuYzo2OTIgc2VxdWVuY2VyLmM6MzM4OAorIzogc2VxdWVuY2VyLmM6MzQxNCBzZXF1ZW5jZXIuYzo1MDg0IGJ1aWx0aW4vZnNjay5jOjM1NiBidWlsdGluL3JlYmFzZS5jOjIzNQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3Qgd3JpdGUgJyVzJyIKIG1zZ3N0ciAibm8gc2UgcHVkbyBlc2NyaWJpciAnJXMnIgpAQCAtNDkzMiwxNCArNDk2NSwxNCBAQAogIzogcmVmcy5jOjI2MgogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyBkb2VzIG5vdCBwb2ludCB0byBhIHZhbGlkIG9iamVjdCEiCi1tc2dzdHIgIiVzIG5vIGFwdW50YSBhIG5pbmfDum4gb2JqZXRvIHbDoWxpZG8hIgorbXNnc3RyICLCoSVzIG5vIGFwdW50YSBhIG5pbmfDum4gb2JqZXRvIHbDoWxpZG8hIgogCiAjOiByZWZzLmM6NjY3CiAjLCBjLWZvcm1hdAogbXNnaWQgImlnbm9yaW5nIGRhbmdsaW5nIHN5bXJlZiAlcyIKIG1zZ3N0ciAiaWdub3JhbmRvIHJlZmVyZW5jaWEgcm90YSAlcyIKIAotIzogcmVmcy5jOjY2OSByZWYtZmlsdGVyLmM6MjA5MgorIzogcmVmcy5jOjY2OSByZWYtZmlsdGVyLmM6MjA5OAogIywgYy1mb3JtYXQKIG1zZ2lkICJpZ25vcmluZyBicm9rZW4gcmVmICVzIgogbXNnc3RyICJpZ25vcmFuZG8gcmVmZXJlbmNpYSByb3RhICVzIgpAQCAtNDk2NCwxNCArNDk5NywxNCBAQAogbXNnaWQgInVuZXhwZWN0ZWQgb2JqZWN0IElEIHdoZW4gd3JpdGluZyAnJXMnIgogbXNnc3RyICJJRCBkZSBvYmplY3RvIGluZXNwZXJhZG8gY3VhbmRvIHNlIGVzY3JpYsOtYSAnJXMnIgogCi0jOiByZWZzLmM6ODMzIHNlcXVlbmNlci5jOjQwMyBzZXF1ZW5jZXIuYzoyNzA5IHNlcXVlbmNlci5jOjI5MTMKLSM6IHNlcXVlbmNlci5jOjI5Mjcgc2VxdWVuY2VyLmM6MzE4NCBzZXF1ZW5jZXIuYzo1MDM3IHdyYXBwZXIuYzo2NTYKKyM6IHJlZnMuYzo4MzMgc2VxdWVuY2VyLmM6NDAzIHNlcXVlbmNlci5jOjI2NDcgc2VxdWVuY2VyLmM6Mjg1MQorIzogc2VxdWVuY2VyLmM6Mjg2NSBzZXF1ZW5jZXIuYzozMTIyIHNlcXVlbmNlci5jOjUwMDEgd3JhcHBlci5jOjYyMAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3Qgd3JpdGUgdG8gJyVzJyIKIG1zZ3N0ciAibm8gc2UgcHVkbyBlc2NyaWJpciBlbiAnJXMnIgogCi0jOiByZWZzLmM6ODYwIHdyYXBwZXIuYzoyMjUgd3JhcHBlci5jOjM5NSBidWlsdGluL2FtLmM6NzE1Ci0jOiBidWlsdGluL3JlYmFzZS5jOjEwMDMKKyM6IHJlZnMuYzo4NjAgd3JhcHBlci5jOjE4OCB3cmFwcGVyLmM6MzU4IGJ1aWx0aW4vYW0uYzo3MTQKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTAwNAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3Qgb3BlbiAnJXMnIGZvciB3cml0aW5nIgogbXNnc3RyICJubyBzZSBwdWRvIGFicmlyICclcycgcGFyYSBlc2NyaXR1cmEiCkBAIC01MDA2LDIxICs1MDM5LDIxIEBACiBtc2dpZCAidXBkYXRlX3JlZiBmYWlsZWQgZm9yIHJlZiAnJXMnOiAlcyIKIG1zZ3N0ciAidXBkYXRlX3JlZiBmYWxsw7MgcGFyYSByZWYgJyVzJzogJXMiCiAKLSM6IHJlZnMuYzoyMDEyCisjOiByZWZzLmM6MjAyMwogIywgYy1mb3JtYXQKIG1zZ2lkICJtdWx0aXBsZSB1cGRhdGVzIGZvciByZWYgJyVzJyBub3QgYWxsb3dlZCIKIG1zZ3N0ciAibcO6bHRpcGxlcyBhY3R1YWxpemFjaW9uZXMgcGFyYSByZWYgJyVzJyBubyBwZXJtaXRpZGFzIgogCi0jOiByZWZzLmM6MjA0NAorIzogcmVmcy5jOjIwNTUKIG1zZ2lkICJyZWYgdXBkYXRlcyBmb3JiaWRkZW4gaW5zaWRlIHF1YXJhbnRpbmUgZW52aXJvbm1lbnQiCiBtc2dzdHIgImFjdHVhbGl6YWNpb25lcyBkZSByZWYgcHJvaGliaWRhcyBkZW50cm8gZGUgYW1iaWVudGUgZGUgY3VhcmVudGVuYSIKIAotIzogcmVmcy5jOjIxNDAgcmVmcy5jOjIxNzAKKyM6IHJlZnMuYzoyMTUxIHJlZnMuYzoyMTgxCiAjLCBjLWZvcm1hdAogbXNnaWQgIiclcycgZXhpc3RzOyBjYW5ub3QgY3JlYXRlICclcyciCiBtc2dzdHIgIiclcycgZXhpc3RlOyBubyBzZSBwdWVkZSBjcmVhciAnJXMnIgogCi0jOiByZWZzLmM6MjE0NiByZWZzLmM6MjE4MQorIzogcmVmcy5jOjIxNTcgcmVmcy5jOjIxOTIKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IHByb2Nlc3MgJyVzJyBhbmQgJyVzJyBhdCB0aGUgc2FtZSB0aW1lIgogbXNnc3RyICJubyBzZSBwdWVkZSBwcm9jZXNhciAnJXMnIHkgJyVzJyBhbCBtaXNtbyB0aWVtcG8iCkBAIC01MDMwLDEzICs1MDYzLDEzIEBACiBtc2dpZCAiY291bGQgbm90IHJlbW92ZSByZWZlcmVuY2UgJXMiCiBtc2dzdHIgIm5vIHNlIHB1ZG8gZWxpbWluYXIgbGEgcmVmZXJlbmNpYSAlcyIKIAotIzogcmVmcy9maWxlcy1iYWNrZW5kLmM6MTI0OCByZWZzL3BhY2tlZC1iYWNrZW5kLmM6MTUzMgotIzogcmVmcy9wYWNrZWQtYmFja2VuZC5jOjE1NDIKKyM6IHJlZnMvZmlsZXMtYmFja2VuZC5jOjEyNDggcmVmcy9wYWNrZWQtYmFja2VuZC5jOjE1NDEKKyM6IHJlZnMvcGFja2VkLWJhY2tlbmQuYzoxNTUxCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBkZWxldGUgcmVmZXJlbmNlICVzOiAlcyIKIG1zZ3N0ciAibm8gc2UgcHVkbyBlbGltaW5hciBsYSByZWZlcmVuY2lhICVzOiAlcyIKIAotIzogcmVmcy9maWxlcy1iYWNrZW5kLmM6MTI1MSByZWZzL3BhY2tlZC1iYWNrZW5kLmM6MTU0NQorIzogcmVmcy9maWxlcy1iYWNrZW5kLmM6MTI1MSByZWZzL3BhY2tlZC1iYWNrZW5kLmM6MTU1NAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgZGVsZXRlIHJlZmVyZW5jZXM6ICVzIgogbXNnc3RyICJubyBzZSBwdWRvIGVsaW1pbmFyIGxhIHJlZmVyZW5jaWE6ICVzIgpAQCAtNTA0Niw3ICs1MDc5LDcgQEAKIG1zZ2lkICJpbnZhbGlkIHJlZnNwZWMgJyVzJyIKIG1zZ3N0ciAicmVmc3BlYyBpbnbDoWxpZG86ICclcyciCiAKLSM6IHJlZi1maWx0ZXIuYzo0MiB3dC1zdGF0dXMuYzoxOTM0CisjOiByZWYtZmlsdGVyLmM6NDIgd3Qtc3RhdHVzLmM6MTkzOAogbXNnaWQgImdvbmUiCiBtc2dzdHIgImRlc2FwYXJlY2lkbyIKIApAQCAtNTA2NSwyODEgKzUwOTgsMjgxIEBACiBtc2dpZCAiYWhlYWQgJWQsIGJlaGluZCAlZCIKIG1zZ3N0ciAiZGVsYW50ZSAlZCwgZGV0csOhcyAlZCIKIAotIzogcmVmLWZpbHRlci5jOjE2MgorIzogcmVmLWZpbHRlci5jOjE2NQogIywgYy1mb3JtYXQKIG1zZ2lkICJleHBlY3RlZCBmb3JtYXQ6ICUlKGNvbG9yOjxjb2xvcj4pIgogbXNnc3RyICJmb3JtYXRvIGVzcGVyYWRvOiAlJShjb2xvcjo8Y29sb3I+KSIKIAotIzogcmVmLWZpbHRlci5jOjE2NAorIzogcmVmLWZpbHRlci5jOjE2NwogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bnJlY29nbml6ZWQgY29sb3I6ICUlKGNvbG9yOiVzKSIKIG1zZ3N0ciAiY29sb3Igbm8gcmVjb25vY2lkbzogJSUoY29sb3I6JXMpIgogCi0jOiByZWYtZmlsdGVyLmM6MTg2CisjOiByZWYtZmlsdGVyLmM6MTg5CiAjLCBjLWZvcm1hdAogbXNnaWQgIkludGVnZXIgdmFsdWUgZXhwZWN0ZWQgcmVmbmFtZTpsc3RyaXA9JXMiCiBtc2dzdHIgIlZhbG9yIGVudGVybyBlc3BlcmFkbyByZWZuYW1lOmxzdHJpcD0lcyIKIAotIzogcmVmLWZpbHRlci5jOjE5MAorIzogcmVmLWZpbHRlci5jOjE5MwogIywgYy1mb3JtYXQKIG1zZ2lkICJJbnRlZ2VyIHZhbHVlIGV4cGVjdGVkIHJlZm5hbWU6cnN0cmlwPSVzIgogbXNnc3RyICJWYWxvciBlbnRlcm8gZXNwZXJhZG8gcmVmbmFtZTpyc3RyaXA9JXMiCiAKLSM6IHJlZi1maWx0ZXIuYzoxOTIKKyM6IHJlZi1maWx0ZXIuYzoxOTUKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5yZWNvZ25pemVkICUlKCVzKSBhcmd1bWVudDogJXMiCiBtc2dzdHIgImFyZ3VtZW50bzogJXMgbm8gcmVjb25vY2lkbyAlJSglcykiCiAKLSM6IHJlZi1maWx0ZXIuYzoyNDcKKyM6IHJlZi1maWx0ZXIuYzoyNTAKICMsIGMtZm9ybWF0CiBtc2dpZCAiJSUob2JqZWN0dHlwZSkgZG9lcyBub3QgdGFrZSBhcmd1bWVudHMiCiBtc2dzdHIgIiUlKG9iamVjdHR5cGUpIG5vIHRvbWEgbmluZ8O6biBhcmd1bWVudG8iCiAKLSM6IHJlZi1maWx0ZXIuYzoyNjkKKyM6IHJlZi1maWx0ZXIuYzoyNzIKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5yZWNvZ25pemVkICUlKG9iamVjdHNpemUpIGFyZ3VtZW50OiAlcyIKIG1zZ3N0ciAiJSUob2JqZWN0c2l6ZSkgbm8gcmVjb25vY2lkbyBhcmd1bWVudG86ICVzIgogCi0jOiByZWYtZmlsdGVyLmM6Mjc3CisjOiByZWYtZmlsdGVyLmM6MjgwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiUlKGRlbHRhYmFzZSkgZG9lcyBub3QgdGFrZSBhcmd1bWVudHMiCiBtc2dzdHIgIiUlKGRlbHRhYmFzZSkgbm8gdG9tYSBhcmd1bWVudG9zIgogCi0jOiByZWYtZmlsdGVyLmM6Mjg5CisjOiByZWYtZmlsdGVyLmM6MjkyCiAjLCBjLWZvcm1hdAogbXNnaWQgIiUlKGJvZHkpIGRvZXMgbm90IHRha2UgYXJndW1lbnRzIgogbXNnc3RyICIlJShib2R5KSBubyB0b21hIG5pbmfDum4gYXJndW1lbnRvIgogCi0jOiByZWYtZmlsdGVyLmM6Mjk4CisjOiByZWYtZmlsdGVyLmM6MzAxCiAjLCBjLWZvcm1hdAogbXNnaWQgIiUlKHN1YmplY3QpIGRvZXMgbm90IHRha2UgYXJndW1lbnRzIgogbXNnc3RyICIlJShzdWJqZWN0KSBubyB0b21hIG5pbmfDum4gYXJndW1lbnRvIgogCi0jOiByZWYtZmlsdGVyLmM6MzIwCisjOiByZWYtZmlsdGVyLmM6MzIzCiAjLCBjLWZvcm1hdAogbXNnaWQgInVua25vd24gJSUodHJhaWxlcnMpIGFyZ3VtZW50OiAlcyIKIG1zZ3N0ciAiJSUodHJhaWxlcnMpIGRlc2Nvbm9jaWRvcywgYXJndW1lbnRvOiAlcyIKIAotIzogcmVmLWZpbHRlci5jOjM0OQorIzogcmVmLWZpbHRlci5jOjM1MgogIywgYy1mb3JtYXQKIG1zZ2lkICJwb3NpdGl2ZSB2YWx1ZSBleHBlY3RlZCBjb250ZW50czpsaW5lcz0lcyIKIG1zZ3N0ciAidmFsb3IgcG9zaXRpdm8gZXNwZXJhZG8gY29udGVudHM6bGluZXM9JXMiCiAKLSM6IHJlZi1maWx0ZXIuYzozNTEKKyM6IHJlZi1maWx0ZXIuYzozNTQKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5yZWNvZ25pemVkICUlKGNvbnRlbnRzKSBhcmd1bWVudDogJXMiCiBtc2dzdHIgImFyZ3VtZW50byAlcyBubyByZWNvbm9jaWRvICUlKGNvbnRlbnRzKSIKIAotIzogcmVmLWZpbHRlci5jOjM2NgorIzogcmVmLWZpbHRlci5jOjM2OQogIywgYy1mb3JtYXQKIG1zZ2lkICJwb3NpdGl2ZSB2YWx1ZSBleHBlY3RlZCBvYmplY3RuYW1lOnNob3J0PSVzIgogbXNnc3RyICJ2YWxvciBwb3NpdGl2byBlc3BlcmFkbyBvYmplY3RuYW1lOnNob3J0PSVzIgogCi0jOiByZWYtZmlsdGVyLmM6MzcwCisjOiByZWYtZmlsdGVyLmM6MzczCiAjLCBjLWZvcm1hdAogbXNnaWQgInVucmVjb2duaXplZCAlJShvYmplY3RuYW1lKSBhcmd1bWVudDogJXMiCiBtc2dzdHIgImFyZ3VtZW50bzogJXMgbm8gcmVjb25vY2lkbyAlJShvYmplY3RuYW1lKSIKIAotIzogcmVmLWZpbHRlci5jOjQwMAorIzogcmVmLWZpbHRlci5jOjQwMwogIywgYy1mb3JtYXQKIG1zZ2lkICJleHBlY3RlZCBmb3JtYXQ6ICUlKGFsaWduOjx3aWR0aD4sPHBvc2l0aW9uPikiCiBtc2dzdHIgImZvcm1hdG8gZXNwZXJhZG86ICUlKGFsaWduOjxhbmNobz4sPHBvc2ljacOzbj4pIgogCi0jOiByZWYtZmlsdGVyLmM6NDEyCisjOiByZWYtZmlsdGVyLmM6NDE1CiAjLCBjLWZvcm1hdAogbXNnaWQgInVucmVjb2duaXplZCBwb3NpdGlvbjolcyIKIG1zZ3N0ciAicG9zaWNpw7NuIGRlc2Nvbm9jaWRhOiAlcyIKIAotIzogcmVmLWZpbHRlci5jOjQxOQorIzogcmVmLWZpbHRlci5jOjQyMgogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bnJlY29nbml6ZWQgd2lkdGg6JXMiCiBtc2dzdHIgImFuY2hvIGRlc2Nvbm9jaWRvOiAlcyIKIAotIzogcmVmLWZpbHRlci5jOjQyOAorIzogcmVmLWZpbHRlci5jOjQzMQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bnJlY29nbml6ZWQgJSUoYWxpZ24pIGFyZ3VtZW50OiAlcyIKIG1zZ3N0ciAiYXJndW1lbnRvIG5vIHJlY29ub2NpZG8gcGFyYSAlJShhbGlnbik6ICVzIgogCi0jOiByZWYtZmlsdGVyLmM6NDM2CisjOiByZWYtZmlsdGVyLmM6NDM5CiAjLCBjLWZvcm1hdAogbXNnaWQgInBvc2l0aXZlIHdpZHRoIGV4cGVjdGVkIHdpdGggdGhlICUlKGFsaWduKSBhdG9tIgogbXNnc3RyICJzZSBlc3BlcmFiYSB1biBhbmNobyBwb3NpdGl2byBjb24gZWwgw6F0b21vICUlKGFsaWduKSIKIAotIzogcmVmLWZpbHRlci5jOjQ1NAorIzogcmVmLWZpbHRlci5jOjQ1NwogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bnJlY29nbml6ZWQgJSUoaWYpIGFyZ3VtZW50OiAlcyIKIG1zZ3N0ciAiYXJndW1lbnRvOiAlcyBubyByZWNvbm9jaWRvICUlKGlmKSIKIAotIzogcmVmLWZpbHRlci5jOjU1NgorIzogcmVmLWZpbHRlci5jOjU1OQogIywgYy1mb3JtYXQKIG1zZ2lkICJtYWxmb3JtZWQgZmllbGQgbmFtZTogJS4qcyIKIG1zZ3N0ciAibm9tYnJlIG1hbCBmb3JtYWRvIGRlIGNhbXBvOiAlLipzIgogCi0jOiByZWYtZmlsdGVyLmM6NTgzCisjOiByZWYtZmlsdGVyLmM6NTg2CiAjLCBjLWZvcm1hdAogbXNnaWQgInVua25vd24gZmllbGQgbmFtZTogJS4qcyIKIG1zZ3N0ciAibm9tYnJlIGRlIGNhbXBvIGRlc2Nvbm9jaWRvOiAlLipzIgogCi0jOiByZWYtZmlsdGVyLmM6NTg3CisjOiByZWYtZmlsdGVyLmM6NTkwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJub3QgYSBnaXQgcmVwb3NpdG9yeSwgYnV0IHRoZSBmaWVsZCAnJS4qcycgcmVxdWlyZXMgYWNjZXNzIHRvIG9iamVjdCBkYXRhIgogbXNnc3RyICIiCiAibm8gZXMgdW4gcmVwb3NpdG9yaW8gZ2l0LCBwZXJvIGVsIGNhbXBvICclLipzJyByZXF1aWVyZSBhY2Nlc28gYWwgb2JqZXRvIGRhdGEiCiAKLSM6IHJlZi1maWx0ZXIuYzo3MTEKKyM6IHJlZi1maWx0ZXIuYzo3MTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiZm9ybWF0OiAlJShpZikgYXRvbSB1c2VkIHdpdGhvdXQgYSAlJSh0aGVuKSBhdG9tIgogbXNnc3RyICJmb3JtYXRvOiDDoXRvbW8gJSUoaWYpIHVzYWRvIHNpbiB1biDDoXRvbW8gJSUodGhlbikiCiAKLSM6IHJlZi1maWx0ZXIuYzo3NzQKKyM6IHJlZi1maWx0ZXIuYzo3NzcKICMsIGMtZm9ybWF0CiBtc2dpZCAiZm9ybWF0OiAlJSh0aGVuKSBhdG9tIHVzZWQgd2l0aG91dCBhbiAlJShpZikgYXRvbSIKIG1zZ3N0ciAiZm9ybWF0bzogw6F0b21vICUlKHRoZW4pIHVzYWRvIHNpbiDDoXRvbW8gJSUoaWYpIgogCi0jOiByZWYtZmlsdGVyLmM6Nzc2CisjOiByZWYtZmlsdGVyLmM6Nzc5CiAjLCBjLWZvcm1hdAogbXNnaWQgImZvcm1hdDogJSUodGhlbikgYXRvbSB1c2VkIG1vcmUgdGhhbiBvbmNlIgogbXNnc3RyICJmb3JtYXRvOiDDoXRvbW8gJSUodGhlbikgdXNhZG8gbcOhcyBkZSB1bmEgdmV6IgogCi0jOiByZWYtZmlsdGVyLmM6Nzc4CisjOiByZWYtZmlsdGVyLmM6NzgxCiAjLCBjLWZvcm1hdAogbXNnaWQgImZvcm1hdDogJSUodGhlbikgYXRvbSB1c2VkIGFmdGVyICUlKGVsc2UpIgogbXNnc3RyICJmb3JtYXRvOiDDoXRvbW8gJSUodGhlbikgdXNhZG8gZGVzcHXDqXMgZGUgJSUoZWxzZSkiCiAKLSM6IHJlZi1maWx0ZXIuYzo4MDYKKyM6IHJlZi1maWx0ZXIuYzo4MDkKICMsIGMtZm9ybWF0CiBtc2dpZCAiZm9ybWF0OiAlJShlbHNlKSBhdG9tIHVzZWQgd2l0aG91dCBhbiAlJShpZikgYXRvbSIKIG1zZ3N0ciAiZm9ybWF0bzogw6F0b21vICUlKGVsc2UpIHVzYWRvIHNpbiB1biDDoXRvbW8gJSUoaWYpIgogCi0jOiByZWYtZmlsdGVyLmM6ODA4CisjOiByZWYtZmlsdGVyLmM6ODExCiAjLCBjLWZvcm1hdAogbXNnaWQgImZvcm1hdDogJSUoZWxzZSkgYXRvbSB1c2VkIHdpdGhvdXQgYSAlJSh0aGVuKSBhdG9tIgogbXNnc3RyICJmb3JtYXRvOiDDoXRvbW8gJSUoZWxzZSkgdXNhZG8gc2luIHVuIMOhdG9tbyAlJSh0aGVuKSIKIAotIzogcmVmLWZpbHRlci5jOjgxMAorIzogcmVmLWZpbHRlci5jOjgxMwogIywgYy1mb3JtYXQKIG1zZ2lkICJmb3JtYXQ6ICUlKGVsc2UpIGF0b20gdXNlZCBtb3JlIHRoYW4gb25jZSIKIG1zZ3N0ciAiZm9ybWF0bzogw6F0b21vICUlKGVsc2UpIHVzYWRvIG3DoXMgZGUgdW5hIHZleiIKIAotIzogcmVmLWZpbHRlci5jOjgyNQorIzogcmVmLWZpbHRlci5jOjgyOAogIywgYy1mb3JtYXQKIG1zZ2lkICJmb3JtYXQ6ICUlKGVuZCkgYXRvbSB1c2VkIHdpdGhvdXQgY29ycmVzcG9uZGluZyBhdG9tIgogbXNnc3RyICJmb3JtYXRvOiDDoXRvbW8gJSUoZW5kKSB1c2FkbyBzaW4gw6F0b21vIGNvcnJlc3BvbmRpZW50ZSIKIAotIzogcmVmLWZpbHRlci5jOjg4MgorIzogcmVmLWZpbHRlci5jOjg4NQogIywgYy1mb3JtYXQKIG1zZ2lkICJtYWxmb3JtZWQgZm9ybWF0IHN0cmluZyAlcyIKIG1zZ3N0ciAiZm9ybWF0byBkZSBjYWRlbmEgbWFsIGZvcm1hZG8gJXMiCiAKLSM6IHJlZi1maWx0ZXIuYzoxNDg1CisjOiByZWYtZmlsdGVyLmM6MTQ4OAogIywgYy1mb3JtYXQKIG1zZ2lkICJubyBicmFuY2gsIHJlYmFzaW5nICVzIgogbXNnc3RyICJubyBoYXkgcmFtYSwgcmViYXNhbmRvICVzIgogCi0jOiByZWYtZmlsdGVyLmM6MTQ4OAorIzogcmVmLWZpbHRlci5jOjE0OTEKICMsIGMtZm9ybWF0CiBtc2dpZCAibm8gYnJhbmNoLCByZWJhc2luZyBkZXRhY2hlZCBIRUFEICVzIgogbXNnc3RyICIobyBoYXkgcmFtYSwgcmViYXNhbmRvIGNvbiBIRUFEIGRlc2Fjb3BsYWRvICVzIgogCi0jOiByZWYtZmlsdGVyLmM6MTQ5MQorIzogcmVmLWZpbHRlci5jOjE0OTQKICMsIGMtZm9ybWF0CiBtc2dpZCAibm8gYnJhbmNoLCBiaXNlY3Qgc3RhcnRlZCBvbiAlcyIKIG1zZ3N0ciAibm8gaGF5IHJhbWEsIGNvbWVuemFuZG8gYmlzZWNjw7NuIGVuICAlcyIKIAotIzogcmVmLWZpbHRlci5jOjE1MDEKKyM6IHJlZi1maWx0ZXIuYzoxNTA0CiBtc2dpZCAibm8gYnJhbmNoIgogbXNnc3RyICJzaW4gcmFtYSIKIAotIzogcmVmLWZpbHRlci5jOjE1MzcgcmVmLWZpbHRlci5jOjE3NDMKKyM6IHJlZi1maWx0ZXIuYzoxNTQwIHJlZi1maWx0ZXIuYzoxNzQ5CiAjLCBjLWZvcm1hdAogbXNnaWQgIm1pc3Npbmcgb2JqZWN0ICVzIGZvciAlcyIKIG1zZ3N0ciAiZmFsdGEgb2JqZXRvICVzIHBhcmEgJXMiCiAKLSM6IHJlZi1maWx0ZXIuYzoxNTQ3CisjOiByZWYtZmlsdGVyLmM6MTU1MAogIywgYy1mb3JtYXQKIG1zZ2lkICJwYXJzZV9vYmplY3RfYnVmZmVyIGZhaWxlZCBvbiAlcyBmb3IgJXMiCiBtc2dzdHIgInBhcnNlX29iamVjdF9idWZmZXIgZmFsbMOzIGVuICVzIHBhcmEgJXMiCiAKLSM6IHJlZi1maWx0ZXIuYzoxOTk4CisjOiByZWYtZmlsdGVyLmM6MjAwNAogIywgYy1mb3JtYXQKIG1zZ2lkICJtYWxmb3JtZWQgb2JqZWN0IGF0ICclcyciCiBtc2dzdHIgIm9iamV0byBtYWwgZm9ybWFkbyBlbiAnJXMnIgogCi0jOiByZWYtZmlsdGVyLmM6MjA4NworIzogcmVmLWZpbHRlci5jOjIwOTMKICMsIGMtZm9ybWF0CiBtc2dpZCAiaWdub3JpbmcgcmVmIHdpdGggYnJva2VuIG5hbWUgJXMiCiBtc2dzdHIgImlnbm9yYW5kbyByZWZlcmVuY2lhIGNvbiBub21icmUgcm90byAlcyIKIAotIzogcmVmLWZpbHRlci5jOjIzODIKKyM6IHJlZi1maWx0ZXIuYzoyMzg5CiAjLCBjLWZvcm1hdAogbXNnaWQgImZvcm1hdDogJSUoZW5kKSBhdG9tIG1pc3NpbmciCiBtc2dzdHIgImZvcm1hdG86IGZhbHRhIMOhdG9tbyAlJShlbmQpIgogCi0jOiByZWYtZmlsdGVyLmM6MjQ4MgorIzogcmVmLWZpbHRlci5jOjI0ODkKICMsIGMtZm9ybWF0CiBtc2dpZCAib3B0aW9uIGAlcycgaXMgaW5jb21wYXRpYmxlIHdpdGggLS1tZXJnZWQiCiBtc2dzdHIgIm9wY2nDs24gYCVzJyBlcyBpbmNvbXBhdGlibGUgY29uIC0tbWVyZ2VkIgogCi0jOiByZWYtZmlsdGVyLmM6MjQ4NQorIzogcmVmLWZpbHRlci5jOjI0OTIKICMsIGMtZm9ybWF0CiBtc2dpZCAib3B0aW9uIGAlcycgaXMgaW5jb21wYXRpYmxlIHdpdGggLS1uby1tZXJnZWQiCiBtc2dzdHIgIm9wY2nDs24gYCVzJyBlcyBpbmNvbXBhdGlibGUgY29uIC0tbm8tbWVyZ2VkIgogCi0jOiByZWYtZmlsdGVyLmM6MjQ5NQorIzogcmVmLWZpbHRlci5jOjI1MDIKICMsIGMtZm9ybWF0CiBtc2dpZCAibWFsZm9ybWVkIG9iamVjdCBuYW1lICVzIgogbXNnc3RyICJub21icmUgZGUgb2JqZXRvIG1hbCBmb3JtYWRvICVzIgogCi0jOiByZWYtZmlsdGVyLmM6MjUwMAorIzogcmVmLWZpbHRlci5jOjI1MDcKICMsIGMtZm9ybWF0CiBtc2dpZCAib3B0aW9uIGAlcycgbXVzdCBwb2ludCB0byBhIGNvbW1pdCIKIG1zZ3N0ciAib3BjacOzbiAnJXMnIGRlYmUgYXB1bnRhciBhIHVuIGNvbW1pdCIKIAotIzogcmVtb3RlLmM6MzYzCisjOiByZW1vdGUuYzozNjYKICMsIGMtZm9ybWF0CiBtc2dpZCAiY29uZmlnIHJlbW90ZSBzaG9ydGhhbmQgY2Fubm90IGJlZ2luIHdpdGggJy8nOiAlcyIKIG1zZ3N0ciAiY29uZmlnIHJlbW90ZSBzaG9ydGhhbmQgbm8gcHVlZGUgY29tZW56YXIgY29uICcvJzogJXMiCiAKLSM6IHJlbW90ZS5jOjQxMAorIzogcmVtb3RlLmM6NDEzCiBtc2dpZCAibW9yZSB0aGFuIG9uZSByZWNlaXZlcGFjayBnaXZlbiwgdXNpbmcgdGhlIGZpcnN0IgogbXNnc3RyICJtw6FzIGRlIHVuIHJlY2VpdmVwYWNrIGRhZG8sIHVzYW5kbyBlbCBwcmltZXJvIgogCi0jOiByZW1vdGUuYzo0MTgKKyM6IHJlbW90ZS5jOjQyMQogbXNnaWQgIm1vcmUgdGhhbiBvbmUgdXBsb2FkcGFjayBnaXZlbiwgdXNpbmcgdGhlIGZpcnN0IgogbXNnc3RyICJtw6FzIGRlIHVuIHVwbG9hZHBhY2sgZGFkbywgdXNhbmRvIGVsIHByaW1lcm8iCiAKLSM6IHJlbW90ZS5jOjYwOAorIzogcmVtb3RlLmM6NjExCiAjLCBjLWZvcm1hdAogbXNnaWQgIkNhbm5vdCBmZXRjaCBib3RoICVzIGFuZCAlcyB0byAlcyIKIG1zZ3N0ciAiTm8gc2UgcHVlZGVuIHRyYWVyIGFtYm9zICVzIHkgJXMgYSAlcyIKIAotIzogcmVtb3RlLmM6NjEyCisjOiByZW1vdGUuYzo2MTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgdXN1YWxseSB0cmFja3MgJXMsIG5vdCAlcyIKIG1zZ3N0ciAiJXMgcG9yIGxvIGdlbmVyYWwgaGFjZSBzZWd1aW1pZW50byBhICVzLCBubyBhICVzIgogCi0jOiByZW1vdGUuYzo2MTYKKyM6IHJlbW90ZS5jOjYxOQogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyB0cmFja3MgYm90aCAlcyBhbmQgJXMiCiBtc2dzdHIgIiVzIGhhY2Ugc2VndWltaWVudG8gdGFudG8gYSAlcyBjb21vIGEgJXMiCiAKLSM6IHJlbW90ZS5jOjY4NAorIzogcmVtb3RlLmM6Njg3CiAjLCBjLWZvcm1hdAogbXNnaWQgImtleSAnJXMnIG9mIHBhdHRlcm4gaGFkIG5vICcqJyIKIG1zZ3N0ciAibGxhdmUgJyVzJyBkZSBwYXRyw7NuIG5vIHR1dm8gJyonIgogCi0jOiByZW1vdGUuYzo2OTQKKyM6IHJlbW90ZS5jOjY5NwogIywgYy1mb3JtYXQKIG1zZ2lkICJ2YWx1ZSAnJXMnIG9mIHBhdHRlcm4gaGFzIG5vICcqJyIKIG1zZ3N0ciAidmFsb3IgJyVzJyBkZWwgcGF0csOzbiBubyB0aWVuZSAnKiciCiAKLSM6IHJlbW90ZS5jOjEwMDAKKyM6IHJlbW90ZS5jOjEwMDMKICMsIGMtZm9ybWF0CiBtc2dpZCAic3JjIHJlZnNwZWMgJXMgZG9lcyBub3QgbWF0Y2ggYW55IgogbXNnc3RyICJzcmMgcmVmc29lYyAlczogbm8gY29uY3VlcmRhIGNvbiBuaW5ndW5vIgogCi0jOiByZW1vdGUuYzoxMDA1CisjOiByZW1vdGUuYzoxMDA4CiAjLCBjLWZvcm1hdAogbXNnaWQgInNyYyByZWZzcGVjICVzIG1hdGNoZXMgbW9yZSB0aGFuIG9uZSIKIG1zZ3N0ciAic3JjIHJlZnNwZWMgJXMgY29uY3VlcmRhIGNvbiBtw6FzIGRlIHVubyIKQEAgLTUzNDgsNyArNTM4MSw3IEBACiAjLiA8cmVtb3RlPiA8c3JjPjo8ZHN0PiIgcHVzaCwgYW5kICJiZWluZyBwdXNoZWQgKCclcycpIiBpcwogIy4gdGhlIDxzcmM+LgogIy4KLSM6IHJlbW90ZS5jOjEwMjAKKyM6IHJlbW90ZS5jOjEwMjMKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlRoZSBkZXN0aW5hdGlvbiB5b3UgcHJvdmlkZWQgaXMgbm90IGEgZnVsbCByZWZuYW1lIChpLmUuLFxuIgpAQCAtNTM3Miw3ICs1NDA1LDcgQEAKICJOaW5ndW5vIGZ1bmNpb27DsyBhc8OtIHF1ZSBub3MgZGltb3MgcG9yIHZlbmNpZG9zLiBUaWVuZXMgcXVlIGVzcGVjaWZpY2FyIGVsICIKICJmdWxsIHJlZi4iCiAKLSM6IHJlbW90ZS5jOjEwNDAKKyM6IHJlbW90ZS5jOjEwNDMKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlRoZSA8c3JjPiBwYXJ0IG9mIHRoZSByZWZzcGVjIGlzIGEgY29tbWl0IG9iamVjdC5cbiIKQEAgLTUzODMsNyArNTQxNiw3IEBACiAiwr9RdWlzaXN0ZSBjcmVhciB1biBicmFuY2ggbnVldm8gbWVkaWFudGUgdW4gcHVzaCBhXG4iCiAiJyVzOnJlZnMvaGVhZHMvJXMnPyIKIAotIzogcmVtb3RlLmM6MTA0NQorIzogcmVtb3RlLmM6MTA0OAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiVGhlIDxzcmM+IHBhcnQgb2YgdGhlIHJlZnNwZWMgaXMgYSB0YWcgb2JqZWN0LlxuIgpAQCAtNTM5NCw3ICs1NDI3LDcgQEAKICJEaWQgeW91IG1lYW4gdG8gY3JlYXRlIGEgbmV3IHRhZyBieSBwdXNoaW5nIHRvXG4iCiAiJyVzOnJlZnMvdGFncy8lcyc/IgogCi0jOiByZW1vdGUuYzoxMDUwCisjOiByZW1vdGUuYzoxMDUzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgPHNyYz4gcGFydCBvZiB0aGUgcmVmc3BlYyBpcyBhIHRyZWUgb2JqZWN0LlxuIgpAQCAtNTQwNSw3ICs1NDM4LDcgQEAKICLCv1F1aXNpc3RlIGNyZWFyIHVuIHRhZyBudWV2byBtZWRpYW50ZSB1biBwdXNoIGFcbiIKICInJXM6cmVmcy9oZWFkcy8lcyc/IgogCi0jOiByZW1vdGUuYzoxMDU1CisjOiByZW1vdGUuYzoxMDU4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgPHNyYz4gcGFydCBvZiB0aGUgcmVmc3BlYyBpcyBhIGJsb2Igb2JqZWN0LlxuIgpAQCAtNTQxNiwxMTUgKzU0NDksMTE1IEBACiAiwr9RdWlzaXN0ZSBjcmVhciB1biB0YWcgbnVldm8gbWVkaWFudGUgdW4gcHVzaCBhXG4iCiAiJyVzOnJlZnMvaGVhZHMvJXMnPyIKIAotIzogcmVtb3RlLmM6MTA5MQorIzogcmVtb3RlLmM6MTA5NAogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyBjYW5ub3QgYmUgcmVzb2x2ZWQgdG8gYnJhbmNoIgogbXNnc3RyICIlcyBubyBwdWVkZSBzZXIgcmVzb2x2ZXIgYSB1biBicmFuY2giCiAKLSM6IHJlbW90ZS5jOjExMDIKKyM6IHJlbW90ZS5jOjExMDUKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGRlbGV0ZSAnJXMnOiByZW1vdGUgcmVmIGRvZXMgbm90IGV4aXN0IgogbXNnc3RyICJubyBlcyBwb3NpYmxlIGJvcnJhciAnJXMnOiByZWYgcmVtb3RvIG5vIGV4aXN0ZSIKIAotIzogcmVtb3RlLmM6MTExNAorIzogcmVtb3RlLmM6MTExNwogIywgYy1mb3JtYXQKIG1zZ2lkICJkc3QgcmVmc3BlYyAlcyBtYXRjaGVzIG1vcmUgdGhhbiBvbmUiCiBtc2dzdHIgImRzdCByZWZzcGVjICVzIGNvbmN1ZXJkYSBjb24gbcOhcyBkZSB1bm8iCiAKLSM6IHJlbW90ZS5jOjExMjEKKyM6IHJlbW90ZS5jOjExMjQKICMsIGMtZm9ybWF0CiBtc2dpZCAiZHN0IHJlZiAlcyByZWNlaXZlcyBmcm9tIG1vcmUgdGhhbiBvbmUgc3JjIgogbXNnc3RyICJkc3QgcmVmICVzIHJlY2liZSBkZSBtw6FzIGRlIHVuIHNyYyIKIAotIzogcmVtb3RlLmM6MTYyNCByZW1vdGUuYzoxNzI1CisjOiByZW1vdGUuYzoxNjI3IHJlbW90ZS5jOjE3MjgKIG1zZ2lkICJIRUFEIGRvZXMgbm90IHBvaW50IHRvIGEgYnJhbmNoIgogbXNnc3RyICJIRUFEIG5vIGFwdW50YSBhIG5pbmd1bmEgcmFtYSIKIAotIzogcmVtb3RlLmM6MTYzMworIzogcmVtb3RlLmM6MTYzNgogIywgYy1mb3JtYXQKIG1zZ2lkICJubyBzdWNoIGJyYW5jaDogJyVzJyIKIG1zZ3N0ciAibm8gZXhpc3RlIHRhbCByYW1hOiAnJXMnIgogCi0jOiByZW1vdGUuYzoxNjM2CisjOiByZW1vdGUuYzoxNjM5CiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vIHVwc3RyZWFtIGNvbmZpZ3VyZWQgZm9yIGJyYW5jaCAnJXMnIgogbXNnc3RyICJubyBzZSBoYSBjb25maWd1cmFkbyB1cHN0cmVhbSBwYXJhIGxhIHJhbWEgJyVzJyIKIAotIzogcmVtb3RlLmM6MTY0MgorIzogcmVtb3RlLmM6MTY0NQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1cHN0cmVhbSBicmFuY2ggJyVzJyBub3Qgc3RvcmVkIGFzIGEgcmVtb3RlLXRyYWNraW5nIGJyYW5jaCIKIG1zZ3N0ciAibGEgcmFtYSAnJXMnIGRlIHVwc3RyZWFtIG5vIGVzIGd1YXJkYWQgY29tbyByYW1hIGRlIHJhc3RyZW8gcmVtb3RvIgogCi0jOiByZW1vdGUuYzoxNjU3CisjOiByZW1vdGUuYzoxNjYwCiAjLCBjLWZvcm1hdAogbXNnaWQgInB1c2ggZGVzdGluYXRpb24gJyVzJyBvbiByZW1vdGUgJyVzJyBoYXMgbm8gbG9jYWwgdHJhY2tpbmcgYnJhbmNoIgogbXNnc3RyICIiCiAiZGVzdGlubyBkZSBwdXNoICclcycgZW4gZWwgcmVtb3RvICclcycgbm8gdGllbmUgdW5hIHJhbWEgZGUgcmFzdHJlbyBsb2NhbCIKIAotIzogcmVtb3RlLmM6MTY2OQorIzogcmVtb3RlLmM6MTY3MgogIywgYy1mb3JtYXQKIG1zZ2lkICJicmFuY2ggJyVzJyBoYXMgbm8gcmVtb3RlIGZvciBwdXNoaW5nIgogbXNnc3RyICJsYSByYW1hICclcycgbm8gdGllbmUgcmVtb3RvIHBhcmEgZW52aWFyIgogCi0jOiByZW1vdGUuYzoxNjc5CisjOiByZW1vdGUuYzoxNjgyCiAjLCBjLWZvcm1hdAogbXNnaWQgInB1c2ggcmVmc3BlY3MgZm9yICclcycgZG8gbm90IGluY2x1ZGUgJyVzJyIKIG1zZ3N0ciAicmVmc3BlY3MgZGVsIHB1c2ggcGFyYSAnJXMnIG5vIGluY2x1eWVuICclcyciCiAKLSM6IHJlbW90ZS5jOjE2OTIKKyM6IHJlbW90ZS5jOjE2OTUKIG1zZ2lkICJwdXNoIGhhcyBubyBkZXN0aW5hdGlvbiAocHVzaC5kZWZhdWx0IGlzICdub3RoaW5nJykiCiBtc2dzdHIgInB1c2ggbm8gdGllbmUgZGVzdGlubyAocHVzaC5kZWZhdWx0IGVzICduYWRhJykiCiAKLSM6IHJlbW90ZS5jOjE3MTQKKyM6IHJlbW90ZS5jOjE3MTcKIG1zZ2lkICJjYW5ub3QgcmVzb2x2ZSAnc2ltcGxlJyBwdXNoIHRvIGEgc2luZ2xlIGRlc3RpbmF0aW9uIgogbXNnc3RyICJubyBzZSBwdWVkZSByZXNvbHZlciBwdXNoICdzaW1wbGUnIHBhcmEgdW4gZGVzdGlubyDDum5pY28iCiAKLSM6IHJlbW90ZS5jOjE4NDAKKyM6IHJlbW90ZS5jOjE4NDMKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGRuJ3QgZmluZCByZW1vdGUgcmVmICVzIgogbXNnc3RyICJubyBzZSBwdWVkbyBlbmNvbnRyYXIgcmVmIHJlbW90YSAlcyIKIAotIzogcmVtb3RlLmM6MTg1MworIzogcmVtb3RlLmM6MTg1NgogIywgYy1mb3JtYXQKIG1zZ2lkICIqIElnbm9yaW5nIGZ1bm55IHJlZiAnJXMnIGxvY2FsbHkiCiBtc2dzdHIgIiogSWdub3JhbmRvIHJlZiBncmFjaW9zYSAnJXMnIGxvY2FsbWVudGUiCiAKLSM6IHJlbW90ZS5jOjIwMTYKKyM6IHJlbW90ZS5jOjIwMTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiWW91ciBicmFuY2ggaXMgYmFzZWQgb24gJyVzJywgYnV0IHRoZSB1cHN0cmVhbSBpcyBnb25lLlxuIgogbXNnc3RyICJUdSByYW1hIGVzdMOhIGJhc2FkYSBlbiAnJXMnLCBwZXJvIHVwc3RyZWFtIGhhIGRlc2FwYXJlY2lkby5cbiIKIAotIzogcmVtb3RlLmM6MjAyMAorIzogcmVtb3RlLmM6MjAyMwogbXNnaWQgIiAgKHVzZSBcImdpdCBicmFuY2ggLS11bnNldC11cHN0cmVhbVwiIHRvIGZpeHVwKVxuIgogbXNnc3RyICIgICh1c2EgXCJnaXQgYnJhbmNoIC0tdW5zZXQtdXBzdHJlYW1cIiBwYXJhIGFycmVnbGFyKVxuIgogCi0jOiByZW1vdGUuYzoyMDIzCisjOiByZW1vdGUuYzoyMDI2CiAjLCBjLWZvcm1hdAogbXNnaWQgIllvdXIgYnJhbmNoIGlzIHVwIHRvIGRhdGUgd2l0aCAnJXMnLlxuIgogbXNnc3RyICJUdSByYW1hIGVzdMOhIGFjdHVhbGl6YWRhIGNvbiAnJXMnLlxuIgogCi0jOiByZW1vdGUuYzoyMDI3CisjOiByZW1vdGUuYzoyMDMwCiAjLCBjLWZvcm1hdAogbXNnaWQgIllvdXIgYnJhbmNoIGFuZCAnJXMnIHJlZmVyIHRvIGRpZmZlcmVudCBjb21taXRzLlxuIgogbXNnc3RyICJUdSByYW1hIHkgJyVzJyByZWZpZXJlbiBhIGNvbW1pdHMgZGlmZXJlbnRlcy5cbiIKIAotIzogcmVtb3RlLmM6MjAzMAorIzogcmVtb3RlLmM6MjAzMwogIywgYy1mb3JtYXQKIG1zZ2lkICIgICh1c2UgXCIlc1wiIGZvciBkZXRhaWxzKVxuIgogbXNnc3RyICIgICh1c2EgXCIlc1wiIHBhcmEgZGV0YWxsZXMpXG4iCiAKLSM6IHJlbW90ZS5jOjIwMzQKKyM6IHJlbW90ZS5jOjIwMzcKICMsIGMtZm9ybWF0CiBtc2dpZCAiWW91ciBicmFuY2ggaXMgYWhlYWQgb2YgJyVzJyBieSAlZCBjb21taXQuXG4iCiBtc2dpZF9wbHVyYWwgIllvdXIgYnJhbmNoIGlzIGFoZWFkIG9mICclcycgYnkgJWQgY29tbWl0cy5cbiIKIG1zZ3N0clswXSAiVHUgcmFtYSBlc3TDoSBhZGVsYW50YWRhIGEgJyVzJyBwb3IgJWQgY29tbWl0LlxuIgogbXNnc3RyWzFdICJUdSByYW1hIGVzdMOhIGFkZWxhbnRhZGEgYSAnJXMnIHBvciAlZCBjb21taXRzLlxuIgogCi0jOiByZW1vdGUuYzoyMDQwCisjOiByZW1vdGUuYzoyMDQzCiBtc2dpZCAiICAodXNlIFwiZ2l0IHB1c2hcIiB0byBwdWJsaXNoIHlvdXIgbG9jYWwgY29tbWl0cylcbiIKIG1zZ3N0ciAiICAodXNhIFwiZ2l0IHB1c2hcIiBwYXJhIHB1YmxpY2FyIHR1cyBjb21taXRzIGxvY2FsZXMpXG4iCiAKLSM6IHJlbW90ZS5jOjIwNDMKKyM6IHJlbW90ZS5jOjIwNDYKICMsIGMtZm9ybWF0CiBtc2dpZCAiWW91ciBicmFuY2ggaXMgYmVoaW5kICclcycgYnkgJWQgY29tbWl0LCBhbmQgY2FuIGJlIGZhc3QtZm9yd2FyZGVkLlxuIgogbXNnaWRfcGx1cmFsICIiCkBAIC01NTM0LDExICs1NTY3LDExIEBACiBtc2dzdHJbMV0gIiIKICJUdSByYW1hIGVzdMOhIGRldHLDoXMgZGUgJyVzJyBwb3IgJWQgY29tbWl0cywgeSBwdWVkZSBzZXIgYXZhbnphZGEgcsOhcGlkby5cbiIKIAotIzogcmVtb3RlLmM6MjA1MQorIzogcmVtb3RlLmM6MjA1NAogbXNnaWQgIiAgKHVzZSBcImdpdCBwdWxsXCIgdG8gdXBkYXRlIHlvdXIgbG9jYWwgYnJhbmNoKVxuIgogbXNnc3RyICIgICh1c2EgXCJnaXQgcHVsbFwiIHBhcmEgYWN0dWFsaXphciB0dSByYW1hIGxvY2FsKVxuIgogCi0jOiByZW1vdGUuYzoyMDU0CisjOiByZW1vdGUuYzoyMDU3CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJZb3VyIGJyYW5jaCBhbmQgJyVzJyBoYXZlIGRpdmVyZ2VkLFxuIgpAQCAtNTU1MywxMSArNTU4NiwxMSBAQAogIlR1IHJhbWEgeSAnJXMnIGhhbiBkaXZlcmdpZG8sXG4iCiAieSB0aWVuZW4gJWQgeSAlZCBjb21taXRzIGRpZmVyZW50ZXMgY2FkYSB1bmEgcmVzcGVjdGl2YW1lbnRlLlxuIgogCi0jOiByZW1vdGUuYzoyMDY0CisjOiByZW1vdGUuYzoyMDY3CiBtc2dpZCAiICAodXNlIFwiZ2l0IHB1bGxcIiB0byBtZXJnZSB0aGUgcmVtb3RlIGJyYW5jaCBpbnRvIHlvdXJzKVxuIgogbXNnc3RyICIgICh1c2EgXCJnaXQgcHVsbFwiIHBhcmEgZnVzaW9uYXIgbGEgcmFtYSByZW1vdGEgZW4gbGEgdHV5YSlcbiIKIAotIzogcmVtb3RlLmM6MjI0NworIzogcmVtb3RlLmM6MjI1MAogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgcGFyc2UgZXhwZWN0ZWQgb2JqZWN0IG5hbWUgJyVzJyIKIG1zZ3N0ciAibm8gc2UgcHVlZGUgbGVlciBlbCBub21icmUgZGUgb2JqZXRvICclcyciCkBAIC01NjM1LDcgKzU2NjgsNyBAQAogbXNnaWQgIlJlY29yZGVkIHByZWltYWdlIGZvciAnJXMnIgogbXNnc3RyICJSZXNvbHVjacOzbiBwcmVjYXJnYWRhIHBhcmEgJyVzJyIKIAotIzogcmVyZXJlLmM6ODgxIHN1Ym1vZHVsZS5jOjIwMjMgYnVpbHRpbi9sb2cuYzoxNzczCisjOiByZXJlcmUuYzo4ODEgc3VibW9kdWxlLmM6MjAyMyBidWlsdGluL2xvZy5jOjE3OTAKICM6IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxNDE4IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxNDI4CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBjcmVhdGUgZGlyZWN0b3J5ICclcyciCkBAIC01NjcwLDIwICs1NzAzLDIwIEBACiBtc2dpZCAidW5hYmxlIHRvIG9wZW4gcnItY2FjaGUgZGlyZWN0b3J5IgogbXNnc3RyICJubyBlcyBwb3NpYmxlIGFicmlyIGRpcmVjdG9yaW8gcnItY2FjaGUiCiAKLSM6IHJldmlzaW9uLmM6MjUwNworIzogcmV2aXNpb24uYzoyNTA5CiBtc2dpZCAieW91ciBjdXJyZW50IGJyYW5jaCBhcHBlYXJzIHRvIGJlIGJyb2tlbiIKIG1zZ3N0ciAidHUgcmFtYSBhY3R1YWwgcGFyZWNlIGVzdGFyIHJvdGEiCiAKLSM6IHJldmlzaW9uLmM6MjUxMAorIzogcmV2aXNpb24uYzoyNTEyCiAjLCBjLWZvcm1hdAogbXNnaWQgInlvdXIgY3VycmVudCBicmFuY2ggJyVzJyBkb2VzIG5vdCBoYXZlIGFueSBjb21taXRzIHlldCIKIG1zZ3N0ciAidHUgcmFtYSBhY3R1YWwgJyVzJyBubyB0aWVuZSBuaW5nw7puIGNvbW1pdCB0b2RhdsOtYSIKIAotIzogcmV2aXNpb24uYzoyNzEwCisjOiByZXZpc2lvbi5jOjI3MjAKIG1zZ2lkICItLWZpcnN0LXBhcmVudCBpcyBpbmNvbXBhdGlibGUgd2l0aCAtLWJpc2VjdCIKIG1zZ3N0ciAiLS1maXJzdC1wYXJlbnQgZXMgaW5jb21wYXRpYmxlIGNvbiAtLWJpc2VjdCIKIAotIzogcmV2aXNpb24uYzoyNzE0CisjOiByZXZpc2lvbi5jOjI3MjQKIG1zZ2lkICItTCBkb2VzIG5vdCB5ZXQgc3VwcG9ydCBkaWZmIGZvcm1hdHMgYmVzaWRlcyAtcCBhbmQgLXMiCiBtc2dzdHIgIi1MIG5vIHNvcG9ydGEgdG9kYXbDrWEgZm9ybWF0b3MgZGUgZGlmZiBmdWVyYSBkZSAtcCB5IC1zIgogCkBAIC01NzA2LDMwICs1NzM5LDMwIEBACiAiUHVlZGVzIGRlc2FjdGl2YXIgZXN0YSBhZHZlcnRlbmNpYXMgY29uIGBnaXQgY29uZmlnIGFkdmljZS5pZ25vcmVkSG9vayAiCiAiZmFsc2VgLiIKIAotIzogc2VuZC1wYWNrLmM6MTQxCisjOiBzZW5kLXBhY2suYzoxNDIKIG1zZ2lkICJ1bmV4cGVjdGVkIGZsdXNoIHBhY2tldCB3aGlsZSByZWFkaW5nIHJlbW90ZSB1bnBhY2sgc3RhdHVzIgogbXNnc3RyICIiCiAiZmx1c2ggcGFja2V0IGluZXNwZXJhZG8gbWllbnRyYXMgc2UgbGXDrWEgZXN0YXR1cyBkZSBkZXNlbXBhcXVldGFkbyByZW1vdG8iCiAKLSM6IHNlbmQtcGFjay5jOjE0MworIzogc2VuZC1wYWNrLmM6MTQ0CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBwYXJzZSByZW1vdGUgdW5wYWNrIHN0YXR1czogJXMiCiBtc2dzdHIgIm5vIGVzIHBvc2libGUgYW5hbGl6YXIgZWwgZXN0YWRvIGRlIGRlc2VtcGFxdWV0YWRvIHJlbW90bzogJXMiCiAKLSM6IHNlbmQtcGFjay5jOjE0NQorIzogc2VuZC1wYWNrLmM6MTQ2CiAjLCBjLWZvcm1hdAogbXNnaWQgInJlbW90ZSB1bnBhY2sgZmFpbGVkOiAlcyIKIG1zZ3N0ciAiZGVzZW1wYXF1ZXRhZG8gcmVtb3RvIGZhbGzDszogJXMiCiAKLSM6IHNlbmQtcGFjay5jOjMwNgorIzogc2VuZC1wYWNrLmM6MzA3CiBtc2dpZCAiZmFpbGVkIHRvIHNpZ24gdGhlIHB1c2ggY2VydGlmaWNhdGUiCiBtc2dzdHIgImZhbGzDsyBhbCBmaXJtYXIgZWwgY2VydGlmaWNhZG8gZGUgcHVzaCIKIAotIzogc2VuZC1wYWNrLmM6NDIwCisjOiBzZW5kLXBhY2suYzo0MjEKIG1zZ2lkICJ0aGUgcmVjZWl2aW5nIGVuZCBkb2VzIG5vdCBzdXBwb3J0IC0tc2lnbmVkIHB1c2giCiBtc2dzdHIgImVsIGZpbmFsIHJlY2VwdG9yIG5vIHNvcG9ydGEgLS1zaWduZWQgcHVzaCIKIAotIzogc2VuZC1wYWNrLmM6NDIyCisjOiBzZW5kLXBhY2suYzo0MjMKIG1zZ2lkICIiCiAibm90IHNlbmRpbmcgYSBwdXNoIGNlcnRpZmljYXRlIHNpbmNlIHRoZSByZWNlaXZpbmcgZW5kIGRvZXMgbm90IHN1cHBvcnQgLS0iCiAic2lnbmVkIHB1c2giCkBAIC01NzM3LDExICs1NzcwLDExIEBACiAibm8gc2UgbWFuZGEgdW4gY2VydGlmaWNhZG8gZGUgcHVzaCB5YSBxdWUgZWwgZGVzdGlubyBubyBzb3BvcnRhIHB1c2ggZmlybWFkbyAiCiAiKC0tc2lnbmVkICkiCiAKLSM6IHNlbmQtcGFjay5jOjQzNAorIzogc2VuZC1wYWNrLmM6NDM1CiBtc2dpZCAidGhlIHJlY2VpdmluZyBlbmQgZG9lcyBub3Qgc3VwcG9ydCAtLWF0b21pYyBwdXNoIgogbXNnc3RyICJlbCBkZXN0aW5vIG5vIHNvcG9ydGEgcHVzaCBhdMOzbWljb3MgKC0tYXRvbWljKSIKIAotIzogc2VuZC1wYWNrLmM6NDM5CisjOiBzZW5kLXBhY2suYzo0NDAKIG1zZ2lkICJ0aGUgcmVjZWl2aW5nIGVuZCBkb2VzIG5vdCBzdXBwb3J0IHB1c2ggb3B0aW9ucyIKIG1zZ3N0ciAiZWwgZGVzdGlubyBubyBzb3BvcnRhIG9wY2lvbmVzIGRlIHB1c2giCiAKQEAgLTU3NTUsNyArNTc4OCw3IEBACiBtc2dpZCAiY291bGQgbm90IGRlbGV0ZSAnJXMnIgogbXNnc3RyICJubyBzZSBwdWRvIGJvcnJhciAnJXMnIgogCi0jOiBzZXF1ZW5jZXIuYzozMTEgYnVpbHRpbi9yZWJhc2UuYzo3NTkgYnVpbHRpbi9yZWJhc2UuYzoxNjQ1IGJ1aWx0aW4vcm0uYzozNjkKKyM6IHNlcXVlbmNlci5jOjMxMSBidWlsdGluL3JlYmFzZS5jOjc2MCBidWlsdGluL3JlYmFzZS5jOjE2NzYgYnVpbHRpbi9ybS5jOjM2OQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcmVtb3ZlICclcyciCiBtc2dzdHIgIm5vIHNlIHB1ZG8gZWxpbWluYXInJXMnIgpAQCAtNTc5NSw3ICs1ODI4LDcgQEAKICJjb24gJ2dpdCBhZGQgPHJ1dGFzPicgbyAnZ2l0IHJtIDxydXRhcz4nXG4iCiAieSBoYXogdW4gY29tbWl0IGRlbCByZXN1bHRhZG8gY29uICdnaXQgY29tbWl0JyIKIAotIzogc2VxdWVuY2VyLmM6NDAxIHNlcXVlbmNlci5jOjI5MDkKKyM6IHNlcXVlbmNlci5jOjQwMSBzZXF1ZW5jZXIuYzoyODQ3CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBsb2NrICclcyciCiBtc2dzdHIgIm5vIHNlIHB1ZG8gYmxvcXVlYXIgJyVzJyIKQEAgLTU4MDUsMTUgKzU4MzgsMTUgQEAKIG1zZ2lkICJjb3VsZCBub3Qgd3JpdGUgZW9sIHRvICclcyciCiBtc2dzdHIgIm5vIHNlIHB1ZG8gZXNjcmliaXIgRU9MIGVuICclcyciCiAKLSM6IHNlcXVlbmNlci5jOjQxMyBzZXF1ZW5jZXIuYzoyNzE0IHNlcXVlbmNlci5jOjI5MTUgc2VxdWVuY2VyLmM6MjkyOQotIzogc2VxdWVuY2VyLmM6MzE5MgorIzogc2VxdWVuY2VyLmM6NDEzIHNlcXVlbmNlci5jOjI2NTIgc2VxdWVuY2VyLmM6Mjg1MyBzZXF1ZW5jZXIuYzoyODY3CisjOiBzZXF1ZW5jZXIuYzozMTMwCiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBmaW5hbGl6ZSAnJXMnIgogbXNnc3RyICJmYWxsw7MgYWwgZmluYWxpemFyICclcyciCiAKLSM6IHNlcXVlbmNlci5jOjQzNiBzZXF1ZW5jZXIuYzo5ODEgc2VxdWVuY2VyLmM6MTY1NSBzZXF1ZW5jZXIuYzoyNzM0Ci0jOiBzZXF1ZW5jZXIuYzozMTc0IHNlcXVlbmNlci5jOjMyODMgYnVpbHRpbi9hbS5jOjI0NSBidWlsdGluL2NvbW1pdC5jOjc2MwotIzogYnVpbHRpbi9tZXJnZS5jOjExMTIgYnVpbHRpbi9yZWJhc2UuYzo1NjcKKyM6IHNlcXVlbmNlci5jOjQzNiBzZXF1ZW5jZXIuYzoxNTg1IHNlcXVlbmNlci5jOjI2NzIgc2VxdWVuY2VyLmM6MzExMgorIzogc2VxdWVuY2VyLmM6MzIyMSBidWlsdGluL2FtLmM6MjQ0IGJ1aWx0aW4vY29tbWl0LmM6NzYzIGJ1aWx0aW4vbWVyZ2UuYzoxMTE3CisjOiBidWlsdGluL3JlYmFzZS5jOjU2OAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcmVhZCAnJXMnIgogbXNnc3RyICJubyBzZSBwdWRvIGxlZXIgJyVzJyIKQEAgLTU4NDAsNzAgKzU4NzMsNjUgQEAKICMuIFRSQU5TTEFUT1JTOiAlcyB3aWxsIGJlICJyZXZlcnQiLCAiY2hlcnJ5LXBpY2siIG9yCiAjLiAicmViYXNlIC1pIi4KICMuCi0jOiBzZXF1ZW5jZXIuYzo2MzIKKyM6IHNlcXVlbmNlci5jOjYzMQogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogVW5hYmxlIHRvIHdyaXRlIG5ldyBpbmRleCBmaWxlIgogbXNnc3RyICIlczogSW5jYXBheiBkZSBlc2NyaWJpciBlbCBudWV2byBhcmNoaXZvIMOtbmRpY2UiCiAKLSM6IHNlcXVlbmNlci5jOjY0OQorIzogc2VxdWVuY2VyLmM6NjQ4CiBtc2dpZCAidW5hYmxlIHRvIHVwZGF0ZSBjYWNoZSB0cmVlIgogbXNnc3RyICJubyBlcyBwb3NpYmxlIGFjdHVhbGl6YXIgZWwgw6FyYm9sIGRlIGxhIGNhY2jDqSIKIAotIzogc2VxdWVuY2VyLmM6NjYzCisjOiBzZXF1ZW5jZXIuYzo2NjIKIG1zZ2lkICJjb3VsZCBub3QgcmVzb2x2ZSBIRUFEIGNvbW1pdCIKIG1zZ3N0ciAibm8gc2UgcHVkbyByZXNvbHZlciBlbCBjb21taXQgZGUgSEVBRCIKIAotIzogc2VxdWVuY2VyLmM6NzQzCisjOiBzZXF1ZW5jZXIuYzo3NDIKICMsIGMtZm9ybWF0CiBtc2dpZCAibm8ga2V5IHByZXNlbnQgaW4gJyUuKnMnIgogbXNnc3RyICJubyBoYXkgbGxhdmUgcHJlc2VudGUgZW4gJyUuKnMnIgogCi0jOiBzZXF1ZW5jZXIuYzo3NTQKKyM6IHNlcXVlbmNlci5jOjc1MwogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gZGVxdW90ZSB2YWx1ZSBvZiAnJXMnIgogbXNnc3RyICJubyBlcyBwb3NpYmxlIGRlcXVvdGUgcGFyYSAnJXMnIgogCi0jOiBzZXF1ZW5jZXIuYzo3OTEgd3JhcHBlci5jOjIyNyB3cmFwcGVyLmM6Mzk3IGJ1aWx0aW4vYW0uYzo3MDYKLSM6IGJ1aWx0aW4vYW0uYzo3OTggYnVpbHRpbi9tZXJnZS5jOjExMDkgYnVpbHRpbi9yZWJhc2UuYzoxMDQ1CisjOiBzZXF1ZW5jZXIuYzo3OTAgd3JhcHBlci5jOjE5MCB3cmFwcGVyLmM6MzYwIGJ1aWx0aW4vYW0uYzo3MDUKKyM6IGJ1aWx0aW4vYW0uYzo3OTcgYnVpbHRpbi9tZXJnZS5jOjExMTQgYnVpbHRpbi9yZWJhc2UuYzoxMDQ2CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBvcGVuICclcycgZm9yIHJlYWRpbmciCiBtc2dzdHIgIm5vIHNlIHB1ZG8gYWJyaXIgJyVzJyBwYXJhIGxlY3R1cmEiCiAKLSM6IHNlcXVlbmNlci5jOjgwMQorIzogc2VxdWVuY2VyLmM6ODAwCiBtc2dpZCAiJ0dJVF9BVVRIT1JfTkFNRScgYWxyZWFkeSBnaXZlbiIKIG1zZ3N0ciAiJ0dJVF9BVVRIT1JfTkFNRScgeWEgcHJvcG9yY2lvbmFkbyIKIAotIzogc2VxdWVuY2VyLmM6ODA2CisjOiBzZXF1ZW5jZXIuYzo4MDUKIG1zZ2lkICInR0lUX0FVVEhPUl9FTUFJTCcgYWxyZWFkeSBnaXZlbiIKIG1zZ3N0ciAiJ0dJVF9BVVRIT1JfRU1BSUwnIHlhIHByb3BvcmNpb25hZG8iCiAKLSM6IHNlcXVlbmNlci5jOjgxMQorIzogc2VxdWVuY2VyLmM6ODEwCiBtc2dpZCAiJ0dJVF9BVVRIT1JfREFURScgYWxyZWFkeSBnaXZlbiIKIG1zZ3N0ciAiJ0dJVF9BVVRIT1JfREFURScgeWEgcHJvcG9yY2lvbmFkbyIKIAotIzogc2VxdWVuY2VyLmM6ODE1CisjOiBzZXF1ZW5jZXIuYzo4MTQKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5rbm93biB2YXJpYWJsZSAnJXMnIgogbXNnc3RyICJ2YXJpYWJsZSBkZXNjb25vY2lkYSAnJXMnIgogCi0jOiBzZXF1ZW5jZXIuYzo4MjAKKyM6IHNlcXVlbmNlci5jOjgxOQogbXNnaWQgIm1pc3NpbmcgJ0dJVF9BVVRIT1JfTkFNRSciCiBtc2dzdHIgImZhbHRhICdHSVRfQVVUSE9SX05BTUUnIgogCi0jOiBzZXF1ZW5jZXIuYzo4MjIKKyM6IHNlcXVlbmNlci5jOjgyMQogbXNnaWQgIm1pc3NpbmcgJ0dJVF9BVVRIT1JfRU1BSUwnIgogbXNnc3RyICJmYWx0YSAnR0lUX0FVVEhPUl9FTUFJTCciCiAKLSM6IHNlcXVlbmNlci5jOjgyNAorIzogc2VxdWVuY2VyLmM6ODIzCiBtc2dpZCAibWlzc2luZyAnR0lUX0FVVEhPUl9EQVRFJyIKIG1zZ3N0ciAiZmFsdGEgJ0dJVF9BVVRIT1JfREFURSciCiAKLSM6IHNlcXVlbmNlci5jOjg4NAotIywgYy1mb3JtYXQKLW1zZ2lkICJpbnZhbGlkIGRhdGUgZm9ybWF0ICclcycgaW4gJyVzJyIKLW1zZ3N0ciAiZm9ybWF0byBkZSBmZWNoYSBpbnbDoWxpZG8gJyVzJyBlbiAnJXMnIgotCi0jOiBzZXF1ZW5jZXIuYzo5MDEKKyM6IHNlcXVlbmNlci5jOjg3MgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAieW91IGhhdmUgc3RhZ2VkIGNoYW5nZXMgaW4geW91ciB3b3JraW5nIHRyZWVcbiIKQEAgLTU5MzMsMTUgKzU5NjEsMTEgQEAKICJcbiIKICIgIGdpdCByZWJhc2UgLS1jb250aW51ZVxuIgogCi0jOiBzZXF1ZW5jZXIuYzo5OTUKLW1zZ2lkICJ3cml0aW5nIHJvb3QgY29tbWl0IgotbXNnc3RyICJlc2NyaWJpZW5kbyBjb21taXQgcmHDrXoiCi0KLSM6IHNlcXVlbmNlci5jOjEyMTYKKyM6IHNlcXVlbmNlci5jOjExNDYKIG1zZ2lkICIncHJlcGFyZS1jb21taXQtbXNnJyBob29rIGZhaWxlZCIKIG1zZ3N0ciAiaG9vayAncHJlcGFyZS1jb21taXQtbXNnJyBmYWxsw7MiCiAKLSM6IHNlcXVlbmNlci5jOjEyMjMKKyM6IHNlcXVlbmNlci5jOjExNTMKIG1zZ2lkICIiCiAiWW91ciBuYW1lIGFuZCBlbWFpbCBhZGRyZXNzIHdlcmUgY29uZmlndXJlZCBhdXRvbWF0aWNhbGx5IGJhc2VkXG4iCiAib24geW91ciB1c2VybmFtZSBhbmQgaG9zdG5hbWUuIFBsZWFzZSBjaGVjayB0aGF0IHRoZXkgYXJlIGFjY3VyYXRlLlxuIgpAQCAtNTk2OCw3ICs1OTkyLDcgQEAKICJcbiIKICIgICAgZ2l0IGNvbW1pdCAtLWFtZW5kIC0tcmVzZXQtYXV0aG9yXG4iCiAKLSM6IHNlcXVlbmNlci5jOjEyMzYKKyM6IHNlcXVlbmNlci5jOjExNjYKIG1zZ2lkICIiCiAiWW91ciBuYW1lIGFuZCBlbWFpbCBhZGRyZXNzIHdlcmUgY29uZmlndXJlZCBhdXRvbWF0aWNhbGx5IGJhc2VkXG4iCiAib24geW91ciB1c2VybmFtZSBhbmQgaG9zdG5hbWUuIFBsZWFzZSBjaGVjayB0aGF0IHRoZXkgYXJlIGFjY3VyYXRlLlxuIgpAQCAtNTk5MiwzMjUgKzYwMTYsMzI1IEBACiAiXG4iCiAiICAgIGdpdCBjb21taXQgLS1hbWVuZCAtLXJlc2V0LWF1dGhvclxuIgogCi0jOiBzZXF1ZW5jZXIuYzoxMjc4CisjOiBzZXF1ZW5jZXIuYzoxMjA4CiBtc2dpZCAiY291bGRuJ3QgbG9vayB1cCBuZXdseSBjcmVhdGVkIGNvbW1pdCIKIG1zZ3N0ciAibm8gc2UgcHVkbyByZXZpc2FyIGVsIGNvbW1pdCByZWNpw6luIGNyZWFkbyIKIAotIzogc2VxdWVuY2VyLmM6MTI4MAorIzogc2VxdWVuY2VyLmM6MTIxMAogbXNnaWQgImNvdWxkIG5vdCBwYXJzZSBuZXdseSBjcmVhdGVkIGNvbW1pdCIKIG1zZ3N0ciAibm8gc2UgcHVkbyBhbmFsaXphciBlbCBjb21taXQgcmVjacOpbiBjcmVhZG8iCiAKLSM6IHNlcXVlbmNlci5jOjEzMjYKKyM6IHNlcXVlbmNlci5jOjEyNTYKIG1zZ2lkICJ1bmFibGUgdG8gcmVzb2x2ZSBIRUFEIGFmdGVyIGNyZWF0aW5nIGNvbW1pdCIKIG1zZ3N0ciAibm8gc2UgcHVkbyByZXNvbHZlciBIRUFEIHRyYXMgY3JlYXIgZWwgY29tbWl0IgogCi0jOiBzZXF1ZW5jZXIuYzoxMzI4CisjOiBzZXF1ZW5jZXIuYzoxMjU4CiBtc2dpZCAiZGV0YWNoZWQgSEVBRCIKIG1zZ3N0ciAiSEVBRCBkZXNhY29wbGFkbyIKIAotIzogc2VxdWVuY2VyLmM6MTMzMgorIzogc2VxdWVuY2VyLmM6MTI2MgogbXNnaWQgIiAocm9vdC1jb21taXQpIgogbXNnc3RyICIgKGNvbW1pdC1yYcOteikiCiAKLSM6IHNlcXVlbmNlci5jOjEzNTMKKyM6IHNlcXVlbmNlci5jOjEyODMKIG1zZ2lkICJjb3VsZCBub3QgcGFyc2UgSEVBRCIKIG1zZ3N0ciAibm8gc2UgcHVkbyBhbmFsaXphciBIRUFEIgogCi0jOiBzZXF1ZW5jZXIuYzoxMzU1CisjOiBzZXF1ZW5jZXIuYzoxMjg1CiAjLCBjLWZvcm1hdAogbXNnaWQgIkhFQUQgJXMgaXMgbm90IGEgY29tbWl0ISIKLW1zZ3N0ciAiSEVBRCAlcyBubyBlcyB1biBjb21taXQhIgorbXNnc3RyICLCoUhFQUQgJXMgbm8gZXMgdW4gY29tbWl0ISIKIAotIzogc2VxdWVuY2VyLmM6MTM1OSBidWlsdGluL2NvbW1pdC5jOjE1NzEKKyM6IHNlcXVlbmNlci5jOjEyODkgYnVpbHRpbi9jb21taXQuYzoxNTcxCiBtc2dpZCAiY291bGQgbm90IHBhcnNlIEhFQUQgY29tbWl0IgogbXNnc3RyICJubyBzZSBwdWRvIGFuYWxpemFyIGVsIGNvbW1pdCBkZSBIRUFEIgogCi0jOiBzZXF1ZW5jZXIuYzoxNDExIHNlcXVlbmNlci5jOjIwMDQKKyM6IHNlcXVlbmNlci5jOjEzNDEgc2VxdWVuY2VyLmM6MTkzMwogbXNnaWQgInVuYWJsZSB0byBwYXJzZSBjb21taXQgYXV0aG9yIgogbXNnc3RyICJubyBlcyBwb3NpYmxlIGFuYWxpemFyIGVsIGF1dG9yIGRlbCBjb21taXQiCiAKLSM6IHNlcXVlbmNlci5jOjE0MjEgYnVpbHRpbi9hbS5jOjE1NzMgYnVpbHRpbi9tZXJnZS5jOjY4NAorIzogc2VxdWVuY2VyLmM6MTM1MiBidWlsdGluL2FtLmM6MTU2MSBidWlsdGluL21lcmdlLmM6Njg0CiBtc2dpZCAiZ2l0IHdyaXRlLXRyZWUgZmFpbGVkIHRvIHdyaXRlIGEgdHJlZSIKIG1zZ3N0ciAiZ2l0IHdyaXRlLXRyZWUgZmFsbMOzIGFsIGVzY3JpYmlyIGVsIMOhcmJvbCIKIAotIzogc2VxdWVuY2VyLmM6MTQzOCBzZXF1ZW5jZXIuYzoxNDk5CisjOiBzZXF1ZW5jZXIuYzoxMzY5IHNlcXVlbmNlci5jOjE0MjkKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHJlYWQgY29tbWl0IG1lc3NhZ2UgZnJvbSAnJXMnIgogbXNnc3RyICJubyBzZSBwdWVkZSBsZWVyIGVsIG1lbnNhamUgZGVsIGNvbW1pdCBkZSAnJXMnIgogCi0jOiBzZXF1ZW5jZXIuYzoxNDY1IGJ1aWx0aW4vYW0uYzoxNTk1IGJ1aWx0aW4vY29tbWl0LmM6MTY3MCBidWlsdGluL21lcmdlLmM6ODc4Ci0jOiBidWlsdGluL21lcmdlLmM6OTAzCisjOiBzZXF1ZW5jZXIuYzoxMzk2IGJ1aWx0aW4vYW0uYzoxNTgzIGJ1aWx0aW4vY29tbWl0LmM6MTY3MCBidWlsdGluL21lcmdlLmM6ODgzCisjOiBidWlsdGluL21lcmdlLmM6OTA4CiBtc2dpZCAiZmFpbGVkIHRvIHdyaXRlIGNvbW1pdCBvYmplY3QiCiBtc2dzdHIgImZhbGzDsyBhbCBlc2NyaWJpciBlbCBvYmpldG8gY29tbWl0IgogCi0jOiBzZXF1ZW5jZXIuYzoxNTI2CisjOiBzZXF1ZW5jZXIuYzoxNDU2CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBwYXJzZSBjb21taXQgJXMiCiBtc2dzdHIgIm5vIHNlIHB1ZG8gYW5hbGl6YXIgY29tbWl0ICVzIgogCi0jOiBzZXF1ZW5jZXIuYzoxNTMxCisjOiBzZXF1ZW5jZXIuYzoxNDYxCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBwYXJzZSBwYXJlbnQgY29tbWl0ICVzIgogbXNnc3RyICJubyBzZSBwdWRvIGFuYWxpemFyIGVsIGNvbW1pdCBwYWRyZSAlcyIKIAotIzogc2VxdWVuY2VyLmM6MTYwNSBzZXF1ZW5jZXIuYzoxNzE1CisjOiBzZXF1ZW5jZXIuYzoxNTM1IHNlcXVlbmNlci5jOjE2NDUKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5rbm93biBjb21tYW5kOiAlZCIKIG1zZ3N0ciAiY29tYW5kbyBkZXNjb25vY2lkbzogJWQiCiAKLSM6IHNlcXVlbmNlci5jOjE2NjIgc2VxdWVuY2VyLmM6MTY4NworIzogc2VxdWVuY2VyLmM6MTU5MiBzZXF1ZW5jZXIuYzoxNjE3CiAjLCBjLWZvcm1hdAogbXNnaWQgIlRoaXMgaXMgYSBjb21iaW5hdGlvbiBvZiAlZCBjb21taXRzLiIKIG1zZ3N0ciAiRXN0YSBlcyB1bmEgY29tYmluYWNpw7NuIGRlICVkIGNvbW1pdHMuIgogCi0jOiBzZXF1ZW5jZXIuYzoxNjcyCisjOiBzZXF1ZW5jZXIuYzoxNjAyCiBtc2dpZCAibmVlZCBhIEhFQUQgdG8gZml4dXAiCiBtc2dzdHIgInNlIG5lY2VzaXRhIHVuIEhFQUQgcGFyYSBhcnJlZ2xhciIKIAotIzogc2VxdWVuY2VyLmM6MTY3NCBzZXF1ZW5jZXIuYzozMjE5CisjOiBzZXF1ZW5jZXIuYzoxNjA0IHNlcXVlbmNlci5jOjMxNTcKIG1zZ2lkICJjb3VsZCBub3QgcmVhZCBIRUFEIgogbXNnc3RyICJubyBzZSBwdWRvIGxlZXIgSEVBRCIKIAotIzogc2VxdWVuY2VyLmM6MTY3NgorIzogc2VxdWVuY2VyLmM6MTYwNgogbXNnaWQgImNvdWxkIG5vdCByZWFkIEhFQUQncyBjb21taXQgbWVzc2FnZSIKIG1zZ3N0ciAibm8gc2UgcHVkbyBsZWVyIGVsIG1lbnNhamUgZGUgY29tbWl0IGRlIEhFQUQiCiAKLSM6IHNlcXVlbmNlci5jOjE2ODIKKyM6IHNlcXVlbmNlci5jOjE2MTIKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IHdyaXRlICclcyciCiBtc2dzdHIgIm5vIHNlIHB1ZWRlIGVzY3JpYmlyICclcyciCiAKLSM6IHNlcXVlbmNlci5jOjE2ODkgZ2l0LXJlYmFzZS0tcHJlc2VydmUtbWVyZ2VzLnNoOjQ5NgorIzogc2VxdWVuY2VyLmM6MTYxOSBnaXQtcmViYXNlLS1wcmVzZXJ2ZS1tZXJnZXMuc2g6NDk2CiBtc2dpZCAiVGhpcyBpcyB0aGUgMXN0IGNvbW1pdCBtZXNzYWdlOiIKIG1zZ3N0ciAiRXN0ZSBlcyBlbCBtZW5zYWplIGRlbCAxZXIgY29tbWl0OiIKIAotIzogc2VxdWVuY2VyLmM6MTY5NworIzogc2VxdWVuY2VyLmM6MTYyNwogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcmVhZCBjb21taXQgbWVzc2FnZSBvZiAlcyIKIG1zZ3N0ciAibm8gc2UgcHVlZGUgbGVlciBlbCBtZW5zYWplIGRlbCBjb21taXQgZGUgJXMiCiAKLSM6IHNlcXVlbmNlci5jOjE3MDQKKyM6IHNlcXVlbmNlci5jOjE2MzQKICMsIGMtZm9ybWF0CiBtc2dpZCAiVGhpcyBpcyB0aGUgY29tbWl0IG1lc3NhZ2UgIyVkOiIKIG1zZ3N0ciAiRXN0ZSBlcyBlbCBtZW5zYWplIGRlbCBjb21taXQgIyVkOiIKIAotIzogc2VxdWVuY2VyLmM6MTcxMAorIzogc2VxdWVuY2VyLmM6MTY0MAogIywgYy1mb3JtYXQKIG1zZ2lkICJUaGUgY29tbWl0IG1lc3NhZ2UgIyVkIHdpbGwgYmUgc2tpcHBlZDoiCiBtc2dzdHIgIkVsIG1lbnNhamUgZGVsIGNvbW1pdCAjJWQgc2Vyw6Egc2FsdGFkbzoiCiAKLSM6IHNlcXVlbmNlci5jOjE3OTgKKyM6IHNlcXVlbmNlci5jOjE3MjgKIG1zZ2lkICJ5b3VyIGluZGV4IGZpbGUgaXMgdW5tZXJnZWQuIgogbXNnc3RyICJ0dSBhcmNoaXZvIMOtbmRpY2Ugbm8gZXN0w6EgZnVzaW9uYWRvLiIKIAotIzogc2VxdWVuY2VyLmM6MTgwNQorIzogc2VxdWVuY2VyLmM6MTczNQogbXNnaWQgImNhbm5vdCBmaXh1cCByb290IGNvbW1pdCIKIG1zZ3N0ciAibm8gc2UgcHVlZGUgYXJyZWdsYXIgZWwgY29tbWl0IHJhw616IgogCi0jOiBzZXF1ZW5jZXIuYzoxODI0CisjOiBzZXF1ZW5jZXIuYzoxNzU0CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvbW1pdCAlcyBpcyBhIG1lcmdlIGJ1dCBubyAtbSBvcHRpb24gd2FzIGdpdmVuLiIKIG1zZ3N0ciAiZWwgY29tbWl0ICVzIGVzIHVuYSBmdXNpw7NuIHBlcm8gbm8gc2UgcHJvcG9yY2lvbsOzIGxhIG9wY2nDs24gLW0uIgogCi0jOiBzZXF1ZW5jZXIuYzoxODMyIHNlcXVlbmNlci5jOjE4NDAKKyM6IHNlcXVlbmNlci5jOjE3NjIgc2VxdWVuY2VyLmM6MTc3MAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb21taXQgJXMgZG9lcyBub3QgaGF2ZSBwYXJlbnQgJWQiCiBtc2dzdHIgImVsIGNvbW1pdCAlcyBubyB0aWVuZSB1biBwYWRyZSAlZCIKIAotIzogc2VxdWVuY2VyLmM6MTg0NgorIzogc2VxdWVuY2VyLmM6MTc3NgogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgZ2V0IGNvbW1pdCBtZXNzYWdlIGZvciAlcyIKIG1zZ3N0ciAibm8gc2UgcHVlZGUgb2J0ZW5lciBlbCBtZW5zYWplIGRlIGNvbW1pdCBwYXJhICVzIgogCiAjLiBUUkFOU0xBVE9SUzogVGhlIGZpcnN0ICVzIHdpbGwgYmUgYSAidG9kbyIgY29tbWFuZCBsaWtlCiAjLiAicmV2ZXJ0IiBvciAicGljayIsIHRoZSBzZWNvbmQgJXMgYSBTSEExLgotIzogc2VxdWVuY2VyLmM6MTg2NQorIzogc2VxdWVuY2VyLmM6MTc5NQogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogY2Fubm90IHBhcnNlIHBhcmVudCBjb21taXQgJXMiCiBtc2dzdHIgIiVzOiBubyBzZSBwdWVkZSBhbmFsaXphciBlbCBjb21taXQgcGFkcmUgJXMiCiAKLSM6IHNlcXVlbmNlci5jOjE5MzAKKyM6IHNlcXVlbmNlci5jOjE4NjAKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHJlbmFtZSAnJXMnIHRvICclcyciCiBtc2dzdHIgIm5vIHNlIHB1ZWRlIHJlbm9tYnJhciAnJXMnIGEgJyVzJyIKIAotIzogc2VxdWVuY2VyLmM6MTk4NQorIzogc2VxdWVuY2VyLmM6MTkxNQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcmV2ZXJ0ICVzLi4uICVzIgogbXNnc3RyICJubyBzZSBwdWRvIHJldmVydGlyICVzLi4uICVzIgogCi0jOiBzZXF1ZW5jZXIuYzoxOTg2CisjOiBzZXF1ZW5jZXIuYzoxOTE2CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBhcHBseSAlcy4uLiAlcyIKIG1zZ3N0ciAibm8gc2UgcHVkbyBhcGxpY2FyICVzLi4uICVzIgogCi0jOiBzZXF1ZW5jZXIuYzoyMDQ1CisjOiBzZXF1ZW5jZXIuYzoxOTgzCiAjLCBjLWZvcm1hdAogbXNnaWQgImdpdCAlczogZmFpbGVkIHRvIHJlYWQgdGhlIGluZGV4IgogbXNnc3RyICJnaXQgJXM6IGZhbGzDsyBhbCBsZWVyIGVsIMOtbmRpY2UiCiAKLSM6IHNlcXVlbmNlci5jOjIwNTIKKyM6IHNlcXVlbmNlci5jOjE5OTAKICMsIGMtZm9ybWF0CiBtc2dpZCAiZ2l0ICVzOiBmYWlsZWQgdG8gcmVmcmVzaCB0aGUgaW5kZXgiCiBtc2dzdHIgImdpdCAlczogZmFsbMOzIGFsIHJlZnJlc2NhciBlbCDDrW5kaWNlIgogCi0jOiBzZXF1ZW5jZXIuYzoyMTI4CisjOiBzZXF1ZW5jZXIuYzoyMDY2CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIGRvZXMgbm90IGFjY2VwdCBhcmd1bWVudHM6ICclcyciCiBtc2dzdHIgIiVzIG5vIGFjZXB0YSBsb3MgYXJndW1lbnRvczogJyVzJyIKIAotIzogc2VxdWVuY2VyLmM6MjEzNworIzogc2VxdWVuY2VyLmM6MjA3NQogIywgYy1mb3JtYXQKIG1zZ2lkICJtaXNzaW5nIGFyZ3VtZW50cyBmb3IgJXMiCiBtc2dzdHIgImZhbHRhbiBhcmd1bWVudG9zIHBhcmEgcGFyYSAlcyIKIAotIzogc2VxdWVuY2VyLmM6MjE3NAorIzogc2VxdWVuY2VyLmM6MjExMgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcGFyc2UgJyUuKnMnIgogbXNnc3RyICJubyBzZSBwdWVkZSBhbmFsaXphciAnJS4qcyciCiAKLSM6IHNlcXVlbmNlci5jOjIyMjgKKyM6IHNlcXVlbmNlci5jOjIxNjYKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBsaW5lICVkOiAlLipzIgogbXNnc3RyICJsw61uZWEgaW52w6FsaWRhICVkOiAlLipzIgogCi0jOiBzZXF1ZW5jZXIuYzoyMjM5CisjOiBzZXF1ZW5jZXIuYzoyMTc3CiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCAnJXMnIHdpdGhvdXQgYSBwcmV2aW91cyBjb21taXQiCiBtc2dzdHIgIm5vIHNlIHB1ZWRlICAnJXMnIHNpbiB1biBjb21taXQgcHJldmlvIgogCi0jOiBzZXF1ZW5jZXIuYzoyMjg3IGJ1aWx0aW4vcmViYXNlLmM6MTUzIGJ1aWx0aW4vcmViYXNlLmM6MTc4CisjOiBzZXF1ZW5jZXIuYzoyMjI1IGJ1aWx0aW4vcmViYXNlLmM6MTUzIGJ1aWx0aW4vcmViYXNlLmM6MTc4CiAjOiBidWlsdGluL3JlYmFzZS5jOjIwNCBidWlsdGluL3JlYmFzZS5jOjIyOQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcmVhZCAnJXMnLiIKIG1zZ3N0ciAibm8gc2UgcHVlZGUgbGVlciAnJXMnLiIKIAotIzogc2VxdWVuY2VyLmM6MjMyMworIzogc2VxdWVuY2VyLmM6MjI2MQogbXNnaWQgImNhbmNlbGxpbmcgYSBjaGVycnkgcGlja2luZyBpbiBwcm9ncmVzcyIKIG1zZ3N0ciAiY2FuY2VsYW5kbyBjaGVycnktcGljayBlbiBwcm9ncmVzbyIKIAotIzogc2VxdWVuY2VyLmM6MjMzMAorIzogc2VxdWVuY2VyLmM6MjI2OAogbXNnaWQgImNhbmNlbGxpbmcgYSByZXZlcnQgaW4gcHJvZ3Jlc3MiCiBtc2dzdHIgImNhbmNlbGFuZG8gcmV2ZXJ0IGVuIHByb2dyZXNvIgogCi0jOiBzZXF1ZW5jZXIuYzoyMzY0CisjOiBzZXF1ZW5jZXIuYzoyMzAyCiBtc2dpZCAicGxlYXNlIGZpeCB0aGlzIHVzaW5nICdnaXQgcmViYXNlIC0tZWRpdC10b2RvJy4iCiBtc2dzdHIgInBvciBmYXZvciBhcnJlZ2xlIGVzdG8gdXNhbmRvICdnaXQgcmViYXNlIC0tZWRpdC10b2RvJy4iCiAKLSM6IHNlcXVlbmNlci5jOjIzNjYKKyM6IHNlcXVlbmNlci5jOjIzMDQKICMsIGMtZm9ybWF0CiBtc2dpZCAidW51c2FibGUgaW5zdHJ1Y3Rpb24gc2hlZXQ6ICclcyciCiBtc2dzdHIgImhvamEgZGUgaW5zdHJ1Y2Npb25lcyBpbnV0aWxpemFibGU6ICclcyciCiAKLSM6IHNlcXVlbmNlci5jOjIzNzEKKyM6IHNlcXVlbmNlci5jOjIzMDkKIG1zZ2lkICJubyBjb21taXRzIHBhcnNlZC4iCiBtc2dzdHIgIm5pbmfDum4gY29tbWl0IGFuYWxpemFkby4iCiAKLSM6IHNlcXVlbmNlci5jOjIzODIKKyM6IHNlcXVlbmNlci5jOjIzMjAKIG1zZ2lkICJjYW5ub3QgY2hlcnJ5LXBpY2sgZHVyaW5nIGEgcmV2ZXJ0LiIKIG1zZ3N0ciAibm8gc2UgcHVlZGUgcmVhbGl6YXIgY2hlcnJ5LXBpY2sgZHVyYW50ZSB1biByZXZlcnQuIgogCi0jOiBzZXF1ZW5jZXIuYzoyMzg0CisjOiBzZXF1ZW5jZXIuYzoyMzIyCiBtc2dpZCAiY2Fubm90IHJldmVydCBkdXJpbmcgYSBjaGVycnktcGljay4iCiBtc2dzdHIgIm5vIHNlIHB1ZWRlIHJlYWxpemFyIHVuIHJldmVydCBkdXJhbnRlIHVuIGNoZXJyeS1waWNrLiIKIAotIzogc2VxdWVuY2VyLmM6MjQ2NgorIzogc2VxdWVuY2VyLmM6MjQwNAogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIHZhbHVlIGZvciAlczogJXMiCiBtc2dzdHIgInZhbG9yIGludsOhbGlkbyBwYXJhICVzOiAlcyIKIAotIzogc2VxdWVuY2VyLmM6MjU1MworIzogc2VxdWVuY2VyLmM6MjQ5MQogbXNnaWQgInVudXNhYmxlIHNxdWFzaC1vbnRvIgogbXNnc3RyICJzcXVhc2gtb250byBpbnNlcnZpYmxlIgogCi0jOiBzZXF1ZW5jZXIuYzoyNTY5CisjOiBzZXF1ZW5jZXIuYzoyNTA3CiAjLCBjLWZvcm1hdAogbXNnaWQgIm1hbGZvcm1lZCBvcHRpb25zIHNoZWV0OiAnJXMnIgogbXNnc3RyICJob2phIGRlIG9wY2lvbmVzIG1hbCBmb3JtYWRhOiAnJXMnIgogCi0jOiBzZXF1ZW5jZXIuYzoyNjUyIHNlcXVlbmNlci5jOjQzNTEKKyM6IHNlcXVlbmNlci5jOjI1OTAgc2VxdWVuY2VyLmM6NDMwOAogbXNnaWQgImVtcHR5IGNvbW1pdCBzZXQgcGFzc2VkIgogbXNnc3RyICJjb25qdW50byBkZSBjb21taXRzIHZhY8OtbyBlbnRyZWdhZG8iCiAKLSM6IHNlcXVlbmNlci5jOjI2NjgKKyM6IHNlcXVlbmNlci5jOjI2MDYKIG1zZ2lkICJyZXZlcnQgaXMgYWxyZWFkeSBpbiBwcm9ncmVzcyIKIG1zZ3N0ciAicmV2ZXJ0IHlhIGVzdMOhIGVuIHByb2dyZXNvIgogCi0jOiBzZXF1ZW5jZXIuYzoyNjcwCisjOiBzZXF1ZW5jZXIuYzoyNjA4CiAjLCBjLWZvcm1hdAogbXNnaWQgInRyeSBcImdpdCByZXZlcnQgKC0tY29udGludWUgfCAlcy0tYWJvcnQgfCAtLXF1aXQpXCIiCiBtc2dzdHIgImludGVudGEgXCJnaXQgcmV2ZXJ0ICgtLWNvbnRpbnVlIHwgLS1xdWl0IHwgJXMgLS1hYm9ydClcIiIKIAotIzogc2VxdWVuY2VyLmM6MjY3MworIzogc2VxdWVuY2VyLmM6MjYxMQogbXNnaWQgImNoZXJyeS1waWNrIGlzIGFscmVhZHkgaW4gcHJvZ3Jlc3MiCiBtc2dzdHIgImNoZXJyeS1waWNrIHlhIGVzdMOhIGVuIHByb2dyZXNvIgogCi0jOiBzZXF1ZW5jZXIuYzoyNjc1CisjOiBzZXF1ZW5jZXIuYzoyNjEzCiAjLCBjLWZvcm1hdAogbXNnaWQgInRyeSBcImdpdCBjaGVycnktcGljayAoLS1jb250aW51ZSB8ICVzLS1hYm9ydCB8IC0tcXVpdClcIiIKIG1zZ3N0ciAiaW50ZW50YSBcImdpdCBjaGVycnktcGljayAoLS1jb250aW51ZSB8IC0tcXVpdCB8ICVzIC0tYWJvcnQpXCIiCiAKLSM6IHNlcXVlbmNlci5jOjI2ODkKKyM6IHNlcXVlbmNlci5jOjI2MjcKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGNyZWF0ZSBzZXF1ZW5jZXIgZGlyZWN0b3J5ICclcyciCiBtc2dzdHIgIm5vIHNlIHB1ZG8gY3JlYXIgdW4gZGlyZWN0b3JpbyBzZWN1ZW5jaWFkb3IgJyVzJyIKIAotIzogc2VxdWVuY2VyLmM6MjcwNAorIzogc2VxdWVuY2VyLmM6MjY0MgogbXNnaWQgImNvdWxkIG5vdCBsb2NrIEhFQUQiCiBtc2dzdHIgIm5vIHNlIHB1ZG8gYmxvcXVlYXIgSEVBRCIKIAotIzogc2VxdWVuY2VyLmM6Mjc2NCBzZXF1ZW5jZXIuYzo0MTAzCisjOiBzZXF1ZW5jZXIuYzoyNzAyIHNlcXVlbmNlci5jOjQwNTcKIG1zZ2lkICJubyBjaGVycnktcGljayBvciByZXZlcnQgaW4gcHJvZ3Jlc3MiCiBtc2dzdHIgIm5pbmfDum4gY2hlcnJ5LXBpY2sgbyByZXZlcnQgZW4gcHJvZ3Jlc28iCiAKLSM6IHNlcXVlbmNlci5jOjI3NjYgc2VxdWVuY2VyLmM6Mjc3NworIzogc2VxdWVuY2VyLmM6MjcwNCBzZXF1ZW5jZXIuYzoyNzE1CiBtc2dpZCAiY2Fubm90IHJlc29sdmUgSEVBRCIKIG1zZ3N0ciAibm8gc2UgcHVlZGUgcmVzb2x2ZXIgSEVBRCIKIAotIzogc2VxdWVuY2VyLmM6Mjc2OCBzZXF1ZW5jZXIuYzoyODEyCisjOiBzZXF1ZW5jZXIuYzoyNzA2IHNlcXVlbmNlci5jOjI3NTAKIG1zZ2lkICJjYW5ub3QgYWJvcnQgZnJvbSBhIGJyYW5jaCB5ZXQgdG8gYmUgYm9ybiIKIG1zZ3N0ciAibm8gc2UgcHVlZGUgYWJvcnRhciBkZSB1bmEgcmFtYSBwb3IgbmFjZXIiCiAKLSM6IHNlcXVlbmNlci5jOjI3OTggYnVpbHRpbi9ncmVwLmM6NzM0CisjOiBzZXF1ZW5jZXIuYzoyNzM2IGJ1aWx0aW4vZ3JlcC5jOjczNgogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3Qgb3BlbiAnJXMnIgogbXNnc3RyICJubyBzZSBwdWVkZSBhYnJpciAnJXMnIgogCi0jOiBzZXF1ZW5jZXIuYzoyODAwCisjOiBzZXF1ZW5jZXIuYzoyNzM4CiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCByZWFkICclcyc6ICVzIgogbXNnc3RyICJubyBzZSBwdWVkZSBsZWVyICclcyc6ICVzIgogCi0jOiBzZXF1ZW5jZXIuYzoyODAxCisjOiBzZXF1ZW5jZXIuYzoyNzM5CiBtc2dpZCAidW5leHBlY3RlZCBlbmQgb2YgZmlsZSIKIG1zZ3N0ciAiZmluYWwgZGUgYXJjaGl2byBpbmVzcGVyYWRvIgogCi0jOiBzZXF1ZW5jZXIuYzoyODA3CisjOiBzZXF1ZW5jZXIuYzoyNzQ1CiAjLCBjLWZvcm1hdAogbXNnaWQgInN0b3JlZCBwcmUtY2hlcnJ5LXBpY2sgSEVBRCBmaWxlICclcycgaXMgY29ycnVwdCIKIG1zZ3N0ciAiYXJjaGl2byBIRUFEIGRlIHByZS1jaGVycnktcGljayBndWFyZGFkb8KgJyVzJyBlc3TDoSBjb3JydXB0byIKIAotIzogc2VxdWVuY2VyLmM6MjgxOAorIzogc2VxdWVuY2VyLmM6Mjc1NgogbXNnaWQgIllvdSBzZWVtIHRvIGhhdmUgbW92ZWQgSEVBRC4gTm90IHJld2luZGluZywgY2hlY2sgeW91ciBIRUFEISIKLW1zZ3N0ciAiUGFyZWNlIHF1ZSBzZSBoYSBtb3ZpZG8gSEVBRC4gTm8gc2UgaGFjZSByZWJvYmluYWRvLCByZXZpc2EgdHUgSEVBRCEiCittc2dzdHIgIlBhcmVjZSBxdWUgc2UgaGEgbW92aWRvIEhFQUQuIE5vIHNlIGhhY2UgcmVib2JpbmFkbywgwqFyZXZpc2EgdHUgSEVBRCEiCiAKLSM6IHNlcXVlbmNlci5jOjI4NTkKKyM6IHNlcXVlbmNlci5jOjI3OTcKIG1zZ2lkICJubyByZXZlcnQgaW4gcHJvZ3Jlc3MiCiBtc2dzdHIgIm5vIGhheSByZXZlcnQgZW4gcHJvZ3Jlc28iCiAKLSM6IHNlcXVlbmNlci5jOjI4NjcKKyM6IHNlcXVlbmNlci5jOjI4MDUKIG1zZ2lkICJubyBjaGVycnktcGljayBpbiBwcm9ncmVzcyIKIG1zZ3N0ciAibmluZ8O6biBjaGVycnktcGljayBlbiBwcm9ncmVzbyIKIAotIzogc2VxdWVuY2VyLmM6Mjg3NworIzogc2VxdWVuY2VyLmM6MjgxNQogbXNnaWQgImZhaWxlZCB0byBza2lwIHRoZSBjb21taXQiCiBtc2dzdHIgImZhbGzDsyBhbCBlc2NyaWJpciBlbCBjb21taXQiCiAKLSM6IHNlcXVlbmNlci5jOjI4ODQKKyM6IHNlcXVlbmNlci5jOjI4MjIKIG1zZ2lkICJ0aGVyZSBpcyBub3RoaW5nIHRvIHNraXAiCiBtc2dzdHIgIm5vIGhheSBuYWRhIHF1ZSBzYWx0YXIiCiAKLSM6IHNlcXVlbmNlci5jOjI4ODcKKyM6IHNlcXVlbmNlci5jOjI4MjUKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogImhhdmUgeW91IGNvbW1pdHRlZCBhbHJlYWR5P1xuIgpAQCAtNjMxOSwyMSArNjM0MywyMSBAQAogIsK/eWEgaGFzIGhlY2hvIGVsIGNvbW1pdD9cbiIKICJpbnRlbnRhIFwiZ2l0ICVzIC0tY29udGludWVcIiIKIAotIzogc2VxdWVuY2VyLmM6MzAxMSBzZXF1ZW5jZXIuYzo0MDE1CisjOiBzZXF1ZW5jZXIuYzoyOTQ5IHNlcXVlbmNlci5jOjM5NjkKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHVwZGF0ZSAlcyIKIG1zZ3N0ciAibm8gc2UgcHVlZGUgYWN0dWFsaXphciAlcyIKIAotIzogc2VxdWVuY2VyLmM6MzA0OSBzZXF1ZW5jZXIuYzozOTk1CisjOiBzZXF1ZW5jZXIuYzoyOTg3IHNlcXVlbmNlci5jOjM5NDkKIG1zZ2lkICJjYW5ub3QgcmVhZCBIRUFEIgogbXNnc3RyICJubyBzZSBwdWVkZSBsZWVyIEhFQUQiCiAKLSM6IHNlcXVlbmNlci5jOjMwNjYKKyM6IHNlcXVlbmNlci5jOjMwMDQKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGNvcHkgJyVzJyB0byAnJXMnIgogbXNnc3RyICJubyBzZSBwdWRvIGNvcGlhciAnJXMnIGEgJyVzJyIKIAotIzogc2VxdWVuY2VyLmM6MzA3NAorIzogc2VxdWVuY2VyLmM6MzAxMgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiWW91IGNhbiBhbWVuZCB0aGUgY29tbWl0IG5vdywgd2l0aFxuIgpAQCAtNjM1MiwyNyArNjM3NiwyNyBAQAogIlxuIgogIlx0Z2l0IHJlYmFzZSAtLWNvbnRpbnVlXG4iCiAKLSM6IHNlcXVlbmNlci5jOjMwODQKKyM6IHNlcXVlbmNlci5jOjMwMjIKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ291bGQgbm90IGFwcGx5ICVzLi4uICUuKnMiCiBtc2dzdHIgIk5vIHNlIHB1ZG8gYXBsaWNhciAlcy4uLiAlLipzIgogCi0jOiBzZXF1ZW5jZXIuYzozMDkxCisjOiBzZXF1ZW5jZXIuYzozMDI5CiAjLCBjLWZvcm1hdAogbXNnaWQgIkNvdWxkIG5vdCBtZXJnZSAlLipzIgogbXNnc3RyICJObyBzZSBwdWRvIGZ1c2lvbmFyICUuKnMiCiAKLSM6IHNlcXVlbmNlci5jOjMxMDUgc2VxdWVuY2VyLmM6MzEwOSBidWlsdGluL2RpZmZ0b29sLmM6NjMzCisjOiBzZXF1ZW5jZXIuYzozMDQzIHNlcXVlbmNlci5jOjMwNDcgYnVpbHRpbi9kaWZmdG9vbC5jOjY0MQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgY29weSAnJXMnIHRvICclcyciCiBtc2dzdHIgIm5vIHNlIHB1ZG8gY29waWFyICclcycgYSAnJXMnIgogCi0jOiBzZXF1ZW5jZXIuYzozMTMxIHNlcXVlbmNlci5jOjM1NTggYnVpbHRpbi9yZWJhc2UuYzo4NDkgYnVpbHRpbi9yZWJhc2UuYzoxNTgyCi0jOiBidWlsdGluL3JlYmFzZS5jOjE5NTMgYnVpbHRpbi9yZWJhc2UuYzoyMDA4CisjOiBzZXF1ZW5jZXIuYzozMDY5IHNlcXVlbmNlci5jOjM1MDYgYnVpbHRpbi9yZWJhc2UuYzo4NTAgYnVpbHRpbi9yZWJhc2UuYzoxNjEzCisjOiBidWlsdGluL3JlYmFzZS5jOjE5ODcgYnVpbHRpbi9yZWJhc2UuYzoyMDMxCiBtc2dpZCAiY291bGQgbm90IHJlYWQgaW5kZXgiCiBtc2dzdHIgIm5vIHNlIHB1ZG8gbGVlciDDrW5kaWNlIgogCi0jOiBzZXF1ZW5jZXIuYzozMTM2CisjOiBzZXF1ZW5jZXIuYzozMDc0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJleGVjdXRpb24gZmFpbGVkOiAlc1xuIgpAQCAtNjM4NywxMSArNjQxMSwxMSBAQAogIiAgZ2l0IHJlYmFzZSAtLWNvbnRpbnVlXG4iCiAiXG4iCiAKLSM6IHNlcXVlbmNlci5jOjMxNDIKKyM6IHNlcXVlbmNlci5jOjMwODAKIG1zZ2lkICJhbmQgbWFkZSBjaGFuZ2VzIHRvIHRoZSBpbmRleCBhbmQvb3IgdGhlIHdvcmtpbmcgdHJlZVxuIgogbXNnc3RyICJ5IHNlIGhpY2llcm9uIGNhbWJpb3MgYWwgw61uZGljZSB5L28gw6FyYm9sIGRlIHRyYWJham9cbiIKIAotIzogc2VxdWVuY2VyLmM6MzE0OAorIzogc2VxdWVuY2VyLmM6MzA4NgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiZXhlY3V0aW9uIHN1Y2NlZWRlZDogJXNcbiIKQEAgLTY0MDgsNzYgKzY0MzIsNzYgQEAKICIgIGdpdCByZWJhc2UgLS1jb250aW51ZVxuIgogIlxuIgogCi0jOiBzZXF1ZW5jZXIuYzozMjA5CisjOiBzZXF1ZW5jZXIuYzozMTQ3CiAjLCBjLWZvcm1hdAogbXNnaWQgImlsbGVnYWwgbGFiZWwgbmFtZTogJyUuKnMnIgogbXNnc3RyICJub21icmUgZGUgbGFiZWwgaWxlZ2FsOiAnJS4qcyciCiAKLSM6IHNlcXVlbmNlci5jOjMyNjMKKyM6IHNlcXVlbmNlci5jOjMyMDEKIG1zZ2lkICJ3cml0aW5nIGZha2Ugcm9vdCBjb21taXQiCiBtc2dzdHIgImVzY3JpYmllbmRvIGNvbW1pdCByYcOteiBmYWxzbyIKIAotIzogc2VxdWVuY2VyLmM6MzI2OAorIzogc2VxdWVuY2VyLmM6MzIwNgogbXNnaWQgIndyaXRpbmcgc3F1YXNoLW9udG8iCiBtc2dzdHIgImVzY3JpYmllbmRvIHNxdWFzaC1vbnRvIgogCi0jOiBzZXF1ZW5jZXIuYzozMzA2IGJ1aWx0aW4vcmViYXNlLmM6ODU0IGJ1aWx0aW4vcmViYXNlLmM6ODYwCisjOiBzZXF1ZW5jZXIuYzozMjQ0IGJ1aWx0aW4vcmViYXNlLmM6ODU1IGJ1aWx0aW4vcmViYXNlLmM6ODYxCiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBmaW5kIHRyZWUgb2YgJXMiCiBtc2dzdHIgImZhbGzDsyBhbCBlbmNvbnRyYXIgw6FyYm9sIGRlICVzIgogCi0jOiBzZXF1ZW5jZXIuYzozMzI0IGJ1aWx0aW4vcmViYXNlLmM6ODczCisjOiBzZXF1ZW5jZXIuYzozMjYyIGJ1aWx0aW4vcmViYXNlLmM6ODc0CiBtc2dpZCAiY291bGQgbm90IHdyaXRlIGluZGV4IgogbXNnc3RyICJubyBzZSBwdWRvIGVzY3JpYmlyIMOtbmRpY2UiCiAKLSM6IHNlcXVlbmNlci5jOjMzNTEKKyM6IHNlcXVlbmNlci5jOjMyODkKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHJlc29sdmUgJyVzJyIKIG1zZ3N0ciAibm8gc2UgcHVkbyByZXNvbHZlciAnJXMnIgogCi0jOiBzZXF1ZW5jZXIuYzozMzc5CisjOiBzZXF1ZW5jZXIuYzozMzIwCiBtc2dpZCAiY2Fubm90IG1lcmdlIHdpdGhvdXQgYSBjdXJyZW50IHJldmlzaW9uIgogbXNnc3RyICJubyBzZSBwdWVkZSBmdXNpb25hciBzaW4gdW5hIHZlcnNpw7NuIGFjdHVhbCIKIAotIzogc2VxdWVuY2VyLmM6MzQwMQorIzogc2VxdWVuY2VyLmM6MzM0MgogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gcGFyc2UgJyUuKnMnIgogbXNnc3RyICJubyBzZSBwdWVkZSBhbmFsaXphciAnJS4qcyciCiAKLSM6IHNlcXVlbmNlci5jOjM0MTAKKyM6IHNlcXVlbmNlci5jOjMzNTEKICMsIGMtZm9ybWF0CiBtc2dpZCAibm90aGluZyB0byBtZXJnZTogJyUuKnMnIgogbXNnc3RyICJuYWRhIHBhcmEgZnVzaW9uYXI6ICclLipzJyIKIAotIzogc2VxdWVuY2VyLmM6MzQyMgorIzogc2VxdWVuY2VyLmM6MzM2MwogbXNnaWQgIm9jdG9wdXMgbWVyZ2UgY2Fubm90IGJlIGV4ZWN1dGVkIG9uIHRvcCBvZiBhIFtuZXcgcm9vdF0iCiBtc2dzdHIgImZ1c2nDs24gb2N0b3B1cyBubyBwdWVkZSBzZXIgZWplY3V0YWRhIGVuIGxhIHB1bnRhIGRlIHVuIFtudWV2byByb290XSIKIAotIzogc2VxdWVuY2VyLmM6MzQzNworIzogc2VxdWVuY2VyLmM6MzM3OAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgZ2V0IGNvbW1pdCBtZXNzYWdlIG9mICclcyciCiBtc2dzdHIgIm5vIHNlIHB1ZWRlIGxlZXIgZWwgbWVuc2FqZSBkZWwgY29tbWl0ICclcyciCiAKLSM6IHNlcXVlbmNlci5jOjM1OTAKKyM6IHNlcXVlbmNlci5jOjM1MzgKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGV2ZW4gYXR0ZW1wdCB0byBtZXJnZSAnJS4qcyciCiBtc2dzdHIgIm5vIHNlIHB1ZG8gaW50ZW50YXIgZnVzaW9uYXIgJyUuKnMnIgogCi0jOiBzZXF1ZW5jZXIuYzozNjA2CisjOiBzZXF1ZW5jZXIuYzozNTU0CiBtc2dpZCAibWVyZ2U6IFVuYWJsZSB0byB3cml0ZSBuZXcgaW5kZXggZmlsZSIKIG1zZ3N0ciAiZnVzacOzbjogTm8gc2UgcHVlZGUgZXNjcmliaXIgZWwgbnVldm8gYXJjaGl2byDDrW5kaWNlIgogCi0jOiBzZXF1ZW5jZXIuYzozNjc1IGJ1aWx0aW4vcmViYXNlLmM6NzExCisjOiBzZXF1ZW5jZXIuYzozNjIzIGJ1aWx0aW4vcmViYXNlLmM6NzEyCiAjLCBjLWZvcm1hdAogbXNnaWQgIkFwcGxpZWQgYXV0b3N0YXNoLlxuIgogbXNnc3RyICJBdXRvc3Rhc2ggYXBsaWNhZG8uXG4iCiAKLSM6IHNlcXVlbmNlci5jOjM2ODcKKyM6IHNlcXVlbmNlci5jOjM2MzUKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IHN0b3JlICVzIgogbXNnc3RyICJubyBzZSBwdWVkZSBndWFyZGFyICVzIgogCi0jOiBzZXF1ZW5jZXIuYzozNjkwIGJ1aWx0aW4vcmViYXNlLmM6NzI3IGdpdC1yZWJhc2UtLXByZXNlcnZlLW1lcmdlcy5zaDoxMTMKKyM6IHNlcXVlbmNlci5jOjM2MzggYnVpbHRpbi9yZWJhc2UuYzo3MjggZ2l0LXJlYmFzZS0tcHJlc2VydmUtbWVyZ2VzLnNoOjExMwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiQXBwbHlpbmcgYXV0b3N0YXNoIHJlc3VsdGVkIGluIGNvbmZsaWN0cy5cbiIKQEAgLTY0ODksMzEgKzY1MTMsMzEgQEAKICJQdWVkZXMgZWplY3V0YXIgXCJnaXQgc3Rhc2ggcG9wXCIgbyBcImdpdCBzdGFzaCBkcm9wXCIgZW4gY3VhbHF1aWVyICIKICJtb21lbnRvLlxuIgogCi0jOiBzZXF1ZW5jZXIuYzozNzUxCisjOiBzZXF1ZW5jZXIuYzozNjk5CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBjaGVja291dCAlcyIKIG1zZ3N0ciAibm8gc2UgcHVlZGUgaGFjZXIgY2hlY2tvdXQgYSAlcyIKIAotIzogc2VxdWVuY2VyLmM6Mzc2NQorIzogc2VxdWVuY2VyLmM6MzcxMwogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogbm90IGEgdmFsaWQgT0lEIgogbXNnc3RyICIlcyBubyBlcyBPSUQgdsOhbGlkbyIKIAotIzogc2VxdWVuY2VyLmM6Mzc3MCBnaXQtcmViYXNlLS1wcmVzZXJ2ZS1tZXJnZXMuc2g6Nzc5CisjOiBzZXF1ZW5jZXIuYzozNzE4IGdpdC1yZWJhc2UtLXByZXNlcnZlLW1lcmdlcy5zaDo3NzkKIG1zZ2lkICJjb3VsZCBub3QgZGV0YWNoIEhFQUQiCiBtc2dzdHIgIm5vIHNlIHB1ZWRlIGRlc2Fjb3BsYXIgSEVBRCIKIAotIzogc2VxdWVuY2VyLmM6Mzc4NQorIzogc2VxdWVuY2VyLmM6MzczMwogIywgYy1mb3JtYXQKIG1zZ2lkICJTdG9wcGVkIGF0IEhFQURcbiIKIG1zZ3N0ciAiRGV0ZW5pZG8gZW4gSEVBRFxuIgogCi0jOiBzZXF1ZW5jZXIuYzozNzg3CisjOiBzZXF1ZW5jZXIuYzozNzM1CiAjLCBjLWZvcm1hdAogbXNnaWQgIlN0b3BwZWQgYXQgJXNcbiIKIG1zZ3N0ciAiRGV0ZW5pZG8gZW4gJXNcbiIKIAotIzogc2VxdWVuY2VyLmM6Mzc5NQorIzogc2VxdWVuY2VyLmM6Mzc0MwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiQ291bGQgbm90IGV4ZWN1dGUgdGhlIHRvZG8gY29tbWFuZFxuIgpAQCAtNjUzNCw0OCArNjU1OCw0OCBAQAogIiAgICBnaXQgcmViYXNlIC0tZWRpdC10b2RvXG4iCiAiICAgIGdpdCByZWJhc2UgLS1jb250aW51ZVxuIgogCi0jOiBzZXF1ZW5jZXIuYzozODc3CisjOiBzZXF1ZW5jZXIuYzozODI3CiAjLCBjLWZvcm1hdAogbXNnaWQgIlN0b3BwZWQgYXQgJXMuLi4gICUuKnNcbiIKIG1zZ3N0ciAiRGV0ZW5pZG8gZW4gJXMuLi4gICUuKnNcbiIKIAotIzogc2VxdWVuY2VyLmM6Mzk1OAorIzogc2VxdWVuY2VyLmM6Mzg5OAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmtub3duIGNvbW1hbmQgJWQiCiBtc2dzdHIgImNvbWFuZG8gZGVzY29ub2NpZG8gJWQiCiAKLSM6IHNlcXVlbmNlci5jOjQwMDMKKyM6IHNlcXVlbmNlci5jOjM5NTcKIG1zZ2lkICJjb3VsZCBub3QgcmVhZCBvcmlnLWhlYWQiCiBtc2dzdHIgIm5vIHNlIHB1ZWRlIGxlZXIgb3JpZy1oZWFkIgogCi0jOiBzZXF1ZW5jZXIuYzo0MDA4CisjOiBzZXF1ZW5jZXIuYzozOTYyCiBtc2dpZCAiY291bGQgbm90IHJlYWQgJ29udG8nIgogbXNnc3RyICJubyBzZSBwdWVkZSBsZWVyICdvbnRvJyIKIAotIzogc2VxdWVuY2VyLmM6NDAyMgorIzogc2VxdWVuY2VyLmM6Mzk3NgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgdXBkYXRlIEhFQUQgdG8gJXMiCiBtc2dzdHIgIm5vIHNlIHB1ZWRlIGFjdHVhbGl6YXIgSEVBRCBhICVzIgogCi0jOiBzZXF1ZW5jZXIuYzo0MTE1CisjOiBzZXF1ZW5jZXIuYzo0MDY5CiBtc2dpZCAiY2Fubm90IHJlYmFzZTogWW91IGhhdmUgdW5zdGFnZWQgY2hhbmdlcy4iCiBtc2dzdHIgIm5vIHNlIHB1ZWRlIHJlYWxpemFyIHJlYmFzZTogVGllbmVzIGNhbWJpb3MgZnVlcmEgZGVsIMOhcmVhIGRlIHN0YWdlLiIKIAotIzogc2VxdWVuY2VyLmM6NDEyNAorIzogc2VxdWVuY2VyLmM6NDA3OAogbXNnaWQgImNhbm5vdCBhbWVuZCBub24tZXhpc3RpbmcgY29tbWl0IgogbXNnc3RyICJubyBzZSBwdWVkZSBhcnJlZ2xhciB1biBjb21taXQgbm8gZXhpc3RlbnRlIgogCi0jOiBzZXF1ZW5jZXIuYzo0MTI2CisjOiBzZXF1ZW5jZXIuYzo0MDgwCiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgZmlsZTogJyVzJyIKIG1zZ3N0ciAiYXJjaGl2byBpbnbDoWxpZG86ICclcyciCiAKLSM6IHNlcXVlbmNlci5jOjQxMjgKKyM6IHNlcXVlbmNlci5jOjQwODIKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBjb250ZW50czogJyVzJyIKIG1zZ3N0ciAiY29udGVuaWRvIGludsOhbGlkbzogJyVzJyIKIAotIzogc2VxdWVuY2VyLmM6NDEzMQorIzogc2VxdWVuY2VyLmM6NDA4NQogbXNnaWQgIiIKICJcbiIKICJZb3UgaGF2ZSB1bmNvbW1pdHRlZCBjaGFuZ2VzIGluIHlvdXIgd29ya2luZyB0cmVlLiBQbGVhc2UsIGNvbW1pdCB0aGVtXG4iCkBAIC02NTg2LDQyICs2NjEwLDQyIEBACiAidW4gY29tbWl0IGNvbiBlc3Rvc1xuIgogInByaW1lcm8geSBsdWVnbyBlamVjdXRhICdnaXQgcmViYXNlIC0tY29udGludWUnIGRlIG51ZXZvLiIKIAotIzogc2VxdWVuY2VyLmM6NDE2NyBzZXF1ZW5jZXIuYzo0MjA1CisjOiBzZXF1ZW5jZXIuYzo0MTIxIHNlcXVlbmNlci5jOjQxNTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHdyaXRlIGZpbGU6ICclcyciCiBtc2dzdHIgIm5vIHNlIHB1ZG8gZXNjcmliaXIgZWwgYXJjaGl2bzogJyVzJyIKIAotIzogc2VxdWVuY2VyLmM6NDIyMAorIzogc2VxdWVuY2VyLmM6NDE3NAogbXNnaWQgImNvdWxkIG5vdCByZW1vdmUgQ0hFUlJZX1BJQ0tfSEVBRCIKIG1zZ3N0ciAibm8gc2UgcHVlZGUgZWxpbWluYXIgQ0hFUlJZX1BJQ0tfSEVBRCIKIAotIzogc2VxdWVuY2VyLmM6NDIyNworIzogc2VxdWVuY2VyLmM6NDE4MQogbXNnaWQgImNvdWxkIG5vdCBjb21taXQgc3RhZ2VkIGNoYW5nZXMuIgogbXNnc3RyICJubyBzZSBwdWRvIHJlYWxpemFyIGVsIGNvbW1pdCBjb24gbG9zIGNhbWJpb3MgZW4gZWwgw6FyZWEgZGUgc3RhZ2UuIgogCi0jOiBzZXF1ZW5jZXIuYzo0MzI4CisjOiBzZXF1ZW5jZXIuYzo0Mjg1CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiBjYW4ndCBjaGVycnktcGljayBhICVzIgogbXNnc3RyICIlczogbm8gc2UgcHVlZGUgYXBsaWNhciBjaGVycnktcGljayBhIHVuICVzIgogCi0jOiBzZXF1ZW5jZXIuYzo0MzMyCisjOiBzZXF1ZW5jZXIuYzo0Mjg5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiBiYWQgcmV2aXNpb24iCiBtc2dzdHIgIiVzOiByZXZpc2nDs24gZXJyw7NuZWEiCiAKLSM6IHNlcXVlbmNlci5jOjQzNjcKKyM6IHNlcXVlbmNlci5jOjQzMjQKIG1zZ2lkICJjYW4ndCByZXZlcnQgYXMgaW5pdGlhbCBjb21taXQiCiBtc2dzdHIgIm5vIHNlIHB1ZWRlIHJldmVydGlyIGNvbW8gY29tbWl0IGluaWNpYWwiCiAKLSM6IHNlcXVlbmNlci5jOjQ4MTAKKyM6IHNlcXVlbmNlci5jOjQ3NzQKIG1zZ2lkICJtYWtlX3NjcmlwdDogdW5oYW5kbGVkIG9wdGlvbnMiCiBtc2dzdHIgIm1ha2Vfc2NyaXB0OiBvcGNpb25lcyBkZXNjb25vY2lkYXMiCiAKLSM6IHNlcXVlbmNlci5jOjQ4MTMKKyM6IHNlcXVlbmNlci5jOjQ3NzcKIG1zZ2lkICJtYWtlX3NjcmlwdDogZXJyb3IgcHJlcGFyaW5nIHJldmlzaW9ucyIKIG1zZ3N0ciAibWFrZV9zY3JpcHQ6IGVycm9yIHByZXBhcmFuZG8gcmV2aXNpb25lcyIKIAotIzogc2VxdWVuY2VyLmM6NDk3MQorIzogc2VxdWVuY2VyLmM6NDkzNQogbXNnaWQgIiIKICJZb3UgY2FuIGZpeCB0aGlzIHdpdGggJ2dpdCByZWJhc2UgLS1lZGl0LXRvZG8nIGFuZCB0aGVuIHJ1biAnZ2l0IHJlYmFzZSAtLSIKICJjb250aW51ZScuXG4iCkBAIC02NjMxLDI0ICs2NjU1LDI0IEBACiAicmViYXNlIC0tY29udGludWUnLlxuIgogIk8gc2UgcHVlZGUgYWJvcnRhciBlbCByZWJhc2UgY29uICdnaXQgcmViYXNlIC0tYWJvcnQnLlxuIgogCi0jOiBzZXF1ZW5jZXIuYzo1MDgzIHNlcXVlbmNlci5jOjUxMDAKKyM6IHNlcXVlbmNlci5jOjUwNDcgc2VxdWVuY2VyLmM6NTA2NAogbXNnaWQgIm5vdGhpbmcgdG8gZG8iCiBtc2dzdHIgIm5hZGEgcXVlIGhhY2VyIgogCi0jOiBzZXF1ZW5jZXIuYzo1MTE0CisjOiBzZXF1ZW5jZXIuYzo1MDc4CiBtc2dpZCAiY291bGQgbm90IHNraXAgdW5uZWNlc3NhcnkgcGljayBjb21tYW5kcyIKIG1zZ3N0ciAibm8gc2UgcHVkbyBzYWx0YXIgbG9zIGNvbWFuZG9zIHBpY2sgaW5uZWNlc2FyaW9zIgogCi0jOiBzZXF1ZW5jZXIuYzo1MTk3CisjOiBzZXF1ZW5jZXIuYzo1MTY2CiBtc2dpZCAidGhlIHNjcmlwdCB3YXMgYWxyZWFkeSByZWFycmFuZ2VkLiIKIG1zZ3N0ciAiZXN0ZSBzY3JpcHQgeWEgZnVlIHJlb3JnYW5pemFkby4iCiAKLSM6IHNldHVwLmM6MTIzCisjOiBzZXR1cC5jOjEyNAogIywgYy1mb3JtYXQKIG1zZ2lkICInJXMnIGlzIG91dHNpZGUgcmVwb3NpdG9yeSIKIG1zZ3N0ciAiJyVzJyBlc3TDoSBmdWVyYSBkZWwgcmVwb3NpdG9yaW8iCiAKLSM6IHNldHVwLmM6MTczCisjOiBzZXR1cC5jOjE3NAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiJXM6IG5vIHN1Y2ggcGF0aCBpbiB0aGUgd29ya2luZyB0cmVlLlxuIgpAQCAtNjY1OCw3ICs2NjgyLDcgQEAKICJVc2UgJ2dpdCA8Y29tYW5kbz4gLS0gPHJ1dGE+Li4uJyBwYXJhIGVzcGVjaWZpY2FyIHJ1dGFzIHF1ZSBubyBleGlzdGVuICIKICJsb2NhbG1lbnRlLiIKIAotIzogc2V0dXAuYzoxODYKKyM6IHNldHVwLmM6MTg3CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJhbWJpZ3VvdXMgYXJndW1lbnQgJyVzJzogdW5rbm93biByZXZpc2lvbiBvciBwYXRoIG5vdCBpbiB0aGUgd29ya2luZyB0cmVlLlxuIgpAQCAtNjY3MCwxMiArNjY5NCwxMiBAQAogIlVzZSAnLS0nIHBhcmEgc2VwYXJhciBsYXMgcnV0YXMgZGUgbGFzIHJldmlzaW9uZXMsIGRlIGVzdGEgbWFuZXJhOlxuIgogIidnaXQgPGNvbWFuZG8+IFs8cmV2aXNpw7NuPi4uLl0gLS0gWzxhcmNoaXZvPi4uLl0nIgogCi0jOiBzZXR1cC5jOjIzNQorIzogc2V0dXAuYzoyMzYKICMsIGMtZm9ybWF0CiBtc2dpZCAib3B0aW9uICclcycgbXVzdCBjb21lIGJlZm9yZSBub24tb3B0aW9uIGFyZ3VtZW50cyIKIG1zZ3N0ciAib3BjacOzbiAnJXMnIGRlYmUgdmVuaXIgYW50ZXMgZGUgYXJndW1lbnRvcyBubyBvcGNpb25hbGVzIgogCi0jOiBzZXR1cC5jOjI1NAorIzogc2V0dXAuYzoyNTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogImFtYmlndW91cyBhcmd1bWVudCAnJXMnOiBib3RoIHJldmlzaW9uIGFuZCBmaWxlbmFtZVxuIgpAQCAtNjY4Niw5NSArNjcxMCw5NSBAQAogIlVzZSAnLS0nIHBhcmEgc2VwYXJhciBydXRhcyBkZSByZXZpc2lvbmVzLCBkZSBlc3RhIG1hbmVyYTpcbiIKICInZ2l0IDxjb21hbmRvPiBbPHJldmlzacOzbj4uLi5dIC0tIFs8YXJjaGl2bz4uLi5dJyIKIAotIzogc2V0dXAuYzozOTAKKyM6IHNldHVwLmM6MzkxCiBtc2dpZCAidW5hYmxlIHRvIHNldCB1cCB3b3JrIHRyZWUgdXNpbmcgaW52YWxpZCBjb25maWciCiBtc2dzdHIgIiIKICJubyBlcyBwb3NpYmxlIGNvbmZpZ3VyYXIgZWwgZGlyZWN0b3JpbyBkZSB0cmFiYWpvIHVzYW5kbyB1bmEgY29uZmlndXJhY2nDs24gIgogImludsOhbGlkYSIKIAotIzogc2V0dXAuYzozOTQKKyM6IHNldHVwLmM6Mzk1CiBtc2dpZCAidGhpcyBvcGVyYXRpb24gbXVzdCBiZSBydW4gaW4gYSB3b3JrIHRyZWUiCiBtc2dzdHIgImVzdGEgb3BlcmFjacOzbiBkZWJlIHNlciByZWFsaXphZGEgZW4gdW4gw6FyYm9sIGRlIHRyYWJham8iCiAKLSM6IHNldHVwLmM6NTQwCisjOiBzZXR1cC5jOjU0MQogIywgYy1mb3JtYXQKIG1zZ2lkICJFeHBlY3RlZCBnaXQgcmVwbyB2ZXJzaW9uIDw9ICVkLCBmb3VuZCAlZCIKIG1zZ3N0ciAiU2UgZXNwZXJhYmEgdmVyc2nDs24gZGUgZ2l0IHJlcG8gIDw9ICVkLCBlbmNvbnRyYWRhICVkIgogCi0jOiBzZXR1cC5jOjU0OAorIzogc2V0dXAuYzo1NDkKIG1zZ2lkICJ1bmtub3duIHJlcG9zaXRvcnkgZXh0ZW5zaW9ucyBmb3VuZDoiCiBtc2dzdHIgInNlIGVuY29udHLDsyBleHRlbnNpw7NuIGRlIHJlcG9zaXRvcmlvIGRlc2Nvbm9jaWRhOiIKIAotIzogc2V0dXAuYzo1NjcKKyM6IHNldHVwLmM6NTY4CiAjLCBjLWZvcm1hdAogbXNnaWQgImVycm9yIG9wZW5pbmcgJyVzJyIKIG1zZ3N0ciAiZXJyb3IgYWJyaWVuZG8gJyVzJyIKIAotIzogc2V0dXAuYzo1NjkKKyM6IHNldHVwLmM6NTcwCiAjLCBjLWZvcm1hdAogbXNnaWQgInRvbyBsYXJnZSB0byBiZSBhIC5naXQgZmlsZTogJyVzJyIKIG1zZ3N0ciAibXV5IGdyYW5kZSBwYXJhIHNlciB1biBhcmNoaXZvIC5naXQ6ICclcyciCiAKLSM6IHNldHVwLmM6NTcxCisjOiBzZXR1cC5jOjU3MgogIywgYy1mb3JtYXQKIG1zZ2lkICJlcnJvciByZWFkaW5nICVzIgogbXNnc3RyICJlcnJvciBsZXllbmRvICVzIgogCi0jOiBzZXR1cC5jOjU3MworIzogc2V0dXAuYzo1NzQKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBnaXRmaWxlIGZvcm1hdDogJXMiCiBtc2dzdHIgImZvcm1hdG8gZ2l0ZmlsZSBpbnbDoWxpZG86ICVzIgogCi0jOiBzZXR1cC5jOjU3NQorIzogc2V0dXAuYzo1NzYKICMsIGMtZm9ybWF0CiBtc2dpZCAibm8gcGF0aCBpbiBnaXRmaWxlOiAlcyIKIG1zZ3N0ciAibm8gaGF5IHJ1dGEgZW4gZ2l0ZmlsZTogJXMiCiAKLSM6IHNldHVwLmM6NTc3CisjOiBzZXR1cC5jOjU3OAogIywgYy1mb3JtYXQKIG1zZ2lkICJub3QgYSBnaXQgcmVwb3NpdG9yeTogJXMiCiBtc2dzdHIgIm5vIGVzIHVuIHJlcG9zaXRvcmlvIGdpdDogJXMiCiAKLSM6IHNldHVwLmM6Njc2CisjOiBzZXR1cC5jOjY3NwogIywgYy1mb3JtYXQKIG1zZ2lkICInJCVzJyB0b28gYmlnIgogbXNnc3RyICInJCVzJyBtdXkgZ3JhbmRlIgogCi0jOiBzZXR1cC5jOjY5MAorIzogc2V0dXAuYzo2OTEKICMsIGMtZm9ybWF0CiBtc2dpZCAibm90IGEgZ2l0IHJlcG9zaXRvcnk6ICclcyciCiBtc2dzdHIgIm5vIGVzIHVuIHJlcG9zaXRvcmlvIGdpdDogJyVzJyIKIAotIzogc2V0dXAuYzo3MTkgc2V0dXAuYzo3MjEgc2V0dXAuYzo3NTIKKyM6IHNldHVwLmM6NzIwIHNldHVwLmM6NzIyIHNldHVwLmM6NzUzCiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCBjaGRpciB0byAnJXMnIgogbXNnc3RyICJubyBzZSBwdWVkZSBhcGxpY2FyIGNoZGlyIGEgJyVzJyIKIAotIzogc2V0dXAuYzo3MjQgc2V0dXAuYzo3ODAgc2V0dXAuYzo3OTAgc2V0dXAuYzo4Mjkgc2V0dXAuYzo4MzcKKyM6IHNldHVwLmM6NzI1IHNldHVwLmM6NzgxIHNldHVwLmM6NzkxIHNldHVwLmM6ODMwIHNldHVwLmM6ODM4CiBtc2dpZCAiY2Fubm90IGNvbWUgYmFjayB0byBjd2QiCiBtc2dzdHIgIm5vIHNlIHB1ZWRlIHZvbHZlciBhIGN3ZCIKIAotIzogc2V0dXAuYzo4NTEKKyM6IHNldHVwLmM6ODUyCiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBzdGF0ICclKnMlcyVzJyIKIG1zZ3N0ciAiZmFsbMOzIGFsIGRldGVybWluYXIgJyUqcyVzJXMnIgogCi0jOiBzZXR1cC5jOjEwODMKKyM6IHNldHVwLmM6MTA5MAogbXNnaWQgIlVuYWJsZSB0byByZWFkIGN1cnJlbnQgd29ya2luZyBkaXJlY3RvcnkiCiBtc2dzdHIgIkluY2FwYXogZGUgbGVlciBlbCBkaXJlY3RvcmlvIGRlIHRyYWJham8gYWN0dWFsIgogCi0jOiBzZXR1cC5jOjEwOTIgc2V0dXAuYzoxMDk4CisjOiBzZXR1cC5jOjEwOTkgc2V0dXAuYzoxMTA1CiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCBjaGFuZ2UgdG8gJyVzJyIKIG1zZ3N0ciAibm8gc2UgcHVlZGUgY2FtYmlhciBhICclcyciCiAKLSM6IHNldHVwLmM6MTEwMworIzogc2V0dXAuYzoxMTEwCiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vdCBhIGdpdCByZXBvc2l0b3J5IChvciBhbnkgb2YgdGhlIHBhcmVudCBkaXJlY3Rvcmllcyk6ICVzIgogbXNnc3RyICIiCiAibm8gZXMgdW4gcmVwb3NpdG9yaW8gZ2l0IChuaSBuaW5ndW5vIGRlIGxvcyBkaXJlY3RvcmlvcyBzdXBlcmlvcmVzKTogJXMiCiAKLSM6IHNldHVwLmM6MTEwOQorIzogc2V0dXAuYzoxMTE2CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJub3QgYSBnaXQgcmVwb3NpdG9yeSAob3IgYW55IHBhcmVudCB1cCB0byBtb3VudCBwb2ludCAlcylcbiIKQEAgLTY3ODQsNyArNjgwOCw3IEBACiAiUGFyYW5kbyBlbiBlbCBsw61taXRlIGRlbCBzaXN0ZW1hIGRlIGFyY2hpdm9zICIKICIoR0lUX0RJU0NPVkVSWV9BQ1JPU1NfRklMRVNZU1RFTSBubyBlc3RhYmxlY2lkbykuIgogCi0jOiBzZXR1cC5jOjEyMjAKKyM6IHNldHVwLmM6MTIyNwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAicHJvYmxlbSB3aXRoIGNvcmUuc2hhcmVkUmVwb3NpdG9yeSBmaWxlbW9kZSB2YWx1ZSAoMCUuM28pLlxuIgpAQCAtNjc5MywyODYgKzY4MTcsMjg2IEBACiAicHJvYmxlbWEgY29uIGVsIHZhbG9yIGRlbCBtb2RvIGRlIGFyY2hpdm8gY29yZS5zaGFyZWRSZXBvc2l0b3J5ICgwJS4zbykuXG4iCiAiRWwgZHVlw7FvIGRlIGxvcyBhcmNoaXZvcyB0aWVuZSBxdWUgdGVuZXIgcGVybWlzb3MgZGUgbGVjdHVyYSB5IGVzY3JpdHVyYS4iCiAKLSM6IHNldHVwLmM6MTI2NAorIzogc2V0dXAuYzoxMjcxCiBtc2dpZCAib3BlbiAvZGV2L251bGwgb3IgZHVwIGZhaWxlZCIKIG1zZ3N0ciAiZmFsbMOzIGFsIGFicmlyIC9kZXYvbnVsbCBvIGR1cCIKIAotIzogc2V0dXAuYzoxMjc5CisjOiBzZXR1cC5jOjEyODYKIG1zZ2lkICJmb3JrIGZhaWxlZCIKIG1zZ3N0ciAiZmFsbMOzIGZvcmsiCiAKLSM6IHNldHVwLmM6MTI4NAorIzogc2V0dXAuYzoxMjkxCiBtc2dpZCAic2V0c2lkIGZhaWxlZCIKIG1zZ3N0ciAiZmFsbMOzIHNldHNpZCIKIAotIzogc2hhMS1maWxlLmM6NDUzCisjOiBzaGExLWZpbGUuYzo0NTIKICMsIGMtZm9ybWF0CiBtc2dpZCAib2JqZWN0IGRpcmVjdG9yeSAlcyBkb2VzIG5vdCBleGlzdDsgY2hlY2sgLmdpdC9vYmplY3RzL2luZm8vYWx0ZXJuYXRlcyIKIG1zZ3N0ciAib2JqZXRvIGRpcmVjdG9yaW8gJXMgbm8gZXhpc3RlOyByZXZpc2EgLmdpdC9vYmplY3RzL2luZm8vYWx0ZXJuYXRlcyIKIAotIzogc2hhMS1maWxlLmM6NTA0CisjOiBzaGExLWZpbGUuYzo1MDMKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIG5vcm1hbGl6ZSBhbHRlcm5hdGUgb2JqZWN0IHBhdGg6ICVzIgogbXNnc3RyICJpbmNhcGF6IGRlIG5vcm1hbGl6YXIgbGEgcnV0YSBkZSBvYmpldG8gYWx0ZXJubzogJXMiCiAKLSM6IHNoYTEtZmlsZS5jOjU3NgorIzogc2hhMS1maWxlLmM6NTc1CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiBpZ25vcmluZyBhbHRlcm5hdGUgb2JqZWN0IHN0b3JlcywgbmVzdGluZyB0b28gZGVlcCIKIG1zZ3N0ciAiJXM6IGlnbm9yYW5kbyBlc3BhY2lvcyBkZSBvYmpldG9zIGFsdGVybm9zLCBhbmlkYWRvIG11eSBwcm9mdW5kbyIKIAotIzogc2hhMS1maWxlLmM6NTgzCisjOiBzaGExLWZpbGUuYzo1ODIKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIG5vcm1hbGl6ZSBvYmplY3QgZGlyZWN0b3J5OiAlcyIKIG1zZ3N0ciAiaW5jYXBheiBkZSBub3JtYWxpemFyIGRpcmVjdG9yaW8gZGUgb2JqZXRvOiAlcyIKIAotIzogc2hhMS1maWxlLmM6NjI2CisjOiBzaGExLWZpbGUuYzo2MjUKIG1zZ2lkICJ1bmFibGUgdG8gZmRvcGVuIGFsdGVybmF0ZXMgbG9ja2ZpbGUiCiBtc2dzdHIgIm5vIGVzIHBvc2libGUgaGFjZXIgZmRvcGVuIGVuIGxvY2tmaWxlIGFsdGVybm9zIgogCi0jOiBzaGExLWZpbGUuYzo2NDQKKyM6IHNoYTEtZmlsZS5jOjY0MwogbXNnaWQgInVuYWJsZSB0byByZWFkIGFsdGVybmF0ZXMgZmlsZSIKIG1zZ3N0ciAibm8gZXMgcG9zaWJsZSBsZWVyIGFyY2hpdm9zIGFsdGVybm9zIgogCi0jOiBzaGExLWZpbGUuYzo2NTEKKyM6IHNoYTEtZmlsZS5jOjY1MAogbXNnaWQgInVuYWJsZSB0byBtb3ZlIG5ldyBhbHRlcm5hdGVzIGZpbGUgaW50byBwbGFjZSIKIG1zZ3N0ciAibm8gZXMgcG9zaWJsZSBtb3ZlciBhcmNoaXZvcyBhbHRlcm5vcyBlbiBlbCBsdWdhciIKIAotIzogc2hhMS1maWxlLmM6Njg2CisjOiBzaGExLWZpbGUuYzo2ODUKICMsIGMtZm9ybWF0CiBtc2dpZCAicGF0aCAnJXMnIGRvZXMgbm90IGV4aXN0IgogbXNnc3RyICJydXRhICclcycgbm8gZXhpc3RlIgogCi0jOiBzaGExLWZpbGUuYzo3MTIKKyM6IHNoYTEtZmlsZS5jOjcxMQogIywgYy1mb3JtYXQKIG1zZ2lkICJyZWZlcmVuY2UgcmVwb3NpdG9yeSAnJXMnIGFzIGEgbGlua2VkIGNoZWNrb3V0IGlzIG5vdCBzdXBwb3J0ZWQgeWV0LiIKIG1zZ3N0ciAiIgogInJlcG9zaXRvcmlvIGRlIHJlZmVyZW5jaWEgJyVzJyBjb21vIHVuIGNoZWNrb3V0IHZpbmN1bGFkbyBubyBlcyBzb3BvcnRhZG8gIgogInRvZGF2w61hLiIKIAotIzogc2hhMS1maWxlLmM6NzE4CisjOiBzaGExLWZpbGUuYzo3MTcKICMsIGMtZm9ybWF0CiBtc2dpZCAicmVmZXJlbmNlIHJlcG9zaXRvcnkgJyVzJyBpcyBub3QgYSBsb2NhbCByZXBvc2l0b3J5LiIKIG1zZ3N0ciAicmVwb3NpdG9yaW8gZGUgcmVmZXJlbmNpYSAnJXMnIG5vIGVzIHVuIHJlcG9zaXRvcmlvIGxvY2FsLiIKIAotIzogc2hhMS1maWxlLmM6NzI0CisjOiBzaGExLWZpbGUuYzo3MjMKICMsIGMtZm9ybWF0CiBtc2dpZCAicmVmZXJlbmNlIHJlcG9zaXRvcnkgJyVzJyBpcyBzaGFsbG93IgogbXNnc3RyICJyZXBvc2l0b3JpbyBkZSByZWZlcmVuY2lhICclcycgZXMgc3VwZXJmaWNpYWwgKHNoYWxsb3cpIgogCi0jOiBzaGExLWZpbGUuYzo3MzIKKyM6IHNoYTEtZmlsZS5jOjczMQogIywgYy1mb3JtYXQKIG1zZ2lkICJyZWZlcmVuY2UgcmVwb3NpdG9yeSAnJXMnIGlzIGdyYWZ0ZWQiCiBtc2dzdHIgInJlcG9zaXRvcmlvIGRlIHJlZmVyZW5jaWEgJyUgcycgZXN0w6EgaW5qZXJ0YWRvIgogCi0jOiBzaGExLWZpbGUuYzo3OTIKKyM6IHNoYTEtZmlsZS5jOjc5MQogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIGxpbmUgd2hpbGUgcGFyc2luZyBhbHRlcm5hdGUgcmVmczogJXMiCiBtc2dzdHIgImzDrW5lYSBpbnbDoWxpZGEgbWllbnRyYXMgc2UgYW5hbGl6YWJhbiByZWZzIGFsdGVybmFzOiAlcyIKIAotIzogc2hhMS1maWxlLmM6OTQ0CisjOiBzaGExLWZpbGUuYzo5NDMKICMsIGMtZm9ybWF0CiBtc2dpZCAiYXR0ZW1wdGluZyB0byBtbWFwICU8UFJJdU1BWD4gb3ZlciBsaW1pdCAlPFBSSXVNQVg+IgogbXNnc3RyICJpbnRlbnRhbmRvIHVzYXIgbW1hcCAlPFBSSXVNQVg+IHNvYnJlIGzDrW1pdGUgJTxQUkl1TUFYPiIKIAotIzogc2hhMS1maWxlLmM6OTY5CisjOiBzaGExLWZpbGUuYzo5NjQKIG1zZ2lkICJtbWFwIGZhaWxlZCIKIG1zZ3N0ciAibW1hcCBmYWxsw7MiCiAKLSM6IHNoYTEtZmlsZS5jOjExMzMKKyM6IHNoYTEtZmlsZS5jOjExMjgKICMsIGMtZm9ybWF0CiBtc2dpZCAib2JqZWN0IGZpbGUgJXMgaXMgZW1wdHkiCiBtc2dzdHIgImFyY2hpdm8gZGUgb2JqZXRvICVzIGVzdMOhIHZhY8OtbyIKIAotIzogc2hhMS1maWxlLmM6MTI1NyBzaGExLWZpbGUuYzoyMzk2CisjOiBzaGExLWZpbGUuYzoxMjUyIHNoYTEtZmlsZS5jOjIzOTIKICMsIGMtZm9ybWF0CiBtc2dpZCAiY29ycnVwdCBsb29zZSBvYmplY3QgJyVzJyIKIG1zZ3N0ciAib2JqZXRvIHBlcmRpZG8gY29ycnVwdG8gJyVzJyIKIAotIzogc2hhMS1maWxlLmM6MTI1OSBzaGExLWZpbGUuYzoyNDAwCisjOiBzaGExLWZpbGUuYzoxMjU0IHNoYTEtZmlsZS5jOjIzOTYKICMsIGMtZm9ybWF0CiBtc2dpZCAiZ2FyYmFnZSBhdCBlbmQgb2YgbG9vc2Ugb2JqZWN0ICclcyciCiBtc2dzdHIgImJhc3VyYSBhbCBmaW5hbCBkZWwgb2JqZXRvIHBlcmRpZG8gJyVzJyIKIAotIzogc2hhMS1maWxlLmM6MTMwMQorIzogc2hhMS1maWxlLmM6MTI5NgogbXNnaWQgImludmFsaWQgb2JqZWN0IHR5cGUiCiBtc2dzdHIgInRpcG8gZGUgb2JqZXRvIGludsOhbGlkbyIKIAotIzogc2hhMS1maWxlLmM6MTM4NQorIzogc2hhMS1maWxlLmM6MTM4MAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gdW5wYWNrICVzIGhlYWRlciB3aXRoIC0tYWxsb3ctdW5rbm93bi10eXBlIgogbXNnc3RyICJubyBlcyBwb3NpYmxlIGRlc2VtcGFjYXIgaGVhZGVyICVzIGNvbiAtLWFsbG93LXVua25vd24tdHlwZSIKIAotIzogc2hhMS1maWxlLmM6MTM4OAorIzogc2hhMS1maWxlLmM6MTM4MwogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gdW5wYWNrICVzIGhlYWRlciIKIG1zZ3N0ciAiaW5jYXBheiBkZSBkZXNlbXBhcXVldGFyIGhlYWRlciAlcyIKIAotIzogc2hhMS1maWxlLmM6MTM5NAorIzogc2hhMS1maWxlLmM6MTM4OQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gcGFyc2UgJXMgaGVhZGVyIHdpdGggLS1hbGxvdy11bmtub3duLXR5cGUiCiBtc2dzdHIgIm5vIGVzIHBvc2libGUgYW5hbGl6YXIgaGVhZGVyICVzIGNvbiAtLWFsbG93LXVua25vd24tdHlwZSIKIAotIzogc2hhMS1maWxlLmM6MTM5NworIzogc2hhMS1maWxlLmM6MTM5MgogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gcGFyc2UgJXMgaGVhZGVyIgogbXNnc3RyICJpbmNhcGF6IGRlIGFuYWxpemFyIGhlYWRlciAlcyIKIAotIzogc2hhMS1maWxlLmM6MTU4OAorIzogc2hhMS1maWxlLmM6MTU4NAogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gcmVhZCBvYmplY3QgJXMiCiBtc2dzdHIgImZhbGzDsyBhbCBsZWVyIG9iamV0byAlcyIKIAotIzogc2hhMS1maWxlLmM6MTU5MgorIzogc2hhMS1maWxlLmM6MTU4OAogIywgYy1mb3JtYXQKIG1zZ2lkICJyZXBsYWNlbWVudCAlcyBub3QgZm91bmQgZm9yICVzIgogbXNnc3RyICJyZWVtcGxhem8gJXMgbm8gZW5jb250cmFkbyBwYXJhICVzIgogCi0jOiBzaGExLWZpbGUuYzoxNTk2CisjOiBzaGExLWZpbGUuYzoxNTkyCiAjLCBjLWZvcm1hdAogbXNnaWQgImxvb3NlIG9iamVjdCAlcyAoc3RvcmVkIGluICVzKSBpcyBjb3JydXB0IgogbXNnc3RyICJvYmpldG8gcGVyZGlkbyAlcyAoZ3VhcmRhZG8gZW4gJXMpIGVzdMOhIGNvcnJvbXBpZG8iCiAKLSM6IHNoYTEtZmlsZS5jOjE2MDAKKyM6IHNoYTEtZmlsZS5jOjE1OTYKICMsIGMtZm9ybWF0CiBtc2dpZCAicGFja2VkIG9iamVjdCAlcyAoc3RvcmVkIGluICVzKSBpcyBjb3JydXB0IgogbXNnc3RyICJwYXF1ZXRlIGRlIG9iamV0byAlcyAoZ3VhcmRhZG8gZW4gJXMpIGVzdMOhIGNvcnJvbXBpZG8iCiAKLSM6IHNoYTEtZmlsZS5jOjE3MDMKKyM6IHNoYTEtZmlsZS5jOjE2OTkKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHdyaXRlIGZpbGUgJXMiCiBtc2dzdHIgIm5vIGVzIHBvc2libGUgZXNjcmliaXIgYXJjaGl2byAlcyIKIAotIzogc2hhMS1maWxlLmM6MTcxMAorIzogc2hhMS1maWxlLmM6MTcwNgogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gc2V0IHBlcm1pc3Npb24gdG8gJyVzJyIKIG1zZ3N0ciAibm8gc2UgcHVkbyBwb25lciBwZXJtaXNvcyBhICclcyciCiAKLSM6IHNoYTEtZmlsZS5jOjE3MTcKKyM6IHNoYTEtZmlsZS5jOjE3MTMKIG1zZ2lkICJmaWxlIHdyaXRlIGVycm9yIgogbXNnc3RyICJmYWxsw7MgZGUgZXNjcml0dXJhIgogCi0jOiBzaGExLWZpbGUuYzoxNzM2CisjOiBzaGExLWZpbGUuYzoxNzMyCiBtc2dpZCAiZXJyb3Igd2hlbiBjbG9zaW5nIGxvb3NlIG9iamVjdCBmaWxlIgogbXNnc3RyICJlcnJvciBjZXJyYW5kbyBlbCBhcmNoaXZvIGRlIG9iamV0byBzdWVsdG8iCiAKLSM6IHNoYTEtZmlsZS5jOjE4MDEKKyM6IHNoYTEtZmlsZS5jOjE3OTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW5zdWZmaWNpZW50IHBlcm1pc3Npb24gZm9yIGFkZGluZyBhbiBvYmplY3QgdG8gcmVwb3NpdG9yeSBkYXRhYmFzZSAlcyIKIG1zZ3N0ciAiIgogInBlcm1pc29zIGluc3VmaWNpZW50ZXMgcGFyYSBhZ3JlZ2FyIHVuIG9iamV0byBhIGxhIGJhc2UgZGUgZGF0b3MgZGVsICIKICJyZXBvc2l0b3JpbyAlcyIKIAotIzogc2hhMS1maWxlLmM6MTgwMworIzogc2hhMS1maWxlLmM6MTc5OQogbXNnaWQgInVuYWJsZSB0byBjcmVhdGUgdGVtcG9yYXJ5IGZpbGUiCiBtc2dzdHIgIm5vIGVzIHBvc2libGUgY3JlYXIgdW4gYXJjaGl2byB0ZW1wb3JhbCIKIAotIzogc2hhMS1maWxlLmM6MTgyNworIzogc2hhMS1maWxlLmM6MTgyMwogbXNnaWQgInVuYWJsZSB0byB3cml0ZSBsb29zZSBvYmplY3QgZmlsZSIKIG1zZ3N0ciAibm8gZXMgcG9zaWJsZSBlc2NyaWJpciBlbCBhcmNoaXZvIGRlIG9iamV0byBzdWVsdG8iCiAKLSM6IHNoYTEtZmlsZS5jOjE4MzMKKyM6IHNoYTEtZmlsZS5jOjE4MjkKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGRlZmxhdGUgbmV3IG9iamVjdCAlcyAoJWQpIgogbXNnc3RyICJubyBlcyBwb3NpYmxlIGRlc2luZmxhciBlbCBvYmpldG8gbnVldm8gJXMgKCVkKSIKIAotIzogc2hhMS1maWxlLmM6MTgzNworIzogc2hhMS1maWxlLmM6MTgzMwogIywgYy1mb3JtYXQKIG1zZ2lkICJkZWZsYXRlRW5kIG9uIG9iamVjdCAlcyBmYWlsZWQgKCVkKSIKIG1zZ3N0ciAiZGVmbGF0ZUVuZCBlbiBvYmpldG8gJXMgZmFsbMOzICglZCkiCiAKLSM6IHNoYTEtZmlsZS5jOjE4NDEKKyM6IHNoYTEtZmlsZS5jOjE4MzcKICMsIGMtZm9ybWF0CiBtc2dpZCAiY29uZnVzZWQgYnkgdW5zdGFibGUgb2JqZWN0IHNvdXJjZSBkYXRhIGZvciAlcyIKIG1zZ3N0ciAiY29uZnVuZGlkbyBwb3IgZnVlbnRlIGRlIGRhdGEgZGUgb2JqZXRvcyBpbmVzdGFibGUgcGFyYSAlcyIKIAotIzogc2hhMS1maWxlLmM6MTg1MSBidWlsdGluL3BhY2stb2JqZWN0cy5jOjkyNQorIzogc2hhMS1maWxlLmM6MTg0NyBidWlsdGluL3BhY2stb2JqZWN0cy5jOjkyNQogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdXRpbWUoKSBvbiAlcyIKIG1zZ3N0ciAiZmFsbMOzIHV0aW1lKCkgZW4gJXMiCiAKLSM6IHNoYTEtZmlsZS5jOjE5MjYKKyM6IHNoYTEtZmlsZS5jOjE5MjIKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IHJlYWQgb2JqZWN0IGZvciAlcyIKIG1zZ3N0ciAibm8gc2UgcHVkbyBsZWVyIGVsIG9iamV0byBwYXJhICVzIgogCi0jOiBzaGExLWZpbGUuYzoxOTY2CisjOiBzaGExLWZpbGUuYzoxOTYyCiBtc2dpZCAiY29ycnVwdCBjb21taXQiCiBtc2dzdHIgImNvbW1pdCBjb3JydXB0byIKIAotIzogc2hhMS1maWxlLmM6MTk3NAorIzogc2hhMS1maWxlLmM6MTk3MAogbXNnaWQgImNvcnJ1cHQgdGFnIgogbXNnc3RyICJ0YWcgY29ycnVwdG8iCiAKLSM6IHNoYTEtZmlsZS5jOjIwNzMKKyM6IHNoYTEtZmlsZS5jOjIwNjkKICMsIGMtZm9ybWF0CiBtc2dpZCAicmVhZCBlcnJvciB3aGlsZSBpbmRleGluZyAlcyIKIG1zZ3N0ciAiZXJyb3IgbGV5ZW5kbyBhbCBpbmRleGFyICVzIgogCi0jOiBzaGExLWZpbGUuYzoyMDc2CisjOiBzaGExLWZpbGUuYzoyMDcyCiAjLCBjLWZvcm1hdAogbXNnaWQgInNob3J0IHJlYWQgd2hpbGUgaW5kZXhpbmcgJXMiCiBtc2dzdHIgImxlY3R1cmEgY29ydGEgYWwgaW5kZXhhciAlcyIKIAotIzogc2hhMS1maWxlLmM6MjE0OSBzaGExLWZpbGUuYzoyMTU4CisjOiBzaGExLWZpbGUuYzoyMTQ1IHNoYTEtZmlsZS5jOjIxNTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXM6IGZhaWxlZCB0byBpbnNlcnQgaW50byBkYXRhYmFzZSIKIG1zZ3N0ciAiJXM6IGZhbGzDsyBhbCBpbnNlcnRhciBlbiBsYSBiYXNlIGRlIGRhdG9zIgogCi0jOiBzaGExLWZpbGUuYzoyMTY0CisjOiBzaGExLWZpbGUuYzoyMTYwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiB1bnN1cHBvcnRlZCBmaWxlIHR5cGUiCiBtc2dzdHIgIiVzOiB0aXBvIGRlIGFyY2hpdm8gbm8gc29wb3J0YWRvIgogCi0jOiBzaGExLWZpbGUuYzoyMTg4CisjOiBzaGExLWZpbGUuYzoyMTg0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIGlzIG5vdCBhIHZhbGlkIG9iamVjdCIKIG1zZ3N0ciAiJXMgbm8gZXMgb2JqZXRvIHbDoWxpZG8iCiAKLSM6IHNoYTEtZmlsZS5jOjIxOTAKKyM6IHNoYTEtZmlsZS5jOjIxODYKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgaXMgbm90IGEgdmFsaWQgJyVzJyBvYmplY3QiCiBtc2dzdHIgIiVzIG5vIGVzIHVuIG9iamV0byAnJXMnIHbDoWxpZG8iCiAKLSM6IHNoYTEtZmlsZS5jOjIyMTcgYnVpbHRpbi9pbmRleC1wYWNrLmM6MTU1CisjOiBzaGExLWZpbGUuYzoyMjEzIGJ1aWx0aW4vaW5kZXgtcGFjay5jOjE1NQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gb3BlbiAlcyIKIG1zZ3N0ciAibm8gZXMgcG9zaWJsZSBhYnJpciAlcyIKIAotIzogc2hhMS1maWxlLmM6MjQwNyBzaGExLWZpbGUuYzoyNDU5CisjOiBzaGExLWZpbGUuYzoyNDAzIHNoYTEtZmlsZS5jOjI0NTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiaGFzaCBtaXNtYXRjaCBmb3IgJXMgKGV4cGVjdGVkICVzKSIKIG1zZ3N0ciAiaGFzaCBubyBjb25jdWVyZGEgcGFyYSAlcyAoc2UgZXNwZXJhYmEgJXMpIgogCi0jOiBzaGExLWZpbGUuYzoyNDMxCisjOiBzaGExLWZpbGUuYzoyNDI3CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBtbWFwICVzIgogbXNnc3RyICJubyBlcyBwb3NpYmxlIGhhY2VyIG1tYXAgYSAlcyIKIAotIzogc2hhMS1maWxlLmM6MjQzNgorIzogc2hhMS1maWxlLmM6MjQzMgogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gdW5wYWNrIGhlYWRlciBvZiAlcyIKIG1zZ3N0ciAiaW5jYXBheiBkZSBkZXNlbXBhcXVldGFyIGhlYWRlciBkZSAlcyIKIAotIzogc2hhMS1maWxlLmM6MjQ0MgorIzogc2hhMS1maWxlLmM6MjQzOAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gcGFyc2UgaGVhZGVyIG9mICVzIgogbXNnc3RyICJpbmNhcGF6IGRlIGFuYWxpemFyIGhlYWRlciBkZSAlcyIKIAotIzogc2hhMS1maWxlLmM6MjQ1MworIzogc2hhMS1maWxlLmM6MjQ0OQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gdW5wYWNrIGNvbnRlbnRzIG9mICVzIgogbXNnc3RyICJubyBlcyBwb3NpYmxlIGRlc2VtcGFxdWV0YXIgY29udGVuaWRvcyBkZSAlcyIKIAotIzogc2hhMS1uYW1lLmM6NDkwCisjOiBzaGExLW5hbWUuYzo0ODcKICMsIGMtZm9ybWF0CiBtc2dpZCAic2hvcnQgU0hBMSAlcyBpcyBhbWJpZ3VvdXMiCiBtc2dzdHIgIlNIQTEgJXMgY29ydG8gZXMgYW1iaWd1byIKIAotIzogc2hhMS1uYW1lLmM6NTAxCisjOiBzaGExLW5hbWUuYzo0OTgKIG1zZ2lkICJUaGUgY2FuZGlkYXRlcyBhcmU6IgogbXNnc3RyICJMb3MgY2FuZGlkYXRvcyBzb246IgogCi0jOiBzaGExLW5hbWUuYzo4MDAKKyM6IHNoYTEtbmFtZS5jOjc5NwogbXNnaWQgIiIKICJHaXQgbm9ybWFsbHkgbmV2ZXIgY3JlYXRlcyBhIHJlZiB0aGF0IGVuZHMgd2l0aCA0MCBoZXggY2hhcmFjdGVyc1xuIgogImJlY2F1c2UgaXQgd2lsbCBiZSBpZ25vcmVkIHdoZW4geW91IGp1c3Qgc3BlY2lmeSA0MC1oZXguIFRoZXNlIHJlZnNcbiIKQEAgLTcwOTYsNDMgKzcxMjAsNDMgQEAKICJlamVjdXRhbmRvIFwiZ2l0IGNvbmZpZyBhZHZpY2Uub2JqZWN0TmFtZVdhcm5pbmcgZmFsc2VcIiIKIAogIy4gVFJBTlNMQVRPUlM6IElFQyA4MDAwMC0xMzoyMDA4IGdpYmlieXRlCi0jOiBzdHJidWYuYzo4MjEKKyM6IHN0cmJ1Zi5jOjgyMgogIywgYy1mb3JtYXQKIG1zZ2lkICIldS4lMi4ydSBHaUIiCiBtc2dzdHIgIiV1LiUyLjJ1IEdpQiIKIAogIy4gVFJBTlNMQVRPUlM6IElFQyA4MDAwMC0xMzoyMDA4IGdpYmlieXRlL3NlY29uZAotIzogc3RyYnVmLmM6ODIzCisjOiBzdHJidWYuYzo4MjQKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXUuJTIuMnUgR2lCL3MiCiBtc2dzdHIgIiV1LiUyLjJ1IEdpQi9zIgogCiAjLiBUUkFOU0xBVE9SUzogSUVDIDgwMDAwLTEzOjIwMDggbWViaWJ5dGUKLSM6IHN0cmJ1Zi5jOjgzMQorIzogc3RyYnVmLmM6ODMyCiAjLCBjLWZvcm1hdAogbXNnaWQgIiV1LiUyLjJ1IE1pQiIKIG1zZ3N0ciAiJXUuJTIuMnUgTWlCIgogCiAjLiBUUkFOU0xBVE9SUzogSUVDIDgwMDAwLTEzOjIwMDggbWViaWJ5dGUvc2Vjb25kCi0jOiBzdHJidWYuYzo4MzMKKyM6IHN0cmJ1Zi5jOjgzNAogIywgYy1mb3JtYXQKIG1zZ2lkICIldS4lMi4ydSBNaUIvcyIKIG1zZ3N0ciAiJXUuJTIuMnUgTWlCL3MiCiAKICMuIFRSQU5TTEFUT1JTOiBJRUMgODAwMDAtMTM6MjAwOCBraWJpYnl0ZQotIzogc3RyYnVmLmM6ODQwCisjOiBzdHJidWYuYzo4NDEKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXUuJTIuMnUgS2lCIgogbXNnc3RyICIldS4lMi4ydSBLaUIiCiAKICMuIFRSQU5TTEFUT1JTOiBJRUMgODAwMDAtMTM6MjAwOCBraWJpYnl0ZS9zZWNvbmQKLSM6IHN0cmJ1Zi5jOjg0MgorIzogc3RyYnVmLmM6ODQzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiV1LiUyLjJ1IEtpQi9zIgogbXNnc3RyICIldS4lMi4ydSBLaUIvcyIKIAogIy4gVFJBTlNMQVRPUlM6IElFQyA4MDAwMC0xMzoyMDA4IGJ5dGUKLSM6IHN0cmJ1Zi5jOjg0OAorIzogc3RyYnVmLmM6ODQ5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiV1IGJ5dGUiCiBtc2dpZF9wbHVyYWwgIiV1IGJ5dGVzIgpAQCAtNzE0MCw3ICs3MTY0LDcgQEAKIG1zZ3N0clsxXSAiJXUgYnl0ZXMiCiAKICMuIFRSQU5TTEFUT1JTOiBJRUMgODAwMDAtMTM6MjAwOCBieXRlL3NlY29uZAotIzogc3RyYnVmLmM6ODUwCisjOiBzdHJidWYuYzo4NTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXUgYnl0ZS9zIgogbXNnaWRfcGx1cmFsICIldSBieXRlcy9zIgpAQCAtNzI1OCwyOCArNzI4MiwyOCBAQAogbXNnaWQgImxzLXRyZWUgcmV0dXJuZWQgdW5leHBlY3RlZCByZXR1cm4gY29kZSAlZCIKIG1zZ3N0ciAibHMtdHJlZSBkZXZvbHZpw7MgdW4gY8OzZGlnbyAlZCBpbmVzcGVyYWRvIgogCi0jOiBzdWJtb2R1bGUtY29uZmlnLmM6MjMyCisjOiBzdWJtb2R1bGUtY29uZmlnLmM6MjM2CiAjLCBjLWZvcm1hdAogbXNnaWQgImlnbm9yaW5nIHN1c3BpY2lvdXMgc3VibW9kdWxlIG5hbWU6ICVzIgogbXNnc3RyICJpZ25vcmFuZG8gc3VibcOzZHVsbyBzb3NwZWNob3NvOiAlcyIKIAotIzogc3VibW9kdWxlLWNvbmZpZy5jOjI5OQorIzogc3VibW9kdWxlLWNvbmZpZy5jOjMwMwogbXNnaWQgIm5lZ2F0aXZlIHZhbHVlcyBub3QgYWxsb3dlZCBmb3Igc3VibW9kdWxlLmZldGNoam9icyIKIG1zZ3N0ciAibm8gc2UgcGVybWl0ZW4gdmFsb3JlcyBuZWdhdGl2b3MgcGFyYSBzdWJtb2R1bGUuZmV0Y2hqb2JzIgogCi0jOiBzdWJtb2R1bGUtY29uZmlnLmM6Mzk3CisjOiBzdWJtb2R1bGUtY29uZmlnLmM6NDAxCiAjLCBjLWZvcm1hdAogbXNnaWQgImlnbm9yaW5nICclcycgd2hpY2ggbWF5IGJlIGludGVycHJldGVkIGFzIGEgY29tbWFuZC1saW5lIG9wdGlvbjogJXMiCiBtc2dzdHIgIiIKICJpZ25vcmFuZG8gJyVzJyB5YSBxdWUgcHVlZGUgc2VyIGludGVycHJldGFkbyBjb21vIHVuYSBvcGNpw7NuIGRlIGzDrW5lYSBkZSAiCiAiY29tYW5kbzogJXMiCiAKLSM6IHN1Ym1vZHVsZS1jb25maWcuYzo0ODYKKyM6IHN1Ym1vZHVsZS1jb25maWcuYzo0OTAKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCB2YWx1ZSBmb3IgJXMiCiBtc2dzdHIgInZhbG9yIGludsOhbGlkbyBwYXJhICVzIgogCi0jOiBzdWJtb2R1bGUtY29uZmlnLmM6NzU1CisjOiBzdWJtb2R1bGUtY29uZmlnLmM6NzYxCiAjLCBjLWZvcm1hdAogbXNnaWQgIkNvdWxkIG5vdCB1cGRhdGUgLmdpdG1vZHVsZXMgZW50cnkgJXMiCiBtc2dzdHIgIk5vIHNlIHB1ZG8gYWN0dWFsaXphciBsYSBlbnRyYWRhICVzIGRlIC5naXRtb2R1bGVzIgpAQCAtNzMxNCw3ICs3MzM4LDcgQEAKIG1zZ2lkICJjb3VsZCBub3QgcmVhZCBmcm9tIHN0ZGluIgogbXNnc3RyICJubyBzZSBwdWRvIGxlZXIgZGVzZGUgc3RkaW4iCiAKLSM6IHRyYWlsZXIuYzoxMDExIHdyYXBwZXIuYzo3MDEKKyM6IHRyYWlsZXIuYzoxMDExIHdyYXBwZXIuYzo2NjUKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHN0YXQgJXMiCiBtc2dzdHIgIm5vIHNlIHB1ZG8gZGVmaW5pciAlcyIKQEAgLTczNDMsNDcgKzczNjcsNDcgQEAKIG1zZ2lkICJXb3VsZCBzZXQgdXBzdHJlYW0gb2YgJyVzJyB0byAnJXMnIG9mICclcydcbiIKIG1zZ3N0ciAiQ29uZmlndXJhcsOhIHVwc3RyZWFtIGRlICclcycgYSAnJXMnIGRlICclcydcbiIKIAotIzogdHJhbnNwb3J0LmM6MTQyCisjOiB0cmFuc3BvcnQuYzoxNDUKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHJlYWQgYnVuZGxlICclcyciCiBtc2dzdHIgIm5vIHNlIHB1ZG8gbGVlciBlbCBjb25qdW50byAnJXMnIgogCi0jOiB0cmFuc3BvcnQuYzoyMDgKKyM6IHRyYW5zcG9ydC5jOjIxNAogIywgYy1mb3JtYXQKIG1zZ2lkICJ0cmFuc3BvcnQ6IGludmFsaWQgZGVwdGggb3B0aW9uICclcyciCiBtc2dzdHIgInRyYW5zcG9ydDogb3BjacOzbiBpbnbDoWxpZGEgJyVzJyIKIAotIzogdHJhbnNwb3J0LmM6MjU5CisjOiB0cmFuc3BvcnQuYzoyNjYKIG1zZ2lkICJzZWUgcHJvdG9jb2wudmVyc2lvbiBpbiAnZ2l0IGhlbHAgY29uZmlnJyBmb3IgbW9yZSBkZXRhaWxzIgogbXNnc3RyICJ2ZXIgcHJvdG9jb2wudmVyc2lvbiBlbiAnZ2l0IGhlbHAgY29uZmlnJyBwYXJhIG3DoXMgaW5mb3JtYWNpw7NuIgogCi0jOiB0cmFuc3BvcnQuYzoyNjAKKyM6IHRyYW5zcG9ydC5jOjI2NwogbXNnaWQgInNlcnZlciBvcHRpb25zIHJlcXVpcmUgcHJvdG9jb2wgdmVyc2lvbiAyIG9yIGxhdGVyIgogbXNnc3RyICJvcGNpb25lcyBkZWwgc2Vydmlkb3IgcmVxdWllcmVuIHByb3RvY29sbyB2ZXJzacOzbiAyIG8gcG9zdGVyaW9yIgogCi0jOiB0cmFuc3BvcnQuYzo2MjUKKyM6IHRyYW5zcG9ydC5jOjYzMgogbXNnaWQgImNvdWxkIG5vdCBwYXJzZSB0cmFuc3BvcnQuY29sb3IuKiBjb25maWciCiBtc2dzdHIgIm5vIHNlIHB1ZG8gYW5hbGl6YXIgdmFsb3IgZGUgY29uZmlndXJhY2nDs24gdHJhbnNwb3J0LmNvbG9yLioiCiAKLSM6IHRyYW5zcG9ydC5jOjY5OAorIzogdHJhbnNwb3J0LmM6NzA1CiBtc2dpZCAic3VwcG9ydCBmb3IgcHJvdG9jb2wgdjIgbm90IGltcGxlbWVudGVkIHlldCIKIG1zZ3N0ciAic29wb3J0ZSBwYXJhIHByb3RvY29sbyB2MiBubyBpbXBsZW1lbnRhZG8gdG9kYXbDrWEiCiAKLSM6IHRyYW5zcG9ydC5jOjgyNQorIzogdHJhbnNwb3J0LmM6ODMxCiAjLCBjLWZvcm1hdAogbXNnaWQgInVua25vd24gdmFsdWUgZm9yIGNvbmZpZyAnJXMnOiAlcyIKIG1zZ3N0ciAidmFsb3IgZGVzY29ub2NpZG8gcGFyYSBjb25maWd1cmFjacOzbiAnJXMnOiAlcyIKIAotIzogdHJhbnNwb3J0LmM6ODkxCisjOiB0cmFuc3BvcnQuYzo4OTcKICMsIGMtZm9ybWF0CiBtc2dpZCAidHJhbnNwb3J0ICclcycgbm90IGFsbG93ZWQiCiBtc2dzdHIgInRyYW5zcG9ydGUgJyVzJyBubyBwZXJtaXRpZG8iCiAKLSM6IHRyYW5zcG9ydC5jOjk0NQorIzogdHJhbnNwb3J0LmM6OTQ5CiBtc2dpZCAiZ2l0LW92ZXItcnN5bmMgaXMgbm8gbG9uZ2VyIHN1cHBvcnRlZCIKIG1zZ3N0ciAiZ2l0LW92ZXItcnN5bmMgeWEgbm8gZXMgc29wb3J0YWRvIgogCi0jOiB0cmFuc3BvcnQuYzoxMDQwCisjOiB0cmFuc3BvcnQuYzoxMDQ0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgZm9sbG93aW5nIHN1Ym1vZHVsZSBwYXRocyBjb250YWluIGNoYW5nZXMgdGhhdCBjYW5cbiIKQEAgLTczOTIsNyArNzQxNiw3IEBACiAiTGEgc2lndWllbnRlIHJ1dGEgZGUgc3VibcOzZHVsbyBjb250aWVuZSBjYW1iaW9zIHF1ZSBub1xuIgogInB1ZWRlbiBzZXIgZW5jb250cmFkb3MgZW4gbmluZ8O6biByZW1vdG86XG4iCiAKLSM6IHRyYW5zcG9ydC5jOjEwNDQKKyM6IHRyYW5zcG9ydC5jOjEwNDgKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlxuIgpAQCAtNzQxOSwzMiArNzQ0MywzMiBAQAogInBhcmEgaGFjZXIgdW4gcHVzaCBhbCByZW1vdG8uXG4iCiAiXG4iCiAKLSM6IHRyYW5zcG9ydC5jOjEwNTIKKyM6IHRyYW5zcG9ydC5jOjEwNTYKIG1zZ2lkICJBYm9ydGluZy4iCiBtc2dzdHIgIkFib3J0YW5kby4iCiAKLSM6IHRyYW5zcG9ydC5jOjExOTMKKyM6IHRyYW5zcG9ydC5jOjEyMDEKIG1zZ2lkICJmYWlsZWQgdG8gcHVzaCBhbGwgbmVlZGVkIHN1Ym1vZHVsZXMiCiBtc2dzdHIgImZhbGzDsyBhbCBoYWNlciBwdXNoIGEgdG9kb3MgbG9zIHN1Ym3Ds2R1bG9zIG5lY2VzYXJpb3MiCiAKLSM6IHRyYW5zcG9ydC5jOjEzNDAgdHJhbnNwb3J0LWhlbHBlci5jOjY0NQorIzogdHJhbnNwb3J0LmM6MTM0NSB0cmFuc3BvcnQtaGVscGVyLmM6NjU1CiBtc2dpZCAib3BlcmF0aW9uIG5vdCBzdXBwb3J0ZWQgYnkgcHJvdG9jb2wiCiBtc2dzdHIgIm9wZXJhY2nDs24gbm8gc29wb3J0YWRhIHBvciBwcm90b2NvbG8iCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzo1MSB0cmFuc3BvcnQtaGVscGVyLmM6ODAKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzo2MSB0cmFuc3BvcnQtaGVscGVyLmM6OTAKIG1zZ2lkICJmdWxsIHdyaXRlIHRvIHJlbW90ZSBoZWxwZXIgZmFpbGVkIgogbXNnc3RyICJlc2NyaXR1cmEgdG90YWwgYWwgaGVscGVyIHJlbW90byBmYWxsw7MiCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxMzQKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxNDQKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGZpbmQgcmVtb3RlIGhlbHBlciBmb3IgJyVzJyIKIG1zZ3N0ciAibm8gZXMgcG9zaWJsZSBlbmNvbnRyYXIgaGVscGVyIHJlbW90byBwYXJhICclcyciCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxNTAgdHJhbnNwb3J0LWhlbHBlci5jOjU1OQorIzogdHJhbnNwb3J0LWhlbHBlci5jOjE2MCB0cmFuc3BvcnQtaGVscGVyLmM6NTY5CiBtc2dpZCAiY2FuJ3QgZHVwIGhlbHBlciBvdXRwdXQgZmQiCiBtc2dzdHIgIm5vIHNlIHB1ZWRlIGR1cGxpY2FyIG91dHB1dCBkZSBmZCBkZWwgaGVscGVyIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6MjAxCisjOiB0cmFuc3BvcnQtaGVscGVyLmM6MjExCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJ1bmtub3duIG1hbmRhdG9yeSBjYXBhYmlsaXR5ICVzOyB0aGlzIHJlbW90ZSBoZWxwZXIgcHJvYmFibHkgbmVlZHMgbmV3ZXIgIgpAQCAtNzQ1Myw5OSArNzQ3NywxMDQgQEAKICJjYXBhY2lkYWQgbWFuZGF0b3JpYSBkZXNjb25vY2lkYSAlczsgZXN0ZSBoZWxwZXIgcmVtb3RvIHByb2JhYmxlbWVudGUgIgogIm5lY2VzaXRhIHVuYSBudWV2YSB2ZXJzacOzbiBkZSBHaXQiCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzoyMDcKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzoyMTcKIG1zZ2lkICJ0aGlzIHJlbW90ZSBoZWxwZXIgc2hvdWxkIGltcGxlbWVudCByZWZzcGVjIGNhcGFiaWxpdHkiCiBtc2dzdHIgImVzdGUgaGVscGVyIHJlbW90byBkZWJlcsOtYSBpbXBsZW1lbnRhciBjYXBhY2lkYWQgcmVmc3BlYyIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjI3NCB0cmFuc3BvcnQtaGVscGVyLmM6NDE0CisjOiB0cmFuc3BvcnQtaGVscGVyLmM6Mjg0IHRyYW5zcG9ydC1oZWxwZXIuYzo0MjQKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgdW5leHBlY3RlZGx5IHNhaWQ6ICclcyciCiBtc2dzdHIgIiVzIGRpam8gaW5lc3BlcmFkYW1lbnRlOiAnJXMnIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6NDAzCisjOiB0cmFuc3BvcnQtaGVscGVyLmM6NDEzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIGFsc28gbG9ja2VkICVzIgogbXNnc3RyICIlcyB0YW1iacOpbiBibG9xdWXDsyAlcyIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjQ4MQorIzogdHJhbnNwb3J0LWhlbHBlci5jOjQ5MQogbXNnaWQgImNvdWxkbid0IHJ1biBmYXN0LWltcG9ydCIKIG1zZ3N0ciAibm8gc2UgcHVkbyBlamVjdXRhciBmYXN0LWltcG9ydCIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjUwNAorIzogdHJhbnNwb3J0LWhlbHBlci5jOjUxNAogbXNnaWQgImVycm9yIHdoaWxlIHJ1bm5pbmcgZmFzdC1pbXBvcnQiCiBtc2dzdHIgImVycm9yIGFsIGVqZWN1dGFyIGZhc3QtaW1wb3J0IgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6NTMzIHRyYW5zcG9ydC1oZWxwZXIuYzoxMTA1CisjOiB0cmFuc3BvcnQtaGVscGVyLmM6NTQzIHRyYW5zcG9ydC1oZWxwZXIuYzoxMTMyCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCByZWFkIHJlZiAlcyIKIG1zZ3N0ciAibm8gc2UgcHVkbyBsZWVyIGxhIHJlZmVyZW5jaWEgJXMiCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzo1NzgKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzo1ODgKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5rbm93biByZXNwb25zZSB0byBjb25uZWN0OiAlcyIKIG1zZ3N0ciAicmVzcHVlc3RhIHBhcmEgY29uZWN0YXIgZGVzY29ub2NpZGE6ICVzIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6NjAwCisjOiB0cmFuc3BvcnQtaGVscGVyLmM6NjEwCiBtc2dpZCAic2V0dGluZyByZW1vdGUgc2VydmljZSBwYXRoIG5vdCBzdXBwb3J0ZWQgYnkgcHJvdG9jb2wiCiBtc2dzdHIgImNvbmZpZ3VyYW5kbyBzZXJ2aWNpbyBkZSBydXRhIHJlbW90YSBubyBzb3BvcnRhZG8gcG9yIGVsIHByb3RvY29sbyIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjYwMgorIzogdHJhbnNwb3J0LWhlbHBlci5jOjYxMgogbXNnaWQgImludmFsaWQgcmVtb3RlIHNlcnZpY2UgcGF0aCIKIG1zZ3N0ciAicnV0YSBkZSBzZXJ2aWNpbyByZW1vdG8gaW52w6FsaWRhIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6NjQ4CisjOiB0cmFuc3BvcnQtaGVscGVyLmM6NjU4CiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbid0IGNvbm5lY3QgdG8gc3Vic2VydmljZSAlcyIKIG1zZ3N0ciAibm8gc2UgcHVlZGUgY29uZWN0YXIgYWwgc3Vic2VydmljaW8gJXMiCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzo3MjAKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzo3MzQKICMsIGMtZm9ybWF0CiBtc2dpZCAiZXhwZWN0ZWQgb2svZXJyb3IsIGhlbHBlciBzYWlkICclcyciCiBtc2dzdHIgInNlIGVzcGVyYWJhIG9rL2Vycm9yLCBoZWxwZXIgZGlqbyAnJXMnIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6NzczCisjOiB0cmFuc3BvcnQtaGVscGVyLmM6Nzg3CiAjLCBjLWZvcm1hdAogbXNnaWQgImhlbHBlciByZXBvcnRlZCB1bmV4cGVjdGVkIHN0YXR1cyBvZiAlcyIKIG1zZ3N0ciAiaGVscGVyIHJlcG9ydMOzIGVzdGFkbyBpbmVzcGVyYWRvIGRlICVzIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6ODM0CisjOiB0cmFuc3BvcnQtaGVscGVyLmM6ODQ4CiAjLCBjLWZvcm1hdAogbXNnaWQgImhlbHBlciAlcyBkb2VzIG5vdCBzdXBwb3J0IGRyeS1ydW4iCiBtc2dzdHIgImhlbHBlciAlcyBubyBzb3BvcnRhIGRyeS1ydW4iCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzo4MzcKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzo4NTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiaGVscGVyICVzIGRvZXMgbm90IHN1cHBvcnQgLS1zaWduZWQiCiBtc2dzdHIgImhlbHBlciAlcyBubyBzb3BvcnRhIC0tc2lnbmVkIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6ODQwCisjOiB0cmFuc3BvcnQtaGVscGVyLmM6ODU0CiAjLCBjLWZvcm1hdAogbXNnaWQgImhlbHBlciAlcyBkb2VzIG5vdCBzdXBwb3J0IC0tc2lnbmVkPWlmLWFza2VkIgogbXNnc3RyICJoZWxwZXIgJXMgbm8gc29wb3J0YSAtLXNpZ25lZD1pZi1hc2tlZCIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjg0NworIzogdHJhbnNwb3J0LWhlbHBlci5jOjg1OQorIywgYy1mb3JtYXQKK21zZ2lkICJoZWxwZXIgJXMgZG9lcyBub3Qgc3VwcG9ydCAtLWF0b21pYyIKK21zZ3N0ciAiaGVscGVyICVzIG5vIHNvcG9ydGEgLS1hdG9taWMiCisKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzo4NjUKICMsIGMtZm9ybWF0CiBtc2dpZCAiaGVscGVyICVzIGRvZXMgbm90IHN1cHBvcnQgJ3B1c2gtb3B0aW9uJyIKIG1zZ3N0ciAiaGVscGVyICVzIG5vIHNvcG9ydGEgJ3B1c2gtb3B0aW9uJyIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjk0NQorIzogdHJhbnNwb3J0LWhlbHBlci5jOjk2MwogbXNnaWQgInJlbW90ZS1oZWxwZXIgZG9lc24ndCBzdXBwb3J0IHB1c2g7IHJlZnNwZWMgbmVlZGVkIgogbXNnc3RyICJyZW1vdGUtaGVscGVyIG5vIHNvcG9ydGEgcHVzaDsgc2UgbmVjZXNpdGEgcmVmc3BlYyIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjk1MAorIzogdHJhbnNwb3J0LWhlbHBlci5jOjk2OAogIywgYy1mb3JtYXQKIG1zZ2lkICJoZWxwZXIgJXMgZG9lcyBub3Qgc3VwcG9ydCAnZm9yY2UnIgogbXNnc3RyICJoZWxwZXIgJXMgbm8gc29wb3J0YSAnZm9yY2UnIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6OTk3CisjOiB0cmFuc3BvcnQtaGVscGVyLmM6MTAxNQogbXNnaWQgImNvdWxkbid0IHJ1biBmYXN0LWV4cG9ydCIKIG1zZ3N0ciAibm8gc2UgcHVkbyBlamVjdXRhciBmYXN0LWV4cG9ydCIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjEwMDIKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxMDIwCiBtc2dpZCAiZXJyb3Igd2hpbGUgcnVubmluZyBmYXN0LWV4cG9ydCIKIG1zZ3N0ciAiZXJyb3IgYWwgZWplY3V0YXIgZmFzdC1leHBvcnQiCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxMDI3CisjOiB0cmFuc3BvcnQtaGVscGVyLmM6MTA0NQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiTm8gcmVmcyBpbiBjb21tb24gYW5kIG5vbmUgc3BlY2lmaWVkOyBkb2luZyBub3RoaW5nLlxuIgpAQCAtNzU1NCw0NyArNzU4Myw0NyBAQAogIk5vIGhheSByZWZzIGNvbXVuZXMgeSBuaW5ndW5vIGVzcGVjaWZpY2Fkbzsgbm8gc2UgaGFjZSBuYWRhLlxuIgogIlRhbCB2ZXogZGViZXLDrWFzIGVzcGVjaWZpY2FyIHVuIGJyYW5jaCBjb21vICdtYXN0ZXInLlxuIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6MTA5MQorIzogdHJhbnNwb3J0LWhlbHBlci5jOjExMTgKICMsIGMtZm9ybWF0CiBtc2dpZCAibWFsZm9ybWVkIHJlc3BvbnNlIGluIHJlZiBsaXN0OiAlcyIKIG1zZ3N0ciAicmVzcHVlc3RhIG1hbGZvcm1hZGEgZW4gbGlzdGEgZGUgcmVmczogJXMiCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxMjQ0CisjOiB0cmFuc3BvcnQtaGVscGVyLmM6MTI3MAogIywgYy1mb3JtYXQKIG1zZ2lkICJyZWFkKCVzKSBmYWlsZWQiCiBtc2dzdHIgImxlZXIoJXMpIGZhbGzDsyIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjEyNzEKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxMjk3CiAjLCBjLWZvcm1hdAogbXNnaWQgIndyaXRlKCVzKSBmYWlsZWQiCiBtc2dzdHIgImVzY3JpYmlyKCVzKSBmYWxsw7MiCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxMzIwCisjOiB0cmFuc3BvcnQtaGVscGVyLmM6MTM0NgogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyB0aHJlYWQgZmFpbGVkIgogbXNnc3RyICJoaWxvICVzIGZhbGzDsyIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjEzMjQKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxMzUwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIHRocmVhZCBmYWlsZWQgdG8gam9pbjogJXMiCiBtc2dzdHIgImhpbG8gJXMgZmFsbMOzIGFsIHVuaXJzZTogJXMiCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxMzQzIHRyYW5zcG9ydC1oZWxwZXIuYzoxMzQ3CisjOiB0cmFuc3BvcnQtaGVscGVyLmM6MTM2OSB0cmFuc3BvcnQtaGVscGVyLmM6MTM3MwogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW4ndCBzdGFydCB0aHJlYWQgZm9yIGNvcHlpbmcgZGF0YTogJXMiCiBtc2dzdHIgIm5vIHNlIHB1ZWRlIGluaWNpYXIgZWwgaGlsbyBwYXJhIGNvcGlhciBkYXRhOiAlcyIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjEzODQKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxNDEwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIHByb2Nlc3MgZmFpbGVkIHRvIHdhaXQiCiBtc2dzdHIgInByb2Nlc28gJXMgZmFsbMOzIGFsIGVzcGVyYXIiCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxMzg4CisjOiB0cmFuc3BvcnQtaGVscGVyLmM6MTQxNAogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyBwcm9jZXNzIGZhaWxlZCIKIG1zZ3N0ciAicHJvY2VzbyAlcyBmYWxsw7MiCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxNDA2IHRyYW5zcG9ydC1oZWxwZXIuYzoxNDE1CisjOiB0cmFuc3BvcnQtaGVscGVyLmM6MTQzMiB0cmFuc3BvcnQtaGVscGVyLmM6MTQ0MQogbXNnaWQgImNhbid0IHN0YXJ0IHRocmVhZCBmb3IgY29weWluZyBkYXRhIgogbXNnc3RyICJubyBzZSBwdWVkZSBpbmljaWFyIGhpbG8gcGFyYSBjb3BpYXIgZGF0YSIKIApAQCAtNzYxNCw3ICs3NjQzLDcgQEAKIG1zZ2lkICJ0b28tc2hvcnQgdHJlZSBmaWxlIgogbXNnc3RyICJhcmNoaXZvIGRlIMOhcmJvbCBtdXkgY29ydG8iCiAKLSM6IHVucGFjay10cmVlcy5jOjExMQorIzogdW5wYWNrLXRyZWVzLmM6MTEwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJZb3VyIGxvY2FsIGNoYW5nZXMgdG8gdGhlIGZvbGxvd2luZyBmaWxlcyB3b3VsZCBiZSBvdmVyd3JpdHRlbiBieSBjaGVja291dDpcbiIKQEAgLTc2MjUsNyArNzY1NCw3IEBACiAiJSVzUG9yIGZhdm9yIHJlYWxpemEgdW4gY29tbWl0IGNvbiBsb3MgY2FtYmlvcyBvIHVuIHN0YXNoIGFudGVzIGRlIGNhbWJpYXIgIgogInJhbWFzLiIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTEzCisjOiB1bnBhY2stdHJlZXMuYzoxMTIKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIllvdXIgbG9jYWwgY2hhbmdlcyB0byB0aGUgZm9sbG93aW5nIGZpbGVzIHdvdWxkIGJlIG92ZXJ3cml0dGVuIGJ5IGNoZWNrb3V0OlxuIgpAQCAtNzYzNSw3ICs3NjY0LDcgQEAKICJjaGVja291dDpcbiIKICIlJXMiCiAKLSM6IHVucGFjay10cmVlcy5jOjExNgorIzogdW5wYWNrLXRyZWVzLmM6MTE1CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJZb3VyIGxvY2FsIGNoYW5nZXMgdG8gdGhlIGZvbGxvd2luZyBmaWxlcyB3b3VsZCBiZSBvdmVyd3JpdHRlbiBieSBtZXJnZTpcbiIKQEAgLTc2NDUsNyArNzY3NCw3IEBACiAiZnVzaW9uYXI6XG4iCiAiJSVzUG9yIGZhdm9yLCBjb25maXJtYSB0dXMgY2FtYmlvcyBvIGFndcOhcmRhbG9zIGFudGVzIGRlIGZ1c2lvbmFyLiIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTE4CisjOiB1bnBhY2stdHJlZXMuYzoxMTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIllvdXIgbG9jYWwgY2hhbmdlcyB0byB0aGUgZm9sbG93aW5nIGZpbGVzIHdvdWxkIGJlIG92ZXJ3cml0dGVuIGJ5IG1lcmdlOlxuIgpAQCAtNzY1NSw3ICs3Njg0LDcgQEAKICJtZXJnZTpcbiIKICIlJXMiCiAKLSM6IHVucGFjay10cmVlcy5jOjEyMQorIzogdW5wYWNrLXRyZWVzLmM6MTIwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJZb3VyIGxvY2FsIGNoYW5nZXMgdG8gdGhlIGZvbGxvd2luZyBmaWxlcyB3b3VsZCBiZSBvdmVyd3JpdHRlbiBieSAlczpcbiIKQEAgLTc2NjQsNyArNzY5Myw3IEBACiAiTG9zIGNhbWJpb3MgbG9jYWxlcyBkZSBsb3Mgc2lndWllbnRlcyBhcmNoaXZvcyBzZXLDoW4gc29icmVzY3JpdG9zIGFsICVzOlxuIgogIiUlc1BvciBmYXZvciwgY29uZmlybWEgdHVzIGNhbWJpb3MgbyBndcOhcmRhbG9zIGFudGVzIGRlICVzLiIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTIzCisjOiB1bnBhY2stdHJlZXMuYzoxMjIKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIllvdXIgbG9jYWwgY2hhbmdlcyB0byB0aGUgZm9sbG93aW5nIGZpbGVzIHdvdWxkIGJlIG92ZXJ3cml0dGVuIGJ5ICVzOlxuIgpAQCAtNzY3Myw3ICs3NzAyLDcgQEAKICJMb3MgY2FtYmlvcyBsb2NhbGVzIGRlIGxvcyBzaWd1aWVudGVzIGFyY2hpdm9zIHNlcsOhbiBzb2JyZWVzY3JpdG9zIHBvciAlczpcbiIKICIlJXMiCiAKLSM6IHVucGFjay10cmVlcy5jOjEyOAorIzogdW5wYWNrLXRyZWVzLmM6MTI3CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJVcGRhdGluZyB0aGUgZm9sbG93aW5nIGRpcmVjdG9yaWVzIHdvdWxkIGxvc2UgdW50cmFja2VkIGZpbGVzIGluIHRoZW06XG4iCkBAIC03NjgzLDcgKzc3MTIsNyBAQAogInNlZ3VpbWllbnRvIGVuIGVsbG9zOlxuIgogIiVzIgogCi0jOiB1bnBhY2stdHJlZXMuYzoxMzIKKyM6IHVucGFjay10cmVlcy5jOjEzMQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiVGhlIGZvbGxvd2luZyB1bnRyYWNrZWQgd29ya2luZyB0cmVlIGZpbGVzIHdvdWxkIGJlIHJlbW92ZWQgYnkgY2hlY2tvdXQ6XG4iCkBAIC03NjkzLDcgKzc3MjIsNyBAQAogImVsaW1pbmFkb3MgYWwgYWN0dWFsaXphciBlbCDDoXJib2wgZGUgdHJhYmFqbzpcbiIKICIlJXNQb3IgZmF2b3IsIG11w6l2ZWxvcyBvIGVsaW3DrW5hbG9zIGFudGVzIGRlIGludGVyY2FtYmlhciByYW1hcy4iCiAKLSM6IHVucGFjay10cmVlcy5jOjEzNAorIzogdW5wYWNrLXRyZWVzLmM6MTMzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgZm9sbG93aW5nIHVudHJhY2tlZCB3b3JraW5nIHRyZWUgZmlsZXMgd291bGQgYmUgcmVtb3ZlZCBieSBjaGVja291dDpcbiIKQEAgLTc3MDMsNyArNzczMiw3IEBACiAiZWxpbWluYWRvc2FsIGFjdHVhbGl6YXIgZWwgw6FyYm9sIGRlIHRyYWJham86XG4iCiAiJSVzIgogCi0jOiB1bnBhY2stdHJlZXMuYzoxMzcKKyM6IHVucGFjay10cmVlcy5jOjEzNgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiVGhlIGZvbGxvd2luZyB1bnRyYWNrZWQgd29ya2luZyB0cmVlIGZpbGVzIHdvdWxkIGJlIHJlbW92ZWQgYnkgbWVyZ2U6XG4iCkBAIC03NzEzLDcgKzc3NDIsNyBAQAogImVsaW1pbmFkb3MgYWwgZnVzaW9uYXI6XG4iCiAiJSVzUG9yIGZhdm9yLCBtdcOpdmVsb3MgbyBlbGltw61uYWxvcyBhbnRlcyBkZSBmdXNpb25hci4iCiAKLSM6IHVucGFjay10cmVlcy5jOjEzOQorIzogdW5wYWNrLXRyZWVzLmM6MTM4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgZm9sbG93aW5nIHVudHJhY2tlZCB3b3JraW5nIHRyZWUgZmlsZXMgd291bGQgYmUgcmVtb3ZlZCBieSBtZXJnZTpcbiIKQEAgLTc3MjMsNyArNzc1Miw3IEBACiAiZWxpbWluYWRvc2FsIGZ1c2lvbmFyOlxuIgogIiUlcyIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTQyCisjOiB1bnBhY2stdHJlZXMuYzoxNDEKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlRoZSBmb2xsb3dpbmcgdW50cmFja2VkIHdvcmtpbmcgdHJlZSBmaWxlcyB3b3VsZCBiZSByZW1vdmVkIGJ5ICVzOlxuIgpAQCAtNzczMyw3ICs3NzYyLDcgQEAKICJlbGltaW5hZG9zIGFsICVzOlxuIgogIiUlc1BvciBmYXZvciwgbXXDqXZlbG9zIG8gZWxpbcOtbmFsb3MgYW50ZXMgZGUgJXMuIgogCi0jOiB1bnBhY2stdHJlZXMuYzoxNDQKKyM6IHVucGFjay10cmVlcy5jOjE0MwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiVGhlIGZvbGxvd2luZyB1bnRyYWNrZWQgd29ya2luZyB0cmVlIGZpbGVzIHdvdWxkIGJlIHJlbW92ZWQgYnkgJXM6XG4iCkBAIC03NzQzLDcgKzc3NzIsNyBAQAogImVsaW1pbmFkb3MgYWwgZWplY3V0YXIgJXM6XG4iCiAiJSVzIgogCi0jOiB1bnBhY2stdHJlZXMuYzoxNTAKKyM6IHVucGFjay10cmVlcy5jOjE0OQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiVGhlIGZvbGxvd2luZyB1bnRyYWNrZWQgd29ya2luZyB0cmVlIGZpbGVzIHdvdWxkIGJlIG92ZXJ3cml0dGVuIGJ5ICIKQEAgLTc3NTQsNyArNzc4Myw3IEBACiAic29icmVzY3JpdG9zIGFsIGFjdHVhbGl6YXIgZWwgw6FyYm9sIGRlIHRyYWJham86XG4iCiAiJSVzUG9yIGZhdm9yLCBtdcOpdmVsb3MgbyBlbGltw61uYWxvcyBhbnRlcyBkZSBpbnRlcmNhbWJpYXIgcmFtYXMuIgogCi0jOiB1bnBhY2stdHJlZXMuYzoxNTIKKyM6IHVucGFjay10cmVlcy5jOjE1MQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiVGhlIGZvbGxvd2luZyB1bnRyYWNrZWQgd29ya2luZyB0cmVlIGZpbGVzIHdvdWxkIGJlIG92ZXJ3cml0dGVuIGJ5ICIKQEAgLTc3NjUsNyArNzc5NCw3IEBACiAic29icmVzY3JpdG9zIGFsIGFjdHVhbGl6YXIgZWwgw6FyYm9sIGRlIHRyYWJham86XG4iCiAiJSVzIgogCi0jOiB1bnBhY2stdHJlZXMuYzoxNTUKKyM6IHVucGFjay10cmVlcy5jOjE1NAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiVGhlIGZvbGxvd2luZyB1bnRyYWNrZWQgd29ya2luZyB0cmVlIGZpbGVzIHdvdWxkIGJlIG92ZXJ3cml0dGVuIGJ5IG1lcmdlOlxuIgpAQCAtNzc3NSw3ICs3ODA0LDcgQEAKICJzb2JyZXNjcml0b3MgYWwgZnVzaW9uYXI6XG4iCiAiJSVzUG9yIGZhdm9yLCBtdcOpdmVsb3MgbyBlbGltw61uYWxvcyBhbnRlcyBkZSBmdXNpb25hci4iCiAKLSM6IHVucGFjay10cmVlcy5jOjE1NworIzogdW5wYWNrLXRyZWVzLmM6MTU2CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgZm9sbG93aW5nIHVudHJhY2tlZCB3b3JraW5nIHRyZWUgZmlsZXMgd291bGQgYmUgb3ZlcndyaXR0ZW4gYnkgbWVyZ2U6XG4iCkBAIC03Nzg1LDcgKzc4MTQsNyBAQAogInNvYnJlc2NyaXRvcyBhbCBmdXNpb25hcjpcbiIKICIlJXMiCiAKLSM6IHVucGFjay10cmVlcy5jOjE2MAorIzogdW5wYWNrLXRyZWVzLmM6MTU5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgZm9sbG93aW5nIHVudHJhY2tlZCB3b3JraW5nIHRyZWUgZmlsZXMgd291bGQgYmUgb3ZlcndyaXR0ZW4gYnkgJXM6XG4iCkBAIC03Nzk1LDcgKzc4MjQsNyBAQAogInNvYnJlc2NyaXRvcyBhbCAlczpcbiIKICIlJXNQb3IgZmF2b3IsIG11w6l2ZWxvcyBvIGVsaW3DrW5hbG9zIGFudGVzIGRlICVzLiIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTYyCisjOiB1bnBhY2stdHJlZXMuYzoxNjEKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlRoZSBmb2xsb3dpbmcgdW50cmFja2VkIHdvcmtpbmcgdHJlZSBmaWxlcyB3b3VsZCBiZSBvdmVyd3JpdHRlbiBieSAlczpcbiIKQEAgLTc4MDUsMTIgKzc4MzQsMTIgQEAKICJlbGltaW5hZG9zcG9yICVzOlxuIgogIiUlcyIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTcwCisjOiB1bnBhY2stdHJlZXMuYzoxNjkKICMsIGMtZm9ybWF0CiBtc2dpZCAiRW50cnkgJyVzJyBvdmVybGFwcyB3aXRoICclcycuICBDYW5ub3QgYmluZC4iCiBtc2dzdHIgIkVudHJhZGEgJyVzJyBzZSBzdXBlcnBvbmUgY29uICclcycuICBObyBzZSBwdWVkZW4gdW5pci4iCiAKLSM6IHVucGFjay10cmVlcy5jOjE3MworIzogdW5wYWNrLXRyZWVzLmM6MTcyCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJDYW5ub3QgdXBkYXRlIHNwYXJzZSBjaGVja291dDogdGhlIGZvbGxvd2luZyBlbnRyaWVzIGFyZSBub3QgdXAgdG8gZGF0ZTpcbiIKQEAgLTc4MjAsNyArNzg0OSw3IEBACiAiYWN0dWFsaXphZGFzOlxuIgogIiVzIgogCi0jOiB1bnBhY2stdHJlZXMuYzoxNzUKKyM6IHVucGFjay10cmVlcy5jOjE3NAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiVGhlIGZvbGxvd2luZyB3b3JraW5nIHRyZWUgZmlsZXMgd291bGQgYmUgb3ZlcndyaXR0ZW4gYnkgc3BhcnNlIGNoZWNrb3V0ICIKQEAgLTc4MzEsNyArNzg2MCw3IEBACiAiYWN0dWFsaXphY2nDs24gc3BhcnNlIGNoZWNrb3V0OlxuIgogIiVzIgogCi0jOiB1bnBhY2stdHJlZXMuYzoxNzcKKyM6IHVucGFjay10cmVlcy5jOjE3NgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiVGhlIGZvbGxvd2luZyB3b3JraW5nIHRyZWUgZmlsZXMgd291bGQgYmUgcmVtb3ZlZCBieSBzcGFyc2UgY2hlY2tvdXQgIgpAQCAtNzg0Miw3ICs3ODcxLDcgQEAKICJhY3R1YWxpemFjacOzbiBzcGFyc2UgY2hlY2tvdXQ6XG4iCiAiJXMiCiAKLSM6IHVucGFjay10cmVlcy5jOjE3OQorIzogdW5wYWNrLXRyZWVzLmM6MTc4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJDYW5ub3QgdXBkYXRlIHN1Ym1vZHVsZTpcbiIKQEAgLTc4NTEsMTYgKzc4ODAsMTYgQEAKICJObyBzZSBwdWVkZSBhY3R1YWxpemFyIGxlIHN1Ym3Ds2R1bG86XG4iCiAiJXMiCiAKLSM6IHVucGFjay10cmVlcy5jOjI1NgorIzogdW5wYWNrLXRyZWVzLmM6MjU1CiAjLCBjLWZvcm1hdAogbXNnaWQgIkFib3J0aW5nXG4iCiBtc2dzdHIgIkFib3J0YW5kb1xuIgogCi0jOiB1bnBhY2stdHJlZXMuYzozMTgKKyM6IHVucGFjay10cmVlcy5jOjMxNwogbXNnaWQgIlVwZGF0aW5nIGZpbGVzIgogbXNnc3RyICJBY3R1YWxpemFuZG8gYXJjaGl2b3MiCiAKLSM6IHVucGFjay10cmVlcy5jOjM1MAorIzogdW5wYWNrLXRyZWVzLmM6MzQ5CiBtc2dpZCAiIgogInRoZSBmb2xsb3dpbmcgcGF0aHMgaGF2ZSBjb2xsaWRlZCAoZS5nLiBjYXNlLXNlbnNpdGl2ZSBwYXRoc1xuIgogIm9uIGEgY2FzZS1pbnNlbnNpdGl2ZSBmaWxlc3lzdGVtKSBhbmQgb25seSBvbmUgZnJvbSB0aGUgc2FtZVxuIgpAQCAtNzg5OSw3ICs3OTI4LDcgQEAKIG1zZ2lkICJpbnZhbGlkICcuLicgcGF0aCBzZWdtZW50IgogbXNnc3RyICJzZWdtZW50byBkZSBydXRhICcuLicgaW52w6FsaWRvIgogCi0jOiB3b3JrdHJlZS5jOjI1OCBidWlsdGluL2FtLmM6MjA5NQorIzogd29ya3RyZWUuYzoyNTggYnVpbHRpbi9hbS5jOjIwODQKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIHJlYWQgJyVzJyIKIG1zZ3N0ciAiZmFsbMOzIGFsIGxlZXIgJyVzJyIKQEAgLTc5MzIsMTcgKzc5NjEsMTcgQEAKIG1zZ2lkICInJXMnIGRvZXMgbm90IHBvaW50IGJhY2sgdG8gJyVzJyIKIG1zZ3N0ciAiJyVzJyBubyBhcHVudGEgZGUgdnVlbHRhIGEgJyVzJyIKIAotIzogd3JhcHBlci5jOjIyMyB3cmFwcGVyLmM6MzkzCisjOiB3cmFwcGVyLmM6MTg2IHdyYXBwZXIuYzozNTYKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IG9wZW4gJyVzJyBmb3IgcmVhZGluZyBhbmQgd3JpdGluZyIKIG1zZ3N0ciAibm8gc2UgcHVkbyBhYnJpciAnJXMnIHBhcmEgbGVjdHVyYSB5IGVzY3JpdHVyYSIKIAotIzogd3JhcHBlci5jOjQyNCB3cmFwcGVyLmM6NjI0CisjOiB3cmFwcGVyLmM6Mzg3IHdyYXBwZXIuYzo1ODgKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGFjY2VzcyAnJXMnIgogbXNnc3RyICJubyBlcyBwb3NpYmxlIGFjY2VkZXIgJyVzJyIKIAotIzogd3JhcHBlci5jOjYzMgorIzogd3JhcHBlci5jOjU5NgogbXNnaWQgInVuYWJsZSB0byBnZXQgY3VycmVudCB3b3JraW5nIGRpcmVjdG9yeSIKIG1zZ3N0ciAibm8gZXMgcG9zaWJsZSBvYnRlbmVyIGVsIGRpcmVjdG9yaW8gZGUgdHJhYmFqbyBhY3R1YWwiCiAKQEAgLTgyODcsODEgKzgzMTYsODkgQEAKICIgICh0b2RvcyBsb3MgY29uZmxpY3RvcyBjb3JyZWdpZG9zOiBlamVjdXRhIFwiZ2l0IGNoZXJyeS1waWNrIC0tY29udGludWVcIikiCiAKICM6IHd0LXN0YXR1cy5jOjE0MzcKK21zZ2lkICIgICh1c2UgXCJnaXQgY2hlcnJ5LXBpY2sgLS1za2lwXCIgdG8gc2tpcCB0aGlzIHBhdGNoKSIKK21zZ3N0ciAiICAodXNhIFwiZ2l0IGNoZXJyeS1waWNrIC0tc2tpcFwiIHBhcmEgc2FsdGFyIGVzdGUgcGFyY2hlKSIKKworIzogd3Qtc3RhdHVzLmM6MTQzOQogbXNnaWQgIiAgKHVzZSBcImdpdCBjaGVycnktcGljayAtLWFib3J0XCIgdG8gY2FuY2VsIHRoZSBjaGVycnktcGljayBvcGVyYXRpb24pIgogbXNnc3RyICIiCiAiICAodXNlIFwiZ2l0IGNoZXJyeS1waWNrIC0tYWJvcnRcIiBwYXJhIGNhbmNlbGFyIGxhIG9wZXJhY2nDs24gY2hlcnJ5LXBpY2spIgogCi0jOiB3dC1zdGF0dXMuYzoxNDQ3CisjOiB3dC1zdGF0dXMuYzoxNDQ5CiBtc2dpZCAiUmV2ZXJ0IGN1cnJlbnRseSBpbiBwcm9ncmVzcy4iCiBtc2dzdHIgIlJldmllcnRlIGVsIGVzdGFkbyBlbiBwcm9ncmVzbyBhY3R1YWwuIgogCi0jOiB3dC1zdGF0dXMuYzoxNDUwCisjOiB3dC1zdGF0dXMuYzoxNDUyCiAjLCBjLWZvcm1hdAogbXNnaWQgIllvdSBhcmUgY3VycmVudGx5IHJldmVydGluZyBjb21taXQgJXMuIgogbXNnc3RyICJFc3TDoXMgcmV2aXJ0aWVuZG8gZWwgY29tbWl0ICVzLiIKIAotIzogd3Qtc3RhdHVzLmM6MTQ1NgorIzogd3Qtc3RhdHVzLmM6MTQ1OAogbXNnaWQgIiAgKGZpeCBjb25mbGljdHMgYW5kIHJ1biBcImdpdCByZXZlcnQgLS1jb250aW51ZVwiKSIKIG1zZ3N0ciAiICAoY29ycmlnZSBsb3MgY29uZmxpY3RvcyB5IGVqZWN1dGEgXCJnaXQgcmV2ZXJ0IC0tY29udGludWVcIikiCiAKLSM6IHd0LXN0YXR1cy5jOjE0NTkKKyM6IHd0LXN0YXR1cy5jOjE0NjEKIG1zZ2lkICIgIChydW4gXCJnaXQgcmV2ZXJ0IC0tY29udGludWVcIiB0byBjb250aW51ZSkiCiBtc2dzdHIgIiAgKGVqZWN1dGEgXCJnaXQgcmV2ZXJ0IC0tY29udGludWVcIiBwYXJhIGNvbnRpbnVhcikiCiAKLSM6IHd0LXN0YXR1cy5jOjE0NjIKKyM6IHd0LXN0YXR1cy5jOjE0NjQKIG1zZ2lkICIgIChhbGwgY29uZmxpY3RzIGZpeGVkOiBydW4gXCJnaXQgcmV2ZXJ0IC0tY29udGludWVcIikiCiBtc2dzdHIgIiAgKHRvZG9zIGxvcyBjb25mbGljdG9zIGNvcnJlZ2lkb3M6IGVqZWN1dGEgXCJnaXQgcmV2ZXJ0IC0tY29udGludWVcIikiCiAKLSM6IHd0LXN0YXR1cy5jOjE0NjQKKyM6IHd0LXN0YXR1cy5jOjE0NjYKK21zZ2lkICIgICh1c2UgXCJnaXQgcmV2ZXJ0IC0tc2tpcFwiIHRvIHNraXAgdGhpcyBwYXRjaCkiCittc2dzdHIgIiAgKHVzYSBcImdpdCByZXZlcnQgLS1za2lwXCIgcGFyYSBvbWl0aXIgZXN0ZSBwYXJjaGUpIgorCisjOiB3dC1zdGF0dXMuYzoxNDY4CiBtc2dpZCAiICAodXNlIFwiZ2l0IHJldmVydCAtLWFib3J0XCIgdG8gY2FuY2VsIHRoZSByZXZlcnQgb3BlcmF0aW9uKSIKIG1zZ3N0ciAiICAodXNhIFwiZ2l0IHJldmVydCAtLWFib3J0XCIgcGFyYSBjYW5jZWxhciBsYSBvcGVyYWNpw7NuIGRlIHJldmVydGlyKSIKIAotIzogd3Qtc3RhdHVzLmM6MTQ3NAorIzogd3Qtc3RhdHVzLmM6MTQ3OAogIywgYy1mb3JtYXQKIG1zZ2lkICJZb3UgYXJlIGN1cnJlbnRseSBiaXNlY3RpbmcsIHN0YXJ0ZWQgZnJvbSBicmFuY2ggJyVzJy4iCiBtc2dzdHIgIkVzdMOhcyBhcGxpY2FuZG8gdW4gYmlzZWN0LCBjb21lbnphbmRvIGVuIGxhIHJhbWEgJyVzJy4iCiAKLSM6IHd0LXN0YXR1cy5jOjE0NzgKKyM6IHd0LXN0YXR1cy5jOjE0ODIKIG1zZ2lkICJZb3UgYXJlIGN1cnJlbnRseSBiaXNlY3RpbmcuIgogbXNnc3RyICJFc3TDoXMgYXBsaWNhbmRvIHVuIGJpc2VjdC4iCiAKLSM6IHd0LXN0YXR1cy5jOjE0ODEKKyM6IHd0LXN0YXR1cy5jOjE0ODUKIG1zZ2lkICIgICh1c2UgXCJnaXQgYmlzZWN0IHJlc2V0XCIgdG8gZ2V0IGJhY2sgdG8gdGhlIG9yaWdpbmFsIGJyYW5jaCkiCiBtc2dzdHIgIiAgKHVzYSBcImdpdCBiaXNlY3QgcmVzZXRcIiBwYXJhIHZvbHZlciBhIGxhIHJhbWEgb3JpZ2luYWwpIgogCi0jOiB3dC1zdGF0dXMuYzoxNjkwCisjOiB3dC1zdGF0dXMuYzoxNjk0CiBtc2dpZCAiT24gYnJhbmNoICIKIG1zZ3N0ciAiRW4gbGEgcmFtYSAiCiAKLSM6IHd0LXN0YXR1cy5jOjE2OTcKKyM6IHd0LXN0YXR1cy5jOjE3MDEKIG1zZ2lkICJpbnRlcmFjdGl2ZSByZWJhc2UgaW4gcHJvZ3Jlc3M7IG9udG8gIgogbXNnc3RyICJyZWJhc2UgaW50ZXJhY3Rpdm8gZW4gcHJvZ3Jlc287IGVuICIKIAotIzogd3Qtc3RhdHVzLmM6MTY5OQorIzogd3Qtc3RhdHVzLmM6MTcwMwogbXNnaWQgInJlYmFzZSBpbiBwcm9ncmVzczsgb250byAiCiBtc2dzdHIgInJlYmFzZSBlbiBwcm9ncmVzbzsgZW4gIgogCi0jOiB3dC1zdGF0dXMuYzoxNzA5CisjOiB3dC1zdGF0dXMuYzoxNzEzCiBtc2dpZCAiTm90IGN1cnJlbnRseSBvbiBhbnkgYnJhbmNoLiIKIG1zZ3N0ciAiQWN0dWFsbWVudGUgbm8gZXN0w6FzIGVuIG5pbmd1bmEgcmFtYS4iCiAKLSM6IHd0LXN0YXR1cy5jOjE3MjYKKyM6IHd0LXN0YXR1cy5jOjE3MzAKIG1zZ2lkICJJbml0aWFsIGNvbW1pdCIKIG1zZ3N0ciAiQ29uZmlybWFjacOzbiBpbmljaWFsIgogCi0jOiB3dC1zdGF0dXMuYzoxNzI3CisjOiB3dC1zdGF0dXMuYzoxNzMxCiBtc2dpZCAiTm8gY29tbWl0cyB5ZXQiCiBtc2dzdHIgIk5vIGhheSBjb21taXRzIHRvZGF2w61hIgogCi0jOiB3dC1zdGF0dXMuYzoxNzQxCisjOiB3dC1zdGF0dXMuYzoxNzQ1CiBtc2dpZCAiVW50cmFja2VkIGZpbGVzIgogbXNnc3RyICJBcmNoaXZvcyBzaW4gc2VndWltaWVudG8iCiAKLSM6IHd0LXN0YXR1cy5jOjE3NDMKKyM6IHd0LXN0YXR1cy5jOjE3NDcKIG1zZ2lkICJJZ25vcmVkIGZpbGVzIgogbXNnc3RyICJBcmNoaXZvcyBpZ25vcmFkb3MiCiAKLSM6IHd0LXN0YXR1cy5jOjE3NDcKKyM6IHd0LXN0YXR1cy5jOjE3NTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkl0IHRvb2sgJS4yZiBzZWNvbmRzIHRvIGVudW1lcmF0ZSB1bnRyYWNrZWQgZmlsZXMuICdzdGF0dXMgLXVubydcbiIKQEAgLTgzNzIsMzEgKzg0MDksMzEgQEAKICJwdWVkZSBhY2VsZXJhcmxvLCBwZXJvIHRpZW5lcyBxdWUgc2VyIGN1aWRhZG9zbyBkZSBubyBvbHZpZGFyIGFncmVnYXJcbiIKICJudWV2b3MgYXJjaGl2b3MgdMO6IG1pc21vICh2ZWEgJ2dpdCBoZWxwIHN0YXR1cycpLiIKIAotIzogd3Qtc3RhdHVzLmM6MTc1MworIzogd3Qtc3RhdHVzLmM6MTc1NwogIywgYy1mb3JtYXQKIG1zZ2lkICJVbnRyYWNrZWQgZmlsZXMgbm90IGxpc3RlZCVzIgogbXNnc3RyICJBcmNoaXZvcyBubyByYXN0cmVhZG9zIG5vIHNvbiBtb3N0cmFkb3MgJXMiCiAKLSM6IHd0LXN0YXR1cy5jOjE3NTUKKyM6IHd0LXN0YXR1cy5jOjE3NTkKIG1zZ2lkICIgKHVzZSAtdSBvcHRpb24gdG8gc2hvdyB1bnRyYWNrZWQgZmlsZXMpIgogbXNnc3RyICIgKHVzYSBsYSBvcGNpw7NuIC11IHBhcmEgbW9zdHJhciBsb3MgYXJjaGl2b3Mgc2luIHNlZ3VpbWllbnRvKSIKIAotIzogd3Qtc3RhdHVzLmM6MTc2MQorIzogd3Qtc3RhdHVzLmM6MTc2NQogbXNnaWQgIk5vIGNoYW5nZXMiCiBtc2dzdHIgIlNpbiBjYW1iaW9zIgogCi0jOiB3dC1zdGF0dXMuYzoxNzY2CisjOiB3dC1zdGF0dXMuYzoxNzcwCiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vIGNoYW5nZXMgYWRkZWQgdG8gY29tbWl0ICh1c2UgXCJnaXQgYWRkXCIgYW5kL29yIFwiZ2l0IGNvbW1pdCAtYVwiKVxuIgogbXNnc3RyICIiCiAic2luIGNhbWJpb3MgYWdyZWdhZG9zIGFsIGNvbW1pdCAodXNhIFwiZ2l0IGFkZFwiIHkvbyBcImdpdCBjb21taXQgLWFcIilcbiIKIAotIzogd3Qtc3RhdHVzLmM6MTc2OQorIzogd3Qtc3RhdHVzLmM6MTc3MwogIywgYy1mb3JtYXQKIG1zZ2lkICJubyBjaGFuZ2VzIGFkZGVkIHRvIGNvbW1pdFxuIgogbXNnc3RyICJubyBzZSBhZ3JlZ2Fyb24gY2FtYmlvcyBhbCBjb21taXRcbiIKIAotIzogd3Qtc3RhdHVzLmM6MTc3MgorIzogd3Qtc3RhdHVzLmM6MTc3NgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAibm90aGluZyBhZGRlZCB0byBjb21taXQgYnV0IHVudHJhY2tlZCBmaWxlcyBwcmVzZW50ICh1c2UgXCJnaXQgYWRkXCIgdG8gIgpAQCAtODQwNSw3MSArODQ0Miw3NiBAQAogIm5vIGhheSBuYWRhIGFncmVnYWRvIGFsIGNvbW1pdCBwZXJvIGhheSBhcmNoaXZvcyBzaW4gc2VndWltaWVudG8gcHJlc2VudGVzICIKICIodXNhIFwiZ2l0IGFkZFwiIHBhcmEgaGFjZXJsZXMgc2VndWltaWVudG8pXG4iCiAKLSM6IHd0LXN0YXR1cy5jOjE3NzUKKyM6IHd0LXN0YXR1cy5jOjE3NzkKICMsIGMtZm9ybWF0CiBtc2dpZCAibm90aGluZyBhZGRlZCB0byBjb21taXQgYnV0IHVudHJhY2tlZCBmaWxlcyBwcmVzZW50XG4iCiBtc2dzdHIgIiIKICJubyBoYXkgbmFkYSBhZ3JlZ2FkbyBwYXJhIGNvbmZpcm1hciwgcGVybyBoYXkgYXJjaGl2b3Mgc2luIHNlZ3VpbWllbnRvICIKICJwcmVzZW50ZXNcbiIKIAotIzogd3Qtc3RhdHVzLmM6MTc3OAorIzogd3Qtc3RhdHVzLmM6MTc4MgogIywgYy1mb3JtYXQKIG1zZ2lkICJub3RoaW5nIHRvIGNvbW1pdCAoY3JlYXRlL2NvcHkgZmlsZXMgYW5kIHVzZSBcImdpdCBhZGRcIiB0byB0cmFjaylcbiIKIG1zZ3N0ciAiIgogIm5vIGhheSBuYWRhIHBhcmEgY29uZmlybWFyIChjcmVhL2NvcGlhIGFyY2hpdm9zIHkgdXNhIFwiZ2l0IGFkZFwiIHBhcmEgIgogImhhY2VybGVzIHNlZ3VpbWllbnRvKVxuIgogCi0jOiB3dC1zdGF0dXMuYzoxNzgxIHd0LXN0YXR1cy5jOjE3ODYKKyM6IHd0LXN0YXR1cy5jOjE3ODUgd3Qtc3RhdHVzLmM6MTc5MAogIywgYy1mb3JtYXQKIG1zZ2lkICJub3RoaW5nIHRvIGNvbW1pdFxuIgogbXNnc3RyICJuYWRhIHBhcmEgaGFjZXIgY29tbWl0XG4iCiAKLSM6IHd0LXN0YXR1cy5jOjE3ODQKKyM6IHd0LXN0YXR1cy5jOjE3ODgKICMsIGMtZm9ybWF0CiBtc2dpZCAibm90aGluZyB0byBjb21taXQgKHVzZSAtdSB0byBzaG93IHVudHJhY2tlZCBmaWxlcylcbiIKIG1zZ3N0ciAiIgogIm5hZGEgcGFyYSBoYWNlciBjb21taXQgKHVzYSAtdSBwYXJhIG1vc3RyYXIgbG9zIGFyY2hpdm9zIG5vIHJhc3RyZWFkb3MpXG4iCiAKLSM6IHd0LXN0YXR1cy5jOjE3ODgKKyM6IHd0LXN0YXR1cy5jOjE3OTIKICMsIGMtZm9ybWF0CiBtc2dpZCAibm90aGluZyB0byBjb21taXQsIHdvcmtpbmcgdHJlZSBjbGVhblxuIgogbXNnc3RyICJuYWRhIHBhcmEgaGFjZXIgY29tbWl0LCBlbCDDoXJib2wgZGUgdHJhYmFqbyBlc3TDoSBsaW1waW9cbiIKIAotIzogd3Qtc3RhdHVzLmM6MTkwMQorIzogd3Qtc3RhdHVzLmM6MTkwNQogbXNnaWQgIk5vIGNvbW1pdHMgeWV0IG9uICIKIG1zZ3N0ciAiTm8gaGF5IGNvbW1pdHMgdG9kYXbDrWEgZW4gIgogCi0jOiB3dC1zdGF0dXMuYzoxOTA1CisjOiB3dC1zdGF0dXMuYzoxOTA5CiBtc2dpZCAiSEVBRCAobm8gYnJhbmNoKSIKIG1zZ3N0ciAiSEVBRCAoc2luIHJhbWEpIgogCi0jOiB3dC1zdGF0dXMuYzoxOTM2CisjOiB3dC1zdGF0dXMuYzoxOTQwCiBtc2dpZCAiZGlmZmVyZW50IgogbXNnc3RyICJkaWZlcmVudGUiCiAKLSM6IHd0LXN0YXR1cy5jOjE5Mzggd3Qtc3RhdHVzLmM6MTk0NgorIzogd3Qtc3RhdHVzLmM6MTk0MiB3dC1zdGF0dXMuYzoxOTUwCiBtc2dpZCAiYmVoaW5kICIKIG1zZ3N0ciAiZGV0csOhcyAiCiAKLSM6IHd0LXN0YXR1cy5jOjE5NDEgd3Qtc3RhdHVzLmM6MTk0NAorIzogd3Qtc3RhdHVzLmM6MTk0NSB3dC1zdGF0dXMuYzoxOTQ4CiBtc2dpZCAiYWhlYWQgIgogbXNnc3RyICJhZGVsYW50ZSAiCiAKICMuIFRSQU5TTEFUT1JTOiB0aGUgYWN0aW9uIGlzIGUuZy4gInB1bGwgd2l0aCByZWJhc2UiCi0jOiB3dC1zdGF0dXMuYzoyNDY2CisjOiB3dC1zdGF0dXMuYzoyNDcwCiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCAlczogWW91IGhhdmUgdW5zdGFnZWQgY2hhbmdlcy4iCiBtc2dzdHIgIm5vIHNlIHB1ZWRlICVzOiBUaWVuZXMgY2FtYmlvcyBzaW4gbWFyY2FyLiIKIAotIzogd3Qtc3RhdHVzLmM6MjQ3MgorIzogd3Qtc3RhdHVzLmM6MjQ3NgogbXNnaWQgImFkZGl0aW9uYWxseSwgeW91ciBpbmRleCBjb250YWlucyB1bmNvbW1pdHRlZCBjaGFuZ2VzLiIKIG1zZ3N0ciAiYWRpY2lvbmFsbWVudGUsIHR1IMOtbmRpY2UgY29udGllbmUgY2FtYmlvcyBxdWUgbm8gZXN0w6FuIGVuIHVuIGNvbW1pdC4iCiAKLSM6IHd0LXN0YXR1cy5jOjI0NzQKKyM6IHd0LXN0YXR1cy5jOjI0NzgKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90ICVzOiBZb3VyIGluZGV4IGNvbnRhaW5zIHVuY29tbWl0dGVkIGNoYW5nZXMuIgogbXNnc3RyICJubyBzZSBwdWVkZSAlczogVHUgw61uZGljZSBjb250aWVuZSBjYW1iaW9zIHF1ZSBubyBlc3TDoW4gZW4gdW4gY29tbWl0LiIKIAorIzogY29tcGF0L3ByZWNvbXBvc2VfdXRmOC5jOjU4IGJ1aWx0aW4vY2xvbmUuYzo0NTIKKyMsIGMtZm9ybWF0Cittc2dpZCAiZmFpbGVkIHRvIHVubGluayAnJXMnIgorbXNnc3RyICJmYWxsw7MgYWwgZGVzdmluY3VsYXIgJyVzJyIKKwogIzogYnVpbHRpbi9hZGQuYzoyNQogbXNnaWQgImdpdCBhZGQgWzxvcHRpb25zPl0gWy0tXSA8cGF0aHNwZWM+Li4uIgogbXNnc3RyICJnaXQgYWRkIFs8b3BjacOzbj5dIFstLV0gPGVzcGVjaWZpY2FjacOzbi1kZS1ydXRhPi4uLiIKQEAgLTg0OTIsNyArODUzNCw3IEBACiBtc2dpZCAiVW5zdGFnZWQgY2hhbmdlcyBhZnRlciByZWZyZXNoaW5nIHRoZSBpbmRleDoiCiBtc2dzdHIgIkNhbWJpb3MgZnVlcmEgZGVsIMOhcmVhIGRlIHN0YWdlIHRyYXMgcmVmcmVzY2FyIGVsIMOtbmRpY2U6IgogCi0jOiBidWlsdGluL2FkZC5jOjIzNCBidWlsdGluL3Jldi1wYXJzZS5jOjg5NgorIzogYnVpbHRpbi9hZGQuYzoyMzQgYnVpbHRpbi9yZXYtcGFyc2UuYzo4OTcKIG1zZ2lkICJDb3VsZCBub3QgcmVhZCB0aGUgaW5kZXgiCiBtc2dzdHIgIk5vIHNlIHB1ZG8gbGVlciBlbCDDrW5kaWNlIgogCkBAIC04NTI4LDggKzg1NzAsOCBAQAogbXNnc3RyICIiCiAiTGFzIHNpZ3VpZW50ZXMgcnV0YXMgc29uIGlnbm9yYWRhcyBwb3IgdW5vIGRlIHR1cyBhcmNoaXZvcyAuZ2l0aWdub3JlOlxuIgogCi0jOiBidWlsdGluL2FkZC5jOjI5MCBidWlsdGluL2NsZWFuLmM6OTA5IGJ1aWx0aW4vZmV0Y2guYzoxNDcgYnVpbHRpbi9tdi5jOjEyNAotIzogYnVpbHRpbi9wcnVuZS1wYWNrZWQuYzo1NiBidWlsdGluL3B1bGwuYzoyMjIgYnVpbHRpbi9wdXNoLmM6NTYwCisjOiBidWlsdGluL2FkZC5jOjI5MCBidWlsdGluL2NsZWFuLmM6OTEwIGJ1aWx0aW4vZmV0Y2guYzoxNjIgYnVpbHRpbi9tdi5jOjEyNAorIzogYnVpbHRpbi9wcnVuZS1wYWNrZWQuYzo1NiBidWlsdGluL3B1bGwuYzoyMjMgYnVpbHRpbi9wdXNoLmM6NTQ3CiAjOiBidWlsdGluL3JlbW90ZS5jOjEzNDUgYnVpbHRpbi9ybS5jOjI0MSBidWlsdGluL3NlbmQtcGFjay5jOjE2NQogbXNnaWQgImRyeSBydW4iCiBtc2dzdHIgImRyeSBydW4gKCBlamVjdWNpw7NuIGVuIHNlY28pIgpAQCAtODU2OCw3ICs4NjEwLDggQEAKIAogIzogYnVpbHRpbi9hZGQuYzozMDMKIG1zZ2lkICJpZ25vcmUgcGF0aHMgcmVtb3ZlZCBpbiB0aGUgd29ya2luZyB0cmVlIChzYW1lIGFzIC0tbm8tYWxsKSIKLW1zZ3N0ciAiaWdub3JhciBydXRhcyByZW1vdmlkYXMgZW4gZWwgw6FyYm9sIGRlIHRyYWJham8gKGxvIG1pc21vIHF1ZSAtLW5vLWFsbCkiCittc2dzdHIgIiIKKyJpZ25vcmFyIHJ1dGFzIGVsaW1pbmFkYXMgZW4gZWwgw6FyYm9sIGRlIHRyYWJham8gKGxvIG1pc21vIHF1ZSAtLW5vLWFsbCkiCiAKICM6IGJ1aWx0aW4vYWRkLmM6MzA1CiBtc2dpZCAiZG9uJ3QgYWRkLCBvbmx5IHJlZnJlc2ggdGhlIGluZGV4IgpAQCAtODU4Miw3ICs4NjI1LDcgQEAKIG1zZ2lkICJjaGVjayBpZiAtIGV2ZW4gbWlzc2luZyAtIGZpbGVzIGFyZSBpZ25vcmVkIGluIGRyeSBydW4iCiBtc2dzdHIgImNvbXByb2JhciBzaSAtIGluY2x1c28gbG9zIGFyY2hpdm9zIHF1ZSBmYWx0YW4gLSBzZSBpZ25vcmFuIGVuIGRyeSBydW4iCiAKLSM6IGJ1aWx0aW4vYWRkLmM6MzA5IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAwMQorIzogYnVpbHRpbi9hZGQuYzozMDkgYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDAyCiBtc2dpZCAib3ZlcnJpZGUgdGhlIGV4ZWN1dGFibGUgYml0IG9mIHRoZSBsaXN0ZWQgZmlsZXMiCiBtc2dzdHIgInNvYnJlc2NyaWJpciBlbCBiaXQgZWplY3V0YWJsZSBkZSBsb3MgYXJjaGl2b3MgbGlzdGFkb3MiCiAKQEAgLTg2NTYsMTQyICs4Njk5LDEzOCBAQAogIzogYnVpbHRpbi9hZGQuYzo0NDYKICMsIGMtZm9ybWF0CiBtc2dpZCAiTWF5YmUgeW91IHdhbnRlZCB0byBzYXkgJ2dpdCBhZGQgLic/XG4iCi1tc2dzdHIgIlRhbCB2ZXogcXVpc28gZGVjaXIgJ2dpdCBhZGQgLic/XG4iCittc2dzdHIgIsK/VGFsIHZleiBxdWlzbyBkZWNpciAnZ2l0IGFkZCAuJz9cbiIKIAotIzogYnVpbHRpbi9hbS5jOjM0OAorIzogYnVpbHRpbi9hbS5jOjM0NwogbXNnaWQgImNvdWxkIG5vdCBwYXJzZSBhdXRob3Igc2NyaXB0IgogbXNnc3RyICJubyBzZSBwdWRvIGFuYWxpemFyIGVsIHNjcmlwdCBkZWwgYXV0b3IiCiAKLSM6IGJ1aWx0aW4vYW0uYzo0MzIKKyM6IGJ1aWx0aW4vYW0uYzo0MzEKICMsIGMtZm9ybWF0CiBtc2dpZCAiJyVzJyB3YXMgZGVsZXRlZCBieSB0aGUgYXBwbHlwYXRjaC1tc2cgaG9vayIKIG1zZ3N0ciAiJyVzJyBmdWUgYm9ycmFkbyBwb3IgZWwgaG9vayBkZSBhcHBseXBhdGNoLW1zZyIKIAotIzogYnVpbHRpbi9hbS5jOjQ3NAorIzogYnVpbHRpbi9hbS5jOjQ3MwogIywgYy1mb3JtYXQKIG1zZ2lkICJNYWxmb3JtZWQgaW5wdXQgbGluZTogJyVzJy4iCiBtc2dzdHIgIkzDrW5lYSBtYWwgZm9ybWFkYTogJyVzJy4iCiAKLSM6IGJ1aWx0aW4vYW0uYzo1MTIKKyM6IGJ1aWx0aW4vYW0uYzo1MTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiRmFpbGVkIHRvIGNvcHkgbm90ZXMgZnJvbSAnJXMnIHRvICclcyciCiBtc2dzdHIgIkZhbGzDsyBhbCBjb3BpYXIgbm90YXMgZGUgJyVzJyBhICclcyciCiAKLSM6IGJ1aWx0aW4vYW0uYzo1MzgKKyM6IGJ1aWx0aW4vYW0uYzo1MzcKIG1zZ2lkICJmc2VlayBmYWlsZWQiCiBtc2dzdHIgImZhbGwgZGUgZnNlZWsiCiAKLSM6IGJ1aWx0aW4vYW0uYzo3MjYKKyM6IGJ1aWx0aW4vYW0uYzo3MjUKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHBhcnNlIHBhdGNoICclcyciCiBtc2dzdHIgIm5vIHNlIHB1ZG8gYW5hbGl6YXIgZWwgcGFyY2hlICclcyciCiAKLSM6IGJ1aWx0aW4vYW0uYzo3OTEKKyM6IGJ1aWx0aW4vYW0uYzo3OTAKIG1zZ2lkICJPbmx5IG9uZSBTdEdJVCBwYXRjaCBzZXJpZXMgY2FuIGJlIGFwcGxpZWQgYXQgb25jZSIKIG1zZ3N0ciAiU29sbyB1biBwYXJjaGUgU3RHSVQgcHVlZGUgc2VyIGFwbGljYWRvIGRlIHVuYSB2ZXoiCiAKLSM6IGJ1aWx0aW4vYW0uYzo4MzkKKyM6IGJ1aWx0aW4vYW0uYzo4MzgKIG1zZ2lkICJpbnZhbGlkIHRpbWVzdGFtcCIKIG1zZ3N0ciAidGltZXN0YW1wIGludsOhbGlkbyIKIAotIzogYnVpbHRpbi9hbS5jOjg0NCBidWlsdGluL2FtLmM6ODU2CisjOiBidWlsdGluL2FtLmM6ODQzIGJ1aWx0aW4vYW0uYzo4NTUKIG1zZ2lkICJpbnZhbGlkIERhdGUgbGluZSIKIG1zZ3N0ciAibMOtbmVhIERhdGUgaW52w6FsaWRhIgogCi0jOiBidWlsdGluL2FtLmM6ODUxCisjOiBidWlsdGluL2FtLmM6ODUwCiBtc2dpZCAiaW52YWxpZCB0aW1lem9uZSBvZmZzZXQiCiBtc2dzdHIgIm9mZnNldCBkZSB6b25hIGhvcmFyaWEgaW52w6FsaWRvIgogCi0jOiBidWlsdGluL2FtLmM6OTQ0CisjOiBidWlsdGluL2FtLmM6OTQzCiBtc2dpZCAiUGF0Y2ggZm9ybWF0IGRldGVjdGlvbiBmYWlsZWQuIgogbXNnc3RyICJGYWxsw7MgYWwgZGV0ZWN0YXIgZWwgZm9ybWF0byBkZWwgcGFyY2hlLiIKIAotIzogYnVpbHRpbi9hbS5jOjk0OSBidWlsdGluL2Nsb25lLmM6NDA3CisjOiBidWlsdGluL2FtLmM6OTQ4IGJ1aWx0aW4vY2xvbmUuYzo0MDYKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIGNyZWF0ZSBkaXJlY3RvcnkgJyVzJyIKIG1zZ3N0ciAiZmFsbMOzIGFsIGNyZWFyIGVsIGRpcmVjdG9yaW8gJyVzJyIKIAotIzogYnVpbHRpbi9hbS5jOjk1NAorIzogYnVpbHRpbi9hbS5jOjk1MwogbXNnaWQgIkZhaWxlZCB0byBzcGxpdCBwYXRjaGVzLiIKIG1zZ3N0ciAiRmFsbMOzIGFsIGRpdmlkaXIgcGFyY2hlcy4iCiAKLSM6IGJ1aWx0aW4vYW0uYzoxMDg0IGJ1aWx0aW4vY29tbWl0LmM6Mzc0Ci1tc2dpZCAidW5hYmxlIHRvIHdyaXRlIGluZGV4IGZpbGUiCi1tc2dzdHIgIm5vIGVzIHBvc2libGUgZXNjcmliaXIgZW4gZWwgYXJjaGl2byDDrW5kaWNlIgotCi0jOiBidWlsdGluL2FtLmM6MTA5OAorIzogYnVpbHRpbi9hbS5jOjEwODQKICMsIGMtZm9ybWF0CiBtc2dpZCAiV2hlbiB5b3UgaGF2ZSByZXNvbHZlZCB0aGlzIHByb2JsZW0sIHJ1biBcIiVzIC0tY29udGludWVcIi4iCiBtc2dzdHIgIkN1YW5kbyBoYXlhcyByZXN1ZWx0byBlc3RlIHByb2JsZW1hLCBlamVjdXRhIFwiJXMgLS1jb250aW51ZVwiLiIKIAotIzogYnVpbHRpbi9hbS5jOjEwOTkKKyM6IGJ1aWx0aW4vYW0uYzoxMDg1CiAjLCBjLWZvcm1hdAogbXNnaWQgIklmIHlvdSBwcmVmZXIgdG8gc2tpcCB0aGlzIHBhdGNoLCBydW4gXCIlcyAtLXNraXBcIiBpbnN0ZWFkLiIKIG1zZ3N0ciAiU2kgcHJlZmllcmVzIHNhbHRhciBlc3RlIHBhcmNoZSwgZWplY3V0YSBcIiVzIC0tc2tpcFwiLiIKIAotIzogYnVpbHRpbi9hbS5jOjExMDAKKyM6IGJ1aWx0aW4vYW0uYzoxMDg2CiAjLCBjLWZvcm1hdAogbXNnaWQgIlRvIHJlc3RvcmUgdGhlIG9yaWdpbmFsIGJyYW5jaCBhbmQgc3RvcCBwYXRjaGluZywgcnVuIFwiJXMgLS1hYm9ydFwiLiIKIG1zZ3N0ciAiIgogIlBhcmEgcmVzdGF1cmFyIGxhIHJhbWEgb3JpZ2luYWwgeSBkZXRlbmVyIGVsIHBhcmNoYWRvLCBlamVjdXRhciBcIiVzIC0tYWJvcnQiCiAiXCIuIgogCi0jOiBidWlsdGluL2FtLmM6MTE4MworIzogYnVpbHRpbi9hbS5jOjExNjkKIG1zZ2lkICJQYXRjaCBzZW50IHdpdGggZm9ybWF0PWZsb3dlZDsgc3BhY2UgYXQgdGhlIGVuZCBvZiBsaW5lcyBtaWdodCBiZSBsb3N0LiIKIG1zZ3N0ciAiIgogIlBhcmNoZSBtYW5kYWRvIGNvbiBmb3JtYXRvPWZsb3dlZDsgZXNwYWNpb3MgYWwgZmluYWwgZGUgbGFzIGzDrW5lYXMgdGFsIHZleiAiCiAiZGVzYXBhcmV6Y2FuLiIKIAotIzogYnVpbHRpbi9hbS5jOjEyMTEKKyM6IGJ1aWx0aW4vYW0uYzoxMTk3CiBtc2dpZCAiUGF0Y2ggaXMgZW1wdHkuIgogbXNnc3RyICJFbCBwYXJjaGUgZXN0w6EgdmFjw61vLiIKIAotIzogYnVpbHRpbi9hbS5jOjEyNzcKKyM6IGJ1aWx0aW4vYW0uYzoxMjYyCisjLCBjLWZvcm1hdAorbXNnaWQgIm1pc3NpbmcgYXV0aG9yIGxpbmUgaW4gY29tbWl0ICVzIgorbXNnc3RyICJmYWx0YSBsw61uZWEgYXV0b3IgZW4gY29tbWl0ICVzIgorCisjOiBidWlsdGluL2FtLmM6MTI2NQogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIGlkZW50IGxpbmU6ICUuKnMiCiBtc2dzdHIgInNhbmdyw61hIG5vIHbDoWxpZGE6ICUuKnMiCiAKLSM6IGJ1aWx0aW4vYW0uYzoxMjk5Ci0jLCBjLWZvcm1hdAotbXNnaWQgInVuYWJsZSB0byBwYXJzZSBjb21taXQgJXMiCi1tc2dzdHIgIm5vIGVzIHBvc2libGUgYW5hbGl6YXIgZWwgY29tbWl0ICVzIgotCi0jOiBidWlsdGluL2FtLmM6MTQ5NgorIzogYnVpbHRpbi9hbS5jOjE0ODQKIG1zZ2lkICJSZXBvc2l0b3J5IGxhY2tzIG5lY2Vzc2FyeSBibG9icyB0byBmYWxsIGJhY2sgb24gMy13YXkgbWVyZ2UuIgogbXNnc3RyICIiCiAiUmVwb3NpdG9yaW8gY2FyZWNlIGRlIGxvcyBibG9icyBuZWNlc2FyaW9zIHBhcmEgcmV0cm9jZWRlciBlbiB1bmEgZnVzacOzbiBkZSAiCiAiMy12w61hcy4iCiAKLSM6IGJ1aWx0aW4vYW0uYzoxNDk4CisjOiBidWlsdGluL2FtLmM6MTQ4NgogbXNnaWQgIlVzaW5nIGluZGV4IGluZm8gdG8gcmVjb25zdHJ1Y3QgYSBiYXNlIHRyZWUuLi4iCiBtc2dzdHIgIlVzYW5kbyBsYSBpbmZvcm1hY2nDs24gZGVsIMOtbmRpY2UgcGFyYSByZWNvbnN0cnVpciB1biDDoXJib2wgYmFzZS4uLiIKIAotIzogYnVpbHRpbi9hbS5jOjE1MTcKKyM6IGJ1aWx0aW4vYW0uYzoxNTA1CiBtc2dpZCAiIgogIkRpZCB5b3UgaGFuZCBlZGl0IHlvdXIgcGF0Y2g/XG4iCiAiSXQgZG9lcyBub3QgYXBwbHkgdG8gYmxvYnMgcmVjb3JkZWQgaW4gaXRzIGluZGV4LiIKIG1zZ3N0ciAiIgotIkVkaXRhc3RlIGVsIHBhcmNoZSBhIG1hbm8/XG4iCisiwr9FZGl0YXN0ZSBlbCBwYXJjaGUgYSBtYW5vP1xuIgogIk5vIGFwbGljYSBhIGJsb2JzIGd1YXJkYWRvcyBlbiBzdSDDrW5kaWNlLiIKIAotIzogYnVpbHRpbi9hbS5jOjE1MjMKKyM6IGJ1aWx0aW4vYW0uYzoxNTExCiBtc2dpZCAiRmFsbGluZyBiYWNrIHRvIHBhdGNoaW5nIGJhc2UgYW5kIDMtd2F5IG1lcmdlLi4uIgogbXNnc3RyICJSZXRyb2NlZGllbmRvIHBhcmEgcGFyY2hhciBiYXNlIHkgZnVzacOzbiBkZSAzLXbDrWFzLi4uIgogCi0jOiBidWlsdGluL2FtLmM6MTU0OQorIzogYnVpbHRpbi9hbS5jOjE1MzcKIG1zZ2lkICJGYWlsZWQgdG8gbWVyZ2UgaW4gdGhlIGNoYW5nZXMuIgogbXNnc3RyICJGYWxsw7MgYWwgZnVzaW9uYXIgZW4gbG9zIGNhbWJpb3MuIgogCi0jOiBidWlsdGluL2FtLmM6MTU4MQorIzogYnVpbHRpbi9hbS5jOjE1NjkKIG1zZ2lkICJhcHBseWluZyB0byBhbiBlbXB0eSBoaXN0b3J5IgogbXNnc3RyICJhcGxpY2FuZG8gYSB1biBoaXN0b3JpYWwgdmFjw61vIgogCi0jOiBidWlsdGluL2FtLmM6MTYyOCBidWlsdGluL2FtLmM6MTYzMgorIzogYnVpbHRpbi9hbS5jOjE2MTYgYnVpbHRpbi9hbS5jOjE2MjAKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IHJlc3VtZTogJXMgZG9lcyBub3QgZXhpc3QuIgogbXNnc3RyICJubyBzZSBwdWVkZSBjb250aW51YXI6ICVzIG5vIGV4aXN0ZS4iCiAKLSM6IGJ1aWx0aW4vYW0uYzoxNjUwCisjOiBidWlsdGluL2FtLmM6MTYzOAogbXNnaWQgIkNvbW1pdCBCb2R5IGlzOiIKIG1zZ3N0ciAiQ3VlcnBvIGRlIGNvbW1pdCBlczoiCiAKQEAgLTg3OTksNDUgKzg4MzgsNDkgQEAKICMuIGluIHlvdXIgdHJhbnNsYXRpb24uIFRoZSBwcm9ncmFtIHdpbGwgb25seSBhY2NlcHQgRW5nbGlzaAogIy4gaW5wdXQgYXQgdGhpcyBwb2ludC4KICMuCi0jOiBidWlsdGluL2FtLmM6MTY2MAorIzogYnVpbHRpbi9hbS5jOjE2NDgKICMsIGMtZm9ybWF0CiBtc2dpZCAiQXBwbHk/IFt5XWVzL1tuXW8vW2VdZGl0L1t2XWlldyBwYXRjaC9bYV1jY2VwdCBhbGw6ICIKLW1zZ3N0ciAiQXBsaWNhcj8gW3ldZXMvW25dby9bZV1kaXQvW3ZdaWV3IHBhdGNoL1thXWNjZXB0IGFsbDogIgorbXNnc3RyICLCv0FwbGljYXI/IFt5XWVzL1tuXW8vW2VdZGl0L1t2XWlldyBwYXRjaC9bYV1jY2VwdCBhbGw6ICIKIAotIzogYnVpbHRpbi9hbS5jOjE3MTAKKyM6IGJ1aWx0aW4vYW0uYzoxNjk1IGJ1aWx0aW4vY29tbWl0LmM6Mzc0Cittc2dpZCAidW5hYmxlIHRvIHdyaXRlIGluZGV4IGZpbGUiCittc2dzdHIgIm5vIGVzIHBvc2libGUgZXNjcmliaXIgZW4gZWwgYXJjaGl2byDDrW5kaWNlIgorCisjOiBidWlsdGluL2FtLmM6MTY5OQogIywgYy1mb3JtYXQKIG1zZ2lkICJEaXJ0eSBpbmRleDogY2Fubm90IGFwcGx5IHBhdGNoZXMgKGRpcnR5OiAlcykiCiBtc2dzdHIgIsONbmRpY2Ugc3VjaW86IG5vIHNlIHB1ZWRlIGFwbGljYXIgcGFyY2hlcyAoc3VjaW86ICVzKSIKIAotIzogYnVpbHRpbi9hbS5jOjE3NTAgYnVpbHRpbi9hbS5jOjE4MTgKKyM6IGJ1aWx0aW4vYW0uYzoxNzM5IGJ1aWx0aW4vYW0uYzoxODA3CiAjLCBjLWZvcm1hdAogbXNnaWQgIkFwcGx5aW5nOiAlLipzIgogbXNnc3RyICJBcGxpY2FuZG86ICUuKnMiCiAKLSM6IGJ1aWx0aW4vYW0uYzoxNzY3CisjOiBidWlsdGluL2FtLmM6MTc1NgogbXNnaWQgIk5vIGNoYW5nZXMgLS0gUGF0Y2ggYWxyZWFkeSBhcHBsaWVkLiIKIG1zZ3N0ciAiU2luIGNhbWJpb3MgLS0gcGFyY2hlIHlhIGFwbGljYWRvLiIKIAotIzogYnVpbHRpbi9hbS5jOjE3NzMKKyM6IGJ1aWx0aW4vYW0uYzoxNzYyCiAjLCBjLWZvcm1hdAogbXNnaWQgIlBhdGNoIGZhaWxlZCBhdCAlcyAlLipzIgogbXNnc3RyICJFbCBwYXJjaGUgZmFsbMOzIGVuICVzICUuKnMiCiAKLSM6IGJ1aWx0aW4vYW0uYzoxNzc3CisjOiBidWlsdGluL2FtLmM6MTc2NgogbXNnaWQgIlVzZSAnZ2l0IGFtIC0tc2hvdy1jdXJyZW50LXBhdGNoJyB0byBzZWUgdGhlIGZhaWxlZCBwYXRjaCIKIG1zZ3N0ciAiVXNlICdnaXQgYW0gLS1zaG93LWN1cnJlbnQtcGF0Y2gnIHBhcmEgdmVyIGVsIHBhcmNoZSBmYWxsaWRvIgogCi0jOiBidWlsdGluL2FtLmM6MTgyMQorIzogYnVpbHRpbi9hbS5jOjE4MTAKIG1zZ2lkICIiCiAiTm8gY2hhbmdlcyAtIGRpZCB5b3UgZm9yZ2V0IHRvIHVzZSAnZ2l0IGFkZCc/XG4iCiAiSWYgdGhlcmUgaXMgbm90aGluZyBsZWZ0IHRvIHN0YWdlLCBjaGFuY2VzIGFyZSB0aGF0IHNvbWV0aGluZyBlbHNlXG4iCiAiYWxyZWFkeSBpbnRyb2R1Y2VkIHRoZSBzYW1lIGNoYW5nZXM7IHlvdSBtaWdodCB3YW50IHRvIHNraXAgdGhpcyBwYXRjaC4iCiBtc2dzdHIgIiIKLSJTaW4gY2FtYmlvcyAtIG9sdmlkYXN0ZSB1c2FyICdnaXQgYWRkJz9cbiIKKyJTaW4gY2FtYmlvcyAtIMK/b2x2aWRhc3RlIHVzYXIgJ2dpdCBhZGQnP1xuIgogIlNpIG5vIGhheSBuYWRhIGVuIGVsIMOhcmVhIGRlIHN0YWdlLCBsYXMgcG9zaWJpbGlkYWQgZXMgcXVlIGFsZ28gbWFzXG4iCiAieWEgaGF5YSBpbnRyb2R1Y2lkbyBlbCBtaXNtbyBjYW1iaW87IHRhbCB2ZXogcXVpZXJhcyBvbWl0aXIgZXN0ZSBwYXJjaGUuIgogCi0jOiBidWlsdGluL2FtLmM6MTgyOAorIzogYnVpbHRpbi9hbS5jOjE4MTcKIG1zZ2lkICIiCiAiWW91IHN0aWxsIGhhdmUgdW5tZXJnZWQgcGF0aHMgaW4geW91ciBpbmRleC5cbiIKICJZb3Ugc2hvdWxkICdnaXQgYWRkJyBlYWNoIGZpbGUgd2l0aCByZXNvbHZlZCBjb25mbGljdHMgdG8gbWFyayB0aGVtIGFzICIKQEAgLTg4NTAsMTcgKzg4OTMsMTcgQEAKICJTZSBwdWVkZSBlamVjdXRhciBgZ2l0IHJtYCBlbiBlbCBhcmNoaXZvIHBhcmEgYWNlcHRhciBcImJvcnJhZG8gcG9yIGVsbG9zXCIgIgogImVuIMOpbC4iCiAKLSM6IGJ1aWx0aW4vYW0uYzoxOTM1IGJ1aWx0aW4vYW0uYzoxOTM5IGJ1aWx0aW4vYW0uYzoxOTUxIGJ1aWx0aW4vcmVzZXQuYzozMjkKKyM6IGJ1aWx0aW4vYW0uYzoxOTI0IGJ1aWx0aW4vYW0uYzoxOTI4IGJ1aWx0aW4vYW0uYzoxOTQwIGJ1aWx0aW4vcmVzZXQuYzozMjkKICM6IGJ1aWx0aW4vcmVzZXQuYzozMzcKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ291bGQgbm90IHBhcnNlIG9iamVjdCAnJXMnLiIKIG1zZ3N0ciAiTm8gc2UgcHVkbyBhbmFsaXphciBlbCBvYmpldG8gJyVzJy4iCiAKLSM6IGJ1aWx0aW4vYW0uYzoxOTg3CisjOiBidWlsdGluL2FtLmM6MTk3NgogbXNnaWQgImZhaWxlZCB0byBjbGVhbiBpbmRleCIKIG1zZ3N0ciAiZmFsbMOzIGFsIGxpbXBpYXIgZWwgw61uZGljZSIKIAotIzogYnVpbHRpbi9hbS5jOjIwMzEKKyM6IGJ1aWx0aW4vYW0uYzoyMDIwCiBtc2dpZCAiIgogIllvdSBzZWVtIHRvIGhhdmUgbW92ZWQgSEVBRCBzaW5jZSB0aGUgbGFzdCAnYW0nIGZhaWx1cmUuXG4iCiAiTm90IHJld2luZGluZyB0byBPUklHX0hFQUQiCkBAIC04ODY4LDE2MSArODkxMSwxNjEgQEAKICJQYXJlY2UgaGFiZXIgbW92aWRvIEhFQUQgZGVzZGUgZWwgw7psdGltbyBmYWxsw7MgJ2FtJy5cbiIKICJObyByZWJvYmluYW5kbyBhIE9SSUdfSEVBRCIKIAotIzogYnVpbHRpbi9hbS5jOjIxMjgKKyM6IGJ1aWx0aW4vYW0uYzoyMTE3CiAjLCBjLWZvcm1hdAogbXNnaWQgIkludmFsaWQgdmFsdWUgZm9yIC0tcGF0Y2gtZm9ybWF0OiAlcyIKIG1zZ3N0ciAiVmFsb3IgaW52w6FsaWRvIHBhcmEgLS1wYXRjaC1mb3JtYXQ6ICVzIgogCi0jOiBidWlsdGluL2FtLmM6MjE2NAorIzogYnVpbHRpbi9hbS5jOjIxNTMKIG1zZ2lkICJnaXQgYW0gWzxvcHRpb25zPl0gWyg8bWJveD4gfCA8TWFpbGRpcj4pLi4uXSIKIG1zZ3N0ciAiZ2l0IGFtIFs8b3BjaW9uZXM+XSBbKDxtYm94PiB8IDxEaXJlY3RvcmlvLWRlLWNvcnJlbz4pLi4uXSIKIAotIzogYnVpbHRpbi9hbS5jOjIxNjUKKyM6IGJ1aWx0aW4vYW0uYzoyMTU0CiBtc2dpZCAiZ2l0IGFtIFs8b3B0aW9ucz5dICgtLWNvbnRpbnVlIHwgLS1za2lwIHwgLS1hYm9ydCkiCiBtc2dzdHIgImdpdCBhbSBbPG9wY2lvbmVzPl0gKC0tY29udGludWUgfCAtLXNraXAgfCAtLWFib3J0KSIKIAotIzogYnVpbHRpbi9hbS5jOjIxNzEKKyM6IGJ1aWx0aW4vYW0uYzoyMTYwCiBtc2dpZCAicnVuIGludGVyYWN0aXZlbHkiCiBtc2dzdHIgImVqZWN1dGFyIGRlIG1hbmVyYSBpbnRlcmFjdGl2YSIKIAotIzogYnVpbHRpbi9hbS5jOjIxNzMKKyM6IGJ1aWx0aW4vYW0uYzoyMTYyCiBtc2dpZCAiaGlzdG9yaWNhbCBvcHRpb24gLS0gbm8tb3AiCiBtc2dzdHIgIm9wY2nDs24gaGlzdMOzcmljYSAtLSBuby1vcCIKIAotIzogYnVpbHRpbi9hbS5jOjIxNzUKKyM6IGJ1aWx0aW4vYW0uYzoyMTY0CiBtc2dpZCAiYWxsb3cgZmFsbCBiYWNrIG9uIDN3YXkgbWVyZ2luZyBpZiBuZWVkZWQiCiBtc2dzdHIgInBlcm1pdGlyIHJldHJvY2VzbyBlbiBmdXNpw7NuIGRlIDMtdsOtYXMgc2kgZXMgbmVjZXNhcmlvIgogCi0jOiBidWlsdGluL2FtLmM6MjE3NiBidWlsdGluL2luaXQtZGIuYzo0OTQgYnVpbHRpbi9wcnVuZS1wYWNrZWQuYzo1OAotIzogYnVpbHRpbi9yZXBhY2suYzoyOTYgYnVpbHRpbi9zdGFzaC5jOjgwNgorIzogYnVpbHRpbi9hbS5jOjIxNjUgYnVpbHRpbi9pbml0LWRiLmM6NDk0IGJ1aWx0aW4vcHJ1bmUtcGFja2VkLmM6NTgKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6Mjk3IGJ1aWx0aW4vc3Rhc2guYzo4MTIKIG1zZ2lkICJiZSBxdWlldCIKIG1zZ3N0ciAic2VyIHNpbGVuY2lvc28iCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMTc4CisjOiBidWlsdGluL2FtLmM6MjE2NwogbXNnaWQgImFkZCBhIFNpZ25lZC1vZmYtYnkgbGluZSB0byB0aGUgY29tbWl0IG1lc3NhZ2UiCiBtc2dzdHIgImFncmVnYXIgdW5hIGzDrW5lYSBcIkZpcm1hZG8tcG9yXCIgYWwgbWVuc2FqZSBkZWwgY29tbWl0IgogCi0jOiBidWlsdGluL2FtLmM6MjE4MQorIzogYnVpbHRpbi9hbS5jOjIxNzAKIG1zZ2lkICJyZWNvZGUgaW50byB1dGY4IChkZWZhdWx0KSIKIG1zZ3N0ciAicmVjb2RpZmljYXIgZW4gdXRmOCAoZGVmYXVsdCkiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMTgzCisjOiBidWlsdGluL2FtLmM6MjE3MgogbXNnaWQgInBhc3MgLWsgZmxhZyB0byBnaXQtbWFpbGluZm8iCiBtc2dzdHIgInBhc2FyIGZsYWcgLWsgYSBnaXQtbWFpbGluZm8iCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMTg1CisjOiBidWlsdGluL2FtLmM6MjE3NAogbXNnaWQgInBhc3MgLWIgZmxhZyB0byBnaXQtbWFpbGluZm8iCiBtc2dzdHIgInBhc2FyIGZsYWcgLWIgYSBnaXQtbWFpbGluZm8iCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMTg3CisjOiBidWlsdGluL2FtLmM6MjE3NgogbXNnaWQgInBhc3MgLW0gZmxhZyB0byBnaXQtbWFpbGluZm8iCiBtc2dzdHIgInBhc2FyIGZsYWcgLW0gYSBnaXQtbWFpbGluZm8iCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMTg5CisjOiBidWlsdGluL2FtLmM6MjE3OAogbXNnaWQgInBhc3MgLS1rZWVwLWNyIGZsYWcgdG8gZ2l0LW1haWxzcGxpdCBmb3IgbWJveCBmb3JtYXQiCiBtc2dzdHIgInBhc2FyIGZsYWcgLS1rZWVwLWNyIGEgZ2l0LW1haWxzcGxpdCBwYXJhIGZvcm1hdG8gbWJveCIKIAotIzogYnVpbHRpbi9hbS5jOjIxOTIKKyM6IGJ1aWx0aW4vYW0uYzoyMTgxCiBtc2dpZCAiZG8gbm90IHBhc3MgLS1rZWVwLWNyIGZsYWcgdG8gZ2l0LW1haWxzcGxpdCBpbmRlcGVuZGVudCBvZiBhbS5rZWVwY3IiCiBtc2dzdHIgIiIKICJubyBwYXNhciBmbGFnIC0ta2VlcC1jciBhIGdpdC1tYWlsc3BsaXQgaW5kZXBlbmRpZW50ZW1lbnRlIGRlIGFtLmtlZXBjciIKIAotIzogYnVpbHRpbi9hbS5jOjIxOTUKKyM6IGJ1aWx0aW4vYW0uYzoyMTg0CiBtc2dpZCAic3RyaXAgZXZlcnl0aGluZyBiZWZvcmUgYSBzY2lzc29ycyBsaW5lIgogbXNnc3RyICJkZXNjdWJyaXIgdG9kbyBhbnRlcyBkZSB1bmEgbMOtbmVhIGRlIHRpamVyYXMiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMTk3IGJ1aWx0aW4vYW0uYzoyMjAwIGJ1aWx0aW4vYW0uYzoyMjAzIGJ1aWx0aW4vYW0uYzoyMjA2Ci0jOiBidWlsdGluL2FtLmM6MjIwOSBidWlsdGluL2FtLmM6MjIxMiBidWlsdGluL2FtLmM6MjIxNSBidWlsdGluL2FtLmM6MjIxOAotIzogYnVpbHRpbi9hbS5jOjIyMjQKKyM6IGJ1aWx0aW4vYW0uYzoyMTg2IGJ1aWx0aW4vYW0uYzoyMTg5IGJ1aWx0aW4vYW0uYzoyMTkyIGJ1aWx0aW4vYW0uYzoyMTk1CisjOiBidWlsdGluL2FtLmM6MjE5OCBidWlsdGluL2FtLmM6MjIwMSBidWlsdGluL2FtLmM6MjIwNCBidWlsdGluL2FtLmM6MjIwNworIzogYnVpbHRpbi9hbS5jOjIyMTMKIG1zZ2lkICJwYXNzIGl0IHRocm91Z2ggZ2l0LWFwcGx5IgogbXNnc3RyICJwYXNhcmxvIGEgdHJhdsOpcyBkZSBnaXQtYXBwbHkiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMjE0IGJ1aWx0aW4vY29tbWl0LmM6MTM2OCBidWlsdGluL2ZtdC1tZXJnZS1tc2cuYzo2NzEKLSM6IGJ1aWx0aW4vZm10LW1lcmdlLW1zZy5jOjY3NCBidWlsdGluL2dyZXAuYzo4ODEgYnVpbHRpbi9tZXJnZS5jOjI0OQotIzogYnVpbHRpbi9wdWxsLmM6MTU5IGJ1aWx0aW4vcHVsbC5jOjIxOCBidWlsdGluL3JlYmFzZS5jOjE0MTgKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MzA3IGJ1aWx0aW4vcmVwYWNrLmM6MzExIGJ1aWx0aW4vcmVwYWNrLmM6MzEzCisjOiBidWlsdGluL2FtLmM6MjIwMyBidWlsdGluL2NvbW1pdC5jOjEzNjggYnVpbHRpbi9mbXQtbWVyZ2UtbXNnLmM6NjcxCisjOiBidWlsdGluL2ZtdC1tZXJnZS1tc2cuYzo2NzQgYnVpbHRpbi9ncmVwLmM6ODgzIGJ1aWx0aW4vbWVyZ2UuYzoyNDkKKyM6IGJ1aWx0aW4vcHVsbC5jOjE2MCBidWlsdGluL3B1bGwuYzoyMTkgYnVpbHRpbi9yZWJhc2UuYzoxNDQyCisjOiBidWlsdGluL3JlcGFjay5jOjMwOCBidWlsdGluL3JlcGFjay5jOjMxMiBidWlsdGluL3JlcGFjay5jOjMxNAogIzogYnVpbHRpbi9zaG93LWJyYW5jaC5jOjY1MCBidWlsdGluL3Nob3ctcmVmLmM6MTcyIGJ1aWx0aW4vdGFnLmM6NDAzCi0jOiBwYXJzZS1vcHRpb25zLmg6MTQxIHBhcnNlLW9wdGlvbnMuaDoxNjIgcGFyc2Utb3B0aW9ucy5oOjMxMgorIzogcGFyc2Utb3B0aW9ucy5oOjE1MCBwYXJzZS1vcHRpb25zLmg6MTcxIHBhcnNlLW9wdGlvbnMuaDozMTIKIG1zZ2lkICJuIgogbXNnc3RyICJuIgogCi0jOiBidWlsdGluL2FtLmM6MjIyMCBidWlsdGluL2JyYW5jaC5jOjY2MSBidWlsdGluL2Zvci1lYWNoLXJlZi5jOjM4Ci0jOiBidWlsdGluL3JlcGxhY2UuYzo1NTQgYnVpbHRpbi90YWcuYzo0MzcgYnVpbHRpbi92ZXJpZnktdGFnLmM6MzgKKyM6IGJ1aWx0aW4vYW0uYzoyMjA5IGJ1aWx0aW4vYnJhbmNoLmM6NjYxIGJ1aWx0aW4vZm9yLWVhY2gtcmVmLmM6MzgKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU1NSBidWlsdGluL3RhZy5jOjQzNyBidWlsdGluL3ZlcmlmeS10YWcuYzozOAogbXNnaWQgImZvcm1hdCIKIG1zZ3N0ciAiZm9ybWF0byIKIAotIzogYnVpbHRpbi9hbS5jOjIyMjEKKyM6IGJ1aWx0aW4vYW0uYzoyMjEwCiBtc2dpZCAiZm9ybWF0IHRoZSBwYXRjaChlcykgYXJlIGluIgogbXNnc3RyICJmb3JtYXRlYXIgZWwgcGFyY2hlKHMpIgogCi0jOiBidWlsdGluL2FtLmM6MjIyNworIzogYnVpbHRpbi9hbS5jOjIyMTYKIG1zZ2lkICJvdmVycmlkZSBlcnJvciBtZXNzYWdlIHdoZW4gcGF0Y2ggZmFpbHVyZSBvY2N1cnMiCiBtc2dzdHIgInNvYnJlc2NyaWJpciBtZW5zYWplcyBkZSBlcnJvciBjdWFuZG8gZmFsbG9zIGRlIHBhcmNoYWRvIG9jdXJyYW4iCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMjI5CisjOiBidWlsdGluL2FtLmM6MjIxOAogbXNnaWQgImNvbnRpbnVlIGFwcGx5aW5nIHBhdGNoZXMgYWZ0ZXIgcmVzb2x2aW5nIGEgY29uZmxpY3QiCiBtc2dzdHIgImNvbnRpbnVhciBhcGxpY2FuZG8gbG9zIHBhcmNoZXMgdHJhcyByZXNvbHZlciBjb25mbGljdG9zIgogCi0jOiBidWlsdGluL2FtLmM6MjIzMgorIzogYnVpbHRpbi9hbS5jOjIyMjEKIG1zZ2lkICJzeW5vbnltcyBmb3IgLS1jb250aW51ZSIKIG1zZ3N0ciAic2luw7NuaW1vcyBwYXJhIC0tY29udGludWUiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMjM1CisjOiBidWlsdGluL2FtLmM6MjIyNAogbXNnaWQgInNraXAgdGhlIGN1cnJlbnQgcGF0Y2giCiBtc2dzdHIgInNhbHRhciBlbCBwYXJjaGUgYWN0dWFsIgogCi0jOiBidWlsdGluL2FtLmM6MjIzOAorIzogYnVpbHRpbi9hbS5jOjIyMjcKIG1zZ2lkICJyZXN0b3JlIHRoZSBvcmlnaW5hbCBicmFuY2ggYW5kIGFib3J0IHRoZSBwYXRjaGluZyBvcGVyYXRpb24uIgogbXNnc3RyICJyZXN0YXVyYXIgbGEgcmFtYSBvcmlnaW5hbCB5IGFib3J0YXIgbGEgb3BlcmFjacOzbiBkZSBwYXJjaGFkby4iCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMjQxCisjOiBidWlsdGluL2FtLmM6MjIzMAogbXNnaWQgImFib3J0IHRoZSBwYXRjaGluZyBvcGVyYXRpb24gYnV0IGtlZXAgSEVBRCB3aGVyZSBpdCBpcy4iCiBtc2dzdHIgImFib3J0YXIgbGEgb3BlcmFjacOzbiBkZSBwYXJjaGFkbyBwZXJvIG1hbnRlbmVyIEhFQUQgZG9uZGUgZXN0w6EuIgogCi0jOiBidWlsdGluL2FtLmM6MjI0NAorIzogYnVpbHRpbi9hbS5jOjIyMzMKIG1zZ2lkICJzaG93IHRoZSBwYXRjaCBiZWluZyBhcHBsaWVkLiIKIG1zZ3N0ciAibXVlc3RyYSBlbCBwYXJjaGUgc2llbmRvIGFwbGljYWRvLiIKIAotIzogYnVpbHRpbi9hbS5jOjIyNDgKKyM6IGJ1aWx0aW4vYW0uYzoyMjM3CiBtc2dpZCAibGllIGFib3V0IGNvbW1pdHRlciBkYXRlIgogbXNnc3RyICJtZW50aXIgc29icmUgbGEgZmVjaGEgZGVsIGNvbW1pdHRlciIKIAotIzogYnVpbHRpbi9hbS5jOjIyNTAKKyM6IGJ1aWx0aW4vYW0uYzoyMjM5CiBtc2dpZCAidXNlIGN1cnJlbnQgdGltZXN0YW1wIGZvciBhdXRob3IgZGF0ZSIKIG1zZ3N0ciAidXNhciBlbCB0aW1lc3RhbXAgYWN0dWFsIHBhcmEgbGEgZmVjaGEgZGVsIGF1dG9yIgogCi0jOiBidWlsdGluL2FtLmM6MjI1MiBidWlsdGluL2NvbW1pdC10cmVlLmM6MTIwIGJ1aWx0aW4vY29tbWl0LmM6MTUxMQotIzogYnVpbHRpbi9tZXJnZS5jOjI4NiBidWlsdGluL3B1bGwuYzoxOTMgYnVpbHRpbi9yZWJhc2UuYzo0ODkKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ1OSBidWlsdGluL3JldmVydC5jOjExNyBidWlsdGluL3RhZy5jOjQxOAorIzogYnVpbHRpbi9hbS5jOjIyNDEgYnVpbHRpbi9jb21taXQtdHJlZS5jOjEyMCBidWlsdGluL2NvbW1pdC5jOjE1MTEKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoyODYgYnVpbHRpbi9wdWxsLmM6MTk0IGJ1aWx0aW4vcmViYXNlLmM6NDkwCisjOiBidWlsdGluL3JlYmFzZS5jOjE0ODMgYnVpbHRpbi9yZXZlcnQuYzoxMTcgYnVpbHRpbi90YWcuYzo0MTgKIG1zZ2lkICJrZXktaWQiCiBtc2dzdHIgImtleS1pZCIKIAotIzogYnVpbHRpbi9hbS5jOjIyNTMgYnVpbHRpbi9yZWJhc2UuYzo0OTAgYnVpbHRpbi9yZWJhc2UuYzoxNDYwCisjOiBidWlsdGluL2FtLmM6MjI0MiBidWlsdGluL3JlYmFzZS5jOjQ5MSBidWlsdGluL3JlYmFzZS5jOjE0ODQKIG1zZ2lkICJHUEctc2lnbiBjb21taXRzIgogbXNnc3RyICJDb21taXRzIGNvbiBmaXJtYSBHUEciCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMjU2CisjOiBidWlsdGluL2FtLmM6MjI0NQogbXNnaWQgIihpbnRlcm5hbCB1c2UgZm9yIGdpdC1yZWJhc2UpIgogbXNnc3RyICIodXNvIGludGVybm8gcGFyYSBnaXQtcmViYXNlKSIKIAotIzogYnVpbHRpbi9hbS5jOjIyNzQKKyM6IGJ1aWx0aW4vYW0uYzoyMjYzCiBtc2dpZCAiIgogIlRoZSAtYi8tLWJpbmFyeSBvcHRpb24gaGFzIGJlZW4gYSBuby1vcCBmb3IgbG9uZyB0aW1lLCBhbmRcbiIKICJpdCB3aWxsIGJlIHJlbW92ZWQuIFBsZWFzZSBkbyBub3QgdXNlIGl0IGFueW1vcmUuIgogbXNnc3RyICIiCiAiTGEgb3BjacOzbiAtYi8tLWJpbmFyeSBoYSBlc3RhZG8gZGVzaGFiaWxpdGFkYSBwb3IgbXVjaG8gdGllbXBvLCB5XG4iCi0ic2Vyw6EgcmVtb3ZpZGEuIFBvciBmYXZvciBubyBsYSB1c2UgbcOhcy4iCisic2Vyw6EgZWxpbWluYWRhLiBQb3IgZmF2b3Igbm8gbGEgdXNlIG3DoXMuIgogCi0jOiBidWlsdGluL2FtLmM6MjI4MQorIzogYnVpbHRpbi9hbS5jOjIyNzAKIG1zZ2lkICJmYWlsZWQgdG8gcmVhZCB0aGUgaW5kZXgiCiBtc2dzdHIgImZhbGzDsyBhbCBsZWVyIGVsIMOtbmRpY2UiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMjk2CisjOiBidWlsdGluL2FtLmM6MjI4NQogIywgYy1mb3JtYXQKIG1zZ2lkICJwcmV2aW91cyByZWJhc2UgZGlyZWN0b3J5ICVzIHN0aWxsIGV4aXN0cyBidXQgbWJveCBnaXZlbi4iCiBtc2dzdHIgImRpcmVjdG9yaW8gZGUgcmViYXNlIHByZXZpbyAlcyB0b2RhdsOtYSBleGlzdGUgZW4gZWwgbWJveCBkYWRvLiIKIAotIzogYnVpbHRpbi9hbS5jOjIzMjAKKyM6IGJ1aWx0aW4vYW0uYzoyMzA5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJTdHJheSAlcyBkaXJlY3RvcnkgZm91bmQuXG4iCkBAIC05MDMxLDExICs5MDc0LDExIEBACiAiRGlyZWN0b3JpbyBleHRyYXZpYWRvICVzIGVuY29udHJhZG8uXG4iCiAiVXNlIFwiZ2l0IGFtIC0tYWJvcnRcIiBwYXJhIGJvcnJhcmxvLiIKIAotIzogYnVpbHRpbi9hbS5jOjIzMjYKKyM6IGJ1aWx0aW4vYW0uYzoyMzE1CiBtc2dpZCAiUmVzb2x2ZSBvcGVyYXRpb24gbm90IGluIHByb2dyZXNzLCB3ZSBhcmUgbm90IHJlc3VtaW5nLiIKIG1zZ3N0ciAiT3BlcmFjacOzbiBkZSByZXNvbHVjacOzbiBubyBlc3TDoSBlbiBwcm9ncmVzbywgbm8gdmFtb3MgYSBjb250aW51YXIuIgogCi0jOiBidWlsdGluL2FtLmM6MjMzNgorIzogYnVpbHRpbi9hbS5jOjIzMjUKIG1zZ2lkICJpbnRlcmFjdGl2ZSBtb2RlIHJlcXVpcmVzIHBhdGNoZXMgb24gdGhlIGNvbW1hbmQgbGluZSIKIG1zZ3N0ciAibW9kbyBpbnRlcmFjdGl2byByZXF1aWVyZSBwYXJjaGVzIGVuIGxhIGzDrW5lYSBkZSBjb21hbmRvIgogCkBAIC05MzUwLDE1NCArOTM5MywxNTQgQEAKIG1zZ2lkICItLWJpc2VjdC10ZXJtcyByZXF1aXJlcyAwIG9yIDEgYXJndW1lbnQiCiBtc2dzdHIgIi0tYmlzZWN0LXRlcm1zIHJlcXVpZXJlIDAgbyAxIGFyZ3VtZW50b3MiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzozMgorIzogYnVpbHRpbi9ibGFtZS5jOjMxCiBtc2dpZCAiZ2l0IGJsYW1lIFs8b3B0aW9ucz5dIFs8cmV2LW9wdHM+XSBbPHJldj5dIFstLV0gPGZpbGU+IgogbXNnc3RyICJnaXQgYmxhbWUgWzxvcGNpb25lcz5dIFs8b3BjaW9uZXMtcmV2Pl0gWzxyZXZpc2lvbj5dIFstLV0gPGFyY2hpdm8+IgogCi0jOiBidWlsdGluL2JsYW1lLmM6MzcKKyM6IGJ1aWx0aW4vYmxhbWUuYzozNgogbXNnaWQgIjxyZXYtb3B0cz4gYXJlIGRvY3VtZW50ZWQgaW4gZ2l0LXJldi1saXN0KDEpIgogbXNnc3RyICI8cmV2LW9wdHM+IGVzdMOhbiBkb2N1bWVudGFkYXMgZW4gZ2l0LXJldi1saXN0KDEpIgogCi0jOiBidWlsdGluL2JsYW1lLmM6NDEwCisjOiBidWlsdGluL2JsYW1lLmM6NDA5CiAjLCBjLWZvcm1hdAogbXNnaWQgImV4cGVjdGluZyBhIGNvbG9yOiAlcyIKIG1zZ3N0ciAiZXNwZXJhbmRvIHVuIGNvbG9yOiAlcyIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjQxNworIzogYnVpbHRpbi9ibGFtZS5jOjQxNgogbXNnaWQgIm11c3QgZW5kIHdpdGggYSBjb2xvciIKIG1zZ3N0ciAidGllbmUgcXVlIHRlcm1pbmFyIGNvbiB1biBjb2xvciIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjczMAorIzogYnVpbHRpbi9ibGFtZS5jOjcyOQogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIGNvbG9yICclcycgaW4gY29sb3IuYmxhbWUucmVwZWF0ZWRMaW5lcyIKIG1zZ3N0ciAiY29sb3IgaW52w6FsaWRvICclcycgZW4gY29sb3IuYmxhbWUucmVwZWF0ZWRMaW5lcyIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjc0OAorIzogYnVpbHRpbi9ibGFtZS5jOjc0NwogbXNnaWQgImludmFsaWQgdmFsdWUgZm9yIGJsYW1lLmNvbG9yaW5nIgogbXNnc3RyICJ2YWxvciBpbnbDoWxpZG8gcGFyYSBibGFtZS5jb2xvcmluZyIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjgyMworIzogYnVpbHRpbi9ibGFtZS5jOjgyMgogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgZmluZCByZXZpc2lvbiAlcyB0byBpZ25vcmUiCiBtc2dzdHIgIm5vIHNlIHB1ZG8gZW5jb250cmFyIHJldmlzaW9uICVzIHBhcmEgaWdub3JhciIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg0NQorIzogYnVpbHRpbi9ibGFtZS5jOjg0NAogbXNnaWQgIlNob3cgYmxhbWUgZW50cmllcyBhcyB3ZSBmaW5kIHRoZW0sIGluY3JlbWVudGFsbHkiCiBtc2dzdHIgIk1vc3RyYXIgbGFzIGVudHJhZGFzIGJsYW1lIGNvbW8gbGFzIGVuY29udHJhbW9zLCBpbmNyZW1lbnRhbG1lbnRlIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODQ2CisjOiBidWlsdGluL2JsYW1lLmM6ODQ1CiBtc2dpZCAiU2hvdyBibGFuayBTSEEtMSBmb3IgYm91bmRhcnkgY29tbWl0cyAoRGVmYXVsdDogb2ZmKSIKIG1zZ3N0ciAiTW9zdHJhciBTSEEtMSBlbiBibGFuY28gcGFyYSBjb21taXRzIGV4dHJlbW9zIChEZWZhdWx0OiBvZmYpIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODQ3CisjOiBidWlsdGluL2JsYW1lLmM6ODQ2CiBtc2dpZCAiRG8gbm90IHRyZWF0IHJvb3QgY29tbWl0cyBhcyBib3VuZGFyaWVzIChEZWZhdWx0OiBvZmYpIgogbXNnc3RyICJObyB0cmF0YXIgY29tbWl0cyByYcOtY2VzIGNvbW8gZXh0cmVtb3MgKERlZmF1bHQ6IG9mZikiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NDgKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NDcKIG1zZ2lkICJTaG93IHdvcmsgY29zdCBzdGF0aXN0aWNzIgogbXNnc3RyICJNb3N0cmFyIGVzdGFkw61zdGljYXMgZGUgY29zdG8gZGUgdHJhYmFqbyIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg0OQorIzogYnVpbHRpbi9ibGFtZS5jOjg0OAogbXNnaWQgIkZvcmNlIHByb2dyZXNzIHJlcG9ydGluZyIKIG1zZ3N0ciAiRm9yemFyIGVsIHJlcG9ydGUgZGUgcHJvZ3Jlc28iCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NTAKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NDkKIG1zZ2lkICJTaG93IG91dHB1dCBzY29yZSBmb3IgYmxhbWUgZW50cmllcyIKIG1zZ3N0ciAiTW9zdHJhciBsYSBwdW50dWFjacOzbiBkZSBzYWxpZGEgZGUgbGFzIGVudHJhZGFzIGRlIGJsYW1lIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODUxCisjOiBidWlsdGluL2JsYW1lLmM6ODUwCiBtc2dpZCAiU2hvdyBvcmlnaW5hbCBmaWxlbmFtZSAoRGVmYXVsdDogYXV0bykiCiBtc2dzdHIgIk1vc3RyYXIgbm9tYnJlIG9yaWdpbmFsIGRlbCBhcmNoaXZvIChEZWZhdWx0OiBhdXRvKSIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg1MgorIzogYnVpbHRpbi9ibGFtZS5jOjg1MQogbXNnaWQgIlNob3cgb3JpZ2luYWwgbGluZW51bWJlciAoRGVmYXVsdDogb2ZmKSIKIG1zZ3N0ciAiTW9zdHJhciBuw7ptZXJvIGRlIGzDrW5lYSBvcmlnaW5hbCAoRGVmYXVsdDogb2ZmKSIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg1MworIzogYnVpbHRpbi9ibGFtZS5jOjg1MgogbXNnaWQgIlNob3cgaW4gYSBmb3JtYXQgZGVzaWduZWQgZm9yIG1hY2hpbmUgY29uc3VtcHRpb24iCiBtc2dzdHIgIk1vc3RyYXIgZW4gdW4gZm9ybWF0byBkaXNlw7FhZG8gcGFyYSBjb25zdW1vIGRlIG3DoXF1aW5hIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODU0CisjOiBidWlsdGluL2JsYW1lLmM6ODUzCiBtc2dpZCAiU2hvdyBwb3JjZWxhaW4gZm9ybWF0IHdpdGggcGVyLWxpbmUgY29tbWl0IGluZm9ybWF0aW9uIgogbXNnc3RyICJNb3N0cmFyIGVuIGZvcm1hdG8gcG9yY2VsYW5hIGNvbiBpbmZvcm1hY2nDs24gZGUgY29tbWl0IHBvciBsw61uZWEiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NTUKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NTQKIG1zZ2lkICJVc2UgdGhlIHNhbWUgb3V0cHV0IG1vZGUgYXMgZ2l0LWFubm90YXRlIChEZWZhdWx0OiBvZmYpIgogbXNnc3RyICJVc2FyIGVsIG1pc21vIG1vZG8gc2FsaWRhIGNvbW8gZ2l0LWFubm90YXRlIChEZWZhdWx0OiBvZmYpIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODU2CisjOiBidWlsdGluL2JsYW1lLmM6ODU1CiBtc2dpZCAiU2hvdyByYXcgdGltZXN0YW1wIChEZWZhdWx0OiBvZmYpIgogbXNnc3RyICJNb3N0cmFyIHRpbWVzdGFtcCBlbiBmb3JtYXRvIHJhdyAoRGVmYXVsdDogb2ZmKSIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg1NworIzogYnVpbHRpbi9ibGFtZS5jOjg1NgogbXNnaWQgIlNob3cgbG9uZyBjb21taXQgU0hBMSAoRGVmYXVsdDogb2ZmKSIKIG1zZ3N0ciAiTW9zdHJhciBTSEExIGRlbCBjb21taXQgZW4gZm9ybWF0byBsYXJnbyAoRGVmYXVsdDogb2ZmKSIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg1OAorIzogYnVpbHRpbi9ibGFtZS5jOjg1NwogbXNnaWQgIlN1cHByZXNzIGF1dGhvciBuYW1lIGFuZCB0aW1lc3RhbXAgKERlZmF1bHQ6IG9mZikiCiBtc2dzdHIgIlN1cHJpbWlyIG5vbWJyZSBkZWwgYXV0b3IgeSB0aW1lc3RhbXAgKERlZmF1bHQ6IG9mZikiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NTkKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NTgKIG1zZ2lkICJTaG93IGF1dGhvciBlbWFpbCBpbnN0ZWFkIG9mIG5hbWUgKERlZmF1bHQ6IG9mZikiCiBtc2dzdHIgIk1vc3RyYXIgZW4gY2FtYmlvIGVsIGVtYWlsIGRlbCBhdXRvciAoRGVmYXVsdDogb2ZmKSIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg2MAorIzogYnVpbHRpbi9ibGFtZS5jOjg1OQogbXNnaWQgIklnbm9yZSB3aGl0ZXNwYWNlIGRpZmZlcmVuY2VzIgogbXNnc3RyICJJZ25vcmFyIGRpZmVyZW5jaWFzIGRlIGVzcGFjaW9zIGVuIGJsYW5jbyIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg2MSBidWlsdGluL2xvZy5jOjE2MjkKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NjAgYnVpbHRpbi9sb2cuYzoxNjMwCiBtc2dpZCAicmV2IgogbXNnc3RyICJyZXYiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NjEKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NjAKIG1zZ2lkICJJZ25vcmUgPHJldj4gd2hlbiBibGFtaW5nIgogbXNnc3RyICJpZ25vcmFyIDxyZXY+IGR1cmFudGUgZWwgYmxhbWUiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NjIKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NjEKIG1zZ2lkICJJZ25vcmUgcmV2aXNpb25zIGZyb20gPGZpbGU+IgogbXNnc3RyICJpZ25vcmFyIHJldmlzaW9uZXMgZGUgPGFyY2hpdm8+IgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODYzCisjOiBidWlsdGluL2JsYW1lLmM6ODYyCiBtc2dpZCAiY29sb3IgcmVkdW5kYW50IG1ldGFkYXRhIGZyb20gcHJldmlvdXMgbGluZSBkaWZmZXJlbnRseSIKIG1zZ3N0ciAiY29sb3JlYXIgbWV0YWRhdGEgcmVkdW5kYW50ZSBkZSBsw61uZWFzIHByZXZpYXMgZGUgbWFuZXJhIGRpZmVyZW50ZSIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg2NAorIzogYnVpbHRpbi9ibGFtZS5jOjg2MwogbXNnaWQgImNvbG9yIGxpbmVzIGJ5IGFnZSIKIG1zZ3N0ciAiY29sb3JlYXIgbMOtbmVhcyBwb3IgZWRhZCIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg3MQorIzogYnVpbHRpbi9ibGFtZS5jOjg3MAogbXNnaWQgIlVzZSBhbiBleHBlcmltZW50YWwgaGV1cmlzdGljIHRvIGltcHJvdmUgZGlmZnMiCiBtc2dzdHIgIlVzYXIgdW4gaGV1csOtc3RpY28gZXhwZXJpbWVudGFsIHBhcmEgbWVqb3JhciBsb3MgZGlmZnMiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NzMKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NzIKIG1zZ2lkICJTcGVuZCBleHRyYSBjeWNsZXMgdG8gZmluZCBiZXR0ZXIgbWF0Y2giCiBtc2dzdHIgIk9jdXBvIG3DoXMgY2ljbG9zIHBhcmEgZW5jb250cmFyIG1lam9yYXMgcmVzdWx0YWRvcyIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg3NAorIzogYnVpbHRpbi9ibGFtZS5jOjg3MwogbXNnaWQgIlVzZSByZXZpc2lvbnMgZnJvbSA8ZmlsZT4gaW5zdGVhZCBvZiBjYWxsaW5nIGdpdC1yZXYtbGlzdCIKIG1zZ3N0ciAiVXNlIHJldmlzaW9uZXMgZGVzZGUgPGFyY2hpdm8+IGVuIGx1Z2FyIGRlIGxsYW1hciBnaXQtcmV2LWxpc3QiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NzUKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NzQKIG1zZ2lkICJVc2UgPGZpbGU+J3MgY29udGVudHMgYXMgdGhlIGZpbmFsIGltYWdlIgogbXNnc3RyICJVc2FyIGNvbnRlbmlkbyBkZSA8YXJjaGl2bz4gY29tbyBpbWFnZW4gZmluYWwiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NzYgYnVpbHRpbi9ibGFtZS5jOjg3NworIzogYnVpbHRpbi9ibGFtZS5jOjg3NSBidWlsdGluL2JsYW1lLmM6ODc2CiBtc2dpZCAic2NvcmUiCiBtc2dzdHIgInB1bnRhamUiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NzYKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NzUKIG1zZ2lkICJGaW5kIGxpbmUgY29waWVzIHdpdGhpbiBhbmQgYWNyb3NzIGZpbGVzIgogbXNnc3RyICJFbmNvbnRyYXIgY29waWFzIGRlIGzDrW5lYXMgZW50cmUgeSBhIHRyYXbDqXMgZGUgYXJjaGl2b3MiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NzcKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NzYKIG1zZ2lkICJGaW5kIGxpbmUgbW92ZW1lbnRzIHdpdGhpbiBhbmQgYWNyb3NzIGZpbGVzIgogbXNnc3RyICJFbmNvbnRyYXIgbW92aW1pZW50b3MgZGUgbMOtbmVhcyBlbnRyZSB5IGEgdHJhdsOpcyBkZSBhcmNoaXZvcyIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg3OAorIzogYnVpbHRpbi9ibGFtZS5jOjg3NwogbXNnaWQgIm4sbSIKIG1zZ3N0ciAibixtIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODc4CisjOiBidWlsdGluL2JsYW1lLmM6ODc3CiBtc2dpZCAiUHJvY2VzcyBvbmx5IGxpbmUgcmFuZ2UgbixtLCBjb3VudGluZyBmcm9tIDEiCiBtc2dzdHIgIlByb2Nlc2FyIHNvbG8gZWwgcmFuZ28gZGUgbMOtbmVhcyBuLG0sIGNvbnRhbmRvIGRlc2RlIDEiCiAKQEAgLTk3MTUsNyArOTc1OCw3IEBACiBtc2dzdHIgIiIKICJQb3IgZmF2b3IsIGVkaXRhIGxhIGRlc2NyaXBjacOzbiBwYXJhIGxhIHJhbWFcbiIKICIlc1xuIgotIkxhcyBsw61uZWFzIHF1ZSBjb21pZW5jZW4gY29uICclYycgc2Vyw6FuIHJlbW92aWRhcy5cbiIKKyJMYXMgbMOtbmVhcyBxdWUgY29taWVuY2VuIGNvbiAnJWMnIHNlcsOhbiBlbGltaW5hZGFzLlxuIgogCiAjOiBidWlsdGluL2JyYW5jaC5jOjYxOAogbXNnaWQgIkdlbmVyaWMgb3B0aW9ucyIKQEAgLTk3MzcsNyArOTc4MCw3IEBACiBtc2dpZCAiZG8gbm90IHVzZSIKIG1zZ3N0ciAibm8gdXNhciIKIAotIzogYnVpbHRpbi9icmFuY2guYzo2MjYgYnVpbHRpbi9yZWJhc2UuYzo0ODUKKyM6IGJ1aWx0aW4vYnJhbmNoLmM6NjI2IGJ1aWx0aW4vcmViYXNlLmM6NDg2CiBtc2dpZCAidXBzdHJlYW0iCiBtc2dzdHIgInVwc3RyZWFtIgogCkBAIC05ODQ4LDkgKzk4OTEsOSBAQAogbXNnaWQgImZvcm1hdCB0byB1c2UgZm9yIHRoZSBvdXRwdXQiCiBtc2dzdHIgImZvcm1hdG8gcGFyYSB1c2FyIHBhcmEgZWwgb3V0cHV0IgogCi0jOiBidWlsdGluL2JyYW5jaC5jOjY4NCBidWlsdGluL2Nsb25lLmM6NzYxCisjOiBidWlsdGluL2JyYW5jaC5jOjY4NCBidWlsdGluL2Nsb25lLmM6NzYwCiBtc2dpZCAiSEVBRCBub3QgZm91bmQgYmVsb3cgcmVmcy9oZWFkcyEiCi1tc2dzdHIgIkhFQUQgbm8gZW5jb250cmFkbyBhYmFqbyBkZSByZWZzL2hlYWRzISIKK21zZ3N0ciAiwqFIRUFEIG5vIGVuY29udHJhZG8gYWJham8gZGUgcmVmcy9oZWFkcyEiCiAKICM6IGJ1aWx0aW4vYnJhbmNoLmM6NzA4CiBtc2dpZCAiLS1jb2x1bW4gYW5kIC0tdmVyYm9zZSBhcmUgaW5jb21wYXRpYmxlIgpAQCAtOTk1Miw3ICs5OTk1LDcgQEAKIG1zZ2lkICJOZWVkIGEgcmVwb3NpdG9yeSB0byB1bmJ1bmRsZS4iCiBtc2dzdHIgIlNlIG5lY2VzaXRhIHVuIHJlcG9zaXRvcmlvIHBhcmEgZGVzYWdydXBhci4iCiAKLSM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo1OTQKKyM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo1OTUKIG1zZ2lkICIiCiAiZ2l0IGNhdC1maWxlICgtdCBbLS1hbGxvdy11bmtub3duLXR5cGVdIHwgLXMgWy0tYWxsb3ctdW5rbm93bi10eXBlXSB8IC1lIHwgLSIKICJwIHwgPHR5cGU+IHwgLS10ZXh0Y29udiB8IC0tZmlsdGVycykgWy0tcGF0aD08cGF0aD5dIDxvYmplY3Q+IgpAQCAtOTk2MCw3ICsxMDAwMyw3IEBACiAiZ2l0IGNhdC1maWxlICgtdCBbLS1hbGxvdy11bmtub3duLXR5cGVdIHwgLXMgWy0tYWxsb3ctdW5rbm93bi10eXBlXSB8IC1lIHwgLSIKICJwIHwgPHRpcG8+IHwgLS10ZXh0Y29udiB8IC0tZmlsdGVycykgWy0tcGF0aD08cnV0YT5dIDxvYmpldG8+IgogCi0jOiBidWlsdGluL2NhdC1maWxlLmM6NTk1CisjOiBidWlsdGluL2NhdC1maWxlLmM6NTk2CiBtc2dpZCAiIgogImdpdCBjYXQtZmlsZSAoLS1iYXRjaCB8IC0tYmF0Y2gtY2hlY2spIFstLWZvbGxvdy1zeW1saW5rc10gWy0tdGV4dGNvbnYgfCAtLSIKICJmaWx0ZXJzXSIKQEAgLTk5NjgsNzIgKzEwMDExLDcyIEBACiAiZ2l0IGNhdC1maWxlICgtLWJhdGNoIHwgLS1iYXRjaC1jaGVjaykgWy0tZm9sbG93LXN5bWxpbmtzXSBbLS10ZXh0Y29udiB8IC0tIgogImZpbHRlcnNdIgogCi0jOiBidWlsdGluL2NhdC1maWxlLmM6NjE2CisjOiBidWlsdGluL2NhdC1maWxlLmM6NjE3CiBtc2dpZCAib25seSBvbmUgYmF0Y2ggb3B0aW9uIG1heSBiZSBzcGVjaWZpZWQiCiBtc2dzdHIgInNvbG8gc2UgcHVlZGUgZXNwZWNpZmljYXIgdW5hIG9wY2nDs24gYmF0Y2giCiAKLSM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2MzQKKyM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2MzUKIG1zZ2lkICI8dHlwZT4gY2FuIGJlIG9uZSBvZjogYmxvYiwgdHJlZSwgY29tbWl0LCB0YWciCiBtc2dzdHIgIjx0aXBvPiBwdWVkZSBzZXI6IGJsb2IsIHRyZWUsIGNvbW1pdCwgdGFnIgogCi0jOiBidWlsdGluL2NhdC1maWxlLmM6NjM1CisjOiBidWlsdGluL2NhdC1maWxlLmM6NjM2CiBtc2dpZCAic2hvdyBvYmplY3QgdHlwZSIKIG1zZ3N0ciAibW9zdHJhciBlbCB0aXBvIGRlbCBvYmpldG8iCiAKLSM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2MzYKKyM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2MzcKIG1zZ2lkICJzaG93IG9iamVjdCBzaXplIgogbXNnc3RyICJtb3N0cmFyIGVsIHRhbWHDsW8gZGVsIG9iamV0byIKIAotIzogYnVpbHRpbi9jYXQtZmlsZS5jOjYzOAorIzogYnVpbHRpbi9jYXQtZmlsZS5jOjYzOQogbXNnaWQgImV4aXQgd2l0aCB6ZXJvIHdoZW4gdGhlcmUncyBubyBlcnJvciIKIG1zZ3N0ciAic2FsaXIgY29uIGNlcm8gY3VhbmRvIG5vIGhheWEgZXJyb3IiCiAKLSM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2MzkKKyM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NDAKIG1zZ2lkICJwcmV0dHktcHJpbnQgb2JqZWN0J3MgY29udGVudCIKIG1zZ3N0ciAicmVhbGl6YXIgcHJldHR5LXByaW50IGRlbCBjb250ZW5pZG8gZGVsIG9iamV0byIKIAotIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY0MQorIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY0MgogbXNnaWQgImZvciBibG9iIG9iamVjdHMsIHJ1biB0ZXh0Y29udiBvbiBvYmplY3QncyBjb250ZW50IgogbXNnc3RyICJwYXJhIG9iamV0b3MgYmxvYiwgZWplY3V0YSB0ZXh0Y29udiBlbiBlbCBjb250ZW5pZG8gZGVsIG9iamV0byIKIAotIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY0MworIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY0NAogbXNnaWQgImZvciBibG9iIG9iamVjdHMsIHJ1biBmaWx0ZXJzIG9uIG9iamVjdCdzIGNvbnRlbnQiCiBtc2dzdHIgInBhcmEgb2JqZXRvcyBibG9iLCBlamVjdXRhIGZpbHRlcnMgZW4gZWwgY29udGVuaWRvIGRlbCBvYmpldG8iCiAKLSM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NDQgZ2l0LXN1Ym1vZHVsZS5zaDo5MzYKKyM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NDUgZ2l0LXN1Ym1vZHVsZS5zaDo5MzYKIG1zZ2lkICJibG9iIgogbXNnc3RyICJibG9iIgogCi0jOiBidWlsdGluL2NhdC1maWxlLmM6NjQ1CisjOiBidWlsdGluL2NhdC1maWxlLmM6NjQ2CiBtc2dpZCAidXNlIGEgc3BlY2lmaWMgcGF0aCBmb3IgLS10ZXh0Y29udi8tLWZpbHRlcnMiCiBtc2dzdHIgInVzZSB1bmEgcnV0YSBlc3BlY8OtZmljYSBwYXJhIC0tdGV4dGNvbnYvLS1maWx0ZXJzIgogCi0jOiBidWlsdGluL2NhdC1maWxlLmM6NjQ3CisjOiBidWlsdGluL2NhdC1maWxlLmM6NjQ4CiBtc2dpZCAiYWxsb3cgLXMgYW5kIC10IHRvIHdvcmsgd2l0aCBicm9rZW4vY29ycnVwdCBvYmplY3RzIgogbXNnc3RyICJwZXJtaXRhIC1zIHkgLXQgcGFyYSB0cmFiYWphciBjb24gb2JqZXRvcyByb3RvcyBvIGNvcnJ1cHRvcyIKIAotIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY0OAorIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY0OQogbXNnaWQgImJ1ZmZlciAtLWJhdGNoIG91dHB1dCIKIG1zZ3N0ciAic2FsaWRhIGJ1ZmZlciAtLWJhdGNoIgogCi0jOiBidWlsdGluL2NhdC1maWxlLmM6NjUwCisjOiBidWlsdGluL2NhdC1maWxlLmM6NjUxCiBtc2dpZCAic2hvdyBpbmZvIGFuZCBjb250ZW50IG9mIG9iamVjdHMgZmVkIGZyb20gdGhlIHN0YW5kYXJkIGlucHV0IgogbXNnc3RyICJtb3N0cmFyIGluZm8geSBjb250ZW50IGRlIGxvcyBvYmpldG9zIGFsaW1lbnRhZG9zIHBvciBzdGFuZGFyZCBpbnB1dCIKIAotIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY1NAorIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY1NQogbXNnaWQgInNob3cgaW5mbyBhYm91dCBvYmplY3RzIGZlZCBmcm9tIHRoZSBzdGFuZGFyZCBpbnB1dCIKIG1zZ3N0ciAibW9zdHJhciBpbmZvIGRlIGxvcyBvYmpldG9zIGFsaW1lbnRhZG9zIHBvciBzdGFuZGFyZCBpbnB1dCIKIAotIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY1OAorIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY1OQogbXNnaWQgImZvbGxvdyBpbi10cmVlIHN5bWxpbmtzICh1c2VkIHdpdGggLS1iYXRjaCBvciAtLWJhdGNoLWNoZWNrKSIKIG1zZ3N0ciAiIgogInNlZ3VpciBsb3MgZW5sYWNlcyBzaW1iw7NsaWNvcyBlbiBlbCDDoXJib2wgKHVzYWRvIGNvbiAtLWJhdGNoIG8gLS1iYXRjaC1jaGVjaykiCiAKLSM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NjAKKyM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NjEKIG1zZ2lkICJzaG93IGFsbCBvYmplY3RzIHdpdGggLS1iYXRjaCBvciAtLWJhdGNoLWNoZWNrIgogbXNnc3RyICJtb3N0cmFyIHRvZG9zIGxvcyBvYmpldG9zIGNvbiAtLWJhdGNoIG8gLS1iYXRjaC1jaGVjayIKIAotIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY2MgorIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY2MwogbXNnaWQgImRvIG5vdCBvcmRlciAtLWJhdGNoLWFsbC1vYmplY3RzIG91dHB1dCIKIG1zZ3N0ciAibm8gb3JkZW5hciBlbCBvdXRwdXQgZGUgLS1iYXRjaC1hbGwtb2JqZWN0cyIKIApAQCAtMTAwNjEsOCArMTAxMDQsOCBAQAogbXNnaWQgInRlcm1pbmF0ZSBpbnB1dCBhbmQgb3V0cHV0IHJlY29yZHMgYnkgYSBOVUwgY2hhcmFjdGVyIgogbXNnc3RyICJ0ZXJtaW5hciByZWdpc3Ryb3MgZGUgZW50cmFkYSB5IHNhbGlkYSBjb24gdW4gY2Fyw6FjdGVyIE5VTCIKIAotIzogYnVpbHRpbi9jaGVjay1pZ25vcmUuYzoyMSBidWlsdGluL2NoZWNrb3V0LmM6MTQzMyBidWlsdGluL2djLmM6NTM4Ci0jOiBidWlsdGluL3dvcmt0cmVlLmM6NTA3CisjOiBidWlsdGluL2NoZWNrLWlnbm9yZS5jOjIxIGJ1aWx0aW4vY2hlY2tvdXQuYzoxNDMzIGJ1aWx0aW4vZ2MuYzo1MzcKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo1MDYKIG1zZ2lkICJzdXBwcmVzcyBwcm9ncmVzcyByZXBvcnRpbmciCiBtc2dzdHIgInN1cHJpbWlyIGVsIHJlcG9ydGUgZGUgcHJvZ3Jlc28iCiAKQEAgLTEwMTU2LDcgKzEwMTk5LDcgQEAKICM6IGJ1aWx0aW4vY2hlY2tvdXQtaW5kZXguYzoxNzggYnVpbHRpbi9jb2x1bW4uYzozMQogIzogYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjEzNzMgYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjEzNzYKICM6IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxMzg0IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxODU3Ci0jOiBidWlsdGluL3dvcmt0cmVlLmM6NjgwCisjOiBidWlsdGluL3dvcmt0cmVlLmM6Njc5CiBtc2dpZCAic3RyaW5nIgogbXNnc3RyICJzdHJpbmciCiAKQEAgLTEwMTg0LDk4ICsxMDIyNyw5OCBAQAogbXNnaWQgImdpdCByZXN0b3JlIFs8b3B0aW9ucz5dIFstLXNvdXJjZT08YnJhbmNoPl0gPGZpbGU+Li4uIgogbXNnc3RyICJnaXQgcmVzdG9yZSBbPG9wY2lvbmVzPl0gWy0tc291cmNlPTxyYW1hPl0gLS0gPGFyY2hpdm8+Li4uIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6MTcyIGJ1aWx0aW4vY2hlY2tvdXQuYzoyMTEKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzMgYnVpbHRpbi9jaGVja291dC5jOjIxMgogIywgYy1mb3JtYXQKIG1zZ2lkICJwYXRoICclcycgZG9lcyBub3QgaGF2ZSBvdXIgdmVyc2lvbiIKIG1zZ3N0ciAicnV0YSAnJXMnIG5vIHRpZW5lIG51ZXN0cmEgdmVyc2nDs24iCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzQgYnVpbHRpbi9jaGVja291dC5jOjIxMworIzogYnVpbHRpbi9jaGVja291dC5jOjE3NSBidWlsdGluL2NoZWNrb3V0LmM6MjE0CiAjLCBjLWZvcm1hdAogbXNnaWQgInBhdGggJyVzJyBkb2VzIG5vdCBoYXZlIHRoZWlyIHZlcnNpb24iCiBtc2dzdHIgInJ1dGEgJyVzJyBubyB0aWVuZSBzdSB2ZXJzacOzbiIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjE5MAorIzogYnVpbHRpbi9jaGVja291dC5jOjE5MQogIywgYy1mb3JtYXQKIG1zZ2lkICJwYXRoICclcycgZG9lcyBub3QgaGF2ZSBhbGwgbmVjZXNzYXJ5IHZlcnNpb25zIgogbXNnc3RyICJydXRhICclcycgbm8gdGllbmUgdG9kYXMgbGFzIHZlcnNpb25lcyBuZWNlc2FyaWFzIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6MjQwCisjOiBidWlsdGluL2NoZWNrb3V0LmM6MjQxCiAjLCBjLWZvcm1hdAogbXNnaWQgInBhdGggJyVzJyBkb2VzIG5vdCBoYXZlIG5lY2Vzc2FyeSB2ZXJzaW9ucyIKIG1zZ3N0ciAicnV0YSAnJXMnIG5vIHRpZW5lIHZlcnNpb25lcyBuZWNlc2FyaWFzIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6MjU4CisjOiBidWlsdGluL2NoZWNrb3V0LmM6MjU5CiAjLCBjLWZvcm1hdAogbXNnaWQgInBhdGggJyVzJzogY2Fubm90IG1lcmdlIgogbXNnc3RyICJydXRhICclcyc6IG5vIHNlIHB1ZWRlIGZ1c2lvbmFyIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6Mjc0CisjOiBidWlsdGluL2NoZWNrb3V0LmM6Mjc1CiAjLCBjLWZvcm1hdAogbXNnaWQgIlVuYWJsZSB0byBhZGQgbWVyZ2UgcmVzdWx0IGZvciAnJXMnIgogbXNnc3RyICJJbmNhcGF6IGRlIGFncmVnYXIgcmVzdWx0YWRvcyBkZSBmdXNpw7NuIGEgJyVzJyIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjM3NAorIzogYnVpbHRpbi9jaGVja291dC5jOjM3NQogIywgYy1mb3JtYXQKIG1zZ2lkICJSZWNyZWF0ZWQgJWQgbWVyZ2UgY29uZmxpY3QiCiBtc2dpZF9wbHVyYWwgIlJlY3JlYXRlZCAlZCBtZXJnZSBjb25mbGljdHMiCiBtc2dzdHJbMF0gIlJlY3JlYWRvICVkIGNvbmZsaWN0byBkZSBtZXJnZSIKIG1zZ3N0clsxXSAiUmVjcmVhZG9zICVkIGNvbmZsaWN0b3MgZGUgbWVyZ2UiCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzozNzkKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzozODAKICMsIGMtZm9ybWF0CiBtc2dpZCAiVXBkYXRlZCAlZCBwYXRoIGZyb20gJXMiCiBtc2dpZF9wbHVyYWwgIlVwZGF0ZWQgJWQgcGF0aHMgZnJvbSAlcyIKIG1zZ3N0clswXSAiQWN0dWFsaXphZGEgJWQgcnV0YSBwYXJhICVzIgogbXNnc3RyWzFdICJBY3R1YWxpemFkYXMgJWQgcnV0YXMgcGFyYSAlcyIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjM4NgorIzogYnVpbHRpbi9jaGVja291dC5jOjM4NwogIywgYy1mb3JtYXQKIG1zZ2lkICJVcGRhdGVkICVkIHBhdGggZnJvbSB0aGUgaW5kZXgiCiBtc2dpZF9wbHVyYWwgIlVwZGF0ZWQgJWQgcGF0aHMgZnJvbSB0aGUgaW5kZXgiCiBtc2dzdHJbMF0gIkFjdHVhbGl6YWRhICVkIHJ1dGEgZGVzZGUgZWwgaW5kZXgiCiBtc2dzdHJbMV0gIkFjdHVhbGl6YWRhcyAlZCBydXRhcyBkZXNkZSBlbCBpbmRleCIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjQwOSBidWlsdGluL2NoZWNrb3V0LmM6NDEyIGJ1aWx0aW4vY2hlY2tvdXQuYzo0MTUKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo0MTkKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo0MTAgYnVpbHRpbi9jaGVja291dC5jOjQxMyBidWlsdGluL2NoZWNrb3V0LmM6NDE2CisjOiBidWlsdGluL2NoZWNrb3V0LmM6NDIwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiclcycgY2Fubm90IGJlIHVzZWQgd2l0aCB1cGRhdGluZyBwYXRocyIKIG1zZ3N0ciAiJyVzJyBubyBwdWVkZSBzZXIgdXNhZGEgY29uIHJ1dGFzIGFjdHVhbGl6YWRhcyIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjQyMiBidWlsdGluL2NoZWNrb3V0LmM6NDI1CisjOiBidWlsdGluL2NoZWNrb3V0LmM6NDIzIGJ1aWx0aW4vY2hlY2tvdXQuYzo0MjYKICMsIGMtZm9ybWF0CiBtc2dpZCAiJyVzJyBjYW5ub3QgYmUgdXNlZCB3aXRoICVzIgogbXNnc3RyICInJXMnIG5vIHB1ZWRlIHNlciB1c2FkbyBjb24gJXMiCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo0MjkKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo0MzAKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ2Fubm90IHVwZGF0ZSBwYXRocyBhbmQgc3dpdGNoIHRvIGJyYW5jaCAnJXMnIGF0IHRoZSBzYW1lIHRpbWUuIgogbXNnc3RyICJObyBzZSBwdWVkZSBhY3R1YWxpemFyIHJ1dGFzIHkgY2FtYmlhciBhIGxhIHJhbWEgJyVzJyBhbCBtaXNtbyB0aWVtcG8uIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6NDMzCisjOiBidWlsdGluL2NoZWNrb3V0LmM6NDM0CiAjLCBjLWZvcm1hdAogbXNnaWQgIm5laXRoZXIgJyVzJyBvciAnJXMnIGlzIHNwZWNpZmllZCIKIG1zZ3N0ciAibmkgJyVzJyBvICclcycgZXN0w6FuIGVzcGVjaWZpY2Fkb3MiCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo0MzcKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo0MzgKICMsIGMtZm9ybWF0CiBtc2dpZCAiJyVzJyBtdXN0IGJlIHVzZWQgd2hlbiAnJXMnIGlzIG5vdCBzcGVjaWZpZWQiCiBtc2dzdHIgIiclcycgdGllbmUgcXVlIHNlciB1c2FkbyBjdWFuZG8gJyVzJyBubyBlcyBlc3BlY2lmaWNhZG8iCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo0NDIgYnVpbHRpbi9jaGVja291dC5jOjQ0NworIzogYnVpbHRpbi9jaGVja291dC5jOjQ0MyBidWlsdGluL2NoZWNrb3V0LmM6NDQ4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiclcycgb3IgJyVzJyBjYW5ub3QgYmUgdXNlZCB3aXRoICVzIgogbXNnc3RyICInJXMnIG8gJyVzJyBubyBwdWVkZSBzZXIgdXNhZG8gY29uICVzIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6NTA2IGJ1aWx0aW4vY2hlY2tvdXQuYzo1MTMKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo1MDcgYnVpbHRpbi9jaGVja291dC5jOjUxNAogIywgYy1mb3JtYXQKIG1zZ2lkICJwYXRoICclcycgaXMgdW5tZXJnZWQiCiBtc2dzdHIgInJ1dGEgJyVzJyBubyBlc3RhIGZ1c2lvbmFkYSIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjY3OQorIzogYnVpbHRpbi9jaGVja291dC5jOjY4MAogbXNnaWQgInlvdSBuZWVkIHRvIHJlc29sdmUgeW91ciBjdXJyZW50IGluZGV4IGZpcnN0IgogbXNnc3RyICJuZWNlc2l0YXMgcmVzb2x2ZXIgdHUgw61uZGljZSBhY3R1YWwgcHJpbWVybyIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjcyOQorIzogYnVpbHRpbi9jaGVja291dC5jOjczMAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiY2Fubm90IGNvbnRpbnVlIHdpdGggc3RhZ2VkIGNoYW5nZXMgaW4gdGhlIGZvbGxvd2luZyBmaWxlczpcbiIKQEAgLTEwMjg0LDEyICsxMDMyNyw2IEBACiAibm8gc2UgcHVlZGUgY29udGludWFyIGNvbiBsb3MgY2FtYmlvcyBlbiBzdGFnZSBlbiBsb3Mgc2lndWllbnRlcyBhcmNoaXZvczpcbiIKICIlcyIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjczNgotIywgYy1mb3JtYXQKLW1zZ2lkICJzdGFnZWQgY2hhbmdlcyBpbiB0aGUgZm9sbG93aW5nIGZpbGVzIG1heSBiZSBsb3N0OiAlcyIKLW1zZ3N0ciAiIgotImNhbWJpb3MgZW4gZWwgw6FyZWEgZGUgc3RhZ2UgZW4gZWwgc2lndWllbnRlIGFyY2hpdm8gcHVlZGVuIHNlciBwZXJkaWRvczogJXMiCi0KICM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo4MzMKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ2FuIG5vdCBkbyByZWZsb2cgZm9yICclcyc6ICVzXG4iCkBAIC0xMDI5OSw3ICsxMDMzNiw3IEBACiBtc2dpZCAiSEVBRCBpcyBub3cgYXQiCiBtc2dzdHIgIkhFQUQgZXN0w6EgYWhvcmEgZW4iCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo4NzkgYnVpbHRpbi9jbG9uZS5jOjcxNAorIzogYnVpbHRpbi9jaGVja291dC5jOjg3OSBidWlsdGluL2Nsb25lLmM6NzEzCiBtc2dpZCAidW5hYmxlIHRvIHVwZGF0ZSBIRUFEIgogbXNnc3RyICJubyBlcyBwb3NpYmxlIGFjdHVhbGl6YXIgIEhFQUQiCiAKQEAgLTEwNDEzLDcgKzEwNDUwLDcgQEAKICInJXMnIHB1ZWRlIHNlciB0YW50byB1biBhcmNoaXZvIGxvY2FsIGNvbW8gdW5hIHJhbWEgZGUgcmFzdHJlby5cbiIKICJQb3IgZmF2b3IgdXNlIC0tICh5IG9wY2lvbmFsbWVudGUgLS1uby1ndWVzcykgcGFyYSBkZXNhbWJpZ3VhciIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjEyNDMgYnVpbHRpbi93b3JrdHJlZS5jOjI5MSBidWlsdGluL3dvcmt0cmVlLmM6NDU2CisjOiBidWlsdGluL2NoZWNrb3V0LmM6MTI0MyBidWlsdGluL3dvcmt0cmVlLmM6MjkwIGJ1aWx0aW4vd29ya3RyZWUuYzo0NTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCByZWZlcmVuY2U6ICVzIgogbXNnc3RyICJyZWZlcmVuY2lhIGludsOhbGlkYTogJXMiCkBAIC0xMDUxNiw5ICsxMDU1Myw5IEBACiBtc2dpZCAibWlzc2luZyBicmFuY2ggb3IgY29tbWl0IGFyZ3VtZW50IgogbXNnc3RyICJmYWx0YSBicmFuY2ggbyBjb21taXQgY29tbyBhcmd1bWVudG8iCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNDM3IGJ1aWx0aW4vY2xvbmUuYzo5MSBidWlsdGluL2ZldGNoLmM6MTUxCi0jOiBidWlsdGluL21lcmdlLmM6Mjg1IGJ1aWx0aW4vcHVsbC5jOjEzNyBidWlsdGluL3B1c2guYzo1NzUKLSM6IGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTc0CisjOiBidWlsdGluL2NoZWNrb3V0LmM6MTQzNyBidWlsdGluL2Nsb25lLmM6OTAgYnVpbHRpbi9jb21taXQtZ3JhcGguYzo1OQorIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxODAgYnVpbHRpbi9mZXRjaC5jOjE2NiBidWlsdGluL21lcmdlLmM6Mjg1CisjOiBidWlsdGluL3B1bGwuYzoxMzggYnVpbHRpbi9wdXNoLmM6NTYyIGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTc0CiBtc2dpZCAiZm9yY2UgcHJvZ3Jlc3MgcmVwb3J0aW5nIgogbXNnc3RyICJmb3J6YXIgZWwgcmVwb3J0ZSBkZSBwcm9ncmVzbyIKIApAQCAtMTA1MjYsNyArMTA1NjMsNyBAQAogbXNnaWQgInBlcmZvcm0gYSAzLXdheSBtZXJnZSB3aXRoIHRoZSBuZXcgYnJhbmNoIgogbXNnc3RyICJyZWFsaXphciB1bmEgZnVzacOzbiBkZSB0cmVzIHbDrWFzIGNvbiBsYSByYW1hIG51ZXZhIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6MTQzOSBidWlsdGluL2xvZy5jOjE2MTcgcGFyc2Utb3B0aW9ucy5oOjMxOAorIzogYnVpbHRpbi9jaGVja291dC5jOjE0MzkgYnVpbHRpbi9sb2cuYzoxNjE4IHBhcnNlLW9wdGlvbnMuaDozMTgKIG1zZ2lkICJzdHlsZSIKIG1zZ3N0ciAiZXN0aWxvIgogCkBAIC0xMDUzNCw3ICsxMDU3MSw3IEBACiBtc2dpZCAiY29uZmxpY3Qgc3R5bGUgKG1lcmdlIG9yIGRpZmYzKSIKIG1zZ3N0ciAiY29uZmxpY3RvIGRlIGVzdGlsb3MgKG1lcmdlIG8gZGlmZjMpIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6MTQ1MiBidWlsdGluL3dvcmt0cmVlLmM6NTA0CisjOiBidWlsdGluL2NoZWNrb3V0LmM6MTQ1MiBidWlsdGluL3dvcmt0cmVlLmM6NTAzCiBtc2dpZCAiZGV0YWNoIEhFQUQgYXQgbmFtZWQgY29tbWl0IgogbXNnc3RyICJkZXNhY29wbGFyIEhFQUQgZW4gZWwgY29tbWl0IG5vbWJyYWRvIgogCkBAIC0xMDYzOSw3ICsxMDY3Niw3IEBACiBtc2dzdHIgIiIKICInJXMnIGFjZXJ0w7MgbcOhcyBkZSB1bmEgcmFtYSByZW1vdGEgcmFzdHJlYWRhLlxuIgogIkVuY29udHJhbW9zICVkIHJlbW90b3MgY29uIHVuYSByZWZlcmVuY2lhIHF1ZSBjb25jdWVyZGEuIEFzw60gcXVlIHZvbHZlbW9zXG4iCi0iYSBpbnRlbnRhciByZXNvbHZlciBlbCBhcmd1bWVudG8gY29tbyB1bmEgcnV0YSwgcGVybyBlc28gdGFtYmnDqW4gZmFsbMOzIVxuIgorImEgaW50ZW50YXIgcmVzb2x2ZXIgZWwgYXJndW1lbnRvIGNvbW8gdW5hIHJ1dGEsIMKhcGVybyBlc28gdGFtYmnDqW4gZmFsbMOzIVxuIgogIlxuIgogIlNpIHF1ZXLDrWFzIGhhY2VyIHVuIGNoZWNrIG91dCBhIHVuYSByYW1hIHJhc3RyZWFkYSByZW1vdGEsIGNvbW8gJ29yaWdpbicsXG4iCiAicHVlZGVzIGhhY2VybG8gcHJvcG9yY2lvbmFuZG8gZWwgbm9tYnJlIGNvbXBsZXRvIGNvbiBsYSBvcGNpw7NuIC0tdHJhY2s6XG4iCkBAIC0xMDY1MSw5ICsxMDY4OCw5IEBACiAiZGUgbm9tYnJlIDxub21icmU+IHJlbW90YSwgY29tbyAnb3JpZ2luJywgY29uc2lkZXJhIGNvbmZpZ3VyYXJcbiIKICJjaGVja291dC5kZWZhdWx0UmVtb3RlPW9yaWdpbiBlbiB0dSBjb25maWd1cmFjacOzbi4iCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNjkxIGJ1aWx0aW4vY2hlY2tvdXQuYzoxNjkzIGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzMzCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6MTczNSBidWlsdGluL2Nsb25lLmM6MTIxIGJ1aWx0aW4vcmVtb3RlLmM6MTY5Ci0jOiBidWlsdGluL3JlbW90ZS5jOjE3MSBidWlsdGluL3dvcmt0cmVlLmM6NTAwIGJ1aWx0aW4vd29ya3RyZWUuYzo1MDIKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNjkxIGJ1aWx0aW4vY2hlY2tvdXQuYzoxNjkzIGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzQyCisjOiBidWlsdGluL2NoZWNrb3V0LmM6MTc0NCBidWlsdGluL2Nsb25lLmM6MTIwIGJ1aWx0aW4vcmVtb3RlLmM6MTY5CisjOiBidWlsdGluL3JlbW90ZS5jOjE3MSBidWlsdGluL3dvcmt0cmVlLmM6NDk5IGJ1aWx0aW4vd29ya3RyZWUuYzo1MDEKIG1zZ2lkICJicmFuY2giCiBtc2dzdHIgInJhbWEiCiAKQEAgLTEwNjc3LDM5ICsxMDcxNCwzOSBAQAogbXNnaWQgInVzZSBvdmVybGF5IG1vZGUgKGRlZmF1bHQpIgogbXNnc3RyICJ1c2FyIG1vZG8gb3ZlcmxheSAoZGVmYXVsdCkiCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzM0CisjOiBidWlsdGluL2NoZWNrb3V0LmM6MTc0MwogbXNnaWQgImNyZWF0ZSBhbmQgc3dpdGNoIHRvIGEgbmV3IGJyYW5jaCIKIG1zZ3N0ciAiY3JlYXIgeSBoYWNlciBzd2l0Y2ggYSB1bmEgbnVldmEgcmFtYSIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjE3MzYKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzQ1CiBtc2dpZCAiY3JlYXRlL3Jlc2V0IGFuZCBzd2l0Y2ggdG8gYSBicmFuY2giCiBtc2dzdHIgImNyZWFyL3JlaW5pY2lhciB5IGhhY2VyIHN3aXRjaCBhIHVuYSByYW1hIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6MTczOAorIzogYnVpbHRpbi9jaGVja291dC5jOjE3NDcKIG1zZ2lkICJzZWNvbmQgZ3Vlc3MgJ2dpdCBzd2l0Y2ggPG5vLXN1Y2gtYnJhbmNoPiciCiBtc2dzdHIgImFkaXZpbmFyIHNlZ3VuZGEgb3BjacOzbiAnZ2l0IGNoZWNrb3V0IDxuby1oYXktdGFsLXJhbWE+JyIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjE3NDAKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzQ5CiBtc2dpZCAidGhyb3cgYXdheSBsb2NhbCBtb2RpZmljYXRpb25zIgogbXNnc3RyICJkZXNjYXJ0YXIgbW9kaWZpY2FjaW9uZXMgbG9jYWxlcyIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjE3NzIKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzgxCiBtc2dpZCAid2hpY2ggdHJlZS1pc2ggdG8gY2hlY2tvdXQgZnJvbSIKIG1zZ3N0ciAiZGUgcXXDqSDDoXJib2wgaGFjZXIgZWwgY2hlY2tvdXQiCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzc0CisjOiBidWlsdGluL2NoZWNrb3V0LmM6MTc4MwogbXNnaWQgInJlc3RvcmUgdGhlIGluZGV4IgogbXNnc3RyICJyZXN0YXVyYXIgZWwgaW5kZXgiCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzc2CisjOiBidWlsdGluL2NoZWNrb3V0LmM6MTc4NQogbXNnaWQgInJlc3RvcmUgdGhlIHdvcmtpbmcgdHJlZSAoZGVmYXVsdCkiCiBtc2dzdHIgInJlc3RhdXJhciBlbCDDoXJib2wgZGUgdHJhYmFqbyAoZGVmYXVsdCkiCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzc4CisjOiBidWlsdGluL2NoZWNrb3V0LmM6MTc4NwogbXNnaWQgImlnbm9yZSB1bm1lcmdlZCBlbnRyaWVzIgogbXNnc3RyICJpZ25vcmFyIGVudHJhZGFzIG5vIGZ1c2lvbmFkYXMiCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzc5CisjOiBidWlsdGluL2NoZWNrb3V0LmM6MTc4OAogbXNnaWQgInVzZSBvdmVybGF5IG1vZGUiCiBtc2dzdHIgInVzYXIgbW9kbyBvdmVybGF5IgogCkBAIC0xMDc0OSw3ICsxMDc4Niw3IEBACiBtc2dpZCAiY291bGQgbm90IGxzdGF0ICVzXG4iCiBtc2dzdHIgIm5vIHNlIHB1ZG8gbHN0YXQgJXNcbiIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjMwMCBnaXQtYWRkLS1pbnRlcmFjdGl2ZS5wZXJsOjU5MworIzogYnVpbHRpbi9jbGVhbi5jOjMwMSBnaXQtYWRkLS1pbnRlcmFjdGl2ZS5wZXJsOjU5MwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiUHJvbXB0IGhlbHA6XG4iCkBAIC0xMDc2Miw3ICsxMDc5OSw3IEBACiAiZm9vICAgICAgICAtIHNlbGVjY2lvbmEgdW4gb2JqZXRvIGJhc2FkbyBlbiB1biBwcmVmaWpvIMO6bmljb1xuIgogIiAgICAgICAgICAgLSAodmFjw61vKSBubyBlbGVnaXIgbmFkYVxuIgogCi0jOiBidWlsdGluL2NsZWFuLmM6MzA0IGdpdC1hZGQtLWludGVyYWN0aXZlLnBlcmw6NjAyCisjOiBidWlsdGluL2NsZWFuLmM6MzA1IGdpdC1hZGQtLWludGVyYWN0aXZlLnBlcmw6NjAyCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJQcm9tcHQgaGVscDpcbiIKQEAgLTEwNzgzLDM4ICsxMDgyMCwzOCBAQAogIiogICAgICAgICAgLSBlc2NvZ2VyIHRvZG9zIGxvcyBvYmpldG9zXG4iCiAiICAgICAgICAgICAtICh2YWPDrW8pIHRlcm1pbmFyIHNlbGVjY2nDs25cbiIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjUyMCBnaXQtYWRkLS1pbnRlcmFjdGl2ZS5wZXJsOjU2OAorIzogYnVpbHRpbi9jbGVhbi5jOjUyMSBnaXQtYWRkLS1pbnRlcmFjdGl2ZS5wZXJsOjU2OAogIzogZ2l0LWFkZC0taW50ZXJhY3RpdmUucGVybDo1NzMKICMsIGMtZm9ybWF0LCBwZXJsLWZvcm1hdAogbXNnaWQgIkh1aCAoJXMpP1xuIgotbXNnc3RyICJBaGggKCVzKT9cbiIKK21zZ3N0ciAiwr9BaGggKCVzKT9cbiIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjY2MgorIzogYnVpbHRpbi9jbGVhbi5jOjY2MwogIywgYy1mb3JtYXQKIG1zZ2lkICJJbnB1dCBpZ25vcmUgcGF0dGVybnM+PiAiCiBtc2dzdHIgIklucHV0IGlnbm9yYSBsb3MgcGF0cm9uZXMgPj4gIgogCi0jOiBidWlsdGluL2NsZWFuLmM6Njk5CisjOiBidWlsdGluL2NsZWFuLmM6NzAwCiAjLCBjLWZvcm1hdAogbXNnaWQgIldBUk5JTkc6IENhbm5vdCBmaW5kIGl0ZW1zIG1hdGNoZWQgYnk6ICVzIgogbXNnc3RyICJQRUxJR1JPOiBObyBzZSBwdWVkZSBlbmNvbnRyYXIgb2JqZXRvcyBxdWUgY29uY3VlcmRlbiBjb246ICVzIgogCi0jOiBidWlsdGluL2NsZWFuLmM6NzIwCisjOiBidWlsdGluL2NsZWFuLmM6NzIxCiBtc2dpZCAiU2VsZWN0IGl0ZW1zIHRvIGRlbGV0ZSIKIG1zZ3N0ciAiU2VsZWNjaW9uYXIgb2JqZXRvcyBwYXJhIGJvcnJhciIKIAogIy4gVFJBTlNMQVRPUlM6IE1ha2Ugc3VyZSB0byBrZWVwIFt5L05dIGFzIGlzCi0jOiBidWlsdGluL2NsZWFuLmM6NzYxCisjOiBidWlsdGluL2NsZWFuLmM6NzYyCiAjLCBjLWZvcm1hdAogbXNnaWQgIlJlbW92ZSAlcyBbeS9OXT8gIgotbXNnc3RyICJCb3JyYXIgJXMgW3kvTl0/ICIKK21zZ3N0ciAiwr9Cb3JyYXIgJXMgW3kvTl0/ICIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjc4NiBnaXQtYWRkLS1pbnRlcmFjdGl2ZS5wZXJsOjE3NjMKKyM6IGJ1aWx0aW4vY2xlYW4uYzo3ODcgZ2l0LWFkZC0taW50ZXJhY3RpdmUucGVybDoxNzYzCiAjLCBjLWZvcm1hdAogbXNnaWQgIkJ5ZS5cbiIKIG1zZ3N0ciAiQWRpw7NzLlxuIgogCi0jOiBidWlsdGluL2NsZWFuLmM6Nzk0CisjOiBidWlsdGluL2NsZWFuLmM6Nzk1CiBtc2dpZCAiIgogImNsZWFuICAgICAgICAgICAgICAgLSBzdGFydCBjbGVhbmluZ1xuIgogImZpbHRlciBieSBwYXR0ZXJuICAgLSBleGNsdWRlIGl0ZW1zIGZyb20gZGVsZXRpb25cbiIKQEAgLTEwODMyLDY0ICsxMDg2OSw2NCBAQAogImhlbHAgICAgICAgICAgICAgICAgLSBlc3RhIHZlbnRhbmFcbiIKICI/ICAgICAgICAgICAgICAgICAgIC0gYXl1ZGEgcGFyYSBzZWxlY2Npw7NuIGRlIG9wY2lvbmVzIgogCi0jOiBidWlsdGluL2NsZWFuLmM6ODIxIGdpdC1hZGQtLWludGVyYWN0aXZlLnBlcmw6MTg0OQorIzogYnVpbHRpbi9jbGVhbi5jOjgyMiBnaXQtYWRkLS1pbnRlcmFjdGl2ZS5wZXJsOjE4NDkKIG1zZ2lkICIqKiogQ29tbWFuZHMgKioqIgogbXNnc3RyICIqKiogQ29tYW5kb3MgKioqIgogCi0jOiBidWlsdGluL2NsZWFuLmM6ODIyIGdpdC1hZGQtLWludGVyYWN0aXZlLnBlcmw6MTg0NgorIzogYnVpbHRpbi9jbGVhbi5jOjgyMyBnaXQtYWRkLS1pbnRlcmFjdGl2ZS5wZXJsOjE4NDYKIG1zZ2lkICJXaGF0IG5vdyIKIG1zZ3N0ciAiQWhvcmEgcXVlIgogCi0jOiBidWlsdGluL2NsZWFuLmM6ODMwCisjOiBidWlsdGluL2NsZWFuLmM6ODMxCiBtc2dpZCAiV291bGQgcmVtb3ZlIHRoZSBmb2xsb3dpbmcgaXRlbToiCiBtc2dpZF9wbHVyYWwgIldvdWxkIHJlbW92ZSB0aGUgZm9sbG93aW5nIGl0ZW1zOiIKIG1zZ3N0clswXSAiU2UgZWxpbWluYXLDoSBlbCBzaWd1aWVudGUgb2JqZXRvOiIKIG1zZ3N0clsxXSAiU2UgZWxpbWluYXLDoW4gbG9zIHNpZ3VpZW50ZXMgb2JqZXRvczoiCiAKLSM6IGJ1aWx0aW4vY2xlYW4uYzo4NDYKKyM6IGJ1aWx0aW4vY2xlYW4uYzo4NDcKIG1zZ2lkICJObyBtb3JlIGZpbGVzIHRvIGNsZWFuLCBleGl0aW5nLiIKIG1zZ3N0ciAiTm8gaGF5IG3DoXMgYXJjaGl2b3MgcGFyYSBsaW1waWFyLCBzYWxpZW5kby4iCiAKLSM6IGJ1aWx0aW4vY2xlYW4uYzo5MDgKKyM6IGJ1aWx0aW4vY2xlYW4uYzo5MDkKIG1zZ2lkICJkbyBub3QgcHJpbnQgbmFtZXMgb2YgZmlsZXMgcmVtb3ZlZCIKIG1zZ3N0ciAibm8gaW1wcmltaXIgbm9tYnJlcyBkZSBhcmNoaXZvcyBib3JyYWRvcyIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjkxMAorIzogYnVpbHRpbi9jbGVhbi5jOjkxMQogbXNnaWQgImZvcmNlIgogbXNnc3RyICJmb3J6YXIiCiAKLSM6IGJ1aWx0aW4vY2xlYW4uYzo5MTEKKyM6IGJ1aWx0aW4vY2xlYW4uYzo5MTIKIG1zZ2lkICJpbnRlcmFjdGl2ZSBjbGVhbmluZyIKIG1zZ3N0ciAibGltcGllemEgaW50ZXJhY3RpdmEiCiAKLSM6IGJ1aWx0aW4vY2xlYW4uYzo5MTMKKyM6IGJ1aWx0aW4vY2xlYW4uYzo5MTQKIG1zZ2lkICJyZW1vdmUgd2hvbGUgZGlyZWN0b3JpZXMiCiBtc2dzdHIgImJvcnJhciBkaXJlY3RvcmlvcyBjb21wbGV0b3MiCiAKLSM6IGJ1aWx0aW4vY2xlYW4uYzo5MTQgYnVpbHRpbi9kZXNjcmliZS5jOjU0NiBidWlsdGluL2Rlc2NyaWJlLmM6NTQ4Ci0jOiBidWlsdGluL2dyZXAuYzo4OTkgYnVpbHRpbi9sb2cuYzoxNzYgYnVpbHRpbi9sb2cuYzoxNzgKLSM6IGJ1aWx0aW4vbHMtZmlsZXMuYzo1NTcgYnVpbHRpbi9uYW1lLXJldi5jOjQxMyBidWlsdGluL25hbWUtcmV2LmM6NDE1CisjOiBidWlsdGluL2NsZWFuLmM6OTE1IGJ1aWx0aW4vZGVzY3JpYmUuYzo1NDggYnVpbHRpbi9kZXNjcmliZS5jOjU1MAorIzogYnVpbHRpbi9ncmVwLmM6OTAxIGJ1aWx0aW4vbG9nLmM6MTc2IGJ1aWx0aW4vbG9nLmM6MTc4CisjOiBidWlsdGluL2xzLWZpbGVzLmM6NTU3IGJ1aWx0aW4vbmFtZS1yZXYuYzo0MTcgYnVpbHRpbi9uYW1lLXJldi5jOjQxOQogIzogYnVpbHRpbi9zaG93LXJlZi5jOjE3OQogbXNnaWQgInBhdHRlcm4iCiBtc2dzdHIgInBhdHLDs24iCiAKLSM6IGJ1aWx0aW4vY2xlYW4uYzo5MTUKKyM6IGJ1aWx0aW4vY2xlYW4uYzo5MTYKIG1zZ2lkICJhZGQgPHBhdHRlcm4+IHRvIGlnbm9yZSBydWxlcyIKIG1zZ3N0ciAiYWdyZWdhciA8cGF0csOzbj4gcGFyYSBpZ25vcmFyIHJlZ2xhcyIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjkxNgorIzogYnVpbHRpbi9jbGVhbi5jOjkxNwogbXNnaWQgInJlbW92ZSBpZ25vcmVkIGZpbGVzLCB0b28iCiBtc2dzdHIgImJvcnJhciBhcmNoaXZvcyBpZ25vcmFkb3MsIHRhbWJpw6luIgogCi0jOiBidWlsdGluL2NsZWFuLmM6OTE4CisjOiBidWlsdGluL2NsZWFuLmM6OTE5CiBtc2dpZCAicmVtb3ZlIG9ubHkgaWdub3JlZCBmaWxlcyIKIG1zZ3N0ciAiYm9ycmFyIHNvbG8gYXJjaGl2b3MgaWdub3JhZG9zIgogCi0jOiBidWlsdGluL2NsZWFuLmM6OTM2CisjOiBidWlsdGluL2NsZWFuLmM6OTM3CiBtc2dpZCAiLXggYW5kIC1YIGNhbm5vdCBiZSB1c2VkIHRvZ2V0aGVyIgogbXNnc3RyICIteCB5IC1YIG5vIHB1ZWRlbiBzZXIgdXNhZGFzIGp1bnRhcyIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjk0MAorIzogYnVpbHRpbi9jbGVhbi5jOjk0MQogbXNnaWQgIiIKICJjbGVhbi5yZXF1aXJlRm9yY2Ugc2V0IHRvIHRydWUgYW5kIG5laXRoZXIgLWksIC1uLCBub3IgLWYgZ2l2ZW47IHJlZnVzaW5nIHRvICIKICJjbGVhbiIKQEAgLTEwODk3LDcgKzEwOTM0LDcgQEAKICJjbGVhbi5yZXF1aXJlRm9yY2UgY29uZmlndXJhZG8gY29tbyB0cnVlIHkgbmluZ3VubyAtaSwgLW4sIG5pIC1mIGVudHJlZ2Fkb3M7ICIKICJyZWh1c2FuZG8gZWwgY2xlYW4iCiAKLSM6IGJ1aWx0aW4vY2xlYW4uYzo5NDMKKyM6IGJ1aWx0aW4vY2xlYW4uYzo5NDQKIG1zZ2lkICIiCiAiY2xlYW4ucmVxdWlyZUZvcmNlIGRlZmF1bHRzIHRvIHRydWUgYW5kIG5laXRoZXIgLWksIC1uLCBub3IgLWYgZ2l2ZW47ICIKICJyZWZ1c2luZyB0byBjbGVhbiIKQEAgLTEwOTA1LDE2MCArMTA5NDIsMTYwIEBACiAiY2xlYW4ucmVxdWlyZUZvcmNlIGRlZmF1bHQgZW4gdHJ1ZSB5IG5pbmd1bm8gLWksIC1uLCBuaSAtZiBlbnRyZWdhZG9zOyAiCiAicmVodXNhbmRvIGVsIGNsZWFuIgogCi0jOiBidWlsdGluL2Nsb25lLmM6NDYKKyM6IGJ1aWx0aW4vY2xvbmUuYzo0NQogbXNnaWQgImdpdCBjbG9uZSBbPG9wdGlvbnM+XSBbLS1dIDxyZXBvPiBbPGRpcj5dIgogbXNnc3RyICJnaXQgY2xvbmUgWzxvcGNpb25lcz5dIFstLV0gPHJlcG8+IFs8ZGlyZWN0b3Jpbz5dIgogCi0jOiBidWlsdGluL2Nsb25lLmM6OTMKKyM6IGJ1aWx0aW4vY2xvbmUuYzo5MgogbXNnaWQgImRvbid0IGNyZWF0ZSBhIGNoZWNrb3V0IgogbXNnc3RyICJubyBjcmVhciBjaGVja291dCIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjk0IGJ1aWx0aW4vY2xvbmUuYzo5NiBidWlsdGluL2luaXQtZGIuYzo0ODkKKyM6IGJ1aWx0aW4vY2xvbmUuYzo5MyBidWlsdGluL2Nsb25lLmM6OTUgYnVpbHRpbi9pbml0LWRiLmM6NDg5CiBtc2dpZCAiY3JlYXRlIGEgYmFyZSByZXBvc2l0b3J5IgogbXNnc3RyICJjcmVhciB1biByZXBvc2l0b3JpbyB2YWPDrW8iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo5OAorIzogYnVpbHRpbi9jbG9uZS5jOjk3CiBtc2dpZCAiY3JlYXRlIGEgbWlycm9yIHJlcG9zaXRvcnkgKGltcGxpZXMgYmFyZSkiCiBtc2dzdHIgImNyZWFyIHVuIHJlcG9zaXRvcmlvIGVzcGVqbyAoaW1wbGljYSB2YWPDrW8pIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTAwCisjOiBidWlsdGluL2Nsb25lLmM6OTkKIG1zZ2lkICJ0byBjbG9uZSBmcm9tIGEgbG9jYWwgcmVwb3NpdG9yeSIKIG1zZ3N0ciAiY2xvbmFyIGRlIHVuIHJlcG9zaXRvcmlvIGxvY2FsIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTAyCisjOiBidWlsdGluL2Nsb25lLmM6MTAxCiBtc2dpZCAiZG9uJ3QgdXNlIGxvY2FsIGhhcmRsaW5rcywgYWx3YXlzIGNvcHkiCiBtc2dzdHIgIm5vIHVzYXIgaGFyZGxpbmtzLCBzaWVtcHJlIGNvcGlhciIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEwNAorIzogYnVpbHRpbi9jbG9uZS5jOjEwMwogbXNnaWQgInNldHVwIGFzIHNoYXJlZCByZXBvc2l0b3J5IgogbXNnc3RyICJjb25maWd1cmFyIGNvbW8gcmVwb3NpdG9yaW8gY29tcGFydGlkbyIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEwNworIzogYnVpbHRpbi9jbG9uZS5jOjEwNgogbXNnaWQgInBhdGhzcGVjIgogbXNnc3RyICJwYXRoc3BlYyIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEwNworIzogYnVpbHRpbi9jbG9uZS5jOjEwNgogbXNnaWQgImluaXRpYWxpemUgc3VibW9kdWxlcyBpbiB0aGUgY2xvbmUiCiBtc2dzdHIgImluaWNpYWxpemFyIHN1Ym3Ds2R1bG9zIGVuIGVsIGNsb25hZG8iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMTAKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMDkKIG1zZ2lkICJudW1iZXIgb2Ygc3VibW9kdWxlcyBjbG9uZWQgaW4gcGFyYWxsZWwiCiBtc2dzdHIgIm51bWVybyBkZSBzdWJtw7NkdWxvcyBjbG9uYWRvcyBlbiBwYXJhbGVsbyIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjExMSBidWlsdGluL2luaXQtZGIuYzo0ODYKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMTAgYnVpbHRpbi9pbml0LWRiLmM6NDg2CiBtc2dpZCAidGVtcGxhdGUtZGlyZWN0b3J5IgogbXNnc3RyICJkaXJlY3RvcmlvLXRlbXBsYXRlIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTEyIGJ1aWx0aW4vaW5pdC1kYi5jOjQ4NworIzogYnVpbHRpbi9jbG9uZS5jOjExMSBidWlsdGluL2luaXQtZGIuYzo0ODcKIG1zZ2lkICJkaXJlY3RvcnkgZnJvbSB3aGljaCB0ZW1wbGF0ZXMgd2lsbCBiZSB1c2VkIgogbXNnc3RyICJkaXJlY3RvcmlvIGRlbCBjdWFsIGxvcyB0ZW1wbGF0ZXMgc2Vyw6FuIHVzYWRvcyIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjExNCBidWlsdGluL2Nsb25lLmM6MTE2IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxMzgwCisjOiBidWlsdGluL2Nsb25lLmM6MTEzIGJ1aWx0aW4vY2xvbmUuYzoxMTUgYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjEzODAKICM6IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxODYwCiBtc2dpZCAicmVmZXJlbmNlIHJlcG9zaXRvcnkiCiBtc2dzdHIgInJlcG9zaXRvcmlvIGRlIHJlZmVyZW5jaWEiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMTggYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjEzODIKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMTcgYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjEzODIKICM6IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxODYyCiBtc2dpZCAidXNlIC0tcmVmZXJlbmNlIG9ubHkgd2hpbGUgY2xvbmluZyIKIG1zZ3N0ciAidXNhLS1yZWZlcmVuY2UgIHNvbGFtZW50ZSBzaSBlc3TDoXMgY2xvbmFkbyIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjExOSBidWlsdGluL2NvbHVtbi5jOjI3IGJ1aWx0aW4vbWVyZ2UtZmlsZS5jOjQ2Ci0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMTQgYnVpbHRpbi9yZXBhY2suYzozMTkKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMTggYnVpbHRpbi9jb2x1bW4uYzoyNyBidWlsdGluL21lcmdlLWZpbGUuYzo0NgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjk0IGJ1aWx0aW4vcmVwYWNrLmM6MzIwCiBtc2dpZCAibmFtZSIKIG1zZ3N0ciAibm9tYnJlIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTIwCisjOiBidWlsdGluL2Nsb25lLmM6MTE5CiBtc2dpZCAidXNlIDxuYW1lPiBpbnN0ZWFkIG9mICdvcmlnaW4nIHRvIHRyYWNrIHVwc3RyZWFtIgogbXNnc3RyICJ1c2UgPG5vbWJyZT4gZW4gbHVnYXIgZGUgJ29yaWdpbicgcGFyYSByYXN0cmVhciB1cHN0cmVhbSIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEyMgorIzogYnVpbHRpbi9jbG9uZS5jOjEyMQogbXNnaWQgImNoZWNrb3V0IDxicmFuY2g+IGluc3RlYWQgb2YgdGhlIHJlbW90ZSdzIEhFQUQiCiBtc2dzdHIgImNoZWNrb3V0IDxyYW1hPiBlbiBsdWdhciBkZSBIRUFEIHJlbW90YSIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEyNAorIzogYnVpbHRpbi9jbG9uZS5jOjEyMwogbXNnaWQgInBhdGggdG8gZ2l0LXVwbG9hZC1wYWNrIG9uIHRoZSByZW1vdGUiCiBtc2dzdHIgInJ1dGEgcGFyYSBnaXQtdXBsb2FkLXBhY2sgZW4gZWwgcmVtb3RvIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTI1IGJ1aWx0aW4vZmV0Y2guYzoxNTIgYnVpbHRpbi9ncmVwLmM6ODM4Ci0jOiBidWlsdGluL3B1bGwuYzoyMjYKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMjQgYnVpbHRpbi9mZXRjaC5jOjE2NyBidWlsdGluL2dyZXAuYzo4NDAKKyM6IGJ1aWx0aW4vcHVsbC5jOjIyNwogbXNnaWQgImRlcHRoIgogbXNnc3RyICJwcm9mdW5kaWRhZCIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEyNgorIzogYnVpbHRpbi9jbG9uZS5jOjEyNQogbXNnaWQgImNyZWF0ZSBhIHNoYWxsb3cgY2xvbmUgb2YgdGhhdCBkZXB0aCIKIG1zZ3N0ciAiY3JlYXIgdW4gY2xvbiBzdXBlcmZpY2lhbCBwYXJhIGVzYSBwcm9mdW5kaWRhZCIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEyNyBidWlsdGluL2ZldGNoLmM6MTU0IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMwMworIzogYnVpbHRpbi9jbG9uZS5jOjEyNiBidWlsdGluL2ZldGNoLmM6MTY5IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI4MwogbXNnaWQgInRpbWUiCiBtc2dzdHIgInRpZW1wbyIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEyOAorIzogYnVpbHRpbi9jbG9uZS5jOjEyNwogbXNnaWQgImNyZWF0ZSBhIHNoYWxsb3cgY2xvbmUgc2luY2UgYSBzcGVjaWZpYyB0aW1lIgogbXNnc3RyICJjcmVhciB1biBjbG9uIHN1cGVyZmljaWFsIGRlc2RlIGVsIHRpZW1wbyBlc3BlY8OtZmljbyIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEyOSBidWlsdGluL2ZldGNoLmM6MTU2IGJ1aWx0aW4vZmV0Y2guYzoxNzkKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTM5NQorIzogYnVpbHRpbi9jbG9uZS5jOjEyOCBidWlsdGluL2ZldGNoLmM6MTcxIGJ1aWx0aW4vZmV0Y2guYzoxOTQKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQxNwogbXNnaWQgInJldmlzaW9uIgogbXNnc3RyICJyZXZpc2lvbiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEzMCBidWlsdGluL2ZldGNoLmM6MTU3CisjOiBidWlsdGluL2Nsb25lLmM6MTI5IGJ1aWx0aW4vZmV0Y2guYzoxNzIKIG1zZ2lkICJkZWVwZW4gaGlzdG9yeSBvZiBzaGFsbG93IGNsb25lLCBleGNsdWRpbmcgcmV2IgogbXNnc3RyICJhaG9uZGFuZG8gaGlzdG9yaWEgZGUgY2xvbiBzdXBlcmZpY2lhbCwgZXhjbHV5ZW5kbyByZXYiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMzIKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMzEKIG1zZ2lkICJjbG9uZSBvbmx5IG9uZSBicmFuY2gsIEhFQUQgb3IgLS1icmFuY2giCiBtc2dzdHIgImNsb25hciBzb2xvIHVuYSByYW1hLEhFQUQgbyAtLWJyYW5jaCIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEzNAorIzogYnVpbHRpbi9jbG9uZS5jOjEzMwogbXNnaWQgImRvbid0IGNsb25lIGFueSB0YWdzLCBhbmQgbWFrZSBsYXRlciBmZXRjaGVzIG5vdCB0byBmb2xsb3cgdGhlbSIKIG1zZ3N0ciAibm8gY2xvbmFyIG5pbmfDum4gdGFnLCB5IGhhY2VyIHF1ZSBsb3Mgc3Vic2lndWllbnRlcyBmZXRjaCBubyBsb3Mgc2lnYW4iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMzYKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMzUKIG1zZ2lkICJhbnkgY2xvbmVkIHN1Ym1vZHVsZXMgd2lsbCBiZSBzaGFsbG93IgogbXNnc3RyICJjdWFscXVpZXIgc3VibcOzZHVsbyBjbG9uYWRvIHNlcsOhIHN1cGVyZmljaWFsIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTM3IGJ1aWx0aW4vaW5pdC1kYi5jOjQ5NQorIzogYnVpbHRpbi9jbG9uZS5jOjEzNiBidWlsdGluL2luaXQtZGIuYzo0OTUKIG1zZ2lkICJnaXRkaXIiCiBtc2dzdHIgImdpdGRpciIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEzOCBidWlsdGluL2luaXQtZGIuYzo0OTYKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMzcgYnVpbHRpbi9pbml0LWRiLmM6NDk2CiBtc2dpZCAic2VwYXJhdGUgZ2l0IGRpciBmcm9tIHdvcmtpbmcgdHJlZSIKIG1zZ3N0ciAic2VwYXJhIGdpdCBkaXIgZGVsIMOhcmJvbCBkZSB0cmFiYWpvIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTM5CisjOiBidWlsdGluL2Nsb25lLmM6MTM4CiBtc2dpZCAia2V5PXZhbHVlIgogbXNnc3RyICJsbGF2ZT12YWxvciIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjE0MAorIzogYnVpbHRpbi9jbG9uZS5jOjEzOQogbXNnaWQgInNldCBjb25maWcgaW5zaWRlIHRoZSBuZXcgcmVwb3NpdG9yeSIKIG1zZ3N0ciAiY29uZmlndXJhciBjb25maWcgZGVudHJvIGRlbCBudWV2byByZXBvc2l0b3JpbyIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjE0MiBidWlsdGluL2ZldGNoLmM6MTc0IGJ1aWx0aW4vbHMtcmVtb3RlLmM6NzYKLSM6IGJ1aWx0aW4vcHVzaC5jOjU4NSBidWlsdGluL3NlbmQtcGFjay5jOjE3MgorIzogYnVpbHRpbi9jbG9uZS5jOjE0MSBidWlsdGluL2ZldGNoLmM6MTg5IGJ1aWx0aW4vbHMtcmVtb3RlLmM6NzYKKyM6IGJ1aWx0aW4vcHVzaC5jOjU3MiBidWlsdGluL3NlbmQtcGFjay5jOjE3MgogbXNnaWQgInNlcnZlci1zcGVjaWZpYyIKIG1zZ3N0ciAiZXNwZWNpZmljby1kZS1zZXJ2aWRvciIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjE0MiBidWlsdGluL2ZldGNoLmM6MTc0IGJ1aWx0aW4vbHMtcmVtb3RlLmM6NzYKLSM6IGJ1aWx0aW4vcHVzaC5jOjU4NSBidWlsdGluL3NlbmQtcGFjay5jOjE3MworIzogYnVpbHRpbi9jbG9uZS5jOjE0MSBidWlsdGluL2ZldGNoLmM6MTg5IGJ1aWx0aW4vbHMtcmVtb3RlLmM6NzYKKyM6IGJ1aWx0aW4vcHVzaC5jOjU3MiBidWlsdGluL3NlbmQtcGFjay5jOjE3MwogbXNnaWQgIm9wdGlvbiB0byB0cmFuc21pdCIKIG1zZ3N0ciAib3BjacOzbiBwYXJhIHRyYXNtaXRpciIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjE0MyBidWlsdGluL2ZldGNoLmM6MTc1IGJ1aWx0aW4vcHVsbC5jOjIzOQotIzogYnVpbHRpbi9wdXNoLmM6NTg2CisjOiBidWlsdGluL2Nsb25lLmM6MTQyIGJ1aWx0aW4vZmV0Y2guYzoxOTAgYnVpbHRpbi9wdWxsLmM6MjQwCisjOiBidWlsdGluL3B1c2guYzo1NzMKIG1zZ2lkICJ1c2UgSVB2NCBhZGRyZXNzZXMgb25seSIKIG1zZ3N0ciAic29sbyB1c2FyIGRpcmVjY2lvbmVzIElQdjQiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxNDUgYnVpbHRpbi9mZXRjaC5jOjE3NyBidWlsdGluL3B1bGwuYzoyNDIKLSM6IGJ1aWx0aW4vcHVzaC5jOjU4OAorIzogYnVpbHRpbi9jbG9uZS5jOjE0NCBidWlsdGluL2ZldGNoLmM6MTkyIGJ1aWx0aW4vcHVsbC5jOjI0MworIzogYnVpbHRpbi9wdXNoLmM6NTc1CiBtc2dpZCAidXNlIElQdjYgYWRkcmVzc2VzIG9ubHkiCiBtc2dzdHIgInNvbG8gdXNhciBkaXJlY2Npb25lcyBJUHY2IgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTQ5CisjOiBidWlsdGluL2Nsb25lLmM6MTQ4CiBtc2dpZCAiYW55IGNsb25lZCBzdWJtb2R1bGVzIHdpbGwgdXNlIHRoZWlyIHJlbW90ZS10cmFja2luZyBicmFuY2giCiBtc2dzdHIgImN1YWxxdWllciBzdWJtw7NkdWxvIGNsb25hZG8gdXNhcsOhIHN1IGJyYW5jaCBkZSByYXN0cmVvIHJlbW90byIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjI4NQorIzogYnVpbHRpbi9jbG9uZS5jOjI4NAogbXNnaWQgIiIKICJObyBkaXJlY3RvcnkgbmFtZSBjb3VsZCBiZSBndWVzc2VkLlxuIgogIlBsZWFzZSBzcGVjaWZ5IGEgZGlyZWN0b3J5IG9uIHRoZSBjb21tYW5kIGxpbmUiCkBAIC0xMTA2Niw0NyArMTExMDMsNDIgQEAKICJObyBzZSBwdWRvIGFkaXZpbmFyIG5pbmfDum4gbm9tYnJlIGRlIGRpcmVjdG9yaW8uXG4iCiAiUG9yIGZhdm9yIGVzcGVjaWZpcXVlIHVuIGRpcmVjdG9yaW8gZW4gbGEgbMOtbmVhIGRlIGNvbWFuZG8iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzozMzgKKyM6IGJ1aWx0aW4vY2xvbmUuYzozMzcKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW5mbzogQ291bGQgbm90IGFkZCBhbHRlcm5hdGUgZm9yICclcyc6ICVzXG4iCiBtc2dzdHIgImluZm86IE5vIHNlIHB1ZG8gYWdyZWdhciB1biBhbHRlcm5vIHBhcmEgJyVzJzogJXNcbiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjQxMQorIzogYnVpbHRpbi9jbG9uZS5jOjQxMAogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyBleGlzdHMgYW5kIGlzIG5vdCBhIGRpcmVjdG9yeSIKIG1zZ3N0ciAiJXMgZXhpc3RlIHBlcm8gbm8gZXMgdW4gZGlyZWN0b3JpbyIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjQyOAorIzogYnVpbHRpbi9jbG9uZS5jOjQyNwogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gc3RhcnQgaXRlcmF0b3Igb3ZlciAnJXMnIgogbXNnc3RyICJmYWxsw7MgYWwgaW5pY2lhciBlbCBpdGVyYWRvciBzb2JyZSAnJXMnIgogCi0jOiBidWlsdGluL2Nsb25lLmM6NDUzCi0jLCBjLWZvcm1hdAotbXNnaWQgImZhaWxlZCB0byB1bmxpbmsgJyVzJyIKLW1zZ3N0ciAiZmFsbMOzIGFsIGRlc3ZpbmN1bGFyICclcyciCi0KLSM6IGJ1aWx0aW4vY2xvbmUuYzo0NTgKKyM6IGJ1aWx0aW4vY2xvbmUuYzo0NTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIGNyZWF0ZSBsaW5rICclcyciCiBtc2dzdHIgImZhbGzDsyBhbCBjcmVhciBsaW5rICclcyciCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo0NjIKKyM6IGJ1aWx0aW4vY2xvbmUuYzo0NjEKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIGNvcHkgZmlsZSB0byAnJXMnIgogbXNnc3RyICJmYWxsw7MgYWwgY29waWFyIGFyY2hpdm8gYSAnJXMnIgogCi0jOiBidWlsdGluL2Nsb25lLmM6NDY3CisjOiBidWlsdGluL2Nsb25lLmM6NDY2CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBpdGVyYXRlIG92ZXIgJyVzJyIKIG1zZ3N0ciAiZmFsbMOzIGFsIGl0ZXJhciBzb2JyZSAnJXMnIgogCi0jOiBidWlsdGluL2Nsb25lLmM6NDkyCisjOiBidWlsdGluL2Nsb25lLmM6NDkxCiAjLCBjLWZvcm1hdAogbXNnaWQgImRvbmUuXG4iCiBtc2dzdHIgImhlY2hvLlxuIgogCi0jOiBidWlsdGluL2Nsb25lLmM6NTA2CisjOiBidWlsdGluL2Nsb25lLmM6NTA1CiBtc2dpZCAiIgogIkNsb25lIHN1Y2NlZWRlZCwgYnV0IGNoZWNrb3V0IGZhaWxlZC5cbiIKICJZb3UgY2FuIGluc3BlY3Qgd2hhdCB3YXMgY2hlY2tlZCBvdXQgd2l0aCAnZ2l0IHN0YXR1cydcbiIKQEAgLTExMTE2LDk2ICsxMTE0OCw5NiBAQAogIlB1ZWRlcyBpbnNwZWNjaW9uYXIgYSBxdcOpIHNlIGhpem8gY2hlY2tvdXQgY29uICdnaXQgc3RhdHVzJ1xuIgogInkgdm9sdmVyIGEgaW50ZW50YXJsbyBjb24gJ2dpdCByZXN0b3JlIC0tc291cmNlPUhFQUQgOi8nXG4iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo1ODMKKyM6IGJ1aWx0aW4vY2xvbmUuYzo1ODIKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ291bGQgbm90IGZpbmQgcmVtb3RlIGJyYW5jaCAlcyB0byBjbG9uZS4iCiBtc2dzdHIgIk5vIHNlIHB1ZG8gZW5jb250cmFyIGxhIHJhbWEgcmVtb3RhICVzIHBhcmEgY2xvbmFyLiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjcwMgorIzogYnVpbHRpbi9jbG9uZS5jOjcwMQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gdXBkYXRlICVzIgogbXNnc3RyICJpbmNhcGF6IGRlIGFjdHVhbGl6YXIgJXMiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo3NTIKKyM6IGJ1aWx0aW4vY2xvbmUuYzo3NTEKIG1zZ2lkICJyZW1vdGUgSEVBRCByZWZlcnMgdG8gbm9uZXhpc3RlbnQgcmVmLCB1bmFibGUgdG8gY2hlY2tvdXQuXG4iCiBtc2dzdHIgIiIKICJyZW1vdG8gSEVBRCByZWZpZXJlIGEgdW4gcmVmIGluZXhpc3RlbnRlLCBubyBzZSBwdWVkZSBoYWNlciBjaGVja291dC5cbiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjc4MworIzogYnVpbHRpbi9jbG9uZS5jOjc4MgogbXNnaWQgInVuYWJsZSB0byBjaGVja291dCB3b3JraW5nIHRyZWUiCiBtc2dzdHIgIm5vIGVzIHBvc2libGUgcmVhbGl6YXIgY2hlY2tvdXQgZW4gZWwgw6FyYm9sIGRlIHRyYWJham8iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo4MzMKKyM6IGJ1aWx0aW4vY2xvbmUuYzo4MzIKIG1zZ2lkICJ1bmFibGUgdG8gd3JpdGUgcGFyYW1ldGVycyB0byBjb25maWcgZmlsZSIKIG1zZ3N0ciAibm8gZXMgcG9zaWJsZSBlc2NyaWJpciBwYXLDoW1ldHJvcyBhbCBhcmNoaXZvIGNvbmZpZyIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjg5NgorIzogYnVpbHRpbi9jbG9uZS5jOjg5NQogbXNnaWQgImNhbm5vdCByZXBhY2sgdG8gY2xlYW4gdXAiCiBtc2dzdHIgIm5vIHNlIHB1ZWRlIHJlZW1wYXF1ZXRhciBwYXJhIGxpbXBpYXIiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo4OTgKKyM6IGJ1aWx0aW4vY2xvbmUuYzo4OTcKIG1zZ2lkICJjYW5ub3QgdW5saW5rIHRlbXBvcmFyeSBhbHRlcm5hdGVzIGZpbGUiCiBtc2dzdHIgIm5vIHNlIHB1ZWRlIGRlc3ZpbmN1bGFyIGFyY2hpdm9zIGFsdGVybm9zIHRlbXBvcmFsZXMiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo5MzggYnVpbHRpbi9yZWNlaXZlLXBhY2suYzoxOTUwCisjOiBidWlsdGluL2Nsb25lLmM6OTM3IGJ1aWx0aW4vcmVjZWl2ZS1wYWNrLmM6MTk0OAogbXNnaWQgIlRvbyBtYW55IGFyZ3VtZW50cy4iCiBtc2dzdHIgIk11Y2hvcyBhcmd1bWVudG9zLiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjk0MgorIzogYnVpbHRpbi9jbG9uZS5jOjk0MQogbXNnaWQgIllvdSBtdXN0IHNwZWNpZnkgYSByZXBvc2l0b3J5IHRvIGNsb25lLiIKIG1zZ3N0ciAiVGllbmVzIHF1ZSBlc3BlY2lmaWNhciB1biByZXBvc2l0b3JpbyBwYXJhIGNsb25hci4iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo5NTUKKyM6IGJ1aWx0aW4vY2xvbmUuYzo5NTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiLS1iYXJlIGFuZCAtLW9yaWdpbiAlcyBvcHRpb25zIGFyZSBpbmNvbXBhdGlibGUuIgogbXNnc3RyICJMYXMgb3BjaW9uZXMgLS1iYXJlIHkgLS1vcmlnaW4gJXMgc29uIGluY29tcGF0aWJsZXMuIgogCi0jOiBidWlsdGluL2Nsb25lLmM6OTU4CisjOiBidWlsdGluL2Nsb25lLmM6OTU3CiBtc2dpZCAiLS1iYXJlIGFuZCAtLXNlcGFyYXRlLWdpdC1kaXIgYXJlIGluY29tcGF0aWJsZS4iCiBtc2dzdHIgIi0tYmFyZSB5IC0tc2VwYXJhdGUtZ2l0LWRpciBzb24gaW5jb21wYXRpYmxlcy4iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo5NzEKKyM6IGJ1aWx0aW4vY2xvbmUuYzo5NzAKICMsIGMtZm9ybWF0CiBtc2dpZCAicmVwb3NpdG9yeSAnJXMnIGRvZXMgbm90IGV4aXN0IgogbXNnc3RyICJyZXBvc2l0b3JpbyAnJXMnIG5vIGV4aXN0ZSIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjk3NyBidWlsdGluL2ZldGNoLmM6MTY2MAorIzogYnVpbHRpbi9jbG9uZS5jOjk3NiBidWlsdGluL2ZldGNoLmM6MTc5MAogIywgYy1mb3JtYXQKIG1zZ2lkICJkZXB0aCAlcyBpcyBub3QgYSBwb3NpdGl2ZSBudW1iZXIiCiBtc2dzdHIgInByb2Z1bmRpZGFkICVzIG5vIGVzIHVuIG51bWVybyBwb3NpdGl2byIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjk4NworIzogYnVpbHRpbi9jbG9uZS5jOjk4NgogIywgYy1mb3JtYXQKIG1zZ2lkICJkZXN0aW5hdGlvbiBwYXRoICclcycgYWxyZWFkeSBleGlzdHMgYW5kIGlzIG5vdCBhbiBlbXB0eSBkaXJlY3RvcnkuIgogbXNnc3RyICJsYSBydXRhIGRlIGRlc3Rpbm8gJyVzJyB5YSBleGlzdGUgeSBubyBlcyB1biBkaXJlY3RvcmlvIHZhY8Otby4iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo5OTcKKyM6IGJ1aWx0aW4vY2xvbmUuYzo5OTYKICMsIGMtZm9ybWF0CiBtc2dpZCAid29ya2luZyB0cmVlICclcycgYWxyZWFkeSBleGlzdHMuIgogbXNnc3RyICJkaXJlY3RvcmlvIGRlIHRyYWJham8gJyVzJyB5YSBleGlzdGUuIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTAxMiBidWlsdGluL2Nsb25lLmM6MTAzMyBidWlsdGluL2RpZmZ0b29sLmM6MjY0Ci0jOiBidWlsdGluL3dvcmt0cmVlLmM6MzAzIGJ1aWx0aW4vd29ya3RyZWUuYzozMzUKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMDExIGJ1aWx0aW4vY2xvbmUuYzoxMDMyIGJ1aWx0aW4vZGlmZnRvb2wuYzoyNzEKKyM6IGJ1aWx0aW4vbG9nLmM6MTc4NSBidWlsdGluL3dvcmt0cmVlLmM6MzAyIGJ1aWx0aW4vd29ya3RyZWUuYzozMzQKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGNyZWF0ZSBsZWFkaW5nIGRpcmVjdG9yaWVzIG9mICclcyciCiBtc2dzdHIgIm5vIHNlIHB1ZG8gY3JlYXIgZGlyZWN0b3Jpb3MgcHJpbmNpcGFsZXMgZGUgJyVzJyIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEwMTcKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMDE2CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBjcmVhdGUgd29yayB0cmVlIGRpciAnJXMnIgogbXNnc3RyICJubyBzZSBwdWRvIGNyZWFyIHVuIMOhcmJvbCBkZSB0cmFiYWpvICclcyciCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMDM3CisjOiBidWlsdGluL2Nsb25lLmM6MTAzNgogIywgYy1mb3JtYXQKIG1zZ2lkICJDbG9uaW5nIGludG8gYmFyZSByZXBvc2l0b3J5ICclcycuLi5cbiIKIG1zZ3N0ciAiQ2xvbmFuZG8gZW4gdW4gcmVwb3NpdG9yaW8gdmFjw61vICclcycuLi5cbiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEwMzkKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMDM4CiAjLCBjLWZvcm1hdAogbXNnaWQgIkNsb25pbmcgaW50byAnJXMnLi4uXG4iCiBtc2dzdHIgIkNsb25hbmRvIGVuICclcycuLi5cbiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEwNjMKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMDYyCiBtc2dpZCAiIgogImNsb25lIC0tcmVjdXJzaXZlIGlzIG5vdCBjb21wYXRpYmxlIHdpdGggYm90aCAtLXJlZmVyZW5jZSBhbmQgLS1yZWZlcmVuY2UtaWYtIgogImFibGUiCkBAIC0xMTIxMywzNiArMTEyNDUsMzYgQEAKICJjbG9uZSAtLXJlY3Vyc2l2ZSBubyBlcyBjb21wYXRpYmxlIGNvbiAtLXJlZmVyZW5jZSB5IC0tcmVmZXJlbmNlLWlmLWFibGUgYWwgIgogIm1pc21vIHRpZW1wbyIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjExMjQKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMTIzCiBtc2dpZCAiLS1kZXB0aCBpcyBpZ25vcmVkIGluIGxvY2FsIGNsb25lczsgdXNlIGZpbGU6Ly8gaW5zdGVhZC4iCiBtc2dzdHIgIi0tZGVwdGggZXMgaWdub3JhZGEgZW4gY2xvbmFjaW9uZXMgbG9jYWxlczsgdXNhIGZpbGU6Ly8gbcOhcyBiaWVuLiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjExMjYKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMTI1CiBtc2dpZCAiLS1zaGFsbG93LXNpbmNlIGlzIGlnbm9yZWQgaW4gbG9jYWwgY2xvbmVzOyB1c2UgZmlsZTovLyBpbnN0ZWFkLiIKIG1zZ3N0ciAiLS1zaGFsbG93LXNpbmNlIGVzIGlnbm9yYWRvIGVuIGVsIGNsb24gbG9jYWw7IHVzZSBmaWxlOi8vIC4iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMTI4CisjOiBidWlsdGluL2Nsb25lLmM6MTEyNwogbXNnaWQgIi0tc2hhbGxvdy1leGNsdWRlIGlzIGlnbm9yZWQgaW4gbG9jYWwgY2xvbmVzOyB1c2UgZmlsZTovLyBpbnN0ZWFkLiIKIG1zZ3N0ciAiLS1zaGFsbG93LWV4Y2x1ZGUgZXMgaWdub3JhZG8gZW4gY2xvbmVzIGxvY2FsZXM7IHVzZSBmaWxlOi8vLiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjExMzAKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMTI5CiBtc2dpZCAiLS1maWx0ZXIgaXMgaWdub3JlZCBpbiBsb2NhbCBjbG9uZXM7IHVzZSBmaWxlOi8vIGluc3RlYWQuIgogbXNnc3RyICItLWZpbHRlciBlcyBpZ25vcmFkbyBlbiBjbG9uZXMgbG9jYWxlczsgdXNhIGZpbGU6Ly8gZW4gc3UgbHVnYXIuIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTEzMworIzogYnVpbHRpbi9jbG9uZS5jOjExMzIKIG1zZ2lkICJzb3VyY2UgcmVwb3NpdG9yeSBpcyBzaGFsbG93LCBpZ25vcmluZyAtLWxvY2FsIgogbXNnc3RyICJyZXBvc2l0b3JpbyBmdWVudGUgZXMgc3VwZXJmaWNpYWwsIGlnbm9yYW5kbyAtLWxvY2FsIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTEzOAorIzogYnVpbHRpbi9jbG9uZS5jOjExMzcKIG1zZ2lkICItLWxvY2FsIGlzIGlnbm9yZWQiCiBtc2dzdHIgIi0tbG9jYWwgZXMgaWdub3JhZG8iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMjE1IGJ1aWx0aW4vY2xvbmUuYzoxMjIzCisjOiBidWlsdGluL2Nsb25lLmM6MTIxMiBidWlsdGluL2Nsb25lLmM6MTIyMAogIywgYy1mb3JtYXQKIG1zZ2lkICJSZW1vdGUgYnJhbmNoICVzIG5vdCBmb3VuZCBpbiB1cHN0cmVhbSAlcyIKIG1zZ3N0ciAiUmFtYSByZW1vdGEgJXMgbm8gZW5jb250cmFkYSBlbiB1cHN0cmVhbSAlcyIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEyMjYKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMjIzCiBtc2dpZCAiWW91IGFwcGVhciB0byBoYXZlIGNsb25lZCBhbiBlbXB0eSByZXBvc2l0b3J5LiIKIG1zZ3N0ciAiUGFyZWNlcyBoYWJlciBjbG9uYWRvIHVuIHJlcG9zaXRvcmlvIHNpbiBjb250ZW5pZG8uIgogCkBAIC0xMTMyMCw3ICsxMTM1Miw3IEBACiBtc2dzdHIgImlkIGRlbCBvYmpldG8gY29tbWl0IHBhZHJlIgogCiAjOiBidWlsdGluL2NvbW1pdC10cmVlLmM6MTE0IGJ1aWx0aW4vY29tbWl0LmM6MTUwMCBidWlsdGluL21lcmdlLmM6MjcwCi0jOiBidWlsdGluL25vdGVzLmM6NDA5IGJ1aWx0aW4vbm90ZXMuYzo1NzUgYnVpbHRpbi9zdGFzaC5jOjE0NjAKKyM6IGJ1aWx0aW4vbm90ZXMuYzo0MDkgYnVpbHRpbi9ub3Rlcy5jOjU3NSBidWlsdGluL3N0YXNoLmM6MTQ2OQogIzogYnVpbHRpbi90YWcuYzo0MTIKIG1zZ2lkICJtZXNzYWdlIgogbXNnc3RyICJtZW5zYWplIgpAQCAtMTEzMzQsNyArMTEzNjYsNyBAQAogbXNnc3RyICJsZWVyIG1lbnNhamUgZGUgY29tbWl0IGRlc2RlIHVuIGFyY2hpdm8iCiAKICM6IGJ1aWx0aW4vY29tbWl0LXRyZWUuYzoxMjEgYnVpbHRpbi9jb21taXQuYzoxNTEyIGJ1aWx0aW4vbWVyZ2UuYzoyODcKLSM6IGJ1aWx0aW4vcHVsbC5jOjE5NCBidWlsdGluL3JldmVydC5jOjExOAorIzogYnVpbHRpbi9wdWxsLmM6MTk1IGJ1aWx0aW4vcmV2ZXJ0LmM6MTE4CiBtc2dpZCAiR1BHIHNpZ24gY29tbWl0IgogbXNnc3RyICJGaXJtYXIgY29tbWl0IGNvbiBHUEciCiAKQEAgLTExNTA5LDcgKzExNTQxLDcgQEAKIG1zZ3N0ciAiIgogIlxuIgogIlBhcmVjZSBxdWUgZXN0w6FzIGhhY2llbmRvIHVuIGNvbW1pdCBjb24gdW5hIGZ1c2nDs24gZGVudHJvLlxuIgotIlNpIGVzdG8gbm8gZXMgY29ycmVjdG8sIHBvciBmYXZvciByZW11ZXZlIGVsIGFyY2hpdm9cbiIKKyJTaSBlc3RvIG5vIGVzIGNvcnJlY3RvLCBwb3IgZmF2b3IgZWxpbWluYSBlbCBhcmNoaXZvXG4iCiAiXHQlc1xuIgogInkgdnVlbHZlIGEgaW50ZW50YXIuXG4iCiAKQEAgLTExNTM0LDkgKzExNTY2LDkgQEAKICJQbGVhc2UgZW50ZXIgdGhlIGNvbW1pdCBtZXNzYWdlIGZvciB5b3VyIGNoYW5nZXMuIExpbmVzIHN0YXJ0aW5nXG4iCiAid2l0aCAnJWMnIHdpbGwgYmUgaWdub3JlZCwgYW5kIGFuIGVtcHR5IG1lc3NhZ2UgYWJvcnRzIHRoZSBjb21taXQuXG4iCiBtc2dzdHIgIiIKLSJQb3IgZmF2b3IgaW5ncmVzYSBlbCBtZW5zYWplIGRlbCBjb21taXQgcGFyYSB0dXMgY2FtYmlvcy4gTGFzIGzDrW5lYXMgcXVlICIKLSJjb21pZW5jZW5cbiIKLSJjb24gJyVjJyBzZXLDoW4gaWdub3JhZGFzLCB5IHVuIG1lbnNhamUgdmFjw61vIGFib3J0YSBlbCBjb21taXQuXG4iCisiUG9yIGZhdm9yIGluZ3Jlc2EgZWwgbWVuc2FqZSBkZWwgY29tbWl0IHBhcmEgdHVzIGNhbWJpb3MuIExhc1xuIgorIiBsw61uZWFzIHF1ZSBjb21pZW5jZW4gY29uICclYycgc2Vyw6FuIGlnbm9yYWRhcywgeSB1biBtZW5zYWplXG4iCisiIHZhY8OtbyBhYm9ydGEgZWwgY29tbWl0LlxuIgogCiAjOiBidWlsdGluL2NvbW1pdC5jOjg1NQogIywgYy1mb3JtYXQKQEAgLTExNTQ1LDkgKzExNTc3LDkgQEAKICJ3aXRoICclYycgd2lsbCBiZSBrZXB0OyB5b3UgbWF5IHJlbW92ZSB0aGVtIHlvdXJzZWxmIGlmIHlvdSB3YW50IHRvLlxuIgogIkFuIGVtcHR5IG1lc3NhZ2UgYWJvcnRzIHRoZSBjb21taXQuXG4iCiBtc2dzdHIgIiIKLSJQb3IgZmF2b3IgaW5ncmVzYSBlbCBtZW5zYWplIGRlbCBjb21taXQgcGFyYSB0dXMgY2FtYmlvcy4gTGFzIGzDrW5lYXMgcXVlICIKLSJjb21pZW5jZW5cbiIKLSJjb24gJyVjJyBzZXLDoW4gZ3VhcmRhZGFzOyBwdWVkZSBlbGltaW5hcmxhcyB1c3RlZCBtaXNtbyBzaSBkZXNlYS5cbiIKKyJQb3IgZmF2b3IgaW5ncmVzYSBlbCBtZW5zYWplIGRlbCBjb21taXQgcGFyYSB0dXMgY2FtYmlvcy4gTGFzXG4iCisiIGzDrW5lYXMgcXVlIGNvbWllbmNlbiBjb24gJyVjJyBzZXLDoW4gZ3VhcmRhZGFzOyBwdWVkZSBlbGltaW5hcmxhc1xuIgorIiB1c3RlZCBtaXNtbyBzaSBsbyBkZXNlYS5cbiIKICJVbiBtZW5zYWplIHZhY8OtbyBhYm9ydGEgZWwgY29tbWl0LlxuIgogCiAjOiBidWlsdGluL2NvbW1pdC5jOjg3MgpAQCAtMTE2NjUsOCArMTE2OTcsOCBAQAogbXNnaWQgInZlcnNpb24iCiBtc2dzdHIgInZlcnNpb24iCiAKLSM6IGJ1aWx0aW4vY29tbWl0LmM6MTM0NyBidWlsdGluL2NvbW1pdC5jOjE1MjkgYnVpbHRpbi9wdXNoLmM6NTYxCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NjUxCisjOiBidWlsdGluL2NvbW1pdC5jOjEzNDcgYnVpbHRpbi9jb21taXQuYzoxNTI5IGJ1aWx0aW4vcHVzaC5jOjU0OAorIzogYnVpbHRpbi93b3JrdHJlZS5jOjY1MAogbXNnaWQgIm1hY2hpbmUtcmVhZGFibGUgb3V0cHV0IgogbXNnc3RyICJvdXRwdXQgZm9ybWF0by1tYXF1aW5hIgogCkBAIC0xMTY3OSw4ICsxMTcxMSw4IEBACiBtc2dzdHIgInRlcm1pbmFyIGVudHJhZGFzIGNvbiBOVUwiCiAKICM6IGJ1aWx0aW4vY29tbWl0LmM6MTM1NSBidWlsdGluL2NvbW1pdC5jOjEzNTkgYnVpbHRpbi9jb21taXQuYzoxNTM3Ci0jOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTEyNSBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTEyOAotIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExMzEgYnVpbHRpbi9yZWJhc2UuYzoxNDcxIHBhcnNlLW9wdGlvbnMuaDozMzIKKyM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTUzIGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTU2CisjOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE1OSBidWlsdGluL3JlYmFzZS5jOjE0OTUgcGFyc2Utb3B0aW9ucy5oOjMzMgogbXNnaWQgIm1vZGUiCiBtc2dzdHIgIm1vZG8iCiAKQEAgLTExNjk4LDcgKzExNzMwLDcgQEAKICJtb3N0cmFyIGFyY2hpdm9zIGlnbm9yYWRvcywgbW9kb3Mgb3BjaW9uYWxlczogdHJhZGl0aW9uYWwsIG1hdGNoaW5nLCBuby4gIgogIihQcmVkZXRlcm1pbmFkbzogdHJhZGl0aW9uYWwpIgogCi0jOiBidWlsdGluL2NvbW1pdC5jOjEzNjIgcGFyc2Utb3B0aW9ucy5oOjE3OQorIzogYnVpbHRpbi9jb21taXQuYzoxMzYyIHBhcnNlLW9wdGlvbnMuaDoxODgKIG1zZ2lkICJ3aGVuIgogbXNnc3RyICJjdWFuZG8iCiAKQEAgLTExNzUxLDcgKzExNzgzLDcgQEAKIG1zZ2lkICJvdmVycmlkZSBhdXRob3IgZm9yIGNvbW1pdCIKIG1zZ3N0ciAic29icmVzY3JpYmUgZWwgYXV0b3IgZGVsIGNvbW1pdCIKIAotIzogYnVpbHRpbi9jb21taXQuYzoxNDk5IGJ1aWx0aW4vZ2MuYzo1MzkKKyM6IGJ1aWx0aW4vY29tbWl0LmM6MTQ5OSBidWlsdGluL2djLmM6NTM4CiBtc2dpZCAiZGF0ZSIKIG1zZ3N0ciAiZmVjaGEiCiAKQEAgLTExNzg3LDggKzExODE5LDggQEAKIG1zZ2lkICJ0aGUgY29tbWl0IGlzIGF1dGhvcmVkIGJ5IG1lIG5vdyAodXNlZCB3aXRoIC1DLy1jLy0tYW1lbmQpIgogbXNnc3RyICJlbCBhdXRvciBkZWwgY29tbWl0IHNveSB5byBhaG9yYSAodXNhZG8gY29uIC1DLy1jLy0tYW1lbmQpIgogCi0jOiBidWlsdGluL2NvbW1pdC5jOjE1MDYgYnVpbHRpbi9sb2cuYzoxNTY0IGJ1aWx0aW4vbWVyZ2UuYzoyODkKLSM6IGJ1aWx0aW4vcHVsbC5jOjE2MyBidWlsdGluL3JldmVydC5jOjExMAorIzogYnVpbHRpbi9jb21taXQuYzoxNTA2IGJ1aWx0aW4vbG9nLmM6MTU2NSBidWlsdGluL21lcmdlLmM6Mjg5CisjOiBidWlsdGluL3B1bGwuYzoxNjQgYnVpbHRpbi9yZXZlcnQuYzoxMTAKIG1zZ2lkICJhZGQgU2lnbmVkLW9mZi1ieToiCiBtc2dzdHIgImFncmVnYXIgU2lnbmVkLW9mZi1ieTogKGZpcm1hZG8gcG9yKSIKIApAQCAtMTE4OTUsNjYgKzExOTI3LDY5IEBACiBtc2dzdHIgImdpdCBjb21taXQtZ3JhcGggcmVhZCBbLS1vYmplY3QtZGlyIDxvYmpkaXI+XSIKIAogIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxMyBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE5Ci1tc2dpZCAiZ2l0IGNvbW1pdC1ncmFwaCB2ZXJpZnkgWy0tb2JqZWN0LWRpciA8b2JqZGlyPl0gWy0tc2hhbGxvd10iCi1tc2dzdHIgImdpdCBjb21taXQtZ3JhcGggdmVyaWZ5IFstLW9iamVjdC1kaXIgPG9iamRpcj5dIFstLXNoYWxsb3ddIgorbXNnaWQgIiIKKyJnaXQgY29tbWl0LWdyYXBoIHZlcmlmeSBbLS1vYmplY3QtZGlyIDxvYmpkaXI+XSBbLS1zaGFsbG93XSBbLS1bbm8tXXByb2dyZXNzXSIKK21zZ3N0ciAiIgorImdpdCBjb21taXQtZ3JhcGggdmVyaWZ5IFstLW9iamVjdC1kaXIgPG9iamRpcj5dIFstLXNoYWxsb3ddIFstLVtuby1dcHJvZ3Jlc3NdIgogCiAjOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE0IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MjkKIG1zZ2lkICIiCiAiZ2l0IGNvbW1pdC1ncmFwaCB3cml0ZSBbLS1vYmplY3QtZGlyIDxvYmpkaXI+XSBbLS1hcHBlbmR8LS1zcGxpdF0gWy0tIgotInJlYWNoYWJsZXwtLXN0ZGluLXBhY2tzfC0tc3RkaW4tY29tbWl0c10gPHNwbGl0IG9wdGlvbnM+IgorInJlYWNoYWJsZXwtLXN0ZGluLXBhY2tzfC0tc3RkaW4tY29tbWl0c10gWy0tW25vLV1wcm9ncmVzc10gPHNwbGl0IG9wdGlvbnM+IgogbXNnc3RyICIiCi0iZ2l0IGNvbW1pdC1ncmFwaCB3cml0ZSBbLS1vYmplY3QtZGlyIDxvYmpkaXI+XSBbLS1hcHBlbmR8LS1zcGxpdF0gWy0tIgotInJlYWNoYWJsZXwtLXN0ZGluLXBhY2tzfC0tc3RkaW4tY29tbWl0c10gPHNwbGl0IG9wdGlvbnM+IgorImdpdCBjb21taXQtZ3JhcGggd3JpdGUgWy0tb2JqZWN0LWRpciA8ZGlyIG9iamV0bz5dIFstLWFwcGVuZHwtLXNwbGl0XSBbLS0iCisicmVhY2hhYmxlfC0tc3RkaW4tcGFja3N8LS1zdGRpbi1jb21taXRzXSBbLS1bbm8tXXByb2dyZXNzXSA8b3BjaW9uZXMgZGUgIgorInNwbGl0PiIKIAotIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzo1NCBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjEwMAotIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxNjEgYnVpbHRpbi9jb21taXQtZ3JhcGguYzoyMzcgYnVpbHRpbi9mZXRjaC5jOjE2MwotIzogYnVpbHRpbi9sb2cuYzoxNTg0CisjOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjU1IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTA3CisjOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE3MCBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjI1NCBidWlsdGluL2ZldGNoLmM6MTc4CisjOiBidWlsdGluL2xvZy5jOjE1ODUKIG1zZ2lkICJkaXIiCiBtc2dzdHIgImRpciIKIAotIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzo1NSBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjEwMQotIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxNjIgYnVpbHRpbi9jb21taXQtZ3JhcGguYzoyMzgKKyM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6NTYgYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxMDgKKyM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTcxIGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MjU1CiBtc2dpZCAiVGhlIG9iamVjdCBkaXJlY3RvcnkgdG8gc3RvcmUgdGhlIGdyYXBoIgogbXNnc3RyICJFbCBkaXJlY3RvcmlvIGRlIG9iamV0b3MgcGFyYSBndWFyZGFyIGVsIGdyw6FmaWNvIgogCi0jOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjU3CisjOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjU4CiBtc2dpZCAiaWYgdGhlIGNvbW1pdC1ncmFwaCBpcyBzcGxpdCwgb25seSB2ZXJpZnkgdGhlIHRpcCBmaWxlIgogbXNnc3RyICJzaSBlbCBjb21taXQtZ3JhcGggZXN0w6EgY29ydGFkbywgc29sbyB2ZXJpZmljYSBsYSBwdW50YSBkZWwgYXJjaGl2byIKIAotIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzo3MyBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjExNgorIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzo4MCBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjEyNQogIywgYy1mb3JtYXQKIG1zZ2lkICJDb3VsZCBub3Qgb3BlbiBjb21taXQtZ3JhcGggJyVzJyIKIG1zZ3N0ciAiTm8gc2UgcHVkbyBhYnJpciBjb21taXQtZ3JhcGggJyVzJyIKIAotIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxNjQKKyM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTczCiBtc2dpZCAic3RhcnQgd2FsayBhdCBhbGwgcmVmcyIKIG1zZ3N0ciAiY29tZW56YXIgY2FtaW5hdGEgZW4gdG9kYXMgbGFzIHJlZnMiCiAKLSM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTY2CisjOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE3NQogbXNnaWQgInNjYW4gcGFjay1pbmRleGVzIGxpc3RlZCBieSBzdGRpbiBmb3IgY29tbWl0cyIKIG1zZ3N0ciAiZXNjYW5lYXIgcGFxdWV0ZSBkZSDDrW5kaWNlcyBwb3Igc3RkaW4gcG9yIGNvbW1pdHMiCiAKLSM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTY4CisjOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE3NwogbXNnaWQgInN0YXJ0IHdhbGsgYXQgY29tbWl0cyBsaXN0ZWQgYnkgc3RkaW4iCiBtc2dzdHIgImNvbWVuemFyIGEgY2FtaW5hciBhIGxvcyBjb21taXRzIGxpc3RhZG9zIHBvciBzdGRpbiIKIAotIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxNzAKKyM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTc5CiBtc2dpZCAiaW5jbHVkZSBhbGwgY29tbWl0cyBhbHJlYWR5IGluIHRoZSBjb21taXQtZ3JhcGggZmlsZSIKIG1zZ3N0ciAiaW5jbHllIHRvZG9zIGxvcyBjb21taXRzIHF1ZSB5YSBlc3TDoW4gZW4gZWwgYXJjaGl2byBjb21taXQtZ3JhcGgiCiAKLSM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTcyCisjOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE4MgogbXNnaWQgImFsbG93IHdyaXRpbmcgYW4gaW5jcmVtZW50YWwgY29tbWl0LWdyYXBoIGZpbGUiCiBtc2dzdHIgInBlcm1pdGlyIGVzY3JpYmlyIHVuIGFyY2hpdm8gY29tbWl0LWdyYXBoIGluY3JlbWVudGFsIgogCi0jOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE3NCBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE3OAorIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxODQgYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxODgKIG1zZ2lkICJtYXhpbXVtIG51bWJlciBvZiBjb21taXRzIGluIGEgbm9uLWJhc2Ugc3BsaXQgY29tbWl0LWdyYXBoIgogbXNnc3RyICJtw6F4aW1vIG7Dum1lcm8gZGUgY29tbWl0cyBlbiB1biBjb21taXQtZ3JhcGggc2luIGJhc2UgY29ydGFkYSIKIAotIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxNzYKKyM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTg2CiBtc2dpZCAibWF4aW11bSByYXRpbyBiZXR3ZWVuIHR3byBsZXZlbHMgb2YgYSBzcGxpdCBjb21taXQtZ3JhcGgiCiBtc2dzdHIgInJhZGlvIG3DoXhpbW8gZW50cmUgZG9zIG5pdmVsZXMgZGUgY29ydGUgZGUgY29tbWl0LWdyYXBoIgogCi0jOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE5MQorIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoyMDQKIG1zZ2lkICJ1c2UgYXQgbW9zdCBvbmUgb2YgLS1yZWFjaGFibGUsIC0tc3RkaW4tY29tbWl0cywgb3IgLS1zdGRpbi1wYWNrcyIKIG1zZ3N0ciAidXNlIGNvbW8gbcOheGltbyB1bm8gZGUgLS1yZWFjaGFibGUsIC0tc3RkaW4tY29tbWl0cywgbyAtLXN0ZGluLXBhY2tzIgogCkBAIC0xMjI3MSw1NyArMTIzMDYsNTcgQEAKIG1zZ2lkICJwcmludCBzaXplcyBpbiBodW1hbiByZWFkYWJsZSBmb3JtYXQiCiBtc2dzdHIgIm1vc3RyYXIgdGFtYcOxb3MgZW4gZm9ybWF0byBsZWdpYmxlIHBhcmEgaHVtYW5vIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6MjcKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzoyNgogbXNnaWQgImdpdCBkZXNjcmliZSBbPG9wdGlvbnM+XSBbPGNvbW1pdC1pc2g+Li4uXSIKIG1zZ3N0ciAiZ2l0IGRlc2NyaWJlIFs8b3BjaW9uZXM+XSBbPGNvbW1pdC1pc2g+Li4uXSIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjI4CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6MjcKIG1zZ2lkICJnaXQgZGVzY3JpYmUgWzxvcHRpb25zPl0gLS1kaXJ0eSIKIG1zZ3N0ciAiZ2l0IGRlc2NyaWJlIFs8b3BjaW9uZXM+XSAtLWRpcnR5IgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NjMKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo2MgogbXNnaWQgImhlYWQiCiBtc2dzdHIgImhlYWQiCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo2MworIzogYnVpbHRpbi9kZXNjcmliZS5jOjYyCiBtc2dpZCAibGlnaHR3ZWlnaHQiCiBtc2dzdHIgImxpZ2VybyIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjYzCisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NjIKIG1zZ2lkICJhbm5vdGF0ZWQiCiBtc2dzdHIgImFub3RhZG8iCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzoyNzMKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzoyNzUKICMsIGMtZm9ybWF0CiBtc2dpZCAiYW5ub3RhdGVkIHRhZyAlcyBub3QgYXZhaWxhYmxlIgogbXNnc3RyICJ0YWcgYW5vdGFkbyAlcyBubyBkaXNwb25pYmxlIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6Mjc3CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6Mjc5CiAjLCBjLWZvcm1hdAogbXNnaWQgImFubm90YXRlZCB0YWcgJXMgaGFzIG5vIGVtYmVkZGVkIG5hbWUiCiBtc2dzdHIgInRhZyBhbm90YWRvICVzIG5vIHRpZW5lIG5vbWJyZSBlbWJlYmlkbyIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjI3OQorIzogYnVpbHRpbi9kZXNjcmliZS5jOjI4MQogIywgYy1mb3JtYXQKIG1zZ2lkICJ0YWcgJyVzJyBpcyByZWFsbHkgJyVzJyBoZXJlIgogbXNnc3RyICJ0YWcgJyVzJyBlcyByZWFsbWVudGUgJyVzJyBhcXXDrSIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjMyMworIzogYnVpbHRpbi9kZXNjcmliZS5jOjMyNQogIywgYy1mb3JtYXQKIG1zZ2lkICJubyB0YWcgZXhhY3RseSBtYXRjaGVzICclcyciCiBtc2dzdHIgIm5vIGhheSB0YWcgcXVlIGNvbmN1ZXJkZSBleGFjdGFtZW50ZSBjb24gJyVzJyIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjMyNQorIzogYnVpbHRpbi9kZXNjcmliZS5jOjMyNwogIywgYy1mb3JtYXQKIG1zZ2lkICJObyBleGFjdCBtYXRjaCBvbiByZWZzIG9yIHRhZ3MsIHNlYXJjaGluZyB0byBkZXNjcmliZVxuIgogbXNnc3RyICJObyBoYXkgY29pbmNpZGVuY2lhIGV4YWN0YSBlbiByZWZzIG8gdGFncywgYnVzY2FuZG8gZW4gZGVzY3JpYmVcbiIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjM3OQorIzogYnVpbHRpbi9kZXNjcmliZS5jOjM4MQogIywgYy1mb3JtYXQKIG1zZ2lkICJmaW5pc2hlZCBzZWFyY2ggYXQgJXNcbiIKIG1zZ3N0ciAiYsO6c3F1ZWRhIGZpbmFsaXphZGEgYSBsYXMgJXNcbiIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjQwNQorIzogYnVpbHRpbi9kZXNjcmliZS5jOjQwNwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiTm8gYW5ub3RhdGVkIHRhZ3MgY2FuIGRlc2NyaWJlICclcycuXG4iCkBAIC0xMjMzMCw3ICsxMjM2NSw3IEBACiAiTm8gaGF5IHRhZ3MgYW5vdGFkb3MgcXVlIHB1ZWRhbiBkZXNjcmliaXIgJyVzJy5cbiIKICJTaW4gZW1iYXJnbywgaHViaWVyb24gdGFncyBubyBhbm90YWRvczogaW50ZW50ZSAtLXRhZ3MuIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NDA5CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NDExCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJObyB0YWdzIGNhbiBkZXNjcmliZSAnJXMnLlxuIgpAQCAtMTIzMzksMTIgKzEyMzc0LDEyIEBACiAiTmluZ8O6biB0YWcgcHVlZGUgZGVzY3JpYml0ICclcycuXG4iCiAiSW50ZW50ZSAtLWFsd2F5cywgbyBjcmVlIGFsZ3Vub3MgdGFncy4iCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo0MzkKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo0NDEKICMsIGMtZm9ybWF0CiBtc2dpZCAidHJhdmVyc2VkICVsdSBjb21taXRzXG4iCiBtc2dzdHIgIiVsdSBjb21taXRzIGNydXphZG9zXG4iCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo0NDIKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo0NDQKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIm1vcmUgdGhhbiAlaSB0YWdzIGZvdW5kOyBsaXN0ZWQgJWkgbW9zdCByZWNlbnRcbiIKQEAgLTEyMzUzLDkwICsxMjM4OCw5MCBAQAogInNlIGVuY29udHLDsyBtw6FzIGRlICVpIHRhZ3M7IHNlIG1vc3Ryw7MgJWkgbcOhcyByZWNpZW50ZVxuIgogImZpbiBkZSBsYSBiw7pzcXVlZGEgZW4gJXNcbiIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjUxMAorIzogYnVpbHRpbi9kZXNjcmliZS5jOjUxMgogIywgYy1mb3JtYXQKIG1zZ2lkICJkZXNjcmliZSAlc1xuIgogbXNnc3RyICJkZXNjcmliZSAlc1xuIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NTEzCisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NTE1CiAjLCBjLWZvcm1hdAogbXNnaWQgIk5vdCBhIHZhbGlkIG9iamVjdCBuYW1lICVzIgogbXNnc3RyICJOb21icmUgZGUgb2JqZXRvICVzIG5vIHbDoWxpZG8iCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1MjEKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1MjMKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgaXMgbmVpdGhlciBhIGNvbW1pdCBub3IgYmxvYiIKIG1zZ3N0ciAiJXMgbm8gZXMgdW4gY29tbWl0IG5pIHVuIGJsb2IiCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1MzUKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1MzcKIG1zZ2lkICJmaW5kIHRoZSB0YWcgdGhhdCBjb21lcyBhZnRlciB0aGUgY29tbWl0IgogbXNnc3RyICJlbmNvbnRyYXIgZWwgdGFnIHF1ZSB2aWVuZSBkZXNwdcOpcyBkZWwgY29tbWl0IgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NTM2CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NTM4CiBtc2dpZCAiZGVidWcgc2VhcmNoIHN0cmF0ZWd5IG9uIHN0ZGVyciIKIG1zZ3N0ciAiaGFjZXIgZGVidWcgYSBsYSBlc3RyYXRlZ2lhIGRlIGLDunNxdWVkYSBlbiBzdGRlcnIiCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1MzcKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1MzkKIG1zZ2lkICJ1c2UgYW55IHJlZiIKIG1zZ3N0ciAidXNlIGN1YWxxdWllciByZWYiCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1MzgKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1NDAKIG1zZ2lkICJ1c2UgYW55IHRhZywgZXZlbiB1bmFubm90YXRlZCIKIG1zZ3N0ciAidXNlIGN1YWxxdWllciB0YWcsIGluY2x1c28gbG9zIG5vIGFub3RhZG9zIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NTM5CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NTQxCiBtc2dpZCAiYWx3YXlzIHVzZSBsb25nIGZvcm1hdCIKIG1zZ3N0ciAic2llbXByZSB1c2FyIGZvcm1hdG8gbGFyZ28iCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1NDAKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1NDIKIG1zZ2lkICJvbmx5IGZvbGxvdyBmaXJzdCBwYXJlbnQiCiBtc2dzdHIgInNvbG8gc2VndWlyIGVsIHByaW1lciBwYXRyw7NuIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NTQzCisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NTQ1CiBtc2dpZCAib25seSBvdXRwdXQgZXhhY3QgbWF0Y2hlcyIKIG1zZ3N0ciAic29sbyBtb3N0cmFyIGNvbmNvcmRhbmNpYXMgZXhhY3RhcyIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjU0NQorIzogYnVpbHRpbi9kZXNjcmliZS5jOjU0NwogbXNnaWQgImNvbnNpZGVyIDxuPiBtb3N0IHJlY2VudCB0YWdzIChkZWZhdWx0OiAxMCkiCiBtc2dzdHIgImNvbnNpZGVyYXIgPG4+IHRhZ3MgbcOhcyByZWNpZW50ZXMgKGRlZmF1bHQ6MTApIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NTQ3CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NTQ5CiBtc2dpZCAib25seSBjb25zaWRlciB0YWdzIG1hdGNoaW5nIDxwYXR0ZXJuPiIKIG1zZ3N0ciAic29sbyBjb25zaWRlcmFyIHRhZ3MgcXVlIGNvbmN1ZXJkZW4gY29uIDxwYXRyw7NuPiIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjU0OQorIzogYnVpbHRpbi9kZXNjcmliZS5jOjU1MQogbXNnaWQgImRvIG5vdCBjb25zaWRlciB0YWdzIG1hdGNoaW5nIDxwYXR0ZXJuPiIKIG1zZ3N0ciAibm8gY29uc2lkZXJhciB0YWdzIHF1ZSBjb25jdWVyZGVuIGNvbiA8cGF0csOzbj4iCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1NTEgYnVpbHRpbi9uYW1lLXJldi5jOjQyMgorIzogYnVpbHRpbi9kZXNjcmliZS5jOjU1MyBidWlsdGluL25hbWUtcmV2LmM6NDI2CiBtc2dpZCAic2hvdyBhYmJyZXZpYXRlZCBjb21taXQgb2JqZWN0IGFzIGZhbGxiYWNrIgogbXNnc3RyICJtb3N0cmFyIGVsIG9iamV0byBjb21taXQgYWJyZXZpYWRvIGNvbW8gZmFsbGJhY2siCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1NTIgYnVpbHRpbi9kZXNjcmliZS5jOjU1NQorIzogYnVpbHRpbi9kZXNjcmliZS5jOjU1NCBidWlsdGluL2Rlc2NyaWJlLmM6NTU3CiBtc2dpZCAibWFyayIKIG1zZ3N0ciAibWFyY2EiCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1NTMKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1NTUKIG1zZ2lkICJhcHBlbmQgPG1hcms+IG9uIGRpcnR5IHdvcmtpbmcgdHJlZSAoZGVmYXVsdDogXCItZGlydHlcIikiCiBtc2dzdHIgImFkanVudGFyIDxtYXJjYT4gZW4gZWwgw6FyYm9sIGRlIHRyYWJham8gc3VjaW8gKGRlZmF1bHQ6IFwiLWRpcnR5XCIpIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NTU2CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NTU4CiBtc2dpZCAiYXBwZW5kIDxtYXJrPiBvbiBicm9rZW4gd29ya2luZyB0cmVlIChkZWZhdWx0OiBcIi1icm9rZW5cIikiCiBtc2dzdHIgImFkanVudGFyIDxtYXJjYT4gZW4gdW4gw6FyYm9sIGRlIHRyYWJham8gcm90byAoZGVmYXVsdDogXCItYnJva2VuXCIpIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NTc0CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NTc2CiBtc2dpZCAiLS1sb25nIGlzIGluY29tcGF0aWJsZSB3aXRoIC0tYWJicmV2PTAiCiBtc2dzdHIgIi0tbG9uZyBlcyBpbmNvbXBhdGlibGUgY29uIC0tYWJicmV2PTAiCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo2MDMKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo2MDUKIG1zZ2lkICJObyBuYW1lcyBmb3VuZCwgY2Fubm90IGRlc2NyaWJlIGFueXRoaW5nLiIKIG1zZ3N0ciAiTm8gc2UgZW5jb250cmFyb24gbm9tYnJlcywgbm8gc2UgcHVlZGUgZGVzY3JpYmlyIG5hZGEuIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NjU0CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NjU2CiBtc2dpZCAiLS1kaXJ0eSBpcyBpbmNvbXBhdGlibGUgd2l0aCBjb21taXQtaXNoZXMiCiBtc2dzdHIgIi0tZGlydHkgZXMgaW5jb21wYXRpYmxlIGNvbiBjb21taXQtaXNtb3MiCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo2NTYKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo2NTgKIG1zZ2lkICItLWJyb2tlbiBpcyBpbmNvbXBhdGlibGUgd2l0aCBjb21taXQtaXNoZXMiCiBtc2dzdHIgIi0tYnJva2VuIGVzIGluY29tcGF0aWJsZSBjb24gY29tbWl0LWlzbW9zIgogCkBAIC0xMjQ3MywyNyArMTI1MDgsMjcgQEAKIG1zZ2lkICJnaXQgZGlmZnRvb2wgWzxvcHRpb25zPl0gWzxjb21taXQ+IFs8Y29tbWl0Pl1dIFstLV0gWzxwYXRoPi4uLl0iCiBtc2dzdHIgImdpdCBkaWZmdG9vbCBbPG9wY2lvbmVzPl0gWzxjb21taXQ+IFs8Y29tbWl0Pl1dIFstLV0gWzxydXRhPi4uLl0iCiAKLSM6IGJ1aWx0aW4vZGlmZnRvb2wuYzoyNTMKKyM6IGJ1aWx0aW4vZGlmZnRvb2wuYzoyNjAKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkOiAlZCIKIG1zZ3N0ciAiZmFsbMOzOiAlZCIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjI5NQorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjMwMgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcmVhZCBzeW1saW5rICVzIgogbXNnc3RyICJubyBzZSBwdWRvIGxlZXIgZWwgc3ltbGluayAlcyIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjI5NworIzogYnVpbHRpbi9kaWZmdG9vbC5jOjMwNAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcmVhZCBzeW1saW5rIGZpbGUgJXMiCiBtc2dzdHIgIm5vIHNlIHB1ZG8gbGVlciBlbCBhcmNoaXZvIHN5bWxpbmsgJXMiCiAKLSM6IGJ1aWx0aW4vZGlmZnRvb2wuYzozMDUKKyM6IGJ1aWx0aW4vZGlmZnRvb2wuYzozMTIKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHJlYWQgb2JqZWN0ICVzIGZvciBzeW1saW5rICVzIgogbXNnc3RyICJubyBzZSBwdWRvIGxlZXIgZWwgb2JqZXRvICVzIHBhcmEgZWwgc3ltbGluayAlcyIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjQwNgorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjQxMwogbXNnaWQgIiIKICJjb21iaW5lZCBkaWZmIGZvcm1hdHMoJy1jJyBhbmQgJy0tY2MnKSBhcmUgbm90IHN1cHBvcnRlZCBpblxuIgogImRpcmVjdG9yeSBkaWZmIG1vZGUoJy1kJyBhbmQgJy0tZGlyLWRpZmYnKS4iCkBAIC0xMjUwMSw1NCArMTI1MzYsNTQgQEAKICJmb3JtYXRvcyBjb21iaW5hZG9zIGRlIGRpZmYgKCctYycgeSAnLS1jYycpIG5vIHNvcG9ydGFkb3MgZW5cbiIKICJtb2RvIGRpZmYgcGFyYSBkaXJlY3RvcmlvKCctZCcgeSAnLS1kaXItZGlmZicpLiIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjYyNgorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjYzNAogIywgYy1mb3JtYXQKIG1zZ2lkICJib3RoIGZpbGVzIG1vZGlmaWVkOiAnJXMnIGFuZCAnJXMnLiIKIG1zZ3N0ciAiYW1ib3MgYXJjaGl2b3MgbW9kaWZpY2Fkb3M6ICclcycgeSAnJXMnLiIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjYyOAorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjYzNgogbXNnaWQgIndvcmtpbmcgdHJlZSBmaWxlIGhhcyBiZWVuIGxlZnQuIgogbXNnc3RyICJhcmNoaXZvIGRlbCDDoXJib2wgZGUgdHJhYmFqbyBoYSBzaWRvIGRlamFkby4iCiAKLSM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo2MzkKKyM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo2NDcKICMsIGMtZm9ybWF0CiBtc2dpZCAidGVtcG9yYXJ5IGZpbGVzIGV4aXN0IGluICclcycuIgogbXNnc3RyICJhcmNoaXZvIHRlbXBvcmFsIGV4aXN0ZSBlbiAnJXMnLiIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjY0MAorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjY0OAogbXNnaWQgInlvdSBtYXkgd2FudCB0byBjbGVhbnVwIG9yIHJlY292ZXIgdGhlc2UuIgogbXNnc3RyICJ0YWwgdmV6IGRlc2VlcyBsaW1waWFyIG8gcmVjdXBlcmFyIGVzdG9zLiIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjY4OQorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjY5NwogbXNnaWQgInVzZSBgZGlmZi5ndWl0b29sYCBpbnN0ZWFkIG9mIGBkaWZmLnRvb2xgIgogbXNnc3RyICJ1c2UgYGRpZmYuZ3VpdG9vbGAgZW4gbHVnYXIgZGUgYGRpZmYudG9vbGAiCiAKLSM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo2OTEKKyM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo2OTkKIG1zZ2lkICJwZXJmb3JtIGEgZnVsbC1kaXJlY3RvcnkgZGlmZiIKIG1zZ3N0ciAicmVhbGl6YXIgdW4gZGlmZiBkZSB0b2RvIGVsIGRpcmVjdG9yaW8iCiAKLSM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo2OTMKKyM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo3MDEKIG1zZ2lkICJkbyBub3QgcHJvbXB0IGJlZm9yZSBsYXVuY2hpbmcgYSBkaWZmIHRvb2wiCiBtc2dzdHIgIm5vIG1vc3RyYXIgYW50ZXMgZGUgbGFuemFyIHVuYSBoZXJyYW1pZW50YSBkZSBkaWZmIgogCi0jOiBidWlsdGluL2RpZmZ0b29sLmM6Njk4CisjOiBidWlsdGluL2RpZmZ0b29sLmM6NzA2CiBtc2dpZCAidXNlIHN5bWxpbmtzIGluIGRpci1kaWZmIG1vZGUiCiBtc2dzdHIgInVzYXIgZW5sYWNlcyBzaW1iw7NsaWNvcyBlbiBtb2RvIGRpci1kaWZmIgogCi0jOiBidWlsdGluL2RpZmZ0b29sLmM6Njk5CisjOiBidWlsdGluL2RpZmZ0b29sLmM6NzA3CiBtc2dpZCAidG9vbCIKIG1zZ3N0ciAiaGVycmFtaWVudGEiCiAKLSM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo3MDAKKyM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo3MDgKIG1zZ2lkICJ1c2UgdGhlIHNwZWNpZmllZCBkaWZmIHRvb2wiCiBtc2dzdHIgInVzYXIgbGEgaGVycmFtaWVudGEgZGUgZGlmZiBlc3BlY2lmaWNhZGEiCiAKLSM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo3MDIKKyM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo3MTAKIG1zZ2lkICJwcmludCBhIGxpc3Qgb2YgZGlmZiB0b29scyB0aGF0IG1heSBiZSB1c2VkIHdpdGggYC0tdG9vbGAiCiBtc2dzdHIgIiIKICJtb3N0cmFyIHVuYSBsaXN0YSBkZSBoZXJyYW1pZW50YXMgZGUgZGlmZiBxdWUgcHVlZGVuIHNlciB1c2FkYXMgY29uIGAtLXRvb2xgIgogCi0jOiBidWlsdGluL2RpZmZ0b29sLmM6NzA1CisjOiBidWlsdGluL2RpZmZ0b29sLmM6NzEzCiBtc2dpZCAiIgogIm1ha2UgJ2dpdC1kaWZmdG9vbCcgZXhpdCB3aGVuIGFuIGludm9rZWQgZGlmZiB0b29sIHJldHVybnMgYSBub24gLSB6ZXJvIGV4aXQgIgogImNvZGUiCkBAIC0xMjU1NiwzMSArMTI1OTEsMzEgQEAKICJoYWNlciBxdWUgJ2dpdC1kaWZmdG9vbCcgc2FsZ2EgY3VhbmRvIHVuYSBoZXJyYW1pZW50YSBkZSBkaWZmIHJldG9ybmUgdW4gIgogImPDs2RpZ28gZGUgc2FsaWRhIGRpc3RpbnRvIGRlIGNlcm8iCiAKLSM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo3MDgKKyM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo3MTYKIG1zZ2lkICJzcGVjaWZ5IGEgY3VzdG9tIGNvbW1hbmQgZm9yIHZpZXdpbmcgZGlmZnMiCiBtc2dzdHIgImVzcGVjaWZpY2FyIHVuIGNvbWFuZG8gcGVyc29uYWxpemFkbyBwYXJhIHZlciBkaWZmcyIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjcwOQorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjcxNwogbXNnaWQgInBhc3NlZCB0byBgZGlmZmAiCiBtc2dzdHIgInBhc2FkbyBhIGBkaWZmYCIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjcyNAorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjczMgogbXNnaWQgImRpZmZ0b29sIHJlcXVpcmVzIHdvcmt0cmVlIG9yIC0tbm8taW5kZXgiCiBtc2dzdHIgImRpZmZ0b29sIHJlcXVpZXJlIHVuIMOhcmJvbCBkZSB0cmFiYWpvIG8gLS1uby1pbmRleCIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjczMQorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjczOQogbXNnaWQgIi0tZGlyLWRpZmYgaXMgaW5jb21wYXRpYmxlIHdpdGggLS1uby1pbmRleCIKIG1zZ3N0ciAiLS1kaXJ0eS1kaWZmIGVzIGluY29tcGF0aWJsZSBjb24gLS1uby1pbmRleCIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjczNAorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjc0MgogbXNnaWQgIi0tZ3VpLCAtLXRvb2wgYW5kIC0tZXh0Y21kIGFyZSBtdXR1YWxseSBleGNsdXNpdmUiCiBtc2dzdHIgIi0tZ3VpLCAtLXRvb2wgeSAtLWV4dGNtZCBzb24gbXV0dWFtZW50ZSBleGNsdXNpdmFzIgogCi0jOiBidWlsdGluL2RpZmZ0b29sLmM6NzQyCisjOiBidWlsdGluL2RpZmZ0b29sLmM6NzUwCiBtc2dpZCAibm8gPHRvb2w+IGdpdmVuIGZvciAtLXRvb2w9PHRvb2w+IgogbXNnc3RyICJubyBzZSBoYSBwcm9wb3JjaW9uYWRvIDxoZXJyYW1pZW50YT4gcGFyYSAtLXRvb2w9PGhlcnJhbWllbnRhPiIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjc0OQorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjc1NwogbXNnaWQgIm5vIDxjbWQ+IGdpdmVuIGZvciAtLWV4dGNtZD08Y21kPiIKIG1zZ3N0ciAibm8gc2UgaGEgZW50cmVnYWRvIDxjb21hbmRvPiBwYXJhIC0tZXh0Y21kPTxjb21hbmRvPiIKIApAQCAtMTI2MTcsMTU4ICsxMjY1MiwxODQgQEAKIG1zZ2lkICJnaXQgZmFzdC1leHBvcnQgW3Jldi1saXN0LW9wdHNdIgogbXNnc3RyICJnaXQgZmFzdC1leHBvcnQgW3Jldi1saXN0LW9wdHNdIgogCi0jOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTEyNAorIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjg1MgorbXNnaWQgIkVycm9yOiBDYW5ub3QgZXhwb3J0IG5lc3RlZCB0YWdzIHVubGVzcyAtLW1hcmstdGFncyBpcyBzcGVjaWZpZWQuIgorbXNnc3RyICIiCisiRXJyb3I6IE5vIHNlIHB1ZWRlIGV4cG9ydGFyIGxvcyB0YWdzIGFuaWRhZG9zIGEgbWVub3MgcXVlIC0tbWFyay10YWdzIHNlYSAiCisiZXNwZWNpZmljYWRvLiIKKworIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNTIKIG1zZ2lkICJzaG93IHByb2dyZXNzIGFmdGVyIDxuPiBvYmplY3RzIgogbXNnc3RyICJtb3N0cmFyIHByb2dyZXNvIGRlc3B1w6lzIGRlIDxuPiBvYmpldG9zIgogCi0jOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTEyNgorIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNTQKIG1zZ2lkICJzZWxlY3QgaGFuZGxpbmcgb2Ygc2lnbmVkIHRhZ3MiCiBtc2dzdHIgInNlbGVjY2lvbmFyIGVsIG1hbmVqbyBkZSB0YWdzIGZpcm1hZG9zIgogCi0jOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTEyOQorIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNTcKIG1zZ2lkICJzZWxlY3QgaGFuZGxpbmcgb2YgdGFncyB0aGF0IHRhZyBmaWx0ZXJlZCBvYmplY3RzIgogbXNnc3RyICJzZWxlY2Npb25hciBlbCBtYW5lam8gZGUgdGFncyBxdWUgc29uIHRhZ3MgZGUgb2JqZXRvcyBmaWx0cmFkb3MiCiAKLSM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTMyCisjOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE2MAogbXNnaWQgInNlbGVjdCBoYW5kbGluZyBvZiBjb21taXQgbWVzc2FnZXMgaW4gYW4gYWx0ZXJuYXRlIGVuY29kaW5nIgogbXNnc3RyICJzZWxlY2Npb25hciBlbCBtYW5lam8gZGUgbWVuc2FqZXMgZGUgY29tbWl0IGVuIHVuIGVuY29kaW5nIGRpZmVyZW50ZSIKIAotIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExMzUKKyM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTYzCiBtc2dpZCAiRHVtcCBtYXJrcyB0byB0aGlzIGZpbGUiCiBtc2dzdHIgIlZvbGNhciBtYXJjYXMgYSBlc3RlIGFyY2hpdm8iCiAKLSM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTM3CisjOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE2NQogbXNnaWQgIkltcG9ydCBtYXJrcyBmcm9tIHRoaXMgZmlsZSIKIG1zZ3N0ciAiSW1wb3J0YXIgbWFyY2FzIGRlIGVzdGUgYXJjaGl2byIKIAotIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExMzkKKyM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTY5Cittc2dpZCAiSW1wb3J0IG1hcmtzIGZyb20gdGhpcyBmaWxlIGlmIGl0IGV4aXN0cyIKK21zZ3N0ciAiSW1wb3J0YXIgbWFyY2FzIGRlIGVzdGUgYXJjaGl2byBzaSBleGlzdGUiCisKKyM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTcxCiBtc2dpZCAiRmFrZSBhIHRhZ2dlciB3aGVuIHRhZ3MgbGFjayBvbmUiCiBtc2dzdHIgIkZhbHNpZmljYXIgdW4gdGFnZ2VyIGN1YW5kbyBsZXMgZmFsdGEgdW5vIgogCi0jOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE0MQorIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNzMKIG1zZ2lkICJPdXRwdXQgZnVsbCB0cmVlIGZvciBlYWNoIGNvbW1pdCIKIG1zZ3N0ciAiTW9zdHJhciB0b2RvIGVsIMOhcmJvbCBwYXJhIGNhZGEgY29tbWl0IgogCi0jOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE0MworIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNzUKIG1zZ2lkICJVc2UgdGhlIGRvbmUgZmVhdHVyZSB0byB0ZXJtaW5hdGUgdGhlIHN0cmVhbSIKIG1zZ3N0ciAiVXNlIGVsIGZlYXR1cmUgZG9uZSBwYXJhIHRlcm1pbmFyIGVsIHN0cmVhbSIKIAotIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNDQKKyM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTc2CiBtc2dpZCAiU2tpcCBvdXRwdXQgb2YgYmxvYiBkYXRhIgogbXNnc3RyICJTYWx0YXIgZWwgb3V0cHV0IGRlIGRhdGEgYmxvYiIKIAotIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNDUgYnVpbHRpbi9sb2cuYzoxNjMyCisjOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE3NyBidWlsdGluL2xvZy5jOjE2MzMKIG1zZ2lkICJyZWZzcGVjIgogbXNnc3RyICJyZWZzcGVjIgogCi0jOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE0NgorIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNzgKIG1zZ2lkICJBcHBseSByZWZzcGVjIHRvIGV4cG9ydGVkIHJlZnMiCiBtc2dzdHIgIkFwbGljYXIgcmVmc3BlYyBwYXJhIGxvcyByZWZzIGV4cG9ydGFkb3MiCiAKLSM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTQ3CisjOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE3OQogbXNnaWQgImFub255bWl6ZSBvdXRwdXQiCiBtc2dzdHIgImFub25pbWl6YXIgbGEgc2FsaWRhIgogCi0jOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE0OQorIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExODEKIG1zZ2lkICJSZWZlcmVuY2UgcGFyZW50cyB3aGljaCBhcmUgbm90IGluIGZhc3QtZXhwb3J0IHN0cmVhbSBieSBvYmplY3QgaWQiCiBtc2dzdHIgIiIKICJQYWRyZXMgZGUgbGEgcmVmZXJlbmNpYSBxdWUgbm8gZXN0YW4gZW4gZmFzdC1leHBvcnQgc3RyZWFtIHBvciBpZCBkZSBvYmpldG8iCiAKLSM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTUxCisjOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE4MwogbXNnaWQgIlNob3cgb3JpZ2luYWwgb2JqZWN0IGlkcyBvZiBibG9icy9jb21taXRzIgogbXNnc3RyICJNb3N0cmFyIGlkcyBkZSBvYmpldG9zIG9yaWdpbmFsZXMgcGFyYSBibG9icy9jb21taXRzIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MzAKKyM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTg1Cittc2dpZCAiTGFiZWwgdGFncyB3aXRoIG1hcmsgaWRzIgorbXNnc3RyICJNYXJjYXIgdGFncyBjb24gaWRzIGRlIG1hcmsiCisKKyM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMjIwCittc2dpZCAiQ2Fubm90IHBhc3MgYm90aCAtLWltcG9ydC1tYXJrcyBhbmQgLS1pbXBvcnQtbWFya3MtaWYtZXhpc3RzIgorbXNnc3RyICJObyBzZSBwdWVkZSBwYXNhciBhbWJvcyAtLWltcG9ydC1tYXJrcyB5IC0taW1wb3J0LW1hcmtzLWlmLWV4aXN0cyIKKworIzogYnVpbHRpbi9mZXRjaC5jOjM0CiBtc2dpZCAiZ2l0IGZldGNoIFs8b3B0aW9ucz5dIFs8cmVwb3NpdG9yeT4gWzxyZWZzcGVjPi4uLl1dIgogbXNnc3RyICJnaXQgZmV0Y2ggWzxvcGNpb25lcz5dIFs8cmVwb3NpdG9yaW8+IFs8cmVmc3BlYz4uLi5dXSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjMxCisjOiBidWlsdGluL2ZldGNoLmM6MzUKIG1zZ2lkICJnaXQgZmV0Y2ggWzxvcHRpb25zPl0gPGdyb3VwPiIKIG1zZ3N0ciAiZ2l0IGZldGNoIFs8b3BjaW9uZXM+XSA8Z3J1cG8+IgogCi0jOiBidWlsdGluL2ZldGNoLmM6MzIKKyM6IGJ1aWx0aW4vZmV0Y2guYzozNgogbXNnaWQgImdpdCBmZXRjaCAtLW11bHRpcGxlIFs8b3B0aW9ucz5dIFsoPHJlcG9zaXRvcnk+IHwgPGdyb3VwPikuLi5dIgogbXNnc3RyICJnaXQgZmV0Y2ggLS1tdWx0aXBsZSBbPG9wY2lvbmVzPl0gWyg8cmVwb3NpdG9yaW8+IHwgPGdydXBvPikuLi5dIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MzMKKyM6IGJ1aWx0aW4vZmV0Y2guYzozNwogbXNnaWQgImdpdCBmZXRjaCAtLWFsbCBbPG9wdGlvbnM+XSIKIG1zZ3N0ciAiZ2l0IGZldGNoIC0tYWxsIFs8b3BjaW9uZXM+XSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjEyNSBidWlsdGluL3B1bGwuYzoyMDMKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxMTUKK21zZ2lkICJmZXRjaC5wYXJhbGxlbCBjYW5ub3QgYmUgbmVnYXRpdmUiCittc2dzdHIgImZldGNoLnBhcmFsbGVsIG5vIHB1ZWRlIHNlciBuZWdhdGl2byIKKworIzogYnVpbHRpbi9mZXRjaC5jOjEzOCBidWlsdGluL3B1bGwuYzoyMDQKIG1zZ2lkICJmZXRjaCBmcm9tIGFsbCByZW1vdGVzIgogbXNnc3RyICJleHRyYWVyIGRlIHRvZG9zIGxvcyByZW1vdG9zIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTI3IGJ1aWx0aW4vcHVsbC5jOjIwNgorIzogYnVpbHRpbi9mZXRjaC5jOjE0MCBidWlsdGluL3B1bGwuYzoyNDgKK21zZ2lkICJzZXQgdXBzdHJlYW0gZm9yIGdpdCBwdWxsL2ZldGNoIgorbXNnc3RyICJjb25maWd1cmFyIHVwc3RyZWFtIHBhcmEgZ2l0IHB1bGxsL2ZldGNoIgorCisjOiBidWlsdGluL2ZldGNoLmM6MTQyIGJ1aWx0aW4vcHVsbC5jOjIwNwogbXNnaWQgImFwcGVuZCB0byAuZ2l0L0ZFVENIX0hFQUQgaW5zdGVhZCBvZiBvdmVyd3JpdGluZyIKIG1zZ3N0ciAiYWRqdW50YXIgYSAuZ2l0L0ZFVENIX0hFQUQgZW4gbHVnYXIgZGUgc29icmVzY3JpYmlyIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTI5IGJ1aWx0aW4vcHVsbC5jOjIwOQorIzogYnVpbHRpbi9mZXRjaC5jOjE0NCBidWlsdGluL3B1bGwuYzoyMTAKIG1zZ2lkICJwYXRoIHRvIHVwbG9hZCBwYWNrIG9uIHJlbW90ZSBlbmQiCiBtc2dzdHIgInJ1dGEgcGFyYSBjYXJnYXIgZWwgcGFxdWV0ZSBhbCBmaW5hbCBkZWwgcmVtb3RvIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTMwCisjOiBidWlsdGluL2ZldGNoLmM6MTQ1CiBtc2dpZCAiZm9yY2Ugb3ZlcndyaXRlIG9mIGxvY2FsIHJlZmVyZW5jZSIKIG1zZ3N0ciAiZm9yemFyIHNvYnJlc2NyaXR1cmEgZGUgcmVmZXJlbmNpYSBsb2NhbCIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjEzMgorIzogYnVpbHRpbi9mZXRjaC5jOjE0NwogbXNnaWQgImZldGNoIGZyb20gbXVsdGlwbGUgcmVtb3RlcyIKIG1zZ3N0ciAiZXh0cmFlciBkZSBtw7psdGlwbGVzIHJlbW90b3MiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxMzQgYnVpbHRpbi9wdWxsLmM6MjEzCisjOiBidWlsdGluL2ZldGNoLmM6MTQ5IGJ1aWx0aW4vcHVsbC5jOjIxNAogbXNnaWQgImZldGNoIGFsbCB0YWdzIGFuZCBhc3NvY2lhdGVkIG9iamVjdHMiCiBtc2dzdHIgImV4dHJhZXIgdG9kb3MgbG9zIHRhZ3MgeSBvYmpldG9zIGFzb2NpYWRvcyIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjEzNgorIzogYnVpbHRpbi9mZXRjaC5jOjE1MQogbXNnaWQgImRvIG5vdCBmZXRjaCBhbGwgdGFncyAoLS1uby10YWdzKSIKIG1zZ3N0ciAibm8gZXh0cmFlciB0b2RvcyBsb3MgdGFncyAoLS1uby10YWdzKSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjEzOAorIzogYnVpbHRpbi9mZXRjaC5jOjE1MwogbXNnaWQgIm51bWJlciBvZiBzdWJtb2R1bGVzIGZldGNoZWQgaW4gcGFyYWxsZWwiCiBtc2dzdHIgIm7Dum1lcm8gZGUgc3VibcOzZHVsb3MgZXh0cmHDrWRvcyBlbiBwYXJhbGVsbyIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE0MCBidWlsdGluL3B1bGwuYzoyMTYKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNTUgYnVpbHRpbi9wdWxsLmM6MjE3CiBtc2dpZCAicHJ1bmUgcmVtb3RlLXRyYWNraW5nIGJyYW5jaGVzIG5vIGxvbmdlciBvbiByZW1vdGUiCiBtc2dzdHIgImxpbXBpYXIgcmFtYXMgcmVtb3RhcyByYXN0cmVhZGFzIHF1ZSB5YSBubyBlc3TDoW4gZW4gZWwgcmVtb3RvIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTQyCisjOiBidWlsdGluL2ZldGNoLmM6MTU3CiBtc2dpZCAicHJ1bmUgbG9jYWwgdGFncyBubyBsb25nZXIgb24gcmVtb3RlIGFuZCBjbG9iYmVyIGNoYW5nZWQgdGFncyIKIG1zZ3N0ciAiIgogImxpbXBpYXIgdGFncyBsb2NhbGVzIHF1ZSBubyBzZSBlbmN1ZW50cmFuIGVuIGVsIHJlbW90byB5IGVsaW1pbmFyIHRhZ3MgIgogImNhbWJpYWRvcyIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE0MyBidWlsdGluL2ZldGNoLmM6MTY2IGJ1aWx0aW4vcHVsbC5jOjE0MAorIzogYnVpbHRpbi9mZXRjaC5jOjE1OCBidWlsdGluL2ZldGNoLmM6MTgxIGJ1aWx0aW4vcHVsbC5jOjE0MQogbXNnaWQgIm9uLWRlbWFuZCIKIG1zZ3N0ciAiZW4gZGVtYW5kYSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE0NAorIzogYnVpbHRpbi9mZXRjaC5jOjE1OQogbXNnaWQgImNvbnRyb2wgcmVjdXJzaXZlIGZldGNoaW5nIG9mIHN1Ym1vZHVsZXMiCiBtc2dzdHIgImNvbnRyb2xhciBleHRyYWNjacOzbiByZWN1cnNpdmEgZGUgc3VibcOzZHVsb3MiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNDggYnVpbHRpbi9wdWxsLmM6MjI0CisjOiBidWlsdGluL2ZldGNoLmM6MTYzIGJ1aWx0aW4vcHVsbC5jOjIyNQogbXNnaWQgImtlZXAgZG93bmxvYWRlZCBwYWNrIgogbXNnc3RyICJtYW50ZW5lciBlbCBwYXF1ZXRlIGRlc2NhcmdhZG8iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNTAKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNjUKIG1zZ2lkICJhbGxvdyB1cGRhdGluZyBvZiBIRUFEIHJlZiIKIG1zZ3N0ciAicGVybWl0aXIgYWN0dWFsaXphciBsYSByZWYgSEVBRCIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE1MyBidWlsdGluL2ZldGNoLmM6MTU5IGJ1aWx0aW4vcHVsbC5jOjIyNworIzogYnVpbHRpbi9mZXRjaC5jOjE2OCBidWlsdGluL2ZldGNoLmM6MTc0IGJ1aWx0aW4vcHVsbC5jOjIyOAogbXNnaWQgImRlZXBlbiBoaXN0b3J5IG9mIHNoYWxsb3cgY2xvbmUiCiBtc2dzdHIgImhpc3RvcmlhIHByb2Z1bmRhIGRlIHVuIGNsb24gc3VwZXJmaWNpYWwiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNTUKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNzAKIG1zZ2lkICJkZWVwZW4gaGlzdG9yeSBvZiBzaGFsbG93IHJlcG9zaXRvcnkgYmFzZWQgb24gdGltZSIKIG1zZ3N0ciAiaGlzdG9yaWEgcHJvZnVuZGEgZGUgdW4gcmVwb3NpdG9yaW8gc3VwZXJmaWNpYWwgYmFzYWRvIGVuIHRpZW1wbyIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE2MSBidWlsdGluL3B1bGwuYzoyMzAKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNzYgYnVpbHRpbi9wdWxsLmM6MjMxCiBtc2dpZCAiY29udmVydCB0byBhIGNvbXBsZXRlIHJlcG9zaXRvcnkiCiBtc2dzdHIgImNvbnZlcnRpciBhIHVuIHJlcG9zaXRvcmlvIGNvbXBsZXRvIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTY0CisjOiBidWlsdGluL2ZldGNoLmM6MTc5CiBtc2dpZCAicHJlcGVuZCB0aGlzIHRvIHN1Ym1vZHVsZSBwYXRoIG91dHB1dCIKIG1zZ3N0ciAiYW50ZXBvbmVyIGVzdG8gYSBzYWxpZGEgZGUgbGEgcnV0YSBkZWwgc3VibcOzZHVsbyIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE2NworIzogYnVpbHRpbi9mZXRjaC5jOjE4MgogbXNnaWQgIiIKICJkZWZhdWx0IGZvciByZWN1cnNpdmUgZmV0Y2hpbmcgb2Ygc3VibW9kdWxlcyAobG93ZXIgcHJpb3JpdHkgdGhhbiBjb25maWcgIgogImZpbGVzKSIKQEAgLTEyNzc2LDkwICsxMjgzNyw5MCBAQAogImRlZmF1bHQgcGFyYSBleHRyYWNjacOzbiByZWN1cnNpdmEgZGUgc3VibcOzZHVsb3MgKG1lbm9yIHByaW9yaWRhZCBxdWUgIgogImFyY2hpdm9zIGRlIGNvbmZpZ3VyYWNpw7NuKSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE3MSBidWlsdGluL3B1bGwuYzoyMzMKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxODYgYnVpbHRpbi9wdWxsLmM6MjM0CiBtc2dpZCAiYWNjZXB0IHJlZnMgdGhhdCB1cGRhdGUgLmdpdC9zaGFsbG93IgogbXNnc3RyICJhY2VwdGFyIHJlZnMgcXVlIGFjdHVhbGljZW4gLmdpdC9zaGFsbG93IgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTcyIGJ1aWx0aW4vcHVsbC5jOjIzNQorIzogYnVpbHRpbi9mZXRjaC5jOjE4NyBidWlsdGluL3B1bGwuYzoyMzYKIG1zZ2lkICJyZWZtYXAiCiBtc2dzdHIgInJlZm1hcCIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE3MyBidWlsdGluL3B1bGwuYzoyMzYKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxODggYnVpbHRpbi9wdWxsLmM6MjM3CiBtc2dpZCAic3BlY2lmeSBmZXRjaCByZWZtYXAiCiBtc2dzdHIgImVzcGVjaWZpY2FyIGV4dHJhY2Npw7NuIGRlIHJlZm1hcCIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE4MAorIzogYnVpbHRpbi9mZXRjaC5jOjE5NQogbXNnaWQgInJlcG9ydCB0aGF0IHdlIGhhdmUgb25seSBvYmplY3RzIHJlYWNoYWJsZSBmcm9tIHRoaXMgb2JqZWN0IgogbXNnc3RyICJyZXBvcnRhIHF1ZSBzb2xvIHRlbmVtb3Mgb2JqZXRvcyBhbGNhbnphYmxlcyBkZSBlc3RlIG9iamV0byIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE4MworIzogYnVpbHRpbi9mZXRjaC5jOjE5OAogbXNnaWQgInJ1biAnZ2MgLS1hdXRvJyBhZnRlciBmZXRjaGluZyIKIG1zZ3N0ciAiZWplY3V0YXIgJ2djIC0tYXV0bycgdHJhcyBlbCBmZXRjaCIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE4NSBidWlsdGluL3B1bGwuYzoyNDUKKyM6IGJ1aWx0aW4vZmV0Y2guYzoyMDAgYnVpbHRpbi9wdWxsLmM6MjQ2CiBtc2dpZCAiY2hlY2sgZm9yIGZvcmNlZC11cGRhdGVzIG9uIGFsbCB1cGRhdGVkIGJyYW5jaGVzIgogbXNnc3RyICJ2ZXJpZmljYXIgdXBkYXRlcyBmb3J6YWRvcyBlbiB0b2RvcyBsb3MgYnJhbmNoIGFjdHVhbGl6YWRvcyIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjQ5MQorIzogYnVpbHRpbi9mZXRjaC5jOjUxMAogbXNnaWQgIkNvdWxkbid0IGZpbmQgcmVtb3RlIHJlZiBIRUFEIgogbXNnc3RyICJObyBzZSBwdWVkbyBlbmNvbnRyYXIgcmVmIHJlbW90YSBIRUFEIgogCi0jOiBidWlsdGluL2ZldGNoLmM6NjMwCisjOiBidWlsdGluL2ZldGNoLmM6NjUwCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvbmZpZ3VyYXRpb24gZmV0Y2gub3V0cHV0IGNvbnRhaW5zIGludmFsaWQgdmFsdWUgJXMiCiBtc2dzdHIgImxhIGNvbmZpZ3VyYWNpw7NuIGZldGNoLm91dHB1dCBjb250aWVuZSBlbCB2YWxvciBpbnbDoWxpZG8gJXMiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzo3MjgKKyM6IGJ1aWx0aW4vZmV0Y2guYzo3NDgKICMsIGMtZm9ybWF0CiBtc2dpZCAib2JqZWN0ICVzIG5vdCBmb3VuZCIKIG1zZ3N0ciAib2JqZXRvICVzIG5vIGVuY29udHJhZG8iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzo3MzIKKyM6IGJ1aWx0aW4vZmV0Y2guYzo3NTIKIG1zZ2lkICJbdXAgdG8gZGF0ZV0iCiBtc2dzdHIgIlthY3R1YWxpemFkb10iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzo3NDUgYnVpbHRpbi9mZXRjaC5jOjc2MSBidWlsdGluL2ZldGNoLmM6ODMzCisjOiBidWlsdGluL2ZldGNoLmM6NzY1IGJ1aWx0aW4vZmV0Y2guYzo3ODEgYnVpbHRpbi9mZXRjaC5jOjg1MwogbXNnaWQgIltyZWplY3RlZF0iCiBtc2dzdHIgIltyZWNoYXphZG9dIgogCi0jOiBidWlsdGluL2ZldGNoLmM6NzQ2CisjOiBidWlsdGluL2ZldGNoLmM6NzY2CiBtc2dpZCAiY2FuJ3QgZmV0Y2ggaW4gY3VycmVudCBicmFuY2giCiBtc2dzdHIgIm5vIHNlIHB1ZWRlIHRyYWVyIGVuIGxhIHJhbWEgYWN0dWFsIgogCi0jOiBidWlsdGluL2ZldGNoLmM6NzU2CisjOiBidWlsdGluL2ZldGNoLmM6Nzc2CiBtc2dpZCAiW3RhZyB1cGRhdGVdIgogbXNnc3RyICJbYWN0dWFsaXphY2nDs24gZGUgdGFnXSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjc1NyBidWlsdGluL2ZldGNoLmM6Nzk0IGJ1aWx0aW4vZmV0Y2guYzo4MTYKLSM6IGJ1aWx0aW4vZmV0Y2guYzo4MjgKKyM6IGJ1aWx0aW4vZmV0Y2guYzo3NzcgYnVpbHRpbi9mZXRjaC5jOjgxNCBidWlsdGluL2ZldGNoLmM6ODM2CisjOiBidWlsdGluL2ZldGNoLmM6ODQ4CiBtc2dpZCAidW5hYmxlIHRvIHVwZGF0ZSBsb2NhbCByZWYiCiBtc2dzdHIgIm5vIHNlIHBvc2libGUgYWN0dWFsaXphciBlbCByZWYgbG9jYWwiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzo3NjEKKyM6IGJ1aWx0aW4vZmV0Y2guYzo3ODEKIG1zZ2lkICJ3b3VsZCBjbG9iYmVyIGV4aXN0aW5nIHRhZyIKIG1zZ3N0ciAicG9kcsOtYSBnb2xwZWFyIHRhZyBleGlzdGVudGUiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzo3ODMKKyM6IGJ1aWx0aW4vZmV0Y2guYzo4MDMKIG1zZ2lkICJbbmV3IHRhZ10iCiBtc2dzdHIgIltudWV2byB0YWddIgogCi0jOiBidWlsdGluL2ZldGNoLmM6Nzg2CisjOiBidWlsdGluL2ZldGNoLmM6ODA2CiBtc2dpZCAiW25ldyBicmFuY2hdIgogbXNnc3RyICJbbnVldmEgcmFtYV0iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzo3ODkKKyM6IGJ1aWx0aW4vZmV0Y2guYzo4MDkKIG1zZ2lkICJbbmV3IHJlZl0iCiBtc2dzdHIgIltudWV2YSByZWZlcmVuY2lhXSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjgyOAorIzogYnVpbHRpbi9mZXRjaC5jOjg0OAogbXNnaWQgImZvcmNlZCB1cGRhdGUiCiBtc2dzdHIgImFjdHVhbGl6YWNpw7NuIGZvcnphZGEiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzo4MzMKKyM6IGJ1aWx0aW4vZmV0Y2guYzo4NTMKIG1zZ2lkICJub24tZmFzdC1mb3J3YXJkIgogbXNnc3RyICJhdmFuY2UgbGVudG8iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzo4NTQKKyM6IGJ1aWx0aW4vZmV0Y2guYzo4NzQKIG1zZ2lkICIiCiAiRmV0Y2ggbm9ybWFsbHkgaW5kaWNhdGVzIHdoaWNoIGJyYW5jaGVzIGhhZCBhIGZvcmNlZCB1cGRhdGUsXG4iCiAiYnV0IHRoYXQgY2hlY2sgaGFzIGJlZW4gZGlzYWJsZWQuIFRvIHJlLWVuYWJsZSwgdXNlICctLXNob3ctZm9yY2VkLXVwZGF0ZXMnXG4iCkBAIC0xMjg3MCw3ICsxMjkzMSw3IEBACiAic2hvdy1mb3JjZWQtdXBkYXRlcydcbiIKICJvIGVqZWN1dGUgJ2dpdCBjb25maWcgZmV0Y2guc2hvd0ZvcmNlZFVwZGF0ZXMgdHJ1ZScuIgogCi0jOiBidWlsdGluL2ZldGNoLmM6ODU4CisjOiBidWlsdGluL2ZldGNoLmM6ODc4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJJdCB0b29rICUuMmYgc2Vjb25kcyB0byBjaGVjayBmb3JjZWQgdXBkYXRlcy4gWW91IGNhbiB1c2VcbiIKQEAgLTEyODgzLDIyICsxMjk0NCwyMiBAQAogImZhbHNlJ1xuIgogInBhcmEgZXZpdGFyIGVzdGEgdmFsaWRhY2nDs24uXG4iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzo4ODgKKyM6IGJ1aWx0aW4vZmV0Y2guYzo5MDgKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgZGlkIG5vdCBzZW5kIGFsbCBuZWNlc3Nhcnkgb2JqZWN0c1xuIgogbXNnc3RyICIlcyBubyBlbnZpw7MgdG9kb3MgbG9zIG9iamV0b3MgbmVjZXNhcmlvc1xuIgogCi0jOiBidWlsdGluL2ZldGNoLmM6OTA5CisjOiBidWlsdGluL2ZldGNoLmM6OTI5CiAjLCBjLWZvcm1hdAogbXNnaWQgInJlamVjdCAlcyBiZWNhdXNlIHNoYWxsb3cgcm9vdHMgYXJlIG5vdCBhbGxvd2VkIHRvIGJlIHVwZGF0ZWQiCiBtc2dzdHIgInJlY2hhemFkbyAlcyBwb3JxdWUgcmHDrWNlcyBzdXBlcmZpY2lhbGVzIG5vIHB1ZWRlbiBzZXIgYWN0dWFsaXphZGFzIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTAwMCBidWlsdGluL2ZldGNoLmM6MTEzMQorIzogYnVpbHRpbi9mZXRjaC5jOjEwMjAgYnVpbHRpbi9mZXRjaC5jOjExNTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiRnJvbSAlLipzXG4iCiBtc2dzdHIgIkRlc2RlICUuKnNcbiIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjEwMTEKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxMDMxCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJzb21lIGxvY2FsIHJlZnMgY291bGQgbm90IGJlIHVwZGF0ZWQ7IHRyeSBydW5uaW5nXG4iCkBAIC0xMjkwNyw1OCArMTI5NjgsNzkgQEAKICJhbGd1bm9zIHJlZnMgbG9jYWxlcyBubyBwdWRpZXJvbiBzZXIgYWN0dWFsaXphZG9zOyBpbnRlbnRlIGVqZWN1dGFyXG4iCiAiICdnaXQgcmVtb3RlIHBydW5lICVzJyBwYXJhIGVsaW1pbmFyIGN1YWxxdWllciByYW1hIHZpZWphIG8gY29uZmxpY3RpdmEiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxMTAxCisjOiBidWlsdGluL2ZldGNoLmM6MTEyNwogIywgYy1mb3JtYXQKIG1zZ2lkICIgICAoJXMgd2lsbCBiZWNvbWUgZGFuZ2xpbmcpIgogbXNnc3RyICIgICAoJXMgc2UgcG9uZHLDoSBjb2xnYWRvKSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjExMDIKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxMTI4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiAgICglcyBoYXMgYmVjb21lIGRhbmdsaW5nKSIKIG1zZ3N0ciAiICAgKCVzIHNlIGhhIGNvbGdhZG8pIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTEzNAorIzogYnVpbHRpbi9mZXRjaC5jOjExNjAKIG1zZ2lkICJbZGVsZXRlZF0iCiBtc2dzdHIgIltlbGltaW5hZG9dIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTEzNSBidWlsdGluL3JlbW90ZS5jOjEwMzYKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxMTYxIGJ1aWx0aW4vcmVtb3RlLmM6MTAzNgogbXNnaWQgIihub25lKSIKIG1zZ3N0ciAiKG5hZGEpIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTE1OAorIzogYnVpbHRpbi9mZXRjaC5jOjExODQKICMsIGMtZm9ybWF0CiBtc2dpZCAiUmVmdXNpbmcgdG8gZmV0Y2ggaW50byBjdXJyZW50IGJyYW5jaCAlcyBvZiBub24tYmFyZSByZXBvc2l0b3J5IgogbXNnc3RyICJSZWh1c2FuZG8gZXh0cmFlciBlbiBsYSByYW1hIGFjdHVhbCAlcyBkZSB1biByZXBvc2l0b3JpbyBubyB2YWPDrW8iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxMTc3CisjOiBidWlsdGluL2ZldGNoLmM6MTIwMwogIywgYy1mb3JtYXQKIG1zZ2lkICJPcHRpb24gXCIlc1wiIHZhbHVlIFwiJXNcIiBpcyBub3QgdmFsaWQgZm9yICVzIgogbXNnc3RyICJPcGNpw7NuIFwiJXNcIiB2YWxvciBcIiVzXCIgbm8gZXMgdsOhbGlkbyBwYXJhICVzIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTE4MAorIzogYnVpbHRpbi9mZXRjaC5jOjEyMDYKICMsIGMtZm9ybWF0CiBtc2dpZCAiT3B0aW9uIFwiJXNcIiBpcyBpZ25vcmVkIGZvciAlc1xuIgogbXNnc3RyICJPcGNpw7NuIFwiJXNcIiBlcyBpZ25vcmFkYSBwb3IgJXNcbiIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE0ODQKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNDE0Cittc2dpZCAibXVsdGlwbGUgYnJhbmNoIGRldGVjdGVkLCBpbmNvbXBhdGlibGUgd2l0aCAtLXNldC11cHN0cmVhbSIKK21zZ3N0ciAibcO6bHRpcGxlcyByYW1hcyBkZXRlY3RhZGFzLCBpbmNvbXBhdGlibGUgY29uIC0tc2V0LXVwc3RyZWFtIgorCisjOiBidWlsdGluL2ZldGNoLmM6MTQyOQorbXNnaWQgIm5vdCBzZXR0aW5nIHVwc3RyZWFtIGZvciBhIHJlbW90ZSByZW1vdGUtdHJhY2tpbmcgYnJhbmNoIgorbXNnc3RyICJubyBjb25maWd1cmFyIHVwc3RyZWFtIHBhcmEgdW5hIHJhbWEgZGUgcmFzdHJlbyByZW1vdG8iCisKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNDMxCittc2dpZCAibm90IHNldHRpbmcgdXBzdHJlYW0gZm9yIGEgcmVtb3RlIHRhZyIKK21zZ3N0ciAibm8gY29uZmlndXJhciB1cHN0cmVhbSBwYXJhIHVuIHRhZyByZW1vdG8iCisKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNDMzCittc2dpZCAidW5rbm93biBicmFuY2ggdHlwZSIKK21zZ3N0ciAidGlwbyBkZSBicmFuY2ggZGVzY29ub2NpZG8iCisKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNDM1Cittc2dpZCAiIgorIm5vIHNvdXJjZSBicmFuY2ggZm91bmQuXG4iCisieW91IG5lZWQgdG8gc3BlY2lmeSBleGFjdGx5IG9uZSBicmFuY2ggd2l0aCB0aGUgLS1zZXQtdXBzdHJlYW0gb3B0aW9uLiIKK21zZ3N0ciAiIgorIm5vIHNlIGVuY29udHLDsyByYW1hIGZ1ZW50ZS5cbiIKKyJ0aWVuZXMgcXVlIGVzcGVjaWZpY2FyIGV4YWN0YW1lbnRlIHVuYSByYW1hIGNvbiBsYSBvcGNpw7NuIC0tc2V0LXVwc3RyZWFtLiIKKworIzogYnVpbHRpbi9mZXRjaC5jOjE1NjEgYnVpbHRpbi9mZXRjaC5jOjE2MjMKICMsIGMtZm9ybWF0CiBtc2dpZCAiRmV0Y2hpbmcgJXNcbiIKIG1zZ3N0ciAiRXh0cmF5ZW5kbyAlc1xuIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTQ4NiBidWlsdGluL3JlbW90ZS5jOjEwMAorIzogYnVpbHRpbi9mZXRjaC5jOjE1NzEgYnVpbHRpbi9mZXRjaC5jOjE2MjUgYnVpbHRpbi9yZW1vdGUuYzoxMDAKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ291bGQgbm90IGZldGNoICVzIgogbXNnc3RyICJObyBzZSBwdWRvIGV4dHJhZXIgJXMiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNTMyCi1tc2dpZCAiIgotIi0tZmlsdGVyIGNhbiBvbmx5IGJlIHVzZWQgd2l0aCB0aGUgcmVtb3RlIGNvbmZpZ3VyZWQgaW4gZXh0ZW5zaW9ucy4iCi0icGFydGlhbENsb25lIgotbXNnc3RyICIiCi0iLS1maWx0ZXIgc29sbyBwdWVkZSBzZXIgdXNhZG8gY29uIGVsIHJlbW90byBjb25maWd1cmFkbyBlbiBleHRlbnNpb25zLiIKLSJwYXJ0aWFsQ2xvbmUiCisjOiBidWlsdGluL2ZldGNoLmM6MTU4MworIywgYy1mb3JtYXQKK21zZ2lkICJjb3VsZCBub3QgZmV0Y2ggJyVzJyAoZXhpdCBjb2RlOiAlZClcbiIKK21zZ3N0ciAibm8gc2UgcHVkbyBoYWNlciBmZXRjaCBhICclcycgKGPDs2RpZ28gZGUgc2FsaWRhOiAlZClcbiIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE1NTYKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNjg1CiBtc2dpZCAiIgogIk5vIHJlbW90ZSByZXBvc2l0b3J5IHNwZWNpZmllZC4gIFBsZWFzZSwgc3BlY2lmeSBlaXRoZXIgYSBVUkwgb3IgYVxuIgogInJlbW90ZSBuYW1lIGZyb20gd2hpY2ggbmV3IHJldmlzaW9ucyBzaG91bGQgYmUgZmV0Y2hlZC4iCkBAIC0xMjk2Niw0NCArMTMwNDgsNDQgQEAKICJObyBoYXkgcmVwb3NpdG9yaW8gcmVtb3RvIGVzcGVjaWZpY2Fkby4gUG9yIGZhdm9yLCBlc3BlY2lmaXF1ZSB1biBVUkwgbyB1blxuIgogIm5vbWJyZSByZW1vdG8gZGVsIGN1YWwgbGFzIG51ZXZhcyByZXZpc2lvbmVzIGRlYmVuIHNlciBleHRyYcOtZGFzLiIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE1OTMKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNzIyCiBtc2dpZCAiWW91IG5lZWQgdG8gc3BlY2lmeSBhIHRhZyBuYW1lLiIKIG1zZ3N0ciAiVGllbmVzIHF1ZSBlc3BlY2lmaWNhciB1biBub21icmUgZGUgdGFnLiIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE2NDQKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNzc0CiBtc2dpZCAiTmVnYXRpdmUgZGVwdGggaW4gLS1kZWVwZW4gaXMgbm90IHN1cHBvcnRlZCIKIG1zZ3N0ciAiUHJvZnVuZGlkYWQgbmVnYXRpdmEgZW4gLS1kZWVwZW4gbm8gc29wb3J0YWRhIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTY0NgorIzogYnVpbHRpbi9mZXRjaC5jOjE3NzYKIG1zZ2lkICItLWRlZXBlbiBhbmQgLS1kZXB0aCBhcmUgbXV0dWFsbHkgZXhjbHVzaXZlIgogbXNnc3RyICItLWRlZXBlbiB5IC0tZGVwdGggc29uIG11dHVhbWVudGUgZXhjbHVzaXZhcyIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE2NTEKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNzgxCiBtc2dpZCAiLS1kZXB0aCBhbmQgLS11bnNoYWxsb3cgY2Fubm90IGJlIHVzZWQgdG9nZXRoZXIiCiBtc2dzdHIgIi0tZGVwdGggeSAtLXVuc2hhbGxvdyBubyBwdWVkZW4gc2VyIHVzYWRhcyBqdW50YXMiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNjUzCisjOiBidWlsdGluL2ZldGNoLmM6MTc4MwogbXNnaWQgIi0tdW5zaGFsbG93IG9uIGEgY29tcGxldGUgcmVwb3NpdG9yeSBkb2VzIG5vdCBtYWtlIHNlbnNlIgogbXNnc3RyICItLXVuc2hhbGxvdyBubyB0aWVuZSBzZW50aWRvIGVuIHVuIHJlcG9zaXRvcmlvIGNvbXBsZXRvIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTY2OQorIzogYnVpbHRpbi9mZXRjaC5jOjE3OTkKIG1zZ2lkICJmZXRjaCAtLWFsbCBkb2VzIG5vdCB0YWtlIGEgcmVwb3NpdG9yeSBhcmd1bWVudCIKIG1zZ3N0ciAiZmV0Y2ggLS1hbGwgbm8gdG9tYSB1biBhcmd1bWVudG8gZGUgcmVwb3NpdG9yaW8iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNjcxCisjOiBidWlsdGluL2ZldGNoLmM6MTgwMQogbXNnaWQgImZldGNoIC0tYWxsIGRvZXMgbm90IG1ha2Ugc2Vuc2Ugd2l0aCByZWZzcGVjcyIKIG1zZ3N0ciAiZmV0Y2ggLS1hbGwgbm8gdGllbmUgc2VudGlkbyBjb24gcmVmc3BlY3MiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNjgwCisjOiBidWlsdGluL2ZldGNoLmM6MTgxMAogIywgYy1mb3JtYXQKIG1zZ2lkICJObyBzdWNoIHJlbW90ZSBvciByZW1vdGUgZ3JvdXA6ICVzIgogbXNnc3RyICJObyBleGlzdGUgZWwgcmVtb3RvIG8gZ3J1cG8gcmVtb3RvOiAlcyIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE2ODcKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxODE3CiBtc2dpZCAiRmV0Y2hpbmcgYSBncm91cCBhbmQgc3BlY2lmeWluZyByZWZzcGVjcyBkb2VzIG5vdCBtYWtlIHNlbnNlIgogbXNnc3RyICJFeHRyYWVyIHVuIGdydXBvIHkgZXNwZWNpZmljYXIgdW4gcmVmc3BlY3Mgbm8gdGllbmUgc2VudGlkbyIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE3MDMKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxODM1CiBtc2dpZCAiIgogIi0tZmlsdGVyIGNhbiBvbmx5IGJlIHVzZWQgd2l0aCB0aGUgcmVtb3RlIGNvbmZpZ3VyZWQgaW4gZXh0ZW5zaW9ucy4iCiAicGFydGlhbGNsb25lIgpAQCAtMTMzNDAsNyArMTM0MjIsNyBAQAogbXNnaWQgImludmFsaWQgcGFyYW1ldGVyOiBleHBlY3RlZCBzaGExLCBnb3QgJyVzJyIKIG1zZ3N0ciAicGFyw6FtZXRybyBpbnbDoWxpZG86IHNoYTEgZXNwZXJhZG8sIHNlIG9idHV2byAnJXMnIgogCi0jOiBidWlsdGluL2djLmM6MzQKKyM6IGJ1aWx0aW4vZ2MuYzozNQogbXNnaWQgImdpdCBnYyBbPG9wdGlvbnM+XSIKIG1zZ3N0ciAiZ2l0IGdjIFs8b3BjaW9uZXM+XSIKIApAQCAtMTMzNTQsMTcgKzEzNDM2LDE3IEBACiBtc2dpZCAiZmFpbGVkIHRvIHBhcnNlICclcycgdmFsdWUgJyVzJyIKIG1zZ3N0ciAiZmFsbMOzIGFsIGFuYWxpemFyICclcycgdmFsb3IgJyVzJyIKIAotIzogYnVpbHRpbi9nYy5jOjQ3NiBidWlsdGluL2luaXQtZGIuYzo1NQorIzogYnVpbHRpbi9nYy5jOjQ3NSBidWlsdGluL2luaXQtZGIuYzo1NQogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3Qgc3RhdCAnJXMnIgogbXNnc3RyICJubyBzZSBwdWRvIGRlZmluaXIgJyVzJyIKIAotIzogYnVpbHRpbi9nYy5jOjQ4NSBidWlsdGluL25vdGVzLmM6MjQwIGJ1aWx0aW4vdGFnLmM6NTI5CisjOiBidWlsdGluL2djLmM6NDg0IGJ1aWx0aW4vbm90ZXMuYzoyNDAgYnVpbHRpbi90YWcuYzo1MjkKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IHJlYWQgJyVzJyIKIG1zZ3N0ciAibm8gc2UgcHVlZGUgbGVlciAnJXMnIgogCi0jOiBidWlsdGluL2djLmM6NDkyCisjOiBidWlsdGluL2djLmM6NDkxCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgbGFzdCBnYyBydW4gcmVwb3J0ZWQgdGhlIGZvbGxvd2luZy4gUGxlYXNlIGNvcnJlY3QgdGhlIHJvb3QgY2F1c2VcbiIKQEAgLTEzMzc0LDU5ICsxMzQ1Niw1OSBAQAogIiVzIgogbXNnc3RyICIiCiAiRWwgw7psdGltbyBnYyByZXBvcnTDsyBsbyBzaWd1aWVudGUuIFBvciBmYXZvciBjb3JyaWdlIGxhIGNhdXNhXG4iCi0ieSByZW11ZXZhICVzLlxuIgorInkgZWxpbWluZSAlcy5cbiIKICJMaW1waWV6YSBhdXRvbcOhdGljYSBubyBzZSByZWFsaXphcsOhIGhhc3RhIHF1ZSBlbCBhcmNoaXZvIHNlYSBlbGltaW5hZG8uXG4iCiAiXG4iCiAiJXMiCiAKLSM6IGJ1aWx0aW4vZ2MuYzo1NDAKKyM6IGJ1aWx0aW4vZ2MuYzo1MzkKIG1zZ2lkICJwcnVuZSB1bnJlZmVyZW5jZWQgb2JqZWN0cyIKIG1zZ3N0ciAibGltcGlhciBvYmpldG9zIG5vIHJlZmVyZW5jaWFkb3MiCiAKLSM6IGJ1aWx0aW4vZ2MuYzo1NDIKKyM6IGJ1aWx0aW4vZ2MuYzo1NDEKIG1zZ2lkICJiZSBtb3JlIHRob3JvdWdoIChpbmNyZWFzZWQgcnVudGltZSkiCiBtc2dzdHIgInNlciBtw6FzIGV4aGF1c3Rpdm8gKGF1bWVudGFyIHJ1bnRpbWUpIgogCi0jOiBidWlsdGluL2djLmM6NTQzCisjOiBidWlsdGluL2djLmM6NTQyCiBtc2dpZCAiZW5hYmxlIGF1dG8tZ2MgbW9kZSIKIG1zZ3N0ciAiaGFiaWxpdGFyIG1vZG8gYXV0by1nYyIKIAotIzogYnVpbHRpbi9nYy5jOjU0NgorIzogYnVpbHRpbi9nYy5jOjU0NQogbXNnaWQgImZvcmNlIHJ1bm5pbmcgZ2MgZXZlbiBpZiB0aGVyZSBtYXkgYmUgYW5vdGhlciBnYyBydW5uaW5nIgogbXNnc3RyICJmb3J6YXIgbGEgZWplY3VjacOzbiBkZSBnYyBpbmNsdXNvIHNpIHB1ZWRlIGhhYmVyIG90cm8gZ2MgZWplY3V0w6FuZG9zZSIKIAotIzogYnVpbHRpbi9nYy5jOjU0OQorIzogYnVpbHRpbi9nYy5jOjU0OAogbXNnaWQgInJlcGFjayBhbGwgb3RoZXIgcGFja3MgZXhjZXB0IHRoZSBsYXJnZXN0IHBhY2siCiBtc2dzdHIgInJlZW1wYXF1ZXRhciB0b2RvcyBsb3Mgb3Ryb3MgcGFxdWV0ZXMgZXhjZXB0byBlbCBwYXF1ZXRlIG3DoXMgZ3JhbmRlIgogCi0jOiBidWlsdGluL2djLmM6NTY2CisjOiBidWlsdGluL2djLmM6NTY1CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBwYXJzZSBnYy5sb2dleHBpcnkgdmFsdWUgJXMiCiBtc2dzdHIgImZhbGzDsyBhbCBhbmFsaXphciB2YWxvciAlcyBkZSBnYy5sb2dleHBpcml0eSIKIAotIzogYnVpbHRpbi9nYy5jOjU3NworIzogYnVpbHRpbi9nYy5jOjU3NgogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gcGFyc2UgcHJ1bmUgZXhwaXJ5IHZhbHVlICVzIgogbXNnc3RyICJmYWxsw7MgYWwgYW5hbGl6YXIgdmFsb3IgJXMgZGUgcHJ1bmUgZXhwaXJ5IgogCi0jOiBidWlsdGluL2djLmM6NTk3CisjOiBidWlsdGluL2djLmM6NTk2CiAjLCBjLWZvcm1hdAogbXNnaWQgIkF1dG8gcGFja2luZyB0aGUgcmVwb3NpdG9yeSBpbiBiYWNrZ3JvdW5kIGZvciBvcHRpbXVtIHBlcmZvcm1hbmNlLlxuIgogbXNnc3RyICIiCiAiQXV0byBlbXBhcXVldGFkbyBkZWwgcmVwb3NpdG9yaW8gZW4gc2VndW5kbyBwbGFubyBwYXJhIHVuIHBlcmZvcm1hbmNlICIKICLDs3B0aW1vLlxuIgogCi0jOiBidWlsdGluL2djLmM6NTk5CisjOiBidWlsdGluL2djLmM6NTk4CiAjLCBjLWZvcm1hdAogbXNnaWQgIkF1dG8gcGFja2luZyB0aGUgcmVwb3NpdG9yeSBmb3Igb3B0aW11bSBwZXJmb3JtYW5jZS5cbiIKIG1zZ3N0ciAiQXV0byBlbXBhcXVldGFkbyBkZWwgcmVwb3NpdG9yaW8gcGFyYSBwZXJmb3JtYW5jZSDDs3B0aW1vLlxuIgogCi0jOiBidWlsdGluL2djLmM6NjAwCisjOiBidWlsdGluL2djLmM6NTk5CiAjLCBjLWZvcm1hdAogbXNnaWQgIlNlZSBcImdpdCBoZWxwIGdjXCIgZm9yIG1hbnVhbCBob3VzZWtlZXBpbmcuXG4iCiBtc2dzdHIgIlZlYSBcImdpdCBoZWxwIGdjXCIgcGFyYSBsaW1waWV6YSBtYW51YWwuXG4iCiAKLSM6IGJ1aWx0aW4vZ2MuYzo2NDAKKyM6IGJ1aWx0aW4vZ2MuYzo2MzkKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogImdjIGlzIGFscmVhZHkgcnVubmluZyBvbiBtYWNoaW5lICclcycgcGlkICU8UFJJdU1BWD4gKHVzZSAtLWZvcmNlIGlmIG5vdCkiCkBAIC0xMzQzNCw3ICsxMzUxNiw3IEBACiAiZ2MgeWEgZXN0w6EgZWplY3V0w6FuZG9zZSBlbiBsYSBtw6FxdWluYSAnJXMnIHBpZCAlPFBSSXVNQVg+ICh1c2UgLS1mb3JjZSBzbyBubyAiCiAiZXMgYXPDrSkiCiAKLSM6IGJ1aWx0aW4vZ2MuYzo2OTUKKyM6IGJ1aWx0aW4vZ2MuYzo2OTQKIG1zZ2lkICIiCiAiVGhlcmUgYXJlIHRvbyBtYW55IHVucmVhY2hhYmxlIGxvb3NlIG9iamVjdHM7IHJ1biAnZ2l0IHBydW5lJyB0byByZW1vdmUgdGhlbS4iCiBtc2dzdHIgIiIKQEAgLTEzNDYwLDI2MSArMTM1NDIsMjYxIEBACiAjLiBncmVwLnRocmVhZHMKICMuCiAjOiBidWlsdGluL2dyZXAuYzoyODcgYnVpbHRpbi9pbmRleC1wYWNrLmM6MTUzNCBidWlsdGluL2luZGV4LXBhY2suYzoxNzI3Ci0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI3MjgKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjcwOAogIywgYy1mb3JtYXQKIG1zZ2lkICJubyB0aHJlYWRzIHN1cHBvcnQsIGlnbm9yaW5nICVzIgogbXNnc3RyICJubyBoYXkgc29wb3J0ZSBwYXJhIGhpbG9zLCBpZ25vcmFuZG8gJXMiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjQ2NyBidWlsdGluL2dyZXAuYzo1OTEgYnVpbHRpbi9ncmVwLmM6NjMzCisjOiBidWlsdGluL2dyZXAuYzo0NjcgYnVpbHRpbi9ncmVwLmM6NTkyIGJ1aWx0aW4vZ3JlcC5jOjYzNQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gcmVhZCB0cmVlICglcykiCiBtc2dzdHIgIm5vIGVzIHBvc2libGUgbGVlciBlbCAgw6FyYm9sICglcykiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjY0OAorIzogYnVpbHRpbi9ncmVwLmM6NjUwCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBncmVwIGZyb20gb2JqZWN0IG9mIHR5cGUgJXMiCiBtc2dzdHIgIm5vIGVzIHBvc2libGUgcmVhbGl6YXIgZ3JlcCBkZWwgb2JqZXRvIGRlIHRpcG8gJXMiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjcxNAorIzogYnVpbHRpbi9ncmVwLmM6NzE2CiAjLCBjLWZvcm1hdAogbXNnaWQgInN3aXRjaCBgJWMnIGV4cGVjdHMgYSBudW1lcmljYWwgdmFsdWUiCiBtc2dzdHIgInN3aXRjaCBgJWMnIGVzcGVyYSB1biB2YWxvciBudW3DqXJpY28iCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjgxMworIzogYnVpbHRpbi9ncmVwLmM6ODE1CiBtc2dpZCAic2VhcmNoIGluIGluZGV4IGluc3RlYWQgb2YgaW4gdGhlIHdvcmsgdHJlZSIKIG1zZ3N0ciAiYnVzY2FyIGVuIGVsIMOtbmRpY2UgZW4gbHVnYXIgZGVsIMOhcmJvbCBkZSB0cmFiYWpvIgogCi0jOiBidWlsdGluL2dyZXAuYzo4MTUKKyM6IGJ1aWx0aW4vZ3JlcC5jOjgxNwogbXNnaWQgImZpbmQgaW4gY29udGVudHMgbm90IG1hbmFnZWQgYnkgZ2l0IgogbXNnc3RyICJlbmNvbnRyYXIgZW4gY29udGVuaWRvcyBubyBtYW5lamFkb3MgcG9yIGdpdCIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODE3CisjOiBidWlsdGluL2dyZXAuYzo4MTkKIG1zZ2lkICJzZWFyY2ggaW4gYm90aCB0cmFja2VkIGFuZCB1bnRyYWNrZWQgZmlsZXMiCiBtc2dzdHIgImJ1c2NhciBlbiBhcmNoaXZvcyByYXN0cmVhZG9zIHkgbm8gcmFzdHJlYWRvcyIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODE5CisjOiBidWlsdGluL2dyZXAuYzo4MjEKIG1zZ2lkICJpZ25vcmUgZmlsZXMgc3BlY2lmaWVkIHZpYSAnLmdpdGlnbm9yZSciCiBtc2dzdHIgImlnbm9yYXIgYXJjaGl2b3MgZXNwZWNpZmljYWRvcyB2aWEgJy5naXRpZ25vcmUnIgogCi0jOiBidWlsdGluL2dyZXAuYzo4MjEKKyM6IGJ1aWx0aW4vZ3JlcC5jOjgyMwogbXNnaWQgInJlY3Vyc2l2ZWx5IHNlYXJjaCBpbiBlYWNoIHN1Ym1vZHVsZSIKIG1zZ3N0ciAiYsO6c3F1ZWRhIHJlY3Vyc2l2YSBlbiBjYWRhIHN1Ym3Ds2R1bG8iCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjgyNAorIzogYnVpbHRpbi9ncmVwLmM6ODI2CiBtc2dpZCAic2hvdyBub24tbWF0Y2hpbmcgbGluZXMiCiBtc2dzdHIgIm1vc3RyYXIgbMOtbmVhcyBxdWUgbm8gY29uY3VlcmRhbiIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODI2CisjOiBidWlsdGluL2dyZXAuYzo4MjgKIG1zZ2lkICJjYXNlIGluc2Vuc2l0aXZlIG1hdGNoaW5nIgogbXNnc3RyICJiw7pzcXVlZGEgaW5zZW5zaWJsZSBhIG1hecO6c2N1bGFzIgogCi0jOiBidWlsdGluL2dyZXAuYzo4MjgKKyM6IGJ1aWx0aW4vZ3JlcC5jOjgzMAogbXNnaWQgIm1hdGNoIHBhdHRlcm5zIG9ubHkgYXQgd29yZCBib3VuZGFyaWVzIgogbXNnc3RyICJjb25jb3JkYXIgcGF0csOzbiBzb2xvIGEgbG9zIGzDrW1pdGVzIGRlIGxhcyBwYWxhYnJhcyIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODMwCisjOiBidWlsdGluL2dyZXAuYzo4MzIKIG1zZ2lkICJwcm9jZXNzIGJpbmFyeSBmaWxlcyBhcyB0ZXh0IgogbXNnc3RyICJwcm9jZXNhciBhcmNoaXZvcyBiaW5hcmlvcyBjb21vIHRleHRvIgogCi0jOiBidWlsdGluL2dyZXAuYzo4MzIKKyM6IGJ1aWx0aW4vZ3JlcC5jOjgzNAogbXNnaWQgImRvbid0IG1hdGNoIHBhdHRlcm5zIGluIGJpbmFyeSBmaWxlcyIKIG1zZ3N0ciAibm8gY29uY29yZGFyIHBhdHJvbmVzIGVuIGFyY2hpdm9zIGJpbmFyaW9zIgogCi0jOiBidWlsdGluL2dyZXAuYzo4MzUKKyM6IGJ1aWx0aW4vZ3JlcC5jOjgzNwogbXNnaWQgInByb2Nlc3MgYmluYXJ5IGZpbGVzIHdpdGggdGV4dGNvbnYgZmlsdGVycyIKIG1zZ3N0ciAicHJvY2VzYXIgYXJjaGl2b3MgYmluYXJpb3MgY29uIGZpbHRyb3MgdGV4dGNvbnYiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjgzNworIzogYnVpbHRpbi9ncmVwLmM6ODM5CiBtc2dpZCAic2VhcmNoIGluIHN1YmRpcmVjdG9yaWVzIChkZWZhdWx0KSIKIG1zZ3N0ciAiYnVzY2FyIGVuIHN1YmRpcmVjdG9yaW9zIChkZWZhdWx0KSIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODM5CisjOiBidWlsdGluL2dyZXAuYzo4NDEKIG1zZ2lkICJkZXNjZW5kIGF0IG1vc3QgPGRlcHRoPiBsZXZlbHMiCiBtc2dzdHIgImRlc2NlbmRlciBjb21vIG3DoXhpbW8gPHZhbG9yLWRlLXByb2Z1bmRpYWQ+ICBuaXZlbGVzIgogCi0jOiBidWlsdGluL2dyZXAuYzo4NDMKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg0NQogbXNnaWQgInVzZSBleHRlbmRlZCBQT1NJWCByZWd1bGFyIGV4cHJlc3Npb25zIgogbXNnc3RyICJ1c2FyIGV4cHJlc2lvbmVzIHJlZ3VsYXJlcyBQT1NJWCBleHRlbmRpZGFzIgogCi0jOiBidWlsdGluL2dyZXAuYzo4NDYKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg0OAogbXNnaWQgInVzZSBiYXNpYyBQT1NJWCByZWd1bGFyIGV4cHJlc3Npb25zIChkZWZhdWx0KSIKIG1zZ3N0ciAidXNhciBleHByZXNpb25lcyByZWd1bGFyZXMgUE9TSVggKGRlZmF1bHQpIgogCi0jOiBidWlsdGluL2dyZXAuYzo4NDkKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg1MQogbXNnaWQgImludGVycHJldCBwYXR0ZXJucyBhcyBmaXhlZCBzdHJpbmdzIgogbXNnc3RyICJpbnRlcnByZXRhciBwYXRyb25lcyBjb21vIHN0cmluZ3MgYXJyZWdsYWRvcyIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODUyCisjOiBidWlsdGluL2dyZXAuYzo4NTQKIG1zZ2lkICJ1c2UgUGVybC1jb21wYXRpYmxlIHJlZ3VsYXIgZXhwcmVzc2lvbnMiCiBtc2dzdHIgInVzYXIgZXhwcmVzaW9uZXMgcmVndWxhcmVzIGNvbXBhdGlibGVzIGNvbiBQZXJsIgogCi0jOiBidWlsdGluL2dyZXAuYzo4NTUKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg1NwogbXNnaWQgInNob3cgbGluZSBudW1iZXJzIgogbXNnc3RyICJtb3N0cmFyIG7Dum1lcm9zIGRlIGzDrW5lYSIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODU2CisjOiBidWlsdGluL2dyZXAuYzo4NTgKIG1zZ2lkICJzaG93IGNvbHVtbiBudW1iZXIgb2YgZmlyc3QgbWF0Y2giCiBtc2dzdHIgIm1vc3RyYXIgZWwgbsO6bWVybyBkZSBjb2x1bW5hIGRlIGxhIHByaW1lciBjb2luY2lkZW5jaWEiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg1NworIzogYnVpbHRpbi9ncmVwLmM6ODU5CiBtc2dpZCAiZG9uJ3Qgc2hvdyBmaWxlbmFtZXMiCiBtc2dzdHIgIm5vIG1vc3RyYXIgbm9tYnJlcyBkZSBhcmNoaXZvIgogCi0jOiBidWlsdGluL2dyZXAuYzo4NTgKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg2MAogbXNnaWQgInNob3cgZmlsZW5hbWVzIgogbXNnc3RyICJtb3N0cmFyIG5vbWJyZXMgZGUgYXJjaGl2byIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODYwCisjOiBidWlsdGluL2dyZXAuYzo4NjIKIG1zZ2lkICJzaG93IGZpbGVuYW1lcyByZWxhdGl2ZSB0byB0b3AgZGlyZWN0b3J5IgogbXNnc3RyICJtb3N0cmFyIG5vbWJyZXMgZGUgYXJjaGl2byByZWxhdGl2b3MgYWwgZGlyZWN0b3JpbyBzdXBlcmlvciIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODYyCisjOiBidWlsdGluL2dyZXAuYzo4NjQKIG1zZ2lkICJzaG93IG9ubHkgZmlsZW5hbWVzIGluc3RlYWQgb2YgbWF0Y2hpbmcgbGluZXMiCiBtc2dzdHIgIm1vc3RyYXIgc29sbyBub21icmVzIGRlIGFyY2hpdm9zIGVuIGx1Z2FyIGRlIGzDrW5lYXMgZW5jb250cmFkYXMiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg2NAorIzogYnVpbHRpbi9ncmVwLmM6ODY2CiBtc2dpZCAic3lub255bSBmb3IgLS1maWxlcy13aXRoLW1hdGNoZXMiCiBtc2dzdHIgInNpbsOzbmltbyBwYXJhIC0tZmlsZXMtd2l0aC1tYXRjaGVzIgogCi0jOiBidWlsdGluL2dyZXAuYzo4NjcKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg2OQogbXNnaWQgInNob3cgb25seSB0aGUgbmFtZXMgb2YgZmlsZXMgd2l0aG91dCBtYXRjaCIKIG1zZ3N0ciAibW9zdHJhciBzb2xvIGxvcyBub21icmVzIGRlIGFyY2hpdm9zIHNpbiBjb2luY2lkZW5jaWFzIgogCi0jOiBidWlsdGluL2dyZXAuYzo4NjkKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg3MQogbXNnaWQgInByaW50IE5VTCBhZnRlciBmaWxlbmFtZXMiCiBtc2dzdHIgImltcHJpbWlyIE5VTCBkZXNwdcOpcyBkZWwgbm9tYnJlIGRlIGFyY2hpdm8iCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg3MgorIzogYnVpbHRpbi9ncmVwLmM6ODc0CiBtc2dpZCAic2hvdyBvbmx5IG1hdGNoaW5nIHBhcnRzIG9mIGEgbGluZSIKIG1zZ3N0ciAibW9zdHJhciBzb2xvIHBhcnRlcyBxdWUgY29uY3VlcmRhbiBkZSB1bmEgbMOtbmVhIgogCi0jOiBidWlsdGluL2dyZXAuYzo4NzQKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg3NgogbXNnaWQgInNob3cgdGhlIG51bWJlciBvZiBtYXRjaGVzIGluc3RlYWQgb2YgbWF0Y2hpbmcgbGluZXMiCiBtc2dzdHIgIm1vc3RyYXIgZWwgbsO6bWVybyBkZSBjb25jb3JkYW5jaWFzIGVuIGx1Z2FyIGRlIGxhcyBsw61uZWFzIGNvbmNvcmRhbnRlcyIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODc1CisjOiBidWlsdGluL2dyZXAuYzo4NzcKIG1zZ2lkICJoaWdobGlnaHQgbWF0Y2hlcyIKIG1zZ3N0ciAicmVzYWx0YXIgY29uY29yZGFuY2lhcyIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODc3CisjOiBidWlsdGluL2dyZXAuYzo4NzkKIG1zZ2lkICJwcmludCBlbXB0eSBsaW5lIGJldHdlZW4gbWF0Y2hlcyBmcm9tIGRpZmZlcmVudCBmaWxlcyIKIG1zZ3N0ciAiaW1wcmltaXIgdW5hIGzDrW5lYSB2YWPDrWEgZW50cmUgY29pbmNpZGVuY2lhcyBkZSBkaWZlcmVudGVzIGFyY2hpdm9zIgogCi0jOiBidWlsdGluL2dyZXAuYzo4NzkKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg4MQogbXNnaWQgInNob3cgZmlsZW5hbWUgb25seSBvbmNlIGFib3ZlIG1hdGNoZXMgZnJvbSBzYW1lIGZpbGUiCiBtc2dzdHIgIiIKICJtb3N0cmFyIGVsIG5vbWJyZSBkZSBhcmNoaXZvIHNvbG8gdW5hIHZleiBwYXJhIGNvbmNvcmRhbmNpYXMgZW4gZWwgbWlzbW8gIgogImFyY2hpdm8iCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg4MgorIzogYnVpbHRpbi9ncmVwLmM6ODg0CiBtc2dpZCAic2hvdyA8bj4gY29udGV4dCBsaW5lcyBiZWZvcmUgYW5kIGFmdGVyIG1hdGNoZXMiCiBtc2dzdHIgIm1vc3RyYXIgPG4+IGzDrW5lYXMgZGUgY29udGV4dG8gYW50ZXMgeSBkZXNwdcOpcyBkZSBsYSBjb25jb3JkYW5jaWEiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg4NQorIzogYnVpbHRpbi9ncmVwLmM6ODg3CiBtc2dpZCAic2hvdyA8bj4gY29udGV4dCBsaW5lcyBiZWZvcmUgbWF0Y2hlcyIKIG1zZ3N0ciAibW9zdHJhciA8bj4gbMOtbmVhcyBkZSBjb250ZXh0byBhbnRlcyBkZSBsYXMgY29uY29yZGFuY2lhcyIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODg3CisjOiBidWlsdGluL2dyZXAuYzo4ODkKIG1zZ2lkICJzaG93IDxuPiBjb250ZXh0IGxpbmVzIGFmdGVyIG1hdGNoZXMiCiBtc2dzdHIgIm1vc3RyYXIgPG4+IGzDrW5lYXMgZGUgY29udGV4dCBkZXNwdcOpcyBkZSBsYXMgY29uY29yZGFuY2lhcyIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODg5CisjOiBidWlsdGluL2dyZXAuYzo4OTEKIG1zZ2lkICJ1c2UgPG4+IHdvcmtlciB0aHJlYWRzIgogbXNnc3RyICJ1c2FyIDxuPiBoaWxvcyBkZSB0cmFiYWpvIgogCi0jOiBidWlsdGluL2dyZXAuYzo4OTAKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg5MgogbXNnaWQgInNob3J0Y3V0IGZvciAtQyBOVU0iCiBtc2dzdHIgImF0YWpvIHBhcmEgLUMgTlVNIgogCi0jOiBidWlsdGluL2dyZXAuYzo4OTMKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg5NQogbXNnaWQgInNob3cgYSBsaW5lIHdpdGggdGhlIGZ1bmN0aW9uIG5hbWUgYmVmb3JlIG1hdGNoZXMiCiBtc2dzdHIgIiIKICJtb3N0cmFyIHVuYSBsw61uZWEgY29uIGVsIG5vbWJyZSBkZSBsYSBmdW5jacOzbiBhbnRlcyBkZSBsYXMgY29uY29yZGFuY2lhcyIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODk1CisjOiBidWlsdGluL2dyZXAuYzo4OTcKIG1zZ2lkICJzaG93IHRoZSBzdXJyb3VuZGluZyBmdW5jdGlvbiIKIG1zZ3N0ciAibW9zdHJhciBsYSBmdW5jacOzbiBjaXJjdW5kYW50ZSIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODk4CisjOiBidWlsdGluL2dyZXAuYzo5MDAKIG1zZ2lkICJyZWFkIHBhdHRlcm5zIGZyb20gZmlsZSIKIG1zZ3N0ciAibGVlciBwYXRyb25lcyBkZWwgYXJjaGl2byIKIAotIzogYnVpbHRpbi9ncmVwLmM6OTAwCisjOiBidWlsdGluL2dyZXAuYzo5MDIKIG1zZ2lkICJtYXRjaCA8cGF0dGVybj4iCiBtc2dzdHIgImNvbmNvcmRhciA8cGF0csOzbj4iCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjkwMgorIzogYnVpbHRpbi9ncmVwLmM6OTA0CiBtc2dpZCAiY29tYmluZSBwYXR0ZXJucyBzcGVjaWZpZWQgd2l0aCAtZSIKIG1zZ3N0ciAiY29tYmluYXIgcGF0cm9uZXMgZXNwZWNpZmljYWRvcyBjb24gLWUiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjkxNAorIzogYnVpbHRpbi9ncmVwLmM6OTE2CiBtc2dpZCAiaW5kaWNhdGUgaGl0IHdpdGggZXhpdCBzdGF0dXMgd2l0aG91dCBvdXRwdXQiCiBtc2dzdHIgImluZGljYXIgY29uY29yZGFuY2lhIGNvbiBleGl0IHN0YXR1cyBzaW4gb3V0cHV0IgogCi0jOiBidWlsdGluL2dyZXAuYzo5MTYKKyM6IGJ1aWx0aW4vZ3JlcC5jOjkxOAogbXNnaWQgInNob3cgb25seSBtYXRjaGVzIGZyb20gZmlsZXMgdGhhdCBtYXRjaCBhbGwgcGF0dGVybnMiCiBtc2dzdHIgIiIKICJtb3N0cmFyIHNvbG8gY29uY29yZGFuY2lhcyBjb24gYXJjaGl2b3MgcXVlIGNvbmN1ZXJkYW4gdG9kb3MgbG9zIHBhdHJvbmVzIgogCi0jOiBidWlsdGluL2dyZXAuYzo5MTgKKyM6IGJ1aWx0aW4vZ3JlcC5jOjkyMAogbXNnaWQgInNob3cgcGFyc2UgdHJlZSBmb3IgZ3JlcCBleHByZXNzaW9uIgogbXNnc3RyICJtb3N0cmFyIMOhcmJvbCBhbmFsaXphZG8gcGFyYSBsYSBleHByZXNpw7NuIGdyZXAiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjkyMgorIzogYnVpbHRpbi9ncmVwLmM6OTI0CiBtc2dpZCAicGFnZXIiCiBtc2dzdHIgInBhZ2luYWRvciIKIAotIzogYnVpbHRpbi9ncmVwLmM6OTIyCisjOiBidWlsdGluL2dyZXAuYzo5MjQKIG1zZ2lkICJzaG93IG1hdGNoaW5nIGZpbGVzIGluIHRoZSBwYWdlciIKIG1zZ3N0ciAibW9zdHJhciBhcmNoaXZvcyBjb25jb3JkYW50ZXMgZW4gZWwgcGFnaW5hZG9yIgogCi0jOiBidWlsdGluL2dyZXAuYzo5MjYKKyM6IGJ1aWx0aW4vZ3JlcC5jOjkyOAogbXNnaWQgImFsbG93IGNhbGxpbmcgb2YgZ3JlcCgxKSAoaWdub3JlZCBieSB0aGlzIGJ1aWxkKSIKIG1zZ3N0ciAicGVybWl0aXIgZWwgbGxhbWFkbyBkZSBncmVwKDEpIChpZ25vcmFkbyBwb3IgZXN0YSBidWlsZCkiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjk5MAorIzogYnVpbHRpbi9ncmVwLmM6OTkyCiBtc2dpZCAibm8gcGF0dGVybiBnaXZlbiIKIG1zZ3N0ciAibm8gc2UgaGEgZW50cmVnYWRvIHBhdHLDs24iCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjEwMjYKKyM6IGJ1aWx0aW4vZ3JlcC5jOjEwMjgKIG1zZ2lkICItLW5vLWluZGV4IG9yIC0tdW50cmFja2VkIGNhbm5vdCBiZSB1c2VkIHdpdGggcmV2cyIKIG1zZ3N0ciAiLS1uby1pbmRleCBvIC0tdW50cmFja2VkIG5vIHNlIHB1ZWRlIHVzYXIgY29uIHJldnMiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjEwMzQKKyM6IGJ1aWx0aW4vZ3JlcC5jOjEwMzYKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHJlc29sdmUgcmV2aXNpb246ICVzIgogbXNnc3RyICJubyBzZSBwb3NpYmxlIHJlc29sdmVyIHJldmlzacOzbjogJXMiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjEwNjUKKyM6IGJ1aWx0aW4vZ3JlcC5jOjEwNjcKIG1zZ2lkICJpbnZhbGlkIG9wdGlvbiBjb21iaW5hdGlvbiwgaWdub3JpbmcgLS10aHJlYWRzIgogbXNnc3RyICJjb21iaW5hY2nDs24gZGUgb3BjaW9uZXMgaW52w6FsaWRhLCBpZ25vcmFuZG8gLS10aHJlYWRzIgogCi0jOiBidWlsdGluL2dyZXAuYzoxMDY4IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzQxNgorIzogYnVpbHRpbi9ncmVwLmM6MTA3MCBidWlsdGluL3BhY2stb2JqZWN0cy5jOjM0MDAKIG1zZ2lkICJubyB0aHJlYWRzIHN1cHBvcnQsIGlnbm9yaW5nIC0tdGhyZWFkcyIKIG1zZ3N0ciAibm8gc2Ugc29wb3J0YW4gaGlsb3MsIGlnbm9yYW5kbyAtLXRocmVhZHMiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjEwNzEgYnVpbHRpbi9pbmRleC1wYWNrLmM6MTUzMSBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI3MjUKKyM6IGJ1aWx0aW4vZ3JlcC5jOjEwNzMgYnVpbHRpbi9pbmRleC1wYWNrLmM6MTUzMSBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI3MDUKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBudW1iZXIgb2YgdGhyZWFkcyBzcGVjaWZpZWQgKCVkKSIKIG1zZ3N0ciAibsO6bWVybyBpbnbDoWxpZG8gZGUgaGlsb3MgZXNwZWNpZmljYWRvICglZCkiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjEwOTQKKyM6IGJ1aWx0aW4vZ3JlcC5jOjEwOTYKIG1zZ2lkICItLW9wZW4tZmlsZXMtaW4tcGFnZXIgb25seSB3b3JrcyBvbiB0aGUgd29ya3RyZWUiCiBtc2dzdHIgIi0tb3Blbi1maWxlcy1pbi1wYWdlciBzb2xvIGZ1bmNpb25hIGVuIGVsIMOhcmJvbCBkZSB0cmFiYWpvIgogCi0jOiBidWlsdGluL2dyZXAuYzoxMTE3CisjOiBidWlsdGluL2dyZXAuYzoxMTE5CiBtc2dpZCAib3B0aW9uIG5vdCBzdXBwb3J0ZWQgd2l0aCAtLXJlY3Vyc2Utc3VibW9kdWxlcyIKIG1zZ3N0ciAib3BjacOzbiBubyBzb3BvcnRhZGEgY29uIC0tcmVjdXJzZS1zdWJtb2R1bGVzIgogCi0jOiBidWlsdGluL2dyZXAuYzoxMTIzCisjOiBidWlsdGluL2dyZXAuYzoxMTI1CiBtc2dpZCAiLS1jYWNoZWQgb3IgLS11bnRyYWNrZWQgY2Fubm90IGJlIHVzZWQgd2l0aCAtLW5vLWluZGV4IgogbXNnc3RyICItLWNhY2hlZCBvIC0tdW50cmFja2VkIG5vIHB1ZWRlbiBzZXIgdXNhZGFzIGNvbiAtLW5vLWluZGV4IgogCi0jOiBidWlsdGluL2dyZXAuYzoxMTI5CisjOiBidWlsdGluL2dyZXAuYzoxMTMxCiBtc2dpZCAiLS1bbm8tXWV4Y2x1ZGUtc3RhbmRhcmQgY2Fubm90IGJlIHVzZWQgZm9yIHRyYWNrZWQgY29udGVudHMiCiBtc2dzdHIgIi0tW25vLV1leGNsdWRlLXN0YW5kYXJkIG5vIHB1ZWRlIHNlciB1c2FkYSBwYXJhIGNvbnRlbmlkbyByYXN0cmVhZG8iCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjExMzcKKyM6IGJ1aWx0aW4vZ3JlcC5jOjExMzkKIG1zZ2lkICJib3RoIC0tY2FjaGVkIGFuZCB0cmVlcyBhcmUgZ2l2ZW4iCiBtc2dzdHIgIi0tY2FjaGVkIHkgw6FyYm9sZXMgaGFuIHNpZG8gZW50cmVnYWRvcyIKIApAQCAtMTM5NjQsNyArMTQwNDYsNyBAQAogIzogYnVpbHRpbi9pbmRleC1wYWNrLmM6ODAzIGJ1aWx0aW4vaW5kZXgtcGFjay5jOjgxMgogIywgYy1mb3JtYXQKIG1zZ2lkICJTSEExIENPTExJU0lPTiBGT1VORCBXSVRIICVzICEiCi1tc2dzdHIgIkNPTElTScOTTiBERSBUSVBPIFNIQTEgRU5DT05UUkFEQSBDT04gJXMgISIKK21zZ3N0ciAiwqFDT0xJU0nDk04gREUgVElQTyBTSEExIEVOQ09OVFJBREEgQ09OICVzICEiCiAKICM6IGJ1aWx0aW4vaW5kZXgtcGFjay5jOjczOCBidWlsdGluL3BhY2stb2JqZWN0cy5jOjE1NwogIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyMTcgYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMTEKQEAgLTE0MDI4LDcgKzE0MTEwLDcgQEAKIG1zZ2lkICJSZXNvbHZpbmcgZGVsdGFzIgogbXNnc3RyICJSZXNvbHZpZW5kbyBkZWx0YXMiCiAKLSM6IGJ1aWx0aW4vaW5kZXgtcGFjay5jOjEyMDUgYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNDk3CisjOiBidWlsdGluL2luZGV4LXBhY2suYzoxMjA1IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjQ4MQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gY3JlYXRlIHRocmVhZDogJXMiCiBtc2dzdHIgIm5vIGVzIHBvc2libGUgY3JlYXIgaGlsbzogJXMiCkBAIC0xNDA0Nyw3ICsxNDEyOSw3IEBACiAjOiBidWlsdGluL2luZGV4LXBhY2suYzoxMjY0CiAjLCBjLWZvcm1hdAogbXNnaWQgIlVuZXhwZWN0ZWQgdGFpbCBjaGVja3N1bSBmb3IgJXMgKGRpc2sgY29ycnVwdGlvbj8pIgotbXNnc3RyICJUYWlsIGNoZWNrc3VtIHBhcmEgJXMgaW5lc3BlcmFkYSAoY29ycnVwY2nDs24gZGUgZGlzY28/KSIKK21zZ3N0ciAiVGFpbCBjaGVja3N1bSBwYXJhICVzIGluZXNwZXJhZGEgKMK/Y29ycnVwY2nDs24gZGUgZGlzY28/KSIKIAogIzogYnVpbHRpbi9pbmRleC1wYWNrLmM6MTI2OAogIywgYy1mb3JtYXQKQEAgLTE0MDkzLDcgKzE0MTc1LDcgQEAKIG1zZ2lkICJjYW5ub3Qgc3RvcmUgaW5kZXggZmlsZSIKIG1zZ3N0ciAibm8gc2UgcHVlZGUgZ3VhcmRhciBlbCBhcmNoaXZvIMOtbmRpY2UiCiAKLSM6IGJ1aWx0aW4vaW5kZXgtcGFjay5jOjE1MjUgYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNzM2CisjOiBidWlsdGluL2luZGV4LXBhY2suYzoxNTI1IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjcxNgogIywgYy1mb3JtYXQKIG1zZ2lkICJiYWQgcGFjay5pbmRleHZlcnNpb249JTxQUkl1MzI+IgogbXNnc3RyICJtYWwgcGFjay5pbmRleHZlcnNpb249JTxQUkl1MzI+IgpAQCAtMTQzNzUsNzQgKzE0NDU3LDc0IEBACiBtc2dpZCAiZ2l0IHNob3cgJXM6IGJhZCBmaWxlIgogbXNnc3RyICJnaXQgc2hvdyAlczogbWFsIGFyY2hpdm8iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6NTQ5IGJ1aWx0aW4vbG9nLmM6NjQzCisjOiBidWlsdGluL2xvZy5jOjU0OSBidWlsdGluL2xvZy5jOjY0NAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcmVhZCBvYmplY3QgJXMiCiBtc2dzdHIgIm5vIHNlIHB1ZG8gbGVlciBvYmpldG8gJXMiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6NjY4CisjOiBidWlsdGluL2xvZy5jOjY2OQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmtub3duIHR5cGU6ICVkIgogbXNnc3RyICJ0aXBvIGRlc2Nvbm9jaWRvOiAlZCIKIAotIzogYnVpbHRpbi9sb2cuYzo3OTEKKyM6IGJ1aWx0aW4vbG9nLmM6NzkyCiBtc2dpZCAiZm9ybWF0LmhlYWRlcnMgd2l0aG91dCB2YWx1ZSIKIG1zZ3N0ciAiZm9ybWF0ZS5oZWFkZXJzLiBzaW4gdmFsb3IiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6OTA4CisjOiBidWlsdGluL2xvZy5jOjkwOQogbXNnaWQgIm5hbWUgb2Ygb3V0cHV0IGRpcmVjdG9yeSBpcyB0b28gbG9uZyIKIG1zZ3N0ciAibm9tYnJlIGRlbCBkaXJlY3RvcmlvIGRlIHNhbGlkYSBlcyBtdXkgbGFyZ28iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6OTI0CisjOiBidWlsdGluL2xvZy5jOjkyNQogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3Qgb3BlbiBwYXRjaCBmaWxlICVzIgogbXNnc3RyICJubyBzZSBwdWVkZSBhYnJpciBhcmNoaXZvIHBhdGNoICVzIgogCi0jOiBidWlsdGluL2xvZy5jOjk0MQorIzogYnVpbHRpbi9sb2cuYzo5NDIKIG1zZ2lkICJuZWVkIGV4YWN0bHkgb25lIHJhbmdlIgogbXNnc3RyICJuZWNlc2l0YSBleGFjdGFtZW50ZSB1biByYW5nbyIKIAotIzogYnVpbHRpbi9sb2cuYzo5NTEKKyM6IGJ1aWx0aW4vbG9nLmM6OTUyCiBtc2dpZCAibm90IGEgcmFuZ2UiCiBtc2dzdHIgIm5vIGVzIHVuIHJhbmdvIgogCi0jOiBidWlsdGluL2xvZy5jOjEwNzQKKyM6IGJ1aWx0aW4vbG9nLmM6MTA3NQogbXNnaWQgImNvdmVyIGxldHRlciBuZWVkcyBlbWFpbCBmb3JtYXQiCiBtc2dzdHIgImxldHJhcyBkZSBwb3J0YWRhIG5lY2VzaXRhIGZvcm1hdG8gZW1haWwiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTA4MAorIzogYnVpbHRpbi9sb2cuYzoxMDgxCiBtc2dpZCAiZmFpbGVkIHRvIGNyZWF0ZSBjb3Zlci1sZXR0ZXIgZmlsZSIKIG1zZ3N0ciAiZmFsbMOzIGFsIGNyZWFyIGxvcyBhcmNoaXZvcyBjb3Zlci1sZXR0ZXIiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTE1OQorIzogYnVpbHRpbi9sb2cuYzoxMTYwCiAjLCBjLWZvcm1hdAogbXNnaWQgImluc2FuZSBpbi1yZXBseS10bzogJXMiCiBtc2dzdHIgImluc2FubyBpbi1yZXBseS10bzogJXMiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTE4NgorIzogYnVpbHRpbi9sb2cuYzoxMTg3CiBtc2dpZCAiZ2l0IGZvcm1hdC1wYXRjaCBbPG9wdGlvbnM+XSBbPHNpbmNlPiB8IDxyZXZpc2lvbi1yYW5nZT5dIgogbXNnc3RyICJnaXQgZm9ybWF0LXBhdGNoIFs8b3BjaW9uZXM+XSBbPGRlc2RlPiB8IDxyYW5nby1kZS1yZXZpc2lvbmVzPl0iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTI0NAorIzogYnVpbHRpbi9sb2cuYzoxMjQ1CiBtc2dpZCAidHdvIG91dHB1dCBkaXJlY3Rvcmllcz8iCi1tc2dzdHIgImRvcyBkaXJlY3RvcmlvcyBkZSBzYWxpZGE/IgorbXNnc3RyICLCv2RvcyBkaXJlY3RvcmlvcyBkZSBzYWxpZGE/IgogCi0jOiBidWlsdGluL2xvZy5jOjEzNTUgYnVpbHRpbi9sb2cuYzoyMDk5IGJ1aWx0aW4vbG9nLmM6MjEwMSBidWlsdGluL2xvZy5jOjIxMTMKKyM6IGJ1aWx0aW4vbG9nLmM6MTM1NiBidWlsdGluL2xvZy5jOjIxMTYgYnVpbHRpbi9sb2cuYzoyMTE4IGJ1aWx0aW4vbG9nLmM6MjEzMAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmtub3duIGNvbW1pdCAlcyIKIG1zZ3N0ciAiY29tbWl0IGRlc2Nvbm9jaWRvICVzIgogCi0jOiBidWlsdGluL2xvZy5jOjEzNjUgYnVpbHRpbi9yZXBsYWNlLmM6NTggYnVpbHRpbi9yZXBsYWNlLmM6MjA3CisjOiBidWlsdGluL2xvZy5jOjEzNjYgYnVpbHRpbi9yZXBsYWNlLmM6NTggYnVpbHRpbi9yZXBsYWNlLmM6MjA3CiAjOiBidWlsdGluL3JlcGxhY2UuYzoyMTAKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIHJlc29sdmUgJyVzJyBhcyBhIHZhbGlkIHJlZiIKIG1zZ3N0ciAiZmFsbMOzIGFsIHJlc29sdmVyICclcycgY29tbyByZWYgdsOhbGlkYSIKIAotIzogYnVpbHRpbi9sb2cuYzoxMzcwCisjOiBidWlsdGluL2xvZy5jOjEzNzEKIG1zZ2lkICJjb3VsZCBub3QgZmluZCBleGFjdCBtZXJnZSBiYXNlIgogbXNnc3RyICJubyBzZSBwdWRvIGVuY29udHJhciB1bmEgYmFzZSBkZSBmdXNpw7NuIGV4YWN0YSIKIAotIzogYnVpbHRpbi9sb2cuYzoxMzc0CisjOiBidWlsdGluL2xvZy5jOjEzNzUKIG1zZ2lkICIiCiAiZmFpbGVkIHRvIGdldCB1cHN0cmVhbSwgaWYgeW91IHdhbnQgdG8gcmVjb3JkIGJhc2UgY29tbWl0IGF1dG9tYXRpY2FsbHksXG4iCiAicGxlYXNlIHVzZSBnaXQgYnJhbmNoIC0tc2V0LXVwc3RyZWFtLXRvIHRvIHRyYWNrIGEgcmVtb3RlIGJyYW5jaC5cbiIKQEAgLTE0NDU0LDI3MSArMTQ1MzYsMjcxIEBACiAiTyBwdWVkZXMgZXNwZWNpZmljYXIgdW4gY29tbWl0IGJhc2UgbWVkaWFudGUgLS1iYXNlPTxpZC1jb21taXQtYmFzZT4gIgogIm1hbnVhbG1lbnRlIgogCi0jOiBidWlsdGluL2xvZy5jOjEzOTQKKyM6IGJ1aWx0aW4vbG9nLmM6MTM5NQogbXNnaWQgImZhaWxlZCB0byBmaW5kIGV4YWN0IG1lcmdlIGJhc2UiCiBtc2dzdHIgImZhbGzDsyBhbCBlbmNvbnRyYXIgdW5hIGJhc2UgZGUgZnVzacOzbiBleGFjdGEiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTQwNQorIzogYnVpbHRpbi9sb2cuYzoxNDA2CiBtc2dpZCAiYmFzZSBjb21taXQgc2hvdWxkIGJlIHRoZSBhbmNlc3RvciBvZiByZXZpc2lvbiBsaXN0IgogbXNnc3RyICJlbCBjb21taXQgYmFzZSBkZWJlIHNlciBlbCBhbmNlc3RybyBkZSBsYSBsaXN0YSBkZSByZXZpc2nDs24iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTQwOQorIzogYnVpbHRpbi9sb2cuYzoxNDEwCiBtc2dpZCAiYmFzZSBjb21taXQgc2hvdWxkbid0IGJlIGluIHJldmlzaW9uIGxpc3QiCiBtc2dzdHIgImVsIGNvbW1pdCBiYXNlIG5vIGRlYmUgZXN0YXIgZW4gbGEgbGlzdGEgZGUgcmV2aXNpw7NuIgogCi0jOiBidWlsdGluL2xvZy5jOjE0NjIKKyM6IGJ1aWx0aW4vbG9nLmM6MTQ2MwogbXNnaWQgImNhbm5vdCBnZXQgcGF0Y2ggaWQiCiBtc2dzdHIgIm5vIHNlIHB1ZWRlIG9idGVuZXIgaWQgZGUgcGF0Y2giCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTUxNAorIzogYnVpbHRpbi9sb2cuYzoxNTE1CiBtc2dpZCAiZmFpbGVkIHRvIGluZmVyIHJhbmdlLWRpZmYgcmFuZ2VzIgogbXNnc3RyICJmYWxsw7MgYWwgaW5mZXJpciByYW5nb3MgcmFuZ2UtZGlmZiIKIAotIzogYnVpbHRpbi9sb2cuYzoxNTU5CisjOiBidWlsdGluL2xvZy5jOjE1NjAKIG1zZ2lkICJ1c2UgW1BBVENIIG4vbV0gZXZlbiB3aXRoIGEgc2luZ2xlIHBhdGNoIgogbXNnc3RyICJ1c2UgW1BBVENIIG4vbV0gaW5jbHVzbyBjb24gdW4gw7puaWNvIHBhcmNoZSIKIAotIzogYnVpbHRpbi9sb2cuYzoxNTYyCisjOiBidWlsdGluL2xvZy5jOjE1NjMKIG1zZ2lkICJ1c2UgW1BBVENIXSBldmVuIHdpdGggbXVsdGlwbGUgcGF0Y2hlcyIKIG1zZ3N0ciAidXNlIFtQQVRDSF0gaW5jbHVzbyBjb24gbcO6bHRpcGxlcyBwYXJjaGVzIgogCi0jOiBidWlsdGluL2xvZy5jOjE1NjYKKyM6IGJ1aWx0aW4vbG9nLmM6MTU2NwogbXNnaWQgInByaW50IHBhdGNoZXMgdG8gc3RhbmRhcmQgb3V0IgogbXNnc3RyICJtb3N0cmFyIHBhcmNoZXMgZW4gc3RhbmRhcmQgb3V0IgogCi0jOiBidWlsdGluL2xvZy5jOjE1NjgKKyM6IGJ1aWx0aW4vbG9nLmM6MTU2OQogbXNnaWQgImdlbmVyYXRlIGEgY292ZXIgbGV0dGVyIgogbXNnc3RyICJnZW5lcmFyIGxldHJhIGRlIGNvdmVyIgogCi0jOiBidWlsdGluL2xvZy5jOjE1NzAKKyM6IGJ1aWx0aW4vbG9nLmM6MTU3MQogbXNnaWQgInVzZSBzaW1wbGUgbnVtYmVyIHNlcXVlbmNlIGZvciBvdXRwdXQgZmlsZSBuYW1lcyIKIG1zZ3N0ciAiIgogInVzYXIgdW5hIHNlY3VlbmNpYSBzaW1wbGUgZGUgbsO6bWVyb3MgcGFyYSBzYWxpZGEgZGUgbm9tYnJlcyBkZSBhcmNoaXZvcyIKIAotIzogYnVpbHRpbi9sb2cuYzoxNTcxCisjOiBidWlsdGluL2xvZy5jOjE1NzIKIG1zZ2lkICJzZngiCiBtc2dzdHIgInNmeCIKIAotIzogYnVpbHRpbi9sb2cuYzoxNTcyCisjOiBidWlsdGluL2xvZy5jOjE1NzMKIG1zZ2lkICJ1c2UgPHNmeD4gaW5zdGVhZCBvZiAnLnBhdGNoJyIKIG1zZ3N0ciAidXNlIDxzZng+IGVuIGx1Z2FyIGRlICcucGF0Y2gnIgogCi0jOiBidWlsdGluL2xvZy5jOjE1NzQKKyM6IGJ1aWx0aW4vbG9nLmM6MTU3NQogbXNnaWQgInN0YXJ0IG51bWJlcmluZyBwYXRjaGVzIGF0IDxuPiBpbnN0ZWFkIG9mIDEiCiBtc2dzdHIgImNvbWVuemFyIGEgbnVtZXJhciBsb3MgcGFyY2hlcyBkZXNkZSA8bj4gZW4gbHVnYXIgZGUgMSIKIAotIzogYnVpbHRpbi9sb2cuYzoxNTc2CisjOiBidWlsdGluL2xvZy5jOjE1NzcKIG1zZ2lkICJtYXJrIHRoZSBzZXJpZXMgYXMgTnRoIHJlLXJvbGwiCiBtc2dzdHIgIm1hcmNhciBsYXMgc2VyaWVzIGNvbW8gTnRoIHJlLXJvbGwiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTU3OAorIzogYnVpbHRpbi9sb2cuYzoxNTc5CiBtc2dpZCAiVXNlIFtSRkMgUEFUQ0hdIGluc3RlYWQgb2YgW1BBVENIXSIKIG1zZ3N0ciAiVXNlIFtSRkMgUEFUQ0hdIGVuIGx1Z2FyIGRlIFtQQVRDSF0iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTU4MQorIzogYnVpbHRpbi9sb2cuYzoxNTgyCiBtc2dpZCAiVXNlIFs8cHJlZml4Pl0gaW5zdGVhZCBvZiBbUEFUQ0hdIgogbXNnc3RyICJVc2UgWzxwcmVmaWpvPl0gZW4gbHVnYXIgZGUgW1BBVENIXSIKIAotIzogYnVpbHRpbi9sb2cuYzoxNTg0CisjOiBidWlsdGluL2xvZy5jOjE1ODUKIG1zZ2lkICJzdG9yZSByZXN1bHRpbmcgZmlsZXMgaW4gPGRpcj4iCiBtc2dzdHIgImd1YXJkYXIgYXJjaGl2b3MgcmVzdWx0YW50ZXMgZW4gPGRpcj4iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTU4NworIzogYnVpbHRpbi9sb2cuYzoxNTg4CiBtc2dpZCAiZG9uJ3Qgc3RyaXAvYWRkIFtQQVRDSF0iCiBtc2dzdHIgIm5vIGNvcnRhci9hZ3JlZ2FyIFtQQVRDSF0iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTU5MAorIzogYnVpbHRpbi9sb2cuYzoxNTkxCiBtc2dpZCAiZG9uJ3Qgb3V0cHV0IGJpbmFyeSBkaWZmcyIKIG1zZ3N0ciAibm8gbW9zdHJhciBkaWZmcyBiaW5hcmlvcyIKIAotIzogYnVpbHRpbi9sb2cuYzoxNTkyCisjOiBidWlsdGluL2xvZy5jOjE1OTMKIG1zZ2lkICJvdXRwdXQgYWxsLXplcm8gaGFzaCBpbiBGcm9tIGhlYWRlciIKIG1zZ3N0ciAic2FsaWRhIGNvbW8gaGFzaCBkZSB0b2Rvcy1jZXJvcyBlbiBsYSBjYWJlY2VyYSBGcm9tIgogCi0jOiBidWlsdGluL2xvZy5jOjE1OTQKKyM6IGJ1aWx0aW4vbG9nLmM6MTU5NQogbXNnaWQgImRvbid0IGluY2x1ZGUgYSBwYXRjaCBtYXRjaGluZyBhIGNvbW1pdCB1cHN0cmVhbSIKIG1zZ3N0ciAibm8gaW5jbHV5YSB1biBwYXJjaGUgcXVlIGNvaW5jaWRhIGNvbiB1biBjb21taXQgZW4gdXBzdHJlYW0iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTU5NgorIzogYnVpbHRpbi9sb2cuYzoxNTk3CiBtc2dpZCAic2hvdyBwYXRjaCBmb3JtYXQgaW5zdGVhZCBvZiBkZWZhdWx0IChwYXRjaCArIHN0YXQpIgogbXNnc3RyICJtb3N0cmFyIGZvcm1hdG8gZGUgcGFyY2hlIGVuIGx1Z2FyIGRlbCBkZWZhdWx0IChwYXJjaGUgKyBzdGF0KSIKIAotIzogYnVpbHRpbi9sb2cuYzoxNTk4CisjOiBidWlsdGluL2xvZy5jOjE1OTkKIG1zZ2lkICJNZXNzYWdpbmciCiBtc2dzdHIgIk1lbnNhamVhbmRvIgogCi0jOiBidWlsdGluL2xvZy5jOjE1OTkKKyM6IGJ1aWx0aW4vbG9nLmM6MTYwMAogbXNnaWQgImhlYWRlciIKIG1zZ3N0ciAiY2FiZXphbCIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjAwCisjOiBidWlsdGluL2xvZy5jOjE2MDEKIG1zZ2lkICJhZGQgZW1haWwgaGVhZGVyIgogbXNnc3RyICJhZ3JlZ2FyIGNhYmVjZXJhIGVtYWlsIgogCi0jOiBidWlsdGluL2xvZy5jOjE2MDEgYnVpbHRpbi9sb2cuYzoxNjAzCisjOiBidWlsdGluL2xvZy5jOjE2MDIgYnVpbHRpbi9sb2cuYzoxNjA0CiBtc2dpZCAiZW1haWwiCiBtc2dzdHIgImVtYWlsIgogCi0jOiBidWlsdGluL2xvZy5jOjE2MDEKKyM6IGJ1aWx0aW4vbG9nLmM6MTYwMgogbXNnaWQgImFkZCBUbzogaGVhZGVyIgogbXNnc3RyICJhZ3JlZ2FyIGNhYmVjZXJhIFRvOiIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjAzCisjOiBidWlsdGluL2xvZy5jOjE2MDQKIG1zZ2lkICJhZGQgQ2M6IGhlYWRlciIKIG1zZ3N0ciAiYWdyZWdhciBjYWJlY2VyYSBDYzoiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTYwNQorIzogYnVpbHRpbi9sb2cuYzoxNjA2CiBtc2dpZCAiaWRlbnQiCiBtc2dzdHIgImlkZW50IgogCi0jOiBidWlsdGluL2xvZy5jOjE2MDYKKyM6IGJ1aWx0aW4vbG9nLmM6MTYwNwogbXNnaWQgInNldCBGcm9tIGFkZHJlc3MgdG8gPGlkZW50PiAob3IgY29tbWl0dGVyIGlkZW50IGlmIGFic2VudCkiCiBtc2dzdHIgIiIKICJjb25maWd1cmFyIGRpcmVjY2nDs24gRnJvbSBhIDxpZGVudD4gKCBvIGlkZW50aWRhZCBkZSBjb21taXR0ZXIgc2kgZXN0w6EgIgogImF1c2VudGUpIgogCi0jOiBidWlsdGluL2xvZy5jOjE2MDgKKyM6IGJ1aWx0aW4vbG9nLmM6MTYwOQogbXNnaWQgIm1lc3NhZ2UtaWQiCiBtc2dzdHIgImlkIGRlIG1lbnNhamUiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTYwOQorIzogYnVpbHRpbi9sb2cuYzoxNjEwCiBtc2dpZCAibWFrZSBmaXJzdCBtYWlsIGEgcmVwbHkgdG8gPG1lc3NhZ2UtaWQ+IgogbXNnc3RyICJoYWNlciBwcmltZXIgbWFpbCB1bmEgcmVzcHVlc3RhIGEgPGlkIGRlIG1lbnNhamU+IgogCi0jOiBidWlsdGluL2xvZy5jOjE2MTAgYnVpbHRpbi9sb2cuYzoxNjEzCisjOiBidWlsdGluL2xvZy5jOjE2MTEgYnVpbHRpbi9sb2cuYzoxNjE0CiBtc2dpZCAiYm91bmRhcnkiCiBtc2dzdHIgImzDrW1pdGUiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTYxMQorIzogYnVpbHRpbi9sb2cuYzoxNjEyCiBtc2dpZCAiYXR0YWNoIHRoZSBwYXRjaCIKIG1zZ3N0ciAiYWRqdW50YXIgZWwgcGFyY2hlIgogCi0jOiBidWlsdGluL2xvZy5jOjE2MTQKKyM6IGJ1aWx0aW4vbG9nLmM6MTYxNQogbXNnaWQgImlubGluZSB0aGUgcGF0Y2giCiBtc2dzdHIgInBvbmVyIGVsIHBhcmNoZSBlbiBsw61uZWEiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTYxOAorIzogYnVpbHRpbi9sb2cuYzoxNjE5CiBtc2dpZCAiZW5hYmxlIG1lc3NhZ2UgdGhyZWFkaW5nLCBzdHlsZXM6IHNoYWxsb3csIGRlZXAiCiBtc2dzdHIgImhhYmlsaXRhciBoaWxvcyBkZSBtZW5zYWplcywgZXN0aWxvczogc3VwZXJmaWNpYWwsIHByb2Z1bmRvIgogCi0jOiBidWlsdGluL2xvZy5jOjE2MjAKKyM6IGJ1aWx0aW4vbG9nLmM6MTYyMQogbXNnaWQgInNpZ25hdHVyZSIKIG1zZ3N0ciAiZmlybWEiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTYyMQorIzogYnVpbHRpbi9sb2cuYzoxNjIyCiBtc2dpZCAiYWRkIGEgc2lnbmF0dXJlIgogbXNnc3RyICJhZ3JlZ2FyIHVuYSBmaXJtYSIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjIyCisjOiBidWlsdGluL2xvZy5jOjE2MjMKIG1zZ2lkICJiYXNlLWNvbW1pdCIKIG1zZ3N0ciAiY29tbWl0LWJhc2UiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTYyMworIzogYnVpbHRpbi9sb2cuYzoxNjI0CiBtc2dpZCAiYWRkIHByZXJlcXVpc2l0ZSB0cmVlIGluZm8gdG8gdGhlIHBhdGNoIHNlcmllcyIKIG1zZ3N0ciAiIgogImFncmVnYXIgaW5mb3JtYWNpw7NuIGRlIMOhcmJvbCBkZSByZXF1aXNpdG9zIHByZXZpb3MgYSBsYSBzZXJpZSBkZSBwYXJjaGVzIgogCi0jOiBidWlsdGluL2xvZy5jOjE2MjUKKyM6IGJ1aWx0aW4vbG9nLmM6MTYyNgogbXNnaWQgImFkZCBhIHNpZ25hdHVyZSBmcm9tIGEgZmlsZSIKIG1zZ3N0ciAiYWdyZWdhciB1bmEgZmlybWEgZGUgdW4gYXJjaGl2byIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjI2CisjOiBidWlsdGluL2xvZy5jOjE2MjcKIG1zZ2lkICJkb24ndCBwcmludCB0aGUgcGF0Y2ggZmlsZW5hbWVzIgogbXNnc3RyICJubyBtb3N0cmFyIGxvcyBub21icmVzIGRlIGFyY2hpdm9zIGRlIGxvcyBwYXJjaGVzIgogCi0jOiBidWlsdGluL2xvZy5jOjE2MjgKKyM6IGJ1aWx0aW4vbG9nLmM6MTYyOQogbXNnaWQgInNob3cgcHJvZ3Jlc3Mgd2hpbGUgZ2VuZXJhdGluZyBwYXRjaGVzIgogbXNnc3RyICJtb3N0cmFyIG1lZGlkb3IgZGUgcHJvZ3Jlc28gbWllbnRyYXMgc2UgZ2VuZXJhbiBsb3MgcGFyY2hlcyIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjMwCisjOiBidWlsdGluL2xvZy5jOjE2MzEKIG1zZ2lkICJzaG93IGNoYW5nZXMgYWdhaW5zdCA8cmV2PiBpbiBjb3ZlciBsZXR0ZXIgb3Igc2luZ2xlIHBhdGNoIgogbXNnc3RyICJtdWVzdHJhIGNhbWJpb3MgY29udHJhIDxyZXY+IGVuIGNvdmVyIGxldHRlciBvIGVuIHVuIHNvbG8gcGFyY2hlIgogCi0jOiBidWlsdGluL2xvZy5jOjE2MzMKKyM6IGJ1aWx0aW4vbG9nLmM6MTYzNAogbXNnaWQgInNob3cgY2hhbmdlcyBhZ2FpbnN0IDxyZWZzcGVjPiBpbiBjb3ZlciBsZXR0ZXIgb3Igc2luZ2xlIHBhdGNoIgogbXNnc3RyICJtdWVzdHJhIGNhbWJpb3MgY29udHJhIDxyZWZzcGVjPiBlbiBjb3ZlciBsZXR0ZXIgbyBlbiB1biBzb2xvIHBhcmNoZSIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjM1CisjOiBidWlsdGluL2xvZy5jOjE2MzYKIG1zZ2lkICJwZXJjZW50YWdlIGJ5IHdoaWNoIGNyZWF0aW9uIGlzIHdlaWdodGVkIgogbXNnc3RyICJwb3JjZW50YWplIHBvciBlbCBjdWFsIGxhIGNyZWFjacOzbiBlcyBwZXNhZGEiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTcxMAorIzogYnVpbHRpbi9sb2cuYzoxNzExCiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgaWRlbnQgbGluZTogJXMiCiBtc2dzdHIgImzDrW5lYSBkZSBpZGVudGlmaWNhY2nDs24gaW52w6FsaWRhOiAlcyIKIAotIzogYnVpbHRpbi9sb2cuYzoxNzI1CisjOiBidWlsdGluL2xvZy5jOjE3MjYKIG1zZ2lkICItbiBhbmQgLWsgYXJlIG11dHVhbGx5IGV4Y2x1c2l2ZSIKIG1zZ3N0ciAiLW4geSAtayBzb24gbXV0dWFtZW50ZSBleGNsdXNpdmFzIgogCi0jOiBidWlsdGluL2xvZy5jOjE3MjcKKyM6IGJ1aWx0aW4vbG9nLmM6MTcyOAogbXNnaWQgIi0tc3ViamVjdC1wcmVmaXgvLS1yZmMgYW5kIC1rIGFyZSBtdXR1YWxseSBleGNsdXNpdmUiCiBtc2dzdHIgIi0tc3ViamVjdC1wcmVmaXgvLS1yZmMgeSAtayBzb24gbXV0dWFtZW50ZSBleGNsdXNpdm9zIgogCi0jOiBidWlsdGluL2xvZy5jOjE3MzUKKyM6IGJ1aWx0aW4vbG9nLmM6MTczNgogbXNnaWQgIi0tbmFtZS1vbmx5IGRvZXMgbm90IG1ha2Ugc2Vuc2UiCiBtc2dzdHIgIi0tbmFtZS1vbmx5IG5vIHRpZW5lIHNlbnRpZG8iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTczNworIzogYnVpbHRpbi9sb2cuYzoxNzM4CiBtc2dpZCAiLS1uYW1lLXN0YXR1cyBkb2VzIG5vdCBtYWtlIHNlbnNlIgogbXNnc3RyICItLW5hbWUtc3RhdHVzIG5vIHRpZW5lIHNlbnRpZG8iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTczOQorIzogYnVpbHRpbi9sb2cuYzoxNzQwCiBtc2dpZCAiLS1jaGVjayBkb2VzIG5vdCBtYWtlIHNlbnNlIgogbXNnc3RyICItLWNoZWNrIG5vIHRpZW5lIHNlbnRpZG8iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTc3MQorIzogYnVpbHRpbi9sb2cuYzoxNzczCiBtc2dpZCAic3RhbmRhcmQgb3V0cHV0LCBvciBkaXJlY3RvcnksIHdoaWNoIG9uZT8iCi1tc2dzdHIgInNhbGlkYSBzdGFuZGFyZCwgbyBkaXJlY3RvcmlvLCBjdWFsPyIKK21zZ3N0ciAiwr9zYWxpZGEgc3RhbmRhcmQsIG8gZGlyZWN0b3JpbywgY3VhbD8iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTg2MAorIzogYnVpbHRpbi9sb2cuYzoxODc3CiBtc2dpZCAiLS1pbnRlcmRpZmYgcmVxdWlyZXMgLS1jb3Zlci1sZXR0ZXIgb3Igc2luZ2xlIHBhdGNoIgogbXNnc3RyICItLWludGVyZGlmZiByZXF1aWVyZSAtLWNvdmVyLWxldHRlciBvIHVuIHBhcmNoZSDDum5pY28iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTg2NAorIzogYnVpbHRpbi9sb2cuYzoxODgxCiBtc2dpZCAiSW50ZXJkaWZmOiIKIG1zZ3N0ciAiSW50ZXJkaWZmOiIKIAotIzogYnVpbHRpbi9sb2cuYzoxODY1CisjOiBidWlsdGluL2xvZy5jOjE4ODIKICMsIGMtZm9ybWF0CiBtc2dpZCAiSW50ZXJkaWZmIGFnYWluc3QgdiVkOiIKIG1zZ3N0ciAiSW50ZXJkaWZmIGNvbnRyYSB2JWQ6IgogCi0jOiBidWlsdGluL2xvZy5jOjE4NzEKKyM6IGJ1aWx0aW4vbG9nLmM6MTg4OAogbXNnaWQgIi0tY3JlYXRpb24tZmFjdG9yIHJlcXVpcmVzIC0tcmFuZ2UtZGlmZiIKIG1zZ3N0ciAiLS1jcmVhdGlvbi1mYWN0b3IgcmVxdWllcmUgLS1yYW5nZS1kaWZmIgogCi0jOiBidWlsdGluL2xvZy5jOjE4NzUKKyM6IGJ1aWx0aW4vbG9nLmM6MTg5MgogbXNnaWQgIi0tcmFuZ2UtZGlmZiByZXF1aXJlcyAtLWNvdmVyLWxldHRlciBvciBzaW5nbGUgcGF0Y2giCiBtc2dzdHIgIi0tcmFuZ2UtZGlmZiByZXF1aWVyZSAtLWNvdmVyLWxldHRlciBvIHBhcmNoZSDDum5pY28iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTg4MworIzogYnVpbHRpbi9sb2cuYzoxOTAwCiBtc2dpZCAiUmFuZ2UtZGlmZjoiCiBtc2dzdHIgIlJhbmdlLWRpZmY6IgogCi0jOiBidWlsdGluL2xvZy5jOjE4ODQKKyM6IGJ1aWx0aW4vbG9nLmM6MTkwMQogIywgYy1mb3JtYXQKIG1zZ2lkICJSYW5nZS1kaWZmIGFnYWluc3QgdiVkOiIKIG1zZ3N0ciAiUmFuZ2UtZGlmZiBjb250cmEgdiVkOiIKIAotIzogYnVpbHRpbi9sb2cuYzoxODk1CisjOiBidWlsdGluL2xvZy5jOjE5MTIKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHJlYWQgc2lnbmF0dXJlIGZpbGUgJyVzJyIKIG1zZ3N0ciAibm8gc2UgcHVlZGUgbGVlciBsYSBmaXJtYSBkZWwgYXJjaGl2byAnJXMnIgogCi0jOiBidWlsdGluL2xvZy5jOjE5MzEKKyM6IGJ1aWx0aW4vbG9nLmM6MTk0OAogbXNnaWQgIkdlbmVyYXRpbmcgcGF0Y2hlcyIKIG1zZ3N0ciAiR2VuZXJhbmRvIHBhcmNoZXMiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTk3NQorIzogYnVpbHRpbi9sb2cuYzoxOTkyCiBtc2dpZCAiZmFpbGVkIHRvIGNyZWF0ZSBvdXRwdXQgZmlsZXMiCiBtc2dzdHIgImZhbGzDsyBhbCBjcmVhciBsb3MgYXJjaGl2b3MgZGUgc2FsaWRhIgogCi0jOiBidWlsdGluL2xvZy5jOjIwMzQKKyM6IGJ1aWx0aW4vbG9nLmM6MjA1MQogbXNnaWQgImdpdCBjaGVycnkgWy12XSBbPHVwc3RyZWFtPiBbPGhlYWQ+IFs8bGltaXQ+XV1dIgogbXNnc3RyICJnaXQgY2hlcnJ5IFstdl0gWzx1cHN0cmVhbT4gWzxoZWFkPiBbPGzDrW1pdGU+XV1dIgogCi0jOiBidWlsdGluL2xvZy5jOjIwODgKKyM6IGJ1aWx0aW4vbG9nLmM6MjEwNQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiQ291bGQgbm90IGZpbmQgYSB0cmFja2VkIHJlbW90ZSBicmFuY2gsIHBsZWFzZSBzcGVjaWZ5IDx1cHN0cmVhbT4gbWFudWFsbHkuXG4iCkBAIC0xNDg0OCw3ICsxNDkzMCw3IEBACiBtc2dpZCAiZG8gbm90IHByaW50IHJlbW90ZSBVUkwiCiBtc2dzdHIgIm5vIG1vc3RyYXIgZWwgVVJMIHJlbW90byIKIAotIzogYnVpbHRpbi9scy1yZW1vdGUuYzo2MCBidWlsdGluL2xzLXJlbW90ZS5jOjYyIGJ1aWx0aW4vcmViYXNlLmM6MTQ2NAorIzogYnVpbHRpbi9scy1yZW1vdGUuYzo2MCBidWlsdGluL2xzLXJlbW90ZS5jOjYyIGJ1aWx0aW4vcmViYXNlLmM6MTQ4OAogbXNnaWQgImV4ZWMiCiBtc2dzdHIgImVqZWN1dGFyIgogCkBAIC0xNDk1OCwzMyArMTUwNDAsMzMgQEAKIG1zZ2lkICJBdmFpbGFibGUgY3VzdG9tIHN0cmF0ZWdpZXMgYXJlOiIKIG1zZ3N0ciAiRXN0cmF0ZWdpYXMgcGVyc29uYWxpemFkYXMgZGlzcG9uaWJsZXMgc29uOiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjI0NCBidWlsdGluL3B1bGwuYzoxNTEKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoyNDQgYnVpbHRpbi9wdWxsLmM6MTUyCiBtc2dpZCAiZG8gbm90IHNob3cgYSBkaWZmc3RhdCBhdCB0aGUgZW5kIG9mIHRoZSBtZXJnZSIKIG1zZ3N0ciAibm8gbW9zdHJhciB1biBkaWZmc3RhdCBhbCBmaW5hbCBkZSBsYSBmdXNpw7NuIgogCi0jOiBidWlsdGluL21lcmdlLmM6MjQ3IGJ1aWx0aW4vcHVsbC5jOjE1NAorIzogYnVpbHRpbi9tZXJnZS5jOjI0NyBidWlsdGluL3B1bGwuYzoxNTUKIG1zZ2lkICJzaG93IGEgZGlmZnN0YXQgYXQgdGhlIGVuZCBvZiB0aGUgbWVyZ2UiCiBtc2dzdHIgIm1vc3RyYXIgdW4gZGlmZnN0YXQgYWwgZmluYWwgZGUgbGEgZnVzacOzbiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjI0OCBidWlsdGluL3B1bGwuYzoxNTcKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoyNDggYnVpbHRpbi9wdWxsLmM6MTU4CiBtc2dpZCAiKHN5bm9ueW0gdG8gLS1zdGF0KSIKIG1zZ3N0ciAiKHNpbsOzbmltbyBwYXJhIC0tc3RhdCkiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoyNTAgYnVpbHRpbi9wdWxsLmM6MTYwCisjOiBidWlsdGluL21lcmdlLmM6MjUwIGJ1aWx0aW4vcHVsbC5jOjE2MQogbXNnaWQgImFkZCAoYXQgbW9zdCA8bj4pIGVudHJpZXMgZnJvbSBzaG9ydGxvZyB0byBtZXJnZSBjb21taXQgbWVzc2FnZSIKIG1zZ3N0ciAiIgogImFncmVnYXIgKGNvbW8gbcOheGltbyA8bj4pIGVudHJhZGFzIGRlbCBzaG9ydGxvZyBhbCBtZW5zYWplIGRlbCBjb21taXQgZGUgIgogImZ1c2nDs24iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoyNTMgYnVpbHRpbi9wdWxsLmM6MTY2CisjOiBidWlsdGluL21lcmdlLmM6MjUzIGJ1aWx0aW4vcHVsbC5jOjE2NwogbXNnaWQgImNyZWF0ZSBhIHNpbmdsZSBjb21taXQgaW5zdGVhZCBvZiBkb2luZyBhIG1lcmdlIgogbXNnc3RyICJjcmVhciB1biBjb21taXQgw7puaWNvIGVuIGx1Z2FyIGRlIGhhY2VyIHVuYSBmdXNpw7NuIgogCi0jOiBidWlsdGluL21lcmdlLmM6MjU1IGJ1aWx0aW4vcHVsbC5jOjE2OQorIzogYnVpbHRpbi9tZXJnZS5jOjI1NSBidWlsdGluL3B1bGwuYzoxNzAKIG1zZ2lkICJwZXJmb3JtIGEgY29tbWl0IGlmIHRoZSBtZXJnZSBzdWNjZWVkcyAoZGVmYXVsdCkiCiBtc2dzdHIgInJlYWxpemFyIHVuIGNvbW1pdCBzaSBsYSBmdXNpw7NuIGVzIGV4aXRvc2EgKGRlZmF1bHQpIgogCi0jOiBidWlsdGluL21lcmdlLmM6MjU3IGJ1aWx0aW4vcHVsbC5jOjE3MgorIzogYnVpbHRpbi9tZXJnZS5jOjI1NyBidWlsdGluL3B1bGwuYzoxNzMKIG1zZ2lkICJlZGl0IG1lc3NhZ2UgYmVmb3JlIGNvbW1pdHRpbmciCiBtc2dzdHIgImVkaXRhciBtZW5zYWplIGFudGVzIGRlIHJlYWxpemFyIGNvbW1pdCIKIApAQCAtMTQ5OTIsMjggKzE1MDc0LDI4IEBACiBtc2dpZCAiYWxsb3cgZmFzdC1mb3J3YXJkIChkZWZhdWx0KSIKIG1zZ3N0ciAicGVybWl0aXIgZmFzdC1mb3J3YXJzIChkZWZhdWx0KSIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjI2MSBidWlsdGluL3B1bGwuYzoxNzkKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoyNjEgYnVpbHRpbi9wdWxsLmM6MTgwCiBtc2dpZCAiYWJvcnQgaWYgZmFzdC1mb3J3YXJkIGlzIG5vdCBwb3NzaWJsZSIKIG1zZ3N0ciAiYWJvcnRhciBzaSBmYXN0LWZvcndhcmQgbm8gZXMgcG9zaWJsZSIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjI2NSBidWlsdGluL3B1bGwuYzoxODIKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoyNjUgYnVpbHRpbi9wdWxsLmM6MTgzCiBtc2dpZCAidmVyaWZ5IHRoYXQgdGhlIG5hbWVkIGNvbW1pdCBoYXMgYSB2YWxpZCBHUEcgc2lnbmF0dXJlIgogbXNnc3RyICJ2ZXJpZmljYXIgcXVlIGVsIGNvbW1pdCBub21icmFkbyB0aWVuZSB1bmEgZmlybWEgR1BHIHbDoWxpZGEiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoyNjYgYnVpbHRpbi9ub3Rlcy5jOjc4NyBidWlsdGluL3B1bGwuYzoxODYKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDkyIGJ1aWx0aW4vcmViYXNlLmM6MTQ3NyBidWlsdGluL3JldmVydC5jOjExNAorIzogYnVpbHRpbi9tZXJnZS5jOjI2NiBidWlsdGluL25vdGVzLmM6Nzg3IGJ1aWx0aW4vcHVsbC5jOjE4NworIzogYnVpbHRpbi9yZWJhc2UuYzo0OTMgYnVpbHRpbi9yZWJhc2UuYzoxNTAxIGJ1aWx0aW4vcmV2ZXJ0LmM6MTE0CiBtc2dpZCAic3RyYXRlZ3kiCiBtc2dzdHIgImVzdHJhdGVnaWEiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoyNjcgYnVpbHRpbi9wdWxsLmM6MTg3CisjOiBidWlsdGluL21lcmdlLmM6MjY3IGJ1aWx0aW4vcHVsbC5jOjE4OAogbXNnaWQgIm1lcmdlIHN0cmF0ZWd5IHRvIHVzZSIKIG1zZ3N0ciAiZXN0cmF0ZWdpYSBkZSBmdXNpw7NuIHBhcmEgdXNhciIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjI2OCBidWlsdGluL3B1bGwuYzoxOTAKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoyNjggYnVpbHRpbi9wdWxsLmM6MTkxCiBtc2dpZCAib3B0aW9uPXZhbHVlIgogbXNnc3RyICJvcGNpw7NuPXZhbG9yIgogCi0jOiBidWlsdGluL21lcmdlLmM6MjY5IGJ1aWx0aW4vcHVsbC5jOjE5MQorIzogYnVpbHRpbi9tZXJnZS5jOjI2OSBidWlsdGluL3B1bGwuYzoxOTIKIG1zZ2lkICJvcHRpb24gZm9yIHNlbGVjdGVkIG1lcmdlIHN0cmF0ZWd5IgogbXNnc3RyICJvcGNpw7NuIHBhcmEgbGEgZXN0cmF0ZWdpYSBkZSBmdXNpw7NuIHNlbGVjY2lvbmFkYSIKIApAQCAtMTUwMzMsMTMgKzE1MTE1LDEzIEBACiBtc2dpZCAiY29udGludWUgdGhlIGN1cnJlbnQgaW4tcHJvZ3Jlc3MgbWVyZ2UiCiBtc2dzdHIgImNvbnRpbnVhciBsYSBmdXNpw7NuIGVuIHByb2dyZXNvIGFjdHVhbCIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjI4NCBidWlsdGluL3B1bGwuYzoxOTgKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoyODQgYnVpbHRpbi9wdWxsLmM6MTk5CiBtc2dpZCAiYWxsb3cgbWVyZ2luZyB1bnJlbGF0ZWQgaGlzdG9yaWVzIgogbXNnc3RyICJwZXJtaXRpciBmdXNpb25hciBoaXN0b3JpYXMgbm8gcmVsYWNpb25hZGFzIgogCiAjOiBidWlsdGluL21lcmdlLmM6MjkwCi1tc2dpZCAidmVyaWZ5IGNvbW1pdC1tc2cgaG9vayIKLW1zZ3N0ciAidmVyaWZpY2FyIGVsIGhvb2sgY29tbWl0LW1zZyIKK21zZ2lkICJieXBhc3MgcHJlLW1lcmdlLWNvbW1pdCBhbmQgY29tbWl0LW1zZyBob29rcyIKK21zZ3N0ciAiaGFjZXIgdW4gYnlwYXNzIGEgaG9va3MgcHJlLW1lcmdlLWNvbW1pdCB5IGNvbW1pdC1tc2ciCiAKICM6IGJ1aWx0aW4vbWVyZ2UuYzozMDcKIG1zZ2lkICJjb3VsZCBub3QgcnVuIHN0YXNoLiIKQEAgLTE1MDgyLDMzICsxNTE2NCwzMyBAQAogbXNnaWQgIkJhZCBicmFuY2guJXMubWVyZ2VvcHRpb25zIHN0cmluZzogJXMiCiBtc2dzdHIgIk1hbCBzdHJpbmcgYnJhbmNoLiVzLm1lcmdlb3B0aW9uczogJXMiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzo3MDgKKyM6IGJ1aWx0aW4vbWVyZ2UuYzo3MDUKIG1zZ2lkICJOb3QgaGFuZGxpbmcgYW55dGhpbmcgb3RoZXIgdGhhbiB0d28gaGVhZHMgbWVyZ2UuIgogbXNnc3RyICJObyBtYW5lamFuZG8gbmFkYSBtw6FzIHF1ZSBmdXNpw7NuIGRlIGRvcyBoZWFkcy4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzo3MjIKKyM6IGJ1aWx0aW4vbWVyZ2UuYzo3MTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiVW5rbm93biBvcHRpb24gZm9yIG1lcmdlLXJlY3Vyc2l2ZTogLVglcyIKIG1zZ3N0ciAiT3BjacOzbiBkZXNjb25vY2lkYSBwYXJhIG1lcmdlLXJlY3Vyc2l2ZTogLVglcyIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjczNworIzogYnVpbHRpbi9tZXJnZS5jOjczNAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gd3JpdGUgJXMiCiBtc2dzdHIgIm5vIGVzIHBvc2libGUgZXNjcmliaXIgJXMiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzo3ODkKKyM6IGJ1aWx0aW4vbWVyZ2UuYzo3ODYKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ291bGQgbm90IHJlYWQgZnJvbSAnJXMnIgogbXNnc3RyICJObyBzZSBwdWVkbyBsZWVyIGRlICclcyciCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzo3OTgKKyM6IGJ1aWx0aW4vbWVyZ2UuYzo3OTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiTm90IGNvbW1pdHRpbmcgbWVyZ2U7IHVzZSAnZ2l0IGNvbW1pdCcgdG8gY29tcGxldGUgdGhlIG1lcmdlLlxuIgogbXNnc3RyICIiCiAiTm8gc2UgcmVhbGl6YSBjb21taXQgZGUgbGEgZnVzacOzbjsgdXNlICdnaXQgY29tbWl0JyBwYXJhIGNvbXBsZXRhciBsYSAiCiAiZnVzacOzbi5cbiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjgwNAorIzogYnVpbHRpbi9tZXJnZS5jOjgwMQogbXNnaWQgIiIKICJQbGVhc2UgZW50ZXIgYSBjb21taXQgbWVzc2FnZSB0byBleHBsYWluIHdoeSB0aGlzIG1lcmdlIGlzIG5lY2Vzc2FyeSxcbiIKICJlc3BlY2lhbGx5IGlmIGl0IG1lcmdlcyBhbiB1cGRhdGVkIHVwc3RyZWFtIGludG8gYSB0b3BpYyBicmFuY2guXG4iCkBAIC0xNTEyMCwxMSArMTUyMDIsMTEgQEAKICJ0w7NwaWNvLlxuIgogIlxuIgogCi0jOiBidWlsdGluL21lcmdlLmM6ODA5CisjOiBidWlsdGluL21lcmdlLmM6ODA2CiBtc2dpZCAiQW4gZW1wdHkgbWVzc2FnZSBhYm9ydHMgdGhlIGNvbW1pdC5cbiIKIG1zZ3N0ciAiVW4gbWVuc2FqZSB2YWPDrW8gYWJvcnRhIGVsIGNvbW1pdC5cbiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjgxMgorIzogYnVpbHRpbi9tZXJnZS5jOjgwOQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiTGluZXMgc3RhcnRpbmcgd2l0aCAnJWMnIHdpbGwgYmUgaWdub3JlZCwgYW5kIGFuIGVtcHR5IG1lc3NhZ2UgYWJvcnRzXG4iCkBAIC0xNTEzMyw3NCArMTUyMTUsNzQgQEAKICJMw61uZWFzIGNvbWVuemFuZG8gY29uICclYycgc2Vyw6FuIGlnbm9yYWRhcywgeSB1biBtZW5zYWplIHZhY8OtbyBhYm9ydGFcbiIKICIgZWwgY29tbWl0LlxuIgogCi0jOiBidWlsdGluL21lcmdlLmM6ODUzCisjOiBidWlsdGluL21lcmdlLmM6ODYyCiBtc2dpZCAiRW1wdHkgY29tbWl0IG1lc3NhZ2UuIgogbXNnc3RyICJNZW5zYWplIGRlIGNvbW1pdCB2YWPDrW8uIgogCi0jOiBidWlsdGluL21lcmdlLmM6ODcyCisjOiBidWlsdGluL21lcmdlLmM6ODc3CiAjLCBjLWZvcm1hdAogbXNnaWQgIldvbmRlcmZ1bC5cbiIKIG1zZ3N0ciAiTWFyYXZpbGxvc28uXG4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzo5MzMKKyM6IGJ1aWx0aW4vbWVyZ2UuYzo5MzgKICMsIGMtZm9ybWF0CiBtc2dpZCAiQXV0b21hdGljIG1lcmdlIGZhaWxlZDsgZml4IGNvbmZsaWN0cyBhbmQgdGhlbiBjb21taXQgdGhlIHJlc3VsdC5cbiIKIG1zZ3N0ciAiIgogIkZ1c2nDs24gYXV0b23DoXRpY2EgZmFsbMOzOyBhcnJlZ2xlIGxvcyBjb25mbGljdG9zIHkgbHVlZ28gcmVhbGljZSB1biBjb21taXQgIgogImNvbiBlbCByZXN1bHRhZG8uXG4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzo5NzIKKyM6IGJ1aWx0aW4vbWVyZ2UuYzo5NzcKIG1zZ2lkICJObyBjdXJyZW50IGJyYW5jaC4iCiBtc2dzdHIgIk5vIHJhbWEgYWN0dWFsLiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjk3NAorIzogYnVpbHRpbi9tZXJnZS5jOjk3OQogbXNnaWQgIk5vIHJlbW90ZSBmb3IgdGhlIGN1cnJlbnQgYnJhbmNoLiIKIG1zZ3N0ciAiTm8gaGF5IHJlbW90byBwYXJhIGxhIHJhbWEgYWN0dWFsLiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjk3NgorIzogYnVpbHRpbi9tZXJnZS5jOjk4MQogbXNnaWQgIk5vIGRlZmF1bHQgdXBzdHJlYW0gZGVmaW5lZCBmb3IgdGhlIGN1cnJlbnQgYnJhbmNoLiIKIG1zZ3N0ciAiUG9yIGRlZmVjdG8sIG5vIGhheSB1biB1cHN0cmVhbSAgZGVmaW5pZG8gcGFyYSBsYSByYW1hIGFjdHVhbC4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzo5ODEKKyM6IGJ1aWx0aW4vbWVyZ2UuYzo5ODYKICMsIGMtZm9ybWF0CiBtc2dpZCAiTm8gcmVtb3RlLXRyYWNraW5nIGJyYW5jaCBmb3IgJXMgZnJvbSAlcyIKIG1zZ3N0ciAiTm8gaGF5IHJhbWEgZGUgcmFzdHJlbyByZW1vdG8gcGFyYSAlcyBkZSAlcyIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjEwMzgKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxMDQzCiAjLCBjLWZvcm1hdAogbXNnaWQgIkJhZCB2YWx1ZSAnJXMnIGluIGVudmlyb25tZW50ICclcyciCiBtc2dzdHIgIlZhbG9yIGVycsOzbmVvICclcycgZW4gZWwgZW50b3JubyAnJXMnIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTE0MQorIzogYnVpbHRpbi9tZXJnZS5jOjExNDYKICMsIGMtZm9ybWF0CiBtc2dpZCAibm90IHNvbWV0aGluZyB3ZSBjYW4gbWVyZ2UgaW4gJXM6ICVzIgogbXNnc3RyICJuYWRhIHF1ZSBwb2RhbW9zIGZ1c2lvbmFyIGVuICVzOiAlcyIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjExNzUKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxMTgwCiBtc2dpZCAibm90IHNvbWV0aGluZyB3ZSBjYW4gbWVyZ2UiCiBtc2dzdHIgIm5hZGEgcXVlIHBvZGFtb3MgZnVzaW9uYXIiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxMjc4CisjOiBidWlsdGluL21lcmdlLmM6MTI4MwogbXNnaWQgIi0tYWJvcnQgZXhwZWN0cyBubyBhcmd1bWVudHMiCiBtc2dzdHIgIi0tYWJvcnQgbm8gZXNwZXJhIGFyZ3VtZW50b3MiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxMjgyCisjOiBidWlsdGluL21lcmdlLmM6MTI4NwogbXNnaWQgIlRoZXJlIGlzIG5vIG1lcmdlIHRvIGFib3J0IChNRVJHRV9IRUFEIG1pc3NpbmcpLiIKIG1zZ3N0ciAiTm8gaGF5IHVuYSBmdXNpw7NuIHBhcmEgYWJvcnRhciAoZmFsdGEgTUVSR0VfSEVBRCkiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxMjkxCisjOiBidWlsdGluL21lcmdlLmM6MTI5NgogbXNnaWQgIi0tcXVpdCBleHBlY3RzIG5vIGFyZ3VtZW50cyIKIG1zZ3N0ciAiLS1xdWl0IG5vIGVzcGVyYSBhcmd1bWVudG9zIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTMwNAorIzogYnVpbHRpbi9tZXJnZS5jOjEzMDkKIG1zZ2lkICItLWNvbnRpbnVlIGV4cGVjdHMgbm8gYXJndW1lbnRzIgogbXNnc3RyICItLWNvbnRpbnVlIG5vIGVzcGVyYSBhcmd1bWVudG9zIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTMwOAorIzogYnVpbHRpbi9tZXJnZS5jOjEzMTMKIG1zZ2lkICJUaGVyZSBpcyBubyBtZXJnZSBpbiBwcm9ncmVzcyAoTUVSR0VfSEVBRCBtaXNzaW5nKS4iCiBtc2dzdHIgIk5vIGhheSBmdXNpw7NuIGVuIHByb2dyZXNvIChmYWx0YSBNRVJHRV9IRUFEKS4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzI0CisjOiBidWlsdGluL21lcmdlLmM6MTMyOQogbXNnaWQgIiIKICJZb3UgaGF2ZSBub3QgY29uY2x1ZGVkIHlvdXIgbWVyZ2UgKE1FUkdFX0hFQUQgZXhpc3RzKS5cbiIKICJQbGVhc2UsIGNvbW1pdCB5b3VyIGNoYW5nZXMgYmVmb3JlIHlvdSBtZXJnZS4iCkBAIC0xNTIwOCw3ICsxNTI5MCw3IEBACiAiTm8gaGFzIGNvbmNsdWlkbyBsYSBmdXNpw7NuIChleGlzdGUgTUVSR0VfSEVBRCkuXG4iCiAiUG9yIGZhdm9yLCByZWFsaXphIHVuIGNvbW1pdCBjb24gbG9zIGNhbWJpb3MgYW50ZXMgZGUgZnVzaW9uYXIuIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTMzMQorIzogYnVpbHRpbi9tZXJnZS5jOjEzMzYKIG1zZ2lkICIiCiAiWW91IGhhdmUgbm90IGNvbmNsdWRlZCB5b3VyIGNoZXJyeS1waWNrIChDSEVSUllfUElDS19IRUFEIGV4aXN0cykuXG4iCiAiUGxlYXNlLCBjb21taXQgeW91ciBjaGFuZ2VzIGJlZm9yZSB5b3UgbWVyZ2UuIgpAQCAtMTUyMTYsOTcgKzE1Mjk4LDk3IEBACiAiTm8gaGFzIGNvbmNsdWlkbyBlbCBjaGVycnktcGljayAoZXhpc3RlIENIRVJSWV9QSUNLX0hFQUQpLlxuIgogIlBvciBmYXZvciwgcmVhbGl6YSB1biBjb21taXQgY29uIGxvcyBjYW1iaW9zIGFudGVzIGRlIGZ1c2lvbmFyLiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjEzMzQKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzM5CiBtc2dpZCAiWW91IGhhdmUgbm90IGNvbmNsdWRlZCB5b3VyIGNoZXJyeS1waWNrIChDSEVSUllfUElDS19IRUFEIGV4aXN0cykuIgogbXNnc3RyICJObyBoYXMgY29uY2x1aWRvIGVsIGNoZXJyeS1waWNrIChleGlzdGUgQ0hFUlJZX1BJQ0tfSEVBRCkuIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTM0OAorIzogYnVpbHRpbi9tZXJnZS5jOjEzNTMKIG1zZ2lkICJZb3UgY2Fubm90IGNvbWJpbmUgLS1zcXVhc2ggd2l0aCAtLW5vLWZmLiIKIG1zZ3N0ciAiTm8gc2UgcHVlZGUgY29tYmluYXIgLS1zcXVhc2ggY29uIC0tbm8tZmYuIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTM1MAorIzogYnVpbHRpbi9tZXJnZS5jOjEzNTUKIG1zZ2lkICJZb3UgY2Fubm90IGNvbWJpbmUgLS1zcXVhc2ggd2l0aCAtLWNvbW1pdC4iCiBtc2dzdHIgIk5vIHNlIHB1ZWRlIGNvbWJpbmFyIC0tc3F1YXNoIGNvbiAtLWNvbW1pdC4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzY2CisjOiBidWlsdGluL21lcmdlLmM6MTM3MQogbXNnaWQgIk5vIGNvbW1pdCBzcGVjaWZpZWQgYW5kIG1lcmdlLmRlZmF1bHRUb1Vwc3RyZWFtIG5vdCBzZXQuIgogbXNnc3RyICIiCiAiTm8gaGF5IGNvbW1pdCBlc3BlY2lmaWNhZG8geSBtZXJnZS5kZWZhdWx0VG9VcHN0cmVhbSBubyBlc3TDoSBjb25maWd1cmFkby4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzgzCisjOiBidWlsdGluL21lcmdlLmM6MTM4OAogbXNnaWQgIlNxdWFzaCBjb21taXQgaW50byBlbXB0eSBoZWFkIG5vdCBzdXBwb3J0ZWQgeWV0IgogbXNnc3RyICJDb21taXQgYXBsYXN0YWRvIGRlbnRybyBkZSB1biBoZWFkIHZhY8OtbyBubyBlcyBzb3BvcnRhZG8gdG9kYXbDrWEiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzg1CisjOiBidWlsdGluL21lcmdlLmM6MTM5MAogbXNnaWQgIk5vbi1mYXN0LWZvcndhcmQgY29tbWl0IGRvZXMgbm90IG1ha2Ugc2Vuc2UgaW50byBhbiBlbXB0eSBoZWFkIgogbXNnc3RyICJDb21taXQgbm8gZmFzdC1mb3J3YXJkIG5vIHRpZW5lIHNlbnRpZG8gZGVudHJvIGRlIHVuIGhlYWQgdmFjw61vIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTM5MAorIzogYnVpbHRpbi9tZXJnZS5jOjEzOTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgLSBub3Qgc29tZXRoaW5nIHdlIGNhbiBtZXJnZSIKIG1zZ3N0ciAiJXMgLSBuYWRhIHF1ZSBwb2RhbW9zIGZ1c2lvbmFyIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTM5MgorIzogYnVpbHRpbi9tZXJnZS5jOjEzOTcKIG1zZ2lkICJDYW4gbWVyZ2Ugb25seSBleGFjdGx5IG9uZSBjb21taXQgaW50byBlbXB0eSBoZWFkIgogbXNnc3RyICJTb2xvIHNlIHB1ZWRlIGZ1c2lvbmFyIGV4YWN0YW1lbnRlIHVuIGNvbW1pdCBlbiB1biBoZWFkIHZhY8OtbyIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjE0NzEKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxNDc2CiBtc2dpZCAicmVmdXNpbmcgdG8gbWVyZ2UgdW5yZWxhdGVkIGhpc3RvcmllcyIKIG1zZ3N0ciAicmVodXNhbmRvIGZ1c2lvbmFyIGhpc3RvcmlhcyBubyByZWxhY2lvbmFkYXMiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxNDgwCisjOiBidWlsdGluL21lcmdlLmM6MTQ4NQogbXNnaWQgIkFscmVhZHkgdXAgdG8gZGF0ZS4iCiBtc2dzdHIgIllhIGVzdMOhIGFjdHVhbGl6YWRvLiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjE0OTAKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxNDk1CiAjLCBjLWZvcm1hdAogbXNnaWQgIlVwZGF0aW5nICVzLi4lc1xuIgogbXNnc3RyICJBY3R1YWxpemFuZG8gJXMuLiVzXG4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxNTMyCisjOiBidWlsdGluL21lcmdlLmM6MTUzNwogIywgYy1mb3JtYXQKIG1zZ2lkICJUcnlpbmcgcmVhbGx5IHRyaXZpYWwgaW4taW5kZXggbWVyZ2UuLi5cbiIKIG1zZ3N0ciAiSW50ZW50YW5kbyBmdXNpw7NuIGVuIMOtbmRpY2UgcmVhbG1lbnRlIHRyaXZpYWwuLi5cbiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjE1MzkKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxNTQ0CiAjLCBjLWZvcm1hdAogbXNnaWQgIk5vcGUuXG4iCiBtc2dzdHIgIk5vcC5cbiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjE1NjQKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxNTY5CiBtc2dpZCAiQWxyZWFkeSB1cCB0byBkYXRlLiBZZWVhaCEiCiBtc2dzdHIgIllhIGVzdMOhIGFjdHVhbGl6YWRvLiDCoU9oLCB5ZWFhaGghIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTU3MAorIzogYnVpbHRpbi9tZXJnZS5jOjE1NzUKIG1zZ2lkICJOb3QgcG9zc2libGUgdG8gZmFzdC1mb3J3YXJkLCBhYm9ydGluZy4iCiBtc2dzdHIgIk5vIGVzIHBvc2libGUgaGFjZXIgZmFzdC1mb3J3YXJkLCBhYm9ydGFuZG8uIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTU5MyBidWlsdGluL21lcmdlLmM6MTY1OAorIzogYnVpbHRpbi9tZXJnZS5jOjE1OTggYnVpbHRpbi9tZXJnZS5jOjE2NjMKICMsIGMtZm9ybWF0CiBtc2dpZCAiUmV3aW5kaW5nIHRoZSB0cmVlIHRvIHByaXN0aW5lLi4uXG4iCiBtc2dzdHIgIlJlYm9iaW5hbmRvIGVsIMOhcmJvbCBhIG9yaWdpbmFsLi4uXG4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxNTk3CisjOiBidWlsdGluL21lcmdlLmM6MTYwMgogIywgYy1mb3JtYXQKIG1zZ2lkICJUcnlpbmcgbWVyZ2Ugc3RyYXRlZ3kgJXMuLi5cbiIKIG1zZ3N0ciAiSW50ZW50YW5kbyBlc3RyYXRlZ2lhIGRlIGZ1c2nDs24gJXMuLi5cbiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjE2NDkKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxNjU0CiAjLCBjLWZvcm1hdAogbXNnaWQgIk5vIG1lcmdlIHN0cmF0ZWd5IGhhbmRsZWQgdGhlIG1lcmdlLlxuIgogbXNnc3RyICJOaW5ndW5hIGVzdHJhdGVnaWEgZGUgZnVzacOzbiBtYW5lasOzIGxhIGZ1c2nDs24uXG4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxNjUxCisjOiBidWlsdGluL21lcmdlLmM6MTY1NgogIywgYy1mb3JtYXQKIG1zZ2lkICJNZXJnZSB3aXRoIHN0cmF0ZWd5ICVzIGZhaWxlZC5cbiIKIG1zZ3N0ciAiRnVzaW9uYXIgY29uIGVzdHJhdGVnaWEgJXMgZmFsbMOzLlxuIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTY2MAorIzogYnVpbHRpbi9tZXJnZS5jOjE2NjUKICMsIGMtZm9ybWF0CiBtc2dpZCAiVXNpbmcgdGhlICVzIHRvIHByZXBhcmUgcmVzb2x2aW5nIGJ5IGhhbmQuXG4iCiBtc2dzdHIgIlVzYW5kbyBlbCAlcyBwYXJhIHByZXBhcmFyIHJlc29sdWNpw7NuIGEgbWFuby5cbiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjE2NzIKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxNjc3CiAjLCBjLWZvcm1hdAogbXNnaWQgIkF1dG9tYXRpYyBtZXJnZSB3ZW50IHdlbGw7IHN0b3BwZWQgYmVmb3JlIGNvbW1pdHRpbmcgYXMgcmVxdWVzdGVkXG4iCiBtc2dzdHIgIiIKQEAgLTE1MzQ2LDcgKzE1NDI4LDcgQEAKIAogIzogYnVpbHRpbi9tZXJnZS1iYXNlLmM6MTU5CiBtc2dpZCAiaXMgdGhlIGZpcnN0IG9uZSBhbmNlc3RvciBvZiB0aGUgb3RoZXI/IgotbXNnc3RyICJlcyBlbCBwcmltZXIgYW5jZXN0cm8gZGVsIG90cm8/IgorbXNnc3RyICLCv2VzIGVsIHByaW1lciBhbmNlc3RybyBkZWwgb3Rybz8iCiAKICM6IGJ1aWx0aW4vbWVyZ2UtYmFzZS5jOjE2MQogbXNnaWQgImZpbmQgd2hlcmUgPGNvbW1pdD4gZm9ya2VkIGZyb20gcmVmbG9nIG9mIDxyZWY+IgpAQCAtMTUzOTIsMzMgKzE1NDc0LDMzIEBACiBtc2dpZCAic2V0IGxhYmVscyBmb3IgZmlsZTEvb3JpZy1maWxlL2ZpbGUyIgogbXNnc3RyICJjb25maWd1cmFyIGxhYmVscyBwYXJhIGFyY2hpdm8xL29yaWctYXJjaGl2by9hcmNoaXZvMiIKIAotIzogYnVpbHRpbi9tZXJnZS1yZWN1cnNpdmUuYzo0NgorIzogYnVpbHRpbi9tZXJnZS1yZWN1cnNpdmUuYzo0NwogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmtub3duIG9wdGlvbiAlcyIKIG1zZ3N0ciAib3BjacOzbiAlcyBkZXNjb25vY2lkYSIKIAotIzogYnVpbHRpbi9tZXJnZS1yZWN1cnNpdmUuYzo1MgorIzogYnVpbHRpbi9tZXJnZS1yZWN1cnNpdmUuYzo1MwogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcGFyc2Ugb2JqZWN0ICclcyciCiBtc2dzdHIgIm5vIHNlIHB1ZG8gYW5hbGl6YXIgZWwgb2JqZXRvICclcyciCiAKLSM6IGJ1aWx0aW4vbWVyZ2UtcmVjdXJzaXZlLmM6NTYKKyM6IGJ1aWx0aW4vbWVyZ2UtcmVjdXJzaXZlLmM6NTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IGhhbmRsZSBtb3JlIHRoYW4gJWQgYmFzZS4gSWdub3JpbmcgJXMuIgogbXNnaWRfcGx1cmFsICJjYW5ub3QgaGFuZGxlIG1vcmUgdGhhbiAlZCBiYXNlcy4gSWdub3JpbmcgJXMuIgogbXNnc3RyWzBdICJubyBzZSBwdWVkZSBtYW5lamFyIG3DoXMgZGUgJWQgYmFzZS4gSWdub3JhbmRvICVzLiIKIG1zZ3N0clsxXSAibm8gc2UgcHVlZGUgbWFuZWphciBtw6FzIGRlICVkIGJhc2VzLiBJZ25vcmFuZG8gJXMuIgogCi0jOiBidWlsdGluL21lcmdlLXJlY3Vyc2l2ZS5jOjY0CisjOiBidWlsdGluL21lcmdlLXJlY3Vyc2l2ZS5jOjY1CiBtc2dpZCAibm90IGhhbmRsaW5nIGFueXRoaW5nIG90aGVyIHRoYW4gdHdvIGhlYWRzIG1lcmdlLiIKIG1zZ3N0ciAibm8gbWFuZWphbmRvIG5hZGEgZGlzdGludG8gYSBmdXNpb25lcyBkZSBkb3MgaGVhZHMuIgogCi0jOiBidWlsdGluL21lcmdlLXJlY3Vyc2l2ZS5jOjcwIGJ1aWx0aW4vbWVyZ2UtcmVjdXJzaXZlLmM6NzIKKyM6IGJ1aWx0aW4vbWVyZ2UtcmVjdXJzaXZlLmM6NzQgYnVpbHRpbi9tZXJnZS1yZWN1cnNpdmUuYzo3NgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcmVzb2x2ZSByZWYgJyVzJyIKIG1zZ3N0ciAibm8gc2UgcHVkbyByZXNvbHZlciByZWYgJyVzJyIKIAotIzogYnVpbHRpbi9tZXJnZS1yZWN1cnNpdmUuYzo3OAorIzogYnVpbHRpbi9tZXJnZS1yZWN1cnNpdmUuYzo4MgogIywgYy1mb3JtYXQKIG1zZ2lkICJNZXJnaW5nICVzIHdpdGggJXNcbiIKIG1zZ3N0ciAiRnVzaW9uYW5kbyAlcyBjb24gJXNcbiIKQEAgLTE1NDc5LDcgKzE1NTYxLDcgQEAKICM6IGJ1aWx0aW4vbXYuYzo4MwogIywgYy1mb3JtYXQKIG1zZ2lkICJEaXJlY3RvcnkgJXMgaXMgaW4gaW5kZXggYW5kIG5vIHN1Ym1vZHVsZT8iCi1tc2dzdHIgIkRpcmVjdG9yaW8gJXMgZXN0w6EgZW4gZWwgw61uZGljZSB5IG5vIGhheSBzdWJtw7NkdWxvPyIKK21zZ3N0ciAiwr9EaXJlY3RvcmlvICVzIGVzdMOhIGVuIGVsIMOtbmRpY2UgeSBubyBoYXkgc3VibcOzZHVsbz8iCiAKICM6IGJ1aWx0aW4vbXYuYzo4NQogbXNnaWQgIlBsZWFzZSBzdGFnZSB5b3VyIGNoYW5nZXMgdG8gLmdpdG1vZHVsZXMgb3Igc3Rhc2ggdGhlbSB0byBwcm9jZWVkIgpAQCAtMTU1NjEsNTIgKzE1NjQzLDUyIEBACiBtc2dpZCAiUmVuYW1pbmcgJXMgdG8gJXNcbiIKIG1zZ3N0ciAiUmVub21icmFuZG8gJXMgYSAlc1xuIgogCi0jOiBidWlsdGluL212LmM6Mjc3IGJ1aWx0aW4vcmVtb3RlLmM6NzE3IGJ1aWx0aW4vcmVwYWNrLmM6NTEwCisjOiBidWlsdGluL212LmM6Mjc3IGJ1aWx0aW4vcmVtb3RlLmM6NzE3IGJ1aWx0aW4vcmVwYWNrLmM6NTExCiAjLCBjLWZvcm1hdAogbXNnaWQgInJlbmFtaW5nICclcycgZmFpbGVkIgogbXNnc3RyICJyZW5vbWJyYW5kbyAnJXMnIGZhbGzDsyIKIAotIzogYnVpbHRpbi9uYW1lLXJldi5jOjM1MgorIzogYnVpbHRpbi9uYW1lLXJldi5jOjM1NgogbXNnaWQgImdpdCBuYW1lLXJldiBbPG9wdGlvbnM+XSA8Y29tbWl0Pi4uLiIKIG1zZ3N0ciAiZ2l0IG5hbWUtcmV2IFs8b3BjaW9uZXM+XSA8Y29tbWl0Pi4uLiIKIAotIzogYnVpbHRpbi9uYW1lLXJldi5jOjM1MworIzogYnVpbHRpbi9uYW1lLXJldi5jOjM1NwogbXNnaWQgImdpdCBuYW1lLXJldiBbPG9wdGlvbnM+XSAtLWFsbCIKIG1zZ3N0ciAiZ2l0IG5hbWUtcmV2IFs8b3BjaW9uZXM+XSAtLWFsbCIKIAotIzogYnVpbHRpbi9uYW1lLXJldi5jOjM1NAorIzogYnVpbHRpbi9uYW1lLXJldi5jOjM1OAogbXNnaWQgImdpdCBuYW1lLXJldiBbPG9wdGlvbnM+XSAtLXN0ZGluIgogbXNnc3RyICJnaXQgbmFtZS1yZXYgWzxvcGNpb25lcz5dIC0tc3RkaW4iCiAKLSM6IGJ1aWx0aW4vbmFtZS1yZXYuYzo0MTEKKyM6IGJ1aWx0aW4vbmFtZS1yZXYuYzo0MTUKIG1zZ2lkICJwcmludCBvbmx5IG5hbWVzIChubyBTSEEtMSkiCiBtc2dzdHIgImltcHJpbWlyIHPDs2xvIG5vbWJyZXMgKHNpbiBTSEEtMSkiCiAKLSM6IGJ1aWx0aW4vbmFtZS1yZXYuYzo0MTIKKyM6IGJ1aWx0aW4vbmFtZS1yZXYuYzo0MTYKIG1zZ2lkICJvbmx5IHVzZSB0YWdzIHRvIG5hbWUgdGhlIGNvbW1pdHMiCiBtc2dzdHIgInPDs2xvIHVzYXIgdGFncyBwYXJhIG5vbWJyYXIgY29tbWl0cyIKIAotIzogYnVpbHRpbi9uYW1lLXJldi5jOjQxNAorIzogYnVpbHRpbi9uYW1lLXJldi5jOjQxOAogbXNnaWQgIm9ubHkgdXNlIHJlZnMgbWF0Y2hpbmcgPHBhdHRlcm4+IgogbXNnc3RyICJzb2xvIHVzYXIgcmVmcyBxdWUgY29uY3VlcmRlbiBjb24gPHBhdHLDs24+IgogCi0jOiBidWlsdGluL25hbWUtcmV2LmM6NDE2CisjOiBidWlsdGluL25hbWUtcmV2LmM6NDIwCiBtc2dpZCAiaWdub3JlIHJlZnMgbWF0Y2hpbmcgPHBhdHRlcm4+IgogbXNnc3RyICJpZ25vcmFyIHJlZnMgcXVlIGNvbmN1ZXJkZW4gY29uIDxwYXRyw7NuPiIKIAotIzogYnVpbHRpbi9uYW1lLXJldi5jOjQxOAorIzogYnVpbHRpbi9uYW1lLXJldi5jOjQyMgogbXNnaWQgImxpc3QgYWxsIGNvbW1pdHMgcmVhY2hhYmxlIGZyb20gYWxsIHJlZnMiCiBtc2dzdHIgImxpc3RhciB0b2RvcyBsb3MgY29tbWl0cyBhbGNhbnphYmxlcyBkZXNkZSB0b2RhcyBsYXMgcmVmZXJlbmNpYXMiCiAKLSM6IGJ1aWx0aW4vbmFtZS1yZXYuYzo0MTkKKyM6IGJ1aWx0aW4vbmFtZS1yZXYuYzo0MjMKIG1zZ2lkICJyZWFkIGZyb20gc3RkaW4iCiBtc2dzdHIgImxlZXIgZGVzZGUgc3RkaW4iCiAKLSM6IGJ1aWx0aW4vbmFtZS1yZXYuYzo0MjAKKyM6IGJ1aWx0aW4vbmFtZS1yZXYuYzo0MjQKIG1zZ2lkICJhbGxvdyB0byBwcmludCBgdW5kZWZpbmVkYCBuYW1lcyAoZGVmYXVsdCkiCiBtc2dzdHIgInBlcm1pdGlyIGltcHJpbWlyIG5vbWJyZXMgYHVuZGVmaW5lZGAgKHByZWRldGVybWluYWRvKSIKIAotIzogYnVpbHRpbi9uYW1lLXJldi5jOjQyNgorIzogYnVpbHRpbi9uYW1lLXJldi5jOjQzMAogbXNnaWQgImRlcmVmZXJlbmNlIHRhZ3MgaW4gdGhlIGlucHV0IChpbnRlcm5hbCB1c2UpIgogbXNnc3RyICJkZXNyZWZlcmVuY2lhciB0YWdzIGVuIGxhIGVudHJhZGEgKHVzbyBpbnRlcm5vKSIKIApAQCAtMTYwMDYsNyArMTYwODgsNyBAQAogbXNnaWQgInJlYWQgb2JqZWN0IG5hbWVzIGZyb20gdGhlIHN0YW5kYXJkIGlucHV0IgogbXNnc3RyICJsZWVyIG5vbWJyZXMgZGUgb2JqZXRvcyBkZSBzdGFuZGFyZCBpbnB1dCIKIAotIzogYnVpbHRpbi9ub3Rlcy5jOjk1NCBidWlsdGluL3BydW5lLmM6MTMwIGJ1aWx0aW4vd29ya3RyZWUuYzoxNjUKKyM6IGJ1aWx0aW4vbm90ZXMuYzo5NTQgYnVpbHRpbi9wcnVuZS5jOjEzMCBidWlsdGluL3dvcmt0cmVlLmM6MTY0CiBtc2dpZCAiZG8gbm90IHJlbW92ZSwgc2hvdyBvbmx5IgogbXNnc3RyICJubyBlbGltaW5hciwgc29sbyBtb3N0cmFyIgogCkBAIC0xNjAyMiw3ICsxNjEwNCw3IEBACiBtc2dpZCAidXNlIG5vdGVzIGZyb20gPG5vdGVzLXJlZj4iCiBtc2dzdHIgInVzYXIgbm90YXMgZGVzZGUgPHJlZmVyZW5jaWEtZGUtbm90YXM+IgogCi0jOiBidWlsdGluL25vdGVzLmM6MTAzNCBidWlsdGluL3N0YXNoLmM6MTU5OAorIzogYnVpbHRpbi9ub3Rlcy5jOjEwMzQgYnVpbHRpbi9zdGFzaC5jOjE2MDcKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5rbm93biBzdWJjb21tYW5kOiAlcyIKIG1zZ3N0ciAic3ViY29tYW5kbyBkZXNjb25vY2lkbzogJXMiCkBAIC0xNjA5OSw3MSArMTYxODEsNzEgQEAKIG1zZ2lkICJ3cm90ZSAlPFBSSXUzMj4gb2JqZWN0cyB3aGlsZSBleHBlY3RpbmcgJTxQUkl1MzI+IgogbXNnc3RyICIlPFBSSXUzMj4gb2JqZXRvcyBlc2NyaXRvcyBtaWVudHJhcyBzZSBlc3BlcmFiYW4gJTxQUkl1MzI+IgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjExNjYKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MTE2NAogbXNnaWQgImRpc2FibGluZyBiaXRtYXAgd3JpdGluZywgYXMgc29tZSBvYmplY3RzIGFyZSBub3QgYmVpbmcgcGFja2VkIgogbXNnc3RyICIiCiAiZGVzaGFiaWxpdGFuZG8gZXNjcml0dXJhIGJpdG1hcCwgeWEgcXVlIGFsZ3Vub3Mgb2JqZXRvcyBubyBlc3TDoW4gc2llbmRvICIKICJlbXBhcXVldGFkb3MiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MTU5NworIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoxNTkyCiAjLCBjLWZvcm1hdAogbXNnaWQgImRlbHRhIGJhc2Ugb2Zmc2V0IG92ZXJmbG93IGluIHBhY2sgZm9yICVzIgogbXNnc3RyICJvdmVyZmxvdyBkZSBvZmZzZXQgZW4gbGEgYmFzZSBkZSBkZWx0YSBlbiBwYXF1ZXRlIHBhcmEgJXMiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MTYwNgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoxNjAxCiAjLCBjLWZvcm1hdAogbXNnaWQgImRlbHRhIGJhc2Ugb2Zmc2V0IG91dCBvZiBib3VuZCBmb3IgJXMiCiBtc2dzdHIgIm91dGJvdW5kIGRlIG9mZnNldCBlbiBsYSBiYXNlIGRlIGRlbHRhIHBhcmEgJXMiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MTg3NQorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoxODcwCiBtc2dpZCAiQ291bnRpbmcgb2JqZWN0cyIKIG1zZ3N0ciAiQ29udGFuZG8gb2JqZXRvcyIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyMDA1CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjIwMDAKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGdldCBzaXplIG9mICVzIgogbXNnc3RyICJubyBzZSBwdWRvIG9idGVuZXIgZWwgdGFtYcOxbyBkZSAlcyIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyMDIwCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjIwMTUKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHBhcnNlIG9iamVjdCBoZWFkZXIgb2YgJXMiCiBtc2dzdHIgImluY2FwYXogZGUgYW5hbGl6YXIgaGVhZGVyIGRlbCBvYmpldG8gJXMiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjA5MCBidWlsdGluL3BhY2stb2JqZWN0cy5jOjIxMDYKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjExNgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyMDg1IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjEwMQorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyMTExCiAjLCBjLWZvcm1hdAogbXNnaWQgIm9iamVjdCAlcyBjYW5ub3QgYmUgcmVhZCIKIG1zZ3N0ciAib2JqZXRvICVzIG5vIHB1ZWRlIHNlciBsZcOtZG8iCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjA5MyBidWlsdGluL3BhY2stb2JqZWN0cy5jOjIxMjAKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjA4OCBidWlsdGluL3BhY2stb2JqZWN0cy5jOjIxMTUKICMsIGMtZm9ybWF0CiBtc2dpZCAib2JqZWN0ICVzIGluY29uc2lzdGVudCBvYmplY3QgbGVuZ3RoICglPFBSSXVNQVg+IHZzICU8UFJJdU1BWD4pIgogbXNnc3RyICIiCiAib2JqZXRvICVzIGluY29uc2lzdGVudGUgY29uIGVsIGxhcmdvIGRlbCBvYmpldG8gKCU8UFJJdU1BWD4gdnMgJTxQUkl1TUFYPikiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjEzMAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyMTI1CiBtc2dpZCAic3Vib3B0aW1hbCBwYWNrIC0gb3V0IG9mIG1lbW9yeSIKIG1zZ3N0ciAic3Vib3B0aW1hbCBwYWNrIC0gZnVlcmEgZGUgbWVtb3JpYSIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNDU2CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI0NDAKICMsIGMtZm9ybWF0CiBtc2dpZCAiRGVsdGEgY29tcHJlc3Npb24gdXNpbmcgdXAgdG8gJWQgdGhyZWFkcyIKIG1zZ3N0ciAiQ29tcHJlc2nDs24gZGVsdGEgdXNhbmRvIGhhc3RhICVkIGhpbG9zIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI1ODgKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjU3MgogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gcGFjayBvYmplY3RzIHJlYWNoYWJsZSBmcm9tIHRhZyAlcyIKIG1zZ3N0ciAibm8gZXMgcG9zaWJsZSBlbXBhcXVldGFyIG9iamV0b3MgYWxjYW56YWJsZXMgZGVzZGUgdGFnICVzIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI2NzUKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjY1OQogbXNnaWQgIkNvbXByZXNzaW5nIG9iamVjdHMiCiBtc2dzdHIgIkNvbXByaW1pZW5kbyBvYmpldG9zIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI2ODEKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjY2NQogbXNnaWQgImluY29uc2lzdGVuY3kgd2l0aCBkZWx0YSBjb3VudCIKIG1zZ3N0ciAiaW5jb25zaXN0ZW5jaWEgY29uIGxhIGN1ZW50YSBkZSBkZWx0YSIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNzYyCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI3NDIKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogImV4cGVjdGVkIGVkZ2Ugb2JqZWN0IElELCBnb3QgZ2FyYmFnZTpcbiIKQEAgLTE2MTcyLDcgKzE2MjU0LDcgQEAKICJzZSBlc3BzZXJhYmEgSUQgZGUgb2JqZXRvIGFsIGJvcmRlLCBzZSBvYnR1dm8gYmFzdXJhOlxuIgogIiVzIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI3NjgKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6Mjc0OAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiZXhwZWN0ZWQgb2JqZWN0IElELCBnb3QgZ2FyYmFnZTpcbiIKQEAgLTE2MTgxLDI0NiArMTYyNjMsMjQ2IEBACiAic2UgZXNwZXJhYmEgSUQgZGUgb2JqZXRvLCBzZSBvYnR1dm8gYmFzdXRhOlxuIgogIiVzIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI4NjYKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6Mjg0NgogbXNnaWQgImludmFsaWQgdmFsdWUgZm9yIC0tbWlzc2luZyIKIG1zZ3N0ciAidmFsb3IgaW52w6FsaWRvIHBhcmEgLS1taXNzaW5nIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI5MjUgYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMDMzCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI5MDUgYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMDEzCiBtc2dpZCAiY2Fubm90IG9wZW4gcGFjayBpbmRleCIKIG1zZ3N0ciAibm8gc2UgcHVlZGUgYWJyaXIgw61uZGljZSBkZSBwYXF1ZXRlcyIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyOTU2CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI5MzYKICMsIGMtZm9ybWF0CiBtc2dpZCAibG9vc2Ugb2JqZWN0IGF0ICVzIGNvdWxkIG5vdCBiZSBleGFtaW5lZCIKIG1zZ3N0ciAib2JqZXRvIHBlcmRpZG8gZW4gJXMgbm8gcHVkbyBzZXIgZXhhbWluYWRvIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMwNDEKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzAyMQogbXNnaWQgInVuYWJsZSB0byBmb3JjZSBsb29zZSBvYmplY3QiCiBtc2dzdHIgImluY2FwYXogZGUgZm9yemFyIHVuIG9iamV0byBwZXJkaWRvIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMxMzMKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzExMwogIywgYy1mb3JtYXQKIG1zZ2lkICJub3QgYSByZXYgJyVzJyIKIG1zZ3N0ciAibm8gZXMgdW5hIHJldiAnJXMnIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMxMzYKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzExNgogIywgYy1mb3JtYXQKIG1zZ2lkICJiYWQgcmV2aXNpb24gJyVzJyIKIG1zZ3N0ciAibWFsYSByZXZpc2nDs24gJyVzJyIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMTYxCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMxNDEKIG1zZ2lkICJ1bmFibGUgdG8gYWRkIHJlY2VudCBvYmplY3RzIgogbXNnc3RyICJpbmNhcGF6IGRlIGHDsWFkaXIgb2JqZXRvcyByZWNpZW50ZXMiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzIxNAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMTk0CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuc3VwcG9ydGVkIGluZGV4IHZlcnNpb24gJXMiCiBtc2dzdHIgInZlcnNpw7NuIGRlIMOtbmRpY2Ugbm8gc29wb3J0YWRhICVzIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyMTgKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzE5OAogIywgYy1mb3JtYXQKIG1zZ2lkICJiYWQgaW5kZXggdmVyc2lvbiAnJXMnIgogbXNnc3RyICJtYWxhIHZlcnNpw7NuIGRlbCDDrW5kaWNlICclcyciCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI0OAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjI4CiBtc2dpZCAiZG8gbm90IHNob3cgcHJvZ3Jlc3MgbWV0ZXIiCiBtc2dzdHIgIm5vIG1vc3RyYXIgbWVkaWRvciBkZSBwcm9ncmVzbyIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjUwCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyMzAKIG1zZ2lkICJzaG93IHByb2dyZXNzIG1ldGVyIgogbXNnc3RyICJtb3N0cmFyIG1lZGlkb3IgZGUgcHJvZ3Jlc28iCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI1MgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjMyCiBtc2dpZCAic2hvdyBwcm9ncmVzcyBtZXRlciBkdXJpbmcgb2JqZWN0IHdyaXRpbmcgcGhhc2UiCiBtc2dzdHIgIm1vc3RyYXIgbWVkaWRvciBkZSBwcm9ncmVzbyBkdXJhbnRlIGxhIGZhc2UgZGUgZXNjcml0dXJhIGRlIG9iamV0byIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjU1CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyMzUKIG1zZ2lkICJzaW1pbGFyIHRvIC0tYWxsLXByb2dyZXNzIHdoZW4gcHJvZ3Jlc3MgbWV0ZXIgaXMgc2hvd24iCiBtc2dzdHIgInNpbWlsYXIgYSAtLWFsbC1wcm9ncmVzcyBjdWFuZG8gbWVkaWRvciBkZSBwcm9ncmVzbyBlcyBtb3N0cmFkbyIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjU2CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyMzYKIG1zZ2lkICI8dmVyc2lvbj5bLDxvZmZzZXQ+XSIKIG1zZ3N0ciAiPHZlcnNpw7NuPlssPG9mZnNldD5dIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNTcKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzIzNwogbXNnaWQgIndyaXRlIHRoZSBwYWNrIGluZGV4IGZpbGUgaW4gdGhlIHNwZWNpZmllZCBpZHggZm9ybWF0IHZlcnNpb24iCiBtc2dzdHIgIiIKICJlc2NyaWJpciBlbCDDrW5kaWNlIGRlIHBhcXVldGUgZW4gbGEgdmVyc2nDs24gZGUgZm9ybWF0byBpZHggZXNwZWNpZmljYWRvIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNjAKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI0MAogbXNnaWQgIm1heGltdW0gc2l6ZSBvZiBlYWNoIG91dHB1dCBwYWNrIGZpbGUiCiBtc2dzdHIgInRhbWHDsW8gbcOheGltbyBkZSBjYWRhIHBhcXVldGUgcmVzdWx0YW50ZSIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjYyCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNDIKIG1zZ2lkICJpZ25vcmUgYm9ycm93ZWQgb2JqZWN0cyBmcm9tIGFsdGVybmF0ZSBvYmplY3Qgc3RvcmUiCiBtc2dzdHIgImlnbm9yYXIgb2JqZXRvcyBwcmVzdGFkb3MgZGUgb3Ryb3MgYWxtYWNlbmVzIGRlIG9iamV0b3MiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI2NAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjQ0CiBtc2dpZCAiaWdub3JlIHBhY2tlZCBvYmplY3RzIgogbXNnc3RyICJpZ25vcmFyIG9iamV0b3MgcGFxdWV0ZSIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjY2CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNDYKIG1zZ2lkICJsaW1pdCBwYWNrIHdpbmRvdyBieSBvYmplY3RzIgogbXNnc3RyICJsaW1pdGFyIHZlbnRhbmEgZGUgcGFxdWV0ZSBwb3Igb2JqZXRvcyIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjY4CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNDgKIG1zZ2lkICJsaW1pdCBwYWNrIHdpbmRvdyBieSBtZW1vcnkgaW4gYWRkaXRpb24gdG8gb2JqZWN0IGxpbWl0IgogbXNnc3RyICJsaW1pdGFyIHZlbnRhbmEgZGUgcGFxdWV0ZSBwb3IgbWVtb3JpYSBlbiBhZGljacOzbiBhIGzDrW1pdGUgZGUgb2JqZXRvcyIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjcwCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNTAKIG1zZ2lkICJtYXhpbXVtIGxlbmd0aCBvZiBkZWx0YSBjaGFpbiBhbGxvd2VkIGluIHRoZSByZXN1bHRpbmcgcGFjayIKIG1zZ3N0ciAibG9uZ2l0dWQgbcOheGltYSBkZSBjYWRlbmEgZGVsdGEgcGVybWl0aWRhIGVuIGVsIHBhcXVldGUgcmVzdWx0YW50ZSIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjcyCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNTIKIG1zZ2lkICJyZXVzZSBleGlzdGluZyBkZWx0YXMiCiBtc2dzdHIgInJldXNhciBkZWx0YXMgZXhpc3RlbnRlcyIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjc0CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNTQKIG1zZ2lkICJyZXVzZSBleGlzdGluZyBvYmplY3RzIgogbXNnc3RyICJyZXV0aWxpemFyIG9iamV0b3MgZXhpc3RlbnRlcyIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjc2CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNTYKIG1zZ2lkICJ1c2UgT0ZTX0RFTFRBIG9iamVjdHMiCiBtc2dzdHIgInVzYXIgb2JqZXRvcyBPRlNfREVMVEEiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI3OAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjU4CiBtc2dpZCAidXNlIHRocmVhZHMgd2hlbiBzZWFyY2hpbmcgZm9yIGJlc3QgZGVsdGEgbWF0Y2hlcyIKIG1zZ3N0ciAidXNhciBoaWxvcyBjdWFuZG8gc2UgYnVzcXVlIHBhcmEgbWVqb3JlcyBjb25jb3JkYW5jaWFzIGRlIGRlbHRhIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyODAKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI2MAogbXNnaWQgImRvIG5vdCBjcmVhdGUgYW4gZW1wdHkgcGFjayBvdXRwdXQiCiBtc2dzdHIgIm5vIGNyZWFyIHVuIHBhcXVldGUgcmVzdWx0YW50ZSB2YWPDrW8iCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI4MgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjYyCiBtc2dpZCAicmVhZCByZXZpc2lvbiBhcmd1bWVudHMgZnJvbSBzdGFuZGFyZCBpbnB1dCIKIG1zZ3N0ciAibGVlciBhcmd1bWVudG9zIGRlIHJldmlzacOzbiBkZSBzdGFuZGFyZCBpbnB1dCIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjg0CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNjQKIG1zZ2lkICJsaW1pdCB0aGUgb2JqZWN0cyB0byB0aG9zZSB0aGF0IGFyZSBub3QgeWV0IHBhY2tlZCIKIG1zZ3N0ciAibGltaXRhciBsb3Mgb2JqZXRvcyBhIGFxdWVsbG9zIHF1ZSBubyBoYW4gc2lkbyBlbXBhcXVldGFkb3MgdG9kYXbDrWEiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI4NworIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjY3CiBtc2dpZCAiaW5jbHVkZSBvYmplY3RzIHJlYWNoYWJsZSBmcm9tIGFueSByZWZlcmVuY2UiCiBtc2dzdHIgImluY2x1aXIgb2JqZXRvcyBhbGNhbnphYmxlcyBwb3IgY3VhbHF1aWVyIHJlZmVyZW5jaWEiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI5MAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjcwCiBtc2dpZCAiaW5jbHVkZSBvYmplY3RzIHJlZmVycmVkIGJ5IHJlZmxvZyBlbnRyaWVzIgogbXNnc3RyICJpbmNsdWlyIG9iamV0b3MgcmVmZXJpZG9zIHBvciBlbnRyYWRhcyBkZSByZWZsb2ciCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI5MworIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjczCiBtc2dpZCAiaW5jbHVkZSBvYmplY3RzIHJlZmVycmVkIHRvIGJ5IHRoZSBpbmRleCIKIG1zZ3N0ciAiaW5jbHVpciBvYmpldG9zIHJlZmVyaWRvcyBwb3IgZWwgw61uZGljZSIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjk2CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNzYKIG1zZ2lkICJvdXRwdXQgcGFjayB0byBzdGRvdXQiCiBtc2dzdHIgIm1vc3RyYXIgcGFxdWV0ZSBlbiBzdGRvdXQiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI5OAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjc4CiBtc2dpZCAiaW5jbHVkZSB0YWcgb2JqZWN0cyB0aGF0IHJlZmVyIHRvIG9iamVjdHMgdG8gYmUgcGFja2VkIgogbXNnc3RyICJpbmNsdWlyIG9iamV0b3MgdGFnIHF1ZSByZWZpZXJlbiBhIG9iamV0b3MgYSBzZXIgZW1wYXF1ZXRhZG9zIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMDAKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI4MAogbXNnaWQgImtlZXAgdW5yZWFjaGFibGUgb2JqZWN0cyIKIG1zZ3N0ciAibWFudGVuZXIgb2JqZXRvcyBpbmFsY2FuemFibGVzIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMDIKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI4MgogbXNnaWQgInBhY2sgbG9vc2UgdW5yZWFjaGFibGUgb2JqZWN0cyIKIG1zZ3N0ciAiZW1wYXF1ZXRhciBvYmpldG9zIHN1ZWx0b3MgaW5hbGNhbnphYmxlcyIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzA0CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyODQKIG1zZ2lkICJ1bnBhY2sgdW5yZWFjaGFibGUgb2JqZWN0cyBuZXdlciB0aGFuIDx0aW1lPiIKIG1zZ3N0ciAiZGVzZW1wYXF1ZXRhciBvYmpldG9zIGluYWxjYW56YWJsZXMgbcOhcyBudWV2b3MgcXVlIDx0aWVtcG8+IgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMDcKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI4NwogbXNnaWQgInVzZSB0aGUgc3BhcnNlIHJlYWNoYWJpbGl0eSBhbGdvcml0aG0iCiBtc2dzdHIgInVzYXIgZWwgYWxnb3JpdG1vIHNwYXJzZSByZWFjaGFiaWxpdHkiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMwOQorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjg5CiBtc2dpZCAiY3JlYXRlIHRoaW4gcGFja3MiCiBtc2dzdHIgImNyZWFyIHBhcXVldGVzIGRlbGdhZG9zIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMTEKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI5MQogbXNnaWQgImNyZWF0ZSBwYWNrcyBzdWl0YWJsZSBmb3Igc2hhbGxvdyBmZXRjaGVzIgogbXNnc3RyICJjcmVhciBwYXF1ZXRlcyBhZGVjdWFkb3MgcGFyYSBmZXRjaGVzIHN1cGVyZmljaWFsZXMiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMxMworIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjkzCiBtc2dpZCAiaWdub3JlIHBhY2tzIHRoYXQgaGF2ZSBjb21wYW5pb24gLmtlZXAgZmlsZSIKIG1zZ3N0ciAiaWdub3JhciBwYXF1ZXRlcyBxdWUgdGllbmVuIHVuIGFyY2hpdm8gLmtlZXAgYWNvbXBhw7FhbnRlIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMTUKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI5NQogbXNnaWQgImlnbm9yZSB0aGlzIHBhY2siCiBtc2dzdHIgImlnbm9yYXIgZXN0ZSBwYXF1ZXRlIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMTcKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI5NwogbXNnaWQgInBhY2sgY29tcHJlc3Npb24gbGV2ZWwiCiBtc2dzdHIgIm5pdmVsIGRlIGNvbXByZXNpw7NuIGRlbCBwYXF1ZXRlIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMTkKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI5OQogbXNnaWQgImRvIG5vdCBoaWRlIGNvbW1pdHMgYnkgZ3JhZnRzIgogbXNnc3RyICJubyBvY3VsdGFyIGNvbW1pdHMgcG9yIGluamVydG9zIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMjEKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMwMQogbXNnaWQgInVzZSBhIGJpdG1hcCBpbmRleCBpZiBhdmFpbGFibGUgdG8gc3BlZWQgdXAgY291bnRpbmcgb2JqZWN0cyIKIG1zZ3N0ciAiIgogInVzYXIgdW4gw61uZGljZSBiaXRtYXAgc2kgZXN0w6EgZGlzcG9uaWJsZSBwYXJhIGFjZWxlcmFyIGxhIGN1ZW50YSBkZSBvYmpldG9zIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMjMKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMwMwogbXNnaWQgIndyaXRlIGEgYml0bWFwIGluZGV4IHRvZ2V0aGVyIHdpdGggdGhlIHBhY2sgaW5kZXgiCiBtc2dzdHIgImVzY3JpYmlyIHVuIMOtbmRpY2UgZGUgYml0bWFwIGp1bnRvIGFsIMOtbmRpY2UgZGUgcGFxdWV0ZSIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzI3CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMDcKIG1zZ2lkICJ3cml0ZSBhIGJpdG1hcCBpbmRleCBpZiBwb3NzaWJsZSIKIG1zZ3N0ciAiZXNjcmliaXIgdW4gw61uZGljZSBkZSBiaXRtYXAgc2kgZXMgcG9zaWJsZSIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzMxCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMTEKIG1zZ2lkICJoYW5kbGluZyBmb3IgbWlzc2luZyBvYmplY3RzIgogbXNnc3RyICJtYW5lam8gZGUgb2JqZXRvcyBwZXJkaWRvcyIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzM0CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMTQKIG1zZ2lkICJkbyBub3QgcGFjayBvYmplY3RzIGluIHByb21pc29yIHBhY2tmaWxlcyIKIG1zZ3N0ciAibm8gc2UgcHVlZGUgZW1wYXF1ZXRhciBvYmpldG9zIGVuIHBhY2tmaWxlcyBwcm9taXNvcmVzIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMzYKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMxNgogbXNnaWQgInJlc3BlY3QgaXNsYW5kcyBkdXJpbmcgZGVsdGEgY29tcHJlc3Npb24iCiBtc2dzdHIgInJlc3BldGFyIGlzbGFzIGR1cmFudGUgbGEgY29tcHJlc2nDs24gZGVsdGEiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzM2MQorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzQ1CiAjLCBjLWZvcm1hdAogbXNnaWQgImRlbHRhIGNoYWluIGRlcHRoICVkIGlzIHRvbyBkZWVwLCBmb3JjaW5nICVkIgogbXNnc3RyICJwcm9mdW5kaWRhZCBkZSBjYWRlbmEgZGUgZGVsdGEgJWQgZXMgbXV5IHByb2Z1bmRhLCBmb3J6YW5kbyAlZCIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzY2CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzNTAKICMsIGMtZm9ybWF0CiBtc2dpZCAicGFjay5kZWx0YUNhY2hlTGltaXQgaXMgdG9vIGhpZ2gsIGZvcmNpbmcgJWQiCiBtc2dzdHIgInBhY2suZGVsdGFDYWNoZUxpbWl0IGVzIG11eSBncmFuZGUsIGZvcnphbmRvICVkIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjM0MjAKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzQwNAogbXNnaWQgIi0tbWF4LXBhY2stc2l6ZSBjYW5ub3QgYmUgdXNlZCB0byBidWlsZCBhIHBhY2sgZm9yIHRyYW5zZmVyIgogbXNnc3RyICIiCiAiLS1tYXgtcGFjay1zaXplIG5vIHB1ZWRlIHNlciB1c2FkbyBwYXJhIGNvbnN0cnVpciB1biBwYXF1ZXRlIHBhcmEgIgogInRyYW5zZmVyZW5jaWEiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzQyMgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozNDA2CiBtc2dpZCAibWluaW11bSBwYWNrIHNpemUgbGltaXQgaXMgMSBNaUIiCiBtc2dzdHIgInRhbWHDsW8gbcOtbmltbyBkZWwgcGFxdWV0ZSBlcyAxIE1pQiIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozNDI3CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjM0MTEKIG1zZ2lkICItLXRoaW4gY2Fubm90IGJlIHVzZWQgdG8gYnVpbGQgYW4gaW5kZXhhYmxlIHBhY2siCiBtc2dzdHIgIi0tdGhpbiBubyBwdWVkZSBzZXIgdXNhZG8gcGFyYSBjb25zdHJ1aXIgdW4gcGFxdWV0ZSBpbmRleGFibGUiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzQzMAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozNDE0CiBtc2dpZCAiLS1rZWVwLXVucmVhY2hhYmxlIGFuZCAtLXVucGFjay11bnJlYWNoYWJsZSBhcmUgaW5jb21wYXRpYmxlIgogbXNnc3RyICItLWtlZXAtdW5yZWFjaGFibGUgeSAtLXVucGFjay11bnJlYWNoYWJsZSBzb24gaW5jb21wYXRpYmxlcyIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozNDM2CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjM0MjAKIG1zZ2lkICJjYW5ub3QgdXNlIC0tZmlsdGVyIHdpdGhvdXQgLS1zdGRvdXQiCiBtc2dzdHIgIm5vIHNlIHB1ZWRlIHVzYXItLWZpbHRlciBzaW4gLS1zdGRvdXQiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzQ5NworIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozNDgxCiBtc2dpZCAiRW51bWVyYXRpbmcgb2JqZWN0cyIKIG1zZ3N0ciAiRW51bWVyYW5kbyBvYmpldG9zIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjM1MjcKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzUxMQogIywgYy1mb3JtYXQKIG1zZ2lkICJUb3RhbCAlPFBSSXUzMj4gKGRlbHRhICU8UFJJdTMyPiksIHJldXNlZCAlPFBSSXUzMj4gKGRlbHRhICU8UFJJdTMyPikiCiBtc2dzdHIgIlRvdGFsICU8UFJJdTMyPiAoZGVsdGEgJTxQUkl1MzI+KSwgcmV1c2FkbyAlPFBSSXUzMj4gKGRlbHRhICU8UFJJdTMyPikiCkBAIC0xNjQ3NSw1NiArMTY1NTcsNTYgQEAKIG1zZ3N0ciAiIgogImdpdCBwdWxsIFs8b3BjaW9uZXM+XSBbPHJlcG9zaXRvcmlvPiBbPGVzcGVjaWZpY2FjacOzbi1kZS1yZWZlcmVuY2lhPi4uLl1dIgogCi0jOiBidWlsdGluL3B1bGwuYzoxNDEKKyM6IGJ1aWx0aW4vcHVsbC5jOjE0MgogbXNnaWQgImNvbnRyb2wgZm9yIHJlY3Vyc2l2ZSBmZXRjaGluZyBvZiBzdWJtb2R1bGVzIgogbXNnc3RyICJjb250cm9sIGRlIGZldGNoIHJlY3Vyc2l2byBlbiBzdWJtw7NkdWxvcyIKIAotIzogYnVpbHRpbi9wdWxsLmM6MTQ1CisjOiBidWlsdGluL3B1bGwuYzoxNDYKIG1zZ2lkICJPcHRpb25zIHJlbGF0ZWQgdG8gbWVyZ2luZyIKIG1zZ3N0ciAiT3BjaW9uZXMgcmVsYWNpb25hZGFzIGEgZnVzacOzbiIKIAotIzogYnVpbHRpbi9wdWxsLmM6MTQ4CisjOiBidWlsdGluL3B1bGwuYzoxNDkKIG1zZ2lkICJpbmNvcnBvcmF0ZSBjaGFuZ2VzIGJ5IHJlYmFzaW5nIHJhdGhlciB0aGFuIG1lcmdpbmciCiBtc2dzdHIgImluY29ycG9yYXIgY2FtYmlvcyBwb3IgcmViYXNlIGVuIGx1Z2FyIGRlIGZ1c2nDs24iCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjE3NiBidWlsdGluL3JlYmFzZS5jOjQ0NyBidWlsdGluL3JldmVydC5jOjEyNgorIzogYnVpbHRpbi9wdWxsLmM6MTc3IGJ1aWx0aW4vcmViYXNlLmM6NDQ4IGJ1aWx0aW4vcmV2ZXJ0LmM6MTI2CiBtc2dpZCAiYWxsb3cgZmFzdC1mb3J3YXJkIgogbXNnc3RyICJwZXJtaXRpciBmYXN0LWZvcndhcmQiCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjE4NQorIzogYnVpbHRpbi9wdWxsLmM6MTg2CiBtc2dpZCAiYXV0b21hdGljYWxseSBzdGFzaC9zdGFzaCBwb3AgYmVmb3JlIGFuZCBhZnRlciByZWJhc2UiCiBtc2dzdHIgImVqZWN1dGFyIGF1dG9tw6F0aWNhbWVudGUgc3Rhc2gvc3Rhc2ggcG9wIGFudGVzIHkgZGVzcHXDqXMgZGUgcmViYXNlIgogCi0jOiBidWlsdGluL3B1bGwuYzoyMDEKKyM6IGJ1aWx0aW4vcHVsbC5jOjIwMgogbXNnaWQgIk9wdGlvbnMgcmVsYXRlZCB0byBmZXRjaGluZyIKIG1zZ3N0ciAiT3BjaW9uZXMgcmVsYWNpb25hZGFzIGEgZmV0Y2giCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjIxMQorIzogYnVpbHRpbi9wdWxsLmM6MjEyCiBtc2dpZCAiZm9yY2Ugb3ZlcndyaXRlIG9mIGxvY2FsIGJyYW5jaCIKIG1zZ3N0ciAiZm9yemFyIHNvYnJlc2NyaXR1cmEgZGUgbGEgcmFtYSBsb2NhbCIKIAotIzogYnVpbHRpbi9wdWxsLmM6MjE5CisjOiBidWlsdGluL3B1bGwuYzoyMjAKIG1zZ2lkICJudW1iZXIgb2Ygc3VibW9kdWxlcyBwdWxsZWQgaW4gcGFyYWxsZWwiCiBtc2dzdHIgIm7Dum1lcm8gZGUgc3VibcOzZHVsb3MgcXVlIHJlYWxpemFuIHB1bGwgZW4gcGFyYWxlbG8iCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjMxNgorIzogYnVpbHRpbi9wdWxsLmM6MzIwCiAjLCBjLWZvcm1hdAogbXNnaWQgIkludmFsaWQgdmFsdWUgZm9yIHB1bGwuZmY6ICVzIgogbXNnc3RyICJWYWxvciBpbnbDoWxpZG8gcGFyYSBwdWxsLmZmOiAlcyIKIAotIzogYnVpbHRpbi9wdWxsLmM6NDMzCisjOiBidWlsdGluL3B1bGwuYzo0MzcKIG1zZ2lkICIiCiAiVGhlcmUgaXMgbm8gY2FuZGlkYXRlIGZvciByZWJhc2luZyBhZ2FpbnN0IGFtb25nIHRoZSByZWZzIHRoYXQgeW91IGp1c3QgIgogImZldGNoZWQuIgogbXNnc3RyICJObyBoYXkgY2FuZGlkYXRvIHBhcmEgcmViYXNhciBlbnRyZSBsYXMgcmVmcyBxdWUgaGFzIGJhamFkbyBjb24gZmV0Y2guIgogCi0jOiBidWlsdGluL3B1bGwuYzo0MzUKKyM6IGJ1aWx0aW4vcHVsbC5jOjQzOQogbXNnaWQgIiIKICJUaGVyZSBhcmUgbm8gY2FuZGlkYXRlcyBmb3IgbWVyZ2luZyBhbW9uZyB0aGUgcmVmcyB0aGF0IHlvdSBqdXN0IGZldGNoZWQuIgogbXNnc3RyICIiCiAiTm8gaGF5IGNhbmRpZGF0b3MgcGFyYSBmdXNpb25hciBlbnRyZSBsYXMgcmVmcyBxdWUgaGFzIGJhamFkbyBjb24gZmV0Y2guIgogCi0jOiBidWlsdGluL3B1bGwuYzo0MzYKKyM6IGJ1aWx0aW4vcHVsbC5jOjQ0MAogbXNnaWQgIiIKICJHZW5lcmFsbHkgdGhpcyBtZWFucyB0aGF0IHlvdSBwcm92aWRlZCBhIHdpbGRjYXJkIHJlZnNwZWMgd2hpY2ggaGFkIG5vXG4iCiAibWF0Y2hlcyBvbiB0aGUgcmVtb3RlIGVuZC4iCkBAIC0xNjUzMyw3ICsxNjYxNSw3IEBACiAidGllbmVcbiIKICJjb25jb3JkYW5jaWEgZW4gZWwgZmluYWwgcmVtb3RvLiIKIAotIzogYnVpbHRpbi9wdWxsLmM6NDM5CisjOiBidWlsdGluL3B1bGwuYzo0NDMKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIllvdSBhc2tlZCB0byBwdWxsIGZyb20gdGhlIHJlbW90ZSAnJXMnLCBidXQgZGlkIG5vdCBzcGVjaWZ5XG4iCkBAIC0xNjU0NCw0NCArMTY2MjYsNDQgQEAKICJ1bmEgcmFtYS4gUG9ycXVlIGVzdGUgbm8gZXMgZWwgcmVtb3RvIGNvbmZpZ3VyYWRvIHBvciBkZWZhdWx0XG4iCiAicGFyYSB0dSByYW1hIGFjdHVhbCwgdGllbmVzIHF1ZSBlc3BlY2lmaWNhciB1bmEgcmFtYSBlbiBsYSBsw61uZWEgZGUgY29tYW5kby4iCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjQ0NCBidWlsdGluL3JlYmFzZS5jOjEzMjYgZ2l0LXBhcnNlLXJlbW90ZS5zaDo3MworIzogYnVpbHRpbi9wdWxsLmM6NDQ4IGJ1aWx0aW4vcmViYXNlLmM6MTM0NyBnaXQtcGFyc2UtcmVtb3RlLnNoOjczCiBtc2dpZCAiWW91IGFyZSBub3QgY3VycmVudGx5IG9uIGEgYnJhbmNoLiIKIG1zZ3N0ciAiTm8gdGUgZW5jdWVudHJhcyBhY3R1YWxtZW50ZSBlbiBsYSByYW1hLiIKIAotIzogYnVpbHRpbi9wdWxsLmM6NDQ2IGJ1aWx0aW4vcHVsbC5jOjQ2MSBnaXQtcGFyc2UtcmVtb3RlLnNoOjc5CisjOiBidWlsdGluL3B1bGwuYzo0NTAgYnVpbHRpbi9wdWxsLmM6NDY1IGdpdC1wYXJzZS1yZW1vdGUuc2g6NzkKIG1zZ2lkICJQbGVhc2Ugc3BlY2lmeSB3aGljaCBicmFuY2ggeW91IHdhbnQgdG8gcmViYXNlIGFnYWluc3QuIgogbXNnc3RyICJQb3IgZmF2b3IgZXNwZWNpZmljYSBhIHF1w6kgcmFtYSBxdWllcmVzIHJlYmFzYXIuIgogCi0jOiBidWlsdGluL3B1bGwuYzo0NDggYnVpbHRpbi9wdWxsLmM6NDYzIGdpdC1wYXJzZS1yZW1vdGUuc2g6ODIKKyM6IGJ1aWx0aW4vcHVsbC5jOjQ1MiBidWlsdGluL3B1bGwuYzo0NjcgZ2l0LXBhcnNlLXJlbW90ZS5zaDo4MgogbXNnaWQgIlBsZWFzZSBzcGVjaWZ5IHdoaWNoIGJyYW5jaCB5b3Ugd2FudCB0byBtZXJnZSB3aXRoLiIKIG1zZ3N0ciAiUG9yIGZhdm9yIGVzcGVjaWZpY2EgYSBxdcOpIHJhbWEgcXVpZXJlcyBmdXNpb25hci4iCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjQ0OSBidWlsdGluL3B1bGwuYzo0NjQKKyM6IGJ1aWx0aW4vcHVsbC5jOjQ1MyBidWlsdGluL3B1bGwuYzo0NjgKIG1zZ2lkICJTZWUgZ2l0LXB1bGwoMSkgZm9yIGRldGFpbHMuIgogbXNnc3RyICJWZXIgZ2l0LXB1bGwoMSkgcGFyYSBkZXRhbGxlcy4iCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjQ1MSBidWlsdGluL3B1bGwuYzo0NTcgYnVpbHRpbi9wdWxsLmM6NDY2Ci0jOiBidWlsdGluL3JlYmFzZS5jOjEzMzIgZ2l0LXBhcnNlLXJlbW90ZS5zaDo2NAorIzogYnVpbHRpbi9wdWxsLmM6NDU1IGJ1aWx0aW4vcHVsbC5jOjQ2MSBidWlsdGluL3B1bGwuYzo0NzAKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTM1MyBnaXQtcGFyc2UtcmVtb3RlLnNoOjY0CiBtc2dpZCAiPHJlbW90ZT4iCiBtc2dzdHIgIjxyZW1vdG8+IgogCi0jOiBidWlsdGluL3B1bGwuYzo0NTEgYnVpbHRpbi9wdWxsLmM6NDY2IGJ1aWx0aW4vcHVsbC5jOjQ3MQorIzogYnVpbHRpbi9wdWxsLmM6NDU1IGJ1aWx0aW4vcHVsbC5jOjQ3MCBidWlsdGluL3B1bGwuYzo0NzUKICM6IGdpdC1wYXJzZS1yZW1vdGUuc2g6NjUKIG1zZ2lkICI8YnJhbmNoPiIKIG1zZ3N0ciAiPHJhbWE+IgogCi0jOiBidWlsdGluL3B1bGwuYzo0NTkgYnVpbHRpbi9yZWJhc2UuYzoxMzI0IGdpdC1wYXJzZS1yZW1vdGUuc2g6NzUKKyM6IGJ1aWx0aW4vcHVsbC5jOjQ2MyBidWlsdGluL3JlYmFzZS5jOjEzNDUgZ2l0LXBhcnNlLXJlbW90ZS5zaDo3NQogbXNnaWQgIlRoZXJlIGlzIG5vIHRyYWNraW5nIGluZm9ybWF0aW9uIGZvciB0aGUgY3VycmVudCBicmFuY2guIgogbXNnc3RyICJObyBoYXkgaW5mb3JtYWNpw7NuIGRlIHJhc3RyZW8gcGFyYSBsYSByYW1hIGFjdHVhbC4iCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjQ2OCBnaXQtcGFyc2UtcmVtb3RlLnNoOjk1CisjOiBidWlsdGluL3B1bGwuYzo0NzIgZ2l0LXBhcnNlLXJlbW90ZS5zaDo5NQogbXNnaWQgIiIKICJJZiB5b3Ugd2lzaCB0byBzZXQgdHJhY2tpbmcgaW5mb3JtYXRpb24gZm9yIHRoaXMgYnJhbmNoIHlvdSBjYW4gZG8gc28gd2l0aDoiCiBtc2dzdHIgIiIKICJTaSBkZXNlYXMgY29uZmlndXJhciBlbCByYXN0cmVvIGRlIGluZm9ybWFjacOzbiBwYXJhIGVzdGEgcmFtYSwgcHVlZGVzICIKICJoYWNlcmxvIGNvbjoiCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjQ3MworIzogYnVpbHRpbi9wdWxsLmM6NDc3CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJZb3VyIGNvbmZpZ3VyYXRpb24gc3BlY2lmaWVzIHRvIG1lcmdlIHdpdGggdGhlIHJlZiAnJXMnXG4iCkBAIC0xNjU5MCwzMiArMTY2NzIsMzIgQEAKICJUdSBjb25maWd1cmFjacOzbiBlc3BlY2lmaWNhIGZ1c2lvbmFyIGNvbiBsYSByZWYgJyVzJ1xuIgogImRlIHR1IHJlbW90bywgcGVybyBubyBzZSBwdWRvIGhhY2VyIGZldGNoIGEgZXNhIHJlZi4iCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjU4MQorIzogYnVpbHRpbi9wdWxsLmM6NTg3CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBhY2Nlc3MgY29tbWl0ICVzIgogbXNnc3RyICJubyBlcyBwb3NpYmxlIGFjY2VkZXIgYWwgY29tbWl0ICVzIgogCi0jOiBidWlsdGluL3B1bGwuYzo4NjEKKyM6IGJ1aWx0aW4vcHVsbC5jOjg2NwogbXNnaWQgImlnbm9yaW5nIC0tdmVyaWZ5LXNpZ25hdHVyZXMgZm9yIHJlYmFzZSIKIG1zZ3N0ciAiaWdub3JhbmRvIC0tdmVyaWZ5LXNpZ25hdHVyZXMgcGFyYSByZWJhc2UiCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjkxNgorIzogYnVpbHRpbi9wdWxsLmM6OTIyCiBtc2dpZCAiLS1bbm8tXWF1dG9zdGFzaCBvcHRpb24gaXMgb25seSB2YWxpZCB3aXRoIC0tcmViYXNlLiIKIG1zZ3N0ciAiTGEgb3BjacOzbiAtLVtuby1dYXV0b3N0YXNoIHPDs2xvIGVzIHbDoWxpZGEgY29uIC0tcmViYXNlLiIKIAotIzogYnVpbHRpbi9wdWxsLmM6OTI0CisjOiBidWlsdGluL3B1bGwuYzo5MzAKIG1zZ2lkICJVcGRhdGluZyBhbiB1bmJvcm4gYnJhbmNoIHdpdGggY2hhbmdlcyBhZGRlZCB0byB0aGUgaW5kZXguIgogbXNnc3RyICJBY3R1YWxpemFuZG8gdW5hIHJhbWEgbm8gbmF0YSBjb24gY2FtYmlvcyBhZ3JlZ2Fkb3MgYWwgw61uZGljZS4iCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjkyOAorIzogYnVpbHRpbi9wdWxsLmM6OTM0CiBtc2dpZCAicHVsbCB3aXRoIHJlYmFzZSIKIG1zZ3N0ciAicHVsbCBjb24gcmViYXNlIgogCi0jOiBidWlsdGluL3B1bGwuYzo5MjkKKyM6IGJ1aWx0aW4vcHVsbC5jOjkzNQogbXNnaWQgInBsZWFzZSBjb21taXQgb3Igc3Rhc2ggdGhlbS4iCiBtc2dzdHIgInBvciBmYXZvciByZWFsaXphIHVuIGNvbW1pdCBvIHVuIHN0YXNoIGNvbiBlbGxvcy4iCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjk1NAorIzogYnVpbHRpbi9wdWxsLmM6OTYwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJmZXRjaCB1cGRhdGVkIHRoZSBjdXJyZW50IGJyYW5jaCBoZWFkLlxuIgpAQCAtMTY2MjYsNyArMTY3MDgsNyBAQAogInJlYWxpemFuZG8gZmFzdC1mb3J3YXJkIGFsIMOhcmJvbCBkZSB0cmFiYWpvXG4iCiAiZGVzZGUgY29tbWl0ICVzLiIKIAotIzogYnVpbHRpbi9wdWxsLmM6OTYwCisjOiBidWlsdGluL3B1bGwuYzo5NjYKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkNhbm5vdCBmYXN0LWZvcndhcmQgeW91ciB3b3JraW5nIHRyZWUuXG4iCkBAIC0xNjY0MywxNSArMTY3MjUsMTUgQEAKICIkIGdpdCByZXNldCAtLWhhcmRcbiIKICJwYXJhIHJlY3VwZXJhci4iCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjk3NQorIzogYnVpbHRpbi9wdWxsLmM6OTgxCiBtc2dpZCAiQ2Fubm90IG1lcmdlIG11bHRpcGxlIGJyYW5jaGVzIGludG8gZW1wdHkgaGVhZC4iCiBtc2dzdHIgIk5vIHNlIHB1ZWRlIGZ1c2lvbmFyIG3Dumx0aXBsZXMgcmFtYXMgZW4gdW4gaGVhZCB2YWPDrW8uIgogCi0jOiBidWlsdGluL3B1bGwuYzo5NzkKKyM6IGJ1aWx0aW4vcHVsbC5jOjk4NQogbXNnaWQgIkNhbm5vdCByZWJhc2Ugb250byBtdWx0aXBsZSBicmFuY2hlcy4iCiBtc2dzdHIgIk5vIHNlIHB1ZWRlIHJlYmFzYXIgZW4gbcO6bHRpcGxlcyByYW1hcy4iCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjk4NgorIzogYnVpbHRpbi9wdWxsLmM6OTkyCiBtc2dpZCAiY2Fubm90IHJlYmFzZSB3aXRoIGxvY2FsbHkgcmVjb3JkZWQgc3VibW9kdWxlIG1vZGlmaWNhdGlvbnMiCiBtc2dzdHIgIiIKICJubyBzZSBwdWVkZSByZWJhc2FyIGNvbiBtb2RpZmljYWNpb25lcyBkZSBzdWJtw7NkdWxvcyBncmFiYWRhcyBsb2NhbG1lbnRlIgpAQCAtMTY4MTMsMTcgKzE2ODk1LDk0IEBACiBtc2dpZCAiUHVzaGluZyB0byAlc1xuIgogbXNnc3RyICJIYWNpZW5kbyBwdXNoIGEgJXNcbiIKIAotIzogYnVpbHRpbi9wdXNoLmM6MzY0CisjOiBidWlsdGluL3B1c2guYzozNjYKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIHB1c2ggc29tZSByZWZzIHRvICclcyciCiBtc2dzdHIgImZhbGzDsyBlbCBwdXNoIGRlIGFsZ3VuYXMgcmVmZXJlbmNpYXMgYSAnJXMnIgogCi0jOiBidWlsdGluL3B1c2guYzozOTgKKyM6IGJ1aWx0aW4vcHVzaC5jOjU0MQorbXNnaWQgInJlcG9zaXRvcnkiCittc2dzdHIgInJlcG9zaXRvcmlvIgorCisjOiBidWlsdGluL3B1c2guYzo1NDIgYnVpbHRpbi9zZW5kLXBhY2suYzoxNjQKK21zZ2lkICJwdXNoIGFsbCByZWZzIgorbXNnc3RyICJyZWFsaXphciBwdXNoIGEgdG9kYXMgbGFzIHJlZnMiCisKKyM6IGJ1aWx0aW4vcHVzaC5jOjU0MyBidWlsdGluL3NlbmQtcGFjay5jOjE2NgorbXNnaWQgIm1pcnJvciBhbGwgcmVmcyIKK21zZ3N0ciAicmVhbGl6YXIgbWlycm9yIGEgdG9kYXMgbGFzIHJlZnMiCisKKyM6IGJ1aWx0aW4vcHVzaC5jOjU0NQorbXNnaWQgImRlbGV0ZSByZWZzIgorbXNnc3RyICJib3JyYXIgcmVmcyIKKworIzogYnVpbHRpbi9wdXNoLmM6NTQ2Cittc2dpZCAicHVzaCB0YWdzIChjYW4ndCBiZSB1c2VkIHdpdGggLS1hbGwgb3IgLS1taXJyb3IpIgorbXNnc3RyICJyZWFsaXphciBwdXNoIGEgdGFncyAobm8gcHVlZGUgc2VyIHVzYWRvIGNvbiAtLWFsbCBvIC0tbWlycm9yKSIKKworIzogYnVpbHRpbi9wdXNoLmM6NTQ5IGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTY3Cittc2dpZCAiZm9yY2UgdXBkYXRlcyIKK21zZ3N0ciAiZm9yemFyIGFjdHVhbGl6YWNpb25lcyIKKworIzogYnVpbHRpbi9wdXNoLmM6NTUxIGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTgxCittc2dpZCAiPHJlZm5hbWU+OjxleHBlY3Q+IgorbXNnc3RyICI8cmVmbmFtZT46PGV4cGVjdD4iCisKKyM6IGJ1aWx0aW4vcHVzaC5jOjU1MiBidWlsdGluL3NlbmQtcGFjay5jOjE4MgorbXNnaWQgInJlcXVpcmUgb2xkIHZhbHVlIG9mIHJlZiB0byBiZSBhdCB0aGlzIHZhbHVlIgorbXNnc3RyICJyZXF1aWVyZSBoYWJlciB2YWxvciB2aWVqbyBkZSByZWYgZW4gZXN0ZSB2YWxvciIKKworIzogYnVpbHRpbi9wdXNoLmM6NTU1Cittc2dpZCAiY29udHJvbCByZWN1cnNpdmUgcHVzaGluZyBvZiBzdWJtb2R1bGVzIgorbXNnc3RyICJjb250cm9sYXIgcHVzaCByZWN1cnNpdm8gZGUgc3VibcOzZHVsb3MiCisKKyM6IGJ1aWx0aW4vcHVzaC5jOjU1NyBidWlsdGluL3NlbmQtcGFjay5jOjE3NQorbXNnaWQgInVzZSB0aGluIHBhY2siCittc2dzdHIgInVzYXIgZW1wYXF1ZXRhZG8gZGVsZ2FkbyIKKworIzogYnVpbHRpbi9wdXNoLmM6NTU4IGJ1aWx0aW4vcHVzaC5jOjU1OSBidWlsdGluL3NlbmQtcGFjay5jOjE2MQorIzogYnVpbHRpbi9zZW5kLXBhY2suYzoxNjIKK21zZ2lkICJyZWNlaXZlIHBhY2sgcHJvZ3JhbSIKK21zZ3N0ciAicmVjaWJpciBwcm9ncmFtYSBkZSBwYXF1ZXRlIgorCisjOiBidWlsdGluL3B1c2guYzo1NjAKK21zZ2lkICJzZXQgdXBzdHJlYW0gZm9yIGdpdCBwdWxsL3N0YXR1cyIKK21zZ3N0ciAiY29uZmlndXJhciB1cHN0cmVhbSBwYXJhIGdpdCBwdWxsbC9zdGF0dXMiCisKKyM6IGJ1aWx0aW4vcHVzaC5jOjU2MworbXNnaWQgInBydW5lIGxvY2FsbHkgcmVtb3ZlZCByZWZzIgorbXNnc3RyICJyZWNvcnRhbmRvIHJlZnMgZWxpbWluYWRhcyBsb2NhbG1lbnRlIgorCisjOiBidWlsdGluL3B1c2guYzo1NjUKK21zZ2lkICJieXBhc3MgcHJlLXB1c2ggaG9vayIKK21zZ3N0ciAiaGFjZXIgdW4gYnlwYXNzIGFsIGhvb2sgcHJlLXB1c2giCisKKyM6IGJ1aWx0aW4vcHVzaC5jOjU2NgorbXNnaWQgInB1c2ggbWlzc2luZyBidXQgcmVsZXZhbnQgdGFncyIKK21zZ3N0ciAicmVhbGl6YXIgcHVzaCBkZSB0YWdzIGZhbHRhbnRlcyBwZXJvIHJlbGV2YW50ZXMiCisKKyM6IGJ1aWx0aW4vcHVzaC5jOjU2OSBidWlsdGluL3NlbmQtcGFjay5jOjE2OQorbXNnaWQgIkdQRyBzaWduIHRoZSBwdXNoIgorbXNnc3RyICJGaXJtYXIgY29uIEdQRyBlbCBwdXNoIgorCisjOiBidWlsdGluL3B1c2guYzo1NzEgYnVpbHRpbi9zZW5kLXBhY2suYzoxNzYKK21zZ2lkICJyZXF1ZXN0IGF0b21pYyB0cmFuc2FjdGlvbiBvbiByZW1vdGUgc2lkZSIKK21zZ3N0ciAic29saWNpdGFyIHRyYW5zYWNjacOzbiBhdMOzbWljYSBlbiBlbCBsYWRvIHJlbW90byIKKworIzogYnVpbHRpbi9wdXNoLmM6NTg5Cittc2dpZCAiLS1kZWxldGUgaXMgaW5jb21wYXRpYmxlIHdpdGggLS1hbGwsIC0tbWlycm9yIGFuZCAtLXRhZ3MiCittc2dzdHIgIi0tZGVsZXRlIGVzIGluY29tcGF0aWJsZSBjb24gLS1hbGwsIC0tbWlycm9yIHkgLS10YWdzIgorCisjOiBidWlsdGluL3B1c2guYzo1OTEKK21zZ2lkICItLWRlbGV0ZSBkb2Vzbid0IG1ha2Ugc2Vuc2Ugd2l0aG91dCBhbnkgcmVmcyIKK21zZ3N0ciAiLS1kZWxldGUgbm8gdGllbmUgc2VudGlkbyBzaW4gbmluZ3VuYSByZWZlcmVuY2lhIgorCisjOiBidWlsdGluL3B1c2guYzo2MTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiYmFkIHJlcG9zaXRvcnkgJyVzJyIKIG1zZ3N0ciAibWFsIHJlcG9zaXRvcmlvICclcyciCiAKLSM6IGJ1aWx0aW4vcHVzaC5jOjM5OQorIzogYnVpbHRpbi9wdXNoLmM6NjEyCiBtc2dpZCAiIgogIk5vIGNvbmZpZ3VyZWQgcHVzaCBkZXN0aW5hdGlvbi5cbiIKICJFaXRoZXIgc3BlY2lmeSB0aGUgVVJMIGZyb20gdGhlIGNvbW1hbmQtbGluZSBvciBjb25maWd1cmUgYSByZW1vdGUgIgpAQCAtMTY4NDUsMTA0ICsxNzAwNCwyNyBAQAogIlxuIgogIiAgICBnaXQgcHVzaCA8bm9tYnJlPlxuIgogCi0jOiBidWlsdGluL3B1c2guYzo1NTQKLW1zZ2lkICJyZXBvc2l0b3J5IgotbXNnc3RyICJyZXBvc2l0b3JpbyIKLQotIzogYnVpbHRpbi9wdXNoLmM6NTU1IGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTY0Ci1tc2dpZCAicHVzaCBhbGwgcmVmcyIKLW1zZ3N0ciAicmVhbGl6YXIgcHVzaCBhIHRvZGFzIGxhcyByZWZzIgotCi0jOiBidWlsdGluL3B1c2guYzo1NTYgYnVpbHRpbi9zZW5kLXBhY2suYzoxNjYKLW1zZ2lkICJtaXJyb3IgYWxsIHJlZnMiCi1tc2dzdHIgInJlYWxpemFyIG1pcnJvciBhIHRvZGFzIGxhcyByZWZzIgotCi0jOiBidWlsdGluL3B1c2guYzo1NTgKLW1zZ2lkICJkZWxldGUgcmVmcyIKLW1zZ3N0ciAiYm9ycmFyIHJlZnMiCi0KLSM6IGJ1aWx0aW4vcHVzaC5jOjU1OQotbXNnaWQgInB1c2ggdGFncyAoY2FuJ3QgYmUgdXNlZCB3aXRoIC0tYWxsIG9yIC0tbWlycm9yKSIKLW1zZ3N0ciAicmVhbGl6YXIgcHVzaCBhIHRhZ3MgKG5vIHB1ZWRlIHNlciB1c2FkbyBjb24gLS1hbGwgbyAtLW1pcnJvcikiCi0KLSM6IGJ1aWx0aW4vcHVzaC5jOjU2MiBidWlsdGluL3NlbmQtcGFjay5jOjE2NwotbXNnaWQgImZvcmNlIHVwZGF0ZXMiCi1tc2dzdHIgImZvcnphciBhY3R1YWxpemFjaW9uZXMiCi0KLSM6IGJ1aWx0aW4vcHVzaC5jOjU2NCBidWlsdGluL3NlbmQtcGFjay5jOjE4MQotbXNnaWQgIjxyZWZuYW1lPjo8ZXhwZWN0PiIKLW1zZ3N0ciAiPHJlZm5hbWU+OjxleHBlY3Q+IgotCi0jOiBidWlsdGluL3B1c2guYzo1NjUgYnVpbHRpbi9zZW5kLXBhY2suYzoxODIKLW1zZ2lkICJyZXF1aXJlIG9sZCB2YWx1ZSBvZiByZWYgdG8gYmUgYXQgdGhpcyB2YWx1ZSIKLW1zZ3N0ciAicmVxdWllcmUgaGFiZXIgdmFsb3Igdmllam8gZGUgcmVmIGVuIGVzdGUgdmFsb3IiCi0KLSM6IGJ1aWx0aW4vcHVzaC5jOjU2OAotbXNnaWQgImNvbnRyb2wgcmVjdXJzaXZlIHB1c2hpbmcgb2Ygc3VibW9kdWxlcyIKLW1zZ3N0ciAiY29udHJvbGFyIHB1c2ggcmVjdXJzaXZvIGRlIHN1Ym3Ds2R1bG9zIgotCi0jOiBidWlsdGluL3B1c2guYzo1NzAgYnVpbHRpbi9zZW5kLXBhY2suYzoxNzUKLW1zZ2lkICJ1c2UgdGhpbiBwYWNrIgotbXNnc3RyICJ1c2FyIGVtcGFxdWV0YWRvIGRlbGdhZG8iCi0KLSM6IGJ1aWx0aW4vcHVzaC5jOjU3MSBidWlsdGluL3B1c2guYzo1NzIgYnVpbHRpbi9zZW5kLXBhY2suYzoxNjEKLSM6IGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTYyCi1tc2dpZCAicmVjZWl2ZSBwYWNrIHByb2dyYW0iCi1tc2dzdHIgInJlY2liaXIgcHJvZ3JhbWEgZGUgcGFxdWV0ZSIKLQotIzogYnVpbHRpbi9wdXNoLmM6NTczCi1tc2dpZCAic2V0IHVwc3RyZWFtIGZvciBnaXQgcHVsbC9zdGF0dXMiCi1tc2dzdHIgImNvbmZpZ3VyYXIgdXBzdHJlYW0gcGFyYSBnaXQgcHVsbGwvc3RhdHVzIgotCi0jOiBidWlsdGluL3B1c2guYzo1NzYKLW1zZ2lkICJwcnVuZSBsb2NhbGx5IHJlbW92ZWQgcmVmcyIKLW1zZ3N0ciAicmVjb3J0YW5kbyByZWZzIHJlbW92aWRhcyBsb2NhbG1lbnRlIgotCi0jOiBidWlsdGluL3B1c2guYzo1NzgKLW1zZ2lkICJieXBhc3MgcHJlLXB1c2ggaG9vayIKLW1zZ3N0ciAiaGFjZXIgdW4gYnlwYXNzIGFsIGhvb2sgcHJlLXB1c2giCi0KLSM6IGJ1aWx0aW4vcHVzaC5jOjU3OQotbXNnaWQgInB1c2ggbWlzc2luZyBidXQgcmVsZXZhbnQgdGFncyIKLW1zZ3N0ciAicmVhbGl6YXIgcHVzaCBkZSB0YWdzIGZhbHRhbnRlcyBwZXJvIHJlbGV2YW50ZXMiCi0KLSM6IGJ1aWx0aW4vcHVzaC5jOjU4MiBidWlsdGluL3NlbmQtcGFjay5jOjE2OQotbXNnaWQgIkdQRyBzaWduIHRoZSBwdXNoIgotbXNnc3RyICJGaXJtYXIgY29uIEdQRyBlbCBwdXNoIgotCi0jOiBidWlsdGluL3B1c2guYzo1ODQgYnVpbHRpbi9zZW5kLXBhY2suYzoxNzYKLW1zZ2lkICJyZXF1ZXN0IGF0b21pYyB0cmFuc2FjdGlvbiBvbiByZW1vdGUgc2lkZSIKLW1zZ3N0ciAic29saWNpdGFyIHRyYW5zYWNjacOzbiBhdMOzbWljYSBlbiBlbCBsYWRvIHJlbW90byIKLQotIzogYnVpbHRpbi9wdXNoLmM6NjAyCi1tc2dpZCAiLS1kZWxldGUgaXMgaW5jb21wYXRpYmxlIHdpdGggLS1hbGwsIC0tbWlycm9yIGFuZCAtLXRhZ3MiCi1tc2dzdHIgIi0tZGVsZXRlIGVzIGluY29tcGF0aWJsZSBjb24gLS1hbGwsIC0tbWlycm9yIHkgLS10YWdzIgotCi0jOiBidWlsdGluL3B1c2guYzo2MDQKLW1zZ2lkICItLWRlbGV0ZSBkb2Vzbid0IG1ha2Ugc2Vuc2Ugd2l0aG91dCBhbnkgcmVmcyIKLW1zZ3N0ciAiLS1kZWxldGUgbm8gdGllbmUgc2VudGlkbyBzaW4gbmluZ3VuYSByZWZlcmVuY2lhIgotCi0jOiBidWlsdGluL3B1c2guYzo2MDcKKyM6IGJ1aWx0aW4vcHVzaC5jOjYyNwogbXNnaWQgIi0tYWxsIGFuZCAtLXRhZ3MgYXJlIGluY29tcGF0aWJsZSIKIG1zZ3N0ciAiLS1hbGwgeSAtLXRhZ3Mgc29uIGluY29tcGF0aWJsZXMiCiAKLSM6IGJ1aWx0aW4vcHVzaC5jOjYwOQorIzogYnVpbHRpbi9wdXNoLmM6NjI5CiBtc2dpZCAiLS1hbGwgY2FuJ3QgYmUgY29tYmluZWQgd2l0aCByZWZzcGVjcyIKIG1zZ3N0ciAiLS1hbGwgbm8gcHVlZGUgc2VyIGNvbWJpbmFkYSBjb24gcmVmc3BlY3MiCiAKLSM6IGJ1aWx0aW4vcHVzaC5jOjYxMworIzogYnVpbHRpbi9wdXNoLmM6NjMzCiBtc2dpZCAiLS1taXJyb3IgYW5kIC0tdGFncyBhcmUgaW5jb21wYXRpYmxlIgogbXNnc3RyICItLW1pcnJvciB5IC0tdGFncyBzb24gaW5jb21wYXRpYmxlcyIKIAotIzogYnVpbHRpbi9wdXNoLmM6NjE1CisjOiBidWlsdGluL3B1c2guYzo2MzUKIG1zZ2lkICItLW1pcnJvciBjYW4ndCBiZSBjb21iaW5lZCB3aXRoIHJlZnNwZWNzIgogbXNnc3RyICItLW1pcnJvciBubyBwdWVkZSBzZXIgY29tYmluYWRvIGNvbiByZWZzcGVjcyIKIAotIzogYnVpbHRpbi9wdXNoLmM6NjE4CisjOiBidWlsdGluL3B1c2guYzo2MzgKIG1zZ2lkICItLWFsbCBhbmQgLS1taXJyb3IgYXJlIGluY29tcGF0aWJsZSIKIG1zZ3N0ciAiLS1hbGwgeSAtLW1pcnJvciBzb24gaW5jb21wYXRpYmxlcyIKIAotIzogYnVpbHRpbi9wdXNoLmM6NjM3CisjOiBidWlsdGluL3B1c2guYzo2NDIKIG1zZ2lkICJwdXNoIG9wdGlvbnMgbXVzdCBub3QgaGF2ZSBuZXcgbGluZSBjaGFyYWN0ZXJzIgogbXNnc3RyICJvcGNpb25lcyBkZSBwdXNoIG5vIHB1ZWRlbiB0ZW5lciBjYXJhY3RlcmVzIGRlIGzDrW5lYSBudWV2YSIKIApAQCAtMTcwNjIsMTEgKzE3MTQ0LDExIEBACiAKICM6IGJ1aWx0aW4vcmViYXNlLmM6MzIKIG1zZ2lkICIiCi0iZ2l0IHJlYmFzZSBbLWldIFtvcHRpb25zXSBbLS1leGVjIDxjbWQ+XSBbLS1vbnRvIDxuZXdiYXNlPl0gWzx1cHN0cmVhbT5dICIKLSJbPGJyYW5jaD5dIgorImdpdCByZWJhc2UgWy1pXSBbb3B0aW9uc10gWy0tZXhlYyA8Y21kPl0gWy0tb250byA8bmV3YmFzZT4gfCAtLWtlZXAtYmFzZV0gIgorIls8dXBzdHJlYW0+IFs8YnJhbmNoPl1dIgogbXNnc3RyICIiCi0iZ2l0IHJlYmFzZSBbLWldIFtvcGNpb25lc10gWy0tZXhlYyA8Y21kPl0gWy0tb250byA8bmV3YmFzZT5dIFs8dXBzdHJlYW0+XSAiCi0iWzxicmFuY2g+XSIKKyJnaXQgcmViYXNlIFstaV0gW29wY2lvbmVzXSBbLS1leGVjIDxjbWQ+XSBbLS1vbnRvIDxuZXdiYXNlPiB8IC0ta2VlcC1iYXNlXSAiCisiWzx1cHN0cmVhbT4gWzxicmFuY2g+XV0iCiAKICM6IGJ1aWx0aW4vcmViYXNlLmM6MzQKIG1zZ2lkICIiCkBAIC0xNzEwNSwxODkgKzE3MTg3LDE4OSBAQAogbXNnaWQgImNvdWxkIG5vdCBnZW5lcmF0ZSB0b2RvIGxpc3QiCiBtc2dzdHIgIm5vIHNlIHB1ZG8gZ2VuZXJhciBsaXN0YSBkZSBwZW5kaWVudGVzIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjM4MgorIzogYnVpbHRpbi9yZWJhc2UuYzozODMKIG1zZ2lkICJhIGJhc2UgY29tbWl0IG11c3QgYmUgcHJvdmlkZWQgd2l0aCAtLXVwc3RyZWFtIG9yIC0tb250byIKIG1zZ3N0ciAidW4gY29tbWl0IGJhc2UgdGllbmUgcXVlIHNlciBwcm92aXN0byBjb24gLS11cHN0cmVhbSBvIC0tb250byIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0MzcKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDM4CiBtc2dpZCAiZ2l0IHJlYmFzZS0taW50ZXJhY3RpdmUgWzxvcHRpb25zPl0iCiBtc2dzdHIgImdpdCByZWJhc2UtLWludGVyYWN0aXZlIFs8b3BjaW9uZXM+XSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0NDkKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDUwCiBtc2dpZCAia2VlcCBlbXB0eSBjb21taXRzIgogbXNnc3RyICJtYW50ZW5lciBjb21taXRzIHZhY8Otb3MiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDUxIGJ1aWx0aW4vcmV2ZXJ0LmM6MTI4CisjOiBidWlsdGluL3JlYmFzZS5jOjQ1MiBidWlsdGluL3JldmVydC5jOjEyOAogbXNnaWQgImFsbG93IGNvbW1pdHMgd2l0aCBlbXB0eSBtZXNzYWdlcyIKIG1zZ3N0ciAicGVybWl0aXIgY29tbWl0cyBjb24gbWVuc2FqZXMgdmFjw61vcyIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0NTIKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDUzCiBtc2dpZCAicmViYXNlIG1lcmdlIGNvbW1pdHMiCiBtc2dzdHIgInJlYmFzYW5kbyBjb21taXRzIGRlIGZ1c2nDs24iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDU0CisjOiBidWlsdGluL3JlYmFzZS5jOjQ1NQogbXNnaWQgImtlZXAgb3JpZ2luYWwgYnJhbmNoIHBvaW50cyBvZiBjb3VzaW5zIgogbXNnc3RyICJtYW50ZW5lciBwdW50b3Mgb3JpZ2luYWxlcyBkZSBsYSByYW1hIGRlIHN1cyBwcmltb3MiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDU2CisjOiBidWlsdGluL3JlYmFzZS5jOjQ1NwogbXNnaWQgIm1vdmUgY29tbWl0cyB0aGF0IGJlZ2luIHdpdGggc3F1YXNoIS9maXh1cCEiCiBtc2dzdHIgIm1vdmVyIGNvbW1pdHMgcXVlIGNvbWllbnphbiBjb24gc3F1YXNoIS9maXh1cCEiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDU3CisjOiBidWlsdGluL3JlYmFzZS5jOjQ1OAogbXNnaWQgInNpZ24gY29tbWl0cyIKIG1zZ3N0ciAiZmlybWFyIGNvbW1pdHMiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDU5IGJ1aWx0aW4vcmViYXNlLmM6MTQwMworIzogYnVpbHRpbi9yZWJhc2UuYzo0NjAgYnVpbHRpbi9yZWJhc2UuYzoxNDI3CiBtc2dpZCAiZGlzcGxheSBhIGRpZmZzdGF0IG9mIHdoYXQgY2hhbmdlZCB1cHN0cmVhbSIKIG1zZ3N0ciAibW9zdHJhciB1biBkaWZmc3RhdCBkZSBsbyBxdWUgY2FtYmnDsyBlbiB1cHN0cmVhbSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0NjEKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDYyCiBtc2dpZCAiY29udGludWUgcmViYXNlIgogbXNnc3RyICJjb250aW51YXIgcmViYXNlIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ2MworIzogYnVpbHRpbi9yZWJhc2UuYzo0NjQKIG1zZ2lkICJza2lwIGNvbW1pdCIKIG1zZ3N0ciAic2FsdGFyIGNvbW1pdCIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0NjQKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDY1CiBtc2dpZCAiZWRpdCB0aGUgdG9kbyBsaXN0IgogbXNnc3RyICJlZGl0YXIgbGEgbGlzdGEgZGUgcGVuZGllbnRlcyIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0NjYKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDY3CiBtc2dpZCAic2hvdyB0aGUgY3VycmVudCBwYXRjaCIKIG1zZ3N0ciAibW9zdHJhciBlbCBwYXJjaGUgYWN0dWFsIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ2OQorIzogYnVpbHRpbi9yZWJhc2UuYzo0NzAKIG1zZ2lkICJzaG9ydGVuIGNvbW1pdCBpZHMgaW4gdGhlIHRvZG8gbGlzdCIKIG1zZ3N0ciAiaWRzIGRlIGNvbW1pdHMgY29ydG9zIGVuIGxhIGxpc3RhIGRlIHBlbmRpZW50ZXMiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDcxCisjOiBidWlsdGluL3JlYmFzZS5jOjQ3MgogbXNnaWQgImV4cGFuZCBjb21taXQgaWRzIGluIHRoZSB0b2RvIGxpc3QiCiBtc2dzdHIgImV4cGFuZGlyIGlkcyBkZSBjb21taXRzIGVuIGxhIGxpc3RhIGRlIHBlbmRpZW50ZXMiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDczCisjOiBidWlsdGluL3JlYmFzZS5jOjQ3NAogbXNnaWQgImNoZWNrIHRoZSB0b2RvIGxpc3QiCiBtc2dzdHIgInJldmlzYXIgbGEgbGlzdGEgZGUgcGVuZGllbnRlcyIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0NzUKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDc2CiBtc2dpZCAicmVhcnJhbmdlIGZpeHVwL3NxdWFzaCBsaW5lcyIKIG1zZ3N0ciAicmVvcmdhbml6YXIgbMOtbmVhcyBmaXh1cC9zcXVhc2giCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDc3CisjOiBidWlsdGluL3JlYmFzZS5jOjQ3OAogbXNnaWQgImluc2VydCBleGVjIGNvbW1hbmRzIGluIHRvZG8gbGlzdCIKIG1zZ3N0ciAiaW5zZXJ0YXIgY29tYW5kbyBleGVjIGVuIGxhIGxpc3RhIGRlIHBlbmRpZW50ZXMiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDc4CisjOiBidWlsdGluL3JlYmFzZS5jOjQ3OQogbXNnaWQgIm9udG8iCiBtc2dzdHIgImhhY2lhIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ4MQorIzogYnVpbHRpbi9yZWJhc2UuYzo0ODIKIG1zZ2lkICJyZXN0cmljdC1yZXZpc2lvbiIKIG1zZ3N0ciAicmVzdHJpY3QtcmV2aXNpb24iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDgxCisjOiBidWlsdGluL3JlYmFzZS5jOjQ4MgogbXNnaWQgInJlc3RyaWN0IHJldmlzaW9uIgogbXNnc3RyICJyZXN0cmluZ2lyIHJldmlzaW9uIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ4MworIzogYnVpbHRpbi9yZWJhc2UuYzo0ODQKIG1zZ2lkICJzcXVhc2gtb250byIKIG1zZ3N0ciAic3F1YXNoLW9udG8iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDg0CisjOiBidWlsdGluL3JlYmFzZS5jOjQ4NQogbXNnaWQgInNxdWFzaCBvbnRvIgogbXNnc3RyICJzcXVhc2ggaGFjaWEiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDg2CisjOiBidWlsdGluL3JlYmFzZS5jOjQ4NwogbXNnaWQgInRoZSB1cHN0cmVhbSBjb21taXQiCiBtc2dzdHIgImVsIGNvbW1pdCBkZSB1cHN0cmVhbSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0ODgKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDg5CiBtc2dpZCAiaGVhZC1uYW1lIgogbXNnc3RyICJoZWFkLW5hbWUiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDg4CisjOiBidWlsdGluL3JlYmFzZS5jOjQ4OQogbXNnaWQgImhlYWQgbmFtZSIKIG1zZ3N0ciAibm9tYnJlIGRlIGhlYWQiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDkzCisjOiBidWlsdGluL3JlYmFzZS5jOjQ5NAogbXNnaWQgInJlYmFzZSBzdHJhdGVneSIKIG1zZ3N0ciAiZXN0cmF0ZWdpYSBkZSByZWJhc2UiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDk0CisjOiBidWlsdGluL3JlYmFzZS5jOjQ5NQogbXNnaWQgInN0cmF0ZWd5LW9wdHMiCiBtc2dzdHIgInN0cmF0ZWd5LW9wdHMiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDk1CisjOiBidWlsdGluL3JlYmFzZS5jOjQ5NgogbXNnaWQgInN0cmF0ZWd5IG9wdGlvbnMiCiBtc2dzdHIgIm9wY2lvbmVzIGRlIGVzdHJhdGVnaWEiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDk2CisjOiBidWlsdGluL3JlYmFzZS5jOjQ5NwogbXNnaWQgInN3aXRjaC10byIKIG1zZ3N0ciAiY2FtYmlhciBhIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ5NworIzogYnVpbHRpbi9yZWJhc2UuYzo0OTgKIG1zZ2lkICJ0aGUgYnJhbmNoIG9yIGNvbW1pdCB0byBjaGVja291dCIKIG1zZ3N0ciAibGEgcmFtYSBvIGNvbW1pdCBwYXJhIGhhY2VyIGNoZWNrb3V0IgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ5OAorIzogYnVpbHRpbi9yZWJhc2UuYzo0OTkKIG1zZ2lkICJvbnRvLW5hbWUiCiBtc2dzdHIgImhhY2lhLW5vbWJyZSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0OTgKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDk5CiBtc2dpZCAib250byBuYW1lIgogbXNnc3RyICJoYWNpYSBub21icmUiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDk5CisjOiBidWlsdGluL3JlYmFzZS5jOjUwMAogbXNnaWQgImNtZCIKIG1zZ3N0ciAiY21kIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ5OQorIzogYnVpbHRpbi9yZWJhc2UuYzo1MDAKIG1zZ2lkICJ0aGUgY29tbWFuZCB0byBydW4iCiBtc2dzdHIgImVsIGNvbWFuZG8gcGFyYSBlamVjdXRhciIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo1MDIgYnVpbHRpbi9yZWJhc2UuYzoxNDg2CisjOiBidWlsdGluL3JlYmFzZS5jOjUwMyBidWlsdGluL3JlYmFzZS5jOjE1MTAKIG1zZ2lkICJhdXRvbWF0aWNhbGx5IHJlLXNjaGVkdWxlIGFueSBgZXhlY2AgdGhhdCBmYWlscyIKIG1zZ3N0ciAicmVwcm9ncmFtYXIgYXV0b21hdGljYW1lbnRlIGN1YWxxdWllciBgZXhlY2AgcXVlIGZhbGxlIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjUxOAorIzogYnVpbHRpbi9yZWJhc2UuYzo1MTkKIG1zZ2lkICItLVtuby1dcmViYXNlLWNvdXNpbnMgaGFzIG5vIGVmZmVjdCB3aXRob3V0IC0tcmViYXNlLW1lcmdlcyIKIG1zZ3N0ciAiLS1bbm8tXXJlYmFzZS1jb3VzaW5zIG5vIHRpZW5lIGVmZWN0byBzaW4gLS1yZWJhc2UtbWVyZ2VzIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjUzNAorIzogYnVpbHRpbi9yZWJhc2UuYzo1MzUKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgcmVxdWlyZXMgYW4gaW50ZXJhY3RpdmUgcmViYXNlIgogbXNnc3RyICIlcyByZXF1aWVyZSB1biByZWJhc2UgaW50ZXJhY3Rpdm8iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NTg2CisjOiBidWlsdGluL3JlYmFzZS5jOjU4NwogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgZ2V0ICdvbnRvJzogJyVzJyIKIG1zZ3N0ciAibm8gc2UgcHVkbyBjb25zZWd1aXIgJ29udG8nOiAnJXMnIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjYwMQorIzogYnVpbHRpbi9yZWJhc2UuYzo2MDIKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBvcmlnLWhlYWQ6ICclcyciCiBtc2dzdHIgIm9yaWctaGVhZCBpbnbDoWxpZG86ICclcyciCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NjI2CisjOiBidWlsdGluL3JlYmFzZS5jOjYyNwogIywgYy1mb3JtYXQKIG1zZ2lkICJpZ25vcmluZyBpbnZhbGlkIGFsbG93X3JlcmVyZV9hdXRvdXBkYXRlOiAnJXMnIgogbXNnc3RyICJpZ25vcmFuZG8gaW52w6FsaWRvIGFsbG93X3JlcmVyZV9hdXRvdXBkYXRlOiAnJXMnIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjcwMgorIzogYnVpbHRpbi9yZWJhc2UuYzo3MDMKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ291bGQgbm90IHJlYWQgJyVzJyIKIG1zZ3N0ciAiTm8gc2UgcHVkbyBsZWVyICclcyciCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NzIwCisjOiBidWlsdGluL3JlYmFzZS5jOjcyMQogIywgYy1mb3JtYXQKIG1zZ2lkICJDYW5ub3Qgc3RvcmUgJXMiCiBtc2dzdHIgIk5vIHNlIHB1ZWRlIGd1YXJkYXIgJXMiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6ODI3CisjOiBidWlsdGluL3JlYmFzZS5jOjgyOAogbXNnaWQgImNvdWxkIG5vdCBkZXRlcm1pbmUgSEVBRCByZXZpc2lvbiIKIG1zZ3N0ciAibm8gc2UgcHVkbyBkZXRlcm1pbmFyIHJldmlzacOzbiBIRUFEIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjk1MCBnaXQtcmViYXNlLS1wcmVzZXJ2ZS1tZXJnZXMuc2g6ODEKKyM6IGJ1aWx0aW4vcmViYXNlLmM6OTUxIGdpdC1yZWJhc2UtLXByZXNlcnZlLW1lcmdlcy5zaDo4MQogbXNnaWQgIiIKICJSZXNvbHZlIGFsbCBjb25mbGljdHMgbWFudWFsbHksIG1hcmsgdGhlbSBhcyByZXNvbHZlZCB3aXRoXG4iCiAiXCJnaXQgYWRkL3JtIDxjb25mbGljdGVkX2ZpbGVzPlwiLCB0aGVuIHJ1biBcImdpdCByZWJhc2UgLS1jb250aW51ZVwiLlxuIgpAQCAtMTczMDIsNyArMTczODQsNyBAQAogIlBhcmEgYWJvcnRhciB5IHJlZ3Jlc2FyIGFsIGVzdGFkbyBwcmV2aW8gYWwgXCJnaXQgcmViYXNlXCIsIGVqZWN1dGEgXCJnaXQgIgogInJlYmFzZSAtLWFib3J0XCIuIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjEwMzEKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTAzMgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiXG4iCkBAIC0xNzMyMSw3ICsxNzQwMyw3IEBACiAiXG4iCiAiQ29tbyByZXN1bHRhZG8sIGdpdCBubyBwdWVkZSBoYWNlciByZWJhc2UgY29uIGVsbG9zLiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxMzE4CisjOiBidWlsdGluL3JlYmFzZS5jOjEzMzkKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIiVzXG4iCkBAIC0xNzMzOCw3ICsxNzQyMCw3IEBACiAiICAgIGdpdCByZWJhc2UgJzxyYW1hPidcbiIKICJcbiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxMzM0CisjOiBidWlsdGluL3JlYmFzZS5jOjEzNTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIklmIHlvdSB3aXNoIHRvIHNldCB0cmFja2luZyBpbmZvcm1hdGlvbiBmb3IgdGhpcyBicmFuY2ggeW91IGNhbiBkbyBzbyB3aXRoOlxuIgpAQCAtMTczNTEsMTU4ICsxNzQzMywxNzAgQEAKICIgICAgZ2l0IGJyYW5jaCAtLXNldC11cHN0cmVhbS10bz0lcy88cmFtYT4gJXNcbiIKICJcbiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxMzY0CisjOiBidWlsdGluL3JlYmFzZS5jOjEzODUKIG1zZ2lkICJleGVjIGNvbW1hbmRzIGNhbm5vdCBjb250YWluIG5ld2xpbmVzIgogbXNnc3RyICJjb21hbmRvcyBleGVjIG5vIHB1ZWRlbiBjb250ZW5lciBuZXdsaW5lcyIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxMzY4CisjOiBidWlsdGluL3JlYmFzZS5jOjEzODkKIG1zZ2lkICJlbXB0eSBleGVjIGNvbW1hbmQiCiBtc2dzdHIgImNvbWFuZG8gZXhlYyB2YWPDrW8iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTM5NgorIzogYnVpbHRpbi9yZWJhc2UuYzoxNDE4CiBtc2dpZCAicmViYXNlIG9udG8gZ2l2ZW4gYnJhbmNoIGluc3RlYWQgb2YgdXBzdHJlYW0iCiBtc2dzdHIgImhhY2llbmRvIHJlYmFzZSBoYWNpYSByYW1hIGRhZGEgZW4gbHVnYXIgZGUgdXBzdHJlYW0iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTM5OAorIzogYnVpbHRpbi9yZWJhc2UuYzoxNDIwCittc2dpZCAidXNlIHRoZSBtZXJnZS1iYXNlIG9mIHVwc3RyZWFtIGFuZCBicmFuY2ggYXMgdGhlIGN1cnJlbnQgYmFzZSIKK21zZ3N0ciAidXNhciBsYSBiYXNlIGRlIGZ1c2nDs24gZGUgdXBzdHJlYW0geSBsYSByYW1hIGNvbW8gYmFzZSBhY3R1YWwiCisKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQyMgogbXNnaWQgImFsbG93IHByZS1yZWJhc2UgaG9vayB0byBydW4iCiBtc2dzdHIgInBlcm1pdGlyIGVqZWN1dGFyIGhvb2sgcHJlLXJlYmFzZSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDAwCisjOiBidWlsdGluL3JlYmFzZS5jOjE0MjQKIG1zZ2lkICJiZSBxdWlldC4gaW1wbGllcyAtLW5vLXN0YXQiCiBtc2dzdHIgInNlciBzaWxlbmNpb3NvIGltcGxpY2EgLS1uby1zdGF0IgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0MDYKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQzMAogbXNnaWQgImRvIG5vdCBzaG93IGRpZmZzdGF0IG9mIHdoYXQgY2hhbmdlZCB1cHN0cmVhbSIKIG1zZ3N0ciAibm8gbW9zdHJhciB1biBkaWZmc3RhdCBkZSBsbyBxdWUgY2FtYmnDsyBlbiB1cHN0cmVhbSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDA5CisjOiBidWlsdGluL3JlYmFzZS5jOjE0MzMKIG1zZ2lkICJhZGQgYSBTaWduZWQtb2ZmLWJ5OiBsaW5lIHRvIGVhY2ggY29tbWl0IgogbXNnc3RyICJhZ3JlZ2FyIHVuYSBsw61uZWEgXCJGaXJtYWRvLXBvclwiIGFsIG1lbnNhamUgZGUgY2FkYSBjb21taXQiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQxMSBidWlsdGluL3JlYmFzZS5jOjE0MTUgYnVpbHRpbi9yZWJhc2UuYzoxNDE3CisjOiBidWlsdGluL3JlYmFzZS5jOjE0MzUgYnVpbHRpbi9yZWJhc2UuYzoxNDM5IGJ1aWx0aW4vcmViYXNlLmM6MTQ0MQogbXNnaWQgInBhc3NlZCB0byAnZ2l0IGFtJyIKIG1zZ3N0ciAicGFzYWRvIGEgJ2dpdCBhbSciCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQxOSBidWlsdGluL3JlYmFzZS5jOjE0MjEKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ0MyBidWlsdGluL3JlYmFzZS5jOjE0NDUKIG1zZ2lkICJwYXNzZWQgdG8gJ2dpdCBhcHBseSciCiBtc2dzdHIgInBhc2FkbyBhICdnaXQtYXBwbHknIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0MjMgYnVpbHRpbi9yZWJhc2UuYzoxNDI2CisjOiBidWlsdGluL3JlYmFzZS5jOjE0NDcgYnVpbHRpbi9yZWJhc2UuYzoxNDUwCiBtc2dpZCAiY2hlcnJ5LXBpY2sgYWxsIGNvbW1pdHMsIGV2ZW4gaWYgdW5jaGFuZ2VkIgogbXNnc3RyICJjaGVycnktcGljayB0b2RvcyBsb3MgY29tbWl0cywgaW5jbHVzbyBzaSBubyBoYW4gY2FtYmlhZG8iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQyOAorIzogYnVpbHRpbi9yZWJhc2UuYzoxNDUyCiBtc2dpZCAiY29udGludWUiCiBtc2dzdHIgImNvbnRpbnVhciIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDMxCisjOiBidWlsdGluL3JlYmFzZS5jOjE0NTUKIG1zZ2lkICJza2lwIGN1cnJlbnQgcGF0Y2ggYW5kIGNvbnRpbnVlIgogbXNnc3RyICJzYWx0YXIgZWwgcGFyY2hlIHkgY29udGludWFyIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0MzMKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ1NwogbXNnaWQgImFib3J0IGFuZCBjaGVjayBvdXQgdGhlIG9yaWdpbmFsIGJyYW5jaCIKIG1zZ3N0ciAiYWJvcnRhIHkgcmV2aXNhIGxhIHJhbWEgb3JpZ2luYWwiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQzNgorIzogYnVpbHRpbi9yZWJhc2UuYzoxNDYwCiBtc2dpZCAiYWJvcnQgYnV0IGtlZXAgSEVBRCB3aGVyZSBpdCBpcyIKIG1zZ3N0ciAiYWJvcnRhIHBlcm8gbWFudGllbmUgSEVBRCBkb25kZSBlc3TDoSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDM3CisjOiBidWlsdGluL3JlYmFzZS5jOjE0NjEKIG1zZ2lkICJlZGl0IHRoZSB0b2RvIGxpc3QgZHVyaW5nIGFuIGludGVyYWN0aXZlIHJlYmFzZSIKIG1zZ3N0ciAiZWRpdGFyIGxhIGxpc3RhIGRlIHBlbmRpZW50ZXMgZHVyYW50ZSBlbCByZWJhc2UgaW50ZXJhY3Rpdm8iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ0MAorIzogYnVpbHRpbi9yZWJhc2UuYzoxNDY0CiBtc2dpZCAic2hvdyB0aGUgcGF0Y2ggZmlsZSBiZWluZyBhcHBsaWVkIG9yIG1lcmdlZCIKIG1zZ3N0ciAibXVlc3RyYSBlbCBhcmNoaXZvIHBhcmNoZSBzaWVuZG8gYXBsaWNhZG8gbyBmdXNpb25hZG8iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ0MworIzogYnVpbHRpbi9yZWJhc2UuYzoxNDY3CiBtc2dpZCAidXNlIG1lcmdpbmcgc3RyYXRlZ2llcyB0byByZWJhc2UiCiBtc2dzdHIgInVzYXIgZXN0cmF0ZWdpYXMgZGUgZnVzacOzbiBwYXJhIGVsIHJlYmFzZSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDQ3CisjOiBidWlsdGluL3JlYmFzZS5jOjE0NzEKIG1zZ2lkICJsZXQgdGhlIHVzZXIgZWRpdCB0aGUgbGlzdCBvZiBjb21taXRzIHRvIHJlYmFzZSIKIG1zZ3N0ciAicGVybWl0aXIgYWwgdXN1YXJpbyBlZGl0YXIgbGEgbGlzdGEgZGUgY29tbWl0cyBwYXJhIHJlYmFzYXIiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ1MQorIzogYnVpbHRpbi9yZWJhc2UuYzoxNDc1CiBtc2dpZCAiKERFUFJFQ0FURUQpIHRyeSB0byByZWNyZWF0ZSBtZXJnZXMgaW5zdGVhZCBvZiBpZ25vcmluZyB0aGVtIgogbXNnc3RyICIoREVQUkVDQURPKSBpbnRlbnRhciByZWNyZWFyIG1lcmdlcyBlbiBsdWdhciBkZSBpZ25vcmFybG9zIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0NTUKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ3OQogbXNnaWQgInByZXNlcnZlIGVtcHR5IGNvbW1pdHMgZHVyaW5nIHJlYmFzZSIKIG1zZ3N0ciAicHJlc2VydmFyIGNvbW1pdHMgdmFjw61vcyBkdXJhbnRlIGVsIHJlYmFzZSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDU3CisjOiBidWlsdGluL3JlYmFzZS5jOjE0ODEKIG1zZ2lkICJtb3ZlIGNvbW1pdHMgdGhhdCBiZWdpbiB3aXRoIHNxdWFzaCEvZml4dXAhIHVuZGVyIC1pIgogbXNnc3RyICJtb3ZlciBjb21taXRzIHF1ZSBjb21pZW56YW4gY29uIHNxdWFzaCEvZml4dXAhIGJham8gLWkiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ2MworIzogYnVpbHRpbi9yZWJhc2UuYzoxNDg3CiBtc2dpZCAiYXV0b21hdGljYWxseSBzdGFzaC9zdGFzaCBwb3AgYmVmb3JlIGFuZCBhZnRlciIKIG1zZ3N0ciAiZWplY3V0YXIgYXV0b23DoXRpY2FtZW50ZSBzdGFzaC9zdGFzaCBwb3AgYW50ZXMgeSBkZXNwdcOpcyIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDY1CisjOiBidWlsdGluL3JlYmFzZS5jOjE0ODkKIG1zZ2lkICJhZGQgZXhlYyBsaW5lcyBhZnRlciBlYWNoIGNvbW1pdCBvZiB0aGUgZWRpdGFibGUgbGlzdCIKIG1zZ3N0ciAiYWdyZWdhciBsw61uZWFzIGV4ZWMgdHJhcyBjYWRhIGFjb21taXQgZGUgbGEgbGlzdGEgZWRpdGFibGUiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ2OQorIzogYnVpbHRpbi9yZWJhc2UuYzoxNDkzCiBtc2dpZCAiYWxsb3cgcmViYXNpbmcgY29tbWl0cyB3aXRoIGVtcHR5IG1lc3NhZ2VzIgogbXNnc3RyICJwZXJtaXRpciByZWJhc2UgY29tbWl0cyBjb24gbWVuc2FqZXMgdmFjw61vcyIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDcyCisjOiBidWlsdGluL3JlYmFzZS5jOjE0OTYKIG1zZ2lkICJ0cnkgdG8gcmViYXNlIG1lcmdlcyBpbnN0ZWFkIG9mIHNraXBwaW5nIHRoZW0iCiBtc2dzdHIgImludGVudGFyIGZ1c2lvbmVzIHBvciByZWJhc2UgZW4gbHVnYXIgZGUgc2FsdGFybGFzIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0NzUKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ5OQogbXNnaWQgInVzZSAnbWVyZ2UtYmFzZSAtLWZvcmstcG9pbnQnIHRvIHJlZmluZSB1cHN0cmVhbSIKIG1zZ3N0ciAidXNlICdtZXJnZS1iYXNlIC0tZm9yay1wb2ludCcgcGFyYSByZWZpbmFyIHVwc3RyZWFtIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0NzcKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTUwMQogbXNnaWQgInVzZSB0aGUgZ2l2ZW4gbWVyZ2Ugc3RyYXRlZ3kiCiBtc2dzdHIgInVzYXIgbGEgZXN0cmF0ZWdpYSBkZSBtZXJnZSBkYWRhIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0NzkgYnVpbHRpbi9yZXZlcnQuYzoxMTUKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTUwMyBidWlsdGluL3JldmVydC5jOjExNQogbXNnaWQgIm9wdGlvbiIKIG1zZ3N0ciAib3BjacOzbiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDgwCisjOiBidWlsdGluL3JlYmFzZS5jOjE1MDQKIG1zZ2lkICJwYXNzIHRoZSBhcmd1bWVudCB0aHJvdWdoIHRvIHRoZSBtZXJnZSBzdHJhdGVneSIKIG1zZ3N0ciAicGFzYXIgZWwgYXJndW1lbnRvIHBhcmEgbGEgZXN0cmF0ZWdpYSBkZSBmdXNpw7NuIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0ODMKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTUwNwogbXNnaWQgInJlYmFzZSBhbGwgcmVhY2hhYmxlIGNvbW1pdHMgdXAgdG8gdGhlIHJvb3QocykiCiBtc2dzdHIgImhhY2VyIHJlYmFzZSBhIHRvZG9zIGxvcyBjb21taXRzIGFsY2FuemFibGVzIGhhc3RhIGxhIHJhw616KHJhw61jZXMpIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE1MDAKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTUyNAogbXNnaWQgIiIKICJ0aGUgcmViYXNlLnVzZUJ1aWx0aW4gc3VwcG9ydCBoYXMgYmVlbiByZW1vdmVkIVxuIgogIlNlZSBpdHMgZW50cnkgaW4gJ2dpdCBoZWxwIGNvbmZpZycgZm9yIGRldGFpbHMuIgogbXNnc3RyICIiCi0iZWwgc29wb3J0ZSBwYXJhIHJlYmFzZS51c2VCdWlsdGluIGhhIHNpZG8gcmVtb3ZpZG8hXG4iCisiZWwgc29wb3J0ZSBwYXJhIHJlYmFzZS51c2VCdWlsdGluIGhhIHNpZG8gZWxpbWluYWRvIVxuIgogIlZlYSBzdSBlbnRyYWRhIGVuICdnaXQgaGVscCBjb25maWcnIHBhcmEgZGV0YWxsZXMuIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE1MDYKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTUzMAogbXNnaWQgIkl0IGxvb2tzIGxpa2UgJ2dpdCBhbScgaXMgaW4gcHJvZ3Jlc3MuIENhbm5vdCByZWJhc2UuIgogbXNnc3RyICJQYXJlY2UgcXVlICdnaXQgYW0nIGVzdMOhIGVuIHByb2dyZXNvLiBObyBzZSBwdWVkZSByZWJhc2FyLiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNTQ3CisjOiBidWlsdGluL3JlYmFzZS5jOjE1NzEKIG1zZ2lkICIiCiAiZ2l0IHJlYmFzZSAtLXByZXNlcnZlLW1lcmdlcyBpcyBkZXByZWNhdGVkLiBVc2UgLS1yZWJhc2UtbWVyZ2VzIGluc3RlYWQuIgogbXNnc3RyICIiCiAiZ2l0IHJlYmFzZSAtLXByZXNlcnZlLW1lcmdlcyBlc3TDoSBkZXByZWNhZG8uIFVzZSAtLXJlYmFzZS1tZXJnZXMgZW4gc3UgbHVnYXIuIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE1NTEKLW1zZ2lkICJObyByZWJhc2UgaW4gcHJvZ3Jlc3M/IgotbXNnc3RyICJObyBoYXkgcmViYXNlIGVuIHByb2dyZXNvPyIKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTU3NgorbXNnaWQgImNhbm5vdCBjb21iaW5lICctLWtlZXAtYmFzZScgd2l0aCAnLS1vbnRvJyIKK21zZ3N0ciAibm8gc2UgcHVlZGUgY29tYmluYXIgJy0ta2VlcC1iYXNlJyBjb24gJy0tb250byciCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTU1NQorIzogYnVpbHRpbi9yZWJhc2UuYzoxNTc4Cittc2dpZCAiY2Fubm90IGNvbWJpbmUgJy0ta2VlcC1iYXNlJyB3aXRoICctLXJvb3QnIgorbXNnc3RyICJubyBzZSBwdWVkZSBjb21iaW5hciAnLS1rZWVwLWJhc2UnIGNvbiAnLS1yb290JyIKKworIzogYnVpbHRpbi9yZWJhc2UuYzoxNTgyCittc2dpZCAiTm8gcmViYXNlIGluIHByb2dyZXNzPyIKK21zZ3N0ciAiwr9ObyBoYXkgcmViYXNlIGVuIHByb2dyZXNvPyIKKworIzogYnVpbHRpbi9yZWJhc2UuYzoxNTg2CiBtc2dpZCAiVGhlIC0tZWRpdC10b2RvIGFjdGlvbiBjYW4gb25seSBiZSB1c2VkIGR1cmluZyBpbnRlcmFjdGl2ZSByZWJhc2UuIgogbXNnc3RyICIiCiAiTGEgYWNjacOzbiAtLWVkaXQtdG9kbyBzw7NsbyBwdWVkZSBzZXIgdXNhZGEgYWwgcmViYXNhciBpbnRlcmFjdGl2YW1lbnRlLiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNTc4CisjOiBidWlsdGluL3JlYmFzZS5jOjE2MDkKIG1zZ2lkICJDYW5ub3QgcmVhZCBIRUFEIgogbXNnc3RyICJObyBzZSBwdWVkZSBsZWVyIGVsIEhFQUQiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTU5MAorIzogYnVpbHRpbi9yZWJhc2UuYzoxNjIxCiBtc2dpZCAiIgogIllvdSBtdXN0IGVkaXQgYWxsIG1lcmdlIGNvbmZsaWN0cyBhbmQgdGhlblxuIgogIm1hcmsgdGhlbSBhcyByZXNvbHZlZCB1c2luZyBnaXQgYWRkIgpAQCAtMTc1MTAsMTYgKzE3NjA0LDE2IEBACiAiVGllbmVzIHF1ZSBlZGl0YXIgdG9kb3MgbG9zIGNvbmZsaWN0b3MgZGUgZnVzacOzbiB5IGx1ZWdvXG4iCiAibWFyY2FybG9zIGNvbW8gcmVzdWVsdG9zIHVzYW5kbyBnaXQgYWRkIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE2MDkKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTY0MAogbXNnaWQgImNvdWxkIG5vdCBkaXNjYXJkIHdvcmt0cmVlIGNoYW5nZXMiCiBtc2dzdHIgIm5vIHNlIHB1ZG8gZGVzY2FydGFyIGxvcyBjYW1iaW9zIGRlbCDDoXJib2wgZGUgdHJhYmFqbyIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNjI4CisjOiBidWlsdGluL3JlYmFzZS5jOjE2NTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IG1vdmUgYmFjayB0byAlcyIKIG1zZ3N0ciAibm8gc2UgcHVlZGUgcmVncmVzYXIgYSAlcyIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNjczCisjOiBidWlsdGluL3JlYmFzZS5jOjE3MDQKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkl0IHNlZW1zIHRoYXQgdGhlcmUgaXMgYWxyZWFkeSBhICVzIGRpcmVjdG9yeSwgYW5kXG4iCkBAIC0xNzU0MCwxNjcgKzE3NjM0LDE1OSBAQAogInkgZWplY8O6dGFtZSBudWV2YW1lbnRlLiBNZSBlc3RveSBkZXRlbmllbmRvIGVuIGNhc28gZGUgcXVlIHRlbmdhc1xuIgogImFsZ28gZGUgdmFsb3IgYWjDrS5cbiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNjk0CisjOiBidWlsdGluL3JlYmFzZS5jOjE3MjUKIG1zZ2lkICJzd2l0Y2ggYEMnIGV4cGVjdHMgYSBudW1lcmljYWwgdmFsdWUiCiBtc2dzdHIgInN3aXRjaCBgQycgZXNwZXJhIHVuIHZhbG9yIG51bcOpcmljbyIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNzM1CisjOiBidWlsdGluL3JlYmFzZS5jOjE3NjYKICMsIGMtZm9ybWF0CiBtc2dpZCAiVW5rbm93biBtb2RlOiAlcyIKIG1zZ3N0ciAiTW9kbyBkZXNjb25vY2lkbzogJXMiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTc1NworIzogYnVpbHRpbi9yZWJhc2UuYzoxNzg4CiBtc2dpZCAiLS1zdHJhdGVneSByZXF1aXJlcyAtLW1lcmdlIG9yIC0taW50ZXJhY3RpdmUiCiBtc2dzdHIgIi0tc3RyYXRlZ3kgcmVxdWllcmUgLS1tZXJnZSBvIC0taW50ZXJhY3RpdmUiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTc5NworIzogYnVpbHRpbi9yZWJhc2UuYzoxODI4CiBtc2dpZCAiLS1yZXNjaGVkdWxlLWZhaWxlZC1leGVjIHJlcXVpcmVzIC0tZXhlYyBvciAtLWludGVyYWN0aXZlIgogbXNnc3RyICItLXJlc2NoZWR1bGUtZmFpbGVkLWV4ZWMgcmVxdWllcmUgLS1leGVjIG8gLS1pbnRlcmFjdGl2ZSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxODA5CisjOiBidWlsdGluL3JlYmFzZS5jOjE4NDAKIG1zZ2lkICJjYW5ub3QgY29tYmluZSBhbSBvcHRpb25zIHdpdGggZWl0aGVyIGludGVyYWN0aXZlIG9yIG1lcmdlIG9wdGlvbnMiCiBtc2dzdHIgIiIKICJubyBzZSBwdWVkZW4gY29tYmluYXIgb3BjaW9uZXMgZGUgYW0gY29uIG9wY2lvbmVzIGludGVyYWN0aXZhcyBvIGRlIG1lcmdlIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE4MjgKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTg1OQogbXNnaWQgImNhbm5vdCBjb21iaW5lICctLXByZXNlcnZlLW1lcmdlcycgd2l0aCAnLS1yZWJhc2UtbWVyZ2VzJyIKIG1zZ3N0ciAibm8gc2UgcHVlZGUgY29tYmluYXIgJy0tcHJlc2VydmUtbWVyZ2VzJyBjb24gJy0tcmViYXNlLW1lcmdlcyciCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTgzMgorIzogYnVpbHRpbi9yZWJhc2UuYzoxODYzCiBtc2dpZCAiIgogImVycm9yOiBjYW5ub3QgY29tYmluZSAnLS1wcmVzZXJ2ZS1tZXJnZXMnIHdpdGggJy0tcmVzY2hlZHVsZS1mYWlsZWQtZXhlYyciCiBtc2dzdHIgIiIKICJlcnJvcjogbm8gc2UgcHVlZGUgY29tYmluYXIgJy0tcHJlc2VydmUtbWVyZ2VzJyBjb24gJy0tcmVzY2hlZHVsZS1mYWlsZWQtIgogImV4ZWMnIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE4MzgKLW1zZ2lkICJjYW5ub3QgY29tYmluZSAnLS1yZWJhc2UtbWVyZ2VzJyB3aXRoICctLXN0cmF0ZWd5LW9wdGlvbiciCi1tc2dzdHIgIm5vIHNlIHB1ZWRlIGNvbWJpbmFyICctLXJlYmFzZS1tZXJnZXMnIGNvbiAnLS1zdHJhdGVneS1vcHRpb24nIgotCi0jOiBidWlsdGluL3JlYmFzZS5jOjE4NDEKLW1zZ2lkICJjYW5ub3QgY29tYmluZSAnLS1yZWJhc2UtbWVyZ2VzJyB3aXRoICctLXN0cmF0ZWd5JyIKLW1zZ3N0ciAibm8gc2UgcHVlZGUgY29tYmluYXIgJy0tcmViYXNlLW1lcmdlcycgY29uICctLXN0cmF0ZWd5JyIKLQotIzogYnVpbHRpbi9yZWJhc2UuYzoxODY1CisjOiBidWlsdGluL3JlYmFzZS5jOjE4ODcKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCB1cHN0cmVhbSAnJXMnIgogbXNnc3RyICJ1cHN0cmVhbSBpbnbDoWxpZG8gJyVzJyIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxODcxCisjOiBidWlsdGluL3JlYmFzZS5jOjE4OTMKIG1zZ2lkICJDb3VsZCBub3QgY3JlYXRlIG5ldyByb290IGNvbW1pdCIKIG1zZ3N0ciAiTm8gc2UgcHVkbyBjcmVhciBjb21taXQgcmHDrXogbnVldm8iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTg4OQorIzogYnVpbHRpbi9yZWJhc2UuYzoxOTE5CisjLCBjLWZvcm1hdAorbXNnaWQgIiclcyc6IG5lZWQgZXhhY3RseSBvbmUgbWVyZ2UgYmFzZSB3aXRoIGJyYW5jaCIKK21zZ3N0ciAiJyVzJzogbmVjZXNpdGEgZXhhY3RhbWVudGUgdW5hIGJhc2UgZGUgZnVzacOzbiBjb24gcmFtYSIKKworIzogYnVpbHRpbi9yZWJhc2UuYzoxOTIyCiAjLCBjLWZvcm1hdAogbXNnaWQgIiclcyc6IG5lZWQgZXhhY3RseSBvbmUgbWVyZ2UgYmFzZSIKIG1zZ3N0ciAiJyVzJzogbmVjZXNpdGEgZXhhY3RhbWVudGUgdW5hIGJhc2UgZGUgZnVzacOzbiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxODk2CisjOiBidWlsdGluL3JlYmFzZS5jOjE5MzAKICMsIGMtZm9ybWF0CiBtc2dpZCAiRG9lcyBub3QgcG9pbnQgdG8gYSB2YWxpZCBjb21taXQgJyVzJyIKIG1zZ3N0ciAiTm8gYXB1bnRhIGEgdW4gY29tbWl0IHbDoWxpZG8gJyVzJyIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxOTIxCisjOiBidWlsdGluL3JlYmFzZS5jOjE5NTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmF0YWw6IG5vIHN1Y2ggYnJhbmNoL2NvbW1pdCAnJXMnIgogbXNnc3RyICJmYXRhbDogbm8gZXhpc3RlIGxhIHJhbWEvY29tbWl0OiAnJXMnIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE5MjkgYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjM4CisjOiBidWlsdGluL3JlYmFzZS5jOjE5NjMgYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjM4CiAjOiBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6MTkzNAogIywgYy1mb3JtYXQKIG1zZ2lkICJObyBzdWNoIHJlZjogJXMiCiBtc2dzdHIgIk5vIGV4aXN0ZSByZWY6ICVzIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE5NDAKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTk3NAogbXNnaWQgIkNvdWxkIG5vdCByZXNvbHZlIEhFQUQgdG8gYSByZXZpc2lvbiIKIG1zZ3N0ciAiTm8gc2UgcHVkbyByZXNvbHZlciBIRUFEIGEgdW5hIHJldmlzacOzbiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxOTgxCisjOiBidWlsdGluL3JlYmFzZS5jOjIwMTIKIG1zZ2lkICJDYW5ub3QgYXV0b3N0YXNoIgogbXNnc3RyICJObyBzZSBwdWVkZSBlamVjdXRhciBhdXRvc3Rhc2giCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTk4NAorIzogYnVpbHRpbi9yZWJhc2UuYzoyMDE1CiAjLCBjLWZvcm1hdAogbXNnaWQgIlVuZXhwZWN0ZWQgc3Rhc2ggcmVzcG9uc2U6ICclcyciCiBtc2dzdHIgIlJlc3B1ZXN0YSBkZSBzdGFzaCBpbmVzcGVyYWRhOiAnJXMnIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE5OTAKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MjAyMQogIywgYy1mb3JtYXQKIG1zZ2lkICJDb3VsZCBub3QgY3JlYXRlIGRpcmVjdG9yeSBmb3IgJyVzJyIKIG1zZ3N0ciAiTm8gc2UgcHVkbyBjcmVhciBlbCBkaXJlY3RvcmlvIHBhcmEgJyVzJyIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxOTkzCisjOiBidWlsdGluL3JlYmFzZS5jOjIwMjQKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ3JlYXRlZCBhdXRvc3Rhc2g6ICVzXG4iCiBtc2dzdHIgIkF1dG9zdGFzaCBjcmVhZG86ICVzXG4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTk5NgorIzogYnVpbHRpbi9yZWJhc2UuYzoyMDI3CiBtc2dpZCAiY291bGQgbm90IHJlc2V0IC0taGFyZCIKIG1zZ3N0ciAibm8gc2UgcHVkbyByZXNldCAtLWhhcmQiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTk5NyBidWlsdGluL3Jlc2V0LmM6MTE0Ci0jLCBjLWZvcm1hdAotbXNnaWQgIkhFQUQgaXMgbm93IGF0ICVzIgotbXNnc3RyICJIRUFEIGVzdMOhIGFob3JhIGVuICVzIgotCi0jOiBidWlsdGluL3JlYmFzZS5jOjIwMTMKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MjAzNgogbXNnaWQgIlBsZWFzZSBjb21taXQgb3Igc3Rhc2ggdGhlbS4iCiBtc2dzdHIgIlBvciBmYXZvciwgY29uZsOtcm1hbG9zIG8gZ3XDoXJkYWxvcy4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MjA0MAorIzogYnVpbHRpbi9yZWJhc2UuYzoyMDYzCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBwYXJzZSAnJXMnIgogbXNnc3RyICJubyBzZSBwdWVkZSBhbmFsaXphciAnJXMnIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjIwNTMKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MjA3NgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3Qgc3dpdGNoIHRvICVzIgogbXNnc3RyICJubyBzZSBwdWRvIGNhbWJpYXIgYSAlcyIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoyMDY0CisjOiBidWlsdGluL3JlYmFzZS5jOjIwODcKIG1zZ2lkICJIRUFEIGlzIHVwIHRvIGRhdGUuIgogbXNnc3RyICJIRUFEIGVzdMOhIGFjdHVhbGl6YWRvLiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoyMDY2CisjOiBidWlsdGluL3JlYmFzZS5jOjIwODkKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ3VycmVudCBicmFuY2ggJXMgaXMgdXAgdG8gZGF0ZS5cbiIKIG1zZ3N0ciAiTGEgcmFtYSBhY3R1YWwgJXMgZXN0w6EgYWN0dWFsaXphZGEuXG4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MjA3NAorIzogYnVpbHRpbi9yZWJhc2UuYzoyMDk3CiBtc2dpZCAiSEVBRCBpcyB1cCB0byBkYXRlLCByZWJhc2UgZm9yY2VkLiIKIG1zZ3N0ciAiSEVBRCBlc3TDoSBhY3R1YWxpemFkbywgcmViYXNlIGZvcnphZG8uIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjIwNzYKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MjA5OQogIywgYy1mb3JtYXQKIG1zZ2lkICJDdXJyZW50IGJyYW5jaCAlcyBpcyB1cCB0byBkYXRlLCByZWJhc2UgZm9yY2VkLlxuIgogbXNnc3RyICJSYW1hIGFjdHVhbCAlcyBlc3TDoSBhY3R1YWxpemFkYSwgcmViYXNlIGZvcnphZG8uXG4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MjA4NAorIzogYnVpbHRpbi9yZWJhc2UuYzoyMTA3CiBtc2dpZCAiVGhlIHByZS1yZWJhc2UgaG9vayByZWZ1c2VkIHRvIHJlYmFzZS4iCiBtc2dzdHIgIkVsIGhvb2sgcHJlLXJlYmFzZSByZWNoYXrDsyBlbCByZWJhc2UuIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjIwOTEKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MjExNAogIywgYy1mb3JtYXQKIG1zZ2lkICJDaGFuZ2VzIHRvICVzOlxuIgogbXNnc3RyICJDYW1iaW9zIGEgJXM6XG4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MjA5NAorIzogYnVpbHRpbi9yZWJhc2UuYzoyMTE3CiAjLCBjLWZvcm1hdAogbXNnaWQgIkNoYW5nZXMgZnJvbSAlcyB0byAlczpcbiIKIG1zZ3N0ciAiQ2FtYmlvcyBkZXNkZSAlcyBhICVzOlxuIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjIxMTkKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MjE0MgogIywgYy1mb3JtYXQKIG1zZ2lkICJGaXJzdCwgcmV3aW5kaW5nIGhlYWQgdG8gcmVwbGF5IHlvdXIgd29yayBvbiB0b3Agb2YgaXQuLi5cbiIKIG1zZ3N0ciAiIgogIkVuIHByaW1lciBsdWdhciwgcmVib2JpbmFuZG8gSEVBRCBwYXJhIGRlc3B1w6lzIHJlcHJvZHVjaXIgdHVzIGNhbWJpb3MgZW5jaW1hICIKICJkZSDDqXN0YS4uLlxuIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjIxMjgKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MjE1MQogbXNnaWQgIkNvdWxkIG5vdCBkZXRhY2ggSEVBRCIKIG1zZ3N0ciAiTm8gc2UgcHVlZGUgZGVzYWNvcGxhciBIRUFEIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjIxMzcKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MjE2MAogIywgYy1mb3JtYXQKIG1zZ2lkICJGYXN0LWZvcndhcmRlZCAlcyB0byAlcy5cbiIKIG1zZ3N0ciAiQXZhbmNlIHLDoXBpZG8gZGUgJXMgYSAlcy5cbiIKQEAgLTE3NzA5LDcgKzE3Nzk1LDcgQEAKIG1zZ2lkICJnaXQgcmVjZWl2ZS1wYWNrIDxnaXQtZGlyPiIKIG1zZ3N0ciAiZ2l0IHJlY2VpdmUtcGFjayA8Z2l0LWRpcj4iCiAKLSM6IGJ1aWx0aW4vcmVjZWl2ZS1wYWNrLmM6ODMyCisjOiBidWlsdGluL3JlY2VpdmUtcGFjay5jOjgzMAogbXNnaWQgIiIKICJCeSBkZWZhdWx0LCB1cGRhdGluZyB0aGUgY3VycmVudCBicmFuY2ggaW4gYSBub24tYmFyZSByZXBvc2l0b3J5XG4iCiAiaXMgZGVuaWVkLCBiZWNhdXNlIGl0IHdpbGwgbWFrZSB0aGUgaW5kZXggYW5kIHdvcmsgdHJlZSBpbmNvbnNpc3RlbnRcbiIKQEAgLTE3NzM1LDE0ICsxNzgyMSwxNCBAQAogIlB1ZWRlcyBjb25maWd1cmFyIGxhIHZhcmlhYmxlIGRlIGNvbmZpZ3VyYWNpw7NuICdyZWNlaXZlLmRlbnlDdXJyZW50QnJhbmNoJ1xuIgogIlwiaWdub3JlXCIgbyBcIndhcm5cIiBlbiBlbCByZXBvc2l0b3JpbyByZW1vdG8gcGFyYSBwZXJtaXRpclxuIgogInN1IHJhbWEgYWN0dWFsOyBTaW4gZW1iYXJnbywgZXN0byBubyBzZSByZWNvbWllbmRhIGEgbWVub3MgcXVlIHTDulxuIgotInRlIGhheWFzIG9yZ2FuaXphZG8gcGFyYSBhY3R1YWxpemFyIHN1IMOhcmJvbCBkZSB0cmFiYWpvIHBhcmEgcXVlIGNvaW5jaWRhIGNvbiAiCi0ibG8gcXVlXG4iCisidGUgaGF5YXMgb3JnYW5pemFkbyBwYXJhIGFjdHVhbGl6YXIgc3Ugw6FyYm9sIGRlIHRyYWJham8gcGFyYSBxdWUgY29pbmNpZGEgIgorImNvbiBsbyBxdWVcbiIKICJlbnZpYXLDoXMgY29uIGVsIHB1c2ggZGUgb3RyYSBtYW5lcmEuXG4iCiAiXG4iCiAiUGFyYSBzdXByaW1pciBlc3RlIG1lbnNhamUgeSBtYW50ZW5lciBlbCBjb21wb3J0YW1pZW50byBwcmVkZXRlcm1pbmFkbyxcbiIKICJjb25maWd1cmEgJ3JlY2VpdmUuZGVueUN1cnJlbnRCcmFuY2gnIGEgJ3JlZnVzZScuIgogCi0jOiBidWlsdGluL3JlY2VpdmUtcGFjay5jOjg1MgorIzogYnVpbHRpbi9yZWNlaXZlLXBhY2suYzo4NTAKIG1zZ2lkICIiCiAiQnkgZGVmYXVsdCwgZGVsZXRpbmcgdGhlIGN1cnJlbnQgYnJhbmNoIGlzIGRlbmllZCwgYmVjYXVzZSB0aGUgbmV4dFxuIgogIidnaXQgY2xvbmUnIHdvbid0IHJlc3VsdCBpbiBhbnkgZmlsZSBjaGVja2VkIG91dCwgY2F1c2luZyBjb25mdXNpb24uXG4iCkBAIC0xNzc2MywxMSArMTc4NDksMTEgQEAKICJcbiIKICJQYXJhIHN1cHJpbWlyIGVzdGUgbWVuc2FqZSwgcHVlZGVzIGNvbmZpZ3VyYXJsbyBlbiAncmVmdXNlJy4iCiAKLSM6IGJ1aWx0aW4vcmVjZWl2ZS1wYWNrLmM6MTkzOAorIzogYnVpbHRpbi9yZWNlaXZlLXBhY2suYzoxOTM2CiBtc2dpZCAicXVpZXQiCiBtc2dzdHIgInRyYW5xdWlsbyIKIAotIzogYnVpbHRpbi9yZWNlaXZlLXBhY2suYzoxOTUyCisjOiBidWlsdGluL3JlY2VpdmUtcGFjay5jOjE5NTAKIG1zZ2lkICJZb3UgbXVzdCBzcGVjaWZ5IGEgZGlyZWN0b3J5LiIKIG1zZ3N0ciAiU2UgdGllbmUgcXVlIGVzcGVjaWZpY2FyIHVuIGRpcmVjdG9yaW8uIgogCkBAIC0xNzgwNiw3ICsxNzg5Miw3IEBACiAjOiBidWlsdGluL3JlZmxvZy5jOjY0MwogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyBwb2ludHMgbm93aGVyZSEiCi1tc2dzdHIgIiVzIGFwdW50YSBhIG5pbmfDum4gbGFkbyEiCittc2dzdHIgIsKhJXMgYXB1bnRhIGEgbmluZ8O6biBsYWRvISIKIAogIzogYnVpbHRpbi9yZWZsb2cuYzo2OTUKIG1zZ2lkICJubyByZWZsb2cgc3BlY2lmaWVkIHRvIGRlbGV0ZSIKQEAgLTE4MDMyLDExICsxODExOCwxMSBAQAogIk5vdGU6IFNvbWUgYnJhbmNoZXMgb3V0c2lkZSB0aGUgcmVmcy9yZW1vdGVzLyBoaWVyYXJjaHkgd2VyZSBub3QgcmVtb3ZlZDtcbiIKICJ0byBkZWxldGUgdGhlbSwgdXNlOiIKIG1zZ3N0clswXSAiIgotIk5vdGE6IFVuYSByYW1hIGZ1ZXJhIGRlIGxhIGplcmFycXXDrWEgcmVmcy9yZW1vdGVzLyBubyBmdWUgcmVtb3ZpZGE7XG4iCisiTm90YTogVW5hIHJhbWEgZnVlcmEgZGUgbGEgamVyYXJxdcOtYSByZWZzL3JlbW90ZXMvIG5vIGZ1ZSBlbGltaW5hZGE7XG4iCiAicGFyYSBib3JyYXJsYSwgdXNlOiIKIG1zZ3N0clsxXSAiIgogIk5vdGE6IEFsZ3VuYXMgcmFtYXMgZnVlcmEgZGUgbGEgamVyYXJxdcOtYSByZWZzL3JlbW90ZXMvIG5vIGZ1ZXJvbiAiCi0icmVtb3ZpZGFzO1xuIgorImVsaW1pbmFkYXM7XG4iCiAicGFyYSBib3JyYXJsYXMsIHVzZToiCiAKICM6IGJ1aWx0aW4vcmVtb3RlLmM6ODE2CkBAIC0xODI0NSwxMiArMTgzMzEsMTIgQEAKICM6IGJ1aWx0aW4vcmVtb3RlLmM6MTI5OQogIywgYy1mb3JtYXQKIG1zZ2lkICIgJXMgd2lsbCBiZWNvbWUgZGFuZ2xpbmchIgotbXNnc3RyICIgJXMgc2Vyw6EgY29sZ2FkbyEiCittc2dzdHIgIiDCoSVzIHNlcsOhIGNvbGdhZG8hIgogCiAjOiBidWlsdGluL3JlbW90ZS5jOjEzMDAKICMsIGMtZm9ybWF0CiBtc2dpZCAiICVzIGhhcyBiZWNvbWUgZGFuZ2xpbmchIgotbXNnc3RyICIgJXMgaGEgc2lkbyBjb2xnYWRvISIKK21zZ3N0ciAiIMKhJXMgaGEgc2lkbyBjb2xnYWRvISIKIAogIzogYnVpbHRpbi9yZW1vdGUuYzoxMzEwCiAjLCBjLWZvcm1hdApAQCAtMTgzNDEsMTEgKzE4NDI3LDExIEBACiBtc2dpZCAiVW5rbm93biBzdWJjb21tYW5kOiAlcyIKIG1zZ3N0ciAiU3ViLWNvbWFuZG8gZGVzY29ub2NpZG86ICVzIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjIyCisjOiBidWlsdGluL3JlcGFjay5jOjIzCiBtc2dpZCAiZ2l0IHJlcGFjayBbPG9wdGlvbnM+XSIKIG1zZ3N0ciAiZ2l0IHJlcGFjayBbPG9wY2lvbmVzPl0iCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MjcKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6MjgKIG1zZ2lkICIiCiAiSW5jcmVtZW50YWwgcmVwYWNrcyBhcmUgaW5jb21wYXRpYmxlIHdpdGggYml0bWFwIGluZGV4ZXMuICBVc2VcbiIKICItLW5vLXdyaXRlLWJpdG1hcC1pbmRleCBvciBkaXNhYmxlIHRoZSBwYWNrLndyaXRlYml0bWFwcyBjb25maWd1cmF0aW9uLiIKQEAgLTE4MzUzLDExNSArMTg0MzksMTE1IEBACiAiUmUgZW1wYXF1ZXRhZG9zIGluY3JlbWVudGFsZXMgc29uIGluY29tcGF0aWJsZXMgY29uIMOtbmRpY2VzIGJpdG1hcC4gVXNlIFxuIgogIi0tbm8td3JpdGUtYml0bWFwLWluZGV4IG8gZGVzaGFiaWxpdGUgbGEgY29uZmlndXJhY2nDs24gcGFjay53cml0ZWJpdG1hcHMuIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjE5MAorIzogYnVpbHRpbi9yZXBhY2suYzoxOTEKIG1zZ2lkICJjb3VsZCBub3Qgc3RhcnQgcGFjay1vYmplY3RzIHRvIHJlcGFjayBwcm9taXNvciBvYmplY3RzIgogbXNnc3RyICJubyBzZSBwdWVkZSBpbmljaWFyIHBhY2stb2JqZWN0cyBwYXJhIHJlZW1wYXF1ZXRhciBvYmpldG9zIHByb21pc29yZXMiCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MjI5IGJ1aWx0aW4vcmVwYWNrLmM6NDA4CisjOiBidWlsdGluL3JlcGFjay5jOjIzMCBidWlsdGluL3JlcGFjay5jOjQwOQogbXNnaWQgInJlcGFjazogRXhwZWN0aW5nIGZ1bGwgaGV4IG9iamVjdCBJRCBsaW5lcyBvbmx5IGZyb20gcGFjay1vYmplY3RzLiIKIG1zZ3N0ciAiIgogInJlcGFjazogRXNwZXJhbmRvIGzDrW5lYXMgZGUgSUQgZGUgb2JqZXRvIGVuIGZ1bGwgaGV4IHNvbG8gZGVzZGUgcGFjay1vYmplY3RzLiIKIAotIzogYnVpbHRpbi9yZXBhY2suYzoyNDYKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6MjQ3CiBtc2dpZCAiY291bGQgbm90IGZpbmlzaCBwYWNrLW9iamVjdHMgdG8gcmVwYWNrIHByb21pc29yIG9iamVjdHMiCiBtc2dzdHIgIiIKICJubyBzZSBwdWVkZSBmaW5hbGl6YXIgcGFjay1vYmplY3RzIHBhcmEgcmVlbXBhcXVldGFyIG9iamV0b3MgcHJvbWlzb3JlcyIKIAotIzogYnVpbHRpbi9yZXBhY2suYzoyODQKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6Mjg1CiBtc2dpZCAicGFjayBldmVyeXRoaW5nIGluIGEgc2luZ2xlIHBhY2siCiBtc2dzdHIgImVtcGFxdWV0YXIgdG9kbyBlbiB1biDDum5pY28gcGFxdWV0ZSIKIAotIzogYnVpbHRpbi9yZXBhY2suYzoyODYKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6Mjg3CiBtc2dpZCAic2FtZSBhcyAtYSwgYW5kIHR1cm4gdW5yZWFjaGFibGUgb2JqZWN0cyBsb29zZSIKIG1zZ3N0ciAibG8gbWlzbW8gcXVlIC1hLCB5IHBpZXJkZSBvYmpldG9zIGluYWNjZXNpYmxlcyIKIAotIzogYnVpbHRpbi9yZXBhY2suYzoyODkKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6MjkwCiBtc2dpZCAicmVtb3ZlIHJlZHVuZGFudCBwYWNrcywgYW5kIHJ1biBnaXQtcHJ1bmUtcGFja2VkIgogbXNnc3RyICJlbGltaW5hciBwYXF1ZXRlcyByZWR1bmRhbnRlcywgeSBlamVjdXRhciBnaXQtcHJ1bmUtcGFja2VkIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjI5MQorIzogYnVpbHRpbi9yZXBhY2suYzoyOTIKIG1zZ2lkICJwYXNzIC0tbm8tcmV1c2UtZGVsdGEgdG8gZ2l0LXBhY2stb2JqZWN0cyIKIG1zZ3N0ciAicGFzYXIgLS1uby1yZXVzZS1kZWx0YSBhIGdpdC1wYWNrLW9iamVjdHMiCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MjkzCisjOiBidWlsdGluL3JlcGFjay5jOjI5NAogbXNnaWQgInBhc3MgLS1uby1yZXVzZS1vYmplY3QgdG8gZ2l0LXBhY2stb2JqZWN0cyIKIG1zZ3N0ciAicGFzYXIgLS1uby1yZXVzZS1vYmplY3QgYSBnaXQtcGFjay1vYmplY3RzIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjI5NQorIzogYnVpbHRpbi9yZXBhY2suYzoyOTYKIG1zZ2lkICJkbyBub3QgcnVuIGdpdC11cGRhdGUtc2VydmVyLWluZm8iCiBtc2dzdHIgIm5vIGVqZWN1dGFyIGdpdC11cGRhdGUtc2VydmVyLWluZm8iCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6Mjk4CisjOiBidWlsdGluL3JlcGFjay5jOjI5OQogbXNnaWQgInBhc3MgLS1sb2NhbCB0byBnaXQtcGFjay1vYmplY3RzIgogbXNnc3RyICJwYXNhciAtLWxvY2FsIGEgZ2l0LXBhY2stb2JqZWN0cyIKIAotIzogYnVpbHRpbi9yZXBhY2suYzozMDAKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6MzAxCiBtc2dpZCAid3JpdGUgYml0bWFwIGluZGV4IgogbXNnc3RyICJlc2NyaWJpciB1biDDrW5kaWNlIGRlIGJpdG1hcCIKIAotIzogYnVpbHRpbi9yZXBhY2suYzozMDIKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6MzAzCiBtc2dpZCAicGFzcyAtLWRlbHRhLWlzbGFuZHMgdG8gZ2l0LXBhY2stb2JqZWN0cyIKIG1zZ3N0ciAicGFzYXIgLS1kZWx0YS1pc2xhbmRzIGEgZ2l0LXBhY2stb2JqZWN0cyIKIAotIzogYnVpbHRpbi9yZXBhY2suYzozMDMKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6MzA0CiBtc2dpZCAiYXBwcm94aWRhdGUiCiBtc2dzdHIgImFwcm94aW1lIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjMwNAorIzogYnVpbHRpbi9yZXBhY2suYzozMDUKIG1zZ2lkICJ3aXRoIC1BLCBkbyBub3QgbG9vc2VuIG9iamVjdHMgb2xkZXIgdGhhbiB0aGlzIgogbXNnc3RyICJjb24gLUEsIG5vIHBlcmRlciBvYmpldG9zIG3DoXMgYW50aWd1b3MgcXVlIGVzdGUiCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MzA2CisjOiBidWlsdGluL3JlcGFjay5jOjMwNwogbXNnaWQgIndpdGggLWEsIHJlcGFjayB1bnJlYWNoYWJsZSBvYmplY3RzIgogbXNnc3RyICJjb24gLWEsIHJlIGVtcGFxdWV0YXIgb2JqZXRvcyBpbmFsY2FuemFibGVzIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjMwOAorIzogYnVpbHRpbi9yZXBhY2suYzozMDkKIG1zZ2lkICJzaXplIG9mIHRoZSB3aW5kb3cgdXNlZCBmb3IgZGVsdGEgY29tcHJlc3Npb24iCiBtc2dzdHIgInRhbWHDsW8gZGUgbGEgdmVudGFuYSB1c2FkbyBwYXJhIGxhIGNvbXByZXNpw7NuIGRlbHRhIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjMwOSBidWlsdGluL3JlcGFjay5jOjMxNQorIzogYnVpbHRpbi9yZXBhY2suYzozMTAgYnVpbHRpbi9yZXBhY2suYzozMTYKIG1zZ2lkICJieXRlcyIKIG1zZ3N0ciAiYnl0ZXMiCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MzEwCisjOiBidWlsdGluL3JlcGFjay5jOjMxMQogbXNnaWQgInNhbWUgYXMgdGhlIGFib3ZlLCBidXQgbGltaXQgbWVtb3J5IHNpemUgaW5zdGVhZCBvZiBlbnRyaWVzIGNvdW50IgogbXNnc3RyICIiCiAibG8gbWlzbW8gcXVlIGFycmliYSwgcGVybyBsaW1pdGEgZWwgdGFtYcOxbyBkZSBtZW1vcmlhIGVuIGx1Z2FyIGRlIGNvbnRhciAiCiAiZW50cmFkYXMiCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MzEyCisjOiBidWlsdGluL3JlcGFjay5jOjMxMwogbXNnaWQgImxpbWl0cyB0aGUgbWF4aW11bSBkZWx0YSBkZXB0aCIKIG1zZ3N0ciAibGltaXRhIGxhIHByb2Z1bmRpZGFkIG3DoXhpbWEgZGVsIGRlbHRhIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjMxNAorIzogYnVpbHRpbi9yZXBhY2suYzozMTUKIG1zZ2lkICJsaW1pdHMgdGhlIG1heGltdW0gbnVtYmVyIG9mIHRocmVhZHMiCiBtc2dzdHIgImxpbWl0YSBlbCBuw7ptZXJvIG3DoXhpbW8gZGUgaGlsb3MiCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MzE2CisjOiBidWlsdGluL3JlcGFjay5jOjMxNwogbXNnaWQgIm1heGltdW0gc2l6ZSBvZiBlYWNoIHBhY2tmaWxlIgogbXNnc3RyICJ0YW1hw7FvIG3DoXhpbW8gZGUgY2FkYSBwYXF1ZXRlIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjMxOAorIzogYnVpbHRpbi9yZXBhY2suYzozMTkKIG1zZ2lkICJyZXBhY2sgb2JqZWN0cyBpbiBwYWNrcyBtYXJrZWQgd2l0aCAua2VlcCIKIG1zZ3N0ciAicmUtZW1wYXF1ZXRhciBvYmpldG9zIGVuIHBhcXVldGVzIG1hcmNhZG9zIGNvbiAua2VlcCIKIAotIzogYnVpbHRpbi9yZXBhY2suYzozMjAKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6MzIxCiBtc2dpZCAiZG8gbm90IHJlcGFjayB0aGlzIHBhY2siCiBtc2dzdHIgIm5vIHJlZW1wYXF1ZXRhciBlc3RlIHBhcXVldGUiCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MzMwCisjOiBidWlsdGluL3JlcGFjay5jOjMzMQogbXNnaWQgImNhbm5vdCBkZWxldGUgcGFja3MgaW4gYSBwcmVjaW91cy1vYmplY3RzIHJlcG8iCiBtc2dzdHIgIm5vIHNlIHB1ZWRlbiBib3JyYXIgcGFxdWV0ZXMgZW4gdW4gcmVwb3NpdG9yaW8gZGUgb2JqZXRvcy1wcmVjaW9zb3MiCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MzM0CisjOiBidWlsdGluL3JlcGFjay5jOjMzNQogbXNnaWQgIi0ta2VlcC11bnJlYWNoYWJsZSBhbmQgLUEgYXJlIGluY29tcGF0aWJsZSIKIG1zZ3N0ciAiLS1rZWVwLXVucmVhY2hhYmxlIHkgLUEgc29uIGluY29tcGF0aWJsZXMiCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6NDE3CisjOiBidWlsdGluL3JlcGFjay5jOjQxOAogbXNnaWQgIk5vdGhpbmcgbmV3IHRvIHBhY2suIgogbXNnc3RyICJOYWRhIG51ZXZvIHBhcmEgZW1wYXF1ZXRhci4iCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6NDc4CisjOiBidWlsdGluL3JlcGFjay5jOjQ3OQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiV0FSTklORzogU29tZSBwYWNrcyBpbiB1c2UgaGF2ZSBiZWVuIHJlbmFtZWQgYnlcbiIKQEAgLTE4NDgwLDcgKzE4NTY2LDcgQEAKICJXQVJOSU5HOiB0YW1iacOpbiBmYWxsw7MuXG4iCiAiV0FSTklORzogUG9yIGZhdm9yIHJlbm9tYnJhbG9zIGVuICVzIG1hbnVhbG1lbnRlOlxuIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjUyNgorIzogYnVpbHRpbi9yZXBhY2suYzo1MjcKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIHJlbW92ZSAnJXMnIgogbXNnc3RyICJmYWxsw7MgYWwgZWxpbWluYXInJXMnIgpAQCAtMTg1ODgsOCArMTg2NzQsOCBAQAogbXNnaWQgInVuYWJsZSB0byB3cml0ZSBvYmplY3QgdG8gZGF0YWJhc2UiCiBtc2dzdHIgImluY2FwYXogZGUgZXNjcmliaXIgZWwgb2JqZXRvIGVuIGxhIGJhc2UgZGUgZGF0b3MiCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjMyMiBidWlsdGluL3JlcGxhY2UuYzozNzcgYnVpbHRpbi9yZXBsYWNlLmM6NDIyCi0jOiBidWlsdGluL3JlcGxhY2UuYzo0NTIKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjMyMiBidWlsdGluL3JlcGxhY2UuYzozNzggYnVpbHRpbi9yZXBsYWNlLmM6NDIzCisjOiBidWlsdGluL3JlcGxhY2UuYzo0NTMKICMsIGMtZm9ybWF0CiBtc2dpZCAibm90IGEgdmFsaWQgb2JqZWN0IG5hbWU6ICclcyciCiBtc2dzdHIgIm5vbWJyZSBkZSBvYmpldG8gbm8gdsOhbGlkbzogJyVzJyIKQEAgLTE4NjA4LDIyICsxODY5NCwyMiBAQAogbXNnaWQgIm5ldyBvYmplY3QgaXMgdGhlIHNhbWUgYXMgdGhlIG9sZCBvbmU6ICclcyciCiBtc2dzdHIgIm51ZXZvIG9iamV0byBlcyBpZ3VhbCBhbCBhbnRpZ3VvOiAnJXMnIgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzozODMKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjM4NAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcGFyc2UgJXMgYXMgYSBjb21taXQiCiBtc2dzdHIgIm5vIHNlIHB1ZG8gYW5hbGl6YXIgJXMgY29tbyB1biBjb21taXQiCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjQxNAorIzogYnVpbHRpbi9yZXBsYWNlLmM6NDE1CiAjLCBjLWZvcm1hdAogbXNnaWQgImJhZCBtZXJnZXRhZyBpbiBjb21taXQgJyVzJyIKIG1zZ3N0ciAibWFsIG1lcmdldGFnIGVuIGNvbW1pdCAnJXMnIgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo0MTYKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjQxNwogIywgYy1mb3JtYXQKIG1zZ2lkICJtYWxmb3JtZWQgbWVyZ2V0YWcgaW4gY29tbWl0ICclcyciCiBtc2dzdHIgIm1lcmdldGFnIG1hbCBmb3JtYWRvIGVuIGNvbW1pdCAnJXMnIgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo0MjgKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjQyOQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAib3JpZ2luYWwgY29tbWl0ICclcycgY29udGFpbnMgbWVyZ2V0YWcgJyVzJyB0aGF0IGlzIGRpc2NhcmRlZDsgdXNlIC0tZWRpdCAiCkBAIC0xODYzMiwzMSArMTg3MTgsMzEgQEAKICJjb21taXQgb3JpZ2luYWwgJyVzJyBjb250aWVuZSB1biBtZXJnZXRhZyAnJXMnIHF1ZSBlcyBkZXNjYXJ0YWRvOyB1c2UgLS1lZGl0ICIKICJlbiBsdWdhciBkZSAtLWdyYWZ0IgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo0NjcKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjQ2OAogIywgYy1mb3JtYXQKIG1zZ2lkICJ0aGUgb3JpZ2luYWwgY29tbWl0ICclcycgaGFzIGEgZ3BnIHNpZ25hdHVyZSIKIG1zZ3N0ciAiZWwgY29tbWl0IG9yaWdpbmFsICclcycgdGllbmUgdW5hIGZpcm1hIGdwZyIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NDY4CisjOiBidWlsdGluL3JlcGxhY2UuYzo0NjkKIG1zZ2lkICJ0aGUgc2lnbmF0dXJlIHdpbGwgYmUgcmVtb3ZlZCBpbiB0aGUgcmVwbGFjZW1lbnQgY29tbWl0ISIKLW1zZ3N0ciAibGEgZmlybWEgc2Vyw6EgcmVtb3ZpZGEgZW4gZWwgY29tbWl0IGRlIHJlZW1wbGF6byEiCittc2dzdHIgImxhIGZpcm1hIHNlcsOhIGVsaW1pbmFkYSBlbiBlbCBjb21taXQgZGUgcmVlbXBsYXpvISIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NDc4CisjOiBidWlsdGluL3JlcGxhY2UuYzo0NzkKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHdyaXRlIHJlcGxhY2VtZW50IGNvbW1pdCBmb3I6ICclcyciCiBtc2dzdHIgIm5vIHNlIHB1ZG8gZXNjcmliaXIgZWwgY29tbWl0IGRlIHJlZW1wbGF6bzogJyVzJyIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NDg2CisjOiBidWlsdGluL3JlcGxhY2UuYzo0ODcKICMsIGMtZm9ybWF0CiBtc2dpZCAiZ3JhZnQgZm9yICclcycgdW5uZWNlc3NhcnkiCiBtc2dzdHIgImdyYWZ0IHBhcmEgJyVzJyBpbm5lY2VzYXJpbyIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NDkwCisjOiBidWlsdGluL3JlcGxhY2UuYzo0OTEKICMsIGMtZm9ybWF0CiBtc2dpZCAibmV3IGNvbW1pdCBpcyB0aGUgc2FtZSBhcyB0aGUgb2xkIG9uZTogJyVzJyIKIG1zZ3N0ciAibnVldm8gY29tbWl0IGVzIGxlIG1pc21vIHF1ZSBlbCBhbnRpZ3VvOiAnJXMnIgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo1MjUKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjUyNgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiY291bGQgbm90IGNvbnZlcnQgdGhlIGZvbGxvd2luZyBncmFmdChzKTpcbiIKQEAgLTE4NjY1LDcxICsxODc1MSw3MSBAQAogIm5vIHNlIHB1ZG8gY29udmVydGlyIGVsIHNpZ3VpZW50ZSBncmFmdChzKTpcbiIKICIlcyIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NTQ2CisjOiBidWlsdGluL3JlcGxhY2UuYzo1NDcKIG1zZ2lkICJsaXN0IHJlcGxhY2UgcmVmcyIKIG1zZ3N0ciAibGlzdGFyIHJlcGxhY2UgcmVmcyIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NTQ3CisjOiBidWlsdGluL3JlcGxhY2UuYzo1NDgKIG1zZ2lkICJkZWxldGUgcmVwbGFjZSByZWZzIgogbXNnc3RyICJib3JyYXIgcmVwbGFjZSByZWZzIgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo1NDgKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU0OQogbXNnaWQgImVkaXQgZXhpc3Rpbmcgb2JqZWN0IgogbXNnc3RyICJlZGl0YXIgb2JqZXRvIGV4aXN0ZW50ZSIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NTQ5CisjOiBidWlsdGluL3JlcGxhY2UuYzo1NTAKIG1zZ2lkICJjaGFuZ2UgYSBjb21taXQncyBwYXJlbnRzIgogbXNnc3RyICJjYW1iaWFyIHVuIHBhZHJlIGRlIGNvbW1pdCIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NTUwCisjOiBidWlsdGluL3JlcGxhY2UuYzo1NTEKIG1zZ2lkICJjb252ZXJ0IGV4aXN0aW5nIGdyYWZ0IGZpbGUiCiBtc2dzdHIgImNvbnZlcnRpciBhcmNoaXZvIGdyYWZ0IGV4aXN0ZW50ZSIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NTUxCisjOiBidWlsdGluL3JlcGxhY2UuYzo1NTIKIG1zZ2lkICJyZXBsYWNlIHRoZSByZWYgaWYgaXQgZXhpc3RzIgogbXNnc3RyICJyZWVtcGxhemFyIGVsIHJlZiBzaSBlc3RlIGV4aXN0ZSIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NTUzCisjOiBidWlsdGluL3JlcGxhY2UuYzo1NTQKIG1zZ2lkICJkbyBub3QgcHJldHR5LXByaW50IGNvbnRlbnRzIGZvciAtLWVkaXQiCiBtc2dzdHIgIm5vIHNlIHB1ZWRlIGltcHJpbWlyIGNvbnRlbmlkb3MgcGFyYSAtLWVkaXQiCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU1NAorIzogYnVpbHRpbi9yZXBsYWNlLmM6NTU1CiBtc2dpZCAidXNlIHRoaXMgZm9ybWF0IgogbXNnc3RyICJ1c2FyIGVzdGUgZm9ybWF0byIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NTY3CisjOiBidWlsdGluL3JlcGxhY2UuYzo1NjgKIG1zZ2lkICItLWZvcm1hdCBjYW5ub3QgYmUgdXNlZCB3aGVuIG5vdCBsaXN0aW5nIgogbXNnc3RyICItLWZvcm1hdCBubyBwdWVkZSBzZXIgdXNhZG8gY3VhbmRvIG5vIHNlIGhhY2UgbGlzdGluZyIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NTc1CisjOiBidWlsdGluL3JlcGxhY2UuYzo1NzYKIG1zZ2lkICItZiBvbmx5IG1ha2VzIHNlbnNlIHdoZW4gd3JpdGluZyBhIHJlcGxhY2VtZW50IgogbXNnc3RyICItZiBzb2xvIHRpZW5lIHNlbnRpZG8gY3VhbmRvIHNlIGVzY3JpYmUgdW4gcmVlbXBsYXpvIgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo1NzkKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU4MAogbXNnaWQgIi0tcmF3IG9ubHkgbWFrZXMgc2Vuc2Ugd2l0aCAtLWVkaXQiCiBtc2dzdHIgIi0tcmF3IHNvbG8gdGllbmUgc2VudGlkbyBjb24gLS1lZGl0IgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo1ODUKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU4NgogbXNnaWQgIi1kIG5lZWRzIGF0IGxlYXN0IG9uZSBhcmd1bWVudCIKIG1zZ3N0ciAiLWQgbmVjZXNpdGEgYWwgbWVub3MgdW4gYXJndW1lbnRvIgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo1OTEKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU5MgogbXNnaWQgImJhZCBudW1iZXIgb2YgYXJndW1lbnRzIgogbXNnc3RyICJtYWwgbsO6bWVybyBkZSBhcmd1bWVudG9zIgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo1OTcKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU5OAogbXNnaWQgIi1lIG5lZWRzIGV4YWN0bHkgb25lIGFyZ3VtZW50IgogbXNnc3RyICItZSBuZWNlc2l0YSBleGFjdGFtZW50ZSB1biBhcmd1bWVudG8iCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjYwMworIzogYnVpbHRpbi9yZXBsYWNlLmM6NjA0CiBtc2dpZCAiLWcgbmVlZHMgYXQgbGVhc3Qgb25lIGFyZ3VtZW50IgogbXNnc3RyICItZyBuZWNlc2l0YSBhbCBtZW5vcyB1biBhcmd1bWVudG8iCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjYwOQorIzogYnVpbHRpbi9yZXBsYWNlLmM6NjEwCiBtc2dpZCAiLS1jb252ZXJ0LWdyYWZ0LWZpbGUgdGFrZXMgbm8gYXJndW1lbnQiCiBtc2dzdHIgIi0tY29udmVydC1ncmFmdC1maWxlIG5vIHRvbWEgYXJndW1lbnRvcyIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NjE1CisjOiBidWlsdGluL3JlcGxhY2UuYzo2MTYKIG1zZ2lkICJvbmx5IG9uZSBwYXR0ZXJuIGNhbiBiZSBnaXZlbiB3aXRoIC1sIgogbXNnc3RyICJzb2xvIHNlIHB1ZWRlIGRhciB1biBwYXRyw7NuIGNvbiAtbCIKIApAQCAtMTg3OTcsMTMgKzE4ODgzLDE4IEBACiBtc2dpZCAiRmFpbGVkIHRvIGZpbmQgdHJlZSBvZiAlcy4iCiBtc2dzdHIgIkZhbGzDsyBhbCBlbmNvbnRyYXIgw6FyYm9sIGRlICVzLiIKIAorIzogYnVpbHRpbi9yZXNldC5jOjExNAorIywgYy1mb3JtYXQKK21zZ2lkICJIRUFEIGlzIG5vdyBhdCAlcyIKK21zZ3N0ciAiSEVBRCBlc3TDoSBhaG9yYSBlbiAlcyIKKwogIzogYnVpbHRpbi9yZXNldC5jOjE5MwogIywgYy1mb3JtYXQKIG1zZ2lkICJDYW5ub3QgZG8gYSAlcyByZXNldCBpbiB0aGUgbWlkZGxlIG9mIGEgbWVyZ2UuIgogbXNnc3RyICJObyBzZSBwdWVkZSByZWFsemlhciB1biByZXNldCAlcyAgZW4gbWVkaW8gZGUgdW5hIGZ1c2nDs24uIgogCi0jOiBidWlsdGluL3Jlc2V0LmM6MjkzIGJ1aWx0aW4vc3Rhc2guYzo1MTQgYnVpbHRpbi9zdGFzaC5jOjU4OQotIzogYnVpbHRpbi9zdGFzaC5jOjYxMworIzogYnVpbHRpbi9yZXNldC5jOjI5MyBidWlsdGluL3N0YXNoLmM6NTIwIGJ1aWx0aW4vc3Rhc2guYzo1OTUKKyM6IGJ1aWx0aW4vc3Rhc2guYzo2MTkKIG1zZ2lkICJiZSBxdWlldCwgb25seSByZXBvcnQgZXJyb3JzIgogbXNnc3RyICJzZXIgc2lsZW5jaW9zbywgc29sbyByZXBvcnRhciBlcnJvcmVzIgogCkBAIC0xODgyNiw3ICsxODkxNyw3IEBACiAjOiBidWlsdGluL3Jlc2V0LmM6MzA4CiBtc2dpZCAicmVjb3JkIG9ubHkgdGhlIGZhY3QgdGhhdCByZW1vdmVkIHBhdGhzIHdpbGwgYmUgYWRkZWQgbGF0ZXIiCiBtc2dzdHIgIiIKLSJncmFiYXIgc29sbyBlbCBoZWNobyBkZSBxdWUgbGFzIHJ1dGFzIHJlbW92aWRhcyBzZXLDoW4gYWdyZWdhZGFzIGRlc3B1w6lzIgorImdyYWJhciBzb2xvIGVsIGhlY2hvIGRlIHF1ZSBsYXMgcnV0YXMgZWxpbWluYWRhcyBzZXLDoW4gYWdyZWdhZGFzIGRlc3B1w6lzIgogCiAjOiBidWlsdGluL3Jlc2V0LmM6MzI2CiAjLCBjLWZvcm1hdApAQCAtMTg4ODgsMjQgKzE4OTc5LDE5IEBACiBtc2dpZCAiQ291bGQgbm90IHdyaXRlIG5ldyBpbmRleCBmaWxlLiIKIG1zZ3N0ciAiTm8gc2UgcHVlZGUgZXNjcmliaXIgdW4gbnVldm8gYXJjaGl2byDDrW5kaWNlLiIKIAotIzogYnVpbHRpbi9yZXYtbGlzdC5jOjQxMgorIzogYnVpbHRpbi9yZXYtbGlzdC5jOjQxMQogbXNnaWQgImNhbm5vdCBjb21iaW5lIC0tZXhjbHVkZS1wcm9taXNvci1vYmplY3RzIGFuZCAtLW1pc3NpbmciCiBtc2dzdHIgIm5vIHNlIHB1ZWRlIGNvbWJpbmFyIC0tZXhjbHVkZS1wcm9taXNvci1vYmplY3RzIHkgLS1taXNzaW5nIgogCi0jOiBidWlsdGluL3Jldi1saXN0LmM6NDczCisjOiBidWlsdGluL3Jldi1saXN0LmM6NDcyCiBtc2dpZCAib2JqZWN0IGZpbHRlcmluZyByZXF1aXJlcyAtLW9iamVjdHMiCiBtc2dzdHIgImZpbHRyYWRvIGRlIG9iamV0b3MgcmVxdWllcmUgLS1vYmplY3RzIgogCi0jOiBidWlsdGluL3Jldi1saXN0LmM6NDc2Ci0jLCBjLWZvcm1hdAotbXNnaWQgImludmFsaWQgc3BhcnNlIHZhbHVlICclcyciCi1tc2dzdHIgInZhbG9yIGRpc3BlcnNvIGludsOhbGlkbzogJyVzJyIKLQotIzogYnVpbHRpbi9yZXYtbGlzdC5jOjUyNworIzogYnVpbHRpbi9yZXYtbGlzdC5jOjUyMgogbXNnaWQgInJldi1saXN0IGRvZXMgbm90IHN1cHBvcnQgZGlzcGxheSBvZiBub3RlcyIKIG1zZ3N0ciAicmV2LWxpc3Qgbm8gc29wb3J0YSBtb3N0cmFyIG5vdGFzIgogCi0jOiBidWlsdGluL3Jldi1saXN0LmM6NTMwCisjOiBidWlsdGluL3Jldi1saXN0LmM6NTI1CiBtc2dpZCAiY2Fubm90IGNvbWJpbmUgLS11c2UtYml0bWFwLWluZGV4IHdpdGggb2JqZWN0IGZpbHRlcmluZyIKIG1zZ3N0ciAibm8gc2UgcHVlZGUgY29tYmluYXIgLS11c2UtYml0bWFwLWluZGV4IGNvbiBvYmpldG9zIGRlIGZpbHRyYWRvIgogCkBAIC0xOTEwMSw3ICsxOTE4Nyw3IEBACiAjOiBidWlsdGluL3JtLmM6MzA3CiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vdCByZW1vdmluZyAnJXMnIHJlY3Vyc2l2ZWx5IHdpdGhvdXQgLXIiCi1tc2dzdHIgIm5vIHJlbW92aWVuZG8gJyVzJyBkZSBtYW5lcmEgcmVjdXJzaXZhIHNpbiAtciIKK21zZ3N0ciAibm8gZWxpbWluYW5kbyAnJXMnIGRlIG1hbmVyYSByZWN1cnNpdmEgc2luIC1yIgogCiAjOiBidWlsdGluL3JtLmM6MzQ2CiAjLCBjLWZvcm1hdApAQCAtMTk0NDUsMTM0ICsxOTUzMSwxMzQgQEAKIG1zZ2lkICJjb3VsZCBub3Qgc2F2ZSBpbmRleCB0cmVlIgogbXNnc3RyICJubyBzZSBwdWVkZSBndWFyZGFyIGVsIMOtbmRpY2UgZGVsIMOhcmJvbCIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjQzNAorIzogYnVpbHRpbi9zdGFzaC5jOjQzNgogbXNnaWQgImNvdWxkIG5vdCByZXN0b3JlIHVudHJhY2tlZCBmaWxlcyBmcm9tIHN0YXNoIgogbXNnc3RyICJubyBzZSBwdWVkZW4gcmVzdGF1cmFyIGFyY2hpdm9zIG5vIHJhc3RyZWFkb3MgZGUgbGEgZW50cmFkYSBzdGFzaCIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjQ0OAorIzogYnVpbHRpbi9zdGFzaC5jOjQ1MAogIywgYy1mb3JtYXQKIG1zZ2lkICJNZXJnaW5nICVzIHdpdGggJXMiCiBtc2dzdHIgIkZ1c2lvbmFuZG8gJXMgY29uICVzIgogCi0jOiBidWlsdGluL3N0YXNoLmM6NDU4IGdpdC1sZWdhY3ktc3Rhc2guc2g6NjgwCisjOiBidWlsdGluL3N0YXNoLmM6NDYwIGdpdC1sZWdhY3ktc3Rhc2guc2g6NjgwCiBtc2dpZCAiSW5kZXggd2FzIG5vdCB1bnN0YXNoZWQuIgogbXNnc3RyICJFbCDDrW5kaWNlIG5vIGZ1ZSBzYWNhZG8gZGUgc3Rhc2guIgogCi0jOiBidWlsdGluL3N0YXNoLmM6NTE2IGJ1aWx0aW4vc3Rhc2guYzo2MTUKKyM6IGJ1aWx0aW4vc3Rhc2guYzo1MjIgYnVpbHRpbi9zdGFzaC5jOjYyMQogbXNnaWQgImF0dGVtcHQgdG8gcmVjcmVhdGUgdGhlIGluZGV4IgogbXNnc3RyICJpbnRlbnRvIGRlIHJlY3JlYXIgZWwgaW5kZXgiCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzo1NDkKKyM6IGJ1aWx0aW4vc3Rhc2guYzo1NTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiRHJvcHBlZCAlcyAoJXMpIgogbXNnc3RyICJCb3RhZG8gJXMgKCVzKSIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjU1MgorIzogYnVpbHRpbi9zdGFzaC5jOjU1OAogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogQ291bGQgbm90IGRyb3Agc3Rhc2ggZW50cnkiCiBtc2dzdHIgIiVzOiBObyBzZSBwdWRvIGJvcnJhciBlbnRyYWRhIHN0YXNoIgogCi0jOiBidWlsdGluL3N0YXNoLmM6NTc3CisjOiBidWlsdGluL3N0YXNoLmM6NTgzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiclcycgaXMgbm90IGEgc3Rhc2ggcmVmZXJlbmNlIgogbXNnc3RyICInJXMnIG5vIGVzIHVuYSByZWZlcmVuY2lhIHN0YXNoIgogCi0jOiBidWlsdGluL3N0YXNoLmM6NjI3IGdpdC1sZWdhY3ktc3Rhc2guc2g6Njk0CisjOiBidWlsdGluL3N0YXNoLmM6NjMzIGdpdC1sZWdhY3ktc3Rhc2guc2g6Njk0CiBtc2dpZCAiVGhlIHN0YXNoIGVudHJ5IGlzIGtlcHQgaW4gY2FzZSB5b3UgbmVlZCBpdCBhZ2Fpbi4iCiBtc2dzdHIgIkxhIGVudHJhZGEgZGUgc3Rhc2ggc2UgZ3VhcmTDsyBlbiBjYXNvIGRlIHNlciBuZWNlc2FyaW8gbnVldmFtZW50ZS4iCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzo2NTAgZ2l0LWxlZ2FjeS1zdGFzaC5zaDo3MTIKKyM6IGJ1aWx0aW4vc3Rhc2guYzo2NTYgZ2l0LWxlZ2FjeS1zdGFzaC5zaDo3MTIKIG1zZ2lkICJObyBicmFuY2ggbmFtZSBzcGVjaWZpZWQiCiBtc2dzdHIgIk5vIHNlIGVzcGVjaWZpY8OzIGVsIG5vbWJyZSBkZSBsYSByYW1hIgogCi0jOiBidWlsdGluL3N0YXNoLmM6NzkwIGJ1aWx0aW4vc3Rhc2guYzo4MjcKKyM6IGJ1aWx0aW4vc3Rhc2guYzo3OTYgYnVpbHRpbi9zdGFzaC5jOjgzMwogIywgYy1mb3JtYXQKIG1zZ2lkICJDYW5ub3QgdXBkYXRlICVzIHdpdGggJXMiCiBtc2dzdHIgIk5vIHNlIHB1ZWRlIGFjdHVhbGl6YXIgJXMgY29uICVzIgogCi0jOiBidWlsdGluL3N0YXNoLmM6ODA4IGJ1aWx0aW4vc3Rhc2guYzoxNDYxIGJ1aWx0aW4vc3Rhc2guYzoxNDk3CisjOiBidWlsdGluL3N0YXNoLmM6ODE0IGJ1aWx0aW4vc3Rhc2guYzoxNDcwIGJ1aWx0aW4vc3Rhc2guYzoxNTA2CiBtc2dpZCAic3Rhc2ggbWVzc2FnZSIKIG1zZ3N0ciAibWVuc2FqZSBkZSBzdGFzaCIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjgxOAorIzogYnVpbHRpbi9zdGFzaC5jOjgyNAogbXNnaWQgIlwiZ2l0IHN0YXNoIHN0b3JlXCIgcmVxdWlyZXMgb25lIDxjb21taXQ+IGFyZ3VtZW50IgogbXNnc3RyICJcImdpdCBzdGFzaCBzdG9yZVwiIHJlcXVpZXJlIHVuIGFyZ3VtZW50byA8Y29tbWl0PiIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjEwNDAgZ2l0LWxlZ2FjeS1zdGFzaC5zaDoyMTcKKyM6IGJ1aWx0aW4vc3Rhc2guYzoxMDQ2IGdpdC1sZWdhY3ktc3Rhc2guc2g6MjE3CiBtc2dpZCAiTm8gY2hhbmdlcyBzZWxlY3RlZCIKIG1zZ3N0ciAiU2luIGNhbWJpb3Mgc2VsZWNjaW9uYWRvcyIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjExMzYgZ2l0LWxlZ2FjeS1zdGFzaC5zaDoxNTAKKyM6IGJ1aWx0aW4vc3Rhc2guYzoxMTQ1IGdpdC1sZWdhY3ktc3Rhc2guc2g6MTUwCiBtc2dpZCAiWW91IGRvIG5vdCBoYXZlIHRoZSBpbml0aWFsIGNvbW1pdCB5ZXQiCiBtc2dzdHIgIkHDum4gbm8gdGllbmVzIHVuIGNvbW1pdCBpbmljaWFsIgogCi0jOiBidWlsdGluL3N0YXNoLmM6MTE2MyBnaXQtbGVnYWN5LXN0YXNoLnNoOjE2NQorIzogYnVpbHRpbi9zdGFzaC5jOjExNzIgZ2l0LWxlZ2FjeS1zdGFzaC5zaDoxNjUKIG1zZ2lkICJDYW5ub3Qgc2F2ZSB0aGUgY3VycmVudCBpbmRleCBzdGF0ZSIKIG1zZ3N0ciAiTm8gc2UgcHVlZGUgZ3VhcmRhciBlbCBlc3RhZG8gYWN0dWFsIGRlbCDDrW5kaWNlIgogCi0jOiBidWlsdGluL3N0YXNoLmM6MTE3MiBnaXQtbGVnYWN5LXN0YXNoLnNoOjE4MAorIzogYnVpbHRpbi9zdGFzaC5jOjExODEgZ2l0LWxlZ2FjeS1zdGFzaC5zaDoxODAKIG1zZ2lkICJDYW5ub3Qgc2F2ZSB0aGUgdW50cmFja2VkIGZpbGVzIgogbXNnc3RyICJObyBzZSBwdWVkZW4gZ3VhcmRhciBsb3MgYXJjaGl2b3Mgbm8gcmFzdHJlYWRvcyIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjExODMgYnVpbHRpbi9zdGFzaC5jOjExOTIgZ2l0LWxlZ2FjeS1zdGFzaC5zaDoyMDAKKyM6IGJ1aWx0aW4vc3Rhc2guYzoxMTkyIGJ1aWx0aW4vc3Rhc2guYzoxMjAxIGdpdC1sZWdhY3ktc3Rhc2guc2g6MjAwCiAjOiBnaXQtbGVnYWN5LXN0YXNoLnNoOjIxMwogbXNnaWQgIkNhbm5vdCBzYXZlIHRoZSBjdXJyZW50IHdvcmt0cmVlIHN0YXRlIgogbXNnc3RyICJObyBzZSBwdWVkZSBndWFyZGFyIGVsIGVzdGFkbyBhY3R1YWwgZGVsIMOhcmJvbCBkZSB0cmFiYWpvIgogCi0jOiBidWlsdGluL3N0YXNoLmM6MTIyMCBnaXQtbGVnYWN5LXN0YXNoLnNoOjIzMworIzogYnVpbHRpbi9zdGFzaC5jOjEyMjkgZ2l0LWxlZ2FjeS1zdGFzaC5zaDoyMzMKIG1zZ2lkICJDYW5ub3QgcmVjb3JkIHdvcmtpbmcgdHJlZSBzdGF0ZSIKIG1zZ3N0ciAiTm8gc2UgcHVlZGUgZ3JhYmFyIGVsIGVzdGFkbyBkZWwgw6FyYm9sIGRlIHRyYWJham8iCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzoxMjY5IGdpdC1sZWdhY3ktc3Rhc2guc2g6MzM3CisjOiBidWlsdGluL3N0YXNoLmM6MTI3OCBnaXQtbGVnYWN5LXN0YXNoLnNoOjMzNwogbXNnaWQgIkNhbid0IHVzZSAtLXBhdGNoIGFuZCAtLWluY2x1ZGUtdW50cmFja2VkIG9yIC0tYWxsIGF0IHRoZSBzYW1lIHRpbWUiCiBtc2dzdHIgIk5vIHNlIHB1ZWRlIHVzYXIgLS1wYXRjaCB5IC0taW5jbHVkZS11bnRyYWNrZWQgbyAtLWFsbCBhbCBtaXNtbyB0aWVtcG8iCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzoxMjg1CisjOiBidWlsdGluL3N0YXNoLmM6MTI5NAogbXNnaWQgIkRpZCB5b3UgZm9yZ2V0IHRvICdnaXQgYWRkJz8iCi1tc2dzdHIgIk9sdmlkYXN0ZSAnZ2l0IGFkZCc/IgorbXNnc3RyICLCv09sdmlkYXN0ZSAnZ2l0IGFkZCc/IgogCi0jOiBidWlsdGluL3N0YXNoLmM6MTMwMCBnaXQtbGVnYWN5LXN0YXNoLnNoOjM0NQorIzogYnVpbHRpbi9zdGFzaC5jOjEzMDkgZ2l0LWxlZ2FjeS1zdGFzaC5zaDozNDUKIG1zZ2lkICJObyBsb2NhbCBjaGFuZ2VzIHRvIHNhdmUiCiBtc2dzdHIgIk5vIGhheSBjYW1iaW9zIGxvY2FsZXMgcGFyYSBndWFyZGFyIgogCi0jOiBidWlsdGluL3N0YXNoLmM6MTMwNyBnaXQtbGVnYWN5LXN0YXNoLnNoOjM1MAorIzogYnVpbHRpbi9zdGFzaC5jOjEzMTYgZ2l0LWxlZ2FjeS1zdGFzaC5zaDozNTAKIG1zZ2lkICJDYW5ub3QgaW5pdGlhbGl6ZSBzdGFzaCIKIG1zZ3N0ciAiTm8gc2UgcHVlZGUgaW5pY2lhbGl6YXIgc3Rhc2giCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzoxMzIyIGdpdC1sZWdhY3ktc3Rhc2guc2g6MzU0CisjOiBidWlsdGluL3N0YXNoLmM6MTMzMSBnaXQtbGVnYWN5LXN0YXNoLnNoOjM1NAogbXNnaWQgIkNhbm5vdCBzYXZlIHRoZSBjdXJyZW50IHN0YXR1cyIKIG1zZ3N0ciAiTm8gc2UgcHVlZGUgZ3VhcmRhciBlbCBlc3RhZG8gYWN0dWFsIgogCi0jOiBidWlsdGluL3N0YXNoLmM6MTMyNworIzogYnVpbHRpbi9zdGFzaC5jOjEzMzYKICMsIGMtZm9ybWF0CiBtc2dpZCAiU2F2ZWQgd29ya2luZyBkaXJlY3RvcnkgYW5kIGluZGV4IHN0YXRlICVzIgogbXNnc3RyICJEaXJlY3RvcmlvIGRlIHRyYWJham8gZ3VhcmRhZG8geSBlc3RhZG8gZGUgw61uZGljZSAlcyIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjE0MTcgZ2l0LWxlZ2FjeS1zdGFzaC5zaDozODQKKyM6IGJ1aWx0aW4vc3Rhc2guYzoxNDI2IGdpdC1sZWdhY3ktc3Rhc2guc2g6Mzg0CiBtc2dpZCAiQ2Fubm90IHJlbW92ZSB3b3JrdHJlZSBjaGFuZ2VzIgogbXNnc3RyICJObyBzZSBwdWVkZW4gZWxpbWluYXIgY2FtYmlvcyBkZWwgw6FyYm9sIGRlIHRyYWJham8iCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzoxNDUyIGJ1aWx0aW4vc3Rhc2guYzoxNDg4CisjOiBidWlsdGluL3N0YXNoLmM6MTQ2MSBidWlsdGluL3N0YXNoLmM6MTQ5NwogbXNnaWQgImtlZXAgaW5kZXgiCiBtc2dzdHIgIm1hbnRlbmVyIGluZGV4IgogCi0jOiBidWlsdGluL3N0YXNoLmM6MTQ1NCBidWlsdGluL3N0YXNoLmM6MTQ5MAorIzogYnVpbHRpbi9zdGFzaC5jOjE0NjMgYnVpbHRpbi9zdGFzaC5jOjE0OTkKIG1zZ2lkICJzdGFzaCBpbiBwYXRjaCBtb2RlIgogbXNnc3RyICJzdGFzaCBlbiBtb2RvIHBhdGNoIgogCi0jOiBidWlsdGluL3N0YXNoLmM6MTQ1NSBidWlsdGluL3N0YXNoLmM6MTQ5MQorIzogYnVpbHRpbi9zdGFzaC5jOjE0NjQgYnVpbHRpbi9zdGFzaC5jOjE1MDAKIG1zZ2lkICJxdWlldCBtb2RlIgogbXNnc3RyICJtb2RvIHRyYW5xdWlsbyIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjE0NTcgYnVpbHRpbi9zdGFzaC5jOjE0OTMKKyM6IGJ1aWx0aW4vc3Rhc2guYzoxNDY2IGJ1aWx0aW4vc3Rhc2guYzoxNTAyCiBtc2dpZCAiaW5jbHVkZSB1bnRyYWNrZWQgZmlsZXMgaW4gc3Rhc2giCiBtc2dzdHIgImluY2x1aXIgYXJjaGl2b3Mgc2luIHNlZ3VpbWllbnRvIGVuIHN0YXNoIgogCi0jOiBidWlsdGluL3N0YXNoLmM6MTQ1OSBidWlsdGluL3N0YXNoLmM6MTQ5NQorIzogYnVpbHRpbi9zdGFzaC5jOjE0NjggYnVpbHRpbi9zdGFzaC5jOjE1MDQKIG1zZ2lkICJpbmNsdWRlIGlnbm9yZSBmaWxlcyIKIG1zZ3N0ciAiaW5jbHVpciBhcmNoaXZvcyBpZ25vcmFkb3MiCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzoxNTU1CisjOiBidWlsdGluL3N0YXNoLmM6MTU2NAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgZXhlYyAlcyIKIG1zZ3N0ciAibm8gc2UgcHVkbyBlamVjdXRhciAlcyIKQEAgLTE5ODk1LDcgKzE5OTgxLDcgQEAKIAogIzogYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjE1NzUKIG1zZ2lkICJNYXliZSB5b3Ugd2FudCB0byB1c2UgJ3VwZGF0ZSAtLWluaXQnPyIKLW1zZ3N0ciAiVGFsIHZleiBxdWllcmVzIHVzYXIgJ3VwZGF0ZSAtLWluaXQnPyIKK21zZ3N0ciAiwr9UYWwgdmV6IHF1aWVyZXMgdXNhciAndXBkYXRlIC0taW5pdCc/IgogCiAjOiBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6MTYwNQogIywgYy1mb3JtYXQKQEAgLTE5OTQ3LDggKzIwMDMzLDggQEAKIG1zZ3N0ciAibm8gbW9zdHJhciBlbCBwcm9ncmVzbyBkZSBjbG9uYWRvIgogCiAjOiBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6MTg3NwotbXNnaWQgImdpdCBzdWJtb2R1bGUtLWhlbHBlciB1cGRhdGVfY2xvbmUgWy0tcHJlZml4PTxwYXRoPl0gWzxwYXRoPi4uLl0iCi1tc2dzdHIgImdpdCBzdWJtb2R1bGUtLWhlbHBlciB1cGRhdGVfY2xvbmUgWy0tcHJlZml4PTxydXRhPl0gWzxydXRhPi4uLl0iCittc2dpZCAiZ2l0IHN1Ym1vZHVsZS0taGVscGVyIHVwZGF0ZS1jbG9uZSBbLS1wcmVmaXg9PHBhdGg+XSBbPHBhdGg+Li4uXSIKK21zZ3N0ciAiZ2l0IHN1Ym1vZHVsZS0taGVscGVyIHVwZGF0ZS1jbG9uZSBbLS1wcmVmaXg9PHJ1dGE+XSBbPHJ1dGE+Li4uXSIKIAogIzogYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjE4OTAKIG1zZ2lkICJiYWQgdmFsdWUgZm9yIHVwZGF0ZSBwYXJhbWV0ZXIiCkBAIC0yMDAwMiw3ICsyMDA4OCw3IEBACiBtc2dzdHIgIiIKICJwb3IgZmF2b3IgYXNlZ8O6cmF0ZSBxdWUgZWwgYXJjaGl2byAuZ2l0bW9kdWxlcyBlc3TDoSBlbiBlbCDDoXJib2wgZGUgdHJhYmFqbyIKIAotIzogYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjIyMzUgZ2l0LmM6NDM0IGdpdC5jOjY4NAorIzogYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjIyMzUgZ2l0LmM6NDMzIGdpdC5jOjY4MwogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyBkb2Vzbid0IHN1cHBvcnQgLS1zdXBlci1wcmVmaXgiCiBtc2dzdHIgIiVzIG5vIHNvcG9ydGEgLS1zdXBlci1wcmVmaXgiCkBAIC0yMDMyNSwxNDMgKzIwNDExLDE0MyBAQAogbXNnaWQgImdpdCB1cGRhdGUtaW5kZXggWzxvcHRpb25zPl0gWy0tXSBbPGZpbGU+Li4uXSIKIG1zZ3N0ciAiZ2l0IHVwZGF0ZS1pbmRleCBbPG9wY2lvbmVzPl0gWy0tXSBbPGFyY2hpdm8+Li4uXSIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzo5NzEKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6OTcyCiBtc2dpZCAiY29udGludWUgcmVmcmVzaCBldmVuIHdoZW4gaW5kZXggbmVlZHMgdXBkYXRlIgogbXNnc3RyICIiCiAiY29udGludWFyIHJlZnJlc2ggKEFjdHVhbGl6YWNpw7NuKSBpbmNsdXNvIGN1YW5kbyBlbCDDrW5kaWNlIG5lY2VzaXRhICIKICJhY3R1YWxpemFjacOzbiIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzo5NzQKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6OTc1CiBtc2dpZCAicmVmcmVzaDogaWdub3JlIHN1Ym1vZHVsZXMiCiBtc2dzdHIgInJlZnJlc2g6IGlnbm9yYSBzdWJtw7NkdWxvcyIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzo5NzcKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6OTc4CiBtc2dpZCAiZG8gbm90IGlnbm9yZSBuZXcgZmlsZXMiCiBtc2dzdHIgIm5vIGlnbm9yYXIgYXJjaGl2b3MgbnVldm9zIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjk3OQorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzo5ODAKIG1zZ2lkICJsZXQgZmlsZXMgcmVwbGFjZSBkaXJlY3RvcmllcyBhbmQgdmljZS12ZXJzYSIKIG1zZ3N0ciAicGVybWl0aXIgcXVlIGFyY2hpdm9zIHJlbXBsYWNlbiBkaXJlY3RvcmlvcyB5IHZpY2UtdmVyc2EiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6OTgxCisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjk4MgogbXNnaWQgIm5vdGljZSBmaWxlcyBtaXNzaW5nIGZyb20gd29ya3RyZWUiCiBtc2dzdHIgImF2aXNhciBkZSBhcmNoaXZvcyBmYWx0YW5kbyBlbiBlbCDDoXJib2wgZGUgdHJhYmFqbyIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzo5ODMKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6OTg0CiBtc2dpZCAicmVmcmVzaCBldmVuIGlmIGluZGV4IGNvbnRhaW5zIHVubWVyZ2VkIGVudHJpZXMiCiBtc2dzdHIgImVqZWN1dGFyIHJlZnJlc2ggaW5jbHVzbyBzaSBlbCDDrW5kaWNlIGNvbnRpZW5lIGVudHJhZGFzIHNpbiBjYW1iaW9zIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjk4NgorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzo5ODcKIG1zZ2lkICJyZWZyZXNoIHN0YXQgaW5mb3JtYXRpb24iCiBtc2dzdHIgInJlZnJlc2ggaW5mb3JtYWNpw7NuIGRlIGVzdGFkbyIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzo5OTAKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6OTkxCiBtc2dpZCAibGlrZSAtLXJlZnJlc2gsIGJ1dCBpZ25vcmUgYXNzdW1lLXVuY2hhbmdlZCBzZXR0aW5nIgogbXNnc3RyICJjb21vIC0tcmVmcmVzaCwgcGVybyBpZ25vcmEgY29uZmlndXJhY2nDs24gYXNzdW1lLXVuY2hhbmdlZCIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzo5OTQKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6OTk1CiBtc2dpZCAiPG1vZGU+LDxvYmplY3Q+LDxwYXRoPiIKIG1zZ3N0ciAiPG1vZG8+LDxvYmpldG8+LDxydXRhPiIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzo5OTUKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6OTk2CiBtc2dpZCAiYWRkIHRoZSBzcGVjaWZpZWQgZW50cnkgdG8gdGhlIGluZGV4IgogbXNnc3RyICJhZ3JlZ2FyIGxhIGVudHJhZGEgZXNwZWNpZmljYWRhIGFsIMOtbmRpY2UiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAwNQorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDA2CiBtc2dpZCAibWFyayBmaWxlcyBhcyBcIm5vdCBjaGFuZ2luZ1wiIgogbXNnc3RyICJtYXJjYXIgYXJjaGl2b3MgY29tbyBcIm5vdCBjaGFuZ2luZ1wiIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMDgKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAwOQogbXNnaWQgImNsZWFyIGFzc3VtZWQtdW5jaGFuZ2VkIGJpdCIKIG1zZ3N0ciAibGltcGlhciBiaXQgYXNzdW1lZC11bmNoYW5nZWQiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAxMQorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDEyCiBtc2dpZCAibWFyayBmaWxlcyBhcyBcImluZGV4LW9ubHlcIiIKIG1zZ3N0ciAibWFyY2FyIGFyY2hpdm9zIGNvbW8gXCJpbmRleC1vbmx5XCIiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAxNAorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDE1CiBtc2dpZCAiY2xlYXIgc2tpcC13b3JrdHJlZSBiaXQiCiBtc2dzdHIgImxpbXBpYXIgYml0IHNraXAtd29ya3RyZWUiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAxNworIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDE4CiBtc2dpZCAiYWRkIHRvIGluZGV4IG9ubHk7IGRvIG5vdCBhZGQgY29udGVudCB0byBvYmplY3QgZGF0YWJhc2UiCiBtc2dzdHIgIiIKICJhZ3JlZ2FyIHNvbG8gYWwgw61uZGljZTsgbm8gYWdyZWdhciBjb250ZW5pZG8gYSBsYSBiYXNlIGRlIGRhdG9zIGRlIG9iamV0b3MiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAxOQorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDIwCiBtc2dpZCAicmVtb3ZlIG5hbWVkIHBhdGhzIGV2ZW4gaWYgcHJlc2VudCBpbiB3b3JrdHJlZSIKIG1zZ3N0ciAiIgogImVsaW1pbmFyIHJ1dGFzIG5vbWJyYWRhcyBpbmNsdXNvIHNpIGVzdMOhbiBwcmVzZW50ZXMgZW4gZWwgw6FyYm9sIGRlIHRyYWJham8iCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAyMQorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDIyCiBtc2dpZCAid2l0aCAtLXN0ZGluOiBpbnB1dCBsaW5lcyBhcmUgdGVybWluYXRlZCBieSBudWxsIGJ5dGVzIgogbXNnc3RyICJjb24gLS1zdGRpbjogbGFzIGzDrW5lYXMgZGUgZW50cmFkYSBzb24gdGVybWluYWRhcyBjb24gYnl0ZXMgbnVsb3MiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAyMworIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDI0CiBtc2dpZCAicmVhZCBsaXN0IG9mIHBhdGhzIHRvIGJlIHVwZGF0ZWQgZnJvbSBzdGFuZGFyZCBpbnB1dCIKIG1zZ3N0ciAibGVlciBsYSBsaXN0YSBkZSBydXRhcyBwYXJhIHNlciBhY3R1YWxpemFkYSBkZXNkZSBzdGFuZGFyZCBpbnB1dCIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDI3CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMjgKIG1zZ2lkICJhZGQgZW50cmllcyBmcm9tIHN0YW5kYXJkIGlucHV0IHRvIHRoZSBpbmRleCIKIG1zZ3N0ciAiYWdyZWdhciBlbnRyYWRhcyBkZSBzdGFuZGFyZCBpbnB1dCBhbCDDrW5kaWNlIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMzEKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAzMgogbXNnaWQgInJlcG9wdWxhdGUgc3RhZ2VzICMyIGFuZCAjMyBmb3IgdGhlIGxpc3RlZCBwYXRocyIKIG1zZ3N0ciAicmVwb2JsYXIgc3RhZ2VzICMyIHkgIzMgcGFyYSBsYXMgcnV0YXMgbGlzdGFkYXMiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAzNQorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDM2CiBtc2dpZCAib25seSB1cGRhdGUgZW50cmllcyB0aGF0IGRpZmZlciBmcm9tIEhFQUQiCiBtc2dzdHIgInNvbG8gYWN0dWFsaXphciBlbnRyYWRhcyBxdWUgZGlmaWVyZW4gZGUgSEVBRCIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDM5CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwNDAKIG1zZ2lkICJpZ25vcmUgZmlsZXMgbWlzc2luZyBmcm9tIHdvcmt0cmVlIgogbXNnc3RyICJpZ25vcmFyIGFyY2hpdm9zIGZhbHRhbnRlcyBlbiBlbCDDoXJib2wgZGUgdHJhYmFqbyIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDQyCisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwNDMKIG1zZ2lkICJyZXBvcnQgYWN0aW9ucyB0byBzdGFuZGFyZCBvdXRwdXQiCiBtc2dzdHIgInJlcG9ydGFyIGFjY2lvbmVzIHBvciBzdGFuZGFyZCBvdXRwdXQiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTA0NAorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDQ1CiBtc2dpZCAiKGZvciBwb3JjZWxhaW5zKSBmb3JnZXQgc2F2ZWQgdW5yZXNvbHZlZCBjb25mbGljdHMiCiBtc2dzdHIgIihwYXJhIHBvcmNlbGFuYXMpIG9sdmlkYXIgY29uZmxpY3RvcyBzaW4gcmVzb2x2ZXIgZ3VhcmRhZG9zIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwNDgKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTA0OQogbXNnaWQgIndyaXRlIGluZGV4IGluIHRoaXMgZm9ybWF0IgogbXNnc3RyICJlc2NyaWJpciDDrW5kaWNlIGVuIGVzdGUgZm9ybWF0byIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDUwCisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwNTEKIG1zZ2lkICJlbmFibGUgb3IgZGlzYWJsZSBzcGxpdCBpbmRleCIKIG1zZ3N0ciAiYWN0aXZhciBvIGRlc2FjdGl2YXIgw61uZGljZSBkaXZpZGlkbyIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDUyCisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwNTMKIG1zZ2lkICJlbmFibGUvZGlzYWJsZSB1bnRyYWNrZWQgY2FjaGUiCiBtc2dzdHIgImhhYmlsaXRhciBvIGRlc2hhYmlsaXRhciBjYWNow6kgbm8gcmFzdHJlYWRvIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwNTQKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTA1NQogbXNnaWQgInRlc3QgaWYgdGhlIGZpbGVzeXN0ZW0gc3VwcG9ydHMgdW50cmFja2VkIGNhY2hlIgogbXNnc3RyICJwcm9iYXIgc2kgZWwgZmlsZXN5c3RlbSBzb3BvcnRhIGNhY2jDqSBubyByYXN0cmVhZG8iCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTA1NgorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDU3CiBtc2dpZCAiZW5hYmxlIHVudHJhY2tlZCBjYWNoZSB3aXRob3V0IHRlc3RpbmcgdGhlIGZpbGVzeXN0ZW0iCiBtc2dzdHIgImhhYmlsaXRhciBjYWNow6kgbm8gcmFzdHJlYWRvIHNpbiBwcm9iYXIgZWwgZmlsZXN5c3RlbSIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDU4CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwNTkKIG1zZ2lkICJ3cml0ZSBvdXQgdGhlIGluZGV4IGV2ZW4gaWYgaXMgbm90IGZsYWdnZWQgYXMgY2hhbmdlZCIKIG1zZ3N0ciAiZXNjcmliaXIgZWwgw61uZGljZSBpbmNsdXNvIHNpIG5vIGVzdMOhIG1hcmNhZG8gY29tbyBjYW1iaWFkbyIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDYwCisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwNjEKIG1zZ2lkICJlbmFibGUgb3IgZGlzYWJsZSBmaWxlIHN5c3RlbSBtb25pdG9yIgogbXNnc3RyICJhY3RpdmFyIG8gZGVzYWN0aXZhciBtb25pdG9yIGRlIHNpc3RlbWEgZGUgYXJjaGl2b3MiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTA2MgorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDYzCiBtc2dpZCAibWFyayBmaWxlcyBhcyBmc21vbml0b3IgdmFsaWQiCiBtc2dzdHIgIm1hcmNhciBhcmNoaXZvcyBjb21vIHbDoWxpZG9zIHBhcmEgZnNtb25pdG9yIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwNjUKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTA2NgogbXNnaWQgImNsZWFyIGZzbW9uaXRvciB2YWxpZCBiaXQiCiBtc2dzdHIgImxpbXBpYSBlbCBiaXQgZGUgdmFsaWRhY2nDs24gZnNtb25pdG9yIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjExNjgKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTE2OQogbXNnaWQgIiIKICJjb3JlLnNwbGl0SW5kZXggaXMgc2V0IHRvIGZhbHNlOyByZW1vdmUgb3IgY2hhbmdlIGl0LCBpZiB5b3UgcmVhbGx5IHdhbnQgdG8gIgogImVuYWJsZSBzcGxpdCBpbmRleCIKQEAgLTIwNDY5LDcgKzIwNTU1LDcgQEAKICJjb3JlLnNwbGl0SW5kZXggZXN0w6EgY29uZmlndXJhZG8gZW4gZmFsc2U7IHJlbXXDqXZlbG8gbyBjw6FtYmlhbG8sIHNpICIKICJyZWFsbWVudGUgcXVpZXJlcyBoYWJpbGl0YXIgZWwgw61uZGljZSBwYXJ0aWRvIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjExNzcKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTE3OAogbXNnaWQgIiIKICJjb3JlLnNwbGl0SW5kZXggaXMgc2V0IHRvIHRydWU7IHJlbW92ZSBvciBjaGFuZ2UgaXQsIGlmIHlvdSByZWFsbHkgd2FudCB0byAiCiAiZGlzYWJsZSBzcGxpdCBpbmRleCIKQEAgLTIwNDc3LDcgKzIwNTYzLDcgQEAKICJjb3JlLnNwbGl0SW5kZXggZXN0w6EgY29uZmlndXJhZG8gZW4gdHJ1ZTsgcmVtdcOpdmVsbyBvIGPDoW1iaWFsbywgc2kgcmVhbG1lbnRlICIKICJxdWllcmVzIGRlc2hhYmlsaXRhciBlbCDDrW5kaWNlIHBhcnRpZG8iCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTE4OAorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMTkwCiBtc2dpZCAiIgogImNvcmUudW50cmFja2VkQ2FjaGUgaXMgc2V0IHRvIHRydWU7IHJlbW92ZSBvciBjaGFuZ2UgaXQsIGlmIHlvdSByZWFsbHkgd2FudCAiCiAidG8gZGlzYWJsZSB0aGUgdW50cmFja2VkIGNhY2hlIgpAQCAtMjA0ODUsMTEgKzIwNTcxLDExIEBACiAiY29yZS51bnRyYWNrZWRDYWNoZSBlc3TDoSBjb25maWd1cmFkbyBlbiB0cnVlOyByZW11w6l2ZWxvIG8gY8OhbWJpYWxvLCBzaSAiCiAicmVhbG1lbnRlIHF1aWVyZXMgZGVzaGFiaWxpdGFyIGVsIGNoYWNow6kgbm8gcmFzdHJlYWRvIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjExOTIKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTE5NAogbXNnaWQgIlVudHJhY2tlZCBjYWNoZSBkaXNhYmxlZCIKIG1zZ3N0ciAiQ2FjaMOpIG5vIHJhc3RyZWFkbyBkZXNoYWJpbGl0YWRvIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEyMDAKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTIwMgogbXNnaWQgIiIKICJjb3JlLnVudHJhY2tlZENhY2hlIGlzIHNldCB0byBmYWxzZTsgcmVtb3ZlIG9yIGNoYW5nZSBpdCwgaWYgeW91IHJlYWxseSB3YW50ICIKICJ0byBlbmFibGUgdGhlIHVudHJhY2tlZCBjYWNoZSIKQEAgLTIwNDk3LDI5ICsyMDU4MywyOSBAQAogImNvcmUudW50cmFja2VkQ2FjaGUgZXN0w6EgY29uZmlndXJhZG8gZW4gZmFsc2U7IHJlbXXDqXZlbG8gbyBjw6FtYmlhbG8sIHNpICIKICJyZWFsbWVudGUgcXVpZXJlcyBoYWJpbGl0YXIgZWwgY2FjaMOpIG5vIHJhc3RyZWFkbyIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMjA0CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEyMDYKICMsIGMtZm9ybWF0CiBtc2dpZCAiVW50cmFja2VkIGNhY2hlIGVuYWJsZWQgZm9yICclcyciCiBtc2dzdHIgIkNhY2jDqSBubyByYXN0cmVhZG8gaGFiaWxpdGFkbyBwYXJhICclcyciCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTIxMgorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMjE0CiBtc2dpZCAiY29yZS5mc21vbml0b3IgaXMgdW5zZXQ7IHNldCBpdCBpZiB5b3UgcmVhbGx5IHdhbnQgdG8gZW5hYmxlIGZzbW9uaXRvciIKIG1zZ3N0ciAiIgogImNvcmUuZnNtb25pdG9yIG5vIGVzdMOhIGNvbmZpZ3VyYWRvOyBhY3TDrXZhbG8gc2kgcmVhbG1lbnRlIHF1aWVyZXMgaGFiaWxpdGFyICIKICJmc21vbml0b3IiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTIxNgorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMjE4CiBtc2dpZCAiZnNtb25pdG9yIGVuYWJsZWQiCiBtc2dzdHIgImZzbW9uaXRvciBhY3RpdmFkbyIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMjE5CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEyMjEKIG1zZ2lkICIiCiAiY29yZS5mc21vbml0b3IgaXMgc2V0OyByZW1vdmUgaXQgaWYgeW91IHJlYWxseSB3YW50IHRvIGRpc2FibGUgZnNtb25pdG9yIgogbXNnc3RyICIiCiAiY29yZS5mc21vbml0b3IgZXN0w6EgY29uZmlndXJhZG87IHJlbXXDqXZlbG8gc2kgcmVhbG1lbnRlIHF1aWVyZXMgZGVzaGFiaWxpdGFyICIKICJlbCBmc21vbml0b3IiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTIyMworIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMjI1CiBtc2dpZCAiZnNtb25pdG9yIGRpc2FibGVkIgogbXNnc3RyICJmc21vbml0b3IgZGVzYWN0aXZhZG8iCiAKQEAgLTIwNjEzLDU1ICsyMDY5OSw1NSBAQAogbXNnaWQgInByaW50IHRhZyBjb250ZW50cyIKIG1zZ3N0ciAiaW1wcmltaXIgY29udGVuaWRvIGRlbCB0YWciCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzoxOAorIzogYnVpbHRpbi93b3JrdHJlZS5jOjE3CiBtc2dpZCAiZ2l0IHdvcmt0cmVlIGFkZCBbPG9wdGlvbnM+XSA8cGF0aD4gWzxjb21taXQtaXNoPl0iCiBtc2dzdHIgImdpdCB3b3JrdHJlZSBhZGQgWzxvcGNpb25lcz5dIDxydXRhPiBbPGNvbW1pdC1pc2g+XSIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjE5CisjOiBidWlsdGluL3dvcmt0cmVlLmM6MTgKIG1zZ2lkICJnaXQgd29ya3RyZWUgbGlzdCBbPG9wdGlvbnM+XSIKIG1zZ3N0ciAiZ2l0IHdvcmt0cmVlIGxpc3QgWzxvcGNpb25lcz5dIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6MjAKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzoxOQogbXNnaWQgImdpdCB3b3JrdHJlZSBsb2NrIFs8b3B0aW9ucz5dIDxwYXRoPiIKIG1zZ3N0ciAiZ2l0IHdvcmt0cmVlIGxvY2sgWzxvcGNpb25lcz5dIDxydXRhPiIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjIxCisjOiBidWlsdGluL3dvcmt0cmVlLmM6MjAKIG1zZ2lkICJnaXQgd29ya3RyZWUgbW92ZSA8d29ya3RyZWU+IDxuZXctcGF0aD4iCiBtc2dzdHIgImdpdCB3b3JrdHJlZSBtb3ZlIDx3b3JrdHJlZT4gPG51ZXZhLXJ1dGE+IgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6MjIKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzoyMQogbXNnaWQgImdpdCB3b3JrdHJlZSBwcnVuZSBbPG9wdGlvbnM+XSIKIG1zZ3N0ciAiZ2l0IHdvcmt0cmVlIHBydW5lIFs8b3BjaW9uZXM+XSIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjIzCisjOiBidWlsdGluL3dvcmt0cmVlLmM6MjIKIG1zZ2lkICJnaXQgd29ya3RyZWUgcmVtb3ZlIFs8b3B0aW9ucz5dIDx3b3JrdHJlZT4iCiBtc2dzdHIgImdpdCB3b3JrdHJlZSByZW1vdmUgWzxvcGNpb25lcz5dIDx3b3JrdHJlZT4iCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzoyNAorIzogYnVpbHRpbi93b3JrdHJlZS5jOjIzCiBtc2dpZCAiZ2l0IHdvcmt0cmVlIHVubG9jayA8cGF0aD4iCiBtc2dzdHIgImdpdCB3b3JrdHJlZSB1bmxvY2sgPHJ1dGE+IgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NjEgYnVpbHRpbi93b3JrdHJlZS5jOjg5OQorIzogYnVpbHRpbi93b3JrdHJlZS5jOjYwIGJ1aWx0aW4vd29ya3RyZWUuYzo4OTgKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIGRlbGV0ZSAnJXMnIgogbXNnc3RyICJmYWxsw7MgYWwgYm9ycmFyICclcyciCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4MAorIzogYnVpbHRpbi93b3JrdHJlZS5jOjc5CiAjLCBjLWZvcm1hdAogbXNnaWQgIlJlbW92aW5nIHdvcmt0cmVlcy8lczogbm90IGEgdmFsaWQgZGlyZWN0b3J5IgogbXNnc3RyICJSZW1vdmllbmRvIGVsIHdvcmt0cmVlcy8lczogbm8gZXMgdW4gZGlyZWN0b3JpbyB2w6FsaWRvIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6ODYKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4NQogIywgYy1mb3JtYXQKIG1zZ2lkICJSZW1vdmluZyB3b3JrdHJlZXMvJXM6IGdpdGRpciBmaWxlIGRvZXMgbm90IGV4aXN0IgogbXNnc3RyICJSZW1vdmllbmRvIHdvcmt0cmVlcy8lczogYXJjaGl2byBnaXRkaXIgbm8gZXhpc3RlIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6OTEgYnVpbHRpbi93b3JrdHJlZS5jOjEwMAorIzogYnVpbHRpbi93b3JrdHJlZS5jOjkwIGJ1aWx0aW4vd29ya3RyZWUuYzo5OQogIywgYy1mb3JtYXQKIG1zZ2lkICJSZW1vdmluZyB3b3JrdHJlZXMvJXM6IHVuYWJsZSB0byByZWFkIGdpdGRpciBmaWxlICglcykiCiBtc2dzdHIgIlJlbW92aWVuZG8gd29ya3RyZWVzLyVzOiBubyBlcyBwb3NpYmxlIGxlZXIgZWwgYXJjaGl2byBnaXRkaXIgKCVzKSIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjExMAorIzogYnVpbHRpbi93b3JrdHJlZS5jOjEwOQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiUmVtb3Zpbmcgd29ya3RyZWVzLyVzOiBzaG9ydCByZWFkIChleHBlY3RlZCAlPFBSSXVNQVg+IGJ5dGVzLCByZWFkICIKQEAgLTIwNjcwLDM2ICsyMDc1NiwzNiBAQAogIlJlbW92aWVuZG8gw6FyYm9sZXMgZGUgdHJhYmFqby8lczogbGVjdHVyYSBjb3J0YSAoc2UgZXNwZXJhbiAlPFBSSXVNQVg+ICIKICJieXRlcywgJTxQUkl1TUFYPiBsZcOtZG9zKSIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjExOAorIzogYnVpbHRpbi93b3JrdHJlZS5jOjExNwogIywgYy1mb3JtYXQKIG1zZ2lkICJSZW1vdmluZyB3b3JrdHJlZXMvJXM6IGludmFsaWQgZ2l0ZGlyIGZpbGUiCiBtc2dzdHIgIlJlbW92aWVuZG8gd29ya3RyZWVzLyVzOiBhcmNoaXZvIGdpdGRpciBpbnbDoWxpZG8iCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzoxMjcKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzoxMjYKICMsIGMtZm9ybWF0CiBtc2dpZCAiUmVtb3Zpbmcgd29ya3RyZWVzLyVzOiBnaXRkaXIgZmlsZSBwb2ludHMgdG8gbm9uLWV4aXN0ZW50IGxvY2F0aW9uIgogbXNnc3RyICIiCiAiUmVtb3ZpZW5kbyB3b3JrdHJlZXMvJXM6IGFyY2hpdm8gZ2l0ZGlyIGFwdW50YSBhIHVuYSB1YmljYWNpw7NuIG5vIGV4aXN0ZW50ZSIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjE2NgorIzogYnVpbHRpbi93b3JrdHJlZS5jOjE2NQogbXNnaWQgInJlcG9ydCBwcnVuZWQgd29ya2luZyB0cmVlcyIKIG1zZ3N0ciAicmVwb3J0YSDDoXJib2xlcyBkZSB0cmFiYWpvIHJlY29ydGFkb3MiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzoxNjgKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzoxNjcKIG1zZ2lkICJleHBpcmUgd29ya2luZyB0cmVlcyBvbGRlciB0aGFuIDx0aW1lPiIKIG1zZ3N0ciAiZXhwaXJhciDDoXJib2xlcyBkZSB0cmFiYWpvIG3DoXMgdmllam9zIGEgPHRpZW1wbz4iCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzoyMzUKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzoyMzQKICMsIGMtZm9ybWF0CiBtc2dpZCAiJyVzJyBhbHJlYWR5IGV4aXN0cyIKIG1zZ3N0ciAiJyVzJyB5YSBleGlzdGUiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzoyNTIKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzoyNTEKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHJlLWFkZCB3b3JrdHJlZSAnJXMnIgogbXNnc3RyICJubyBlcyBwb3NpYmxlIHZvbHZlciBhIGFncmVnYXIgZWwgw6FyYm9sICclcyciCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzoyNTcKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzoyNTYKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIiclcycgaXMgYSBtaXNzaW5nIGJ1dCBsb2NrZWQgd29ya3RyZWU7XG4iCkBAIC0yMDcwOSw3ICsyMDc5NSw3IEBACiAidXNhICdhZGQgLWYgLWYnIHBhcmEgc29icmVlc2NyaWJpciwgbyAndW5sb2NrJyB5ICdwcnVuZScgbyAncmVtb3ZlJyBwYXJhICIKICJsaW1waWFyIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6MjU5CisjOiBidWlsdGluL3dvcmt0cmVlLmM6MjU4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICInJXMnIGlzIGEgbWlzc2luZyBidXQgYWxyZWFkeSByZWdpc3RlcmVkIHdvcmt0cmVlO1xuIgpAQCAtMjA3MTgsMTI0ICsyMDgwNCwxMjQgQEAKICInJXMnIGVzIHVuIMOhcmJvbCBkZSB0cmFiYWpvIGZhbHRhbnRlIHBlcm8geWEgcmVnaXN0cmFkbztcbiIKICJ1c2EgJ2FkZCAtZicgcGFyYSBzb2JyZWVzY3JpYmlyLCBvICdwcnVuZScgbyAncmVtb3ZlJyBwYXJhIGxpbXBpYXIiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzozMDkKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzozMDgKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGNyZWF0ZSBkaXJlY3Rvcnkgb2YgJyVzJyIKIG1zZ3N0ciAibm8gc2UgcHVkbyBjcmVhciBkaXJlY3RvcmlvIGRlICclcyciCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo0NDAgYnVpbHRpbi93b3JrdHJlZS5jOjQ0NgorIzogYnVpbHRpbi93b3JrdHJlZS5jOjQzOSBidWlsdGluL3dvcmt0cmVlLmM6NDQ1CiAjLCBjLWZvcm1hdAogbXNnaWQgIlByZXBhcmluZyB3b3JrdHJlZSAobmV3IGJyYW5jaCAnJXMnKSIKIG1zZ3N0ciAiUHJlcGFyYW5kbyDDoXJib2wgZGUgdHJhYmFqbyAobnVldmEgcmFtYSAnJXMnKSIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjQ0MgorIzogYnVpbHRpbi93b3JrdHJlZS5jOjQ0MQogIywgYy1mb3JtYXQKIG1zZ2lkICJQcmVwYXJpbmcgd29ya3RyZWUgKHJlc2V0dGluZyBicmFuY2ggJyVzJzsgd2FzIGF0ICVzKSIKIG1zZ3N0ciAiUHJlcGFyYW5kbyDDoXJib2wgZGUgdHJhYmFqbyAocmVpbmljaWFuZG8gcmFtYSAnJXMnOyBlc3RhYmEgZW4gJXMpIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NDUxCisjOiBidWlsdGluL3dvcmt0cmVlLmM6NDUwCiAjLCBjLWZvcm1hdAogbXNnaWQgIlByZXBhcmluZyB3b3JrdHJlZSAoY2hlY2tpbmcgb3V0ICclcycpIgogbXNnc3RyICJQcmVwYXJhbmRvIMOhcmJvbCBkZSB0cmFiYWpvIChoYWNpZW5kbyBjaGVja291dCBhICclcycpIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NDU3CisjOiBidWlsdGluL3dvcmt0cmVlLmM6NDU2CiAjLCBjLWZvcm1hdAogbXNnaWQgIlByZXBhcmluZyB3b3JrdHJlZSAoZGV0YWNoZWQgSEVBRCAlcykiCiBtc2dzdHIgIlByZXBhcmFuZG8gw6FyYm9sIGRlIHRyYWJham8gKEhFQUQgZGVzYWNvcGxhZG8gJXMpIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NDk4CisjOiBidWlsdGluL3dvcmt0cmVlLmM6NDk3CiBtc2dpZCAiY2hlY2tvdXQgPGJyYW5jaD4gZXZlbiBpZiBhbHJlYWR5IGNoZWNrZWQgb3V0IGluIG90aGVyIHdvcmt0cmVlIgogbXNnc3RyICIiCiAiaGFjZXIgY2hlY2tvdXQgYSA8cmFtYT4gaW5jbHVzbyBzaSB5YSBoYSBoZWNobyBjaGVja291dCBlbiBvdHJvIMOhcmJvbCBkZSAiCiAidHJhYmFqbyIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjUwMQorIzogYnVpbHRpbi93b3JrdHJlZS5jOjUwMAogbXNnaWQgImNyZWF0ZSBhIG5ldyBicmFuY2giCiBtc2dzdHIgImNyZWFyIHVuYSBudWV2YSByYW1hIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NTAzCisjOiBidWlsdGluL3dvcmt0cmVlLmM6NTAyCiBtc2dpZCAiY3JlYXRlIG9yIHJlc2V0IGEgYnJhbmNoIgogbXNnc3RyICJjcmVhciBvIHJlc3RhYmxlY2VyIHVuYSByYW1hIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NTA1CisjOiBidWlsdGluL3dvcmt0cmVlLmM6NTA0CiBtc2dpZCAicG9wdWxhdGUgdGhlIG5ldyB3b3JraW5nIHRyZWUiCiBtc2dzdHIgInBvcHVsYXIgZWwgbnVldm8gw6FyYm9sIGRlIHRyYWJham8iCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo1MDYKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo1MDUKIG1zZ2lkICJrZWVwIHRoZSBuZXcgd29ya2luZyB0cmVlIGxvY2tlZCIKIG1zZ3N0ciAibWFudGVuZXIgZWwgbnVldm8gw6FyYm9sIGRlIHRyYWJham8gYmxvcXVlYWRvIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NTA5CisjOiBidWlsdGluL3dvcmt0cmVlLmM6NTA4CiBtc2dpZCAic2V0IHVwIHRyYWNraW5nIG1vZGUgKHNlZSBnaXQtYnJhbmNoKDEpKSIKIG1zZ3N0ciAiY29uZmlndXJhbmRvIG1vZG8gdHJhY2tpbmcgKG1pcmFyIGdpdC1icmFuY2goMSkpIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NTEyCisjOiBidWlsdGluL3dvcmt0cmVlLmM6NTExCiBtc2dpZCAidHJ5IHRvIG1hdGNoIHRoZSBuZXcgYnJhbmNoIG5hbWUgd2l0aCBhIHJlbW90ZS10cmFja2luZyBicmFuY2giCiBtc2dzdHIgIiIKICJpbnRlbnRhciBlbXBhcmVqYXIgZWwgbnVldm8gbm9tYnJlIGRlIHJhbWEgY29uIHVuYSByYW1hIGRlIHJhc3RyZW8gcmVtb3RvIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NTIwCisjOiBidWlsdGluL3dvcmt0cmVlLmM6NTE5CiBtc2dpZCAiLWIsIC1CLCBhbmQgLS1kZXRhY2ggYXJlIG11dHVhbGx5IGV4Y2x1c2l2ZSIKIG1zZ3N0ciAiLWIsIC1CLCB5IC0tZGV0YWNoIHNvbiBtdXR1YW1lbnRlIGV4Y2x1c2l2YXMiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo1ODEKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo1ODAKIG1zZ2lkICItLVtuby1ddHJhY2sgY2FuIG9ubHkgYmUgdXNlZCBpZiBhIG5ldyBicmFuY2ggaXMgY3JlYXRlZCIKIG1zZ3N0ciAiLS1bbm8tXXRyYWNrIHNvbG8gcHVlZGUgc2VyIHVzYWRvIHNpIHVuYSBudWV2YSByYW1hIGVzIGNyZWFkYSIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjY4MQorIzogYnVpbHRpbi93b3JrdHJlZS5jOjY4MAogbXNnaWQgInJlYXNvbiBmb3IgbG9ja2luZyIKIG1zZ3N0ciAicmF6w7NuIHBhcmEgYmxvcXVlYXIiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo2OTMgYnVpbHRpbi93b3JrdHJlZS5jOjcyNiBidWlsdGluL3dvcmt0cmVlLmM6ODAwCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6OTI3CisjOiBidWlsdGluL3dvcmt0cmVlLmM6NjkyIGJ1aWx0aW4vd29ya3RyZWUuYzo3MjUgYnVpbHRpbi93b3JrdHJlZS5jOjc5OQorIzogYnVpbHRpbi93b3JrdHJlZS5jOjkyNgogIywgYy1mb3JtYXQKIG1zZ2lkICInJXMnIGlzIG5vdCBhIHdvcmtpbmcgdHJlZSIKIG1zZ3N0ciAiJyVzJyBubyBlcyB1biDDoXJib2wgZGUgdHJhYmFqbyIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjY5NSBidWlsdGluL3dvcmt0cmVlLmM6NzI4CisjOiBidWlsdGluL3dvcmt0cmVlLmM6Njk0IGJ1aWx0aW4vd29ya3RyZWUuYzo3MjcKIG1zZ2lkICJUaGUgbWFpbiB3b3JraW5nIHRyZWUgY2Fubm90IGJlIGxvY2tlZCBvciB1bmxvY2tlZCIKIG1zZ3N0ciAiRWwgw6FyYm9sIGRlIHRyYWJham8gcHJpbmNpcGFsIG5vIHB1ZWRlIHNlciBibG9xdWVhZG8gbmkgZGVzYmxvcXVlYWRvIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NzAwCisjOiBidWlsdGluL3dvcmt0cmVlLmM6Njk5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiclcycgaXMgYWxyZWFkeSBsb2NrZWQsIHJlYXNvbjogJXMiCiBtc2dzdHIgIiclcycgeWEgZXN0w6EgYmxvcXVlYWRvOyByYXrDs246ICVzIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NzAyCisjOiBidWlsdGluL3dvcmt0cmVlLmM6NzAxCiAjLCBjLWZvcm1hdAogbXNnaWQgIiclcycgaXMgYWxyZWFkeSBsb2NrZWQiCiBtc2dzdHIgIiclcycgeWEgZXN0w6EgYmxvcXVlYWRvIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NzMwCisjOiBidWlsdGluL3dvcmt0cmVlLmM6NzI5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiclcycgaXMgbm90IGxvY2tlZCIKIG1zZ3N0ciAiJyVzJyBubyBlc3TDoSBibG9xdWVhZG8iCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo3NzEKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo3NzAKIG1zZ2lkICJ3b3JraW5nIHRyZWVzIGNvbnRhaW5pbmcgc3VibW9kdWxlcyBjYW5ub3QgYmUgbW92ZWQgb3IgcmVtb3ZlZCIKIG1zZ3N0ciAiIgogIsOhcmJvbGVzIGRlIHRyYWJham8gY29udGVuaWVuZG8gc3VibcOzZHVsb3Mgbm8gcHVlZGUgc2VyIG1vdmlkb3MgbyBlbGltaW5hZG8iCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo3NzkKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo3NzgKIG1zZ2lkICJmb3JjZSBtb3ZlIGV2ZW4gaWYgd29ya3RyZWUgaXMgZGlydHkgb3IgbG9ja2VkIgogbXNnc3RyICJmb3J6YXIgbW92ZSBpbmNsdXNvIHNpIGVsIMOhcmJvbCBkZSB0cmFiYWpvIGVzdMOhIHN1Y2lvIG8gYmxvcXVlYWRvIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6ODAyIGJ1aWx0aW4vd29ya3RyZWUuYzo5MjkKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4MDEgYnVpbHRpbi93b3JrdHJlZS5jOjkyOAogIywgYy1mb3JtYXQKIG1zZ2lkICInJXMnIGlzIGEgbWFpbiB3b3JraW5nIHRyZWUiCiBtc2dzdHIgIiclcycgZXMgdW4gw6FyYm9sIGRlIHRyYWJham8gcHJpbmNpcGFsIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6ODA3CisjOiBidWlsdGluL3dvcmt0cmVlLmM6ODA2CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBmaWd1cmUgb3V0IGRlc3RpbmF0aW9uIG5hbWUgZnJvbSAnJXMnIgogbXNnc3RyICJubyBzZSBwdWRvIGRlc2N1YnJpciBlbCBub21icmUgZGUgZGVzdGlubyBkZSAnJXMnIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6ODEzCisjOiBidWlsdGluL3dvcmt0cmVlLmM6ODEyCiAjLCBjLWZvcm1hdAogbXNnaWQgInRhcmdldCAnJXMnIGFscmVhZHkgZXhpc3RzIgogbXNnc3RyICJlbCBvYmpldGl2byAnJXMnIHlhIGV4aXN0ZSIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjgyMQorIzogYnVpbHRpbi93b3JrdHJlZS5jOjgyMAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiY2Fubm90IG1vdmUgYSBsb2NrZWQgd29ya2luZyB0cmVlLCBsb2NrIHJlYXNvbjogJXNcbiIKQEAgLTIwODQ0LDcgKzIwOTMwLDcgQEAKICJubyBzZSBwdWVkZSBtb3ZlciB1biDDoXJib2wgZGUgdHJhYmFqbyBibG9xdWVhZG8sIG1vdGl2byBkZWwgYmxvcXVlbzogJXNcbiIKICJ1c2UgJ21vdmUgLWYgLWYnIHBhcmEgc29icmVlc2NyaWJpciBvIGRlc2Jsb3F1ZWFyIHByaW1lcm8iCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4MjMKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4MjIKIG1zZ2lkICIiCiAiY2Fubm90IG1vdmUgYSBsb2NrZWQgd29ya2luZyB0cmVlO1xuIgogInVzZSAnbW92ZSAtZiAtZicgdG8gb3ZlcnJpZGUgb3IgdW5sb2NrIGZpcnN0IgpAQCAtMjA4NTIsMzYgKzIwOTM4LDM3IEBACiAibm8gc2UgcHVlZGUgbW92ZXIgdW4gw6FyYm9sIGRlIHRyYWJham8gYmxvcXVlYWRvO1xuIgogInVzZSAnbW92ZSAtZiAtZicgcGFyYSBzb2JyZWVzY3JpYmlyIG8gZGVzYmxvcXVlYXIgcHJpbWVybyIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjgyNgorIzogYnVpbHRpbi93b3JrdHJlZS5jOjgyNQogIywgYy1mb3JtYXQKIG1zZ2lkICJ2YWxpZGF0aW9uIGZhaWxlZCwgY2Fubm90IG1vdmUgd29ya2luZyB0cmVlOiAlcyIKIG1zZ3N0ciAiZmFsbMOzIHZhbGlkYWNpw7NuLCBubyBzZSBwdWVkZSBtb3ZlciBlbCDDoXJib2wgZGUgdHJhYmFqbzogJXMiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4MzEKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4MzAKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIG1vdmUgJyVzJyB0byAnJXMnIgogbXNnc3RyICJmYWxsw7MgYWwgbW92ZXIgJyVzJyBhICclcyciCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4NzkKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4NzgKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIHJ1biAnZ2l0IHN0YXR1cycgb24gJyVzJyIKIG1zZ3N0ciAiZmFsbMOzIGFsIGVqZWN1dGFyICdnaXQgc3RhdHVzJyBlbiAnJXMnIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6ODgzCisjOiBidWlsdGluL3dvcmt0cmVlLmM6ODgyCiAjLCBjLWZvcm1hdAotbXNnaWQgIiclcycgaXMgZGlydHksIHVzZSAtLWZvcmNlIHRvIGRlbGV0ZSBpdCIKLW1zZ3N0ciAiJyVzJyBlc3TDoSBzdWNpbywgdXNlIC0tZm9yY2UgcGFyYSBib3JyYXJsbyIKK21zZ2lkICInJXMnIGNvbnRhaW5zIG1vZGlmaWVkIG9yIHVudHJhY2tlZCBmaWxlcywgdXNlIC0tZm9yY2UgdG8gZGVsZXRlIGl0IgorbXNnc3RyICIiCisiJyVzJyBjb250aWVuZSBhcmNoaXZvcyBubyByYXN0cmVhZG9zIG8gbW9kaWZpY2Fkb3MsIHVzZSAtLWZvcmNlIHBhcmEgYm9ycmFybG8iCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4ODgKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4ODcKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIHJ1biAnZ2l0IHN0YXR1cycgb24gJyVzJywgY29kZSAlZCIKIG1zZ3N0ciAibm8gc2UgcHVkbyBlamVjdXRhciAnZ2l0IHN0YXR1cycgZW4gJyVzJywgY8OzZGlnbyAlZCIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjkxMQorIzogYnVpbHRpbi93b3JrdHJlZS5jOjkxMAogbXNnaWQgImZvcmNlIHJlbW92YWwgZXZlbiBpZiB3b3JrdHJlZSBpcyBkaXJ0eSBvciBsb2NrZWQiCiBtc2dzdHIgImZvcnphciByZW1vY2nDs24gaW5jbHVzbyBzaSBlbCDDoXJib2wgZGUgdHJhYmFqbyBlc3TDoSBzdWNpbyBvIGJsb3F1ZWFkbyIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjkzNAorIzogYnVpbHRpbi93b3JrdHJlZS5jOjkzMwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiY2Fubm90IHJlbW92ZSBhIGxvY2tlZCB3b3JraW5nIHRyZWUsIGxvY2sgcmVhc29uOiAlc1xuIgpAQCAtMjA4OTAsNyArMjA5NzcsNyBAQAogIm5vIHNlIHB1ZWRlbiBlbGltaW5hciDDoXJib2wgZGUgdHJhYmFqbyBibG9xdWVhZG8sIHJhesOzbiBkZWwgYmxvcXVlbzogJXNcbiIKICJ1c2UgJ3JlbW92ZSAtZiAtZicgcGFyYSBzb2JyZWVzY3JpYmlyIG8gZGVzYmxvcXVlYXIgcHJpbWVybyIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjkzNgorIzogYnVpbHRpbi93b3JrdHJlZS5jOjkzNQogbXNnaWQgIiIKICJjYW5ub3QgcmVtb3ZlIGEgbG9ja2VkIHdvcmtpbmcgdHJlZTtcbiIKICJ1c2UgJ3JlbW92ZSAtZiAtZicgdG8gb3ZlcnJpZGUgb3IgdW5sb2NrIGZpcnN0IgpAQCAtMjA4OTgsNyArMjA5ODUsNyBAQAogIm5vIHNlIHB1ZWRlbiBlbGltaW5hciDDoXJib2wgZGUgdHJhYmFqbyBibG9xdWVhZG87XG4iCiAidXNlICdyZW1vdmUgLWYgLWYnIHBhcmEgc29icmVlc2NyaWJpciBvIGRlc2Jsb3F1ZWFyIHByaW1lcm8iCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo5MzkKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo5MzgKICMsIGMtZm9ybWF0CiBtc2dpZCAidmFsaWRhdGlvbiBmYWlsZWQsIGNhbm5vdCByZW1vdmUgd29ya2luZyB0cmVlOiAlcyIKIG1zZ3N0ciAiZmFsbMOzIHZhbGlkYWNpw7NuLCBubyBzZSBwdWVkZSBlbGltaW5hciDDoXJib2wgZGUgdHJhYmFqbzogJXMiCkBAIC0yMDkxOSw2ICsyMTAwNiwxNiBAQAogbXNnaWQgIm9ubHkgdXNlZnVsIGZvciBkZWJ1Z2dpbmciCiBtc2dzdHIgInPDs2xvIMO6dGlsIHBhcmEgZGVwdXJhciIKIAorIzogZmFzdC1pbXBvcnQuYzozMTE4CisjLCBjLWZvcm1hdAorbXNnaWQgIkV4cGVjdGVkICdtYXJrJyBjb21tYW5kLCBnb3QgJXMiCittc2dzdHIgInNlIGVzcGVyYWJhIGNvbWFuZG8gJ21hcmsnLCBzZSBvYnR1dm8gJXMiCisKKyM6IGZhc3QtaW1wb3J0LmM6MzEyMworIywgYy1mb3JtYXQKK21zZ2lkICJFeHBlY3RlZCAndG8nIGNvbW1hbmQsIGdvdCAlcyIKK21zZ3N0ciAic2UgZXNwZXJhYmEgY29tYW5kbyAndG8nLCBzZSBvYnR1dm8gJXMiCisKICM6IGNyZWRlbnRpYWwtY2FjaGUtLWRhZW1vbi5jOjIyMwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCkBAIC0yMTAzMSwzOSArMjExMjgsMzkgQEAKICJhbGlhcyAnJXMnIGNhbWJpYSBsYXMgdmFyaWFibGVzIGRlIGVudG9ybm8uXG4iCiAiUHVlZGVzIHVzYXIgJyFnaXQnIGVuIGVsIGFsaWFzIHBhcmEgaGFjZXIgZXN0byIKIAotIzogZ2l0LmM6Mzc3CisjOiBnaXQuYzozNzYKICMsIGMtZm9ybWF0CiBtc2dpZCAiZW1wdHkgYWxpYXMgZm9yICVzIgogbXNnc3RyICJhbGlhcyB2YWPDrW8gcGFyYSAlcyIKIAotIzogZ2l0LmM6MzgwCisjOiBnaXQuYzozNzkKICMsIGMtZm9ybWF0CiBtc2dpZCAicmVjdXJzaXZlIGFsaWFzOiAlcyIKIG1zZ3N0ciAiYWxpYXMgcmVjdXJzaXZvOiAlcyIKIAotIzogZ2l0LmM6NDYwCisjOiBnaXQuYzo0NTkKIG1zZ2lkICJ3cml0ZSBmYWlsdXJlIG9uIHN0YW5kYXJkIG91dHB1dCIKIG1zZ3N0ciAiZXJyb3IgZGUgZXNjcml0dXJhIGVuIHN0YW5kYXJkIG91dHB1dCIKIAotIzogZ2l0LmM6NDYyCisjOiBnaXQuYzo0NjEKIG1zZ2lkICJ1bmtub3duIHdyaXRlIGZhaWx1cmUgb24gc3RhbmRhcmQgb3V0cHV0IgogbXNnc3RyICJlcnJvciBkZXNjb25vY2lkbyBkZSBlc2NyaXR1cmEgZW4gc3RhbmRhcmQgb3V0cHV0IgogCi0jOiBnaXQuYzo0NjQKKyM6IGdpdC5jOjQ2MwogbXNnaWQgImNsb3NlIGZhaWxlZCBvbiBzdGFuZGFyZCBvdXRwdXQiCiBtc2dzdHIgImNpZXJyZSBmYWxsw7MgZW4gc3RhbmRhcmQgb3V0cHV0IgogCi0jOiBnaXQuYzo3OTMKKyM6IGdpdC5jOjc5MgogIywgYy1mb3JtYXQKIG1zZ2lkICJhbGlhcyBsb29wIGRldGVjdGVkOiBleHBhbnNpb24gb2YgJyVzJyBkb2VzIG5vdCB0ZXJtaW5hdGU6JXMiCiBtc2dzdHIgImJ1Y2xlIGRlIGFsaWFzIGRldGVjdGFkbzogZXhwYW5zacOzbiBkZSAnJXMnIG5vIHRlcm1pbmE6ICVzIgogCi0jOiBnaXQuYzo4NDMKKyM6IGdpdC5jOjg0MgogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgaGFuZGxlICVzIGFzIGEgYnVpbHRpbiIKIG1zZ3N0ciAibm8gc2UgcHVlZGUgbWFuZWphciAlcyBjb21vIHVuIGJ1aWx0aW4iCiAKLSM6IGdpdC5jOjg1NgorIzogZ2l0LmM6ODU1CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJ1c2FnZTogJXNcbiIKQEAgLTIxMDc0LDEyICsyMTE3MSwxMiBAQAogIlxuIgogIlxuIgogCi0jOiBnaXQuYzo4NzYKKyM6IGdpdC5jOjg3NQogIywgYy1mb3JtYXQKIG1zZ2lkICJleHBhbnNpb24gb2YgYWxpYXMgJyVzJyBmYWlsZWQ7ICclcycgaXMgbm90IGEgZ2l0IGNvbW1hbmRcbiIKIG1zZ3N0ciAiZXhwYW5zacOzbiBkZWwgYWxpYXMgJyVzJyBmYWxsw7M7ICclcycgbm8gZXMgdW4gY29tYW5kbyBkZSBnaXRcbiIKIAotIzogZ2l0LmM6ODg4CisjOiBnaXQuYzo4ODcKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIHJ1biBjb21tYW5kICclcyc6ICVzXG4iCiBtc2dzdHIgImZhbGzDsyBhbCBlamVjdXRhciBjb21hbmRvICclcyc6ICVzXG4iCkBAIC0yMTA5NywzMiArMjExOTQsMzIgQEAKIG1zZ2lkICJQdWJsaWMga2V5IHBpbm5pbmcgbm90IHN1cHBvcnRlZCB3aXRoIGNVUkwgPCA3LjQ0LjAiCiBtc2dzdHIgIkZpamFjacOzbiBkZSBsbGF2ZSBww7pibGljYSBubyBlcyBzb3BvcnRhZGEgY29uIGNVUkwgPCA3LjQ0LjAiCiAKLSM6IGh0dHAuYzo4NzYKKyM6IGh0dHAuYzo4NzgKIG1zZ2lkICJDVVJMU1NMT1BUX05PX1JFVk9LRSBub3Qgc3VwcG9ydGVkIHdpdGggY1VSTCA8IDcuNDQuMCIKIG1zZ3N0ciAiQ1VSTFNTTE9QVF9OT19SRVZPS0Ugbm8gc29wb3J0YWRvIGNvbiBjVVJMIDwgNy40NC4wIgogCi0jOiBodHRwLmM6OTQ5CisjOiBodHRwLmM6OTUxCiBtc2dpZCAiUHJvdG9jb2wgcmVzdHJpY3Rpb25zIG5vdCBzdXBwb3J0ZWQgd2l0aCBjVVJMIDwgNy4xOS40IgogbXNnc3RyICJSZXN0cmljY2nDs24gZGUgcHJvdG9jb2xvIG5vIHNvcG9ydGFkYSBjb24gY1VSTCA8IDcuMTkuNCIKIAotIzogaHR0cC5jOjEwODUKKyM6IGh0dHAuYzoxMDg4CiAjLCBjLWZvcm1hdAogbXNnaWQgIlVuc3VwcG9ydGVkIFNTTCBiYWNrZW5kICclcycuIFN1cHBvcnRlZCBTU0wgYmFja2VuZHM6IgogbXNnc3RyICJCYWNrZW5kIFNTTCBubyBzb3BvcnRhZG8gJyVzJy4gQmFja2VuZHMgU1NMIHNvcG9ydGFkb3M6IgogCi0jOiBodHRwLmM6MTA5MgorIzogaHR0cC5jOjEwOTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ291bGQgbm90IHNldCBTU0wgYmFja2VuZCB0byAnJXMnOiBjVVJMIHdhcyBidWlsdCB3aXRob3V0IFNTTCBiYWNrZW5kcyIKIG1zZ3N0ciAiIgogIk5vIHNlIHB1ZG8gY29uZmlndXJhciBiYWNrZW5kIFNTTCBhICclcyc6IGNVUkwgZnVlIGNvbnN0cnVpZG8gc2luIGJhY2tlbmRzICIKICJTU0wiCiAKLSM6IGh0dHAuYzoxMDk2CisjOiBodHRwLmM6MTA5OQogIywgYy1mb3JtYXQKIG1zZ2lkICJDb3VsZCBub3Qgc2V0IFNTTCBiYWNrZW5kIHRvICclcyc6IGFscmVhZHkgc2V0IgogbXNnc3RyICJObyBzZSBwdWRvIGNvbmZpZ3VyYXIgYmFja2VuZCBTU0wgcGFyYSAnJXMnOiB5YSBjb25maWd1cmFkbyIKIAotIzogaHR0cC5jOjE5NjUKKyM6IGh0dHAuYzoxOTY4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJ1bmFibGUgdG8gdXBkYXRlIHVybCBiYXNlIGZyb20gcmVkaXJlY3Rpb246XG4iCkBAIC0yMTEzMywxMzEgKzIxMjMwLDEzMSBAQAogIiAgcHJlZ3VudGFiYSBwb3I6ICVzXG4iCiAiICAgcmVkaXJlY2Npb25hbWllbnRvOiAlcyIKIAotIzogcmVtb3RlLWN1cmwuYzoxNTcKKyM6IHJlbW90ZS1jdXJsLmM6MTY2CiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgcXVvdGluZyBpbiBwdXNoLW9wdGlvbiB2YWx1ZTogJyVzJyIKIG1zZ3N0ciAicXVvdGluZyBpbnbDoWxpZG8gZW4gdmFsb3IgZGUgcHVzaC1vcHRpb246ICclcyciCiAKLSM6IHJlbW90ZS1jdXJsLmM6MjU0CisjOiByZW1vdGUtY3VybC5jOjI2MwogIywgYy1mb3JtYXQKIG1zZ2lkICIlc2luZm8vcmVmcyBub3QgdmFsaWQ6IGlzIHRoaXMgYSBnaXQgcmVwb3NpdG9yeT8iCiBtc2dzdHIgIiVzaW5mby9yZWZzIG5vIGVzIHbDoWxpZG86IMK/ZXMgZXN0ZSB1biByZXBvc2l0b3JpbyBnaXQ/IgogCi0jOiByZW1vdGUtY3VybC5jOjM1NQorIzogcmVtb3RlLWN1cmwuYzozNjQKIG1zZ2lkICJpbnZhbGlkIHNlcnZlciByZXNwb25zZTsgZXhwZWN0ZWQgc2VydmljZSwgZ290IGZsdXNoIHBhY2tldCIKIG1zZ3N0ciAiIgogInJlc3B1ZXN0YSBkZSBzZXJ2aWRvciBpbnbDoWxpZGE7IHNlIGVzcGVyYWJhIHNlcnZpY2lvLCBzZSBvYnR1dm8gdW4gZmx1c2ggIgogInBhY2tldCIKIAotIzogcmVtb3RlLWN1cmwuYzozODYKKyM6IHJlbW90ZS1jdXJsLmM6Mzk1CiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgc2VydmVyIHJlc3BvbnNlOyBnb3QgJyVzJyIKIG1zZ3N0ciAicmVzcHVlc3RhIGRlIHNlcnZpZG9yIGludsOhbGlkYTsgc2Ugb2J0dXZvICclcyciCiAKLSM6IHJlbW90ZS1jdXJsLmM6NDQ2CisjOiByZW1vdGUtY3VybC5jOjQ1NQogIywgYy1mb3JtYXQKIG1zZ2lkICJyZXBvc2l0b3J5ICclcycgbm90IGZvdW5kIgogbXNnc3RyICJyZXBvc2l0b3JpbyAnJXMnIG5vIGVuY29udHJhZG8iCiAKLSM6IHJlbW90ZS1jdXJsLmM6NDUwCisjOiByZW1vdGUtY3VybC5jOjQ1OQogIywgYy1mb3JtYXQKIG1zZ2lkICJBdXRoZW50aWNhdGlvbiBmYWlsZWQgZm9yICclcyciCiBtc2dzdHIgIkF1dGVudGljYWNpw7NuIGZhbGzDsyBwYXJhICclcyciCiAKLSM6IHJlbW90ZS1jdXJsLmM6NDU0CisjOiByZW1vdGUtY3VybC5jOjQ2MwogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gYWNjZXNzICclcyc6ICVzIgogbXNnc3RyICJubyBlcyBwb3NpYmxlIGFjY2VkZXIgJyVzJzolcyIKIAotIzogcmVtb3RlLWN1cmwuYzo0NjAKKyM6IHJlbW90ZS1jdXJsLmM6NDY5CiAjLCBjLWZvcm1hdAogbXNnaWQgInJlZGlyZWN0aW5nIHRvICVzIgogbXNnc3RyICJyZWRpcmlnaWVuZG8gYSAlcyIKIAotIzogcmVtb3RlLWN1cmwuYzo1ODQKKyM6IHJlbW90ZS1jdXJsLmM6NTkzCiBtc2dpZCAic2hvdWxkbid0IGhhdmUgRU9GIHdoZW4gbm90IGdlbnRsZSBvbiBFT0YiCiBtc2dzdHIgIm5vIGRlYmVyw61hIHRlbmVyIEVPRiBjdWFuZG8gbm8gZXMgZ2VudGlsIGVuIEVPRiIKIAotIzogcmVtb3RlLWN1cmwuYzo2NjQKKyM6IHJlbW90ZS1jdXJsLmM6NjczCiBtc2dpZCAidW5hYmxlIHRvIHJld2luZCBycGMgcG9zdCBkYXRhIC0gdHJ5IGluY3JlYXNpbmcgaHR0cC5wb3N0QnVmZmVyIgogbXNnc3RyICIiCiAibm8gZXMgcG9zaWJsZSByZWJvYmluYXIgcnBjIHBvc3QgZGF0YSAtIGludGVudGEgaW5jcmVtZW50YW5kbyBodHRwLnBvc3RCdWZmZXIiCiAKLSM6IHJlbW90ZS1jdXJsLmM6NzI0CisjOiByZW1vdGUtY3VybC5jOjczMwogIywgYy1mb3JtYXQKIG1zZ2lkICJSUEMgZmFpbGVkOyAlcyIKIG1zZ3N0ciAiUlBDIGZhbGzDszsgJXMiCiAKLSM6IHJlbW90ZS1jdXJsLmM6NzY0CisjOiByZW1vdGUtY3VybC5jOjc3MwogbXNnaWQgImNhbm5vdCBoYW5kbGUgcHVzaGVzIHRoaXMgYmlnIgogbXNnc3RyICJubyBzZSBwdWVkZSBtYW5lamFyIHB1c2hlcyB0YW4gZ3JhbmRlcyIKIAotIzogcmVtb3RlLWN1cmwuYzo4NzkKKyM6IHJlbW90ZS1jdXJsLmM6ODg4CiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCBkZWZsYXRlIHJlcXVlc3Q7IHpsaWIgZGVmbGF0ZSBlcnJvciAlZCIKIG1zZ3N0ciAibm8gc2UgcHVlZGUgZGVzaW5mbGFyIGVsIHJlcXVlc3Q7IHpsaWIgZGVmbGF0ZSBlcnJvciAlZCIKIAotIzogcmVtb3RlLWN1cmwuYzo4ODMKKyM6IHJlbW90ZS1jdXJsLmM6ODkyCiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCBkZWZsYXRlIHJlcXVlc3Q7IHpsaWIgZW5kIGVycm9yICVkIgogbXNnc3RyICJubyBzZSBwdWVkZSBkZXNpbmZsYXIgZWwgcmVxdWVzdDsgemxpYiBlbmQgZXJyb3IgJWQiCiAKLSM6IHJlbW90ZS1jdXJsLmM6MTAxNAorIzogcmVtb3RlLWN1cmwuYzoxMDIzCiBtc2dpZCAiZHVtYiBodHRwIHRyYW5zcG9ydCBkb2VzIG5vdCBzdXBwb3J0IHNoYWxsb3cgY2FwYWJpbGl0aWVzIgogbXNnc3RyICJkdW1wIGh0dHAgdHJhbnNwb3J0IG5vIHNvcG9ydGEgY2FwYWNpZGFkZXMgc3VwZXJmaWNpYWxlcyIKIAotIzogcmVtb3RlLWN1cmwuYzoxMDI4CisjOiByZW1vdGUtY3VybC5jOjEwMzcKIG1zZ2lkICJmZXRjaCBmYWlsZWQuIgogbXNnc3RyICJmZXRjaCBmYWxsw7MuIgogCi0jOiByZW1vdGUtY3VybC5jOjEwNzYKKyM6IHJlbW90ZS1jdXJsLmM6MTA4NQogbXNnaWQgImNhbm5vdCBmZXRjaCBieSBzaGExIG92ZXIgc21hcnQgaHR0cCIKIG1zZ3N0ciAibm8gc2UgcHVlZGUgaGFjZXIgZmV0Y2ggcG9yIHNoYTEgc29icmUgc21hcnQgaHR0cCIKIAotIzogcmVtb3RlLWN1cmwuYzoxMTIwIHJlbW90ZS1jdXJsLmM6MTEyNgorIzogcmVtb3RlLWN1cmwuYzoxMTI5IHJlbW90ZS1jdXJsLmM6MTEzNQogIywgYy1mb3JtYXQKIG1zZ2lkICJwcm90b2NvbCBlcnJvcjogZXhwZWN0ZWQgc2hhL3JlZiwgZ290ICclcyciCiBtc2dzdHIgImVycm9yIGRlIHByb3RvY29sbzogc2UgZXNwZXJhYmEgc2hhL3JlZiwgc2Ugb2J0dXZvICclcyciCiAKLSM6IHJlbW90ZS1jdXJsLmM6MTEzOCByZW1vdGUtY3VybC5jOjEyNTIKKyM6IHJlbW90ZS1jdXJsLmM6MTE0NyByZW1vdGUtY3VybC5jOjEyNjEKICMsIGMtZm9ybWF0CiBtc2dpZCAiaHR0cCB0cmFuc3BvcnQgZG9lcyBub3Qgc3VwcG9ydCAlcyIKIG1zZ3N0ciAiaHR0cCB0cmFuc3BvcnQgbm8gc29wb3J0YSAlcyIKIAotIzogcmVtb3RlLWN1cmwuYzoxMTc0CisjOiByZW1vdGUtY3VybC5jOjExODMKIG1zZ2lkICJnaXQtaHR0cC1wdXNoIGZhaWxlZCIKIG1zZ3N0ciAiZ2l0LWh0dHAtcHVzaCBmYWxsw7MiCiAKLSM6IHJlbW90ZS1jdXJsLmM6MTM2MAorIzogcmVtb3RlLWN1cmwuYzoxMzY3CiBtc2dpZCAicmVtb3RlLWN1cmw6IHVzYWdlOiBnaXQgcmVtb3RlLWN1cmwgPHJlbW90ZT4gWzx1cmw+XSIKIG1zZ3N0ciAicmVtb3RlLWN1cmw6IHVzbzogZ2l0IHJlbW90ZS1jdXJsIDxyZW1vdGU+IFs8dXJsPl0iCiAKLSM6IHJlbW90ZS1jdXJsLmM6MTM5MgorIzogcmVtb3RlLWN1cmwuYzoxMzk5CiBtc2dpZCAicmVtb3RlLWN1cmw6IGVycm9yIHJlYWRpbmcgY29tbWFuZCBzdHJlYW0gZnJvbSBnaXQiCiBtc2dzdHIgInJlbW90ZS1jdXJsOiBlcnJvciBsZXllbmRvIGNvbW1hbmQgc3RyZWFtIGRlIGdpdCIKIAotIzogcmVtb3RlLWN1cmwuYzoxMzk5CisjOiByZW1vdGUtY3VybC5jOjE0MDYKIG1zZ2lkICJyZW1vdGUtY3VybDogZmV0Y2ggYXR0ZW1wdGVkIHdpdGhvdXQgYSBsb2NhbCByZXBvIgogbXNnc3RyICJyZW1vdGUtY3VybDogZmV0Y2ggaW50ZW50YWRvIHNpbiB1biByZXBvc2l0b3JpbyBsb2NhbCIKIAotIzogcmVtb3RlLWN1cmwuYzoxNDM5CisjOiByZW1vdGUtY3VybC5jOjE0NDYKICMsIGMtZm9ybWF0CiBtc2dpZCAicmVtb3RlLWN1cmw6IHVua25vd24gY29tbWFuZCAnJXMnIGZyb20gZ2l0IgogbXNnc3RyICJyZW1vdGUtY3VybDogY29tYW5kbyAnJXMnIGRlc2Nvbm9jaWRvIGRlIGdpdCIKIAotIzogbGlzdC1vYmplY3RzLWZpbHRlci1vcHRpb25zLmg6NjEKKyM6IGxpc3Qtb2JqZWN0cy1maWx0ZXItb3B0aW9ucy5oOjg1CiBtc2dpZCAiYXJncyIKIG1zZ3N0ciAiYXJncyIKIAotIzogbGlzdC1vYmplY3RzLWZpbHRlci1vcHRpb25zLmg6NjIKKyM6IGxpc3Qtb2JqZWN0cy1maWx0ZXItb3B0aW9ucy5oOjg2CiBtc2dpZCAib2JqZWN0IGZpbHRlcmluZyIKIG1zZ3N0ciAiZmlsdHJhZG8gZGUgb2JqZXRvIgogCi0jOiBwYXJzZS1vcHRpb25zLmg6MTcwCisjOiBwYXJzZS1vcHRpb25zLmg6MTc5CiBtc2dpZCAiZXhwaXJ5LWRhdGUiCiBtc2dzdHIgImZlY2hhIGRlIGV4cGlyYWNpw7NuIgogCi0jOiBwYXJzZS1vcHRpb25zLmg6MTg0CisjOiBwYXJzZS1vcHRpb25zLmg6MTkzCiBtc2dpZCAibm8tb3AgKGJhY2t3YXJkIGNvbXBhdGliaWxpdHkpIgogbXNnc3RyICJuby1vcCAoY29tcGF0aWJpbGlkYWQgY29uIHZlcnNpb25lcyBhbnRlcmlvcmVzKSIKIApAQCAtMjI4OTQsNyArMjI5OTEsNyBAQAogIi0tLVxuIgogIlBhcmEgZWxpbWluYXIgJyVzJyBsw61uZWFzLCBoYWdhIGRlIGVsbGFzIGzDrW5lYXMgICcgJyAgKGNvbnRleHRvKS5cbiIKICJQYXJhIGVsaW1pbmFyICclcycgbMOtbmVhcywgYsOzcnJlbGFzLlxuIgotIkxpbmVhcyBjb21lbnphbmRvIGNvbiAgJXMgc2Vyw6FuIHJlbW92aWRhcy5cbiIKKyJMaW5lYXMgY29tZW56YW5kbyBjb24gICVzIHNlcsOhbiBlbGltaW5hZGFzLlxuIgogCiAjLiBUUkFOU0xBVE9SUzogJ2l0JyByZWZlcnMgdG8gdGhlIHBhdGNoIG1lbnRpb25lZCBpbiB0aGUgcHJldmlvdXMgbWVzc2FnZXMuCiAjOiBnaXQtYWRkLS1pbnRlcmFjdGl2ZS5wZXJsOjExMjQKQEAgLTIyOTA0LDcgKzIzMDAxLDcgQEAKICJhYm9ydGVkIGFuZCB0aGUgaHVuayBpcyBsZWZ0IHVuY2hhbmdlZC5cbiIKIG1zZ3N0ciAiIgogIlNpIGVzdG8gbm8gYXBsaWNhIGRlIG1hbmVyYSBsaW1waWEsIHNlIHRlIGRhIGxhIG9wb3J0dW5pZGFkIGRlIFxuIgotImVkaXRhciBudWV2YW1lbnRlLiBTaSB0b2RhcyBsYXMgbMOtbmVhcyBkZWwgaHVuayBzb24gcmVtb3ZpZGFzLCBlbnRvbmNlcyBcbiIKKyJlZGl0YXIgbnVldmFtZW50ZS4gU2kgdG9kYXMgbGFzIGzDrW5lYXMgZGVsIGh1bmsgc29uIGVsaW1pbmFkYXMsIGVudG9uY2VzIFxuIgogImxhIGVkaWNpw7NuIGVzIGFib3J0YWRhIHkgZWwgaHVuayBxdWVkYSBzaW4gY2FtYmlvcy5cbiIKIAogIzogZ2l0LWFkZC0taW50ZXJhY3RpdmUucGVybDoxMTM4CkBAIC0yMjkyMiw3ICsyMzAxOSw4IEBACiBtc2dpZCAiIgogIllvdXIgZWRpdGVkIGh1bmsgZG9lcyBub3QgYXBwbHkuIEVkaXQgYWdhaW4gKHNheWluZyBcIm5vXCIgZGlzY2FyZHMhKSBbeS9uXT8gIgogbXNnc3RyICIiCi0iVHUgaHVuayBlZGl0YWRvIG5vIGFwbGljYS4gRWRpdGFyIG51ZXZhbWVudGUgKGRlY2lyIFwibm9cIiBkZXNjYXJ0YSEpIFt5L25dPyAiCisiVHUgaHVuayBlZGl0YWRvIG5vIGFwbGljYS4gwr9FZGl0YXIgbnVldmFtZW50ZSAowqFkZWNpciBcIm5vXCIgZGVzY2FydGEhKSBbeS8iCisibl0/ICIKIAogIzogZ2l0LWFkZC0taW50ZXJhY3RpdmUucGVybDoxMjQ2CiBtc2dpZCAiIgpAQCAtMjMwNjIsMTEgKzIzMTYwLDExIEBACiAKICM6IGdpdC1hZGQtLWludGVyYWN0aXZlLnBlcmw6MTM0MAogbXNnaWQgIlRoZSBzZWxlY3RlZCBodW5rcyBkbyBub3QgYXBwbHkgdG8gdGhlIGluZGV4IVxuIgotbXNnc3RyICJMb3MgaHVua3Mgc2VsZWNjaW9uYWRvcyBubyBhcGxpY2FuIGFsIMOtbmRpY2UhXG4iCittc2dzdHIgIsKhTG9zIGh1bmtzIHNlbGVjY2lvbmFkb3Mgbm8gYXBsaWNhbiBhbCDDrW5kaWNlIVxuIgogCiAjOiBnaXQtYWRkLS1pbnRlcmFjdGl2ZS5wZXJsOjEzNDEKIG1zZ2lkICJBcHBseSB0aGVtIHRvIHRoZSB3b3JrdHJlZSBhbnl3YXk/ICIKLW1zZ3N0ciAiQXBsaWNhcmxvcyBhbCDDoXJib2wgZGUgdHJhYmFqbyBkZSB0b2RhcyBtYW5lcmFzPyAiCittc2dzdHIgIsK/QXBsaWNhcmxvcyBhbCDDoXJib2wgZGUgdHJhYmFqbyBkZSB0b2RhcyBtYW5lcmFzPyAiCiAKICM6IGdpdC1hZGQtLWludGVyYWN0aXZlLnBlcmw6MTM0NAogbXNnaWQgIk5vdGhpbmcgd2FzIGFwcGxpZWQuXG4iCkBAIC0yMzA5MiwxMjQgKzIzMTkwLDEyNiBAQAogIzogZ2l0LWFkZC0taW50ZXJhY3RpdmUucGVybDoxNDI2CiAjLCBwZXJsLWZvcm1hdAogbXNnaWQgIlN0YWdlIG1vZGUgY2hhbmdlIFt5LG4scSxhLGQlcyw/XT8gIgotbXNnc3RyICJDYW1iaW8gZGUgbW9kbyBkZSBzdGFnZSBbeSxuLHEsYSxkJXMsP10/ICIKK21zZ3N0ciAiwr9DYW1iaW8gZGUgbW9kbyBkZSBzdGFnZSBbeSxuLHEsYSxkJXMsP10/ICIKIAogIzogZ2l0LWFkZC0taW50ZXJhY3RpdmUucGVybDoxNDI3CiAjLCBwZXJsLWZvcm1hdAogbXNnaWQgIlN0YWdlIGRlbGV0aW9uIFt5LG4scSxhLGQlcyw/XT8gIgotbXNnc3RyICJBcGxpY2FyIHN0YWdlIGFsIGJvcnJhZG8gW3ksbixxLGEsZCVzLD9dPyAiCittc2dzdHIgIsK/QXBsaWNhciBzdGFnZSBhbCBib3JyYWRvIFt5LG4scSxhLGQlcyw/XT8gIgogCiAjOiBnaXQtYWRkLS1pbnRlcmFjdGl2ZS5wZXJsOjE0MjgKICMsIHBlcmwtZm9ybWF0CiBtc2dpZCAiU3RhZ2UgdGhpcyBodW5rIFt5LG4scSxhLGQlcyw/XT8gIgotbXNnc3RyICJBcGxpY2FyIHN0YWdlIGEgZXN0ZSBodW5rIFt5LG4scSxhLGQlcyw/XT8gIgorbXNnc3RyICLCv0FwbGljYXIgc3RhZ2UgYSBlc3RlIGh1bmsgW3ksbixxLGEsZCVzLD9dPyAiCiAKICM6IGdpdC1hZGQtLWludGVyYWN0aXZlLnBlcmw6MTQzMQogIywgcGVybC1mb3JtYXQKIG1zZ2lkICJTdGFzaCBtb2RlIGNoYW5nZSBbeSxuLHEsYSxkJXMsP10/ICIKLW1zZ3N0ciAiQXBsaWNhciBzdGFzaCBhbCBjYW1iaW8gZGUgbW9kbyBbeSxuLHEsYSxkJXMsP10/ICIKK21zZ3N0ciAiwr9BcGxpY2FyIHN0YXNoIGFsIGNhbWJpbyBkZSBtb2RvIFt5LG4scSxhLGQlcyw/XT8gIgogCiAjOiBnaXQtYWRkLS1pbnRlcmFjdGl2ZS5wZXJsOjE0MzIKICMsIHBlcmwtZm9ybWF0CiBtc2dpZCAiU3Rhc2ggZGVsZXRpb24gW3ksbixxLGEsZCVzLD9dPyAiCi1tc2dzdHIgIkFwbGljYXIgc3Rhc2ggYWwgYm9ycmFkbyBbeSxuLHEsYSxkJXMsP10/ICIKK21zZ3N0ciAiwr9BcGxpY2FyIHN0YXNoIGFsIGJvcnJhZG8gW3ksbixxLGEsZCVzLD9dPyAiCiAKICM6IGdpdC1hZGQtLWludGVyYWN0aXZlLnBlcmw6MTQzMwogIywgcGVybC1mb3JtYXQKIG1zZ2lkICJTdGFzaCB0aGlzIGh1bmsgW3ksbixxLGEsZCVzLD9dPyAiCi1tc2dzdHIgIkFwbGljYXIgc3Rhc2ggYSBlc3RlIGh1bmsgW3ksbixxLGEsZCVzLD9dPyAiCittc2dzdHIgIsK/QXBsaWNhciBzdGFzaCBhIGVzdGUgaHVuayBbeSxuLHEsYSxkJXMsP10/ICIKIAogIzogZ2l0LWFkZC0taW50ZXJhY3RpdmUucGVybDoxNDM2CiAjLCBwZXJsLWZvcm1hdAogbXNnaWQgIlVuc3RhZ2UgbW9kZSBjaGFuZ2UgW3ksbixxLGEsZCVzLD9dPyAiCi1tc2dzdHIgIlNhY2FyIGNhbWJpbyBkZSBtb2RvIGRlbCBzdGFnZSBbeSxuLHEsYSxkJXMsP10/ICIKK21zZ3N0ciAiwr9TYWNhciBjYW1iaW8gZGUgbW9kbyBkZWwgc3RhZ2UgW3ksbixxLGEsZCVzLD9dPyAiCiAKICM6IGdpdC1hZGQtLWludGVyYWN0aXZlLnBlcmw6MTQzNwogIywgcGVybC1mb3JtYXQKIG1zZ2lkICJVbnN0YWdlIGRlbGV0aW9uIFt5LG4scSxhLGQlcyw/XT8gIgotbXNnc3RyICJTYWNhciBib3JyYWRvIGRlbCBzdGFnZSBbeSxuLHEsYSxkJXMsP10/ICIKK21zZ3N0ciAiwr9TYWNhciBib3JyYWRvIGRlbCBzdGFnZSBbeSxuLHEsYSxkJXMsP10/ICIKIAogIzogZ2l0LWFkZC0taW50ZXJhY3RpdmUucGVybDoxNDM4CiAjLCBwZXJsLWZvcm1hdAogbXNnaWQgIlVuc3RhZ2UgdGhpcyBodW5rIFt5LG4scSxhLGQlcyw/XT8gIgotbXNnc3RyICJTYWNhciBlc3RlIGh1bmsgZGVsIHN0YWdlIFt5LG4scSxhLGQlcyw/XT8gIgorbXNnc3RyICLCv1NhY2FyIGVzdGUgaHVuayBkZWwgc3RhZ2UgW3ksbixxLGEsZCVzLD9dPyAiCiAKICM6IGdpdC1hZGQtLWludGVyYWN0aXZlLnBlcmw6MTQ0MQogIywgcGVybC1mb3JtYXQKIG1zZ2lkICJBcHBseSBtb2RlIGNoYW5nZSB0byBpbmRleCBbeSxuLHEsYSxkJXMsP10/ICIKLW1zZ3N0ciAiQXBsaWNhciBjYW1iaW8gZGUgbW9kbyBhbCDDrW5kaWNlIFt5LG4scSxhLGQlcyw/XT8gIgorbXNnc3RyICLCv0FwbGljYXIgY2FtYmlvIGRlIG1vZG8gYWwgw61uZGljZSBbeSxuLHEsYSxkJXMsP10/ICIKIAogIzogZ2l0LWFkZC0taW50ZXJhY3RpdmUucGVybDoxNDQyCiAjLCBwZXJsLWZvcm1hdAogbXNnaWQgIkFwcGx5IGRlbGV0aW9uIHRvIGluZGV4IFt5LG4scSxhLGQlcyw/XT8gIgotbXNnc3RyICJBcGxpY2FyIGJvcnJhZG8gYWwgw61uZGljZSBbeSxuLHEsYSxkJXMsP10/ICIKK21zZ3N0ciAiwr9BcGxpY2FyIGJvcnJhZG8gYWwgw61uZGljZSBbeSxuLHEsYSxkJXMsP10/ICIKIAogIzogZ2l0LWFkZC0taW50ZXJhY3RpdmUucGVybDoxNDQzCiAjLCBwZXJsLWZvcm1hdAogbXNnaWQgIkFwcGx5IHRoaXMgaHVuayB0byBpbmRleCBbeSxuLHEsYSxkJXMsP10/ICIKLW1zZ3N0ciAiQXBsaWNhciBlc3RlIGh1bmsgYWwgw61uZGljZSBbeSxuLHEsYSxkJXMsP10/ICIKK21zZ3N0ciAiwr9BcGxpY2FyIGVzdGUgaHVuayBhbCDDrW5kaWNlIFt5LG4scSxhLGQlcyw/XT8gIgogCiAjOiBnaXQtYWRkLS1pbnRlcmFjdGl2ZS5wZXJsOjE0NDYgZ2l0LWFkZC0taW50ZXJhY3RpdmUucGVybDoxNDYxCiAjLCBwZXJsLWZvcm1hdAogbXNnaWQgIkRpc2NhcmQgbW9kZSBjaGFuZ2UgZnJvbSB3b3JrdHJlZSBbeSxuLHEsYSxkJXMsP10/ICIKLW1zZ3N0ciAiRGVzY2FydGFyIGNhbWJpbyBkZSBtb2RvIGRlbCDDoXJib2wgZGUgdHJhYmFqbyBbeSxuLHEsYSxkJXMsP10/ICIKK21zZ3N0ciAiwr9EZXNjYXJ0YXIgY2FtYmlvIGRlIG1vZG8gZGVsIMOhcmJvbCBkZSB0cmFiYWpvIFt5LG4scSxhLGQlcyw/XT8gIgogCiAjOiBnaXQtYWRkLS1pbnRlcmFjdGl2ZS5wZXJsOjE0NDcgZ2l0LWFkZC0taW50ZXJhY3RpdmUucGVybDoxNDYyCiAjLCBwZXJsLWZvcm1hdAogbXNnaWQgIkRpc2NhcmQgZGVsZXRpb24gZnJvbSB3b3JrdHJlZSBbeSxuLHEsYSxkJXMsP10/ICIKLW1zZ3N0ciAiRGVzY2FydGFyIGJvcnJhZG8gZGVsIMOhcmJvbCBkZSB0cmFiYWpvIFt5LG4scSxhLGQlcyw/XT8gIgorbXNnc3RyICLCv0Rlc2NhcnRhciBib3JyYWRvIGRlbCDDoXJib2wgZGUgdHJhYmFqbyBbeSxuLHEsYSxkJXMsP10/ICIKIAogIzogZ2l0LWFkZC0taW50ZXJhY3RpdmUucGVybDoxNDQ4IGdpdC1hZGQtLWludGVyYWN0aXZlLnBlcmw6MTQ2MwogIywgcGVybC1mb3JtYXQKIG1zZ2lkICJEaXNjYXJkIHRoaXMgaHVuayBmcm9tIHdvcmt0cmVlIFt5LG4scSxhLGQlcyw/XT8gIgotbXNnc3RyICJEZXNjYXJ0YXIgZXN0ZSBodW5rIGRlbCDDoXJib2wgZGUgdHJhYmFqbyBbeSxuLHEsYSxkJXMsP10/ICIKK21zZ3N0ciAiwr9EZXNjYXJ0YXIgZXN0ZSBodW5rIGRlbCDDoXJib2wgZGUgdHJhYmFqbyBbeSxuLHEsYSxkJXMsP10/ICIKIAogIzogZ2l0LWFkZC0taW50ZXJhY3RpdmUucGVybDoxNDUxCiAjLCBwZXJsLWZvcm1hdAogbXNnaWQgIkRpc2NhcmQgbW9kZSBjaGFuZ2UgZnJvbSBpbmRleCBhbmQgd29ya3RyZWUgW3ksbixxLGEsZCVzLD9dPyAiCiBtc2dzdHIgIiIKLSJEZXNjYXJ0YXIgY2FtYmlvIGRlIG1vZG8gZGVsIMOtbmRpY2UgeSBlbCDDoXJib2wgZGUgdHJhYmFqbyBbeSxuLHEsYSxkJXMsP10/ICIKKyLCv0Rlc2NhcnRhciBjYW1iaW8gZGUgbW9kbyBkZWwgw61uZGljZSB5IGVsIMOhcmJvbCBkZSB0cmFiYWpvIFt5LG4scSxhLGQlcyw/XT8gIgogCiAjOiBnaXQtYWRkLS1pbnRlcmFjdGl2ZS5wZXJsOjE0NTIKICMsIHBlcmwtZm9ybWF0CiBtc2dpZCAiRGlzY2FyZCBkZWxldGlvbiBmcm9tIGluZGV4IGFuZCB3b3JrdHJlZSBbeSxuLHEsYSxkJXMsP10/ICIKLW1zZ3N0ciAiRGVzY2FydGFyIGJvcnJhZG8gZGVsIMOtbmRpY2UgeSBlbCDDoXJib2wgZGUgdHJhYmFqbyBbeSxuLHEsYSxkJXMsP10/ICIKK21zZ3N0ciAiwr9EZXNjYXJ0YXIgYm9ycmFkbyBkZWwgw61uZGljZSB5IGVsIMOhcmJvbCBkZSB0cmFiYWpvIFt5LG4scSxhLGQlcyw/XT8gIgogCiAjOiBnaXQtYWRkLS1pbnRlcmFjdGl2ZS5wZXJsOjE0NTMKICMsIHBlcmwtZm9ybWF0CiBtc2dpZCAiRGlzY2FyZCB0aGlzIGh1bmsgZnJvbSBpbmRleCBhbmQgd29ya3RyZWUgW3ksbixxLGEsZCVzLD9dPyAiCi1tc2dzdHIgIkRlc2NhcnRhciBlc3RlIGh1bmsgZGVsIMOtbmRpY2UgeSBlbCDDoXJib2wgZGUgdHJhYmFqbyBbeSxuLHEsYSxkJXMsP10/ICIKK21zZ3N0ciAiIgorIsK/RGVzY2FydGFyIGVzdGUgaHVuayBkZWwgw61uZGljZSB5IGVsIMOhcmJvbCBkZSB0cmFiYWpvIFt5LG4scSxhLGQlcyw/XT8gIgogCiAjOiBnaXQtYWRkLS1pbnRlcmFjdGl2ZS5wZXJsOjE0NTYKICMsIHBlcmwtZm9ybWF0CiBtc2dpZCAiQXBwbHkgbW9kZSBjaGFuZ2UgdG8gaW5kZXggYW5kIHdvcmt0cmVlIFt5LG4scSxhLGQlcyw/XT8gIgogbXNnc3RyICIiCi0iQXBsaWNhciBjYW1iaW8gZGUgbW9kbyBwYXJhIGVsIMOtbmRpY2UgeSBlbCDDoXJib2wgZGUgdHJhYmFqbyBbeSxuLHEsYSxkJXMsP10/ICIKKyLCv0FwbGljYXIgY2FtYmlvIGRlIG1vZG8gcGFyYSBlbCDDrW5kaWNlIHkgZWwgw6FyYm9sIGRlIHRyYWJham8gW3ksbixxLGEsZCIKKyIlcyw/XT8gIgogCiAjOiBnaXQtYWRkLS1pbnRlcmFjdGl2ZS5wZXJsOjE0NTcKICMsIHBlcmwtZm9ybWF0CiBtc2dpZCAiQXBwbHkgZGVsZXRpb24gdG8gaW5kZXggYW5kIHdvcmt0cmVlIFt5LG4scSxhLGQlcyw/XT8gIgotbXNnc3RyICJBcGxpY2FyIGJvcnJhZG8gYWwgw61uZGljZSB5IGFsIMOhcmJvbCBkZSB0cmFiYWpvIFt5LG4scSxhLGQlcyw/XT8gIgorbXNnc3RyICLCv0FwbGljYXIgYm9ycmFkbyBhbCDDrW5kaWNlIHkgYWwgw6FyYm9sIGRlIHRyYWJham8gW3ksbixxLGEsZCVzLD9dPyAiCiAKICM6IGdpdC1hZGQtLWludGVyYWN0aXZlLnBlcmw6MTQ1OAogIywgcGVybC1mb3JtYXQKIG1zZ2lkICJBcHBseSB0aGlzIGh1bmsgdG8gaW5kZXggYW5kIHdvcmt0cmVlIFt5LG4scSxhLGQlcyw/XT8gIgotbXNnc3RyICJBcGxpY2FyIGVzdGUgaHVuayBhbCDDrW5kaWNlIHkgw6FyYm9sIGRlIHRyYWJham8gW3ksbixxLGEsZCwvJXMsP10/ICIKK21zZ3N0ciAiwr9BcGxpY2FyIGVzdGUgaHVuayBhbCDDrW5kaWNlIHkgw6FyYm9sIGRlIHRyYWJham8gW3ksbixxLGEsZCwvJXMsP10/ICIKIAogIzogZ2l0LWFkZC0taW50ZXJhY3RpdmUucGVybDoxNDY2CiAjLCBwZXJsLWZvcm1hdAogbXNnaWQgIkFwcGx5IG1vZGUgY2hhbmdlIHRvIHdvcmt0cmVlIFt5LG4scSxhLGQlcyw/XT8gIgotbXNnc3RyICJBcGxpY2FyIGNhbWJpbyBkZSBtb2RvIHBhcmEgZWwgw6FyYm9sIGRlIHRyYWJham8gW3ksbixxLGEsZCVzLD9dPyAiCittc2dzdHIgIsK/QXBsaWNhciBjYW1iaW8gZGUgbW9kbyBwYXJhIGVsIMOhcmJvbCBkZSB0cmFiYWpvIFt5LG4scSxhLGQlcyw/XT8gIgogCiAjOiBnaXQtYWRkLS1pbnRlcmFjdGl2ZS5wZXJsOjE0NjcKICMsIHBlcmwtZm9ybWF0CiBtc2dpZCAiQXBwbHkgZGVsZXRpb24gdG8gd29ya3RyZWUgW3ksbixxLGEsZCVzLD9dPyAiCi1tc2dzdHIgIkFwbGljYXIgYm9ycmFkbyBhbCDDoXJib2wgZGUgdHJhYmFqbyBbeSxuLHEsYSxkJXMsP10/ICIKK21zZ3N0ciAiwr9BcGxpY2FyIGJvcnJhZG8gYWwgw6FyYm9sIGRlIHRyYWJham8gW3ksbixxLGEsZCVzLD9dPyAiCiAKICM6IGdpdC1hZGQtLWludGVyYWN0aXZlLnBlcmw6MTQ2OAogIywgcGVybC1mb3JtYXQKIG1zZ2lkICJBcHBseSB0aGlzIGh1bmsgdG8gd29ya3RyZWUgW3ksbixxLGEsZCVzLD9dPyAiCi1tc2dzdHIgIkFwbGljYXIgZXN0ZSBodW5rIGFsIMOhcmJvbCBkZSB0cmFiYWpvIFt5LG4scSxhLGQsLyVzLD9dPyAiCittc2dzdHIgIsK/QXBsaWNhciBlc3RlIGh1bmsgYWwgw6FyYm9sIGRlIHRyYWJham8gW3ksbixxLGEsZCwvJXMsP10/ICIKIAogIzogZ2l0LWFkZC0taW50ZXJhY3RpdmUucGVybDoxNTY4CiBtc2dpZCAiTm8gb3RoZXIgaHVua3MgdG8gZ290b1xuIgpAQCAtMjMyMTcsMTEgKzIzMzE3LDExIEBACiAKICM6IGdpdC1hZGQtLWludGVyYWN0aXZlLnBlcmw6MTU3NQogbXNnaWQgImdvIHRvIHdoaWNoIGh1bmsgKDxyZXQ+IHRvIHNlZSBtb3JlKT8gIgotbXNnc3RyICJhIHF1ZSBodW5rIGlyICg8ZW50ZXI+IHBhcmEgdmVyIG3DoXMpPyAiCittc2dzdHIgIsK/YSBxdWUgaHVuayBpciAoPGVudGVyPiBwYXJhIHZlciBtw6FzKT8gIgogCiAjOiBnaXQtYWRkLS1pbnRlcmFjdGl2ZS5wZXJsOjE1NzcKIG1zZ2lkICJnbyB0byB3aGljaCBodW5rPyAiCi1tc2dzdHIgImEgcXVlIGh1bmsgaXI/ICIKK21zZ3N0ciAiwr9hIHF1ZSBodW5rIGlyPyAiCiAKICM6IGdpdC1hZGQtLWludGVyYWN0aXZlLnBlcmw6MTU4NgogIywgcGVybC1mb3JtYXQKQEAgLTIzMjQxLDcgKzIzMzQxLDcgQEAKIAogIzogZ2l0LWFkZC0taW50ZXJhY3RpdmUucGVybDoxNjIxCiBtc2dpZCAic2VhcmNoIGZvciByZWdleD8gIgotbXNnc3RyICJidXNjYXIgcGFyYSByZWdleHA/ICIKK21zZ3N0ciAiwr9idXNjYXIgcGFyYSByZWdleHA/ICIKIAogIzogZ2l0LWFkZC0taW50ZXJhY3RpdmUucGVybDoxNjM0CiAjLCBwZXJsLWZvcm1hdApAQCAtMjM0MzAsNyArMjM1MzAsNyBAQAogIzogZ2l0LXNlbmQtZW1haWwucGVybDo3MTgKICMsIHBlcmwtZm9ybWF0CiBtc2dpZCAiTm8gc3ViamVjdCBsaW5lIGluICVzPyIKLW1zZ3N0ciAiTm8gaGF5IGzDrW5lYSBkZSBzdWJqZWN0IGVuICVzPyIKK21zZ3N0ciAiwr9ObyBoYXkgbMOtbmVhIGRlIHN1YmplY3QgZW4gJXM/IgogCiAjOiBnaXQtc2VuZC1lbWFpbC5wZXJsOjcyOAogIywgcGVybC1mb3JtYXQKQEAgLTIzNDQ1LDcgKzIzNTQ1LDcgQEAKICJcbiIKICJDbGVhciB0aGUgYm9keSBjb250ZW50IGlmIHlvdSBkb24ndCB3aXNoIHRvIHNlbmQgYSBzdW1tYXJ5LlxuIgogbXNnc3RyICIiCi0iTGluZWFzIHF1ZSBjb21pZW56YW4gZW4gXCJHSVQ6XCIgc2Vyw6FuIHJlbW92aWRhcy5cbiIKKyJMaW5lYXMgcXVlIGNvbWllbnphbiBlbiBcIkdJVDpcIiBzZXLDoW4gZWxpbWluYWRhcy5cbiIKICJDb25zaWRlcmUgaW5jbHVpciB1biBkaWZmc3RhdCBnbG9iYWwgbyB1bmEgdGFibGEgZGUgY29udGVuaWRvc1xuIgogInBhcmEgZWwgcGFyY2hlIHF1ZSBlc3TDoXMgZXNjcmliaWVuZG8uXG4iCiAiXG4iCkBAIC0yMzQ2OSw3ICsyMzU2OSw3IEBACiAjOiBnaXQtc2VuZC1lbWFpbC5wZXJsOjg1OAogIywgcGVybC1mb3JtYXQKIG1zZ2lkICJBcmUgeW91IHN1cmUgeW91IHdhbnQgdG8gdXNlIDwlcz4gW3kvTl0/ICIKLW1zZ3N0ciAiRXN0w6FzIHNlZ3VybyBkZSBxdWUgZGVzZWFzIHVzYXIgPCVzPiBbeS9OXT8gIgorbXNnc3RyICLCv0VzdMOhcyBzZWd1cm8gZGUgcXVlIGRlc2VhcyB1c2FyIDwlcz4gW3kvTl0/ICIKIAogIzogZ2l0LXNlbmQtZW1haWwucGVybDo5MTMKIG1zZ2lkICIiCkBAIC0yMzQ4MSw3ICsyMzU4MSw3IEBACiAKICM6IGdpdC1zZW5kLWVtYWlsLnBlcmw6OTE4CiBtc2dpZCAiV2hpY2ggOGJpdCBlbmNvZGluZyBzaG91bGQgSSBkZWNsYXJlIFtVVEYtOF0/ICIKLW1zZ3N0ciAiUXVlIGNvZGlmaWNhY2nDs24gZGUgOGJpdCBkZWJlcsOtYSBkZWNsYXJhciBbVVRGLThdPyAiCittc2dzdHIgIsK/UXVlIGNvZGlmaWNhY2nDs24gZGUgOGJpdCBkZWJlcsOtYSBkZWNsYXJhciBbVVRGLThdPyAiCiAKICM6IGdpdC1zZW5kLWVtYWlsLnBlcmw6OTI2CiAjLCBwZXJsLWZvcm1hdApAQCAtMjM0OTgsNyArMjM1OTgsNyBAQAogCiAjOiBnaXQtc2VuZC1lbWFpbC5wZXJsOjk0NQogbXNnaWQgIlRvIHdob20gc2hvdWxkIHRoZSBlbWFpbHMgYmUgc2VudCAoaWYgYW55b25lKT8iCi1tc2dzdHIgIkEgcXVpZW4gc2UgZGViZW4gbWFuZGFyIGxvcyBjb3JyZW9zIChzaSBleGlzdGUpPyIKK21zZ3N0ciAiwr9BIHF1aWVuIHNlIGRlYmVuIG1hbmRhciBsb3MgY29ycmVvcyAoc2kgZXhpc3RlKT8iCiAKICM6IGdpdC1zZW5kLWVtYWlsLnBlcmw6OTYzCiAjLCBwZXJsLWZvcm1hdApAQCAtMjM1MDgsNyArMjM2MDgsNyBAQAogIzogZ2l0LXNlbmQtZW1haWwucGVybDo5NzUKIG1zZ2lkICJNZXNzYWdlLUlEIHRvIGJlIHVzZWQgYXMgSW4tUmVwbHktVG8gZm9yIHRoZSBmaXJzdCBlbWFpbCAoaWYgYW55KT8gIgogbXNnc3RyICIiCi0iUXXDqSBpZCBkZSBtZW5zYWplIHNlcsOhIHVzYWRvIGNvbW8gRW4tUmVzcHVlc3RhLVBhcmEgZW4gZWwgcHJpbWVyIGVtYWlsIChzaSAiCisiwr9RdcOpIGlkIGRlIG1lbnNhamUgc2Vyw6EgdXNhZG8gY29tbyBFbi1SZXNwdWVzdGEtUGFyYSBlbiBlbCBwcmltZXIgZW1haWwgKHNpICIKICJleGlzdGUgYWxndW5vKT8gIgogCiAjOiBnaXQtc2VuZC1lbWFpbC5wZXJsOjEwMzMgZ2l0LXNlbmQtZW1haWwucGVybDoxMDQxCkBAIC0yMzUyMSw3ICsyMzYyMSw3IEBACiAjLiBhdCB0aGlzIHBvaW50LgogIzogZ2l0LXNlbmQtZW1haWwucGVybDoxMDQ1CiBtc2dpZCAiV2hhdCB0byBkbyB3aXRoIHRoaXMgYWRkcmVzcz8gKFtxXXVpdHxbZF1yb3B8W2VdZGl0KTogIgotbXNnc3RyICJRdWUgaGFjZXIgY29uIGVzdGEgZGlyZWNjacOzbj8gKFtxXXNhbGlyfFtkXWJvdGFyfFtlXWRpdGFyKTogIgorbXNnc3RyICLCv1F1ZSBoYWNlciBjb24gZXN0YSBkaXJlY2Npw7NuPyAoW3Fdc2FsaXJ8W2RdYm90YXJ8W2VdZGl0YXIpOiAiCiAKICM6IGdpdC1zZW5kLWVtYWlsLnBlcmw6MTM2MgogIywgcGVybC1mb3JtYXQKQEAgLTIzNTU4LDcgKzIzNjU4LDcgQEAKICMuIGF0IHRoaXMgcG9pbnQuCiAjOiBnaXQtc2VuZC1lbWFpbC5wZXJsOjE0NjAKIG1zZ2lkICJTZW5kIHRoaXMgZW1haWw/IChbeV1lc3xbbl1vfFtlXWRpdHxbcV11aXR8W2FdbGwpOiAiCi1tc2dzdHIgIk1hbmRhciBlc3RlIGVtYWlsPyAoW3ldc2l8fFtuXW98W2VdZWRpdGFyfFtxXXNhbGlyfFthXXRvZG8pOiAiCittc2dzdHIgIsK/TWFuZGFyIGVzdGUgZW1haWw/IChbeV1zaXx8W25db3xbZV1lZGl0YXJ8W3Fdc2FsaXJ8W2FddG9kbyk6ICIKIAogIzogZ2l0LXNlbmQtZW1haWwucGVybDoxNDYzCiBtc2dpZCAiU2VuZCB0aGlzIGVtYWlsIHJlcGx5IHJlcXVpcmVkIgpAQCAtMjM1NzEsMTIgKzIzNjcxLDEyIEBACiAjOiBnaXQtc2VuZC1lbWFpbC5wZXJsOjE1MzgKICMsIHBlcmwtZm9ybWF0CiBtc2dpZCAiU2VydmVyIGRvZXMgbm90IHN1cHBvcnQgU1RBUlRUTFMhICVzIgotbXNnc3RyICJFbCBzZXJ2aWRvciBubyBzb3BvcnRhIFNUQVJUVExTISAlcyIKK21zZ3N0ciAiwqFFbCBzZXJ2aWRvciBubyBzb3BvcnRhIFNUQVJUVExTISAlcyIKIAogIzogZ2l0LXNlbmQtZW1haWwucGVybDoxNTQzIGdpdC1zZW5kLWVtYWlsLnBlcmw6MTU0NwogIywgcGVybC1mb3JtYXQKIG1zZ2lkICJTVEFSVFRMUyBmYWlsZWQhICVzIgotbXNnc3RyICJGYWxsw7MgU1RBUlRUTFMhICVzIgorbXNnc3RyICLCoUZhbGzDsyBTVEFSVFRMUyEgJXMiCiAKICM6IGdpdC1zZW5kLWVtYWlsLnBlcmw6MTU1NgogbXNnaWQgIlVuYWJsZSB0byBpbml0aWFsaXplIFNNVFAgcHJvcGVybHkuIENoZWNrIGNvbmZpZyBhbmQgdXNlIC0tc210cC1kZWJ1Zy4iCkBAIC0yMzY4Miw3ICsyMzc4Miw0NSBAQAogIzogZ2l0LXNlbmQtZW1haWwucGVybDoxOTc4CiAjLCBwZXJsLWZvcm1hdAogbXNnaWQgIkRvIHlvdSByZWFsbHkgd2FudCB0byBzZW5kICVzPyBbeXxOXTogIgotbXNnc3RyICJSZWFsbWVudGUgZGVzZWFzIG1hbmRhciAlcz9beXxOXTogIgorbXNnc3RyICLCv1JlYWxtZW50ZSBkZXNlYXMgbWFuZGFyICVzP1t5fE5dOiAiCisKKyN+IG1zZ2lkICJ1bmtub3duIGNvcmUudW50cmFja2VkQ2FjaGUgdmFsdWUgJyVzJzsgdXNpbmcgJ2tlZXAnIGRlZmF1bHQgdmFsdWUiCisjfiBtc2dzdHIgIiIKKyN+ICJ2YWxvciBjb3JlLnVudHJhY2tlZENhY2hlICclcycgZGVzY29ub2NpZG87IHVzYW5kbyAna2VlcCcgY29tbyB2YWxvciBwb3IgIgorI34gImRlZmVjdG8iCisKKyN+IG1zZ2lkICJjYW5ub3QgY2hhbmdlIHBhcnRpYWwgY2xvbmUgcHJvbWlzb3IgcmVtb3RlIgorI34gbXNnc3RyICJubyBzZSBwdWVkZSBjYW1iaWFyIHVuIGNsb24gcGFyY2lhbCByZW1vdG8gcHJvbWlzb3IiCisKKyN+IG1zZ2lkICJlcnJvciBidWlsZGluZyB0cmVlcyIKKyN+IG1zZ3N0ciAiZXJyb3IgY29uc3RydXllbmRvIMOhcmJvbGVzIgorCisjfiBtc2dpZCAiaW52YWxpZCBkYXRlIGZvcm1hdCAnJXMnIGluICclcyciCisjfiBtc2dzdHIgImZvcm1hdG8gZGUgZmVjaGEgaW52w6FsaWRvICclcycgZW4gJyVzJyIKKworI34gbXNnaWQgIndyaXRpbmcgcm9vdCBjb21taXQiCisjfiBtc2dzdHIgImVzY3JpYmllbmRvIGNvbW1pdCByYcOteiIKKworI34gbXNnaWQgInN0YWdlZCBjaGFuZ2VzIGluIHRoZSBmb2xsb3dpbmcgZmlsZXMgbWF5IGJlIGxvc3Q6ICVzIgorI34gbXNnc3RyICIiCisjfiAiY2FtYmlvcyBlbiBlbCDDoXJlYSBkZSBzdGFnZSBlbiBlbCBzaWd1aWVudGUgYXJjaGl2byBwdWVkZW4gc2VyIHBlcmRpZG9zOiAiCisjfiAiJXMiCisKKyN+IG1zZ2lkICIiCisjfiAiLS1maWx0ZXIgY2FuIG9ubHkgYmUgdXNlZCB3aXRoIHRoZSByZW1vdGUgY29uZmlndXJlZCBpbiBleHRlbnNpb25zLiIKKyN+ICJwYXJ0aWFsQ2xvbmUiCisjfiBtc2dzdHIgIiIKKyN+ICItLWZpbHRlciBzb2xvIHB1ZWRlIHNlciB1c2FkbyBjb24gZWwgcmVtb3RvIGNvbmZpZ3VyYWRvIGVuIGV4dGVuc2lvbnMuIgorI34gInBhcnRpYWxDbG9uZSIKKworI34gbXNnaWQgInZlcmlmeSBjb21taXQtbXNnIGhvb2siCisjfiBtc2dzdHIgInZlcmlmaWNhciBlbCBob29rIGNvbW1pdC1tc2ciCisKKyN+IG1zZ2lkICJjYW5ub3QgY29tYmluZSAnLS1yZWJhc2UtbWVyZ2VzJyB3aXRoICctLXN0cmF0ZWd5LW9wdGlvbiciCisjfiBtc2dzdHIgIm5vIHNlIHB1ZWRlIGNvbWJpbmFyICctLXJlYmFzZS1tZXJnZXMnIGNvbiAnLS1zdHJhdGVneS1vcHRpb24nIgorCisjfiBtc2dpZCAiaW52YWxpZCBzcGFyc2UgdmFsdWUgJyVzJyIKKyN+IG1zZ3N0ciAidmFsb3IgZGlzcGVyc28gaW52w6FsaWRvOiAnJXMnIgogCiAjfiBtc2dpZCAiU2VydmVyIHN1cHBvcnRzIG11bHRpX2Fja19kZXRhaWxlZCIKICN+IG1zZ3N0ciAiRWwgc2Vydmlkb3Igc29wb3J0YSB1bHRpX2Fja19kZXRhaWxlZCIKZGlmZiAtLWdpdCBhL3BvL2ZyLnBvIGIvcG8vZnIucG8KaW5kZXggNTVjN2RiNi4uYTg5YTVlZCAxMDA2NDQKLS0tIGEvcG8vZnIucG8KKysrIGIvcG8vZnIucG8KQEAgLTc1LDggKzc1LDggQEAKIG1zZ3N0ciAiIgogIlByb2plY3QtSWQtVmVyc2lvbjogZ2l0XG4iCiAiUmVwb3J0LU1zZ2lkLUJ1Z3MtVG86IEdpdCBNYWlsaW5nIExpc3QgPGdpdEB2Z2VyLmtlcm5lbC5vcmc+XG4iCi0iUE9ULUNyZWF0aW9uLURhdGU6IDIwMTktMDgtMTAgMjA6MTIrMDgwMFxuIgotIlBPLVJldmlzaW9uLURhdGU6IDIwMTktMDgtMTAgMTg6MTcrMDIwMFxuIgorIlBPVC1DcmVhdGlvbi1EYXRlOiAyMDE5LTEwLTI4IDEzOjE5KzA4MDBcbiIKKyJQTy1SZXZpc2lvbi1EYXRlOiAyMDE5LTEwLTI4IDIwOjM1KzAxMDBcbiIKICJMYXN0LVRyYW5zbGF0b3I6IEPDqWRyaWMgTWFsYXJkIDxjLm1hbGFyZC1naXRAdmFsZHVuLm5ldD5cbiIKICJMYW5ndWFnZS1UZWFtOiBKZWFuLU5vw6tsIEF2aWxhIDxqbi5hdmlsYUBmcmVlLmZyPlxuIgogIkxhbmd1YWdlOiBmclxuIgpAQCAtMTI4LDcgKzEyOCw3IEBACiBtc2dpZCAiRXhpdGluZyBiZWNhdXNlIG9mIGFuIHVucmVzb2x2ZWQgY29uZmxpY3QuIgogbXNnc3RyICJBYmFuZG9uIMOgIGNhdXNlIGRlIGNvbmZsaXQgbm9uIHLDqXNvbHUuIgogCi0jOiBhZHZpY2UuYzoxOTMgYnVpbHRpbi9tZXJnZS5jOjEzMjcKKyM6IGFkdmljZS5jOjE5MyBidWlsdGluL21lcmdlLmM6MTMzMgogbXNnaWQgIllvdSBoYXZlIG5vdCBjb25jbHVkZWQgeW91ciBtZXJnZSAoTUVSR0VfSEVBRCBleGlzdHMpLiIKIG1zZ3N0ciAiVm91cyBuJ2F2ZXogcGFzIHRlcm1pbsOpIHZvdHJlIGZ1c2lvbiAoTUVSR0VfSEVBRCBleGlzdGUpLiIKIApAQCAtMjc1LDE3ICsyNzUsNyBAQAogbXNnaWQgImluY29uc2lzdGVudCBoZWFkZXIgbGluZXMgJWQgYW5kICVkIgogbXNnc3RyICJsaWduZXMgZCdlbnTDqnRlIGluY29uc2lzdGFudGVzICVkIGV0ICVkIgogCi0jOiBhcHBseS5jOjE0NjAKLSMsIGMtZm9ybWF0Ci1tc2dpZCAicmVjb3VudDogdW5leHBlY3RlZCBsaW5lOiAlLipzIgotbXNnc3RyICJyZWNvbXB0YWdlIDogbGlnbmUgaW5hdHRlbmR1ZSA6ICUuKnMiCi0KLSM6IGFwcGx5LmM6MTUyOQotIywgYy1mb3JtYXQKLW1zZ2lkICJwYXRjaCBmcmFnbWVudCB3aXRob3V0IGhlYWRlciBhdCBsaW5lICVkOiAlLipzIgotbXNnc3RyICJmcmFnbWVudCBkZSBwYXRjaCBzYW5zIGVuLXTDqnRlIMOgIGxhIGxpZ25lICVkIDogJS4qcyIKLQotIzogYXBwbHkuYzoxNTUxCisjOiBhcHBseS5jOjEzNzIKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogImdpdCBkaWZmIGhlYWRlciBsYWNrcyBmaWxlbmFtZSBpbmZvcm1hdGlvbiB3aGVuIHJlbW92aW5nICVkIGxlYWRpbmcgcGF0aG5hbWUgIgpAQCAtMzAwLDgzICsyOTAsOTMgQEAKICJpbmZvcm1hdGlvbiBkZSBub20gZGUgZmljaGllciBtYW5xdWFudGUgZGFucyBsJ2VuLXTDqnRlIGRlIGdpdCBkaWZmIGxvcnMgZGUgIgogImxhIHN1cHByZXNzaW9uIGRlICVkIGNvbXBvc2FudHMgZGUgcHLDqWZpeGUgZGUgY2hlbWluIChsaWduZSAlZCkiCiAKLSM6IGFwcGx5LmM6MTU2NAorIzogYXBwbHkuYzoxMzg1CiAjLCBjLWZvcm1hdAogbXNnaWQgImdpdCBkaWZmIGhlYWRlciBsYWNrcyBmaWxlbmFtZSBpbmZvcm1hdGlvbiAobGluZSAlZCkiCiBtc2dzdHIgIiIKICJpbmZvcm1hdGlvbiBkZSBub20gZGUgZmljaGllciBtYW5xdWFudGUgZGFucyBsJ2VuLXTDqnRlIGRlIGdpdCBkaWZmIChsaWduZSAlZCkiCiAKLSM6IGFwcGx5LmM6MTc1MgorIzogYXBwbHkuYzoxNDgxCisjLCBjLWZvcm1hdAorbXNnaWQgInJlY291bnQ6IHVuZXhwZWN0ZWQgbGluZTogJS4qcyIKK21zZ3N0ciAicmVjb21wdGFnZSA6IGxpZ25lIGluYXR0ZW5kdWUgOiAlLipzIgorCisjOiBhcHBseS5jOjE1NTAKKyMsIGMtZm9ybWF0Cittc2dpZCAicGF0Y2ggZnJhZ21lbnQgd2l0aG91dCBoZWFkZXIgYXQgbGluZSAlZDogJS4qcyIKK21zZ3N0ciAiZnJhZ21lbnQgZGUgcGF0Y2ggc2FucyBlbi10w6p0ZSDDoCBsYSBsaWduZSAlZCA6ICUuKnMiCisKKyM6IGFwcGx5LmM6MTc1MwogbXNnaWQgIm5ldyBmaWxlIGRlcGVuZHMgb24gb2xkIGNvbnRlbnRzIgogbXNnc3RyICJsZSBub3V2ZWF1IGZpY2hpZXIgZMOpcGVuZCBkZSBjb250ZW51cyBhbmNpZW5zIgogCi0jOiBhcHBseS5jOjE3NTQKKyM6IGFwcGx5LmM6MTc1NQogbXNnaWQgImRlbGV0ZWQgZmlsZSBzdGlsbCBoYXMgY29udGVudHMiCiBtc2dzdHIgImxlIGZpY2hpZXIgc3VwcHJpbcOpIGEgZW5jb3JlIGR1IGNvbnRlbnUiCiAKLSM6IGFwcGx5LmM6MTc4OAorIzogYXBwbHkuYzoxNzg5CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvcnJ1cHQgcGF0Y2ggYXQgbGluZSAlZCIKIG1zZ3N0ciAicGF0Y2ggY29ycm9tcHUgw6AgbGEgbGlnbmUgJWQiCiAKLSM6IGFwcGx5LmM6MTgyNQorIzogYXBwbHkuYzoxODI2CiAjLCBjLWZvcm1hdAogbXNnaWQgIm5ldyBmaWxlICVzIGRlcGVuZHMgb24gb2xkIGNvbnRlbnRzIgogbXNnc3RyICJsZSBub3V2ZWF1IGZpY2hpZXIgJXMgZMOpcGVuZCBkZSBjb250ZW51cyBhbmNpZW5zIgogCi0jOiBhcHBseS5jOjE4MjcKKyM6IGFwcGx5LmM6MTgyOAogIywgYy1mb3JtYXQKIG1zZ2lkICJkZWxldGVkIGZpbGUgJXMgc3RpbGwgaGFzIGNvbnRlbnRzIgogbXNnc3RyICJsZSBmaWNoaWVyIHN1cHByaW3DqSAlcyBhIGVuY29yZSBkdSBjb250ZW51IgogCi0jOiBhcHBseS5jOjE4MzAKKyM6IGFwcGx5LmM6MTgzMQogIywgYy1mb3JtYXQKIG1zZ2lkICIqKiB3YXJuaW5nOiBmaWxlICVzIGJlY29tZXMgZW1wdHkgYnV0IGlzIG5vdCBkZWxldGVkIgogbXNnc3RyICIqKiBhdHRlbnRpb24gOiBsZSBmaWNoaWVyICVzIGRldmllbnQgdmlkZSBtYWlzIG4nZXN0IHBhcyBzdXBwcmltw6kiCiAKLSM6IGFwcGx5LmM6MTk3NworIzogYXBwbHkuYzoxOTc4CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvcnJ1cHQgYmluYXJ5IHBhdGNoIGF0IGxpbmUgJWQ6ICUuKnMiCiBtc2dzdHIgInBhdGNoIGJpbmFpcmUgY29ycm9tcHUgw6AgbGEgbGlnbmUgJWQgOiAlLipzIgogCi0jOiBhcHBseS5jOjIwMTQKKyM6IGFwcGx5LmM6MjAxNQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bnJlY29nbml6ZWQgYmluYXJ5IHBhdGNoIGF0IGxpbmUgJWQiCiBtc2dzdHIgInBhdGNoIGJpbmFpcmUgbm9uIHJlY29ubnUgw6AgbGEgbGlnbmUgJWQiCiAKLSM6IGFwcGx5LmM6MjE3NgorIzogYXBwbHkuYzoyMTc3CiAjLCBjLWZvcm1hdAogbXNnaWQgInBhdGNoIHdpdGggb25seSBnYXJiYWdlIGF0IGxpbmUgJWQiCiBtc2dzdHIgInBhdGNoIHRvdGFsZW1lbnQgaW5jb21wcsOpaGVuc2libGUgw6AgbGEgbGlnbmUgJWQiCiAKLSM6IGFwcGx5LmM6MjI2MgorIzogYXBwbHkuYzoyMjYzCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byByZWFkIHN5bWxpbmsgJXMiCiBtc2dzdHIgImxlY3R1cmUgZHUgbGllbiBzeW1ib2xpcXVlICVzIGltcG9zc2libGUiCiAKLSM6IGFwcGx5LmM6MjI2NgorIzogYXBwbHkuYzoyMjY3CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBvcGVuIG9yIHJlYWQgJXMiCiBtc2dzdHIgIm91dmVydHVyZSBvdSBsZWN0dXJlIGRlICVzIGltcG9zc2libGUiCiAKLSM6IGFwcGx5LmM6MjkyNQorIzogYXBwbHkuYzoyOTI2CiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgc3RhcnQgb2YgbGluZTogJyVjJyIKIG1zZ3N0ciAiZMOpYnV0IGRlIGxpZ25lIGludmFsaWRlIDogJyVjJyIKIAotIzogYXBwbHkuYzozMDQ2CisjOiBhcHBseS5jOjMwNDcKICMsIGMtZm9ybWF0CiBtc2dpZCAiSHVuayAjJWQgc3VjY2VlZGVkIGF0ICVkIChvZmZzZXQgJWQgbGluZSkuIgogbXNnaWRfcGx1cmFsICJIdW5rICMlZCBzdWNjZWVkZWQgYXQgJWQgKG9mZnNldCAlZCBsaW5lcykuIgogbXNnc3RyWzBdICJMYSBzZWN0aW9uIG7CsCVkIGEgcsOpdXNzaSDDoCBsYSBsaWduZSAlZCAob2Zmc2V0ICVkIGxpZ25lKS4iCiBtc2dzdHJbMV0gIkxhIHNlY3Rpb24gbsKwJWQgYSByw6l1c3NpIMOgIGxhIGxpZ25lICVkIChvZmZzZXQgJWQgbGlnbmVzKS4iCiAKLSM6IGFwcGx5LmM6MzA1OAorIzogYXBwbHkuYzozMDU5CiAjLCBjLWZvcm1hdAogbXNnaWQgIkNvbnRleHQgcmVkdWNlZCB0byAoJWxkLyVsZCkgdG8gYXBwbHkgZnJhZ21lbnQgYXQgJWQiCiBtc2dzdHIgIkNvbnRleHRlIHLDqWR1aXQgw6AgKCVsZC8lbGQpIHBvdXIgYXBwbGlxdWVyIGxlIGZyYWdtZW50IMOgIGxhIGxpZ25lICVkIgogCi0jOiBhcHBseS5jOjMwNjQKKyM6IGFwcGx5LmM6MzA2NQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAid2hpbGUgc2VhcmNoaW5nIGZvcjpcbiIKQEAgLTM4NSw0NjMgKzM4NSw0NjMgQEAKICJwZW5kYW50IGxhIHJlY2hlcmNoZSBkZSA6XG4iCiAiJS4qcyIKIAotIzogYXBwbHkuYzozMDg2CisjOiBhcHBseS5jOjMwODcKICMsIGMtZm9ybWF0CiBtc2dpZCAibWlzc2luZyBiaW5hcnkgcGF0Y2ggZGF0YSBmb3IgJyVzJyIKIG1zZ3N0ciAiZG9ubsOpZXMgZGUgcGF0Y2ggYmluYWlyZSBtYW5xdWFudGVzIHBvdXIgJyVzJyIKIAotIzogYXBwbHkuYzozMDk0CisjOiBhcHBseS5jOjMwOTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IHJldmVyc2UtYXBwbHkgYSBiaW5hcnkgcGF0Y2ggd2l0aG91dCB0aGUgcmV2ZXJzZSBodW5rIHRvICclcyciCiBtc2dzdHIgIiIKICJpbXBvc3NpYmxlIGQnYXBwbGlxdWVyIGwnaW52ZXJzZSBkJ3VuIHBhdGNoIGJpbmFpcmUgw6AgJyVzJyBzYW5zIGxhIHNlY3Rpb24gIgogImludmVyc2UiCiAKLSM6IGFwcGx5LmM6MzE0MQorIzogYXBwbHkuYzozMTQyCiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCBhcHBseSBiaW5hcnkgcGF0Y2ggdG8gJyVzJyB3aXRob3V0IGZ1bGwgaW5kZXggbGluZSIKIG1zZ3N0ciAiIgogImltcG9zc2libGUgZCdhcHBsaXF1ZXIgdW4gcGF0Y2ggYmluYWlyZSDDoCAnJXMnIHNhbnMgbGEgbGlnbmUgY29tcGzDqHRlIGQnaW5kZXgiCiAKLSM6IGFwcGx5LmM6MzE1MQorIzogYXBwbHkuYzozMTUyCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJ0aGUgcGF0Y2ggYXBwbGllcyB0byAnJXMnICglcyksIHdoaWNoIGRvZXMgbm90IG1hdGNoIHRoZSBjdXJyZW50IGNvbnRlbnRzLiIKIG1zZ3N0ciAiIgogImxlIHBhdGNoIHMnYXBwbGlxdWUgw6AgJyVzJyAoJXMpLCBjZSBxdWkgbmUgY29ycmVzcG9uZCBwYXMgYXUgY29udGVudSBhY3R1ZWwuIgogCi0jOiBhcHBseS5jOjMxNTkKKyM6IGFwcGx5LmM6MzE2MAogIywgYy1mb3JtYXQKIG1zZ2lkICJ0aGUgcGF0Y2ggYXBwbGllcyB0byBhbiBlbXB0eSAnJXMnIGJ1dCBpdCBpcyBub3QgZW1wdHkiCiBtc2dzdHIgImxlIHBhdGNoIHMnYXBwbGlxdWUgw6AgdW4gJyVzJyB2aWRlIG1haXMgY2Ugbidlc3QgcGFzIHZpZGUiCiAKLSM6IGFwcGx5LmM6MzE3NworIzogYXBwbHkuYzozMTc4CiAjLCBjLWZvcm1hdAogbXNnaWQgInRoZSBuZWNlc3NhcnkgcG9zdGltYWdlICVzIGZvciAnJXMnIGNhbm5vdCBiZSByZWFkIgogbXNnc3RyICJsJ2ltYWdlIHBvc3TDqXJpZXVyZSBuw6ljZXNzYWlyZSAlcyBwb3VyICclcycgbmUgcGV1dCBwYXMgw6p0cmUgbHVlIgogCi0jOiBhcHBseS5jOjMxOTAKKyM6IGFwcGx5LmM6MzE5MQogIywgYy1mb3JtYXQKIG1zZ2lkICJiaW5hcnkgcGF0Y2ggZG9lcyBub3QgYXBwbHkgdG8gJyVzJyIKIG1zZ3N0ciAibGUgcGF0Y2ggYmluYWlyZSBuZSBzJ2FwcGxpcXVlIHBhciBjb3JyZWN0ZW1lbnQgw6AgJyVzJyIKIAotIzogYXBwbHkuYzozMTk2CisjOiBhcHBseS5jOjMxOTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiYmluYXJ5IHBhdGNoIHRvICclcycgY3JlYXRlcyBpbmNvcnJlY3QgcmVzdWx0IChleHBlY3RpbmcgJXMsIGdvdCAlcykiCiBtc2dzdHIgIiIKICJsZSBwYXRjaCBiaW5haXJlIHN1ciAnJXMnIGNyw6llIHVuIHLDqXN1bHRhdCBpbmNvcnJlY3QgKCVzIGF0dGVuZHUsIG1haXMgJXMgIgogInRyb3V2w6kpIgogCi0jOiBhcHBseS5jOjMyMTcKKyM6IGFwcGx5LmM6MzIxOAogIywgYy1mb3JtYXQKIG1zZ2lkICJwYXRjaCBmYWlsZWQ6ICVzOiVsZCIKIG1zZ3N0ciAibGUgcGF0Y2ggYSDDqWNob3XDqSA6ICVzOiVsZCIKIAotIzogYXBwbHkuYzozMzQwCisjOiBhcHBseS5jOjMzNDEKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IGNoZWNrb3V0ICVzIgogbXNnc3RyICJleHRyYWN0aW9uIGRlICVzIGltcG9zc2libGUiCiAKLSM6IGFwcGx5LmM6MzM5MiBhcHBseS5jOjM0MDMgYXBwbHkuYzozNDQ5IG1pZHguYzo2MiBzZXR1cC5jOjI3OQorIzogYXBwbHkuYzozMzkzIGFwcGx5LmM6MzQwNCBhcHBseS5jOjM0NTAgbWlkeC5jOjYxIHNldHVwLmM6MjgwCiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byByZWFkICVzIgogbXNnc3RyICLDqWNoZWMgZGUgbGEgbGVjdHVyZSBkZSAlcyIKIAotIzogYXBwbHkuYzozNDAwCisjOiBhcHBseS5jOjM0MDEKICMsIGMtZm9ybWF0CiBtc2dpZCAicmVhZGluZyBmcm9tICclcycgYmV5b25kIGEgc3ltYm9saWMgbGluayIKIG1zZ3N0ciAibGVjdHVyZSBkZXB1aXMgJyVzJyBhdS1kZWzDoCBkJ3VuIGxpZW4gc3ltYm9saXF1ZSIKIAotIzogYXBwbHkuYzozNDI5IGFwcGx5LmM6MzY3MgorIzogYXBwbHkuYzozNDMwIGFwcGx5LmM6MzY3MwogIywgYy1mb3JtYXQKIG1zZ2lkICJwYXRoICVzIGhhcyBiZWVuIHJlbmFtZWQvZGVsZXRlZCIKIG1zZ3N0ciAibGUgY2hlbWluICVzIGEgw6l0w6kgcmVub21tw6kvc3VwcHJpbcOpIgogCi0jOiBhcHBseS5jOjM1MTUgYXBwbHkuYzozNjg3CisjOiBhcHBseS5jOjM1MTYgYXBwbHkuYzozNjg4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiBkb2VzIG5vdCBleGlzdCBpbiBpbmRleCIKIG1zZ3N0ciAiJXMgOiBuJ2V4aXN0ZSBwYXMgZGFucyBsJ2luZGV4IgogCi0jOiBhcHBseS5jOjM1MjQgYXBwbHkuYzozNjk1CisjOiBhcHBseS5jOjM1MjUgYXBwbHkuYzozNjk2CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiBkb2VzIG5vdCBtYXRjaCBpbmRleCIKIG1zZ3N0ciAiJXMgOiBuZSBjb3JyZXNwb25kIHBhcyDDoCBsJ2luZGV4IgogCi0jOiBhcHBseS5jOjM1NTkKKyM6IGFwcGx5LmM6MzU2MAogbXNnaWQgInJlcG9zaXRvcnkgbGFja3MgdGhlIG5lY2Vzc2FyeSBibG9iIHRvIGZhbGwgYmFjayBvbiAzLXdheSBtZXJnZS4iCiBtc2dzdHIgIiIKICJsZSBkw6lww7R0IG4nYSBwYXMgbGVzIGJsb2JzIG7DqWNlc3NhaXJlcyBwb3VyIHVuIHJldG91ciDDoCB1bmUgZnVzaW9uIMOgIDMgIgogInBvaW50cy4iCiAKLSM6IGFwcGx5LmM6MzU2MgorIzogYXBwbHkuYzozNTYzCiAjLCBjLWZvcm1hdAogbXNnaWQgIkZhbGxpbmcgYmFjayB0byB0aHJlZS13YXkgbWVyZ2UuLi5cbiIKIG1zZ3N0ciAiUmV0b3VyIMOgIHVuZSBmdXNpb24gw6AgMyBwb2ludHPigKZcbiIKIAotIzogYXBwbHkuYzozNTc4IGFwcGx5LmM6MzU4MgorIzogYXBwbHkuYzozNTc5IGFwcGx5LmM6MzU4MwogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgcmVhZCB0aGUgY3VycmVudCBjb250ZW50cyBvZiAnJXMnIgogbXNnc3RyICJpbXBvc3NpYmxlIGRlIGxpcmUgbGUgY29udGVudSBhY3R1ZWwgZGUgJyVzJyIKIAotIzogYXBwbHkuYzozNTk0CisjOiBhcHBseS5jOjM1OTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiRmFpbGVkIHRvIGZhbGwgYmFjayBvbiB0aHJlZS13YXkgbWVyZ2UuLi5cbiIKIG1zZ3N0ciAiw4ljaGVjIGR1IHJldG91ciDDoCB1bmUgZnVzaW9uIMOgIDMgcG9pbnRz4oCmXG4iCiAKLSM6IGFwcGx5LmM6MzYwOAorIzogYXBwbHkuYzozNjA5CiAjLCBjLWZvcm1hdAogbXNnaWQgIkFwcGxpZWQgcGF0Y2ggdG8gJyVzJyB3aXRoIGNvbmZsaWN0cy5cbiIKIG1zZ3N0ciAiUGF0Y2ggJXMgYXBwbGlxdcOpIGF2ZWMgZGVzIGNvbmZsaXRzLlxuIgogCi0jOiBhcHBseS5jOjM2MTMKKyM6IGFwcGx5LmM6MzYxNAogIywgYy1mb3JtYXQKIG1zZ2lkICJBcHBsaWVkIHBhdGNoIHRvICclcycgY2xlYW5seS5cbiIKIG1zZ3N0ciAiUGF0Y2ggJXMgYXBwbGlxdcOpIHByb3ByZW1lbnQuXG4iCiAKLSM6IGFwcGx5LmM6MzYzOQorIzogYXBwbHkuYzozNjQwCiBtc2dpZCAicmVtb3ZhbCBwYXRjaCBsZWF2ZXMgZmlsZSBjb250ZW50cyIKIG1zZ3N0ciAibGUgcGF0Y2ggZGUgc3VwcHJlc3Npb24gbGFpc3NlIHVuIGNvbnRlbnUgZGFucyBsZSBmaWNoaWVyIgogCi0jOiBhcHBseS5jOjM3MTIKKyM6IGFwcGx5LmM6MzcxMwogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogd3JvbmcgdHlwZSIKIG1zZ3N0ciAiJXMgOiB0eXBlIGVycm9uw6kiCiAKLSM6IGFwcGx5LmM6MzcxNAorIzogYXBwbHkuYzozNzE1CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIGhhcyB0eXBlICVvLCBleHBlY3RlZCAlbyIKIG1zZ3N0ciAiJXMgZXN0IGRlIHR5cGUgJW8sIG1haXMgJW8gYXR0ZW5kdSIKIAotIzogYXBwbHkuYzozODY1IGFwcGx5LmM6Mzg2NyByZWFkLWNhY2hlLmM6ODMwIHJlYWQtY2FjaGUuYzo4NTYKKyM6IGFwcGx5LmM6Mzg2NiBhcHBseS5jOjM4NjggcmVhZC1jYWNoZS5jOjgzMCByZWFkLWNhY2hlLmM6ODU2CiAjOiByZWFkLWNhY2hlLmM6MTMwOQogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIHBhdGggJyVzJyIKIG1zZ3N0ciAiY2hlbWluIGludmFsaWRlICclcyciCiAKLSM6IGFwcGx5LmM6MzkyMworIzogYXBwbHkuYzozOTI0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiBhbHJlYWR5IGV4aXN0cyBpbiBpbmRleCIKIG1zZ3N0ciAiJXMgOiBleGlzdGUgZMOpasOgIGRhbnMgbCdpbmRleCIKIAotIzogYXBwbHkuYzozOTI2CisjOiBhcHBseS5jOjM5MjcKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXM6IGFscmVhZHkgZXhpc3RzIGluIHdvcmtpbmcgZGlyZWN0b3J5IgogbXNnc3RyICIlcyA6IGV4aXN0ZSBkw6lqw6AgZGFucyBsYSBjb3BpZSBkZSB0cmF2YWlsIgogCi0jOiBhcHBseS5jOjM5NDYKKyM6IGFwcGx5LmM6Mzk0NwogIywgYy1mb3JtYXQKIG1zZ2lkICJuZXcgbW9kZSAoJW8pIG9mICVzIGRvZXMgbm90IG1hdGNoIG9sZCBtb2RlICglbykiCiBtc2dzdHIgImxlIG5vdXZlYXUgbW9kZSAoJW8pIGRlICVzIG5lIGNvcnJlc3BvbmQgcGFzIMOgIGwnYW5jaWVuIG1vZGUgKCVvKSIKIAotIzogYXBwbHkuYzozOTUxCisjOiBhcHBseS5jOjM5NTIKICMsIGMtZm9ybWF0CiBtc2dpZCAibmV3IG1vZGUgKCVvKSBvZiAlcyBkb2VzIG5vdCBtYXRjaCBvbGQgbW9kZSAoJW8pIG9mICVzIgogbXNnc3RyICIiCiAibGUgbm91dmVhdSBtb2RlICglbykgZGUgJXMgbmUgY29ycmVzcG9uZCBwYXMgw6AgbCdhbmNpZW4gbW9kZSAoJW8pIGRlICVzIgogCi0jOiBhcHBseS5jOjM5NzEKKyM6IGFwcGx5LmM6Mzk3MgogIywgYy1mb3JtYXQKIG1zZ2lkICJhZmZlY3RlZCBmaWxlICclcycgaXMgYmV5b25kIGEgc3ltYm9saWMgbGluayIKIG1zZ3N0ciAibGUgZmljaGllciBhZmZlY3TDqSAnJXMnIGVzdCBhdS1kZWzDoCBkJ3VuIGxpZW4gc3ltYm9saXF1ZSIKIAotIzogYXBwbHkuYzozOTc1CisjOiBhcHBseS5jOjM5NzYKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXM6IHBhdGNoIGRvZXMgbm90IGFwcGx5IgogbXNnc3RyICIlcyA6IGxlIHBhdGNoIG5lIHMnYXBwbGlxdWUgcGFzIgogCi0jOiBhcHBseS5jOjM5OTAKKyM6IGFwcGx5LmM6Mzk5MQogIywgYy1mb3JtYXQKIG1zZ2lkICJDaGVja2luZyBwYXRjaCAlcy4uLiIKIG1zZ3N0ciAiVsOpcmlmaWNhdGlvbiBkdSBwYXRjaCAlcy4uLiIKIAotIzogYXBwbHkuYzo0MDgyCisjOiBhcHBseS5jOjQwODMKICMsIGMtZm9ybWF0CiBtc2dpZCAic2hhMSBpbmZvcm1hdGlvbiBpcyBsYWNraW5nIG9yIHVzZWxlc3MgZm9yIHN1Ym1vZHVsZSAlcyIKIG1zZ3N0ciAiIgogImwnaW5mb3JtYXRpb24gc2hhMSBlc3QgbWFucXVhbnRlIG91IGludXRpbGlzYWJsZSBwb3VyIGxlIHNvdXMtbW9kdWxlICVzIgogCi0jOiBhcHBseS5jOjQwODkKKyM6IGFwcGx5LmM6NDA5MAogIywgYy1mb3JtYXQKIG1zZ2lkICJtb2RlIGNoYW5nZSBmb3IgJXMsIHdoaWNoIGlzIG5vdCBpbiBjdXJyZW50IEhFQUQiCiBtc2dzdHIgImxlIG1vZGUgY2hhbmdlIHBvdXIgJXMsIHF1aSBuJ2VzdCBwYXMgZGFucyBsYSBIRUFEIGFjdHVlbGxlIgogCi0jOiBhcHBseS5jOjQwOTIKKyM6IGFwcGx5LmM6NDA5MwogIywgYy1mb3JtYXQKIG1zZ2lkICJzaGExIGluZm9ybWF0aW9uIGlzIGxhY2tpbmcgb3IgdXNlbGVzcyAoJXMpLiIKIG1zZ3N0ciAibCdpbmZvcm1hdGlvbiBkZSBzaGExIGVzdCBtYW5xdWFudGUgb3UgaW51dGlsaXNhYmxlICglcykuIgogCi0jOiBhcHBseS5jOjQwOTcgYnVpbHRpbi9jaGVja291dC5jOjI3OCBidWlsdGluL3Jlc2V0LmM6MTQzCisjOiBhcHBseS5jOjQwOTggYnVpbHRpbi9jaGVja291dC5jOjI3OSBidWlsdGluL3Jlc2V0LmM6MTQzCiAjLCBjLWZvcm1hdAogbXNnaWQgIm1ha2VfY2FjaGVfZW50cnkgZmFpbGVkIGZvciBwYXRoICclcyciCiBtc2dzdHIgIsOpY2hlYyBkZSBtYWtlX2NhY2hlX2VudHJ5IHBvdXIgbGUgY2hlbWluICclcyciCiAKLSM6IGFwcGx5LmM6NDEwMQorIzogYXBwbHkuYzo0MTAyCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBhZGQgJXMgdG8gdGVtcG9yYXJ5IGluZGV4IgogbXNnc3RyICJpbXBvc3NpYmxlIGQnYWpvdXRlciAlcyDDoCBsJ2luZGV4IHRlbXBvcmFpcmUiCiAKLSM6IGFwcGx5LmM6NDExMQorIzogYXBwbHkuYzo0MTEyCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCB3cml0ZSB0ZW1wb3JhcnkgaW5kZXggdG8gJXMiCiBtc2dzdHIgImltcG9zc2libGUgZCfDqWNyaXJlIGwnaW5kZXggdGVtcG9yYWlyZSBkYW5zICVzIgogCi0jOiBhcHBseS5jOjQyNDkKKyM6IGFwcGx5LmM6NDI1MAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gcmVtb3ZlICVzIGZyb20gaW5kZXgiCiBtc2dzdHIgInN1cHByZXNzaW9uIGRlICVzIGRhbnMgbCdpbmRleCBpbXBvc3NpYmxlIgogCi0jOiBhcHBseS5jOjQyODMKKyM6IGFwcGx5LmM6NDI4NAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3JydXB0IHBhdGNoIGZvciBzdWJtb2R1bGUgJXMiCiBtc2dzdHIgInBhdGNoIGNvcnJvbXB1IHBvdXIgbGUgc291cy1tb2R1bGUgJXMiCiAKLSM6IGFwcGx5LmM6NDI4OQorIzogYXBwbHkuYzo0MjkwCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBzdGF0IG5ld2x5IGNyZWF0ZWQgZmlsZSAnJXMnIgogbXNnc3RyICJzdGF0IGR1IGZpY2hpZXIgbm91dmVsbGVtZW50IGNyw6nDqSAnJXMnIGltcG9zc2libGUiCiAKLSM6IGFwcGx5LmM6NDI5NworIzogYXBwbHkuYzo0Mjk4CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBjcmVhdGUgYmFja2luZyBzdG9yZSBmb3IgbmV3bHkgY3JlYXRlZCBmaWxlICVzIgogbXNnc3RyICIiCiAiY3LDqWF0aW9uIGR1IG1hZ2FzaW4gZGUgc3RvY2thZ2UgcG91ciBsZSBmaWNoaWVyIG5vdXZlbGxlbWVudCBjcsOpw6kgJXMgIgogImltcG9zc2libGUiCiAKLSM6IGFwcGx5LmM6NDMwMyBhcHBseS5jOjQ0NDgKKyM6IGFwcGx5LmM6NDMwNCBhcHBseS5jOjQ0NDkKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGFkZCBjYWNoZSBlbnRyeSBmb3IgJXMiCiBtc2dzdHIgImFqb3V0IGRlIGwnw6lsw6ltZW50IGRlIGNhY2hlICVzIGltcG9zc2libGUiCiAKLSM6IGFwcGx5LmM6NDM0NgorIzogYXBwbHkuYzo0MzQ3CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byB3cml0ZSB0byAnJXMnIgogbXNnc3RyICLDqWNoZWMgZGUgbCfDqWNyaXR1cmUgZGFucyAnJXMnIgogCi0jOiBhcHBseS5jOjQzNTAKKyM6IGFwcGx5LmM6NDM1MQogIywgYy1mb3JtYXQKIG1zZ2lkICJjbG9zaW5nIGZpbGUgJyVzJyIKIG1zZ3N0ciAiZmVybWV0dXJlIGR1IGZpY2hpZXIgJyVzJyIKIAotIzogYXBwbHkuYzo0NDIwCisjOiBhcHBseS5jOjQ0MjEKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHdyaXRlIGZpbGUgJyVzJyBtb2RlICVvIgogbXNnc3RyICLDqWNyaXR1cmUgZHUgZmljaGllciAnJXMnIG1vZGUgJW8gaW1wb3NzaWJsZSIKIAotIzogYXBwbHkuYzo0NTE4CisjOiBhcHBseS5jOjQ1MTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiQXBwbGllZCBwYXRjaCAlcyBjbGVhbmx5LiIKIG1zZ3N0ciAiUGF0Y2ggJXMgYXBwbGlxdcOpIHByb3ByZW1lbnQuIgogCi0jOiBhcHBseS5jOjQ1MjYKKyM6IGFwcGx5LmM6NDUyNwogbXNnaWQgImludGVybmFsIGVycm9yIgogbXNnc3RyICJlcnJldXIgaW50ZXJuZSIKIAotIzogYXBwbHkuYzo0NTI5CisjOiBhcHBseS5jOjQ1MzAKICMsIGMtZm9ybWF0CiBtc2dpZCAiQXBwbHlpbmcgcGF0Y2ggJSVzIHdpdGggJWQgcmVqZWN0Li4uIgogbXNnaWRfcGx1cmFsICJBcHBseWluZyBwYXRjaCAlJXMgd2l0aCAlZCByZWplY3RzLi4uIgogbXNnc3RyWzBdICJBcHBsaWNhdGlvbiBkdSBwYXRjaCAlJXMgYXZlYyAlZCByZWpldC4uLiIKIG1zZ3N0clsxXSAiQXBwbGljYXRpb24gZHUgcGF0Y2ggJSVzIGF2ZWMgJWQgcmVqZXRzLi4uIgogCi0jOiBhcHBseS5jOjQ1NDAKKyM6IGFwcGx5LmM6NDU0MQogIywgYy1mb3JtYXQKIG1zZ2lkICJ0cnVuY2F0aW5nIC5yZWogZmlsZW5hbWUgdG8gJS4qcy5yZWoiCiBtc2dzdHIgInRyb25jYXR1cmUgZHUgbm9tIGRlIGZpY2hpZXIgLnJlaiBlbiAlLipzLnJlaiIKIAotIzogYXBwbHkuYzo0NTQ4IGJ1aWx0aW4vZmV0Y2guYzo4NzggYnVpbHRpbi9mZXRjaC5jOjExNjgKKyM6IGFwcGx5LmM6NDU0OSBidWlsdGluL2ZldGNoLmM6ODk4IGJ1aWx0aW4vZmV0Y2guYzoxMTk0CiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCBvcGVuICVzIgogbXNnc3RyICJpbXBvc3NpYmxlIGQnb3V2cmlyICVzIgogCi0jOiBhcHBseS5jOjQ1NjIKKyM6IGFwcGx5LmM6NDU2MwogIywgYy1mb3JtYXQKIG1zZ2lkICJIdW5rICMlZCBhcHBsaWVkIGNsZWFubHkuIgogbXNnc3RyICJTZWN0aW9uIG7CsCVkIGFwcGxpcXXDqWUgcHJvcHJlbWVudC4iCiAKLSM6IGFwcGx5LmM6NDU2NgorIzogYXBwbHkuYzo0NTY3CiAjLCBjLWZvcm1hdAogbXNnaWQgIlJlamVjdGVkIGh1bmsgIyVkLiIKIG1zZ3N0ciAiU2VjdGlvbiBuwrAlZCByZWpldMOpZS4iCiAKLSM6IGFwcGx5LmM6NDY3NgorIzogYXBwbHkuYzo0Njg2CiAjLCBjLWZvcm1hdAogbXNnaWQgIlNraXBwZWQgcGF0Y2ggJyVzJy4iCiBtc2dzdHIgIkNoZW1pbiAnJXMnIG5vbiB0cmFpdMOpLiIKIAotIzogYXBwbHkuYzo0Njg0CisjOiBhcHBseS5jOjQ2OTQKIG1zZ2lkICJ1bnJlY29nbml6ZWQgaW5wdXQiCiBtc2dzdHIgImVudHLDqWUgbm9uIHJlY29ubnVlIgogCi0jOiBhcHBseS5jOjQ3MDQKKyM6IGFwcGx5LmM6NDcxNAogbXNnaWQgInVuYWJsZSB0byByZWFkIGluZGV4IGZpbGUiCiBtc2dzdHIgImxlY3R1cmUgZHUgZmljaGllciBkJ2luZGV4IGltcG9zc2libGUiCiAKLSM6IGFwcGx5LmM6NDg1OQorIzogYXBwbHkuYzo0ODcxCiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbid0IG9wZW4gcGF0Y2ggJyVzJzogJXMiCiBtc2dzdHIgIm91dmVydHVyZSBpbXBvc3NpYmxlIGR1IHBhdGNoICclcyfCoDolcyIKIAotIzogYXBwbHkuYzo0ODg2CisjOiBhcHBseS5jOjQ4OTgKICMsIGMtZm9ybWF0CiBtc2dpZCAic3F1ZWxjaGVkICVkIHdoaXRlc3BhY2UgZXJyb3IiCiBtc2dpZF9wbHVyYWwgInNxdWVsY2hlZCAlZCB3aGl0ZXNwYWNlIGVycm9ycyIKIG1zZ3N0clswXSAiJWQgZXJyZXVyIGQnZXNwYWNlIGlnbm9yw6llIgogbXNnc3RyWzFdICIlZCBlcnJldXJzIGQnZXNwYWNlIGlnbm9yw6llcyIKIAotIzogYXBwbHkuYzo0ODkyIGFwcGx5LmM6NDkwNworIzogYXBwbHkuYzo0OTA0IGFwcGx5LmM6NDkxOQogIywgYy1mb3JtYXQKIG1zZ2lkICIlZCBsaW5lIGFkZHMgd2hpdGVzcGFjZSBlcnJvcnMuIgogbXNnaWRfcGx1cmFsICIlZCBsaW5lcyBhZGQgd2hpdGVzcGFjZSBlcnJvcnMuIgogbXNnc3RyWzBdICIlZCBsaWduZSBhIGFqb3V0w6kgZGVzIGVycmV1cnMgZCdlc3BhY2UuIgogbXNnc3RyWzFdICIlZCBsaWduZXMgb250IGFqb3V0w6kgZGVzIGVycmV1cnMgZCdlc3BhY2UuIgogCi0jOiBhcHBseS5jOjQ5MDAKKyM6IGFwcGx5LmM6NDkxMgogIywgYy1mb3JtYXQKIG1zZ2lkICIlZCBsaW5lIGFwcGxpZWQgYWZ0ZXIgZml4aW5nIHdoaXRlc3BhY2UgZXJyb3JzLiIKIG1zZ2lkX3BsdXJhbCAiJWQgbGluZXMgYXBwbGllZCBhZnRlciBmaXhpbmcgd2hpdGVzcGFjZSBlcnJvcnMuIgogbXNnc3RyWzBdICIlZCBsaWduZSBham91dMOpZSBhcHLDqHMgY29ycmVjdGlvbiBkZXMgZXJyZXVycyBkJ2VzcGFjZS4iCiBtc2dzdHJbMV0gIiVkIGxpZ25lcyBham91dMOpZXMgYXByw6hzIGNvcnJlY3Rpb24gZGVzIGVycmV1cnMgZCdlc3BhY2UuIgogCi0jOiBhcHBseS5jOjQ5MTYgYnVpbHRpbi9hZGQuYzo1NDAgYnVpbHRpbi9tdi5jOjMwMSBidWlsdGluL3JtLmM6MzkwCisjOiBhcHBseS5jOjQ5MjggYnVpbHRpbi9hZGQuYzo1NDAgYnVpbHRpbi9tdi5jOjMwMSBidWlsdGluL3JtLmM6MzkwCiBtc2dpZCAiVW5hYmxlIHRvIHdyaXRlIG5ldyBpbmRleCBmaWxlIgogbXNnc3RyICJJbXBvc3NpYmxlIGQnw6ljcmlyZSBsZSBub3V2ZWF1IGZpY2hpZXIgZCdpbmRleCIKIAotIzogYXBwbHkuYzo0OTQzIGFwcGx5LmM6NDk0NiBidWlsdGluL2FtLmM6MjIwOCBidWlsdGluL2FtLmM6MjIxMQotIzogYnVpbHRpbi9jbG9uZS5jOjEyMyBidWlsdGluL2ZldGNoLmM6MTI4IGJ1aWx0aW4vbWVyZ2UuYzoyNzMKLSM6IGJ1aWx0aW4vcHVsbC5jOjIwOCBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6NDA3CisjOiBhcHBseS5jOjQ5NTUgYXBwbHkuYzo0OTU4IGJ1aWx0aW4vYW0uYzoyMTk3IGJ1aWx0aW4vYW0uYzoyMjAwCisjOiBidWlsdGluL2Nsb25lLmM6MTIyIGJ1aWx0aW4vZmV0Y2guYzoxNDMgYnVpbHRpbi9tZXJnZS5jOjI3MworIzogYnVpbHRpbi9wdWxsLmM6MjA5IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzo0MDcKICM6IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxMzY3IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxMzcwCiAjOiBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6MTg1MCBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6MTg1MwogIzogYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjIwOTIgZ2l0LWFkZC0taW50ZXJhY3RpdmUucGVybDoyMTEKIG1zZ2lkICJwYXRoIgogbXNnc3RyICJjaGVtaW4iCiAKLSM6IGFwcGx5LmM6NDk0NAorIzogYXBwbHkuYzo0OTU2CiBtc2dpZCAiZG9uJ3QgYXBwbHkgY2hhbmdlcyBtYXRjaGluZyB0aGUgZ2l2ZW4gcGF0aCIKIG1zZ3N0ciAibmUgcGFzIGFwcGxpcXVlciBsZXMgbW9kaWZpY2F0aW9ucyBxdWkgY29ycmVzcG9uZGVudCBhdSBjaGVtaW4gZG9ubsOpIgogCi0jOiBhcHBseS5jOjQ5NDcKKyM6IGFwcGx5LmM6NDk1OQogbXNnaWQgImFwcGx5IGNoYW5nZXMgbWF0Y2hpbmcgdGhlIGdpdmVuIHBhdGgiCiBtc2dzdHIgImFwcGxpcXVlciBsZXMgbW9kaWZpY2F0aW9ucyBxdWkgY29ycmVzcG9uZGVudCBhdSBjaGVtaW4gZG9ubsOpIgogCi0jOiBhcHBseS5jOjQ5NDkgYnVpbHRpbi9hbS5jOjIyMTcKKyM6IGFwcGx5LmM6NDk2MSBidWlsdGluL2FtLmM6MjIwNgogbXNnaWQgIm51bSIKIG1zZ3N0ciAibnVtIgogCi0jOiBhcHBseS5jOjQ5NTAKKyM6IGFwcGx5LmM6NDk2MgogbXNnaWQgInJlbW92ZSA8bnVtPiBsZWFkaW5nIHNsYXNoZXMgZnJvbSB0cmFkaXRpb25hbCBkaWZmIHBhdGhzIgogbXNnc3RyICJzdXBwcmltZXIgPG51bT4gYmFycmVzIG9ibGlxdWVzIGRlcyBjaGVtaW5zIHRyYWRpdGlvbm5lbHMgZGUgZGlmZiIKIAotIzogYXBwbHkuYzo0OTUzCisjOiBhcHBseS5jOjQ5NjUKIG1zZ2lkICJpZ25vcmUgYWRkaXRpb25zIG1hZGUgYnkgdGhlIHBhdGNoIgogbXNnc3RyICJpZ25vcmVyIGxlcyBhZGRpdGlvbnMgcsOpYWxpc8OpZXMgcGFyIGxlIHBhdGNoIgogCi0jOiBhcHBseS5jOjQ5NTUKKyM6IGFwcGx5LmM6NDk2NwogbXNnaWQgImluc3RlYWQgb2YgYXBwbHlpbmcgdGhlIHBhdGNoLCBvdXRwdXQgZGlmZnN0YXQgZm9yIHRoZSBpbnB1dCIKIG1zZ3N0ciAiYXUgbGlldSBkJ2FwcGxpcXVlciBsZSBwYXRjaCwgYWZmaWNoZXIgbGUgZGlmZnN0YXQgZGUgbCdlbnRyw6llIgogCi0jOiBhcHBseS5jOjQ5NTkKKyM6IGFwcGx5LmM6NDk3MQogbXNnaWQgInNob3cgbnVtYmVyIG9mIGFkZGVkIGFuZCBkZWxldGVkIGxpbmVzIGluIGRlY2ltYWwgbm90YXRpb24iCiBtc2dzdHIgIiIKICJhZmZpY2hlciBsZSBub21icmUgZGUgbGlnbmVzIGFqb3V0w6llcyBldCBzdXBwcmltw6llcyBlbiBub3RhdGlvbiBkw6ljaW1hbGUiCiAKLSM6IGFwcGx5LmM6NDk2MQorIzogYXBwbHkuYzo0OTczCiBtc2dpZCAiaW5zdGVhZCBvZiBhcHBseWluZyB0aGUgcGF0Y2gsIG91dHB1dCBhIHN1bW1hcnkgZm9yIHRoZSBpbnB1dCIKIG1zZ3N0ciAiYXUgbGlldSBkJ2FwcGxpcXVlciBsZSBwYXRjaCwgYWZmaWNoZXIgdW4gcsOpc3Vtw6kgZGUgbCdlbnRyw6llIgogCi0jOiBhcHBseS5jOjQ5NjMKKyM6IGFwcGx5LmM6NDk3NQogbXNnaWQgImluc3RlYWQgb2YgYXBwbHlpbmcgdGhlIHBhdGNoLCBzZWUgaWYgdGhlIHBhdGNoIGlzIGFwcGxpY2FibGUiCiBtc2dzdHIgImF1IGxpZXUgZCdhcHBsaXF1ZXIgbGUgcGF0Y2gsIHZvaXIgc2kgbGUgcGF0Y2ggZXN0IGFwcGxpY2FibGUiCiAKLSM6IGFwcGx5LmM6NDk2NQorIzogYXBwbHkuYzo0OTc3CiBtc2dpZCAibWFrZSBzdXJlIHRoZSBwYXRjaCBpcyBhcHBsaWNhYmxlIHRvIHRoZSBjdXJyZW50IGluZGV4IgogbXNnc3RyICJzJ2Fzc3VyZXIgcXVlIGxlIHBhdGNoIGVzdCBhcHBsaWNhYmxlIHN1ciBsJ2luZGV4IGFjdHVlbCIKIAotIzogYXBwbHkuYzo0OTY3CisjOiBhcHBseS5jOjQ5NzkKIG1zZ2lkICJtYXJrIG5ldyBmaWxlcyB3aXRoIGBnaXQgYWRkIC0taW50ZW50LXRvLWFkZGAiCiBtc2dzdHIgIm1hcnF1ZXIgbGVzIG5vdXZlYXV4IGZpY2hpZXJzIGBnaXQgYWRkIC0taW50ZW50LXRvLWFkZGAiCiAKLSM6IGFwcGx5LmM6NDk2OQorIzogYXBwbHkuYzo0OTgxCiBtc2dpZCAiYXBwbHkgYSBwYXRjaCB3aXRob3V0IHRvdWNoaW5nIHRoZSB3b3JraW5nIHRyZWUiCiBtc2dzdHIgImFwcGxpcXVlciBsZXMgcGF0Y2ggc2FucyB0b3VjaGVyIMOgIGxhIGNvcGllIGRlIHRyYXZhaWwiCiAKLSM6IGFwcGx5LmM6NDk3MQorIzogYXBwbHkuYzo0OTgzCiBtc2dpZCAiYWNjZXB0IGEgcGF0Y2ggdGhhdCB0b3VjaGVzIG91dHNpZGUgdGhlIHdvcmtpbmcgYXJlYSIKIG1zZ3N0ciAiYWNjZXB0ZXIgdW4gcGF0Y2ggcXVpIHRvdWNoZSBob3JzIGRlIGxhIGNvcGllIGRlIHRyYXZhaWwiCiAKLSM6IGFwcGx5LmM6NDk3NAorIzogYXBwbHkuYzo0OTg2CiBtc2dpZCAiYWxzbyBhcHBseSB0aGUgcGF0Y2ggKHVzZSB3aXRoIC0tc3RhdC8tLXN1bW1hcnkvLS1jaGVjaykiCiBtc2dzdHIgImFwcGxpcXVlciBhdXNzaSBsZSBwYXRjaCAow6AgdXRpbGlzZXIgYXZlYyAtLXN0YXQvLS1zdW1tYXJ5Ly0tY2hlY2spIgogCi0jOiBhcHBseS5jOjQ5NzYKKyM6IGFwcGx5LmM6NDk4OAogbXNnaWQgImF0dGVtcHQgdGhyZWUtd2F5IG1lcmdlIGlmIGEgcGF0Y2ggZG9lcyBub3QgYXBwbHkiCiBtc2dzdHIgInRlbnRlciB1bmUgZnVzaW9uIMOgIDMgcG9pbnRzIHNpIGxlIHBhdGNoIG5lIHMnYXBwbGlxdWUgcGFzIHByb3ByZW1lbnQiCiAKLSM6IGFwcGx5LmM6NDk3OAorIzogYXBwbHkuYzo0OTkwCiBtc2dpZCAiYnVpbGQgYSB0ZW1wb3JhcnkgaW5kZXggYmFzZWQgb24gZW1iZWRkZWQgaW5kZXggaW5mb3JtYXRpb24iCiBtc2dzdHIgIiIKICJjb25zdHJ1aXJlIHVuIGluZGV4IHRlbXBvcmFpcmUgZm9uZMOpIHN1ciBsJ2luZm9ybWF0aW9uIGRlIGwnaW5kZXggZW1iYXJxdcOpIgogCi0jOiBhcHBseS5jOjQ5ODEgYnVpbHRpbi9jaGVja291dC1pbmRleC5jOjE3MyBidWlsdGluL2xzLWZpbGVzLmM6NTI0CisjOiBhcHBseS5jOjQ5OTMgYnVpbHRpbi9jaGVja291dC1pbmRleC5jOjE3MyBidWlsdGluL2xzLWZpbGVzLmM6NTI0CiBtc2dpZCAicGF0aHMgYXJlIHNlcGFyYXRlZCB3aXRoIE5VTCBjaGFyYWN0ZXIiCiBtc2dzdHIgImxlcyBjaGVtaW5zIHNvbnQgc8OpcGFyw6lzIHBhciB1biBjYXJhY3TDqHJlIE5VTCIKIAotIzogYXBwbHkuYzo0OTgzCisjOiBhcHBseS5jOjQ5OTUKIG1zZ2lkICJlbnN1cmUgYXQgbGVhc3QgPG4+IGxpbmVzIG9mIGNvbnRleHQgbWF0Y2giCiBtc2dzdHIgInMnYXNzdXJlciBkJ2F1IG1vaW5zIDxuPiBsaWduZXMgZGUgY29ycmVzcG9uZGFuY2UgZGUgY29udGV4dGUiCiAKLSM6IGFwcGx5LmM6NDk4NCBidWlsdGluL2FtLmM6MjE5NiBidWlsdGluL2ludGVycHJldC10cmFpbGVycy5jOjk4CisjOiBhcHBseS5jOjQ5OTYgYnVpbHRpbi9hbS5jOjIxODUgYnVpbHRpbi9pbnRlcnByZXQtdHJhaWxlcnMuYzo5OAogIzogYnVpbHRpbi9pbnRlcnByZXQtdHJhaWxlcnMuYzoxMDAgYnVpbHRpbi9pbnRlcnByZXQtdHJhaWxlcnMuYzoxMDIKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMzMCBidWlsdGluL3JlYmFzZS5jOjE0MjEKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMxMCBidWlsdGluL3JlYmFzZS5jOjE0NDUKIG1zZ2lkICJhY3Rpb24iCiBtc2dzdHIgImFjdGlvbiIKIAotIzogYXBwbHkuYzo0OTg1CisjOiBhcHBseS5jOjQ5OTcKIG1zZ2lkICJkZXRlY3QgbmV3IG9yIG1vZGlmaWVkIGxpbmVzIHRoYXQgaGF2ZSB3aGl0ZXNwYWNlIGVycm9ycyIKIG1zZ3N0ciAiIgogImTDqXRlY3RlciBkZXMgbGlnbmVzIG5vdXZlbGxlcyBvdSBtb2RpZmnDqWVzIHF1aSBjb250aWVubmVudCBkZXMgZXJyZXVycyAiCiAiZCdlc3BhY2UiCiAKLSM6IGFwcGx5LmM6NDk4OCBhcHBseS5jOjQ5OTEKKyM6IGFwcGx5LmM6NTAwMCBhcHBseS5jOjUwMDMKIG1zZ2lkICJpZ25vcmUgY2hhbmdlcyBpbiB3aGl0ZXNwYWNlIHdoZW4gZmluZGluZyBjb250ZXh0IgogbXNnc3RyICJpZ25vcmVyIGRlcyBtb2RpZmljYXRpb25zIGQnZXNwYWNlIGxvcnMgZGUgbGEgcmVjaGVyY2hlIGRlIGNvbnRleHRlIgogCi0jOiBhcHBseS5jOjQ5OTQKKyM6IGFwcGx5LmM6NTAwNgogbXNnaWQgImFwcGx5IHRoZSBwYXRjaCBpbiByZXZlcnNlIgogbXNnc3RyICJhcHBsaXF1ZXIgbGUgcGF0Y2ggZW4gc2VucyBpbnZlcnNlIgogCi0jOiBhcHBseS5jOjQ5OTYKKyM6IGFwcGx5LmM6NTAwOAogbXNnaWQgImRvbid0IGV4cGVjdCBhdCBsZWFzdCBvbmUgbGluZSBvZiBjb250ZXh0IgogbXNnc3RyICJuZSBwYXMgcydhdHRlbmRyZSDDoCBhdSBtb2lucyB1bmUgbGlnbmUgZGUgY29udGV4dGUiCiAKLSM6IGFwcGx5LmM6NDk5OAorIzogYXBwbHkuYzo1MDEwCiBtc2dpZCAibGVhdmUgdGhlIHJlamVjdGVkIGh1bmtzIGluIGNvcnJlc3BvbmRpbmcgKi5yZWogZmlsZXMiCiBtc2dzdHIgImxhaXNzZXIgbGVzIHNlY3Rpb25zIHJlamV0w6llcyBkYW5zIGxlcyBmaWNoaWVycyAqLnJlaiBjb3JyZXNwb25kYW50cyIKIAotIzogYXBwbHkuYzo1MDAwCisjOiBhcHBseS5jOjUwMTIKIG1zZ2lkICJhbGxvdyBvdmVybGFwcGluZyBodW5rcyIKIG1zZ3N0ciAiYWNjZXB0ZXIgbGVzIHJlY291dnJlbWVudHMgZGUgc2VjdGlvbnMiCiAKLSM6IGFwcGx5LmM6NTAwMSBidWlsdGluL2FkZC5jOjI5MSBidWlsdGluL2NoZWNrLWlnbm9yZS5jOjIyCisjOiBhcHBseS5jOjUwMTMgYnVpbHRpbi9hZGQuYzoyOTEgYnVpbHRpbi9jaGVjay1pZ25vcmUuYzoyMgogIzogYnVpbHRpbi9jb21taXQuYzoxMzM3IGJ1aWx0aW4vY291bnQtb2JqZWN0cy5jOjk4IGJ1aWx0aW4vZnNjay5jOjc4NgotIzogYnVpbHRpbi9sb2cuYzoyMDY4IGJ1aWx0aW4vbXYuYzoxMjMgYnVpbHRpbi9yZWFkLXRyZWUuYzoxMjgKKyM6IGJ1aWx0aW4vbG9nLmM6MjA4NSBidWlsdGluL212LmM6MTIzIGJ1aWx0aW4vcmVhZC10cmVlLmM6MTI4CiBtc2dpZCAiYmUgdmVyYm9zZSIKIG1zZ3N0ciAibW9kZSB2ZXJiZXV4IgogCi0jOiBhcHBseS5jOjUwMDMKKyM6IGFwcGx5LmM6NTAxNQogbXNnaWQgInRvbGVyYXRlIGluY29ycmVjdGx5IGRldGVjdGVkIG1pc3NpbmcgbmV3LWxpbmUgYXQgdGhlIGVuZCBvZiBmaWxlIgogbXNnc3RyICIiCiAidG9sw6lyZXIgZGVzIGVycmV1cnMgZGUgZMOpdGVjdGlvbiBkZSByZXRvdXJzIGNoYXJpb3QgbWFucXVhbnRzIGVuIGZpbiBkZSAiCiAiZmljaGllciIKIAotIzogYXBwbHkuYzo1MDA2CisjOiBhcHBseS5jOjUwMTgKIG1zZ2lkICJkbyBub3QgdHJ1c3QgdGhlIGxpbmUgY291bnRzIGluIHRoZSBodW5rIGhlYWRlcnMiCiBtc2dzdHIgIm5lIHBhcyBzZSBmaWVyIGF1IGNvbXB0ZSBkZSBsaWduZXMgZGFucyBsZXMgZW4tdMOqdGVzIGRlIHNlY3Rpb24iCiAKLSM6IGFwcGx5LmM6NTAwOCBidWlsdGluL2FtLmM6MjIwNQorIzogYXBwbHkuYzo1MDIwIGJ1aWx0aW4vYW0uYzoyMTk0CiBtc2dpZCAicm9vdCIKIG1zZ3N0ciAicmFjaW5lIgogCi0jOiBhcHBseS5jOjUwMDkKKyM6IGFwcGx5LmM6NTAyMQogbXNnaWQgInByZXBlbmQgPHJvb3Q+IHRvIGFsbCBmaWxlbmFtZXMiCiBtc2dzdHIgInByw6lmaXhlciB0b3VzIGxlcyBub21zIGRlIGZpY2hpZXIgYXZlYyA8cm9vdD4iCiAKQEAgLTg5Niw3ICs4OTYsNyBAQAogbXNnaWQgImFyY2hpdmUgZm9ybWF0IgogbXNnc3RyICJmb3JtYXQgZCdhcmNoaXZlIgogCi0jOiBhcmNoaXZlLmM6NDU4IGJ1aWx0aW4vbG9nLmM6MTU4MAorIzogYXJjaGl2ZS5jOjQ1OCBidWlsdGluL2xvZy5jOjE1ODEKIG1zZ2lkICJwcmVmaXgiCiBtc2dzdHIgInByw6lmaXhlIgogCkBAIC05MDQsMTEgKzkwNCwxMiBAQAogbXNnaWQgInByZXBlbmQgcHJlZml4IHRvIGVhY2ggcGF0aG5hbWUgaW4gdGhlIGFyY2hpdmUiCiBtc2dzdHIgInByw6lmaXhlciBjaGFxdWUgY2hlbWluIGRlIGZpY2hpZXIgZGFucyBsJ2FyY2hpdmUiCiAKLSM6IGFyY2hpdmUuYzo0NjAgYnVpbHRpbi9ibGFtZS5jOjg2MiBidWlsdGluL2JsYW1lLmM6ODc0IGJ1aWx0aW4vYmxhbWUuYzo4NzUKLSM6IGJ1aWx0aW4vY29tbWl0LXRyZWUuYzoxMTcgYnVpbHRpbi9jb25maWcuYzoxMjkgYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExMzQKLSM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTM2IGJ1aWx0aW4vZ3JlcC5jOjg5NyBidWlsdGluL2hhc2gtb2JqZWN0LmM6MTA1Ci0jOiBidWlsdGluL2xzLWZpbGVzLmM6NTYwIGJ1aWx0aW4vbHMtZmlsZXMuYzo1NjMgYnVpbHRpbi9ub3Rlcy5jOjQxMgotIzogYnVpbHRpbi9ub3Rlcy5jOjU3OCBidWlsdGluL3JlYWQtdHJlZS5jOjEyMyBwYXJzZS1vcHRpb25zLmg6MTc3CisjOiBhcmNoaXZlLmM6NDYwIGJ1aWx0aW4vYmxhbWUuYzo4NjEgYnVpbHRpbi9ibGFtZS5jOjg3MyBidWlsdGluL2JsYW1lLmM6ODc0CisjOiBidWlsdGluL2NvbW1pdC10cmVlLmM6MTE3IGJ1aWx0aW4vY29uZmlnLmM6MTI5IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTYyCisjOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE2NCBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE2OCBidWlsdGluL2dyZXAuYzo4OTkKKyM6IGJ1aWx0aW4vaGFzaC1vYmplY3QuYzoxMDUgYnVpbHRpbi9scy1maWxlcy5jOjU2MCBidWlsdGluL2xzLWZpbGVzLmM6NTYzCisjOiBidWlsdGluL25vdGVzLmM6NDEyIGJ1aWx0aW4vbm90ZXMuYzo1NzggYnVpbHRpbi9yZWFkLXRyZWUuYzoxMjMKKyM6IHBhcnNlLW9wdGlvbnMuaDoxODYKIG1zZ2lkICJmaWxlIgogbXNnc3RyICJmaWNoaWVyIgogCkBAIC05NDAsNyArOTQxLDcgQEAKIG1zZ2lkICJsaXN0IHN1cHBvcnRlZCBhcmNoaXZlIGZvcm1hdHMiCiBtc2dzdHIgImFmZmljaGVyIGxlcyBmb3JtYXRzIGQnYXJjaGl2ZSBzdXBwb3J0w6lzIgogCi0jOiBhcmNoaXZlLmM6NDc5IGJ1aWx0aW4vYXJjaGl2ZS5jOjkxIGJ1aWx0aW4vY2xvbmUuYzoxMTMgYnVpbHRpbi9jbG9uZS5jOjExNgorIzogYXJjaGl2ZS5jOjQ3OSBidWlsdGluL2FyY2hpdmUuYzo5MSBidWlsdGluL2Nsb25lLmM6MTEyIGJ1aWx0aW4vY2xvbmUuYzoxMTUKICM6IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxMzc5IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxODU5CiBtc2dpZCAicmVwbyIKIG1zZ3N0ciAiZMOpcMO0dCIKQEAgLTk0OSw3ICs5NTAsNyBAQAogbXNnaWQgInJldHJpZXZlIHRoZSBhcmNoaXZlIGZyb20gcmVtb3RlIHJlcG9zaXRvcnkgPHJlcG8+IgogbXNnc3RyICJyw6ljdXDDqXJlciBsJ2FyY2hpdmUgZGVwdWlzIGxlIGTDqXDDtHQgZGlzdGFudCA8ZMOpcMO0dD4iCiAKLSM6IGFyY2hpdmUuYzo0ODEgYnVpbHRpbi9hcmNoaXZlLmM6OTMgYnVpbHRpbi9kaWZmdG9vbC5jOjcwNworIzogYXJjaGl2ZS5jOjQ4MSBidWlsdGluL2FyY2hpdmUuYzo5MyBidWlsdGluL2RpZmZ0b29sLmM6NzE1CiAjOiBidWlsdGluL25vdGVzLmM6NDk4CiBtc2dpZCAiY29tbWFuZCIKIG1zZ3N0ciAiY29tbWFuZGUiCkBAIC05ODUsMjYgKzk4NiwyNiBAQAogbXNnaWQgImNhbm5vdCBzdHJlYW0gYmxvYiAlcyIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkZSB0cmFuc21ldHRyZSBsZSBibG9iICVzIGVuIGZsdXgiCiAKLSM6IGFyY2hpdmUtdGFyLmM6MjYwIGFyY2hpdmUtemlwLmM6MzYzCisjOiBhcmNoaXZlLXRhci5jOjI2NiBhcmNoaXZlLXppcC5jOjM2MwogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bnN1cHBvcnRlZCBmaWxlIG1vZGU6IDAlbyAoU0hBMTogJXMpIgogbXNnc3RyICJtb2RlIGRlIGZpY2hpZXIgbm9uIHN1cHBvcnTDqcKgOjAlbyAoU0hBMTogJXMpIgogCi0jOiBhcmNoaXZlLXRhci5jOjI4NyBhcmNoaXZlLXppcC5jOjM1MworIzogYXJjaGl2ZS10YXIuYzoyOTMgYXJjaGl2ZS16aXAuYzozNTMKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IHJlYWQgJXMiCiBtc2dzdHIgImltcG9zc2libGUgZGUgbGlyZSAlcyIKIAotIzogYXJjaGl2ZS10YXIuYzo0NTkKKyM6IGFyY2hpdmUtdGFyLmM6NDY1CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBzdGFydCAnJXMnIGZpbHRlciIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkZSBkw6ltYXJyZXIgbGUgZmlsdHJlICclcyciCiAKLSM6IGFyY2hpdmUtdGFyLmM6NDYyCisjOiBhcmNoaXZlLXRhci5jOjQ2OAogbXNnaWQgInVuYWJsZSB0byByZWRpcmVjdCBkZXNjcmlwdG9yIgogbXNnc3RyICJpbXBvc3NpYmxlIGRlIHJlZGlyaWdlciB1biBkZXNjcmlwdGV1ciIKIAotIzogYXJjaGl2ZS10YXIuYzo0NjkKKyM6IGFyY2hpdmUtdGFyLmM6NDc1CiAjLCBjLWZvcm1hdAogbXNnaWQgIiclcycgZmlsdGVyIHJlcG9ydGVkIGVycm9yIgogbXNnc3RyICJsZSBmaWx0cmUgJyVzJyBhIHJldG91cm7DqSB1bmUgZXJyZXVyIgpAQCAtMTAyOSwxNyArMTAzMCwxNyBAQAogbXNnaWQgInRpbWVzdGFtcCB0b28gbGFyZ2UgZm9yIHRoaXMgc3lzdGVtOiAlPFBSSXVNQVg+IgogbXNnc3RyICJsJ2hvcm9kYXRhZ2UgZXN0IHRyb3AgZ3JhbmQgcG91ciBjZSBzeXN0w6htZcKgOiAlPFBSSXVNQVg+IgogCi0jOiBhdHRyLmM6MjExCisjOiBhdHRyLmM6MjEzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiUuKnMgaXMgbm90IGEgdmFsaWQgYXR0cmlidXRlIG5hbWUiCiBtc2dzdHIgIiUuKnMgbidlc3QgcGFzIHVuIG5vbSB2YWxpZGUgZCdhdHRyaWJ1dCIKIAotIzogYXR0ci5jOjM2OAorIzogYXR0ci5jOjM3MAogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyBub3QgYWxsb3dlZDogJXM6JWQiCiBtc2dzdHIgIiVzIG5vbiBwZXJtaXMgOiAlcyA6ICVkIgogCi0jOiBhdHRyLmM6NDA4CisjOiBhdHRyLmM6NDEwCiBtc2dpZCAiIgogIk5lZ2F0aXZlIHBhdHRlcm5zIGFyZSBpZ25vcmVkIGluIGdpdCBhdHRyaWJ1dGVzXG4iCiAiVXNlICdcXCEnIGZvciBsaXRlcmFsIGxlYWRpbmcgZXhjbGFtYXRpb24uIgpAQCAtMTE2Nyw0MSArMTE2OCw0MSBAQAogbXNnc3RyWzBdICJCaXNzZWN0aW9uwqA6ICVkIHLDqXZpc2lvbiDDoCB0ZXN0ZXIgYXByw6hzIGNlY2kgJXNcbiIKIG1zZ3N0clsxXSAiQmlzc2VjdGlvbsKgOiAlZCByw6l2aXNpb25zIMOgIHRlc3RlciBhcHLDqHMgY2VjaSAlc1xuIgogCi0jOiBibGFtZS5jOjI2OTcKKyM6IGJsYW1lLmM6MjcwMAogbXNnaWQgIi0tY29udGVudHMgYW5kIC0tcmV2ZXJzZSBkbyBub3QgYmxlbmQgd2VsbC4iCiBtc2dzdHIgIi0tY29udGVudHMgZXQgLS1yZXZlcnNlIG5lIGZvbnQgcGFzIGJvbiBtw6luYWdlLiIKIAotIzogYmxhbWUuYzoyNzExCisjOiBibGFtZS5jOjI3MTQKIG1zZ2lkICJjYW5ub3QgdXNlIC0tY29udGVudHMgd2l0aCBmaW5hbCBjb21taXQgb2JqZWN0IG5hbWUiCiBtc2dzdHIgIm9uIG5lIHBldXQgcGFzIHV0aWxpc2VyIC0tY29udGVudHMgYXZlYyB1biBub20gZCdvYmpldCBjb21taXQgZmluYWwiCiAKLSM6IGJsYW1lLmM6MjczMgorIzogYmxhbWUuYzoyNzM1CiBtc2dpZCAiLS1yZXZlcnNlIGFuZCAtLWZpcnN0LXBhcmVudCB0b2dldGhlciByZXF1aXJlIHNwZWNpZmllZCBsYXRlc3QgY29tbWl0IgogbXNnc3RyICIiCiAiLS1yZXZlcnNlIGV0IC0tZmlyc3QtcGFyZW50IGVuc2VtYmxlIG7DqWNlc3NpdGVudCBsYSBzcMOpY2lmaWNhdGlvbiBkJ3VuICIKICJkZXJuaWVyIGNvbW1pdCIKIAotIzogYmxhbWUuYzoyNzQxIGJ1bmRsZS5jOjE2NyByZWYtZmlsdGVyLmM6MjE5NiByZW1vdGUuYzoxOTM4IHNlcXVlbmNlci5jOjIwMzMKLSM6IHNlcXVlbmNlci5jOjQzNDggYnVpbHRpbi9jb21taXQuYzoxMDIwIGJ1aWx0aW4vbG9nLmM6Mzg3IGJ1aWx0aW4vbG9nLmM6OTYzCi0jOiBidWlsdGluL2xvZy5jOjE0NTEgYnVpbHRpbi9sb2cuYzoxODI3IGJ1aWx0aW4vbG9nLmM6MjExNyBidWlsdGluL21lcmdlLmM6NDExCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMxNDggYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMTYzCisjOiBibGFtZS5jOjI3NDQgYnVuZGxlLmM6MTY3IHJlZi1maWx0ZXIuYzoyMjAzIHJlbW90ZS5jOjE5NDEgc2VxdWVuY2VyLmM6MTk3MQorIzogc2VxdWVuY2VyLmM6NDMwNSBidWlsdGluL2NvbW1pdC5jOjEwMjAgYnVpbHRpbi9sb2cuYzozODcgYnVpbHRpbi9sb2cuYzo5NjQKKyM6IGJ1aWx0aW4vbG9nLmM6MTQ1MiBidWlsdGluL2xvZy5jOjE4NDQgYnVpbHRpbi9sb2cuYzoyMTM0IGJ1aWx0aW4vbWVyZ2UuYzo0MTEKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzEyOCBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMxNDMKICM6IGJ1aWx0aW4vc2hvcnRsb2cuYzoxOTIKIG1zZ2lkICJyZXZpc2lvbiB3YWxrIHNldHVwIGZhaWxlZCIKIG1zZ3N0ciAiw6ljaGVjIGRlIGxhIHByw6lwYXJhdGlvbiBkdSBwYXJjb3VycyBkZXMgcsOpdmlzaW9ucyIKIAotIzogYmxhbWUuYzoyNzU5CisjOiBibGFtZS5jOjI3NjIKIG1zZ2lkICIiCiAiLS1yZXZlcnNlIC0tZmlyc3QtcGFyZW50IHRvZ2V0aGVyIHJlcXVpcmUgcmFuZ2UgYWxvbmcgZmlyc3QtcGFyZW50IGNoYWluIgogbXNnc3RyICIiCiAiLS1yZXZlcnNlIC0tZmlyc3QtcGFyZW50IGVuc2VtYmxlIG7DqWNlc3NpdGVudCB1bmUgcG9ydMOpZSBhdmVjIGxhIGNoYcOubmUgZGUgIgogInByZW1pZXIgcGFyZW50IgogCi0jOiBibGFtZS5jOjI3NzAKKyM6IGJsYW1lLmM6Mjc3MwogIywgYy1mb3JtYXQKIG1zZ2lkICJubyBzdWNoIHBhdGggJXMgaW4gJXMiCiBtc2dzdHIgInBhcyBkZSBjaGVtaW4gJXMgZGFucyAlcyIKIAotIzogYmxhbWUuYzoyNzgxCisjOiBibGFtZS5jOjI3ODQKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IHJlYWQgYmxvYiAlcyBmb3IgcGF0aCAlcyIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkZSBsaXJlIGxlIGJsb2IgJXMgIHBvdXIgbGUgY2hlbWluICVzIgpAQCAtMTM2NCw3ICsxMzY1LDcgQEAKIG1zZ2lkICJ1bnJlY29nbml6ZWQgaGVhZGVyOiAlcyVzICglZCkiCiBtc2dzdHIgImVuLXTDqnRlIG5vbiByZWNvbm51IDogJXMlcyAoJWQpIgogCi0jOiBidW5kbGUuYzo5MCByZXJlcmUuYzo0ODAgcmVyZXJlLmM6NjkwIHNlcXVlbmNlci5jOjIyODMgc2VxdWVuY2VyLmM6MzAyNAorIzogYnVuZGxlLmM6OTAgcmVyZXJlLmM6NDgwIHJlcmVyZS5jOjY5MCBzZXF1ZW5jZXIuYzoyMjIxIHNlcXVlbmNlci5jOjI5NjIKICM6IGJ1aWx0aW4vY29tbWl0LmM6NzkxCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBvcGVuICclcyciCkBAIC0xNDE3LDcgKzE0MTgsNyBAQAogbXNnaWQgInJlZiAnJXMnIGlzIGV4Y2x1ZGVkIGJ5IHRoZSByZXYtbGlzdCBvcHRpb25zIgogbXNnc3RyICJsYSByw6lmw6lyZW5jZSAnJXMnIGVzdCBleGNsdWUgcGFyIGxlcyBvcHRpb25zIGRlIHJldi1saXN0IgogCi0jOiBidW5kbGUuYzo0NjAgYnVpbHRpbi9sb2cuYzoyMDIgYnVpbHRpbi9sb2cuYzoxNzMyIGJ1aWx0aW4vc2hvcnRsb2cuYzozMDYKKyM6IGJ1bmRsZS5jOjQ2MCBidWlsdGluL2xvZy5jOjIwMiBidWlsdGluL2xvZy5jOjE3MzMgYnVpbHRpbi9zaG9ydGxvZy5jOjMwNgogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bnJlY29nbml6ZWQgYXJndW1lbnQ6ICVzIgogbXNnc3RyICJhcmd1bWVudCBub24gcmVjb25udSA6ICVzIgpAQCAtMTQ0MCw4ICsxNDQxLDggQEAKIG1zZ2lkICJpbnZhbGlkIGNvbG9yIHZhbHVlOiAlLipzIgogbXNnc3RyICJWYWxldXIgaW52YWxpZGUgZGUgY291bGV1ciA6ICUuKnMiCiAKLSM6IGNvbW1pdC5jOjUwIHNlcXVlbmNlci5jOjI3MjcgYnVpbHRpbi9hbS5jOjM1NSBidWlsdGluL2FtLmM6Mzk5Ci0jOiBidWlsdGluL2FtLmM6MTM3OCBidWlsdGluL2FtLmM6MjAyMCBidWlsdGluL3JlcGxhY2UuYzo0NTUKKyM6IGNvbW1pdC5jOjUwIHNlcXVlbmNlci5jOjI2NjUgYnVpbHRpbi9hbS5jOjM1NCBidWlsdGluL2FtLmM6Mzk4CisjOiBidWlsdGluL2FtLmM6MTM2NiBidWlsdGluL2FtLmM6MjAwOSBidWlsdGluL3JlcGxhY2UuYzo0NTYKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHBhcnNlICVzIgogbXNnc3RyICJpbXBvc3NpYmxlIGQnYW5hbHlzZXIgJXMiCkBAIC0xNDcxLDI3ICsxNDcyLDI3IEBACiAiU3VwcHJpbWV6IGNlIG1lc3NhZ2UgZW4gbGFuw6dhbnRcbiIKICJcImdpdCBjb25maWcgYWR2aWNlLmdyYWZ0RmlsZURlcHJlY2F0ZWQgZmFsc2VcIiIKIAotIzogY29tbWl0LmM6MTEyNworIzogY29tbWl0LmM6MTEyOAogIywgYy1mb3JtYXQKIG1zZ2lkICJDb21taXQgJXMgaGFzIGFuIHVudHJ1c3RlZCBHUEcgc2lnbmF0dXJlLCBhbGxlZ2VkbHkgYnkgJXMuIgogbXNnc3RyICJMYSB2YWxpZGF0aW9uICVzIGEgdW5lIHNpZ25hdHVyZSBHUEcgbm9uIGZpYWJsZSwgcHLDqXRlbmR1bWVudCBwYXIgJXMuIgogCi0jOiBjb21taXQuYzoxMTMwCisjOiBjb21taXQuYzoxMTMxCiAjLCBjLWZvcm1hdAogbXNnaWQgIkNvbW1pdCAlcyBoYXMgYSBiYWQgR1BHIHNpZ25hdHVyZSBhbGxlZ2VkbHkgYnkgJXMuIgogbXNnc3RyICJMYSB2YWxpZGF0aW9uICVzIGEgdW5lIG1hdXZhaXNlIHNpZ25hdHVyZSBHUEcgcHLDqXRlbmR1bWVudCBwYXIgJXMuIgogCi0jOiBjb21taXQuYzoxMTMzCisjOiBjb21taXQuYzoxMTM0CiAjLCBjLWZvcm1hdAogbXNnaWQgIkNvbW1pdCAlcyBkb2VzIG5vdCBoYXZlIGEgR1BHIHNpZ25hdHVyZS4iCiBtc2dzdHIgIkxhIHZhbGlkYXRpb24gJXMgbidhIHBhcyBkZSBzaWduYXR1cmUgR1BHLiIKIAotIzogY29tbWl0LmM6MTEzNgorIzogY29tbWl0LmM6MTEzNwogIywgYy1mb3JtYXQKIG1zZ2lkICJDb21taXQgJXMgaGFzIGEgZ29vZCBHUEcgc2lnbmF0dXJlIGJ5ICVzXG4iCiBtc2dzdHIgIkxhIHZhbGlkYXRpb24gJXMgYSB1bmUgc2lnbmF0dXJlIEdQRyBjb3JyZWN0ZSBwYXIgJXNcbiIKIAotIzogY29tbWl0LmM6MTM5MAorIzogY29tbWl0LmM6MTM5MQogbXNnaWQgIiIKICJXYXJuaW5nOiBjb21taXQgbWVzc2FnZSBkaWQgbm90IGNvbmZvcm0gdG8gVVRGLTguXG4iCiAiWW91IG1heSB3YW50IHRvIGFtZW5kIGl0IGFmdGVyIGZpeGluZyB0aGUgbWVzc2FnZSwgb3Igc2V0IHRoZSBjb25maWdcbiIKQEAgLTE1NTksMTg5ICsxNTYwLDIwNCBAQAogbXNnaWQgInVuYWJsZSB0byBmaW5kIGFsbCBjb21taXQtZ3JhcGggZmlsZXMiCiBtc2dzdHIgImltcG9zc2libGUgZGUgdHJvdXZlciB0b3VzIGxlcyBmaWNoaWVycyBkdSBncmFwaGUgZGUgY29tbWl0IgogCi0jOiBjb21taXQtZ3JhcGguYzo1NTQgY29tbWl0LWdyYXBoLmM6NjE0CisjOiBjb21taXQtZ3JhcGguYzo1NjEgY29tbWl0LWdyYXBoLmM6NjIxCiBtc2dpZCAiaW52YWxpZCBjb21taXQgcG9zaXRpb24uIGNvbW1pdC1ncmFwaCBpcyBsaWtlbHkgY29ycnVwdCIKIG1zZ3N0ciAiIgogInBvc2l0aW9uIGRlIGNvbW1pdCBpbnZhbGlkZS4gTGUgZ3JhcGhlIGRlIGNvbW1pdCBlc3QgdnJhaXNlbWJsYWJsZW1lbnQgIgogImNvcnJvbXB1IgogCi0jOiBjb21taXQtZ3JhcGguYzo1NzUKKyM6IGNvbW1pdC1ncmFwaC5jOjU4MgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgZmluZCBjb21taXQgJXMiCiBtc2dzdHIgImltcG9zc2libGUgZGUgdHJvdXZlciBsZSBjb21taXQgJXMiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjEwMDIgYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNjU3CisjOiBjb21taXQtZ3JhcGguYzo4NTUgYnVpbHRpbi9hbS5jOjEyODcKKyMsIGMtZm9ybWF0Cittc2dpZCAidW5hYmxlIHRvIHBhcnNlIGNvbW1pdCAlcyIKK21zZ3N0ciAiaW1wb3NzaWJsZSBkJ2FuYWx5c2VyIGxlIGNvbW1pdCAlcyIKKworIzogY29tbWl0LWdyYXBoLmM6ODU5CisjLCBjLWZvcm1hdAorbXNnaWQgInVuYWJsZSB0byBnZXQgdHJlZSBmb3IgJXMiCittc2dzdHIgImltcG9zc2libGUgZGUgcsOpY3Vww6lyZXIgbCdhcmJyZSBkZSAlcyIKKworIzogY29tbWl0LWdyYXBoLmM6MTAxNyBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI2NDEKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGdldCB0eXBlIG9mIG9iamVjdCAlcyIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkJ29idGVuaXIgbGUgdHlwZSBkZSBsJ29iamV0ICVzIgogCi0jOiBjb21taXQtZ3JhcGguYzoxMDM0CisjOiBjb21taXQtZ3JhcGguYzoxMDQ5CiBtc2dpZCAiTG9hZGluZyBrbm93biBjb21taXRzIGluIGNvbW1pdCBncmFwaCIKIG1zZ3N0ciAiTGVjdHVyZSBkZXMgY29tbWl0cyBjb25udXMgZGFucyB1biBncmFwaGUgZGUgY29tbWl0IgogCi0jOiBjb21taXQtZ3JhcGguYzoxMDUxCisjOiBjb21taXQtZ3JhcGguYzoxMDY2CiBtc2dpZCAiRXhwYW5kaW5nIHJlYWNoYWJsZSBjb21taXRzIGluIGNvbW1pdCBncmFwaCIKIG1zZ3N0ciAiRXhwYW5zaW9uIGRlcyBjb21taXRzIGpvaWduYWJsZXMgZGFucyB1biBncmFwaGUgZGUgY29tbWl0IgogCi0jOiBjb21taXQtZ3JhcGguYzoxMDcwCisjOiBjb21taXQtZ3JhcGguYzoxMDg1CiBtc2dpZCAiQ2xlYXJpbmcgY29tbWl0IG1hcmtzIGluIGNvbW1pdCBncmFwaCIKIG1zZ3N0ciAiU3VwcHJlc3Npb24gbGVzIG1hcnF1ZXMgZGUgY29tbWl0IGRhbnMgbGUgZ3JhcGhlIGRlIGNvbW1pdHMiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjEwODkKKyM6IGNvbW1pdC1ncmFwaC5jOjExMDQKIG1zZ2lkICJDb21wdXRpbmcgY29tbWl0IGdyYXBoIGdlbmVyYXRpb24gbnVtYmVycyIKIG1zZ3N0ciAiQ2FsY3VsIGRlcyBjaGlmZnJlcyBkZSBnw6luw6lyYXRpb24gZHUgZ3JhcGhlIGRlIGNvbW1pdHMiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjExNjMKKyM6IGNvbW1pdC1ncmFwaC5jOjExNzkKICMsIGMtZm9ybWF0CiBtc2dpZCAiRmluZGluZyBjb21taXRzIGZvciBjb21taXQgZ3JhcGggaW4gJWQgcGFjayIKIG1zZ2lkX3BsdXJhbCAiRmluZGluZyBjb21taXRzIGZvciBjb21taXQgZ3JhcGggaW4gJWQgcGFja3MiCiBtc2dzdHJbMF0gIlJlY2hlcmNoZSBkZSBjb21taXRzIHBvdXIgdW4gZ3JhcGhlIGRlIGNvbW1pdHMgZGFucyAlZCBwYXF1ZXQiCiBtc2dzdHJbMV0gIlJlY2hlcmNoZSBkZSBjb21taXRzIHBvdXIgdW4gZ3JhcGhlIGRlIGNvbW1pdHMgZGFucyAlZCBwYXF1ZXRzIgogCi0jOiBjb21taXQtZ3JhcGguYzoxMTc2CisjOiBjb21taXQtZ3JhcGguYzoxMTkyCiAjLCBjLWZvcm1hdAogbXNnaWQgImVycm9yIGFkZGluZyBwYWNrICVzIgogbXNnc3RyICJlcnJldXIgw6AgbCdham91dCBkdSBwYWNrZXQgJXMiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjExODAKKyM6IGNvbW1pdC1ncmFwaC5jOjExOTYKICMsIGMtZm9ybWF0CiBtc2dpZCAiZXJyb3Igb3BlbmluZyBpbmRleCBmb3IgJXMiCiBtc2dzdHIgImVycmV1ciDDoCBsJ291dmVydHVyZSBkZSBsJ2luZGV4IHBvdXIgJXMiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjEyMDQKKyM6IGNvbW1pdC1ncmFwaC5jOjEyMjAKICMsIGMtZm9ybWF0CiBtc2dpZCAiRmluZGluZyBjb21taXRzIGZvciBjb21taXQgZ3JhcGggZnJvbSAlZCByZWYiCiBtc2dpZF9wbHVyYWwgIkZpbmRpbmcgY29tbWl0cyBmb3IgY29tbWl0IGdyYXBoIGZyb20gJWQgcmVmcyIKIG1zZ3N0clswXSAiUmVjaGVyY2hlIGRlIGNvbW1pdHMgcG91ciB1biBncmFwaGUgZGUgY29tbWl0cyBkZXB1aXMgJWQgcsOpZiIKIG1zZ3N0clsxXSAiUmVjaGVyY2hlIGRlIGNvbW1pdHMgcG91ciB1biBncmFwaGUgZGUgY29tbWl0cyBkZXB1aXMgJWQgcsOpZnMiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjEyMzgKKyM6IGNvbW1pdC1ncmFwaC5jOjEyNDAKKyMsIGMtZm9ybWF0Cittc2dpZCAiaW52YWxpZCBjb21taXQgb2JqZWN0IGlkOiAlcyIKK21zZ3N0ciAiaWRlbnRpZmlhbnQgZCdvYmpldCBjb21taXQgaW52YWxpZGUgOiAlcyIKKworIzogY29tbWl0LWdyYXBoLmM6MTI1NQogbXNnaWQgIkZpbmRpbmcgY29tbWl0cyBmb3IgY29tbWl0IGdyYXBoIGFtb25nIHBhY2tlZCBvYmplY3RzIgogbXNnc3RyICIiCiAiUmVjaGVyY2hlIGRlIGNvbW1pdHMgcG91ciB1biBncmFwaGUgZGUgY29tbWl0cyBwYXJtaSBsZXMgb2JqZXRzIGVtcGFxdWV0w6lzIgogCi0jOiBjb21taXQtZ3JhcGguYzoxMjUzCisjOiBjb21taXQtZ3JhcGguYzoxMjcwCiBtc2dpZCAiQ291bnRpbmcgZGlzdGluY3QgY29tbWl0cyBpbiBjb21taXQgZ3JhcGgiCiBtc2dzdHIgIkNvbXB0YWdlIGRlcyBjb21taXRzIGRpc3RpbmN0cyBkYW5zIHVuIGdyYXBoZSBkZSBjb21taXQiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjEyODQKKyM6IGNvbW1pdC1ncmFwaC5jOjEzMDAKIG1zZ2lkICJGaW5kaW5nIGV4dHJhIGVkZ2VzIGluIGNvbW1pdCBncmFwaCIKIG1zZ3N0ciAiUmVjaGVyY2hlIGQnYXLDqnRlcyBzdXBwbMOpbWVudGFpcmVzIGRhbnMgdW4gZ3JhcGhlIGRlIGNvbW1pdHMiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjEzMzIKKyM6IGNvbW1pdC1ncmFwaC5jOjEzNDYKIG1zZ2lkICJmYWlsZWQgdG8gd3JpdGUgY29ycmVjdCBudW1iZXIgb2YgYmFzZSBncmFwaCBpZHMiCiBtc2dzdHIgIsOpY2hlYyDDoCBsJ8OpY3JpdHVyZSBsZSBub21icmUgY29ycmVjdCBkJ2lkIGRlIGJhc2UgZGUgZnVzaW9uIgogCi0jOiBjb21taXQtZ3JhcGguYzoxMzY1IG1pZHguYzo4MTEKKyM6IGNvbW1pdC1ncmFwaC5jOjEzNzkgbWlkeC5jOjgxMAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gY3JlYXRlIGxlYWRpbmcgZGlyZWN0b3JpZXMgb2YgJXMiCiBtc2dzdHIgImltcG9zc2libGUgZGUgY3LDqWVyIGxlcyByw6lwZXJ0b2lyZXMgZGUgcHJlbWllciBuaXZlYXUgZGUgJXMiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjEzNzcgYnVpbHRpbi9pbmRleC1wYWNrLmM6MzA2IGJ1aWx0aW4vcmVwYWNrLmM6MjQwCisjOiBjb21taXQtZ3JhcGguYzoxMzkxIGJ1aWx0aW4vaW5kZXgtcGFjay5jOjMwNiBidWlsdGluL3JlcGFjay5jOjI0MQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gY3JlYXRlICclcyciCiBtc2dzdHIgImltcG9zc2libGUgZGUgY3LDqWVyICclcyciCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjE0MzcKKyM6IGNvbW1pdC1ncmFwaC5jOjE0NTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiV3JpdGluZyBvdXQgY29tbWl0IGdyYXBoIGluICVkIHBhc3MiCiBtc2dpZF9wbHVyYWwgIldyaXRpbmcgb3V0IGNvbW1pdCBncmFwaCBpbiAlZCBwYXNzZXMiCiBtc2dzdHJbMF0gIsOJY3JpdHVyZSBsZSBncmFwaGUgZGUgY29tbWl0cyBlbiAlZCBwYXNzZSIKIG1zZ3N0clsxXSAiw4ljcml0dXJlIGxlIGdyYXBoZSBkZSBjb21taXRzIGVuICVkIHBhc3NlcyIKIAotIzogY29tbWl0LWdyYXBoLmM6MTQ3OAorIzogY29tbWl0LWdyYXBoLmM6MTQ5MgogbXNnaWQgInVuYWJsZSB0byBvcGVuIGNvbW1pdC1ncmFwaCBjaGFpbiBmaWxlIgogbXNnc3RyICJpbXBvc3NpYmxlIGQnb3V2cmlyIGxlIGZpY2hpZXIgZGUgZ3JhcGhlIGRlIGNvbW1pdCIKIAotIzogY29tbWl0LWdyYXBoLmM6MTQ5MAorIzogY29tbWl0LWdyYXBoLmM6MTUwNAogbXNnaWQgImZhaWxlZCB0byByZW5hbWUgYmFzZSBjb21taXQtZ3JhcGggZmlsZSIKIG1zZ3N0ciAiw6ljaGVjIGR1IHJlbm9tbWFnZSBkdSBmaWNoaWVyIGRlIGdyYXBoZSBkZSBjb21taXRzIgogCi0jOiBjb21taXQtZ3JhcGguYzoxNTEwCisjOiBjb21taXQtZ3JhcGguYzoxNTI0CiBtc2dpZCAiZmFpbGVkIHRvIHJlbmFtZSB0ZW1wb3JhcnkgY29tbWl0LWdyYXBoIGZpbGUiCiBtc2dzdHIgImltcG9zc2libGUgZGUgcmVub21tZXIgbGUgZmljaGllciB0ZW1wb3JhaXJlIGRlIGdyYXBoZSBkZSBjb21taXRzIgogCi0jOiBjb21taXQtZ3JhcGguYzoxNjIxCisjOiBjb21taXQtZ3JhcGguYzoxNjM1CiBtc2dpZCAiU2Nhbm5pbmcgbWVyZ2VkIGNvbW1pdHMiCiBtc2dzdHIgIkFuYWx5c2UgZGVzIGNvbW1pdHMgZGUgZnVzaW9uIgogCi0jOiBjb21taXQtZ3JhcGguYzoxNjMyCisjOiBjb21taXQtZ3JhcGguYzoxNjQ2CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuZXhwZWN0ZWQgZHVwbGljYXRlIGNvbW1pdCBpZCAlcyIKIG1zZ3N0ciAiaWQgZGUgY29tbWl0ICVzIGR1cGxpcXXDqSBpbmF0dGVuZHUiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjE2NTcKKyM6IGNvbW1pdC1ncmFwaC5jOjE2NzAKIG1zZ2lkICJNZXJnaW5nIGNvbW1pdC1ncmFwaCIKIG1zZ3N0ciAiZnVzaW9uIGR1IGdyYXBoZSBkZSBjb21taXRzIgogCi0jOiBjb21taXQtZ3JhcGguYzoxODQ0CisjOiBjb21taXQtZ3JhcGguYzoxODYwCiAjLCBjLWZvcm1hdAogbXNnaWQgInRoZSBjb21taXQgZ3JhcGggZm9ybWF0IGNhbm5vdCB3cml0ZSAlZCBjb21taXRzIgogbXNnc3RyICJsZSBncmFwaGUgZGUgY29tbWl0cyBuZSBwZXV0IHBhcyDDqWNyaXJlICVkIGNvbW1pdHMiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjE4NTUKKyM6IGNvbW1pdC1ncmFwaC5jOjE4NzEKIG1zZ2lkICJ0b28gbWFueSBjb21taXRzIHRvIHdyaXRlIGdyYXBoIgogbXNnc3RyICJ0cm9wIGRlIGNvbW1pdHMgcG91ciDDqWNyaXJlIHVuIGdyYXBoZSIKIAotIzogY29tbWl0LWdyYXBoLmM6MTk0NQorIzogY29tbWl0LWdyYXBoLmM6MTk2MQogbXNnaWQgInRoZSBjb21taXQtZ3JhcGggZmlsZSBoYXMgaW5jb3JyZWN0IGNoZWNrc3VtIGFuZCBpcyBsaWtlbHkgY29ycnVwdCIKIG1zZ3N0ciAiIgogImxlIGdyYXBoZSBkZSBjb21taXQgYSB1bmUgc29tbWUgZGUgY29udHLDtGxlIGluY29ycmVjdGUgZXQgZXN0ICIKICJ2cmFpc2VtYmxhYmxlbWVudCBjb3Jyb21wdSIKIAotIzogY29tbWl0LWdyYXBoLmM6MTk1NQorIzogY29tbWl0LWdyYXBoLmM6MTk3MQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb21taXQtZ3JhcGggaGFzIGluY29ycmVjdCBPSUQgb3JkZXI6ICVzIHRoZW4gJXMiCiBtc2dzdHIgImxlIGdyYXBoZSBkZSBjb21taXQgYSB1biBvcmRyZSBkJ09JRCBpbmNvcnJlY3TCoDogJXMgcHVpcyAlcyIKIAotIzogY29tbWl0LWdyYXBoLmM6MTk2NSBjb21taXQtZ3JhcGguYzoxOTgwCisjOiBjb21taXQtZ3JhcGguYzoxOTgxIGNvbW1pdC1ncmFwaC5jOjE5OTYKICMsIGMtZm9ybWF0CiBtc2dpZCAiY29tbWl0LWdyYXBoIGhhcyBpbmNvcnJlY3QgZmFub3V0IHZhbHVlOiBmYW5vdXRbJWRdID0gJXUgIT0gJXUiCiBtc2dzdHIgIiIKICJsZSBncmFwaGUgZGUgY29tbWl0IGEgdW5lIHZhbGV1ciBkZSBkaXNwZXJzaW9uIGluY29ycmVjdGUgOiBkaXNwZXJzaW9uWyVkXSA9ICIKICIldSAhPSAldSIKIAotIzogY29tbWl0LWdyYXBoLmM6MTk3MgorIzogY29tbWl0LWdyYXBoLmM6MTk4OAogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gcGFyc2UgY29tbWl0ICVzIGZyb20gY29tbWl0LWdyYXBoIgogbXNnc3RyICLDqWNoZWMgZGUgbCdhbmFseXNlIGxlIGNvbW1pdCAlcyBkZXB1aXMgbGUgZ3JhcGhlIGRlIGNvbW1pdHMiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjE5ODkKKyM6IGNvbW1pdC1ncmFwaC5jOjIwMDYKIG1zZ2lkICJWZXJpZnlpbmcgY29tbWl0cyBpbiBjb21taXQgZ3JhcGgiCiBtc2dzdHIgIlZlcmlmaWNhdGlvbiBkZXMgY29tbWl0cyBkYW5zIGxlIGdyYXBoZSBkZSBjb21taXRzIgogCi0jOiBjb21taXQtZ3JhcGguYzoyMDAyCisjOiBjb21taXQtZ3JhcGguYzoyMDIwCiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBwYXJzZSBjb21taXQgJXMgZnJvbSBvYmplY3QgZGF0YWJhc2UgZm9yIGNvbW1pdC1ncmFwaCIKIG1zZ3N0ciAiIgogIsOpY2hlYyBkZSBsJ2FuYWx5c2UgZHUgY29tbWl0ICVzIGRlcHVpcyBsYSBiYXNlIGRlIGRvbm7DqWVzIGQnb2JqZXRzIHBvdXIgbGUgIgogImdyYXBoZSBkZSBjb21taXQiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjIwMDkKKyM6IGNvbW1pdC1ncmFwaC5jOjIwMjcKICMsIGMtZm9ybWF0CiBtc2dpZCAicm9vdCB0cmVlIE9JRCBmb3IgY29tbWl0ICVzIGluIGNvbW1pdC1ncmFwaCBpcyAlcyAhPSAlcyIKIG1zZ3N0ciAiIgogImwnT0lEIGRlIGwnYXJicmUgcmFjaW5lIHBvdXIgbGUgY29tbWl0ICVzIGRhbnMgbGUgZ3JhcGhlIGRlIGNvbW1pdCBlc3QgJXMgIT0gIgogIiVzIgogCi0jOiBjb21taXQtZ3JhcGguYzoyMDE5CisjOiBjb21taXQtZ3JhcGguYzoyMDM3CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvbW1pdC1ncmFwaCBwYXJlbnQgbGlzdCBmb3IgY29tbWl0ICVzIGlzIHRvbyBsb25nIgogbXNnc3RyICIiCiAibGEgbGlzdGUgZGVzIHBhcmVudHMgZHUgZ3JhcGhlIGRlIGNvbW1pdCBwb3VyIGxlIGNvbW1pdCAlcyBlc3QgdHJvcCBsb25ndWUiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjIwMjgKKyM6IGNvbW1pdC1ncmFwaC5jOjIwNDYKICMsIGMtZm9ybWF0CiBtc2dpZCAiY29tbWl0LWdyYXBoIHBhcmVudCBmb3IgJXMgaXMgJXMgIT0gJXMiCiBtc2dzdHIgImxlIHBhcmVudCBkdSBncmFwaGUgZGUgY29tbWl0IHBvdXIgJXMgZXN0ICVzICE9ICVzIgogCi0jOiBjb21taXQtZ3JhcGguYzoyMDQxCisjOiBjb21taXQtZ3JhcGguYzoyMDU5CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvbW1pdC1ncmFwaCBwYXJlbnQgbGlzdCBmb3IgY29tbWl0ICVzIHRlcm1pbmF0ZXMgZWFybHkiCiBtc2dzdHIgIiIKICJsYSBsaXN0ZSBkZSBwYXJlbnRzIGR1IGdyYXBoZSBkZSBjb21taXQgcG91ciBsZSBjb21taXQgJXMgc2UgdGVybWluZSB0cm9wIHTDtHQiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjIwNDYKKyM6IGNvbW1pdC1ncmFwaC5jOjIwNjQKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogImNvbW1pdC1ncmFwaCBoYXMgZ2VuZXJhdGlvbiBudW1iZXIgemVybyBmb3IgY29tbWl0ICVzLCBidXQgbm9uLXplcm8gZWxzZXdoZXJlIgpAQCAtMTc0OSw3ICsxNzY1LDcgQEAKICJsZSBncmFwaGUgZGUgY29tbWl0IGEgdW4gbnVtw6lybyBkZSBnw6luw6lyYXRpb24gbnVsIHBvdXIgbGUgY29tbWl0ICVzLCBtYWlzICIKICJub24tbnVsIGFpbGxldXJzIgogCi0jOiBjb21taXQtZ3JhcGguYzoyMDUwCisjOiBjb21taXQtZ3JhcGguYzoyMDY4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJjb21taXQtZ3JhcGggaGFzIG5vbi16ZXJvIGdlbmVyYXRpb24gbnVtYmVyIGZvciBjb21taXQgJXMsIGJ1dCB6ZXJvIGVsc2V3aGVyZSIKQEAgLTE3NTcsMTIgKzE3NzMsMTIgQEAKICJsZSBncmFwaGUgZGUgY29tbWl0IGEgdW4gbnVtw6lybyBkZSBnw6luw6lyYXRpb24gbm9uLW51bCBwb3VyIGxlIGNvbW1pdCAlcywgIgogIm1haXMgbnVsIGFpbGxldXJzIgogCi0jOiBjb21taXQtZ3JhcGguYzoyMDY1CisjOiBjb21taXQtZ3JhcGguYzoyMDgzCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvbW1pdC1ncmFwaCBnZW5lcmF0aW9uIGZvciBjb21taXQgJXMgaXMgJXUgIT0gJXUiCiBtc2dzdHIgImxhIGfDqW7DqXJhdGlvbiBkdSBncmFwaGUgZGUgY29tbWl0IHBvdXIgbGUgY29tbWl0ICVzIGVzdCAldSAhPSAldSIKIAotIzogY29tbWl0LWdyYXBoLmM6MjA3MQorIzogY29tbWl0LWdyYXBoLmM6MjA4OQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb21taXQgZGF0ZSBmb3IgY29tbWl0ICVzIGluIGNvbW1pdC1ncmFwaCBpcyAlPFBSSXVNQVg+ICE9ICU8UFJJdU1BWD4iCiBtc2dzdHIgIiIKQEAgLTE4MTMsNyArMTgyOSw3IEBACiBtc2dpZCAia2V5IGRvZXMgbm90IGNvbnRhaW4gdmFyaWFibGUgbmFtZTogJXMiCiBtc2dzdHIgImxhIGNsw6kgbmUgY29udGllbnQgcGFzIGRlIG5vbSBkZSB2YXJpYWJsZcKgOiAlcyIKIAotIzogY29uZmlnLmM6NDA2IHNlcXVlbmNlci5jOjI0NjMKKyM6IGNvbmZpZy5jOjQwNiBzZXF1ZW5jZXIuYzoyNDAxCiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQga2V5OiAlcyIKIG1zZ3N0ciAiY2zDqSBpbnZhbGlkZcKgOiAlcyIKQEAgLTE5NDYsMTU1ICsxOTYyLDE0OCBAQAogbXNnaWQgImludmFsaWQgbW9kZSBmb3Igb2JqZWN0IGNyZWF0aW9uOiAlcyIKIG1zZ3N0ciAibW9kZSBpbnZhbGlkZSBwb3VyIGxhIGNyw6lhdGlvbiBkJ29iamV0IDogJXMiCiAKLSM6IGNvbmZpZy5jOjE0MzAKKyM6IGNvbmZpZy5jOjE0MjUKICMsIGMtZm9ybWF0CiBtc2dpZCAibWFsZm9ybWVkIHZhbHVlIGZvciAlcyIKIG1zZ3N0ciAidmFsZXVyIG1hbCBmb3Jtw6llIHBvdXIgJXMiCiAKLSM6IGNvbmZpZy5jOjE0NTYKKyM6IGNvbmZpZy5jOjE0NTEKICMsIGMtZm9ybWF0CiBtc2dpZCAibWFsZm9ybWVkIHZhbHVlIGZvciAlczogJXMiCiBtc2dzdHIgInZhbGV1ciBtYWwgZm9ybcOpZSBwb3VyICVzwqA6ICVzIgogCi0jOiBjb25maWcuYzoxNDU3CisjOiBjb25maWcuYzoxNDUyCiBtc2dpZCAibXVzdCBiZSBvbmUgb2Ygbm90aGluZywgbWF0Y2hpbmcsIHNpbXBsZSwgdXBzdHJlYW0gb3IgY3VycmVudCIKIG1zZ3N0ciAiZG9pdCDDqnRyZSBwYXJtaSBub3RoaW5nLCBtYXRjaGluZywgc2ltcGxlLCB1cHN0cmVhbSBvdSBjdXJyZW50IgogCi0jOiBjb25maWcuYzoxNTE4IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzQxMAorIzogY29uZmlnLmM6MTUxMyBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzOTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiYmFkIHBhY2sgY29tcHJlc3Npb24gbGV2ZWwgJWQiCiBtc2dzdHIgIm5pdmVhdSBkZSBjb21wcmVzc2lvbiBkdSBwYXF1ZXQgJWQiCiAKLSM6IGNvbmZpZy5jOjE2MzkKKyM6IGNvbmZpZy5jOjE2MzQKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGxvYWQgY29uZmlnIGJsb2Igb2JqZWN0ICclcyciCiBtc2dzdHIgImltcG9zc2libGUgZGUgY2hhcmdlciBsJ29iamV0IGJsb2IgZGUgY29uZmlnICclcyciCiAKLSM6IGNvbmZpZy5jOjE2NDIKKyM6IGNvbmZpZy5jOjE2MzcKICMsIGMtZm9ybWF0CiBtc2dpZCAicmVmZXJlbmNlICclcycgZG9lcyBub3QgcG9pbnQgdG8gYSBibG9iIgogbXNnc3RyICJsYSByw6lmw6lyZW5jZSAnJXMnIG5lIHBvaW50ZSBwYXMgc3VyIHVuIGJsb2IiCiAKLSM6IGNvbmZpZy5jOjE2NTkKKyM6IGNvbmZpZy5jOjE2NTQKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHJlc29sdmUgY29uZmlnIGJsb2IgJyVzJyIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkZSByw6lzb3VkcmUgbGUgYmxvYiBkZSBjb25maWcgJyVzJyIKIAotIzogY29uZmlnLmM6MTY4OQorIzogY29uZmlnLmM6MTY4NAogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gcGFyc2UgJXMiCiBtc2dzdHIgIsOpY2hlYyBkZSBsJ2FuYWx5c2UgZGUgJXMiCiAKLSM6IGNvbmZpZy5jOjE3NDUKKyM6IGNvbmZpZy5jOjE3NDAKIG1zZ2lkICJ1bmFibGUgdG8gcGFyc2UgY29tbWFuZC1saW5lIGNvbmZpZyIKIG1zZ3N0ciAibGVjdHVyZSBkZSBsYSBjb25maWd1cmF0aW9uIGRlIGxpZ25lIGRlIGNvbW1hbmRlIGltcG9zc2libGUiCiAKLSM6IGNvbmZpZy5jOjIwOTQKKyM6IGNvbmZpZy5jOjIwOTEKIG1zZ2lkICJ1bmtub3duIGVycm9yIG9jY3VycmVkIHdoaWxlIHJlYWRpbmcgdGhlIGNvbmZpZ3VyYXRpb24gZmlsZXMiCiBtc2dzdHIgImVycmV1ciBpbmNvbm51ZSBwZW5kYW50IGxhIGxlY3R1cmUgZGVzIGZpY2hpZXJzIGRlIGNvbmZpZ3VyYXRpb24iCiAKLSM6IGNvbmZpZy5jOjIyNjQKKyM6IGNvbmZpZy5jOjIyNjEKICMsIGMtZm9ybWF0CiBtc2dpZCAiSW52YWxpZCAlczogJyVzJyIKIG1zZ3N0ciAiJXMgaW52YWxpZGUgOiAnJXMnIgogCi0jOiBjb25maWcuYzoyMzA3Ci0jLCBjLWZvcm1hdAotbXNnaWQgInVua25vd24gY29yZS51bnRyYWNrZWRDYWNoZSB2YWx1ZSAnJXMnOyB1c2luZyAna2VlcCcgZGVmYXVsdCB2YWx1ZSIKLW1zZ3N0ciAiIgotInZhbGV1ciAnJXMnIGRlIGNvcmUudW50cmFja2VkQ2FjaGUgaW5jb25udWXCoDsgdXRpbGlzYXRpb24gZGUgJ2tlZXAnIHBhciAiCi0iZMOpZmF1dCIKLQotIzogY29uZmlnLmM6MjMzMworIzogY29uZmlnLmM6MjMwNgogIywgYy1mb3JtYXQKIG1zZ2lkICJzcGxpdEluZGV4Lm1heFBlcmNlbnRDaGFuZ2UgdmFsdWUgJyVkJyBzaG91bGQgYmUgYmV0d2VlbiAwIGFuZCAxMDAiCiBtc2dzdHIgIiIKICJsYSB2YWxldXIgJyVkJyBkZSBzcGxpdEluZGV4Lm1heFBlcmNlbnRDaGFuZ2UgZGV2cmFpdCBzZSBzaXR1ZXIgZW50cmUgMCBldCAiCiAiMTAwIgogCi0jOiBjb25maWcuYzoyMzc5CisjOiBjb25maWcuYzoyMzUyCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBwYXJzZSAnJXMnIGZyb20gY29tbWFuZC1saW5lIGNvbmZpZyIKIG1zZ3N0ciAiIgogImltcG9zc2libGUgZCdhbmFseXNlciAnJXMnIGRlcHVpcyBsZSBjb25maWd1cmF0aW9uIGVuIGxpZ25lIGRlIGNvbW1hbmRlIgogCi0jOiBjb25maWcuYzoyMzgxCisjOiBjb25maWcuYzoyMzU0CiAjLCBjLWZvcm1hdAogbXNnaWQgImJhZCBjb25maWcgdmFyaWFibGUgJyVzJyBpbiBmaWxlICclcycgYXQgbGluZSAlZCIKIG1zZ3N0ciAiIgogInZhcmlhYmxlIGRlIGNvbmZpZ3VyYXRpb24gJyVzJyBpbmNvcnJlY3RlIGRhbnMgbGUgZmljaGllciAnJXMnIMOgIGxhIGxpZ25lICVkIgogCi0jOiBjb25maWcuYzoyNDYyCisjOiBjb25maWcuYzoyNDM1CiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgc2VjdGlvbiBuYW1lICclcyciCiBtc2dzdHIgIm5vbSBkZSBzZWN0aW9uIGludmFsaWRlICclcyciCiAKLSM6IGNvbmZpZy5jOjI0OTQKKyM6IGNvbmZpZy5jOjI0NjcKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgaGFzIG11bHRpcGxlIHZhbHVlcyIKIG1zZ3N0ciAiJXMgYSBkZXMgdmFsZXVycyBtdWx0aXBsZXMiCiAKLSM6IGNvbmZpZy5jOjI1MjMKKyM6IGNvbmZpZy5jOjI0OTYKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIHdyaXRlIG5ldyBjb25maWd1cmF0aW9uIGZpbGUgJXMiCiBtc2dzdHIgImltcG9zc2libGUgZCfDqWNyaXJlIGxlIGZpY2hpZXIgZGUgY29uZmlndXJhdGlvbiAlcyIKIAotIzogY29uZmlnLmM6Mjc3NSBjb25maWcuYzozMDk5CisjOiBjb25maWcuYzoyNzQ4IGNvbmZpZy5jOjMwNzIKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGxvY2sgY29uZmlnIGZpbGUgJXMiCiBtc2dzdHIgImltcG9zc2libGUgZGUgdmVycm91aWxsZXIgbGUgZmljaGllciBkZSBjb25maWd1cmF0aW9uICVzIgogCi0jOiBjb25maWcuYzoyNzg2CisjOiBjb25maWcuYzoyNzU5CiAjLCBjLWZvcm1hdAogbXNnaWQgIm9wZW5pbmcgJXMiCiBtc2dzdHIgIm91dmVydHVyZSBkZSAlcyIKIAotIzogY29uZmlnLmM6MjgyMSBidWlsdGluL2NvbmZpZy5jOjMyOAorIzogY29uZmlnLmM6Mjc5NCBidWlsdGluL2NvbmZpZy5jOjMyOAogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIHBhdHRlcm46ICVzIgogbXNnc3RyICJtb3RpZiBpbnZhbGlkZSA6ICVzIgogCi0jOiBjb25maWcuYzoyODQ2CisjOiBjb25maWcuYzoyODE5CiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgY29uZmlnIGZpbGUgJXMiCiBtc2dzdHIgImZpY2hpZXIgZGUgY29uZmlndXJhdGlvbiBpbnZhbGlkZSAlcyIKIAotIzogY29uZmlnLmM6Mjg1OSBjb25maWcuYzozMTEyCisjOiBjb25maWcuYzoyODMyIGNvbmZpZy5jOjMwODUKICMsIGMtZm9ybWF0CiBtc2dpZCAiZnN0YXQgb24gJXMgZmFpbGVkIgogbXNnc3RyICLDqWNoZWMgZGUgZnN0YXQgc3VyICVzIgogCi0jOiBjb25maWcuYzoyODcwCisjOiBjb25maWcuYzoyODQzCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBtbWFwICclcyciCiBtc2dzdHIgImltcG9zc2libGUgZGUgcsOpYWxpc2VyIHVuIG1hcCBkZSAnJXMnIgogCi0jOiBjb25maWcuYzoyODc5IGNvbmZpZy5jOjMxMTcKKyM6IGNvbmZpZy5jOjI4NTIgY29uZmlnLmM6MzA5MAogIywgYy1mb3JtYXQKIG1zZ2lkICJjaG1vZCBvbiAlcyBmYWlsZWQiCiBtc2dzdHIgIsOpY2hlYyBkZSBjaG1vZCBzdXIgJXMiCiAKLSM6IGNvbmZpZy5jOjI5NjQgY29uZmlnLmM6MzIxNAorIzogY29uZmlnLmM6MjkzNyBjb25maWcuYzozMTg3CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCB3cml0ZSBjb25maWcgZmlsZSAlcyIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkJ8OpY3JpcmUgbGUgZmljaGllciBkZSBjb25maWd1cmF0aW9uICVzIgogCi0jOiBjb25maWcuYzoyOTk4CisjOiBjb25maWcuYzoyOTcxCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBzZXQgJyVzJyB0byAnJXMnIgogbXNnc3RyICJpbXBvc3NpYmxlIGRlIHLDqWdsZXIgJyVzJyDDoCAnJXMnIgogCi0jOiBjb25maWcuYzozMDAwIGJ1aWx0aW4vcmVtb3RlLmM6NzgyCisjOiBjb25maWcuYzoyOTczIGJ1aWx0aW4vcmVtb3RlLmM6NzgyCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCB1bnNldCAnJXMnIgogbXNnc3RyICJpbXBvc3NpYmxlIGRlIGTDqXNpbml0aWFsaXNlciAnJXMnIgogCi0jOiBjb25maWcuYzozMDkwCisjOiBjb25maWcuYzozMDYzCiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgc2VjdGlvbiBuYW1lOiAlcyIKIG1zZ3N0ciAibm9tIGRlIHNlY3Rpb24gaW52YWxpZGXCoDogJXMiCiAKLSM6IGNvbmZpZy5jOjMyNTcKKyM6IGNvbmZpZy5jOjMyMzAKICMsIGMtZm9ybWF0CiBtc2dpZCAibWlzc2luZyB2YWx1ZSBmb3IgJyVzJyIKIG1zZ3N0ciAidmFsZXVyIG1hbnF1YW50ZSBwb3VyICclcyciCkBAIC0yMjE4LDcgKzIyMjcsNyBAQAogbXNnaWQgInVua25vd24gcG9ydCAlcyIKIG1zZ3N0ciAicG9ydCBpbmNvbm51ICVzIgogCi0jOiBjb25uZWN0LmM6ODQ1IGNvbm5lY3QuYzoxMTcxCisjOiBjb25uZWN0LmM6ODQ1IGNvbm5lY3QuYzoxMTc1CiAjLCBjLWZvcm1hdAogbXNnaWQgInN0cmFuZ2UgaG9zdG5hbWUgJyVzJyBibG9ja2VkIgogbXNnc3RyICJub20gZCdow7R0ZSDDqXRyYW5nZSAnJXMnIGJsb3F1w6kiCkBAIC0yMjMzLDYwICsyMjQyLDYwIEBACiBtc2dpZCAiY2Fubm90IHN0YXJ0IHByb3h5ICVzIgogbXNnc3RyICJpbXBvc3NpYmxlIGRlIGTDqW1hcnJlciB1biBwcm94eSAlcyIKIAotIzogY29ubmVjdC5jOjkyNAorIzogY29ubmVjdC5jOjkyOAogbXNnaWQgIm5vIHBhdGggc3BlY2lmaWVkOyBzZWUgJ2dpdCBoZWxwIHB1bGwnIGZvciB2YWxpZCB1cmwgc3ludGF4IgogbXNnc3RyICIiCiAiYXVjdW4gY2hlbWluIHNww6ljaWZpw6nCoDsgcsOpZsOpcmV6LXZvdXMgw6AgJ2dpdCBoZWxwIHB1bGwnIHBvdXIgdW5lIHN5bnRheGUgIgogImQnVVJMIHZhbGlkZSIKIAotIzogY29ubmVjdC5jOjExMTkKKyM6IGNvbm5lY3QuYzoxMTIzCiBtc2dpZCAic3NoIHZhcmlhbnQgJ3NpbXBsZScgZG9lcyBub3Qgc3VwcG9ydCAtNCIKIG1zZ3N0ciAibGEgdmFyaWFudGUgc3NoICdzaW1wbGUnIG5lIHN1cHBvcnRlIHBhcyAtNCIKIAotIzogY29ubmVjdC5jOjExMzEKKyM6IGNvbm5lY3QuYzoxMTM1CiBtc2dpZCAic3NoIHZhcmlhbnQgJ3NpbXBsZScgZG9lcyBub3Qgc3VwcG9ydCAtNiIKIG1zZ3N0ciAibGEgdmFyaWFudGUgc3NoICdzaW1wbGUnIG5lIHN1cHBvcnRlIHBhcyAtNiIKIAotIzogY29ubmVjdC5jOjExNDgKKyM6IGNvbm5lY3QuYzoxMTUyCiBtc2dpZCAic3NoIHZhcmlhbnQgJ3NpbXBsZScgZG9lcyBub3Qgc3VwcG9ydCBzZXR0aW5nIHBvcnQiCiBtc2dzdHIgImxhIHZhcmlhbnRlIHNzaCAnc2ltcGxlJyBuZSBzdXBwb3J0ZSBwYXMgZGUgc3DDqWNpZmllciBsZSBwb3J0IgogCi0jOiBjb25uZWN0LmM6MTI2MAorIzogY29ubmVjdC5jOjEyNjQKICMsIGMtZm9ybWF0CiBtc2dpZCAic3RyYW5nZSBwYXRobmFtZSAnJXMnIGJsb2NrZWQiCiBtc2dzdHIgImNoZW1pbiDDqXRyYW5nZSAnJXMnIGJsb3F1w6kiCiAKLSM6IGNvbm5lY3QuYzoxMzA3CisjOiBjb25uZWN0LmM6MTMxMQogbXNnaWQgInVuYWJsZSB0byBmb3JrIgogbXNnc3RyICJmb3JrIGltcG9zc2libGUiCiAKLSM6IGNvbm5lY3RlZC5jOjg2IGJ1aWx0aW4vZnNjay5jOjIyMSBidWlsdGluL3BydW5lLmM6NDMKKyM6IGNvbm5lY3RlZC5jOjg4IGJ1aWx0aW4vZnNjay5jOjIyMSBidWlsdGluL3BydW5lLmM6NDMKIG1zZ2lkICJDaGVja2luZyBjb25uZWN0aXZpdHkiCiBtc2dzdHIgIlbDqXJpZmljYXRpb24gZGUgbGEgY29ubmVjdGl2aXTDqSIKIAotIzogY29ubmVjdGVkLmM6OTgKKyM6IGNvbm5lY3RlZC5jOjEwMAogbXNnaWQgIkNvdWxkIG5vdCBydW4gJ2dpdCByZXYtbGlzdCciCiBtc2dzdHIgIkltcG9zc2libGUgZGUgbGFuY2VyICdnaXQgcmV2LWxpc3QnIgogCi0jOiBjb25uZWN0ZWQuYzoxMTgKKyM6IGNvbm5lY3RlZC5jOjEyMAogbXNnaWQgImZhaWxlZCB3cml0ZSB0byByZXYtbGlzdCIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkJ8OpY3JpcmUgZGFucyBsYSByZXYtbGlzdCIKIAotIzogY29ubmVjdGVkLmM6MTI1CisjOiBjb25uZWN0ZWQuYzoxMjcKIG1zZ2lkICJmYWlsZWQgdG8gY2xvc2UgcmV2LWxpc3QncyBzdGRpbiIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkZSBmZXJtZXIgbCdlbnRyw6llIHN0YW5kYXJkIGR1IHJldi1saXN0IgogCi0jOiBjb252ZXJ0LmM6MTkzCisjOiBjb252ZXJ0LmM6MTk0CiAjLCBjLWZvcm1hdAogbXNnaWQgImlsbGVnYWwgY3JsZl9hY3Rpb24gJWQiCiBtc2dzdHIgImNybGZfYWN0aW9uIGlsbMOpZ2FsICVkIgogCi0jOiBjb252ZXJ0LmM6MjA2CisjOiBjb252ZXJ0LmM6MjA3CiAjLCBjLWZvcm1hdAogbXNnaWQgIkNSTEYgd291bGQgYmUgcmVwbGFjZWQgYnkgTEYgaW4gJXMiCiBtc2dzdHIgIkxlcyBDUkxGIHNlcmFpZW50IHJlbXBsYWPDqXMgcGFyIGRlcyBMRiBkYW5zICVzIgogCi0jOiBjb252ZXJ0LmM6MjA4CisjOiBjb252ZXJ0LmM6MjA5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJDUkxGIHdpbGwgYmUgcmVwbGFjZWQgYnkgTEYgaW4gJXMuXG4iCkBAIC0yMjk1LDEyICsyMzA0LDEyIEBACiAiTGVzIENSTEYgc2Vyb250IHJlbXBsYWPDqXMgcGFyIGRlcyBMRiBkYW5zICVzLlxuIgogIkxlIGZpY2hpZXIgY29uc2VydmVyYSBzZXMgZmlucyBkZSBsaWduZSBkJ29yaWdpbmUgZGFucyB2b3RyZSBjb3BpZSBkZSB0cmF2YWlsIgogCi0jOiBjb252ZXJ0LmM6MjE2CisjOiBjb252ZXJ0LmM6MjE3CiAjLCBjLWZvcm1hdAogbXNnaWQgIkxGIHdvdWxkIGJlIHJlcGxhY2VkIGJ5IENSTEYgaW4gJXMiCiBtc2dzdHIgIkxlcyBMRiBzZXJhaWVudCByZW1wbGFjw6lzIHBhciBkZXMgQ1JMRiBkYW5zICVzIgogCi0jOiBjb252ZXJ0LmM6MjE4CisjOiBjb252ZXJ0LmM6MjE5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJMRiB3aWxsIGJlIHJlcGxhY2VkIGJ5IENSTEYgaW4gJXMuXG4iCkBAIC0yMzA5LDEyICsyMzE4LDEyIEBACiAiTGVzIExGIHNlcm9udCByZW1wbGFjw6lzIHBhciBkZXMgQ1JMRiBkYW5zICVzLlxuIgogIkxlIGZpY2hpZXIgY29uc2VydmVyYSBzZXMgZmlucyBkZSBsaWduZSBkJ29yaWdpbmUgZGFucyB2b3RyZSBjb3BpZSBkZSB0cmF2YWlsIgogCi0jOiBjb252ZXJ0LmM6Mjc5CisjOiBjb252ZXJ0LmM6MjgwCiAjLCBjLWZvcm1hdAogbXNnaWQgIkJPTSBpcyBwcm9oaWJpdGVkIGluICclcycgaWYgZW5jb2RlZCBhcyAlcyIKIG1zZ3N0ciAiQXVjdW4gQk9NIG4nZXN0IHBlcm1pcyBkYW5zICclcycgcydpbCBlc3QgZW5jb2TDqSBjb21tZSAlcyIKIAotIzogY29udmVydC5jOjI4NgorIzogY29udmVydC5jOjI4NwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiVGhlIGZpbGUgJyVzJyBjb250YWlucyBhIGJ5dGUgb3JkZXIgbWFyayAoQk9NKS4gUGxlYXNlIHVzZSBVVEYtJXMgYXMgd29ya2luZy0iCkBAIC0yMzIzLDEyICsyMzMyLDEyIEBACiAiTGUgZmljaGllciAnJXMnIGNvbnRpZW50IHVuIG1hcnF1ZXVyIGQnb3JkcmUgZCdvY3RldHMgKEJPTSkuIFZldWlsbGV6ICIKICJ1dGlsaXNlciBVVEYtJXMgY29tbWUgZW5jb2RhZ2UgZCdhcmJyZSBkZSB0cmF2YWlsLiIKIAotIzogY29udmVydC5jOjMwNAorIzogY29udmVydC5jOjMwNQogIywgYy1mb3JtYXQKIG1zZ2lkICJCT00gaXMgcmVxdWlyZWQgaW4gJyVzJyBpZiBlbmNvZGVkIGFzICVzIgogbXNnc3RyICJVbiBCT00gZXN0IG9ibGlnYXRvaXJlIGRhbnMgJyVzJyBzJ2lsIGVzdCBlbmNvZMOpIGNvbW1lICVzIgogCi0jOiBjb252ZXJ0LmM6MzA2CisjOiBjb252ZXJ0LmM6MzA3CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgZmlsZSAnJXMnIGlzIG1pc3NpbmcgYSBieXRlIG9yZGVyIG1hcmsgKEJPTSkuIFBsZWFzZSB1c2UgVVRGLSVzQkUgb3IgVVRGLSIKQEAgLTIzMzgsNTIgKzIzNDcsNTIgQEAKICJ1dGlsaXNlciBVVEYtJXNCRSBvdSBVVEYtJXNMRSAoc2Vsb24gbCdvcmRyZSBkw6lzaXLDqSkgY29tbWUgZW5jb2RhZ2UgZCdhcmJyZSAiCiAiZGUgdHJhdmFpbC4iCiAKLSM6IGNvbnZlcnQuYzo0MjQgY29udmVydC5jOjQ5NQorIzogY29udmVydC5jOjQyNSBjb252ZXJ0LmM6NDk2CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBlbmNvZGUgJyVzJyBmcm9tICVzIHRvICVzIgogbXNnc3RyICLDqWNoZWMgZGUgbCdlbmNvZGFnZSBkZSAnJXMnIGRlICVzIHZlcnMgJXMiCiAKLSM6IGNvbnZlcnQuYzo0NjcKKyM6IGNvbnZlcnQuYzo0NjgKICMsIGMtZm9ybWF0CiBtc2dpZCAiZW5jb2RpbmcgJyVzJyBmcm9tICVzIHRvICVzIGFuZCBiYWNrIGlzIG5vdCB0aGUgc2FtZSIKIG1zZ3N0ciAiIgogImVuY29kZXIgJyVzJyBkZXB1aXMgJXMgdmVycyAlcyBwdWlzIGludmVyc2VtZW50IG5lIHByb2R1aXQgcGFzIGxlIG3Dqm1lICIKICJjb250ZW51IgogCi0jOiBjb252ZXJ0LmM6NjczCisjOiBjb252ZXJ0LmM6Njc0CiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCBmb3JrIHRvIHJ1biBleHRlcm5hbCBmaWx0ZXIgJyVzJyIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkZSBmb3JrZXIgcG91ciBsYW5jZXIgbGUgZmlsdHJlIGV4dGVybmUgJyVzJyIKIAotIzogY29udmVydC5jOjY5MworIzogY29udmVydC5jOjY5NAogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgZmVlZCB0aGUgaW5wdXQgdG8gZXh0ZXJuYWwgZmlsdGVyICclcyciCiBtc2dzdHIgImltcG9zc2libGUgZGUgZm91cm5pciBsJ2VudHLDqWUgYXUgZmlsdHJlIGV4dGVybmUgJyVzJyIKIAotIzogY29udmVydC5jOjcwMAorIzogY29udmVydC5jOjcwMQogIywgYy1mb3JtYXQKIG1zZ2lkICJleHRlcm5hbCBmaWx0ZXIgJyVzJyBmYWlsZWQgJWQiCiBtc2dzdHIgImxlIGZpbHRyZSBleHRlcm5lICclcycgYSDDqWNob3XDqSAlZCIKIAotIzogY29udmVydC5jOjczNSBjb252ZXJ0LmM6NzM4CisjOiBjb252ZXJ0LmM6NzM2IGNvbnZlcnQuYzo3MzkKICMsIGMtZm9ybWF0CiBtc2dpZCAicmVhZCBmcm9tIGV4dGVybmFsIGZpbHRlciAnJXMnIGZhaWxlZCIKIG1zZ3N0ciAibGEgbGVjdHVyZSBkZXB1aXMgbGUgZmlsdHJlIGV4dGVybmUgJyVzJyBhIMOpY2hvdcOpIgogCi0jOiBjb252ZXJ0LmM6NzQxIGNvbnZlcnQuYzo3OTYKKyM6IGNvbnZlcnQuYzo3NDIgY29udmVydC5jOjc5NwogIywgYy1mb3JtYXQKIG1zZ2lkICJleHRlcm5hbCBmaWx0ZXIgJyVzJyBmYWlsZWQiCiBtc2dzdHIgImxlIGZpbHRyZSBleHRlcm5lICclcycgYSDDqWNob3XDqSIKIAotIzogY29udmVydC5jOjg0NAorIzogY29udmVydC5jOjg0NQogbXNnaWQgInVuZXhwZWN0ZWQgZmlsdGVyIHR5cGUiCiBtc2dzdHIgInR5cGUgZGUgZmlsdHJlIGluYXR0ZW5kdSIKIAotIzogY29udmVydC5jOjg1NQorIzogY29udmVydC5jOjg1NgogbXNnaWQgInBhdGggbmFtZSB0b28gbG9uZyBmb3IgZXh0ZXJuYWwgZmlsdGVyIgogbXNnc3RyICJub20gZGUgY2hlbWluIHRyb3AgbG9uZyBwb3VyIHVuIGZpbHRyZSBleHRlcm5lIgogCi0jOiBjb252ZXJ0LmM6OTI5CisjOiBjb252ZXJ0LmM6OTMwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJleHRlcm5hbCBmaWx0ZXIgJyVzJyBpcyBub3QgYXZhaWxhYmxlIGFueW1vcmUgYWx0aG91Z2ggbm90IGFsbCBwYXRocyBoYXZlICIKQEAgLTIzOTIsNjcgKzI0MDEsNjcgQEAKICJsZSBmaWx0cmUgZXh0ZXJuZSAnJXMnIG4nZXN0IHBsdXMgZGlzcG9uaWJsZSBiaWVuIHF1ZSB0b3VzIGxlcyBjaGVtaW5zICIKICJuJ2FpZW50IHBhcyDDqXTDqSBmaWx0csOpcyIKIAotIzogY29udmVydC5jOjEyMjgKKyM6IGNvbnZlcnQuYzoxMjI5CiBtc2dpZCAidHJ1ZS9mYWxzZSBhcmUgbm8gdmFsaWQgd29ya2luZy10cmVlLWVuY29kaW5ncyIKIG1zZ3N0ciAidHJ1ZS9mYWxzZSBuZSBzb250IHBhcyBkZXMgZW5jb2RhZ2VzIGQnYXJicmUgZGUgdHJhdmFpbCB2YWxpZGVzIgogCi0jOiBjb252ZXJ0LmM6MTM5OCBjb252ZXJ0LmM6MTQzMgorIzogY29udmVydC5jOjE0MTcgY29udmVydC5jOjE0NTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXM6IGNsZWFuIGZpbHRlciAnJXMnIGZhaWxlZCIKIG1zZ3N0ciAiJXPCoDogbGUgZmlsdHJlIGNsZWFuICclcycgYSDDqWNob3XDqSIKIAotIzogY29udmVydC5jOjE0NzYKKyM6IGNvbnZlcnQuYzoxNDk1CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiBzbXVkZ2UgZmlsdGVyICVzIGZhaWxlZCIKIG1zZ3N0ciAiJXPCoDogbGUgZmlsdHJlIHNtdWRnZSAnJXMnIGEgw6ljaG91w6kiCiAKLSM6IGRhdGUuYzoxMzcKKyM6IGRhdGUuYzoxMzgKIG1zZ2lkICJpbiB0aGUgZnV0dXJlIgogbXNnc3RyICJkYW5zIGxlIGZ1dHVyIgogCi0jOiBkYXRlLmM6MTQzCisjOiBkYXRlLmM6MTQ0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiU8UFJJdU1BWD4gc2Vjb25kIGFnbyIKIG1zZ2lkX3BsdXJhbCAiJTxQUkl1TUFYPiBzZWNvbmRzIGFnbyIKIG1zZ3N0clswXSAiaWwgeSBhICU8UFJJdU1BWD4gc2Vjb25kZSIKIG1zZ3N0clsxXSAiaWwgeSBhICU8UFJJdU1BWD4gc2Vjb25kZXMiCiAKLSM6IGRhdGUuYzoxNTAKKyM6IGRhdGUuYzoxNTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiJTxQUkl1TUFYPiBtaW51dGUgYWdvIgogbXNnaWRfcGx1cmFsICIlPFBSSXVNQVg+IG1pbnV0ZXMgYWdvIgogbXNnc3RyWzBdICJpbCB5IGEgJTxQUkl1TUFYPiBtaW51dGUiCiBtc2dzdHJbMV0gImlsIHkgYSAlPFBSSXVNQVg+IG1pbnV0ZXMiCiAKLSM6IGRhdGUuYzoxNTcKKyM6IGRhdGUuYzoxNTgKICMsIGMtZm9ybWF0CiBtc2dpZCAiJTxQUkl1TUFYPiBob3VyIGFnbyIKIG1zZ2lkX3BsdXJhbCAiJTxQUkl1TUFYPiBob3VycyBhZ28iCiBtc2dzdHJbMF0gImlsIHkgYSAlPFBSSXVNQVg+IGhldXJlIgogbXNnc3RyWzFdICJpbCB5IGEgJTxQUkl1TUFYPiBoZXVyZXMiCiAKLSM6IGRhdGUuYzoxNjQKKyM6IGRhdGUuYzoxNjUKICMsIGMtZm9ybWF0CiBtc2dpZCAiJTxQUkl1TUFYPiBkYXkgYWdvIgogbXNnaWRfcGx1cmFsICIlPFBSSXVNQVg+IGRheXMgYWdvIgogbXNnc3RyWzBdICJpbCB5IGEgJTxQUkl1TUFYPiBqb3VyIgogbXNnc3RyWzFdICJpbCB5IGEgJTxQUkl1TUFYPiBqb3VycyIKIAotIzogZGF0ZS5jOjE3MAorIzogZGF0ZS5jOjE3MQogIywgYy1mb3JtYXQKIG1zZ2lkICIlPFBSSXVNQVg+IHdlZWsgYWdvIgogbXNnaWRfcGx1cmFsICIlPFBSSXVNQVg+IHdlZWtzIGFnbyIKIG1zZ3N0clswXSAiaWwgeSBhICU8UFJJdU1BWD4gc2VtYWluZSIKIG1zZ3N0clsxXSAiaWwgeSBhICU8UFJJdU1BWD4gc2VtYWluZXMiCiAKLSM6IGRhdGUuYzoxNzcKKyM6IGRhdGUuYzoxNzgKICMsIGMtZm9ybWF0CiBtc2dpZCAiJTxQUkl1TUFYPiBtb250aCBhZ28iCiBtc2dpZF9wbHVyYWwgIiU8UFJJdU1BWD4gbW9udGhzIGFnbyIKIG1zZ3N0clswXSAiaWwgeSBhICU8UFJJdU1BWD4gbW9pcyIKIG1zZ3N0clsxXSAiaWwgeSBhICU8UFJJdU1BWD4gbW9pcyIKIAotIzogZGF0ZS5jOjE4OAorIzogZGF0ZS5jOjE4OQogIywgYy1mb3JtYXQKIG1zZ2lkICIlPFBSSXVNQVg+IHllYXIiCiBtc2dpZF9wbHVyYWwgIiU8UFJJdU1BWD4geWVhcnMiCkBAIC0yNDYwLDE0ICsyNDY5LDE0IEBACiBtc2dzdHJbMV0gIiU8UFJJdU1BWD4gYW5zIgogCiAjLiBUUkFOU0xBVE9SUzogIiVzIiBpcyAiPG4+IHllYXJzIgotIzogZGF0ZS5jOjE5MQorIzogZGF0ZS5jOjE5MgogIywgYy1mb3JtYXQKIG1zZ2lkICIlcywgJTxQUkl1TUFYPiBtb250aCBhZ28iCiBtc2dpZF9wbHVyYWwgIiVzLCAlPFBSSXVNQVg+IG1vbnRocyBhZ28iCiBtc2dzdHJbMF0gImlsIHkgYSAlcyBldCAlPFBSSXVNQVg+IG1vaXMiCiBtc2dzdHJbMV0gImlsIHkgYSAlcyBldCAlPFBSSXVNQVg+IG1vaXMiCiAKLSM6IGRhdGUuYzoxOTYgZGF0ZS5jOjIwMQorIzogZGF0ZS5jOjE5NyBkYXRlLmM6MjAyCiAjLCBjLWZvcm1hdAogbXNnaWQgIiU8UFJJdU1BWD4geWVhciBhZ28iCiBtc2dpZF9wbHVyYWwgIiU8UFJJdU1BWD4geWVhcnMgYWdvIgpAQCAtMjUwNSw3ICsyNTE0LDcgQEAKIG1zZ2lkICJmYWlsZWQgdG8gcmVhZCBvcmRlcmZpbGUgJyVzJyIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkZSBsaXJlIGxlIGZpY2hpZXIgZGUgY29tbWFuZGUgJyVzJyIKIAotIzogZGlmZmNvcmUtcmVuYW1lLmM6NTQ0CisjOiBkaWZmY29yZS1yZW5hbWUuYzo1NDMKIG1zZ2lkICJQZXJmb3JtaW5nIGluZXhhY3QgcmVuYW1lIGRldGVjdGlvbiIKIG1zZ3N0ciAiRMOpdGVjdGlvbiBkZSByZW5vbW1hZ2UgaW5leGFjdCBlbiBjb3VycyIKIApAQCAtMjU3MywzNSArMjU4MiwzNSBAQAogIkVycmV1cnMgZGFucyBsYSB2YXJpYWJsZSBkZSBjb25maWd1cmF0aW9uICdkaWZmLmRpcnN0YXQnIDpcbiIKICIlcyIKIAotIzogZGlmZi5jOjQyMTUKKyM6IGRpZmYuYzo0MjE4CiAjLCBjLWZvcm1hdAogbXNnaWQgImV4dGVybmFsIGRpZmYgZGllZCwgc3RvcHBpbmcgYXQgJXMiCiBtc2dzdHIgImwnYXBwbGljYXRpb24gZGUgZGlmZiBleHRlcm5lIGEgZGlzcGFydSwgYXJyw6p0IMOgICVzIgogCi0jOiBkaWZmLmM6NDU2MAorIzogZGlmZi5jOjQ1NjMKIG1zZ2lkICItLW5hbWUtb25seSwgLS1uYW1lLXN0YXR1cywgLS1jaGVjayBhbmQgLXMgYXJlIG11dHVhbGx5IGV4Y2x1c2l2ZSIKIG1zZ3N0ciAiLS1uYW1lLW9ubHksIC0tbmFtZS1zdGF0dXMsIC0tY2hlY2sgZXQgLXMgc29udCBtdXR1ZWxsZW1lbnQgZXhjbHVzaWZzIgogCi0jOiBkaWZmLmM6NDU2MworIzogZGlmZi5jOjQ1NjYKIG1zZ2lkICItRywgLVMgYW5kIC0tZmluZC1vYmplY3QgYXJlIG11dHVhbGx5IGV4Y2x1c2l2ZSIKIG1zZ3N0ciAiLUcsIC1TIGV0IC0tZmluZC1vYmplY3Qgc29udCBtdXR1ZWxsZW1lbnQgZXhjbHVzaWZzIgogCi0jOiBkaWZmLmM6NDY0MQorIzogZGlmZi5jOjQ2NDQKIG1zZ2lkICItLWZvbGxvdyByZXF1aXJlcyBleGFjdGx5IG9uZSBwYXRoc3BlYyIKIG1zZ3N0ciAiLS1mb2xsb3cgYSBiZXNvaW4gZCd1bmUgc3DDqWNpZmljYXRpb24gZGUgY2hlbWluIHVuaXF1ZSIKIAotIzogZGlmZi5jOjQ2ODkKKyM6IGRpZmYuYzo0NjkyCiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgLS1zdGF0IHZhbHVlOiAlcyIKIG1zZ3N0ciAidmFsZXVyIGludmFsaWRlIGRlIC0tc3RhdMKgOiAlcyIKIAotIzogZGlmZi5jOjQ2OTQgZGlmZi5jOjQ2OTkgZGlmZi5jOjQ3MDQgZGlmZi5jOjQ3MDkgZGlmZi5jOjUyMjIKKyM6IGRpZmYuYzo0Njk3IGRpZmYuYzo0NzAyIGRpZmYuYzo0NzA3IGRpZmYuYzo0NzEyIGRpZmYuYzo1MjI1CiAjOiBwYXJzZS1vcHRpb25zLmM6MTk5IHBhcnNlLW9wdGlvbnMuYzoyMDMKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgZXhwZWN0cyBhIG51bWVyaWNhbCB2YWx1ZSIKIG1zZ3N0ciAiJXMgYXR0ZW5kIHVuZSB2YWxldXIgbnVtw6lyaXF1ZSIKIAotIzogZGlmZi5jOjQ3MjYKKyM6IGRpZmYuYzo0NzI5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJGYWlsZWQgdG8gcGFyc2UgLS1kaXJzdGF0Ly1YIG9wdGlvbiBwYXJhbWV0ZXI6XG4iCkBAIC0yNjEwLDQyICsyNjE5LDQyIEBACiAiSW1wb3NzaWJsZSBkJ2FuYWx5c2VyIGxlIHBhcmFtw6h0cmUgZGUgbCdvcHRpb24gLS1kaXJzdGF0Ly1YIDpcbiIKICIlcyIKIAotIzogZGlmZi5jOjQ4MTEKKyM6IGRpZmYuYzo0ODE0CiAjLCBjLWZvcm1hdAogbXNnaWQgInVua25vd24gY2hhbmdlIGNsYXNzICclYycgaW4gLS1kaWZmLWZpbHRlcj0lcyIKIG1zZ3N0ciAiY2xhc3NlIGRlIG1vZGlmaWNhdGlvbiBpbmNvbm51ZSAnJWMnIGRhbnMgLS1kaWZmLWZpbGV0ZXI9JXMiCiAKLSM6IGRpZmYuYzo0ODM1CisjOiBkaWZmLmM6NDgzOAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmtub3duIHZhbHVlIGFmdGVyIHdzLWVycm9yLWhpZ2hsaWdodD0lLipzIgogbXNnc3RyICJ2YWxldXIgaW5jb25udWUgYXByw6hzIHdzLWVycm9yLWhpZ2hsaWdodD0lLipzIgogCi0jOiBkaWZmLmM6NDg0OQorIzogZGlmZi5jOjQ4NTIKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHJlc29sdmUgJyVzJyIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkZSByw6lzb3VkcmUgJyVzJyIKIAotIzogZGlmZi5jOjQ4OTkgZGlmZi5jOjQ5MDUKKyM6IGRpZmYuYzo0OTAyIGRpZmYuYzo0OTA4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIGV4cGVjdHMgPG4+LzxtPiBmb3JtIgogbXNnc3RyICJmb3JtZSA8bj4vPG0+IGF0dGVuZHVlIHBhciAlcyIKIAotIzogZGlmZi5jOjQ5MTcKKyM6IGRpZmYuYzo0OTIwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIGV4cGVjdHMgYSBjaGFyYWN0ZXIsIGdvdCAnJXMnIgogbXNnc3RyICJjYXJhY3TDqHJlIGF0dGVuZHUgcGFyICVzLCAnJXMnIHRyb3V2w6kiCiAKLSM6IGRpZmYuYzo0OTM4CisjOiBkaWZmLmM6NDk0MQogIywgYy1mb3JtYXQKIG1zZ2lkICJiYWQgLS1jb2xvci1tb3ZlZCBhcmd1bWVudDogJXMiCiBtc2dzdHIgIm1hdXZhaXMgYXJndW1lbnQgLS1jb2xvci1tb3ZlZMKgOiAlcyIKIAotIzogZGlmZi5jOjQ5NTcKKyM6IGRpZmYuYzo0OTYwCiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgbW9kZSAnJXMnIGluIC0tY29sb3ItbW92ZWQtd3MiCiBtc2dzdHIgIm1vZGUgaW52YWxpZGUgJyVzJyBkYW5zIC0tY29sb3ItbW92ZWQtd3MiCiAKLSM6IGRpZmYuYzo0OTk3CisjOiBkaWZmLmM6NTAwMAogbXNnaWQgIiIKICJvcHRpb24gZGlmZi1hbGdvcml0aG0gYWNjZXB0cyBcIm15ZXJzXCIsIFwibWluaW1hbFwiLCBcInBhdGllbmNlXCIgYW5kICIKICJcImhpc3RvZ3JhbVwiIgpAQCAtMjY1MywxNTUgKzI2NjIsMTU1IEBACiAibCdvcHRpb24gZGlmZi1hbGdvcml0aG0gYWNjZXB0IFwibXllcnNcIiwgXCJtaW5pbWFsXCIsIFwicGF0aWVuY2VcIiBldCAiCiAiXCJoaXN0b2dyYW1cIiIKIAotIzogZGlmZi5jOjUwMzMgZGlmZi5jOjUwNTMKKyM6IGRpZmYuYzo1MDM2IGRpZmYuYzo1MDU2CiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgYXJndW1lbnQgdG8gJXMiCiBtc2dzdHIgImFyZ3VtZW50IGludmFsaWRlIHBvdXIgJXMiCiAKLSM6IGRpZmYuYzo1MTkxCisjOiBkaWZmLmM6NTE5NAogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gcGFyc2UgLS1zdWJtb2R1bGUgb3B0aW9uIHBhcmFtZXRlcjogJyVzJyIKIG1zZ3N0ciAiw6ljaGVjIGRlIGwnYW5hbHlzZSBkdSBwYXJhbcOodHJlIGRlIGwnb3B0aW9uIC0tc3VibW9kdWxlIDogJyVzJyIKIAotIzogZGlmZi5jOjUyNDcKKyM6IGRpZmYuYzo1MjUwCiAjLCBjLWZvcm1hdAogbXNnaWQgImJhZCAtLXdvcmQtZGlmZiBhcmd1bWVudDogJXMiCiBtc2dzdHIgIm1hdXZhaXMgYXJndW1lbnQgcG91ciAtLXdvcmQtZGlmZsKgOiAlcyIKIAotIzogZGlmZi5jOjUyNzAKKyM6IGRpZmYuYzo1MjczCiBtc2dpZCAiRGlmZiBvdXRwdXQgZm9ybWF0IG9wdGlvbnMiCiBtc2dzdHIgIk9wdGlvbnMgZGUgZm9ybWF0IGRlIHNvcnRpZSBkZSBkaWZmIgogCi0jOiBkaWZmLmM6NTI3MiBkaWZmLmM6NTI3OAorIzogZGlmZi5jOjUyNzUgZGlmZi5jOjUyODEKIG1zZ2lkICJnZW5lcmF0ZSBwYXRjaCIKIG1zZ3N0ciAiZ8OpbsOpcmVyIGxhIHJ1c3RpbmUiCiAKLSM6IGRpZmYuYzo1Mjc1IGJ1aWx0aW4vbG9nLmM6MTcyCisjOiBkaWZmLmM6NTI3OCBidWlsdGluL2xvZy5jOjE3MgogbXNnaWQgInN1cHByZXNzIGRpZmYgb3V0cHV0IgogbXNnc3RyICJzdXBwcmltZXIgbGEgc29ydGllIGRlcyBkaWZmw6lyZW5jZXMiCiAKLSM6IGRpZmYuYzo1MjgwIGRpZmYuYzo1Mzk0IGRpZmYuYzo1NDAxCisjOiBkaWZmLmM6NTI4MyBkaWZmLmM6NTM5NyBkaWZmLmM6NTQwNAogbXNnaWQgIjxuPiIKIG1zZ3N0ciAiPG4+IgogCi0jOiBkaWZmLmM6NTI4MSBkaWZmLmM6NTI4NAorIzogZGlmZi5jOjUyODQgZGlmZi5jOjUyODcKIG1zZ2lkICJnZW5lcmF0ZSBkaWZmcyB3aXRoIDxuPiBsaW5lcyBjb250ZXh0IgogbXNnc3RyICJnw6luw6lyZXIgbGVzIGRpZmZzIGF2ZWMgPG4+IGxpZ25lcyBkZSBjb250ZXh0ZSIKIAotIzogZGlmZi5jOjUyODYKKyM6IGRpZmYuYzo1Mjg5CiBtc2dpZCAiZ2VuZXJhdGUgdGhlIGRpZmYgaW4gcmF3IGZvcm1hdCIKIG1zZ3N0ciAiZ8OpbsOpcmVyIGxlIGRpZmYgZW4gZm9ybWF0IGJydXQiCiAKLSM6IGRpZmYuYzo1Mjg5CisjOiBkaWZmLmM6NTI5MgogbXNnaWQgInN5bm9ueW0gZm9yICctcCAtLXJhdyciCiBtc2dzdHIgInN5bm9ueW1lIGRlICctcCAtLXJhdyciCiAKLSM6IGRpZmYuYzo1MjkzCisjOiBkaWZmLmM6NTI5NgogbXNnaWQgInN5bm9ueW0gZm9yICctcCAtLXN0YXQnIgogbXNnc3RyICJzeW5vbnltZSBkZSAnLXAgLS1zdGF0JyIKIAotIzogZGlmZi5jOjUyOTcKKyM6IGRpZmYuYzo1MzAwCiBtc2dpZCAibWFjaGluZSBmcmllbmRseSAtLXN0YXQiCiBtc2dzdHIgIi0tc3RhdCBwb3VyIHRyYWl0ZW1lbnQgYXV0b21hdGlxdWUiCiAKLSM6IGRpZmYuYzo1MzAwCisjOiBkaWZmLmM6NTMwMwogbXNnaWQgIm91dHB1dCBvbmx5IHRoZSBsYXN0IGxpbmUgb2YgLS1zdGF0IgogbXNnc3RyICJhZmZpY2hlciBzZXVsZW1lbnQgbGEgZGVybmnDqHJlIGxpZ25lIGRlIC0tc3RhdCIKIAotIzogZGlmZi5jOjUzMDIgZGlmZi5jOjUzMTAKKyM6IGRpZmYuYzo1MzA1IGRpZmYuYzo1MzEzCiBtc2dpZCAiPHBhcmFtMSxwYXJhbTI+Li4uIgogbXNnc3RyICI8cGFyYW0xLHBhcmFtMj4uLi4iCiAKLSM6IGRpZmYuYzo1MzAzCisjOiBkaWZmLmM6NTMwNgogbXNnaWQgIiIKICJvdXRwdXQgdGhlIGRpc3RyaWJ1dGlvbiBvZiByZWxhdGl2ZSBhbW91bnQgb2YgY2hhbmdlcyBmb3IgZWFjaCBzdWItZGlyZWN0b3J5IgogbXNnc3RyICIiCiAiYWZmaWNoZXIgbGEgZGlzdHJpYnV0aW9uIGRlcyBxdWFudGl0w6lzIGRlIG1vZGlmaWNhdGlvbnMgcmVsYXRpdmVzIHBvdXIgIgogImNoYXF1ZSBzb3VzLXLDqXBlcnRvaXJlIgogCi0jOiBkaWZmLmM6NTMwNworIzogZGlmZi5jOjUzMTAKIG1zZ2lkICJzeW5vbnltIGZvciAtLWRpcnN0YXQ9Y3VtdWxhdGl2ZSIKIG1zZ3N0ciAic3lub255bWUgcG91ciAtLWRpcnN0YXQ9Y3VtdWxhdGl2ZSIKIAotIzogZGlmZi5jOjUzMTEKKyM6IGRpZmYuYzo1MzE0CiBtc2dpZCAic3lub255bSBmb3IgLS1kaXJzdGF0PWZpbGVzLHBhcmFtMSxwYXJhbTIuLi4iCiBtc2dzdHIgInN5bm9ueW1lIHBvdXIgLS1kaXJzdGF0PWZpbGVzLHBhcmFtMSxwYXJhbTIuLi4iCiAKLSM6IGRpZmYuYzo1MzE1CisjOiBkaWZmLmM6NTMxOAogbXNnaWQgIndhcm4gaWYgY2hhbmdlcyBpbnRyb2R1Y2UgY29uZmxpY3QgbWFya2VycyBvciB3aGl0ZXNwYWNlIGVycm9ycyIKIG1zZ3N0ciAiIgogImF2ZXJ0aXIgc2kgbGVzIG1vZGlmaWNhdGlvbnMgaW50cm9kdWlzZW50IGRlcyBtYXJxdWV1cnMgZGUgY29uZmxpdCBvdSBkZXMgIgogImVycmV1cnMgZCdlc3BhY2UiCiAKLSM6IGRpZmYuYzo1MzE4CisjOiBkaWZmLmM6NTMyMQogbXNnaWQgImNvbmRlbnNlZCBzdW1tYXJ5IHN1Y2ggYXMgY3JlYXRpb25zLCByZW5hbWVzIGFuZCBtb2RlIGNoYW5nZXMiCiBtc2dzdHIgIiIKICJyw6lzdW3DqSBzdWNjaW5jdCB0ZWwgcXVlIGxlcyBjcsOpYXRpb25zLCBsZXMgcmVub21tYWdlcyBldCBsZXMgbW9kaWZpY2F0aW9ucyAiCiAiZGUgbW9kZSIKIAotIzogZGlmZi5jOjUzMjEKKyM6IGRpZmYuYzo1MzI0CiBtc2dpZCAic2hvdyBvbmx5IG5hbWVzIG9mIGNoYW5nZWQgZmlsZXMiCiBtc2dzdHIgIm4nYWZmaWNoZXIgcXVlIGxlcyBub21zIGRlIGZpY2hpZXJzIG1vZGlmacOpcyIKIAotIzogZGlmZi5jOjUzMjQKKyM6IGRpZmYuYzo1MzI3CiBtc2dpZCAic2hvdyBvbmx5IG5hbWVzIGFuZCBzdGF0dXMgb2YgY2hhbmdlZCBmaWxlcyIKIG1zZ3N0ciAibidhZmZpY2hlciBxdWUgbGVzIG5vbXMgZXQgbGVzIHN0YXR1cyBkZXMgZmljaGllcnMgbW9kaWZpw6lzIgogCi0jOiBkaWZmLmM6NTMyNgorIzogZGlmZi5jOjUzMjkKIG1zZ2lkICI8d2lkdGg+Wyw8bmFtZS13aWR0aD5bLDxjb3VudD5dXSIKIG1zZ3N0ciAiPGxhcmdldXI+Wyw8bGFyZ2V1ci1kZS1ub20+Wyw8Y29tcHRlPl1dIgogCi0jOiBkaWZmLmM6NTMyNworIzogZGlmZi5jOjUzMzAKIG1zZ2lkICJnZW5lcmF0ZSBkaWZmc3RhdCIKIG1zZ3N0ciAiZ8OpbsOpcmVyIHVuIGRpZmZzdGF0IgogCi0jOiBkaWZmLmM6NTMyOSBkaWZmLmM6NTMzMiBkaWZmLmM6NTMzNQorIzogZGlmZi5jOjUzMzIgZGlmZi5jOjUzMzUgZGlmZi5jOjUzMzgKIG1zZ2lkICI8d2lkdGg+IgogbXNnc3RyICI8bGFyZ2V1cj4iCiAKLSM6IGRpZmYuYzo1MzMwCisjOiBkaWZmLmM6NTMzMwogbXNnaWQgImdlbmVyYXRlIGRpZmZzdGF0IHdpdGggYSBnaXZlbiB3aWR0aCIKIG1zZ3N0ciAiZ8OpbsOpcmVyIHVuIGRpZmZzdGF0IGF2ZWMgbGEgbGFyZ2V1ciBpbmRpcXXDqWUiCiAKLSM6IGRpZmYuYzo1MzMzCisjOiBkaWZmLmM6NTMzNgogbXNnaWQgImdlbmVyYXRlIGRpZmZzdGF0IHdpdGggYSBnaXZlbiBuYW1lIHdpZHRoIgogbXNnc3RyICJnw6luZXJlciB1biBkaWZmc3RhdCBhdmVjIGxhIGxhcmdldXIgZGUgbm9tIGluZGlxdcOpZSIKIAotIzogZGlmZi5jOjUzMzYKKyM6IGRpZmYuYzo1MzM5CiBtc2dpZCAiZ2VuZXJhdGUgZGlmZnN0YXQgd2l0aCBhIGdpdmVuIGdyYXBoIHdpZHRoIgogbXNnc3RyICJnw6luZXJlciB1biBkaWZmc3RhdCBhdmVjIGxhIGxhcmdldXIgZGUgZ3JhcGhlIGluZGlxdcOpZSIKIAotIzogZGlmZi5jOjUzMzgKKyM6IGRpZmYuYzo1MzQxCiBtc2dpZCAiPGNvdW50PiIKIG1zZ3N0ciAiPGNvbXB0ZT4iCiAKLSM6IGRpZmYuYzo1MzM5CisjOiBkaWZmLmM6NTM0MgogbXNnaWQgImdlbmVyYXRlIGRpZmZzdGF0IHdpdGggbGltaXRlZCBsaW5lcyIKIG1zZ3N0ciAiZ8OpbsOpcmVyIHVuIGRpZmZzdGF0IGF2ZWMgZGVzIGxpZ25lcyBsaW1pdMOpZXMiCiAKLSM6IGRpZmYuYzo1MzQyCisjOiBkaWZmLmM6NTM0NQogbXNnaWQgImdlbmVyYXRlIGNvbXBhY3Qgc3VtbWFyeSBpbiBkaWZmc3RhdCIKIG1zZ3N0ciAiZ8OpbsOpcmVyIHVuZSByw6lzdW3DqSBjb21wYWN0IGRhbnMgbGUgZGlmZnN0YXQiCiAKLSM6IGRpZmYuYzo1MzQ1CisjOiBkaWZmLmM6NTM0OAogbXNnaWQgIm91dHB1dCBhIGJpbmFyeSBkaWZmIHRoYXQgY2FuIGJlIGFwcGxpZWQiCiBtc2dzdHIgInByb2R1aXJlIHVuIGRpZmYgYmluYWlyZSBxdWkgcGV1dCDDqnRyZSBhcHBsaXF1w6kiCiAKLSM6IGRpZmYuYzo1MzQ4CisjOiBkaWZmLmM6NTM1MQogbXNnaWQgInNob3cgZnVsbCBwcmUtIGFuZCBwb3N0LWltYWdlIG9iamVjdCBuYW1lcyBvbiB0aGUgXCJpbmRleFwiIGxpbmVzIgogbXNnc3RyICIiCiAiYWZmaWNoZXIgbGVzIG5vbXMgY29tcGxldHMgZGVzIG9iamV0cyBwcmUtIGV0IHBvc3QtaW1hZ2Ugc3VyIGxlcyBsaWduZXMgIgogIlwiaW5kZXhcIiIKIAotIzogZGlmZi5jOjUzNTAKKyM6IGRpZmYuYzo1MzUzCiBtc2dpZCAic2hvdyBjb2xvcmVkIGRpZmYiCiBtc2dzdHIgImFmZmljaGVyIHVuIGRpZmYgY29sb3LDqSIKIAotIzogZGlmZi5jOjUzNTEKKyM6IGRpZmYuYzo1MzU0CiBtc2dpZCAiPGtpbmQ+IgogbXNnc3RyICI8c29ydGU+IgogCi0jOiBkaWZmLmM6NTM1MgorIzogZGlmZi5jOjUzNTUKIG1zZ2lkICIiCiAiaGlnaGxpZ2h0IHdoaXRlc3BhY2UgZXJyb3JzIGluIHRoZSAnY29udGV4dCcsICdvbGQnIG9yICduZXcnIGxpbmVzIGluIHRoZSAiCiAiZGlmZiIKQEAgLTI4MDksNyArMjgxOCw3IEBACiAic3VybGlnbmVyIGxlcyBlcnJldXJzIGQnZXNwYWNlIGRhbnMgbGVzIGxpZ25lcyAnY29udGV4dGUnLCAnYW5jaWVuJywgIgogIidub3V2ZWF1JyBkYW5zIGxlIGRpZmYiCiAKLSM6IGRpZmYuYzo1MzU1CisjOiBkaWZmLmM6NTM1OAogbXNnaWQgIiIKICJkbyBub3QgbXVuZ2UgcGF0aG5hbWVzIGFuZCB1c2UgTlVMcyBhcyBvdXRwdXQgZmllbGQgdGVybWluYXRvcnMgaW4gLS1yYXcgb3IgIgogIi0tbnVtc3RhdCIKQEAgLTI4MTcsOTMgKzI4MjYsOTMgQEAKICJuZSBwYXMgY29tcHJlc3NlciBsZXMgY2hlbWlucyBldCB1dGlsaXNlciBkZXMgTlVMcyBjb21tZSB0ZXJtaW5hdGV1cnMgZGUgIgogImNoYW1wcyBkYW5zIC0tcmF3IG91IC0tbnVtc3RhdCIKIAotIzogZGlmZi5jOjUzNTggZGlmZi5jOjUzNjEgZGlmZi5jOjUzNjQgZGlmZi5jOjU0NzAKKyM6IGRpZmYuYzo1MzYxIGRpZmYuYzo1MzY0IGRpZmYuYzo1MzY3IGRpZmYuYzo1NDczCiBtc2dpZCAiPHByZWZpeD4iCiBtc2dzdHIgIjxwcsOpZml4ZT4iCiAKLSM6IGRpZmYuYzo1MzU5CisjOiBkaWZmLmM6NTM2MgogbXNnaWQgInNob3cgdGhlIGdpdmVuIHNvdXJjZSBwcmVmaXggaW5zdGVhZCBvZiBcImEvXCIiCiBtc2dzdHIgImFmZmljaGVyIGxlIHByw6lmaXhlIGRlIHNvdXJjZSBpbmRpcXXDqSBhdSBsaWV1IGRlIFwiYS9cIiIKIAotIzogZGlmZi5jOjUzNjIKKyM6IGRpZmYuYzo1MzY1CiBtc2dpZCAic2hvdyB0aGUgZ2l2ZW4gZGVzdGluYXRpb24gcHJlZml4IGluc3RlYWQgb2YgXCJiL1wiIgogbXNnc3RyICJhZmZpY2hlciBsZSBwcsOpZml4ZSBkZSBkZXN0aW5hdGlvbiBpbmRpcXXDqSBhdSBsaWV1IGRlIFwiYi9cIiIKIAotIzogZGlmZi5jOjUzNjUKKyM6IGRpZmYuYzo1MzY4CiBtc2dpZCAicHJlcGVuZCBhbiBhZGRpdGlvbmFsIHByZWZpeCB0byBldmVyeSBsaW5lIG9mIG91dHB1dCIKIG1zZ3N0ciAicHLDqWZpeGVyIHRvdXRlcyBsZXMgbGlnbmVzIGVuIHNvcnRpZSBhdmVjIGxhIGNoYcOubmUgaW5kaXF1w6llIgogCi0jOiBkaWZmLmM6NTM2OAorIzogZGlmZi5jOjUzNzEKIG1zZ2lkICJkbyBub3Qgc2hvdyBhbnkgc291cmNlIG9yIGRlc3RpbmF0aW9uIHByZWZpeCIKIG1zZ3N0ciAibidhZmZpY2hlciBhdWN1biBwcsOpZml4ZSwgbmkgZGUgc291cmNlLCBuaSBkZSBkZXN0aW5hdGlvbiIKIAotIzogZGlmZi5jOjUzNzEKKyM6IGRpZmYuYzo1Mzc0CiBtc2dpZCAic2hvdyBjb250ZXh0IGJldHdlZW4gZGlmZiBodW5rcyB1cCB0byB0aGUgc3BlY2lmaWVkIG51bWJlciBvZiBsaW5lcyIKIG1zZ3N0ciAiIgogImFmZmljaGVyIGxlIGNvbnRleHRlIGVudHJlIGxlcyBzZWN0aW9ucyDDoCBjb25jdXJyZW5jZSBkdSBub21icmUgZGUgbGlnbmUgIgogImluZGlxdcOpIgogCi0jOiBkaWZmLmM6NTM3NSBkaWZmLmM6NTM4MCBkaWZmLmM6NTM4NQorIzogZGlmZi5jOjUzNzggZGlmZi5jOjUzODMgZGlmZi5jOjUzODgKIG1zZ2lkICI8Y2hhcj4iCiBtc2dzdHIgIjxjYXJhY3TDqHJlPiIKIAotIzogZGlmZi5jOjUzNzYKKyM6IGRpZmYuYzo1Mzc5CiBtc2dpZCAic3BlY2lmeSB0aGUgY2hhcmFjdGVyIHRvIGluZGljYXRlIGEgbmV3IGxpbmUgaW5zdGVhZCBvZiAnKyciCiBtc2dzdHIgInNww6ljaWZpZXIgbGUgY2FyYWN0w6hyZSBwb3VyIGluZGlxdWVyIHVuZSBub3V2ZWxsZSBsaWduZSBhdSBsaWV1IGRlICcrJyIKIAotIzogZGlmZi5jOjUzODEKKyM6IGRpZmYuYzo1Mzg0CiBtc2dpZCAic3BlY2lmeSB0aGUgY2hhcmFjdGVyIHRvIGluZGljYXRlIGFuIG9sZCBsaW5lIGluc3RlYWQgb2YgJy0nIgogbXNnc3RyICJzcMOpY2lmaWVyIGxlIGNhcmFjdMOocmUgcG91ciBpbmRpcXVlciB1bmUgYW5jaWVubmUgbGlnbmUgYXUgbGlldSBkZSAnLSciCiAKLSM6IGRpZmYuYzo1Mzg2CisjOiBkaWZmLmM6NTM4OQogbXNnaWQgInNwZWNpZnkgdGhlIGNoYXJhY3RlciB0byBpbmRpY2F0ZSBhIGNvbnRleHQgaW5zdGVhZCBvZiAnICciCiBtc2dzdHIgIiIKICJzcMOpY2lmaWVyIGxlIGNhcmFjdMOocmUgcG91ciBpbmRpcXVlciB1bmUgbGlnbmUgZGUgY29udGV4dGUgYXUgbGlldSBkZSAnICciCiAKLSM6IGRpZmYuYzo1Mzg5CisjOiBkaWZmLmM6NTM5MgogbXNnaWQgIkRpZmYgcmVuYW1lIG9wdGlvbnMiCiBtc2dzdHIgIk9wdGlvbnMgZGUgcmVub21tYWdlIGRlIGRpZmYiCiAKLSM6IGRpZmYuYzo1MzkwCisjOiBkaWZmLmM6NTM5MwogbXNnaWQgIjxuPlsvPG0+XSIKIG1zZ3N0ciAiPG4+Wy88bT5dIgogCi0jOiBkaWZmLmM6NTM5MQorIzogZGlmZi5jOjUzOTQKIG1zZ2lkICJicmVhayBjb21wbGV0ZSByZXdyaXRlIGNoYW5nZXMgaW50byBwYWlycyBvZiBkZWxldGUgYW5kIGNyZWF0ZSIKIG1zZ3N0ciAiIgogImNhc3NlciBsZXMgbW9kaWZpY2F0aW9ucyBkJ3VuZSByw6nDqWNyaXJlIGNvbXBsw6h0ZSBlbiBwYWlyZXMgZGUgc3VwcHJlc3Npb24gZXQgIgogImNyw6lhdGlvbiIKIAotIzogZGlmZi5jOjUzOTUKKyM6IGRpZmYuYzo1Mzk4CiBtc2dpZCAiZGV0ZWN0IHJlbmFtZXMiCiBtc2dzdHIgImTDqXRlY3RlciBsZXMgcmVub21tYWdlcyIKIAotIzogZGlmZi5jOjUzOTkKKyM6IGRpZmYuYzo1NDAyCiBtc2dpZCAib21pdCB0aGUgcHJlaW1hZ2UgZm9yIGRlbGV0ZXMiCiBtc2dzdHIgInN1cHByaW1lciBsYSBwcsOpLWltYWdlIHBvdXIgbGVzIHN1cHByZXNzaW9ucyIKIAotIzogZGlmZi5jOjU0MDIKKyM6IGRpZmYuYzo1NDA1CiBtc2dpZCAiZGV0ZWN0IGNvcGllcyIKIG1zZ3N0ciAiZMOpdGVjdGVyIGxlcyBjb3BpZXMiCiAKLSM6IGRpZmYuYzo1NDA2CisjOiBkaWZmLmM6NTQwOQogbXNnaWQgInVzZSB1bm1vZGlmaWVkIGZpbGVzIGFzIHNvdXJjZSB0byBmaW5kIGNvcGllcyIKIG1zZ3N0ciAiIgogInV0aWxpc2VyIGxlcyBmaWNoaWVycyBub24tbW9kaWZpw6lzIGNvbW1lIHNvdXJjZXMgcG91ciB0cm91dmVyIGRlcyBjb3BpZXMiCiAKLSM6IGRpZmYuYzo1NDA4CisjOiBkaWZmLmM6NTQxMQogbXNnaWQgImRpc2FibGUgcmVuYW1lIGRldGVjdGlvbiIKIG1zZ3N0ciAiZMOpc2FjdGl2ZXIgbGEgZMOpdGVjdGlvbiBkZSByZW5vbW1hZ2UiCiAKLSM6IGRpZmYuYzo1NDExCisjOiBkaWZmLmM6NTQxNAogbXNnaWQgInVzZSBlbXB0eSBibG9icyBhcyByZW5hbWUgc291cmNlIgogbXNnc3RyICJ1dGlsaXNlciBkZXMgYmxvYnMgdmlkZXMgY29tbWUgc291cmNlIGRlIHJlbm9tbWFnZSIKIAotIzogZGlmZi5jOjU0MTMKKyM6IGRpZmYuYzo1NDE2CiBtc2dpZCAiY29udGludWUgbGlzdGluZyB0aGUgaGlzdG9yeSBvZiBhIGZpbGUgYmV5b25kIHJlbmFtZXMiCiBtc2dzdHIgImNvbnRpbnVlciDDoCBhZmZpY2hlciBsJ2hpc3RvcmlxdWUgZCd1biBmaWNoaWVyIGF1IGRlbMOgIGRlcyByZW5vbW1hZ2VzIgogCi0jOiBkaWZmLmM6NTQxNgorIzogZGlmZi5jOjU0MTkKIG1zZ2lkICIiCiAicHJldmVudCByZW5hbWUvY29weSBkZXRlY3Rpb24gaWYgdGhlIG51bWJlciBvZiByZW5hbWUvY29weSB0YXJnZXRzIGV4Y2VlZHMgIgogImdpdmVuIGxpbWl0IgpAQCAtMjkxMSwxNjEgKzI5MjAsMTYxIEBACiAiZW1ww6pjaGVyIGxhIGTDqXRlY3Rpb24gZGUgcmVub21tYWdlL2NvcGllIHNpIGxlIG5vbWJyZSBkZSBjaWJsZXMgZGUgcmVub21tYWdlLyIKICJjb3BpZSBleGPDqGRlIGxhIGxpbWl0ZSBpbmRpcXXDqWUiCiAKLSM6IGRpZmYuYzo1NDE4CisjOiBkaWZmLmM6NTQyMQogbXNnaWQgIkRpZmYgYWxnb3JpdGhtIG9wdGlvbnMiCiBtc2dzdHIgIk9wdGlvbnMgZGUgbCdhbGdvcml0aG1lIGRlIGRpZmYiCiAKLSM6IGRpZmYuYzo1NDIwCisjOiBkaWZmLmM6NTQyMwogbXNnaWQgInByb2R1Y2UgdGhlIHNtYWxsZXN0IHBvc3NpYmxlIGRpZmYiCiBtc2dzdHIgInByb2R1aXJlIGxlIGRpZmYgbGUgcGx1cyBwZXRpdCBwb3NzaWJsZSIKIAotIzogZGlmZi5jOjU0MjMKKyM6IGRpZmYuYzo1NDI2CiBtc2dpZCAiaWdub3JlIHdoaXRlc3BhY2Ugd2hlbiBjb21wYXJpbmcgbGluZXMiCiBtc2dzdHIgImlnbm9yZXIgbGVzIGVzcGFjZXMgbG9ycyBkZSBsYSBjb21wYXJhaXNvbiBkZSBsaWduZSIKIAotIzogZGlmZi5jOjU0MjYKKyM6IGRpZmYuYzo1NDI5CiBtc2dpZCAiaWdub3JlIGNoYW5nZXMgaW4gYW1vdW50IG9mIHdoaXRlc3BhY2UiCiBtc2dzdHIgImlnbm9yZXIgZGVzIG1vZGlmaWNhdGlvbnMgZHUgbm9tYnJlIGQnZXNwYWNlcyIKIAotIzogZGlmZi5jOjU0MjkKKyM6IGRpZmYuYzo1NDMyCiBtc2dpZCAiaWdub3JlIGNoYW5nZXMgaW4gd2hpdGVzcGFjZSBhdCBFT0wiCiBtc2dzdHIgImlnbm9yZXIgZGVzIG1vZGlmaWNhdGlvbnMgZCdlc3BhY2UgZW4gZmluIGRlIGxpZ25lIgogCi0jOiBkaWZmLmM6NTQzMgorIzogZGlmZi5jOjU0MzUKIG1zZ2lkICJpZ25vcmUgY2Fycmllci1yZXR1cm4gYXQgdGhlIGVuZCBvZiBsaW5lIgogbXNnc3RyICJpZ25vcmUgbGUgcmV0b3VyIGNoYXJpb3QgZW4gZmluIGRlIGxpZ25lIgogCi0jOiBkaWZmLmM6NTQzNQorIzogZGlmZi5jOjU0MzgKIG1zZ2lkICJpZ25vcmUgY2hhbmdlcyB3aG9zZSBsaW5lcyBhcmUgYWxsIGJsYW5rIgogbXNnc3RyICJpZ25vcmVyIGxlcyBtb2RpZmljYXRpb25zIGRvbnQgbGVzIGxpZ25lcyBzb250IHZpZGVzIgogCi0jOiBkaWZmLmM6NTQzOAorIzogZGlmZi5jOjU0NDEKIG1zZ2lkICJoZXVyaXN0aWMgdG8gc2hpZnQgZGlmZiBodW5rIGJvdW5kYXJpZXMgZm9yIGVhc3kgcmVhZGluZyIKIG1zZ3N0ciAiIgogImhldXJpc3RpcXVlIHF1aSBkw6lwbGFjZSBsZXMgbGltaXRlcyBkZSBzZWN0aW9ucyBkZSBkaWZmIHBvdXIgZmFjaWxpdGVyIGxhICIKICJsZWN0dXJlIgogCi0jOiBkaWZmLmM6NTQ0MQorIzogZGlmZi5jOjU0NDQKIG1zZ2lkICJnZW5lcmF0ZSBkaWZmIHVzaW5nIHRoZSBcInBhdGllbmNlIGRpZmZcIiBhbGdvcml0aG0iCiBtc2dzdHIgImfDqW7DqXJlciB1biBkaWZmIGVuIHV0aWxpc2FudCBsJ2FsZ29yaXRobWUgZGUgZGlmZsOpcmVuY2UgXCJwYXRpZW5jZVwiIgogCi0jOiBkaWZmLmM6NTQ0NQorIzogZGlmZi5jOjU0NDgKIG1zZ2lkICJnZW5lcmF0ZSBkaWZmIHVzaW5nIHRoZSBcImhpc3RvZ3JhbSBkaWZmXCIgYWxnb3JpdGhtIgogbXNnc3RyICIiCiAiZ8OpbsOpcmVyIHVuIGRpZmYgZW4gdXRpbGlzYW50IGwnYWxnb3JpdGhtZSBkZSBkaWZmw6lyZW5jZSBcImhpc3RvZ3JhbW1lXCIiCiAKLSM6IGRpZmYuYzo1NDQ3CisjOiBkaWZmLmM6NTQ1MAogbXNnaWQgIjxhbGdvcml0aG0+IgogbXNnc3RyICI8YWxnb3JpdGhtZT4iCiAKLSM6IGRpZmYuYzo1NDQ4CisjOiBkaWZmLmM6NTQ1MQogbXNnaWQgImNob29zZSBhIGRpZmYgYWxnb3JpdGhtIgogbXNnc3RyICJjaG9pc2lyIHVuIGFsZ29yaXRobWUgZGUgZGlmZsOpcmVuY2UiCiAKLSM6IGRpZmYuYzo1NDUwCisjOiBkaWZmLmM6NTQ1MwogbXNnaWQgIjx0ZXh0PiIKIG1zZ3N0ciAiPHRleHRlPiIKIAotIzogZGlmZi5jOjU0NTEKKyM6IGRpZmYuYzo1NDU0CiBtc2dpZCAiZ2VuZXJhdGUgZGlmZiB1c2luZyB0aGUgXCJhbmNob3JlZCBkaWZmXCIgYWxnb3JpdGhtIgogbXNnc3RyICJnw6luw6lyZXIgdW4gZGlmZiBlbiB1dGlsaXNhbnQgbCdhbGdvcml0aG1lIGRlIGRpZmbDqXJlbmNlIFwiYW5jcsOpXCIiCiAKLSM6IGRpZmYuYzo1NDUzIGRpZmYuYzo1NDYyIGRpZmYuYzo1NDY1CisjOiBkaWZmLmM6NTQ1NiBkaWZmLmM6NTQ2NSBkaWZmLmM6NTQ2OAogbXNnaWQgIjxtb2RlPiIKIG1zZ3N0ciAiPG1vZGU+IgogCi0jOiBkaWZmLmM6NTQ1NAorIzogZGlmZi5jOjU0NTcKIG1zZ2lkICJzaG93IHdvcmQgZGlmZiwgdXNpbmcgPG1vZGU+IHRvIGRlbGltaXQgY2hhbmdlZCB3b3JkcyIKIG1zZ3N0ciAiIgogImFmZmljaGVyIGRlcyBkaWZmw6lyZW5jZXMgcGFyIG1vdCwgZW4gdXRpbGlzYW50IDxtb2RlPiBwb3VyIGTDqWxpbWl0ZXIgbGVzICIKICJtb3RzIG1vZGlmacOpcyIKIAotIzogZGlmZi5jOjU0NTYgZGlmZi5jOjU0NTkgZGlmZi5jOjU1MDQKKyM6IGRpZmYuYzo1NDU5IGRpZmYuYzo1NDYyIGRpZmYuYzo1NTA3CiBtc2dpZCAiPHJlZ2V4PiIKIG1zZ3N0ciAiPHJlZ2V4PiIKIAotIzogZGlmZi5jOjU0NTcKKyM6IGRpZmYuYzo1NDYwCiBtc2dpZCAidXNlIDxyZWdleD4gdG8gZGVjaWRlIHdoYXQgYSB3b3JkIGlzIgogbXNnc3RyICJ1dGlsaXNlciA8cmVnZXg+IHBvdXIgZMOpY2lkZXIgY2UgcXUnZXN0IHVuIG1vdCIKIAotIzogZGlmZi5jOjU0NjAKKyM6IGRpZmYuYzo1NDYzCiBtc2dpZCAiZXF1aXZhbGVudCB0byAtLXdvcmQtZGlmZj1jb2xvciAtLXdvcmQtZGlmZi1yZWdleD08cmVnZXg+IgogbXNnc3RyICLDqXF1aXZhbGVudCDDoCAtLXdvcmQtZGlmZj1jb2xvciAtLXdvcmQtZGlmZi1yZWdleD08cmVnZXg+IgogCi0jOiBkaWZmLmM6NTQ2MworIzogZGlmZi5jOjU0NjYKIG1zZ2lkICJtb3ZlZCBsaW5lcyBvZiBjb2RlIGFyZSBjb2xvcmVkIGRpZmZlcmVudGx5IgogbXNnc3RyICJsZXMgbGlnbmVzIGTDqXBsYWPDqWVzIHNvbnQgY29sb3LDqWVzIGRpZmbDqXJlbW1lbnQiCiAKLSM6IGRpZmYuYzo1NDY2CisjOiBkaWZmLmM6NTQ2OQogbXNnaWQgImhvdyB3aGl0ZSBzcGFjZXMgYXJlIGlnbm9yZWQgaW4gLS1jb2xvci1tb3ZlZCIKIG1zZ3N0ciAiY29tbWVudCBsZXMgZXNwYWNlcyBzb250IGlnbm9yw6lzIGRhbnMgLS1jb2xvci1tb3ZlZCIKIAotIzogZGlmZi5jOjU0NjkKKyM6IGRpZmYuYzo1NDcyCiBtc2dpZCAiT3RoZXIgZGlmZiBvcHRpb25zIgogbXNnc3RyICJBdXRyZXMgb3B0aW9ucyBkaWZmIgogCi0jOiBkaWZmLmM6NTQ3MQorIzogZGlmZi5jOjU0NzQKIG1zZ2lkICJ3aGVuIHJ1biBmcm9tIHN1YmRpciwgZXhjbHVkZSBjaGFuZ2VzIG91dHNpZGUgYW5kIHNob3cgcmVsYXRpdmUgcGF0aHMiCiBtc2dzdHIgIiIKICJsYW5jw6kgZGVwdWlzIHVuIHNvdXMtcsOpcGVydG9pcmUsIGV4Y2x1cmUgbGVzIG1vZGlmaWNhdGlvbnMgZW4gZGVob3JzIGV0ICIKICJhZmZpY2hlciBsZXMgY2hlbWlucyByZWxhdGlmcyIKIAotIzogZGlmZi5jOjU0NzUKKyM6IGRpZmYuYzo1NDc4CiBtc2dpZCAidHJlYXQgYWxsIGZpbGVzIGFzIHRleHQiCiBtc2dzdHIgInRyYWl0ZXIgbGVzIGZpY2hpZXJzIGNvbW1lIHRleHRlIgogCi0jOiBkaWZmLmM6NTQ3NworIzogZGlmZi5jOjU0ODAKIG1zZ2lkICJzd2FwIHR3byBpbnB1dHMsIHJldmVyc2UgdGhlIGRpZmYiCiBtc2dzdHIgIsOpY2hhbmdlciBsZXMgZW50csOpZXMsIGludmVyc2VyIGxlIGRpZmYiCiAKLSM6IGRpZmYuYzo1NDc5CisjOiBkaWZmLmM6NTQ4MgogbXNnaWQgImV4aXQgd2l0aCAxIGlmIHRoZXJlIHdlcmUgZGlmZmVyZW5jZXMsIDAgb3RoZXJ3aXNlIgogbXNnc3RyICJzb3J0aXIgdW4gY29kZSBkJ2VycmV1ciAxIHMnaWwgeSBhdmFpdCBkZSBkaWZmw6lyZW5jZXMsIDAgc2lub24iCiAKLSM6IGRpZmYuYzo1NDgxCisjOiBkaWZmLmM6NTQ4NAogbXNnaWQgImRpc2FibGUgYWxsIG91dHB1dCBvZiB0aGUgcHJvZ3JhbSIKIG1zZ3N0ciAiZMOpc2FjdGl2ZXIgdG91cyBsZXMgYWZmaWNoYWdlcyBkdSBwcm9ncmFtbWUiCiAKLSM6IGRpZmYuYzo1NDgzCisjOiBkaWZmLmM6NTQ4NgogbXNnaWQgImFsbG93IGFuIGV4dGVybmFsIGRpZmYgaGVscGVyIHRvIGJlIGV4ZWN1dGVkIgogbXNnc3RyICJhdXRvcmlzZXIgbCdleMOpY3V0aW9uIGQndW4gYXNzaXN0YW50IGV4dGVybmUgZGUgZGlmZiIKIAotIzogZGlmZi5jOjU0ODUKKyM6IGRpZmYuYzo1NDg4CiBtc2dpZCAicnVuIGV4dGVybmFsIHRleHQgY29udmVyc2lvbiBmaWx0ZXJzIHdoZW4gY29tcGFyaW5nIGJpbmFyeSBmaWxlcyIKIG1zZ3N0ciAiIgogImxhbmNlciBsZXMgZmlsdHJlcyBleHRlcm5lcyBkZSBjb252ZXJzaW9uIGVuIHRleHRlIGxvcnMgZGUgbGEgY29tcGFyYWlzb24gZGUgIgogImZpY2hpZXJzIGJpbmFpcmVzIgogCi0jOiBkaWZmLmM6NTQ4NworIzogZGlmZi5jOjU0OTAKIG1zZ2lkICI8d2hlbj4iCiBtc2dzdHIgIjxxdWFuZD4iCiAKLSM6IGRpZmYuYzo1NDg4CisjOiBkaWZmLmM6NTQ5MQogbXNnaWQgImlnbm9yZSBjaGFuZ2VzIHRvIHN1Ym1vZHVsZXMgaW4gdGhlIGRpZmYgZ2VuZXJhdGlvbiIKIG1zZ3N0ciAiIgogImlnbm9yZXIgbGVzIG1vZGlmaWNhdGlvbnMgZGFucyBsZXMgc291cy1tb2R1bGVzIGxvcnMgZGUgbGEgZ8OpbsOpcmF0aW9uIGRlIGRpZmYiCiAKLSM6IGRpZmYuYzo1NDkxCisjOiBkaWZmLmM6NTQ5NAogbXNnaWQgIjxmb3JtYXQ+IgogbXNnc3RyICI8Zm9ybWF0PiIKIAotIzogZGlmZi5jOjU0OTIKKyM6IGRpZmYuYzo1NDk1CiBtc2dpZCAic3BlY2lmeSBob3cgZGlmZmVyZW5jZXMgaW4gc3VibW9kdWxlcyBhcmUgc2hvd24iCiBtc2dzdHIgInNww6ljaWZpZXIgY29tbWVudCBsZXMgZGlmZsOpcmVuY2VzIGRhbnMgbGVzIHNvdXMtbW9kdWxlcyBzb250IGFmZmljaMOpZXMiCiAKLSM6IGRpZmYuYzo1NDk2CisjOiBkaWZmLmM6NTQ5OQogbXNnaWQgImhpZGUgJ2dpdCBhZGQgLU4nIGVudHJpZXMgZnJvbSB0aGUgaW5kZXgiCiBtc2dzdHIgIm1hc3F1ZXIgbGVzIGVudHLDqWVzICdnaXQgYWRkIC1OJyBkZSBsJ2luZGV4IgogCi0jOiBkaWZmLmM6NTQ5OQorIzogZGlmZi5jOjU1MDIKIG1zZ2lkICJ0cmVhdCAnZ2l0IGFkZCAtTicgZW50cmllcyBhcyByZWFsIGluIHRoZSBpbmRleCIKIG1zZ3N0ciAidHJhaXRlciBsZXMgZW50csOpZXMgJ2dpdCBhZGQgLU4nIGNvbW1lIHLDqWVsbGVzIGRhbnMgbCdpbmRleCIKIAotIzogZGlmZi5jOjU1MDEKKyM6IGRpZmYuYzo1NTA0CiBtc2dpZCAiPHN0cmluZz4iCiBtc2dzdHIgIjxjaGHDrm5lPiIKIAotIzogZGlmZi5jOjU1MDIKKyM6IGRpZmYuYzo1NTA1CiBtc2dpZCAiIgogImxvb2sgZm9yIGRpZmZlcmVuY2VzIHRoYXQgY2hhbmdlIHRoZSBudW1iZXIgb2Ygb2NjdXJyZW5jZXMgb2YgdGhlIHNwZWNpZmllZCAiCiAic3RyaW5nIgpAQCAtMzA3Myw3ICszMDgyLDcgQEAKICJyZWNoZXJjaGVyIGxlcyBkaWZmw6lyZW5jZXMgcXVpIG1vZGlmaWVudCBsZSBub21icmUgZCdvY2N1cnJlbmNlcyBkZSBsYSAiCiAiY2hhw65uZSBzcMOpY2lmacOpZSIKIAotIzogZGlmZi5jOjU1MDUKKyM6IGRpZmYuYzo1NTA4CiBtc2dpZCAiIgogImxvb2sgZm9yIGRpZmZlcmVuY2VzIHRoYXQgY2hhbmdlIHRoZSBudW1iZXIgb2Ygb2NjdXJyZW5jZXMgb2YgdGhlIHNwZWNpZmllZCAiCiAicmVnZXgiCkBAIC0zMDgxLDI2ICszMDkwLDI2IEBACiAicmVjaGVyY2hlciBsZXMgZGlmZsOpcmVuY2VzIHF1aSBtb2RpZmllbnQgbGUgbm9tYnJlIGQnb2NjdXJyZW5jZXMgZGUgbGEgcmVnZXggIgogInNww6ljaWZpw6llIgogCi0jOiBkaWZmLmM6NTUwOAorIzogZGlmZi5jOjU1MTEKIG1zZ2lkICJzaG93IGFsbCBjaGFuZ2VzIGluIHRoZSBjaGFuZ2VzZXQgd2l0aCAtUyBvciAtRyIKIG1zZ3N0ciAiIgogImFmZmljaGVyIHRvdXRlcyBsZXMgbW9kaWZpY2F0aW9ucyBkYW5zIGwnZW5zZW1ibGUgZGUgbW9kaWZpY2F0aW9ucyBhdmVjIC1TICIKICJvdSAtRyIKIAotIzogZGlmZi5jOjU1MTEKKyM6IGRpZmYuYzo1NTE0CiBtc2dpZCAidHJlYXQgPHN0cmluZz4gaW4gLVMgYXMgZXh0ZW5kZWQgUE9TSVggcmVndWxhciBleHByZXNzaW9uIgogbXNnc3RyICIiCiAidHJhaXRlciA8Y2hhw65uZT4gZGFucyAtUyBjb21tZSB1bmUgZXhwcmVzc2lvbiByYXRpb25uZWxsZSBQT1NJWCDDqXRlbmR1ZSIKIAotIzogZGlmZi5jOjU1MTQKKyM6IGRpZmYuYzo1NTE3CiBtc2dpZCAiY29udHJvbCB0aGUgb3JkZXIgaW4gd2hpY2ggZmlsZXMgYXBwZWFyIGluIHRoZSBvdXRwdXQiCiBtc2dzdHIgImNvbnRyw7RsZXIgbCdvcmRyZSBkYW5zIGxlcXVlbCBsZXMgZmljaGllcnMgYXBwYXJhaXNzZW50IGRhbnMgbGEgc29ydGllIgogCi0jOiBkaWZmLmM6NTUxNQorIzogZGlmZi5jOjU1MTgKIG1zZ2lkICI8b2JqZWN0LWlkPiIKIG1zZ3N0ciAiPGlkLW9iamV0PiIKIAotIzogZGlmZi5jOjU1MTYKKyM6IGRpZmYuYzo1NTE5CiBtc2dpZCAiIgogImxvb2sgZm9yIGRpZmZlcmVuY2VzIHRoYXQgY2hhbmdlIHRoZSBudW1iZXIgb2Ygb2NjdXJyZW5jZXMgb2YgdGhlIHNwZWNpZmllZCAiCiAib2JqZWN0IgpAQCAtMzEwOCwzNSArMzExNywzNSBAQAogInJlY2hlcmNoZXIgbGVzIGRpZmbDqXJlbmNlcyBxdWkgbW9kaWZpZW50IGxlIG5vbWJyZSBkJ29jY3VycmVuY2VzIGRlIGwnb2JqZXQgIgogImluZGlxdcOpIgogCi0jOiBkaWZmLmM6NTUxOAorIzogZGlmZi5jOjU1MjEKIG1zZ2lkICJbKEF8Q3xEfE18UnxUfFV8WHxCKS4uLlsqXV0iCiBtc2dzdHIgIlsoQXxDfER8TXxSfFR8VXxYfEIpLi4uWypdXSIKIAotIzogZGlmZi5jOjU1MTkKKyM6IGRpZmYuYzo1NTIyCiBtc2dpZCAic2VsZWN0IGZpbGVzIGJ5IGRpZmYgdHlwZSIKIG1zZ3N0ciAic8OpbGVjdGlvbm5lciBsZXMgZmljaGllcnMgcGFyIHR5cGVzIGRlIGRpZmYiCiAKLSM6IGRpZmYuYzo1NTIxCisjOiBkaWZmLmM6NTUyNAogbXNnaWQgIjxmaWxlPiIKIG1zZ3N0ciAiPGZpY2hpZXI+IgogCi0jOiBkaWZmLmM6NTUyMgorIzogZGlmZi5jOjU1MjUKIG1zZ2lkICJPdXRwdXQgdG8gYSBzcGVjaWZpYyBmaWxlIgogbXNnc3RyICJTb3J0aWUgdmVycyB1biBmaWNoaWVyIHNww6ljaWZpw6kiCiAKLSM6IGRpZmYuYzo2MTc3CisjOiBkaWZmLmM6NjE4MAogbXNnaWQgImluZXhhY3QgcmVuYW1lIGRldGVjdGlvbiB3YXMgc2tpcHBlZCBkdWUgdG8gdG9vIG1hbnkgZmlsZXMuIgogbXNnc3RyICIiCiAiZMOpdGVjdGlvbiBkZSByZW5vbW1hZ2UgaW5leGFjdCBhbm51bMOpZSDDoCBjYXVzZSBkJ3VuIHRyb3AgZ3JhbmQgbm9tYnJlIGRlICIKICJmaWNoaWVycy4iCiAKLSM6IGRpZmYuYzo2MTgwCisjOiBkaWZmLmM6NjE4MwogbXNnaWQgIm9ubHkgZm91bmQgY29waWVzIGZyb20gbW9kaWZpZWQgcGF0aHMgZHVlIHRvIHRvbyBtYW55IGZpbGVzLiIKIG1zZ3N0ciAiIgogInJlY2hlcmNoZSB1bmlxdWVtZW50IGRlcyBjb3BpZXMgcGFyIG1vZGlmaWNhdGlvbiBkZSBjaGVtaW4gw6AgY2F1c2UgZCd1biB0cm9wICIKICJncmFuZCBub21icmUgZGUgZmljaGllcnMuIgogCi0jOiBkaWZmLmM6NjE4MworIzogZGlmZi5jOjYxODYKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogInlvdSBtYXkgd2FudCB0byBzZXQgeW91ciAlcyB2YXJpYWJsZSB0byBhdCBsZWFzdCAlZCBhbmQgcmV0cnkgdGhlIGNvbW1hbmQuIgpAQCAtMzE0NCw0MSArMzE1Myw0MSBAQAogInZvdXMgc291aGFpdGV6IHBldXQtw6p0cmUgcsOpZ2xlciBsYSB2YXJpYWJsZSAlcyDDoCBhdSBtb2lucyAlZCBldCByw6llc3NheWVyIGxlICIKICJjb21tYW5kZS4iCiAKLSM6IGRpci5jOjUzNworIzogZGlyLmM6NTQ5CiAjLCBjLWZvcm1hdAogbXNnaWQgInBhdGhzcGVjICclcycgZGlkIG5vdCBtYXRjaCBhbnkgZmlsZShzKSBrbm93biB0byBnaXQiCiBtc2dzdHIgIiIKICJsZSBzcMOpY2lmaWNhdGV1ciBkZSBjaGVtaW4gJyVzJyBuZSBjb3JyZXNwb25kIMOgIGF1Y3VuIGZpY2hpZXIgY29ubnUgZGUgZ2l0IgogCi0jOiBkaXIuYzo5MjYKKyM6IGRpci5jOjkzOAogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgdXNlICVzIGFzIGFuIGV4Y2x1ZGUgZmlsZSIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkJ3V0aWxpc2VyICVzIGNvbW1lIGZpY2hpZXIgZCdleGNsdXNpb24iCiAKLSM6IGRpci5jOjE4NDMKKyM6IGRpci5jOjE4NzcKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IG9wZW4gZGlyZWN0b3J5ICclcyciCiBtc2dzdHIgImltcG9zc2libGUgZCdvdXZyaXIgbGUgcsOpcGVydG9pcmUgJyVzJyIKIAotIzogZGlyLmM6MjA4NQorIzogZGlyLmM6MjEyOAogbXNnaWQgImZhaWxlZCB0byBnZXQga2VybmVsIG5hbWUgYW5kIGluZm9ybWF0aW9uIgogbXNnc3RyICJlY2hlYyBkZSBsJ29idGVudGlvbiBkJ2luZm9ybWF0aW9uIGRlIGtlcm5lbCIKIAotIzogZGlyLmM6MjIwOQorIzogZGlyLmM6MjI1MgogbXNnaWQgInVudHJhY2tlZCBjYWNoZSBpcyBkaXNhYmxlZCBvbiB0aGlzIHN5c3RlbSBvciBsb2NhdGlvbiIKIG1zZ3N0ciAiTGUgY2FjaGUgbm9uIHN1aXZpIGVzdCBkw6lzYWN0aXbDqSBzdXIgY2Ugc3lzdMOobWUgb3Ugc3VyIGNldCBlbmRyb2l0IgogCi0jOiBkaXIuYzozMDEzCisjOiBkaXIuYzozMDU2CiAjLCBjLWZvcm1hdAogbXNnaWQgImluZGV4IGZpbGUgY29ycnVwdCBpbiByZXBvICVzIgogbXNnc3RyICJmaWNoaWVyIGQnaW5kZXggY29ycm9tcHUgZGFucyBsZSBkw6lww7R0ICVzIgogCi0jOiBkaXIuYzozMDU4IGRpci5jOjMwNjMKKyM6IGRpci5jOjMxMDEgZGlyLmM6MzEwNgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgY3JlYXRlIGRpcmVjdG9yaWVzIGZvciAlcyIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkZSBjcsOpZXIgbGVzIHLDqXBlcnRvaXJlcyBwb3VyICVzIgogCi0jOiBkaXIuYzozMDkyCisjOiBkaXIuYzozMTM1CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBtaWdyYXRlIGdpdCBkaXJlY3RvcnkgZnJvbSAnJXMnIHRvICclcyciCiBtc2dzdHIgImltcG9zc2libGUgZGUgbWlncmVyIGxlIHLDqXBlcnRvaXJlIGdpdCBkZSAnJXMnIHZlcnMgJyVzJyIKQEAgLTMxOTksMTIgKzMyMDgsMTIgQEAKIG1zZ2lkICJjb3VsZCBub3Qgc3RhdCBmaWxlICclcyciCiBtc2dzdHIgImltcG9zc2libGUgZGUgc3RhdCBsZSBmaWNoaWVyICclcyciCiAKLSM6IGVudmlyb25tZW50LmM6MTUwCisjOiBlbnZpcm9ubWVudC5jOjE0OAogIywgYy1mb3JtYXQKIG1zZ2lkICJiYWQgZ2l0IG5hbWVzcGFjZSBwYXRoIFwiJXNcIiIKIG1zZ3N0ciAiRXNwYWNlcyBkZSBub20gZGUgR2l0IFwiJXNcIiIKIAotIzogZW52aXJvbm1lbnQuYzozMzIKKyM6IGVudmlyb25tZW50LmM6MzMwCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBzZXQgR0lUX0RJUiB0byAnJXMnIgogbXNnc3RyICJpbXBvc3NpYmxlIGRlIHLDqWdsZXIgR0lUX0RJUiDDoCAnJXMnIgpAQCAtMzIxNCwxNTkgKzMyMjMsMTU1IEBACiBtc2dpZCAidG9vIG1hbnkgYXJncyB0byBydW4gJXMiCiBtc2dzdHIgInRyb3AgZCdhcmd1bWVudHMgcG91ciBsYW5jZXIgJXMiCiAKLSM6IGZldGNoLW9iamVjdC5jOjE3Ci1tc2dpZCAiUmVtb3RlIHdpdGggbm8gVVJMIgotbXNnc3RyICJEw6lww7R0IGRpc3RhbnQgc2FucyBVUkwiCi0KLSM6IGZldGNoLXBhY2suYzoxNTEKKyM6IGZldGNoLXBhY2suYzoxNTAKIG1zZ2lkICJnaXQgZmV0Y2gtcGFjazogZXhwZWN0ZWQgc2hhbGxvdyBsaXN0IgogbXNnc3RyICJnaXQgZmV0Y2gtcGFjayA6IGxpc3RlIHN1cGVyZmljaWVsbGUgYXR0ZW5kdWUiCiAKLSM6IGZldGNoLXBhY2suYzoxNTQKKyM6IGZldGNoLXBhY2suYzoxNTMKIG1zZ2lkICJnaXQgZmV0Y2gtcGFjazogZXhwZWN0ZWQgYSBmbHVzaCBwYWNrZXQgYWZ0ZXIgc2hhbGxvdyBsaXN0IgogbXNnc3RyICIiCiAiZ2l0IGZldGNoLXBhY2sgOiBwYXF1ZXQgZGUgdmlkYWdlIGF0dGVuZHUgYXByw6hzIHVuZSBsaXN0ZSBzdXBlcmZpY2llbGxlIgogCi0jOiBmZXRjaC1wYWNrLmM6MTY1CisjOiBmZXRjaC1wYWNrLmM6MTY0CiBtc2dpZCAiZ2l0IGZldGNoLXBhY2s6IGV4cGVjdGVkIEFDSy9OQUssIGdvdCBhIGZsdXNoIHBhY2tldCIKIG1zZ3N0ciAiZ2l0IGZldGNoLXBhY2sgOiBBQ0svTkFDSyBhdHRlbmR1LCBwYXF1ZXQgZGUgbmV0dG95YWdlIHJlw6d1IgogCi0jOiBmZXRjaC1wYWNrLmM6MTg1CisjOiBmZXRjaC1wYWNrLmM6MTg0CiAjLCBjLWZvcm1hdAogbXNnaWQgImdpdCBmZXRjaC1wYWNrOiBleHBlY3RlZCBBQ0svTkFLLCBnb3QgJyVzJyIKIG1zZ3N0ciAiZ2l0IGZldGNoLXBhY2sgOiBBQ0svTkFDSyBhdHRlbmR1LCAnJXMnIHJlw6d1IgogCi0jOiBmZXRjaC1wYWNrLmM6MTk2CisjOiBmZXRjaC1wYWNrLmM6MTk1CiBtc2dpZCAidW5hYmxlIHRvIHdyaXRlIHRvIHJlbW90ZSIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkJ8OpY3JpcmUgc3VyIHVuIGRpc3RhbnQiCiAKLSM6IGZldGNoLXBhY2suYzoyNTgKKyM6IGZldGNoLXBhY2suYzoyNTcKIG1zZ2lkICItLXN0YXRlbGVzcy1ycGMgcmVxdWlyZXMgbXVsdGlfYWNrX2RldGFpbGVkIgogbXNnc3RyICItLXN0YXRlbGVzcy1ycGMgbsOpY2Vzc2l0ZSBtdWx0aV9hY2tfZGV0YWlsZWQiCiAKLSM6IGZldGNoLXBhY2suYzozNjAgZmV0Y2gtcGFjay5jOjEyODQKKyM6IGZldGNoLXBhY2suYzozNTYgZmV0Y2gtcGFjay5jOjEyODAKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBzaGFsbG93IGxpbmU6ICVzIgogbXNnc3RyICJsaWduZSBkZSBzdXBlcmZpY2llbCBpbnZhbGlkZcKgOiAlcyIKIAotIzogZmV0Y2gtcGFjay5jOjM2NiBmZXRjaC1wYWNrLmM6MTI5MAorIzogZmV0Y2gtcGFjay5jOjM2MiBmZXRjaC1wYWNrLmM6MTI4NgogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIHVuc2hhbGxvdyBsaW5lOiAlcyIKIG1zZ3N0ciAibGlnbmUgZGUgZmluIGRlIHN1cGVyZmljaWVsIGludmFsaWRlIDogJXMiCiAKLSM6IGZldGNoLXBhY2suYzozNjggZmV0Y2gtcGFjay5jOjEyOTIKKyM6IGZldGNoLXBhY2suYzozNjQgZmV0Y2gtcGFjay5jOjEyODgKICMsIGMtZm9ybWF0CiBtc2dpZCAib2JqZWN0IG5vdCBmb3VuZDogJXMiCiBtc2dzdHIgIm9iamV0IG5vbiB0cm91dsOpwqA6ICVzIgogCi0jOiBmZXRjaC1wYWNrLmM6MzcxIGZldGNoLXBhY2suYzoxMjk1CisjOiBmZXRjaC1wYWNrLmM6MzY3IGZldGNoLXBhY2suYzoxMjkxCiAjLCBjLWZvcm1hdAogbXNnaWQgImVycm9yIGluIG9iamVjdDogJXMiCiBtc2dzdHIgIkVycmV1ciBkYW5zIGwnb2JqZXTCoDogJXMiCiAKLSM6IGZldGNoLXBhY2suYzozNzMgZmV0Y2gtcGFjay5jOjEyOTcKKyM6IGZldGNoLXBhY2suYzozNjkgZmV0Y2gtcGFjay5jOjEyOTMKICMsIGMtZm9ybWF0CiBtc2dpZCAibm8gc2hhbGxvdyBmb3VuZDogJXMiCiBtc2dzdHIgIlBhcyBkZSBzdXBlcmZpY2llbCB0cm91dsOpwqA6ICVzIgogCi0jOiBmZXRjaC1wYWNrLmM6Mzc2IGZldGNoLXBhY2suYzoxMzAxCisjOiBmZXRjaC1wYWNrLmM6MzcyIGZldGNoLXBhY2suYzoxMjk3CiAjLCBjLWZvcm1hdAogbXNnaWQgImV4cGVjdGVkIHNoYWxsb3cvdW5zaGFsbG93LCBnb3QgJXMiCiBtc2dzdHIgInN1cGVyZmljaWVsL25vbiBzdXBlcmZpY2llbCBhdHRlbmR1LCAlcyB0cm91dsOpIgogCi0jOiBmZXRjaC1wYWNrLmM6NDE3CisjOiBmZXRjaC1wYWNrLmM6NDE0CiAjLCBjLWZvcm1hdAogbXNnaWQgImdvdCAlcyAlZCAlcyIKIG1zZ3N0ciAicsOpcG9uc2UgJXMgJWQgJXMiCiAKLSM6IGZldGNoLXBhY2suYzo0MzQKKyM6IGZldGNoLXBhY2suYzo0MzEKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBjb21taXQgJXMiCiBtc2dzdHIgImNvbW1pdCBpbnZhbGlkZSAlcyIKIAotIzogZmV0Y2gtcGFjay5jOjQ2NQorIzogZmV0Y2gtcGFjay5jOjQ2MgogbXNnaWQgImdpdmluZyB1cCIKIG1zZ3N0ciAiYWJhbmRvbiIKIAotIzogZmV0Y2gtcGFjay5jOjQ3NyBwcm9ncmVzcy5jOjI3NworIzogZmV0Y2gtcGFjay5jOjQ3NSBwcm9ncmVzcy5jOjMxMgogbXNnaWQgImRvbmUiCiBtc2dzdHIgImZhaXQiCiAKLSM6IGZldGNoLXBhY2suYzo0ODkKKyM6IGZldGNoLXBhY2suYzo0ODcKICMsIGMtZm9ybWF0CiBtc2dpZCAiZ290ICVzICglZCkgJXMiCiBtc2dzdHIgIiVzIHRyb3V2w6kgKCVkKSAlcyIKIAotIzogZmV0Y2gtcGFjay5jOjUzNQorIzogZmV0Y2gtcGFjay5jOjUzMwogIywgYy1mb3JtYXQKIG1zZ2lkICJNYXJraW5nICVzIGFzIGNvbXBsZXRlIgogbXNnc3RyICJNYXJxdWFnZSBkZSAlcyBjb21tZSB0ZXJtaW7DqSIKIAotIzogZmV0Y2gtcGFjay5jOjc0NAorIzogZmV0Y2gtcGFjay5jOjc0MgogIywgYy1mb3JtYXQKIG1zZ2lkICJhbHJlYWR5IGhhdmUgJXMgKCVzKSIKIG1zZ3N0ciAiJXMgZMOpasOgIHBvc3PDqWTDqSAoJXMpIgogCi0jOiBmZXRjaC1wYWNrLmM6NzgzCisjOiBmZXRjaC1wYWNrLmM6NzgxCiBtc2dpZCAiZmV0Y2gtcGFjazogdW5hYmxlIHRvIGZvcmsgb2ZmIHNpZGViYW5kIGRlbXVsdGlwbGV4ZXIiCiBtc2dzdHIgImZldGNoLXBhY2vCoDogaW1wb3NzaWJsZSBkZSBkdXBsaXF1ZXIgbGUgZMOpbXVsdGlwbGV4ZXVyIGxhdMOpcmFsIgogCi0jOiBmZXRjaC1wYWNrLmM6NzkxCisjOiBmZXRjaC1wYWNrLmM6Nzg5CiBtc2dpZCAicHJvdG9jb2wgZXJyb3I6IGJhZCBwYWNrIGhlYWRlciIKIG1zZ3N0ciAiZXJyZXVyIGRlIHByb3RvY29sZcKgOiBtYXV2YWlzIGVudMOqdGUgZGUgcGFxdWV0IgogCi0jOiBmZXRjaC1wYWNrLmM6ODU5CisjOiBmZXRjaC1wYWNrLmM6ODU3CiAjLCBjLWZvcm1hdAogbXNnaWQgImZldGNoLXBhY2s6IHVuYWJsZSB0byBmb3JrIG9mZiAlcyIKIG1zZ3N0ciAiZmV0Y2gtcGFjayA6IGltcG9zc2libGUgZGUgZHVwbGlxdWVyICVzIgogCi0jOiBmZXRjaC1wYWNrLmM6ODc1CisjOiBmZXRjaC1wYWNrLmM6ODczCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIGZhaWxlZCIKIG1zZ3N0ciAiw6ljaGVjIGRlICVzIgogCi0jOiBmZXRjaC1wYWNrLmM6ODc3CisjOiBmZXRjaC1wYWNrLmM6ODc1CiBtc2dpZCAiZXJyb3IgaW4gc2lkZWJhbmQgZGVtdWx0aXBsZXhlciIKIG1zZ3N0ciAiZXJyZXVyIGRhbnMgbGUgZMOpbXVsdGlwbGV4ZXIgbGF0w6lyYWwiCiAKLSM6IGZldGNoLXBhY2suYzo5MDgKKyM6IGZldGNoLXBhY2suYzo5MDcKICMsIGMtZm9ybWF0CiBtc2dpZCAiU2VydmVyIHZlcnNpb24gaXMgJS4qcyIKIG1zZ3N0ciAiTGEgdmVyc2lvbiBkdSBzZXJ2ZXVyIGVzdCAlLipzIgogCi0jOiBmZXRjaC1wYWNrLmM6OTEzIGZldGNoLXBhY2suYzo5MTkgZmV0Y2gtcGFjay5jOjkyMiBmZXRjaC1wYWNrLmM6OTI4Ci0jOiBmZXRjaC1wYWNrLmM6OTMyIGZldGNoLXBhY2suYzo5MzYgZmV0Y2gtcGFjay5jOjk0MCBmZXRjaC1wYWNrLmM6OTQ0Ci0jOiBmZXRjaC1wYWNrLmM6OTQ4IGZldGNoLXBhY2suYzo5NTIgZmV0Y2gtcGFjay5jOjk1NiBmZXRjaC1wYWNrLmM6OTYwCi0jOiBmZXRjaC1wYWNrLmM6OTY2IGZldGNoLXBhY2suYzo5NzIgZmV0Y2gtcGFjay5jOjk3NyBmZXRjaC1wYWNrLmM6OTgyCisjOiBmZXRjaC1wYWNrLmM6OTEyIGZldGNoLXBhY2suYzo5MTggZmV0Y2gtcGFjay5jOjkyMSBmZXRjaC1wYWNrLmM6OTI3CisjOiBmZXRjaC1wYWNrLmM6OTMxIGZldGNoLXBhY2suYzo5MzUgZmV0Y2gtcGFjay5jOjkzOSBmZXRjaC1wYWNrLmM6OTQzCisjOiBmZXRjaC1wYWNrLmM6OTQ3IGZldGNoLXBhY2suYzo5NTEgZmV0Y2gtcGFjay5jOjk1NSBmZXRjaC1wYWNrLmM6OTU5CisjOiBmZXRjaC1wYWNrLmM6OTY1IGZldGNoLXBhY2suYzo5NzEgZmV0Y2gtcGFjay5jOjk3NiBmZXRjaC1wYWNrLmM6OTgxCiAjLCBjLWZvcm1hdAogbXNnaWQgIlNlcnZlciBzdXBwb3J0cyAlcyIKIG1zZ3N0ciAiTGUgc2VydmV1ciBzdXBwb3J0ZSAlcyIKIAotIzogZmV0Y2gtcGFjay5jOjkxNQorIzogZmV0Y2gtcGFjay5jOjkxNAogbXNnaWQgIlNlcnZlciBkb2VzIG5vdCBzdXBwb3J0IHNoYWxsb3cgY2xpZW50cyIKIG1zZ3N0ciAiTGUgc2VydmV1ciBuZSBzdXBwb3J0ZSBsZXMgY2xpZW50cyBzdXBlcmZpY2llbHMiCiAKLSM6IGZldGNoLXBhY2suYzo5NzUKKyM6IGZldGNoLXBhY2suYzo5NzQKIG1zZ2lkICJTZXJ2ZXIgZG9lcyBub3Qgc3VwcG9ydCAtLXNoYWxsb3ctc2luY2UiCiBtc2dzdHIgIkxlIHJlY2V2ZXVyIG5lIGfDqHJlIHBhcyAtLXNoYWxsb3ctc2luY2UiCiAKLSM6IGZldGNoLXBhY2suYzo5ODAKKyM6IGZldGNoLXBhY2suYzo5NzkKIG1zZ2lkICJTZXJ2ZXIgZG9lcyBub3Qgc3VwcG9ydCAtLXNoYWxsb3ctZXhjbHVkZSIKIG1zZ3N0ciAiTGUgcmVjZXZldXIgbmUgZ8OocmUgcGFzIC0tc2hhbGxvdy1leGNsdWRlIgogCi0jOiBmZXRjaC1wYWNrLmM6OTg0CisjOiBmZXRjaC1wYWNrLmM6OTgzCiBtc2dpZCAiU2VydmVyIGRvZXMgbm90IHN1cHBvcnQgLS1kZWVwZW4iCiBtc2dzdHIgIkxlIHJlY2V2ZXVyIG5lIGfDqHJlIHBhcyAtLWRlZXBlbiIKIAotIzogZmV0Y2gtcGFjay5jOjEwMDEKKyM6IGZldGNoLXBhY2suYzoxMDAwCiBtc2dpZCAibm8gY29tbW9uIGNvbW1pdHMiCiBtc2dzdHIgInBhcyBkZSBjb21taXQgY29tbXVuIgogCi0jOiBmZXRjaC1wYWNrLmM6MTAxMyBmZXRjaC1wYWNrLmM6MTQ2MgorIzogZmV0Y2gtcGFjay5jOjEwMTIgZmV0Y2gtcGFjay5jOjE0NjgKIG1zZ2lkICJnaXQgZmV0Y2gtcGFjazogZmV0Y2ggZmFpbGVkLiIKIG1zZ3N0ciAiZ2l0IGZldGNoLXBhY2vCoDogw6ljaGVjIGRlIGxlIHLDqWN1cMOpcmF0aW9uLiIKIAotIzogZmV0Y2gtcGFjay5jOjExNTEKKyM6IGZldGNoLXBhY2suYzoxMTUwCiBtc2dpZCAiU2VydmVyIGRvZXMgbm90IHN1cHBvcnQgc2hhbGxvdyByZXF1ZXN0cyIKIG1zZ3N0ciAiTGUgc2VydmV1ciBuZSBzdXBwb3J0ZSBsZXMgcmVxdcOqdGVzIHN1cGVyZmljaWVsbGVzIgogCkBAIC0zMzc0LDcyICszMzc5LDcyIEBACiBtc2dpZCAiU2VydmVyIHN1cHBvcnRzIGZpbHRlciIKIG1zZ3N0ciAiTGUgc2VydmV1ciBzdXBwb3J0ZSBmaWx0ZXIiCiAKLSM6IGZldGNoLXBhY2suYzoxMTg0CisjOiBmZXRjaC1wYWNrLmM6MTE4MAogbXNnaWQgInVuYWJsZSB0byB3cml0ZSByZXF1ZXN0IHRvIHJlbW90ZSIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkJ8OpY3JpcmUgbGEgcmVxdcOqdGUgc3VyIGxlIGRpc3RhbnQiCiAKLSM6IGZldGNoLXBhY2suYzoxMjAyCisjOiBmZXRjaC1wYWNrLmM6MTE5OAogIywgYy1mb3JtYXQKIG1zZ2lkICJlcnJvciByZWFkaW5nIHNlY3Rpb24gaGVhZGVyICclcyciCiBtc2dzdHIgImVycmV1ciDDoCBsYSBsZWN0dXJlIGRlIGwnZW50w6p0ZSBkZSBzZWN0aW9uICclcyciCiAKLSM6IGZldGNoLXBhY2suYzoxMjA4CisjOiBmZXRjaC1wYWNrLmM6MTIwNAogIywgYy1mb3JtYXQKIG1zZ2lkICJleHBlY3RlZCAnJXMnLCByZWNlaXZlZCAnJXMnIgogbXNnc3RyICInJXMnIGF0dGVuZHUsICclcycgcmXDp3UiCiAKLSM6IGZldGNoLXBhY2suYzoxMjQ3CisjOiBmZXRjaC1wYWNrLmM6MTI0MwogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmV4cGVjdGVkIGFja25vd2xlZGdtZW50IGxpbmU6ICclcyciCiBtc2dzdHIgImxpZ25lIGQnYWNxdWl0dGVtZW50IGluYXR0ZW5kdWXCoDogJyVzJyIKIAotIzogZmV0Y2gtcGFjay5jOjEyNTIKKyM6IGZldGNoLXBhY2suYzoxMjQ4CiAjLCBjLWZvcm1hdAogbXNnaWQgImVycm9yIHByb2Nlc3NpbmcgYWNrczogJWQiCiBtc2dzdHIgImVycmV1ciBsb3JzIGR1IHRyYWl0ZW1lbnQgZGVzIGFjcXVpdHRlbWVudHPCoDogJWQiCiAKLSM6IGZldGNoLXBhY2suYzoxMjYyCisjOiBmZXRjaC1wYWNrLmM6MTI1OAogbXNnaWQgImV4cGVjdGVkIHBhY2tmaWxlIHRvIGJlIHNlbnQgYWZ0ZXIgJ3JlYWR5JyIKIG1zZ3N0ciAiZmljaGllciBwYXF1ZXQgYXR0ZW5kdSDDoCBlbnZveWVyIGFwcsOocyAncmVhZHknIgogCi0jOiBmZXRjaC1wYWNrLmM6MTI2NAorIzogZmV0Y2gtcGFjay5jOjEyNjAKIG1zZ2lkICJleHBlY3RlZCBubyBvdGhlciBzZWN0aW9ucyB0byBiZSBzZW50IGFmdGVyIG5vICdyZWFkeSciCiBtc2dzdHIgImF1Y3VuZSBhdXRyZSBzZWN0aW9uIGF0dGVuZHVlIMOgIGVudm95ZXIgYXByw6hzIGFic2VuY2UgZGUgJ3JlYWR5JyIKIAotIzogZmV0Y2gtcGFjay5jOjEzMDYKKyM6IGZldGNoLXBhY2suYzoxMzAyCiAjLCBjLWZvcm1hdAogbXNnaWQgImVycm9yIHByb2Nlc3Npbmcgc2hhbGxvdyBpbmZvOiAlZCIKIG1zZ3N0ciAiZXJyZXVyIGxvcnMgZHUgdHJhaXRlbWVudCBkZSBsJ2luZm9ybWF0aW9uIGRlIHN1cGVyZmljaWFsaXTDqcKgOiAlZCIKIAotIzogZmV0Y2gtcGFjay5jOjEzNTMKKyM6IGZldGNoLXBhY2suYzoxMzQ5CiAjLCBjLWZvcm1hdAogbXNnaWQgImV4cGVjdGVkIHdhbnRlZC1yZWYsIGdvdCAnJXMnIgogbXNnc3RyICJ3YW50ZWQtcmVmIGF0dGVuZHUsICclcycgdHJvdXbDqSIKIAotIzogZmV0Y2gtcGFjay5jOjEzNTgKKyM6IGZldGNoLXBhY2suYzoxMzU0CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuZXhwZWN0ZWQgd2FudGVkLXJlZjogJyVzJyIKIG1zZ3N0ciAid2FudGVkLXJlZiBpbmF0dGVuZHXCoDogJyVzJyIKIAotIzogZmV0Y2gtcGFjay5jOjEzNjMKKyM6IGZldGNoLXBhY2suYzoxMzU5CiAjLCBjLWZvcm1hdAogbXNnaWQgImVycm9yIHByb2Nlc3Npbmcgd2FudGVkIHJlZnM6ICVkIgogbXNnc3RyICJlcnJldXIgbG9ycyBkdSB0cmFpdGVtZW50IGRlcyByw6lmw6lyZW5jZXMgdm91bHVlc8KgOiAlZCIKIAotIzogZmV0Y2gtcGFjay5jOjE2ODkKKyM6IGZldGNoLXBhY2suYzoxNjkzCiBtc2dpZCAibm8gbWF0Y2hpbmcgcmVtb3RlIGhlYWQiCiBtc2dzdHIgInBhcyBkZSBIRUFEIGRpc3RhbnRlIGNvcnJlc3BvbmRhbnRlIgogCi0jOiBmZXRjaC1wYWNrLmM6MTcxMiBidWlsdGluL2Nsb25lLmM6Njg2CisjOiBmZXRjaC1wYWNrLmM6MTcxNiBidWlsdGluL2Nsb25lLmM6Njg1CiBtc2dpZCAicmVtb3RlIGRpZCBub3Qgc2VuZCBhbGwgbmVjZXNzYXJ5IG9iamVjdHMiCiBtc2dzdHIgImxlIHNlcnZldXIgZGlzdGFudCBuJ2EgcGFzIGVudm95w6kgdG91cyBsZXMgb2JqZXRzIG7DqWNlc3NhaXJlcyIKIAotIzogZmV0Y2gtcGFjay5jOjE3MzkKKyM6IGZldGNoLXBhY2suYzoxNzQzCiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vIHN1Y2ggcmVtb3RlIHJlZiAlcyIKIG1zZ3N0ciAicsOpZsOpcmVuY2UgZGlzdGFudGUgaW5jb25udWUgJXMiCiAKLSM6IGZldGNoLXBhY2suYzoxNzQyCisjOiBmZXRjaC1wYWNrLmM6MTc0NgogIywgYy1mb3JtYXQKIG1zZ2lkICJTZXJ2ZXIgZG9lcyBub3QgYWxsb3cgcmVxdWVzdCBmb3IgdW5hZHZlcnRpc2VkIG9iamVjdCAlcyIKIG1zZ3N0ciAiTGUgc2VydmV1ciBuJ2F1dG9yaXNlIHBhcyBkZSByZXF1w6p0ZSBwb3VyIGwnb2JqZXQgJXMgbm9uIGFubm9uY8OpIgpAQCAtMzQ2MiwxOCArMzQ2NywyNiBAQAogbXNnaWQgImlnbm9yZSBpbnZhbGlkIGNvbG9yICclLipzJyBpbiBsb2cuZ3JhcGhDb2xvcnMiCiBtc2dzdHIgImNvdWxldXIgaW52YWxpZGUgJyUuKnMnIGlnbm9yw6llIGRhbnMgbG9nLmdyYXBoQ29sb3JzIgogCi0jOiBncmVwLmM6MjExNworIzogZ3JlcC5jOjY2OAorbXNnaWQgIiIKKyJnaXZlbiBwYXR0ZXJuIGNvbnRhaW5zIE5VTEwgYnl0ZSAodmlhIC1mIDxmaWxlPikuIFRoaXMgaXMgb25seSBzdXBwb3J0ZWQgIgorIndpdGggLVAgdW5kZXIgUENSRSB2MiIKK21zZ3N0ciAiIgorImxlIG1vdGlmIGZvdXJuaSBjb250aWVudCBkZXMgb2N0ZXRzIE5VTCAodmlhIC1mIDxmaWNoaWVyPikuIENlIG4nZXN0ICIKKyJzdXBwb3J0w6kgcXUnYXZlYyAtUCBhdmVjIFBDUkUgdjIiCisKKyM6IGdyZXAuYzoyMTI0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiclcyc6IHVuYWJsZSB0byByZWFkICVzIgogbXNnc3RyICInJXMnIDogbGVjdHVyZSBkZSAlcyBpbXBvc3NpYmxlIgogCi0jOiBncmVwLmM6MjEzNCBzZXR1cC5jOjE2NCBidWlsdGluL2Nsb25lLmM6NDA5IGJ1aWx0aW4vZGlmZi5jOjgyCisjOiBncmVwLmM6MjE0MSBzZXR1cC5jOjE2NSBidWlsdGluL2Nsb25lLmM6NDA4IGJ1aWx0aW4vZGlmZi5jOjgyCiAjOiBidWlsdGluL3JtLmM6MTM1CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBzdGF0ICclcyciCiBtc2dzdHIgIsOpY2hlYyBkdSBzdGF0IGRlICclcyciCiAKLSM6IGdyZXAuYzoyMTQ1CisjOiBncmVwLmM6MjE1MgogIywgYy1mb3JtYXQKIG1zZ2lkICInJXMnOiBzaG9ydCByZWFkIgogbXNnc3RyICInJXMnIDogbGVjdHVyZSB0cm9ucXXDqWUiCkBAIC0zNjIwLDEyICszNjMzLDEyIEBACiBtc2dpZCAiZ2l0IHZlcnNpb24gWzxvcHRpb25zPl0iCiBtc2dzdHIgImdpdCB2ZXJzaW9uIFs8b3B0aW9ucz5dIgogCi0jOiBoZWxwLmM6NzgyCisjOiBoZWxwLmM6NzgzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiAlcyAtICVzIgogbXNnc3RyICIlczogJXMgLSAlcyIKIAotIzogaGVscC5jOjc4NgorIzogaGVscC5jOjc4NwogbXNnaWQgIiIKICJcbiIKICJEaWQgeW91IG1lYW4gdGhpcz8iCkBAIC0zNjk4LDQzICszNzExLDU5IEBACiBtc2dpZCAiaW52YWxpZCBkYXRlIGZvcm1hdDogJXMiCiBtc2dzdHIgImZvcm1hdCBkZSBkYXRlIGludmFsaWRlIDogJXMiCiAKLSM6IGxpc3Qtb2JqZWN0cy5jOjEyOQorIzogbGlzdC1vYmplY3RzLmM6MTI3CiAjLCBjLWZvcm1hdAogbXNnaWQgImVudHJ5ICclcycgaW4gdHJlZSAlcyBoYXMgdHJlZSBtb2RlLCBidXQgaXMgbm90IGEgdHJlZSIKIG1zZ3N0ciAiIgogImwnZW50csOpZSAnJXMnIGRhbnMgbCdhcmJyZSAlcyBhIHVuIG1vZGUgZCdhcmJyZSwgbWFpcyBuJ2VzdCBwYXMgdW4gYXJicmUiCiAKLSM6IGxpc3Qtb2JqZWN0cy5jOjE0MgorIzogbGlzdC1vYmplY3RzLmM6MTQwCiAjLCBjLWZvcm1hdAogbXNnaWQgImVudHJ5ICclcycgaW4gdHJlZSAlcyBoYXMgYmxvYiBtb2RlLCBidXQgaXMgbm90IGEgYmxvYiIKIG1zZ3N0ciAiIgogImwnZW50csOpZSAnJXMnIGRhbnMgbCdhcmJyZSAlcyBhIHVuIG1vZGUgZGUgYmxvYiwgbWFpcyBuJ2VzdCBwYXMgdW4gYmxvYiIKIAotIzogbGlzdC1vYmplY3RzLmM6Mzc4CisjOiBsaXN0LW9iamVjdHMuYzozNzUKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGxvYWQgcm9vdCB0cmVlIGZvciBjb21taXQgJXMiCiBtc2dzdHIgImltcG9zc2libGUgZGUgY2hhcmdlciBsJ2FyYnJlIHJhY2luZSBwb3VyIGxlIGNvbW1pdCAlcyIKIAotIzogbGlzdC1vYmplY3RzLWZpbHRlci1vcHRpb25zLmM6MzYKLW1zZ2lkICJtdWx0aXBsZSBmaWx0ZXItc3BlY3MgY2Fubm90IGJlIGNvbWJpbmVkIgotbXNnc3RyICJpbXBvc3NpYmxlIGRlIGNvbWJpbmVyIGRlcyBzcMOpY2lmaWNhdGV1cnMgbXVsdGlwbGVzIGRlIGZpbHRyZSIKKyM6IGxpc3Qtb2JqZWN0cy1maWx0ZXIuYzo0OTIKKyMsIGMtZm9ybWF0Cittc2dpZCAidW5hYmxlIHRvIGFjY2VzcyBzcGFyc2UgYmxvYiBpbiAnJXMnIgorbXNnc3RyICJpbXBvc3NpYmxlIGQnYWNjw6lkZXIgYXUgYmxvYiBjbGFpcnNlbcOpIGRhbnMgJyVzJyIKKworIzogbGlzdC1vYmplY3RzLWZpbHRlci5jOjQ5NQorIywgYy1mb3JtYXQKK21zZ2lkICJ1bmFibGUgdG8gcGFyc2Ugc3BhcnNlIGZpbHRlciBkYXRhIGluICVzIgorbXNnc3RyICJpbXBvc3NpYmxlIGQnYW5hbHlzZXIgbGEgZG9ubsOpZSBkZSBmaWx0cmUgY2xhaXJzZW3DqSBkYW5zICVzIgogCiAjOiBsaXN0LW9iamVjdHMtZmlsdGVyLW9wdGlvbnMuYzo1OAogbXNnaWQgImV4cGVjdGVkICd0cmVlOjxkZXB0aD4nIgogbXNnc3RyICJhdHRlbmR1wqA6ICd0cmVlOjxwcm9mb25kZXVyPiciCiAKLSM6IGxpc3Qtb2JqZWN0cy1maWx0ZXItb3B0aW9ucy5jOjg0CisjOiBsaXN0LW9iamVjdHMtZmlsdGVyLW9wdGlvbnMuYzo3MwogbXNnaWQgInNwYXJzZTpwYXRoIGZpbHRlcnMgc3VwcG9ydCBoYXMgYmVlbiBkcm9wcGVkIgogbXNnc3RyICJzcGFyc2XCoDogbGUgc3VwcG9ydCBkZXMgZmlsdHJlcyBkZSBjaGVtaW4gYSDDqXTDqSBhYmFuZG9ubsOpIgogCi0jOiBsaXN0LW9iamVjdHMtZmlsdGVyLW9wdGlvbnMuYzo5NAorIzogbGlzdC1vYmplY3RzLWZpbHRlci1vcHRpb25zLmM6ODYKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBmaWx0ZXItc3BlYyAnJXMnIgogbXNnc3RyICJzcMOpY2lmaWNhdGV1ciBkZSBmaWx0cmUgaW52YWxpZGUgJyVzJyIKIAotIzogbGlzdC1vYmplY3RzLWZpbHRlci1vcHRpb25zLmM6MTU4Ci1tc2dpZCAiY2Fubm90IGNoYW5nZSBwYXJ0aWFsIGNsb25lIHByb21pc29yIHJlbW90ZSIKLW1zZ3N0ciAiaW1wb3NzaWJsZSBkZSBtb2RpZmllciBsZSBwcm9tZXR0ZXVyIGRpc3RhbnQgZGUgY2xvbmUgcGFydGllbCIKKyM6IGxpc3Qtb2JqZWN0cy1maWx0ZXItb3B0aW9ucy5jOjEwMgorIywgYy1mb3JtYXQKK21zZ2lkICJtdXN0IGVzY2FwZSBjaGFyIGluIHN1Yi1maWx0ZXItc3BlYzogJyVjJyIKK21zZ3N0ciAiIgorImxlIGNhcmFjdMOocmUgZG9pdCDDqnRyZSDDqWNoYXBww6kgZGFucyBsZSBzcMOpY2lmaWNhdGV1ciBkZSBzb3VzLWZpbHRyZcKgOiAnJWMnIgorCisjOiBsaXN0LW9iamVjdHMtZmlsdGVyLW9wdGlvbnMuYzoxNDQKK21zZ2lkICJleHBlY3RlZCBzb21ldGhpbmcgYWZ0ZXIgY29tYmluZToiCittc2dzdHIgInF1ZWxxdWUgY2hvc2UgYXR0ZW5kdSBhcHLDqHMgY29tYmluZcKgOiIKKworIzogbGlzdC1vYmplY3RzLWZpbHRlci1vcHRpb25zLmM6MjI2Cittc2dpZCAibXVsdGlwbGUgZmlsdGVyLXNwZWNzIGNhbm5vdCBiZSBjb21iaW5lZCIKK21zZ3N0ciAiaW1wb3NzaWJsZSBkZSBjb21iaW5lciBkZXMgc3DDqWNpZmljYXRldXJzIG11bHRpcGxlcyBkZSBmaWx0cmUiCiAKICM6IGxvY2tmaWxlLmM6MTUxCiAjLCBjLWZvcm1hdApAQCAtMzc2NCwxMTcgKzM3OTMsMTEzIEBACiBtc2dpZCAiZmFpbGVkIHRvIHJlYWQgdGhlIGNhY2hlIgogbXNnc3RyICJpbXBvc3NpYmxlIGRlIGxpcmUgbGUgY2FjaGUiCiAKLSM6IG1lcmdlLmM6MTA3IHJlcmVyZS5jOjcyMCBidWlsdGluL2FtLmM6MTg4NSBidWlsdGluL2FtLmM6MTkxOQotIzogYnVpbHRpbi9jaGVja291dC5jOjUzNiBidWlsdGluL2NoZWNrb3V0LmM6Nzk2IGJ1aWx0aW4vY2xvbmUuYzo3ODYKKyM6IG1lcmdlLmM6MTA3IHJlcmVyZS5jOjcyMCBidWlsdGluL2FtLmM6MTg3NCBidWlsdGluL2FtLmM6MTkwOAorIzogYnVpbHRpbi9jaGVja291dC5jOjUzNyBidWlsdGluL2NoZWNrb3V0LmM6Nzk2IGJ1aWx0aW4vY2xvbmUuYzo3ODUKICM6IGJ1aWx0aW4vc3Rhc2guYzoyNjQKIG1zZ2lkICJ1bmFibGUgdG8gd3JpdGUgbmV3IGluZGV4IGZpbGUiCiBtc2dzdHIgImltcG9zc2libGUgZCfDqWNyaXJlIGxlIG5vdXZlYXUgZmljaGllciBkJ2luZGV4IgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozMjIKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjM2NwogbXNnaWQgIihiYWQgY29tbWl0KVxuIgogbXNnc3RyICIobWF1dmFpcyBjb21taXQpXG4iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjM0NQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzkwCiAjLCBjLWZvcm1hdAogbXNnaWQgImFkZF9jYWNoZWluZm8gZmFpbGVkIGZvciBwYXRoICclcyc7IG1lcmdlIGFib3J0aW5nLiIKIG1zZ3N0ciAiw6ljaGVjIGRlIGFkZGluZm9fY2FjaGUgcG91ciBsZSBjaGVtaW4gJyVzJ8KgOyBhYmFuZG9uIGRlIGxhIGZ1c2lvbi4iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjM1NAorIzogbWVyZ2UtcmVjdXJzaXZlLmM6Mzk5CiAjLCBjLWZvcm1hdAogbXNnaWQgImFkZF9jYWNoZWluZm8gZmFpbGVkIHRvIHJlZnJlc2ggZm9yIHBhdGggJyVzJzsgbWVyZ2UgYWJvcnRpbmcuIgogbXNnc3RyICLDqWNoZWMgZGUgYWRkaW5mb19jYWNoZSBwb3VyIGxlIGNoZW1pbiAnJXMnwqA7IGFiYW5kb24gZGUgbGEgZnVzaW9uLiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6NDM3Ci1tc2dpZCAiZXJyb3IgYnVpbGRpbmcgdHJlZXMiCi1tc2dzdHIgImVycmV1ciBkZSBjb25zdHJ1Y3Rpb24gZGVzIGFyYnJlcyIKLQotIzogbWVyZ2UtcmVjdXJzaXZlLmM6ODYzCisjOiBtZXJnZS1yZWN1cnNpdmUuYzo4ODUKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIGNyZWF0ZSBwYXRoICclcyclcyIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkZSBjcsOpZXIgbGUgY2hlbWluICclcycgJXMiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjg3NAorIzogbWVyZ2UtcmVjdXJzaXZlLmM6ODk2CiAjLCBjLWZvcm1hdAogbXNnaWQgIlJlbW92aW5nICVzIHRvIG1ha2Ugcm9vbSBmb3Igc3ViZGlyZWN0b3J5XG4iCiBtc2dzdHIgIlN1cHByZXNzaW9uIGRlICVzIHBvdXIgZmFpcmUgZGUgbGEgcGxhY2UgcG91ciBsZSBzb3VzLXLDqXBlcnRvaXJlXG4iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjg4OCBtZXJnZS1yZWN1cnNpdmUuYzo5MDcKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjkxMCBtZXJnZS1yZWN1cnNpdmUuYzo5MjkKIG1zZ2lkICI6IHBlcmhhcHMgYSBEL0YgY29uZmxpY3Q/IgogbXNnc3RyICI6IHBldXQtw6p0cmUgdW4gY29uZmxpdCBEL0YgPyIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6ODk3CisjOiBtZXJnZS1yZWN1cnNpdmUuYzo5MTkKICMsIGMtZm9ybWF0CiBtc2dpZCAicmVmdXNpbmcgdG8gbG9zZSB1bnRyYWNrZWQgZmlsZSBhdCAnJXMnIgogbXNnc3RyICJyZWZ1cyBkZSBwZXJkcmUgbGUgZmljaGllciBub24gc3VpdmkgJyVzJyIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6OTM4IGJ1aWx0aW4vY2F0LWZpbGUuYzo0MAorIzogbWVyZ2UtcmVjdXJzaXZlLmM6OTYwIGJ1aWx0aW4vY2F0LWZpbGUuYzo0MQogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgcmVhZCBvYmplY3QgJXMgJyVzJyIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkZSBsaXJlIGwnb2JqZXQgJXMgJyVzJyIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6OTQxCisjOiBtZXJnZS1yZWN1cnNpdmUuYzo5NjUKICMsIGMtZm9ybWF0CiBtc2dpZCAiYmxvYiBleHBlY3RlZCBmb3IgJXMgJyVzJyIKIG1zZ3N0ciAiYmxvYiBhdHRlbmR1IHBvdXIgJXMgJyVzJyIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6OTY1CisjOiBtZXJnZS1yZWN1cnNpdmUuYzo5OTAKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIG9wZW4gJyVzJzogJXMiCiBtc2dzdHIgIsOpY2hlYyDDoCBsJ291dmVydHVyZSBkZSAnJXMnwqA6ICVzIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzo5NzYKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEwMDEKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIHN5bWxpbmsgJyVzJzogJXMiCiBtc2dzdHIgIsOpY2hlYyDDoCBsYSBjcsOpYXRpb24gZHUgbGllbiBzeW1ib2xpcXVlICclcyfCoDogJXMiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjk4MQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTAwNgogIywgYy1mb3JtYXQKIG1zZ2lkICJkbyBub3Qga25vdyB3aGF0IHRvIGRvIHdpdGggJTA2byAlcyAnJXMnIgogbXNnc3RyICJuZSBzYWl0IHBhcyB0cmFpdGVyICUwNm8gJXMgJyVzJyIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTE3NworIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTE5OQogIywgYy1mb3JtYXQKIG1zZ2lkICJGYWlsZWQgdG8gbWVyZ2Ugc3VibW9kdWxlICVzIChub3QgY2hlY2tlZCBvdXQpIgogbXNnc3RyICLDiWNoZWMgZGUgbGEgZnVzaW9uIGR1IHNvdXMtbW9kdWxlICVzIChub24gZXh0cmFpdCkiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjExODQKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEyMDYKICMsIGMtZm9ybWF0CiBtc2dpZCAiRmFpbGVkIHRvIG1lcmdlIHN1Ym1vZHVsZSAlcyAoY29tbWl0cyBub3QgcHJlc2VudCkiCiBtc2dzdHIgIsOJY2hlYyBkZSBmdXNpb24gZHUgc291cy1tb2R1bGUgJXMgKGNvbW1pdHMgbm9uIHByw6lzZW50cykiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjExOTEKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEyMTMKICMsIGMtZm9ybWF0CiBtc2dpZCAiRmFpbGVkIHRvIG1lcmdlIHN1Ym1vZHVsZSAlcyAoY29tbWl0cyBkb24ndCBmb2xsb3cgbWVyZ2UtYmFzZSkiCiBtc2dzdHIgIiIKICLDiWNoZWMgZGUgbGEgZnVzaW9uIGR1IHNvdXMtbW9kdWxlICVzIChsZXMgY29tbWl0cyBuZSBkZXNjZW5kZW50IHBhcyBkZSBsYSAiCiAiYmFzZSBkZSBmdXNpb24pIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxMTk5IG1lcmdlLXJlY3Vyc2l2ZS5jOjEyMTEKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEyMjEgbWVyZ2UtcmVjdXJzaXZlLmM6MTIzMwogIywgYy1mb3JtYXQKIG1zZ2lkICJGYXN0LWZvcndhcmRpbmcgc3VibW9kdWxlICVzIHRvIHRoZSBmb2xsb3dpbmcgY29tbWl0OiIKIG1zZ3N0ciAiQXZhbmNlIHJhcGlkZSBkdSBzb3VzLW1vZHVsZSAlcyBhdSBjb21taXQgc3VpdmFudMKgOiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTIwMiBtZXJnZS1yZWN1cnNpdmUuYzoxMjE0CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxMjI0IG1lcmdlLXJlY3Vyc2l2ZS5jOjEyMzYKICMsIGMtZm9ybWF0CiBtc2dpZCAiRmFzdC1mb3J3YXJkaW5nIHN1Ym1vZHVsZSAlcyIKIG1zZ3N0ciAiQXZhbmNlIHJhcGlkZSBkdSBzb3VzLW1vZHVsZSAlcyIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTIzNworIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTI1OQogIywgYy1mb3JtYXQKIG1zZ2lkICJGYWlsZWQgdG8gbWVyZ2Ugc3VibW9kdWxlICVzIChtZXJnZSBmb2xsb3dpbmcgY29tbWl0cyBub3QgZm91bmQpIgogbXNnc3RyICIiCiAiw4ljaGVjIGRlIGZ1c2lvbiBkdSBzb3VzLW1vZHVsZSAlcyAoZnVzaW9uIHN1aXZhbnQgbGVzIGNvbW1pdHMgbm9uIHRyb3V2w6llKSIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTI0MQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTI2MwogIywgYy1mb3JtYXQKIG1zZ2lkICJGYWlsZWQgdG8gbWVyZ2Ugc3VibW9kdWxlICVzIChub3QgZmFzdC1mb3J3YXJkKSIKIG1zZ3N0ciAiw4ljaGVjIGRlIGZ1c2lvbiBkdSBzb3VzLW1vZHVsZSAlcyAocGFzIGVuIGF2YW5jZSByYXBpZGUpIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxMjQyCisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxMjY0CiBtc2dpZCAiRm91bmQgYSBwb3NzaWJsZSBtZXJnZSByZXNvbHV0aW9uIGZvciB0aGUgc3VibW9kdWxlOlxuIgogbXNnc3RyICJSw6lzb2x1dGlvbiBwb3NzaWJsZSBkZSBmdXNpb24gdHJvdXbDqWUgcG91ciBsZSBzb3VzLW1vZHVsZcKgOlxuIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxMjQ1CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxMjY3CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJJZiB0aGlzIGlzIGNvcnJlY3Qgc2ltcGx5IGFkZCBpdCB0byB0aGUgaW5kZXggZm9yIGV4YW1wbGVcbiIKQEAgLTM4OTEsMzMgKzM5MTYsMzMgQEAKICJcbiIKICJxdWkgYWNjZXB0ZXJhIGNldHRlIHN1Z2dlc3Rpb24uXG4iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEyNTQKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEyNzYKICMsIGMtZm9ybWF0CiBtc2dpZCAiRmFpbGVkIHRvIG1lcmdlIHN1Ym1vZHVsZSAlcyAobXVsdGlwbGUgbWVyZ2VzIGZvdW5kKSIKIG1zZ3N0ciAiw4ljaGVjIGRlIGZ1c2lvbiBkdSBzb3VzLW1vZHVsZSAlcyAocGx1c2lldXJzIGZ1c2lvbnMgdHJvdXbDqWVzKSIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTMyNworIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTM0OQogbXNnaWQgIkZhaWxlZCB0byBleGVjdXRlIGludGVybmFsIG1lcmdlIgogbXNnc3RyICLDiWNoZWMgw6AgbCdleMOpY3V0aW9uIGRlIGxhIGZ1c2lvbiBpbnRlcm5lIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxMzMyCisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxMzU0CiAjLCBjLWZvcm1hdAogbXNnaWQgIlVuYWJsZSB0byBhZGQgJXMgdG8gZGF0YWJhc2UiCiBtc2dzdHIgIkltcG9zc2libGUgZCdham91dGVyICVzIMOgIGxhIGJhc2UgZGUgZG9ubsOpZXMiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEzNjQKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEzODYKICMsIGMtZm9ybWF0CiBtc2dpZCAiQXV0by1tZXJnaW5nICVzIgogbXNnc3RyICJGdXNpb24gYXV0b21hdGlxdWUgZGUgJXMiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEzODcKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE0MTAKICMsIGMtZm9ybWF0CiBtc2dpZCAiRXJyb3I6IFJlZnVzaW5nIHRvIGxvc2UgdW50cmFja2VkIGZpbGUgYXQgJXM7IHdyaXRpbmcgdG8gJXMgaW5zdGVhZC4iCiBtc2dzdHIgIiIKICJFcnJldXLCoDogcmVmdXMgZGUgcGVyZHJlIGxlIGZpY2hpZXIgbm9uIHN1aXZpICVzwqA7IMOpY3JpdHVyZSBkYW5zICVzIMOgIGxhICIKICJwbGFjZS4iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE0NTkKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE0ODIKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkNPTkZMSUNUICglcy9kZWxldGUpOiAlcyBkZWxldGVkIGluICVzIGFuZCAlcyBpbiAlcy4gVmVyc2lvbiAlcyBvZiAlcyBsZWZ0ICIKQEAgLTM5MjYsNyArMzk1MSw3IEBACiAiQ09ORkxJVCAoJXMvc3VwcHJlc3Npb24pIDogJXMgc3VwcHJpbcOpIGRhbnMgJXMgZXQgJXMgZGFucyAlcy4gVmVyc2lvbiAlcyBkZSAiCiAiJXMgbGFpc3PDqWUgZGFucyBsJ2FyYnJlLiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTQ2NAorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTQ4NwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiQ09ORkxJQ1QgKCVzL2RlbGV0ZSk6ICVzIGRlbGV0ZWQgaW4gJXMgYW5kICVzIHRvICVzIGluICVzLiBWZXJzaW9uICVzIG9mICVzICIKQEAgLTM5MzUsNyArMzk2MCw3IEBACiAiQ09ORkxJVCAoJXMvc3VwcHJlc3Npb24pIDogJXMgc3VwcHJpbcOpIGRhbnMgJXMgZXQgJXMgw6AgJXMgZGFucyAlcy4gVmVyc2lvbiAiCiAiJXMgZGUgJXMgbGFpc3PDqWUgZGFucyBsJ2FyYnJlLiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTQ3MQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTQ5NAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiQ09ORkxJQ1QgKCVzL2RlbGV0ZSk6ICVzIGRlbGV0ZWQgaW4gJXMgYW5kICVzIGluICVzLiBWZXJzaW9uICVzIG9mICVzIGxlZnQgIgpAQCAtMzk0NCw3ICszOTY5LDcgQEAKICJDT05GTElUICglcy9zdXBwcmVzc2lvbikgOiAlcyBzdXBwcmltw6kgZGFucyAlcyBldCAlcyBkYW5zICVzLiBWZXJzaW9uICVzIGRlICIKICIlcyBsYWlzc8OpZSBkYW5zIGwnYXJicmUgZGFucyBsZSBmaWNoaWVyICVzLiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTQ3NgorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTQ5OQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiQ09ORkxJQ1QgKCVzL2RlbGV0ZSk6ICVzIGRlbGV0ZWQgaW4gJXMgYW5kICVzIHRvICVzIGluICVzLiBWZXJzaW9uICVzIG9mICVzICIKQEAgLTM5NTMsNDEgKzM5NzgsNDEgQEAKICJDT05GTElUICglcy9zdXBwcmVzc2lvbikgOiAlcyBzdXBwcmltw6kgZGFucyAlcyBldCAlcyDDoCAlcyBkYW5zICVzLiBWZXJzaW9uICIKICIlcyBkZSAlcyBsYWlzc8OpZSBkYW5zIGwnYXJicmUgZGFucyBsZSBmaWNoaWVyICVzLiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTUxMQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTUzNAogbXNnaWQgInJlbmFtZSIKIG1zZ3N0ciAicmVub21tYWdlIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxNTExCisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxNTM0CiBtc2dpZCAicmVuYW1lZCIKIG1zZ3N0ciAicmVub21tw6kiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE1OTEgbWVyZ2UtcmVjdXJzaXZlLmM6MjQ1MCBtZXJnZS1yZWN1cnNpdmUuYzozMDk0CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxNjE0IG1lcmdlLXJlY3Vyc2l2ZS5jOjI0NzIgbWVyZ2UtcmVjdXJzaXZlLmM6MzExNwogIywgYy1mb3JtYXQKIG1zZ2lkICJSZWZ1c2luZyB0byBsb3NlIGRpcnR5IGZpbGUgYXQgJXMiCiBtc2dzdHIgIlJlZnVzIGRlIHBlcmRyZSBsZSBmaWNoaWVyIG1vZGlmacOpICVzIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxNjAxCisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxNjI0CiAjLCBjLWZvcm1hdAogbXNnaWQgIlJlZnVzaW5nIHRvIGxvc2UgdW50cmFja2VkIGZpbGUgYXQgJXMsIGV2ZW4gdGhvdWdoIGl0J3MgaW4gdGhlIHdheS4iCiBtc2dzdHIgIlJlZnVzIGRlIHBlcmRyZSBsZSBmaWNoaWVyIG5vbiBzdWl2aSAlcywgbcOqbWUgcydpbCBnw6puZS4iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE2NTkKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE2ODIKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ09ORkxJQ1QgKHJlbmFtZS9hZGQpOiBSZW5hbWUgJXMtPiVzIGluICVzLiAgQWRkZWQgJXMgaW4gJXMiCiBtc2dzdHIgIiIKICJDT05GTElUIChyZW5vbW1hZ2UvYWpvdXQpIDogUmVub21tYWdlIGRlICVzLT4lcyBkYW5zICVzLiAlcyBham91dMOpIGRhbnMgJXMiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE2OTAKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE3MTMKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgaXMgYSBkaXJlY3RvcnkgaW4gJXMgYWRkaW5nIGFzICVzIGluc3RlYWQiCiBtc2dzdHIgIiVzIGVzdCB1biByw6lwZXJ0b2lyZSBkYW5zICVzIGFqb3V0w6kgcGx1dMO0dCBjb21tZSAlcyIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTY5NQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTcxOAogIywgYy1mb3JtYXQKIG1zZ2lkICJSZWZ1c2luZyB0byBsb3NlIHVudHJhY2tlZCBmaWxlIGF0ICVzOyBhZGRpbmcgYXMgJXMgaW5zdGVhZCIKIG1zZ3N0ciAiUmVmdXMgZGUgcGVyZHJlIGxlIGZpY2hpZXIgbm9uIHN1aXZpICVzIDsgYWpvdXQgY29tbWUgJXMgw6AgbGEgcGxhY2UiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE3MTQKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE3MzcKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkNPTkZMSUNUIChyZW5hbWUvcmVuYW1lKTogUmVuYW1lIFwiJXNcIi0+XCIlc1wiIGluIGJyYW5jaCBcIiVzXCIgcmVuYW1lIFwiJXMiCkBAIC0zOTk2LDE4ICs0MDIxLDE4IEBACiAiQ09ORkxJVCAocmVub21tYWdlL3Jlbm9tbWFnZSkgOiBSZW5vbW1hZ2UgZGUgXCIlc1wiLT5cIiVzXCIgZGFucyBsYSBicmFuY2hlICIKICJcIiVzXCIgZXQgcmVub21tYWdlIFwiJXNcIi0+XCIlc1wiIGRhbnMgXCIlc1wiJXMiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE3MTkKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE3NDIKIG1zZ2lkICIgKGxlZnQgdW5yZXNvbHZlZCkiCiBtc2dzdHIgIiAobGFpc3PDqSBub24gcsOpc29sdSkiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE4MjgKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE4NTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ09ORkxJQ1QgKHJlbmFtZS9yZW5hbWUpOiBSZW5hbWUgJXMtPiVzIGluICVzLiBSZW5hbWUgJXMtPiVzIGluICVzIgogbXNnc3RyICIiCiAiQ09ORkxJVCAocmVub21tYWdlL3Jlbm9tbWFnZSkgOiByZW5vbW1hZ2UgJyVzJy0+JyVzJyBkYW5zICVzLiBSZW5vbW1hZ2UgJyVzJy0iCiAiPiclcycgZGFucyAlcyIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MjAzNQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MjA1NgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiQ09ORkxJQ1QgKGRpcmVjdG9yeSByZW5hbWUgc3BsaXQpOiBVbmNsZWFyIHdoZXJlIHRvIHBsYWNlICVzIGJlY2F1c2UgIgpAQCAtNDAxOCw3ICs0MDQzLDcgQEAKICJwYXJjZSBxdWUgbGUgcsOpcGVydG9pcmUgJXMgYSDDqXTDqSByZW5vbW3DqSBlbiBwbHVzaWV1cnMgYXV0cmVzIHLDqXBlcnRvaXJlcywgIgogInNhbnMgYXVjdW5lIGRlc3RpbmF0aW9uIHLDqWN1cMOpcmFudCBsYSBtYWpvcml0w6kgZGVzIGZpY2hpZXJzLiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MjA2NworIzogbWVyZ2UtcmVjdXJzaXZlLmM6MjA4OAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiQ09ORkxJQ1QgKGltcGxpY2l0IGRpciByZW5hbWUpOiBFeGlzdGluZyBmaWxlL2RpciBhdCAlcyBpbiB0aGUgd2F5IG9mICIKQEAgLTQwMjcsNyArNDA1Miw3IEBACiAiQ09ORkxJVCAocmVub21tYWdlIGltcGxpY2l0ZSBkZSByw6lwZXJ0b2lyZSnCoDogbGUgcsOpcGVydG9pcmUvZmljaGllciAlcyBnw6puZSAiCiAiZGVzIHJlbm9tbWFnZXMgaW1wbGljaXRlcyBkZSByw6lwZXJ0b2lyZSBkw6lwbGHDp2FudCBsZXMgY2hlbWlucyBzdWl2YW50c8KgOiAlcy4iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjIwNzcKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjIwOTgKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkNPTkZMSUNUIChpbXBsaWNpdCBkaXIgcmVuYW1lKTogQ2Fubm90IG1hcCBtb3JlIHRoYW4gb25lIHBhdGggdG8gJXM7ICIKQEAgLTQwMzYsNyArNDA2MSw3IEBACiAiQ09ORkxJVCAocmVub21tYWdlIGltcGxpY2l0ZSBkZSByw6lwZXJ0b2lyZSnCoDogaW1wb3NzaWJsZSBkZSB0cmFuc2Zvcm1lciAiCiAicGx1c2lldXJzIGNoZW1pbnMgc3VyICVzwqA7IGxlcyBjaGVtaW5zIGNvbmNlcm7DqXMgc29udMKgOiAlcyIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MjE2OQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MjE5MAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiQ09ORkxJQ1QgKHJlbmFtZS9yZW5hbWUpOiBSZW5hbWUgZGlyZWN0b3J5ICVzLT4lcyBpbiAlcy4gUmVuYW1lIGRpcmVjdG9yeSAlcy0iCkBAIC00MDQ1LDcgKzQwNzAsNyBAQAogIkNPTkZMSVQgKHJlbm9tbWFnZS9yZW5vbW1hZ2UpIDogcmVub21tYWdlIGR1IHLDqXBlcnRvaXJlICVzLT4lcyBkYW5zICVzLiAiCiAiUmVub21tYWdlIGRlIHLDqXBlcnRvaXJlICVzLT4lcyBkYW5zICVzIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoyNDEzCisjOiBtZXJnZS1yZWN1cnNpdmUuYzoyNDM1CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJXQVJOSU5HOiBBdm9pZGluZyBhcHBseWluZyAlcyAtPiAlcyByZW5hbWUgdG8gJXMsIGJlY2F1c2UgJXMgaXRzZWxmIHdhcyAiCkBAIC00MDU0LDUyICs0MDc5LDUyIEBACiAiQVZFUlRJU1NFTUVOVMKgOiBuZSByZW5vbW1lIHBhcyAlcy0+JXMgZGFucyAlcywgcGFyY2UgcXVlICVzIGx1aS1tw6ptZSBhIMOpdMOpICIKICJyZW5vbW3DqS4iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjI5MzgKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjI5NjEKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IHJlYWQgb2JqZWN0ICVzIgogbXNnc3RyICJpbXBvc3NpYmxlIGRlIGxpcmUgbCdvYmpldCAlcyIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6Mjk0MQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6Mjk2NAogIywgYy1mb3JtYXQKIG1zZ2lkICJvYmplY3QgJXMgaXMgbm90IGEgYmxvYiIKIG1zZ3N0ciAibCdvYmpldCAlcyBuJ2VzdCBwYXMgdW4gYmxvYiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzAwNQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzAyOAogbXNnaWQgIm1vZGlmeSIKIG1zZ3N0ciAibW9kaWZpY2F0aW9uIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozMDA1CisjOiBtZXJnZS1yZWN1cnNpdmUuYzozMDI4CiBtc2dpZCAibW9kaWZpZWQiCiBtc2dzdHIgIm1vZGlmacOpIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozMDE3CisjOiBtZXJnZS1yZWN1cnNpdmUuYzozMDQwCiBtc2dpZCAiY29udGVudCIKIG1zZ3N0ciAiY29udGVudSIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzAyMQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzA0NAogbXNnaWQgImFkZC9hZGQiCiBtc2dzdHIgImFqb3V0L2Fqb3V0IgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozMDQ0CisjOiBtZXJnZS1yZWN1cnNpdmUuYzozMDY3CiAjLCBjLWZvcm1hdAogbXNnaWQgIlNraXBwZWQgJXMgKG1lcmdlZCBzYW1lIGFzIGV4aXN0aW5nKSIKIG1zZ3N0ciAiJXMgc2F1dMOpIChmdXNpb24gaWRlbnRpcXVlIMOgIGwnZXhpc3RhbnQpIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozMDY2IGdpdC1zdWJtb2R1bGUuc2g6OTM3CisjOiBtZXJnZS1yZWN1cnNpdmUuYzozMDg5IGdpdC1zdWJtb2R1bGUuc2g6OTM3CiBtc2dpZCAic3VibW9kdWxlIgogbXNnc3RyICJzb3VzLW1vZHVsZSIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzA2NworIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzA5MAogIywgYy1mb3JtYXQKIG1zZ2lkICJDT05GTElDVCAoJXMpOiBNZXJnZSBjb25mbGljdCBpbiAlcyIKIG1zZ3N0ciAiQ09ORkxJVCAoJXMpIDogQ29uZmxpdCBkZSBmdXNpb24gZGFucyAlcyIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzA5NworIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzEyMAogIywgYy1mb3JtYXQKIG1zZ2lkICJBZGRpbmcgYXMgJXMgaW5zdGVhZCIKIG1zZ3N0ciAiQWpvdXQgcGx1dMO0dCBjb21tZSAlcyIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzE3OQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzIwMwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiUGF0aCB1cGRhdGVkOiAlcyBhZGRlZCBpbiAlcyBpbnNpZGUgYSBkaXJlY3RvcnkgdGhhdCB3YXMgcmVuYW1lZCBpbiAlczsgIgpAQCAtNDEwOCw3ICs0MTMzLDcgQEAKICJDaGVtaW4gbWlzIMOgIGpvdXLCoDogJXMgYWpvdXTDqSBkYW5zICVzIGRhbnMgdW4gcsOpcGVydG9pcmUgcXVpIGEgw6l0w6kgcmVub21tw6kgIgogImVuICVzwqA7IGTDqXBsYWPDqSBkYW5zICVzLiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzE4MgorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzIwNgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiQ09ORkxJQ1QgKGZpbGUgbG9jYXRpb24pOiAlcyBhZGRlZCBpbiAlcyBpbnNpZGUgYSBkaXJlY3RvcnkgdGhhdCB3YXMgcmVuYW1lZCAiCkBAIC00MTE4LDcgKzQxNDMsNyBAQAogImEgw6l0w6kgcmVub21tw6kgZGFucyAlcywgY2UgcXVpIHN1Z2fDqHJlIHF1J2lsIGRldnJhaXQgcGV1dC3DqnRyZSDDqnRyZSBkw6lwbGFjw6kgIgogInZlcnMgJXMuIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozMTg2CisjOiBtZXJnZS1yZWN1cnNpdmUuYzozMjEwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJQYXRoIHVwZGF0ZWQ6ICVzIHJlbmFtZWQgdG8gJXMgaW4gJXMsIGluc2lkZSBhIGRpcmVjdG9yeSB0aGF0IHdhcyByZW5hbWVkIGluICIKQEAgLTQxMjcsNyArNDE1Miw3IEBACiAiQ2hlbWluIG1pcyDDoCBqb3VywqA6ICVzIHJlbm9tbcOpIGVuICVzIGRhbnMgJXMsIGRhbnMgdW4gcsOpcGVydG9pcmUgcXVpIGEgw6l0w6kgIgogInJlbm9tbcOpIGVuICVzwqA7IGTDqXBsYWPDqSBkYW5zICVzLiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzE4OQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzIxMwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiQ09ORkxJQ1QgKGZpbGUgbG9jYXRpb24pOiAlcyByZW5hbWVkIHRvICVzIGluICVzLCBpbnNpZGUgYSBkaXJlY3RvcnkgdGhhdCAiCkBAIC00MTM3LDM2ICs0MTYyLDYwIEBACiAicsOpcGVydG9pcmUgcXVpIGEgw6l0w6kgcmVub21tw6kgZGFucyAlcywgY2UgcXVpIHN1Z2fDqHJlIHF1J2lsIGRldnJhaXQgcGV1dC3DqnRyZSAiCiAiw6p0cmUgZMOpcGxhY8OpIHZlcnMgJXMuIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozMzAzCisjOiBtZXJnZS1yZWN1cnNpdmUuYzozMzI3CiAjLCBjLWZvcm1hdAogbXNnaWQgIlJlbW92aW5nICVzIgogbXNnc3RyICJTdXBwcmVzc2lvbiBkZSAlcyIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzMyNgorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzM1MAogbXNnaWQgImZpbGUvZGlyZWN0b3J5IgogbXNnc3RyICJmaWNoaWVyL3LDqXBlcnRvaXJlIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozMzMxCisjOiBtZXJnZS1yZWN1cnNpdmUuYzozMzU1CiBtc2dpZCAiZGlyZWN0b3J5L2ZpbGUiCiBtc2dzdHIgInLDqXBlcnRvaXJlL2ZpY2hpZXIiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMzMzgKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMzNjIKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ09ORkxJQ1QgKCVzKTogVGhlcmUgaXMgYSBkaXJlY3Rvcnkgd2l0aCBuYW1lICVzIGluICVzLiBBZGRpbmcgJXMgYXMgJXMiCiBtc2dzdHIgIiIKICJDT05GTElUICglcykgOiBJbCB5IGEgdW4gcsOpcGVydG9pcmUgbm9tbcOpICVzIGRhbnMgJXMuIEFqb3V0IGRlICVzIGNvbW1lICVzIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozMzQ3CisjOiBtZXJnZS1yZWN1cnNpdmUuYzozMzcxCiAjLCBjLWZvcm1hdAogbXNnaWQgIkFkZGluZyAlcyIKIG1zZ3N0ciAiQWpvdXQgZGUgJXMiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMzNTYKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMzODAKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ09ORkxJQ1QgKGFkZC9hZGQpOiBNZXJnZSBjb25mbGljdCBpbiAlcyIKIG1zZ3N0ciAiQ09ORkxJVCAoYWpvdXQvYWpvdXQpwqA6IENvbmZsaXQgZGUgZnVzaW9uIGRhbnMgJXMiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMzOTQKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjM0MjQKK21zZ2lkICJBbHJlYWR5IHVwIHRvIGRhdGUhIgorbXNnc3RyICJEw6lqw6Agw6Agam91ciAhIgorCisjOiBtZXJnZS1yZWN1cnNpdmUuYzozNDMzCisjLCBjLWZvcm1hdAorbXNnaWQgIm1lcmdpbmcgb2YgdHJlZXMgJXMgYW5kICVzIGZhaWxlZCIKK21zZ3N0ciAiw6ljaGVjIGRlIGZ1c2lvbiBkZXMgYXJicmVzICVzIGV0ICVzIgorCisjOiBtZXJnZS1yZWN1cnNpdmUuYzozNTM3Cittc2dpZCAiTWVyZ2luZzoiCittc2dzdHIgIkZ1c2lvbiA6IgorCisjOiBtZXJnZS1yZWN1cnNpdmUuYzozNTUwCisjLCBjLWZvcm1hdAorbXNnaWQgImZvdW5kICV1IGNvbW1vbiBhbmNlc3RvcjoiCittc2dpZF9wbHVyYWwgImZvdW5kICV1IGNvbW1vbiBhbmNlc3RvcnM6IgorbXNnc3RyWzBdICIldSBhbmPDqnRyZSBjb21tdW4gdHJvdXbDqSA6IgorbXNnc3RyWzFdICIldSBhbmPDqnRyZXMgY29tbXVucyB0cm91dsOpcyA6IgorCisjOiBtZXJnZS1yZWN1cnNpdmUuYzozNjAwCittc2dpZCAibWVyZ2UgcmV0dXJuZWQgbm8gY29tbWl0IgorbXNnc3RyICJsYSBmdXNpb24gbidhIHBhcyByZXRvdXJuw6kgZGUgY29tbWl0IgorCisjOiBtZXJnZS1yZWN1cnNpdmUuYzozNjU5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJZb3VyIGxvY2FsIGNoYW5nZXMgdG8gdGhlIGZvbGxvd2luZyBmaWxlcyB3b3VsZCBiZSBvdmVyd3JpdHRlbiBieSBtZXJnZTpcbiIKQEAgLTQxNzYsMTM3ICs0MjI1LDExMyBAQAogImZ1c2lvbsKgOlxuIgogIiAgJXMiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjM0MDUKLW1zZ2lkICJBbHJlYWR5IHVwIHRvIGRhdGUhIgotbXNnc3RyICJEw6lqw6Agw6Agam91ciAhIgotCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozNDE0Ci0jLCBjLWZvcm1hdAotbXNnaWQgIm1lcmdpbmcgb2YgdHJlZXMgJXMgYW5kICVzIGZhaWxlZCIKLW1zZ3N0ciAiw6ljaGVjIGRlIGZ1c2lvbiBkZXMgYXJicmVzICVzIGV0ICVzIgotCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozNTEzCi1tc2dpZCAiTWVyZ2luZzoiCi1tc2dzdHIgIkZ1c2lvbiA6IgotCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozNTI2Ci0jLCBjLWZvcm1hdAotbXNnaWQgImZvdW5kICV1IGNvbW1vbiBhbmNlc3RvcjoiCi1tc2dpZF9wbHVyYWwgImZvdW5kICV1IGNvbW1vbiBhbmNlc3RvcnM6IgotbXNnc3RyWzBdICIldSBhbmPDqnRyZSBjb21tdW4gdHJvdXbDqSA6IgotbXNnc3RyWzFdICIldSBhbmPDqnRyZXMgY29tbXVucyB0cm91dsOpcyA6IgotCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozNTY1Ci1tc2dpZCAibWVyZ2UgcmV0dXJuZWQgbm8gY29tbWl0IgotbXNnc3RyICJsYSBmdXNpb24gbidhIHBhcyByZXRvdXJuw6kgZGUgY29tbWl0IgotCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozNjMxCisjOiBtZXJnZS1yZWN1cnNpdmUuYzozNzU2CiAjLCBjLWZvcm1hdAogbXNnaWQgIkNvdWxkIG5vdCBwYXJzZSBvYmplY3QgJyVzJyIKIG1zZ3N0ciAiSW1wb3NzaWJsZSBkJ2FuYWx5c2VyIGwnb2JqZXQgJyVzJyIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzY0NyBidWlsdGluL21lcmdlLmM6Njk4IGJ1aWx0aW4vbWVyZ2UuYzo4NjkKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjM3NzQgYnVpbHRpbi9tZXJnZS5jOjY5NCBidWlsdGluL21lcmdlLmM6ODc0CiBtc2dpZCAiVW5hYmxlIHRvIHdyaXRlIGluZGV4LiIKIG1zZ3N0ciAiSW1wb3NzaWJsZSBkJ8OpY3JpcmUgbCdpbmRleC4iCiAKLSM6IG1pZHguYzo2OQorIzogbWlkeC5jOjY4CiAjLCBjLWZvcm1hdAogbXNnaWQgIm11bHRpLXBhY2staW5kZXggZmlsZSAlcyBpcyB0b28gc21hbGwiCiBtc2dzdHIgImxlIGZpY2hpZXIgZCdpbmRleCBtdWx0aS1wYXF1ZXQgJXMgZXN0IHRyb3AgcGV0aXQiCiAKLSM6IG1pZHguYzo4NQorIzogbWlkeC5jOjg0CiAjLCBjLWZvcm1hdAogbXNnaWQgIm11bHRpLXBhY2staW5kZXggc2lnbmF0dXJlIDB4JTA4eCBkb2VzIG5vdCBtYXRjaCBzaWduYXR1cmUgMHglMDh4IgogbXNnc3RyICIiCiAibGEgc2lnbmF0dXJlIGRlIGwnaW5kZXggbXVsdGktcGFxdWV0IDB4JTA4eCBuZSBjb3JyZXNwb25kIHBhcyDDoCBsYSBzaWduYXR1cmUgIgogIjB4JTA4eCIKIAotIzogbWlkeC5jOjkwCisjOiBtaWR4LmM6ODkKICMsIGMtZm9ybWF0CiBtc2dpZCAibXVsdGktcGFjay1pbmRleCB2ZXJzaW9uICVkIG5vdCByZWNvZ25pemVkIgogbXNnc3RyICJsYSB2ZXJzaW9uIGQnaW5kZXggbXVsdGktcGFxdWV0ICVkIG4nZXN0IHBhcyByZWNvbm51ZSIKIAotIzogbWlkeC5jOjk1CisjOiBtaWR4LmM6OTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiaGFzaCB2ZXJzaW9uICV1IGRvZXMgbm90IG1hdGNoIgogbXNnc3RyICJsYSB2ZXJzaW9uICV1IGR1IGNvbmRlbnPDqSBuZSBjb3JyZXNwb25kIHBhcyIKIAotIzogbWlkeC5jOjEwOQorIzogbWlkeC5jOjEwOAogbXNnaWQgImludmFsaWQgY2h1bmsgb2Zmc2V0ICh0b28gbGFyZ2UpIgogbXNnc3RyICJkw6ljYWxhZ2UgZGUgc2VjdGlvbiBpbnZhbGlkZSAodHJvcCBncmFuZCkiCiAKLSM6IG1pZHguYzoxMzMKKyM6IG1pZHguYzoxMzIKIG1zZ2lkICJ0ZXJtaW5hdGluZyBtdWx0aS1wYWNrLWluZGV4IGNodW5rIGlkIGFwcGVhcnMgZWFybGllciB0aGFuIGV4cGVjdGVkIgogbXNnc3RyICIiCiAiaWRlbnRpZmlhbnQgZGUgdGVybWluYWlzb24gZGUgdHJvbsOnb24gZCdpbmRleCBtdWx0aS1wYXF1ZXQgdGVybWluYW50ICIKICJhcHBhcmHDrnQgcGx1cyB0w7R0IHF1J2F0dGVuZHUiCiAKLSM6IG1pZHguYzoxNDYKKyM6IG1pZHguYzoxNDUKIG1zZ2lkICJtdWx0aS1wYWNrLWluZGV4IG1pc3NpbmcgcmVxdWlyZWQgcGFjay1uYW1lIGNodW5rIgogbXNnc3RyICJpbmRleCBtdWx0aS1wYXF1ZXQgbWFucXVlIGRlIHRyb27Dp29uIGRlIG5vbSBkZSBwYXF1ZXQiCiAKLSM6IG1pZHguYzoxNDgKKyM6IG1pZHguYzoxNDcKIG1zZ2lkICJtdWx0aS1wYWNrLWluZGV4IG1pc3NpbmcgcmVxdWlyZWQgT0lEIGZhbm91dCBjaHVuayIKIG1zZ3N0ciAiaW5kZXggbXVsdGktcGFxdWV0IG1hbnF1ZSBkZSB0cm9uw6dvbiBkZSBkJ8OpdGFsZW1lbnQgT0lEIHJlcXVpcyIKIAotIzogbWlkeC5jOjE1MAorIzogbWlkeC5jOjE0OQogbXNnaWQgIm11bHRpLXBhY2staW5kZXggbWlzc2luZyByZXF1aXJlZCBPSUQgbG9va3VwIGNodW5rIgogbXNnc3RyICJpbmRleCBtdWx0aS1wYXF1ZXQgbWFucXVlIGRlIHRyb27Dp29uIGRlIHJlY2hlcmNoZSBPSUQiCiAKLSM6IG1pZHguYzoxNTIKKyM6IG1pZHguYzoxNTEKIG1zZ2lkICJtdWx0aS1wYWNrLWluZGV4IG1pc3NpbmcgcmVxdWlyZWQgb2JqZWN0IG9mZnNldHMgY2h1bmsiCiBtc2dzdHIgImluZGV4IG11bHRpLXBhcXVldCBtYW5xdWUgZGUgdHJvbsOnb24gZGUgZMOpY2FsYWdlIGQnb2JqZXQiCiAKLSM6IG1pZHguYzoxNjYKKyM6IG1pZHguYzoxNjUKICMsIGMtZm9ybWF0CiBtc2dpZCAibXVsdGktcGFjay1pbmRleCBwYWNrIG5hbWVzIG91dCBvZiBvcmRlcjogJyVzJyBiZWZvcmUgJyVzJyIKIG1zZ3N0ciAiIgogImluZGV4IG11bHRpLXBhcXVldCBsZXMgbm9tcyBkZSBwYXF1ZXRzIHNvbnQgZW4gZMOpc29yZHJlwqA6ICclcycgYXZhbnQgJyVzJyIKIAotIzogbWlkeC5jOjIxMQorIzogbWlkeC5jOjIxMAogIywgYy1mb3JtYXQKIG1zZ2lkICJiYWQgcGFjay1pbnQtaWQ6ICV1ICgldSB0b3RhbCBwYWNrcykiCiBtc2dzdHIgIm1hdXZhaXMgcGFjay1pbnQtaWTCoDogJXUgKCV1IHBhcXVldHMgYXUgdG90YWwpIgogCi0jOiBtaWR4LmM6MjYxCisjOiBtaWR4LmM6MjYwCiBtc2dpZCAibXVsdGktcGFjay1pbmRleCBzdG9yZXMgYSA2NC1iaXQgb2Zmc2V0LCBidXQgb2ZmX3QgaXMgdG9vIHNtYWxsIgogbXNnc3RyICIiCiAibXVsdGktcGFjay1pbmRleCBzdG9jayB1biBkw6ljYWxhZ2UgZW4gNjQtYml0LCBtYWlzIG9mZl90IGVzdCB0cm9wIHBldGl0IgogCi0jOiBtaWR4LmM6Mjg5CisjOiBtaWR4LmM6Mjg4CiBtc2dpZCAiZXJyb3IgcHJlcGFyaW5nIHBhY2tmaWxlIGZyb20gbXVsdGktcGFjay1pbmRleCIKIG1zZ3N0ciAiZXJyZXVyIMOgIGxhIHByw6lwYXJhdGlvbiBkdSBmaWNoaWVyIHBhcXVldCBkZXB1aXMgdW4gaW5kZXggbXVsdGktcGFxdWV0IgogCi0jOiBtaWR4LmM6NDcwCisjOiBtaWR4LmM6NDY5CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBhZGQgcGFja2ZpbGUgJyVzJyIKIG1zZ3N0ciAiw6ljaGVjIGRlIGwnYWpvdXQgZHUgZmljaGllciBwYXF1ZXQgJyVzJyIKIAotIzogbWlkeC5jOjQ3NgorIzogbWlkeC5jOjQ3NQogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gb3BlbiBwYWNrLWluZGV4ICclcyciCiBtc2dzdHIgIsOpY2hlYyDDoCBsJ291dmVydHVyZSBkdSBmaWNoaWVyIHBhcXVldCAnJXMnIgogCi0jOiBtaWR4LmM6NTM2CisjOiBtaWR4LmM6NTM1CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBsb2NhdGUgb2JqZWN0ICVkIGluIHBhY2tmaWxlIgogbXNnc3RyICLDqWNoZWMgZGUgbG9jYWxpc2F0aW9uIGRlIGwnb2JqZXQgJWQgZGFucyBsZSBmaWNoaWVyIHBhcXVldCIKIAotIzogbWlkeC5jOjg2NQorIzogbWlkeC5jOjg2NAogIywgYy1mb3JtYXQKIG1zZ2lkICJkaWQgbm90IHNlZSBwYWNrLWZpbGUgJXMgdG8gZHJvcCIKIG1zZ3N0ciAiZmljaGllciBwYXF1ZXQgw6Agw6lsaW1pbmVyICVzIG5vbiB0cm91dsOpIgogCi0jOiBtaWR4LmM6MTAzNgorIzogbWlkeC5jOjEwMzUKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIGNsZWFyIG11bHRpLXBhY2staW5kZXggYXQgJXMiCiBtc2dzdHIgIsOpY2hlYyBkdSBuZXR0b3lhZ2UgZGUgbCdpbmRleCBkZSBtdWx0aS1wYXF1ZXQgw6AgJXMiCiAKLSM6IG1pZHguYzoxMDkxCisjOiBtaWR4LmM6MTA5MAogbXNnaWQgIkxvb2tpbmcgZm9yIHJlZmVyZW5jZWQgcGFja2ZpbGVzIgogbXNnc3RyICJSZWNoZXJjaGUgZGUgZmljaGllcnMgcGFxdWV0cyByw6lmw6lyZW5jw6lzIgogCi0jOiBtaWR4LmM6MTEwNgorIzogbWlkeC5jOjExMDUKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIm9pZCBmYW5vdXQgb3V0IG9mIG9yZGVyOiBmYW5vdXRbJWRdID0gJTxQUkl4MzI+ID4gJTxQUkl4MzI+ID0gZmFub3V0WyVkXSIKQEAgLTQzMTQsNTcgKzQzMzksNTcgQEAKICLDqXRhbGVtZW50IG9pZCBlbiBkw6lzb3JkcmXCoDogw6l0YWxlbWVudFslZF0gPSAlPFBSSXgzMj4gPiAlPFBSSXgzMj4gPSAiCiAiw6l0YWxlbWVudFslZF0iCiAKLSM6IG1pZHguYzoxMTEwCisjOiBtaWR4LmM6MTEwOQogbXNnaWQgIlZlcmlmeWluZyBPSUQgb3JkZXIgaW4gTUlEWCIKIG1zZ3N0ciAiVsOpcmlmaWNhdGlvbiBkZSBsJ29yZHJlIGRlcyBPSUQgZGFucyBNSURYIgogCi0jOiBtaWR4LmM6MTExOQorIzogbWlkeC5jOjExMTgKICMsIGMtZm9ybWF0CiBtc2dpZCAib2lkIGxvb2t1cCBvdXQgb2Ygb3JkZXI6IG9pZFslZF0gPSAlcyA+PSAlcyA9IG9pZFslZF0iCiBtc2dzdHIgInJlY2hlcmNoZSBkJ29pZCBlbiBkw6lzb3JkcmXCoDogb2lkWyVkXSA9ICVzID49ICVzID0gb2lkWyVkXSIKIAotIzogbWlkeC5jOjExMzgKKyM6IG1pZHguYzoxMTM3CiBtc2dpZCAiU29ydGluZyBvYmplY3RzIGJ5IHBhY2tmaWxlIgogbXNnc3RyICJDbGFzc2VtZW50IGRlcyBvYmpldHMgcGFyIGZpY2hpZXIgcGFxdWV0IgogCi0jOiBtaWR4LmM6MTE0NAorIzogbWlkeC5jOjExNDMKIG1zZ2lkICJWZXJpZnlpbmcgb2JqZWN0IG9mZnNldHMiCiBtc2dzdHIgIlbDqXJpZmljYXRpb24gZGVzIGTDqWNhbGFnZXMgZGVzIG9iamV0cyIKIAotIzogbWlkeC5jOjExNjAKKyM6IG1pZHguYzoxMTU5CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBsb2FkIHBhY2sgZW50cnkgZm9yIG9pZFslZF0gPSAlcyIKIG1zZ3N0ciAiw6ljaGVjIGRlIGxhIGxlY3R1cmUgZGUgbCfDqWzDqW1lbnQgZGUgY2FjaGUgcG91ciBvaWRbJWRdID0gJXMiCiAKLSM6IG1pZHguYzoxMTY2CisjOiBtaWR4LmM6MTE2NQogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gbG9hZCBwYWNrLWluZGV4IGZvciBwYWNrZmlsZSAlcyIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkZSBsaXJlIGxlIGZpY2hpZXIgcGFxdWV0ICVzIgogCi0jOiBtaWR4LmM6MTE3NQorIzogbWlkeC5jOjExNzQKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW5jb3JyZWN0IG9iamVjdCBvZmZzZXQgZm9yIG9pZFslZF0gPSAlczogJTxQUkl4NjQ+ICE9ICU8UFJJeDY0PiIKIG1zZ3N0ciAiZMOpY2FsYWdlIGQnb2JqZXQgaW5jb3JyZWN0IHBvdXIgb2lkWyVkXSA9ICVzwqA6ICU8UFJJeDY0PiAhPSAlPFBSSXg2ND4iCiAKLSM6IG1pZHguYzoxMzUwCisjOiBtaWR4LmM6MTM0OQogbXNnaWQgImNvdWxkIG5vdCBzdGFydCBwYWNrLW9iamVjdHMiCiBtc2dzdHIgIkltcG9zc2libGUgZGUgZMOpbWFycmVyIGxlIGdyb3VwZW1lbnQgZCdvYmpldHMiCiAKLSM6IG1pZHguYzoxMzY5CisjOiBtaWR4LmM6MTM2OAogbXNnaWQgImNvdWxkIG5vdCBmaW5pc2ggcGFjay1vYmplY3RzIgogbXNnc3RyICJJbXBvc3NpYmxlIGRlIGZpbmlyIGxlIGdyb3VwZW1lbnQgZCdvYmpldHMiCiAKLSM6IG5hbWUtaGFzaC5jOjUzMgorIzogbmFtZS1oYXNoLmM6NTM3CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBjcmVhdGUgbGF6eV9kaXIgdGhyZWFkOiAlcyIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkZSBjcsOpZXIgbGUgZmlsIGxhenlfZGlyIDogJXMiCiAKLSM6IG5hbWUtaGFzaC5jOjU1NAorIzogbmFtZS1oYXNoLmM6NTU5CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBjcmVhdGUgbGF6eV9uYW1lIHRocmVhZDogJXMiCiBtc2dzdHIgImltcG9zc2libGUgZGUgY3LDqWVyIGxlIGZpbCBsYXp5X25hbWUgOiAlcyIKIAotIzogbmFtZS1oYXNoLmM6NTYwCisjOiBuYW1lLWhhc2guYzo1NjUKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGpvaW4gbGF6eV9uYW1lIHRocmVhZDogJXMiCiBtc2dzdHIgImltcG9zc2libGUgZGUgam9pbmRyZSBsZSBmaWwgbGF6eV9uYW1lIDogJXMiCkBAIC00NDA4LDQxICs0NDMzLDQxIEBACiBtc2dpZCAiQmFkICVzIHZhbHVlOiAnJXMnIgogbXNnc3RyICJNYXV2YWlzZSB2YWxldXIgZGUgJXMgOiAnJXMnIgogCi0jOiBvYmplY3QuYzo1NAorIzogb2JqZWN0LmM6NTMKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBvYmplY3QgdHlwZSBcIiVzXCIiCiBtc2dzdHIgInR5cGUgZCdvYmpldCBpbnZhbGlkZSBcIiVzXCIiCiAKLSM6IG9iamVjdC5jOjE3NAorIzogb2JqZWN0LmM6MTczCiAjLCBjLWZvcm1hdAogbXNnaWQgIm9iamVjdCAlcyBpcyBhICVzLCBub3QgYSAlcyIKIG1zZ3N0ciAibCdvYmpldCAlcyBlc3QgZGUgdHlwZSAlcywgcGFzIGRlIHR5cGUgJXMiCiAKLSM6IG9iamVjdC5jOjIzNAorIzogb2JqZWN0LmM6MjMzCiAjLCBjLWZvcm1hdAogbXNnaWQgIm9iamVjdCAlcyBoYXMgdW5rbm93biB0eXBlIGlkICVkIgogbXNnc3RyICJsJ29iamV0ICVzIGEgdW4gaWQgZGUgdHlwZSBpbmNvbm51ICVkIgogCi0jOiBvYmplY3QuYzoyNDcKKyM6IG9iamVjdC5jOjI0NgogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gcGFyc2Ugb2JqZWN0OiAlcyIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkJ2FuYWx5c2VyIGwnb2JqZXQgOiAlcyIKIAotIzogb2JqZWN0LmM6MjY3IG9iamVjdC5jOjI3OAorIzogb2JqZWN0LmM6MjY2IG9iamVjdC5jOjI3NwogIywgYy1mb3JtYXQKIG1zZ2lkICJoYXNoIG1pc21hdGNoICVzIgogbXNnc3RyICJpbmNvaMOpcmVuY2UgZGUgaGFjaGFnZSAlcyIKIAotIzogcGFja2ZpbGUuYzo2NDgKKyM6IHBhY2tmaWxlLmM6NjQxCiBtc2dpZCAib2Zmc2V0IGJlZm9yZSBlbmQgb2YgcGFja2ZpbGUgKGJyb2tlbiAuaWR4PykiCiBtc2dzdHIgIm9mZnNldCBhdmFudCBsYSBmaW4gZHUgZmljaGllciBwYXF1ZXQgKC5pZHggY2Fzc8OpwqA/KSIKIAotIzogcGFja2ZpbGUuYzoxODk5CisjOiBwYWNrZmlsZS5jOjE4ODcKICMsIGMtZm9ybWF0CiBtc2dpZCAib2Zmc2V0IGJlZm9yZSBzdGFydCBvZiBwYWNrIGluZGV4IGZvciAlcyAoY29ycnVwdCBpbmRleD8pIgogbXNnc3RyICJvZmZzZXQgYXZhbnQgbGUgZMOpYnV0IGRlIGwnaW5kZXggZGUgcGFxdWV0IHBvdXIgJXMgKGluZGV4IGNvcnJvbXB1wqA/KSIKIAotIzogcGFja2ZpbGUuYzoxOTAzCisjOiBwYWNrZmlsZS5jOjE4OTEKICMsIGMtZm9ybWF0CiBtc2dpZCAib2Zmc2V0IGJleW9uZCBlbmQgb2YgcGFjayBpbmRleCBmb3IgJXMgKHRydW5jYXRlZCBpbmRleD8pIgogbXNnc3RyICIiCkBAIC00NDg4LDI2ICs0NTEzLDI2IEBACiBtc2dpZCAiZGlkIHlvdSBtZWFuIGAtLSVzYCAod2l0aCB0d28gZGFzaGVzID8pIgogbXNnc3RyICJ2b3VsaWV6LXZvdXMgZGlyZSBgLS0lc2AgKGF2ZWMgZGV1eCBzaWduZXMgbW9pbnMpPyIKIAotIzogcGFyc2Utb3B0aW9ucy5jOjg1OQorIzogcGFyc2Utb3B0aW9ucy5jOjg2MAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmtub3duIG9wdGlvbiBgJXMnIgogbXNnc3RyICJvcHRpb24gaW5jb25udWUgwqvCoCVzwqDCuyIKIAotIzogcGFyc2Utb3B0aW9ucy5jOjg2MQorIzogcGFyc2Utb3B0aW9ucy5jOjg2MgogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmtub3duIHN3aXRjaCBgJWMnIgogbXNnc3RyICJiYXNjdWxlIGluY29ubnVlIMKrwqAlY8KgwrsiCiAKLSM6IHBhcnNlLW9wdGlvbnMuYzo4NjMKKyM6IHBhcnNlLW9wdGlvbnMuYzo4NjQKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5rbm93biBub24tYXNjaWkgb3B0aW9uIGluIHN0cmluZzogYCVzJyIKIG1zZ3N0ciAib3B0aW9uIG5vbi1hc2NpaSBpbmNvbm51ZSBkYW5zIGxhIGNoYcOubmXCoDogJyVzJyIKIAotIzogcGFyc2Utb3B0aW9ucy5jOjg4NworIzogcGFyc2Utb3B0aW9ucy5jOjg4OAogbXNnaWQgIi4uLiIKIG1zZ3N0ciAiLi4uIgogCi0jOiBwYXJzZS1vcHRpb25zLmM6OTA2CisjOiBwYXJzZS1vcHRpb25zLmM6OTA3CiAjLCBjLWZvcm1hdAogbXNnaWQgInVzYWdlOiAlcyIKIG1zZ3N0ciAidXNhZ2UgOiAlcyIKQEAgLTQ1MTUsMjEgKzQ1NDAsMjEgQEAKICMuIFRSQU5TTEFUT1JTOiB0aGUgY29sb24gaGVyZSBzaG91bGQgYWxpZ24gd2l0aCB0aGUKICMuIG9uZSBpbiAidXNhZ2U6ICVzIiB0cmFuc2xhdGlvbi4KICMuCi0jOiBwYXJzZS1vcHRpb25zLmM6OTEyCisjOiBwYXJzZS1vcHRpb25zLmM6OTEzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiAgIG9yOiAlcyIKIG1zZ3N0ciAiICAgb3UgOiAlcyIKIAotIzogcGFyc2Utb3B0aW9ucy5jOjkxNQorIzogcGFyc2Utb3B0aW9ucy5jOjkxNgogIywgYy1mb3JtYXQKIG1zZ2lkICIgICAgJXMiCiBtc2dzdHIgIiAgICAlcyIKIAotIzogcGFyc2Utb3B0aW9ucy5jOjk1NAorIzogcGFyc2Utb3B0aW9ucy5jOjk1NQogbXNnaWQgIi1OVU0iCiBtc2dzdHIgIi1OVU0iCiAKLSM6IHBhcnNlLW9wdGlvbnMuYzo5NjgKKyM6IHBhcnNlLW9wdGlvbnMuYzo5NjkKICMsIGMtZm9ybWF0CiBtc2dpZCAiYWxpYXMgb2YgLS0lcyIKIG1zZ3N0ciAiYWxpYXMgcG91ciAtLSVzIgpAQCAtNDcwNCwyOSArNDcyOSwzOCBAQAogbXNnaWQgInVuYWJsZSB0byBwYXJzZSAtLXByZXR0eSBmb3JtYXQiCiBtc2dzdHIgImltcG9zc2libGUgZCdhbmFseXNlciBsZSBmb3JtYXQgLS1wcmV0dHkiCiAKLSM6IHJhbmdlLWRpZmYuYzo3MAorIzogcHJvbWlzb3ItcmVtb3RlLmM6MjUKK21zZ2lkICJSZW1vdGUgd2l0aCBubyBVUkwiCittc2dzdHIgIkTDqXDDtHQgZGlzdGFudCBzYW5zIFVSTCIKKworIzogcHJvbWlzb3ItcmVtb3RlLmM6NjEKKyMsIGMtZm9ybWF0Cittc2dpZCAicHJvbWlzb3IgcmVtb3RlIG5hbWUgY2Fubm90IGJlZ2luIHdpdGggJy8nOiAlcyIKK21zZ3N0ciAidW4gbm9tIGRlIHByb21ldHRldXIgZGlzdGFudCBuZSBwZXV0IHBhcyBjb21tZW5jZXIgcGFyICcvJ8KgOiAlcyIKKworIzogcmFuZ2UtZGlmZi5jOjcxCiBtc2dpZCAiY291bGQgbm90IHN0YXJ0IGBsb2dgIgogbXNnc3RyICJpbXBvc3NpYmxlIGRlIGTDqW1hcnJlciBgbG9nYCIKIAotIzogcmFuZ2UtZGlmZi5jOjcyCisjOiByYW5nZS1kaWZmLmM6NzMKIG1zZ2lkICJjb3VsZCBub3QgcmVhZCBgbG9nYCBvdXRwdXQiCiBtc2dzdHIgImltcG9zc2libGUgZGUgbGlyZSBsYSBzb3J0aWUgZGUgYGxvZ2AiCiAKLSM6IHJhbmdlLWRpZmYuYzo5MSBzZXF1ZW5jZXIuYzo1MDIxCisjOiByYW5nZS1kaWZmLmM6OTIgc2VxdWVuY2VyLmM6NDk4NQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcGFyc2UgY29tbWl0ICclcyciCiBtc2dzdHIgImltcG9zc2libGUgZCdhbmFseXNlciBsZSBjb21taXQgJyVzJyIKIAotIzogcmFuZ2UtZGlmZi5jOjExNworIzogcmFuZ2UtZGlmZi5jOjExOAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcGFyc2UgZ2l0IGhlYWRlciAnJS4qcyciCiBtc2dzdHIgImltcG9zc2libGUgZCdhbmFseXNlciBsJ2VudMOqdGUgZ2l0ICclLipzJyIKIAotIzogcmFuZ2UtZGlmZi5jOjI3NAorIzogcmFuZ2UtZGlmZi5jOjI3NQogbXNnaWQgImZhaWxlZCB0byBnZW5lcmF0ZSBkaWZmIgogbXNnc3RyICLDqWNoZWMgZGUgbGEgZ8OpbsOpcmF0aW9uIGRlIGRpZmYiCiAKLSM6IHJhbmdlLWRpZmYuYzo1MDYgcmFuZ2UtZGlmZi5jOjUwOAorIzogcmFuZ2UtZGlmZi5jOjUwNyByYW5nZS1kaWZmLmM6NTA5CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBwYXJzZSBsb2cgZm9yICclcyciCiBtc2dzdHIgImltcG9zc2libGUgZCdhbmFseXNlciBsZSBqb3VybmFsIHBvdXIgJyVzJyIKQEAgLTQ3NzIsMTEgKzQ4MDYsMTEgQEAKIG1zZ2lkICInJXMnIGFwcGVhcnMgYXMgYm90aCBhIGZpbGUgYW5kIGFzIGEgZGlyZWN0b3J5IgogbXNnc3RyICInJXMnIGV4aXN0ZSDDoCBsYSBmb2lzIGNvbW1lIHVuIGZpY2hpZXIgZXQgdW4gcsOpcGVydG9pcmUiCiAKLSM6IHJlYWQtY2FjaGUuYzoxNDk5CisjOiByZWFkLWNhY2hlLmM6MTUyMAogbXNnaWQgIlJlZnJlc2ggaW5kZXgiCiBtc2dzdHIgIlJhZnJhw65jaGlyIGwnaW5kZXgiCiAKLSM6IHJlYWQtY2FjaGUuYzoxNjEzCisjOiByZWFkLWNhY2hlLmM6MTYzNQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiaW5kZXgudmVyc2lvbiBzZXQsIGJ1dCB0aGUgdmFsdWUgaXMgaW52YWxpZC5cbiIKQEAgLTQ3ODUsNyArNDgxOSw3IEBACiAidmVyc2lvbiBkJ2luZGV4IHJlbnNlaWduw6llLCBtYWlzIGxhIHZhbGV1ciBlc3QgaW52YWxpZGUuXG4iCiAiVXRpbGlzYXRpb24gZGUgbGEgdmVyc2lvbiAlaSIKIAotIzogcmVhZC1jYWNoZS5jOjE2MjMKKyM6IHJlYWQtY2FjaGUuYzoxNjQ1CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJHSVRfSU5ERVhfVkVSU0lPTiBzZXQsIGJ1dCB0aGUgdmFsdWUgaXMgaW52YWxpZC5cbiIKQEAgLTQ3OTQsMTM4ICs0ODI4LDEzOCBAQAogIkdJVF9JTkRFWF9WRVJTSU9OIGVzdCByZW5zZWlnbsOpLCBtYWlzIGxhIHZhbGV1ciBlc3QgaW52YWxpZGUuXG4iCiAiVXRpbGlzYXRpb24gZGUgbGEgdmVyc2lvbiAlaSIKIAotIzogcmVhZC1jYWNoZS5jOjE2NzkKKyM6IHJlYWQtY2FjaGUuYzoxNzAxCiAjLCBjLWZvcm1hdAogbXNnaWQgImJhZCBzaWduYXR1cmUgMHglMDh4IgogbXNnc3RyICJzaWduYXR1cmUgaW5jb3JyZWN0ZSAweCUwOHgiCiAKLSM6IHJlYWQtY2FjaGUuYzoxNjgyCisjOiByZWFkLWNhY2hlLmM6MTcwNAogIywgYy1mb3JtYXQKIG1zZ2lkICJiYWQgaW5kZXggdmVyc2lvbiAlZCIKIG1zZ3N0ciAibWF1dmFpc2UgdmVyc2lvbiBkJ2luZGV4ICVkIgogCi0jOiByZWFkLWNhY2hlLmM6MTY5MQorIzogcmVhZC1jYWNoZS5jOjE3MTMKIG1zZ2lkICJiYWQgaW5kZXggZmlsZSBzaGExIHNpZ25hdHVyZSIKIG1zZ3N0ciAibWF1dmFpc2Ugc2lnbmF0dXJlIHNoYTEgZCdpbmRleCIKIAotIzogcmVhZC1jYWNoZS5jOjE3MjEKKyM6IHJlYWQtY2FjaGUuYzoxNzQzCiAjLCBjLWZvcm1hdAogbXNnaWQgImluZGV4IHVzZXMgJS40cyBleHRlbnNpb24sIHdoaWNoIHdlIGRvIG5vdCB1bmRlcnN0YW5kIgogbXNnc3RyICJsJ2luZGV4IHV0aWxpc2UgbCdleHRlbnNpb24gJS40cyBxdWkgbidlc3QgcGFzIGNvbXByaXNlIgogCi0jOiByZWFkLWNhY2hlLmM6MTcyMworIzogcmVhZC1jYWNoZS5jOjE3NDUKICMsIGMtZm9ybWF0CiBtc2dpZCAiaWdub3JpbmcgJS40cyBleHRlbnNpb24iCiBtc2dzdHIgImV4dGVuc2lvbiAlLjRzIGlnbm9yw6llIgogCi0jOiByZWFkLWNhY2hlLmM6MTc2MAorIzogcmVhZC1jYWNoZS5jOjE3ODIKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5rbm93biBpbmRleCBlbnRyeSBmb3JtYXQgMHglMDh4IgogbXNnc3RyICJmb3JtYXQgZCdlbnRyw6llIGQnaW5kZXggaW5jb25udSAweCUwOHgiCiAKLSM6IHJlYWQtY2FjaGUuYzoxNzc2CisjOiByZWFkLWNhY2hlLmM6MTc5OAogIywgYy1mb3JtYXQKIG1zZ2lkICJtYWxmb3JtZWQgbmFtZSBmaWVsZCBpbiB0aGUgaW5kZXgsIG5lYXIgcGF0aCAnJXMnIgogbXNnc3RyICJjaGFtcCBkZSBub20gbWFsZm9ybcOpIGRhbnMgbCdpbmRleCwgcHLDqHMgZHUgY2hlbWluICclcyciCiAKLSM6IHJlYWQtY2FjaGUuYzoxODMzCisjOiByZWFkLWNhY2hlLmM6MTg1NQogbXNnaWQgInVub3JkZXJlZCBzdGFnZSBlbnRyaWVzIGluIGluZGV4IgogbXNnc3RyICJlbnRyw6llcyBkZSBwcsOpcGFyYXRpb24gbm9uIG9yZG9ubsOpZXMgZGFucyBsJ2luZGV4IgogCi0jOiByZWFkLWNhY2hlLmM6MTgzNgorIzogcmVhZC1jYWNoZS5jOjE4NTgKICMsIGMtZm9ybWF0CiBtc2dpZCAibXVsdGlwbGUgc3RhZ2UgZW50cmllcyBmb3IgbWVyZ2VkIGZpbGUgJyVzJyIKIG1zZ3N0ciAiZW50csOpZXMgbXVsdGlwbGVzIGRlIHByw6lwYXJhdGlvbiBwb3VyIGxlIGZpY2hpZXIgZnVzaW9ubsOpICclcyciCiAKLSM6IHJlYWQtY2FjaGUuYzoxODM5CisjOiByZWFkLWNhY2hlLmM6MTg2MQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bm9yZGVyZWQgc3RhZ2UgZW50cmllcyBmb3IgJyVzJyIKIG1zZ3N0ciAiZW50csOpZXMgZGUgcHLDqXBhcmF0aW9uIG5vbiBvcmRvbm7DqWVzIHBvdXIgJyVzJyIKIAotIzogcmVhZC1jYWNoZS5jOjE5NDYgcmVhZC1jYWNoZS5jOjIyMzQgcmVyZXJlLmM6NTY1IHJlcmVyZS5jOjU5OSByZXJlcmUuYzoxMTExCi0jOiBidWlsdGluL2FkZC5jOjQ2MCBidWlsdGluL2NoZWNrLWlnbm9yZS5jOjE3OCBidWlsdGluL2NoZWNrb3V0LmM6NDY3Ci0jOiBidWlsdGluL2NoZWNrb3V0LmM6NjUxIGJ1aWx0aW4vY2xlYW4uYzo5NTYgYnVpbHRpbi9jb21taXQuYzozNDcKKyM6IHJlYWQtY2FjaGUuYzoxOTY3IHJlYWQtY2FjaGUuYzoyMjU1IHJlcmVyZS5jOjU2NSByZXJlcmUuYzo1OTkgcmVyZXJlLmM6MTExMQorIzogYnVpbHRpbi9hZGQuYzo0NjAgYnVpbHRpbi9jaGVjay1pZ25vcmUuYzoxNzggYnVpbHRpbi9jaGVja291dC5jOjQ2OAorIzogYnVpbHRpbi9jaGVja291dC5jOjY1MiBidWlsdGluL2NsZWFuLmM6OTY3IGJ1aWx0aW4vY29tbWl0LmM6MzQ3CiAjOiBidWlsdGluL2RpZmYtdHJlZS5jOjEyMCBidWlsdGluL2dyZXAuYzo0OTkgYnVpbHRpbi9tdi5jOjE0NQogIzogYnVpbHRpbi9yZXNldC5jOjI0NSBidWlsdGluL3JtLmM6MjcxIGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzozMzAKIG1zZ2lkICJpbmRleCBmaWxlIGNvcnJ1cHQiCiBtc2dzdHIgImZpY2hpZXIgZCdpbmRleCBjb3Jyb21wdSIKIAotIzogcmVhZC1jYWNoZS5jOjIwODcKKyM6IHJlYWQtY2FjaGUuYzoyMTA4CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBjcmVhdGUgbG9hZF9jYWNoZV9lbnRyaWVzIHRocmVhZDogJXMiCiBtc2dzdHIgImltcG9zc2libGUgZGUgY3LDqWVyIGxlIGZpbCBsb2FkX2NhY2hlX2VudHJpZXMgOiAlcyIKIAotIzogcmVhZC1jYWNoZS5jOjIxMDAKKyM6IHJlYWQtY2FjaGUuYzoyMTIxCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBqb2luIGxvYWRfY2FjaGVfZW50cmllcyB0aHJlYWQ6ICVzIgogbXNnc3RyICJpbXBvc3NpYmxlIGRlIGpvaW5kcmUgbGUgZmlsIGxvYWRfY2FjaF9lbnRyaWVzIDogJXMiCiAKLSM6IHJlYWQtY2FjaGUuYzoyMTMzCisjOiByZWFkLWNhY2hlLmM6MjE1NAogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogaW5kZXggZmlsZSBvcGVuIGZhaWxlZCIKIG1zZ3N0ciAiJXPCoDogbCdvdXZlcnR1cmUgZHUgZmljaGllciBkJ2luZGV4IGEgw6ljaG91w6kiCiAKLSM6IHJlYWQtY2FjaGUuYzoyMTM3CisjOiByZWFkLWNhY2hlLmM6MjE1OAogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogY2Fubm90IHN0YXQgdGhlIG9wZW4gaW5kZXgiCiBtc2dzdHIgIiVzwqA6IGltcG9zc2libGUgZGUgZmFpcmUgdW4gc3RhdCBzdXIgbCdpbmRleCBvdXZlcnQiCiAKLSM6IHJlYWQtY2FjaGUuYzoyMTQxCisjOiByZWFkLWNhY2hlLmM6MjE2MgogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogaW5kZXggZmlsZSBzbWFsbGVyIHRoYW4gZXhwZWN0ZWQiCiBtc2dzdHIgIiVzwqA6IGZpY2hpZXIgZCdpbmRleCBwbHVzIHBldGl0IHF1J2F0dGVuZHUiCiAKLSM6IHJlYWQtY2FjaGUuYzoyMTQ1CisjOiByZWFkLWNhY2hlLmM6MjE2NgogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogdW5hYmxlIHRvIG1hcCBpbmRleCBmaWxlIgogbXNnc3RyICIlc8KgOiBpbXBvc3NpYmxlIGRlIG1hcHBlciBsZSBmaWNoaWVyIGQnaW5kZXgiCiAKLSM6IHJlYWQtY2FjaGUuYzoyMTg3CisjOiByZWFkLWNhY2hlLmM6MjIwOAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gY3JlYXRlIGxvYWRfaW5kZXhfZXh0ZW5zaW9ucyB0aHJlYWQ6ICVzIgogbXNnc3RyICJpbXBvc3NpYmxlIGRlIGNyw6llciBsZSBmaWwgbG9hZF9pbmRleF9leHRlbnNpb25zIDogJXMiCiAKLSM6IHJlYWQtY2FjaGUuYzoyMjE0CisjOiByZWFkLWNhY2hlLmM6MjIzNQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gam9pbiBsb2FkX2luZGV4X2V4dGVuc2lvbnMgdGhyZWFkOiAlcyIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkZSBqb2luZHJlIGxlIGZpbCBsb2FkX2luZGV4X2V4dGVuc2lvbnMgOiAlcyIKIAotIzogcmVhZC1jYWNoZS5jOjIyNDYKKyM6IHJlYWQtY2FjaGUuYzoyMjY3CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBmcmVzaGVuIHNoYXJlZCBpbmRleCAnJXMnIgogbXNnc3RyICJpbXBvc3NpYmxlIGRlIHJhZnJhw65jaGlyIGwnaW5kZXggcGFydGFnw6kgJyVzJyIKIAotIzogcmVhZC1jYWNoZS5jOjIyOTMKKyM6IHJlYWQtY2FjaGUuYzoyMzE0CiAjLCBjLWZvcm1hdAogbXNnaWQgImJyb2tlbiBpbmRleCwgZXhwZWN0ICVzIGluICVzLCBnb3QgJXMiCiBtc2dzdHIgImluZGV4IGNhc3PDqSwgJXMgYXR0ZW5kdSBkYW5zICVzLCAlcyBvYnRlbnUiCiAKLSM6IHJlYWQtY2FjaGUuYzoyOTg5IHdyYXBwZXIuYzo2NTggYnVpbHRpbi9tZXJnZS5jOjExMTQKKyM6IHJlYWQtY2FjaGUuYzozMDEwIHdyYXBwZXIuYzo2MjIgYnVpbHRpbi9tZXJnZS5jOjExMTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGNsb3NlICclcyciCiBtc2dzdHIgImltcG9zc2libGUgZGUgZmVybWVyICclcyciCiAKLSM6IHJlYWQtY2FjaGUuYzozMDkyIHNlcXVlbmNlci5jOjIzNTggc2VxdWVuY2VyLmM6MzkyOAorIzogcmVhZC1jYWNoZS5jOjMxMTMgc2VxdWVuY2VyLmM6MjI5NiBzZXF1ZW5jZXIuYzozOTE3CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBzdGF0ICclcyciCiBtc2dzdHIgInN0YXQgaW1wb3NzaWJsZSBkZSAnJXMnIgogCi0jOiByZWFkLWNhY2hlLmM6MzEwNQorIzogcmVhZC1jYWNoZS5jOjMxMjYKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIG9wZW4gZ2l0IGRpcjogJXMiCiBtc2dzdHIgImltcG9zc2libGUgZCdvdXZyaXIgbGUgcsOpcGVydG9pcmUgZ2l0wqA6ICVzIgogCi0jOiByZWFkLWNhY2hlLmM6MzExNworIzogcmVhZC1jYWNoZS5jOjMxMzgKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHVubGluazogJXMiCiBtc2dzdHIgIsOpY2hlYyBsb3JzIGRlIGwndW5saW5rwqA6ICVzIgogCi0jOiByZWFkLWNhY2hlLmM6MzE0MgorIzogcmVhZC1jYWNoZS5jOjMxNjMKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IGZpeCBwZXJtaXNzaW9uIGJpdHMgb24gJyVzJyIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkZSByw6lnbGVyIGxlcyBiaXRzIGRlIGRyb2l0IGRlICclcyciCiAKLSM6IHJlYWQtY2FjaGUuYzozMjkxCisjOiByZWFkLWNhY2hlLmM6MzMxMgogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogY2Fubm90IGRyb3AgdG8gc3RhZ2UgIzAiCiBtc2dzdHIgIiVzIDogaW1wb3NzaWJsZSBkZSByZXZlbmlyIMOgIGwnw6l0YXBlIDAiCkBAIC01MDMyLDggKzUwNjYsOCBAQAogbXNnaWQgIk5vdGUgdGhhdCBlbXB0eSBjb21taXRzIGFyZSBjb21tZW50ZWQgb3V0IgogbXNnc3RyICJWZXVpbGxleiBub3RlciBxdWUgbGVzIGNvbW1pdHMgdmlkZXMgc29udCBlbiBjb21tZW50YWlyZSIKIAotIzogcmViYXNlLWludGVyYWN0aXZlLmM6MTA1IHJlcmVyZS5jOjQ4NSByZXJlcmUuYzo2OTIgc2VxdWVuY2VyLmM6MzQ0NwotIzogc2VxdWVuY2VyLmM6MzQ3MyBzZXF1ZW5jZXIuYzo1MTIwIGJ1aWx0aW4vZnNjay5jOjM1NiBidWlsdGluL3JlYmFzZS5jOjIzNQorIzogcmViYXNlLWludGVyYWN0aXZlLmM6MTA1IHJlcmVyZS5jOjQ4NSByZXJlcmUuYzo2OTIgc2VxdWVuY2VyLmM6MzM4OAorIzogc2VxdWVuY2VyLmM6MzQxNCBzZXF1ZW5jZXIuYzo1MDg0IGJ1aWx0aW4vZnNjay5jOjM1NiBidWlsdGluL3JlYmFzZS5jOjIzNQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3Qgd3JpdGUgJyVzJyIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkJ8OpY3JpcmUgJyVzJyIKQEAgLTUwODAsNyArNTExNCw3IEBACiBtc2dpZCAiaWdub3JpbmcgZGFuZ2xpbmcgc3ltcmVmICVzIgogbXNnc3RyICJzeW1yZWYgcGVuZGFudCAlcyBpZ25vcsOpIgogCi0jOiByZWZzLmM6NjY5IHJlZi1maWx0ZXIuYzoyMDkyCisjOiByZWZzLmM6NjY5IHJlZi1maWx0ZXIuYzoyMDk4CiAjLCBjLWZvcm1hdAogbXNnaWQgImlnbm9yaW5nIGJyb2tlbiByZWYgJXMiCiBtc2dzdHIgInLDqWYgY2Fzc8OpICVzIGlnbm9yw6kiCkBAIC01MTA1LDE0ICs1MTM5LDE0IEBACiBtc2dpZCAidW5leHBlY3RlZCBvYmplY3QgSUQgd2hlbiB3cml0aW5nICclcyciCiBtc2dzdHIgImlkIGQnb2JqZXQgaW5hdHRlbmR1IHBlbmRhbnQgbCfDqWNyaXR1cmUgZGUgJyVzJyIKIAotIzogcmVmcy5jOjgzMyBzZXF1ZW5jZXIuYzo0MDMgc2VxdWVuY2VyLmM6MjcwOSBzZXF1ZW5jZXIuYzoyOTEzCi0jOiBzZXF1ZW5jZXIuYzoyOTI3IHNlcXVlbmNlci5jOjMxODQgc2VxdWVuY2VyLmM6NTAzNyB3cmFwcGVyLmM6NjU2CisjOiByZWZzLmM6ODMzIHNlcXVlbmNlci5jOjQwMyBzZXF1ZW5jZXIuYzoyNjQ3IHNlcXVlbmNlci5jOjI4NTEKKyM6IHNlcXVlbmNlci5jOjI4NjUgc2VxdWVuY2VyLmM6MzEyMiBzZXF1ZW5jZXIuYzo1MDAxIHdyYXBwZXIuYzo2MjAKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHdyaXRlIHRvICclcyciCiBtc2dzdHIgImltcG9zc2libGUgZCfDqWNyaXJlIGRhbnMgJyVzJyIKIAotIzogcmVmcy5jOjg2MCB3cmFwcGVyLmM6MjI1IHdyYXBwZXIuYzozOTUgYnVpbHRpbi9hbS5jOjcxNQotIzogYnVpbHRpbi9yZWJhc2UuYzoxMDAzCisjOiByZWZzLmM6ODYwIHdyYXBwZXIuYzoxODggd3JhcHBlci5jOjM1OCBidWlsdGluL2FtLmM6NzE0CisjOiBidWlsdGluL3JlYmFzZS5jOjEwMDQKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IG9wZW4gJyVzJyBmb3Igd3JpdGluZyIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkJ291dnJpciAnJXMnIGVuIMOpY3JpdHVyZSIKQEAgLTUxNDcsMjEgKzUxODEsMjEgQEAKIG1zZ2lkICJ1cGRhdGVfcmVmIGZhaWxlZCBmb3IgcmVmICclcyc6ICVzIgogbXNnc3RyICLDqWNoZWMgZGUgdXBkYXRlX3JlZiBwb3VyIGxhIHLDqWYgJyVzJ8KgOiAlcyIKIAotIzogcmVmcy5jOjIwMTIKKyM6IHJlZnMuYzoyMDIzCiAjLCBjLWZvcm1hdAogbXNnaWQgIm11bHRpcGxlIHVwZGF0ZXMgZm9yIHJlZiAnJXMnIG5vdCBhbGxvd2VkIgogbXNnc3RyICJtaXNlcyDDoCBqb3VyIG11bHRpcGxlcyBwb3VyIGxhIHLDqWYgJyVzJyBub24gcGVybWlzZXMiCiAKLSM6IHJlZnMuYzoyMDQ0CisjOiByZWZzLmM6MjA1NQogbXNnaWQgInJlZiB1cGRhdGVzIGZvcmJpZGRlbiBpbnNpZGUgcXVhcmFudGluZSBlbnZpcm9ubWVudCIKIG1zZ3N0ciAibWlzZXMgw6Agam91ciBkZXMgcsOpZsOpcmVuY2VzIGludGVyZGl0ZXMgZW4gZW52aXJvbm5lbWVudCBkZSBxdWFyYW50YWluZSIKIAotIzogcmVmcy5jOjIxNDAgcmVmcy5jOjIxNzAKKyM6IHJlZnMuYzoyMTUxIHJlZnMuYzoyMTgxCiAjLCBjLWZvcm1hdAogbXNnaWQgIiclcycgZXhpc3RzOyBjYW5ub3QgY3JlYXRlICclcyciCiBtc2dzdHIgIiclcycgZXhpc3RlwqA7IGltcG9zc2libGUgZGUgY3LDqWVyICclcyciCiAKLSM6IHJlZnMuYzoyMTQ2IHJlZnMuYzoyMTgxCisjOiByZWZzLmM6MjE1NyByZWZzLmM6MjE5MgogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgcHJvY2VzcyAnJXMnIGFuZCAnJXMnIGF0IHRoZSBzYW1lIHRpbWUiCiBtc2dzdHIgImltcG9zc2libGUgZGUgdHJhaXRlciAnJXMnIGV0ICclcycgZW4gbcOqbWUgdGVtcHMiCkBAIC01MTcxLDEzICs1MjA1LDEzIEBACiBtc2dpZCAiY291bGQgbm90IHJlbW92ZSByZWZlcmVuY2UgJXMiCiBtc2dzdHIgImltcG9zc2libGUgZGUgc3VwcHJpbWVyIGxhIHLDqWbDqXJlbmNlICVzIgogCi0jOiByZWZzL2ZpbGVzLWJhY2tlbmQuYzoxMjQ4IHJlZnMvcGFja2VkLWJhY2tlbmQuYzoxNTMyCi0jOiByZWZzL3BhY2tlZC1iYWNrZW5kLmM6MTU0MgorIzogcmVmcy9maWxlcy1iYWNrZW5kLmM6MTI0OCByZWZzL3BhY2tlZC1iYWNrZW5kLmM6MTU0MQorIzogcmVmcy9wYWNrZWQtYmFja2VuZC5jOjE1NTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGRlbGV0ZSByZWZlcmVuY2UgJXM6ICVzIgogbXNnc3RyICJJbXBvc3NpYmxlIGRlIHN1cHByaW1lciBsYSByw6lmw6lyZW5jZSAlc8KgOiAlcyIKIAotIzogcmVmcy9maWxlcy1iYWNrZW5kLmM6MTI1MSByZWZzL3BhY2tlZC1iYWNrZW5kLmM6MTU0NQorIzogcmVmcy9maWxlcy1iYWNrZW5kLmM6MTI1MSByZWZzL3BhY2tlZC1iYWNrZW5kLmM6MTU1NAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgZGVsZXRlIHJlZmVyZW5jZXM6ICVzIgogbXNnc3RyICJpbXBvc3NpYmxlIGRlIHN1cHByaW1lciBsZXMgcsOpZsOpcmVuY2VzwqA6ICVzIgpAQCAtNTE4OCw3ICs1MjIyLDcgQEAKIG1zZ3N0ciAic3DDqWNpZmljYXRldXIgZGUgcsOpZmVyZW5jZSBpbnZhbGlkZcKgOiAnJXMnIgogCiAjIMOgIHByaW9yaSBvbiBwYXJsZSBkJ3VuZSBicmFuY2hlIGljaQotIzogcmVmLWZpbHRlci5jOjQyIHd0LXN0YXR1cy5jOjE5MzQKKyM6IHJlZi1maWx0ZXIuYzo0MiB3dC1zdGF0dXMuYzoxOTM4CiBtc2dpZCAiZ29uZSIKIG1zZ3N0ciAiZGlzcGFydWUiCiAKQEAgLTUyMDcsMjgzICs1MjQxLDI4MyBAQAogbXNnaWQgImFoZWFkICVkLCBiZWhpbmQgJWQiCiBtc2dzdHIgImVuIGF2YW5jZSBkZSAlZCwgZW4gcmV0YXJkIGRlICVkIgogCi0jOiByZWYtZmlsdGVyLmM6MTYyCisjOiByZWYtZmlsdGVyLmM6MTY1CiAjLCBjLWZvcm1hdAogbXNnaWQgImV4cGVjdGVkIGZvcm1hdDogJSUoY29sb3I6PGNvbG9yPikiCiBtc2dzdHIgImZvcm1hdCBhdHRlbmR1wqA6ICUlKGNvbG9yOjxjb3VsZXVyPikiCiAKLSM6IHJlZi1maWx0ZXIuYzoxNjQKKyM6IHJlZi1maWx0ZXIuYzoxNjcKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5yZWNvZ25pemVkIGNvbG9yOiAlJShjb2xvcjolcykiCiBtc2dzdHIgImNvdWxldXIgbm9uIHJlY29ubnVlIDogJSUoY29sb3I6JXMpIgogCi0jOiByZWYtZmlsdGVyLmM6MTg2CisjOiByZWYtZmlsdGVyLmM6MTg5CiAjLCBjLWZvcm1hdAogbXNnaWQgIkludGVnZXIgdmFsdWUgZXhwZWN0ZWQgcmVmbmFtZTpsc3RyaXA9JXMiCiBtc2dzdHIgIlZhbGV1ciBlbnRpw6hyZSBhdHRlbmR1ZSByZWZuYW1lOmxzdHJpcD0lcyIKIAotIzogcmVmLWZpbHRlci5jOjE5MAorIzogcmVmLWZpbHRlci5jOjE5MwogIywgYy1mb3JtYXQKIG1zZ2lkICJJbnRlZ2VyIHZhbHVlIGV4cGVjdGVkIHJlZm5hbWU6cnN0cmlwPSVzIgogbXNnc3RyICJWYWxldXIgZW50acOocmUgYXR0ZW5kdWUgcmVmbmFtZTpyc3RyaXA9JXMiCiAKLSM6IHJlZi1maWx0ZXIuYzoxOTIKKyM6IHJlZi1maWx0ZXIuYzoxOTUKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5yZWNvZ25pemVkICUlKCVzKSBhcmd1bWVudDogJXMiCiBtc2dzdHIgImFyZ3VtZW50ICUlKCVzKSBub24gcmVjb25udcKgOiAlcyIKIAotIzogcmVmLWZpbHRlci5jOjI0NworIzogcmVmLWZpbHRlci5jOjI1MAogIywgYy1mb3JtYXQKIG1zZ2lkICIlJShvYmplY3R0eXBlKSBkb2VzIG5vdCB0YWtlIGFyZ3VtZW50cyIKIG1zZ3N0ciAiJSUob2JqZWN0dHlwZSkgbidhY2NlcHRlIHBhcyBkJ2FyZ3VtZW50IgogCi0jOiByZWYtZmlsdGVyLmM6MjY5CisjOiByZWYtZmlsdGVyLmM6MjcyCiAjLCBjLWZvcm1hdAogbXNnaWQgInVucmVjb2duaXplZCAlJShvYmplY3RzaXplKSBhcmd1bWVudDogJXMiCiBtc2dzdHIgImFyZ3VtZW50ICUlKG9iamVjdHNpemUpIG5vbiByZWNvbm51IDogJXMiCiAKLSM6IHJlZi1maWx0ZXIuYzoyNzcKKyM6IHJlZi1maWx0ZXIuYzoyODAKICMsIGMtZm9ybWF0CiBtc2dpZCAiJSUoZGVsdGFiYXNlKSBkb2VzIG5vdCB0YWtlIGFyZ3VtZW50cyIKIG1zZ3N0ciAiJSUoZGVsdGFiYXNlKSBuJ2FjY2VwdGUgcGFzIGQnYXJndW1lbnQiCiAKLSM6IHJlZi1maWx0ZXIuYzoyODkKKyM6IHJlZi1maWx0ZXIuYzoyOTIKICMsIGMtZm9ybWF0CiBtc2dpZCAiJSUoYm9keSkgZG9lcyBub3QgdGFrZSBhcmd1bWVudHMiCiBtc2dzdHIgIiUlKGJvZHkpIG4nYWNjZXB0ZSBwYXMgZCdhcmd1bWVudCIKIAotIzogcmVmLWZpbHRlci5jOjI5OAorIzogcmVmLWZpbHRlci5jOjMwMQogIywgYy1mb3JtYXQKIG1zZ2lkICIlJShzdWJqZWN0KSBkb2VzIG5vdCB0YWtlIGFyZ3VtZW50cyIKIG1zZ3N0ciAiJSUoc3ViamVjdCkgbidhY2NlcHRlIHBhcyBkJ2FyZ3VtZW50IgogCi0jOiByZWYtZmlsdGVyLmM6MzIwCisjOiByZWYtZmlsdGVyLmM6MzIzCiAjLCBjLWZvcm1hdAogbXNnaWQgInVua25vd24gJSUodHJhaWxlcnMpIGFyZ3VtZW50OiAlcyIKIG1zZ3N0ciAiYXJndW1lbnQgJSUodHJhaWxlcnMpIGluY29ubnXCoDogJXMiCiAKLSM6IHJlZi1maWx0ZXIuYzozNDkKKyM6IHJlZi1maWx0ZXIuYzozNTIKICMsIGMtZm9ybWF0CiBtc2dpZCAicG9zaXRpdmUgdmFsdWUgZXhwZWN0ZWQgY29udGVudHM6bGluZXM9JXMiCiBtc2dzdHIgInZhbGV1ciBwb3NpdGl2ZSBhdHRlbmR1ZSBjb250ZW50czpsaW5lcz0lcyIKIAotIzogcmVmLWZpbHRlci5jOjM1MQorIzogcmVmLWZpbHRlci5jOjM1NAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bnJlY29nbml6ZWQgJSUoY29udGVudHMpIGFyZ3VtZW50OiAlcyIKIG1zZ3N0ciAiYXJndW1lbnQgJSUoY29udGVudHMpIG5vbiByZWNvbm51IDogJXMiCiAKLSM6IHJlZi1maWx0ZXIuYzozNjYKKyM6IHJlZi1maWx0ZXIuYzozNjkKICMsIGMtZm9ybWF0CiBtc2dpZCAicG9zaXRpdmUgdmFsdWUgZXhwZWN0ZWQgb2JqZWN0bmFtZTpzaG9ydD0lcyIKIG1zZ3N0ciAidmFsZXVyIHBvc2l0aXZlIGF0dGVuZHVlIG9iamVjdG5hbWU6c2hvcnQ9JXMiCiAKLSM6IHJlZi1maWx0ZXIuYzozNzAKKyM6IHJlZi1maWx0ZXIuYzozNzMKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5yZWNvZ25pemVkICUlKG9iamVjdG5hbWUpIGFyZ3VtZW50OiAlcyIKIG1zZ3N0ciAiYXJndW1lbnQgJSUob2JqZWN0bmFtZSkgbm9uIHJlY29ubnUgOiAlcyIKIAotIzogcmVmLWZpbHRlci5jOjQwMAorIzogcmVmLWZpbHRlci5jOjQwMwogIywgYy1mb3JtYXQKIG1zZ2lkICJleHBlY3RlZCBmb3JtYXQ6ICUlKGFsaWduOjx3aWR0aD4sPHBvc2l0aW9uPikiCiBtc2dzdHIgImZvcm1hdCBhdHRlbmR1wqA6ICUlKGFsaWduOjxsYXJnZXVyPiw8cG9zaXRpb24+KSIKIAotIzogcmVmLWZpbHRlci5jOjQxMgorIzogcmVmLWZpbHRlci5jOjQxNQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bnJlY29nbml6ZWQgcG9zaXRpb246JXMiCiBtc2dzdHIgInBvc2l0aW9uIG5vbiByZWNvbm51ZcKgOiAlcyIKIAotIzogcmVmLWZpbHRlci5jOjQxOQorIzogcmVmLWZpbHRlci5jOjQyMgogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bnJlY29nbml6ZWQgd2lkdGg6JXMiCiBtc2dzdHIgImxhcmdldXIgbm9uIHJlY29ubnVlwqA6ICVzIgogCi0jOiByZWYtZmlsdGVyLmM6NDI4CisjOiByZWYtZmlsdGVyLmM6NDMxCiAjLCBjLWZvcm1hdAogbXNnaWQgInVucmVjb2duaXplZCAlJShhbGlnbikgYXJndW1lbnQ6ICVzIgogbXNnc3RyICJhcmd1bWVudCAlJShhbGlnbikgbm9uIHJlY29ubnUgOiAlcyIKIAotIzogcmVmLWZpbHRlci5jOjQzNgorIzogcmVmLWZpbHRlci5jOjQzOQogIywgYy1mb3JtYXQKIG1zZ2lkICJwb3NpdGl2ZSB3aWR0aCBleHBlY3RlZCB3aXRoIHRoZSAlJShhbGlnbikgYXRvbSIKIG1zZ3N0ciAidmFsZXVyIHBvc2l0aXZlIGF0dGVuZHVlIGF2ZWMgbCdhdG9tZSAlJShhbGlnbikiCiAKLSM6IHJlZi1maWx0ZXIuYzo0NTQKKyM6IHJlZi1maWx0ZXIuYzo0NTcKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5yZWNvZ25pemVkICUlKGlmKSBhcmd1bWVudDogJXMiCiBtc2dzdHIgImFyZ3VtZW50ICUlKGlmKSBub24gcmVjb25udcKgOiAlcyIKIAotIzogcmVmLWZpbHRlci5jOjU1NgorIzogcmVmLWZpbHRlci5jOjU1OQogIywgYy1mb3JtYXQKIG1zZ2lkICJtYWxmb3JtZWQgZmllbGQgbmFtZTogJS4qcyIKIG1zZ3N0ciAibm9tIGRlIGNoYW1wIG1hbGZvcm3DqSAlLipzIgogCi0jOiByZWYtZmlsdGVyLmM6NTgzCisjOiByZWYtZmlsdGVyLmM6NTg2CiAjLCBjLWZvcm1hdAogbXNnaWQgInVua25vd24gZmllbGQgbmFtZTogJS4qcyIKIG1zZ3N0ciAibm9tIGRlIGNoYW1wIGluY29ubnUgOiAlLipzIgogCi0jOiByZWYtZmlsdGVyLmM6NTg3CisjOiByZWYtZmlsdGVyLmM6NTkwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJub3QgYSBnaXQgcmVwb3NpdG9yeSwgYnV0IHRoZSBmaWVsZCAnJS4qcycgcmVxdWlyZXMgYWNjZXNzIHRvIG9iamVjdCBkYXRhIgogbXNnc3RyICIiCiAicGFzIHVuIGTDqXDDtHQgZ2l0LCBtYWlzIGxlIGNoYW1wICclLipzJyBuw6ljZXNzaXRlIGwnYWNjw6hzIGF1eCBkb25uw6llcyBkJ29iamV0IgogCi0jOiByZWYtZmlsdGVyLmM6NzExCisjOiByZWYtZmlsdGVyLmM6NzE0CiAjLCBjLWZvcm1hdAogbXNnaWQgImZvcm1hdDogJSUoaWYpIGF0b20gdXNlZCB3aXRob3V0IGEgJSUodGhlbikgYXRvbSIKIG1zZ3N0ciAiZm9ybWF0wqA6IGF0b21lICUlKGlmKSB1dGlsaXPDqSBzYW5zIHVuIGF0b21lICUlKHRoZW4pIgogCi0jOiByZWYtZmlsdGVyLmM6Nzc0CisjOiByZWYtZmlsdGVyLmM6Nzc3CiAjLCBjLWZvcm1hdAogbXNnaWQgImZvcm1hdDogJSUodGhlbikgYXRvbSB1c2VkIHdpdGhvdXQgYW4gJSUoaWYpIGF0b20iCiBtc2dzdHIgImZvcm1hdMKgOiBhdG9tZSAlJSh0aGVuKSB1dGlsaXPDqSBzYW5zIHVuIGF0b21lICUlKGlmKSIKIAotIzogcmVmLWZpbHRlci5jOjc3NgorIzogcmVmLWZpbHRlci5jOjc3OQogIywgYy1mb3JtYXQKIG1zZ2lkICJmb3JtYXQ6ICUlKHRoZW4pIGF0b20gdXNlZCBtb3JlIHRoYW4gb25jZSIKIG1zZ3N0ciAiZm9ybWF0wqA6IGF0b21lICUlKHRoZW4pIHV0aWxpc8OpIHBsdXMgZCd1bmUgZm9pcyIKIAotIzogcmVmLWZpbHRlci5jOjc3OAorIzogcmVmLWZpbHRlci5jOjc4MQogIywgYy1mb3JtYXQKIG1zZ2lkICJmb3JtYXQ6ICUlKHRoZW4pIGF0b20gdXNlZCBhZnRlciAlJShlbHNlKSIKIG1zZ3N0ciAiZm9ybWF0OiBhdG9tZSAlJSh0aGVuKSB1dGlsaXPDqSBhcHLDqHMgJSUoZWxzZSkiCiAKLSM6IHJlZi1maWx0ZXIuYzo4MDYKKyM6IHJlZi1maWx0ZXIuYzo4MDkKICMsIGMtZm9ybWF0CiBtc2dpZCAiZm9ybWF0OiAlJShlbHNlKSBhdG9tIHVzZWQgd2l0aG91dCBhbiAlJShpZikgYXRvbSIKIG1zZ3N0ciAiZm9ybWF0wqA6IGF0b21lICUlKGVsc2UpIHV0aWxpc8OpIHNhbnMgdW4gYXRvbWUgJSUoaWYpIgogCi0jOiByZWYtZmlsdGVyLmM6ODA4CisjOiByZWYtZmlsdGVyLmM6ODExCiAjLCBjLWZvcm1hdAogbXNnaWQgImZvcm1hdDogJSUoZWxzZSkgYXRvbSB1c2VkIHdpdGhvdXQgYSAlJSh0aGVuKSBhdG9tIgogbXNnc3RyICJmb3JtYXTCoDogYXRvbWUgJSUoZWxzZSkgdXRpbGlzw6kgc2FucyB1biBhdG9tZSAlJSh0aGVuKSIKIAotIzogcmVmLWZpbHRlci5jOjgxMAorIzogcmVmLWZpbHRlci5jOjgxMwogIywgYy1mb3JtYXQKIG1zZ2lkICJmb3JtYXQ6ICUlKGVsc2UpIGF0b20gdXNlZCBtb3JlIHRoYW4gb25jZSIKIG1zZ3N0ciAiZm9ybWF0wqA6IGF0b21lICUlKGVsc2UpIHV0aWxpc8OpIHBsdXMgZCd1bmUgZm9pcyIKIAotIzogcmVmLWZpbHRlci5jOjgyNQorIzogcmVmLWZpbHRlci5jOjgyOAogIywgYy1mb3JtYXQKIG1zZ2lkICJmb3JtYXQ6ICUlKGVuZCkgYXRvbSB1c2VkIHdpdGhvdXQgY29ycmVzcG9uZGluZyBhdG9tIgogbXNnc3RyICJmb3JtYXTCoDogYXRvbWUgJSUoZW5kKSB1dGlsaXPDqSBzYW5zIGF0b21lIGNvcnJlc3BvbmRhbnQiCiAKLSM6IHJlZi1maWx0ZXIuYzo4ODIKKyM6IHJlZi1maWx0ZXIuYzo4ODUKICMsIGMtZm9ybWF0CiBtc2dpZCAibWFsZm9ybWVkIGZvcm1hdCBzdHJpbmcgJXMiCiBtc2dzdHIgIkNoYcOubmUgZGUgZm9ybWF0YWdlIG1hbCBmb3Jtw6llICVzIgogCi0jOiByZWYtZmlsdGVyLmM6MTQ4NQorIzogcmVmLWZpbHRlci5jOjE0ODgKICMsIGMtZm9ybWF0CiBtc2dpZCAibm8gYnJhbmNoLCByZWJhc2luZyAlcyIKIG1zZ3N0ciAiYXVjdW5lIGJyYW5jaGUsIHJlYmFzYWdlIGRlICVzIgogCi0jOiByZWYtZmlsdGVyLmM6MTQ4OAorIzogcmVmLWZpbHRlci5jOjE0OTEKICMsIGMtZm9ybWF0CiBtc2dpZCAibm8gYnJhbmNoLCByZWJhc2luZyBkZXRhY2hlZCBIRUFEICVzIgogbXNnc3RyICJhdWN1bmUgYnJhbmNoZSwgcmViYXNhZ2UgZGUgbGEgSEVBRCBkw6l0YWNow6llICVzIgogCi0jOiByZWYtZmlsdGVyLmM6MTQ5MQorIzogcmVmLWZpbHRlci5jOjE0OTQKICMsIGMtZm9ybWF0CiBtc2dpZCAibm8gYnJhbmNoLCBiaXNlY3Qgc3RhcnRlZCBvbiAlcyIKIG1zZ3N0ciAiYXVjdW5lIGJyYW5jaGUsIGJpc2VjdCBhIGTDqW1hcnLDqSBzdXIgJXMiCiAKLSM6IHJlZi1maWx0ZXIuYzoxNTAxCisjOiByZWYtZmlsdGVyLmM6MTUwNAogbXNnaWQgIm5vIGJyYW5jaCIKIG1zZ3N0ciAiYXVjdW5lIGJyYW5jaGUiCiAKLSM6IHJlZi1maWx0ZXIuYzoxNTM3IHJlZi1maWx0ZXIuYzoxNzQzCisjOiByZWYtZmlsdGVyLmM6MTU0MCByZWYtZmlsdGVyLmM6MTc0OQogIywgYy1mb3JtYXQKIG1zZ2lkICJtaXNzaW5nIG9iamVjdCAlcyBmb3IgJXMiCiBtc2dzdHIgIm9iamV0IG1hbnF1YW50ICVzIHBvdXIgJXMiCiAKLSM6IHJlZi1maWx0ZXIuYzoxNTQ3CisjOiByZWYtZmlsdGVyLmM6MTU1MAogIywgYy1mb3JtYXQKIG1zZ2lkICJwYXJzZV9vYmplY3RfYnVmZmVyIGZhaWxlZCBvbiAlcyBmb3IgJXMiCiBtc2dzdHIgIsOpY2hlYyBkZSBwYXJzZV9vYmplY3RfYnVmZmVyIHN1ciAlcyBwb3VyICVzIgogCi0jOiByZWYtZmlsdGVyLmM6MTk5OAorIzogcmVmLWZpbHRlci5jOjIwMDQKICMsIGMtZm9ybWF0CiBtc2dpZCAibWFsZm9ybWVkIG9iamVjdCBhdCAnJXMnIgogbXNnc3RyICJvYmpldCBtYWxmb3Jtw6kgw6AgJyVzJyIKIAotIzogcmVmLWZpbHRlci5jOjIwODcKKyM6IHJlZi1maWx0ZXIuYzoyMDkzCiAjLCBjLWZvcm1hdAogbXNnaWQgImlnbm9yaW5nIHJlZiB3aXRoIGJyb2tlbiBuYW1lICVzIgogbXNnc3RyICJyw6lmIGF2ZWMgdW4gbm9tIGNhc3PDqSAlcyBpZ25vcsOpIgogCi0jOiByZWYtZmlsdGVyLmM6MjM4MgorIzogcmVmLWZpbHRlci5jOjIzODkKICMsIGMtZm9ybWF0CiBtc2dpZCAiZm9ybWF0OiAlJShlbmQpIGF0b20gbWlzc2luZyIKIG1zZ3N0ciAiZm9ybWF0OiBhdG9tZSAlJShlbmQpIG1hbnF1YW50IgogCi0jOiByZWYtZmlsdGVyLmM6MjQ4MgorIzogcmVmLWZpbHRlci5jOjI0ODkKICMsIGMtZm9ybWF0CiBtc2dpZCAib3B0aW9uIGAlcycgaXMgaW5jb21wYXRpYmxlIHdpdGggLS1tZXJnZWQiCiBtc2dzdHIgImwnb3B0aW9uIMKrwqAlc8KgwrsgZXN0IGluY29tcGF0aWJsZSBhdmVjIC0tbWVyZ2VkIgogCi0jOiByZWYtZmlsdGVyLmM6MjQ4NQorIzogcmVmLWZpbHRlci5jOjI0OTIKICMsIGMtZm9ybWF0CiBtc2dpZCAib3B0aW9uIGAlcycgaXMgaW5jb21wYXRpYmxlIHdpdGggLS1uby1tZXJnZWQiCiBtc2dzdHIgImwnb3B0aW9uIMKrwqAlc8KgwrsgZXN0IGluY29tcGF0aWJsZSBhdmVjIC0tbm8tbWVyZ2VkIgogCi0jOiByZWYtZmlsdGVyLmM6MjQ5NQorIzogcmVmLWZpbHRlci5jOjI1MDIKICMsIGMtZm9ybWF0CiBtc2dpZCAibWFsZm9ybWVkIG9iamVjdCBuYW1lICVzIgogbXNnc3RyICJub20gZCdvYmpldCBtYWxmb3Jtw6kgJXMiCiAKLSM6IHJlZi1maWx0ZXIuYzoyNTAwCisjOiByZWYtZmlsdGVyLmM6MjUwNwogIywgYy1mb3JtYXQKIG1zZ2lkICJvcHRpb24gYCVzJyBtdXN0IHBvaW50IHRvIGEgY29tbWl0IgogbXNnc3RyICJsJ29wdGlvbiAnJXMnIGRvaXQgcG9pbnRlciBzdXIgdW4gY29tbWl0IgogCi0jOiByZW1vdGUuYzozNjMKKyM6IHJlbW90ZS5jOjM2NgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb25maWcgcmVtb3RlIHNob3J0aGFuZCBjYW5ub3QgYmVnaW4gd2l0aCAnLyc6ICVzIgogbXNnc3RyICIiCiAidW4gcmFjY291cmNpIGRlIGNvbmZpZ3VyYXRpb24gZGUgZGlzdGFudCBuZSBwZXV0IHBhcyBjb21tZW5jZXIgcGFyICcvJ8KgOiAlcyIKIAotIzogcmVtb3RlLmM6NDEwCisjOiByZW1vdGUuYzo0MTMKIG1zZ2lkICJtb3JlIHRoYW4gb25lIHJlY2VpdmVwYWNrIGdpdmVuLCB1c2luZyB0aGUgZmlyc3QiCiBtc2dzdHIgInBsdXMgZCd1biByZWNlaXZlcGFjayBmb3VybmlzLCB1dGlsaXNhdGlvbiBkdSBwcmVtaWVyIgogCi0jOiByZW1vdGUuYzo0MTgKKyM6IHJlbW90ZS5jOjQyMQogbXNnaWQgIm1vcmUgdGhhbiBvbmUgdXBsb2FkcGFjayBnaXZlbiwgdXNpbmcgdGhlIGZpcnN0IgogbXNnc3RyICJwbHVzIGQndW4gdXBsb2FkcGFjayBmb3VybmlzLCB1dGlsaXNhdGlvbiBkdSBwcmVtaWVyIgogCi0jOiByZW1vdGUuYzo2MDgKKyM6IHJlbW90ZS5jOjYxMQogIywgYy1mb3JtYXQKIG1zZ2lkICJDYW5ub3QgZmV0Y2ggYm90aCAlcyBhbmQgJXMgdG8gJXMiCiBtc2dzdHIgIkltcG9zc2libGUgZGUgcsOpY3Vww6lyZXIgw6AgbGEgZm9pcyAlcyBldCAlcyBwb3VyICVzIgogCi0jOiByZW1vdGUuYzo2MTIKKyM6IHJlbW90ZS5jOjYxNQogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyB1c3VhbGx5IHRyYWNrcyAlcywgbm90ICVzIgogbXNnc3RyICIlcyBzdWl0IGhhYml0dWVsbGVtZW50ICVzLCBwYXMgJXMiCiAKLSM6IHJlbW90ZS5jOjYxNgorIzogcmVtb3RlLmM6NjE5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIHRyYWNrcyBib3RoICVzIGFuZCAlcyIKIG1zZ3N0ciAiJXMgc3VpdCDDoCBsYSBmb2lzICVzIGV0ICVzIgogCi0jOiByZW1vdGUuYzo2ODQKKyM6IHJlbW90ZS5jOjY4NwogIywgYy1mb3JtYXQKIG1zZ2lkICJrZXkgJyVzJyBvZiBwYXR0ZXJuIGhhZCBubyAnKiciCiBtc2dzdHIgImxhIGNsw6kgJyVzJyBkdSBtb2TDqGxlIG4nYSBwYXMgZGUgJyonIgogCi0jOiByZW1vdGUuYzo2OTQKKyM6IHJlbW90ZS5jOjY5NwogIywgYy1mb3JtYXQKIG1zZ2lkICJ2YWx1ZSAnJXMnIG9mIHBhdHRlcm4gaGFzIG5vICcqJyIKIG1zZ3N0ciAibGEgdmFsZXVyICclcycgZHUgbW9kw6hsZSBuJ2EgcGFzIGRlICcqJyIKIAotIzogcmVtb3RlLmM6MTAwMAorIzogcmVtb3RlLmM6MTAwMwogIywgYy1mb3JtYXQKIG1zZ2lkICJzcmMgcmVmc3BlYyAlcyBkb2VzIG5vdCBtYXRjaCBhbnkiCiBtc2dzdHIgIiIKICJsZSBzcMOpY2lmaWNhdGV1ciBkZSByw6lmw6lyZW5jZSBzb3VyY2UgJXMgbmUgY29ycmVzcG9uZCDDoCBhdWN1bmUgcsOpZsOpcmVuY2UiCiAKLSM6IHJlbW90ZS5jOjEwMDUKKyM6IHJlbW90ZS5jOjEwMDgKICMsIGMtZm9ybWF0CiBtc2dpZCAic3JjIHJlZnNwZWMgJXMgbWF0Y2hlcyBtb3JlIHRoYW4gb25lIgogbXNnc3RyICIiCkBAIC01NDkzLDcgKzU1MjcsNyBAQAogIy4gPHJlbW90ZT4gPHNyYz46PGRzdD4iIHB1c2gsIGFuZCAiYmVpbmcgcHVzaGVkICgnJXMnKSIgaXMKICMuIHRoZSA8c3JjPi4KICMuCi0jOiByZW1vdGUuYzoxMDIwCisjOiByZW1vdGUuYzoxMDIzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgZGVzdGluYXRpb24geW91IHByb3ZpZGVkIGlzIG5vdCBhIGZ1bGwgcmVmbmFtZSAoaS5lLixcbiIKQEAgLTU1MTcsNyArNTU1MSw3IEBACiAiQXVjdW5lIG4nYSBmb25jdGlvbm7DqSwgZG9uYyBhYmFuZG9uLiBWZXVpbGxleiBzcMOpY2lmaWVyIHVuZSByw6lmw6lyZW5jZSAiCiAidG90YWxlbWVudCBxdWFsaWZpw6llLiIKIAotIzogcmVtb3RlLmM6MTA0MAorIzogcmVtb3RlLmM6MTA0MwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiVGhlIDxzcmM+IHBhcnQgb2YgdGhlIHJlZnNwZWMgaXMgYSBjb21taXQgb2JqZWN0LlxuIgpAQCAtNTUyOCw3ICs1NTYyLDcgQEAKICJTb3VoYWl0aWV6LXZvdXMgY3LDqWVyIHVuZSBub3V2ZWxsZSBicmFuY2hlIGVuIHBvdXNzYW50IHN1clxuIgogIiclczpyZWZzL2hlYWRzLyVzJ8KgPyIKIAotIzogcmVtb3RlLmM6MTA0NQorIzogcmVtb3RlLmM6MTA0OAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiVGhlIDxzcmM+IHBhcnQgb2YgdGhlIHJlZnNwZWMgaXMgYSB0YWcgb2JqZWN0LlxuIgpAQCAtNTUzOSw3ICs1NTczLDcgQEAKICJTb3VoYWl0aWV6LXZvdXMgY3LDqWVyIHVuZSBub3V2ZWxsZSDDqXRpcXVldHRlIGVuIHBvdXNzYW50IHN1clxuIgogIiclczpyZWZzL3RhZ3MvJXMnwqA/IgogCi0jOiByZW1vdGUuYzoxMDUwCisjOiByZW1vdGUuYzoxMDUzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgPHNyYz4gcGFydCBvZiB0aGUgcmVmc3BlYyBpcyBhIHRyZWUgb2JqZWN0LlxuIgpAQCAtNTU1MCw3ICs1NTg0LDcgQEAKICJTb3VoYWl0aWV6LXZvdXMgY3LDqWVyIHVuIG5vdXZlbCBhcmJyZSBlbiBwb3Vzc2FudCBzdXJcbiIKICInJXM6cmVmcy90YWdzLyVzJ8KgPyIKIAotIzogcmVtb3RlLmM6MTA1NQorIzogcmVtb3RlLmM6MTA1OAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiVGhlIDxzcmM+IHBhcnQgb2YgdGhlIHJlZnNwZWMgaXMgYSBibG9iIG9iamVjdC5cbiIKQEAgLTU1NjEsMTE5ICs1NTk1LDExOSBAQAogIlNvdWhhaXRpZXotdm91cyBjcsOpZXIgdW4gbm91dmVhdSBibG9iIGVuIHBvdXNzYW50IHN1clxuIgogIiclczpyZWZzL3RhZ3MvJXMnwqA/IgogCi0jOiByZW1vdGUuYzoxMDkxCisjOiByZW1vdGUuYzoxMDk0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIGNhbm5vdCBiZSByZXNvbHZlZCB0byBicmFuY2giCiBtc2dzdHIgIiclcycgbmUgcGV1dCBwYXMgw6p0cmUgcsOpc29sdWUgY29tbWUgdW5lIGJyYW5jaGUiCiAKLSM6IHJlbW90ZS5jOjExMDIKKyM6IHJlbW90ZS5jOjExMDUKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGRlbGV0ZSAnJXMnOiByZW1vdGUgcmVmIGRvZXMgbm90IGV4aXN0IgogbXNnc3RyICJzdXBwcmVzc2lvbiBkICclcycgaW1wb3NzaWJsZcKgOiBsYSByw6lmw6lyZW5jZSBkaXN0YW50ZSBuJ2V4aXN0ZSBwYXMiCiAKLSM6IHJlbW90ZS5jOjExMTQKKyM6IHJlbW90ZS5jOjExMTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiZHN0IHJlZnNwZWMgJXMgbWF0Y2hlcyBtb3JlIHRoYW4gb25lIgogbXNnc3RyICIiCiAibGUgc3DDqWNpZmljYXRldXIgZGUgcsOpZsOpcmVuY2UgZHN0ICVzIGNvcnJlc3BvbmQgw6AgcGx1cyBkJ3VuIHNww6ljaWZpY2F0ZXVyIGRlICIKICJyw6lmw6lyZW5jZXMiCiAKLSM6IHJlbW90ZS5jOjExMjEKKyM6IHJlbW90ZS5jOjExMjQKICMsIGMtZm9ybWF0CiBtc2dpZCAiZHN0IHJlZiAlcyByZWNlaXZlcyBmcm9tIG1vcmUgdGhhbiBvbmUgc3JjIgogbXNnc3RyICJsZSBzcMOpY2lmaWNhdGV1ciBkZSByw6lmw6lyZW5jZSBkc3QgJXMgcmXDp29pdCBkZXB1aXMgcGx1cyBkJ3VuZSBzb3VyY2UiCiAKLSM6IHJlbW90ZS5jOjE2MjQgcmVtb3RlLmM6MTcyNQorIzogcmVtb3RlLmM6MTYyNyByZW1vdGUuYzoxNzI4CiBtc2dpZCAiSEVBRCBkb2VzIG5vdCBwb2ludCB0byBhIGJyYW5jaCIKIG1zZ3N0ciAiSEVBRCBuZSBwb2ludGUgcGFzIHN1ciB1bmUgYnJhbmNoZSIKIAotIzogcmVtb3RlLmM6MTYzMworIzogcmVtb3RlLmM6MTYzNgogIywgYy1mb3JtYXQKIG1zZ2lkICJubyBzdWNoIGJyYW5jaDogJyVzJyIKIG1zZ3N0ciAicGFzIGRlIGJyYW5jaGUgJyVzJyIKIAotIzogcmVtb3RlLmM6MTYzNgorIzogcmVtb3RlLmM6MTYzOQogIywgYy1mb3JtYXQKIG1zZ2lkICJubyB1cHN0cmVhbSBjb25maWd1cmVkIGZvciBicmFuY2ggJyVzJyIKIG1zZ3N0ciAiYXVjdW5lIGJyYW5jaGUgYW1vbnQgY29uZmlndXLDqWUgcG91ciBsYSBicmFuY2hlICclcyciCiAKLSM6IHJlbW90ZS5jOjE2NDIKKyM6IHJlbW90ZS5jOjE2NDUKICMsIGMtZm9ybWF0CiBtc2dpZCAidXBzdHJlYW0gYnJhbmNoICclcycgbm90IHN0b3JlZCBhcyBhIHJlbW90ZS10cmFja2luZyBicmFuY2giCiBtc2dzdHIgImxhIGJyYW5jaGUgYW1vbnQgJyVzJyBuJ2VzdCBwYXMgc3RvY2vDqWUgY29tbWUgYnJhbmNoZSBkZSBzdWl2aSIKIAotIzogcmVtb3RlLmM6MTY1NworIzogcmVtb3RlLmM6MTY2MAogIywgYy1mb3JtYXQKIG1zZ2lkICJwdXNoIGRlc3RpbmF0aW9uICclcycgb24gcmVtb3RlICclcycgaGFzIG5vIGxvY2FsIHRyYWNraW5nIGJyYW5jaCIKIG1zZ3N0ciAiIgogImxhIGRlc3RpbmF0aW9uIGRlIHBvdXNzw6llICclcycgc3VyIGxlIHNlcnZldXIgZGlzdGFudCAnJXMnIG4nYSBwYXMgZGUgIgogImJyYW5jaGUgbG9jYWxlIGRlIHN1aXZpIgogCi0jOiByZW1vdGUuYzoxNjY5CisjOiByZW1vdGUuYzoxNjcyCiAjLCBjLWZvcm1hdAogbXNnaWQgImJyYW5jaCAnJXMnIGhhcyBubyByZW1vdGUgZm9yIHB1c2hpbmciCiBtc2dzdHIgImxhIGJyYW5jaGUgJyVzJyBuJ2EgYXVjdW5lIGJyYW5jaGUgZGlzdGFudGUgZGUgcG91c3PDqWUiCiAKLSM6IHJlbW90ZS5jOjE2NzkKKyM6IHJlbW90ZS5jOjE2ODIKICMsIGMtZm9ybWF0CiBtc2dpZCAicHVzaCByZWZzcGVjcyBmb3IgJyVzJyBkbyBub3QgaW5jbHVkZSAnJXMnIgogbXNnc3RyICJsZXMgcsOpZsOpcmVuY2VzIGRlIHNwZWMgcG91ciAnJXMnIG4naW5jbHVlbnQgcGFzICclcyciCiAKLSM6IHJlbW90ZS5jOjE2OTIKKyM6IHJlbW90ZS5jOjE2OTUKIG1zZ2lkICJwdXNoIGhhcyBubyBkZXN0aW5hdGlvbiAocHVzaC5kZWZhdWx0IGlzICdub3RoaW5nJykiCiBtc2dzdHIgImxhIHBvdXNzw6llIG4nYSBwYXMgZGUgZGVzdGluYXRpb24gKHB1c2guZGVmYXVsdCB2YXV0ICdub3RoaW5nJykiCiAKLSM6IHJlbW90ZS5jOjE3MTQKKyM6IHJlbW90ZS5jOjE3MTcKIG1zZ2lkICJjYW5ub3QgcmVzb2x2ZSAnc2ltcGxlJyBwdXNoIHRvIGEgc2luZ2xlIGRlc3RpbmF0aW9uIgogbXNnc3RyICIiCiAiaW1wb3NzaWJsZSBkZSByw6lzb3VkcmUgdW5lIHBvdXNzw6llICdzaW1wbGUnIHBvdXIgdW5lIGRlc3RpbmF0aW9uIHVuaXF1ZSIKIAotIzogcmVtb3RlLmM6MTg0MAorIzogcmVtb3RlLmM6MTg0MwogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZG4ndCBmaW5kIHJlbW90ZSByZWYgJXMiCiBtc2dzdHIgImltcG9zc2libGUgZGUgdHJvdXZlciBsYSByw6lmw6lyZW5jZSBkaXN0YW50ZSAlcyIKIAotIzogcmVtb3RlLmM6MTg1MworIzogcmVtb3RlLmM6MTg1NgogIywgYy1mb3JtYXQKIG1zZ2lkICIqIElnbm9yaW5nIGZ1bm55IHJlZiAnJXMnIGxvY2FsbHkiCiBtc2dzdHIgIiogUsOpZsOpcmVuY2UgYml6YXJyZSAnJXMnIGlnbm9yw6llIGxvY2FsZW1lbnQiCiAKLSM6IHJlbW90ZS5jOjIwMTYKKyM6IHJlbW90ZS5jOjIwMTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiWW91ciBicmFuY2ggaXMgYmFzZWQgb24gJyVzJywgYnV0IHRoZSB1cHN0cmVhbSBpcyBnb25lLlxuIgogbXNnc3RyICJWb3RyZSBicmFuY2hlIGVzdCBiYXPDqWUgc3VyICclcycsIG1haXMgbGEgYnJhbmNoZSBhbW9udCBhIGRpc3BhcnUuXG4iCiAKLSM6IHJlbW90ZS5jOjIwMjAKKyM6IHJlbW90ZS5jOjIwMjMKIG1zZ2lkICIgICh1c2UgXCJnaXQgYnJhbmNoIC0tdW5zZXQtdXBzdHJlYW1cIiB0byBmaXh1cClcbiIKIG1zZ3N0ciAiICAodXRpbGlzZXogXCJnaXQgYnJhbmNoIC0tdW5zZXQtdXBzdHJlYW1cIiBwb3VyIGNvcnJpZ2VyKVxuIgogCi0jOiByZW1vdGUuYzoyMDIzCisjOiByZW1vdGUuYzoyMDI2CiAjLCBjLWZvcm1hdAogbXNnaWQgIllvdXIgYnJhbmNoIGlzIHVwIHRvIGRhdGUgd2l0aCAnJXMnLlxuIgogbXNnc3RyICJWb3RyZSBicmFuY2hlIGVzdCDDoCBqb3VyIGF2ZWMgJyVzJy5cbiIKIAotIzogcmVtb3RlLmM6MjAyNworIzogcmVtb3RlLmM6MjAzMAogIywgYy1mb3JtYXQKIG1zZ2lkICJZb3VyIGJyYW5jaCBhbmQgJyVzJyByZWZlciB0byBkaWZmZXJlbnQgY29tbWl0cy5cbiIKIG1zZ3N0ciAiVm90cmUgYnJhbmNoZSBldCAnJXMnIGZvbnQgcsOpZsOpcmVuY2Ugw6AgZGVzIGNvbW1pdHMgZGlmZsOpcmVudHMuXG4iCiAKLSM6IHJlbW90ZS5jOjIwMzAKKyM6IHJlbW90ZS5jOjIwMzMKICMsIGMtZm9ybWF0CiBtc2dpZCAiICAodXNlIFwiJXNcIiBmb3IgZGV0YWlscylcbiIKIG1zZ3N0ciAiICAodXRpbGlzZXogXCIlc1wiIHBvdXIgcGx1cyBkZSBkw6l0YWlscylcbiIKIAotIzogcmVtb3RlLmM6MjAzNAorIzogcmVtb3RlLmM6MjAzNwogIywgYy1mb3JtYXQKIG1zZ2lkICJZb3VyIGJyYW5jaCBpcyBhaGVhZCBvZiAnJXMnIGJ5ICVkIGNvbW1pdC5cbiIKIG1zZ2lkX3BsdXJhbCAiWW91ciBicmFuY2ggaXMgYWhlYWQgb2YgJyVzJyBieSAlZCBjb21taXRzLlxuIgogbXNnc3RyWzBdICJWb3RyZSBicmFuY2hlIGVzdCBlbiBhdmFuY2Ugc3VyICclcycgZGUgJWQgY29tbWl0LlxuIgogbXNnc3RyWzFdICJWb3RyZSBicmFuY2hlIGVzdCBlbiBhdmFuY2Ugc3VyICclcycgZGUgJWQgY29tbWl0cy5cbiIKIAotIzogcmVtb3RlLmM6MjA0MAorIzogcmVtb3RlLmM6MjA0MwogbXNnaWQgIiAgKHVzZSBcImdpdCBwdXNoXCIgdG8gcHVibGlzaCB5b3VyIGxvY2FsIGNvbW1pdHMpXG4iCiBtc2dzdHIgIiAgKHV0aWxpc2V6IFwiZ2l0IHB1c2hcIiBwb3VyIHB1YmxpZXIgdm9zIGNvbW1pdHMgbG9jYXV4KVxuIgogCi0jOiByZW1vdGUuYzoyMDQzCisjOiByZW1vdGUuYzoyMDQ2CiAjLCBjLWZvcm1hdAogbXNnaWQgIllvdXIgYnJhbmNoIGlzIGJlaGluZCAnJXMnIGJ5ICVkIGNvbW1pdCwgYW5kIGNhbiBiZSBmYXN0LWZvcndhcmRlZC5cbiIKIG1zZ2lkX3BsdXJhbCAiIgpAQCAtNTY4NSwxMSArNTcxOSwxMSBAQAogIlZvdHJlIGJyYW5jaGUgZXN0IGVuIHJldGFyZCBzdXIgJyVzJyBkZSAlZCBjb21taXRzLCBldCBwZXV0IMOqdHJlIG1pc2Ugw6Agam91ciAiCiAiZW4gYXZhbmNlIHJhcGlkZS5cbiIKIAotIzogcmVtb3RlLmM6MjA1MQorIzogcmVtb3RlLmM6MjA1NAogbXNnaWQgIiAgKHVzZSBcImdpdCBwdWxsXCIgdG8gdXBkYXRlIHlvdXIgbG9jYWwgYnJhbmNoKVxuIgogbXNnc3RyICIgICh1dGlsaXNleiBcImdpdCBwdWxsXCIgcG91ciBtZXR0cmUgw6Agam91ciB2b3RyZSBicmFuY2hlIGxvY2FsZSlcbiIKIAotIzogcmVtb3RlLmM6MjA1NAorIzogcmVtb3RlLmM6MjA1NwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiWW91ciBicmFuY2ggYW5kICclcycgaGF2ZSBkaXZlcmdlZCxcbiIKQEAgLTU3MDQsMTIgKzU3MzgsMTIgQEAKICJWb3RyZSBicmFuY2hlIGV0ICclcycgb250IGRpdmVyZ8OpLFxuIgogImV0IG9udCAlZCBldCAlZCBjb21taXRzIGRpZmbDqXJlbnRzIGNoYWN1bmUgcmVzcGVjdGl2ZW1lbnQuXG4iCiAKLSM6IHJlbW90ZS5jOjIwNjQKKyM6IHJlbW90ZS5jOjIwNjcKIG1zZ2lkICIgICh1c2UgXCJnaXQgcHVsbFwiIHRvIG1lcmdlIHRoZSByZW1vdGUgYnJhbmNoIGludG8geW91cnMpXG4iCiBtc2dzdHIgIiIKICIgICh1dGlsaXNleiBcImdpdCBwdWxsXCIgcG91ciBmdXNpb25uZXIgbGEgYnJhbmNoZSBkaXN0YW50ZSBkYW5zIGxhIHbDtHRyZSlcbiIKIAotIzogcmVtb3RlLmM6MjI0NworIzogcmVtb3RlLmM6MjI1MAogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgcGFyc2UgZXhwZWN0ZWQgb2JqZWN0IG5hbWUgJyVzJyIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkJ2FuYWx5c2VyIGxlIG5vbSBhdHRlbmR1IGQnb2JqZXQgJyVzJyIKQEAgLTU3ODcsNyArNTgyMSw3IEBACiBtc2dpZCAiUmVjb3JkZWQgcHJlaW1hZ2UgZm9yICclcyciCiBtc2dzdHIgIlByw6ktaW1hZ2UgZW5yZWdpc3Ryw6llIHBvdXIgJyVzJyIKIAotIzogcmVyZXJlLmM6ODgxIHN1Ym1vZHVsZS5jOjIwMjMgYnVpbHRpbi9sb2cuYzoxNzczCisjOiByZXJlcmUuYzo4ODEgc3VibW9kdWxlLmM6MjAyMyBidWlsdGluL2xvZy5jOjE3OTAKICM6IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxNDE4IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxNDI4CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBjcmVhdGUgZGlyZWN0b3J5ICclcyciCkBAIC01ODIyLDIwICs1ODU2LDIwIEBACiBtc2dpZCAidW5hYmxlIHRvIG9wZW4gcnItY2FjaGUgZGlyZWN0b3J5IgogbXNnc3RyICJpbXBvc3NpYmxlIGQnb3V2cmlyIGxlIHLDqXBlcnRvaXJlIHJyLWNhY2hlIgogCi0jOiByZXZpc2lvbi5jOjI1MDcKKyM6IHJldmlzaW9uLmM6MjUwOQogbXNnaWQgInlvdXIgY3VycmVudCBicmFuY2ggYXBwZWFycyB0byBiZSBicm9rZW4iCiBtc2dzdHIgInZvdHJlIGJyYW5jaGUgYWN0dWVsbGUgc2VtYmxlIGNhc3PDqWUiCiAKLSM6IHJldmlzaW9uLmM6MjUxMAorIzogcmV2aXNpb24uYzoyNTEyCiAjLCBjLWZvcm1hdAogbXNnaWQgInlvdXIgY3VycmVudCBicmFuY2ggJyVzJyBkb2VzIG5vdCBoYXZlIGFueSBjb21taXRzIHlldCIKIG1zZ3N0ciAidm90cmUgYnJhbmNoZSBhY3R1ZWxsZSAnJXMnIG5lIGNvbnRpZW50IGVuY29yZSBhdWN1biBjb21taXQiCiAKLSM6IHJldmlzaW9uLmM6MjcxMAorIzogcmV2aXNpb24uYzoyNzIwCiBtc2dpZCAiLS1maXJzdC1wYXJlbnQgaXMgaW5jb21wYXRpYmxlIHdpdGggLS1iaXNlY3QiCiBtc2dzdHIgIi0tZmlyc3QtcGFyZW50IGVzdCBpbmNvbXBhdGlibGUgYXZlYyAtLWJpc2VjdCIKIAotIzogcmV2aXNpb24uYzoyNzE0CisjOiByZXZpc2lvbi5jOjI3MjQKIG1zZ2lkICItTCBkb2VzIG5vdCB5ZXQgc3VwcG9ydCBkaWZmIGZvcm1hdHMgYmVzaWRlcyAtcCBhbmQgLXMiCiBtc2dzdHIgIi1MIG5lIHN1cHBvcnRlIHBhcyBlbmNvcmUgbGVzIGZvcm1hdHMgZGUgZGlmZiBhdXRyZXMgcXVlIC1wIGV0IC1zIgogCkBAIC01ODU4LDMxICs1ODkyLDMxIEBACiAiVm91cyBwb3V2ZXogZMOpc2FjdGl2ZXIgY2V0IGF2ZXJ0aXNzZW1lbnQgYXZlYyBgZ2l0IGNvbmZpZyBhZHZpY2UuaWdub3JlZEhvb2sgIgogImZhbHNlYC4iCiAKLSM6IHNlbmQtcGFjay5jOjE0MQorIzogc2VuZC1wYWNrLmM6MTQyCiBtc2dpZCAidW5leHBlY3RlZCBmbHVzaCBwYWNrZXQgd2hpbGUgcmVhZGluZyByZW1vdGUgdW5wYWNrIHN0YXR1cyIKIG1zZ3N0ciAiIgogInBhcXVldCBkZSBuZXR0b3lhZ2UgaW5hdHRlbmR1IHBlbmRhbnQgbGEgbGVjdHVyZSBkZSBsJ8OpdGF0IGRlIGTDqXBhcXVldGFnZSAiCiAiZGlzdGFudCIKIAotIzogc2VuZC1wYWNrLmM6MTQzCisjOiBzZW5kLXBhY2suYzoxNDQKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHBhcnNlIHJlbW90ZSB1bnBhY2sgc3RhdHVzOiAlcyIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkJ2FuYWx5c2VyIGwnw6l0YXQgZGUgZMOpcGFxdWV0YWdlIGRpc3RhbnTCoDogJXMiCiAKLSM6IHNlbmQtcGFjay5jOjE0NQorIzogc2VuZC1wYWNrLmM6MTQ2CiAjLCBjLWZvcm1hdAogbXNnaWQgInJlbW90ZSB1bnBhY2sgZmFpbGVkOiAlcyIKIG1zZ3N0ciAibGUgZMOpcGFxdWV0YWdlIGEgw6ljaG91w6nCoDogJXMiCiAKLSM6IHNlbmQtcGFjay5jOjMwNgorIzogc2VuZC1wYWNrLmM6MzA3CiBtc2dpZCAiZmFpbGVkIHRvIHNpZ24gdGhlIHB1c2ggY2VydGlmaWNhdGUiCiBtc2dzdHIgImltcG9zc2libGUgZGUgc2lnbmVyIGxlIGNlcnRpZmljYXQgZGUgcG91c3PDqWUiCiAKLSM6IHNlbmQtcGFjay5jOjQyMAorIzogc2VuZC1wYWNrLmM6NDIxCiBtc2dpZCAidGhlIHJlY2VpdmluZyBlbmQgZG9lcyBub3Qgc3VwcG9ydCAtLXNpZ25lZCBwdXNoIgogbXNnc3RyICJMZSByZWNldmV1ciBuZSBnw6hyZSBwYXMgbGVzIHBvdXNzw6llcyBhdmVjIC0tc2lnbmVkIgogCi0jOiBzZW5kLXBhY2suYzo0MjIKKyM6IHNlbmQtcGFjay5jOjQyMwogbXNnaWQgIiIKICJub3Qgc2VuZGluZyBhIHB1c2ggY2VydGlmaWNhdGUgc2luY2UgdGhlIHJlY2VpdmluZyBlbmQgZG9lcyBub3Qgc3VwcG9ydCAtLSIKICJzaWduZWQgcHVzaCIKQEAgLTU4OTAsMTEgKzU5MjQsMTEgQEAKICJwYXMgZCdlbnZvaSBkZSBjZXJ0aWZpY2F0IGRlIHBvdXNzw6llIGNhciBsZSByZWNldmV1ciBuZSBnw6hyZSBwYXMgbGVzICIKICJwb3Vzc8OpZXMgYXZlYyAtLXNpZ25lZCIKIAotIzogc2VuZC1wYWNrLmM6NDM0CisjOiBzZW5kLXBhY2suYzo0MzUKIG1zZ2lkICJ0aGUgcmVjZWl2aW5nIGVuZCBkb2VzIG5vdCBzdXBwb3J0IC0tYXRvbWljIHB1c2giCiBtc2dzdHIgIkxlIHJlY2V2ZXVyIG5lIGfDqHJlIHBhcyBsZXMgcG91c3PDqWVzIGF2ZWMgLS1hdG9taWMiCiAKLSM6IHNlbmQtcGFjay5jOjQzOQorIzogc2VuZC1wYWNrLmM6NDQwCiBtc2dpZCAidGhlIHJlY2VpdmluZyBlbmQgZG9lcyBub3Qgc3VwcG9ydCBwdXNoIG9wdGlvbnMiCiBtc2dzdHIgIkxlIHJlY2V2ZXVyIG5lIGfDqHJlIHBhcyBsZXMgb3B0aW9ucyBkZSBwb3Vzc8OpZXMiCiAKQEAgLTU5MDgsNyArNTk0Miw3IEBACiBtc2dpZCAiY291bGQgbm90IGRlbGV0ZSAnJXMnIgogbXNnc3RyICJJbXBvc3NpYmxlIGRlIHN1cHByaW1lciAnJXMnIgogCi0jOiBzZXF1ZW5jZXIuYzozMTEgYnVpbHRpbi9yZWJhc2UuYzo3NTkgYnVpbHRpbi9yZWJhc2UuYzoxNjQ1IGJ1aWx0aW4vcm0uYzozNjkKKyM6IHNlcXVlbmNlci5jOjMxMSBidWlsdGluL3JlYmFzZS5jOjc2MCBidWlsdGluL3JlYmFzZS5jOjE2NzYgYnVpbHRpbi9ybS5jOjM2OQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcmVtb3ZlICclcyciCiBtc2dzdHIgImltcG9zc2libGUgZGUgc3VwcHJpbWVyICclcyciCkBAIC01OTQ4LDcgKzU5ODIsNyBAQAogImF2ZWMgJ2dpdCBhZGQgPGNoZW1pbnM+JyBvdSAnZ2l0IHJtIDxjaGVtaW5zPidcbiIKICJwdWlzIHZhbGlkZXogbGUgcsOpc3VsdGF0IGF2ZWMgJ2dpdCBjb21taXQnIgogCi0jOiBzZXF1ZW5jZXIuYzo0MDEgc2VxdWVuY2VyLmM6MjkwOQorIzogc2VxdWVuY2VyLmM6NDAxIHNlcXVlbmNlci5jOjI4NDcKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGxvY2sgJyVzJyIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkZSB2ZXJyb3VpbGxlciAnJXMnIgpAQCAtNTk1OCwxNSArNTk5MiwxNSBAQAogbXNnaWQgImNvdWxkIG5vdCB3cml0ZSBlb2wgdG8gJyVzJyIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkJ8OpY3JpcmUgbGEgZmluIGRlIGxpZ25lIGRhbnMgJyVzJyIKIAotIzogc2VxdWVuY2VyLmM6NDEzIHNlcXVlbmNlci5jOjI3MTQgc2VxdWVuY2VyLmM6MjkxNSBzZXF1ZW5jZXIuYzoyOTI5Ci0jOiBzZXF1ZW5jZXIuYzozMTkyCisjOiBzZXF1ZW5jZXIuYzo0MTMgc2VxdWVuY2VyLmM6MjY1MiBzZXF1ZW5jZXIuYzoyODUzIHNlcXVlbmNlci5jOjI4NjcKKyM6IHNlcXVlbmNlci5jOjMxMzAKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIGZpbmFsaXplICclcyciCiBtc2dzdHIgIsOpY2hlYyBsb3JzIGRlIGxhIGZpbmFsaXNhdGlvbiBkZSAnJXMnIgogCi0jOiBzZXF1ZW5jZXIuYzo0MzYgc2VxdWVuY2VyLmM6OTgxIHNlcXVlbmNlci5jOjE2NTUgc2VxdWVuY2VyLmM6MjczNAotIzogc2VxdWVuY2VyLmM6MzE3NCBzZXF1ZW5jZXIuYzozMjgzIGJ1aWx0aW4vYW0uYzoyNDUgYnVpbHRpbi9jb21taXQuYzo3NjMKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxMTEyIGJ1aWx0aW4vcmViYXNlLmM6NTY3CisjOiBzZXF1ZW5jZXIuYzo0MzYgc2VxdWVuY2VyLmM6MTU4NSBzZXF1ZW5jZXIuYzoyNjcyIHNlcXVlbmNlci5jOjMxMTIKKyM6IHNlcXVlbmNlci5jOjMyMjEgYnVpbHRpbi9hbS5jOjI0NCBidWlsdGluL2NvbW1pdC5jOjc2MyBidWlsdGluL21lcmdlLmM6MTExNworIzogYnVpbHRpbi9yZWJhc2UuYzo1NjgKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHJlYWQgJyVzJyIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkZSBsaXJlICclcyciCkBAIC01OTkzLDcwICs2MDI3LDY1IEBACiAjLiBUUkFOU0xBVE9SUzogJXMgd2lsbCBiZSAicmV2ZXJ0IiwgImNoZXJyeS1waWNrIiBvcgogIy4gInJlYmFzZSAtaSIuCiAjLgotIzogc2VxdWVuY2VyLmM6NjMyCisjOiBzZXF1ZW5jZXIuYzo2MzEKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXM6IFVuYWJsZSB0byB3cml0ZSBuZXcgaW5kZXggZmlsZSIKIG1zZ3N0ciAiJXM6IEltcG9zc2libGUgZCfDqWNyaXJlIGxlIG5vdXZlYXUgZmljaGllciBpbmRleCIKIAotIzogc2VxdWVuY2VyLmM6NjQ5CisjOiBzZXF1ZW5jZXIuYzo2NDgKIG1zZ2lkICJ1bmFibGUgdG8gdXBkYXRlIGNhY2hlIHRyZWUiCiBtc2dzdHIgImltcG9zc2libGUgZGUgbWV0dHJlIMOgIGpvdXIgbCdhcmJyZSBkZSBjYWNoZSIKIAotIzogc2VxdWVuY2VyLmM6NjYzCisjOiBzZXF1ZW5jZXIuYzo2NjIKIG1zZ2lkICJjb3VsZCBub3QgcmVzb2x2ZSBIRUFEIGNvbW1pdCIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkZSByw6lzb3VkcmUgbGUgY29tbWl0IEhFQUQiCiAKLSM6IHNlcXVlbmNlci5jOjc0MworIzogc2VxdWVuY2VyLmM6NzQyCiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vIGtleSBwcmVzZW50IGluICclLipzJyIKIG1zZ3N0ciAiYXVjdW5lIGNsw6kgcHLDqXNlbnRlIGRhbnMgJyUuKnMnIgogCi0jOiBzZXF1ZW5jZXIuYzo3NTQKKyM6IHNlcXVlbmNlci5jOjc1MwogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gZGVxdW90ZSB2YWx1ZSBvZiAnJXMnIgogbXNnc3RyICJJbXBvc3NpYmxlIGRlIGTDqWNvdGVyIGxhIHZhbGV1ciBkZSAnJXMnIgogCi0jOiBzZXF1ZW5jZXIuYzo3OTEgd3JhcHBlci5jOjIyNyB3cmFwcGVyLmM6Mzk3IGJ1aWx0aW4vYW0uYzo3MDYKLSM6IGJ1aWx0aW4vYW0uYzo3OTggYnVpbHRpbi9tZXJnZS5jOjExMDkgYnVpbHRpbi9yZWJhc2UuYzoxMDQ1CisjOiBzZXF1ZW5jZXIuYzo3OTAgd3JhcHBlci5jOjE5MCB3cmFwcGVyLmM6MzYwIGJ1aWx0aW4vYW0uYzo3MDUKKyM6IGJ1aWx0aW4vYW0uYzo3OTcgYnVpbHRpbi9tZXJnZS5jOjExMTQgYnVpbHRpbi9yZWJhc2UuYzoxMDQ2CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBvcGVuICclcycgZm9yIHJlYWRpbmciCiBtc2dzdHIgImltcG9zc2libGUgZCdvdXZyaXIgJyVzJyBlbiBsZWN0dXJlIgogCi0jOiBzZXF1ZW5jZXIuYzo4MDEKKyM6IHNlcXVlbmNlci5jOjgwMAogbXNnaWQgIidHSVRfQVVUSE9SX05BTUUnIGFscmVhZHkgZ2l2ZW4iCiBtc2dzdHIgIidHSVRfQVVUSE9SX05BTUUnIGTDqWrDoCBmb3VybmkiCiAKLSM6IHNlcXVlbmNlci5jOjgwNgorIzogc2VxdWVuY2VyLmM6ODA1CiBtc2dpZCAiJ0dJVF9BVVRIT1JfRU1BSUwnIGFscmVhZHkgZ2l2ZW4iCiBtc2dzdHIgIidHSVRfQVVUSE9SX0VNQUlMJyBkw6lqw6AgZm91cm5pIgogCi0jOiBzZXF1ZW5jZXIuYzo4MTEKKyM6IHNlcXVlbmNlci5jOjgxMAogbXNnaWQgIidHSVRfQVVUSE9SX0RBVEUnIGFscmVhZHkgZ2l2ZW4iCiBtc2dzdHIgIidHSVRfQVVUSE9SX0RBVEUnIGTDqWrDoCBmb3VybmkiCiAKLSM6IHNlcXVlbmNlci5jOjgxNQorIzogc2VxdWVuY2VyLmM6ODE0CiAjLCBjLWZvcm1hdAogbXNnaWQgInVua25vd24gdmFyaWFibGUgJyVzJyIKIG1zZ3N0ciAidmFyaWFibGUgaW5jb25udWUgJyVzJyIKIAotIzogc2VxdWVuY2VyLmM6ODIwCisjOiBzZXF1ZW5jZXIuYzo4MTkKIG1zZ2lkICJtaXNzaW5nICdHSVRfQVVUSE9SX05BTUUnIgogbXNnc3RyICInR0lUX0FVVEhPUl9OQU1FJyBtYW5xdWFudCIKIAotIzogc2VxdWVuY2VyLmM6ODIyCisjOiBzZXF1ZW5jZXIuYzo4MjEKIG1zZ2lkICJtaXNzaW5nICdHSVRfQVVUSE9SX0VNQUlMJyIKIG1zZ3N0ciAiJ0dJVF9BVVRIT1JfRU1BSUwnIG1hbnF1YW50IgogCi0jOiBzZXF1ZW5jZXIuYzo4MjQKKyM6IHNlcXVlbmNlci5jOjgyMwogbXNnaWQgIm1pc3NpbmcgJ0dJVF9BVVRIT1JfREFURSciCiBtc2dzdHIgIidHSVRfQVVUSE9SX0RBVEUnIG1hbnF1YW50IgogCi0jOiBzZXF1ZW5jZXIuYzo4ODQKLSMsIGMtZm9ybWF0Ci1tc2dpZCAiaW52YWxpZCBkYXRlIGZvcm1hdCAnJXMnIGluICclcyciCi1tc2dzdHIgImZvcm1hdCBkZSBkYXRlIGludmFsaWRlICclcycgZGFucyAnJXMnIgotCi0jOiBzZXF1ZW5jZXIuYzo5MDEKKyM6IHNlcXVlbmNlci5jOjg3MgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAieW91IGhhdmUgc3RhZ2VkIGNoYW5nZXMgaW4geW91ciB3b3JraW5nIHRyZWVcbiIKQEAgLTYwODUsMTUgKzYxMTQsMTEgQEAKICJcbiIKICIgIGdpdCByZWJhc2UgLS1jb250aW51ZVxuIgogCi0jOiBzZXF1ZW5jZXIuYzo5OTUKLW1zZ2lkICJ3cml0aW5nIHJvb3QgY29tbWl0IgotbXNnc3RyICLDqWNyaXR1cmUgZHUgY29tbWl0IHJhY2luZSIKLQotIzogc2VxdWVuY2VyLmM6MTIxNgorIzogc2VxdWVuY2VyLmM6MTE0NgogbXNnaWQgIidwcmVwYXJlLWNvbW1pdC1tc2cnIGhvb2sgZmFpbGVkIgogbXNnc3RyICLDqWNoZWMgZHUgY3JvY2hldCAncHJlcGFyZS1jb21taXQtbXNnJyIKIAotIzogc2VxdWVuY2VyLmM6MTIyMworIzogc2VxdWVuY2VyLmM6MTE1MwogbXNnaWQgIiIKICJZb3VyIG5hbWUgYW5kIGVtYWlsIGFkZHJlc3Mgd2VyZSBjb25maWd1cmVkIGF1dG9tYXRpY2FsbHkgYmFzZWRcbiIKICJvbiB5b3VyIHVzZXJuYW1lIGFuZCBob3N0bmFtZS4gUGxlYXNlIGNoZWNrIHRoYXQgdGhleSBhcmUgYWNjdXJhdGUuXG4iCkBAIC02MTIyLDcgKzYxNDcsNyBAQAogIlxuIgogIiAgICBnaXQgY29tbWl0IC0tYW1lbmQgLS1yZXNldC1hdXRob3JcbiIKIAotIzogc2VxdWVuY2VyLmM6MTIzNgorIzogc2VxdWVuY2VyLmM6MTE2NgogbXNnaWQgIiIKICJZb3VyIG5hbWUgYW5kIGVtYWlsIGFkZHJlc3Mgd2VyZSBjb25maWd1cmVkIGF1dG9tYXRpY2FsbHkgYmFzZWRcbiIKICJvbiB5b3VyIHVzZXJuYW1lIGFuZCBob3N0bmFtZS4gUGxlYXNlIGNoZWNrIHRoYXQgdGhleSBhcmUgYWNjdXJhdGUuXG4iCkBAIC02MTQ4LDMyNiArNjE3MywzMjYgQEAKICJcbiIKICIgICAgZ2l0IGNvbW1pdCAtLWFtZW5kIC0tcmVzZXQtYXV0aG9yXG4iCiAKLSM6IHNlcXVlbmNlci5jOjEyNzgKKyM6IHNlcXVlbmNlci5jOjEyMDgKIG1zZ2lkICJjb3VsZG4ndCBsb29rIHVwIG5ld2x5IGNyZWF0ZWQgY29tbWl0IgogbXNnc3RyICJpbXBvc3NpYmxlIGRlIHJldHJvdXZlciBsZSBjb21taXQgbm91dmVsbGVtZW50IGNyw6nDqSIKIAotIzogc2VxdWVuY2VyLmM6MTI4MAorIzogc2VxdWVuY2VyLmM6MTIxMAogbXNnaWQgImNvdWxkIG5vdCBwYXJzZSBuZXdseSBjcmVhdGVkIGNvbW1pdCIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkJ2FuYWx5c2VyIGxlIGNvbW1pdCBub3V2ZWxsZW1lbnQgY3LDqcOpIgogCi0jOiBzZXF1ZW5jZXIuYzoxMzI2CisjOiBzZXF1ZW5jZXIuYzoxMjU2CiBtc2dpZCAidW5hYmxlIHRvIHJlc29sdmUgSEVBRCBhZnRlciBjcmVhdGluZyBjb21taXQiCiBtc2dzdHIgImltcG9zc2libGUgZGUgcsOpc291ZHJlIEhFQUQgYXByw6hzIGNyw6lhdGlvbiBkdSBjb21taXQiCiAKLSM6IHNlcXVlbmNlci5jOjEzMjgKKyM6IHNlcXVlbmNlci5jOjEyNTgKIG1zZ2lkICJkZXRhY2hlZCBIRUFEIgogbXNnc3RyICJIRUFEIGTDqXRhY2jDqWUiCiAKLSM6IHNlcXVlbmNlci5jOjEzMzIKKyM6IHNlcXVlbmNlci5jOjEyNjIKIG1zZ2lkICIgKHJvb3QtY29tbWl0KSIKIG1zZ3N0ciAiIChjb21taXQgcmFjaW5lKSIKIAotIzogc2VxdWVuY2VyLmM6MTM1MworIzogc2VxdWVuY2VyLmM6MTI4MwogbXNnaWQgImNvdWxkIG5vdCBwYXJzZSBIRUFEIgogbXNnc3RyICJpbXBvc3NpYmxlIGRlIGxpcmUgSEVBRCIKIAotIzogc2VxdWVuY2VyLmM6MTM1NQorIzogc2VxdWVuY2VyLmM6MTI4NQogIywgYy1mb3JtYXQKIG1zZ2lkICJIRUFEICVzIGlzIG5vdCBhIGNvbW1pdCEiCiBtc2dzdHIgIkhFQUQgJXMgbidlc3QgcGFzIHVuIGNvbW1pdCAhIgogCi0jOiBzZXF1ZW5jZXIuYzoxMzU5IGJ1aWx0aW4vY29tbWl0LmM6MTU3MQorIzogc2VxdWVuY2VyLmM6MTI4OSBidWlsdGluL2NvbW1pdC5jOjE1NzEKIG1zZ2lkICJjb3VsZCBub3QgcGFyc2UgSEVBRCBjb21taXQiCiBtc2dzdHIgImltcG9zc2libGUgZCdhbmFseXNlciBsZSBjb21taXQgSEVBRCIKIAotIzogc2VxdWVuY2VyLmM6MTQxMSBzZXF1ZW5jZXIuYzoyMDA0CisjOiBzZXF1ZW5jZXIuYzoxMzQxIHNlcXVlbmNlci5jOjE5MzMKIG1zZ2lkICJ1bmFibGUgdG8gcGFyc2UgY29tbWl0IGF1dGhvciIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkJ2FuYWx5c2VyIGwnYXV0ZXVyIGR1IGNvbW1pdCIKIAotIzogc2VxdWVuY2VyLmM6MTQyMSBidWlsdGluL2FtLmM6MTU3MyBidWlsdGluL21lcmdlLmM6Njg0CisjOiBzZXF1ZW5jZXIuYzoxMzUyIGJ1aWx0aW4vYW0uYzoxNTYxIGJ1aWx0aW4vbWVyZ2UuYzo2ODQKIG1zZ2lkICJnaXQgd3JpdGUtdHJlZSBmYWlsZWQgdG8gd3JpdGUgYSB0cmVlIgogbXNnc3RyICJnaXQgd3JpdGUtdHJlZSBhIMOpY2hvdcOpIMOgIMOpY3JpcmUgdW4gYXJicmUiCiAKLSM6IHNlcXVlbmNlci5jOjE0Mzggc2VxdWVuY2VyLmM6MTQ5OQorIzogc2VxdWVuY2VyLmM6MTM2OSBzZXF1ZW5jZXIuYzoxNDI5CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byByZWFkIGNvbW1pdCBtZXNzYWdlIGZyb20gJyVzJyIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkZSBsaXJlIGxlIG1lc3NhZ2UgZGUgdmFsaWRhdGlvbiBkZSAnJXMnIgogCi0jOiBzZXF1ZW5jZXIuYzoxNDY1IGJ1aWx0aW4vYW0uYzoxNTk1IGJ1aWx0aW4vY29tbWl0LmM6MTY3MCBidWlsdGluL21lcmdlLmM6ODc4Ci0jOiBidWlsdGluL21lcmdlLmM6OTAzCisjOiBzZXF1ZW5jZXIuYzoxMzk2IGJ1aWx0aW4vYW0uYzoxNTgzIGJ1aWx0aW4vY29tbWl0LmM6MTY3MCBidWlsdGluL21lcmdlLmM6ODgzCisjOiBidWlsdGluL21lcmdlLmM6OTA4CiBtc2dpZCAiZmFpbGVkIHRvIHdyaXRlIGNvbW1pdCBvYmplY3QiCiBtc2dzdHIgIsOpY2hlYyBkZSBsJ8OpY3JpdHVyZSBkZSBsJ29iamV0IGNvbW1pdCIKIAotIzogc2VxdWVuY2VyLmM6MTUyNgorIzogc2VxdWVuY2VyLmM6MTQ1NgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcGFyc2UgY29tbWl0ICVzIgogbXNnc3RyICJpbXBvc3NpYmxlIGQnYW5hbHlzZXIgbGUgY29tbWl0ICVzIgogCi0jOiBzZXF1ZW5jZXIuYzoxNTMxCisjOiBzZXF1ZW5jZXIuYzoxNDYxCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBwYXJzZSBwYXJlbnQgY29tbWl0ICVzIgogbXNnc3RyICJpbXBvc3NpYmxlIGQnYW5hbHlzZXIgbGUgY29tbWl0IHBhcmVudCAlcyIKIAotIzogc2VxdWVuY2VyLmM6MTYwNSBzZXF1ZW5jZXIuYzoxNzE1CisjOiBzZXF1ZW5jZXIuYzoxNTM1IHNlcXVlbmNlci5jOjE2NDUKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5rbm93biBjb21tYW5kOiAlZCIKIG1zZ3N0ciAiY29tbWFuZGUgaW5jb25udWXCoDogJWQiCiAKLSM6IHNlcXVlbmNlci5jOjE2NjIgc2VxdWVuY2VyLmM6MTY4NworIzogc2VxdWVuY2VyLmM6MTU5MiBzZXF1ZW5jZXIuYzoxNjE3CiAjLCBjLWZvcm1hdAogbXNnaWQgIlRoaXMgaXMgYSBjb21iaW5hdGlvbiBvZiAlZCBjb21taXRzLiIKIG1zZ3N0ciAiQ2VjaSBlc3QgbGEgY29tYmluYWlzb24gZGUgJWQgY29tbWl0cy4iCiAKLSM6IHNlcXVlbmNlci5jOjE2NzIKKyM6IHNlcXVlbmNlci5jOjE2MDIKIG1zZ2lkICJuZWVkIGEgSEVBRCB0byBmaXh1cCIKIG1zZ3N0ciAidW5lIEhFQUQgZXN0IG7DqWNlc3NhaXJlIMOgIGxhIGNvcnJlY3Rpb24iCiAKLSM6IHNlcXVlbmNlci5jOjE2NzQgc2VxdWVuY2VyLmM6MzIxOQorIzogc2VxdWVuY2VyLmM6MTYwNCBzZXF1ZW5jZXIuYzozMTU3CiBtc2dpZCAiY291bGQgbm90IHJlYWQgSEVBRCIKIG1zZ3N0ciAiSW1wb3NzaWJsZSBkZSBsaXJlIEhFQUQiCiAKLSM6IHNlcXVlbmNlci5jOjE2NzYKKyM6IHNlcXVlbmNlci5jOjE2MDYKIG1zZ2lkICJjb3VsZCBub3QgcmVhZCBIRUFEJ3MgY29tbWl0IG1lc3NhZ2UiCiBtc2dzdHIgImltcG9zc2libGUgZGUgbGlyZSBsZSBtZXNzYWdlIGRlIHZhbGlkYXRpb24gZGUgSEVBRCIKIAotIzogc2VxdWVuY2VyLmM6MTY4MgorIzogc2VxdWVuY2VyLmM6MTYxMgogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3Qgd3JpdGUgJyVzJyIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkJ8OpY3JpcmUgJyVzJyIKIAotIzogc2VxdWVuY2VyLmM6MTY4OSBnaXQtcmViYXNlLS1wcmVzZXJ2ZS1tZXJnZXMuc2g6NDk2CisjOiBzZXF1ZW5jZXIuYzoxNjE5IGdpdC1yZWJhc2UtLXByZXNlcnZlLW1lcmdlcy5zaDo0OTYKIG1zZ2lkICJUaGlzIGlzIHRoZSAxc3QgY29tbWl0IG1lc3NhZ2U6IgogbXNnc3RyICJDZWNpIGVzdCBsZSBwcmVtaWVyIG1lc3NhZ2UgZGUgdmFsaWRhdGlvbsKgOiIKIAotIzogc2VxdWVuY2VyLmM6MTY5NworIzogc2VxdWVuY2VyLmM6MTYyNwogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcmVhZCBjb21taXQgbWVzc2FnZSBvZiAlcyIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkZSBsaXJlIGxlIG1lc3NhZ2UgZGUgdmFsaWRhdGlvbiBkZSAlcyIKIAotIzogc2VxdWVuY2VyLmM6MTcwNAorIzogc2VxdWVuY2VyLmM6MTYzNAogIywgYy1mb3JtYXQKIG1zZ2lkICJUaGlzIGlzIHRoZSBjb21taXQgbWVzc2FnZSAjJWQ6IgogbXNnc3RyICJDZWNpIGVzdCBsZSBtZXNzYWdlIGRlIHZhbGlkYXRpb24gbnVtw6lybyAlZMKgOiIKIAotIzogc2VxdWVuY2VyLmM6MTcxMAorIzogc2VxdWVuY2VyLmM6MTY0MAogIywgYy1mb3JtYXQKIG1zZ2lkICJUaGUgY29tbWl0IG1lc3NhZ2UgIyVkIHdpbGwgYmUgc2tpcHBlZDoiCiBtc2dzdHIgIkxlIG1lc3NhZ2UgZGUgdmFsaWRhdGlvbiAlZCBzZXJhIGlnbm9yw6nCoDoiCiAKLSM6IHNlcXVlbmNlci5jOjE3OTgKKyM6IHNlcXVlbmNlci5jOjE3MjgKIG1zZ2lkICJ5b3VyIGluZGV4IGZpbGUgaXMgdW5tZXJnZWQuIgogbXNnc3RyICJ2b3RyZSBmaWNoaWVyIGQnaW5kZXggbidlc3QgcGFzIGZ1c2lvbm7DqS4iCiAKLSM6IHNlcXVlbmNlci5jOjE4MDUKKyM6IHNlcXVlbmNlci5jOjE3MzUKIG1zZ2lkICJjYW5ub3QgZml4dXAgcm9vdCBjb21taXQiCiBtc2dzdHIgImltcG9zc2libGUgZGUgcsOpcGFyZXIgbGUgY29tbWl0IHJhY2luZSIKIAotIzogc2VxdWVuY2VyLmM6MTgyNAorIzogc2VxdWVuY2VyLmM6MTc1NAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb21taXQgJXMgaXMgYSBtZXJnZSBidXQgbm8gLW0gb3B0aW9uIHdhcyBnaXZlbi4iCiBtc2dzdHIgImxlIGNvbW1pdCAlcyBlc3QgdW5lIGZ1c2lvbiBtYWlzIGwnb3B0aW9uIC1tIG4nYSBwYXMgw6l0w6kgc3DDqWNpZmnDqWUuIgogCi0jOiBzZXF1ZW5jZXIuYzoxODMyIHNlcXVlbmNlci5jOjE4NDAKKyM6IHNlcXVlbmNlci5jOjE3NjIgc2VxdWVuY2VyLmM6MTc3MAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb21taXQgJXMgZG9lcyBub3QgaGF2ZSBwYXJlbnQgJWQiCiBtc2dzdHIgImxlIGNvbW1pdCAlcyBuJ2EgcGFzIGRlIHBhcmVudCAlZCIKIAotIzogc2VxdWVuY2VyLmM6MTg0NgorIzogc2VxdWVuY2VyLmM6MTc3NgogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgZ2V0IGNvbW1pdCBtZXNzYWdlIGZvciAlcyIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkJ29idGVuaXIgdW4gbWVzc2FnZSBkZSB2YWxpZGF0aW9uIHBvdXIgJXMiCiAKICMuIFRSQU5TTEFUT1JTOiBUaGUgZmlyc3QgJXMgd2lsbCBiZSBhICJ0b2RvIiBjb21tYW5kIGxpa2UKICMuICJyZXZlcnQiIG9yICJwaWNrIiwgdGhlIHNlY29uZCAlcyBhIFNIQTEuCi0jOiBzZXF1ZW5jZXIuYzoxODY1CisjOiBzZXF1ZW5jZXIuYzoxNzk1CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiBjYW5ub3QgcGFyc2UgcGFyZW50IGNvbW1pdCAlcyIKIG1zZ3N0ciAiJXMgOiBpbXBvc3NpYmxlIGQnYW5hbHlzZXIgbGUgY29tbWl0IHBhcmVudCAlcyIKIAotIzogc2VxdWVuY2VyLmM6MTkzMAorIzogc2VxdWVuY2VyLmM6MTg2MAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcmVuYW1lICclcycgdG8gJyVzJyIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkZSByZW5vbW1lciAnJXMnIGVuICclcyciCiAKLSM6IHNlcXVlbmNlci5jOjE5ODUKKyM6IHNlcXVlbmNlci5jOjE5MTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHJldmVydCAlcy4uLiAlcyIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkJ2FubnVsZXIgJXMuLi4gJXMiCiAKLSM6IHNlcXVlbmNlci5jOjE5ODYKKyM6IHNlcXVlbmNlci5jOjE5MTYKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGFwcGx5ICVzLi4uICVzIgogbXNnc3RyICJpbXBvc3NpYmxlIGQnYXBwbGlxdWVyICVzLi4uICVzIgogCi0jOiBzZXF1ZW5jZXIuYzoyMDQ1CisjOiBzZXF1ZW5jZXIuYzoxOTgzCiAjLCBjLWZvcm1hdAogbXNnaWQgImdpdCAlczogZmFpbGVkIHRvIHJlYWQgdGhlIGluZGV4IgogbXNnc3RyICJnaXQgJXMgOiDDqWNoZWMgw6AgbGEgbGVjdHVyZSBkZSBsJ2luZGV4IgogCi0jOiBzZXF1ZW5jZXIuYzoyMDUyCisjOiBzZXF1ZW5jZXIuYzoxOTkwCiAjLCBjLWZvcm1hdAogbXNnaWQgImdpdCAlczogZmFpbGVkIHRvIHJlZnJlc2ggdGhlIGluZGV4IgogbXNnc3RyICJnaXQgJXMgOiDDqWNoZWMgZHUgcmFmcmHDrmNoaXNzZW1lbnQgZGUgbCdpbmRleCIKIAotIzogc2VxdWVuY2VyLmM6MjEyOAorIzogc2VxdWVuY2VyLmM6MjA2NgogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyBkb2VzIG5vdCBhY2NlcHQgYXJndW1lbnRzOiAnJXMnIgogbXNnc3RyICIlcyBuJ2FjY2VwdGUgcGFzIGQnYXJndW1lbnTCoDogJyVzJyIKIAotIzogc2VxdWVuY2VyLmM6MjEzNworIzogc2VxdWVuY2VyLmM6MjA3NQogIywgYy1mb3JtYXQKIG1zZ2lkICJtaXNzaW5nIGFyZ3VtZW50cyBmb3IgJXMiCiBtc2dzdHIgImFyZ3VtZW50IG1hbnF1YW50IHBvdXIgJXMiCiAKLSM6IHNlcXVlbmNlci5jOjIxNzQKKyM6IHNlcXVlbmNlci5jOjIxMTIKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHBhcnNlICclLipzJyIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkJ2FuYWx5c2VyICclLipzJyIKIAotIzogc2VxdWVuY2VyLmM6MjIyOAorIzogc2VxdWVuY2VyLmM6MjE2NgogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIGxpbmUgJWQ6ICUuKnMiCiBtc2dzdHIgImxpZ25lICVkIGludmFsaWRlwqA6ICUuKnMiCiAKLSM6IHNlcXVlbmNlci5jOjIyMzkKKyM6IHNlcXVlbmNlci5jOjIxNzcKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90ICclcycgd2l0aG91dCBhIHByZXZpb3VzIGNvbW1pdCIKIG1zZ3N0ciAiJyVzJyBpbXBvc3NpYmxlIGF2ZWMgbGUgY29tbWl0IHByw6ljw6lkZW50IgogCi0jOiBzZXF1ZW5jZXIuYzoyMjg3IGJ1aWx0aW4vcmViYXNlLmM6MTUzIGJ1aWx0aW4vcmViYXNlLmM6MTc4CisjOiBzZXF1ZW5jZXIuYzoyMjI1IGJ1aWx0aW4vcmViYXNlLmM6MTUzIGJ1aWx0aW4vcmViYXNlLmM6MTc4CiAjOiBidWlsdGluL3JlYmFzZS5jOjIwNCBidWlsdGluL3JlYmFzZS5jOjIyOQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcmVhZCAnJXMnLiIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkZSBsaXJlICclcycuIgogCi0jOiBzZXF1ZW5jZXIuYzoyMzIzCisjOiBzZXF1ZW5jZXIuYzoyMjYxCiBtc2dpZCAiY2FuY2VsbGluZyBhIGNoZXJyeSBwaWNraW5nIGluIHByb2dyZXNzIgogbXNnc3RyICJhbm51bGF0aW9uIGQndW4gcGljb3JhZ2UgZW4gY291cnMiCiAKLSM6IHNlcXVlbmNlci5jOjIzMzAKKyM6IHNlcXVlbmNlci5jOjIyNjgKIG1zZ2lkICJjYW5jZWxsaW5nIGEgcmV2ZXJ0IGluIHByb2dyZXNzIgogbXNnc3RyICJhbm51bGF0aW9uIGQndW4gcmV0b3VyIGVuIGNvdXJzIgogCi0jOiBzZXF1ZW5jZXIuYzoyMzY0CisjOiBzZXF1ZW5jZXIuYzoyMzAyCiBtc2dpZCAicGxlYXNlIGZpeCB0aGlzIHVzaW5nICdnaXQgcmViYXNlIC0tZWRpdC10b2RvJy4iCiBtc2dzdHIgInZldWlsbGV6IGNvcnJpZ2VyIGNlY2kgZW4gdXRpbGlzYW50ICdnaXQgcmViYXNlIC0tZWRpdC10b2RvJy4iCiAKLSM6IHNlcXVlbmNlci5jOjIzNjYKKyM6IHNlcXVlbmNlci5jOjIzMDQKICMsIGMtZm9ybWF0CiBtc2dpZCAidW51c2FibGUgaW5zdHJ1Y3Rpb24gc2hlZXQ6ICclcyciCiBtc2dzdHIgImZldWlsbGUgZCdpbnN0cnVjdGlvbiBpbnV0aWxpc2FibGXCoDogJyVzJyIKIAotIzogc2VxdWVuY2VyLmM6MjM3MQorIzogc2VxdWVuY2VyLmM6MjMwOQogbXNnaWQgIm5vIGNvbW1pdHMgcGFyc2VkLiIKIG1zZ3N0ciAiYXVjdW4gY29tbWl0IGFuYWx5c8OpLiIKIAotIzogc2VxdWVuY2VyLmM6MjM4MgorIzogc2VxdWVuY2VyLmM6MjMyMAogbXNnaWQgImNhbm5vdCBjaGVycnktcGljayBkdXJpbmcgYSByZXZlcnQuIgogbXNnc3RyICJpbXBvc3NpYmxlIGRlIHBpY29yZXIgcGVuZGFudCBsJ2FubnVsYXRpb24gZCd1biBjb21taXQuIgogCi0jOiBzZXF1ZW5jZXIuYzoyMzg0CisjOiBzZXF1ZW5jZXIuYzoyMzIyCiBtc2dpZCAiY2Fubm90IHJldmVydCBkdXJpbmcgYSBjaGVycnktcGljay4iCiBtc2dzdHIgImltcG9zc2libGUgZCdhbm51bGVyIHVuIGNvbW1pdCBwZW5kYW50IHVuIHBpY29yYWdlLiIKIAotIzogc2VxdWVuY2VyLmM6MjQ2NgorIzogc2VxdWVuY2VyLmM6MjQwNAogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIHZhbHVlIGZvciAlczogJXMiCiBtc2dzdHIgInZhbGV1ciBpbnZhbGlkZSBwb3VyICVzwqA6ICVzIgogCi0jOiBzZXF1ZW5jZXIuYzoyNTUzCisjOiBzZXF1ZW5jZXIuYzoyNDkxCiBtc2dpZCAidW51c2FibGUgc3F1YXNoLW9udG8iCiBtc2dzdHIgIlwiw6ljcmFzZS1zdXJcIiBpbnV0aWxpc2FibGUiCiAKLSM6IHNlcXVlbmNlci5jOjI1NjkKKyM6IHNlcXVlbmNlci5jOjI1MDcKICMsIGMtZm9ybWF0CiBtc2dpZCAibWFsZm9ybWVkIG9wdGlvbnMgc2hlZXQ6ICclcyciCiBtc2dzdHIgImZldWlsbGUgZCdvcHRpb25zIG1hbGZvcm3DqWXCoDogJXMiCiAKLSM6IHNlcXVlbmNlci5jOjI2NTIgc2VxdWVuY2VyLmM6NDM1MQorIzogc2VxdWVuY2VyLmM6MjU5MCBzZXF1ZW5jZXIuYzo0MzA4CiBtc2dpZCAiZW1wdHkgY29tbWl0IHNldCBwYXNzZWQiCiBtc2dzdHIgImwnZW5zZW1ibGUgZGUgY29tbWl0cyBzcMOpY2lmacOpIGVzdCB2aWRlIgogCi0jOiBzZXF1ZW5jZXIuYzoyNjY4CisjOiBzZXF1ZW5jZXIuYzoyNjA2CiBtc2dpZCAicmV2ZXJ0IGlzIGFscmVhZHkgaW4gcHJvZ3Jlc3MiCiBtc2dzdHIgInVuIHJldG91ciBlc3QgZMOpasOgIGVuIGNvdXJzIgogCi0jOiBzZXF1ZW5jZXIuYzoyNjcwCisjOiBzZXF1ZW5jZXIuYzoyNjA4CiAjLCBjLWZvcm1hdAogbXNnaWQgInRyeSBcImdpdCByZXZlcnQgKC0tY29udGludWUgfCAlcy0tYWJvcnQgfCAtLXF1aXQpXCIiCiBtc2dzdHIgImVzc2F5ZXogXCJnaXQgcmV2ZXJ0ICgtLWNvbnRpbnVlIHwgJXMtLWFib3J0IHwgLS1xdWl0KVwiIgogCi0jOiBzZXF1ZW5jZXIuYzoyNjczCisjOiBzZXF1ZW5jZXIuYzoyNjExCiBtc2dpZCAiY2hlcnJ5LXBpY2sgaXMgYWxyZWFkeSBpbiBwcm9ncmVzcyIKIG1zZ3N0ciAidW4gcGljb3JhZ2UgZXN0IGTDqWrDoCBlbiBjb3VycyIKIAotIzogc2VxdWVuY2VyLmM6MjY3NQorIzogc2VxdWVuY2VyLmM6MjYxMwogIywgYy1mb3JtYXQKIG1zZ2lkICJ0cnkgXCJnaXQgY2hlcnJ5LXBpY2sgKC0tY29udGludWUgfCAlcy0tYWJvcnQgfCAtLXF1aXQpXCIiCiBtc2dzdHIgImVzc2F5ZXogXCJnaXQgY2hlcnJ5LXBpY2sgKC0tY29udGludWUgfCAlcy0tYWJvcnQgfCAtLXF1aXQpXCIiCiAKLSM6IHNlcXVlbmNlci5jOjI2ODkKKyM6IHNlcXVlbmNlci5jOjI2MjcKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGNyZWF0ZSBzZXF1ZW5jZXIgZGlyZWN0b3J5ICclcyciCiBtc2dzdHIgImltcG9zc2libGUgZGUgY3LDqWVyIGxlIHLDqXBlcnRvaXJlIGRlIHPDqXF1ZW5jZXVyICclcyciCiAKLSM6IHNlcXVlbmNlci5jOjI3MDQKKyM6IHNlcXVlbmNlci5jOjI2NDIKIG1zZ2lkICJjb3VsZCBub3QgbG9jayBIRUFEIgogbXNnc3RyICJpbXBvc3NpYmxlIGRlIHZlcnJvdWlsbGVyIEhFQUQiCiAKLSM6IHNlcXVlbmNlci5jOjI3NjQgc2VxdWVuY2VyLmM6NDEwMworIzogc2VxdWVuY2VyLmM6MjcwMiBzZXF1ZW5jZXIuYzo0MDU3CiBtc2dpZCAibm8gY2hlcnJ5LXBpY2sgb3IgcmV2ZXJ0IGluIHByb2dyZXNzIgogbXNnc3RyICJhdWN1biBwaWNvcmFnZSBvdSByZXRvdXIgZW4gY291cnMiCiAKLSM6IHNlcXVlbmNlci5jOjI3NjYgc2VxdWVuY2VyLmM6Mjc3NworIzogc2VxdWVuY2VyLmM6MjcwNCBzZXF1ZW5jZXIuYzoyNzE1CiBtc2dpZCAiY2Fubm90IHJlc29sdmUgSEVBRCIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkZSByw6lzb3VkcmUgSEVBRCIKIAotIzogc2VxdWVuY2VyLmM6Mjc2OCBzZXF1ZW5jZXIuYzoyODEyCisjOiBzZXF1ZW5jZXIuYzoyNzA2IHNlcXVlbmNlci5jOjI3NTAKIG1zZ2lkICJjYW5ub3QgYWJvcnQgZnJvbSBhIGJyYW5jaCB5ZXQgdG8gYmUgYm9ybiIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkJ2FiYW5kb25uZXIgZGVwdWlzIHVuZSBicmFuY2hlIG5vbiBlbmNvcmUgY3LDqcOpZSIKIAotIzogc2VxdWVuY2VyLmM6Mjc5OCBidWlsdGluL2dyZXAuYzo3MzQKKyM6IHNlcXVlbmNlci5jOjI3MzYgYnVpbHRpbi9ncmVwLmM6NzM2CiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCBvcGVuICclcyciCiBtc2dzdHIgImltcG9zc2libGUgZCdvdXZyaXIgJyVzJyIKIAotIzogc2VxdWVuY2VyLmM6MjgwMAorIzogc2VxdWVuY2VyLmM6MjczOAogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgcmVhZCAnJXMnOiAlcyIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkZSBsaXJlICclcyfCoDogJXMiCiAKLSM6IHNlcXVlbmNlci5jOjI4MDEKKyM6IHNlcXVlbmNlci5jOjI3MzkKIG1zZ2lkICJ1bmV4cGVjdGVkIGVuZCBvZiBmaWxlIgogbXNnc3RyICJmaW4gZGUgZmljaGllciBpbmF0dGVuZHVlIgogCi0jOiBzZXF1ZW5jZXIuYzoyODA3CisjOiBzZXF1ZW5jZXIuYzoyNzQ1CiAjLCBjLWZvcm1hdAogbXNnaWQgInN0b3JlZCBwcmUtY2hlcnJ5LXBpY2sgSEVBRCBmaWxlICclcycgaXMgY29ycnVwdCIKIG1zZ3N0ciAibGUgZmljaGllciBIRUFEIGRlIHByw6lwYXJhdGlvbiBkZSBwaWNvcmFnZSAnJXMnIGVzdCBjb3Jyb21wdSIKIAotIzogc2VxdWVuY2VyLmM6MjgxOAorIzogc2VxdWVuY2VyLmM6Mjc1NgogbXNnaWQgIllvdSBzZWVtIHRvIGhhdmUgbW92ZWQgSEVBRC4gTm90IHJld2luZGluZywgY2hlY2sgeW91ciBIRUFEISIKIG1zZ3N0ciAiIgogIlZvdXMgc2VtYmxleiBhdm9pciBkw6lwbGFjw6kgbGEgSEVBRC4gUGFzIGRlIHJlbWJvYmluYWdlLCB2w6lyaWZpZXogdm90cmUgSEVBRMKgISIKIAotIzogc2VxdWVuY2VyLmM6Mjg1OQorIzogc2VxdWVuY2VyLmM6Mjc5NwogbXNnaWQgIm5vIHJldmVydCBpbiBwcm9ncmVzcyIKIG1zZ3N0ciAiUGFzIGRlIHJldG91ciBlbiBjb3VycyA/IgogCi0jOiBzZXF1ZW5jZXIuYzoyODY3CisjOiBzZXF1ZW5jZXIuYzoyODA1CiBtc2dpZCAibm8gY2hlcnJ5LXBpY2sgaW4gcHJvZ3Jlc3MiCiBtc2dzdHIgImF1Y3VuIHBpY29yYWdlIGVuIGNvdXJzIgogCi0jOiBzZXF1ZW5jZXIuYzoyODc3CisjOiBzZXF1ZW5jZXIuYzoyODE1CiBtc2dpZCAiZmFpbGVkIHRvIHNraXAgdGhlIGNvbW1pdCIKIG1zZ3N0ciAiw6ljaGVjIGR1IHNhdXQgZGUgY29tbWl0IgogCi0jOiBzZXF1ZW5jZXIuYzoyODg0CisjOiBzZXF1ZW5jZXIuYzoyODIyCiBtc2dpZCAidGhlcmUgaXMgbm90aGluZyB0byBza2lwIgogbXNnc3RyICJpbCBuJ3kgYSByaWVuIMOgIHNhdXRlciIKIAotIzogc2VxdWVuY2VyLmM6Mjg4NworIzogc2VxdWVuY2VyLmM6MjgyNQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiaGF2ZSB5b3UgY29tbWl0dGVkIGFscmVhZHk/XG4iCkBAIC02NDc2LDIxICs2NTAxLDIxIEBACiAiQXZlei12b3VzIGTDqWrDoCB2YWxpZMOpwqA/XG4iCiAiZXNzYXlleiBcImdpdCAlcyAtY29udGludWVcIiIKIAotIzogc2VxdWVuY2VyLmM6MzAxMSBzZXF1ZW5jZXIuYzo0MDE1CisjOiBzZXF1ZW5jZXIuYzoyOTQ5IHNlcXVlbmNlci5jOjM5NjkKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHVwZGF0ZSAlcyIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkZSBtZXR0cmUgw6Agam91ciAlcyIKIAotIzogc2VxdWVuY2VyLmM6MzA0OSBzZXF1ZW5jZXIuYzozOTk1CisjOiBzZXF1ZW5jZXIuYzoyOTg3IHNlcXVlbmNlci5jOjM5NDkKIG1zZ2lkICJjYW5ub3QgcmVhZCBIRUFEIgogbXNnc3RyICJpbXBvc3NpYmxlIGRlIGxpcmUgSEVBRCIKIAotIzogc2VxdWVuY2VyLmM6MzA2NgorIzogc2VxdWVuY2VyLmM6MzAwNAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gY29weSAnJXMnIHRvICclcyciCiBtc2dzdHIgImltcG9zc2libGUgZGUgY29waWVyICclcycgdmVycyAnJXMnIgogCi0jOiBzZXF1ZW5jZXIuYzozMDc0CisjOiBzZXF1ZW5jZXIuYzozMDEyCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJZb3UgY2FuIGFtZW5kIHRoZSBjb21taXQgbm93LCB3aXRoXG4iCkBAIC02NTA5LDI3ICs2NTM0LDI3IEBACiAiXG4iCiAiICBnaXQgcmViYXNlIC0tY29udGludWVcbiIKIAotIzogc2VxdWVuY2VyLmM6MzA4NAorIzogc2VxdWVuY2VyLmM6MzAyMgogIywgYy1mb3JtYXQKIG1zZ2lkICJDb3VsZCBub3QgYXBwbHkgJXMuLi4gJS4qcyIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkJ2FwcGxpcXVlciAlcy4uLiAlLipzIgogCi0jOiBzZXF1ZW5jZXIuYzozMDkxCisjOiBzZXF1ZW5jZXIuYzozMDI5CiAjLCBjLWZvcm1hdAogbXNnaWQgIkNvdWxkIG5vdCBtZXJnZSAlLipzIgogbXNnc3RyICJJbXBvc3NpYmxlIGRlIGZ1c2lvbm5lciAlLipzIgogCi0jOiBzZXF1ZW5jZXIuYzozMTA1IHNlcXVlbmNlci5jOjMxMDkgYnVpbHRpbi9kaWZmdG9vbC5jOjYzMworIzogc2VxdWVuY2VyLmM6MzA0MyBzZXF1ZW5jZXIuYzozMDQ3IGJ1aWx0aW4vZGlmZnRvb2wuYzo2NDEKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGNvcHkgJyVzJyB0byAnJXMnIgogbXNnc3RyICJpbXBvc3NpYmxlIGRlIGNvcGllciAnJXMnIHZlcnMgJyVzJyIKIAotIzogc2VxdWVuY2VyLmM6MzEzMSBzZXF1ZW5jZXIuYzozNTU4IGJ1aWx0aW4vcmViYXNlLmM6ODQ5IGJ1aWx0aW4vcmViYXNlLmM6MTU4MgotIzogYnVpbHRpbi9yZWJhc2UuYzoxOTUzIGJ1aWx0aW4vcmViYXNlLmM6MjAwOAorIzogc2VxdWVuY2VyLmM6MzA2OSBzZXF1ZW5jZXIuYzozNTA2IGJ1aWx0aW4vcmViYXNlLmM6ODUwIGJ1aWx0aW4vcmViYXNlLmM6MTYxMworIzogYnVpbHRpbi9yZWJhc2UuYzoxOTg3IGJ1aWx0aW4vcmViYXNlLmM6MjAzMQogbXNnaWQgImNvdWxkIG5vdCByZWFkIGluZGV4IgogbXNnc3RyICJpbXBvc3NpYmxlIGRlIGxpcmUgbCdpbmRleCIKIAotIzogc2VxdWVuY2VyLmM6MzEzNgorIzogc2VxdWVuY2VyLmM6MzA3NAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiZXhlY3V0aW9uIGZhaWxlZDogJXNcbiIKQEAgLTY1NDQsMTEgKzY1NjksMTEgQEAKICJnaXQgcmViYXNlIC0tY29udGludWVcbiIKICJcbiIKIAotIzogc2VxdWVuY2VyLmM6MzE0MgorIzogc2VxdWVuY2VyLmM6MzA4MAogbXNnaWQgImFuZCBtYWRlIGNoYW5nZXMgdG8gdGhlIGluZGV4IGFuZC9vciB0aGUgd29ya2luZyB0cmVlXG4iCiBtc2dzdHIgImV0IGEgbWlzIMOgIGpvdXIgbCdpbmRleCBvdSBsJ2FyYnJlIGRlIHRyYXZhaWxcbiIKIAotIzogc2VxdWVuY2VyLmM6MzE0OAorIzogc2VxdWVuY2VyLmM6MzA4NgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiZXhlY3V0aW9uIHN1Y2NlZWRlZDogJXNcbiIKQEAgLTY1NjUsNzcgKzY1OTAsNzcgQEAKICIgIGdpdCByZWJhc2UgLS1jb250aW51ZVxuIgogIlxuIgogCi0jOiBzZXF1ZW5jZXIuYzozMjA5CisjOiBzZXF1ZW5jZXIuYzozMTQ3CiAjLCBjLWZvcm1hdAogbXNnaWQgImlsbGVnYWwgbGFiZWwgbmFtZTogJyUuKnMnIgogbXNnc3RyICJub20gZGUgbGFiZWwgaWxsw6lnYWwgJyUuKnMnIgogCi0jOiBzZXF1ZW5jZXIuYzozMjYzCisjOiBzZXF1ZW5jZXIuYzozMjAxCiBtc2dpZCAid3JpdGluZyBmYWtlIHJvb3QgY29tbWl0IgogbXNnc3RyICLDqWNyaXR1cmUgZCd1biBjb21taXQgcmFjaW5lIGJpZG9uIgogCi0jOiBzZXF1ZW5jZXIuYzozMjY4CisjOiBzZXF1ZW5jZXIuYzozMjA2CiBtc2dpZCAid3JpdGluZyBzcXVhc2gtb250byIKIG1zZ3N0ciAiw6ljcml0dXJlIGRlICfDqWNyYXNlci1zdXInIgogCi0jOiBzZXF1ZW5jZXIuYzozMzA2IGJ1aWx0aW4vcmViYXNlLmM6ODU0IGJ1aWx0aW4vcmViYXNlLmM6ODYwCisjOiBzZXF1ZW5jZXIuYzozMjQ0IGJ1aWx0aW4vcmViYXNlLmM6ODU1IGJ1aWx0aW4vcmViYXNlLmM6ODYxCiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBmaW5kIHRyZWUgb2YgJXMiCiBtc2dzdHIgImltcG9zc2libGUgZGUgdHJvdXZlciBsJ2FyYnJlIGRlICVzIgogCi0jOiBzZXF1ZW5jZXIuYzozMzI0IGJ1aWx0aW4vcmViYXNlLmM6ODczCisjOiBzZXF1ZW5jZXIuYzozMjYyIGJ1aWx0aW4vcmViYXNlLmM6ODc0CiBtc2dpZCAiY291bGQgbm90IHdyaXRlIGluZGV4IgogbXNnc3RyICJpbXBvc3NpYmxlIGQnw6ljcmlyZSBsJ2luZGV4IgogCi0jOiBzZXF1ZW5jZXIuYzozMzUxCisjOiBzZXF1ZW5jZXIuYzozMjg5CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCByZXNvbHZlICclcyciCiBtc2dzdHIgImltcG9zc2libGUgZGUgcsOpc291ZHJlICclcyciCiAKLSM6IHNlcXVlbmNlci5jOjMzNzkKKyM6IHNlcXVlbmNlci5jOjMzMjAKIG1zZ2lkICJjYW5ub3QgbWVyZ2Ugd2l0aG91dCBhIGN1cnJlbnQgcmV2aXNpb24iCiBtc2dzdHIgImltcG9zc2libGUgZGUgZnVzaW9ubmVyIGF2ZWMgdW5lIHLDqXZpc2lvbiBjb3VyYW50ZSIKIAotIzogc2VxdWVuY2VyLmM6MzQwMQorIzogc2VxdWVuY2VyLmM6MzM0MgogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gcGFyc2UgJyUuKnMnIgogbXNnc3RyICJpbXBvc3NpYmxlIGQnYW5hbHlzZXIgJyUuKnMnIgogCi0jOiBzZXF1ZW5jZXIuYzozNDEwCisjOiBzZXF1ZW5jZXIuYzozMzUxCiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vdGhpbmcgdG8gbWVyZ2U6ICclLipzJyIKIG1zZ3N0ciAicmllbiDDoCBmdXNpb25uZXLCoDogJyUuKnMnIgogCi0jOiBzZXF1ZW5jZXIuYzozNDIyCisjOiBzZXF1ZW5jZXIuYzozMzYzCiBtc2dpZCAib2N0b3B1cyBtZXJnZSBjYW5ub3QgYmUgZXhlY3V0ZWQgb24gdG9wIG9mIGEgW25ldyByb290XSIKIG1zZ3N0ciAiIgogInVuZSBmdXNpb24gb2N0b3B1cyBuZSBwZXV0IHBhcyDDqnRyZSBleMOpY3V0w6llIHBhciBkZXNzdXMgdW5lIG5vdXZlbGxlIHJhY2luZSIKIAotIzogc2VxdWVuY2VyLmM6MzQzNworIzogc2VxdWVuY2VyLmM6MzM3OAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgZ2V0IGNvbW1pdCBtZXNzYWdlIG9mICclcyciCiBtc2dzdHIgImltcG9zc2libGUgZGUgbGlyZSBsZSBtZXNzYWdlIGRlIHZhbGlkYXRpb24gZGUgJyVzJyIKIAotIzogc2VxdWVuY2VyLmM6MzU5MAorIzogc2VxdWVuY2VyLmM6MzUzOAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgZXZlbiBhdHRlbXB0IHRvIG1lcmdlICclLipzJyIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkZSBzZXVsZW1lbnQgZXNzYXllciBkZSBmdXNpb25uZXIgJyUuKnMnIgogCi0jOiBzZXF1ZW5jZXIuYzozNjA2CisjOiBzZXF1ZW5jZXIuYzozNTU0CiBtc2dpZCAibWVyZ2U6IFVuYWJsZSB0byB3cml0ZSBuZXcgaW5kZXggZmlsZSIKIG1zZ3N0ciAiZnVzaW9uwqA6IEltcG9zc2libGUgZCfDqWNyaXJlIGxlIG5vdXZlYXUgZmljaGllciBpbmRleCIKIAotIzogc2VxdWVuY2VyLmM6MzY3NSBidWlsdGluL3JlYmFzZS5jOjcxMQorIzogc2VxdWVuY2VyLmM6MzYyMyBidWlsdGluL3JlYmFzZS5jOjcxMgogIywgYy1mb3JtYXQKIG1zZ2lkICJBcHBsaWVkIGF1dG9zdGFzaC5cbiIKIG1zZ3N0ciAiQXV0b3JlbWlzYWdlIGFwcGxpcXXDqS5cbiIKIAotIzogc2VxdWVuY2VyLmM6MzY4NworIzogc2VxdWVuY2VyLmM6MzYzNQogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3Qgc3RvcmUgJXMiCiBtc2dzdHIgImltcG9zc2libGUgZGUgc3RvY2tlciAlcyIKIAotIzogc2VxdWVuY2VyLmM6MzY5MCBidWlsdGluL3JlYmFzZS5jOjcyNyBnaXQtcmViYXNlLS1wcmVzZXJ2ZS1tZXJnZXMuc2g6MTEzCisjOiBzZXF1ZW5jZXIuYzozNjM4IGJ1aWx0aW4vcmViYXNlLmM6NzI4IGdpdC1yZWJhc2UtLXByZXNlcnZlLW1lcmdlcy5zaDoxMTMKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkFwcGx5aW5nIGF1dG9zdGFzaCByZXN1bHRlZCBpbiBjb25mbGljdHMuXG4iCkBAIC02NjQ2LDMxICs2NjcxLDMxIEBACiAiVm9zICBtb2RpZmljYXRpb25zIHNvbnQgw6AgbCdhYnJpIGRhbnMgbGEgcmVtaXNlLlxuIgogIlZvdXMgcG91dmV6IGxhbmNlciBcImdpdCBzdGFzaCBwb3BcIiBvdSBcImdpdCBzdGFzaCBkcm9wXCIgw6AgdG91dCBtb21lbnQuXG4iCiAKLSM6IHNlcXVlbmNlci5jOjM3NTEKKyM6IHNlcXVlbmNlci5jOjM2OTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGNoZWNrb3V0ICVzIgogbXNnc3RyICJleHRyYWN0aW9uIGRlICVzIGltcG9zc2libGUiCiAKLSM6IHNlcXVlbmNlci5jOjM3NjUKKyM6IHNlcXVlbmNlci5jOjM3MTMKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXM6IG5vdCBhIHZhbGlkIE9JRCIKIG1zZ3N0ciAiJXMgbidlc3QgcGFzIHVuIE9JRCB2YWxpZGUiCiAKLSM6IHNlcXVlbmNlci5jOjM3NzAgZ2l0LXJlYmFzZS0tcHJlc2VydmUtbWVyZ2VzLnNoOjc3OQorIzogc2VxdWVuY2VyLmM6MzcxOCBnaXQtcmViYXNlLS1wcmVzZXJ2ZS1tZXJnZXMuc2g6Nzc5CiBtc2dpZCAiY291bGQgbm90IGRldGFjaCBIRUFEIgogbXNnc3RyICJJbXBvc3NpYmxlIGRlIGTDqXRhY2hlciBIRUFEIgogCi0jOiBzZXF1ZW5jZXIuYzozNzg1CisjOiBzZXF1ZW5jZXIuYzozNzMzCiAjLCBjLWZvcm1hdAogbXNnaWQgIlN0b3BwZWQgYXQgSEVBRFxuIgogbXNnc3RyICJhcnLDqnQgw6AgSEVBRFxuIgogCi0jOiBzZXF1ZW5jZXIuYzozNzg3CisjOiBzZXF1ZW5jZXIuYzozNzM1CiAjLCBjLWZvcm1hdAogbXNnaWQgIlN0b3BwZWQgYXQgJXNcbiIKIG1zZ3N0ciAiQXJyw6p0w6kgw6AgJXNcbiIKIAotIzogc2VxdWVuY2VyLmM6Mzc5NQorIzogc2VxdWVuY2VyLmM6Mzc0MwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiQ291bGQgbm90IGV4ZWN1dGUgdGhlIHRvZG8gY29tbWFuZFxuIgpAQCAtNjY5MSw0OCArNjcxNiw0OCBAQAogIiAgICBnaXQgcmViYXNlIC0tZWRpdC10b2RvXG4iCiAiICAgIGdpdCByZWJhc2UgLS1jb250aW51ZVxuIgogCi0jOiBzZXF1ZW5jZXIuYzozODc3CisjOiBzZXF1ZW5jZXIuYzozODI3CiAjLCBjLWZvcm1hdAogbXNnaWQgIlN0b3BwZWQgYXQgJXMuLi4gICUuKnNcbiIKIG1zZ3N0ciAiYXJyw6p0IMOgICVzLi4uICUuKnNcbiIKIAotIzogc2VxdWVuY2VyLmM6Mzk1OAorIzogc2VxdWVuY2VyLmM6Mzg5OAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmtub3duIGNvbW1hbmQgJWQiCiBtc2dzdHIgImNvbW1hbmRlIGluY29ubnVlICVkIgogCi0jOiBzZXF1ZW5jZXIuYzo0MDAzCisjOiBzZXF1ZW5jZXIuYzozOTU3CiBtc2dpZCAiY291bGQgbm90IHJlYWQgb3JpZy1oZWFkIgogbXNnc3RyICJpbXBvc3NpYmxlIGRlIGxpcmUgb3JpZy1oZWFkIgogCi0jOiBzZXF1ZW5jZXIuYzo0MDA4CisjOiBzZXF1ZW5jZXIuYzozOTYyCiBtc2dpZCAiY291bGQgbm90IHJlYWQgJ29udG8nIgogbXNnc3RyICJpbXBvc3NpYmxlIGRlIGxpcmUgJ29udG8nIgogCi0jOiBzZXF1ZW5jZXIuYzo0MDIyCisjOiBzZXF1ZW5jZXIuYzozOTc2CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCB1cGRhdGUgSEVBRCB0byAlcyIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkZSBtZXR0cmUgw6Agam91ciBIRUFEIHN1ciAlcyIKIAotIzogc2VxdWVuY2VyLmM6NDExNQorIzogc2VxdWVuY2VyLmM6NDA2OQogbXNnaWQgImNhbm5vdCByZWJhc2U6IFlvdSBoYXZlIHVuc3RhZ2VkIGNoYW5nZXMuIgogbXNnc3RyICJpbXBvc3NpYmxlIGRlIHJlYmFzZXLCoDogdm91cyBhdmV6IGRlcyBtb2RpZmljYXRpb25zIG5vbiBpbmRleMOpZXMuIgogCi0jOiBzZXF1ZW5jZXIuYzo0MTI0CisjOiBzZXF1ZW5jZXIuYzo0MDc4CiBtc2dpZCAiY2Fubm90IGFtZW5kIG5vbi1leGlzdGluZyBjb21taXQiCiBtc2dzdHIgImltcG9zc2libGUgZGUgY29ycmlnZXIgdW4gY29tbWl0IG5vbi1leGlzdGFudCIKIAotIzogc2VxdWVuY2VyLmM6NDEyNgorIzogc2VxdWVuY2VyLmM6NDA4MAogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIGZpbGU6ICclcyciCiBtc2dzdHIgImZpY2hpZXIgaW52YWxpZGXCoDogJyVzJyIKIAotIzogc2VxdWVuY2VyLmM6NDEyOAorIzogc2VxdWVuY2VyLmM6NDA4MgogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIGNvbnRlbnRzOiAnJXMnIgogbXNnc3RyICJjb250ZW51IGludmFsaWRlIDogJyVzJyIKIAotIzogc2VxdWVuY2VyLmM6NDEzMQorIzogc2VxdWVuY2VyLmM6NDA4NQogbXNnaWQgIiIKICJcbiIKICJZb3UgaGF2ZSB1bmNvbW1pdHRlZCBjaGFuZ2VzIGluIHlvdXIgd29ya2luZyB0cmVlLiBQbGVhc2UsIGNvbW1pdCB0aGVtXG4iCkBAIC02NzQyLDQyICs2NzY3LDQyIEBACiAiVm91cyBhdmV6IGRlcyBtb2RpZmljYXRpb25zIG5vbiB2YWxpZMOpZXMgZGFucyB2b3RyZSBjb3BpZSBkZSB0cmF2YWlsLlxuIgogIlZldWlsbGV6IGxlcyB2YWxpZGVyIGQnYWJvcmQsIHB1aXMgcmVsYW5jZXIgJ2dpdCByZWJhc2UgLS1jb250aW51ZScuIgogCi0jOiBzZXF1ZW5jZXIuYzo0MTY3IHNlcXVlbmNlci5jOjQyMDUKKyM6IHNlcXVlbmNlci5jOjQxMjEgc2VxdWVuY2VyLmM6NDE1OQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3Qgd3JpdGUgZmlsZTogJyVzJyIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkJ8OpY3JpcmUgbGUgZmljaGllcsKgOiAnJXMnIgogCi0jOiBzZXF1ZW5jZXIuYzo0MjIwCisjOiBzZXF1ZW5jZXIuYzo0MTc0CiBtc2dpZCAiY291bGQgbm90IHJlbW92ZSBDSEVSUllfUElDS19IRUFEIgogbXNnc3RyICJpbXBvc3NpYmxlIGRlIHN1cHByaW1lciBDSEVSUllfUElDS19IRUFEIgogCi0jOiBzZXF1ZW5jZXIuYzo0MjI3CisjOiBzZXF1ZW5jZXIuYzo0MTgxCiBtc2dpZCAiY291bGQgbm90IGNvbW1pdCBzdGFnZWQgY2hhbmdlcy4iCiBtc2dzdHIgImltcG9zc2libGUgZGUgdmFsaWRlciBsZXMgbW9kaWZpY2F0aW9ucyBpbmRleMOpZXMuIgogCi0jOiBzZXF1ZW5jZXIuYzo0MzI4CisjOiBzZXF1ZW5jZXIuYzo0Mjg1CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiBjYW4ndCBjaGVycnktcGljayBhICVzIgogbXNnc3RyICIlcyA6IGltcG9zc2libGUgZGUgcGljb3JlciB1biAlcyIKIAotIzogc2VxdWVuY2VyLmM6NDMzMgorIzogc2VxdWVuY2VyLmM6NDI4OQogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogYmFkIHJldmlzaW9uIgogbXNnc3RyICIlcyA6IG1hdXZhaXNlIHLDqXZpc2lvbiIKIAotIzogc2VxdWVuY2VyLmM6NDM2NworIzogc2VxdWVuY2VyLmM6NDMyNAogbXNnaWQgImNhbid0IHJldmVydCBhcyBpbml0aWFsIGNvbW1pdCIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkJ2FubnVsZXIgZW4gdGFudCBxdWUgY29tbWl0IGluaXRpYWwiCiAKLSM6IHNlcXVlbmNlci5jOjQ4MTAKKyM6IHNlcXVlbmNlci5jOjQ3NzQKIG1zZ2lkICJtYWtlX3NjcmlwdDogdW5oYW5kbGVkIG9wdGlvbnMiCiBtc2dzdHIgIm1ha2Vfc2NyaXB0wqA6IG9wdGlvbnMgbm9uIGfDqXLDqWVzIgogCi0jOiBzZXF1ZW5jZXIuYzo0ODEzCisjOiBzZXF1ZW5jZXIuYzo0Nzc3CiBtc2dpZCAibWFrZV9zY3JpcHQ6IGVycm9yIHByZXBhcmluZyByZXZpc2lvbnMiCiBtc2dzdHIgIm1ha2Vfc2NyaXB0wqA6IGVycmV1ciBsb3JzIGRlIGxhIHByw6lwYXJhdGlvbiBkZXMgcsOpdmlzaW9ucyIKIAotIzogc2VxdWVuY2VyLmM6NDk3MQorIzogc2VxdWVuY2VyLmM6NDkzNQogbXNnaWQgIiIKICJZb3UgY2FuIGZpeCB0aGlzIHdpdGggJ2dpdCByZWJhc2UgLS1lZGl0LXRvZG8nIGFuZCB0aGVuIHJ1biAnZ2l0IHJlYmFzZSAtLSIKICJjb250aW51ZScuXG4iCkBAIC02Nzg3LDI0ICs2ODEyLDI0IEBACiAicmViYXNlIC0tY29udGludWUnLlxuIgogIk91IHZvdXMgcG91dmV6IGFiYW5kb25uZXIgbGUgcmViYXNhZ2UgYXZlYyAnZ2l0IHJlYmFzZSAtLWFib3J0Jy5cbiIKIAotIzogc2VxdWVuY2VyLmM6NTA4MyBzZXF1ZW5jZXIuYzo1MTAwCisjOiBzZXF1ZW5jZXIuYzo1MDQ3IHNlcXVlbmNlci5jOjUwNjQKIG1zZ2lkICJub3RoaW5nIHRvIGRvIgogbXNnc3RyICJyaWVuIMOgIGZhaXJlIgogCi0jOiBzZXF1ZW5jZXIuYzo1MTE0CisjOiBzZXF1ZW5jZXIuYzo1MDc4CiBtc2dpZCAiY291bGQgbm90IHNraXAgdW5uZWNlc3NhcnkgcGljayBjb21tYW5kcyIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkJ8Opdml0ZXIgbGVzIGNvbW1hbmRlcyBkZSBwaWNvcmFnZSBub24gbsOpY2Vzc2FpcmVzIgogCi0jOiBzZXF1ZW5jZXIuYzo1MTk3CisjOiBzZXF1ZW5jZXIuYzo1MTY2CiBtc2dpZCAidGhlIHNjcmlwdCB3YXMgYWxyZWFkeSByZWFycmFuZ2VkLiIKIG1zZ3N0ciAibGUgc2NyaXB0IGEgZMOpasOgIMOpdMOpIHLDqWFycmFuZ8OpLiIKIAotIzogc2V0dXAuYzoxMjMKKyM6IHNldHVwLmM6MTI0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiclcycgaXMgb3V0c2lkZSByZXBvc2l0b3J5IgogbXNnc3RyICInJXMnIGVzdCBob3JzIGR1IGTDqXDDtHQiCiAKLSM6IHNldHVwLmM6MTczCisjOiBzZXR1cC5jOjE3NAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiJXM6IG5vIHN1Y2ggcGF0aCBpbiB0aGUgd29ya2luZyB0cmVlLlxuIgpAQCAtNjgxNCw3ICs2ODM5LDcgQEAKICJVdGlsaXNleiAnZ2l0IDxjb21tYW5kZT4gLS0gPGNoZW1pbj4uLi4nIHBvdXIgc3DDqWNpZmllciBkZXMgY2hlbWlucyBxdWkgIgogIm4nZXhpc3RlbnQgcGFzIGxvY2FsZW1lbnQuIgogCi0jOiBzZXR1cC5jOjE4NgorIzogc2V0dXAuYzoxODcKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogImFtYmlndW91cyBhcmd1bWVudCAnJXMnOiB1bmtub3duIHJldmlzaW9uIG9yIHBhdGggbm90IGluIHRoZSB3b3JraW5nIHRyZWUuXG4iCkBAIC02ODI1LDE0ICs2ODUwLDE0IEBACiAiVXRpbGlzZXogJy0tJyBwb3VyIHPDqXBhcmVyIGxlcyBjaGVtaW5zIGRlcyByw6l2aXNpb25zLCBjb21tZSBjZWNpwqA6XG4iCiAiJ2dpdCA8Y29tbWFuZGU+IFs8csOpdmlzaW9uPi4uLl0gLS0gWzxjaGVtaW4+Li4uXSciCiAKLSM6IHNldHVwLmM6MjM1CisjOiBzZXR1cC5jOjIzNgogIywgYy1mb3JtYXQKIG1zZ2lkICJvcHRpb24gJyVzJyBtdXN0IGNvbWUgYmVmb3JlIG5vbi1vcHRpb24gYXJndW1lbnRzIgogbXNnc3RyICIiCiAibCdvcHRpb24gJyVzJyBkb2l0IMOqdHJlIHByw6lzZW50ZSBhdmFudCBsZXMgYXJndW1lbnRzIHF1aSBuZSBzb250IHBhcyBkZXMgIgogIm9wdGlvbnMiCiAKLSM6IHNldHVwLmM6MjU0CisjOiBzZXR1cC5jOjI1NQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiYW1iaWd1b3VzIGFyZ3VtZW50ICclcyc6IGJvdGggcmV2aXNpb24gYW5kIGZpbGVuYW1lXG4iCkBAIC02ODQzLDk0ICs2ODY4LDk0IEBACiAiVXRpbGlzZXogJy0tJyBwb3VyIHPDqXBhcmVyIGxlcyBjaGVtaW5zIGRlcyByw6l2aXNpb25zLCBjb21tZSBjZWNpwqA6XG4iCiAiJ2dpdCA8Y29tbWFuZGU+IFs8csOpdmlzaW9uPi4uLl0gLS0gWzxjaGVtaW4+Li4uXSciCiAKLSM6IHNldHVwLmM6MzkwCisjOiBzZXR1cC5jOjM5MQogbXNnaWQgInVuYWJsZSB0byBzZXQgdXAgd29yayB0cmVlIHVzaW5nIGludmFsaWQgY29uZmlnIgogbXNnc3RyICIiCiAiaW1wb3NzaWJsZSBkZSBtZXR0cmUgZW4gcGxhY2UgbGUgcsOpcGVydG9pcmUgZGUgdHJhdmFpbCBlbiB1dGlsaXNhbnQgdW5lICIKICJjb25maWd1cmF0aW9uIGludmFsaWRlIgogCi0jOiBzZXR1cC5jOjM5NAorIzogc2V0dXAuYzozOTUKIG1zZ2lkICJ0aGlzIG9wZXJhdGlvbiBtdXN0IGJlIHJ1biBpbiBhIHdvcmsgdHJlZSIKIG1zZ3N0ciAiQ2V0dGUgb3DDqXJhdGlvbiBkb2l0IMOqdHJlIGVmZmVjdHXDqWUgZGFucyB1biBhcmJyZSBkZSB0cmF2YWlsIgogCi0jOiBzZXR1cC5jOjU0MAorIzogc2V0dXAuYzo1NDEKICMsIGMtZm9ybWF0CiBtc2dpZCAiRXhwZWN0ZWQgZ2l0IHJlcG8gdmVyc2lvbiA8PSAlZCwgZm91bmQgJWQiCiBtc2dzdHIgIlZlcnNpb24gYXR0ZW5kdWUgZHUgZMOpcMO0dCBnaXQgPD0gJWQsICVkIHRyb3V2w6llIgogCi0jOiBzZXR1cC5jOjU0OAorIzogc2V0dXAuYzo1NDkKIG1zZ2lkICJ1bmtub3duIHJlcG9zaXRvcnkgZXh0ZW5zaW9ucyBmb3VuZDoiCiBtc2dzdHIgImV4dGVuc2lvbnMgZGUgZMOpcMO0dCBpbmNvbm51ZXMgdHJvdXbDqWVzwqA6IgogCi0jOiBzZXR1cC5jOjU2NworIzogc2V0dXAuYzo1NjgKICMsIGMtZm9ybWF0CiBtc2dpZCAiZXJyb3Igb3BlbmluZyAnJXMnIgogbXNnc3RyICJlcnJldXIgw6AgbCdvdXZlcnR1cmUgZGUgJyVzJyIKIAotIzogc2V0dXAuYzo1NjkKKyM6IHNldHVwLmM6NTcwCiAjLCBjLWZvcm1hdAogbXNnaWQgInRvbyBsYXJnZSB0byBiZSBhIC5naXQgZmlsZTogJyVzJyIKIG1zZ3N0ciAidHJvcCBncm9zIHBvdXIgw6p0cmUgdW5lIGZpY2hpZXIgLmdpdMKgOiAnJXMnIgogCi0jOiBzZXR1cC5jOjU3MQorIzogc2V0dXAuYzo1NzIKICMsIGMtZm9ybWF0CiBtc2dpZCAiZXJyb3IgcmVhZGluZyAlcyIKIG1zZ3N0ciAiZXJyZXVyIMOgIGxhIGxlY3R1cmUgZGUgJXMiCiAKLSM6IHNldHVwLmM6NTczCisjOiBzZXR1cC5jOjU3NAogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIGdpdGZpbGUgZm9ybWF0OiAlcyIKIG1zZ3N0ciAiZm9ybWF0IGRlIGZpY2hpZXIgZ2l0IGludmFsaWRlIDogJXMiCiAKLSM6IHNldHVwLmM6NTc1CisjOiBzZXR1cC5jOjU3NgogIywgYy1mb3JtYXQKIG1zZ2lkICJubyBwYXRoIGluIGdpdGZpbGU6ICVzIgogbXNnc3RyICJhdWN1biBjaGVtaW4gZGFucyBsZSBmaWNoaWVyIGdpdMKgOiAlcyIKIAotIzogc2V0dXAuYzo1NzcKKyM6IHNldHVwLmM6NTc4CiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vdCBhIGdpdCByZXBvc2l0b3J5OiAlcyIKIG1zZ3N0ciAiY2Ugbidlc3QgcGFzIHVuIGTDqXDDtHQgZ2l0wqA6ICVzIgogCi0jOiBzZXR1cC5jOjY3NgorIzogc2V0dXAuYzo2NzcKICMsIGMtZm9ybWF0CiBtc2dpZCAiJyQlcycgdG9vIGJpZyIKIG1zZ3N0ciAiJyQlcycgdHJvcCBncm9zIgogCi0jOiBzZXR1cC5jOjY5MAorIzogc2V0dXAuYzo2OTEKICMsIGMtZm9ybWF0CiBtc2dpZCAibm90IGEgZ2l0IHJlcG9zaXRvcnk6ICclcyciCiBtc2dzdHIgImNlIG4nZXN0IHBhcyB1biBkw6lww7R0IGdpdCA6ICclcyciCiAKLSM6IHNldHVwLmM6NzE5IHNldHVwLmM6NzIxIHNldHVwLmM6NzUyCisjOiBzZXR1cC5jOjcyMCBzZXR1cC5jOjcyMiBzZXR1cC5jOjc1MwogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgY2hkaXIgdG8gJyVzJyIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkZSBzZSBkw6lwbGFjZXIgdmVycyBsZSByw6lwZXJ0b2lyZSAoY2hkaXIpICclcyciCiAKLSM6IHNldHVwLmM6NzI0IHNldHVwLmM6NzgwIHNldHVwLmM6NzkwIHNldHVwLmM6ODI5IHNldHVwLmM6ODM3CisjOiBzZXR1cC5jOjcyNSBzZXR1cC5jOjc4MSBzZXR1cC5jOjc5MSBzZXR1cC5jOjgzMCBzZXR1cC5jOjgzOAogbXNnaWQgImNhbm5vdCBjb21lIGJhY2sgdG8gY3dkIgogbXNnc3RyICJpbXBvc3NpYmxlIGRlIHJldmVuaXIgYXUgcsOpcGVydG9pcmUgZGUgdHJhdmFpbCBjb3VyYW50IgogCi0jOiBzZXR1cC5jOjg1MQorIzogc2V0dXAuYzo4NTIKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIHN0YXQgJyUqcyVzJXMnIgogbXNnc3RyICLDqWNoZWMgZHUgc3RhdCBkZSAnJSpzJXMlcyciCiAKLSM6IHNldHVwLmM6MTA4MworIzogc2V0dXAuYzoxMDkwCiBtc2dpZCAiVW5hYmxlIHRvIHJlYWQgY3VycmVudCB3b3JraW5nIGRpcmVjdG9yeSIKIG1zZ3N0ciAiSW1wb3NzaWJsZSBkJ2FjY8OpZGVyIGF1IHLDqXBlcnRvaXJlIGRlIHRyYXZhaWwgY291cmFudCIKIAotIzogc2V0dXAuYzoxMDkyIHNldHVwLmM6MTA5OAorIzogc2V0dXAuYzoxMDk5IHNldHVwLmM6MTEwNQogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgY2hhbmdlIHRvICclcyciCiBtc2dzdHIgImltcG9zc2libGUgZGUgbW9kaWZpZXIgZW4gJyVzJyIKIAotIzogc2V0dXAuYzoxMTAzCisjOiBzZXR1cC5jOjExMTAKICMsIGMtZm9ybWF0CiBtc2dpZCAibm90IGEgZ2l0IHJlcG9zaXRvcnkgKG9yIGFueSBvZiB0aGUgcGFyZW50IGRpcmVjdG9yaWVzKTogJXMiCiBtc2dzdHIgIm5pIGNlY2kgbmkgYXVjdW4gZGUgc2VzIHLDqXBlcnRvaXJlcyBwYXJlbnRzIG4nZXN0IHVuIGTDqXDDtHQgZ2l0wqA6ICVzIgogCi0jOiBzZXR1cC5jOjExMDkKKyM6IHNldHVwLmM6MTExNgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAibm90IGEgZ2l0IHJlcG9zaXRvcnkgKG9yIGFueSBwYXJlbnQgdXAgdG8gbW91bnQgcG9pbnQgJXMpXG4iCkBAIC02OTQxLDcgKzY5NjYsNyBAQAogIkFycsOqdCDDoCBsYSBsaW1pdGUgZHUgc3lzdMOobWUgZGUgZmljaGllcnMgKEdJVF9ESVNDT1ZFUllfQUNST1NTX0ZJTEVTWVNURU0gIgogIm4nZXN0IHBhcyBkw6lmaW5pKS4iCiAKLSM6IHNldHVwLmM6MTIyMAorIzogc2V0dXAuYzoxMjI3CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJwcm9ibGVtIHdpdGggY29yZS5zaGFyZWRSZXBvc2l0b3J5IGZpbGVtb2RlIHZhbHVlICgwJS4zbykuXG4iCkBAIC02OTUxLDI4NiArNjk3NiwyODYgQEAKICJMZSBwcm9wcmnDqXRhaXJlIGRlcyBmaWNoaWVycyBkb2l0IHRvdWpvdXJzIGF2b2lyIGxlcyBkcm9pdHMgZW4gbGVjdHVyZSBldCAiCiAiw6ljcml0dXJlLiIKIAotIzogc2V0dXAuYzoxMjY0CisjOiBzZXR1cC5jOjEyNzEKIG1zZ2lkICJvcGVuIC9kZXYvbnVsbCBvciBkdXAgZmFpbGVkIgogbXNnc3RyICLDqWNoZWMgZGUgbCdvdXZlcnR1cmUgb3UgYXUgZHVwIGRlIC9kZXYvbnVsbCIKIAotIzogc2V0dXAuYzoxMjc5CisjOiBzZXR1cC5jOjEyODYKIG1zZ2lkICJmb3JrIGZhaWxlZCIKIG1zZ3N0ciAiw6ljaGVjIGRlIGxhIGJpZnVyY2F0aW9uIgogCi0jOiBzZXR1cC5jOjEyODQKKyM6IHNldHVwLmM6MTI5MQogbXNnaWQgInNldHNpZCBmYWlsZWQiCiBtc2dzdHIgIsOpY2hlYyBkdSBzZXRzaWQiCiAKLSM6IHNoYTEtZmlsZS5jOjQ1MworIzogc2hhMS1maWxlLmM6NDUyCiAjLCBjLWZvcm1hdAogbXNnaWQgIm9iamVjdCBkaXJlY3RvcnkgJXMgZG9lcyBub3QgZXhpc3Q7IGNoZWNrIC5naXQvb2JqZWN0cy9pbmZvL2FsdGVybmF0ZXMiCiBtc2dzdHIgIiIKICJsZSByw6lwZXJ0b2lyZSBvYmpldCAlcyBuJ2V4aXN0ZSBwYXPCoDsgdsOpcmlmaWV6IC5naXQvb2JqZWN0cy9pbmZvL2FsdGVybmF0ZXMiCiAKLSM6IHNoYTEtZmlsZS5jOjUwNAorIzogc2hhMS1maWxlLmM6NTAzCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBub3JtYWxpemUgYWx0ZXJuYXRlIG9iamVjdCBwYXRoOiAlcyIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkZSBub3JtYWxpc2VyIGxlIGNoZW1pbiBkJ29iamV0IGFsdGVybmF0aWbCoDogJXMiCiAKLSM6IHNoYTEtZmlsZS5jOjU3NgorIzogc2hhMS1maWxlLmM6NTc1CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiBpZ25vcmluZyBhbHRlcm5hdGUgb2JqZWN0IHN0b3JlcywgbmVzdGluZyB0b28gZGVlcCIKIG1zZ3N0ciAiJXPCoDogbWFnYXNpbnMgZCdvYmpldHMgYWx0ZXJuYXRpZnMgaWdub3LDqXMsIHLDqWN1cnNpb24gdHJvcCBwcm9mb25kZSIKIAotIzogc2hhMS1maWxlLmM6NTgzCisjOiBzaGExLWZpbGUuYzo1ODIKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIG5vcm1hbGl6ZSBvYmplY3QgZGlyZWN0b3J5OiAlcyIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkZSBub3JtYWxpc2VyIGxlIHLDqXBlcnRvaXJlIGQnb2JqZXTCoDogJXMiCiAKLSM6IHNoYTEtZmlsZS5jOjYyNgorIzogc2hhMS1maWxlLmM6NjI1CiBtc2dpZCAidW5hYmxlIHRvIGZkb3BlbiBhbHRlcm5hdGVzIGxvY2tmaWxlIgogbXNnc3RyICJpbXBvc3NpYmxlIGQnb3V2cmlyIChmZG9wZW4pIGxlIGZpY2hpZXIgdmVycm91IGRlcyBhbHRlcm5hdGl2ZXMiCiAKLSM6IHNoYTEtZmlsZS5jOjY0NAorIzogc2hhMS1maWxlLmM6NjQzCiBtc2dpZCAidW5hYmxlIHRvIHJlYWQgYWx0ZXJuYXRlcyBmaWxlIgogbXNnc3RyICJsZWN0dXJlIGR1IGZpY2hpZXIgZCdhbHRlcm5hdGl2ZXMgaW1wb3NzaWJsZSIKIAotIzogc2hhMS1maWxlLmM6NjUxCisjOiBzaGExLWZpbGUuYzo2NTAKIG1zZ2lkICJ1bmFibGUgdG8gbW92ZSBuZXcgYWx0ZXJuYXRlcyBmaWxlIGludG8gcGxhY2UiCiBtc2dzdHIgImltcG9zc2libGUgZGUgZMOpcGxhY2VyIGxlIG5vdXZlYXUgZmljaGllciBkJ2FsdGVybmF0aXZlIgogCi0jOiBzaGExLWZpbGUuYzo2ODYKKyM6IHNoYTEtZmlsZS5jOjY4NQogIywgYy1mb3JtYXQKIG1zZ2lkICJwYXRoICclcycgZG9lcyBub3QgZXhpc3QiCiBtc2dzdHIgImxlIGNoZW1pbiAnJXMnIG4nZXhpc3RlIHBhcyIKIAotIzogc2hhMS1maWxlLmM6NzEyCisjOiBzaGExLWZpbGUuYzo3MTEKICMsIGMtZm9ybWF0CiBtc2dpZCAicmVmZXJlbmNlIHJlcG9zaXRvcnkgJyVzJyBhcyBhIGxpbmtlZCBjaGVja291dCBpcyBub3Qgc3VwcG9ydGVkIHlldC4iCiBtc2dzdHIgIiIKICJleHRyYWlyZSBsZSBkw6lww7R0IGRlIHLDqWbDqXJlbmNlICclcycgY29tbWUgdW5lIGV4dHJhY3Rpb24gbGnDqWUgbidlc3QgcGFzICIKICJlbmNvcmUgc3VwcG9ydMOpLiIKIAotIzogc2hhMS1maWxlLmM6NzE4CisjOiBzaGExLWZpbGUuYzo3MTcKICMsIGMtZm9ybWF0CiBtc2dpZCAicmVmZXJlbmNlIHJlcG9zaXRvcnkgJyVzJyBpcyBub3QgYSBsb2NhbCByZXBvc2l0b3J5LiIKIG1zZ3N0ciAibGUgZMOpcMO0dCBkZSByw6lmw6lyZW5jZSAnJXMnIG4nZXN0IHBhcyB1biBkw6lww7R0IGxvY2FsLiIKIAotIzogc2hhMS1maWxlLmM6NzI0CisjOiBzaGExLWZpbGUuYzo3MjMKICMsIGMtZm9ybWF0CiBtc2dpZCAicmVmZXJlbmNlIHJlcG9zaXRvcnkgJyVzJyBpcyBzaGFsbG93IgogbXNnc3RyICJsZSBkw6lww7R0IGRlIHLDqWbDqXJlbmNlICclcycgZXN0IHN1cGVyZmljaWVsIgogCi0jOiBzaGExLWZpbGUuYzo3MzIKKyM6IHNoYTEtZmlsZS5jOjczMQogIywgYy1mb3JtYXQKIG1zZ2lkICJyZWZlcmVuY2UgcmVwb3NpdG9yeSAnJXMnIGlzIGdyYWZ0ZWQiCiBtc2dzdHIgImxlIGTDqXDDtHQgZGUgcsOpZsOpcmVuY2UgJyVzJyBlc3QgZ3JlZmbDqSIKIAotIzogc2hhMS1maWxlLmM6NzkyCisjOiBzaGExLWZpbGUuYzo3OTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBsaW5lIHdoaWxlIHBhcnNpbmcgYWx0ZXJuYXRlIHJlZnM6ICVzIgogbXNnc3RyICJsaWduZSBpbnZhbGlkZSBwZW5kYW50IGwnYW5hbHlzZSBkZXMgcmVmcyBhbHRlcm5hdGl2ZXPCoDogJXMiCiAKLSM6IHNoYTEtZmlsZS5jOjk0NAorIzogc2hhMS1maWxlLmM6OTQzCiAjLCBjLWZvcm1hdAogbXNnaWQgImF0dGVtcHRpbmcgdG8gbW1hcCAlPFBSSXVNQVg+IG92ZXIgbGltaXQgJTxQUkl1TUFYPiIKIG1zZ3N0ciAiZXNzYWkgZGUgbW1hcCAlPFBSSXVNQVg+IGF1IGRlbMOgIGRlIGxhIGxpbWl0ZSAlPFBSSXVNQVg+IgogCi0jOiBzaGExLWZpbGUuYzo5NjkKKyM6IHNoYTEtZmlsZS5jOjk2NAogbXNnaWQgIm1tYXAgZmFpbGVkIgogbXNnc3RyICLDqWNoZWMgZGUgbW1hcCIKIAotIzogc2hhMS1maWxlLmM6MTEzMworIzogc2hhMS1maWxlLmM6MTEyOAogIywgYy1mb3JtYXQKIG1zZ2lkICJvYmplY3QgZmlsZSAlcyBpcyBlbXB0eSIKIG1zZ3N0ciAibGUgZmljaGllciBvYmpldCAlcyBlc3QgdmlkZSIKIAotIzogc2hhMS1maWxlLmM6MTI1NyBzaGExLWZpbGUuYzoyMzk2CisjOiBzaGExLWZpbGUuYzoxMjUyIHNoYTEtZmlsZS5jOjIzOTIKICMsIGMtZm9ybWF0CiBtc2dpZCAiY29ycnVwdCBsb29zZSBvYmplY3QgJyVzJyIKIG1zZ3N0ciAib2JqZXQgbGlicmUgY29ycm9tcHUgJyVzJyIKIAotIzogc2hhMS1maWxlLmM6MTI1OSBzaGExLWZpbGUuYzoyNDAwCisjOiBzaGExLWZpbGUuYzoxMjU0IHNoYTEtZmlsZS5jOjIzOTYKICMsIGMtZm9ybWF0CiBtc2dpZCAiZ2FyYmFnZSBhdCBlbmQgb2YgbG9vc2Ugb2JqZWN0ICclcyciCiBtc2dzdHIgImRvbm7DqWVzIGluY29ycmVjdGVzIMOgIGxhIGZpbiBkZSBsJ29iamV0IGxpYnJlICclcyciCiAKLSM6IHNoYTEtZmlsZS5jOjEzMDEKKyM6IHNoYTEtZmlsZS5jOjEyOTYKIG1zZ2lkICJpbnZhbGlkIG9iamVjdCB0eXBlIgogbXNnc3RyICJ0eXBlIGQnb2JqZXQgaW52YWxpZGUiCiAKLSM6IHNoYTEtZmlsZS5jOjEzODUKKyM6IHNoYTEtZmlsZS5jOjEzODAKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHVucGFjayAlcyBoZWFkZXIgd2l0aCAtLWFsbG93LXVua25vd24tdHlwZSIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkZSBkw6lwYXF1ZXRlciBsJ2VudMOqdGUgJXMgYXZlYyAtLWFsbG93LXVua25vdy10eXBlIgogCi0jOiBzaGExLWZpbGUuYzoxMzg4CisjOiBzaGExLWZpbGUuYzoxMzgzCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byB1bnBhY2sgJXMgaGVhZGVyIgogbXNnc3RyICJpbXBvc3NpYmxlIGRlIGTDqXBhcXVldGVyIGwnZW50w6p0ZSAlcyIKIAotIzogc2hhMS1maWxlLmM6MTM5NAorIzogc2hhMS1maWxlLmM6MTM4OQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gcGFyc2UgJXMgaGVhZGVyIHdpdGggLS1hbGxvdy11bmtub3duLXR5cGUiCiBtc2dzdHIgImltcG9zc2libGUgZCdhbmFseXNlciBsJ2VudMOqdGUgJXMgYXZlYyAtLWFsbG93LXVua25vdy10eXBlIgogCi0jOiBzaGExLWZpbGUuYzoxMzk3CisjOiBzaGExLWZpbGUuYzoxMzkyCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBwYXJzZSAlcyBoZWFkZXIiCiBtc2dzdHIgImltcG9zc2libGUgZCdhbmFseXNlciBsJ2VudMOqdGUgJXMiCiAKLSM6IHNoYTEtZmlsZS5jOjE1ODgKKyM6IHNoYTEtZmlsZS5jOjE1ODQKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIHJlYWQgb2JqZWN0ICVzIgogbXNnc3RyICJpbXBvc3NpYmxlIGRlIGxpcmUgbCdvYmpldCAlcyIKIAotIzogc2hhMS1maWxlLmM6MTU5MgorIzogc2hhMS1maWxlLmM6MTU4OAogIywgYy1mb3JtYXQKIG1zZ2lkICJyZXBsYWNlbWVudCAlcyBub3QgZm91bmQgZm9yICVzIgogbXNnc3RyICJyZW1wbGFjZW1lbnQgJXMgbm9uIHRyb3V2w6kgcG91ciAlcyIKIAotIzogc2hhMS1maWxlLmM6MTU5NgorIzogc2hhMS1maWxlLmM6MTU5MgogIywgYy1mb3JtYXQKIG1zZ2lkICJsb29zZSBvYmplY3QgJXMgKHN0b3JlZCBpbiAlcykgaXMgY29ycnVwdCIKIG1zZ3N0ciAibCdvYmpldCBsaWJyZSAlcyAoc3RvY2vDqSBkYW5zICVzKSBlc3QgY29ycm9tcHUiCiAKLSM6IHNoYTEtZmlsZS5jOjE2MDAKKyM6IHNoYTEtZmlsZS5jOjE1OTYKICMsIGMtZm9ybWF0CiBtc2dpZCAicGFja2VkIG9iamVjdCAlcyAoc3RvcmVkIGluICVzKSBpcyBjb3JydXB0IgogbXNnc3RyICJsJ29iamV0IGVtcGFxdWV0w6kgJXMgKHN0b2Nrw6kgZGFucyAlcykgZXN0IGNvcnJvbXB1IgogCi0jOiBzaGExLWZpbGUuYzoxNzAzCisjOiBzaGExLWZpbGUuYzoxNjk5CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byB3cml0ZSBmaWxlICVzIgogbXNnc3RyICJpbXBvc3NpYmxlIGQnw6ljcmlyZSBsZSBmaWNoaWVyICVzIgogCi0jOiBzaGExLWZpbGUuYzoxNzEwCisjOiBzaGExLWZpbGUuYzoxNzA2CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBzZXQgcGVybWlzc2lvbiB0byAnJXMnIgogbXNnc3RyICJpbXBvc3NpYmxlIGRlIHLDqWdsZXIgbGVzIGRyb2l0cyBkZSAnJXMnIgogCi0jOiBzaGExLWZpbGUuYzoxNzE3CisjOiBzaGExLWZpbGUuYzoxNzEzCiBtc2dpZCAiZmlsZSB3cml0ZSBlcnJvciIKIG1zZ3N0ciAiZXJyZXVyIGQnw6ljcml0dXJlIGQndW4gZmljaGllciIKIAotIzogc2hhMS1maWxlLmM6MTczNgorIzogc2hhMS1maWxlLmM6MTczMgogbXNnaWQgImVycm9yIHdoZW4gY2xvc2luZyBsb29zZSBvYmplY3QgZmlsZSIKIG1zZ3N0ciAiZXJyZXVyIGVuIGZlcm1ldHVyZSBkdSBmaWNoaWVyIGQnb2JqZXQgZXNzZXVsw6kiCiAKLSM6IHNoYTEtZmlsZS5jOjE4MDEKKyM6IHNoYTEtZmlsZS5jOjE3OTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW5zdWZmaWNpZW50IHBlcm1pc3Npb24gZm9yIGFkZGluZyBhbiBvYmplY3QgdG8gcmVwb3NpdG9yeSBkYXRhYmFzZSAlcyIKIG1zZ3N0ciAiIgogImRyb2l0cyBpbnN1ZmZpc2FudHMgcG91ciBham91dGVyIHVuIG9iamV0IMOgIGxhIGJhc2UgZGUgZG9ubsOpZXMgJXMgZHUgZMOpcMO0dCIKIAotIzogc2hhMS1maWxlLmM6MTgwMworIzogc2hhMS1maWxlLmM6MTc5OQogbXNnaWQgInVuYWJsZSB0byBjcmVhdGUgdGVtcG9yYXJ5IGZpbGUiCiBtc2dzdHIgImltcG9zc2libGUgZGUgY3LDqWVyIHVuIGZpY2hpZXIgdGVtcG9yYWlyZSIKIAotIzogc2hhMS1maWxlLmM6MTgyNworIzogc2hhMS1maWxlLmM6MTgyMwogbXNnaWQgInVuYWJsZSB0byB3cml0ZSBsb29zZSBvYmplY3QgZmlsZSIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkJ8OpY3JpcmUgbGUgZmljaGllciBkJ29iamV0IGVzc2V1bMOpIgogCi0jOiBzaGExLWZpbGUuYzoxODMzCisjOiBzaGExLWZpbGUuYzoxODI5CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBkZWZsYXRlIG5ldyBvYmplY3QgJXMgKCVkKSIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkZSBjb21wcmVzc2VyIGxlIG5vdXZlbCBvYmpldCAlcyAoJWQpIgogCi0jOiBzaGExLWZpbGUuYzoxODM3CisjOiBzaGExLWZpbGUuYzoxODMzCiAjLCBjLWZvcm1hdAogbXNnaWQgImRlZmxhdGVFbmQgb24gb2JqZWN0ICVzIGZhaWxlZCAoJWQpIgogbXNnc3RyICLDqWNoZWMgZGUgZGVmbGF0ZUVuZCBzdXIgbCdvYmpldCAlcyAoJWQpIgogCi0jOiBzaGExLWZpbGUuYzoxODQxCisjOiBzaGExLWZpbGUuYzoxODM3CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvbmZ1c2VkIGJ5IHVuc3RhYmxlIG9iamVjdCBzb3VyY2UgZGF0YSBmb3IgJXMiCiBtc2dzdHIgImRvbm7DqWVzIGRlIHNvdXJjZSBkJ29iamV0IGluc3RhYmxlIHBvdXIgJXMiCiAKLSM6IHNoYTEtZmlsZS5jOjE4NTEgYnVpbHRpbi9wYWNrLW9iamVjdHMuYzo5MjUKKyM6IHNoYTEtZmlsZS5jOjE4NDcgYnVpbHRpbi9wYWNrLW9iamVjdHMuYzo5MjUKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHV0aW1lKCkgb24gJXMiCiBtc2dzdHIgIsOpY2hlYyBkZSB1dGltZSgpIHN1ciAlcyIKIAotIzogc2hhMS1maWxlLmM6MTkyNgorIzogc2hhMS1maWxlLmM6MTkyMgogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgcmVhZCBvYmplY3QgZm9yICVzIgogbXNnc3RyICJpbXBvc3NpYmxlIGRlIGxpcmUgbCdvYmpldCBwb3VyICVzIgogCi0jOiBzaGExLWZpbGUuYzoxOTY2CisjOiBzaGExLWZpbGUuYzoxOTYyCiBtc2dpZCAiY29ycnVwdCBjb21taXQiCiBtc2dzdHIgImNvbW1pdCBjb3Jyb21wdSIKIAotIzogc2hhMS1maWxlLmM6MTk3NAorIzogc2hhMS1maWxlLmM6MTk3MAogbXNnaWQgImNvcnJ1cHQgdGFnIgogbXNnc3RyICLDqXRpcXVldHRlIGNvcnJvbXB1ZSIKIAotIzogc2hhMS1maWxlLmM6MjA3MworIzogc2hhMS1maWxlLmM6MjA2OQogIywgYy1mb3JtYXQKIG1zZ2lkICJyZWFkIGVycm9yIHdoaWxlIGluZGV4aW5nICVzIgogbXNnc3RyICJlcnJldXIgZGUgbGVjdHVyZSDDoCBsJ2luZGV4YXRpb24gZGUgJXMiCiAKLSM6IHNoYTEtZmlsZS5jOjIwNzYKKyM6IHNoYTEtZmlsZS5jOjIwNzIKICMsIGMtZm9ybWF0CiBtc2dpZCAic2hvcnQgcmVhZCB3aGlsZSBpbmRleGluZyAlcyIKIG1zZ3N0ciAibGVjdHVyZSB0cm9ucXXDqWUgcGVuZGFudCBsJ2luZGV4YXRpb24gZGUgJXMiCiAKLSM6IHNoYTEtZmlsZS5jOjIxNDkgc2hhMS1maWxlLmM6MjE1OAorIzogc2hhMS1maWxlLmM6MjE0NSBzaGExLWZpbGUuYzoyMTU0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiBmYWlsZWQgdG8gaW5zZXJ0IGludG8gZGF0YWJhc2UiCiBtc2dzdHIgIiVzwqA6IMOpY2hlYyBkZSBsJ2luc2VydGlvbiBkYW5zIGxhIGJhc2UgZGUgZG9ubsOpZXMiCiAKLSM6IHNoYTEtZmlsZS5jOjIxNjQKKyM6IHNoYTEtZmlsZS5jOjIxNjAKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXM6IHVuc3VwcG9ydGVkIGZpbGUgdHlwZSIKIG1zZ3N0ciAiJXPCoDogdHlwZSBkZSBmaWNoaWVyIG5vbiBzdXBwb3J0w6kiCiAKLSM6IHNoYTEtZmlsZS5jOjIxODgKKyM6IHNoYTEtZmlsZS5jOjIxODQKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgaXMgbm90IGEgdmFsaWQgb2JqZWN0IgogbXNnc3RyICIlcyBuJ2VzdCBwYXMgdW4gb2JqZXQgdmFsaWRlIgogCi0jOiBzaGExLWZpbGUuYzoyMTkwCisjOiBzaGExLWZpbGUuYzoyMTg2CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIGlzIG5vdCBhIHZhbGlkICclcycgb2JqZWN0IgogbXNnc3RyICIlcyBuJ2VzdCBwYXMgdW4gb2JqZXQgJyVzJyB2YWxpZGUiCiAKLSM6IHNoYTEtZmlsZS5jOjIyMTcgYnVpbHRpbi9pbmRleC1wYWNrLmM6MTU1CisjOiBzaGExLWZpbGUuYzoyMjEzIGJ1aWx0aW4vaW5kZXgtcGFjay5jOjE1NQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gb3BlbiAlcyIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkJ291dnJpciAlcyIKIAotIzogc2hhMS1maWxlLmM6MjQwNyBzaGExLWZpbGUuYzoyNDU5CisjOiBzaGExLWZpbGUuYzoyNDAzIHNoYTEtZmlsZS5jOjI0NTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiaGFzaCBtaXNtYXRjaCBmb3IgJXMgKGV4cGVjdGVkICVzKSIKIG1zZ3N0ciAiaW5jb2jDqXJlbmNlIGRlIGhhY2hhZ2UgcG91ciAlcyAoJXMgYXR0ZW5kdSkiCiAKLSM6IHNoYTEtZmlsZS5jOjI0MzEKKyM6IHNoYTEtZmlsZS5jOjI0MjcKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIG1tYXAgJXMiCiBtc2dzdHIgImltcG9zc2libGUgZGUgbW1hcCAlcyIKIAotIzogc2hhMS1maWxlLmM6MjQzNgorIzogc2hhMS1maWxlLmM6MjQzMgogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gdW5wYWNrIGhlYWRlciBvZiAlcyIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkZSBkw6lwYXF1ZXRlciBsJ2VudMOqdGUgZGUgJXMiCiAKLSM6IHNoYTEtZmlsZS5jOjI0NDIKKyM6IHNoYTEtZmlsZS5jOjI0MzgKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHBhcnNlIGhlYWRlciBvZiAlcyIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkJ2FuYWx5c2VyIGwnZW50w6p0ZSBkZSAlcyIKIAotIzogc2hhMS1maWxlLmM6MjQ1MworIzogc2hhMS1maWxlLmM6MjQ0OQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gdW5wYWNrIGNvbnRlbnRzIG9mICVzIgogbXNnc3RyICJpbXBvc3NpYmxlIGRlIGTDqXBhcXVldGVyIGxlIGNvbnRlbnUgZGUgJXMiCiAKLSM6IHNoYTEtbmFtZS5jOjQ5MAorIzogc2hhMS1uYW1lLmM6NDg3CiAjLCBjLWZvcm1hdAogbXNnaWQgInNob3J0IFNIQTEgJXMgaXMgYW1iaWd1b3VzIgogbXNnc3RyICJsZSBTSEExIGNvdXJ0ICVzIGVzdCBhbWJpZ3UiCiAKLSM6IHNoYTEtbmFtZS5jOjUwMQorIzogc2hhMS1uYW1lLmM6NDk4CiBtc2dpZCAiVGhlIGNhbmRpZGF0ZXMgYXJlOiIKIG1zZ3N0ciAiTGVzIGNhbmRpZGF0cyBzb250wqA6IgogCi0jOiBzaGExLW5hbWUuYzo4MDAKKyM6IHNoYTEtbmFtZS5jOjc5NwogbXNnaWQgIiIKICJHaXQgbm9ybWFsbHkgbmV2ZXIgY3JlYXRlcyBhIHJlZiB0aGF0IGVuZHMgd2l0aCA0MCBoZXggY2hhcmFjdGVyc1xuIgogImJlY2F1c2UgaXQgd2lsbCBiZSBpZ25vcmVkIHdoZW4geW91IGp1c3Qgc3BlY2lmeSA0MC1oZXguIFRoZXNlIHJlZnNcbiIKQEAgLTcyNTUsNDMgKzcyODAsNDMgQEAKICJlbiBsYW7Dp2FudCBcImdpdCBjb25maWcgYWR2aWNlLm9iamVjdE5hbWVXYXJuaW5nIGZhbHNlXCIiCiAKICMuIFRSQU5TTEFUT1JTOiBJRUMgODAwMDAtMTM6MjAwOCBnaWJpYnl0ZQotIzogc3RyYnVmLmM6ODIxCisjOiBzdHJidWYuYzo4MjIKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXUuJTIuMnUgR2lCIgogbXNnc3RyICIldS4lMi4ydSBHaW8iCiAKICMuIFRSQU5TTEFUT1JTOiBJRUMgODAwMDAtMTM6MjAwOCBnaWJpYnl0ZS9zZWNvbmQKLSM6IHN0cmJ1Zi5jOjgyMworIzogc3RyYnVmLmM6ODI0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiV1LiUyLjJ1IEdpQi9zIgogbXNnc3RyICIldS4lMi4ydSBHaW8vcyIKIAogIy4gVFJBTlNMQVRPUlM6IElFQyA4MDAwMC0xMzoyMDA4IG1lYmlieXRlCi0jOiBzdHJidWYuYzo4MzEKKyM6IHN0cmJ1Zi5jOjgzMgogIywgYy1mb3JtYXQKIG1zZ2lkICIldS4lMi4ydSBNaUIiCiBtc2dzdHIgIiV1LiUyLjJ1IE1pbyIKIAogIy4gVFJBTlNMQVRPUlM6IElFQyA4MDAwMC0xMzoyMDA4IG1lYmlieXRlL3NlY29uZAotIzogc3RyYnVmLmM6ODMzCisjOiBzdHJidWYuYzo4MzQKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXUuJTIuMnUgTWlCL3MiCiBtc2dzdHIgIiV1LiUyLjJ1IE1pby9zIgogCiAjLiBUUkFOU0xBVE9SUzogSUVDIDgwMDAwLTEzOjIwMDgga2liaWJ5dGUKLSM6IHN0cmJ1Zi5jOjg0MAorIzogc3RyYnVmLmM6ODQxCiAjLCBjLWZvcm1hdAogbXNnaWQgIiV1LiUyLjJ1IEtpQiIKIG1zZ3N0ciAiJXUuJTIuMnUgS2lvIgogCiAjLiBUUkFOU0xBVE9SUzogSUVDIDgwMDAwLTEzOjIwMDgga2liaWJ5dGUvc2Vjb25kCi0jOiBzdHJidWYuYzo4NDIKKyM6IHN0cmJ1Zi5jOjg0MwogIywgYy1mb3JtYXQKIG1zZ2lkICIldS4lMi4ydSBLaUIvcyIKIG1zZ3N0ciAiJXUuJTIuMnUgS2lvL3MiCiAKICMuIFRSQU5TTEFUT1JTOiBJRUMgODAwMDAtMTM6MjAwOCBieXRlCi0jOiBzdHJidWYuYzo4NDgKKyM6IHN0cmJ1Zi5jOjg0OQogIywgYy1mb3JtYXQKIG1zZ2lkICIldSBieXRlIgogbXNnaWRfcGx1cmFsICIldSBieXRlcyIKQEAgLTcyOTksNyArNzMyNCw3IEBACiBtc2dzdHJbMV0gIiV1IG9jdGV0cyIKIAogIy4gVFJBTlNMQVRPUlM6IElFQyA4MDAwMC0xMzoyMDA4IGJ5dGUvc2Vjb25kCi0jOiBzdHJidWYuYzo4NTAKKyM6IHN0cmJ1Zi5jOjg1MQogIywgYy1mb3JtYXQKIG1zZ2lkICIldSBieXRlL3MiCiBtc2dpZF9wbHVyYWwgIiV1IGJ5dGVzL3MiCkBAIC03NDE5LDI4ICs3NDQ0LDI4IEBACiBtc2dpZCAibHMtdHJlZSByZXR1cm5lZCB1bmV4cGVjdGVkIHJldHVybiBjb2RlICVkIgogbXNnc3RyICJscy10cmVlIGEgcmVudm95w6kgdW4gY29kZSBkZSByZXRvdXIgaW5hdHRlbmR1ICVkIgogCi0jOiBzdWJtb2R1bGUtY29uZmlnLmM6MjMyCisjOiBzdWJtb2R1bGUtY29uZmlnLmM6MjM2CiAjLCBjLWZvcm1hdAogbXNnaWQgImlnbm9yaW5nIHN1c3BpY2lvdXMgc3VibW9kdWxlIG5hbWU6ICVzIgogbXNnc3RyICJub20gZGUgc291cy1tb2R1bGUgc3VzcGljaWV1eCAlcyBpZ25vcsOpIgogCi0jOiBzdWJtb2R1bGUtY29uZmlnLmM6Mjk5CisjOiBzdWJtb2R1bGUtY29uZmlnLmM6MzAzCiBtc2dpZCAibmVnYXRpdmUgdmFsdWVzIG5vdCBhbGxvd2VkIGZvciBzdWJtb2R1bGUuZmV0Y2hqb2JzIgogbXNnc3RyICJsZXMgdmFsZXVycyBuw6lnYXRpdmVzIG5lIHNvbnQgcGFzIHBlcm1pc2VzIHBvdXIgc3VibW9kdWxlLmZldGNoSm9icyIKIAotIzogc3VibW9kdWxlLWNvbmZpZy5jOjM5NworIzogc3VibW9kdWxlLWNvbmZpZy5jOjQwMQogIywgYy1mb3JtYXQKIG1zZ2lkICJpZ25vcmluZyAnJXMnIHdoaWNoIG1heSBiZSBpbnRlcnByZXRlZCBhcyBhIGNvbW1hbmQtbGluZSBvcHRpb246ICVzIgogbXNnc3RyICIiCiAiJyVzJyBpZ25vcsOpIGV0IHF1aSBwZXV0IMOqdHJlIGludGVycHLDqXTDqSBjb21tZSB1bmUgb3B0aW9uIGRlIGxpZ25lIGRlICIKICJjb21tYW5kZcKgOiAlcyIKIAotIzogc3VibW9kdWxlLWNvbmZpZy5jOjQ4NgorIzogc3VibW9kdWxlLWNvbmZpZy5jOjQ5MAogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIHZhbHVlIGZvciAlcyIKIG1zZ3N0ciAiVmFsZXVyIGludmFsaWRlIHBvdXIgJXMiCiAKLSM6IHN1Ym1vZHVsZS1jb25maWcuYzo3NTUKKyM6IHN1Ym1vZHVsZS1jb25maWcuYzo3NjEKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ291bGQgbm90IHVwZGF0ZSAuZ2l0bW9kdWxlcyBlbnRyeSAlcyIKIG1zZ3N0ciAiSW1wb3NzaWJsZSBkZSBtZXR0cmUgw6Agam91ciBsJ8OpbMOpbWVudCAlcyBkZSAuZ2l0bW9kdWxlcyIKQEAgLTc0NzUsNyArNzUwMCw3IEBACiBtc2dpZCAiY291bGQgbm90IHJlYWQgZnJvbSBzdGRpbiIKIG1zZ3N0ciAiSW1wb3NzaWJsZSBkZSBsaXJlIGRlcHVpcyBsJ2VudHLDqWUgc3RhbmRhcmQiCiAKLSM6IHRyYWlsZXIuYzoxMDExIHdyYXBwZXIuYzo3MDEKKyM6IHRyYWlsZXIuYzoxMDExIHdyYXBwZXIuYzo2NjUKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHN0YXQgJXMiCiBtc2dzdHIgInN0YXQgaW1wb3NzaWJsZSBkZSAlcyIKQEAgLTc1MDQsNDcgKzc1MjksNDcgQEAKIG1zZ2lkICJXb3VsZCBzZXQgdXBzdHJlYW0gb2YgJyVzJyB0byAnJXMnIG9mICclcydcbiIKIG1zZ3N0ciAiUG9zaXRpb25uZXJhaXQgbGEgYnJhbmNoZSBhbW9udCBkZSAnJXMnIHN1ciAnJXMnIGRlICclcydcbiIKIAotIzogdHJhbnNwb3J0LmM6MTQyCisjOiB0cmFuc3BvcnQuYzoxNDUKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHJlYWQgYnVuZGxlICclcyciCiBtc2dzdHIgImltcG9zc2libGUgZGUgbGlyZSBsYSBsaWFzc2UgJyVzJyIKIAotIzogdHJhbnNwb3J0LmM6MjA4CisjOiB0cmFuc3BvcnQuYzoyMTQKICMsIGMtZm9ybWF0CiBtc2dpZCAidHJhbnNwb3J0OiBpbnZhbGlkIGRlcHRoIG9wdGlvbiAnJXMnIgogbXNnc3RyICJ0cmFuc3BvcnTCoDogb3B0aW9uIGRlIHByb2ZvbmRldXIgaW52YWxpZGUgJyVzJyIKIAotIzogdHJhbnNwb3J0LmM6MjU5CisjOiB0cmFuc3BvcnQuYzoyNjYKIG1zZ2lkICJzZWUgcHJvdG9jb2wudmVyc2lvbiBpbiAnZ2l0IGhlbHAgY29uZmlnJyBmb3IgbW9yZSBkZXRhaWxzIgogbXNnc3RyICJ2b2lyIHByb3RvY29sLnZlcnNpb24gZGFucyAnZ2l0IGhlbHAgY29uZmlnJyBwb3VyIHBsdXMgZCdpbmZvcm1hdGlvbiIKIAotIzogdHJhbnNwb3J0LmM6MjYwCisjOiB0cmFuc3BvcnQuYzoyNjcKIG1zZ2lkICJzZXJ2ZXIgb3B0aW9ucyByZXF1aXJlIHByb3RvY29sIHZlcnNpb24gMiBvciBsYXRlciIKIG1zZ3N0ciAibGVzIG9wdGlvbnMgZGUgc2VydmV1ciBleGlnZW50IHVuZSB2ZXJzaW9uIDIgb3Ugc3Vww6lyaWV1cmUiCiAKLSM6IHRyYW5zcG9ydC5jOjYyNQorIzogdHJhbnNwb3J0LmM6NjMyCiBtc2dpZCAiY291bGQgbm90IHBhcnNlIHRyYW5zcG9ydC5jb2xvci4qIGNvbmZpZyIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkJ2FuYWx5c2VyIGxhIGNvbmZpZ3VyYXRpb24gdHJhbnNwb3J0LmNvbG9yLioiCiAKLSM6IHRyYW5zcG9ydC5jOjY5OAorIzogdHJhbnNwb3J0LmM6NzA1CiBtc2dpZCAic3VwcG9ydCBmb3IgcHJvdG9jb2wgdjIgbm90IGltcGxlbWVudGVkIHlldCIKIG1zZ3N0ciAibGUgc3VwcG9ydCBkdSBwcm90b2NvbGUgdjIgbidlc3QgcGFzIGVuY29yZSBpbXBsYW50w6kiCiAKLSM6IHRyYW5zcG9ydC5jOjgyNQorIzogdHJhbnNwb3J0LmM6ODMxCiAjLCBjLWZvcm1hdAogbXNnaWQgInVua25vd24gdmFsdWUgZm9yIGNvbmZpZyAnJXMnOiAlcyIKIG1zZ3N0ciAidmFsZXVyIGluY29ubnVlIHBvdXIgbGEgY29uZmlnICclcyfCoDogJXMiCiAKLSM6IHRyYW5zcG9ydC5jOjg5MQorIzogdHJhbnNwb3J0LmM6ODk3CiAjLCBjLWZvcm1hdAogbXNnaWQgInRyYW5zcG9ydCAnJXMnIG5vdCBhbGxvd2VkIgogbXNnc3RyICJ0cmFuc3BvcnQgJyVzJyBub24gcGVybWlzIgogCi0jOiB0cmFuc3BvcnQuYzo5NDUKKyM6IHRyYW5zcG9ydC5jOjk0OQogbXNnaWQgImdpdC1vdmVyLXJzeW5jIGlzIG5vIGxvbmdlciBzdXBwb3J0ZWQiCiBtc2dzdHIgImdpdC1vdmVyLXJzeW5jIG4nZXN0IHBsdXMgc3VwcG9ydMOpIgogCi0jOiB0cmFuc3BvcnQuYzoxMDQwCisjOiB0cmFuc3BvcnQuYzoxMDQ0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgZm9sbG93aW5nIHN1Ym1vZHVsZSBwYXRocyBjb250YWluIGNoYW5nZXMgdGhhdCBjYW5cbiIKQEAgLTc1NTMsNyArNzU3OCw3IEBACiAiTGVzIGNoZW1pbnMgc3VpdmFudHMgZGUgc291cy1tb2R1bGUgY29udGllbm5lbnQgZGVzIG1vZGlmaWNhdGlvbnNcbiIKICJxdWkgbmUgcGV1dmVudCDDqnRyZSB0cm91dsOpZXMgc3VyIGF1Y3VuIGRpc3RhbnTCoDpcbiIKIAotIzogdHJhbnNwb3J0LmM6MTA0NAorIzogdHJhbnNwb3J0LmM6MTA0OAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiXG4iCkBAIC03NTgwLDMzICs3NjA1LDMzIEBACiAicG91ciBsZXMgcG91c3NlciB2ZXJzIHVuIHNlcnZldXIgZGlzdGFudC5cbiIKICJcbiIKIAotIzogdHJhbnNwb3J0LmM6MTA1MgorIzogdHJhbnNwb3J0LmM6MTA1NgogbXNnaWQgIkFib3J0aW5nLiIKIG1zZ3N0ciAiQWJhbmRvbi4iCiAKLSM6IHRyYW5zcG9ydC5jOjExOTMKKyM6IHRyYW5zcG9ydC5jOjEyMDEKIG1zZ2lkICJmYWlsZWQgdG8gcHVzaCBhbGwgbmVlZGVkIHN1Ym1vZHVsZXMiCiBtc2dzdHIgIsOpY2hlYyBkZSBsYSBwb3Vzc8OpZSBkZSB0b3VzIGxlcyBzb3VzLW1vZHVsZXMgbsOpY2Vzc2FpcmVzIgogCi0jOiB0cmFuc3BvcnQuYzoxMzQwIHRyYW5zcG9ydC1oZWxwZXIuYzo2NDUKKyM6IHRyYW5zcG9ydC5jOjEzNDUgdHJhbnNwb3J0LWhlbHBlci5jOjY1NQogbXNnaWQgIm9wZXJhdGlvbiBub3Qgc3VwcG9ydGVkIGJ5IHByb3RvY29sIgogbXNnc3RyICJvcHRpb24gbm9uIHN1cHBvcnTDqWUgcGFyIGxlIHByb3RvY29sZSIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjUxIHRyYW5zcG9ydC1oZWxwZXIuYzo4MAorIzogdHJhbnNwb3J0LWhlbHBlci5jOjYxIHRyYW5zcG9ydC1oZWxwZXIuYzo5MAogbXNnaWQgImZ1bGwgd3JpdGUgdG8gcmVtb3RlIGhlbHBlciBmYWlsZWQiCiBtc2dzdHIgIsOpY2hlYyBkZSBsJ8OpY3JpdHVyZSB0b3RhbGUgc3VyIGwnYXNzaXN0YW50IGRpc3RhbnQiCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxMzQKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxNDQKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGZpbmQgcmVtb3RlIGhlbHBlciBmb3IgJyVzJyIKIG1zZ3N0ciAiSW1wb3NzaWJsZSBkZSB0cm91dmVyIHVuIGFzc2lzdGFudCBkaXN0YW50IHBvdXIgJyVzJyIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjE1MCB0cmFuc3BvcnQtaGVscGVyLmM6NTU5CisjOiB0cmFuc3BvcnQtaGVscGVyLmM6MTYwIHRyYW5zcG9ydC1oZWxwZXIuYzo1NjkKIG1zZ2lkICJjYW4ndCBkdXAgaGVscGVyIG91dHB1dCBmZCIKIG1zZ3N0ciAiIgogImltcG9zc2libGUgZGUgZHVwbGlxdWVyIGxlIGRlc2NyaXB0ZXVyIGRlIGZsdXggZGUgc29ydGllIGRlIGwnYXNzaXN0YW50IgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6MjAxCisjOiB0cmFuc3BvcnQtaGVscGVyLmM6MjExCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJ1bmtub3duIG1hbmRhdG9yeSBjYXBhYmlsaXR5ICVzOyB0aGlzIHJlbW90ZSBoZWxwZXIgcHJvYmFibHkgbmVlZHMgbmV3ZXIgIgpAQCAtNzYxNSwxMDMgKzc2NDAsMTA4IEBACiAiY2FwYWNpdMOpIG9ibGlnYXRvaXJlIGluY29ubnVlICVzwqA7IGNldCBhc3Npc3RhbnQgZGlzdGFudCByZXF1aWVydCAiCiAicHJvYmFibGVtZW50IHVuZSB1bmUgbm91dmVsbGUgdmVyc2lvbiBkZSBHaXQiCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzoyMDcKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzoyMTcKIG1zZ2lkICJ0aGlzIHJlbW90ZSBoZWxwZXIgc2hvdWxkIGltcGxlbWVudCByZWZzcGVjIGNhcGFiaWxpdHkiCiBtc2dzdHIgImNldCBhc3Npc3RhbnQgZGlzdGFudCBkZXZyYWl0IHN1cHBvcnRlciBsYSBjYXBhY2l0w6kgcmVmc3BlYyIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjI3NCB0cmFuc3BvcnQtaGVscGVyLmM6NDE0CisjOiB0cmFuc3BvcnQtaGVscGVyLmM6Mjg0IHRyYW5zcG9ydC1oZWxwZXIuYzo0MjQKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgdW5leHBlY3RlZGx5IHNhaWQ6ICclcyciCiBtc2dzdHIgIiVzIGEgZGl0IGRlIG1hbmnDqHJlIGluYXR0ZW5kdWXCoDogJyVzJyIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjQwMworIzogdHJhbnNwb3J0LWhlbHBlci5jOjQxMwogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyBhbHNvIGxvY2tlZCAlcyIKIG1zZ3N0ciAiJXMgYSBhdXNzaSB2ZXJyb3VpbGzDqSAlcyIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjQ4MQorIzogdHJhbnNwb3J0LWhlbHBlci5jOjQ5MQogbXNnaWQgImNvdWxkbid0IHJ1biBmYXN0LWltcG9ydCIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkZSBsYW5jZXIgZmFzdC1pbXBvcnQiCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzo1MDQKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzo1MTQKIG1zZ2lkICJlcnJvciB3aGlsZSBydW5uaW5nIGZhc3QtaW1wb3J0IgogbXNnc3RyICJlcnJldXIgYXUgbGFuY2VtZW50IGRlIGZhc3QtaW1wb3J0IgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6NTMzIHRyYW5zcG9ydC1oZWxwZXIuYzoxMTA1CisjOiB0cmFuc3BvcnQtaGVscGVyLmM6NTQzIHRyYW5zcG9ydC1oZWxwZXIuYzoxMTMyCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCByZWFkIHJlZiAlcyIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkZSBsaXJlIGxhIHLDqWYgJXMiCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzo1NzgKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzo1ODgKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5rbm93biByZXNwb25zZSB0byBjb25uZWN0OiAlcyIKIG1zZ3N0ciAicsOpcG9uc2UgaW5jb25udWUgw6AgY29ubmVjdMKgOiAlcyIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjYwMAorIzogdHJhbnNwb3J0LWhlbHBlci5jOjYxMAogbXNnaWQgInNldHRpbmcgcmVtb3RlIHNlcnZpY2UgcGF0aCBub3Qgc3VwcG9ydGVkIGJ5IHByb3RvY29sIgogbXNnc3RyICIiCiAibGEgc3DDqWNpZmljYXRpb24gZHUgY2hlbWluIGRlIHNlcnZpY2UgZGlzdGFudCBuJ2VzdCBwYXMgc3VwcG9ydMOpZSBwYXIgbGUgIgogInByb3RvY29sZSIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjYwMgorIzogdHJhbnNwb3J0LWhlbHBlci5jOjYxMgogbXNnaWQgImludmFsaWQgcmVtb3RlIHNlcnZpY2UgcGF0aCIKIG1zZ3N0ciAiY2hlbWluIGRlIHNlcnZpY2UgZGlzdGFudCBpbnZhbGlkZSIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjY0OAorIzogdHJhbnNwb3J0LWhlbHBlci5jOjY1OAogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW4ndCBjb25uZWN0IHRvIHN1YnNlcnZpY2UgJXMiCiBtc2dzdHIgImltcG9zc2libGUgZGUgc2UgY29ubmVjdGVyIGF1IHNvdXMtc2VydmljZSAlcyIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjcyMAorIzogdHJhbnNwb3J0LWhlbHBlci5jOjczNAogIywgYy1mb3JtYXQKIG1zZ2lkICJleHBlY3RlZCBvay9lcnJvciwgaGVscGVyIHNhaWQgJyVzJyIKIG1zZ3N0ciAib2svZXJyb3IgYXR0ZW5kdSwgbCdhc3Npc3RhbnQgYSBkaXQgJyVzJyIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjc3MworIzogdHJhbnNwb3J0LWhlbHBlci5jOjc4NwogIywgYy1mb3JtYXQKIG1zZ2lkICJoZWxwZXIgcmVwb3J0ZWQgdW5leHBlY3RlZCBzdGF0dXMgb2YgJXMiCiBtc2dzdHIgImwnYXNzaXN0YW50IGEgcmVudm95w6kgdW4gc3RhdHV0IGRlIHJldG91ciBpbmF0dGVuZHUgJXMiCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzo4MzQKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzo4NDgKICMsIGMtZm9ybWF0CiBtc2dpZCAiaGVscGVyICVzIGRvZXMgbm90IHN1cHBvcnQgZHJ5LXJ1biIKIG1zZ3N0ciAibCdhc3Npc3RhbnQgJXMgbmUgZ8OocmUgcGFzIGRyeS1ydW4iCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzo4MzcKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzo4NTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiaGVscGVyICVzIGRvZXMgbm90IHN1cHBvcnQgLS1zaWduZWQiCiBtc2dzdHIgImwnYXNzaXN0YW50ICVzIG5lIGfDqHJlIHBhcyAtLXNpZ25lZCIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjg0MAorIzogdHJhbnNwb3J0LWhlbHBlci5jOjg1NAogIywgYy1mb3JtYXQKIG1zZ2lkICJoZWxwZXIgJXMgZG9lcyBub3Qgc3VwcG9ydCAtLXNpZ25lZD1pZi1hc2tlZCIKIG1zZ3N0ciAibCdhc3Npc3RhbnQgJXMgbmUgZ8OocmUgcGFzIC0tc2lnbmVkPWlmLWFza2VkIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6ODQ3CisjOiB0cmFuc3BvcnQtaGVscGVyLmM6ODU5CisjLCBjLWZvcm1hdAorbXNnaWQgImhlbHBlciAlcyBkb2VzIG5vdCBzdXBwb3J0IC0tYXRvbWljIgorbXNnc3RyICJsJ2Fzc2lzdGFudCAlcyBuZSBnw6hyZSBwYXMgLS1hdG9taWMiCisKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzo4NjUKICMsIGMtZm9ybWF0CiBtc2dpZCAiaGVscGVyICVzIGRvZXMgbm90IHN1cHBvcnQgJ3B1c2gtb3B0aW9uJyIKIG1zZ3N0ciAibCdhc3Npc3RhbnQgJXMgbmUgZ8OocmUgcGFzICdwdXNoLW9wdGlvbiciCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzo5NDUKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzo5NjMKIG1zZ2lkICJyZW1vdGUtaGVscGVyIGRvZXNuJ3Qgc3VwcG9ydCBwdXNoOyByZWZzcGVjIG5lZWRlZCIKIG1zZ3N0ciAiIgogImwnYXNzaXN0YW50ICVzIG5lIGfDqHJlIHBhcyBwdXNowqA7IHVuIHNww6ljaWZpY2F0ZXVyIGRlIHLDqWbDqXJlbmNlIGVzdCAiCiAibsOpY2Vzc2FpcmUiCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzo5NTAKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzo5NjgKICMsIGMtZm9ybWF0CiBtc2dpZCAiaGVscGVyICVzIGRvZXMgbm90IHN1cHBvcnQgJ2ZvcmNlJyIKIG1zZ3N0ciAibCdhc3Npc3RhbnQgJXMgbmUgZ8OocmUgcGFzICdmb3JjZSciCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzo5OTcKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxMDE1CiBtc2dpZCAiY291bGRuJ3QgcnVuIGZhc3QtZXhwb3J0IgogbXNnc3RyICJpbXBvc3NpYmxlIGRlIGxhbmNlciBmYXN0LWV4cG9ydCIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjEwMDIKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxMDIwCiBtc2dpZCAiZXJyb3Igd2hpbGUgcnVubmluZyBmYXN0LWV4cG9ydCIKIG1zZ3N0ciAiZXJyZXVyIGF1IGxhbmNlbWVudCBkZSBmYXN0LWV4cG9ydCIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjEwMjcKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxMDQ1CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJObyByZWZzIGluIGNvbW1vbiBhbmQgbm9uZSBzcGVjaWZpZWQ7IGRvaW5nIG5vdGhpbmcuXG4iCkBAIC03NzIwLDQ3ICs3NzUwLDQ3IEBACiAiQXVjdW5lIHLDqWbDqXJlbmNlIGVuIGNvbW11biBldCBhdWN1bmUgc3DDqWNmacOpZcKgOyByaWVuIMOgIGZhaXJlLlxuIgogIlZvdXMgZGV2cmlleiBwZXV0LcOqdHJlIHNww6ljaWZpZXIgdW5lIGJyYW5jaGUgdGVsbGUgcXVlICdtYXN0ZXInLlxuIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6MTA5MQorIzogdHJhbnNwb3J0LWhlbHBlci5jOjExMTgKICMsIGMtZm9ybWF0CiBtc2dpZCAibWFsZm9ybWVkIHJlc3BvbnNlIGluIHJlZiBsaXN0OiAlcyIKIG1zZ3N0ciAicsOpcG9uc2UgbWFsZm9ybcOpZSBkYW5zIGxlIGxpc3RlIGRlIHLDqWZzwqA6ICVzIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6MTI0NAorIzogdHJhbnNwb3J0LWhlbHBlci5jOjEyNzAKICMsIGMtZm9ybWF0CiBtc2dpZCAicmVhZCglcykgZmFpbGVkIgogbXNnc3RyICLDqWNoZWMgZGUgcmVhZCglcykiCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxMjcxCisjOiB0cmFuc3BvcnQtaGVscGVyLmM6MTI5NwogIywgYy1mb3JtYXQKIG1zZ2lkICJ3cml0ZSglcykgZmFpbGVkIgogbXNnc3RyICLDqWNoZWMgZGUgd3JpdGUoJXMpIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6MTMyMAorIzogdHJhbnNwb3J0LWhlbHBlci5jOjEzNDYKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgdGhyZWFkIGZhaWxlZCIKIG1zZ3N0ciAiw6ljaGVjIGR1IGZpbCBkJ2V4w6ljdXRpb24gJXMiCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxMzI0CisjOiB0cmFuc3BvcnQtaGVscGVyLmM6MTM1MAogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyB0aHJlYWQgZmFpbGVkIHRvIGpvaW46ICVzIgogbXNnc3RyICLDqWNoZWMgZGUgam9uY3Rpb24gZHUgZmlsIGQnZXjDqWN1dGlvbiAlc8KgOiAlcyIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjEzNDMgdHJhbnNwb3J0LWhlbHBlci5jOjEzNDcKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxMzY5IHRyYW5zcG9ydC1oZWxwZXIuYzoxMzczCiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbid0IHN0YXJ0IHRocmVhZCBmb3IgY29weWluZyBkYXRhOiAlcyIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkZSBkw6ltYXJyZXIgbGUgZmlsIGQnZXjDqWN1dGlvbiBwb3VyIGNvcGllciBsZXMgZG9ubsOpZXPCoDogJXMiCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxMzg0CisjOiB0cmFuc3BvcnQtaGVscGVyLmM6MTQxMAogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyBwcm9jZXNzIGZhaWxlZCB0byB3YWl0IgogbXNnc3RyICLDqWNoZWMgZHUgcHJvY2Vzc3VzICVzIHBvdXIgbCdhdHRlbnRlIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6MTM4OAorIzogdHJhbnNwb3J0LWhlbHBlci5jOjE0MTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgcHJvY2VzcyBmYWlsZWQiCiBtc2dzdHIgIsOpY2hlYyBkdSBwcm9jZXNzdXMgJXMiCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxNDA2IHRyYW5zcG9ydC1oZWxwZXIuYzoxNDE1CisjOiB0cmFuc3BvcnQtaGVscGVyLmM6MTQzMiB0cmFuc3BvcnQtaGVscGVyLmM6MTQ0MQogbXNnaWQgImNhbid0IHN0YXJ0IHRocmVhZCBmb3IgY29weWluZyBkYXRhIgogbXNnc3RyICJpbXBvc3NpYmxlIGRlIGTDqW1hcnJlciBsZSBmaWwgZCdleMOpY3V0aW9uIHBvdXIgY29waWVyIGxlcyBkb25uw6llcyIKIApAQCAtNzc4MCw3ICs3ODEwLDcgQEAKIG1zZ2lkICJ0b28tc2hvcnQgdHJlZSBmaWxlIgogbXNnc3RyICJmaWNoaWVyIGFyYnJlIHRyb3AgY291cnQiCiAKLSM6IHVucGFjay10cmVlcy5jOjExMQorIzogdW5wYWNrLXRyZWVzLmM6MTEwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJZb3VyIGxvY2FsIGNoYW5nZXMgdG8gdGhlIGZvbGxvd2luZyBmaWxlcyB3b3VsZCBiZSBvdmVyd3JpdHRlbiBieSBjaGVja291dDpcbiIKQEAgLTc3OTEsNyArNzgyMSw3IEBACiAiJSVzVmV1aWxsZXogdmFsaWRlciBvdSByZW1pc2VyIHZvcyBtb2RpZmljYXRpb25zIGF2YW50IGRlIGJhc2N1bGVyIGRlICIKICJicmFuY2hlLiIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTEzCisjOiB1bnBhY2stdHJlZXMuYzoxMTIKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIllvdXIgbG9jYWwgY2hhbmdlcyB0byB0aGUgZm9sbG93aW5nIGZpbGVzIHdvdWxkIGJlIG92ZXJ3cml0dGVuIGJ5IGNoZWNrb3V0OlxuIgpAQCAtNzgwMSw3ICs3ODMxLDcgQEAKICJsJ2V4dHJhY3Rpb27CoDpcbiIKICIlJXMiCiAKLSM6IHVucGFjay10cmVlcy5jOjExNgorIzogdW5wYWNrLXRyZWVzLmM6MTE1CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJZb3VyIGxvY2FsIGNoYW5nZXMgdG8gdGhlIGZvbGxvd2luZyBmaWxlcyB3b3VsZCBiZSBvdmVyd3JpdHRlbiBieSBtZXJnZTpcbiIKQEAgLTc4MTEsNyArNzg0MSw3IEBACiAiZnVzaW9uwqA6XG4iCiAiJSVzVmV1aWxsZXogdmFsaWRlciBvdSByZW1pc2VyIHZvcyBtb2RpZmljYXRpb25zIGF2YW50IGxhIGZ1c2lvbi4iCiAKLSM6IHVucGFjay10cmVlcy5jOjExOAorIzogdW5wYWNrLXRyZWVzLmM6MTE3CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJZb3VyIGxvY2FsIGNoYW5nZXMgdG8gdGhlIGZvbGxvd2luZyBmaWxlcyB3b3VsZCBiZSBvdmVyd3JpdHRlbiBieSBtZXJnZTpcbiIKQEAgLTc4MjEsNyArNzg1MSw3IEBACiAiZnVzaW9uwqA6XG4iCiAiJSVzIgogCi0jOiB1bnBhY2stdHJlZXMuYzoxMjEKKyM6IHVucGFjay10cmVlcy5jOjEyMAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiWW91ciBsb2NhbCBjaGFuZ2VzIHRvIHRoZSBmb2xsb3dpbmcgZmlsZXMgd291bGQgYmUgb3ZlcndyaXR0ZW4gYnkgJXM6XG4iCkBAIC03ODMwLDcgKzc4NjAsNyBAQAogIlZvcyBtb2RpZmljYXRpb25zIGxvY2FsZXMgYXV4IGZpY2hpZXJzIHN1aXZhbnRzIHNlcmFpZW50IMOpY3Jhc8OpZXMgcGFyICVzwqA6XG4iCiAiJSVzVmV1aWxsZXogdmFsaWRlciBvdSByZW1pc2VyIHZvcyBtb2RpZmljYXRpb25zIGF2YW50ICVzLiIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTIzCisjOiB1bnBhY2stdHJlZXMuYzoxMjIKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIllvdXIgbG9jYWwgY2hhbmdlcyB0byB0aGUgZm9sbG93aW5nIGZpbGVzIHdvdWxkIGJlIG92ZXJ3cml0dGVuIGJ5ICVzOlxuIgpAQCAtNzgzOSw3ICs3ODY5LDcgQEAKICJWb3MgbW9kaWZpY2F0aW9ucyBsb2NhbGVzIGF1eCBmaWNoaWVycyBzdWl2YW50cyBzZXJhaWVudCDDqWNyYXPDqWVzIHBhciAlc8KgOlxuIgogIiUlcyIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTI4CisjOiB1bnBhY2stdHJlZXMuYzoxMjcKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlVwZGF0aW5nIHRoZSBmb2xsb3dpbmcgZGlyZWN0b3JpZXMgd291bGQgbG9zZSB1bnRyYWNrZWQgZmlsZXMgaW4gdGhlbTpcbiIKQEAgLTc4NDksNyArNzg3OSw3IEBACiAiY29udGVudXPCoDpcbiIKICIlcyIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTMyCisjOiB1bnBhY2stdHJlZXMuYzoxMzEKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlRoZSBmb2xsb3dpbmcgdW50cmFja2VkIHdvcmtpbmcgdHJlZSBmaWxlcyB3b3VsZCBiZSByZW1vdmVkIGJ5IGNoZWNrb3V0OlxuIgpAQCAtNzg1OSw3ICs3ODg5LDcgQEAKICJsJ2V4dHJhY3Rpb27CoDpcbiIKICIlJXNWZXVpbGxleiByZW5vbW1lciBvdSBlZmZhY2VyIGNlcyBmaWNoaWVycyBhdmFudCBkZSBiYXNjdWxlciBkZSBicmFuY2hlLiIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTM0CisjOiB1bnBhY2stdHJlZXMuYzoxMzMKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlRoZSBmb2xsb3dpbmcgdW50cmFja2VkIHdvcmtpbmcgdHJlZSBmaWxlcyB3b3VsZCBiZSByZW1vdmVkIGJ5IGNoZWNrb3V0OlxuIgpAQCAtNzg2OCw3ICs3ODk4LDcgQEAKICJMZXMgZmljaGllcnMgc3VpdmFudHMgbm9uIHN1aXZpcyBzZXJhaWVudCBlZmZhY8OpcyBwYXIgbCdleHRyYWN0aW9uwqA6XG4iCiAiJSVzIgogCi0jOiB1bnBhY2stdHJlZXMuYzoxMzcKKyM6IHVucGFjay10cmVlcy5jOjEzNgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiVGhlIGZvbGxvd2luZyB1bnRyYWNrZWQgd29ya2luZyB0cmVlIGZpbGVzIHdvdWxkIGJlIHJlbW92ZWQgYnkgbWVyZ2U6XG4iCkBAIC03ODc4LDcgKzc5MDgsNyBAQAogImxhIGZ1c2lvbsKgOlxuIgogIiUlc1ZldWlsbGV6IHJlbm9tbWVyIG91IGVmZmFjZXIgY2VzIGZpY2hpZXJzIGF2YW50IGxhIGZ1c2lvbi4iCiAKLSM6IHVucGFjay10cmVlcy5jOjEzOQorIzogdW5wYWNrLXRyZWVzLmM6MTM4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgZm9sbG93aW5nIHVudHJhY2tlZCB3b3JraW5nIHRyZWUgZmlsZXMgd291bGQgYmUgcmVtb3ZlZCBieSBtZXJnZTpcbiIKQEAgLTc4ODcsNyArNzkxNyw3IEBACiAiTGVzIGZpY2hpZXJzIHN1aXZhbnRzIG5vbiBzdWl2aXMgc2VyYWllbnQgZWZmYWPDqXMgcGFyIGxhIGZ1c2lvbsKgOlxuIgogIiUlcyIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTQyCisjOiB1bnBhY2stdHJlZXMuYzoxNDEKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlRoZSBmb2xsb3dpbmcgdW50cmFja2VkIHdvcmtpbmcgdHJlZSBmaWxlcyB3b3VsZCBiZSByZW1vdmVkIGJ5ICVzOlxuIgpAQCAtNzg5Nyw3ICs3OTI3LDcgQEAKICIlc8KgOlxuIgogIiUlc1ZldWlsbGV6IHJlbm9tbWVyIG91IGVmZmFjZXIgY2VzIGZpY2hpZXJzIGF2YW50ICVzLiIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTQ0CisjOiB1bnBhY2stdHJlZXMuYzoxNDMKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlRoZSBmb2xsb3dpbmcgdW50cmFja2VkIHdvcmtpbmcgdHJlZSBmaWxlcyB3b3VsZCBiZSByZW1vdmVkIGJ5ICVzOlxuIgpAQCAtNzkwNiw3ICs3OTM2LDcgQEAKICJMZXMgZmljaGllcnMgc3VpdmFudHMgbm9uIHN1aXZpcyBzZXJhaWVudCBlZmZhY8OpcyBwYXIgJXPCoDpcbiIKICIlJXMiCiAKLSM6IHVucGFjay10cmVlcy5jOjE1MAorIzogdW5wYWNrLXRyZWVzLmM6MTQ5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgZm9sbG93aW5nIHVudHJhY2tlZCB3b3JraW5nIHRyZWUgZmlsZXMgd291bGQgYmUgb3ZlcndyaXR0ZW4gYnkgIgpAQCAtNzkxNyw3ICs3OTQ3LDcgQEAKICJsJ2V4dHJhY3Rpb27CoDpcbiIKICIlJXNWZXVpbGxleiByZW5vbW1lciBvdSBlZmZhY2VyIGNlcyBmaWNoaWVycyBhdmFudCBkZSBiYXNjdWxlciBkZSBicmFuY2hlLiIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTUyCisjOiB1bnBhY2stdHJlZXMuYzoxNTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlRoZSBmb2xsb3dpbmcgdW50cmFja2VkIHdvcmtpbmcgdHJlZSBmaWxlcyB3b3VsZCBiZSBvdmVyd3JpdHRlbiBieSAiCkBAIC03OTI3LDcgKzc5NTcsNyBAQAogIkxlcyBmaWNoaWVycyBzdWl2YW50cyBub24gc3VpdmlzIHNlcmFpZW50IMOpY3Jhc8OpcyBwYXIgbCdleHRyYWN0aW9uwqA6XG4iCiAiJSVzIgogCi0jOiB1bnBhY2stdHJlZXMuYzoxNTUKKyM6IHVucGFjay10cmVlcy5jOjE1NAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiVGhlIGZvbGxvd2luZyB1bnRyYWNrZWQgd29ya2luZyB0cmVlIGZpbGVzIHdvdWxkIGJlIG92ZXJ3cml0dGVuIGJ5IG1lcmdlOlxuIgpAQCAtNzkzNyw3ICs3OTY3LDcgQEAKICJsYSBmdXNpb27CoDpcbiIKICIlJXNWZXVpbGxleiByZW5vbW1lciBvdSBlZmZhY2VyIGNlcyBmaWNoaWVycyBhdmFudCBsYSBmdXNpb24uIgogCi0jOiB1bnBhY2stdHJlZXMuYzoxNTcKKyM6IHVucGFjay10cmVlcy5jOjE1NgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiVGhlIGZvbGxvd2luZyB1bnRyYWNrZWQgd29ya2luZyB0cmVlIGZpbGVzIHdvdWxkIGJlIG92ZXJ3cml0dGVuIGJ5IG1lcmdlOlxuIgpAQCAtNzk0Niw3ICs3OTc2LDcgQEAKICJMZXMgZmljaGllcnMgc3VpdmFudHMgbm9uIHN1aXZpcyBzZXJhaWVudCDDqWNyYXPDqXMgcGFyIGxhIGZ1c2lvbsKgOlxuIgogIiUlcyIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTYwCisjOiB1bnBhY2stdHJlZXMuYzoxNTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlRoZSBmb2xsb3dpbmcgdW50cmFja2VkIHdvcmtpbmcgdHJlZSBmaWxlcyB3b3VsZCBiZSBvdmVyd3JpdHRlbiBieSAlczpcbiIKQEAgLTc5NTYsNyArNzk4Niw3IEBACiAiJXPCoDpcbiIKICIlJXNWZXVpbGxleiByZW5vbW1lciBvdSBlZmZhY2VyIGNlcyBmaWNoaWVycyBhdmFudCAlcy4iCiAKLSM6IHVucGFjay10cmVlcy5jOjE2MgorIzogdW5wYWNrLXRyZWVzLmM6MTYxCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgZm9sbG93aW5nIHVudHJhY2tlZCB3b3JraW5nIHRyZWUgZmlsZXMgd291bGQgYmUgb3ZlcndyaXR0ZW4gYnkgJXM6XG4iCkBAIC03OTY1LDEyICs3OTk1LDEyIEBACiAiTGVzIGZpY2hpZXJzIHN1aXZhbnRzIG5vbiBzdWl2aXMgc2VyYWllbnQgw6ljcmFzw6lzIHBhciAlc8KgOlxuIgogIiUlcyIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTcwCisjOiB1bnBhY2stdHJlZXMuYzoxNjkKICMsIGMtZm9ybWF0CiBtc2dpZCAiRW50cnkgJyVzJyBvdmVybGFwcyB3aXRoICclcycuICBDYW5ub3QgYmluZC4iCiBtc2dzdHIgIkwnZW50csOpZSAnJXMnIHN1cmNoYXJnZSBhdmVjICclcycuIEFmZmVjdGF0aW9uIGltcG9zc2libGUuIgogCi0jOiB1bnBhY2stdHJlZXMuYzoxNzMKKyM6IHVucGFjay10cmVlcy5jOjE3MgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiQ2Fubm90IHVwZGF0ZSBzcGFyc2UgY2hlY2tvdXQ6IHRoZSBmb2xsb3dpbmcgZW50cmllcyBhcmUgbm90IHVwIHRvIGRhdGU6XG4iCkBAIC03OTgwLDcgKzgwMTAsNyBAQAogInBhcyDDoCBqb3VywqA6XG4iCiAiJXMiCiAKLSM6IHVucGFjay10cmVlcy5jOjE3NQorIzogdW5wYWNrLXRyZWVzLmM6MTc0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgZm9sbG93aW5nIHdvcmtpbmcgdHJlZSBmaWxlcyB3b3VsZCBiZSBvdmVyd3JpdHRlbiBieSBzcGFyc2UgY2hlY2tvdXQgIgpAQCAtNzk5MSw3ICs4MDIxLDcgQEAKICJqb3VyIHBhciBsJ2V4dHJhY3Rpb24gY3JldXNlwqA6XG4iCiAiJXMiCiAKLSM6IHVucGFjay10cmVlcy5jOjE3NworIzogdW5wYWNrLXRyZWVzLmM6MTc2CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgZm9sbG93aW5nIHdvcmtpbmcgdHJlZSBmaWxlcyB3b3VsZCBiZSByZW1vdmVkIGJ5IHNwYXJzZSBjaGVja291dCAiCkBAIC04MDAyLDcgKzgwMzIsNyBAQAogIsOgIGpvdXIgcGFyIGV4dHJhY3Rpb24gY3JldXNlwqA6XG4iCiAiJXMiCiAKLSM6IHVucGFjay10cmVlcy5jOjE3OQorIzogdW5wYWNrLXRyZWVzLmM6MTc4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJDYW5ub3QgdXBkYXRlIHN1Ym1vZHVsZTpcbiIKQEAgLTgwMTEsMTYgKzgwNDEsMTYgQEAKICJNaXNlIMOgIGpvdXIgaW1wb3NzaWJsZSBwb3VyIGxlIHNvdXMtbW9kdWxlwqA6XG4iCiAiJXMiCiAKLSM6IHVucGFjay10cmVlcy5jOjI1NgorIzogdW5wYWNrLXRyZWVzLmM6MjU1CiAjLCBjLWZvcm1hdAogbXNnaWQgIkFib3J0aW5nXG4iCiBtc2dzdHIgIkFiYW5kb25cbiIKIAotIzogdW5wYWNrLXRyZWVzLmM6MzE4CisjOiB1bnBhY2stdHJlZXMuYzozMTcKIG1zZ2lkICJVcGRhdGluZyBmaWxlcyIKIG1zZ3N0ciAiTWlzZSDDoCBqb3VyIGRlcyBmaWNoaWVycyIKIAotIzogdW5wYWNrLXRyZWVzLmM6MzUwCisjOiB1bnBhY2stdHJlZXMuYzozNDkKIG1zZ2lkICIiCiAidGhlIGZvbGxvd2luZyBwYXRocyBoYXZlIGNvbGxpZGVkIChlLmcuIGNhc2Utc2Vuc2l0aXZlIHBhdGhzXG4iCiAib24gYSBjYXNlLWluc2Vuc2l0aXZlIGZpbGVzeXN0ZW0pIGFuZCBvbmx5IG9uZSBmcm9tIHRoZSBzYW1lXG4iCkBAIC04MDU5LDcgKzgwODksNyBAQAogbXNnaWQgImludmFsaWQgJy4uJyBwYXRoIHNlZ21lbnQiCiBtc2dzdHIgInNlZ21lbnQgZGUgY2hlbWluICcuLicgaW52YWxpZGUiCiAKLSM6IHdvcmt0cmVlLmM6MjU4IGJ1aWx0aW4vYW0uYzoyMDk1CisjOiB3b3JrdHJlZS5jOjI1OCBidWlsdGluL2FtLmM6MjA4NAogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gcmVhZCAnJXMnIgogbXNnc3RyICLDqWNoZWMgZGUgbGEgbGVjdHVyZSBkZSAnJXMnIgpAQCAtODA5MiwxNyArODEyMiwxNyBAQAogbXNnaWQgIiclcycgZG9lcyBub3QgcG9pbnQgYmFjayB0byAnJXMnIgogbXNnc3RyICInJXMnIG5lIHBvaW50ZSBwYXMgZW4gcmV0b3VyIHN1ciAnJXMnIgogCi0jOiB3cmFwcGVyLmM6MjIzIHdyYXBwZXIuYzozOTMKKyM6IHdyYXBwZXIuYzoxODYgd3JhcHBlci5jOjM1NgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3Qgb3BlbiAnJXMnIGZvciByZWFkaW5nIGFuZCB3cml0aW5nIgogbXNnc3RyICJpbXBvc3NpYmxlIGQnb3V2cmlyICclcycgZW4gbGVjdHVyZS/DqWNyaXR1cmUiCiAKLSM6IHdyYXBwZXIuYzo0MjQgd3JhcHBlci5jOjYyNAorIzogd3JhcHBlci5jOjM4NyB3cmFwcGVyLmM6NTg4CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBhY2Nlc3MgJyVzJyIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkJ2FjY8OpZGVyIMOgICclcyciCiAKLSM6IHdyYXBwZXIuYzo2MzIKKyM6IHdyYXBwZXIuYzo1OTYKIG1zZ2lkICJ1bmFibGUgdG8gZ2V0IGN1cnJlbnQgd29ya2luZyBkaXJlY3RvcnkiCiBtc2dzdHIgImltcG9zc2libGUgZCdhY2PDqWRlciBhdSByw6lwZXJ0b2lyZSBkZSB0cmF2YWlsIGNvdXJhbnQiCiAKQEAgLTg0NDcsODAgKzg0NzcsODggQEAKICIgICh0b3VzIGxlcyBjb25mbGl0cyBzb250IHLDqWdsw6lzIDogbGFuY2V6IFwiZ2l0IGNoZXJyeS1waWNrIC0tY29udGludWVcIikiCiAKICM6IHd0LXN0YXR1cy5jOjE0MzcKK21zZ2lkICIgICh1c2UgXCJnaXQgY2hlcnJ5LXBpY2sgLS1za2lwXCIgdG8gc2tpcCB0aGlzIHBhdGNoKSIKK21zZ3N0ciAiICAodXRpbGlzZXogXCJnaXQgY2hlcnJ5LXBpY2sgLS1za2lwXCIgcG91ciBzYXV0ZXIgY2UgcGF0Y2gpIgorCisjOiB3dC1zdGF0dXMuYzoxNDM5CiBtc2dpZCAiICAodXNlIFwiZ2l0IGNoZXJyeS1waWNrIC0tYWJvcnRcIiB0byBjYW5jZWwgdGhlIGNoZXJyeS1waWNrIG9wZXJhdGlvbikiCiBtc2dzdHIgIiAgKHV0aWxpc2V6IFwiZ2l0IGNoZXJyeS1waWNrIC0tYWJvcnRcIiBwb3VyIGFubnVsZXIgbGUgcGljb3JhZ2UpIgogCi0jOiB3dC1zdGF0dXMuYzoxNDQ3CisjOiB3dC1zdGF0dXMuYzoxNDQ5CiBtc2dpZCAiUmV2ZXJ0IGN1cnJlbnRseSBpbiBwcm9ncmVzcy4iCiBtc2dzdHIgIlLDqXRhYmxpc3NlbWVudCBlbiBjb3Vycy4iCiAKLSM6IHd0LXN0YXR1cy5jOjE0NTAKKyM6IHd0LXN0YXR1cy5jOjE0NTIKICMsIGMtZm9ybWF0CiBtc2dpZCAiWW91IGFyZSBjdXJyZW50bHkgcmV2ZXJ0aW5nIGNvbW1pdCAlcy4iCiBtc2dzdHIgIlZvdXMgw6p0ZXMgYWN0dWVsbGVtZW50IGVuIHRyYWluIGRlIHLDqXRhYmxpciBsZSBjb21taXQgJXMuIgogCi0jOiB3dC1zdGF0dXMuYzoxNDU2CisjOiB3dC1zdGF0dXMuYzoxNDU4CiBtc2dpZCAiICAoZml4IGNvbmZsaWN0cyBhbmQgcnVuIFwiZ2l0IHJldmVydCAtLWNvbnRpbnVlXCIpIgogbXNnc3RyICIgIChyw6lnbGV6IGxlcyBjb25mbGl0cyBwdWlzIGxhbmNleiBcImdpdCByZXZlcnQgLS1jb250aW51ZVwiKSIKIAotIzogd3Qtc3RhdHVzLmM6MTQ1OQorIzogd3Qtc3RhdHVzLmM6MTQ2MQogbXNnaWQgIiAgKHJ1biBcImdpdCByZXZlcnQgLS1jb250aW51ZVwiIHRvIGNvbnRpbnVlKSIKIG1zZ3N0ciAiICAobGFuY2V6IFwiZ2l0IHJldmVydCAtLWNvbnRpbnVlXCIgcG91ciBjb250aW51ZXIpIgogCi0jOiB3dC1zdGF0dXMuYzoxNDYyCisjOiB3dC1zdGF0dXMuYzoxNDY0CiBtc2dpZCAiICAoYWxsIGNvbmZsaWN0cyBmaXhlZDogcnVuIFwiZ2l0IHJldmVydCAtLWNvbnRpbnVlXCIpIgogbXNnc3RyICIgICh0b3VzIGxlcyBjb25mbGl0cyBzb250IHLDqWdsw6lzIDogbGFuY2V6IFwiZ2l0IHJldmVydCAtLWNvbnRpbnVlXCIpIgogCi0jOiB3dC1zdGF0dXMuYzoxNDY0CisjOiB3dC1zdGF0dXMuYzoxNDY2Cittc2dpZCAiICAodXNlIFwiZ2l0IHJldmVydCAtLXNraXBcIiB0byBza2lwIHRoaXMgcGF0Y2gpIgorbXNnc3RyICIgICh1dGlsaXNleiBcImdpdCByZXZlcnQgLS1za2lwXCIgcG91ciBzYXV0ZXIgY2UgcGF0Y2gpIgorCisjOiB3dC1zdGF0dXMuYzoxNDY4CiBtc2dpZCAiICAodXNlIFwiZ2l0IHJldmVydCAtLWFib3J0XCIgdG8gY2FuY2VsIHRoZSByZXZlcnQgb3BlcmF0aW9uKSIKIG1zZ3N0ciAiICAodXRpbGlzZXogXCJnaXQgcmV2ZXJ0IC0tYWJvcnRcIiBwb3VyIGFubnVsZXIgbGUgcsOpdGFibGlzc2VtZW50KSIKIAotIzogd3Qtc3RhdHVzLmM6MTQ3NAorIzogd3Qtc3RhdHVzLmM6MTQ3OAogIywgYy1mb3JtYXQKIG1zZ2lkICJZb3UgYXJlIGN1cnJlbnRseSBiaXNlY3RpbmcsIHN0YXJ0ZWQgZnJvbSBicmFuY2ggJyVzJy4iCiBtc2dzdHIgIlZvdXMgw6p0ZXMgZW4gY291cnMgZGUgYmlzc2VjdGlvbiwgZGVwdWlzIGxhIGJyYW5jaGUgJyVzJy4iCiAKLSM6IHd0LXN0YXR1cy5jOjE0NzgKKyM6IHd0LXN0YXR1cy5jOjE0ODIKIG1zZ2lkICJZb3UgYXJlIGN1cnJlbnRseSBiaXNlY3RpbmcuIgogbXNnc3RyICJWb3VzIMOqdGVzIGVuIGNvdXJzIGRlIGJpc3NlY3Rpb24uIgogCi0jOiB3dC1zdGF0dXMuYzoxNDgxCisjOiB3dC1zdGF0dXMuYzoxNDg1CiBtc2dpZCAiICAodXNlIFwiZ2l0IGJpc2VjdCByZXNldFwiIHRvIGdldCBiYWNrIHRvIHRoZSBvcmlnaW5hbCBicmFuY2gpIgogbXNnc3RyICIgICh1dGlsaXNleiBcImdpdCBiaXNlY3QgcmVzZXRcIiBwb3VyIHJldmVuaXIgw6AgbGEgYnJhbmNoZSBkJ29yaWdpbmUpIgogCi0jOiB3dC1zdGF0dXMuYzoxNjkwCisjOiB3dC1zdGF0dXMuYzoxNjk0CiBtc2dpZCAiT24gYnJhbmNoICIKIG1zZ3N0ciAiU3VyIGxhIGJyYW5jaGUgIgogCi0jOiB3dC1zdGF0dXMuYzoxNjk3CisjOiB3dC1zdGF0dXMuYzoxNzAxCiBtc2dpZCAiaW50ZXJhY3RpdmUgcmViYXNlIGluIHByb2dyZXNzOyBvbnRvICIKIG1zZ3N0ciAicmViYXNhZ2UgaW50ZXJhY3RpZiBlbiBjb3VycyA7IHN1ciAiCiAKLSM6IHd0LXN0YXR1cy5jOjE2OTkKKyM6IHd0LXN0YXR1cy5jOjE3MDMKIG1zZ2lkICJyZWJhc2UgaW4gcHJvZ3Jlc3M7IG9udG8gIgogbXNnc3RyICJyZWJhc2FnZSBlbiBjb3VycyA7IHN1ciAiCiAKLSM6IHd0LXN0YXR1cy5jOjE3MDkKKyM6IHd0LXN0YXR1cy5jOjE3MTMKIG1zZ2lkICJOb3QgY3VycmVudGx5IG9uIGFueSBicmFuY2guIgogbXNnc3RyICJBY3R1ZWxsZW1lbnQgc3VyIGF1Y3VuIGJyYW5jaGUuIgogCi0jOiB3dC1zdGF0dXMuYzoxNzI2CisjOiB3dC1zdGF0dXMuYzoxNzMwCiBtc2dpZCAiSW5pdGlhbCBjb21taXQiCiBtc2dzdHIgIlZhbGlkYXRpb24gaW5pdGlhbGUiCiAKLSM6IHd0LXN0YXR1cy5jOjE3MjcKKyM6IHd0LXN0YXR1cy5jOjE3MzEKIG1zZ2lkICJObyBjb21taXRzIHlldCIKIG1zZ3N0ciAiQXVjdW4gY29tbWl0IgogCi0jOiB3dC1zdGF0dXMuYzoxNzQxCisjOiB3dC1zdGF0dXMuYzoxNzQ1CiBtc2dpZCAiVW50cmFja2VkIGZpbGVzIgogbXNnc3RyICJGaWNoaWVycyBub24gc3VpdmlzIgogCi0jOiB3dC1zdGF0dXMuYzoxNzQzCisjOiB3dC1zdGF0dXMuYzoxNzQ3CiBtc2dpZCAiSWdub3JlZCBmaWxlcyIKIG1zZ3N0ciAiRmljaGllcnMgaWdub3LDqXMiCiAKLSM6IHd0LXN0YXR1cy5jOjE3NDcKKyM6IHd0LXN0YXR1cy5jOjE3NTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkl0IHRvb2sgJS4yZiBzZWNvbmRzIHRvIGVudW1lcmF0ZSB1bnRyYWNrZWQgZmlsZXMuICdzdGF0dXMgLXVubydcbiIKQEAgLTg1MzIsMzIgKzg1NzAsMzIgQEAKICJvdWJsaWVyIGQnYWpvdXRlciBsZXMgbm91dmVhdXggZmljaGllcnMgcGFyIHZvdXMtbcOqbWUgKHZvaXIgJ2dpdCBoZWxwICIKICJzdGF0dXMnKS4iCiAKLSM6IHd0LXN0YXR1cy5jOjE3NTMKKyM6IHd0LXN0YXR1cy5jOjE3NTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiVW50cmFja2VkIGZpbGVzIG5vdCBsaXN0ZWQlcyIKIG1zZ3N0ciAiRmljaGllcnMgbm9uIHN1aXZpcyBub24gYWZmaWNow6lzJXMiCiAKLSM6IHd0LXN0YXR1cy5jOjE3NTUKKyM6IHd0LXN0YXR1cy5jOjE3NTkKIG1zZ2lkICIgKHVzZSAtdSBvcHRpb24gdG8gc2hvdyB1bnRyYWNrZWQgZmlsZXMpIgogbXNnc3RyICIgKHV0aWxpc2V6IC11IHBvdXIgYWZmaWNoZXIgbGVzIGZpY2hpZXJzIG5vbiBzdWl2aXMpIgogCi0jOiB3dC1zdGF0dXMuYzoxNzYxCisjOiB3dC1zdGF0dXMuYzoxNzY1CiBtc2dpZCAiTm8gY2hhbmdlcyIKIG1zZ3N0ciAiQXVjdW5lIG1vZGlmaWNhdGlvbiIKIAotIzogd3Qtc3RhdHVzLmM6MTc2NgorIzogd3Qtc3RhdHVzLmM6MTc3MAogIywgYy1mb3JtYXQKIG1zZ2lkICJubyBjaGFuZ2VzIGFkZGVkIHRvIGNvbW1pdCAodXNlIFwiZ2l0IGFkZFwiIGFuZC9vciBcImdpdCBjb21taXQgLWFcIilcbiIKIG1zZ3N0ciAiIgogImF1Y3VuZSBtb2RpZmljYXRpb24gbidhIMOpdMOpIGFqb3V0w6llIMOgIGxhIHZhbGlkYXRpb24gKHV0aWxpc2V6IFwiZ2l0IGFkZFwiIG91ICIKICJcImdpdCBjb21taXQgLWFcIilcbiIKIAotIzogd3Qtc3RhdHVzLmM6MTc2OQorIzogd3Qtc3RhdHVzLmM6MTc3MwogIywgYy1mb3JtYXQKIG1zZ2lkICJubyBjaGFuZ2VzIGFkZGVkIHRvIGNvbW1pdFxuIgogbXNnc3RyICJhdWN1bmUgbW9kaWZpY2F0aW9uIGFqb3V0w6llIMOgIGxhIHZhbGlkYXRpb25cbiIKIAotIzogd3Qtc3RhdHVzLmM6MTc3MgorIzogd3Qtc3RhdHVzLmM6MTc3NgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAibm90aGluZyBhZGRlZCB0byBjb21taXQgYnV0IHVudHJhY2tlZCBmaWxlcyBwcmVzZW50ICh1c2UgXCJnaXQgYWRkXCIgdG8gIgpAQCAtODU2Niw3MCArODYwNCw3NSBAQAogImF1Y3VuZSBtb2RpZmljYXRpb24gYWpvdXTDqWUgw6AgbGEgdmFsaWRhdGlvbiBtYWlzIGRlcyBmaWNoaWVycyBub24gc3VpdmlzICIKICJzb250IHByw6lzZW50cyAodXRpbGlzZXogXCJnaXQgYWRkXCIgcG91ciBsZXMgc3VpdnJlKVxuIgogCi0jOiB3dC1zdGF0dXMuYzoxNzc1CisjOiB3dC1zdGF0dXMuYzoxNzc5CiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vdGhpbmcgYWRkZWQgdG8gY29tbWl0IGJ1dCB1bnRyYWNrZWQgZmlsZXMgcHJlc2VudFxuIgogbXNnc3RyICIiCiAiYXVjdW5lIG1vZGlmaWNhdGlvbiBham91dMOpZSDDoCBsYSB2YWxpZGF0aW9uIG1haXMgZGVzIGZpY2hpZXJzIG5vbiBzdWl2aXMgIgogInNvbnQgcHLDqXNlbnRzXG4iCiAKLSM6IHd0LXN0YXR1cy5jOjE3NzgKKyM6IHd0LXN0YXR1cy5jOjE3ODIKICMsIGMtZm9ybWF0CiBtc2dpZCAibm90aGluZyB0byBjb21taXQgKGNyZWF0ZS9jb3B5IGZpbGVzIGFuZCB1c2UgXCJnaXQgYWRkXCIgdG8gdHJhY2spXG4iCiBtc2dzdHIgIiIKICJyaWVuIMOgIHZhbGlkZXIgKGNyw6llei9jb3BpZXogZGVzIGZpY2hpZXJzIGV0IHV0aWxpc2V6IFwiZ2l0IGFkZFwiIHBvdXIgbGVzICIKICJzdWl2cmUpXG4iCiAKLSM6IHd0LXN0YXR1cy5jOjE3ODEgd3Qtc3RhdHVzLmM6MTc4NgorIzogd3Qtc3RhdHVzLmM6MTc4NSB3dC1zdGF0dXMuYzoxNzkwCiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vdGhpbmcgdG8gY29tbWl0XG4iCiBtc2dzdHIgInJpZW4gw6AgdmFsaWRlclxuIgogCi0jOiB3dC1zdGF0dXMuYzoxNzg0CisjOiB3dC1zdGF0dXMuYzoxNzg4CiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vdGhpbmcgdG8gY29tbWl0ICh1c2UgLXUgdG8gc2hvdyB1bnRyYWNrZWQgZmlsZXMpXG4iCiBtc2dzdHIgInJpZW4gw6AgdmFsaWRlciAodXRpbGlzZXogLXUgcG91ciBhZmZpY2hlciBsZXMgZmljaGllcnMgbm9uIHN1aXZpcylcbiIKIAotIzogd3Qtc3RhdHVzLmM6MTc4OAorIzogd3Qtc3RhdHVzLmM6MTc5MgogIywgYy1mb3JtYXQKIG1zZ2lkICJub3RoaW5nIHRvIGNvbW1pdCwgd29ya2luZyB0cmVlIGNsZWFuXG4iCiBtc2dzdHIgInJpZW4gw6AgdmFsaWRlciwgbGEgY29waWUgZGUgdHJhdmFpbCBlc3QgcHJvcHJlXG4iCiAKLSM6IHd0LXN0YXR1cy5jOjE5MDEKKyM6IHd0LXN0YXR1cy5jOjE5MDUKIG1zZ2lkICJObyBjb21taXRzIHlldCBvbiAiCiBtc2dzdHIgIkVuY29yZSBhdWN1biBjb21taXQgc3VyICIKIAotIzogd3Qtc3RhdHVzLmM6MTkwNQorIzogd3Qtc3RhdHVzLmM6MTkwOQogbXNnaWQgIkhFQUQgKG5vIGJyYW5jaCkiCiBtc2dzdHIgIkhFQUQgKGF1Y3VuZSBicmFuY2hlKSIKIAotIzogd3Qtc3RhdHVzLmM6MTkzNgorIzogd3Qtc3RhdHVzLmM6MTk0MAogbXNnaWQgImRpZmZlcmVudCIKIG1zZ3N0ciAiZGlmZsOpcmVudCIKIAotIzogd3Qtc3RhdHVzLmM6MTkzOCB3dC1zdGF0dXMuYzoxOTQ2CisjOiB3dC1zdGF0dXMuYzoxOTQyIHd0LXN0YXR1cy5jOjE5NTAKIG1zZ2lkICJiZWhpbmQgIgogbXNnc3RyICJkZXJyacOocmUgIgogCi0jOiB3dC1zdGF0dXMuYzoxOTQxIHd0LXN0YXR1cy5jOjE5NDQKKyM6IHd0LXN0YXR1cy5jOjE5NDUgd3Qtc3RhdHVzLmM6MTk0OAogbXNnaWQgImFoZWFkICIKIG1zZ3N0ciAiZGV2YW50ICIKIAogIy4gVFJBTlNMQVRPUlM6IHRoZSBhY3Rpb24gaXMgZS5nLiAicHVsbCB3aXRoIHJlYmFzZSIKLSM6IHd0LXN0YXR1cy5jOjI0NjYKKyM6IHd0LXN0YXR1cy5jOjI0NzAKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90ICVzOiBZb3UgaGF2ZSB1bnN0YWdlZCBjaGFuZ2VzLiIKIG1zZ3N0ciAiSW1wb3NzaWJsZSBkZSAlc8KgOiB2b3VzIGF2ZXogZGVzIG1vZGlmaWNhdGlvbnMgbm9uIGluZGV4w6llcy4iCiAKLSM6IHd0LXN0YXR1cy5jOjI0NzIKKyM6IHd0LXN0YXR1cy5jOjI0NzYKIG1zZ2lkICJhZGRpdGlvbmFsbHksIHlvdXIgaW5kZXggY29udGFpbnMgdW5jb21taXR0ZWQgY2hhbmdlcy4iCiBtc2dzdHIgImRlIHBsdXMsIHZvdHJlIGluZGV4IGNvbnRpZW50IGRlcyBtb2RpZmljYXRpb25zIG5vbiB2YWxpZMOpZXMuIgogCi0jOiB3dC1zdGF0dXMuYzoyNDc0CisjOiB3dC1zdGF0dXMuYzoyNDc4CiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCAlczogWW91ciBpbmRleCBjb250YWlucyB1bmNvbW1pdHRlZCBjaGFuZ2VzLiIKIG1zZ3N0ciAiJXMgaW1wb3NzaWJsZcKgOiB2b3RyZSBpbmRleCBjb250aWVudCBkZXMgbW9kaWZpY2F0aW9ucyBub24gdmFsaWTDqWVzLiIKIAorIzogY29tcGF0L3ByZWNvbXBvc2VfdXRmOC5jOjU4IGJ1aWx0aW4vY2xvbmUuYzo0NTIKKyMsIGMtZm9ybWF0Cittc2dpZCAiZmFpbGVkIHRvIHVubGluayAnJXMnIgorbXNnc3RyICLDqWNoZWMgcG91ciBkw6lsaWVyICclcyciCisKICM6IGJ1aWx0aW4vYWRkLmM6MjUKIG1zZ2lkICJnaXQgYWRkIFs8b3B0aW9ucz5dIFstLV0gPHBhdGhzcGVjPi4uLiIKIG1zZ3N0ciAiZ2l0IGFkZCBbPG9wdGlvbnM+XSBbLS1dIDxjaGVtaW4+Li4uIgpAQCAtODY1Miw3ICs4Njk1LDcgQEAKIG1zZ2lkICJVbnN0YWdlZCBjaGFuZ2VzIGFmdGVyIHJlZnJlc2hpbmcgdGhlIGluZGV4OiIKIG1zZ3N0ciAiTW9kaWZpY2F0aW9ucyBub24gaW5kZXjDqWVzIGFwcsOocyByYWZyYcOuY2hpc3NlbWVudCBkZSBsJ2luZGV4IDoiCiAKLSM6IGJ1aWx0aW4vYWRkLmM6MjM0IGJ1aWx0aW4vcmV2LXBhcnNlLmM6ODk2CisjOiBidWlsdGluL2FkZC5jOjIzNCBidWlsdGluL3Jldi1wYXJzZS5jOjg5NwogbXNnaWQgIkNvdWxkIG5vdCByZWFkIHRoZSBpbmRleCIKIG1zZ3N0ciAiSW1wb3NzaWJsZSBkZSBsaXJlIGwnaW5kZXgiCiAKQEAgLTg2ODgsOCArODczMSw4IEBACiBtc2dzdHIgIiIKICJMZXMgY2hlbWlucyBzdWl2YW50cyBzb250IGlnbm9yw6lzIHBhciB1biBkZSB2b3MgZmljaGllcnMgLmdpdGlnbm9yZSA6XG4iCiAKLSM6IGJ1aWx0aW4vYWRkLmM6MjkwIGJ1aWx0aW4vY2xlYW4uYzo5MDkgYnVpbHRpbi9mZXRjaC5jOjE0NyBidWlsdGluL212LmM6MTI0Ci0jOiBidWlsdGluL3BydW5lLXBhY2tlZC5jOjU2IGJ1aWx0aW4vcHVsbC5jOjIyMiBidWlsdGluL3B1c2guYzo1NjAKKyM6IGJ1aWx0aW4vYWRkLmM6MjkwIGJ1aWx0aW4vY2xlYW4uYzo5MTAgYnVpbHRpbi9mZXRjaC5jOjE2MiBidWlsdGluL212LmM6MTI0CisjOiBidWlsdGluL3BydW5lLXBhY2tlZC5jOjU2IGJ1aWx0aW4vcHVsbC5jOjIyMyBidWlsdGluL3B1c2guYzo1NDcKICM6IGJ1aWx0aW4vcmVtb3RlLmM6MTM0NSBidWlsdGluL3JtLmM6MjQxIGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTY1CiBtc2dpZCAiZHJ5IHJ1biIKIG1zZ3N0ciAic2ltdWxlciBsJ2FjdGlvbiIKQEAgLTg3NDYsNyArODc4OSw3IEBACiBtc2dpZCAiY2hlY2sgaWYgLSBldmVuIG1pc3NpbmcgLSBmaWxlcyBhcmUgaWdub3JlZCBpbiBkcnkgcnVuIgogbXNnc3RyICJ2w6lyaWZpZXIgc2kgZGVzIGZpY2hpZXJzIC0gbcOqbWUgbWFucXVhbnRzIC0gc29udCBpZ25vcsOpcywgw6AgdmlkZSIKIAotIzogYnVpbHRpbi9hZGQuYzozMDkgYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDAxCisjOiBidWlsdGluL2FkZC5jOjMwOSBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMDIKIG1zZ2lkICJvdmVycmlkZSB0aGUgZXhlY3V0YWJsZSBiaXQgb2YgdGhlIGxpc3RlZCBmaWxlcyIKIG1zZ3N0ciAib3V0cmVwYXNzZXIgbGUgYml0IGV4w6ljdXRhYmxlIHBvdXIgbGVzIGZpY2hpZXJzIGxpc3TDqXMiCiAKQEAgLTg4MjMsMTE2ICs4ODY2LDExMiBAQAogbXNnaWQgIk1heWJlIHlvdSB3YW50ZWQgdG8gc2F5ICdnaXQgYWRkIC4nP1xuIgogbXNnc3RyICJWb3VzIHZvdWxpZXogc8O7cmVtZW50IGRpcmUgJ2dpdCBhZGQgLicgP1xuIgogCi0jOiBidWlsdGluL2FtLmM6MzQ4CisjOiBidWlsdGluL2FtLmM6MzQ3CiBtc2dpZCAiY291bGQgbm90IHBhcnNlIGF1dGhvciBzY3JpcHQiCiBtc2dzdHIgImltcG9zc2libGUgZCdhbmFseXNlciBsJ2F1dGV1ciBkdSBzY3JpcHQiCiAKLSM6IGJ1aWx0aW4vYW0uYzo0MzIKKyM6IGJ1aWx0aW4vYW0uYzo0MzEKICMsIGMtZm9ybWF0CiBtc2dpZCAiJyVzJyB3YXMgZGVsZXRlZCBieSB0aGUgYXBwbHlwYXRjaC1tc2cgaG9vayIKIG1zZ3N0ciAiJyVzJyBhIMOpdMOpIGVmZmFjw6kgcGFyIGxlIGNyb2NoZXQgYXBwbHlwYXRjaC1tc2ciCiAKLSM6IGJ1aWx0aW4vYW0uYzo0NzQKKyM6IGJ1aWx0aW4vYW0uYzo0NzMKICMsIGMtZm9ybWF0CiBtc2dpZCAiTWFsZm9ybWVkIGlucHV0IGxpbmU6ICclcycuIgogbXNnc3RyICJMaWduZSBlbiBlbnRyw6llIG1hbGZvcm3DqWUgOiAnJXMnLiIKIAotIzogYnVpbHRpbi9hbS5jOjUxMgorIzogYnVpbHRpbi9hbS5jOjUxMQogIywgYy1mb3JtYXQKIG1zZ2lkICJGYWlsZWQgdG8gY29weSBub3RlcyBmcm9tICclcycgdG8gJyVzJyIKIG1zZ3N0ciAiSW1wb3NzaWJsZSBkZSBjb3BpZXIgbGVzIG5vdGVzIGRlICclcycgdmVycyAnJXMnIgogCi0jOiBidWlsdGluL2FtLmM6NTM4CisjOiBidWlsdGluL2FtLmM6NTM3CiBtc2dpZCAiZnNlZWsgZmFpbGVkIgogbXNnc3RyICLDqWNoZWMgZGUgZnNlZWsiCiAKLSM6IGJ1aWx0aW4vYW0uYzo3MjYKKyM6IGJ1aWx0aW4vYW0uYzo3MjUKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHBhcnNlIHBhdGNoICclcyciCiBtc2dzdHIgImltcG9zc2libGUgZCdhbmFseXNlciBsZSBwYXRjaCAnJXMnIgogCi0jOiBidWlsdGluL2FtLmM6NzkxCisjOiBidWlsdGluL2FtLmM6NzkwCiBtc2dpZCAiT25seSBvbmUgU3RHSVQgcGF0Y2ggc2VyaWVzIGNhbiBiZSBhcHBsaWVkIGF0IG9uY2UiCiBtc2dzdHIgIlNldWxlbWVudCB1bmUgc8OpcmllIGRlIHBhdGNocyBTdEdJVCBwZXV0IMOqdHJlIGFwcGxpcXXDqWUgw6AgbGEgZm9pcyIKIAotIzogYnVpbHRpbi9hbS5jOjgzOQorIzogYnVpbHRpbi9hbS5jOjgzOAogbXNnaWQgImludmFsaWQgdGltZXN0YW1wIgogbXNnc3RyICJob3JvZGF0YWdlIGludmFsaWRlIgogCi0jOiBidWlsdGluL2FtLmM6ODQ0IGJ1aWx0aW4vYW0uYzo4NTYKKyM6IGJ1aWx0aW4vYW0uYzo4NDMgYnVpbHRpbi9hbS5jOjg1NQogbXNnaWQgImludmFsaWQgRGF0ZSBsaW5lIgogbXNnc3RyICJsaWduZSBkZSBEYXRlIGludmFsaWRlIgogCi0jOiBidWlsdGluL2FtLmM6ODUxCisjOiBidWlsdGluL2FtLmM6ODUwCiBtc2dpZCAiaW52YWxpZCB0aW1lem9uZSBvZmZzZXQiCiBtc2dzdHIgImTDqWNhbGFnZSBob3JhaXJlIGludmFsaWRlIgogCi0jOiBidWlsdGluL2FtLmM6OTQ0CisjOiBidWlsdGluL2FtLmM6OTQzCiBtc2dpZCAiUGF0Y2ggZm9ybWF0IGRldGVjdGlvbiBmYWlsZWQuIgogbXNnc3RyICLDiWNoZWMgZGUgZMOpdGVjdGlvbiBkdSBmb3JtYXQgZHUgcGF0Y2guIgogCi0jOiBidWlsdGluL2FtLmM6OTQ5IGJ1aWx0aW4vY2xvbmUuYzo0MDcKKyM6IGJ1aWx0aW4vYW0uYzo5NDggYnVpbHRpbi9jbG9uZS5jOjQwNgogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gY3JlYXRlIGRpcmVjdG9yeSAnJXMnIgogbXNnc3RyICLDqWNoZWMgZGUgbGEgY3LDqWF0aW9uIGR1IHLDqXBlcnRvaXJlICclcyciCiAKLSM6IGJ1aWx0aW4vYW0uYzo5NTQKKyM6IGJ1aWx0aW4vYW0uYzo5NTMKIG1zZ2lkICJGYWlsZWQgdG8gc3BsaXQgcGF0Y2hlcy4iCiBtc2dzdHIgIsOJY2hlYyBkZSBkw6ljb3VwYWdlIGRlcyBwYXRjaHMuIgogCi0jOiBidWlsdGluL2FtLmM6MTA4NCBidWlsdGluL2NvbW1pdC5jOjM3NAotbXNnaWQgInVuYWJsZSB0byB3cml0ZSBpbmRleCBmaWxlIgotbXNnc3RyICJpbXBvc3NpYmxlIGQnw6ljcmlyZSBsZSBmaWNoaWVyIGQnaW5kZXgiCi0KLSM6IGJ1aWx0aW4vYW0uYzoxMDk4CisjOiBidWlsdGluL2FtLmM6MTA4NAogIywgYy1mb3JtYXQKIG1zZ2lkICJXaGVuIHlvdSBoYXZlIHJlc29sdmVkIHRoaXMgcHJvYmxlbSwgcnVuIFwiJXMgLS1jb250aW51ZVwiLiIKIG1zZ3N0ciAiUXVhbmQgdm91cyBhdmV6IHLDqXNvbHUgY2UgcHJvYmzDqG1lLCBsYW5jZXogXCIlcyAtLWNvbnRpbnVlXCIuIgogCi0jOiBidWlsdGluL2FtLmM6MTA5OQorIzogYnVpbHRpbi9hbS5jOjEwODUKICMsIGMtZm9ybWF0CiBtc2dpZCAiSWYgeW91IHByZWZlciB0byBza2lwIHRoaXMgcGF0Y2gsIHJ1biBcIiVzIC0tc2tpcFwiIGluc3RlYWQuIgogbXNnc3RyICJTaSB2b3VzIHByw6lmw6lyZXogcGx1dMO0dCBzYXV0ZXIgY2UgcGF0Y2gsIGxhbmNleiBcIiVzIC0tc2tpcFwiLiIKIAotIzogYnVpbHRpbi9hbS5jOjExMDAKKyM6IGJ1aWx0aW4vYW0uYzoxMDg2CiAjLCBjLWZvcm1hdAogbXNnaWQgIlRvIHJlc3RvcmUgdGhlIG9yaWdpbmFsIGJyYW5jaCBhbmQgc3RvcCBwYXRjaGluZywgcnVuIFwiJXMgLS1hYm9ydFwiLiIKIG1zZ3N0ciAiIgogIlBvdXIgcmVzdGF1cmVyIGxhIGJyYW5jaGUgb3JpZ2luYWxlIGV0IGFycsOqdGVyIGRlIHBhdGNoZXIsIGxhbmNleiBcIiVzIC0tIgogImFib3J0XCIuIgogCi0jOiBidWlsdGluL2FtLmM6MTE4MworIzogYnVpbHRpbi9hbS5jOjExNjkKIG1zZ2lkICJQYXRjaCBzZW50IHdpdGggZm9ybWF0PWZsb3dlZDsgc3BhY2UgYXQgdGhlIGVuZCBvZiBsaW5lcyBtaWdodCBiZSBsb3N0LiIKIG1zZ3N0ciAiIgogIlJ1c3RpbmUgZW52b3nDqWUgYXZlYyBmb3JtYXQ9Zmxvd2VkwqA7IGxlcyBlc3BhY2VzIGVuIGZpbiBkZSBsaWduZSBwZXV2ZW50ICIKICLDqnRyZSBwZXJkdXMuIgogCi0jOiBidWlsdGluL2FtLmM6MTIxMQorIzogYnVpbHRpbi9hbS5jOjExOTcKIG1zZ2lkICJQYXRjaCBpcyBlbXB0eS4iCiBtc2dzdHIgIkxlIHBhdGNoIGFjdHVlbCBlc3QgdmlkZS4iCiAKLSM6IGJ1aWx0aW4vYW0uYzoxMjc3CisjOiBidWlsdGluL2FtLmM6MTI2MgorIywgYy1mb3JtYXQKK21zZ2lkICJtaXNzaW5nIGF1dGhvciBsaW5lIGluIGNvbW1pdCAlcyIKK21zZ3N0ciAibGlnbmUgZCdhdXRldXIgbWFucXVhbnRlIGRhbnMgbGUgY29tbWl0ICVzIgorCisjOiBidWlsdGluL2FtLmM6MTI2NQogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIGlkZW50IGxpbmU6ICUuKnMiCiBtc2dzdHIgImxpZ25lIGQnaWRlbnRpZmljYXRpb24gaW52YWxpZGUgOiAlLipzIgogCi0jOiBidWlsdGluL2FtLmM6MTI5OQotIywgYy1mb3JtYXQKLW1zZ2lkICJ1bmFibGUgdG8gcGFyc2UgY29tbWl0ICVzIgotbXNnc3RyICJpbXBvc3NpYmxlIGQnYW5hbHlzZXIgbGUgY29tbWl0ICVzIgotCi0jOiBidWlsdGluL2FtLmM6MTQ5NgorIzogYnVpbHRpbi9hbS5jOjE0ODQKIG1zZ2lkICJSZXBvc2l0b3J5IGxhY2tzIG5lY2Vzc2FyeSBibG9icyB0byBmYWxsIGJhY2sgb24gMy13YXkgbWVyZ2UuIgogbXNnc3RyICIiCiAiTGUgZMOpcMO0dCBuJ2EgcGFzIGxlcyBibG9icyBuw6ljZXNzYWlyZXMgcG91ciB1biByZXRvdXIgw6AgdW5lIGZ1c2lvbiDDoCAzICIKICJwb2ludHMuIgogCi0jOiBidWlsdGluL2FtLmM6MTQ5OAorIzogYnVpbHRpbi9hbS5jOjE0ODYKIG1zZ2lkICJVc2luZyBpbmRleCBpbmZvIHRvIHJlY29uc3RydWN0IGEgYmFzZSB0cmVlLi4uIgogbXNnc3RyICIiCiAiVXRpbGlzYXRpb24gZGUgbCdpbmZvcm1hdGlvbiBkZSBsJ2luZGV4IHBvdXIgcmVjb25zdHJ1aXJlIHVuIGFyYnJlIGRlIGJhc2UuLi4iCiAKLSM6IGJ1aWx0aW4vYW0uYzoxNTE3CisjOiBidWlsdGluL2FtLmM6MTUwNQogbXNnaWQgIiIKICJEaWQgeW91IGhhbmQgZWRpdCB5b3VyIHBhdGNoP1xuIgogIkl0IGRvZXMgbm90IGFwcGx5IHRvIGJsb2JzIHJlY29yZGVkIGluIGl0cyBpbmRleC4iCkBAIC04OTQwLDI0ICs4OTc5LDI0IEBACiAiQXZlei12b3VzIMOpZGl0w6kgbGUgcGF0Y2ggw6AgbGEgbWFpbiA/XG4iCiAiSWwgbmUgcydhcHBsaXF1ZSBwYXMgYXV4IGJsb2JzIGVucmVnaXN0csOpcyBkYW5zIHNvbiBpbmRleC4iCiAKLSM6IGJ1aWx0aW4vYW0uYzoxNTIzCisjOiBidWlsdGluL2FtLmM6MTUxMQogbXNnaWQgIkZhbGxpbmcgYmFjayB0byBwYXRjaGluZyBiYXNlIGFuZCAzLXdheSBtZXJnZS4uLiIKIG1zZ3N0ciAiUmV0b3VyIMOgIHVuIHBhdGNoIGRlIGxhIGJhc2UgZXQgZnVzaW9uIMOgIDMgcG9pbnRzLi4uIgogCi0jOiBidWlsdGluL2FtLmM6MTU0OQorIzogYnVpbHRpbi9hbS5jOjE1MzcKIG1zZ2lkICJGYWlsZWQgdG8gbWVyZ2UgaW4gdGhlIGNoYW5nZXMuIgogbXNnc3RyICLDiWNoZWMgZCdpbnTDqWdyYXRpb24gZGVzIG1vZGlmaWNhdGlvbnMuIgogCi0jOiBidWlsdGluL2FtLmM6MTU4MQorIzogYnVpbHRpbi9hbS5jOjE1NjkKIG1zZ2lkICJhcHBseWluZyB0byBhbiBlbXB0eSBoaXN0b3J5IgogbXNnc3RyICJhcHBsaWNhdGlvbiDDoCB1biBoaXN0b3JpcXVlIHZpZGUiCiAKLSM6IGJ1aWx0aW4vYW0uYzoxNjI4IGJ1aWx0aW4vYW0uYzoxNjMyCisjOiBidWlsdGluL2FtLmM6MTYxNiBidWlsdGluL2FtLmM6MTYyMAogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgcmVzdW1lOiAlcyBkb2VzIG5vdCBleGlzdC4iCiBtc2dzdHIgImltcG9zc2libGUgZGUgY29udGludWVyIDogJXMgbidleGlzdGUgcGFzLiIKIAotIzogYnVpbHRpbi9hbS5jOjE2NTAKKyM6IGJ1aWx0aW4vYW0uYzoxNjM4CiBtc2dpZCAiQ29tbWl0IEJvZHkgaXM6IgogbXNnc3RyICJMZSBjb3JwcyBkZSBsYSB2YWxpZGF0aW9uIGVzdCA6IgogCkBAIC04OTY1LDM2ICs5MDA0LDQwIEBACiAjLiBpbiB5b3VyIHRyYW5zbGF0aW9uLiBUaGUgcHJvZ3JhbSB3aWxsIG9ubHkgYWNjZXB0IEVuZ2xpc2gKICMuIGlucHV0IGF0IHRoaXMgcG9pbnQuCiAjLgotIzogYnVpbHRpbi9hbS5jOjE2NjAKKyM6IGJ1aWx0aW4vYW0uYzoxNjQ4CiAjLCBjLWZvcm1hdAogbXNnaWQgIkFwcGx5PyBbeV1lcy9bbl1vL1tlXWRpdC9bdl1pZXcgcGF0Y2gvW2FdY2NlcHQgYWxsOiAiCiBtc2dzdHIgIkFwcGxpcXVlciA/IFt5XWVzL1tuXW8vW2VdZGl0L1t2XWlldyBwYXRjaC9bYV1jY2VwdCBhbGzCoDogIgogCi0jOiBidWlsdGluL2FtLmM6MTcxMAorIzogYnVpbHRpbi9hbS5jOjE2OTUgYnVpbHRpbi9jb21taXQuYzozNzQKK21zZ2lkICJ1bmFibGUgdG8gd3JpdGUgaW5kZXggZmlsZSIKK21zZ3N0ciAiaW1wb3NzaWJsZSBkJ8OpY3JpcmUgbGUgZmljaGllciBkJ2luZGV4IgorCisjOiBidWlsdGluL2FtLmM6MTY5OQogIywgYy1mb3JtYXQKIG1zZ2lkICJEaXJ0eSBpbmRleDogY2Fubm90IGFwcGx5IHBhdGNoZXMgKGRpcnR5OiAlcykiCiBtc2dzdHIgIkluZGV4IHNhbGUgOiBpbXBvc3NpYmxlIGQnYXBwbGlxdWVyIGRlcyBwYXRjaHMgKHNhbGVzIDogJXMpIgogCi0jOiBidWlsdGluL2FtLmM6MTc1MCBidWlsdGluL2FtLmM6MTgxOAorIzogYnVpbHRpbi9hbS5jOjE3MzkgYnVpbHRpbi9hbS5jOjE4MDcKICMsIGMtZm9ybWF0CiBtc2dpZCAiQXBwbHlpbmc6ICUuKnMiCiBtc2dzdHIgIkFwcGxpY2F0aW9uIGRlICAlLipzIgogCi0jOiBidWlsdGluL2FtLmM6MTc2NworIzogYnVpbHRpbi9hbS5jOjE3NTYKIG1zZ2lkICJObyBjaGFuZ2VzIC0tIFBhdGNoIGFscmVhZHkgYXBwbGllZC4iCiBtc2dzdHIgIlBhcyBkZSBjaGFuZ2VtZW50IC0tIFBhdGNoIGTDqWrDoCBhcHBsaXF1w6kuIgogCi0jOiBidWlsdGluL2FtLmM6MTc3MworIzogYnVpbHRpbi9hbS5jOjE3NjIKICMsIGMtZm9ybWF0CiBtc2dpZCAiUGF0Y2ggZmFpbGVkIGF0ICVzICUuKnMiCiBtc2dzdHIgImxlIHBhdGNoIGEgw6ljaG91w6kgw6AgJXMgJS4qcyIKIAotIzogYnVpbHRpbi9hbS5jOjE3NzcKKyM6IGJ1aWx0aW4vYW0uYzoxNzY2CiBtc2dpZCAiVXNlICdnaXQgYW0gLS1zaG93LWN1cnJlbnQtcGF0Y2gnIHRvIHNlZSB0aGUgZmFpbGVkIHBhdGNoIgogbXNnc3RyICIiCiAiVXRpbGlzZXogJ2dpdCBhbSAtLXNob3ctY3VycmVudC1wYXRjaCcgcG91ciB2aXN1YWxpc2VyIGxlIHBhdGNoIGVuIMOpY2hlYyIKIAotIzogYnVpbHRpbi9hbS5jOjE4MjEKKyM6IGJ1aWx0aW4vYW0uYzoxODEwCiBtc2dpZCAiIgogIk5vIGNoYW5nZXMgLSBkaWQgeW91IGZvcmdldCB0byB1c2UgJ2dpdCBhZGQnP1xuIgogIklmIHRoZXJlIGlzIG5vdGhpbmcgbGVmdCB0byBzdGFnZSwgY2hhbmNlcyBhcmUgdGhhdCBzb21ldGhpbmcgZWxzZVxuIgpAQCAtOTAwNSw3ICs5MDQ4LDcgQEAKICJpbnRyb2R1aXQgbGVzIG3Dqm1lcyBjaGFuZ2VtZW50cyA7IHZvdXMgcG91cnJpZXogYXZvaXIgZW52aWUgZGUgc2F1dGVyIGNlICIKICJwYXRjaC4iCiAKLSM6IGJ1aWx0aW4vYW0uYzoxODI4CisjOiBidWlsdGluL2FtLmM6MTgxNwogbXNnaWQgIiIKICJZb3Ugc3RpbGwgaGF2ZSB1bm1lcmdlZCBwYXRocyBpbiB5b3VyIGluZGV4LlxuIgogIllvdSBzaG91bGQgJ2dpdCBhZGQnIGVhY2ggZmlsZSB3aXRoIHJlc29sdmVkIGNvbmZsaWN0cyB0byBtYXJrIHRoZW0gYXMgIgpAQCAtOTAxOCwxNyArOTA2MSwxNyBAQAogIlZvdXMgcG91dmV6IGxhbmNlciAnZ2l0IHJtJyBzdXIgdW4gZmljaGllciBcInN1cHByaW3DqSBwYXIgZXV4XCIgcG91ciAiCiAiYWNjZXB0ZXIgc29uIMOpdGF0LiIKIAotIzogYnVpbHRpbi9hbS5jOjE5MzUgYnVpbHRpbi9hbS5jOjE5MzkgYnVpbHRpbi9hbS5jOjE5NTEgYnVpbHRpbi9yZXNldC5jOjMyOQorIzogYnVpbHRpbi9hbS5jOjE5MjQgYnVpbHRpbi9hbS5jOjE5MjggYnVpbHRpbi9hbS5jOjE5NDAgYnVpbHRpbi9yZXNldC5jOjMyOQogIzogYnVpbHRpbi9yZXNldC5jOjMzNwogIywgYy1mb3JtYXQKIG1zZ2lkICJDb3VsZCBub3QgcGFyc2Ugb2JqZWN0ICclcycuIgogbXNnc3RyICJJbXBvc3NpYmxlIGQnYW5hbHlzZXIgbCdvYmpldCAnJXMnLiIKIAotIzogYnVpbHRpbi9hbS5jOjE5ODcKKyM6IGJ1aWx0aW4vYW0uYzoxOTc2CiBtc2dpZCAiZmFpbGVkIHRvIGNsZWFuIGluZGV4IgogbXNnc3RyICLDqWNoZWMgZHUgbmV0dG95YWdlIGRlIGwnaW5kZXgiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMDMxCisjOiBidWlsdGluL2FtLmM6MjAyMAogbXNnaWQgIiIKICJZb3Ugc2VlbSB0byBoYXZlIG1vdmVkIEhFQUQgc2luY2UgdGhlIGxhc3QgJ2FtJyBmYWlsdXJlLlxuIgogIk5vdCByZXdpbmRpbmcgdG8gT1JJR19IRUFEIgpAQCAtOTAzNiwxNDUgKzkwNzksMTQ1IEBACiAiVm91cyBzZW1ibGV6IGF2b2lyIGTDqXBsYWPDqSBsYSBIRUFEIGRlcHVpcyBsZSBkZXJuaWVyIMOpY2hlYyBkZSAnYW0nLlxuIgogIlBhcyBkZSByZXRvdXIgw6AgT1JJR19IRUFEIgogCi0jOiBidWlsdGluL2FtLmM6MjEyOAorIzogYnVpbHRpbi9hbS5jOjIxMTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiSW52YWxpZCB2YWx1ZSBmb3IgLS1wYXRjaC1mb3JtYXQ6ICVzIgogbXNnc3RyICJWYWxldXIgaW52YWxpZGUgcG91ciAtLXBhdGNoLWZvcm1hdCA6ICVzIgogCi0jOiBidWlsdGluL2FtLmM6MjE2NAorIzogYnVpbHRpbi9hbS5jOjIxNTMKIG1zZ2lkICJnaXQgYW0gWzxvcHRpb25zPl0gWyg8bWJveD4gfCA8TWFpbGRpcj4pLi4uXSIKIG1zZ3N0ciAiZ2l0IGFtIFs8b3B0aW9ucz5dIFsoPG1ib3g+IHwgPE1haWxkaXI+KS4uLl0iCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMTY1CisjOiBidWlsdGluL2FtLmM6MjE1NAogbXNnaWQgImdpdCBhbSBbPG9wdGlvbnM+XSAoLS1jb250aW51ZSB8IC0tc2tpcCB8IC0tYWJvcnQpIgogbXNnc3RyICJnaXQgYW0gWzxvcHRpb25zPl0gKC0tY29udGludWUgfCAtLXNraXAgfCAtLWFib3J0KSIKIAotIzogYnVpbHRpbi9hbS5jOjIxNzEKKyM6IGJ1aWx0aW4vYW0uYzoyMTYwCiBtc2dpZCAicnVuIGludGVyYWN0aXZlbHkiCiBtc2dzdHIgImV4w6ljdXRpb24gaW50ZXJhY3RpdmUiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMTczCisjOiBidWlsdGluL2FtLmM6MjE2MgogbXNnaWQgImhpc3RvcmljYWwgb3B0aW9uIC0tIG5vLW9wIgogbXNnc3RyICJvcHRpb24gaGlzdG9yaXF1ZSAtLSBuby1vcCIKIAotIzogYnVpbHRpbi9hbS5jOjIxNzUKKyM6IGJ1aWx0aW4vYW0uYzoyMTY0CiBtc2dpZCAiYWxsb3cgZmFsbCBiYWNrIG9uIDN3YXkgbWVyZ2luZyBpZiBuZWVkZWQiCiBtc2dzdHIgInBlcm1ldHRyZSBkZSByZXZlbmlyIMOgIHVuZSBmdXNpb24gw6AgMyBwb2ludHMgc2kgbsOpY2Vzc2FpcmUiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMTc2IGJ1aWx0aW4vaW5pdC1kYi5jOjQ5NCBidWlsdGluL3BydW5lLXBhY2tlZC5jOjU4Ci0jOiBidWlsdGluL3JlcGFjay5jOjI5NiBidWlsdGluL3N0YXNoLmM6ODA2CisjOiBidWlsdGluL2FtLmM6MjE2NSBidWlsdGluL2luaXQtZGIuYzo0OTQgYnVpbHRpbi9wcnVuZS1wYWNrZWQuYzo1OAorIzogYnVpbHRpbi9yZXBhY2suYzoyOTcgYnVpbHRpbi9zdGFzaC5jOjgxMgogbXNnaWQgImJlIHF1aWV0IgogbXNnc3RyICLDqnRyZSBzaWxlbmNpZXV4IgogCi0jOiBidWlsdGluL2FtLmM6MjE3OAorIzogYnVpbHRpbi9hbS5jOjIxNjcKIG1zZ2lkICJhZGQgYSBTaWduZWQtb2ZmLWJ5IGxpbmUgdG8gdGhlIGNvbW1pdCBtZXNzYWdlIgogbXNnc3RyICJham91dGVyIHVuZSBsaWduZSBTaWduZWQtb2ZmLWJ5IGF1IG1lc3NhZ2UgZGUgdmFsaWRhdGlvbiIKIAotIzogYnVpbHRpbi9hbS5jOjIxODEKKyM6IGJ1aWx0aW4vYW0uYzoyMTcwCiBtc2dpZCAicmVjb2RlIGludG8gdXRmOCAoZGVmYXVsdCkiCiBtc2dzdHIgInJlY29kZXIgZW4gdXRmLTggKHBhciBkw6lmYXV0KSIKIAotIzogYnVpbHRpbi9hbS5jOjIxODMKKyM6IGJ1aWx0aW4vYW0uYzoyMTcyCiBtc2dpZCAicGFzcyAtayBmbGFnIHRvIGdpdC1tYWlsaW5mbyIKIG1zZ3N0ciAicGFzc2VyIGwnb3B0aW9uIC1rIMOgIGdpdC1tYWlsaW5mbyIKIAotIzogYnVpbHRpbi9hbS5jOjIxODUKKyM6IGJ1aWx0aW4vYW0uYzoyMTc0CiBtc2dpZCAicGFzcyAtYiBmbGFnIHRvIGdpdC1tYWlsaW5mbyIKIG1zZ3N0ciAicGFzc2VyIGwnb3B0aW9uIC1iIMOgIGdpdC1tYWlsaW5mbyIKIAotIzogYnVpbHRpbi9hbS5jOjIxODcKKyM6IGJ1aWx0aW4vYW0uYzoyMTc2CiBtc2dpZCAicGFzcyAtbSBmbGFnIHRvIGdpdC1tYWlsaW5mbyIKIG1zZ3N0ciAicGFzc2VyIGwnb3B0aW9uIC1tIMOgIGdpdC1tYWlsaW5mbyIKIAotIzogYnVpbHRpbi9hbS5jOjIxODkKKyM6IGJ1aWx0aW4vYW0uYzoyMTc4CiBtc2dpZCAicGFzcyAtLWtlZXAtY3IgZmxhZyB0byBnaXQtbWFpbHNwbGl0IGZvciBtYm94IGZvcm1hdCIKIG1zZ3N0ciAicGFzc2VyIGwnb3B0aW9uIC0ta2VlcC1jciDDoCBnaXQtbWFpbHNwbGl0IGZwb3VyIGxlIGZvcm1hdCBtYm94IgogCi0jOiBidWlsdGluL2FtLmM6MjE5MgorIzogYnVpbHRpbi9hbS5jOjIxODEKIG1zZ2lkICJkbyBub3QgcGFzcyAtLWtlZXAtY3IgZmxhZyB0byBnaXQtbWFpbHNwbGl0IGluZGVwZW5kZW50IG9mIGFtLmtlZXBjciIKIG1zZ3N0ciAiIgogIm5lIHBhcyBwYXNzZXIgbCdvcHRpb24gLS1rZWVwLWNyIMOgIGdpdC1tYWlsc3BsaXQgaW5kw6lwZW5kYW1tZW50IGRlIGFtLmtlZXBjciIKIAotIzogYnVpbHRpbi9hbS5jOjIxOTUKKyM6IGJ1aWx0aW4vYW0uYzoyMTg0CiBtc2dpZCAic3RyaXAgZXZlcnl0aGluZyBiZWZvcmUgYSBzY2lzc29ycyBsaW5lIgogbXNnc3RyICJyZXRpcmVyIHRvdXQgbGUgY29udGVudSBhdmFudCBsYSBsaWduZSBkZXMgY2lzZWF1eCIKIAotIzogYnVpbHRpbi9hbS5jOjIxOTcgYnVpbHRpbi9hbS5jOjIyMDAgYnVpbHRpbi9hbS5jOjIyMDMgYnVpbHRpbi9hbS5jOjIyMDYKLSM6IGJ1aWx0aW4vYW0uYzoyMjA5IGJ1aWx0aW4vYW0uYzoyMjEyIGJ1aWx0aW4vYW0uYzoyMjE1IGJ1aWx0aW4vYW0uYzoyMjE4Ci0jOiBidWlsdGluL2FtLmM6MjIyNAorIzogYnVpbHRpbi9hbS5jOjIxODYgYnVpbHRpbi9hbS5jOjIxODkgYnVpbHRpbi9hbS5jOjIxOTIgYnVpbHRpbi9hbS5jOjIxOTUKKyM6IGJ1aWx0aW4vYW0uYzoyMTk4IGJ1aWx0aW4vYW0uYzoyMjAxIGJ1aWx0aW4vYW0uYzoyMjA0IGJ1aWx0aW4vYW0uYzoyMjA3CisjOiBidWlsdGluL2FtLmM6MjIxMwogbXNnaWQgInBhc3MgaXQgdGhyb3VnaCBnaXQtYXBwbHkiCiBtc2dzdHIgImxlIHBhc3NlciBqdXNxdSfDoCBnaXQtYXBwbHkiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMjE0IGJ1aWx0aW4vY29tbWl0LmM6MTM2OCBidWlsdGluL2ZtdC1tZXJnZS1tc2cuYzo2NzEKLSM6IGJ1aWx0aW4vZm10LW1lcmdlLW1zZy5jOjY3NCBidWlsdGluL2dyZXAuYzo4ODEgYnVpbHRpbi9tZXJnZS5jOjI0OQotIzogYnVpbHRpbi9wdWxsLmM6MTU5IGJ1aWx0aW4vcHVsbC5jOjIxOCBidWlsdGluL3JlYmFzZS5jOjE0MTgKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MzA3IGJ1aWx0aW4vcmVwYWNrLmM6MzExIGJ1aWx0aW4vcmVwYWNrLmM6MzEzCisjOiBidWlsdGluL2FtLmM6MjIwMyBidWlsdGluL2NvbW1pdC5jOjEzNjggYnVpbHRpbi9mbXQtbWVyZ2UtbXNnLmM6NjcxCisjOiBidWlsdGluL2ZtdC1tZXJnZS1tc2cuYzo2NzQgYnVpbHRpbi9ncmVwLmM6ODgzIGJ1aWx0aW4vbWVyZ2UuYzoyNDkKKyM6IGJ1aWx0aW4vcHVsbC5jOjE2MCBidWlsdGluL3B1bGwuYzoyMTkgYnVpbHRpbi9yZWJhc2UuYzoxNDQyCisjOiBidWlsdGluL3JlcGFjay5jOjMwOCBidWlsdGluL3JlcGFjay5jOjMxMiBidWlsdGluL3JlcGFjay5jOjMxNAogIzogYnVpbHRpbi9zaG93LWJyYW5jaC5jOjY1MCBidWlsdGluL3Nob3ctcmVmLmM6MTcyIGJ1aWx0aW4vdGFnLmM6NDAzCi0jOiBwYXJzZS1vcHRpb25zLmg6MTQxIHBhcnNlLW9wdGlvbnMuaDoxNjIgcGFyc2Utb3B0aW9ucy5oOjMxMgorIzogcGFyc2Utb3B0aW9ucy5oOjE1MCBwYXJzZS1vcHRpb25zLmg6MTcxIHBhcnNlLW9wdGlvbnMuaDozMTIKIG1zZ2lkICJuIgogbXNnc3RyICJuIgogCi0jOiBidWlsdGluL2FtLmM6MjIyMCBidWlsdGluL2JyYW5jaC5jOjY2MSBidWlsdGluL2Zvci1lYWNoLXJlZi5jOjM4Ci0jOiBidWlsdGluL3JlcGxhY2UuYzo1NTQgYnVpbHRpbi90YWcuYzo0MzcgYnVpbHRpbi92ZXJpZnktdGFnLmM6MzgKKyM6IGJ1aWx0aW4vYW0uYzoyMjA5IGJ1aWx0aW4vYnJhbmNoLmM6NjYxIGJ1aWx0aW4vZm9yLWVhY2gtcmVmLmM6MzgKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU1NSBidWlsdGluL3RhZy5jOjQzNyBidWlsdGluL3ZlcmlmeS10YWcuYzozOAogbXNnaWQgImZvcm1hdCIKIG1zZ3N0ciAiZm9ybWF0IgogCi0jOiBidWlsdGluL2FtLmM6MjIyMQorIzogYnVpbHRpbi9hbS5jOjIyMTAKIG1zZ2lkICJmb3JtYXQgdGhlIHBhdGNoKGVzKSBhcmUgaW4iCiBtc2dzdHIgImZvcm1hdCBkZSBwcsOpc2VudGF0aW9uIGRlcyBwYXRjaHMiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMjI3CisjOiBidWlsdGluL2FtLmM6MjIxNgogbXNnaWQgIm92ZXJyaWRlIGVycm9yIG1lc3NhZ2Ugd2hlbiBwYXRjaCBmYWlsdXJlIG9jY3VycyIKIG1zZ3N0ciAic3VyY2hhcmdlciBsZSBtZXNzYWdlIGQnZXJyZXVyIGxvcnMgZCd1biDDqWNoZWMgZCdhcHBsaWNhdGlvbiBkZSBwYXRjaCIKIAotIzogYnVpbHRpbi9hbS5jOjIyMjkKKyM6IGJ1aWx0aW4vYW0uYzoyMjE4CiBtc2dpZCAiY29udGludWUgYXBwbHlpbmcgcGF0Y2hlcyBhZnRlciByZXNvbHZpbmcgYSBjb25mbGljdCIKIG1zZ3N0ciAiY29udGludWVyIMOgIGFwcGxpcXVlciBsZXMgcGF0Y2hzIGFwcsOocyByw6lzb2x1dGlvbiBkJ3VuIGNvbmZsaXQiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMjMyCisjOiBidWlsdGluL2FtLmM6MjIyMQogbXNnaWQgInN5bm9ueW1zIGZvciAtLWNvbnRpbnVlIgogbXNnc3RyICJzeW5vbnltZXMgZGUgLS1jb250aW51ZSIKIAotIzogYnVpbHRpbi9hbS5jOjIyMzUKKyM6IGJ1aWx0aW4vYW0uYzoyMjI0CiBtc2dpZCAic2tpcCB0aGUgY3VycmVudCBwYXRjaCIKIG1zZ3N0ciAic2F1dGVyIGxlIHBhdGNoIGNvdXJhbnQiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMjM4CisjOiBidWlsdGluL2FtLmM6MjIyNwogbXNnaWQgInJlc3RvcmUgdGhlIG9yaWdpbmFsIGJyYW5jaCBhbmQgYWJvcnQgdGhlIHBhdGNoaW5nIG9wZXJhdGlvbi4iCiBtc2dzdHIgIiIKICJyZXN0YXVyZXIgbGEgYnJhbmNoZSBvcmlnaW5hbGUgZXQgYWJhbmRvbm5lciBsZXMgYXBwbGljYXRpb25zIGRlIHBhdGNoLiIKIAotIzogYnVpbHRpbi9hbS5jOjIyNDEKKyM6IGJ1aWx0aW4vYW0uYzoyMjMwCiBtc2dpZCAiYWJvcnQgdGhlIHBhdGNoaW5nIG9wZXJhdGlvbiBidXQga2VlcCBIRUFEIHdoZXJlIGl0IGlzLiIKIG1zZ3N0ciAiYWJhbmRvbm5lIGwnb3DDqXJhdGlvbiBkZSBwYXRjaCBtYWlzIGdhcmRlIEhFQUQgb8O5IGlsIGVzdC4iCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMjQ0CisjOiBidWlsdGluL2FtLmM6MjIzMwogbXNnaWQgInNob3cgdGhlIHBhdGNoIGJlaW5nIGFwcGxpZWQuIgogbXNnc3RyICJhZmZpY2hlciBsZSBwYXRjaCBlbiBjb3VycyBkJ2FwcGxpY2F0aW9uLiIKIAotIzogYnVpbHRpbi9hbS5jOjIyNDgKKyM6IGJ1aWx0aW4vYW0uYzoyMjM3CiBtc2dpZCAibGllIGFib3V0IGNvbW1pdHRlciBkYXRlIgogbXNnc3RyICJtZW50aXIgc3VyIGxhIGRhdGUgZGUgdmFsaWRhdGlvbiIKIAotIzogYnVpbHRpbi9hbS5jOjIyNTAKKyM6IGJ1aWx0aW4vYW0uYzoyMjM5CiBtc2dpZCAidXNlIGN1cnJlbnQgdGltZXN0YW1wIGZvciBhdXRob3IgZGF0ZSIKIG1zZ3N0ciAidXRpbGlzZXIgbCdob3JvZGF0YWdlIGFjdHVlbCBwb3VyIGxhIGRhdGUgZCdhdXRldXIiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMjUyIGJ1aWx0aW4vY29tbWl0LXRyZWUuYzoxMjAgYnVpbHRpbi9jb21taXQuYzoxNTExCi0jOiBidWlsdGluL21lcmdlLmM6Mjg2IGJ1aWx0aW4vcHVsbC5jOjE5MyBidWlsdGluL3JlYmFzZS5jOjQ4OQotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDU5IGJ1aWx0aW4vcmV2ZXJ0LmM6MTE3IGJ1aWx0aW4vdGFnLmM6NDE4CisjOiBidWlsdGluL2FtLmM6MjI0MSBidWlsdGluL2NvbW1pdC10cmVlLmM6MTIwIGJ1aWx0aW4vY29tbWl0LmM6MTUxMQorIzogYnVpbHRpbi9tZXJnZS5jOjI4NiBidWlsdGluL3B1bGwuYzoxOTQgYnVpbHRpbi9yZWJhc2UuYzo0OTAKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ4MyBidWlsdGluL3JldmVydC5jOjExNyBidWlsdGluL3RhZy5jOjQxOAogbXNnaWQgImtleS1pZCIKIG1zZ3N0ciAiaWQtY2zDqSIKIAotIzogYnVpbHRpbi9hbS5jOjIyNTMgYnVpbHRpbi9yZWJhc2UuYzo0OTAgYnVpbHRpbi9yZWJhc2UuYzoxNDYwCisjOiBidWlsdGluL2FtLmM6MjI0MiBidWlsdGluL3JlYmFzZS5jOjQ5MSBidWlsdGluL3JlYmFzZS5jOjE0ODQKIG1zZ2lkICJHUEctc2lnbiBjb21taXRzIgogbXNnc3RyICJzaWduZXIgbGVzIGNvbW1pdHMgYXZlYyBHUEciCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMjU2CisjOiBidWlsdGluL2FtLmM6MjI0NQogbXNnaWQgIihpbnRlcm5hbCB1c2UgZm9yIGdpdC1yZWJhc2UpIgogbXNnc3RyICIodXRpbGlzYXRpb24gaW50ZXJuZSBwb3VyIGdpdC1yZWJhc2UpIgogCi0jOiBidWlsdGluL2FtLmM6MjI3NAorIzogYnVpbHRpbi9hbS5jOjIyNjMKIG1zZ2lkICIiCiAiVGhlIC1iLy0tYmluYXJ5IG9wdGlvbiBoYXMgYmVlbiBhIG5vLW9wIGZvciBsb25nIHRpbWUsIGFuZFxuIgogIml0IHdpbGwgYmUgcmVtb3ZlZC4gUGxlYXNlIGRvIG5vdCB1c2UgaXQgYW55bW9yZS4iCkBAIC05MTgyLDE3ICs5MjI1LDE3IEBACiAiTCdvcHRpb24gLWIvLS1iaW5hcnkgbmUgZmFpdCBwbHVzIHJpZW4gZGVwdWlzIGxvbmd0ZW1wcyxcbiIKICJldCBlbGxlIHNlcmEgc3VwcHJpbcOpZS4gVmV1aWxsZXogbmUgcGx1cyBsJ3V0aWxpc2VyLiIKIAotIzogYnVpbHRpbi9hbS5jOjIyODEKKyM6IGJ1aWx0aW4vYW0uYzoyMjcwCiBtc2dpZCAiZmFpbGVkIHRvIHJlYWQgdGhlIGluZGV4IgogbXNnc3RyICLDqWNoZWMgw6AgbGEgbGVjdHVyZSBkZSBsJ2luZGV4IgogCi0jOiBidWlsdGluL2FtLmM6MjI5NgorIzogYnVpbHRpbi9hbS5jOjIyODUKICMsIGMtZm9ybWF0CiBtc2dpZCAicHJldmlvdXMgcmViYXNlIGRpcmVjdG9yeSAlcyBzdGlsbCBleGlzdHMgYnV0IG1ib3ggZ2l2ZW4uIgogbXNnc3RyICIiCiAibGUgcsOpcGVydG9pcmUgcHLDqWPDqWRlbnQgZGUgcmViYXNhZ2UgJXMgZXhpc3RlIHRvdWpvdXJzIG1haXMgbWJveCBkb25uw6llLiIKIAotIzogYnVpbHRpbi9hbS5jOjIzMjAKKyM6IGJ1aWx0aW4vYW0uYzoyMzA5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJTdHJheSAlcyBkaXJlY3RvcnkgZm91bmQuXG4iCkBAIC05MjAxLDEzICs5MjQ0LDEzIEBACiAiUsOpcGVydG9pcmUgYWJhbmRvbm7DqSAlcyB0cm91dsOpLlxuIgogIlV0aWxpc2V6IFwiZ2l0IGFtIC0tYWJvcnRcIiBwb3VyIGxlIHN1cHByaW1lci4iCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMzI2CisjOiBidWlsdGluL2FtLmM6MjMxNQogbXNnaWQgIlJlc29sdmUgb3BlcmF0aW9uIG5vdCBpbiBwcm9ncmVzcywgd2UgYXJlIG5vdCByZXN1bWluZy4iCiBtc2dzdHIgIiIKICJQYXMgZGUgcsOpc29sdXRpb24gZGUgbCdvcMOpcmF0aW9uIGVuIGNvdXJzLCBub3VzIG5lIHNvbW1lcyBwYXMgZGFucyB1bmUgIgogInJlcHJpc2UuIgogCi0jOiBidWlsdGluL2FtLmM6MjMzNgorIzogYnVpbHRpbi9hbS5jOjIzMjUKIG1zZ2lkICJpbnRlcmFjdGl2ZSBtb2RlIHJlcXVpcmVzIHBhdGNoZXMgb24gdGhlIGNvbW1hbmQgbGluZSIKIG1zZ3N0ciAibGUgbW9kZSBpbnRlcmFjdGlmIHJlcXVpZXJ0IGRlcyBydXN0aW5lcyBzdXIgbGEgbGlnbmUgZGUgY29tbWFuZGUiCiAKQEAgLTk1MjUsMTYwICs5NTY4LDE2MCBAQAogbXNnaWQgIi0tYmlzZWN0LXRlcm1zIHJlcXVpcmVzIDAgb3IgMSBhcmd1bWVudCIKIG1zZ3N0ciAiLS1iaXNlY3QtdGVybXMgZXhpZ2UgMCBvdSAxIGFyZ3VtZW50IgogCi0jOiBidWlsdGluL2JsYW1lLmM6MzIKKyM6IGJ1aWx0aW4vYmxhbWUuYzozMQogbXNnaWQgImdpdCBibGFtZSBbPG9wdGlvbnM+XSBbPHJldi1vcHRzPl0gWzxyZXY+XSBbLS1dIDxmaWxlPiIKIG1zZ3N0ciAiZ2l0IGJsYW1lIFs8b3B0aW9ucz5dIFs8cmV2LW9wdHM+XSBbPHJldj5dIFstLV0gPGZpY2hpZXI+IgogCi0jOiBidWlsdGluL2JsYW1lLmM6MzcKKyM6IGJ1aWx0aW4vYmxhbWUuYzozNgogbXNnaWQgIjxyZXYtb3B0cz4gYXJlIGRvY3VtZW50ZWQgaW4gZ2l0LXJldi1saXN0KDEpIgogbXNnc3RyICI8b3B0aW9ucy1kZS1yw6l2aXNpb24+IHNvbnQgZG9jdW1lbnTDqXMgZGFucyBnaXQtcmV2LWxpc3QoMSkiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo0MTAKKyM6IGJ1aWx0aW4vYmxhbWUuYzo0MDkKICMsIGMtZm9ybWF0CiBtc2dpZCAiZXhwZWN0aW5nIGEgY29sb3I6ICVzIgogbXNnc3RyICJjb3VsZXVyIGF0dGVuZHVlwqA6ICVzIgogCi0jOiBidWlsdGluL2JsYW1lLmM6NDE3CisjOiBidWlsdGluL2JsYW1lLmM6NDE2CiBtc2dpZCAibXVzdCBlbmQgd2l0aCBhIGNvbG9yIgogbXNnc3RyICJkb2l0IGZpbmlyIGF2ZWMgdW5lIGNvdWxldXIiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo3MzAKKyM6IGJ1aWx0aW4vYmxhbWUuYzo3MjkKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBjb2xvciAnJXMnIGluIGNvbG9yLmJsYW1lLnJlcGVhdGVkTGluZXMiCiBtc2dzdHIgImNvdWxldXIgaW52YWxpZGUgJyVzJyBkYW5zIGNvbG9yLmJsYW1lLnJlcGVhdGVkbGluZXMiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo3NDgKKyM6IGJ1aWx0aW4vYmxhbWUuYzo3NDcKIG1zZ2lkICJpbnZhbGlkIHZhbHVlIGZvciBibGFtZS5jb2xvcmluZyIKIG1zZ3N0ciAidmFsZXVyIGludmFsaWRlIHBvdXIgYmxhbWUuY29sb3JpbmciCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4MjMKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4MjIKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IGZpbmQgcmV2aXNpb24gJXMgdG8gaWdub3JlIgogbXNnc3RyICJyw6lmw6lyZW5jZSDDoCBpZ25vcmVyICVzIGludHJvdXZhYmxlIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODQ1CisjOiBidWlsdGluL2JsYW1lLmM6ODQ0CiBtc2dpZCAiU2hvdyBibGFtZSBlbnRyaWVzIGFzIHdlIGZpbmQgdGhlbSwgaW5jcmVtZW50YWxseSIKIG1zZ3N0ciAiIgogIk1vbnRyZXIgbGVzIMOpbMOpbWVudHMgZGUgYmzDom1lIGF1IGZ1ciBldCDDoCBtZXN1cmUgZGUgbGV1ciBkw6ljb3V2ZXJ0ZSwgZGUgIgogIm1hbmnDqHJlIGluY3LDqW1lbnRhbGUiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NDYKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NDUKIG1zZ2lkICJTaG93IGJsYW5rIFNIQS0xIGZvciBib3VuZGFyeSBjb21taXRzIChEZWZhdWx0OiBvZmYpIgogbXNnc3RyICJNb250cmVyIHVuIFNIQS0xIGJsYW5jIHBvdXIgbGVzIGNvbW1pdHMgZGUgbGltaXRlIChEw6lmYXV0IDogZMOpc2FjdGl2w6kpIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODQ3CisjOiBidWlsdGluL2JsYW1lLmM6ODQ2CiBtc2dpZCAiRG8gbm90IHRyZWF0IHJvb3QgY29tbWl0cyBhcyBib3VuZGFyaWVzIChEZWZhdWx0OiBvZmYpIgogbXNnc3RyICIiCiAiTmUgcGFzIHRyYWl0ZXIgbGVzIGNvbW1pdHMgcmFjaW5lIGNvbW1lIGRlcyBsaW1pdGVzIChEw6lmYXV0IDogZMOpc2FjdGl2w6kpIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODQ4CisjOiBidWlsdGluL2JsYW1lLmM6ODQ3CiBtc2dpZCAiU2hvdyB3b3JrIGNvc3Qgc3RhdGlzdGljcyIKIG1zZ3N0ciAiTW9udHJlciBsZXMgc3RhdGlzdGlxdWVzIGRlIGNvw7t0IGQnYWN0aXZpdMOpIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODQ5CisjOiBidWlsdGluL2JsYW1lLmM6ODQ4CiBtc2dpZCAiRm9yY2UgcHJvZ3Jlc3MgcmVwb3J0aW5nIgogbXNnc3RyICJGb3JjZXIgbCdhZmZpY2hhZ2UgZGUgbCfDqXRhdCBkJ2F2YW5jZW1lbnQiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NTAKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NDkKIG1zZ2lkICJTaG93IG91dHB1dCBzY29yZSBmb3IgYmxhbWUgZW50cmllcyIKIG1zZ3N0ciAiTW9udHJlciBsZSBzY29yZSBkZSBzb3J0aWUgcG91ciBsZXMgw6lsw6ltZW50cyBkZSBibMOibWUiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NTEKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NTAKIG1zZ2lkICJTaG93IG9yaWdpbmFsIGZpbGVuYW1lIChEZWZhdWx0OiBhdXRvKSIKIG1zZ3N0ciAiTW9udHJlciBsZXMgbm9tcyBkZSBmaWNoaWVyIG9yaWdpbmF1eCAoRMOpZmF1dCA6IGF1dG8pIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODUyCisjOiBidWlsdGluL2JsYW1lLmM6ODUxCiBtc2dpZCAiU2hvdyBvcmlnaW5hbCBsaW5lbnVtYmVyIChEZWZhdWx0OiBvZmYpIgogbXNnc3RyICJNb250cmVyIGxlcyBudW3DqXJvcyBkZSBsaWduZXMgb3JpZ2luYXV4IChEw6lmYXV0IDogZMOpc2FjdGl2w6kpIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODUzCisjOiBidWlsdGluL2JsYW1lLmM6ODUyCiBtc2dpZCAiU2hvdyBpbiBhIGZvcm1hdCBkZXNpZ25lZCBmb3IgbWFjaGluZSBjb25zdW1wdGlvbiIKIG1zZ3N0ciAiQWZmaWNoZXIgZGFucyB1biBmb3JtYXQgcHJvcGljZSDDoCBsYSBjb25zb21tYXRpb24gcGFyIG1hY2hpbmUiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NTQKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NTMKIG1zZ2lkICJTaG93IHBvcmNlbGFpbiBmb3JtYXQgd2l0aCBwZXItbGluZSBjb21taXQgaW5mb3JtYXRpb24iCiBtc2dzdHIgIkFmZmljaGVyIGVuIGZvcm1hdCBwb3JjZWxhaW5lIGF2ZWMgbCdpbmZvcm1hdGlvbiBkZSBjb21taXQgcGFyIGxpZ25lIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODU1CisjOiBidWlsdGluL2JsYW1lLmM6ODU0CiBtc2dpZCAiVXNlIHRoZSBzYW1lIG91dHB1dCBtb2RlIGFzIGdpdC1hbm5vdGF0ZSAoRGVmYXVsdDogb2ZmKSIKIG1zZ3N0ciAiVXRpbGlzZXIgbGUgbcOqbWUgbW9kZSBkZSBzb3J0aWUgcXVlIGdpdC1hbm5vdGF0ZSAoRMOpZmF1dCA6IGTDqXNhY3RpdsOpKSIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg1NgorIzogYnVpbHRpbi9ibGFtZS5jOjg1NQogbXNnaWQgIlNob3cgcmF3IHRpbWVzdGFtcCAoRGVmYXVsdDogb2ZmKSIKIG1zZ3N0ciAiQWZmaWNoZXIgbGVzIGhvcm9kYXRhZ2VzIGJydXRzIChEw6lmYXV0IDogZMOpc2FjdGl2w6kpIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODU3CisjOiBidWlsdGluL2JsYW1lLmM6ODU2CiBtc2dpZCAiU2hvdyBsb25nIGNvbW1pdCBTSEExIChEZWZhdWx0OiBvZmYpIgogbXNnc3RyICJBZmZpY2hlciBsZXMgbG9uZ3MgU0hBMSBkZSBjb21taXRzIChEw6lmYXV0IDogZMOpc2FjdGl2w6kpIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODU4CisjOiBidWlsdGluL2JsYW1lLmM6ODU3CiBtc2dpZCAiU3VwcHJlc3MgYXV0aG9yIG5hbWUgYW5kIHRpbWVzdGFtcCAoRGVmYXVsdDogb2ZmKSIKIG1zZ3N0ciAiU3VwcHJpbWVyIGxlIG5vbSBkZSBsJ2F1dGV1ciBldCBsJ2hvcm9kYXRhZ2UgKETDqWZhdXQgOiBkw6lzYWN0aXbDqSkiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NTkKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NTgKIG1zZ2lkICJTaG93IGF1dGhvciBlbWFpbCBpbnN0ZWFkIG9mIG5hbWUgKERlZmF1bHQ6IG9mZikiCiBtc2dzdHIgIkFmZmljaGVyIGxlIGNvdXJyaWVsIGRlIGwnYXV0ZXVyIGF1IGxpZXUgZHUgbm9tIChEw6lmYXV0IDogZMOpc2FjdGl2w6kpIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODYwCisjOiBidWlsdGluL2JsYW1lLmM6ODU5CiBtc2dpZCAiSWdub3JlIHdoaXRlc3BhY2UgZGlmZmVyZW5jZXMiCiBtc2dzdHIgIklnbm9yZXIgbGVzIGRpZmbDqXJlbmNlcyBkJ2VzcGFjZSIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg2MSBidWlsdGluL2xvZy5jOjE2MjkKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NjAgYnVpbHRpbi9sb2cuYzoxNjMwCiBtc2dpZCAicmV2IgogbXNnc3RyICJyw6l2IgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODYxCisjOiBidWlsdGluL2JsYW1lLmM6ODYwCiBtc2dpZCAiSWdub3JlIDxyZXY+IHdoZW4gYmxhbWluZyIKIG1zZ3N0ciAiaWdub3JlIDxyZXY+IHBlbmRhbnQgbGUgYmzDom1lIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODYyCisjOiBidWlsdGluL2JsYW1lLmM6ODYxCiBtc2dpZCAiSWdub3JlIHJldmlzaW9ucyBmcm9tIDxmaWxlPiIKIG1zZ3N0ciAiaWdub3JlciBsZXMgcsOpdmlzaW9ucyBsaXN0w6llcyBkYW5zIDxmaWNoaWVyPiIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg2MworIzogYnVpbHRpbi9ibGFtZS5jOjg2MgogbXNnaWQgImNvbG9yIHJlZHVuZGFudCBtZXRhZGF0YSBmcm9tIHByZXZpb3VzIGxpbmUgZGlmZmVyZW50bHkiCiBtc2dzdHIgIiIKICJjb2xvcmVyIGRpZmbDqXJlbW1lbnQgbGVzIG3DqXRhZG9ubsOpZXMgcmVkb25kYW50ZXMgYXZlYyBsYSBsaWduZSBwcsOpY8OpZGVudGUiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NjQKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NjMKIG1zZ2lkICJjb2xvciBsaW5lcyBieSBhZ2UiCiBtc2dzdHIgImNvbG9yaWVyIGxlcyBsaWduZXMgcGFyIMOiZ2UiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NzEKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NzAKIG1zZ2lkICJVc2UgYW4gZXhwZXJpbWVudGFsIGhldXJpc3RpYyB0byBpbXByb3ZlIGRpZmZzIgogbXNnc3RyICJVdGlsaXNlciB1bmUgaGV1cmlzdGlxdWUgZXhww6lyaW1lbnRhbGUgcG91ciBhbcOpbGlvcmVyIGxlcyBkaWZmcyIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg3MworIzogYnVpbHRpbi9ibGFtZS5jOjg3MgogbXNnaWQgIlNwZW5kIGV4dHJhIGN5Y2xlcyB0byBmaW5kIGJldHRlciBtYXRjaCIKIG1zZ3N0ciAiIgogIkTDqXBlbnNlciBkZXMgY3ljbGVzIHN1cHBsw6ltZW50YWlyZXMgcG91ciB0cm91dmVyIHVuZSBtZWlsbGV1cmUgY29ycmVzcG9uZGFuY2UiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NzQKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NzMKIG1zZ2lkICJVc2UgcmV2aXNpb25zIGZyb20gPGZpbGU+IGluc3RlYWQgb2YgY2FsbGluZyBnaXQtcmV2LWxpc3QiCiBtc2dzdHIgIiIKICJVdGlsaXNlciBsZXMgcsOpdmlzaW9ucyBkdSBmaWNoaWVyIDxmaWNoaWVyPiBhdSBsaWV1IGQnYXBwZWxlciBnaXQtcmV2LWxpc3QiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NzUKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NzQKIG1zZ2lkICJVc2UgPGZpbGU+J3MgY29udGVudHMgYXMgdGhlIGZpbmFsIGltYWdlIgogbXNnc3RyICJVdGlsaXNlciBsZSBjb250ZW51IGRlIDxmaWNoaWVyPiBjb21tZSBpbWFnZSBmaW5hbGUiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NzYgYnVpbHRpbi9ibGFtZS5jOjg3NworIzogYnVpbHRpbi9ibGFtZS5jOjg3NSBidWlsdGluL2JsYW1lLmM6ODc2CiBtc2dpZCAic2NvcmUiCiBtc2dzdHIgInNjb3JlIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODc2CisjOiBidWlsdGluL2JsYW1lLmM6ODc1CiBtc2dpZCAiRmluZCBsaW5lIGNvcGllcyB3aXRoaW4gYW5kIGFjcm9zcyBmaWxlcyIKIG1zZ3N0ciAiVHJvdXZlciBsZXMgY29waWVzIGRlIGxpZ25lIGRhbnMgZXQgZW50cmUgbGVzIGZpY2hpZXJzIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODc3CisjOiBidWlsdGluL2JsYW1lLmM6ODc2CiBtc2dpZCAiRmluZCBsaW5lIG1vdmVtZW50cyB3aXRoaW4gYW5kIGFjcm9zcyBmaWxlcyIKIG1zZ3N0ciAiVHJvdXZlciBsZXMgbW91dmVtZW50cyBkZSBsaWduZSBkYW5zIGV0IGVudHJlIGxlcyBmaWNoaWVycyIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg3OAorIzogYnVpbHRpbi9ibGFtZS5jOjg3NwogbXNnaWQgIm4sbSIKIG1zZ3N0ciAibixtIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODc4CisjOiBidWlsdGluL2JsYW1lLmM6ODc3CiBtc2dpZCAiUHJvY2VzcyBvbmx5IGxpbmUgcmFuZ2UgbixtLCBjb3VudGluZyBmcm9tIDEiCiBtc2dzdHIgIiIKICJUcmFpdGVyIHNldWxlbWVudCBsJ2ludGVydmFsbGUgZGUgbGlnbmUgbixtIGVuIGNvbW1lbsOnYW50IGxlIGNvbXB0ZSDDoCAxIgpAQCAtOTkyMyw3ICs5OTY2LDcgQEAKIG1zZ2lkICJkbyBub3QgdXNlIgogbXNnc3RyICJuZSBwYXMgdXRpbGlzZXIiCiAKLSM6IGJ1aWx0aW4vYnJhbmNoLmM6NjI2IGJ1aWx0aW4vcmViYXNlLmM6NDg1CisjOiBidWlsdGluL2JyYW5jaC5jOjYyNiBidWlsdGluL3JlYmFzZS5jOjQ4NgogbXNnaWQgInVwc3RyZWFtIgogbXNnc3RyICJhbW9udCIKIApAQCAtMTAwMzQsNyArMTAwNzcsNyBAQAogbXNnaWQgImZvcm1hdCB0byB1c2UgZm9yIHRoZSBvdXRwdXQiCiBtc2dzdHIgImZvcm1hdCDDoCB1dGlsaXNlciBwb3VyIGxhIHNvcnRpZSIKIAotIzogYnVpbHRpbi9icmFuY2guYzo2ODQgYnVpbHRpbi9jbG9uZS5jOjc2MQorIzogYnVpbHRpbi9icmFuY2guYzo2ODQgYnVpbHRpbi9jbG9uZS5jOjc2MAogbXNnaWQgIkhFQUQgbm90IGZvdW5kIGJlbG93IHJlZnMvaGVhZHMhIgogbXNnc3RyICJIRUFEIG5vbiB0cm91dsOpZSBzb3VzIHJlZnMvaGVhZHMgISIKIApAQCAtMTAxMzksNyArMTAxODIsNyBAQAogbXNnaWQgIk5lZWQgYSByZXBvc2l0b3J5IHRvIHVuYnVuZGxlLiIKIG1zZ3N0ciAiTGUgZMOpcGFxdWV0YWdlIGQndW4gY29saXMgcmVxdWllcnQgdW4gZMOpcMO0dC4iCiAKLSM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo1OTQKKyM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo1OTUKIG1zZ2lkICIiCiAiZ2l0IGNhdC1maWxlICgtdCBbLS1hbGxvdy11bmtub3duLXR5cGVdIHwgLXMgWy0tYWxsb3ctdW5rbm93bi10eXBlXSB8IC1lIHwgLSIKICJwIHwgPHR5cGU+IHwgLS10ZXh0Y29udiB8IC0tZmlsdGVycykgWy0tcGF0aD08cGF0aD5dIDxvYmplY3Q+IgpAQCAtMTAxNDcsNyArMTAxOTAsNyBAQAogImdpdCBjYXQtZmlsZSAoLXQgWy0tYWxsb3ctdW5rbm93LXR5cGVdIHwgLXMgWy0tYWxsb3ctdW5rbm93LXR5cGVdIHwgLWUgfCAtcCAiCiAifCA8dHlwZT4gfCAtLXRleHRjb252IHwgLS1maWx0ZXJzKSBbLS1wYXRoPTxjaGVtaW4+XSA8b2JqZXQ+IgogCi0jOiBidWlsdGluL2NhdC1maWxlLmM6NTk1CisjOiBidWlsdGluL2NhdC1maWxlLmM6NTk2CiBtc2dpZCAiIgogImdpdCBjYXQtZmlsZSAoLS1iYXRjaCB8IC0tYmF0Y2gtY2hlY2spIFstLWZvbGxvdy1zeW1saW5rc10gWy0tdGV4dGNvbnYgfCAtLSIKICJmaWx0ZXJzXSIKQEAgLTEwMTU1LDc0ICsxMDE5OCw3NCBAQAogImdpdCBjYXQtZmlsZSAoLS1iYXRjaCB8IC0tYmF0Y2gtY2hlY2spIFstLWZvbGxvdy1zeW1saW5rc10gWy0tdGV4dGNvbnYgfCAtLSIKICJmaWx0ZXJzXSIKIAotIzogYnVpbHRpbi9jYXQtZmlsZS5jOjYxNgorIzogYnVpbHRpbi9jYXQtZmlsZS5jOjYxNwogbXNnaWQgIm9ubHkgb25lIGJhdGNoIG9wdGlvbiBtYXkgYmUgc3BlY2lmaWVkIgogbXNnc3RyICJ1bmUgc2V1bGUgb3B0aW9uIGRlIHRyYWl0ZW1lbnQgbmUgcGV1dCDDqnRyZSBzcMOpY2lmacOpZSDDoCBsYSBmb2lzIgogCi0jOiBidWlsdGluL2NhdC1maWxlLmM6NjM0CisjOiBidWlsdGluL2NhdC1maWxlLmM6NjM1CiBtc2dpZCAiPHR5cGU+IGNhbiBiZSBvbmUgb2Y6IGJsb2IsIHRyZWUsIGNvbW1pdCwgdGFnIgogbXNnc3RyICI8dHlwZT4gcGV1dCDDqnRyZSA6IGJsb2IsIHRyZWUsIGNvbW1pdCBvdSB0YWciCiAKLSM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2MzUKKyM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2MzYKIG1zZ2lkICJzaG93IG9iamVjdCB0eXBlIgogbXNnc3RyICJhZmZpY2hlciBsZSB0eXBlIGRlIGwnb2JqZXQiCiAKLSM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2MzYKKyM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2MzcKIG1zZ2lkICJzaG93IG9iamVjdCBzaXplIgogbXNnc3RyICJhZmZpY2hlciBsYSB0YWlsbGUgZGUgbCdvYmpldCIKIAotIzogYnVpbHRpbi9jYXQtZmlsZS5jOjYzOAorIzogYnVpbHRpbi9jYXQtZmlsZS5jOjYzOQogbXNnaWQgImV4aXQgd2l0aCB6ZXJvIHdoZW4gdGhlcmUncyBubyBlcnJvciIKIG1zZ3N0ciAic29ydGlyIGF2ZWMgdW4gY29kZSBkJ2VycmV1ciBudWwgcXVhbmQgaWwgbid5IGEgYXVjdW5lIGVycmV1ciIKIAotIzogYnVpbHRpbi9jYXQtZmlsZS5jOjYzOQorIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY0MAogbXNnaWQgInByZXR0eS1wcmludCBvYmplY3QncyBjb250ZW50IgogbXNnc3RyICJhZmZpY2hlciBhdmVjIG1pc2UgZW4gZm9ybWUgbGUgY29udGVudSBkZSBsJ29iamV0IgogCi0jOiBidWlsdGluL2NhdC1maWxlLmM6NjQxCisjOiBidWlsdGluL2NhdC1maWxlLmM6NjQyCiBtc2dpZCAiZm9yIGJsb2Igb2JqZWN0cywgcnVuIHRleHRjb252IG9uIG9iamVjdCdzIGNvbnRlbnQiCiBtc2dzdHIgInBvdXIgbGVzIG9iamV0cyBibG9iLCBsYW5jZXIgdGV4dGNvbnYgc3VyIGxlIGNvbnRlbnUgZGUgbCdvYmpldCIKIAotIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY0MworIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY0NAogbXNnaWQgImZvciBibG9iIG9iamVjdHMsIHJ1biBmaWx0ZXJzIG9uIG9iamVjdCdzIGNvbnRlbnQiCiBtc2dzdHIgInBvdXIgbGVzIG9iamV0cyBibG9iLCBsYW5jZXIgbGVzIGZpbHRyZXMgc3VyIGxlIGNvbnRlbnUgZGUgbCdvYmpldCIKIAotIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY0NCBnaXQtc3VibW9kdWxlLnNoOjkzNgorIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY0NSBnaXQtc3VibW9kdWxlLnNoOjkzNgogbXNnaWQgImJsb2IiCiBtc2dzdHIgImJsb2IiCiAKLSM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NDUKKyM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NDYKIG1zZ2lkICJ1c2UgYSBzcGVjaWZpYyBwYXRoIGZvciAtLXRleHRjb252Ly0tZmlsdGVycyIKIG1zZ3N0ciAidXRpbGlzZXIgdW4gY2hlbWluIHNww6ljaWZpcXVlIHBvdXIgLS10ZXh0Y29udi8tLWZpbHRlcnMiCiAKLSM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NDcKKyM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NDgKIG1zZ2lkICJhbGxvdyAtcyBhbmQgLXQgdG8gd29yayB3aXRoIGJyb2tlbi9jb3JydXB0IG9iamVjdHMiCiBtc2dzdHIgImF1dG9yaXNlciAtcyBldCAtdCDDoCB0cmF2YWlsbGVyIHN1ciBkZXMgb2JqZXRzIGNhc3PDqXMvY29ycm9tcHVzIgogCi0jOiBidWlsdGluL2NhdC1maWxlLmM6NjQ4CisjOiBidWlsdGluL2NhdC1maWxlLmM6NjQ5CiBtc2dpZCAiYnVmZmVyIC0tYmF0Y2ggb3V0cHV0IgogbXNnc3RyICJidWZmZXJpc2VyIGxhIHNvcnRpZSBkZSAtLWJhdGNoIgogCi0jOiBidWlsdGluL2NhdC1maWxlLmM6NjUwCisjOiBidWlsdGluL2NhdC1maWxlLmM6NjUxCiBtc2dpZCAic2hvdyBpbmZvIGFuZCBjb250ZW50IG9mIG9iamVjdHMgZmVkIGZyb20gdGhlIHN0YW5kYXJkIGlucHV0IgogbXNnc3RyICIiCiAiYWZmaWNoZXIgbCdpbmZvcm1hdGlvbiBldCBsZSBjb250ZW51IGRlcyBvYmpldHMgcGFzc8OpcyBlbiBlbnRyw6llIHN0YW5kYXJkIgogCi0jOiBidWlsdGluL2NhdC1maWxlLmM6NjU0CisjOiBidWlsdGluL2NhdC1maWxlLmM6NjU1CiBtc2dpZCAic2hvdyBpbmZvIGFib3V0IG9iamVjdHMgZmVkIGZyb20gdGhlIHN0YW5kYXJkIGlucHV0IgogbXNnc3RyICJhZmZpY2hlciBsJ2luZm9ybWF0aW9uIGRlcyBvYmpldHMgcGFzc8OpcyBlbiBlbnRyw6llIHN0YW5kYXJkIgogCi0jOiBidWlsdGluL2NhdC1maWxlLmM6NjU4CisjOiBidWlsdGluL2NhdC1maWxlLmM6NjU5CiBtc2dpZCAiZm9sbG93IGluLXRyZWUgc3ltbGlua3MgKHVzZWQgd2l0aCAtLWJhdGNoIG9yIC0tYmF0Y2gtY2hlY2spIgogbXNnc3RyICIiCiAic3VpdnJlIGxlcyBsaWVucyBzeW1ib2xpcXVlIGludGVybmVzIMOgIGxhIGNvcGllIGRlIHRyYXZhaWwgKHV0aWxpc8OpIGF2ZWMgLS0iCiAiYmF0Y2ggb3UgLS1iYXRjaC1jaGVjaykiCiAKLSM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NjAKKyM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NjEKIG1zZ2lkICJzaG93IGFsbCBvYmplY3RzIHdpdGggLS1iYXRjaCBvciAtLWJhdGNoLWNoZWNrIgogbXNnc3RyICJtb250cmVyIHRvdXMgbGVzIG9iamV0cyBhdmVjIC0tYmF0Y2ggb3UgLS1iYXRjaC1jaGVjayIKIAotIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY2MgorIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY2MwogbXNnaWQgImRvIG5vdCBvcmRlciAtLWJhdGNoLWFsbC1vYmplY3RzIG91dHB1dCIKIG1zZ3N0ciAibmUgcGFzIG9yZG9ubmVyIGxhIHNvcnRpZSBkZSAtLWJhdGNoLWFsbC1vYmplY3RzIgogCkBAIC0xMDI1MSw4ICsxMDI5NCw4IEBACiBtc2dzdHIgIiIKICJ0ZXJtaW5lciBsZXMgZW5yZWdpc3RyZW1lbnRzIGVuIGVudHLDqWUgZXQgZW4gc29ydGllIHBhciB1biBjYXJhY3TDqHJlIE5VTCIKIAotIzogYnVpbHRpbi9jaGVjay1pZ25vcmUuYzoyMSBidWlsdGluL2NoZWNrb3V0LmM6MTQzMyBidWlsdGluL2djLmM6NTM4Ci0jOiBidWlsdGluL3dvcmt0cmVlLmM6NTA3CisjOiBidWlsdGluL2NoZWNrLWlnbm9yZS5jOjIxIGJ1aWx0aW4vY2hlY2tvdXQuYzoxNDMzIGJ1aWx0aW4vZ2MuYzo1MzcKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo1MDYKIG1zZ2lkICJzdXBwcmVzcyBwcm9ncmVzcyByZXBvcnRpbmciCiBtc2dzdHIgInN1cHByaW1lciBsJ8OpdGF0IGQnYXZhbmNlbWVudCIKIApAQCAtMTAzNDYsNyArMTAzODksNyBAQAogIzogYnVpbHRpbi9jaGVja291dC1pbmRleC5jOjE3OCBidWlsdGluL2NvbHVtbi5jOjMxCiAjOiBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6MTM3MyBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6MTM3NgogIzogYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjEzODQgYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjE4NTcKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo2ODAKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo2NzkKIG1zZ2lkICJzdHJpbmciCiBtc2dzdHIgImNoYcOubmUiCiAKQEAgLTEwMzc0LDEwMCArMTA0MTcsMTAwIEBACiBtc2dpZCAiZ2l0IHJlc3RvcmUgWzxvcHRpb25zPl0gWy0tc291cmNlPTxicmFuY2g+XSA8ZmlsZT4uLi4iCiBtc2dzdHIgImdpdCByZXN0b3JlIFs8b3B0aW9ucz5dIFstLXNvdXJjZT08YnJhbmNoZT5dIDxmaWNoaWVyPi4uLiIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjE3MiBidWlsdGluL2NoZWNrb3V0LmM6MjExCisjOiBidWlsdGluL2NoZWNrb3V0LmM6MTczIGJ1aWx0aW4vY2hlY2tvdXQuYzoyMTIKICMsIGMtZm9ybWF0CiBtc2dpZCAicGF0aCAnJXMnIGRvZXMgbm90IGhhdmUgb3VyIHZlcnNpb24iCiBtc2dzdHIgImxlIGNoZW1pbiAnJXMnIG4nYSBwYXMgbm90cmUgdmVyc2lvbiIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjE3NCBidWlsdGluL2NoZWNrb3V0LmM6MjEzCisjOiBidWlsdGluL2NoZWNrb3V0LmM6MTc1IGJ1aWx0aW4vY2hlY2tvdXQuYzoyMTQKICMsIGMtZm9ybWF0CiBtc2dpZCAicGF0aCAnJXMnIGRvZXMgbm90IGhhdmUgdGhlaXIgdmVyc2lvbiIKIG1zZ3N0ciAibGUgY2hlbWluICclcycgbidhIHBhcyBsZXVyIHZlcnNpb24iCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxOTAKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxOTEKICMsIGMtZm9ybWF0CiBtc2dpZCAicGF0aCAnJXMnIGRvZXMgbm90IGhhdmUgYWxsIG5lY2Vzc2FyeSB2ZXJzaW9ucyIKIG1zZ3N0ciAibGUgY2hlbWluICclcycgbidhIGF1Y3VuZSBkZXMgdmVyc2lvbnMgbsOpY2Vzc2FpcmVzIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6MjQwCisjOiBidWlsdGluL2NoZWNrb3V0LmM6MjQxCiAjLCBjLWZvcm1hdAogbXNnaWQgInBhdGggJyVzJyBkb2VzIG5vdCBoYXZlIG5lY2Vzc2FyeSB2ZXJzaW9ucyIKIG1zZ3N0ciAibGUgY2hlbWluICclcycgbidhIHBhcyBsZXMgdmVyc2lvbnMgbsOpY2Vzc2FpcmVzIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6MjU4CisjOiBidWlsdGluL2NoZWNrb3V0LmM6MjU5CiAjLCBjLWZvcm1hdAogbXNnaWQgInBhdGggJyVzJzogY2Fubm90IG1lcmdlIgogbXNnc3RyICJjaGVtaW4gJyVzJyA6IGltcG9zc2libGUgZGUgZnVzaW9ubmVyIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6Mjc0CisjOiBidWlsdGluL2NoZWNrb3V0LmM6Mjc1CiAjLCBjLWZvcm1hdAogbXNnaWQgIlVuYWJsZSB0byBhZGQgbWVyZ2UgcmVzdWx0IGZvciAnJXMnIgogbXNnc3RyICJJbXBvc3NpYmxlIGQnYWpvdXRlciBsZSByw6lzdWx0YXQgZGUgZnVzaW9uIHBvdXIgJyVzJyIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjM3NAorIzogYnVpbHRpbi9jaGVja291dC5jOjM3NQogIywgYy1mb3JtYXQKIG1zZ2lkICJSZWNyZWF0ZWQgJWQgbWVyZ2UgY29uZmxpY3QiCiBtc2dpZF9wbHVyYWwgIlJlY3JlYXRlZCAlZCBtZXJnZSBjb25mbGljdHMiCiBtc2dzdHJbMF0gIiVkIGNvbmZsaXQgZHUgZnVzaW9uIHJlY3LDqcOpIgogbXNnc3RyWzFdICIlZCBjb25mbGl0cyBkdSBmdXNpb24gcmVjcsOpw6lzIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6Mzc5CisjOiBidWlsdGluL2NoZWNrb3V0LmM6MzgwCiAjLCBjLWZvcm1hdAogbXNnaWQgIlVwZGF0ZWQgJWQgcGF0aCBmcm9tICVzIgogbXNnaWRfcGx1cmFsICJVcGRhdGVkICVkIHBhdGhzIGZyb20gJXMiCiBtc2dzdHJbMF0gIiVkIGNoZW1pbiBtaXMgw6Agam91ciBkZXB1aXMgJXMiCiBtc2dzdHJbMV0gIiVkIGNoZW1pbnMgbWlzIMOgIGpvdXIgZGVwdWlzICVzIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6Mzg2CisjOiBidWlsdGluL2NoZWNrb3V0LmM6Mzg3CiAjLCBjLWZvcm1hdAogbXNnaWQgIlVwZGF0ZWQgJWQgcGF0aCBmcm9tIHRoZSBpbmRleCIKIG1zZ2lkX3BsdXJhbCAiVXBkYXRlZCAlZCBwYXRocyBmcm9tIHRoZSBpbmRleCIKIG1zZ3N0clswXSAiJWQgY2hlbWluIG1pcyDDoCBqb3VyIGRlcHVpcyBsJ2luZGV4IgogbXNnc3RyWzFdICIlZCBjaGVtaW5zIG1pcyDDoCBqb3VyIGRlcHVpcyBsJ2luZGV4IgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6NDA5IGJ1aWx0aW4vY2hlY2tvdXQuYzo0MTIgYnVpbHRpbi9jaGVja291dC5jOjQxNQotIzogYnVpbHRpbi9jaGVja291dC5jOjQxOQorIzogYnVpbHRpbi9jaGVja291dC5jOjQxMCBidWlsdGluL2NoZWNrb3V0LmM6NDEzIGJ1aWx0aW4vY2hlY2tvdXQuYzo0MTYKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo0MjAKICMsIGMtZm9ybWF0CiBtc2dpZCAiJyVzJyBjYW5ub3QgYmUgdXNlZCB3aXRoIHVwZGF0aW5nIHBhdGhzIgogbXNnc3RyICInJXMnIG5lIHBldXQgcGFzIMOqdHJlIHV0aWxpc8OpIGF2ZWMgZGVzIG1pc2VzIMOgIGpvdXIgZGUgY2hlbWlucyIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjQyMiBidWlsdGluL2NoZWNrb3V0LmM6NDI1CisjOiBidWlsdGluL2NoZWNrb3V0LmM6NDIzIGJ1aWx0aW4vY2hlY2tvdXQuYzo0MjYKICMsIGMtZm9ybWF0CiBtc2dpZCAiJyVzJyBjYW5ub3QgYmUgdXNlZCB3aXRoICVzIgogbXNnc3RyICInJXMnIG5lIHBldXQgcGFzIMOqdHJlIHV0aWxpc8OpIGF2ZWMgJXMiCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo0MjkKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo0MzAKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ2Fubm90IHVwZGF0ZSBwYXRocyBhbmQgc3dpdGNoIHRvIGJyYW5jaCAnJXMnIGF0IHRoZSBzYW1lIHRpbWUuIgogbXNnc3RyICIiCiAiSW1wb3NzaWJsZSBkZSBtZXR0cmUgw6Agam91ciBsZXMgY2hlbWlucyBldCBiYXNjdWxlciBzdXIgbGEgYnJhbmNoZSAnJXMnIGVuICIKICJtw6ptZSB0ZW1wcy4iCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo0MzMKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo0MzQKICMsIGMtZm9ybWF0CiBtc2dpZCAibmVpdGhlciAnJXMnIG9yICclcycgaXMgc3BlY2lmaWVkIgogbXNnc3RyICJuaSAnJXMnLCBuaSAnJXMnIHNww6ljaWZpw6kiCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo0MzcKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo0MzgKICMsIGMtZm9ybWF0CiBtc2dpZCAiJyVzJyBtdXN0IGJlIHVzZWQgd2hlbiAnJXMnIGlzIG5vdCBzcGVjaWZpZWQiCiBtc2dzdHIgIiclcycgbmUgcGV1dCBwYXMgw6p0cmUgdXRpbGlzw6kgcXVhbmQgJyVzJyBuJ2VzdCBwYXMgc3DDqWNpZmnDqSIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjQ0MiBidWlsdGluL2NoZWNrb3V0LmM6NDQ3CisjOiBidWlsdGluL2NoZWNrb3V0LmM6NDQzIGJ1aWx0aW4vY2hlY2tvdXQuYzo0NDgKICMsIGMtZm9ybWF0CiBtc2dpZCAiJyVzJyBvciAnJXMnIGNhbm5vdCBiZSB1c2VkIHdpdGggJXMiCiBtc2dzdHIgIiclcycgb3UgJyVzJyBuZSBwZXV0IHBhcyDDqnRyZSB1dGlsaXPDqSBhdmVjICVzIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6NTA2IGJ1aWx0aW4vY2hlY2tvdXQuYzo1MTMKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo1MDcgYnVpbHRpbi9jaGVja291dC5jOjUxNAogIywgYy1mb3JtYXQKIG1zZ2lkICJwYXRoICclcycgaXMgdW5tZXJnZWQiCiBtc2dzdHIgImxlIGNoZW1pbiAnJXMnIG4nZXN0IHBhcyBmdXNpb25uw6kiCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo2NzkKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo2ODAKIG1zZ2lkICJ5b3UgbmVlZCB0byByZXNvbHZlIHlvdXIgY3VycmVudCBpbmRleCBmaXJzdCIKIG1zZ3N0ciAidm91cyBkZXZleiBkJ2Fib3JkIHLDqXNvdWRyZSB2b3RyZSBpbmRleCBjb3VyYW50IgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6NzI5CisjOiBidWlsdGluL2NoZWNrb3V0LmM6NzMwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJjYW5ub3QgY29udGludWUgd2l0aCBzdGFnZWQgY2hhbmdlcyBpbiB0aGUgZm9sbG93aW5nIGZpbGVzOlxuIgpAQCAtMTA0NzcsMTIgKzEwNTIwLDYgQEAKICJzdWl2YW50cyA6XG4iCiAiJXMiCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo3MzYKLSMsIGMtZm9ybWF0Ci1tc2dpZCAic3RhZ2VkIGNoYW5nZXMgaW4gdGhlIGZvbGxvd2luZyBmaWxlcyBtYXkgYmUgbG9zdDogJXMiCi1tc2dzdHIgIiIKLSJsZXMgbW9kaWZpY2F0aW9ucyBpbmRleMOpZXMgZGFucyBsZXMgZmljaGllcnMgc3VpdmFudHMgc2VyYWllbnQgcGVyZHVlc8KgOiAlcyIKLQogIzogYnVpbHRpbi9jaGVja291dC5jOjgzMwogIywgYy1mb3JtYXQKIG1zZ2lkICJDYW4gbm90IGRvIHJlZmxvZyBmb3IgJyVzJzogJXNcbiIKQEAgLTEwNDkyLDcgKzEwNTI5LDcgQEAKIG1zZ2lkICJIRUFEIGlzIG5vdyBhdCIKIG1zZ3N0ciAiSEVBRCBlc3QgbWFpbnRlbmFudCBzdXIiCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo4NzkgYnVpbHRpbi9jbG9uZS5jOjcxNAorIzogYnVpbHRpbi9jaGVja291dC5jOjg3OSBidWlsdGluL2Nsb25lLmM6NzEzCiBtc2dpZCAidW5hYmxlIHRvIHVwZGF0ZSBIRUFEIgogbXNnc3RyICJpbXBvc3NpYmxlIGRlIG1ldHRyZSDDoCBqb3VyIEhFQUQiCiAKQEAgLTEwNjA4LDcgKzEwNjQ1LDcgQEAKICInJXMnIHBvdXJyYWl0IMOqdHJlIHVuIGZpY2hpZXIgbG9jYWwgb3UgdW4gYnJhbmNoZSBkZSBzdWl2aS5cbiIKICJWZXVpbGxleiB1dGlsaXNlciAtLSAoZXQgLS1uby1ndWVzcyBlbiBmYWN1bHRhdGlmKSBwb3VyIGxlcyBkaXN0aW5ndWVyIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6MTI0MyBidWlsdGluL3dvcmt0cmVlLmM6MjkxIGJ1aWx0aW4vd29ya3RyZWUuYzo0NTYKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxMjQzIGJ1aWx0aW4vd29ya3RyZWUuYzoyOTAgYnVpbHRpbi93b3JrdHJlZS5jOjQ1NQogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIHJlZmVyZW5jZTogJXMiCiBtc2dzdHIgInLDqWbDqXJlbmNlIGludmFsaWRlIDogJXMiCkBAIC0xMDcxMSw5ICsxMDc0OCw5IEBACiBtc2dpZCAibWlzc2luZyBicmFuY2ggb3IgY29tbWl0IGFyZ3VtZW50IgogbXNnc3RyICJhcmd1bWVudCBkZSBicmFuY2hlIG91IGRlIGNvbW1pdCBtYW5xdWFudCIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjE0MzcgYnVpbHRpbi9jbG9uZS5jOjkxIGJ1aWx0aW4vZmV0Y2guYzoxNTEKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoyODUgYnVpbHRpbi9wdWxsLmM6MTM3IGJ1aWx0aW4vcHVzaC5jOjU3NQotIzogYnVpbHRpbi9zZW5kLXBhY2suYzoxNzQKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNDM3IGJ1aWx0aW4vY2xvbmUuYzo5MCBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjU5CisjOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE4MCBidWlsdGluL2ZldGNoLmM6MTY2IGJ1aWx0aW4vbWVyZ2UuYzoyODUKKyM6IGJ1aWx0aW4vcHVsbC5jOjEzOCBidWlsdGluL3B1c2guYzo1NjIgYnVpbHRpbi9zZW5kLXBhY2suYzoxNzQKIG1zZ2lkICJmb3JjZSBwcm9ncmVzcyByZXBvcnRpbmciCiBtc2dzdHIgImZvcmNlciBsJ2FmZmljaGFnZSBkZSBsJ8OpdGF0IGQnYXZhbmNlbWVudCIKIApAQCAtMTA3MjEsNyArMTA3NTgsNyBAQAogbXNnaWQgInBlcmZvcm0gYSAzLXdheSBtZXJnZSB3aXRoIHRoZSBuZXcgYnJhbmNoIgogbXNnc3RyICJlZmZlY3R1ZXIgdW5lIGZ1c2lvbiDDoCAzIHBvaW50cyBhdmVjIGxhIG5vdXZlbGxlIGJyYW5jaGUiCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNDM5IGJ1aWx0aW4vbG9nLmM6MTYxNyBwYXJzZS1vcHRpb25zLmg6MzE4CisjOiBidWlsdGluL2NoZWNrb3V0LmM6MTQzOSBidWlsdGluL2xvZy5jOjE2MTggcGFyc2Utb3B0aW9ucy5oOjMxOAogbXNnaWQgInN0eWxlIgogbXNnc3RyICJzdHlsZSIKIApAQCAtMTA3MjksNyArMTA3NjYsNyBAQAogbXNnaWQgImNvbmZsaWN0IHN0eWxlIChtZXJnZSBvciBkaWZmMykiCiBtc2dzdHIgInN0eWxlIGRlIGNvbmZsaXQgKG1lcmdlIChmdXNpb24pIG91IGRpZmYzKSIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjE0NTIgYnVpbHRpbi93b3JrdHJlZS5jOjUwNAorIzogYnVpbHRpbi9jaGVja291dC5jOjE0NTIgYnVpbHRpbi93b3JrdHJlZS5jOjUwMwogbXNnaWQgImRldGFjaCBIRUFEIGF0IG5hbWVkIGNvbW1pdCIKIG1zZ3N0ciAiZMOpdGFjaGVyIGxhIEhFQUQgYXUgY29tbWl0IG5vbW3DqSIKIApAQCAtMTA4NDcsOSArMTA4ODQsOSBAQAogImFtYmlndSwgdm91cyBwb3V2ZXogcG9zaXRpb25uZXIgY2hlY2tvdXQuZGVmYXVsdFJlbW90ZT1vcmlnaW4gZGFuc1xuIgogInZvdHJlIGNvbmZpZy4iCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNjkxIGJ1aWx0aW4vY2hlY2tvdXQuYzoxNjkzIGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzMzCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6MTczNSBidWlsdGluL2Nsb25lLmM6MTIxIGJ1aWx0aW4vcmVtb3RlLmM6MTY5Ci0jOiBidWlsdGluL3JlbW90ZS5jOjE3MSBidWlsdGluL3dvcmt0cmVlLmM6NTAwIGJ1aWx0aW4vd29ya3RyZWUuYzo1MDIKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNjkxIGJ1aWx0aW4vY2hlY2tvdXQuYzoxNjkzIGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzQyCisjOiBidWlsdGluL2NoZWNrb3V0LmM6MTc0NCBidWlsdGluL2Nsb25lLmM6MTIwIGJ1aWx0aW4vcmVtb3RlLmM6MTY5CisjOiBidWlsdGluL3JlbW90ZS5jOjE3MSBidWlsdGluL3dvcmt0cmVlLmM6NDk5IGJ1aWx0aW4vd29ya3RyZWUuYzo1MDEKIG1zZ2lkICJicmFuY2giCiBtc2dzdHIgImJyYW5jaGUiCiAKQEAgLTEwODc0LDM5ICsxMDkxMSwzOSBAQAogbXNnaWQgInVzZSBvdmVybGF5IG1vZGUgKGRlZmF1bHQpIgogbXNnc3RyICJ1dGlsaXNlciBsZSBtb2RlIGRlIHN1cGVycG9zaXRpb24gKGTDqWZhdXQpIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6MTczNAorIzogYnVpbHRpbi9jaGVja291dC5jOjE3NDMKIG1zZ2lkICJjcmVhdGUgYW5kIHN3aXRjaCB0byBhIG5ldyBicmFuY2giCiBtc2dzdHIgImNyw6llciBldCBiYXNjdWxlciBzdXIgdW5lIG5vdXZlbGxlIGJyYW5jaGUiCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzM2CisjOiBidWlsdGluL2NoZWNrb3V0LmM6MTc0NQogbXNnaWQgImNyZWF0ZS9yZXNldCBhbmQgc3dpdGNoIHRvIGEgYnJhbmNoIgogbXNnc3RyICJjcsOpZXIvcsOpaW5pdGlhbGlzZXIgZXQgYmFzY3VsZXIgc3VyIHVuZSBicmFuY2hlIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6MTczOAorIzogYnVpbHRpbi9jaGVja291dC5jOjE3NDcKIG1zZ2lkICJzZWNvbmQgZ3Vlc3MgJ2dpdCBzd2l0Y2ggPG5vLXN1Y2gtYnJhbmNoPiciCiBtc2dzdHIgImludGVycHLDqXRlciAnZ2l0IHN3aXRjaCA8YnJhbmNoZS1pbmV4aXN0YW50ZT4nIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6MTc0MAorIzogYnVpbHRpbi9jaGVja291dC5jOjE3NDkKIG1zZ2lkICJ0aHJvdyBhd2F5IGxvY2FsIG1vZGlmaWNhdGlvbnMiCiBtc2dzdHIgImxhaXNzZXIgdG9tYmVyIGxlcyBtb2RpZmljYXRpb25zIGxvY2FsZXMiCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzcyCisjOiBidWlsdGluL2NoZWNrb3V0LmM6MTc4MQogbXNnaWQgIndoaWNoIHRyZWUtaXNoIHRvIGNoZWNrb3V0IGZyb20iCiBtc2dzdHIgImRlIHF1ZWwgPGFyYnJlLWVzcXVlPiBmYWlyZSBsJ2V4dHJhY3Rpb24iCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzc0CisjOiBidWlsdGluL2NoZWNrb3V0LmM6MTc4MwogbXNnaWQgInJlc3RvcmUgdGhlIGluZGV4IgogbXNnc3RyICJyZXN0YXVyZXIgbCdpbmRleCIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjE3NzYKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzg1CiBtc2dpZCAicmVzdG9yZSB0aGUgd29ya2luZyB0cmVlIChkZWZhdWx0KSIKIG1zZ3N0ciAicmVzdGF1cmVyIGwnYXJicmUgZGUgdHJhdmFpbCAocGFyIGTDqWZhdXQpIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6MTc3OAorIzogYnVpbHRpbi9jaGVja291dC5jOjE3ODcKIG1zZ2lkICJpZ25vcmUgdW5tZXJnZWQgZW50cmllcyIKIG1zZ3N0ciAiaWdub3JlciBsZXMgZW50csOpZXMgbm9uLWZ1c2lvbm7DqWVzIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6MTc3OQorIzogYnVpbHRpbi9jaGVja291dC5jOjE3ODgKIG1zZ2lkICJ1c2Ugb3ZlcmxheSBtb2RlIgogbXNnc3RyICJ1dGlsaXNlciBsZSBtb2RlIGRlIHN1cGVycG9zaXRpb24iCiAKQEAgLTEwOTQ2LDcgKzEwOTgzLDcgQEAKIG1zZ2lkICJjb3VsZCBub3QgbHN0YXQgJXNcbiIKIG1zZ3N0ciAibHN0YXQgZGUgJXMgaW1wb3NzaWJsZVxuIgogCi0jOiBidWlsdGluL2NsZWFuLmM6MzAwIGdpdC1hZGQtLWludGVyYWN0aXZlLnBlcmw6NTkzCisjOiBidWlsdGluL2NsZWFuLmM6MzAxIGdpdC1hZGQtLWludGVyYWN0aXZlLnBlcmw6NTkzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJQcm9tcHQgaGVscDpcbiIKQEAgLTEwOTU5LDcgKzEwOTk2LDcgQEAKICJmb28gICAgICAgICAtIHPDqWxlY3Rpb25uZXIgdW4gw6lsw6ltZW50IHBhciB1biBwcsOpZml4ZSB1bmlxdWVcbiIKICIgICAgICAgICAgICAtICh2aWRlKSBuZSByaWVuIHPDqWxlY3Rpb25uZXJcbiIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjMwNCBnaXQtYWRkLS1pbnRlcmFjdGl2ZS5wZXJsOjYwMgorIzogYnVpbHRpbi9jbGVhbi5jOjMwNSBnaXQtYWRkLS1pbnRlcmFjdGl2ZS5wZXJsOjYwMgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiUHJvbXB0IGhlbHA6XG4iCkBAIC0xMDk4MCwzOCArMTEwMTcsMzggQEAKICIqICAgICAgICAgIC0gY2hvaXNpciB0b3VzIGxlcyDDqWzDqW1lbnRzXG4iCiAiICAgICAgICAgICAtICh2aWRlKSB0ZXJtaW5lciBsYSBzw6lsZWN0aW9uXG4iCiAKLSM6IGJ1aWx0aW4vY2xlYW4uYzo1MjAgZ2l0LWFkZC0taW50ZXJhY3RpdmUucGVybDo1NjgKKyM6IGJ1aWx0aW4vY2xlYW4uYzo1MjEgZ2l0LWFkZC0taW50ZXJhY3RpdmUucGVybDo1NjgKICM6IGdpdC1hZGQtLWludGVyYWN0aXZlLnBlcmw6NTczCiAjLCBjLWZvcm1hdCwgcGVybC1mb3JtYXQKIG1zZ2lkICJIdWggKCVzKT9cbiIKIG1zZ3N0ciAiSGVpbiAoJXMpwqA/XG4iCiAKLSM6IGJ1aWx0aW4vY2xlYW4uYzo2NjIKKyM6IGJ1aWx0aW4vY2xlYW4uYzo2NjMKICMsIGMtZm9ybWF0CiBtc2dpZCAiSW5wdXQgaWdub3JlIHBhdHRlcm5zPj4gIgogbXNnc3RyICJFbnRyZXogbGVzIG1vdGlmcyDDoCBpZ25vcmVyPj4gIgogCi0jOiBidWlsdGluL2NsZWFuLmM6Njk5CisjOiBidWlsdGluL2NsZWFuLmM6NzAwCiAjLCBjLWZvcm1hdAogbXNnaWQgIldBUk5JTkc6IENhbm5vdCBmaW5kIGl0ZW1zIG1hdGNoZWQgYnk6ICVzIgogbXNnc3RyICJBVFRFTlRJT04gOiBJbXBvc3NpYmxlIGRlIHRyb3V2ZXIgbGVzIMOpbMOpbWVudHMgY29ycmVzcG9uZGFudCDDoCA6ICVzIgogCi0jOiBidWlsdGluL2NsZWFuLmM6NzIwCisjOiBidWlsdGluL2NsZWFuLmM6NzIxCiBtc2dpZCAiU2VsZWN0IGl0ZW1zIHRvIGRlbGV0ZSIKIG1zZ3N0ciAiU8OpbGVjdGlvbm5lciBsZXMgw6lsw6ltZW50cyDDoCBzdXBwcmltZXIiCiAKICMuIFRSQU5TTEFUT1JTOiBNYWtlIHN1cmUgdG8ga2VlcCBbeS9OXSBhcyBpcwotIzogYnVpbHRpbi9jbGVhbi5jOjc2MQorIzogYnVpbHRpbi9jbGVhbi5jOjc2MgogIywgYy1mb3JtYXQKIG1zZ2lkICJSZW1vdmUgJXMgW3kvTl0/ICIKIG1zZ3N0ciAiU3VwcHJpbWVyICVzIFt5L05dID8gIgogCi0jOiBidWlsdGluL2NsZWFuLmM6Nzg2IGdpdC1hZGQtLWludGVyYWN0aXZlLnBlcmw6MTc2MworIzogYnVpbHRpbi9jbGVhbi5jOjc4NyBnaXQtYWRkLS1pbnRlcmFjdGl2ZS5wZXJsOjE3NjMKICMsIGMtZm9ybWF0CiBtc2dpZCAiQnllLlxuIgogbXNnc3RyICJBdSByZXZvaXIuXG4iCiAKLSM6IGJ1aWx0aW4vY2xlYW4uYzo3OTQKKyM6IGJ1aWx0aW4vY2xlYW4uYzo3OTUKIG1zZ2lkICIiCiAiY2xlYW4gICAgICAgICAgICAgICAtIHN0YXJ0IGNsZWFuaW5nXG4iCiAiZmlsdGVyIGJ5IHBhdHRlcm4gICAtIGV4Y2x1ZGUgaXRlbXMgZnJvbSBkZWxldGlvblxuIgpAQCAtMTEwMjksNjQgKzExMDY2LDY0IEBACiAiaGVscCAgICAgICAgICAgICAgICAtIGNldCDDqWNyYW5cbiIKICI/ICAgICAgICAgICAgICAgICAgIC0gYWlkZSBwb3VyIGxhIHPDqWxlY3Rpb24gZW4gbGlnbmUiCiAKLSM6IGJ1aWx0aW4vY2xlYW4uYzo4MjEgZ2l0LWFkZC0taW50ZXJhY3RpdmUucGVybDoxODQ5CisjOiBidWlsdGluL2NsZWFuLmM6ODIyIGdpdC1hZGQtLWludGVyYWN0aXZlLnBlcmw6MTg0OQogbXNnaWQgIioqKiBDb21tYW5kcyAqKioiCiBtc2dzdHIgIioqKiBDb21tYW5kZXMgKioqIgogCi0jOiBidWlsdGluL2NsZWFuLmM6ODIyIGdpdC1hZGQtLWludGVyYWN0aXZlLnBlcmw6MTg0NgorIzogYnVpbHRpbi9jbGVhbi5jOjgyMyBnaXQtYWRkLS1pbnRlcmFjdGl2ZS5wZXJsOjE4NDYKIG1zZ2lkICJXaGF0IG5vdyIKIG1zZ3N0ciAiRXQgbWFpbnRlbmFudCA/IgogCi0jOiBidWlsdGluL2NsZWFuLmM6ODMwCisjOiBidWlsdGluL2NsZWFuLmM6ODMxCiBtc2dpZCAiV291bGQgcmVtb3ZlIHRoZSBmb2xsb3dpbmcgaXRlbToiCiBtc2dpZF9wbHVyYWwgIldvdWxkIHJlbW92ZSB0aGUgZm9sbG93aW5nIGl0ZW1zOiIKIG1zZ3N0clswXSAiU3VwcHJpbWVyYWl0IGwnw6lsw6ltZW50IHN1aXZhbnQgOiIKIG1zZ3N0clsxXSAiU3VwcHJpbWVyYWl0IGxlcyDDqWzDqW1lbnRzIHN1aXZhbnRzIDoiCiAKLSM6IGJ1aWx0aW4vY2xlYW4uYzo4NDYKKyM6IGJ1aWx0aW4vY2xlYW4uYzo4NDcKIG1zZ2lkICJObyBtb3JlIGZpbGVzIHRvIGNsZWFuLCBleGl0aW5nLiIKIG1zZ3N0ciAiUGx1cyBkZSBmaWNoaWVyIMOgIG5ldHRveWVyLCBzb3J0aWUuIgogCi0jOiBidWlsdGluL2NsZWFuLmM6OTA4CisjOiBidWlsdGluL2NsZWFuLmM6OTA5CiBtc2dpZCAiZG8gbm90IHByaW50IG5hbWVzIG9mIGZpbGVzIHJlbW92ZWQiCiBtc2dzdHIgIm5lIHBhcyBhZmZpY2hlciBsZXMgbm9tcyBkZXMgZmljaGllcnMgc3VwcHJpbcOpcyIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjkxMAorIzogYnVpbHRpbi9jbGVhbi5jOjkxMQogbXNnaWQgImZvcmNlIgogbXNnc3RyICJmb3JjZXIiCiAKLSM6IGJ1aWx0aW4vY2xlYW4uYzo5MTEKKyM6IGJ1aWx0aW4vY2xlYW4uYzo5MTIKIG1zZ2lkICJpbnRlcmFjdGl2ZSBjbGVhbmluZyIKIG1zZ3N0ciAibmV0dG95YWdlIGludGVyYWN0aWYiCiAKLSM6IGJ1aWx0aW4vY2xlYW4uYzo5MTMKKyM6IGJ1aWx0aW4vY2xlYW4uYzo5MTQKIG1zZ2lkICJyZW1vdmUgd2hvbGUgZGlyZWN0b3JpZXMiCiBtc2dzdHIgInN1cHByaW1lciBsZXMgcsOpcGVydG9pcmVzIGVudGllcnMiCiAKLSM6IGJ1aWx0aW4vY2xlYW4uYzo5MTQgYnVpbHRpbi9kZXNjcmliZS5jOjU0NiBidWlsdGluL2Rlc2NyaWJlLmM6NTQ4Ci0jOiBidWlsdGluL2dyZXAuYzo4OTkgYnVpbHRpbi9sb2cuYzoxNzYgYnVpbHRpbi9sb2cuYzoxNzgKLSM6IGJ1aWx0aW4vbHMtZmlsZXMuYzo1NTcgYnVpbHRpbi9uYW1lLXJldi5jOjQxMyBidWlsdGluL25hbWUtcmV2LmM6NDE1CisjOiBidWlsdGluL2NsZWFuLmM6OTE1IGJ1aWx0aW4vZGVzY3JpYmUuYzo1NDggYnVpbHRpbi9kZXNjcmliZS5jOjU1MAorIzogYnVpbHRpbi9ncmVwLmM6OTAxIGJ1aWx0aW4vbG9nLmM6MTc2IGJ1aWx0aW4vbG9nLmM6MTc4CisjOiBidWlsdGluL2xzLWZpbGVzLmM6NTU3IGJ1aWx0aW4vbmFtZS1yZXYuYzo0MTcgYnVpbHRpbi9uYW1lLXJldi5jOjQxOQogIzogYnVpbHRpbi9zaG93LXJlZi5jOjE3OQogbXNnaWQgInBhdHRlcm4iCiBtc2dzdHIgIm1vdGlmIgogCi0jOiBidWlsdGluL2NsZWFuLmM6OTE1CisjOiBidWlsdGluL2NsZWFuLmM6OTE2CiBtc2dpZCAiYWRkIDxwYXR0ZXJuPiB0byBpZ25vcmUgcnVsZXMiCiBtc2dzdHIgImFqb3V0ZXIgPG1vdGlmPiBhdXggcsOoZ2xlcyBpZ25vcmUiCiAKLSM6IGJ1aWx0aW4vY2xlYW4uYzo5MTYKKyM6IGJ1aWx0aW4vY2xlYW4uYzo5MTcKIG1zZ2lkICJyZW1vdmUgaWdub3JlZCBmaWxlcywgdG9vIgogbXNnc3RyICJzdXBwcmltZXIgbGVzIGZpY2hpZXJzIGlnbm9yw6lzLCBhdXNzaSIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjkxOAorIzogYnVpbHRpbi9jbGVhbi5jOjkxOQogbXNnaWQgInJlbW92ZSBvbmx5IGlnbm9yZWQgZmlsZXMiCiBtc2dzdHIgInN1cHByaW1lciBzZXVsZW1lbnQgbGVzIGZpY2hpZXJzIGlnbm9yw6lzIgogCi0jOiBidWlsdGluL2NsZWFuLmM6OTM2CisjOiBidWlsdGluL2NsZWFuLmM6OTM3CiBtc2dpZCAiLXggYW5kIC1YIGNhbm5vdCBiZSB1c2VkIHRvZ2V0aGVyIgogbXNnc3RyICIteCBldCAtWCBuZSBwZXV2ZW50IHBhcyDDqnRyZSB1dGlsaXPDqXMgZW5zZW1ibGUiCiAKLSM6IGJ1aWx0aW4vY2xlYW4uYzo5NDAKKyM6IGJ1aWx0aW4vY2xlYW4uYzo5NDEKIG1zZ2lkICIiCiAiY2xlYW4ucmVxdWlyZUZvcmNlIHNldCB0byB0cnVlIGFuZCBuZWl0aGVyIC1pLCAtbiwgbm9yIC1mIGdpdmVuOyByZWZ1c2luZyB0byAiCiAiY2xlYW4iCkBAIC0xMTA5NCw3ICsxMTEzMSw3IEBACiAiY2xlYW4ucmVxdWlyZUZvcmNlIHBvc2l0aW9ubsOpIMOgIHRydWUgZXQgbmkgLWksIC1uIG91IC1mIGZvdXJuaSA7IHJlZnVzIGRlICIKICJuZXR0b3llciIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjk0MworIzogYnVpbHRpbi9jbGVhbi5jOjk0NAogbXNnaWQgIiIKICJjbGVhbi5yZXF1aXJlRm9yY2UgZGVmYXVsdHMgdG8gdHJ1ZSBhbmQgbmVpdGhlciAtaSwgLW4sIG5vciAtZiBnaXZlbjsgIgogInJlZnVzaW5nIHRvIGNsZWFuIgpAQCAtMTExMDIsMTY0ICsxMTEzOSwxNjQgQEAKICJjbGVhbi5yZXF1aXJlRm9yY2Ugw6AgdHJ1ZSBwYXIgZMOpZmF1dCBldCBuaSAtaSwgLW4gb3UgLWYgZm91cm5pIDsgcmVmdXMgZGUgIgogIm5ldHRveWVyIgogCi0jOiBidWlsdGluL2Nsb25lLmM6NDYKKyM6IGJ1aWx0aW4vY2xvbmUuYzo0NQogbXNnaWQgImdpdCBjbG9uZSBbPG9wdGlvbnM+XSBbLS1dIDxyZXBvPiBbPGRpcj5dIgogbXNnc3RyICJnaXQgY2xvbmUgWzxvcHRpb25zPl0gWy0tXSA8ZMOpcMO0dD4gWzxyw6lwZXJ0b2lyZT5dIgogCi0jOiBidWlsdGluL2Nsb25lLmM6OTMKKyM6IGJ1aWx0aW4vY2xvbmUuYzo5MgogbXNnaWQgImRvbid0IGNyZWF0ZSBhIGNoZWNrb3V0IgogbXNnc3RyICJuZSBwYXMgY3LDqWVyIGQnZXh0cmFjdGlvbiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjk0IGJ1aWx0aW4vY2xvbmUuYzo5NiBidWlsdGluL2luaXQtZGIuYzo0ODkKKyM6IGJ1aWx0aW4vY2xvbmUuYzo5MyBidWlsdGluL2Nsb25lLmM6OTUgYnVpbHRpbi9pbml0LWRiLmM6NDg5CiBtc2dpZCAiY3JlYXRlIGEgYmFyZSByZXBvc2l0b3J5IgogbXNnc3RyICJjcsOpZXIgdW4gZMOpcMO0dCBudSIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjk4CisjOiBidWlsdGluL2Nsb25lLmM6OTcKIG1zZ2lkICJjcmVhdGUgYSBtaXJyb3IgcmVwb3NpdG9yeSAoaW1wbGllcyBiYXJlKSIKIG1zZ3N0ciAiY3LDqWVyIHVuIGTDqXDDtHQgbWlyb2lyIChpbXBsaXF1ZSBkw6lww7R0IG51KSIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEwMAorIzogYnVpbHRpbi9jbG9uZS5jOjk5CiBtc2dpZCAidG8gY2xvbmUgZnJvbSBhIGxvY2FsIHJlcG9zaXRvcnkiCiBtc2dzdHIgInBvdXIgY2xvbmVyIGRlcHVpcyB1biBkw6lww7R0IGxvY2FsIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTAyCisjOiBidWlsdGluL2Nsb25lLmM6MTAxCiBtc2dpZCAiZG9uJ3QgdXNlIGxvY2FsIGhhcmRsaW5rcywgYWx3YXlzIGNvcHkiCiBtc2dzdHIgIm5lIHBhcyB1dGlsaXNlciBkZSBsaWVucyBkdXJzIGxvY2F1eCwgdG91am91cnMgY29waWVyIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTA0CisjOiBidWlsdGluL2Nsb25lLmM6MTAzCiBtc2dpZCAic2V0dXAgYXMgc2hhcmVkIHJlcG9zaXRvcnkiCiBtc2dzdHIgInLDqWdsZXIgY29tbWUgZMOpcMO0dCBwYXJ0YWfDqSIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEwNworIzogYnVpbHRpbi9jbG9uZS5jOjEwNgogbXNnaWQgInBhdGhzcGVjIgogbXNnc3RyICJzcMOpY2lmaWNhdGV1ciBkZSBjaGVtaW4iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMDcKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMDYKIG1zZ2lkICJpbml0aWFsaXplIHN1Ym1vZHVsZXMgaW4gdGhlIGNsb25lIgogbXNnc3RyICJpbml0aWFsaXNlciBsZXMgc291cy1tb2R1bGVzIGRhbnMgbGUgY2xvbmUiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMTAKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMDkKIG1zZ2lkICJudW1iZXIgb2Ygc3VibW9kdWxlcyBjbG9uZWQgaW4gcGFyYWxsZWwiCiBtc2dzdHIgIm5vbWJyZSBkZSBzb3VzLW1vZHVsZXMgY2xvbsOpcyBlbiBwYXJhbGzDqGxlIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTExIGJ1aWx0aW4vaW5pdC1kYi5jOjQ4NgorIzogYnVpbHRpbi9jbG9uZS5jOjExMCBidWlsdGluL2luaXQtZGIuYzo0ODYKIG1zZ2lkICJ0ZW1wbGF0ZS1kaXJlY3RvcnkiCiBtc2dzdHIgInLDqXBlcnRvaXJlLW1vZMOobGUiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMTIgYnVpbHRpbi9pbml0LWRiLmM6NDg3CisjOiBidWlsdGluL2Nsb25lLmM6MTExIGJ1aWx0aW4vaW5pdC1kYi5jOjQ4NwogbXNnaWQgImRpcmVjdG9yeSBmcm9tIHdoaWNoIHRlbXBsYXRlcyB3aWxsIGJlIHVzZWQiCiBtc2dzdHIgInLDqXBlcnRvaXJlIGRlcHVpcyBsZXF1ZWwgbGVzIG1vZMOobGVzIHZvbnQgw6p0cmUgdXRpbGlzw6lzIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTE0IGJ1aWx0aW4vY2xvbmUuYzoxMTYgYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjEzODAKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMTMgYnVpbHRpbi9jbG9uZS5jOjExNSBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6MTM4MAogIzogYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjE4NjAKIG1zZ2lkICJyZWZlcmVuY2UgcmVwb3NpdG9yeSIKIG1zZ3N0ciAiZMOpcMO0dCBkZSByw6lmw6lyZW5jZSIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjExOCBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6MTM4MgorIzogYnVpbHRpbi9jbG9uZS5jOjExNyBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6MTM4MgogIzogYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjE4NjIKIG1zZ2lkICJ1c2UgLS1yZWZlcmVuY2Ugb25seSB3aGlsZSBjbG9uaW5nIgogbXNnc3RyICJ1dGlsaXNlciBzZXVsZW1lbnQgLS1yZWZlcmVuY2UgcG91ciBjbG9uZXIiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMTkgYnVpbHRpbi9jb2x1bW4uYzoyNyBidWlsdGluL21lcmdlLWZpbGUuYzo0NgotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzE0IGJ1aWx0aW4vcmVwYWNrLmM6MzE5CisjOiBidWlsdGluL2Nsb25lLmM6MTE4IGJ1aWx0aW4vY29sdW1uLmM6MjcgYnVpbHRpbi9tZXJnZS1maWxlLmM6NDYKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI5NCBidWlsdGluL3JlcGFjay5jOjMyMAogbXNnaWQgIm5hbWUiCiBtc2dzdHIgIm5vbSIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEyMAorIzogYnVpbHRpbi9jbG9uZS5jOjExOQogbXNnaWQgInVzZSA8bmFtZT4gaW5zdGVhZCBvZiAnb3JpZ2luJyB0byB0cmFjayB1cHN0cmVhbSIKIG1zZ3N0ciAidXRpbGlzZXIgPG5vbT4gYXUgbGlldSBkZSAnb3JpZ2luJyBwb3VyIHN1aXZyZSBsYSBicmFuY2hlIGFtb250IgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTIyCisjOiBidWlsdGluL2Nsb25lLmM6MTIxCiBtc2dpZCAiY2hlY2tvdXQgPGJyYW5jaD4gaW5zdGVhZCBvZiB0aGUgcmVtb3RlJ3MgSEVBRCIKIG1zZ3N0ciAiZXh0cmFpcmUgPGJyYW5jaGU+IGF1IGxpZXUgZGUgbGEgSEVBRCBkdSByw6lwZXJ0b2lyZSBkaXN0YW50IgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTI0CisjOiBidWlsdGluL2Nsb25lLmM6MTIzCiBtc2dpZCAicGF0aCB0byBnaXQtdXBsb2FkLXBhY2sgb24gdGhlIHJlbW90ZSIKIG1zZ3N0ciAiY2hlbWluIHZlcnMgZ2l0LXVwbG9hZC1wYWNrIHN1ciBsZSBzZXJ2ZXVyIGRpc3RhbnQiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMjUgYnVpbHRpbi9mZXRjaC5jOjE1MiBidWlsdGluL2dyZXAuYzo4MzgKLSM6IGJ1aWx0aW4vcHVsbC5jOjIyNgorIzogYnVpbHRpbi9jbG9uZS5jOjEyNCBidWlsdGluL2ZldGNoLmM6MTY3IGJ1aWx0aW4vZ3JlcC5jOjg0MAorIzogYnVpbHRpbi9wdWxsLmM6MjI3CiBtc2dpZCAiZGVwdGgiCiBtc2dzdHIgInByb2ZvbmRldXIiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMjYKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMjUKIG1zZ2lkICJjcmVhdGUgYSBzaGFsbG93IGNsb25lIG9mIHRoYXQgZGVwdGgiCiBtc2dzdHIgImNyw6llciB1biBjbG9uZSBzdXBlcmZpY2llbCBkZSBjZXR0ZSBwcm9mb25kZXVyIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTI3IGJ1aWx0aW4vZmV0Y2guYzoxNTQgYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzAzCisjOiBidWlsdGluL2Nsb25lLmM6MTI2IGJ1aWx0aW4vZmV0Y2guYzoxNjkgYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjgzCiBtc2dpZCAidGltZSIKIG1zZ3N0ciAiaGV1cmUiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMjgKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMjcKIG1zZ2lkICJjcmVhdGUgYSBzaGFsbG93IGNsb25lIHNpbmNlIGEgc3BlY2lmaWMgdGltZSIKIG1zZ3N0ciAiY3LDqWVyIHVuIGNsb25lIHN1cGVyZmljaWVsIGRlcHVpcyB1bmUgZGF0ZSBzcMOpY2lmaXF1ZSIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEyOSBidWlsdGluL2ZldGNoLmM6MTU2IGJ1aWx0aW4vZmV0Y2guYzoxNzkKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTM5NQorIzogYnVpbHRpbi9jbG9uZS5jOjEyOCBidWlsdGluL2ZldGNoLmM6MTcxIGJ1aWx0aW4vZmV0Y2guYzoxOTQKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQxNwogbXNnaWQgInJldmlzaW9uIgogbXNnc3RyICJyw6l2aXNpb24iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMzAgYnVpbHRpbi9mZXRjaC5jOjE1NworIzogYnVpbHRpbi9jbG9uZS5jOjEyOSBidWlsdGluL2ZldGNoLmM6MTcyCiBtc2dpZCAiZGVlcGVuIGhpc3Rvcnkgb2Ygc2hhbGxvdyBjbG9uZSwgZXhjbHVkaW5nIHJldiIKIG1zZ3N0ciAiIgogImFwcHJvZm9uZGlyIGwnaGlzdG9yaXF1ZSBkJ3VuIGNsb25lIHN1cGVyZmljaWVsIGVuIGV4Y2x1YW50IHVuZSByw6l2aXNpb24iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMzIKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMzEKIG1zZ2lkICJjbG9uZSBvbmx5IG9uZSBicmFuY2gsIEhFQUQgb3IgLS1icmFuY2giCiBtc2dzdHIgImNsb25lciBzZXVsZW1lbnQgdW5lIGJyYW5jaGUsIEhFQUQgb3UgLS1icmFuY2giCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMzQKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMzMKIG1zZ2lkICJkb24ndCBjbG9uZSBhbnkgdGFncywgYW5kIG1ha2UgbGF0ZXIgZmV0Y2hlcyBub3QgdG8gZm9sbG93IHRoZW0iCiBtc2dzdHIgIiIKICJuZSBwYXMgY2xvbmVyIGxlcyB0YWdzIGV0IGluZGlxdWVyIGF1eCByw6ljdXDDqXJhdGlvbnMgZnV0dXJlcyBkZSBuZSBwYXMgbGUgIgogImZhaXJlIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTM2CisjOiBidWlsdGluL2Nsb25lLmM6MTM1CiBtc2dpZCAiYW55IGNsb25lZCBzdWJtb2R1bGVzIHdpbGwgYmUgc2hhbGxvdyIKIG1zZ3N0ciAidG91cyBsZXMgc291cy1tb2R1bGVzIGNsb27DqXMgc2Vyb250IHN1cGVyZmljaWVscyIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEzNyBidWlsdGluL2luaXQtZGIuYzo0OTUKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMzYgYnVpbHRpbi9pbml0LWRiLmM6NDk1CiBtc2dpZCAiZ2l0ZGlyIgogbXNnc3RyICJnaXRkaXIiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMzggYnVpbHRpbi9pbml0LWRiLmM6NDk2CisjOiBidWlsdGluL2Nsb25lLmM6MTM3IGJ1aWx0aW4vaW5pdC1kYi5jOjQ5NgogbXNnaWQgInNlcGFyYXRlIGdpdCBkaXIgZnJvbSB3b3JraW5nIHRyZWUiCiBtc2dzdHIgInPDqXBhcmVyIGxlIHLDqXBlcnRvaXJlIGdpdCBkZSBsYSBjb3BpZSBkZSB0cmF2YWlsIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTM5CisjOiBidWlsdGluL2Nsb25lLmM6MTM4CiBtc2dpZCAia2V5PXZhbHVlIgogbXNnc3RyICJjbMOpPXZhbGV1ciIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjE0MAorIzogYnVpbHRpbi9jbG9uZS5jOjEzOQogbXNnaWQgInNldCBjb25maWcgaW5zaWRlIHRoZSBuZXcgcmVwb3NpdG9yeSIKIG1zZ3N0ciAicsOpZ2xlciBsYSBjb25maWd1cmF0aW9uIGRhbnMgbGUgbm91dmVhdSBkw6lww7R0IgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTQyIGJ1aWx0aW4vZmV0Y2guYzoxNzQgYnVpbHRpbi9scy1yZW1vdGUuYzo3NgotIzogYnVpbHRpbi9wdXNoLmM6NTg1IGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTcyCisjOiBidWlsdGluL2Nsb25lLmM6MTQxIGJ1aWx0aW4vZmV0Y2guYzoxODkgYnVpbHRpbi9scy1yZW1vdGUuYzo3NgorIzogYnVpbHRpbi9wdXNoLmM6NTcyIGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTcyCiBtc2dpZCAic2VydmVyLXNwZWNpZmljIgogbXNnc3RyICJzcMOpY2lmaXF1ZSBhdSBzZXJ2ZXVyIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTQyIGJ1aWx0aW4vZmV0Y2guYzoxNzQgYnVpbHRpbi9scy1yZW1vdGUuYzo3NgotIzogYnVpbHRpbi9wdXNoLmM6NTg1IGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTczCisjOiBidWlsdGluL2Nsb25lLmM6MTQxIGJ1aWx0aW4vZmV0Y2guYzoxODkgYnVpbHRpbi9scy1yZW1vdGUuYzo3NgorIzogYnVpbHRpbi9wdXNoLmM6NTcyIGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTczCiBtc2dpZCAib3B0aW9uIHRvIHRyYW5zbWl0IgogbXNnc3RyICJvcHRpb24gw6AgdHJhbnNtZXR0cmUiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxNDMgYnVpbHRpbi9mZXRjaC5jOjE3NSBidWlsdGluL3B1bGwuYzoyMzkKLSM6IGJ1aWx0aW4vcHVzaC5jOjU4NgorIzogYnVpbHRpbi9jbG9uZS5jOjE0MiBidWlsdGluL2ZldGNoLmM6MTkwIGJ1aWx0aW4vcHVsbC5jOjI0MAorIzogYnVpbHRpbi9wdXNoLmM6NTczCiBtc2dpZCAidXNlIElQdjQgYWRkcmVzc2VzIG9ubHkiCiBtc2dzdHIgIm4ndXRpbGlzZXIgcXVlIGRlcyBhZHJlc3NlcyBJUHY0IgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTQ1IGJ1aWx0aW4vZmV0Y2guYzoxNzcgYnVpbHRpbi9wdWxsLmM6MjQyCi0jOiBidWlsdGluL3B1c2guYzo1ODgKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxNDQgYnVpbHRpbi9mZXRjaC5jOjE5MiBidWlsdGluL3B1bGwuYzoyNDMKKyM6IGJ1aWx0aW4vcHVzaC5jOjU3NQogbXNnaWQgInVzZSBJUHY2IGFkZHJlc3NlcyBvbmx5IgogbXNnc3RyICJuJ3V0aWxpc2VyIHF1ZSBkZXMgYWRyZXNzZXMgSVB2NiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjE0OQorIzogYnVpbHRpbi9jbG9uZS5jOjE0OAogbXNnaWQgImFueSBjbG9uZWQgc3VibW9kdWxlcyB3aWxsIHVzZSB0aGVpciByZW1vdGUtdHJhY2tpbmcgYnJhbmNoIgogbXNnc3RyICIiCiAidG91cyBsZXMgc291cy1tb2R1bGVzIGNsb27DqXMgdXRpbGlzZXJvbnQgbGV1ciBicmFuY2hlIGRlIHN1aXZpIMOgIGRpc3RhbmNlIgogCi0jOiBidWlsdGluL2Nsb25lLmM6Mjg1CisjOiBidWlsdGluL2Nsb25lLmM6Mjg0CiBtc2dpZCAiIgogIk5vIGRpcmVjdG9yeSBuYW1lIGNvdWxkIGJlIGd1ZXNzZWQuXG4iCiAiUGxlYXNlIHNwZWNpZnkgYSBkaXJlY3Rvcnkgb24gdGhlIGNvbW1hbmQgbGluZSIKQEAgLTExMjY3LDQ3ICsxMTMwNCw0MiBAQAogIkF1Y3VuIG5vbSBkZSByw6lwZXJ0b2lyZSBuJ2EgcHUgw6p0cmUgZGV2aW7DqVxuIgogIlZldWlsbGV6IHNww6ljaWZpZXIgdW4gcsOpcGVydG9pcmUgZGFucyBsYSBsaWduZSBkZSBjb21tYW5kZSIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjMzOAorIzogYnVpbHRpbi9jbG9uZS5jOjMzNwogIywgYy1mb3JtYXQKIG1zZ2lkICJpbmZvOiBDb3VsZCBub3QgYWRkIGFsdGVybmF0ZSBmb3IgJyVzJzogJXNcbiIKIG1zZ3N0ciAiaW5mb8KgOiBpbXBvc3NpYmxlIGQnYWpvdXRlciB1bmUgYWx0ZXJuYXRpdmUgcG91ciAnJXMnwqA6ICVzXG4iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo0MTEKKyM6IGJ1aWx0aW4vY2xvbmUuYzo0MTAKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgZXhpc3RzIGFuZCBpcyBub3QgYSBkaXJlY3RvcnkiCiBtc2dzdHIgIiVzIGV4aXN0ZSBldCBuJ2VzdCBwYXMgdW4gcsOpcGVydG9pcmUiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo0MjgKKyM6IGJ1aWx0aW4vY2xvbmUuYzo0MjcKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIHN0YXJ0IGl0ZXJhdG9yIG92ZXIgJyVzJyIKIG1zZ3N0ciAiw6ljaGVjIGR1IGTDqW1hcnJhZ2UgdW4gaXTDqXJhdGV1ciBzdXIgJyVzJyIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjQ1MwotIywgYy1mb3JtYXQKLW1zZ2lkICJmYWlsZWQgdG8gdW5saW5rICclcyciCi1tc2dzdHIgIsOpY2hlYyBwb3VyIGTDqWxpZXIgJyVzJyIKLQotIzogYnVpbHRpbi9jbG9uZS5jOjQ1OAorIzogYnVpbHRpbi9jbG9uZS5jOjQ1NwogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gY3JlYXRlIGxpbmsgJyVzJyIKIG1zZ3N0ciAiw6ljaGVjIGRlIGxhIGNyw6lhdGlvbiBkdSBsaWVuICclcyciCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo0NjIKKyM6IGJ1aWx0aW4vY2xvbmUuYzo0NjEKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIGNvcHkgZmlsZSB0byAnJXMnIgogbXNnc3RyICLDqWNoZWMgZGUgbGEgY29waWUgdmVycyAnJXMnIgogCi0jOiBidWlsdGluL2Nsb25lLmM6NDY3CisjOiBidWlsdGluL2Nsb25lLmM6NDY2CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBpdGVyYXRlIG92ZXIgJyVzJyIKIG1zZ3N0ciAiw6ljaGVjIGRlIGwnaXTDqXJhdGlvbiBzdXIgJyVzJyIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjQ5MgorIzogYnVpbHRpbi9jbG9uZS5jOjQ5MQogIywgYy1mb3JtYXQKIG1zZ2lkICJkb25lLlxuIgogbXNnc3RyICJmYWl0LlxuIgogCi0jOiBidWlsdGluL2Nsb25lLmM6NTA2CisjOiBidWlsdGluL2Nsb25lLmM6NTA1CiBtc2dpZCAiIgogIkNsb25lIHN1Y2NlZWRlZCwgYnV0IGNoZWNrb3V0IGZhaWxlZC5cbiIKICJZb3UgY2FuIGluc3BlY3Qgd2hhdCB3YXMgY2hlY2tlZCBvdXQgd2l0aCAnZ2l0IHN0YXR1cydcbiIKQEAgLTExMzE3LDk4ICsxMTM0OSw5OCBAQAogIlZvdXMgcG91dmV6IGluc3BlY3RlciBjZSBxdWkgYSDDqXTDqSBleHRyYWl0IGF2ZWMgJ2dpdCBzdGF0dXMnXG4iCiAiZXQgcsOpZXNzYXllciBhdmVjICdnaXQgcmVzdG9yZSAtLXNvdXJjZT1IRUFEIDovJ1xuIgogCi0jOiBidWlsdGluL2Nsb25lLmM6NTgzCisjOiBidWlsdGluL2Nsb25lLmM6NTgyCiAjLCBjLWZvcm1hdAogbXNnaWQgIkNvdWxkIG5vdCBmaW5kIHJlbW90ZSBicmFuY2ggJXMgdG8gY2xvbmUuIgogbXNnc3RyICJJbXBvc3NpYmxlIGRlIHRyb3V2ZXIgbGEgYnJhbmNoZSBkaXN0YW50ZSAnJXMnIMOgIGNsb25lci4iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo3MDIKKyM6IGJ1aWx0aW4vY2xvbmUuYzo3MDEKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHVwZGF0ZSAlcyIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkZSBtZXR0cmUgw6Agam91ciAlcyIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjc1MgorIzogYnVpbHRpbi9jbG9uZS5jOjc1MQogbXNnaWQgInJlbW90ZSBIRUFEIHJlZmVycyB0byBub25leGlzdGVudCByZWYsIHVuYWJsZSB0byBjaGVja291dC5cbiIKIG1zZ3N0ciAiIgogImxhIEhFQUQgZGlzdGFudGUgcsOpZsOocmUgw6AgdW5lIHLDqWbDqXJlbmNlIG5vbiBleGlzdGFudGUsIGltcG9zc2libGUgZGUgIgogImwnZXh0cmFpcmUuXG4iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo3ODMKKyM6IGJ1aWx0aW4vY2xvbmUuYzo3ODIKIG1zZ2lkICJ1bmFibGUgdG8gY2hlY2tvdXQgd29ya2luZyB0cmVlIgogbXNnc3RyICJpbXBvc3NpYmxlIGQnZXh0cmFpcmUgbGEgY29waWUgZGUgdHJhdmFpbCIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjgzMworIzogYnVpbHRpbi9jbG9uZS5jOjgzMgogbXNnaWQgInVuYWJsZSB0byB3cml0ZSBwYXJhbWV0ZXJzIHRvIGNvbmZpZyBmaWxlIgogbXNnc3RyICJpbXBvc3NpYmxlIGQnw6ljcmlyZSBsZXMgcGFyYW3DqHRyZXMgZGFucyBsZSBmaWNoaWVyIGRlIGNvbmZpZ3VyYXRpb24iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo4OTYKKyM6IGJ1aWx0aW4vY2xvbmUuYzo4OTUKIG1zZ2lkICJjYW5ub3QgcmVwYWNrIHRvIGNsZWFuIHVwIgogbXNnc3RyICJpbXBvc3NpYmxlIGRlIHJlbWJhbGxlciBwb3VyIG5ldHRveWVyIgogCi0jOiBidWlsdGluL2Nsb25lLmM6ODk4CisjOiBidWlsdGluL2Nsb25lLmM6ODk3CiBtc2dpZCAiY2Fubm90IHVubGluayB0ZW1wb3JhcnkgYWx0ZXJuYXRlcyBmaWxlIgogbXNnc3RyICJpbXBvc3NpYmxlIGRlIGTDqWxpZXIgbGUgZmljaGllciB0ZW1wb3JhaXJlIGFsdGVybmF0ZXMiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo5MzggYnVpbHRpbi9yZWNlaXZlLXBhY2suYzoxOTUwCisjOiBidWlsdGluL2Nsb25lLmM6OTM3IGJ1aWx0aW4vcmVjZWl2ZS1wYWNrLmM6MTk0OAogbXNnaWQgIlRvbyBtYW55IGFyZ3VtZW50cy4iCiBtc2dzdHIgIlRyb3AgZCdhcmd1bWVudHMuIgogCi0jOiBidWlsdGluL2Nsb25lLmM6OTQyCisjOiBidWlsdGluL2Nsb25lLmM6OTQxCiBtc2dpZCAiWW91IG11c3Qgc3BlY2lmeSBhIHJlcG9zaXRvcnkgdG8gY2xvbmUuIgogbXNnc3RyICJWb3VzIGRldmV6IHNww6ljaWZpZXIgdW4gZMOpcMO0dCDDoCBjbG9uZXIuIgogCi0jOiBidWlsdGluL2Nsb25lLmM6OTU1CisjOiBidWlsdGluL2Nsb25lLmM6OTU0CiAjLCBjLWZvcm1hdAogbXNnaWQgIi0tYmFyZSBhbmQgLS1vcmlnaW4gJXMgb3B0aW9ucyBhcmUgaW5jb21wYXRpYmxlLiIKIG1zZ3N0ciAibGVzIG9wdGlvbnMgLS1iYXJlIGV0IC0tb3JpZ2luICVzIHNvbnQgaW5jb21wYXRpYmxlcy4iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo5NTgKKyM6IGJ1aWx0aW4vY2xvbmUuYzo5NTcKIG1zZ2lkICItLWJhcmUgYW5kIC0tc2VwYXJhdGUtZ2l0LWRpciBhcmUgaW5jb21wYXRpYmxlLiIKIG1zZ3N0ciAiLS1iYXJlIGV0IC0tc2VwYXJhdGUtZ2l0LWRpciBzb250IGluY29tcGF0aWJsZXMuIgogCi0jOiBidWlsdGluL2Nsb25lLmM6OTcxCisjOiBidWlsdGluL2Nsb25lLmM6OTcwCiAjLCBjLWZvcm1hdAogbXNnaWQgInJlcG9zaXRvcnkgJyVzJyBkb2VzIG5vdCBleGlzdCIKIG1zZ3N0ciAibGUgZMOpcMO0dCAnJXMnIG4nZXhpc3RlIHBhcyIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjk3NyBidWlsdGluL2ZldGNoLmM6MTY2MAorIzogYnVpbHRpbi9jbG9uZS5jOjk3NiBidWlsdGluL2ZldGNoLmM6MTc5MAogIywgYy1mb3JtYXQKIG1zZ2lkICJkZXB0aCAlcyBpcyBub3QgYSBwb3NpdGl2ZSBudW1iZXIiCiBtc2dzdHIgImxhIHByb2ZvbmRldXIgJXMgbidlc3QgcGFzIHVuIGVudGllciBwb3NpdGlmIgogCi0jOiBidWlsdGluL2Nsb25lLmM6OTg3CisjOiBidWlsdGluL2Nsb25lLmM6OTg2CiAjLCBjLWZvcm1hdAogbXNnaWQgImRlc3RpbmF0aW9uIHBhdGggJyVzJyBhbHJlYWR5IGV4aXN0cyBhbmQgaXMgbm90IGFuIGVtcHR5IGRpcmVjdG9yeS4iCiBtc2dzdHIgIiIKICJsZSBjaGVtaW4gZGUgZGVzdGluYXRpb24gJyVzJyBleGlzdGUgZMOpasOgIGV0IG4nZXN0IHBhcyB1biByw6lwZXJ0b2lyZSB2aWRlLiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjk5NworIzogYnVpbHRpbi9jbG9uZS5jOjk5NgogIywgYy1mb3JtYXQKIG1zZ2lkICJ3b3JraW5nIHRyZWUgJyVzJyBhbHJlYWR5IGV4aXN0cy4iCiBtc2dzdHIgImxhIGNvcGllIGRlIHRyYXZhaWwgJyVzJyBleGlzdGUgZMOpasOgLiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEwMTIgYnVpbHRpbi9jbG9uZS5jOjEwMzMgYnVpbHRpbi9kaWZmdG9vbC5jOjI2NAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjMwMyBidWlsdGluL3dvcmt0cmVlLmM6MzM1CisjOiBidWlsdGluL2Nsb25lLmM6MTAxMSBidWlsdGluL2Nsb25lLmM6MTAzMiBidWlsdGluL2RpZmZ0b29sLmM6MjcxCisjOiBidWlsdGluL2xvZy5jOjE3ODUgYnVpbHRpbi93b3JrdHJlZS5jOjMwMiBidWlsdGluL3dvcmt0cmVlLmM6MzM0CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBjcmVhdGUgbGVhZGluZyBkaXJlY3RvcmllcyBvZiAnJXMnIgogbXNnc3RyICJpbXBvc3NpYmxlIGRlIGNyw6llciBsZXMgcsOpcGVydG9pcmVzIGRlIHByZW1pZXIgbml2ZWF1IGRhbnMgJyVzJyIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEwMTcKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMDE2CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBjcmVhdGUgd29yayB0cmVlIGRpciAnJXMnIgogbXNnc3RyICJpbXBvc3NpYmxlIGRlIGNyw6llciBsZSByw6lwZXJ0b2lyZSBkZSBsYSBjb3BpZSBkZSB0cmF2YWlsICclcyciCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMDM3CisjOiBidWlsdGluL2Nsb25lLmM6MTAzNgogIywgYy1mb3JtYXQKIG1zZ2lkICJDbG9uaW5nIGludG8gYmFyZSByZXBvc2l0b3J5ICclcycuLi5cbiIKIG1zZ3N0ciAiQ2xvbmFnZSBkYW5zIGxlIGTDqXDDtHQgbnUgJyVzJ1xuIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTAzOQorIzogYnVpbHRpbi9jbG9uZS5jOjEwMzgKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ2xvbmluZyBpbnRvICclcycuLi5cbiIKIG1zZ3N0ciAiQ2xvbmFnZSBkYW5zICclcycuLi5cbiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEwNjMKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMDYyCiBtc2dpZCAiIgogImNsb25lIC0tcmVjdXJzaXZlIGlzIG5vdCBjb21wYXRpYmxlIHdpdGggYm90aCAtLXJlZmVyZW5jZSBhbmQgLS1yZWZlcmVuY2UtaWYtIgogImFibGUiCkBAIC0xMTQxNiw0MSArMTE0NDgsNDEgQEAKICJjbG9uZSAtLXJlY3Vyc2l2ZSBuJ2VzdCBwYXMgY29tcGF0aWJsZSBhdmVjIMOgIGxhIGZvaXMgLS1yZWZlcmVuY2UgZXQgLS0iCiAicmVmZXJlbmNlLWlmLWFibGUiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMTI0CisjOiBidWlsdGluL2Nsb25lLmM6MTEyMwogbXNnaWQgIi0tZGVwdGggaXMgaWdub3JlZCBpbiBsb2NhbCBjbG9uZXM7IHVzZSBmaWxlOi8vIGluc3RlYWQuIgogbXNnc3RyICIiCiAiLS1kZXB0aCBlc3QgaWdub3LDqSBkYW5zIGxlcyBjbG9uZXMgbG9jYXV4IDogdXRpbGlzZXogcGx1dMO0dCBcImZpbGU6Ly9cIi4iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMTI2CisjOiBidWlsdGluL2Nsb25lLmM6MTEyNQogbXNnaWQgIi0tc2hhbGxvdy1zaW5jZSBpcyBpZ25vcmVkIGluIGxvY2FsIGNsb25lczsgdXNlIGZpbGU6Ly8gaW5zdGVhZC4iCiBtc2dzdHIgIiIKICItLXNoYWxsb3ctc2luY2UgZXN0IGlnbm9yw6kgZGFucyBsZXMgY2xvbmVzIGxvY2F1eCA6IHV0aWxpc2V6IHBsdXTDtHQgXCJmaWxlOi8vIgogIlwiLiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjExMjgKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMTI3CiBtc2dpZCAiLS1zaGFsbG93LWV4Y2x1ZGUgaXMgaWdub3JlZCBpbiBsb2NhbCBjbG9uZXM7IHVzZSBmaWxlOi8vIGluc3RlYWQuIgogbXNnc3RyICIiCiAiLS1zaGFsbG93LWV4Y2x1ZGUgZXN0IGlnbm9yw6kgZGFucyBsZXMgY2xvbmVzIGxvY2F1eCA6IHV0aWxpc2V6IHBsdXTDtHQgIgogIlwiZmlsZTovL1wiLiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjExMzAKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMTI5CiBtc2dpZCAiLS1maWx0ZXIgaXMgaWdub3JlZCBpbiBsb2NhbCBjbG9uZXM7IHVzZSBmaWxlOi8vIGluc3RlYWQuIgogbXNnc3RyICItLWZpbHRlciBlc3QgaWdub3LDqSBkYW5zIGxlcyBjbG9uZXMgbG9jYXV4IDsgdXRpbGlzZXogcGx1dMO0dCBmaWxlOi8vIC4iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMTMzCisjOiBidWlsdGluL2Nsb25lLmM6MTEzMgogbXNnaWQgInNvdXJjZSByZXBvc2l0b3J5IGlzIHNoYWxsb3csIGlnbm9yaW5nIC0tbG9jYWwiCiBtc2dzdHIgImxlIGTDqXDDtHQgc291cmNlIGVzdCBzdXBlcmZpY2llbCwgb3B0aW9uIC0tbG9jYWwgaWdub3LDqWUiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMTM4CisjOiBidWlsdGluL2Nsb25lLmM6MTEzNwogbXNnaWQgIi0tbG9jYWwgaXMgaWdub3JlZCIKIG1zZ3N0ciAiLS1sb2NhbCBlc3QgaWdub3LDqSIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEyMTUgYnVpbHRpbi9jbG9uZS5jOjEyMjMKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMjEyIGJ1aWx0aW4vY2xvbmUuYzoxMjIwCiAjLCBjLWZvcm1hdAogbXNnaWQgIlJlbW90ZSBicmFuY2ggJXMgbm90IGZvdW5kIGluIHVwc3RyZWFtICVzIgogbXNnc3RyICJMYSBicmFuY2hlIGRpc3RhbnRlICVzIG4nYSBwYXMgw6l0w6kgdHJvdXbDqWUgZGFucyBsZSBkw6lww7R0IGFtb250ICVzIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTIyNgorIzogYnVpbHRpbi9jbG9uZS5jOjEyMjMKIG1zZ2lkICJZb3UgYXBwZWFyIHRvIGhhdmUgY2xvbmVkIGFuIGVtcHR5IHJlcG9zaXRvcnkuIgogbXNnc3RyICJWb3VzIHNlbWJsZXogYXZvaXIgY2xvbsOpIHVuIGTDqXDDtHQgdmlkZS4iCiAKQEAgLTExNTI4LDcgKzExNTYwLDcgQEAKIG1zZ3N0ciAiaWQgZCd1biBvYmpldCBjb21taXQgcGFyZW50IgogCiAjOiBidWlsdGluL2NvbW1pdC10cmVlLmM6MTE0IGJ1aWx0aW4vY29tbWl0LmM6MTUwMCBidWlsdGluL21lcmdlLmM6MjcwCi0jOiBidWlsdGluL25vdGVzLmM6NDA5IGJ1aWx0aW4vbm90ZXMuYzo1NzUgYnVpbHRpbi9zdGFzaC5jOjE0NjAKKyM6IGJ1aWx0aW4vbm90ZXMuYzo0MDkgYnVpbHRpbi9ub3Rlcy5jOjU3NSBidWlsdGluL3N0YXNoLmM6MTQ2OQogIzogYnVpbHRpbi90YWcuYzo0MTIKIG1zZ2lkICJtZXNzYWdlIgogbXNnc3RyICJtZXNzYWdlIgpAQCAtMTE1NDIsNyArMTE1NzQsNyBAQAogbXNnc3RyICJsaXJlIGxlIG1lc3NhZ2UgZGUgdmFsaWRhdGlvbiBkZXB1aXMgdW4gZmljaGllciIKIAogIzogYnVpbHRpbi9jb21taXQtdHJlZS5jOjEyMSBidWlsdGluL2NvbW1pdC5jOjE1MTIgYnVpbHRpbi9tZXJnZS5jOjI4NwotIzogYnVpbHRpbi9wdWxsLmM6MTk0IGJ1aWx0aW4vcmV2ZXJ0LmM6MTE4CisjOiBidWlsdGluL3B1bGwuYzoxOTUgYnVpbHRpbi9yZXZlcnQuYzoxMTgKIG1zZ2lkICJHUEcgc2lnbiBjb21taXQiCiBtc2dzdHIgInNpZ25lciBsYSB2YWxpZGF0aW9uIGF2ZWMgR1BHIgogCkBAIC0xMTg3NCw4ICsxMTkwNiw4IEBACiBtc2dpZCAidmVyc2lvbiIKIG1zZ3N0ciAidmVyc2lvbiIKIAotIzogYnVpbHRpbi9jb21taXQuYzoxMzQ3IGJ1aWx0aW4vY29tbWl0LmM6MTUyOSBidWlsdGluL3B1c2guYzo1NjEKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo2NTEKKyM6IGJ1aWx0aW4vY29tbWl0LmM6MTM0NyBidWlsdGluL2NvbW1pdC5jOjE1MjkgYnVpbHRpbi9wdXNoLmM6NTQ4CisjOiBidWlsdGluL3dvcmt0cmVlLmM6NjUwCiBtc2dpZCAibWFjaGluZS1yZWFkYWJsZSBvdXRwdXQiCiBtc2dzdHIgInNvcnRpZSBwb3VyIHRyYWl0ZW1lbnQgYXV0b21hdGlxdWUiCiAKQEAgLTExODg4LDggKzExOTIwLDggQEAKIG1zZ3N0ciAidGVybWluZXIgbGVzIMOpbMOpbWVudHMgcGFyIE5VTCIKIAogIzogYnVpbHRpbi9jb21taXQuYzoxMzU1IGJ1aWx0aW4vY29tbWl0LmM6MTM1OSBidWlsdGluL2NvbW1pdC5jOjE1MzcKLSM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTI1IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTI4Ci0jOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTEzMSBidWlsdGluL3JlYmFzZS5jOjE0NzEgcGFyc2Utb3B0aW9ucy5oOjMzMgorIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNTMgYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNTYKKyM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTU5IGJ1aWx0aW4vcmViYXNlLmM6MTQ5NSBwYXJzZS1vcHRpb25zLmg6MzMyCiBtc2dpZCAibW9kZSIKIG1zZ3N0ciAibW9kZSIKIApAQCAtMTE5MDcsNyArMTE5MzksNyBAQAogImFmZmljaGVyIGxlcyBmaWNoaWVycyBpZ25vcsOpcywgXCJtb2RlXCIgZmFjdWx0YXRpZiA6IHRyYWRpdGlvbmFsICIKICIodHJhZGl0aW9ubmVsKSwgbWF0Y2hpbmcgKGNvcnJlc3BvbmRhbnQpLCBuby4gKETDqWZhdXTCoDogdHJhZGl0aW9uYWwpIgogCi0jOiBidWlsdGluL2NvbW1pdC5jOjEzNjIgcGFyc2Utb3B0aW9ucy5oOjE3OQorIzogYnVpbHRpbi9jb21taXQuYzoxMzYyIHBhcnNlLW9wdGlvbnMuaDoxODgKIG1zZ2lkICJ3aGVuIgogbXNnc3RyICJxdWFuZCIKIApAQCAtMTE5NjIsNyArMTE5OTQsNyBAQAogbXNnaWQgIm92ZXJyaWRlIGF1dGhvciBmb3IgY29tbWl0IgogbXNnc3RyICJyZW1wbGFjZXIgbCdhdXRldXIgcG91ciBsYSB2YWxpZGF0aW9uIgogCi0jOiBidWlsdGluL2NvbW1pdC5jOjE0OTkgYnVpbHRpbi9nYy5jOjUzOQorIzogYnVpbHRpbi9jb21taXQuYzoxNDk5IGJ1aWx0aW4vZ2MuYzo1MzgKIG1zZ2lkICJkYXRlIgogbXNnc3RyICJkYXRlIgogCkBAIC0xMTk5OCw4ICsxMjAzMCw4IEBACiBtc2dzdHIgIiIKICLDoCBwcsOpc2VudCBqZSBzdWlzIGwnYXV0ZXVyIGRlIGxhIHZhbGlkYXRpb24gKHV0aWxpc8OpIGF2ZWMgLUMvLWMvLS1hbWVuZCkiCiAKLSM6IGJ1aWx0aW4vY29tbWl0LmM6MTUwNiBidWlsdGluL2xvZy5jOjE1NjQgYnVpbHRpbi9tZXJnZS5jOjI4OQotIzogYnVpbHRpbi9wdWxsLmM6MTYzIGJ1aWx0aW4vcmV2ZXJ0LmM6MTEwCisjOiBidWlsdGluL2NvbW1pdC5jOjE1MDYgYnVpbHRpbi9sb2cuYzoxNTY1IGJ1aWx0aW4vbWVyZ2UuYzoyODkKKyM6IGJ1aWx0aW4vcHVsbC5jOjE2NCBidWlsdGluL3JldmVydC5jOjExMAogbXNnaWQgImFkZCBTaWduZWQtb2ZmLWJ5OiIKIG1zZ3N0ciAiYWpvdXRlciB1bmUgZW50csOpZSBTaWduZWQtb2ZmLWJ5IDoiCiAKQEAgLTEyMTA2LDY5ICsxMjEzOCw3MiBAQAogbXNnc3RyICJnaXQgY29tbWl0LWdyYXBoIHJlYWQgWy0tb2JqZWN0LWRpciA8b2JqZGlyPl0iCiAKICM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTMgYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxOQotbXNnaWQgImdpdCBjb21taXQtZ3JhcGggdmVyaWZ5IFstLW9iamVjdC1kaXIgPG9iamRpcj5dIFstLXNoYWxsb3ddIgotbXNnc3RyICJnaXQgY29tbWl0LWdyYXBoIHZlcmlmeSBbLS1vYmplY3QtZGlyIDxvYmpkaXI+XSBbLS1zaGFsbG93XSIKK21zZ2lkICIiCisiZ2l0IGNvbW1pdC1ncmFwaCB2ZXJpZnkgWy0tb2JqZWN0LWRpciA8b2JqZGlyPl0gWy0tc2hhbGxvd10gWy0tW25vLV1wcm9ncmVzc10iCittc2dzdHIgIiIKKyJnaXQgY29tbWl0LWdyYXBoIHZlcmlmeSBbLS1vYmplY3QtZGlyIDxvYmpkaXI+XSBbLS1zaGFsbG93XSBbLS1bbm8tXXByb2dyZXNzXSIKIAogIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxNCBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjI5CiBtc2dpZCAiIgogImdpdCBjb21taXQtZ3JhcGggd3JpdGUgWy0tb2JqZWN0LWRpciA8b2JqZGlyPl0gWy0tYXBwZW5kfC0tc3BsaXRdIFstLSIKLSJyZWFjaGFibGV8LS1zdGRpbi1wYWNrc3wtLXN0ZGluLWNvbW1pdHNdIDxzcGxpdCBvcHRpb25zPiIKKyJyZWFjaGFibGV8LS1zdGRpbi1wYWNrc3wtLXN0ZGluLWNvbW1pdHNdIFstLVtuby1dcHJvZ3Jlc3NdIDxzcGxpdCBvcHRpb25zPiIKIG1zZ3N0ciAiIgotImdpdCBjb21taXQtZ3JhcGggd3JpdGUgWy0tb2JqZWN0LWRpciA8b2JqZGlyPl0gWy0tYXBwZW5kfC0tc3BsaXRdIFstLSIKLSJyZWFjaGFibGV8LS1zdGRpbi1wYWNrc3wtLXN0ZGluLWNvbW1pdHNdIDxvcHRpb25zIGRlIGRpdmlzaW9uPiIKKyJnaXQgY29tbWl0LWdyYXBoIHdyaXRlIFstLW9iamVjdC1kaXIgPHLDqXBlcnRvaXJlLWQnb2JqZXQ+XSBbLS1hcHBlbmR8LS0iCisic3BsaXRdIFstLXJlYWNoYWJsZXwtLXN0ZGluLXBhY2tzfC0tc3RkaW4tY29tbWl0c10gWy0tfG5vLV1wcm9ncmVzc10gIgorIjxvcHRpb25zIGRlIGRpdmlzaW9uPiIKIAotIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzo1NCBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjEwMAotIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxNjEgYnVpbHRpbi9jb21taXQtZ3JhcGguYzoyMzcgYnVpbHRpbi9mZXRjaC5jOjE2MwotIzogYnVpbHRpbi9sb2cuYzoxNTg0CisjOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjU1IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTA3CisjOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE3MCBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjI1NCBidWlsdGluL2ZldGNoLmM6MTc4CisjOiBidWlsdGluL2xvZy5jOjE1ODUKIG1zZ2lkICJkaXIiCiBtc2dzdHIgInLDqXBlcnRvaXJlIgogCi0jOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjU1IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTAxCi0jOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE2MiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjIzOAorIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzo1NiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjEwOAorIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxNzEgYnVpbHRpbi9jb21taXQtZ3JhcGguYzoyNTUKIG1zZ2lkICJUaGUgb2JqZWN0IGRpcmVjdG9yeSB0byBzdG9yZSB0aGUgZ3JhcGgiCiBtc2dzdHIgIkxlIHLDqXBlcnRvaXJlIGQnb2JqZXQgb8O5IHN0b2NrZXIgbGUgZ3JhcGhlIgogCi0jOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjU3CisjOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjU4CiBtc2dpZCAiaWYgdGhlIGNvbW1pdC1ncmFwaCBpcyBzcGxpdCwgb25seSB2ZXJpZnkgdGhlIHRpcCBmaWxlIgogbXNnc3RyICIiCiAic2kgbGUgZ3JhcGhlIGRlIGNvbW1pdCBlc3QgZGl2aXPDqSwgdsOpcmlmaWVyIHNldWxlbWVudCBsZSBmaWNoaWVyIHNvbW1ldCIKIAotIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzo3MyBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjExNgorIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzo4MCBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjEyNQogIywgYy1mb3JtYXQKIG1zZ2lkICJDb3VsZCBub3Qgb3BlbiBjb21taXQtZ3JhcGggJyVzJyIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkJ291dnJpciBsZSBncmFwaGUgZGUgY29tbWl0ICclcyciCiAKLSM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTY0CisjOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE3MwogbXNnaWQgInN0YXJ0IHdhbGsgYXQgYWxsIHJlZnMiCiBtc2dzdHIgImNvbW1lbmNlciBsZSBwYXJjb3VycyDDoCB0b3V0ZXMgbGVzIHLDqWZzIgogCi0jOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE2NgorIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxNzUKIG1zZ2lkICJzY2FuIHBhY2staW5kZXhlcyBsaXN0ZWQgYnkgc3RkaW4gZm9yIGNvbW1pdHMiCiBtc2dzdHIgInNjYW5uZXIgbGVzIGluZGV4IGNvbXBhY3TDqXMgbGlzdMOpcyBzdXIgc3RkaW4gw6AgbGEgcmVjaGVyY2hlIGRlIGNvbW1pdHMiCiAKLSM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTY4CisjOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE3NwogbXNnaWQgInN0YXJ0IHdhbGsgYXQgY29tbWl0cyBsaXN0ZWQgYnkgc3RkaW4iCiBtc2dzdHIgImNvbW1lbmNlciBsZSBwYXJjb3VycyBhdXggY29tbWl0cyBsaXN0w6lzIHN1ciBzdGRpbiIKIAotIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxNzAKKyM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTc5CiBtc2dpZCAiaW5jbHVkZSBhbGwgY29tbWl0cyBhbHJlYWR5IGluIHRoZSBjb21taXQtZ3JhcGggZmlsZSIKIG1zZ3N0ciAiIgogImluY2x1cmUgdG91cyBsZXMgY29tbWl0cyBkw6lqw6AgcHLDqXNlbnRzIGRhbnMgbGUgZmljaGllciBkZSBncmFwaGUgZGUgY29tbWl0cyIKIAotIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxNzIKKyM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTgyCiBtc2dpZCAiYWxsb3cgd3JpdGluZyBhbiBpbmNyZW1lbnRhbCBjb21taXQtZ3JhcGggZmlsZSIKIG1zZ3N0ciAicGVybWV0dHJlIGQnw6ljcmlyZSB1biBmaWNoaWVyIGluY3LDqW1lbnRhbCBkZSBncmFwaGUgZGUgY29tbWl0IgogCi0jOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE3NCBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE3OAorIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxODQgYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxODgKIG1zZ2lkICJtYXhpbXVtIG51bWJlciBvZiBjb21taXRzIGluIGEgbm9uLWJhc2Ugc3BsaXQgY29tbWl0LWdyYXBoIgogbXNnc3RyICIiCiAibGUgbm9tYnJlIG1heGltdW0gZGUgY29tbWl0cyBkYW5zIHVuIGdyYXBoZSBkZSBjb21taXQgZGl2aXPDqSBwYXMgZGUgYmFzZSIKIAotIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxNzYKKyM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTg2CiBtc2dpZCAibWF4aW11bSByYXRpbyBiZXR3ZWVuIHR3byBsZXZlbHMgb2YgYSBzcGxpdCBjb21taXQtZ3JhcGgiCiBtc2dzdHIgInJhcHBvcnQgbWF4aW11bSBlbnRyZSBkZXV4IG5pdmVhdXggZCd1biBncmFwaGUgZGUgY29tbWl0IGRpdmlzw6kiCiAKLSM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTkxCisjOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjIwNAogbXNnaWQgInVzZSBhdCBtb3N0IG9uZSBvZiAtLXJlYWNoYWJsZSwgLS1zdGRpbi1jb21taXRzLCBvciAtLXN0ZGluLXBhY2tzIgogbXNnc3RyICJ1dGlsaXNleiB1biBzZXVsIHBhcm1pIC0tcmVhY2hhYmxlLCAtLXN0ZGluLWNvbW1pdHMgb3UgLS1zdGRpbi1wYWNrcyIKIApAQCAtMTI0ODcsNTkgKzEyNTIyLDU5IEBACiBtc2dpZCAicHJpbnQgc2l6ZXMgaW4gaHVtYW4gcmVhZGFibGUgZm9ybWF0IgogbXNnc3RyICJhZmZpY2hlIGxlcyB0YWlsbGVzIGRhbnMgdW4gZm9ybWF0IGh1bWFpbmVtZW50IGxpc2libGUiCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzoyNworIzogYnVpbHRpbi9kZXNjcmliZS5jOjI2CiBtc2dpZCAiZ2l0IGRlc2NyaWJlIFs8b3B0aW9ucz5dIFs8Y29tbWl0LWlzaD4uLi5dIgogbXNnc3RyICJnaXQgZGVzY3JpYmUgWzxvcHRpb25zPl0gPGNvbW1pdCBvdSBhcHBhcmVudMOpPioiCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzoyOAorIzogYnVpbHRpbi9kZXNjcmliZS5jOjI3CiBtc2dpZCAiZ2l0IGRlc2NyaWJlIFs8b3B0aW9ucz5dIC0tZGlydHkiCiBtc2dzdHIgImdpdCBkZXNjcmliZSBbPG9wdGlvbnM+XSAtLWRpcnR5IgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NjMKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo2MgogbXNnaWQgImhlYWQiCiBtc2dzdHIgInTDqnRlIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NjMKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo2MgogbXNnaWQgImxpZ2h0d2VpZ2h0IgogbXNnc3RyICJsw6lnZXIiCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo2MworIzogYnVpbHRpbi9kZXNjcmliZS5jOjYyCiBtc2dpZCAiYW5ub3RhdGVkIgogbXNnc3RyICJhbm5vdMOpIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6MjczCisjOiBidWlsdGluL2Rlc2NyaWJlLmM6Mjc1CiAjLCBjLWZvcm1hdAogbXNnaWQgImFubm90YXRlZCB0YWcgJXMgbm90IGF2YWlsYWJsZSIKIG1zZ3N0ciAibCfDqXRpcXVldHRlIGFubm90w6llICVzIG4nZXN0IHBhcyBkaXNwb25pYmxlIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6Mjc3CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6Mjc5CiAjLCBjLWZvcm1hdAogbXNnaWQgImFubm90YXRlZCB0YWcgJXMgaGFzIG5vIGVtYmVkZGVkIG5hbWUiCiBtc2dzdHIgImwnw6l0aXF1ZXR0ZSBhbm5vdMOpZSAlcyBuJ2EgcGFzIGRlIG5vbSBlbWJhcnF1w6kiCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzoyNzkKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzoyODEKICMsIGMtZm9ybWF0CiBtc2dpZCAidGFnICclcycgaXMgcmVhbGx5ICclcycgaGVyZSIKIG1zZ3N0ciAibCfDqXRpcXVldHRlICclcycgZXN0IGVuIGZhaXQgJyVzJyIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjMyMworIzogYnVpbHRpbi9kZXNjcmliZS5jOjMyNQogIywgYy1mb3JtYXQKIG1zZ2lkICJubyB0YWcgZXhhY3RseSBtYXRjaGVzICclcyciCiBtc2dzdHIgImF1Y3VuZSDDqXRpcXVldHRlIG5lIGNvcnJlc3BvbmQgcGFyZmFpdGVtZW50IMOgICclcyciCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzozMjUKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzozMjcKICMsIGMtZm9ybWF0CiBtc2dpZCAiTm8gZXhhY3QgbWF0Y2ggb24gcmVmcyBvciB0YWdzLCBzZWFyY2hpbmcgdG8gZGVzY3JpYmVcbiIKIG1zZ3N0ciAiIgogIlBhcyBkZSBjb3JyZXNwb25kYW5jZSBleGFjdGUgc3VyIGRlcyByw6lmcyBvdSBkZXMgw6l0aXF1ZXR0ZXMsIHJlY2hlcmNoZSBwYXIgIgogImRlc2NyaWJlXG4iCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzozNzkKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzozODEKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmluaXNoZWQgc2VhcmNoIGF0ICVzXG4iCiBtc2dzdHIgInJlY2hlcmNoZSB0ZXJtaW7DqWUgw6AgJXNcbiIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjQwNQorIzogYnVpbHRpbi9kZXNjcmliZS5jOjQwNwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiTm8gYW5ub3RhdGVkIHRhZ3MgY2FuIGRlc2NyaWJlICclcycuXG4iCkBAIC0xMjU0OCw3ICsxMjU4Myw3IEBACiAiQXVjdW5lIMOpdGlxdWV0dGUgYW5ub3TDqWUgbmUgcGV1dCBkw6ljcmlyZSAnJXMnLlxuIgogIkNlcGVuZGFudCwgaWwgZXhpc3RlIGRlcyDDqXRpcXVldHRlcyBub24tYW5ub3TDqWVzIDogZXNzYXlleiBhdmVjIC0tdGFncy4iCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo0MDkKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo0MTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIk5vIHRhZ3MgY2FuIGRlc2NyaWJlICclcycuXG4iCkBAIC0xMjU1NywxMiArMTI1OTIsMTIgQEAKICJBdWN1bmUgw6l0aXF1ZXR0ZSBuZSBwZXV0IGTDqWNyaXJlICclcycuXG4iCiAiRXNzYXlleiAtLWFsd2F5cywgb3UgY3LDqWV6IGRlcyDDqXRpcXVldHRlcy4iCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo0MzkKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo0NDEKICMsIGMtZm9ybWF0CiBtc2dpZCAidHJhdmVyc2VkICVsdSBjb21taXRzXG4iCiBtc2dzdHIgIiVsdSBjb21taXRzIHBhcmNvdXJ1c1xuIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NDQyCisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NDQ0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJtb3JlIHRoYW4gJWkgdGFncyBmb3VuZDsgbGlzdGVkICVpIG1vc3QgcmVjZW50XG4iCkBAIC0xMjU3Miw5MiArMTI2MDcsOTIgQEAKICJhZmZpY2jDqWVzXG4iCiAiYWJhbmRvbiBkZSBsYSByZWNoZXJjaGUgw6AgJXNcbiIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjUxMAorIzogYnVpbHRpbi9kZXNjcmliZS5jOjUxMgogIywgYy1mb3JtYXQKIG1zZ2lkICJkZXNjcmliZSAlc1xuIgogbXNnc3RyICJkw6ljcmlyZSAlc1xuIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NTEzCisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NTE1CiAjLCBjLWZvcm1hdAogbXNnaWQgIk5vdCBhIHZhbGlkIG9iamVjdCBuYW1lICVzIgogbXNnc3RyICIlcyBuJ2VzdCBwYXMgdW4gbm9tIGQnb2JqZXQgdmFsaWRlIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NTIxCisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NTIzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIGlzIG5laXRoZXIgYSBjb21taXQgbm9yIGJsb2IiCiBtc2dzdHIgIiVzIG4nZXN0IG5pIHVuIGNvbW1pdCBuaSB1biBibG9iIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NTM1CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NTM3CiBtc2dpZCAiZmluZCB0aGUgdGFnIHRoYXQgY29tZXMgYWZ0ZXIgdGhlIGNvbW1pdCIKIG1zZ3N0ciAicmVjaGVyY2hlciBsJ8OpdGlxdWV0dGUgcXVpIHN1aXQgbGUgY29tbWl0IgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NTM2CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NTM4CiBtc2dpZCAiZGVidWcgc2VhcmNoIHN0cmF0ZWd5IG9uIHN0ZGVyciIKIG1zZ3N0ciAiZMOpYm9ndWVyIGxhIHN0cmF0w6lnaWUgZGUgcmVjaGVyY2hlIHN1ciBzdGRlcnIiCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1MzcKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1MzkKIG1zZ2lkICJ1c2UgYW55IHJlZiIKIG1zZ3N0ciAidXRpbGlzZXIgbidpbXBvcnRlIHF1ZWxsZSByw6lmw6lyZW5jZSIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjUzOAorIzogYnVpbHRpbi9kZXNjcmliZS5jOjU0MAogbXNnaWQgInVzZSBhbnkgdGFnLCBldmVuIHVuYW5ub3RhdGVkIgogbXNnc3RyICJ1dGlsaXNlciBuJ2ltcG9ydGUgcXVlbGxlIMOpdGlxdWV0dGUsIG3Dqm1lIG5vbi1hbm5vdMOpZSIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjUzOQorIzogYnVpbHRpbi9kZXNjcmliZS5jOjU0MQogbXNnaWQgImFsd2F5cyB1c2UgbG9uZyBmb3JtYXQiCiBtc2dzdHIgInRvdWpvdXJzIHV0aWxpc2VyIGxlIGZvcm1hdCBsb25nIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NTQwCisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NTQyCiBtc2dpZCAib25seSBmb2xsb3cgZmlyc3QgcGFyZW50IgogbXNnc3RyICJuZSBzdWl2cmUgcXVlIGxlIHByZW1pZXIgcGFyZW50IgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NTQzCisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NTQ1CiBtc2dpZCAib25seSBvdXRwdXQgZXhhY3QgbWF0Y2hlcyIKIG1zZ3N0ciAibidhZmZpY2hlciBxdWUgbGVzIGNvcnJlc3BvbmRhbmNlcyBleGFjdGVzIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NTQ1CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NTQ3CiBtc2dpZCAiY29uc2lkZXIgPG4+IG1vc3QgcmVjZW50IHRhZ3MgKGRlZmF1bHQ6IDEwKSIKIG1zZ3N0ciAiIgogImNvbnNpZMOpcmVyIHVuaXF1ZW1lbnQgbGVzIDxuPiDDqXRpcXVldHRlcyBsZSBwbHVzIHLDqWNlbnRlcyAoZMOpZmF1dCA6IDEwKSIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjU0NworIzogYnVpbHRpbi9kZXNjcmliZS5jOjU0OQogbXNnaWQgIm9ubHkgY29uc2lkZXIgdGFncyBtYXRjaGluZyA8cGF0dGVybj4iCiBtc2dzdHIgIm5lIGNvbnNpZMOpcmVyIHF1ZSBsZXMgw6l0aXF1ZXR0ZXMgY29ycmVzcG9uZGFudCDDoCA8bW90aWY+IgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NTQ5CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NTUxCiBtc2dpZCAiZG8gbm90IGNvbnNpZGVyIHRhZ3MgbWF0Y2hpbmcgPHBhdHRlcm4+IgogbXNnc3RyICJuZSBwYXMgY29uc2lkw6lyZXIgbGVzIMOpdGlxdWV0dGVzIGNvcnJlc3BvbmRhbnQgw6AgPG1vdGlmPiIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjU1MSBidWlsdGluL25hbWUtcmV2LmM6NDIyCisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NTUzIGJ1aWx0aW4vbmFtZS1yZXYuYzo0MjYKIG1zZ2lkICJzaG93IGFiYnJldmlhdGVkIGNvbW1pdCBvYmplY3QgYXMgZmFsbGJhY2siCiBtc2dzdHIgImFmZmljaGVyIGxlcyBvYmpldHMgY29tbWl0cyBhYnLDqWfDqXMgZW4gZGVybmllciByZWNvdXJzIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NTUyIGJ1aWx0aW4vZGVzY3JpYmUuYzo1NTUKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1NTQgYnVpbHRpbi9kZXNjcmliZS5jOjU1NwogbXNnaWQgIm1hcmsiCiBtc2dzdHIgIm1hcnF1ZSIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjU1MworIzogYnVpbHRpbi9kZXNjcmliZS5jOjU1NQogbXNnaWQgImFwcGVuZCA8bWFyaz4gb24gZGlydHkgd29ya2luZyB0cmVlIChkZWZhdWx0OiBcIi1kaXJ0eVwiKSIKIG1zZ3N0ciAiYWpvdXRlciA8bWFycXVlPiBzaSBsYSBjb3BpZSBkZSB0cmF2YWlsIGVzdCBzYWxlIChkw6lmYXV0IDogXCItZGlydHlcIikiCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1NTYKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1NTgKIG1zZ2lkICJhcHBlbmQgPG1hcms+IG9uIGJyb2tlbiB3b3JraW5nIHRyZWUgKGRlZmF1bHQ6IFwiLWJyb2tlblwiKSIKIG1zZ3N0ciAiIgogImFqb3V0ZXIgPG1hcnF1ZT4gc2kgbGEgY29waWUgZGUgdHJhdmFpbCBlc3QgY2Fzc8OpZSAoZMOpZmF1dCA6IFwiLWJyb2tlblwiKSIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjU3NAorIzogYnVpbHRpbi9kZXNjcmliZS5jOjU3NgogbXNnaWQgIi0tbG9uZyBpcyBpbmNvbXBhdGlibGUgd2l0aCAtLWFiYnJldj0wIgogbXNnc3RyICItLWxvbmcgZXQgLS1hYmJyZXY9MCBzb250IGluY29tcGF0aWJsZXMiCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo2MDMKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo2MDUKIG1zZ2lkICJObyBuYW1lcyBmb3VuZCwgY2Fubm90IGRlc2NyaWJlIGFueXRoaW5nLiIKIG1zZ3N0ciAiYXVjdW4gbm9tIHRyb3V2w6ksIGltcG9zc2libGUgZGUgZMOpY3JpcmUgcXVvaSBxdWUgY2Ugc29pdC4iCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo2NTQKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo2NTYKIG1zZ2lkICItLWRpcnR5IGlzIGluY29tcGF0aWJsZSB3aXRoIGNvbW1pdC1pc2hlcyIKIG1zZ3N0ciAiLS1kaXJ0eSBlc3QgaW5jb21wYXRpYmxlIGF2ZWMgbGEgc3DDqWNpZmljYXRpb24gZGUgY29tbWl0cyBvdSBhc3NpbWlsw6lzIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NjU2CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NjU4CiBtc2dpZCAiLS1icm9rZW4gaXMgaW5jb21wYXRpYmxlIHdpdGggY29tbWl0LWlzaGVzIgogbXNnc3RyICItLWJyb2tlbiBlc3QgaW5jb21wYXRpYmxlIGF2ZWMgbGVzIGNvbW1pdHMgb3UgYXNzaW1pbMOpcyIKIApAQCAtMTI2OTQsMjcgKzEyNzI5LDI3IEBACiBtc2dpZCAiZ2l0IGRpZmZ0b29sIFs8b3B0aW9ucz5dIFs8Y29tbWl0PiBbPGNvbW1pdD5dXSBbLS1dIFs8cGF0aD4uLi5dIgogbXNnc3RyICJnaXQgZGlmZnRvb2wgWzxvcHRpb25zPl0gWzxjb21taXQ+IFs8Y29tbWl0Pl1dIFstLV0gWzxjaGVtaW4+Li4uXSIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjI1MworIzogYnVpbHRpbi9kaWZmdG9vbC5jOjI2MAogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQ6ICVkIgogbXNnc3RyICLDqWNoZWMgOiAlZCIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjI5NQorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjMwMgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcmVhZCBzeW1saW5rICVzIgogbXNnc3RyICJsZWN0dXJlIGR1IGxpZW4gc3ltYm9saXF1ZSAlcyBpbXBvc3NpYmxlIgogCi0jOiBidWlsdGluL2RpZmZ0b29sLmM6Mjk3CisjOiBidWlsdGluL2RpZmZ0b29sLmM6MzA0CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCByZWFkIHN5bWxpbmsgZmlsZSAlcyIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkZSBsaXJlIGxlIGZpY2hpZXIgc3ltbGluayAlcyIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjMwNQorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjMxMgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcmVhZCBvYmplY3QgJXMgZm9yIHN5bWxpbmsgJXMiCiBtc2dzdHIgIkltcG9zc2libGUgZGUgbGlyZSBsJ29iamV0ICVzIHBvdXIgbGUgc3ltbGluayAlcyIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjQwNgorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjQxMwogbXNnaWQgIiIKICJjb21iaW5lZCBkaWZmIGZvcm1hdHMoJy1jJyBhbmQgJy0tY2MnKSBhcmUgbm90IHN1cHBvcnRlZCBpblxuIgogImRpcmVjdG9yeSBkaWZmIG1vZGUoJy1kJyBhbmQgJy0tZGlyLWRpZmYnKS4iCkBAIC0xMjcyMiw1MyArMTI3NTcsNTMgQEAKICJsZXMgZm9ybWF0cyBkZSBkaWZmIGNvbWJpbsOpcyAoJy1jJyBldCAnLS1jYycpIG5lIHNvbnQgcGFzIHN1cHBvcnTDqXNcbiIKICJkYW5zIGxlIG1vZGUgZGUgZGlmZiBkZSByw6lwZXJ0b2lyZSAoJy1kJyBldCAnLS1kaXItZGlmZicpLiIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjYyNgorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjYzNAogIywgYy1mb3JtYXQKIG1zZ2lkICJib3RoIGZpbGVzIG1vZGlmaWVkOiAnJXMnIGFuZCAnJXMnLiIKIG1zZ3N0ciAibGVzIGRldXggZmljaGllcnMgc29udCBtb2RpZmnDqXPCoDogJyVzJyBldCAnJXMnLiIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjYyOAorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjYzNgogbXNnaWQgIndvcmtpbmcgdHJlZSBmaWxlIGhhcyBiZWVuIGxlZnQuIgogbXNnc3RyICJsZSBmaWNoaWVyIGRhbnMgbCdhcmJyZSBkZSB0cmF2YWlsIGEgw6l0w6kgbGFpc3PDqS4iCiAKLSM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo2MzkKKyM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo2NDcKICMsIGMtZm9ybWF0CiBtc2dpZCAidGVtcG9yYXJ5IGZpbGVzIGV4aXN0IGluICclcycuIgogbXNnc3RyICJkZXMgZmljaGllcnMgdGVtcG9yYWlyZXMgZXhpc3RlbnQgZGFucyAnJXMnLiIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjY0MAorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjY0OAogbXNnaWQgInlvdSBtYXkgd2FudCB0byBjbGVhbnVwIG9yIHJlY292ZXIgdGhlc2UuIgogbXNnc3RyICJ2b3VzIHBvdXJyaWV6IHNvdWhhaXRlciBsZXMgbmV0dG95ZXIgb3UgbGVzIHLDqWN1cMOpcmVyLiIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjY4OQorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjY5NwogbXNnaWQgInVzZSBgZGlmZi5ndWl0b29sYCBpbnN0ZWFkIG9mIGBkaWZmLnRvb2xgIgogbXNnc3RyICJ1dGlsaXNlciBgZGlmZi5ndWl0b29sYCBhdSBsaWV1IGRlIGBkaWZmLnRvb2xgIgogCi0jOiBidWlsdGluL2RpZmZ0b29sLmM6NjkxCisjOiBidWlsdGluL2RpZmZ0b29sLmM6Njk5CiBtc2dpZCAicGVyZm9ybSBhIGZ1bGwtZGlyZWN0b3J5IGRpZmYiCiBtc2dzdHIgInLDqWFsaXNlIHVuIGRpZmYgZGUgcsOpcGVydG9pcmUgY29tcGxldCIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjY5MworIzogYnVpbHRpbi9kaWZmdG9vbC5jOjcwMQogbXNnaWQgImRvIG5vdCBwcm9tcHQgYmVmb3JlIGxhdW5jaGluZyBhIGRpZmYgdG9vbCIKIG1zZ3N0ciAibmUgcGFzIGNvbmZpcm1lciBhdmFudCBkZSBsYW5jZXIgbCdvdXRpbCBkZSBkaWZmIgogCi0jOiBidWlsdGluL2RpZmZ0b29sLmM6Njk4CisjOiBidWlsdGluL2RpZmZ0b29sLmM6NzA2CiBtc2dpZCAidXNlIHN5bWxpbmtzIGluIGRpci1kaWZmIG1vZGUiCiBtc2dzdHIgInV0aWxpc2VyIGxlcyBsaWVucyBzeW1ib2xpcXVlcyBlbiBtb2RlIGRlIGRpZmYgZGUgcsOpcGVydG9pcmUiCiAKLSM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo2OTkKKyM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo3MDcKIG1zZ2lkICJ0b29sIgogbXNnc3RyICJvdXRpbCIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjcwMAorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjcwOAogbXNnaWQgInVzZSB0aGUgc3BlY2lmaWVkIGRpZmYgdG9vbCIKIG1zZ3N0ciAidXRpbGlzZXIgbCdvdXRpbCBkZSBkaWZmIHNww6ljaWZpw6kiCiAKLSM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo3MDIKKyM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo3MTAKIG1zZ2lkICJwcmludCBhIGxpc3Qgb2YgZGlmZiB0b29scyB0aGF0IG1heSBiZSB1c2VkIHdpdGggYC0tdG9vbGAiCiBtc2dzdHIgImFmZmljaGVyIHVuZSBsaXN0ZSBkZXMgb3V0aWxzIGRlIGRpZmYgdXRpbGlzYWJsZXMgYXZlYyBgLS10b29sYCIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjcwNQorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjcxMwogbXNnaWQgIiIKICJtYWtlICdnaXQtZGlmZnRvb2wnIGV4aXQgd2hlbiBhbiBpbnZva2VkIGRpZmYgdG9vbCByZXR1cm5zIGEgbm9uIC0gemVybyBleGl0ICIKICJjb2RlIgpAQCAtMTI3NzYsMzEgKzEyODExLDMxIEBACiAicHJvdm9xdWUgbGEgZmluIGRlICdnaXQtZGlmZnRvb2wnIHNpIGwnb3V0aWwgZGUgZGlmZiBpbnZvcXXDqSByZW52b2llIHVuIGNvZGUgIgogIm5vbi1udWwiCiAKLSM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo3MDgKKyM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo3MTYKIG1zZ2lkICJzcGVjaWZ5IGEgY3VzdG9tIGNvbW1hbmQgZm9yIHZpZXdpbmcgZGlmZnMiCiBtc2dzdHIgInNww6ljaWZpZXIgdW5lIGNvbW1hbmRlIHBlcnNvbm5hbGlzw6llIHBvdXIgdmlzdWFsaXNlciBsZXMgZGlmZsOpcmVuY2VzIgogCi0jOiBidWlsdGluL2RpZmZ0b29sLmM6NzA5CisjOiBidWlsdGluL2RpZmZ0b29sLmM6NzE3CiBtc2dpZCAicGFzc2VkIHRvIGBkaWZmYCIKIG1zZ3N0ciAicGFzc8OpIMOgIGBkaWZmYCIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjcyNAorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjczMgogbXNnaWQgImRpZmZ0b29sIHJlcXVpcmVzIHdvcmt0cmVlIG9yIC0tbm8taW5kZXgiCiBtc2dzdHIgImRpZmZ0b29sIGV4aWdlIHVuIGFyYnJlIGRlIHRyYXZhaWwgb3UgLS1uby1pbmRleCIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjczMQorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjczOQogbXNnaWQgIi0tZGlyLWRpZmYgaXMgaW5jb21wYXRpYmxlIHdpdGggLS1uby1pbmRleCIKIG1zZ3N0ciAiLS1kaXItZGlmZiBlc3QgaW5jb21wYXRpYmxlIGF2ZWMgLS1uby1pbmRleCIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjczNAorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjc0MgogbXNnaWQgIi0tZ3VpLCAtLXRvb2wgYW5kIC0tZXh0Y21kIGFyZSBtdXR1YWxseSBleGNsdXNpdmUiCiBtc2dzdHIgIi0tZ3VpLCAtLXRvb2wgZXQgLS1leHRjbWQgc29udCBtdXR1ZWxsZW1lbnQgZXhjbHVzaWZzIgogCi0jOiBidWlsdGluL2RpZmZ0b29sLmM6NzQyCisjOiBidWlsdGluL2RpZmZ0b29sLmM6NzUwCiBtc2dpZCAibm8gPHRvb2w+IGdpdmVuIGZvciAtLXRvb2w9PHRvb2w+IgogbXNnc3RyICJwYXMgZCc8b3V0aWw+IHNww6ljaWZpw6kgcG91ciAtLXRvb2w9PG91dGlsPiIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjc0OQorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjc1NwogbXNnaWQgIm5vIDxjbWQ+IGdpdmVuIGZvciAtLWV4dGNtZD08Y21kPiIKIG1zZ3N0ciAicGFzIGRlIDxjb21tYW5kZT4gc3DDqWNpZmnDqSBwb3VyIC0tZXh0Y21kPTxjb21tYW5kZT4iCiAKQEAgLTEyODQxLDE2NCArMTI4NzYsMTkxIEBACiBtc2dpZCAiZ2l0IGZhc3QtZXhwb3J0IFtyZXYtbGlzdC1vcHRzXSIKIG1zZ3N0ciAiZ2l0IGZhc3QtZXhwb3J0IFtvcHRpb25zLWRlLWxpc3RlLWRlLXLDqXZpc2lvbnNdIgogCi0jOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTEyNAorIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjg1MgorbXNnaWQgIkVycm9yOiBDYW5ub3QgZXhwb3J0IG5lc3RlZCB0YWdzIHVubGVzcyAtLW1hcmstdGFncyBpcyBzcGVjaWZpZWQuIgorbXNnc3RyICIiCisiRXJyZXVywqA6IGltcG9zc2libGUgZCdleHBvcnRlciBkZXMgw6l0aXF1ZXR0ZXMgaW1icmlxdcOpZXMgw6AgbW9pbnMgcXVlIC0tbWFyay0iCisidGFncyBuZSBzb2l0IHNww6ljaWZpw6kuIgorCisjOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE1MgogbXNnaWQgInNob3cgcHJvZ3Jlc3MgYWZ0ZXIgPG4+IG9iamVjdHMiCiBtc2dzdHIgImFmZmljaGVyIGxhIHByb2dyZXNzaW9uIGFwcsOocyA8bj4gb2JqZXRzIgogCi0jOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTEyNgorIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNTQKIG1zZ2lkICJzZWxlY3QgaGFuZGxpbmcgb2Ygc2lnbmVkIHRhZ3MiCiBtc2dzdHIgInPDqWxlY3Rpb25uZXIgbGEgZ2VzdGlvbiBkZXMgw6l0aXF1ZXR0ZXMgc2lnbsOpZXMiCiAKLSM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTI5CisjOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE1NwogbXNnaWQgInNlbGVjdCBoYW5kbGluZyBvZiB0YWdzIHRoYXQgdGFnIGZpbHRlcmVkIG9iamVjdHMiCiBtc2dzdHIgIiIKICJzw6lsZWN0aW9ubmVyIGxhIGdlc3Rpb24gZGVzIMOpdGlxdWV0dGVzIHF1aSBwb2ludGVudCBzdXIgZGVzIG9iamV0cyBmaWx0csOpcyIKIAotIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExMzIKKyM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTYwCiBtc2dpZCAic2VsZWN0IGhhbmRsaW5nIG9mIGNvbW1pdCBtZXNzYWdlcyBpbiBhbiBhbHRlcm5hdGUgZW5jb2RpbmciCiBtc2dzdHIgIiIKICJzw6lsZWN0aW9ubmVyIGxhIGdlc3Rpb24gZGVzIG1lc3NhZ2VzIGRlIHZhbGlkYXRpb24gZGFucyB1biBlbmNvZGFnZSAiCiAiYWx0ZXJuYXRpZiIKIAotIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExMzUKKyM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTYzCiBtc2dpZCAiRHVtcCBtYXJrcyB0byB0aGlzIGZpbGUiCiBtc2dzdHIgIkVucmVnaXN0cmVyIGxlcyBtYXJxdWVzIGRhbnMgY2UgZmljaGllciIKIAotIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExMzcKKyM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTY1CiBtc2dpZCAiSW1wb3J0IG1hcmtzIGZyb20gdGhpcyBmaWxlIgogbXNnc3RyICJpbXBvcnRlciBsZXMgbWFycXVlcyBkZXB1aXMgY2UgZmljaGllciIKIAotIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExMzkKKyM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTY5Cittc2dpZCAiSW1wb3J0IG1hcmtzIGZyb20gdGhpcyBmaWxlIGlmIGl0IGV4aXN0cyIKK21zZ3N0ciAiaW1wb3J0ZXIgbGVzIG1hcnF1ZXMgZGVwdWlzIGNlIGZpY2hpZXIgcydpbCBleGlzdGUiCisKKyM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTcxCiBtc2dpZCAiRmFrZSBhIHRhZ2dlciB3aGVuIHRhZ3MgbGFjayBvbmUiCiBtc2dzdHIgImZhbHNpZmllciB1biBhdXRldXIgZCfDqXRpcXVldHRlIHNpIGwnw6l0aXF1ZXR0ZSBuJ2VuIHByw6lzZW50ZSBwYXMiCiAKLSM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTQxCisjOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE3MwogbXNnaWQgIk91dHB1dCBmdWxsIHRyZWUgZm9yIGVhY2ggY29tbWl0IgogbXNnc3RyICJBZmZpY2hlciBsJ2FyYnJlIGNvbXBsZXQgcG91ciBjaGFxdWUgY29tbWl0IgogCi0jOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE0MworIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNzUKIG1zZ2lkICJVc2UgdGhlIGRvbmUgZmVhdHVyZSB0byB0ZXJtaW5hdGUgdGhlIHN0cmVhbSIKIG1zZ3N0ciAiVXRpbGlzZXIgbGEgZm9uY3Rpb24gXCJkb25lXCIgcG91ciB0ZXJtaW5lciBsZSBmbHV4IgogCi0jOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE0NAorIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNzYKIG1zZ2lkICJTa2lwIG91dHB1dCBvZiBibG9iIGRhdGEiCiBtc2dzdHIgIlNhdXRlciBsJ2FmZmljaGFnZSBkZSBkb25uw6llcyBkZSBibG9iIgogCi0jOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE0NSBidWlsdGluL2xvZy5jOjE2MzIKKyM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTc3IGJ1aWx0aW4vbG9nLmM6MTYzMwogbXNnaWQgInJlZnNwZWMiCiBtc2dzdHIgInNww6ljaWZpY2F0ZXVyIGRlIHLDqWbDqXJlbmNlIgogCi0jOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE0NgorIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNzgKIG1zZ2lkICJBcHBseSByZWZzcGVjIHRvIGV4cG9ydGVkIHJlZnMiCiBtc2dzdHIgIkFwcGxpcXVlciBsZSBzcMOpY2lmaWNhdGV1ciBkZSByw6lmw6lyZW5jZSBhdXggcsOpZsOpcmVuY2VzIGV4cG9ydMOpZXMiCiAKLSM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTQ3CisjOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE3OQogbXNnaWQgImFub255bWl6ZSBvdXRwdXQiCiBtc2dzdHIgImFub255bWlzZSBsYSBzb3J0aWUiCiAKLSM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTQ5CisjOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE4MQogbXNnaWQgIlJlZmVyZW5jZSBwYXJlbnRzIHdoaWNoIGFyZSBub3QgaW4gZmFzdC1leHBvcnQgc3RyZWFtIGJ5IG9iamVjdCBpZCIKIG1zZ3N0ciAiIgogImxlcyBwYXJlbnRzIHLDqWbDqXJlbmNlcyBxdWkgbmUgc29udCBwYXMgZGFucyBsZSBmbHV4IGQnZXhwb3J0IHJhcGlkZSBwYXIgaWQgIgogImQnb2JqZXQiCiAKLSM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTUxCisjOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE4MwogbXNnaWQgIlNob3cgb3JpZ2luYWwgb2JqZWN0IGlkcyBvZiBibG9icy9jb21taXRzIgogbXNnc3RyICJBZmZpY2hlciBsZXMgaWRzIGQnb2JqZXQgb3JpZ2luYXV4IGRlcyBibG9icy9jb21taXRzIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MzAKKyM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTg1Cittc2dpZCAiTGFiZWwgdGFncyB3aXRoIG1hcmsgaWRzIgorbXNnc3RyICJNYXJxdWVyIGxlcyDDqXRpcXVldHRlcyBhdmVjIGRlcyBpZHMgZGUgbWFycXVlIgorCisjOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTIyMAorbXNnaWQgIkNhbm5vdCBwYXNzIGJvdGggLS1pbXBvcnQtbWFya3MgYW5kIC0taW1wb3J0LW1hcmtzLWlmLWV4aXN0cyIKK21zZ3N0ciAiIgorIkltcG9zc2libGUgZCd1dGlsaXNlciDDoCBsYSBmb2lzIC0taW1wb3J0LW1hcmtzIGV0IC0taW1wb3J0LW1hcmtzLWlmLWV4aXN0cyIKKworIzogYnVpbHRpbi9mZXRjaC5jOjM0CiBtc2dpZCAiZ2l0IGZldGNoIFs8b3B0aW9ucz5dIFs8cmVwb3NpdG9yeT4gWzxyZWZzcGVjPi4uLl1dIgogbXNnc3RyICJnaXQgZmV0Y2ggWzxvcHRpb25zPl0gWzxkw6lww7R0PiBbPHNww6ljaWZpY2F0aW9uLWRlLXLDqWbDqXJlbmNlPi4uLl1dIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MzEKKyM6IGJ1aWx0aW4vZmV0Y2guYzozNQogbXNnaWQgImdpdCBmZXRjaCBbPG9wdGlvbnM+XSA8Z3JvdXA+IgogbXNnc3RyICJnaXQgZmV0Y2ggWzxvcHRpb25zPl0gPGdyb3VwZT4iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzozMgorIzogYnVpbHRpbi9mZXRjaC5jOjM2CiBtc2dpZCAiZ2l0IGZldGNoIC0tbXVsdGlwbGUgWzxvcHRpb25zPl0gWyg8cmVwb3NpdG9yeT4gfCA8Z3JvdXA+KS4uLl0iCiBtc2dzdHIgImdpdCBmZXRjaCAtLW11bHRpcGxlIFs8b3B0aW9ucz5dIFsoPGTDqXDDtHQ+IHwgPGdyb3VwZT4pLi4uXSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjMzCisjOiBidWlsdGluL2ZldGNoLmM6MzcKIG1zZ2lkICJnaXQgZmV0Y2ggLS1hbGwgWzxvcHRpb25zPl0iCiBtc2dzdHIgImdpdCBmZXRjaCAtLWFsbCBbPG9wdGlvbnM+XSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjEyNSBidWlsdGluL3B1bGwuYzoyMDMKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxMTUKK21zZ2lkICJmZXRjaC5wYXJhbGxlbCBjYW5ub3QgYmUgbmVnYXRpdmUiCittc2dzdHIgImZldGNoLnBhcmFsbGVsIG5lIHBldXQgcGFzIMOqdHJlIG7DqWdhdGlmIgorCisjOiBidWlsdGluL2ZldGNoLmM6MTM4IGJ1aWx0aW4vcHVsbC5jOjIwNAogbXNnaWQgImZldGNoIGZyb20gYWxsIHJlbW90ZXMiCiBtc2dzdHIgInLDqWN1cMOpcmVyIGRlcHVpcyB0b3VzIGxlcyBkw6lww7R0cyBkaXN0YW50cyIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjEyNyBidWlsdGluL3B1bGwuYzoyMDYKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNDAgYnVpbHRpbi9wdWxsLmM6MjQ4Cittc2dpZCAic2V0IHVwc3RyZWFtIGZvciBnaXQgcHVsbC9mZXRjaCIKK21zZ3N0ciAiZMOpZmluaXIgbGEgYnJhbmNoZSBhbW9udCBwb3VyIGdpdCBwdWxsL2ZldGNoIgorCisjOiBidWlsdGluL2ZldGNoLmM6MTQyIGJ1aWx0aW4vcHVsbC5jOjIwNwogbXNnaWQgImFwcGVuZCB0byAuZ2l0L0ZFVENIX0hFQUQgaW5zdGVhZCBvZiBvdmVyd3JpdGluZyIKIG1zZ3N0ciAiYWpvdXRlciDDoCAuZ2l0L0ZFVENIX0hFQUQgYXUgbGlldSBkZSBsJ8OpY3Jhc2VyIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTI5IGJ1aWx0aW4vcHVsbC5jOjIwOQorIzogYnVpbHRpbi9mZXRjaC5jOjE0NCBidWlsdGluL3B1bGwuYzoyMTAKIG1zZ2lkICJwYXRoIHRvIHVwbG9hZCBwYWNrIG9uIHJlbW90ZSBlbmQiCiBtc2dzdHIgImNoZW1pbiB2ZXJzIGxlcXVlbCB0w6lsw6ljaGFyZ2VyIGxlIHBhcXVldCBzdXIgbGUgcG9zdGUgZGlzdGFudCIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjEzMAorIzogYnVpbHRpbi9mZXRjaC5jOjE0NQogbXNnaWQgImZvcmNlIG92ZXJ3cml0ZSBvZiBsb2NhbCByZWZlcmVuY2UiCiBtc2dzdHIgImZvcmNlciBsJ8OpY3Jhc2VtZW50IGRlIGxhIGJyYW5jaGUgbG9jYWxlIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTMyCisjOiBidWlsdGluL2ZldGNoLmM6MTQ3CiBtc2dpZCAiZmV0Y2ggZnJvbSBtdWx0aXBsZSByZW1vdGVzIgogbXNnc3RyICJyw6ljdXDDqXJlciBkZXB1aXMgcGx1c2lldXJzIGTDqXDDtHRzIGRpc3RhbnRzIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTM0IGJ1aWx0aW4vcHVsbC5jOjIxMworIzogYnVpbHRpbi9mZXRjaC5jOjE0OSBidWlsdGluL3B1bGwuYzoyMTQKIG1zZ2lkICJmZXRjaCBhbGwgdGFncyBhbmQgYXNzb2NpYXRlZCBvYmplY3RzIgogbXNnc3RyICJyw6ljdXDDqXJlciB0b3V0ZXMgbGVzIMOpdGlxdWV0dGVzIGV0IGxldXJzIG9iamV0cyBhc3NvY2nDqXMiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxMzYKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNTEKIG1zZ2lkICJkbyBub3QgZmV0Y2ggYWxsIHRhZ3MgKC0tbm8tdGFncykiCiBtc2dzdHIgIm5lIHBhcyByw6ljdXDDqXJlciB0b3V0ZXMgbGVzIMOpdGlxdWV0dGVzICgtLW5vLXRhZ3MpIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTM4CisjOiBidWlsdGluL2ZldGNoLmM6MTUzCiBtc2dpZCAibnVtYmVyIG9mIHN1Ym1vZHVsZXMgZmV0Y2hlZCBpbiBwYXJhbGxlbCIKIG1zZ3N0ciAibm9tYnJlIGRlIHNvdXMtbW9kdWxlcyByw6ljdXDDqXLDqXMgZW4gcGFyYWxsw6hsZSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE0MCBidWlsdGluL3B1bGwuYzoyMTYKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNTUgYnVpbHRpbi9wdWxsLmM6MjE3CiBtc2dpZCAicHJ1bmUgcmVtb3RlLXRyYWNraW5nIGJyYW5jaGVzIG5vIGxvbmdlciBvbiByZW1vdGUiCiBtc2dzdHIgIiIKICLDqWxpbWluZXIgbGVzIGJyYW5jaGVzIGRlIHN1aXZpIGRpc3RhbnQgc2kgbGEgYnJhbmNoZSBuJ2V4aXN0ZSBwbHVzIGRhbnMgbGUgIgogImTDqXDDtHQgZGlzdGFudCIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE0MgorIzogYnVpbHRpbi9mZXRjaC5jOjE1NwogbXNnaWQgInBydW5lIGxvY2FsIHRhZ3Mgbm8gbG9uZ2VyIG9uIHJlbW90ZSBhbmQgY2xvYmJlciBjaGFuZ2VkIHRhZ3MiCiBtc2dzdHIgIiIKICLDqWxpbWluZXIgbGVzIMOpdGlxdWV0dGVzIGxvY2FsZXMgcXVpIG9udCBkaXNwYXJ1IGR1IGTDqXDDtHQgZGlzdGFudCBldCBxdWkgIgogImVuY29tYnJlbnQgbGVzIMOpdGlxdWV0dGVzIG1vZGlmacOpZXMiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNDMgYnVpbHRpbi9mZXRjaC5jOjE2NiBidWlsdGluL3B1bGwuYzoxNDAKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNTggYnVpbHRpbi9mZXRjaC5jOjE4MSBidWlsdGluL3B1bGwuYzoxNDEKIG1zZ2lkICJvbi1kZW1hbmQiCiBtc2dzdHIgIsOgIGxhIGRlbWFuZGUiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNDQKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNTkKIG1zZ2lkICJjb250cm9sIHJlY3Vyc2l2ZSBmZXRjaGluZyBvZiBzdWJtb2R1bGVzIgogbXNnc3RyICJjb250csO0bGVyIGxhIHLDqWN1cMOpcmF0aW9uIHLDqWN1cnNpdmUgZGFucyBsZXMgc291cy1tb2R1bGVzIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTQ4IGJ1aWx0aW4vcHVsbC5jOjIyNAorIzogYnVpbHRpbi9mZXRjaC5jOjE2MyBidWlsdGluL3B1bGwuYzoyMjUKIG1zZ2lkICJrZWVwIGRvd25sb2FkZWQgcGFjayIKIG1zZ3N0ciAiY29uc2VydmVyIGxlIHBhcXVldCB0w6lsw6ljaGFyZ8OpIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTUwCisjOiBidWlsdGluL2ZldGNoLmM6MTY1CiBtc2dpZCAiYWxsb3cgdXBkYXRpbmcgb2YgSEVBRCByZWYiCiBtc2dzdHIgInBlcm1ldHRyZSBsYSBtaXNlIMOgIGpvdXIgZGUgbGEgcsOpZsOpcmVuY2UgSEVBRCIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE1MyBidWlsdGluL2ZldGNoLmM6MTU5IGJ1aWx0aW4vcHVsbC5jOjIyNworIzogYnVpbHRpbi9mZXRjaC5jOjE2OCBidWlsdGluL2ZldGNoLmM6MTc0IGJ1aWx0aW4vcHVsbC5jOjIyOAogbXNnaWQgImRlZXBlbiBoaXN0b3J5IG9mIHNoYWxsb3cgY2xvbmUiCiBtc2dzdHIgImFwcHJvZm9uZGlyIGwnaGlzdG9yaXF1ZSBkJ3VuIGNsb25lIHN1cGVyZmljaWVsIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTU1CisjOiBidWlsdGluL2ZldGNoLmM6MTcwCiBtc2dpZCAiZGVlcGVuIGhpc3Rvcnkgb2Ygc2hhbGxvdyByZXBvc2l0b3J5IGJhc2VkIG9uIHRpbWUiCiBtc2dzdHIgImFwcHJvZm9uZGlyIGwnaGlzdG9yaXF1ZSBkJ3VuIGNsb25lIHN1cGVyZmljaWVsIGVuIGZvbmN0aW9uIGQndW5lIGRhdGUiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNjEgYnVpbHRpbi9wdWxsLmM6MjMwCisjOiBidWlsdGluL2ZldGNoLmM6MTc2IGJ1aWx0aW4vcHVsbC5jOjIzMQogbXNnaWQgImNvbnZlcnQgdG8gYSBjb21wbGV0ZSByZXBvc2l0b3J5IgogbXNnc3RyICJjb252ZXJ0aXIgZW4gdW4gZMOpcMO0dCBjb21wbGV0IgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTY0CisjOiBidWlsdGluL2ZldGNoLmM6MTc5CiBtc2dpZCAicHJlcGVuZCB0aGlzIHRvIHN1Ym1vZHVsZSBwYXRoIG91dHB1dCIKIG1zZ3N0ciAicHLDqWZpeGVyIGNlY2kgw6AgbGEgc29ydGllIGR1IGNoZW1pbiBkdSBzb3VzLW1vZHVsZSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE2NworIzogYnVpbHRpbi9mZXRjaC5jOjE4MgogbXNnaWQgIiIKICJkZWZhdWx0IGZvciByZWN1cnNpdmUgZmV0Y2hpbmcgb2Ygc3VibW9kdWxlcyAobG93ZXIgcHJpb3JpdHkgdGhhbiBjb25maWcgIgogImZpbGVzKSIKQEAgLTEzMDA2LDkxICsxMzA2OCw5MSBAQAogInBhciBkw6lmYXV0IHBvdXIgbGEgcsOpY3Vww6lyYXRpb24gcsOpY3Vyc2l2ZSBkZSBzb3VzLW1vZHVsZXMgKHByaW9yaXTDqSBwbHVzICIKICJiYXNzZSBxdWUgbGVzIGZpY2hpZXJzIGRlIGNvbmZpZykiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNzEgYnVpbHRpbi9wdWxsLmM6MjMzCisjOiBidWlsdGluL2ZldGNoLmM6MTg2IGJ1aWx0aW4vcHVsbC5jOjIzNAogbXNnaWQgImFjY2VwdCByZWZzIHRoYXQgdXBkYXRlIC5naXQvc2hhbGxvdyIKIG1zZ3N0ciAiYWNjZXB0ZXIgbGVzIHLDqWbDqXJlbmNlcyBxdWkgbWV0dGVudCDDoCBqb3VyIC5naXQvc2hhbGxvdyIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE3MiBidWlsdGluL3B1bGwuYzoyMzUKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxODcgYnVpbHRpbi9wdWxsLmM6MjM2CiBtc2dpZCAicmVmbWFwIgogbXNnc3RyICJjb3JyZXNwb25kYW5jZSBkZSByw6lmw6lyZW5jZSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE3MyBidWlsdGluL3B1bGwuYzoyMzYKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxODggYnVpbHRpbi9wdWxsLmM6MjM3CiBtc2dpZCAic3BlY2lmeSBmZXRjaCByZWZtYXAiCiBtc2dzdHIgInNww6ljaWZpZXIgdW5lIGNvcnJlc3BvbmRhbmNlIGRlIHLDqWbDqXJlbmNlIHBvdXIgbGEgcsOpY3Vww6lyYXRpb24iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxODAKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxOTUKIG1zZ2lkICJyZXBvcnQgdGhhdCB3ZSBoYXZlIG9ubHkgb2JqZWN0cyByZWFjaGFibGUgZnJvbSB0aGlzIG9iamVjdCIKIG1zZ3N0ciAicmFwcG9ydGUgcXVlIG5vdXMgbidhdm9ucyBxdWUgZGVzIG9iamV0cyBqb2lnbmFibGVzIGRlcHVpcyBjZXQgb2JqZXQiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxODMKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxOTgKIG1zZ2lkICJydW4gJ2djIC0tYXV0bycgYWZ0ZXIgZmV0Y2hpbmciCiBtc2dzdHIgImxhbmNlciAnZ2MgLS1hdXRvJyBhcHLDqHMgbGEgcsOpY3Vww6lyYXRpb24iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxODUgYnVpbHRpbi9wdWxsLmM6MjQ1CisjOiBidWlsdGluL2ZldGNoLmM6MjAwIGJ1aWx0aW4vcHVsbC5jOjI0NgogbXNnaWQgImNoZWNrIGZvciBmb3JjZWQtdXBkYXRlcyBvbiBhbGwgdXBkYXRlZCBicmFuY2hlcyIKIG1zZ3N0ciAidsOpcmlmaWVyIGxlcyBtaXNlcyDDoCBqb3VyIGZvcmPDqWVzIHN1ciB0b3V0ZXMgbGVzIGJyYW5jaGVzIG1pc2VzIMOgIGpvdXIiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzo0OTEKKyM6IGJ1aWx0aW4vZmV0Y2guYzo1MTAKIG1zZ2lkICJDb3VsZG4ndCBmaW5kIHJlbW90ZSByZWYgSEVBRCIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkZSB0cm91dmVyIGxhIHLDqWbDqXJlbmNlIEhFQUQgZGlzdGFudGUiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzo2MzAKKyM6IGJ1aWx0aW4vZmV0Y2guYzo2NTAKICMsIGMtZm9ybWF0CiBtc2dpZCAiY29uZmlndXJhdGlvbiBmZXRjaC5vdXRwdXQgY29udGFpbnMgaW52YWxpZCB2YWx1ZSAlcyIKIG1zZ3N0ciAiIgogImxlIHBhcmFtw6h0cmUgZGUgY29uZmlndXJhdGlvbiBmZXRjaC5vdXRwdXQgY29udGllbnQgdW5lIHZhbGV1ciBpbnZhbGlkZSAlcyIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjcyOAorIzogYnVpbHRpbi9mZXRjaC5jOjc0OAogIywgYy1mb3JtYXQKIG1zZ2lkICJvYmplY3QgJXMgbm90IGZvdW5kIgogbXNnc3RyICJvYmpldCAlcyBub24gdHJvdXbDqSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjczMgorIzogYnVpbHRpbi9mZXRjaC5jOjc1MgogbXNnaWQgIlt1cCB0byBkYXRlXSIKIG1zZ3N0ciAiW8OgIGpvdXJdIgogCi0jOiBidWlsdGluL2ZldGNoLmM6NzQ1IGJ1aWx0aW4vZmV0Y2guYzo3NjEgYnVpbHRpbi9mZXRjaC5jOjgzMworIzogYnVpbHRpbi9mZXRjaC5jOjc2NSBidWlsdGluL2ZldGNoLmM6NzgxIGJ1aWx0aW4vZmV0Y2guYzo4NTMKIG1zZ2lkICJbcmVqZWN0ZWRdIgogbXNnc3RyICJbcmVqZXTDqV0iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzo3NDYKKyM6IGJ1aWx0aW4vZmV0Y2guYzo3NjYKIG1zZ2lkICJjYW4ndCBmZXRjaCBpbiBjdXJyZW50IGJyYW5jaCIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkZSByw6ljdXDDqXJlciBkYW5zIGxhIGJyYW5jaGUgYWN0dWVsbGUiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzo3NTYKKyM6IGJ1aWx0aW4vZmV0Y2guYzo3NzYKIG1zZ2lkICJbdGFnIHVwZGF0ZV0iCiBtc2dzdHIgIlttaXNlIMOgIGpvdXIgZGUgbCfDqXRpcXVldHRlXSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjc1NyBidWlsdGluL2ZldGNoLmM6Nzk0IGJ1aWx0aW4vZmV0Y2guYzo4MTYKLSM6IGJ1aWx0aW4vZmV0Y2guYzo4MjgKKyM6IGJ1aWx0aW4vZmV0Y2guYzo3NzcgYnVpbHRpbi9mZXRjaC5jOjgxNCBidWlsdGluL2ZldGNoLmM6ODM2CisjOiBidWlsdGluL2ZldGNoLmM6ODQ4CiBtc2dpZCAidW5hYmxlIHRvIHVwZGF0ZSBsb2NhbCByZWYiCiBtc2dzdHIgImltcG9zc2libGUgZGUgbWV0dHJlIMOgIGpvdXIgbGEgcsOpZsOpcmVuY2UgbG9jYWxlIgogCi0jOiBidWlsdGluL2ZldGNoLmM6NzYxCisjOiBidWlsdGluL2ZldGNoLmM6NzgxCiBtc2dpZCAid291bGQgY2xvYmJlciBleGlzdGluZyB0YWciCiBtc2dzdHIgIsOpY3Jhc2VyYWl0IGwnw6l0aXF1ZXR0ZSBleGlzdGFudGUiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzo3ODMKKyM6IGJ1aWx0aW4vZmV0Y2guYzo4MDMKIG1zZ2lkICJbbmV3IHRhZ10iCiBtc2dzdHIgIltub3V2ZWxsZSDDqXRpcXVldHRlXSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjc4NgorIzogYnVpbHRpbi9mZXRjaC5jOjgwNgogbXNnaWQgIltuZXcgYnJhbmNoXSIKIG1zZ3N0ciAiW25vdXZlbGxlIGJyYW5jaGVdIgogCi0jOiBidWlsdGluL2ZldGNoLmM6Nzg5CisjOiBidWlsdGluL2ZldGNoLmM6ODA5CiBtc2dpZCAiW25ldyByZWZdIgogbXNnc3RyICJbbm91dmVsbGUgcsOpZsOpcmVuY2VdIgogCi0jOiBidWlsdGluL2ZldGNoLmM6ODI4CisjOiBidWlsdGluL2ZldGNoLmM6ODQ4CiBtc2dpZCAiZm9yY2VkIHVwZGF0ZSIKIG1zZ3N0ciAibWlzZSDDoCBqb3VyIGZvcmPDqWUiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzo4MzMKKyM6IGJ1aWx0aW4vZmV0Y2guYzo4NTMKIG1zZ2lkICJub24tZmFzdC1mb3J3YXJkIgogbXNnc3RyICJwYXMgZW4gYXZhbmNlIHJhcGlkZSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjg1NAorIzogYnVpbHRpbi9mZXRjaC5jOjg3NAogbXNnaWQgIiIKICJGZXRjaCBub3JtYWxseSBpbmRpY2F0ZXMgd2hpY2ggYnJhbmNoZXMgaGFkIGEgZm9yY2VkIHVwZGF0ZSxcbiIKICJidXQgdGhhdCBjaGVjayBoYXMgYmVlbiBkaXNhYmxlZC4gVG8gcmUtZW5hYmxlLCB1c2UgJy0tc2hvdy1mb3JjZWQtdXBkYXRlcydcbiIKQEAgLTEzMTAwLDcgKzEzMTYyLDcgQEAKICJtYWlzIGNlY2kgYSDDqXTDqSBkw6lzYWN0aXbDqS4gUG91ciByw6ktYWN0aXZlciwgdXRpbGlzZXogbGUgZHJhcGVhdVxuIgogIictLXNob3ctZm9yY2VkLXVwZGF0ZScgb3UgbGFuY2V6ICdnaXQgY29uZmlnIGZldGNoLnNob3dGb3JjZWRVcGRhdGVzIHRydWUnLiIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjg1OAorIzogYnVpbHRpbi9mZXRjaC5jOjg3OAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiSXQgdG9vayAlLjJmIHNlY29uZHMgdG8gY2hlY2sgZm9yY2VkIHVwZGF0ZXMuIFlvdSBjYW4gdXNlXG4iCkBAIC0xMzExMiwyMyArMTMxNzQsMjMgQEAKICJWb3VzIHBvdXZleiB1dGlsaXNlciAnLS1uby1zaG93LWZvcmNlZC11cGRhdGUnIG91IGxhbmNlclxuIgogIidnaXQgY29uZmlnIGZldGNoLnNob3dGb3JjZWRVcGRhdGVzIGZhbHNlJyBwb3VyIMOpdml0ZXIgY2VjaS5cbiIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjg4OAorIzogYnVpbHRpbi9mZXRjaC5jOjkwOAogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyBkaWQgbm90IHNlbmQgYWxsIG5lY2Vzc2FyeSBvYmplY3RzXG4iCiBtc2dzdHIgIiVzIG4nYSBwYXMgZW52b3nDqSB0b3VzIGxlcyBvYmpldHMgbsOpY2Vzc2FpcmVzXG4iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzo5MDkKKyM6IGJ1aWx0aW4vZmV0Y2guYzo5MjkKICMsIGMtZm9ybWF0CiBtc2dpZCAicmVqZWN0ICVzIGJlY2F1c2Ugc2hhbGxvdyByb290cyBhcmUgbm90IGFsbG93ZWQgdG8gYmUgdXBkYXRlZCIKIG1zZ3N0ciAiIgogIiVzIHJlamV0w6kgcGFyY2UgcXVlIGxlcyByYWNpbmVzIHN1cGVyZmljaWVsbGVzIG5lIHNvbnQgcGFzIG1pc2VzIMOgIGpvdXIiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxMDAwIGJ1aWx0aW4vZmV0Y2guYzoxMTMxCisjOiBidWlsdGluL2ZldGNoLmM6MTAyMCBidWlsdGluL2ZldGNoLmM6MTE1NwogIywgYy1mb3JtYXQKIG1zZ2lkICJGcm9tICUuKnNcbiIKIG1zZ3N0ciAiRGVwdWlzICUuKnNcbiIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjEwMTEKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxMDMxCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJzb21lIGxvY2FsIHJlZnMgY291bGQgbm90IGJlIHVwZGF0ZWQ7IHRyeSBydW5uaW5nXG4iCkBAIC0xMzEzNyw1OCArMTMxOTksNzkgQEAKICJkZXMgcsOpZsOpcmVuY2VzIGxvY2FsZXMgbidvbnQgcGFzIHB1IMOqdHJlIG1pc2VzIMOgIGpvdXIgOyBlc3NheWV6IGRlIGxhbmNlclxuIgogIiAnZ2l0IHJlbW90ZSBwcnVuZSAlcycgcG91ciBzdXBwcmltZXIgZGVzIGJyYW5jaGVzIGFuY2llbm5lcyBlbiBjb25mbGl0IgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTEwMQorIzogYnVpbHRpbi9mZXRjaC5jOjExMjcKICMsIGMtZm9ybWF0CiBtc2dpZCAiICAgKCVzIHdpbGwgYmVjb21lIGRhbmdsaW5nKSIKIG1zZ3N0ciAiICAgKCVzIHNlcmEgZW4gc3VzcGVucykiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxMTAyCisjOiBidWlsdGluL2ZldGNoLmM6MTEyOAogIywgYy1mb3JtYXQKIG1zZ2lkICIgICAoJXMgaGFzIGJlY29tZSBkYW5nbGluZykiCiBtc2dzdHIgIiAgICglcyBlc3QgZGV2ZW51IGVuIHN1c3BlbnMpIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTEzNAorIzogYnVpbHRpbi9mZXRjaC5jOjExNjAKIG1zZ2lkICJbZGVsZXRlZF0iCiBtc2dzdHIgIltzdXBwcmltw6ldIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTEzNSBidWlsdGluL3JlbW90ZS5jOjEwMzYKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxMTYxIGJ1aWx0aW4vcmVtb3RlLmM6MTAzNgogbXNnaWQgIihub25lKSIKIG1zZ3N0ciAiKGF1Y3VuKGUpKSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjExNTgKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxMTg0CiAjLCBjLWZvcm1hdAogbXNnaWQgIlJlZnVzaW5nIHRvIGZldGNoIGludG8gY3VycmVudCBicmFuY2ggJXMgb2Ygbm9uLWJhcmUgcmVwb3NpdG9yeSIKIG1zZ3N0ciAiUmVmdXMgZGUgcsOpY3Vww6lyZXIgZGFucyBsYSBicmFuY2hlIGNvdXJhbnQgJXMgZCd1biBkw6lww7R0IG5vbiBudSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjExNzcKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxMjAzCiAjLCBjLWZvcm1hdAogbXNnaWQgIk9wdGlvbiBcIiVzXCIgdmFsdWUgXCIlc1wiIGlzIG5vdCB2YWxpZCBmb3IgJXMiCiBtc2dzdHIgIkxhIHZhbGV1ciBcIiUyJHNcIiBkZSBsJ29wdGlvbiBcIiUxJHNcIiBlc3QgaW52YWxpZGUgcG91ciAlMyRzIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTE4MAorIzogYnVpbHRpbi9mZXRjaC5jOjEyMDYKICMsIGMtZm9ybWF0CiBtc2dpZCAiT3B0aW9uIFwiJXNcIiBpcyBpZ25vcmVkIGZvciAlc1xuIgogbXNnc3RyICJMJ29wdGlvbiBcIiVzXCIgZXN0IGlnbm9yw6llIHBvdXIgJXNcbiIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE0ODQKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNDE0Cittc2dpZCAibXVsdGlwbGUgYnJhbmNoIGRldGVjdGVkLCBpbmNvbXBhdGlibGUgd2l0aCAtLXNldC11cHN0cmVhbSIKK21zZ3N0ciAiYnJhbmNoZXMgbXVsdGlwbGVzIGTDqXRlY3TDqWVzLCBpbWNvbXBhdGlibGUgYXZlYyAtLXNldC11cHN0cmVhbSIKKworIzogYnVpbHRpbi9mZXRjaC5jOjE0MjkKK21zZ2lkICJub3Qgc2V0dGluZyB1cHN0cmVhbSBmb3IgYSByZW1vdGUgcmVtb3RlLXRyYWNraW5nIGJyYW5jaCIKK21zZ3N0ciAiZMOpcMO0dCBhbW9udCBub24gZMOpZmluaSBwb3VyIGxhIGJyYW5jaGUgZGUgc3Vpdmkgw6AgZGlzdGFuY2UiCisKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNDMxCittc2dpZCAibm90IHNldHRpbmcgdXBzdHJlYW0gZm9yIGEgcmVtb3RlIHRhZyIKK21zZ3N0ciAiZMOpcMO0dCBhbW9udCBub24gZMOpZmluaSBwb3VyIGwnw6l0aXF1ZXR0ZSBkaXN0YW50ZSIKKworIzogYnVpbHRpbi9mZXRjaC5jOjE0MzMKK21zZ2lkICJ1bmtub3duIGJyYW5jaCB0eXBlIgorbXNnc3RyICJ0eXBlIGRlIGJyYW5jaGUgaW5jb25udSIKKworIzogYnVpbHRpbi9mZXRjaC5jOjE0MzUKK21zZ2lkICIiCisibm8gc291cmNlIGJyYW5jaCBmb3VuZC5cbiIKKyJ5b3UgbmVlZCB0byBzcGVjaWZ5IGV4YWN0bHkgb25lIGJyYW5jaCB3aXRoIHRoZSAtLXNldC11cHN0cmVhbSBvcHRpb24uIgorbXNnc3RyICIiCisiQXVjdW5lIGJyYW5jaGUgc291cmNlIHRyb3V2w6llLlxuIgorIlZvdXMgZGV2ZXogc3DDqWNpZmllciBleGFjdGVtZW50IHVuZSBicmFuY2hlIGF2ZWMgbCdvcHRpb24gLS1zZXQtdXBzdHJlYW0uIgorCisjOiBidWlsdGluL2ZldGNoLmM6MTU2MSBidWlsdGluL2ZldGNoLmM6MTYyMwogIywgYy1mb3JtYXQKIG1zZ2lkICJGZXRjaGluZyAlc1xuIgogbXNnc3RyICJSw6ljdXDDqXJhdGlvbiBkZSAlc1xuIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTQ4NiBidWlsdGluL3JlbW90ZS5jOjEwMAorIzogYnVpbHRpbi9mZXRjaC5jOjE1NzEgYnVpbHRpbi9mZXRjaC5jOjE2MjUgYnVpbHRpbi9yZW1vdGUuYzoxMDAKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ291bGQgbm90IGZldGNoICVzIgogbXNnc3RyICJJbXBvc3NpYmxlIGRlIHLDqWN1cMOpcmVyICVzIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTUzMgotbXNnaWQgIiIKLSItLWZpbHRlciBjYW4gb25seSBiZSB1c2VkIHdpdGggdGhlIHJlbW90ZSBjb25maWd1cmVkIGluIGV4dGVuc2lvbnMuIgotInBhcnRpYWxDbG9uZSIKLW1zZ3N0ciAiIgotIi0tZmlsdGVyIG5lIHBldXQgw6p0cmUgdXRpbGlzw6kgcXUnYXZlYyBsZSBkw6lww7R0IGRpc3RhbnQgY29uZmlndXLDqSBkYW5zICIKLSJleHRlbnNpb25zLnBhcnRpYWxDbG9uZSIKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNTgzCisjLCBjLWZvcm1hdAorbXNnaWQgImNvdWxkIG5vdCBmZXRjaCAnJXMnIChleGl0IGNvZGU6ICVkKVxuIgorbXNnc3RyICJpbXBvc3NpYmxlIGRlIHLDqWN1cMOpcmVyICclcycgKGNvZGUgZGUgc29ydGllwqA6ICVkKVxuIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTU1NgorIzogYnVpbHRpbi9mZXRjaC5jOjE2ODUKIG1zZ2lkICIiCiAiTm8gcmVtb3RlIHJlcG9zaXRvcnkgc3BlY2lmaWVkLiAgUGxlYXNlLCBzcGVjaWZ5IGVpdGhlciBhIFVSTCBvciBhXG4iCiAicmVtb3RlIG5hbWUgZnJvbSB3aGljaCBuZXcgcmV2aXNpb25zIHNob3VsZCBiZSBmZXRjaGVkLiIKQEAgLTEzMTk2LDQ2ICsxMzI3OSw0NiBAQAogIkF1Y3VuIGTDqXDDtHQgZGlzdGFudCBzcMOpY2lmacOpLiBWZXVpbGxleiBzcMOpY2lmaWVyIHVuZSBVUkwgb3UgdW4gbm9tXG4iCiAiZGlzdGFudCBkZXB1aXMgbGVzcXVlbHMgbGVzIG5vdXZlbGxlcyByw6l2aXNpb25zIGRldnJhaWVudCDDqnRyZSByw6ljdXDDqXLDqWVzLiIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE1OTMKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNzIyCiBtc2dpZCAiWW91IG5lZWQgdG8gc3BlY2lmeSBhIHRhZyBuYW1lLiIKIG1zZ3N0ciAiVm91cyBkZXZleiBzcMOpY2lmaWVyIHVuIG5vbSBkJ8OpdGlxdWV0dGUuIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTY0NAorIzogYnVpbHRpbi9mZXRjaC5jOjE3NzQKIG1zZ2lkICJOZWdhdGl2ZSBkZXB0aCBpbiAtLWRlZXBlbiBpcyBub3Qgc3VwcG9ydGVkIgogbXNnc3RyICJVbmUgcHJvZm9uZGV1ciBuw6lnYXRpdmUgZGFucyAtLWRlZXBlbiBuJ2VzdCBwYXMgc3VwcG9ydMOpZSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE2NDYKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNzc2CiBtc2dpZCAiLS1kZWVwZW4gYW5kIC0tZGVwdGggYXJlIG11dHVhbGx5IGV4Y2x1c2l2ZSIKIG1zZ3N0ciAiLS1kZWVwZW4gZXQgLS1kZXB0aCBzb250IG11dHVlbGxlbWVudCBleGNsdXNpZnMiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNjUxCisjOiBidWlsdGluL2ZldGNoLmM6MTc4MQogbXNnaWQgIi0tZGVwdGggYW5kIC0tdW5zaGFsbG93IGNhbm5vdCBiZSB1c2VkIHRvZ2V0aGVyIgogbXNnc3RyICItLWRlcHRoIGV0IC0tdW5zaGFsbG93IG5lIHBldXZlbnQgcGFzIMOqdHJlIHV0aWxpc8OpcyBlbnNlbWJsZSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE2NTMKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNzgzCiBtc2dpZCAiLS11bnNoYWxsb3cgb24gYSBjb21wbGV0ZSByZXBvc2l0b3J5IGRvZXMgbm90IG1ha2Ugc2Vuc2UiCiBtc2dzdHIgIi0tdW5zaGFsbG93IHN1ciB1biBkw6lww7R0IGNvbXBsZXQgbidhIHBhcyBkZSBzZW5zIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTY2OQorIzogYnVpbHRpbi9mZXRjaC5jOjE3OTkKIG1zZ2lkICJmZXRjaCAtLWFsbCBkb2VzIG5vdCB0YWtlIGEgcmVwb3NpdG9yeSBhcmd1bWVudCIKIG1zZ3N0ciAiZmV0Y2ggLS1hbGwgbidhY2NlcHRlIHBhcyBkJ2FyZ3VtZW50IGRlIGTDqXDDtHQiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNjcxCisjOiBidWlsdGluL2ZldGNoLmM6MTgwMQogbXNnaWQgImZldGNoIC0tYWxsIGRvZXMgbm90IG1ha2Ugc2Vuc2Ugd2l0aCByZWZzcGVjcyIKIG1zZ3N0ciAiZmV0Y2ggLS1hbGwgbidhIHBhcyBkZSBzZW5zIGF2ZWMgZGVzIHNww6ljaWZpY2F0aW9ucyBkZSByw6lmw6lyZW5jZSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE2ODAKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxODEwCiAjLCBjLWZvcm1hdAogbXNnaWQgIk5vIHN1Y2ggcmVtb3RlIG9yIHJlbW90ZSBncm91cDogJXMiCiBtc2dzdHIgImRpc3RhbnQgb3UgZ3JvdXBlIGRpc3RhbnQgaW5leGlzdGFudCA6ICVzIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTY4NworIzogYnVpbHRpbi9mZXRjaC5jOjE4MTcKIG1zZ2lkICJGZXRjaGluZyBhIGdyb3VwIGFuZCBzcGVjaWZ5aW5nIHJlZnNwZWNzIGRvZXMgbm90IG1ha2Ugc2Vuc2UiCiBtc2dzdHIgIiIKICJMYSByw6ljdXDDqXJhdGlvbiBkJ3VuIGdyb3VwZSBldCBsZXMgc3DDqWNpZmljYXRpb25zIGRlIHLDqWbDqXJlbmNlIG4nb250IHBhcyBkZSAiCiAic2VucyIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE3MDMKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxODM1CiBtc2dpZCAiIgogIi0tZmlsdGVyIGNhbiBvbmx5IGJlIHVzZWQgd2l0aCB0aGUgcmVtb3RlIGNvbmZpZ3VyZWQgaW4gZXh0ZW5zaW9ucy4iCiAicGFydGlhbGNsb25lIgpAQCAtMTM1NzMsNyArMTM2NTYsNyBAQAogbXNnaWQgImludmFsaWQgcGFyYW1ldGVyOiBleHBlY3RlZCBzaGExLCBnb3QgJyVzJyIKIG1zZ3N0ciAicGFyYW3DqHRyZSBpbnZhbGlkZcKgOiBzaGEtMSBhdHRlbmR1LCAnJXMnIHRyb3V2w6kiCiAKLSM6IGJ1aWx0aW4vZ2MuYzozNAorIzogYnVpbHRpbi9nYy5jOjM1CiBtc2dpZCAiZ2l0IGdjIFs8b3B0aW9ucz5dIgogbXNnc3RyICJnaXQgZ2MgWzxvcHRpb25zPl0iCiAKQEAgLTEzNTg3LDE3ICsxMzY3MCwxNyBAQAogbXNnaWQgImZhaWxlZCB0byBwYXJzZSAnJXMnIHZhbHVlICclcyciCiBtc2dzdHIgIsOpY2hlYyBkZSBsJ2FuYWx5c2UgZGUgJyVzJyB2YWxldXIgJyVzJyIKIAotIzogYnVpbHRpbi9nYy5jOjQ3NiBidWlsdGluL2luaXQtZGIuYzo1NQorIzogYnVpbHRpbi9nYy5jOjQ3NSBidWlsdGluL2luaXQtZGIuYzo1NQogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3Qgc3RhdCAnJXMnIgogbXNnc3RyICJpbXBvc3NpYmxlIGRlIGZhaXJlIHVuIHN0YXQgZGUgJyVzJyIKIAotIzogYnVpbHRpbi9nYy5jOjQ4NSBidWlsdGluL25vdGVzLmM6MjQwIGJ1aWx0aW4vdGFnLmM6NTI5CisjOiBidWlsdGluL2djLmM6NDg0IGJ1aWx0aW4vbm90ZXMuYzoyNDAgYnVpbHRpbi90YWcuYzo1MjkKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IHJlYWQgJyVzJyIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkZSBsaXJlICclcyciCiAKLSM6IGJ1aWx0aW4vZ2MuYzo0OTIKKyM6IGJ1aWx0aW4vZ2MuYzo0OTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlRoZSBsYXN0IGdjIHJ1biByZXBvcnRlZCB0aGUgZm9sbG93aW5nLiBQbGVhc2UgY29ycmVjdCB0aGUgcm9vdCBjYXVzZVxuIgpAQCAtMTM2MTMsNTYgKzEzNjk2LDU2IEBACiAiXG4iCiAiJXMiCiAKLSM6IGJ1aWx0aW4vZ2MuYzo1NDAKKyM6IGJ1aWx0aW4vZ2MuYzo1MzkKIG1zZ2lkICJwcnVuZSB1bnJlZmVyZW5jZWQgb2JqZWN0cyIKIG1zZ3N0ciAiw6lsaW1pbmVyIGxlcyBvYmpldHMgbm9uIHLDqWbDqXJlbmPDqXMiCiAKLSM6IGJ1aWx0aW4vZ2MuYzo1NDIKKyM6IGJ1aWx0aW4vZ2MuYzo1NDEKIG1zZ2lkICJiZSBtb3JlIHRob3JvdWdoIChpbmNyZWFzZWQgcnVudGltZSkiCiBtc2dzdHIgIsOqdHJlIHBsdXMgY29uc2NpZW5jaWV1eCAoZHVyw6llIGRlIHRyYWl0ZW1lbnQgYWxsb25nw6llKSIKIAotIzogYnVpbHRpbi9nYy5jOjU0MworIzogYnVpbHRpbi9nYy5jOjU0MgogbXNnaWQgImVuYWJsZSBhdXRvLWdjIG1vZGUiCiBtc2dzdHIgImFjdGl2ZXIgbGUgbW9kZSBhdXRvLWdjIgogCi0jOiBidWlsdGluL2djLmM6NTQ2CisjOiBidWlsdGluL2djLmM6NTQ1CiBtc2dpZCAiZm9yY2UgcnVubmluZyBnYyBldmVuIGlmIHRoZXJlIG1heSBiZSBhbm90aGVyIGdjIHJ1bm5pbmciCiBtc2dzdHIgIiIKICJmb3JjZXIgbGUgbGFuY2VtZW50IGR1IHJhbWFzc2UtbWlldHRlcyBtw6ptZSBzaSB1biBhdXRyZSByYW1hc3NlLW1pZXR0ZXMgIgogInRvdXJuZSBkw6lqw6AiCiAKLSM6IGJ1aWx0aW4vZ2MuYzo1NDkKKyM6IGJ1aWx0aW4vZ2MuYzo1NDgKIG1zZ2lkICJyZXBhY2sgYWxsIG90aGVyIHBhY2tzIGV4Y2VwdCB0aGUgbGFyZ2VzdCBwYWNrIgogbXNnc3RyICJyZWNvbXBhY3RlciB0b3VzIGxlcyBhdXRyZXMgcGFxdWV0cyBleGNlcHTDqSBsZSBwbHVzIGdyb3MgcGFxdWV0IgogCi0jOiBidWlsdGluL2djLmM6NTY2CisjOiBidWlsdGluL2djLmM6NTY1CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBwYXJzZSBnYy5sb2dleHBpcnkgdmFsdWUgJXMiCiBtc2dzdHIgImltcG9zc2libGUgZCdhbmFseXNlciBnYy5sb2dleHBpcnkgJXMiCiAKLSM6IGJ1aWx0aW4vZ2MuYzo1NzcKKyM6IGJ1aWx0aW4vZ2MuYzo1NzYKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIHBhcnNlIHBydW5lIGV4cGlyeSB2YWx1ZSAlcyIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkJ2FuYWx5c2VyIGxhIHZhbGV1ciBkJ2V4cGlyYXRpb24gZCfDqWxhZ2FnZSAlcyIKIAotIzogYnVpbHRpbi9nYy5jOjU5NworIzogYnVpbHRpbi9nYy5jOjU5NgogIywgYy1mb3JtYXQKIG1zZ2lkICJBdXRvIHBhY2tpbmcgdGhlIHJlcG9zaXRvcnkgaW4gYmFja2dyb3VuZCBmb3Igb3B0aW11bSBwZXJmb3JtYW5jZS5cbiIKIG1zZ3N0ciAiIgogIkNvbXByZXNzaW9uIGF1dG9tYXRpcXVlIGR1IGTDqXDDtHQgZW4gdMOiY2hlIGRlIGZvbmQgcG91ciBvcHRpbWlzZXIgbGVzICIKICJwZXJmb3JtYW5jZXMuXG4iCiAKLSM6IGJ1aWx0aW4vZ2MuYzo1OTkKKyM6IGJ1aWx0aW4vZ2MuYzo1OTgKICMsIGMtZm9ybWF0CiBtc2dpZCAiQXV0byBwYWNraW5nIHRoZSByZXBvc2l0b3J5IGZvciBvcHRpbXVtIHBlcmZvcm1hbmNlLlxuIgogbXNnc3RyICJDb21wcmVzc2lvbiBkdSBkw6lww7R0IHBvdXIgb3B0aW1pc2VyIGxlcyBwZXJmb3JtYW5jZXMuXG4iCiAKLSM6IGJ1aWx0aW4vZ2MuYzo2MDAKKyM6IGJ1aWx0aW4vZ2MuYzo1OTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiU2VlIFwiZ2l0IGhlbHAgZ2NcIiBmb3IgbWFudWFsIGhvdXNla2VlcGluZy5cbiIKIG1zZ3N0ciAiVm9pciBcImdpdCBoZWxwIGdjXCIgcG91ciB0b3V0ZSBpbmZvcm1hdGlvbiBzdXIgbGUgbmV0dG95YWdlIG1hbnVlbC5cbiIKIAotIzogYnVpbHRpbi9nYy5jOjY0MAorIzogYnVpbHRpbi9nYy5jOjYzOQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiZ2MgaXMgYWxyZWFkeSBydW5uaW5nIG9uIG1hY2hpbmUgJyVzJyBwaWQgJTxQUkl1TUFYPiAodXNlIC0tZm9yY2UgaWYgbm90KSIKQEAgLTEzNjcwLDcgKzEzNzUzLDcgQEAKICJ1biByYW1hc3NlLW1pZXR0ZXMgZXN0IGTDqWrDoCBlbiBjb3VycyBzdXIgbGEgbWFjaGluZSAnJXMnIHBpZCAlPFBSSXVNQVg+ICIKICIodXRpbGlzZXogLS1mb3JjZSBzaSBjZSBuJ2VzdCBwYXMgbGUgY2FzKSIKIAotIzogYnVpbHRpbi9nYy5jOjY5NQorIzogYnVpbHRpbi9nYy5jOjY5NAogbXNnaWQgIiIKICJUaGVyZSBhcmUgdG9vIG1hbnkgdW5yZWFjaGFibGUgbG9vc2Ugb2JqZWN0czsgcnVuICdnaXQgcHJ1bmUnIHRvIHJlbW92ZSB0aGVtLiIKIG1zZ3N0ciAiIgpAQCAtMTM2OTYsMjY1ICsxMzc3OSwyNjUgQEAKICMuIGdyZXAudGhyZWFkcwogIy4KICM6IGJ1aWx0aW4vZ3JlcC5jOjI4NyBidWlsdGluL2luZGV4LXBhY2suYzoxNTM0IGJ1aWx0aW4vaW5kZXgtcGFjay5jOjE3MjcKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjcyOAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNzA4CiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vIHRocmVhZHMgc3VwcG9ydCwgaWdub3JpbmcgJXMiCiBtc2dzdHIgInBhcyBkZSBzdXBwb3J0IGRlcyBmaWxzLCBpZ25vcmUgJXMiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjQ2NyBidWlsdGluL2dyZXAuYzo1OTEgYnVpbHRpbi9ncmVwLmM6NjMzCisjOiBidWlsdGluL2dyZXAuYzo0NjcgYnVpbHRpbi9ncmVwLmM6NTkyIGJ1aWx0aW4vZ3JlcC5jOjYzNQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gcmVhZCB0cmVlICglcykiCiBtc2dzdHIgImltcG9zc2libGUgZGUgbGlyZSBsJ2FyYnJlICglcykiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjY0OAorIzogYnVpbHRpbi9ncmVwLmM6NjUwCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBncmVwIGZyb20gb2JqZWN0IG9mIHR5cGUgJXMiCiBtc2dzdHIgImltcG9zc2libGUgZGUgZmFpcmUgdW4gZ3JlcCBzdXIgdW4gb2JqZXQgZGUgdHlwZSAlcyIKIAotIzogYnVpbHRpbi9ncmVwLmM6NzE0CisjOiBidWlsdGluL2dyZXAuYzo3MTYKICMsIGMtZm9ybWF0CiBtc2dpZCAic3dpdGNoIGAlYycgZXhwZWN0cyBhIG51bWVyaWNhbCB2YWx1ZSIKIG1zZ3N0ciAibCdvcHRpb24gJyVjJyBhdHRlbmQgdW5lIHZhbGV1ciBudW3DqXJpcXVlIgogCi0jOiBidWlsdGluL2dyZXAuYzo4MTMKKyM6IGJ1aWx0aW4vZ3JlcC5jOjgxNQogbXNnaWQgInNlYXJjaCBpbiBpbmRleCBpbnN0ZWFkIG9mIGluIHRoZSB3b3JrIHRyZWUiCiBtc2dzdHIgInJlY2hlcmNoZXIgZGFucyBsJ2luZGV4IHBsdXTDtHQgcXVlIGRhbnMgbGEgY29waWUgZGUgdHJhdmFpbCIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODE1CisjOiBidWlsdGluL2dyZXAuYzo4MTcKIG1zZ2lkICJmaW5kIGluIGNvbnRlbnRzIG5vdCBtYW5hZ2VkIGJ5IGdpdCIKIG1zZ3N0ciAicmVjaGVyY2hlciBkYW5zIGxlcyBjb250ZW51cyBub24gZ8OpcsOpcyBwYXIgZ2l0IgogCi0jOiBidWlsdGluL2dyZXAuYzo4MTcKKyM6IGJ1aWx0aW4vZ3JlcC5jOjgxOQogbXNnaWQgInNlYXJjaCBpbiBib3RoIHRyYWNrZWQgYW5kIHVudHJhY2tlZCBmaWxlcyIKIG1zZ3N0ciAicmVjaGVyY2hlciBkYW5zIGxlcyBmaWNoaWVycyBzdWl2aXMgZXQgbm9uLXN1aXZpcyIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODE5CisjOiBidWlsdGluL2dyZXAuYzo4MjEKIG1zZ2lkICJpZ25vcmUgZmlsZXMgc3BlY2lmaWVkIHZpYSAnLmdpdGlnbm9yZSciCiBtc2dzdHIgImlnbm9yZXIgbGVzIGZpY2hpZXJzIHNww6ljaWZpw6lzIHZpYSAnLmdpdGlnbm9yZSciCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjgyMQorIzogYnVpbHRpbi9ncmVwLmM6ODIzCiBtc2dpZCAicmVjdXJzaXZlbHkgc2VhcmNoIGluIGVhY2ggc3VibW9kdWxlIgogbXNnc3RyICJyZWNoZXJjaGVyIHLDqWN1cnNpdmVtZW50IGRhbnMgY2hhcXVlIHNvdXMtbW9kdWxlIgogCi0jOiBidWlsdGluL2dyZXAuYzo4MjQKKyM6IGJ1aWx0aW4vZ3JlcC5jOjgyNgogbXNnaWQgInNob3cgbm9uLW1hdGNoaW5nIGxpbmVzIgogbXNnc3RyICJhZmZpY2hlciBsZXMgbGlnbmVzIHF1aSBuZSBjb3JyZXNwb25kZW50IHBhcyIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODI2CisjOiBidWlsdGluL2dyZXAuYzo4MjgKIG1zZ2lkICJjYXNlIGluc2Vuc2l0aXZlIG1hdGNoaW5nIgogbXNnc3RyICJjb3JyZXNwb25kYW5jZSBpbnNlbnNpYmxlIMOgIGxhIGNhc3NlIgogCi0jOiBidWlsdGluL2dyZXAuYzo4MjgKKyM6IGJ1aWx0aW4vZ3JlcC5jOjgzMAogbXNnaWQgIm1hdGNoIHBhdHRlcm5zIG9ubHkgYXQgd29yZCBib3VuZGFyaWVzIgogbXNnc3RyICJyZWNoZXJjaGVyIGxlcyBtb3RpZnMgYXV4IHPDqXBhcmF0ZXVycyBkZSBtb3RzIgogCi0jOiBidWlsdGluL2dyZXAuYzo4MzAKKyM6IGJ1aWx0aW4vZ3JlcC5jOjgzMgogbXNnaWQgInByb2Nlc3MgYmluYXJ5IGZpbGVzIGFzIHRleHQiCiBtc2dzdHIgInRyYWl0ZXIgbGVzIGZpY2hpZXJzIGJpbmFpcmVzIGNvbW1lIHRleHRlIgogCi0jOiBidWlsdGluL2dyZXAuYzo4MzIKKyM6IGJ1aWx0aW4vZ3JlcC5jOjgzNAogbXNnaWQgImRvbid0IG1hdGNoIHBhdHRlcm5zIGluIGJpbmFyeSBmaWxlcyIKIG1zZ3N0ciAibmUgcGFzIGNoZXJjaGVyIGxlcyBtb3RpZnMgZGFucyBsZXMgZmljaGllcnMgYmluYWlyZXMiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjgzNQorIzogYnVpbHRpbi9ncmVwLmM6ODM3CiBtc2dpZCAicHJvY2VzcyBiaW5hcnkgZmlsZXMgd2l0aCB0ZXh0Y29udiBmaWx0ZXJzIgogbXNnc3RyICJ0cmFpdGVyIGxlcyBmaWNoaWVycyBiaW5haXJlcyBhdmVjIGxlcyBmaWx0cmVzIHRleHRjb252IgogCi0jOiBidWlsdGluL2dyZXAuYzo4MzcKKyM6IGJ1aWx0aW4vZ3JlcC5jOjgzOQogbXNnaWQgInNlYXJjaCBpbiBzdWJkaXJlY3RvcmllcyAoZGVmYXVsdCkiCiBtc2dzdHIgInJlY2hlcmNoZXIgZGFucyBsZXMgc291cy1yw6lwZXJ0b2lyZXMgKGTDqWZhdXQpIgogCi0jOiBidWlsdGluL2dyZXAuYzo4MzkKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg0MQogbXNnaWQgImRlc2NlbmQgYXQgbW9zdCA8ZGVwdGg+IGxldmVscyIKIG1zZ3N0ciAiZGVzY2VuZHJlIGF1IHBsdXMgZGUgPHByb2ZvbmRldXI+IGRhbnMgbCdhcmJvcmVzY2VuY2UiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg0MworIzogYnVpbHRpbi9ncmVwLmM6ODQ1CiBtc2dpZCAidXNlIGV4dGVuZGVkIFBPU0lYIHJlZ3VsYXIgZXhwcmVzc2lvbnMiCiBtc2dzdHIgInV0aWxpc2VyIGRlcyBleHByZXNzaW9ucyByw6lndWxpw6hyZXMgw6l0ZW5kdWVzIFBPU0lYIgogCi0jOiBidWlsdGluL2dyZXAuYzo4NDYKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg0OAogbXNnaWQgInVzZSBiYXNpYyBQT1NJWCByZWd1bGFyIGV4cHJlc3Npb25zIChkZWZhdWx0KSIKIG1zZ3N0ciAidXRpbGlzZXIgZGVzIGV4cHJlc3Npb25zIHLDqWd1bGnDqHJlcyBiYXNpcXVlcyBQT1NJWCAocGFyIGTDqWZhdXQpIgogCi0jOiBidWlsdGluL2dyZXAuYzo4NDkKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg1MQogbXNnaWQgImludGVycHJldCBwYXR0ZXJucyBhcyBmaXhlZCBzdHJpbmdzIgogbXNnc3RyICJpbnRlcnByw6l0ZXIgbGVzIG1vdGlmcyBjb21tZSBkZSBjaGHDrm5lcyBmaXhlcyIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODUyCisjOiBidWlsdGluL2dyZXAuYzo4NTQKIG1zZ2lkICJ1c2UgUGVybC1jb21wYXRpYmxlIHJlZ3VsYXIgZXhwcmVzc2lvbnMiCiBtc2dzdHIgInV0aWxpc2VyIGRlcyBleHByZXNzaW9ucyByw6lndWxpw6hyZXMgY29tcGF0aWJsZXMgYXZlYyBQZXJsIgogCi0jOiBidWlsdGluL2dyZXAuYzo4NTUKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg1NwogbXNnaWQgInNob3cgbGluZSBudW1iZXJzIgogbXNnc3RyICJhZmZpY2hlciBsZXMgbnVtw6lyb3MgZGUgbGlnbmUiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg1NgorIzogYnVpbHRpbi9ncmVwLmM6ODU4CiBtc2dpZCAic2hvdyBjb2x1bW4gbnVtYmVyIG9mIGZpcnN0IG1hdGNoIgogbXNnc3RyICJhZmZpY2hlciBsZSBudW3DqXJvIGRlIGNvbG9ubmUgZGUgbGEgcHJlbWnDqHJlIGNvcnJlc3BvbmRhbmNlIgogCi0jOiBidWlsdGluL2dyZXAuYzo4NTcKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg1OQogbXNnaWQgImRvbid0IHNob3cgZmlsZW5hbWVzIgogbXNnc3RyICJuZSBwYXMgcGFzIGFmZmljaGVyIGxlcyBub21zIGRlIGZpY2hpZXIiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg1OAorIzogYnVpbHRpbi9ncmVwLmM6ODYwCiBtc2dpZCAic2hvdyBmaWxlbmFtZXMiCiBtc2dzdHIgImFmZmljaGVyIGxlcyBub21zIGRlIGZpY2hpZXIiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg2MAorIzogYnVpbHRpbi9ncmVwLmM6ODYyCiBtc2dpZCAic2hvdyBmaWxlbmFtZXMgcmVsYXRpdmUgdG8gdG9wIGRpcmVjdG9yeSIKIG1zZ3N0ciAiYWZmaWNoZXIgbGVzIG5vbXMgZGUgZmljaGllcnMgcmVsYXRpdmVtZW50IGF1IHLDqXBlcnRvaXJlIGRlIGJhc2UiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg2MgorIzogYnVpbHRpbi9ncmVwLmM6ODY0CiBtc2dpZCAic2hvdyBvbmx5IGZpbGVuYW1lcyBpbnN0ZWFkIG9mIG1hdGNoaW5nIGxpbmVzIgogbXNnc3RyICJuJ2FmZmljaGVyIHF1ZSBsZXMgbm9tcyBkZSBmaWNoaWVycyBhdSBsaWV1IGRlcyBsaWduZXMgY29ycmVzcG9uZGFudCIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODY0CisjOiBidWlsdGluL2dyZXAuYzo4NjYKIG1zZ2lkICJzeW5vbnltIGZvciAtLWZpbGVzLXdpdGgtbWF0Y2hlcyIKIG1zZ3N0ciAic3lub255bWUgcG91ciAtLWZpbGVzLXdpdGgtbWF0Y2hlcyIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODY3CisjOiBidWlsdGluL2dyZXAuYzo4NjkKIG1zZ2lkICJzaG93IG9ubHkgdGhlIG5hbWVzIG9mIGZpbGVzIHdpdGhvdXQgbWF0Y2giCiBtc2dzdHIgIm4nYWZmaWNoZXIgcXVlIGxlcyBub21zIGRlcyBmaWNoaWVycyBzYW5zIGNvcnJlc3BvbmRhbmNlIgogCi0jOiBidWlsdGluL2dyZXAuYzo4NjkKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg3MQogbXNnaWQgInByaW50IE5VTCBhZnRlciBmaWxlbmFtZXMiCiBtc2dzdHIgImltcHJpbWVyIHVuZSBjYXJhY3TDqHJlIE5VTCBhcHLDqHMgbGUgbm9tcyBkZSBmaWNoaWVyIgogCi0jOiBidWlsdGluL2dyZXAuYzo4NzIKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg3NAogbXNnaWQgInNob3cgb25seSBtYXRjaGluZyBwYXJ0cyBvZiBhIGxpbmUiCiBtc2dzdHIgIm4nYWZmaWNoZXIgcXVlIGxlcyBwYXJ0aWVzIGNvcnJlc3BvbmRhbnRlcyBkJ3VuZSBsaWduZSIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODc0CisjOiBidWlsdGluL2dyZXAuYzo4NzYKIG1zZ2lkICJzaG93IHRoZSBudW1iZXIgb2YgbWF0Y2hlcyBpbnN0ZWFkIG9mIG1hdGNoaW5nIGxpbmVzIgogbXNnc3RyICJhZmZpY2hlciBsZSBub21icmUgZGUgY29ycmVzcG9uZGFuY2VzIGF1IGxpZXUgZGVzIGxpZ25lcyBjb3JyZXNwb25kYW50IgogCi0jOiBidWlsdGluL2dyZXAuYzo4NzUKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg3NwogbXNnaWQgImhpZ2hsaWdodCBtYXRjaGVzIgogbXNnc3RyICJtZXR0cmUgZW4gw6l2aWRlbmNlIGxlcyBjb3JyZXNwb25kYW5jZXMiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg3NworIzogYnVpbHRpbi9ncmVwLmM6ODc5CiBtc2dpZCAicHJpbnQgZW1wdHkgbGluZSBiZXR3ZWVuIG1hdGNoZXMgZnJvbSBkaWZmZXJlbnQgZmlsZXMiCiBtc2dzdHIgIiIKICJpbXByaW1lciB1bmUgbGlnbmUgdmlkZSBlbnRyZSBsZXMgY29ycmVzcG9uZGFuY2VzIGRlIGZpY2hpZXJzIGRpZmbDqXJlbnRzIgogCi0jOiBidWlsdGluL2dyZXAuYzo4NzkKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg4MQogbXNnaWQgInNob3cgZmlsZW5hbWUgb25seSBvbmNlIGFib3ZlIG1hdGNoZXMgZnJvbSBzYW1lIGZpbGUiCiBtc2dzdHIgIiIKICJhZmZpY2hlciBsZSBub20gZGUgZmljaGllciB1bmUgZm9pcyBhdSBkZXNzdXMgZGVzIGNvcnJlc3BvbmRhbmNlcyBkdSBtw6ptZSAiCiAiZmljaGllciIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODgyCisjOiBidWlsdGluL2dyZXAuYzo4ODQKIG1zZ2lkICJzaG93IDxuPiBjb250ZXh0IGxpbmVzIGJlZm9yZSBhbmQgYWZ0ZXIgbWF0Y2hlcyIKIG1zZ3N0ciAiYWZmaWNoZXIgPG4+IGxpZ25lcyBkZSBjb250ZXh0ZSBhdmFudCBldCBhcHLDqHMgbGVzIGNvcnJlc3BvbmRhbmNlcyIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODg1CisjOiBidWlsdGluL2dyZXAuYzo4ODcKIG1zZ2lkICJzaG93IDxuPiBjb250ZXh0IGxpbmVzIGJlZm9yZSBtYXRjaGVzIgogbXNnc3RyICJhZmZpY2hlciA8bj4gbGlnbmVzIGRlIGNvbnRleHRlIGF2YW50IGxlcyBjb3JyZXNwb25kYW5jZXMiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg4NworIzogYnVpbHRpbi9ncmVwLmM6ODg5CiBtc2dpZCAic2hvdyA8bj4gY29udGV4dCBsaW5lcyBhZnRlciBtYXRjaGVzIgogbXNnc3RyICJhZmZpY2hlciA8bj4gbGlnbmVzIGRlIGNvbnRleHRlIGFwcsOocyBsZXMgY29ycmVzcG9uZGFuY2VzIgogCi0jOiBidWlsdGluL2dyZXAuYzo4ODkKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg5MQogbXNnaWQgInVzZSA8bj4gd29ya2VyIHRocmVhZHMiCiBtc2dzdHIgInV0aWxpc2VyIDxuPiBmaWxzIGRlIHRyYXZhaWwiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg5MAorIzogYnVpbHRpbi9ncmVwLmM6ODkyCiBtc2dpZCAic2hvcnRjdXQgZm9yIC1DIE5VTSIKIG1zZ3N0ciAicmFjY291cmNpIHBvdXIgLUMgTlVNIgogCi0jOiBidWlsdGluL2dyZXAuYzo4OTMKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg5NQogbXNnaWQgInNob3cgYSBsaW5lIHdpdGggdGhlIGZ1bmN0aW9uIG5hbWUgYmVmb3JlIG1hdGNoZXMiCiBtc2dzdHIgIiIKICJhZmZpY2hlciB1bmUgbGlnbmUgYXZlYyBsZSBub20gZGUgbGEgZm9uY3Rpb24gYXZhbnQgbGVzIGNvcnJlc3BvbmRhbmNlcyIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODk1CisjOiBidWlsdGluL2dyZXAuYzo4OTcKIG1zZ2lkICJzaG93IHRoZSBzdXJyb3VuZGluZyBmdW5jdGlvbiIKIG1zZ3N0ciAiYWZmaWNoZXIgbGEgZm9uY3Rpb24gY29udGVuYW50ZSIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODk4CisjOiBidWlsdGluL2dyZXAuYzo5MDAKIG1zZ2lkICJyZWFkIHBhdHRlcm5zIGZyb20gZmlsZSIKIG1zZ3N0ciAibGlyZSBsZXMgbW90aWZzIGRlcHVpcyBmaWNoaWVyIgogCi0jOiBidWlsdGluL2dyZXAuYzo5MDAKKyM6IGJ1aWx0aW4vZ3JlcC5jOjkwMgogbXNnaWQgIm1hdGNoIDxwYXR0ZXJuPiIKIG1zZ3N0ciAicmVjaGVyY2hlciA8bW90aWY+IgogCi0jOiBidWlsdGluL2dyZXAuYzo5MDIKKyM6IGJ1aWx0aW4vZ3JlcC5jOjkwNAogbXNnaWQgImNvbWJpbmUgcGF0dGVybnMgc3BlY2lmaWVkIHdpdGggLWUiCiBtc2dzdHIgImNvbWJpbmVyIGxlcyBtb3RpZnMgc3DDqWNpZmnDqXMgcGFyIC1lIgogCi0jOiBidWlsdGluL2dyZXAuYzo5MTQKKyM6IGJ1aWx0aW4vZ3JlcC5jOjkxNgogbXNnaWQgImluZGljYXRlIGhpdCB3aXRoIGV4aXQgc3RhdHVzIHdpdGhvdXQgb3V0cHV0IgogbXNnc3RyICIiCiAiaW5kaXF1ZXIgZGVzIGNvcnJlc3BvbmRhbmNlcyBhdmVjIGxlIGNvZGUgZGUgc29ydGllIG1haXMgc2FucyByaWVuIGFmZmljaGVyIgogCi0jOiBidWlsdGluL2dyZXAuYzo5MTYKKyM6IGJ1aWx0aW4vZ3JlcC5jOjkxOAogbXNnaWQgInNob3cgb25seSBtYXRjaGVzIGZyb20gZmlsZXMgdGhhdCBtYXRjaCBhbGwgcGF0dGVybnMiCiBtc2dzdHIgIiIKICJuJ2FmZmljaGVyIHF1ZSBsZXMgY29ycmVzcG9uZGFuY2VzIGRlIGZpY2hpZXJzIHF1aSBjb3JyZXNwb25kZW50IMOgIHRvdXMgbGVzICIKICJtb3RpZnMiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjkxOAorIzogYnVpbHRpbi9ncmVwLmM6OTIwCiBtc2dpZCAic2hvdyBwYXJzZSB0cmVlIGZvciBncmVwIGV4cHJlc3Npb24iCiBtc2dzdHIgImFmZmljaGVyIGwnYXJicmUgZCdhbmFseXNlIHBvdXIgbGUgbW90aWYgZ3JlcCIKIAotIzogYnVpbHRpbi9ncmVwLmM6OTIyCisjOiBidWlsdGluL2dyZXAuYzo5MjQKIG1zZ2lkICJwYWdlciIKIG1zZ3N0ciAicGFnaW5ldXIiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjkyMgorIzogYnVpbHRpbi9ncmVwLmM6OTI0CiBtc2dpZCAic2hvdyBtYXRjaGluZyBmaWxlcyBpbiB0aGUgcGFnZXIiCiBtc2dzdHIgImFmZmljaGVyIGxlcyBmaWNoaWVycyBjb3JyZXNwb25kYW50IGRhbnMgbGUgcGFnaW5ldXIiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjkyNgorIzogYnVpbHRpbi9ncmVwLmM6OTI4CiBtc2dpZCAiYWxsb3cgY2FsbGluZyBvZiBncmVwKDEpIChpZ25vcmVkIGJ5IHRoaXMgYnVpbGQpIgogbXNnc3RyICJwZXJtZXR0cmUgbCdhcHBlbCBkZSBncmVwKDEpIChpZ25vcsOpIHBhciBjZSBidWlsZCkiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjk5MAorIzogYnVpbHRpbi9ncmVwLmM6OTkyCiBtc2dpZCAibm8gcGF0dGVybiBnaXZlbiIKIG1zZ3N0ciAiYXVjdW4gbW90aWYgZm91cm5pIgogCi0jOiBidWlsdGluL2dyZXAuYzoxMDI2CisjOiBidWlsdGluL2dyZXAuYzoxMDI4CiBtc2dpZCAiLS1uby1pbmRleCBvciAtLXVudHJhY2tlZCBjYW5ub3QgYmUgdXNlZCB3aXRoIHJldnMiCiBtc2dzdHIgIiIKICItLW5vLWluZGV4IG91IC0tdW50cmFja2VkIG5lIHBldXZlbnQgcGFzIMOqdHJlIHV0aWxpc8OpcyBhdmVjIGRlcyByw6l2aXNpb25zIgogCi0jOiBidWlsdGluL2dyZXAuYzoxMDM0CisjOiBidWlsdGluL2dyZXAuYzoxMDM2CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byByZXNvbHZlIHJldmlzaW9uOiAlcyIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkZSByw6lzb3VkcmUgbGEgcsOpdmlzaW9uwqA6ICVzIgogCi0jOiBidWlsdGluL2dyZXAuYzoxMDY1CisjOiBidWlsdGluL2dyZXAuYzoxMDY3CiBtc2dpZCAiaW52YWxpZCBvcHRpb24gY29tYmluYXRpb24sIGlnbm9yaW5nIC0tdGhyZWFkcyIKIG1zZ3N0ciAib3B0aW9uIGRlIGNvbWJpbmFpc29uIGludmFsaWRlLCBpZ25vcmUgLS10aHJlYWRzIgogCi0jOiBidWlsdGluL2dyZXAuYzoxMDY4IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzQxNgorIzogYnVpbHRpbi9ncmVwLmM6MTA3MCBidWlsdGluL3BhY2stb2JqZWN0cy5jOjM0MDAKIG1zZ2lkICJubyB0aHJlYWRzIHN1cHBvcnQsIGlnbm9yaW5nIC0tdGhyZWFkcyIKIG1zZ3N0ciAicGFzIGRlIHN1cHBvcnQgZGVzIGZpbHMsIGlnbm9yZSAtLXRocmVhZHMiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjEwNzEgYnVpbHRpbi9pbmRleC1wYWNrLmM6MTUzMSBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI3MjUKKyM6IGJ1aWx0aW4vZ3JlcC5jOjEwNzMgYnVpbHRpbi9pbmRleC1wYWNrLmM6MTUzMSBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI3MDUKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBudW1iZXIgb2YgdGhyZWFkcyBzcGVjaWZpZWQgKCVkKSIKIG1zZ3N0ciAibm9tYnJlIGRlIGZpbHMgc3DDqWNpZmnDqSBpbnZhbGlkZSAoJWQpIgogCi0jOiBidWlsdGluL2dyZXAuYzoxMDk0CisjOiBidWlsdGluL2dyZXAuYzoxMDk2CiBtc2dpZCAiLS1vcGVuLWZpbGVzLWluLXBhZ2VyIG9ubHkgd29ya3Mgb24gdGhlIHdvcmt0cmVlIgogbXNnc3RyICItLW9wZW4tZmlsZXMtaW4tcGFnZXIgbmUgZm9uY3Rpb25uZSBxdWUgc3VyIGxhIGNvcGllIGRlIHRyYXZhaWwiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjExMTcKKyM6IGJ1aWx0aW4vZ3JlcC5jOjExMTkKIG1zZ2lkICJvcHRpb24gbm90IHN1cHBvcnRlZCB3aXRoIC0tcmVjdXJzZS1zdWJtb2R1bGVzIgogbXNnc3RyICJvcHRpb24gbm9uIHN1cHBvcnTDqWUgYXZlYyAtLXJlY3Vyc2Utc3VibW9kdWxlcyIKIAotIzogYnVpbHRpbi9ncmVwLmM6MTEyMworIzogYnVpbHRpbi9ncmVwLmM6MTEyNQogbXNnaWQgIi0tY2FjaGVkIG9yIC0tdW50cmFja2VkIGNhbm5vdCBiZSB1c2VkIHdpdGggLS1uby1pbmRleCIKIG1zZ3N0ciAiLS1jYWNoZWQgb3UgLS11bnRyYWNrZWQgbmUgcGV1dmVudCBwYXMgw6p0cmUgdXRpbGlzw6lzIGF2ZWMgLS1uby1pbmRleCIKIAotIzogYnVpbHRpbi9ncmVwLmM6MTEyOQorIzogYnVpbHRpbi9ncmVwLmM6MTEzMQogbXNnaWQgIi0tW25vLV1leGNsdWRlLXN0YW5kYXJkIGNhbm5vdCBiZSB1c2VkIGZvciB0cmFja2VkIGNvbnRlbnRzIgogbXNnc3RyICItLVtuby1dZXhjbHVkZS1zdGFuZGFyZCBuZSBwZXV0IHBhcyDDqnRyZSB1dGlsaXPDqSBhdmVjIGR1IGNvbnRlbnUgc3VpdmkiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjExMzcKKyM6IGJ1aWx0aW4vZ3JlcC5jOjExMzkKIG1zZ2lkICJib3RoIC0tY2FjaGVkIGFuZCB0cmVlcyBhcmUgZ2l2ZW4iCiBtc2dzdHIgIi0tY2FjaGVkIGV0IGRlcyBhcmJyZXMgc29udCBmb3VybmlzIGVuIG3Dqm1lIHRlbXBzIgogCkBAIC0xNDI2OCw3ICsxNDM1MSw3IEBACiBtc2dpZCAiUmVzb2x2aW5nIGRlbHRhcyIKIG1zZ3N0ciAiUsOpc29sdXRpb24gZGVzIGRlbHRhcyIKIAotIzogYnVpbHRpbi9pbmRleC1wYWNrLmM6MTIwNSBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI0OTcKKyM6IGJ1aWx0aW4vaW5kZXgtcGFjay5jOjEyMDUgYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNDgxCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBjcmVhdGUgdGhyZWFkOiAlcyIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkZSBjcsOpZXIgbGUgZmlsIDogJXMiCkBAIC0xNDMzNCw3ICsxNDQxNyw3IEBACiBtc2dpZCAiY2Fubm90IHN0b3JlIGluZGV4IGZpbGUiCiBtc2dzdHIgImltcG9zc2libGUgZGUgc3RvY2tlciBsZSBmaWNoaWVyIGQnaW5kZXgiCiAKLSM6IGJ1aWx0aW4vaW5kZXgtcGFjay5jOjE1MjUgYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNzM2CisjOiBidWlsdGluL2luZGV4LXBhY2suYzoxNTI1IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjcxNgogIywgYy1mb3JtYXQKIG1zZ2lkICJiYWQgcGFjay5pbmRleHZlcnNpb249JTxQUkl1MzI+IgogbXNnc3RyICJtYXV2YWlzIHBhY2suaW5kZXh2ZXJzaW9uPSU8UFJJdTMyPiIKQEAgLTE0NjE3LDc0ICsxNDcwMCw3NCBAQAogbXNnaWQgImdpdCBzaG93ICVzOiBiYWQgZmlsZSIKIG1zZ3N0ciAiZ2l0IHNob3cgJXMgOiBmaWNoaWVyIGluY29ycmVjdCIKIAotIzogYnVpbHRpbi9sb2cuYzo1NDkgYnVpbHRpbi9sb2cuYzo2NDMKKyM6IGJ1aWx0aW4vbG9nLmM6NTQ5IGJ1aWx0aW4vbG9nLmM6NjQ0CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCByZWFkIG9iamVjdCAlcyIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkZSBsaXJlIGwnb2JqZXQgJXMiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6NjY4CisjOiBidWlsdGluL2xvZy5jOjY2OQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmtub3duIHR5cGU6ICVkIgogbXNnc3RyICJ0eXBlIGluY29ubnUgOiAlZCIKIAotIzogYnVpbHRpbi9sb2cuYzo3OTEKKyM6IGJ1aWx0aW4vbG9nLmM6NzkyCiBtc2dpZCAiZm9ybWF0LmhlYWRlcnMgd2l0aG91dCB2YWx1ZSIKIG1zZ3N0ciAiZm9ybWF0LmhlYWRlcnMgc2FucyB2YWxldXIiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6OTA4CisjOiBidWlsdGluL2xvZy5jOjkwOQogbXNnaWQgIm5hbWUgb2Ygb3V0cHV0IGRpcmVjdG9yeSBpcyB0b28gbG9uZyIKIG1zZ3N0ciAibGUgbm9tIGR1IHLDqXBlcnRvaXJlIGRlIHNvcnRpZSBlc3QgdHJvcCBsb25nIgogCi0jOiBidWlsdGluL2xvZy5jOjkyNAorIzogYnVpbHRpbi9sb2cuYzo5MjUKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IG9wZW4gcGF0Y2ggZmlsZSAlcyIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkJ291dnJpciBsZSBmaWNoaWVyIGNvcnJlY3RpZiAlcyIKIAotIzogYnVpbHRpbi9sb2cuYzo5NDEKKyM6IGJ1aWx0aW4vbG9nLmM6OTQyCiBtc2dpZCAibmVlZCBleGFjdGx5IG9uZSByYW5nZSIKIG1zZ3N0ciAiZXhhY3RlbWVudCB1bmUgcGxhZ2UgbsOpY2Vzc2FpcmUiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6OTUxCisjOiBidWlsdGluL2xvZy5jOjk1MgogbXNnaWQgIm5vdCBhIHJhbmdlIgogbXNnc3RyICJjZWNpIG4nZXN0IHBhcyB1bmUgcGxhZ2UiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTA3NAorIzogYnVpbHRpbi9sb2cuYzoxMDc1CiBtc2dpZCAiY292ZXIgbGV0dGVyIG5lZWRzIGVtYWlsIGZvcm1hdCIKIG1zZ3N0ciAibGEgbGV0dHJlIGRlIG1vdGl2YXRpb24gZG9pdCDDqnRyZSBhdSBmb3JtYXQgY291cnJpZWwiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTA4MAorIzogYnVpbHRpbi9sb2cuYzoxMDgxCiBtc2dpZCAiZmFpbGVkIHRvIGNyZWF0ZSBjb3Zlci1sZXR0ZXIgZmlsZSIKIG1zZ3N0ciAiw6ljaGVjIGRlIGNyw6lhdGlvbiBkdSBmaWNoaWVyIGRlIGxldHRyZSBkZSBtb3RpdmF0aW9uIgogCi0jOiBidWlsdGluL2xvZy5jOjExNTkKKyM6IGJ1aWx0aW4vbG9nLmM6MTE2MAogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnNhbmUgaW4tcmVwbHktdG86ICVzIgogbXNnc3RyICJpbi1yZXBseS10byBhYmVycmFudCA6ICVzIgogCi0jOiBidWlsdGluL2xvZy5jOjExODYKKyM6IGJ1aWx0aW4vbG9nLmM6MTE4NwogbXNnaWQgImdpdCBmb3JtYXQtcGF0Y2ggWzxvcHRpb25zPl0gWzxzaW5jZT4gfCA8cmV2aXNpb24tcmFuZ2U+XSIKIG1zZ3N0ciAiZ2l0IGZvcm1hdC1wYXRjaCBbPG9wdGlvbnM+XSBbPGRlcHVpcz4gfCA8cGxhZ2UgZGUgcsOpdmlzaW9ucz5dIgogCi0jOiBidWlsdGluL2xvZy5jOjEyNDQKKyM6IGJ1aWx0aW4vbG9nLmM6MTI0NQogbXNnaWQgInR3byBvdXRwdXQgZGlyZWN0b3JpZXM/IgogbXNnc3RyICJkZXV4IHLDqXBlcnRvaXJlcyBkZSBzb3J0aWXCoD8iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTM1NSBidWlsdGluL2xvZy5jOjIwOTkgYnVpbHRpbi9sb2cuYzoyMTAxIGJ1aWx0aW4vbG9nLmM6MjExMworIzogYnVpbHRpbi9sb2cuYzoxMzU2IGJ1aWx0aW4vbG9nLmM6MjExNiBidWlsdGluL2xvZy5jOjIxMTggYnVpbHRpbi9sb2cuYzoyMTMwCiAjLCBjLWZvcm1hdAogbXNnaWQgInVua25vd24gY29tbWl0ICVzIgogbXNnc3RyICJjb21taXQgaW5jb25udSAlcyIKIAotIzogYnVpbHRpbi9sb2cuYzoxMzY1IGJ1aWx0aW4vcmVwbGFjZS5jOjU4IGJ1aWx0aW4vcmVwbGFjZS5jOjIwNworIzogYnVpbHRpbi9sb2cuYzoxMzY2IGJ1aWx0aW4vcmVwbGFjZS5jOjU4IGJ1aWx0aW4vcmVwbGFjZS5jOjIwNwogIzogYnVpbHRpbi9yZXBsYWNlLmM6MjEwCiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byByZXNvbHZlICclcycgYXMgYSB2YWxpZCByZWYiCiBtc2dzdHIgIsOpY2hlYyDDoCByw6lzb3VkcmUgJyVzJyBjb21tZSB1bmUgcsOpZsOpcmVuY2UgdmFsaWRlIgogCi0jOiBidWlsdGluL2xvZy5jOjEzNzAKKyM6IGJ1aWx0aW4vbG9nLmM6MTM3MQogbXNnaWQgImNvdWxkIG5vdCBmaW5kIGV4YWN0IG1lcmdlIGJhc2UiCiBtc2dzdHIgImltcG9zc2libGUgZGUgdHJvdXZlciBsYSBiYXNlIGRlIGZ1c2lvbiBleGFjdGUiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTM3NAorIzogYnVpbHRpbi9sb2cuYzoxMzc1CiBtc2dpZCAiIgogImZhaWxlZCB0byBnZXQgdXBzdHJlYW0sIGlmIHlvdSB3YW50IHRvIHJlY29yZCBiYXNlIGNvbW1pdCBhdXRvbWF0aWNhbGx5LFxuIgogInBsZWFzZSB1c2UgZ2l0IGJyYW5jaCAtLXNldC11cHN0cmVhbS10byB0byB0cmFjayBhIHJlbW90ZSBicmFuY2guXG4iCkBAIC0xNDY5NywyNzUgKzE0NzgwLDI3NSBAQAogIk91IHZvdXMgcG91dmV6IHNww6ljaWZpZXIgbGUgY29tbWl0IGRlIGJhc2UgcGFyIC0tYmFzZT08aWQtZHUtY29tbWl0LWRlLWJhc2U+ICIKICJtYW51ZWxsZW1lbnQiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTM5NAorIzogYnVpbHRpbi9sb2cuYzoxMzk1CiBtc2dpZCAiZmFpbGVkIHRvIGZpbmQgZXhhY3QgbWVyZ2UgYmFzZSIKIG1zZ3N0ciAiw6ljaGVjIMOgIHRyb3V2ZXIgbGEgYmFzZSBkZSBmdXNpb24gZXhhY3RlIgogCi0jOiBidWlsdGluL2xvZy5jOjE0MDUKKyM6IGJ1aWx0aW4vbG9nLmM6MTQwNgogbXNnaWQgImJhc2UgY29tbWl0IHNob3VsZCBiZSB0aGUgYW5jZXN0b3Igb2YgcmV2aXNpb24gbGlzdCIKIG1zZ3N0ciAibGUgY29tbWl0IGRlIGJhc2UgZGV2cmFpdCDDqnRyZSBsJ2FuY8OqdHJlIGRlIGxhIGxpc3RlIGRlIHLDqXZpc2lvbnMiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTQwOQorIzogYnVpbHRpbi9sb2cuYzoxNDEwCiBtc2dpZCAiYmFzZSBjb21taXQgc2hvdWxkbid0IGJlIGluIHJldmlzaW9uIGxpc3QiCiBtc2dzdHIgImxlIGNvbW1pdCBkZSBiYXNlIG5lIGRldnJhaXQgcGFzIGZhaXJlIHBhcnRpZSBkZSBsYSBsaXN0ZSBkZSByw6l2aXNpb25zIgogCi0jOiBidWlsdGluL2xvZy5jOjE0NjIKKyM6IGJ1aWx0aW4vbG9nLmM6MTQ2MwogbXNnaWQgImNhbm5vdCBnZXQgcGF0Y2ggaWQiCiBtc2dzdHIgImltcG9zc2libGUgZCdvYnRlbmlyIGwnaWQgZHUgcGF0Y2giCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTUxNAorIzogYnVpbHRpbi9sb2cuYzoxNTE1CiBtc2dpZCAiZmFpbGVkIHRvIGluZmVyIHJhbmdlLWRpZmYgcmFuZ2VzIgogbXNnc3RyICLDqWNoZWMgZCdpbmbDqXJlbmNlIGQnaW50ZXJ2YWxsZXMgZGUgZGlmZsOpcmVuY2UgZCdpbnRlcnZhbGxlcyIKIAotIzogYnVpbHRpbi9sb2cuYzoxNTU5CisjOiBidWlsdGluL2xvZy5jOjE1NjAKIG1zZ2lkICJ1c2UgW1BBVENIIG4vbV0gZXZlbiB3aXRoIGEgc2luZ2xlIHBhdGNoIgogbXNnc3RyICJ1dGlsaXNlciBbUEFUQ0ggbi9tXSBtw6ptZSBhdmVjIHVuIHBhdGNoIHVuaXF1ZSIKIAotIzogYnVpbHRpbi9sb2cuYzoxNTYyCisjOiBidWlsdGluL2xvZy5jOjE1NjMKIG1zZ2lkICJ1c2UgW1BBVENIXSBldmVuIHdpdGggbXVsdGlwbGUgcGF0Y2hlcyIKIG1zZ3N0ciAidXRpbGlzZXIgW1BBVENIXSBtw6ptZSBhdmVjIGRlcyBwYXRjaHMgbXVsdGlwbGVzIgogCi0jOiBidWlsdGluL2xvZy5jOjE1NjYKKyM6IGJ1aWx0aW4vbG9nLmM6MTU2NwogbXNnaWQgInByaW50IHBhdGNoZXMgdG8gc3RhbmRhcmQgb3V0IgogbXNnc3RyICJhZmZpY2hlciBsZXMgcGF0Y2hzIHN1ciBsYSBzb3J0aWUgc3RhbmRhcmQiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTU2OAorIzogYnVpbHRpbi9sb2cuYzoxNTY5CiBtc2dpZCAiZ2VuZXJhdGUgYSBjb3ZlciBsZXR0ZXIiCiBtc2dzdHIgImfDqW7DqXJlciB1bmUgbGV0dHJlIGRlIG1vdGl2YXRpb24iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTU3MAorIzogYnVpbHRpbi9sb2cuYzoxNTcxCiBtc2dpZCAidXNlIHNpbXBsZSBudW1iZXIgc2VxdWVuY2UgZm9yIG91dHB1dCBmaWxlIG5hbWVzIgogbXNnc3RyICIiCiAidXRpbGlzZXIgdW5lIHPDqXF1ZW5jZSBzaW1wbGUgZGUgbm9tYnJlcyBwb3VyIGxlcyBub20gZGVzIGZpY2hpZXJzIGRlIHNvcnRpZSIKIAotIzogYnVpbHRpbi9sb2cuYzoxNTcxCisjOiBidWlsdGluL2xvZy5jOjE1NzIKIG1zZ2lkICJzZngiCiBtc2dzdHIgInNmeCIKIAotIzogYnVpbHRpbi9sb2cuYzoxNTcyCisjOiBidWlsdGluL2xvZy5jOjE1NzMKIG1zZ2lkICJ1c2UgPHNmeD4gaW5zdGVhZCBvZiAnLnBhdGNoJyIKIG1zZ3N0ciAidXRpbGlzZXIgPHNmeD4gYXUgbGlldSBkZSAnLnBhdGNoJyIKIAotIzogYnVpbHRpbi9sb2cuYzoxNTc0CisjOiBidWlsdGluL2xvZy5jOjE1NzUKIG1zZ2lkICJzdGFydCBudW1iZXJpbmcgcGF0Y2hlcyBhdCA8bj4gaW5zdGVhZCBvZiAxIgogbXNnc3RyICJkw6ltYXJyZXIgbGEgbnVtw6lyb3RhdGlvbiBkZXMgcGF0Y2hzIMOgIDxuPiBhdSBsaWV1IGRlIDEiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTU3NgorIzogYnVpbHRpbi9sb2cuYzoxNTc3CiBtc2dpZCAibWFyayB0aGUgc2VyaWVzIGFzIE50aCByZS1yb2xsIgogbXNnc3RyICJtYXJxdWVyIGxhIHPDqXJpZSBjb21tZSB1bmUgTmnDqG1lIHLDqcOpZGl0aW9uIgogCi0jOiBidWlsdGluL2xvZy5jOjE1NzgKKyM6IGJ1aWx0aW4vbG9nLmM6MTU3OQogbXNnaWQgIlVzZSBbUkZDIFBBVENIXSBpbnN0ZWFkIG9mIFtQQVRDSF0iCiBtc2dzdHIgInV0aWxpc2VyIFtSRkMgUEFUQ0hdIGF1IGxpZXUgZGUgW1BBVENIXSIKIAotIzogYnVpbHRpbi9sb2cuYzoxNTgxCisjOiBidWlsdGluL2xvZy5jOjE1ODIKIG1zZ2lkICJVc2UgWzxwcmVmaXg+XSBpbnN0ZWFkIG9mIFtQQVRDSF0iCiBtc2dzdHIgInV0aWxpc2VyIFs8cHLDqWZpeGU+XSBhdSBsaWV1IGRlIFtQQVRDSF0iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTU4NAorIzogYnVpbHRpbi9sb2cuYzoxNTg1CiBtc2dpZCAic3RvcmUgcmVzdWx0aW5nIGZpbGVzIGluIDxkaXI+IgogbXNnc3RyICJzdG9ja2VyIGxlcyBmaWNoaWVycyByw6lzdWx0YXRzIGRhbnMgPHLDqXBlcnRvaXJlPiIKIAotIzogYnVpbHRpbi9sb2cuYzoxNTg3CisjOiBidWlsdGluL2xvZy5jOjE1ODgKIG1zZ2lkICJkb24ndCBzdHJpcC9hZGQgW1BBVENIXSIKIG1zZ3N0ciAibmUgcGFzIHJldGlyZXIvYWpvdXRlciBbUEFUQ0hdIgogCi0jOiBidWlsdGluL2xvZy5jOjE1OTAKKyM6IGJ1aWx0aW4vbG9nLmM6MTU5MQogbXNnaWQgImRvbid0IG91dHB1dCBiaW5hcnkgZGlmZnMiCiBtc2dzdHIgIm5lIHBhcyBpbXByaW1lciBsZXMgZGlmZnMgYmluYWlyZXMiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTU5MgorIzogYnVpbHRpbi9sb2cuYzoxNTkzCiBtc2dpZCAib3V0cHV0IGFsbC16ZXJvIGhhc2ggaW4gRnJvbSBoZWFkZXIiCiBtc2dzdHIgIsOpY3JpcmUgdW5lIGVtcHJlaW50ZSDDoCB6w6lybyBkYW5zIGwnZW50w6p0ZSBGcm9tIgogCi0jOiBidWlsdGluL2xvZy5jOjE1OTQKKyM6IGJ1aWx0aW4vbG9nLmM6MTU5NQogbXNnaWQgImRvbid0IGluY2x1ZGUgYSBwYXRjaCBtYXRjaGluZyBhIGNvbW1pdCB1cHN0cmVhbSIKIG1zZ3N0ciAibmUgcGFzIGluY2x1cmUgdW4gcGF0Y2ggY29ycmVzcG9uZGFudCDDoCB1biBjb21taXQgYW1vbnQiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTU5NgorIzogYnVpbHRpbi9sb2cuYzoxNTk3CiBtc2dpZCAic2hvdyBwYXRjaCBmb3JtYXQgaW5zdGVhZCBvZiBkZWZhdWx0IChwYXRjaCArIHN0YXQpIgogbXNnc3RyICJhZmZpY2hlciBsZSBmb3JtYXQgZHUgcGF0Y2ggYXUgbGlldSBkdSBkw6lmYXV0IChwYXRjaCArIHN0YXQpIgogCi0jOiBidWlsdGluL2xvZy5jOjE1OTgKKyM6IGJ1aWx0aW4vbG9nLmM6MTU5OQogbXNnaWQgIk1lc3NhZ2luZyIKIG1zZ3N0ciAiQ29tbXVuaWNhdGlvbiIKIAotIzogYnVpbHRpbi9sb2cuYzoxNTk5CisjOiBidWlsdGluL2xvZy5jOjE2MDAKIG1zZ2lkICJoZWFkZXIiCiBtc2dzdHIgImVuLXTDqnRlIgogCi0jOiBidWlsdGluL2xvZy5jOjE2MDAKKyM6IGJ1aWx0aW4vbG9nLmM6MTYwMQogbXNnaWQgImFkZCBlbWFpbCBoZWFkZXIiCiBtc2dzdHIgImFqb3V0ZXIgbCdlbi10w6p0ZSBkZSBjb3VycmllbCIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjAxIGJ1aWx0aW4vbG9nLmM6MTYwMworIzogYnVpbHRpbi9sb2cuYzoxNjAyIGJ1aWx0aW4vbG9nLmM6MTYwNAogbXNnaWQgImVtYWlsIgogbXNnc3RyICJjb3VycmllbCIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjAxCisjOiBidWlsdGluL2xvZy5jOjE2MDIKIG1zZ2lkICJhZGQgVG86IGhlYWRlciIKIG1zZ3N0ciAiYWpvdXRlciBsJ2VuLXTDqnRlIFwiVG86XCIiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTYwMworIzogYnVpbHRpbi9sb2cuYzoxNjA0CiBtc2dpZCAiYWRkIENjOiBoZWFkZXIiCiBtc2dzdHIgImFqb3V0ZXIgbCdlbi10w6p0ZSBcIkNjOlwiIgogCi0jOiBidWlsdGluL2xvZy5jOjE2MDUKKyM6IGJ1aWx0aW4vbG9nLmM6MTYwNgogbXNnaWQgImlkZW50IgogbXNnc3RyICJpZGVudCIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjA2CisjOiBidWlsdGluL2xvZy5jOjE2MDcKIG1zZ2lkICJzZXQgRnJvbSBhZGRyZXNzIHRvIDxpZGVudD4gKG9yIGNvbW1pdHRlciBpZGVudCBpZiBhYnNlbnQpIgogbXNnc3RyICIiCiAicmVuc2VpZ25lciBsJ2FkcmVzc2UgRnJvbSDDoCA8aWRlbnQ+IChvdSDDoCBsJ2lkZW50IGR1IHZhbGlkYXRldXIgc2kgYWJzZW50KSIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjA4CisjOiBidWlsdGluL2xvZy5jOjE2MDkKIG1zZ2lkICJtZXNzYWdlLWlkIgogbXNnc3RyICJpZC1tZXNzYWdlIgogCi0jOiBidWlsdGluL2xvZy5jOjE2MDkKKyM6IGJ1aWx0aW4vbG9nLmM6MTYxMAogbXNnaWQgIm1ha2UgZmlyc3QgbWFpbCBhIHJlcGx5IHRvIDxtZXNzYWdlLWlkPiIKIG1zZ3N0ciAicsOpcG9uZHJlIGRhbnMgbGUgcHJlbWllciBtZXNzYWdlIMOgIDxpZC1tZXNzYWdlPiIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjEwIGJ1aWx0aW4vbG9nLmM6MTYxMworIzogYnVpbHRpbi9sb2cuYzoxNjExIGJ1aWx0aW4vbG9nLmM6MTYxNAogbXNnaWQgImJvdW5kYXJ5IgogbXNnc3RyICJsaW1pdGUiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTYxMQorIzogYnVpbHRpbi9sb2cuYzoxNjEyCiBtc2dpZCAiYXR0YWNoIHRoZSBwYXRjaCIKIG1zZ3N0ciAiYXR0YWNoZXIgbGUgcGF0Y2giCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTYxNAorIzogYnVpbHRpbi9sb2cuYzoxNjE1CiBtc2dpZCAiaW5saW5lIHRoZSBwYXRjaCIKIG1zZ3N0ciAicGF0Y2ggw6AgbCdpbnTDqXJpZXVyIgogCi0jOiBidWlsdGluL2xvZy5jOjE2MTgKKyM6IGJ1aWx0aW4vbG9nLmM6MTYxOQogbXNnaWQgImVuYWJsZSBtZXNzYWdlIHRocmVhZGluZywgc3R5bGVzOiBzaGFsbG93LCBkZWVwIgogbXNnc3RyICIiCiAiYWN0aXZlciBsJ2VuZmlsYWdlIGRlIG1lc3NhZ2UsIHN0eWxlcyA6IHNoYWxsb3cgKHN1cGVyZmljaWVsKSwgZGVlcCAocHJvZm9uZCkiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTYyMAorIzogYnVpbHRpbi9sb2cuYzoxNjIxCiBtc2dpZCAic2lnbmF0dXJlIgogbXNnc3RyICJzaWduYXR1cmUiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTYyMQorIzogYnVpbHRpbi9sb2cuYzoxNjIyCiBtc2dpZCAiYWRkIGEgc2lnbmF0dXJlIgogbXNnc3RyICJham91dGVyIHVuZSBzaWduYXR1cmUiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTYyMgorIzogYnVpbHRpbi9sb2cuYzoxNjIzCiBtc2dpZCAiYmFzZS1jb21taXQiCiBtc2dzdHIgImNvbW1pdC1kZS1iYXNlIgogCi0jOiBidWlsdGluL2xvZy5jOjE2MjMKKyM6IGJ1aWx0aW4vbG9nLmM6MTYyNAogbXNnaWQgImFkZCBwcmVyZXF1aXNpdGUgdHJlZSBpbmZvIHRvIHRoZSBwYXRjaCBzZXJpZXMiCiBtc2dzdHIgIkFqb3V0ZXIgdW4gYXJicmUgcHLDqXJlcXVpcyDDoCBsYSBzw6lyaWUgZGUgcGF0Y2hzIgogCi0jOiBidWlsdGluL2xvZy5jOjE2MjUKKyM6IGJ1aWx0aW4vbG9nLmM6MTYyNgogbXNnaWQgImFkZCBhIHNpZ25hdHVyZSBmcm9tIGEgZmlsZSIKIG1zZ3N0ciAiYWpvdXRlciB1bmUgc2lnbmF0dXJlIGRlcHVpcyB1biBmaWNoaWVyIgogCi0jOiBidWlsdGluL2xvZy5jOjE2MjYKKyM6IGJ1aWx0aW4vbG9nLmM6MTYyNwogbXNnaWQgImRvbid0IHByaW50IHRoZSBwYXRjaCBmaWxlbmFtZXMiCiBtc2dzdHIgIm5lIHBhcyBhZmZpY2hlciBsZXMgbm9tcyBkZSBmaWNoaWVycyBkZXMgcGF0Y2hzIgogCi0jOiBidWlsdGluL2xvZy5jOjE2MjgKKyM6IGJ1aWx0aW4vbG9nLmM6MTYyOQogbXNnaWQgInNob3cgcHJvZ3Jlc3Mgd2hpbGUgZ2VuZXJhdGluZyBwYXRjaGVzIgogbXNnc3RyICIiCiAiYWZmaWNoZXIgbGEgYmFycmUgZGUgcHJvZ3Jlc3Npb24gZHVyYW50IGxhIHBoYXNlIGRlIGfDqW7DqXJhdGlvbiBkZXMgcGF0Y2hzIgogCi0jOiBidWlsdGluL2xvZy5jOjE2MzAKKyM6IGJ1aWx0aW4vbG9nLmM6MTYzMQogbXNnaWQgInNob3cgY2hhbmdlcyBhZ2FpbnN0IDxyZXY+IGluIGNvdmVyIGxldHRlciBvciBzaW5nbGUgcGF0Y2giCiBtc2dzdHIgIiIKICJhZmZpY2hlciBsZXMgbW9kaWZpY2F0aW9ucyBwYXIgcmFwcG9ydCDDoCA8csOpdj4gZGFucyBsYSBwcmVtacOocmUgcGFnZSBvdSB1bmUgIgogInJ1c3RpbmUiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTYzMworIzogYnVpbHRpbi9sb2cuYzoxNjM0CiBtc2dpZCAic2hvdyBjaGFuZ2VzIGFnYWluc3QgPHJlZnNwZWM+IGluIGNvdmVyIGxldHRlciBvciBzaW5nbGUgcGF0Y2giCiBtc2dzdHIgIiIKICJhZmZpY2hlciBsZXMgbW9kaWZpY2F0aW9ucyBwYXIgcmFwcG9ydCDDoCA8cmVmc3BlYz4gZGFucyBsYSBwcmVtacOocmUgcGFnZSBvdSAiCiAidW5lIHJ1c3RpbmUiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTYzNQorIzogYnVpbHRpbi9sb2cuYzoxNjM2CiBtc2dpZCAicGVyY2VudGFnZSBieSB3aGljaCBjcmVhdGlvbiBpcyB3ZWlnaHRlZCIKIG1zZ3N0ciAicG91cmNlbnRhZ2UgcGFyIGxlcXVlbCBsYSBjcsOpYXRpb24gZXN0IHBvbmTDqXLDqWUiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTcxMAorIzogYnVpbHRpbi9sb2cuYzoxNzExCiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgaWRlbnQgbGluZTogJXMiCiBtc2dzdHIgImxpZ25lIGQnaWRlbnRpZmljYXRpb24gaW52YWxpZGUgOiAlcyIKIAotIzogYnVpbHRpbi9sb2cuYzoxNzI1CisjOiBidWlsdGluL2xvZy5jOjE3MjYKIG1zZ2lkICItbiBhbmQgLWsgYXJlIG11dHVhbGx5IGV4Y2x1c2l2ZSIKIG1zZ3N0ciAiLW4gZXQgLWsgc29udCBtdXR1ZWxsZW1lbnQgZXhjbHVzaWZzIgogCi0jOiBidWlsdGluL2xvZy5jOjE3MjcKKyM6IGJ1aWx0aW4vbG9nLmM6MTcyOAogbXNnaWQgIi0tc3ViamVjdC1wcmVmaXgvLS1yZmMgYW5kIC1rIGFyZSBtdXR1YWxseSBleGNsdXNpdmUiCiBtc2dzdHIgIi0tc3ViamVjdC1wcmVmaXgvLS1yZmMgZXQgLWsgc29udCBtdXR1ZWxsZW1lbnQgZXhjbHVzaWZzIgogCi0jOiBidWlsdGluL2xvZy5jOjE3MzUKKyM6IGJ1aWx0aW4vbG9nLmM6MTczNgogbXNnaWQgIi0tbmFtZS1vbmx5IGRvZXMgbm90IG1ha2Ugc2Vuc2UiCiBtc2dzdHIgIi0tbmFtZS1vbmx5IG4nYSBwYXMgZGUgc2VucyIKIAotIzogYnVpbHRpbi9sb2cuYzoxNzM3CisjOiBidWlsdGluL2xvZy5jOjE3MzgKIG1zZ2lkICItLW5hbWUtc3RhdHVzIGRvZXMgbm90IG1ha2Ugc2Vuc2UiCiBtc2dzdHIgIi0tbmFtZS1zdGF0dXMgbidhIHBhcyBkZSBzZW5zIgogCi0jOiBidWlsdGluL2xvZy5jOjE3MzkKKyM6IGJ1aWx0aW4vbG9nLmM6MTc0MAogbXNnaWQgIi0tY2hlY2sgZG9lcyBub3QgbWFrZSBzZW5zZSIKIG1zZ3N0ciAiLS1jaGVjayBuJ2EgcGFzIGRlIHNlbnMiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTc3MQorIzogYnVpbHRpbi9sb2cuYzoxNzczCiBtc2dpZCAic3RhbmRhcmQgb3V0cHV0LCBvciBkaXJlY3RvcnksIHdoaWNoIG9uZT8iCiBtc2dzdHIgInNvcnRpZSBzdGFuZGFyZCwgb3UgcsOpcGVydG9pcmUsIGxlcXVlbCA/IgogCi0jOiBidWlsdGluL2xvZy5jOjE4NjAKKyM6IGJ1aWx0aW4vbG9nLmM6MTg3NwogbXNnaWQgIi0taW50ZXJkaWZmIHJlcXVpcmVzIC0tY292ZXItbGV0dGVyIG9yIHNpbmdsZSBwYXRjaCIKIG1zZ3N0ciAiLS1pbnRlcmRpZmYgcmVxdWllcnQgLS1jb3Zlci1sZXR0ZXIgb3UgdW5lIHJ1c3RpbmUgdW5pcXVlIgogCi0jOiBidWlsdGluL2xvZy5jOjE4NjQKKyM6IGJ1aWx0aW4vbG9nLmM6MTg4MQogbXNnaWQgIkludGVyZGlmZjoiCiBtc2dzdHIgIkludGVyZGlmZsKgOiIKIAotIzogYnVpbHRpbi9sb2cuYzoxODY1CisjOiBidWlsdGluL2xvZy5jOjE4ODIKICMsIGMtZm9ybWF0CiBtc2dpZCAiSW50ZXJkaWZmIGFnYWluc3QgdiVkOiIKIG1zZ3N0ciAiSW50ZXJkaWZmIGNvbnRyZSB2JWTCoDoiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTg3MQorIzogYnVpbHRpbi9sb2cuYzoxODg4CiBtc2dpZCAiLS1jcmVhdGlvbi1mYWN0b3IgcmVxdWlyZXMgLS1yYW5nZS1kaWZmIgogbXNnc3RyICItLWNyZWF0aW9uLWZhY3RvciByZXF1aWVydCAtLXJhbmdlLWRpZmYiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTg3NQorIzogYnVpbHRpbi9sb2cuYzoxODkyCiBtc2dpZCAiLS1yYW5nZS1kaWZmIHJlcXVpcmVzIC0tY292ZXItbGV0dGVyIG9yIHNpbmdsZSBwYXRjaCIKIG1zZ3N0ciAiLS1yYW5nZS1kaWZmIHJlcXVpZXJ0IC0tY292ZXItbGV0dGVyIG91IHVuZSBydXN0aW5lIHVuaXF1ZSIKIAotIzogYnVpbHRpbi9sb2cuYzoxODgzCisjOiBidWlsdGluL2xvZy5jOjE5MDAKIG1zZ2lkICJSYW5nZS1kaWZmOiIKIG1zZ3N0ciAiRGlmZi1pbnRlcnZhbGxlwqA6IgogCi0jOiBidWlsdGluL2xvZy5jOjE4ODQKKyM6IGJ1aWx0aW4vbG9nLmM6MTkwMQogIywgYy1mb3JtYXQKIG1zZ2lkICJSYW5nZS1kaWZmIGFnYWluc3QgdiVkOiIKIG1zZ3N0ciAiRGlmZi1pbnRlcnZhbGxlIGNvbnRyZSB2JWTCoDoiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTg5NQorIzogYnVpbHRpbi9sb2cuYzoxOTEyCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byByZWFkIHNpZ25hdHVyZSBmaWxlICclcyciCiBtc2dzdHIgImxlY3R1cmUgZHUgZmljaGllciBkZSBzaWduYXR1cmUgJyVzJyBpbXBvc3NpYmxlIgogCi0jOiBidWlsdGluL2xvZy5jOjE5MzEKKyM6IGJ1aWx0aW4vbG9nLmM6MTk0OAogbXNnaWQgIkdlbmVyYXRpbmcgcGF0Y2hlcyIKIG1zZ3N0ciAiR8OpbsOpcmF0aW9uIGRlcyBwYXRjaHMiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTk3NQorIzogYnVpbHRpbi9sb2cuYzoxOTkyCiBtc2dpZCAiZmFpbGVkIHRvIGNyZWF0ZSBvdXRwdXQgZmlsZXMiCiBtc2dzdHIgIsOpY2hlYyBkZSBjcsOpYXRpb24gZGVzIGZpY2hpZXJzIGVuIHNvcnRpZSIKIAotIzogYnVpbHRpbi9sb2cuYzoyMDM0CisjOiBidWlsdGluL2xvZy5jOjIwNTEKIG1zZ2lkICJnaXQgY2hlcnJ5IFstdl0gWzx1cHN0cmVhbT4gWzxoZWFkPiBbPGxpbWl0Pl1dXSIKIG1zZ3N0ciAiZ2l0IGNoZXJyeSBbLXZdIFs8YnJhbmNoZV9hbW9udD4gWzxoZWFkPiBbPGxpbWl0ZT5dXV0iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MjA4OAorIzogYnVpbHRpbi9sb2cuYzoyMTA1CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJDb3VsZCBub3QgZmluZCBhIHRyYWNrZWQgcmVtb3RlIGJyYW5jaCwgcGxlYXNlIHNwZWNpZnkgPHVwc3RyZWFtPiBtYW51YWxseS5cbiIKQEAgLTE1MDk0LDcgKzE1MTc3LDcgQEAKIG1zZ2lkICJkbyBub3QgcHJpbnQgcmVtb3RlIFVSTCIKIG1zZ3N0ciAibmUgcGFzIGFmZmljaGVyIGxlcyBVUkwgZGlzdGFudGVzIgogCi0jOiBidWlsdGluL2xzLXJlbW90ZS5jOjYwIGJ1aWx0aW4vbHMtcmVtb3RlLmM6NjIgYnVpbHRpbi9yZWJhc2UuYzoxNDY0CisjOiBidWlsdGluL2xzLXJlbW90ZS5jOjYwIGJ1aWx0aW4vbHMtcmVtb3RlLmM6NjIgYnVpbHRpbi9yZWJhc2UuYzoxNDg4CiBtc2dpZCAiZXhlYyIKIG1zZ3N0ciAiZXjDqWN1dGFibGUiCiAKQEAgLTE1MjA3LDMzICsxNTI5MCwzMyBAQAogbXNnaWQgIkF2YWlsYWJsZSBjdXN0b20gc3RyYXRlZ2llcyBhcmU6IgogbXNnc3RyICJMZXMgc3RyYXTDqWdpZXMgcGVyc29ubmFsaXPDqWVzIHNvbnQgOiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjI0NCBidWlsdGluL3B1bGwuYzoxNTEKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoyNDQgYnVpbHRpbi9wdWxsLmM6MTUyCiBtc2dpZCAiZG8gbm90IHNob3cgYSBkaWZmc3RhdCBhdCB0aGUgZW5kIG9mIHRoZSBtZXJnZSIKIG1zZ3N0ciAibmUgcGFzIGFmZmljaGVyIHVuIGRpZmZzdGF0IMOgIGxhIGZpbiBkZSBsYSBmdXNpb24iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoyNDcgYnVpbHRpbi9wdWxsLmM6MTU0CisjOiBidWlsdGluL21lcmdlLmM6MjQ3IGJ1aWx0aW4vcHVsbC5jOjE1NQogbXNnaWQgInNob3cgYSBkaWZmc3RhdCBhdCB0aGUgZW5kIG9mIHRoZSBtZXJnZSIKIG1zZ3N0ciAiYWZmaWNoZXIgdW4gZGlmZnN0YXQgw6AgbGEgZmluIGRlIGxhIGZ1c2lvbiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjI0OCBidWlsdGluL3B1bGwuYzoxNTcKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoyNDggYnVpbHRpbi9wdWxsLmM6MTU4CiBtc2dpZCAiKHN5bm9ueW0gdG8gLS1zdGF0KSIKIG1zZ3N0ciAiKHN5bm9ueW1lIGRlIC0tc3RhdCkiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoyNTAgYnVpbHRpbi9wdWxsLmM6MTYwCisjOiBidWlsdGluL21lcmdlLmM6MjUwIGJ1aWx0aW4vcHVsbC5jOjE2MQogbXNnaWQgImFkZCAoYXQgbW9zdCA8bj4pIGVudHJpZXMgZnJvbSBzaG9ydGxvZyB0byBtZXJnZSBjb21taXQgbWVzc2FnZSIKIG1zZ3N0ciAiIgogImFqb3V0ZXIgKGF1IHBsdXMgPG4+KSDDqWzDqW1lbnRzIGR1IGpvdXJuYWwgY291cnQgYXUgbWVzc2FnZSBkZSB2YWxpZGF0aW9uIGRlICIKICJsYSBmdXNpb24iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoyNTMgYnVpbHRpbi9wdWxsLmM6MTY2CisjOiBidWlsdGluL21lcmdlLmM6MjUzIGJ1aWx0aW4vcHVsbC5jOjE2NwogbXNnaWQgImNyZWF0ZSBhIHNpbmdsZSBjb21taXQgaW5zdGVhZCBvZiBkb2luZyBhIG1lcmdlIgogbXNnc3RyICJjcsOpZXIgdW5lIHZhbGlkYXRpb24gdW5pcXVlIGF1IGxpZXUgZGUgZmFpcmUgdW5lIGZ1c2lvbiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjI1NSBidWlsdGluL3B1bGwuYzoxNjkKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoyNTUgYnVpbHRpbi9wdWxsLmM6MTcwCiBtc2dpZCAicGVyZm9ybSBhIGNvbW1pdCBpZiB0aGUgbWVyZ2Ugc3VjY2VlZHMgKGRlZmF1bHQpIgogbXNnc3RyICJlZmZlY3R1ZXIgdW5lIHZhbGlkYXRpb24gc2kgbGEgZnVzaW9uIHLDqXVzc2l0IChkw6lmYXV0KSIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjI1NyBidWlsdGluL3B1bGwuYzoxNzIKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoyNTcgYnVpbHRpbi9wdWxsLmM6MTczCiBtc2dpZCAiZWRpdCBtZXNzYWdlIGJlZm9yZSBjb21taXR0aW5nIgogbXNnc3RyICLDqWRpdGVyIGxlIG1lc3NhZ2UgYXZhbnQgbGEgdmFsaWRhdGlvbiIKIApAQCAtMTUyNDEsMjggKzE1MzI0LDI4IEBACiBtc2dpZCAiYWxsb3cgZmFzdC1mb3J3YXJkIChkZWZhdWx0KSIKIG1zZ3N0ciAiYXV0b3Jpc2VyIGwnYXZhbmNlIHJhcGlkZSAoZMOpZmF1dCkiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoyNjEgYnVpbHRpbi9wdWxsLmM6MTc5CisjOiBidWlsdGluL21lcmdlLmM6MjYxIGJ1aWx0aW4vcHVsbC5jOjE4MAogbXNnaWQgImFib3J0IGlmIGZhc3QtZm9yd2FyZCBpcyBub3QgcG9zc2libGUiCiBtc2dzdHIgImFiYW5kb25uZXIgc2kgbCdhdmFuY2UgcmFwaWRlIG4nZXN0IHBhcyBwb3NzaWJsZSIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjI2NSBidWlsdGluL3B1bGwuYzoxODIKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoyNjUgYnVpbHRpbi9wdWxsLmM6MTgzCiBtc2dpZCAidmVyaWZ5IHRoYXQgdGhlIG5hbWVkIGNvbW1pdCBoYXMgYSB2YWxpZCBHUEcgc2lnbmF0dXJlIgogbXNnc3RyICJ2w6lyaWZpZXIgcXVlIGxlIGNvbW1pdCBub21tw6kgYSB1bmUgc2lnbmF0dXJlIEdQRyB2YWxpZGUiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoyNjYgYnVpbHRpbi9ub3Rlcy5jOjc4NyBidWlsdGluL3B1bGwuYzoxODYKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDkyIGJ1aWx0aW4vcmViYXNlLmM6MTQ3NyBidWlsdGluL3JldmVydC5jOjExNAorIzogYnVpbHRpbi9tZXJnZS5jOjI2NiBidWlsdGluL25vdGVzLmM6Nzg3IGJ1aWx0aW4vcHVsbC5jOjE4NworIzogYnVpbHRpbi9yZWJhc2UuYzo0OTMgYnVpbHRpbi9yZWJhc2UuYzoxNTAxIGJ1aWx0aW4vcmV2ZXJ0LmM6MTE0CiBtc2dpZCAic3RyYXRlZ3kiCiBtc2dzdHIgInN0cmF0w6lnaWUiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoyNjcgYnVpbHRpbi9wdWxsLmM6MTg3CisjOiBidWlsdGluL21lcmdlLmM6MjY3IGJ1aWx0aW4vcHVsbC5jOjE4OAogbXNnaWQgIm1lcmdlIHN0cmF0ZWd5IHRvIHVzZSIKIG1zZ3N0ciAic3RyYXTDqWdpZSBkZSBmdXNpb24gw6AgdXRpbGlzZXIiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoyNjggYnVpbHRpbi9wdWxsLmM6MTkwCisjOiBidWlsdGluL21lcmdlLmM6MjY4IGJ1aWx0aW4vcHVsbC5jOjE5MQogbXNnaWQgIm9wdGlvbj12YWx1ZSIKIG1zZ3N0ciAib3B0aW9uPXZhbGV1ciIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjI2OSBidWlsdGluL3B1bGwuYzoxOTEKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoyNjkgYnVpbHRpbi9wdWxsLmM6MTkyCiBtc2dpZCAib3B0aW9uIGZvciBzZWxlY3RlZCBtZXJnZSBzdHJhdGVneSIKIG1zZ3N0ciAib3B0aW9uIHBvdXIgbGEgc3RyYXTDqWdpZSBkZSBmdXNpb24gc8OpbGVjdGlvbm7DqWUiCiAKQEAgLTE1MjgzLDEzICsxNTM2NiwxMyBAQAogbXNnaWQgImNvbnRpbnVlIHRoZSBjdXJyZW50IGluLXByb2dyZXNzIG1lcmdlIgogbXNnc3RyICJjb250aW51ZXIgbGEgZnVzaW9uIGVuIGNvdXJzIgogCi0jOiBidWlsdGluL21lcmdlLmM6Mjg0IGJ1aWx0aW4vcHVsbC5jOjE5OAorIzogYnVpbHRpbi9tZXJnZS5jOjI4NCBidWlsdGluL3B1bGwuYzoxOTkKIG1zZ2lkICJhbGxvdyBtZXJnaW5nIHVucmVsYXRlZCBoaXN0b3JpZXMiCiBtc2dzdHIgInBlcm1ldHRyZSBsYSBmdXNpb24gZCdoaXN0b3JpcXVlcyBzYW5zIHJhcHBvcnQiCiAKICM6IGJ1aWx0aW4vbWVyZ2UuYzoyOTAKLW1zZ2lkICJ2ZXJpZnkgY29tbWl0LW1zZyBob29rIgotbXNnc3RyICJ2w6lyaWZpZXIgbGUgY3JvY2hldCBjb21taXQtbXNnIgorbXNnaWQgImJ5cGFzcyBwcmUtbWVyZ2UtY29tbWl0IGFuZCBjb21taXQtbXNnIGhvb2tzIgorbXNnc3RyICJuZSBwYXMgdXRpbGlzZXIgbGVzIGNyb2NoZXRzIHByZS1tZXJnZS1jb21taXQgZXQgY29tbWl0LW1zZyIKIAogIzogYnVpbHRpbi9tZXJnZS5jOjMwNwogbXNnaWQgImNvdWxkIG5vdCBydW4gc3Rhc2guIgpAQCAtMTUzMzIsMzMgKzE1NDE1LDMzIEBACiBtc2dpZCAiQmFkIGJyYW5jaC4lcy5tZXJnZW9wdGlvbnMgc3RyaW5nOiAlcyIKIG1zZ3N0ciAiTWF1dmFpc2UgY2hhw65uZSBicmFuY2guJXMubWVyZ2VvcHRpb25zIDogJXMiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzo3MDgKKyM6IGJ1aWx0aW4vbWVyZ2UuYzo3MDUKIG1zZ2lkICJOb3QgaGFuZGxpbmcgYW55dGhpbmcgb3RoZXIgdGhhbiB0d28gaGVhZHMgbWVyZ2UuIgogbXNnc3RyICJJbXBvc3NpYmxlIGRlIGfDqXJlciBhdXRyZSBjaG9zZSBxdWUgbGEgZnVzaW9uIGRlIGRldXggdMOqdGVzLiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjcyMgorIzogYnVpbHRpbi9tZXJnZS5jOjcxOQogIywgYy1mb3JtYXQKIG1zZ2lkICJVbmtub3duIG9wdGlvbiBmb3IgbWVyZ2UtcmVjdXJzaXZlOiAtWCVzIgogbXNnc3RyICJPcHRpb25zIGluY29ubnVlIHBvdXIgbWVyZ2UtcmVjdXJzaXZlIDogLVglcyIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjczNworIzogYnVpbHRpbi9tZXJnZS5jOjczNAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gd3JpdGUgJXMiCiBtc2dzdHIgImltcG9zc2libGUgZCfDqWNyaXJlICVzIgogCi0jOiBidWlsdGluL21lcmdlLmM6Nzg5CisjOiBidWlsdGluL21lcmdlLmM6Nzg2CiAjLCBjLWZvcm1hdAogbXNnaWQgIkNvdWxkIG5vdCByZWFkIGZyb20gJyVzJyIKIG1zZ3N0ciAiSW1wb3NzaWJsZSBkZSBsaXJlIGRlcHVpcyAnJXMnIgogCi0jOiBidWlsdGluL21lcmdlLmM6Nzk4CisjOiBidWlsdGluL21lcmdlLmM6Nzk1CiAjLCBjLWZvcm1hdAogbXNnaWQgIk5vdCBjb21taXR0aW5nIG1lcmdlOyB1c2UgJ2dpdCBjb21taXQnIHRvIGNvbXBsZXRlIHRoZSBtZXJnZS5cbiIKIG1zZ3N0ciAiIgogIlBhcyBkZSB2YWxpZGF0aW9uIGRlIGxhIGZ1c2lvbiA7IHV0aWxpc2V6ICdnaXQgY29tbWl0JyBwb3VyIHRlcm1pbmVyIGxhICIKICJmdXNpb24uXG4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzo4MDQKKyM6IGJ1aWx0aW4vbWVyZ2UuYzo4MDEKIG1zZ2lkICIiCiAiUGxlYXNlIGVudGVyIGEgY29tbWl0IG1lc3NhZ2UgdG8gZXhwbGFpbiB3aHkgdGhpcyBtZXJnZSBpcyBuZWNlc3NhcnksXG4iCiAiZXNwZWNpYWxseSBpZiBpdCBtZXJnZXMgYW4gdXBkYXRlZCB1cHN0cmVhbSBpbnRvIGEgdG9waWMgYnJhbmNoLlxuIgpAQCAtMTUzNzAsMTEgKzE1NDUzLDExIEBACiAiYnJhbmNoZSBkZSBzdWpldC5cbiIKICJcbiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjgwOQorIzogYnVpbHRpbi9tZXJnZS5jOjgwNgogbXNnaWQgIkFuIGVtcHR5IG1lc3NhZ2UgYWJvcnRzIHRoZSBjb21taXQuXG4iCiBtc2dzdHIgIlVuIG1lc3NhZ2UgdmlkZSBhYmFuZG9ubmUgbGEgdmFsaWRhdGlvbi5cbiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjgxMgorIzogYnVpbHRpbi9tZXJnZS5jOjgwOQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiTGluZXMgc3RhcnRpbmcgd2l0aCAnJWMnIHdpbGwgYmUgaWdub3JlZCwgYW5kIGFuIGVtcHR5IG1lc3NhZ2UgYWJvcnRzXG4iCkBAIC0xNTM4Myw3NCArMTU0NjYsNzQgQEAKICJMZXMgbGlnbmVzIGNvbW1lbsOnYW50IHBhciAnJWMnIHNlcm9udCBpZ25vcsOpZXMsIGV0IHVuIG1lc3NhZ2UgdmlkZVxuIgogImFiYW5kb25uZSBsYSB2YWxpZGF0aW9uLlxuIgogCi0jOiBidWlsdGluL21lcmdlLmM6ODUzCisjOiBidWlsdGluL21lcmdlLmM6ODYyCiBtc2dpZCAiRW1wdHkgY29tbWl0IG1lc3NhZ2UuIgogbXNnc3RyICJNZXNzYWdlIGRlIHZhbGlkYXRpb24gdmlkZS4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzo4NzIKKyM6IGJ1aWx0aW4vbWVyZ2UuYzo4NzcKICMsIGMtZm9ybWF0CiBtc2dpZCAiV29uZGVyZnVsLlxuIgogbXNnc3RyICJNZXJ2ZWlsbGV1eC5cbiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjkzMworIzogYnVpbHRpbi9tZXJnZS5jOjkzOAogIywgYy1mb3JtYXQKIG1zZ2lkICJBdXRvbWF0aWMgbWVyZ2UgZmFpbGVkOyBmaXggY29uZmxpY3RzIGFuZCB0aGVuIGNvbW1pdCB0aGUgcmVzdWx0LlxuIgogbXNnc3RyICIiCiAiTGEgZnVzaW9uIGF1dG9tYXRpcXVlIGEgw6ljaG91w6kgOyByw6lnbGV6IGxlcyBjb25mbGl0cyBldCB2YWxpZGV6IGxlICIKICJyw6lzdWx0YXQuXG4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzo5NzIKKyM6IGJ1aWx0aW4vbWVyZ2UuYzo5NzcKIG1zZ2lkICJObyBjdXJyZW50IGJyYW5jaC4iCiBtc2dzdHIgIlBhcyBkZSBicmFuY2hlIGNvdXJhbnRlLiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjk3NAorIzogYnVpbHRpbi9tZXJnZS5jOjk3OQogbXNnaWQgIk5vIHJlbW90ZSBmb3IgdGhlIGN1cnJlbnQgYnJhbmNoLiIKIG1zZ3N0ciAiUGFzIGRlIGJyYW5jaGUgZGlzdGFudGUgcG91ciBsYSBicmFuY2hlIGNvdXJhbnRlLiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjk3NgorIzogYnVpbHRpbi9tZXJnZS5jOjk4MQogbXNnaWQgIk5vIGRlZmF1bHQgdXBzdHJlYW0gZGVmaW5lZCBmb3IgdGhlIGN1cnJlbnQgYnJhbmNoLiIKIG1zZ3N0ciAiUGFzIGRlIGJyYW5jaGUgYW1vbnQgcGFyIGTDqWZhdXQgZMOpZmluaWUgcG91ciBsYSBicmFuY2hlIGNvdXJhbnRlLiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjk4MQorIzogYnVpbHRpbi9tZXJnZS5jOjk4NgogIywgYy1mb3JtYXQKIG1zZ2lkICJObyByZW1vdGUtdHJhY2tpbmcgYnJhbmNoIGZvciAlcyBmcm9tICVzIgogbXNnc3RyICJQYXMgZGUgYnJhbmNoZSBkZSBzdWl2aSBwb3VyICVzIGRlcHVpcyAlcyIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjEwMzgKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxMDQzCiAjLCBjLWZvcm1hdAogbXNnaWQgIkJhZCB2YWx1ZSAnJXMnIGluIGVudmlyb25tZW50ICclcyciCiBtc2dzdHIgIk1hdXZhaXNlIHZhbGV1ciAnJXMnIGRhbnMgbCdlbnZpcm9ubmVtZW50ICclcyciCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxMTQxCisjOiBidWlsdGluL21lcmdlLmM6MTE0NgogIywgYy1mb3JtYXQKIG1zZ2lkICJub3Qgc29tZXRoaW5nIHdlIGNhbiBtZXJnZSBpbiAlczogJXMiCiBtc2dzdHIgInBhcyBwb3NzaWJsZSBkZSBmdXNpb25uZXIgY2VjaSBkYW5zICVzwqA6ICVzIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTE3NQorIzogYnVpbHRpbi9tZXJnZS5jOjExODAKIG1zZ2lkICJub3Qgc29tZXRoaW5nIHdlIGNhbiBtZXJnZSIKIG1zZ3N0ciAicGFzIHBvc3NpYmxlIGRlIGZ1c2lvbm5lciBjZWNpIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTI3OAorIzogYnVpbHRpbi9tZXJnZS5jOjEyODMKIG1zZ2lkICItLWFib3J0IGV4cGVjdHMgbm8gYXJndW1lbnRzIgogbXNnc3RyICItLWFib3J0IG4nYWNjZXB0ZSBwYXMgZCdhcmd1bWVudCIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjEyODIKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxMjg3CiBtc2dpZCAiVGhlcmUgaXMgbm8gbWVyZ2UgdG8gYWJvcnQgKE1FUkdFX0hFQUQgbWlzc2luZykuIgogbXNnc3RyICJJbCBuJ3kgYSBwYXMgZGUgZnVzaW9uIMOgIGFiYW5kb25uZXIgKE1FUkdFX0hFQUQgbWFucXVhbnQpLiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjEyOTEKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxMjk2CiBtc2dpZCAiLS1xdWl0IGV4cGVjdHMgbm8gYXJndW1lbnRzIgogbXNnc3RyICItLXF1aXQgbidhY2NlcHRlIHBhcyBkJ2FyZ3VtZW50IgogCi0jOiBidWlsdGluL21lcmdlLmM6MTMwNAorIzogYnVpbHRpbi9tZXJnZS5jOjEzMDkKIG1zZ2lkICItLWNvbnRpbnVlIGV4cGVjdHMgbm8gYXJndW1lbnRzIgogbXNnc3RyICItLWNvbnRpbnVlIG5lIHN1cHBvcnRlIGF1Y3VuIGFyZ3VtZW50IgogCi0jOiBidWlsdGluL21lcmdlLmM6MTMwOAorIzogYnVpbHRpbi9tZXJnZS5jOjEzMTMKIG1zZ2lkICJUaGVyZSBpcyBubyBtZXJnZSBpbiBwcm9ncmVzcyAoTUVSR0VfSEVBRCBtaXNzaW5nKS4iCiBtc2dzdHIgIklsIG4neSBhIHBhcyBkZSBmdXNpb24gZW4gY291cnMgKE1FUkdFX0hFQUQgbWFucXVhbnQpLiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjEzMjQKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzI5CiBtc2dpZCAiIgogIllvdSBoYXZlIG5vdCBjb25jbHVkZWQgeW91ciBtZXJnZSAoTUVSR0VfSEVBRCBleGlzdHMpLlxuIgogIlBsZWFzZSwgY29tbWl0IHlvdXIgY2hhbmdlcyBiZWZvcmUgeW91IG1lcmdlLiIKQEAgLTE1NDU4LDcgKzE1NTQxLDcgQEAKICJWb3VzIG4nYXZleiBwYXMgdGVybWluw6kgdm90cmUgZnVzaW9uIChNRVJHRV9IRUFEIGV4aXN0ZSkuXG4iCiAiVmV1aWxsZXogdmFsaWRlciB2b3MgbW9kaWZpY2F0aW9ucyBhdmFudCBkZSBwb3V2b2lyIGZ1c2lvbm5lci4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzMxCisjOiBidWlsdGluL21lcmdlLmM6MTMzNgogbXNnaWQgIiIKICJZb3UgaGF2ZSBub3QgY29uY2x1ZGVkIHlvdXIgY2hlcnJ5LXBpY2sgKENIRVJSWV9QSUNLX0hFQUQgZXhpc3RzKS5cbiIKICJQbGVhc2UsIGNvbW1pdCB5b3VyIGNoYW5nZXMgYmVmb3JlIHlvdSBtZXJnZS4iCkBAIC0xNTQ2Niw5OCArMTU1NDksOTggQEAKICJWb3VzIG4nYXZleiBwYXMgdGVybWluw6kgdm90cmUgcGljb3JhZ2UgKENIRVJSWV9QSUNLX0hFQUQgZXhpc3RlKS5cbiIKICJWZXVpbGxleiB2YWxpZGVyIHZvcyBtb2RpZmljYXRpb25zIGF2YW50IGRlIHBvdXZvaXIgZnVzaW9ubmVyLiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjEzMzQKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzM5CiBtc2dpZCAiWW91IGhhdmUgbm90IGNvbmNsdWRlZCB5b3VyIGNoZXJyeS1waWNrIChDSEVSUllfUElDS19IRUFEIGV4aXN0cykuIgogbXNnc3RyICJWb3VzIG4nYXZleiBwYXMgdGVybWluw6kgdm90cmUgcGljb3JhZ2UgKENIRVJSWV9QSUNLX0hFQUQgZXhpc3RlKS4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzQ4CisjOiBidWlsdGluL21lcmdlLmM6MTM1MwogbXNnaWQgIllvdSBjYW5ub3QgY29tYmluZSAtLXNxdWFzaCB3aXRoIC0tbm8tZmYuIgogbXNnc3RyICJWb3VzIG5lIHBvdXZleiBwYXMgY29tYmluZXIgLS1zcXVhc2ggYXZlYyAtLW5vLWZmLiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjEzNTAKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzU1CiBtc2dpZCAiWW91IGNhbm5vdCBjb21iaW5lIC0tc3F1YXNoIHdpdGggLS1jb21taXQuIgogbXNnc3RyICJWb3VzIG5lIHBvdXZleiBwYXMgY29tYmluZXIgLS1zcXVhc2ggYXZlYyAtLWNvbW1pdC4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzY2CisjOiBidWlsdGluL21lcmdlLmM6MTM3MQogbXNnaWQgIk5vIGNvbW1pdCBzcGVjaWZpZWQgYW5kIG1lcmdlLmRlZmF1bHRUb1Vwc3RyZWFtIG5vdCBzZXQuIgogbXNnc3RyICIiCiAiUGFzIGRlIHZhbGlkYXRpb24gc3DDqWNpZmnDqWUgZXQgbWVyZ2UuZGVmYXVsdFRvVXBzdHJlYW0gbidlc3QgcGFzIGTDqWZpbmkuIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTM4MworIzogYnVpbHRpbi9tZXJnZS5jOjEzODgKIG1zZ2lkICJTcXVhc2ggY29tbWl0IGludG8gZW1wdHkgaGVhZCBub3Qgc3VwcG9ydGVkIHlldCIKIG1zZ3N0ciAiTGEgdmFsaWRhdGlvbiBjb21wcmVzc8OpZSB2ZXJzIHVuZSB0w6p0ZSB2aWRlIG4nZXN0IHBhcyBlbmNvcmUgc3VwcG9ydMOpZSIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjEzODUKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzkwCiBtc2dpZCAiTm9uLWZhc3QtZm9yd2FyZCBjb21taXQgZG9lcyBub3QgbWFrZSBzZW5zZSBpbnRvIGFuIGVtcHR5IGhlYWQiCiBtc2dzdHIgIlVuZSB2YWxpZGF0aW9uIHNhbnMgYXZhbmNlIHJhcGlkZSBuJ2EgcGFzIGRlIHNlbnMgZGFucyB1bmUgdMOqdGUgdmlkZSIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjEzOTAKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzk1CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIC0gbm90IHNvbWV0aGluZyB3ZSBjYW4gbWVyZ2UiCiBtc2dzdHIgIiVzIC0gcGFzIHBvc3NpYmxlIGRlIGZ1c2lvbm5lciBjZWNpIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTM5MgorIzogYnVpbHRpbi9tZXJnZS5jOjEzOTcKIG1zZ2lkICJDYW4gbWVyZ2Ugb25seSBleGFjdGx5IG9uZSBjb21taXQgaW50byBlbXB0eSBoZWFkIgogbXNnc3RyICIiCiAiUG9zc2libGUgZGUgZnVzaW9ubmVyIGV4YWN0ZW1lbnQgdW5lIHNldWxlIHZhbGlkYXRpb24gZGFucyB1bmUgdMOqdGUgdmlkZSIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjE0NzEKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxNDc2CiBtc2dpZCAicmVmdXNpbmcgdG8gbWVyZ2UgdW5yZWxhdGVkIGhpc3RvcmllcyIKIG1zZ3N0ciAicmVmdXMgZGUgZnVzaW9ubmVyIGRlcyBoaXN0b3JpcXVlcyBzYW5zIHJlbGF0aW9uIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTQ4MAorIzogYnVpbHRpbi9tZXJnZS5jOjE0ODUKIG1zZ2lkICJBbHJlYWR5IHVwIHRvIGRhdGUuIgogbXNnc3RyICJEw6lqw6Agw6Agam91ci4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxNDkwCisjOiBidWlsdGluL21lcmdlLmM6MTQ5NQogIywgYy1mb3JtYXQKIG1zZ2lkICJVcGRhdGluZyAlcy4uJXNcbiIKIG1zZ3N0ciAiTWlzZSDDoCBqb3VyICVzLi4lc1xuIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTUzMgorIzogYnVpbHRpbi9tZXJnZS5jOjE1MzcKICMsIGMtZm9ybWF0CiBtc2dpZCAiVHJ5aW5nIHJlYWxseSB0cml2aWFsIGluLWluZGV4IG1lcmdlLi4uXG4iCiBtc2dzdHIgIkVzc2FpIGRlIGZ1c2lvbiB2cmFpbWVudCB0cml2aWFsZSBkYW5zIGwnaW5kZXguLi5cbiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjE1MzkKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxNTQ0CiAjLCBjLWZvcm1hdAogbXNnaWQgIk5vcGUuXG4iCiBtc2dzdHIgIk5vbi5cbiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjE1NjQKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxNTY5CiBtc2dpZCAiQWxyZWFkeSB1cCB0byBkYXRlLiBZZWVhaCEiCiBtc2dzdHIgIkTDqWrDoCDDoCBqb3VyLiBPdWFpc8KgISIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjE1NzAKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxNTc1CiBtc2dpZCAiTm90IHBvc3NpYmxlIHRvIGZhc3QtZm9yd2FyZCwgYWJvcnRpbmcuIgogbXNnc3RyICJQYXMgcG9zc2libGUgZCdhdmFuY2VyIHJhcGlkZW1lbnQsIGFiYW5kb24uIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTU5MyBidWlsdGluL21lcmdlLmM6MTY1OAorIzogYnVpbHRpbi9tZXJnZS5jOjE1OTggYnVpbHRpbi9tZXJnZS5jOjE2NjMKICMsIGMtZm9ybWF0CiBtc2dpZCAiUmV3aW5kaW5nIHRoZSB0cmVlIHRvIHByaXN0aW5lLi4uXG4iCiBtc2dzdHIgIlJldG91ciBkZSBsJ2FyYnJlIMOgIGwnb3JpZ2luYWwuLi5cbiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjE1OTcKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxNjAyCiAjLCBjLWZvcm1hdAogbXNnaWQgIlRyeWluZyBtZXJnZSBzdHJhdGVneSAlcy4uLlxuIgogbXNnc3RyICJFc3NhaSBkZSBsYSBzdHJhdMOpZ2llIGRlIGZ1c2lvbiAlcy4uLlxuIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTY0OQorIzogYnVpbHRpbi9tZXJnZS5jOjE2NTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiTm8gbWVyZ2Ugc3RyYXRlZ3kgaGFuZGxlZCB0aGUgbWVyZ2UuXG4iCiBtc2dzdHIgIkF1Y3VuZSBzdHJhdMOpZ2llIGRlIGZ1c2lvbiBuJ2EgcHJpcyBlbiBjaGFyZ2UgbGEgZnVzaW9uLlxuIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTY1MQorIzogYnVpbHRpbi9tZXJnZS5jOjE2NTYKICMsIGMtZm9ybWF0CiBtc2dpZCAiTWVyZ2Ugd2l0aCBzdHJhdGVneSAlcyBmYWlsZWQuXG4iCiBtc2dzdHIgIkxhIGZ1c2lvbiBhdmVjIGxhIHN0cmF0w6lnaWUgJXMgYSDDqWNob3XDqS5cbiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjE2NjAKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxNjY1CiAjLCBjLWZvcm1hdAogbXNnaWQgIlVzaW5nIHRoZSAlcyB0byBwcmVwYXJlIHJlc29sdmluZyBieSBoYW5kLlxuIgogbXNnc3RyICJVdGlsaXNhdGlvbiBkZSAlcyBwb3VyIHByw6lwYXJlciBsYSByw6lzb2x1dGlvbiDDoCBsYSBtYWluLlxuIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTY3MgorIzogYnVpbHRpbi9tZXJnZS5jOjE2NzcKICMsIGMtZm9ybWF0CiBtc2dpZCAiQXV0b21hdGljIG1lcmdlIHdlbnQgd2VsbDsgc3RvcHBlZCBiZWZvcmUgY29tbWl0dGluZyBhcyByZXF1ZXN0ZWRcbiIKIG1zZ3N0ciAiIgpAQCAtMTU2NDMsMzMgKzE1NzI2LDMzIEBACiBtc2dpZCAic2V0IGxhYmVscyBmb3IgZmlsZTEvb3JpZy1maWxlL2ZpbGUyIgogbXNnc3RyICJkw6lmaW5pciBsZXMgbGFiZWxzIHBvdXIgZmljaGllcjEvZmljaGllci1vcmlnL2ZpY2hpZXIyIgogCi0jOiBidWlsdGluL21lcmdlLXJlY3Vyc2l2ZS5jOjQ2CisjOiBidWlsdGluL21lcmdlLXJlY3Vyc2l2ZS5jOjQ3CiAjLCBjLWZvcm1hdAogbXNnaWQgInVua25vd24gb3B0aW9uICVzIgogbXNnc3RyICJvcHRpb24gaW5jb25udWUgJXMiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UtcmVjdXJzaXZlLmM6NTIKKyM6IGJ1aWx0aW4vbWVyZ2UtcmVjdXJzaXZlLmM6NTMKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHBhcnNlIG9iamVjdCAnJXMnIgogbXNnc3RyICJJbXBvc3NpYmxlIGQnYW5hbHlzZXIgbCdvYmpldCAnJXMnIgogCi0jOiBidWlsdGluL21lcmdlLXJlY3Vyc2l2ZS5jOjU2CisjOiBidWlsdGluL21lcmdlLXJlY3Vyc2l2ZS5jOjU3CiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCBoYW5kbGUgbW9yZSB0aGFuICVkIGJhc2UuIElnbm9yaW5nICVzLiIKIG1zZ2lkX3BsdXJhbCAiY2Fubm90IGhhbmRsZSBtb3JlIHRoYW4gJWQgYmFzZXMuIElnbm9yaW5nICVzLiIKIG1zZ3N0clswXSAiaW1wb3NzaWJsZSBkZSBnw6lyZXIgcGx1cyBkZSAlZCBiYXNlLiAlcyBpZ25vcsOpLiIKIG1zZ3N0clsxXSAiaW1wb3NzaWJsZSBkZSBnw6lyZXIgcGx1cyBkZSAlZCBiYXNlcy4gJXMgaWdub3LDqS4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UtcmVjdXJzaXZlLmM6NjQKKyM6IGJ1aWx0aW4vbWVyZ2UtcmVjdXJzaXZlLmM6NjUKIG1zZ2lkICJub3QgaGFuZGxpbmcgYW55dGhpbmcgb3RoZXIgdGhhbiB0d28gaGVhZHMgbWVyZ2UuIgogbXNnc3RyICJpbXBvc3NpYmxlIGRlIGfDqXJlciBhdXRyZSBjaG9zZSBxdWUgbGEgZnVzaW9uIGRlIGRldXggdMOqdGVzLiIKIAotIzogYnVpbHRpbi9tZXJnZS1yZWN1cnNpdmUuYzo3MCBidWlsdGluL21lcmdlLXJlY3Vyc2l2ZS5jOjcyCisjOiBidWlsdGluL21lcmdlLXJlY3Vyc2l2ZS5jOjc0IGJ1aWx0aW4vbWVyZ2UtcmVjdXJzaXZlLmM6NzYKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHJlc29sdmUgcmVmICclcyciCiBtc2dzdHIgImltcG9zc2libGUgZGUgcsOpc291ZHJlIGxhIHLDqWbDqXJlbmNlICclcyciCiAKLSM6IGJ1aWx0aW4vbWVyZ2UtcmVjdXJzaXZlLmM6NzgKKyM6IGJ1aWx0aW4vbWVyZ2UtcmVjdXJzaXZlLmM6ODIKICMsIGMtZm9ybWF0CiBtc2dpZCAiTWVyZ2luZyAlcyB3aXRoICVzXG4iCiBtc2dzdHIgIkZ1c2lvbiBkZSAlcyBhdmVjICVzXG4iCkBAIC0xNTgxNCw1MyArMTU4OTcsNTMgQEAKIG1zZ2lkICJSZW5hbWluZyAlcyB0byAlc1xuIgogbXNnc3RyICJSZW5vbW1hZ2UgZGUgJXMgZW4gJXNcbiIKIAotIzogYnVpbHRpbi9tdi5jOjI3NyBidWlsdGluL3JlbW90ZS5jOjcxNyBidWlsdGluL3JlcGFjay5jOjUxMAorIzogYnVpbHRpbi9tdi5jOjI3NyBidWlsdGluL3JlbW90ZS5jOjcxNyBidWlsdGluL3JlcGFjay5jOjUxMQogIywgYy1mb3JtYXQKIG1zZ2lkICJyZW5hbWluZyAnJXMnIGZhaWxlZCIKIG1zZ3N0ciAibGUgcmVub21tYWdlIGRlICclcycgYSDDqWNob3XDqSIKIAotIzogYnVpbHRpbi9uYW1lLXJldi5jOjM1MgorIzogYnVpbHRpbi9uYW1lLXJldi5jOjM1NgogbXNnaWQgImdpdCBuYW1lLXJldiBbPG9wdGlvbnM+XSA8Y29tbWl0Pi4uLiIKIG1zZ3N0ciAiZ2l0IG5hbWUtcmV2IFs8b3B0aW9ucz5dIDx2YWxpZGF0aW9uPi4uLiIKIAotIzogYnVpbHRpbi9uYW1lLXJldi5jOjM1MworIzogYnVpbHRpbi9uYW1lLXJldi5jOjM1NwogbXNnaWQgImdpdCBuYW1lLXJldiBbPG9wdGlvbnM+XSAtLWFsbCIKIG1zZ3N0ciAiZ2l0IG5hbWUtcmV2IFs8b3B0aW9ucz5dIC0tYWxsIgogCi0jOiBidWlsdGluL25hbWUtcmV2LmM6MzU0CisjOiBidWlsdGluL25hbWUtcmV2LmM6MzU4CiBtc2dpZCAiZ2l0IG5hbWUtcmV2IFs8b3B0aW9ucz5dIC0tc3RkaW4iCiBtc2dzdHIgImdpdCBuYW1lLXJldiBbPG9wdGlvbnM+XSAtLXN0ZGluIgogCi0jOiBidWlsdGluL25hbWUtcmV2LmM6NDExCisjOiBidWlsdGluL25hbWUtcmV2LmM6NDE1CiBtc2dpZCAicHJpbnQgb25seSBuYW1lcyAobm8gU0hBLTEpIgogbXNnc3RyICJhZmZpY2hlciBzZXVsZW1lbnQgbGVzIG5vbXMgKHBhcyBkZSBTSEEtMSkiCiAKLSM6IGJ1aWx0aW4vbmFtZS1yZXYuYzo0MTIKKyM6IGJ1aWx0aW4vbmFtZS1yZXYuYzo0MTYKIG1zZ2lkICJvbmx5IHVzZSB0YWdzIHRvIG5hbWUgdGhlIGNvbW1pdHMiCiBtc2dzdHIgInV0aWxpc2VyIHNldWxlbWVudCBsZXMgw6l0aXF1ZXR0ZXMgcG91ciBub21tZXIgbGVzIHZhbGlkYXRpb25zIgogCi0jOiBidWlsdGluL25hbWUtcmV2LmM6NDE0CisjOiBidWlsdGluL25hbWUtcmV2LmM6NDE4CiBtc2dpZCAib25seSB1c2UgcmVmcyBtYXRjaGluZyA8cGF0dGVybj4iCiBtc2dzdHIgInV0aWxpc2VyIHNldWxlbWVudCBsZXMgcsOpZsOpcmVuY2VzIGNvcnJlc3BvbmRhbnQgw6AgPG1vdGlmPiIKIAotIzogYnVpbHRpbi9uYW1lLXJldi5jOjQxNgorIzogYnVpbHRpbi9uYW1lLXJldi5jOjQyMAogbXNnaWQgImlnbm9yZSByZWZzIG1hdGNoaW5nIDxwYXR0ZXJuPiIKIG1zZ3N0ciAiaWdub3JlciBsZXMgcsOpZsOpcmVuY2VzIGNvcnJlc3BvbmRhbnQgw6AgPG1vdGlmPiIKIAotIzogYnVpbHRpbi9uYW1lLXJldi5jOjQxOAorIzogYnVpbHRpbi9uYW1lLXJldi5jOjQyMgogbXNnaWQgImxpc3QgYWxsIGNvbW1pdHMgcmVhY2hhYmxlIGZyb20gYWxsIHJlZnMiCiBtc2dzdHIgIiIKICJhZmZpY2hlciB0b3V0ZXMgbGVzIHZhbGlkYXRpb25zIGFjY2Vzc2libGVzIGRlcHVpcyB0b3V0ZXMgbGVzIHLDqWbDqXJlbmNlcyIKIAotIzogYnVpbHRpbi9uYW1lLXJldi5jOjQxOQorIzogYnVpbHRpbi9uYW1lLXJldi5jOjQyMwogbXNnaWQgInJlYWQgZnJvbSBzdGRpbiIKIG1zZ3N0ciAibGlyZSBkZXB1aXMgbCdlbnRyw6llIHN0YW5kYXJkIgogCi0jOiBidWlsdGluL25hbWUtcmV2LmM6NDIwCisjOiBidWlsdGluL25hbWUtcmV2LmM6NDI0CiBtc2dpZCAiYWxsb3cgdG8gcHJpbnQgYHVuZGVmaW5lZGAgbmFtZXMgKGRlZmF1bHQpIgogbXNnc3RyICJhdXRvcmlzZXIgbCdhZmZpY2hhZ2UgZGVzIG5vbXMgYG5vbiBkw6lmaW5pc2AgKHBhciBkw6lmYXV0KSIKIAotIzogYnVpbHRpbi9uYW1lLXJldi5jOjQyNgorIzogYnVpbHRpbi9uYW1lLXJldi5jOjQzMAogbXNnaWQgImRlcmVmZXJlbmNlIHRhZ3MgaW4gdGhlIGlucHV0IChpbnRlcm5hbCB1c2UpIgogbXNnc3RyICJkw6lyw6lmw6lyZW5jZXIgbGVzIMOpdGlxdWV0dGVzIGVuIGVudHLDqWUgKHVzYWdlIGludGVybmUpIgogCkBAIC0xNjI2MCw3ICsxNjM0Myw3IEBACiBtc2dpZCAicmVhZCBvYmplY3QgbmFtZXMgZnJvbSB0aGUgc3RhbmRhcmQgaW5wdXQiCiBtc2dzdHIgImxpcmUgbGVzIG5vbXMgZCdvYmpldCBkZXB1aXMgbCdlbnRyw6llIHN0YW5kYXJkIgogCi0jOiBidWlsdGluL25vdGVzLmM6OTU0IGJ1aWx0aW4vcHJ1bmUuYzoxMzAgYnVpbHRpbi93b3JrdHJlZS5jOjE2NQorIzogYnVpbHRpbi9ub3Rlcy5jOjk1NCBidWlsdGluL3BydW5lLmM6MTMwIGJ1aWx0aW4vd29ya3RyZWUuYzoxNjQKIG1zZ2lkICJkbyBub3QgcmVtb3ZlLCBzaG93IG9ubHkiCiBtc2dzdHIgIm5lIHBhcyBzdXBwcmltZXIsIGFmZmljaGVyIHNldWxlbWVudCIKIApAQCAtMTYyNzYsNyArMTYzNTksNyBAQAogbXNnaWQgInVzZSBub3RlcyBmcm9tIDxub3Rlcy1yZWY+IgogbXNnc3RyICJ1dGlsaXNlciBsZXMgbm90ZXMgZGVwdWlzIDxyw6lmw6lyZW5jZXMtbm90ZXM+IgogCi0jOiBidWlsdGluL25vdGVzLmM6MTAzNCBidWlsdGluL3N0YXNoLmM6MTU5OAorIzogYnVpbHRpbi9ub3Rlcy5jOjEwMzQgYnVpbHRpbi9zdGFzaC5jOjE2MDcKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5rbm93biBzdWJjb21tYW5kOiAlcyIKIG1zZ3N0ciAic291cy1jb21tYW5kZSBpbmNvbm51ZSA6ICVzIgpAQCAtMTYzNTMsNzEgKzE2NDM2LDcxIEBACiBtc2dpZCAid3JvdGUgJTxQUkl1MzI+IG9iamVjdHMgd2hpbGUgZXhwZWN0aW5nICU8UFJJdTMyPiIKIG1zZ3N0ciAiJTxQUkl1MzI+IG9iamV0cyDDqWNyaXRzLCAlPFBSSXUzMj4gYXR0ZW5kdXMiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MTE2NgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoxMTY0CiBtc2dpZCAiZGlzYWJsaW5nIGJpdG1hcCB3cml0aW5nLCBhcyBzb21lIG9iamVjdHMgYXJlIG5vdCBiZWluZyBwYWNrZWQiCiBtc2dzdHIgIiIKICJkw6lzYWN0aXZhdGlvbiBkZSBsJ8OpY3JpdHVyZSBlbiBiaXRtYXAgY2FyIGNlcnRhaW5zIG9iamV0cyBuZSBzb250IHBhcyAiCiAiY29tcHJlc3PDqXMiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MTU5NworIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoxNTkyCiAjLCBjLWZvcm1hdAogbXNnaWQgImRlbHRhIGJhc2Ugb2Zmc2V0IG92ZXJmbG93IGluIHBhY2sgZm9yICVzIgogbXNnc3RyICJkw6lwYXNzZW1lbnQgZGUgZMOpY2FsYWdlIGRlIGJhc2UgZGUgZGVsdGEgcG91ciAlcyIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoxNjA2CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjE2MDEKICMsIGMtZm9ybWF0CiBtc2dpZCAiZGVsdGEgYmFzZSBvZmZzZXQgb3V0IG9mIGJvdW5kIGZvciAlcyIKIG1zZ3N0ciAiZMOpY2FsYWdlIGRlIGJhc2UgZGUgZGVsdGEgZXN0IGhvcnMgbGltaXRlIHBvdXIgJXMiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MTg3NQorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoxODcwCiBtc2dpZCAiQ291bnRpbmcgb2JqZWN0cyIKIG1zZ3N0ciAiRMOpY29tcHRlIGRlcyBvYmpldHMiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjAwNQorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyMDAwCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBnZXQgc2l6ZSBvZiAlcyIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkZSByw6ljdXDDqXJlciBsYSB0YWlsbGUgZGUgJXMiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjAyMAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyMDE1CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBwYXJzZSBvYmplY3QgaGVhZGVyIG9mICVzIgogbXNnc3RyICJpbXBvc3NpYmxlIGQnYW5hbHlzZXIgbCdlbnTDqnRlIGQnb2JqZXQgZGUgJXMiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjA5MCBidWlsdGluL3BhY2stb2JqZWN0cy5jOjIxMDYKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjExNgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyMDg1IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjEwMQorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyMTExCiAjLCBjLWZvcm1hdAogbXNnaWQgIm9iamVjdCAlcyBjYW5ub3QgYmUgcmVhZCIKIG1zZ3N0ciAibCdvYmpldCAlcyBuZSBwZXV0IMOqdHJlIGx1IgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjIwOTMgYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyMTIwCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjIwODggYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyMTE1CiAjLCBjLWZvcm1hdAogbXNnaWQgIm9iamVjdCAlcyBpbmNvbnNpc3RlbnQgb2JqZWN0IGxlbmd0aCAoJTxQUkl1TUFYPiB2cyAlPFBSSXVNQVg+KSIKIG1zZ3N0ciAiIgogIm9iamV0ICVzIGxvbmd1ZXVyIGRlIGwnb2JqZXQgaW5jb25zaXN0YW50ZSAoJTxQUkl1TUFYPiBjb250cmUgJTxQUkl1TUFYPikiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjEzMAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyMTI1CiBtc2dpZCAic3Vib3B0aW1hbCBwYWNrIC0gb3V0IG9mIG1lbW9yeSIKIG1zZ3N0ciAicGFxdWV0IHNvdXMtb3B0aW1hbCAtIG3DqW1vaXJlIGluc3VmZmlzYW50ZSIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNDU2CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI0NDAKICMsIGMtZm9ybWF0CiBtc2dpZCAiRGVsdGEgY29tcHJlc3Npb24gdXNpbmcgdXAgdG8gJWQgdGhyZWFkcyIKIG1zZ3N0ciAiQ29tcHJlc3Npb24gcGFyIGRlbHRhIGVuIHV0aWxpc2FudCBqdXNxdSfDoCAlZCBmaWxzIGQnZXjDqWN1dGlvbiIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNTg4CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI1NzIKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHBhY2sgb2JqZWN0cyByZWFjaGFibGUgZnJvbSB0YWcgJXMiCiBtc2dzdHIgImltcG9zc2libGUgZCdlbXBhcXVldGVyIGxlcyBvYmpldHMgam9pZ25hYmxlcyBkZXB1aXMgbCfDqXRpcXVldHRlICVzIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI2NzUKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjY1OQogbXNnaWQgIkNvbXByZXNzaW5nIG9iamVjdHMiCiBtc2dzdHIgIkNvbXByZXNzaW9uIGRlcyBvYmpldHMiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjY4MQorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNjY1CiBtc2dpZCAiaW5jb25zaXN0ZW5jeSB3aXRoIGRlbHRhIGNvdW50IgogbXNnc3RyICJpbmNvbnNpc3RhbmNlIGRhbnMgbGUgY29tcHRlIGRlIGRlbHRhIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI3NjIKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6Mjc0MgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiZXhwZWN0ZWQgZWRnZSBvYmplY3QgSUQsIGdvdCBnYXJiYWdlOlxuIgpAQCAtMTY0MjYsNyArMTY1MDksNyBAQAogIklEIGQnb2JqZXQgZGUgYm9yZCBhdHRlbmR1LCByZcOndSBkZXMgZG9ubsOpZXMgaWxsaXNpYmxlc8KgOlxuIgogIiVzIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI3NjgKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6Mjc0OAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiZXhwZWN0ZWQgb2JqZWN0IElELCBnb3QgZ2FyYmFnZTpcbiIKQEAgLTE2NDM1LDI1MiArMTY1MTgsMjUyIEBACiAiSUQgZCdvYmpldCBhdHRlbmR1LCByZcOndSBkZXMgZG9ubsOpZXMgaWxsaXNpYmxlc8KgOlxuIgogIiVzIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI4NjYKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6Mjg0NgogbXNnaWQgImludmFsaWQgdmFsdWUgZm9yIC0tbWlzc2luZyIKIG1zZ3N0ciAidmFsZXVyIGludmFsaWRlIHBvdXIgLS1taXNzaW5nIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI5MjUgYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMDMzCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI5MDUgYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMDEzCiBtc2dpZCAiY2Fubm90IG9wZW4gcGFjayBpbmRleCIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkJ291dnJpciBsJ2luZGV4IGRlIHBhcXVldCIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyOTU2CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI5MzYKICMsIGMtZm9ybWF0CiBtc2dpZCAibG9vc2Ugb2JqZWN0IGF0ICVzIGNvdWxkIG5vdCBiZSBleGFtaW5lZCIKIG1zZ3N0ciAibCdvYmpldCBsaWJyZSDDoCAlcyBuJ2EgcGFzIHB1IMOqdHJlIGV4YW1pbsOpIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMwNDEKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzAyMQogbXNnaWQgInVuYWJsZSB0byBmb3JjZSBsb29zZSBvYmplY3QiCiBtc2dzdHIgImltcG9zc2libGUgZGUgZm9yY2VyIGwnb2JqZXQgbGlicmUiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzEzMworIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMTEzCiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vdCBhIHJldiAnJXMnIgogbXNnc3RyICInJXMnIG4nZXN0IHBhcyB1bmUgcsOpdmlzaW9uIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMxMzYKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzExNgogIywgYy1mb3JtYXQKIG1zZ2lkICJiYWQgcmV2aXNpb24gJyVzJyIKIG1zZ3N0ciAibWF1dmFpc2UgcsOpdmlzaW9uICclcyciCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzE2MQorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMTQxCiBtc2dpZCAidW5hYmxlIHRvIGFkZCByZWNlbnQgb2JqZWN0cyIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkJ2Fqb3V0ZXIgbGVzIG9iamV0cyByw6ljZW50cyIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjE0CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMxOTQKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5zdXBwb3J0ZWQgaW5kZXggdmVyc2lvbiAlcyIKIG1zZ3N0ciAidmVyc2lvbiBkJ2luZGV4IG5vbiBzdXBwb3J0w6llICVzIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyMTgKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzE5OAogIywgYy1mb3JtYXQKIG1zZ2lkICJiYWQgaW5kZXggdmVyc2lvbiAnJXMnIgogbXNnc3RyICJtYXV2YWlzZSB2ZXJzaW9uIGQnaW5kZXggJyVzJyIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjQ4CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyMjgKIG1zZ2lkICJkbyBub3Qgc2hvdyBwcm9ncmVzcyBtZXRlciIKIG1zZ3N0ciAibmUgcGFzIGFmZmljaGVyIGxhIGJhcnJlIGRlIHByb2dyZXNzaW9uIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNTAKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzIzMAogbXNnaWQgInNob3cgcHJvZ3Jlc3MgbWV0ZXIiCiBtc2dzdHIgImFmZmljaGVyIGxhIGJhcnJlIGRlIHByb2dyZXNzaW9uIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNTIKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzIzMgogbXNnaWQgInNob3cgcHJvZ3Jlc3MgbWV0ZXIgZHVyaW5nIG9iamVjdCB3cml0aW5nIHBoYXNlIgogbXNnc3RyICJhZmZpY2hlciBsYSBiYXJyZSBkZSBwcm9ncmVzc2lvbiBkdXJhbnQgbGEgcGhhc2UgZCfDqWNyaXRlIGRlcyBvYmpldHMiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI1NQorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjM1CiBtc2dpZCAic2ltaWxhciB0byAtLWFsbC1wcm9ncmVzcyB3aGVuIHByb2dyZXNzIG1ldGVyIGlzIHNob3duIgogbXNnc3RyICJzaW1pbGFpcmUgw6AgLS1hbGwtcHJvZ3Jlc3MgcXVhbmQgbGEgYmFycmUgZGUgcHJvZ3Jlc3Npb24gZXN0IGFmZmljaMOpZSIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjU2CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyMzYKIG1zZ2lkICI8dmVyc2lvbj5bLDxvZmZzZXQ+XSIKIG1zZ3N0ciAiPHZlcnNpb24+Wyw8ZMOpY2FsYWdlPl0iCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI1NworIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjM3CiBtc2dpZCAid3JpdGUgdGhlIHBhY2sgaW5kZXggZmlsZSBpbiB0aGUgc3BlY2lmaWVkIGlkeCBmb3JtYXQgdmVyc2lvbiIKIG1zZ3N0ciAiIgogIsOpY3JpcmUgbGUgZmljaGllciBkJ2luZGV4IGR1IHBhcXVldCBkYW5zIGxlIGZvcm1hdCBkJ2luZGV4IGRlIHZlcnNpb24gIgogInNww6ljaWZpw6kiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI2MAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjQwCiBtc2dpZCAibWF4aW11bSBzaXplIG9mIGVhY2ggb3V0cHV0IHBhY2sgZmlsZSIKIG1zZ3N0ciAidGFpbGxlIG1heGltdW0gZGUgY2hhcXVlIGZpY2hpZXIgcGFxdWV0IGVuIHNvcnRpZSIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjYyCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNDIKIG1zZ2lkICJpZ25vcmUgYm9ycm93ZWQgb2JqZWN0cyBmcm9tIGFsdGVybmF0ZSBvYmplY3Qgc3RvcmUiCiBtc2dzdHIgImlnbm9yZXIgbGVzIG9iamV0cyBlbXBydW50w6lzIMOgIHVuIGF1dHJlIG1hZ2FzaW4gZCdvYmpldHMiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI2NAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjQ0CiBtc2dpZCAiaWdub3JlIHBhY2tlZCBvYmplY3RzIgogbXNnc3RyICJpZ25vcmVyIGxlcyBvYmpldHMgZW1wYXF1ZXTDqXMiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI2NgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjQ2CiBtc2dpZCAibGltaXQgcGFjayB3aW5kb3cgYnkgb2JqZWN0cyIKIG1zZ3N0ciAibGltaXRlciBsYSBmZW7DqnRyZSBkJ2VtcGFxdWV0YWdlIHBhciBvYmpldHMiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI2OAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjQ4CiBtc2dpZCAibGltaXQgcGFjayB3aW5kb3cgYnkgbWVtb3J5IGluIGFkZGl0aW9uIHRvIG9iamVjdCBsaW1pdCIKIG1zZ3N0ciAiIgogImxpbWl0ZXIgbGEgZmVuw6p0cmUgZCdlbXBhcXVldGFnZSBwYXIgbcOpbW9pcmUgZW4gcGx1cyBkZSBsYSBsaW1pdGUgZCdvYmpldHMiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI3MAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjUwCiBtc2dpZCAibWF4aW11bSBsZW5ndGggb2YgZGVsdGEgY2hhaW4gYWxsb3dlZCBpbiB0aGUgcmVzdWx0aW5nIHBhY2siCiBtc2dzdHIgIiIKICJsb25ndWV1ciBtYXhpbXVtIGRlIGxhIGNoYcOubmUgZGUgZGVsdGEgYXV0b3Jpc8OpZSBkYW5zIGxlIHBhcXVldCByw6lzdWx0YW50IgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNzIKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI1MgogbXNnaWQgInJldXNlIGV4aXN0aW5nIGRlbHRhcyIKIG1zZ3N0ciAicsOpdXRpbGlzZXIgbGVzIGRlbHRhcyBleGlzdGFudHMiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI3NAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjU0CiBtc2dpZCAicmV1c2UgZXhpc3Rpbmcgb2JqZWN0cyIKIG1zZ3N0ciAicsOpdXRpbGlzZXIgbGVzIG9iamV0cyBleGlzdGFudHMiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI3NgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjU2CiBtc2dpZCAidXNlIE9GU19ERUxUQSBvYmplY3RzIgogbXNnc3RyICJ1dGlsaXNlciBsZXMgb2JqZXRzIE9GU19ERUxUQSIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjc4CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNTgKIG1zZ2lkICJ1c2UgdGhyZWFkcyB3aGVuIHNlYXJjaGluZyBmb3IgYmVzdCBkZWx0YSBtYXRjaGVzIgogbXNnc3RyICIiCiAidXRpbGlzZXIgZGVzIGZpbHMgbG9ycyBkZSBsYSByZWNoZXJjaGUgcG91ciB1bmUgbWVpbGxldXJlIGNvcnJlc3BvbmRhbmNlIGRlcyAiCiAiZGVsdGFzIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyODAKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI2MAogbXNnaWQgImRvIG5vdCBjcmVhdGUgYW4gZW1wdHkgcGFjayBvdXRwdXQiCiBtc2dzdHIgIm5lIHBhcyBjcsOpZXIgdW4gcGFxdWV0IHZpZGUiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI4MgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjYyCiBtc2dpZCAicmVhZCByZXZpc2lvbiBhcmd1bWVudHMgZnJvbSBzdGFuZGFyZCBpbnB1dCIKIG1zZ3N0ciAibGlyZSBsZXMgcGFyYW3DqHRyZXMgZGUgcsOpdmlzaW9uIGRlcHVpcyBsJ2VudHLDqWUgc3RhbmRhcmQiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI4NAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjY0CiBtc2dpZCAibGltaXQgdGhlIG9iamVjdHMgdG8gdGhvc2UgdGhhdCBhcmUgbm90IHlldCBwYWNrZWQiCiBtc2dzdHIgImxpbWl0ZXIgbGVzIG9iamV0cyDDoCBjZXV4IHF1aSBuZSBzb250IHBhcyBlbmNvcmUgZW1wYXF1ZXTDqXMiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI4NworIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjY3CiBtc2dpZCAiaW5jbHVkZSBvYmplY3RzIHJlYWNoYWJsZSBmcm9tIGFueSByZWZlcmVuY2UiCiBtc2dzdHIgImluY2x1cmUgbGVzIG9iamV0cyBhY2Nlc3NpYmxlcyBkZXB1aXMgdG91dGUgcsOpZsOpcmVuY2UiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI5MAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjcwCiBtc2dpZCAiaW5jbHVkZSBvYmplY3RzIHJlZmVycmVkIGJ5IHJlZmxvZyBlbnRyaWVzIgogbXNnc3RyICJpbmNsdXJlIGxlcyBvYmpldHMgcsOpZsOpcmVuY8OpcyBwYXIgbGVzIMOpbMOpbWVudHMgZGUgcmVmbG9nIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyOTMKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI3MwogbXNnaWQgImluY2x1ZGUgb2JqZWN0cyByZWZlcnJlZCB0byBieSB0aGUgaW5kZXgiCiBtc2dzdHIgImluY2x1cmUgbGVzIG9iamV0cyByw6lmw6lyZW5jw6lzIHBhciBsJ2luZGV4IgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyOTYKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI3NgogbXNnaWQgIm91dHB1dCBwYWNrIHRvIHN0ZG91dCIKIG1zZ3N0ciAiYWZmaWNoZXIgbCdlbXBhcXVldGFnZSBzdXIgbGEgc29ydGllIHN0YW5kYXJkIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyOTgKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI3OAogbXNnaWQgImluY2x1ZGUgdGFnIG9iamVjdHMgdGhhdCByZWZlciB0byBvYmplY3RzIHRvIGJlIHBhY2tlZCIKIG1zZ3N0ciAiaW5jbHVyZSBsZXMgb2JqZXRzIGQnw6l0aXF1ZXR0ZXMgcXVpIHLDqWbDqHJlbnQgw6AgZGVzIG9iamV0cyDDoCBlbXBhcXVldGVyIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMDAKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI4MAogbXNnaWQgImtlZXAgdW5yZWFjaGFibGUgb2JqZWN0cyIKIG1zZ3N0ciAiZ2FyZGVyIGxlcyBvYmpldHMgaW5hY2Nlc3NpYmxlcyIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzAyCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyODIKIG1zZ2lkICJwYWNrIGxvb3NlIHVucmVhY2hhYmxlIG9iamVjdHMiCiBtc2dzdHIgImVtcGFxdWV0ZXIgbGVzIG9iamV0cyBpbmFjY2Vzc2libGVzIGTDqXRhY2jDqXMiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMwNAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjg0CiBtc2dpZCAidW5wYWNrIHVucmVhY2hhYmxlIG9iamVjdHMgbmV3ZXIgdGhhbiA8dGltZT4iCiBtc2dzdHIgImTDqXBhcXVldGVyIGxlcyBvYmpldHMgaW5hY2Nlc3NpYmxlcyBwbHVzIHLDqWNlbnRzIHF1ZSA8aGV1cmU+IgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMDcKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI4NwogbXNnaWQgInVzZSB0aGUgc3BhcnNlIHJlYWNoYWJpbGl0eSBhbGdvcml0aG0iCiBtc2dzdHIgInV0aWxpc2VyIGwnYWxnb3JpdGhtZSBkZSBqb2lnbmFiaWxpdMOpIGNyZXVzZSIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzA5CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyODkKIG1zZ2lkICJjcmVhdGUgdGhpbiBwYWNrcyIKIG1zZ3N0ciAiY3LDqWVyIGRlcyBwYXF1ZXRzIGzDqWdlcnMiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMxMQorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjkxCiBtc2dpZCAiY3JlYXRlIHBhY2tzIHN1aXRhYmxlIGZvciBzaGFsbG93IGZldGNoZXMiCiBtc2dzdHIgImNyw6llciBkZXMgcGFxdWV0cyBwZXJtZXR0YW50IGRlcyByw6ljdXDDqXJhdGlvbnMgc3VwZXJmaWNpZWxsZXMiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMxMworIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjkzCiBtc2dpZCAiaWdub3JlIHBhY2tzIHRoYXQgaGF2ZSBjb21wYW5pb24gLmtlZXAgZmlsZSIKIG1zZ3N0ciAiaWdub3JlciBsZXMgcGFxdWV0cyBxdWkgb250IHVuIGZpY2hpZXIgLmtlZXAiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMxNQorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjk1CiBtc2dpZCAiaWdub3JlIHRoaXMgcGFjayIKIG1zZ3N0ciAiaWdub3JlciBjZSBwYXF1ZXQiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMxNworIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjk3CiBtc2dpZCAicGFjayBjb21wcmVzc2lvbiBsZXZlbCIKIG1zZ3N0ciAibml2ZWF1IGRlIGNvbXByZXNzaW9uIGR1IHBhcXVldCIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzE5CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyOTkKIG1zZ2lkICJkbyBub3QgaGlkZSBjb21taXRzIGJ5IGdyYWZ0cyIKIG1zZ3N0ciAibmUgcGFzIGNhY2hlciBsZXMgdmFsaWRhdGlvbnMgcGFyIGdyZWZmZXMiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMyMQorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzAxCiBtc2dpZCAidXNlIGEgYml0bWFwIGluZGV4IGlmIGF2YWlsYWJsZSB0byBzcGVlZCB1cCBjb3VudGluZyBvYmplY3RzIgogbXNnc3RyICIiCiAidXRpbGlzZXIgdW4gaW5kZXggZW4gYml0bWFwIHNpIGRpc3BvbmlibGUgcG91ciBhY2PDqWxlcmVyIGxlIGTDqWNvbXB0ZSBkZXMgIgogIm9iamV0cyIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzIzCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMDMKIG1zZ2lkICJ3cml0ZSBhIGJpdG1hcCBpbmRleCB0b2dldGhlciB3aXRoIHRoZSBwYWNrIGluZGV4IgogbXNnc3RyICLDqWNyaXJlIHVuIGluZGV4IGVuIGJpdG1hcCBhc3NvY2nDqSDDoCBsJ2luZGV4IGRlIHBhcXVldCIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzI3CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMDcKIG1zZ2lkICJ3cml0ZSBhIGJpdG1hcCBpbmRleCBpZiBwb3NzaWJsZSIKIG1zZ3N0ciAiw6ljcmlyZSB1biBpbmRleCBkZSBiaXRtYXAgc2kgcG9zc2libGUiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMzMQorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzExCiBtc2dpZCAiaGFuZGxpbmcgZm9yIG1pc3Npbmcgb2JqZWN0cyIKIG1zZ3N0ciAiZ2VzdGlvbiBkZXMgb2JqZXRzIG1hbnF1YW50cyIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzM0CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMTQKIG1zZ2lkICJkbyBub3QgcGFjayBvYmplY3RzIGluIHByb21pc29yIHBhY2tmaWxlcyIKIG1zZ3N0ciAibmUgcGFzIGVtcGFxdWV0ZXIgbGVzIG9iamV0cyBkYW5zIGxlcyBmaWNoaWVycyBwYXF1ZXRzIHByb21ldHRldXJzIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMzYKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMxNgogbXNnaWQgInJlc3BlY3QgaXNsYW5kcyBkdXJpbmcgZGVsdGEgY29tcHJlc3Npb24iCiBtc2dzdHIgInJlc3BlY3RlciBsZXMgw65sb3RzIHBlbmRhbnQgbGEgY29tcHJlc3Npb24gZGVzIGRlbHRhcyIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzYxCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzNDUKICMsIGMtZm9ybWF0CiBtc2dpZCAiZGVsdGEgY2hhaW4gZGVwdGggJWQgaXMgdG9vIGRlZXAsIGZvcmNpbmcgJWQiCiBtc2dzdHIgImxhIHByb2ZvbmRldXIgJWQgZGUgY2hhw65uZSBkZSBkZWx0YSBlc3QgdHJvcCBncmFuZGUsIGZvcmPDqWUgw6AgJWQiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzM2NgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzUwCiAjLCBjLWZvcm1hdAogbXNnaWQgInBhY2suZGVsdGFDYWNoZUxpbWl0IGlzIHRvbyBoaWdoLCBmb3JjaW5nICVkIgogbXNnc3RyICJwYWNrLmRlbHRhQ2FjaGVMaW1pdCBlc3QgdHJvcCBncmFuZCwgZm9yY8OpIMOgICVkIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjM0MjAKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzQwNAogbXNnaWQgIi0tbWF4LXBhY2stc2l6ZSBjYW5ub3QgYmUgdXNlZCB0byBidWlsZCBhIHBhY2sgZm9yIHRyYW5zZmVyIgogbXNnc3RyICIiCiAiLS1tYXgtcGFjay1zaXplIG5lIHBldXQgcGFzIMOqdHJlIHV0aWxpc8OpIHBvdXIgY29uc3RydWlyZSB1biBwYXF1ZXQgw6AgIgogInRyYW5zZsOpcmVyIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjM0MjIKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzQwNgogbXNnaWQgIm1pbmltdW0gcGFjayBzaXplIGxpbWl0IGlzIDEgTWlCIgogbXNnc3RyICJsYSB0YWlsbGUgbGltaXRlIG1pbmltYWxlIGQndW4gcGFxdWV0IGVzdCAxIE1pQiIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozNDI3CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjM0MTEKIG1zZ2lkICItLXRoaW4gY2Fubm90IGJlIHVzZWQgdG8gYnVpbGQgYW4gaW5kZXhhYmxlIHBhY2siCiBtc2dzdHIgIi0tdGhpbiBuZSBwZXV0IHBhcyDDqnRyZSB1dGlsaXPDqSBwb3VyIGNvbnN0cnVpcmUgdW4gcGFxdWV0IGluZGV4YWJsZSIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozNDMwCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjM0MTQKIG1zZ2lkICItLWtlZXAtdW5yZWFjaGFibGUgYW5kIC0tdW5wYWNrLXVucmVhY2hhYmxlIGFyZSBpbmNvbXBhdGlibGUiCiBtc2dzdHIgIi0ta2VlcC11bnJlYWNoYWJsZSBldCAtLXVucGFjay11bnJlYWNoYWJsZSBzb250IGluY29tcGF0aWJsZXMiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzQzNgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozNDIwCiBtc2dpZCAiY2Fubm90IHVzZSAtLWZpbHRlciB3aXRob3V0IC0tc3Rkb3V0IgogbXNnc3RyICJpbXBvc3NpYmxlIGQndXRpbGlzZXIgLS1maWx0ZXIgc2FucyAtLXN0ZG91dCIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozNDk3CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjM0ODEKIG1zZ2lkICJFbnVtZXJhdGluZyBvYmplY3RzIgogbXNnc3RyICLDiW51bcOpcmF0aW9uIGRlcyBvYmpldHMiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzUyNworIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozNTExCiAjLCBjLWZvcm1hdAogbXNnaWQgIlRvdGFsICU8UFJJdTMyPiAoZGVsdGEgJTxQUkl1MzI+KSwgcmV1c2VkICU8UFJJdTMyPiAoZGVsdGEgJTxQUkl1MzI+KSIKIG1zZ3N0ciAiIgpAQCAtMTY3MzUsNDQgKzE2ODE4LDQ0IEBACiBtc2dpZCAiZ2l0IHB1bGwgWzxvcHRpb25zPl0gWzxyZXBvc2l0b3J5PiBbPHJlZnNwZWM+Li4uXV0iCiBtc2dzdHIgImdpdCBwdWxsIFs8b3B0aW9ucz5dIFs8ZMOpcMO0dD4gWzxzcMOpY2lmaWNhdGlvbi1kZS1yw6lmw6lyZW5jZT4uLi5dXSIKIAotIzogYnVpbHRpbi9wdWxsLmM6MTQxCisjOiBidWlsdGluL3B1bGwuYzoxNDIKIG1zZ2lkICJjb250cm9sIGZvciByZWN1cnNpdmUgZmV0Y2hpbmcgb2Ygc3VibW9kdWxlcyIKIG1zZ3N0ciAiY29udHLDtGxlciBsYSByw6ljdXDDqXJhdGlvbiByw6ljdXJzaXZlIGRhbnMgbGVzIHNvdXMtbW9kdWxlcyIKIAotIzogYnVpbHRpbi9wdWxsLmM6MTQ1CisjOiBidWlsdGluL3B1bGwuYzoxNDYKIG1zZ2lkICJPcHRpb25zIHJlbGF0ZWQgdG8gbWVyZ2luZyIKIG1zZ3N0ciAiT3B0aW9ucyByZWxhdGl2ZXMgw6AgbGEgZnVzaW9uIgogCi0jOiBidWlsdGluL3B1bGwuYzoxNDgKKyM6IGJ1aWx0aW4vcHVsbC5jOjE0OQogbXNnaWQgImluY29ycG9yYXRlIGNoYW5nZXMgYnkgcmViYXNpbmcgcmF0aGVyIHRoYW4gbWVyZ2luZyIKIG1zZ3N0ciAiaW5jb3Jwb3JlciBsZXMgbW9kaWZpY2F0aW9ucyBlbiByZWJhc2FudCBwbHV0w7R0IHF1J2VuIGZ1c2lvbm5hbnQiCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjE3NiBidWlsdGluL3JlYmFzZS5jOjQ0NyBidWlsdGluL3JldmVydC5jOjEyNgorIzogYnVpbHRpbi9wdWxsLmM6MTc3IGJ1aWx0aW4vcmViYXNlLmM6NDQ4IGJ1aWx0aW4vcmV2ZXJ0LmM6MTI2CiBtc2dpZCAiYWxsb3cgZmFzdC1mb3J3YXJkIgogbXNnc3RyICJhdXRvcmlzZXIgbCdhdmFuY2UgcmFwaWRlIgogCi0jOiBidWlsdGluL3B1bGwuYzoxODUKKyM6IGJ1aWx0aW4vcHVsbC5jOjE4NgogbXNnaWQgImF1dG9tYXRpY2FsbHkgc3Rhc2gvc3Rhc2ggcG9wIGJlZm9yZSBhbmQgYWZ0ZXIgcmViYXNlIgogbXNnc3RyICJyZW1pc2VyIGF2YW50IGV0IHLDqWFwcGxpcXVlciBhcHLDqHMgbGUgcmViYXNhZ2UgYXV0b21hdGlxdWVtZW50IgogCi0jOiBidWlsdGluL3B1bGwuYzoyMDEKKyM6IGJ1aWx0aW4vcHVsbC5jOjIwMgogbXNnaWQgIk9wdGlvbnMgcmVsYXRlZCB0byBmZXRjaGluZyIKIG1zZ3N0ciAiT3B0aW9ucyByZWxhdGl2ZXMgYXUgcmFwYXRyaWVtZW50IgogCi0jOiBidWlsdGluL3B1bGwuYzoyMTEKKyM6IGJ1aWx0aW4vcHVsbC5jOjIxMgogbXNnaWQgImZvcmNlIG92ZXJ3cml0ZSBvZiBsb2NhbCBicmFuY2giCiBtc2dzdHIgImZvcmNlciBsJ8OpY3Jhc2VtZW50IGRlIGxhIGJyYW5jaGUgbG9jYWxlIgogCi0jOiBidWlsdGluL3B1bGwuYzoyMTkKKyM6IGJ1aWx0aW4vcHVsbC5jOjIyMAogbXNnaWQgIm51bWJlciBvZiBzdWJtb2R1bGVzIHB1bGxlZCBpbiBwYXJhbGxlbCIKIG1zZ3N0ciAibm9tYnJlIGRlIHNvdXMtbW9kdWxlcyB0aXLDqXMgZW4gcGFyYWxsw6hsZSIKIAotIzogYnVpbHRpbi9wdWxsLmM6MzE2CisjOiBidWlsdGluL3B1bGwuYzozMjAKICMsIGMtZm9ybWF0CiBtc2dpZCAiSW52YWxpZCB2YWx1ZSBmb3IgcHVsbC5mZjogJXMiCiBtc2dzdHIgIlZhbGV1ciBpbnZhbGlkZSBwb3VyIHB1bGwuZmYgOiAlcyIKIAotIzogYnVpbHRpbi9wdWxsLmM6NDMzCisjOiBidWlsdGluL3B1bGwuYzo0MzcKIG1zZ2lkICIiCiAiVGhlcmUgaXMgbm8gY2FuZGlkYXRlIGZvciByZWJhc2luZyBhZ2FpbnN0IGFtb25nIHRoZSByZWZzIHRoYXQgeW91IGp1c3QgIgogImZldGNoZWQuIgpAQCAtMTY3ODAsMTQgKzE2ODYzLDE0IEBACiAiSWwgbid5IGEgcGFzIGRlIGNhbmRpZGF0ZSBzdXIgbGFxdWVsbGUgcmViYXNlciBwYXJtaSBsZXMgcsOpZsOpcmVuY2VzIHF1ZSB2b3VzICIKICJ2ZW5leiBkZSByw6ljdXDDqXJlci4iCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjQzNQorIzogYnVpbHRpbi9wdWxsLmM6NDM5CiBtc2dpZCAiIgogIlRoZXJlIGFyZSBubyBjYW5kaWRhdGVzIGZvciBtZXJnaW5nIGFtb25nIHRoZSByZWZzIHRoYXQgeW91IGp1c3QgZmV0Y2hlZC4iCiBtc2dzdHIgIiIKICJJbCBuJ3kgYSBwYXMgZGUgY2FuZGlkYXRlIGF2ZWMgbGFxdWVsbGUgZnVzaW9ubmVyIHBhcm1pIGxlcyByw6lmw6lyZW5jZXMgcXVlICIKICJ2b3VzIHZlbmV6IGRlIHLDqWN1cMOpcmVyLiIKIAotIzogYnVpbHRpbi9wdWxsLmM6NDM2CisjOiBidWlsdGluL3B1bGwuYzo0NDAKIG1zZ2lkICIiCiAiR2VuZXJhbGx5IHRoaXMgbWVhbnMgdGhhdCB5b3UgcHJvdmlkZWQgYSB3aWxkY2FyZCByZWZzcGVjIHdoaWNoIGhhZCBub1xuIgogIm1hdGNoZXMgb24gdGhlIHJlbW90ZSBlbmQuIgpAQCAtMTY3OTUsNyArMTY4NzgsNyBAQAogIkfDqW7DqXJhbGVtZW50LCBjZWxhIHNpZ25pZmllIHF1ZSB2b3VzIGF2ZXogaW5kaXF1w6kgdW4gc3DDqWNpZmljYXRldXJcbiIKICJkZSByw6lmw6lyZW5jZSBqb2tlciBxdWkgbidhIHBhcyBldSBkZSBjb3JyZXNwb25kYW5jZSBzdXIgbGUgc2VydmV1ciBkaXN0YW50LiIKIAotIzogYnVpbHRpbi9wdWxsLmM6NDM5CisjOiBidWlsdGluL3B1bGwuYzo0NDMKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIllvdSBhc2tlZCB0byBwdWxsIGZyb20gdGhlIHJlbW90ZSAnJXMnLCBidXQgZGlkIG5vdCBzcGVjaWZ5XG4iCkBAIC0xNjgwNyw0NCArMTY4OTAsNDQgQEAKICJjb25maWd1cmF0aW9uXG4iCiAicG91ciBsYSBicmFuY2hlIGFjdHVlbGxlLCB2b3VzIGRldmV6IHNww6ljaWZpZXIgbGEgYnJhbmNoZSBhdmVjIGxhIGNvbW1hbmRlLiIKIAotIzogYnVpbHRpbi9wdWxsLmM6NDQ0IGJ1aWx0aW4vcmViYXNlLmM6MTMyNiBnaXQtcGFyc2UtcmVtb3RlLnNoOjczCisjOiBidWlsdGluL3B1bGwuYzo0NDggYnVpbHRpbi9yZWJhc2UuYzoxMzQ3IGdpdC1wYXJzZS1yZW1vdGUuc2g6NzMKIG1zZ2lkICJZb3UgYXJlIG5vdCBjdXJyZW50bHkgb24gYSBicmFuY2guIgogbXNnc3RyICJWb3VzIG4nw6p0ZXMgYWN0dWVsbGVtZW50IHN1ciBhdWN1bmUgYnJhbmNoZS4iCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjQ0NiBidWlsdGluL3B1bGwuYzo0NjEgZ2l0LXBhcnNlLXJlbW90ZS5zaDo3OQorIzogYnVpbHRpbi9wdWxsLmM6NDUwIGJ1aWx0aW4vcHVsbC5jOjQ2NSBnaXQtcGFyc2UtcmVtb3RlLnNoOjc5CiBtc2dpZCAiUGxlYXNlIHNwZWNpZnkgd2hpY2ggYnJhbmNoIHlvdSB3YW50IHRvIHJlYmFzZSBhZ2FpbnN0LiIKIG1zZ3N0ciAiVmV1aWxsZXogc3DDqWNpZmllciBzdXIgcXVlbGxlIGJyYW5jaGUgdm91cyBzb3VoYWl0ZXIgcmViYXNlci4iCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjQ0OCBidWlsdGluL3B1bGwuYzo0NjMgZ2l0LXBhcnNlLXJlbW90ZS5zaDo4MgorIzogYnVpbHRpbi9wdWxsLmM6NDUyIGJ1aWx0aW4vcHVsbC5jOjQ2NyBnaXQtcGFyc2UtcmVtb3RlLnNoOjgyCiBtc2dpZCAiUGxlYXNlIHNwZWNpZnkgd2hpY2ggYnJhbmNoIHlvdSB3YW50IHRvIG1lcmdlIHdpdGguIgogbXNnc3RyICJWZXVpbGxleiBzcMOpY2lmaWVyIHVuZSBicmFuY2hlIGF2ZWMgbGFxdWVsbGUgZnVzaW9ubmVyLiIKIAotIzogYnVpbHRpbi9wdWxsLmM6NDQ5IGJ1aWx0aW4vcHVsbC5jOjQ2NAorIzogYnVpbHRpbi9wdWxsLmM6NDUzIGJ1aWx0aW4vcHVsbC5jOjQ2OAogbXNnaWQgIlNlZSBnaXQtcHVsbCgxKSBmb3IgZGV0YWlscy4iCiBtc2dzdHIgIlLDqWbDqXJlei12b3VzIMOgIGdpdC1wdWxsKDEpIHBvdXIgZGUgcGx1cyBhbXBsZXMgZMOpdGFpbHMuIgogCi0jOiBidWlsdGluL3B1bGwuYzo0NTEgYnVpbHRpbi9wdWxsLmM6NDU3IGJ1aWx0aW4vcHVsbC5jOjQ2NgotIzogYnVpbHRpbi9yZWJhc2UuYzoxMzMyIGdpdC1wYXJzZS1yZW1vdGUuc2g6NjQKKyM6IGJ1aWx0aW4vcHVsbC5jOjQ1NSBidWlsdGluL3B1bGwuYzo0NjEgYnVpbHRpbi9wdWxsLmM6NDcwCisjOiBidWlsdGluL3JlYmFzZS5jOjEzNTMgZ2l0LXBhcnNlLXJlbW90ZS5zaDo2NAogbXNnaWQgIjxyZW1vdGU+IgogbXNnc3RyICI8ZGlzdGFudD4iCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjQ1MSBidWlsdGluL3B1bGwuYzo0NjYgYnVpbHRpbi9wdWxsLmM6NDcxCisjOiBidWlsdGluL3B1bGwuYzo0NTUgYnVpbHRpbi9wdWxsLmM6NDcwIGJ1aWx0aW4vcHVsbC5jOjQ3NQogIzogZ2l0LXBhcnNlLXJlbW90ZS5zaDo2NQogbXNnaWQgIjxicmFuY2g+IgogbXNnc3RyICI8YnJhbmNoZT4iCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjQ1OSBidWlsdGluL3JlYmFzZS5jOjEzMjQgZ2l0LXBhcnNlLXJlbW90ZS5zaDo3NQorIzogYnVpbHRpbi9wdWxsLmM6NDYzIGJ1aWx0aW4vcmViYXNlLmM6MTM0NSBnaXQtcGFyc2UtcmVtb3RlLnNoOjc1CiBtc2dpZCAiVGhlcmUgaXMgbm8gdHJhY2tpbmcgaW5mb3JtYXRpb24gZm9yIHRoZSBjdXJyZW50IGJyYW5jaC4iCiBtc2dzdHIgIlBhcyBkJ2luZm9ybWF0aW9uIGRlIHN1aXZpIGRpc3RhbnQgcG91ciBsYSBicmFuY2hlIGFjdHVlbGxlLiIKIAotIzogYnVpbHRpbi9wdWxsLmM6NDY4IGdpdC1wYXJzZS1yZW1vdGUuc2g6OTUKKyM6IGJ1aWx0aW4vcHVsbC5jOjQ3MiBnaXQtcGFyc2UtcmVtb3RlLnNoOjk1CiBtc2dpZCAiIgogIklmIHlvdSB3aXNoIHRvIHNldCB0cmFja2luZyBpbmZvcm1hdGlvbiBmb3IgdGhpcyBicmFuY2ggeW91IGNhbiBkbyBzbyB3aXRoOiIKIG1zZ3N0ciAiIgogIlNpIHZvdXMgc291aGFpdGV6IGluZGlxdWVyIGwnaW5mb3JtYXRpb24gZGUgc3VpdmkgZGlzdGFudCBwb3VyIGNldHRlICIKICJicmFuY2hlLCB2b3VzIHBvdXZleiBsZSBmYWlyZSBhdmVjwqA6IgogCi0jOiBidWlsdGluL3B1bGwuYzo0NzMKKyM6IGJ1aWx0aW4vcHVsbC5jOjQ3NwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiWW91ciBjb25maWd1cmF0aW9uIHNwZWNpZmllcyB0byBtZXJnZSB3aXRoIHRoZSByZWYgJyVzJ1xuIgpAQCAtMTY4NTQsMzQgKzE2OTM3LDM0IEBACiAiJyVzJ1xuIgogImR1IHNlcnZldXIgZGlzdGFudCwgbWFpcyBjZXR0ZSByw6lmw6lyZW5jZSBuJ2EgcGFzIMOpdMOpIHLDqWN1cMOpcsOpZS4iCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjU4MQorIzogYnVpbHRpbi9wdWxsLmM6NTg3CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBhY2Nlc3MgY29tbWl0ICVzIgogbXNnc3RyICJpbXBvc3NpYmxlIGQnYWNjw6lkZXIgbGUgY29tbWl0ICVzIgogCi0jOiBidWlsdGluL3B1bGwuYzo4NjEKKyM6IGJ1aWx0aW4vcHVsbC5jOjg2NwogbXNnaWQgImlnbm9yaW5nIC0tdmVyaWZ5LXNpZ25hdHVyZXMgZm9yIHJlYmFzZSIKIG1zZ3N0ciAiLS12ZXJpZnktc2lnbmF0dXJlcyBlc3QgaWdub3LDqSBwb3VyIHVuIHJlYmFzYWdlIgogCi0jOiBidWlsdGluL3B1bGwuYzo5MTYKKyM6IGJ1aWx0aW4vcHVsbC5jOjkyMgogbXNnaWQgIi0tW25vLV1hdXRvc3Rhc2ggb3B0aW9uIGlzIG9ubHkgdmFsaWQgd2l0aCAtLXJlYmFzZS4iCiBtc2dzdHIgImwnb3B0aW9uIC0tW25vLV1hdXRvc3Rhc2ggbidlc3QgdmFsaWRlIHF1J2F2ZWMgLS1yZWJhc2UuIgogCi0jOiBidWlsdGluL3B1bGwuYzo5MjQKKyM6IGJ1aWx0aW4vcHVsbC5jOjkzMAogbXNnaWQgIlVwZGF0aW5nIGFuIHVuYm9ybiBicmFuY2ggd2l0aCBjaGFuZ2VzIGFkZGVkIHRvIHRoZSBpbmRleC4iCiBtc2dzdHIgIiIKICJNaXNlIMOgIGpvdXIgZCd1bmUgYnJhbmNoZSBub24gZW5jb3JlIGNyw6nDqWUgYXZlYyBsZXMgY2hhbmdlbWVudHMgYWpvdXTDqXMgZGFucyAiCiAibCdpbmRleC4iCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjkyOAorIzogYnVpbHRpbi9wdWxsLmM6OTM0CiBtc2dpZCAicHVsbCB3aXRoIHJlYmFzZSIKIG1zZ3N0ciAidGlyZXIgYXZlYyB1biByZWJhc2FnZSIKIAotIzogYnVpbHRpbi9wdWxsLmM6OTI5CisjOiBidWlsdGluL3B1bGwuYzo5MzUKIG1zZ2lkICJwbGVhc2UgY29tbWl0IG9yIHN0YXNoIHRoZW0uIgogbXNnc3RyICJ2ZXVpbGxleiBsZXMgdmFsaWRlciBvdSBsZXMgcmVtaXNlci4iCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjk1NAorIzogYnVpbHRpbi9wdWxsLmM6OTYwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJmZXRjaCB1cGRhdGVkIHRoZSBjdXJyZW50IGJyYW5jaCBoZWFkLlxuIgpAQCAtMTY4OTIsNyArMTY5NzUsNyBAQAogImF2YW5jZSByYXBpZGUgZGUgdm90cmUgY29waWUgZGUgdHJhdmFpbFxuIgogImRlcHVpcyBsZSBjb21taXQgJXMuIgogCi0jOiBidWlsdGluL3B1bGwuYzo5NjAKKyM6IGJ1aWx0aW4vcHVsbC5jOjk2NgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiQ2Fubm90IGZhc3QtZm9yd2FyZCB5b3VyIHdvcmtpbmcgdHJlZS5cbiIKQEAgLTE2OTA5LDE1ICsxNjk5MiwxNSBAQAogIiQgZ2l0IHJlc2V0IC0taGFyZFxuIgogInBvdXIgcsOpZ8OpbsOpcmVyLiIKIAotIzogYnVpbHRpbi9wdWxsLmM6OTc1CisjOiBidWlsdGluL3B1bGwuYzo5ODEKIG1zZ2lkICJDYW5ub3QgbWVyZ2UgbXVsdGlwbGUgYnJhbmNoZXMgaW50byBlbXB0eSBoZWFkLiIKIG1zZ3N0ciAiSW1wb3NzaWJsZSBkZSBmdXNpb25uZXIgZGUgbXVsdGlwbGVzIGJyYW5jaGVzIHN1ciB1bmUgdMOqdGUgdmlkZS4iCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjk3OQorIzogYnVpbHRpbi9wdWxsLmM6OTg1CiBtc2dpZCAiQ2Fubm90IHJlYmFzZSBvbnRvIG11bHRpcGxlIGJyYW5jaGVzLiIKIG1zZ3N0ciAiSW1wb3NzaWJsZSBkZSByZWJhc2VyIHN1ciBkZSBtdWx0aXBsZXMgYnJhbmNoZXMuIgogCi0jOiBidWlsdGluL3B1bGwuYzo5ODYKKyM6IGJ1aWx0aW4vcHVsbC5jOjk5MgogbXNnaWQgImNhbm5vdCByZWJhc2Ugd2l0aCBsb2NhbGx5IHJlY29yZGVkIHN1Ym1vZHVsZSBtb2RpZmljYXRpb25zIgogbXNnc3RyICIiCiAiaW1wb3NzaWJsZSBkZSByZWJhc2VyIGF2ZWMgZGVzIG1vZGlmaWNhdGlvbnMgZGUgc291cy1tb2R1bGVzIGVucmVnaXN0csOpZXMgIgpAQCAtMTcwOTMsMTcgKzE3MTc2LDk1IEBACiBtc2dpZCAiUHVzaGluZyB0byAlc1xuIgogbXNnc3RyICJQb3Vzc8OpZSB2ZXJzICVzXG4iCiAKLSM6IGJ1aWx0aW4vcHVzaC5jOjM2NAorIzogYnVpbHRpbi9wdXNoLmM6MzY2CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBwdXNoIHNvbWUgcmVmcyB0byAnJXMnIgogbXNnc3RyICJpbXBvc3NpYmxlIGRlIHBvdXNzZXIgZGVzIHLDqWbDqXJlbmNlcyB2ZXJzICclcyciCiAKLSM6IGJ1aWx0aW4vcHVzaC5jOjM5OAorIzogYnVpbHRpbi9wdXNoLmM6NTQxCittc2dpZCAicmVwb3NpdG9yeSIKK21zZ3N0ciAiZMOpcMO0dCIKKworIzogYnVpbHRpbi9wdXNoLmM6NTQyIGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTY0Cittc2dpZCAicHVzaCBhbGwgcmVmcyIKK21zZ3N0ciAicG91c3NlciB0b3V0ZXMgbGVzIHLDqWbDqXJlbmNlcyIKKworIzogYnVpbHRpbi9wdXNoLmM6NTQzIGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTY2Cittc2dpZCAibWlycm9yIGFsbCByZWZzIgorbXNnc3RyICJyZWZsw6l0ZXIgdG91dGVzIGxlcyByw6lmw6lyZW5jZXMiCisKKyM6IGJ1aWx0aW4vcHVzaC5jOjU0NQorbXNnaWQgImRlbGV0ZSByZWZzIgorbXNnc3RyICJzdXBwcmltZXIgbGVzIHLDqWbDqXJlbmNlcyIKKworIzogYnVpbHRpbi9wdXNoLmM6NTQ2Cittc2dpZCAicHVzaCB0YWdzIChjYW4ndCBiZSB1c2VkIHdpdGggLS1hbGwgb3IgLS1taXJyb3IpIgorbXNnc3RyICIiCisicG91c3NlciBsZXMgw6l0aXF1ZXR0ZXMgKG5lIHBldXQgcGFzIMOqdHJlIHV0aWxpc8OpIGF2ZWMgLS1hbGwgb3UgLS1taXJyb3IpIgorCisjOiBidWlsdGluL3B1c2guYzo1NDkgYnVpbHRpbi9zZW5kLXBhY2suYzoxNjcKK21zZ2lkICJmb3JjZSB1cGRhdGVzIgorbXNnc3RyICJmb3JjZXIgbGVzIG1pc2VzIMOgIGpvdXIiCisKKyM6IGJ1aWx0aW4vcHVzaC5jOjU1MSBidWlsdGluL3NlbmQtcGFjay5jOjE4MQorbXNnaWQgIjxyZWZuYW1lPjo8ZXhwZWN0PiIKK21zZ3N0ciAiPG5vbS1kZS1yZWY+OjxhdHRlbmR1PiIKKworIzogYnVpbHRpbi9wdXNoLmM6NTUyIGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTgyCittc2dpZCAicmVxdWlyZSBvbGQgdmFsdWUgb2YgcmVmIHRvIGJlIGF0IHRoaXMgdmFsdWUiCittc2dzdHIgImV4aWdlciBxdWUgbCdhbmNpZW5uZSB2YWxldXIgZGUgbGEgcsOpZsOpcmVuY2Ugc29pdCDDoCBjZXR0ZSB2YWxldXIiCisKKyM6IGJ1aWx0aW4vcHVzaC5jOjU1NQorbXNnaWQgImNvbnRyb2wgcmVjdXJzaXZlIHB1c2hpbmcgb2Ygc3VibW9kdWxlcyIKK21zZ3N0ciAiY29udHLDtGxlciBsYSBwb3Vzc8OpZSByw6ljdXJzaXZlIGRlcyBzb3VzLW1vZHVsZXMiCisKKyM6IGJ1aWx0aW4vcHVzaC5jOjU1NyBidWlsdGluL3NlbmQtcGFjay5jOjE3NQorbXNnaWQgInVzZSB0aGluIHBhY2siCittc2dzdHIgInV0aWxpc2VyIHVuIGVtcGFxdWV0YWdlIGzDqWdlciIKKworIzogYnVpbHRpbi9wdXNoLmM6NTU4IGJ1aWx0aW4vcHVzaC5jOjU1OSBidWlsdGluL3NlbmQtcGFjay5jOjE2MQorIzogYnVpbHRpbi9zZW5kLXBhY2suYzoxNjIKK21zZ2lkICJyZWNlaXZlIHBhY2sgcHJvZ3JhbSIKK21zZ3N0ciAicmVjZXZvaXIgbGUgcHJvZ3JhbW1lIGQnZW1wYXF1ZXRhZ2UiCisKKyM6IGJ1aWx0aW4vcHVzaC5jOjU2MAorbXNnaWQgInNldCB1cHN0cmVhbSBmb3IgZ2l0IHB1bGwvc3RhdHVzIgorbXNnc3RyICJkw6lmaW5pciBsYSBicmFuY2hlIGFtb250IHBvdXIgZ2l0IHB1bGwvc3RhdHVzIgorCisjOiBidWlsdGluL3B1c2guYzo1NjMKK21zZ2lkICJwcnVuZSBsb2NhbGx5IHJlbW92ZWQgcmVmcyIKK21zZ3N0ciAiw6lsaW1pbmVyIGxlcyByw6lmw6lyZW5jZXMgbG9jYWxlcyBzdXBwcmltw6llcyIKKworIzogYnVpbHRpbi9wdXNoLmM6NTY1Cittc2dpZCAiYnlwYXNzIHByZS1wdXNoIGhvb2siCittc2dzdHIgIsOpdml0ZXIgZCd1dGlsaXNlciBsZSBjcm9jaGV0IHByZS1wdXNoIgorCisjOiBidWlsdGluL3B1c2guYzo1NjYKK21zZ2lkICJwdXNoIG1pc3NpbmcgYnV0IHJlbGV2YW50IHRhZ3MiCittc2dzdHIgInBvdXNzZXIgbGVzIMOpdGlxdWV0dGVzIG1hbnF1YW50ZXMgbWFpcyBwZXJ0aW5lbnRlcyIKKworIzogYnVpbHRpbi9wdXNoLmM6NTY5IGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTY5Cittc2dpZCAiR1BHIHNpZ24gdGhlIHB1c2giCittc2dzdHIgInNpZ25lciBsYSBwb3Vzc8OpZSBhdmVjIEdQRyIKKworIzogYnVpbHRpbi9wdXNoLmM6NTcxIGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTc2Cittc2dpZCAicmVxdWVzdCBhdG9taWMgdHJhbnNhY3Rpb24gb24gcmVtb3RlIHNpZGUiCittc2dzdHIgImRlbWFuZGUgdW5lIHRyYW5zYWN0aW9uIGF0b21pcXVlIHN1ciBsZSBzZXJ2ZXVyIGRpc3RhbnQiCisKKyM6IGJ1aWx0aW4vcHVzaC5jOjU4OQorbXNnaWQgIi0tZGVsZXRlIGlzIGluY29tcGF0aWJsZSB3aXRoIC0tYWxsLCAtLW1pcnJvciBhbmQgLS10YWdzIgorbXNnc3RyICItLWRlbGV0ZSBlc3QgaW5jb21wYXRpYmxlIGF2ZWMgLS1hbGwsIC0tbWlycm9yIGV0IC0tdGFncyIKKworIzogYnVpbHRpbi9wdXNoLmM6NTkxCittc2dpZCAiLS1kZWxldGUgZG9lc24ndCBtYWtlIHNlbnNlIHdpdGhvdXQgYW55IHJlZnMiCittc2dzdHIgIi0tZGVsZXRlIG4nYSBwYXMgZGUgc2VucyBzYW5zIGF1Y3VuZSByw6lmw6lyZW5jZSIKKworIzogYnVpbHRpbi9wdXNoLmM6NjExCiAjLCBjLWZvcm1hdAogbXNnaWQgImJhZCByZXBvc2l0b3J5ICclcyciCiBtc2dzdHIgIm1hdXZhaXMgZMOpcMO0dCAnJXMnIgogCi0jOiBidWlsdGluL3B1c2guYzozOTkKKyM6IGJ1aWx0aW4vcHVzaC5jOjYxMgogbXNnaWQgIiIKICJObyBjb25maWd1cmVkIHB1c2ggZGVzdGluYXRpb24uXG4iCiAiRWl0aGVyIHNwZWNpZnkgdGhlIFVSTCBmcm9tIHRoZSBjb21tYW5kLWxpbmUgb3IgY29uZmlndXJlIGEgcmVtb3RlICIKQEAgLTE3MTI1LDEwNSArMTcyODYsMjcgQEAKICJcbiIKICIgICAgZ2l0IHB1c2ggPG5vbT5cbiIKIAotIzogYnVpbHRpbi9wdXNoLmM6NTU0Ci1tc2dpZCAicmVwb3NpdG9yeSIKLW1zZ3N0ciAiZMOpcMO0dCIKLQotIzogYnVpbHRpbi9wdXNoLmM6NTU1IGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTY0Ci1tc2dpZCAicHVzaCBhbGwgcmVmcyIKLW1zZ3N0ciAicG91c3NlciB0b3V0ZXMgbGVzIHLDqWbDqXJlbmNlcyIKLQotIzogYnVpbHRpbi9wdXNoLmM6NTU2IGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTY2Ci1tc2dpZCAibWlycm9yIGFsbCByZWZzIgotbXNnc3RyICJyZWZsw6l0ZXIgdG91dGVzIGxlcyByw6lmw6lyZW5jZXMiCi0KLSM6IGJ1aWx0aW4vcHVzaC5jOjU1OAotbXNnaWQgImRlbGV0ZSByZWZzIgotbXNnc3RyICJzdXBwcmltZXIgbGVzIHLDqWbDqXJlbmNlcyIKLQotIzogYnVpbHRpbi9wdXNoLmM6NTU5Ci1tc2dpZCAicHVzaCB0YWdzIChjYW4ndCBiZSB1c2VkIHdpdGggLS1hbGwgb3IgLS1taXJyb3IpIgotbXNnc3RyICIiCi0icG91c3NlciBsZXMgw6l0aXF1ZXR0ZXMgKG5lIHBldXQgcGFzIMOqdHJlIHV0aWxpc8OpIGF2ZWMgLS1hbGwgb3UgLS1taXJyb3IpIgotCi0jOiBidWlsdGluL3B1c2guYzo1NjIgYnVpbHRpbi9zZW5kLXBhY2suYzoxNjcKLW1zZ2lkICJmb3JjZSB1cGRhdGVzIgotbXNnc3RyICJmb3JjZXIgbGVzIG1pc2VzIMOgIGpvdXIiCi0KLSM6IGJ1aWx0aW4vcHVzaC5jOjU2NCBidWlsdGluL3NlbmQtcGFjay5jOjE4MQotbXNnaWQgIjxyZWZuYW1lPjo8ZXhwZWN0PiIKLW1zZ3N0ciAiPG5vbS1kZS1yZWY+OjxhdHRlbmR1PiIKLQotIzogYnVpbHRpbi9wdXNoLmM6NTY1IGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTgyCi1tc2dpZCAicmVxdWlyZSBvbGQgdmFsdWUgb2YgcmVmIHRvIGJlIGF0IHRoaXMgdmFsdWUiCi1tc2dzdHIgImV4aWdlciBxdWUgbCdhbmNpZW5uZSB2YWxldXIgZGUgbGEgcsOpZsOpcmVuY2Ugc29pdCDDoCBjZXR0ZSB2YWxldXIiCi0KLSM6IGJ1aWx0aW4vcHVzaC5jOjU2OAotbXNnaWQgImNvbnRyb2wgcmVjdXJzaXZlIHB1c2hpbmcgb2Ygc3VibW9kdWxlcyIKLW1zZ3N0ciAiY29udHLDtGxlciBsYSBwb3Vzc8OpZSByw6ljdXJzaXZlIGRlcyBzb3VzLW1vZHVsZXMiCi0KLSM6IGJ1aWx0aW4vcHVzaC5jOjU3MCBidWlsdGluL3NlbmQtcGFjay5jOjE3NQotbXNnaWQgInVzZSB0aGluIHBhY2siCi1tc2dzdHIgInV0aWxpc2VyIHVuIGVtcGFxdWV0YWdlIGzDqWdlciIKLQotIzogYnVpbHRpbi9wdXNoLmM6NTcxIGJ1aWx0aW4vcHVzaC5jOjU3MiBidWlsdGluL3NlbmQtcGFjay5jOjE2MQotIzogYnVpbHRpbi9zZW5kLXBhY2suYzoxNjIKLW1zZ2lkICJyZWNlaXZlIHBhY2sgcHJvZ3JhbSIKLW1zZ3N0ciAicmVjZXZvaXIgbGUgcHJvZ3JhbW1lIGQnZW1wYXF1ZXRhZ2UiCi0KLSM6IGJ1aWx0aW4vcHVzaC5jOjU3MwotbXNnaWQgInNldCB1cHN0cmVhbSBmb3IgZ2l0IHB1bGwvc3RhdHVzIgotbXNnc3RyICJkw6lmaW5pciBsYSBicmFuY2hlIGFtb250IHBvdXIgZ2l0IHB1bGwvc3RhdHVzIgotCi0jOiBidWlsdGluL3B1c2guYzo1NzYKLW1zZ2lkICJwcnVuZSBsb2NhbGx5IHJlbW92ZWQgcmVmcyIKLW1zZ3N0ciAiw6lsaW1pbmVyIGxlcyByw6lmw6lyZW5jZXMgbG9jYWxlcyBzdXBwcmltw6llcyIKLQotIzogYnVpbHRpbi9wdXNoLmM6NTc4Ci1tc2dpZCAiYnlwYXNzIHByZS1wdXNoIGhvb2siCi1tc2dzdHIgIsOpdml0ZXIgZCd1dGlsaXNlciBsZSBjcm9jaGV0IHByZS1wdXNoIgotCi0jOiBidWlsdGluL3B1c2guYzo1NzkKLW1zZ2lkICJwdXNoIG1pc3NpbmcgYnV0IHJlbGV2YW50IHRhZ3MiCi1tc2dzdHIgInBvdXNzZXIgbGVzIMOpdGlxdWV0dGVzIG1hbnF1YW50ZXMgbWFpcyBwZXJ0aW5lbnRlcyIKLQotIzogYnVpbHRpbi9wdXNoLmM6NTgyIGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTY5Ci1tc2dpZCAiR1BHIHNpZ24gdGhlIHB1c2giCi1tc2dzdHIgInNpZ25lciBsYSBwb3Vzc8OpZSBhdmVjIEdQRyIKLQotIzogYnVpbHRpbi9wdXNoLmM6NTg0IGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTc2Ci1tc2dpZCAicmVxdWVzdCBhdG9taWMgdHJhbnNhY3Rpb24gb24gcmVtb3RlIHNpZGUiCi1tc2dzdHIgImRlbWFuZGUgdW5lIHRyYW5zYWN0aW9uIGF0b21pcXVlIHN1ciBsZSBzZXJ2ZXVyIGRpc3RhbnQiCi0KLSM6IGJ1aWx0aW4vcHVzaC5jOjYwMgotbXNnaWQgIi0tZGVsZXRlIGlzIGluY29tcGF0aWJsZSB3aXRoIC0tYWxsLCAtLW1pcnJvciBhbmQgLS10YWdzIgotbXNnc3RyICItLWRlbGV0ZSBlc3QgaW5jb21wYXRpYmxlIGF2ZWMgLS1hbGwsIC0tbWlycm9yIGV0IC0tdGFncyIKLQotIzogYnVpbHRpbi9wdXNoLmM6NjA0Ci1tc2dpZCAiLS1kZWxldGUgZG9lc24ndCBtYWtlIHNlbnNlIHdpdGhvdXQgYW55IHJlZnMiCi1tc2dzdHIgIi0tZGVsZXRlIG4nYSBwYXMgZGUgc2VucyBzYW5zIGF1Y3VuZSByw6lmw6lyZW5jZSIKLQotIzogYnVpbHRpbi9wdXNoLmM6NjA3CisjOiBidWlsdGluL3B1c2guYzo2MjcKIG1zZ2lkICItLWFsbCBhbmQgLS10YWdzIGFyZSBpbmNvbXBhdGlibGUiCiBtc2dzdHIgIi0tYWxsIGV0IC0tdGFncyBzb250IGluY29tcGF0aWJsZXMiCiAKLSM6IGJ1aWx0aW4vcHVzaC5jOjYwOQorIzogYnVpbHRpbi9wdXNoLmM6NjI5CiBtc2dpZCAiLS1hbGwgY2FuJ3QgYmUgY29tYmluZWQgd2l0aCByZWZzcGVjcyIKIG1zZ3N0ciAiLS1hbGwgbmUgcGV1dCBwYXMgw6p0cmUgY29tYmluw6kgYXZlYyBkZXMgc3DDqWNpZmljYXRpb25zIGRlIHLDqWbDqXJlbmNlIgogCi0jOiBidWlsdGluL3B1c2guYzo2MTMKKyM6IGJ1aWx0aW4vcHVzaC5jOjYzMwogbXNnaWQgIi0tbWlycm9yIGFuZCAtLXRhZ3MgYXJlIGluY29tcGF0aWJsZSIKIG1zZ3N0ciAiLS1taXJyb3IgZXQgLS10YWdzIHNvbnQgaW5jb21wYXRpYmxlcyIKIAotIzogYnVpbHRpbi9wdXNoLmM6NjE1CisjOiBidWlsdGluL3B1c2guYzo2MzUKIG1zZ2lkICItLW1pcnJvciBjYW4ndCBiZSBjb21iaW5lZCB3aXRoIHJlZnNwZWNzIgogbXNnc3RyICItLW1pcnJvciBuZSBwZXV0IHBhcyDDqnRyZSBjb21iaW7DqSBhdmVjIGRlcyBzcMOpY2lmaWNhdGlvbnMgZGUgcsOpZsOpcmVuY2UiCiAKLSM6IGJ1aWx0aW4vcHVzaC5jOjYxOAorIzogYnVpbHRpbi9wdXNoLmM6NjM4CiBtc2dpZCAiLS1hbGwgYW5kIC0tbWlycm9yIGFyZSBpbmNvbXBhdGlibGUiCiBtc2dzdHIgIi0tYWxsIGV0IC0tbWlycm9yIHNvbnQgaW5jb21wYXRpYmxlcyIKIAotIzogYnVpbHRpbi9wdXNoLmM6NjM3CisjOiBidWlsdGluL3B1c2guYzo2NDIKIG1zZ2lkICJwdXNoIG9wdGlvbnMgbXVzdCBub3QgaGF2ZSBuZXcgbGluZSBjaGFyYWN0ZXJzIgogbXNnc3RyICIiCiAibGVzIG9wdGlvbnMgZGUgcG91c3PDqWUgbmUgcGV1dmVudCBwYXMgY29udGVuaXIgZGUgY2FyYWN0w6hyZXMgZGUgbm91dmVsbGUgIgpAQCAtMTczNDUsMTEgKzE3NDI4LDExIEBACiAKICM6IGJ1aWx0aW4vcmViYXNlLmM6MzIKIG1zZ2lkICIiCi0iZ2l0IHJlYmFzZSBbLWldIFtvcHRpb25zXSBbLS1leGVjIDxjbWQ+XSBbLS1vbnRvIDxuZXdiYXNlPl0gWzx1cHN0cmVhbT5dICIKLSJbPGJyYW5jaD5dIgorImdpdCByZWJhc2UgWy1pXSBbb3B0aW9uc10gWy0tZXhlYyA8Y21kPl0gWy0tb250byA8bmV3YmFzZT4gfCAtLWtlZXAtYmFzZV0gIgorIls8dXBzdHJlYW0+IFs8YnJhbmNoPl1dIgogbXNnc3RyICIiCi0iZ2l0IHJlYmFzZSBbLWldIFtvcHRpb25zXSBbLS1leGVjIDxjbWQ+XSBbLS1vbnRvIDxub3V2ZWxsZS1iYXNlPl0gWzxhbW9udD5dICIKLSJbPGJyYW5jaGU+XSIKKyJnaXQgcmViYXNlIFstaV0gW29wdGlvbnNdIFstLWV4ZWMgPGNtZD5dIFstLW9udG8gPG5vdXZlbGxlLWJhc2U+IHwgLS1rZWVwLSIKKyJiYXNlXSBbPGFtb250PiBbPGJyYW5jaGU+XV0iCiAKICM6IGJ1aWx0aW4vcmViYXNlLmM6MzQKIG1zZ2lkICIiCkBAIC0xNzM4OSwxODkgKzE3NDcyLDE4OSBAQAogbXNnaWQgImNvdWxkIG5vdCBnZW5lcmF0ZSB0b2RvIGxpc3QiCiBtc2dzdHIgImltcG9zc2libGUgZGUgZ8OpbsOpcmVyIGxhIGxpc3RlIMOgLWZhaXJlIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjM4MgorIzogYnVpbHRpbi9yZWJhc2UuYzozODMKIG1zZ2lkICJhIGJhc2UgY29tbWl0IG11c3QgYmUgcHJvdmlkZWQgd2l0aCAtLXVwc3RyZWFtIG9yIC0tb250byIKIG1zZ3N0ciAidW4gY29tbWl0IGRlIGJhc2UgZG9pdCDDqnRyZSBmb3VybmkgYXZlYyAtLXVwc3RyZWFtIG91IC0tb250byIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0MzcKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDM4CiBtc2dpZCAiZ2l0IHJlYmFzZS0taW50ZXJhY3RpdmUgWzxvcHRpb25zPl0iCiBtc2dzdHIgImdpdCByZWJhc2UtLWludGVyYWN0aXZlIFs8b3B0aW9ucz5dIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ0OQorIzogYnVpbHRpbi9yZWJhc2UuYzo0NTAKIG1zZ2lkICJrZWVwIGVtcHR5IGNvbW1pdHMiCiBtc2dzdHIgImdhcmRlciBsZXMgdmFsaWRhdGlvbnMgdmlkZXMiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDUxIGJ1aWx0aW4vcmV2ZXJ0LmM6MTI4CisjOiBidWlsdGluL3JlYmFzZS5jOjQ1MiBidWlsdGluL3JldmVydC5jOjEyOAogbXNnaWQgImFsbG93IGNvbW1pdHMgd2l0aCBlbXB0eSBtZXNzYWdlcyIKIG1zZ3N0ciAiYXV0b3Jpc2VyIGxlcyB2YWxpZGF0aW9ucyBhdmVjIGRlcyBtZXNzYWdlcyB2aWRlcyIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0NTIKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDUzCiBtc2dpZCAicmViYXNlIG1lcmdlIGNvbW1pdHMiCiBtc2dzdHIgInJlYmFzZXIgbGVzIGNvbW1pdHMgZGUgZnVzaW9uIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ1NAorIzogYnVpbHRpbi9yZWJhc2UuYzo0NTUKIG1zZ2lkICJrZWVwIG9yaWdpbmFsIGJyYW5jaCBwb2ludHMgb2YgY291c2lucyIKIG1zZ3N0ciAiY29uc2VydmVyIGxlcyBwb2ludHMgZGUgYnJhbmNoZW1lbnQgZGUgY291c2lucyBvcmlnaW5hdXgiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDU2CisjOiBidWlsdGluL3JlYmFzZS5jOjQ1NwogbXNnaWQgIm1vdmUgY29tbWl0cyB0aGF0IGJlZ2luIHdpdGggc3F1YXNoIS9maXh1cCEiCiBtc2dzdHIgImTDqXBsYWNlciBsZXMgY29tbWl0cyBxdWkgY29tbWVuY2VudCBwYXIgc3F1YXNoIS9maXh1cCEiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDU3CisjOiBidWlsdGluL3JlYmFzZS5jOjQ1OAogbXNnaWQgInNpZ24gY29tbWl0cyIKIG1zZ3N0ciAic2lnbmVyIGxlcyBjb21taXRzIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ1OSBidWlsdGluL3JlYmFzZS5jOjE0MDMKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDYwIGJ1aWx0aW4vcmViYXNlLmM6MTQyNwogbXNnaWQgImRpc3BsYXkgYSBkaWZmc3RhdCBvZiB3aGF0IGNoYW5nZWQgdXBzdHJlYW0iCiBtc2dzdHIgImFmZmljaGVyIHVuIGRpZmZzdGF0IGRlIGNlIHF1aSBhIGNoYW5nw6kgZW4gYW1vbnQiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDYxCisjOiBidWlsdGluL3JlYmFzZS5jOjQ2MgogbXNnaWQgImNvbnRpbnVlIHJlYmFzZSIKIG1zZ3N0ciAiY29udGludWVyIGxlIHJlYmFzYWdlIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ2MworIzogYnVpbHRpbi9yZWJhc2UuYzo0NjQKIG1zZ2lkICJza2lwIGNvbW1pdCIKIG1zZ3N0ciAic2F1dGVyIGxlIGNvbW1pdCIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0NjQKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDY1CiBtc2dpZCAiZWRpdCB0aGUgdG9kbyBsaXN0IgogbXNnc3RyICLDqWRpdGVyIGxhIGxpc3RlIMOgLWZhaXJlIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ2NgorIzogYnVpbHRpbi9yZWJhc2UuYzo0NjcKIG1zZ2lkICJzaG93IHRoZSBjdXJyZW50IHBhdGNoIgogbXNnc3RyICJhZmZpY2hlciBsZSBwYXRjaCBjb3VyYW50IgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ2OQorIzogYnVpbHRpbi9yZWJhc2UuYzo0NzAKIG1zZ2lkICJzaG9ydGVuIGNvbW1pdCBpZHMgaW4gdGhlIHRvZG8gbGlzdCIKIG1zZ3N0ciAicmFjY291cmNpciBsZXMgaWRlbnRpZmlhbnRzIGRlIGNvbW1pdHMgZGFucyBsYSBsaXN0ZSDDoC1mYWlyZSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0NzEKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDcyCiBtc2dpZCAiZXhwYW5kIGNvbW1pdCBpZHMgaW4gdGhlIHRvZG8gbGlzdCIKIG1zZ3N0ciAiw6l0ZW5kcmUgbGVzIGlkZW50aWZpYW50cyBkZSBjb21taXQgZGFucyBsYSBsaXN0ZSDDoC1mYWlyZSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0NzMKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDc0CiBtc2dpZCAiY2hlY2sgdGhlIHRvZG8gbGlzdCIKIG1zZ3N0ciAidsOpcmlmaWVyIGxhIGxpc3RlIMOgLWZhaXJlIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ3NQorIzogYnVpbHRpbi9yZWJhc2UuYzo0NzYKIG1zZ2lkICJyZWFycmFuZ2UgZml4dXAvc3F1YXNoIGxpbmVzIgogbXNnc3RyICJyw6lhcnJhbmdlciBsZXMgbGlnbmVzIGZpeHVwL3NxdWFzaCIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0NzcKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDc4CiBtc2dpZCAiaW5zZXJ0IGV4ZWMgY29tbWFuZHMgaW4gdG9kbyBsaXN0IgogbXNnc3RyICJpbnPDqXJlciBsZXMgY29tbWFuZGVzIGV4ZWMgZGFucyBsYSBsaXN0ZSDDoC1mYWlyZSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0NzgKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDc5CiBtc2dpZCAib250byIKIG1zZ3N0ciAic3VyIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ4MQorIzogYnVpbHRpbi9yZWJhc2UuYzo0ODIKIG1zZ2lkICJyZXN0cmljdC1yZXZpc2lvbiIKIG1zZ3N0ciAicmVzdHJpY3QtcmV2aXNpb24iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDgxCisjOiBidWlsdGluL3JlYmFzZS5jOjQ4MgogbXNnaWQgInJlc3RyaWN0IHJldmlzaW9uIgogbXNnc3RyICJyZXN0cmVpbmRyZSBsYSByw6l2aXNpb24iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDgzCisjOiBidWlsdGluL3JlYmFzZS5jOjQ4NAogbXNnaWQgInNxdWFzaC1vbnRvIgogbXNnc3RyICLDqWNyYXNlci1zdXIiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDg0CisjOiBidWlsdGluL3JlYmFzZS5jOjQ4NQogbXNnaWQgInNxdWFzaCBvbnRvIgogbXNnc3RyICLDqWNyYXNlciBzdXIiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDg2CisjOiBidWlsdGluL3JlYmFzZS5jOjQ4NwogbXNnaWQgInRoZSB1cHN0cmVhbSBjb21taXQiCiBtc2dzdHIgImxlIGNvbW1pdCBhbW9udCIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0ODgKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDg5CiBtc2dpZCAiaGVhZC1uYW1lIgogbXNnc3RyICJub20gZHUgaGVhZCIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0ODgKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDg5CiBtc2dpZCAiaGVhZCBuYW1lIgogbXNnc3RyICJub20gZHUgaGVhZCIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0OTMKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDk0CiBtc2dpZCAicmViYXNlIHN0cmF0ZWd5IgogbXNnc3RyICJzdHJhdMOpZ2llIGRlIHJlYmFzYWdlIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ5NAorIzogYnVpbHRpbi9yZWJhc2UuYzo0OTUKIG1zZ2lkICJzdHJhdGVneS1vcHRzIgogbXNnc3RyICJvcHRpb25zIGRlIHN0cmF0w6lnaWUiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDk1CisjOiBidWlsdGluL3JlYmFzZS5jOjQ5NgogbXNnaWQgInN0cmF0ZWd5IG9wdGlvbnMiCiBtc2dzdHIgIm9wdGlvbnMgZGUgc3RyYXTDqWdpZSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0OTYKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDk3CiBtc2dpZCAic3dpdGNoLXRvIgogbXNnc3RyICJzd2l0Y2gtdG8iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDk3CisjOiBidWlsdGluL3JlYmFzZS5jOjQ5OAogbXNnaWQgInRoZSBicmFuY2ggb3IgY29tbWl0IHRvIGNoZWNrb3V0IgogbXNnc3RyICJsYSBicmFuY2hlIG91IGxlIGNvbW1pdCDDoCBleHRyYWlyZSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0OTgKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDk5CiBtc2dpZCAib250by1uYW1lIgogbXNnc3RyICJzdXItbGUtbm9tIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ5OAorIzogYnVpbHRpbi9yZWJhc2UuYzo0OTkKIG1zZ2lkICJvbnRvIG5hbWUiCiBtc2dzdHIgInN1ciBsZSBub20iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDk5CisjOiBidWlsdGluL3JlYmFzZS5jOjUwMAogbXNnaWQgImNtZCIKIG1zZ3N0ciAiY21kIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ5OQorIzogYnVpbHRpbi9yZWJhc2UuYzo1MDAKIG1zZ2lkICJ0aGUgY29tbWFuZCB0byBydW4iCiBtc2dzdHIgImxhIGNvbW1hbmRlIMOgIGxhbmNlciIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo1MDIgYnVpbHRpbi9yZWJhc2UuYzoxNDg2CisjOiBidWlsdGluL3JlYmFzZS5jOjUwMyBidWlsdGluL3JlYmFzZS5jOjE1MTAKIG1zZ2lkICJhdXRvbWF0aWNhbGx5IHJlLXNjaGVkdWxlIGFueSBgZXhlY2AgdGhhdCBmYWlscyIKIG1zZ3N0ciAicmUtcGxhbmlmaWVyIGF1dG9tYXRpcXVlbWVudCB0b3V0IGBleGVjYCBxdWkgw6ljaG91ZSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo1MTgKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NTE5CiBtc2dpZCAiLS1bbm8tXXJlYmFzZS1jb3VzaW5zIGhhcyBubyBlZmZlY3Qgd2l0aG91dCAtLXJlYmFzZS1tZXJnZXMiCiBtc2dzdHIgIi0tW25vLV1yZWJhc2UtY291c2lucyBuJ2EgYXVjdW4gZWZmZXQgc2FucyAtLXJlYmFzZS1tZXJnZXMiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NTM0CisjOiBidWlsdGluL3JlYmFzZS5jOjUzNQogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyByZXF1aXJlcyBhbiBpbnRlcmFjdGl2ZSByZWJhc2UiCiBtc2dzdHIgIiVzIHJlcXVpZXJ0IHVuIHJlYmFzYWdlIGludGVyYWN0aWYiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NTg2CisjOiBidWlsdGluL3JlYmFzZS5jOjU4NwogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgZ2V0ICdvbnRvJzogJyVzJyIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkJ2FjY8OpZGVyICdvbnRvJyA6ICclcyciCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NjAxCisjOiBidWlsdGluL3JlYmFzZS5jOjYwMgogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIG9yaWctaGVhZDogJyVzJyIKIG1zZ3N0ciAib3JpZy1oZWFkIGludmFsaWRlwqA6ICclcyciCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NjI2CisjOiBidWlsdGluL3JlYmFzZS5jOjYyNwogIywgYy1mb3JtYXQKIG1zZ2lkICJpZ25vcmluZyBpbnZhbGlkIGFsbG93X3JlcmVyZV9hdXRvdXBkYXRlOiAnJXMnIgogbXNnc3RyICJhbGxvd19yZXJlcmVfYXV0b3VwZGF0ZSBpbnZhbGlkZSBpZ25vcsOpwqA6ICclcyciCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NzAyCisjOiBidWlsdGluL3JlYmFzZS5jOjcwMwogIywgYy1mb3JtYXQKIG1zZ2lkICJDb3VsZCBub3QgcmVhZCAnJXMnIgogbXNnc3RyICJJbXBvc3NpYmxlIGRlIGxpcmUgJyVzJyIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo3MjAKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NzIxCiAjLCBjLWZvcm1hdAogbXNnaWQgIkNhbm5vdCBzdG9yZSAlcyIKIG1zZ3N0ciAiSW1wb3NzaWJsZSBkZSBzdG9ja2VyICVzIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjgyNworIzogYnVpbHRpbi9yZWJhc2UuYzo4MjgKIG1zZ2lkICJjb3VsZCBub3QgZGV0ZXJtaW5lIEhFQUQgcmV2aXNpb24iCiBtc2dzdHIgImltcG9zc2libGUgZGUgZMOpdGVybWluZXIgbGEgcsOpdmlzaW9uIEhFQUQiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6OTUwIGdpdC1yZWJhc2UtLXByZXNlcnZlLW1lcmdlcy5zaDo4MQorIzogYnVpbHRpbi9yZWJhc2UuYzo5NTEgZ2l0LXJlYmFzZS0tcHJlc2VydmUtbWVyZ2VzLnNoOjgxCiBtc2dpZCAiIgogIlJlc29sdmUgYWxsIGNvbmZsaWN0cyBtYW51YWxseSwgbWFyayB0aGVtIGFzIHJlc29sdmVkIHdpdGhcbiIKICJcImdpdCBhZGQvcm0gPGNvbmZsaWN0ZWRfZmlsZXM+XCIsIHRoZW4gcnVuIFwiZ2l0IHJlYmFzZSAtLWNvbnRpbnVlXCIuXG4iCkBAIC0xNzU4NSw3ICsxNzY2OCw3IEBACiAiYXJyw6p0ZXJcbiIKICJldCByZXZlbmlyIMOgIGwnw6l0YXQgYW50w6lyaWV1ciDDoCBsYSBjb21tYW5kZSwgbGFuY2V6IFwiZ2l0IHJlYmFzZSAtLWFib3J0XCIuIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjEwMzEKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTAzMgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiXG4iCkBAIC0xNzYwNCw3ICsxNzY4Nyw3IEBACiAiXG4iCiAiUsOpc3VsdGF0LCBnaXQgbmUgcGV1dCBwYXMgbGVzIHJlYmFzZXIuIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjEzMTgKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTMzOQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiJXNcbiIKQEAgLTE3NjIxLDcgKzE3NzA0LDcgQEAKICIgICAgZ2l0IHJlYmFzZSAnPGJyYW5jaGU+J1xuIgogIlxuIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjEzMzQKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTM1NQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiSWYgeW91IHdpc2ggdG8gc2V0IHRyYWNraW5nIGluZm9ybWF0aW9uIGZvciB0aGlzIGJyYW5jaCB5b3UgY2FuIGRvIHNvIHdpdGg6XG4iCkBAIC0xNzYzNSwxMjcgKzE3NzE4LDEzMiBAQAogIiAgICBnaXQgYnJhbmNoIC0tc2V0LXVwc3RyZWFtLXRvPSVzLzxicmFuY2hlPiAlc1xuIgogIlxuIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjEzNjQKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTM4NQogbXNnaWQgImV4ZWMgY29tbWFuZHMgY2Fubm90IGNvbnRhaW4gbmV3bGluZXMiCiBtc2dzdHIgImxlcyBjb21tYW5kZXMgZXhlYyBuZSBwZXV0IHBhcyBjb250ZW5pciBkZSByZXRvdXIgw6AgbGEgbGlnbmUiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTM2OAorIzogYnVpbHRpbi9yZWJhc2UuYzoxMzg5CiBtc2dpZCAiZW1wdHkgZXhlYyBjb21tYW5kIgogbXNnc3RyICJjb21tYW5kZSBleGVjIHZpZGUiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTM5NgorIzogYnVpbHRpbi9yZWJhc2UuYzoxNDE4CiBtc2dpZCAicmViYXNlIG9udG8gZ2l2ZW4gYnJhbmNoIGluc3RlYWQgb2YgdXBzdHJlYW0iCiBtc2dzdHIgInJlYmFzZXIgc3VyIGxhIGJyYW5jaGUgJXMgYXUgbGlldSBkZSBsYSBicmFuY2hlIGFtb250IgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjEzOTgKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQyMAorbXNnaWQgInVzZSB0aGUgbWVyZ2UtYmFzZSBvZiB1cHN0cmVhbSBhbmQgYnJhbmNoIGFzIHRoZSBjdXJyZW50IGJhc2UiCittc2dzdHIgIiIKKyJ1dGlsaXNlciBsYSBiYXNlIGRlIGZ1c2lvbiBkZSBsJ2Ftb250IGV0IGxhIGJyYW5jaGUgY29tbWUgYmFzZSBhY3R1ZWxsZSIKKworIzogYnVpbHRpbi9yZWJhc2UuYzoxNDIyCiBtc2dpZCAiYWxsb3cgcHJlLXJlYmFzZSBob29rIHRvIHJ1biIKIG1zZ3N0ciAicGVybWV0dHJlIGxlIGxhbmNlbWVudCBkdSBjcm9jaGV0IHByZS1yZWJhc2UiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQwMAorIzogYnVpbHRpbi9yZWJhc2UuYzoxNDI0CiBtc2dpZCAiYmUgcXVpZXQuIGltcGxpZXMgLS1uby1zdGF0IgogbXNnc3RyICLDqnRyZSBzaWxlbmNpZXV4LiBpbXBsaXF1ZSAtLW5vLXN0YXQiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQwNgorIzogYnVpbHRpbi9yZWJhc2UuYzoxNDMwCiBtc2dpZCAiZG8gbm90IHNob3cgZGlmZnN0YXQgb2Ygd2hhdCBjaGFuZ2VkIHVwc3RyZWFtIgogbXNnc3RyICJuZSBwYXMgYWZmaWNoZXIgdW4gZGlmZnN0YXQgZGUgY2UgcXVpIGEgY2hhbmfDqSBlbiBhbW9udCIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDA5CisjOiBidWlsdGluL3JlYmFzZS5jOjE0MzMKIG1zZ2lkICJhZGQgYSBTaWduZWQtb2ZmLWJ5OiBsaW5lIHRvIGVhY2ggY29tbWl0IgogbXNnc3RyICJham91dGVyIHVuZSBsaWduZSBTaWduZWQtb2ZmLWJ5IMOgIGNoYXF1ZSBtZXNzYWdlIGRlIHZhbGlkYXRpb24iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQxMSBidWlsdGluL3JlYmFzZS5jOjE0MTUgYnVpbHRpbi9yZWJhc2UuYzoxNDE3CisjOiBidWlsdGluL3JlYmFzZS5jOjE0MzUgYnVpbHRpbi9yZWJhc2UuYzoxNDM5IGJ1aWx0aW4vcmViYXNlLmM6MTQ0MQogbXNnaWQgInBhc3NlZCB0byAnZ2l0IGFtJyIKIG1zZ3N0ciAicGFzc8OpIMOgICdnaXQgYW0nIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0MTkgYnVpbHRpbi9yZWJhc2UuYzoxNDIxCisjOiBidWlsdGluL3JlYmFzZS5jOjE0NDMgYnVpbHRpbi9yZWJhc2UuYzoxNDQ1CiBtc2dpZCAicGFzc2VkIHRvICdnaXQgYXBwbHknIgogbXNnc3RyICJwYXNzw6kganVzcXUnw6AgZ2l0LWFwcGx5IgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0MjMgYnVpbHRpbi9yZWJhc2UuYzoxNDI2CisjOiBidWlsdGluL3JlYmFzZS5jOjE0NDcgYnVpbHRpbi9yZWJhc2UuYzoxNDUwCiBtc2dpZCAiY2hlcnJ5LXBpY2sgYWxsIGNvbW1pdHMsIGV2ZW4gaWYgdW5jaGFuZ2VkIgogbXNnc3RyICJwaWNvcmVyIHRvdXMgbGVzIGNvbW1pdHMsIG3Dqm1lIHNhbnMgbW9kaWZpYW50IgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0MjgKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ1MgogbXNnaWQgImNvbnRpbnVlIgogbXNnc3RyICJjb250aW51ZXIiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQzMQorIzogYnVpbHRpbi9yZWJhc2UuYzoxNDU1CiBtc2dpZCAic2tpcCBjdXJyZW50IHBhdGNoIGFuZCBjb250aW51ZSIKIG1zZ3N0ciAic2F1dGVyIGxlIHBhdGNoIGNvdXJhbnQgZXQgY29udGludWVyIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0MzMKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ1NwogbXNnaWQgImFib3J0IGFuZCBjaGVjayBvdXQgdGhlIG9yaWdpbmFsIGJyYW5jaCIKIG1zZ3N0ciAiYWJhbmRvbm5lciBldCBleHRyYWlyZSBsYSBicmFuY2hlIGQnb3JpZ2luZSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDM2CisjOiBidWlsdGluL3JlYmFzZS5jOjE0NjAKIG1zZ2lkICJhYm9ydCBidXQga2VlcCBIRUFEIHdoZXJlIGl0IGlzIgogbXNnc3RyICJhYmFuZG9ubmUgbWFpcyBnYXJkZSBIRUFEIG/DuSBpbCBlc3QiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQzNworIzogYnVpbHRpbi9yZWJhc2UuYzoxNDYxCiBtc2dpZCAiZWRpdCB0aGUgdG9kbyBsaXN0IGR1cmluZyBhbiBpbnRlcmFjdGl2ZSByZWJhc2UiCiBtc2dzdHIgIsOpZGl0ZXIgbGEgbGlzdGUgw6AgZmFpcmUgbG9ycyBkJ3VuIHJlYmFzYWdlIGludGVyYWN0aWYiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ0MAorIzogYnVpbHRpbi9yZWJhc2UuYzoxNDY0CiBtc2dpZCAic2hvdyB0aGUgcGF0Y2ggZmlsZSBiZWluZyBhcHBsaWVkIG9yIG1lcmdlZCIKIG1zZ3N0ciAiYWZmaWNoZXIgbGUgcGF0Y2ggZW4gY291cnMgZCdhcHBsaWNhdGlvbiBvdSBkZSBmdXNpb24iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ0MworIzogYnVpbHRpbi9yZWJhc2UuYzoxNDY3CiBtc2dpZCAidXNlIG1lcmdpbmcgc3RyYXRlZ2llcyB0byByZWJhc2UiCiBtc2dzdHIgInV0aWxpc2VyIGRlcyBzdHJhdMOpZ2llcyBkZSBmdXNpb24gcG91ciByZWJhc2VyIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0NDcKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ3MQogbXNnaWQgImxldCB0aGUgdXNlciBlZGl0IHRoZSBsaXN0IG9mIGNvbW1pdHMgdG8gcmViYXNlIgogbXNnc3RyICJsYWlzc2VyIGwndXRpbGlzYXRldXIgw6lkaXRlciBsYSBsaXN0ZSBkZXMgY29tbWl0cyDDoCByZWJhc2VyIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0NTEKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ3NQogbXNnaWQgIihERVBSRUNBVEVEKSB0cnkgdG8gcmVjcmVhdGUgbWVyZ2VzIGluc3RlYWQgb2YgaWdub3JpbmcgdGhlbSIKIG1zZ3N0ciAiKETDiUNPTlNFSUxMw4kpIGVzc2F5ZXIgZGUgcmVjcsOpZXIgbGVzIGZ1c2lvbnMgYXUgbGlldSBkZSBsZXMgaWdub3JlciIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDU1CisjOiBidWlsdGluL3JlYmFzZS5jOjE0NzkKIG1zZ2lkICJwcmVzZXJ2ZSBlbXB0eSBjb21taXRzIGR1cmluZyByZWJhc2UiCiBtc2dzdHIgInByw6lzZXJ2ZXIgbGVzIHZhbGlkYXRpb25zIHZpZGVzIHBlbmRhbnQgbGUgcmViYXNhZ2UiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ1NworIzogYnVpbHRpbi9yZWJhc2UuYzoxNDgxCiBtc2dpZCAibW92ZSBjb21taXRzIHRoYXQgYmVnaW4gd2l0aCBzcXVhc2ghL2ZpeHVwISB1bmRlciAtaSIKIG1zZ3N0ciAiZMOpcGxhY2UgbGVzIGNvbW1pdHMgcXVpIGNvbW1lbmNlbnQgcGFyIHNxdWFzaCEvZml4dXAhIHNvdXMgLWkiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ2MworIzogYnVpbHRpbi9yZWJhc2UuYzoxNDg3CiBtc2dpZCAiYXV0b21hdGljYWxseSBzdGFzaC9zdGFzaCBwb3AgYmVmb3JlIGFuZCBhZnRlciIKIG1zZ3N0ciAicmVtaXNlciBldCByw6lhcHBsaXF1ZXIgYXV0b21hdGlxdWVtZW50IGF2YW50IGV0IGFwcsOocyIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDY1CisjOiBidWlsdGluL3JlYmFzZS5jOjE0ODkKIG1zZ2lkICJhZGQgZXhlYyBsaW5lcyBhZnRlciBlYWNoIGNvbW1pdCBvZiB0aGUgZWRpdGFibGUgbGlzdCIKIG1zZ3N0ciAiYWpvdXRlciBsZXMgbGlnbmVzIGV4ZWMgYXByw6hzIGNoYXF1ZSBjb21taXQgZGUgbGEgbGlzdGUgw6lkaXRhYmxlIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0NjkKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ5MwogbXNnaWQgImFsbG93IHJlYmFzaW5nIGNvbW1pdHMgd2l0aCBlbXB0eSBtZXNzYWdlcyIKIG1zZ3N0ciAiYXV0b3Jpc2VyIGxlcyBjb21taXRzIGRlIHJlYmFzYWdlIGF2ZWMgZGVzIG1lc3NhZ2VzIHZpZGVzIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0NzIKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ5NgogbXNnaWQgInRyeSB0byByZWJhc2UgbWVyZ2VzIGluc3RlYWQgb2Ygc2tpcHBpbmcgdGhlbSIKIG1zZ3N0ciAiZXNzYXllciBkZSByZWJhc2VyIGxlcyBmdXNpb25zIGF1IGxpZXUgZGUgbGVzIGdhcmRlciIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDc1CisjOiBidWlsdGluL3JlYmFzZS5jOjE0OTkKIG1zZ2lkICJ1c2UgJ21lcmdlLWJhc2UgLS1mb3JrLXBvaW50JyB0byByZWZpbmUgdXBzdHJlYW0iCiBtc2dzdHIgInV0aWxpc2VyICdtZXJnZS1iYXNlIC0tZm9yay1wb2ludCcgcG91ciByYWZmaW5lciBsJ2Ftb250IgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0NzcKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTUwMQogbXNnaWQgInVzZSB0aGUgZ2l2ZW4gbWVyZ2Ugc3RyYXRlZ3kiCiBtc2dzdHIgInV0aWxpc2VyIGxhIHN0cmF0w6lnaWUgZGUgZnVzaW9uIGluZGlxdcOpZSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDc5IGJ1aWx0aW4vcmV2ZXJ0LmM6MTE1CisjOiBidWlsdGluL3JlYmFzZS5jOjE1MDMgYnVpbHRpbi9yZXZlcnQuYzoxMTUKIG1zZ2lkICJvcHRpb24iCiBtc2dzdHIgIm9wdGlvbiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDgwCisjOiBidWlsdGluL3JlYmFzZS5jOjE1MDQKIG1zZ2lkICJwYXNzIHRoZSBhcmd1bWVudCB0aHJvdWdoIHRvIHRoZSBtZXJnZSBzdHJhdGVneSIKIG1zZ3N0ciAicGFzc2VyIGxlcyBhcmd1bWVudHMganVzcXUnw6AgbGEgc3RyYXTDqWdpZSBkZSBmdXNpb24iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ4MworIzogYnVpbHRpbi9yZWJhc2UuYzoxNTA3CiBtc2dpZCAicmViYXNlIGFsbCByZWFjaGFibGUgY29tbWl0cyB1cCB0byB0aGUgcm9vdChzKSIKIG1zZ3N0ciAicmViYXNlciB0b3VzIGxlcyBvYmpldHMgaW5hdHRlaWduYWJsZXMgZGVwdWlzIGxlcyByYWNpbmVzIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE1MDAKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTUyNAogbXNnaWQgIiIKICJ0aGUgcmViYXNlLnVzZUJ1aWx0aW4gc3VwcG9ydCBoYXMgYmVlbiByZW1vdmVkIVxuIgogIlNlZSBpdHMgZW50cnkgaW4gJ2dpdCBoZWxwIGNvbmZpZycgZm9yIGRldGFpbHMuIgpAQCAtMTc3NjMsMzIgKzE3ODUxLDQwIEBACiAibGVzIHN1cHBvcnQgZGUgcmViYXNlLnVzZUJ1aWx0aW4gYSDDqXTDqSBzdXBwcmltw6kgIVxuIgogIlZvaXIgc29uIGVudHLDqWUgZGFucyAnZ2l0IGhlbHAgY29uZmlnJyBwb3VyIHBsdXMgZGUgZMOpdGFpbHMuIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE1MDYKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTUzMAogbXNnaWQgIkl0IGxvb2tzIGxpa2UgJ2dpdCBhbScgaXMgaW4gcHJvZ3Jlc3MuIENhbm5vdCByZWJhc2UuIgogbXNnc3RyICJJbCBzZW1ibGUgcXVlICdnaXQtYW0nIHNvaXQgZW4gY291cnMuIEltcG9zc2libGUgZGUgcmViYXNlci4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTU0NworIzogYnVpbHRpbi9yZWJhc2UuYzoxNTcxCiBtc2dpZCAiIgogImdpdCByZWJhc2UgLS1wcmVzZXJ2ZS1tZXJnZXMgaXMgZGVwcmVjYXRlZC4gVXNlIC0tcmViYXNlLW1lcmdlcyBpbnN0ZWFkLiIKIG1zZ3N0ciAiIgogImdpdCByZWJhc2UgLS1wcmVzZXJ2ZS1tZXJnZXMgZXN0IGTDqWNvbnNlaWxsw6kuIFV0aWxpc2V6IC0tcmViYXNlLW1lcmdlcyDDoCBsYSAiCiAicGxhY2UuIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE1NTEKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTU3NgorbXNnaWQgImNhbm5vdCBjb21iaW5lICctLWtlZXAtYmFzZScgd2l0aCAnLS1vbnRvJyIKK21zZ3N0ciAiaW1wb3NzaWJsZSBkZSBjb21iaW5lciAnLS1rZWVwLWJhc2UnIGF2ZWMgJy0tb250byciCisKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTU3OAorbXNnaWQgImNhbm5vdCBjb21iaW5lICctLWtlZXAtYmFzZScgd2l0aCAnLS1yb290JyIKK21zZ3N0ciAiaW1wb3NzaWJsZSBkZSBjb21iaW5lciAnLS1rZWVwLWJhc2UnIGF2ZWMgJy0tcm9vdCciCisKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTU4MgogbXNnaWQgIk5vIHJlYmFzZSBpbiBwcm9ncmVzcz8iCiBtc2dzdHIgIlBhcyBkZSByZWJhc2FnZSBlbiBjb3VycyA/IgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE1NTUKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTU4NgogbXNnaWQgIlRoZSAtLWVkaXQtdG9kbyBhY3Rpb24gY2FuIG9ubHkgYmUgdXNlZCBkdXJpbmcgaW50ZXJhY3RpdmUgcmViYXNlLiIKIG1zZ3N0ciAiIgogIkwnYWN0aW9uIC0tZWRpdC10b2RvIHBldXQgc2V1bGVtZW50IMOqdHJlIHV0aWxpc8OpZSBsb3JzIGQndW4gcmViYXNhZ2UgIgogImludGVyYWN0aWYuIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE1NzgKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTYwOQogbXNnaWQgIkNhbm5vdCByZWFkIEhFQUQiCiBtc2dzdHIgIkltcG9zc2libGUgZGUgbGlyZSBIRUFEIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE1OTAKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTYyMQogbXNnaWQgIiIKICJZb3UgbXVzdCBlZGl0IGFsbCBtZXJnZSBjb25mbGljdHMgYW5kIHRoZW5cbiIKICJtYXJrIHRoZW0gYXMgcmVzb2x2ZWQgdXNpbmcgZ2l0IGFkZCIKQEAgLTE3Nzk2LDE2ICsxNzg5MiwxNiBAQAogIlZvdXMgZGV2ZXogw6lkaXRlciB0b3VzIGxlcyBjb25mbGl0cyBkZSBmdXNpb24gZXRcbiIKICJsZXMgbWFycXVlciBjb21tZSByw6lzb2x1cyBhdmVjIGdpdCBhZGQiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTYwOQorIzogYnVpbHRpbi9yZWJhc2UuYzoxNjQwCiBtc2dpZCAiY291bGQgbm90IGRpc2NhcmQgd29ya3RyZWUgY2hhbmdlcyIKIG1zZ3N0ciAiSW1wb3NzaWJsZSBkZSBzdXBwcmltZXIgbGVzIGNoYW5nZW1lbnRzIGRlIGwnYXJicmUgZGUgdHJhdmFpbCIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNjI4CisjOiBidWlsdGluL3JlYmFzZS5jOjE2NTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IG1vdmUgYmFjayB0byAlcyIKIG1zZ3N0ciAiSW1wb3NzaWJsZSBkZSByZXZlbmlyIMOgICVzIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE2NzMKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTcwNAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiSXQgc2VlbXMgdGhhdCB0aGVyZSBpcyBhbHJlYWR5IGEgJXMgZGlyZWN0b3J5LCBhbmRcbiIKQEAgLTE3ODI3LDE2NyArMTc5MjMsMTU5IEBACiAiY2hvc2VcbiIKICJkJ2ltcG9ydGFudCBpY2kuXG4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTY5NAorIzogYnVpbHRpbi9yZWJhc2UuYzoxNzI1CiBtc2dpZCAic3dpdGNoIGBDJyBleHBlY3RzIGEgbnVtZXJpY2FsIHZhbHVlIgogbXNnc3RyICJsJ29wdGlvbiBgQycgYXR0ZW5kIHVuIHZhbGV1ciBudW3DqXJpcXVlIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE3MzUKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTc2NgogIywgYy1mb3JtYXQKIG1zZ2lkICJVbmtub3duIG1vZGU6ICVzIgogbXNnc3RyICJtb2RlIGluY29ubnXCoDogJXMiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTc1NworIzogYnVpbHRpbi9yZWJhc2UuYzoxNzg4CiBtc2dpZCAiLS1zdHJhdGVneSByZXF1aXJlcyAtLW1lcmdlIG9yIC0taW50ZXJhY3RpdmUiCiBtc2dzdHIgIi0tc3RyYXRlZ3kgcmVxdWllcnQgLS1tZXJnZSBvdSAtLWludGVyYWN0aXZlIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE3OTcKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTgyOAogbXNnaWQgIi0tcmVzY2hlZHVsZS1mYWlsZWQtZXhlYyByZXF1aXJlcyAtLWV4ZWMgb3IgLS1pbnRlcmFjdGl2ZSIKIG1zZ3N0ciAiLS1yZXNjaGVkdWxlLWZhaWxlZC1leGVjIHJlcXVpZXJ0IC0tZXhlYyBvdSAtLWludGVyYWN0aXZlIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE4MDkKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTg0MAogbXNnaWQgImNhbm5vdCBjb21iaW5lIGFtIG9wdGlvbnMgd2l0aCBlaXRoZXIgaW50ZXJhY3RpdmUgb3IgbWVyZ2Ugb3B0aW9ucyIKIG1zZ3N0ciAiIgogImltcG9zc2libGUgZGUgY29tYmluZXIgbGVzIG9wdGlvbnMgYW0gYXZlYyBsJ29wdGlvbnMgaW50ZXJhY3RpdmUgb3UgbWVyZ2UiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTgyOAorIzogYnVpbHRpbi9yZWJhc2UuYzoxODU5CiBtc2dpZCAiY2Fubm90IGNvbWJpbmUgJy0tcHJlc2VydmUtbWVyZ2VzJyB3aXRoICctLXJlYmFzZS1tZXJnZXMnIgogbXNnc3RyICJpbXBvc3NpYmxlIGRlIGNvbWJpbmVyICctLXByZXNlcnZlLW1lcmdlcycgYXZlYyAnLS1yZWJhc2UtbWVyZ2VzJyIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxODMyCisjOiBidWlsdGluL3JlYmFzZS5jOjE4NjMKIG1zZ2lkICIiCiAiZXJyb3I6IGNhbm5vdCBjb21iaW5lICctLXByZXNlcnZlLW1lcmdlcycgd2l0aCAnLS1yZXNjaGVkdWxlLWZhaWxlZC1leGVjJyIKIG1zZ3N0ciAiIgogImVycmV1csKgOiBpbXBvc3NpYmxlIGRlIGNvbWJpbmVyICctLXByZXNlcnZlLW1lcmdlcycgYXZlYyAnLS1yZXNjaGVkdWxlLSIKICJmYWlsZWQtZXhlYyciCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTgzOAotbXNnaWQgImNhbm5vdCBjb21iaW5lICctLXJlYmFzZS1tZXJnZXMnIHdpdGggJy0tc3RyYXRlZ3ktb3B0aW9uJyIKLW1zZ3N0ciAiaW1wb3NzaWJsZSBkZSBjb21iaW5lciAnLS1yZWJhc2UtbWVyZ2VzJyBhdmVjICctLXN0cmF0ZWd5LW9wdGlvbiciCi0KLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTg0MQotbXNnaWQgImNhbm5vdCBjb21iaW5lICctLXJlYmFzZS1tZXJnZXMnIHdpdGggJy0tc3RyYXRlZ3knIgotbXNnc3RyICJpbXBvc3NpYmxlIGRlIGNvbWJpbmVyICctLXJlYmFzZS1tZXJnZXMnIGF2ZWMgJy0tc3RyYXRlZ3knIgotCi0jOiBidWlsdGluL3JlYmFzZS5jOjE4NjUKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTg4NwogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIHVwc3RyZWFtICclcyciCiBtc2dzdHIgImFtb250IGludmFsaWRlICclcyciCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTg3MQorIzogYnVpbHRpbi9yZWJhc2UuYzoxODkzCiBtc2dpZCAiQ291bGQgbm90IGNyZWF0ZSBuZXcgcm9vdCBjb21taXQiCiBtc2dzdHIgIkltcG9zc2libGUgZGUgY3LDqWVyIHVuIG5vdXZlYXUgY29tbWl0IHJhY2luZSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxODg5CisjOiBidWlsdGluL3JlYmFzZS5jOjE5MTkKKyMsIGMtZm9ybWF0Cittc2dpZCAiJyVzJzogbmVlZCBleGFjdGx5IG9uZSBtZXJnZSBiYXNlIHdpdGggYnJhbmNoIgorbXNnc3RyICInJXMnOiBleGFjdGVtZW50IHVuZSBiYXNlIGRlIGZ1c2lvbiBuw6ljZXNzYWlyZSBhdmVjIHVuZSBicmFuY2hlIgorCisjOiBidWlsdGluL3JlYmFzZS5jOjE5MjIKICMsIGMtZm9ybWF0CiBtc2dpZCAiJyVzJzogbmVlZCBleGFjdGx5IG9uZSBtZXJnZSBiYXNlIgogbXNnc3RyICInJXMnOiBleGFjdGVtZW50IHVuZSBiYXNlIGRlIGZ1c2lvbiBuw6ljZXNzYWlyZSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxODk2CisjOiBidWlsdGluL3JlYmFzZS5jOjE5MzAKICMsIGMtZm9ybWF0CiBtc2dpZCAiRG9lcyBub3QgcG9pbnQgdG8gYSB2YWxpZCBjb21taXQgJyVzJyIKIG1zZ3N0ciAibmUgcG9pbnRlIHBhcyBzdXIgdW5lIHZhbGlkYXRpb24gdmFsaWRlIDogJyVzJyIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxOTIxCisjOiBidWlsdGluL3JlYmFzZS5jOjE5NTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmF0YWw6IG5vIHN1Y2ggYnJhbmNoL2NvbW1pdCAnJXMnIgogbXNnc3RyICJmYXRhbCA6IHBhcyBkZSBicmFuY2hlIG91IGNvbW1pdCAnJXMnIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE5MjkgYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjM4CisjOiBidWlsdGluL3JlYmFzZS5jOjE5NjMgYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjM4CiAjOiBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6MTkzNAogIywgYy1mb3JtYXQKIG1zZ2lkICJObyBzdWNoIHJlZjogJXMiCiBtc2dzdHIgIlLDqWbDqXJlbmNlIGluZXhpc3RhbnRlwqA6ICVzIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE5NDAKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTk3NAogbXNnaWQgIkNvdWxkIG5vdCByZXNvbHZlIEhFQUQgdG8gYSByZXZpc2lvbiIKIG1zZ3N0ciAiSW1wb3NzaWJsZSBkZSByw6lzb3VkcmUgbGUgY29tbWl0IEhFQUQgdmVycyB1biByw6l2aXNpb24iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTk4MQorIzogYnVpbHRpbi9yZWJhc2UuYzoyMDEyCiBtc2dpZCAiQ2Fubm90IGF1dG9zdGFzaCIKIG1zZ3N0ciAiQXV0b3JlbWlzYWdlIGltcG9zc2libGUiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTk4NAorIzogYnVpbHRpbi9yZWJhc2UuYzoyMDE1CiAjLCBjLWZvcm1hdAogbXNnaWQgIlVuZXhwZWN0ZWQgc3Rhc2ggcmVzcG9uc2U6ICclcyciCiBtc2dzdHIgInLDqXBvbnNlIGRlIHJlbWlzYWdlIGluYXR0ZW5kdWXCoDogJyVzJyIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxOTkwCisjOiBidWlsdGluL3JlYmFzZS5jOjIwMjEKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ291bGQgbm90IGNyZWF0ZSBkaXJlY3RvcnkgZm9yICclcyciCiBtc2dzdHIgIkltcG9zc2libGUgZGUgY3LDqWVyIGxlIHLDqXBlcnRvaXJlIHBvdXIgJyVzJyIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxOTkzCisjOiBidWlsdGluL3JlYmFzZS5jOjIwMjQKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ3JlYXRlZCBhdXRvc3Rhc2g6ICVzXG4iCiBtc2dzdHIgIkF1dG9yZW1pc2FnZSBjcsOpw6kgOiAlc1xuIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE5OTYKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MjAyNwogbXNnaWQgImNvdWxkIG5vdCByZXNldCAtLWhhcmQiCiBtc2dzdHIgImltcG9zc2libGUgZGUgcsOpaW5pdGlhbGlzZXIgLS1oYXJkIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE5OTcgYnVpbHRpbi9yZXNldC5jOjExNAotIywgYy1mb3JtYXQKLW1zZ2lkICJIRUFEIGlzIG5vdyBhdCAlcyIKLW1zZ3N0ciAiSEVBRCBlc3QgbWFpbnRlbmFudCDDoCAlcyIKLQotIzogYnVpbHRpbi9yZWJhc2UuYzoyMDEzCisjOiBidWlsdGluL3JlYmFzZS5jOjIwMzYKIG1zZ2lkICJQbGVhc2UgY29tbWl0IG9yIHN0YXNoIHRoZW0uIgogbXNnc3RyICJWZXVpbGxleiBsZXMgdmFsaWRlciBvdSBsZXMgcmVtaXNlci4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MjA0MAorIzogYnVpbHRpbi9yZWJhc2UuYzoyMDYzCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBwYXJzZSAnJXMnIgogbXNnc3RyICJpbXBvc3NpYmxlIGQnYW5hbHlzZXIgJyVzJyIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoyMDUzCisjOiBidWlsdGluL3JlYmFzZS5jOjIwNzYKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHN3aXRjaCB0byAlcyIKIG1zZ3N0ciAiSW1wb3NzaWJsZSBkZSBiYXNjdWxlciB2ZXJzICVzIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjIwNjQKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MjA4NwogbXNnaWQgIkhFQUQgaXMgdXAgdG8gZGF0ZS4iCiBtc2dzdHIgIkhFQUQgZXN0IMOgIGpvdXIuIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjIwNjYKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MjA4OQogIywgYy1mb3JtYXQKIG1zZ2lkICJDdXJyZW50IGJyYW5jaCAlcyBpcyB1cCB0byBkYXRlLlxuIgogbXNnc3RyICJMYSBicmFuY2hlIGNvdXJhbnRlICVzIGVzdCDDoCBqb3VyLlxuIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjIwNzQKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MjA5NwogbXNnaWQgIkhFQUQgaXMgdXAgdG8gZGF0ZSwgcmViYXNlIGZvcmNlZC4iCiBtc2dzdHIgIkhFQUQgZXN0IMOgIGpvdXIsIHJlYmFzYWdlIGZvcmPDqS4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MjA3NgorIzogYnVpbHRpbi9yZWJhc2UuYzoyMDk5CiAjLCBjLWZvcm1hdAogbXNnaWQgIkN1cnJlbnQgYnJhbmNoICVzIGlzIHVwIHRvIGRhdGUsIHJlYmFzZSBmb3JjZWQuXG4iCiBtc2dzdHIgIkxhIGJyYW5jaGUgY291cmFudGUgJXMgZXN0IMOgIGpvdXIsIHJlYmFzYWdlIGZvcmPDqS5cbiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoyMDg0CisjOiBidWlsdGluL3JlYmFzZS5jOjIxMDcKIG1zZ2lkICJUaGUgcHJlLXJlYmFzZSBob29rIHJlZnVzZWQgdG8gcmViYXNlLiIKIG1zZ3N0ciAiTGUgY3JvY2hldCBwcmUtcmViYXNlIGEgcmVmdXPDqSBkZSByZWJhc2VyLiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoyMDkxCisjOiBidWlsdGluL3JlYmFzZS5jOjIxMTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ2hhbmdlcyB0byAlczpcbiIKIG1zZ3N0ciAiQ2hhbmdlbWVudHMgdmVycyAlcyA6XG4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MjA5NAorIzogYnVpbHRpbi9yZWJhc2UuYzoyMTE3CiAjLCBjLWZvcm1hdAogbXNnaWQgIkNoYW5nZXMgZnJvbSAlcyB0byAlczpcbiIKIG1zZ3N0ciAiQ2hhbmdlbWVudHMgZGUgJXMgc3VyICVzIDpcbiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoyMTE5CisjOiBidWlsdGluL3JlYmFzZS5jOjIxNDIKICMsIGMtZm9ybWF0CiBtc2dpZCAiRmlyc3QsIHJld2luZGluZyBoZWFkIHRvIHJlcGxheSB5b3VyIHdvcmsgb24gdG9wIG9mIGl0Li4uXG4iCiBtc2dzdHIgIiIKICJSZW1ib2JpbmFnZSBwcsOpYWxhYmxlIGRlIGhlYWQgcG91ciBwb3V2b2lyIHJlam91ZXIgdm90cmUgdHJhdmFpbCBwYXItIgogImRlc3N1cy4uLlxuIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjIxMjgKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MjE1MQogbXNnaWQgIkNvdWxkIG5vdCBkZXRhY2ggSEVBRCIKIG1zZ3N0ciAiSW1wb3NzaWJsZSBkZSBkw6l0YWNoZXIgSEVBRCIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoyMTM3CisjOiBidWlsdGluL3JlYmFzZS5jOjIxNjAKICMsIGMtZm9ybWF0CiBtc2dpZCAiRmFzdC1mb3J3YXJkZWQgJXMgdG8gJXMuXG4iCiBtc2dzdHIgIkF2YW5jZSByYXBpZGUgZGUgJXMgc3VyICVzLlxuIgpAQCAtMTc5OTYsNyArMTgwODQsNyBAQAogbXNnaWQgImdpdCByZWNlaXZlLXBhY2sgPGdpdC1kaXI+IgogbXNnc3RyICJnaXQgcmVjZWl2ZS1wYWNrIDxyw6lwZXJ0b2lyZS1naXQ+IgogCi0jOiBidWlsdGluL3JlY2VpdmUtcGFjay5jOjgzMgorIzogYnVpbHRpbi9yZWNlaXZlLXBhY2suYzo4MzAKIG1zZ2lkICIiCiAiQnkgZGVmYXVsdCwgdXBkYXRpbmcgdGhlIGN1cnJlbnQgYnJhbmNoIGluIGEgbm9uLWJhcmUgcmVwb3NpdG9yeVxuIgogImlzIGRlbmllZCwgYmVjYXVzZSBpdCB3aWxsIG1ha2UgdGhlIGluZGV4IGFuZCB3b3JrIHRyZWUgaW5jb25zaXN0ZW50XG4iCkBAIC0xODAyNiw3ICsxODExNCw3IEBACiAiUG91ciDDqWxpbWluZXIgY2UgbWVzc2FnZSBldCBjb25zZXJ2ZXIgbGUgY29tcG9ydGVtZW50IHBhciBkw6lmYXV0LFxuIgogInLDqWdsZXogwqvCoHJlY2VpdmUuZGVueUN1cnJlbnRCcmFuY2jCoMK7IMOgICdyZWZ1c2UnLiIKIAotIzogYnVpbHRpbi9yZWNlaXZlLXBhY2suYzo4NTIKKyM6IGJ1aWx0aW4vcmVjZWl2ZS1wYWNrLmM6ODUwCiBtc2dpZCAiIgogIkJ5IGRlZmF1bHQsIGRlbGV0aW5nIHRoZSBjdXJyZW50IGJyYW5jaCBpcyBkZW5pZWQsIGJlY2F1c2UgdGhlIG5leHRcbiIKICInZ2l0IGNsb25lJyB3b24ndCByZXN1bHQgaW4gYW55IGZpbGUgY2hlY2tlZCBvdXQsIGNhdXNpbmcgY29uZnVzaW9uLlxuIgpAQCAtMTgwNDYsMTEgKzE4MTM0LDExIEBACiAiXG4iCiAiUG91ciDDqWxpbWluZXIgY2UgbWVzc2FnZSwgcsOpZ2xlei1sZSDDoCAncmVmdXNlJy4iCiAKLSM6IGJ1aWx0aW4vcmVjZWl2ZS1wYWNrLmM6MTkzOAorIzogYnVpbHRpbi9yZWNlaXZlLXBhY2suYzoxOTM2CiBtc2dpZCAicXVpZXQiCiBtc2dzdHIgInF1aWV0IgogCi0jOiBidWlsdGluL3JlY2VpdmUtcGFjay5jOjE5NTIKKyM6IGJ1aWx0aW4vcmVjZWl2ZS1wYWNrLmM6MTk1MAogbXNnaWQgIllvdSBtdXN0IHNwZWNpZnkgYSBkaXJlY3RvcnkuIgogbXNnc3RyICJWb3VzIGRldmV6IHNww6ljaWZpZXIgdW4gcsOpcGVydG9pcmUuIgogCkBAIC0xODYzMiwxMSArMTg3MjAsMTEgQEAKIG1zZ2lkICJVbmtub3duIHN1YmNvbW1hbmQ6ICVzIgogbXNnc3RyICJTb3VzLWNvbW1hbmRlIGluY29ubnVlIDogJXMiCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MjIKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6MjMKIG1zZ2lkICJnaXQgcmVwYWNrIFs8b3B0aW9ucz5dIgogbXNnc3RyICJnaXQgcmVwYWNrIFs8b3B0aW9ucz5dIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjI3CisjOiBidWlsdGluL3JlcGFjay5jOjI4CiBtc2dpZCAiIgogIkluY3JlbWVudGFsIHJlcGFja3MgYXJlIGluY29tcGF0aWJsZSB3aXRoIGJpdG1hcCBpbmRleGVzLiAgVXNlXG4iCiAiLS1uby13cml0ZS1iaXRtYXAtaW5kZXggb3IgZGlzYWJsZSB0aGUgcGFjay53cml0ZWJpdG1hcHMgY29uZmlndXJhdGlvbi4iCkBAIC0xODY0NSwxMTcgKzE4NzMzLDExNyBAQAogIlV0aWxpc2V6XG4iCiAiLS1uby13cml0ZS1iaXRtYXAtaW5kZXggb3UgZMOpc2FjdGl2ZXogbGUgcGFyYW3DqHRyZSBwYWNrLndyaXRlYml0bWFwcy4iCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MTkwCisjOiBidWlsdGluL3JlcGFjay5jOjE5MQogbXNnaWQgImNvdWxkIG5vdCBzdGFydCBwYWNrLW9iamVjdHMgdG8gcmVwYWNrIHByb21pc29yIG9iamVjdHMiCiBtc2dzdHIgIiIKICJuZSBwYXMgZMOpbWFycmVyIHBhY2stb2JqZWN0cyBwb3VyIHLDqS1lbXBhcXVldGVyIGxlcyBvYmplY3RzIGRlIHByb21ldHRldXIiCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MjI5IGJ1aWx0aW4vcmVwYWNrLmM6NDA4CisjOiBidWlsdGluL3JlcGFjay5jOjIzMCBidWlsdGluL3JlcGFjay5jOjQwOQogbXNnaWQgInJlcGFjazogRXhwZWN0aW5nIGZ1bGwgaGV4IG9iamVjdCBJRCBsaW5lcyBvbmx5IGZyb20gcGFjay1vYmplY3RzLiIKIG1zZ3N0ciAiIgogInJlcGFja8KgOiBhdHRlbnRlIGRlIGxpZ25lcyBkJ0lkIGQnb2JqZXRzIGVuIGhleGEgY29tcGxldCBzZXVsZW1lbnQgZGVwdWlzICIKICJsZXMgb2JqZWN0cyBkZSBwYXF1ZXQuIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjI0NgorIzogYnVpbHRpbi9yZXBhY2suYzoyNDcKIG1zZ2lkICJjb3VsZCBub3QgZmluaXNoIHBhY2stb2JqZWN0cyB0byByZXBhY2sgcHJvbWlzb3Igb2JqZWN0cyIKIG1zZ3N0ciAiIgogImltcG9zc2libGUgZGUgdGVybWluZXIgcGFjay1vYmplY3RzICBwb3VyIHLDqS1lbXBhcXVldGVyIGxlcyBvYmpldHMgZGUgIgogInByb21ldHRldXIiCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6Mjg0CisjOiBidWlsdGluL3JlcGFjay5jOjI4NQogbXNnaWQgInBhY2sgZXZlcnl0aGluZyBpbiBhIHNpbmdsZSBwYWNrIgogbXNnc3RyICJlbXBhcXVldGVyIHRvdXQgZGFucyB1biBzZXVsIHBhcXVldCIKIAotIzogYnVpbHRpbi9yZXBhY2suYzoyODYKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6Mjg3CiBtc2dpZCAic2FtZSBhcyAtYSwgYW5kIHR1cm4gdW5yZWFjaGFibGUgb2JqZWN0cyBsb29zZSIKIG1zZ3N0ciAiaWRlbnRpcXVlIMOgIC1hIGV0IHRyYW5zZm9ybWVyIGxlcyBvYmpldHMgaW5hY2Nlc3NpYmxlcyBlbiBzdXNwZW5zIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjI4OQorIzogYnVpbHRpbi9yZXBhY2suYzoyOTAKIG1zZ2lkICJyZW1vdmUgcmVkdW5kYW50IHBhY2tzLCBhbmQgcnVuIGdpdC1wcnVuZS1wYWNrZWQiCiBtc2dzdHIgInN1cHByaW1lciBsZXMgcGFxdWV0cyByZWRvbmRhbnRzIGV0IGxhbmNlciBnaXQtcHJ1bmUtcGFja2VkIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjI5MQorIzogYnVpbHRpbi9yZXBhY2suYzoyOTIKIG1zZ2lkICJwYXNzIC0tbm8tcmV1c2UtZGVsdGEgdG8gZ2l0LXBhY2stb2JqZWN0cyIKIG1zZ3N0ciAicGFzc2VyIC0tbm8tcmV1c2UtZGVsdGEgw6AgZ2l0LXBhY2stb2JqZWN0cyIKIAotIzogYnVpbHRpbi9yZXBhY2suYzoyOTMKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6Mjk0CiBtc2dpZCAicGFzcyAtLW5vLXJldXNlLW9iamVjdCB0byBnaXQtcGFjay1vYmplY3RzIgogbXNnc3RyICJwYXNzZXIgLS1uby1yZXVzZS1vYmplY3Qgw6AgZ2l0LXBhY2stb2JqZWN0cyIKIAotIzogYnVpbHRpbi9yZXBhY2suYzoyOTUKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6Mjk2CiBtc2dpZCAiZG8gbm90IHJ1biBnaXQtdXBkYXRlLXNlcnZlci1pbmZvIgogbXNnc3RyICJuZSBwYXMgbGFuY2VyIGdpdCB1cGRhdGUtc2VydmVyLWluZm8iCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6Mjk4CisjOiBidWlsdGluL3JlcGFjay5jOjI5OQogbXNnaWQgInBhc3MgLS1sb2NhbCB0byBnaXQtcGFjay1vYmplY3RzIgogbXNnc3RyICJwYXNzZXIgLS1sb2NhbCDDoCBnaXQtcGFjay1vYmplY3RzIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjMwMAorIzogYnVpbHRpbi9yZXBhY2suYzozMDEKIG1zZ2lkICJ3cml0ZSBiaXRtYXAgaW5kZXgiCiBtc2dzdHIgIsOpY3JpcmUgdW4gaW5kZXggZW4gYml0bWFwIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjMwMgorIzogYnVpbHRpbi9yZXBhY2suYzozMDMKIG1zZ2lkICJwYXNzIC0tZGVsdGEtaXNsYW5kcyB0byBnaXQtcGFjay1vYmplY3RzIgogbXNnc3RyICJwYXNzZXIgLS1kZWx0YS1pc2xhbmRzIMOgIGdpdC1wYWNrLW9iamVjdHMiCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MzAzCisjOiBidWlsdGluL3JlcGFjay5jOjMwNAogbXNnaWQgImFwcHJveGlkYXRlIgogbXNnc3RyICJkYXRlIGFwcHJveGltYXRpdmUiCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MzA0CisjOiBidWlsdGluL3JlcGFjay5jOjMwNQogbXNnaWQgIndpdGggLUEsIGRvIG5vdCBsb29zZW4gb2JqZWN0cyBvbGRlciB0aGFuIHRoaXMiCiBtc2dzdHIgImF2ZWMgLUEsIG5lIHBhcyBzdXNwZW5kcmUgbGVzIG9iamV0cyBwbHVzIHZpZXV4IHF1ZSBjZWx1aS1jaSIKIAotIzogYnVpbHRpbi9yZXBhY2suYzozMDYKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6MzA3CiBtc2dpZCAid2l0aCAtYSwgcmVwYWNrIHVucmVhY2hhYmxlIG9iamVjdHMiCiBtc2dzdHIgImF2ZWMgLWEsIHJlcGFxdcOpdGlzZXIgbGVzIG9iamV0cyBpbmFjY2Vzc2libGVzIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjMwOAorIzogYnVpbHRpbi9yZXBhY2suYzozMDkKIG1zZ2lkICJzaXplIG9mIHRoZSB3aW5kb3cgdXNlZCBmb3IgZGVsdGEgY29tcHJlc3Npb24iCiBtc2dzdHIgInRhaWxsZSBkZSBsYSBmZW7DqnRyZSB1dGlsaXPDqWUgcG91ciBsYSBjb21wcmVzc2lvbiBkZXMgZGVsdGFzIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjMwOSBidWlsdGluL3JlcGFjay5jOjMxNQorIzogYnVpbHRpbi9yZXBhY2suYzozMTAgYnVpbHRpbi9yZXBhY2suYzozMTYKIG1zZ2lkICJieXRlcyIKIG1zZ3N0ciAib2N0ZXRzIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjMxMAorIzogYnVpbHRpbi9yZXBhY2suYzozMTEKIG1zZ2lkICJzYW1lIGFzIHRoZSBhYm92ZSwgYnV0IGxpbWl0IG1lbW9yeSBzaXplIGluc3RlYWQgb2YgZW50cmllcyBjb3VudCIKIG1zZ3N0ciAiIgogImlkZW0gY2ktZGVzc3VzLCBtYWlzIGxpbWl0ZXIgbGEgdGFpbGxlIG3DqW1vaXJlIGF1IGxpZXUgZHUgbm9tYnJlIGQnw6lsw6ltZW50cyIKIAotIzogYnVpbHRpbi9yZXBhY2suYzozMTIKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6MzEzCiBtc2dpZCAibGltaXRzIHRoZSBtYXhpbXVtIGRlbHRhIGRlcHRoIgogbXNnc3RyICJsaW1pdGUgbGEgcHJvZm9uZGV1ciBtYXhpbWFsZSBkZXMgZGVsdGFzIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjMxNAorIzogYnVpbHRpbi9yZXBhY2suYzozMTUKIG1zZ2lkICJsaW1pdHMgdGhlIG1heGltdW0gbnVtYmVyIG9mIHRocmVhZHMiCiBtc2dzdHIgImxpbWl0ZSBsZSBub21icmUgbWF4aW1hbCBkZSBmaWxzIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjMxNgorIzogYnVpbHRpbi9yZXBhY2suYzozMTcKIG1zZ2lkICJtYXhpbXVtIHNpemUgb2YgZWFjaCBwYWNrZmlsZSIKIG1zZ3N0ciAidGFpbGxlIG1heGltdW0gZGUgY2hhcXVlIGZpY2hpZXIgcGFxdWV0IgogCi0jOiBidWlsdGluL3JlcGFjay5jOjMxOAorIzogYnVpbHRpbi9yZXBhY2suYzozMTkKIG1zZ2lkICJyZXBhY2sgb2JqZWN0cyBpbiBwYWNrcyBtYXJrZWQgd2l0aCAua2VlcCIKIG1zZ3N0ciAicsOpZW1wYXF1ZXRlciBsZXMgb2JqZXRzIGRhbnMgZGVzIHBhcXVldHMgbWFycXXDqXMgYXZlYyAua2VlcCIKIAotIzogYnVpbHRpbi9yZXBhY2suYzozMjAKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6MzIxCiBtc2dpZCAiZG8gbm90IHJlcGFjayB0aGlzIHBhY2siCiBtc2dzdHIgIm5lIHBhcyByZW1wYXF1ZXRlciBjZSBwYXF1ZXQiCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MzMwCisjOiBidWlsdGluL3JlcGFjay5jOjMzMQogbXNnaWQgImNhbm5vdCBkZWxldGUgcGFja3MgaW4gYSBwcmVjaW91cy1vYmplY3RzIHJlcG8iCiBtc2dzdHIgImltcG9zc2libGUgZGUgc3VwcHJpbWVyIGxlcyBwYXF1ZXRzIGRhbnMgdW4gZMOpcMO0dCBkJ29iamV0cyBwcsOpY2lldXgiCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MzM0CisjOiBidWlsdGluL3JlcGFjay5jOjMzNQogbXNnaWQgIi0ta2VlcC11bnJlYWNoYWJsZSBhbmQgLUEgYXJlIGluY29tcGF0aWJsZSIKIG1zZ3N0ciAiLS1rZWVwLXVucmVhY2hhYmxlIGV0IC1BIHNvbnQgaW5jb21wYXRpYmxlcyIKIAotIzogYnVpbHRpbi9yZXBhY2suYzo0MTcKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6NDE4CiBtc2dpZCAiTm90aGluZyBuZXcgdG8gcGFjay4iCiBtc2dzdHIgIlJpZW4gZGUgbmV1ZiDDoCBlbXBhcXVldGVyLiIKIAotIzogYnVpbHRpbi9yZXBhY2suYzo0NzgKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6NDc5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJXQVJOSU5HOiBTb21lIHBhY2tzIGluIHVzZSBoYXZlIGJlZW4gcmVuYW1lZCBieVxuIgpAQCAtMTg3NzQsNyArMTg4NjIsNyBAQAogIkFMRVJURcKgOiBhdXNzaSDDqWNob3XDqS5cbiIKICJBTEVSVEXCoDogVmV1aWxsZXogbGVzIHJlbm9tbWVyIG1hbnVlbGxlbWVudCBkYW5zICVzIDpcbiIKIAotIzogYnVpbHRpbi9yZXBhY2suYzo1MjYKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6NTI3CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byByZW1vdmUgJyVzJyIKIG1zZ3N0ciAiw6ljaGVjIGRlIGxhIHN1cHByZXNzaW9uIGRlICclcyciCkBAIC0xODg4Miw4ICsxODk3MCw4IEBACiBtc2dpZCAidW5hYmxlIHRvIHdyaXRlIG9iamVjdCB0byBkYXRhYmFzZSIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkJ8OpY3JpcmUgbCdvYmpldCBkYW5zIGxhIGJhc2UgZGUgZG9ubsOpZXMiCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjMyMiBidWlsdGluL3JlcGxhY2UuYzozNzcgYnVpbHRpbi9yZXBsYWNlLmM6NDIyCi0jOiBidWlsdGluL3JlcGxhY2UuYzo0NTIKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjMyMiBidWlsdGluL3JlcGxhY2UuYzozNzggYnVpbHRpbi9yZXBsYWNlLmM6NDIzCisjOiBidWlsdGluL3JlcGxhY2UuYzo0NTMKICMsIGMtZm9ybWF0CiBtc2dpZCAibm90IGEgdmFsaWQgb2JqZWN0IG5hbWU6ICclcyciCiBtc2dzdHIgIm5vbSBkJ29iamV0IGludmFsaWRlIDogJyVzJyIKQEAgLTE4OTAyLDIyICsxODk5MCwyMiBAQAogbXNnaWQgIm5ldyBvYmplY3QgaXMgdGhlIHNhbWUgYXMgdGhlIG9sZCBvbmU6ICclcyciCiBtc2dzdHIgImxlIG5vdXZlbCBvYmpldCBlc3QgaWRlbnRpcXVlIMOgIGwnYW5jaWVuwqA6ICclcyciCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjM4MworIzogYnVpbHRpbi9yZXBsYWNlLmM6Mzg0CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBwYXJzZSAlcyBhcyBhIGNvbW1pdCIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkJ2FuYWx5c2VyICVzIGNvbW1lIGNvbW1pdCIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NDE0CisjOiBidWlsdGluL3JlcGxhY2UuYzo0MTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiYmFkIG1lcmdldGFnIGluIGNvbW1pdCAnJXMnIgogbXNnc3RyICJtYXV2YWlzZSDDqXRpcXVldHRlIGRlIGZ1c2lvbiBkYW5zIGxlIGNvbW1pdCAnJXMnIgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo0MTYKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjQxNwogIywgYy1mb3JtYXQKIG1zZ2lkICJtYWxmb3JtZWQgbWVyZ2V0YWcgaW4gY29tbWl0ICclcyciCiBtc2dzdHIgIsOpdGlxdWV0dGUgZGUgZnVzaW9uIG1hbGZvcm3DqWUgZGFucyBsZSBjb21taXQgJyVzJyIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NDI4CisjOiBidWlsdGluL3JlcGxhY2UuYzo0MjkKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIm9yaWdpbmFsIGNvbW1pdCAnJXMnIGNvbnRhaW5zIG1lcmdldGFnICclcycgdGhhdCBpcyBkaXNjYXJkZWQ7IHVzZSAtLWVkaXQgIgpAQCAtMTg5MjYsMzEgKzE5MDE0LDMxIEBACiAibGUgY29tbWl0IG9yaWdpbmFsICclcycgY29udGllbnQgbCfDqXRpcXVldHRlIGRlIGZ1c2lvbiAnJXMnIHF1aSBhIGRpc3BhcnUgOyAiCiAidXRpbGlzZXogLS1lZGl0IGF1IGxpZXUgZGUgLS1ncmFmdCIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NDY3CisjOiBidWlsdGluL3JlcGxhY2UuYzo0NjgKICMsIGMtZm9ybWF0CiBtc2dpZCAidGhlIG9yaWdpbmFsIGNvbW1pdCAnJXMnIGhhcyBhIGdwZyBzaWduYXR1cmUiCiBtc2dzdHIgImxlIGNvbW1pdCBvcmlnaW5hbCAnJXMnIGNvbnRpZW50IHVuZSBzaWduYXR1cmUgR1BHIgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo0NjgKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjQ2OQogbXNnaWQgInRoZSBzaWduYXR1cmUgd2lsbCBiZSByZW1vdmVkIGluIHRoZSByZXBsYWNlbWVudCBjb21taXQhIgogbXNnc3RyICJsYSBzaWduYXR1cmUgc2VyYSDDqWxpbWluw6llIGRhbnMgbGEgdmFsaWRhdGlvbiBkZSByZW1wbGFjZW1lbnQgISIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NDc4CisjOiBidWlsdGluL3JlcGxhY2UuYzo0NzkKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHdyaXRlIHJlcGxhY2VtZW50IGNvbW1pdCBmb3I6ICclcyciCiBtc2dzdHIgIkltcG9zc2libGUgZCfDqWNyaXJlIGxlIGNvbW1pdCBkZSByZW1wbGFjZW1lbnQgcG91ciAnJXMnIgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo0ODYKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjQ4NwogIywgYy1mb3JtYXQKIG1zZ2lkICJncmFmdCBmb3IgJyVzJyB1bm5lY2Vzc2FyeSIKIG1zZ3N0ciAiZ3JhZnQgcG91ciAnJXMnIG5vbiBuw6ljZXNzYWlyZSIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NDkwCisjOiBidWlsdGluL3JlcGxhY2UuYzo0OTEKICMsIGMtZm9ybWF0CiBtc2dpZCAibmV3IGNvbW1pdCBpcyB0aGUgc2FtZSBhcyB0aGUgb2xkIG9uZTogJyVzJyIKIG1zZ3N0ciAibGUgbm91dmVhdSBjb21taXQgZXN0IGlkZW50aXF1ZSDDoCBsJ2FuY2llbsKgOiAnJXMnIgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo1MjUKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjUyNgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiY291bGQgbm90IGNvbnZlcnQgdGhlIGZvbGxvd2luZyBncmFmdChzKTpcbiIKQEAgLTE4OTU5LDcxICsxOTA0Nyw3MSBAQAogImltcG9zc2libGUgZGUgY29udmVydGlyIGxhKGxlcykgZ3JlZmZlKHMpIHN1aXZhbnRlKHMpIDpcbiIKICIlcyIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NTQ2CisjOiBidWlsdGluL3JlcGxhY2UuYzo1NDcKIG1zZ2lkICJsaXN0IHJlcGxhY2UgcmVmcyIKIG1zZ3N0ciAiYWZmaWNoZXIgbGVzIHLDqWbDqXJlbmNlcyBkZSByZW1wbGFjZW1lbnQiCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU0NworIzogYnVpbHRpbi9yZXBsYWNlLmM6NTQ4CiBtc2dpZCAiZGVsZXRlIHJlcGxhY2UgcmVmcyIKIG1zZ3N0ciAic3VwcHJpbWVyIGxlcyByw6lmw6lyZW5jZXMgZGUgcmVtcGxhY2VtZW50IgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo1NDgKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU0OQogbXNnaWQgImVkaXQgZXhpc3Rpbmcgb2JqZWN0IgogbXNnc3RyICLDqWRpdGVyIGwnb2JqZXQgZXhpc3RhbnQiCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU0OQorIzogYnVpbHRpbi9yZXBsYWNlLmM6NTUwCiBtc2dpZCAiY2hhbmdlIGEgY29tbWl0J3MgcGFyZW50cyIKIG1zZ3N0ciAiTW9kaWZpZXIgbGVzIHBhcmVudHMgZCd1biBjb21taXQiCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU1MAorIzogYnVpbHRpbi9yZXBsYWNlLmM6NTUxCiBtc2dpZCAiY29udmVydCBleGlzdGluZyBncmFmdCBmaWxlIgogbXNnc3RyICJjb252ZXJ0aXIgbGUgZmljaGllciBkZSBncmVmZmUgZXhpc3RhbnQiCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU1MQorIzogYnVpbHRpbi9yZXBsYWNlLmM6NTUyCiBtc2dpZCAicmVwbGFjZSB0aGUgcmVmIGlmIGl0IGV4aXN0cyIKIG1zZ3N0ciAicmVtcGxhY2VyIGxhIHLDqWbDqXJlbmNlIHNpIGVsbGUgZXhpc3RlIgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo1NTMKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU1NAogbXNnaWQgImRvIG5vdCBwcmV0dHktcHJpbnQgY29udGVudHMgZm9yIC0tZWRpdCIKIG1zZ3N0ciAiYWZmaWNoZXIgc2FucyBtaXNlIGVuIGZvcm1lIHBvdXIgLS1lZGl0IgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo1NTQKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU1NQogbXNnaWQgInVzZSB0aGlzIGZvcm1hdCIKIG1zZ3N0ciAidXRpbGlzZXIgY2UgZm9ybWF0IgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo1NjcKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU2OAogbXNnaWQgIi0tZm9ybWF0IGNhbm5vdCBiZSB1c2VkIHdoZW4gbm90IGxpc3RpbmciCiBtc2dzdHIgIi0tZm9ybWF0IG5lIHBldXQgcGFzIMOqdHJlIHV0aWxpc8OpIHNhbnMgbGlzdGVyIgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo1NzUKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU3NgogbXNnaWQgIi1mIG9ubHkgbWFrZXMgc2Vuc2Ugd2hlbiB3cml0aW5nIGEgcmVwbGFjZW1lbnQiCiBtc2dzdHIgIi1mIG4nYSBkZSBzZW5zIHF1J2VuIMOpY3JpdmFudCB1biByZW1wbGFjZW1lbnQiCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU3OQorIzogYnVpbHRpbi9yZXBsYWNlLmM6NTgwCiBtc2dpZCAiLS1yYXcgb25seSBtYWtlcyBzZW5zZSB3aXRoIC0tZWRpdCIKIG1zZ3N0ciAiLS1yYXcgbidhIGRlIHNlbnMgcXUnYXZlYyBsJ29wdGlvbiAtLWVkaXQiCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU4NQorIzogYnVpbHRpbi9yZXBsYWNlLmM6NTg2CiBtc2dpZCAiLWQgbmVlZHMgYXQgbGVhc3Qgb25lIGFyZ3VtZW50IgogbXNnc3RyICItZCByZXF1aWVydCBhdSBtb2lucyB1biBhcmd1bWVudCIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NTkxCisjOiBidWlsdGluL3JlcGxhY2UuYzo1OTIKIG1zZ2lkICJiYWQgbnVtYmVyIG9mIGFyZ3VtZW50cyIKIG1zZ3N0ciAibWF1dmFpcyBub21icmUgZCdhcmd1bWVudHMiCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU5NworIzogYnVpbHRpbi9yZXBsYWNlLmM6NTk4CiBtc2dpZCAiLWUgbmVlZHMgZXhhY3RseSBvbmUgYXJndW1lbnQiCiBtc2dzdHIgIi1lIHJlcXVpZXJ0IHVuIHNldWwgYXJndW1lbnQiCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjYwMworIzogYnVpbHRpbi9yZXBsYWNlLmM6NjA0CiBtc2dpZCAiLWcgbmVlZHMgYXQgbGVhc3Qgb25lIGFyZ3VtZW50IgogbXNnc3RyICItZyByZXF1aWVydCBhdSBtb2lucyB1biBhcmd1bWVudCIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NjA5CisjOiBidWlsdGluL3JlcGxhY2UuYzo2MTAKIG1zZ2lkICItLWNvbnZlcnQtZ3JhZnQtZmlsZSB0YWtlcyBubyBhcmd1bWVudCIKIG1zZ3N0ciAiLS1jb252ZXJ0LWdyYWZ0LWZpbGUgbmUgc3VwcG9ydGUgYXVjdW4gYXJndW1lbnQiCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjYxNQorIzogYnVpbHRpbi9yZXBsYWNlLmM6NjE2CiBtc2dpZCAib25seSBvbmUgcGF0dGVybiBjYW4gYmUgZ2l2ZW4gd2l0aCAtbCIKIG1zZ3N0ciAiLWwgbidhY2NlcHRlIHF1J3VuIG1vdGlmcyIKIApAQCAtMTkwOTIsMTMgKzE5MTgwLDE4IEBACiBtc2dpZCAiRmFpbGVkIHRvIGZpbmQgdHJlZSBvZiAlcy4iCiBtc2dzdHIgIkltcG9zc2libGUgZGUgdHJvdXZlciBsJ2FyYnJlIHBvdXIgJXMuIgogCisjOiBidWlsdGluL3Jlc2V0LmM6MTE0CisjLCBjLWZvcm1hdAorbXNnaWQgIkhFQUQgaXMgbm93IGF0ICVzIgorbXNnc3RyICJIRUFEIGVzdCBtYWludGVuYW50IMOgICVzIgorCiAjOiBidWlsdGluL3Jlc2V0LmM6MTkzCiAjLCBjLWZvcm1hdAogbXNnaWQgIkNhbm5vdCBkbyBhICVzIHJlc2V0IGluIHRoZSBtaWRkbGUgb2YgYSBtZXJnZS4iCiBtc2dzdHIgIkltcG9zc2libGUgZGUgZmFpcmUgdW4gXCJyZXNldCAlc1wiIGF1IG1pbGlldSBkJ3VuZSBmdXNpb24uIgogCi0jOiBidWlsdGluL3Jlc2V0LmM6MjkzIGJ1aWx0aW4vc3Rhc2guYzo1MTQgYnVpbHRpbi9zdGFzaC5jOjU4OQotIzogYnVpbHRpbi9zdGFzaC5jOjYxMworIzogYnVpbHRpbi9yZXNldC5jOjI5MyBidWlsdGluL3N0YXNoLmM6NTIwIGJ1aWx0aW4vc3Rhc2guYzo1OTUKKyM6IGJ1aWx0aW4vc3Rhc2guYzo2MTkKIG1zZ2lkICJiZSBxdWlldCwgb25seSByZXBvcnQgZXJyb3JzIgogbXNnc3RyICLDqnRyZSBzaWxlbmNpZXV4LCBhZmZpY2hlciBzZXVsZW1lbnQgbGVzIGVycmV1cnMiCiAKQEAgLTE5MTg2LDI0ICsxOTI3OSwxOSBAQAogbXNnaWQgIkNvdWxkIG5vdCB3cml0ZSBuZXcgaW5kZXggZmlsZS4iCiBtc2dzdHIgIkltcG9zc2libGUgZCfDqWNyaXJlIGxlIG5vdXZlYXUgZmljaGllciBkJ2luZGV4LiIKIAotIzogYnVpbHRpbi9yZXYtbGlzdC5jOjQxMgorIzogYnVpbHRpbi9yZXYtbGlzdC5jOjQxMQogbXNnaWQgImNhbm5vdCBjb21iaW5lIC0tZXhjbHVkZS1wcm9taXNvci1vYmplY3RzIGFuZCAtLW1pc3NpbmciCiBtc2dzdHIgImltcG9zc2libGUgZGUgY29tYmluZXIgLS1leGNsdWRlLXByb21pc29yLW9iamVjdHMgZXQgLS1taXNzaW5nIgogCi0jOiBidWlsdGluL3Jldi1saXN0LmM6NDczCisjOiBidWlsdGluL3Jldi1saXN0LmM6NDcyCiBtc2dpZCAib2JqZWN0IGZpbHRlcmluZyByZXF1aXJlcyAtLW9iamVjdHMiCiBtc2dzdHIgImxlIGZpbHRyYWdlIGQnb2JqZXQgZXhpZ2UgLS1vYmplY3RzIgogCi0jOiBidWlsdGluL3Jldi1saXN0LmM6NDc2Ci0jLCBjLWZvcm1hdAotbXNnaWQgImludmFsaWQgc3BhcnNlIHZhbHVlICclcyciCi1tc2dzdHIgInZhbGV1ciBpbnZhbGlkZSBkZSAnc3BhcnNlJyAnJXMnIgotCi0jOiBidWlsdGluL3Jldi1saXN0LmM6NTI3CisjOiBidWlsdGluL3Jldi1saXN0LmM6NTIyCiBtc2dpZCAicmV2LWxpc3QgZG9lcyBub3Qgc3VwcG9ydCBkaXNwbGF5IG9mIG5vdGVzIgogbXNnc3RyICJyZXYtbGlzdCBuZSBzdXBwb3J0ZSBsJ2FmZmljaGFnZSBkZXMgbm90ZXMiCiAKLSM6IGJ1aWx0aW4vcmV2LWxpc3QuYzo1MzAKKyM6IGJ1aWx0aW4vcmV2LWxpc3QuYzo1MjUKIG1zZ2lkICJjYW5ub3QgY29tYmluZSAtLXVzZS1iaXRtYXAtaW5kZXggd2l0aCBvYmplY3QgZmlsdGVyaW5nIgogbXNnc3RyICJpbXBvc3NpYmxlIGRlIGNvbWJpbmVyIC0tdXNlLWJpdG1hcC1pbmRleCBhdmVjIGxlIGZpbHRyYWdlIGQnb2JqZXQiCiAKQEAgLTE5NzU0LDEzNiArMTk4NDIsMTM2IEBACiBtc2dpZCAiY291bGQgbm90IHNhdmUgaW5kZXggdHJlZSIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkZSBzYXV2ZWdhcmRlciBsJ2FyYnJlIGQnaW5kZXgiCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzo0MzQKKyM6IGJ1aWx0aW4vc3Rhc2guYzo0MzYKIG1zZ2lkICJjb3VsZCBub3QgcmVzdG9yZSB1bnRyYWNrZWQgZmlsZXMgZnJvbSBzdGFzaCIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkZSByZXN0YXVyZXIgbGVzIGZpY2hpZXJzIG5vbi1zdWl2aXMgZGVwdWlzIGxlIHJlbWlzYWdlIgogCi0jOiBidWlsdGluL3N0YXNoLmM6NDQ4CisjOiBidWlsdGluL3N0YXNoLmM6NDUwCiAjLCBjLWZvcm1hdAogbXNnaWQgIk1lcmdpbmcgJXMgd2l0aCAlcyIKIG1zZ3N0ciAiRnVzaW9uIGRlICVzIGF2ZWMgJXMiCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzo0NTggZ2l0LWxlZ2FjeS1zdGFzaC5zaDo2ODAKKyM6IGJ1aWx0aW4vc3Rhc2guYzo0NjAgZ2l0LWxlZ2FjeS1zdGFzaC5zaDo2ODAKIG1zZ2lkICJJbmRleCB3YXMgbm90IHVuc3Rhc2hlZC4iCiBtc2dzdHIgIkwnaW5kZXggbidhIHBhcyDDqXTDqSBzb3J0aSBkZSByZW1pc2UuIgogCi0jOiBidWlsdGluL3N0YXNoLmM6NTE2IGJ1aWx0aW4vc3Rhc2guYzo2MTUKKyM6IGJ1aWx0aW4vc3Rhc2guYzo1MjIgYnVpbHRpbi9zdGFzaC5jOjYyMQogbXNnaWQgImF0dGVtcHQgdG8gcmVjcmVhdGUgdGhlIGluZGV4IgogbXNnc3RyICJ0ZW50YXRpdmUgZGUgcmVjcsOpZXIgbCdpbmRleCIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjU0OQorIzogYnVpbHRpbi9zdGFzaC5jOjU1NQogIywgYy1mb3JtYXQKIG1zZ2lkICJEcm9wcGVkICVzICglcykiCiBtc2dzdHIgIiVzIHN1cHByaW3DqSAoJXMpIgogCi0jOiBidWlsdGluL3N0YXNoLmM6NTUyCisjOiBidWlsdGluL3N0YXNoLmM6NTU4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiBDb3VsZCBub3QgZHJvcCBzdGFzaCBlbnRyeSIKIG1zZ3N0ciAiJXPCoDogSW1wb3NzaWJsZSBkZSBzdXBwcmltZXIgbCfDqWzDqW1lbnQgZGUgc3Rhc2giCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzo1NzcKKyM6IGJ1aWx0aW4vc3Rhc2guYzo1ODMKICMsIGMtZm9ybWF0CiBtc2dpZCAiJyVzJyBpcyBub3QgYSBzdGFzaCByZWZlcmVuY2UiCiBtc2dzdHIgIiclcycgbidlc3QgcGFzIHVuZSByw6lmw6lyZW5jZSBkZSByZW1pc2FnZSIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjYyNyBnaXQtbGVnYWN5LXN0YXNoLnNoOjY5NAorIzogYnVpbHRpbi9zdGFzaC5jOjYzMyBnaXQtbGVnYWN5LXN0YXNoLnNoOjY5NAogbXNnaWQgIlRoZSBzdGFzaCBlbnRyeSBpcyBrZXB0IGluIGNhc2UgeW91IG5lZWQgaXQgYWdhaW4uIgogbXNnc3RyICIiCiAiTCdlbnRyw6llIGRlIHJlbWlzYWdlIGVzdCBjb25zZXJ2w6llIGF1IGNhcyBvw7kgdm91cyBlbiBhdXJpZXogZW5jb3JlIGJlc29pbi4iCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzo2NTAgZ2l0LWxlZ2FjeS1zdGFzaC5zaDo3MTIKKyM6IGJ1aWx0aW4vc3Rhc2guYzo2NTYgZ2l0LWxlZ2FjeS1zdGFzaC5zaDo3MTIKIG1zZ2lkICJObyBicmFuY2ggbmFtZSBzcGVjaWZpZWQiCiBtc2dzdHIgIkF1Y3VuZSBicmFuY2hlIHNww6ljaWZpw6llIgogCi0jOiBidWlsdGluL3N0YXNoLmM6NzkwIGJ1aWx0aW4vc3Rhc2guYzo4MjcKKyM6IGJ1aWx0aW4vc3Rhc2guYzo3OTYgYnVpbHRpbi9zdGFzaC5jOjgzMwogIywgYy1mb3JtYXQKIG1zZ2lkICJDYW5ub3QgdXBkYXRlICVzIHdpdGggJXMiCiBtc2dzdHIgIkltcG9zc2libGUgZGUgbWV0dHJlIMOgIGpvdXIgJXMgYXZlYyAlcyIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjgwOCBidWlsdGluL3N0YXNoLmM6MTQ2MSBidWlsdGluL3N0YXNoLmM6MTQ5NworIzogYnVpbHRpbi9zdGFzaC5jOjgxNCBidWlsdGluL3N0YXNoLmM6MTQ3MCBidWlsdGluL3N0YXNoLmM6MTUwNgogbXNnaWQgInN0YXNoIG1lc3NhZ2UiCiBtc2dzdHIgIm1lc3NhZ2UgcG91ciBsZSByZW1pc2FnZSIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjgxOAorIzogYnVpbHRpbi9zdGFzaC5jOjgyNAogbXNnaWQgIlwiZ2l0IHN0YXNoIHN0b3JlXCIgcmVxdWlyZXMgb25lIDxjb21taXQ+IGFyZ3VtZW50IgogbXNnc3RyICJcImdpdCBzdGFzaCBzdG9yZVwiIGV4aWdlIHVuIGFyZ3VtZW50IDxjb21taXQ+IgogCi0jOiBidWlsdGluL3N0YXNoLmM6MTA0MCBnaXQtbGVnYWN5LXN0YXNoLnNoOjIxNworIzogYnVpbHRpbi9zdGFzaC5jOjEwNDYgZ2l0LWxlZ2FjeS1zdGFzaC5zaDoyMTcKIG1zZ2lkICJObyBjaGFuZ2VzIHNlbGVjdGVkIgogbXNnc3RyICJBdWN1biBjaGFuZ2VtZW50IHPDqWxlY3Rpb25uw6kiCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzoxMTM2IGdpdC1sZWdhY3ktc3Rhc2guc2g6MTUwCisjOiBidWlsdGluL3N0YXNoLmM6MTE0NSBnaXQtbGVnYWN5LXN0YXNoLnNoOjE1MAogbXNnaWQgIllvdSBkbyBub3QgaGF2ZSB0aGUgaW5pdGlhbCBjb21taXQgeWV0IgogbXNnc3RyICJWb3VzIG4nYXZleiBwYXMgZW5jb3JlIGxhIHZhbGlkYXRpb24gaW5pdGlhbGUiCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzoxMTYzIGdpdC1sZWdhY3ktc3Rhc2guc2g6MTY1CisjOiBidWlsdGluL3N0YXNoLmM6MTE3MiBnaXQtbGVnYWN5LXN0YXNoLnNoOjE2NQogbXNnaWQgIkNhbm5vdCBzYXZlIHRoZSBjdXJyZW50IGluZGV4IHN0YXRlIgogbXNnc3RyICJJbXBvc3NpYmxlIGRlIHNhdXZlciBsJ8OpdGF0IGNvdXJhbnQgZGUgbCdpbmRleCIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjExNzIgZ2l0LWxlZ2FjeS1zdGFzaC5zaDoxODAKKyM6IGJ1aWx0aW4vc3Rhc2guYzoxMTgxIGdpdC1sZWdhY3ktc3Rhc2guc2g6MTgwCiBtc2dpZCAiQ2Fubm90IHNhdmUgdGhlIHVudHJhY2tlZCBmaWxlcyIKIG1zZ3N0ciAiSW1wb3NzaWJsZSBkZSBzYXV2ZXIgbGVzIGZpY2hpZXJzIG5vbi1zdWl2aXMiCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzoxMTgzIGJ1aWx0aW4vc3Rhc2guYzoxMTkyIGdpdC1sZWdhY3ktc3Rhc2guc2g6MjAwCisjOiBidWlsdGluL3N0YXNoLmM6MTE5MiBidWlsdGluL3N0YXNoLmM6MTIwMSBnaXQtbGVnYWN5LXN0YXNoLnNoOjIwMAogIzogZ2l0LWxlZ2FjeS1zdGFzaC5zaDoyMTMKIG1zZ2lkICJDYW5ub3Qgc2F2ZSB0aGUgY3VycmVudCB3b3JrdHJlZSBzdGF0ZSIKIG1zZ3N0ciAiSW1wb3NzaWJsZSBkZSBzYXV2ZXIgbCfDqXRhdCBjb3VyYW50IGRlIGxhIGNvcGllIGRlIHRyYXZhaWwiCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzoxMjIwIGdpdC1sZWdhY3ktc3Rhc2guc2g6MjMzCisjOiBidWlsdGluL3N0YXNoLmM6MTIyOSBnaXQtbGVnYWN5LXN0YXNoLnNoOjIzMwogbXNnaWQgIkNhbm5vdCByZWNvcmQgd29ya2luZyB0cmVlIHN0YXRlIgogbXNnc3RyICJJbXBvc3NpYmxlIGQnZW5yZWdpc3RyZXIgbCfDqXRhdCBkZSBsYSBjb3BpZSBkZSB0cmF2YWlsIgogCi0jOiBidWlsdGluL3N0YXNoLmM6MTI2OSBnaXQtbGVnYWN5LXN0YXNoLnNoOjMzNworIzogYnVpbHRpbi9zdGFzaC5jOjEyNzggZ2l0LWxlZ2FjeS1zdGFzaC5zaDozMzcKIG1zZ2lkICJDYW4ndCB1c2UgLS1wYXRjaCBhbmQgLS1pbmNsdWRlLXVudHJhY2tlZCBvciAtLWFsbCBhdCB0aGUgc2FtZSB0aW1lIgogbXNnc3RyICIiCiAiSW1wb3NzaWJsZSBkJ3V0aWxpc2VyIC0tcGF0Y2ggZXQgLS1pbmNsdWRlLXVudHJhY2tlZCBvdSAtLWFsbCBlbiBtw6ptZSB0ZW1wcyIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjEyODUKKyM6IGJ1aWx0aW4vc3Rhc2guYzoxMjk0CiBtc2dpZCAiRGlkIHlvdSBmb3JnZXQgdG8gJ2dpdCBhZGQnPyIKIG1zZ3N0ciAiVm91cyBhdmV6IHPDu3JlbWVudCBvdWJsacOpICdnaXQgYWRkJyA/IgogCi0jOiBidWlsdGluL3N0YXNoLmM6MTMwMCBnaXQtbGVnYWN5LXN0YXNoLnNoOjM0NQorIzogYnVpbHRpbi9zdGFzaC5jOjEzMDkgZ2l0LWxlZ2FjeS1zdGFzaC5zaDozNDUKIG1zZ2lkICJObyBsb2NhbCBjaGFuZ2VzIHRvIHNhdmUiCiBtc2dzdHIgIlBhcyBkZSBtb2RpZmljYXRpb25zIGxvY2FsZXMgw6Agc2F1dmVyIgogCi0jOiBidWlsdGluL3N0YXNoLmM6MTMwNyBnaXQtbGVnYWN5LXN0YXNoLnNoOjM1MAorIzogYnVpbHRpbi9zdGFzaC5jOjEzMTYgZ2l0LWxlZ2FjeS1zdGFzaC5zaDozNTAKIG1zZ2lkICJDYW5ub3QgaW5pdGlhbGl6ZSBzdGFzaCIKIG1zZ3N0ciAiSW1wb3NzaWJsZSBkJ2luaXRpYWxpc2VyIGxlIHJlbWlzYWdlIgogCi0jOiBidWlsdGluL3N0YXNoLmM6MTMyMiBnaXQtbGVnYWN5LXN0YXNoLnNoOjM1NAorIzogYnVpbHRpbi9zdGFzaC5jOjEzMzEgZ2l0LWxlZ2FjeS1zdGFzaC5zaDozNTQKIG1zZ2lkICJDYW5ub3Qgc2F2ZSB0aGUgY3VycmVudCBzdGF0dXMiCiBtc2dzdHIgIkltcG9zc2libGUgZGUgc2F1dmVyIGwnw6l0YXQgY291cmFudCIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjEzMjcKKyM6IGJ1aWx0aW4vc3Rhc2guYzoxMzM2CiAjLCBjLWZvcm1hdAogbXNnaWQgIlNhdmVkIHdvcmtpbmcgZGlyZWN0b3J5IGFuZCBpbmRleCBzdGF0ZSAlcyIKIG1zZ3N0ciAiQXJicmUgZGUgdHJhdmFpbCBldCDDqXRhdCBkZSBsJ2luZGV4IHNhdXZlZ2FyZMOpcyBkYW5zICVzIgogCi0jOiBidWlsdGluL3N0YXNoLmM6MTQxNyBnaXQtbGVnYWN5LXN0YXNoLnNoOjM4NAorIzogYnVpbHRpbi9zdGFzaC5jOjE0MjYgZ2l0LWxlZ2FjeS1zdGFzaC5zaDozODQKIG1zZ2lkICJDYW5ub3QgcmVtb3ZlIHdvcmt0cmVlIGNoYW5nZXMiCiBtc2dzdHIgIkltcG9zc2libGUgZGUgc3VwcHJpbWVyIGxlcyBjaGFuZ2VtZW50cyBkZSBsYSBjb3BpZSBkZSB0cmF2YWlsIgogCi0jOiBidWlsdGluL3N0YXNoLmM6MTQ1MiBidWlsdGluL3N0YXNoLmM6MTQ4OAorIzogYnVpbHRpbi9zdGFzaC5jOjE0NjEgYnVpbHRpbi9zdGFzaC5jOjE0OTcKIG1zZ2lkICJrZWVwIGluZGV4IgogbXNnc3RyICJjb25zZXJ2ZXIgbCdpbmRleCIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjE0NTQgYnVpbHRpbi9zdGFzaC5jOjE0OTAKKyM6IGJ1aWx0aW4vc3Rhc2guYzoxNDYzIGJ1aWx0aW4vc3Rhc2guYzoxNDk5CiBtc2dpZCAic3Rhc2ggaW4gcGF0Y2ggbW9kZSIKIG1zZ3N0ciAicmVtaXNlciB1bmUgbW9kZSBydXN0aW5lIgogCi0jOiBidWlsdGluL3N0YXNoLmM6MTQ1NSBidWlsdGluL3N0YXNoLmM6MTQ5MQorIzogYnVpbHRpbi9zdGFzaC5jOjE0NjQgYnVpbHRpbi9zdGFzaC5jOjE1MDAKIG1zZ2lkICJxdWlldCBtb2RlIgogbXNnc3RyICJtb2RlIHNpbGVuY2lldXgiCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzoxNDU3IGJ1aWx0aW4vc3Rhc2guYzoxNDkzCisjOiBidWlsdGluL3N0YXNoLmM6MTQ2NiBidWlsdGluL3N0YXNoLmM6MTUwMgogbXNnaWQgImluY2x1ZGUgdW50cmFja2VkIGZpbGVzIGluIHN0YXNoIgogbXNnc3RyICJpbmNsdXJlIGxlcyBmaWNoaWVycyBub24gc3VpdmlzIGRhbnMgbGEgcmVtaXNlIgogCi0jOiBidWlsdGluL3N0YXNoLmM6MTQ1OSBidWlsdGluL3N0YXNoLmM6MTQ5NQorIzogYnVpbHRpbi9zdGFzaC5jOjE0NjggYnVpbHRpbi9zdGFzaC5jOjE1MDQKIG1zZ2lkICJpbmNsdWRlIGlnbm9yZSBmaWxlcyIKIG1zZ3N0ciAiaW5jbHVyZSBsZXMgZmljaGllcnMgaWdub3LDqXMiCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzoxNTU1CisjOiBidWlsdGluL3N0YXNoLmM6MTU2NAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgZXhlYyAlcyIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkJ2V4w6ljdXRlciAlcyIKQEAgLTIwMjY3LDggKzIwMzU1LDggQEAKIG1zZ3N0ciAibmUgcGFzIGFmZmljaGVyIGxhIHByb2dyZXNzaW9uIGR1IGNsb25hZ2UiCiAKICM6IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxODc3Ci1tc2dpZCAiZ2l0IHN1Ym1vZHVsZS0taGVscGVyIHVwZGF0ZV9jbG9uZSBbLS1wcmVmaXg9PHBhdGg+XSBbPHBhdGg+Li4uXSIKLW1zZ3N0ciAiZ2l0IHN1Ym1vZHVsZS0taGVscGVyIHVwZGF0ZV9jbG9uZSBbLS1wcmVmaXg9PGNoZW1pbj5dIFs8Y2hlbWluPi4uLl0iCittc2dpZCAiZ2l0IHN1Ym1vZHVsZS0taGVscGVyIHVwZGF0ZS1jbG9uZSBbLS1wcmVmaXg9PHBhdGg+XSBbPHBhdGg+Li4uXSIKK21zZ3N0ciAiZ2l0IHN1Ym1vZHVsZS0taGVscGVyIHVwZGF0ZS1jbG9uZSBbLS1wcmVmaXg9PGNoZW1pbj5dIFs8Y2hlbWluPi4uLl0iCiAKICM6IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxODkwCiBtc2dpZCAiYmFkIHZhbHVlIGZvciB1cGRhdGUgcGFyYW1ldGVyIgpAQCAtMjAzMjIsNyArMjA0MTAsNyBAQAogbXNnc3RyICIiCiAidmV1aWxsZXogdm91cyBhc3N1cmVyIHF1ZSBsZSBmaWNoaWVyIC5naXRtb2R1bGVzIGVzdCBkYW5zIGwnYXJicmUgZGUgdHJhdmFpbCIKIAotIzogYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjIyMzUgZ2l0LmM6NDM0IGdpdC5jOjY4NAorIzogYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjIyMzUgZ2l0LmM6NDMzIGdpdC5jOjY4MwogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyBkb2Vzbid0IHN1cHBvcnQgLS1zdXBlci1wcmVmaXgiCiBtc2dzdHIgIiVzIG5lIGfDqHJlIHBhcyAtLXN1cGVyLXByZWZpeCIKQEAgLTIwNjU1LDE0NCArMjA3NDMsMTQ0IEBACiBtc2dpZCAiZ2l0IHVwZGF0ZS1pbmRleCBbPG9wdGlvbnM+XSBbLS1dIFs8ZmlsZT4uLi5dIgogbXNnc3RyICJnaXQgdXBkYXRlLWluZGV4IFs8b3B0aW9ucz5dIFstLV0gWzxmaWNoaWVyPi4uLl0iCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6OTcxCisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjk3MgogbXNnaWQgImNvbnRpbnVlIHJlZnJlc2ggZXZlbiB3aGVuIGluZGV4IG5lZWRzIHVwZGF0ZSIKIG1zZ3N0ciAiY29udGludWVyIGRlIHJhZnJhw65jaGlyIG3Dqm1lIHNpIGwnaW5kZXggYSBiZXNvaW4gZCd1bmUgbWlzZSDDoCBqb3VyIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjk3NAorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzo5NzUKIG1zZ2lkICJyZWZyZXNoOiBpZ25vcmUgc3VibW9kdWxlcyIKIG1zZ3N0ciAicmFmcmHDrmNoaXIgOiBpZ25vcmVyIGxlcyBzb3VzLW1vZHVsZXMiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6OTc3CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjk3OAogbXNnaWQgImRvIG5vdCBpZ25vcmUgbmV3IGZpbGVzIgogbXNnc3RyICJuZSBwYXMgaWdub3JlciBsZXMgbm91dmVhdXggZmljaGllcnMiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6OTc5CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjk4MAogbXNnaWQgImxldCBmaWxlcyByZXBsYWNlIGRpcmVjdG9yaWVzIGFuZCB2aWNlLXZlcnNhIgogbXNnc3RyICJsYWlzc2VyIGxlcyBmaWNoaWVycyByZW1wbGFjZXIgZGVzIHLDqXBlcnRvaXJlcyBldCB2aWNlLXZlcnNhIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjk4MQorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzo5ODIKIG1zZ2lkICJub3RpY2UgZmlsZXMgbWlzc2luZyBmcm9tIHdvcmt0cmVlIgogbXNnc3RyICJhdmlzZXIgZGVzIGZpY2hpZXJzIG1hbnF1YW50cyBkYW5zIGxhIGNvcGllIGRlIHRyYXZhaWwiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6OTgzCisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjk4NAogbXNnaWQgInJlZnJlc2ggZXZlbiBpZiBpbmRleCBjb250YWlucyB1bm1lcmdlZCBlbnRyaWVzIgogbXNnc3RyICJyYWZyYcOuY2hpciBtw6ptZSBzaSBsJ2luZGV4IGNvbnRpZW50IGRlcyDDqWzDqW1lbnRzIG5vbiBmdXNpb25uw6lzIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjk4NgorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzo5ODcKIG1zZ2lkICJyZWZyZXNoIHN0YXQgaW5mb3JtYXRpb24iCiBtc2dzdHIgInJhZnJhw65jaGlyIGwnaW5mb3JtYXRpb24gZGUgc3RhdCIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzo5OTAKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6OTkxCiBtc2dpZCAibGlrZSAtLXJlZnJlc2gsIGJ1dCBpZ25vcmUgYXNzdW1lLXVuY2hhbmdlZCBzZXR0aW5nIgogbXNnc3RyICJjb21tZSAtLXJlZnJlc2gsIG1haXMgZW4gaWdub3JhbnQgbCdvcHRpb24gYXNzdW1lLXVuY2hhbmdlZCIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzo5OTQKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6OTk1CiBtc2dpZCAiPG1vZGU+LDxvYmplY3Q+LDxwYXRoPiIKIG1zZ3N0ciAiPG1vZGU+LCA8b2JqZXQ+LCA8Y2hlbWluPiIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzo5OTUKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6OTk2CiBtc2dpZCAiYWRkIHRoZSBzcGVjaWZpZWQgZW50cnkgdG8gdGhlIGluZGV4IgogbXNnc3RyICJham91dGVyIGwnw6lsw6ltZW50IHNww6ljaWZpw6kgZGFucyBsJ2luZGV4IgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMDUKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAwNgogbXNnaWQgIm1hcmsgZmlsZXMgYXMgXCJub3QgY2hhbmdpbmdcIiIKIG1zZ3N0ciAibWFycXVlciBsZXMgZmljaGllcnMgY29tbWUgXCJub24gY2hhbmdlYW50c1wiIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMDgKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAwOQogbXNnaWQgImNsZWFyIGFzc3VtZWQtdW5jaGFuZ2VkIGJpdCIKIG1zZ3N0ciAibWV0dHJlIMOgIHrDqXJvIGxlIGJpdCBzdXBwb3PDqS1ub24tbW9kaWZpw6kiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAxMQorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDEyCiBtc2dpZCAibWFyayBmaWxlcyBhcyBcImluZGV4LW9ubHlcIiIKIG1zZ3N0ciAibWFycXVlciBsZXMgZmljaGllcnMgY29tbWUgXCJpbmRleCBzZXVsZW1lbnRcIiIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDE0CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMTUKIG1zZ2lkICJjbGVhciBza2lwLXdvcmt0cmVlIGJpdCIKIG1zZ3N0ciAibWV0dHJlIMOgIHrDqXJvIGxlIGJpdCBzYXV0ZXItbGEtY29waWUtZGUgdHJhdmFpbCIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDE3CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMTgKIG1zZ2lkICJhZGQgdG8gaW5kZXggb25seTsgZG8gbm90IGFkZCBjb250ZW50IHRvIG9iamVjdCBkYXRhYmFzZSIKIG1zZ3N0ciAiIgogImFqb3V0ZXIgc2V1bGVtZW50IMOgIGwnaW5kZXggOyBuZSBwYXMgYWpvdXRlciBsZSBjb250ZW51IGRhbnMgbGEgYmFzZSBkZSAiCiAiZG9ubsOpZXMgZGVzIG9iamV0cyIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDE5CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMjAKIG1zZ2lkICJyZW1vdmUgbmFtZWQgcGF0aHMgZXZlbiBpZiBwcmVzZW50IGluIHdvcmt0cmVlIgogbXNnc3RyICIiCiAic3VwcHJpbWVyIGxlcyBjaGVtaW5zIG5vbW3DqXMgbcOqbWUgcydpbHMgc29udCBwcsOpc2VudHMgZGFucyBsYSBjb3BpZSBkZSAiCiAidHJhdmFpbCIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDIxCisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMjIKIG1zZ2lkICJ3aXRoIC0tc3RkaW46IGlucHV0IGxpbmVzIGFyZSB0ZXJtaW5hdGVkIGJ5IG51bGwgYnl0ZXMiCiBtc2dzdHIgImF2ZWMgLS1zdGRpbiA6IGxlcyBsaWduZXMgZW4gZW50csOpZSBzb250IHRlcm1pbsOpZXMgcGFyIGRlcyBvY3RldHMgbnVscyIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDIzCisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMjQKIG1zZ2lkICJyZWFkIGxpc3Qgb2YgcGF0aHMgdG8gYmUgdXBkYXRlZCBmcm9tIHN0YW5kYXJkIGlucHV0IgogbXNnc3RyICJsaXJlIGxhIGxpc3RlIGRlcyBjaGVtaW5zIMOgIG1ldHRyZSDDoCBqb3VyIGRlcHVpcyBsJ2VudHLDqWUgc3RhbmRhcmQiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAyNworIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDI4CiBtc2dpZCAiYWRkIGVudHJpZXMgZnJvbSBzdGFuZGFyZCBpbnB1dCB0byB0aGUgaW5kZXgiCiBtc2dzdHIgImFqb3V0ZXIgbGVzIMOpbMOpbWVudHMgZGVwdWlzIGwnZW50csOpZSBzdGFuZGFyZCDDoCBsJ2luZGV4IgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMzEKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAzMgogbXNnaWQgInJlcG9wdWxhdGUgc3RhZ2VzICMyIGFuZCAjMyBmb3IgdGhlIGxpc3RlZCBwYXRocyIKIG1zZ3N0ciAicmVwZXVwbGVyIGxlcyDDqXRhcGVzIG7CsDIgZXQgbsKwMyBwb3VyIGxlcyBjaGVtaW5zIGxpc3TDqXMiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAzNQorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDM2CiBtc2dpZCAib25seSB1cGRhdGUgZW50cmllcyB0aGF0IGRpZmZlciBmcm9tIEhFQUQiCiBtc2dzdHIgIm1ldHRyZSDDoCBqb3VyIHNldWxlbWVudCBsZXMgw6lsw6ltZW50cyBxdWkgZGlmZsOocmVudCBkZSBIRUFEIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMzkKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTA0MAogbXNnaWQgImlnbm9yZSBmaWxlcyBtaXNzaW5nIGZyb20gd29ya3RyZWUiCiBtc2dzdHIgImlnbm9yZXIgbGVzIGZpY2hpZXJzIG1hbnF1YW50cyBkYW5zIGxhIGNvcGllIGRlIHRyYXZhaWwiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTA0MgorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDQzCiBtc2dpZCAicmVwb3J0IGFjdGlvbnMgdG8gc3RhbmRhcmQgb3V0cHV0IgogbXNnc3RyICJhZmZpY2hlciBsZXMgYWN0aW9ucyBzdXIgbGEgc29ydGllIHN0YW5kYXJkIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwNDQKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTA0NQogbXNnaWQgIihmb3IgcG9yY2VsYWlucykgZm9yZ2V0IHNhdmVkIHVucmVzb2x2ZWQgY29uZmxpY3RzIgogbXNnc3RyICIocG91ciBwb3JjZWxhaW5lcykgb3VibGllciBsZXMgY29uZmxpdHMgc2F1dsOpcyBldCBub24gcsOpc29sdXMiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTA0OAorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDQ5CiBtc2dpZCAid3JpdGUgaW5kZXggaW4gdGhpcyBmb3JtYXQiCiBtc2dzdHIgIsOpY3JpcmUgbCdpbmRleCBkYW5zIGNlIGZvcm1hdCIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDUwCisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwNTEKIG1zZ2lkICJlbmFibGUgb3IgZGlzYWJsZSBzcGxpdCBpbmRleCIKIG1zZ3N0ciAiYWN0aXZlciBvdSBkw6lzYWN0aXZlciBsJ2luZGV4IGRpdmlzw6kiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTA1MgorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDUzCiBtc2dpZCAiZW5hYmxlL2Rpc2FibGUgdW50cmFja2VkIGNhY2hlIgogbXNnc3RyICJhY3RpdmVyIG91IGTDqXNhY3RpdmVyIGxlIGNhY2hlIGRlIG5vbi1zdWl2aXMiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTA1NAorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDU1CiBtc2dpZCAidGVzdCBpZiB0aGUgZmlsZXN5c3RlbSBzdXBwb3J0cyB1bnRyYWNrZWQgY2FjaGUiCiBtc2dzdHIgInRlc3RlciBzaSBsZSBzeXN0w6htZSBkZSBmaWNoaWVyIHN1cHBvcnRlIGxlIGNhY2hlIGRlIG5vbi1zdWl2aXMiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTA1NgorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDU3CiBtc2dpZCAiZW5hYmxlIHVudHJhY2tlZCBjYWNoZSB3aXRob3V0IHRlc3RpbmcgdGhlIGZpbGVzeXN0ZW0iCiBtc2dzdHIgImFjdGl2ZXIgbGUgY2FjaGUgZGUgbm9uLXN1aXZpcyBzYW5zIHRlc3RlciBsZSBzeXN0w6htZSBkZSBmaWNoaWVyIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwNTgKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTA1OQogbXNnaWQgIndyaXRlIG91dCB0aGUgaW5kZXggZXZlbiBpZiBpcyBub3QgZmxhZ2dlZCBhcyBjaGFuZ2VkIgogbXNnc3RyICLDqWNyaXJlIGwnaW5kZXggbcOqbWUgcydpbCBuJ2VzdCBwYXMgbWFycXXDqSBjb21tZSBtb2RpZmnDqSIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDYwCisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwNjEKIG1zZ2lkICJlbmFibGUgb3IgZGlzYWJsZSBmaWxlIHN5c3RlbSBtb25pdG9yIgogbXNnc3RyICIiCiAiYWN0aXZlciBvdSBkw6lzYWN0aXZlciBsYSBzdXJ2ZWlsbGFuY2UgZHUgc3lzdMOobWUgZGUgZmljaGllciAoZnNtb25pdG9yKSIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDYyCisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwNjMKIG1zZ2lkICJtYXJrIGZpbGVzIGFzIGZzbW9uaXRvciB2YWxpZCIKIG1zZ3N0ciAibWFycXVlciBsZXMgZmljaGllcnMgY29tbWUgdmFsaWRlcyBwb3VyIGZzbW9uaXRvciIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDY1CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwNjYKIG1zZ2lkICJjbGVhciBmc21vbml0b3IgdmFsaWQgYml0IgogbXNnc3RyICJlZmZhY2VyIGxlIGJpdCBkZSB2YWxpZGl0w6kgZnNtb25pdG9yIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjExNjgKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTE2OQogbXNnaWQgIiIKICJjb3JlLnNwbGl0SW5kZXggaXMgc2V0IHRvIGZhbHNlOyByZW1vdmUgb3IgY2hhbmdlIGl0LCBpZiB5b3UgcmVhbGx5IHdhbnQgdG8gIgogImVuYWJsZSBzcGxpdCBpbmRleCIKQEAgLTIwODAwLDcgKzIwODg4LDcgQEAKICJjb3JlLnNwbGl0SW5kZXggZXN0IHLDqWdsw6kgw6AgZmFsc2XCoDsgc3VwcHJpbWV6LWxlIG91IGNoYW5nZXotbGUgc2kgdm91cyAiCiAic291aGFpdGV6IHZyYWltZW50IGFjdGl2ZXIgbCdpbmRleCBjb3Vww6kiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTE3NworIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMTc4CiBtc2dpZCAiIgogImNvcmUuc3BsaXRJbmRleCBpcyBzZXQgdG8gdHJ1ZTsgcmVtb3ZlIG9yIGNoYW5nZSBpdCwgaWYgeW91IHJlYWxseSB3YW50IHRvICIKICJkaXNhYmxlIHNwbGl0IGluZGV4IgpAQCAtMjA4MDgsNyArMjA4OTYsNyBAQAogImNvcmUuc3BsaXRJbmRleCBlc3QgcsOpZ2zDqSDDoCB2cmFpwqA7IHN1cHByaW1lei1sZSBvdSBjaGFuZ2V6LWxlIHNpIHZvdXMgIgogInNvdWhhaXRleiB2cmFpbWVudCBkw6lzYWN0aXZlciBsJ2luZGV4IGNvdXDDqSIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMTg4CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjExOTAKIG1zZ2lkICIiCiAiY29yZS51bnRyYWNrZWRDYWNoZSBpcyBzZXQgdG8gdHJ1ZTsgcmVtb3ZlIG9yIGNoYW5nZSBpdCwgaWYgeW91IHJlYWxseSB3YW50ICIKICJ0byBkaXNhYmxlIHRoZSB1bnRyYWNrZWQgY2FjaGUiCkBAIC0yMDgxNiwxMSArMjA5MDQsMTEgQEAKICJjb3JlLnVudHJhY2tlZENhY2hlIGVzdCByw6lnbMOpIMOgIHRydWXCoDsgc3VwcHJpbWV6LWxlIG91IGNoYW5nZXotbGUgc2kgdm91cyAiCiAic291aGFpdGV6IHZyYWltZW50IGTDqXNhY3RpdmVyIGxlIGNhY2hlIGRlcyBmaWNoaWVycyBub24tc3VpdmlzIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjExOTIKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTE5NAogbXNnaWQgIlVudHJhY2tlZCBjYWNoZSBkaXNhYmxlZCIKIG1zZ3N0ciAiTGUgY2FjaGUgbm9uIHN1aXZpIGVzdCBkw6lzYWN0aXbDqSIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMjAwCisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEyMDIKIG1zZ2lkICIiCiAiY29yZS51bnRyYWNrZWRDYWNoZSBpcyBzZXQgdG8gZmFsc2U7IHJlbW92ZSBvciBjaGFuZ2UgaXQsIGlmIHlvdSByZWFsbHkgd2FudCAiCiAidG8gZW5hYmxlIHRoZSB1bnRyYWNrZWQgY2FjaGUiCkBAIC0yMDgyOCwyOSArMjA5MTYsMjkgQEAKICJjb3JlLnVudHJhY2tlZENhY2hlIGVzdCByw6lnbMOpIMOgIGZhbHNlwqA7IHN1cHByaW1lei1sZSBvdSBjaGFuZ2V6LWxlIHNpIHZvdXMgIgogInNvdWhhaXRleiB2cmFpbWVudCBhY3RpdmVyIGxlIGNhY2hlIGRlcyBmaWNoaWVycyBub24tc3VpdmlzIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEyMDQKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTIwNgogIywgYy1mb3JtYXQKIG1zZ2lkICJVbnRyYWNrZWQgY2FjaGUgZW5hYmxlZCBmb3IgJyVzJyIKIG1zZ3N0ciAiTGUgY2FjaGUgbm9uIHN1aXZpIGVzdCBhY3RpdsOpIHBvdXIgJyVzJyIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMjEyCisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEyMTQKIG1zZ2lkICJjb3JlLmZzbW9uaXRvciBpcyB1bnNldDsgc2V0IGl0IGlmIHlvdSByZWFsbHkgd2FudCB0byBlbmFibGUgZnNtb25pdG9yIgogbXNnc3RyICIiCiAiY29yZS5mc21vbml0b3IgZXN0IHLDqWdsw6kgw6AgZmFsc2XCoDsgY2hhbmdlei1sZSBzaSB2b3VzIHNvdWhhaXRleiB2cmFpbWVudCAiCiAiYWN0aXZlciBsYSBzdXJ2ZWlsbGFuY2UgZHUgc3lzdMOobWUgZGUgZmljaGllcnMiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTIxNgorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMjE4CiBtc2dpZCAiZnNtb25pdG9yIGVuYWJsZWQiCiBtc2dzdHIgImZzbW9uaXRvciBhY3RpdsOpIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEyMTkKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTIyMQogbXNnaWQgIiIKICJjb3JlLmZzbW9uaXRvciBpcyBzZXQ7IHJlbW92ZSBpdCBpZiB5b3UgcmVhbGx5IHdhbnQgdG8gZGlzYWJsZSBmc21vbml0b3IiCiBtc2dzdHIgIiIKICJjb3JlLmZzbW9uaXRvciBlc3QgcsOpZ2zDqSDDoCB0cnVlwqA7IHN1cHByaW1lei1sZSBvdSBjaGFuZ2V6LWxlIHNpIHZvdXMgIgogInNvdWhhaXRleiB2cmFpbWVudCBkw6lzYWN0aXZlciBsYSBzdXJ2ZWlsbGFuY2UgZHUgc3lzdMOobWUgZGUgZmljaGllcnMiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTIyMworIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMjI1CiBtc2dpZCAiZnNtb25pdG9yIGRpc2FibGVkIgogbXNnc3RyICJmc21vbml0b3IgZMOpc2FjdGl2w6kiCiAKQEAgLTIwOTQ2LDU2ICsyMTAzNCw1NiBAQAogbXNnaWQgInByaW50IHRhZyBjb250ZW50cyIKIG1zZ3N0ciAiYWZmaWNoZXIgbGUgY29udGVudSBkZSBsJ8OpdGlxdWV0dGUiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzoxOAorIzogYnVpbHRpbi93b3JrdHJlZS5jOjE3CiBtc2dpZCAiZ2l0IHdvcmt0cmVlIGFkZCBbPG9wdGlvbnM+XSA8cGF0aD4gWzxjb21taXQtaXNoPl0iCiBtc2dzdHIgImdpdCB3b3JrdHJlZSBhZGQgWzxvcHRpb25zPl0gPGNoZW1pbj4gWzxjb21taXQ+XSIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjE5CisjOiBidWlsdGluL3dvcmt0cmVlLmM6MTgKIG1zZ2lkICJnaXQgd29ya3RyZWUgbGlzdCBbPG9wdGlvbnM+XSIKIG1zZ3N0ciAiZ2l0IHdvcmt0cmVlIGxpc3QgWzxvcHRpb25zPl0iCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzoyMAorIzogYnVpbHRpbi93b3JrdHJlZS5jOjE5CiBtc2dpZCAiZ2l0IHdvcmt0cmVlIGxvY2sgWzxvcHRpb25zPl0gPHBhdGg+IgogbXNnc3RyICJnaXQgd29ya3RyZWUgbG9jayBbPG9wdGlvbnM+XSA8Y2hlbWluPiIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjIxCisjOiBidWlsdGluL3dvcmt0cmVlLmM6MjAKIG1zZ2lkICJnaXQgd29ya3RyZWUgbW92ZSA8d29ya3RyZWU+IDxuZXctcGF0aD4iCiBtc2dzdHIgImdpdCB3b3JrdHJlZSBtb3ZlIDxhcmJyZS1kZS10cmF2YWlsPiA8bm91dmVhdS1jaGVtaW4+IgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6MjIKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzoyMQogbXNnaWQgImdpdCB3b3JrdHJlZSBwcnVuZSBbPG9wdGlvbnM+XSIKIG1zZ3N0ciAiZ2l0IHdvcmt0cmVlIHBydW5lIFs8b3B0aW9ucz5dIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6MjMKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzoyMgogbXNnaWQgImdpdCB3b3JrdHJlZSByZW1vdmUgWzxvcHRpb25zPl0gPHdvcmt0cmVlPiIKIG1zZ3N0ciAiZ2l0IHdvcmt0cmVlIHJlbW92ZSBbPG9wdGlvbnM+XSA8YXJicmUtZGUtdHJhdmFpbD4iCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzoyNAorIzogYnVpbHRpbi93b3JrdHJlZS5jOjIzCiBtc2dpZCAiZ2l0IHdvcmt0cmVlIHVubG9jayA8cGF0aD4iCiBtc2dzdHIgImdpdCB3b3JrdHJlZSB1bmxvY2sgPGNoZW1pbj4iCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo2MSBidWlsdGluL3dvcmt0cmVlLmM6ODk5CisjOiBidWlsdGluL3dvcmt0cmVlLmM6NjAgYnVpbHRpbi93b3JrdHJlZS5jOjg5OAogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gZGVsZXRlICclcyciCiBtc2dzdHIgIsOpY2hlYyBkZSBsYSBzdXBwcmVzc2lvbiBkZSAnJXMnIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6ODAKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo3OQogIywgYy1mb3JtYXQKIG1zZ2lkICJSZW1vdmluZyB3b3JrdHJlZXMvJXM6IG5vdCBhIHZhbGlkIGRpcmVjdG9yeSIKIG1zZ3N0ciAiU3VwcHJlc3Npb24gZGUgd29ya3RyZWVzLyVzwqA6IHLDqXBlcnRvaXJlIGludmFsaWRlIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6ODYKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4NQogIywgYy1mb3JtYXQKIG1zZ2lkICJSZW1vdmluZyB3b3JrdHJlZXMvJXM6IGdpdGRpciBmaWxlIGRvZXMgbm90IGV4aXN0IgogbXNnc3RyICJTdXBwcmVzc2lvbiBkZSB3b3JrdHJlZXMvJXPCoDogbGUgZmljaGllciBnaXRkaXIgbidleGlzdGUgcGFzIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6OTEgYnVpbHRpbi93b3JrdHJlZS5jOjEwMAorIzogYnVpbHRpbi93b3JrdHJlZS5jOjkwIGJ1aWx0aW4vd29ya3RyZWUuYzo5OQogIywgYy1mb3JtYXQKIG1zZ2lkICJSZW1vdmluZyB3b3JrdHJlZXMvJXM6IHVuYWJsZSB0byByZWFkIGdpdGRpciBmaWxlICglcykiCiBtc2dzdHIgIiIKICJTdXBwcmVzc2lvbiBkZSB3b3JrdHJlZXMvJXPCoDogw6ljaGVjIGRlIGxhIGxlY3R1cmUgZHUgZmljaGllciBnaXRkaXIgKCVzKSIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjExMAorIzogYnVpbHRpbi93b3JrdHJlZS5jOjEwOQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiUmVtb3Zpbmcgd29ya3RyZWVzLyVzOiBzaG9ydCByZWFkIChleHBlY3RlZCAlPFBSSXVNQVg+IGJ5dGVzLCByZWFkICIKQEAgLTIxMDA0LDM3ICsyMTA5MiwzNyBAQAogIlN1cHByZXNzaW9uIGRlIHdvcmt0cmVlcy8lczogbGVjdHVyZSB0cm9wIGNvdXJ0ZSAoICU8UFJJdU1BWD4gb2N0ZXRzICIKICJhdHRlbmR1cywgJTxQUkl1TUFYPiBvY3RldHMgbHVzKSIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjExOAorIzogYnVpbHRpbi93b3JrdHJlZS5jOjExNwogIywgYy1mb3JtYXQKIG1zZ2lkICJSZW1vdmluZyB3b3JrdHJlZXMvJXM6IGludmFsaWQgZ2l0ZGlyIGZpbGUiCiBtc2dzdHIgIlN1cHByZXNzaW9uIGRlIHdvcmt0cmVlcy8lc8KgOiBmaWNoaWVyIGdpdGRpciBpbnZhbGlkZSIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjEyNworIzogYnVpbHRpbi93b3JrdHJlZS5jOjEyNgogIywgYy1mb3JtYXQKIG1zZ2lkICJSZW1vdmluZyB3b3JrdHJlZXMvJXM6IGdpdGRpciBmaWxlIHBvaW50cyB0byBub24tZXhpc3RlbnQgbG9jYXRpb24iCiBtc2dzdHIgIiIKICJTdXBwcmVzc2lvbiBkZSB3b3JrdHJlZXMvJXPCoDogbGUgZmljaGllciBnaXRkaXIgcG9pbnQgc3VyIHVuIGVuZHJvaXQgIgogImluZXhpc3RhbnQiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzoxNjYKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzoxNjUKIG1zZ2lkICJyZXBvcnQgcHJ1bmVkIHdvcmtpbmcgdHJlZXMiCiBtc2dzdHIgImFmZmljaGVyIGxlcyBhcmJyZXMgZGUgdHJhdmFpbCDDqWxpbWluw6lzIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6MTY4CisjOiBidWlsdGluL3dvcmt0cmVlLmM6MTY3CiBtc2dpZCAiZXhwaXJlIHdvcmtpbmcgdHJlZXMgb2xkZXIgdGhhbiA8dGltZT4iCiBtc2dzdHIgImZhaXJlIGV4cGlyZXIgbGVzIGFyYnJlcyBkZSB0cmF2YWlsIHBsdXMgdmlldXggcXVlIDx0ZW1wcz4iCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzoyMzUKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzoyMzQKICMsIGMtZm9ybWF0CiBtc2dpZCAiJyVzJyBhbHJlYWR5IGV4aXN0cyIKIG1zZ3N0ciAiJyVzJyBleGlzdGUgZMOpasOgIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6MjUyCisjOiBidWlsdGluL3dvcmt0cmVlLmM6MjUxCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byByZS1hZGQgd29ya3RyZWUgJyVzJyIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkZSByw6ktYWpvdXRlciBsJ2FyYnJlIGRlIHRyYXZhaWwgJyVzJyIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjI1NworIzogYnVpbHRpbi93b3JrdHJlZS5jOjI1NgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiJyVzJyBpcyBhIG1pc3NpbmcgYnV0IGxvY2tlZCB3b3JrdHJlZTtcbiIKQEAgLTIxMDQ0LDcgKzIxMTMyLDcgQEAKICJ1dGlsaXNleiAnYWRkIC1mIC1mJyBwb3VyIHBhc3NlciBvdXRyZSwgb3UgJ3VubG9jaycgZXQgJ3BydW5lJyBvdSAncmVtb3ZlJyAiCiAicG91ciBjb3JyaWdlciIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjI1OQorIzogYnVpbHRpbi93b3JrdHJlZS5jOjI1OAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiJyVzJyBpcyBhIG1pc3NpbmcgYnV0IGFscmVhZHkgcmVnaXN0ZXJlZCB3b3JrdHJlZTtcbiIKQEAgLTIxMDUzLDEyOSArMjExNDEsMTI5IEBACiAiJyVzJyBlc3QgdW4gYXJicmUgZGUgdHJhdmFpbCBtYW5xdWFudCBtYWlzIGTDqWrDoCBlbnJlZ2lzdHLDqcKgO1xuIgogInV0aWxpc2V6ICdhZGQgLWYnIHBvdXIgcGFzc2VyIG91dHJlLCBvdSAncHJ1bmUnIG91ICdyZW1vdmUnIHBvdXIgY29ycmlnZXIiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzozMDkKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzozMDgKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGNyZWF0ZSBkaXJlY3Rvcnkgb2YgJyVzJyIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkZSBjcsOpZXIgbGUgcsOpcGVydG9pcmUgZGUgJyVzJyIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjQ0MCBidWlsdGluL3dvcmt0cmVlLmM6NDQ2CisjOiBidWlsdGluL3dvcmt0cmVlLmM6NDM5IGJ1aWx0aW4vd29ya3RyZWUuYzo0NDUKICMsIGMtZm9ybWF0CiBtc2dpZCAiUHJlcGFyaW5nIHdvcmt0cmVlIChuZXcgYnJhbmNoICclcycpIgogbXNnc3RyICJQcsOpcGFyYXRpb24gZGUgbCdhcmJyZSBkZSB0cmF2YWlsIChub3V2ZWxsZSBicmFuY2hlICclcycpIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NDQyCisjOiBidWlsdGluL3dvcmt0cmVlLmM6NDQxCiAjLCBjLWZvcm1hdAogbXNnaWQgIlByZXBhcmluZyB3b3JrdHJlZSAocmVzZXR0aW5nIGJyYW5jaCAnJXMnOyB3YXMgYXQgJXMpIgogbXNnc3RyICIiCiAiUHLDqXBhcmF0aW9uIGRlIGwnYXJicmUgZGUgdHJhdmFpbCAocsOpaW5pdGlhbGlzYXRpb24gZGUgbGEgYnJhbmNoZSAnJXMnwqA7ICIKICJwcsOpY8OpZGVtbWVudCBzdXIgJXMpIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NDUxCisjOiBidWlsdGluL3dvcmt0cmVlLmM6NDUwCiAjLCBjLWZvcm1hdAogbXNnaWQgIlByZXBhcmluZyB3b3JrdHJlZSAoY2hlY2tpbmcgb3V0ICclcycpIgogbXNnc3RyICJQcsOpcGFyYXRpb24gZGUgbCdhcmJyZSBkZSB0cmF2YWlsIChleHRyYWN0aW9uIGRlICclcycpIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NDU3CisjOiBidWlsdGluL3dvcmt0cmVlLmM6NDU2CiAjLCBjLWZvcm1hdAogbXNnaWQgIlByZXBhcmluZyB3b3JrdHJlZSAoZGV0YWNoZWQgSEVBRCAlcykiCiBtc2dzdHIgIlByw6lwYXJhdGlvbiBkZSBsJ2FyYnJlIGRlIHRyYXZhaWwgKEhFQUQgZMOpdGFjaMOpZSAlcykiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo0OTgKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo0OTcKIG1zZ2lkICJjaGVja291dCA8YnJhbmNoPiBldmVuIGlmIGFscmVhZHkgY2hlY2tlZCBvdXQgaW4gb3RoZXIgd29ya3RyZWUiCiBtc2dzdHIgIiIKICJleHRyYWlyZSBsYSA8YnJhbmNoZT4gbcOqbWUgc2kgZWxsZSBlc3QgZMOpasOgIGV4dHJhaXRlIGRhbnMgdW5lIGF1dHJlIGNvcGllIGRlICIKICJ0cmF2YWlsIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NTAxCisjOiBidWlsdGluL3dvcmt0cmVlLmM6NTAwCiBtc2dpZCAiY3JlYXRlIGEgbmV3IGJyYW5jaCIKIG1zZ3N0ciAiY3LDqWVyIHVuZSBub3V2ZWxsZSBicmFuY2hlIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NTAzCisjOiBidWlsdGluL3dvcmt0cmVlLmM6NTAyCiBtc2dpZCAiY3JlYXRlIG9yIHJlc2V0IGEgYnJhbmNoIgogbXNnc3RyICJjcsOpZXIgb3UgcsOpaW5pdGlhbGlzZXIgdW5lIGJyYW5jaGUiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo1MDUKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo1MDQKIG1zZ2lkICJwb3B1bGF0ZSB0aGUgbmV3IHdvcmtpbmcgdHJlZSIKIG1zZ3N0ciAicmVtcGxpc3NhZ2UgZGUgbGEgbm91dmVsbGUgY29waWUgZGUgdHJhdmFpbCIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjUwNgorIzogYnVpbHRpbi93b3JrdHJlZS5jOjUwNQogbXNnaWQgImtlZXAgdGhlIG5ldyB3b3JraW5nIHRyZWUgbG9ja2VkIgogbXNnc3RyICJjb25zZXJ2ZXIgbGUgdmVycm91IHN1ciBsZSBub3V2ZWwgYXJicmUgZGUgdHJhdmFpbCIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjUwOQorIzogYnVpbHRpbi93b3JrdHJlZS5jOjUwOAogbXNnaWQgInNldCB1cCB0cmFja2luZyBtb2RlIChzZWUgZ2l0LWJyYW5jaCgxKSkiCiBtc2dzdHIgInLDqWdsZXIgbGUgbW9kZSBkZSBzdWl2aSAodm9pciBnaXQtYnJhbmNoKDEpKSIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjUxMgorIzogYnVpbHRpbi93b3JrdHJlZS5jOjUxMQogbXNnaWQgInRyeSB0byBtYXRjaCB0aGUgbmV3IGJyYW5jaCBuYW1lIHdpdGggYSByZW1vdGUtdHJhY2tpbmcgYnJhbmNoIgogbXNnc3RyICJlc3NheWVyIGRlIG5vbW1lciBsYSBub3V2ZWxsZSBicmFuY2hlIGNvbW1lIGxhIGJyYW5jaGUgYW1vbnQiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo1MjAKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo1MTkKIG1zZ2lkICItYiwgLUIsIGFuZCAtLWRldGFjaCBhcmUgbXV0dWFsbHkgZXhjbHVzaXZlIgogbXNnc3RyICItYiwgLUIgZXQgLS1kZXRhY2ggc29udCBtdXR1ZWxsZW1lbnQgZXhjbHVzaWZzIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NTgxCisjOiBidWlsdGluL3dvcmt0cmVlLmM6NTgwCiBtc2dpZCAiLS1bbm8tXXRyYWNrIGNhbiBvbmx5IGJlIHVzZWQgaWYgYSBuZXcgYnJhbmNoIGlzIGNyZWF0ZWQiCiBtc2dzdHIgIiIKICItLVtuby1ddHJhY2sgbmUgcGV1dCDDqnRyZSB1dGlsaXPDqSBxdSfDoCBsYSBjcsOpYXRpb24gZCd1bmUgbm91dmVsbGUgYnJhbmNoZSIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjY4MQorIzogYnVpbHRpbi93b3JrdHJlZS5jOjY4MAogbXNnaWQgInJlYXNvbiBmb3IgbG9ja2luZyIKIG1zZ3N0ciAicmFpc29uIGR1IHZlcnJvdWlsbGFnZSIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjY5MyBidWlsdGluL3dvcmt0cmVlLmM6NzI2IGJ1aWx0aW4vd29ya3RyZWUuYzo4MDAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo5MjcKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo2OTIgYnVpbHRpbi93b3JrdHJlZS5jOjcyNSBidWlsdGluL3dvcmt0cmVlLmM6Nzk5CisjOiBidWlsdGluL3dvcmt0cmVlLmM6OTI2CiAjLCBjLWZvcm1hdAogbXNnaWQgIiclcycgaXMgbm90IGEgd29ya2luZyB0cmVlIgogbXNnc3RyICInJXMnIG4nZXN0IHBhcyB1bmUgY29waWUgZGUgdHJhdmFpbCIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjY5NSBidWlsdGluL3dvcmt0cmVlLmM6NzI4CisjOiBidWlsdGluL3dvcmt0cmVlLmM6Njk0IGJ1aWx0aW4vd29ya3RyZWUuYzo3MjcKIG1zZ2lkICJUaGUgbWFpbiB3b3JraW5nIHRyZWUgY2Fubm90IGJlIGxvY2tlZCBvciB1bmxvY2tlZCIKIG1zZ3N0ciAiIgogIkxhIGNvcGllIGRlIHRyYXZhaWwgcHJpbmNpcGFsZSBuZSBwZXV0IHBhcyDDqnRyZSB2ZXJyb3VpbGzDqWUgb3UgZMOpdmVycm91aWxsw6llIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NzAwCisjOiBidWlsdGluL3dvcmt0cmVlLmM6Njk5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiclcycgaXMgYWxyZWFkeSBsb2NrZWQsIHJlYXNvbjogJXMiCiBtc2dzdHIgIiclcycgZXN0IGTDqWrDoCB2ZXJyb3VpbGzDqSwgY2FyICclcyciCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo3MDIKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo3MDEKICMsIGMtZm9ybWF0CiBtc2dpZCAiJyVzJyBpcyBhbHJlYWR5IGxvY2tlZCIKIG1zZ3N0ciAiJyVzJyBlc3QgZMOpasOgIHZlcnJvdWlsbMOpIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NzMwCisjOiBidWlsdGluL3dvcmt0cmVlLmM6NzI5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiclcycgaXMgbm90IGxvY2tlZCIKIG1zZ3N0ciAiJyVzJyBuJ2VzdCBwYXMgdmVycm91aWxsw6kiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo3NzEKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo3NzAKIG1zZ2lkICJ3b3JraW5nIHRyZWVzIGNvbnRhaW5pbmcgc3VibW9kdWxlcyBjYW5ub3QgYmUgbW92ZWQgb3IgcmVtb3ZlZCIKIG1zZ3N0ciAiIgogImxlcyBhcmJyZXMgZGUgdHJhdmFpbCBjb250ZW5hbnQgZGVzIHNvdXMtbW9kdWxlcyBuZSBwZXV2ZW50IHBhcyDDqnRyZSAiCiAiZMOpcGxhY8OpcyBvdSBzdXBwcmltw6lzIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6Nzc5CisjOiBidWlsdGluL3dvcmt0cmVlLmM6Nzc4CiBtc2dpZCAiZm9yY2UgbW92ZSBldmVuIGlmIHdvcmt0cmVlIGlzIGRpcnR5IG9yIGxvY2tlZCIKIG1zZ3N0ciAiIgogImZvcmNlciBsZSBkw6lwbGFjZW1lbnQgbcOqbWUgc2kgbCdhcmJyZSBkZSB0cmF2YWlsIGVzdCBzYWxlIG91IHZlcnJvdWlsbMOpIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6ODAyIGJ1aWx0aW4vd29ya3RyZWUuYzo5MjkKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4MDEgYnVpbHRpbi93b3JrdHJlZS5jOjkyOAogIywgYy1mb3JtYXQKIG1zZ2lkICInJXMnIGlzIGEgbWFpbiB3b3JraW5nIHRyZWUiCiBtc2dzdHIgIiclcycgZXN0IHVuIGFyYnJlIGRlIHRyYXZhaWwgcHJpbmNpcGFsIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6ODA3CisjOiBidWlsdGluL3dvcmt0cmVlLmM6ODA2CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBmaWd1cmUgb3V0IGRlc3RpbmF0aW9uIG5hbWUgZnJvbSAnJXMnIgogbXNnc3RyICJpbXBvc3NpYmxlIGRlIHRyb3V2ZXIgbGUgbm9tIGRlIGxhIGRlc3RpbmF0aW9uIMOgIHBhcnRpciBkZSAnJXMnIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6ODEzCisjOiBidWlsdGluL3dvcmt0cmVlLmM6ODEyCiAjLCBjLWZvcm1hdAogbXNnaWQgInRhcmdldCAnJXMnIGFscmVhZHkgZXhpc3RzIgogbXNnc3RyICJsYSBjaWJsZSAnJXMnIGV4aXN0ZSBkw6lqw6AiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4MjEKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4MjAKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogImNhbm5vdCBtb3ZlIGEgbG9ja2VkIHdvcmtpbmcgdHJlZSwgbG9jayByZWFzb246ICVzXG4iCkBAIC0yMTE4NSw3ICsyMTI3Myw3IEBACiAidmVycm91aWxsYWdlwqA6ICVzXG4iCiAidXRpbGlzZXogJ21vdmUgLWYgLWYnIHBvdXIgb3V0cmVwYXNzZXIgb3UgZMOpdmVycm91aWxsZXIgYXZhbnQiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4MjMKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4MjIKIG1zZ2lkICIiCiAiY2Fubm90IG1vdmUgYSBsb2NrZWQgd29ya2luZyB0cmVlO1xuIgogInVzZSAnbW92ZSAtZiAtZicgdG8gb3ZlcnJpZGUgb3IgdW5sb2NrIGZpcnN0IgpAQCAtMjExOTMsMzcgKzIxMjgxLDM5IEBACiAiaW1wb3NzaWJsZSBkZSBkw6lwbGFjZXIgdW4gYXJicmUgZGUgdHJhdmFpbCB2ZXJyb3VpbGzDqTtcbiIKICJ1dGlsaXNleiAnbW92ZSAtZiAtZicgcG91ciBvdXRyZXBhc3NlciBvdSBkw6l2ZXJyb3VpbGxlciBhdmFudCIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjgyNgorIzogYnVpbHRpbi93b3JrdHJlZS5jOjgyNQogIywgYy1mb3JtYXQKIG1zZ2lkICJ2YWxpZGF0aW9uIGZhaWxlZCwgY2Fubm90IG1vdmUgd29ya2luZyB0cmVlOiAlcyIKIG1zZ3N0ciAibGEgdmFsaWRhdGlvbiBhIMOpY2hvdcOpLCBpbXBvc3NpYmxlIGRlIGTDqXBsYWNlciBsJ2FyYnJlIGRlIHRyYXZhaWzCoDogJXMiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4MzEKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4MzAKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIG1vdmUgJyVzJyB0byAnJXMnIgogbXNnc3RyICLDqWNoZWMgYXUgZMOpcGxhY2VtZW50IGRlICclcycgdmVycyAnJXMnIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6ODc5CisjOiBidWlsdGluL3dvcmt0cmVlLmM6ODc4CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBydW4gJ2dpdCBzdGF0dXMnIG9uICclcyciCiBtc2dzdHIgIsOpY2hlYyBkdSBsYW5jZW1lbnQgZGUgJ2dpdCBzdGF0dXMnIHN1ciAnJXMnIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6ODgzCisjOiBidWlsdGluL3dvcmt0cmVlLmM6ODgyCiAjLCBjLWZvcm1hdAotbXNnaWQgIiclcycgaXMgZGlydHksIHVzZSAtLWZvcmNlIHRvIGRlbGV0ZSBpdCIKLW1zZ3N0ciAiJyVzJyBlc3Qgc2FsZSwgdXRpbGlzZXogLS1mb3JjZSBwb3VyIGxlIHN1cHByaW1lciIKK21zZ2lkICInJXMnIGNvbnRhaW5zIG1vZGlmaWVkIG9yIHVudHJhY2tlZCBmaWxlcywgdXNlIC0tZm9yY2UgdG8gZGVsZXRlIGl0IgorbXNnc3RyICIiCisiJyVzJyBjb250aWVudCBkZXMgZmljaGllcnMgbW9kaWZpw6lzIG91IG5vbi1zdWl2aXMsIHV0aWxpc2V6IC0tZm9yY2UgcG91ciBsZSAiCisic3VwcHJpbWVyIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6ODg4CisjOiBidWlsdGluL3dvcmt0cmVlLmM6ODg3CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBydW4gJ2dpdCBzdGF0dXMnIG9uICclcycsIGNvZGUgJWQiCiBtc2dzdHIgImltcG9zc2libGUgZGUgbGFuY2VyICdnaXQgc3RhdHVzJyBzdXIgJyVzJywgY29kZSAlZCIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjkxMQorIzogYnVpbHRpbi93b3JrdHJlZS5jOjkxMAogbXNnaWQgImZvcmNlIHJlbW92YWwgZXZlbiBpZiB3b3JrdHJlZSBpcyBkaXJ0eSBvciBsb2NrZWQiCiBtc2dzdHIgIiIKICJmb3JjZXIgbGEgc3VwcHJlc3Npb24gbcOqbWUgc2kgbCdhcmJyZSBkZSB0cmF2YWlsIGVzdCBzYWxlIG91IHZlcnJvdWlsbMOpIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6OTM0CisjOiBidWlsdGluL3dvcmt0cmVlLmM6OTMzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJjYW5ub3QgcmVtb3ZlIGEgbG9ja2VkIHdvcmtpbmcgdHJlZSwgbG9jayByZWFzb246ICVzXG4iCkBAIC0yMTIzMyw3ICsyMTMyMyw3IEBACiAidmVycm91aWxsYWdlwqA6ICVzXG4iCiAidXRpbGlzZXogJ21vdmUgLWYgLWYnIHBvdXIgb3V0cmVwYXNzZXIgb3UgZMOpdmVycm91aWxsZXIgYXZhbnQiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo5MzYKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo5MzUKIG1zZ2lkICIiCiAiY2Fubm90IHJlbW92ZSBhIGxvY2tlZCB3b3JraW5nIHRyZWU7XG4iCiAidXNlICdyZW1vdmUgLWYgLWYnIHRvIG92ZXJyaWRlIG9yIHVubG9jayBmaXJzdCIKQEAgLTIxMjQxLDcgKzIxMzMxLDcgQEAKICJpbXBvc3NpYmxlIGRlIHN1cHByaW1lciB1biBhcmJyZSBkZSB0cmF2YWlsIHZlcnJvdWlsbMOpO1xuIgogInV0aWxpc2V6ICdtb3ZlIC1mIC1mJyBwb3VyIG91dHJlcGFzc2VyIG91IGTDqXZlcnJvdWlsbGVyIGF2YW50IgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6OTM5CisjOiBidWlsdGluL3dvcmt0cmVlLmM6OTM4CiAjLCBjLWZvcm1hdAogbXNnaWQgInZhbGlkYXRpb24gZmFpbGVkLCBjYW5ub3QgcmVtb3ZlIHdvcmtpbmcgdHJlZTogJXMiCiBtc2dzdHIgIiIKQEAgLTIxMjYzLDYgKzIxMzUzLDE2IEBACiBtc2dpZCAib25seSB1c2VmdWwgZm9yIGRlYnVnZ2luZyIKIG1zZ3N0ciAic2V1bGVtZW50IHV0aWxlIHBvdXIgbGUgZMOpYm9nYWdlIgogCisjOiBmYXN0LWltcG9ydC5jOjMxMTgKKyMsIGMtZm9ybWF0Cittc2dpZCAiRXhwZWN0ZWQgJ21hcmsnIGNvbW1hbmQsIGdvdCAlcyIKK21zZ3N0ciAiY29tbWFuZGUgJ21hcmsnIGF0dGVuZHVlLCAlcyB0cm91dsOpIgorCisjOiBmYXN0LWltcG9ydC5jOjMxMjMKKyMsIGMtZm9ybWF0Cittc2dpZCAiRXhwZWN0ZWQgJ3RvJyBjb21tYW5kLCBnb3QgJXMiCittc2dzdHIgImNvbW1hbmRlICd0bycgYXR0ZW5kdWUsICVzIHRyb3V2w6kiCisKICM6IGNyZWRlbnRpYWwtY2FjaGUtLWRhZW1vbi5jOjIyMwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCkBAIC0yMTM3NSwzOSArMjE0NzUsMzkgQEAKICJsJ2FsaWFzICclcycgbW9kaWZpZSBsZXMgdmFyaWFibGVzIGQnZW52aXJvbm5lbWVudC5cbiIKICJWb3VzIHBvdXZleiB1dGlsaXNlciAnIWdpdCcgZGFucyBsJ2FsaWFzIHBvdXIgbGUgZmFpcmUiCiAKLSM6IGdpdC5jOjM3NworIzogZ2l0LmM6Mzc2CiAjLCBjLWZvcm1hdAogbXNnaWQgImVtcHR5IGFsaWFzIGZvciAlcyIKIG1zZ3N0ciAiYWxpYXMgdmlkZSBwb3VyICVzIgogCi0jOiBnaXQuYzozODAKKyM6IGdpdC5jOjM3OQogIywgYy1mb3JtYXQKIG1zZ2lkICJyZWN1cnNpdmUgYWxpYXM6ICVzIgogbXNnc3RyICJhbGlhcyByZWN1cnNpZsKgOiAlcyIKIAotIzogZ2l0LmM6NDYwCisjOiBnaXQuYzo0NTkKIG1zZ2lkICJ3cml0ZSBmYWlsdXJlIG9uIHN0YW5kYXJkIG91dHB1dCIKIG1zZ3N0ciAiw6ljaGVjIGQnw6ljcml0dXJlIHN1ciBsYSBzb3J0aWUgc3RhbmRhcmQiCiAKLSM6IGdpdC5jOjQ2MgorIzogZ2l0LmM6NDYxCiBtc2dpZCAidW5rbm93biB3cml0ZSBmYWlsdXJlIG9uIHN0YW5kYXJkIG91dHB1dCIKIG1zZ3N0ciAiw6ljaGVjIGluY29ubnUgZCfDqWNyaXR1cmUgc3VyIGxhIHNvcnRpZSBzdGFuZGFyZCIKIAotIzogZ2l0LmM6NDY0CisjOiBnaXQuYzo0NjMKIG1zZ2lkICJjbG9zZSBmYWlsZWQgb24gc3RhbmRhcmQgb3V0cHV0IgogbXNnc3RyICLDqWNoZWMgZGUgZmVybWV0dXJlIGRlIGxhIHNvcnRpZSBzdGFuZGFyZCIKIAotIzogZ2l0LmM6NzkzCisjOiBnaXQuYzo3OTIKICMsIGMtZm9ybWF0CiBtc2dpZCAiYWxpYXMgbG9vcCBkZXRlY3RlZDogZXhwYW5zaW9uIG9mICclcycgZG9lcyBub3QgdGVybWluYXRlOiVzIgogbXNnc3RyICJib3VjbGUgZCdhbGlhcyBkw6l0ZWN0w6llwqA6IGwnZXhwYW5zaW9uIGRlICclcycgbmUgZmluaXQgamFtYWlzwqA6ICVzIgogCi0jOiBnaXQuYzo4NDMKKyM6IGdpdC5jOjg0MgogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgaGFuZGxlICVzIGFzIGEgYnVpbHRpbiIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkJ3V0aWxpc2VyICVzIGNvbW1lIHVuZSBmb25jdGlvbiBpbnTDqWdyw6llIgogCi0jOiBnaXQuYzo4NTYKKyM6IGdpdC5jOjg1NQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAidXNhZ2U6ICVzXG4iCkBAIC0yMTQxNiwxMyArMjE1MTYsMTMgQEAKICJ1c2FnZSA6ICVzXG4iCiAiXG4iCiAKLSM6IGdpdC5jOjg3NgorIzogZ2l0LmM6ODc1CiAjLCBjLWZvcm1hdAogbXNnaWQgImV4cGFuc2lvbiBvZiBhbGlhcyAnJXMnIGZhaWxlZDsgJyVzJyBpcyBub3QgYSBnaXQgY29tbWFuZFxuIgogbXNnc3RyICIiCiAibCdleHBhbnNpb24gZGUgbCdhbGlhcyAnJXMnIGEgw6ljaG91w6nCoDogJyVzJyBuJ2VzdCBwYXMgdW5lIGNvbW1hbmRlIGdpdFxuIgogCi0jOiBnaXQuYzo4ODgKKyM6IGdpdC5jOjg4NwogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gcnVuIGNvbW1hbmQgJyVzJzogJXNcbiIKIG1zZ3N0ciAiw6ljaGVjIGF1IGxhbmNlbWVudCBkZSBsYSBjb21tYW5kZSAnJXMnwqA6ICVzXG4iCkBAIC0yMTQ0MSwzMiArMjE1NDEsMzIgQEAKIG1zZ2lkICJQdWJsaWMga2V5IHBpbm5pbmcgbm90IHN1cHBvcnRlZCB3aXRoIGNVUkwgPCA3LjQ0LjAiCiBtc2dzdHIgIkwnw6lwaW5nbGFnZSBkZSBjbMOpIHB1YmxpcXVlIG4nZXN0IHBhcyBzdXBwb3J0w6kgYXZlYyBjdVJMIDwgNy40NC4wIgogCi0jOiBodHRwLmM6ODc2CisjOiBodHRwLmM6ODc4CiBtc2dpZCAiQ1VSTFNTTE9QVF9OT19SRVZPS0Ugbm90IHN1cHBvcnRlZCB3aXRoIGNVUkwgPCA3LjQ0LjAiCiBtc2dzdHIgIkNVUkxTU0xPUFRfTk9fUkVNT1ZFIG4nZXN0IHBhcyBzdXBwb3J0w6kgYXZlYyBjdVJMIDwgNy40NC4wIgogCi0jOiBodHRwLmM6OTQ5CisjOiBodHRwLmM6OTUxCiBtc2dpZCAiUHJvdG9jb2wgcmVzdHJpY3Rpb25zIG5vdCBzdXBwb3J0ZWQgd2l0aCBjVVJMIDwgNy4xOS40IgogbXNnc3RyICJMZXMgcmVzdHJpY3Rpb25zIGRlIHByb3RvY29sZSBuZSBzb250IHBhcyBzdXBwb3J0w6lzIGF2ZWMgY3VSTCA8IDcuMTkuNCIKIAotIzogaHR0cC5jOjEwODUKKyM6IGh0dHAuYzoxMDg4CiAjLCBjLWZvcm1hdAogbXNnaWQgIlVuc3VwcG9ydGVkIFNTTCBiYWNrZW5kICclcycuIFN1cHBvcnRlZCBTU0wgYmFja2VuZHM6IgogbXNnc3RyICJEb3JzYWxlIFNTTCAnJXMnIG5vbiBzdXBwb3J0w6llLiBEb3JzYWxlcyBTU0wgc3VwcG9ydMOpZXPCoDoiCiAKLSM6IGh0dHAuYzoxMDkyCisjOiBodHRwLmM6MTA5NQogIywgYy1mb3JtYXQKIG1zZ2lkICJDb3VsZCBub3Qgc2V0IFNTTCBiYWNrZW5kIHRvICclcyc6IGNVUkwgd2FzIGJ1aWx0IHdpdGhvdXQgU1NMIGJhY2tlbmRzIgogbXNnc3RyICIiCiAiSW1wb3NzaWJsZSBkZSByw6lnbGVyIGxhIGRvcnNhbGUgU1NMIMOgICclcyfCoDogY1VSTCBhIMOpdMOpIGNvbnN0cnVpdCBzYW5zICIKICJkb3JzYWxlIFNTTCIKIAotIzogaHR0cC5jOjEwOTYKKyM6IGh0dHAuYzoxMDk5CiAjLCBjLWZvcm1hdAogbXNnaWQgIkNvdWxkIG5vdCBzZXQgU1NMIGJhY2tlbmQgdG8gJyVzJzogYWxyZWFkeSBzZXQiCiBtc2dzdHIgIkltcG9zc2libGUgZGUgc3DDqWNpZmllciBsZSBkb3JzYWwgU1NMIMOgICclcyfCoDogZMOpasOgIHNww6ljaWZpw6kiCiAKLSM6IGh0dHAuYzoxOTY1CisjOiBodHRwLmM6MTk2OAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAidW5hYmxlIHRvIHVwZGF0ZSB1cmwgYmFzZSBmcm9tIHJlZGlyZWN0aW9uOlxuIgpAQCAtMjE0NzcsMTMwICsyMTU3NywxMzAgQEAKICIgICAgICBkZW1hbmTDqcKgOiAlc1xuIgogIiAgcmVkaXJlY3Rpb27CoDogJXMiCiAKLSM6IHJlbW90ZS1jdXJsLmM6MTU3CisjOiByZW1vdGUtY3VybC5jOjE2NgogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIHF1b3RpbmcgaW4gcHVzaC1vcHRpb24gdmFsdWU6ICclcyciCiBtc2dzdHIgImNpdGF0aW9uIGludmFsaWRlIGRhbnMgbGEgdmFsZXVyIHB1c2gtb3B0aW9uwqA6ICclcyciCiAKLSM6IHJlbW90ZS1jdXJsLmM6MjU0CisjOiByZW1vdGUtY3VybC5jOjI2MwogIywgYy1mb3JtYXQKIG1zZ2lkICIlc2luZm8vcmVmcyBub3QgdmFsaWQ6IGlzIHRoaXMgYSBnaXQgcmVwb3NpdG9yeT8iCiBtc2dzdHIgIiVzaW5mby9yZWZzIG4nZXN0IHBhcyB2YWxpZGUgOiBlc3QtY2UgYmllbiB1biBkw6lww7R0IGdpdMKgPyIKIAotIzogcmVtb3RlLWN1cmwuYzozNTUKKyM6IHJlbW90ZS1jdXJsLmM6MzY0CiBtc2dpZCAiaW52YWxpZCBzZXJ2ZXIgcmVzcG9uc2U7IGV4cGVjdGVkIHNlcnZpY2UsIGdvdCBmbHVzaCBwYWNrZXQiCiBtc2dzdHIgInLDqXBvbnNlIGR1IHNlcnZldXIgaW52YWxpZGXCoDsgc2VydmljZSBhdHRlbmR1LCBwYXF1ZXQgZGUgdmlkYWdlIHJlw6d1IgogCi0jOiByZW1vdGUtY3VybC5jOjM4NgorIzogcmVtb3RlLWN1cmwuYzozOTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBzZXJ2ZXIgcmVzcG9uc2U7IGdvdCAnJXMnIgogbXNnc3RyICJyw6lwb25zZSBkdSBzZXJ2ZXVyIGludmFsaWRlwqA7ICclcycgcmXDp3UiCiAKLSM6IHJlbW90ZS1jdXJsLmM6NDQ2CisjOiByZW1vdGUtY3VybC5jOjQ1NQogIywgYy1mb3JtYXQKIG1zZ2lkICJyZXBvc2l0b3J5ICclcycgbm90IGZvdW5kIgogbXNnc3RyICJkw6lww7R0ICclcycgbm9uIHRyb3V2w6kiCiAKLSM6IHJlbW90ZS1jdXJsLmM6NDUwCisjOiByZW1vdGUtY3VybC5jOjQ1OQogIywgYy1mb3JtYXQKIG1zZ2lkICJBdXRoZW50aWNhdGlvbiBmYWlsZWQgZm9yICclcyciCiBtc2dzdHIgIsOJY2hlYyBkJ2F1dGhlbnRpZmljYXRpb24gcG91ciAnJXMnIgogCi0jOiByZW1vdGUtY3VybC5jOjQ1NAorIzogcmVtb3RlLWN1cmwuYzo0NjMKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGFjY2VzcyAnJXMnOiAlcyIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkJ2FjY8OpZGVyIMOgICclcyfCoDogJXMiCiAKLSM6IHJlbW90ZS1jdXJsLmM6NDYwCisjOiByZW1vdGUtY3VybC5jOjQ2OQogIywgYy1mb3JtYXQKIG1zZ2lkICJyZWRpcmVjdGluZyB0byAlcyIKIG1zZ3N0ciAicmVkaXJlY3Rpb24gdmVycyAlcyIKIAotIzogcmVtb3RlLWN1cmwuYzo1ODQKKyM6IHJlbW90ZS1jdXJsLmM6NTkzCiBtc2dpZCAic2hvdWxkbid0IGhhdmUgRU9GIHdoZW4gbm90IGdlbnRsZSBvbiBFT0YiCiBtc2dzdHIgIm5lIGRldnJhaXQgcGFzIHJlY2V2b2lyIE9FRiBxdWFuZCBvbiBuJ2VzdCBwYXMgZ2VudGlsIHN1ciBFT0YiCiAKLSM6IHJlbW90ZS1jdXJsLmM6NjY0CisjOiByZW1vdGUtY3VybC5jOjY3MwogbXNnaWQgInVuYWJsZSB0byByZXdpbmQgcnBjIHBvc3QgZGF0YSAtIHRyeSBpbmNyZWFzaW5nIGh0dHAucG9zdEJ1ZmZlciIKIG1zZ3N0ciAiIgogImltcG9zc2libGUgZGUgcmVtYm9iaW5lciBsZSBkb25uw6llcyBwb3N0IHJwYyAtIGVzc2F5ZXIgZCdhdWdtZW50ZXIgaHR0cC4iCiAicG9zdEJ1ZmZlciIKIAotIzogcmVtb3RlLWN1cmwuYzo3MjQKKyM6IHJlbW90ZS1jdXJsLmM6NzMzCiAjLCBjLWZvcm1hdAogbXNnaWQgIlJQQyBmYWlsZWQ7ICVzIgogbXNnc3RyICLDqWNoZWMgUlBDwqA7ICVzIgogCi0jOiByZW1vdGUtY3VybC5jOjc2NAorIzogcmVtb3RlLWN1cmwuYzo3NzMKIG1zZ2lkICJjYW5ub3QgaGFuZGxlIHB1c2hlcyB0aGlzIGJpZyIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkZSBnw6lyZXIgZGVzIHBvdXNzw6llcyBhdXNzaSBncm9zc2VzIgogCi0jOiByZW1vdGUtY3VybC5jOjg3OQorIzogcmVtb3RlLWN1cmwuYzo4ODgKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IGRlZmxhdGUgcmVxdWVzdDsgemxpYiBkZWZsYXRlIGVycm9yICVkIgogbXNnc3RyICJpbXBvc3NpYmxlIGRlIGNvbXByZXNzZXIgbGEgcmVxdcOqdGXCoDsgZXJyZXVyIGRlIGNvbXByZXNzaW9uIHpsaWIgJWQiCiAKLSM6IHJlbW90ZS1jdXJsLmM6ODgzCisjOiByZW1vdGUtY3VybC5jOjg5MgogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgZGVmbGF0ZSByZXF1ZXN0OyB6bGliIGVuZCBlcnJvciAlZCIKIG1zZ3N0ciAiaW1wb3NzaWJsZSBkZSBjb21wcmVzc2VyIGxhIHJlcXXDqnRlwqA7IGVycmV1ciBkZSBmaW4gemxpYiAlZCIKIAotIzogcmVtb3RlLWN1cmwuYzoxMDE0CisjOiByZW1vdGUtY3VybC5jOjEwMjMKIG1zZ2lkICJkdW1iIGh0dHAgdHJhbnNwb3J0IGRvZXMgbm90IHN1cHBvcnQgc2hhbGxvdyBjYXBhYmlsaXRpZXMiCiBtc2dzdHIgImxlIHByb3RvY29sZSBodHRwIGlkaW90IG5lIHN1cHBvcnRlIGxhIGNhcGFjaXTDqSBzdXBlcmZpY2llbGxlIgogCi0jOiByZW1vdGUtY3VybC5jOjEwMjgKKyM6IHJlbW90ZS1jdXJsLmM6MTAzNwogbXNnaWQgImZldGNoIGZhaWxlZC4iCiBtc2dzdHIgIsOpY2hlYyBkdSByw6ljdXDDqXJhdGlvbi4iCiAKLSM6IHJlbW90ZS1jdXJsLmM6MTA3NgorIzogcmVtb3RlLWN1cmwuYzoxMDg1CiBtc2dpZCAiY2Fubm90IGZldGNoIGJ5IHNoYTEgb3ZlciBzbWFydCBodHRwIgogbXNnc3RyICJpbXBvc3NpYmxlIGRlIHLDqWN1cMOpcmVyIHBhciBzaGExIHN1ciBodHRwIGludGVsbGlnZW50IgogCi0jOiByZW1vdGUtY3VybC5jOjExMjAgcmVtb3RlLWN1cmwuYzoxMTI2CisjOiByZW1vdGUtY3VybC5jOjExMjkgcmVtb3RlLWN1cmwuYzoxMTM1CiAjLCBjLWZvcm1hdAogbXNnaWQgInByb3RvY29sIGVycm9yOiBleHBlY3RlZCBzaGEvcmVmLCBnb3QgJyVzJyIKIG1zZ3N0ciAiZXJyZXVyIGRlIHByb3RvY29sZcKgOiBzaGEvcmVmIGF0dGVuZHUsICclcycgdHJvdXbDqSIKIAotIzogcmVtb3RlLWN1cmwuYzoxMTM4IHJlbW90ZS1jdXJsLmM6MTI1MgorIzogcmVtb3RlLWN1cmwuYzoxMTQ3IHJlbW90ZS1jdXJsLmM6MTI2MQogIywgYy1mb3JtYXQKIG1zZ2lkICJodHRwIHRyYW5zcG9ydCBkb2VzIG5vdCBzdXBwb3J0ICVzIgogbXNnc3RyICJsZSB0cmFuc3BvcnQgaHR0cCBuZSBzdXBwb3J0ZSBwYXMgJXMiCiAKLSM6IHJlbW90ZS1jdXJsLmM6MTE3NAorIzogcmVtb3RlLWN1cmwuYzoxMTgzCiBtc2dpZCAiZ2l0LWh0dHAtcHVzaCBmYWlsZWQiCiBtc2dzdHIgIsOpY2hlYyBkZSBnaXQtaHR0cC1wdXNoIgogCi0jOiByZW1vdGUtY3VybC5jOjEzNjAKKyM6IHJlbW90ZS1jdXJsLmM6MTM2NwogbXNnaWQgInJlbW90ZS1jdXJsOiB1c2FnZTogZ2l0IHJlbW90ZS1jdXJsIDxyZW1vdGU+IFs8dXJsPl0iCiBtc2dzdHIgInJlbW90ZS1jdXJsOiB1c2FnZTogZ2l0IHJlbW90ZS1jdXJsIDxkaXN0YW50PiBbPHVybD5dIgogCi0jOiByZW1vdGUtY3VybC5jOjEzOTIKKyM6IHJlbW90ZS1jdXJsLmM6MTM5OQogbXNnaWQgInJlbW90ZS1jdXJsOiBlcnJvciByZWFkaW5nIGNvbW1hbmQgc3RyZWFtIGZyb20gZ2l0IgogbXNnc3RyICJyZW1vdGUtY3VybMKgOiBlcnJldXIgZGUgbGVjdHVyZSBkdSBmbHV4IGRlIGNvbW1hbmRlIGRlcHVpcyBnaXQiCiAKLSM6IHJlbW90ZS1jdXJsLmM6MTM5OQorIzogcmVtb3RlLWN1cmwuYzoxNDA2CiBtc2dpZCAicmVtb3RlLWN1cmw6IGZldGNoIGF0dGVtcHRlZCB3aXRob3V0IGEgbG9jYWwgcmVwbyIKIG1zZ3N0ciAicmVtb3RlLWN1cmzCoDogcsOpY3Vww6lyYXRpb24gdGVudMOpZSBzYW5zIGTDqXDDtHQgbG9jYWwiCiAKLSM6IHJlbW90ZS1jdXJsLmM6MTQzOQorIzogcmVtb3RlLWN1cmwuYzoxNDQ2CiAjLCBjLWZvcm1hdAogbXNnaWQgInJlbW90ZS1jdXJsOiB1bmtub3duIGNvbW1hbmQgJyVzJyBmcm9tIGdpdCIKIG1zZ3N0ciAicmVtb3RlLWN1cmzCoDogY29tbWFuZGUgaW5jb25udWUgJyVzJyBkZXB1aXMgZ2l0IgogCi0jOiBsaXN0LW9iamVjdHMtZmlsdGVyLW9wdGlvbnMuaDo2MQorIzogbGlzdC1vYmplY3RzLWZpbHRlci1vcHRpb25zLmg6ODUKIG1zZ2lkICJhcmdzIgogbXNnc3RyICJhcmdzIgogCi0jOiBsaXN0LW9iamVjdHMtZmlsdGVyLW9wdGlvbnMuaDo2MgorIzogbGlzdC1vYmplY3RzLWZpbHRlci1vcHRpb25zLmg6ODYKIG1zZ2lkICJvYmplY3QgZmlsdGVyaW5nIgogbXNnc3RyICJmaWx0cmFnZSBkJ29iamV0IgogCi0jOiBwYXJzZS1vcHRpb25zLmg6MTcwCisjOiBwYXJzZS1vcHRpb25zLmg6MTc5CiBtc2dpZCAiZXhwaXJ5LWRhdGUiCiBtc2dzdHIgImRhdGUtZCdleHBpcmF0aW9uIgogCi0jOiBwYXJzZS1vcHRpb25zLmg6MTg0CisjOiBwYXJzZS1vcHRpb25zLmg6MTkzCiBtc2dpZCAibm8tb3AgKGJhY2t3YXJkIGNvbXBhdGliaWxpdHkpIgogbXNnc3RyICJzYW5zIGFjdGlvbiAocsOpdHJvY29tcGF0aWJpbGl0w6kpIgogCmRpZmYgLS1naXQgYS9wby9naXQucG90IGIvcG8vZ2l0LnBvdAppbmRleCBkNzk5Njk2Li5mZjAwYmMyIDEwMDY0NAotLS0gYS9wby9naXQucG90CisrKyBiL3BvL2dpdC5wb3QKQEAgLTgsNyArOCw3IEBACiBtc2dzdHIgIiIKICJQcm9qZWN0LUlkLVZlcnNpb246IFBBQ0tBR0UgVkVSU0lPTlxuIgogIlJlcG9ydC1Nc2dpZC1CdWdzLVRvOiBHaXQgTWFpbGluZyBMaXN0IDxnaXRAdmdlci5rZXJuZWwub3JnPlxuIgotIlBPVC1DcmVhdGlvbi1EYXRlOiAyMDE5LTA4LTEwIDIwOjEyKzA4MDBcbiIKKyJQT1QtQ3JlYXRpb24tRGF0ZTogMjAxOS0xMC0yOCAxMzoxOSswODAwXG4iCiAiUE8tUmV2aXNpb24tRGF0ZTogWUVBUi1NTy1EQSBITzpNSStaT05FXG4iCiAiTGFzdC1UcmFuc2xhdG9yOiBGVUxMIE5BTUUgPEVNQUlMQEFERFJFU1M+XG4iCiAiTGFuZ3VhZ2UtVGVhbTogTEFOR1VBR0UgPExMQGxpLm9yZz5cbiIKQEAgLTU4LDcgKzU4LDcgQEAKIG1zZ2lkICJFeGl0aW5nIGJlY2F1c2Ugb2YgYW4gdW5yZXNvbHZlZCBjb25mbGljdC4iCiBtc2dzdHIgIiIKIAotIzogYWR2aWNlLmM6MTkzIGJ1aWx0aW4vbWVyZ2UuYzoxMzI3CisjOiBhZHZpY2UuYzoxOTMgYnVpbHRpbi9tZXJnZS5jOjEzMzIKIG1zZ2lkICJZb3UgaGF2ZSBub3QgY29uY2x1ZGVkIHlvdXIgbWVyZ2UgKE1FUkdFX0hFQUQgZXhpc3RzKS4iCiBtc2dzdHIgIiIKIApAQCAtMTc2LDE3ICsxNzYsNyBAQAogbXNnaWQgImluY29uc2lzdGVudCBoZWFkZXIgbGluZXMgJWQgYW5kICVkIgogbXNnc3RyICIiCiAKLSM6IGFwcGx5LmM6MTQ2MAotIywgYy1mb3JtYXQKLW1zZ2lkICJyZWNvdW50OiB1bmV4cGVjdGVkIGxpbmU6ICUuKnMiCi1tc2dzdHIgIiIKLQotIzogYXBwbHkuYzoxNTI5Ci0jLCBjLWZvcm1hdAotbXNnaWQgInBhdGNoIGZyYWdtZW50IHdpdGhvdXQgaGVhZGVyIGF0IGxpbmUgJWQ6ICUuKnMiCi1tc2dzdHIgIiIKLQotIzogYXBwbHkuYzoxNTUxCisjOiBhcHBseS5jOjEzNzIKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogImdpdCBkaWZmIGhlYWRlciBsYWNrcyBmaWxlbmFtZSBpbmZvcm1hdGlvbiB3aGVuIHJlbW92aW5nICVkIGxlYWRpbmcgcGF0aG5hbWUgIgpAQCAtMTk3LDUyNyArMTg3LDUzNyBAQAogbXNnc3RyWzBdICIiCiBtc2dzdHJbMV0gIiIKIAotIzogYXBwbHkuYzoxNTY0CisjOiBhcHBseS5jOjEzODUKICMsIGMtZm9ybWF0CiBtc2dpZCAiZ2l0IGRpZmYgaGVhZGVyIGxhY2tzIGZpbGVuYW1lIGluZm9ybWF0aW9uIChsaW5lICVkKSIKIG1zZ3N0ciAiIgogCi0jOiBhcHBseS5jOjE3NTIKKyM6IGFwcGx5LmM6MTQ4MQorIywgYy1mb3JtYXQKK21zZ2lkICJyZWNvdW50OiB1bmV4cGVjdGVkIGxpbmU6ICUuKnMiCittc2dzdHIgIiIKKworIzogYXBwbHkuYzoxNTUwCisjLCBjLWZvcm1hdAorbXNnaWQgInBhdGNoIGZyYWdtZW50IHdpdGhvdXQgaGVhZGVyIGF0IGxpbmUgJWQ6ICUuKnMiCittc2dzdHIgIiIKKworIzogYXBwbHkuYzoxNzUzCiBtc2dpZCAibmV3IGZpbGUgZGVwZW5kcyBvbiBvbGQgY29udGVudHMiCiBtc2dzdHIgIiIKIAotIzogYXBwbHkuYzoxNzU0CisjOiBhcHBseS5jOjE3NTUKIG1zZ2lkICJkZWxldGVkIGZpbGUgc3RpbGwgaGFzIGNvbnRlbnRzIgogbXNnc3RyICIiCiAKLSM6IGFwcGx5LmM6MTc4OAorIzogYXBwbHkuYzoxNzg5CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvcnJ1cHQgcGF0Y2ggYXQgbGluZSAlZCIKIG1zZ3N0ciAiIgogCi0jOiBhcHBseS5jOjE4MjUKKyM6IGFwcGx5LmM6MTgyNgogIywgYy1mb3JtYXQKIG1zZ2lkICJuZXcgZmlsZSAlcyBkZXBlbmRzIG9uIG9sZCBjb250ZW50cyIKIG1zZ3N0ciAiIgogCi0jOiBhcHBseS5jOjE4MjcKKyM6IGFwcGx5LmM6MTgyOAogIywgYy1mb3JtYXQKIG1zZ2lkICJkZWxldGVkIGZpbGUgJXMgc3RpbGwgaGFzIGNvbnRlbnRzIgogbXNnc3RyICIiCiAKLSM6IGFwcGx5LmM6MTgzMAorIzogYXBwbHkuYzoxODMxCiAjLCBjLWZvcm1hdAogbXNnaWQgIioqIHdhcm5pbmc6IGZpbGUgJXMgYmVjb21lcyBlbXB0eSBidXQgaXMgbm90IGRlbGV0ZWQiCiBtc2dzdHIgIiIKIAotIzogYXBwbHkuYzoxOTc3CisjOiBhcHBseS5jOjE5NzgKICMsIGMtZm9ybWF0CiBtc2dpZCAiY29ycnVwdCBiaW5hcnkgcGF0Y2ggYXQgbGluZSAlZDogJS4qcyIKIG1zZ3N0ciAiIgogCi0jOiBhcHBseS5jOjIwMTQKKyM6IGFwcGx5LmM6MjAxNQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bnJlY29nbml6ZWQgYmluYXJ5IHBhdGNoIGF0IGxpbmUgJWQiCiBtc2dzdHIgIiIKIAotIzogYXBwbHkuYzoyMTc2CisjOiBhcHBseS5jOjIxNzcKICMsIGMtZm9ybWF0CiBtc2dpZCAicGF0Y2ggd2l0aCBvbmx5IGdhcmJhZ2UgYXQgbGluZSAlZCIKIG1zZ3N0ciAiIgogCi0jOiBhcHBseS5jOjIyNjIKKyM6IGFwcGx5LmM6MjI2MwogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gcmVhZCBzeW1saW5rICVzIgogbXNnc3RyICIiCiAKLSM6IGFwcGx5LmM6MjI2NgorIzogYXBwbHkuYzoyMjY3CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBvcGVuIG9yIHJlYWQgJXMiCiBtc2dzdHIgIiIKIAotIzogYXBwbHkuYzoyOTI1CisjOiBhcHBseS5jOjI5MjYKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBzdGFydCBvZiBsaW5lOiAnJWMnIgogbXNnc3RyICIiCiAKLSM6IGFwcGx5LmM6MzA0NgorIzogYXBwbHkuYzozMDQ3CiAjLCBjLWZvcm1hdAogbXNnaWQgIkh1bmsgIyVkIHN1Y2NlZWRlZCBhdCAlZCAob2Zmc2V0ICVkIGxpbmUpLiIKIG1zZ2lkX3BsdXJhbCAiSHVuayAjJWQgc3VjY2VlZGVkIGF0ICVkIChvZmZzZXQgJWQgbGluZXMpLiIKIG1zZ3N0clswXSAiIgogbXNnc3RyWzFdICIiCiAKLSM6IGFwcGx5LmM6MzA1OAorIzogYXBwbHkuYzozMDU5CiAjLCBjLWZvcm1hdAogbXNnaWQgIkNvbnRleHQgcmVkdWNlZCB0byAoJWxkLyVsZCkgdG8gYXBwbHkgZnJhZ21lbnQgYXQgJWQiCiBtc2dzdHIgIiIKIAotIzogYXBwbHkuYzozMDY0CisjOiBhcHBseS5jOjMwNjUKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIndoaWxlIHNlYXJjaGluZyBmb3I6XG4iCiAiJS4qcyIKIG1zZ3N0ciAiIgogCi0jOiBhcHBseS5jOjMwODYKKyM6IGFwcGx5LmM6MzA4NwogIywgYy1mb3JtYXQKIG1zZ2lkICJtaXNzaW5nIGJpbmFyeSBwYXRjaCBkYXRhIGZvciAnJXMnIgogbXNnc3RyICIiCiAKLSM6IGFwcGx5LmM6MzA5NAorIzogYXBwbHkuYzozMDk1CiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCByZXZlcnNlLWFwcGx5IGEgYmluYXJ5IHBhdGNoIHdpdGhvdXQgdGhlIHJldmVyc2UgaHVuayB0byAnJXMnIgogbXNnc3RyICIiCiAKLSM6IGFwcGx5LmM6MzE0MQorIzogYXBwbHkuYzozMTQyCiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCBhcHBseSBiaW5hcnkgcGF0Y2ggdG8gJyVzJyB3aXRob3V0IGZ1bGwgaW5kZXggbGluZSIKIG1zZ3N0ciAiIgogCi0jOiBhcHBseS5jOjMxNTEKKyM6IGFwcGx5LmM6MzE1MgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAidGhlIHBhdGNoIGFwcGxpZXMgdG8gJyVzJyAoJXMpLCB3aGljaCBkb2VzIG5vdCBtYXRjaCB0aGUgY3VycmVudCBjb250ZW50cy4iCiBtc2dzdHIgIiIKIAotIzogYXBwbHkuYzozMTU5CisjOiBhcHBseS5jOjMxNjAKICMsIGMtZm9ybWF0CiBtc2dpZCAidGhlIHBhdGNoIGFwcGxpZXMgdG8gYW4gZW1wdHkgJyVzJyBidXQgaXQgaXMgbm90IGVtcHR5IgogbXNnc3RyICIiCiAKLSM6IGFwcGx5LmM6MzE3NworIzogYXBwbHkuYzozMTc4CiAjLCBjLWZvcm1hdAogbXNnaWQgInRoZSBuZWNlc3NhcnkgcG9zdGltYWdlICVzIGZvciAnJXMnIGNhbm5vdCBiZSByZWFkIgogbXNnc3RyICIiCiAKLSM6IGFwcGx5LmM6MzE5MAorIzogYXBwbHkuYzozMTkxCiAjLCBjLWZvcm1hdAogbXNnaWQgImJpbmFyeSBwYXRjaCBkb2VzIG5vdCBhcHBseSB0byAnJXMnIgogbXNnc3RyICIiCiAKLSM6IGFwcGx5LmM6MzE5NgorIzogYXBwbHkuYzozMTk3CiAjLCBjLWZvcm1hdAogbXNnaWQgImJpbmFyeSBwYXRjaCB0byAnJXMnIGNyZWF0ZXMgaW5jb3JyZWN0IHJlc3VsdCAoZXhwZWN0aW5nICVzLCBnb3QgJXMpIgogbXNnc3RyICIiCiAKLSM6IGFwcGx5LmM6MzIxNworIzogYXBwbHkuYzozMjE4CiAjLCBjLWZvcm1hdAogbXNnaWQgInBhdGNoIGZhaWxlZDogJXM6JWxkIgogbXNnc3RyICIiCiAKLSM6IGFwcGx5LmM6MzM0MAorIzogYXBwbHkuYzozMzQxCiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCBjaGVja291dCAlcyIKIG1zZ3N0ciAiIgogCi0jOiBhcHBseS5jOjMzOTIgYXBwbHkuYzozNDAzIGFwcGx5LmM6MzQ0OSBtaWR4LmM6NjIgc2V0dXAuYzoyNzkKKyM6IGFwcGx5LmM6MzM5MyBhcHBseS5jOjM0MDQgYXBwbHkuYzozNDUwIG1pZHguYzo2MSBzZXR1cC5jOjI4MAogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gcmVhZCAlcyIKIG1zZ3N0ciAiIgogCi0jOiBhcHBseS5jOjM0MDAKKyM6IGFwcGx5LmM6MzQwMQogIywgYy1mb3JtYXQKIG1zZ2lkICJyZWFkaW5nIGZyb20gJyVzJyBiZXlvbmQgYSBzeW1ib2xpYyBsaW5rIgogbXNnc3RyICIiCiAKLSM6IGFwcGx5LmM6MzQyOSBhcHBseS5jOjM2NzIKKyM6IGFwcGx5LmM6MzQzMCBhcHBseS5jOjM2NzMKICMsIGMtZm9ybWF0CiBtc2dpZCAicGF0aCAlcyBoYXMgYmVlbiByZW5hbWVkL2RlbGV0ZWQiCiBtc2dzdHIgIiIKIAotIzogYXBwbHkuYzozNTE1IGFwcGx5LmM6MzY4NworIzogYXBwbHkuYzozNTE2IGFwcGx5LmM6MzY4OAogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogZG9lcyBub3QgZXhpc3QgaW4gaW5kZXgiCiBtc2dzdHIgIiIKIAotIzogYXBwbHkuYzozNTI0IGFwcGx5LmM6MzY5NQorIzogYXBwbHkuYzozNTI1IGFwcGx5LmM6MzY5NgogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogZG9lcyBub3QgbWF0Y2ggaW5kZXgiCiBtc2dzdHIgIiIKIAotIzogYXBwbHkuYzozNTU5CisjOiBhcHBseS5jOjM1NjAKIG1zZ2lkICJyZXBvc2l0b3J5IGxhY2tzIHRoZSBuZWNlc3NhcnkgYmxvYiB0byBmYWxsIGJhY2sgb24gMy13YXkgbWVyZ2UuIgogbXNnc3RyICIiCiAKLSM6IGFwcGx5LmM6MzU2MgorIzogYXBwbHkuYzozNTYzCiAjLCBjLWZvcm1hdAogbXNnaWQgIkZhbGxpbmcgYmFjayB0byB0aHJlZS13YXkgbWVyZ2UuLi5cbiIKIG1zZ3N0ciAiIgogCi0jOiBhcHBseS5jOjM1NzggYXBwbHkuYzozNTgyCisjOiBhcHBseS5jOjM1NzkgYXBwbHkuYzozNTgzCiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCByZWFkIHRoZSBjdXJyZW50IGNvbnRlbnRzIG9mICclcyciCiBtc2dzdHIgIiIKIAotIzogYXBwbHkuYzozNTk0CisjOiBhcHBseS5jOjM1OTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiRmFpbGVkIHRvIGZhbGwgYmFjayBvbiB0aHJlZS13YXkgbWVyZ2UuLi5cbiIKIG1zZ3N0ciAiIgogCi0jOiBhcHBseS5jOjM2MDgKKyM6IGFwcGx5LmM6MzYwOQogIywgYy1mb3JtYXQKIG1zZ2lkICJBcHBsaWVkIHBhdGNoIHRvICclcycgd2l0aCBjb25mbGljdHMuXG4iCiBtc2dzdHIgIiIKIAotIzogYXBwbHkuYzozNjEzCisjOiBhcHBseS5jOjM2MTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiQXBwbGllZCBwYXRjaCB0byAnJXMnIGNsZWFubHkuXG4iCiBtc2dzdHIgIiIKIAotIzogYXBwbHkuYzozNjM5CisjOiBhcHBseS5jOjM2NDAKIG1zZ2lkICJyZW1vdmFsIHBhdGNoIGxlYXZlcyBmaWxlIGNvbnRlbnRzIgogbXNnc3RyICIiCiAKLSM6IGFwcGx5LmM6MzcxMgorIzogYXBwbHkuYzozNzEzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiB3cm9uZyB0eXBlIgogbXNnc3RyICIiCiAKLSM6IGFwcGx5LmM6MzcxNAorIzogYXBwbHkuYzozNzE1CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIGhhcyB0eXBlICVvLCBleHBlY3RlZCAlbyIKIG1zZ3N0ciAiIgogCi0jOiBhcHBseS5jOjM4NjUgYXBwbHkuYzozODY3IHJlYWQtY2FjaGUuYzo4MzAgcmVhZC1jYWNoZS5jOjg1NgorIzogYXBwbHkuYzozODY2IGFwcGx5LmM6Mzg2OCByZWFkLWNhY2hlLmM6ODMwIHJlYWQtY2FjaGUuYzo4NTYKICM6IHJlYWQtY2FjaGUuYzoxMzA5CiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgcGF0aCAnJXMnIgogbXNnc3RyICIiCiAKLSM6IGFwcGx5LmM6MzkyMworIzogYXBwbHkuYzozOTI0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiBhbHJlYWR5IGV4aXN0cyBpbiBpbmRleCIKIG1zZ3N0ciAiIgogCi0jOiBhcHBseS5jOjM5MjYKKyM6IGFwcGx5LmM6MzkyNwogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogYWxyZWFkeSBleGlzdHMgaW4gd29ya2luZyBkaXJlY3RvcnkiCiBtc2dzdHIgIiIKIAotIzogYXBwbHkuYzozOTQ2CisjOiBhcHBseS5jOjM5NDcKICMsIGMtZm9ybWF0CiBtc2dpZCAibmV3IG1vZGUgKCVvKSBvZiAlcyBkb2VzIG5vdCBtYXRjaCBvbGQgbW9kZSAoJW8pIgogbXNnc3RyICIiCiAKLSM6IGFwcGx5LmM6Mzk1MQorIzogYXBwbHkuYzozOTUyCiAjLCBjLWZvcm1hdAogbXNnaWQgIm5ldyBtb2RlICglbykgb2YgJXMgZG9lcyBub3QgbWF0Y2ggb2xkIG1vZGUgKCVvKSBvZiAlcyIKIG1zZ3N0ciAiIgogCi0jOiBhcHBseS5jOjM5NzEKKyM6IGFwcGx5LmM6Mzk3MgogIywgYy1mb3JtYXQKIG1zZ2lkICJhZmZlY3RlZCBmaWxlICclcycgaXMgYmV5b25kIGEgc3ltYm9saWMgbGluayIKIG1zZ3N0ciAiIgogCi0jOiBhcHBseS5jOjM5NzUKKyM6IGFwcGx5LmM6Mzk3NgogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogcGF0Y2ggZG9lcyBub3QgYXBwbHkiCiBtc2dzdHIgIiIKIAotIzogYXBwbHkuYzozOTkwCisjOiBhcHBseS5jOjM5OTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ2hlY2tpbmcgcGF0Y2ggJXMuLi4iCiBtc2dzdHIgIiIKIAotIzogYXBwbHkuYzo0MDgyCisjOiBhcHBseS5jOjQwODMKICMsIGMtZm9ybWF0CiBtc2dpZCAic2hhMSBpbmZvcm1hdGlvbiBpcyBsYWNraW5nIG9yIHVzZWxlc3MgZm9yIHN1Ym1vZHVsZSAlcyIKIG1zZ3N0ciAiIgogCi0jOiBhcHBseS5jOjQwODkKKyM6IGFwcGx5LmM6NDA5MAogIywgYy1mb3JtYXQKIG1zZ2lkICJtb2RlIGNoYW5nZSBmb3IgJXMsIHdoaWNoIGlzIG5vdCBpbiBjdXJyZW50IEhFQUQiCiBtc2dzdHIgIiIKIAotIzogYXBwbHkuYzo0MDkyCisjOiBhcHBseS5jOjQwOTMKICMsIGMtZm9ybWF0CiBtc2dpZCAic2hhMSBpbmZvcm1hdGlvbiBpcyBsYWNraW5nIG9yIHVzZWxlc3MgKCVzKS4iCiBtc2dzdHIgIiIKIAotIzogYXBwbHkuYzo0MDk3IGJ1aWx0aW4vY2hlY2tvdXQuYzoyNzggYnVpbHRpbi9yZXNldC5jOjE0MworIzogYXBwbHkuYzo0MDk4IGJ1aWx0aW4vY2hlY2tvdXQuYzoyNzkgYnVpbHRpbi9yZXNldC5jOjE0MwogIywgYy1mb3JtYXQKIG1zZ2lkICJtYWtlX2NhY2hlX2VudHJ5IGZhaWxlZCBmb3IgcGF0aCAnJXMnIgogbXNnc3RyICIiCiAKLSM6IGFwcGx5LmM6NDEwMQorIzogYXBwbHkuYzo0MTAyCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBhZGQgJXMgdG8gdGVtcG9yYXJ5IGluZGV4IgogbXNnc3RyICIiCiAKLSM6IGFwcGx5LmM6NDExMQorIzogYXBwbHkuYzo0MTEyCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCB3cml0ZSB0ZW1wb3JhcnkgaW5kZXggdG8gJXMiCiBtc2dzdHIgIiIKIAotIzogYXBwbHkuYzo0MjQ5CisjOiBhcHBseS5jOjQyNTAKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHJlbW92ZSAlcyBmcm9tIGluZGV4IgogbXNnc3RyICIiCiAKLSM6IGFwcGx5LmM6NDI4MworIzogYXBwbHkuYzo0Mjg0CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvcnJ1cHQgcGF0Y2ggZm9yIHN1Ym1vZHVsZSAlcyIKIG1zZ3N0ciAiIgogCi0jOiBhcHBseS5jOjQyODkKKyM6IGFwcGx5LmM6NDI5MAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gc3RhdCBuZXdseSBjcmVhdGVkIGZpbGUgJyVzJyIKIG1zZ3N0ciAiIgogCi0jOiBhcHBseS5jOjQyOTcKKyM6IGFwcGx5LmM6NDI5OAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gY3JlYXRlIGJhY2tpbmcgc3RvcmUgZm9yIG5ld2x5IGNyZWF0ZWQgZmlsZSAlcyIKIG1zZ3N0ciAiIgogCi0jOiBhcHBseS5jOjQzMDMgYXBwbHkuYzo0NDQ4CisjOiBhcHBseS5jOjQzMDQgYXBwbHkuYzo0NDQ5CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBhZGQgY2FjaGUgZW50cnkgZm9yICVzIgogbXNnc3RyICIiCiAKLSM6IGFwcGx5LmM6NDM0NgorIzogYXBwbHkuYzo0MzQ3CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byB3cml0ZSB0byAnJXMnIgogbXNnc3RyICIiCiAKLSM6IGFwcGx5LmM6NDM1MAorIzogYXBwbHkuYzo0MzUxCiAjLCBjLWZvcm1hdAogbXNnaWQgImNsb3NpbmcgZmlsZSAnJXMnIgogbXNnc3RyICIiCiAKLSM6IGFwcGx5LmM6NDQyMAorIzogYXBwbHkuYzo0NDIxCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byB3cml0ZSBmaWxlICclcycgbW9kZSAlbyIKIG1zZ3N0ciAiIgogCi0jOiBhcHBseS5jOjQ1MTgKKyM6IGFwcGx5LmM6NDUxOQogIywgYy1mb3JtYXQKIG1zZ2lkICJBcHBsaWVkIHBhdGNoICVzIGNsZWFubHkuIgogbXNnc3RyICIiCiAKLSM6IGFwcGx5LmM6NDUyNgorIzogYXBwbHkuYzo0NTI3CiBtc2dpZCAiaW50ZXJuYWwgZXJyb3IiCiBtc2dzdHIgIiIKIAotIzogYXBwbHkuYzo0NTI5CisjOiBhcHBseS5jOjQ1MzAKICMsIGMtZm9ybWF0CiBtc2dpZCAiQXBwbHlpbmcgcGF0Y2ggJSVzIHdpdGggJWQgcmVqZWN0Li4uIgogbXNnaWRfcGx1cmFsICJBcHBseWluZyBwYXRjaCAlJXMgd2l0aCAlZCByZWplY3RzLi4uIgogbXNnc3RyWzBdICIiCiBtc2dzdHJbMV0gIiIKIAotIzogYXBwbHkuYzo0NTQwCisjOiBhcHBseS5jOjQ1NDEKICMsIGMtZm9ybWF0CiBtc2dpZCAidHJ1bmNhdGluZyAucmVqIGZpbGVuYW1lIHRvICUuKnMucmVqIgogbXNnc3RyICIiCiAKLSM6IGFwcGx5LmM6NDU0OCBidWlsdGluL2ZldGNoLmM6ODc4IGJ1aWx0aW4vZmV0Y2guYzoxMTY4CisjOiBhcHBseS5jOjQ1NDkgYnVpbHRpbi9mZXRjaC5jOjg5OCBidWlsdGluL2ZldGNoLmM6MTE5NAogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3Qgb3BlbiAlcyIKIG1zZ3N0ciAiIgogCi0jOiBhcHBseS5jOjQ1NjIKKyM6IGFwcGx5LmM6NDU2MwogIywgYy1mb3JtYXQKIG1zZ2lkICJIdW5rICMlZCBhcHBsaWVkIGNsZWFubHkuIgogbXNnc3RyICIiCiAKLSM6IGFwcGx5LmM6NDU2NgorIzogYXBwbHkuYzo0NTY3CiAjLCBjLWZvcm1hdAogbXNnaWQgIlJlamVjdGVkIGh1bmsgIyVkLiIKIG1zZ3N0ciAiIgogCi0jOiBhcHBseS5jOjQ2NzYKKyM6IGFwcGx5LmM6NDY4NgogIywgYy1mb3JtYXQKIG1zZ2lkICJTa2lwcGVkIHBhdGNoICclcycuIgogbXNnc3RyICIiCiAKLSM6IGFwcGx5LmM6NDY4NAorIzogYXBwbHkuYzo0Njk0CiBtc2dpZCAidW5yZWNvZ25pemVkIGlucHV0IgogbXNnc3RyICIiCiAKLSM6IGFwcGx5LmM6NDcwNAorIzogYXBwbHkuYzo0NzE0CiBtc2dpZCAidW5hYmxlIHRvIHJlYWQgaW5kZXggZmlsZSIKIG1zZ3N0ciAiIgogCi0jOiBhcHBseS5jOjQ4NTkKKyM6IGFwcGx5LmM6NDg3MQogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW4ndCBvcGVuIHBhdGNoICclcyc6ICVzIgogbXNnc3RyICIiCiAKLSM6IGFwcGx5LmM6NDg4NgorIzogYXBwbHkuYzo0ODk4CiAjLCBjLWZvcm1hdAogbXNnaWQgInNxdWVsY2hlZCAlZCB3aGl0ZXNwYWNlIGVycm9yIgogbXNnaWRfcGx1cmFsICJzcXVlbGNoZWQgJWQgd2hpdGVzcGFjZSBlcnJvcnMiCiBtc2dzdHJbMF0gIiIKIG1zZ3N0clsxXSAiIgogCi0jOiBhcHBseS5jOjQ4OTIgYXBwbHkuYzo0OTA3CisjOiBhcHBseS5jOjQ5MDQgYXBwbHkuYzo0OTE5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVkIGxpbmUgYWRkcyB3aGl0ZXNwYWNlIGVycm9ycy4iCiBtc2dpZF9wbHVyYWwgIiVkIGxpbmVzIGFkZCB3aGl0ZXNwYWNlIGVycm9ycy4iCiBtc2dzdHJbMF0gIiIKIG1zZ3N0clsxXSAiIgogCi0jOiBhcHBseS5jOjQ5MDAKKyM6IGFwcGx5LmM6NDkxMgogIywgYy1mb3JtYXQKIG1zZ2lkICIlZCBsaW5lIGFwcGxpZWQgYWZ0ZXIgZml4aW5nIHdoaXRlc3BhY2UgZXJyb3JzLiIKIG1zZ2lkX3BsdXJhbCAiJWQgbGluZXMgYXBwbGllZCBhZnRlciBmaXhpbmcgd2hpdGVzcGFjZSBlcnJvcnMuIgogbXNnc3RyWzBdICIiCiBtc2dzdHJbMV0gIiIKIAotIzogYXBwbHkuYzo0OTE2IGJ1aWx0aW4vYWRkLmM6NTQwIGJ1aWx0aW4vbXYuYzozMDEgYnVpbHRpbi9ybS5jOjM5MAorIzogYXBwbHkuYzo0OTI4IGJ1aWx0aW4vYWRkLmM6NTQwIGJ1aWx0aW4vbXYuYzozMDEgYnVpbHRpbi9ybS5jOjM5MAogbXNnaWQgIlVuYWJsZSB0byB3cml0ZSBuZXcgaW5kZXggZmlsZSIKIG1zZ3N0ciAiIgogCi0jOiBhcHBseS5jOjQ5NDMgYXBwbHkuYzo0OTQ2IGJ1aWx0aW4vYW0uYzoyMjA4IGJ1aWx0aW4vYW0uYzoyMjExCi0jOiBidWlsdGluL2Nsb25lLmM6MTIzIGJ1aWx0aW4vZmV0Y2guYzoxMjggYnVpbHRpbi9tZXJnZS5jOjI3MwotIzogYnVpbHRpbi9wdWxsLmM6MjA4IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzo0MDcKKyM6IGFwcGx5LmM6NDk1NSBhcHBseS5jOjQ5NTggYnVpbHRpbi9hbS5jOjIxOTcgYnVpbHRpbi9hbS5jOjIyMDAKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMjIgYnVpbHRpbi9mZXRjaC5jOjE0MyBidWlsdGluL21lcmdlLmM6MjczCisjOiBidWlsdGluL3B1bGwuYzoyMDkgYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjQwNwogIzogYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjEzNjcgYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjEzNzAKICM6IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxODUwIGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxODUzCiAjOiBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6MjA5MiBnaXQtYWRkLS1pbnRlcmFjdGl2ZS5wZXJsOjIxMQogbXNnaWQgInBhdGgiCiBtc2dzdHIgIiIKIAotIzogYXBwbHkuYzo0OTQ0CisjOiBhcHBseS5jOjQ5NTYKIG1zZ2lkICJkb24ndCBhcHBseSBjaGFuZ2VzIG1hdGNoaW5nIHRoZSBnaXZlbiBwYXRoIgogbXNnc3RyICIiCiAKLSM6IGFwcGx5LmM6NDk0NworIzogYXBwbHkuYzo0OTU5CiBtc2dpZCAiYXBwbHkgY2hhbmdlcyBtYXRjaGluZyB0aGUgZ2l2ZW4gcGF0aCIKIG1zZ3N0ciAiIgogCi0jOiBhcHBseS5jOjQ5NDkgYnVpbHRpbi9hbS5jOjIyMTcKKyM6IGFwcGx5LmM6NDk2MSBidWlsdGluL2FtLmM6MjIwNgogbXNnaWQgIm51bSIKIG1zZ3N0ciAiIgogCi0jOiBhcHBseS5jOjQ5NTAKKyM6IGFwcGx5LmM6NDk2MgogbXNnaWQgInJlbW92ZSA8bnVtPiBsZWFkaW5nIHNsYXNoZXMgZnJvbSB0cmFkaXRpb25hbCBkaWZmIHBhdGhzIgogbXNnc3RyICIiCiAKLSM6IGFwcGx5LmM6NDk1MworIzogYXBwbHkuYzo0OTY1CiBtc2dpZCAiaWdub3JlIGFkZGl0aW9ucyBtYWRlIGJ5IHRoZSBwYXRjaCIKIG1zZ3N0ciAiIgogCi0jOiBhcHBseS5jOjQ5NTUKKyM6IGFwcGx5LmM6NDk2NwogbXNnaWQgImluc3RlYWQgb2YgYXBwbHlpbmcgdGhlIHBhdGNoLCBvdXRwdXQgZGlmZnN0YXQgZm9yIHRoZSBpbnB1dCIKIG1zZ3N0ciAiIgogCi0jOiBhcHBseS5jOjQ5NTkKKyM6IGFwcGx5LmM6NDk3MQogbXNnaWQgInNob3cgbnVtYmVyIG9mIGFkZGVkIGFuZCBkZWxldGVkIGxpbmVzIGluIGRlY2ltYWwgbm90YXRpb24iCiBtc2dzdHIgIiIKIAotIzogYXBwbHkuYzo0OTYxCisjOiBhcHBseS5jOjQ5NzMKIG1zZ2lkICJpbnN0ZWFkIG9mIGFwcGx5aW5nIHRoZSBwYXRjaCwgb3V0cHV0IGEgc3VtbWFyeSBmb3IgdGhlIGlucHV0IgogbXNnc3RyICIiCiAKLSM6IGFwcGx5LmM6NDk2MworIzogYXBwbHkuYzo0OTc1CiBtc2dpZCAiaW5zdGVhZCBvZiBhcHBseWluZyB0aGUgcGF0Y2gsIHNlZSBpZiB0aGUgcGF0Y2ggaXMgYXBwbGljYWJsZSIKIG1zZ3N0ciAiIgogCi0jOiBhcHBseS5jOjQ5NjUKKyM6IGFwcGx5LmM6NDk3NwogbXNnaWQgIm1ha2Ugc3VyZSB0aGUgcGF0Y2ggaXMgYXBwbGljYWJsZSB0byB0aGUgY3VycmVudCBpbmRleCIKIG1zZ3N0ciAiIgogCi0jOiBhcHBseS5jOjQ5NjcKKyM6IGFwcGx5LmM6NDk3OQogbXNnaWQgIm1hcmsgbmV3IGZpbGVzIHdpdGggYGdpdCBhZGQgLS1pbnRlbnQtdG8tYWRkYCIKIG1zZ3N0ciAiIgogCi0jOiBhcHBseS5jOjQ5NjkKKyM6IGFwcGx5LmM6NDk4MQogbXNnaWQgImFwcGx5IGEgcGF0Y2ggd2l0aG91dCB0b3VjaGluZyB0aGUgd29ya2luZyB0cmVlIgogbXNnc3RyICIiCiAKLSM6IGFwcGx5LmM6NDk3MQorIzogYXBwbHkuYzo0OTgzCiBtc2dpZCAiYWNjZXB0IGEgcGF0Y2ggdGhhdCB0b3VjaGVzIG91dHNpZGUgdGhlIHdvcmtpbmcgYXJlYSIKIG1zZ3N0ciAiIgogCi0jOiBhcHBseS5jOjQ5NzQKKyM6IGFwcGx5LmM6NDk4NgogbXNnaWQgImFsc28gYXBwbHkgdGhlIHBhdGNoICh1c2Ugd2l0aCAtLXN0YXQvLS1zdW1tYXJ5Ly0tY2hlY2spIgogbXNnc3RyICIiCiAKLSM6IGFwcGx5LmM6NDk3NgorIzogYXBwbHkuYzo0OTg4CiBtc2dpZCAiYXR0ZW1wdCB0aHJlZS13YXkgbWVyZ2UgaWYgYSBwYXRjaCBkb2VzIG5vdCBhcHBseSIKIG1zZ3N0ciAiIgogCi0jOiBhcHBseS5jOjQ5NzgKKyM6IGFwcGx5LmM6NDk5MAogbXNnaWQgImJ1aWxkIGEgdGVtcG9yYXJ5IGluZGV4IGJhc2VkIG9uIGVtYmVkZGVkIGluZGV4IGluZm9ybWF0aW9uIgogbXNnc3RyICIiCiAKLSM6IGFwcGx5LmM6NDk4MSBidWlsdGluL2NoZWNrb3V0LWluZGV4LmM6MTczIGJ1aWx0aW4vbHMtZmlsZXMuYzo1MjQKKyM6IGFwcGx5LmM6NDk5MyBidWlsdGluL2NoZWNrb3V0LWluZGV4LmM6MTczIGJ1aWx0aW4vbHMtZmlsZXMuYzo1MjQKIG1zZ2lkICJwYXRocyBhcmUgc2VwYXJhdGVkIHdpdGggTlVMIGNoYXJhY3RlciIKIG1zZ3N0ciAiIgogCi0jOiBhcHBseS5jOjQ5ODMKKyM6IGFwcGx5LmM6NDk5NQogbXNnaWQgImVuc3VyZSBhdCBsZWFzdCA8bj4gbGluZXMgb2YgY29udGV4dCBtYXRjaCIKIG1zZ3N0ciAiIgogCi0jOiBhcHBseS5jOjQ5ODQgYnVpbHRpbi9hbS5jOjIxOTYgYnVpbHRpbi9pbnRlcnByZXQtdHJhaWxlcnMuYzo5OAorIzogYXBwbHkuYzo0OTk2IGJ1aWx0aW4vYW0uYzoyMTg1IGJ1aWx0aW4vaW50ZXJwcmV0LXRyYWlsZXJzLmM6OTgKICM6IGJ1aWx0aW4vaW50ZXJwcmV0LXRyYWlsZXJzLmM6MTAwIGJ1aWx0aW4vaW50ZXJwcmV0LXRyYWlsZXJzLmM6MTAyCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMzAgYnVpbHRpbi9yZWJhc2UuYzoxNDIxCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMTAgYnVpbHRpbi9yZWJhc2UuYzoxNDQ1CiBtc2dpZCAiYWN0aW9uIgogbXNnc3RyICIiCiAKLSM6IGFwcGx5LmM6NDk4NQorIzogYXBwbHkuYzo0OTk3CiBtc2dpZCAiZGV0ZWN0IG5ldyBvciBtb2RpZmllZCBsaW5lcyB0aGF0IGhhdmUgd2hpdGVzcGFjZSBlcnJvcnMiCiBtc2dzdHIgIiIKIAotIzogYXBwbHkuYzo0OTg4IGFwcGx5LmM6NDk5MQorIzogYXBwbHkuYzo1MDAwIGFwcGx5LmM6NTAwMwogbXNnaWQgImlnbm9yZSBjaGFuZ2VzIGluIHdoaXRlc3BhY2Ugd2hlbiBmaW5kaW5nIGNvbnRleHQiCiBtc2dzdHIgIiIKIAotIzogYXBwbHkuYzo0OTk0CisjOiBhcHBseS5jOjUwMDYKIG1zZ2lkICJhcHBseSB0aGUgcGF0Y2ggaW4gcmV2ZXJzZSIKIG1zZ3N0ciAiIgogCi0jOiBhcHBseS5jOjQ5OTYKKyM6IGFwcGx5LmM6NTAwOAogbXNnaWQgImRvbid0IGV4cGVjdCBhdCBsZWFzdCBvbmUgbGluZSBvZiBjb250ZXh0IgogbXNnc3RyICIiCiAKLSM6IGFwcGx5LmM6NDk5OAorIzogYXBwbHkuYzo1MDEwCiBtc2dpZCAibGVhdmUgdGhlIHJlamVjdGVkIGh1bmtzIGluIGNvcnJlc3BvbmRpbmcgKi5yZWogZmlsZXMiCiBtc2dzdHIgIiIKIAotIzogYXBwbHkuYzo1MDAwCisjOiBhcHBseS5jOjUwMTIKIG1zZ2lkICJhbGxvdyBvdmVybGFwcGluZyBodW5rcyIKIG1zZ3N0ciAiIgogCi0jOiBhcHBseS5jOjUwMDEgYnVpbHRpbi9hZGQuYzoyOTEgYnVpbHRpbi9jaGVjay1pZ25vcmUuYzoyMgorIzogYXBwbHkuYzo1MDEzIGJ1aWx0aW4vYWRkLmM6MjkxIGJ1aWx0aW4vY2hlY2staWdub3JlLmM6MjIKICM6IGJ1aWx0aW4vY29tbWl0LmM6MTMzNyBidWlsdGluL2NvdW50LW9iamVjdHMuYzo5OCBidWlsdGluL2ZzY2suYzo3ODYKLSM6IGJ1aWx0aW4vbG9nLmM6MjA2OCBidWlsdGluL212LmM6MTIzIGJ1aWx0aW4vcmVhZC10cmVlLmM6MTI4CisjOiBidWlsdGluL2xvZy5jOjIwODUgYnVpbHRpbi9tdi5jOjEyMyBidWlsdGluL3JlYWQtdHJlZS5jOjEyOAogbXNnaWQgImJlIHZlcmJvc2UiCiBtc2dzdHIgIiIKIAotIzogYXBwbHkuYzo1MDAzCisjOiBhcHBseS5jOjUwMTUKIG1zZ2lkICJ0b2xlcmF0ZSBpbmNvcnJlY3RseSBkZXRlY3RlZCBtaXNzaW5nIG5ldy1saW5lIGF0IHRoZSBlbmQgb2YgZmlsZSIKIG1zZ3N0ciAiIgogCi0jOiBhcHBseS5jOjUwMDYKKyM6IGFwcGx5LmM6NTAxOAogbXNnaWQgImRvIG5vdCB0cnVzdCB0aGUgbGluZSBjb3VudHMgaW4gdGhlIGh1bmsgaGVhZGVycyIKIG1zZ3N0ciAiIgogCi0jOiBhcHBseS5jOjUwMDggYnVpbHRpbi9hbS5jOjIyMDUKKyM6IGFwcGx5LmM6NTAyMCBidWlsdGluL2FtLmM6MjE5NAogbXNnaWQgInJvb3QiCiBtc2dzdHIgIiIKIAotIzogYXBwbHkuYzo1MDA5CisjOiBhcHBseS5jOjUwMjEKIG1zZ2lkICJwcmVwZW5kIDxyb290PiB0byBhbGwgZmlsZW5hbWVzIgogbXNnc3RyICIiCiAKQEAgLTc3MCw3ICs3NzAsNyBAQAogbXNnaWQgImFyY2hpdmUgZm9ybWF0IgogbXNnc3RyICIiCiAKLSM6IGFyY2hpdmUuYzo0NTggYnVpbHRpbi9sb2cuYzoxNTgwCisjOiBhcmNoaXZlLmM6NDU4IGJ1aWx0aW4vbG9nLmM6MTU4MQogbXNnaWQgInByZWZpeCIKIG1zZ3N0ciAiIgogCkBAIC03NzgsMTEgKzc3OCwxMiBAQAogbXNnaWQgInByZXBlbmQgcHJlZml4IHRvIGVhY2ggcGF0aG5hbWUgaW4gdGhlIGFyY2hpdmUiCiBtc2dzdHIgIiIKIAotIzogYXJjaGl2ZS5jOjQ2MCBidWlsdGluL2JsYW1lLmM6ODYyIGJ1aWx0aW4vYmxhbWUuYzo4NzQgYnVpbHRpbi9ibGFtZS5jOjg3NQotIzogYnVpbHRpbi9jb21taXQtdHJlZS5jOjExNyBidWlsdGluL2NvbmZpZy5jOjEyOSBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTEzNAotIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExMzYgYnVpbHRpbi9ncmVwLmM6ODk3IGJ1aWx0aW4vaGFzaC1vYmplY3QuYzoxMDUKLSM6IGJ1aWx0aW4vbHMtZmlsZXMuYzo1NjAgYnVpbHRpbi9scy1maWxlcy5jOjU2MyBidWlsdGluL25vdGVzLmM6NDEyCi0jOiBidWlsdGluL25vdGVzLmM6NTc4IGJ1aWx0aW4vcmVhZC10cmVlLmM6MTIzIHBhcnNlLW9wdGlvbnMuaDoxNzcKKyM6IGFyY2hpdmUuYzo0NjAgYnVpbHRpbi9ibGFtZS5jOjg2MSBidWlsdGluL2JsYW1lLmM6ODczIGJ1aWx0aW4vYmxhbWUuYzo4NzQKKyM6IGJ1aWx0aW4vY29tbWl0LXRyZWUuYzoxMTcgYnVpbHRpbi9jb25maWcuYzoxMjkgYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNjIKKyM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTY0IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTY4IGJ1aWx0aW4vZ3JlcC5jOjg5OQorIzogYnVpbHRpbi9oYXNoLW9iamVjdC5jOjEwNSBidWlsdGluL2xzLWZpbGVzLmM6NTYwIGJ1aWx0aW4vbHMtZmlsZXMuYzo1NjMKKyM6IGJ1aWx0aW4vbm90ZXMuYzo0MTIgYnVpbHRpbi9ub3Rlcy5jOjU3OCBidWlsdGluL3JlYWQtdHJlZS5jOjEyMworIzogcGFyc2Utb3B0aW9ucy5oOjE4NgogbXNnaWQgImZpbGUiCiBtc2dzdHIgIiIKIApAQCAtODE0LDcgKzgxNSw3IEBACiBtc2dpZCAibGlzdCBzdXBwb3J0ZWQgYXJjaGl2ZSBmb3JtYXRzIgogbXNnc3RyICIiCiAKLSM6IGFyY2hpdmUuYzo0NzkgYnVpbHRpbi9hcmNoaXZlLmM6OTEgYnVpbHRpbi9jbG9uZS5jOjExMyBidWlsdGluL2Nsb25lLmM6MTE2CisjOiBhcmNoaXZlLmM6NDc5IGJ1aWx0aW4vYXJjaGl2ZS5jOjkxIGJ1aWx0aW4vY2xvbmUuYzoxMTIgYnVpbHRpbi9jbG9uZS5jOjExNQogIzogYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjEzNzkgYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjE4NTkKIG1zZ2lkICJyZXBvIgogbXNnc3RyICIiCkBAIC04MjMsNyArODI0LDcgQEAKIG1zZ2lkICJyZXRyaWV2ZSB0aGUgYXJjaGl2ZSBmcm9tIHJlbW90ZSByZXBvc2l0b3J5IDxyZXBvPiIKIG1zZ3N0ciAiIgogCi0jOiBhcmNoaXZlLmM6NDgxIGJ1aWx0aW4vYXJjaGl2ZS5jOjkzIGJ1aWx0aW4vZGlmZnRvb2wuYzo3MDcKKyM6IGFyY2hpdmUuYzo0ODEgYnVpbHRpbi9hcmNoaXZlLmM6OTMgYnVpbHRpbi9kaWZmdG9vbC5jOjcxNQogIzogYnVpbHRpbi9ub3Rlcy5jOjQ5OAogbXNnaWQgImNvbW1hbmQiCiBtc2dzdHIgIiIKQEAgLTg1OSwyNiArODYwLDI2IEBACiBtc2dpZCAiY2Fubm90IHN0cmVhbSBibG9iICVzIgogbXNnc3RyICIiCiAKLSM6IGFyY2hpdmUtdGFyLmM6MjYwIGFyY2hpdmUtemlwLmM6MzYzCisjOiBhcmNoaXZlLXRhci5jOjI2NiBhcmNoaXZlLXppcC5jOjM2MwogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bnN1cHBvcnRlZCBmaWxlIG1vZGU6IDAlbyAoU0hBMTogJXMpIgogbXNnc3RyICIiCiAKLSM6IGFyY2hpdmUtdGFyLmM6Mjg3IGFyY2hpdmUtemlwLmM6MzUzCisjOiBhcmNoaXZlLXRhci5jOjI5MyBhcmNoaXZlLXppcC5jOjM1MwogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgcmVhZCAlcyIKIG1zZ3N0ciAiIgogCi0jOiBhcmNoaXZlLXRhci5jOjQ1OQorIzogYXJjaGl2ZS10YXIuYzo0NjUKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHN0YXJ0ICclcycgZmlsdGVyIgogbXNnc3RyICIiCiAKLSM6IGFyY2hpdmUtdGFyLmM6NDYyCisjOiBhcmNoaXZlLXRhci5jOjQ2OAogbXNnaWQgInVuYWJsZSB0byByZWRpcmVjdCBkZXNjcmlwdG9yIgogbXNnc3RyICIiCiAKLSM6IGFyY2hpdmUtdGFyLmM6NDY5CisjOiBhcmNoaXZlLXRhci5jOjQ3NQogIywgYy1mb3JtYXQKIG1zZ2lkICInJXMnIGZpbHRlciByZXBvcnRlZCBlcnJvciIKIG1zZ3N0ciAiIgpAQCAtOTAzLDE3ICs5MDQsMTcgQEAKIG1zZ2lkICJ0aW1lc3RhbXAgdG9vIGxhcmdlIGZvciB0aGlzIHN5c3RlbTogJTxQUkl1TUFYPiIKIG1zZ3N0ciAiIgogCi0jOiBhdHRyLmM6MjExCisjOiBhdHRyLmM6MjEzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiUuKnMgaXMgbm90IGEgdmFsaWQgYXR0cmlidXRlIG5hbWUiCiBtc2dzdHIgIiIKIAotIzogYXR0ci5jOjM2OAorIzogYXR0ci5jOjM3MAogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyBub3QgYWxsb3dlZDogJXM6JWQiCiBtc2dzdHIgIiIKIAotIzogYXR0ci5jOjQwOAorIzogYXR0ci5jOjQxMAogbXNnaWQgIiIKICJOZWdhdGl2ZSBwYXR0ZXJucyBhcmUgaWdub3JlZCBpbiBnaXQgYXR0cmlidXRlc1xuIgogIlVzZSAnXFwhJyBmb3IgbGl0ZXJhbCBsZWFkaW5nIGV4Y2xhbWF0aW9uLiIKQEAgLTEwMjQsMzcgKzEwMjUsMzcgQEAKIG1zZ3N0clswXSAiIgogbXNnc3RyWzFdICIiCiAKLSM6IGJsYW1lLmM6MjY5NworIzogYmxhbWUuYzoyNzAwCiBtc2dpZCAiLS1jb250ZW50cyBhbmQgLS1yZXZlcnNlIGRvIG5vdCBibGVuZCB3ZWxsLiIKIG1zZ3N0ciAiIgogCi0jOiBibGFtZS5jOjI3MTEKKyM6IGJsYW1lLmM6MjcxNAogbXNnaWQgImNhbm5vdCB1c2UgLS1jb250ZW50cyB3aXRoIGZpbmFsIGNvbW1pdCBvYmplY3QgbmFtZSIKIG1zZ3N0ciAiIgogCi0jOiBibGFtZS5jOjI3MzIKKyM6IGJsYW1lLmM6MjczNQogbXNnaWQgIi0tcmV2ZXJzZSBhbmQgLS1maXJzdC1wYXJlbnQgdG9nZXRoZXIgcmVxdWlyZSBzcGVjaWZpZWQgbGF0ZXN0IGNvbW1pdCIKIG1zZ3N0ciAiIgogCi0jOiBibGFtZS5jOjI3NDEgYnVuZGxlLmM6MTY3IHJlZi1maWx0ZXIuYzoyMTk2IHJlbW90ZS5jOjE5Mzggc2VxdWVuY2VyLmM6MjAzMwotIzogc2VxdWVuY2VyLmM6NDM0OCBidWlsdGluL2NvbW1pdC5jOjEwMjAgYnVpbHRpbi9sb2cuYzozODcgYnVpbHRpbi9sb2cuYzo5NjMKLSM6IGJ1aWx0aW4vbG9nLmM6MTQ1MSBidWlsdGluL2xvZy5jOjE4MjcgYnVpbHRpbi9sb2cuYzoyMTE3IGJ1aWx0aW4vbWVyZ2UuYzo0MTEKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzE0OCBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMxNjMKKyM6IGJsYW1lLmM6Mjc0NCBidW5kbGUuYzoxNjcgcmVmLWZpbHRlci5jOjIyMDMgcmVtb3RlLmM6MTk0MSBzZXF1ZW5jZXIuYzoxOTcxCisjOiBzZXF1ZW5jZXIuYzo0MzA1IGJ1aWx0aW4vY29tbWl0LmM6MTAyMCBidWlsdGluL2xvZy5jOjM4NyBidWlsdGluL2xvZy5jOjk2NAorIzogYnVpbHRpbi9sb2cuYzoxNDUyIGJ1aWx0aW4vbG9nLmM6MTg0NCBidWlsdGluL2xvZy5jOjIxMzQgYnVpbHRpbi9tZXJnZS5jOjQxMQorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMTI4IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzE0MwogIzogYnVpbHRpbi9zaG9ydGxvZy5jOjE5MgogbXNnaWQgInJldmlzaW9uIHdhbGsgc2V0dXAgZmFpbGVkIgogbXNnc3RyICIiCiAKLSM6IGJsYW1lLmM6Mjc1OQorIzogYmxhbWUuYzoyNzYyCiBtc2dpZCAiIgogIi0tcmV2ZXJzZSAtLWZpcnN0LXBhcmVudCB0b2dldGhlciByZXF1aXJlIHJhbmdlIGFsb25nIGZpcnN0LXBhcmVudCBjaGFpbiIKIG1zZ3N0ciAiIgogCi0jOiBibGFtZS5jOjI3NzAKKyM6IGJsYW1lLmM6Mjc3MwogIywgYy1mb3JtYXQKIG1zZ2lkICJubyBzdWNoIHBhdGggJXMgaW4gJXMiCiBtc2dzdHIgIiIKIAotIzogYmxhbWUuYzoyNzgxCisjOiBibGFtZS5jOjI3ODQKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IHJlYWQgYmxvYiAlcyBmb3IgcGF0aCAlcyIKIG1zZ3N0ciAiIgpAQCAtMTE5Myw3ICsxMTk0LDcgQEAKIG1zZ2lkICJ1bnJlY29nbml6ZWQgaGVhZGVyOiAlcyVzICglZCkiCiBtc2dzdHIgIiIKIAotIzogYnVuZGxlLmM6OTAgcmVyZXJlLmM6NDgwIHJlcmVyZS5jOjY5MCBzZXF1ZW5jZXIuYzoyMjgzIHNlcXVlbmNlci5jOjMwMjQKKyM6IGJ1bmRsZS5jOjkwIHJlcmVyZS5jOjQ4MCByZXJlcmUuYzo2OTAgc2VxdWVuY2VyLmM6MjIyMSBzZXF1ZW5jZXIuYzoyOTYyCiAjOiBidWlsdGluL2NvbW1pdC5jOjc5MQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3Qgb3BlbiAnJXMnIgpAQCAtMTI0Niw3ICsxMjQ3LDcgQEAKIG1zZ2lkICJyZWYgJyVzJyBpcyBleGNsdWRlZCBieSB0aGUgcmV2LWxpc3Qgb3B0aW9ucyIKIG1zZ3N0ciAiIgogCi0jOiBidW5kbGUuYzo0NjAgYnVpbHRpbi9sb2cuYzoyMDIgYnVpbHRpbi9sb2cuYzoxNzMyIGJ1aWx0aW4vc2hvcnRsb2cuYzozMDYKKyM6IGJ1bmRsZS5jOjQ2MCBidWlsdGluL2xvZy5jOjIwMiBidWlsdGluL2xvZy5jOjE3MzMgYnVpbHRpbi9zaG9ydGxvZy5jOjMwNgogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bnJlY29nbml6ZWQgYXJndW1lbnQ6ICVzIgogbXNnc3RyICIiCkBAIC0xMjY5LDggKzEyNzAsOCBAQAogbXNnaWQgImludmFsaWQgY29sb3IgdmFsdWU6ICUuKnMiCiBtc2dzdHIgIiIKIAotIzogY29tbWl0LmM6NTAgc2VxdWVuY2VyLmM6MjcyNyBidWlsdGluL2FtLmM6MzU1IGJ1aWx0aW4vYW0uYzozOTkKLSM6IGJ1aWx0aW4vYW0uYzoxMzc4IGJ1aWx0aW4vYW0uYzoyMDIwIGJ1aWx0aW4vcmVwbGFjZS5jOjQ1NQorIzogY29tbWl0LmM6NTAgc2VxdWVuY2VyLmM6MjY2NSBidWlsdGluL2FtLmM6MzU0IGJ1aWx0aW4vYW0uYzozOTgKKyM6IGJ1aWx0aW4vYW0uYzoxMzY2IGJ1aWx0aW4vYW0uYzoyMDA5IGJ1aWx0aW4vcmVwbGFjZS5jOjQ1NgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcGFyc2UgJXMiCiBtc2dzdHIgIiIKQEAgLTEyOTIsMjcgKzEyOTMsMjcgQEAKICJcImdpdCBjb25maWcgYWR2aWNlLmdyYWZ0RmlsZURlcHJlY2F0ZWQgZmFsc2VcIiIKIG1zZ3N0ciAiIgogCi0jOiBjb21taXQuYzoxMTI3CisjOiBjb21taXQuYzoxMTI4CiAjLCBjLWZvcm1hdAogbXNnaWQgIkNvbW1pdCAlcyBoYXMgYW4gdW50cnVzdGVkIEdQRyBzaWduYXR1cmUsIGFsbGVnZWRseSBieSAlcy4iCiBtc2dzdHIgIiIKIAotIzogY29tbWl0LmM6MTEzMAorIzogY29tbWl0LmM6MTEzMQogIywgYy1mb3JtYXQKIG1zZ2lkICJDb21taXQgJXMgaGFzIGEgYmFkIEdQRyBzaWduYXR1cmUgYWxsZWdlZGx5IGJ5ICVzLiIKIG1zZ3N0ciAiIgogCi0jOiBjb21taXQuYzoxMTMzCisjOiBjb21taXQuYzoxMTM0CiAjLCBjLWZvcm1hdAogbXNnaWQgIkNvbW1pdCAlcyBkb2VzIG5vdCBoYXZlIGEgR1BHIHNpZ25hdHVyZS4iCiBtc2dzdHIgIiIKIAotIzogY29tbWl0LmM6MTEzNgorIzogY29tbWl0LmM6MTEzNwogIywgYy1mb3JtYXQKIG1zZ2lkICJDb21taXQgJXMgaGFzIGEgZ29vZCBHUEcgc2lnbmF0dXJlIGJ5ICVzXG4iCiBtc2dzdHIgIiIKIAotIzogY29tbWl0LmM6MTM5MAorIzogY29tbWl0LmM6MTM5MQogbXNnaWQgIiIKICJXYXJuaW5nOiBjb21taXQgbWVzc2FnZSBkaWQgbm90IGNvbmZvcm0gdG8gVVRGLTguXG4iCiAiWW91IG1heSB3YW50IHRvIGFtZW5kIGl0IGFmdGVyIGZpeGluZyB0aGUgbWVzc2FnZSwgb3Igc2V0IHRoZSBjb25maWdcbiIKQEAgLTEzNjksMTkzICsxMzcwLDIwOCBAQAogbXNnaWQgInVuYWJsZSB0byBmaW5kIGFsbCBjb21taXQtZ3JhcGggZmlsZXMiCiBtc2dzdHIgIiIKIAotIzogY29tbWl0LWdyYXBoLmM6NTU0IGNvbW1pdC1ncmFwaC5jOjYxNAorIzogY29tbWl0LWdyYXBoLmM6NTYxIGNvbW1pdC1ncmFwaC5jOjYyMQogbXNnaWQgImludmFsaWQgY29tbWl0IHBvc2l0aW9uLiBjb21taXQtZ3JhcGggaXMgbGlrZWx5IGNvcnJ1cHQiCiBtc2dzdHIgIiIKIAotIzogY29tbWl0LWdyYXBoLmM6NTc1CisjOiBjb21taXQtZ3JhcGguYzo1ODIKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGZpbmQgY29tbWl0ICVzIgogbXNnc3RyICIiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjEwMDIgYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNjU3CisjOiBjb21taXQtZ3JhcGguYzo4NTUgYnVpbHRpbi9hbS5jOjEyODcKKyMsIGMtZm9ybWF0Cittc2dpZCAidW5hYmxlIHRvIHBhcnNlIGNvbW1pdCAlcyIKK21zZ3N0ciAiIgorCisjOiBjb21taXQtZ3JhcGguYzo4NTkKKyMsIGMtZm9ybWF0Cittc2dpZCAidW5hYmxlIHRvIGdldCB0cmVlIGZvciAlcyIKK21zZ3N0ciAiIgorCisjOiBjb21taXQtZ3JhcGguYzoxMDE3IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjY0MQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gZ2V0IHR5cGUgb2Ygb2JqZWN0ICVzIgogbXNnc3RyICIiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjEwMzQKKyM6IGNvbW1pdC1ncmFwaC5jOjEwNDkKIG1zZ2lkICJMb2FkaW5nIGtub3duIGNvbW1pdHMgaW4gY29tbWl0IGdyYXBoIgogbXNnc3RyICIiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjEwNTEKKyM6IGNvbW1pdC1ncmFwaC5jOjEwNjYKIG1zZ2lkICJFeHBhbmRpbmcgcmVhY2hhYmxlIGNvbW1pdHMgaW4gY29tbWl0IGdyYXBoIgogbXNnc3RyICIiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjEwNzAKKyM6IGNvbW1pdC1ncmFwaC5jOjEwODUKIG1zZ2lkICJDbGVhcmluZyBjb21taXQgbWFya3MgaW4gY29tbWl0IGdyYXBoIgogbXNnc3RyICIiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjEwODkKKyM6IGNvbW1pdC1ncmFwaC5jOjExMDQKIG1zZ2lkICJDb21wdXRpbmcgY29tbWl0IGdyYXBoIGdlbmVyYXRpb24gbnVtYmVycyIKIG1zZ3N0ciAiIgogCi0jOiBjb21taXQtZ3JhcGguYzoxMTYzCisjOiBjb21taXQtZ3JhcGguYzoxMTc5CiAjLCBjLWZvcm1hdAogbXNnaWQgIkZpbmRpbmcgY29tbWl0cyBmb3IgY29tbWl0IGdyYXBoIGluICVkIHBhY2siCiBtc2dpZF9wbHVyYWwgIkZpbmRpbmcgY29tbWl0cyBmb3IgY29tbWl0IGdyYXBoIGluICVkIHBhY2tzIgogbXNnc3RyWzBdICIiCiBtc2dzdHJbMV0gIiIKIAotIzogY29tbWl0LWdyYXBoLmM6MTE3NgorIzogY29tbWl0LWdyYXBoLmM6MTE5MgogIywgYy1mb3JtYXQKIG1zZ2lkICJlcnJvciBhZGRpbmcgcGFjayAlcyIKIG1zZ3N0ciAiIgogCi0jOiBjb21taXQtZ3JhcGguYzoxMTgwCisjOiBjb21taXQtZ3JhcGguYzoxMTk2CiAjLCBjLWZvcm1hdAogbXNnaWQgImVycm9yIG9wZW5pbmcgaW5kZXggZm9yICVzIgogbXNnc3RyICIiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjEyMDQKKyM6IGNvbW1pdC1ncmFwaC5jOjEyMjAKICMsIGMtZm9ybWF0CiBtc2dpZCAiRmluZGluZyBjb21taXRzIGZvciBjb21taXQgZ3JhcGggZnJvbSAlZCByZWYiCiBtc2dpZF9wbHVyYWwgIkZpbmRpbmcgY29tbWl0cyBmb3IgY29tbWl0IGdyYXBoIGZyb20gJWQgcmVmcyIKIG1zZ3N0clswXSAiIgogbXNnc3RyWzFdICIiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjEyMzgKKyM6IGNvbW1pdC1ncmFwaC5jOjEyNDAKKyMsIGMtZm9ybWF0Cittc2dpZCAiaW52YWxpZCBjb21taXQgb2JqZWN0IGlkOiAlcyIKK21zZ3N0ciAiIgorCisjOiBjb21taXQtZ3JhcGguYzoxMjU1CiBtc2dpZCAiRmluZGluZyBjb21taXRzIGZvciBjb21taXQgZ3JhcGggYW1vbmcgcGFja2VkIG9iamVjdHMiCiBtc2dzdHIgIiIKIAotIzogY29tbWl0LWdyYXBoLmM6MTI1MworIzogY29tbWl0LWdyYXBoLmM6MTI3MAogbXNnaWQgIkNvdW50aW5nIGRpc3RpbmN0IGNvbW1pdHMgaW4gY29tbWl0IGdyYXBoIgogbXNnc3RyICIiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjEyODQKKyM6IGNvbW1pdC1ncmFwaC5jOjEzMDAKIG1zZ2lkICJGaW5kaW5nIGV4dHJhIGVkZ2VzIGluIGNvbW1pdCBncmFwaCIKIG1zZ3N0ciAiIgogCi0jOiBjb21taXQtZ3JhcGguYzoxMzMyCisjOiBjb21taXQtZ3JhcGguYzoxMzQ2CiBtc2dpZCAiZmFpbGVkIHRvIHdyaXRlIGNvcnJlY3QgbnVtYmVyIG9mIGJhc2UgZ3JhcGggaWRzIgogbXNnc3RyICIiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjEzNjUgbWlkeC5jOjgxMQorIzogY29tbWl0LWdyYXBoLmM6MTM3OSBtaWR4LmM6ODEwCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBjcmVhdGUgbGVhZGluZyBkaXJlY3RvcmllcyBvZiAlcyIKIG1zZ3N0ciAiIgogCi0jOiBjb21taXQtZ3JhcGguYzoxMzc3IGJ1aWx0aW4vaW5kZXgtcGFjay5jOjMwNiBidWlsdGluL3JlcGFjay5jOjI0MAorIzogY29tbWl0LWdyYXBoLmM6MTM5MSBidWlsdGluL2luZGV4LXBhY2suYzozMDYgYnVpbHRpbi9yZXBhY2suYzoyNDEKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGNyZWF0ZSAnJXMnIgogbXNnc3RyICIiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjE0MzcKKyM6IGNvbW1pdC1ncmFwaC5jOjE0NTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiV3JpdGluZyBvdXQgY29tbWl0IGdyYXBoIGluICVkIHBhc3MiCiBtc2dpZF9wbHVyYWwgIldyaXRpbmcgb3V0IGNvbW1pdCBncmFwaCBpbiAlZCBwYXNzZXMiCiBtc2dzdHJbMF0gIiIKIG1zZ3N0clsxXSAiIgogCi0jOiBjb21taXQtZ3JhcGguYzoxNDc4CisjOiBjb21taXQtZ3JhcGguYzoxNDkyCiBtc2dpZCAidW5hYmxlIHRvIG9wZW4gY29tbWl0LWdyYXBoIGNoYWluIGZpbGUiCiBtc2dzdHIgIiIKIAotIzogY29tbWl0LWdyYXBoLmM6MTQ5MAorIzogY29tbWl0LWdyYXBoLmM6MTUwNAogbXNnaWQgImZhaWxlZCB0byByZW5hbWUgYmFzZSBjb21taXQtZ3JhcGggZmlsZSIKIG1zZ3N0ciAiIgogCi0jOiBjb21taXQtZ3JhcGguYzoxNTEwCisjOiBjb21taXQtZ3JhcGguYzoxNTI0CiBtc2dpZCAiZmFpbGVkIHRvIHJlbmFtZSB0ZW1wb3JhcnkgY29tbWl0LWdyYXBoIGZpbGUiCiBtc2dzdHIgIiIKIAotIzogY29tbWl0LWdyYXBoLmM6MTYyMQorIzogY29tbWl0LWdyYXBoLmM6MTYzNQogbXNnaWQgIlNjYW5uaW5nIG1lcmdlZCBjb21taXRzIgogbXNnc3RyICIiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjE2MzIKKyM6IGNvbW1pdC1ncmFwaC5jOjE2NDYKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5leHBlY3RlZCBkdXBsaWNhdGUgY29tbWl0IGlkICVzIgogbXNnc3RyICIiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjE2NTcKKyM6IGNvbW1pdC1ncmFwaC5jOjE2NzAKIG1zZ2lkICJNZXJnaW5nIGNvbW1pdC1ncmFwaCIKIG1zZ3N0ciAiIgogCi0jOiBjb21taXQtZ3JhcGguYzoxODQ0CisjOiBjb21taXQtZ3JhcGguYzoxODYwCiAjLCBjLWZvcm1hdAogbXNnaWQgInRoZSBjb21taXQgZ3JhcGggZm9ybWF0IGNhbm5vdCB3cml0ZSAlZCBjb21taXRzIgogbXNnc3RyICIiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjE4NTUKKyM6IGNvbW1pdC1ncmFwaC5jOjE4NzEKIG1zZ2lkICJ0b28gbWFueSBjb21taXRzIHRvIHdyaXRlIGdyYXBoIgogbXNnc3RyICIiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjE5NDUKKyM6IGNvbW1pdC1ncmFwaC5jOjE5NjEKIG1zZ2lkICJ0aGUgY29tbWl0LWdyYXBoIGZpbGUgaGFzIGluY29ycmVjdCBjaGVja3N1bSBhbmQgaXMgbGlrZWx5IGNvcnJ1cHQiCiBtc2dzdHIgIiIKIAotIzogY29tbWl0LWdyYXBoLmM6MTk1NQorIzogY29tbWl0LWdyYXBoLmM6MTk3MQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb21taXQtZ3JhcGggaGFzIGluY29ycmVjdCBPSUQgb3JkZXI6ICVzIHRoZW4gJXMiCiBtc2dzdHIgIiIKIAotIzogY29tbWl0LWdyYXBoLmM6MTk2NSBjb21taXQtZ3JhcGguYzoxOTgwCisjOiBjb21taXQtZ3JhcGguYzoxOTgxIGNvbW1pdC1ncmFwaC5jOjE5OTYKICMsIGMtZm9ybWF0CiBtc2dpZCAiY29tbWl0LWdyYXBoIGhhcyBpbmNvcnJlY3QgZmFub3V0IHZhbHVlOiBmYW5vdXRbJWRdID0gJXUgIT0gJXUiCiBtc2dzdHIgIiIKIAotIzogY29tbWl0LWdyYXBoLmM6MTk3MgorIzogY29tbWl0LWdyYXBoLmM6MTk4OAogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gcGFyc2UgY29tbWl0ICVzIGZyb20gY29tbWl0LWdyYXBoIgogbXNnc3RyICIiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjE5ODkKKyM6IGNvbW1pdC1ncmFwaC5jOjIwMDYKIG1zZ2lkICJWZXJpZnlpbmcgY29tbWl0cyBpbiBjb21taXQgZ3JhcGgiCiBtc2dzdHIgIiIKIAotIzogY29tbWl0LWdyYXBoLmM6MjAwMgorIzogY29tbWl0LWdyYXBoLmM6MjAyMAogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gcGFyc2UgY29tbWl0ICVzIGZyb20gb2JqZWN0IGRhdGFiYXNlIGZvciBjb21taXQtZ3JhcGgiCiBtc2dzdHIgIiIKIAotIzogY29tbWl0LWdyYXBoLmM6MjAwOQorIzogY29tbWl0LWdyYXBoLmM6MjAyNwogIywgYy1mb3JtYXQKIG1zZ2lkICJyb290IHRyZWUgT0lEIGZvciBjb21taXQgJXMgaW4gY29tbWl0LWdyYXBoIGlzICVzICE9ICVzIgogbXNnc3RyICIiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjIwMTkKKyM6IGNvbW1pdC1ncmFwaC5jOjIwMzcKICMsIGMtZm9ybWF0CiBtc2dpZCAiY29tbWl0LWdyYXBoIHBhcmVudCBsaXN0IGZvciBjb21taXQgJXMgaXMgdG9vIGxvbmciCiBtc2dzdHIgIiIKIAotIzogY29tbWl0LWdyYXBoLmM6MjAyOAorIzogY29tbWl0LWdyYXBoLmM6MjA0NgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb21taXQtZ3JhcGggcGFyZW50IGZvciAlcyBpcyAlcyAhPSAlcyIKIG1zZ3N0ciAiIgogCi0jOiBjb21taXQtZ3JhcGguYzoyMDQxCisjOiBjb21taXQtZ3JhcGguYzoyMDU5CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvbW1pdC1ncmFwaCBwYXJlbnQgbGlzdCBmb3IgY29tbWl0ICVzIHRlcm1pbmF0ZXMgZWFybHkiCiBtc2dzdHIgIiIKIAotIzogY29tbWl0LWdyYXBoLmM6MjA0NgorIzogY29tbWl0LWdyYXBoLmM6MjA2NAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiY29tbWl0LWdyYXBoIGhhcyBnZW5lcmF0aW9uIG51bWJlciB6ZXJvIGZvciBjb21taXQgJXMsIGJ1dCBub24temVybyBlbHNld2hlcmUiCiBtc2dzdHIgIiIKIAotIzogY29tbWl0LWdyYXBoLmM6MjA1MAorIzogY29tbWl0LWdyYXBoLmM6MjA2OAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiY29tbWl0LWdyYXBoIGhhcyBub24temVybyBnZW5lcmF0aW9uIG51bWJlciBmb3IgY29tbWl0ICVzLCBidXQgemVybyBlbHNld2hlcmUiCiBtc2dzdHIgIiIKIAotIzogY29tbWl0LWdyYXBoLmM6MjA2NQorIzogY29tbWl0LWdyYXBoLmM6MjA4MwogIywgYy1mb3JtYXQKIG1zZ2lkICJjb21taXQtZ3JhcGggZ2VuZXJhdGlvbiBmb3IgY29tbWl0ICVzIGlzICV1ICE9ICV1IgogbXNnc3RyICIiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjIwNzEKKyM6IGNvbW1pdC1ncmFwaC5jOjIwODkKICMsIGMtZm9ybWF0CiBtc2dpZCAiY29tbWl0IGRhdGUgZm9yIGNvbW1pdCAlcyBpbiBjb21taXQtZ3JhcGggaXMgJTxQUkl1TUFYPiAhPSAlPFBSSXVNQVg+IgogbXNnc3RyICIiCkBAIC0xNTk3LDcgKzE2MTMsNyBAQAogbXNnaWQgImtleSBkb2VzIG5vdCBjb250YWluIHZhcmlhYmxlIG5hbWU6ICVzIgogbXNnc3RyICIiCiAKLSM6IGNvbmZpZy5jOjQwNiBzZXF1ZW5jZXIuYzoyNDYzCisjOiBjb25maWcuYzo0MDYgc2VxdWVuY2VyLmM6MjQwMQogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIGtleTogJXMiCiBtc2dzdHIgIiIKQEAgLTE3MTksMTQ5ICsxNzM1LDE0NCBAQAogbXNnaWQgImludmFsaWQgbW9kZSBmb3Igb2JqZWN0IGNyZWF0aW9uOiAlcyIKIG1zZ3N0ciAiIgogCi0jOiBjb25maWcuYzoxNDMwCisjOiBjb25maWcuYzoxNDI1CiAjLCBjLWZvcm1hdAogbXNnaWQgIm1hbGZvcm1lZCB2YWx1ZSBmb3IgJXMiCiBtc2dzdHIgIiIKIAotIzogY29uZmlnLmM6MTQ1NgorIzogY29uZmlnLmM6MTQ1MQogIywgYy1mb3JtYXQKIG1zZ2lkICJtYWxmb3JtZWQgdmFsdWUgZm9yICVzOiAlcyIKIG1zZ3N0ciAiIgogCi0jOiBjb25maWcuYzoxNDU3CisjOiBjb25maWcuYzoxNDUyCiBtc2dpZCAibXVzdCBiZSBvbmUgb2Ygbm90aGluZywgbWF0Y2hpbmcsIHNpbXBsZSwgdXBzdHJlYW0gb3IgY3VycmVudCIKIG1zZ3N0ciAiIgogCi0jOiBjb25maWcuYzoxNTE4IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzQxMAorIzogY29uZmlnLmM6MTUxMyBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzOTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiYmFkIHBhY2sgY29tcHJlc3Npb24gbGV2ZWwgJWQiCiBtc2dzdHIgIiIKIAotIzogY29uZmlnLmM6MTYzOQorIzogY29uZmlnLmM6MTYzNAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gbG9hZCBjb25maWcgYmxvYiBvYmplY3QgJyVzJyIKIG1zZ3N0ciAiIgogCi0jOiBjb25maWcuYzoxNjQyCisjOiBjb25maWcuYzoxNjM3CiAjLCBjLWZvcm1hdAogbXNnaWQgInJlZmVyZW5jZSAnJXMnIGRvZXMgbm90IHBvaW50IHRvIGEgYmxvYiIKIG1zZ3N0ciAiIgogCi0jOiBjb25maWcuYzoxNjU5CisjOiBjb25maWcuYzoxNjU0CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byByZXNvbHZlIGNvbmZpZyBibG9iICclcyciCiBtc2dzdHIgIiIKIAotIzogY29uZmlnLmM6MTY4OQorIzogY29uZmlnLmM6MTY4NAogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gcGFyc2UgJXMiCiBtc2dzdHIgIiIKIAotIzogY29uZmlnLmM6MTc0NQorIzogY29uZmlnLmM6MTc0MAogbXNnaWQgInVuYWJsZSB0byBwYXJzZSBjb21tYW5kLWxpbmUgY29uZmlnIgogbXNnc3RyICIiCiAKLSM6IGNvbmZpZy5jOjIwOTQKKyM6IGNvbmZpZy5jOjIwOTEKIG1zZ2lkICJ1bmtub3duIGVycm9yIG9jY3VycmVkIHdoaWxlIHJlYWRpbmcgdGhlIGNvbmZpZ3VyYXRpb24gZmlsZXMiCiBtc2dzdHIgIiIKIAotIzogY29uZmlnLmM6MjI2NAorIzogY29uZmlnLmM6MjI2MQogIywgYy1mb3JtYXQKIG1zZ2lkICJJbnZhbGlkICVzOiAnJXMnIgogbXNnc3RyICIiCiAKLSM6IGNvbmZpZy5jOjIzMDcKLSMsIGMtZm9ybWF0Ci1tc2dpZCAidW5rbm93biBjb3JlLnVudHJhY2tlZENhY2hlIHZhbHVlICclcyc7IHVzaW5nICdrZWVwJyBkZWZhdWx0IHZhbHVlIgotbXNnc3RyICIiCi0KLSM6IGNvbmZpZy5jOjIzMzMKKyM6IGNvbmZpZy5jOjIzMDYKICMsIGMtZm9ybWF0CiBtc2dpZCAic3BsaXRJbmRleC5tYXhQZXJjZW50Q2hhbmdlIHZhbHVlICclZCcgc2hvdWxkIGJlIGJldHdlZW4gMCBhbmQgMTAwIgogbXNnc3RyICIiCiAKLSM6IGNvbmZpZy5jOjIzNzkKKyM6IGNvbmZpZy5jOjIzNTIKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHBhcnNlICclcycgZnJvbSBjb21tYW5kLWxpbmUgY29uZmlnIgogbXNnc3RyICIiCiAKLSM6IGNvbmZpZy5jOjIzODEKKyM6IGNvbmZpZy5jOjIzNTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiYmFkIGNvbmZpZyB2YXJpYWJsZSAnJXMnIGluIGZpbGUgJyVzJyBhdCBsaW5lICVkIgogbXNnc3RyICIiCiAKLSM6IGNvbmZpZy5jOjI0NjIKKyM6IGNvbmZpZy5jOjI0MzUKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBzZWN0aW9uIG5hbWUgJyVzJyIKIG1zZ3N0ciAiIgogCi0jOiBjb25maWcuYzoyNDk0CisjOiBjb25maWcuYzoyNDY3CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIGhhcyBtdWx0aXBsZSB2YWx1ZXMiCiBtc2dzdHIgIiIKIAotIzogY29uZmlnLmM6MjUyMworIzogY29uZmlnLmM6MjQ5NgogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gd3JpdGUgbmV3IGNvbmZpZ3VyYXRpb24gZmlsZSAlcyIKIG1zZ3N0ciAiIgogCi0jOiBjb25maWcuYzoyNzc1IGNvbmZpZy5jOjMwOTkKKyM6IGNvbmZpZy5jOjI3NDggY29uZmlnLmM6MzA3MgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgbG9jayBjb25maWcgZmlsZSAlcyIKIG1zZ3N0ciAiIgogCi0jOiBjb25maWcuYzoyNzg2CisjOiBjb25maWcuYzoyNzU5CiAjLCBjLWZvcm1hdAogbXNnaWQgIm9wZW5pbmcgJXMiCiBtc2dzdHIgIiIKIAotIzogY29uZmlnLmM6MjgyMSBidWlsdGluL2NvbmZpZy5jOjMyOAorIzogY29uZmlnLmM6Mjc5NCBidWlsdGluL2NvbmZpZy5jOjMyOAogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIHBhdHRlcm46ICVzIgogbXNnc3RyICIiCiAKLSM6IGNvbmZpZy5jOjI4NDYKKyM6IGNvbmZpZy5jOjI4MTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBjb25maWcgZmlsZSAlcyIKIG1zZ3N0ciAiIgogCi0jOiBjb25maWcuYzoyODU5IGNvbmZpZy5jOjMxMTIKKyM6IGNvbmZpZy5jOjI4MzIgY29uZmlnLmM6MzA4NQogIywgYy1mb3JtYXQKIG1zZ2lkICJmc3RhdCBvbiAlcyBmYWlsZWQiCiBtc2dzdHIgIiIKIAotIzogY29uZmlnLmM6Mjg3MAorIzogY29uZmlnLmM6Mjg0MwogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gbW1hcCAnJXMnIgogbXNnc3RyICIiCiAKLSM6IGNvbmZpZy5jOjI4NzkgY29uZmlnLmM6MzExNworIzogY29uZmlnLmM6Mjg1MiBjb25maWcuYzozMDkwCiAjLCBjLWZvcm1hdAogbXNnaWQgImNobW9kIG9uICVzIGZhaWxlZCIKIG1zZ3N0ciAiIgogCi0jOiBjb25maWcuYzoyOTY0IGNvbmZpZy5jOjMyMTQKKyM6IGNvbmZpZy5jOjI5MzcgY29uZmlnLmM6MzE4NwogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3Qgd3JpdGUgY29uZmlnIGZpbGUgJXMiCiBtc2dzdHIgIiIKIAotIzogY29uZmlnLmM6Mjk5OAorIzogY29uZmlnLmM6Mjk3MQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3Qgc2V0ICclcycgdG8gJyVzJyIKIG1zZ3N0ciAiIgogCi0jOiBjb25maWcuYzozMDAwIGJ1aWx0aW4vcmVtb3RlLmM6NzgyCisjOiBjb25maWcuYzoyOTczIGJ1aWx0aW4vcmVtb3RlLmM6NzgyCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCB1bnNldCAnJXMnIgogbXNnc3RyICIiCiAKLSM6IGNvbmZpZy5jOjMwOTAKKyM6IGNvbmZpZy5jOjMwNjMKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBzZWN0aW9uIG5hbWU6ICVzIgogbXNnc3RyICIiCiAKLSM6IGNvbmZpZy5jOjMyNTcKKyM6IGNvbmZpZy5jOjMyMzAKICMsIGMtZm9ybWF0CiBtc2dpZCAibWlzc2luZyB2YWx1ZSBmb3IgJyVzJyIKIG1zZ3N0ciAiIgpAQCAtMTk3Nyw3ICsxOTg4LDcgQEAKIG1zZ2lkICJ1bmtub3duIHBvcnQgJXMiCiBtc2dzdHIgIiIKIAotIzogY29ubmVjdC5jOjg0NSBjb25uZWN0LmM6MTE3MQorIzogY29ubmVjdC5jOjg0NSBjb25uZWN0LmM6MTE3NQogIywgYy1mb3JtYXQKIG1zZ2lkICJzdHJhbmdlIGhvc3RuYW1lICclcycgYmxvY2tlZCIKIG1zZ3N0ciAiIgpAQCAtMTk5MiwyMTEgKzIwMDMsMjExIEBACiBtc2dpZCAiY2Fubm90IHN0YXJ0IHByb3h5ICVzIgogbXNnc3RyICIiCiAKLSM6IGNvbm5lY3QuYzo5MjQKKyM6IGNvbm5lY3QuYzo5MjgKIG1zZ2lkICJubyBwYXRoIHNwZWNpZmllZDsgc2VlICdnaXQgaGVscCBwdWxsJyBmb3IgdmFsaWQgdXJsIHN5bnRheCIKIG1zZ3N0ciAiIgogCi0jOiBjb25uZWN0LmM6MTExOQorIzogY29ubmVjdC5jOjExMjMKIG1zZ2lkICJzc2ggdmFyaWFudCAnc2ltcGxlJyBkb2VzIG5vdCBzdXBwb3J0IC00IgogbXNnc3RyICIiCiAKLSM6IGNvbm5lY3QuYzoxMTMxCisjOiBjb25uZWN0LmM6MTEzNQogbXNnaWQgInNzaCB2YXJpYW50ICdzaW1wbGUnIGRvZXMgbm90IHN1cHBvcnQgLTYiCiBtc2dzdHIgIiIKIAotIzogY29ubmVjdC5jOjExNDgKKyM6IGNvbm5lY3QuYzoxMTUyCiBtc2dpZCAic3NoIHZhcmlhbnQgJ3NpbXBsZScgZG9lcyBub3Qgc3VwcG9ydCBzZXR0aW5nIHBvcnQiCiBtc2dzdHIgIiIKIAotIzogY29ubmVjdC5jOjEyNjAKKyM6IGNvbm5lY3QuYzoxMjY0CiAjLCBjLWZvcm1hdAogbXNnaWQgInN0cmFuZ2UgcGF0aG5hbWUgJyVzJyBibG9ja2VkIgogbXNnc3RyICIiCiAKLSM6IGNvbm5lY3QuYzoxMzA3CisjOiBjb25uZWN0LmM6MTMxMQogbXNnaWQgInVuYWJsZSB0byBmb3JrIgogbXNnc3RyICIiCiAKLSM6IGNvbm5lY3RlZC5jOjg2IGJ1aWx0aW4vZnNjay5jOjIyMSBidWlsdGluL3BydW5lLmM6NDMKKyM6IGNvbm5lY3RlZC5jOjg4IGJ1aWx0aW4vZnNjay5jOjIyMSBidWlsdGluL3BydW5lLmM6NDMKIG1zZ2lkICJDaGVja2luZyBjb25uZWN0aXZpdHkiCiBtc2dzdHIgIiIKIAotIzogY29ubmVjdGVkLmM6OTgKKyM6IGNvbm5lY3RlZC5jOjEwMAogbXNnaWQgIkNvdWxkIG5vdCBydW4gJ2dpdCByZXYtbGlzdCciCiBtc2dzdHIgIiIKIAotIzogY29ubmVjdGVkLmM6MTE4CisjOiBjb25uZWN0ZWQuYzoxMjAKIG1zZ2lkICJmYWlsZWQgd3JpdGUgdG8gcmV2LWxpc3QiCiBtc2dzdHIgIiIKIAotIzogY29ubmVjdGVkLmM6MTI1CisjOiBjb25uZWN0ZWQuYzoxMjcKIG1zZ2lkICJmYWlsZWQgdG8gY2xvc2UgcmV2LWxpc3QncyBzdGRpbiIKIG1zZ3N0ciAiIgogCi0jOiBjb252ZXJ0LmM6MTkzCisjOiBjb252ZXJ0LmM6MTk0CiAjLCBjLWZvcm1hdAogbXNnaWQgImlsbGVnYWwgY3JsZl9hY3Rpb24gJWQiCiBtc2dzdHIgIiIKIAotIzogY29udmVydC5jOjIwNgorIzogY29udmVydC5jOjIwNwogIywgYy1mb3JtYXQKIG1zZ2lkICJDUkxGIHdvdWxkIGJlIHJlcGxhY2VkIGJ5IExGIGluICVzIgogbXNnc3RyICIiCiAKLSM6IGNvbnZlcnQuYzoyMDgKKyM6IGNvbnZlcnQuYzoyMDkKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkNSTEYgd2lsbCBiZSByZXBsYWNlZCBieSBMRiBpbiAlcy5cbiIKICJUaGUgZmlsZSB3aWxsIGhhdmUgaXRzIG9yaWdpbmFsIGxpbmUgZW5kaW5ncyBpbiB5b3VyIHdvcmtpbmcgZGlyZWN0b3J5IgogbXNnc3RyICIiCiAKLSM6IGNvbnZlcnQuYzoyMTYKKyM6IGNvbnZlcnQuYzoyMTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiTEYgd291bGQgYmUgcmVwbGFjZWQgYnkgQ1JMRiBpbiAlcyIKIG1zZ3N0ciAiIgogCi0jOiBjb252ZXJ0LmM6MjE4CisjOiBjb252ZXJ0LmM6MjE5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJMRiB3aWxsIGJlIHJlcGxhY2VkIGJ5IENSTEYgaW4gJXMuXG4iCiAiVGhlIGZpbGUgd2lsbCBoYXZlIGl0cyBvcmlnaW5hbCBsaW5lIGVuZGluZ3MgaW4geW91ciB3b3JraW5nIGRpcmVjdG9yeSIKIG1zZ3N0ciAiIgogCi0jOiBjb252ZXJ0LmM6Mjc5CisjOiBjb252ZXJ0LmM6MjgwCiAjLCBjLWZvcm1hdAogbXNnaWQgIkJPTSBpcyBwcm9oaWJpdGVkIGluICclcycgaWYgZW5jb2RlZCBhcyAlcyIKIG1zZ3N0ciAiIgogCi0jOiBjb252ZXJ0LmM6Mjg2CisjOiBjb252ZXJ0LmM6Mjg3CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgZmlsZSAnJXMnIGNvbnRhaW5zIGEgYnl0ZSBvcmRlciBtYXJrIChCT00pLiBQbGVhc2UgdXNlIFVURi0lcyBhcyB3b3JraW5nLSIKICJ0cmVlLWVuY29kaW5nLiIKIG1zZ3N0ciAiIgogCi0jOiBjb252ZXJ0LmM6MzA0CisjOiBjb252ZXJ0LmM6MzA1CiAjLCBjLWZvcm1hdAogbXNnaWQgIkJPTSBpcyByZXF1aXJlZCBpbiAnJXMnIGlmIGVuY29kZWQgYXMgJXMiCiBtc2dzdHIgIiIKIAotIzogY29udmVydC5jOjMwNgorIzogY29udmVydC5jOjMwNwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiVGhlIGZpbGUgJyVzJyBpcyBtaXNzaW5nIGEgYnl0ZSBvcmRlciBtYXJrIChCT00pLiBQbGVhc2UgdXNlIFVURi0lc0JFIG9yIFVURi0iCiAiJXNMRSAoZGVwZW5kaW5nIG9uIHRoZSBieXRlIG9yZGVyKSBhcyB3b3JraW5nLXRyZWUtZW5jb2RpbmcuIgogbXNnc3RyICIiCiAKLSM6IGNvbnZlcnQuYzo0MjQgY29udmVydC5jOjQ5NQorIzogY29udmVydC5jOjQyNSBjb252ZXJ0LmM6NDk2CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBlbmNvZGUgJyVzJyBmcm9tICVzIHRvICVzIgogbXNnc3RyICIiCiAKLSM6IGNvbnZlcnQuYzo0NjcKKyM6IGNvbnZlcnQuYzo0NjgKICMsIGMtZm9ybWF0CiBtc2dpZCAiZW5jb2RpbmcgJyVzJyBmcm9tICVzIHRvICVzIGFuZCBiYWNrIGlzIG5vdCB0aGUgc2FtZSIKIG1zZ3N0ciAiIgogCi0jOiBjb252ZXJ0LmM6NjczCisjOiBjb252ZXJ0LmM6Njc0CiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCBmb3JrIHRvIHJ1biBleHRlcm5hbCBmaWx0ZXIgJyVzJyIKIG1zZ3N0ciAiIgogCi0jOiBjb252ZXJ0LmM6NjkzCisjOiBjb252ZXJ0LmM6Njk0CiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCBmZWVkIHRoZSBpbnB1dCB0byBleHRlcm5hbCBmaWx0ZXIgJyVzJyIKIG1zZ3N0ciAiIgogCi0jOiBjb252ZXJ0LmM6NzAwCisjOiBjb252ZXJ0LmM6NzAxCiAjLCBjLWZvcm1hdAogbXNnaWQgImV4dGVybmFsIGZpbHRlciAnJXMnIGZhaWxlZCAlZCIKIG1zZ3N0ciAiIgogCi0jOiBjb252ZXJ0LmM6NzM1IGNvbnZlcnQuYzo3MzgKKyM6IGNvbnZlcnQuYzo3MzYgY29udmVydC5jOjczOQogIywgYy1mb3JtYXQKIG1zZ2lkICJyZWFkIGZyb20gZXh0ZXJuYWwgZmlsdGVyICclcycgZmFpbGVkIgogbXNnc3RyICIiCiAKLSM6IGNvbnZlcnQuYzo3NDEgY29udmVydC5jOjc5NgorIzogY29udmVydC5jOjc0MiBjb252ZXJ0LmM6Nzk3CiAjLCBjLWZvcm1hdAogbXNnaWQgImV4dGVybmFsIGZpbHRlciAnJXMnIGZhaWxlZCIKIG1zZ3N0ciAiIgogCi0jOiBjb252ZXJ0LmM6ODQ0CisjOiBjb252ZXJ0LmM6ODQ1CiBtc2dpZCAidW5leHBlY3RlZCBmaWx0ZXIgdHlwZSIKIG1zZ3N0ciAiIgogCi0jOiBjb252ZXJ0LmM6ODU1CisjOiBjb252ZXJ0LmM6ODU2CiBtc2dpZCAicGF0aCBuYW1lIHRvbyBsb25nIGZvciBleHRlcm5hbCBmaWx0ZXIiCiBtc2dzdHIgIiIKIAotIzogY29udmVydC5jOjkyOQorIzogY29udmVydC5jOjkzMAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiZXh0ZXJuYWwgZmlsdGVyICclcycgaXMgbm90IGF2YWlsYWJsZSBhbnltb3JlIGFsdGhvdWdoIG5vdCBhbGwgcGF0aHMgaGF2ZSAiCiAiYmVlbiBmaWx0ZXJlZCIKIG1zZ3N0ciAiIgogCi0jOiBjb252ZXJ0LmM6MTIyOAorIzogY29udmVydC5jOjEyMjkKIG1zZ2lkICJ0cnVlL2ZhbHNlIGFyZSBubyB2YWxpZCB3b3JraW5nLXRyZWUtZW5jb2RpbmdzIgogbXNnc3RyICIiCiAKLSM6IGNvbnZlcnQuYzoxMzk4IGNvbnZlcnQuYzoxNDMyCisjOiBjb252ZXJ0LmM6MTQxNyBjb252ZXJ0LmM6MTQ1MQogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogY2xlYW4gZmlsdGVyICclcycgZmFpbGVkIgogbXNnc3RyICIiCiAKLSM6IGNvbnZlcnQuYzoxNDc2CisjOiBjb252ZXJ0LmM6MTQ5NQogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogc211ZGdlIGZpbHRlciAlcyBmYWlsZWQiCiBtc2dzdHIgIiIKIAotIzogZGF0ZS5jOjEzNworIzogZGF0ZS5jOjEzOAogbXNnaWQgImluIHRoZSBmdXR1cmUiCiBtc2dzdHIgIiIKIAotIzogZGF0ZS5jOjE0MworIzogZGF0ZS5jOjE0NAogIywgYy1mb3JtYXQKIG1zZ2lkICIlPFBSSXVNQVg+IHNlY29uZCBhZ28iCiBtc2dpZF9wbHVyYWwgIiU8UFJJdU1BWD4gc2Vjb25kcyBhZ28iCiBtc2dzdHJbMF0gIiIKIG1zZ3N0clsxXSAiIgogCi0jOiBkYXRlLmM6MTUwCisjOiBkYXRlLmM6MTUxCiAjLCBjLWZvcm1hdAogbXNnaWQgIiU8UFJJdU1BWD4gbWludXRlIGFnbyIKIG1zZ2lkX3BsdXJhbCAiJTxQUkl1TUFYPiBtaW51dGVzIGFnbyIKIG1zZ3N0clswXSAiIgogbXNnc3RyWzFdICIiCiAKLSM6IGRhdGUuYzoxNTcKKyM6IGRhdGUuYzoxNTgKICMsIGMtZm9ybWF0CiBtc2dpZCAiJTxQUkl1TUFYPiBob3VyIGFnbyIKIG1zZ2lkX3BsdXJhbCAiJTxQUkl1TUFYPiBob3VycyBhZ28iCiBtc2dzdHJbMF0gIiIKIG1zZ3N0clsxXSAiIgogCi0jOiBkYXRlLmM6MTY0CisjOiBkYXRlLmM6MTY1CiAjLCBjLWZvcm1hdAogbXNnaWQgIiU8UFJJdU1BWD4gZGF5IGFnbyIKIG1zZ2lkX3BsdXJhbCAiJTxQUkl1TUFYPiBkYXlzIGFnbyIKIG1zZ3N0clswXSAiIgogbXNnc3RyWzFdICIiCiAKLSM6IGRhdGUuYzoxNzAKKyM6IGRhdGUuYzoxNzEKICMsIGMtZm9ybWF0CiBtc2dpZCAiJTxQUkl1TUFYPiB3ZWVrIGFnbyIKIG1zZ2lkX3BsdXJhbCAiJTxQUkl1TUFYPiB3ZWVrcyBhZ28iCiBtc2dzdHJbMF0gIiIKIG1zZ3N0clsxXSAiIgogCi0jOiBkYXRlLmM6MTc3CisjOiBkYXRlLmM6MTc4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiU8UFJJdU1BWD4gbW9udGggYWdvIgogbXNnaWRfcGx1cmFsICIlPFBSSXVNQVg+IG1vbnRocyBhZ28iCiBtc2dzdHJbMF0gIiIKIG1zZ3N0clsxXSAiIgogCi0jOiBkYXRlLmM6MTg4CisjOiBkYXRlLmM6MTg5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiU8UFJJdU1BWD4geWVhciIKIG1zZ2lkX3BsdXJhbCAiJTxQUkl1TUFYPiB5ZWFycyIKQEAgLTIyMDQsMTQgKzIyMTUsMTQgQEAKIG1zZ3N0clsxXSAiIgogCiAjLiBUUkFOU0xBVE9SUzogIiVzIiBpcyAiPG4+IHllYXJzIgotIzogZGF0ZS5jOjE5MQorIzogZGF0ZS5jOjE5MgogIywgYy1mb3JtYXQKIG1zZ2lkICIlcywgJTxQUkl1TUFYPiBtb250aCBhZ28iCiBtc2dpZF9wbHVyYWwgIiVzLCAlPFBSSXVNQVg+IG1vbnRocyBhZ28iCiBtc2dzdHJbMF0gIiIKIG1zZ3N0clsxXSAiIgogCi0jOiBkYXRlLmM6MTk2IGRhdGUuYzoyMDEKKyM6IGRhdGUuYzoxOTcgZGF0ZS5jOjIwMgogIywgYy1mb3JtYXQKIG1zZ2lkICIlPFBSSXVNQVg+IHllYXIgYWdvIgogbXNnaWRfcGx1cmFsICIlPFBSSXVNQVg+IHllYXJzIGFnbyIKQEAgLTIyNDcsNyArMjI1OCw3IEBACiBtc2dpZCAiZmFpbGVkIHRvIHJlYWQgb3JkZXJmaWxlICclcyciCiBtc2dzdHIgIiIKIAotIzogZGlmZmNvcmUtcmVuYW1lLmM6NTQ0CisjOiBkaWZmY29yZS1yZW5hbWUuYzo1NDMKIG1zZ2lkICJQZXJmb3JtaW5nIGluZXhhY3QgcmVuYW1lIGRldGVjdGlvbiIKIG1zZ3N0ciAiIgogCkBAIC0yMzAyLDU2MiArMjMxMyw1NjIgQEAKICIlcyIKIG1zZ3N0ciAiIgogCi0jOiBkaWZmLmM6NDIxNQorIzogZGlmZi5jOjQyMTgKICMsIGMtZm9ybWF0CiBtc2dpZCAiZXh0ZXJuYWwgZGlmZiBkaWVkLCBzdG9wcGluZyBhdCAlcyIKIG1zZ3N0ciAiIgogCi0jOiBkaWZmLmM6NDU2MAorIzogZGlmZi5jOjQ1NjMKIG1zZ2lkICItLW5hbWUtb25seSwgLS1uYW1lLXN0YXR1cywgLS1jaGVjayBhbmQgLXMgYXJlIG11dHVhbGx5IGV4Y2x1c2l2ZSIKIG1zZ3N0ciAiIgogCi0jOiBkaWZmLmM6NDU2MworIzogZGlmZi5jOjQ1NjYKIG1zZ2lkICItRywgLVMgYW5kIC0tZmluZC1vYmplY3QgYXJlIG11dHVhbGx5IGV4Y2x1c2l2ZSIKIG1zZ3N0ciAiIgogCi0jOiBkaWZmLmM6NDY0MQorIzogZGlmZi5jOjQ2NDQKIG1zZ2lkICItLWZvbGxvdyByZXF1aXJlcyBleGFjdGx5IG9uZSBwYXRoc3BlYyIKIG1zZ3N0ciAiIgogCi0jOiBkaWZmLmM6NDY4OQorIzogZGlmZi5jOjQ2OTIKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCAtLXN0YXQgdmFsdWU6ICVzIgogbXNnc3RyICIiCiAKLSM6IGRpZmYuYzo0Njk0IGRpZmYuYzo0Njk5IGRpZmYuYzo0NzA0IGRpZmYuYzo0NzA5IGRpZmYuYzo1MjIyCisjOiBkaWZmLmM6NDY5NyBkaWZmLmM6NDcwMiBkaWZmLmM6NDcwNyBkaWZmLmM6NDcxMiBkaWZmLmM6NTIyNQogIzogcGFyc2Utb3B0aW9ucy5jOjE5OSBwYXJzZS1vcHRpb25zLmM6MjAzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIGV4cGVjdHMgYSBudW1lcmljYWwgdmFsdWUiCiBtc2dzdHIgIiIKIAotIzogZGlmZi5jOjQ3MjYKKyM6IGRpZmYuYzo0NzI5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJGYWlsZWQgdG8gcGFyc2UgLS1kaXJzdGF0Ly1YIG9wdGlvbiBwYXJhbWV0ZXI6XG4iCiAiJXMiCiBtc2dzdHIgIiIKIAotIzogZGlmZi5jOjQ4MTEKKyM6IGRpZmYuYzo0ODE0CiAjLCBjLWZvcm1hdAogbXNnaWQgInVua25vd24gY2hhbmdlIGNsYXNzICclYycgaW4gLS1kaWZmLWZpbHRlcj0lcyIKIG1zZ3N0ciAiIgogCi0jOiBkaWZmLmM6NDgzNQorIzogZGlmZi5jOjQ4MzgKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5rbm93biB2YWx1ZSBhZnRlciB3cy1lcnJvci1oaWdobGlnaHQ9JS4qcyIKIG1zZ3N0ciAiIgogCi0jOiBkaWZmLmM6NDg0OQorIzogZGlmZi5jOjQ4NTIKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHJlc29sdmUgJyVzJyIKIG1zZ3N0ciAiIgogCi0jOiBkaWZmLmM6NDg5OSBkaWZmLmM6NDkwNQorIzogZGlmZi5jOjQ5MDIgZGlmZi5jOjQ5MDgKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgZXhwZWN0cyA8bj4vPG0+IGZvcm0iCiBtc2dzdHIgIiIKIAotIzogZGlmZi5jOjQ5MTcKKyM6IGRpZmYuYzo0OTIwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIGV4cGVjdHMgYSBjaGFyYWN0ZXIsIGdvdCAnJXMnIgogbXNnc3RyICIiCiAKLSM6IGRpZmYuYzo0OTM4CisjOiBkaWZmLmM6NDk0MQogIywgYy1mb3JtYXQKIG1zZ2lkICJiYWQgLS1jb2xvci1tb3ZlZCBhcmd1bWVudDogJXMiCiBtc2dzdHIgIiIKIAotIzogZGlmZi5jOjQ5NTcKKyM6IGRpZmYuYzo0OTYwCiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgbW9kZSAnJXMnIGluIC0tY29sb3ItbW92ZWQtd3MiCiBtc2dzdHIgIiIKIAotIzogZGlmZi5jOjQ5OTcKKyM6IGRpZmYuYzo1MDAwCiBtc2dpZCAiIgogIm9wdGlvbiBkaWZmLWFsZ29yaXRobSBhY2NlcHRzIFwibXllcnNcIiwgXCJtaW5pbWFsXCIsIFwicGF0aWVuY2VcIiBhbmQgIgogIlwiaGlzdG9ncmFtXCIiCiBtc2dzdHIgIiIKIAotIzogZGlmZi5jOjUwMzMgZGlmZi5jOjUwNTMKKyM6IGRpZmYuYzo1MDM2IGRpZmYuYzo1MDU2CiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgYXJndW1lbnQgdG8gJXMiCiBtc2dzdHIgIiIKIAotIzogZGlmZi5jOjUxOTEKKyM6IGRpZmYuYzo1MTk0CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBwYXJzZSAtLXN1Ym1vZHVsZSBvcHRpb24gcGFyYW1ldGVyOiAnJXMnIgogbXNnc3RyICIiCiAKLSM6IGRpZmYuYzo1MjQ3CisjOiBkaWZmLmM6NTI1MAogIywgYy1mb3JtYXQKIG1zZ2lkICJiYWQgLS13b3JkLWRpZmYgYXJndW1lbnQ6ICVzIgogbXNnc3RyICIiCiAKLSM6IGRpZmYuYzo1MjcwCisjOiBkaWZmLmM6NTI3MwogbXNnaWQgIkRpZmYgb3V0cHV0IGZvcm1hdCBvcHRpb25zIgogbXNnc3RyICIiCiAKLSM6IGRpZmYuYzo1MjcyIGRpZmYuYzo1Mjc4CisjOiBkaWZmLmM6NTI3NSBkaWZmLmM6NTI4MQogbXNnaWQgImdlbmVyYXRlIHBhdGNoIgogbXNnc3RyICIiCiAKLSM6IGRpZmYuYzo1Mjc1IGJ1aWx0aW4vbG9nLmM6MTcyCisjOiBkaWZmLmM6NTI3OCBidWlsdGluL2xvZy5jOjE3MgogbXNnaWQgInN1cHByZXNzIGRpZmYgb3V0cHV0IgogbXNnc3RyICIiCiAKLSM6IGRpZmYuYzo1MjgwIGRpZmYuYzo1Mzk0IGRpZmYuYzo1NDAxCisjOiBkaWZmLmM6NTI4MyBkaWZmLmM6NTM5NyBkaWZmLmM6NTQwNAogbXNnaWQgIjxuPiIKIG1zZ3N0ciAiIgogCi0jOiBkaWZmLmM6NTI4MSBkaWZmLmM6NTI4NAorIzogZGlmZi5jOjUyODQgZGlmZi5jOjUyODcKIG1zZ2lkICJnZW5lcmF0ZSBkaWZmcyB3aXRoIDxuPiBsaW5lcyBjb250ZXh0IgogbXNnc3RyICIiCiAKLSM6IGRpZmYuYzo1Mjg2CisjOiBkaWZmLmM6NTI4OQogbXNnaWQgImdlbmVyYXRlIHRoZSBkaWZmIGluIHJhdyBmb3JtYXQiCiBtc2dzdHIgIiIKIAotIzogZGlmZi5jOjUyODkKKyM6IGRpZmYuYzo1MjkyCiBtc2dpZCAic3lub255bSBmb3IgJy1wIC0tcmF3JyIKIG1zZ3N0ciAiIgogCi0jOiBkaWZmLmM6NTI5MworIzogZGlmZi5jOjUyOTYKIG1zZ2lkICJzeW5vbnltIGZvciAnLXAgLS1zdGF0JyIKIG1zZ3N0ciAiIgogCi0jOiBkaWZmLmM6NTI5NworIzogZGlmZi5jOjUzMDAKIG1zZ2lkICJtYWNoaW5lIGZyaWVuZGx5IC0tc3RhdCIKIG1zZ3N0ciAiIgogCi0jOiBkaWZmLmM6NTMwMAorIzogZGlmZi5jOjUzMDMKIG1zZ2lkICJvdXRwdXQgb25seSB0aGUgbGFzdCBsaW5lIG9mIC0tc3RhdCIKIG1zZ3N0ciAiIgogCi0jOiBkaWZmLmM6NTMwMiBkaWZmLmM6NTMxMAorIzogZGlmZi5jOjUzMDUgZGlmZi5jOjUzMTMKIG1zZ2lkICI8cGFyYW0xLHBhcmFtMj4uLi4iCiBtc2dzdHIgIiIKIAotIzogZGlmZi5jOjUzMDMKKyM6IGRpZmYuYzo1MzA2CiBtc2dpZCAiIgogIm91dHB1dCB0aGUgZGlzdHJpYnV0aW9uIG9mIHJlbGF0aXZlIGFtb3VudCBvZiBjaGFuZ2VzIGZvciBlYWNoIHN1Yi1kaXJlY3RvcnkiCiBtc2dzdHIgIiIKIAotIzogZGlmZi5jOjUzMDcKKyM6IGRpZmYuYzo1MzEwCiBtc2dpZCAic3lub255bSBmb3IgLS1kaXJzdGF0PWN1bXVsYXRpdmUiCiBtc2dzdHIgIiIKIAotIzogZGlmZi5jOjUzMTEKKyM6IGRpZmYuYzo1MzE0CiBtc2dpZCAic3lub255bSBmb3IgLS1kaXJzdGF0PWZpbGVzLHBhcmFtMSxwYXJhbTIuLi4iCiBtc2dzdHIgIiIKIAotIzogZGlmZi5jOjUzMTUKKyM6IGRpZmYuYzo1MzE4CiBtc2dpZCAid2FybiBpZiBjaGFuZ2VzIGludHJvZHVjZSBjb25mbGljdCBtYXJrZXJzIG9yIHdoaXRlc3BhY2UgZXJyb3JzIgogbXNnc3RyICIiCiAKLSM6IGRpZmYuYzo1MzE4CisjOiBkaWZmLmM6NTMyMQogbXNnaWQgImNvbmRlbnNlZCBzdW1tYXJ5IHN1Y2ggYXMgY3JlYXRpb25zLCByZW5hbWVzIGFuZCBtb2RlIGNoYW5nZXMiCiBtc2dzdHIgIiIKIAotIzogZGlmZi5jOjUzMjEKKyM6IGRpZmYuYzo1MzI0CiBtc2dpZCAic2hvdyBvbmx5IG5hbWVzIG9mIGNoYW5nZWQgZmlsZXMiCiBtc2dzdHIgIiIKIAotIzogZGlmZi5jOjUzMjQKKyM6IGRpZmYuYzo1MzI3CiBtc2dpZCAic2hvdyBvbmx5IG5hbWVzIGFuZCBzdGF0dXMgb2YgY2hhbmdlZCBmaWxlcyIKIG1zZ3N0ciAiIgogCi0jOiBkaWZmLmM6NTMyNgorIzogZGlmZi5jOjUzMjkKIG1zZ2lkICI8d2lkdGg+Wyw8bmFtZS13aWR0aD5bLDxjb3VudD5dXSIKIG1zZ3N0ciAiIgogCi0jOiBkaWZmLmM6NTMyNworIzogZGlmZi5jOjUzMzAKIG1zZ2lkICJnZW5lcmF0ZSBkaWZmc3RhdCIKIG1zZ3N0ciAiIgogCi0jOiBkaWZmLmM6NTMyOSBkaWZmLmM6NTMzMiBkaWZmLmM6NTMzNQorIzogZGlmZi5jOjUzMzIgZGlmZi5jOjUzMzUgZGlmZi5jOjUzMzgKIG1zZ2lkICI8d2lkdGg+IgogbXNnc3RyICIiCiAKLSM6IGRpZmYuYzo1MzMwCisjOiBkaWZmLmM6NTMzMwogbXNnaWQgImdlbmVyYXRlIGRpZmZzdGF0IHdpdGggYSBnaXZlbiB3aWR0aCIKIG1zZ3N0ciAiIgogCi0jOiBkaWZmLmM6NTMzMworIzogZGlmZi5jOjUzMzYKIG1zZ2lkICJnZW5lcmF0ZSBkaWZmc3RhdCB3aXRoIGEgZ2l2ZW4gbmFtZSB3aWR0aCIKIG1zZ3N0ciAiIgogCi0jOiBkaWZmLmM6NTMzNgorIzogZGlmZi5jOjUzMzkKIG1zZ2lkICJnZW5lcmF0ZSBkaWZmc3RhdCB3aXRoIGEgZ2l2ZW4gZ3JhcGggd2lkdGgiCiBtc2dzdHIgIiIKIAotIzogZGlmZi5jOjUzMzgKKyM6IGRpZmYuYzo1MzQxCiBtc2dpZCAiPGNvdW50PiIKIG1zZ3N0ciAiIgogCi0jOiBkaWZmLmM6NTMzOQorIzogZGlmZi5jOjUzNDIKIG1zZ2lkICJnZW5lcmF0ZSBkaWZmc3RhdCB3aXRoIGxpbWl0ZWQgbGluZXMiCiBtc2dzdHIgIiIKIAotIzogZGlmZi5jOjUzNDIKKyM6IGRpZmYuYzo1MzQ1CiBtc2dpZCAiZ2VuZXJhdGUgY29tcGFjdCBzdW1tYXJ5IGluIGRpZmZzdGF0IgogbXNnc3RyICIiCiAKLSM6IGRpZmYuYzo1MzQ1CisjOiBkaWZmLmM6NTM0OAogbXNnaWQgIm91dHB1dCBhIGJpbmFyeSBkaWZmIHRoYXQgY2FuIGJlIGFwcGxpZWQiCiBtc2dzdHIgIiIKIAotIzogZGlmZi5jOjUzNDgKKyM6IGRpZmYuYzo1MzUxCiBtc2dpZCAic2hvdyBmdWxsIHByZS0gYW5kIHBvc3QtaW1hZ2Ugb2JqZWN0IG5hbWVzIG9uIHRoZSBcImluZGV4XCIgbGluZXMiCiBtc2dzdHIgIiIKIAotIzogZGlmZi5jOjUzNTAKKyM6IGRpZmYuYzo1MzUzCiBtc2dpZCAic2hvdyBjb2xvcmVkIGRpZmYiCiBtc2dzdHIgIiIKIAotIzogZGlmZi5jOjUzNTEKKyM6IGRpZmYuYzo1MzU0CiBtc2dpZCAiPGtpbmQ+IgogbXNnc3RyICIiCiAKLSM6IGRpZmYuYzo1MzUyCisjOiBkaWZmLmM6NTM1NQogbXNnaWQgIiIKICJoaWdobGlnaHQgd2hpdGVzcGFjZSBlcnJvcnMgaW4gdGhlICdjb250ZXh0JywgJ29sZCcgb3IgJ25ldycgbGluZXMgaW4gdGhlICIKICJkaWZmIgogbXNnc3RyICIiCiAKLSM6IGRpZmYuYzo1MzU1CisjOiBkaWZmLmM6NTM1OAogbXNnaWQgIiIKICJkbyBub3QgbXVuZ2UgcGF0aG5hbWVzIGFuZCB1c2UgTlVMcyBhcyBvdXRwdXQgZmllbGQgdGVybWluYXRvcnMgaW4gLS1yYXcgb3IgIgogIi0tbnVtc3RhdCIKIG1zZ3N0ciAiIgogCi0jOiBkaWZmLmM6NTM1OCBkaWZmLmM6NTM2MSBkaWZmLmM6NTM2NCBkaWZmLmM6NTQ3MAorIzogZGlmZi5jOjUzNjEgZGlmZi5jOjUzNjQgZGlmZi5jOjUzNjcgZGlmZi5jOjU0NzMKIG1zZ2lkICI8cHJlZml4PiIKIG1zZ3N0ciAiIgogCi0jOiBkaWZmLmM6NTM1OQorIzogZGlmZi5jOjUzNjIKIG1zZ2lkICJzaG93IHRoZSBnaXZlbiBzb3VyY2UgcHJlZml4IGluc3RlYWQgb2YgXCJhL1wiIgogbXNnc3RyICIiCiAKLSM6IGRpZmYuYzo1MzYyCisjOiBkaWZmLmM6NTM2NQogbXNnaWQgInNob3cgdGhlIGdpdmVuIGRlc3RpbmF0aW9uIHByZWZpeCBpbnN0ZWFkIG9mIFwiYi9cIiIKIG1zZ3N0ciAiIgogCi0jOiBkaWZmLmM6NTM2NQorIzogZGlmZi5jOjUzNjgKIG1zZ2lkICJwcmVwZW5kIGFuIGFkZGl0aW9uYWwgcHJlZml4IHRvIGV2ZXJ5IGxpbmUgb2Ygb3V0cHV0IgogbXNnc3RyICIiCiAKLSM6IGRpZmYuYzo1MzY4CisjOiBkaWZmLmM6NTM3MQogbXNnaWQgImRvIG5vdCBzaG93IGFueSBzb3VyY2Ugb3IgZGVzdGluYXRpb24gcHJlZml4IgogbXNnc3RyICIiCiAKLSM6IGRpZmYuYzo1MzcxCisjOiBkaWZmLmM6NTM3NAogbXNnaWQgInNob3cgY29udGV4dCBiZXR3ZWVuIGRpZmYgaHVua3MgdXAgdG8gdGhlIHNwZWNpZmllZCBudW1iZXIgb2YgbGluZXMiCiBtc2dzdHIgIiIKIAotIzogZGlmZi5jOjUzNzUgZGlmZi5jOjUzODAgZGlmZi5jOjUzODUKKyM6IGRpZmYuYzo1Mzc4IGRpZmYuYzo1MzgzIGRpZmYuYzo1Mzg4CiBtc2dpZCAiPGNoYXI+IgogbXNnc3RyICIiCiAKLSM6IGRpZmYuYzo1Mzc2CisjOiBkaWZmLmM6NTM3OQogbXNnaWQgInNwZWNpZnkgdGhlIGNoYXJhY3RlciB0byBpbmRpY2F0ZSBhIG5ldyBsaW5lIGluc3RlYWQgb2YgJysnIgogbXNnc3RyICIiCiAKLSM6IGRpZmYuYzo1MzgxCisjOiBkaWZmLmM6NTM4NAogbXNnaWQgInNwZWNpZnkgdGhlIGNoYXJhY3RlciB0byBpbmRpY2F0ZSBhbiBvbGQgbGluZSBpbnN0ZWFkIG9mICctJyIKIG1zZ3N0ciAiIgogCi0jOiBkaWZmLmM6NTM4NgorIzogZGlmZi5jOjUzODkKIG1zZ2lkICJzcGVjaWZ5IHRoZSBjaGFyYWN0ZXIgdG8gaW5kaWNhdGUgYSBjb250ZXh0IGluc3RlYWQgb2YgJyAnIgogbXNnc3RyICIiCiAKLSM6IGRpZmYuYzo1Mzg5CisjOiBkaWZmLmM6NTM5MgogbXNnaWQgIkRpZmYgcmVuYW1lIG9wdGlvbnMiCiBtc2dzdHIgIiIKIAotIzogZGlmZi5jOjUzOTAKKyM6IGRpZmYuYzo1MzkzCiBtc2dpZCAiPG4+Wy88bT5dIgogbXNnc3RyICIiCiAKLSM6IGRpZmYuYzo1MzkxCisjOiBkaWZmLmM6NTM5NAogbXNnaWQgImJyZWFrIGNvbXBsZXRlIHJld3JpdGUgY2hhbmdlcyBpbnRvIHBhaXJzIG9mIGRlbGV0ZSBhbmQgY3JlYXRlIgogbXNnc3RyICIiCiAKLSM6IGRpZmYuYzo1Mzk1CisjOiBkaWZmLmM6NTM5OAogbXNnaWQgImRldGVjdCByZW5hbWVzIgogbXNnc3RyICIiCiAKLSM6IGRpZmYuYzo1Mzk5CisjOiBkaWZmLmM6NTQwMgogbXNnaWQgIm9taXQgdGhlIHByZWltYWdlIGZvciBkZWxldGVzIgogbXNnc3RyICIiCiAKLSM6IGRpZmYuYzo1NDAyCisjOiBkaWZmLmM6NTQwNQogbXNnaWQgImRldGVjdCBjb3BpZXMiCiBtc2dzdHIgIiIKIAotIzogZGlmZi5jOjU0MDYKKyM6IGRpZmYuYzo1NDA5CiBtc2dpZCAidXNlIHVubW9kaWZpZWQgZmlsZXMgYXMgc291cmNlIHRvIGZpbmQgY29waWVzIgogbXNnc3RyICIiCiAKLSM6IGRpZmYuYzo1NDA4CisjOiBkaWZmLmM6NTQxMQogbXNnaWQgImRpc2FibGUgcmVuYW1lIGRldGVjdGlvbiIKIG1zZ3N0ciAiIgogCi0jOiBkaWZmLmM6NTQxMQorIzogZGlmZi5jOjU0MTQKIG1zZ2lkICJ1c2UgZW1wdHkgYmxvYnMgYXMgcmVuYW1lIHNvdXJjZSIKIG1zZ3N0ciAiIgogCi0jOiBkaWZmLmM6NTQxMworIzogZGlmZi5jOjU0MTYKIG1zZ2lkICJjb250aW51ZSBsaXN0aW5nIHRoZSBoaXN0b3J5IG9mIGEgZmlsZSBiZXlvbmQgcmVuYW1lcyIKIG1zZ3N0ciAiIgogCi0jOiBkaWZmLmM6NTQxNgorIzogZGlmZi5jOjU0MTkKIG1zZ2lkICIiCiAicHJldmVudCByZW5hbWUvY29weSBkZXRlY3Rpb24gaWYgdGhlIG51bWJlciBvZiByZW5hbWUvY29weSB0YXJnZXRzIGV4Y2VlZHMgIgogImdpdmVuIGxpbWl0IgogbXNnc3RyICIiCiAKLSM6IGRpZmYuYzo1NDE4CisjOiBkaWZmLmM6NTQyMQogbXNnaWQgIkRpZmYgYWxnb3JpdGhtIG9wdGlvbnMiCiBtc2dzdHIgIiIKIAotIzogZGlmZi5jOjU0MjAKKyM6IGRpZmYuYzo1NDIzCiBtc2dpZCAicHJvZHVjZSB0aGUgc21hbGxlc3QgcG9zc2libGUgZGlmZiIKIG1zZ3N0ciAiIgogCi0jOiBkaWZmLmM6NTQyMworIzogZGlmZi5jOjU0MjYKIG1zZ2lkICJpZ25vcmUgd2hpdGVzcGFjZSB3aGVuIGNvbXBhcmluZyBsaW5lcyIKIG1zZ3N0ciAiIgogCi0jOiBkaWZmLmM6NTQyNgorIzogZGlmZi5jOjU0MjkKIG1zZ2lkICJpZ25vcmUgY2hhbmdlcyBpbiBhbW91bnQgb2Ygd2hpdGVzcGFjZSIKIG1zZ3N0ciAiIgogCi0jOiBkaWZmLmM6NTQyOQorIzogZGlmZi5jOjU0MzIKIG1zZ2lkICJpZ25vcmUgY2hhbmdlcyBpbiB3aGl0ZXNwYWNlIGF0IEVPTCIKIG1zZ3N0ciAiIgogCi0jOiBkaWZmLmM6NTQzMgorIzogZGlmZi5jOjU0MzUKIG1zZ2lkICJpZ25vcmUgY2Fycmllci1yZXR1cm4gYXQgdGhlIGVuZCBvZiBsaW5lIgogbXNnc3RyICIiCiAKLSM6IGRpZmYuYzo1NDM1CisjOiBkaWZmLmM6NTQzOAogbXNnaWQgImlnbm9yZSBjaGFuZ2VzIHdob3NlIGxpbmVzIGFyZSBhbGwgYmxhbmsiCiBtc2dzdHIgIiIKIAotIzogZGlmZi5jOjU0MzgKKyM6IGRpZmYuYzo1NDQxCiBtc2dpZCAiaGV1cmlzdGljIHRvIHNoaWZ0IGRpZmYgaHVuayBib3VuZGFyaWVzIGZvciBlYXN5IHJlYWRpbmciCiBtc2dzdHIgIiIKIAotIzogZGlmZi5jOjU0NDEKKyM6IGRpZmYuYzo1NDQ0CiBtc2dpZCAiZ2VuZXJhdGUgZGlmZiB1c2luZyB0aGUgXCJwYXRpZW5jZSBkaWZmXCIgYWxnb3JpdGhtIgogbXNnc3RyICIiCiAKLSM6IGRpZmYuYzo1NDQ1CisjOiBkaWZmLmM6NTQ0OAogbXNnaWQgImdlbmVyYXRlIGRpZmYgdXNpbmcgdGhlIFwiaGlzdG9ncmFtIGRpZmZcIiBhbGdvcml0aG0iCiBtc2dzdHIgIiIKIAotIzogZGlmZi5jOjU0NDcKKyM6IGRpZmYuYzo1NDUwCiBtc2dpZCAiPGFsZ29yaXRobT4iCiBtc2dzdHIgIiIKIAotIzogZGlmZi5jOjU0NDgKKyM6IGRpZmYuYzo1NDUxCiBtc2dpZCAiY2hvb3NlIGEgZGlmZiBhbGdvcml0aG0iCiBtc2dzdHIgIiIKIAotIzogZGlmZi5jOjU0NTAKKyM6IGRpZmYuYzo1NDUzCiBtc2dpZCAiPHRleHQ+IgogbXNnc3RyICIiCiAKLSM6IGRpZmYuYzo1NDUxCisjOiBkaWZmLmM6NTQ1NAogbXNnaWQgImdlbmVyYXRlIGRpZmYgdXNpbmcgdGhlIFwiYW5jaG9yZWQgZGlmZlwiIGFsZ29yaXRobSIKIG1zZ3N0ciAiIgogCi0jOiBkaWZmLmM6NTQ1MyBkaWZmLmM6NTQ2MiBkaWZmLmM6NTQ2NQorIzogZGlmZi5jOjU0NTYgZGlmZi5jOjU0NjUgZGlmZi5jOjU0NjgKIG1zZ2lkICI8bW9kZT4iCiBtc2dzdHIgIiIKIAotIzogZGlmZi5jOjU0NTQKKyM6IGRpZmYuYzo1NDU3CiBtc2dpZCAic2hvdyB3b3JkIGRpZmYsIHVzaW5nIDxtb2RlPiB0byBkZWxpbWl0IGNoYW5nZWQgd29yZHMiCiBtc2dzdHIgIiIKIAotIzogZGlmZi5jOjU0NTYgZGlmZi5jOjU0NTkgZGlmZi5jOjU1MDQKKyM6IGRpZmYuYzo1NDU5IGRpZmYuYzo1NDYyIGRpZmYuYzo1NTA3CiBtc2dpZCAiPHJlZ2V4PiIKIG1zZ3N0ciAiIgogCi0jOiBkaWZmLmM6NTQ1NworIzogZGlmZi5jOjU0NjAKIG1zZ2lkICJ1c2UgPHJlZ2V4PiB0byBkZWNpZGUgd2hhdCBhIHdvcmQgaXMiCiBtc2dzdHIgIiIKIAotIzogZGlmZi5jOjU0NjAKKyM6IGRpZmYuYzo1NDYzCiBtc2dpZCAiZXF1aXZhbGVudCB0byAtLXdvcmQtZGlmZj1jb2xvciAtLXdvcmQtZGlmZi1yZWdleD08cmVnZXg+IgogbXNnc3RyICIiCiAKLSM6IGRpZmYuYzo1NDYzCisjOiBkaWZmLmM6NTQ2NgogbXNnaWQgIm1vdmVkIGxpbmVzIG9mIGNvZGUgYXJlIGNvbG9yZWQgZGlmZmVyZW50bHkiCiBtc2dzdHIgIiIKIAotIzogZGlmZi5jOjU0NjYKKyM6IGRpZmYuYzo1NDY5CiBtc2dpZCAiaG93IHdoaXRlIHNwYWNlcyBhcmUgaWdub3JlZCBpbiAtLWNvbG9yLW1vdmVkIgogbXNnc3RyICIiCiAKLSM6IGRpZmYuYzo1NDY5CisjOiBkaWZmLmM6NTQ3MgogbXNnaWQgIk90aGVyIGRpZmYgb3B0aW9ucyIKIG1zZ3N0ciAiIgogCi0jOiBkaWZmLmM6NTQ3MQorIzogZGlmZi5jOjU0NzQKIG1zZ2lkICJ3aGVuIHJ1biBmcm9tIHN1YmRpciwgZXhjbHVkZSBjaGFuZ2VzIG91dHNpZGUgYW5kIHNob3cgcmVsYXRpdmUgcGF0aHMiCiBtc2dzdHIgIiIKIAotIzogZGlmZi5jOjU0NzUKKyM6IGRpZmYuYzo1NDc4CiBtc2dpZCAidHJlYXQgYWxsIGZpbGVzIGFzIHRleHQiCiBtc2dzdHIgIiIKIAotIzogZGlmZi5jOjU0NzcKKyM6IGRpZmYuYzo1NDgwCiBtc2dpZCAic3dhcCB0d28gaW5wdXRzLCByZXZlcnNlIHRoZSBkaWZmIgogbXNnc3RyICIiCiAKLSM6IGRpZmYuYzo1NDc5CisjOiBkaWZmLmM6NTQ4MgogbXNnaWQgImV4aXQgd2l0aCAxIGlmIHRoZXJlIHdlcmUgZGlmZmVyZW5jZXMsIDAgb3RoZXJ3aXNlIgogbXNnc3RyICIiCiAKLSM6IGRpZmYuYzo1NDgxCisjOiBkaWZmLmM6NTQ4NAogbXNnaWQgImRpc2FibGUgYWxsIG91dHB1dCBvZiB0aGUgcHJvZ3JhbSIKIG1zZ3N0ciAiIgogCi0jOiBkaWZmLmM6NTQ4MworIzogZGlmZi5jOjU0ODYKIG1zZ2lkICJhbGxvdyBhbiBleHRlcm5hbCBkaWZmIGhlbHBlciB0byBiZSBleGVjdXRlZCIKIG1zZ3N0ciAiIgogCi0jOiBkaWZmLmM6NTQ4NQorIzogZGlmZi5jOjU0ODgKIG1zZ2lkICJydW4gZXh0ZXJuYWwgdGV4dCBjb252ZXJzaW9uIGZpbHRlcnMgd2hlbiBjb21wYXJpbmcgYmluYXJ5IGZpbGVzIgogbXNnc3RyICIiCiAKLSM6IGRpZmYuYzo1NDg3CisjOiBkaWZmLmM6NTQ5MAogbXNnaWQgIjx3aGVuPiIKIG1zZ3N0ciAiIgogCi0jOiBkaWZmLmM6NTQ4OAorIzogZGlmZi5jOjU0OTEKIG1zZ2lkICJpZ25vcmUgY2hhbmdlcyB0byBzdWJtb2R1bGVzIGluIHRoZSBkaWZmIGdlbmVyYXRpb24iCiBtc2dzdHIgIiIKIAotIzogZGlmZi5jOjU0OTEKKyM6IGRpZmYuYzo1NDk0CiBtc2dpZCAiPGZvcm1hdD4iCiBtc2dzdHIgIiIKIAotIzogZGlmZi5jOjU0OTIKKyM6IGRpZmYuYzo1NDk1CiBtc2dpZCAic3BlY2lmeSBob3cgZGlmZmVyZW5jZXMgaW4gc3VibW9kdWxlcyBhcmUgc2hvd24iCiBtc2dzdHIgIiIKIAotIzogZGlmZi5jOjU0OTYKKyM6IGRpZmYuYzo1NDk5CiBtc2dpZCAiaGlkZSAnZ2l0IGFkZCAtTicgZW50cmllcyBmcm9tIHRoZSBpbmRleCIKIG1zZ3N0ciAiIgogCi0jOiBkaWZmLmM6NTQ5OQorIzogZGlmZi5jOjU1MDIKIG1zZ2lkICJ0cmVhdCAnZ2l0IGFkZCAtTicgZW50cmllcyBhcyByZWFsIGluIHRoZSBpbmRleCIKIG1zZ3N0ciAiIgogCi0jOiBkaWZmLmM6NTUwMQorIzogZGlmZi5jOjU1MDQKIG1zZ2lkICI8c3RyaW5nPiIKIG1zZ3N0ciAiIgogCi0jOiBkaWZmLmM6NTUwMgotbXNnaWQgIiIKLSJsb29rIGZvciBkaWZmZXJlbmNlcyB0aGF0IGNoYW5nZSB0aGUgbnVtYmVyIG9mIG9jY3VycmVuY2VzIG9mIHRoZSBzcGVjaWZpZWQgIgotInN0cmluZyIKLW1zZ3N0ciAiIgotCiAjOiBkaWZmLmM6NTUwNQogbXNnaWQgIiIKICJsb29rIGZvciBkaWZmZXJlbmNlcyB0aGF0IGNoYW5nZSB0aGUgbnVtYmVyIG9mIG9jY3VycmVuY2VzIG9mIHRoZSBzcGVjaWZpZWQgIgotInJlZ2V4IgorInN0cmluZyIKIG1zZ3N0ciAiIgogCiAjOiBkaWZmLmM6NTUwOAotbXNnaWQgInNob3cgYWxsIGNoYW5nZXMgaW4gdGhlIGNoYW5nZXNldCB3aXRoIC1TIG9yIC1HIgorbXNnaWQgIiIKKyJsb29rIGZvciBkaWZmZXJlbmNlcyB0aGF0IGNoYW5nZSB0aGUgbnVtYmVyIG9mIG9jY3VycmVuY2VzIG9mIHRoZSBzcGVjaWZpZWQgIgorInJlZ2V4IgogbXNnc3RyICIiCiAKICM6IGRpZmYuYzo1NTExCi1tc2dpZCAidHJlYXQgPHN0cmluZz4gaW4gLVMgYXMgZXh0ZW5kZWQgUE9TSVggcmVndWxhciBleHByZXNzaW9uIgorbXNnaWQgInNob3cgYWxsIGNoYW5nZXMgaW4gdGhlIGNoYW5nZXNldCB3aXRoIC1TIG9yIC1HIgogbXNnc3RyICIiCiAKICM6IGRpZmYuYzo1NTE0Cittc2dpZCAidHJlYXQgPHN0cmluZz4gaW4gLVMgYXMgZXh0ZW5kZWQgUE9TSVggcmVndWxhciBleHByZXNzaW9uIgorbXNnc3RyICIiCisKKyM6IGRpZmYuYzo1NTE3CiBtc2dpZCAiY29udHJvbCB0aGUgb3JkZXIgaW4gd2hpY2ggZmlsZXMgYXBwZWFyIGluIHRoZSBvdXRwdXQiCiBtc2dzdHIgIiIKIAotIzogZGlmZi5jOjU1MTUKKyM6IGRpZmYuYzo1NTE4CiBtc2dpZCAiPG9iamVjdC1pZD4iCiBtc2dzdHIgIiIKIAotIzogZGlmZi5jOjU1MTYKKyM6IGRpZmYuYzo1NTE5CiBtc2dpZCAiIgogImxvb2sgZm9yIGRpZmZlcmVuY2VzIHRoYXQgY2hhbmdlIHRoZSBudW1iZXIgb2Ygb2NjdXJyZW5jZXMgb2YgdGhlIHNwZWNpZmllZCAiCiAib2JqZWN0IgogbXNnc3RyICIiCiAKLSM6IGRpZmYuYzo1NTE4CisjOiBkaWZmLmM6NTUyMQogbXNnaWQgIlsoQXxDfER8TXxSfFR8VXxYfEIpLi4uWypdXSIKIG1zZ3N0ciAiIgogCi0jOiBkaWZmLmM6NTUxOQorIzogZGlmZi5jOjU1MjIKIG1zZ2lkICJzZWxlY3QgZmlsZXMgYnkgZGlmZiB0eXBlIgogbXNnc3RyICIiCiAKLSM6IGRpZmYuYzo1NTIxCisjOiBkaWZmLmM6NTUyNAogbXNnaWQgIjxmaWxlPiIKIG1zZ3N0ciAiIgogCi0jOiBkaWZmLmM6NTUyMgorIzogZGlmZi5jOjU1MjUKIG1zZ2lkICJPdXRwdXQgdG8gYSBzcGVjaWZpYyBmaWxlIgogbXNnc3RyICIiCiAKLSM6IGRpZmYuYzo2MTc3CisjOiBkaWZmLmM6NjE4MAogbXNnaWQgImluZXhhY3QgcmVuYW1lIGRldGVjdGlvbiB3YXMgc2tpcHBlZCBkdWUgdG8gdG9vIG1hbnkgZmlsZXMuIgogbXNnc3RyICIiCiAKLSM6IGRpZmYuYzo2MTgwCisjOiBkaWZmLmM6NjE4MwogbXNnaWQgIm9ubHkgZm91bmQgY29waWVzIGZyb20gbW9kaWZpZWQgcGF0aHMgZHVlIHRvIHRvbyBtYW55IGZpbGVzLiIKIG1zZ3N0ciAiIgogCi0jOiBkaWZmLmM6NjE4MworIzogZGlmZi5jOjYxODYKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogInlvdSBtYXkgd2FudCB0byBzZXQgeW91ciAlcyB2YXJpYWJsZSB0byBhdCBsZWFzdCAlZCBhbmQgcmV0cnkgdGhlIGNvbW1hbmQuIgogbXNnc3RyICIiCiAKLSM6IGRpci5jOjUzNworIzogZGlyLmM6NTQ5CiAjLCBjLWZvcm1hdAogbXNnaWQgInBhdGhzcGVjICclcycgZGlkIG5vdCBtYXRjaCBhbnkgZmlsZShzKSBrbm93biB0byBnaXQiCiBtc2dzdHIgIiIKIAotIzogZGlyLmM6OTI2CisjOiBkaXIuYzo5MzgKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IHVzZSAlcyBhcyBhbiBleGNsdWRlIGZpbGUiCiBtc2dzdHIgIiIKIAotIzogZGlyLmM6MTg0MworIzogZGlyLmM6MTg3NwogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3Qgb3BlbiBkaXJlY3RvcnkgJyVzJyIKIG1zZ3N0ciAiIgogCi0jOiBkaXIuYzoyMDg1CisjOiBkaXIuYzoyMTI4CiBtc2dpZCAiZmFpbGVkIHRvIGdldCBrZXJuZWwgbmFtZSBhbmQgaW5mb3JtYXRpb24iCiBtc2dzdHIgIiIKIAotIzogZGlyLmM6MjIwOQorIzogZGlyLmM6MjI1MgogbXNnaWQgInVudHJhY2tlZCBjYWNoZSBpcyBkaXNhYmxlZCBvbiB0aGlzIHN5c3RlbSBvciBsb2NhdGlvbiIKIG1zZ3N0ciAiIgogCi0jOiBkaXIuYzozMDEzCisjOiBkaXIuYzozMDU2CiAjLCBjLWZvcm1hdAogbXNnaWQgImluZGV4IGZpbGUgY29ycnVwdCBpbiByZXBvICVzIgogbXNnc3RyICIiCiAKLSM6IGRpci5jOjMwNTggZGlyLmM6MzA2MworIzogZGlyLmM6MzEwMSBkaXIuYzozMTA2CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBjcmVhdGUgZGlyZWN0b3JpZXMgZm9yICVzIgogbXNnc3RyICIiCiAKLSM6IGRpci5jOjMwOTIKKyM6IGRpci5jOjMxMzUKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IG1pZ3JhdGUgZ2l0IGRpcmVjdG9yeSBmcm9tICclcycgdG8gJyVzJyIKIG1zZ3N0ciAiIgpAQCAtMjg3NiwxMiArMjg4NywxMiBAQAogbXNnaWQgImNvdWxkIG5vdCBzdGF0IGZpbGUgJyVzJyIKIG1zZ3N0ciAiIgogCi0jOiBlbnZpcm9ubWVudC5jOjE1MAorIzogZW52aXJvbm1lbnQuYzoxNDgKICMsIGMtZm9ybWF0CiBtc2dpZCAiYmFkIGdpdCBuYW1lc3BhY2UgcGF0aCBcIiVzXCIiCiBtc2dzdHIgIiIKIAotIzogZW52aXJvbm1lbnQuYzozMzIKKyM6IGVudmlyb25tZW50LmM6MzMwCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBzZXQgR0lUX0RJUiB0byAnJXMnIgogbXNnc3RyICIiCkBAIC0yODkxLDE1OCArMjkwMiwxNTQgQEAKIG1zZ2lkICJ0b28gbWFueSBhcmdzIHRvIHJ1biAlcyIKIG1zZ3N0ciAiIgogCi0jOiBmZXRjaC1vYmplY3QuYzoxNwotbXNnaWQgIlJlbW90ZSB3aXRoIG5vIFVSTCIKLW1zZ3N0ciAiIgotCi0jOiBmZXRjaC1wYWNrLmM6MTUxCisjOiBmZXRjaC1wYWNrLmM6MTUwCiBtc2dpZCAiZ2l0IGZldGNoLXBhY2s6IGV4cGVjdGVkIHNoYWxsb3cgbGlzdCIKIG1zZ3N0ciAiIgogCi0jOiBmZXRjaC1wYWNrLmM6MTU0CisjOiBmZXRjaC1wYWNrLmM6MTUzCiBtc2dpZCAiZ2l0IGZldGNoLXBhY2s6IGV4cGVjdGVkIGEgZmx1c2ggcGFja2V0IGFmdGVyIHNoYWxsb3cgbGlzdCIKIG1zZ3N0ciAiIgogCi0jOiBmZXRjaC1wYWNrLmM6MTY1CisjOiBmZXRjaC1wYWNrLmM6MTY0CiBtc2dpZCAiZ2l0IGZldGNoLXBhY2s6IGV4cGVjdGVkIEFDSy9OQUssIGdvdCBhIGZsdXNoIHBhY2tldCIKIG1zZ3N0ciAiIgogCi0jOiBmZXRjaC1wYWNrLmM6MTg1CisjOiBmZXRjaC1wYWNrLmM6MTg0CiAjLCBjLWZvcm1hdAogbXNnaWQgImdpdCBmZXRjaC1wYWNrOiBleHBlY3RlZCBBQ0svTkFLLCBnb3QgJyVzJyIKIG1zZ3N0ciAiIgogCi0jOiBmZXRjaC1wYWNrLmM6MTk2CisjOiBmZXRjaC1wYWNrLmM6MTk1CiBtc2dpZCAidW5hYmxlIHRvIHdyaXRlIHRvIHJlbW90ZSIKIG1zZ3N0ciAiIgogCi0jOiBmZXRjaC1wYWNrLmM6MjU4CisjOiBmZXRjaC1wYWNrLmM6MjU3CiBtc2dpZCAiLS1zdGF0ZWxlc3MtcnBjIHJlcXVpcmVzIG11bHRpX2Fja19kZXRhaWxlZCIKIG1zZ3N0ciAiIgogCi0jOiBmZXRjaC1wYWNrLmM6MzYwIGZldGNoLXBhY2suYzoxMjg0CisjOiBmZXRjaC1wYWNrLmM6MzU2IGZldGNoLXBhY2suYzoxMjgwCiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgc2hhbGxvdyBsaW5lOiAlcyIKIG1zZ3N0ciAiIgogCi0jOiBmZXRjaC1wYWNrLmM6MzY2IGZldGNoLXBhY2suYzoxMjkwCisjOiBmZXRjaC1wYWNrLmM6MzYyIGZldGNoLXBhY2suYzoxMjg2CiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgdW5zaGFsbG93IGxpbmU6ICVzIgogbXNnc3RyICIiCiAKLSM6IGZldGNoLXBhY2suYzozNjggZmV0Y2gtcGFjay5jOjEyOTIKKyM6IGZldGNoLXBhY2suYzozNjQgZmV0Y2gtcGFjay5jOjEyODgKICMsIGMtZm9ybWF0CiBtc2dpZCAib2JqZWN0IG5vdCBmb3VuZDogJXMiCiBtc2dzdHIgIiIKIAotIzogZmV0Y2gtcGFjay5jOjM3MSBmZXRjaC1wYWNrLmM6MTI5NQorIzogZmV0Y2gtcGFjay5jOjM2NyBmZXRjaC1wYWNrLmM6MTI5MQogIywgYy1mb3JtYXQKIG1zZ2lkICJlcnJvciBpbiBvYmplY3Q6ICVzIgogbXNnc3RyICIiCiAKLSM6IGZldGNoLXBhY2suYzozNzMgZmV0Y2gtcGFjay5jOjEyOTcKKyM6IGZldGNoLXBhY2suYzozNjkgZmV0Y2gtcGFjay5jOjEyOTMKICMsIGMtZm9ybWF0CiBtc2dpZCAibm8gc2hhbGxvdyBmb3VuZDogJXMiCiBtc2dzdHIgIiIKIAotIzogZmV0Y2gtcGFjay5jOjM3NiBmZXRjaC1wYWNrLmM6MTMwMQorIzogZmV0Y2gtcGFjay5jOjM3MiBmZXRjaC1wYWNrLmM6MTI5NwogIywgYy1mb3JtYXQKIG1zZ2lkICJleHBlY3RlZCBzaGFsbG93L3Vuc2hhbGxvdywgZ290ICVzIgogbXNnc3RyICIiCiAKLSM6IGZldGNoLXBhY2suYzo0MTcKKyM6IGZldGNoLXBhY2suYzo0MTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiZ290ICVzICVkICVzIgogbXNnc3RyICIiCiAKLSM6IGZldGNoLXBhY2suYzo0MzQKKyM6IGZldGNoLXBhY2suYzo0MzEKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBjb21taXQgJXMiCiBtc2dzdHIgIiIKIAotIzogZmV0Y2gtcGFjay5jOjQ2NQorIzogZmV0Y2gtcGFjay5jOjQ2MgogbXNnaWQgImdpdmluZyB1cCIKIG1zZ3N0ciAiIgogCi0jOiBmZXRjaC1wYWNrLmM6NDc3IHByb2dyZXNzLmM6Mjc3CisjOiBmZXRjaC1wYWNrLmM6NDc1IHByb2dyZXNzLmM6MzEyCiBtc2dpZCAiZG9uZSIKIG1zZ3N0ciAiIgogCi0jOiBmZXRjaC1wYWNrLmM6NDg5CisjOiBmZXRjaC1wYWNrLmM6NDg3CiAjLCBjLWZvcm1hdAogbXNnaWQgImdvdCAlcyAoJWQpICVzIgogbXNnc3RyICIiCiAKLSM6IGZldGNoLXBhY2suYzo1MzUKKyM6IGZldGNoLXBhY2suYzo1MzMKICMsIGMtZm9ybWF0CiBtc2dpZCAiTWFya2luZyAlcyBhcyBjb21wbGV0ZSIKIG1zZ3N0ciAiIgogCi0jOiBmZXRjaC1wYWNrLmM6NzQ0CisjOiBmZXRjaC1wYWNrLmM6NzQyCiAjLCBjLWZvcm1hdAogbXNnaWQgImFscmVhZHkgaGF2ZSAlcyAoJXMpIgogbXNnc3RyICIiCiAKLSM6IGZldGNoLXBhY2suYzo3ODMKKyM6IGZldGNoLXBhY2suYzo3ODEKIG1zZ2lkICJmZXRjaC1wYWNrOiB1bmFibGUgdG8gZm9yayBvZmYgc2lkZWJhbmQgZGVtdWx0aXBsZXhlciIKIG1zZ3N0ciAiIgogCi0jOiBmZXRjaC1wYWNrLmM6NzkxCisjOiBmZXRjaC1wYWNrLmM6Nzg5CiBtc2dpZCAicHJvdG9jb2wgZXJyb3I6IGJhZCBwYWNrIGhlYWRlciIKIG1zZ3N0ciAiIgogCi0jOiBmZXRjaC1wYWNrLmM6ODU5CisjOiBmZXRjaC1wYWNrLmM6ODU3CiAjLCBjLWZvcm1hdAogbXNnaWQgImZldGNoLXBhY2s6IHVuYWJsZSB0byBmb3JrIG9mZiAlcyIKIG1zZ3N0ciAiIgogCi0jOiBmZXRjaC1wYWNrLmM6ODc1CisjOiBmZXRjaC1wYWNrLmM6ODczCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIGZhaWxlZCIKIG1zZ3N0ciAiIgogCi0jOiBmZXRjaC1wYWNrLmM6ODc3CisjOiBmZXRjaC1wYWNrLmM6ODc1CiBtc2dpZCAiZXJyb3IgaW4gc2lkZWJhbmQgZGVtdWx0aXBsZXhlciIKIG1zZ3N0ciAiIgogCi0jOiBmZXRjaC1wYWNrLmM6OTA4CisjOiBmZXRjaC1wYWNrLmM6OTA3CiAjLCBjLWZvcm1hdAogbXNnaWQgIlNlcnZlciB2ZXJzaW9uIGlzICUuKnMiCiBtc2dzdHIgIiIKIAotIzogZmV0Y2gtcGFjay5jOjkxMyBmZXRjaC1wYWNrLmM6OTE5IGZldGNoLXBhY2suYzo5MjIgZmV0Y2gtcGFjay5jOjkyOAotIzogZmV0Y2gtcGFjay5jOjkzMiBmZXRjaC1wYWNrLmM6OTM2IGZldGNoLXBhY2suYzo5NDAgZmV0Y2gtcGFjay5jOjk0NAotIzogZmV0Y2gtcGFjay5jOjk0OCBmZXRjaC1wYWNrLmM6OTUyIGZldGNoLXBhY2suYzo5NTYgZmV0Y2gtcGFjay5jOjk2MAotIzogZmV0Y2gtcGFjay5jOjk2NiBmZXRjaC1wYWNrLmM6OTcyIGZldGNoLXBhY2suYzo5NzcgZmV0Y2gtcGFjay5jOjk4MgorIzogZmV0Y2gtcGFjay5jOjkxMiBmZXRjaC1wYWNrLmM6OTE4IGZldGNoLXBhY2suYzo5MjEgZmV0Y2gtcGFjay5jOjkyNworIzogZmV0Y2gtcGFjay5jOjkzMSBmZXRjaC1wYWNrLmM6OTM1IGZldGNoLXBhY2suYzo5MzkgZmV0Y2gtcGFjay5jOjk0MworIzogZmV0Y2gtcGFjay5jOjk0NyBmZXRjaC1wYWNrLmM6OTUxIGZldGNoLXBhY2suYzo5NTUgZmV0Y2gtcGFjay5jOjk1OQorIzogZmV0Y2gtcGFjay5jOjk2NSBmZXRjaC1wYWNrLmM6OTcxIGZldGNoLXBhY2suYzo5NzYgZmV0Y2gtcGFjay5jOjk4MQogIywgYy1mb3JtYXQKIG1zZ2lkICJTZXJ2ZXIgc3VwcG9ydHMgJXMiCiBtc2dzdHIgIiIKIAotIzogZmV0Y2gtcGFjay5jOjkxNQorIzogZmV0Y2gtcGFjay5jOjkxNAogbXNnaWQgIlNlcnZlciBkb2VzIG5vdCBzdXBwb3J0IHNoYWxsb3cgY2xpZW50cyIKIG1zZ3N0ciAiIgogCi0jOiBmZXRjaC1wYWNrLmM6OTc1CisjOiBmZXRjaC1wYWNrLmM6OTc0CiBtc2dpZCAiU2VydmVyIGRvZXMgbm90IHN1cHBvcnQgLS1zaGFsbG93LXNpbmNlIgogbXNnc3RyICIiCiAKLSM6IGZldGNoLXBhY2suYzo5ODAKKyM6IGZldGNoLXBhY2suYzo5NzkKIG1zZ2lkICJTZXJ2ZXIgZG9lcyBub3Qgc3VwcG9ydCAtLXNoYWxsb3ctZXhjbHVkZSIKIG1zZ3N0ciAiIgogCi0jOiBmZXRjaC1wYWNrLmM6OTg0CisjOiBmZXRjaC1wYWNrLmM6OTgzCiBtc2dpZCAiU2VydmVyIGRvZXMgbm90IHN1cHBvcnQgLS1kZWVwZW4iCiBtc2dzdHIgIiIKIAotIzogZmV0Y2gtcGFjay5jOjEwMDEKKyM6IGZldGNoLXBhY2suYzoxMDAwCiBtc2dpZCAibm8gY29tbW9uIGNvbW1pdHMiCiBtc2dzdHIgIiIKIAotIzogZmV0Y2gtcGFjay5jOjEwMTMgZmV0Y2gtcGFjay5jOjE0NjIKKyM6IGZldGNoLXBhY2suYzoxMDEyIGZldGNoLXBhY2suYzoxNDY4CiBtc2dpZCAiZ2l0IGZldGNoLXBhY2s6IGZldGNoIGZhaWxlZC4iCiBtc2dzdHIgIiIKIAotIzogZmV0Y2gtcGFjay5jOjExNTEKKyM6IGZldGNoLXBhY2suYzoxMTUwCiBtc2dpZCAiU2VydmVyIGRvZXMgbm90IHN1cHBvcnQgc2hhbGxvdyByZXF1ZXN0cyIKIG1zZ3N0ciAiIgogCkBAIC0zMDUwLDcyICszMDU3LDcyIEBACiBtc2dpZCAiU2VydmVyIHN1cHBvcnRzIGZpbHRlciIKIG1zZ3N0ciAiIgogCi0jOiBmZXRjaC1wYWNrLmM6MTE4NAorIzogZmV0Y2gtcGFjay5jOjExODAKIG1zZ2lkICJ1bmFibGUgdG8gd3JpdGUgcmVxdWVzdCB0byByZW1vdGUiCiBtc2dzdHIgIiIKIAotIzogZmV0Y2gtcGFjay5jOjEyMDIKKyM6IGZldGNoLXBhY2suYzoxMTk4CiAjLCBjLWZvcm1hdAogbXNnaWQgImVycm9yIHJlYWRpbmcgc2VjdGlvbiBoZWFkZXIgJyVzJyIKIG1zZ3N0ciAiIgogCi0jOiBmZXRjaC1wYWNrLmM6MTIwOAorIzogZmV0Y2gtcGFjay5jOjEyMDQKICMsIGMtZm9ybWF0CiBtc2dpZCAiZXhwZWN0ZWQgJyVzJywgcmVjZWl2ZWQgJyVzJyIKIG1zZ3N0ciAiIgogCi0jOiBmZXRjaC1wYWNrLmM6MTI0NworIzogZmV0Y2gtcGFjay5jOjEyNDMKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5leHBlY3RlZCBhY2tub3dsZWRnbWVudCBsaW5lOiAnJXMnIgogbXNnc3RyICIiCiAKLSM6IGZldGNoLXBhY2suYzoxMjUyCisjOiBmZXRjaC1wYWNrLmM6MTI0OAogIywgYy1mb3JtYXQKIG1zZ2lkICJlcnJvciBwcm9jZXNzaW5nIGFja3M6ICVkIgogbXNnc3RyICIiCiAKLSM6IGZldGNoLXBhY2suYzoxMjYyCisjOiBmZXRjaC1wYWNrLmM6MTI1OAogbXNnaWQgImV4cGVjdGVkIHBhY2tmaWxlIHRvIGJlIHNlbnQgYWZ0ZXIgJ3JlYWR5JyIKIG1zZ3N0ciAiIgogCi0jOiBmZXRjaC1wYWNrLmM6MTI2NAorIzogZmV0Y2gtcGFjay5jOjEyNjAKIG1zZ2lkICJleHBlY3RlZCBubyBvdGhlciBzZWN0aW9ucyB0byBiZSBzZW50IGFmdGVyIG5vICdyZWFkeSciCiBtc2dzdHIgIiIKIAotIzogZmV0Y2gtcGFjay5jOjEzMDYKKyM6IGZldGNoLXBhY2suYzoxMzAyCiAjLCBjLWZvcm1hdAogbXNnaWQgImVycm9yIHByb2Nlc3Npbmcgc2hhbGxvdyBpbmZvOiAlZCIKIG1zZ3N0ciAiIgogCi0jOiBmZXRjaC1wYWNrLmM6MTM1MworIzogZmV0Y2gtcGFjay5jOjEzNDkKICMsIGMtZm9ybWF0CiBtc2dpZCAiZXhwZWN0ZWQgd2FudGVkLXJlZiwgZ290ICclcyciCiBtc2dzdHIgIiIKIAotIzogZmV0Y2gtcGFjay5jOjEzNTgKKyM6IGZldGNoLXBhY2suYzoxMzU0CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuZXhwZWN0ZWQgd2FudGVkLXJlZjogJyVzJyIKIG1zZ3N0ciAiIgogCi0jOiBmZXRjaC1wYWNrLmM6MTM2MworIzogZmV0Y2gtcGFjay5jOjEzNTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiZXJyb3IgcHJvY2Vzc2luZyB3YW50ZWQgcmVmczogJWQiCiBtc2dzdHIgIiIKIAotIzogZmV0Y2gtcGFjay5jOjE2ODkKKyM6IGZldGNoLXBhY2suYzoxNjkzCiBtc2dpZCAibm8gbWF0Y2hpbmcgcmVtb3RlIGhlYWQiCiBtc2dzdHIgIiIKIAotIzogZmV0Y2gtcGFjay5jOjE3MTIgYnVpbHRpbi9jbG9uZS5jOjY4NgorIzogZmV0Y2gtcGFjay5jOjE3MTYgYnVpbHRpbi9jbG9uZS5jOjY4NQogbXNnaWQgInJlbW90ZSBkaWQgbm90IHNlbmQgYWxsIG5lY2Vzc2FyeSBvYmplY3RzIgogbXNnc3RyICIiCiAKLSM6IGZldGNoLXBhY2suYzoxNzM5CisjOiBmZXRjaC1wYWNrLmM6MTc0MwogIywgYy1mb3JtYXQKIG1zZ2lkICJubyBzdWNoIHJlbW90ZSByZWYgJXMiCiBtc2dzdHIgIiIKIAotIzogZmV0Y2gtcGFjay5jOjE3NDIKKyM6IGZldGNoLXBhY2suYzoxNzQ2CiAjLCBjLWZvcm1hdAogbXNnaWQgIlNlcnZlciBkb2VzIG5vdCBhbGxvdyByZXF1ZXN0IGZvciB1bmFkdmVydGlzZWQgb2JqZWN0ICVzIgogbXNnc3RyICIiCkBAIC0zMTM4LDE4ICszMTQ1LDI0IEBACiBtc2dpZCAiaWdub3JlIGludmFsaWQgY29sb3IgJyUuKnMnIGluIGxvZy5ncmFwaENvbG9ycyIKIG1zZ3N0ciAiIgogCi0jOiBncmVwLmM6MjExNworIzogZ3JlcC5jOjY2OAorbXNnaWQgIiIKKyJnaXZlbiBwYXR0ZXJuIGNvbnRhaW5zIE5VTEwgYnl0ZSAodmlhIC1mIDxmaWxlPikuIFRoaXMgaXMgb25seSBzdXBwb3J0ZWQgIgorIndpdGggLVAgdW5kZXIgUENSRSB2MiIKK21zZ3N0ciAiIgorCisjOiBncmVwLmM6MjEyNAogIywgYy1mb3JtYXQKIG1zZ2lkICInJXMnOiB1bmFibGUgdG8gcmVhZCAlcyIKIG1zZ3N0ciAiIgogCi0jOiBncmVwLmM6MjEzNCBzZXR1cC5jOjE2NCBidWlsdGluL2Nsb25lLmM6NDA5IGJ1aWx0aW4vZGlmZi5jOjgyCisjOiBncmVwLmM6MjE0MSBzZXR1cC5jOjE2NSBidWlsdGluL2Nsb25lLmM6NDA4IGJ1aWx0aW4vZGlmZi5jOjgyCiAjOiBidWlsdGluL3JtLmM6MTM1CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBzdGF0ICclcyciCiBtc2dzdHIgIiIKIAotIzogZ3JlcC5jOjIxNDUKKyM6IGdyZXAuYzoyMTUyCiAjLCBjLWZvcm1hdAogbXNnaWQgIiclcyc6IHNob3J0IHJlYWQiCiBtc2dzdHIgIiIKQEAgLTMyODUsMTIgKzMyOTgsMTIgQEAKIG1zZ2lkICJnaXQgdmVyc2lvbiBbPG9wdGlvbnM+XSIKIG1zZ3N0ciAiIgogCi0jOiBoZWxwLmM6NzgyCisjOiBoZWxwLmM6NzgzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiAlcyAtICVzIgogbXNnc3RyICIiCiAKLSM6IGhlbHAuYzo3ODYKKyM6IGhlbHAuYzo3ODcKIG1zZ2lkICIiCiAiXG4iCiAiRGlkIHlvdSBtZWFuIHRoaXM/IgpAQCAtMzM0OCw0MCArMzM2MSw1NSBAQAogbXNnaWQgImludmFsaWQgZGF0ZSBmb3JtYXQ6ICVzIgogbXNnc3RyICIiCiAKLSM6IGxpc3Qtb2JqZWN0cy5jOjEyOQorIzogbGlzdC1vYmplY3RzLmM6MTI3CiAjLCBjLWZvcm1hdAogbXNnaWQgImVudHJ5ICclcycgaW4gdHJlZSAlcyBoYXMgdHJlZSBtb2RlLCBidXQgaXMgbm90IGEgdHJlZSIKIG1zZ3N0ciAiIgogCi0jOiBsaXN0LW9iamVjdHMuYzoxNDIKKyM6IGxpc3Qtb2JqZWN0cy5jOjE0MAogIywgYy1mb3JtYXQKIG1zZ2lkICJlbnRyeSAnJXMnIGluIHRyZWUgJXMgaGFzIGJsb2IgbW9kZSwgYnV0IGlzIG5vdCBhIGJsb2IiCiBtc2dzdHIgIiIKIAotIzogbGlzdC1vYmplY3RzLmM6Mzc4CisjOiBsaXN0LW9iamVjdHMuYzozNzUKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGxvYWQgcm9vdCB0cmVlIGZvciBjb21taXQgJXMiCiBtc2dzdHIgIiIKIAotIzogbGlzdC1vYmplY3RzLWZpbHRlci1vcHRpb25zLmM6MzYKLW1zZ2lkICJtdWx0aXBsZSBmaWx0ZXItc3BlY3MgY2Fubm90IGJlIGNvbWJpbmVkIgorIzogbGlzdC1vYmplY3RzLWZpbHRlci5jOjQ5MgorIywgYy1mb3JtYXQKK21zZ2lkICJ1bmFibGUgdG8gYWNjZXNzIHNwYXJzZSBibG9iIGluICclcyciCittc2dzdHIgIiIKKworIzogbGlzdC1vYmplY3RzLWZpbHRlci5jOjQ5NQorIywgYy1mb3JtYXQKK21zZ2lkICJ1bmFibGUgdG8gcGFyc2Ugc3BhcnNlIGZpbHRlciBkYXRhIGluICVzIgogbXNnc3RyICIiCiAKICM6IGxpc3Qtb2JqZWN0cy1maWx0ZXItb3B0aW9ucy5jOjU4CiBtc2dpZCAiZXhwZWN0ZWQgJ3RyZWU6PGRlcHRoPiciCiBtc2dzdHIgIiIKIAotIzogbGlzdC1vYmplY3RzLWZpbHRlci1vcHRpb25zLmM6ODQKKyM6IGxpc3Qtb2JqZWN0cy1maWx0ZXItb3B0aW9ucy5jOjczCiBtc2dpZCAic3BhcnNlOnBhdGggZmlsdGVycyBzdXBwb3J0IGhhcyBiZWVuIGRyb3BwZWQiCiBtc2dzdHIgIiIKIAotIzogbGlzdC1vYmplY3RzLWZpbHRlci1vcHRpb25zLmM6OTQKKyM6IGxpc3Qtb2JqZWN0cy1maWx0ZXItb3B0aW9ucy5jOjg2CiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgZmlsdGVyLXNwZWMgJyVzJyIKIG1zZ3N0ciAiIgogCi0jOiBsaXN0LW9iamVjdHMtZmlsdGVyLW9wdGlvbnMuYzoxNTgKLW1zZ2lkICJjYW5ub3QgY2hhbmdlIHBhcnRpYWwgY2xvbmUgcHJvbWlzb3IgcmVtb3RlIgorIzogbGlzdC1vYmplY3RzLWZpbHRlci1vcHRpb25zLmM6MTAyCisjLCBjLWZvcm1hdAorbXNnaWQgIm11c3QgZXNjYXBlIGNoYXIgaW4gc3ViLWZpbHRlci1zcGVjOiAnJWMnIgorbXNnc3RyICIiCisKKyM6IGxpc3Qtb2JqZWN0cy1maWx0ZXItb3B0aW9ucy5jOjE0NAorbXNnaWQgImV4cGVjdGVkIHNvbWV0aGluZyBhZnRlciBjb21iaW5lOiIKK21zZ3N0ciAiIgorCisjOiBsaXN0LW9iamVjdHMtZmlsdGVyLW9wdGlvbnMuYzoyMjYKK21zZ2lkICJtdWx0aXBsZSBmaWx0ZXItc3BlY3MgY2Fubm90IGJlIGNvbWJpbmVkIgogbXNnc3RyICIiCiAKICM6IGxvY2tmaWxlLmM6MTUxCkBAIC0zNDA1LDExNCArMzQzMywxMTAgQEAKIG1zZ2lkICJmYWlsZWQgdG8gcmVhZCB0aGUgY2FjaGUiCiBtc2dzdHIgIiIKIAotIzogbWVyZ2UuYzoxMDcgcmVyZXJlLmM6NzIwIGJ1aWx0aW4vYW0uYzoxODg1IGJ1aWx0aW4vYW0uYzoxOTE5Ci0jOiBidWlsdGluL2NoZWNrb3V0LmM6NTM2IGJ1aWx0aW4vY2hlY2tvdXQuYzo3OTYgYnVpbHRpbi9jbG9uZS5jOjc4NgorIzogbWVyZ2UuYzoxMDcgcmVyZXJlLmM6NzIwIGJ1aWx0aW4vYW0uYzoxODc0IGJ1aWx0aW4vYW0uYzoxOTA4CisjOiBidWlsdGluL2NoZWNrb3V0LmM6NTM3IGJ1aWx0aW4vY2hlY2tvdXQuYzo3OTYgYnVpbHRpbi9jbG9uZS5jOjc4NQogIzogYnVpbHRpbi9zdGFzaC5jOjI2NAogbXNnaWQgInVuYWJsZSB0byB3cml0ZSBuZXcgaW5kZXggZmlsZSIKIG1zZ3N0ciAiIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozMjIKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjM2NwogbXNnaWQgIihiYWQgY29tbWl0KVxuIgogbXNnc3RyICIiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjM0NQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzkwCiAjLCBjLWZvcm1hdAogbXNnaWQgImFkZF9jYWNoZWluZm8gZmFpbGVkIGZvciBwYXRoICclcyc7IG1lcmdlIGFib3J0aW5nLiIKIG1zZ3N0ciAiIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozNTQKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjM5OQogIywgYy1mb3JtYXQKIG1zZ2lkICJhZGRfY2FjaGVpbmZvIGZhaWxlZCB0byByZWZyZXNoIGZvciBwYXRoICclcyc7IG1lcmdlIGFib3J0aW5nLiIKIG1zZ3N0ciAiIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzo0MzcKLW1zZ2lkICJlcnJvciBidWlsZGluZyB0cmVlcyIKLW1zZ3N0ciAiIgotCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzo4NjMKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjg4NQogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gY3JlYXRlIHBhdGggJyVzJyVzIgogbXNnc3RyICIiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjg3NAorIzogbWVyZ2UtcmVjdXJzaXZlLmM6ODk2CiAjLCBjLWZvcm1hdAogbXNnaWQgIlJlbW92aW5nICVzIHRvIG1ha2Ugcm9vbSBmb3Igc3ViZGlyZWN0b3J5XG4iCiBtc2dzdHIgIiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6ODg4IG1lcmdlLXJlY3Vyc2l2ZS5jOjkwNworIzogbWVyZ2UtcmVjdXJzaXZlLmM6OTEwIG1lcmdlLXJlY3Vyc2l2ZS5jOjkyOQogbXNnaWQgIjogcGVyaGFwcyBhIEQvRiBjb25mbGljdD8iCiBtc2dzdHIgIiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6ODk3CisjOiBtZXJnZS1yZWN1cnNpdmUuYzo5MTkKICMsIGMtZm9ybWF0CiBtc2dpZCAicmVmdXNpbmcgdG8gbG9zZSB1bnRyYWNrZWQgZmlsZSBhdCAnJXMnIgogbXNnc3RyICIiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjkzOCBidWlsdGluL2NhdC1maWxlLmM6NDAKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjk2MCBidWlsdGluL2NhdC1maWxlLmM6NDEKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IHJlYWQgb2JqZWN0ICVzICclcyciCiBtc2dzdHIgIiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6OTQxCisjOiBtZXJnZS1yZWN1cnNpdmUuYzo5NjUKICMsIGMtZm9ybWF0CiBtc2dpZCAiYmxvYiBleHBlY3RlZCBmb3IgJXMgJyVzJyIKIG1zZ3N0ciAiIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzo5NjUKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjk5MAogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gb3BlbiAnJXMnOiAlcyIKIG1zZ3N0ciAiIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzo5NzYKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEwMDEKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIHN5bWxpbmsgJyVzJzogJXMiCiBtc2dzdHIgIiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6OTgxCisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxMDA2CiAjLCBjLWZvcm1hdAogbXNnaWQgImRvIG5vdCBrbm93IHdoYXQgdG8gZG8gd2l0aCAlMDZvICVzICclcyciCiBtc2dzdHIgIiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTE3NworIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTE5OQogIywgYy1mb3JtYXQKIG1zZ2lkICJGYWlsZWQgdG8gbWVyZ2Ugc3VibW9kdWxlICVzIChub3QgY2hlY2tlZCBvdXQpIgogbXNnc3RyICIiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjExODQKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEyMDYKICMsIGMtZm9ybWF0CiBtc2dpZCAiRmFpbGVkIHRvIG1lcmdlIHN1Ym1vZHVsZSAlcyAoY29tbWl0cyBub3QgcHJlc2VudCkiCiBtc2dzdHIgIiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTE5MQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTIxMwogIywgYy1mb3JtYXQKIG1zZ2lkICJGYWlsZWQgdG8gbWVyZ2Ugc3VibW9kdWxlICVzIChjb21taXRzIGRvbid0IGZvbGxvdyBtZXJnZS1iYXNlKSIKIG1zZ3N0ciAiIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxMTk5IG1lcmdlLXJlY3Vyc2l2ZS5jOjEyMTEKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEyMjEgbWVyZ2UtcmVjdXJzaXZlLmM6MTIzMwogIywgYy1mb3JtYXQKIG1zZ2lkICJGYXN0LWZvcndhcmRpbmcgc3VibW9kdWxlICVzIHRvIHRoZSBmb2xsb3dpbmcgY29tbWl0OiIKIG1zZ3N0ciAiIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxMjAyIG1lcmdlLXJlY3Vyc2l2ZS5jOjEyMTQKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEyMjQgbWVyZ2UtcmVjdXJzaXZlLmM6MTIzNgogIywgYy1mb3JtYXQKIG1zZ2lkICJGYXN0LWZvcndhcmRpbmcgc3VibW9kdWxlICVzIgogbXNnc3RyICIiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEyMzcKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEyNTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiRmFpbGVkIHRvIG1lcmdlIHN1Ym1vZHVsZSAlcyAobWVyZ2UgZm9sbG93aW5nIGNvbW1pdHMgbm90IGZvdW5kKSIKIG1zZ3N0ciAiIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxMjQxCisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxMjYzCiAjLCBjLWZvcm1hdAogbXNnaWQgIkZhaWxlZCB0byBtZXJnZSBzdWJtb2R1bGUgJXMgKG5vdCBmYXN0LWZvcndhcmQpIgogbXNnc3RyICIiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEyNDIKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEyNjQKIG1zZ2lkICJGb3VuZCBhIHBvc3NpYmxlIG1lcmdlIHJlc29sdXRpb24gZm9yIHRoZSBzdWJtb2R1bGU6XG4iCiBtc2dzdHIgIiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTI0NQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTI2NwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiSWYgdGhpcyBpcyBjb3JyZWN0IHNpbXBseSBhZGQgaXQgdG8gdGhlIGluZGV4IGZvciBleGFtcGxlXG4iCkBAIC0zNTIzLDEwOCArMzU0NywxMDggQEAKICJ3aGljaCB3aWxsIGFjY2VwdCB0aGlzIHN1Z2dlc3Rpb24uXG4iCiBtc2dzdHIgIiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTI1NAorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTI3NgogIywgYy1mb3JtYXQKIG1zZ2lkICJGYWlsZWQgdG8gbWVyZ2Ugc3VibW9kdWxlICVzIChtdWx0aXBsZSBtZXJnZXMgZm91bmQpIgogbXNnc3RyICIiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEzMjcKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEzNDkKIG1zZ2lkICJGYWlsZWQgdG8gZXhlY3V0ZSBpbnRlcm5hbCBtZXJnZSIKIG1zZ3N0ciAiIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxMzMyCisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxMzU0CiAjLCBjLWZvcm1hdAogbXNnaWQgIlVuYWJsZSB0byBhZGQgJXMgdG8gZGF0YWJhc2UiCiBtc2dzdHIgIiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTM2NAorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTM4NgogIywgYy1mb3JtYXQKIG1zZ2lkICJBdXRvLW1lcmdpbmcgJXMiCiBtc2dzdHIgIiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTM4NworIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTQxMAogIywgYy1mb3JtYXQKIG1zZ2lkICJFcnJvcjogUmVmdXNpbmcgdG8gbG9zZSB1bnRyYWNrZWQgZmlsZSBhdCAlczsgd3JpdGluZyB0byAlcyBpbnN0ZWFkLiIKIG1zZ3N0ciAiIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxNDU5CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxNDgyCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJDT05GTElDVCAoJXMvZGVsZXRlKTogJXMgZGVsZXRlZCBpbiAlcyBhbmQgJXMgaW4gJXMuIFZlcnNpb24gJXMgb2YgJXMgbGVmdCAiCiAiaW4gdHJlZS4iCiBtc2dzdHIgIiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTQ2NAorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTQ4NwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiQ09ORkxJQ1QgKCVzL2RlbGV0ZSk6ICVzIGRlbGV0ZWQgaW4gJXMgYW5kICVzIHRvICVzIGluICVzLiBWZXJzaW9uICVzIG9mICVzICIKICJsZWZ0IGluIHRyZWUuIgogbXNnc3RyICIiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE0NzEKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE0OTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkNPTkZMSUNUICglcy9kZWxldGUpOiAlcyBkZWxldGVkIGluICVzIGFuZCAlcyBpbiAlcy4gVmVyc2lvbiAlcyBvZiAlcyBsZWZ0ICIKICJpbiB0cmVlIGF0ICVzLiIKIG1zZ3N0ciAiIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxNDc2CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxNDk5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJDT05GTElDVCAoJXMvZGVsZXRlKTogJXMgZGVsZXRlZCBpbiAlcyBhbmQgJXMgdG8gJXMgaW4gJXMuIFZlcnNpb24gJXMgb2YgJXMgIgogImxlZnQgaW4gdHJlZSBhdCAlcy4iCiBtc2dzdHIgIiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTUxMQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTUzNAogbXNnaWQgInJlbmFtZSIKIG1zZ3N0ciAiIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxNTExCisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxNTM0CiBtc2dpZCAicmVuYW1lZCIKIG1zZ3N0ciAiIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxNTkxIG1lcmdlLXJlY3Vyc2l2ZS5jOjI0NTAgbWVyZ2UtcmVjdXJzaXZlLmM6MzA5NAorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTYxNCBtZXJnZS1yZWN1cnNpdmUuYzoyNDcyIG1lcmdlLXJlY3Vyc2l2ZS5jOjMxMTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiUmVmdXNpbmcgdG8gbG9zZSBkaXJ0eSBmaWxlIGF0ICVzIgogbXNnc3RyICIiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE2MDEKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE2MjQKICMsIGMtZm9ybWF0CiBtc2dpZCAiUmVmdXNpbmcgdG8gbG9zZSB1bnRyYWNrZWQgZmlsZSBhdCAlcywgZXZlbiB0aG91Z2ggaXQncyBpbiB0aGUgd2F5LiIKIG1zZ3N0ciAiIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxNjU5CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxNjgyCiAjLCBjLWZvcm1hdAogbXNnaWQgIkNPTkZMSUNUIChyZW5hbWUvYWRkKTogUmVuYW1lICVzLT4lcyBpbiAlcy4gIEFkZGVkICVzIGluICVzIgogbXNnc3RyICIiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE2OTAKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE3MTMKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgaXMgYSBkaXJlY3RvcnkgaW4gJXMgYWRkaW5nIGFzICVzIGluc3RlYWQiCiBtc2dzdHIgIiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTY5NQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTcxOAogIywgYy1mb3JtYXQKIG1zZ2lkICJSZWZ1c2luZyB0byBsb3NlIHVudHJhY2tlZCBmaWxlIGF0ICVzOyBhZGRpbmcgYXMgJXMgaW5zdGVhZCIKIG1zZ3N0ciAiIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxNzE0CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxNzM3CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJDT05GTElDVCAocmVuYW1lL3JlbmFtZSk6IFJlbmFtZSBcIiVzXCItPlwiJXNcIiBpbiBicmFuY2ggXCIlc1wiIHJlbmFtZSBcIiVzIgogIlwiLT5cIiVzXCIgaW4gXCIlc1wiJXMiCiBtc2dzdHIgIiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTcxOQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTc0MgogbXNnaWQgIiAobGVmdCB1bnJlc29sdmVkKSIKIG1zZ3N0ciAiIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxODI4CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxODUxCiAjLCBjLWZvcm1hdAogbXNnaWQgIkNPTkZMSUNUIChyZW5hbWUvcmVuYW1lKTogUmVuYW1lICVzLT4lcyBpbiAlcy4gUmVuYW1lICVzLT4lcyBpbiAlcyIKIG1zZ3N0ciAiIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoyMDM1CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoyMDU2CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJDT05GTElDVCAoZGlyZWN0b3J5IHJlbmFtZSBzcGxpdCk6IFVuY2xlYXIgd2hlcmUgdG8gcGxhY2UgJXMgYmVjYXVzZSAiCkBAIC0zNjMyLDMyMyArMzY1NiwzMjMgQEAKICJnZXR0aW5nIGEgbWFqb3JpdHkgb2YgdGhlIGZpbGVzLiIKIG1zZ3N0ciAiIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoyMDY3CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoyMDg4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJDT05GTElDVCAoaW1wbGljaXQgZGlyIHJlbmFtZSk6IEV4aXN0aW5nIGZpbGUvZGlyIGF0ICVzIGluIHRoZSB3YXkgb2YgIgogImltcGxpY2l0IGRpcmVjdG9yeSByZW5hbWUocykgcHV0dGluZyB0aGUgZm9sbG93aW5nIHBhdGgocykgdGhlcmU6ICVzLiIKIG1zZ3N0ciAiIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoyMDc3CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoyMDk4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJDT05GTElDVCAoaW1wbGljaXQgZGlyIHJlbmFtZSk6IENhbm5vdCBtYXAgbW9yZSB0aGFuIG9uZSBwYXRoIHRvICVzOyAiCiAiaW1wbGljaXQgZGlyZWN0b3J5IHJlbmFtZXMgdHJpZWQgdG8gcHV0IHRoZXNlIHBhdGhzIHRoZXJlOiAlcyIKIG1zZ3N0ciAiIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoyMTY5CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoyMTkwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJDT05GTElDVCAocmVuYW1lL3JlbmFtZSk6IFJlbmFtZSBkaXJlY3RvcnkgJXMtPiVzIGluICVzLiBSZW5hbWUgZGlyZWN0b3J5ICVzLSIKICI+JXMgaW4gJXMiCiBtc2dzdHIgIiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MjQxMworIzogbWVyZ2UtcmVjdXJzaXZlLmM6MjQzNQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiV0FSTklORzogQXZvaWRpbmcgYXBwbHlpbmcgJXMgLT4gJXMgcmVuYW1lIHRvICVzLCBiZWNhdXNlICVzIGl0c2VsZiB3YXMgIgogInJlbmFtZWQuIgogbXNnc3RyICIiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjI5MzgKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjI5NjEKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IHJlYWQgb2JqZWN0ICVzIgogbXNnc3RyICIiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjI5NDEKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjI5NjQKICMsIGMtZm9ybWF0CiBtc2dpZCAib2JqZWN0ICVzIGlzIG5vdCBhIGJsb2IiCiBtc2dzdHIgIiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzAwNQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzAyOAogbXNnaWQgIm1vZGlmeSIKIG1zZ3N0ciAiIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozMDA1CisjOiBtZXJnZS1yZWN1cnNpdmUuYzozMDI4CiBtc2dpZCAibW9kaWZpZWQiCiBtc2dzdHIgIiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzAxNworIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzA0MAogbXNnaWQgImNvbnRlbnQiCiBtc2dzdHIgIiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzAyMQotbXNnaWQgImFkZC9hZGQiCi1tc2dzdHIgIiIKLQogIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzA0NAotIywgYy1mb3JtYXQKLW1zZ2lkICJTa2lwcGVkICVzIChtZXJnZWQgc2FtZSBhcyBleGlzdGluZykiCi1tc2dzdHIgIiIKLQotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzA2NiBnaXQtc3VibW9kdWxlLnNoOjkzNwotbXNnaWQgInN1Ym1vZHVsZSIKK21zZ2lkICJhZGQvYWRkIgogbXNnc3RyICIiCiAKICM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMwNjcKICMsIGMtZm9ybWF0Cittc2dpZCAiU2tpcHBlZCAlcyAobWVyZ2VkIHNhbWUgYXMgZXhpc3RpbmcpIgorbXNnc3RyICIiCisKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMwODkgZ2l0LXN1Ym1vZHVsZS5zaDo5MzcKK21zZ2lkICJzdWJtb2R1bGUiCittc2dzdHIgIiIKKworIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzA5MAorIywgYy1mb3JtYXQKIG1zZ2lkICJDT05GTElDVCAoJXMpOiBNZXJnZSBjb25mbGljdCBpbiAlcyIKIG1zZ3N0ciAiIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozMDk3CisjOiBtZXJnZS1yZWN1cnNpdmUuYzozMTIwCiAjLCBjLWZvcm1hdAogbXNnaWQgIkFkZGluZyBhcyAlcyBpbnN0ZWFkIgogbXNnc3RyICIiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMxNzkKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMyMDMKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlBhdGggdXBkYXRlZDogJXMgYWRkZWQgaW4gJXMgaW5zaWRlIGEgZGlyZWN0b3J5IHRoYXQgd2FzIHJlbmFtZWQgaW4gJXM7ICIKICJtb3ZpbmcgaXQgdG8gJXMuIgogbXNnc3RyICIiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMxODIKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMyMDYKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkNPTkZMSUNUIChmaWxlIGxvY2F0aW9uKTogJXMgYWRkZWQgaW4gJXMgaW5zaWRlIGEgZGlyZWN0b3J5IHRoYXQgd2FzIHJlbmFtZWQgIgogImluICVzLCBzdWdnZXN0aW5nIGl0IHNob3VsZCBwZXJoYXBzIGJlIG1vdmVkIHRvICVzLiIKIG1zZ3N0ciAiIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozMTg2CisjOiBtZXJnZS1yZWN1cnNpdmUuYzozMjEwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJQYXRoIHVwZGF0ZWQ6ICVzIHJlbmFtZWQgdG8gJXMgaW4gJXMsIGluc2lkZSBhIGRpcmVjdG9yeSB0aGF0IHdhcyByZW5hbWVkIGluICIKICIlczsgbW92aW5nIGl0IHRvICVzLiIKIG1zZ3N0ciAiIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozMTg5CisjOiBtZXJnZS1yZWN1cnNpdmUuYzozMjEzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJDT05GTElDVCAoZmlsZSBsb2NhdGlvbik6ICVzIHJlbmFtZWQgdG8gJXMgaW4gJXMsIGluc2lkZSBhIGRpcmVjdG9yeSB0aGF0ICIKICJ3YXMgcmVuYW1lZCBpbiAlcywgc3VnZ2VzdGluZyBpdCBzaG91bGQgcGVyaGFwcyBiZSBtb3ZlZCB0byAlcy4iCiBtc2dzdHIgIiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzMwMworIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzMyNwogIywgYy1mb3JtYXQKIG1zZ2lkICJSZW1vdmluZyAlcyIKIG1zZ3N0ciAiIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozMzI2CisjOiBtZXJnZS1yZWN1cnNpdmUuYzozMzUwCiBtc2dpZCAiZmlsZS9kaXJlY3RvcnkiCiBtc2dzdHIgIiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzMzMQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzM1NQogbXNnaWQgImRpcmVjdG9yeS9maWxlIgogbXNnc3RyICIiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMzMzgKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMzNjIKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ09ORkxJQ1QgKCVzKTogVGhlcmUgaXMgYSBkaXJlY3Rvcnkgd2l0aCBuYW1lICVzIGluICVzLiBBZGRpbmcgJXMgYXMgJXMiCiBtc2dzdHIgIiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzM0NworIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzM3MQogIywgYy1mb3JtYXQKIG1zZ2lkICJBZGRpbmcgJXMiCiBtc2dzdHIgIiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzM1NgorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzM4MAogIywgYy1mb3JtYXQKIG1zZ2lkICJDT05GTElDVCAoYWRkL2FkZCk6IE1lcmdlIGNvbmZsaWN0IGluICVzIgogbXNnc3RyICIiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMzOTQKLSMsIGMtZm9ybWF0Ci1tc2dpZCAiIgotIllvdXIgbG9jYWwgY2hhbmdlcyB0byB0aGUgZm9sbG93aW5nIGZpbGVzIHdvdWxkIGJlIG92ZXJ3cml0dGVuIGJ5IG1lcmdlOlxuIgotIiAgJXMiCi1tc2dzdHIgIiIKLQotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzQwNQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzQyNAogbXNnaWQgIkFscmVhZHkgdXAgdG8gZGF0ZSEiCiBtc2dzdHIgIiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzQxNAorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzQzMwogIywgYy1mb3JtYXQKIG1zZ2lkICJtZXJnaW5nIG9mIHRyZWVzICVzIGFuZCAlcyBmYWlsZWQiCiBtc2dzdHIgIiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzUxMworIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzUzNwogbXNnaWQgIk1lcmdpbmc6IgogbXNnc3RyICIiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjM1MjYKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjM1NTAKICMsIGMtZm9ybWF0CiBtc2dpZCAiZm91bmQgJXUgY29tbW9uIGFuY2VzdG9yOiIKIG1zZ2lkX3BsdXJhbCAiZm91bmQgJXUgY29tbW9uIGFuY2VzdG9yczoiCiBtc2dzdHJbMF0gIiIKIG1zZ3N0clsxXSAiIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozNTY1CisjOiBtZXJnZS1yZWN1cnNpdmUuYzozNjAwCiBtc2dpZCAibWVyZ2UgcmV0dXJuZWQgbm8gY29tbWl0IgogbXNnc3RyICIiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjM2MzEKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjM2NTkKKyMsIGMtZm9ybWF0Cittc2dpZCAiIgorIllvdXIgbG9jYWwgY2hhbmdlcyB0byB0aGUgZm9sbG93aW5nIGZpbGVzIHdvdWxkIGJlIG92ZXJ3cml0dGVuIGJ5IG1lcmdlOlxuIgorIiAgJXMiCittc2dzdHIgIiIKKworIzogbWVyZ2UtcmVjdXJzaXZlLmM6Mzc1NgogIywgYy1mb3JtYXQKIG1zZ2lkICJDb3VsZCBub3QgcGFyc2Ugb2JqZWN0ICclcyciCiBtc2dzdHIgIiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzY0NyBidWlsdGluL21lcmdlLmM6Njk4IGJ1aWx0aW4vbWVyZ2UuYzo4NjkKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjM3NzQgYnVpbHRpbi9tZXJnZS5jOjY5NCBidWlsdGluL21lcmdlLmM6ODc0CiBtc2dpZCAiVW5hYmxlIHRvIHdyaXRlIGluZGV4LiIKIG1zZ3N0ciAiIgogCi0jOiBtaWR4LmM6NjkKKyM6IG1pZHguYzo2OAogIywgYy1mb3JtYXQKIG1zZ2lkICJtdWx0aS1wYWNrLWluZGV4IGZpbGUgJXMgaXMgdG9vIHNtYWxsIgogbXNnc3RyICIiCiAKLSM6IG1pZHguYzo4NQorIzogbWlkeC5jOjg0CiAjLCBjLWZvcm1hdAogbXNnaWQgIm11bHRpLXBhY2staW5kZXggc2lnbmF0dXJlIDB4JTA4eCBkb2VzIG5vdCBtYXRjaCBzaWduYXR1cmUgMHglMDh4IgogbXNnc3RyICIiCiAKLSM6IG1pZHguYzo5MAorIzogbWlkeC5jOjg5CiAjLCBjLWZvcm1hdAogbXNnaWQgIm11bHRpLXBhY2staW5kZXggdmVyc2lvbiAlZCBub3QgcmVjb2duaXplZCIKIG1zZ3N0ciAiIgogCi0jOiBtaWR4LmM6OTUKKyM6IG1pZHguYzo5NAogIywgYy1mb3JtYXQKIG1zZ2lkICJoYXNoIHZlcnNpb24gJXUgZG9lcyBub3QgbWF0Y2giCiBtc2dzdHIgIiIKIAotIzogbWlkeC5jOjEwOQorIzogbWlkeC5jOjEwOAogbXNnaWQgImludmFsaWQgY2h1bmsgb2Zmc2V0ICh0b28gbGFyZ2UpIgogbXNnc3RyICIiCiAKLSM6IG1pZHguYzoxMzMKKyM6IG1pZHguYzoxMzIKIG1zZ2lkICJ0ZXJtaW5hdGluZyBtdWx0aS1wYWNrLWluZGV4IGNodW5rIGlkIGFwcGVhcnMgZWFybGllciB0aGFuIGV4cGVjdGVkIgogbXNnc3RyICIiCiAKLSM6IG1pZHguYzoxNDYKKyM6IG1pZHguYzoxNDUKIG1zZ2lkICJtdWx0aS1wYWNrLWluZGV4IG1pc3NpbmcgcmVxdWlyZWQgcGFjay1uYW1lIGNodW5rIgogbXNnc3RyICIiCiAKLSM6IG1pZHguYzoxNDgKKyM6IG1pZHguYzoxNDcKIG1zZ2lkICJtdWx0aS1wYWNrLWluZGV4IG1pc3NpbmcgcmVxdWlyZWQgT0lEIGZhbm91dCBjaHVuayIKIG1zZ3N0ciAiIgogCi0jOiBtaWR4LmM6MTUwCisjOiBtaWR4LmM6MTQ5CiBtc2dpZCAibXVsdGktcGFjay1pbmRleCBtaXNzaW5nIHJlcXVpcmVkIE9JRCBsb29rdXAgY2h1bmsiCiBtc2dzdHIgIiIKIAotIzogbWlkeC5jOjE1MgorIzogbWlkeC5jOjE1MQogbXNnaWQgIm11bHRpLXBhY2staW5kZXggbWlzc2luZyByZXF1aXJlZCBvYmplY3Qgb2Zmc2V0cyBjaHVuayIKIG1zZ3N0ciAiIgogCi0jOiBtaWR4LmM6MTY2CisjOiBtaWR4LmM6MTY1CiAjLCBjLWZvcm1hdAogbXNnaWQgIm11bHRpLXBhY2staW5kZXggcGFjayBuYW1lcyBvdXQgb2Ygb3JkZXI6ICclcycgYmVmb3JlICclcyciCiBtc2dzdHIgIiIKIAotIzogbWlkeC5jOjIxMQorIzogbWlkeC5jOjIxMAogIywgYy1mb3JtYXQKIG1zZ2lkICJiYWQgcGFjay1pbnQtaWQ6ICV1ICgldSB0b3RhbCBwYWNrcykiCiBtc2dzdHIgIiIKIAotIzogbWlkeC5jOjI2MQorIzogbWlkeC5jOjI2MAogbXNnaWQgIm11bHRpLXBhY2staW5kZXggc3RvcmVzIGEgNjQtYml0IG9mZnNldCwgYnV0IG9mZl90IGlzIHRvbyBzbWFsbCIKIG1zZ3N0ciAiIgogCi0jOiBtaWR4LmM6Mjg5CisjOiBtaWR4LmM6Mjg4CiBtc2dpZCAiZXJyb3IgcHJlcGFyaW5nIHBhY2tmaWxlIGZyb20gbXVsdGktcGFjay1pbmRleCIKIG1zZ3N0ciAiIgogCi0jOiBtaWR4LmM6NDcwCisjOiBtaWR4LmM6NDY5CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBhZGQgcGFja2ZpbGUgJyVzJyIKIG1zZ3N0ciAiIgogCi0jOiBtaWR4LmM6NDc2CisjOiBtaWR4LmM6NDc1CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBvcGVuIHBhY2staW5kZXggJyVzJyIKIG1zZ3N0ciAiIgogCi0jOiBtaWR4LmM6NTM2CisjOiBtaWR4LmM6NTM1CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBsb2NhdGUgb2JqZWN0ICVkIGluIHBhY2tmaWxlIgogbXNnc3RyICIiCiAKLSM6IG1pZHguYzo4NjUKKyM6IG1pZHguYzo4NjQKICMsIGMtZm9ybWF0CiBtc2dpZCAiZGlkIG5vdCBzZWUgcGFjay1maWxlICVzIHRvIGRyb3AiCiBtc2dzdHIgIiIKIAotIzogbWlkeC5jOjEwMzYKKyM6IG1pZHguYzoxMDM1CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBjbGVhciBtdWx0aS1wYWNrLWluZGV4IGF0ICVzIgogbXNnc3RyICIiCiAKLSM6IG1pZHguYzoxMDkxCisjOiBtaWR4LmM6MTA5MAogbXNnaWQgIkxvb2tpbmcgZm9yIHJlZmVyZW5jZWQgcGFja2ZpbGVzIgogbXNnc3RyICIiCiAKLSM6IG1pZHguYzoxMTA2CisjOiBtaWR4LmM6MTEwNQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAib2lkIGZhbm91dCBvdXQgb2Ygb3JkZXI6IGZhbm91dFslZF0gPSAlPFBSSXgzMj4gPiAlPFBSSXgzMj4gPSBmYW5vdXRbJWRdIgogbXNnc3RyICIiCiAKLSM6IG1pZHguYzoxMTEwCisjOiBtaWR4LmM6MTEwOQogbXNnaWQgIlZlcmlmeWluZyBPSUQgb3JkZXIgaW4gTUlEWCIKIG1zZ3N0ciAiIgogCi0jOiBtaWR4LmM6MTExOQorIzogbWlkeC5jOjExMTgKICMsIGMtZm9ybWF0CiBtc2dpZCAib2lkIGxvb2t1cCBvdXQgb2Ygb3JkZXI6IG9pZFslZF0gPSAlcyA+PSAlcyA9IG9pZFslZF0iCiBtc2dzdHIgIiIKIAotIzogbWlkeC5jOjExMzgKKyM6IG1pZHguYzoxMTM3CiBtc2dpZCAiU29ydGluZyBvYmplY3RzIGJ5IHBhY2tmaWxlIgogbXNnc3RyICIiCiAKLSM6IG1pZHguYzoxMTQ0CisjOiBtaWR4LmM6MTE0MwogbXNnaWQgIlZlcmlmeWluZyBvYmplY3Qgb2Zmc2V0cyIKIG1zZ3N0ciAiIgogCi0jOiBtaWR4LmM6MTE2MAorIzogbWlkeC5jOjExNTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIGxvYWQgcGFjayBlbnRyeSBmb3Igb2lkWyVkXSA9ICVzIgogbXNnc3RyICIiCiAKLSM6IG1pZHguYzoxMTY2CisjOiBtaWR4LmM6MTE2NQogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gbG9hZCBwYWNrLWluZGV4IGZvciBwYWNrZmlsZSAlcyIKIG1zZ3N0ciAiIgogCi0jOiBtaWR4LmM6MTE3NQorIzogbWlkeC5jOjExNzQKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW5jb3JyZWN0IG9iamVjdCBvZmZzZXQgZm9yIG9pZFslZF0gPSAlczogJTxQUkl4NjQ+ICE9ICU8UFJJeDY0PiIKIG1zZ3N0ciAiIgogCi0jOiBtaWR4LmM6MTM1MAorIzogbWlkeC5jOjEzNDkKIG1zZ2lkICJjb3VsZCBub3Qgc3RhcnQgcGFjay1vYmplY3RzIgogbXNnc3RyICIiCiAKLSM6IG1pZHguYzoxMzY5CisjOiBtaWR4LmM6MTM2OAogbXNnaWQgImNvdWxkIG5vdCBmaW5pc2ggcGFjay1vYmplY3RzIgogbXNnc3RyICIiCiAKLSM6IG5hbWUtaGFzaC5jOjUzMgorIzogbmFtZS1oYXNoLmM6NTM3CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBjcmVhdGUgbGF6eV9kaXIgdGhyZWFkOiAlcyIKIG1zZ3N0ciAiIgogCi0jOiBuYW1lLWhhc2guYzo1NTQKKyM6IG5hbWUtaGFzaC5jOjU1OQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gY3JlYXRlIGxhenlfbmFtZSB0aHJlYWQ6ICVzIgogbXNnc3RyICIiCiAKLSM6IG5hbWUtaGFzaC5jOjU2MAorIzogbmFtZS1oYXNoLmM6NTY1CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBqb2luIGxhenlfbmFtZSB0aHJlYWQ6ICVzIgogbXNnc3RyICIiCkBAIC0zOTg5LDQxICs0MDEzLDQxIEBACiBtc2dpZCAiQmFkICVzIHZhbHVlOiAnJXMnIgogbXNnc3RyICIiCiAKLSM6IG9iamVjdC5jOjU0CisjOiBvYmplY3QuYzo1MwogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIG9iamVjdCB0eXBlIFwiJXNcIiIKIG1zZ3N0ciAiIgogCi0jOiBvYmplY3QuYzoxNzQKKyM6IG9iamVjdC5jOjE3MwogIywgYy1mb3JtYXQKIG1zZ2lkICJvYmplY3QgJXMgaXMgYSAlcywgbm90IGEgJXMiCiBtc2dzdHIgIiIKIAotIzogb2JqZWN0LmM6MjM0CisjOiBvYmplY3QuYzoyMzMKICMsIGMtZm9ybWF0CiBtc2dpZCAib2JqZWN0ICVzIGhhcyB1bmtub3duIHR5cGUgaWQgJWQiCiBtc2dzdHIgIiIKIAotIzogb2JqZWN0LmM6MjQ3CisjOiBvYmplY3QuYzoyNDYKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHBhcnNlIG9iamVjdDogJXMiCiBtc2dzdHIgIiIKIAotIzogb2JqZWN0LmM6MjY3IG9iamVjdC5jOjI3OAorIzogb2JqZWN0LmM6MjY2IG9iamVjdC5jOjI3NwogIywgYy1mb3JtYXQKIG1zZ2lkICJoYXNoIG1pc21hdGNoICVzIgogbXNnc3RyICIiCiAKLSM6IHBhY2tmaWxlLmM6NjQ4CisjOiBwYWNrZmlsZS5jOjY0MQogbXNnaWQgIm9mZnNldCBiZWZvcmUgZW5kIG9mIHBhY2tmaWxlIChicm9rZW4gLmlkeD8pIgogbXNnc3RyICIiCiAKLSM6IHBhY2tmaWxlLmM6MTg5OQorIzogcGFja2ZpbGUuYzoxODg3CiAjLCBjLWZvcm1hdAogbXNnaWQgIm9mZnNldCBiZWZvcmUgc3RhcnQgb2YgcGFjayBpbmRleCBmb3IgJXMgKGNvcnJ1cHQgaW5kZXg/KSIKIG1zZ3N0ciAiIgogCi0jOiBwYWNrZmlsZS5jOjE5MDMKKyM6IHBhY2tmaWxlLmM6MTg5MQogIywgYy1mb3JtYXQKIG1zZ2lkICJvZmZzZXQgYmV5b25kIGVuZCBvZiBwYWNrIGluZGV4IGZvciAlcyAodHJ1bmNhdGVkIGluZGV4PykiCiBtc2dzdHIgIiIKQEAgLTQwNjgsMjYgKzQwOTIsMjYgQEAKIG1zZ2lkICJkaWQgeW91IG1lYW4gYC0tJXNgICh3aXRoIHR3byBkYXNoZXMgPykiCiBtc2dzdHIgIiIKIAotIzogcGFyc2Utb3B0aW9ucy5jOjg1OQorIzogcGFyc2Utb3B0aW9ucy5jOjg2MAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmtub3duIG9wdGlvbiBgJXMnIgogbXNnc3RyICIiCiAKLSM6IHBhcnNlLW9wdGlvbnMuYzo4NjEKKyM6IHBhcnNlLW9wdGlvbnMuYzo4NjIKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5rbm93biBzd2l0Y2ggYCVjJyIKIG1zZ3N0ciAiIgogCi0jOiBwYXJzZS1vcHRpb25zLmM6ODYzCisjOiBwYXJzZS1vcHRpb25zLmM6ODY0CiAjLCBjLWZvcm1hdAogbXNnaWQgInVua25vd24gbm9uLWFzY2lpIG9wdGlvbiBpbiBzdHJpbmc6IGAlcyciCiBtc2dzdHIgIiIKIAotIzogcGFyc2Utb3B0aW9ucy5jOjg4NworIzogcGFyc2Utb3B0aW9ucy5jOjg4OAogbXNnaWQgIi4uLiIKIG1zZ3N0ciAiIgogCi0jOiBwYXJzZS1vcHRpb25zLmM6OTA2CisjOiBwYXJzZS1vcHRpb25zLmM6OTA3CiAjLCBjLWZvcm1hdAogbXNnaWQgInVzYWdlOiAlcyIKIG1zZ3N0ciAiIgpAQCAtNDA5NSwyMSArNDExOSwyMSBAQAogIy4gVFJBTlNMQVRPUlM6IHRoZSBjb2xvbiBoZXJlIHNob3VsZCBhbGlnbiB3aXRoIHRoZQogIy4gb25lIGluICJ1c2FnZTogJXMiIHRyYW5zbGF0aW9uLgogIy4KLSM6IHBhcnNlLW9wdGlvbnMuYzo5MTIKKyM6IHBhcnNlLW9wdGlvbnMuYzo5MTMKICMsIGMtZm9ybWF0CiBtc2dpZCAiICAgb3I6ICVzIgogbXNnc3RyICIiCiAKLSM6IHBhcnNlLW9wdGlvbnMuYzo5MTUKKyM6IHBhcnNlLW9wdGlvbnMuYzo5MTYKICMsIGMtZm9ybWF0CiBtc2dpZCAiICAgICVzIgogbXNnc3RyICIiCiAKLSM6IHBhcnNlLW9wdGlvbnMuYzo5NTQKKyM6IHBhcnNlLW9wdGlvbnMuYzo5NTUKIG1zZ2lkICItTlVNIgogbXNnc3RyICIiCiAKLSM6IHBhcnNlLW9wdGlvbnMuYzo5NjgKKyM6IHBhcnNlLW9wdGlvbnMuYzo5NjkKICMsIGMtZm9ybWF0CiBtc2dpZCAiYWxpYXMgb2YgLS0lcyIKIG1zZ3N0ciAiIgpAQCAtNDI3NCwyOSArNDI5OCwzOCBAQAogbXNnaWQgInVuYWJsZSB0byBwYXJzZSAtLXByZXR0eSBmb3JtYXQiCiBtc2dzdHIgIiIKIAotIzogcmFuZ2UtZGlmZi5jOjcwCisjOiBwcm9taXNvci1yZW1vdGUuYzoyNQorbXNnaWQgIlJlbW90ZSB3aXRoIG5vIFVSTCIKK21zZ3N0ciAiIgorCisjOiBwcm9taXNvci1yZW1vdGUuYzo2MQorIywgYy1mb3JtYXQKK21zZ2lkICJwcm9taXNvciByZW1vdGUgbmFtZSBjYW5ub3QgYmVnaW4gd2l0aCAnLyc6ICVzIgorbXNnc3RyICIiCisKKyM6IHJhbmdlLWRpZmYuYzo3MQogbXNnaWQgImNvdWxkIG5vdCBzdGFydCBgbG9nYCIKIG1zZ3N0ciAiIgogCi0jOiByYW5nZS1kaWZmLmM6NzIKKyM6IHJhbmdlLWRpZmYuYzo3MwogbXNnaWQgImNvdWxkIG5vdCByZWFkIGBsb2dgIG91dHB1dCIKIG1zZ3N0ciAiIgogCi0jOiByYW5nZS1kaWZmLmM6OTEgc2VxdWVuY2VyLmM6NTAyMQorIzogcmFuZ2UtZGlmZi5jOjkyIHNlcXVlbmNlci5jOjQ5ODUKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHBhcnNlIGNvbW1pdCAnJXMnIgogbXNnc3RyICIiCiAKLSM6IHJhbmdlLWRpZmYuYzoxMTcKKyM6IHJhbmdlLWRpZmYuYzoxMTgKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHBhcnNlIGdpdCBoZWFkZXIgJyUuKnMnIgogbXNnc3RyICIiCiAKLSM6IHJhbmdlLWRpZmYuYzoyNzQKKyM6IHJhbmdlLWRpZmYuYzoyNzUKIG1zZ2lkICJmYWlsZWQgdG8gZ2VuZXJhdGUgZGlmZiIKIG1zZ3N0ciAiIgogCi0jOiByYW5nZS1kaWZmLmM6NTA2IHJhbmdlLWRpZmYuYzo1MDgKKyM6IHJhbmdlLWRpZmYuYzo1MDcgcmFuZ2UtZGlmZi5jOjUwOQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcGFyc2UgbG9nIGZvciAnJXMnIgogbXNnc3RyICIiCkBAIC00MzQwLDE1NiArNDM3MywxNTYgQEAKIG1zZ2lkICInJXMnIGFwcGVhcnMgYXMgYm90aCBhIGZpbGUgYW5kIGFzIGEgZGlyZWN0b3J5IgogbXNnc3RyICIiCiAKLSM6IHJlYWQtY2FjaGUuYzoxNDk5CisjOiByZWFkLWNhY2hlLmM6MTUyMAogbXNnaWQgIlJlZnJlc2ggaW5kZXgiCiBtc2dzdHIgIiIKIAotIzogcmVhZC1jYWNoZS5jOjE2MTMKKyM6IHJlYWQtY2FjaGUuYzoxNjM1CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJpbmRleC52ZXJzaW9uIHNldCwgYnV0IHRoZSB2YWx1ZSBpcyBpbnZhbGlkLlxuIgogIlVzaW5nIHZlcnNpb24gJWkiCiBtc2dzdHIgIiIKIAotIzogcmVhZC1jYWNoZS5jOjE2MjMKKyM6IHJlYWQtY2FjaGUuYzoxNjQ1CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJHSVRfSU5ERVhfVkVSU0lPTiBzZXQsIGJ1dCB0aGUgdmFsdWUgaXMgaW52YWxpZC5cbiIKICJVc2luZyB2ZXJzaW9uICVpIgogbXNnc3RyICIiCiAKLSM6IHJlYWQtY2FjaGUuYzoxNjc5CisjOiByZWFkLWNhY2hlLmM6MTcwMQogIywgYy1mb3JtYXQKIG1zZ2lkICJiYWQgc2lnbmF0dXJlIDB4JTA4eCIKIG1zZ3N0ciAiIgogCi0jOiByZWFkLWNhY2hlLmM6MTY4MgorIzogcmVhZC1jYWNoZS5jOjE3MDQKICMsIGMtZm9ybWF0CiBtc2dpZCAiYmFkIGluZGV4IHZlcnNpb24gJWQiCiBtc2dzdHIgIiIKIAotIzogcmVhZC1jYWNoZS5jOjE2OTEKKyM6IHJlYWQtY2FjaGUuYzoxNzEzCiBtc2dpZCAiYmFkIGluZGV4IGZpbGUgc2hhMSBzaWduYXR1cmUiCiBtc2dzdHIgIiIKIAotIzogcmVhZC1jYWNoZS5jOjE3MjEKKyM6IHJlYWQtY2FjaGUuYzoxNzQzCiAjLCBjLWZvcm1hdAogbXNnaWQgImluZGV4IHVzZXMgJS40cyBleHRlbnNpb24sIHdoaWNoIHdlIGRvIG5vdCB1bmRlcnN0YW5kIgogbXNnc3RyICIiCiAKLSM6IHJlYWQtY2FjaGUuYzoxNzIzCisjOiByZWFkLWNhY2hlLmM6MTc0NQogIywgYy1mb3JtYXQKIG1zZ2lkICJpZ25vcmluZyAlLjRzIGV4dGVuc2lvbiIKIG1zZ3N0ciAiIgogCi0jOiByZWFkLWNhY2hlLmM6MTc2MAorIzogcmVhZC1jYWNoZS5jOjE3ODIKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5rbm93biBpbmRleCBlbnRyeSBmb3JtYXQgMHglMDh4IgogbXNnc3RyICIiCiAKLSM6IHJlYWQtY2FjaGUuYzoxNzc2CisjOiByZWFkLWNhY2hlLmM6MTc5OAogIywgYy1mb3JtYXQKIG1zZ2lkICJtYWxmb3JtZWQgbmFtZSBmaWVsZCBpbiB0aGUgaW5kZXgsIG5lYXIgcGF0aCAnJXMnIgogbXNnc3RyICIiCiAKLSM6IHJlYWQtY2FjaGUuYzoxODMzCisjOiByZWFkLWNhY2hlLmM6MTg1NQogbXNnaWQgInVub3JkZXJlZCBzdGFnZSBlbnRyaWVzIGluIGluZGV4IgogbXNnc3RyICIiCiAKLSM6IHJlYWQtY2FjaGUuYzoxODM2CisjOiByZWFkLWNhY2hlLmM6MTg1OAogIywgYy1mb3JtYXQKIG1zZ2lkICJtdWx0aXBsZSBzdGFnZSBlbnRyaWVzIGZvciBtZXJnZWQgZmlsZSAnJXMnIgogbXNnc3RyICIiCiAKLSM6IHJlYWQtY2FjaGUuYzoxODM5CisjOiByZWFkLWNhY2hlLmM6MTg2MQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bm9yZGVyZWQgc3RhZ2UgZW50cmllcyBmb3IgJyVzJyIKIG1zZ3N0ciAiIgogCi0jOiByZWFkLWNhY2hlLmM6MTk0NiByZWFkLWNhY2hlLmM6MjIzNCByZXJlcmUuYzo1NjUgcmVyZXJlLmM6NTk5IHJlcmVyZS5jOjExMTEKLSM6IGJ1aWx0aW4vYWRkLmM6NDYwIGJ1aWx0aW4vY2hlY2staWdub3JlLmM6MTc4IGJ1aWx0aW4vY2hlY2tvdXQuYzo0NjcKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo2NTEgYnVpbHRpbi9jbGVhbi5jOjk1NiBidWlsdGluL2NvbW1pdC5jOjM0NworIzogcmVhZC1jYWNoZS5jOjE5NjcgcmVhZC1jYWNoZS5jOjIyNTUgcmVyZXJlLmM6NTY1IHJlcmVyZS5jOjU5OSByZXJlcmUuYzoxMTExCisjOiBidWlsdGluL2FkZC5jOjQ2MCBidWlsdGluL2NoZWNrLWlnbm9yZS5jOjE3OCBidWlsdGluL2NoZWNrb3V0LmM6NDY4CisjOiBidWlsdGluL2NoZWNrb3V0LmM6NjUyIGJ1aWx0aW4vY2xlYW4uYzo5NjcgYnVpbHRpbi9jb21taXQuYzozNDcKICM6IGJ1aWx0aW4vZGlmZi10cmVlLmM6MTIwIGJ1aWx0aW4vZ3JlcC5jOjQ5OSBidWlsdGluL212LmM6MTQ1CiAjOiBidWlsdGluL3Jlc2V0LmM6MjQ1IGJ1aWx0aW4vcm0uYzoyNzEgYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjMzMAogbXNnaWQgImluZGV4IGZpbGUgY29ycnVwdCIKIG1zZ3N0ciAiIgogCi0jOiByZWFkLWNhY2hlLmM6MjA4NworIzogcmVhZC1jYWNoZS5jOjIxMDgKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGNyZWF0ZSBsb2FkX2NhY2hlX2VudHJpZXMgdGhyZWFkOiAlcyIKIG1zZ3N0ciAiIgogCi0jOiByZWFkLWNhY2hlLmM6MjEwMAorIzogcmVhZC1jYWNoZS5jOjIxMjEKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGpvaW4gbG9hZF9jYWNoZV9lbnRyaWVzIHRocmVhZDogJXMiCiBtc2dzdHIgIiIKIAotIzogcmVhZC1jYWNoZS5jOjIxMzMKKyM6IHJlYWQtY2FjaGUuYzoyMTU0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiBpbmRleCBmaWxlIG9wZW4gZmFpbGVkIgogbXNnc3RyICIiCiAKLSM6IHJlYWQtY2FjaGUuYzoyMTM3CisjOiByZWFkLWNhY2hlLmM6MjE1OAogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogY2Fubm90IHN0YXQgdGhlIG9wZW4gaW5kZXgiCiBtc2dzdHIgIiIKIAotIzogcmVhZC1jYWNoZS5jOjIxNDEKKyM6IHJlYWQtY2FjaGUuYzoyMTYyCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiBpbmRleCBmaWxlIHNtYWxsZXIgdGhhbiBleHBlY3RlZCIKIG1zZ3N0ciAiIgogCi0jOiByZWFkLWNhY2hlLmM6MjE0NQorIzogcmVhZC1jYWNoZS5jOjIxNjYKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXM6IHVuYWJsZSB0byBtYXAgaW5kZXggZmlsZSIKIG1zZ3N0ciAiIgogCi0jOiByZWFkLWNhY2hlLmM6MjE4NworIzogcmVhZC1jYWNoZS5jOjIyMDgKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGNyZWF0ZSBsb2FkX2luZGV4X2V4dGVuc2lvbnMgdGhyZWFkOiAlcyIKIG1zZ3N0ciAiIgogCi0jOiByZWFkLWNhY2hlLmM6MjIxNAorIzogcmVhZC1jYWNoZS5jOjIyMzUKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGpvaW4gbG9hZF9pbmRleF9leHRlbnNpb25zIHRocmVhZDogJXMiCiBtc2dzdHIgIiIKIAotIzogcmVhZC1jYWNoZS5jOjIyNDYKKyM6IHJlYWQtY2FjaGUuYzoyMjY3CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBmcmVzaGVuIHNoYXJlZCBpbmRleCAnJXMnIgogbXNnc3RyICIiCiAKLSM6IHJlYWQtY2FjaGUuYzoyMjkzCisjOiByZWFkLWNhY2hlLmM6MjMxNAogIywgYy1mb3JtYXQKIG1zZ2lkICJicm9rZW4gaW5kZXgsIGV4cGVjdCAlcyBpbiAlcywgZ290ICVzIgogbXNnc3RyICIiCiAKLSM6IHJlYWQtY2FjaGUuYzoyOTg5IHdyYXBwZXIuYzo2NTggYnVpbHRpbi9tZXJnZS5jOjExMTQKKyM6IHJlYWQtY2FjaGUuYzozMDEwIHdyYXBwZXIuYzo2MjIgYnVpbHRpbi9tZXJnZS5jOjExMTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGNsb3NlICclcyciCiBtc2dzdHIgIiIKIAotIzogcmVhZC1jYWNoZS5jOjMwOTIgc2VxdWVuY2VyLmM6MjM1OCBzZXF1ZW5jZXIuYzozOTI4CisjOiByZWFkLWNhY2hlLmM6MzExMyBzZXF1ZW5jZXIuYzoyMjk2IHNlcXVlbmNlci5jOjM5MTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHN0YXQgJyVzJyIKIG1zZ3N0ciAiIgogCi0jOiByZWFkLWNhY2hlLmM6MzEwNQorIzogcmVhZC1jYWNoZS5jOjMxMjYKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIG9wZW4gZ2l0IGRpcjogJXMiCiBtc2dzdHIgIiIKIAotIzogcmVhZC1jYWNoZS5jOjMxMTcKKyM6IHJlYWQtY2FjaGUuYzozMTM4CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byB1bmxpbms6ICVzIgogbXNnc3RyICIiCiAKLSM6IHJlYWQtY2FjaGUuYzozMTQyCisjOiByZWFkLWNhY2hlLmM6MzE2MwogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgZml4IHBlcm1pc3Npb24gYml0cyBvbiAnJXMnIgogbXNnc3RyICIiCiAKLSM6IHJlYWQtY2FjaGUuYzozMjkxCisjOiByZWFkLWNhY2hlLmM6MzMxMgogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogY2Fubm90IGRyb3AgdG8gc3RhZ2UgIzAiCiBtc2dzdHIgIiIKQEAgLTQ1NjEsOCArNDU5NCw4IEBACiBtc2dpZCAiTm90ZSB0aGF0IGVtcHR5IGNvbW1pdHMgYXJlIGNvbW1lbnRlZCBvdXQiCiBtc2dzdHIgIiIKIAotIzogcmViYXNlLWludGVyYWN0aXZlLmM6MTA1IHJlcmVyZS5jOjQ4NSByZXJlcmUuYzo2OTIgc2VxdWVuY2VyLmM6MzQ0NwotIzogc2VxdWVuY2VyLmM6MzQ3MyBzZXF1ZW5jZXIuYzo1MTIwIGJ1aWx0aW4vZnNjay5jOjM1NiBidWlsdGluL3JlYmFzZS5jOjIzNQorIzogcmViYXNlLWludGVyYWN0aXZlLmM6MTA1IHJlcmVyZS5jOjQ4NSByZXJlcmUuYzo2OTIgc2VxdWVuY2VyLmM6MzM4OAorIzogc2VxdWVuY2VyLmM6MzQxNCBzZXF1ZW5jZXIuYzo1MDg0IGJ1aWx0aW4vZnNjay5jOjM1NiBidWlsdGluL3JlYmFzZS5jOjIzNQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3Qgd3JpdGUgJyVzJyIKIG1zZ3N0ciAiIgpAQCAtNDYwMCw3ICs0NjMzLDcgQEAKIG1zZ2lkICJpZ25vcmluZyBkYW5nbGluZyBzeW1yZWYgJXMiCiBtc2dzdHIgIiIKIAotIzogcmVmcy5jOjY2OSByZWYtZmlsdGVyLmM6MjA5MgorIzogcmVmcy5jOjY2OSByZWYtZmlsdGVyLmM6MjA5OAogIywgYy1mb3JtYXQKIG1zZ2lkICJpZ25vcmluZyBicm9rZW4gcmVmICVzIgogbXNnc3RyICIiCkBAIC00NjI1LDE0ICs0NjU4LDE0IEBACiBtc2dpZCAidW5leHBlY3RlZCBvYmplY3QgSUQgd2hlbiB3cml0aW5nICclcyciCiBtc2dzdHIgIiIKIAotIzogcmVmcy5jOjgzMyBzZXF1ZW5jZXIuYzo0MDMgc2VxdWVuY2VyLmM6MjcwOSBzZXF1ZW5jZXIuYzoyOTEzCi0jOiBzZXF1ZW5jZXIuYzoyOTI3IHNlcXVlbmNlci5jOjMxODQgc2VxdWVuY2VyLmM6NTAzNyB3cmFwcGVyLmM6NjU2CisjOiByZWZzLmM6ODMzIHNlcXVlbmNlci5jOjQwMyBzZXF1ZW5jZXIuYzoyNjQ3IHNlcXVlbmNlci5jOjI4NTEKKyM6IHNlcXVlbmNlci5jOjI4NjUgc2VxdWVuY2VyLmM6MzEyMiBzZXF1ZW5jZXIuYzo1MDAxIHdyYXBwZXIuYzo2MjAKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHdyaXRlIHRvICclcyciCiBtc2dzdHIgIiIKIAotIzogcmVmcy5jOjg2MCB3cmFwcGVyLmM6MjI1IHdyYXBwZXIuYzozOTUgYnVpbHRpbi9hbS5jOjcxNQotIzogYnVpbHRpbi9yZWJhc2UuYzoxMDAzCisjOiByZWZzLmM6ODYwIHdyYXBwZXIuYzoxODggd3JhcHBlci5jOjM1OCBidWlsdGluL2FtLmM6NzE0CisjOiBidWlsdGluL3JlYmFzZS5jOjEwMDQKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IG9wZW4gJyVzJyBmb3Igd3JpdGluZyIKIG1zZ3N0ciAiIgpAQCAtNDY2NywyMSArNDcwMCwyMSBAQAogbXNnaWQgInVwZGF0ZV9yZWYgZmFpbGVkIGZvciByZWYgJyVzJzogJXMiCiBtc2dzdHIgIiIKIAotIzogcmVmcy5jOjIwMTIKKyM6IHJlZnMuYzoyMDIzCiAjLCBjLWZvcm1hdAogbXNnaWQgIm11bHRpcGxlIHVwZGF0ZXMgZm9yIHJlZiAnJXMnIG5vdCBhbGxvd2VkIgogbXNnc3RyICIiCiAKLSM6IHJlZnMuYzoyMDQ0CisjOiByZWZzLmM6MjA1NQogbXNnaWQgInJlZiB1cGRhdGVzIGZvcmJpZGRlbiBpbnNpZGUgcXVhcmFudGluZSBlbnZpcm9ubWVudCIKIG1zZ3N0ciAiIgogCi0jOiByZWZzLmM6MjE0MCByZWZzLmM6MjE3MAorIzogcmVmcy5jOjIxNTEgcmVmcy5jOjIxODEKICMsIGMtZm9ybWF0CiBtc2dpZCAiJyVzJyBleGlzdHM7IGNhbm5vdCBjcmVhdGUgJyVzJyIKIG1zZ3N0ciAiIgogCi0jOiByZWZzLmM6MjE0NiByZWZzLmM6MjE4MQorIzogcmVmcy5jOjIxNTcgcmVmcy5jOjIxOTIKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IHByb2Nlc3MgJyVzJyBhbmQgJyVzJyBhdCB0aGUgc2FtZSB0aW1lIgogbXNnc3RyICIiCkBAIC00NjkxLDEzICs0NzI0LDEzIEBACiBtc2dpZCAiY291bGQgbm90IHJlbW92ZSByZWZlcmVuY2UgJXMiCiBtc2dzdHIgIiIKIAotIzogcmVmcy9maWxlcy1iYWNrZW5kLmM6MTI0OCByZWZzL3BhY2tlZC1iYWNrZW5kLmM6MTUzMgotIzogcmVmcy9wYWNrZWQtYmFja2VuZC5jOjE1NDIKKyM6IHJlZnMvZmlsZXMtYmFja2VuZC5jOjEyNDggcmVmcy9wYWNrZWQtYmFja2VuZC5jOjE1NDEKKyM6IHJlZnMvcGFja2VkLWJhY2tlbmQuYzoxNTUxCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBkZWxldGUgcmVmZXJlbmNlICVzOiAlcyIKIG1zZ3N0ciAiIgogCi0jOiByZWZzL2ZpbGVzLWJhY2tlbmQuYzoxMjUxIHJlZnMvcGFja2VkLWJhY2tlbmQuYzoxNTQ1CisjOiByZWZzL2ZpbGVzLWJhY2tlbmQuYzoxMjUxIHJlZnMvcGFja2VkLWJhY2tlbmQuYzoxNTU0CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBkZWxldGUgcmVmZXJlbmNlczogJXMiCiBtc2dzdHIgIiIKQEAgLTQ3MDcsNyArNDc0MCw3IEBACiBtc2dpZCAiaW52YWxpZCByZWZzcGVjICclcyciCiBtc2dzdHIgIiIKIAotIzogcmVmLWZpbHRlci5jOjQyIHd0LXN0YXR1cy5jOjE5MzQKKyM6IHJlZi1maWx0ZXIuYzo0MiB3dC1zdGF0dXMuYzoxOTM4CiBtc2dpZCAiZ29uZSIKIG1zZ3N0ciAiIgogCkBAIC00NzI2LDI4MCArNDc1OSwyODAgQEAKIG1zZ2lkICJhaGVhZCAlZCwgYmVoaW5kICVkIgogbXNnc3RyICIiCiAKLSM6IHJlZi1maWx0ZXIuYzoxNjIKKyM6IHJlZi1maWx0ZXIuYzoxNjUKICMsIGMtZm9ybWF0CiBtc2dpZCAiZXhwZWN0ZWQgZm9ybWF0OiAlJShjb2xvcjo8Y29sb3I+KSIKIG1zZ3N0ciAiIgogCi0jOiByZWYtZmlsdGVyLmM6MTY0CisjOiByZWYtZmlsdGVyLmM6MTY3CiAjLCBjLWZvcm1hdAogbXNnaWQgInVucmVjb2duaXplZCBjb2xvcjogJSUoY29sb3I6JXMpIgogbXNnc3RyICIiCiAKLSM6IHJlZi1maWx0ZXIuYzoxODYKKyM6IHJlZi1maWx0ZXIuYzoxODkKICMsIGMtZm9ybWF0CiBtc2dpZCAiSW50ZWdlciB2YWx1ZSBleHBlY3RlZCByZWZuYW1lOmxzdHJpcD0lcyIKIG1zZ3N0ciAiIgogCi0jOiByZWYtZmlsdGVyLmM6MTkwCisjOiByZWYtZmlsdGVyLmM6MTkzCiAjLCBjLWZvcm1hdAogbXNnaWQgIkludGVnZXIgdmFsdWUgZXhwZWN0ZWQgcmVmbmFtZTpyc3RyaXA9JXMiCiBtc2dzdHIgIiIKIAotIzogcmVmLWZpbHRlci5jOjE5MgorIzogcmVmLWZpbHRlci5jOjE5NQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bnJlY29nbml6ZWQgJSUoJXMpIGFyZ3VtZW50OiAlcyIKIG1zZ3N0ciAiIgogCi0jOiByZWYtZmlsdGVyLmM6MjQ3CisjOiByZWYtZmlsdGVyLmM6MjUwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiUlKG9iamVjdHR5cGUpIGRvZXMgbm90IHRha2UgYXJndW1lbnRzIgogbXNnc3RyICIiCiAKLSM6IHJlZi1maWx0ZXIuYzoyNjkKKyM6IHJlZi1maWx0ZXIuYzoyNzIKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5yZWNvZ25pemVkICUlKG9iamVjdHNpemUpIGFyZ3VtZW50OiAlcyIKIG1zZ3N0ciAiIgogCi0jOiByZWYtZmlsdGVyLmM6Mjc3CisjOiByZWYtZmlsdGVyLmM6MjgwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiUlKGRlbHRhYmFzZSkgZG9lcyBub3QgdGFrZSBhcmd1bWVudHMiCiBtc2dzdHIgIiIKIAotIzogcmVmLWZpbHRlci5jOjI4OQorIzogcmVmLWZpbHRlci5jOjI5MgogIywgYy1mb3JtYXQKIG1zZ2lkICIlJShib2R5KSBkb2VzIG5vdCB0YWtlIGFyZ3VtZW50cyIKIG1zZ3N0ciAiIgogCi0jOiByZWYtZmlsdGVyLmM6Mjk4CisjOiByZWYtZmlsdGVyLmM6MzAxCiAjLCBjLWZvcm1hdAogbXNnaWQgIiUlKHN1YmplY3QpIGRvZXMgbm90IHRha2UgYXJndW1lbnRzIgogbXNnc3RyICIiCiAKLSM6IHJlZi1maWx0ZXIuYzozMjAKKyM6IHJlZi1maWx0ZXIuYzozMjMKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5rbm93biAlJSh0cmFpbGVycykgYXJndW1lbnQ6ICVzIgogbXNnc3RyICIiCiAKLSM6IHJlZi1maWx0ZXIuYzozNDkKKyM6IHJlZi1maWx0ZXIuYzozNTIKICMsIGMtZm9ybWF0CiBtc2dpZCAicG9zaXRpdmUgdmFsdWUgZXhwZWN0ZWQgY29udGVudHM6bGluZXM9JXMiCiBtc2dzdHIgIiIKIAotIzogcmVmLWZpbHRlci5jOjM1MQorIzogcmVmLWZpbHRlci5jOjM1NAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bnJlY29nbml6ZWQgJSUoY29udGVudHMpIGFyZ3VtZW50OiAlcyIKIG1zZ3N0ciAiIgogCi0jOiByZWYtZmlsdGVyLmM6MzY2CisjOiByZWYtZmlsdGVyLmM6MzY5CiAjLCBjLWZvcm1hdAogbXNnaWQgInBvc2l0aXZlIHZhbHVlIGV4cGVjdGVkIG9iamVjdG5hbWU6c2hvcnQ9JXMiCiBtc2dzdHIgIiIKIAotIzogcmVmLWZpbHRlci5jOjM3MAorIzogcmVmLWZpbHRlci5jOjM3MwogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bnJlY29nbml6ZWQgJSUob2JqZWN0bmFtZSkgYXJndW1lbnQ6ICVzIgogbXNnc3RyICIiCiAKLSM6IHJlZi1maWx0ZXIuYzo0MDAKKyM6IHJlZi1maWx0ZXIuYzo0MDMKICMsIGMtZm9ybWF0CiBtc2dpZCAiZXhwZWN0ZWQgZm9ybWF0OiAlJShhbGlnbjo8d2lkdGg+LDxwb3NpdGlvbj4pIgogbXNnc3RyICIiCiAKLSM6IHJlZi1maWx0ZXIuYzo0MTIKKyM6IHJlZi1maWx0ZXIuYzo0MTUKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5yZWNvZ25pemVkIHBvc2l0aW9uOiVzIgogbXNnc3RyICIiCiAKLSM6IHJlZi1maWx0ZXIuYzo0MTkKKyM6IHJlZi1maWx0ZXIuYzo0MjIKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5yZWNvZ25pemVkIHdpZHRoOiVzIgogbXNnc3RyICIiCiAKLSM6IHJlZi1maWx0ZXIuYzo0MjgKKyM6IHJlZi1maWx0ZXIuYzo0MzEKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5yZWNvZ25pemVkICUlKGFsaWduKSBhcmd1bWVudDogJXMiCiBtc2dzdHIgIiIKIAotIzogcmVmLWZpbHRlci5jOjQzNgorIzogcmVmLWZpbHRlci5jOjQzOQogIywgYy1mb3JtYXQKIG1zZ2lkICJwb3NpdGl2ZSB3aWR0aCBleHBlY3RlZCB3aXRoIHRoZSAlJShhbGlnbikgYXRvbSIKIG1zZ3N0ciAiIgogCi0jOiByZWYtZmlsdGVyLmM6NDU0CisjOiByZWYtZmlsdGVyLmM6NDU3CiAjLCBjLWZvcm1hdAogbXNnaWQgInVucmVjb2duaXplZCAlJShpZikgYXJndW1lbnQ6ICVzIgogbXNnc3RyICIiCiAKLSM6IHJlZi1maWx0ZXIuYzo1NTYKKyM6IHJlZi1maWx0ZXIuYzo1NTkKICMsIGMtZm9ybWF0CiBtc2dpZCAibWFsZm9ybWVkIGZpZWxkIG5hbWU6ICUuKnMiCiBtc2dzdHIgIiIKIAotIzogcmVmLWZpbHRlci5jOjU4MworIzogcmVmLWZpbHRlci5jOjU4NgogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmtub3duIGZpZWxkIG5hbWU6ICUuKnMiCiBtc2dzdHIgIiIKIAotIzogcmVmLWZpbHRlci5jOjU4NworIzogcmVmLWZpbHRlci5jOjU5MAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAibm90IGEgZ2l0IHJlcG9zaXRvcnksIGJ1dCB0aGUgZmllbGQgJyUuKnMnIHJlcXVpcmVzIGFjY2VzcyB0byBvYmplY3QgZGF0YSIKIG1zZ3N0ciAiIgogCi0jOiByZWYtZmlsdGVyLmM6NzExCisjOiByZWYtZmlsdGVyLmM6NzE0CiAjLCBjLWZvcm1hdAogbXNnaWQgImZvcm1hdDogJSUoaWYpIGF0b20gdXNlZCB3aXRob3V0IGEgJSUodGhlbikgYXRvbSIKIG1zZ3N0ciAiIgogCi0jOiByZWYtZmlsdGVyLmM6Nzc0CisjOiByZWYtZmlsdGVyLmM6Nzc3CiAjLCBjLWZvcm1hdAogbXNnaWQgImZvcm1hdDogJSUodGhlbikgYXRvbSB1c2VkIHdpdGhvdXQgYW4gJSUoaWYpIGF0b20iCiBtc2dzdHIgIiIKIAotIzogcmVmLWZpbHRlci5jOjc3NgorIzogcmVmLWZpbHRlci5jOjc3OQogIywgYy1mb3JtYXQKIG1zZ2lkICJmb3JtYXQ6ICUlKHRoZW4pIGF0b20gdXNlZCBtb3JlIHRoYW4gb25jZSIKIG1zZ3N0ciAiIgogCi0jOiByZWYtZmlsdGVyLmM6Nzc4CisjOiByZWYtZmlsdGVyLmM6NzgxCiAjLCBjLWZvcm1hdAogbXNnaWQgImZvcm1hdDogJSUodGhlbikgYXRvbSB1c2VkIGFmdGVyICUlKGVsc2UpIgogbXNnc3RyICIiCiAKLSM6IHJlZi1maWx0ZXIuYzo4MDYKKyM6IHJlZi1maWx0ZXIuYzo4MDkKICMsIGMtZm9ybWF0CiBtc2dpZCAiZm9ybWF0OiAlJShlbHNlKSBhdG9tIHVzZWQgd2l0aG91dCBhbiAlJShpZikgYXRvbSIKIG1zZ3N0ciAiIgogCi0jOiByZWYtZmlsdGVyLmM6ODA4CisjOiByZWYtZmlsdGVyLmM6ODExCiAjLCBjLWZvcm1hdAogbXNnaWQgImZvcm1hdDogJSUoZWxzZSkgYXRvbSB1c2VkIHdpdGhvdXQgYSAlJSh0aGVuKSBhdG9tIgogbXNnc3RyICIiCiAKLSM6IHJlZi1maWx0ZXIuYzo4MTAKKyM6IHJlZi1maWx0ZXIuYzo4MTMKICMsIGMtZm9ybWF0CiBtc2dpZCAiZm9ybWF0OiAlJShlbHNlKSBhdG9tIHVzZWQgbW9yZSB0aGFuIG9uY2UiCiBtc2dzdHIgIiIKIAotIzogcmVmLWZpbHRlci5jOjgyNQorIzogcmVmLWZpbHRlci5jOjgyOAogIywgYy1mb3JtYXQKIG1zZ2lkICJmb3JtYXQ6ICUlKGVuZCkgYXRvbSB1c2VkIHdpdGhvdXQgY29ycmVzcG9uZGluZyBhdG9tIgogbXNnc3RyICIiCiAKLSM6IHJlZi1maWx0ZXIuYzo4ODIKKyM6IHJlZi1maWx0ZXIuYzo4ODUKICMsIGMtZm9ybWF0CiBtc2dpZCAibWFsZm9ybWVkIGZvcm1hdCBzdHJpbmcgJXMiCiBtc2dzdHIgIiIKIAotIzogcmVmLWZpbHRlci5jOjE0ODUKKyM6IHJlZi1maWx0ZXIuYzoxNDg4CiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vIGJyYW5jaCwgcmViYXNpbmcgJXMiCiBtc2dzdHIgIiIKIAotIzogcmVmLWZpbHRlci5jOjE0ODgKKyM6IHJlZi1maWx0ZXIuYzoxNDkxCiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vIGJyYW5jaCwgcmViYXNpbmcgZGV0YWNoZWQgSEVBRCAlcyIKIG1zZ3N0ciAiIgogCi0jOiByZWYtZmlsdGVyLmM6MTQ5MQorIzogcmVmLWZpbHRlci5jOjE0OTQKICMsIGMtZm9ybWF0CiBtc2dpZCAibm8gYnJhbmNoLCBiaXNlY3Qgc3RhcnRlZCBvbiAlcyIKIG1zZ3N0ciAiIgogCi0jOiByZWYtZmlsdGVyLmM6MTUwMQorIzogcmVmLWZpbHRlci5jOjE1MDQKIG1zZ2lkICJubyBicmFuY2giCiBtc2dzdHIgIiIKIAotIzogcmVmLWZpbHRlci5jOjE1MzcgcmVmLWZpbHRlci5jOjE3NDMKKyM6IHJlZi1maWx0ZXIuYzoxNTQwIHJlZi1maWx0ZXIuYzoxNzQ5CiAjLCBjLWZvcm1hdAogbXNnaWQgIm1pc3Npbmcgb2JqZWN0ICVzIGZvciAlcyIKIG1zZ3N0ciAiIgogCi0jOiByZWYtZmlsdGVyLmM6MTU0NworIzogcmVmLWZpbHRlci5jOjE1NTAKICMsIGMtZm9ybWF0CiBtc2dpZCAicGFyc2Vfb2JqZWN0X2J1ZmZlciBmYWlsZWQgb24gJXMgZm9yICVzIgogbXNnc3RyICIiCiAKLSM6IHJlZi1maWx0ZXIuYzoxOTk4CisjOiByZWYtZmlsdGVyLmM6MjAwNAogIywgYy1mb3JtYXQKIG1zZ2lkICJtYWxmb3JtZWQgb2JqZWN0IGF0ICclcyciCiBtc2dzdHIgIiIKIAotIzogcmVmLWZpbHRlci5jOjIwODcKKyM6IHJlZi1maWx0ZXIuYzoyMDkzCiAjLCBjLWZvcm1hdAogbXNnaWQgImlnbm9yaW5nIHJlZiB3aXRoIGJyb2tlbiBuYW1lICVzIgogbXNnc3RyICIiCiAKLSM6IHJlZi1maWx0ZXIuYzoyMzgyCisjOiByZWYtZmlsdGVyLmM6MjM4OQogIywgYy1mb3JtYXQKIG1zZ2lkICJmb3JtYXQ6ICUlKGVuZCkgYXRvbSBtaXNzaW5nIgogbXNnc3RyICIiCiAKLSM6IHJlZi1maWx0ZXIuYzoyNDgyCisjOiByZWYtZmlsdGVyLmM6MjQ4OQogIywgYy1mb3JtYXQKIG1zZ2lkICJvcHRpb24gYCVzJyBpcyBpbmNvbXBhdGlibGUgd2l0aCAtLW1lcmdlZCIKIG1zZ3N0ciAiIgogCi0jOiByZWYtZmlsdGVyLmM6MjQ4NQorIzogcmVmLWZpbHRlci5jOjI0OTIKICMsIGMtZm9ybWF0CiBtc2dpZCAib3B0aW9uIGAlcycgaXMgaW5jb21wYXRpYmxlIHdpdGggLS1uby1tZXJnZWQiCiBtc2dzdHIgIiIKIAotIzogcmVmLWZpbHRlci5jOjI0OTUKKyM6IHJlZi1maWx0ZXIuYzoyNTAyCiAjLCBjLWZvcm1hdAogbXNnaWQgIm1hbGZvcm1lZCBvYmplY3QgbmFtZSAlcyIKIG1zZ3N0ciAiIgogCi0jOiByZWYtZmlsdGVyLmM6MjUwMAorIzogcmVmLWZpbHRlci5jOjI1MDcKICMsIGMtZm9ybWF0CiBtc2dpZCAib3B0aW9uIGAlcycgbXVzdCBwb2ludCB0byBhIGNvbW1pdCIKIG1zZ3N0ciAiIgogCi0jOiByZW1vdGUuYzozNjMKKyM6IHJlbW90ZS5jOjM2NgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb25maWcgcmVtb3RlIHNob3J0aGFuZCBjYW5ub3QgYmVnaW4gd2l0aCAnLyc6ICVzIgogbXNnc3RyICIiCiAKLSM6IHJlbW90ZS5jOjQxMAorIzogcmVtb3RlLmM6NDEzCiBtc2dpZCAibW9yZSB0aGFuIG9uZSByZWNlaXZlcGFjayBnaXZlbiwgdXNpbmcgdGhlIGZpcnN0IgogbXNnc3RyICIiCiAKLSM6IHJlbW90ZS5jOjQxOAorIzogcmVtb3RlLmM6NDIxCiBtc2dpZCAibW9yZSB0aGFuIG9uZSB1cGxvYWRwYWNrIGdpdmVuLCB1c2luZyB0aGUgZmlyc3QiCiBtc2dzdHIgIiIKIAotIzogcmVtb3RlLmM6NjA4CisjOiByZW1vdGUuYzo2MTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ2Fubm90IGZldGNoIGJvdGggJXMgYW5kICVzIHRvICVzIgogbXNnc3RyICIiCiAKLSM6IHJlbW90ZS5jOjYxMgorIzogcmVtb3RlLmM6NjE1CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIHVzdWFsbHkgdHJhY2tzICVzLCBub3QgJXMiCiBtc2dzdHIgIiIKIAotIzogcmVtb3RlLmM6NjE2CisjOiByZW1vdGUuYzo2MTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgdHJhY2tzIGJvdGggJXMgYW5kICVzIgogbXNnc3RyICIiCiAKLSM6IHJlbW90ZS5jOjY4NAorIzogcmVtb3RlLmM6Njg3CiAjLCBjLWZvcm1hdAogbXNnaWQgImtleSAnJXMnIG9mIHBhdHRlcm4gaGFkIG5vICcqJyIKIG1zZ3N0ciAiIgogCi0jOiByZW1vdGUuYzo2OTQKKyM6IHJlbW90ZS5jOjY5NwogIywgYy1mb3JtYXQKIG1zZ2lkICJ2YWx1ZSAnJXMnIG9mIHBhdHRlcm4gaGFzIG5vICcqJyIKIG1zZ3N0ciAiIgogCi0jOiByZW1vdGUuYzoxMDAwCisjOiByZW1vdGUuYzoxMDAzCiAjLCBjLWZvcm1hdAogbXNnaWQgInNyYyByZWZzcGVjICVzIGRvZXMgbm90IG1hdGNoIGFueSIKIG1zZ3N0ciAiIgogCi0jOiByZW1vdGUuYzoxMDA1CisjOiByZW1vdGUuYzoxMDA4CiAjLCBjLWZvcm1hdAogbXNnaWQgInNyYyByZWZzcGVjICVzIG1hdGNoZXMgbW9yZSB0aGFuIG9uZSIKIG1zZ3N0ciAiIgpAQCAtNTAwOCw3ICs1MDQxLDcgQEAKICMuIDxyZW1vdGU+IDxzcmM+Ojxkc3Q+IiBwdXNoLCBhbmQgImJlaW5nIHB1c2hlZCAoJyVzJykiIGlzCiAjLiB0aGUgPHNyYz4uCiAjLgotIzogcmVtb3RlLmM6MTAyMAorIzogcmVtb3RlLmM6MTAyMwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiVGhlIGRlc3RpbmF0aW9uIHlvdSBwcm92aWRlZCBpcyBub3QgYSBmdWxsIHJlZm5hbWUgKGkuZS4sXG4iCkBAIC01MDIyLDcgKzUwNTUsNyBAQAogIk5laXRoZXIgd29ya2VkLCBzbyB3ZSBnYXZlIHVwLiBZb3UgbXVzdCBmdWxseSBxdWFsaWZ5IHRoZSByZWYuIgogbXNnc3RyICIiCiAKLSM6IHJlbW90ZS5jOjEwNDAKKyM6IHJlbW90ZS5jOjEwNDMKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlRoZSA8c3JjPiBwYXJ0IG9mIHRoZSByZWZzcGVjIGlzIGEgY29tbWl0IG9iamVjdC5cbiIKQEAgLTUwMzAsNyArNTA2Myw3IEBACiAiJyVzOnJlZnMvaGVhZHMvJXMnPyIKIG1zZ3N0ciAiIgogCi0jOiByZW1vdGUuYzoxMDQ1CisjOiByZW1vdGUuYzoxMDQ4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgPHNyYz4gcGFydCBvZiB0aGUgcmVmc3BlYyBpcyBhIHRhZyBvYmplY3QuXG4iCkBAIC01MDM4LDcgKzUwNzEsNyBAQAogIiclczpyZWZzL3RhZ3MvJXMnPyIKIG1zZ3N0ciAiIgogCi0jOiByZW1vdGUuYzoxMDUwCisjOiByZW1vdGUuYzoxMDUzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgPHNyYz4gcGFydCBvZiB0aGUgcmVmc3BlYyBpcyBhIHRyZWUgb2JqZWN0LlxuIgpAQCAtNTA0Niw3ICs1MDc5LDcgQEAKICInJXM6cmVmcy90YWdzLyVzJz8iCiBtc2dzdHIgIiIKIAotIzogcmVtb3RlLmM6MTA1NQorIzogcmVtb3RlLmM6MTA1OAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiVGhlIDxzcmM+IHBhcnQgb2YgdGhlIHJlZnNwZWMgaXMgYSBibG9iIG9iamVjdC5cbiIKQEAgLTUwNTQsMTE0ICs1MDg3LDExNCBAQAogIiclczpyZWZzL3RhZ3MvJXMnPyIKIG1zZ3N0ciAiIgogCi0jOiByZW1vdGUuYzoxMDkxCisjOiByZW1vdGUuYzoxMDk0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIGNhbm5vdCBiZSByZXNvbHZlZCB0byBicmFuY2giCiBtc2dzdHIgIiIKIAotIzogcmVtb3RlLmM6MTEwMgorIzogcmVtb3RlLmM6MTEwNQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gZGVsZXRlICclcyc6IHJlbW90ZSByZWYgZG9lcyBub3QgZXhpc3QiCiBtc2dzdHIgIiIKIAotIzogcmVtb3RlLmM6MTExNAorIzogcmVtb3RlLmM6MTExNwogIywgYy1mb3JtYXQKIG1zZ2lkICJkc3QgcmVmc3BlYyAlcyBtYXRjaGVzIG1vcmUgdGhhbiBvbmUiCiBtc2dzdHIgIiIKIAotIzogcmVtb3RlLmM6MTEyMQorIzogcmVtb3RlLmM6MTEyNAogIywgYy1mb3JtYXQKIG1zZ2lkICJkc3QgcmVmICVzIHJlY2VpdmVzIGZyb20gbW9yZSB0aGFuIG9uZSBzcmMiCiBtc2dzdHIgIiIKIAotIzogcmVtb3RlLmM6MTYyNCByZW1vdGUuYzoxNzI1CisjOiByZW1vdGUuYzoxNjI3IHJlbW90ZS5jOjE3MjgKIG1zZ2lkICJIRUFEIGRvZXMgbm90IHBvaW50IHRvIGEgYnJhbmNoIgogbXNnc3RyICIiCiAKLSM6IHJlbW90ZS5jOjE2MzMKLSMsIGMtZm9ybWF0Ci1tc2dpZCAibm8gc3VjaCBicmFuY2g6ICclcyciCi1tc2dzdHIgIiIKLQogIzogcmVtb3RlLmM6MTYzNgogIywgYy1mb3JtYXQKK21zZ2lkICJubyBzdWNoIGJyYW5jaDogJyVzJyIKK21zZ3N0ciAiIgorCisjOiByZW1vdGUuYzoxNjM5CisjLCBjLWZvcm1hdAogbXNnaWQgIm5vIHVwc3RyZWFtIGNvbmZpZ3VyZWQgZm9yIGJyYW5jaCAnJXMnIgogbXNnc3RyICIiCiAKLSM6IHJlbW90ZS5jOjE2NDIKKyM6IHJlbW90ZS5jOjE2NDUKICMsIGMtZm9ybWF0CiBtc2dpZCAidXBzdHJlYW0gYnJhbmNoICclcycgbm90IHN0b3JlZCBhcyBhIHJlbW90ZS10cmFja2luZyBicmFuY2giCiBtc2dzdHIgIiIKIAotIzogcmVtb3RlLmM6MTY1NworIzogcmVtb3RlLmM6MTY2MAogIywgYy1mb3JtYXQKIG1zZ2lkICJwdXNoIGRlc3RpbmF0aW9uICclcycgb24gcmVtb3RlICclcycgaGFzIG5vIGxvY2FsIHRyYWNraW5nIGJyYW5jaCIKIG1zZ3N0ciAiIgogCi0jOiByZW1vdGUuYzoxNjY5CisjOiByZW1vdGUuYzoxNjcyCiAjLCBjLWZvcm1hdAogbXNnaWQgImJyYW5jaCAnJXMnIGhhcyBubyByZW1vdGUgZm9yIHB1c2hpbmciCiBtc2dzdHIgIiIKIAotIzogcmVtb3RlLmM6MTY3OQorIzogcmVtb3RlLmM6MTY4MgogIywgYy1mb3JtYXQKIG1zZ2lkICJwdXNoIHJlZnNwZWNzIGZvciAnJXMnIGRvIG5vdCBpbmNsdWRlICclcyciCiBtc2dzdHIgIiIKIAotIzogcmVtb3RlLmM6MTY5MgorIzogcmVtb3RlLmM6MTY5NQogbXNnaWQgInB1c2ggaGFzIG5vIGRlc3RpbmF0aW9uIChwdXNoLmRlZmF1bHQgaXMgJ25vdGhpbmcnKSIKIG1zZ3N0ciAiIgogCi0jOiByZW1vdGUuYzoxNzE0CisjOiByZW1vdGUuYzoxNzE3CiBtc2dpZCAiY2Fubm90IHJlc29sdmUgJ3NpbXBsZScgcHVzaCB0byBhIHNpbmdsZSBkZXN0aW5hdGlvbiIKIG1zZ3N0ciAiIgogCi0jOiByZW1vdGUuYzoxODQwCisjOiByZW1vdGUuYzoxODQzCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkbid0IGZpbmQgcmVtb3RlIHJlZiAlcyIKIG1zZ3N0ciAiIgogCi0jOiByZW1vdGUuYzoxODUzCisjOiByZW1vdGUuYzoxODU2CiAjLCBjLWZvcm1hdAogbXNnaWQgIiogSWdub3JpbmcgZnVubnkgcmVmICclcycgbG9jYWxseSIKIG1zZ3N0ciAiIgogCi0jOiByZW1vdGUuYzoyMDE2CisjOiByZW1vdGUuYzoyMDE5CiAjLCBjLWZvcm1hdAogbXNnaWQgIllvdXIgYnJhbmNoIGlzIGJhc2VkIG9uICclcycsIGJ1dCB0aGUgdXBzdHJlYW0gaXMgZ29uZS5cbiIKIG1zZ3N0ciAiIgogCi0jOiByZW1vdGUuYzoyMDIwCisjOiByZW1vdGUuYzoyMDIzCiBtc2dpZCAiICAodXNlIFwiZ2l0IGJyYW5jaCAtLXVuc2V0LXVwc3RyZWFtXCIgdG8gZml4dXApXG4iCiBtc2dzdHIgIiIKIAotIzogcmVtb3RlLmM6MjAyMworIzogcmVtb3RlLmM6MjAyNgogIywgYy1mb3JtYXQKIG1zZ2lkICJZb3VyIGJyYW5jaCBpcyB1cCB0byBkYXRlIHdpdGggJyVzJy5cbiIKIG1zZ3N0ciAiIgogCi0jOiByZW1vdGUuYzoyMDI3CisjOiByZW1vdGUuYzoyMDMwCiAjLCBjLWZvcm1hdAogbXNnaWQgIllvdXIgYnJhbmNoIGFuZCAnJXMnIHJlZmVyIHRvIGRpZmZlcmVudCBjb21taXRzLlxuIgogbXNnc3RyICIiCiAKLSM6IHJlbW90ZS5jOjIwMzAKKyM6IHJlbW90ZS5jOjIwMzMKICMsIGMtZm9ybWF0CiBtc2dpZCAiICAodXNlIFwiJXNcIiBmb3IgZGV0YWlscylcbiIKIG1zZ3N0ciAiIgogCi0jOiByZW1vdGUuYzoyMDM0CisjOiByZW1vdGUuYzoyMDM3CiAjLCBjLWZvcm1hdAogbXNnaWQgIllvdXIgYnJhbmNoIGlzIGFoZWFkIG9mICclcycgYnkgJWQgY29tbWl0LlxuIgogbXNnaWRfcGx1cmFsICJZb3VyIGJyYW5jaCBpcyBhaGVhZCBvZiAnJXMnIGJ5ICVkIGNvbW1pdHMuXG4iCiBtc2dzdHJbMF0gIiIKIG1zZ3N0clsxXSAiIgogCi0jOiByZW1vdGUuYzoyMDQwCisjOiByZW1vdGUuYzoyMDQzCiBtc2dpZCAiICAodXNlIFwiZ2l0IHB1c2hcIiB0byBwdWJsaXNoIHlvdXIgbG9jYWwgY29tbWl0cylcbiIKIG1zZ3N0ciAiIgogCi0jOiByZW1vdGUuYzoyMDQzCisjOiByZW1vdGUuYzoyMDQ2CiAjLCBjLWZvcm1hdAogbXNnaWQgIllvdXIgYnJhbmNoIGlzIGJlaGluZCAnJXMnIGJ5ICVkIGNvbW1pdCwgYW5kIGNhbiBiZSBmYXN0LWZvcndhcmRlZC5cbiIKIG1zZ2lkX3BsdXJhbCAiIgpAQCAtNTE2OSwxMSArNTIwMiwxMSBAQAogbXNnc3RyWzBdICIiCiBtc2dzdHJbMV0gIiIKIAotIzogcmVtb3RlLmM6MjA1MQorIzogcmVtb3RlLmM6MjA1NAogbXNnaWQgIiAgKHVzZSBcImdpdCBwdWxsXCIgdG8gdXBkYXRlIHlvdXIgbG9jYWwgYnJhbmNoKVxuIgogbXNnc3RyICIiCiAKLSM6IHJlbW90ZS5jOjIwNTQKKyM6IHJlbW90ZS5jOjIwNTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIllvdXIgYnJhbmNoIGFuZCAnJXMnIGhhdmUgZGl2ZXJnZWQsXG4iCkBAIC01MTg0LDExICs1MjE3LDExIEBACiBtc2dzdHJbMF0gIiIKIG1zZ3N0clsxXSAiIgogCi0jOiByZW1vdGUuYzoyMDY0CisjOiByZW1vdGUuYzoyMDY3CiBtc2dpZCAiICAodXNlIFwiZ2l0IHB1bGxcIiB0byBtZXJnZSB0aGUgcmVtb3RlIGJyYW5jaCBpbnRvIHlvdXJzKVxuIgogbXNnc3RyICIiCiAKLSM6IHJlbW90ZS5jOjIyNDcKKyM6IHJlbW90ZS5jOjIyNTAKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IHBhcnNlIGV4cGVjdGVkIG9iamVjdCBuYW1lICclcyciCiBtc2dzdHIgIiIKQEAgLTUyNjYsNyArNTI5OSw3IEBACiBtc2dpZCAiUmVjb3JkZWQgcHJlaW1hZ2UgZm9yICclcyciCiBtc2dzdHIgIiIKIAotIzogcmVyZXJlLmM6ODgxIHN1Ym1vZHVsZS5jOjIwMjMgYnVpbHRpbi9sb2cuYzoxNzczCisjOiByZXJlcmUuYzo4ODEgc3VibW9kdWxlLmM6MjAyMyBidWlsdGluL2xvZy5jOjE3OTAKICM6IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxNDE4IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxNDI4CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBjcmVhdGUgZGlyZWN0b3J5ICclcyciCkBAIC01MzAxLDIwICs1MzM0LDIwIEBACiBtc2dpZCAidW5hYmxlIHRvIG9wZW4gcnItY2FjaGUgZGlyZWN0b3J5IgogbXNnc3RyICIiCiAKLSM6IHJldmlzaW9uLmM6MjUwNworIzogcmV2aXNpb24uYzoyNTA5CiBtc2dpZCAieW91ciBjdXJyZW50IGJyYW5jaCBhcHBlYXJzIHRvIGJlIGJyb2tlbiIKIG1zZ3N0ciAiIgogCi0jOiByZXZpc2lvbi5jOjI1MTAKKyM6IHJldmlzaW9uLmM6MjUxMgogIywgYy1mb3JtYXQKIG1zZ2lkICJ5b3VyIGN1cnJlbnQgYnJhbmNoICclcycgZG9lcyBub3QgaGF2ZSBhbnkgY29tbWl0cyB5ZXQiCiBtc2dzdHIgIiIKIAotIzogcmV2aXNpb24uYzoyNzEwCisjOiByZXZpc2lvbi5jOjI3MjAKIG1zZ2lkICItLWZpcnN0LXBhcmVudCBpcyBpbmNvbXBhdGlibGUgd2l0aCAtLWJpc2VjdCIKIG1zZ3N0ciAiIgogCi0jOiByZXZpc2lvbi5jOjI3MTQKKyM6IHJldmlzaW9uLmM6MjcyNAogbXNnaWQgIi1MIGRvZXMgbm90IHlldCBzdXBwb3J0IGRpZmYgZm9ybWF0cyBiZXNpZGVzIC1wIGFuZCAtcyIKIG1zZ3N0ciAiIgogCkBAIC01MzM0LDM5ICs1MzY3LDM5IEBACiAiWW91IGNhbiBkaXNhYmxlIHRoaXMgd2FybmluZyB3aXRoIGBnaXQgY29uZmlnIGFkdmljZS5pZ25vcmVkSG9vayBmYWxzZWAuIgogbXNnc3RyICIiCiAKLSM6IHNlbmQtcGFjay5jOjE0MQorIzogc2VuZC1wYWNrLmM6MTQyCiBtc2dpZCAidW5leHBlY3RlZCBmbHVzaCBwYWNrZXQgd2hpbGUgcmVhZGluZyByZW1vdGUgdW5wYWNrIHN0YXR1cyIKIG1zZ3N0ciAiIgogCi0jOiBzZW5kLXBhY2suYzoxNDMKKyM6IHNlbmQtcGFjay5jOjE0NAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gcGFyc2UgcmVtb3RlIHVucGFjayBzdGF0dXM6ICVzIgogbXNnc3RyICIiCiAKLSM6IHNlbmQtcGFjay5jOjE0NQorIzogc2VuZC1wYWNrLmM6MTQ2CiAjLCBjLWZvcm1hdAogbXNnaWQgInJlbW90ZSB1bnBhY2sgZmFpbGVkOiAlcyIKIG1zZ3N0ciAiIgogCi0jOiBzZW5kLXBhY2suYzozMDYKKyM6IHNlbmQtcGFjay5jOjMwNwogbXNnaWQgImZhaWxlZCB0byBzaWduIHRoZSBwdXNoIGNlcnRpZmljYXRlIgogbXNnc3RyICIiCiAKLSM6IHNlbmQtcGFjay5jOjQyMAorIzogc2VuZC1wYWNrLmM6NDIxCiBtc2dpZCAidGhlIHJlY2VpdmluZyBlbmQgZG9lcyBub3Qgc3VwcG9ydCAtLXNpZ25lZCBwdXNoIgogbXNnc3RyICIiCiAKLSM6IHNlbmQtcGFjay5jOjQyMgorIzogc2VuZC1wYWNrLmM6NDIzCiBtc2dpZCAiIgogIm5vdCBzZW5kaW5nIGEgcHVzaCBjZXJ0aWZpY2F0ZSBzaW5jZSB0aGUgcmVjZWl2aW5nIGVuZCBkb2VzIG5vdCBzdXBwb3J0IC0tIgogInNpZ25lZCBwdXNoIgogbXNnc3RyICIiCiAKLSM6IHNlbmQtcGFjay5jOjQzNAorIzogc2VuZC1wYWNrLmM6NDM1CiBtc2dpZCAidGhlIHJlY2VpdmluZyBlbmQgZG9lcyBub3Qgc3VwcG9ydCAtLWF0b21pYyBwdXNoIgogbXNnc3RyICIiCiAKLSM6IHNlbmQtcGFjay5jOjQzOQorIzogc2VuZC1wYWNrLmM6NDQwCiBtc2dpZCAidGhlIHJlY2VpdmluZyBlbmQgZG9lcyBub3Qgc3VwcG9ydCBwdXNoIG9wdGlvbnMiCiBtc2dzdHIgIiIKIApAQCAtNTM4MCw3ICs1NDEzLDcgQEAKIG1zZ2lkICJjb3VsZCBub3QgZGVsZXRlICclcyciCiBtc2dzdHIgIiIKIAotIzogc2VxdWVuY2VyLmM6MzExIGJ1aWx0aW4vcmViYXNlLmM6NzU5IGJ1aWx0aW4vcmViYXNlLmM6MTY0NSBidWlsdGluL3JtLmM6MzY5CisjOiBzZXF1ZW5jZXIuYzozMTEgYnVpbHRpbi9yZWJhc2UuYzo3NjAgYnVpbHRpbi9yZWJhc2UuYzoxNjc2IGJ1aWx0aW4vcm0uYzozNjkKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHJlbW92ZSAnJXMnIgogbXNnc3RyICIiCkBAIC01NDE1LDcgKzU0NDgsNyBAQAogImFuZCBjb21taXQgdGhlIHJlc3VsdCB3aXRoICdnaXQgY29tbWl0JyIKIG1zZ3N0ciAiIgogCi0jOiBzZXF1ZW5jZXIuYzo0MDEgc2VxdWVuY2VyLmM6MjkwOQorIzogc2VxdWVuY2VyLmM6NDAxIHNlcXVlbmNlci5jOjI4NDcKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGxvY2sgJyVzJyIKIG1zZ3N0ciAiIgpAQCAtNTQyNSwxNSArNTQ1OCwxNSBAQAogbXNnaWQgImNvdWxkIG5vdCB3cml0ZSBlb2wgdG8gJyVzJyIKIG1zZ3N0ciAiIgogCi0jOiBzZXF1ZW5jZXIuYzo0MTMgc2VxdWVuY2VyLmM6MjcxNCBzZXF1ZW5jZXIuYzoyOTE1IHNlcXVlbmNlci5jOjI5MjkKLSM6IHNlcXVlbmNlci5jOjMxOTIKKyM6IHNlcXVlbmNlci5jOjQxMyBzZXF1ZW5jZXIuYzoyNjUyIHNlcXVlbmNlci5jOjI4NTMgc2VxdWVuY2VyLmM6Mjg2NworIzogc2VxdWVuY2VyLmM6MzEzMAogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gZmluYWxpemUgJyVzJyIKIG1zZ3N0ciAiIgogCi0jOiBzZXF1ZW5jZXIuYzo0MzYgc2VxdWVuY2VyLmM6OTgxIHNlcXVlbmNlci5jOjE2NTUgc2VxdWVuY2VyLmM6MjczNAotIzogc2VxdWVuY2VyLmM6MzE3NCBzZXF1ZW5jZXIuYzozMjgzIGJ1aWx0aW4vYW0uYzoyNDUgYnVpbHRpbi9jb21taXQuYzo3NjMKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxMTEyIGJ1aWx0aW4vcmViYXNlLmM6NTY3CisjOiBzZXF1ZW5jZXIuYzo0MzYgc2VxdWVuY2VyLmM6MTU4NSBzZXF1ZW5jZXIuYzoyNjcyIHNlcXVlbmNlci5jOjMxMTIKKyM6IHNlcXVlbmNlci5jOjMyMjEgYnVpbHRpbi9hbS5jOjI0NCBidWlsdGluL2NvbW1pdC5jOjc2MyBidWlsdGluL21lcmdlLmM6MTExNworIzogYnVpbHRpbi9yZWJhc2UuYzo1NjgKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHJlYWQgJyVzJyIKIG1zZ3N0ciAiIgpAQCAtNTQ2MCw3MCArNTQ5Myw2NSBAQAogIy4gVFJBTlNMQVRPUlM6ICVzIHdpbGwgYmUgInJldmVydCIsICJjaGVycnktcGljayIgb3IKICMuICJyZWJhc2UgLWkiLgogIy4KLSM6IHNlcXVlbmNlci5jOjYzMgorIzogc2VxdWVuY2VyLmM6NjMxCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiBVbmFibGUgdG8gd3JpdGUgbmV3IGluZGV4IGZpbGUiCiBtc2dzdHIgIiIKIAotIzogc2VxdWVuY2VyLmM6NjQ5CisjOiBzZXF1ZW5jZXIuYzo2NDgKIG1zZ2lkICJ1bmFibGUgdG8gdXBkYXRlIGNhY2hlIHRyZWUiCiBtc2dzdHIgIiIKIAotIzogc2VxdWVuY2VyLmM6NjYzCisjOiBzZXF1ZW5jZXIuYzo2NjIKIG1zZ2lkICJjb3VsZCBub3QgcmVzb2x2ZSBIRUFEIGNvbW1pdCIKIG1zZ3N0ciAiIgogCi0jOiBzZXF1ZW5jZXIuYzo3NDMKKyM6IHNlcXVlbmNlci5jOjc0MgogIywgYy1mb3JtYXQKIG1zZ2lkICJubyBrZXkgcHJlc2VudCBpbiAnJS4qcyciCiBtc2dzdHIgIiIKIAotIzogc2VxdWVuY2VyLmM6NzU0CisjOiBzZXF1ZW5jZXIuYzo3NTMKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGRlcXVvdGUgdmFsdWUgb2YgJyVzJyIKIG1zZ3N0ciAiIgogCi0jOiBzZXF1ZW5jZXIuYzo3OTEgd3JhcHBlci5jOjIyNyB3cmFwcGVyLmM6Mzk3IGJ1aWx0aW4vYW0uYzo3MDYKLSM6IGJ1aWx0aW4vYW0uYzo3OTggYnVpbHRpbi9tZXJnZS5jOjExMDkgYnVpbHRpbi9yZWJhc2UuYzoxMDQ1CisjOiBzZXF1ZW5jZXIuYzo3OTAgd3JhcHBlci5jOjE5MCB3cmFwcGVyLmM6MzYwIGJ1aWx0aW4vYW0uYzo3MDUKKyM6IGJ1aWx0aW4vYW0uYzo3OTcgYnVpbHRpbi9tZXJnZS5jOjExMTQgYnVpbHRpbi9yZWJhc2UuYzoxMDQ2CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBvcGVuICclcycgZm9yIHJlYWRpbmciCiBtc2dzdHIgIiIKIAotIzogc2VxdWVuY2VyLmM6ODAxCisjOiBzZXF1ZW5jZXIuYzo4MDAKIG1zZ2lkICInR0lUX0FVVEhPUl9OQU1FJyBhbHJlYWR5IGdpdmVuIgogbXNnc3RyICIiCiAKLSM6IHNlcXVlbmNlci5jOjgwNgorIzogc2VxdWVuY2VyLmM6ODA1CiBtc2dpZCAiJ0dJVF9BVVRIT1JfRU1BSUwnIGFscmVhZHkgZ2l2ZW4iCiBtc2dzdHIgIiIKIAotIzogc2VxdWVuY2VyLmM6ODExCisjOiBzZXF1ZW5jZXIuYzo4MTAKIG1zZ2lkICInR0lUX0FVVEhPUl9EQVRFJyBhbHJlYWR5IGdpdmVuIgogbXNnc3RyICIiCiAKLSM6IHNlcXVlbmNlci5jOjgxNQorIzogc2VxdWVuY2VyLmM6ODE0CiAjLCBjLWZvcm1hdAogbXNnaWQgInVua25vd24gdmFyaWFibGUgJyVzJyIKIG1zZ3N0ciAiIgogCi0jOiBzZXF1ZW5jZXIuYzo4MjAKKyM6IHNlcXVlbmNlci5jOjgxOQogbXNnaWQgIm1pc3NpbmcgJ0dJVF9BVVRIT1JfTkFNRSciCiBtc2dzdHIgIiIKIAotIzogc2VxdWVuY2VyLmM6ODIyCisjOiBzZXF1ZW5jZXIuYzo4MjEKIG1zZ2lkICJtaXNzaW5nICdHSVRfQVVUSE9SX0VNQUlMJyIKIG1zZ3N0ciAiIgogCi0jOiBzZXF1ZW5jZXIuYzo4MjQKKyM6IHNlcXVlbmNlci5jOjgyMwogbXNnaWQgIm1pc3NpbmcgJ0dJVF9BVVRIT1JfREFURSciCiBtc2dzdHIgIiIKIAotIzogc2VxdWVuY2VyLmM6ODg0Ci0jLCBjLWZvcm1hdAotbXNnaWQgImludmFsaWQgZGF0ZSBmb3JtYXQgJyVzJyBpbiAnJXMnIgotbXNnc3RyICIiCi0KLSM6IHNlcXVlbmNlci5jOjkwMQorIzogc2VxdWVuY2VyLmM6ODcyCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJ5b3UgaGF2ZSBzdGFnZWQgY2hhbmdlcyBpbiB5b3VyIHdvcmtpbmcgdHJlZVxuIgpAQCAtNTU0MCwxNSArNTU2OCwxMSBAQAogIiAgZ2l0IHJlYmFzZSAtLWNvbnRpbnVlXG4iCiBtc2dzdHIgIiIKIAotIzogc2VxdWVuY2VyLmM6OTk1Ci1tc2dpZCAid3JpdGluZyByb290IGNvbW1pdCIKLW1zZ3N0ciAiIgotCi0jOiBzZXF1ZW5jZXIuYzoxMjE2CisjOiBzZXF1ZW5jZXIuYzoxMTQ2CiBtc2dpZCAiJ3ByZXBhcmUtY29tbWl0LW1zZycgaG9vayBmYWlsZWQiCiBtc2dzdHIgIiIKIAotIzogc2VxdWVuY2VyLmM6MTIyMworIzogc2VxdWVuY2VyLmM6MTE1MwogbXNnaWQgIiIKICJZb3VyIG5hbWUgYW5kIGVtYWlsIGFkZHJlc3Mgd2VyZSBjb25maWd1cmVkIGF1dG9tYXRpY2FsbHkgYmFzZWRcbiIKICJvbiB5b3VyIHVzZXJuYW1lIGFuZCBob3N0bmFtZS4gUGxlYXNlIGNoZWNrIHRoYXQgdGhleSBhcmUgYWNjdXJhdGUuXG4iCkBAIC01NTYzLDcgKzU1ODcsNyBAQAogIiAgICBnaXQgY29tbWl0IC0tYW1lbmQgLS1yZXNldC1hdXRob3JcbiIKIG1zZ3N0ciAiIgogCi0jOiBzZXF1ZW5jZXIuYzoxMjM2CisjOiBzZXF1ZW5jZXIuYzoxMTY2CiBtc2dpZCAiIgogIllvdXIgbmFtZSBhbmQgZW1haWwgYWRkcmVzcyB3ZXJlIGNvbmZpZ3VyZWQgYXV0b21hdGljYWxseSBiYXNlZFxuIgogIm9uIHlvdXIgdXNlcm5hbWUgYW5kIGhvc3RuYW1lLiBQbGVhc2UgY2hlY2sgdGhhdCB0aGV5IGFyZSBhY2N1cmF0ZS5cbiIKQEAgLTU1NzcsMzQ2ICs1NjAxLDM0NiBAQAogIiAgICBnaXQgY29tbWl0IC0tYW1lbmQgLS1yZXNldC1hdXRob3JcbiIKIG1zZ3N0ciAiIgogCi0jOiBzZXF1ZW5jZXIuYzoxMjc4CisjOiBzZXF1ZW5jZXIuYzoxMjA4CiBtc2dpZCAiY291bGRuJ3QgbG9vayB1cCBuZXdseSBjcmVhdGVkIGNvbW1pdCIKIG1zZ3N0ciAiIgogCi0jOiBzZXF1ZW5jZXIuYzoxMjgwCisjOiBzZXF1ZW5jZXIuYzoxMjEwCiBtc2dpZCAiY291bGQgbm90IHBhcnNlIG5ld2x5IGNyZWF0ZWQgY29tbWl0IgogbXNnc3RyICIiCiAKLSM6IHNlcXVlbmNlci5jOjEzMjYKKyM6IHNlcXVlbmNlci5jOjEyNTYKIG1zZ2lkICJ1bmFibGUgdG8gcmVzb2x2ZSBIRUFEIGFmdGVyIGNyZWF0aW5nIGNvbW1pdCIKIG1zZ3N0ciAiIgogCi0jOiBzZXF1ZW5jZXIuYzoxMzI4CisjOiBzZXF1ZW5jZXIuYzoxMjU4CiBtc2dpZCAiZGV0YWNoZWQgSEVBRCIKIG1zZ3N0ciAiIgogCi0jOiBzZXF1ZW5jZXIuYzoxMzMyCisjOiBzZXF1ZW5jZXIuYzoxMjYyCiBtc2dpZCAiIChyb290LWNvbW1pdCkiCiBtc2dzdHIgIiIKIAotIzogc2VxdWVuY2VyLmM6MTM1MworIzogc2VxdWVuY2VyLmM6MTI4MwogbXNnaWQgImNvdWxkIG5vdCBwYXJzZSBIRUFEIgogbXNnc3RyICIiCiAKLSM6IHNlcXVlbmNlci5jOjEzNTUKKyM6IHNlcXVlbmNlci5jOjEyODUKICMsIGMtZm9ybWF0CiBtc2dpZCAiSEVBRCAlcyBpcyBub3QgYSBjb21taXQhIgogbXNnc3RyICIiCiAKLSM6IHNlcXVlbmNlci5jOjEzNTkgYnVpbHRpbi9jb21taXQuYzoxNTcxCisjOiBzZXF1ZW5jZXIuYzoxMjg5IGJ1aWx0aW4vY29tbWl0LmM6MTU3MQogbXNnaWQgImNvdWxkIG5vdCBwYXJzZSBIRUFEIGNvbW1pdCIKIG1zZ3N0ciAiIgogCi0jOiBzZXF1ZW5jZXIuYzoxNDExIHNlcXVlbmNlci5jOjIwMDQKKyM6IHNlcXVlbmNlci5jOjEzNDEgc2VxdWVuY2VyLmM6MTkzMwogbXNnaWQgInVuYWJsZSB0byBwYXJzZSBjb21taXQgYXV0aG9yIgogbXNnc3RyICIiCiAKLSM6IHNlcXVlbmNlci5jOjE0MjEgYnVpbHRpbi9hbS5jOjE1NzMgYnVpbHRpbi9tZXJnZS5jOjY4NAorIzogc2VxdWVuY2VyLmM6MTM1MiBidWlsdGluL2FtLmM6MTU2MSBidWlsdGluL21lcmdlLmM6Njg0CiBtc2dpZCAiZ2l0IHdyaXRlLXRyZWUgZmFpbGVkIHRvIHdyaXRlIGEgdHJlZSIKIG1zZ3N0ciAiIgogCi0jOiBzZXF1ZW5jZXIuYzoxNDM4IHNlcXVlbmNlci5jOjE0OTkKKyM6IHNlcXVlbmNlci5jOjEzNjkgc2VxdWVuY2VyLmM6MTQyOQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gcmVhZCBjb21taXQgbWVzc2FnZSBmcm9tICclcyciCiBtc2dzdHIgIiIKIAotIzogc2VxdWVuY2VyLmM6MTQ2NSBidWlsdGluL2FtLmM6MTU5NSBidWlsdGluL2NvbW1pdC5jOjE2NzAgYnVpbHRpbi9tZXJnZS5jOjg3OAotIzogYnVpbHRpbi9tZXJnZS5jOjkwMworIzogc2VxdWVuY2VyLmM6MTM5NiBidWlsdGluL2FtLmM6MTU4MyBidWlsdGluL2NvbW1pdC5jOjE2NzAgYnVpbHRpbi9tZXJnZS5jOjg4MworIzogYnVpbHRpbi9tZXJnZS5jOjkwOAogbXNnaWQgImZhaWxlZCB0byB3cml0ZSBjb21taXQgb2JqZWN0IgogbXNnc3RyICIiCiAKLSM6IHNlcXVlbmNlci5jOjE1MjYKKyM6IHNlcXVlbmNlci5jOjE0NTYKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHBhcnNlIGNvbW1pdCAlcyIKIG1zZ3N0ciAiIgogCi0jOiBzZXF1ZW5jZXIuYzoxNTMxCisjOiBzZXF1ZW5jZXIuYzoxNDYxCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBwYXJzZSBwYXJlbnQgY29tbWl0ICVzIgogbXNnc3RyICIiCiAKLSM6IHNlcXVlbmNlci5jOjE2MDUgc2VxdWVuY2VyLmM6MTcxNQorIzogc2VxdWVuY2VyLmM6MTUzNSBzZXF1ZW5jZXIuYzoxNjQ1CiAjLCBjLWZvcm1hdAogbXNnaWQgInVua25vd24gY29tbWFuZDogJWQiCiBtc2dzdHIgIiIKIAotIzogc2VxdWVuY2VyLmM6MTY2MiBzZXF1ZW5jZXIuYzoxNjg3CisjOiBzZXF1ZW5jZXIuYzoxNTkyIHNlcXVlbmNlci5jOjE2MTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiVGhpcyBpcyBhIGNvbWJpbmF0aW9uIG9mICVkIGNvbW1pdHMuIgogbXNnc3RyICIiCiAKLSM6IHNlcXVlbmNlci5jOjE2NzIKKyM6IHNlcXVlbmNlci5jOjE2MDIKIG1zZ2lkICJuZWVkIGEgSEVBRCB0byBmaXh1cCIKIG1zZ3N0ciAiIgogCi0jOiBzZXF1ZW5jZXIuYzoxNjc0IHNlcXVlbmNlci5jOjMyMTkKKyM6IHNlcXVlbmNlci5jOjE2MDQgc2VxdWVuY2VyLmM6MzE1NwogbXNnaWQgImNvdWxkIG5vdCByZWFkIEhFQUQiCiBtc2dzdHIgIiIKIAotIzogc2VxdWVuY2VyLmM6MTY3NgorIzogc2VxdWVuY2VyLmM6MTYwNgogbXNnaWQgImNvdWxkIG5vdCByZWFkIEhFQUQncyBjb21taXQgbWVzc2FnZSIKIG1zZ3N0ciAiIgogCi0jOiBzZXF1ZW5jZXIuYzoxNjgyCisjOiBzZXF1ZW5jZXIuYzoxNjEyCiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCB3cml0ZSAnJXMnIgogbXNnc3RyICIiCiAKLSM6IHNlcXVlbmNlci5jOjE2ODkgZ2l0LXJlYmFzZS0tcHJlc2VydmUtbWVyZ2VzLnNoOjQ5NgorIzogc2VxdWVuY2VyLmM6MTYxOSBnaXQtcmViYXNlLS1wcmVzZXJ2ZS1tZXJnZXMuc2g6NDk2CiBtc2dpZCAiVGhpcyBpcyB0aGUgMXN0IGNvbW1pdCBtZXNzYWdlOiIKIG1zZ3N0ciAiIgogCi0jOiBzZXF1ZW5jZXIuYzoxNjk3CisjOiBzZXF1ZW5jZXIuYzoxNjI3CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCByZWFkIGNvbW1pdCBtZXNzYWdlIG9mICVzIgogbXNnc3RyICIiCiAKLSM6IHNlcXVlbmNlci5jOjE3MDQKKyM6IHNlcXVlbmNlci5jOjE2MzQKICMsIGMtZm9ybWF0CiBtc2dpZCAiVGhpcyBpcyB0aGUgY29tbWl0IG1lc3NhZ2UgIyVkOiIKIG1zZ3N0ciAiIgogCi0jOiBzZXF1ZW5jZXIuYzoxNzEwCisjOiBzZXF1ZW5jZXIuYzoxNjQwCiAjLCBjLWZvcm1hdAogbXNnaWQgIlRoZSBjb21taXQgbWVzc2FnZSAjJWQgd2lsbCBiZSBza2lwcGVkOiIKIG1zZ3N0ciAiIgogCi0jOiBzZXF1ZW5jZXIuYzoxNzk4CisjOiBzZXF1ZW5jZXIuYzoxNzI4CiBtc2dpZCAieW91ciBpbmRleCBmaWxlIGlzIHVubWVyZ2VkLiIKIG1zZ3N0ciAiIgogCi0jOiBzZXF1ZW5jZXIuYzoxODA1CisjOiBzZXF1ZW5jZXIuYzoxNzM1CiBtc2dpZCAiY2Fubm90IGZpeHVwIHJvb3QgY29tbWl0IgogbXNnc3RyICIiCiAKLSM6IHNlcXVlbmNlci5jOjE4MjQKKyM6IHNlcXVlbmNlci5jOjE3NTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiY29tbWl0ICVzIGlzIGEgbWVyZ2UgYnV0IG5vIC1tIG9wdGlvbiB3YXMgZ2l2ZW4uIgogbXNnc3RyICIiCiAKLSM6IHNlcXVlbmNlci5jOjE4MzIgc2VxdWVuY2VyLmM6MTg0MAorIzogc2VxdWVuY2VyLmM6MTc2MiBzZXF1ZW5jZXIuYzoxNzcwCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvbW1pdCAlcyBkb2VzIG5vdCBoYXZlIHBhcmVudCAlZCIKIG1zZ3N0ciAiIgogCi0jOiBzZXF1ZW5jZXIuYzoxODQ2CisjOiBzZXF1ZW5jZXIuYzoxNzc2CiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCBnZXQgY29tbWl0IG1lc3NhZ2UgZm9yICVzIgogbXNnc3RyICIiCiAKICMuIFRSQU5TTEFUT1JTOiBUaGUgZmlyc3QgJXMgd2lsbCBiZSBhICJ0b2RvIiBjb21tYW5kIGxpa2UKICMuICJyZXZlcnQiIG9yICJwaWNrIiwgdGhlIHNlY29uZCAlcyBhIFNIQTEuCi0jOiBzZXF1ZW5jZXIuYzoxODY1CisjOiBzZXF1ZW5jZXIuYzoxNzk1CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiBjYW5ub3QgcGFyc2UgcGFyZW50IGNvbW1pdCAlcyIKIG1zZ3N0ciAiIgogCi0jOiBzZXF1ZW5jZXIuYzoxOTMwCisjOiBzZXF1ZW5jZXIuYzoxODYwCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCByZW5hbWUgJyVzJyB0byAnJXMnIgogbXNnc3RyICIiCiAKLSM6IHNlcXVlbmNlci5jOjE5ODUKKyM6IHNlcXVlbmNlci5jOjE5MTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHJldmVydCAlcy4uLiAlcyIKIG1zZ3N0ciAiIgogCi0jOiBzZXF1ZW5jZXIuYzoxOTg2CisjOiBzZXF1ZW5jZXIuYzoxOTE2CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBhcHBseSAlcy4uLiAlcyIKIG1zZ3N0ciAiIgogCi0jOiBzZXF1ZW5jZXIuYzoyMDQ1CisjOiBzZXF1ZW5jZXIuYzoxOTgzCiAjLCBjLWZvcm1hdAogbXNnaWQgImdpdCAlczogZmFpbGVkIHRvIHJlYWQgdGhlIGluZGV4IgogbXNnc3RyICIiCiAKLSM6IHNlcXVlbmNlci5jOjIwNTIKKyM6IHNlcXVlbmNlci5jOjE5OTAKICMsIGMtZm9ybWF0CiBtc2dpZCAiZ2l0ICVzOiBmYWlsZWQgdG8gcmVmcmVzaCB0aGUgaW5kZXgiCiBtc2dzdHIgIiIKIAotIzogc2VxdWVuY2VyLmM6MjEyOAorIzogc2VxdWVuY2VyLmM6MjA2NgogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyBkb2VzIG5vdCBhY2NlcHQgYXJndW1lbnRzOiAnJXMnIgogbXNnc3RyICIiCiAKLSM6IHNlcXVlbmNlci5jOjIxMzcKKyM6IHNlcXVlbmNlci5jOjIwNzUKICMsIGMtZm9ybWF0CiBtc2dpZCAibWlzc2luZyBhcmd1bWVudHMgZm9yICVzIgogbXNnc3RyICIiCiAKLSM6IHNlcXVlbmNlci5jOjIxNzQKKyM6IHNlcXVlbmNlci5jOjIxMTIKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHBhcnNlICclLipzJyIKIG1zZ3N0ciAiIgogCi0jOiBzZXF1ZW5jZXIuYzoyMjI4CisjOiBzZXF1ZW5jZXIuYzoyMTY2CiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgbGluZSAlZDogJS4qcyIKIG1zZ3N0ciAiIgogCi0jOiBzZXF1ZW5jZXIuYzoyMjM5CisjOiBzZXF1ZW5jZXIuYzoyMTc3CiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCAnJXMnIHdpdGhvdXQgYSBwcmV2aW91cyBjb21taXQiCiBtc2dzdHIgIiIKIAotIzogc2VxdWVuY2VyLmM6MjI4NyBidWlsdGluL3JlYmFzZS5jOjE1MyBidWlsdGluL3JlYmFzZS5jOjE3OAorIzogc2VxdWVuY2VyLmM6MjIyNSBidWlsdGluL3JlYmFzZS5jOjE1MyBidWlsdGluL3JlYmFzZS5jOjE3OAogIzogYnVpbHRpbi9yZWJhc2UuYzoyMDQgYnVpbHRpbi9yZWJhc2UuYzoyMjkKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHJlYWQgJyVzJy4iCiBtc2dzdHIgIiIKIAotIzogc2VxdWVuY2VyLmM6MjMyMworIzogc2VxdWVuY2VyLmM6MjI2MQogbXNnaWQgImNhbmNlbGxpbmcgYSBjaGVycnkgcGlja2luZyBpbiBwcm9ncmVzcyIKIG1zZ3N0ciAiIgogCi0jOiBzZXF1ZW5jZXIuYzoyMzMwCisjOiBzZXF1ZW5jZXIuYzoyMjY4CiBtc2dpZCAiY2FuY2VsbGluZyBhIHJldmVydCBpbiBwcm9ncmVzcyIKIG1zZ3N0ciAiIgogCi0jOiBzZXF1ZW5jZXIuYzoyMzY0CisjOiBzZXF1ZW5jZXIuYzoyMzAyCiBtc2dpZCAicGxlYXNlIGZpeCB0aGlzIHVzaW5nICdnaXQgcmViYXNlIC0tZWRpdC10b2RvJy4iCiBtc2dzdHIgIiIKIAotIzogc2VxdWVuY2VyLmM6MjM2NgorIzogc2VxdWVuY2VyLmM6MjMwNAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bnVzYWJsZSBpbnN0cnVjdGlvbiBzaGVldDogJyVzJyIKIG1zZ3N0ciAiIgogCi0jOiBzZXF1ZW5jZXIuYzoyMzcxCisjOiBzZXF1ZW5jZXIuYzoyMzA5CiBtc2dpZCAibm8gY29tbWl0cyBwYXJzZWQuIgogbXNnc3RyICIiCiAKLSM6IHNlcXVlbmNlci5jOjIzODIKKyM6IHNlcXVlbmNlci5jOjIzMjAKIG1zZ2lkICJjYW5ub3QgY2hlcnJ5LXBpY2sgZHVyaW5nIGEgcmV2ZXJ0LiIKIG1zZ3N0ciAiIgogCi0jOiBzZXF1ZW5jZXIuYzoyMzg0CisjOiBzZXF1ZW5jZXIuYzoyMzIyCiBtc2dpZCAiY2Fubm90IHJldmVydCBkdXJpbmcgYSBjaGVycnktcGljay4iCiBtc2dzdHIgIiIKIAotIzogc2VxdWVuY2VyLmM6MjQ2NgorIzogc2VxdWVuY2VyLmM6MjQwNAogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIHZhbHVlIGZvciAlczogJXMiCiBtc2dzdHIgIiIKIAotIzogc2VxdWVuY2VyLmM6MjU1MworIzogc2VxdWVuY2VyLmM6MjQ5MQogbXNnaWQgInVudXNhYmxlIHNxdWFzaC1vbnRvIgogbXNnc3RyICIiCiAKLSM6IHNlcXVlbmNlci5jOjI1NjkKKyM6IHNlcXVlbmNlci5jOjI1MDcKICMsIGMtZm9ybWF0CiBtc2dpZCAibWFsZm9ybWVkIG9wdGlvbnMgc2hlZXQ6ICclcyciCiBtc2dzdHIgIiIKIAotIzogc2VxdWVuY2VyLmM6MjY1MiBzZXF1ZW5jZXIuYzo0MzUxCisjOiBzZXF1ZW5jZXIuYzoyNTkwIHNlcXVlbmNlci5jOjQzMDgKIG1zZ2lkICJlbXB0eSBjb21taXQgc2V0IHBhc3NlZCIKIG1zZ3N0ciAiIgogCi0jOiBzZXF1ZW5jZXIuYzoyNjY4CisjOiBzZXF1ZW5jZXIuYzoyNjA2CiBtc2dpZCAicmV2ZXJ0IGlzIGFscmVhZHkgaW4gcHJvZ3Jlc3MiCiBtc2dzdHIgIiIKIAotIzogc2VxdWVuY2VyLmM6MjY3MAorIzogc2VxdWVuY2VyLmM6MjYwOAogIywgYy1mb3JtYXQKIG1zZ2lkICJ0cnkgXCJnaXQgcmV2ZXJ0ICgtLWNvbnRpbnVlIHwgJXMtLWFib3J0IHwgLS1xdWl0KVwiIgogbXNnc3RyICIiCiAKLSM6IHNlcXVlbmNlci5jOjI2NzMKKyM6IHNlcXVlbmNlci5jOjI2MTEKIG1zZ2lkICJjaGVycnktcGljayBpcyBhbHJlYWR5IGluIHByb2dyZXNzIgogbXNnc3RyICIiCiAKLSM6IHNlcXVlbmNlci5jOjI2NzUKKyM6IHNlcXVlbmNlci5jOjI2MTMKICMsIGMtZm9ybWF0CiBtc2dpZCAidHJ5IFwiZ2l0IGNoZXJyeS1waWNrICgtLWNvbnRpbnVlIHwgJXMtLWFib3J0IHwgLS1xdWl0KVwiIgogbXNnc3RyICIiCiAKLSM6IHNlcXVlbmNlci5jOjI2ODkKKyM6IHNlcXVlbmNlci5jOjI2MjcKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGNyZWF0ZSBzZXF1ZW5jZXIgZGlyZWN0b3J5ICclcyciCiBtc2dzdHIgIiIKIAotIzogc2VxdWVuY2VyLmM6MjcwNAorIzogc2VxdWVuY2VyLmM6MjY0MgogbXNnaWQgImNvdWxkIG5vdCBsb2NrIEhFQUQiCiBtc2dzdHIgIiIKIAotIzogc2VxdWVuY2VyLmM6Mjc2NCBzZXF1ZW5jZXIuYzo0MTAzCisjOiBzZXF1ZW5jZXIuYzoyNzAyIHNlcXVlbmNlci5jOjQwNTcKIG1zZ2lkICJubyBjaGVycnktcGljayBvciByZXZlcnQgaW4gcHJvZ3Jlc3MiCiBtc2dzdHIgIiIKIAotIzogc2VxdWVuY2VyLmM6Mjc2NiBzZXF1ZW5jZXIuYzoyNzc3CisjOiBzZXF1ZW5jZXIuYzoyNzA0IHNlcXVlbmNlci5jOjI3MTUKIG1zZ2lkICJjYW5ub3QgcmVzb2x2ZSBIRUFEIgogbXNnc3RyICIiCiAKLSM6IHNlcXVlbmNlci5jOjI3Njggc2VxdWVuY2VyLmM6MjgxMgorIzogc2VxdWVuY2VyLmM6MjcwNiBzZXF1ZW5jZXIuYzoyNzUwCiBtc2dpZCAiY2Fubm90IGFib3J0IGZyb20gYSBicmFuY2ggeWV0IHRvIGJlIGJvcm4iCiBtc2dzdHIgIiIKIAotIzogc2VxdWVuY2VyLmM6Mjc5OCBidWlsdGluL2dyZXAuYzo3MzQKKyM6IHNlcXVlbmNlci5jOjI3MzYgYnVpbHRpbi9ncmVwLmM6NzM2CiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCBvcGVuICclcyciCiBtc2dzdHIgIiIKIAotIzogc2VxdWVuY2VyLmM6MjgwMAorIzogc2VxdWVuY2VyLmM6MjczOAogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgcmVhZCAnJXMnOiAlcyIKIG1zZ3N0ciAiIgogCi0jOiBzZXF1ZW5jZXIuYzoyODAxCisjOiBzZXF1ZW5jZXIuYzoyNzM5CiBtc2dpZCAidW5leHBlY3RlZCBlbmQgb2YgZmlsZSIKIG1zZ3N0ciAiIgogCi0jOiBzZXF1ZW5jZXIuYzoyODA3CisjOiBzZXF1ZW5jZXIuYzoyNzQ1CiAjLCBjLWZvcm1hdAogbXNnaWQgInN0b3JlZCBwcmUtY2hlcnJ5LXBpY2sgSEVBRCBmaWxlICclcycgaXMgY29ycnVwdCIKIG1zZ3N0ciAiIgogCi0jOiBzZXF1ZW5jZXIuYzoyODE4CisjOiBzZXF1ZW5jZXIuYzoyNzU2CiBtc2dpZCAiWW91IHNlZW0gdG8gaGF2ZSBtb3ZlZCBIRUFELiBOb3QgcmV3aW5kaW5nLCBjaGVjayB5b3VyIEhFQUQhIgogbXNnc3RyICIiCiAKLSM6IHNlcXVlbmNlci5jOjI4NTkKKyM6IHNlcXVlbmNlci5jOjI3OTcKIG1zZ2lkICJubyByZXZlcnQgaW4gcHJvZ3Jlc3MiCiBtc2dzdHIgIiIKIAotIzogc2VxdWVuY2VyLmM6Mjg2NworIzogc2VxdWVuY2VyLmM6MjgwNQogbXNnaWQgIm5vIGNoZXJyeS1waWNrIGluIHByb2dyZXNzIgogbXNnc3RyICIiCiAKLSM6IHNlcXVlbmNlci5jOjI4NzcKKyM6IHNlcXVlbmNlci5jOjI4MTUKIG1zZ2lkICJmYWlsZWQgdG8gc2tpcCB0aGUgY29tbWl0IgogbXNnc3RyICIiCiAKLSM6IHNlcXVlbmNlci5jOjI4ODQKKyM6IHNlcXVlbmNlci5jOjI4MjIKIG1zZ2lkICJ0aGVyZSBpcyBub3RoaW5nIHRvIHNraXAiCiBtc2dzdHIgIiIKIAotIzogc2VxdWVuY2VyLmM6Mjg4NworIzogc2VxdWVuY2VyLmM6MjgyNQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiaGF2ZSB5b3UgY29tbWl0dGVkIGFscmVhZHk/XG4iCiAidHJ5IFwiZ2l0ICVzIC0tY29udGludWVcIiIKIG1zZ3N0ciAiIgogCi0jOiBzZXF1ZW5jZXIuYzozMDExIHNlcXVlbmNlci5jOjQwMTUKKyM6IHNlcXVlbmNlci5jOjI5NDkgc2VxdWVuY2VyLmM6Mzk2OQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgdXBkYXRlICVzIgogbXNnc3RyICIiCiAKLSM6IHNlcXVlbmNlci5jOjMwNDkgc2VxdWVuY2VyLmM6Mzk5NQorIzogc2VxdWVuY2VyLmM6Mjk4NyBzZXF1ZW5jZXIuYzozOTQ5CiBtc2dpZCAiY2Fubm90IHJlYWQgSEVBRCIKIG1zZ3N0ciAiIgogCi0jOiBzZXF1ZW5jZXIuYzozMDY2CisjOiBzZXF1ZW5jZXIuYzozMDA0CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBjb3B5ICclcycgdG8gJyVzJyIKIG1zZ3N0ciAiIgogCi0jOiBzZXF1ZW5jZXIuYzozMDc0CisjOiBzZXF1ZW5jZXIuYzozMDEyCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJZb3UgY2FuIGFtZW5kIHRoZSBjb21taXQgbm93LCB3aXRoXG4iCkBAIC01OTI4LDI3ICs1OTUyLDI3IEBACiAiICBnaXQgcmViYXNlIC0tY29udGludWVcbiIKIG1zZ3N0ciAiIgogCi0jOiBzZXF1ZW5jZXIuYzozMDg0CisjOiBzZXF1ZW5jZXIuYzozMDIyCiAjLCBjLWZvcm1hdAogbXNnaWQgIkNvdWxkIG5vdCBhcHBseSAlcy4uLiAlLipzIgogbXNnc3RyICIiCiAKLSM6IHNlcXVlbmNlci5jOjMwOTEKKyM6IHNlcXVlbmNlci5jOjMwMjkKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ291bGQgbm90IG1lcmdlICUuKnMiCiBtc2dzdHIgIiIKIAotIzogc2VxdWVuY2VyLmM6MzEwNSBzZXF1ZW5jZXIuYzozMTA5IGJ1aWx0aW4vZGlmZnRvb2wuYzo2MzMKKyM6IHNlcXVlbmNlci5jOjMwNDMgc2VxdWVuY2VyLmM6MzA0NyBidWlsdGluL2RpZmZ0b29sLmM6NjQxCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBjb3B5ICclcycgdG8gJyVzJyIKIG1zZ3N0ciAiIgogCi0jOiBzZXF1ZW5jZXIuYzozMTMxIHNlcXVlbmNlci5jOjM1NTggYnVpbHRpbi9yZWJhc2UuYzo4NDkgYnVpbHRpbi9yZWJhc2UuYzoxNTgyCi0jOiBidWlsdGluL3JlYmFzZS5jOjE5NTMgYnVpbHRpbi9yZWJhc2UuYzoyMDA4CisjOiBzZXF1ZW5jZXIuYzozMDY5IHNlcXVlbmNlci5jOjM1MDYgYnVpbHRpbi9yZWJhc2UuYzo4NTAgYnVpbHRpbi9yZWJhc2UuYzoxNjEzCisjOiBidWlsdGluL3JlYmFzZS5jOjE5ODcgYnVpbHRpbi9yZWJhc2UuYzoyMDMxCiBtc2dpZCAiY291bGQgbm90IHJlYWQgaW5kZXgiCiBtc2dzdHIgIiIKIAotIzogc2VxdWVuY2VyLmM6MzEzNgorIzogc2VxdWVuY2VyLmM6MzA3NAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiZXhlY3V0aW9uIGZhaWxlZDogJXNcbiIKQEAgLTU5NTgsMTEgKzU5ODIsMTEgQEAKICJcbiIKIG1zZ3N0ciAiIgogCi0jOiBzZXF1ZW5jZXIuYzozMTQyCisjOiBzZXF1ZW5jZXIuYzozMDgwCiBtc2dpZCAiYW5kIG1hZGUgY2hhbmdlcyB0byB0aGUgaW5kZXggYW5kL29yIHRoZSB3b3JraW5nIHRyZWVcbiIKIG1zZ3N0ciAiIgogCi0jOiBzZXF1ZW5jZXIuYzozMTQ4CisjOiBzZXF1ZW5jZXIuYzozMDg2CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJleGVjdXRpb24gc3VjY2VlZGVkOiAlc1xuIgpAQCAtNTk3Myw3NiArNTk5Nyw3NiBAQAogIlxuIgogbXNnc3RyICIiCiAKLSM6IHNlcXVlbmNlci5jOjMyMDkKKyM6IHNlcXVlbmNlci5jOjMxNDcKICMsIGMtZm9ybWF0CiBtc2dpZCAiaWxsZWdhbCBsYWJlbCBuYW1lOiAnJS4qcyciCiBtc2dzdHIgIiIKIAotIzogc2VxdWVuY2VyLmM6MzI2MworIzogc2VxdWVuY2VyLmM6MzIwMQogbXNnaWQgIndyaXRpbmcgZmFrZSByb290IGNvbW1pdCIKIG1zZ3N0ciAiIgogCi0jOiBzZXF1ZW5jZXIuYzozMjY4CisjOiBzZXF1ZW5jZXIuYzozMjA2CiBtc2dpZCAid3JpdGluZyBzcXVhc2gtb250byIKIG1zZ3N0ciAiIgogCi0jOiBzZXF1ZW5jZXIuYzozMzA2IGJ1aWx0aW4vcmViYXNlLmM6ODU0IGJ1aWx0aW4vcmViYXNlLmM6ODYwCisjOiBzZXF1ZW5jZXIuYzozMjQ0IGJ1aWx0aW4vcmViYXNlLmM6ODU1IGJ1aWx0aW4vcmViYXNlLmM6ODYxCiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBmaW5kIHRyZWUgb2YgJXMiCiBtc2dzdHIgIiIKIAotIzogc2VxdWVuY2VyLmM6MzMyNCBidWlsdGluL3JlYmFzZS5jOjg3MworIzogc2VxdWVuY2VyLmM6MzI2MiBidWlsdGluL3JlYmFzZS5jOjg3NAogbXNnaWQgImNvdWxkIG5vdCB3cml0ZSBpbmRleCIKIG1zZ3N0ciAiIgogCi0jOiBzZXF1ZW5jZXIuYzozMzUxCisjOiBzZXF1ZW5jZXIuYzozMjg5CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCByZXNvbHZlICclcyciCiBtc2dzdHIgIiIKIAotIzogc2VxdWVuY2VyLmM6MzM3OQorIzogc2VxdWVuY2VyLmM6MzMyMAogbXNnaWQgImNhbm5vdCBtZXJnZSB3aXRob3V0IGEgY3VycmVudCByZXZpc2lvbiIKIG1zZ3N0ciAiIgogCi0jOiBzZXF1ZW5jZXIuYzozNDAxCisjOiBzZXF1ZW5jZXIuYzozMzQyCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBwYXJzZSAnJS4qcyciCiBtc2dzdHIgIiIKIAotIzogc2VxdWVuY2VyLmM6MzQxMAorIzogc2VxdWVuY2VyLmM6MzM1MQogIywgYy1mb3JtYXQKIG1zZ2lkICJub3RoaW5nIHRvIG1lcmdlOiAnJS4qcyciCiBtc2dzdHIgIiIKIAotIzogc2VxdWVuY2VyLmM6MzQyMgorIzogc2VxdWVuY2VyLmM6MzM2MwogbXNnaWQgIm9jdG9wdXMgbWVyZ2UgY2Fubm90IGJlIGV4ZWN1dGVkIG9uIHRvcCBvZiBhIFtuZXcgcm9vdF0iCiBtc2dzdHIgIiIKIAotIzogc2VxdWVuY2VyLmM6MzQzNworIzogc2VxdWVuY2VyLmM6MzM3OAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgZ2V0IGNvbW1pdCBtZXNzYWdlIG9mICclcyciCiBtc2dzdHIgIiIKIAotIzogc2VxdWVuY2VyLmM6MzU5MAorIzogc2VxdWVuY2VyLmM6MzUzOAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgZXZlbiBhdHRlbXB0IHRvIG1lcmdlICclLipzJyIKIG1zZ3N0ciAiIgogCi0jOiBzZXF1ZW5jZXIuYzozNjA2CisjOiBzZXF1ZW5jZXIuYzozNTU0CiBtc2dpZCAibWVyZ2U6IFVuYWJsZSB0byB3cml0ZSBuZXcgaW5kZXggZmlsZSIKIG1zZ3N0ciAiIgogCi0jOiBzZXF1ZW5jZXIuYzozNjc1IGJ1aWx0aW4vcmViYXNlLmM6NzExCisjOiBzZXF1ZW5jZXIuYzozNjIzIGJ1aWx0aW4vcmViYXNlLmM6NzEyCiAjLCBjLWZvcm1hdAogbXNnaWQgIkFwcGxpZWQgYXV0b3N0YXNoLlxuIgogbXNnc3RyICIiCiAKLSM6IHNlcXVlbmNlci5jOjM2ODcKKyM6IHNlcXVlbmNlci5jOjM2MzUKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IHN0b3JlICVzIgogbXNnc3RyICIiCiAKLSM6IHNlcXVlbmNlci5jOjM2OTAgYnVpbHRpbi9yZWJhc2UuYzo3MjcgZ2l0LXJlYmFzZS0tcHJlc2VydmUtbWVyZ2VzLnNoOjExMworIzogc2VxdWVuY2VyLmM6MzYzOCBidWlsdGluL3JlYmFzZS5jOjcyOCBnaXQtcmViYXNlLS1wcmVzZXJ2ZS1tZXJnZXMuc2g6MTEzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJBcHBseWluZyBhdXRvc3Rhc2ggcmVzdWx0ZWQgaW4gY29uZmxpY3RzLlxuIgpAQCAtNjA1MCwzMSArNjA3NCwzMSBAQAogIllvdSBjYW4gcnVuIFwiZ2l0IHN0YXNoIHBvcFwiIG9yIFwiZ2l0IHN0YXNoIGRyb3BcIiBhdCBhbnkgdGltZS5cbiIKIG1zZ3N0ciAiIgogCi0jOiBzZXF1ZW5jZXIuYzozNzUxCisjOiBzZXF1ZW5jZXIuYzozNjk5CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBjaGVja291dCAlcyIKIG1zZ3N0ciAiIgogCi0jOiBzZXF1ZW5jZXIuYzozNzY1CisjOiBzZXF1ZW5jZXIuYzozNzEzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiBub3QgYSB2YWxpZCBPSUQiCiBtc2dzdHIgIiIKIAotIzogc2VxdWVuY2VyLmM6Mzc3MCBnaXQtcmViYXNlLS1wcmVzZXJ2ZS1tZXJnZXMuc2g6Nzc5CisjOiBzZXF1ZW5jZXIuYzozNzE4IGdpdC1yZWJhc2UtLXByZXNlcnZlLW1lcmdlcy5zaDo3NzkKIG1zZ2lkICJjb3VsZCBub3QgZGV0YWNoIEhFQUQiCiBtc2dzdHIgIiIKIAotIzogc2VxdWVuY2VyLmM6Mzc4NQorIzogc2VxdWVuY2VyLmM6MzczMwogIywgYy1mb3JtYXQKIG1zZ2lkICJTdG9wcGVkIGF0IEhFQURcbiIKIG1zZ3N0ciAiIgogCi0jOiBzZXF1ZW5jZXIuYzozNzg3CisjOiBzZXF1ZW5jZXIuYzozNzM1CiAjLCBjLWZvcm1hdAogbXNnaWQgIlN0b3BwZWQgYXQgJXNcbiIKIG1zZ3N0ciAiIgogCi0jOiBzZXF1ZW5jZXIuYzozNzk1CisjOiBzZXF1ZW5jZXIuYzozNzQzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJDb3VsZCBub3QgZXhlY3V0ZSB0aGUgdG9kbyBjb21tYW5kXG4iCkBAIC02MDg3LDEyMSArNjExMSwxMjEgQEAKICIgICAgZ2l0IHJlYmFzZSAtLWNvbnRpbnVlXG4iCiBtc2dzdHIgIiIKIAotIzogc2VxdWVuY2VyLmM6Mzg3NworIzogc2VxdWVuY2VyLmM6MzgyNwogIywgYy1mb3JtYXQKIG1zZ2lkICJTdG9wcGVkIGF0ICVzLi4uICAlLipzXG4iCiBtc2dzdHIgIiIKIAotIzogc2VxdWVuY2VyLmM6Mzk1OAorIzogc2VxdWVuY2VyLmM6Mzg5OAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmtub3duIGNvbW1hbmQgJWQiCiBtc2dzdHIgIiIKIAotIzogc2VxdWVuY2VyLmM6NDAwMworIzogc2VxdWVuY2VyLmM6Mzk1NwogbXNnaWQgImNvdWxkIG5vdCByZWFkIG9yaWctaGVhZCIKIG1zZ3N0ciAiIgogCi0jOiBzZXF1ZW5jZXIuYzo0MDA4CisjOiBzZXF1ZW5jZXIuYzozOTYyCiBtc2dpZCAiY291bGQgbm90IHJlYWQgJ29udG8nIgogbXNnc3RyICIiCiAKLSM6IHNlcXVlbmNlci5jOjQwMjIKKyM6IHNlcXVlbmNlci5jOjM5NzYKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHVwZGF0ZSBIRUFEIHRvICVzIgogbXNnc3RyICIiCiAKLSM6IHNlcXVlbmNlci5jOjQxMTUKKyM6IHNlcXVlbmNlci5jOjQwNjkKIG1zZ2lkICJjYW5ub3QgcmViYXNlOiBZb3UgaGF2ZSB1bnN0YWdlZCBjaGFuZ2VzLiIKIG1zZ3N0ciAiIgogCi0jOiBzZXF1ZW5jZXIuYzo0MTI0CisjOiBzZXF1ZW5jZXIuYzo0MDc4CiBtc2dpZCAiY2Fubm90IGFtZW5kIG5vbi1leGlzdGluZyBjb21taXQiCiBtc2dzdHIgIiIKIAotIzogc2VxdWVuY2VyLmM6NDEyNgorIzogc2VxdWVuY2VyLmM6NDA4MAogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIGZpbGU6ICclcyciCiBtc2dzdHIgIiIKIAotIzogc2VxdWVuY2VyLmM6NDEyOAorIzogc2VxdWVuY2VyLmM6NDA4MgogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIGNvbnRlbnRzOiAnJXMnIgogbXNnc3RyICIiCiAKLSM6IHNlcXVlbmNlci5jOjQxMzEKKyM6IHNlcXVlbmNlci5jOjQwODUKIG1zZ2lkICIiCiAiXG4iCiAiWW91IGhhdmUgdW5jb21taXR0ZWQgY2hhbmdlcyBpbiB5b3VyIHdvcmtpbmcgdHJlZS4gUGxlYXNlLCBjb21taXQgdGhlbVxuIgogImZpcnN0IGFuZCB0aGVuIHJ1biAnZ2l0IHJlYmFzZSAtLWNvbnRpbnVlJyBhZ2Fpbi4iCiBtc2dzdHIgIiIKIAotIzogc2VxdWVuY2VyLmM6NDE2NyBzZXF1ZW5jZXIuYzo0MjA1CisjOiBzZXF1ZW5jZXIuYzo0MTIxIHNlcXVlbmNlci5jOjQxNTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHdyaXRlIGZpbGU6ICclcyciCiBtc2dzdHIgIiIKIAotIzogc2VxdWVuY2VyLmM6NDIyMAorIzogc2VxdWVuY2VyLmM6NDE3NAogbXNnaWQgImNvdWxkIG5vdCByZW1vdmUgQ0hFUlJZX1BJQ0tfSEVBRCIKIG1zZ3N0ciAiIgogCi0jOiBzZXF1ZW5jZXIuYzo0MjI3CisjOiBzZXF1ZW5jZXIuYzo0MTgxCiBtc2dpZCAiY291bGQgbm90IGNvbW1pdCBzdGFnZWQgY2hhbmdlcy4iCiBtc2dzdHIgIiIKIAotIzogc2VxdWVuY2VyLmM6NDMyOAorIzogc2VxdWVuY2VyLmM6NDI4NQogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogY2FuJ3QgY2hlcnJ5LXBpY2sgYSAlcyIKIG1zZ3N0ciAiIgogCi0jOiBzZXF1ZW5jZXIuYzo0MzMyCisjOiBzZXF1ZW5jZXIuYzo0Mjg5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiBiYWQgcmV2aXNpb24iCiBtc2dzdHIgIiIKIAotIzogc2VxdWVuY2VyLmM6NDM2NworIzogc2VxdWVuY2VyLmM6NDMyNAogbXNnaWQgImNhbid0IHJldmVydCBhcyBpbml0aWFsIGNvbW1pdCIKIG1zZ3N0ciAiIgogCi0jOiBzZXF1ZW5jZXIuYzo0ODEwCisjOiBzZXF1ZW5jZXIuYzo0Nzc0CiBtc2dpZCAibWFrZV9zY3JpcHQ6IHVuaGFuZGxlZCBvcHRpb25zIgogbXNnc3RyICIiCiAKLSM6IHNlcXVlbmNlci5jOjQ4MTMKKyM6IHNlcXVlbmNlci5jOjQ3NzcKIG1zZ2lkICJtYWtlX3NjcmlwdDogZXJyb3IgcHJlcGFyaW5nIHJldmlzaW9ucyIKIG1zZ3N0ciAiIgogCi0jOiBzZXF1ZW5jZXIuYzo0OTcxCisjOiBzZXF1ZW5jZXIuYzo0OTM1CiBtc2dpZCAiIgogIllvdSBjYW4gZml4IHRoaXMgd2l0aCAnZ2l0IHJlYmFzZSAtLWVkaXQtdG9kbycgYW5kIHRoZW4gcnVuICdnaXQgcmViYXNlIC0tIgogImNvbnRpbnVlJy5cbiIKICJPciB5b3UgY2FuIGFib3J0IHRoZSByZWJhc2Ugd2l0aCAnZ2l0IHJlYmFzZSAtLWFib3J0Jy5cbiIKIG1zZ3N0ciAiIgogCi0jOiBzZXF1ZW5jZXIuYzo1MDgzIHNlcXVlbmNlci5jOjUxMDAKKyM6IHNlcXVlbmNlci5jOjUwNDcgc2VxdWVuY2VyLmM6NTA2NAogbXNnaWQgIm5vdGhpbmcgdG8gZG8iCiBtc2dzdHIgIiIKIAotIzogc2VxdWVuY2VyLmM6NTExNAorIzogc2VxdWVuY2VyLmM6NTA3OAogbXNnaWQgImNvdWxkIG5vdCBza2lwIHVubmVjZXNzYXJ5IHBpY2sgY29tbWFuZHMiCiBtc2dzdHIgIiIKIAotIzogc2VxdWVuY2VyLmM6NTE5NworIzogc2VxdWVuY2VyLmM6NTE2NgogbXNnaWQgInRoZSBzY3JpcHQgd2FzIGFscmVhZHkgcmVhcnJhbmdlZC4iCiBtc2dzdHIgIiIKIAotIzogc2V0dXAuYzoxMjMKKyM6IHNldHVwLmM6MTI0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiclcycgaXMgb3V0c2lkZSByZXBvc2l0b3J5IgogbXNnc3RyICIiCiAKLSM6IHNldHVwLmM6MTczCisjOiBzZXR1cC5jOjE3NAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiJXM6IG5vIHN1Y2ggcGF0aCBpbiB0aGUgd29ya2luZyB0cmVlLlxuIgogIlVzZSAnZ2l0IDxjb21tYW5kPiAtLSA8cGF0aD4uLi4nIHRvIHNwZWNpZnkgcGF0aHMgdGhhdCBkbyBub3QgZXhpc3QgbG9jYWxseS4iCiBtc2dzdHIgIiIKIAotIzogc2V0dXAuYzoxODYKKyM6IHNldHVwLmM6MTg3CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJhbWJpZ3VvdXMgYXJndW1lbnQgJyVzJzogdW5rbm93biByZXZpc2lvbiBvciBwYXRoIG5vdCBpbiB0aGUgd29ya2luZyB0cmVlLlxuIgpAQCAtNjIwOSwxMiArNjIzMywxMiBAQAogIidnaXQgPGNvbW1hbmQ+IFs8cmV2aXNpb24+Li4uXSAtLSBbPGZpbGU+Li4uXSciCiBtc2dzdHIgIiIKIAotIzogc2V0dXAuYzoyMzUKKyM6IHNldHVwLmM6MjM2CiAjLCBjLWZvcm1hdAogbXNnaWQgIm9wdGlvbiAnJXMnIG11c3QgY29tZSBiZWZvcmUgbm9uLW9wdGlvbiBhcmd1bWVudHMiCiBtc2dzdHIgIiIKIAotIzogc2V0dXAuYzoyNTQKKyM6IHNldHVwLmM6MjU1CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJhbWJpZ3VvdXMgYXJndW1lbnQgJyVzJzogYm90aCByZXZpc2lvbiBhbmQgZmlsZW5hbWVcbiIKQEAgLTYyMjIsMzgxICs2MjQ2LDM4MSBAQAogIidnaXQgPGNvbW1hbmQ+IFs8cmV2aXNpb24+Li4uXSAtLSBbPGZpbGU+Li4uXSciCiBtc2dzdHIgIiIKIAotIzogc2V0dXAuYzozOTAKKyM6IHNldHVwLmM6MzkxCiBtc2dpZCAidW5hYmxlIHRvIHNldCB1cCB3b3JrIHRyZWUgdXNpbmcgaW52YWxpZCBjb25maWciCiBtc2dzdHIgIiIKIAotIzogc2V0dXAuYzozOTQKKyM6IHNldHVwLmM6Mzk1CiBtc2dpZCAidGhpcyBvcGVyYXRpb24gbXVzdCBiZSBydW4gaW4gYSB3b3JrIHRyZWUiCiBtc2dzdHIgIiIKIAotIzogc2V0dXAuYzo1NDAKKyM6IHNldHVwLmM6NTQxCiAjLCBjLWZvcm1hdAogbXNnaWQgIkV4cGVjdGVkIGdpdCByZXBvIHZlcnNpb24gPD0gJWQsIGZvdW5kICVkIgogbXNnc3RyICIiCiAKLSM6IHNldHVwLmM6NTQ4CisjOiBzZXR1cC5jOjU0OQogbXNnaWQgInVua25vd24gcmVwb3NpdG9yeSBleHRlbnNpb25zIGZvdW5kOiIKIG1zZ3N0ciAiIgogCi0jOiBzZXR1cC5jOjU2NworIzogc2V0dXAuYzo1NjgKICMsIGMtZm9ybWF0CiBtc2dpZCAiZXJyb3Igb3BlbmluZyAnJXMnIgogbXNnc3RyICIiCiAKLSM6IHNldHVwLmM6NTY5CisjOiBzZXR1cC5jOjU3MAogIywgYy1mb3JtYXQKIG1zZ2lkICJ0b28gbGFyZ2UgdG8gYmUgYSAuZ2l0IGZpbGU6ICclcyciCiBtc2dzdHIgIiIKIAotIzogc2V0dXAuYzo1NzEKKyM6IHNldHVwLmM6NTcyCiAjLCBjLWZvcm1hdAogbXNnaWQgImVycm9yIHJlYWRpbmcgJXMiCiBtc2dzdHIgIiIKIAotIzogc2V0dXAuYzo1NzMKKyM6IHNldHVwLmM6NTc0CiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgZ2l0ZmlsZSBmb3JtYXQ6ICVzIgogbXNnc3RyICIiCiAKLSM6IHNldHVwLmM6NTc1CisjOiBzZXR1cC5jOjU3NgogIywgYy1mb3JtYXQKIG1zZ2lkICJubyBwYXRoIGluIGdpdGZpbGU6ICVzIgogbXNnc3RyICIiCiAKLSM6IHNldHVwLmM6NTc3CisjOiBzZXR1cC5jOjU3OAogIywgYy1mb3JtYXQKIG1zZ2lkICJub3QgYSBnaXQgcmVwb3NpdG9yeTogJXMiCiBtc2dzdHIgIiIKIAotIzogc2V0dXAuYzo2NzYKKyM6IHNldHVwLmM6Njc3CiAjLCBjLWZvcm1hdAogbXNnaWQgIickJXMnIHRvbyBiaWciCiBtc2dzdHIgIiIKIAotIzogc2V0dXAuYzo2OTAKKyM6IHNldHVwLmM6NjkxCiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vdCBhIGdpdCByZXBvc2l0b3J5OiAnJXMnIgogbXNnc3RyICIiCiAKLSM6IHNldHVwLmM6NzE5IHNldHVwLmM6NzIxIHNldHVwLmM6NzUyCisjOiBzZXR1cC5jOjcyMCBzZXR1cC5jOjcyMiBzZXR1cC5jOjc1MwogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgY2hkaXIgdG8gJyVzJyIKIG1zZ3N0ciAiIgogCi0jOiBzZXR1cC5jOjcyNCBzZXR1cC5jOjc4MCBzZXR1cC5jOjc5MCBzZXR1cC5jOjgyOSBzZXR1cC5jOjgzNworIzogc2V0dXAuYzo3MjUgc2V0dXAuYzo3ODEgc2V0dXAuYzo3OTEgc2V0dXAuYzo4MzAgc2V0dXAuYzo4MzgKIG1zZ2lkICJjYW5ub3QgY29tZSBiYWNrIHRvIGN3ZCIKIG1zZ3N0ciAiIgogCi0jOiBzZXR1cC5jOjg1MQorIzogc2V0dXAuYzo4NTIKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIHN0YXQgJyUqcyVzJXMnIgogbXNnc3RyICIiCiAKLSM6IHNldHVwLmM6MTA4MworIzogc2V0dXAuYzoxMDkwCiBtc2dpZCAiVW5hYmxlIHRvIHJlYWQgY3VycmVudCB3b3JraW5nIGRpcmVjdG9yeSIKIG1zZ3N0ciAiIgogCi0jOiBzZXR1cC5jOjEwOTIgc2V0dXAuYzoxMDk4CisjOiBzZXR1cC5jOjEwOTkgc2V0dXAuYzoxMTA1CiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCBjaGFuZ2UgdG8gJyVzJyIKIG1zZ3N0ciAiIgogCi0jOiBzZXR1cC5jOjExMDMKKyM6IHNldHVwLmM6MTExMAogIywgYy1mb3JtYXQKIG1zZ2lkICJub3QgYSBnaXQgcmVwb3NpdG9yeSAob3IgYW55IG9mIHRoZSBwYXJlbnQgZGlyZWN0b3JpZXMpOiAlcyIKIG1zZ3N0ciAiIgogCi0jOiBzZXR1cC5jOjExMDkKKyM6IHNldHVwLmM6MTExNgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAibm90IGEgZ2l0IHJlcG9zaXRvcnkgKG9yIGFueSBwYXJlbnQgdXAgdG8gbW91bnQgcG9pbnQgJXMpXG4iCiAiU3RvcHBpbmcgYXQgZmlsZXN5c3RlbSBib3VuZGFyeSAoR0lUX0RJU0NPVkVSWV9BQ1JPU1NfRklMRVNZU1RFTSBub3Qgc2V0KS4iCiBtc2dzdHIgIiIKIAotIzogc2V0dXAuYzoxMjIwCisjOiBzZXR1cC5jOjEyMjcKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogInByb2JsZW0gd2l0aCBjb3JlLnNoYXJlZFJlcG9zaXRvcnkgZmlsZW1vZGUgdmFsdWUgKDAlLjNvKS5cbiIKICJUaGUgb3duZXIgb2YgZmlsZXMgbXVzdCBhbHdheXMgaGF2ZSByZWFkIGFuZCB3cml0ZSBwZXJtaXNzaW9ucy4iCiBtc2dzdHIgIiIKIAotIzogc2V0dXAuYzoxMjY0CisjOiBzZXR1cC5jOjEyNzEKIG1zZ2lkICJvcGVuIC9kZXYvbnVsbCBvciBkdXAgZmFpbGVkIgogbXNnc3RyICIiCiAKLSM6IHNldHVwLmM6MTI3OQorIzogc2V0dXAuYzoxMjg2CiBtc2dpZCAiZm9yayBmYWlsZWQiCiBtc2dzdHIgIiIKIAotIzogc2V0dXAuYzoxMjg0CisjOiBzZXR1cC5jOjEyOTEKIG1zZ2lkICJzZXRzaWQgZmFpbGVkIgogbXNnc3RyICIiCiAKLSM6IHNoYTEtZmlsZS5jOjQ1MworIzogc2hhMS1maWxlLmM6NDUyCiAjLCBjLWZvcm1hdAogbXNnaWQgIm9iamVjdCBkaXJlY3RvcnkgJXMgZG9lcyBub3QgZXhpc3Q7IGNoZWNrIC5naXQvb2JqZWN0cy9pbmZvL2FsdGVybmF0ZXMiCiBtc2dzdHIgIiIKIAotIzogc2hhMS1maWxlLmM6NTA0CisjOiBzaGExLWZpbGUuYzo1MDMKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIG5vcm1hbGl6ZSBhbHRlcm5hdGUgb2JqZWN0IHBhdGg6ICVzIgogbXNnc3RyICIiCiAKLSM6IHNoYTEtZmlsZS5jOjU3NgorIzogc2hhMS1maWxlLmM6NTc1CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiBpZ25vcmluZyBhbHRlcm5hdGUgb2JqZWN0IHN0b3JlcywgbmVzdGluZyB0b28gZGVlcCIKIG1zZ3N0ciAiIgogCi0jOiBzaGExLWZpbGUuYzo1ODMKKyM6IHNoYTEtZmlsZS5jOjU4MgogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gbm9ybWFsaXplIG9iamVjdCBkaXJlY3Rvcnk6ICVzIgogbXNnc3RyICIiCiAKLSM6IHNoYTEtZmlsZS5jOjYyNgorIzogc2hhMS1maWxlLmM6NjI1CiBtc2dpZCAidW5hYmxlIHRvIGZkb3BlbiBhbHRlcm5hdGVzIGxvY2tmaWxlIgogbXNnc3RyICIiCiAKLSM6IHNoYTEtZmlsZS5jOjY0NAorIzogc2hhMS1maWxlLmM6NjQzCiBtc2dpZCAidW5hYmxlIHRvIHJlYWQgYWx0ZXJuYXRlcyBmaWxlIgogbXNnc3RyICIiCiAKLSM6IHNoYTEtZmlsZS5jOjY1MQorIzogc2hhMS1maWxlLmM6NjUwCiBtc2dpZCAidW5hYmxlIHRvIG1vdmUgbmV3IGFsdGVybmF0ZXMgZmlsZSBpbnRvIHBsYWNlIgogbXNnc3RyICIiCiAKLSM6IHNoYTEtZmlsZS5jOjY4NgorIzogc2hhMS1maWxlLmM6Njg1CiAjLCBjLWZvcm1hdAogbXNnaWQgInBhdGggJyVzJyBkb2VzIG5vdCBleGlzdCIKIG1zZ3N0ciAiIgogCi0jOiBzaGExLWZpbGUuYzo3MTIKKyM6IHNoYTEtZmlsZS5jOjcxMQogIywgYy1mb3JtYXQKIG1zZ2lkICJyZWZlcmVuY2UgcmVwb3NpdG9yeSAnJXMnIGFzIGEgbGlua2VkIGNoZWNrb3V0IGlzIG5vdCBzdXBwb3J0ZWQgeWV0LiIKIG1zZ3N0ciAiIgogCi0jOiBzaGExLWZpbGUuYzo3MTgKKyM6IHNoYTEtZmlsZS5jOjcxNwogIywgYy1mb3JtYXQKIG1zZ2lkICJyZWZlcmVuY2UgcmVwb3NpdG9yeSAnJXMnIGlzIG5vdCBhIGxvY2FsIHJlcG9zaXRvcnkuIgogbXNnc3RyICIiCiAKLSM6IHNoYTEtZmlsZS5jOjcyNAorIzogc2hhMS1maWxlLmM6NzIzCiAjLCBjLWZvcm1hdAogbXNnaWQgInJlZmVyZW5jZSByZXBvc2l0b3J5ICclcycgaXMgc2hhbGxvdyIKIG1zZ3N0ciAiIgogCi0jOiBzaGExLWZpbGUuYzo3MzIKKyM6IHNoYTEtZmlsZS5jOjczMQogIywgYy1mb3JtYXQKIG1zZ2lkICJyZWZlcmVuY2UgcmVwb3NpdG9yeSAnJXMnIGlzIGdyYWZ0ZWQiCiBtc2dzdHIgIiIKIAotIzogc2hhMS1maWxlLmM6NzkyCisjOiBzaGExLWZpbGUuYzo3OTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBsaW5lIHdoaWxlIHBhcnNpbmcgYWx0ZXJuYXRlIHJlZnM6ICVzIgogbXNnc3RyICIiCiAKLSM6IHNoYTEtZmlsZS5jOjk0NAorIzogc2hhMS1maWxlLmM6OTQzCiAjLCBjLWZvcm1hdAogbXNnaWQgImF0dGVtcHRpbmcgdG8gbW1hcCAlPFBSSXVNQVg+IG92ZXIgbGltaXQgJTxQUkl1TUFYPiIKIG1zZ3N0ciAiIgogCi0jOiBzaGExLWZpbGUuYzo5NjkKKyM6IHNoYTEtZmlsZS5jOjk2NAogbXNnaWQgIm1tYXAgZmFpbGVkIgogbXNnc3RyICIiCiAKLSM6IHNoYTEtZmlsZS5jOjExMzMKKyM6IHNoYTEtZmlsZS5jOjExMjgKICMsIGMtZm9ybWF0CiBtc2dpZCAib2JqZWN0IGZpbGUgJXMgaXMgZW1wdHkiCiBtc2dzdHIgIiIKIAotIzogc2hhMS1maWxlLmM6MTI1NyBzaGExLWZpbGUuYzoyMzk2CisjOiBzaGExLWZpbGUuYzoxMjUyIHNoYTEtZmlsZS5jOjIzOTIKICMsIGMtZm9ybWF0CiBtc2dpZCAiY29ycnVwdCBsb29zZSBvYmplY3QgJyVzJyIKIG1zZ3N0ciAiIgogCi0jOiBzaGExLWZpbGUuYzoxMjU5IHNoYTEtZmlsZS5jOjI0MDAKKyM6IHNoYTEtZmlsZS5jOjEyNTQgc2hhMS1maWxlLmM6MjM5NgogIywgYy1mb3JtYXQKIG1zZ2lkICJnYXJiYWdlIGF0IGVuZCBvZiBsb29zZSBvYmplY3QgJyVzJyIKIG1zZ3N0ciAiIgogCi0jOiBzaGExLWZpbGUuYzoxMzAxCisjOiBzaGExLWZpbGUuYzoxMjk2CiBtc2dpZCAiaW52YWxpZCBvYmplY3QgdHlwZSIKIG1zZ3N0ciAiIgogCi0jOiBzaGExLWZpbGUuYzoxMzg1CisjOiBzaGExLWZpbGUuYzoxMzgwCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byB1bnBhY2sgJXMgaGVhZGVyIHdpdGggLS1hbGxvdy11bmtub3duLXR5cGUiCiBtc2dzdHIgIiIKIAotIzogc2hhMS1maWxlLmM6MTM4OAorIzogc2hhMS1maWxlLmM6MTM4MwogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gdW5wYWNrICVzIGhlYWRlciIKIG1zZ3N0ciAiIgogCi0jOiBzaGExLWZpbGUuYzoxMzk0CisjOiBzaGExLWZpbGUuYzoxMzg5CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBwYXJzZSAlcyBoZWFkZXIgd2l0aCAtLWFsbG93LXVua25vd24tdHlwZSIKIG1zZ3N0ciAiIgogCi0jOiBzaGExLWZpbGUuYzoxMzk3CisjOiBzaGExLWZpbGUuYzoxMzkyCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBwYXJzZSAlcyBoZWFkZXIiCiBtc2dzdHIgIiIKIAotIzogc2hhMS1maWxlLmM6MTU4OAorIzogc2hhMS1maWxlLmM6MTU4NAogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gcmVhZCBvYmplY3QgJXMiCiBtc2dzdHIgIiIKIAotIzogc2hhMS1maWxlLmM6MTU5MgorIzogc2hhMS1maWxlLmM6MTU4OAogIywgYy1mb3JtYXQKIG1zZ2lkICJyZXBsYWNlbWVudCAlcyBub3QgZm91bmQgZm9yICVzIgogbXNnc3RyICIiCiAKLSM6IHNoYTEtZmlsZS5jOjE1OTYKKyM6IHNoYTEtZmlsZS5jOjE1OTIKICMsIGMtZm9ybWF0CiBtc2dpZCAibG9vc2Ugb2JqZWN0ICVzIChzdG9yZWQgaW4gJXMpIGlzIGNvcnJ1cHQiCiBtc2dzdHIgIiIKIAotIzogc2hhMS1maWxlLmM6MTYwMAorIzogc2hhMS1maWxlLmM6MTU5NgogIywgYy1mb3JtYXQKIG1zZ2lkICJwYWNrZWQgb2JqZWN0ICVzIChzdG9yZWQgaW4gJXMpIGlzIGNvcnJ1cHQiCiBtc2dzdHIgIiIKIAotIzogc2hhMS1maWxlLmM6MTcwMworIzogc2hhMS1maWxlLmM6MTY5OQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gd3JpdGUgZmlsZSAlcyIKIG1zZ3N0ciAiIgogCi0jOiBzaGExLWZpbGUuYzoxNzEwCisjOiBzaGExLWZpbGUuYzoxNzA2CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBzZXQgcGVybWlzc2lvbiB0byAnJXMnIgogbXNnc3RyICIiCiAKLSM6IHNoYTEtZmlsZS5jOjE3MTcKKyM6IHNoYTEtZmlsZS5jOjE3MTMKIG1zZ2lkICJmaWxlIHdyaXRlIGVycm9yIgogbXNnc3RyICIiCiAKLSM6IHNoYTEtZmlsZS5jOjE3MzYKKyM6IHNoYTEtZmlsZS5jOjE3MzIKIG1zZ2lkICJlcnJvciB3aGVuIGNsb3NpbmcgbG9vc2Ugb2JqZWN0IGZpbGUiCiBtc2dzdHIgIiIKIAotIzogc2hhMS1maWxlLmM6MTgwMQorIzogc2hhMS1maWxlLmM6MTc5NwogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnN1ZmZpY2llbnQgcGVybWlzc2lvbiBmb3IgYWRkaW5nIGFuIG9iamVjdCB0byByZXBvc2l0b3J5IGRhdGFiYXNlICVzIgogbXNnc3RyICIiCiAKLSM6IHNoYTEtZmlsZS5jOjE4MDMKKyM6IHNoYTEtZmlsZS5jOjE3OTkKIG1zZ2lkICJ1bmFibGUgdG8gY3JlYXRlIHRlbXBvcmFyeSBmaWxlIgogbXNnc3RyICIiCiAKLSM6IHNoYTEtZmlsZS5jOjE4MjcKKyM6IHNoYTEtZmlsZS5jOjE4MjMKIG1zZ2lkICJ1bmFibGUgdG8gd3JpdGUgbG9vc2Ugb2JqZWN0IGZpbGUiCiBtc2dzdHIgIiIKIAotIzogc2hhMS1maWxlLmM6MTgzMworIzogc2hhMS1maWxlLmM6MTgyOQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gZGVmbGF0ZSBuZXcgb2JqZWN0ICVzICglZCkiCiBtc2dzdHIgIiIKIAotIzogc2hhMS1maWxlLmM6MTgzNworIzogc2hhMS1maWxlLmM6MTgzMwogIywgYy1mb3JtYXQKIG1zZ2lkICJkZWZsYXRlRW5kIG9uIG9iamVjdCAlcyBmYWlsZWQgKCVkKSIKIG1zZ3N0ciAiIgogCi0jOiBzaGExLWZpbGUuYzoxODQxCisjOiBzaGExLWZpbGUuYzoxODM3CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvbmZ1c2VkIGJ5IHVuc3RhYmxlIG9iamVjdCBzb3VyY2UgZGF0YSBmb3IgJXMiCiBtc2dzdHIgIiIKIAotIzogc2hhMS1maWxlLmM6MTg1MSBidWlsdGluL3BhY2stb2JqZWN0cy5jOjkyNQorIzogc2hhMS1maWxlLmM6MTg0NyBidWlsdGluL3BhY2stb2JqZWN0cy5jOjkyNQogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdXRpbWUoKSBvbiAlcyIKIG1zZ3N0ciAiIgogCi0jOiBzaGExLWZpbGUuYzoxOTI2CisjOiBzaGExLWZpbGUuYzoxOTIyCiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCByZWFkIG9iamVjdCBmb3IgJXMiCiBtc2dzdHIgIiIKIAotIzogc2hhMS1maWxlLmM6MTk2NgorIzogc2hhMS1maWxlLmM6MTk2MgogbXNnaWQgImNvcnJ1cHQgY29tbWl0IgogbXNnc3RyICIiCiAKLSM6IHNoYTEtZmlsZS5jOjE5NzQKKyM6IHNoYTEtZmlsZS5jOjE5NzAKIG1zZ2lkICJjb3JydXB0IHRhZyIKIG1zZ3N0ciAiIgogCi0jOiBzaGExLWZpbGUuYzoyMDczCisjOiBzaGExLWZpbGUuYzoyMDY5CiAjLCBjLWZvcm1hdAogbXNnaWQgInJlYWQgZXJyb3Igd2hpbGUgaW5kZXhpbmcgJXMiCiBtc2dzdHIgIiIKIAotIzogc2hhMS1maWxlLmM6MjA3NgorIzogc2hhMS1maWxlLmM6MjA3MgogIywgYy1mb3JtYXQKIG1zZ2lkICJzaG9ydCByZWFkIHdoaWxlIGluZGV4aW5nICVzIgogbXNnc3RyICIiCiAKLSM6IHNoYTEtZmlsZS5jOjIxNDkgc2hhMS1maWxlLmM6MjE1OAorIzogc2hhMS1maWxlLmM6MjE0NSBzaGExLWZpbGUuYzoyMTU0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiBmYWlsZWQgdG8gaW5zZXJ0IGludG8gZGF0YWJhc2UiCiBtc2dzdHIgIiIKIAotIzogc2hhMS1maWxlLmM6MjE2NAorIzogc2hhMS1maWxlLmM6MjE2MAogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogdW5zdXBwb3J0ZWQgZmlsZSB0eXBlIgogbXNnc3RyICIiCiAKLSM6IHNoYTEtZmlsZS5jOjIxODgKKyM6IHNoYTEtZmlsZS5jOjIxODQKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgaXMgbm90IGEgdmFsaWQgb2JqZWN0IgogbXNnc3RyICIiCiAKLSM6IHNoYTEtZmlsZS5jOjIxOTAKKyM6IHNoYTEtZmlsZS5jOjIxODYKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgaXMgbm90IGEgdmFsaWQgJyVzJyBvYmplY3QiCiBtc2dzdHIgIiIKIAotIzogc2hhMS1maWxlLmM6MjIxNyBidWlsdGluL2luZGV4LXBhY2suYzoxNTUKKyM6IHNoYTEtZmlsZS5jOjIyMTMgYnVpbHRpbi9pbmRleC1wYWNrLmM6MTU1CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBvcGVuICVzIgogbXNnc3RyICIiCiAKLSM6IHNoYTEtZmlsZS5jOjI0MDcgc2hhMS1maWxlLmM6MjQ1OQorIzogc2hhMS1maWxlLmM6MjQwMyBzaGExLWZpbGUuYzoyNDU1CiAjLCBjLWZvcm1hdAogbXNnaWQgImhhc2ggbWlzbWF0Y2ggZm9yICVzIChleHBlY3RlZCAlcykiCiBtc2dzdHIgIiIKIAotIzogc2hhMS1maWxlLmM6MjQzMQorIzogc2hhMS1maWxlLmM6MjQyNwogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gbW1hcCAlcyIKIG1zZ3N0ciAiIgogCi0jOiBzaGExLWZpbGUuYzoyNDM2CisjOiBzaGExLWZpbGUuYzoyNDMyCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byB1bnBhY2sgaGVhZGVyIG9mICVzIgogbXNnc3RyICIiCiAKLSM6IHNoYTEtZmlsZS5jOjI0NDIKKyM6IHNoYTEtZmlsZS5jOjI0MzgKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHBhcnNlIGhlYWRlciBvZiAlcyIKIG1zZ3N0ciAiIgogCi0jOiBzaGExLWZpbGUuYzoyNDUzCisjOiBzaGExLWZpbGUuYzoyNDQ5CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byB1bnBhY2sgY29udGVudHMgb2YgJXMiCiBtc2dzdHIgIiIKIAotIzogc2hhMS1uYW1lLmM6NDkwCisjOiBzaGExLW5hbWUuYzo0ODcKICMsIGMtZm9ybWF0CiBtc2dpZCAic2hvcnQgU0hBMSAlcyBpcyBhbWJpZ3VvdXMiCiBtc2dzdHIgIiIKIAotIzogc2hhMS1uYW1lLmM6NTAxCisjOiBzaGExLW5hbWUuYzo0OTgKIG1zZ2lkICJUaGUgY2FuZGlkYXRlcyBhcmU6IgogbXNnc3RyICIiCiAKLSM6IHNoYTEtbmFtZS5jOjgwMAorIzogc2hhMS1uYW1lLmM6Nzk3CiBtc2dpZCAiIgogIkdpdCBub3JtYWxseSBuZXZlciBjcmVhdGVzIGEgcmVmIHRoYXQgZW5kcyB3aXRoIDQwIGhleCBjaGFyYWN0ZXJzXG4iCiAiYmVjYXVzZSBpdCB3aWxsIGJlIGlnbm9yZWQgd2hlbiB5b3UganVzdCBzcGVjaWZ5IDQwLWhleC4gVGhlc2UgcmVmc1xuIgpAQCAtNjYxMCw0MyArNjYzNCw0MyBAQAogbXNnc3RyICIiCiAKICMuIFRSQU5TTEFUT1JTOiBJRUMgODAwMDAtMTM6MjAwOCBnaWJpYnl0ZQotIzogc3RyYnVmLmM6ODIxCisjOiBzdHJidWYuYzo4MjIKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXUuJTIuMnUgR2lCIgogbXNnc3RyICIiCiAKICMuIFRSQU5TTEFUT1JTOiBJRUMgODAwMDAtMTM6MjAwOCBnaWJpYnl0ZS9zZWNvbmQKLSM6IHN0cmJ1Zi5jOjgyMworIzogc3RyYnVmLmM6ODI0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiV1LiUyLjJ1IEdpQi9zIgogbXNnc3RyICIiCiAKICMuIFRSQU5TTEFUT1JTOiBJRUMgODAwMDAtMTM6MjAwOCBtZWJpYnl0ZQotIzogc3RyYnVmLmM6ODMxCisjOiBzdHJidWYuYzo4MzIKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXUuJTIuMnUgTWlCIgogbXNnc3RyICIiCiAKICMuIFRSQU5TTEFUT1JTOiBJRUMgODAwMDAtMTM6MjAwOCBtZWJpYnl0ZS9zZWNvbmQKLSM6IHN0cmJ1Zi5jOjgzMworIzogc3RyYnVmLmM6ODM0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiV1LiUyLjJ1IE1pQi9zIgogbXNnc3RyICIiCiAKICMuIFRSQU5TTEFUT1JTOiBJRUMgODAwMDAtMTM6MjAwOCBraWJpYnl0ZQotIzogc3RyYnVmLmM6ODQwCisjOiBzdHJidWYuYzo4NDEKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXUuJTIuMnUgS2lCIgogbXNnc3RyICIiCiAKICMuIFRSQU5TTEFUT1JTOiBJRUMgODAwMDAtMTM6MjAwOCBraWJpYnl0ZS9zZWNvbmQKLSM6IHN0cmJ1Zi5jOjg0MgorIzogc3RyYnVmLmM6ODQzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiV1LiUyLjJ1IEtpQi9zIgogbXNnc3RyICIiCiAKICMuIFRSQU5TTEFUT1JTOiBJRUMgODAwMDAtMTM6MjAwOCBieXRlCi0jOiBzdHJidWYuYzo4NDgKKyM6IHN0cmJ1Zi5jOjg0OQogIywgYy1mb3JtYXQKIG1zZ2lkICIldSBieXRlIgogbXNnaWRfcGx1cmFsICIldSBieXRlcyIKQEAgLTY2NTQsNyArNjY3OCw3IEBACiBtc2dzdHJbMV0gIiIKIAogIy4gVFJBTlNMQVRPUlM6IElFQyA4MDAwMC0xMzoyMDA4IGJ5dGUvc2Vjb25kCi0jOiBzdHJidWYuYzo4NTAKKyM6IHN0cmJ1Zi5jOjg1MQogIywgYy1mb3JtYXQKIG1zZ2lkICIldSBieXRlL3MiCiBtc2dpZF9wbHVyYWwgIiV1IGJ5dGVzL3MiCkBAIC02NzY2LDI2ICs2NzkwLDI2IEBACiBtc2dpZCAibHMtdHJlZSByZXR1cm5lZCB1bmV4cGVjdGVkIHJldHVybiBjb2RlICVkIgogbXNnc3RyICIiCiAKLSM6IHN1Ym1vZHVsZS1jb25maWcuYzoyMzIKKyM6IHN1Ym1vZHVsZS1jb25maWcuYzoyMzYKICMsIGMtZm9ybWF0CiBtc2dpZCAiaWdub3Jpbmcgc3VzcGljaW91cyBzdWJtb2R1bGUgbmFtZTogJXMiCiBtc2dzdHIgIiIKIAotIzogc3VibW9kdWxlLWNvbmZpZy5jOjI5OQorIzogc3VibW9kdWxlLWNvbmZpZy5jOjMwMwogbXNnaWQgIm5lZ2F0aXZlIHZhbHVlcyBub3QgYWxsb3dlZCBmb3Igc3VibW9kdWxlLmZldGNoam9icyIKIG1zZ3N0ciAiIgogCi0jOiBzdWJtb2R1bGUtY29uZmlnLmM6Mzk3CisjOiBzdWJtb2R1bGUtY29uZmlnLmM6NDAxCiAjLCBjLWZvcm1hdAogbXNnaWQgImlnbm9yaW5nICclcycgd2hpY2ggbWF5IGJlIGludGVycHJldGVkIGFzIGEgY29tbWFuZC1saW5lIG9wdGlvbjogJXMiCiBtc2dzdHIgIiIKIAotIzogc3VibW9kdWxlLWNvbmZpZy5jOjQ4NgorIzogc3VibW9kdWxlLWNvbmZpZy5jOjQ5MAogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIHZhbHVlIGZvciAlcyIKIG1zZ3N0ciAiIgogCi0jOiBzdWJtb2R1bGUtY29uZmlnLmM6NzU1CisjOiBzdWJtb2R1bGUtY29uZmlnLmM6NzYxCiAjLCBjLWZvcm1hdAogbXNnaWQgIkNvdWxkIG5vdCB1cGRhdGUgLmdpdG1vZHVsZXMgZW50cnkgJXMiCiBtc2dzdHIgIiIKQEAgLTY4MjAsNyArNjg0NCw3IEBACiBtc2dpZCAiY291bGQgbm90IHJlYWQgZnJvbSBzdGRpbiIKIG1zZ3N0ciAiIgogCi0jOiB0cmFpbGVyLmM6MTAxMSB3cmFwcGVyLmM6NzAxCisjOiB0cmFpbGVyLmM6MTAxMSB3cmFwcGVyLmM6NjY1CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBzdGF0ICVzIgogbXNnc3RyICIiCkBAIC02ODQ5LDU0ICs2ODczLDU0IEBACiBtc2dpZCAiV291bGQgc2V0IHVwc3RyZWFtIG9mICclcycgdG8gJyVzJyBvZiAnJXMnXG4iCiBtc2dzdHIgIiIKIAotIzogdHJhbnNwb3J0LmM6MTQyCisjOiB0cmFuc3BvcnQuYzoxNDUKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHJlYWQgYnVuZGxlICclcyciCiBtc2dzdHIgIiIKIAotIzogdHJhbnNwb3J0LmM6MjA4CisjOiB0cmFuc3BvcnQuYzoyMTQKICMsIGMtZm9ybWF0CiBtc2dpZCAidHJhbnNwb3J0OiBpbnZhbGlkIGRlcHRoIG9wdGlvbiAnJXMnIgogbXNnc3RyICIiCiAKLSM6IHRyYW5zcG9ydC5jOjI1OQorIzogdHJhbnNwb3J0LmM6MjY2CiBtc2dpZCAic2VlIHByb3RvY29sLnZlcnNpb24gaW4gJ2dpdCBoZWxwIGNvbmZpZycgZm9yIG1vcmUgZGV0YWlscyIKIG1zZ3N0ciAiIgogCi0jOiB0cmFuc3BvcnQuYzoyNjAKKyM6IHRyYW5zcG9ydC5jOjI2NwogbXNnaWQgInNlcnZlciBvcHRpb25zIHJlcXVpcmUgcHJvdG9jb2wgdmVyc2lvbiAyIG9yIGxhdGVyIgogbXNnc3RyICIiCiAKLSM6IHRyYW5zcG9ydC5jOjYyNQorIzogdHJhbnNwb3J0LmM6NjMyCiBtc2dpZCAiY291bGQgbm90IHBhcnNlIHRyYW5zcG9ydC5jb2xvci4qIGNvbmZpZyIKIG1zZ3N0ciAiIgogCi0jOiB0cmFuc3BvcnQuYzo2OTgKKyM6IHRyYW5zcG9ydC5jOjcwNQogbXNnaWQgInN1cHBvcnQgZm9yIHByb3RvY29sIHYyIG5vdCBpbXBsZW1lbnRlZCB5ZXQiCiBtc2dzdHIgIiIKIAotIzogdHJhbnNwb3J0LmM6ODI1CisjOiB0cmFuc3BvcnQuYzo4MzEKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5rbm93biB2YWx1ZSBmb3IgY29uZmlnICclcyc6ICVzIgogbXNnc3RyICIiCiAKLSM6IHRyYW5zcG9ydC5jOjg5MQorIzogdHJhbnNwb3J0LmM6ODk3CiAjLCBjLWZvcm1hdAogbXNnaWQgInRyYW5zcG9ydCAnJXMnIG5vdCBhbGxvd2VkIgogbXNnc3RyICIiCiAKLSM6IHRyYW5zcG9ydC5jOjk0NQorIzogdHJhbnNwb3J0LmM6OTQ5CiBtc2dpZCAiZ2l0LW92ZXItcnN5bmMgaXMgbm8gbG9uZ2VyIHN1cHBvcnRlZCIKIG1zZ3N0ciAiIgogCi0jOiB0cmFuc3BvcnQuYzoxMDQwCisjOiB0cmFuc3BvcnQuYzoxMDQ0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgZm9sbG93aW5nIHN1Ym1vZHVsZSBwYXRocyBjb250YWluIGNoYW5nZXMgdGhhdCBjYW5cbiIKICJub3QgYmUgZm91bmQgb24gYW55IHJlbW90ZTpcbiIKIG1zZ3N0ciAiIgogCi0jOiB0cmFuc3BvcnQuYzoxMDQ0CisjOiB0cmFuc3BvcnQuYzoxMDQ4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJcbiIKQEAgLTY5MTIsMTc4ICs2OTM2LDE4MyBAQAogIlxuIgogbXNnc3RyICIiCiAKLSM6IHRyYW5zcG9ydC5jOjEwNTIKKyM6IHRyYW5zcG9ydC5jOjEwNTYKIG1zZ2lkICJBYm9ydGluZy4iCiBtc2dzdHIgIiIKIAotIzogdHJhbnNwb3J0LmM6MTE5MworIzogdHJhbnNwb3J0LmM6MTIwMQogbXNnaWQgImZhaWxlZCB0byBwdXNoIGFsbCBuZWVkZWQgc3VibW9kdWxlcyIKIG1zZ3N0ciAiIgogCi0jOiB0cmFuc3BvcnQuYzoxMzQwIHRyYW5zcG9ydC1oZWxwZXIuYzo2NDUKKyM6IHRyYW5zcG9ydC5jOjEzNDUgdHJhbnNwb3J0LWhlbHBlci5jOjY1NQogbXNnaWQgIm9wZXJhdGlvbiBub3Qgc3VwcG9ydGVkIGJ5IHByb3RvY29sIgogbXNnc3RyICIiCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzo1MSB0cmFuc3BvcnQtaGVscGVyLmM6ODAKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzo2MSB0cmFuc3BvcnQtaGVscGVyLmM6OTAKIG1zZ2lkICJmdWxsIHdyaXRlIHRvIHJlbW90ZSBoZWxwZXIgZmFpbGVkIgogbXNnc3RyICIiCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxMzQKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxNDQKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGZpbmQgcmVtb3RlIGhlbHBlciBmb3IgJyVzJyIKIG1zZ3N0ciAiIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6MTUwIHRyYW5zcG9ydC1oZWxwZXIuYzo1NTkKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxNjAgdHJhbnNwb3J0LWhlbHBlci5jOjU2OQogbXNnaWQgImNhbid0IGR1cCBoZWxwZXIgb3V0cHV0IGZkIgogbXNnc3RyICIiCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzoyMDEKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzoyMTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogInVua25vd24gbWFuZGF0b3J5IGNhcGFiaWxpdHkgJXM7IHRoaXMgcmVtb3RlIGhlbHBlciBwcm9iYWJseSBuZWVkcyBuZXdlciAiCiAidmVyc2lvbiBvZiBHaXQiCiBtc2dzdHIgIiIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjIwNworIzogdHJhbnNwb3J0LWhlbHBlci5jOjIxNwogbXNnaWQgInRoaXMgcmVtb3RlIGhlbHBlciBzaG91bGQgaW1wbGVtZW50IHJlZnNwZWMgY2FwYWJpbGl0eSIKIG1zZ3N0ciAiIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6Mjc0IHRyYW5zcG9ydC1oZWxwZXIuYzo0MTQKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzoyODQgdHJhbnNwb3J0LWhlbHBlci5jOjQyNAogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyB1bmV4cGVjdGVkbHkgc2FpZDogJyVzJyIKIG1zZ3N0ciAiIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6NDAzCisjOiB0cmFuc3BvcnQtaGVscGVyLmM6NDEzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIGFsc28gbG9ja2VkICVzIgogbXNnc3RyICIiCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzo0ODEKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzo0OTEKIG1zZ2lkICJjb3VsZG4ndCBydW4gZmFzdC1pbXBvcnQiCiBtc2dzdHIgIiIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjUwNAorIzogdHJhbnNwb3J0LWhlbHBlci5jOjUxNAogbXNnaWQgImVycm9yIHdoaWxlIHJ1bm5pbmcgZmFzdC1pbXBvcnQiCiBtc2dzdHIgIiIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjUzMyB0cmFuc3BvcnQtaGVscGVyLmM6MTEwNQorIzogdHJhbnNwb3J0LWhlbHBlci5jOjU0MyB0cmFuc3BvcnQtaGVscGVyLmM6MTEzMgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcmVhZCByZWYgJXMiCiBtc2dzdHIgIiIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjU3OAorIzogdHJhbnNwb3J0LWhlbHBlci5jOjU4OAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmtub3duIHJlc3BvbnNlIHRvIGNvbm5lY3Q6ICVzIgogbXNnc3RyICIiCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzo2MDAKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzo2MTAKIG1zZ2lkICJzZXR0aW5nIHJlbW90ZSBzZXJ2aWNlIHBhdGggbm90IHN1cHBvcnRlZCBieSBwcm90b2NvbCIKIG1zZ3N0ciAiIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6NjAyCisjOiB0cmFuc3BvcnQtaGVscGVyLmM6NjEyCiBtc2dpZCAiaW52YWxpZCByZW1vdGUgc2VydmljZSBwYXRoIgogbXNnc3RyICIiCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzo2NDgKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzo2NTgKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2FuJ3QgY29ubmVjdCB0byBzdWJzZXJ2aWNlICVzIgogbXNnc3RyICIiCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzo3MjAKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzo3MzQKICMsIGMtZm9ybWF0CiBtc2dpZCAiZXhwZWN0ZWQgb2svZXJyb3IsIGhlbHBlciBzYWlkICclcyciCiBtc2dzdHIgIiIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjc3MworIzogdHJhbnNwb3J0LWhlbHBlci5jOjc4NwogIywgYy1mb3JtYXQKIG1zZ2lkICJoZWxwZXIgcmVwb3J0ZWQgdW5leHBlY3RlZCBzdGF0dXMgb2YgJXMiCiBtc2dzdHIgIiIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjgzNAorIzogdHJhbnNwb3J0LWhlbHBlci5jOjg0OAogIywgYy1mb3JtYXQKIG1zZ2lkICJoZWxwZXIgJXMgZG9lcyBub3Qgc3VwcG9ydCBkcnktcnVuIgogbXNnc3RyICIiCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzo4MzcKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzo4NTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiaGVscGVyICVzIGRvZXMgbm90IHN1cHBvcnQgLS1zaWduZWQiCiBtc2dzdHIgIiIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjg0MAorIzogdHJhbnNwb3J0LWhlbHBlci5jOjg1NAogIywgYy1mb3JtYXQKIG1zZ2lkICJoZWxwZXIgJXMgZG9lcyBub3Qgc3VwcG9ydCAtLXNpZ25lZD1pZi1hc2tlZCIKIG1zZ3N0ciAiIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6ODQ3CisjOiB0cmFuc3BvcnQtaGVscGVyLmM6ODU5CisjLCBjLWZvcm1hdAorbXNnaWQgImhlbHBlciAlcyBkb2VzIG5vdCBzdXBwb3J0IC0tYXRvbWljIgorbXNnc3RyICIiCisKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzo4NjUKICMsIGMtZm9ybWF0CiBtc2dpZCAiaGVscGVyICVzIGRvZXMgbm90IHN1cHBvcnQgJ3B1c2gtb3B0aW9uJyIKIG1zZ3N0ciAiIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6OTQ1CisjOiB0cmFuc3BvcnQtaGVscGVyLmM6OTYzCiBtc2dpZCAicmVtb3RlLWhlbHBlciBkb2Vzbid0IHN1cHBvcnQgcHVzaDsgcmVmc3BlYyBuZWVkZWQiCiBtc2dzdHIgIiIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjk1MAorIzogdHJhbnNwb3J0LWhlbHBlci5jOjk2OAogIywgYy1mb3JtYXQKIG1zZ2lkICJoZWxwZXIgJXMgZG9lcyBub3Qgc3VwcG9ydCAnZm9yY2UnIgogbXNnc3RyICIiCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzo5OTcKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxMDE1CiBtc2dpZCAiY291bGRuJ3QgcnVuIGZhc3QtZXhwb3J0IgogbXNnc3RyICIiCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxMDAyCisjOiB0cmFuc3BvcnQtaGVscGVyLmM6MTAyMAogbXNnaWQgImVycm9yIHdoaWxlIHJ1bm5pbmcgZmFzdC1leHBvcnQiCiBtc2dzdHIgIiIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjEwMjcKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxMDQ1CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJObyByZWZzIGluIGNvbW1vbiBhbmQgbm9uZSBzcGVjaWZpZWQ7IGRvaW5nIG5vdGhpbmcuXG4iCiAiUGVyaGFwcyB5b3Ugc2hvdWxkIHNwZWNpZnkgYSBicmFuY2ggc3VjaCBhcyAnbWFzdGVyJy5cbiIKIG1zZ3N0ciAiIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6MTA5MQorIzogdHJhbnNwb3J0LWhlbHBlci5jOjExMTgKICMsIGMtZm9ybWF0CiBtc2dpZCAibWFsZm9ybWVkIHJlc3BvbnNlIGluIHJlZiBsaXN0OiAlcyIKIG1zZ3N0ciAiIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6MTI0NAorIzogdHJhbnNwb3J0LWhlbHBlci5jOjEyNzAKICMsIGMtZm9ybWF0CiBtc2dpZCAicmVhZCglcykgZmFpbGVkIgogbXNnc3RyICIiCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxMjcxCisjOiB0cmFuc3BvcnQtaGVscGVyLmM6MTI5NwogIywgYy1mb3JtYXQKIG1zZ2lkICJ3cml0ZSglcykgZmFpbGVkIgogbXNnc3RyICIiCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxMzIwCisjOiB0cmFuc3BvcnQtaGVscGVyLmM6MTM0NgogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyB0aHJlYWQgZmFpbGVkIgogbXNnc3RyICIiCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxMzI0CisjOiB0cmFuc3BvcnQtaGVscGVyLmM6MTM1MAogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyB0aHJlYWQgZmFpbGVkIHRvIGpvaW46ICVzIgogbXNnc3RyICIiCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxMzQzIHRyYW5zcG9ydC1oZWxwZXIuYzoxMzQ3CisjOiB0cmFuc3BvcnQtaGVscGVyLmM6MTM2OSB0cmFuc3BvcnQtaGVscGVyLmM6MTM3MwogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW4ndCBzdGFydCB0aHJlYWQgZm9yIGNvcHlpbmcgZGF0YTogJXMiCiBtc2dzdHIgIiIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjEzODQKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxNDEwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIHByb2Nlc3MgZmFpbGVkIHRvIHdhaXQiCiBtc2dzdHIgIiIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjEzODgKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxNDE0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIHByb2Nlc3MgZmFpbGVkIgogbXNnc3RyICIiCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxNDA2IHRyYW5zcG9ydC1oZWxwZXIuYzoxNDE1CisjOiB0cmFuc3BvcnQtaGVscGVyLmM6MTQzMiB0cmFuc3BvcnQtaGVscGVyLmM6MTQ0MQogbXNnaWQgImNhbid0IHN0YXJ0IHRocmVhZCBmb3IgY29weWluZyBkYXRhIgogbXNnc3RyICIiCiAKQEAgLTcxMDMsOTggKzcxMzIsOTggQEAKIG1zZ2lkICJ0b28tc2hvcnQgdHJlZSBmaWxlIgogbXNnc3RyICIiCiAKLSM6IHVucGFjay10cmVlcy5jOjExMQorIzogdW5wYWNrLXRyZWVzLmM6MTEwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJZb3VyIGxvY2FsIGNoYW5nZXMgdG8gdGhlIGZvbGxvd2luZyBmaWxlcyB3b3VsZCBiZSBvdmVyd3JpdHRlbiBieSBjaGVja291dDpcbiIKICIlJXNQbGVhc2UgY29tbWl0IHlvdXIgY2hhbmdlcyBvciBzdGFzaCB0aGVtIGJlZm9yZSB5b3Ugc3dpdGNoIGJyYW5jaGVzLiIKIG1zZ3N0ciAiIgogCi0jOiB1bnBhY2stdHJlZXMuYzoxMTMKKyM6IHVucGFjay10cmVlcy5jOjExMgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiWW91ciBsb2NhbCBjaGFuZ2VzIHRvIHRoZSBmb2xsb3dpbmcgZmlsZXMgd291bGQgYmUgb3ZlcndyaXR0ZW4gYnkgY2hlY2tvdXQ6XG4iCiAiJSVzIgogbXNnc3RyICIiCiAKLSM6IHVucGFjay10cmVlcy5jOjExNgorIzogdW5wYWNrLXRyZWVzLmM6MTE1CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJZb3VyIGxvY2FsIGNoYW5nZXMgdG8gdGhlIGZvbGxvd2luZyBmaWxlcyB3b3VsZCBiZSBvdmVyd3JpdHRlbiBieSBtZXJnZTpcbiIKICIlJXNQbGVhc2UgY29tbWl0IHlvdXIgY2hhbmdlcyBvciBzdGFzaCB0aGVtIGJlZm9yZSB5b3UgbWVyZ2UuIgogbXNnc3RyICIiCiAKLSM6IHVucGFjay10cmVlcy5jOjExOAorIzogdW5wYWNrLXRyZWVzLmM6MTE3CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJZb3VyIGxvY2FsIGNoYW5nZXMgdG8gdGhlIGZvbGxvd2luZyBmaWxlcyB3b3VsZCBiZSBvdmVyd3JpdHRlbiBieSBtZXJnZTpcbiIKICIlJXMiCiBtc2dzdHIgIiIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTIxCisjOiB1bnBhY2stdHJlZXMuYzoxMjAKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIllvdXIgbG9jYWwgY2hhbmdlcyB0byB0aGUgZm9sbG93aW5nIGZpbGVzIHdvdWxkIGJlIG92ZXJ3cml0dGVuIGJ5ICVzOlxuIgogIiUlc1BsZWFzZSBjb21taXQgeW91ciBjaGFuZ2VzIG9yIHN0YXNoIHRoZW0gYmVmb3JlIHlvdSAlcy4iCiBtc2dzdHIgIiIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTIzCisjOiB1bnBhY2stdHJlZXMuYzoxMjIKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIllvdXIgbG9jYWwgY2hhbmdlcyB0byB0aGUgZm9sbG93aW5nIGZpbGVzIHdvdWxkIGJlIG92ZXJ3cml0dGVuIGJ5ICVzOlxuIgogIiUlcyIKIG1zZ3N0ciAiIgogCi0jOiB1bnBhY2stdHJlZXMuYzoxMjgKKyM6IHVucGFjay10cmVlcy5jOjEyNwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiVXBkYXRpbmcgdGhlIGZvbGxvd2luZyBkaXJlY3RvcmllcyB3b3VsZCBsb3NlIHVudHJhY2tlZCBmaWxlcyBpbiB0aGVtOlxuIgogIiVzIgogbXNnc3RyICIiCiAKLSM6IHVucGFjay10cmVlcy5jOjEzMgorIzogdW5wYWNrLXRyZWVzLmM6MTMxCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgZm9sbG93aW5nIHVudHJhY2tlZCB3b3JraW5nIHRyZWUgZmlsZXMgd291bGQgYmUgcmVtb3ZlZCBieSBjaGVja291dDpcbiIKICIlJXNQbGVhc2UgbW92ZSBvciByZW1vdmUgdGhlbSBiZWZvcmUgeW91IHN3aXRjaCBicmFuY2hlcy4iCiBtc2dzdHIgIiIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTM0CisjOiB1bnBhY2stdHJlZXMuYzoxMzMKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlRoZSBmb2xsb3dpbmcgdW50cmFja2VkIHdvcmtpbmcgdHJlZSBmaWxlcyB3b3VsZCBiZSByZW1vdmVkIGJ5IGNoZWNrb3V0OlxuIgogIiUlcyIKIG1zZ3N0ciAiIgogCi0jOiB1bnBhY2stdHJlZXMuYzoxMzcKKyM6IHVucGFjay10cmVlcy5jOjEzNgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiVGhlIGZvbGxvd2luZyB1bnRyYWNrZWQgd29ya2luZyB0cmVlIGZpbGVzIHdvdWxkIGJlIHJlbW92ZWQgYnkgbWVyZ2U6XG4iCiAiJSVzUGxlYXNlIG1vdmUgb3IgcmVtb3ZlIHRoZW0gYmVmb3JlIHlvdSBtZXJnZS4iCiBtc2dzdHIgIiIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTM5CisjOiB1bnBhY2stdHJlZXMuYzoxMzgKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlRoZSBmb2xsb3dpbmcgdW50cmFja2VkIHdvcmtpbmcgdHJlZSBmaWxlcyB3b3VsZCBiZSByZW1vdmVkIGJ5IG1lcmdlOlxuIgogIiUlcyIKIG1zZ3N0ciAiIgogCi0jOiB1bnBhY2stdHJlZXMuYzoxNDIKKyM6IHVucGFjay10cmVlcy5jOjE0MQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiVGhlIGZvbGxvd2luZyB1bnRyYWNrZWQgd29ya2luZyB0cmVlIGZpbGVzIHdvdWxkIGJlIHJlbW92ZWQgYnkgJXM6XG4iCiAiJSVzUGxlYXNlIG1vdmUgb3IgcmVtb3ZlIHRoZW0gYmVmb3JlIHlvdSAlcy4iCiBtc2dzdHIgIiIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTQ0CisjOiB1bnBhY2stdHJlZXMuYzoxNDMKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlRoZSBmb2xsb3dpbmcgdW50cmFja2VkIHdvcmtpbmcgdHJlZSBmaWxlcyB3b3VsZCBiZSByZW1vdmVkIGJ5ICVzOlxuIgogIiUlcyIKIG1zZ3N0ciAiIgogCi0jOiB1bnBhY2stdHJlZXMuYzoxNTAKKyM6IHVucGFjay10cmVlcy5jOjE0OQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiVGhlIGZvbGxvd2luZyB1bnRyYWNrZWQgd29ya2luZyB0cmVlIGZpbGVzIHdvdWxkIGJlIG92ZXJ3cml0dGVuIGJ5ICIKQEAgLTcyMDIsNyArNzIzMSw3IEBACiAiJSVzUGxlYXNlIG1vdmUgb3IgcmVtb3ZlIHRoZW0gYmVmb3JlIHlvdSBzd2l0Y2ggYnJhbmNoZXMuIgogbXNnc3RyICIiCiAKLSM6IHVucGFjay10cmVlcy5jOjE1MgorIzogdW5wYWNrLXRyZWVzLmM6MTUxCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgZm9sbG93aW5nIHVudHJhY2tlZCB3b3JraW5nIHRyZWUgZmlsZXMgd291bGQgYmUgb3ZlcndyaXR0ZW4gYnkgIgpAQCAtNzIxMCw0NyArNzIzOSw0NyBAQAogIiUlcyIKIG1zZ3N0ciAiIgogCi0jOiB1bnBhY2stdHJlZXMuYzoxNTUKKyM6IHVucGFjay10cmVlcy5jOjE1NAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiVGhlIGZvbGxvd2luZyB1bnRyYWNrZWQgd29ya2luZyB0cmVlIGZpbGVzIHdvdWxkIGJlIG92ZXJ3cml0dGVuIGJ5IG1lcmdlOlxuIgogIiUlc1BsZWFzZSBtb3ZlIG9yIHJlbW92ZSB0aGVtIGJlZm9yZSB5b3UgbWVyZ2UuIgogbXNnc3RyICIiCiAKLSM6IHVucGFjay10cmVlcy5jOjE1NworIzogdW5wYWNrLXRyZWVzLmM6MTU2CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgZm9sbG93aW5nIHVudHJhY2tlZCB3b3JraW5nIHRyZWUgZmlsZXMgd291bGQgYmUgb3ZlcndyaXR0ZW4gYnkgbWVyZ2U6XG4iCiAiJSVzIgogbXNnc3RyICIiCiAKLSM6IHVucGFjay10cmVlcy5jOjE2MAorIzogdW5wYWNrLXRyZWVzLmM6MTU5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgZm9sbG93aW5nIHVudHJhY2tlZCB3b3JraW5nIHRyZWUgZmlsZXMgd291bGQgYmUgb3ZlcndyaXR0ZW4gYnkgJXM6XG4iCiAiJSVzUGxlYXNlIG1vdmUgb3IgcmVtb3ZlIHRoZW0gYmVmb3JlIHlvdSAlcy4iCiBtc2dzdHIgIiIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTYyCisjOiB1bnBhY2stdHJlZXMuYzoxNjEKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlRoZSBmb2xsb3dpbmcgdW50cmFja2VkIHdvcmtpbmcgdHJlZSBmaWxlcyB3b3VsZCBiZSBvdmVyd3JpdHRlbiBieSAlczpcbiIKICIlJXMiCiBtc2dzdHIgIiIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTcwCisjOiB1bnBhY2stdHJlZXMuYzoxNjkKICMsIGMtZm9ybWF0CiBtc2dpZCAiRW50cnkgJyVzJyBvdmVybGFwcyB3aXRoICclcycuICBDYW5ub3QgYmluZC4iCiBtc2dzdHIgIiIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTczCisjOiB1bnBhY2stdHJlZXMuYzoxNzIKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkNhbm5vdCB1cGRhdGUgc3BhcnNlIGNoZWNrb3V0OiB0aGUgZm9sbG93aW5nIGVudHJpZXMgYXJlIG5vdCB1cCB0byBkYXRlOlxuIgogIiVzIgogbXNnc3RyICIiCiAKLSM6IHVucGFjay10cmVlcy5jOjE3NQorIzogdW5wYWNrLXRyZWVzLmM6MTc0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgZm9sbG93aW5nIHdvcmtpbmcgdHJlZSBmaWxlcyB3b3VsZCBiZSBvdmVyd3JpdHRlbiBieSBzcGFyc2UgY2hlY2tvdXQgIgpAQCAtNzI1OCw3ICs3Mjg3LDcgQEAKICIlcyIKIG1zZ3N0ciAiIgogCi0jOiB1bnBhY2stdHJlZXMuYzoxNzcKKyM6IHVucGFjay10cmVlcy5jOjE3NgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiVGhlIGZvbGxvd2luZyB3b3JraW5nIHRyZWUgZmlsZXMgd291bGQgYmUgcmVtb3ZlZCBieSBzcGFyc2UgY2hlY2tvdXQgIgpAQCAtNzI2NiwyMyArNzI5NSwyMyBAQAogIiVzIgogbXNnc3RyICIiCiAKLSM6IHVucGFjay10cmVlcy5jOjE3OQorIzogdW5wYWNrLXRyZWVzLmM6MTc4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJDYW5ub3QgdXBkYXRlIHN1Ym1vZHVsZTpcbiIKICIlcyIKIG1zZ3N0ciAiIgogCi0jOiB1bnBhY2stdHJlZXMuYzoyNTYKKyM6IHVucGFjay10cmVlcy5jOjI1NQogIywgYy1mb3JtYXQKIG1zZ2lkICJBYm9ydGluZ1xuIgogbXNnc3RyICIiCiAKLSM6IHVucGFjay10cmVlcy5jOjMxOAorIzogdW5wYWNrLXRyZWVzLmM6MzE3CiBtc2dpZCAiVXBkYXRpbmcgZmlsZXMiCiBtc2dzdHIgIiIKIAotIzogdW5wYWNrLXRyZWVzLmM6MzUwCisjOiB1bnBhY2stdHJlZXMuYzozNDkKIG1zZ2lkICIiCiAidGhlIGZvbGxvd2luZyBwYXRocyBoYXZlIGNvbGxpZGVkIChlLmcuIGNhc2Utc2Vuc2l0aXZlIHBhdGhzXG4iCiAib24gYSBjYXNlLWluc2Vuc2l0aXZlIGZpbGVzeXN0ZW0pIGFuZCBvbmx5IG9uZSBmcm9tIHRoZSBzYW1lXG4iCkBAIC03MzE4LDcgKzczNDcsNyBAQAogbXNnaWQgImludmFsaWQgJy4uJyBwYXRoIHNlZ21lbnQiCiBtc2dzdHIgIiIKIAotIzogd29ya3RyZWUuYzoyNTggYnVpbHRpbi9hbS5jOjIwOTUKKyM6IHdvcmt0cmVlLmM6MjU4IGJ1aWx0aW4vYW0uYzoyMDg0CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byByZWFkICclcyciCiBtc2dzdHIgIiIKQEAgLTczNDgsMTcgKzczNzcsMTcgQEAKIG1zZ2lkICInJXMnIGRvZXMgbm90IHBvaW50IGJhY2sgdG8gJyVzJyIKIG1zZ3N0ciAiIgogCi0jOiB3cmFwcGVyLmM6MjIzIHdyYXBwZXIuYzozOTMKKyM6IHdyYXBwZXIuYzoxODYgd3JhcHBlci5jOjM1NgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3Qgb3BlbiAnJXMnIGZvciByZWFkaW5nIGFuZCB3cml0aW5nIgogbXNnc3RyICIiCiAKLSM6IHdyYXBwZXIuYzo0MjQgd3JhcHBlci5jOjYyNAorIzogd3JhcHBlci5jOjM4NyB3cmFwcGVyLmM6NTg4CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBhY2Nlc3MgJyVzJyIKIG1zZ3N0ciAiIgogCi0jOiB3cmFwcGVyLmM6NjMyCisjOiB3cmFwcGVyLmM6NTk2CiBtc2dpZCAidW5hYmxlIHRvIGdldCBjdXJyZW50IHdvcmtpbmcgZGlyZWN0b3J5IgogbXNnc3RyICIiCiAKQEAgLTc2NzYsODAgKzc3MDUsODggQEAKIG1zZ3N0ciAiIgogCiAjOiB3dC1zdGF0dXMuYzoxNDM3Cittc2dpZCAiICAodXNlIFwiZ2l0IGNoZXJyeS1waWNrIC0tc2tpcFwiIHRvIHNraXAgdGhpcyBwYXRjaCkiCittc2dzdHIgIiIKKworIzogd3Qtc3RhdHVzLmM6MTQzOQogbXNnaWQgIiAgKHVzZSBcImdpdCBjaGVycnktcGljayAtLWFib3J0XCIgdG8gY2FuY2VsIHRoZSBjaGVycnktcGljayBvcGVyYXRpb24pIgogbXNnc3RyICIiCiAKLSM6IHd0LXN0YXR1cy5jOjE0NDcKKyM6IHd0LXN0YXR1cy5jOjE0NDkKIG1zZ2lkICJSZXZlcnQgY3VycmVudGx5IGluIHByb2dyZXNzLiIKIG1zZ3N0ciAiIgogCi0jOiB3dC1zdGF0dXMuYzoxNDUwCisjOiB3dC1zdGF0dXMuYzoxNDUyCiAjLCBjLWZvcm1hdAogbXNnaWQgIllvdSBhcmUgY3VycmVudGx5IHJldmVydGluZyBjb21taXQgJXMuIgogbXNnc3RyICIiCiAKLSM6IHd0LXN0YXR1cy5jOjE0NTYKKyM6IHd0LXN0YXR1cy5jOjE0NTgKIG1zZ2lkICIgIChmaXggY29uZmxpY3RzIGFuZCBydW4gXCJnaXQgcmV2ZXJ0IC0tY29udGludWVcIikiCiBtc2dzdHIgIiIKIAotIzogd3Qtc3RhdHVzLmM6MTQ1OQorIzogd3Qtc3RhdHVzLmM6MTQ2MQogbXNnaWQgIiAgKHJ1biBcImdpdCByZXZlcnQgLS1jb250aW51ZVwiIHRvIGNvbnRpbnVlKSIKIG1zZ3N0ciAiIgogCi0jOiB3dC1zdGF0dXMuYzoxNDYyCisjOiB3dC1zdGF0dXMuYzoxNDY0CiBtc2dpZCAiICAoYWxsIGNvbmZsaWN0cyBmaXhlZDogcnVuIFwiZ2l0IHJldmVydCAtLWNvbnRpbnVlXCIpIgogbXNnc3RyICIiCiAKLSM6IHd0LXN0YXR1cy5jOjE0NjQKKyM6IHd0LXN0YXR1cy5jOjE0NjYKK21zZ2lkICIgICh1c2UgXCJnaXQgcmV2ZXJ0IC0tc2tpcFwiIHRvIHNraXAgdGhpcyBwYXRjaCkiCittc2dzdHIgIiIKKworIzogd3Qtc3RhdHVzLmM6MTQ2OAogbXNnaWQgIiAgKHVzZSBcImdpdCByZXZlcnQgLS1hYm9ydFwiIHRvIGNhbmNlbCB0aGUgcmV2ZXJ0IG9wZXJhdGlvbikiCiBtc2dzdHIgIiIKIAotIzogd3Qtc3RhdHVzLmM6MTQ3NAorIzogd3Qtc3RhdHVzLmM6MTQ3OAogIywgYy1mb3JtYXQKIG1zZ2lkICJZb3UgYXJlIGN1cnJlbnRseSBiaXNlY3RpbmcsIHN0YXJ0ZWQgZnJvbSBicmFuY2ggJyVzJy4iCiBtc2dzdHIgIiIKIAotIzogd3Qtc3RhdHVzLmM6MTQ3OAorIzogd3Qtc3RhdHVzLmM6MTQ4MgogbXNnaWQgIllvdSBhcmUgY3VycmVudGx5IGJpc2VjdGluZy4iCiBtc2dzdHIgIiIKIAotIzogd3Qtc3RhdHVzLmM6MTQ4MQorIzogd3Qtc3RhdHVzLmM6MTQ4NQogbXNnaWQgIiAgKHVzZSBcImdpdCBiaXNlY3QgcmVzZXRcIiB0byBnZXQgYmFjayB0byB0aGUgb3JpZ2luYWwgYnJhbmNoKSIKIG1zZ3N0ciAiIgogCi0jOiB3dC1zdGF0dXMuYzoxNjkwCisjOiB3dC1zdGF0dXMuYzoxNjk0CiBtc2dpZCAiT24gYnJhbmNoICIKIG1zZ3N0ciAiIgogCi0jOiB3dC1zdGF0dXMuYzoxNjk3CisjOiB3dC1zdGF0dXMuYzoxNzAxCiBtc2dpZCAiaW50ZXJhY3RpdmUgcmViYXNlIGluIHByb2dyZXNzOyBvbnRvICIKIG1zZ3N0ciAiIgogCi0jOiB3dC1zdGF0dXMuYzoxNjk5CisjOiB3dC1zdGF0dXMuYzoxNzAzCiBtc2dpZCAicmViYXNlIGluIHByb2dyZXNzOyBvbnRvICIKIG1zZ3N0ciAiIgogCi0jOiB3dC1zdGF0dXMuYzoxNzA5CisjOiB3dC1zdGF0dXMuYzoxNzEzCiBtc2dpZCAiTm90IGN1cnJlbnRseSBvbiBhbnkgYnJhbmNoLiIKIG1zZ3N0ciAiIgogCi0jOiB3dC1zdGF0dXMuYzoxNzI2CisjOiB3dC1zdGF0dXMuYzoxNzMwCiBtc2dpZCAiSW5pdGlhbCBjb21taXQiCiBtc2dzdHIgIiIKIAotIzogd3Qtc3RhdHVzLmM6MTcyNworIzogd3Qtc3RhdHVzLmM6MTczMQogbXNnaWQgIk5vIGNvbW1pdHMgeWV0IgogbXNnc3RyICIiCiAKLSM6IHd0LXN0YXR1cy5jOjE3NDEKKyM6IHd0LXN0YXR1cy5jOjE3NDUKIG1zZ2lkICJVbnRyYWNrZWQgZmlsZXMiCiBtc2dzdHIgIiIKIAotIzogd3Qtc3RhdHVzLmM6MTc0MworIzogd3Qtc3RhdHVzLmM6MTc0NwogbXNnaWQgIklnbm9yZWQgZmlsZXMiCiBtc2dzdHIgIiIKIAotIzogd3Qtc3RhdHVzLmM6MTc0NworIzogd3Qtc3RhdHVzLmM6MTc1MQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiSXQgdG9vayAlLjJmIHNlY29uZHMgdG8gZW51bWVyYXRlIHVudHJhY2tlZCBmaWxlcy4gJ3N0YXR1cyAtdW5vJ1xuIgpAQCAtNzc1Nyw5NiArNzc5NCwxMDEgQEAKICJuZXcgZmlsZXMgeW91cnNlbGYgKHNlZSAnZ2l0IGhlbHAgc3RhdHVzJykuIgogbXNnc3RyICIiCiAKLSM6IHd0LXN0YXR1cy5jOjE3NTMKKyM6IHd0LXN0YXR1cy5jOjE3NTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiVW50cmFja2VkIGZpbGVzIG5vdCBsaXN0ZWQlcyIKIG1zZ3N0ciAiIgogCi0jOiB3dC1zdGF0dXMuYzoxNzU1CisjOiB3dC1zdGF0dXMuYzoxNzU5CiBtc2dpZCAiICh1c2UgLXUgb3B0aW9uIHRvIHNob3cgdW50cmFja2VkIGZpbGVzKSIKIG1zZ3N0ciAiIgogCi0jOiB3dC1zdGF0dXMuYzoxNzYxCisjOiB3dC1zdGF0dXMuYzoxNzY1CiBtc2dpZCAiTm8gY2hhbmdlcyIKIG1zZ3N0ciAiIgogCi0jOiB3dC1zdGF0dXMuYzoxNzY2CisjOiB3dC1zdGF0dXMuYzoxNzcwCiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vIGNoYW5nZXMgYWRkZWQgdG8gY29tbWl0ICh1c2UgXCJnaXQgYWRkXCIgYW5kL29yIFwiZ2l0IGNvbW1pdCAtYVwiKVxuIgogbXNnc3RyICIiCiAKLSM6IHd0LXN0YXR1cy5jOjE3NjkKKyM6IHd0LXN0YXR1cy5jOjE3NzMKICMsIGMtZm9ybWF0CiBtc2dpZCAibm8gY2hhbmdlcyBhZGRlZCB0byBjb21taXRcbiIKIG1zZ3N0ciAiIgogCi0jOiB3dC1zdGF0dXMuYzoxNzcyCisjOiB3dC1zdGF0dXMuYzoxNzc2CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJub3RoaW5nIGFkZGVkIHRvIGNvbW1pdCBidXQgdW50cmFja2VkIGZpbGVzIHByZXNlbnQgKHVzZSBcImdpdCBhZGRcIiB0byAiCiAidHJhY2spXG4iCiBtc2dzdHIgIiIKIAotIzogd3Qtc3RhdHVzLmM6MTc3NQorIzogd3Qtc3RhdHVzLmM6MTc3OQogIywgYy1mb3JtYXQKIG1zZ2lkICJub3RoaW5nIGFkZGVkIHRvIGNvbW1pdCBidXQgdW50cmFja2VkIGZpbGVzIHByZXNlbnRcbiIKIG1zZ3N0ciAiIgogCi0jOiB3dC1zdGF0dXMuYzoxNzc4CisjOiB3dC1zdGF0dXMuYzoxNzgyCiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vdGhpbmcgdG8gY29tbWl0IChjcmVhdGUvY29weSBmaWxlcyBhbmQgdXNlIFwiZ2l0IGFkZFwiIHRvIHRyYWNrKVxuIgogbXNnc3RyICIiCiAKLSM6IHd0LXN0YXR1cy5jOjE3ODEgd3Qtc3RhdHVzLmM6MTc4NgorIzogd3Qtc3RhdHVzLmM6MTc4NSB3dC1zdGF0dXMuYzoxNzkwCiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vdGhpbmcgdG8gY29tbWl0XG4iCiBtc2dzdHIgIiIKIAotIzogd3Qtc3RhdHVzLmM6MTc4NAorIzogd3Qtc3RhdHVzLmM6MTc4OAogIywgYy1mb3JtYXQKIG1zZ2lkICJub3RoaW5nIHRvIGNvbW1pdCAodXNlIC11IHRvIHNob3cgdW50cmFja2VkIGZpbGVzKVxuIgogbXNnc3RyICIiCiAKLSM6IHd0LXN0YXR1cy5jOjE3ODgKKyM6IHd0LXN0YXR1cy5jOjE3OTIKICMsIGMtZm9ybWF0CiBtc2dpZCAibm90aGluZyB0byBjb21taXQsIHdvcmtpbmcgdHJlZSBjbGVhblxuIgogbXNnc3RyICIiCiAKLSM6IHd0LXN0YXR1cy5jOjE5MDEKKyM6IHd0LXN0YXR1cy5jOjE5MDUKIG1zZ2lkICJObyBjb21taXRzIHlldCBvbiAiCiBtc2dzdHIgIiIKIAotIzogd3Qtc3RhdHVzLmM6MTkwNQorIzogd3Qtc3RhdHVzLmM6MTkwOQogbXNnaWQgIkhFQUQgKG5vIGJyYW5jaCkiCiBtc2dzdHIgIiIKIAotIzogd3Qtc3RhdHVzLmM6MTkzNgorIzogd3Qtc3RhdHVzLmM6MTk0MAogbXNnaWQgImRpZmZlcmVudCIKIG1zZ3N0ciAiIgogCi0jOiB3dC1zdGF0dXMuYzoxOTM4IHd0LXN0YXR1cy5jOjE5NDYKKyM6IHd0LXN0YXR1cy5jOjE5NDIgd3Qtc3RhdHVzLmM6MTk1MAogbXNnaWQgImJlaGluZCAiCiBtc2dzdHIgIiIKIAotIzogd3Qtc3RhdHVzLmM6MTk0MSB3dC1zdGF0dXMuYzoxOTQ0CisjOiB3dC1zdGF0dXMuYzoxOTQ1IHd0LXN0YXR1cy5jOjE5NDgKIG1zZ2lkICJhaGVhZCAiCiBtc2dzdHIgIiIKIAogIy4gVFJBTlNMQVRPUlM6IHRoZSBhY3Rpb24gaXMgZS5nLiAicHVsbCB3aXRoIHJlYmFzZSIKLSM6IHd0LXN0YXR1cy5jOjI0NjYKKyM6IHd0LXN0YXR1cy5jOjI0NzAKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90ICVzOiBZb3UgaGF2ZSB1bnN0YWdlZCBjaGFuZ2VzLiIKIG1zZ3N0ciAiIgogCi0jOiB3dC1zdGF0dXMuYzoyNDcyCisjOiB3dC1zdGF0dXMuYzoyNDc2CiBtc2dpZCAiYWRkaXRpb25hbGx5LCB5b3VyIGluZGV4IGNvbnRhaW5zIHVuY29tbWl0dGVkIGNoYW5nZXMuIgogbXNnc3RyICIiCiAKLSM6IHd0LXN0YXR1cy5jOjI0NzQKKyM6IHd0LXN0YXR1cy5jOjI0NzgKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90ICVzOiBZb3VyIGluZGV4IGNvbnRhaW5zIHVuY29tbWl0dGVkIGNoYW5nZXMuIgogbXNnc3RyICIiCiAKKyM6IGNvbXBhdC9wcmVjb21wb3NlX3V0ZjguYzo1OCBidWlsdGluL2Nsb25lLmM6NDUyCisjLCBjLWZvcm1hdAorbXNnaWQgImZhaWxlZCB0byB1bmxpbmsgJyVzJyIKK21zZ3N0ciAiIgorCiAjOiBidWlsdGluL2FkZC5jOjI1CiBtc2dpZCAiZ2l0IGFkZCBbPG9wdGlvbnM+XSBbLS1dIDxwYXRoc3BlYz4uLi4iCiBtc2dzdHIgIiIKQEAgLTc4NjksNyArNzkxMSw3IEBACiBtc2dpZCAiVW5zdGFnZWQgY2hhbmdlcyBhZnRlciByZWZyZXNoaW5nIHRoZSBpbmRleDoiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9hZGQuYzoyMzQgYnVpbHRpbi9yZXYtcGFyc2UuYzo4OTYKKyM6IGJ1aWx0aW4vYWRkLmM6MjM0IGJ1aWx0aW4vcmV2LXBhcnNlLmM6ODk3CiBtc2dpZCAiQ291bGQgbm90IHJlYWQgdGhlIGluZGV4IgogbXNnc3RyICIiCiAKQEAgLTc5MDQsOCArNzk0Niw4IEBACiBtc2dpZCAiVGhlIGZvbGxvd2luZyBwYXRocyBhcmUgaWdub3JlZCBieSBvbmUgb2YgeW91ciAuZ2l0aWdub3JlIGZpbGVzOlxuIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vYWRkLmM6MjkwIGJ1aWx0aW4vY2xlYW4uYzo5MDkgYnVpbHRpbi9mZXRjaC5jOjE0NyBidWlsdGluL212LmM6MTI0Ci0jOiBidWlsdGluL3BydW5lLXBhY2tlZC5jOjU2IGJ1aWx0aW4vcHVsbC5jOjIyMiBidWlsdGluL3B1c2guYzo1NjAKKyM6IGJ1aWx0aW4vYWRkLmM6MjkwIGJ1aWx0aW4vY2xlYW4uYzo5MTAgYnVpbHRpbi9mZXRjaC5jOjE2MiBidWlsdGluL212LmM6MTI0CisjOiBidWlsdGluL3BydW5lLXBhY2tlZC5jOjU2IGJ1aWx0aW4vcHVsbC5jOjIyMyBidWlsdGluL3B1c2guYzo1NDcKICM6IGJ1aWx0aW4vcmVtb3RlLmM6MTM0NSBidWlsdGluL3JtLmM6MjQxIGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTY1CiBtc2dpZCAiZHJ5IHJ1biIKIG1zZ3N0ciAiIgpAQCAtNzk1OCw3ICs4MDAwLDcgQEAKIG1zZ2lkICJjaGVjayBpZiAtIGV2ZW4gbWlzc2luZyAtIGZpbGVzIGFyZSBpZ25vcmVkIGluIGRyeSBydW4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9hZGQuYzozMDkgYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDAxCisjOiBidWlsdGluL2FkZC5jOjMwOSBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMDIKIG1zZ2lkICJvdmVycmlkZSB0aGUgZXhlY3V0YWJsZSBiaXQgb2YgdGhlIGxpc3RlZCBmaWxlcyIKIG1zZ3N0ciAiIgogCkBAIC04MDIxLDEzMiArODA2MywxMjggQEAKIG1zZ2lkICJNYXliZSB5b3Ugd2FudGVkIHRvIHNheSAnZ2l0IGFkZCAuJz9cbiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2FtLmM6MzQ4CisjOiBidWlsdGluL2FtLmM6MzQ3CiBtc2dpZCAiY291bGQgbm90IHBhcnNlIGF1dGhvciBzY3JpcHQiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9hbS5jOjQzMgorIzogYnVpbHRpbi9hbS5jOjQzMQogIywgYy1mb3JtYXQKIG1zZ2lkICInJXMnIHdhcyBkZWxldGVkIGJ5IHRoZSBhcHBseXBhdGNoLW1zZyBob29rIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vYW0uYzo0NzQKKyM6IGJ1aWx0aW4vYW0uYzo0NzMKICMsIGMtZm9ybWF0CiBtc2dpZCAiTWFsZm9ybWVkIGlucHV0IGxpbmU6ICclcycuIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vYW0uYzo1MTIKKyM6IGJ1aWx0aW4vYW0uYzo1MTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiRmFpbGVkIHRvIGNvcHkgbm90ZXMgZnJvbSAnJXMnIHRvICclcyciCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9hbS5jOjUzOAorIzogYnVpbHRpbi9hbS5jOjUzNwogbXNnaWQgImZzZWVrIGZhaWxlZCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2FtLmM6NzI2CisjOiBidWlsdGluL2FtLmM6NzI1CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBwYXJzZSBwYXRjaCAnJXMnIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vYW0uYzo3OTEKKyM6IGJ1aWx0aW4vYW0uYzo3OTAKIG1zZ2lkICJPbmx5IG9uZSBTdEdJVCBwYXRjaCBzZXJpZXMgY2FuIGJlIGFwcGxpZWQgYXQgb25jZSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2FtLmM6ODM5CisjOiBidWlsdGluL2FtLmM6ODM4CiBtc2dpZCAiaW52YWxpZCB0aW1lc3RhbXAiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9hbS5jOjg0NCBidWlsdGluL2FtLmM6ODU2CisjOiBidWlsdGluL2FtLmM6ODQzIGJ1aWx0aW4vYW0uYzo4NTUKIG1zZ2lkICJpbnZhbGlkIERhdGUgbGluZSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2FtLmM6ODUxCisjOiBidWlsdGluL2FtLmM6ODUwCiBtc2dpZCAiaW52YWxpZCB0aW1lem9uZSBvZmZzZXQiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9hbS5jOjk0NAorIzogYnVpbHRpbi9hbS5jOjk0MwogbXNnaWQgIlBhdGNoIGZvcm1hdCBkZXRlY3Rpb24gZmFpbGVkLiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2FtLmM6OTQ5IGJ1aWx0aW4vY2xvbmUuYzo0MDcKKyM6IGJ1aWx0aW4vYW0uYzo5NDggYnVpbHRpbi9jbG9uZS5jOjQwNgogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gY3JlYXRlIGRpcmVjdG9yeSAnJXMnIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vYW0uYzo5NTQKKyM6IGJ1aWx0aW4vYW0uYzo5NTMKIG1zZ2lkICJGYWlsZWQgdG8gc3BsaXQgcGF0Y2hlcy4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9hbS5jOjEwODQgYnVpbHRpbi9jb21taXQuYzozNzQKLW1zZ2lkICJ1bmFibGUgdG8gd3JpdGUgaW5kZXggZmlsZSIKLW1zZ3N0ciAiIgotCi0jOiBidWlsdGluL2FtLmM6MTA5OAorIzogYnVpbHRpbi9hbS5jOjEwODQKICMsIGMtZm9ybWF0CiBtc2dpZCAiV2hlbiB5b3UgaGF2ZSByZXNvbHZlZCB0aGlzIHByb2JsZW0sIHJ1biBcIiVzIC0tY29udGludWVcIi4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9hbS5jOjEwOTkKKyM6IGJ1aWx0aW4vYW0uYzoxMDg1CiAjLCBjLWZvcm1hdAogbXNnaWQgIklmIHlvdSBwcmVmZXIgdG8gc2tpcCB0aGlzIHBhdGNoLCBydW4gXCIlcyAtLXNraXBcIiBpbnN0ZWFkLiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2FtLmM6MTEwMAorIzogYnVpbHRpbi9hbS5jOjEwODYKICMsIGMtZm9ybWF0CiBtc2dpZCAiVG8gcmVzdG9yZSB0aGUgb3JpZ2luYWwgYnJhbmNoIGFuZCBzdG9wIHBhdGNoaW5nLCBydW4gXCIlcyAtLWFib3J0XCIuIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vYW0uYzoxMTgzCisjOiBidWlsdGluL2FtLmM6MTE2OQogbXNnaWQgIlBhdGNoIHNlbnQgd2l0aCBmb3JtYXQ9Zmxvd2VkOyBzcGFjZSBhdCB0aGUgZW5kIG9mIGxpbmVzIG1pZ2h0IGJlIGxvc3QuIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vYW0uYzoxMjExCisjOiBidWlsdGluL2FtLmM6MTE5NwogbXNnaWQgIlBhdGNoIGlzIGVtcHR5LiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2FtLmM6MTI3NworIzogYnVpbHRpbi9hbS5jOjEyNjIKKyMsIGMtZm9ybWF0Cittc2dpZCAibWlzc2luZyBhdXRob3IgbGluZSBpbiBjb21taXQgJXMiCittc2dzdHIgIiIKKworIzogYnVpbHRpbi9hbS5jOjEyNjUKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBpZGVudCBsaW5lOiAlLipzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vYW0uYzoxMjk5Ci0jLCBjLWZvcm1hdAotbXNnaWQgInVuYWJsZSB0byBwYXJzZSBjb21taXQgJXMiCi1tc2dzdHIgIiIKLQotIzogYnVpbHRpbi9hbS5jOjE0OTYKKyM6IGJ1aWx0aW4vYW0uYzoxNDg0CiBtc2dpZCAiUmVwb3NpdG9yeSBsYWNrcyBuZWNlc3NhcnkgYmxvYnMgdG8gZmFsbCBiYWNrIG9uIDMtd2F5IG1lcmdlLiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2FtLmM6MTQ5OAorIzogYnVpbHRpbi9hbS5jOjE0ODYKIG1zZ2lkICJVc2luZyBpbmRleCBpbmZvIHRvIHJlY29uc3RydWN0IGEgYmFzZSB0cmVlLi4uIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vYW0uYzoxNTE3CisjOiBidWlsdGluL2FtLmM6MTUwNQogbXNnaWQgIiIKICJEaWQgeW91IGhhbmQgZWRpdCB5b3VyIHBhdGNoP1xuIgogIkl0IGRvZXMgbm90IGFwcGx5IHRvIGJsb2JzIHJlY29yZGVkIGluIGl0cyBpbmRleC4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9hbS5jOjE1MjMKKyM6IGJ1aWx0aW4vYW0uYzoxNTExCiBtc2dpZCAiRmFsbGluZyBiYWNrIHRvIHBhdGNoaW5nIGJhc2UgYW5kIDMtd2F5IG1lcmdlLi4uIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vYW0uYzoxNTQ5CisjOiBidWlsdGluL2FtLmM6MTUzNwogbXNnaWQgIkZhaWxlZCB0byBtZXJnZSBpbiB0aGUgY2hhbmdlcy4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9hbS5jOjE1ODEKKyM6IGJ1aWx0aW4vYW0uYzoxNTY5CiBtc2dpZCAiYXBwbHlpbmcgdG8gYW4gZW1wdHkgaGlzdG9yeSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2FtLmM6MTYyOCBidWlsdGluL2FtLmM6MTYzMgorIzogYnVpbHRpbi9hbS5jOjE2MTYgYnVpbHRpbi9hbS5jOjE2MjAKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IHJlc3VtZTogJXMgZG9lcyBub3QgZXhpc3QuIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vYW0uYzoxNjUwCisjOiBidWlsdGluL2FtLmM6MTYzOAogbXNnaWQgIkNvbW1pdCBCb2R5IGlzOiIKIG1zZ3N0ciAiIgogCkBAIC04MTU0LDQyICs4MTkyLDQ2IEBACiAjLiBpbiB5b3VyIHRyYW5zbGF0aW9uLiBUaGUgcHJvZ3JhbSB3aWxsIG9ubHkgYWNjZXB0IEVuZ2xpc2gKICMuIGlucHV0IGF0IHRoaXMgcG9pbnQuCiAjLgotIzogYnVpbHRpbi9hbS5jOjE2NjAKKyM6IGJ1aWx0aW4vYW0uYzoxNjQ4CiAjLCBjLWZvcm1hdAogbXNnaWQgIkFwcGx5PyBbeV1lcy9bbl1vL1tlXWRpdC9bdl1pZXcgcGF0Y2gvW2FdY2NlcHQgYWxsOiAiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9hbS5jOjE3MTAKKyM6IGJ1aWx0aW4vYW0uYzoxNjk1IGJ1aWx0aW4vY29tbWl0LmM6Mzc0Cittc2dpZCAidW5hYmxlIHRvIHdyaXRlIGluZGV4IGZpbGUiCittc2dzdHIgIiIKKworIzogYnVpbHRpbi9hbS5jOjE2OTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiRGlydHkgaW5kZXg6IGNhbm5vdCBhcHBseSBwYXRjaGVzIChkaXJ0eTogJXMpIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vYW0uYzoxNzUwIGJ1aWx0aW4vYW0uYzoxODE4CisjOiBidWlsdGluL2FtLmM6MTczOSBidWlsdGluL2FtLmM6MTgwNwogIywgYy1mb3JtYXQKIG1zZ2lkICJBcHBseWluZzogJS4qcyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2FtLmM6MTc2NworIzogYnVpbHRpbi9hbS5jOjE3NTYKIG1zZ2lkICJObyBjaGFuZ2VzIC0tIFBhdGNoIGFscmVhZHkgYXBwbGllZC4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9hbS5jOjE3NzMKKyM6IGJ1aWx0aW4vYW0uYzoxNzYyCiAjLCBjLWZvcm1hdAogbXNnaWQgIlBhdGNoIGZhaWxlZCBhdCAlcyAlLipzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vYW0uYzoxNzc3CisjOiBidWlsdGluL2FtLmM6MTc2NgogbXNnaWQgIlVzZSAnZ2l0IGFtIC0tc2hvdy1jdXJyZW50LXBhdGNoJyB0byBzZWUgdGhlIGZhaWxlZCBwYXRjaCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2FtLmM6MTgyMQorIzogYnVpbHRpbi9hbS5jOjE4MTAKIG1zZ2lkICIiCiAiTm8gY2hhbmdlcyAtIGRpZCB5b3UgZm9yZ2V0IHRvIHVzZSAnZ2l0IGFkZCc/XG4iCiAiSWYgdGhlcmUgaXMgbm90aGluZyBsZWZ0IHRvIHN0YWdlLCBjaGFuY2VzIGFyZSB0aGF0IHNvbWV0aGluZyBlbHNlXG4iCiAiYWxyZWFkeSBpbnRyb2R1Y2VkIHRoZSBzYW1lIGNoYW5nZXM7IHlvdSBtaWdodCB3YW50IHRvIHNraXAgdGhpcyBwYXRjaC4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9hbS5jOjE4MjgKKyM6IGJ1aWx0aW4vYW0uYzoxODE3CiBtc2dpZCAiIgogIllvdSBzdGlsbCBoYXZlIHVubWVyZ2VkIHBhdGhzIGluIHlvdXIgaW5kZXguXG4iCiAiWW91IHNob3VsZCAnZ2l0IGFkZCcgZWFjaCBmaWxlIHdpdGggcmVzb2x2ZWQgY29uZmxpY3RzIHRvIG1hcmsgdGhlbSBhcyAiCkBAIC04MTk3LDE4NSArODIzOSwxODUgQEAKICJZb3UgbWlnaHQgcnVuIGBnaXQgcm1gIG9uIGEgZmlsZSB0byBhY2NlcHQgXCJkZWxldGVkIGJ5IHRoZW1cIiBmb3IgaXQuIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vYW0uYzoxOTM1IGJ1aWx0aW4vYW0uYzoxOTM5IGJ1aWx0aW4vYW0uYzoxOTUxIGJ1aWx0aW4vcmVzZXQuYzozMjkKKyM6IGJ1aWx0aW4vYW0uYzoxOTI0IGJ1aWx0aW4vYW0uYzoxOTI4IGJ1aWx0aW4vYW0uYzoxOTQwIGJ1aWx0aW4vcmVzZXQuYzozMjkKICM6IGJ1aWx0aW4vcmVzZXQuYzozMzcKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ291bGQgbm90IHBhcnNlIG9iamVjdCAnJXMnLiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2FtLmM6MTk4NworIzogYnVpbHRpbi9hbS5jOjE5NzYKIG1zZ2lkICJmYWlsZWQgdG8gY2xlYW4gaW5kZXgiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9hbS5jOjIwMzEKKyM6IGJ1aWx0aW4vYW0uYzoyMDIwCiBtc2dpZCAiIgogIllvdSBzZWVtIHRvIGhhdmUgbW92ZWQgSEVBRCBzaW5jZSB0aGUgbGFzdCAnYW0nIGZhaWx1cmUuXG4iCiAiTm90IHJld2luZGluZyB0byBPUklHX0hFQUQiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9hbS5jOjIxMjgKKyM6IGJ1aWx0aW4vYW0uYzoyMTE3CiAjLCBjLWZvcm1hdAogbXNnaWQgIkludmFsaWQgdmFsdWUgZm9yIC0tcGF0Y2gtZm9ybWF0OiAlcyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2FtLmM6MjE2NAorIzogYnVpbHRpbi9hbS5jOjIxNTMKIG1zZ2lkICJnaXQgYW0gWzxvcHRpb25zPl0gWyg8bWJveD4gfCA8TWFpbGRpcj4pLi4uXSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2FtLmM6MjE2NQorIzogYnVpbHRpbi9hbS5jOjIxNTQKIG1zZ2lkICJnaXQgYW0gWzxvcHRpb25zPl0gKC0tY29udGludWUgfCAtLXNraXAgfCAtLWFib3J0KSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2FtLmM6MjE3MQorIzogYnVpbHRpbi9hbS5jOjIxNjAKIG1zZ2lkICJydW4gaW50ZXJhY3RpdmVseSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2FtLmM6MjE3MworIzogYnVpbHRpbi9hbS5jOjIxNjIKIG1zZ2lkICJoaXN0b3JpY2FsIG9wdGlvbiAtLSBuby1vcCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2FtLmM6MjE3NQorIzogYnVpbHRpbi9hbS5jOjIxNjQKIG1zZ2lkICJhbGxvdyBmYWxsIGJhY2sgb24gM3dheSBtZXJnaW5nIGlmIG5lZWRlZCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2FtLmM6MjE3NiBidWlsdGluL2luaXQtZGIuYzo0OTQgYnVpbHRpbi9wcnVuZS1wYWNrZWQuYzo1OAotIzogYnVpbHRpbi9yZXBhY2suYzoyOTYgYnVpbHRpbi9zdGFzaC5jOjgwNgorIzogYnVpbHRpbi9hbS5jOjIxNjUgYnVpbHRpbi9pbml0LWRiLmM6NDk0IGJ1aWx0aW4vcHJ1bmUtcGFja2VkLmM6NTgKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6Mjk3IGJ1aWx0aW4vc3Rhc2guYzo4MTIKIG1zZ2lkICJiZSBxdWlldCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2FtLmM6MjE3OAorIzogYnVpbHRpbi9hbS5jOjIxNjcKIG1zZ2lkICJhZGQgYSBTaWduZWQtb2ZmLWJ5IGxpbmUgdG8gdGhlIGNvbW1pdCBtZXNzYWdlIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMTgxCisjOiBidWlsdGluL2FtLmM6MjE3MAogbXNnaWQgInJlY29kZSBpbnRvIHV0ZjggKGRlZmF1bHQpIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMTgzCisjOiBidWlsdGluL2FtLmM6MjE3MgogbXNnaWQgInBhc3MgLWsgZmxhZyB0byBnaXQtbWFpbGluZm8iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9hbS5jOjIxODUKKyM6IGJ1aWx0aW4vYW0uYzoyMTc0CiBtc2dpZCAicGFzcyAtYiBmbGFnIHRvIGdpdC1tYWlsaW5mbyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2FtLmM6MjE4NworIzogYnVpbHRpbi9hbS5jOjIxNzYKIG1zZ2lkICJwYXNzIC1tIGZsYWcgdG8gZ2l0LW1haWxpbmZvIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMTg5CisjOiBidWlsdGluL2FtLmM6MjE3OAogbXNnaWQgInBhc3MgLS1rZWVwLWNyIGZsYWcgdG8gZ2l0LW1haWxzcGxpdCBmb3IgbWJveCBmb3JtYXQiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9hbS5jOjIxOTIKKyM6IGJ1aWx0aW4vYW0uYzoyMTgxCiBtc2dpZCAiZG8gbm90IHBhc3MgLS1rZWVwLWNyIGZsYWcgdG8gZ2l0LW1haWxzcGxpdCBpbmRlcGVuZGVudCBvZiBhbS5rZWVwY3IiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9hbS5jOjIxOTUKKyM6IGJ1aWx0aW4vYW0uYzoyMTg0CiBtc2dpZCAic3RyaXAgZXZlcnl0aGluZyBiZWZvcmUgYSBzY2lzc29ycyBsaW5lIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMTk3IGJ1aWx0aW4vYW0uYzoyMjAwIGJ1aWx0aW4vYW0uYzoyMjAzIGJ1aWx0aW4vYW0uYzoyMjA2Ci0jOiBidWlsdGluL2FtLmM6MjIwOSBidWlsdGluL2FtLmM6MjIxMiBidWlsdGluL2FtLmM6MjIxNSBidWlsdGluL2FtLmM6MjIxOAotIzogYnVpbHRpbi9hbS5jOjIyMjQKKyM6IGJ1aWx0aW4vYW0uYzoyMTg2IGJ1aWx0aW4vYW0uYzoyMTg5IGJ1aWx0aW4vYW0uYzoyMTkyIGJ1aWx0aW4vYW0uYzoyMTk1CisjOiBidWlsdGluL2FtLmM6MjE5OCBidWlsdGluL2FtLmM6MjIwMSBidWlsdGluL2FtLmM6MjIwNCBidWlsdGluL2FtLmM6MjIwNworIzogYnVpbHRpbi9hbS5jOjIyMTMKIG1zZ2lkICJwYXNzIGl0IHRocm91Z2ggZ2l0LWFwcGx5IgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMjE0IGJ1aWx0aW4vY29tbWl0LmM6MTM2OCBidWlsdGluL2ZtdC1tZXJnZS1tc2cuYzo2NzEKLSM6IGJ1aWx0aW4vZm10LW1lcmdlLW1zZy5jOjY3NCBidWlsdGluL2dyZXAuYzo4ODEgYnVpbHRpbi9tZXJnZS5jOjI0OQotIzogYnVpbHRpbi9wdWxsLmM6MTU5IGJ1aWx0aW4vcHVsbC5jOjIxOCBidWlsdGluL3JlYmFzZS5jOjE0MTgKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MzA3IGJ1aWx0aW4vcmVwYWNrLmM6MzExIGJ1aWx0aW4vcmVwYWNrLmM6MzEzCisjOiBidWlsdGluL2FtLmM6MjIwMyBidWlsdGluL2NvbW1pdC5jOjEzNjggYnVpbHRpbi9mbXQtbWVyZ2UtbXNnLmM6NjcxCisjOiBidWlsdGluL2ZtdC1tZXJnZS1tc2cuYzo2NzQgYnVpbHRpbi9ncmVwLmM6ODgzIGJ1aWx0aW4vbWVyZ2UuYzoyNDkKKyM6IGJ1aWx0aW4vcHVsbC5jOjE2MCBidWlsdGluL3B1bGwuYzoyMTkgYnVpbHRpbi9yZWJhc2UuYzoxNDQyCisjOiBidWlsdGluL3JlcGFjay5jOjMwOCBidWlsdGluL3JlcGFjay5jOjMxMiBidWlsdGluL3JlcGFjay5jOjMxNAogIzogYnVpbHRpbi9zaG93LWJyYW5jaC5jOjY1MCBidWlsdGluL3Nob3ctcmVmLmM6MTcyIGJ1aWx0aW4vdGFnLmM6NDAzCi0jOiBwYXJzZS1vcHRpb25zLmg6MTQxIHBhcnNlLW9wdGlvbnMuaDoxNjIgcGFyc2Utb3B0aW9ucy5oOjMxMgorIzogcGFyc2Utb3B0aW9ucy5oOjE1MCBwYXJzZS1vcHRpb25zLmg6MTcxIHBhcnNlLW9wdGlvbnMuaDozMTIKIG1zZ2lkICJuIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMjIwIGJ1aWx0aW4vYnJhbmNoLmM6NjYxIGJ1aWx0aW4vZm9yLWVhY2gtcmVmLmM6MzgKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU1NCBidWlsdGluL3RhZy5jOjQzNyBidWlsdGluL3ZlcmlmeS10YWcuYzozOAorIzogYnVpbHRpbi9hbS5jOjIyMDkgYnVpbHRpbi9icmFuY2guYzo2NjEgYnVpbHRpbi9mb3ItZWFjaC1yZWYuYzozOAorIzogYnVpbHRpbi9yZXBsYWNlLmM6NTU1IGJ1aWx0aW4vdGFnLmM6NDM3IGJ1aWx0aW4vdmVyaWZ5LXRhZy5jOjM4CiBtc2dpZCAiZm9ybWF0IgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMjIxCisjOiBidWlsdGluL2FtLmM6MjIxMAogbXNnaWQgImZvcm1hdCB0aGUgcGF0Y2goZXMpIGFyZSBpbiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2FtLmM6MjIyNworIzogYnVpbHRpbi9hbS5jOjIyMTYKIG1zZ2lkICJvdmVycmlkZSBlcnJvciBtZXNzYWdlIHdoZW4gcGF0Y2ggZmFpbHVyZSBvY2N1cnMiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9hbS5jOjIyMjkKKyM6IGJ1aWx0aW4vYW0uYzoyMjE4CiBtc2dpZCAiY29udGludWUgYXBwbHlpbmcgcGF0Y2hlcyBhZnRlciByZXNvbHZpbmcgYSBjb25mbGljdCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2FtLmM6MjIzMgorIzogYnVpbHRpbi9hbS5jOjIyMjEKIG1zZ2lkICJzeW5vbnltcyBmb3IgLS1jb250aW51ZSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2FtLmM6MjIzNQorIzogYnVpbHRpbi9hbS5jOjIyMjQKIG1zZ2lkICJza2lwIHRoZSBjdXJyZW50IHBhdGNoIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMjM4CisjOiBidWlsdGluL2FtLmM6MjIyNwogbXNnaWQgInJlc3RvcmUgdGhlIG9yaWdpbmFsIGJyYW5jaCBhbmQgYWJvcnQgdGhlIHBhdGNoaW5nIG9wZXJhdGlvbi4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9hbS5jOjIyNDEKKyM6IGJ1aWx0aW4vYW0uYzoyMjMwCiBtc2dpZCAiYWJvcnQgdGhlIHBhdGNoaW5nIG9wZXJhdGlvbiBidXQga2VlcCBIRUFEIHdoZXJlIGl0IGlzLiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2FtLmM6MjI0NAorIzogYnVpbHRpbi9hbS5jOjIyMzMKIG1zZ2lkICJzaG93IHRoZSBwYXRjaCBiZWluZyBhcHBsaWVkLiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2FtLmM6MjI0OAorIzogYnVpbHRpbi9hbS5jOjIyMzcKIG1zZ2lkICJsaWUgYWJvdXQgY29tbWl0dGVyIGRhdGUiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9hbS5jOjIyNTAKKyM6IGJ1aWx0aW4vYW0uYzoyMjM5CiBtc2dpZCAidXNlIGN1cnJlbnQgdGltZXN0YW1wIGZvciBhdXRob3IgZGF0ZSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2FtLmM6MjI1MiBidWlsdGluL2NvbW1pdC10cmVlLmM6MTIwIGJ1aWx0aW4vY29tbWl0LmM6MTUxMQotIzogYnVpbHRpbi9tZXJnZS5jOjI4NiBidWlsdGluL3B1bGwuYzoxOTMgYnVpbHRpbi9yZWJhc2UuYzo0ODkKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ1OSBidWlsdGluL3JldmVydC5jOjExNyBidWlsdGluL3RhZy5jOjQxOAorIzogYnVpbHRpbi9hbS5jOjIyNDEgYnVpbHRpbi9jb21taXQtdHJlZS5jOjEyMCBidWlsdGluL2NvbW1pdC5jOjE1MTEKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoyODYgYnVpbHRpbi9wdWxsLmM6MTk0IGJ1aWx0aW4vcmViYXNlLmM6NDkwCisjOiBidWlsdGluL3JlYmFzZS5jOjE0ODMgYnVpbHRpbi9yZXZlcnQuYzoxMTcgYnVpbHRpbi90YWcuYzo0MTgKIG1zZ2lkICJrZXktaWQiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9hbS5jOjIyNTMgYnVpbHRpbi9yZWJhc2UuYzo0OTAgYnVpbHRpbi9yZWJhc2UuYzoxNDYwCisjOiBidWlsdGluL2FtLmM6MjI0MiBidWlsdGluL3JlYmFzZS5jOjQ5MSBidWlsdGluL3JlYmFzZS5jOjE0ODQKIG1zZ2lkICJHUEctc2lnbiBjb21taXRzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMjU2CisjOiBidWlsdGluL2FtLmM6MjI0NQogbXNnaWQgIihpbnRlcm5hbCB1c2UgZm9yIGdpdC1yZWJhc2UpIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMjc0CisjOiBidWlsdGluL2FtLmM6MjI2MwogbXNnaWQgIiIKICJUaGUgLWIvLS1iaW5hcnkgb3B0aW9uIGhhcyBiZWVuIGEgbm8tb3AgZm9yIGxvbmcgdGltZSwgYW5kXG4iCiAiaXQgd2lsbCBiZSByZW1vdmVkLiBQbGVhc2UgZG8gbm90IHVzZSBpdCBhbnltb3JlLiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2FtLmM6MjI4MQorIzogYnVpbHRpbi9hbS5jOjIyNzAKIG1zZ2lkICJmYWlsZWQgdG8gcmVhZCB0aGUgaW5kZXgiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9hbS5jOjIyOTYKKyM6IGJ1aWx0aW4vYW0uYzoyMjg1CiAjLCBjLWZvcm1hdAogbXNnaWQgInByZXZpb3VzIHJlYmFzZSBkaXJlY3RvcnkgJXMgc3RpbGwgZXhpc3RzIGJ1dCBtYm94IGdpdmVuLiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2FtLmM6MjMyMAorIzogYnVpbHRpbi9hbS5jOjIzMDkKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlN0cmF5ICVzIGRpcmVjdG9yeSBmb3VuZC5cbiIKICJVc2UgXCJnaXQgYW0gLS1hYm9ydFwiIHRvIHJlbW92ZSBpdC4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9hbS5jOjIzMjYKKyM6IGJ1aWx0aW4vYW0uYzoyMzE1CiBtc2dpZCAiUmVzb2x2ZSBvcGVyYXRpb24gbm90IGluIHByb2dyZXNzLCB3ZSBhcmUgbm90IHJlc3VtaW5nLiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2FtLmM6MjMzNgorIzogYnVpbHRpbi9hbS5jOjIzMjUKIG1zZ2lkICJpbnRlcmFjdGl2ZSBtb2RlIHJlcXVpcmVzIHBhdGNoZXMgb24gdGhlIGNvbW1hbmQgbGluZSIKIG1zZ3N0ciAiIgogCkBAIC04NjcwLDE1NCArODcxMiwxNTQgQEAKIG1zZ2lkICItLWJpc2VjdC10ZXJtcyByZXF1aXJlcyAwIG9yIDEgYXJndW1lbnQiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjMyCisjOiBidWlsdGluL2JsYW1lLmM6MzEKIG1zZ2lkICJnaXQgYmxhbWUgWzxvcHRpb25zPl0gWzxyZXYtb3B0cz5dIFs8cmV2Pl0gWy0tXSA8ZmlsZT4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjM3CisjOiBidWlsdGluL2JsYW1lLmM6MzYKIG1zZ2lkICI8cmV2LW9wdHM+IGFyZSBkb2N1bWVudGVkIGluIGdpdC1yZXYtbGlzdCgxKSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2JsYW1lLmM6NDEwCisjOiBidWlsdGluL2JsYW1lLmM6NDA5CiAjLCBjLWZvcm1hdAogbXNnaWQgImV4cGVjdGluZyBhIGNvbG9yOiAlcyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2JsYW1lLmM6NDE3CisjOiBidWlsdGluL2JsYW1lLmM6NDE2CiBtc2dpZCAibXVzdCBlbmQgd2l0aCBhIGNvbG9yIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo3MzAKKyM6IGJ1aWx0aW4vYmxhbWUuYzo3MjkKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBjb2xvciAnJXMnIGluIGNvbG9yLmJsYW1lLnJlcGVhdGVkTGluZXMiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjc0OAorIzogYnVpbHRpbi9ibGFtZS5jOjc0NwogbXNnaWQgImludmFsaWQgdmFsdWUgZm9yIGJsYW1lLmNvbG9yaW5nIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4MjMKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4MjIKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IGZpbmQgcmV2aXNpb24gJXMgdG8gaWdub3JlIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NDUKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NDQKIG1zZ2lkICJTaG93IGJsYW1lIGVudHJpZXMgYXMgd2UgZmluZCB0aGVtLCBpbmNyZW1lbnRhbGx5IgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NDYKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NDUKIG1zZ2lkICJTaG93IGJsYW5rIFNIQS0xIGZvciBib3VuZGFyeSBjb21taXRzIChEZWZhdWx0OiBvZmYpIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NDcKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NDYKIG1zZ2lkICJEbyBub3QgdHJlYXQgcm9vdCBjb21taXRzIGFzIGJvdW5kYXJpZXMgKERlZmF1bHQ6IG9mZikiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg0OAorIzogYnVpbHRpbi9ibGFtZS5jOjg0NwogbXNnaWQgIlNob3cgd29yayBjb3N0IHN0YXRpc3RpY3MiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg0OQorIzogYnVpbHRpbi9ibGFtZS5jOjg0OAogbXNnaWQgIkZvcmNlIHByb2dyZXNzIHJlcG9ydGluZyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODUwCisjOiBidWlsdGluL2JsYW1lLmM6ODQ5CiBtc2dpZCAiU2hvdyBvdXRwdXQgc2NvcmUgZm9yIGJsYW1lIGVudHJpZXMiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg1MQorIzogYnVpbHRpbi9ibGFtZS5jOjg1MAogbXNnaWQgIlNob3cgb3JpZ2luYWwgZmlsZW5hbWUgKERlZmF1bHQ6IGF1dG8pIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NTIKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NTEKIG1zZ2lkICJTaG93IG9yaWdpbmFsIGxpbmVudW1iZXIgKERlZmF1bHQ6IG9mZikiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg1MworIzogYnVpbHRpbi9ibGFtZS5jOjg1MgogbXNnaWQgIlNob3cgaW4gYSBmb3JtYXQgZGVzaWduZWQgZm9yIG1hY2hpbmUgY29uc3VtcHRpb24iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg1NAorIzogYnVpbHRpbi9ibGFtZS5jOjg1MwogbXNnaWQgIlNob3cgcG9yY2VsYWluIGZvcm1hdCB3aXRoIHBlci1saW5lIGNvbW1pdCBpbmZvcm1hdGlvbiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODU1CisjOiBidWlsdGluL2JsYW1lLmM6ODU0CiBtc2dpZCAiVXNlIHRoZSBzYW1lIG91dHB1dCBtb2RlIGFzIGdpdC1hbm5vdGF0ZSAoRGVmYXVsdDogb2ZmKSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODU2CisjOiBidWlsdGluL2JsYW1lLmM6ODU1CiBtc2dpZCAiU2hvdyByYXcgdGltZXN0YW1wIChEZWZhdWx0OiBvZmYpIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NTcKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NTYKIG1zZ2lkICJTaG93IGxvbmcgY29tbWl0IFNIQTEgKERlZmF1bHQ6IG9mZikiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg1OAorIzogYnVpbHRpbi9ibGFtZS5jOjg1NwogbXNnaWQgIlN1cHByZXNzIGF1dGhvciBuYW1lIGFuZCB0aW1lc3RhbXAgKERlZmF1bHQ6IG9mZikiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg1OQorIzogYnVpbHRpbi9ibGFtZS5jOjg1OAogbXNnaWQgIlNob3cgYXV0aG9yIGVtYWlsIGluc3RlYWQgb2YgbmFtZSAoRGVmYXVsdDogb2ZmKSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODYwCisjOiBidWlsdGluL2JsYW1lLmM6ODU5CiBtc2dpZCAiSWdub3JlIHdoaXRlc3BhY2UgZGlmZmVyZW5jZXMiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg2MSBidWlsdGluL2xvZy5jOjE2MjkKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NjAgYnVpbHRpbi9sb2cuYzoxNjMwCiBtc2dpZCAicmV2IgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NjEKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NjAKIG1zZ2lkICJJZ25vcmUgPHJldj4gd2hlbiBibGFtaW5nIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NjIKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NjEKIG1zZ2lkICJJZ25vcmUgcmV2aXNpb25zIGZyb20gPGZpbGU+IgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NjMKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NjIKIG1zZ2lkICJjb2xvciByZWR1bmRhbnQgbWV0YWRhdGEgZnJvbSBwcmV2aW91cyBsaW5lIGRpZmZlcmVudGx5IgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NjQKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NjMKIG1zZ2lkICJjb2xvciBsaW5lcyBieSBhZ2UiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg3MQorIzogYnVpbHRpbi9ibGFtZS5jOjg3MAogbXNnaWQgIlVzZSBhbiBleHBlcmltZW50YWwgaGV1cmlzdGljIHRvIGltcHJvdmUgZGlmZnMiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg3MworIzogYnVpbHRpbi9ibGFtZS5jOjg3MgogbXNnaWQgIlNwZW5kIGV4dHJhIGN5Y2xlcyB0byBmaW5kIGJldHRlciBtYXRjaCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODc0CisjOiBidWlsdGluL2JsYW1lLmM6ODczCiBtc2dpZCAiVXNlIHJldmlzaW9ucyBmcm9tIDxmaWxlPiBpbnN0ZWFkIG9mIGNhbGxpbmcgZ2l0LXJldi1saXN0IgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NzUKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NzQKIG1zZ2lkICJVc2UgPGZpbGU+J3MgY29udGVudHMgYXMgdGhlIGZpbmFsIGltYWdlIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NzYgYnVpbHRpbi9ibGFtZS5jOjg3NworIzogYnVpbHRpbi9ibGFtZS5jOjg3NSBidWlsdGluL2JsYW1lLmM6ODc2CiBtc2dpZCAic2NvcmUiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg3NgorIzogYnVpbHRpbi9ibGFtZS5jOjg3NQogbXNnaWQgIkZpbmQgbGluZSBjb3BpZXMgd2l0aGluIGFuZCBhY3Jvc3MgZmlsZXMiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg3NworIzogYnVpbHRpbi9ibGFtZS5jOjg3NgogbXNnaWQgIkZpbmQgbGluZSBtb3ZlbWVudHMgd2l0aGluIGFuZCBhY3Jvc3MgZmlsZXMiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg3OAorIzogYnVpbHRpbi9ibGFtZS5jOjg3NwogbXNnaWQgIm4sbSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODc4CisjOiBidWlsdGluL2JsYW1lLmM6ODc3CiBtc2dpZCAiUHJvY2VzcyBvbmx5IGxpbmUgcmFuZ2UgbixtLCBjb3VudGluZyBmcm9tIDEiCiBtc2dzdHIgIiIKIApAQCAtOTA0NCw3ICs5MDg2LDcgQEAKIG1zZ2lkICJkbyBub3QgdXNlIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vYnJhbmNoLmM6NjI2IGJ1aWx0aW4vcmViYXNlLmM6NDg1CisjOiBidWlsdGluL2JyYW5jaC5jOjYyNiBidWlsdGluL3JlYmFzZS5jOjQ4NgogbXNnaWQgInVwc3RyZWFtIgogbXNnc3RyICIiCiAKQEAgLTkxNTUsNyArOTE5Nyw3IEBACiBtc2dpZCAiZm9ybWF0IHRvIHVzZSBmb3IgdGhlIG91dHB1dCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2JyYW5jaC5jOjY4NCBidWlsdGluL2Nsb25lLmM6NzYxCisjOiBidWlsdGluL2JyYW5jaC5jOjY4NCBidWlsdGluL2Nsb25lLmM6NzYwCiBtc2dpZCAiSEVBRCBub3QgZm91bmQgYmVsb3cgcmVmcy9oZWFkcyEiCiBtc2dzdHIgIiIKIApAQCAtOTI1MSw4MyArOTI5Myw4MyBAQAogbXNnaWQgIk5lZWQgYSByZXBvc2l0b3J5IHRvIHVuYnVuZGxlLiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2NhdC1maWxlLmM6NTk0CisjOiBidWlsdGluL2NhdC1maWxlLmM6NTk1CiBtc2dpZCAiIgogImdpdCBjYXQtZmlsZSAoLXQgWy0tYWxsb3ctdW5rbm93bi10eXBlXSB8IC1zIFstLWFsbG93LXVua25vd24tdHlwZV0gfCAtZSB8IC0iCiAicCB8IDx0eXBlPiB8IC0tdGV4dGNvbnYgfCAtLWZpbHRlcnMpIFstLXBhdGg9PHBhdGg+XSA8b2JqZWN0PiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2NhdC1maWxlLmM6NTk1CisjOiBidWlsdGluL2NhdC1maWxlLmM6NTk2CiBtc2dpZCAiIgogImdpdCBjYXQtZmlsZSAoLS1iYXRjaCB8IC0tYmF0Y2gtY2hlY2spIFstLWZvbGxvdy1zeW1saW5rc10gWy0tdGV4dGNvbnYgfCAtLSIKICJmaWx0ZXJzXSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2NhdC1maWxlLmM6NjE2CisjOiBidWlsdGluL2NhdC1maWxlLmM6NjE3CiBtc2dpZCAib25seSBvbmUgYmF0Y2ggb3B0aW9uIG1heSBiZSBzcGVjaWZpZWQiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9jYXQtZmlsZS5jOjYzNAorIzogYnVpbHRpbi9jYXQtZmlsZS5jOjYzNQogbXNnaWQgIjx0eXBlPiBjYW4gYmUgb25lIG9mOiBibG9iLCB0cmVlLCBjb21taXQsIHRhZyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2NhdC1maWxlLmM6NjM1CisjOiBidWlsdGluL2NhdC1maWxlLmM6NjM2CiBtc2dpZCAic2hvdyBvYmplY3QgdHlwZSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2NhdC1maWxlLmM6NjM2CisjOiBidWlsdGluL2NhdC1maWxlLmM6NjM3CiBtc2dpZCAic2hvdyBvYmplY3Qgc2l6ZSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2NhdC1maWxlLmM6NjM4CisjOiBidWlsdGluL2NhdC1maWxlLmM6NjM5CiBtc2dpZCAiZXhpdCB3aXRoIHplcm8gd2hlbiB0aGVyZSdzIG5vIGVycm9yIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2MzkKKyM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NDAKIG1zZ2lkICJwcmV0dHktcHJpbnQgb2JqZWN0J3MgY29udGVudCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2NhdC1maWxlLmM6NjQxCisjOiBidWlsdGluL2NhdC1maWxlLmM6NjQyCiBtc2dpZCAiZm9yIGJsb2Igb2JqZWN0cywgcnVuIHRleHRjb252IG9uIG9iamVjdCdzIGNvbnRlbnQiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY0MworIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY0NAogbXNnaWQgImZvciBibG9iIG9iamVjdHMsIHJ1biBmaWx0ZXJzIG9uIG9iamVjdCdzIGNvbnRlbnQiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY0NCBnaXQtc3VibW9kdWxlLnNoOjkzNgorIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY0NSBnaXQtc3VibW9kdWxlLnNoOjkzNgogbXNnaWQgImJsb2IiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY0NQorIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY0NgogbXNnaWQgInVzZSBhIHNwZWNpZmljIHBhdGggZm9yIC0tdGV4dGNvbnYvLS1maWx0ZXJzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NDcKKyM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NDgKIG1zZ2lkICJhbGxvdyAtcyBhbmQgLXQgdG8gd29yayB3aXRoIGJyb2tlbi9jb3JydXB0IG9iamVjdHMiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY0OAorIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY0OQogbXNnaWQgImJ1ZmZlciAtLWJhdGNoIG91dHB1dCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2NhdC1maWxlLmM6NjUwCisjOiBidWlsdGluL2NhdC1maWxlLmM6NjUxCiBtc2dpZCAic2hvdyBpbmZvIGFuZCBjb250ZW50IG9mIG9iamVjdHMgZmVkIGZyb20gdGhlIHN0YW5kYXJkIGlucHV0IgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NTQKKyM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NTUKIG1zZ2lkICJzaG93IGluZm8gYWJvdXQgb2JqZWN0cyBmZWQgZnJvbSB0aGUgc3RhbmRhcmQgaW5wdXQiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY1OAorIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY1OQogbXNnaWQgImZvbGxvdyBpbi10cmVlIHN5bWxpbmtzICh1c2VkIHdpdGggLS1iYXRjaCBvciAtLWJhdGNoLWNoZWNrKSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2NhdC1maWxlLmM6NjYwCisjOiBidWlsdGluL2NhdC1maWxlLmM6NjYxCiBtc2dpZCAic2hvdyBhbGwgb2JqZWN0cyB3aXRoIC0tYmF0Y2ggb3IgLS1iYXRjaC1jaGVjayIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2NhdC1maWxlLmM6NjYyCisjOiBidWlsdGluL2NhdC1maWxlLmM6NjYzCiBtc2dpZCAiZG8gbm90IG9yZGVyIC0tYmF0Y2gtYWxsLW9iamVjdHMgb3V0cHV0IgogbXNnc3RyICIiCiAKQEAgLTkzNTUsOCArOTM5Nyw4IEBACiBtc2dpZCAidGVybWluYXRlIGlucHV0IGFuZCBvdXRwdXQgcmVjb3JkcyBieSBhIE5VTCBjaGFyYWN0ZXIiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9jaGVjay1pZ25vcmUuYzoyMSBidWlsdGluL2NoZWNrb3V0LmM6MTQzMyBidWlsdGluL2djLmM6NTM4Ci0jOiBidWlsdGluL3dvcmt0cmVlLmM6NTA3CisjOiBidWlsdGluL2NoZWNrLWlnbm9yZS5jOjIxIGJ1aWx0aW4vY2hlY2tvdXQuYzoxNDMzIGJ1aWx0aW4vZ2MuYzo1MzcKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo1MDYKIG1zZ2lkICJzdXBwcmVzcyBwcm9ncmVzcyByZXBvcnRpbmciCiBtc2dzdHIgIiIKIApAQCAtOTQ0OCw3ICs5NDkwLDcgQEAKICM6IGJ1aWx0aW4vY2hlY2tvdXQtaW5kZXguYzoxNzggYnVpbHRpbi9jb2x1bW4uYzozMQogIzogYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjEzNzMgYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjEzNzYKICM6IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxMzg0IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxODU3Ci0jOiBidWlsdGluL3dvcmt0cmVlLmM6NjgwCisjOiBidWlsdGluL3dvcmt0cmVlLmM6Njc5CiBtc2dpZCAic3RyaW5nIgogbXNnc3RyICIiCiAKQEAgLTk0NzYsMTA5ICs5NTE4LDEwNCBAQAogbXNnaWQgImdpdCByZXN0b3JlIFs8b3B0aW9ucz5dIFstLXNvdXJjZT08YnJhbmNoPl0gPGZpbGU+Li4uIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzIgYnVpbHRpbi9jaGVja291dC5jOjIxMQorIzogYnVpbHRpbi9jaGVja291dC5jOjE3MyBidWlsdGluL2NoZWNrb3V0LmM6MjEyCiAjLCBjLWZvcm1hdAogbXNnaWQgInBhdGggJyVzJyBkb2VzIG5vdCBoYXZlIG91ciB2ZXJzaW9uIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzQgYnVpbHRpbi9jaGVja291dC5jOjIxMworIzogYnVpbHRpbi9jaGVja291dC5jOjE3NSBidWlsdGluL2NoZWNrb3V0LmM6MjE0CiAjLCBjLWZvcm1hdAogbXNnaWQgInBhdGggJyVzJyBkb2VzIG5vdCBoYXZlIHRoZWlyIHZlcnNpb24iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjE5MAorIzogYnVpbHRpbi9jaGVja291dC5jOjE5MQogIywgYy1mb3JtYXQKIG1zZ2lkICJwYXRoICclcycgZG9lcyBub3QgaGF2ZSBhbGwgbmVjZXNzYXJ5IHZlcnNpb25zIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoyNDAKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoyNDEKICMsIGMtZm9ybWF0CiBtc2dpZCAicGF0aCAnJXMnIGRvZXMgbm90IGhhdmUgbmVjZXNzYXJ5IHZlcnNpb25zIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoyNTgKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoyNTkKICMsIGMtZm9ybWF0CiBtc2dpZCAicGF0aCAnJXMnOiBjYW5ub3QgbWVyZ2UiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjI3NAorIzogYnVpbHRpbi9jaGVja291dC5jOjI3NQogIywgYy1mb3JtYXQKIG1zZ2lkICJVbmFibGUgdG8gYWRkIG1lcmdlIHJlc3VsdCBmb3IgJyVzJyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6Mzc0CisjOiBidWlsdGluL2NoZWNrb3V0LmM6Mzc1CiAjLCBjLWZvcm1hdAogbXNnaWQgIlJlY3JlYXRlZCAlZCBtZXJnZSBjb25mbGljdCIKIG1zZ2lkX3BsdXJhbCAiUmVjcmVhdGVkICVkIG1lcmdlIGNvbmZsaWN0cyIKIG1zZ3N0clswXSAiIgogbXNnc3RyWzFdICIiCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzozNzkKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzozODAKICMsIGMtZm9ybWF0CiBtc2dpZCAiVXBkYXRlZCAlZCBwYXRoIGZyb20gJXMiCiBtc2dpZF9wbHVyYWwgIlVwZGF0ZWQgJWQgcGF0aHMgZnJvbSAlcyIKIG1zZ3N0clswXSAiIgogbXNnc3RyWzFdICIiCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzozODYKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzozODcKICMsIGMtZm9ybWF0CiBtc2dpZCAiVXBkYXRlZCAlZCBwYXRoIGZyb20gdGhlIGluZGV4IgogbXNnaWRfcGx1cmFsICJVcGRhdGVkICVkIHBhdGhzIGZyb20gdGhlIGluZGV4IgogbXNnc3RyWzBdICIiCiBtc2dzdHJbMV0gIiIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjQwOSBidWlsdGluL2NoZWNrb3V0LmM6NDEyIGJ1aWx0aW4vY2hlY2tvdXQuYzo0MTUKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo0MTkKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo0MTAgYnVpbHRpbi9jaGVja291dC5jOjQxMyBidWlsdGluL2NoZWNrb3V0LmM6NDE2CisjOiBidWlsdGluL2NoZWNrb3V0LmM6NDIwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiclcycgY2Fubm90IGJlIHVzZWQgd2l0aCB1cGRhdGluZyBwYXRocyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6NDIyIGJ1aWx0aW4vY2hlY2tvdXQuYzo0MjUKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo0MjMgYnVpbHRpbi9jaGVja291dC5jOjQyNgogIywgYy1mb3JtYXQKIG1zZ2lkICInJXMnIGNhbm5vdCBiZSB1c2VkIHdpdGggJXMiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjQyOQorIzogYnVpbHRpbi9jaGVja291dC5jOjQzMAogIywgYy1mb3JtYXQKIG1zZ2lkICJDYW5ub3QgdXBkYXRlIHBhdGhzIGFuZCBzd2l0Y2ggdG8gYnJhbmNoICclcycgYXQgdGhlIHNhbWUgdGltZS4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjQzMworIzogYnVpbHRpbi9jaGVja291dC5jOjQzNAogIywgYy1mb3JtYXQKIG1zZ2lkICJuZWl0aGVyICclcycgb3IgJyVzJyBpcyBzcGVjaWZpZWQiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjQzNworIzogYnVpbHRpbi9jaGVja291dC5jOjQzOAogIywgYy1mb3JtYXQKIG1zZ2lkICInJXMnIG11c3QgYmUgdXNlZCB3aGVuICclcycgaXMgbm90IHNwZWNpZmllZCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6NDQyIGJ1aWx0aW4vY2hlY2tvdXQuYzo0NDcKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo0NDMgYnVpbHRpbi9jaGVja291dC5jOjQ0OAogIywgYy1mb3JtYXQKIG1zZ2lkICInJXMnIG9yICclcycgY2Fubm90IGJlIHVzZWQgd2l0aCAlcyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6NTA2IGJ1aWx0aW4vY2hlY2tvdXQuYzo1MTMKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo1MDcgYnVpbHRpbi9jaGVja291dC5jOjUxNAogIywgYy1mb3JtYXQKIG1zZ2lkICJwYXRoICclcycgaXMgdW5tZXJnZWQiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjY3OQorIzogYnVpbHRpbi9jaGVja291dC5jOjY4MAogbXNnaWQgInlvdSBuZWVkIHRvIHJlc29sdmUgeW91ciBjdXJyZW50IGluZGV4IGZpcnN0IgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo3MjkKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo3MzAKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogImNhbm5vdCBjb250aW51ZSB3aXRoIHN0YWdlZCBjaGFuZ2VzIGluIHRoZSBmb2xsb3dpbmcgZmlsZXM6XG4iCiAiJXMiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjczNgotIywgYy1mb3JtYXQKLW1zZ2lkICJzdGFnZWQgY2hhbmdlcyBpbiB0aGUgZm9sbG93aW5nIGZpbGVzIG1heSBiZSBsb3N0OiAlcyIKLW1zZ3N0ciAiIgotCiAjOiBidWlsdGluL2NoZWNrb3V0LmM6ODMzCiAjLCBjLWZvcm1hdAogbXNnaWQgIkNhbiBub3QgZG8gcmVmbG9nIGZvciAnJXMnOiAlc1xuIgpAQCAtOTU4OCw3ICs5NjI1LDcgQEAKIG1zZ2lkICJIRUFEIGlzIG5vdyBhdCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6ODc5IGJ1aWx0aW4vY2xvbmUuYzo3MTQKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo4NzkgYnVpbHRpbi9jbG9uZS5jOjcxMwogbXNnaWQgInVuYWJsZSB0byB1cGRhdGUgSEVBRCIKIG1zZ3N0ciAiIgogCkBAIC05NjgyLDcgKzk3MTksNyBAQAogIlBsZWFzZSB1c2UgLS0gKGFuZCBvcHRpb25hbGx5IC0tbm8tZ3Vlc3MpIHRvIGRpc2FtYmlndWF0ZSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6MTI0MyBidWlsdGluL3dvcmt0cmVlLmM6MjkxIGJ1aWx0aW4vd29ya3RyZWUuYzo0NTYKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxMjQzIGJ1aWx0aW4vd29ya3RyZWUuYzoyOTAgYnVpbHRpbi93b3JrdHJlZS5jOjQ1NQogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIHJlZmVyZW5jZTogJXMiCiBtc2dzdHIgIiIKQEAgLTk3NzUsOSArOTgxMiw5IEBACiBtc2dpZCAibWlzc2luZyBicmFuY2ggb3IgY29tbWl0IGFyZ3VtZW50IgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNDM3IGJ1aWx0aW4vY2xvbmUuYzo5MSBidWlsdGluL2ZldGNoLmM6MTUxCi0jOiBidWlsdGluL21lcmdlLmM6Mjg1IGJ1aWx0aW4vcHVsbC5jOjEzNyBidWlsdGluL3B1c2guYzo1NzUKLSM6IGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTc0CisjOiBidWlsdGluL2NoZWNrb3V0LmM6MTQzNyBidWlsdGluL2Nsb25lLmM6OTAgYnVpbHRpbi9jb21taXQtZ3JhcGguYzo1OQorIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxODAgYnVpbHRpbi9mZXRjaC5jOjE2NiBidWlsdGluL21lcmdlLmM6Mjg1CisjOiBidWlsdGluL3B1bGwuYzoxMzggYnVpbHRpbi9wdXNoLmM6NTYyIGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTc0CiBtc2dpZCAiZm9yY2UgcHJvZ3Jlc3MgcmVwb3J0aW5nIgogbXNnc3RyICIiCiAKQEAgLTk3ODUsNyArOTgyMiw3IEBACiBtc2dpZCAicGVyZm9ybSBhIDMtd2F5IG1lcmdlIHdpdGggdGhlIG5ldyBicmFuY2giCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjE0MzkgYnVpbHRpbi9sb2cuYzoxNjE3IHBhcnNlLW9wdGlvbnMuaDozMTgKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNDM5IGJ1aWx0aW4vbG9nLmM6MTYxOCBwYXJzZS1vcHRpb25zLmg6MzE4CiBtc2dpZCAic3R5bGUiCiBtc2dzdHIgIiIKIApAQCAtOTc5Myw3ICs5ODMwLDcgQEAKIG1zZ2lkICJjb25mbGljdCBzdHlsZSAobWVyZ2Ugb3IgZGlmZjMpIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNDUyIGJ1aWx0aW4vd29ya3RyZWUuYzo1MDQKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNDUyIGJ1aWx0aW4vd29ya3RyZWUuYzo1MDMKIG1zZ2lkICJkZXRhY2ggSEVBRCBhdCBuYW1lZCBjb21taXQiCiBtc2dzdHIgIiIKIApAQCAtOTg5NSw5ICs5OTMyLDkgQEAKICJjaGVja291dC5kZWZhdWx0UmVtb3RlPW9yaWdpbiBpbiB5b3VyIGNvbmZpZy4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjE2OTEgYnVpbHRpbi9jaGVja291dC5jOjE2OTMgYnVpbHRpbi9jaGVja291dC5jOjE3MzMKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzM1IGJ1aWx0aW4vY2xvbmUuYzoxMjEgYnVpbHRpbi9yZW1vdGUuYzoxNjkKLSM6IGJ1aWx0aW4vcmVtb3RlLmM6MTcxIGJ1aWx0aW4vd29ya3RyZWUuYzo1MDAgYnVpbHRpbi93b3JrdHJlZS5jOjUwMgorIzogYnVpbHRpbi9jaGVja291dC5jOjE2OTEgYnVpbHRpbi9jaGVja291dC5jOjE2OTMgYnVpbHRpbi9jaGVja291dC5jOjE3NDIKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzQ0IGJ1aWx0aW4vY2xvbmUuYzoxMjAgYnVpbHRpbi9yZW1vdGUuYzoxNjkKKyM6IGJ1aWx0aW4vcmVtb3RlLmM6MTcxIGJ1aWx0aW4vd29ya3RyZWUuYzo0OTkgYnVpbHRpbi93b3JrdHJlZS5jOjUwMQogbXNnaWQgImJyYW5jaCIKIG1zZ3N0ciAiIgogCkBAIC05OTIxLDM5ICs5OTU4LDM5IEBACiBtc2dpZCAidXNlIG92ZXJsYXkgbW9kZSAoZGVmYXVsdCkiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjE3MzQKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzQzCiBtc2dpZCAiY3JlYXRlIGFuZCBzd2l0Y2ggdG8gYSBuZXcgYnJhbmNoIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzM2CisjOiBidWlsdGluL2NoZWNrb3V0LmM6MTc0NQogbXNnaWQgImNyZWF0ZS9yZXNldCBhbmQgc3dpdGNoIHRvIGEgYnJhbmNoIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzM4CisjOiBidWlsdGluL2NoZWNrb3V0LmM6MTc0NwogbXNnaWQgInNlY29uZCBndWVzcyAnZ2l0IHN3aXRjaCA8bm8tc3VjaC1icmFuY2g+JyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6MTc0MAorIzogYnVpbHRpbi9jaGVja291dC5jOjE3NDkKIG1zZ2lkICJ0aHJvdyBhd2F5IGxvY2FsIG1vZGlmaWNhdGlvbnMiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjE3NzIKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzgxCiBtc2dpZCAid2hpY2ggdHJlZS1pc2ggdG8gY2hlY2tvdXQgZnJvbSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6MTc3NAorIzogYnVpbHRpbi9jaGVja291dC5jOjE3ODMKIG1zZ2lkICJyZXN0b3JlIHRoZSBpbmRleCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6MTc3NgorIzogYnVpbHRpbi9jaGVja291dC5jOjE3ODUKIG1zZ2lkICJyZXN0b3JlIHRoZSB3b3JraW5nIHRyZWUgKGRlZmF1bHQpIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzc4CisjOiBidWlsdGluL2NoZWNrb3V0LmM6MTc4NwogbXNnaWQgImlnbm9yZSB1bm1lcmdlZCBlbnRyaWVzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzc5CisjOiBidWlsdGluL2NoZWNrb3V0LmM6MTc4OAogbXNnaWQgInVzZSBvdmVybGF5IG1vZGUiCiBtc2dzdHIgIiIKIApAQCAtOTk5Miw3ICsxMDAyOSw3IEBACiBtc2dpZCAiY291bGQgbm90IGxzdGF0ICVzXG4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjMwMCBnaXQtYWRkLS1pbnRlcmFjdGl2ZS5wZXJsOjU5MworIzogYnVpbHRpbi9jbGVhbi5jOjMwMSBnaXQtYWRkLS1pbnRlcmFjdGl2ZS5wZXJsOjU5MwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiUHJvbXB0IGhlbHA6XG4iCkBAIC0xMDAwMSw3ICsxMDAzOCw3IEBACiAiICAgICAgICAgICAtIChlbXB0eSkgc2VsZWN0IG5vdGhpbmdcbiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2NsZWFuLmM6MzA0IGdpdC1hZGQtLWludGVyYWN0aXZlLnBlcmw6NjAyCisjOiBidWlsdGluL2NsZWFuLmM6MzA1IGdpdC1hZGQtLWludGVyYWN0aXZlLnBlcmw6NjAyCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJQcm9tcHQgaGVscDpcbiIKQEAgLTEwMDE0LDM4ICsxMDA1MSwzOCBAQAogIiAgICAgICAgICAgLSAoZW1wdHkpIGZpbmlzaCBzZWxlY3RpbmdcbiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2NsZWFuLmM6NTIwIGdpdC1hZGQtLWludGVyYWN0aXZlLnBlcmw6NTY4CisjOiBidWlsdGluL2NsZWFuLmM6NTIxIGdpdC1hZGQtLWludGVyYWN0aXZlLnBlcmw6NTY4CiAjOiBnaXQtYWRkLS1pbnRlcmFjdGl2ZS5wZXJsOjU3MwogIywgYy1mb3JtYXQsIHBlcmwtZm9ybWF0CiBtc2dpZCAiSHVoICglcyk/XG4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjY2MgorIzogYnVpbHRpbi9jbGVhbi5jOjY2MwogIywgYy1mb3JtYXQKIG1zZ2lkICJJbnB1dCBpZ25vcmUgcGF0dGVybnM+PiAiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjY5OQorIzogYnVpbHRpbi9jbGVhbi5jOjcwMAogIywgYy1mb3JtYXQKIG1zZ2lkICJXQVJOSU5HOiBDYW5ub3QgZmluZCBpdGVtcyBtYXRjaGVkIGJ5OiAlcyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2NsZWFuLmM6NzIwCisjOiBidWlsdGluL2NsZWFuLmM6NzIxCiBtc2dpZCAiU2VsZWN0IGl0ZW1zIHRvIGRlbGV0ZSIKIG1zZ3N0ciAiIgogCiAjLiBUUkFOU0xBVE9SUzogTWFrZSBzdXJlIHRvIGtlZXAgW3kvTl0gYXMgaXMKLSM6IGJ1aWx0aW4vY2xlYW4uYzo3NjEKKyM6IGJ1aWx0aW4vY2xlYW4uYzo3NjIKICMsIGMtZm9ybWF0CiBtc2dpZCAiUmVtb3ZlICVzIFt5L05dPyAiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjc4NiBnaXQtYWRkLS1pbnRlcmFjdGl2ZS5wZXJsOjE3NjMKKyM6IGJ1aWx0aW4vY2xlYW4uYzo3ODcgZ2l0LWFkZC0taW50ZXJhY3RpdmUucGVybDoxNzYzCiAjLCBjLWZvcm1hdAogbXNnaWQgIkJ5ZS5cbiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2NsZWFuLmM6Nzk0CisjOiBidWlsdGluL2NsZWFuLmM6Nzk1CiBtc2dpZCAiIgogImNsZWFuICAgICAgICAgICAgICAgLSBzdGFydCBjbGVhbmluZ1xuIgogImZpbHRlciBieSBwYXR0ZXJuICAgLSBleGNsdWRlIGl0ZW1zIGZyb20gZGVsZXRpb25cbiIKQEAgLTEwMDU2LDQwNSArMTAwOTMsNDAwIEBACiAiPyAgICAgICAgICAgICAgICAgICAtIGhlbHAgZm9yIHByb21wdCBzZWxlY3Rpb24iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjgyMSBnaXQtYWRkLS1pbnRlcmFjdGl2ZS5wZXJsOjE4NDkKKyM6IGJ1aWx0aW4vY2xlYW4uYzo4MjIgZ2l0LWFkZC0taW50ZXJhY3RpdmUucGVybDoxODQ5CiBtc2dpZCAiKioqIENvbW1hbmRzICoqKiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2NsZWFuLmM6ODIyIGdpdC1hZGQtLWludGVyYWN0aXZlLnBlcmw6MTg0NgorIzogYnVpbHRpbi9jbGVhbi5jOjgyMyBnaXQtYWRkLS1pbnRlcmFjdGl2ZS5wZXJsOjE4NDYKIG1zZ2lkICJXaGF0IG5vdyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2NsZWFuLmM6ODMwCisjOiBidWlsdGluL2NsZWFuLmM6ODMxCiBtc2dpZCAiV291bGQgcmVtb3ZlIHRoZSBmb2xsb3dpbmcgaXRlbToiCiBtc2dpZF9wbHVyYWwgIldvdWxkIHJlbW92ZSB0aGUgZm9sbG93aW5nIGl0ZW1zOiIKIG1zZ3N0clswXSAiIgogbXNnc3RyWzFdICIiCiAKLSM6IGJ1aWx0aW4vY2xlYW4uYzo4NDYKKyM6IGJ1aWx0aW4vY2xlYW4uYzo4NDcKIG1zZ2lkICJObyBtb3JlIGZpbGVzIHRvIGNsZWFuLCBleGl0aW5nLiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2NsZWFuLmM6OTA4CisjOiBidWlsdGluL2NsZWFuLmM6OTA5CiBtc2dpZCAiZG8gbm90IHByaW50IG5hbWVzIG9mIGZpbGVzIHJlbW92ZWQiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjkxMAorIzogYnVpbHRpbi9jbGVhbi5jOjkxMQogbXNnaWQgImZvcmNlIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vY2xlYW4uYzo5MTEKKyM6IGJ1aWx0aW4vY2xlYW4uYzo5MTIKIG1zZ2lkICJpbnRlcmFjdGl2ZSBjbGVhbmluZyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2NsZWFuLmM6OTEzCisjOiBidWlsdGluL2NsZWFuLmM6OTE0CiBtc2dpZCAicmVtb3ZlIHdob2xlIGRpcmVjdG9yaWVzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vY2xlYW4uYzo5MTQgYnVpbHRpbi9kZXNjcmliZS5jOjU0NiBidWlsdGluL2Rlc2NyaWJlLmM6NTQ4Ci0jOiBidWlsdGluL2dyZXAuYzo4OTkgYnVpbHRpbi9sb2cuYzoxNzYgYnVpbHRpbi9sb2cuYzoxNzgKLSM6IGJ1aWx0aW4vbHMtZmlsZXMuYzo1NTcgYnVpbHRpbi9uYW1lLXJldi5jOjQxMyBidWlsdGluL25hbWUtcmV2LmM6NDE1CisjOiBidWlsdGluL2NsZWFuLmM6OTE1IGJ1aWx0aW4vZGVzY3JpYmUuYzo1NDggYnVpbHRpbi9kZXNjcmliZS5jOjU1MAorIzogYnVpbHRpbi9ncmVwLmM6OTAxIGJ1aWx0aW4vbG9nLmM6MTc2IGJ1aWx0aW4vbG9nLmM6MTc4CisjOiBidWlsdGluL2xzLWZpbGVzLmM6NTU3IGJ1aWx0aW4vbmFtZS1yZXYuYzo0MTcgYnVpbHRpbi9uYW1lLXJldi5jOjQxOQogIzogYnVpbHRpbi9zaG93LXJlZi5jOjE3OQogbXNnaWQgInBhdHRlcm4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjkxNQorIzogYnVpbHRpbi9jbGVhbi5jOjkxNgogbXNnaWQgImFkZCA8cGF0dGVybj4gdG8gaWdub3JlIHJ1bGVzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vY2xlYW4uYzo5MTYKKyM6IGJ1aWx0aW4vY2xlYW4uYzo5MTcKIG1zZ2lkICJyZW1vdmUgaWdub3JlZCBmaWxlcywgdG9vIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vY2xlYW4uYzo5MTgKKyM6IGJ1aWx0aW4vY2xlYW4uYzo5MTkKIG1zZ2lkICJyZW1vdmUgb25seSBpZ25vcmVkIGZpbGVzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vY2xlYW4uYzo5MzYKKyM6IGJ1aWx0aW4vY2xlYW4uYzo5MzcKIG1zZ2lkICIteCBhbmQgLVggY2Fubm90IGJlIHVzZWQgdG9nZXRoZXIiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjk0MAorIzogYnVpbHRpbi9jbGVhbi5jOjk0MQogbXNnaWQgIiIKICJjbGVhbi5yZXF1aXJlRm9yY2Ugc2V0IHRvIHRydWUgYW5kIG5laXRoZXIgLWksIC1uLCBub3IgLWYgZ2l2ZW47IHJlZnVzaW5nIHRvICIKICJjbGVhbiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2NsZWFuLmM6OTQzCisjOiBidWlsdGluL2NsZWFuLmM6OTQ0CiBtc2dpZCAiIgogImNsZWFuLnJlcXVpcmVGb3JjZSBkZWZhdWx0cyB0byB0cnVlIGFuZCBuZWl0aGVyIC1pLCAtbiwgbm9yIC1mIGdpdmVuOyAiCiAicmVmdXNpbmcgdG8gY2xlYW4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjQ2CisjOiBidWlsdGluL2Nsb25lLmM6NDUKIG1zZ2lkICJnaXQgY2xvbmUgWzxvcHRpb25zPl0gWy0tXSA8cmVwbz4gWzxkaXI+XSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2Nsb25lLmM6OTMKKyM6IGJ1aWx0aW4vY2xvbmUuYzo5MgogbXNnaWQgImRvbid0IGNyZWF0ZSBhIGNoZWNrb3V0IgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo5NCBidWlsdGluL2Nsb25lLmM6OTYgYnVpbHRpbi9pbml0LWRiLmM6NDg5CisjOiBidWlsdGluL2Nsb25lLmM6OTMgYnVpbHRpbi9jbG9uZS5jOjk1IGJ1aWx0aW4vaW5pdC1kYi5jOjQ4OQogbXNnaWQgImNyZWF0ZSBhIGJhcmUgcmVwb3NpdG9yeSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2Nsb25lLmM6OTgKKyM6IGJ1aWx0aW4vY2xvbmUuYzo5NwogbXNnaWQgImNyZWF0ZSBhIG1pcnJvciByZXBvc2l0b3J5IChpbXBsaWVzIGJhcmUpIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMDAKKyM6IGJ1aWx0aW4vY2xvbmUuYzo5OQogbXNnaWQgInRvIGNsb25lIGZyb20gYSBsb2NhbCByZXBvc2l0b3J5IgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMDIKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMDEKIG1zZ2lkICJkb24ndCB1c2UgbG9jYWwgaGFyZGxpbmtzLCBhbHdheXMgY29weSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTA0CisjOiBidWlsdGluL2Nsb25lLmM6MTAzCiBtc2dpZCAic2V0dXAgYXMgc2hhcmVkIHJlcG9zaXRvcnkiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEwNworIzogYnVpbHRpbi9jbG9uZS5jOjEwNgogbXNnaWQgInBhdGhzcGVjIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMDcKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMDYKIG1zZ2lkICJpbml0aWFsaXplIHN1Ym1vZHVsZXMgaW4gdGhlIGNsb25lIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMTAKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMDkKIG1zZ2lkICJudW1iZXIgb2Ygc3VibW9kdWxlcyBjbG9uZWQgaW4gcGFyYWxsZWwiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjExMSBidWlsdGluL2luaXQtZGIuYzo0ODYKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMTAgYnVpbHRpbi9pbml0LWRiLmM6NDg2CiBtc2dpZCAidGVtcGxhdGUtZGlyZWN0b3J5IgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMTIgYnVpbHRpbi9pbml0LWRiLmM6NDg3CisjOiBidWlsdGluL2Nsb25lLmM6MTExIGJ1aWx0aW4vaW5pdC1kYi5jOjQ4NwogbXNnaWQgImRpcmVjdG9yeSBmcm9tIHdoaWNoIHRlbXBsYXRlcyB3aWxsIGJlIHVzZWQiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjExNCBidWlsdGluL2Nsb25lLmM6MTE2IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxMzgwCisjOiBidWlsdGluL2Nsb25lLmM6MTEzIGJ1aWx0aW4vY2xvbmUuYzoxMTUgYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjEzODAKICM6IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxODYwCiBtc2dpZCAicmVmZXJlbmNlIHJlcG9zaXRvcnkiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjExOCBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6MTM4MgorIzogYnVpbHRpbi9jbG9uZS5jOjExNyBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6MTM4MgogIzogYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjE4NjIKIG1zZ2lkICJ1c2UgLS1yZWZlcmVuY2Ugb25seSB3aGlsZSBjbG9uaW5nIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMTkgYnVpbHRpbi9jb2x1bW4uYzoyNyBidWlsdGluL21lcmdlLWZpbGUuYzo0NgotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzE0IGJ1aWx0aW4vcmVwYWNrLmM6MzE5CisjOiBidWlsdGluL2Nsb25lLmM6MTE4IGJ1aWx0aW4vY29sdW1uLmM6MjcgYnVpbHRpbi9tZXJnZS1maWxlLmM6NDYKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI5NCBidWlsdGluL3JlcGFjay5jOjMyMAogbXNnaWQgIm5hbWUiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEyMAorIzogYnVpbHRpbi9jbG9uZS5jOjExOQogbXNnaWQgInVzZSA8bmFtZT4gaW5zdGVhZCBvZiAnb3JpZ2luJyB0byB0cmFjayB1cHN0cmVhbSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTIyCisjOiBidWlsdGluL2Nsb25lLmM6MTIxCiBtc2dpZCAiY2hlY2tvdXQgPGJyYW5jaD4gaW5zdGVhZCBvZiB0aGUgcmVtb3RlJ3MgSEVBRCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTI0CisjOiBidWlsdGluL2Nsb25lLmM6MTIzCiBtc2dpZCAicGF0aCB0byBnaXQtdXBsb2FkLXBhY2sgb24gdGhlIHJlbW90ZSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTI1IGJ1aWx0aW4vZmV0Y2guYzoxNTIgYnVpbHRpbi9ncmVwLmM6ODM4Ci0jOiBidWlsdGluL3B1bGwuYzoyMjYKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMjQgYnVpbHRpbi9mZXRjaC5jOjE2NyBidWlsdGluL2dyZXAuYzo4NDAKKyM6IGJ1aWx0aW4vcHVsbC5jOjIyNwogbXNnaWQgImRlcHRoIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMjYKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMjUKIG1zZ2lkICJjcmVhdGUgYSBzaGFsbG93IGNsb25lIG9mIHRoYXQgZGVwdGgiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEyNyBidWlsdGluL2ZldGNoLmM6MTU0IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMwMworIzogYnVpbHRpbi9jbG9uZS5jOjEyNiBidWlsdGluL2ZldGNoLmM6MTY5IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI4MwogbXNnaWQgInRpbWUiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEyOAorIzogYnVpbHRpbi9jbG9uZS5jOjEyNwogbXNnaWQgImNyZWF0ZSBhIHNoYWxsb3cgY2xvbmUgc2luY2UgYSBzcGVjaWZpYyB0aW1lIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMjkgYnVpbHRpbi9mZXRjaC5jOjE1NiBidWlsdGluL2ZldGNoLmM6MTc5Ci0jOiBidWlsdGluL3JlYmFzZS5jOjEzOTUKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMjggYnVpbHRpbi9mZXRjaC5jOjE3MSBidWlsdGluL2ZldGNoLmM6MTk0CisjOiBidWlsdGluL3JlYmFzZS5jOjE0MTcKIG1zZ2lkICJyZXZpc2lvbiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTMwIGJ1aWx0aW4vZmV0Y2guYzoxNTcKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMjkgYnVpbHRpbi9mZXRjaC5jOjE3MgogbXNnaWQgImRlZXBlbiBoaXN0b3J5IG9mIHNoYWxsb3cgY2xvbmUsIGV4Y2x1ZGluZyByZXYiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEzMgorIzogYnVpbHRpbi9jbG9uZS5jOjEzMQogbXNnaWQgImNsb25lIG9ubHkgb25lIGJyYW5jaCwgSEVBRCBvciAtLWJyYW5jaCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTM0CisjOiBidWlsdGluL2Nsb25lLmM6MTMzCiBtc2dpZCAiZG9uJ3QgY2xvbmUgYW55IHRhZ3MsIGFuZCBtYWtlIGxhdGVyIGZldGNoZXMgbm90IHRvIGZvbGxvdyB0aGVtIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMzYKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMzUKIG1zZ2lkICJhbnkgY2xvbmVkIHN1Ym1vZHVsZXMgd2lsbCBiZSBzaGFsbG93IgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMzcgYnVpbHRpbi9pbml0LWRiLmM6NDk1CisjOiBidWlsdGluL2Nsb25lLmM6MTM2IGJ1aWx0aW4vaW5pdC1kYi5jOjQ5NQogbXNnaWQgImdpdGRpciIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTM4IGJ1aWx0aW4vaW5pdC1kYi5jOjQ5NgorIzogYnVpbHRpbi9jbG9uZS5jOjEzNyBidWlsdGluL2luaXQtZGIuYzo0OTYKIG1zZ2lkICJzZXBhcmF0ZSBnaXQgZGlyIGZyb20gd29ya2luZyB0cmVlIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMzkKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMzgKIG1zZ2lkICJrZXk9dmFsdWUiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjE0MAorIzogYnVpbHRpbi9jbG9uZS5jOjEzOQogbXNnaWQgInNldCBjb25maWcgaW5zaWRlIHRoZSBuZXcgcmVwb3NpdG9yeSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTQyIGJ1aWx0aW4vZmV0Y2guYzoxNzQgYnVpbHRpbi9scy1yZW1vdGUuYzo3NgotIzogYnVpbHRpbi9wdXNoLmM6NTg1IGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTcyCisjOiBidWlsdGluL2Nsb25lLmM6MTQxIGJ1aWx0aW4vZmV0Y2guYzoxODkgYnVpbHRpbi9scy1yZW1vdGUuYzo3NgorIzogYnVpbHRpbi9wdXNoLmM6NTcyIGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTcyCiBtc2dpZCAic2VydmVyLXNwZWNpZmljIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxNDIgYnVpbHRpbi9mZXRjaC5jOjE3NCBidWlsdGluL2xzLXJlbW90ZS5jOjc2Ci0jOiBidWlsdGluL3B1c2guYzo1ODUgYnVpbHRpbi9zZW5kLXBhY2suYzoxNzMKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxNDEgYnVpbHRpbi9mZXRjaC5jOjE4OSBidWlsdGluL2xzLXJlbW90ZS5jOjc2CisjOiBidWlsdGluL3B1c2guYzo1NzIgYnVpbHRpbi9zZW5kLXBhY2suYzoxNzMKIG1zZ2lkICJvcHRpb24gdG8gdHJhbnNtaXQiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjE0MyBidWlsdGluL2ZldGNoLmM6MTc1IGJ1aWx0aW4vcHVsbC5jOjIzOQotIzogYnVpbHRpbi9wdXNoLmM6NTg2CisjOiBidWlsdGluL2Nsb25lLmM6MTQyIGJ1aWx0aW4vZmV0Y2guYzoxOTAgYnVpbHRpbi9wdWxsLmM6MjQwCisjOiBidWlsdGluL3B1c2guYzo1NzMKIG1zZ2lkICJ1c2UgSVB2NCBhZGRyZXNzZXMgb25seSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTQ1IGJ1aWx0aW4vZmV0Y2guYzoxNzcgYnVpbHRpbi9wdWxsLmM6MjQyCi0jOiBidWlsdGluL3B1c2guYzo1ODgKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxNDQgYnVpbHRpbi9mZXRjaC5jOjE5MiBidWlsdGluL3B1bGwuYzoyNDMKKyM6IGJ1aWx0aW4vcHVzaC5jOjU3NQogbXNnaWQgInVzZSBJUHY2IGFkZHJlc3NlcyBvbmx5IgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxNDkKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxNDgKIG1zZ2lkICJhbnkgY2xvbmVkIHN1Ym1vZHVsZXMgd2lsbCB1c2UgdGhlaXIgcmVtb3RlLXRyYWNraW5nIGJyYW5jaCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2Nsb25lLmM6Mjg1CisjOiBidWlsdGluL2Nsb25lLmM6Mjg0CiBtc2dpZCAiIgogIk5vIGRpcmVjdG9yeSBuYW1lIGNvdWxkIGJlIGd1ZXNzZWQuXG4iCiAiUGxlYXNlIHNwZWNpZnkgYSBkaXJlY3Rvcnkgb24gdGhlIGNvbW1hbmQgbGluZSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MzM4CisjOiBidWlsdGluL2Nsb25lLmM6MzM3CiAjLCBjLWZvcm1hdAogbXNnaWQgImluZm86IENvdWxkIG5vdCBhZGQgYWx0ZXJuYXRlIGZvciAnJXMnOiAlc1xuIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo0MTEKKyM6IGJ1aWx0aW4vY2xvbmUuYzo0MTAKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgZXhpc3RzIGFuZCBpcyBub3QgYSBkaXJlY3RvcnkiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjQyOAorIzogYnVpbHRpbi9jbG9uZS5jOjQyNwogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gc3RhcnQgaXRlcmF0b3Igb3ZlciAnJXMnIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo0NTMKLSMsIGMtZm9ybWF0Ci1tc2dpZCAiZmFpbGVkIHRvIHVubGluayAnJXMnIgotbXNnc3RyICIiCi0KLSM6IGJ1aWx0aW4vY2xvbmUuYzo0NTgKKyM6IGJ1aWx0aW4vY2xvbmUuYzo0NTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIGNyZWF0ZSBsaW5rICclcyciCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjQ2MgorIzogYnVpbHRpbi9jbG9uZS5jOjQ2MQogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gY29weSBmaWxlIHRvICclcyciCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjQ2NworIzogYnVpbHRpbi9jbG9uZS5jOjQ2NgogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gaXRlcmF0ZSBvdmVyICclcyciCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjQ5MgorIzogYnVpbHRpbi9jbG9uZS5jOjQ5MQogIywgYy1mb3JtYXQKIG1zZ2lkICJkb25lLlxuIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo1MDYKKyM6IGJ1aWx0aW4vY2xvbmUuYzo1MDUKIG1zZ2lkICIiCiAiQ2xvbmUgc3VjY2VlZGVkLCBidXQgY2hlY2tvdXQgZmFpbGVkLlxuIgogIllvdSBjYW4gaW5zcGVjdCB3aGF0IHdhcyBjaGVja2VkIG91dCB3aXRoICdnaXQgc3RhdHVzJ1xuIgogImFuZCByZXRyeSB3aXRoICdnaXQgcmVzdG9yZSAtLXNvdXJjZT1IRUFEIDovJ1xuIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo1ODMKKyM6IGJ1aWx0aW4vY2xvbmUuYzo1ODIKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ291bGQgbm90IGZpbmQgcmVtb3RlIGJyYW5jaCAlcyB0byBjbG9uZS4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjcwMgorIzogYnVpbHRpbi9jbG9uZS5jOjcwMQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gdXBkYXRlICVzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo3NTIKKyM6IGJ1aWx0aW4vY2xvbmUuYzo3NTEKIG1zZ2lkICJyZW1vdGUgSEVBRCByZWZlcnMgdG8gbm9uZXhpc3RlbnQgcmVmLCB1bmFibGUgdG8gY2hlY2tvdXQuXG4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjc4MworIzogYnVpbHRpbi9jbG9uZS5jOjc4MgogbXNnaWQgInVuYWJsZSB0byBjaGVja291dCB3b3JraW5nIHRyZWUiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjgzMworIzogYnVpbHRpbi9jbG9uZS5jOjgzMgogbXNnaWQgInVuYWJsZSB0byB3cml0ZSBwYXJhbWV0ZXJzIHRvIGNvbmZpZyBmaWxlIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo4OTYKKyM6IGJ1aWx0aW4vY2xvbmUuYzo4OTUKIG1zZ2lkICJjYW5ub3QgcmVwYWNrIHRvIGNsZWFuIHVwIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo4OTgKKyM6IGJ1aWx0aW4vY2xvbmUuYzo4OTcKIG1zZ2lkICJjYW5ub3QgdW5saW5rIHRlbXBvcmFyeSBhbHRlcm5hdGVzIGZpbGUiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjkzOCBidWlsdGluL3JlY2VpdmUtcGFjay5jOjE5NTAKKyM6IGJ1aWx0aW4vY2xvbmUuYzo5MzcgYnVpbHRpbi9yZWNlaXZlLXBhY2suYzoxOTQ4CiBtc2dpZCAiVG9vIG1hbnkgYXJndW1lbnRzLiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2Nsb25lLmM6OTQyCisjOiBidWlsdGluL2Nsb25lLmM6OTQxCiBtc2dpZCAiWW91IG11c3Qgc3BlY2lmeSBhIHJlcG9zaXRvcnkgdG8gY2xvbmUuIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo5NTUKKyM6IGJ1aWx0aW4vY2xvbmUuYzo5NTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiLS1iYXJlIGFuZCAtLW9yaWdpbiAlcyBvcHRpb25zIGFyZSBpbmNvbXBhdGlibGUuIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo5NTgKKyM6IGJ1aWx0aW4vY2xvbmUuYzo5NTcKIG1zZ2lkICItLWJhcmUgYW5kIC0tc2VwYXJhdGUtZ2l0LWRpciBhcmUgaW5jb21wYXRpYmxlLiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2Nsb25lLmM6OTcxCisjOiBidWlsdGluL2Nsb25lLmM6OTcwCiAjLCBjLWZvcm1hdAogbXNnaWQgInJlcG9zaXRvcnkgJyVzJyBkb2VzIG5vdCBleGlzdCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2Nsb25lLmM6OTc3IGJ1aWx0aW4vZmV0Y2guYzoxNjYwCisjOiBidWlsdGluL2Nsb25lLmM6OTc2IGJ1aWx0aW4vZmV0Y2guYzoxNzkwCiAjLCBjLWZvcm1hdAogbXNnaWQgImRlcHRoICVzIGlzIG5vdCBhIHBvc2l0aXZlIG51bWJlciIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2Nsb25lLmM6OTg3CisjOiBidWlsdGluL2Nsb25lLmM6OTg2CiAjLCBjLWZvcm1hdAogbXNnaWQgImRlc3RpbmF0aW9uIHBhdGggJyVzJyBhbHJlYWR5IGV4aXN0cyBhbmQgaXMgbm90IGFuIGVtcHR5IGRpcmVjdG9yeS4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjk5NworIzogYnVpbHRpbi9jbG9uZS5jOjk5NgogIywgYy1mb3JtYXQKIG1zZ2lkICJ3b3JraW5nIHRyZWUgJyVzJyBhbHJlYWR5IGV4aXN0cy4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEwMTIgYnVpbHRpbi9jbG9uZS5jOjEwMzMgYnVpbHRpbi9kaWZmdG9vbC5jOjI2NAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjMwMyBidWlsdGluL3dvcmt0cmVlLmM6MzM1CisjOiBidWlsdGluL2Nsb25lLmM6MTAxMSBidWlsdGluL2Nsb25lLmM6MTAzMiBidWlsdGluL2RpZmZ0b29sLmM6MjcxCisjOiBidWlsdGluL2xvZy5jOjE3ODUgYnVpbHRpbi93b3JrdHJlZS5jOjMwMiBidWlsdGluL3dvcmt0cmVlLmM6MzM0CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBjcmVhdGUgbGVhZGluZyBkaXJlY3RvcmllcyBvZiAnJXMnIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMDE3CisjOiBidWlsdGluL2Nsb25lLmM6MTAxNgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgY3JlYXRlIHdvcmsgdHJlZSBkaXIgJyVzJyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTAzNworIzogYnVpbHRpbi9jbG9uZS5jOjEwMzYKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ2xvbmluZyBpbnRvIGJhcmUgcmVwb3NpdG9yeSAnJXMnLi4uXG4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEwMzkKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMDM4CiAjLCBjLWZvcm1hdAogbXNnaWQgIkNsb25pbmcgaW50byAnJXMnLi4uXG4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEwNjMKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMDYyCiBtc2dpZCAiIgogImNsb25lIC0tcmVjdXJzaXZlIGlzIG5vdCBjb21wYXRpYmxlIHdpdGggYm90aCAtLXJlZmVyZW5jZSBhbmQgLS1yZWZlcmVuY2UtaWYtIgogImFibGUiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjExMjQKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMTIzCiBtc2dpZCAiLS1kZXB0aCBpcyBpZ25vcmVkIGluIGxvY2FsIGNsb25lczsgdXNlIGZpbGU6Ly8gaW5zdGVhZC4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjExMjYKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMTI1CiBtc2dpZCAiLS1zaGFsbG93LXNpbmNlIGlzIGlnbm9yZWQgaW4gbG9jYWwgY2xvbmVzOyB1c2UgZmlsZTovLyBpbnN0ZWFkLiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTEyOAorIzogYnVpbHRpbi9jbG9uZS5jOjExMjcKIG1zZ2lkICItLXNoYWxsb3ctZXhjbHVkZSBpcyBpZ25vcmVkIGluIGxvY2FsIGNsb25lczsgdXNlIGZpbGU6Ly8gaW5zdGVhZC4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjExMzAKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMTI5CiBtc2dpZCAiLS1maWx0ZXIgaXMgaWdub3JlZCBpbiBsb2NhbCBjbG9uZXM7IHVzZSBmaWxlOi8vIGluc3RlYWQuIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMTMzCisjOiBidWlsdGluL2Nsb25lLmM6MTEzMgogbXNnaWQgInNvdXJjZSByZXBvc2l0b3J5IGlzIHNoYWxsb3csIGlnbm9yaW5nIC0tbG9jYWwiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjExMzgKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMTM3CiBtc2dpZCAiLS1sb2NhbCBpcyBpZ25vcmVkIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMjE1IGJ1aWx0aW4vY2xvbmUuYzoxMjIzCisjOiBidWlsdGluL2Nsb25lLmM6MTIxMiBidWlsdGluL2Nsb25lLmM6MTIyMAogIywgYy1mb3JtYXQKIG1zZ2lkICJSZW1vdGUgYnJhbmNoICVzIG5vdCBmb3VuZCBpbiB1cHN0cmVhbSAlcyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTIyNgorIzogYnVpbHRpbi9jbG9uZS5jOjEyMjMKIG1zZ2lkICJZb3UgYXBwZWFyIHRvIGhhdmUgY2xvbmVkIGFuIGVtcHR5IHJlcG9zaXRvcnkuIgogbXNnc3RyICIiCiAKQEAgLTEwNTMwLDcgKzEwNTYyLDcgQEAKIG1zZ3N0ciAiIgogCiAjOiBidWlsdGluL2NvbW1pdC10cmVlLmM6MTE0IGJ1aWx0aW4vY29tbWl0LmM6MTUwMCBidWlsdGluL21lcmdlLmM6MjcwCi0jOiBidWlsdGluL25vdGVzLmM6NDA5IGJ1aWx0aW4vbm90ZXMuYzo1NzUgYnVpbHRpbi9zdGFzaC5jOjE0NjAKKyM6IGJ1aWx0aW4vbm90ZXMuYzo0MDkgYnVpbHRpbi9ub3Rlcy5jOjU3NSBidWlsdGluL3N0YXNoLmM6MTQ2OQogIzogYnVpbHRpbi90YWcuYzo0MTIKIG1zZ2lkICJtZXNzYWdlIgogbXNnc3RyICIiCkBAIC0xMDU0NCw3ICsxMDU3Niw3IEBACiBtc2dzdHIgIiIKIAogIzogYnVpbHRpbi9jb21taXQtdHJlZS5jOjEyMSBidWlsdGluL2NvbW1pdC5jOjE1MTIgYnVpbHRpbi9tZXJnZS5jOjI4NwotIzogYnVpbHRpbi9wdWxsLmM6MTk0IGJ1aWx0aW4vcmV2ZXJ0LmM6MTE4CisjOiBidWlsdGluL3B1bGwuYzoxOTUgYnVpbHRpbi9yZXZlcnQuYzoxMTgKIG1zZ2lkICJHUEcgc2lnbiBjb21taXQiCiBtc2dzdHIgIiIKIApAQCAtMTA4MzUsOCArMTA4NjcsOCBAQAogbXNnaWQgInZlcnNpb24iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9jb21taXQuYzoxMzQ3IGJ1aWx0aW4vY29tbWl0LmM6MTUyOSBidWlsdGluL3B1c2guYzo1NjEKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo2NTEKKyM6IGJ1aWx0aW4vY29tbWl0LmM6MTM0NyBidWlsdGluL2NvbW1pdC5jOjE1MjkgYnVpbHRpbi9wdXNoLmM6NTQ4CisjOiBidWlsdGluL3dvcmt0cmVlLmM6NjUwCiBtc2dpZCAibWFjaGluZS1yZWFkYWJsZSBvdXRwdXQiCiBtc2dzdHIgIiIKIApAQCAtMTA4NDksOCArMTA4ODEsOCBAQAogbXNnc3RyICIiCiAKICM6IGJ1aWx0aW4vY29tbWl0LmM6MTM1NSBidWlsdGluL2NvbW1pdC5jOjEzNTkgYnVpbHRpbi9jb21taXQuYzoxNTM3Ci0jOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTEyNSBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTEyOAotIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExMzEgYnVpbHRpbi9yZWJhc2UuYzoxNDcxIHBhcnNlLW9wdGlvbnMuaDozMzIKKyM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTUzIGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTU2CisjOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE1OSBidWlsdGluL3JlYmFzZS5jOjE0OTUgcGFyc2Utb3B0aW9ucy5oOjMzMgogbXNnaWQgIm1vZGUiCiBtc2dzdHIgIiIKIApAQCAtMTA4NjQsNyArMTA4OTYsNyBAQAogInRyYWRpdGlvbmFsKSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2NvbW1pdC5jOjEzNjIgcGFyc2Utb3B0aW9ucy5oOjE3OQorIzogYnVpbHRpbi9jb21taXQuYzoxMzYyIHBhcnNlLW9wdGlvbnMuaDoxODgKIG1zZ2lkICJ3aGVuIgogbXNnc3RyICIiCiAKQEAgLTEwOTE0LDcgKzEwOTQ2LDcgQEAKIG1zZ2lkICJvdmVycmlkZSBhdXRob3IgZm9yIGNvbW1pdCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2NvbW1pdC5jOjE0OTkgYnVpbHRpbi9nYy5jOjUzOQorIzogYnVpbHRpbi9jb21taXQuYzoxNDk5IGJ1aWx0aW4vZ2MuYzo1MzgKIG1zZ2lkICJkYXRlIgogbXNnc3RyICIiCiAKQEAgLTEwOTQ3LDggKzEwOTc5LDggQEAKIG1zZ2lkICJ0aGUgY29tbWl0IGlzIGF1dGhvcmVkIGJ5IG1lIG5vdyAodXNlZCB3aXRoIC1DLy1jLy0tYW1lbmQpIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vY29tbWl0LmM6MTUwNiBidWlsdGluL2xvZy5jOjE1NjQgYnVpbHRpbi9tZXJnZS5jOjI4OQotIzogYnVpbHRpbi9wdWxsLmM6MTYzIGJ1aWx0aW4vcmV2ZXJ0LmM6MTEwCisjOiBidWlsdGluL2NvbW1pdC5jOjE1MDYgYnVpbHRpbi9sb2cuYzoxNTY1IGJ1aWx0aW4vbWVyZ2UuYzoyODkKKyM6IGJ1aWx0aW4vcHVsbC5jOjE2NCBidWlsdGluL3JldmVydC5jOjExMAogbXNnaWQgImFkZCBTaWduZWQtb2ZmLWJ5OiIKIG1zZ3N0ciAiIgogCkBAIC0xMTA1Miw2NCArMTEwODQsNjUgQEAKIG1zZ3N0ciAiIgogCiAjOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjEzIGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTkKLW1zZ2lkICJnaXQgY29tbWl0LWdyYXBoIHZlcmlmeSBbLS1vYmplY3QtZGlyIDxvYmpkaXI+XSBbLS1zaGFsbG93XSIKK21zZ2lkICIiCisiZ2l0IGNvbW1pdC1ncmFwaCB2ZXJpZnkgWy0tb2JqZWN0LWRpciA8b2JqZGlyPl0gWy0tc2hhbGxvd10gWy0tW25vLV1wcm9ncmVzc10iCiBtc2dzdHIgIiIKIAogIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxNCBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjI5CiBtc2dpZCAiIgogImdpdCBjb21taXQtZ3JhcGggd3JpdGUgWy0tb2JqZWN0LWRpciA8b2JqZGlyPl0gWy0tYXBwZW5kfC0tc3BsaXRdIFstLSIKLSJyZWFjaGFibGV8LS1zdGRpbi1wYWNrc3wtLXN0ZGluLWNvbW1pdHNdIDxzcGxpdCBvcHRpb25zPiIKKyJyZWFjaGFibGV8LS1zdGRpbi1wYWNrc3wtLXN0ZGluLWNvbW1pdHNdIFstLVtuby1dcHJvZ3Jlc3NdIDxzcGxpdCBvcHRpb25zPiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjU0IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTAwCi0jOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE2MSBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjIzNyBidWlsdGluL2ZldGNoLmM6MTYzCi0jOiBidWlsdGluL2xvZy5jOjE1ODQKKyM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6NTUgYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxMDcKKyM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTcwIGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MjU0IGJ1aWx0aW4vZmV0Y2guYzoxNzgKKyM6IGJ1aWx0aW4vbG9nLmM6MTU4NQogbXNnaWQgImRpciIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjU1IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTAxCi0jOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE2MiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjIzOAorIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzo1NiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjEwOAorIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxNzEgYnVpbHRpbi9jb21taXQtZ3JhcGguYzoyNTUKIG1zZ2lkICJUaGUgb2JqZWN0IGRpcmVjdG9yeSB0byBzdG9yZSB0aGUgZ3JhcGgiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzo1NworIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzo1OAogbXNnaWQgImlmIHRoZSBjb21taXQtZ3JhcGggaXMgc3BsaXQsIG9ubHkgdmVyaWZ5IHRoZSB0aXAgZmlsZSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjczIGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTE2CisjOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjgwIGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTI1CiAjLCBjLWZvcm1hdAogbXNnaWQgIkNvdWxkIG5vdCBvcGVuIGNvbW1pdC1ncmFwaCAnJXMnIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTY0CisjOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE3MwogbXNnaWQgInN0YXJ0IHdhbGsgYXQgYWxsIHJlZnMiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxNjYKKyM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTc1CiBtc2dpZCAic2NhbiBwYWNrLWluZGV4ZXMgbGlzdGVkIGJ5IHN0ZGluIGZvciBjb21taXRzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTY4CisjOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE3NwogbXNnaWQgInN0YXJ0IHdhbGsgYXQgY29tbWl0cyBsaXN0ZWQgYnkgc3RkaW4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxNzAKKyM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTc5CiBtc2dpZCAiaW5jbHVkZSBhbGwgY29tbWl0cyBhbHJlYWR5IGluIHRoZSBjb21taXQtZ3JhcGggZmlsZSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE3MgorIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxODIKIG1zZ2lkICJhbGxvdyB3cml0aW5nIGFuIGluY3JlbWVudGFsIGNvbW1pdC1ncmFwaCBmaWxlIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTc0IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTc4CisjOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE4NCBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE4OAogbXNnaWQgIm1heGltdW0gbnVtYmVyIG9mIGNvbW1pdHMgaW4gYSBub24tYmFzZSBzcGxpdCBjb21taXQtZ3JhcGgiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxNzYKKyM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTg2CiBtc2dpZCAibWF4aW11bSByYXRpbyBiZXR3ZWVuIHR3byBsZXZlbHMgb2YgYSBzcGxpdCBjb21taXQtZ3JhcGgiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxOTEKKyM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MjA0CiBtc2dpZCAidXNlIGF0IG1vc3Qgb25lIG9mIC0tcmVhY2hhYmxlLCAtLXN0ZGluLWNvbW1pdHMsIG9yIC0tc3RkaW4tcGFja3MiCiBtc2dzdHIgIiIKIApAQCAtMTE0MTIsMTY2ICsxMTQ0NSwxNjYgQEAKIG1zZ2lkICJwcmludCBzaXplcyBpbiBodW1hbiByZWFkYWJsZSBmb3JtYXQiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjI3CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6MjYKIG1zZ2lkICJnaXQgZGVzY3JpYmUgWzxvcHRpb25zPl0gWzxjb21taXQtaXNoPi4uLl0iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjI4CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6MjcKIG1zZ2lkICJnaXQgZGVzY3JpYmUgWzxvcHRpb25zPl0gLS1kaXJ0eSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NjMKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo2MgogbXNnaWQgImhlYWQiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjYzCisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NjIKIG1zZ2lkICJsaWdodHdlaWdodCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NjMKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo2MgogbXNnaWQgImFubm90YXRlZCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6MjczCisjOiBidWlsdGluL2Rlc2NyaWJlLmM6Mjc1CiAjLCBjLWZvcm1hdAogbXNnaWQgImFubm90YXRlZCB0YWcgJXMgbm90IGF2YWlsYWJsZSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6Mjc3CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6Mjc5CiAjLCBjLWZvcm1hdAogbXNnaWQgImFubm90YXRlZCB0YWcgJXMgaGFzIG5vIGVtYmVkZGVkIG5hbWUiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjI3OQorIzogYnVpbHRpbi9kZXNjcmliZS5jOjI4MQogIywgYy1mb3JtYXQKIG1zZ2lkICJ0YWcgJyVzJyBpcyByZWFsbHkgJyVzJyBoZXJlIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzozMjMKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzozMjUKICMsIGMtZm9ybWF0CiBtc2dpZCAibm8gdGFnIGV4YWN0bHkgbWF0Y2hlcyAnJXMnIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzozMjUKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzozMjcKICMsIGMtZm9ybWF0CiBtc2dpZCAiTm8gZXhhY3QgbWF0Y2ggb24gcmVmcyBvciB0YWdzLCBzZWFyY2hpbmcgdG8gZGVzY3JpYmVcbiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6Mzc5CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6MzgxCiAjLCBjLWZvcm1hdAogbXNnaWQgImZpbmlzaGVkIHNlYXJjaCBhdCAlc1xuIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo0MDUKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo0MDcKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIk5vIGFubm90YXRlZCB0YWdzIGNhbiBkZXNjcmliZSAnJXMnLlxuIgogIkhvd2V2ZXIsIHRoZXJlIHdlcmUgdW5hbm5vdGF0ZWQgdGFnczogdHJ5IC0tdGFncy4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjQwOQorIzogYnVpbHRpbi9kZXNjcmliZS5jOjQxMQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiTm8gdGFncyBjYW4gZGVzY3JpYmUgJyVzJy5cbiIKICJUcnkgLS1hbHdheXMsIG9yIGNyZWF0ZSBzb21lIHRhZ3MuIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo0MzkKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo0NDEKICMsIGMtZm9ybWF0CiBtc2dpZCAidHJhdmVyc2VkICVsdSBjb21taXRzXG4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjQ0MgorIzogYnVpbHRpbi9kZXNjcmliZS5jOjQ0NAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAibW9yZSB0aGFuICVpIHRhZ3MgZm91bmQ7IGxpc3RlZCAlaSBtb3N0IHJlY2VudFxuIgogImdhdmUgdXAgc2VhcmNoIGF0ICVzXG4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjUxMAorIzogYnVpbHRpbi9kZXNjcmliZS5jOjUxMgogIywgYy1mb3JtYXQKIG1zZ2lkICJkZXNjcmliZSAlc1xuIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1MTMKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1MTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiTm90IGEgdmFsaWQgb2JqZWN0IG5hbWUgJXMiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjUyMQorIzogYnVpbHRpbi9kZXNjcmliZS5jOjUyMwogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyBpcyBuZWl0aGVyIGEgY29tbWl0IG5vciBibG9iIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1MzUKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1MzcKIG1zZ2lkICJmaW5kIHRoZSB0YWcgdGhhdCBjb21lcyBhZnRlciB0aGUgY29tbWl0IgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1MzYKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1MzgKIG1zZ2lkICJkZWJ1ZyBzZWFyY2ggc3RyYXRlZ3kgb24gc3RkZXJyIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1MzcKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1MzkKIG1zZ2lkICJ1c2UgYW55IHJlZiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NTM4CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NTQwCiBtc2dpZCAidXNlIGFueSB0YWcsIGV2ZW4gdW5hbm5vdGF0ZWQiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjUzOQorIzogYnVpbHRpbi9kZXNjcmliZS5jOjU0MQogbXNnaWQgImFsd2F5cyB1c2UgbG9uZyBmb3JtYXQiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjU0MAorIzogYnVpbHRpbi9kZXNjcmliZS5jOjU0MgogbXNnaWQgIm9ubHkgZm9sbG93IGZpcnN0IHBhcmVudCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NTQzCisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NTQ1CiBtc2dpZCAib25seSBvdXRwdXQgZXhhY3QgbWF0Y2hlcyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NTQ1CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NTQ3CiBtc2dpZCAiY29uc2lkZXIgPG4+IG1vc3QgcmVjZW50IHRhZ3MgKGRlZmF1bHQ6IDEwKSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NTQ3CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NTQ5CiBtc2dpZCAib25seSBjb25zaWRlciB0YWdzIG1hdGNoaW5nIDxwYXR0ZXJuPiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NTQ5CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NTUxCiBtc2dpZCAiZG8gbm90IGNvbnNpZGVyIHRhZ3MgbWF0Y2hpbmcgPHBhdHRlcm4+IgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1NTEgYnVpbHRpbi9uYW1lLXJldi5jOjQyMgorIzogYnVpbHRpbi9kZXNjcmliZS5jOjU1MyBidWlsdGluL25hbWUtcmV2LmM6NDI2CiBtc2dpZCAic2hvdyBhYmJyZXZpYXRlZCBjb21taXQgb2JqZWN0IGFzIGZhbGxiYWNrIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1NTIgYnVpbHRpbi9kZXNjcmliZS5jOjU1NQorIzogYnVpbHRpbi9kZXNjcmliZS5jOjU1NCBidWlsdGluL2Rlc2NyaWJlLmM6NTU3CiBtc2dpZCAibWFyayIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NTUzCisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NTU1CiBtc2dpZCAiYXBwZW5kIDxtYXJrPiBvbiBkaXJ0eSB3b3JraW5nIHRyZWUgKGRlZmF1bHQ6IFwiLWRpcnR5XCIpIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1NTYKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1NTgKIG1zZ2lkICJhcHBlbmQgPG1hcms+IG9uIGJyb2tlbiB3b3JraW5nIHRyZWUgKGRlZmF1bHQ6IFwiLWJyb2tlblwiKSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NTc0CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NTc2CiBtc2dpZCAiLS1sb25nIGlzIGluY29tcGF0aWJsZSB3aXRoIC0tYWJicmV2PTAiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjYwMworIzogYnVpbHRpbi9kZXNjcmliZS5jOjYwNQogbXNnaWQgIk5vIG5hbWVzIGZvdW5kLCBjYW5ub3QgZGVzY3JpYmUgYW55dGhpbmcuIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo2NTQKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo2NTYKIG1zZ2lkICItLWRpcnR5IGlzIGluY29tcGF0aWJsZSB3aXRoIGNvbW1pdC1pc2hlcyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NjU2CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NjU4CiBtc2dpZCAiLS1icm9rZW4gaXMgaW5jb21wYXRpYmxlIHdpdGggY29tbWl0LWlzaGVzIgogbXNnc3RyICIiCiAKQEAgLTExNjA4LDEwOSArMTE2NDEsMTA5IEBACiBtc2dpZCAiZ2l0IGRpZmZ0b29sIFs8b3B0aW9ucz5dIFs8Y29tbWl0PiBbPGNvbW1pdD5dXSBbLS1dIFs8cGF0aD4uLi5dIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZGlmZnRvb2wuYzoyNTMKKyM6IGJ1aWx0aW4vZGlmZnRvb2wuYzoyNjAKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkOiAlZCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2RpZmZ0b29sLmM6Mjk1CisjOiBidWlsdGluL2RpZmZ0b29sLmM6MzAyCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCByZWFkIHN5bWxpbmsgJXMiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjI5NworIzogYnVpbHRpbi9kaWZmdG9vbC5jOjMwNAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcmVhZCBzeW1saW5rIGZpbGUgJXMiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjMwNQorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjMxMgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcmVhZCBvYmplY3QgJXMgZm9yIHN5bWxpbmsgJXMiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjQwNgorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjQxMwogbXNnaWQgIiIKICJjb21iaW5lZCBkaWZmIGZvcm1hdHMoJy1jJyBhbmQgJy0tY2MnKSBhcmUgbm90IHN1cHBvcnRlZCBpblxuIgogImRpcmVjdG9yeSBkaWZmIG1vZGUoJy1kJyBhbmQgJy0tZGlyLWRpZmYnKS4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjYyNgorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjYzNAogIywgYy1mb3JtYXQKIG1zZ2lkICJib3RoIGZpbGVzIG1vZGlmaWVkOiAnJXMnIGFuZCAnJXMnLiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2RpZmZ0b29sLmM6NjI4CisjOiBidWlsdGluL2RpZmZ0b29sLmM6NjM2CiBtc2dpZCAid29ya2luZyB0cmVlIGZpbGUgaGFzIGJlZW4gbGVmdC4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjYzOQorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjY0NwogIywgYy1mb3JtYXQKIG1zZ2lkICJ0ZW1wb3JhcnkgZmlsZXMgZXhpc3QgaW4gJyVzJy4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjY0MAorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjY0OAogbXNnaWQgInlvdSBtYXkgd2FudCB0byBjbGVhbnVwIG9yIHJlY292ZXIgdGhlc2UuIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo2ODkKKyM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo2OTcKIG1zZ2lkICJ1c2UgYGRpZmYuZ3VpdG9vbGAgaW5zdGVhZCBvZiBgZGlmZi50b29sYCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2RpZmZ0b29sLmM6NjkxCisjOiBidWlsdGluL2RpZmZ0b29sLmM6Njk5CiBtc2dpZCAicGVyZm9ybSBhIGZ1bGwtZGlyZWN0b3J5IGRpZmYiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjY5MworIzogYnVpbHRpbi9kaWZmdG9vbC5jOjcwMQogbXNnaWQgImRvIG5vdCBwcm9tcHQgYmVmb3JlIGxhdW5jaGluZyBhIGRpZmYgdG9vbCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2RpZmZ0b29sLmM6Njk4CisjOiBidWlsdGluL2RpZmZ0b29sLmM6NzA2CiBtc2dpZCAidXNlIHN5bWxpbmtzIGluIGRpci1kaWZmIG1vZGUiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjY5OQorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjcwNwogbXNnaWQgInRvb2wiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjcwMAorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjcwOAogbXNnaWQgInVzZSB0aGUgc3BlY2lmaWVkIGRpZmYgdG9vbCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2RpZmZ0b29sLmM6NzAyCisjOiBidWlsdGluL2RpZmZ0b29sLmM6NzEwCiBtc2dpZCAicHJpbnQgYSBsaXN0IG9mIGRpZmYgdG9vbHMgdGhhdCBtYXkgYmUgdXNlZCB3aXRoIGAtLXRvb2xgIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo3MDUKKyM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo3MTMKIG1zZ2lkICIiCiAibWFrZSAnZ2l0LWRpZmZ0b29sJyBleGl0IHdoZW4gYW4gaW52b2tlZCBkaWZmIHRvb2wgcmV0dXJucyBhIG5vbiAtIHplcm8gZXhpdCAiCiAiY29kZSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2RpZmZ0b29sLmM6NzA4CisjOiBidWlsdGluL2RpZmZ0b29sLmM6NzE2CiBtc2dpZCAic3BlY2lmeSBhIGN1c3RvbSBjb21tYW5kIGZvciB2aWV3aW5nIGRpZmZzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo3MDkKKyM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo3MTcKIG1zZ2lkICJwYXNzZWQgdG8gYGRpZmZgIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo3MjQKKyM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo3MzIKIG1zZ2lkICJkaWZmdG9vbCByZXF1aXJlcyB3b3JrdHJlZSBvciAtLW5vLWluZGV4IgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo3MzEKKyM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo3MzkKIG1zZ2lkICItLWRpci1kaWZmIGlzIGluY29tcGF0aWJsZSB3aXRoIC0tbm8taW5kZXgiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjczNAorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjc0MgogbXNnaWQgIi0tZ3VpLCAtLXRvb2wgYW5kIC0tZXh0Y21kIGFyZSBtdXR1YWxseSBleGNsdXNpdmUiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjc0MgorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjc1MAogbXNnaWQgIm5vIDx0b29sPiBnaXZlbiBmb3IgLS10b29sPTx0b29sPiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2RpZmZ0b29sLmM6NzQ5CisjOiBidWlsdGluL2RpZmZ0b29sLmM6NzU3CiBtc2dpZCAibm8gPGNtZD4gZ2l2ZW4gZm9yIC0tZXh0Y21kPTxjbWQ+IgogbXNnc3RyICIiCiAKQEAgLTExNzQ2LDI1MSArMTE3NzksMjc1IEBACiBtc2dpZCAiZ2l0IGZhc3QtZXhwb3J0IFtyZXYtbGlzdC1vcHRzXSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTEyNAorIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjg1MgorbXNnaWQgIkVycm9yOiBDYW5ub3QgZXhwb3J0IG5lc3RlZCB0YWdzIHVubGVzcyAtLW1hcmstdGFncyBpcyBzcGVjaWZpZWQuIgorbXNnc3RyICIiCisKKyM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTUyCiBtc2dpZCAic2hvdyBwcm9ncmVzcyBhZnRlciA8bj4gb2JqZWN0cyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTEyNgorIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNTQKIG1zZ2lkICJzZWxlY3QgaGFuZGxpbmcgb2Ygc2lnbmVkIHRhZ3MiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExMjkKKyM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTU3CiBtc2dpZCAic2VsZWN0IGhhbmRsaW5nIG9mIHRhZ3MgdGhhdCB0YWcgZmlsdGVyZWQgb2JqZWN0cyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTEzMgorIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNjAKIG1zZ2lkICJzZWxlY3QgaGFuZGxpbmcgb2YgY29tbWl0IG1lc3NhZ2VzIGluIGFuIGFsdGVybmF0ZSBlbmNvZGluZyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTEzNQorIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNjMKIG1zZ2lkICJEdW1wIG1hcmtzIHRvIHRoaXMgZmlsZSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTEzNworIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNjUKIG1zZ2lkICJJbXBvcnQgbWFya3MgZnJvbSB0aGlzIGZpbGUiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExMzkKKyM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTY5Cittc2dpZCAiSW1wb3J0IG1hcmtzIGZyb20gdGhpcyBmaWxlIGlmIGl0IGV4aXN0cyIKK21zZ3N0ciAiIgorCisjOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE3MQogbXNnaWQgIkZha2UgYSB0YWdnZXIgd2hlbiB0YWdzIGxhY2sgb25lIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTQxCisjOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE3MwogbXNnaWQgIk91dHB1dCBmdWxsIHRyZWUgZm9yIGVhY2ggY29tbWl0IgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTQzCisjOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE3NQogbXNnaWQgIlVzZSB0aGUgZG9uZSBmZWF0dXJlIHRvIHRlcm1pbmF0ZSB0aGUgc3RyZWFtIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTQ0CisjOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE3NgogbXNnaWQgIlNraXAgb3V0cHV0IG9mIGJsb2IgZGF0YSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE0NSBidWlsdGluL2xvZy5jOjE2MzIKKyM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTc3IGJ1aWx0aW4vbG9nLmM6MTYzMwogbXNnaWQgInJlZnNwZWMiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNDYKKyM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTc4CiBtc2dpZCAiQXBwbHkgcmVmc3BlYyB0byBleHBvcnRlZCByZWZzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTQ3CisjOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE3OQogbXNnaWQgImFub255bWl6ZSBvdXRwdXQiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNDkKKyM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTgxCiBtc2dpZCAiUmVmZXJlbmNlIHBhcmVudHMgd2hpY2ggYXJlIG5vdCBpbiBmYXN0LWV4cG9ydCBzdHJlYW0gYnkgb2JqZWN0IGlkIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTUxCisjOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE4MwogbXNnaWQgIlNob3cgb3JpZ2luYWwgb2JqZWN0IGlkcyBvZiBibG9icy9jb21taXRzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzozMAorIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExODUKK21zZ2lkICJMYWJlbCB0YWdzIHdpdGggbWFyayBpZHMiCittc2dzdHIgIiIKKworIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjEyMjAKK21zZ2lkICJDYW5ub3QgcGFzcyBib3RoIC0taW1wb3J0LW1hcmtzIGFuZCAtLWltcG9ydC1tYXJrcy1pZi1leGlzdHMiCittc2dzdHIgIiIKKworIzogYnVpbHRpbi9mZXRjaC5jOjM0CiBtc2dpZCAiZ2l0IGZldGNoIFs8b3B0aW9ucz5dIFs8cmVwb3NpdG9yeT4gWzxyZWZzcGVjPi4uLl1dIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzozMQorIzogYnVpbHRpbi9mZXRjaC5jOjM1CiBtc2dpZCAiZ2l0IGZldGNoIFs8b3B0aW9ucz5dIDxncm91cD4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjMyCisjOiBidWlsdGluL2ZldGNoLmM6MzYKIG1zZ2lkICJnaXQgZmV0Y2ggLS1tdWx0aXBsZSBbPG9wdGlvbnM+XSBbKDxyZXBvc2l0b3J5PiB8IDxncm91cD4pLi4uXSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MzMKKyM6IGJ1aWx0aW4vZmV0Y2guYzozNwogbXNnaWQgImdpdCBmZXRjaCAtLWFsbCBbPG9wdGlvbnM+XSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTI1IGJ1aWx0aW4vcHVsbC5jOjIwMworIzogYnVpbHRpbi9mZXRjaC5jOjExNQorbXNnaWQgImZldGNoLnBhcmFsbGVsIGNhbm5vdCBiZSBuZWdhdGl2ZSIKK21zZ3N0ciAiIgorCisjOiBidWlsdGluL2ZldGNoLmM6MTM4IGJ1aWx0aW4vcHVsbC5jOjIwNAogbXNnaWQgImZldGNoIGZyb20gYWxsIHJlbW90ZXMiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjEyNyBidWlsdGluL3B1bGwuYzoyMDYKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNDAgYnVpbHRpbi9wdWxsLmM6MjQ4Cittc2dpZCAic2V0IHVwc3RyZWFtIGZvciBnaXQgcHVsbC9mZXRjaCIKK21zZ3N0ciAiIgorCisjOiBidWlsdGluL2ZldGNoLmM6MTQyIGJ1aWx0aW4vcHVsbC5jOjIwNwogbXNnaWQgImFwcGVuZCB0byAuZ2l0L0ZFVENIX0hFQUQgaW5zdGVhZCBvZiBvdmVyd3JpdGluZyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTI5IGJ1aWx0aW4vcHVsbC5jOjIwOQorIzogYnVpbHRpbi9mZXRjaC5jOjE0NCBidWlsdGluL3B1bGwuYzoyMTAKIG1zZ2lkICJwYXRoIHRvIHVwbG9hZCBwYWNrIG9uIHJlbW90ZSBlbmQiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjEzMAorIzogYnVpbHRpbi9mZXRjaC5jOjE0NQogbXNnaWQgImZvcmNlIG92ZXJ3cml0ZSBvZiBsb2NhbCByZWZlcmVuY2UiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjEzMgorIzogYnVpbHRpbi9mZXRjaC5jOjE0NwogbXNnaWQgImZldGNoIGZyb20gbXVsdGlwbGUgcmVtb3RlcyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTM0IGJ1aWx0aW4vcHVsbC5jOjIxMworIzogYnVpbHRpbi9mZXRjaC5jOjE0OSBidWlsdGluL3B1bGwuYzoyMTQKIG1zZ2lkICJmZXRjaCBhbGwgdGFncyBhbmQgYXNzb2NpYXRlZCBvYmplY3RzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxMzYKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNTEKIG1zZ2lkICJkbyBub3QgZmV0Y2ggYWxsIHRhZ3MgKC0tbm8tdGFncykiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjEzOAorIzogYnVpbHRpbi9mZXRjaC5jOjE1MwogbXNnaWQgIm51bWJlciBvZiBzdWJtb2R1bGVzIGZldGNoZWQgaW4gcGFyYWxsZWwiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE0MCBidWlsdGluL3B1bGwuYzoyMTYKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNTUgYnVpbHRpbi9wdWxsLmM6MjE3CiBtc2dpZCAicHJ1bmUgcmVtb3RlLXRyYWNraW5nIGJyYW5jaGVzIG5vIGxvbmdlciBvbiByZW1vdGUiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE0MgorIzogYnVpbHRpbi9mZXRjaC5jOjE1NwogbXNnaWQgInBydW5lIGxvY2FsIHRhZ3Mgbm8gbG9uZ2VyIG9uIHJlbW90ZSBhbmQgY2xvYmJlciBjaGFuZ2VkIHRhZ3MiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE0MyBidWlsdGluL2ZldGNoLmM6MTY2IGJ1aWx0aW4vcHVsbC5jOjE0MAorIzogYnVpbHRpbi9mZXRjaC5jOjE1OCBidWlsdGluL2ZldGNoLmM6MTgxIGJ1aWx0aW4vcHVsbC5jOjE0MQogbXNnaWQgIm9uLWRlbWFuZCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTQ0CisjOiBidWlsdGluL2ZldGNoLmM6MTU5CiBtc2dpZCAiY29udHJvbCByZWN1cnNpdmUgZmV0Y2hpbmcgb2Ygc3VibW9kdWxlcyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTQ4IGJ1aWx0aW4vcHVsbC5jOjIyNAorIzogYnVpbHRpbi9mZXRjaC5jOjE2MyBidWlsdGluL3B1bGwuYzoyMjUKIG1zZ2lkICJrZWVwIGRvd25sb2FkZWQgcGFjayIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTUwCisjOiBidWlsdGluL2ZldGNoLmM6MTY1CiBtc2dpZCAiYWxsb3cgdXBkYXRpbmcgb2YgSEVBRCByZWYiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE1MyBidWlsdGluL2ZldGNoLmM6MTU5IGJ1aWx0aW4vcHVsbC5jOjIyNworIzogYnVpbHRpbi9mZXRjaC5jOjE2OCBidWlsdGluL2ZldGNoLmM6MTc0IGJ1aWx0aW4vcHVsbC5jOjIyOAogbXNnaWQgImRlZXBlbiBoaXN0b3J5IG9mIHNoYWxsb3cgY2xvbmUiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE1NQorIzogYnVpbHRpbi9mZXRjaC5jOjE3MAogbXNnaWQgImRlZXBlbiBoaXN0b3J5IG9mIHNoYWxsb3cgcmVwb3NpdG9yeSBiYXNlZCBvbiB0aW1lIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNjEgYnVpbHRpbi9wdWxsLmM6MjMwCisjOiBidWlsdGluL2ZldGNoLmM6MTc2IGJ1aWx0aW4vcHVsbC5jOjIzMQogbXNnaWQgImNvbnZlcnQgdG8gYSBjb21wbGV0ZSByZXBvc2l0b3J5IgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNjQKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNzkKIG1zZ2lkICJwcmVwZW5kIHRoaXMgdG8gc3VibW9kdWxlIHBhdGggb3V0cHV0IgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNjcKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxODIKIG1zZ2lkICIiCiAiZGVmYXVsdCBmb3IgcmVjdXJzaXZlIGZldGNoaW5nIG9mIHN1Ym1vZHVsZXMgKGxvd2VyIHByaW9yaXR5IHRoYW4gY29uZmlnICIKICJmaWxlcykiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE3MSBidWlsdGluL3B1bGwuYzoyMzMKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxODYgYnVpbHRpbi9wdWxsLmM6MjM0CiBtc2dpZCAiYWNjZXB0IHJlZnMgdGhhdCB1cGRhdGUgLmdpdC9zaGFsbG93IgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNzIgYnVpbHRpbi9wdWxsLmM6MjM1CisjOiBidWlsdGluL2ZldGNoLmM6MTg3IGJ1aWx0aW4vcHVsbC5jOjIzNgogbXNnaWQgInJlZm1hcCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTczIGJ1aWx0aW4vcHVsbC5jOjIzNgorIzogYnVpbHRpbi9mZXRjaC5jOjE4OCBidWlsdGluL3B1bGwuYzoyMzcKIG1zZ2lkICJzcGVjaWZ5IGZldGNoIHJlZm1hcCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTgwCisjOiBidWlsdGluL2ZldGNoLmM6MTk1CiBtc2dpZCAicmVwb3J0IHRoYXQgd2UgaGF2ZSBvbmx5IG9iamVjdHMgcmVhY2hhYmxlIGZyb20gdGhpcyBvYmplY3QiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE4MworIzogYnVpbHRpbi9mZXRjaC5jOjE5OAogbXNnaWQgInJ1biAnZ2MgLS1hdXRvJyBhZnRlciBmZXRjaGluZyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTg1IGJ1aWx0aW4vcHVsbC5jOjI0NQorIzogYnVpbHRpbi9mZXRjaC5jOjIwMCBidWlsdGluL3B1bGwuYzoyNDYKIG1zZ2lkICJjaGVjayBmb3IgZm9yY2VkLXVwZGF0ZXMgb24gYWxsIHVwZGF0ZWQgYnJhbmNoZXMiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjQ5MQorIzogYnVpbHRpbi9mZXRjaC5jOjUxMAogbXNnaWQgIkNvdWxkbid0IGZpbmQgcmVtb3RlIHJlZiBIRUFEIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzo2MzAKKyM6IGJ1aWx0aW4vZmV0Y2guYzo2NTAKICMsIGMtZm9ybWF0CiBtc2dpZCAiY29uZmlndXJhdGlvbiBmZXRjaC5vdXRwdXQgY29udGFpbnMgaW52YWxpZCB2YWx1ZSAlcyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2ZldGNoLmM6NzI4CisjOiBidWlsdGluL2ZldGNoLmM6NzQ4CiAjLCBjLWZvcm1hdAogbXNnaWQgIm9iamVjdCAlcyBub3QgZm91bmQiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjczMgorIzogYnVpbHRpbi9mZXRjaC5jOjc1MgogbXNnaWQgIlt1cCB0byBkYXRlXSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2ZldGNoLmM6NzQ1IGJ1aWx0aW4vZmV0Y2guYzo3NjEgYnVpbHRpbi9mZXRjaC5jOjgzMworIzogYnVpbHRpbi9mZXRjaC5jOjc2NSBidWlsdGluL2ZldGNoLmM6NzgxIGJ1aWx0aW4vZmV0Y2guYzo4NTMKIG1zZ2lkICJbcmVqZWN0ZWRdIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzo3NDYKKyM6IGJ1aWx0aW4vZmV0Y2guYzo3NjYKIG1zZ2lkICJjYW4ndCBmZXRjaCBpbiBjdXJyZW50IGJyYW5jaCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2ZldGNoLmM6NzU2CisjOiBidWlsdGluL2ZldGNoLmM6Nzc2CiBtc2dpZCAiW3RhZyB1cGRhdGVdIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzo3NTcgYnVpbHRpbi9mZXRjaC5jOjc5NCBidWlsdGluL2ZldGNoLmM6ODE2Ci0jOiBidWlsdGluL2ZldGNoLmM6ODI4CisjOiBidWlsdGluL2ZldGNoLmM6Nzc3IGJ1aWx0aW4vZmV0Y2guYzo4MTQgYnVpbHRpbi9mZXRjaC5jOjgzNgorIzogYnVpbHRpbi9mZXRjaC5jOjg0OAogbXNnaWQgInVuYWJsZSB0byB1cGRhdGUgbG9jYWwgcmVmIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzo3NjEKKyM6IGJ1aWx0aW4vZmV0Y2guYzo3ODEKIG1zZ2lkICJ3b3VsZCBjbG9iYmVyIGV4aXN0aW5nIHRhZyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2ZldGNoLmM6NzgzCisjOiBidWlsdGluL2ZldGNoLmM6ODAzCiBtc2dpZCAiW25ldyB0YWddIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzo3ODYKKyM6IGJ1aWx0aW4vZmV0Y2guYzo4MDYKIG1zZ2lkICJbbmV3IGJyYW5jaF0iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjc4OQorIzogYnVpbHRpbi9mZXRjaC5jOjgwOQogbXNnaWQgIltuZXcgcmVmXSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2ZldGNoLmM6ODI4CisjOiBidWlsdGluL2ZldGNoLmM6ODQ4CiBtc2dpZCAiZm9yY2VkIHVwZGF0ZSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2ZldGNoLmM6ODMzCisjOiBidWlsdGluL2ZldGNoLmM6ODUzCiBtc2dpZCAibm9uLWZhc3QtZm9yd2FyZCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2ZldGNoLmM6ODU0CisjOiBidWlsdGluL2ZldGNoLmM6ODc0CiBtc2dpZCAiIgogIkZldGNoIG5vcm1hbGx5IGluZGljYXRlcyB3aGljaCBicmFuY2hlcyBoYWQgYSBmb3JjZWQgdXBkYXRlLFxuIgogImJ1dCB0aGF0IGNoZWNrIGhhcyBiZWVuIGRpc2FibGVkLiBUbyByZS1lbmFibGUsIHVzZSAnLS1zaG93LWZvcmNlZC11cGRhdGVzJ1xuIgogImZsYWcgb3IgcnVuICdnaXQgY29uZmlnIGZldGNoLnNob3dGb3JjZWRVcGRhdGVzIHRydWUnLiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2ZldGNoLmM6ODU4CisjOiBidWlsdGluL2ZldGNoLmM6ODc4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJJdCB0b29rICUuMmYgc2Vjb25kcyB0byBjaGVjayBmb3JjZWQgdXBkYXRlcy4gWW91IGNhbiB1c2VcbiIKQEAgLTExOTk5LDEyMSArMTIwNTYsMTQyIEBACiAiIHRvIGF2b2lkIHRoaXMgY2hlY2suXG4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjg4OAorIzogYnVpbHRpbi9mZXRjaC5jOjkwOAogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyBkaWQgbm90IHNlbmQgYWxsIG5lY2Vzc2FyeSBvYmplY3RzXG4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjkwOQorIzogYnVpbHRpbi9mZXRjaC5jOjkyOQogIywgYy1mb3JtYXQKIG1zZ2lkICJyZWplY3QgJXMgYmVjYXVzZSBzaGFsbG93IHJvb3RzIGFyZSBub3QgYWxsb3dlZCB0byBiZSB1cGRhdGVkIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxMDAwIGJ1aWx0aW4vZmV0Y2guYzoxMTMxCisjOiBidWlsdGluL2ZldGNoLmM6MTAyMCBidWlsdGluL2ZldGNoLmM6MTE1NwogIywgYy1mb3JtYXQKIG1zZ2lkICJGcm9tICUuKnNcbiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTAxMQorIzogYnVpbHRpbi9mZXRjaC5jOjEwMzEKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogInNvbWUgbG9jYWwgcmVmcyBjb3VsZCBub3QgYmUgdXBkYXRlZDsgdHJ5IHJ1bm5pbmdcbiIKICIgJ2dpdCByZW1vdGUgcHJ1bmUgJXMnIHRvIHJlbW92ZSBhbnkgb2xkLCBjb25mbGljdGluZyBicmFuY2hlcyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTEwMQorIzogYnVpbHRpbi9mZXRjaC5jOjExMjcKICMsIGMtZm9ybWF0CiBtc2dpZCAiICAgKCVzIHdpbGwgYmVjb21lIGRhbmdsaW5nKSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTEwMgorIzogYnVpbHRpbi9mZXRjaC5jOjExMjgKICMsIGMtZm9ybWF0CiBtc2dpZCAiICAgKCVzIGhhcyBiZWNvbWUgZGFuZ2xpbmcpIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxMTM0CisjOiBidWlsdGluL2ZldGNoLmM6MTE2MAogbXNnaWQgIltkZWxldGVkXSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTEzNSBidWlsdGluL3JlbW90ZS5jOjEwMzYKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxMTYxIGJ1aWx0aW4vcmVtb3RlLmM6MTAzNgogbXNnaWQgIihub25lKSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTE1OAorIzogYnVpbHRpbi9mZXRjaC5jOjExODQKICMsIGMtZm9ybWF0CiBtc2dpZCAiUmVmdXNpbmcgdG8gZmV0Y2ggaW50byBjdXJyZW50IGJyYW5jaCAlcyBvZiBub24tYmFyZSByZXBvc2l0b3J5IgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxMTc3CisjOiBidWlsdGluL2ZldGNoLmM6MTIwMwogIywgYy1mb3JtYXQKIG1zZ2lkICJPcHRpb24gXCIlc1wiIHZhbHVlIFwiJXNcIiBpcyBub3QgdmFsaWQgZm9yICVzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxMTgwCisjOiBidWlsdGluL2ZldGNoLmM6MTIwNgogIywgYy1mb3JtYXQKIG1zZ2lkICJPcHRpb24gXCIlc1wiIGlzIGlnbm9yZWQgZm9yICVzXG4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE0ODQKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNDE0Cittc2dpZCAibXVsdGlwbGUgYnJhbmNoIGRldGVjdGVkLCBpbmNvbXBhdGlibGUgd2l0aCAtLXNldC11cHN0cmVhbSIKK21zZ3N0ciAiIgorCisjOiBidWlsdGluL2ZldGNoLmM6MTQyOQorbXNnaWQgIm5vdCBzZXR0aW5nIHVwc3RyZWFtIGZvciBhIHJlbW90ZSByZW1vdGUtdHJhY2tpbmcgYnJhbmNoIgorbXNnc3RyICIiCisKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNDMxCittc2dpZCAibm90IHNldHRpbmcgdXBzdHJlYW0gZm9yIGEgcmVtb3RlIHRhZyIKK21zZ3N0ciAiIgorCisjOiBidWlsdGluL2ZldGNoLmM6MTQzMworbXNnaWQgInVua25vd24gYnJhbmNoIHR5cGUiCittc2dzdHIgIiIKKworIzogYnVpbHRpbi9mZXRjaC5jOjE0MzUKK21zZ2lkICIiCisibm8gc291cmNlIGJyYW5jaCBmb3VuZC5cbiIKKyJ5b3UgbmVlZCB0byBzcGVjaWZ5IGV4YWN0bHkgb25lIGJyYW5jaCB3aXRoIHRoZSAtLXNldC11cHN0cmVhbSBvcHRpb24uIgorbXNnc3RyICIiCisKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNTYxIGJ1aWx0aW4vZmV0Y2guYzoxNjIzCiAjLCBjLWZvcm1hdAogbXNnaWQgIkZldGNoaW5nICVzXG4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE0ODYgYnVpbHRpbi9yZW1vdGUuYzoxMDAKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNTcxIGJ1aWx0aW4vZmV0Y2guYzoxNjI1IGJ1aWx0aW4vcmVtb3RlLmM6MTAwCiAjLCBjLWZvcm1hdAogbXNnaWQgIkNvdWxkIG5vdCBmZXRjaCAlcyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTUzMgotbXNnaWQgIiIKLSItLWZpbHRlciBjYW4gb25seSBiZSB1c2VkIHdpdGggdGhlIHJlbW90ZSBjb25maWd1cmVkIGluIGV4dGVuc2lvbnMuIgotInBhcnRpYWxDbG9uZSIKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNTgzCisjLCBjLWZvcm1hdAorbXNnaWQgImNvdWxkIG5vdCBmZXRjaCAnJXMnIChleGl0IGNvZGU6ICVkKVxuIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNTU2CisjOiBidWlsdGluL2ZldGNoLmM6MTY4NQogbXNnaWQgIiIKICJObyByZW1vdGUgcmVwb3NpdG9yeSBzcGVjaWZpZWQuICBQbGVhc2UsIHNwZWNpZnkgZWl0aGVyIGEgVVJMIG9yIGFcbiIKICJyZW1vdGUgbmFtZSBmcm9tIHdoaWNoIG5ldyByZXZpc2lvbnMgc2hvdWxkIGJlIGZldGNoZWQuIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNTkzCisjOiBidWlsdGluL2ZldGNoLmM6MTcyMgogbXNnaWQgIllvdSBuZWVkIHRvIHNwZWNpZnkgYSB0YWcgbmFtZS4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE2NDQKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNzc0CiBtc2dpZCAiTmVnYXRpdmUgZGVwdGggaW4gLS1kZWVwZW4gaXMgbm90IHN1cHBvcnRlZCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTY0NgorIzogYnVpbHRpbi9mZXRjaC5jOjE3NzYKIG1zZ2lkICItLWRlZXBlbiBhbmQgLS1kZXB0aCBhcmUgbXV0dWFsbHkgZXhjbHVzaXZlIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNjUxCisjOiBidWlsdGluL2ZldGNoLmM6MTc4MQogbXNnaWQgIi0tZGVwdGggYW5kIC0tdW5zaGFsbG93IGNhbm5vdCBiZSB1c2VkIHRvZ2V0aGVyIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNjUzCisjOiBidWlsdGluL2ZldGNoLmM6MTc4MwogbXNnaWQgIi0tdW5zaGFsbG93IG9uIGEgY29tcGxldGUgcmVwb3NpdG9yeSBkb2VzIG5vdCBtYWtlIHNlbnNlIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNjY5CisjOiBidWlsdGluL2ZldGNoLmM6MTc5OQogbXNnaWQgImZldGNoIC0tYWxsIGRvZXMgbm90IHRha2UgYSByZXBvc2l0b3J5IGFyZ3VtZW50IgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNjcxCisjOiBidWlsdGluL2ZldGNoLmM6MTgwMQogbXNnaWQgImZldGNoIC0tYWxsIGRvZXMgbm90IG1ha2Ugc2Vuc2Ugd2l0aCByZWZzcGVjcyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTY4MAorIzogYnVpbHRpbi9mZXRjaC5jOjE4MTAKICMsIGMtZm9ybWF0CiBtc2dpZCAiTm8gc3VjaCByZW1vdGUgb3IgcmVtb3RlIGdyb3VwOiAlcyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTY4NworIzogYnVpbHRpbi9mZXRjaC5jOjE4MTcKIG1zZ2lkICJGZXRjaGluZyBhIGdyb3VwIGFuZCBzcGVjaWZ5aW5nIHJlZnNwZWNzIGRvZXMgbm90IG1ha2Ugc2Vuc2UiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE3MDMKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxODM1CiBtc2dpZCAiIgogIi0tZmlsdGVyIGNhbiBvbmx5IGJlIHVzZWQgd2l0aCB0aGUgcmVtb3RlIGNvbmZpZ3VyZWQgaW4gZXh0ZW5zaW9ucy4iCiAicGFydGlhbGNsb25lIgpAQCAtMTI0NDUsNyArMTI1MjMsNyBAQAogbXNnaWQgImludmFsaWQgcGFyYW1ldGVyOiBleHBlY3RlZCBzaGExLCBnb3QgJyVzJyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2djLmM6MzQKKyM6IGJ1aWx0aW4vZ2MuYzozNQogbXNnaWQgImdpdCBnYyBbPG9wdGlvbnM+XSIKIG1zZ3N0ciAiIgogCkBAIC0xMjQ1OSwxNyArMTI1MzcsMTcgQEAKIG1zZ2lkICJmYWlsZWQgdG8gcGFyc2UgJyVzJyB2YWx1ZSAnJXMnIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZ2MuYzo0NzYgYnVpbHRpbi9pbml0LWRiLmM6NTUKKyM6IGJ1aWx0aW4vZ2MuYzo0NzUgYnVpbHRpbi9pbml0LWRiLmM6NTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IHN0YXQgJyVzJyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2djLmM6NDg1IGJ1aWx0aW4vbm90ZXMuYzoyNDAgYnVpbHRpbi90YWcuYzo1MjkKKyM6IGJ1aWx0aW4vZ2MuYzo0ODQgYnVpbHRpbi9ub3Rlcy5jOjI0MCBidWlsdGluL3RhZy5jOjUyOQogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgcmVhZCAnJXMnIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZ2MuYzo0OTIKKyM6IGJ1aWx0aW4vZ2MuYzo0OTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlRoZSBsYXN0IGdjIHJ1biByZXBvcnRlZCB0aGUgZm9sbG93aW5nLiBQbGVhc2UgY29ycmVjdCB0aGUgcm9vdCBjYXVzZVxuIgpAQCAtMTI0NzksNTggKzEyNTU3LDU4IEBACiAiJXMiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9nYy5jOjU0MAorIzogYnVpbHRpbi9nYy5jOjUzOQogbXNnaWQgInBydW5lIHVucmVmZXJlbmNlZCBvYmplY3RzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZ2MuYzo1NDIKKyM6IGJ1aWx0aW4vZ2MuYzo1NDEKIG1zZ2lkICJiZSBtb3JlIHRob3JvdWdoIChpbmNyZWFzZWQgcnVudGltZSkiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9nYy5jOjU0MworIzogYnVpbHRpbi9nYy5jOjU0MgogbXNnaWQgImVuYWJsZSBhdXRvLWdjIG1vZGUiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9nYy5jOjU0NgorIzogYnVpbHRpbi9nYy5jOjU0NQogbXNnaWQgImZvcmNlIHJ1bm5pbmcgZ2MgZXZlbiBpZiB0aGVyZSBtYXkgYmUgYW5vdGhlciBnYyBydW5uaW5nIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZ2MuYzo1NDkKKyM6IGJ1aWx0aW4vZ2MuYzo1NDgKIG1zZ2lkICJyZXBhY2sgYWxsIG90aGVyIHBhY2tzIGV4Y2VwdCB0aGUgbGFyZ2VzdCBwYWNrIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZ2MuYzo1NjYKKyM6IGJ1aWx0aW4vZ2MuYzo1NjUKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIHBhcnNlIGdjLmxvZ2V4cGlyeSB2YWx1ZSAlcyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2djLmM6NTc3CisjOiBidWlsdGluL2djLmM6NTc2CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBwYXJzZSBwcnVuZSBleHBpcnkgdmFsdWUgJXMiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9nYy5jOjU5NworIzogYnVpbHRpbi9nYy5jOjU5NgogIywgYy1mb3JtYXQKIG1zZ2lkICJBdXRvIHBhY2tpbmcgdGhlIHJlcG9zaXRvcnkgaW4gYmFja2dyb3VuZCBmb3Igb3B0aW11bSBwZXJmb3JtYW5jZS5cbiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2djLmM6NTk5CisjOiBidWlsdGluL2djLmM6NTk4CiAjLCBjLWZvcm1hdAogbXNnaWQgIkF1dG8gcGFja2luZyB0aGUgcmVwb3NpdG9yeSBmb3Igb3B0aW11bSBwZXJmb3JtYW5jZS5cbiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2djLmM6NjAwCisjOiBidWlsdGluL2djLmM6NTk5CiAjLCBjLWZvcm1hdAogbXNnaWQgIlNlZSBcImdpdCBoZWxwIGdjXCIgZm9yIG1hbnVhbCBob3VzZWtlZXBpbmcuXG4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9nYy5jOjY0MAorIzogYnVpbHRpbi9nYy5jOjYzOQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiZ2MgaXMgYWxyZWFkeSBydW5uaW5nIG9uIG1hY2hpbmUgJyVzJyBwaWQgJTxQUkl1TUFYPiAodXNlIC0tZm9yY2UgaWYgbm90KSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2djLmM6Njk1CisjOiBidWlsdGluL2djLmM6Njk0CiBtc2dpZCAiIgogIlRoZXJlIGFyZSB0b28gbWFueSB1bnJlYWNoYWJsZSBsb29zZSBvYmplY3RzOyBydW4gJ2dpdCBwcnVuZScgdG8gcmVtb3ZlIHRoZW0uIgogbXNnc3RyICIiCkBAIC0xMjU1NCwyNTcgKzEyNjMyLDI1NyBAQAogIy4gZ3JlcC50aHJlYWRzCiAjLgogIzogYnVpbHRpbi9ncmVwLmM6Mjg3IGJ1aWx0aW4vaW5kZXgtcGFjay5jOjE1MzQgYnVpbHRpbi9pbmRleC1wYWNrLmM6MTcyNwotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNzI4CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI3MDgKICMsIGMtZm9ybWF0CiBtc2dpZCAibm8gdGhyZWFkcyBzdXBwb3J0LCBpZ25vcmluZyAlcyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2dyZXAuYzo0NjcgYnVpbHRpbi9ncmVwLmM6NTkxIGJ1aWx0aW4vZ3JlcC5jOjYzMworIzogYnVpbHRpbi9ncmVwLmM6NDY3IGJ1aWx0aW4vZ3JlcC5jOjU5MiBidWlsdGluL2dyZXAuYzo2MzUKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHJlYWQgdHJlZSAoJXMpIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjY0OAorIzogYnVpbHRpbi9ncmVwLmM6NjUwCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBncmVwIGZyb20gb2JqZWN0IG9mIHR5cGUgJXMiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9ncmVwLmM6NzE0CisjOiBidWlsdGluL2dyZXAuYzo3MTYKICMsIGMtZm9ybWF0CiBtc2dpZCAic3dpdGNoIGAlYycgZXhwZWN0cyBhIG51bWVyaWNhbCB2YWx1ZSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2dyZXAuYzo4MTMKKyM6IGJ1aWx0aW4vZ3JlcC5jOjgxNQogbXNnaWQgInNlYXJjaCBpbiBpbmRleCBpbnN0ZWFkIG9mIGluIHRoZSB3b3JrIHRyZWUiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODE1CisjOiBidWlsdGluL2dyZXAuYzo4MTcKIG1zZ2lkICJmaW5kIGluIGNvbnRlbnRzIG5vdCBtYW5hZ2VkIGJ5IGdpdCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2dyZXAuYzo4MTcKKyM6IGJ1aWx0aW4vZ3JlcC5jOjgxOQogbXNnaWQgInNlYXJjaCBpbiBib3RoIHRyYWNrZWQgYW5kIHVudHJhY2tlZCBmaWxlcyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2dyZXAuYzo4MTkKKyM6IGJ1aWx0aW4vZ3JlcC5jOjgyMQogbXNnaWQgImlnbm9yZSBmaWxlcyBzcGVjaWZpZWQgdmlhICcuZ2l0aWdub3JlJyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2dyZXAuYzo4MjEKKyM6IGJ1aWx0aW4vZ3JlcC5jOjgyMwogbXNnaWQgInJlY3Vyc2l2ZWx5IHNlYXJjaCBpbiBlYWNoIHN1Ym1vZHVsZSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2dyZXAuYzo4MjQKKyM6IGJ1aWx0aW4vZ3JlcC5jOjgyNgogbXNnaWQgInNob3cgbm9uLW1hdGNoaW5nIGxpbmVzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjgyNgorIzogYnVpbHRpbi9ncmVwLmM6ODI4CiBtc2dpZCAiY2FzZSBpbnNlbnNpdGl2ZSBtYXRjaGluZyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2dyZXAuYzo4MjgKKyM6IGJ1aWx0aW4vZ3JlcC5jOjgzMAogbXNnaWQgIm1hdGNoIHBhdHRlcm5zIG9ubHkgYXQgd29yZCBib3VuZGFyaWVzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjgzMAorIzogYnVpbHRpbi9ncmVwLmM6ODMyCiBtc2dpZCAicHJvY2VzcyBiaW5hcnkgZmlsZXMgYXMgdGV4dCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2dyZXAuYzo4MzIKKyM6IGJ1aWx0aW4vZ3JlcC5jOjgzNAogbXNnaWQgImRvbid0IG1hdGNoIHBhdHRlcm5zIGluIGJpbmFyeSBmaWxlcyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2dyZXAuYzo4MzUKKyM6IGJ1aWx0aW4vZ3JlcC5jOjgzNwogbXNnaWQgInByb2Nlc3MgYmluYXJ5IGZpbGVzIHdpdGggdGV4dGNvbnYgZmlsdGVycyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2dyZXAuYzo4MzcKKyM6IGJ1aWx0aW4vZ3JlcC5jOjgzOQogbXNnaWQgInNlYXJjaCBpbiBzdWJkaXJlY3RvcmllcyAoZGVmYXVsdCkiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODM5CisjOiBidWlsdGluL2dyZXAuYzo4NDEKIG1zZ2lkICJkZXNjZW5kIGF0IG1vc3QgPGRlcHRoPiBsZXZlbHMiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODQzCisjOiBidWlsdGluL2dyZXAuYzo4NDUKIG1zZ2lkICJ1c2UgZXh0ZW5kZWQgUE9TSVggcmVndWxhciBleHByZXNzaW9ucyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2dyZXAuYzo4NDYKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg0OAogbXNnaWQgInVzZSBiYXNpYyBQT1NJWCByZWd1bGFyIGV4cHJlc3Npb25zIChkZWZhdWx0KSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2dyZXAuYzo4NDkKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg1MQogbXNnaWQgImludGVycHJldCBwYXR0ZXJucyBhcyBmaXhlZCBzdHJpbmdzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg1MgorIzogYnVpbHRpbi9ncmVwLmM6ODU0CiBtc2dpZCAidXNlIFBlcmwtY29tcGF0aWJsZSByZWd1bGFyIGV4cHJlc3Npb25zIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg1NQorIzogYnVpbHRpbi9ncmVwLmM6ODU3CiBtc2dpZCAic2hvdyBsaW5lIG51bWJlcnMiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODU2CisjOiBidWlsdGluL2dyZXAuYzo4NTgKIG1zZ2lkICJzaG93IGNvbHVtbiBudW1iZXIgb2YgZmlyc3QgbWF0Y2giCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODU3CisjOiBidWlsdGluL2dyZXAuYzo4NTkKIG1zZ2lkICJkb24ndCBzaG93IGZpbGVuYW1lcyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2dyZXAuYzo4NTgKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg2MAogbXNnaWQgInNob3cgZmlsZW5hbWVzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg2MAorIzogYnVpbHRpbi9ncmVwLmM6ODYyCiBtc2dpZCAic2hvdyBmaWxlbmFtZXMgcmVsYXRpdmUgdG8gdG9wIGRpcmVjdG9yeSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2dyZXAuYzo4NjIKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg2NAogbXNnaWQgInNob3cgb25seSBmaWxlbmFtZXMgaW5zdGVhZCBvZiBtYXRjaGluZyBsaW5lcyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2dyZXAuYzo4NjQKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg2NgogbXNnaWQgInN5bm9ueW0gZm9yIC0tZmlsZXMtd2l0aC1tYXRjaGVzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg2NworIzogYnVpbHRpbi9ncmVwLmM6ODY5CiBtc2dpZCAic2hvdyBvbmx5IHRoZSBuYW1lcyBvZiBmaWxlcyB3aXRob3V0IG1hdGNoIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg2OQorIzogYnVpbHRpbi9ncmVwLmM6ODcxCiBtc2dpZCAicHJpbnQgTlVMIGFmdGVyIGZpbGVuYW1lcyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2dyZXAuYzo4NzIKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg3NAogbXNnaWQgInNob3cgb25seSBtYXRjaGluZyBwYXJ0cyBvZiBhIGxpbmUiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODc0CisjOiBidWlsdGluL2dyZXAuYzo4NzYKIG1zZ2lkICJzaG93IHRoZSBudW1iZXIgb2YgbWF0Y2hlcyBpbnN0ZWFkIG9mIG1hdGNoaW5nIGxpbmVzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg3NQorIzogYnVpbHRpbi9ncmVwLmM6ODc3CiBtc2dpZCAiaGlnaGxpZ2h0IG1hdGNoZXMiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODc3CisjOiBidWlsdGluL2dyZXAuYzo4NzkKIG1zZ2lkICJwcmludCBlbXB0eSBsaW5lIGJldHdlZW4gbWF0Y2hlcyBmcm9tIGRpZmZlcmVudCBmaWxlcyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2dyZXAuYzo4NzkKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg4MQogbXNnaWQgInNob3cgZmlsZW5hbWUgb25seSBvbmNlIGFib3ZlIG1hdGNoZXMgZnJvbSBzYW1lIGZpbGUiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODgyCisjOiBidWlsdGluL2dyZXAuYzo4ODQKIG1zZ2lkICJzaG93IDxuPiBjb250ZXh0IGxpbmVzIGJlZm9yZSBhbmQgYWZ0ZXIgbWF0Y2hlcyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2dyZXAuYzo4ODUKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg4NwogbXNnaWQgInNob3cgPG4+IGNvbnRleHQgbGluZXMgYmVmb3JlIG1hdGNoZXMiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODg3CisjOiBidWlsdGluL2dyZXAuYzo4ODkKIG1zZ2lkICJzaG93IDxuPiBjb250ZXh0IGxpbmVzIGFmdGVyIG1hdGNoZXMiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODg5CisjOiBidWlsdGluL2dyZXAuYzo4OTEKIG1zZ2lkICJ1c2UgPG4+IHdvcmtlciB0aHJlYWRzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg5MAorIzogYnVpbHRpbi9ncmVwLmM6ODkyCiBtc2dpZCAic2hvcnRjdXQgZm9yIC1DIE5VTSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2dyZXAuYzo4OTMKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg5NQogbXNnaWQgInNob3cgYSBsaW5lIHdpdGggdGhlIGZ1bmN0aW9uIG5hbWUgYmVmb3JlIG1hdGNoZXMiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODk1CisjOiBidWlsdGluL2dyZXAuYzo4OTcKIG1zZ2lkICJzaG93IHRoZSBzdXJyb3VuZGluZyBmdW5jdGlvbiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2dyZXAuYzo4OTgKKyM6IGJ1aWx0aW4vZ3JlcC5jOjkwMAogbXNnaWQgInJlYWQgcGF0dGVybnMgZnJvbSBmaWxlIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjkwMAorIzogYnVpbHRpbi9ncmVwLmM6OTAyCiBtc2dpZCAibWF0Y2ggPHBhdHRlcm4+IgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjkwMgorIzogYnVpbHRpbi9ncmVwLmM6OTA0CiBtc2dpZCAiY29tYmluZSBwYXR0ZXJucyBzcGVjaWZpZWQgd2l0aCAtZSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2dyZXAuYzo5MTQKKyM6IGJ1aWx0aW4vZ3JlcC5jOjkxNgogbXNnaWQgImluZGljYXRlIGhpdCB3aXRoIGV4aXQgc3RhdHVzIHdpdGhvdXQgb3V0cHV0IgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjkxNgorIzogYnVpbHRpbi9ncmVwLmM6OTE4CiBtc2dpZCAic2hvdyBvbmx5IG1hdGNoZXMgZnJvbSBmaWxlcyB0aGF0IG1hdGNoIGFsbCBwYXR0ZXJucyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2dyZXAuYzo5MTgKKyM6IGJ1aWx0aW4vZ3JlcC5jOjkyMAogbXNnaWQgInNob3cgcGFyc2UgdHJlZSBmb3IgZ3JlcCBleHByZXNzaW9uIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjkyMgorIzogYnVpbHRpbi9ncmVwLmM6OTI0CiBtc2dpZCAicGFnZXIiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9ncmVwLmM6OTIyCisjOiBidWlsdGluL2dyZXAuYzo5MjQKIG1zZ2lkICJzaG93IG1hdGNoaW5nIGZpbGVzIGluIHRoZSBwYWdlciIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2dyZXAuYzo5MjYKKyM6IGJ1aWx0aW4vZ3JlcC5jOjkyOAogbXNnaWQgImFsbG93IGNhbGxpbmcgb2YgZ3JlcCgxKSAoaWdub3JlZCBieSB0aGlzIGJ1aWxkKSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2dyZXAuYzo5OTAKKyM6IGJ1aWx0aW4vZ3JlcC5jOjk5MgogbXNnaWQgIm5vIHBhdHRlcm4gZ2l2ZW4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9ncmVwLmM6MTAyNgorIzogYnVpbHRpbi9ncmVwLmM6MTAyOAogbXNnaWQgIi0tbm8taW5kZXggb3IgLS11bnRyYWNrZWQgY2Fubm90IGJlIHVzZWQgd2l0aCByZXZzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjEwMzQKKyM6IGJ1aWx0aW4vZ3JlcC5jOjEwMzYKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHJlc29sdmUgcmV2aXNpb246ICVzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjEwNjUKKyM6IGJ1aWx0aW4vZ3JlcC5jOjEwNjcKIG1zZ2lkICJpbnZhbGlkIG9wdGlvbiBjb21iaW5hdGlvbiwgaWdub3JpbmcgLS10aHJlYWRzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjEwNjggYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozNDE2CisjOiBidWlsdGluL2dyZXAuYzoxMDcwIGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzQwMAogbXNnaWQgIm5vIHRocmVhZHMgc3VwcG9ydCwgaWdub3JpbmcgLS10aHJlYWRzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjEwNzEgYnVpbHRpbi9pbmRleC1wYWNrLmM6MTUzMSBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI3MjUKKyM6IGJ1aWx0aW4vZ3JlcC5jOjEwNzMgYnVpbHRpbi9pbmRleC1wYWNrLmM6MTUzMSBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI3MDUKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBudW1iZXIgb2YgdGhyZWFkcyBzcGVjaWZpZWQgKCVkKSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2dyZXAuYzoxMDk0CisjOiBidWlsdGluL2dyZXAuYzoxMDk2CiBtc2dpZCAiLS1vcGVuLWZpbGVzLWluLXBhZ2VyIG9ubHkgd29ya3Mgb24gdGhlIHdvcmt0cmVlIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjExMTcKKyM6IGJ1aWx0aW4vZ3JlcC5jOjExMTkKIG1zZ2lkICJvcHRpb24gbm90IHN1cHBvcnRlZCB3aXRoIC0tcmVjdXJzZS1zdWJtb2R1bGVzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjExMjMKKyM6IGJ1aWx0aW4vZ3JlcC5jOjExMjUKIG1zZ2lkICItLWNhY2hlZCBvciAtLXVudHJhY2tlZCBjYW5ub3QgYmUgdXNlZCB3aXRoIC0tbm8taW5kZXgiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9ncmVwLmM6MTEyOQorIzogYnVpbHRpbi9ncmVwLmM6MTEzMQogbXNnaWQgIi0tW25vLV1leGNsdWRlLXN0YW5kYXJkIGNhbm5vdCBiZSB1c2VkIGZvciB0cmFja2VkIGNvbnRlbnRzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjExMzcKKyM6IGJ1aWx0aW4vZ3JlcC5jOjExMzkKIG1zZ2lkICJib3RoIC0tY2FjaGVkIGFuZCB0cmVlcyBhcmUgZ2l2ZW4iCiBtc2dzdHIgIiIKIApAQCAtMTMxMTAsNyArMTMxODgsNyBAQAogbXNnaWQgIlJlc29sdmluZyBkZWx0YXMiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9pbmRleC1wYWNrLmM6MTIwNSBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI0OTcKKyM6IGJ1aWx0aW4vaW5kZXgtcGFjay5jOjEyMDUgYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNDgxCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBjcmVhdGUgdGhyZWFkOiAlcyIKIG1zZ3N0ciAiIgpAQCAtMTMxNzUsNyArMTMyNTMsNyBAQAogbXNnaWQgImNhbm5vdCBzdG9yZSBpbmRleCBmaWxlIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vaW5kZXgtcGFjay5jOjE1MjUgYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNzM2CisjOiBidWlsdGluL2luZGV4LXBhY2suYzoxNTI1IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjcxNgogIywgYy1mb3JtYXQKIG1zZ2lkICJiYWQgcGFjay5pbmRleHZlcnNpb249JTxQUkl1MzI+IgogbXNnc3RyICIiCkBAIC0xMzQ1MCwzNDEgKzEzNTI4LDM0MSBAQAogbXNnaWQgImdpdCBzaG93ICVzOiBiYWQgZmlsZSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2xvZy5jOjU0OSBidWlsdGluL2xvZy5jOjY0MworIzogYnVpbHRpbi9sb2cuYzo1NDkgYnVpbHRpbi9sb2cuYzo2NDQKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHJlYWQgb2JqZWN0ICVzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6NjY4CisjOiBidWlsdGluL2xvZy5jOjY2OQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmtub3duIHR5cGU6ICVkIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6NzkxCisjOiBidWlsdGluL2xvZy5jOjc5MgogbXNnaWQgImZvcm1hdC5oZWFkZXJzIHdpdGhvdXQgdmFsdWUiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9sb2cuYzo5MDgKKyM6IGJ1aWx0aW4vbG9nLmM6OTA5CiBtc2dpZCAibmFtZSBvZiBvdXRwdXQgZGlyZWN0b3J5IGlzIHRvbyBsb25nIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6OTI0CisjOiBidWlsdGluL2xvZy5jOjkyNQogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3Qgb3BlbiBwYXRjaCBmaWxlICVzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6OTQxCisjOiBidWlsdGluL2xvZy5jOjk0MgogbXNnaWQgIm5lZWQgZXhhY3RseSBvbmUgcmFuZ2UiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9sb2cuYzo5NTEKKyM6IGJ1aWx0aW4vbG9nLmM6OTUyCiBtc2dpZCAibm90IGEgcmFuZ2UiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9sb2cuYzoxMDc0CisjOiBidWlsdGluL2xvZy5jOjEwNzUKIG1zZ2lkICJjb3ZlciBsZXR0ZXIgbmVlZHMgZW1haWwgZm9ybWF0IgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTA4MAorIzogYnVpbHRpbi9sb2cuYzoxMDgxCiBtc2dpZCAiZmFpbGVkIHRvIGNyZWF0ZSBjb3Zlci1sZXR0ZXIgZmlsZSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2xvZy5jOjExNTkKKyM6IGJ1aWx0aW4vbG9nLmM6MTE2MAogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnNhbmUgaW4tcmVwbHktdG86ICVzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTE4NgorIzogYnVpbHRpbi9sb2cuYzoxMTg3CiBtc2dpZCAiZ2l0IGZvcm1hdC1wYXRjaCBbPG9wdGlvbnM+XSBbPHNpbmNlPiB8IDxyZXZpc2lvbi1yYW5nZT5dIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTI0NAorIzogYnVpbHRpbi9sb2cuYzoxMjQ1CiBtc2dpZCAidHdvIG91dHB1dCBkaXJlY3Rvcmllcz8iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9sb2cuYzoxMzU1IGJ1aWx0aW4vbG9nLmM6MjA5OSBidWlsdGluL2xvZy5jOjIxMDEgYnVpbHRpbi9sb2cuYzoyMTEzCisjOiBidWlsdGluL2xvZy5jOjEzNTYgYnVpbHRpbi9sb2cuYzoyMTE2IGJ1aWx0aW4vbG9nLmM6MjExOCBidWlsdGluL2xvZy5jOjIxMzAKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5rbm93biBjb21taXQgJXMiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9sb2cuYzoxMzY1IGJ1aWx0aW4vcmVwbGFjZS5jOjU4IGJ1aWx0aW4vcmVwbGFjZS5jOjIwNworIzogYnVpbHRpbi9sb2cuYzoxMzY2IGJ1aWx0aW4vcmVwbGFjZS5jOjU4IGJ1aWx0aW4vcmVwbGFjZS5jOjIwNwogIzogYnVpbHRpbi9yZXBsYWNlLmM6MjEwCiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byByZXNvbHZlICclcycgYXMgYSB2YWxpZCByZWYiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9sb2cuYzoxMzcwCisjOiBidWlsdGluL2xvZy5jOjEzNzEKIG1zZ2lkICJjb3VsZCBub3QgZmluZCBleGFjdCBtZXJnZSBiYXNlIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTM3NAorIzogYnVpbHRpbi9sb2cuYzoxMzc1CiBtc2dpZCAiIgogImZhaWxlZCB0byBnZXQgdXBzdHJlYW0sIGlmIHlvdSB3YW50IHRvIHJlY29yZCBiYXNlIGNvbW1pdCBhdXRvbWF0aWNhbGx5LFxuIgogInBsZWFzZSB1c2UgZ2l0IGJyYW5jaCAtLXNldC11cHN0cmVhbS10byB0byB0cmFjayBhIHJlbW90ZSBicmFuY2guXG4iCiAiT3IgeW91IGNvdWxkIHNwZWNpZnkgYmFzZSBjb21taXQgYnkgLS1iYXNlPTxiYXNlLWNvbW1pdC1pZD4gbWFudWFsbHkiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9sb2cuYzoxMzk0CisjOiBidWlsdGluL2xvZy5jOjEzOTUKIG1zZ2lkICJmYWlsZWQgdG8gZmluZCBleGFjdCBtZXJnZSBiYXNlIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTQwNQorIzogYnVpbHRpbi9sb2cuYzoxNDA2CiBtc2dpZCAiYmFzZSBjb21taXQgc2hvdWxkIGJlIHRoZSBhbmNlc3RvciBvZiByZXZpc2lvbiBsaXN0IgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTQwOQorIzogYnVpbHRpbi9sb2cuYzoxNDEwCiBtc2dpZCAiYmFzZSBjb21taXQgc2hvdWxkbid0IGJlIGluIHJldmlzaW9uIGxpc3QiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9sb2cuYzoxNDYyCisjOiBidWlsdGluL2xvZy5jOjE0NjMKIG1zZ2lkICJjYW5ub3QgZ2V0IHBhdGNoIGlkIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTUxNAorIzogYnVpbHRpbi9sb2cuYzoxNTE1CiBtc2dpZCAiZmFpbGVkIHRvIGluZmVyIHJhbmdlLWRpZmYgcmFuZ2VzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTU1OQorIzogYnVpbHRpbi9sb2cuYzoxNTYwCiBtc2dpZCAidXNlIFtQQVRDSCBuL21dIGV2ZW4gd2l0aCBhIHNpbmdsZSBwYXRjaCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2xvZy5jOjE1NjIKKyM6IGJ1aWx0aW4vbG9nLmM6MTU2MwogbXNnaWQgInVzZSBbUEFUQ0hdIGV2ZW4gd2l0aCBtdWx0aXBsZSBwYXRjaGVzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTU2NgorIzogYnVpbHRpbi9sb2cuYzoxNTY3CiBtc2dpZCAicHJpbnQgcGF0Y2hlcyB0byBzdGFuZGFyZCBvdXQiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9sb2cuYzoxNTY4CisjOiBidWlsdGluL2xvZy5jOjE1NjkKIG1zZ2lkICJnZW5lcmF0ZSBhIGNvdmVyIGxldHRlciIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2xvZy5jOjE1NzAKKyM6IGJ1aWx0aW4vbG9nLmM6MTU3MQogbXNnaWQgInVzZSBzaW1wbGUgbnVtYmVyIHNlcXVlbmNlIGZvciBvdXRwdXQgZmlsZSBuYW1lcyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2xvZy5jOjE1NzEKKyM6IGJ1aWx0aW4vbG9nLmM6MTU3MgogbXNnaWQgInNmeCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2xvZy5jOjE1NzIKKyM6IGJ1aWx0aW4vbG9nLmM6MTU3MwogbXNnaWQgInVzZSA8c2Z4PiBpbnN0ZWFkIG9mICcucGF0Y2gnIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTU3NAorIzogYnVpbHRpbi9sb2cuYzoxNTc1CiBtc2dpZCAic3RhcnQgbnVtYmVyaW5nIHBhdGNoZXMgYXQgPG4+IGluc3RlYWQgb2YgMSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2xvZy5jOjE1NzYKKyM6IGJ1aWx0aW4vbG9nLmM6MTU3NwogbXNnaWQgIm1hcmsgdGhlIHNlcmllcyBhcyBOdGggcmUtcm9sbCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2xvZy5jOjE1NzgKKyM6IGJ1aWx0aW4vbG9nLmM6MTU3OQogbXNnaWQgIlVzZSBbUkZDIFBBVENIXSBpbnN0ZWFkIG9mIFtQQVRDSF0iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9sb2cuYzoxNTgxCisjOiBidWlsdGluL2xvZy5jOjE1ODIKIG1zZ2lkICJVc2UgWzxwcmVmaXg+XSBpbnN0ZWFkIG9mIFtQQVRDSF0iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9sb2cuYzoxNTg0CisjOiBidWlsdGluL2xvZy5jOjE1ODUKIG1zZ2lkICJzdG9yZSByZXN1bHRpbmcgZmlsZXMgaW4gPGRpcj4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9sb2cuYzoxNTg3CisjOiBidWlsdGluL2xvZy5jOjE1ODgKIG1zZ2lkICJkb24ndCBzdHJpcC9hZGQgW1BBVENIXSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2xvZy5jOjE1OTAKKyM6IGJ1aWx0aW4vbG9nLmM6MTU5MQogbXNnaWQgImRvbid0IG91dHB1dCBiaW5hcnkgZGlmZnMiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9sb2cuYzoxNTkyCisjOiBidWlsdGluL2xvZy5jOjE1OTMKIG1zZ2lkICJvdXRwdXQgYWxsLXplcm8gaGFzaCBpbiBGcm9tIGhlYWRlciIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2xvZy5jOjE1OTQKKyM6IGJ1aWx0aW4vbG9nLmM6MTU5NQogbXNnaWQgImRvbid0IGluY2x1ZGUgYSBwYXRjaCBtYXRjaGluZyBhIGNvbW1pdCB1cHN0cmVhbSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2xvZy5jOjE1OTYKKyM6IGJ1aWx0aW4vbG9nLmM6MTU5NwogbXNnaWQgInNob3cgcGF0Y2ggZm9ybWF0IGluc3RlYWQgb2YgZGVmYXVsdCAocGF0Y2ggKyBzdGF0KSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2xvZy5jOjE1OTgKKyM6IGJ1aWx0aW4vbG9nLmM6MTU5OQogbXNnaWQgIk1lc3NhZ2luZyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2xvZy5jOjE1OTkKKyM6IGJ1aWx0aW4vbG9nLmM6MTYwMAogbXNnaWQgImhlYWRlciIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2xvZy5jOjE2MDAKKyM6IGJ1aWx0aW4vbG9nLmM6MTYwMQogbXNnaWQgImFkZCBlbWFpbCBoZWFkZXIiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjAxIGJ1aWx0aW4vbG9nLmM6MTYwMworIzogYnVpbHRpbi9sb2cuYzoxNjAyIGJ1aWx0aW4vbG9nLmM6MTYwNAogbXNnaWQgImVtYWlsIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTYwMQorIzogYnVpbHRpbi9sb2cuYzoxNjAyCiBtc2dpZCAiYWRkIFRvOiBoZWFkZXIiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjAzCisjOiBidWlsdGluL2xvZy5jOjE2MDQKIG1zZ2lkICJhZGQgQ2M6IGhlYWRlciIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2xvZy5jOjE2MDUKKyM6IGJ1aWx0aW4vbG9nLmM6MTYwNgogbXNnaWQgImlkZW50IgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTYwNgorIzogYnVpbHRpbi9sb2cuYzoxNjA3CiBtc2dpZCAic2V0IEZyb20gYWRkcmVzcyB0byA8aWRlbnQ+IChvciBjb21taXR0ZXIgaWRlbnQgaWYgYWJzZW50KSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2xvZy5jOjE2MDgKKyM6IGJ1aWx0aW4vbG9nLmM6MTYwOQogbXNnaWQgIm1lc3NhZ2UtaWQiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjA5CisjOiBidWlsdGluL2xvZy5jOjE2MTAKIG1zZ2lkICJtYWtlIGZpcnN0IG1haWwgYSByZXBseSB0byA8bWVzc2FnZS1pZD4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjEwIGJ1aWx0aW4vbG9nLmM6MTYxMworIzogYnVpbHRpbi9sb2cuYzoxNjExIGJ1aWx0aW4vbG9nLmM6MTYxNAogbXNnaWQgImJvdW5kYXJ5IgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTYxMQorIzogYnVpbHRpbi9sb2cuYzoxNjEyCiBtc2dpZCAiYXR0YWNoIHRoZSBwYXRjaCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2xvZy5jOjE2MTQKKyM6IGJ1aWx0aW4vbG9nLmM6MTYxNQogbXNnaWQgImlubGluZSB0aGUgcGF0Y2giCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjE4CisjOiBidWlsdGluL2xvZy5jOjE2MTkKIG1zZ2lkICJlbmFibGUgbWVzc2FnZSB0aHJlYWRpbmcsIHN0eWxlczogc2hhbGxvdywgZGVlcCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2xvZy5jOjE2MjAKKyM6IGJ1aWx0aW4vbG9nLmM6MTYyMQogbXNnaWQgInNpZ25hdHVyZSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2xvZy5jOjE2MjEKKyM6IGJ1aWx0aW4vbG9nLmM6MTYyMgogbXNnaWQgImFkZCBhIHNpZ25hdHVyZSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2xvZy5jOjE2MjIKKyM6IGJ1aWx0aW4vbG9nLmM6MTYyMwogbXNnaWQgImJhc2UtY29tbWl0IgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTYyMworIzogYnVpbHRpbi9sb2cuYzoxNjI0CiBtc2dpZCAiYWRkIHByZXJlcXVpc2l0ZSB0cmVlIGluZm8gdG8gdGhlIHBhdGNoIHNlcmllcyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2xvZy5jOjE2MjUKKyM6IGJ1aWx0aW4vbG9nLmM6MTYyNgogbXNnaWQgImFkZCBhIHNpZ25hdHVyZSBmcm9tIGEgZmlsZSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2xvZy5jOjE2MjYKKyM6IGJ1aWx0aW4vbG9nLmM6MTYyNwogbXNnaWQgImRvbid0IHByaW50IHRoZSBwYXRjaCBmaWxlbmFtZXMiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjI4CisjOiBidWlsdGluL2xvZy5jOjE2MjkKIG1zZ2lkICJzaG93IHByb2dyZXNzIHdoaWxlIGdlbmVyYXRpbmcgcGF0Y2hlcyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2xvZy5jOjE2MzAKKyM6IGJ1aWx0aW4vbG9nLmM6MTYzMQogbXNnaWQgInNob3cgY2hhbmdlcyBhZ2FpbnN0IDxyZXY+IGluIGNvdmVyIGxldHRlciBvciBzaW5nbGUgcGF0Y2giCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjMzCisjOiBidWlsdGluL2xvZy5jOjE2MzQKIG1zZ2lkICJzaG93IGNoYW5nZXMgYWdhaW5zdCA8cmVmc3BlYz4gaW4gY292ZXIgbGV0dGVyIG9yIHNpbmdsZSBwYXRjaCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2xvZy5jOjE2MzUKKyM6IGJ1aWx0aW4vbG9nLmM6MTYzNgogbXNnaWQgInBlcmNlbnRhZ2UgYnkgd2hpY2ggY3JlYXRpb24gaXMgd2VpZ2h0ZWQiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9sb2cuYzoxNzEwCisjOiBidWlsdGluL2xvZy5jOjE3MTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBpZGVudCBsaW5lOiAlcyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2xvZy5jOjE3MjUKKyM6IGJ1aWx0aW4vbG9nLmM6MTcyNgogbXNnaWQgIi1uIGFuZCAtayBhcmUgbXV0dWFsbHkgZXhjbHVzaXZlIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTcyNworIzogYnVpbHRpbi9sb2cuYzoxNzI4CiBtc2dpZCAiLS1zdWJqZWN0LXByZWZpeC8tLXJmYyBhbmQgLWsgYXJlIG11dHVhbGx5IGV4Y2x1c2l2ZSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2xvZy5jOjE3MzUKKyM6IGJ1aWx0aW4vbG9nLmM6MTczNgogbXNnaWQgIi0tbmFtZS1vbmx5IGRvZXMgbm90IG1ha2Ugc2Vuc2UiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9sb2cuYzoxNzM3CisjOiBidWlsdGluL2xvZy5jOjE3MzgKIG1zZ2lkICItLW5hbWUtc3RhdHVzIGRvZXMgbm90IG1ha2Ugc2Vuc2UiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9sb2cuYzoxNzM5CisjOiBidWlsdGluL2xvZy5jOjE3NDAKIG1zZ2lkICItLWNoZWNrIGRvZXMgbm90IG1ha2Ugc2Vuc2UiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9sb2cuYzoxNzcxCisjOiBidWlsdGluL2xvZy5jOjE3NzMKIG1zZ2lkICJzdGFuZGFyZCBvdXRwdXQsIG9yIGRpcmVjdG9yeSwgd2hpY2ggb25lPyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2xvZy5jOjE4NjAKKyM6IGJ1aWx0aW4vbG9nLmM6MTg3NwogbXNnaWQgIi0taW50ZXJkaWZmIHJlcXVpcmVzIC0tY292ZXItbGV0dGVyIG9yIHNpbmdsZSBwYXRjaCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2xvZy5jOjE4NjQKKyM6IGJ1aWx0aW4vbG9nLmM6MTg4MQogbXNnaWQgIkludGVyZGlmZjoiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9sb2cuYzoxODY1CisjOiBidWlsdGluL2xvZy5jOjE4ODIKICMsIGMtZm9ybWF0CiBtc2dpZCAiSW50ZXJkaWZmIGFnYWluc3QgdiVkOiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2xvZy5jOjE4NzEKKyM6IGJ1aWx0aW4vbG9nLmM6MTg4OAogbXNnaWQgIi0tY3JlYXRpb24tZmFjdG9yIHJlcXVpcmVzIC0tcmFuZ2UtZGlmZiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2xvZy5jOjE4NzUKKyM6IGJ1aWx0aW4vbG9nLmM6MTg5MgogbXNnaWQgIi0tcmFuZ2UtZGlmZiByZXF1aXJlcyAtLWNvdmVyLWxldHRlciBvciBzaW5nbGUgcGF0Y2giCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9sb2cuYzoxODgzCisjOiBidWlsdGluL2xvZy5jOjE5MDAKIG1zZ2lkICJSYW5nZS1kaWZmOiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2xvZy5jOjE4ODQKKyM6IGJ1aWx0aW4vbG9nLmM6MTkwMQogIywgYy1mb3JtYXQKIG1zZ2lkICJSYW5nZS1kaWZmIGFnYWluc3QgdiVkOiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2xvZy5jOjE4OTUKKyM6IGJ1aWx0aW4vbG9nLmM6MTkxMgogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gcmVhZCBzaWduYXR1cmUgZmlsZSAnJXMnIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTkzMQorIzogYnVpbHRpbi9sb2cuYzoxOTQ4CiBtc2dpZCAiR2VuZXJhdGluZyBwYXRjaGVzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTk3NQorIzogYnVpbHRpbi9sb2cuYzoxOTkyCiBtc2dpZCAiZmFpbGVkIHRvIGNyZWF0ZSBvdXRwdXQgZmlsZXMiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9sb2cuYzoyMDM0CisjOiBidWlsdGluL2xvZy5jOjIwNTEKIG1zZ2lkICJnaXQgY2hlcnJ5IFstdl0gWzx1cHN0cmVhbT4gWzxoZWFkPiBbPGxpbWl0Pl1dXSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL2xvZy5jOjIwODgKKyM6IGJ1aWx0aW4vbG9nLmM6MjEwNQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiQ291bGQgbm90IGZpbmQgYSB0cmFja2VkIHJlbW90ZSBicmFuY2gsIHBsZWFzZSBzcGVjaWZ5IDx1cHN0cmVhbT4gbWFudWFsbHkuXG4iCkBAIC0xMzkwNSw3ICsxMzk4Myw3IEBACiBtc2dpZCAiZG8gbm90IHByaW50IHJlbW90ZSBVUkwiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9scy1yZW1vdGUuYzo2MCBidWlsdGluL2xzLXJlbW90ZS5jOjYyIGJ1aWx0aW4vcmViYXNlLmM6MTQ2NAorIzogYnVpbHRpbi9scy1yZW1vdGUuYzo2MCBidWlsdGluL2xzLXJlbW90ZS5jOjYyIGJ1aWx0aW4vcmViYXNlLmM6MTQ4OAogbXNnaWQgImV4ZWMiCiBtc2dzdHIgIiIKIApAQCAtMTQwMTQsMzEgKzE0MDkyLDMxIEBACiBtc2dpZCAiQXZhaWxhYmxlIGN1c3RvbSBzdHJhdGVnaWVzIGFyZToiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjI0NCBidWlsdGluL3B1bGwuYzoxNTEKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoyNDQgYnVpbHRpbi9wdWxsLmM6MTUyCiBtc2dpZCAiZG8gbm90IHNob3cgYSBkaWZmc3RhdCBhdCB0aGUgZW5kIG9mIHRoZSBtZXJnZSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL21lcmdlLmM6MjQ3IGJ1aWx0aW4vcHVsbC5jOjE1NAorIzogYnVpbHRpbi9tZXJnZS5jOjI0NyBidWlsdGluL3B1bGwuYzoxNTUKIG1zZ2lkICJzaG93IGEgZGlmZnN0YXQgYXQgdGhlIGVuZCBvZiB0aGUgbWVyZ2UiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjI0OCBidWlsdGluL3B1bGwuYzoxNTcKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoyNDggYnVpbHRpbi9wdWxsLmM6MTU4CiBtc2dpZCAiKHN5bm9ueW0gdG8gLS1zdGF0KSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL21lcmdlLmM6MjUwIGJ1aWx0aW4vcHVsbC5jOjE2MAorIzogYnVpbHRpbi9tZXJnZS5jOjI1MCBidWlsdGluL3B1bGwuYzoxNjEKIG1zZ2lkICJhZGQgKGF0IG1vc3QgPG4+KSBlbnRyaWVzIGZyb20gc2hvcnRsb2cgdG8gbWVyZ2UgY29tbWl0IG1lc3NhZ2UiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjI1MyBidWlsdGluL3B1bGwuYzoxNjYKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoyNTMgYnVpbHRpbi9wdWxsLmM6MTY3CiBtc2dpZCAiY3JlYXRlIGEgc2luZ2xlIGNvbW1pdCBpbnN0ZWFkIG9mIGRvaW5nIGEgbWVyZ2UiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjI1NSBidWlsdGluL3B1bGwuYzoxNjkKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoyNTUgYnVpbHRpbi9wdWxsLmM6MTcwCiBtc2dpZCAicGVyZm9ybSBhIGNvbW1pdCBpZiB0aGUgbWVyZ2Ugc3VjY2VlZHMgKGRlZmF1bHQpIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoyNTcgYnVpbHRpbi9wdWxsLmM6MTcyCisjOiBidWlsdGluL21lcmdlLmM6MjU3IGJ1aWx0aW4vcHVsbC5jOjE3MwogbXNnaWQgImVkaXQgbWVzc2FnZSBiZWZvcmUgY29tbWl0dGluZyIKIG1zZ3N0ciAiIgogCkBAIC0xNDA0NiwyOCArMTQxMjQsMjggQEAKIG1zZ2lkICJhbGxvdyBmYXN0LWZvcndhcmQgKGRlZmF1bHQpIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoyNjEgYnVpbHRpbi9wdWxsLmM6MTc5CisjOiBidWlsdGluL21lcmdlLmM6MjYxIGJ1aWx0aW4vcHVsbC5jOjE4MAogbXNnaWQgImFib3J0IGlmIGZhc3QtZm9yd2FyZCBpcyBub3QgcG9zc2libGUiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjI2NSBidWlsdGluL3B1bGwuYzoxODIKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoyNjUgYnVpbHRpbi9wdWxsLmM6MTgzCiBtc2dpZCAidmVyaWZ5IHRoYXQgdGhlIG5hbWVkIGNvbW1pdCBoYXMgYSB2YWxpZCBHUEcgc2lnbmF0dXJlIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoyNjYgYnVpbHRpbi9ub3Rlcy5jOjc4NyBidWlsdGluL3B1bGwuYzoxODYKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDkyIGJ1aWx0aW4vcmViYXNlLmM6MTQ3NyBidWlsdGluL3JldmVydC5jOjExNAorIzogYnVpbHRpbi9tZXJnZS5jOjI2NiBidWlsdGluL25vdGVzLmM6Nzg3IGJ1aWx0aW4vcHVsbC5jOjE4NworIzogYnVpbHRpbi9yZWJhc2UuYzo0OTMgYnVpbHRpbi9yZWJhc2UuYzoxNTAxIGJ1aWx0aW4vcmV2ZXJ0LmM6MTE0CiBtc2dpZCAic3RyYXRlZ3kiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjI2NyBidWlsdGluL3B1bGwuYzoxODcKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoyNjcgYnVpbHRpbi9wdWxsLmM6MTg4CiBtc2dpZCAibWVyZ2Ugc3RyYXRlZ3kgdG8gdXNlIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoyNjggYnVpbHRpbi9wdWxsLmM6MTkwCisjOiBidWlsdGluL21lcmdlLmM6MjY4IGJ1aWx0aW4vcHVsbC5jOjE5MQogbXNnaWQgIm9wdGlvbj12YWx1ZSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL21lcmdlLmM6MjY5IGJ1aWx0aW4vcHVsbC5jOjE5MQorIzogYnVpbHRpbi9tZXJnZS5jOjI2OSBidWlsdGluL3B1bGwuYzoxOTIKIG1zZ2lkICJvcHRpb24gZm9yIHNlbGVjdGVkIG1lcmdlIHN0cmF0ZWd5IgogbXNnc3RyICIiCiAKQEAgLTE0MDg3LDEyICsxNDE2NSwxMiBAQAogbXNnaWQgImNvbnRpbnVlIHRoZSBjdXJyZW50IGluLXByb2dyZXNzIG1lcmdlIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoyODQgYnVpbHRpbi9wdWxsLmM6MTk4CisjOiBidWlsdGluL21lcmdlLmM6Mjg0IGJ1aWx0aW4vcHVsbC5jOjE5OQogbXNnaWQgImFsbG93IG1lcmdpbmcgdW5yZWxhdGVkIGhpc3RvcmllcyIKIG1zZ3N0ciAiIgogCiAjOiBidWlsdGluL21lcmdlLmM6MjkwCi1tc2dpZCAidmVyaWZ5IGNvbW1pdC1tc2cgaG9vayIKK21zZ2lkICJieXBhc3MgcHJlLW1lcmdlLWNvbW1pdCBhbmQgY29tbWl0LW1zZyBob29rcyIKIG1zZ3N0ciAiIgogCiAjOiBidWlsdGluL21lcmdlLmM6MzA3CkBAIC0xNDEzNiwyMTUgKzE0MjE0LDIxNSBAQAogbXNnaWQgIkJhZCBicmFuY2guJXMubWVyZ2VvcHRpb25zIHN0cmluZzogJXMiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjcwOAorIzogYnVpbHRpbi9tZXJnZS5jOjcwNQogbXNnaWQgIk5vdCBoYW5kbGluZyBhbnl0aGluZyBvdGhlciB0aGFuIHR3byBoZWFkcyBtZXJnZS4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjcyMgorIzogYnVpbHRpbi9tZXJnZS5jOjcxOQogIywgYy1mb3JtYXQKIG1zZ2lkICJVbmtub3duIG9wdGlvbiBmb3IgbWVyZ2UtcmVjdXJzaXZlOiAtWCVzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzo3MzcKKyM6IGJ1aWx0aW4vbWVyZ2UuYzo3MzQKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHdyaXRlICVzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzo3ODkKKyM6IGJ1aWx0aW4vbWVyZ2UuYzo3ODYKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ291bGQgbm90IHJlYWQgZnJvbSAnJXMnIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzo3OTgKKyM6IGJ1aWx0aW4vbWVyZ2UuYzo3OTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiTm90IGNvbW1pdHRpbmcgbWVyZ2U7IHVzZSAnZ2l0IGNvbW1pdCcgdG8gY29tcGxldGUgdGhlIG1lcmdlLlxuIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzo4MDQKKyM6IGJ1aWx0aW4vbWVyZ2UuYzo4MDEKIG1zZ2lkICIiCiAiUGxlYXNlIGVudGVyIGEgY29tbWl0IG1lc3NhZ2UgdG8gZXhwbGFpbiB3aHkgdGhpcyBtZXJnZSBpcyBuZWNlc3NhcnksXG4iCiAiZXNwZWNpYWxseSBpZiBpdCBtZXJnZXMgYW4gdXBkYXRlZCB1cHN0cmVhbSBpbnRvIGEgdG9waWMgYnJhbmNoLlxuIgogIlxuIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzo4MDkKKyM6IGJ1aWx0aW4vbWVyZ2UuYzo4MDYKIG1zZ2lkICJBbiBlbXB0eSBtZXNzYWdlIGFib3J0cyB0aGUgY29tbWl0LlxuIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzo4MTIKKyM6IGJ1aWx0aW4vbWVyZ2UuYzo4MDkKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkxpbmVzIHN0YXJ0aW5nIHdpdGggJyVjJyB3aWxsIGJlIGlnbm9yZWQsIGFuZCBhbiBlbXB0eSBtZXNzYWdlIGFib3J0c1xuIgogInRoZSBjb21taXQuXG4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjg1MworIzogYnVpbHRpbi9tZXJnZS5jOjg2MgogbXNnaWQgIkVtcHR5IGNvbW1pdCBtZXNzYWdlLiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL21lcmdlLmM6ODcyCisjOiBidWlsdGluL21lcmdlLmM6ODc3CiAjLCBjLWZvcm1hdAogbXNnaWQgIldvbmRlcmZ1bC5cbiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL21lcmdlLmM6OTMzCisjOiBidWlsdGluL21lcmdlLmM6OTM4CiAjLCBjLWZvcm1hdAogbXNnaWQgIkF1dG9tYXRpYyBtZXJnZSBmYWlsZWQ7IGZpeCBjb25mbGljdHMgYW5kIHRoZW4gY29tbWl0IHRoZSByZXN1bHQuXG4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjk3MgorIzogYnVpbHRpbi9tZXJnZS5jOjk3NwogbXNnaWQgIk5vIGN1cnJlbnQgYnJhbmNoLiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL21lcmdlLmM6OTc0CisjOiBidWlsdGluL21lcmdlLmM6OTc5CiBtc2dpZCAiTm8gcmVtb3RlIGZvciB0aGUgY3VycmVudCBicmFuY2guIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzo5NzYKKyM6IGJ1aWx0aW4vbWVyZ2UuYzo5ODEKIG1zZ2lkICJObyBkZWZhdWx0IHVwc3RyZWFtIGRlZmluZWQgZm9yIHRoZSBjdXJyZW50IGJyYW5jaC4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjk4MQorIzogYnVpbHRpbi9tZXJnZS5jOjk4NgogIywgYy1mb3JtYXQKIG1zZ2lkICJObyByZW1vdGUtdHJhY2tpbmcgYnJhbmNoIGZvciAlcyBmcm9tICVzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxMDM4CisjOiBidWlsdGluL21lcmdlLmM6MTA0MwogIywgYy1mb3JtYXQKIG1zZ2lkICJCYWQgdmFsdWUgJyVzJyBpbiBlbnZpcm9ubWVudCAnJXMnIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxMTQxCisjOiBidWlsdGluL21lcmdlLmM6MTE0NgogIywgYy1mb3JtYXQKIG1zZ2lkICJub3Qgc29tZXRoaW5nIHdlIGNhbiBtZXJnZSBpbiAlczogJXMiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjExNzUKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxMTgwCiBtc2dpZCAibm90IHNvbWV0aGluZyB3ZSBjYW4gbWVyZ2UiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjEyNzgKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxMjgzCiBtc2dpZCAiLS1hYm9ydCBleHBlY3RzIG5vIGFyZ3VtZW50cyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTI4MgorIzogYnVpbHRpbi9tZXJnZS5jOjEyODcKIG1zZ2lkICJUaGVyZSBpcyBubyBtZXJnZSB0byBhYm9ydCAoTUVSR0VfSEVBRCBtaXNzaW5nKS4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjEyOTEKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxMjk2CiBtc2dpZCAiLS1xdWl0IGV4cGVjdHMgbm8gYXJndW1lbnRzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzA0CisjOiBidWlsdGluL21lcmdlLmM6MTMwOQogbXNnaWQgIi0tY29udGludWUgZXhwZWN0cyBubyBhcmd1bWVudHMiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjEzMDgKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzEzCiBtc2dpZCAiVGhlcmUgaXMgbm8gbWVyZ2UgaW4gcHJvZ3Jlc3MgKE1FUkdFX0hFQUQgbWlzc2luZykuIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzI0CisjOiBidWlsdGluL21lcmdlLmM6MTMyOQogbXNnaWQgIiIKICJZb3UgaGF2ZSBub3QgY29uY2x1ZGVkIHlvdXIgbWVyZ2UgKE1FUkdFX0hFQUQgZXhpc3RzKS5cbiIKICJQbGVhc2UsIGNvbW1pdCB5b3VyIGNoYW5nZXMgYmVmb3JlIHlvdSBtZXJnZS4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjEzMzEKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzM2CiBtc2dpZCAiIgogIllvdSBoYXZlIG5vdCBjb25jbHVkZWQgeW91ciBjaGVycnktcGljayAoQ0hFUlJZX1BJQ0tfSEVBRCBleGlzdHMpLlxuIgogIlBsZWFzZSwgY29tbWl0IHlvdXIgY2hhbmdlcyBiZWZvcmUgeW91IG1lcmdlLiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTMzNAorIzogYnVpbHRpbi9tZXJnZS5jOjEzMzkKIG1zZ2lkICJZb3UgaGF2ZSBub3QgY29uY2x1ZGVkIHlvdXIgY2hlcnJ5LXBpY2sgKENIRVJSWV9QSUNLX0hFQUQgZXhpc3RzKS4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjEzNDgKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzUzCiBtc2dpZCAiWW91IGNhbm5vdCBjb21iaW5lIC0tc3F1YXNoIHdpdGggLS1uby1mZi4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjEzNTAKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzU1CiBtc2dpZCAiWW91IGNhbm5vdCBjb21iaW5lIC0tc3F1YXNoIHdpdGggLS1jb21taXQuIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzY2CisjOiBidWlsdGluL21lcmdlLmM6MTM3MQogbXNnaWQgIk5vIGNvbW1pdCBzcGVjaWZpZWQgYW5kIG1lcmdlLmRlZmF1bHRUb1Vwc3RyZWFtIG5vdCBzZXQuIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzgzCisjOiBidWlsdGluL21lcmdlLmM6MTM4OAogbXNnaWQgIlNxdWFzaCBjb21taXQgaW50byBlbXB0eSBoZWFkIG5vdCBzdXBwb3J0ZWQgeWV0IgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzg1CisjOiBidWlsdGluL21lcmdlLmM6MTM5MAogbXNnaWQgIk5vbi1mYXN0LWZvcndhcmQgY29tbWl0IGRvZXMgbm90IG1ha2Ugc2Vuc2UgaW50byBhbiBlbXB0eSBoZWFkIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzkwCisjOiBidWlsdGluL21lcmdlLmM6MTM5NQogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyAtIG5vdCBzb21ldGhpbmcgd2UgY2FuIG1lcmdlIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzkyCisjOiBidWlsdGluL21lcmdlLmM6MTM5NwogbXNnaWQgIkNhbiBtZXJnZSBvbmx5IGV4YWN0bHkgb25lIGNvbW1pdCBpbnRvIGVtcHR5IGhlYWQiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjE0NzEKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxNDc2CiBtc2dpZCAicmVmdXNpbmcgdG8gbWVyZ2UgdW5yZWxhdGVkIGhpc3RvcmllcyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTQ4MAorIzogYnVpbHRpbi9tZXJnZS5jOjE0ODUKIG1zZ2lkICJBbHJlYWR5IHVwIHRvIGRhdGUuIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxNDkwCisjOiBidWlsdGluL21lcmdlLmM6MTQ5NQogIywgYy1mb3JtYXQKIG1zZ2lkICJVcGRhdGluZyAlcy4uJXNcbiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTUzMgorIzogYnVpbHRpbi9tZXJnZS5jOjE1MzcKICMsIGMtZm9ybWF0CiBtc2dpZCAiVHJ5aW5nIHJlYWxseSB0cml2aWFsIGluLWluZGV4IG1lcmdlLi4uXG4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjE1MzkKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxNTQ0CiAjLCBjLWZvcm1hdAogbXNnaWQgIk5vcGUuXG4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjE1NjQKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxNTY5CiBtc2dpZCAiQWxyZWFkeSB1cCB0byBkYXRlLiBZZWVhaCEiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjE1NzAKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxNTc1CiBtc2dpZCAiTm90IHBvc3NpYmxlIHRvIGZhc3QtZm9yd2FyZCwgYWJvcnRpbmcuIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxNTkzIGJ1aWx0aW4vbWVyZ2UuYzoxNjU4CisjOiBidWlsdGluL21lcmdlLmM6MTU5OCBidWlsdGluL21lcmdlLmM6MTY2MwogIywgYy1mb3JtYXQKIG1zZ2lkICJSZXdpbmRpbmcgdGhlIHRyZWUgdG8gcHJpc3RpbmUuLi5cbiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTU5NworIzogYnVpbHRpbi9tZXJnZS5jOjE2MDIKICMsIGMtZm9ybWF0CiBtc2dpZCAiVHJ5aW5nIG1lcmdlIHN0cmF0ZWd5ICVzLi4uXG4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjE2NDkKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxNjU0CiAjLCBjLWZvcm1hdAogbXNnaWQgIk5vIG1lcmdlIHN0cmF0ZWd5IGhhbmRsZWQgdGhlIG1lcmdlLlxuIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxNjUxCisjOiBidWlsdGluL21lcmdlLmM6MTY1NgogIywgYy1mb3JtYXQKIG1zZ2lkICJNZXJnZSB3aXRoIHN0cmF0ZWd5ICVzIGZhaWxlZC5cbiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTY2MAorIzogYnVpbHRpbi9tZXJnZS5jOjE2NjUKICMsIGMtZm9ybWF0CiBtc2dpZCAiVXNpbmcgdGhlICVzIHRvIHByZXBhcmUgcmVzb2x2aW5nIGJ5IGhhbmQuXG4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjE2NzIKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxNjc3CiAjLCBjLWZvcm1hdAogbXNnaWQgIkF1dG9tYXRpYyBtZXJnZSB3ZW50IHdlbGw7IHN0b3BwZWQgYmVmb3JlIGNvbW1pdHRpbmcgYXMgcmVxdWVzdGVkXG4iCiBtc2dzdHIgIiIKQEAgLTE0NDI3LDMzICsxNDUwNSwzMyBAQAogbXNnaWQgInNldCBsYWJlbHMgZm9yIGZpbGUxL29yaWctZmlsZS9maWxlMiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL21lcmdlLXJlY3Vyc2l2ZS5jOjQ2CisjOiBidWlsdGluL21lcmdlLXJlY3Vyc2l2ZS5jOjQ3CiAjLCBjLWZvcm1hdAogbXNnaWQgInVua25vd24gb3B0aW9uICVzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UtcmVjdXJzaXZlLmM6NTIKKyM6IGJ1aWx0aW4vbWVyZ2UtcmVjdXJzaXZlLmM6NTMKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHBhcnNlIG9iamVjdCAnJXMnIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UtcmVjdXJzaXZlLmM6NTYKKyM6IGJ1aWx0aW4vbWVyZ2UtcmVjdXJzaXZlLmM6NTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IGhhbmRsZSBtb3JlIHRoYW4gJWQgYmFzZS4gSWdub3JpbmcgJXMuIgogbXNnaWRfcGx1cmFsICJjYW5ub3QgaGFuZGxlIG1vcmUgdGhhbiAlZCBiYXNlcy4gSWdub3JpbmcgJXMuIgogbXNnc3RyWzBdICIiCiBtc2dzdHJbMV0gIiIKIAotIzogYnVpbHRpbi9tZXJnZS1yZWN1cnNpdmUuYzo2NAorIzogYnVpbHRpbi9tZXJnZS1yZWN1cnNpdmUuYzo2NQogbXNnaWQgIm5vdCBoYW5kbGluZyBhbnl0aGluZyBvdGhlciB0aGFuIHR3byBoZWFkcyBtZXJnZS4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9tZXJnZS1yZWN1cnNpdmUuYzo3MCBidWlsdGluL21lcmdlLXJlY3Vyc2l2ZS5jOjcyCisjOiBidWlsdGluL21lcmdlLXJlY3Vyc2l2ZS5jOjc0IGJ1aWx0aW4vbWVyZ2UtcmVjdXJzaXZlLmM6NzYKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHJlc29sdmUgcmVmICclcyciCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9tZXJnZS1yZWN1cnNpdmUuYzo3OAorIzogYnVpbHRpbi9tZXJnZS1yZWN1cnNpdmUuYzo4MgogIywgYy1mb3JtYXQKIG1zZ2lkICJNZXJnaW5nICVzIHdpdGggJXNcbiIKIG1zZ3N0ciAiIgpAQCAtMTQ1OTAsNTIgKzE0NjY4LDUyIEBACiBtc2dpZCAiUmVuYW1pbmcgJXMgdG8gJXNcbiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL212LmM6Mjc3IGJ1aWx0aW4vcmVtb3RlLmM6NzE3IGJ1aWx0aW4vcmVwYWNrLmM6NTEwCisjOiBidWlsdGluL212LmM6Mjc3IGJ1aWx0aW4vcmVtb3RlLmM6NzE3IGJ1aWx0aW4vcmVwYWNrLmM6NTExCiAjLCBjLWZvcm1hdAogbXNnaWQgInJlbmFtaW5nICclcycgZmFpbGVkIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vbmFtZS1yZXYuYzozNTIKKyM6IGJ1aWx0aW4vbmFtZS1yZXYuYzozNTYKIG1zZ2lkICJnaXQgbmFtZS1yZXYgWzxvcHRpb25zPl0gPGNvbW1pdD4uLi4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9uYW1lLXJldi5jOjM1MworIzogYnVpbHRpbi9uYW1lLXJldi5jOjM1NwogbXNnaWQgImdpdCBuYW1lLXJldiBbPG9wdGlvbnM+XSAtLWFsbCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL25hbWUtcmV2LmM6MzU0CisjOiBidWlsdGluL25hbWUtcmV2LmM6MzU4CiBtc2dpZCAiZ2l0IG5hbWUtcmV2IFs8b3B0aW9ucz5dIC0tc3RkaW4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9uYW1lLXJldi5jOjQxMQorIzogYnVpbHRpbi9uYW1lLXJldi5jOjQxNQogbXNnaWQgInByaW50IG9ubHkgbmFtZXMgKG5vIFNIQS0xKSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL25hbWUtcmV2LmM6NDEyCisjOiBidWlsdGluL25hbWUtcmV2LmM6NDE2CiBtc2dpZCAib25seSB1c2UgdGFncyB0byBuYW1lIHRoZSBjb21taXRzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vbmFtZS1yZXYuYzo0MTQKKyM6IGJ1aWx0aW4vbmFtZS1yZXYuYzo0MTgKIG1zZ2lkICJvbmx5IHVzZSByZWZzIG1hdGNoaW5nIDxwYXR0ZXJuPiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL25hbWUtcmV2LmM6NDE2CisjOiBidWlsdGluL25hbWUtcmV2LmM6NDIwCiBtc2dpZCAiaWdub3JlIHJlZnMgbWF0Y2hpbmcgPHBhdHRlcm4+IgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vbmFtZS1yZXYuYzo0MTgKKyM6IGJ1aWx0aW4vbmFtZS1yZXYuYzo0MjIKIG1zZ2lkICJsaXN0IGFsbCBjb21taXRzIHJlYWNoYWJsZSBmcm9tIGFsbCByZWZzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vbmFtZS1yZXYuYzo0MTkKKyM6IGJ1aWx0aW4vbmFtZS1yZXYuYzo0MjMKIG1zZ2lkICJyZWFkIGZyb20gc3RkaW4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9uYW1lLXJldi5jOjQyMAorIzogYnVpbHRpbi9uYW1lLXJldi5jOjQyNAogbXNnaWQgImFsbG93IHRvIHByaW50IGB1bmRlZmluZWRgIG5hbWVzIChkZWZhdWx0KSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL25hbWUtcmV2LmM6NDI2CisjOiBidWlsdGluL25hbWUtcmV2LmM6NDMwCiBtc2dpZCAiZGVyZWZlcmVuY2UgdGFncyBpbiB0aGUgaW5wdXQgKGludGVybmFsIHVzZSkiCiBtc2dzdHIgIiIKIApAQCAtMTUwMTQsNyArMTUwOTIsNyBAQAogbXNnaWQgInJlYWQgb2JqZWN0IG5hbWVzIGZyb20gdGhlIHN0YW5kYXJkIGlucHV0IgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vbm90ZXMuYzo5NTQgYnVpbHRpbi9wcnVuZS5jOjEzMCBidWlsdGluL3dvcmt0cmVlLmM6MTY1CisjOiBidWlsdGluL25vdGVzLmM6OTU0IGJ1aWx0aW4vcHJ1bmUuYzoxMzAgYnVpbHRpbi93b3JrdHJlZS5jOjE2NAogbXNnaWQgImRvIG5vdCByZW1vdmUsIHNob3cgb25seSIKIG1zZ3N0ciAiIgogCkBAIC0xNTAzMCw3ICsxNTEwOCw3IEBACiBtc2dpZCAidXNlIG5vdGVzIGZyb20gPG5vdGVzLXJlZj4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9ub3Rlcy5jOjEwMzQgYnVpbHRpbi9zdGFzaC5jOjE1OTgKKyM6IGJ1aWx0aW4vbm90ZXMuYzoxMDM0IGJ1aWx0aW4vc3Rhc2guYzoxNjA3CiAjLCBjLWZvcm1hdAogbXNnaWQgInVua25vd24gc3ViY29tbWFuZDogJXMiCiBtc2dzdHIgIiIKQEAgLTE1MTAxLDMxNyArMTUxNzksMzE3IEBACiBtc2dpZCAid3JvdGUgJTxQUkl1MzI+IG9iamVjdHMgd2hpbGUgZXhwZWN0aW5nICU8UFJJdTMyPiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjExNjYKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MTE2NAogbXNnaWQgImRpc2FibGluZyBiaXRtYXAgd3JpdGluZywgYXMgc29tZSBvYmplY3RzIGFyZSBub3QgYmVpbmcgcGFja2VkIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MTU5NworIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoxNTkyCiAjLCBjLWZvcm1hdAogbXNnaWQgImRlbHRhIGJhc2Ugb2Zmc2V0IG92ZXJmbG93IGluIHBhY2sgZm9yICVzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MTYwNgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoxNjAxCiAjLCBjLWZvcm1hdAogbXNnaWQgImRlbHRhIGJhc2Ugb2Zmc2V0IG91dCBvZiBib3VuZCBmb3IgJXMiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoxODc1CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjE4NzAKIG1zZ2lkICJDb3VudGluZyBvYmplY3RzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjAwNQorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyMDAwCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBnZXQgc2l6ZSBvZiAlcyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjIwMjAKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjAxNQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gcGFyc2Ugb2JqZWN0IGhlYWRlciBvZiAlcyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjIwOTAgYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyMTA2Ci0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjIxMTYKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjA4NSBidWlsdGluL3BhY2stb2JqZWN0cy5jOjIxMDEKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjExMQogIywgYy1mb3JtYXQKIG1zZ2lkICJvYmplY3QgJXMgY2Fubm90IGJlIHJlYWQiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyMDkzIGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjEyMAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyMDg4IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjExNQogIywgYy1mb3JtYXQKIG1zZ2lkICJvYmplY3QgJXMgaW5jb25zaXN0ZW50IG9iamVjdCBsZW5ndGggKCU8UFJJdU1BWD4gdnMgJTxQUkl1TUFYPikiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyMTMwCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjIxMjUKIG1zZ2lkICJzdWJvcHRpbWFsIHBhY2sgLSBvdXQgb2YgbWVtb3J5IgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjQ1NgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNDQwCiAjLCBjLWZvcm1hdAogbXNnaWQgIkRlbHRhIGNvbXByZXNzaW9uIHVzaW5nIHVwIHRvICVkIHRocmVhZHMiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNTg4CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI1NzIKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHBhY2sgb2JqZWN0cyByZWFjaGFibGUgZnJvbSB0YWcgJXMiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNjc1CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI2NTkKIG1zZ2lkICJDb21wcmVzc2luZyBvYmplY3RzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjY4MQorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNjY1CiBtc2dpZCAiaW5jb25zaXN0ZW5jeSB3aXRoIGRlbHRhIGNvdW50IgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6Mjc2MgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNzQyCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJleHBlY3RlZCBlZGdlIG9iamVjdCBJRCwgZ290IGdhcmJhZ2U6XG4iCiAiICVzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6Mjc2OAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNzQ4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJleHBlY3RlZCBvYmplY3QgSUQsIGdvdCBnYXJiYWdlOlxuIgogIiAlcyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI4NjYKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6Mjg0NgogbXNnaWQgImludmFsaWQgdmFsdWUgZm9yIC0tbWlzc2luZyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI5MjUgYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMDMzCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI5MDUgYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMDEzCiBtc2dpZCAiY2Fubm90IG9wZW4gcGFjayBpbmRleCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI5NTYKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjkzNgogIywgYy1mb3JtYXQKIG1zZ2lkICJsb29zZSBvYmplY3QgYXQgJXMgY291bGQgbm90IGJlIGV4YW1pbmVkIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzA0MQorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMDIxCiBtc2dpZCAidW5hYmxlIHRvIGZvcmNlIGxvb3NlIG9iamVjdCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMxMzMKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzExMwogIywgYy1mb3JtYXQKIG1zZ2lkICJub3QgYSByZXYgJyVzJyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMxMzYKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzExNgogIywgYy1mb3JtYXQKIG1zZ2lkICJiYWQgcmV2aXNpb24gJyVzJyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMxNjEKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzE0MQogbXNnaWQgInVuYWJsZSB0byBhZGQgcmVjZW50IG9iamVjdHMiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjE0CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMxOTQKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5zdXBwb3J0ZWQgaW5kZXggdmVyc2lvbiAlcyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyMTgKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzE5OAogIywgYy1mb3JtYXQKIG1zZ2lkICJiYWQgaW5kZXggdmVyc2lvbiAnJXMnIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI0OAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjI4CiBtc2dpZCAiZG8gbm90IHNob3cgcHJvZ3Jlc3MgbWV0ZXIiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjUwCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyMzAKIG1zZ2lkICJzaG93IHByb2dyZXNzIG1ldGVyIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI1MgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjMyCiBtc2dpZCAic2hvdyBwcm9ncmVzcyBtZXRlciBkdXJpbmcgb2JqZWN0IHdyaXRpbmcgcGhhc2UiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjU1CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyMzUKIG1zZ2lkICJzaW1pbGFyIHRvIC0tYWxsLXByb2dyZXNzIHdoZW4gcHJvZ3Jlc3MgbWV0ZXIgaXMgc2hvd24iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjU2CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyMzYKIG1zZ2lkICI8dmVyc2lvbj5bLDxvZmZzZXQ+XSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNTcKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzIzNwogbXNnaWQgIndyaXRlIHRoZSBwYWNrIGluZGV4IGZpbGUgaW4gdGhlIHNwZWNpZmllZCBpZHggZm9ybWF0IHZlcnNpb24iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjYwCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNDAKIG1zZ2lkICJtYXhpbXVtIHNpemUgb2YgZWFjaCBvdXRwdXQgcGFjayBmaWxlIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI2MgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjQyCiBtc2dpZCAiaWdub3JlIGJvcnJvd2VkIG9iamVjdHMgZnJvbSBhbHRlcm5hdGUgb2JqZWN0IHN0b3JlIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI2NAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjQ0CiBtc2dpZCAiaWdub3JlIHBhY2tlZCBvYmplY3RzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI2NgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjQ2CiBtc2dpZCAibGltaXQgcGFjayB3aW5kb3cgYnkgb2JqZWN0cyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNjgKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI0OAogbXNnaWQgImxpbWl0IHBhY2sgd2luZG93IGJ5IG1lbW9yeSBpbiBhZGRpdGlvbiB0byBvYmplY3QgbGltaXQiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjcwCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNTAKIG1zZ2lkICJtYXhpbXVtIGxlbmd0aCBvZiBkZWx0YSBjaGFpbiBhbGxvd2VkIGluIHRoZSByZXN1bHRpbmcgcGFjayIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNzIKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI1MgogbXNnaWQgInJldXNlIGV4aXN0aW5nIGRlbHRhcyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNzQKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI1NAogbXNnaWQgInJldXNlIGV4aXN0aW5nIG9iamVjdHMiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjc2CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNTYKIG1zZ2lkICJ1c2UgT0ZTX0RFTFRBIG9iamVjdHMiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjc4CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNTgKIG1zZ2lkICJ1c2UgdGhyZWFkcyB3aGVuIHNlYXJjaGluZyBmb3IgYmVzdCBkZWx0YSBtYXRjaGVzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI4MAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjYwCiBtc2dpZCAiZG8gbm90IGNyZWF0ZSBhbiBlbXB0eSBwYWNrIG91dHB1dCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyODIKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI2MgogbXNnaWQgInJlYWQgcmV2aXNpb24gYXJndW1lbnRzIGZyb20gc3RhbmRhcmQgaW5wdXQiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjg0CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNjQKIG1zZ2lkICJsaW1pdCB0aGUgb2JqZWN0cyB0byB0aG9zZSB0aGF0IGFyZSBub3QgeWV0IHBhY2tlZCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyODcKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI2NwogbXNnaWQgImluY2x1ZGUgb2JqZWN0cyByZWFjaGFibGUgZnJvbSBhbnkgcmVmZXJlbmNlIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI5MAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjcwCiBtc2dpZCAiaW5jbHVkZSBvYmplY3RzIHJlZmVycmVkIGJ5IHJlZmxvZyBlbnRyaWVzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI5MworIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjczCiBtc2dpZCAiaW5jbHVkZSBvYmplY3RzIHJlZmVycmVkIHRvIGJ5IHRoZSBpbmRleCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyOTYKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI3NgogbXNnaWQgIm91dHB1dCBwYWNrIHRvIHN0ZG91dCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyOTgKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI3OAogbXNnaWQgImluY2x1ZGUgdGFnIG9iamVjdHMgdGhhdCByZWZlciB0byBvYmplY3RzIHRvIGJlIHBhY2tlZCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMDAKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI4MAogbXNnaWQgImtlZXAgdW5yZWFjaGFibGUgb2JqZWN0cyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMDIKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI4MgogbXNnaWQgInBhY2sgbG9vc2UgdW5yZWFjaGFibGUgb2JqZWN0cyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMDQKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI4NAogbXNnaWQgInVucGFjayB1bnJlYWNoYWJsZSBvYmplY3RzIG5ld2VyIHRoYW4gPHRpbWU+IgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMwNworIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjg3CiBtc2dpZCAidXNlIHRoZSBzcGFyc2UgcmVhY2hhYmlsaXR5IGFsZ29yaXRobSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMDkKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI4OQogbXNnaWQgImNyZWF0ZSB0aGluIHBhY2tzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMxMQorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjkxCiBtc2dpZCAiY3JlYXRlIHBhY2tzIHN1aXRhYmxlIGZvciBzaGFsbG93IGZldGNoZXMiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzEzCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyOTMKIG1zZ2lkICJpZ25vcmUgcGFja3MgdGhhdCBoYXZlIGNvbXBhbmlvbiAua2VlcCBmaWxlIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMxNQorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjk1CiBtc2dpZCAiaWdub3JlIHRoaXMgcGFjayIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMTcKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI5NwogbXNnaWQgInBhY2sgY29tcHJlc3Npb24gbGV2ZWwiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzE5CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyOTkKIG1zZ2lkICJkbyBub3QgaGlkZSBjb21taXRzIGJ5IGdyYWZ0cyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMjEKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMwMQogbXNnaWQgInVzZSBhIGJpdG1hcCBpbmRleCBpZiBhdmFpbGFibGUgdG8gc3BlZWQgdXAgY291bnRpbmcgb2JqZWN0cyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMjMKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMwMwogbXNnaWQgIndyaXRlIGEgYml0bWFwIGluZGV4IHRvZ2V0aGVyIHdpdGggdGhlIHBhY2sgaW5kZXgiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzI3CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMDcKIG1zZ2lkICJ3cml0ZSBhIGJpdG1hcCBpbmRleCBpZiBwb3NzaWJsZSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMzEKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMxMQogbXNnaWQgImhhbmRsaW5nIGZvciBtaXNzaW5nIG9iamVjdHMiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzM0CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMTQKIG1zZ2lkICJkbyBub3QgcGFjayBvYmplY3RzIGluIHByb21pc29yIHBhY2tmaWxlcyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMzYKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMxNgogbXNnaWQgInJlc3BlY3QgaXNsYW5kcyBkdXJpbmcgZGVsdGEgY29tcHJlc3Npb24iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzYxCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzNDUKICMsIGMtZm9ybWF0CiBtc2dpZCAiZGVsdGEgY2hhaW4gZGVwdGggJWQgaXMgdG9vIGRlZXAsIGZvcmNpbmcgJWQiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzY2CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzNTAKICMsIGMtZm9ybWF0CiBtc2dpZCAicGFjay5kZWx0YUNhY2hlTGltaXQgaXMgdG9vIGhpZ2gsIGZvcmNpbmcgJWQiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozNDIwCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjM0MDQKIG1zZ2lkICItLW1heC1wYWNrLXNpemUgY2Fubm90IGJlIHVzZWQgdG8gYnVpbGQgYSBwYWNrIGZvciB0cmFuc2ZlciIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjM0MjIKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzQwNgogbXNnaWQgIm1pbmltdW0gcGFjayBzaXplIGxpbWl0IGlzIDEgTWlCIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzQyNworIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozNDExCiBtc2dpZCAiLS10aGluIGNhbm5vdCBiZSB1c2VkIHRvIGJ1aWxkIGFuIGluZGV4YWJsZSBwYWNrIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzQzMAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozNDE0CiBtc2dpZCAiLS1rZWVwLXVucmVhY2hhYmxlIGFuZCAtLXVucGFjay11bnJlYWNoYWJsZSBhcmUgaW5jb21wYXRpYmxlIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzQzNgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozNDIwCiBtc2dpZCAiY2Fubm90IHVzZSAtLWZpbHRlciB3aXRob3V0IC0tc3Rkb3V0IgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzQ5NworIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozNDgxCiBtc2dpZCAiRW51bWVyYXRpbmcgb2JqZWN0cyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjM1MjcKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzUxMQogIywgYy1mb3JtYXQKIG1zZ2lkICJUb3RhbCAlPFBSSXUzMj4gKGRlbHRhICU8UFJJdTMyPiksIHJldXNlZCAlPFBSSXUzMj4gKGRlbHRhICU8UFJJdTMyPikiCiBtc2dzdHIgIiIKQEAgLTE1NDY1LDYxICsxNTU0Myw2MSBAQAogbXNnaWQgImdpdCBwdWxsIFs8b3B0aW9ucz5dIFs8cmVwb3NpdG9yeT4gWzxyZWZzcGVjPi4uLl1dIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjE0MQorIzogYnVpbHRpbi9wdWxsLmM6MTQyCiBtc2dpZCAiY29udHJvbCBmb3IgcmVjdXJzaXZlIGZldGNoaW5nIG9mIHN1Ym1vZHVsZXMiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9wdWxsLmM6MTQ1CisjOiBidWlsdGluL3B1bGwuYzoxNDYKIG1zZ2lkICJPcHRpb25zIHJlbGF0ZWQgdG8gbWVyZ2luZyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3B1bGwuYzoxNDgKKyM6IGJ1aWx0aW4vcHVsbC5jOjE0OQogbXNnaWQgImluY29ycG9yYXRlIGNoYW5nZXMgYnkgcmViYXNpbmcgcmF0aGVyIHRoYW4gbWVyZ2luZyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3B1bGwuYzoxNzYgYnVpbHRpbi9yZWJhc2UuYzo0NDcgYnVpbHRpbi9yZXZlcnQuYzoxMjYKKyM6IGJ1aWx0aW4vcHVsbC5jOjE3NyBidWlsdGluL3JlYmFzZS5jOjQ0OCBidWlsdGluL3JldmVydC5jOjEyNgogbXNnaWQgImFsbG93IGZhc3QtZm9yd2FyZCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3B1bGwuYzoxODUKKyM6IGJ1aWx0aW4vcHVsbC5jOjE4NgogbXNnaWQgImF1dG9tYXRpY2FsbHkgc3Rhc2gvc3Rhc2ggcG9wIGJlZm9yZSBhbmQgYWZ0ZXIgcmViYXNlIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjIwMQorIzogYnVpbHRpbi9wdWxsLmM6MjAyCiBtc2dpZCAiT3B0aW9ucyByZWxhdGVkIHRvIGZldGNoaW5nIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjIxMQorIzogYnVpbHRpbi9wdWxsLmM6MjEyCiBtc2dpZCAiZm9yY2Ugb3ZlcndyaXRlIG9mIGxvY2FsIGJyYW5jaCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3B1bGwuYzoyMTkKKyM6IGJ1aWx0aW4vcHVsbC5jOjIyMAogbXNnaWQgIm51bWJlciBvZiBzdWJtb2R1bGVzIHB1bGxlZCBpbiBwYXJhbGxlbCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3B1bGwuYzozMTYKKyM6IGJ1aWx0aW4vcHVsbC5jOjMyMAogIywgYy1mb3JtYXQKIG1zZ2lkICJJbnZhbGlkIHZhbHVlIGZvciBwdWxsLmZmOiAlcyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3B1bGwuYzo0MzMKKyM6IGJ1aWx0aW4vcHVsbC5jOjQzNwogbXNnaWQgIiIKICJUaGVyZSBpcyBubyBjYW5kaWRhdGUgZm9yIHJlYmFzaW5nIGFnYWluc3QgYW1vbmcgdGhlIHJlZnMgdGhhdCB5b3UganVzdCAiCiAiZmV0Y2hlZC4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9wdWxsLmM6NDM1CisjOiBidWlsdGluL3B1bGwuYzo0MzkKIG1zZ2lkICIiCiAiVGhlcmUgYXJlIG5vIGNhbmRpZGF0ZXMgZm9yIG1lcmdpbmcgYW1vbmcgdGhlIHJlZnMgdGhhdCB5b3UganVzdCBmZXRjaGVkLiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3B1bGwuYzo0MzYKKyM6IGJ1aWx0aW4vcHVsbC5jOjQ0MAogbXNnaWQgIiIKICJHZW5lcmFsbHkgdGhpcyBtZWFucyB0aGF0IHlvdSBwcm92aWRlZCBhIHdpbGRjYXJkIHJlZnNwZWMgd2hpY2ggaGFkIG5vXG4iCiAibWF0Y2hlcyBvbiB0aGUgcmVtb3RlIGVuZC4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9wdWxsLmM6NDM5CisjOiBidWlsdGluL3B1bGwuYzo0NDMKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIllvdSBhc2tlZCB0byBwdWxsIGZyb20gdGhlIHJlbW90ZSAnJXMnLCBidXQgZGlkIG5vdCBzcGVjaWZ5XG4iCkBAIC0xNTUyNyw3NCArMTU2MDUsNzQgQEAKICJmb3IgeW91ciBjdXJyZW50IGJyYW5jaCwgeW91IG11c3Qgc3BlY2lmeSBhIGJyYW5jaCBvbiB0aGUgY29tbWFuZCBsaW5lLiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3B1bGwuYzo0NDQgYnVpbHRpbi9yZWJhc2UuYzoxMzI2IGdpdC1wYXJzZS1yZW1vdGUuc2g6NzMKKyM6IGJ1aWx0aW4vcHVsbC5jOjQ0OCBidWlsdGluL3JlYmFzZS5jOjEzNDcgZ2l0LXBhcnNlLXJlbW90ZS5zaDo3MwogbXNnaWQgIllvdSBhcmUgbm90IGN1cnJlbnRseSBvbiBhIGJyYW5jaC4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9wdWxsLmM6NDQ2IGJ1aWx0aW4vcHVsbC5jOjQ2MSBnaXQtcGFyc2UtcmVtb3RlLnNoOjc5CisjOiBidWlsdGluL3B1bGwuYzo0NTAgYnVpbHRpbi9wdWxsLmM6NDY1IGdpdC1wYXJzZS1yZW1vdGUuc2g6NzkKIG1zZ2lkICJQbGVhc2Ugc3BlY2lmeSB3aGljaCBicmFuY2ggeW91IHdhbnQgdG8gcmViYXNlIGFnYWluc3QuIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjQ0OCBidWlsdGluL3B1bGwuYzo0NjMgZ2l0LXBhcnNlLXJlbW90ZS5zaDo4MgorIzogYnVpbHRpbi9wdWxsLmM6NDUyIGJ1aWx0aW4vcHVsbC5jOjQ2NyBnaXQtcGFyc2UtcmVtb3RlLnNoOjgyCiBtc2dpZCAiUGxlYXNlIHNwZWNpZnkgd2hpY2ggYnJhbmNoIHlvdSB3YW50IHRvIG1lcmdlIHdpdGguIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjQ0OSBidWlsdGluL3B1bGwuYzo0NjQKKyM6IGJ1aWx0aW4vcHVsbC5jOjQ1MyBidWlsdGluL3B1bGwuYzo0NjgKIG1zZ2lkICJTZWUgZ2l0LXB1bGwoMSkgZm9yIGRldGFpbHMuIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjQ1MSBidWlsdGluL3B1bGwuYzo0NTcgYnVpbHRpbi9wdWxsLmM6NDY2Ci0jOiBidWlsdGluL3JlYmFzZS5jOjEzMzIgZ2l0LXBhcnNlLXJlbW90ZS5zaDo2NAorIzogYnVpbHRpbi9wdWxsLmM6NDU1IGJ1aWx0aW4vcHVsbC5jOjQ2MSBidWlsdGluL3B1bGwuYzo0NzAKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTM1MyBnaXQtcGFyc2UtcmVtb3RlLnNoOjY0CiBtc2dpZCAiPHJlbW90ZT4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9wdWxsLmM6NDUxIGJ1aWx0aW4vcHVsbC5jOjQ2NiBidWlsdGluL3B1bGwuYzo0NzEKKyM6IGJ1aWx0aW4vcHVsbC5jOjQ1NSBidWlsdGluL3B1bGwuYzo0NzAgYnVpbHRpbi9wdWxsLmM6NDc1CiAjOiBnaXQtcGFyc2UtcmVtb3RlLnNoOjY1CiBtc2dpZCAiPGJyYW5jaD4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9wdWxsLmM6NDU5IGJ1aWx0aW4vcmViYXNlLmM6MTMyNCBnaXQtcGFyc2UtcmVtb3RlLnNoOjc1CisjOiBidWlsdGluL3B1bGwuYzo0NjMgYnVpbHRpbi9yZWJhc2UuYzoxMzQ1IGdpdC1wYXJzZS1yZW1vdGUuc2g6NzUKIG1zZ2lkICJUaGVyZSBpcyBubyB0cmFja2luZyBpbmZvcm1hdGlvbiBmb3IgdGhlIGN1cnJlbnQgYnJhbmNoLiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3B1bGwuYzo0NjggZ2l0LXBhcnNlLXJlbW90ZS5zaDo5NQorIzogYnVpbHRpbi9wdWxsLmM6NDcyIGdpdC1wYXJzZS1yZW1vdGUuc2g6OTUKIG1zZ2lkICIiCiAiSWYgeW91IHdpc2ggdG8gc2V0IHRyYWNraW5nIGluZm9ybWF0aW9uIGZvciB0aGlzIGJyYW5jaCB5b3UgY2FuIGRvIHNvIHdpdGg6IgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjQ3MworIzogYnVpbHRpbi9wdWxsLmM6NDc3CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJZb3VyIGNvbmZpZ3VyYXRpb24gc3BlY2lmaWVzIHRvIG1lcmdlIHdpdGggdGhlIHJlZiAnJXMnXG4iCiAiZnJvbSB0aGUgcmVtb3RlLCBidXQgbm8gc3VjaCByZWYgd2FzIGZldGNoZWQuIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjU4MQorIzogYnVpbHRpbi9wdWxsLmM6NTg3CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBhY2Nlc3MgY29tbWl0ICVzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjg2MQorIzogYnVpbHRpbi9wdWxsLmM6ODY3CiBtc2dpZCAiaWdub3JpbmcgLS12ZXJpZnktc2lnbmF0dXJlcyBmb3IgcmViYXNlIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjkxNgorIzogYnVpbHRpbi9wdWxsLmM6OTIyCiBtc2dpZCAiLS1bbm8tXWF1dG9zdGFzaCBvcHRpb24gaXMgb25seSB2YWxpZCB3aXRoIC0tcmViYXNlLiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3B1bGwuYzo5MjQKKyM6IGJ1aWx0aW4vcHVsbC5jOjkzMAogbXNnaWQgIlVwZGF0aW5nIGFuIHVuYm9ybiBicmFuY2ggd2l0aCBjaGFuZ2VzIGFkZGVkIHRvIHRoZSBpbmRleC4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9wdWxsLmM6OTI4CisjOiBidWlsdGluL3B1bGwuYzo5MzQKIG1zZ2lkICJwdWxsIHdpdGggcmViYXNlIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjkyOQorIzogYnVpbHRpbi9wdWxsLmM6OTM1CiBtc2dpZCAicGxlYXNlIGNvbW1pdCBvciBzdGFzaCB0aGVtLiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3B1bGwuYzo5NTQKKyM6IGJ1aWx0aW4vcHVsbC5jOjk2MAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiZmV0Y2ggdXBkYXRlZCB0aGUgY3VycmVudCBicmFuY2ggaGVhZC5cbiIKQEAgLTE1NjAyLDcgKzE1NjgwLDcgQEAKICJjb21taXQgJXMuIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjk2MAorIzogYnVpbHRpbi9wdWxsLmM6OTY2CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJDYW5ub3QgZmFzdC1mb3J3YXJkIHlvdXIgd29ya2luZyB0cmVlLlxuIgpAQCAtMTU2MTMsMTUgKzE1NjkxLDE1IEBACiAidG8gcmVjb3Zlci4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9wdWxsLmM6OTc1CisjOiBidWlsdGluL3B1bGwuYzo5ODEKIG1zZ2lkICJDYW5ub3QgbWVyZ2UgbXVsdGlwbGUgYnJhbmNoZXMgaW50byBlbXB0eSBoZWFkLiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3B1bGwuYzo5NzkKKyM6IGJ1aWx0aW4vcHVsbC5jOjk4NQogbXNnaWQgIkNhbm5vdCByZWJhc2Ugb250byBtdWx0aXBsZSBicmFuY2hlcy4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9wdWxsLmM6OTg2CisjOiBidWlsdGluL3B1bGwuYzo5OTIKIG1zZ2lkICJjYW5ub3QgcmViYXNlIHdpdGggbG9jYWxseSByZWNvcmRlZCBzdWJtb2R1bGUgbW9kaWZpY2F0aW9ucyIKIG1zZ3N0ciAiIgogCkBAIC0xNTczNiwxNyArMTU4MTQsOTQgQEAKIG1zZ2lkICJQdXNoaW5nIHRvICVzXG4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9wdXNoLmM6MzY0CisjOiBidWlsdGluL3B1c2guYzozNjYKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIHB1c2ggc29tZSByZWZzIHRvICclcyciCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9wdXNoLmM6Mzk4CisjOiBidWlsdGluL3B1c2guYzo1NDEKK21zZ2lkICJyZXBvc2l0b3J5IgorbXNnc3RyICIiCisKKyM6IGJ1aWx0aW4vcHVzaC5jOjU0MiBidWlsdGluL3NlbmQtcGFjay5jOjE2NAorbXNnaWQgInB1c2ggYWxsIHJlZnMiCittc2dzdHIgIiIKKworIzogYnVpbHRpbi9wdXNoLmM6NTQzIGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTY2Cittc2dpZCAibWlycm9yIGFsbCByZWZzIgorbXNnc3RyICIiCisKKyM6IGJ1aWx0aW4vcHVzaC5jOjU0NQorbXNnaWQgImRlbGV0ZSByZWZzIgorbXNnc3RyICIiCisKKyM6IGJ1aWx0aW4vcHVzaC5jOjU0NgorbXNnaWQgInB1c2ggdGFncyAoY2FuJ3QgYmUgdXNlZCB3aXRoIC0tYWxsIG9yIC0tbWlycm9yKSIKK21zZ3N0ciAiIgorCisjOiBidWlsdGluL3B1c2guYzo1NDkgYnVpbHRpbi9zZW5kLXBhY2suYzoxNjcKK21zZ2lkICJmb3JjZSB1cGRhdGVzIgorbXNnc3RyICIiCisKKyM6IGJ1aWx0aW4vcHVzaC5jOjU1MSBidWlsdGluL3NlbmQtcGFjay5jOjE4MQorbXNnaWQgIjxyZWZuYW1lPjo8ZXhwZWN0PiIKK21zZ3N0ciAiIgorCisjOiBidWlsdGluL3B1c2guYzo1NTIgYnVpbHRpbi9zZW5kLXBhY2suYzoxODIKK21zZ2lkICJyZXF1aXJlIG9sZCB2YWx1ZSBvZiByZWYgdG8gYmUgYXQgdGhpcyB2YWx1ZSIKK21zZ3N0ciAiIgorCisjOiBidWlsdGluL3B1c2guYzo1NTUKK21zZ2lkICJjb250cm9sIHJlY3Vyc2l2ZSBwdXNoaW5nIG9mIHN1Ym1vZHVsZXMiCittc2dzdHIgIiIKKworIzogYnVpbHRpbi9wdXNoLmM6NTU3IGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTc1Cittc2dpZCAidXNlIHRoaW4gcGFjayIKK21zZ3N0ciAiIgorCisjOiBidWlsdGluL3B1c2guYzo1NTggYnVpbHRpbi9wdXNoLmM6NTU5IGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTYxCisjOiBidWlsdGluL3NlbmQtcGFjay5jOjE2MgorbXNnaWQgInJlY2VpdmUgcGFjayBwcm9ncmFtIgorbXNnc3RyICIiCisKKyM6IGJ1aWx0aW4vcHVzaC5jOjU2MAorbXNnaWQgInNldCB1cHN0cmVhbSBmb3IgZ2l0IHB1bGwvc3RhdHVzIgorbXNnc3RyICIiCisKKyM6IGJ1aWx0aW4vcHVzaC5jOjU2MworbXNnaWQgInBydW5lIGxvY2FsbHkgcmVtb3ZlZCByZWZzIgorbXNnc3RyICIiCisKKyM6IGJ1aWx0aW4vcHVzaC5jOjU2NQorbXNnaWQgImJ5cGFzcyBwcmUtcHVzaCBob29rIgorbXNnc3RyICIiCisKKyM6IGJ1aWx0aW4vcHVzaC5jOjU2NgorbXNnaWQgInB1c2ggbWlzc2luZyBidXQgcmVsZXZhbnQgdGFncyIKK21zZ3N0ciAiIgorCisjOiBidWlsdGluL3B1c2guYzo1NjkgYnVpbHRpbi9zZW5kLXBhY2suYzoxNjkKK21zZ2lkICJHUEcgc2lnbiB0aGUgcHVzaCIKK21zZ3N0ciAiIgorCisjOiBidWlsdGluL3B1c2guYzo1NzEgYnVpbHRpbi9zZW5kLXBhY2suYzoxNzYKK21zZ2lkICJyZXF1ZXN0IGF0b21pYyB0cmFuc2FjdGlvbiBvbiByZW1vdGUgc2lkZSIKK21zZ3N0ciAiIgorCisjOiBidWlsdGluL3B1c2guYzo1ODkKK21zZ2lkICItLWRlbGV0ZSBpcyBpbmNvbXBhdGlibGUgd2l0aCAtLWFsbCwgLS1taXJyb3IgYW5kIC0tdGFncyIKK21zZ3N0ciAiIgorCisjOiBidWlsdGluL3B1c2guYzo1OTEKK21zZ2lkICItLWRlbGV0ZSBkb2Vzbid0IG1ha2Ugc2Vuc2Ugd2l0aG91dCBhbnkgcmVmcyIKK21zZ3N0ciAiIgorCisjOiBidWlsdGluL3B1c2guYzo2MTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiYmFkIHJlcG9zaXRvcnkgJyVzJyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3B1c2guYzozOTkKKyM6IGJ1aWx0aW4vcHVzaC5jOjYxMgogbXNnaWQgIiIKICJObyBjb25maWd1cmVkIHB1c2ggZGVzdGluYXRpb24uXG4iCiAiRWl0aGVyIHNwZWNpZnkgdGhlIFVSTCBmcm9tIHRoZSBjb21tYW5kLWxpbmUgb3IgY29uZmlndXJlIGEgcmVtb3RlICIKQEAgLTE1NzU5LDEwNCArMTU5MTQsMjcgQEAKICIgICAgZ2l0IHB1c2ggPG5hbWU+XG4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9wdXNoLmM6NTU0Ci1tc2dpZCAicmVwb3NpdG9yeSIKLW1zZ3N0ciAiIgotCi0jOiBidWlsdGluL3B1c2guYzo1NTUgYnVpbHRpbi9zZW5kLXBhY2suYzoxNjQKLW1zZ2lkICJwdXNoIGFsbCByZWZzIgotbXNnc3RyICIiCi0KLSM6IGJ1aWx0aW4vcHVzaC5jOjU1NiBidWlsdGluL3NlbmQtcGFjay5jOjE2NgotbXNnaWQgIm1pcnJvciBhbGwgcmVmcyIKLW1zZ3N0ciAiIgotCi0jOiBidWlsdGluL3B1c2guYzo1NTgKLW1zZ2lkICJkZWxldGUgcmVmcyIKLW1zZ3N0ciAiIgotCi0jOiBidWlsdGluL3B1c2guYzo1NTkKLW1zZ2lkICJwdXNoIHRhZ3MgKGNhbid0IGJlIHVzZWQgd2l0aCAtLWFsbCBvciAtLW1pcnJvcikiCi1tc2dzdHIgIiIKLQotIzogYnVpbHRpbi9wdXNoLmM6NTYyIGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTY3Ci1tc2dpZCAiZm9yY2UgdXBkYXRlcyIKLW1zZ3N0ciAiIgotCi0jOiBidWlsdGluL3B1c2guYzo1NjQgYnVpbHRpbi9zZW5kLXBhY2suYzoxODEKLW1zZ2lkICI8cmVmbmFtZT46PGV4cGVjdD4iCi1tc2dzdHIgIiIKLQotIzogYnVpbHRpbi9wdXNoLmM6NTY1IGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTgyCi1tc2dpZCAicmVxdWlyZSBvbGQgdmFsdWUgb2YgcmVmIHRvIGJlIGF0IHRoaXMgdmFsdWUiCi1tc2dzdHIgIiIKLQotIzogYnVpbHRpbi9wdXNoLmM6NTY4Ci1tc2dpZCAiY29udHJvbCByZWN1cnNpdmUgcHVzaGluZyBvZiBzdWJtb2R1bGVzIgotbXNnc3RyICIiCi0KLSM6IGJ1aWx0aW4vcHVzaC5jOjU3MCBidWlsdGluL3NlbmQtcGFjay5jOjE3NQotbXNnaWQgInVzZSB0aGluIHBhY2siCi1tc2dzdHIgIiIKLQotIzogYnVpbHRpbi9wdXNoLmM6NTcxIGJ1aWx0aW4vcHVzaC5jOjU3MiBidWlsdGluL3NlbmQtcGFjay5jOjE2MQotIzogYnVpbHRpbi9zZW5kLXBhY2suYzoxNjIKLW1zZ2lkICJyZWNlaXZlIHBhY2sgcHJvZ3JhbSIKLW1zZ3N0ciAiIgotCi0jOiBidWlsdGluL3B1c2guYzo1NzMKLW1zZ2lkICJzZXQgdXBzdHJlYW0gZm9yIGdpdCBwdWxsL3N0YXR1cyIKLW1zZ3N0ciAiIgotCi0jOiBidWlsdGluL3B1c2guYzo1NzYKLW1zZ2lkICJwcnVuZSBsb2NhbGx5IHJlbW92ZWQgcmVmcyIKLW1zZ3N0ciAiIgotCi0jOiBidWlsdGluL3B1c2guYzo1NzgKLW1zZ2lkICJieXBhc3MgcHJlLXB1c2ggaG9vayIKLW1zZ3N0ciAiIgotCi0jOiBidWlsdGluL3B1c2guYzo1NzkKLW1zZ2lkICJwdXNoIG1pc3NpbmcgYnV0IHJlbGV2YW50IHRhZ3MiCi1tc2dzdHIgIiIKLQotIzogYnVpbHRpbi9wdXNoLmM6NTgyIGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTY5Ci1tc2dpZCAiR1BHIHNpZ24gdGhlIHB1c2giCi1tc2dzdHIgIiIKLQotIzogYnVpbHRpbi9wdXNoLmM6NTg0IGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTc2Ci1tc2dpZCAicmVxdWVzdCBhdG9taWMgdHJhbnNhY3Rpb24gb24gcmVtb3RlIHNpZGUiCi1tc2dzdHIgIiIKLQotIzogYnVpbHRpbi9wdXNoLmM6NjAyCi1tc2dpZCAiLS1kZWxldGUgaXMgaW5jb21wYXRpYmxlIHdpdGggLS1hbGwsIC0tbWlycm9yIGFuZCAtLXRhZ3MiCi1tc2dzdHIgIiIKLQotIzogYnVpbHRpbi9wdXNoLmM6NjA0Ci1tc2dpZCAiLS1kZWxldGUgZG9lc24ndCBtYWtlIHNlbnNlIHdpdGhvdXQgYW55IHJlZnMiCi1tc2dzdHIgIiIKLQotIzogYnVpbHRpbi9wdXNoLmM6NjA3CisjOiBidWlsdGluL3B1c2guYzo2MjcKIG1zZ2lkICItLWFsbCBhbmQgLS10YWdzIGFyZSBpbmNvbXBhdGlibGUiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9wdXNoLmM6NjA5CisjOiBidWlsdGluL3B1c2guYzo2MjkKIG1zZ2lkICItLWFsbCBjYW4ndCBiZSBjb21iaW5lZCB3aXRoIHJlZnNwZWNzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcHVzaC5jOjYxMworIzogYnVpbHRpbi9wdXNoLmM6NjMzCiBtc2dpZCAiLS1taXJyb3IgYW5kIC0tdGFncyBhcmUgaW5jb21wYXRpYmxlIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcHVzaC5jOjYxNQorIzogYnVpbHRpbi9wdXNoLmM6NjM1CiBtc2dpZCAiLS1taXJyb3IgY2FuJ3QgYmUgY29tYmluZWQgd2l0aCByZWZzcGVjcyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3B1c2guYzo2MTgKKyM6IGJ1aWx0aW4vcHVzaC5jOjYzOAogbXNnaWQgIi0tYWxsIGFuZCAtLW1pcnJvciBhcmUgaW5jb21wYXRpYmxlIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcHVzaC5jOjYzNworIzogYnVpbHRpbi9wdXNoLmM6NjQyCiBtc2dpZCAicHVzaCBvcHRpb25zIG11c3Qgbm90IGhhdmUgbmV3IGxpbmUgY2hhcmFjdGVycyIKIG1zZ3N0ciAiIgogCkBAIC0xNTk3MCw4ICsxNjA0OCw4IEBACiAKICM6IGJ1aWx0aW4vcmViYXNlLmM6MzIKIG1zZ2lkICIiCi0iZ2l0IHJlYmFzZSBbLWldIFtvcHRpb25zXSBbLS1leGVjIDxjbWQ+XSBbLS1vbnRvIDxuZXdiYXNlPl0gWzx1cHN0cmVhbT5dICIKLSJbPGJyYW5jaD5dIgorImdpdCByZWJhc2UgWy1pXSBbb3B0aW9uc10gWy0tZXhlYyA8Y21kPl0gWy0tb250byA8bmV3YmFzZT4gfCAtLWtlZXAtYmFzZV0gIgorIls8dXBzdHJlYW0+IFs8YnJhbmNoPl1dIgogbXNnc3RyICIiCiAKICM6IGJ1aWx0aW4vcmViYXNlLmM6MzQKQEAgLTE2MDEwLDE4OSArMTYwODgsMTg5IEBACiBtc2dpZCAiY291bGQgbm90IGdlbmVyYXRlIHRvZG8gbGlzdCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjM4MgorIzogYnVpbHRpbi9yZWJhc2UuYzozODMKIG1zZ2lkICJhIGJhc2UgY29tbWl0IG11c3QgYmUgcHJvdmlkZWQgd2l0aCAtLXVwc3RyZWFtIG9yIC0tb250byIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQzNworIzogYnVpbHRpbi9yZWJhc2UuYzo0MzgKIG1zZ2lkICJnaXQgcmViYXNlLS1pbnRlcmFjdGl2ZSBbPG9wdGlvbnM+XSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ0OQorIzogYnVpbHRpbi9yZWJhc2UuYzo0NTAKIG1zZ2lkICJrZWVwIGVtcHR5IGNvbW1pdHMiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0NTEgYnVpbHRpbi9yZXZlcnQuYzoxMjgKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDUyIGJ1aWx0aW4vcmV2ZXJ0LmM6MTI4CiBtc2dpZCAiYWxsb3cgY29tbWl0cyB3aXRoIGVtcHR5IG1lc3NhZ2VzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDUyCisjOiBidWlsdGluL3JlYmFzZS5jOjQ1MwogbXNnaWQgInJlYmFzZSBtZXJnZSBjb21taXRzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDU0CisjOiBidWlsdGluL3JlYmFzZS5jOjQ1NQogbXNnaWQgImtlZXAgb3JpZ2luYWwgYnJhbmNoIHBvaW50cyBvZiBjb3VzaW5zIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDU2CisjOiBidWlsdGluL3JlYmFzZS5jOjQ1NwogbXNnaWQgIm1vdmUgY29tbWl0cyB0aGF0IGJlZ2luIHdpdGggc3F1YXNoIS9maXh1cCEiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0NTcKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDU4CiBtc2dpZCAic2lnbiBjb21taXRzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDU5IGJ1aWx0aW4vcmViYXNlLmM6MTQwMworIzogYnVpbHRpbi9yZWJhc2UuYzo0NjAgYnVpbHRpbi9yZWJhc2UuYzoxNDI3CiBtc2dpZCAiZGlzcGxheSBhIGRpZmZzdGF0IG9mIHdoYXQgY2hhbmdlZCB1cHN0cmVhbSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ2MQorIzogYnVpbHRpbi9yZWJhc2UuYzo0NjIKIG1zZ2lkICJjb250aW51ZSByZWJhc2UiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0NjMKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDY0CiBtc2dpZCAic2tpcCBjb21taXQiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0NjQKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDY1CiBtc2dpZCAiZWRpdCB0aGUgdG9kbyBsaXN0IgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDY2CisjOiBidWlsdGluL3JlYmFzZS5jOjQ2NwogbXNnaWQgInNob3cgdGhlIGN1cnJlbnQgcGF0Y2giCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0NjkKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDcwCiBtc2dpZCAic2hvcnRlbiBjb21taXQgaWRzIGluIHRoZSB0b2RvIGxpc3QiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0NzEKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDcyCiBtc2dpZCAiZXhwYW5kIGNvbW1pdCBpZHMgaW4gdGhlIHRvZG8gbGlzdCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ3MworIzogYnVpbHRpbi9yZWJhc2UuYzo0NzQKIG1zZ2lkICJjaGVjayB0aGUgdG9kbyBsaXN0IgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDc1CisjOiBidWlsdGluL3JlYmFzZS5jOjQ3NgogbXNnaWQgInJlYXJyYW5nZSBmaXh1cC9zcXVhc2ggbGluZXMiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0NzcKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDc4CiBtc2dpZCAiaW5zZXJ0IGV4ZWMgY29tbWFuZHMgaW4gdG9kbyBsaXN0IgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDc4CisjOiBidWlsdGluL3JlYmFzZS5jOjQ3OQogbXNnaWQgIm9udG8iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0ODEKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDgyCiBtc2dpZCAicmVzdHJpY3QtcmV2aXNpb24iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0ODEKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDgyCiBtc2dpZCAicmVzdHJpY3QgcmV2aXNpb24iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0ODMKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDg0CiBtc2dpZCAic3F1YXNoLW9udG8iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0ODQKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDg1CiBtc2dpZCAic3F1YXNoIG9udG8iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0ODYKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDg3CiBtc2dpZCAidGhlIHVwc3RyZWFtIGNvbW1pdCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ4OAorIzogYnVpbHRpbi9yZWJhc2UuYzo0ODkKIG1zZ2lkICJoZWFkLW5hbWUiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0ODgKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDg5CiBtc2dpZCAiaGVhZCBuYW1lIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDkzCisjOiBidWlsdGluL3JlYmFzZS5jOjQ5NAogbXNnaWQgInJlYmFzZSBzdHJhdGVneSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ5NAorIzogYnVpbHRpbi9yZWJhc2UuYzo0OTUKIG1zZ2lkICJzdHJhdGVneS1vcHRzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDk1CisjOiBidWlsdGluL3JlYmFzZS5jOjQ5NgogbXNnaWQgInN0cmF0ZWd5IG9wdGlvbnMiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0OTYKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDk3CiBtc2dpZCAic3dpdGNoLXRvIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDk3CisjOiBidWlsdGluL3JlYmFzZS5jOjQ5OAogbXNnaWQgInRoZSBicmFuY2ggb3IgY29tbWl0IHRvIGNoZWNrb3V0IgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDk4CisjOiBidWlsdGluL3JlYmFzZS5jOjQ5OQogbXNnaWQgIm9udG8tbmFtZSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ5OAorIzogYnVpbHRpbi9yZWJhc2UuYzo0OTkKIG1zZ2lkICJvbnRvIG5hbWUiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0OTkKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NTAwCiBtc2dpZCAiY21kIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDk5CisjOiBidWlsdGluL3JlYmFzZS5jOjUwMAogbXNnaWQgInRoZSBjb21tYW5kIHRvIHJ1biIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjUwMiBidWlsdGluL3JlYmFzZS5jOjE0ODYKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NTAzIGJ1aWx0aW4vcmViYXNlLmM6MTUxMAogbXNnaWQgImF1dG9tYXRpY2FsbHkgcmUtc2NoZWR1bGUgYW55IGBleGVjYCB0aGF0IGZhaWxzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NTE4CisjOiBidWlsdGluL3JlYmFzZS5jOjUxOQogbXNnaWQgIi0tW25vLV1yZWJhc2UtY291c2lucyBoYXMgbm8gZWZmZWN0IHdpdGhvdXQgLS1yZWJhc2UtbWVyZ2VzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NTM0CisjOiBidWlsdGluL3JlYmFzZS5jOjUzNQogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyByZXF1aXJlcyBhbiBpbnRlcmFjdGl2ZSByZWJhc2UiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo1ODYKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NTg3CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBnZXQgJ29udG8nOiAnJXMnIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NjAxCisjOiBidWlsdGluL3JlYmFzZS5jOjYwMgogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIG9yaWctaGVhZDogJyVzJyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjYyNgorIzogYnVpbHRpbi9yZWJhc2UuYzo2MjcKICMsIGMtZm9ybWF0CiBtc2dpZCAiaWdub3JpbmcgaW52YWxpZCBhbGxvd19yZXJlcmVfYXV0b3VwZGF0ZTogJyVzJyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjcwMgorIzogYnVpbHRpbi9yZWJhc2UuYzo3MDMKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ291bGQgbm90IHJlYWQgJyVzJyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjcyMAorIzogYnVpbHRpbi9yZWJhc2UuYzo3MjEKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ2Fubm90IHN0b3JlICVzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6ODI3CisjOiBidWlsdGluL3JlYmFzZS5jOjgyOAogbXNnaWQgImNvdWxkIG5vdCBkZXRlcm1pbmUgSEVBRCByZXZpc2lvbiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjk1MCBnaXQtcmViYXNlLS1wcmVzZXJ2ZS1tZXJnZXMuc2g6ODEKKyM6IGJ1aWx0aW4vcmViYXNlLmM6OTUxIGdpdC1yZWJhc2UtLXByZXNlcnZlLW1lcmdlcy5zaDo4MQogbXNnaWQgIiIKICJSZXNvbHZlIGFsbCBjb25mbGljdHMgbWFudWFsbHksIG1hcmsgdGhlbSBhcyByZXNvbHZlZCB3aXRoXG4iCiAiXCJnaXQgYWRkL3JtIDxjb25mbGljdGVkX2ZpbGVzPlwiLCB0aGVuIHJ1biBcImdpdCByZWJhc2UgLS1jb250aW51ZVwiLlxuIgpAQCAtMTYyMDEsNyArMTYyNzksNyBAQAogImFib3J0XCIuIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTAzMQorIzogYnVpbHRpbi9yZWJhc2UuYzoxMDMyCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJcbiIKQEAgLTE2MjEzLDcgKzE2MjkxLDcgQEAKICJBcyBhIHJlc3VsdCwgZ2l0IGNhbm5vdCByZWJhc2UgdGhlbS4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxMzE4CisjOiBidWlsdGluL3JlYmFzZS5jOjEzMzkKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIiVzXG4iCkBAIC0xNjIyNCw3ICsxNjMwMiw3IEBACiAiXG4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxMzM0CisjOiBidWlsdGluL3JlYmFzZS5jOjEzNTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIklmIHlvdSB3aXNoIHRvIHNldCB0cmFja2luZyBpbmZvcm1hdGlvbiBmb3IgdGhpcyBicmFuY2ggeW91IGNhbiBkbyBzbyB3aXRoOlxuIgpAQCAtMTYyMzMsMTY5ICsxNjMxMSwxODEgQEAKICJcbiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjEzNjQKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTM4NQogbXNnaWQgImV4ZWMgY29tbWFuZHMgY2Fubm90IGNvbnRhaW4gbmV3bGluZXMiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxMzY4CisjOiBidWlsdGluL3JlYmFzZS5jOjEzODkKIG1zZ2lkICJlbXB0eSBleGVjIGNvbW1hbmQiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxMzk2CisjOiBidWlsdGluL3JlYmFzZS5jOjE0MTgKIG1zZ2lkICJyZWJhc2Ugb250byBnaXZlbiBicmFuY2ggaW5zdGVhZCBvZiB1cHN0cmVhbSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjEzOTgKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQyMAorbXNnaWQgInVzZSB0aGUgbWVyZ2UtYmFzZSBvZiB1cHN0cmVhbSBhbmQgYnJhbmNoIGFzIHRoZSBjdXJyZW50IGJhc2UiCittc2dzdHIgIiIKKworIzogYnVpbHRpbi9yZWJhc2UuYzoxNDIyCiBtc2dpZCAiYWxsb3cgcHJlLXJlYmFzZSBob29rIHRvIHJ1biIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0MDAKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQyNAogbXNnaWQgImJlIHF1aWV0LiBpbXBsaWVzIC0tbm8tc3RhdCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0MDYKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQzMAogbXNnaWQgImRvIG5vdCBzaG93IGRpZmZzdGF0IG9mIHdoYXQgY2hhbmdlZCB1cHN0cmVhbSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0MDkKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQzMwogbXNnaWQgImFkZCBhIFNpZ25lZC1vZmYtYnk6IGxpbmUgdG8gZWFjaCBjb21taXQiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDExIGJ1aWx0aW4vcmViYXNlLmM6MTQxNSBidWlsdGluL3JlYmFzZS5jOjE0MTcKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQzNSBidWlsdGluL3JlYmFzZS5jOjE0MzkgYnVpbHRpbi9yZWJhc2UuYzoxNDQxCiBtc2dpZCAicGFzc2VkIHRvICdnaXQgYW0nIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQxOSBidWlsdGluL3JlYmFzZS5jOjE0MjEKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ0MyBidWlsdGluL3JlYmFzZS5jOjE0NDUKIG1zZ2lkICJwYXNzZWQgdG8gJ2dpdCBhcHBseSciCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDIzIGJ1aWx0aW4vcmViYXNlLmM6MTQyNgorIzogYnVpbHRpbi9yZWJhc2UuYzoxNDQ3IGJ1aWx0aW4vcmViYXNlLmM6MTQ1MAogbXNnaWQgImNoZXJyeS1waWNrIGFsbCBjb21taXRzLCBldmVuIGlmIHVuY2hhbmdlZCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0MjgKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ1MgogbXNnaWQgImNvbnRpbnVlIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQzMQorIzogYnVpbHRpbi9yZWJhc2UuYzoxNDU1CiBtc2dpZCAic2tpcCBjdXJyZW50IHBhdGNoIGFuZCBjb250aW51ZSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0MzMKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ1NwogbXNnaWQgImFib3J0IGFuZCBjaGVjayBvdXQgdGhlIG9yaWdpbmFsIGJyYW5jaCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0MzYKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ2MAogbXNnaWQgImFib3J0IGJ1dCBrZWVwIEhFQUQgd2hlcmUgaXQgaXMiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDM3CisjOiBidWlsdGluL3JlYmFzZS5jOjE0NjEKIG1zZ2lkICJlZGl0IHRoZSB0b2RvIGxpc3QgZHVyaW5nIGFuIGludGVyYWN0aXZlIHJlYmFzZSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0NDAKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ2NAogbXNnaWQgInNob3cgdGhlIHBhdGNoIGZpbGUgYmVpbmcgYXBwbGllZCBvciBtZXJnZWQiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDQzCisjOiBidWlsdGluL3JlYmFzZS5jOjE0NjcKIG1zZ2lkICJ1c2UgbWVyZ2luZyBzdHJhdGVnaWVzIHRvIHJlYmFzZSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0NDcKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ3MQogbXNnaWQgImxldCB0aGUgdXNlciBlZGl0IHRoZSBsaXN0IG9mIGNvbW1pdHMgdG8gcmViYXNlIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ1MQorIzogYnVpbHRpbi9yZWJhc2UuYzoxNDc1CiBtc2dpZCAiKERFUFJFQ0FURUQpIHRyeSB0byByZWNyZWF0ZSBtZXJnZXMgaW5zdGVhZCBvZiBpZ25vcmluZyB0aGVtIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ1NQorIzogYnVpbHRpbi9yZWJhc2UuYzoxNDc5CiBtc2dpZCAicHJlc2VydmUgZW1wdHkgY29tbWl0cyBkdXJpbmcgcmViYXNlIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ1NworIzogYnVpbHRpbi9yZWJhc2UuYzoxNDgxCiBtc2dpZCAibW92ZSBjb21taXRzIHRoYXQgYmVnaW4gd2l0aCBzcXVhc2ghL2ZpeHVwISB1bmRlciAtaSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0NjMKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ4NwogbXNnaWQgImF1dG9tYXRpY2FsbHkgc3Rhc2gvc3Rhc2ggcG9wIGJlZm9yZSBhbmQgYWZ0ZXIiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDY1CisjOiBidWlsdGluL3JlYmFzZS5jOjE0ODkKIG1zZ2lkICJhZGQgZXhlYyBsaW5lcyBhZnRlciBlYWNoIGNvbW1pdCBvZiB0aGUgZWRpdGFibGUgbGlzdCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0NjkKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ5MwogbXNnaWQgImFsbG93IHJlYmFzaW5nIGNvbW1pdHMgd2l0aCBlbXB0eSBtZXNzYWdlcyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0NzIKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ5NgogbXNnaWQgInRyeSB0byByZWJhc2UgbWVyZ2VzIGluc3RlYWQgb2Ygc2tpcHBpbmcgdGhlbSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0NzUKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ5OQogbXNnaWQgInVzZSAnbWVyZ2UtYmFzZSAtLWZvcmstcG9pbnQnIHRvIHJlZmluZSB1cHN0cmVhbSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0NzcKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTUwMQogbXNnaWQgInVzZSB0aGUgZ2l2ZW4gbWVyZ2Ugc3RyYXRlZ3kiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDc5IGJ1aWx0aW4vcmV2ZXJ0LmM6MTE1CisjOiBidWlsdGluL3JlYmFzZS5jOjE1MDMgYnVpbHRpbi9yZXZlcnQuYzoxMTUKIG1zZ2lkICJvcHRpb24iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDgwCisjOiBidWlsdGluL3JlYmFzZS5jOjE1MDQKIG1zZ2lkICJwYXNzIHRoZSBhcmd1bWVudCB0aHJvdWdoIHRvIHRoZSBtZXJnZSBzdHJhdGVneSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0ODMKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTUwNwogbXNnaWQgInJlYmFzZSBhbGwgcmVhY2hhYmxlIGNvbW1pdHMgdXAgdG8gdGhlIHJvb3QocykiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNTAwCisjOiBidWlsdGluL3JlYmFzZS5jOjE1MjQKIG1zZ2lkICIiCiAidGhlIHJlYmFzZS51c2VCdWlsdGluIHN1cHBvcnQgaGFzIGJlZW4gcmVtb3ZlZCFcbiIKICJTZWUgaXRzIGVudHJ5IGluICdnaXQgaGVscCBjb25maWcnIGZvciBkZXRhaWxzLiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE1MDYKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTUzMAogbXNnaWQgIkl0IGxvb2tzIGxpa2UgJ2dpdCBhbScgaXMgaW4gcHJvZ3Jlc3MuIENhbm5vdCByZWJhc2UuIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTU0NworIzogYnVpbHRpbi9yZWJhc2UuYzoxNTcxCiBtc2dpZCAiIgogImdpdCByZWJhc2UgLS1wcmVzZXJ2ZS1tZXJnZXMgaXMgZGVwcmVjYXRlZC4gVXNlIC0tcmViYXNlLW1lcmdlcyBpbnN0ZWFkLiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE1NTEKLW1zZ2lkICJObyByZWJhc2UgaW4gcHJvZ3Jlc3M/IgotbXNnc3RyICIiCi0KLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTU1NQotbXNnaWQgIlRoZSAtLWVkaXQtdG9kbyBhY3Rpb24gY2FuIG9ubHkgYmUgdXNlZCBkdXJpbmcgaW50ZXJhY3RpdmUgcmViYXNlLiIKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTU3NgorbXNnaWQgImNhbm5vdCBjb21iaW5lICctLWtlZXAtYmFzZScgd2l0aCAnLS1vbnRvJyIKIG1zZ3N0ciAiIgogCiAjOiBidWlsdGluL3JlYmFzZS5jOjE1NzgKK21zZ2lkICJjYW5ub3QgY29tYmluZSAnLS1rZWVwLWJhc2UnIHdpdGggJy0tcm9vdCciCittc2dzdHIgIiIKKworIzogYnVpbHRpbi9yZWJhc2UuYzoxNTgyCittc2dpZCAiTm8gcmViYXNlIGluIHByb2dyZXNzPyIKK21zZ3N0ciAiIgorCisjOiBidWlsdGluL3JlYmFzZS5jOjE1ODYKK21zZ2lkICJUaGUgLS1lZGl0LXRvZG8gYWN0aW9uIGNhbiBvbmx5IGJlIHVzZWQgZHVyaW5nIGludGVyYWN0aXZlIHJlYmFzZS4iCittc2dzdHIgIiIKKworIzogYnVpbHRpbi9yZWJhc2UuYzoxNjA5CiBtc2dpZCAiQ2Fubm90IHJlYWQgSEVBRCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE1OTAKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTYyMQogbXNnaWQgIiIKICJZb3UgbXVzdCBlZGl0IGFsbCBtZXJnZSBjb25mbGljdHMgYW5kIHRoZW5cbiIKICJtYXJrIHRoZW0gYXMgcmVzb2x2ZWQgdXNpbmcgZ2l0IGFkZCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE2MDkKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTY0MAogbXNnaWQgImNvdWxkIG5vdCBkaXNjYXJkIHdvcmt0cmVlIGNoYW5nZXMiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNjI4CisjOiBidWlsdGluL3JlYmFzZS5jOjE2NTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IG1vdmUgYmFjayB0byAlcyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE2NzMKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTcwNAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiSXQgc2VlbXMgdGhhdCB0aGVyZSBpcyBhbHJlYWR5IGEgJXMgZGlyZWN0b3J5LCBhbmRcbiIKQEAgLTE2NDA4LDE2MiArMTY0OTgsMTU0IEBACiAidmFsdWFibGUgdGhlcmUuXG4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNjk0CisjOiBidWlsdGluL3JlYmFzZS5jOjE3MjUKIG1zZ2lkICJzd2l0Y2ggYEMnIGV4cGVjdHMgYSBudW1lcmljYWwgdmFsdWUiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNzM1CisjOiBidWlsdGluL3JlYmFzZS5jOjE3NjYKICMsIGMtZm9ybWF0CiBtc2dpZCAiVW5rbm93biBtb2RlOiAlcyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE3NTcKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTc4OAogbXNnaWQgIi0tc3RyYXRlZ3kgcmVxdWlyZXMgLS1tZXJnZSBvciAtLWludGVyYWN0aXZlIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTc5NworIzogYnVpbHRpbi9yZWJhc2UuYzoxODI4CiBtc2dpZCAiLS1yZXNjaGVkdWxlLWZhaWxlZC1leGVjIHJlcXVpcmVzIC0tZXhlYyBvciAtLWludGVyYWN0aXZlIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTgwOQorIzogYnVpbHRpbi9yZWJhc2UuYzoxODQwCiBtc2dpZCAiY2Fubm90IGNvbWJpbmUgYW0gb3B0aW9ucyB3aXRoIGVpdGhlciBpbnRlcmFjdGl2ZSBvciBtZXJnZSBvcHRpb25zIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTgyOAorIzogYnVpbHRpbi9yZWJhc2UuYzoxODU5CiBtc2dpZCAiY2Fubm90IGNvbWJpbmUgJy0tcHJlc2VydmUtbWVyZ2VzJyB3aXRoICctLXJlYmFzZS1tZXJnZXMnIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTgzMgorIzogYnVpbHRpbi9yZWJhc2UuYzoxODYzCiBtc2dpZCAiIgogImVycm9yOiBjYW5ub3QgY29tYmluZSAnLS1wcmVzZXJ2ZS1tZXJnZXMnIHdpdGggJy0tcmVzY2hlZHVsZS1mYWlsZWQtZXhlYyciCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxODM4Ci1tc2dpZCAiY2Fubm90IGNvbWJpbmUgJy0tcmViYXNlLW1lcmdlcycgd2l0aCAnLS1zdHJhdGVneS1vcHRpb24nIgotbXNnc3RyICIiCi0KLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTg0MQotbXNnaWQgImNhbm5vdCBjb21iaW5lICctLXJlYmFzZS1tZXJnZXMnIHdpdGggJy0tc3RyYXRlZ3knIgotbXNnc3RyICIiCi0KLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTg2NQorIzogYnVpbHRpbi9yZWJhc2UuYzoxODg3CiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgdXBzdHJlYW0gJyVzJyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE4NzEKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTg5MwogbXNnaWQgIkNvdWxkIG5vdCBjcmVhdGUgbmV3IHJvb3QgY29tbWl0IgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTg4OQorIzogYnVpbHRpbi9yZWJhc2UuYzoxOTE5CisjLCBjLWZvcm1hdAorbXNnaWQgIiclcyc6IG5lZWQgZXhhY3RseSBvbmUgbWVyZ2UgYmFzZSB3aXRoIGJyYW5jaCIKK21zZ3N0ciAiIgorCisjOiBidWlsdGluL3JlYmFzZS5jOjE5MjIKICMsIGMtZm9ybWF0CiBtc2dpZCAiJyVzJzogbmVlZCBleGFjdGx5IG9uZSBtZXJnZSBiYXNlIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTg5NgorIzogYnVpbHRpbi9yZWJhc2UuYzoxOTMwCiAjLCBjLWZvcm1hdAogbXNnaWQgIkRvZXMgbm90IHBvaW50IHRvIGEgdmFsaWQgY29tbWl0ICclcyciCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxOTIxCisjOiBidWlsdGluL3JlYmFzZS5jOjE5NTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmF0YWw6IG5vIHN1Y2ggYnJhbmNoL2NvbW1pdCAnJXMnIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTkyOSBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6MzgKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTk2MyBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6MzgKICM6IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxOTM0CiAjLCBjLWZvcm1hdAogbXNnaWQgIk5vIHN1Y2ggcmVmOiAlcyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE5NDAKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTk3NAogbXNnaWQgIkNvdWxkIG5vdCByZXNvbHZlIEhFQUQgdG8gYSByZXZpc2lvbiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE5ODEKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MjAxMgogbXNnaWQgIkNhbm5vdCBhdXRvc3Rhc2giCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxOTg0CisjOiBidWlsdGluL3JlYmFzZS5jOjIwMTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiVW5leHBlY3RlZCBzdGFzaCByZXNwb25zZTogJyVzJyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE5OTAKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MjAyMQogIywgYy1mb3JtYXQKIG1zZ2lkICJDb3VsZCBub3QgY3JlYXRlIGRpcmVjdG9yeSBmb3IgJyVzJyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE5OTMKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MjAyNAogIywgYy1mb3JtYXQKIG1zZ2lkICJDcmVhdGVkIGF1dG9zdGFzaDogJXNcbiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE5OTYKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MjAyNwogbXNnaWQgImNvdWxkIG5vdCByZXNldCAtLWhhcmQiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxOTk3IGJ1aWx0aW4vcmVzZXQuYzoxMTQKLSMsIGMtZm9ybWF0Ci1tc2dpZCAiSEVBRCBpcyBub3cgYXQgJXMiCi1tc2dzdHIgIiIKLQotIzogYnVpbHRpbi9yZWJhc2UuYzoyMDEzCisjOiBidWlsdGluL3JlYmFzZS5jOjIwMzYKIG1zZ2lkICJQbGVhc2UgY29tbWl0IG9yIHN0YXNoIHRoZW0uIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MjA0MAorIzogYnVpbHRpbi9yZWJhc2UuYzoyMDYzCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBwYXJzZSAnJXMnIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MjA1MworIzogYnVpbHRpbi9yZWJhc2UuYzoyMDc2CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBzd2l0Y2ggdG8gJXMiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoyMDY0CisjOiBidWlsdGluL3JlYmFzZS5jOjIwODcKIG1zZ2lkICJIRUFEIGlzIHVwIHRvIGRhdGUuIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MjA2NgorIzogYnVpbHRpbi9yZWJhc2UuYzoyMDg5CiAjLCBjLWZvcm1hdAogbXNnaWQgIkN1cnJlbnQgYnJhbmNoICVzIGlzIHVwIHRvIGRhdGUuXG4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoyMDc0CisjOiBidWlsdGluL3JlYmFzZS5jOjIwOTcKIG1zZ2lkICJIRUFEIGlzIHVwIHRvIGRhdGUsIHJlYmFzZSBmb3JjZWQuIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MjA3NgorIzogYnVpbHRpbi9yZWJhc2UuYzoyMDk5CiAjLCBjLWZvcm1hdAogbXNnaWQgIkN1cnJlbnQgYnJhbmNoICVzIGlzIHVwIHRvIGRhdGUsIHJlYmFzZSBmb3JjZWQuXG4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoyMDg0CisjOiBidWlsdGluL3JlYmFzZS5jOjIxMDcKIG1zZ2lkICJUaGUgcHJlLXJlYmFzZSBob29rIHJlZnVzZWQgdG8gcmViYXNlLiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjIwOTEKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MjExNAogIywgYy1mb3JtYXQKIG1zZ2lkICJDaGFuZ2VzIHRvICVzOlxuIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MjA5NAorIzogYnVpbHRpbi9yZWJhc2UuYzoyMTE3CiAjLCBjLWZvcm1hdAogbXNnaWQgIkNoYW5nZXMgZnJvbSAlcyB0byAlczpcbiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjIxMTkKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MjE0MgogIywgYy1mb3JtYXQKIG1zZ2lkICJGaXJzdCwgcmV3aW5kaW5nIGhlYWQgdG8gcmVwbGF5IHlvdXIgd29yayBvbiB0b3Agb2YgaXQuLi5cbiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjIxMjgKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MjE1MQogbXNnaWQgIkNvdWxkIG5vdCBkZXRhY2ggSEVBRCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjIxMzcKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MjE2MAogIywgYy1mb3JtYXQKIG1zZ2lkICJGYXN0LWZvcndhcmRlZCAlcyB0byAlcy5cbiIKIG1zZ3N0ciAiIgpAQCAtMTY1NzIsNyArMTY2NTQsNyBAQAogbXNnaWQgImdpdCByZWNlaXZlLXBhY2sgPGdpdC1kaXI+IgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcmVjZWl2ZS1wYWNrLmM6ODMyCisjOiBidWlsdGluL3JlY2VpdmUtcGFjay5jOjgzMAogbXNnaWQgIiIKICJCeSBkZWZhdWx0LCB1cGRhdGluZyB0aGUgY3VycmVudCBicmFuY2ggaW4gYSBub24tYmFyZSByZXBvc2l0b3J5XG4iCiAiaXMgZGVuaWVkLCBiZWNhdXNlIGl0IHdpbGwgbWFrZSB0aGUgaW5kZXggYW5kIHdvcmsgdHJlZSBpbmNvbnNpc3RlbnRcbiIKQEAgLTE2NTg5LDcgKzE2NjcxLDcgQEAKICIncmVjZWl2ZS5kZW55Q3VycmVudEJyYW5jaCcgY29uZmlndXJhdGlvbiB2YXJpYWJsZSB0byAncmVmdXNlJy4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9yZWNlaXZlLXBhY2suYzo4NTIKKyM6IGJ1aWx0aW4vcmVjZWl2ZS1wYWNrLmM6ODUwCiBtc2dpZCAiIgogIkJ5IGRlZmF1bHQsIGRlbGV0aW5nIHRoZSBjdXJyZW50IGJyYW5jaCBpcyBkZW5pZWQsIGJlY2F1c2UgdGhlIG5leHRcbiIKICInZ2l0IGNsb25lJyB3b24ndCByZXN1bHQgaW4gYW55IGZpbGUgY2hlY2tlZCBvdXQsIGNhdXNpbmcgY29uZnVzaW9uLlxuIgpAQCAtMTY2MDEsMTEgKzE2NjgzLDExIEBACiAiVG8gc3F1ZWxjaCB0aGlzIG1lc3NhZ2UsIHlvdSBjYW4gc2V0IGl0IHRvICdyZWZ1c2UnLiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3JlY2VpdmUtcGFjay5jOjE5MzgKKyM6IGJ1aWx0aW4vcmVjZWl2ZS1wYWNrLmM6MTkzNgogbXNnaWQgInF1aWV0IgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcmVjZWl2ZS1wYWNrLmM6MTk1MgorIzogYnVpbHRpbi9yZWNlaXZlLXBhY2suYzoxOTUwCiBtc2dpZCAiWW91IG11c3Qgc3BlY2lmeSBhIGRpcmVjdG9yeS4iCiBtc2dzdHIgIiIKIApAQCAtMTcxNTgsMTIxICsxNzI0MCwxMjEgQEAKIG1zZ2lkICJVbmtub3duIHN1YmNvbW1hbmQ6ICVzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MjIKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6MjMKIG1zZ2lkICJnaXQgcmVwYWNrIFs8b3B0aW9ucz5dIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MjcKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6MjgKIG1zZ2lkICIiCiAiSW5jcmVtZW50YWwgcmVwYWNrcyBhcmUgaW5jb21wYXRpYmxlIHdpdGggYml0bWFwIGluZGV4ZXMuICBVc2VcbiIKICItLW5vLXdyaXRlLWJpdG1hcC1pbmRleCBvciBkaXNhYmxlIHRoZSBwYWNrLndyaXRlYml0bWFwcyBjb25maWd1cmF0aW9uLiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjE5MAorIzogYnVpbHRpbi9yZXBhY2suYzoxOTEKIG1zZ2lkICJjb3VsZCBub3Qgc3RhcnQgcGFjay1vYmplY3RzIHRvIHJlcGFjayBwcm9taXNvciBvYmplY3RzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MjI5IGJ1aWx0aW4vcmVwYWNrLmM6NDA4CisjOiBidWlsdGluL3JlcGFjay5jOjIzMCBidWlsdGluL3JlcGFjay5jOjQwOQogbXNnaWQgInJlcGFjazogRXhwZWN0aW5nIGZ1bGwgaGV4IG9iamVjdCBJRCBsaW5lcyBvbmx5IGZyb20gcGFjay1vYmplY3RzLiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjI0NgorIzogYnVpbHRpbi9yZXBhY2suYzoyNDcKIG1zZ2lkICJjb3VsZCBub3QgZmluaXNoIHBhY2stb2JqZWN0cyB0byByZXBhY2sgcHJvbWlzb3Igb2JqZWN0cyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjI4NAorIzogYnVpbHRpbi9yZXBhY2suYzoyODUKIG1zZ2lkICJwYWNrIGV2ZXJ5dGhpbmcgaW4gYSBzaW5nbGUgcGFjayIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjI4NgorIzogYnVpbHRpbi9yZXBhY2suYzoyODcKIG1zZ2lkICJzYW1lIGFzIC1hLCBhbmQgdHVybiB1bnJlYWNoYWJsZSBvYmplY3RzIGxvb3NlIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6Mjg5CisjOiBidWlsdGluL3JlcGFjay5jOjI5MAogbXNnaWQgInJlbW92ZSByZWR1bmRhbnQgcGFja3MsIGFuZCBydW4gZ2l0LXBydW5lLXBhY2tlZCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjI5MQorIzogYnVpbHRpbi9yZXBhY2suYzoyOTIKIG1zZ2lkICJwYXNzIC0tbm8tcmV1c2UtZGVsdGEgdG8gZ2l0LXBhY2stb2JqZWN0cyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjI5MworIzogYnVpbHRpbi9yZXBhY2suYzoyOTQKIG1zZ2lkICJwYXNzIC0tbm8tcmV1c2Utb2JqZWN0IHRvIGdpdC1wYWNrLW9iamVjdHMiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9yZXBhY2suYzoyOTUKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6Mjk2CiBtc2dpZCAiZG8gbm90IHJ1biBnaXQtdXBkYXRlLXNlcnZlci1pbmZvIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6Mjk4CisjOiBidWlsdGluL3JlcGFjay5jOjI5OQogbXNnaWQgInBhc3MgLS1sb2NhbCB0byBnaXQtcGFjay1vYmplY3RzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MzAwCisjOiBidWlsdGluL3JlcGFjay5jOjMwMQogbXNnaWQgIndyaXRlIGJpdG1hcCBpbmRleCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjMwMgorIzogYnVpbHRpbi9yZXBhY2suYzozMDMKIG1zZ2lkICJwYXNzIC0tZGVsdGEtaXNsYW5kcyB0byBnaXQtcGFjay1vYmplY3RzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MzAzCisjOiBidWlsdGluL3JlcGFjay5jOjMwNAogbXNnaWQgImFwcHJveGlkYXRlIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MzA0CisjOiBidWlsdGluL3JlcGFjay5jOjMwNQogbXNnaWQgIndpdGggLUEsIGRvIG5vdCBsb29zZW4gb2JqZWN0cyBvbGRlciB0aGFuIHRoaXMiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9yZXBhY2suYzozMDYKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6MzA3CiBtc2dpZCAid2l0aCAtYSwgcmVwYWNrIHVucmVhY2hhYmxlIG9iamVjdHMiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9yZXBhY2suYzozMDgKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6MzA5CiBtc2dpZCAic2l6ZSBvZiB0aGUgd2luZG93IHVzZWQgZm9yIGRlbHRhIGNvbXByZXNzaW9uIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MzA5IGJ1aWx0aW4vcmVwYWNrLmM6MzE1CisjOiBidWlsdGluL3JlcGFjay5jOjMxMCBidWlsdGluL3JlcGFjay5jOjMxNgogbXNnaWQgImJ5dGVzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MzEwCisjOiBidWlsdGluL3JlcGFjay5jOjMxMQogbXNnaWQgInNhbWUgYXMgdGhlIGFib3ZlLCBidXQgbGltaXQgbWVtb3J5IHNpemUgaW5zdGVhZCBvZiBlbnRyaWVzIGNvdW50IgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MzEyCisjOiBidWlsdGluL3JlcGFjay5jOjMxMwogbXNnaWQgImxpbWl0cyB0aGUgbWF4aW11bSBkZWx0YSBkZXB0aCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjMxNAorIzogYnVpbHRpbi9yZXBhY2suYzozMTUKIG1zZ2lkICJsaW1pdHMgdGhlIG1heGltdW0gbnVtYmVyIG9mIHRocmVhZHMiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9yZXBhY2suYzozMTYKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6MzE3CiBtc2dpZCAibWF4aW11bSBzaXplIG9mIGVhY2ggcGFja2ZpbGUiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9yZXBhY2suYzozMTgKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6MzE5CiBtc2dpZCAicmVwYWNrIG9iamVjdHMgaW4gcGFja3MgbWFya2VkIHdpdGggLmtlZXAiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9yZXBhY2suYzozMjAKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6MzIxCiBtc2dpZCAiZG8gbm90IHJlcGFjayB0aGlzIHBhY2siCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9yZXBhY2suYzozMzAKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6MzMxCiBtc2dpZCAiY2Fubm90IGRlbGV0ZSBwYWNrcyBpbiBhIHByZWNpb3VzLW9iamVjdHMgcmVwbyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjMzNAorIzogYnVpbHRpbi9yZXBhY2suYzozMzUKIG1zZ2lkICItLWtlZXAtdW5yZWFjaGFibGUgYW5kIC1BIGFyZSBpbmNvbXBhdGlibGUiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9yZXBhY2suYzo0MTcKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6NDE4CiBtc2dpZCAiTm90aGluZyBuZXcgdG8gcGFjay4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9yZXBhY2suYzo0NzgKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6NDc5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJXQVJOSU5HOiBTb21lIHBhY2tzIGluIHVzZSBoYXZlIGJlZW4gcmVuYW1lZCBieVxuIgpAQCAtMTcyODQsNyArMTczNjYsNyBAQAogIldBUk5JTkc6IFBsZWFzZSByZW5hbWUgdGhlbSBpbiAlcyBtYW51YWxseTpcbiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjUyNgorIzogYnVpbHRpbi9yZXBhY2suYzo1MjcKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIHJlbW92ZSAnJXMnIgogbXNnc3RyICIiCkBAIC0xNzM4Nyw4ICsxNzQ2OSw4IEBACiBtc2dpZCAidW5hYmxlIHRvIHdyaXRlIG9iamVjdCB0byBkYXRhYmFzZSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzozMjIgYnVpbHRpbi9yZXBsYWNlLmM6Mzc3IGJ1aWx0aW4vcmVwbGFjZS5jOjQyMgotIzogYnVpbHRpbi9yZXBsYWNlLmM6NDUyCisjOiBidWlsdGluL3JlcGxhY2UuYzozMjIgYnVpbHRpbi9yZXBsYWNlLmM6Mzc4IGJ1aWx0aW4vcmVwbGFjZS5jOjQyMworIzogYnVpbHRpbi9yZXBsYWNlLmM6NDUzCiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vdCBhIHZhbGlkIG9iamVjdCBuYW1lOiAnJXMnIgogbXNnc3RyICIiCkBAIC0xNzQwNywxMjQgKzE3NDg5LDEyNCBAQAogbXNnaWQgIm5ldyBvYmplY3QgaXMgdGhlIHNhbWUgYXMgdGhlIG9sZCBvbmU6ICclcyciCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6MzgzCisjOiBidWlsdGluL3JlcGxhY2UuYzozODQKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHBhcnNlICVzIGFzIGEgY29tbWl0IgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjQxNAorIzogYnVpbHRpbi9yZXBsYWNlLmM6NDE1CiAjLCBjLWZvcm1hdAogbXNnaWQgImJhZCBtZXJnZXRhZyBpbiBjb21taXQgJyVzJyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo0MTYKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjQxNwogIywgYy1mb3JtYXQKIG1zZ2lkICJtYWxmb3JtZWQgbWVyZ2V0YWcgaW4gY29tbWl0ICclcyciCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NDI4CisjOiBidWlsdGluL3JlcGxhY2UuYzo0MjkKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIm9yaWdpbmFsIGNvbW1pdCAnJXMnIGNvbnRhaW5zIG1lcmdldGFnICclcycgdGhhdCBpcyBkaXNjYXJkZWQ7IHVzZSAtLWVkaXQgIgogImluc3RlYWQgb2YgLS1ncmFmdCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo0NjcKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjQ2OAogIywgYy1mb3JtYXQKIG1zZ2lkICJ0aGUgb3JpZ2luYWwgY29tbWl0ICclcycgaGFzIGEgZ3BnIHNpZ25hdHVyZSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo0NjgKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjQ2OQogbXNnaWQgInRoZSBzaWduYXR1cmUgd2lsbCBiZSByZW1vdmVkIGluIHRoZSByZXBsYWNlbWVudCBjb21taXQhIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjQ3OAorIzogYnVpbHRpbi9yZXBsYWNlLmM6NDc5CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCB3cml0ZSByZXBsYWNlbWVudCBjb21taXQgZm9yOiAnJXMnIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjQ4NgorIzogYnVpbHRpbi9yZXBsYWNlLmM6NDg3CiAjLCBjLWZvcm1hdAogbXNnaWQgImdyYWZ0IGZvciAnJXMnIHVubmVjZXNzYXJ5IgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjQ5MAorIzogYnVpbHRpbi9yZXBsYWNlLmM6NDkxCiAjLCBjLWZvcm1hdAogbXNnaWQgIm5ldyBjb21taXQgaXMgdGhlIHNhbWUgYXMgdGhlIG9sZCBvbmU6ICclcyciCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NTI1CisjOiBidWlsdGluL3JlcGxhY2UuYzo1MjYKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogImNvdWxkIG5vdCBjb252ZXJ0IHRoZSBmb2xsb3dpbmcgZ3JhZnQocyk6XG4iCiAiJXMiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NTQ2CisjOiBidWlsdGluL3JlcGxhY2UuYzo1NDcKIG1zZ2lkICJsaXN0IHJlcGxhY2UgcmVmcyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo1NDcKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU0OAogbXNnaWQgImRlbGV0ZSByZXBsYWNlIHJlZnMiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NTQ4CisjOiBidWlsdGluL3JlcGxhY2UuYzo1NDkKIG1zZ2lkICJlZGl0IGV4aXN0aW5nIG9iamVjdCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo1NDkKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU1MAogbXNnaWQgImNoYW5nZSBhIGNvbW1pdCdzIHBhcmVudHMiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NTUwCisjOiBidWlsdGluL3JlcGxhY2UuYzo1NTEKIG1zZ2lkICJjb252ZXJ0IGV4aXN0aW5nIGdyYWZ0IGZpbGUiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NTUxCisjOiBidWlsdGluL3JlcGxhY2UuYzo1NTIKIG1zZ2lkICJyZXBsYWNlIHRoZSByZWYgaWYgaXQgZXhpc3RzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU1MworIzogYnVpbHRpbi9yZXBsYWNlLmM6NTU0CiBtc2dpZCAiZG8gbm90IHByZXR0eS1wcmludCBjb250ZW50cyBmb3IgLS1lZGl0IgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU1NAorIzogYnVpbHRpbi9yZXBsYWNlLmM6NTU1CiBtc2dpZCAidXNlIHRoaXMgZm9ybWF0IgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU2NworIzogYnVpbHRpbi9yZXBsYWNlLmM6NTY4CiBtc2dpZCAiLS1mb3JtYXQgY2Fubm90IGJlIHVzZWQgd2hlbiBub3QgbGlzdGluZyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo1NzUKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU3NgogbXNnaWQgIi1mIG9ubHkgbWFrZXMgc2Vuc2Ugd2hlbiB3cml0aW5nIGEgcmVwbGFjZW1lbnQiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NTc5CisjOiBidWlsdGluL3JlcGxhY2UuYzo1ODAKIG1zZ2lkICItLXJhdyBvbmx5IG1ha2VzIHNlbnNlIHdpdGggLS1lZGl0IgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU4NQorIzogYnVpbHRpbi9yZXBsYWNlLmM6NTg2CiBtc2dpZCAiLWQgbmVlZHMgYXQgbGVhc3Qgb25lIGFyZ3VtZW50IgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU5MQorIzogYnVpbHRpbi9yZXBsYWNlLmM6NTkyCiBtc2dpZCAiYmFkIG51bWJlciBvZiBhcmd1bWVudHMiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NTk3CisjOiBidWlsdGluL3JlcGxhY2UuYzo1OTgKIG1zZ2lkICItZSBuZWVkcyBleGFjdGx5IG9uZSBhcmd1bWVudCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo2MDMKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjYwNAogbXNnaWQgIi1nIG5lZWRzIGF0IGxlYXN0IG9uZSBhcmd1bWVudCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo2MDkKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjYxMAogbXNnaWQgIi0tY29udmVydC1ncmFmdC1maWxlIHRha2VzIG5vIGFyZ3VtZW50IgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjYxNQorIzogYnVpbHRpbi9yZXBsYWNlLmM6NjE2CiBtc2dpZCAib25seSBvbmUgcGF0dGVybiBjYW4gYmUgZ2l2ZW4gd2l0aCAtbCIKIG1zZ3N0ciAiIgogCkBAIC0xNzU5MSwxMyArMTc2NzMsMTggQEAKIG1zZ2lkICJGYWlsZWQgdG8gZmluZCB0cmVlIG9mICVzLiIKIG1zZ3N0ciAiIgogCisjOiBidWlsdGluL3Jlc2V0LmM6MTE0CisjLCBjLWZvcm1hdAorbXNnaWQgIkhFQUQgaXMgbm93IGF0ICVzIgorbXNnc3RyICIiCisKICM6IGJ1aWx0aW4vcmVzZXQuYzoxOTMKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ2Fubm90IGRvIGEgJXMgcmVzZXQgaW4gdGhlIG1pZGRsZSBvZiBhIG1lcmdlLiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3Jlc2V0LmM6MjkzIGJ1aWx0aW4vc3Rhc2guYzo1MTQgYnVpbHRpbi9zdGFzaC5jOjU4OQotIzogYnVpbHRpbi9zdGFzaC5jOjYxMworIzogYnVpbHRpbi9yZXNldC5jOjI5MyBidWlsdGluL3N0YXNoLmM6NTIwIGJ1aWx0aW4vc3Rhc2guYzo1OTUKKyM6IGJ1aWx0aW4vc3Rhc2guYzo2MTkKIG1zZ2lkICJiZSBxdWlldCwgb25seSByZXBvcnQgZXJyb3JzIgogbXNnc3RyICIiCiAKQEAgLTE3Njc1LDI0ICsxNzc2MiwxOSBAQAogbXNnaWQgIkNvdWxkIG5vdCB3cml0ZSBuZXcgaW5kZXggZmlsZS4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9yZXYtbGlzdC5jOjQxMgorIzogYnVpbHRpbi9yZXYtbGlzdC5jOjQxMQogbXNnaWQgImNhbm5vdCBjb21iaW5lIC0tZXhjbHVkZS1wcm9taXNvci1vYmplY3RzIGFuZCAtLW1pc3NpbmciCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9yZXYtbGlzdC5jOjQ3MworIzogYnVpbHRpbi9yZXYtbGlzdC5jOjQ3MgogbXNnaWQgIm9iamVjdCBmaWx0ZXJpbmcgcmVxdWlyZXMgLS1vYmplY3RzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcmV2LWxpc3QuYzo0NzYKLSMsIGMtZm9ybWF0Ci1tc2dpZCAiaW52YWxpZCBzcGFyc2UgdmFsdWUgJyVzJyIKLW1zZ3N0ciAiIgotCi0jOiBidWlsdGluL3Jldi1saXN0LmM6NTI3CisjOiBidWlsdGluL3Jldi1saXN0LmM6NTIyCiBtc2dpZCAicmV2LWxpc3QgZG9lcyBub3Qgc3VwcG9ydCBkaXNwbGF5IG9mIG5vdGVzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vcmV2LWxpc3QuYzo1MzAKKyM6IGJ1aWx0aW4vcmV2LWxpc3QuYzo1MjUKIG1zZ2lkICJjYW5ub3QgY29tYmluZSAtLXVzZS1iaXRtYXAtaW5kZXggd2l0aCBvYmplY3QgZmlsdGVyaW5nIgogbXNnc3RyICIiCiAKQEAgLTE4MjAwLDEzNCArMTgyODIsMTM0IEBACiBtc2dpZCAiY291bGQgbm90IHNhdmUgaW5kZXggdHJlZSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3N0YXNoLmM6NDM0CisjOiBidWlsdGluL3N0YXNoLmM6NDM2CiBtc2dpZCAiY291bGQgbm90IHJlc3RvcmUgdW50cmFja2VkIGZpbGVzIGZyb20gc3Rhc2giCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjQ0OAorIzogYnVpbHRpbi9zdGFzaC5jOjQ1MAogIywgYy1mb3JtYXQKIG1zZ2lkICJNZXJnaW5nICVzIHdpdGggJXMiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjQ1OCBnaXQtbGVnYWN5LXN0YXNoLnNoOjY4MAorIzogYnVpbHRpbi9zdGFzaC5jOjQ2MCBnaXQtbGVnYWN5LXN0YXNoLnNoOjY4MAogbXNnaWQgIkluZGV4IHdhcyBub3QgdW5zdGFzaGVkLiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3N0YXNoLmM6NTE2IGJ1aWx0aW4vc3Rhc2guYzo2MTUKKyM6IGJ1aWx0aW4vc3Rhc2guYzo1MjIgYnVpbHRpbi9zdGFzaC5jOjYyMQogbXNnaWQgImF0dGVtcHQgdG8gcmVjcmVhdGUgdGhlIGluZGV4IgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzo1NDkKKyM6IGJ1aWx0aW4vc3Rhc2guYzo1NTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiRHJvcHBlZCAlcyAoJXMpIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzo1NTIKKyM6IGJ1aWx0aW4vc3Rhc2guYzo1NTgKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXM6IENvdWxkIG5vdCBkcm9wIHN0YXNoIGVudHJ5IgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzo1NzcKKyM6IGJ1aWx0aW4vc3Rhc2guYzo1ODMKICMsIGMtZm9ybWF0CiBtc2dpZCAiJyVzJyBpcyBub3QgYSBzdGFzaCByZWZlcmVuY2UiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjYyNyBnaXQtbGVnYWN5LXN0YXNoLnNoOjY5NAorIzogYnVpbHRpbi9zdGFzaC5jOjYzMyBnaXQtbGVnYWN5LXN0YXNoLnNoOjY5NAogbXNnaWQgIlRoZSBzdGFzaCBlbnRyeSBpcyBrZXB0IGluIGNhc2UgeW91IG5lZWQgaXQgYWdhaW4uIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzo2NTAgZ2l0LWxlZ2FjeS1zdGFzaC5zaDo3MTIKKyM6IGJ1aWx0aW4vc3Rhc2guYzo2NTYgZ2l0LWxlZ2FjeS1zdGFzaC5zaDo3MTIKIG1zZ2lkICJObyBicmFuY2ggbmFtZSBzcGVjaWZpZWQiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjc5MCBidWlsdGluL3N0YXNoLmM6ODI3CisjOiBidWlsdGluL3N0YXNoLmM6Nzk2IGJ1aWx0aW4vc3Rhc2guYzo4MzMKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ2Fubm90IHVwZGF0ZSAlcyB3aXRoICVzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzo4MDggYnVpbHRpbi9zdGFzaC5jOjE0NjEgYnVpbHRpbi9zdGFzaC5jOjE0OTcKKyM6IGJ1aWx0aW4vc3Rhc2guYzo4MTQgYnVpbHRpbi9zdGFzaC5jOjE0NzAgYnVpbHRpbi9zdGFzaC5jOjE1MDYKIG1zZ2lkICJzdGFzaCBtZXNzYWdlIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzo4MTgKKyM6IGJ1aWx0aW4vc3Rhc2guYzo4MjQKIG1zZ2lkICJcImdpdCBzdGFzaCBzdG9yZVwiIHJlcXVpcmVzIG9uZSA8Y29tbWl0PiBhcmd1bWVudCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3N0YXNoLmM6MTA0MCBnaXQtbGVnYWN5LXN0YXNoLnNoOjIxNworIzogYnVpbHRpbi9zdGFzaC5jOjEwNDYgZ2l0LWxlZ2FjeS1zdGFzaC5zaDoyMTcKIG1zZ2lkICJObyBjaGFuZ2VzIHNlbGVjdGVkIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzoxMTM2IGdpdC1sZWdhY3ktc3Rhc2guc2g6MTUwCisjOiBidWlsdGluL3N0YXNoLmM6MTE0NSBnaXQtbGVnYWN5LXN0YXNoLnNoOjE1MAogbXNnaWQgIllvdSBkbyBub3QgaGF2ZSB0aGUgaW5pdGlhbCBjb21taXQgeWV0IgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzoxMTYzIGdpdC1sZWdhY3ktc3Rhc2guc2g6MTY1CisjOiBidWlsdGluL3N0YXNoLmM6MTE3MiBnaXQtbGVnYWN5LXN0YXNoLnNoOjE2NQogbXNnaWQgIkNhbm5vdCBzYXZlIHRoZSBjdXJyZW50IGluZGV4IHN0YXRlIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzoxMTcyIGdpdC1sZWdhY3ktc3Rhc2guc2g6MTgwCisjOiBidWlsdGluL3N0YXNoLmM6MTE4MSBnaXQtbGVnYWN5LXN0YXNoLnNoOjE4MAogbXNnaWQgIkNhbm5vdCBzYXZlIHRoZSB1bnRyYWNrZWQgZmlsZXMiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjExODMgYnVpbHRpbi9zdGFzaC5jOjExOTIgZ2l0LWxlZ2FjeS1zdGFzaC5zaDoyMDAKKyM6IGJ1aWx0aW4vc3Rhc2guYzoxMTkyIGJ1aWx0aW4vc3Rhc2guYzoxMjAxIGdpdC1sZWdhY3ktc3Rhc2guc2g6MjAwCiAjOiBnaXQtbGVnYWN5LXN0YXNoLnNoOjIxMwogbXNnaWQgIkNhbm5vdCBzYXZlIHRoZSBjdXJyZW50IHdvcmt0cmVlIHN0YXRlIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzoxMjIwIGdpdC1sZWdhY3ktc3Rhc2guc2g6MjMzCisjOiBidWlsdGluL3N0YXNoLmM6MTIyOSBnaXQtbGVnYWN5LXN0YXNoLnNoOjIzMwogbXNnaWQgIkNhbm5vdCByZWNvcmQgd29ya2luZyB0cmVlIHN0YXRlIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzoxMjY5IGdpdC1sZWdhY3ktc3Rhc2guc2g6MzM3CisjOiBidWlsdGluL3N0YXNoLmM6MTI3OCBnaXQtbGVnYWN5LXN0YXNoLnNoOjMzNwogbXNnaWQgIkNhbid0IHVzZSAtLXBhdGNoIGFuZCAtLWluY2x1ZGUtdW50cmFja2VkIG9yIC0tYWxsIGF0IHRoZSBzYW1lIHRpbWUiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjEyODUKKyM6IGJ1aWx0aW4vc3Rhc2guYzoxMjk0CiBtc2dpZCAiRGlkIHlvdSBmb3JnZXQgdG8gJ2dpdCBhZGQnPyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3N0YXNoLmM6MTMwMCBnaXQtbGVnYWN5LXN0YXNoLnNoOjM0NQorIzogYnVpbHRpbi9zdGFzaC5jOjEzMDkgZ2l0LWxlZ2FjeS1zdGFzaC5zaDozNDUKIG1zZ2lkICJObyBsb2NhbCBjaGFuZ2VzIHRvIHNhdmUiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjEzMDcgZ2l0LWxlZ2FjeS1zdGFzaC5zaDozNTAKKyM6IGJ1aWx0aW4vc3Rhc2guYzoxMzE2IGdpdC1sZWdhY3ktc3Rhc2guc2g6MzUwCiBtc2dpZCAiQ2Fubm90IGluaXRpYWxpemUgc3Rhc2giCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjEzMjIgZ2l0LWxlZ2FjeS1zdGFzaC5zaDozNTQKKyM6IGJ1aWx0aW4vc3Rhc2guYzoxMzMxIGdpdC1sZWdhY3ktc3Rhc2guc2g6MzU0CiBtc2dpZCAiQ2Fubm90IHNhdmUgdGhlIGN1cnJlbnQgc3RhdHVzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzoxMzI3CisjOiBidWlsdGluL3N0YXNoLmM6MTMzNgogIywgYy1mb3JtYXQKIG1zZ2lkICJTYXZlZCB3b3JraW5nIGRpcmVjdG9yeSBhbmQgaW5kZXggc3RhdGUgJXMiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjE0MTcgZ2l0LWxlZ2FjeS1zdGFzaC5zaDozODQKKyM6IGJ1aWx0aW4vc3Rhc2guYzoxNDI2IGdpdC1sZWdhY3ktc3Rhc2guc2g6Mzg0CiBtc2dpZCAiQ2Fubm90IHJlbW92ZSB3b3JrdHJlZSBjaGFuZ2VzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzoxNDUyIGJ1aWx0aW4vc3Rhc2guYzoxNDg4CisjOiBidWlsdGluL3N0YXNoLmM6MTQ2MSBidWlsdGluL3N0YXNoLmM6MTQ5NwogbXNnaWQgImtlZXAgaW5kZXgiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjE0NTQgYnVpbHRpbi9zdGFzaC5jOjE0OTAKKyM6IGJ1aWx0aW4vc3Rhc2guYzoxNDYzIGJ1aWx0aW4vc3Rhc2guYzoxNDk5CiBtc2dpZCAic3Rhc2ggaW4gcGF0Y2ggbW9kZSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3N0YXNoLmM6MTQ1NSBidWlsdGluL3N0YXNoLmM6MTQ5MQorIzogYnVpbHRpbi9zdGFzaC5jOjE0NjQgYnVpbHRpbi9zdGFzaC5jOjE1MDAKIG1zZ2lkICJxdWlldCBtb2RlIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzoxNDU3IGJ1aWx0aW4vc3Rhc2guYzoxNDkzCisjOiBidWlsdGluL3N0YXNoLmM6MTQ2NiBidWlsdGluL3N0YXNoLmM6MTUwMgogbXNnaWQgImluY2x1ZGUgdW50cmFja2VkIGZpbGVzIGluIHN0YXNoIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzoxNDU5IGJ1aWx0aW4vc3Rhc2guYzoxNDk1CisjOiBidWlsdGluL3N0YXNoLmM6MTQ2OCBidWlsdGluL3N0YXNoLmM6MTUwNAogbXNnaWQgImluY2x1ZGUgaWdub3JlIGZpbGVzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzoxNTU1CisjOiBidWlsdGluL3N0YXNoLmM6MTU2NAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgZXhlYyAlcyIKIG1zZ3N0ciAiIgpAQCAtMTg2NzgsNyArMTg3NjAsNyBAQAogbXNnc3RyICIiCiAKICM6IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxODc3Ci1tc2dpZCAiZ2l0IHN1Ym1vZHVsZS0taGVscGVyIHVwZGF0ZV9jbG9uZSBbLS1wcmVmaXg9PHBhdGg+XSBbPHBhdGg+Li4uXSIKK21zZ2lkICJnaXQgc3VibW9kdWxlLS1oZWxwZXIgdXBkYXRlLWNsb25lIFstLXByZWZpeD08cGF0aD5dIFs8cGF0aD4uLi5dIgogbXNnc3RyICIiCiAKICM6IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxODkwCkBAIC0xODczMCw3ICsxODgxMiw3IEBACiBtc2dpZCAicGxlYXNlIG1ha2Ugc3VyZSB0aGF0IHRoZSAuZ2l0bW9kdWxlcyBmaWxlIGlzIGluIHRoZSB3b3JraW5nIHRyZWUiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjIyMzUgZ2l0LmM6NDM0IGdpdC5jOjY4NAorIzogYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjIyMzUgZ2l0LmM6NDMzIGdpdC5jOjY4MwogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyBkb2Vzbid0IHN1cHBvcnQgLS1zdXBlci1wcmVmaXgiCiBtc2dzdHIgIiIKQEAgLTE5MDMyLDE4NSArMTkxMTQsMTg1IEBACiBtc2dpZCAiZ2l0IHVwZGF0ZS1pbmRleCBbPG9wdGlvbnM+XSBbLS1dIFs8ZmlsZT4uLi5dIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6OTcxCisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjk3MgogbXNnaWQgImNvbnRpbnVlIHJlZnJlc2ggZXZlbiB3aGVuIGluZGV4IG5lZWRzIHVwZGF0ZSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjk3NAorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzo5NzUKIG1zZ2lkICJyZWZyZXNoOiBpZ25vcmUgc3VibW9kdWxlcyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjk3NworIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzo5NzgKIG1zZ2lkICJkbyBub3QgaWdub3JlIG5ldyBmaWxlcyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjk3OQorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzo5ODAKIG1zZ2lkICJsZXQgZmlsZXMgcmVwbGFjZSBkaXJlY3RvcmllcyBhbmQgdmljZS12ZXJzYSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjk4MQorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzo5ODIKIG1zZ2lkICJub3RpY2UgZmlsZXMgbWlzc2luZyBmcm9tIHdvcmt0cmVlIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6OTgzCisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjk4NAogbXNnaWQgInJlZnJlc2ggZXZlbiBpZiBpbmRleCBjb250YWlucyB1bm1lcmdlZCBlbnRyaWVzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6OTg2CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjk4NwogbXNnaWQgInJlZnJlc2ggc3RhdCBpbmZvcm1hdGlvbiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjk5MAorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzo5OTEKIG1zZ2lkICJsaWtlIC0tcmVmcmVzaCwgYnV0IGlnbm9yZSBhc3N1bWUtdW5jaGFuZ2VkIHNldHRpbmciCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzo5OTQKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6OTk1CiBtc2dpZCAiPG1vZGU+LDxvYmplY3Q+LDxwYXRoPiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjk5NQorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzo5OTYKIG1zZ2lkICJhZGQgdGhlIHNwZWNpZmllZCBlbnRyeSB0byB0aGUgaW5kZXgiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDA1CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMDYKIG1zZ2lkICJtYXJrIGZpbGVzIGFzIFwibm90IGNoYW5naW5nXCIiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDA4CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMDkKIG1zZ2lkICJjbGVhciBhc3N1bWVkLXVuY2hhbmdlZCBiaXQiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDExCisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMTIKIG1zZ2lkICJtYXJrIGZpbGVzIGFzIFwiaW5kZXgtb25seVwiIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAxNAorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDE1CiBtc2dpZCAiY2xlYXIgc2tpcC13b3JrdHJlZSBiaXQiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDE3CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMTgKIG1zZ2lkICJhZGQgdG8gaW5kZXggb25seTsgZG8gbm90IGFkZCBjb250ZW50IHRvIG9iamVjdCBkYXRhYmFzZSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMTkKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAyMAogbXNnaWQgInJlbW92ZSBuYW1lZCBwYXRocyBldmVuIGlmIHByZXNlbnQgaW4gd29ya3RyZWUiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDIxCisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMjIKIG1zZ2lkICJ3aXRoIC0tc3RkaW46IGlucHV0IGxpbmVzIGFyZSB0ZXJtaW5hdGVkIGJ5IG51bGwgYnl0ZXMiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDIzCisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMjQKIG1zZ2lkICJyZWFkIGxpc3Qgb2YgcGF0aHMgdG8gYmUgdXBkYXRlZCBmcm9tIHN0YW5kYXJkIGlucHV0IgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAyNworIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDI4CiBtc2dpZCAiYWRkIGVudHJpZXMgZnJvbSBzdGFuZGFyZCBpbnB1dCB0byB0aGUgaW5kZXgiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDMxCisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMzIKIG1zZ2lkICJyZXBvcHVsYXRlIHN0YWdlcyAjMiBhbmQgIzMgZm9yIHRoZSBsaXN0ZWQgcGF0aHMiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDM1CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMzYKIG1zZ2lkICJvbmx5IHVwZGF0ZSBlbnRyaWVzIHRoYXQgZGlmZmVyIGZyb20gSEVBRCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMzkKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTA0MAogbXNnaWQgImlnbm9yZSBmaWxlcyBtaXNzaW5nIGZyb20gd29ya3RyZWUiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDQyCisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwNDMKIG1zZ2lkICJyZXBvcnQgYWN0aW9ucyB0byBzdGFuZGFyZCBvdXRwdXQiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDQ0CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwNDUKIG1zZ2lkICIoZm9yIHBvcmNlbGFpbnMpIGZvcmdldCBzYXZlZCB1bnJlc29sdmVkIGNvbmZsaWN0cyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwNDgKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTA0OQogbXNnaWQgIndyaXRlIGluZGV4IGluIHRoaXMgZm9ybWF0IgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTA1MAorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDUxCiBtc2dpZCAiZW5hYmxlIG9yIGRpc2FibGUgc3BsaXQgaW5kZXgiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDUyCisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwNTMKIG1zZ2lkICJlbmFibGUvZGlzYWJsZSB1bnRyYWNrZWQgY2FjaGUiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDU0CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwNTUKIG1zZ2lkICJ0ZXN0IGlmIHRoZSBmaWxlc3lzdGVtIHN1cHBvcnRzIHVudHJhY2tlZCBjYWNoZSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwNTYKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTA1NwogbXNnaWQgImVuYWJsZSB1bnRyYWNrZWQgY2FjaGUgd2l0aG91dCB0ZXN0aW5nIHRoZSBmaWxlc3lzdGVtIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTA1OAorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDU5CiBtc2dpZCAid3JpdGUgb3V0IHRoZSBpbmRleCBldmVuIGlmIGlzIG5vdCBmbGFnZ2VkIGFzIGNoYW5nZWQiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDYwCisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwNjEKIG1zZ2lkICJlbmFibGUgb3IgZGlzYWJsZSBmaWxlIHN5c3RlbSBtb25pdG9yIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTA2MgorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDYzCiBtc2dpZCAibWFyayBmaWxlcyBhcyBmc21vbml0b3IgdmFsaWQiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDY1CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwNjYKIG1zZ2lkICJjbGVhciBmc21vbml0b3IgdmFsaWQgYml0IgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTE2OAorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMTY5CiBtc2dpZCAiIgogImNvcmUuc3BsaXRJbmRleCBpcyBzZXQgdG8gZmFsc2U7IHJlbW92ZSBvciBjaGFuZ2UgaXQsIGlmIHlvdSByZWFsbHkgd2FudCB0byAiCiAiZW5hYmxlIHNwbGl0IGluZGV4IgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTE3NworIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMTc4CiBtc2dpZCAiIgogImNvcmUuc3BsaXRJbmRleCBpcyBzZXQgdG8gdHJ1ZTsgcmVtb3ZlIG9yIGNoYW5nZSBpdCwgaWYgeW91IHJlYWxseSB3YW50IHRvICIKICJkaXNhYmxlIHNwbGl0IGluZGV4IgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTE4OAorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMTkwCiBtc2dpZCAiIgogImNvcmUudW50cmFja2VkQ2FjaGUgaXMgc2V0IHRvIHRydWU7IHJlbW92ZSBvciBjaGFuZ2UgaXQsIGlmIHlvdSByZWFsbHkgd2FudCAiCiAidG8gZGlzYWJsZSB0aGUgdW50cmFja2VkIGNhY2hlIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTE5MgorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMTk0CiBtc2dpZCAiVW50cmFja2VkIGNhY2hlIGRpc2FibGVkIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTIwMAorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMjAyCiBtc2dpZCAiIgogImNvcmUudW50cmFja2VkQ2FjaGUgaXMgc2V0IHRvIGZhbHNlOyByZW1vdmUgb3IgY2hhbmdlIGl0LCBpZiB5b3UgcmVhbGx5IHdhbnQgIgogInRvIGVuYWJsZSB0aGUgdW50cmFja2VkIGNhY2hlIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTIwNAorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMjA2CiAjLCBjLWZvcm1hdAogbXNnaWQgIlVudHJhY2tlZCBjYWNoZSBlbmFibGVkIGZvciAnJXMnIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTIxMgorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMjE0CiBtc2dpZCAiY29yZS5mc21vbml0b3IgaXMgdW5zZXQ7IHNldCBpdCBpZiB5b3UgcmVhbGx5IHdhbnQgdG8gZW5hYmxlIGZzbW9uaXRvciIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEyMTYKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTIxOAogbXNnaWQgImZzbW9uaXRvciBlbmFibGVkIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTIxOQorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMjIxCiBtc2dpZCAiIgogImNvcmUuZnNtb25pdG9yIGlzIHNldDsgcmVtb3ZlIGl0IGlmIHlvdSByZWFsbHkgd2FudCB0byBkaXNhYmxlIGZzbW9uaXRvciIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEyMjMKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTIyNQogbXNnaWQgImZzbW9uaXRvciBkaXNhYmxlZCIKIG1zZ3N0ciAiIgogCkBAIC0xOTMwMiwyNzIgKzE5Mzg0LDI3MiBAQAogbXNnaWQgInByaW50IHRhZyBjb250ZW50cyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6MTgKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzoxNwogbXNnaWQgImdpdCB3b3JrdHJlZSBhZGQgWzxvcHRpb25zPl0gPHBhdGg+IFs8Y29tbWl0LWlzaD5dIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzoxOQorIzogYnVpbHRpbi93b3JrdHJlZS5jOjE4CiBtc2dpZCAiZ2l0IHdvcmt0cmVlIGxpc3QgWzxvcHRpb25zPl0iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjIwCisjOiBidWlsdGluL3dvcmt0cmVlLmM6MTkKIG1zZ2lkICJnaXQgd29ya3RyZWUgbG9jayBbPG9wdGlvbnM+XSA8cGF0aD4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjIxCisjOiBidWlsdGluL3dvcmt0cmVlLmM6MjAKIG1zZ2lkICJnaXQgd29ya3RyZWUgbW92ZSA8d29ya3RyZWU+IDxuZXctcGF0aD4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjIyCisjOiBidWlsdGluL3dvcmt0cmVlLmM6MjEKIG1zZ2lkICJnaXQgd29ya3RyZWUgcHJ1bmUgWzxvcHRpb25zPl0iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjIzCisjOiBidWlsdGluL3dvcmt0cmVlLmM6MjIKIG1zZ2lkICJnaXQgd29ya3RyZWUgcmVtb3ZlIFs8b3B0aW9ucz5dIDx3b3JrdHJlZT4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjI0CisjOiBidWlsdGluL3dvcmt0cmVlLmM6MjMKIG1zZ2lkICJnaXQgd29ya3RyZWUgdW5sb2NrIDxwYXRoPiIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NjEgYnVpbHRpbi93b3JrdHJlZS5jOjg5OQorIzogYnVpbHRpbi93b3JrdHJlZS5jOjYwIGJ1aWx0aW4vd29ya3RyZWUuYzo4OTgKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIGRlbGV0ZSAnJXMnIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4MAorIzogYnVpbHRpbi93b3JrdHJlZS5jOjc5CiAjLCBjLWZvcm1hdAogbXNnaWQgIlJlbW92aW5nIHdvcmt0cmVlcy8lczogbm90IGEgdmFsaWQgZGlyZWN0b3J5IgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4NgorIzogYnVpbHRpbi93b3JrdHJlZS5jOjg1CiAjLCBjLWZvcm1hdAogbXNnaWQgIlJlbW92aW5nIHdvcmt0cmVlcy8lczogZ2l0ZGlyIGZpbGUgZG9lcyBub3QgZXhpc3QiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjkxIGJ1aWx0aW4vd29ya3RyZWUuYzoxMDAKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo5MCBidWlsdGluL3dvcmt0cmVlLmM6OTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiUmVtb3Zpbmcgd29ya3RyZWVzLyVzOiB1bmFibGUgdG8gcmVhZCBnaXRkaXIgZmlsZSAoJXMpIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzoxMTAKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzoxMDkKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlJlbW92aW5nIHdvcmt0cmVlcy8lczogc2hvcnQgcmVhZCAoZXhwZWN0ZWQgJTxQUkl1TUFYPiBieXRlcywgcmVhZCAiCiAiJTxQUkl1TUFYPikiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjExOAorIzogYnVpbHRpbi93b3JrdHJlZS5jOjExNwogIywgYy1mb3JtYXQKIG1zZ2lkICJSZW1vdmluZyB3b3JrdHJlZXMvJXM6IGludmFsaWQgZ2l0ZGlyIGZpbGUiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjEyNworIzogYnVpbHRpbi93b3JrdHJlZS5jOjEyNgogIywgYy1mb3JtYXQKIG1zZ2lkICJSZW1vdmluZyB3b3JrdHJlZXMvJXM6IGdpdGRpciBmaWxlIHBvaW50cyB0byBub24tZXhpc3RlbnQgbG9jYXRpb24iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjE2NgorIzogYnVpbHRpbi93b3JrdHJlZS5jOjE2NQogbXNnaWQgInJlcG9ydCBwcnVuZWQgd29ya2luZyB0cmVlcyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6MTY4CisjOiBidWlsdGluL3dvcmt0cmVlLmM6MTY3CiBtc2dpZCAiZXhwaXJlIHdvcmtpbmcgdHJlZXMgb2xkZXIgdGhhbiA8dGltZT4iCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjIzNQorIzogYnVpbHRpbi93b3JrdHJlZS5jOjIzNAogIywgYy1mb3JtYXQKIG1zZ2lkICInJXMnIGFscmVhZHkgZXhpc3RzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzoyNTIKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzoyNTEKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHJlLWFkZCB3b3JrdHJlZSAnJXMnIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzoyNTcKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzoyNTYKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIiclcycgaXMgYSBtaXNzaW5nIGJ1dCBsb2NrZWQgd29ya3RyZWU7XG4iCiAidXNlICdhZGQgLWYgLWYnIHRvIG92ZXJyaWRlLCBvciAndW5sb2NrJyBhbmQgJ3BydW5lJyBvciAncmVtb3ZlJyB0byBjbGVhciIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6MjU5CisjOiBidWlsdGluL3dvcmt0cmVlLmM6MjU4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICInJXMnIGlzIGEgbWlzc2luZyBidXQgYWxyZWFkeSByZWdpc3RlcmVkIHdvcmt0cmVlO1xuIgogInVzZSAnYWRkIC1mJyB0byBvdmVycmlkZSwgb3IgJ3BydW5lJyBvciAncmVtb3ZlJyB0byBjbGVhciIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6MzA5CisjOiBidWlsdGluL3dvcmt0cmVlLmM6MzA4CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBjcmVhdGUgZGlyZWN0b3J5IG9mICclcyciCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjQ0MCBidWlsdGluL3dvcmt0cmVlLmM6NDQ2CisjOiBidWlsdGluL3dvcmt0cmVlLmM6NDM5IGJ1aWx0aW4vd29ya3RyZWUuYzo0NDUKICMsIGMtZm9ybWF0CiBtc2dpZCAiUHJlcGFyaW5nIHdvcmt0cmVlIChuZXcgYnJhbmNoICclcycpIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo0NDIKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo0NDEKICMsIGMtZm9ybWF0CiBtc2dpZCAiUHJlcGFyaW5nIHdvcmt0cmVlIChyZXNldHRpbmcgYnJhbmNoICclcyc7IHdhcyBhdCAlcykiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjQ1MQorIzogYnVpbHRpbi93b3JrdHJlZS5jOjQ1MAogIywgYy1mb3JtYXQKIG1zZ2lkICJQcmVwYXJpbmcgd29ya3RyZWUgKGNoZWNraW5nIG91dCAnJXMnKSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NDU3CisjOiBidWlsdGluL3dvcmt0cmVlLmM6NDU2CiAjLCBjLWZvcm1hdAogbXNnaWQgIlByZXBhcmluZyB3b3JrdHJlZSAoZGV0YWNoZWQgSEVBRCAlcykiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjQ5OAorIzogYnVpbHRpbi93b3JrdHJlZS5jOjQ5NwogbXNnaWQgImNoZWNrb3V0IDxicmFuY2g+IGV2ZW4gaWYgYWxyZWFkeSBjaGVja2VkIG91dCBpbiBvdGhlciB3b3JrdHJlZSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NTAxCisjOiBidWlsdGluL3dvcmt0cmVlLmM6NTAwCiBtc2dpZCAiY3JlYXRlIGEgbmV3IGJyYW5jaCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NTAzCisjOiBidWlsdGluL3dvcmt0cmVlLmM6NTAyCiBtc2dpZCAiY3JlYXRlIG9yIHJlc2V0IGEgYnJhbmNoIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo1MDUKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo1MDQKIG1zZ2lkICJwb3B1bGF0ZSB0aGUgbmV3IHdvcmtpbmcgdHJlZSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NTA2CisjOiBidWlsdGluL3dvcmt0cmVlLmM6NTA1CiBtc2dpZCAia2VlcCB0aGUgbmV3IHdvcmtpbmcgdHJlZSBsb2NrZWQiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjUwOQorIzogYnVpbHRpbi93b3JrdHJlZS5jOjUwOAogbXNnaWQgInNldCB1cCB0cmFja2luZyBtb2RlIChzZWUgZ2l0LWJyYW5jaCgxKSkiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjUxMgorIzogYnVpbHRpbi93b3JrdHJlZS5jOjUxMQogbXNnaWQgInRyeSB0byBtYXRjaCB0aGUgbmV3IGJyYW5jaCBuYW1lIHdpdGggYSByZW1vdGUtdHJhY2tpbmcgYnJhbmNoIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo1MjAKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo1MTkKIG1zZ2lkICItYiwgLUIsIGFuZCAtLWRldGFjaCBhcmUgbXV0dWFsbHkgZXhjbHVzaXZlIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo1ODEKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo1ODAKIG1zZ2lkICItLVtuby1ddHJhY2sgY2FuIG9ubHkgYmUgdXNlZCBpZiBhIG5ldyBicmFuY2ggaXMgY3JlYXRlZCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NjgxCisjOiBidWlsdGluL3dvcmt0cmVlLmM6NjgwCiBtc2dpZCAicmVhc29uIGZvciBsb2NraW5nIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo2OTMgYnVpbHRpbi93b3JrdHJlZS5jOjcyNiBidWlsdGluL3dvcmt0cmVlLmM6ODAwCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6OTI3CisjOiBidWlsdGluL3dvcmt0cmVlLmM6NjkyIGJ1aWx0aW4vd29ya3RyZWUuYzo3MjUgYnVpbHRpbi93b3JrdHJlZS5jOjc5OQorIzogYnVpbHRpbi93b3JrdHJlZS5jOjkyNgogIywgYy1mb3JtYXQKIG1zZ2lkICInJXMnIGlzIG5vdCBhIHdvcmtpbmcgdHJlZSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6Njk1IGJ1aWx0aW4vd29ya3RyZWUuYzo3MjgKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo2OTQgYnVpbHRpbi93b3JrdHJlZS5jOjcyNwogbXNnaWQgIlRoZSBtYWluIHdvcmtpbmcgdHJlZSBjYW5ub3QgYmUgbG9ja2VkIG9yIHVubG9ja2VkIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo3MDAKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo2OTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiJyVzJyBpcyBhbHJlYWR5IGxvY2tlZCwgcmVhc29uOiAlcyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NzAyCisjOiBidWlsdGluL3dvcmt0cmVlLmM6NzAxCiAjLCBjLWZvcm1hdAogbXNnaWQgIiclcycgaXMgYWxyZWFkeSBsb2NrZWQiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjczMAorIzogYnVpbHRpbi93b3JrdHJlZS5jOjcyOQogIywgYy1mb3JtYXQKIG1zZ2lkICInJXMnIGlzIG5vdCBsb2NrZWQiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjc3MQorIzogYnVpbHRpbi93b3JrdHJlZS5jOjc3MAogbXNnaWQgIndvcmtpbmcgdHJlZXMgY29udGFpbmluZyBzdWJtb2R1bGVzIGNhbm5vdCBiZSBtb3ZlZCBvciByZW1vdmVkIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo3NzkKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo3NzgKIG1zZ2lkICJmb3JjZSBtb3ZlIGV2ZW4gaWYgd29ya3RyZWUgaXMgZGlydHkgb3IgbG9ja2VkIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4MDIgYnVpbHRpbi93b3JrdHJlZS5jOjkyOQorIzogYnVpbHRpbi93b3JrdHJlZS5jOjgwMSBidWlsdGluL3dvcmt0cmVlLmM6OTI4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiclcycgaXMgYSBtYWluIHdvcmtpbmcgdHJlZSIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6ODA3CisjOiBidWlsdGluL3dvcmt0cmVlLmM6ODA2CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBmaWd1cmUgb3V0IGRlc3RpbmF0aW9uIG5hbWUgZnJvbSAnJXMnIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4MTMKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4MTIKICMsIGMtZm9ybWF0CiBtc2dpZCAidGFyZ2V0ICclcycgYWxyZWFkeSBleGlzdHMiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjgyMQorIzogYnVpbHRpbi93b3JrdHJlZS5jOjgyMAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiY2Fubm90IG1vdmUgYSBsb2NrZWQgd29ya2luZyB0cmVlLCBsb2NrIHJlYXNvbjogJXNcbiIKICJ1c2UgJ21vdmUgLWYgLWYnIHRvIG92ZXJyaWRlIG9yIHVubG9jayBmaXJzdCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6ODIzCisjOiBidWlsdGluL3dvcmt0cmVlLmM6ODIyCiBtc2dpZCAiIgogImNhbm5vdCBtb3ZlIGEgbG9ja2VkIHdvcmtpbmcgdHJlZTtcbiIKICJ1c2UgJ21vdmUgLWYgLWYnIHRvIG92ZXJyaWRlIG9yIHVubG9jayBmaXJzdCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6ODI2CisjOiBidWlsdGluL3dvcmt0cmVlLmM6ODI1CiAjLCBjLWZvcm1hdAogbXNnaWQgInZhbGlkYXRpb24gZmFpbGVkLCBjYW5ub3QgbW92ZSB3b3JraW5nIHRyZWU6ICVzIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4MzEKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4MzAKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIG1vdmUgJyVzJyB0byAnJXMnIgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4NzkKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4NzgKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIHJ1biAnZ2l0IHN0YXR1cycgb24gJyVzJyIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6ODgzCisjOiBidWlsdGluL3dvcmt0cmVlLmM6ODgyCiAjLCBjLWZvcm1hdAotbXNnaWQgIiclcycgaXMgZGlydHksIHVzZSAtLWZvcmNlIHRvIGRlbGV0ZSBpdCIKK21zZ2lkICInJXMnIGNvbnRhaW5zIG1vZGlmaWVkIG9yIHVudHJhY2tlZCBmaWxlcywgdXNlIC0tZm9yY2UgdG8gZGVsZXRlIGl0IgogbXNnc3RyICIiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4ODgKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4ODcKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIHJ1biAnZ2l0IHN0YXR1cycgb24gJyVzJywgY29kZSAlZCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6OTExCisjOiBidWlsdGluL3dvcmt0cmVlLmM6OTEwCiBtc2dpZCAiZm9yY2UgcmVtb3ZhbCBldmVuIGlmIHdvcmt0cmVlIGlzIGRpcnR5IG9yIGxvY2tlZCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6OTM0CisjOiBidWlsdGluL3dvcmt0cmVlLmM6OTMzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJjYW5ub3QgcmVtb3ZlIGEgbG9ja2VkIHdvcmtpbmcgdHJlZSwgbG9jayByZWFzb246ICVzXG4iCiAidXNlICdyZW1vdmUgLWYgLWYnIHRvIG92ZXJyaWRlIG9yIHVubG9jayBmaXJzdCIKIG1zZ3N0ciAiIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6OTM2CisjOiBidWlsdGluL3dvcmt0cmVlLmM6OTM1CiBtc2dpZCAiIgogImNhbm5vdCByZW1vdmUgYSBsb2NrZWQgd29ya2luZyB0cmVlO1xuIgogInVzZSAncmVtb3ZlIC1mIC1mJyB0byBvdmVycmlkZSBvciB1bmxvY2sgZmlyc3QiCiBtc2dzdHIgIiIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjkzOQorIzogYnVpbHRpbi93b3JrdHJlZS5jOjkzOAogIywgYy1mb3JtYXQKIG1zZ2lkICJ2YWxpZGF0aW9uIGZhaWxlZCwgY2Fubm90IHJlbW92ZSB3b3JraW5nIHRyZWU6ICVzIgogbXNnc3RyICIiCkBAIC0xOTU4OCw2ICsxOTY3MCwxNiBAQAogbXNnaWQgIm9ubHkgdXNlZnVsIGZvciBkZWJ1Z2dpbmciCiBtc2dzdHIgIiIKIAorIzogZmFzdC1pbXBvcnQuYzozMTE4CisjLCBjLWZvcm1hdAorbXNnaWQgIkV4cGVjdGVkICdtYXJrJyBjb21tYW5kLCBnb3QgJXMiCittc2dzdHIgIiIKKworIzogZmFzdC1pbXBvcnQuYzozMTIzCisjLCBjLWZvcm1hdAorbXNnaWQgIkV4cGVjdGVkICd0bycgY29tbWFuZCwgZ290ICVzIgorbXNnc3RyICIiCisKICM6IGNyZWRlbnRpYWwtY2FjaGUtLWRhZW1vbi5jOjIyMwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCkBAIC0xOTY4Myw1MSArMTk3NzUsNTEgQEAKICJZb3UgY2FuIHVzZSAnIWdpdCcgaW4gdGhlIGFsaWFzIHRvIGRvIHRoaXMiCiBtc2dzdHIgIiIKIAotIzogZ2l0LmM6Mzc3CisjOiBnaXQuYzozNzYKICMsIGMtZm9ybWF0CiBtc2dpZCAiZW1wdHkgYWxpYXMgZm9yICVzIgogbXNnc3RyICIiCiAKLSM6IGdpdC5jOjM4MAorIzogZ2l0LmM6Mzc5CiAjLCBjLWZvcm1hdAogbXNnaWQgInJlY3Vyc2l2ZSBhbGlhczogJXMiCiBtc2dzdHIgIiIKIAotIzogZ2l0LmM6NDYwCisjOiBnaXQuYzo0NTkKIG1zZ2lkICJ3cml0ZSBmYWlsdXJlIG9uIHN0YW5kYXJkIG91dHB1dCIKIG1zZ3N0ciAiIgogCi0jOiBnaXQuYzo0NjIKKyM6IGdpdC5jOjQ2MQogbXNnaWQgInVua25vd24gd3JpdGUgZmFpbHVyZSBvbiBzdGFuZGFyZCBvdXRwdXQiCiBtc2dzdHIgIiIKIAotIzogZ2l0LmM6NDY0CisjOiBnaXQuYzo0NjMKIG1zZ2lkICJjbG9zZSBmYWlsZWQgb24gc3RhbmRhcmQgb3V0cHV0IgogbXNnc3RyICIiCiAKLSM6IGdpdC5jOjc5MworIzogZ2l0LmM6NzkyCiAjLCBjLWZvcm1hdAogbXNnaWQgImFsaWFzIGxvb3AgZGV0ZWN0ZWQ6IGV4cGFuc2lvbiBvZiAnJXMnIGRvZXMgbm90IHRlcm1pbmF0ZTolcyIKIG1zZ3N0ciAiIgogCi0jOiBnaXQuYzo4NDMKKyM6IGdpdC5jOjg0MgogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgaGFuZGxlICVzIGFzIGEgYnVpbHRpbiIKIG1zZ3N0ciAiIgogCi0jOiBnaXQuYzo4NTYKKyM6IGdpdC5jOjg1NQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAidXNhZ2U6ICVzXG4iCiAiXG4iCiBtc2dzdHIgIiIKIAotIzogZ2l0LmM6ODc2CisjOiBnaXQuYzo4NzUKICMsIGMtZm9ybWF0CiBtc2dpZCAiZXhwYW5zaW9uIG9mIGFsaWFzICclcycgZmFpbGVkOyAnJXMnIGlzIG5vdCBhIGdpdCBjb21tYW5kXG4iCiBtc2dzdHIgIiIKIAotIzogZ2l0LmM6ODg4CisjOiBnaXQuYzo4ODcKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIHJ1biBjb21tYW5kICclcyc6ICVzXG4iCiBtc2dzdHIgIiIKQEAgLTE5NzQ1LDMwICsxOTgzNywzMCBAQAogbXNnaWQgIlB1YmxpYyBrZXkgcGlubmluZyBub3Qgc3VwcG9ydGVkIHdpdGggY1VSTCA8IDcuNDQuMCIKIG1zZ3N0ciAiIgogCi0jOiBodHRwLmM6ODc2CisjOiBodHRwLmM6ODc4CiBtc2dpZCAiQ1VSTFNTTE9QVF9OT19SRVZPS0Ugbm90IHN1cHBvcnRlZCB3aXRoIGNVUkwgPCA3LjQ0LjAiCiBtc2dzdHIgIiIKIAotIzogaHR0cC5jOjk0OQorIzogaHR0cC5jOjk1MQogbXNnaWQgIlByb3RvY29sIHJlc3RyaWN0aW9ucyBub3Qgc3VwcG9ydGVkIHdpdGggY1VSTCA8IDcuMTkuNCIKIG1zZ3N0ciAiIgogCi0jOiBodHRwLmM6MTA4NQorIzogaHR0cC5jOjEwODgKICMsIGMtZm9ybWF0CiBtc2dpZCAiVW5zdXBwb3J0ZWQgU1NMIGJhY2tlbmQgJyVzJy4gU3VwcG9ydGVkIFNTTCBiYWNrZW5kczoiCiBtc2dzdHIgIiIKIAotIzogaHR0cC5jOjEwOTIKKyM6IGh0dHAuYzoxMDk1CiAjLCBjLWZvcm1hdAogbXNnaWQgIkNvdWxkIG5vdCBzZXQgU1NMIGJhY2tlbmQgdG8gJyVzJzogY1VSTCB3YXMgYnVpbHQgd2l0aG91dCBTU0wgYmFja2VuZHMiCiBtc2dzdHIgIiIKIAotIzogaHR0cC5jOjEwOTYKKyM6IGh0dHAuYzoxMDk5CiAjLCBjLWZvcm1hdAogbXNnaWQgIkNvdWxkIG5vdCBzZXQgU1NMIGJhY2tlbmQgdG8gJyVzJzogYWxyZWFkeSBzZXQiCiBtc2dzdHIgIiIKIAotIzogaHR0cC5jOjE5NjUKKyM6IGh0dHAuYzoxOTY4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJ1bmFibGUgdG8gdXBkYXRlIHVybCBiYXNlIGZyb20gcmVkaXJlY3Rpb246XG4iCkBAIC0xOTc3NiwxMjggKzE5ODY4LDEyOCBAQAogIiAgIHJlZGlyZWN0OiAlcyIKIG1zZ3N0ciAiIgogCi0jOiByZW1vdGUtY3VybC5jOjE1NworIzogcmVtb3RlLWN1cmwuYzoxNjYKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBxdW90aW5nIGluIHB1c2gtb3B0aW9uIHZhbHVlOiAnJXMnIgogbXNnc3RyICIiCiAKLSM6IHJlbW90ZS1jdXJsLmM6MjU0CisjOiByZW1vdGUtY3VybC5jOjI2MwogIywgYy1mb3JtYXQKIG1zZ2lkICIlc2luZm8vcmVmcyBub3QgdmFsaWQ6IGlzIHRoaXMgYSBnaXQgcmVwb3NpdG9yeT8iCiBtc2dzdHIgIiIKIAotIzogcmVtb3RlLWN1cmwuYzozNTUKKyM6IHJlbW90ZS1jdXJsLmM6MzY0CiBtc2dpZCAiaW52YWxpZCBzZXJ2ZXIgcmVzcG9uc2U7IGV4cGVjdGVkIHNlcnZpY2UsIGdvdCBmbHVzaCBwYWNrZXQiCiBtc2dzdHIgIiIKIAotIzogcmVtb3RlLWN1cmwuYzozODYKKyM6IHJlbW90ZS1jdXJsLmM6Mzk1CiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgc2VydmVyIHJlc3BvbnNlOyBnb3QgJyVzJyIKIG1zZ3N0ciAiIgogCi0jOiByZW1vdGUtY3VybC5jOjQ0NgorIzogcmVtb3RlLWN1cmwuYzo0NTUKICMsIGMtZm9ybWF0CiBtc2dpZCAicmVwb3NpdG9yeSAnJXMnIG5vdCBmb3VuZCIKIG1zZ3N0ciAiIgogCi0jOiByZW1vdGUtY3VybC5jOjQ1MAorIzogcmVtb3RlLWN1cmwuYzo0NTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiQXV0aGVudGljYXRpb24gZmFpbGVkIGZvciAnJXMnIgogbXNnc3RyICIiCiAKLSM6IHJlbW90ZS1jdXJsLmM6NDU0CisjOiByZW1vdGUtY3VybC5jOjQ2MwogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gYWNjZXNzICclcyc6ICVzIgogbXNnc3RyICIiCiAKLSM6IHJlbW90ZS1jdXJsLmM6NDYwCisjOiByZW1vdGUtY3VybC5jOjQ2OQogIywgYy1mb3JtYXQKIG1zZ2lkICJyZWRpcmVjdGluZyB0byAlcyIKIG1zZ3N0ciAiIgogCi0jOiByZW1vdGUtY3VybC5jOjU4NAorIzogcmVtb3RlLWN1cmwuYzo1OTMKIG1zZ2lkICJzaG91bGRuJ3QgaGF2ZSBFT0Ygd2hlbiBub3QgZ2VudGxlIG9uIEVPRiIKIG1zZ3N0ciAiIgogCi0jOiByZW1vdGUtY3VybC5jOjY2NAorIzogcmVtb3RlLWN1cmwuYzo2NzMKIG1zZ2lkICJ1bmFibGUgdG8gcmV3aW5kIHJwYyBwb3N0IGRhdGEgLSB0cnkgaW5jcmVhc2luZyBodHRwLnBvc3RCdWZmZXIiCiBtc2dzdHIgIiIKIAotIzogcmVtb3RlLWN1cmwuYzo3MjQKKyM6IHJlbW90ZS1jdXJsLmM6NzMzCiAjLCBjLWZvcm1hdAogbXNnaWQgIlJQQyBmYWlsZWQ7ICVzIgogbXNnc3RyICIiCiAKLSM6IHJlbW90ZS1jdXJsLmM6NzY0CisjOiByZW1vdGUtY3VybC5jOjc3MwogbXNnaWQgImNhbm5vdCBoYW5kbGUgcHVzaGVzIHRoaXMgYmlnIgogbXNnc3RyICIiCiAKLSM6IHJlbW90ZS1jdXJsLmM6ODc5CisjOiByZW1vdGUtY3VybC5jOjg4OAogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgZGVmbGF0ZSByZXF1ZXN0OyB6bGliIGRlZmxhdGUgZXJyb3IgJWQiCiBtc2dzdHIgIiIKIAotIzogcmVtb3RlLWN1cmwuYzo4ODMKKyM6IHJlbW90ZS1jdXJsLmM6ODkyCiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCBkZWZsYXRlIHJlcXVlc3Q7IHpsaWIgZW5kIGVycm9yICVkIgogbXNnc3RyICIiCiAKLSM6IHJlbW90ZS1jdXJsLmM6MTAxNAorIzogcmVtb3RlLWN1cmwuYzoxMDIzCiBtc2dpZCAiZHVtYiBodHRwIHRyYW5zcG9ydCBkb2VzIG5vdCBzdXBwb3J0IHNoYWxsb3cgY2FwYWJpbGl0aWVzIgogbXNnc3RyICIiCiAKLSM6IHJlbW90ZS1jdXJsLmM6MTAyOAorIzogcmVtb3RlLWN1cmwuYzoxMDM3CiBtc2dpZCAiZmV0Y2ggZmFpbGVkLiIKIG1zZ3N0ciAiIgogCi0jOiByZW1vdGUtY3VybC5jOjEwNzYKKyM6IHJlbW90ZS1jdXJsLmM6MTA4NQogbXNnaWQgImNhbm5vdCBmZXRjaCBieSBzaGExIG92ZXIgc21hcnQgaHR0cCIKIG1zZ3N0ciAiIgogCi0jOiByZW1vdGUtY3VybC5jOjExMjAgcmVtb3RlLWN1cmwuYzoxMTI2CisjOiByZW1vdGUtY3VybC5jOjExMjkgcmVtb3RlLWN1cmwuYzoxMTM1CiAjLCBjLWZvcm1hdAogbXNnaWQgInByb3RvY29sIGVycm9yOiBleHBlY3RlZCBzaGEvcmVmLCBnb3QgJyVzJyIKIG1zZ3N0ciAiIgogCi0jOiByZW1vdGUtY3VybC5jOjExMzggcmVtb3RlLWN1cmwuYzoxMjUyCisjOiByZW1vdGUtY3VybC5jOjExNDcgcmVtb3RlLWN1cmwuYzoxMjYxCiAjLCBjLWZvcm1hdAogbXNnaWQgImh0dHAgdHJhbnNwb3J0IGRvZXMgbm90IHN1cHBvcnQgJXMiCiBtc2dzdHIgIiIKIAotIzogcmVtb3RlLWN1cmwuYzoxMTc0CisjOiByZW1vdGUtY3VybC5jOjExODMKIG1zZ2lkICJnaXQtaHR0cC1wdXNoIGZhaWxlZCIKIG1zZ3N0ciAiIgogCi0jOiByZW1vdGUtY3VybC5jOjEzNjAKKyM6IHJlbW90ZS1jdXJsLmM6MTM2NwogbXNnaWQgInJlbW90ZS1jdXJsOiB1c2FnZTogZ2l0IHJlbW90ZS1jdXJsIDxyZW1vdGU+IFs8dXJsPl0iCiBtc2dzdHIgIiIKIAotIzogcmVtb3RlLWN1cmwuYzoxMzkyCisjOiByZW1vdGUtY3VybC5jOjEzOTkKIG1zZ2lkICJyZW1vdGUtY3VybDogZXJyb3IgcmVhZGluZyBjb21tYW5kIHN0cmVhbSBmcm9tIGdpdCIKIG1zZ3N0ciAiIgogCi0jOiByZW1vdGUtY3VybC5jOjEzOTkKKyM6IHJlbW90ZS1jdXJsLmM6MTQwNgogbXNnaWQgInJlbW90ZS1jdXJsOiBmZXRjaCBhdHRlbXB0ZWQgd2l0aG91dCBhIGxvY2FsIHJlcG8iCiBtc2dzdHIgIiIKIAotIzogcmVtb3RlLWN1cmwuYzoxNDM5CisjOiByZW1vdGUtY3VybC5jOjE0NDYKICMsIGMtZm9ybWF0CiBtc2dpZCAicmVtb3RlLWN1cmw6IHVua25vd24gY29tbWFuZCAnJXMnIGZyb20gZ2l0IgogbXNnc3RyICIiCiAKLSM6IGxpc3Qtb2JqZWN0cy1maWx0ZXItb3B0aW9ucy5oOjYxCisjOiBsaXN0LW9iamVjdHMtZmlsdGVyLW9wdGlvbnMuaDo4NQogbXNnaWQgImFyZ3MiCiBtc2dzdHIgIiIKIAotIzogbGlzdC1vYmplY3RzLWZpbHRlci1vcHRpb25zLmg6NjIKKyM6IGxpc3Qtb2JqZWN0cy1maWx0ZXItb3B0aW9ucy5oOjg2CiBtc2dpZCAib2JqZWN0IGZpbHRlcmluZyIKIG1zZ3N0ciAiIgogCi0jOiBwYXJzZS1vcHRpb25zLmg6MTcwCisjOiBwYXJzZS1vcHRpb25zLmg6MTc5CiBtc2dpZCAiZXhwaXJ5LWRhdGUiCiBtc2dzdHIgIiIKIAotIzogcGFyc2Utb3B0aW9ucy5oOjE4NAorIzogcGFyc2Utb3B0aW9ucy5oOjE5MwogbXNnaWQgIm5vLW9wIChiYWNrd2FyZCBjb21wYXRpYmlsaXR5KSIKIG1zZ3N0ciAiIgogCmRpZmYgLS1naXQgYS9wby9pdC5wbyBiL3BvL2l0LnBvCmluZGV4IDMwZWM5OWMuLjAzNjI3NmYgMTAwNjQ0Ci0tLSBhL3BvL2l0LnBvCisrKyBiL3BvL2l0LnBvCkBAIC0xMSw4ICsxMSw4IEBACiBtc2dzdHIgIiIKICJQcm9qZWN0LUlkLVZlcnNpb246IEdpdFxuIgogIlJlcG9ydC1Nc2dpZC1CdWdzLVRvOiBHaXQgTWFpbGluZyBMaXN0IDxnaXRAdmdlci5rZXJuZWwub3JnPlxuIgotIlBPVC1DcmVhdGlvbi1EYXRlOiAyMDE5LTA4LTEwIDIwOjEyKzA4MDBcbiIKLSJQTy1SZXZpc2lvbi1EYXRlOiAyMDE5LTA4LTExIDExOjQ4KzAyMDBcbiIKKyJQT1QtQ3JlYXRpb24tRGF0ZTogMjAxOS0xMC0yOCAxMzoxOSswODAwXG4iCisiUE8tUmV2aXNpb24tRGF0ZTogMjAxOS0xMC0yOCAyMDoxMSswMTAwXG4iCiAiTGFzdC1UcmFuc2xhdG9yOiBBbGVzc2FuZHJvIE1lbnRpIDxhbGVzc2FuZHJvLm1lbnRpQGFsZXNzYW5kcm9tZW50aS5pdD5cbiIKICJMYW5ndWFnZS1UZWFtOiBJdGFsaWFuIDw+XG4iCiAiTGFuZ3VhZ2U6IGl0XG4iCkBAIC0yMCw3ICsyMCw3IEBACiAiQ29udGVudC1UeXBlOiB0ZXh0L3BsYWluOyBjaGFyc2V0PVVURi04XG4iCiAiQ29udGVudC1UcmFuc2Zlci1FbmNvZGluZzogOGJpdFxuIgogIlBsdXJhbC1Gb3JtczogbnBsdXJhbHM9MjsgcGx1cmFsPShuICE9IDEpO1xuIgotIlgtR2VuZXJhdG9yOiBMb2thbGl6ZSAxOS4wNC4zXG4iCisiWC1HZW5lcmF0b3I6IExva2FsaXplIDE5LjA4LjJcbiIKIAogIzogYWR2aWNlLmM6MTA5CiAjLCBjLWZvcm1hdApAQCAtNzYsNyArNzYsNyBAQAogbXNnaWQgIkV4aXRpbmcgYmVjYXVzZSBvZiBhbiB1bnJlc29sdmVkIGNvbmZsaWN0LiIKIG1zZ3N0ciAiRXNjbyBhIGNhdXNhIGRpIHVuIGNvbmZsaXR0byBub24gcmlzb2x0by4iCiAKLSM6IGFkdmljZS5jOjE5MyBidWlsdGluL21lcmdlLmM6MTMyNworIzogYWR2aWNlLmM6MTkzIGJ1aWx0aW4vbWVyZ2UuYzoxMzMyCiBtc2dpZCAiWW91IGhhdmUgbm90IGNvbmNsdWRlZCB5b3VyIG1lcmdlIChNRVJHRV9IRUFEIGV4aXN0cykuIgogbXNnc3RyICJJbCBtZXJnZSBub24gw6ggc3RhdG8gY29uY2x1c28gKGVzaXN0ZSBNRVJHRV9IRUFEKS4iCiAKQEAgLTIxOSwxNyArMjE5LDcgQEAKIG1zZ2lkICJpbmNvbnNpc3RlbnQgaGVhZGVyIGxpbmVzICVkIGFuZCAlZCIKIG1zZ3N0ciAicmlnaGUgZGkgaW50ZXN0YXppb25lICVkIGUgJWQgaW5jb25zaXN0ZW50aSIKIAotIzogYXBwbHkuYzoxNDYwCi0jLCBjLWZvcm1hdAotbXNnaWQgInJlY291bnQ6IHVuZXhwZWN0ZWQgbGluZTogJS4qcyIKLW1zZ3N0ciAicmVjb3VudDogcmlnYSBpbmF0dGVzYTogJS4qcyIKLQotIzogYXBwbHkuYzoxNTI5Ci0jLCBjLWZvcm1hdAotbXNnaWQgInBhdGNoIGZyYWdtZW50IHdpdGhvdXQgaGVhZGVyIGF0IGxpbmUgJWQ6ICUuKnMiCi1tc2dzdHIgImZyYW1tZW50byBkaSBwYXRjaCBzZW56YSBpbnRlc3RhemlvbmUgYWxsYSByaWdhICVkOiAlLipzIgotCi0jOiBhcHBseS5jOjE1NTEKKyM6IGFwcGx5LmM6MTM3MgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiZ2l0IGRpZmYgaGVhZGVyIGxhY2tzIGZpbGVuYW1lIGluZm9ybWF0aW9uIHdoZW4gcmVtb3ZpbmcgJWQgbGVhZGluZyBwYXRobmFtZSAiCkBAIC0yNDQsODIgKzIzNCw5MiBAQAogImwnaW50ZXN0YXppb25lIGdpdCBkaWZmIG5vbiByaXBvcnRhIGxlIGluZm9ybWF6aW9uaSBzdWwgZmlsZSB1bmEgdm9sdGEgIgogInJpbW9zc2kgJWQgY29tcG9uZW50aSBpbml6aWFsaSBkZWwgcGVyY29yc28gKHJpZ2EgJWQpIgogCi0jOiBhcHBseS5jOjE1NjQKKyM6IGFwcGx5LmM6MTM4NQogIywgYy1mb3JtYXQKIG1zZ2lkICJnaXQgZGlmZiBoZWFkZXIgbGFja3MgZmlsZW5hbWUgaW5mb3JtYXRpb24gKGxpbmUgJWQpIgogbXNnc3RyICJsJ2ludGVzdGF6aW9uZSBnaXQgZGlmZiBub24gcmlwb3J0YSBsZSBpbmZvcm1hemlvbmkgc3VsIGZpbGUgKHJpZ2EgJWQpIgogCi0jOiBhcHBseS5jOjE3NTIKKyM6IGFwcGx5LmM6MTQ4MQorIywgYy1mb3JtYXQKK21zZ2lkICJyZWNvdW50OiB1bmV4cGVjdGVkIGxpbmU6ICUuKnMiCittc2dzdHIgInJlY291bnQ6IHJpZ2EgaW5hdHRlc2E6ICUuKnMiCisKKyM6IGFwcGx5LmM6MTU1MAorIywgYy1mb3JtYXQKK21zZ2lkICJwYXRjaCBmcmFnbWVudCB3aXRob3V0IGhlYWRlciBhdCBsaW5lICVkOiAlLipzIgorbXNnc3RyICJmcmFtbWVudG8gZGkgcGF0Y2ggc2VuemEgaW50ZXN0YXppb25lIGFsbGEgcmlnYSAlZDogJS4qcyIKKworIzogYXBwbHkuYzoxNzUzCiBtc2dpZCAibmV3IGZpbGUgZGVwZW5kcyBvbiBvbGQgY29udGVudHMiCiBtc2dzdHIgImlsIG51b3ZvIGZpbGUgZGlwZW5kZSBkYSB2ZWNjaGkgY29udGVudXRpIgogCi0jOiBhcHBseS5jOjE3NTQKKyM6IGFwcGx5LmM6MTc1NQogbXNnaWQgImRlbGV0ZWQgZmlsZSBzdGlsbCBoYXMgY29udGVudHMiCiBtc2dzdHIgImlsIGZpbGUgZWxpbWluYXRvIGhhIGFuY29yYSBkZWkgY29udGVudXRpIgogCi0jOiBhcHBseS5jOjE3ODgKKyM6IGFwcGx5LmM6MTc4OQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3JydXB0IHBhdGNoIGF0IGxpbmUgJWQiCiBtc2dzdHIgInBhdGNoIGNvcnJvdHRhIGFsbGEgcmlnYSAlZCIKIAotIzogYXBwbHkuYzoxODI1CisjOiBhcHBseS5jOjE4MjYKICMsIGMtZm9ybWF0CiBtc2dpZCAibmV3IGZpbGUgJXMgZGVwZW5kcyBvbiBvbGQgY29udGVudHMiCiBtc2dzdHIgImlsIG51b3ZvIGZpbGUgJXMgZGlwZW5kZSBkYSB2ZWNjaGkgY29udGVudXRpIgogCi0jOiBhcHBseS5jOjE4MjcKKyM6IGFwcGx5LmM6MTgyOAogIywgYy1mb3JtYXQKIG1zZ2lkICJkZWxldGVkIGZpbGUgJXMgc3RpbGwgaGFzIGNvbnRlbnRzIgogbXNnc3RyICJpbCBmaWxlIGVsaW1pbmF0byAlcyBoYSBhbmNvcmEgZGVpIGNvbnRlbnV0aSIKIAotIzogYXBwbHkuYzoxODMwCisjOiBhcHBseS5jOjE4MzEKICMsIGMtZm9ybWF0CiBtc2dpZCAiKiogd2FybmluZzogZmlsZSAlcyBiZWNvbWVzIGVtcHR5IGJ1dCBpcyBub3QgZGVsZXRlZCIKIG1zZ3N0ciAiKiogYXR0ZW56aW9uZTogaWwgZmlsZSAlcyBkaXZlbnRhIHZ1b3RvIG1hIG5vbiDDqCBlbGltaW5hdG8iCiAKLSM6IGFwcGx5LmM6MTk3NworIzogYXBwbHkuYzoxOTc4CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvcnJ1cHQgYmluYXJ5IHBhdGNoIGF0IGxpbmUgJWQ6ICUuKnMiCiBtc2dzdHIgInBhdGNoIGJpbmFyaWEgY29ycm90dGEgYWxsYSByaWdhICVkOiAlLipzIgogCi0jOiBhcHBseS5jOjIwMTQKKyM6IGFwcGx5LmM6MjAxNQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bnJlY29nbml6ZWQgYmluYXJ5IHBhdGNoIGF0IGxpbmUgJWQiCiBtc2dzdHIgInBhdGNoIGJpbmFyaWEgbm9uIHJpY29ub3NjaXV0YSBhbGxhIHJpZ2EgJWQiCiAKLSM6IGFwcGx5LmM6MjE3NgorIzogYXBwbHkuYzoyMTc3CiAjLCBjLWZvcm1hdAogbXNnaWQgInBhdGNoIHdpdGggb25seSBnYXJiYWdlIGF0IGxpbmUgJWQiCiBtc2dzdHIgInBhdGNoIGNvbiBzb2xpIGNvbnRlbnV0aSBnYXJiYWdlIGFsbGEgcmlnYSAlZCIKIAotIzogYXBwbHkuYzoyMjYyCisjOiBhcHBseS5jOjIyNjMKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHJlYWQgc3ltbGluayAlcyIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgbGVnZ2VyZSBpbCBjb2xsZWdhbWVudG8gc2ltYm9saWNvICVzIgogCi0jOiBhcHBseS5jOjIyNjYKKyM6IGFwcGx5LmM6MjI2NwogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gb3BlbiBvciByZWFkICVzIgogbXNnc3RyICJpbXBvc3NpYmlsZSBhcHJpcmUgbyBsZWdnZXJlICVzIgogCi0jOiBhcHBseS5jOjI5MjUKKyM6IGFwcGx5LmM6MjkyNgogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIHN0YXJ0IG9mIGxpbmU6ICclYyciCiBtc2dzdHIgImluaXppbyBkZWxsYSByaWdhIG5vbiB2YWxpZG86ICclYyciCiAKLSM6IGFwcGx5LmM6MzA0NgorIzogYXBwbHkuYzozMDQ3CiAjLCBjLWZvcm1hdAogbXNnaWQgIkh1bmsgIyVkIHN1Y2NlZWRlZCBhdCAlZCAob2Zmc2V0ICVkIGxpbmUpLiIKIG1zZ2lkX3BsdXJhbCAiSHVuayAjJWQgc3VjY2VlZGVkIGF0ICVkIChvZmZzZXQgJWQgbGluZXMpLiIKIG1zZ3N0clswXSAiQXBwbGljYXppb25lIGZyYW1tZW50byAlZCByaXVzY2l0YSBhbGxhIHJpZ2EgJWQgKG9mZnNldDogJWQgcmlnYSkuIgogbXNnc3RyWzFdICJBcHBsaWNhemlvbmUgZnJhbW1lbnRvICVkIHJpdXNjaXRhIGFsbGEgcmlnYSAlZCAob2Zmc2V0OiAlZCByaWdoZSkuIgogCi0jOiBhcHBseS5jOjMwNTgKKyM6IGFwcGx5LmM6MzA1OQogIywgYy1mb3JtYXQKIG1zZ2lkICJDb250ZXh0IHJlZHVjZWQgdG8gKCVsZC8lbGQpIHRvIGFwcGx5IGZyYWdtZW50IGF0ICVkIgogbXNnc3RyICJDb250ZXN0byByaWRvdHRvIGEgKCVsZC8lbGQpIHBlciBhcHBsaWNhcmUgaWwgZnJhbW1lbnRvIGFsbGEgcmlnYSAlZCIKIAotIzogYXBwbHkuYzozMDY0CisjOiBhcHBseS5jOjMwNjUKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIndoaWxlIHNlYXJjaGluZyBmb3I6XG4iCkBAIC0zMjgsMjYgKzMyOCwyNiBAQAogImR1cmFudGUgbGEgcmljZXJjYSBkaTpcbiIKICIlLipzIgogCi0jOiBhcHBseS5jOjMwODYKKyM6IGFwcGx5LmM6MzA4NwogIywgYy1mb3JtYXQKIG1zZ2lkICJtaXNzaW5nIGJpbmFyeSBwYXRjaCBkYXRhIGZvciAnJXMnIgogbXNnc3RyICJkYXRpIGRlbGxhIHBhdGNoIGJpbmFyaWEgbWFuY2FudGkgcGVyICclcyciCiAKLSM6IGFwcGx5LmM6MzA5NAorIzogYXBwbHkuYzozMDk1CiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCByZXZlcnNlLWFwcGx5IGEgYmluYXJ5IHBhdGNoIHdpdGhvdXQgdGhlIHJldmVyc2UgaHVuayB0byAnJXMnIgogbXNnc3RyICIiCiAiaW1wb3NzaWJpbGUgYXBwbGljYXJlIHVuYSBwYXRjaCBiaW5hcmlhIGFsIGNvbnRyYXJpbyBzZW56YSBsJ2h1bmsgY29udHJhcmlvICIKICJwZXIgJyVzJyIKIAotIzogYXBwbHkuYzozMTQxCisjOiBhcHBseS5jOjMxNDIKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IGFwcGx5IGJpbmFyeSBwYXRjaCB0byAnJXMnIHdpdGhvdXQgZnVsbCBpbmRleCBsaW5lIgogbXNnc3RyICIiCiAiaW1wb3NzaWJpbGUgYXBwbGljYXJlIHVuYSBwYXRjaCBiaW5hcmlhIGEgJyVzJyBzZW56YSBsYSByaWdhIGQnaW5kaWNlICIKICJjb21wbGV0YSIKIAotIzogYXBwbHkuYzozMTUxCisjOiBhcHBseS5jOjMxNTIKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogInRoZSBwYXRjaCBhcHBsaWVzIHRvICclcycgKCVzKSwgd2hpY2ggZG9lcyBub3QgbWF0Y2ggdGhlIGN1cnJlbnQgY29udGVudHMuIgpAQCAtMzU1LDQzMiArMzU1LDQzMiBAQAogImxhIHBhdGNoIHNpIGFwcGxpY2EgYSAnJXMnICglcyksIGNoZSBub24gY29ycmlzcG9uZGUgYWkgY29udGVudXRpIGNvcnJlbnRpICIKICJkZWwgZmlsZS4iCiAKLSM6IGFwcGx5LmM6MzE1OQorIzogYXBwbHkuYzozMTYwCiAjLCBjLWZvcm1hdAogbXNnaWQgInRoZSBwYXRjaCBhcHBsaWVzIHRvIGFuIGVtcHR5ICclcycgYnV0IGl0IGlzIG5vdCBlbXB0eSIKIG1zZ3N0ciAibGEgcGF0Y2ggc2kgYXBwbGljYSBhIHVuIGZpbGUgdnVvdG8gJyVzJyBtYSBpbCBmaWxlIG5vbiDDqCB2dW90byIKIAotIzogYXBwbHkuYzozMTc3CisjOiBhcHBseS5jOjMxNzgKICMsIGMtZm9ybWF0CiBtc2dpZCAidGhlIG5lY2Vzc2FyeSBwb3N0aW1hZ2UgJXMgZm9yICclcycgY2Fubm90IGJlIHJlYWQiCiBtc2dzdHIgImltcG9zc2liaWxlIGxlZ2dlcmUgbGEgcG9zdGltbWFnaW5lICVzIG5lY2Vzc2FyaWEgcGVyICclcyciCiAKLSM6IGFwcGx5LmM6MzE5MAorIzogYXBwbHkuYzozMTkxCiAjLCBjLWZvcm1hdAogbXNnaWQgImJpbmFyeSBwYXRjaCBkb2VzIG5vdCBhcHBseSB0byAnJXMnIgogbXNnc3RyICJsYSBwYXRjaCBiaW5hcmlhIG5vbiBzaSBhcHBsaWNhIGNvcnJldHRhbWVudGUgYSAnJXMnIgogCi0jOiBhcHBseS5jOjMxOTYKKyM6IGFwcGx5LmM6MzE5NwogIywgYy1mb3JtYXQKIG1zZ2lkICJiaW5hcnkgcGF0Y2ggdG8gJyVzJyBjcmVhdGVzIGluY29ycmVjdCByZXN1bHQgKGV4cGVjdGluZyAlcywgZ290ICVzKSIKIG1zZ3N0ciAiIgogImxhIHBhdGNoIGJpbmFyaWEgc3UgJyVzJyBjcmVhIHJpc3VsdGF0aSBub24gY29ycmV0dGkgKGF0dGVzbyAlcywgcmljZXZ1dG8gJXMpIgogCi0jOiBhcHBseS5jOjMyMTcKKyM6IGFwcGx5LmM6MzIxOAogIywgYy1mb3JtYXQKIG1zZ2lkICJwYXRjaCBmYWlsZWQ6ICVzOiVsZCIKIG1zZ3N0ciAicGF0Y2ggbm9uIHJpdXNjaXRhOiAlczolbGQiCiAKLSM6IGFwcGx5LmM6MzM0MAorIzogYXBwbHkuYzozMzQxCiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCBjaGVja291dCAlcyIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgZXNlZ3VpcmUgaWwgY2hlY2tvdXQgZGkgJyVzJyIKIAotIzogYXBwbHkuYzozMzkyIGFwcGx5LmM6MzQwMyBhcHBseS5jOjM0NDkgbWlkeC5jOjYyIHNldHVwLmM6Mjc5CisjOiBhcHBseS5jOjMzOTMgYXBwbHkuYzozNDA0IGFwcGx5LmM6MzQ1MCBtaWR4LmM6NjEgc2V0dXAuYzoyODAKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIHJlYWQgJXMiCiBtc2dzdHIgImxldHR1cmEgZGkgJXMgbm9uIHJpdXNjaXRhIgogCi0jOiBhcHBseS5jOjM0MDAKKyM6IGFwcGx5LmM6MzQwMQogIywgYy1mb3JtYXQKIG1zZ2lkICJyZWFkaW5nIGZyb20gJyVzJyBiZXlvbmQgYSBzeW1ib2xpYyBsaW5rIgogbXNnc3RyICJsZXR0dXJhIGRpICclcycgb2x0cmUgdW4gY29sbGVnYW1lbnRvIHNpbWJvbGljbyIKIAotIzogYXBwbHkuYzozNDI5IGFwcGx5LmM6MzY3MgorIzogYXBwbHkuYzozNDMwIGFwcGx5LmM6MzY3MwogIywgYy1mb3JtYXQKIG1zZ2lkICJwYXRoICVzIGhhcyBiZWVuIHJlbmFtZWQvZGVsZXRlZCIKIG1zZ3N0ciAiaWwgcGVyY29yc28gJXMgw6ggc3RhdG8gcmlub21pbmF0by9lbGltaW5hdG8iCiAKLSM6IGFwcGx5LmM6MzUxNSBhcHBseS5jOjM2ODcKKyM6IGFwcGx5LmM6MzUxNiBhcHBseS5jOjM2ODgKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXM6IGRvZXMgbm90IGV4aXN0IGluIGluZGV4IgogbXNnc3RyICIlczogbm9uIGVzaXN0ZSBuZWxsJ2luZGljZSIKIAotIzogYXBwbHkuYzozNTI0IGFwcGx5LmM6MzY5NQorIzogYXBwbHkuYzozNTI1IGFwcGx5LmM6MzY5NgogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogZG9lcyBub3QgbWF0Y2ggaW5kZXgiCiBtc2dzdHIgIiVzOiBub24gY29ycmlzcG9uZGUgYWxsJ2luZGljZSIKIAotIzogYXBwbHkuYzozNTU5CisjOiBhcHBseS5jOjM1NjAKIG1zZ2lkICJyZXBvc2l0b3J5IGxhY2tzIHRoZSBuZWNlc3NhcnkgYmxvYiB0byBmYWxsIGJhY2sgb24gMy13YXkgbWVyZ2UuIgogbXNnc3RyICIiCiAiZGFsIHJlcG9zaXRvcnkgbWFuY2EgaWwgYmxvYiBuZWNlc3NhcmlvIHBlciByaXBpZWdhcmUgc3VsIG1lcmdlIGEgdHJlIHZpZS4iCiAKLSM6IGFwcGx5LmM6MzU2MgorIzogYXBwbHkuYzozNTYzCiAjLCBjLWZvcm1hdAogbXNnaWQgIkZhbGxpbmcgYmFjayB0byB0aHJlZS13YXkgbWVyZ2UuLi5cbiIKIG1zZ3N0ciAiUmlwaWVnbyBzdWwgbWVyZ2UgYSB0cmUgdmllLi4uXG4iCiAKLSM6IGFwcGx5LmM6MzU3OCBhcHBseS5jOjM1ODIKKyM6IGFwcGx5LmM6MzU3OSBhcHBseS5jOjM1ODMKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IHJlYWQgdGhlIGN1cnJlbnQgY29udGVudHMgb2YgJyVzJyIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgbGVnZ2VyZSBpIGNvbnRlbnV0aSBjb3JyZW50aSBkaSAnJXMnIgogCi0jOiBhcHBseS5jOjM1OTQKKyM6IGFwcGx5LmM6MzU5NQogIywgYy1mb3JtYXQKIG1zZ2lkICJGYWlsZWQgdG8gZmFsbCBiYWNrIG9uIHRocmVlLXdheSBtZXJnZS4uLlxuIgogbXNnc3RyICJSaXBpZWdvIHN1bCBtZXJnZSBhIHRyZSB2aWUgbm9uIHJpdXNjaXRvLi4uXG4iCiAKLSM6IGFwcGx5LmM6MzYwOAorIzogYXBwbHkuYzozNjA5CiAjLCBjLWZvcm1hdAogbXNnaWQgIkFwcGxpZWQgcGF0Y2ggdG8gJyVzJyB3aXRoIGNvbmZsaWN0cy5cbiIKIG1zZ3N0ciAiUGF0Y2ggYXBwbGljYXRhIGEgJyVzJyBjb24gY29uZmxpdHRpLlxuIgogCi0jOiBhcHBseS5jOjM2MTMKKyM6IGFwcGx5LmM6MzYxNAogIywgYy1mb3JtYXQKIG1zZ2lkICJBcHBsaWVkIHBhdGNoIHRvICclcycgY2xlYW5seS5cbiIKIG1zZ3N0ciAiUGF0Y2ggJyVzJyBhcHBsaWNhdGEgY29ycmV0dGFtZW50ZS5cbiIKIAotIzogYXBwbHkuYzozNjM5CisjOiBhcHBseS5jOjM2NDAKIG1zZ2lkICJyZW1vdmFsIHBhdGNoIGxlYXZlcyBmaWxlIGNvbnRlbnRzIgogbXNnc3RyICJsYSByaW1vemlvbmUgZGVsbGEgcGF0Y2ggbGFzY2lhIGNvbnRlbnV0aSBkZWwgZmlsZSIKIAotIzogYXBwbHkuYzozNzEyCisjOiBhcHBseS5jOjM3MTMKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXM6IHdyb25nIHR5cGUiCiBtc2dzdHIgIiVzOiB0aXBvIGVycmF0byIKIAotIzogYXBwbHkuYzozNzE0CisjOiBhcHBseS5jOjM3MTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgaGFzIHR5cGUgJW8sIGV4cGVjdGVkICVvIgogbXNnc3RyICIlcyBoYSBpbCB0aXBvICVvLCBhdHRlc28gJW8iCiAKLSM6IGFwcGx5LmM6Mzg2NSBhcHBseS5jOjM4NjcgcmVhZC1jYWNoZS5jOjgzMCByZWFkLWNhY2hlLmM6ODU2CisjOiBhcHBseS5jOjM4NjYgYXBwbHkuYzozODY4IHJlYWQtY2FjaGUuYzo4MzAgcmVhZC1jYWNoZS5jOjg1NgogIzogcmVhZC1jYWNoZS5jOjEzMDkKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBwYXRoICclcyciCiBtc2dzdHIgInBlcmNvcnNvICclcycgbm9uIHZhbGlkbyIKIAotIzogYXBwbHkuYzozOTIzCisjOiBhcHBseS5jOjM5MjQKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXM6IGFscmVhZHkgZXhpc3RzIGluIGluZGV4IgogbXNnc3RyICIlczogZXNpc3RlIGdpw6AgbmVsbCdpbmRpY2UiCiAKLSM6IGFwcGx5LmM6MzkyNgorIzogYXBwbHkuYzozOTI3CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiBhbHJlYWR5IGV4aXN0cyBpbiB3b3JraW5nIGRpcmVjdG9yeSIKIG1zZ3N0ciAiJXM6IGVzaXN0ZSBnacOgIG5lbGxhIGRpcmVjdG9yeSBkaSBsYXZvcm8iCiAKLSM6IGFwcGx5LmM6Mzk0NgorIzogYXBwbHkuYzozOTQ3CiAjLCBjLWZvcm1hdAogbXNnaWQgIm5ldyBtb2RlICglbykgb2YgJXMgZG9lcyBub3QgbWF0Y2ggb2xkIG1vZGUgKCVvKSIKIG1zZ3N0ciAiaWwgbnVvdm8gbW9kbyAoJW8pIGRpICVzIG5vbiBjb3JyaXNwb25kZSBhbCB2ZWNjaGlvIG1vZG8gKCVvKSIKIAotIzogYXBwbHkuYzozOTUxCisjOiBhcHBseS5jOjM5NTIKICMsIGMtZm9ybWF0CiBtc2dpZCAibmV3IG1vZGUgKCVvKSBvZiAlcyBkb2VzIG5vdCBtYXRjaCBvbGQgbW9kZSAoJW8pIG9mICVzIgogbXNnc3RyICJpbCBudW92byBtb2RvICglbykgZGkgJXMgbm9uIGNvcnJpc3BvbmRlIGFsIHZlY2NoaW8gbW9kbyAoJW8pIGRpICVzIgogCi0jOiBhcHBseS5jOjM5NzEKKyM6IGFwcGx5LmM6Mzk3MgogIywgYy1mb3JtYXQKIG1zZ2lkICJhZmZlY3RlZCBmaWxlICclcycgaXMgYmV5b25kIGEgc3ltYm9saWMgbGluayIKIG1zZ3N0ciAiaWwgZmlsZSBpbnRlcmVzc2F0byAnJXMnIHNpIHRyb3ZhIG9sdHJlIHVuIGNvbGxlZ2FtZW50byBzaW1ib2xpY28iCiAKLSM6IGFwcGx5LmM6Mzk3NQorIzogYXBwbHkuYzozOTc2CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiBwYXRjaCBkb2VzIG5vdCBhcHBseSIKIG1zZ3N0ciAiJXM6IGxhIHBhdGNoIG5vbiBzaSBhcHBsaWNhIGNvcnJldHRhbWVudGUiCiAKLSM6IGFwcGx5LmM6Mzk5MAorIzogYXBwbHkuYzozOTkxCiAjLCBjLWZvcm1hdAogbXNnaWQgIkNoZWNraW5nIHBhdGNoICVzLi4uIgogbXNnc3RyICJDb250cm9sbG8gZGVsbGEgcGF0Y2ggJXMgaW4gY29yc28uLi4iCiAKLSM6IGFwcGx5LmM6NDA4MgorIzogYXBwbHkuYzo0MDgzCiAjLCBjLWZvcm1hdAogbXNnaWQgInNoYTEgaW5mb3JtYXRpb24gaXMgbGFja2luZyBvciB1c2VsZXNzIGZvciBzdWJtb2R1bGUgJXMiCiBtc2dzdHIgImxlIGluZm9ybWF6aW9uaSBTSEExIHBlciBpbCBzb3R0b21vZHVsbyAlcyBzb25vIG1hbmNhbnRpIG8gaW51dGlsaSIKIAotIzogYXBwbHkuYzo0MDg5CisjOiBhcHBseS5jOjQwOTAKICMsIGMtZm9ybWF0CiBtc2dpZCAibW9kZSBjaGFuZ2UgZm9yICVzLCB3aGljaCBpcyBub3QgaW4gY3VycmVudCBIRUFEIgogbXNnc3RyICJtb2RpZmljYSBtb2RvIHBlciAlcyBjaGUgbm9uIMOoIG5lbGwnSEVBRCBjb3JyZW50ZSIKIAotIzogYXBwbHkuYzo0MDkyCisjOiBhcHBseS5jOjQwOTMKICMsIGMtZm9ybWF0CiBtc2dpZCAic2hhMSBpbmZvcm1hdGlvbiBpcyBsYWNraW5nIG9yIHVzZWxlc3MgKCVzKS4iCiBtc2dzdHIgImxlIGluZm9ybWF6aW9uaSBTSEExIHNvbm8gbWFuY2FudGkgbyBpbnV0aWxpICglcykuIgogCi0jOiBhcHBseS5jOjQwOTcgYnVpbHRpbi9jaGVja291dC5jOjI3OCBidWlsdGluL3Jlc2V0LmM6MTQzCisjOiBhcHBseS5jOjQwOTggYnVpbHRpbi9jaGVja291dC5jOjI3OSBidWlsdGluL3Jlc2V0LmM6MTQzCiAjLCBjLWZvcm1hdAogbXNnaWQgIm1ha2VfY2FjaGVfZW50cnkgZmFpbGVkIGZvciBwYXRoICclcyciCiBtc2dzdHIgIm1ha2VfY2FjaGVfZW50cnkgbm9uIHJpdXNjaXRvIHBlciBpbCBwZXJjb3JzbyAnJXMnIgogCi0jOiBhcHBseS5jOjQxMDEKKyM6IGFwcGx5LmM6NDEwMgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgYWRkICVzIHRvIHRlbXBvcmFyeSBpbmRleCIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgYWdnaXVuZ2VyZSAlcyBhbGwnaW5kaWNlIHRlbXBvcmFuZW8iCiAKLSM6IGFwcGx5LmM6NDExMQorIzogYXBwbHkuYzo0MTEyCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCB3cml0ZSB0ZW1wb3JhcnkgaW5kZXggdG8gJXMiCiBtc2dzdHIgImltcG9zc2liaWxlIHNjcml2ZXJlIGwnaW5kaWNlIHRlbXBvcmFuZW8gaW4gJXMiCiAKLSM6IGFwcGx5LmM6NDI0OQorIzogYXBwbHkuYzo0MjUwCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byByZW1vdmUgJXMgZnJvbSBpbmRleCIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgcmltdW92ZXJlICVzIGRhbGwnaW5kaWNlIgogCi0jOiBhcHBseS5jOjQyODMKKyM6IGFwcGx5LmM6NDI4NAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3JydXB0IHBhdGNoIGZvciBzdWJtb2R1bGUgJXMiCiBtc2dzdHIgInBhdGNoIGNvcnJvdHRhIHBlciBpbCBzb3R0b21vZHVsbyAlcyIKIAotIzogYXBwbHkuYzo0Mjg5CisjOiBhcHBseS5jOjQyOTAKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHN0YXQgbmV3bHkgY3JlYXRlZCBmaWxlICclcyciCiBtc2dzdHIgImltcG9zc2liaWxlIGVzZWd1aXJlIGxvIHN0YXQgZGVsIGZpbGUgYXBwZW5hIGNyZWF0byAnJXMnIgogCi0jOiBhcHBseS5jOjQyOTcKKyM6IGFwcGx5LmM6NDI5OAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gY3JlYXRlIGJhY2tpbmcgc3RvcmUgZm9yIG5ld2x5IGNyZWF0ZWQgZmlsZSAlcyIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgY3JlYXJlIGwnYXJjaGl2aW8gZGkgYmFja3VwIHBlciBpbCBmaWxlIGFwcGVuYSBjcmVhdG8gJXMiCiAKLSM6IGFwcGx5LmM6NDMwMyBhcHBseS5jOjQ0NDgKKyM6IGFwcGx5LmM6NDMwNCBhcHBseS5jOjQ0NDkKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGFkZCBjYWNoZSBlbnRyeSBmb3IgJXMiCiBtc2dzdHIgImltcG9zc2liaWxlIGFnZ2l1bmdlcmUgbGEgdm9jZSBkZWxsYSBjYWNoZSBwZXIgJXMiCiAKLSM6IGFwcGx5LmM6NDM0NgorIzogYXBwbHkuYzo0MzQ3CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byB3cml0ZSB0byAnJXMnIgogbXNnc3RyICJzY3JpdHR1cmEgaW4gJyVzJyBub24gcml1c2NpdGEiCiAKLSM6IGFwcGx5LmM6NDM1MAorIzogYXBwbHkuYzo0MzUxCiAjLCBjLWZvcm1hdAogbXNnaWQgImNsb3NpbmcgZmlsZSAnJXMnIgogbXNnc3RyICJjaGl1c3VyYSBkZWwgZmlsZSAnJXMnIGluIGNvcnNvIgogCi0jOiBhcHBseS5jOjQ0MjAKKyM6IGFwcGx5LmM6NDQyMQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gd3JpdGUgZmlsZSAnJXMnIG1vZGUgJW8iCiBtc2dzdHIgImltcG9zc2liaWxlIHNjcml2ZXJlIGlsIGZpbGUgJyVzJyBjb24gbW9kbyAlbyIKIAotIzogYXBwbHkuYzo0NTE4CisjOiBhcHBseS5jOjQ1MTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiQXBwbGllZCBwYXRjaCAlcyBjbGVhbmx5LiIKIG1zZ3N0ciAiUGF0Y2ggJXMgYXBwbGljYXRhIGNvcnJldHRhbWVudGUuIgogCi0jOiBhcHBseS5jOjQ1MjYKKyM6IGFwcGx5LmM6NDUyNwogbXNnaWQgImludGVybmFsIGVycm9yIgogbXNnc3RyICJlcnJvcmUgaW50ZXJubyIKIAotIzogYXBwbHkuYzo0NTI5CisjOiBhcHBseS5jOjQ1MzAKICMsIGMtZm9ybWF0CiBtc2dpZCAiQXBwbHlpbmcgcGF0Y2ggJSVzIHdpdGggJWQgcmVqZWN0Li4uIgogbXNnaWRfcGx1cmFsICJBcHBseWluZyBwYXRjaCAlJXMgd2l0aCAlZCByZWplY3RzLi4uIgogbXNnc3RyWzBdICJBcHBsaWNhemlvbmUgZGVsbGEgcGF0Y2ggJSVzIGNvbiAlZCBmcmFtbWVudG8gcmVzcGludG8uLi4iCiBtc2dzdHJbMV0gIkFwcGxpY2F6aW9uZSBkZWxsYSBwYXRjaCAlJXMgY29uICVkIGZyYW1tZW50aSByZXNwaW50aS4uLiIKIAotIzogYXBwbHkuYzo0NTQwCisjOiBhcHBseS5jOjQ1NDEKICMsIGMtZm9ybWF0CiBtc2dpZCAidHJ1bmNhdGluZyAucmVqIGZpbGVuYW1lIHRvICUuKnMucmVqIgogbXNnc3RyICJub21lIGZpbGUgLnJlaiB0cm9uY2F0byBhICUuKnMucmVqIgogCi0jOiBhcHBseS5jOjQ1NDggYnVpbHRpbi9mZXRjaC5jOjg3OCBidWlsdGluL2ZldGNoLmM6MTE2OAorIzogYXBwbHkuYzo0NTQ5IGJ1aWx0aW4vZmV0Y2guYzo4OTggYnVpbHRpbi9mZXRjaC5jOjExOTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IG9wZW4gJXMiCiBtc2dzdHIgImltcG9zc2liaWxlIGFwcmlyZSAlcyIKIAotIzogYXBwbHkuYzo0NTYyCisjOiBhcHBseS5jOjQ1NjMKICMsIGMtZm9ybWF0CiBtc2dpZCAiSHVuayAjJWQgYXBwbGllZCBjbGVhbmx5LiIKIG1zZ3N0ciAiRnJhbW1lbnRvICVkIGFwcGxpY2F0byBjb3JyZXR0YW1lbnRlLiIKIAotIzogYXBwbHkuYzo0NTY2CisjOiBhcHBseS5jOjQ1NjcKICMsIGMtZm9ybWF0CiBtc2dpZCAiUmVqZWN0ZWQgaHVuayAjJWQuIgogbXNnc3RyICJGcmFtbWVudG8gJWQgcmVzcGludG8uIgogCi0jOiBhcHBseS5jOjQ2NzYKKyM6IGFwcGx5LmM6NDY4NgogIywgYy1mb3JtYXQKIG1zZ2lkICJTa2lwcGVkIHBhdGNoICclcycuIgogbXNnc3RyICJQYXRjaCAnJXMnIGlnbm9yYXRhLiIKIAotIzogYXBwbHkuYzo0Njg0CisjOiBhcHBseS5jOjQ2OTQKIG1zZ2lkICJ1bnJlY29nbml6ZWQgaW5wdXQiCiBtc2dzdHIgImlucHV0IG5vbiByaWNvbm9zY2l1dG8iCiAKLSM6IGFwcGx5LmM6NDcwNAorIzogYXBwbHkuYzo0NzE0CiBtc2dpZCAidW5hYmxlIHRvIHJlYWQgaW5kZXggZmlsZSIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgbGVnZ2VyZSBpbCBmaWxlIGluZGV4IgogCi0jOiBhcHBseS5jOjQ4NTkKKyM6IGFwcGx5LmM6NDg3MQogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW4ndCBvcGVuIHBhdGNoICclcyc6ICVzIgogbXNnc3RyICJpbXBvc3NpYmlsZSBhcHJpcmUgbGEgcGF0Y2ggJyVzJzogJXMiCiAKLSM6IGFwcGx5LmM6NDg4NgorIzogYXBwbHkuYzo0ODk4CiAjLCBjLWZvcm1hdAogbXNnaWQgInNxdWVsY2hlZCAlZCB3aGl0ZXNwYWNlIGVycm9yIgogbXNnaWRfcGx1cmFsICJzcXVlbGNoZWQgJWQgd2hpdGVzcGFjZSBlcnJvcnMiCiBtc2dzdHJbMF0gIiVkIGVycm9yZSBkaSBzcGF6aSBiaWFuY2hpIHNvcHByZXNzbyIKIG1zZ3N0clsxXSAiJWQgZXJyb3JpIGRpIHNwYXppIGJpYW5jaGkgc29wcHJlc3NpIgogCi0jOiBhcHBseS5jOjQ4OTIgYXBwbHkuYzo0OTA3CisjOiBhcHBseS5jOjQ5MDQgYXBwbHkuYzo0OTE5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVkIGxpbmUgYWRkcyB3aGl0ZXNwYWNlIGVycm9ycy4iCiBtc2dpZF9wbHVyYWwgIiVkIGxpbmVzIGFkZCB3aGl0ZXNwYWNlIGVycm9ycy4iCiBtc2dzdHJbMF0gIiVkIHJpZ2EgYWdnaXVuZ2UgZXJyb3JpIGRpIHNwYXppIGJpYW5jaGkuIgogbXNnc3RyWzFdICIlZCByaWdoZSBhZ2dpdW5nb25vIGVycm9yaSBkaSBzcGF6aSBiaWFuY2hpLiIKIAotIzogYXBwbHkuYzo0OTAwCisjOiBhcHBseS5jOjQ5MTIKICMsIGMtZm9ybWF0CiBtc2dpZCAiJWQgbGluZSBhcHBsaWVkIGFmdGVyIGZpeGluZyB3aGl0ZXNwYWNlIGVycm9ycy4iCiBtc2dpZF9wbHVyYWwgIiVkIGxpbmVzIGFwcGxpZWQgYWZ0ZXIgZml4aW5nIHdoaXRlc3BhY2UgZXJyb3JzLiIKIG1zZ3N0clswXSAiJWQgcmlnYSBhcHBsaWNhdGEgZG9wbyBsYSBjb3JyZXppb25lIGRpIGVycm9yaSBkaSBzcGF6aSBiaWFuY2hpLiIKIG1zZ3N0clsxXSAiJWQgcmlnaGUgYXBwbGljYXRlIGRvcG8gbGEgY29ycmV6aW9uZSBkaSBlcnJvcmkgZGkgc3BhemkgYmlhbmNoaS4iCiAKLSM6IGFwcGx5LmM6NDkxNiBidWlsdGluL2FkZC5jOjU0MCBidWlsdGluL212LmM6MzAxIGJ1aWx0aW4vcm0uYzozOTAKKyM6IGFwcGx5LmM6NDkyOCBidWlsdGluL2FkZC5jOjU0MCBidWlsdGluL212LmM6MzAxIGJ1aWx0aW4vcm0uYzozOTAKIG1zZ2lkICJVbmFibGUgdG8gd3JpdGUgbmV3IGluZGV4IGZpbGUiCiBtc2dzdHIgIkltcG9zc2liaWxlIHNjcml2ZXJlIGlsIG51b3ZvIGZpbGUgaW5kZXgiCiAKLSM6IGFwcGx5LmM6NDk0MyBhcHBseS5jOjQ5NDYgYnVpbHRpbi9hbS5jOjIyMDggYnVpbHRpbi9hbS5jOjIyMTEKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMjMgYnVpbHRpbi9mZXRjaC5jOjEyOCBidWlsdGluL21lcmdlLmM6MjczCi0jOiBidWlsdGluL3B1bGwuYzoyMDggYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjQwNworIzogYXBwbHkuYzo0OTU1IGFwcGx5LmM6NDk1OCBidWlsdGluL2FtLmM6MjE5NyBidWlsdGluL2FtLmM6MjIwMAorIzogYnVpbHRpbi9jbG9uZS5jOjEyMiBidWlsdGluL2ZldGNoLmM6MTQzIGJ1aWx0aW4vbWVyZ2UuYzoyNzMKKyM6IGJ1aWx0aW4vcHVsbC5jOjIwOSBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6NDA3CiAjOiBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6MTM2NyBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6MTM3MAogIzogYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjE4NTAgYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjE4NTMKICM6IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoyMDkyIGdpdC1hZGQtLWludGVyYWN0aXZlLnBlcmw6MjExCiBtc2dpZCAicGF0aCIKIG1zZ3N0ciAicGVyY29yc28iCiAKLSM6IGFwcGx5LmM6NDk0NAorIzogYXBwbHkuYzo0OTU2CiBtc2dpZCAiZG9uJ3QgYXBwbHkgY2hhbmdlcyBtYXRjaGluZyB0aGUgZ2l2ZW4gcGF0aCIKIG1zZ3N0ciAibm9uIGFwcGxpY2FyZSBsZSBtb2RpZmljaGUgY29ycmlzcG9uZGVudGkgYWwgcGVyY29yc28gc3BlY2lmaWNhdG8iCiAKLSM6IGFwcGx5LmM6NDk0NworIzogYXBwbHkuYzo0OTU5CiBtc2dpZCAiYXBwbHkgY2hhbmdlcyBtYXRjaGluZyB0aGUgZ2l2ZW4gcGF0aCIKIG1zZ3N0ciAiYXBwbGljYSBsZSBtb2RpZmljaGUgY29ycmlzcG9uZGVudGkgYWwgcGVyY29yc28gc3BlY2lmaWNhdG8iCiAKLSM6IGFwcGx5LmM6NDk0OSBidWlsdGluL2FtLmM6MjIxNworIzogYXBwbHkuYzo0OTYxIGJ1aWx0aW4vYW0uYzoyMjA2CiBtc2dpZCAibnVtIgogbXNnc3RyICJudW0iCiAKLSM6IGFwcGx5LmM6NDk1MAorIzogYXBwbHkuYzo0OTYyCiBtc2dpZCAicmVtb3ZlIDxudW0+IGxlYWRpbmcgc2xhc2hlcyBmcm9tIHRyYWRpdGlvbmFsIGRpZmYgcGF0aHMiCiBtc2dzdHIgInJpbXVvdmkgPG51bT4gYmFycmUgaW5pemlhbGkgZGFpIHBlcmNvcnNpIGRpZmYgdHJhZGl6aW9uYWxpIgogCi0jOiBhcHBseS5jOjQ5NTMKKyM6IGFwcGx5LmM6NDk2NQogbXNnaWQgImlnbm9yZSBhZGRpdGlvbnMgbWFkZSBieSB0aGUgcGF0Y2giCiBtc2dzdHIgImlnbm9yYSBsZSBhZ2dpdW50ZSBjcmVhdGUgZGFsbGEgcGF0Y2giCiAKLSM6IGFwcGx5LmM6NDk1NQorIzogYXBwbHkuYzo0OTY3CiBtc2dpZCAiaW5zdGVhZCBvZiBhcHBseWluZyB0aGUgcGF0Y2gsIG91dHB1dCBkaWZmc3RhdCBmb3IgdGhlIGlucHV0IgogbXNnc3RyICIiCiAiaW52ZWNlIGRpIGFwcGxpY2FyZSBsYSBwYXRjaCwgdmlzdWFsaXp6YSBsJ291dHB1dCBkaSBkaWZmc3RhdCBwZXIgbCdpbnB1dCIKIAotIzogYXBwbHkuYzo0OTU5CisjOiBhcHBseS5jOjQ5NzEKIG1zZ2lkICJzaG93IG51bWJlciBvZiBhZGRlZCBhbmQgZGVsZXRlZCBsaW5lcyBpbiBkZWNpbWFsIG5vdGF0aW9uIgogbXNnc3RyICIiCiAidmlzdWFsaXp6YSBpbCBudW1lcm8gZGkgcmlnaGUgYWdnaXVudGUgZWQgZWxpbWluYXRlIGluIG5vdGF6aW9uZSBkZWNpbWFsZSIKIAotIzogYXBwbHkuYzo0OTYxCisjOiBhcHBseS5jOjQ5NzMKIG1zZ2lkICJpbnN0ZWFkIG9mIGFwcGx5aW5nIHRoZSBwYXRjaCwgb3V0cHV0IGEgc3VtbWFyeSBmb3IgdGhlIGlucHV0IgogbXNnc3RyICJpbnZlY2UgZGkgYXBwbGljYXJlIGxhIHBhdGNoLCB2aXN1YWxpenphIHVuIHJpYXNzdW50byBwZXIgbCdpbnB1dCIKIAotIzogYXBwbHkuYzo0OTYzCisjOiBhcHBseS5jOjQ5NzUKIG1zZ2lkICJpbnN0ZWFkIG9mIGFwcGx5aW5nIHRoZSBwYXRjaCwgc2VlIGlmIHRoZSBwYXRjaCBpcyBhcHBsaWNhYmxlIgogbXNnc3RyICJpbnZlY2UgZGkgYXBwbGljYXJlIGxhIHBhdGNoLCB2ZXJpZmljYSBzZSBwdcOyIGVzc2VyZSBhcHBsaWNhdGEiCiAKLSM6IGFwcGx5LmM6NDk2NQorIzogYXBwbHkuYzo0OTc3CiBtc2dpZCAibWFrZSBzdXJlIHRoZSBwYXRjaCBpcyBhcHBsaWNhYmxlIHRvIHRoZSBjdXJyZW50IGluZGV4IgogbXNnc3RyICJhc3NpY3VyYSBjaGUgbGEgcGF0Y2ggc2lhIGFwcGxpY2FiaWxlIGFsbCdpbmRpY2UgY29ycmVudGUiCiAKLSM6IGFwcGx5LmM6NDk2NworIzogYXBwbHkuYzo0OTc5CiBtc2dpZCAibWFyayBuZXcgZmlsZXMgd2l0aCBgZ2l0IGFkZCAtLWludGVudC10by1hZGRgIgogbXNnc3RyICJjb250cmFzc2VnbmEgaSBudW92aSBmaWxlIGNvbiBgZ2l0IGFkZCAtLWludGVudC10by1hZGRgIgogCi0jOiBhcHBseS5jOjQ5NjkKKyM6IGFwcGx5LmM6NDk4MQogbXNnaWQgImFwcGx5IGEgcGF0Y2ggd2l0aG91dCB0b3VjaGluZyB0aGUgd29ya2luZyB0cmVlIgogbXNnc3RyICJhcHBsaWNhIHVuYSBwYXRjaCBzZW56YSBtb2RpZmljYXJlIGwnYWxiZXJvIGRpIGxhdm9ybyIKIAotIzogYXBwbHkuYzo0OTcxCisjOiBhcHBseS5jOjQ5ODMKIG1zZ2lkICJhY2NlcHQgYSBwYXRjaCB0aGF0IHRvdWNoZXMgb3V0c2lkZSB0aGUgd29ya2luZyBhcmVhIgogbXNnc3RyICIiCiAiYWNjZXR0YSB1bmEgcGF0Y2ggY2hlIGFwcG9ydGEgbW9kaWZpY2hlIGFsIGRpIGZ1b3JpIGRlbGwnYXJlYSBkaSBsYXZvcm8iCiAKLSM6IGFwcGx5LmM6NDk3NAorIzogYXBwbHkuYzo0OTg2CiBtc2dpZCAiYWxzbyBhcHBseSB0aGUgcGF0Y2ggKHVzZSB3aXRoIC0tc3RhdC8tLXN1bW1hcnkvLS1jaGVjaykiCiBtc2dzdHIgImFwcGxpY2EgYW5jaGUgbGEgcGF0Y2ggKGRhIHVzYXJlIGNvbiAtLXN0YXQvLS1zdW1tYXJ5Ly0tY2hlY2spIgogCi0jOiBhcHBseS5jOjQ5NzYKKyM6IGFwcGx5LmM6NDk4OAogbXNnaWQgImF0dGVtcHQgdGhyZWUtd2F5IG1lcmdlIGlmIGEgcGF0Y2ggZG9lcyBub3QgYXBwbHkiCiBtc2dzdHIgInByb3ZhIHVuIG1lcmdlIGEgdHJlIHZpZSBzZSBsYSBwYXRjaCBub24gc2kgYXBwbGljYSBjb3JyZXR0YW1lbnRlIgogCi0jOiBhcHBseS5jOjQ5NzgKKyM6IGFwcGx5LmM6NDk5MAogbXNnaWQgImJ1aWxkIGEgdGVtcG9yYXJ5IGluZGV4IGJhc2VkIG9uIGVtYmVkZGVkIGluZGV4IGluZm9ybWF0aW9uIgogbXNnc3RyICJjb21waWxhIHVuIGluZGV4IHRlbXBvcmFuZW8gYmFzYXRvIHN1bGxlIGluZm9ybWF6aW9uaSBpbmRpY2UgaW5jbHVzZSIKIAotIzogYXBwbHkuYzo0OTgxIGJ1aWx0aW4vY2hlY2tvdXQtaW5kZXguYzoxNzMgYnVpbHRpbi9scy1maWxlcy5jOjUyNAorIzogYXBwbHkuYzo0OTkzIGJ1aWx0aW4vY2hlY2tvdXQtaW5kZXguYzoxNzMgYnVpbHRpbi9scy1maWxlcy5jOjUyNAogbXNnaWQgInBhdGhzIGFyZSBzZXBhcmF0ZWQgd2l0aCBOVUwgY2hhcmFjdGVyIgogbXNnc3RyICJpIHBlcmNvcnNpIHNvbm8gc2VwYXJhdGkgY29uIHVuIGNhcmF0dGVyZSBOVUwiCiAKLSM6IGFwcGx5LmM6NDk4MworIzogYXBwbHkuYzo0OTk1CiBtc2dpZCAiZW5zdXJlIGF0IGxlYXN0IDxuPiBsaW5lcyBvZiBjb250ZXh0IG1hdGNoIgogbXNnc3RyICJhc3NpY3VyYSBjaGUgYWxtZW5vIDxuPiByaWdoZSBkaSBjb250ZXN0byBjb3JyaXNwb25kYW5vIgogCi0jOiBhcHBseS5jOjQ5ODQgYnVpbHRpbi9hbS5jOjIxOTYgYnVpbHRpbi9pbnRlcnByZXQtdHJhaWxlcnMuYzo5OAorIzogYXBwbHkuYzo0OTk2IGJ1aWx0aW4vYW0uYzoyMTg1IGJ1aWx0aW4vaW50ZXJwcmV0LXRyYWlsZXJzLmM6OTgKICM6IGJ1aWx0aW4vaW50ZXJwcmV0LXRyYWlsZXJzLmM6MTAwIGJ1aWx0aW4vaW50ZXJwcmV0LXRyYWlsZXJzLmM6MTAyCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMzAgYnVpbHRpbi9yZWJhc2UuYzoxNDIxCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMTAgYnVpbHRpbi9yZWJhc2UuYzoxNDQ1CiBtc2dpZCAiYWN0aW9uIgogbXNnc3RyICJhemlvbmUiCiAKLSM6IGFwcGx5LmM6NDk4NQorIzogYXBwbHkuYzo0OTk3CiBtc2dpZCAiZGV0ZWN0IG5ldyBvciBtb2RpZmllZCBsaW5lcyB0aGF0IGhhdmUgd2hpdGVzcGFjZSBlcnJvcnMiCiBtc2dzdHIgInJpbGV2YSByaWdoZSBudW92ZSBvIG1vZGlmaWNhdGUgY2hlIGhhbm5vIGVycm9yaSBkaSBzcGF6aSBiaWFuY2hpIgogCi0jOiBhcHBseS5jOjQ5ODggYXBwbHkuYzo0OTkxCisjOiBhcHBseS5jOjUwMDAgYXBwbHkuYzo1MDAzCiBtc2dpZCAiaWdub3JlIGNoYW5nZXMgaW4gd2hpdGVzcGFjZSB3aGVuIGZpbmRpbmcgY29udGV4dCIKIG1zZ3N0ciAiaWdub3JhIG1vZGlmaWNoZSBhZ2xpIHNwYXppIGJpYW5jaGkgZHVyYW50ZSBsYSByaWNlcmNhIGRlaSBjb250ZXN0aSIKIAotIzogYXBwbHkuYzo0OTk0CisjOiBhcHBseS5jOjUwMDYKIG1zZ2lkICJhcHBseSB0aGUgcGF0Y2ggaW4gcmV2ZXJzZSIKIG1zZ3N0ciAiYXBwbGljYSBsYSBwYXRjaCBpbiBtYW5pZXJhIGludmVyc2EiCiAKLSM6IGFwcGx5LmM6NDk5NgorIzogYXBwbHkuYzo1MDA4CiBtc2dpZCAiZG9uJ3QgZXhwZWN0IGF0IGxlYXN0IG9uZSBsaW5lIG9mIGNvbnRleHQiCiBtc2dzdHIgIm5vbiBhc3BldHRhcmUgYWxtZW5vIHVuYSByaWdhIGRpIGNvbnRlc3RvIgogCi0jOiBhcHBseS5jOjQ5OTgKKyM6IGFwcGx5LmM6NTAxMAogbXNnaWQgImxlYXZlIHRoZSByZWplY3RlZCBodW5rcyBpbiBjb3JyZXNwb25kaW5nICoucmVqIGZpbGVzIgogbXNnc3RyICJsYXNjaWEgaSBmcmFtbWVudGkgcmVzcGludGkgbmVpIGZpbGUgKi5yZWogY29ycmlzcG9uZGVudGkiCiAKLSM6IGFwcGx5LmM6NTAwMAorIzogYXBwbHkuYzo1MDEyCiBtc2dpZCAiYWxsb3cgb3ZlcmxhcHBpbmcgaHVua3MiCiBtc2dzdHIgImNvbnNlbnRpIGxhIHNvdnJhcHBvc2l6aW9uZSBkZWkgZnJhbW1lbnRpIgogCi0jOiBhcHBseS5jOjUwMDEgYnVpbHRpbi9hZGQuYzoyOTEgYnVpbHRpbi9jaGVjay1pZ25vcmUuYzoyMgorIzogYXBwbHkuYzo1MDEzIGJ1aWx0aW4vYWRkLmM6MjkxIGJ1aWx0aW4vY2hlY2staWdub3JlLmM6MjIKICM6IGJ1aWx0aW4vY29tbWl0LmM6MTMzNyBidWlsdGluL2NvdW50LW9iamVjdHMuYzo5OCBidWlsdGluL2ZzY2suYzo3ODYKLSM6IGJ1aWx0aW4vbG9nLmM6MjA2OCBidWlsdGluL212LmM6MTIzIGJ1aWx0aW4vcmVhZC10cmVlLmM6MTI4CisjOiBidWlsdGluL2xvZy5jOjIwODUgYnVpbHRpbi9tdi5jOjEyMyBidWlsdGluL3JlYWQtdHJlZS5jOjEyOAogbXNnaWQgImJlIHZlcmJvc2UiCiBtc2dzdHIgInZpc3VhbGl6emEgdWx0ZXJpb3JpIGRldHRhZ2xpIgogCi0jOiBhcHBseS5jOjUwMDMKKyM6IGFwcGx5LmM6NTAxNQogbXNnaWQgInRvbGVyYXRlIGluY29ycmVjdGx5IGRldGVjdGVkIG1pc3NpbmcgbmV3LWxpbmUgYXQgdGhlIGVuZCBvZiBmaWxlIgogbXNnc3RyICIiCiAidG9sbGVyYSBjYXJhdHRlcmUgZmluZSByaWdhIHJpbGV2YXRvIGVycm9uZWFtZW50ZSBjb21lIG1hbmNhbnRlIGFsbGEgZmluZSAiCiAiZGVsIGZpbGUiCiAKLSM6IGFwcGx5LmM6NTAwNgorIzogYXBwbHkuYzo1MDE4CiBtc2dpZCAiZG8gbm90IHRydXN0IHRoZSBsaW5lIGNvdW50cyBpbiB0aGUgaHVuayBoZWFkZXJzIgogbXNnc3RyICIiCiAibm9uIGZhcmUgYWZmaWRhbWVudG8gc3VsIG51bWVybyBkaSByaWdoZSBuZWxsZSBpbnRlc3RhemlvbmkgZGVpIGZyYW1tZW50aSIKIAotIzogYXBwbHkuYzo1MDA4IGJ1aWx0aW4vYW0uYzoyMjA1CisjOiBhcHBseS5jOjUwMjAgYnVpbHRpbi9hbS5jOjIxOTQKIG1zZ2lkICJyb290IgogbXNnc3RyICJyYWRpY2UiCiAKLSM6IGFwcGx5LmM6NTAwOQorIzogYXBwbHkuYzo1MDIxCiBtc2dpZCAicHJlcGVuZCA8cm9vdD4gdG8gYWxsIGZpbGVuYW1lcyIKIG1zZ3N0ciAiYW50ZXBvbmkgPHJhZGljZT4gYSB0dXR0aSBpIG5vbWkgZmlsZSIKIApAQCAtODM1LDcgKzgzNSw3IEBACiBtc2dpZCAiYXJjaGl2ZSBmb3JtYXQiCiBtc2dzdHIgImZvcm1hdG8gYXJjaGl2aW8iCiAKLSM6IGFyY2hpdmUuYzo0NTggYnVpbHRpbi9sb2cuYzoxNTgwCisjOiBhcmNoaXZlLmM6NDU4IGJ1aWx0aW4vbG9nLmM6MTU4MQogbXNnaWQgInByZWZpeCIKIG1zZ3N0ciAicHJlZmlzc28iCiAKQEAgLTg0MywxMSArODQzLDEyIEBACiBtc2dpZCAicHJlcGVuZCBwcmVmaXggdG8gZWFjaCBwYXRobmFtZSBpbiB0aGUgYXJjaGl2ZSIKIG1zZ3N0ciAiYW50ZXBvbmkgPHByZWZpc3NvPiBhIG9nbmkgbm9tZSBwZXJjb3JzbyBuZWxsJ2FyY2hpdmlvIgogCi0jOiBhcmNoaXZlLmM6NDYwIGJ1aWx0aW4vYmxhbWUuYzo4NjIgYnVpbHRpbi9ibGFtZS5jOjg3NCBidWlsdGluL2JsYW1lLmM6ODc1Ci0jOiBidWlsdGluL2NvbW1pdC10cmVlLmM6MTE3IGJ1aWx0aW4vY29uZmlnLmM6MTI5IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTM0Ci0jOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTEzNiBidWlsdGluL2dyZXAuYzo4OTcgYnVpbHRpbi9oYXNoLW9iamVjdC5jOjEwNQotIzogYnVpbHRpbi9scy1maWxlcy5jOjU2MCBidWlsdGluL2xzLWZpbGVzLmM6NTYzIGJ1aWx0aW4vbm90ZXMuYzo0MTIKLSM6IGJ1aWx0aW4vbm90ZXMuYzo1NzggYnVpbHRpbi9yZWFkLXRyZWUuYzoxMjMgcGFyc2Utb3B0aW9ucy5oOjE3NworIzogYXJjaGl2ZS5jOjQ2MCBidWlsdGluL2JsYW1lLmM6ODYxIGJ1aWx0aW4vYmxhbWUuYzo4NzMgYnVpbHRpbi9ibGFtZS5jOjg3NAorIzogYnVpbHRpbi9jb21taXQtdHJlZS5jOjExNyBidWlsdGluL2NvbmZpZy5jOjEyOSBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE2MgorIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNjQgYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNjggYnVpbHRpbi9ncmVwLmM6ODk5CisjOiBidWlsdGluL2hhc2gtb2JqZWN0LmM6MTA1IGJ1aWx0aW4vbHMtZmlsZXMuYzo1NjAgYnVpbHRpbi9scy1maWxlcy5jOjU2MworIzogYnVpbHRpbi9ub3Rlcy5jOjQxMiBidWlsdGluL25vdGVzLmM6NTc4IGJ1aWx0aW4vcmVhZC10cmVlLmM6MTIzCisjOiBwYXJzZS1vcHRpb25zLmg6MTg2CiBtc2dpZCAiZmlsZSIKIG1zZ3N0ciAiZmlsZSIKIApAQCAtODc5LDcgKzg4MCw3IEBACiBtc2dpZCAibGlzdCBzdXBwb3J0ZWQgYXJjaGl2ZSBmb3JtYXRzIgogbXNnc3RyICJlbGVuY2EgaSBmb3JtYXRpIGFyY2hpdmlvIHN1cHBvcnRhdGkiCiAKLSM6IGFyY2hpdmUuYzo0NzkgYnVpbHRpbi9hcmNoaXZlLmM6OTEgYnVpbHRpbi9jbG9uZS5jOjExMyBidWlsdGluL2Nsb25lLmM6MTE2CisjOiBhcmNoaXZlLmM6NDc5IGJ1aWx0aW4vYXJjaGl2ZS5jOjkxIGJ1aWx0aW4vY2xvbmUuYzoxMTIgYnVpbHRpbi9jbG9uZS5jOjExNQogIzogYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjEzNzkgYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjE4NTkKIG1zZ2lkICJyZXBvIgogbXNnc3RyICJyZXBvc2l0b3J5IgpAQCAtODg4LDcgKzg4OSw3IEBACiBtc2dpZCAicmV0cmlldmUgdGhlIGFyY2hpdmUgZnJvbSByZW1vdGUgcmVwb3NpdG9yeSA8cmVwbz4iCiBtc2dzdHIgInJlY3VwZXJhIGwnYXJjaGl2aW8gZGFsIHJlcG9zaXRvcnkgcmVtb3RvIDxyZXBvc2l0b3J5PiIKIAotIzogYXJjaGl2ZS5jOjQ4MSBidWlsdGluL2FyY2hpdmUuYzo5MyBidWlsdGluL2RpZmZ0b29sLmM6NzA3CisjOiBhcmNoaXZlLmM6NDgxIGJ1aWx0aW4vYXJjaGl2ZS5jOjkzIGJ1aWx0aW4vZGlmZnRvb2wuYzo3MTUKICM6IGJ1aWx0aW4vbm90ZXMuYzo0OTgKIG1zZ2lkICJjb21tYW5kIgogbXNnc3RyICJjb21hbmRvIgpAQCAtOTI0LDI2ICs5MjUsMjYgQEAKIG1zZ2lkICJjYW5ub3Qgc3RyZWFtIGJsb2IgJXMiCiBtc2dzdHIgImltcG9zc2liaWxlIGVzZWd1aXJlIGxvIHN0cmVhbWluZyBkZWwgYmxvYiAlcyIKIAotIzogYXJjaGl2ZS10YXIuYzoyNjAgYXJjaGl2ZS16aXAuYzozNjMKKyM6IGFyY2hpdmUtdGFyLmM6MjY2IGFyY2hpdmUtemlwLmM6MzYzCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuc3VwcG9ydGVkIGZpbGUgbW9kZTogMCVvIChTSEExOiAlcykiCiBtc2dzdHIgIm1vZG8gZmlsZSBub24gc3VwcG9ydGF0bzogMCVvIChTSEExOiAlcykiCiAKLSM6IGFyY2hpdmUtdGFyLmM6Mjg3IGFyY2hpdmUtemlwLmM6MzUzCisjOiBhcmNoaXZlLXRhci5jOjI5MyBhcmNoaXZlLXppcC5jOjM1MwogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgcmVhZCAlcyIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgbGVnZ2VyZSAlcyIKIAotIzogYXJjaGl2ZS10YXIuYzo0NTkKKyM6IGFyY2hpdmUtdGFyLmM6NDY1CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBzdGFydCAnJXMnIGZpbHRlciIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgYXZ2aWFyZSBpbCBmaWx0cm8gJyVzJyIKIAotIzogYXJjaGl2ZS10YXIuYzo0NjIKKyM6IGFyY2hpdmUtdGFyLmM6NDY4CiBtc2dpZCAidW5hYmxlIHRvIHJlZGlyZWN0IGRlc2NyaXB0b3IiCiBtc2dzdHIgImltcG9zc2liaWxlIHJpZGlyZXppb25hcmUgaWwgZGVzY3JpdHRvcmUiCiAKLSM6IGFyY2hpdmUtdGFyLmM6NDY5CisjOiBhcmNoaXZlLXRhci5jOjQ3NQogIywgYy1mb3JtYXQKIG1zZ2lkICInJXMnIGZpbHRlciByZXBvcnRlZCBlcnJvciIKIG1zZ3N0ciAiaWwgZmlsdHJvICclcycgaGEgc2VnbmFsYXRvIHVuIGVycm9yZSIKQEAgLTk2OCwxNyArOTY5LDE3IEBACiBtc2dpZCAidGltZXN0YW1wIHRvbyBsYXJnZSBmb3IgdGhpcyBzeXN0ZW06ICU8UFJJdU1BWD4iCiBtc2dzdHIgInRpbWVzdGFtcCB0cm9wcG8gZ3JhbmRlIHBlciBxdWVzdG8gc2lzdGVtYTogJTxQUkl1TUFYPiIKIAotIzogYXR0ci5jOjIxMQorIzogYXR0ci5jOjIxMwogIywgYy1mb3JtYXQKIG1zZ2lkICIlLipzIGlzIG5vdCBhIHZhbGlkIGF0dHJpYnV0ZSBuYW1lIgogbXNnc3RyICIlLipzIG5vbiDDqCB1biBub21lIGF0dHJpYnV0byB2YWxpZG8iCiAKLSM6IGF0dHIuYzozNjgKKyM6IGF0dHIuYzozNzAKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgbm90IGFsbG93ZWQ6ICVzOiVkIgogbXNnc3RyICIlcyBub24gY29uc2VudGl0bzogJXM6JWQiCiAKLSM6IGF0dHIuYzo0MDgKKyM6IGF0dHIuYzo0MTAKIG1zZ2lkICIiCiAiTmVnYXRpdmUgcGF0dGVybnMgYXJlIGlnbm9yZWQgaW4gZ2l0IGF0dHJpYnV0ZXNcbiIKICJVc2UgJ1xcIScgZm9yIGxpdGVyYWwgbGVhZGluZyBleGNsYW1hdGlvbi4iCkBAIC0xMTA3LDQxICsxMTA4LDQxIEBACiBtc2dzdHJbMV0gIiIKICJCaXNlemlvbmUgaW4gY29yc286ICVkIHJldmlzaW9uaSByaW1hbmVudGkgZGEgdGVzdGFyZSBkb3BvIHF1ZXN0YSAlc1xuIgogCi0jOiBibGFtZS5jOjI2OTcKKyM6IGJsYW1lLmM6MjcwMAogbXNnaWQgIi0tY29udGVudHMgYW5kIC0tcmV2ZXJzZSBkbyBub3QgYmxlbmQgd2VsbC4iCiBtc2dzdHIgIi0tY29udGVudHMgZSAtLXJldmVyc2Ugbm9uIHNvbm8gY29tcGF0aWJpbGkuIgogCi0jOiBibGFtZS5jOjI3MTEKKyM6IGJsYW1lLmM6MjcxNAogbXNnaWQgImNhbm5vdCB1c2UgLS1jb250ZW50cyB3aXRoIGZpbmFsIGNvbW1pdCBvYmplY3QgbmFtZSIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgdXNhcmUgLS1jb250ZW50cyBjb24gaWwgbm9tZSBvZ2dldHRvIGRlbCBjb21taXQgZmluYWxlIgogCi0jOiBibGFtZS5jOjI3MzIKKyM6IGJsYW1lLmM6MjczNQogbXNnaWQgIi0tcmV2ZXJzZSBhbmQgLS1maXJzdC1wYXJlbnQgdG9nZXRoZXIgcmVxdWlyZSBzcGVjaWZpZWQgbGF0ZXN0IGNvbW1pdCIKIG1zZ3N0ciAiIgogImxlIG9wemlvbmkgLS1yZXZlcnNlIGUgLS1maXJzdC1wYXJlbnQgc2UgdXNhdGUgaW5zaWVtZSByaWNoaWVkb25vIGNoZSBzaWEgIgogInNwZWNpZmljYXRvIGwndWx0aW1vIGNvbW1pdCIKIAotIzogYmxhbWUuYzoyNzQxIGJ1bmRsZS5jOjE2NyByZWYtZmlsdGVyLmM6MjE5NiByZW1vdGUuYzoxOTM4IHNlcXVlbmNlci5jOjIwMzMKLSM6IHNlcXVlbmNlci5jOjQzNDggYnVpbHRpbi9jb21taXQuYzoxMDIwIGJ1aWx0aW4vbG9nLmM6Mzg3IGJ1aWx0aW4vbG9nLmM6OTYzCi0jOiBidWlsdGluL2xvZy5jOjE0NTEgYnVpbHRpbi9sb2cuYzoxODI3IGJ1aWx0aW4vbG9nLmM6MjExNyBidWlsdGluL21lcmdlLmM6NDExCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMxNDggYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMTYzCisjOiBibGFtZS5jOjI3NDQgYnVuZGxlLmM6MTY3IHJlZi1maWx0ZXIuYzoyMjAzIHJlbW90ZS5jOjE5NDEgc2VxdWVuY2VyLmM6MTk3MQorIzogc2VxdWVuY2VyLmM6NDMwNSBidWlsdGluL2NvbW1pdC5jOjEwMjAgYnVpbHRpbi9sb2cuYzozODcgYnVpbHRpbi9sb2cuYzo5NjQKKyM6IGJ1aWx0aW4vbG9nLmM6MTQ1MiBidWlsdGluL2xvZy5jOjE4NDQgYnVpbHRpbi9sb2cuYzoyMTM0IGJ1aWx0aW4vbWVyZ2UuYzo0MTEKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzEyOCBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMxNDMKICM6IGJ1aWx0aW4vc2hvcnRsb2cuYzoxOTIKIG1zZ2lkICJyZXZpc2lvbiB3YWxrIHNldHVwIGZhaWxlZCIKIG1zZ3N0ciAiaW1wb3N0YXppb25lIHBlcmNvcnNvIHJldmlzaW9uaSBub24gcml1c2NpdGEiCiAKLSM6IGJsYW1lLmM6Mjc1OQorIzogYmxhbWUuYzoyNzYyCiBtc2dpZCAiIgogIi0tcmV2ZXJzZSAtLWZpcnN0LXBhcmVudCB0b2dldGhlciByZXF1aXJlIHJhbmdlIGFsb25nIGZpcnN0LXBhcmVudCBjaGFpbiIKIG1zZ3N0ciAiIgogImxlIG9wemlvbmkgLS1yZXZlcnNlIGUgLS1maXJzdC1wYXJlbnQgc2UgdXNhdGUgaW5zaWVtZSByaWNoaWVkb25vIGNoZSBzaWEgIgogInNwZWNpZmljYXRvIHVuIGludGVydmFsbG8gbmVsbGEgY2F0ZW5hIGRlbCBwcmltbyBjb21taXQgZ2VuaXRvcmUiCiAKLSM6IGJsYW1lLmM6Mjc3MAorIzogYmxhbWUuYzoyNzczCiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vIHN1Y2ggcGF0aCAlcyBpbiAlcyIKIG1zZ3N0ciAiaWwgcGVyY29yc28gJXMgaW4gJXMgbm9uIGVzaXN0ZSIKIAotIzogYmxhbWUuYzoyNzgxCisjOiBibGFtZS5jOjI3ODQKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IHJlYWQgYmxvYiAlcyBmb3IgcGF0aCAlcyIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgbGVnZ2VyZSBpbCBibG9iICVzIHBlciBpbCBwZXJjb3JzbyAlcyIKQEAgLTEzMDMsNyArMTMwNCw3IEBACiBtc2dpZCAidW5yZWNvZ25pemVkIGhlYWRlcjogJXMlcyAoJWQpIgogbXNnc3RyICJpbnRlc3RhemlvbmUgbm9uIHJpY29ub3NjaXV0YTogJXMlcyAoJWQpIgogCi0jOiBidW5kbGUuYzo5MCByZXJlcmUuYzo0ODAgcmVyZXJlLmM6NjkwIHNlcXVlbmNlci5jOjIyODMgc2VxdWVuY2VyLmM6MzAyNAorIzogYnVuZGxlLmM6OTAgcmVyZXJlLmM6NDgwIHJlcmVyZS5jOjY5MCBzZXF1ZW5jZXIuYzoyMjIxIHNlcXVlbmNlci5jOjI5NjIKICM6IGJ1aWx0aW4vY29tbWl0LmM6NzkxCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBvcGVuICclcyciCkBAIC0xMzU2LDcgKzEzNTcsNyBAQAogbXNnaWQgInJlZiAnJXMnIGlzIGV4Y2x1ZGVkIGJ5IHRoZSByZXYtbGlzdCBvcHRpb25zIgogbXNnc3RyICJpbCByaWZlcmltZW50byAnJXMnIMOoIGVzY2x1c28gZGFsbGUgb3B6aW9uaSBkaSByZXYtbGlzdCIKIAotIzogYnVuZGxlLmM6NDYwIGJ1aWx0aW4vbG9nLmM6MjAyIGJ1aWx0aW4vbG9nLmM6MTczMiBidWlsdGluL3Nob3J0bG9nLmM6MzA2CisjOiBidW5kbGUuYzo0NjAgYnVpbHRpbi9sb2cuYzoyMDIgYnVpbHRpbi9sb2cuYzoxNzMzIGJ1aWx0aW4vc2hvcnRsb2cuYzozMDYKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5yZWNvZ25pemVkIGFyZ3VtZW50OiAlcyIKIG1zZ3N0ciAiYXJnb21lbnRvIG5vbiByaWNvbm9zY2l1dG86ICVzIgpAQCAtMTM3OSw4ICsxMzgwLDggQEAKIG1zZ2lkICJpbnZhbGlkIGNvbG9yIHZhbHVlOiAlLipzIgogbXNnc3RyICJ2YWxvcmUgY29sb3JlIG5vbiB2YWxpZG86ICUuKnMiCiAKLSM6IGNvbW1pdC5jOjUwIHNlcXVlbmNlci5jOjI3MjcgYnVpbHRpbi9hbS5jOjM1NSBidWlsdGluL2FtLmM6Mzk5Ci0jOiBidWlsdGluL2FtLmM6MTM3OCBidWlsdGluL2FtLmM6MjAyMCBidWlsdGluL3JlcGxhY2UuYzo0NTUKKyM6IGNvbW1pdC5jOjUwIHNlcXVlbmNlci5jOjI2NjUgYnVpbHRpbi9hbS5jOjM1NCBidWlsdGluL2FtLmM6Mzk4CisjOiBidWlsdGluL2FtLmM6MTM2NiBidWlsdGluL2FtLmM6MjAwOSBidWlsdGluL3JlcGxhY2UuYzo0NTYKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHBhcnNlICVzIgogbXNnc3RyICJpbXBvc3NpYmlsZSBhbmFsaXp6YXJlICVzIgpAQCAtMTQxMCwyNyArMTQxMSwyNyBAQAogIlBlciBkaXNhYmlsaXRhcmUgcXVlc3RvIG1lc3NhZ2dpbywgZXNlZ3VpXG4iCiAiXCJnaXQgY29uZmlnIGFkdmljZS5ncmFmdEZpbGVEZXByZWNhdGVkIGZhbHNlXCIiCiAKLSM6IGNvbW1pdC5jOjExMjcKKyM6IGNvbW1pdC5jOjExMjgKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ29tbWl0ICVzIGhhcyBhbiB1bnRydXN0ZWQgR1BHIHNpZ25hdHVyZSwgYWxsZWdlZGx5IGJ5ICVzLiIKIG1zZ3N0ciAiSWwgY29tbWl0ICVzIGhhIHVuYSBmaXJtYSBHUEcgbm9uIGFmZmlkYWJpbGUsIHByZXN1bWliaWxtZW50ZSBkaSAlcy4iCiAKLSM6IGNvbW1pdC5jOjExMzAKKyM6IGNvbW1pdC5jOjExMzEKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ29tbWl0ICVzIGhhcyBhIGJhZCBHUEcgc2lnbmF0dXJlIGFsbGVnZWRseSBieSAlcy4iCiBtc2dzdHIgIklsIGNvbW1pdCAlcyBoYSB1bmEgZmlybWEgR1BHIG5vbiB2YWxpZGEgcHJlc3VtaWJpbG1lbnRlIGRpICVzLiIKIAotIzogY29tbWl0LmM6MTEzMworIzogY29tbWl0LmM6MTEzNAogIywgYy1mb3JtYXQKIG1zZ2lkICJDb21taXQgJXMgZG9lcyBub3QgaGF2ZSBhIEdQRyBzaWduYXR1cmUuIgogbXNnc3RyICJJbCBjb21taXQgJXMgbm9uIGhhIHVuYSBmaXJtYSBHUEcuIgogCi0jOiBjb21taXQuYzoxMTM2CisjOiBjb21taXQuYzoxMTM3CiAjLCBjLWZvcm1hdAogbXNnaWQgIkNvbW1pdCAlcyBoYXMgYSBnb29kIEdQRyBzaWduYXR1cmUgYnkgJXNcbiIKIG1zZ3N0ciAiSWwgY29tbWl0ICVzIGhhIHVuYSBmaXJtYSBHUEcgdmFsaWRhIGRpICVzXG4iCiAKLSM6IGNvbW1pdC5jOjEzOTAKKyM6IGNvbW1pdC5jOjEzOTEKIG1zZ2lkICIiCiAiV2FybmluZzogY29tbWl0IG1lc3NhZ2UgZGlkIG5vdCBjb25mb3JtIHRvIFVURi04LlxuIgogIllvdSBtYXkgd2FudCB0byBhbWVuZCBpdCBhZnRlciBmaXhpbmcgdGhlIG1lc3NhZ2UsIG9yIHNldCB0aGUgY29uZmlnXG4iCkBAIC0xNDk0LDU1ICsxNDk1LDY1IEBACiBtc2dpZCAidW5hYmxlIHRvIGZpbmQgYWxsIGNvbW1pdC1ncmFwaCBmaWxlcyIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgdHJvdmFyZSB0dXR0aSBpIGZpbGUgZ3JhZm8gZGVpIGNvbW1pdCIKIAotIzogY29tbWl0LWdyYXBoLmM6NTU0IGNvbW1pdC1ncmFwaC5jOjYxNAorIzogY29tbWl0LWdyYXBoLmM6NTYxIGNvbW1pdC1ncmFwaC5jOjYyMQogbXNnaWQgImludmFsaWQgY29tbWl0IHBvc2l0aW9uLiBjb21taXQtZ3JhcGggaXMgbGlrZWx5IGNvcnJ1cHQiCiBtc2dzdHIgIiIKICJwb3NpemlvbmUgY29tbWl0IG5vbiB2YWxpZGEuIElsIGdyYWZvIGRlaSBjb21taXQgw6ggcHJvYmFiaWxtZW50ZSBjb3Jyb3R0byIKIAotIzogY29tbWl0LWdyYXBoLmM6NTc1CisjOiBjb21taXQtZ3JhcGguYzo1ODIKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGZpbmQgY29tbWl0ICVzIgogbXNnc3RyICJpbXBvc3NpYmlsZSB0cm92YXJlIGlsIGNvbW1pdCAlcyIKIAotIzogY29tbWl0LWdyYXBoLmM6MTAwMiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI2NTcKKyM6IGNvbW1pdC1ncmFwaC5jOjg1NSBidWlsdGluL2FtLmM6MTI4NworIywgYy1mb3JtYXQKK21zZ2lkICJ1bmFibGUgdG8gcGFyc2UgY29tbWl0ICVzIgorbXNnc3RyICJpbXBvc3NpYmlsZSBhbmFsaXp6YXJlIGlsIGNvbW1pdCAlcyIKKworIzogY29tbWl0LWdyYXBoLmM6ODU5CisjLCBjLWZvcm1hdAorbXNnaWQgInVuYWJsZSB0byBnZXQgdHJlZSBmb3IgJXMiCittc2dzdHIgImltcG9zc2liaWxlIHJlY3VwZXJhcmUgbCdhbGJlcm8gcGVyICVzIgorCisjOiBjb21taXQtZ3JhcGguYzoxMDE3IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjY0MQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gZ2V0IHR5cGUgb2Ygb2JqZWN0ICVzIgogbXNnc3RyICJpbXBvc3NpYmlsZSByZWN1cGVyYXJlIGlsIHRpcG8gZGVsbCdvZ2dldHRvICVzIgogCi0jOiBjb21taXQtZ3JhcGguYzoxMDM0CisjOiBjb21taXQtZ3JhcGguYzoxMDQ5CiBtc2dpZCAiTG9hZGluZyBrbm93biBjb21taXRzIGluIGNvbW1pdCBncmFwaCIKIG1zZ3N0ciAiQ2FyaWNhbWVudG8gY29tbWl0IG5vdGkgbmVsIGdyYWZvIGRlaSBjb21taXQgaW4gY29yc28iCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjEwNTEKKyM6IGNvbW1pdC1ncmFwaC5jOjEwNjYKIG1zZ2lkICJFeHBhbmRpbmcgcmVhY2hhYmxlIGNvbW1pdHMgaW4gY29tbWl0IGdyYXBoIgogbXNnc3RyICJFc3BhbnNpb25lIGRlaSBjb21taXQgcmFnZ2l1bmdpYmlsaSBuZWwgZ3JhZm8gZGVpIGNvbW1pdCBpbiBjb3JzbyIKIAotIzogY29tbWl0LWdyYXBoLmM6MTA3MAorIzogY29tbWl0LWdyYXBoLmM6MTA4NQogbXNnaWQgIkNsZWFyaW5nIGNvbW1pdCBtYXJrcyBpbiBjb21taXQgZ3JhcGgiCiBtc2dzdHIgIlJpbW96aW9uZSBkZWkgY29udHJhc3NlZ25pIGNvbW1pdCBuZWwgZ3JhZm8gZGVpIGNvbW1pdCBpbiBjb3JzbyIKIAotIzogY29tbWl0LWdyYXBoLmM6MTA4OQorIzogY29tbWl0LWdyYXBoLmM6MTEwNAogbXNnaWQgIkNvbXB1dGluZyBjb21taXQgZ3JhcGggZ2VuZXJhdGlvbiBudW1iZXJzIgogbXNnc3RyICJDYWxjb2xvIG51bWVyaSBnZW5lcmF6aW9uZSBkZWwgZ3JhZm8gZGVpIGNvbW1pdCBpbiBjb3JzbyIKIAotIzogY29tbWl0LWdyYXBoLmM6MTE2MworIzogY29tbWl0LWdyYXBoLmM6MTE3OQogIywgYy1mb3JtYXQKIG1zZ2lkICJGaW5kaW5nIGNvbW1pdHMgZm9yIGNvbW1pdCBncmFwaCBpbiAlZCBwYWNrIgogbXNnaWRfcGx1cmFsICJGaW5kaW5nIGNvbW1pdHMgZm9yIGNvbW1pdCBncmFwaCBpbiAlZCBwYWNrcyIKIG1zZ3N0clswXSAiUmljZXJjYSBkZWkgY29tbWl0IHBlciBpbCBncmFmbyBkZWkgY29tbWl0IGluICVkIHBhY2sgaW4gY29yc28iCiBtc2dzdHJbMV0gIlJpY2VyY2EgZGVpIGNvbW1pdCBwZXIgaWwgZ3JhZm8gZGVpIGNvbW1pdCBpbiAlZCBwYWNrIGluIGNvcnNvIgogCi0jOiBjb21taXQtZ3JhcGguYzoxMTc2CisjOiBjb21taXQtZ3JhcGguYzoxMTkyCiAjLCBjLWZvcm1hdAogbXNnaWQgImVycm9yIGFkZGluZyBwYWNrICVzIgogbXNnc3RyICJlcnJvcmUgZHVyYW50ZSBsJ2FnZ2l1bnRhIGRlbCBwYWNrICVzIgogCi0jOiBjb21taXQtZ3JhcGguYzoxMTgwCisjOiBjb21taXQtZ3JhcGguYzoxMTk2CiAjLCBjLWZvcm1hdAogbXNnaWQgImVycm9yIG9wZW5pbmcgaW5kZXggZm9yICVzIgogbXNnc3RyICJlcnJvcmUgZHVyYW50ZSBsJ2FwZXJ0dXJhIGRlbGwnaW5kaWNlIHBlciAlcyIKIAotIzogY29tbWl0LWdyYXBoLmM6MTIwNAorIzogY29tbWl0LWdyYXBoLmM6MTIyMAogIywgYy1mb3JtYXQKIG1zZ2lkICJGaW5kaW5nIGNvbW1pdHMgZm9yIGNvbW1pdCBncmFwaCBmcm9tICVkIHJlZiIKIG1zZ2lkX3BsdXJhbCAiRmluZGluZyBjb21taXRzIGZvciBjb21taXQgZ3JhcGggZnJvbSAlZCByZWZzIgpAQCAtMTU1MSwxMzIgKzE1NjIsMTM3IEBACiBtc2dzdHJbMV0gIiIKICJSaWNlcmNhIGRlaSBjb21taXQgcGVyIGlsIGdyYWZvIGRlaSBjb21taXQgZGEgJWQgcmlmZXJpbWVudGkgaW4gY29yc28iCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjEyMzgKKyM6IGNvbW1pdC1ncmFwaC5jOjEyNDAKKyMsIGMtZm9ybWF0Cittc2dpZCAiaW52YWxpZCBjb21taXQgb2JqZWN0IGlkOiAlcyIKK21zZ3N0ciAiSUQgb2dnZXR0byBjb21taXQgbm9uIHZhbGlkbzogJXMiCisKKyM6IGNvbW1pdC1ncmFwaC5jOjEyNTUKIG1zZ2lkICJGaW5kaW5nIGNvbW1pdHMgZm9yIGNvbW1pdCBncmFwaCBhbW9uZyBwYWNrZWQgb2JqZWN0cyIKIG1zZ3N0ciAiIgogIlJpY2VyY2EgZGVpIGNvbW1pdCBwZXIgaWwgZ3JhZm8gZGVpIGNvbW1pdCBmcmEgZ2xpIG9nZ2V0dGkgbmVpIHBhY2sgaW4gY29yc28iCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjEyNTMKKyM6IGNvbW1pdC1ncmFwaC5jOjEyNzAKIG1zZ2lkICJDb3VudGluZyBkaXN0aW5jdCBjb21taXRzIGluIGNvbW1pdCBncmFwaCIKIG1zZ3N0ciAiQ29udGVnZ2lvIGNvbW1pdCBkaXN0aW50aSBuZWwgZ3JhZm8gZGVpIGNvbW1pdCBpbiBjb3JzbyIKIAotIzogY29tbWl0LWdyYXBoLmM6MTI4NAorIzogY29tbWl0LWdyYXBoLmM6MTMwMAogbXNnaWQgIkZpbmRpbmcgZXh0cmEgZWRnZXMgaW4gY29tbWl0IGdyYXBoIgogbXNnc3RyICJSaWNlcmNhIGRlZ2xpIGFyY2hpIGFnZ2l1bnRpdmkgbmVsIGdyYWZvIGRlaSBjb21taXQgaW4gY29yc28iCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjEzMzIKKyM6IGNvbW1pdC1ncmFwaC5jOjEzNDYKIG1zZ2lkICJmYWlsZWQgdG8gd3JpdGUgY29ycmVjdCBudW1iZXIgb2YgYmFzZSBncmFwaCBpZHMiCiBtc2dzdHIgImltcG9zc2liaWxlIHNjcml2ZXJlIGlsIG51bWVybyBlc2F0dG8gZGVnbGkgSUQgZ3JhZm8gZGkgYmFzZSIKIAotIzogY29tbWl0LWdyYXBoLmM6MTM2NSBtaWR4LmM6ODExCisjOiBjb21taXQtZ3JhcGguYzoxMzc5IG1pZHguYzo4MTAKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGNyZWF0ZSBsZWFkaW5nIGRpcmVjdG9yaWVzIG9mICVzIgogbXNnc3RyICJpbXBvc3NpYmlsZSBjcmVhcmUgbGUgcHJpbWUgZGlyZWN0b3J5IGRpICVzIgogCi0jOiBjb21taXQtZ3JhcGguYzoxMzc3IGJ1aWx0aW4vaW5kZXgtcGFjay5jOjMwNiBidWlsdGluL3JlcGFjay5jOjI0MAorIzogY29tbWl0LWdyYXBoLmM6MTM5MSBidWlsdGluL2luZGV4LXBhY2suYzozMDYgYnVpbHRpbi9yZXBhY2suYzoyNDEKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGNyZWF0ZSAnJXMnIgogbXNnc3RyICJpbXBvc3NpYmlsZSBjcmVhcmUgJyVzJyIKIAotIzogY29tbWl0LWdyYXBoLmM6MTQzNworIzogY29tbWl0LWdyYXBoLmM6MTQ1MQogIywgYy1mb3JtYXQKIG1zZ2lkICJXcml0aW5nIG91dCBjb21taXQgZ3JhcGggaW4gJWQgcGFzcyIKIG1zZ2lkX3BsdXJhbCAiV3JpdGluZyBvdXQgY29tbWl0IGdyYXBoIGluICVkIHBhc3NlcyIKIG1zZ3N0clswXSAiU2NyaXR0dXJhIGluICVkIHBhc3NhZ2dpbyBkZWwgZ3JhZm8gZGVpIGNvbW1pdCBpbiBjb3JzbyIKIG1zZ3N0clsxXSAiU2NyaXR0dXJhIGluICVkIHBhc3NhZ2dpIGRlbCBncmFmbyBkZWkgY29tbWl0IGluIGNvcnNvIgogCi0jOiBjb21taXQtZ3JhcGguYzoxNDc4CisjOiBjb21taXQtZ3JhcGguYzoxNDkyCiBtc2dpZCAidW5hYmxlIHRvIG9wZW4gY29tbWl0LWdyYXBoIGNoYWluIGZpbGUiCiBtc2dzdHIgImltcG9zc2liaWxlIGFwcmlyZSBpbCBmaWxlIGNhdGVuYSBncmFmbyBkZWkgY29tbWl0IgogCi0jOiBjb21taXQtZ3JhcGguYzoxNDkwCisjOiBjb21taXQtZ3JhcGguYzoxNTA0CiBtc2dpZCAiZmFpbGVkIHRvIHJlbmFtZSBiYXNlIGNvbW1pdC1ncmFwaCBmaWxlIgogbXNnc3RyICJpbXBvc3NpYmlsZSByaWRlbm9taW5hcmUgaWwgZmlsZSBkaSBiYXNlIGdyYWZvIGRlaSBjb21taXQiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjE1MTAKKyM6IGNvbW1pdC1ncmFwaC5jOjE1MjQKIG1zZ2lkICJmYWlsZWQgdG8gcmVuYW1lIHRlbXBvcmFyeSBjb21taXQtZ3JhcGggZmlsZSIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgcmlkZW5vbWluYXJlIGlsIGZpbGUgdGVtcG9yYW5lbyBncmFmbyBkZWkgY29tbWl0IgogCi0jOiBjb21taXQtZ3JhcGguYzoxNjIxCisjOiBjb21taXQtZ3JhcGguYzoxNjM1CiBtc2dpZCAiU2Nhbm5pbmcgbWVyZ2VkIGNvbW1pdHMiCiBtc2dzdHIgIlNjYW5zaW9uZSBkZWkgY29tbWl0IHNvdHRvcG9zdGkgYSBtZXJnZSBpbiBjb3JzbyIKIAotIzogY29tbWl0LWdyYXBoLmM6MTYzMgorIzogY29tbWl0LWdyYXBoLmM6MTY0NgogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmV4cGVjdGVkIGR1cGxpY2F0ZSBjb21taXQgaWQgJXMiCiBtc2dzdHIgIklEIGNvbW1pdCBkdXBsaWNhdG8gaW5hdHRlc286ICVzIgogCi0jOiBjb21taXQtZ3JhcGguYzoxNjU3CisjOiBjb21taXQtZ3JhcGguYzoxNjcwCiBtc2dpZCAiTWVyZ2luZyBjb21taXQtZ3JhcGgiCiBtc2dzdHIgIk1lcmdlIGRlbCBncmFmbyBkZWkgY29tbWl0IGluIGNvcnNvIgogCi0jOiBjb21taXQtZ3JhcGguYzoxODQ0CisjOiBjb21taXQtZ3JhcGguYzoxODYwCiAjLCBjLWZvcm1hdAogbXNnaWQgInRoZSBjb21taXQgZ3JhcGggZm9ybWF0IGNhbm5vdCB3cml0ZSAlZCBjb21taXRzIgogbXNnc3RyICIiCiAiaWwgZm9ybWF0byBkZWwgZ3JhZm8gZGVpIGNvbW1pdCBub24gcHXDsiBlc3NlcmUgdXNhdG8gcGVyIHNjcml2ZXJlICVkIGNvbW1pdCIKIAotIzogY29tbWl0LWdyYXBoLmM6MTg1NQorIzogY29tbWl0LWdyYXBoLmM6MTg3MQogbXNnaWQgInRvbyBtYW55IGNvbW1pdHMgdG8gd3JpdGUgZ3JhcGgiCiBtc2dzdHIgInRyb3BwaSBjb21taXQgZGEgc2NyaXZlcmUgbmVsIGdyYWZvIgogCi0jOiBjb21taXQtZ3JhcGguYzoxOTQ1CisjOiBjb21taXQtZ3JhcGguYzoxOTYxCiBtc2dpZCAidGhlIGNvbW1pdC1ncmFwaCBmaWxlIGhhcyBpbmNvcnJlY3QgY2hlY2tzdW0gYW5kIGlzIGxpa2VseSBjb3JydXB0IgogbXNnc3RyICIiCiAiaWwgZmlsZSBkZWwgZ3JhZm8gZGVpIGNvbW1pdCBoYSB1biBjaGVja3N1bSBub24gY29ycmV0dG8gZSBwcm9iYWJpbG1lbnRlIMOoICIKICJjb3Jyb3R0byIKIAotIzogY29tbWl0LWdyYXBoLmM6MTk1NQorIzogY29tbWl0LWdyYXBoLmM6MTk3MQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb21taXQtZ3JhcGggaGFzIGluY29ycmVjdCBPSUQgb3JkZXI6ICVzIHRoZW4gJXMiCiBtc2dzdHIgImlsIGdyYWZvIGRlaSBjb21taXQgaGEgdW4gb3JkaW5lIE9JRCBub24gY29ycmV0dG86ICVzIHNlZ3VpdG8gZGEgJXMiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjE5NjUgY29tbWl0LWdyYXBoLmM6MTk4MAorIzogY29tbWl0LWdyYXBoLmM6MTk4MSBjb21taXQtZ3JhcGguYzoxOTk2CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvbW1pdC1ncmFwaCBoYXMgaW5jb3JyZWN0IGZhbm91dCB2YWx1ZTogZmFub3V0WyVkXSA9ICV1ICE9ICV1IgogbXNnc3RyICIiCiAiaWwgZ3JhZm8gZGVpIGNvbW1pdCBoYSB1biB2YWxvcmUgZmFub3V0IG5vbiBjb3JyZXR0bzogZmFub3V0WyVkXSA9ICV1ICE9ICV1IgogCi0jOiBjb21taXQtZ3JhcGguYzoxOTcyCisjOiBjb21taXQtZ3JhcGguYzoxOTg4CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBwYXJzZSBjb21taXQgJXMgZnJvbSBjb21taXQtZ3JhcGgiCiBtc2dzdHIgImltcG9zc2liaWxlIGFuYWxpenphcmUgaWwgY29tbWl0ICVzIG5lbCBncmFmbyBkZWkgY29tbWl0IgogCi0jOiBjb21taXQtZ3JhcGguYzoxOTg5CisjOiBjb21taXQtZ3JhcGguYzoyMDA2CiBtc2dpZCAiVmVyaWZ5aW5nIGNvbW1pdHMgaW4gY29tbWl0IGdyYXBoIgogbXNnc3RyICJWZXJpZmljYSBkZWkgY29tbWl0IG5lbCBncmFmbyBkZWkgY29tbWl0IGluIGNvcnNvIgogCi0jOiBjb21taXQtZ3JhcGguYzoyMDAyCisjOiBjb21taXQtZ3JhcGguYzoyMDIwCiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBwYXJzZSBjb21taXQgJXMgZnJvbSBvYmplY3QgZGF0YWJhc2UgZm9yIGNvbW1pdC1ncmFwaCIKIG1zZ3N0ciAiIgogImltcG9zc2liaWxlIGFuYWxpenphcmUgaWwgY29tbWl0ICVzIGRhbCBkYXRhYmFzZSBvZ2dldHRpIHBlciBpbCBncmFmbyBkZWkgIgogImNvbW1pdCIKIAotIzogY29tbWl0LWdyYXBoLmM6MjAwOQorIzogY29tbWl0LWdyYXBoLmM6MjAyNwogIywgYy1mb3JtYXQKIG1zZ2lkICJyb290IHRyZWUgT0lEIGZvciBjb21taXQgJXMgaW4gY29tbWl0LWdyYXBoIGlzICVzICE9ICVzIgogbXNnc3RyICIiCiAibCdPSUQgZGVsbCdhbGJlcm8gcmFkaWNlIHBlciBpbCBjb21taXQgJXMgbmVsIGdyYWZvIGRlaSBjb21taXQgw6ggJXMgIT0gJXMiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjIwMTkKKyM6IGNvbW1pdC1ncmFwaC5jOjIwMzcKICMsIGMtZm9ybWF0CiBtc2dpZCAiY29tbWl0LWdyYXBoIHBhcmVudCBsaXN0IGZvciBjb21taXQgJXMgaXMgdG9vIGxvbmciCiBtc2dzdHIgImwnZWxlbmNvIGdlbml0b3JpIG5lbCBncmFmbyBkZWkgY29tbWl0IHBlciBpbCBjb21taXQgJXMgw6ggdHJvcHBvIGx1bmdvIgogCi0jOiBjb21taXQtZ3JhcGguYzoyMDI4CisjOiBjb21taXQtZ3JhcGguYzoyMDQ2CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvbW1pdC1ncmFwaCBwYXJlbnQgZm9yICVzIGlzICVzICE9ICVzIgogbXNnc3RyICJpbCBnZW5pdG9yZSBuZWwgZ3JhZm8gZGVpIGNvbW1pdCBwZXIgJXMgw6ggJXMgIT0gJXMiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjIwNDEKKyM6IGNvbW1pdC1ncmFwaC5jOjIwNTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiY29tbWl0LWdyYXBoIHBhcmVudCBsaXN0IGZvciBjb21taXQgJXMgdGVybWluYXRlcyBlYXJseSIKIG1zZ3N0ciAiIgogImwnZWxlbmNvIGdlbml0b3JpIG5lbCBncmFmbyBkZWkgY29tbWl0IHBlciBpbCBjb21taXQgJXMgw6ggZmluaXRvIHByaW1hIGRlbCAiCiAicHJldmlzdG8iCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjIwNDYKKyM6IGNvbW1pdC1ncmFwaC5jOjIwNjQKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogImNvbW1pdC1ncmFwaCBoYXMgZ2VuZXJhdGlvbiBudW1iZXIgemVybyBmb3IgY29tbWl0ICVzLCBidXQgbm9uLXplcm8gZWxzZXdoZXJlIgpAQCAtMTY4NCw3ICsxNzAwLDcgQEAKICJpbCBncmFmbyBkZWkgY29tbWl0IGhhIHVuIG51bWVybyBnZW5lcmF6aW9uZSB6ZXJvIHBlciBpbCBjb21taXQgJXMgbWEgbm9uICIKICJwYXJpIGEgemVybyBwZXIgZ2xpIGFsdHJpIgogCi0jOiBjb21taXQtZ3JhcGguYzoyMDUwCisjOiBjb21taXQtZ3JhcGguYzoyMDY4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJjb21taXQtZ3JhcGggaGFzIG5vbi16ZXJvIGdlbmVyYXRpb24gbnVtYmVyIGZvciBjb21taXQgJXMsIGJ1dCB6ZXJvIGVsc2V3aGVyZSIKQEAgLTE2OTIsMTIgKzE3MDgsMTIgQEAKICJpbCBncmFmbyBkZWkgY29tbWl0IGhhIHVuIG51bWVybyBnZW5lcmF6aW9uZSBub24gcGFyaSBhIHplcm8gcGVyIGlsIGNvbW1pdCAiCiAiJXMgbWEgcGFyaSBhIHplcm8gcGVyIGdsaSBhbHRyaSIKIAotIzogY29tbWl0LWdyYXBoLmM6MjA2NQorIzogY29tbWl0LWdyYXBoLmM6MjA4MwogIywgYy1mb3JtYXQKIG1zZ2lkICJjb21taXQtZ3JhcGggZ2VuZXJhdGlvbiBmb3IgY29tbWl0ICVzIGlzICV1ICE9ICV1IgogbXNnc3RyICJpbCBudW1lcm8gZ2VuZXJhemlvbmUgbmVsIGdyYWZvIGRlaSBjb21taXQgcGVyIGlsIGNvbW1pdCAlcyDDqCAldSAhPSAldSIKIAotIzogY29tbWl0LWdyYXBoLmM6MjA3MQorIzogY29tbWl0LWdyYXBoLmM6MjA4OQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb21taXQgZGF0ZSBmb3IgY29tbWl0ICVzIGluIGNvbW1pdC1ncmFwaCBpcyAlPFBSSXVNQVg+ICE9ICU8UFJJdU1BWD4iCiBtc2dzdHIgIiIKQEAgLTE3NDYsNyArMTc2Miw3IEBACiBtc2dpZCAia2V5IGRvZXMgbm90IGNvbnRhaW4gdmFyaWFibGUgbmFtZTogJXMiCiBtc2dzdHIgImxhIGNoaWF2ZSBub24gY29udGllbmUgdW4gbm9tZSB2YXJpYWJpbGU6ICVzIgogCi0jOiBjb25maWcuYzo0MDYgc2VxdWVuY2VyLmM6MjQ2MworIzogY29uZmlnLmM6NDA2IHNlcXVlbmNlci5jOjI0MDEKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBrZXk6ICVzIgogbXNnc3RyICJjaGlhdmUgbm9uIHZhbGlkYTogJXMiCkBAIC0xODczLDE1NSArMTg4OSwxNDggQEAKIG1zZ2lkICJpbnZhbGlkIG1vZGUgZm9yIG9iamVjdCBjcmVhdGlvbjogJXMiCiBtc2dzdHIgIm1vZGFsaXTDoCBub24gdmFsaWRhIHBlciBsYSBjcmVhemlvbmUgZGkgdW4gb2dnZXR0bzogJXMiCiAKLSM6IGNvbmZpZy5jOjE0MzAKKyM6IGNvbmZpZy5jOjE0MjUKICMsIGMtZm9ybWF0CiBtc2dpZCAibWFsZm9ybWVkIHZhbHVlIGZvciAlcyIKIG1zZ3N0ciAidmFsb3JlIG1hbGZvcm1hdG8gcGVyICVzIgogCi0jOiBjb25maWcuYzoxNDU2CisjOiBjb25maWcuYzoxNDUxCiAjLCBjLWZvcm1hdAogbXNnaWQgIm1hbGZvcm1lZCB2YWx1ZSBmb3IgJXM6ICVzIgogbXNnc3RyICJ2YWxvcmUgbWFsZm9ybWF0byBwZXIgJXM6ICVzIgogCi0jOiBjb25maWcuYzoxNDU3CisjOiBjb25maWcuYzoxNDUyCiBtc2dpZCAibXVzdCBiZSBvbmUgb2Ygbm90aGluZywgbWF0Y2hpbmcsIHNpbXBsZSwgdXBzdHJlYW0gb3IgY3VycmVudCIKIG1zZ3N0ciAiZGV2J2Vzc2VyZSBub3RoaW5nLCBtYXRjaGluZywgc2ltcGxlLCB1cHN0cmVhbSBvIGN1cnJlbnQiCiAKLSM6IGNvbmZpZy5jOjE1MTggYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozNDEwCisjOiBjb25maWcuYzoxNTEzIGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzM5NAogIywgYy1mb3JtYXQKIG1zZ2lkICJiYWQgcGFjayBjb21wcmVzc2lvbiBsZXZlbCAlZCIKIG1zZ3N0ciAibGl2ZWxsbyBjb21wcmVzc2lvbmUgcGFjayAlZCBub24gdmFsaWRvIgogCi0jOiBjb25maWcuYzoxNjM5CisjOiBjb25maWcuYzoxNjM0CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBsb2FkIGNvbmZpZyBibG9iIG9iamVjdCAnJXMnIgogbXNnc3RyICJpbXBvc3NpYmlsZSBjYXJpY2FyZSBsJ29nZ2V0dG8gYmxvYiBjb25maWd1cmF6aW9uZSAnJXMnIgogCi0jOiBjb25maWcuYzoxNjQyCisjOiBjb25maWcuYzoxNjM3CiAjLCBjLWZvcm1hdAogbXNnaWQgInJlZmVyZW5jZSAnJXMnIGRvZXMgbm90IHBvaW50IHRvIGEgYmxvYiIKIG1zZ3N0ciAiaWwgcmlmZXJpbWVudG8gJyVzJyBub24gcHVudGEgYWQgdW4gYmxvYiIKIAotIzogY29uZmlnLmM6MTY1OQorIzogY29uZmlnLmM6MTY1NAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gcmVzb2x2ZSBjb25maWcgYmxvYiAnJXMnIgogbXNnc3RyICJpbXBvc3NpYmlsZSByaXNvbHZlcmUgaWwgYmxvYiBjb25maWd1cmF6aW9uZSAnJXMnIgogCi0jOiBjb25maWcuYzoxNjg5CisjOiBjb25maWcuYzoxNjg0CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBwYXJzZSAlcyIKIG1zZ3N0ciAiYW5hbGlzaSBkaSAlcyBub24gcml1c2NpdGEiCiAKLSM6IGNvbmZpZy5jOjE3NDUKKyM6IGNvbmZpZy5jOjE3NDAKIG1zZ2lkICJ1bmFibGUgdG8gcGFyc2UgY29tbWFuZC1saW5lIGNvbmZpZyIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgYW5hbGl6emFyZSBsYSBjb25maWd1cmF6aW9uZSBhIHJpZ2EgZGkgY29tYW5kbyIKIAotIzogY29uZmlnLmM6MjA5NAorIzogY29uZmlnLmM6MjA5MQogbXNnaWQgInVua25vd24gZXJyb3Igb2NjdXJyZWQgd2hpbGUgcmVhZGluZyB0aGUgY29uZmlndXJhdGlvbiBmaWxlcyIKIG1zZ3N0ciAiIgogInNpIMOoIHZlcmlmaWNhdG8gdW4gZXJyb3JlIGltcHJldmlzdG8gZHVyYW50ZSBsYSBsZXR0dXJhIGRlaSBmaWxlIGRpICIKICJjb25maWd1cmF6aW9uZSIKIAotIzogY29uZmlnLmM6MjI2NAorIzogY29uZmlnLmM6MjI2MQogIywgYy1mb3JtYXQKIG1zZ2lkICJJbnZhbGlkICVzOiAnJXMnIgogbXNnc3RyICIlcyBub24gdmFsaWRvOiAnJXMnIgogCi0jOiBjb25maWcuYzoyMzA3Ci0jLCBjLWZvcm1hdAotbXNnaWQgInVua25vd24gY29yZS51bnRyYWNrZWRDYWNoZSB2YWx1ZSAnJXMnOyB1c2luZyAna2VlcCcgZGVmYXVsdCB2YWx1ZSIKLW1zZ3N0ciAiIgotInZhbG9yZSBjb3JlLnVudHJhY2tlZENhY2hlICclcycgbm9uIHZhbGlkbzsgdXRpbGl6emVyw7IgaWwgdmFsb3JlIHByZWRlZmluaXRvICIKLSIna2VlcCciCi0KLSM6IGNvbmZpZy5jOjIzMzMKKyM6IGNvbmZpZy5jOjIzMDYKICMsIGMtZm9ybWF0CiBtc2dpZCAic3BsaXRJbmRleC5tYXhQZXJjZW50Q2hhbmdlIHZhbHVlICclZCcgc2hvdWxkIGJlIGJldHdlZW4gMCBhbmQgMTAwIgogbXNnc3RyICIiCiAiaWwgdmFsb3JlIHNwbGl0SW5kZXgubWF4UGVyY2VudENoYW5nZSAnJWQnIGRvdnJlYmJlIGVzc2VyZSBjb21wcmVzbyBmcmEgMCBlICIKICIxMDAiCiAKLSM6IGNvbmZpZy5jOjIzNzkKKyM6IGNvbmZpZy5jOjIzNTIKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHBhcnNlICclcycgZnJvbSBjb21tYW5kLWxpbmUgY29uZmlnIgogbXNnc3RyICJpbXBvc3NpYmlsZSBhbmFsaXp6YXJlICclcycgZGFsbGEgY29uZmlndXJhemlvbmUgYSByaWdhIGRpIGNvbWFuZG8iCiAKLSM6IGNvbmZpZy5jOjIzODEKKyM6IGNvbmZpZy5jOjIzNTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiYmFkIGNvbmZpZyB2YXJpYWJsZSAnJXMnIGluIGZpbGUgJyVzJyBhdCBsaW5lICVkIgogbXNnc3RyICJ2YXJpYWJpbGUgY29uZmlndXJhemlvbmUgJyVzJyBlcnJhdGEgbmVsIGZpbGUgJyVzJyBhbGxhIHJpZ2EgJWQiCiAKLSM6IGNvbmZpZy5jOjI0NjIKKyM6IGNvbmZpZy5jOjI0MzUKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBzZWN0aW9uIG5hbWUgJyVzJyIKIG1zZ3N0ciAibm9tZSBzZXppb25lICclcycgbm9uIHZhbGlkbyIKIAotIzogY29uZmlnLmM6MjQ5NAorIzogY29uZmlnLmM6MjQ2NwogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyBoYXMgbXVsdGlwbGUgdmFsdWVzIgogbXNnc3RyICIlcyBoYSBwacO5IHZhbG9yaSIKIAotIzogY29uZmlnLmM6MjUyMworIzogY29uZmlnLmM6MjQ5NgogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gd3JpdGUgbmV3IGNvbmZpZ3VyYXRpb24gZmlsZSAlcyIKIG1zZ3N0ciAic2NyaXR0dXJhIGRlbCBudW92byBmaWxlIGRpIGNvbmZpZ3VyYXppb25lICVzIG5vbiByaXVzY2l0YSIKIAotIzogY29uZmlnLmM6Mjc3NSBjb25maWcuYzozMDk5CisjOiBjb25maWcuYzoyNzQ4IGNvbmZpZy5jOjMwNzIKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGxvY2sgY29uZmlnIGZpbGUgJXMiCiBtc2dzdHIgImltcG9zc2liaWxlIGJsb2NjYXJlIGlsIGZpbGUgZGkgY29uZmlndXJhemlvbmUgJXMiCiAKLSM6IGNvbmZpZy5jOjI3ODYKKyM6IGNvbmZpZy5jOjI3NTkKICMsIGMtZm9ybWF0CiBtc2dpZCAib3BlbmluZyAlcyIKIG1zZ3N0ciAiYXBlcnR1cmEgZGkgJXMgaW4gY29yc28iCiAKLSM6IGNvbmZpZy5jOjI4MjEgYnVpbHRpbi9jb25maWcuYzozMjgKKyM6IGNvbmZpZy5jOjI3OTQgYnVpbHRpbi9jb25maWcuYzozMjgKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBwYXR0ZXJuOiAlcyIKIG1zZ3N0ciAicGF0dGVybiBub24gdmFsaWRvOiAlcyIKIAotIzogY29uZmlnLmM6Mjg0NgorIzogY29uZmlnLmM6MjgxOQogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIGNvbmZpZyBmaWxlICVzIgogbXNnc3RyICJmaWxlIGRpIGNvbmZpZ3VyYXppb25lICVzIG5vbiB2YWxpZG8iCiAKLSM6IGNvbmZpZy5jOjI4NTkgY29uZmlnLmM6MzExMgorIzogY29uZmlnLmM6MjgzMiBjb25maWcuYzozMDg1CiAjLCBjLWZvcm1hdAogbXNnaWQgImZzdGF0IG9uICVzIGZhaWxlZCIKIG1zZ3N0ciAiZnN0YXQgZGkgJXMgbm9uIHJpdXNjaXRhIgogCi0jOiBjb25maWcuYzoyODcwCisjOiBjb25maWcuYzoyODQzCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBtbWFwICclcyciCiBtc2dzdHIgImltcG9zc2liaWxlIGVzZWd1aXJlIG1tYXAgc3UgJyVzJyIKIAotIzogY29uZmlnLmM6Mjg3OSBjb25maWcuYzozMTE3CisjOiBjb25maWcuYzoyODUyIGNvbmZpZy5jOjMwOTAKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2htb2Qgb24gJXMgZmFpbGVkIgogbXNnc3RyICJlc2VjdXppb25lIGNobW9kIHN1ICVzIG5vbiByaXVzY2l0YSIKIAotIzogY29uZmlnLmM6Mjk2NCBjb25maWcuYzozMjE0CisjOiBjb25maWcuYzoyOTM3IGNvbmZpZy5jOjMxODcKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHdyaXRlIGNvbmZpZyBmaWxlICVzIgogbXNnc3RyICJpbXBvc3NpYmlsZSBzY3JpdmVyZSBpbCBmaWxlIGRpIGNvbmZpZ3VyYXppb25lICVzIgogCi0jOiBjb25maWcuYzoyOTk4CisjOiBjb25maWcuYzoyOTcxCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBzZXQgJyVzJyB0byAnJXMnIgogbXNnc3RyICJpbXBvc3NpYmlsZSBpbXBvc3RhcmUgJyVzJyBhICclcyciCiAKLSM6IGNvbmZpZy5jOjMwMDAgYnVpbHRpbi9yZW1vdGUuYzo3ODIKKyM6IGNvbmZpZy5jOjI5NzMgYnVpbHRpbi9yZW1vdGUuYzo3ODIKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHVuc2V0ICclcyciCiBtc2dzdHIgImltcG9zc2liaWxlIGVsaW1pbmFyZSBsJ2ltcG9zdGF6aW9uZSBkaSAnJXMnIgogCi0jOiBjb25maWcuYzozMDkwCisjOiBjb25maWcuYzozMDYzCiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgc2VjdGlvbiBuYW1lOiAlcyIKIG1zZ3N0ciAibm9tZSBzZXppb25lIG5vbiB2YWxpZG86ICVzIgogCi0jOiBjb25maWcuYzozMjU3CisjOiBjb25maWcuYzozMjMwCiAjLCBjLWZvcm1hdAogbXNnaWQgIm1pc3NpbmcgdmFsdWUgZm9yICclcyciCiBtc2dzdHIgInZhbG9yZSBtYW5jYW50ZSBwZXIgJyVzJyIKQEAgLTIxNDYsNyArMjE1NSw3IEBACiBtc2dpZCAidW5rbm93biBwb3J0ICVzIgogbXNnc3RyICJwb3J0YSAlcyBzY29ub3NjaXV0YSIKIAotIzogY29ubmVjdC5jOjg0NSBjb25uZWN0LmM6MTE3MQorIzogY29ubmVjdC5jOjg0NSBjb25uZWN0LmM6MTE3NQogIywgYy1mb3JtYXQKIG1zZ2lkICJzdHJhbmdlIGhvc3RuYW1lICclcycgYmxvY2tlZCIKIG1zZ3N0ciAibm9tZSBob3N0IHN0cmFubyAnJXMnIGJsb2NjYXRvIgpAQCAtMjE2MSw2MCArMjE3MCw2MCBAQAogbXNnaWQgImNhbm5vdCBzdGFydCBwcm94eSAlcyIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgYXZ2aWFyZSBpbCBwcm94eSAlcyIKIAotIzogY29ubmVjdC5jOjkyNAorIzogY29ubmVjdC5jOjkyOAogbXNnaWQgIm5vIHBhdGggc3BlY2lmaWVkOyBzZWUgJ2dpdCBoZWxwIHB1bGwnIGZvciB2YWxpZCB1cmwgc3ludGF4IgogbXNnc3RyICIiCiAibmVzc3VuIHBlcmNvcnNvIHNwZWNpZmljYXRvOyB2ZWRlcmUgJ2dpdCBoZWxwIHB1bGwnIHBlciBsZSBzaW50YXNzaSBVUkwgIgogInZhbGlkZSIKIAotIzogY29ubmVjdC5jOjExMTkKKyM6IGNvbm5lY3QuYzoxMTIzCiBtc2dpZCAic3NoIHZhcmlhbnQgJ3NpbXBsZScgZG9lcyBub3Qgc3VwcG9ydCAtNCIKIG1zZ3N0ciAibGEgdmFyaWFudGUgU1NIICdzaW1wbGUnIG5vbiBzdXBwb3J0YSAtNCIKIAotIzogY29ubmVjdC5jOjExMzEKKyM6IGNvbm5lY3QuYzoxMTM1CiBtc2dpZCAic3NoIHZhcmlhbnQgJ3NpbXBsZScgZG9lcyBub3Qgc3VwcG9ydCAtNiIKIG1zZ3N0ciAibGEgdmFyaWFudGUgU1NIICdzaW1wbGUnIG5vbiBzdXBwb3J0YSAtNiIKIAotIzogY29ubmVjdC5jOjExNDgKKyM6IGNvbm5lY3QuYzoxMTUyCiBtc2dpZCAic3NoIHZhcmlhbnQgJ3NpbXBsZScgZG9lcyBub3Qgc3VwcG9ydCBzZXR0aW5nIHBvcnQiCiBtc2dzdHIgImxhIHZhcmlhbnRlIFNTSCAnc2ltcGxlJyBub24gc3VwcG9ydGEgbCdpbXBvc3RhemlvbmUgZGVsbGEgcG9ydGEiCiAKLSM6IGNvbm5lY3QuYzoxMjYwCisjOiBjb25uZWN0LmM6MTI2NAogIywgYy1mb3JtYXQKIG1zZ2lkICJzdHJhbmdlIHBhdGhuYW1lICclcycgYmxvY2tlZCIKIG1zZ3N0ciAicGVyY29yc28gc3RyYW5vICclcycgYmxvY2NhdG8iCiAKLSM6IGNvbm5lY3QuYzoxMzA3CisjOiBjb25uZWN0LmM6MTMxMQogbXNnaWQgInVuYWJsZSB0byBmb3JrIgogbXNnc3RyICJpbXBvc3NpYmlsZSBlc2VndWlyZSBmb3JrIgogCi0jOiBjb25uZWN0ZWQuYzo4NiBidWlsdGluL2ZzY2suYzoyMjEgYnVpbHRpbi9wcnVuZS5jOjQzCisjOiBjb25uZWN0ZWQuYzo4OCBidWlsdGluL2ZzY2suYzoyMjEgYnVpbHRpbi9wcnVuZS5jOjQzCiBtc2dpZCAiQ2hlY2tpbmcgY29ubmVjdGl2aXR5IgogbXNnc3RyICJDb250cm9sbG8gY29ubmVzc2lvbmUgaW4gY29yc28iCiAKLSM6IGNvbm5lY3RlZC5jOjk4CisjOiBjb25uZWN0ZWQuYzoxMDAKIG1zZ2lkICJDb3VsZCBub3QgcnVuICdnaXQgcmV2LWxpc3QnIgogbXNnc3RyICJJbXBvc3NpYmlsZSBlc2VndWlyZSAnZ2l0LXJldi1saXN0JyIKIAotIzogY29ubmVjdGVkLmM6MTE4CisjOiBjb25uZWN0ZWQuYzoxMjAKIG1zZ2lkICJmYWlsZWQgd3JpdGUgdG8gcmV2LWxpc3QiCiBtc2dzdHIgInNjcml0dHVyYSBuZWxsYSByZXYtbGlzdCBub24gcml1c2NpdGEiCiAKLSM6IGNvbm5lY3RlZC5jOjEyNQorIzogY29ubmVjdGVkLmM6MTI3CiBtc2dpZCAiZmFpbGVkIHRvIGNsb3NlIHJldi1saXN0J3Mgc3RkaW4iCiBtc2dzdHIgImNoaXVzdXJhIHN0YW5kYXJkIGlucHV0IGRlbGxhIHJldi1saXN0IG5vbiByaXVzY2l0YSIKIAotIzogY29udmVydC5jOjE5MworIzogY29udmVydC5jOjE5NAogIywgYy1mb3JtYXQKIG1zZ2lkICJpbGxlZ2FsIGNybGZfYWN0aW9uICVkIgogbXNnc3RyICJjcmxmX2FjdGlvbiAlZCBpbGxlY2l0YSIKIAotIzogY29udmVydC5jOjIwNgorIzogY29udmVydC5jOjIwNwogIywgYy1mb3JtYXQKIG1zZ2lkICJDUkxGIHdvdWxkIGJlIHJlcGxhY2VkIGJ5IExGIGluICVzIgogbXNnc3RyICJDUkxGIHNhcmViYmUgc29zdGl0dWl0byBkYSBMRiBpbiAlcyIKIAotIzogY29udmVydC5jOjIwOAorIzogY29udmVydC5jOjIwOQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiQ1JMRiB3aWxsIGJlIHJlcGxhY2VkIGJ5IExGIGluICVzLlxuIgpAQCAtMjIyMywxMiArMjIzMiwxMiBAQAogIkNSTEYgc2Fyw6Agc29zdGl0dWl0byBkYSBMRiBpbiAlcy5cbiIKICJJbCBmaWxlIGF2csOgIGkgc3VvaSBmaW5lIHJpZ2Egb3JpZ2luYXJpIG5lbGxhIHByb3ByaWEgZGlyZWN0b3J5IGRpIGxhdm9ybyIKIAotIzogY29udmVydC5jOjIxNgorIzogY29udmVydC5jOjIxNwogIywgYy1mb3JtYXQKIG1zZ2lkICJMRiB3b3VsZCBiZSByZXBsYWNlZCBieSBDUkxGIGluICVzIgogbXNnc3RyICJMRiBzYXJlYmJlIHNvc3RpdHVpdG8gZGEgQ1JMRiBpbiAlcyIKIAotIzogY29udmVydC5jOjIxOAorIzogY29udmVydC5jOjIxOQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiTEYgd2lsbCBiZSByZXBsYWNlZCBieSBDUkxGIGluICVzLlxuIgpAQCAtMjIzNywxMiArMjI0NiwxMiBAQAogIkxGIHNhcsOgIHNvc3RpdHVpdG8gZGEgQ1JMRiBpbiAlcy5cbiIKICJJbCBmaWxlIGF2csOgIGkgc3VvaSBmaW5lIHJpZ2Egb3JpZ2luYXJpIG5lbGxhIHByb3ByaWEgZGlyZWN0b3J5IGRpIGxhdm9ybyIKIAotIzogY29udmVydC5jOjI3OQorIzogY29udmVydC5jOjI4MAogIywgYy1mb3JtYXQKIG1zZ2lkICJCT00gaXMgcHJvaGliaXRlZCBpbiAnJXMnIGlmIGVuY29kZWQgYXMgJXMiCiBtc2dzdHIgIklsIEJPTSDDqCB2aWV0YXRvIGluICclcycgc2UgaWwgZmlsZSDDqCBjb2RpZmljYXRvIGNvbWUgJXMiCiAKLSM6IGNvbnZlcnQuYzoyODYKKyM6IGNvbnZlcnQuYzoyODcKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlRoZSBmaWxlICclcycgY29udGFpbnMgYSBieXRlIG9yZGVyIG1hcmsgKEJPTSkuIFBsZWFzZSB1c2UgVVRGLSVzIGFzIHdvcmtpbmctIgpAQCAtMjI1MSwxMiArMjI2MCwxMiBAQAogIklsIGZpbGUgJyVzJyBjb250aWVuZSB1biBpbmRpY2F0b3JlIGRlbGwnb3JkaW5lIGRlaSBieXRlIChCT00pLiBVc2FyZSBVVEYtJXMgIgogImNvbWUgY29kaWZpY2EgZGVsbCdhbGJlcm8gZGkgbGF2b3JvLiIKIAotIzogY29udmVydC5jOjMwNAorIzogY29udmVydC5jOjMwNQogIywgYy1mb3JtYXQKIG1zZ2lkICJCT00gaXMgcmVxdWlyZWQgaW4gJyVzJyBpZiBlbmNvZGVkIGFzICVzIgogbXNnc3RyICJJbCBCT00gw6ggcmljaGllc3RvIGluICclcycgc2UgaWwgZmlsZSDDqCBjb2RpZmljYXRvIGNvbWUgJXMiCiAKLSM6IGNvbnZlcnQuYzozMDYKKyM6IGNvbnZlcnQuYzozMDcKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlRoZSBmaWxlICclcycgaXMgbWlzc2luZyBhIGJ5dGUgb3JkZXIgbWFyayAoQk9NKS4gUGxlYXNlIHVzZSBVVEYtJXNCRSBvciBVVEYtIgpAQCAtMjI2Niw1MSArMjI3NSw1MSBAQAogIm8gVVRGLSVzTEUgKGEgc2Vjb25kYSBkZWxsJ29yZGluZSBkZWkgYnl0ZSkgY29tZSBjb2RpZmljYSBkZWxsJ2FsYmVybyBkaSAiCiAibGF2b3JvLiIKIAotIzogY29udmVydC5jOjQyNCBjb252ZXJ0LmM6NDk1CisjOiBjb252ZXJ0LmM6NDI1IGNvbnZlcnQuYzo0OTYKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIGVuY29kZSAnJXMnIGZyb20gJXMgdG8gJXMiCiBtc2dzdHIgImNvbnZlcnNpb25lIGRlbGxhIGNvZGlmaWNhICclcycgZGEgJXMgYSAlcyBub24gcml1c2NpdGEiCiAKLSM6IGNvbnZlcnQuYzo0NjcKKyM6IGNvbnZlcnQuYzo0NjgKICMsIGMtZm9ybWF0CiBtc2dpZCAiZW5jb2RpbmcgJyVzJyBmcm9tICVzIHRvICVzIGFuZCBiYWNrIGlzIG5vdCB0aGUgc2FtZSIKIG1zZ3N0ciAiIgogImlsIHJpc3VsdGF0byBkZWxsYSBjb2RpZmljYSBkaSAnJXMnIGRhICVzIGEgJXMgZSB2aWNldmVyc2Egbm9uIMOoIGxvIHN0ZXNzbyIKIAotIzogY29udmVydC5jOjY3MworIzogY29udmVydC5jOjY3NAogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgZm9yayB0byBydW4gZXh0ZXJuYWwgZmlsdGVyICclcyciCiBtc2dzdHIgImltcG9zc2liaWxlIGVzZWd1aXJlIGZvcmsgcGVyIGVzZWd1aXJlIGlsIGZpbHRybyBlc3Rlcm5vICclcyciCiAKLSM6IGNvbnZlcnQuYzo2OTMKKyM6IGNvbnZlcnQuYzo2OTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IGZlZWQgdGhlIGlucHV0IHRvIGV4dGVybmFsIGZpbHRlciAnJXMnIgogbXNnc3RyICJpbXBvc3NpYmlsZSBmb3JuaXJlIGwnaW5wdXQgYWwgZmlsdHJvIGVzdGVybm8gJyVzJyIKIAotIzogY29udmVydC5jOjcwMAorIzogY29udmVydC5jOjcwMQogIywgYy1mb3JtYXQKIG1zZ2lkICJleHRlcm5hbCBmaWx0ZXIgJyVzJyBmYWlsZWQgJWQiCiBtc2dzdHIgImVzZWN1emlvbmUgZGVsIGZpbHRybyBlc3Rlcm5vICclcycgbm9uIHJpdXNjaXRhOiAlZCIKIAotIzogY29udmVydC5jOjczNSBjb252ZXJ0LmM6NzM4CisjOiBjb252ZXJ0LmM6NzM2IGNvbnZlcnQuYzo3MzkKICMsIGMtZm9ybWF0CiBtc2dpZCAicmVhZCBmcm9tIGV4dGVybmFsIGZpbHRlciAnJXMnIGZhaWxlZCIKIG1zZ3N0ciAibGV0dHVyYSBkYWwgZmlsdHJvIGVzdGVybm8gJyVzJyBub24gcml1c2NpdGEiCiAKLSM6IGNvbnZlcnQuYzo3NDEgY29udmVydC5jOjc5NgorIzogY29udmVydC5jOjc0MiBjb252ZXJ0LmM6Nzk3CiAjLCBjLWZvcm1hdAogbXNnaWQgImV4dGVybmFsIGZpbHRlciAnJXMnIGZhaWxlZCIKIG1zZ3N0ciAiZXNlY3V6aW9uZSBkZWwgZmlsdHJvIGVzdGVybm8gJyVzJyBub24gcml1c2NpdGEiCiAKLSM6IGNvbnZlcnQuYzo4NDQKKyM6IGNvbnZlcnQuYzo4NDUKIG1zZ2lkICJ1bmV4cGVjdGVkIGZpbHRlciB0eXBlIgogbXNnc3RyICJ0aXBvIGZpbHRybyBpbmF0dGVzbyIKIAotIzogY29udmVydC5jOjg1NQorIzogY29udmVydC5jOjg1NgogbXNnaWQgInBhdGggbmFtZSB0b28gbG9uZyBmb3IgZXh0ZXJuYWwgZmlsdGVyIgogbXNnc3RyICJub21lIHBlcmNvcnNvIHRyb3BwbyBsdW5nbyBwZXIgaWwgZmlsdHJvIGVzdGVybm8iCiAKLSM6IGNvbnZlcnQuYzo5MjkKKyM6IGNvbnZlcnQuYzo5MzAKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogImV4dGVybmFsIGZpbHRlciAnJXMnIGlzIG5vdCBhdmFpbGFibGUgYW55bW9yZSBhbHRob3VnaCBub3QgYWxsIHBhdGhzIGhhdmUgIgpAQCAtMjMxOSw2NyArMjMyOCw2NyBAQAogImlsIGZpbHRybyBlc3Rlcm5vICclcycgbm9uIMOoIHBpw7kgZGlzcG9uaWJpbGUgbm9ub3N0YW50ZSBub24gdHV0dGkgaSBwZXJjb3JzaSAiCiAic2lhbm8gc3RhdGkgZmlsdHJhdGkiCiAKLSM6IGNvbnZlcnQuYzoxMjI4CisjOiBjb252ZXJ0LmM6MTIyOQogbXNnaWQgInRydWUvZmFsc2UgYXJlIG5vIHZhbGlkIHdvcmtpbmctdHJlZS1lbmNvZGluZ3MiCiBtc2dzdHIgInRydWUvZmFsc2Ugbm9uIHNvbm8gY29kaWZpY2hlIGRlbGwnYWxiZXJvIGRpIGxhdm9ybyB2YWxpZGUiCiAKLSM6IGNvbnZlcnQuYzoxMzk4IGNvbnZlcnQuYzoxNDMyCisjOiBjb252ZXJ0LmM6MTQxNyBjb252ZXJ0LmM6MTQ1MQogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogY2xlYW4gZmlsdGVyICclcycgZmFpbGVkIgogbXNnc3RyICIlczogZXNlY3V6aW9uZSBkZWwgZmlsdHJvIGNsZWFuICclcycgbm9uIHJpdXNjaXRhIgogCi0jOiBjb252ZXJ0LmM6MTQ3NgorIzogY29udmVydC5jOjE0OTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXM6IHNtdWRnZSBmaWx0ZXIgJXMgZmFpbGVkIgogbXNnc3RyICIlczogZXNlY3V6aW9uZSBkZWwgZmlsdHJvIHNtdWRnZSAnJXMnIG5vbiByaXVzY2l0YSIKIAotIzogZGF0ZS5jOjEzNworIzogZGF0ZS5jOjEzOAogbXNnaWQgImluIHRoZSBmdXR1cmUiCiBtc2dzdHIgImluIGZ1dHVybyIKIAotIzogZGF0ZS5jOjE0MworIzogZGF0ZS5jOjE0NAogIywgYy1mb3JtYXQKIG1zZ2lkICIlPFBSSXVNQVg+IHNlY29uZCBhZ28iCiBtc2dpZF9wbHVyYWwgIiU8UFJJdU1BWD4gc2Vjb25kcyBhZ28iCiBtc2dzdHJbMF0gIiU8UFJJdU1BWD4gc2Vjb25kbyBmYSIKIG1zZ3N0clsxXSAiJTxQUkl1TUFYPiBzZWNvbmRpIGZhIgogCi0jOiBkYXRlLmM6MTUwCisjOiBkYXRlLmM6MTUxCiAjLCBjLWZvcm1hdAogbXNnaWQgIiU8UFJJdU1BWD4gbWludXRlIGFnbyIKIG1zZ2lkX3BsdXJhbCAiJTxQUkl1TUFYPiBtaW51dGVzIGFnbyIKIG1zZ3N0clswXSAiJTxQUkl1TUFYPiBtaW51dG8gZmEiCiBtc2dzdHJbMV0gIiU8UFJJdU1BWD4gbWludXRpIGZhIgogCi0jOiBkYXRlLmM6MTU3CisjOiBkYXRlLmM6MTU4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiU8UFJJdU1BWD4gaG91ciBhZ28iCiBtc2dpZF9wbHVyYWwgIiU8UFJJdU1BWD4gaG91cnMgYWdvIgogbXNnc3RyWzBdICIlPFBSSXVNQVg+IG9yYSBmYSIKIG1zZ3N0clsxXSAiJTxQUkl1TUFYPiBvcmUgZmEiCiAKLSM6IGRhdGUuYzoxNjQKKyM6IGRhdGUuYzoxNjUKICMsIGMtZm9ybWF0CiBtc2dpZCAiJTxQUkl1TUFYPiBkYXkgYWdvIgogbXNnaWRfcGx1cmFsICIlPFBSSXVNQVg+IGRheXMgYWdvIgogbXNnc3RyWzBdICIlPFBSSXVNQVg+IGdpb3JubyBmYSIKIG1zZ3N0clsxXSAiJTxQUkl1TUFYPiBnaW9ybmkgZmEiCiAKLSM6IGRhdGUuYzoxNzAKKyM6IGRhdGUuYzoxNzEKICMsIGMtZm9ybWF0CiBtc2dpZCAiJTxQUkl1TUFYPiB3ZWVrIGFnbyIKIG1zZ2lkX3BsdXJhbCAiJTxQUkl1TUFYPiB3ZWVrcyBhZ28iCiBtc2dzdHJbMF0gIiU8UFJJdU1BWD4gc2V0dGltYW5hIGZhIgogbXNnc3RyWzFdICIlPFBSSXVNQVg+IHNldHRpbWFuZSBmYSIKIAotIzogZGF0ZS5jOjE3NworIzogZGF0ZS5jOjE3OAogIywgYy1mb3JtYXQKIG1zZ2lkICIlPFBSSXVNQVg+IG1vbnRoIGFnbyIKIG1zZ2lkX3BsdXJhbCAiJTxQUkl1TUFYPiBtb250aHMgYWdvIgogbXNnc3RyWzBdICIlPFBSSXVNQVg+IG1lc2UgZmEiCiBtc2dzdHJbMV0gIiU8UFJJdU1BWD4gbWVzaSBmYSIKIAotIzogZGF0ZS5jOjE4OAorIzogZGF0ZS5jOjE4OQogIywgYy1mb3JtYXQKIG1zZ2lkICIlPFBSSXVNQVg+IHllYXIiCiBtc2dpZF9wbHVyYWwgIiU8UFJJdU1BWD4geWVhcnMiCkBAIC0yMzg3LDE0ICsyMzk2LDE0IEBACiBtc2dzdHJbMV0gIiU8UFJJdU1BWD4gYW5uaSIKIAogIy4gVFJBTlNMQVRPUlM6ICIlcyIgaXMgIjxuPiB5ZWFycyIKLSM6IGRhdGUuYzoxOTEKKyM6IGRhdGUuYzoxOTIKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMsICU8UFJJdU1BWD4gbW9udGggYWdvIgogbXNnaWRfcGx1cmFsICIlcywgJTxQUkl1TUFYPiBtb250aHMgYWdvIgogbXNnc3RyWzBdICIlcywgJTxQUkl1TUFYPiBtZXNlIGZhIgogbXNnc3RyWzFdICIlcywgJTxQUkl1TUFYPiBtZXNpIGZhIgogCi0jOiBkYXRlLmM6MTk2IGRhdGUuYzoyMDEKKyM6IGRhdGUuYzoxOTcgZGF0ZS5jOjIwMgogIywgYy1mb3JtYXQKIG1zZ2lkICIlPFBSSXVNQVg+IHllYXIgYWdvIgogbXNnaWRfcGx1cmFsICIlPFBSSXVNQVg+IHllYXJzIGFnbyIKQEAgLTI0MzMsNyArMjQ0Miw3IEBACiBtc2dpZCAiZmFpbGVkIHRvIHJlYWQgb3JkZXJmaWxlICclcyciCiBtc2dzdHIgImxldHR1cmEgZGVsbCdvcmRlcmZpbGUgJyVzJyBub24gcml1c2NpdGEiCiAKLSM6IGRpZmZjb3JlLXJlbmFtZS5jOjU0NAorIzogZGlmZmNvcmUtcmVuYW1lLmM6NTQzCiBtc2dpZCAiUGVyZm9ybWluZyBpbmV4YWN0IHJlbmFtZSBkZXRlY3Rpb24iCiBtc2dzdHIgIlJpbGV2YW1lbnRvIHJpZGVub21pbmF6aW9uZSBub24gZXNhdHRhIGluIGNvcnNvIgogCkBAIC0yNTAyLDM2ICsyNTExLDM2IEBACiAiVHJvdmF0aSBlcnJvcmkgbmVsbGEgdmFyaWFiaWxlIGRpIGNvbmZpZ3VyYXppb25lICdkaWZmLmRpcnN0YXQnOlxuIgogIiVzIgogCi0jOiBkaWZmLmM6NDIxNQorIzogZGlmZi5jOjQyMTgKICMsIGMtZm9ybWF0CiBtc2dpZCAiZXh0ZXJuYWwgZGlmZiBkaWVkLCBzdG9wcGluZyBhdCAlcyIKIG1zZ3N0ciAicHJvY2Vzc28gZXN0ZXJubyBkaWZmIG1vcnRvLCBtaSBmZXJtbyBhICVzIgogCi0jOiBkaWZmLmM6NDU2MAorIzogZGlmZi5jOjQ1NjMKIG1zZ2lkICItLW5hbWUtb25seSwgLS1uYW1lLXN0YXR1cywgLS1jaGVjayBhbmQgLXMgYXJlIG11dHVhbGx5IGV4Y2x1c2l2ZSIKIG1zZ3N0ciAiIgogImxlIG9wemlvbmkgLS1uYW1lLW9ubHksIC0tbmFtZS1zdGF0dXMsIC0tY2hlY2sgZSAtcyBzb25vIG11dHVhbWVudGUgZXNjbHVzaXZlIgogCi0jOiBkaWZmLmM6NDU2MworIzogZGlmZi5jOjQ1NjYKIG1zZ2lkICItRywgLVMgYW5kIC0tZmluZC1vYmplY3QgYXJlIG11dHVhbGx5IGV4Y2x1c2l2ZSIKIG1zZ3N0ciAibGUgb3B6aW9uaSAtRywgLVMgZSAtLWZpbmQtb2JqZWN0IHNvbm8gbXV0dWFtZW50ZSBlc2NsdXNpdmUiCiAKLSM6IGRpZmYuYzo0NjQxCisjOiBkaWZmLmM6NDY0NAogbXNnaWQgIi0tZm9sbG93IHJlcXVpcmVzIGV4YWN0bHkgb25lIHBhdGhzcGVjIgogbXNnc3RyICItLWZvbGxvdyByaWNoaWVkZSBlc2F0dGFtZW50ZSB1bm8gc3BlY2lmaWNhdG9yZSBwZXJjb3JzbyIKIAotIzogZGlmZi5jOjQ2ODkKKyM6IGRpZmYuYzo0NjkyCiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgLS1zdGF0IHZhbHVlOiAlcyIKIG1zZ3N0ciAidmFsb3JlIG5vbiB2YWxpZG8gcGVyIC0tc3RhdDogJXMiCiAKLSM6IGRpZmYuYzo0Njk0IGRpZmYuYzo0Njk5IGRpZmYuYzo0NzA0IGRpZmYuYzo0NzA5IGRpZmYuYzo1MjIyCisjOiBkaWZmLmM6NDY5NyBkaWZmLmM6NDcwMiBkaWZmLmM6NDcwNyBkaWZmLmM6NDcxMiBkaWZmLmM6NTIyNQogIzogcGFyc2Utb3B0aW9ucy5jOjE5OSBwYXJzZS1vcHRpb25zLmM6MjAzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIGV4cGVjdHMgYSBudW1lcmljYWwgdmFsdWUiCiBtc2dzdHIgIiVzIHJpY2hpZWRlIHVuIHZhbG9yZSBudW1lcmljbyIKIAotIzogZGlmZi5jOjQ3MjYKKyM6IGRpZmYuYzo0NzI5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJGYWlsZWQgdG8gcGFyc2UgLS1kaXJzdGF0Ly1YIG9wdGlvbiBwYXJhbWV0ZXI6XG4iCkBAIC0yNTQwLDQyICsyNTQ5LDQyIEBACiAiQW5hbGlzaSBkZWwgcGFyYW1ldHJvIGRlbGwnb3B6aW9uZSAtLWRpcnN0YXQvLVggbm9uIHJpdXNjaXRhOlxuIgogIiVzIgogCi0jOiBkaWZmLmM6NDgxMQorIzogZGlmZi5jOjQ4MTQKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5rbm93biBjaGFuZ2UgY2xhc3MgJyVjJyBpbiAtLWRpZmYtZmlsdGVyPSVzIgogbXNnc3RyICJjbGFzc2UgbW9kaWZpY2EgJyVjJyBzY29ub3NjaXV0YSBpbiAtLWRpZmYtZmlsdGVyPSVzIgogCi0jOiBkaWZmLmM6NDgzNQorIzogZGlmZi5jOjQ4MzgKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5rbm93biB2YWx1ZSBhZnRlciB3cy1lcnJvci1oaWdobGlnaHQ9JS4qcyIKIG1zZ3N0ciAidmFsb3JlIHNjb25vc2NpdXRvIGRvcG8gd3MtZXJyb3ItaGlnaGxpZ2h0PSUuKnMiCiAKLSM6IGRpZmYuYzo0ODQ5CisjOiBkaWZmLmM6NDg1MgogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gcmVzb2x2ZSAnJXMnIgogbXNnc3RyICJpbXBvc3NpYmlsZSByaXNvbHZlcmUgJyVzJyIKIAotIzogZGlmZi5jOjQ4OTkgZGlmZi5jOjQ5MDUKKyM6IGRpZmYuYzo0OTAyIGRpZmYuYzo0OTA4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIGV4cGVjdHMgPG4+LzxtPiBmb3JtIgogbXNnc3RyICIlcyByaWNoaWVkZSBpbCBmb3JtYXRvIDxuPi88bT4iCiAKLSM6IGRpZmYuYzo0OTE3CisjOiBkaWZmLmM6NDkyMAogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyBleHBlY3RzIGEgY2hhcmFjdGVyLCBnb3QgJyVzJyIKIG1zZ3N0ciAiJXMgcmljaGllZGUgdW4gY2FyYXR0ZXJlLCByaWNldnV0byAnJXMnIgogCi0jOiBkaWZmLmM6NDkzOAorIzogZGlmZi5jOjQ5NDEKICMsIGMtZm9ybWF0CiBtc2dpZCAiYmFkIC0tY29sb3ItbW92ZWQgYXJndW1lbnQ6ICVzIgogbXNnc3RyICJhcmdvbWVudG8gLS1jb2xvci1tb3ZlZCBlcnJhdG86ICVzIgogCi0jOiBkaWZmLmM6NDk1NworIzogZGlmZi5jOjQ5NjAKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBtb2RlICclcycgaW4gLS1jb2xvci1tb3ZlZC13cyIKIG1zZ3N0ciAibW9kbyBub24gdmFsaWRvICclcycgaW4gLS1jb2xvci1tb3ZlZC13cyIKIAotIzogZGlmZi5jOjQ5OTcKKyM6IGRpZmYuYzo1MDAwCiBtc2dpZCAiIgogIm9wdGlvbiBkaWZmLWFsZ29yaXRobSBhY2NlcHRzIFwibXllcnNcIiwgXCJtaW5pbWFsXCIsIFwicGF0aWVuY2VcIiBhbmQgIgogIlwiaGlzdG9ncmFtXCIiCkBAIC0yNTgzLDE1MSArMjU5MiwxNTEgQEAKICJsJ29wemlvbmUgZGlmZi1hbGdvcml0aG0gYWNjZXR0YSBpIHZhbG9yaSBcIm15ZXJzXCIsIFwibWluaW1hbFwiLCBcInBhdGllbmNlIgogIlwiIGUgXCJoaXN0b2dyYW1cIiIKIAotIzogZGlmZi5jOjUwMzMgZGlmZi5jOjUwNTMKKyM6IGRpZmYuYzo1MDM2IGRpZmYuYzo1MDU2CiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgYXJndW1lbnQgdG8gJXMiCiBtc2dzdHIgImFyZ29tZW50byBub24gdmFsaWRvIHBlciAlcyIKIAotIzogZGlmZi5jOjUxOTEKKyM6IGRpZmYuYzo1MTk0CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBwYXJzZSAtLXN1Ym1vZHVsZSBvcHRpb24gcGFyYW1ldGVyOiAnJXMnIgogbXNnc3RyICJhbmFsaXNpIGRlbCBwYXJhbWV0cm8gZGVsbCdvcHppb25lIC0tc3VibW9kdWxlIG5vbiByaXVzY2l0YTogJyVzJyIKIAotIzogZGlmZi5jOjUyNDcKKyM6IGRpZmYuYzo1MjUwCiAjLCBjLWZvcm1hdAogbXNnaWQgImJhZCAtLXdvcmQtZGlmZiBhcmd1bWVudDogJXMiCiBtc2dzdHIgImFyZ29tZW50byAtLXdvcmQtZGlmZiBlcnJhdG86ICVzIgogCi0jOiBkaWZmLmM6NTI3MAorIzogZGlmZi5jOjUyNzMKIG1zZ2lkICJEaWZmIG91dHB1dCBmb3JtYXQgb3B0aW9ucyIKIG1zZ3N0ciAiT3B6aW9uaSBmb3JtYXRvIG91dHB1dCBkaWZmIgogCi0jOiBkaWZmLmM6NTI3MiBkaWZmLmM6NTI3OAorIzogZGlmZi5jOjUyNzUgZGlmZi5jOjUyODEKIG1zZ2lkICJnZW5lcmF0ZSBwYXRjaCIKIG1zZ3N0ciAiZ2VuZXJhIHBhdGNoIgogCi0jOiBkaWZmLmM6NTI3NSBidWlsdGluL2xvZy5jOjE3MgorIzogZGlmZi5jOjUyNzggYnVpbHRpbi9sb2cuYzoxNzIKIG1zZ2lkICJzdXBwcmVzcyBkaWZmIG91dHB1dCIKIG1zZ3N0ciAibm9uIHZpc3VhbGl6emFyZSBsJ291dHB1dCBkZWwgZGlmZiIKIAotIzogZGlmZi5jOjUyODAgZGlmZi5jOjUzOTQgZGlmZi5jOjU0MDEKKyM6IGRpZmYuYzo1MjgzIGRpZmYuYzo1Mzk3IGRpZmYuYzo1NDA0CiBtc2dpZCAiPG4+IgogbXNnc3RyICI8bj4iCiAKLSM6IGRpZmYuYzo1MjgxIGRpZmYuYzo1Mjg0CisjOiBkaWZmLmM6NTI4NCBkaWZmLmM6NTI4NwogbXNnaWQgImdlbmVyYXRlIGRpZmZzIHdpdGggPG4+IGxpbmVzIGNvbnRleHQiCiBtc2dzdHIgImdlbmVyYSBkaWZmIGNvbiA8bj4gcmlnaGUgZGkgY29udGVzdG8iCiAKLSM6IGRpZmYuYzo1Mjg2CisjOiBkaWZmLmM6NTI4OQogbXNnaWQgImdlbmVyYXRlIHRoZSBkaWZmIGluIHJhdyBmb3JtYXQiCiBtc2dzdHIgImdlbmVyYSBpbCBkaWZmIGluIGZvcm1hdG8gZ3JlenpvIgogCi0jOiBkaWZmLmM6NTI4OQorIzogZGlmZi5jOjUyOTIKIG1zZ2lkICJzeW5vbnltIGZvciAnLXAgLS1yYXcnIgogbXNnc3RyICJzaW5vbmltbyBkaSAnLXAgLS1yYXcnIgogCi0jOiBkaWZmLmM6NTI5MworIzogZGlmZi5jOjUyOTYKIG1zZ2lkICJzeW5vbnltIGZvciAnLXAgLS1zdGF0JyIKIG1zZ3N0ciAic2lub25pbW8gZGkgJy1wIC0tc3RhdCciCiAKLSM6IGRpZmYuYzo1Mjk3CisjOiBkaWZmLmM6NTMwMAogbXNnaWQgIm1hY2hpbmUgZnJpZW5kbHkgLS1zdGF0IgogbXNnc3RyICItLXN0YXQgbGVnZ2liaWxlIGRhIHVuYSBtYWNjaGluYSIKIAotIzogZGlmZi5jOjUzMDAKKyM6IGRpZmYuYzo1MzAzCiBtc2dpZCAib3V0cHV0IG9ubHkgdGhlIGxhc3QgbGluZSBvZiAtLXN0YXQiCiBtc2dzdHIgImVtZXR0aSBpbiBvdXRwdXQgc29sbyBsJ3VsdGltYSByaWdhIGRpIC0tc3RhdCIKIAotIzogZGlmZi5jOjUzMDIgZGlmZi5jOjUzMTAKKyM6IGRpZmYuYzo1MzA1IGRpZmYuYzo1MzEzCiBtc2dpZCAiPHBhcmFtMSxwYXJhbTI+Li4uIgogbXNnc3RyICI8cGFyYW1ldHJvMSxwYXJhbWV0cm8yPi4uLiIKIAotIzogZGlmZi5jOjUzMDMKKyM6IGRpZmYuYzo1MzA2CiBtc2dpZCAiIgogIm91dHB1dCB0aGUgZGlzdHJpYnV0aW9uIG9mIHJlbGF0aXZlIGFtb3VudCBvZiBjaGFuZ2VzIGZvciBlYWNoIHN1Yi1kaXJlY3RvcnkiCiBtc2dzdHIgIiIKICJlbWV0dGkgaW4gb3V0cHV0IGxhIGRpc3RyaWJ1emlvbmUgZGVsIG51bWVybyBkaSBtb2RpZmljaGUgcmVsYXRpdm8gYSBvZ25pICIKICJzb3R0b2RpcmVjdG9yeSIKIAotIzogZGlmZi5jOjUzMDcKKyM6IGRpZmYuYzo1MzEwCiBtc2dpZCAic3lub255bSBmb3IgLS1kaXJzdGF0PWN1bXVsYXRpdmUiCiBtc2dzdHIgInNpbm9uaW1vIGRpIC0tZGlyc3RhdD1jdW11bGF0aXZlIgogCi0jOiBkaWZmLmM6NTMxMQorIzogZGlmZi5jOjUzMTQKIG1zZ2lkICJzeW5vbnltIGZvciAtLWRpcnN0YXQ9ZmlsZXMscGFyYW0xLHBhcmFtMi4uLiIKIG1zZ3N0ciAic2lub25pbW8gZGkgLS1kaXJzdGF0PWZpbGVzLHBhcmFtZXRybzEscGFyYW1ldHJvMi4uLiIKIAotIzogZGlmZi5jOjUzMTUKKyM6IGRpZmYuYzo1MzE4CiBtc2dpZCAid2FybiBpZiBjaGFuZ2VzIGludHJvZHVjZSBjb25mbGljdCBtYXJrZXJzIG9yIHdoaXRlc3BhY2UgZXJyb3JzIgogbXNnc3RyICIiCiAiYXZ2aXNhIHNlIGxlIG1vZGlmaWNoZSBpbnRyb2R1Y29ubyBtYXJjYXRvcmkgY29uZmxpdHRvIG8gZXJyb3JpIHNwYXppIGJpYW5jaGkiCiAKLSM6IGRpZmYuYzo1MzE4CisjOiBkaWZmLmM6NTMyMQogbXNnaWQgImNvbmRlbnNlZCBzdW1tYXJ5IHN1Y2ggYXMgY3JlYXRpb25zLCByZW5hbWVzIGFuZCBtb2RlIGNoYW5nZXMiCiBtc2dzdHIgIiIKICJyaWFzc3VudG8gY29uY2lzbyAoYWQgZXMuIGVsZW1lbnRpIGNyZWF0aSwgcmlkZW5vbWluYXRpIGUgbW9kaWZpY2hlIG1vZGkpIgogCi0jOiBkaWZmLmM6NTMyMQorIzogZGlmZi5jOjUzMjQKIG1zZ2lkICJzaG93IG9ubHkgbmFtZXMgb2YgY2hhbmdlZCBmaWxlcyIKIG1zZ3N0ciAidmlzdWFsaXp6YSBzb2xvIGkgbm9taSBkZWkgZmlsZSBtb2RpZmljYXRpIgogCi0jOiBkaWZmLmM6NTMyNAorIzogZGlmZi5jOjUzMjcKIG1zZ2lkICJzaG93IG9ubHkgbmFtZXMgYW5kIHN0YXR1cyBvZiBjaGFuZ2VkIGZpbGVzIgogbXNnc3RyICJ2aXN1YWxpenphIHNvbG8gaSBub21pIGUgbG8gc3RhdG8gZGVpIGZpbGUgbW9kaWZpY2F0aSIKIAotIzogZGlmZi5jOjUzMjYKKyM6IGRpZmYuYzo1MzI5CiBtc2dpZCAiPHdpZHRoPlssPG5hbWUtd2lkdGg+Wyw8Y291bnQ+XV0iCiBtc2dzdHIgIjxhbXBpZXp6YT5bLDxhbXBpZXp6YSBub21lPlssPG51bWVybz5dXSIKIAotIzogZGlmZi5jOjUzMjcKKyM6IGRpZmYuYzo1MzMwCiBtc2dpZCAiZ2VuZXJhdGUgZGlmZnN0YXQiCiBtc2dzdHIgImdlbmVyYSBkaWZmc3RhdCIKIAotIzogZGlmZi5jOjUzMjkgZGlmZi5jOjUzMzIgZGlmZi5jOjUzMzUKKyM6IGRpZmYuYzo1MzMyIGRpZmYuYzo1MzM1IGRpZmYuYzo1MzM4CiBtc2dpZCAiPHdpZHRoPiIKIG1zZ3N0ciAiPGFtcGllenphPiIKIAotIzogZGlmZi5jOjUzMzAKKyM6IGRpZmYuYzo1MzMzCiBtc2dpZCAiZ2VuZXJhdGUgZGlmZnN0YXQgd2l0aCBhIGdpdmVuIHdpZHRoIgogbXNnc3RyICJnZW5lcmEgaWwgZGlmZnN0YXQgY29uIHVuJ2FtcGllenphIHNwZWNpZmljYXRhIgogCi0jOiBkaWZmLmM6NTMzMworIzogZGlmZi5jOjUzMzYKIG1zZ2lkICJnZW5lcmF0ZSBkaWZmc3RhdCB3aXRoIGEgZ2l2ZW4gbmFtZSB3aWR0aCIKIG1zZ3N0ciAiZ2VuZXJhIGlsIGRpZmZzdGF0IGNvbiB1bidhbXBpZXp6YSBub21pIHNwZWNpZmljYXRhIgogCi0jOiBkaWZmLmM6NTMzNgorIzogZGlmZi5jOjUzMzkKIG1zZ2lkICJnZW5lcmF0ZSBkaWZmc3RhdCB3aXRoIGEgZ2l2ZW4gZ3JhcGggd2lkdGgiCiBtc2dzdHIgImdlbmVyYSBpbCBkaWZmc3RhdCBjb24gdW4nYW1waWV6emEgZ3JhZm8gc3BlY2lmaWNhdGEiCiAKLSM6IGRpZmYuYzo1MzM4CisjOiBkaWZmLmM6NTM0MQogbXNnaWQgIjxjb3VudD4iCiBtc2dzdHIgIjxudW1lcm8+IgogCi0jOiBkaWZmLmM6NTMzOQorIzogZGlmZi5jOjUzNDIKIG1zZ2lkICJnZW5lcmF0ZSBkaWZmc3RhdCB3aXRoIGxpbWl0ZWQgbGluZXMiCiBtc2dzdHIgImdlbmVyYSBpbCBkaWZmc3RhdCBjb24gcmlnaGUgbGltaXRhdGUiCiAKLSM6IGRpZmYuYzo1MzQyCisjOiBkaWZmLmM6NTM0NQogbXNnaWQgImdlbmVyYXRlIGNvbXBhY3Qgc3VtbWFyeSBpbiBkaWZmc3RhdCIKIG1zZ3N0ciAiZ2VuZXJhIHJpYXNzdW50byBjb25jaXNvIG5lbCBkaWZmc3RhdCIKIAotIzogZGlmZi5jOjUzNDUKKyM6IGRpZmYuYzo1MzQ4CiBtc2dpZCAib3V0cHV0IGEgYmluYXJ5IGRpZmYgdGhhdCBjYW4gYmUgYXBwbGllZCIKIG1zZ3N0ciAic3RhbXBhIGluIG91dHB1dCB1biBkaWZmIGJpbmFyaW8gY2hlIHB1w7IgZXNzZXJlIGFwcGxpY2F0byIKIAotIzogZGlmZi5jOjUzNDgKKyM6IGRpZmYuYzo1MzUxCiBtc2dpZCAic2hvdyBmdWxsIHByZS0gYW5kIHBvc3QtaW1hZ2Ugb2JqZWN0IG5hbWVzIG9uIHRoZSBcImluZGV4XCIgbGluZXMiCiBtc2dzdHIgInZpc3VhbGl6emEgaSBub21pIG9nZ2V0dG8gcHJlIGUgcG9zdCBpbW1hZ2luZSBuZWxsZSByaWdoZSBcImluZGljZVwiIgogCi0jOiBkaWZmLmM6NTM1MAorIzogZGlmZi5jOjUzNTMKIG1zZ2lkICJzaG93IGNvbG9yZWQgZGlmZiIKIG1zZ3N0ciAidmlzdWFsaXp6YSBkaWZmIGNvbG9yYXRvIgogCi0jOiBkaWZmLmM6NTM1MQorIzogZGlmZi5jOjUzNTQKIG1zZ2lkICI8a2luZD4iCiBtc2dzdHIgIjx0aXBvPiIKIAotIzogZGlmZi5jOjUzNTIKKyM6IGRpZmYuYzo1MzU1CiBtc2dpZCAiIgogImhpZ2hsaWdodCB3aGl0ZXNwYWNlIGVycm9ycyBpbiB0aGUgJ2NvbnRleHQnLCAnb2xkJyBvciAnbmV3JyBsaW5lcyBpbiB0aGUgIgogImRpZmYiCkBAIC0yNzM1LDcgKzI3NDQsNyBAQAogImV2aWRlbnppYSBnbGkgZXJyb3JpIGRpIHNwYXppIGJpYW5jaGkgbmVsbGUgcmlnaGUgJ2NvbnRlc3RvJywgJ3ZlY2NoaWUnIG8gIgogIidudW92ZScgbmVsIGRpZmYiCiAKLSM6IGRpZmYuYzo1MzU1CisjOiBkaWZmLmM6NTM1OAogbXNnaWQgIiIKICJkbyBub3QgbXVuZ2UgcGF0aG5hbWVzIGFuZCB1c2UgTlVMcyBhcyBvdXRwdXQgZmllbGQgdGVybWluYXRvcnMgaW4gLS1yYXcgb3IgIgogIi0tbnVtc3RhdCIKQEAgLTI3NDMsOTEgKzI3NTIsOTEgQEAKICJub24gcmltdW92ZXJlIGkgbm9taSBwZXJjb3JzbyBlIHVzYXJlIGNhcmF0dGVyaSBOVUwgY29tZSB0ZXJtaW5hdG9yaSBjYW1wbyAiCiAiaW4gLS1yYXcgbyAtLW51bXN0YXQiCiAKLSM6IGRpZmYuYzo1MzU4IGRpZmYuYzo1MzYxIGRpZmYuYzo1MzY0IGRpZmYuYzo1NDcwCisjOiBkaWZmLmM6NTM2MSBkaWZmLmM6NTM2NCBkaWZmLmM6NTM2NyBkaWZmLmM6NTQ3MwogbXNnaWQgIjxwcmVmaXg+IgogbXNnc3RyICI8cHJlZmlzc28+IgogCi0jOiBkaWZmLmM6NTM1OQorIzogZGlmZi5jOjUzNjIKIG1zZ2lkICJzaG93IHRoZSBnaXZlbiBzb3VyY2UgcHJlZml4IGluc3RlYWQgb2YgXCJhL1wiIgogbXNnc3RyICJ2aXN1YWxpenphIGlsIHByZWZpc3NvIHNvcmdlbnRlIHNwZWNpZmljYXRvIGludmVjZSBkaSBcImEvXCIiCiAKLSM6IGRpZmYuYzo1MzYyCisjOiBkaWZmLmM6NTM2NQogbXNnaWQgInNob3cgdGhlIGdpdmVuIGRlc3RpbmF0aW9uIHByZWZpeCBpbnN0ZWFkIG9mIFwiYi9cIiIKIG1zZ3N0ciAidmlzdWFsaXp6YSBpbCBwcmVmaXNzbyBkZXN0aW5hemlvbmUgc3BlY2lmaWNhdG8gaW52ZWNlIGRpIFwiYi9cIiIKIAotIzogZGlmZi5jOjUzNjUKKyM6IGRpZmYuYzo1MzY4CiBtc2dpZCAicHJlcGVuZCBhbiBhZGRpdGlvbmFsIHByZWZpeCB0byBldmVyeSBsaW5lIG9mIG91dHB1dCIKIG1zZ3N0ciAiYW50ZXBvbmkgdW4gcHJlZmlzc28gYWdnaXVudGl2byBhZCBvZ25pIHJpZ2EgZGVsbCdvdXRwdXQiCiAKLSM6IGRpZmYuYzo1MzY4CisjOiBkaWZmLmM6NTM3MQogbXNnaWQgImRvIG5vdCBzaG93IGFueSBzb3VyY2Ugb3IgZGVzdGluYXRpb24gcHJlZml4IgogbXNnc3RyICJub24gdmlzdWFsaXp6YXJlIGFsY3VuIHByZWZpc3NvIHNvcmdlbnRlIG8gZGVzdGluYXppb25lIgogCi0jOiBkaWZmLmM6NTM3MQorIzogZGlmZi5jOjUzNzQKIG1zZ2lkICJzaG93IGNvbnRleHQgYmV0d2VlbiBkaWZmIGh1bmtzIHVwIHRvIHRoZSBzcGVjaWZpZWQgbnVtYmVyIG9mIGxpbmVzIgogbXNnc3RyICIiCiAidmlzdWFsaXp6YSBpbCBjb250ZXN0byB0cmEgZ2xpIGh1bmsgZGVsIGRpZmYgZmlubyBhbCBudW1lcm8gZGkgcmlnaGUgIgogInNwZWNpZmljYXRvIgogCi0jOiBkaWZmLmM6NTM3NSBkaWZmLmM6NTM4MCBkaWZmLmM6NTM4NQorIzogZGlmZi5jOjUzNzggZGlmZi5jOjUzODMgZGlmZi5jOjUzODgKIG1zZ2lkICI8Y2hhcj4iCiBtc2dzdHIgIjxjYXJhdHRlcmU+IgogCi0jOiBkaWZmLmM6NTM3NgorIzogZGlmZi5jOjUzNzkKIG1zZ2lkICJzcGVjaWZ5IHRoZSBjaGFyYWN0ZXIgdG8gaW5kaWNhdGUgYSBuZXcgbGluZSBpbnN0ZWFkIG9mICcrJyIKIG1zZ3N0ciAic3BlY2lmaWNhIGlsIGNhcmF0dGVyZSBjaGUgaW5kaWNhIHVuYSBudW92YSByaWdhIGFsIHBvc3RvIGRpICcrJyIKIAotIzogZGlmZi5jOjUzODEKKyM6IGRpZmYuYzo1Mzg0CiBtc2dpZCAic3BlY2lmeSB0aGUgY2hhcmFjdGVyIHRvIGluZGljYXRlIGFuIG9sZCBsaW5lIGluc3RlYWQgb2YgJy0nIgogbXNnc3RyICJzcGVjaWZpY2EgaWwgY2FyYXR0ZXJlIGNoZSBpbmRpY2EgdW5hIHZlY2NoaWEgcmlnYSBhbCBwb3N0byBkaSAnLSciCiAKLSM6IGRpZmYuYzo1Mzg2CisjOiBkaWZmLmM6NTM4OQogbXNnaWQgInNwZWNpZnkgdGhlIGNoYXJhY3RlciB0byBpbmRpY2F0ZSBhIGNvbnRleHQgaW5zdGVhZCBvZiAnICciCiBtc2dzdHIgInNwZWNpZmljYSBpbCBjYXJhdHRlcmUgY2hlIGluZGljYSB1biBjb250ZXN0byBhbCBwb3N0byBkaSAnICciCiAKLSM6IGRpZmYuYzo1Mzg5CisjOiBkaWZmLmM6NTM5MgogbXNnaWQgIkRpZmYgcmVuYW1lIG9wdGlvbnMiCiBtc2dzdHIgIk9wemlvbmkgcmlub21pbmF6aW9uZSBkaWZmIgogCi0jOiBkaWZmLmM6NTM5MAorIzogZGlmZi5jOjUzOTMKIG1zZ2lkICI8bj5bLzxtPl0iCiBtc2dzdHIgIjxuPlsvPG0+XSIKIAotIzogZGlmZi5jOjUzOTEKKyM6IGRpZmYuYzo1Mzk0CiBtc2dpZCAiYnJlYWsgY29tcGxldGUgcmV3cml0ZSBjaGFuZ2VzIGludG8gcGFpcnMgb2YgZGVsZXRlIGFuZCBjcmVhdGUiCiBtc2dzdHIgIiIKICJzcGV6emEgbW9kaWZpY2hlIGRpIHJpc2NyaXR0dXJhIGNvbXBsZXRhIGluIGNvcHBpZSBlbGltaW5hemlvbmUvY3JlYXppb25lIgogCi0jOiBkaWZmLmM6NTM5NQorIzogZGlmZi5jOjUzOTgKIG1zZ2lkICJkZXRlY3QgcmVuYW1lcyIKIG1zZ3N0ciAicmlsZXZhIGxlIHJpZGVub21pbmF6aW9uaSIKIAotIzogZGlmZi5jOjUzOTkKKyM6IGRpZmYuYzo1NDAyCiBtc2dpZCAib21pdCB0aGUgcHJlaW1hZ2UgZm9yIGRlbGV0ZXMiCiBtc2dzdHIgIm9tZXR0aSBsYSBwcmVpbW1hZ2luZSBwZXIgbGUgZWxpbWluYXppb25pIgogCi0jOiBkaWZmLmM6NTQwMgorIzogZGlmZi5jOjU0MDUKIG1zZ2lkICJkZXRlY3QgY29waWVzIgogbXNnc3RyICJyaWxldmEgbGUgY29waWUiCiAKLSM6IGRpZmYuYzo1NDA2CisjOiBkaWZmLmM6NTQwOQogbXNnaWQgInVzZSB1bm1vZGlmaWVkIGZpbGVzIGFzIHNvdXJjZSB0byBmaW5kIGNvcGllcyIKIG1zZ3N0ciAidXNhIGZpbGUgbm9uIG1vZGlmaWNhdGkgY29tZSBzb3JnZW50ZSBwZXIgdHJvdmFyZSBjb3BpZSIKIAotIzogZGlmZi5jOjU0MDgKKyM6IGRpZmYuYzo1NDExCiBtc2dpZCAiZGlzYWJsZSByZW5hbWUgZGV0ZWN0aW9uIgogbXNnc3RyICJkaXNhYmlsaXRhIHJpbGV2YW1lbnRvIHJpZGVub21pbmF6aW9uZSIKIAotIzogZGlmZi5jOjU0MTEKKyM6IGRpZmYuYzo1NDE0CiBtc2dpZCAidXNlIGVtcHR5IGJsb2JzIGFzIHJlbmFtZSBzb3VyY2UiCiBtc2dzdHIgInVzYSBibG9iIHZ1b3RpIGNvbWUgc29yZ2VudGUgcmlkZW5vbWluYXppb25lIgogCi0jOiBkaWZmLmM6NTQxMworIzogZGlmZi5jOjU0MTYKIG1zZ2lkICJjb250aW51ZSBsaXN0aW5nIHRoZSBoaXN0b3J5IG9mIGEgZmlsZSBiZXlvbmQgcmVuYW1lcyIKIG1zZ3N0ciAiIgogImNvbnRpbnVhIGEgZWxlbmNhcmUgbGEgY3Jvbm9sb2dpYSBkaSB1biBmaWxlIGFsIGRpIGzDoCBkZWxsZSByaWRlbm9taW5hemlvbmkiCiAKLSM6IGRpZmYuYzo1NDE2CisjOiBkaWZmLmM6NTQxOQogbXNnaWQgIiIKICJwcmV2ZW50IHJlbmFtZS9jb3B5IGRldGVjdGlvbiBpZiB0aGUgbnVtYmVyIG9mIHJlbmFtZS9jb3B5IHRhcmdldHMgZXhjZWVkcyAiCiAiZ2l2ZW4gbGltaXQiCkBAIC0yODM1LDE1OSArMjg0NCwxNTkgQEAKICJpbXBlZGlzY2kgaWwgcmlsZXZhbWVudG8gcmlkZW5vbWluYXppb25lL2NvcGlhIHNlIGlsIG51bWVybyBkZWxsZSAiCiAiZGVzdGluYXppb25pIHJpZGVub21pbmF6aW9uZS9jb3BpYSBlY2NlZGUgaWwgbGltaXRlIHNwZWNpZmljYXRvIgogCi0jOiBkaWZmLmM6NTQxOAorIzogZGlmZi5jOjU0MjEKIG1zZ2lkICJEaWZmIGFsZ29yaXRobSBvcHRpb25zIgogbXNnc3RyICJPcHppb25pIGFsZ29yaXRtbyBkaWZmIgogCi0jOiBkaWZmLmM6NTQyMAorIzogZGlmZi5jOjU0MjMKIG1zZ2lkICJwcm9kdWNlIHRoZSBzbWFsbGVzdCBwb3NzaWJsZSBkaWZmIgogbXNnc3RyICJwcm9kdWNpIGlsIGRpZmYgcGnDuSBwaWNjb2xvIHBvc3NpYmlsZSIKIAotIzogZGlmZi5jOjU0MjMKKyM6IGRpZmYuYzo1NDI2CiBtc2dpZCAiaWdub3JlIHdoaXRlc3BhY2Ugd2hlbiBjb21wYXJpbmcgbGluZXMiCiBtc2dzdHIgImlnbm9yYSBnbGkgc3BhemkgYmlhbmNoaSBkdXJhbnRlIGlsIGNvbmZyb250byBkZWxsZSByaWdoZSIKIAotIzogZGlmZi5jOjU0MjYKKyM6IGRpZmYuYzo1NDI5CiBtc2dpZCAiaWdub3JlIGNoYW5nZXMgaW4gYW1vdW50IG9mIHdoaXRlc3BhY2UiCiBtc2dzdHIgImlnbm9yYSBsZSBtb2RpZmljaGUgYWwgbnVtZXJvIGRlZ2xpIHNwYXppIGJpYW5jaGkiCiAKLSM6IGRpZmYuYzo1NDI5CisjOiBkaWZmLmM6NTQzMgogbXNnaWQgImlnbm9yZSBjaGFuZ2VzIGluIHdoaXRlc3BhY2UgYXQgRU9MIgogbXNnc3RyICJpZ25vcmEgbW9kaWZpY2hlIGFnbGkgc3BhemkgYmlhbmNoaSBhIGZpbmUgcmlnYSIKIAotIzogZGlmZi5jOjU0MzIKKyM6IGRpZmYuYzo1NDM1CiBtc2dpZCAiaWdub3JlIGNhcnJpZXItcmV0dXJuIGF0IHRoZSBlbmQgb2YgbGluZSIKIG1zZ3N0ciAiaWdub3JhIGNhcmF0dGVyZSByaXRvcm5vIGEgY2FwbyBhIGZpbmUgcmlnYSIKIAotIzogZGlmZi5jOjU0MzUKKyM6IGRpZmYuYzo1NDM4CiBtc2dpZCAiaWdub3JlIGNoYW5nZXMgd2hvc2UgbGluZXMgYXJlIGFsbCBibGFuayIKIG1zZ3N0ciAiaWdub3JhIG1vZGlmaWNoZSBjaGUgcmlndWFyZGFubyBzb2xvIHJpZ2hlIHZ1b3RlIgogCi0jOiBkaWZmLmM6NTQzOAorIzogZGlmZi5jOjU0NDEKIG1zZ2lkICJoZXVyaXN0aWMgdG8gc2hpZnQgZGlmZiBodW5rIGJvdW5kYXJpZXMgZm9yIGVhc3kgcmVhZGluZyIKIG1zZ3N0ciAiIgogImV1cmlzdGljYSBwZXIgc3Bvc3RhcmUgaSBsaW1pdGkgZGVnbGkgaHVuayBuZWwgZGlmZiBwZXIgdW5hIGxldHR1cmEgYWdldm9sZSIKIAotIzogZGlmZi5jOjU0NDEKKyM6IGRpZmYuYzo1NDQ0CiBtc2dpZCAiZ2VuZXJhdGUgZGlmZiB1c2luZyB0aGUgXCJwYXRpZW5jZSBkaWZmXCIgYWxnb3JpdGhtIgogbXNnc3RyICJnZW5lcmEgaWwgZGlmZiB1c2FuZG8gbCdhbGdvcml0bW8gXCJwYXRpZW5jZSBkaWZmXCIiCiAKLSM6IGRpZmYuYzo1NDQ1CisjOiBkaWZmLmM6NTQ0OAogbXNnaWQgImdlbmVyYXRlIGRpZmYgdXNpbmcgdGhlIFwiaGlzdG9ncmFtIGRpZmZcIiBhbGdvcml0aG0iCiBtc2dzdHIgImdlbmVyYSBpbCBkaWZmIHVzYW5kbyBsJ2FsZ29yaXRtbyBcImhpc3RvZ3JhbSBkaWZmXCIiCiAKLSM6IGRpZmYuYzo1NDQ3CisjOiBkaWZmLmM6NTQ1MAogbXNnaWQgIjxhbGdvcml0aG0+IgogbXNnc3RyICI8YWxnb3JpdG1vPiIKIAotIzogZGlmZi5jOjU0NDgKKyM6IGRpZmYuYzo1NDUxCiBtc2dpZCAiY2hvb3NlIGEgZGlmZiBhbGdvcml0aG0iCiBtc2dzdHIgInNlbGV6aW9uYSB1biBhbGdvcml0bW8gZGlmZiIKIAotIzogZGlmZi5jOjU0NTAKKyM6IGRpZmYuYzo1NDUzCiBtc2dpZCAiPHRleHQ+IgogbXNnc3RyICI8dGVzdG8+IgogCi0jOiBkaWZmLmM6NTQ1MQorIzogZGlmZi5jOjU0NTQKIG1zZ2lkICJnZW5lcmF0ZSBkaWZmIHVzaW5nIHRoZSBcImFuY2hvcmVkIGRpZmZcIiBhbGdvcml0aG0iCiBtc2dzdHIgImdlbmVyYSBpbCBkaWZmIHVzYW5kbyBsJ2FsZ29yaXRtbyBcImFuY2hvcmVkIGRpZmZcIiIKIAotIzogZGlmZi5jOjU0NTMgZGlmZi5jOjU0NjIgZGlmZi5jOjU0NjUKKyM6IGRpZmYuYzo1NDU2IGRpZmYuYzo1NDY1IGRpZmYuYzo1NDY4CiBtc2dpZCAiPG1vZGU+IgogbXNnc3RyICI8bW9kYWxpdMOgPiIKIAotIzogZGlmZi5jOjU0NTQKKyM6IGRpZmYuYzo1NDU3CiBtc2dpZCAic2hvdyB3b3JkIGRpZmYsIHVzaW5nIDxtb2RlPiB0byBkZWxpbWl0IGNoYW5nZWQgd29yZHMiCiBtc2dzdHIgIiIKICJ2aXN1YWxpenphIGlsIGRpZmYgcGFyb2xhIHBlciBwYXJvbGEgdXNhbmRvIDxtb2RhbGl0w6A+IHBlciBkZWxpbWl0YXJlIGxlICIKICJwYXJvbGUgbW9kaWZpY2F0ZSIKIAotIzogZGlmZi5jOjU0NTYgZGlmZi5jOjU0NTkgZGlmZi5jOjU1MDQKKyM6IGRpZmYuYzo1NDU5IGRpZmYuYzo1NDYyIGRpZmYuYzo1NTA3CiBtc2dpZCAiPHJlZ2V4PiIKIG1zZ3N0ciAiPGVzcHJlc3Npb25lIHJlZ29sYXJlPiIKIAotIzogZGlmZi5jOjU0NTcKKyM6IGRpZmYuYzo1NDYwCiBtc2dpZCAidXNlIDxyZWdleD4gdG8gZGVjaWRlIHdoYXQgYSB3b3JkIGlzIgogbXNnc3RyICJ1c2EgPGVzcHJlc3Npb25lIHJlZ29sYXJlPiBwZXIgZGVjaWRlcmUgY29zYSBjb3N0aXR1aXNjZSB1bmEgcGFyb2xhIgogCi0jOiBkaWZmLmM6NTQ2MAorIzogZGlmZi5jOjU0NjMKIG1zZ2lkICJlcXVpdmFsZW50IHRvIC0td29yZC1kaWZmPWNvbG9yIC0td29yZC1kaWZmLXJlZ2V4PTxyZWdleD4iCiBtc2dzdHIgIiIKICJlcXVpdmFsZW50ZSBkaSAtLXdvcmQtZGlmZj1jb2xvciAtLXdvcmQtZGlmZi1yZWdleD08ZXNwcmVzc2lvbmUgcmVnb2xhcmU+IgogCi0jOiBkaWZmLmM6NTQ2MworIzogZGlmZi5jOjU0NjYKIG1zZ2lkICJtb3ZlZCBsaW5lcyBvZiBjb2RlIGFyZSBjb2xvcmVkIGRpZmZlcmVudGx5IgogbXNnc3RyICJsZSByaWdoZSBkaSBjb2RpY2Ugc3Bvc3RhdGUgc29ubyBjb2xvcmF0ZSBpbiBtb2RvIGRpdmVyc28iCiAKLSM6IGRpZmYuYzo1NDY2CisjOiBkaWZmLmM6NTQ2OQogbXNnaWQgImhvdyB3aGl0ZSBzcGFjZXMgYXJlIGlnbm9yZWQgaW4gLS1jb2xvci1tb3ZlZCIKIG1zZ3N0ciAibW9kbyBpbiBjdWkgc29ubyBpZ25vcmF0aSBnbGkgc3BhemkgYmlhbmNoaSBpbiAtLWNvbG9yLW1vdmVkIgogCi0jOiBkaWZmLmM6NTQ2OQorIzogZGlmZi5jOjU0NzIKIG1zZ2lkICJPdGhlciBkaWZmIG9wdGlvbnMiCiBtc2dzdHIgIkFsdHJlIG9wemlvbmkgZGlmZiIKIAotIzogZGlmZi5jOjU0NzEKKyM6IGRpZmYuYzo1NDc0CiBtc2dpZCAid2hlbiBydW4gZnJvbSBzdWJkaXIsIGV4Y2x1ZGUgY2hhbmdlcyBvdXRzaWRlIGFuZCBzaG93IHJlbGF0aXZlIHBhdGhzIgogbXNnc3RyICIiCiAic2UgZXNlZ3VpdG8gZGEgdW5hIHNvdHRvZGlyZWN0b3J5LCBlc2NsdWRpIGxlIG1vZGlmaWNoZSBlc3Rlcm5lIGFkIGVzc2EgZSAiCiAidmlzdWFsaXp6YSBpIHBlcmNvcnNpIHJlbGF0aXZpIgogCi0jOiBkaWZmLmM6NTQ3NQorIzogZGlmZi5jOjU0NzgKIG1zZ2lkICJ0cmVhdCBhbGwgZmlsZXMgYXMgdGV4dCIKIG1zZ3N0ciAidHJhdHRhIHR1dHRpIGkgZmlsZSBjb21lIHNlIGZvc3Nlcm8gZGkgdGVzdG8iCiAKLSM6IGRpZmYuYzo1NDc3CisjOiBkaWZmLmM6NTQ4MAogbXNnaWQgInN3YXAgdHdvIGlucHV0cywgcmV2ZXJzZSB0aGUgZGlmZiIKIG1zZ3N0ciAic2NhbWJpYSBpIGR1ZSBpbnB1dCwgZ2VuZXJhIHVuIGRpZmYgYWwgY29udHJhcmlvIgogCi0jOiBkaWZmLmM6NTQ3OQorIzogZGlmZi5jOjU0ODIKIG1zZ2lkICJleGl0IHdpdGggMSBpZiB0aGVyZSB3ZXJlIGRpZmZlcmVuY2VzLCAwIG90aGVyd2lzZSIKIG1zZ3N0ciAiZXNjaSBjb24gY29kaWNlIDEgc2UgY2kgc29ubyBkaWZmZXJlbnplLCBjb24gMCBhbHRyaW1lbnRpIgogCi0jOiBkaWZmLmM6NTQ4MQorIzogZGlmZi5jOjU0ODQKIG1zZ2lkICJkaXNhYmxlIGFsbCBvdXRwdXQgb2YgdGhlIHByb2dyYW0iCiBtc2dzdHIgImRpc2FiaWxpdGEgbCdpbnRlcm8gb3V0cHV0IGRlbCBwcm9ncmFtbWEiCiAKLSM6IGRpZmYuYzo1NDgzCisjOiBkaWZmLmM6NTQ4NgogbXNnaWQgImFsbG93IGFuIGV4dGVybmFsIGRpZmYgaGVscGVyIHRvIGJlIGV4ZWN1dGVkIgogbXNnc3RyICJjb25zZW50aSBsJ2VzZWN1emlvbmUgZGkgdW4gaGVscGVyIGRpZmYgZXN0ZXJubyIKIAotIzogZGlmZi5jOjU0ODUKKyM6IGRpZmYuYzo1NDg4CiBtc2dpZCAicnVuIGV4dGVybmFsIHRleHQgY29udmVyc2lvbiBmaWx0ZXJzIHdoZW4gY29tcGFyaW5nIGJpbmFyeSBmaWxlcyIKIG1zZ3N0ciAiIgogImVzZWd1aSBmaWx0cmkgZGkgY29udmVyc2lvbmUgaW4gdGVzdG8gZXN0ZXJuaSBxdWFuZG8gc2kgY29uZnJvbnRhbm8gZmlsZSAiCiAiYmluYXJpIgogCi0jOiBkaWZmLmM6NTQ4NworIzogZGlmZi5jOjU0OTAKIG1zZ2lkICI8d2hlbj4iCiBtc2dzdHIgIjxxdWFuZG8+IgogCi0jOiBkaWZmLmM6NTQ4OAorIzogZGlmZi5jOjU0OTEKIG1zZ2lkICJpZ25vcmUgY2hhbmdlcyB0byBzdWJtb2R1bGVzIGluIHRoZSBkaWZmIGdlbmVyYXRpb24iCiBtc2dzdHIgImlnbm9yYSBsZSBtb2RpZmljaGUgYWkgc290dG9tb2R1bGkgZHVyYW50ZSBsYSBnZW5lcmF6aW9uZSBkZWwgZGlmZiIKIAotIzogZGlmZi5jOjU0OTEKKyM6IGRpZmYuYzo1NDk0CiBtc2dpZCAiPGZvcm1hdD4iCiBtc2dzdHIgIjxmb3JtYXRvPiIKIAotIzogZGlmZi5jOjU0OTIKKyM6IGRpZmYuYzo1NDk1CiBtc2dpZCAic3BlY2lmeSBob3cgZGlmZmVyZW5jZXMgaW4gc3VibW9kdWxlcyBhcmUgc2hvd24iCiBtc2dzdHIgInNwZWNpZmljYSBjb21lIHZlcnJhbm5vIHZpc3VhbGl6emF0ZSBsZSBkaWZmZXJlbnplIG5laSBzb3R0b21vZHVsaSIKIAotIzogZGlmZi5jOjU0OTYKKyM6IGRpZmYuYzo1NDk5CiBtc2dpZCAiaGlkZSAnZ2l0IGFkZCAtTicgZW50cmllcyBmcm9tIHRoZSBpbmRleCIKIG1zZ3N0ciAibmFzY29uZGkgbGUgdm9jaSAnZ2l0IGFkZCAtTicgbmVsbCdpbmRpY2UiCiAKLSM6IGRpZmYuYzo1NDk5CisjOiBkaWZmLmM6NTUwMgogbXNnaWQgInRyZWF0ICdnaXQgYWRkIC1OJyBlbnRyaWVzIGFzIHJlYWwgaW4gdGhlIGluZGV4IgogbXNnc3RyICJ0cmF0dGEgbGUgdm9jaSAnZ2l0IGFkZCAtTicgY29tZSByZWFsaSBuZWxsJ2luZGljZSIKIAotIzogZGlmZi5jOjU1MDEKKyM6IGRpZmYuYzo1NTA0CiBtc2dpZCAiPHN0cmluZz4iCiBtc2dzdHIgIjxzdHJpbmdhPiIKIAotIzogZGlmZi5jOjU1MDIKKyM6IGRpZmYuYzo1NTA1CiBtc2dpZCAiIgogImxvb2sgZm9yIGRpZmZlcmVuY2VzIHRoYXQgY2hhbmdlIHRoZSBudW1iZXIgb2Ygb2NjdXJyZW5jZXMgb2YgdGhlIHNwZWNpZmllZCAiCiAic3RyaW5nIgpAQCAtMjk5NSw3ICszMDA0LDcgQEAKICJjZXJjYSBkaWZmZXJlbnplIGNoZSBtb2RpZmljYW5vIGlsIG51bWVybyBkaSBvY2NvcnJlbnplIGRlbGxhIHN0cmluZ2EgIgogInNwZWNpZmljYXRhIgogCi0jOiBkaWZmLmM6NTUwNQorIzogZGlmZi5jOjU1MDgKIG1zZ2lkICIiCiAibG9vayBmb3IgZGlmZmVyZW5jZXMgdGhhdCBjaGFuZ2UgdGhlIG51bWJlciBvZiBvY2N1cnJlbmNlcyBvZiB0aGUgc3BlY2lmaWVkICIKICJyZWdleCIKQEAgLTMwMDMsMjQgKzMwMTIsMjQgQEAKICJjZXJjYSBkaWZmZXJlbnplIGNoZSBtb2RpZmljYW5vIGlsIG51bWVybyBkaSBvY2NvcnJlbnplIGRlbGwnZXNwcmVzc2lvbmUgIgogInJlZ29sYXJlIHNwZWNpZmljYXRhIgogCi0jOiBkaWZmLmM6NTUwOAorIzogZGlmZi5jOjU1MTEKIG1zZ2lkICJzaG93IGFsbCBjaGFuZ2VzIGluIHRoZSBjaGFuZ2VzZXQgd2l0aCAtUyBvciAtRyIKIG1zZ3N0ciAidmlzdWFsaXp6YSB0dXR0ZSBsZSBtb2RpZmljaGUgbmVsIGNoYW5nZXNldCBjb24gLVMgbyAtRyIKIAotIzogZGlmZi5jOjU1MTEKKyM6IGRpZmYuYzo1NTE0CiBtc2dpZCAidHJlYXQgPHN0cmluZz4gaW4gLVMgYXMgZXh0ZW5kZWQgUE9TSVggcmVndWxhciBleHByZXNzaW9uIgogbXNnc3RyICIiCiAidHJhdHRhIGxhIDxzdHJpbmdhPiBuZWxsJ29wemlvbmUgLVMgY29tZSB1bidlc3ByZXNzaW9uZSByZWdvbGFyZSBQT1NJWCBlc3Rlc2EiCiAKLSM6IGRpZmYuYzo1NTE0CisjOiBkaWZmLmM6NTUxNwogbXNnaWQgImNvbnRyb2wgdGhlIG9yZGVyIGluIHdoaWNoIGZpbGVzIGFwcGVhciBpbiB0aGUgb3V0cHV0IgogbXNnc3RyICJjb250cm9sbGEgbCdvcmRpbmUgY29uIGN1aSBpIGZpbGUgYXBwYXJpcmFubm8gbmVsbCdvdXRwdXQiCiAKLSM6IGRpZmYuYzo1NTE1CisjOiBkaWZmLmM6NTUxOAogbXNnaWQgIjxvYmplY3QtaWQ+IgogbXNnc3RyICI8SUQgb2dnZXR0bz4iCiAKLSM6IGRpZmYuYzo1NTE2CisjOiBkaWZmLmM6NTUxOQogbXNnaWQgIiIKICJsb29rIGZvciBkaWZmZXJlbmNlcyB0aGF0IGNoYW5nZSB0aGUgbnVtYmVyIG9mIG9jY3VycmVuY2VzIG9mIHRoZSBzcGVjaWZpZWQgIgogIm9iamVjdCIKQEAgLTMwMjgsMzQgKzMwMzcsMzQgQEAKICJjZXJjYSBkaWZmZXJlbnplIGNoZSBtb2RpZmljYW5vIGlsIG51bWVybyBkaSBvY2NvcnJlbnplIGRlbGwnb2dnZXR0byAiCiAic3BlY2lmaWNhdG8iCiAKLSM6IGRpZmYuYzo1NTE4CisjOiBkaWZmLmM6NTUyMQogbXNnaWQgIlsoQXxDfER8TXxSfFR8VXxYfEIpLi4uWypdXSIKIG1zZ3N0ciAiWyhBfEN8RHxNfFJ8VHxVfFh8QikuLi5bKl1dIgogCi0jOiBkaWZmLmM6NTUxOQorIzogZGlmZi5jOjU1MjIKIG1zZ2lkICJzZWxlY3QgZmlsZXMgYnkgZGlmZiB0eXBlIgogbXNnc3RyICJzZWxlemlvbmEgZmlsZSBpbiBiYXNlIGFsIHRpcG8gZGlmZiIKIAotIzogZGlmZi5jOjU1MjEKKyM6IGRpZmYuYzo1NTI0CiBtc2dpZCAiPGZpbGU+IgogbXNnc3RyICI8ZmlsZT4iCiAKLSM6IGRpZmYuYzo1NTIyCisjOiBkaWZmLmM6NTUyNQogbXNnaWQgIk91dHB1dCB0byBhIHNwZWNpZmljIGZpbGUiCiBtc2dzdHIgIlNhbHZhIGwnb3V0cHV0IGluIHVuIGZpbGUgc3BlY2lmaWNvIgogCi0jOiBkaWZmLmM6NjE3NworIzogZGlmZi5jOjYxODAKIG1zZ2lkICJpbmV4YWN0IHJlbmFtZSBkZXRlY3Rpb24gd2FzIHNraXBwZWQgZHVlIHRvIHRvbyBtYW55IGZpbGVzLiIKIG1zZ3N0ciAiIgogImlsIHJpbGV2YW1lbnRvIHJpZGVub21pbmF6aW9uZSBub24gZXNhdHRhIMOoIHN0YXRvIG9tZXNzbyBwZXIgbGEgcHJlc2VuemEgZGkgIgogInRyb3BwaSBmaWxlLiIKIAotIzogZGlmZi5jOjYxODAKKyM6IGRpZmYuYzo2MTgzCiBtc2dpZCAib25seSBmb3VuZCBjb3BpZXMgZnJvbSBtb2RpZmllZCBwYXRocyBkdWUgdG8gdG9vIG1hbnkgZmlsZXMuIgogbXNnc3RyICIiCiAidHJvdmF0ZSBzb2xvIGNvcGllIGRhaSBwZXJjb3JzaSBtb2RpZmljYXRpIHBlciBsYSBwcmVzZW56YSBkaSB0cm9wcGkgZmlsZS4iCiAKLSM6IGRpZmYuYzo2MTgzCisjOiBkaWZmLmM6NjE4NgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAieW91IG1heSB3YW50IHRvIHNldCB5b3VyICVzIHZhcmlhYmxlIHRvIGF0IGxlYXN0ICVkIGFuZCByZXRyeSB0aGUgY29tbWFuZC4iCkBAIC0zMDYzLDQxICszMDcyLDQxIEBACiAicG90cmVzdGkgdm9sZXIgaW1wb3N0YXJlIGxhIHZhcmlhYmlsZSAlcyBhZCBhbG1lbm8gJWQgZSByaXByb3ZhcmUgYWQgIgogImVzZWd1aXJlIGlsIGNvbWFuZG8uIgogCi0jOiBkaXIuYzo1MzcKKyM6IGRpci5jOjU0OQogIywgYy1mb3JtYXQKIG1zZ2lkICJwYXRoc3BlYyAnJXMnIGRpZCBub3QgbWF0Y2ggYW55IGZpbGUocykga25vd24gdG8gZ2l0IgogbXNnc3RyICIiCiAibG8gc3BlY2lmaWNhdG9yZSBwZXJjb3JzbyAnJXMnIG5vbiBjb3JyaXNwb25kZSBhZCBhbGN1biBmaWxlIG5vdG8gYSBnaXQiCiAKLSM6IGRpci5jOjkyNgorIzogZGlyLmM6OTM4CiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCB1c2UgJXMgYXMgYW4gZXhjbHVkZSBmaWxlIgogbXNnc3RyICJpbXBvc3NpYmlsZSB1c2FyZSAlcyBjb21lIGZpbGUgZGkgZXNjbHVzaW9uZSIKIAotIzogZGlyLmM6MTg0MworIzogZGlyLmM6MTg3NwogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3Qgb3BlbiBkaXJlY3RvcnkgJyVzJyIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgYXByaXJlIGxhIGRpcmVjdG9yeSAnJXMnIgogCi0jOiBkaXIuYzoyMDg1CisjOiBkaXIuYzoyMTI4CiBtc2dpZCAiZmFpbGVkIHRvIGdldCBrZXJuZWwgbmFtZSBhbmQgaW5mb3JtYXRpb24iCiBtc2dzdHIgImltcG9zc2liaWxlIG90dGVuZXJlIGlsIG5vbWUgZSBsZSBpbmZvcm1hemlvbmkgc3VsIGtlcm5lbCIKIAotIzogZGlyLmM6MjIwOQorIzogZGlyLmM6MjI1MgogbXNnaWQgInVudHJhY2tlZCBjYWNoZSBpcyBkaXNhYmxlZCBvbiB0aGlzIHN5c3RlbSBvciBsb2NhdGlvbiIKIG1zZ3N0ciAibGEgY2FjaGUgbm9uIHRyYWNjaWF0YSDDqCBkaXNhYmlsaXRhdGEgc3UgcXVlc3RvIHNpc3RlbWEgbyBwZXJjb3JzbyIKIAotIzogZGlyLmM6MzAxMworIzogZGlyLmM6MzA1NgogIywgYy1mb3JtYXQKIG1zZ2lkICJpbmRleCBmaWxlIGNvcnJ1cHQgaW4gcmVwbyAlcyIKIG1zZ3N0ciAiZmlsZSBpbmRleCBjb3Jyb3R0byBuZWwgcmVwb3NpdG9yeSAlcyIKIAotIzogZGlyLmM6MzA1OCBkaXIuYzozMDYzCisjOiBkaXIuYzozMTAxIGRpci5jOjMxMDYKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGNyZWF0ZSBkaXJlY3RvcmllcyBmb3IgJXMiCiBtc2dzdHIgImltcG9zc2liaWxlIGNyZWFyZSBsZSBkaXJlY3RvcnkgcGVyICVzIgogCi0jOiBkaXIuYzozMDkyCisjOiBkaXIuYzozMTM1CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBtaWdyYXRlIGdpdCBkaXJlY3RvcnkgZnJvbSAnJXMnIHRvICclcyciCiBtc2dzdHIgImltcG9zc2liaWxlIG1pZ3JhcmUgbGEgZGlyZWN0b3J5IGdpdCBkYSAnJXMnIGEgJyVzJyIKQEAgLTMxMTcsMTIgKzMxMjYsMTIgQEAKIG1zZ2lkICJjb3VsZCBub3Qgc3RhdCBmaWxlICclcyciCiBtc2dzdHIgImltcG9zc2liaWxlIGVzZWd1aXJlIHN0YXQgc3VsIGZpbGUgJyVzJyIKIAotIzogZW52aXJvbm1lbnQuYzoxNTAKKyM6IGVudmlyb25tZW50LmM6MTQ4CiAjLCBjLWZvcm1hdAogbXNnaWQgImJhZCBnaXQgbmFtZXNwYWNlIHBhdGggXCIlc1wiIgogbXNnc3RyICJwZXJjb3JzbyBzcGF6aW8gZGVpIG5vbWkgZ2l0IFwiJXNcIiBub24gdmFsaWRvIgogCi0jOiBlbnZpcm9ubWVudC5jOjMzMgorIzogZW52aXJvbm1lbnQuYzozMzAKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHNldCBHSVRfRElSIHRvICclcyciCiBtc2dzdHIgImltcG9zc2liaWxlIGltcG9zdGFyZSBHSVRfRElSIGEgJyVzJyIKQEAgLTMxMzIsMTYwICszMTQxLDE1NiBAQAogbXNnaWQgInRvbyBtYW55IGFyZ3MgdG8gcnVuICVzIgogbXNnc3RyICJ0cm9wcGkgYXJnb21lbnRpIHBlciBlc2VndWlyZSAlcyIKIAotIzogZmV0Y2gtb2JqZWN0LmM6MTcKLW1zZ2lkICJSZW1vdGUgd2l0aCBubyBVUkwiCi1tc2dzdHIgIlJlbW90byBzZW56YSBVUkwiCi0KLSM6IGZldGNoLXBhY2suYzoxNTEKKyM6IGZldGNoLXBhY2suYzoxNTAKIG1zZ2lkICJnaXQgZmV0Y2gtcGFjazogZXhwZWN0ZWQgc2hhbGxvdyBsaXN0IgogbXNnc3RyICJnaXQgZmV0Y2gtcGFjazogYXR0ZXNhIGxpc3RhIHNoYWxsb3ciCiAKLSM6IGZldGNoLXBhY2suYzoxNTQKKyM6IGZldGNoLXBhY2suYzoxNTMKIG1zZ2lkICJnaXQgZmV0Y2gtcGFjazogZXhwZWN0ZWQgYSBmbHVzaCBwYWNrZXQgYWZ0ZXIgc2hhbGxvdyBsaXN0IgogbXNnc3RyICJnaXQgZmV0Y2gtcGFjazogYXR0ZXNvIHBhY2NoZXR0byBmbHVzaCBkb3BvIGxpc3RhIHNoYWxsb3ciCiAKLSM6IGZldGNoLXBhY2suYzoxNjUKKyM6IGZldGNoLXBhY2suYzoxNjQKIG1zZ2lkICJnaXQgZmV0Y2gtcGFjazogZXhwZWN0ZWQgQUNLL05BSywgZ290IGEgZmx1c2ggcGFja2V0IgogbXNnc3RyICJnaXQgZmV0Y2gtcGFjazogYXR0ZXNpIEFDSy9OQUssIHJpY2V2dXRvIHBhY2NoZXR0byBmbHVzaCIKIAotIzogZmV0Y2gtcGFjay5jOjE4NQorIzogZmV0Y2gtcGFjay5jOjE4NAogIywgYy1mb3JtYXQKIG1zZ2lkICJnaXQgZmV0Y2gtcGFjazogZXhwZWN0ZWQgQUNLL05BSywgZ290ICclcyciCiBtc2dzdHIgImdpdCBmZXRjaC1wYWNrOiBhdHRlc2kgQUNLL05BSywgcmljZXZ1dG8gJyVzJyIKIAotIzogZmV0Y2gtcGFjay5jOjE5NgorIzogZmV0Y2gtcGFjay5jOjE5NQogbXNnaWQgInVuYWJsZSB0byB3cml0ZSB0byByZW1vdGUiCiBtc2dzdHIgImltcG9zc2liaWxlIHNjcml2ZXJlIHN1bCByZW1vdG8iCiAKLSM6IGZldGNoLXBhY2suYzoyNTgKKyM6IGZldGNoLXBhY2suYzoyNTcKIG1zZ2lkICItLXN0YXRlbGVzcy1ycGMgcmVxdWlyZXMgbXVsdGlfYWNrX2RldGFpbGVkIgogbXNnc3RyICItLXN0YXRlbGVzcy1ycGMgcmljaGllZGUgbXVsdGlfYWNrX2RldGFpbGVkIgogCi0jOiBmZXRjaC1wYWNrLmM6MzYwIGZldGNoLXBhY2suYzoxMjg0CisjOiBmZXRjaC1wYWNrLmM6MzU2IGZldGNoLXBhY2suYzoxMjgwCiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgc2hhbGxvdyBsaW5lOiAlcyIKIG1zZ3N0ciAicmlnYSBzaGFsbG93IG5vbiB2YWxpZGE6ICclcyciCiAKLSM6IGZldGNoLXBhY2suYzozNjYgZmV0Y2gtcGFjay5jOjEyOTAKKyM6IGZldGNoLXBhY2suYzozNjIgZmV0Y2gtcGFjay5jOjEyODYKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCB1bnNoYWxsb3cgbGluZTogJXMiCiBtc2dzdHIgInJpZ2EgdW5zaGFsbG93IG5vbiB2YWxpZGE6ICclcyciCiAKLSM6IGZldGNoLXBhY2suYzozNjggZmV0Y2gtcGFjay5jOjEyOTIKKyM6IGZldGNoLXBhY2suYzozNjQgZmV0Y2gtcGFjay5jOjEyODgKICMsIGMtZm9ybWF0CiBtc2dpZCAib2JqZWN0IG5vdCBmb3VuZDogJXMiCiBtc2dzdHIgIm9nZ2V0dG8gbm9uIHRyb3ZhdG86ICVzIgogCi0jOiBmZXRjaC1wYWNrLmM6MzcxIGZldGNoLXBhY2suYzoxMjk1CisjOiBmZXRjaC1wYWNrLmM6MzY3IGZldGNoLXBhY2suYzoxMjkxCiAjLCBjLWZvcm1hdAogbXNnaWQgImVycm9yIGluIG9iamVjdDogJXMiCiBtc2dzdHIgImVycm9yZSBuZWxsJ29nZ2V0dG86ICVzIgogCi0jOiBmZXRjaC1wYWNrLmM6MzczIGZldGNoLXBhY2suYzoxMjk3CisjOiBmZXRjaC1wYWNrLmM6MzY5IGZldGNoLXBhY2suYzoxMjkzCiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vIHNoYWxsb3cgZm91bmQ6ICVzIgogbXNnc3RyICJuZXNzdW5vIHNoYWxsb3cgdHJvdmF0bzogJXMiCiAKLSM6IGZldGNoLXBhY2suYzozNzYgZmV0Y2gtcGFjay5jOjEzMDEKKyM6IGZldGNoLXBhY2suYzozNzIgZmV0Y2gtcGFjay5jOjEyOTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiZXhwZWN0ZWQgc2hhbGxvdy91bnNoYWxsb3csIGdvdCAlcyIKIG1zZ3N0ciAiYXR0ZXNpIHNoYWxsb3cvdW5zaGFsbG93LCByaWNldnV0byAlcyIKIAotIzogZmV0Y2gtcGFjay5jOjQxNworIzogZmV0Y2gtcGFjay5jOjQxNAogIywgYy1mb3JtYXQKIG1zZ2lkICJnb3QgJXMgJWQgJXMiCiBtc2dzdHIgInJpY2V2dXRvICVzICVkICVzIgogCi0jOiBmZXRjaC1wYWNrLmM6NDM0CisjOiBmZXRjaC1wYWNrLmM6NDMxCiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgY29tbWl0ICVzIgogbXNnc3RyICJjb21taXQgbm9uIHZhbGlkbzogJXMiCiAKLSM6IGZldGNoLXBhY2suYzo0NjUKKyM6IGZldGNoLXBhY2suYzo0NjIKIG1zZ2lkICJnaXZpbmcgdXAiCiBtc2dzdHIgInNtZXR0byBkaSBwcm92YXJlIgogCi0jOiBmZXRjaC1wYWNrLmM6NDc3IHByb2dyZXNzLmM6Mjc3CisjOiBmZXRjaC1wYWNrLmM6NDc1IHByb2dyZXNzLmM6MzEyCiBtc2dpZCAiZG9uZSIKIG1zZ3N0ciAiZmF0dG8iCiAKLSM6IGZldGNoLXBhY2suYzo0ODkKKyM6IGZldGNoLXBhY2suYzo0ODcKICMsIGMtZm9ybWF0CiBtc2dpZCAiZ290ICVzICglZCkgJXMiCiBtc2dzdHIgInJpY2V2dXRvICVzICglZCkgJXMiCiAKLSM6IGZldGNoLXBhY2suYzo1MzUKKyM6IGZldGNoLXBhY2suYzo1MzMKICMsIGMtZm9ybWF0CiBtc2dpZCAiTWFya2luZyAlcyBhcyBjb21wbGV0ZSIKIG1zZ3N0ciAiQ29udHJhc3NlZ25vICVzIGNvbWUgY29tcGxldG8iCiAKLSM6IGZldGNoLXBhY2suYzo3NDQKKyM6IGZldGNoLXBhY2suYzo3NDIKICMsIGMtZm9ybWF0CiBtc2dpZCAiYWxyZWFkeSBoYXZlICVzICglcykiCiBtc2dzdHIgImhvIGdpw6AgJXMgKCVzKSIKIAotIzogZmV0Y2gtcGFjay5jOjc4MworIzogZmV0Y2gtcGFjay5jOjc4MQogbXNnaWQgImZldGNoLXBhY2s6IHVuYWJsZSB0byBmb3JrIG9mZiBzaWRlYmFuZCBkZW11bHRpcGxleGVyIgogbXNnc3RyICIiCiAiZmV0Y2gtcGFjazogaW1wb3NzaWJpbGUgZXNlZ3VpcmUgaWwgZm9yayBkZWwgZGVtdWx0aXBsZXhlciBkZWxsYSBiYW5kYSAiCiAibGF0ZXJsYWUiCiAKLSM6IGZldGNoLXBhY2suYzo3OTEKKyM6IGZldGNoLXBhY2suYzo3ODkKIG1zZ2lkICJwcm90b2NvbCBlcnJvcjogYmFkIHBhY2sgaGVhZGVyIgogbXNnc3RyICJlcnJvcmUgcHJvdG9jb2xsbzogaW50ZXN0YXppb25lIHBhY2sgbm9uIHZhbGlkYSIKIAotIzogZmV0Y2gtcGFjay5jOjg1OQorIzogZmV0Y2gtcGFjay5jOjg1NwogIywgYy1mb3JtYXQKIG1zZ2lkICJmZXRjaC1wYWNrOiB1bmFibGUgdG8gZm9yayBvZmYgJXMiCiBtc2dzdHIgImZldGNoLXBhY2s6IGltcG9zc2liaWxlIGVzZWd1aXJlIGlsIGZvcmsgZGkgJXMiCiAKLSM6IGZldGNoLXBhY2suYzo4NzUKKyM6IGZldGNoLXBhY2suYzo4NzMKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgZmFpbGVkIgogbXNnc3RyICIlcyBub24gcml1c2NpdG8iCiAKLSM6IGZldGNoLXBhY2suYzo4NzcKKyM6IGZldGNoLXBhY2suYzo4NzUKIG1zZ2lkICJlcnJvciBpbiBzaWRlYmFuZCBkZW11bHRpcGxleGVyIgogbXNnc3RyICJlcnJvcmUgbmVsIGRlbXVsdGlwbGV4ZXIgZGVsbGEgYmFuZGEgbGF0ZXJhbGUiCiAKLSM6IGZldGNoLXBhY2suYzo5MDgKKyM6IGZldGNoLXBhY2suYzo5MDcKICMsIGMtZm9ybWF0CiBtc2dpZCAiU2VydmVyIHZlcnNpb24gaXMgJS4qcyIKIG1zZ3N0ciAiTGEgdmVyc2lvbmUgZGVsIHNlcnZlciDDqCAlLipzIgogCi0jOiBmZXRjaC1wYWNrLmM6OTEzIGZldGNoLXBhY2suYzo5MTkgZmV0Y2gtcGFjay5jOjkyMiBmZXRjaC1wYWNrLmM6OTI4Ci0jOiBmZXRjaC1wYWNrLmM6OTMyIGZldGNoLXBhY2suYzo5MzYgZmV0Y2gtcGFjay5jOjk0MCBmZXRjaC1wYWNrLmM6OTQ0Ci0jOiBmZXRjaC1wYWNrLmM6OTQ4IGZldGNoLXBhY2suYzo5NTIgZmV0Y2gtcGFjay5jOjk1NiBmZXRjaC1wYWNrLmM6OTYwCi0jOiBmZXRjaC1wYWNrLmM6OTY2IGZldGNoLXBhY2suYzo5NzIgZmV0Y2gtcGFjay5jOjk3NyBmZXRjaC1wYWNrLmM6OTgyCisjOiBmZXRjaC1wYWNrLmM6OTEyIGZldGNoLXBhY2suYzo5MTggZmV0Y2gtcGFjay5jOjkyMSBmZXRjaC1wYWNrLmM6OTI3CisjOiBmZXRjaC1wYWNrLmM6OTMxIGZldGNoLXBhY2suYzo5MzUgZmV0Y2gtcGFjay5jOjkzOSBmZXRjaC1wYWNrLmM6OTQzCisjOiBmZXRjaC1wYWNrLmM6OTQ3IGZldGNoLXBhY2suYzo5NTEgZmV0Y2gtcGFjay5jOjk1NSBmZXRjaC1wYWNrLmM6OTU5CisjOiBmZXRjaC1wYWNrLmM6OTY1IGZldGNoLXBhY2suYzo5NzEgZmV0Y2gtcGFjay5jOjk3NiBmZXRjaC1wYWNrLmM6OTgxCiAjLCBjLWZvcm1hdAogbXNnaWQgIlNlcnZlciBzdXBwb3J0cyAlcyIKIG1zZ3N0ciAiSWwgc2VydmVyIHN1cHBvcnRhICVzIgogCi0jOiBmZXRjaC1wYWNrLmM6OTE1CisjOiBmZXRjaC1wYWNrLmM6OTE0CiBtc2dpZCAiU2VydmVyIGRvZXMgbm90IHN1cHBvcnQgc2hhbGxvdyBjbGllbnRzIgogbXNnc3RyICJJbCBzZXJ2ZXIgbm9uIHN1cHBvcnRhIGNsaWVudCBzaGFsbG93IgogCi0jOiBmZXRjaC1wYWNrLmM6OTc1CisjOiBmZXRjaC1wYWNrLmM6OTc0CiBtc2dpZCAiU2VydmVyIGRvZXMgbm90IHN1cHBvcnQgLS1zaGFsbG93LXNpbmNlIgogbXNnc3RyICJJbCBzZXJ2ZXIgbm9uIHN1cHBvcnRhIC0tc2hhbGxvdy1zaW5jZSIKIAotIzogZmV0Y2gtcGFjay5jOjk4MAorIzogZmV0Y2gtcGFjay5jOjk3OQogbXNnaWQgIlNlcnZlciBkb2VzIG5vdCBzdXBwb3J0IC0tc2hhbGxvdy1leGNsdWRlIgogbXNnc3RyICJJbCBzZXJ2ZXIgbm9uIHN1cHBvcnRhIC0tc2hhbGxvdy1leGNsdWRlIgogCi0jOiBmZXRjaC1wYWNrLmM6OTg0CisjOiBmZXRjaC1wYWNrLmM6OTgzCiBtc2dpZCAiU2VydmVyIGRvZXMgbm90IHN1cHBvcnQgLS1kZWVwZW4iCiBtc2dzdHIgIklsIHNlcnZlciBub24gc3VwcG9ydGEgLS1kZWVwZW4iCiAKLSM6IGZldGNoLXBhY2suYzoxMDAxCisjOiBmZXRjaC1wYWNrLmM6MTAwMAogbXNnaWQgIm5vIGNvbW1vbiBjb21taXRzIgogbXNnc3RyICJuZXNzdW4gY29tbWl0IGluIGNvbXVuZSIKIAotIzogZmV0Y2gtcGFjay5jOjEwMTMgZmV0Y2gtcGFjay5jOjE0NjIKKyM6IGZldGNoLXBhY2suYzoxMDEyIGZldGNoLXBhY2suYzoxNDY4CiBtc2dpZCAiZ2l0IGZldGNoLXBhY2s6IGZldGNoIGZhaWxlZC4iCiBtc2dzdHIgImdpdCBmZXRjaC1wYWNrOiByZWN1cGVybyBub24gcml1c2NpdG8uIgogCi0jOiBmZXRjaC1wYWNrLmM6MTE1MQorIzogZmV0Y2gtcGFjay5jOjExNTAKIG1zZ2lkICJTZXJ2ZXIgZG9lcyBub3Qgc3VwcG9ydCBzaGFsbG93IHJlcXVlc3RzIgogbXNnc3RyICJJbCBzZXJ2ZXIgbm9uIHN1cHBvcnRhIGxlIHJpY2hpZXN0ZSBzaGFsbG93IgogCkBAIC0zMjkzLDczICszMjk4LDczIEBACiBtc2dpZCAiU2VydmVyIHN1cHBvcnRzIGZpbHRlciIKIG1zZ3N0ciAiSWwgc2VydmVyIHN1cHBvcnRhIGZpbHRlciIKIAotIzogZmV0Y2gtcGFjay5jOjExODQKKyM6IGZldGNoLXBhY2suYzoxMTgwCiBtc2dpZCAidW5hYmxlIHRvIHdyaXRlIHJlcXVlc3QgdG8gcmVtb3RlIgogbXNnc3RyICJpbXBvc3NpYmlsZSBzY3JpdmVyZSBsYSByaWNoaWVzdGEgc3VsIHJlbW90byIKIAotIzogZmV0Y2gtcGFjay5jOjEyMDIKKyM6IGZldGNoLXBhY2suYzoxMTk4CiAjLCBjLWZvcm1hdAogbXNnaWQgImVycm9yIHJlYWRpbmcgc2VjdGlvbiBoZWFkZXIgJyVzJyIKIG1zZ3N0ciAiZXJyb3JlIGR1cmFudGUgbGEgbGV0dHVyYSBkZWxsJ2ludGVzdGF6aW9uZSBkaSBzZXppb25lICclcyciCiAKLSM6IGZldGNoLXBhY2suYzoxMjA4CisjOiBmZXRjaC1wYWNrLmM6MTIwNAogIywgYy1mb3JtYXQKIG1zZ2lkICJleHBlY3RlZCAnJXMnLCByZWNlaXZlZCAnJXMnIgogbXNnc3RyICJhdHRlc28gJyVzJywgcmljZXZ1dG8gJyVzJyIKIAotIzogZmV0Y2gtcGFjay5jOjEyNDcKKyM6IGZldGNoLXBhY2suYzoxMjQzCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuZXhwZWN0ZWQgYWNrbm93bGVkZ21lbnQgbGluZTogJyVzJyIKIG1zZ3N0ciAicmlnYSBkaSBjb25mZXJtYSBpbmF0dGVzYTogJyVzJyIKIAotIzogZmV0Y2gtcGFjay5jOjEyNTIKKyM6IGZldGNoLXBhY2suYzoxMjQ4CiAjLCBjLWZvcm1hdAogbXNnaWQgImVycm9yIHByb2Nlc3NpbmcgYWNrczogJWQiCiBtc2dzdHIgImVycm9yZSBkdXJhbnRlIGwnZWxhYm9yYXppb25lIGRlZ2xpIGFjazogJWQiCiAKLSM6IGZldGNoLXBhY2suYzoxMjYyCisjOiBmZXRjaC1wYWNrLmM6MTI1OAogbXNnaWQgImV4cGVjdGVkIHBhY2tmaWxlIHRvIGJlIHNlbnQgYWZ0ZXIgJ3JlYWR5JyIKIG1zZ3N0ciAiY2kgc2kgYXR0ZW5kZXZhIGNoZSBpbCBwYWNrZmlsZSBmb3NzZSBpbnZpYXRvIGRvcG8gJ3JlYWR5JyIKIAotIzogZmV0Y2gtcGFjay5jOjEyNjQKKyM6IGZldGNoLXBhY2suYzoxMjYwCiBtc2dpZCAiZXhwZWN0ZWQgbm8gb3RoZXIgc2VjdGlvbnMgdG8gYmUgc2VudCBhZnRlciBubyAncmVhZHknIgogbXNnc3RyICIiCiAiY2kgc2kgYXR0ZW5kZXZhIGNoZSBuZXNzdW4nYWx0cmEgc2V6aW9uZSBmb3NzZSBpbnZpYXRhIGluIGFzc2VuemEgZGkgJ3JlYWR5JyIKIAotIzogZmV0Y2gtcGFjay5jOjEzMDYKKyM6IGZldGNoLXBhY2suYzoxMzAyCiAjLCBjLWZvcm1hdAogbXNnaWQgImVycm9yIHByb2Nlc3Npbmcgc2hhbGxvdyBpbmZvOiAlZCIKIG1zZ3N0ciAiZXJyb3JlIGR1cmFudGUgbCdlbGFib3JhemlvbmUgZGVsbGUgaW5mb3JtYXppb25pIHNoYWxsb3c6ICVkIgogCi0jOiBmZXRjaC1wYWNrLmM6MTM1MworIzogZmV0Y2gtcGFjay5jOjEzNDkKICMsIGMtZm9ybWF0CiBtc2dpZCAiZXhwZWN0ZWQgd2FudGVkLXJlZiwgZ290ICclcyciCiBtc2dzdHIgImF0dGVzbyB3YW50ZWQtcmVmLCByaWNldnV0byAnJXMnIgogCi0jOiBmZXRjaC1wYWNrLmM6MTM1OAorIzogZmV0Y2gtcGFjay5jOjEzNTQKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5leHBlY3RlZCB3YW50ZWQtcmVmOiAnJXMnIgogbXNnc3RyICJ3YW50ZWQtcmVmIGluYXR0ZXNvOiAnJXMnIgogCi0jOiBmZXRjaC1wYWNrLmM6MTM2MworIzogZmV0Y2gtcGFjay5jOjEzNTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiZXJyb3IgcHJvY2Vzc2luZyB3YW50ZWQgcmVmczogJWQiCiBtc2dzdHIgImVycm9yZSBkdXJhbnRlIGwnZWxhYm9yYXppb25lIGRlaSByaWZlcmltZW50aSBkZXNpZGVyYXRpOiAlZCIKIAotIzogZmV0Y2gtcGFjay5jOjE2ODkKKyM6IGZldGNoLXBhY2suYzoxNjkzCiBtc2dpZCAibm8gbWF0Y2hpbmcgcmVtb3RlIGhlYWQiCiBtc2dzdHIgIm5lc3N1biBoZWFkIHJlbW90byBjb3JyaXNwb25kZW50ZSIKIAotIzogZmV0Y2gtcGFjay5jOjE3MTIgYnVpbHRpbi9jbG9uZS5jOjY4NgorIzogZmV0Y2gtcGFjay5jOjE3MTYgYnVpbHRpbi9jbG9uZS5jOjY4NQogbXNnaWQgInJlbW90ZSBkaWQgbm90IHNlbmQgYWxsIG5lY2Vzc2FyeSBvYmplY3RzIgogbXNnc3RyICJpbCByZW1vdG8gbm9uIGhhIGludmlhdG8gdHV0dGkgZ2xpIG9nZ2V0dGkgbmVjZXNzYXJpIgogCi0jOiBmZXRjaC1wYWNrLmM6MTczOQorIzogZmV0Y2gtcGFjay5jOjE3NDMKICMsIGMtZm9ybWF0CiBtc2dpZCAibm8gc3VjaCByZW1vdGUgcmVmICVzIgogbXNnc3RyICJyaWZlcmltZW50byByZW1vdG8gbm9uIGVzaXN0ZW50ZTogJXMiCiAKLSM6IGZldGNoLXBhY2suYzoxNzQyCisjOiBmZXRjaC1wYWNrLmM6MTc0NgogIywgYy1mb3JtYXQKIG1zZ2lkICJTZXJ2ZXIgZG9lcyBub3QgYWxsb3cgcmVxdWVzdCBmb3IgdW5hZHZlcnRpc2VkIG9iamVjdCAlcyIKIG1zZ3N0ciAiSWwgc2VydmVyIG5vbiBjb25zZW50ZSByaWNoaWVzdGUgcGVyIGwnb2dnZXR0byBub24gcHViYmxpY2l6emF0byAlcyIKQEAgLTMzODIsMTggKzMzODcsMjYgQEAKIG1zZ2lkICJpZ25vcmUgaW52YWxpZCBjb2xvciAnJS4qcycgaW4gbG9nLmdyYXBoQ29sb3JzIgogbXNnc3RyICJpZ25vcm8gaWwgY29sb3JlIG5vbiB2YWxpZG8gJyUuKnMnIGluIGxvZy5ncmFwaENvbG9ycyIKIAotIzogZ3JlcC5jOjIxMTcKKyM6IGdyZXAuYzo2NjgKK21zZ2lkICIiCisiZ2l2ZW4gcGF0dGVybiBjb250YWlucyBOVUxMIGJ5dGUgKHZpYSAtZiA8ZmlsZT4pLiBUaGlzIGlzIG9ubHkgc3VwcG9ydGVkICIKKyJ3aXRoIC1QIHVuZGVyIFBDUkUgdjIiCittc2dzdHIgIiIKKyJpbCBwYXR0ZXJuIGZvcm5pdG8gKGNvbiAtZiA8ZmlsZT4pIGNvbnRpZW5lIHVuIGJ5dGUgTlVMTC4gQ2nDsiDDqCBzdXBwb3J0YXRvICIKKyJzb2xvIGNvbiAtUCB1c2FuZG8gUENSRSB2MiIKKworIzogZ3JlcC5jOjIxMjQKICMsIGMtZm9ybWF0CiBtc2dpZCAiJyVzJzogdW5hYmxlIHRvIHJlYWQgJXMiCiBtc2dzdHIgIiclcyc6IGltcG9zc2liaWxlIGxlZ2dlcmUgJXMiCiAKLSM6IGdyZXAuYzoyMTM0IHNldHVwLmM6MTY0IGJ1aWx0aW4vY2xvbmUuYzo0MDkgYnVpbHRpbi9kaWZmLmM6ODIKKyM6IGdyZXAuYzoyMTQxIHNldHVwLmM6MTY1IGJ1aWx0aW4vY2xvbmUuYzo0MDggYnVpbHRpbi9kaWZmLmM6ODIKICM6IGJ1aWx0aW4vcm0uYzoxMzUKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIHN0YXQgJyVzJyIKIG1zZ3N0ciAic3RhdCBkaSAnJXMnIG5vbiByaXVzY2l0byIKIAotIzogZ3JlcC5jOjIxNDUKKyM6IGdyZXAuYzoyMTUyCiAjLCBjLWZvcm1hdAogbXNnaWQgIiclcyc6IHNob3J0IHJlYWQiCiBtc2dzdHIgIiclcyc6IGxldHR1cmEgdHJvcHBvIGJyZXZlIgpAQCAtMzUzNiwxMiArMzU0OSwxMiBAQAogbXNnaWQgImdpdCB2ZXJzaW9uIFs8b3B0aW9ucz5dIgogbXNnc3RyICJnaXQgdmVyc2lvbiBbPG9wemlvbmk+XSIKIAotIzogaGVscC5jOjc4MgorIzogaGVscC5jOjc4MwogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogJXMgLSAlcyIKIG1zZ3N0ciAiJXM6ICVzIC0gJXMiCiAKLSM6IGhlbHAuYzo3ODYKKyM6IGhlbHAuYzo3ODcKIG1zZ2lkICIiCiAiXG4iCiAiRGlkIHlvdSBtZWFuIHRoaXM/IgpAQCAtMzYxNiw0MSArMzYyOSw1OCBAQAogbXNnaWQgImludmFsaWQgZGF0ZSBmb3JtYXQ6ICVzIgogbXNnc3RyICJmb3JtYXRvIGRhdGEgbm9uIHZhbGlkbzogJXMiCiAKLSM6IGxpc3Qtb2JqZWN0cy5jOjEyOQorIzogbGlzdC1vYmplY3RzLmM6MTI3CiAjLCBjLWZvcm1hdAogbXNnaWQgImVudHJ5ICclcycgaW4gdHJlZSAlcyBoYXMgdHJlZSBtb2RlLCBidXQgaXMgbm90IGEgdHJlZSIKIG1zZ3N0ciAibGEgdm9jZSAnJXMnIG5lbGwnYWxiZXJvICVzIGhhIGxhIG1vZGFsaXTDoCBhbGJlcm8sIG1hIG5vbiDDqCB1biBhbGJlcm8iCiAKLSM6IGxpc3Qtb2JqZWN0cy5jOjE0MgorIzogbGlzdC1vYmplY3RzLmM6MTQwCiAjLCBjLWZvcm1hdAogbXNnaWQgImVudHJ5ICclcycgaW4gdHJlZSAlcyBoYXMgYmxvYiBtb2RlLCBidXQgaXMgbm90IGEgYmxvYiIKIG1zZ3N0ciAibGEgdm9jZSAnJXMnIG5lbGwnYWxiZXJvICVzIGhhIGxhIG1vZGFsaXTDoCBibG9iLCBtYSBub24gw6ggdW4gYmxvYiIKIAotIzogbGlzdC1vYmplY3RzLmM6Mzc4CisjOiBsaXN0LW9iamVjdHMuYzozNzUKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGxvYWQgcm9vdCB0cmVlIGZvciBjb21taXQgJXMiCiBtc2dzdHIgImltcG9zc2liaWxlIGNhcmljYXJlIGwnYWxiZXJvIHJhZGljZSBwZXIgaWwgY29tbWl0ICVzIgogCi0jOiBsaXN0LW9iamVjdHMtZmlsdGVyLW9wdGlvbnMuYzozNgotbXNnaWQgIm11bHRpcGxlIGZpbHRlci1zcGVjcyBjYW5ub3QgYmUgY29tYmluZWQiCi1tc2dzdHIgIm5vbiDDqCBwb3NzaWJpbGUgY29tYmluYXJlIHBpw7kgc3BlY2lmaWNhdG9yaSBmaWx0cm8iCisjOiBsaXN0LW9iamVjdHMtZmlsdGVyLmM6NDkyCisjLCBjLWZvcm1hdAorbXNnaWQgInVuYWJsZSB0byBhY2Nlc3Mgc3BhcnNlIGJsb2IgaW4gJyVzJyIKK21zZ3N0ciAiaW1wb3NzaWJpbGUgYWNjZWRlcmUgYWwgYmxvYiBzcGFyc2UgaW4gJyVzJyIKKworIzogbGlzdC1vYmplY3RzLWZpbHRlci5jOjQ5NQorIywgYy1mb3JtYXQKK21zZ2lkICJ1bmFibGUgdG8gcGFyc2Ugc3BhcnNlIGZpbHRlciBkYXRhIGluICVzIgorbXNnc3RyICJpbXBvc3NpYmlsZSBhbmFsaXp6YXJlIGkgZGF0aSBmaWx0cm8gc3BhcnNlIGluICVzIgogCiAjOiBsaXN0LW9iamVjdHMtZmlsdGVyLW9wdGlvbnMuYzo1OAogbXNnaWQgImV4cGVjdGVkICd0cmVlOjxkZXB0aD4nIgogbXNnc3RyICJhdHRlc28gJ3RyZWU6PHByb2ZvbmRpdMOgPiciCiAKLSM6IGxpc3Qtb2JqZWN0cy1maWx0ZXItb3B0aW9ucy5jOjg0CisjOiBsaXN0LW9iamVjdHMtZmlsdGVyLW9wdGlvbnMuYzo3MwogbXNnaWQgInNwYXJzZTpwYXRoIGZpbHRlcnMgc3VwcG9ydCBoYXMgYmVlbiBkcm9wcGVkIgogbXNnc3RyICJpbCBzdXBwb3J0byBwZXIgaSBmaWx0cmkgc3BhcnNlOnBlcmNvcnNvIMOoIHN0YXRvIHJpbW9zc28iCiAKLSM6IGxpc3Qtb2JqZWN0cy1maWx0ZXItb3B0aW9ucy5jOjk0CisjOiBsaXN0LW9iamVjdHMtZmlsdGVyLW9wdGlvbnMuYzo4NgogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIGZpbHRlci1zcGVjICclcyciCiBtc2dzdHIgInNwZWNpZmljYXRvcmUgZmlsdHJvICclcycgbm9uIHZhbGlkbyIKIAotIzogbGlzdC1vYmplY3RzLWZpbHRlci1vcHRpb25zLmM6MTU4Ci1tc2dpZCAiY2Fubm90IGNoYW5nZSBwYXJ0aWFsIGNsb25lIHByb21pc29yIHJlbW90ZSIKLW1zZ3N0ciAiaW1wb3NzaWJpbGUgbW9kaWZpY2FyZSBpbCByZW1vdG8gcHJvbWV0dGVudGUgZGVsIGNsb25lIHBhcnppYWxlIgorIzogbGlzdC1vYmplY3RzLWZpbHRlci1vcHRpb25zLmM6MTAyCisjLCBjLWZvcm1hdAorbXNnaWQgIm11c3QgZXNjYXBlIGNoYXIgaW4gc3ViLWZpbHRlci1zcGVjOiAnJWMnIgorbXNnc3RyICIiCisiw6ggbmVjZXNzYXJpbyBlc2VndWlyZSBsJ2VzY2FwZSBkZWwgY2FyYXR0ZXJlIG5lbGxvIHNwZWNpZmljYXRvcmUgZGVsICIKKyJzb3R0b2ZpbHRybzogJyVjJyIKKworIzogbGlzdC1vYmplY3RzLWZpbHRlci1vcHRpb25zLmM6MTQ0Cittc2dpZCAiZXhwZWN0ZWQgc29tZXRoaW5nIGFmdGVyIGNvbWJpbmU6IgorbXNnc3RyICJhdHRlc28gcXVhbGNvc2EgZG9wbyBsYSByaWNvbWJpbmF6aW9uZToiCisKKyM6IGxpc3Qtb2JqZWN0cy1maWx0ZXItb3B0aW9ucy5jOjIyNgorbXNnaWQgIm11bHRpcGxlIGZpbHRlci1zcGVjcyBjYW5ub3QgYmUgY29tYmluZWQiCittc2dzdHIgIm5vbiDDqCBwb3NzaWJpbGUgY29tYmluYXJlIHBpw7kgc3BlY2lmaWNhdG9yaSBmaWx0cm8iCiAKICM6IGxvY2tmaWxlLmM6MTUxCiAjLCBjLWZvcm1hdApAQCAtMzY4MSwxMTkgKzM3MTEsMTE1IEBACiBtc2dpZCAiZmFpbGVkIHRvIHJlYWQgdGhlIGNhY2hlIgogbXNnc3RyICJsZXR0dXJhIGRlbGxhIGNhY2hlIG5vbiByaXVzY2l0YSIKIAotIzogbWVyZ2UuYzoxMDcgcmVyZXJlLmM6NzIwIGJ1aWx0aW4vYW0uYzoxODg1IGJ1aWx0aW4vYW0uYzoxOTE5Ci0jOiBidWlsdGluL2NoZWNrb3V0LmM6NTM2IGJ1aWx0aW4vY2hlY2tvdXQuYzo3OTYgYnVpbHRpbi9jbG9uZS5jOjc4NgorIzogbWVyZ2UuYzoxMDcgcmVyZXJlLmM6NzIwIGJ1aWx0aW4vYW0uYzoxODc0IGJ1aWx0aW4vYW0uYzoxOTA4CisjOiBidWlsdGluL2NoZWNrb3V0LmM6NTM3IGJ1aWx0aW4vY2hlY2tvdXQuYzo3OTYgYnVpbHRpbi9jbG9uZS5jOjc4NQogIzogYnVpbHRpbi9zdGFzaC5jOjI2NAogbXNnaWQgInVuYWJsZSB0byB3cml0ZSBuZXcgaW5kZXggZmlsZSIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgc2NyaXZlcmUgaWwgbnVvdm8gZmlsZSBpbmRleCIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzIyCisjOiBtZXJnZS1yZWN1cnNpdmUuYzozNjcKIG1zZ2lkICIoYmFkIGNvbW1pdClcbiIKIG1zZ3N0ciAiKGNvbW1pdCBub24gdmFsaWRvKVxuIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozNDUKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjM5MAogIywgYy1mb3JtYXQKIG1zZ2lkICJhZGRfY2FjaGVpbmZvIGZhaWxlZCBmb3IgcGF0aCAnJXMnOyBtZXJnZSBhYm9ydGluZy4iCiBtc2dzdHIgImFkZF9jYWNoZWluZm8gbm9uIHJpdXNjaXRvIHBlciBpbCBwZXJjb3JzbyAnJXMnOyBpbnRlcnJvbXBvIGlsIG1lcmdlLiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzU0CisjOiBtZXJnZS1yZWN1cnNpdmUuYzozOTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiYWRkX2NhY2hlaW5mbyBmYWlsZWQgdG8gcmVmcmVzaCBmb3IgcGF0aCAnJXMnOyBtZXJnZSBhYm9ydGluZy4iCiBtc2dzdHIgIiIKICJhZ2dpb3JuYW1lbnRvIGFkZF9jYWNoZWluZm8gbm9uIHJpdXNjaXRvIHBlciBpbCBwZXJjb3JzbyAnJXMnOyBpbnRlcnJvbXBvIGlsICIKICJtZXJnZS4iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjQzNwotbXNnaWQgImVycm9yIGJ1aWxkaW5nIHRyZWVzIgotbXNnc3RyICJlcnJvcmUgZHVyYW50ZSBsYSBjb3N0cnV6aW9uZSBkZWdsaSBhbGJlcmkiCi0KLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjg2MworIzogbWVyZ2UtcmVjdXJzaXZlLmM6ODg1CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBjcmVhdGUgcGF0aCAnJXMnJXMiCiBtc2dzdHIgImNyZWF6aW9uZSBkZWwgcGVyY29yc28gJyVzJyBub24gcml1c2NpdGElcyIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6ODc0CisjOiBtZXJnZS1yZWN1cnNpdmUuYzo4OTYKICMsIGMtZm9ybWF0CiBtc2dpZCAiUmVtb3ZpbmcgJXMgdG8gbWFrZSByb29tIGZvciBzdWJkaXJlY3RvcnlcbiIKIG1zZ3N0ciAiUmltdW92byAlcyBwZXIgZmFyZSBzcGF6aW8gYWxsYSBzb3R0b2RpcmVjdG9yeVxuIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzo4ODggbWVyZ2UtcmVjdXJzaXZlLmM6OTA3CisjOiBtZXJnZS1yZWN1cnNpdmUuYzo5MTAgbWVyZ2UtcmVjdXJzaXZlLmM6OTI5CiBtc2dpZCAiOiBwZXJoYXBzIGEgRC9GIGNvbmZsaWN0PyIKIG1zZ3N0ciAiOiBmb3JzZSBzaSB0cmF0dGEgZGkgdW4gY29uZmxpdHRvIEQvRj8iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjg5NworIzogbWVyZ2UtcmVjdXJzaXZlLmM6OTE5CiAjLCBjLWZvcm1hdAogbXNnaWQgInJlZnVzaW5nIHRvIGxvc2UgdW50cmFja2VkIGZpbGUgYXQgJyVzJyIKIG1zZ3N0ciAibWkgcmlmaXV0byBkaSBwZXJkZXJlIHVuIGZpbGUgbm9uIHRyYWNjaWF0byBpbiAnJXMnIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzo5MzggYnVpbHRpbi9jYXQtZmlsZS5jOjQwCisjOiBtZXJnZS1yZWN1cnNpdmUuYzo5NjAgYnVpbHRpbi9jYXQtZmlsZS5jOjQxCiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCByZWFkIG9iamVjdCAlcyAnJXMnIgogbXNnc3RyICJpbXBvc3NpYmlsZSBsZWdnZXJlIGwnb2dnZXR0byAlcyAnJXMnIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzo5NDEKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjk2NQogIywgYy1mb3JtYXQKIG1zZ2lkICJibG9iIGV4cGVjdGVkIGZvciAlcyAnJXMnIgogbXNnc3RyICJhdHRlc28gYmxvYiBwZXIgJXMgJyVzJyIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6OTY1CisjOiBtZXJnZS1yZWN1cnNpdmUuYzo5OTAKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIG9wZW4gJyVzJzogJXMiCiBtc2dzdHIgImFwZXJ0dXJhIGRpICclcycgbm9uIHJpdXNjaXRhOiAlcyIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6OTc2CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxMDAxCiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBzeW1saW5rICclcyc6ICVzIgogbXNnc3RyICJjcmVhemlvbmUgZGVsIGNvbGxlZ2FtZW50byBzaW1ib2xpY28gJyVzJyBub24gcml1c2NpdGE6ICVzIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzo5ODEKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEwMDYKICMsIGMtZm9ybWF0CiBtc2dpZCAiZG8gbm90IGtub3cgd2hhdCB0byBkbyB3aXRoICUwNm8gJXMgJyVzJyIKIG1zZ3N0ciAibm9uIHNvIGNoZSBmYXJlIGNvbiAlMDZvICVzICclcyciCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjExNzcKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjExOTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiRmFpbGVkIHRvIG1lcmdlIHN1Ym1vZHVsZSAlcyAobm90IGNoZWNrZWQgb3V0KSIKIG1zZ3N0ciAiTWVyZ2UgZGVsIHNvdHRvbW9kdWxvICVzIG5vbiByaXVzY2l0byAoY2hlY2tvdXQgbm9uIGVzZWd1aXRvKSIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTE4NAorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTIwNgogIywgYy1mb3JtYXQKIG1zZ2lkICJGYWlsZWQgdG8gbWVyZ2Ugc3VibW9kdWxlICVzIChjb21taXRzIG5vdCBwcmVzZW50KSIKIG1zZ3N0ciAiTWVyZ2UgZGVsIHNvdHRvbW9kdWxvICVzIG5vbiByaXVzY2l0byAoY29tbWl0IG5vbiBwcmVzZW50aSkiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjExOTEKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEyMTMKICMsIGMtZm9ybWF0CiBtc2dpZCAiRmFpbGVkIHRvIG1lcmdlIHN1Ym1vZHVsZSAlcyAoY29tbWl0cyBkb24ndCBmb2xsb3cgbWVyZ2UtYmFzZSkiCiBtc2dzdHIgIiIKICJNZXJnZSBkZWwgc290dG9tb2R1bG8gJXMgbm9uIHJpdXNjaXRvIChpIGNvbW1pdCBub24gc2VndW9ubyBsYSBiYXNlIGRlbCAiCiAibWVyZ2UpIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxMTk5IG1lcmdlLXJlY3Vyc2l2ZS5jOjEyMTEKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEyMjEgbWVyZ2UtcmVjdXJzaXZlLmM6MTIzMwogIywgYy1mb3JtYXQKIG1zZ2lkICJGYXN0LWZvcndhcmRpbmcgc3VibW9kdWxlICVzIHRvIHRoZSBmb2xsb3dpbmcgY29tbWl0OiIKIG1zZ3N0ciAiRXNlZ3VvIGlsIGZhc3QgZm9yd2FyZCBkZWwgc290dG9tb2R1bG8gJXMgYWwgc2VndWVudGUgY29tbWl0OiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTIwMiBtZXJnZS1yZWN1cnNpdmUuYzoxMjE0CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxMjI0IG1lcmdlLXJlY3Vyc2l2ZS5jOjEyMzYKICMsIGMtZm9ybWF0CiBtc2dpZCAiRmFzdC1mb3J3YXJkaW5nIHN1Ym1vZHVsZSAlcyIKIG1zZ3N0ciAiRXNlZ3VvIGlsIGZhc3QgZm9yd2FyZCBkZWwgc290dG9tb2R1bG8gJXMiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEyMzcKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEyNTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiRmFpbGVkIHRvIG1lcmdlIHN1Ym1vZHVsZSAlcyAobWVyZ2UgZm9sbG93aW5nIGNvbW1pdHMgbm90IGZvdW5kKSIKIG1zZ3N0ciAiIgogIk1lcmdlIGRlbCBzb3R0b21vZHVsbyAlcyBub24gcml1c2NpdG8gKG1lcmdlIGRvcG8gaSBjb21taXQgbm9uIHRyb3ZhdG8pIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxMjQxCisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxMjYzCiAjLCBjLWZvcm1hdAogbXNnaWQgIkZhaWxlZCB0byBtZXJnZSBzdWJtb2R1bGUgJXMgKG5vdCBmYXN0LWZvcndhcmQpIgogbXNnc3RyICJNZXJnZSBkZWwgc290dG9tb2R1bG8gJXMgbm9uIHJpdXNjaXRvIChub24gZmFzdCBmb3J3YXJkKSIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTI0MgorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTI2NAogbXNnaWQgIkZvdW5kIGEgcG9zc2libGUgbWVyZ2UgcmVzb2x1dGlvbiBmb3IgdGhlIHN1Ym1vZHVsZTpcbiIKIG1zZ3N0ciAiVHJvdmF0YSBwb3NzaWJpbGUgcmlzb2x1emlvbmUgbWVyZ2UgcGVyIGlsIHNvdHRvbW9kdWxvOlxuIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxMjQ1CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxMjY3CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJJZiB0aGlzIGlzIGNvcnJlY3Qgc2ltcGx5IGFkZCBpdCB0byB0aGUgaW5kZXggZm9yIGV4YW1wbGVcbiIKQEAgLTM4MTAsMzIgKzM4MzYsMzIgQEAKICJcbiIKICJwZXIgYWNjZXR0YXJlIHF1ZXN0byBzdWdnZXJpbWVudG8uXG4iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEyNTQKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEyNzYKICMsIGMtZm9ybWF0CiBtc2dpZCAiRmFpbGVkIHRvIG1lcmdlIHN1Ym1vZHVsZSAlcyAobXVsdGlwbGUgbWVyZ2VzIGZvdW5kKSIKIG1zZ3N0ciAiTWVyZ2UgZGVsIHNvdHRvbW9kdWxvICVzIG5vbiByaXVzY2l0byAocGnDuSBtZXJnZSB0cm92YXRpKSIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTMyNworIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTM0OQogbXNnaWQgIkZhaWxlZCB0byBleGVjdXRlIGludGVybmFsIG1lcmdlIgogbXNnc3RyICJFc2VjdXppb25lIGRlbCBtZXJnZSBpbnRlcm5vIG5vbiByaXVzY2l0YSIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTMzMgorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTM1NAogIywgYy1mb3JtYXQKIG1zZ2lkICJVbmFibGUgdG8gYWRkICVzIHRvIGRhdGFiYXNlIgogbXNnc3RyICJJbXBvc3NpYmlsZSBhZ2dpdW5nZXJlICVzIGFsIGRhdGFiYXNlIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxMzY0CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxMzg2CiAjLCBjLWZvcm1hdAogbXNnaWQgIkF1dG8tbWVyZ2luZyAlcyIKIG1zZ3N0ciAiTWVyZ2UgYXV0b21hdGljbyBkaSAlcyBpbiBjb3JzbyIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTM4NworIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTQxMAogIywgYy1mb3JtYXQKIG1zZ2lkICJFcnJvcjogUmVmdXNpbmcgdG8gbG9zZSB1bnRyYWNrZWQgZmlsZSBhdCAlczsgd3JpdGluZyB0byAlcyBpbnN0ZWFkLiIKIG1zZ3N0ciAiIgogIkVycm9yZTogbWkgcmlmaXV0byBkaSBwZXJkZXJlIGlsIGZpbGUgbm9uIHRyYWNjaWF0byAlczsgc2NyaXZvIGludmVjZSBpbiAlcy4iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE0NTkKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE0ODIKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkNPTkZMSUNUICglcy9kZWxldGUpOiAlcyBkZWxldGVkIGluICVzIGFuZCAlcyBpbiAlcy4gVmVyc2lvbiAlcyBvZiAlcyBsZWZ0ICIKQEAgLTM4NDQsNyArMzg3MCw3IEBACiAiQ09ORkxJVFRPICglcy9lbGltaW5hemlvbmUpOiAlcyBlbGltaW5hdG8gaW4gJXMgZSAlcyBpbiAlcy4gVmVyc2lvbmUgJXMgZGkgIgogIiVzIGxhc2NpYXRhIG5lbGwnYWxiZXJvLiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTQ2NAorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTQ4NwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiQ09ORkxJQ1QgKCVzL2RlbGV0ZSk6ICVzIGRlbGV0ZWQgaW4gJXMgYW5kICVzIHRvICVzIGluICVzLiBWZXJzaW9uICVzIG9mICVzICIKQEAgLTM4NTMsNyArMzg3OSw3IEBACiAiQ09ORkxJVFRPICglcy9lbGltaW5hemlvbmUpOiAlcyBlbGltaW5hdG8gaW4gJXMgZSAlcyBjb21lICVzIGluICVzLiBWZXJzaW9uZSAiCiAiJXMgZGkgJXMgbGFzY2lhdGEgbmVsbCdhbGJlcm8uIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxNDcxCisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxNDk0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJDT05GTElDVCAoJXMvZGVsZXRlKTogJXMgZGVsZXRlZCBpbiAlcyBhbmQgJXMgaW4gJXMuIFZlcnNpb24gJXMgb2YgJXMgbGVmdCAiCkBAIC0zODYyLDcgKzM4ODgsNyBAQAogIkNPTkZMSVRUTyAoJXMvZWxpbWluYXppb25lKTogJXMgZWxpbWluYXRvIGluICVzIGUgJXMgaW4gJXMuIFZlcnNpb25lICVzIGRpICIKICIlcyBsYXNjaWF0YSBuZWxsJ2FsYmVybyBpbiAlcy4iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE0NzYKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE0OTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkNPTkZMSUNUICglcy9kZWxldGUpOiAlcyBkZWxldGVkIGluICVzIGFuZCAlcyB0byAlcyBpbiAlcy4gVmVyc2lvbiAlcyBvZiAlcyAiCkBAIC0zODcxLDQzICszODk3LDQzIEBACiAiQ09ORkxJVFRPICglcy9lbGltaW5hemlvbmUpOiAlcyBlbGltaW5hdG8gaW4gJXMgZSAlcyBjb21lICVzIGluICVzLiBWZXJzaW9uZSAiCiAiJXMgZGkgJXMgbGFzY2lhdGEgbmVsbCdhbGJlcm8gaW4gJXMuIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxNTExCisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxNTM0CiBtc2dpZCAicmVuYW1lIgogbXNnc3RyICJyaWRlbm9taW5hemlvbmUiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE1MTEKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE1MzQKIG1zZ2lkICJyZW5hbWVkIgogbXNnc3RyICJyaW5vbWluYXRvIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxNTkxIG1lcmdlLXJlY3Vyc2l2ZS5jOjI0NTAgbWVyZ2UtcmVjdXJzaXZlLmM6MzA5NAorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTYxNCBtZXJnZS1yZWN1cnNpdmUuYzoyNDcyIG1lcmdlLXJlY3Vyc2l2ZS5jOjMxMTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiUmVmdXNpbmcgdG8gbG9zZSBkaXJ0eSBmaWxlIGF0ICVzIgogbXNnc3RyICJNaSByaWZpdXRvIGRpIHBlcmRlcmUgdW4gZmlsZSBzcG9yY28gaW4gJXMiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE2MDEKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE2MjQKICMsIGMtZm9ybWF0CiBtc2dpZCAiUmVmdXNpbmcgdG8gbG9zZSB1bnRyYWNrZWQgZmlsZSBhdCAlcywgZXZlbiB0aG91Z2ggaXQncyBpbiB0aGUgd2F5LiIKIG1zZ3N0ciAiIgogIk1pIHJpZml1dG8gZGkgcGVyZGVyZSB1biBmaWxlIG5vbiB0cmFjY2lhdG8gaW4gJXMsIGJlbmNow6kgc2lhIGQnb3N0YWNvbG8uIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxNjU5CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxNjgyCiAjLCBjLWZvcm1hdAogbXNnaWQgIkNPTkZMSUNUIChyZW5hbWUvYWRkKTogUmVuYW1lICVzLT4lcyBpbiAlcy4gIEFkZGVkICVzIGluICVzIgogbXNnc3RyICIiCiAiQ09ORkxJVFRPIChyaWRlbm9taW5hemlvbmUvYWdnaXVudGEpOiBlbGVtZW50byByaWRlbm9taW5hdG8gJXMtPiVzIGluICVzLiAlcyAiCiAiYWdnaXVudG8gaW4gJXMiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE2OTAKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE3MTMKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgaXMgYSBkaXJlY3RvcnkgaW4gJXMgYWRkaW5nIGFzICVzIGluc3RlYWQiCiBtc2dzdHIgIiVzIMOoIHVuYSBkaXJlY3RvcnkgaW4gJXM7IGxhIGFnZ2l1bmdvIGNvbWUgJXMiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE2OTUKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE3MTgKICMsIGMtZm9ybWF0CiBtc2dpZCAiUmVmdXNpbmcgdG8gbG9zZSB1bnRyYWNrZWQgZmlsZSBhdCAlczsgYWRkaW5nIGFzICVzIGluc3RlYWQiCiBtc2dzdHIgIk1pIHJpZml1dG8gZGkgcGVyZGVyZSB1biBmaWxlIG5vbiB0cmFjY2lhdG8gaW4gJXM7IGxvIGFnZ2l1bmdvIGNvbWUgJXMiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE3MTQKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE3MzcKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkNPTkZMSUNUIChyZW5hbWUvcmVuYW1lKTogUmVuYW1lIFwiJXNcIi0+XCIlc1wiIGluIGJyYW5jaCBcIiVzXCIgcmVuYW1lIFwiJXMiCkBAIC0zOTE2LDE4ICszOTQyLDE4IEBACiAiQ09ORkxJVFRPIChyaWRlbm9taW5hemlvbmUvcmlkZW5vbWluYXppb25lKTogZmlsZSByaWRlbm9taW5hdG8gXCIlc1wiLT5cIiVzIgogIlwiIG5lbCBicmFuY2ggXCIlc1wiLCByaWRlbm9taW5hdG8gXCIlc1wiLT5cIiVzXCIgaW4gXCIlc1wiJXMiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE3MTkKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE3NDIKIG1zZ2lkICIgKGxlZnQgdW5yZXNvbHZlZCkiCiBtc2dzdHIgIiAobGFzY2lhdG8gaXJyaXNvbHRvKSIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTgyOAorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTg1MQogIywgYy1mb3JtYXQKIG1zZ2lkICJDT05GTElDVCAocmVuYW1lL3JlbmFtZSk6IFJlbmFtZSAlcy0+JXMgaW4gJXMuIFJlbmFtZSAlcy0+JXMgaW4gJXMiCiBtc2dzdHIgIiIKICJDT05GTElUVE8gKHJpZGVub21pbmF6aW9uZS9yaWRlbm9taW5hemlvbmUpOiBmaWxlIHJpZGVub21pbmF0byAlcy0+JXMgaW4gJXMuICIKICJSaWRlbm9taW5hdG8gJXMtPiVzIGluICVzIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoyMDM1CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoyMDU2CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJDT05GTElDVCAoZGlyZWN0b3J5IHJlbmFtZSBzcGxpdCk6IFVuY2xlYXIgd2hlcmUgdG8gcGxhY2UgJXMgYmVjYXVzZSAiCkBAIC0zOTM4LDcgKzM5NjQsNyBAQAogInBlcmNow6kgbGEgZGlyZWN0b3J5ICVzIMOoIHN0YXRhIHJpZGVub21pbmF0YSBpbiBwacO5IGRpcmVjdG9yeSBkaXZlcnNlIGUgIgogIm5lc3N1bmEgZGlyZWN0b3J5IGRpIGRlc3RpbmF6aW9uZSBjb250aWVuZSBsYSBtYWdnaW9yIHBhcnRlIGRlaSBmaWxlLiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MjA2NworIzogbWVyZ2UtcmVjdXJzaXZlLmM6MjA4OAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiQ09ORkxJQ1QgKGltcGxpY2l0IGRpciByZW5hbWUpOiBFeGlzdGluZyBmaWxlL2RpciBhdCAlcyBpbiB0aGUgd2F5IG9mICIKQEAgLTM5NDgsNyArMzk3NCw3IEBACiAiJXMgw6ggZCdvc3RhY29sbyBhbGxlIHNlZ3VlbnRpIHJpZGVub21pbmF6aW9uaSBkaXJlY3RvcnkgY2hlIHNwb3N0YW5vIGluIHRhbGUgIgogInBvc2l6aW9uZSBpIHNlZ3VlbnRpIHBlcmNvcnNpOiAlcy4iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjIwNzcKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjIwOTgKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkNPTkZMSUNUIChpbXBsaWNpdCBkaXIgcmVuYW1lKTogQ2Fubm90IG1hcCBtb3JlIHRoYW4gb25lIHBhdGggdG8gJXM7ICIKQEAgLTM5NTgsNyArMzk4NCw3IEBACiAidW4gcGVyY29yc28gaW4gJXM7IGRlbGxlIHJpZGVub21pbmF6aW9uaSBkaXJlY3RvcnkgaW1wbGljaXRlIGhhbm5vIHRlbnRhdG8gIgogImRpIHNwb3N0YXJlIGluIHRhbGUgcG9zaXppb25lIGkgc2VndWVudGkgcGVyY29yc2k6ICVzIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoyMTY5CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoyMTkwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJDT05GTElDVCAocmVuYW1lL3JlbmFtZSk6IFJlbmFtZSBkaXJlY3RvcnkgJXMtPiVzIGluICVzLiBSZW5hbWUgZGlyZWN0b3J5ICVzLSIKQEAgLTM5NjcsNyArMzk5Myw3IEBACiAiQ09ORkxJVFRPIChyaWRlbm9taW5hemlvbmUvcmlkZW5vbWluYXppb25lKTogZGlyZWN0b3J5IHJpZGVub21pbmF0YSAlcy0+JXMgIgogImluICVzLiBEaXJlY3RvcnkgcmlkZW5vbWluYXRhICVzLT4lcyBpbiAlcyIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MjQxMworIzogbWVyZ2UtcmVjdXJzaXZlLmM6MjQzNQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiV0FSTklORzogQXZvaWRpbmcgYXBwbHlpbmcgJXMgLT4gJXMgcmVuYW1lIHRvICVzLCBiZWNhdXNlICVzIGl0c2VsZiB3YXMgIgpAQCAtMzk3Niw1MiArNDAwMiw1MiBAQAogIkFUVEVOWklPTkU6IGV2aXRvIGRpIGFwcGxpY2FyZSBsYSByaWRlbm9taW5hemlvbmUgJXMgLT4gJXMgYSAlcyBwZXJjaMOpICVzICIKICJzdGVzc28gw6ggc3RhdG8gcmlkZW5vbWluYXRvLiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MjkzOAorIzogbWVyZ2UtcmVjdXJzaXZlLmM6Mjk2MQogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgcmVhZCBvYmplY3QgJXMiCiBtc2dzdHIgImltcG9zc2liaWxlIGxlZ2dlcmUgbCdvZ2dldHRvICVzIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoyOTQxCisjOiBtZXJnZS1yZWN1cnNpdmUuYzoyOTY0CiAjLCBjLWZvcm1hdAogbXNnaWQgIm9iamVjdCAlcyBpcyBub3QgYSBibG9iIgogbXNnc3RyICJsJ29nZ2V0dG8gJXMgbm9uIMOoIHVuIGJsb2IiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMwMDUKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMwMjgKIG1zZ2lkICJtb2RpZnkiCiBtc2dzdHIgIm1vZGlmaWNhIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozMDA1CisjOiBtZXJnZS1yZWN1cnNpdmUuYzozMDI4CiBtc2dpZCAibW9kaWZpZWQiCiBtc2dzdHIgIm1vZGlmaWNhdG8iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMwMTcKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMwNDAKIG1zZ2lkICJjb250ZW50IgogbXNnc3RyICJjb250ZW51dG8iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMwMjEKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMwNDQKIG1zZ2lkICJhZGQvYWRkIgogbXNnc3RyICJhZ2dpdW50YS9hZ2dpdW50YSIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzA0NAorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzA2NwogIywgYy1mb3JtYXQKIG1zZ2lkICJTa2lwcGVkICVzIChtZXJnZWQgc2FtZSBhcyBleGlzdGluZykiCiBtc2dzdHIgIk9tZXNzbyAlcyAoZWxlbWVudG8gc290dG9wb3N0byBhIG1lcmdlIHVndWFsZSBhIHF1ZWxsbyBlc2lzdGVudGUpIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozMDY2IGdpdC1zdWJtb2R1bGUuc2g6OTM3CisjOiBtZXJnZS1yZWN1cnNpdmUuYzozMDg5IGdpdC1zdWJtb2R1bGUuc2g6OTM3CiBtc2dpZCAic3VibW9kdWxlIgogbXNnc3RyICJzb3R0b21vZHVsbyIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzA2NworIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzA5MAogIywgYy1mb3JtYXQKIG1zZ2lkICJDT05GTElDVCAoJXMpOiBNZXJnZSBjb25mbGljdCBpbiAlcyIKIG1zZ3N0ciAiQ09ORkxJVFRPICglcyk6IGNvbmZsaXR0byBkaSBtZXJnZSBpbiAlcyIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzA5NworIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzEyMAogIywgYy1mb3JtYXQKIG1zZ2lkICJBZGRpbmcgYXMgJXMgaW5zdGVhZCIKIG1zZ3N0ciAiTG8gYWdnaXVuZ28gY29tZSAlcyIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzE3OQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzIwMwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiUGF0aCB1cGRhdGVkOiAlcyBhZGRlZCBpbiAlcyBpbnNpZGUgYSBkaXJlY3RvcnkgdGhhdCB3YXMgcmVuYW1lZCBpbiAlczsgIgpAQCAtNDAzMCw3ICs0MDU2LDcgQEAKICJQZXJjb3JzbyBhZ2dpb3JuYXRvOiAlcyBhZ2dpdW50byBpbiAlcyBpbiB1bmEgZGlyZWN0b3J5IHJpZGVub21pbmF0YSBpbiAlczsgIgogImxvIHNwb3N0byBpbiAlcy4iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMxODIKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMyMDYKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkNPTkZMSUNUIChmaWxlIGxvY2F0aW9uKTogJXMgYWRkZWQgaW4gJXMgaW5zaWRlIGEgZGlyZWN0b3J5IHRoYXQgd2FzIHJlbmFtZWQgIgpAQCAtNDAzOSw3ICs0MDY1LDcgQEAKICJDT05GTElUVE8gKHBvc2l6aW9uZSBmaWxlKTogJXMgYWdnaXVudG8gaW4gJXMgaW4gdW5hIGRpcmVjdG9yeSByaWRlbm9taW5hdGEgIgogImluICVzLCBpbCBjaGUgc3VnZ2VyaXNjZSBjaGUgZm9yc2UgZG92cmViYmUgZXNzZXJlIHNwb3N0YXRvIGluICVzLiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzE4NgorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzIxMAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiUGF0aCB1cGRhdGVkOiAlcyByZW5hbWVkIHRvICVzIGluICVzLCBpbnNpZGUgYSBkaXJlY3RvcnkgdGhhdCB3YXMgcmVuYW1lZCBpbiAiCkBAIC00MDQ4LDcgKzQwNzQsNyBAQAogIlBlcmNvcnNvIGFnZ2lvcm5hdG86ICVzIHJpZGVub21pbmF0byBpbiAlcyBpbiAlcyBpbiB1bmEgZGlyZWN0b3J5ICIKICJyaWRlbm9taW5hdGEgaW4gJXM7IGxvIHNwb3N0byBpbiAlcy4iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMxODkKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMyMTMKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkNPTkZMSUNUIChmaWxlIGxvY2F0aW9uKTogJXMgcmVuYW1lZCB0byAlcyBpbiAlcywgaW5zaWRlIGEgZGlyZWN0b3J5IHRoYXQgIgpAQCAtNDA1OCwzNyArNDA4NCw2MSBAQAogInJpZGVub21pbmF0YSBpbiAlcywgaWwgY2hlIHN1Z2dlcmlzY2UgY2hlIGZvcnNlIGRvdnJlYmJlIGVzc2VyZSBzcG9zdGF0byBpbiAiCiAiJXMuIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozMzAzCisjOiBtZXJnZS1yZWN1cnNpdmUuYzozMzI3CiAjLCBjLWZvcm1hdAogbXNnaWQgIlJlbW92aW5nICVzIgogbXNnc3RyICJSaW1vemlvbmUgZGkgJXMiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMzMjYKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMzNTAKIG1zZ2lkICJmaWxlL2RpcmVjdG9yeSIKIG1zZ3N0ciAiZmlsZS9kaXJlY3RvcnkiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMzMzEKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMzNTUKIG1zZ2lkICJkaXJlY3RvcnkvZmlsZSIKIG1zZ3N0ciAiZGlyZWN0b3J5L2ZpbGUiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMzMzgKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMzNjIKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ09ORkxJQ1QgKCVzKTogVGhlcmUgaXMgYSBkaXJlY3Rvcnkgd2l0aCBuYW1lICVzIGluICVzLiBBZGRpbmcgJXMgYXMgJXMiCiBtc2dzdHIgIiIKICJDT05GTElUVE8gKCVzKTogdW5hIGRpcmVjdG9yeSBkZW5vbWluYXRhICVzIGVzaXN0ZSBnacOgIGluICVzLiBBZ2dpdW5nbyAlcyAiCiAiY29tZSAlcyIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzM0NworIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzM3MQogIywgYy1mb3JtYXQKIG1zZ2lkICJBZGRpbmcgJXMiCiBtc2dzdHIgIkFnZ2l1bnRhICVzIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozMzU2CisjOiBtZXJnZS1yZWN1cnNpdmUuYzozMzgwCiAjLCBjLWZvcm1hdAogbXNnaWQgIkNPTkZMSUNUIChhZGQvYWRkKTogTWVyZ2UgY29uZmxpY3QgaW4gJXMiCiBtc2dzdHIgIkNPTkZMSVRUTyAoYWdnaXVuZ2kvYWdnaXVuZ2kpOiBjb25mbGl0dG8gZGkgbWVyZ2UgaW4gJXMiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMzOTQKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjM0MjQKK21zZ2lkICJBbHJlYWR5IHVwIHRvIGRhdGUhIgorbXNnc3RyICJHacOgIGFnZ2lvcm5hdG8hIgorCisjOiBtZXJnZS1yZWN1cnNpdmUuYzozNDMzCisjLCBjLWZvcm1hdAorbXNnaWQgIm1lcmdpbmcgb2YgdHJlZXMgJXMgYW5kICVzIGZhaWxlZCIKK21zZ3N0ciAibWVyZ2UgZGVnbGkgYWxiZXJpICVzIGUgJXMgbm9uIHJpdXNjaXRvIgorCisjOiBtZXJnZS1yZWN1cnNpdmUuYzozNTM3Cittc2dpZCAiTWVyZ2luZzoiCittc2dzdHIgIk1lcmdlIGluIGNvcnNvOiIKKworIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzU1MAorIywgYy1mb3JtYXQKK21zZ2lkICJmb3VuZCAldSBjb21tb24gYW5jZXN0b3I6IgorbXNnaWRfcGx1cmFsICJmb3VuZCAldSBjb21tb24gYW5jZXN0b3JzOiIKK21zZ3N0clswXSAidHJvdmF0byAldSBhbnRlbmF0byBjb211bmU6IgorbXNnc3RyWzFdICJ0cm92YXRpICV1IGFudGVuYXRpIGNvbXVuaToiCisKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjM2MDAKK21zZ2lkICJtZXJnZSByZXR1cm5lZCBubyBjb21taXQiCittc2dzdHIgImlsIG1lcmdlIG5vbiBoYSByZXN0aXR1aXRvIGFsY3VuIGNvbW1pdCIKKworIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzY1OQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiWW91ciBsb2NhbCBjaGFuZ2VzIHRvIHRoZSBmb2xsb3dpbmcgZmlsZXMgd291bGQgYmUgb3ZlcndyaXR0ZW4gYnkgbWVyZ2U6XG4iCkBAIC00MDk3LDE4OSArNDE0NywxNjUgQEAKICJMZSB0dWUgbW9kaWZpY2hlIGxvY2FsaSBhaSBzZWd1ZW50aSBmaWxlIHNhcmViYmVybyBzb3ZyYXNjcml0dGUgZGFsIG1lcmdlOlxuIgogIiAgJXMiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjM0MDUKLW1zZ2lkICJBbHJlYWR5IHVwIHRvIGRhdGUhIgotbXNnc3RyICJHacOgIGFnZ2lvcm5hdG8hIgotCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozNDE0Ci0jLCBjLWZvcm1hdAotbXNnaWQgIm1lcmdpbmcgb2YgdHJlZXMgJXMgYW5kICVzIGZhaWxlZCIKLW1zZ3N0ciAibWVyZ2UgZGVnbGkgYWxiZXJpICVzIGUgJXMgbm9uIHJpdXNjaXRvIgotCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozNTEzCi1tc2dpZCAiTWVyZ2luZzoiCi1tc2dzdHIgIk1lcmdlIGluIGNvcnNvOiIKLQotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzUyNgotIywgYy1mb3JtYXQKLW1zZ2lkICJmb3VuZCAldSBjb21tb24gYW5jZXN0b3I6IgotbXNnaWRfcGx1cmFsICJmb3VuZCAldSBjb21tb24gYW5jZXN0b3JzOiIKLW1zZ3N0clswXSAidHJvdmF0byAldSBhbnRlbmF0byBjb211bmU6IgotbXNnc3RyWzFdICJ0cm92YXRpICV1IGFudGVuYXRpIGNvbXVuaToiCi0KLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjM1NjUKLW1zZ2lkICJtZXJnZSByZXR1cm5lZCBubyBjb21taXQiCi1tc2dzdHIgImlsIG1lcmdlIG5vbiBoYSByZXN0aXR1aXRvIGFsY3VuIGNvbW1pdCIKLQotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzYzMQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6Mzc1NgogIywgYy1mb3JtYXQKIG1zZ2lkICJDb3VsZCBub3QgcGFyc2Ugb2JqZWN0ICclcyciCiBtc2dzdHIgIkltcG9zc2liaWxlIGFuYWxpenphcmUgbCdvZ2dldHRvICclcyciCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjM2NDcgYnVpbHRpbi9tZXJnZS5jOjY5OCBidWlsdGluL21lcmdlLmM6ODY5CisjOiBtZXJnZS1yZWN1cnNpdmUuYzozNzc0IGJ1aWx0aW4vbWVyZ2UuYzo2OTQgYnVpbHRpbi9tZXJnZS5jOjg3NAogbXNnaWQgIlVuYWJsZSB0byB3cml0ZSBpbmRleC4iCiBtc2dzdHIgIkltcG9zc2liaWxlIHNjcml2ZXJlIGwnaW5kaWNlLiIKIAotIzogbWlkeC5jOjY5CisjOiBtaWR4LmM6NjgKICMsIGMtZm9ybWF0CiBtc2dpZCAibXVsdGktcGFjay1pbmRleCBmaWxlICVzIGlzIHRvbyBzbWFsbCIKIG1zZ3N0ciAiaWwgZmlsZSBtdWx0aS1wYWNrLWluZGV4ICVzIMOoIHRyb3BwbyBwaWNjb2xvIgogCi0jOiBtaWR4LmM6ODUKKyM6IG1pZHguYzo4NAogIywgYy1mb3JtYXQKIG1zZ2lkICJtdWx0aS1wYWNrLWluZGV4IHNpZ25hdHVyZSAweCUwOHggZG9lcyBub3QgbWF0Y2ggc2lnbmF0dXJlIDB4JTA4eCIKIG1zZ3N0ciAibGEgZmlybWEgZGVsIG11bHRpLXBhY2staW5kZXggMHglMDh4IG5vbiBjb3JyaXNwb25kZSBhbGxhIGZpcm1hIDB4JTA4eCIKIAotIzogbWlkeC5jOjkwCisjOiBtaWR4LmM6ODkKICMsIGMtZm9ybWF0CiBtc2dpZCAibXVsdGktcGFjay1pbmRleCB2ZXJzaW9uICVkIG5vdCByZWNvZ25pemVkIgogbXNnc3RyICJ2ZXJzaW9uZSAlZCBtdWx0aS1wYWNrLWluZGV4IG5vbiByaWNvbm9zY2l1dGEiCiAKLSM6IG1pZHguYzo5NQorIzogbWlkeC5jOjk0CiAjLCBjLWZvcm1hdAogbXNnaWQgImhhc2ggdmVyc2lvbiAldSBkb2VzIG5vdCBtYXRjaCIKIG1zZ3N0ciAibGEgdmVyc2lvbmUgZGVsbCdoYXNoICV1IG5vbiBjb3JyaXNwb25kZSIKIAotIzogbWlkeC5jOjEwOQorIzogbWlkeC5jOjEwOAogbXNnaWQgImludmFsaWQgY2h1bmsgb2Zmc2V0ICh0b28gbGFyZ2UpIgogbXNnc3RyICJvZmZzZXQgYmxvY2NvIG5vbiB2YWxpZG8gKHRyb3BwbyBncmFuZGUpIgogCi0jOiBtaWR4LmM6MTMzCisjOiBtaWR4LmM6MTMyCiBtc2dpZCAidGVybWluYXRpbmcgbXVsdGktcGFjay1pbmRleCBjaHVuayBpZCBhcHBlYXJzIGVhcmxpZXIgdGhhbiBleHBlY3RlZCIKIG1zZ3N0ciAibCdJRCBibG9jY28gZmluYWxlIG11bHRpLXBhY2staW5kZXggY29tcGFyZSBwcmltYSBkaSBxdWFudG8gcHJldmlzdG8iCiAKLSM6IG1pZHguYzoxNDYKKyM6IG1pZHguYzoxNDUKIG1zZ2lkICJtdWx0aS1wYWNrLWluZGV4IG1pc3NpbmcgcmVxdWlyZWQgcGFjay1uYW1lIGNodW5rIgogbXNnc3RyICJkYWwgbXVsdGktcGFjay1pbmRleCBtYW5jYSBpbCBibG9jY28gcmljaGllc3RvIHBhY2stbmFtZSIKIAotIzogbWlkeC5jOjE0OAorIzogbWlkeC5jOjE0NwogbXNnaWQgIm11bHRpLXBhY2staW5kZXggbWlzc2luZyByZXF1aXJlZCBPSUQgZmFub3V0IGNodW5rIgogbXNnc3RyICJkYWwgbXVsdGktcGFjay1pbmRleCBtYW5jYSBpbCBibG9jY28gcmljaGllc3RvIGZhbm91dCBPSUQiCiAKLSM6IG1pZHguYzoxNTAKKyM6IG1pZHguYzoxNDkKIG1zZ2lkICJtdWx0aS1wYWNrLWluZGV4IG1pc3NpbmcgcmVxdWlyZWQgT0lEIGxvb2t1cCBjaHVuayIKIG1zZ3N0ciAiZGFsIG11bHRpLXBhY2staW5kZXggbWFuY2EgaWwgYmxvY2NvIHJpY2hpZXN0byBsb29rdXAgT0lEIgogCi0jOiBtaWR4LmM6MTUyCisjOiBtaWR4LmM6MTUxCiBtc2dpZCAibXVsdGktcGFjay1pbmRleCBtaXNzaW5nIHJlcXVpcmVkIG9iamVjdCBvZmZzZXRzIGNodW5rIgogbXNnc3RyICJkYWwgbXVsdGktcGFjay1pbmRleCBtYW5jYSBpbCBibG9jY28gcmljaGllc3RvIG9mZnNldCBvZ2dldHRpIgogCi0jOiBtaWR4LmM6MTY2CisjOiBtaWR4LmM6MTY1CiAjLCBjLWZvcm1hdAogbXNnaWQgIm11bHRpLXBhY2staW5kZXggcGFjayBuYW1lcyBvdXQgb2Ygb3JkZXI6ICclcycgYmVmb3JlICclcyciCiBtc2dzdHIgIm5vbWkgcGFjayBtdWx0aS1wYWNrLWluZGV4IGluIGRpc29yZGluZTogJyVzJyBhcHBhcmUgcHJpbWEgZGkgJyVzJyIKIAotIzogbWlkeC5jOjIxMQorIzogbWlkeC5jOjIxMAogIywgYy1mb3JtYXQKIG1zZ2lkICJiYWQgcGFjay1pbnQtaWQ6ICV1ICgldSB0b3RhbCBwYWNrcykiCiBtc2dzdHIgInBhY2staW50LWlkIG5vbiB2YWxpZG86ICV1ICgldSBwYWNrIHRvdGFsaSkiCiAKLSM6IG1pZHguYzoyNjEKKyM6IG1pZHguYzoyNjAKIG1zZ2lkICJtdWx0aS1wYWNrLWluZGV4IHN0b3JlcyBhIDY0LWJpdCBvZmZzZXQsIGJ1dCBvZmZfdCBpcyB0b28gc21hbGwiCiBtc2dzdHIgIiIKICJuZWwgbXVsdGktcGFjay1pbmRleCDDqCBzYWx2YXRvIHVuIG9mZnNldCBhIDY0IGJpdCwgbWEgb2ZmX3Qgw6ggdHJvcHBvIHBpY2NvbG8iCiAKLSM6IG1pZHguYzoyODkKKyM6IG1pZHguYzoyODgKIG1zZ2lkICJlcnJvciBwcmVwYXJpbmcgcGFja2ZpbGUgZnJvbSBtdWx0aS1wYWNrLWluZGV4IgogbXNnc3RyICJlcnJvcmUgZHVyYW50ZSBsYSBwcmVwYXJhemlvbmUgZGVsIHBhY2tmaWxlIGRhbCBtdWx0aS1wYWNrLWluZGV4IgogCi0jOiBtaWR4LmM6NDcwCisjOiBtaWR4LmM6NDY5CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBhZGQgcGFja2ZpbGUgJyVzJyIKIG1zZ3N0ciAiYWdnaXVudGEgZGVsIHBhY2tmaWxlICclcycgbm9uIHJpdXNjaXRhIgogCi0jOiBtaWR4LmM6NDc2CisjOiBtaWR4LmM6NDc1CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBvcGVuIHBhY2staW5kZXggJyVzJyIKIG1zZ3N0ciAiYXBlcnR1cmEgZGVsIHBhY2staW5kZXggJyVzJyBub24gcml1c2NpdGEiCiAKLSM6IG1pZHguYzo1MzYKKyM6IG1pZHguYzo1MzUKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIGxvY2F0ZSBvYmplY3QgJWQgaW4gcGFja2ZpbGUiCiBtc2dzdHIgInJpY2VyY2EgZGVsbCdvZ2dldHRvICVkIG5lbCBwYWNrZmlsZSBub24gcml1c2NpdGEiCiAKLSM6IG1pZHguYzo4NjUKKyM6IG1pZHguYzo4NjQKICMsIGMtZm9ybWF0CiBtc2dpZCAiZGlkIG5vdCBzZWUgcGFjay1maWxlICVzIHRvIGRyb3AiCiBtc2dzdHIgIm5vbiBobyB2aXN0byBpbCBmaWxlIHBhY2sgJXMgZGEgc2NhcnRhcmUiCiAKLSM6IG1pZHguYzoxMDM2CisjOiBtaWR4LmM6MTAzNQogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gY2xlYXIgbXVsdGktcGFjay1pbmRleCBhdCAlcyIKIG1zZ3N0ciAicHVsaXppYSBkZWwgbXVsdGktcGFjay1pbmRleCAlcyBub24gcml1c2NpdGEiCiAKLSM6IG1pZHguYzoxMDkxCisjOiBtaWR4LmM6MTA5MAogbXNnaWQgIkxvb2tpbmcgZm9yIHJlZmVyZW5jZWQgcGFja2ZpbGVzIgogbXNnc3RyICJSaWNlcmNhIGRpIGZpbGUgcGFjayByZWZlcmVuemlhdGkgaW4gY29yc28iCiAKLSM6IG1pZHguYzoxMTA2CisjOiBtaWR4LmM6MTEwNQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAib2lkIGZhbm91dCBvdXQgb2Ygb3JkZXI6IGZhbm91dFslZF0gPSAlPFBSSXgzMj4gPiAlPFBSSXgzMj4gPSBmYW5vdXRbJWRdIgogbXNnc3RyICIiCiAiZmFub3V0IG9pZCBpbiBkaXNvcmRpbmU6IGZhbm91dFslZF0gPSAlPFBSSXgzMj4gPiAlPFBSSXgzMj4gPSBmYW5vdXRbJWRdIgogCi0jOiBtaWR4LmM6MTExMAorIzogbWlkeC5jOjExMDkKIG1zZ2lkICJWZXJpZnlpbmcgT0lEIG9yZGVyIGluIE1JRFgiCiBtc2dzdHIgIlZlcmlmaWNhIG9yZGluZSBPSUQgaW4gTUlEWCBpbiBjb3JzbyIKIAotIzogbWlkeC5jOjExMTkKKyM6IG1pZHguYzoxMTE4CiAjLCBjLWZvcm1hdAogbXNnaWQgIm9pZCBsb29rdXAgb3V0IG9mIG9yZGVyOiBvaWRbJWRdID0gJXMgPj0gJXMgPSBvaWRbJWRdIgogbXNnc3RyICJsb29rdXAgb2lkIGluIGRpc29yZGluZTogb2lkWyVkXSA9ICVzID49ICVzID0gb2lkWyVkXSIKIAotIzogbWlkeC5jOjExMzgKKyM6IG1pZHguYzoxMTM3CiBtc2dpZCAiU29ydGluZyBvYmplY3RzIGJ5IHBhY2tmaWxlIgogbXNnc3RyICJPcmRpbmFtZW50byBkZWdsaSBvZ2dldHRpIG5lbCBwYWNrZmlsZSBpbiBjb3JzbyIKIAotIzogbWlkeC5jOjExNDQKKyM6IG1pZHguYzoxMTQzCiBtc2dpZCAiVmVyaWZ5aW5nIG9iamVjdCBvZmZzZXRzIgogbXNnc3RyICJWZXJpZmljYSBvZmZzZXQgb2dnZXR0aSBpbiBjb3JzbyIKIAotIzogbWlkeC5jOjExNjAKKyM6IG1pZHguYzoxMTU5CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBsb2FkIHBhY2sgZW50cnkgZm9yIG9pZFslZF0gPSAlcyIKIG1zZ3N0ciAiY2FyaWNhbWVudG8gdm9jZSBwYWNrIHBlciBvaWRbJWRdID0gJXMgbm9uIHJpdXNjaXRvIgogCi0jOiBtaWR4LmM6MTE2NgorIzogbWlkeC5jOjExNjUKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIGxvYWQgcGFjay1pbmRleCBmb3IgcGFja2ZpbGUgJXMiCiBtc2dzdHIgImNhcmljYW1lbnRvIHBhY2staW5kZXggcGVyIGlsIHBhY2tmaWxlICVzIG5vbiByaXVzY2l0byIKIAotIzogbWlkeC5jOjExNzUKKyM6IG1pZHguYzoxMTc0CiAjLCBjLWZvcm1hdAogbXNnaWQgImluY29ycmVjdCBvYmplY3Qgb2Zmc2V0IGZvciBvaWRbJWRdID0gJXM6ICU8UFJJeDY0PiAhPSAlPFBSSXg2ND4iCiBtc2dzdHIgIm9mZnNldCBvZ2dldHRvIG5vbiBjb3JyZXR0byBwZXIgb2lkWyVkXSA9ICVzOiAlPFBSSXg2ND4gIT0gJTxQUkl4NjQ+IgogCi0jOiBtaWR4LmM6MTM1MAorIzogbWlkeC5jOjEzNDkKIG1zZ2lkICJjb3VsZCBub3Qgc3RhcnQgcGFjay1vYmplY3RzIgogbXNnc3RyICJpbXBvc3NpYmlsZSBhdnZpYXJlIHBhY2stb2JqZWN0cyIKIAotIzogbWlkeC5jOjEzNjkKKyM6IG1pZHguYzoxMzY4CiBtc2dpZCAiY291bGQgbm90IGZpbmlzaCBwYWNrLW9iamVjdHMiCiBtc2dzdHIgImltcG9zc2liaWxlIGZpbmlyZSBwYWNrLW9iamVjdHMiCiAKLSM6IG5hbWUtaGFzaC5jOjUzMgorIzogbmFtZS1oYXNoLmM6NTM3CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBjcmVhdGUgbGF6eV9kaXIgdGhyZWFkOiAlcyIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgY3JlYXJlIGlsIHRocmVhZCBsYXp5X2RpcjogJXMiCiAKLSM6IG5hbWUtaGFzaC5jOjU1NAorIzogbmFtZS1oYXNoLmM6NTU5CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBjcmVhdGUgbGF6eV9uYW1lIHRocmVhZDogJXMiCiBtc2dzdHIgImltcG9zc2liaWxlIGNyZWFyZSBpbCB0aHJlYWQgbGF6eV9uYW1lOiAlcyIKIAotIzogbmFtZS1oYXNoLmM6NTYwCisjOiBuYW1lLWhhc2guYzo1NjUKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGpvaW4gbGF6eV9uYW1lIHRocmVhZDogJXMiCiBtc2dzdHIgImltcG9zc2liaWxlIGJsb2NjYXJlIGlsIHRocmVhZCBsYXp5X25hbWU6ICVzIgpAQCAtNDMyNiw0MiArNDM1Miw0MiBAQAogbXNnaWQgIkJhZCAlcyB2YWx1ZTogJyVzJyIKIG1zZ3N0ciAiVmFsb3JlIGRpICVzIGVycmF0bzogJyVzJyIKIAotIzogb2JqZWN0LmM6NTQKKyM6IG9iamVjdC5jOjUzCiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgb2JqZWN0IHR5cGUgXCIlc1wiIgogbXNnc3RyICJ0aXBvIG9nZ2V0dG8gXCIlc1wiIG5vbiB2YWxpZG8iCiAKLSM6IG9iamVjdC5jOjE3NAorIzogb2JqZWN0LmM6MTczCiAjLCBjLWZvcm1hdAogbXNnaWQgIm9iamVjdCAlcyBpcyBhICVzLCBub3QgYSAlcyIKIG1zZ3N0ciAibCdvZ2dldHRvICVzIMOoIHVuICVzLCBub24gdW4gJXMiCiAKLSM6IG9iamVjdC5jOjIzNAorIzogb2JqZWN0LmM6MjMzCiAjLCBjLWZvcm1hdAogbXNnaWQgIm9iamVjdCAlcyBoYXMgdW5rbm93biB0eXBlIGlkICVkIgogbXNnc3RyICJsJ29nZ2V0dG8gJXMgaGEgbCdJRCB0aXBvIHNjb25vc2NpdXRvICVkIgogCi0jOiBvYmplY3QuYzoyNDcKKyM6IG9iamVjdC5jOjI0NgogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gcGFyc2Ugb2JqZWN0OiAlcyIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgYW5hbGl6emFyZSBsJ29nZ2V0dG86ICVzIgogCi0jOiBvYmplY3QuYzoyNjcgb2JqZWN0LmM6Mjc4CisjOiBvYmplY3QuYzoyNjYgb2JqZWN0LmM6Mjc3CiAjLCBjLWZvcm1hdAogbXNnaWQgImhhc2ggbWlzbWF0Y2ggJXMiCiBtc2dzdHIgImhhc2ggbm9uIGNvcnJpc3BvbmRlbnRlOiAlcyIKIAotIzogcGFja2ZpbGUuYzo2NDgKKyM6IHBhY2tmaWxlLmM6NjQxCiBtc2dpZCAib2Zmc2V0IGJlZm9yZSBlbmQgb2YgcGFja2ZpbGUgKGJyb2tlbiAuaWR4PykiCiBtc2dzdHIgIm9mZnNldCBjb2xsb2NhdG8gcHJpbWEgZGVsbGEgZmluZSBkZWwgcGFja2ZpbGUgKC5pZHggY29ycm90dG8/KSIKIAotIzogcGFja2ZpbGUuYzoxODk5CisjOiBwYWNrZmlsZS5jOjE4ODcKICMsIGMtZm9ybWF0CiBtc2dpZCAib2Zmc2V0IGJlZm9yZSBzdGFydCBvZiBwYWNrIGluZGV4IGZvciAlcyAoY29ycnVwdCBpbmRleD8pIgogbXNnc3RyICIiCiAib2Zmc2V0IGNvbGxvY2F0byBwcmltYSBkZWxsJ2luaXppbyBkZWxsJ2luZGljZSBwYWNrIHBlciAlcyAoaW5kaWNlIGNvcnJvdHRvPykiCiAKLSM6IHBhY2tmaWxlLmM6MTkwMworIzogcGFja2ZpbGUuYzoxODkxCiAjLCBjLWZvcm1hdAogbXNnaWQgIm9mZnNldCBiZXlvbmQgZW5kIG9mIHBhY2sgaW5kZXggZm9yICVzICh0cnVuY2F0ZWQgaW5kZXg/KSIKIG1zZ3N0ciAiIgpAQCAtNDQwOCwyNiArNDQzNCwyNiBAQAogbXNnaWQgImRpZCB5b3UgbWVhbiBgLS0lc2AgKHdpdGggdHdvIGRhc2hlcyA/KSIKIG1zZ3N0ciAiZm9yc2UgaW50ZW5kZXZpIGAtLSVzYCAoY29uIGR1ZSB0cmF0dGluaSk/IgogCi0jOiBwYXJzZS1vcHRpb25zLmM6ODU5CisjOiBwYXJzZS1vcHRpb25zLmM6ODYwCiAjLCBjLWZvcm1hdAogbXNnaWQgInVua25vd24gb3B0aW9uIGAlcyciCiBtc2dzdHIgIm9wemlvbmUgc2Nvbm9zY2l1dGEgYCVzJyIKIAotIzogcGFyc2Utb3B0aW9ucy5jOjg2MQorIzogcGFyc2Utb3B0aW9ucy5jOjg2MgogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmtub3duIHN3aXRjaCBgJWMnIgogbXNnc3RyICJvcHppb25lIGAlY2Agc2Nvbm9zY2l1dGEiCiAKLSM6IHBhcnNlLW9wdGlvbnMuYzo4NjMKKyM6IHBhcnNlLW9wdGlvbnMuYzo4NjQKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5rbm93biBub24tYXNjaWkgb3B0aW9uIGluIHN0cmluZzogYCVzJyIKIG1zZ3N0ciAib3B6aW9uZSBub24gQVNDSUkgc2Nvbm9zY2l1dGEgcHJlc2VudGUgbmVsbGEgc3RyaW5nYTogYCVzJyIKIAotIzogcGFyc2Utb3B0aW9ucy5jOjg4NworIzogcGFyc2Utb3B0aW9ucy5jOjg4OAogbXNnaWQgIi4uLiIKIG1zZ3N0ciAiLi4uIgogCi0jOiBwYXJzZS1vcHRpb25zLmM6OTA2CisjOiBwYXJzZS1vcHRpb25zLmM6OTA3CiAjLCBjLWZvcm1hdAogbXNnaWQgInVzYWdlOiAlcyIKIG1zZ3N0ciAidXNvOiAlcyIKQEAgLTQ0MzUsMjEgKzQ0NjEsMjEgQEAKICMuIFRSQU5TTEFUT1JTOiB0aGUgY29sb24gaGVyZSBzaG91bGQgYWxpZ24gd2l0aCB0aGUKICMuIG9uZSBpbiAidXNhZ2U6ICVzIiB0cmFuc2xhdGlvbi4KICMuCi0jOiBwYXJzZS1vcHRpb25zLmM6OTEyCisjOiBwYXJzZS1vcHRpb25zLmM6OTEzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiAgIG9yOiAlcyIKIG1zZ3N0ciAiICBvcHB1cmU6ICVzIgogCi0jOiBwYXJzZS1vcHRpb25zLmM6OTE1CisjOiBwYXJzZS1vcHRpb25zLmM6OTE2CiAjLCBjLWZvcm1hdAogbXNnaWQgIiAgICAlcyIKIG1zZ3N0ciAiICAgICVzIgogCi0jOiBwYXJzZS1vcHRpb25zLmM6OTU0CisjOiBwYXJzZS1vcHRpb25zLmM6OTU1CiBtc2dpZCAiLU5VTSIKIG1zZ3N0ciAiLU5VTSIKIAotIzogcGFyc2Utb3B0aW9ucy5jOjk2OAorIzogcGFyc2Utb3B0aW9ucy5jOjk2OQogIywgYy1mb3JtYXQKIG1zZ2lkICJhbGlhcyBvZiAtLSVzIgogbXNnc3RyICJhbGlhcyBkaSAtLSVzIgpAQCAtNDYyMywyOSArNDY0OSwzOCBAQAogbXNnaWQgInVuYWJsZSB0byBwYXJzZSAtLXByZXR0eSBmb3JtYXQiCiBtc2dzdHIgImltcG9zc2liaWxlIGFuYWxpenphcmUgaWwgZm9ybWF0byAtLXByZXR0eSIKIAotIzogcmFuZ2UtZGlmZi5jOjcwCisjOiBwcm9taXNvci1yZW1vdGUuYzoyNQorbXNnaWQgIlJlbW90ZSB3aXRoIG5vIFVSTCIKK21zZ3N0ciAiUmVtb3RvIHNlbnphIFVSTCIKKworIzogcHJvbWlzb3ItcmVtb3RlLmM6NjEKKyMsIGMtZm9ybWF0Cittc2dpZCAicHJvbWlzb3IgcmVtb3RlIG5hbWUgY2Fubm90IGJlZ2luIHdpdGggJy8nOiAlcyIKK21zZ3N0ciAiaWwgbm9tZSBkZWwgcmVtb3RvIHByb21ldHRlbnRlIG5vbiBwdcOyIGluaXppYXJlIGNvbiAnLyc6ICVzIgorCisjOiByYW5nZS1kaWZmLmM6NzEKIG1zZ2lkICJjb3VsZCBub3Qgc3RhcnQgYGxvZ2AiCiBtc2dzdHIgImltcG9zc2liaWxlIGF2dmlhcmUgYGxvZ2AiCiAKLSM6IHJhbmdlLWRpZmYuYzo3MgorIzogcmFuZ2UtZGlmZi5jOjczCiBtc2dpZCAiY291bGQgbm90IHJlYWQgYGxvZ2Agb3V0cHV0IgogbXNnc3RyICJpbXBvc3NpYmlsZSBsZWdnZXJlIGwnb3V0cHV0IGRpIGBsb2dgIgogCi0jOiByYW5nZS1kaWZmLmM6OTEgc2VxdWVuY2VyLmM6NTAyMQorIzogcmFuZ2UtZGlmZi5jOjkyIHNlcXVlbmNlci5jOjQ5ODUKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHBhcnNlIGNvbW1pdCAnJXMnIgogbXNnc3RyICJpbXBvc3NpYmlsZSBhbmFsaXp6YXJlIGlsIGNvbW1pdCAnJXMnIgogCi0jOiByYW5nZS1kaWZmLmM6MTE3CisjOiByYW5nZS1kaWZmLmM6MTE4CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBwYXJzZSBnaXQgaGVhZGVyICclLipzJyIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgYW5hbGl6emFyZSBsJ2hlYWRlciBHaXQgJyUuKnMnIgogCi0jOiByYW5nZS1kaWZmLmM6Mjc0CisjOiByYW5nZS1kaWZmLmM6Mjc1CiBtc2dpZCAiZmFpbGVkIHRvIGdlbmVyYXRlIGRpZmYiCiBtc2dzdHIgImdlbmVyYXppb25lIGRlbCBkaWZmIG5vbiByaXVzY2l0YSIKIAotIzogcmFuZ2UtZGlmZi5jOjUwNiByYW5nZS1kaWZmLmM6NTA4CisjOiByYW5nZS1kaWZmLmM6NTA3IHJhbmdlLWRpZmYuYzo1MDkKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHBhcnNlIGxvZyBmb3IgJyVzJyIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgYW5hbGl6emFyZSBpbCByZWdpc3RybyBkaSAnJXMnIgpAQCAtNDY5MSwxMSArNDcyNiwxMSBAQAogbXNnaWQgIiclcycgYXBwZWFycyBhcyBib3RoIGEgZmlsZSBhbmQgYXMgYSBkaXJlY3RvcnkiCiBtc2dzdHIgIiclcycgY29tcGFyZSBzaWEgY29tZSBmaWxlIHNpYSBjb21lIGRpcmVjdG9yeSIKIAotIzogcmVhZC1jYWNoZS5jOjE0OTkKKyM6IHJlYWQtY2FjaGUuYzoxNTIwCiBtc2dpZCAiUmVmcmVzaCBpbmRleCIKIG1zZ3N0ciAiQWdnaW9ybmFtZW50byBpbmRpY2UiCiAKLSM6IHJlYWQtY2FjaGUuYzoxNjEzCisjOiByZWFkLWNhY2hlLmM6MTYzNQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiaW5kZXgudmVyc2lvbiBzZXQsIGJ1dCB0aGUgdmFsdWUgaXMgaW52YWxpZC5cbiIKQEAgLTQ3MDQsNyArNDczOSw3IEBACiAiaW5kZXgudmVyc2lvbiBpbXBvc3RhdG8sIG1hIGlsIHZhbG9yZSBub24gw6ggdmFsaWRvLlxuIgogIlVzbyBsYSB2ZXJzaW9uZSAlaSIKIAotIzogcmVhZC1jYWNoZS5jOjE2MjMKKyM6IHJlYWQtY2FjaGUuYzoxNjQ1CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJHSVRfSU5ERVhfVkVSU0lPTiBzZXQsIGJ1dCB0aGUgdmFsdWUgaXMgaW52YWxpZC5cbiIKQEAgLTQ3MTMsMTM4ICs0NzQ4LDEzOCBAQAogIkdJVF9JTkRFWF9WRVJTSU9OIGltcG9zdGF0bywgbWEgaWwgdmFsb3JlIG5vbiDDqCB2YWxpZG8uXG4iCiAiVXNvIGxhIHZlcnNpb25lICVpIgogCi0jOiByZWFkLWNhY2hlLmM6MTY3OQorIzogcmVhZC1jYWNoZS5jOjE3MDEKICMsIGMtZm9ybWF0CiBtc2dpZCAiYmFkIHNpZ25hdHVyZSAweCUwOHgiCiBtc2dzdHIgImZpcm1hIG5vbiB2YWxpZGE6IDB4JTA4eCIKIAotIzogcmVhZC1jYWNoZS5jOjE2ODIKKyM6IHJlYWQtY2FjaGUuYzoxNzA0CiAjLCBjLWZvcm1hdAogbXNnaWQgImJhZCBpbmRleCB2ZXJzaW9uICVkIgogbXNnc3RyICJ2ZXJzaW9uZSBpbmRpY2Ugbm9uIHZhbGlkYTogJWQiCiAKLSM6IHJlYWQtY2FjaGUuYzoxNjkxCisjOiByZWFkLWNhY2hlLmM6MTcxMwogbXNnaWQgImJhZCBpbmRleCBmaWxlIHNoYTEgc2lnbmF0dXJlIgogbXNnc3RyICJmaXJtYSBTSEExIGZpbGUgaW5kaWNlIG5vbiB2YWxpZGEiCiAKLSM6IHJlYWQtY2FjaGUuYzoxNzIxCisjOiByZWFkLWNhY2hlLmM6MTc0MwogIywgYy1mb3JtYXQKIG1zZ2lkICJpbmRleCB1c2VzICUuNHMgZXh0ZW5zaW9uLCB3aGljaCB3ZSBkbyBub3QgdW5kZXJzdGFuZCIKIG1zZ3N0ciAibCdpbmRpY2UgdXNhIGwnZXN0ZW5zaW9uZSAlLjRzIGNoZSBub24gY29tcHJlbmRpYW1vIgogCi0jOiByZWFkLWNhY2hlLmM6MTcyMworIzogcmVhZC1jYWNoZS5jOjE3NDUKICMsIGMtZm9ybWF0CiBtc2dpZCAiaWdub3JpbmcgJS40cyBleHRlbnNpb24iCiBtc2dzdHIgImVzdGVuc2lvbmUgJS40cyBpZ25vcmF0YSIKIAotIzogcmVhZC1jYWNoZS5jOjE3NjAKKyM6IHJlYWQtY2FjaGUuYzoxNzgyCiAjLCBjLWZvcm1hdAogbXNnaWQgInVua25vd24gaW5kZXggZW50cnkgZm9ybWF0IDB4JTA4eCIKIG1zZ3N0ciAiZm9ybWF0byB2b2NlIGluZGljZSBzY29ub3NjaXV0bzogMHglMDh4IgogCi0jOiByZWFkLWNhY2hlLmM6MTc3NgorIzogcmVhZC1jYWNoZS5jOjE3OTgKICMsIGMtZm9ybWF0CiBtc2dpZCAibWFsZm9ybWVkIG5hbWUgZmllbGQgaW4gdGhlIGluZGV4LCBuZWFyIHBhdGggJyVzJyIKIG1zZ3N0ciAiY2FtcG8gbm9tZSBtYWxmb3JtYXRvIG5lbGwnaW5kaWNlLCB2aWNpbm8gYWwgcGVyY29yc28gJyVzJyIKIAotIzogcmVhZC1jYWNoZS5jOjE4MzMKKyM6IHJlYWQtY2FjaGUuYzoxODU1CiBtc2dpZCAidW5vcmRlcmVkIHN0YWdlIGVudHJpZXMgaW4gaW5kZXgiCiBtc2dzdHIgInZvY2kgc3RhZ2Ugbm9uIG9yZGluYXRlIG5lbGwnaW5kaWNlIgogCi0jOiByZWFkLWNhY2hlLmM6MTgzNgorIzogcmVhZC1jYWNoZS5jOjE4NTgKICMsIGMtZm9ybWF0CiBtc2dpZCAibXVsdGlwbGUgc3RhZ2UgZW50cmllcyBmb3IgbWVyZ2VkIGZpbGUgJyVzJyIKIG1zZ3N0ciAidm9jaSBzdGFnZSBtdWx0aXBsZSBwZXIgaWwgZmlsZSBzb3R0b3Bvc3RvIGEgbWVyZ2UgJyVzJyIKIAotIzogcmVhZC1jYWNoZS5jOjE4MzkKKyM6IHJlYWQtY2FjaGUuYzoxODYxCiAjLCBjLWZvcm1hdAogbXNnaWQgInVub3JkZXJlZCBzdGFnZSBlbnRyaWVzIGZvciAnJXMnIgogbXNnc3RyICJ2b2NpIHN0YWdlIG5vbiBvcmRpbmF0ZSBwZXIgJyVzJyIKIAotIzogcmVhZC1jYWNoZS5jOjE5NDYgcmVhZC1jYWNoZS5jOjIyMzQgcmVyZXJlLmM6NTY1IHJlcmVyZS5jOjU5OSByZXJlcmUuYzoxMTExCi0jOiBidWlsdGluL2FkZC5jOjQ2MCBidWlsdGluL2NoZWNrLWlnbm9yZS5jOjE3OCBidWlsdGluL2NoZWNrb3V0LmM6NDY3Ci0jOiBidWlsdGluL2NoZWNrb3V0LmM6NjUxIGJ1aWx0aW4vY2xlYW4uYzo5NTYgYnVpbHRpbi9jb21taXQuYzozNDcKKyM6IHJlYWQtY2FjaGUuYzoxOTY3IHJlYWQtY2FjaGUuYzoyMjU1IHJlcmVyZS5jOjU2NSByZXJlcmUuYzo1OTkgcmVyZXJlLmM6MTExMQorIzogYnVpbHRpbi9hZGQuYzo0NjAgYnVpbHRpbi9jaGVjay1pZ25vcmUuYzoxNzggYnVpbHRpbi9jaGVja291dC5jOjQ2OAorIzogYnVpbHRpbi9jaGVja291dC5jOjY1MiBidWlsdGluL2NsZWFuLmM6OTY3IGJ1aWx0aW4vY29tbWl0LmM6MzQ3CiAjOiBidWlsdGluL2RpZmYtdHJlZS5jOjEyMCBidWlsdGluL2dyZXAuYzo0OTkgYnVpbHRpbi9tdi5jOjE0NQogIzogYnVpbHRpbi9yZXNldC5jOjI0NSBidWlsdGluL3JtLmM6MjcxIGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzozMzAKIG1zZ2lkICJpbmRleCBmaWxlIGNvcnJ1cHQiCiBtc2dzdHIgImZpbGUgaW5kaWNlIGNvcnJvdHRvIgogCi0jOiByZWFkLWNhY2hlLmM6MjA4NworIzogcmVhZC1jYWNoZS5jOjIxMDgKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGNyZWF0ZSBsb2FkX2NhY2hlX2VudHJpZXMgdGhyZWFkOiAlcyIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgY3JlYXJlIGlsIHRocmVhZCBsb2FkX2NhY2hlX2VudHJpZXM6ICVzIgogCi0jOiByZWFkLWNhY2hlLmM6MjEwMAorIzogcmVhZC1jYWNoZS5jOjIxMjEKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGpvaW4gbG9hZF9jYWNoZV9lbnRyaWVzIHRocmVhZDogJXMiCiBtc2dzdHIgImltcG9zc2liaWxlIGJsb2NjYXJlIGlsIHRocmVhZCBsb2FkX2NhY2hlX2VudHJpZXM6ICVzIgogCi0jOiByZWFkLWNhY2hlLmM6MjEzMworIzogcmVhZC1jYWNoZS5jOjIxNTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXM6IGluZGV4IGZpbGUgb3BlbiBmYWlsZWQiCiBtc2dzdHIgIiVzOiBhcGVydHVyYSBkZWwgZmlsZSBpbmRpY2Ugbm9uIHJpdXNjaXRhIgogCi0jOiByZWFkLWNhY2hlLmM6MjEzNworIzogcmVhZC1jYWNoZS5jOjIxNTgKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXM6IGNhbm5vdCBzdGF0IHRoZSBvcGVuIGluZGV4IgogbXNnc3RyICIlczogaW1wb3NzaWJpbGUgZXNlZ3VpcmUgc3RhdCBzdWxsJ2luZGljZSBhcGVydG8iCiAKLSM6IHJlYWQtY2FjaGUuYzoyMTQxCisjOiByZWFkLWNhY2hlLmM6MjE2MgogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogaW5kZXggZmlsZSBzbWFsbGVyIHRoYW4gZXhwZWN0ZWQiCiBtc2dzdHIgIiVzOiBmaWxlIGluZGljZSBwacO5IHBpY2NvbG8gZGVsbGEgZGltZW5zaW9uZSBhdHRlc2EiCiAKLSM6IHJlYWQtY2FjaGUuYzoyMTQ1CisjOiByZWFkLWNhY2hlLmM6MjE2NgogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogdW5hYmxlIHRvIG1hcCBpbmRleCBmaWxlIgogbXNnc3RyICIlczogaW1wb3NzaWJpbGUgbWFwcGFyZSBpbCBmaWxlIGluZGljZSIKIAotIzogcmVhZC1jYWNoZS5jOjIxODcKKyM6IHJlYWQtY2FjaGUuYzoyMjA4CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBjcmVhdGUgbG9hZF9pbmRleF9leHRlbnNpb25zIHRocmVhZDogJXMiCiBtc2dzdHIgImltcG9zc2liaWxlIGNyZWFyZSBpbCB0aHJlYWQgbG9hZF9pbmRleF9leHRlbnNpb25zOiAlcyIKIAotIzogcmVhZC1jYWNoZS5jOjIyMTQKKyM6IHJlYWQtY2FjaGUuYzoyMjM1CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBqb2luIGxvYWRfaW5kZXhfZXh0ZW5zaW9ucyB0aHJlYWQ6ICVzIgogbXNnc3RyICJpbXBvc3NpYmlsZSBibG9jY2FyZSBpbCB0aHJlYWQgbG9hZF9pbmRleF9leHRlbnNpb25zOiAlcyIKIAotIzogcmVhZC1jYWNoZS5jOjIyNDYKKyM6IHJlYWQtY2FjaGUuYzoyMjY3CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBmcmVzaGVuIHNoYXJlZCBpbmRleCAnJXMnIgogbXNnc3RyICJpbXBvc3NpYmlsZSBhZ2dpb3JuYXJlIGwnaW5kaWNlIGNvbmRpdmlzbyAnJXMnIgogCi0jOiByZWFkLWNhY2hlLmM6MjI5MworIzogcmVhZC1jYWNoZS5jOjIzMTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiYnJva2VuIGluZGV4LCBleHBlY3QgJXMgaW4gJXMsIGdvdCAlcyIKIG1zZ3N0ciAiaW5kaWNlIGNvcnJvdHRvLCBhdHRlc28gJXMgaW4gJXMsIHByZXNlbnRlICVzIgogCi0jOiByZWFkLWNhY2hlLmM6Mjk4OSB3cmFwcGVyLmM6NjU4IGJ1aWx0aW4vbWVyZ2UuYzoxMTE0CisjOiByZWFkLWNhY2hlLmM6MzAxMCB3cmFwcGVyLmM6NjIyIGJ1aWx0aW4vbWVyZ2UuYzoxMTE5CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBjbG9zZSAnJXMnIgogbXNnc3RyICJpbXBvc3NpYmlsZSBjaGl1ZGVyZSAnJXMnIgogCi0jOiByZWFkLWNhY2hlLmM6MzA5MiBzZXF1ZW5jZXIuYzoyMzU4IHNlcXVlbmNlci5jOjM5MjgKKyM6IHJlYWQtY2FjaGUuYzozMTEzIHNlcXVlbmNlci5jOjIyOTYgc2VxdWVuY2VyLmM6MzkxNwogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3Qgc3RhdCAnJXMnIgogbXNnc3RyICJpbXBvc3NpYmlsZSBlc2VndWlyZSBsbyBzdGF0IGRpICclcyciCiAKLSM6IHJlYWQtY2FjaGUuYzozMTA1CisjOiByZWFkLWNhY2hlLmM6MzEyNgogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gb3BlbiBnaXQgZGlyOiAlcyIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgYXByaXJlIGxhIGRpcmVjdG9yeSBnaXQ6ICVzIgogCi0jOiByZWFkLWNhY2hlLmM6MzExNworIzogcmVhZC1jYWNoZS5jOjMxMzgKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHVubGluazogJXMiCiBtc2dzdHIgImltcG9zc2liaWxlIGVzZWd1aXJlIHVubGluazogJXMiCiAKLSM6IHJlYWQtY2FjaGUuYzozMTQyCisjOiByZWFkLWNhY2hlLmM6MzE2MwogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgZml4IHBlcm1pc3Npb24gYml0cyBvbiAnJXMnIgogbXNnc3RyICJpbXBvc3NpYmlsZSBjb3JyZWdnZXJlIGkgcGVybWVzc2kgZGkgJyVzJyIKIAotIzogcmVhZC1jYWNoZS5jOjMyOTEKKyM6IHJlYWQtY2FjaGUuYzozMzEyCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiBjYW5ub3QgZHJvcCB0byBzdGFnZSAjMCIKIG1zZ3N0ciAiJXM6IGltcG9zc2liaWxlIHJpcGllZ2FyZSBzdWxsbyBzdGFkaW8gMCIKQEAgLTQ5NTQsOCArNDk4OSw4IEBACiBtc2dpZCAiTm90ZSB0aGF0IGVtcHR5IGNvbW1pdHMgYXJlIGNvbW1lbnRlZCBvdXQiCiBtc2dzdHIgIk5vdGEgY2hlIGkgY29tbWl0IHZ1b3RpIHNvbm8gY29tbWVudGF0aSIKIAotIzogcmViYXNlLWludGVyYWN0aXZlLmM6MTA1IHJlcmVyZS5jOjQ4NSByZXJlcmUuYzo2OTIgc2VxdWVuY2VyLmM6MzQ0NwotIzogc2VxdWVuY2VyLmM6MzQ3MyBzZXF1ZW5jZXIuYzo1MTIwIGJ1aWx0aW4vZnNjay5jOjM1NiBidWlsdGluL3JlYmFzZS5jOjIzNQorIzogcmViYXNlLWludGVyYWN0aXZlLmM6MTA1IHJlcmVyZS5jOjQ4NSByZXJlcmUuYzo2OTIgc2VxdWVuY2VyLmM6MzM4OAorIzogc2VxdWVuY2VyLmM6MzQxNCBzZXF1ZW5jZXIuYzo1MDg0IGJ1aWx0aW4vZnNjay5jOjM1NiBidWlsdGluL3JlYmFzZS5jOjIzNQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3Qgd3JpdGUgJyVzJyIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgc2NyaXZlcmUgJyVzJyIKQEAgLTUwMDMsNyArNTAzOCw3IEBACiBtc2dpZCAiaWdub3JpbmcgZGFuZ2xpbmcgc3ltcmVmICVzIgogbXNnc3RyICJpZ25vcm8gaWwgcmlmZXJpbWVudG8gc2ltYm9saWNvIHBlbmRlbnRlICVzIgogCi0jOiByZWZzLmM6NjY5IHJlZi1maWx0ZXIuYzoyMDkyCisjOiByZWZzLmM6NjY5IHJlZi1maWx0ZXIuYzoyMDk4CiAjLCBjLWZvcm1hdAogbXNnaWQgImlnbm9yaW5nIGJyb2tlbiByZWYgJXMiCiBtc2dzdHIgImlnbm9ybyBpbCByaWZlcmltZW50byByb3R0byAlcyIKQEAgLTUwMjgsMTQgKzUwNjMsMTQgQEAKIG1zZ2lkICJ1bmV4cGVjdGVkIG9iamVjdCBJRCB3aGVuIHdyaXRpbmcgJyVzJyIKIG1zZ3N0ciAiSUQgb2dnZXR0byBpbmF0dGVzbyBkdXJhbnRlIGxhIHNjcml0dHVyYSBkaSAnJXMnIgogCi0jOiByZWZzLmM6ODMzIHNlcXVlbmNlci5jOjQwMyBzZXF1ZW5jZXIuYzoyNzA5IHNlcXVlbmNlci5jOjI5MTMKLSM6IHNlcXVlbmNlci5jOjI5Mjcgc2VxdWVuY2VyLmM6MzE4NCBzZXF1ZW5jZXIuYzo1MDM3IHdyYXBwZXIuYzo2NTYKKyM6IHJlZnMuYzo4MzMgc2VxdWVuY2VyLmM6NDAzIHNlcXVlbmNlci5jOjI2NDcgc2VxdWVuY2VyLmM6Mjg1MQorIzogc2VxdWVuY2VyLmM6Mjg2NSBzZXF1ZW5jZXIuYzozMTIyIHNlcXVlbmNlci5jOjUwMDEgd3JhcHBlci5jOjYyMAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3Qgd3JpdGUgdG8gJyVzJyIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgc2NyaXZlcmUgc3UgJyVzJyIKIAotIzogcmVmcy5jOjg2MCB3cmFwcGVyLmM6MjI1IHdyYXBwZXIuYzozOTUgYnVpbHRpbi9hbS5jOjcxNQotIzogYnVpbHRpbi9yZWJhc2UuYzoxMDAzCisjOiByZWZzLmM6ODYwIHdyYXBwZXIuYzoxODggd3JhcHBlci5jOjM1OCBidWlsdGluL2FtLmM6NzE0CisjOiBidWlsdGluL3JlYmFzZS5jOjEwMDQKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IG9wZW4gJyVzJyBmb3Igd3JpdGluZyIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgYXByaXJlICclcycgaW4gc2NyaXR0dXJhIgpAQCAtNTA3MCwyMSArNTEwNSwyMSBAQAogbXNnaWQgInVwZGF0ZV9yZWYgZmFpbGVkIGZvciByZWYgJyVzJzogJXMiCiBtc2dzdHIgInVwZGF0ZV9yZWYgcGVyIGlsIHJpZmVyaW1lbnRvICclcycgbm9uIHJpdXNjaXRhOiAlcyIKIAotIzogcmVmcy5jOjIwMTIKKyM6IHJlZnMuYzoyMDIzCiAjLCBjLWZvcm1hdAogbXNnaWQgIm11bHRpcGxlIHVwZGF0ZXMgZm9yIHJlZiAnJXMnIG5vdCBhbGxvd2VkIgogbXNnc3RyICJhZ2dpb3JuYW1lbnRpIG11bHRpcGxpIHBlciBpbCByaWZlcmltZW50byAnJXMnIG5vbiBjb25zZW50aXRpIgogCi0jOiByZWZzLmM6MjA0NAorIzogcmVmcy5jOjIwNTUKIG1zZ2lkICJyZWYgdXBkYXRlcyBmb3JiaWRkZW4gaW5zaWRlIHF1YXJhbnRpbmUgZW52aXJvbm1lbnQiCiBtc2dzdHIgImFnZ2lvcm5hbWVudGkgcmlmZXJpbWVudG8gdmlldGF0aSBuZWxsJ2FtYmllbnRlIHF1YXJhbnRlbmEiCiAKLSM6IHJlZnMuYzoyMTQwIHJlZnMuYzoyMTcwCisjOiByZWZzLmM6MjE1MSByZWZzLmM6MjE4MQogIywgYy1mb3JtYXQKIG1zZ2lkICInJXMnIGV4aXN0czsgY2Fubm90IGNyZWF0ZSAnJXMnIgogbXNnc3RyICInJXMnIGVzaXN0ZSBnacOgOyBpbXBvc3NpYmlsZSBjcmVhcmUgJyVzJyIKIAotIzogcmVmcy5jOjIxNDYgcmVmcy5jOjIxODEKKyM6IHJlZnMuYzoyMTU3IHJlZnMuYzoyMTkyCiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCBwcm9jZXNzICclcycgYW5kICclcycgYXQgdGhlIHNhbWUgdGltZSIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgZ2VzdGlyZSAnJXMnIGUgJyVzJyBjb250ZW1wb3JhbmVhbWVudGUiCkBAIC01MDk0LDEzICs1MTI5LDEzIEBACiBtc2dpZCAiY291bGQgbm90IHJlbW92ZSByZWZlcmVuY2UgJXMiCiBtc2dzdHIgImltcG9zc2liaWxlIHJpbXVvdmVyZSBpbCByaWZlcmltZW50byAlcyIKIAotIzogcmVmcy9maWxlcy1iYWNrZW5kLmM6MTI0OCByZWZzL3BhY2tlZC1iYWNrZW5kLmM6MTUzMgotIzogcmVmcy9wYWNrZWQtYmFja2VuZC5jOjE1NDIKKyM6IHJlZnMvZmlsZXMtYmFja2VuZC5jOjEyNDggcmVmcy9wYWNrZWQtYmFja2VuZC5jOjE1NDEKKyM6IHJlZnMvcGFja2VkLWJhY2tlbmQuYzoxNTUxCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBkZWxldGUgcmVmZXJlbmNlICVzOiAlcyIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgZWxpbWluYXJlIGlsIHJpZmVyaW1lbnRvICVzOiAlcyIKIAotIzogcmVmcy9maWxlcy1iYWNrZW5kLmM6MTI1MSByZWZzL3BhY2tlZC1iYWNrZW5kLmM6MTU0NQorIzogcmVmcy9maWxlcy1iYWNrZW5kLmM6MTI1MSByZWZzL3BhY2tlZC1iYWNrZW5kLmM6MTU1NAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgZGVsZXRlIHJlZmVyZW5jZXM6ICVzIgogbXNnc3RyICJpbXBvc3NpYmlsZSBlbGltaW5hcmUgaSByaWZlcmltZW50aTogJXMiCkBAIC01MTEwLDcgKzUxNDUsNyBAQAogbXNnaWQgImludmFsaWQgcmVmc3BlYyAnJXMnIgogbXNnc3RyICJzcGVjaWZpY2F0b3JlIHJpZmVyaW1lbnRvICclcycgbm9uIHZhbGlkbyIKIAotIzogcmVmLWZpbHRlci5jOjQyIHd0LXN0YXR1cy5jOjE5MzQKKyM6IHJlZi1maWx0ZXIuYzo0MiB3dC1zdGF0dXMuYzoxOTM4CiBtc2dpZCAiZ29uZSIKIG1zZ3N0ciAic3Bhcml0byIKIApAQCAtNTEyOSwxMjIgKzUxNjQsMTIyIEBACiBtc2dpZCAiYWhlYWQgJWQsIGJlaGluZCAlZCIKIG1zZ3N0ciAiZG9wbyAlZCwgcHJpbWEgZGkgJWQiCiAKLSM6IHJlZi1maWx0ZXIuYzoxNjIKKyM6IHJlZi1maWx0ZXIuYzoxNjUKICMsIGMtZm9ybWF0CiBtc2dpZCAiZXhwZWN0ZWQgZm9ybWF0OiAlJShjb2xvcjo8Y29sb3I+KSIKIG1zZ3N0ciAiZm9ybWF0byBhdHRlc286ICUlKGNvbG9yOjxjb2xvcmU+KSIKIAotIzogcmVmLWZpbHRlci5jOjE2NAorIzogcmVmLWZpbHRlci5jOjE2NwogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bnJlY29nbml6ZWQgY29sb3I6ICUlKGNvbG9yOiVzKSIKIG1zZ3N0ciAiY29sb3JlIG5vbiByaWNvbm9zY2l1dG86ICUlKGNvbG9yOiVzKSIKIAotIzogcmVmLWZpbHRlci5jOjE4NgorIzogcmVmLWZpbHRlci5jOjE4OQogIywgYy1mb3JtYXQKIG1zZ2lkICJJbnRlZ2VyIHZhbHVlIGV4cGVjdGVkIHJlZm5hbWU6bHN0cmlwPSVzIgogbXNnc3RyICJBdHRlc28gdmFsb3JlIGludGVybzogcmVmbmFtZTpsc3RyaXA9JXMiCiAKLSM6IHJlZi1maWx0ZXIuYzoxOTAKKyM6IHJlZi1maWx0ZXIuYzoxOTMKICMsIGMtZm9ybWF0CiBtc2dpZCAiSW50ZWdlciB2YWx1ZSBleHBlY3RlZCByZWZuYW1lOnJzdHJpcD0lcyIKIG1zZ3N0ciAiQXR0ZXNvIHZhbG9yZSBpbnRlcm86IHJlZm5hbWU6cnN0cmlwPSVzIgogCi0jOiByZWYtZmlsdGVyLmM6MTkyCisjOiByZWYtZmlsdGVyLmM6MTk1CiAjLCBjLWZvcm1hdAogbXNnaWQgInVucmVjb2duaXplZCAlJSglcykgYXJndW1lbnQ6ICVzIgogbXNnc3RyICJhcmdvbWVudG8gJSUoJXMpIG5vbiByaWNvbm9zY2l1dG86ICVzIgogCi0jOiByZWYtZmlsdGVyLmM6MjQ3CisjOiByZWYtZmlsdGVyLmM6MjUwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiUlKG9iamVjdHR5cGUpIGRvZXMgbm90IHRha2UgYXJndW1lbnRzIgogbXNnc3RyICIlJShvYmplY3R0eXBlKSBub24gYWNjZXR0YSBhcmdvbWVudGkiCiAKLSM6IHJlZi1maWx0ZXIuYzoyNjkKKyM6IHJlZi1maWx0ZXIuYzoyNzIKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5yZWNvZ25pemVkICUlKG9iamVjdHNpemUpIGFyZ3VtZW50OiAlcyIKIG1zZ3N0ciAiYXJnb21lbnRvICUlKG9iamVjdHNpemUpIG5vbiByaWNvbm9zY2l1dG86ICVzIgogCi0jOiByZWYtZmlsdGVyLmM6Mjc3CisjOiByZWYtZmlsdGVyLmM6MjgwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiUlKGRlbHRhYmFzZSkgZG9lcyBub3QgdGFrZSBhcmd1bWVudHMiCiBtc2dzdHIgIiUlKGRlbHRhYmFzZSkgbm9uIGFjY2V0dGEgYXJnb21lbnRpIgogCi0jOiByZWYtZmlsdGVyLmM6Mjg5CisjOiByZWYtZmlsdGVyLmM6MjkyCiAjLCBjLWZvcm1hdAogbXNnaWQgIiUlKGJvZHkpIGRvZXMgbm90IHRha2UgYXJndW1lbnRzIgogbXNnc3RyICIlJShib2R5KSBub24gYWNjZXR0YSBhcmdvbWVudGkiCiAKLSM6IHJlZi1maWx0ZXIuYzoyOTgKKyM6IHJlZi1maWx0ZXIuYzozMDEKICMsIGMtZm9ybWF0CiBtc2dpZCAiJSUoc3ViamVjdCkgZG9lcyBub3QgdGFrZSBhcmd1bWVudHMiCiBtc2dzdHIgIiUlKHN1YmplY3QpIG5vbiBhY2NldHRhIGFyZ29tZW50aSIKIAotIzogcmVmLWZpbHRlci5jOjMyMAorIzogcmVmLWZpbHRlci5jOjMyMwogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmtub3duICUlKHRyYWlsZXJzKSBhcmd1bWVudDogJXMiCiBtc2dzdHIgImFyZ29tZW50byAlJSh0cmFpbGVycykgc2Nvbm9zY2l1dG86ICVzIgogCi0jOiByZWYtZmlsdGVyLmM6MzQ5CisjOiByZWYtZmlsdGVyLmM6MzUyCiAjLCBjLWZvcm1hdAogbXNnaWQgInBvc2l0aXZlIHZhbHVlIGV4cGVjdGVkIGNvbnRlbnRzOmxpbmVzPSVzIgogbXNnc3RyICJhdHRlc28gdmFsb3JlIHBvc2l0aXZvIGluIGNvbnRlbnRzOmxpbmVzPSVzIgogCi0jOiByZWYtZmlsdGVyLmM6MzUxCisjOiByZWYtZmlsdGVyLmM6MzU0CiAjLCBjLWZvcm1hdAogbXNnaWQgInVucmVjb2duaXplZCAlJShjb250ZW50cykgYXJndW1lbnQ6ICVzIgogbXNnc3RyICJhcmdvbWVudG8gJSUoY29udGVudHMpIG5vbiByaWNvbm9zY2l1dG86ICVzIgogCi0jOiByZWYtZmlsdGVyLmM6MzY2CisjOiByZWYtZmlsdGVyLmM6MzY5CiAjLCBjLWZvcm1hdAogbXNnaWQgInBvc2l0aXZlIHZhbHVlIGV4cGVjdGVkIG9iamVjdG5hbWU6c2hvcnQ9JXMiCiBtc2dzdHIgImF0dGVzbyB2YWxvcmUgcG9zaXRpdm8gaW4gb2JqZWN0bmFtZTpzaG9ydD0lcyIKIAotIzogcmVmLWZpbHRlci5jOjM3MAorIzogcmVmLWZpbHRlci5jOjM3MwogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bnJlY29nbml6ZWQgJSUob2JqZWN0bmFtZSkgYXJndW1lbnQ6ICVzIgogbXNnc3RyICJhcmdvbWVudG8gJSUob2JqZWN0bmFtZSkgbm9uIHJpY29ub3NjaXV0bzogJXMiCiAKLSM6IHJlZi1maWx0ZXIuYzo0MDAKKyM6IHJlZi1maWx0ZXIuYzo0MDMKICMsIGMtZm9ybWF0CiBtc2dpZCAiZXhwZWN0ZWQgZm9ybWF0OiAlJShhbGlnbjo8d2lkdGg+LDxwb3NpdGlvbj4pIgogbXNnc3RyICJmb3JtYXRvIGF0dGVzbzogJSUoYWxpZ246PGFtcGllenphPiw8cG9zaXppb25lPikiCiAKLSM6IHJlZi1maWx0ZXIuYzo0MTIKKyM6IHJlZi1maWx0ZXIuYzo0MTUKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5yZWNvZ25pemVkIHBvc2l0aW9uOiVzIgogbXNnc3RyICJ2YWxvcmUgbm9uIHJpY29ub3NjaXV0bzogcG9zaXRpb246JXMiCiAKLSM6IHJlZi1maWx0ZXIuYzo0MTkKKyM6IHJlZi1maWx0ZXIuYzo0MjIKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5yZWNvZ25pemVkIHdpZHRoOiVzIgogbXNnc3RyICJ2YWxvcmUgbm9uIHJpY29ub3NjaXV0bzogd2lkdGg6JXMiCiAKLSM6IHJlZi1maWx0ZXIuYzo0MjgKKyM6IHJlZi1maWx0ZXIuYzo0MzEKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5yZWNvZ25pemVkICUlKGFsaWduKSBhcmd1bWVudDogJXMiCiBtc2dzdHIgImFyZ29tZW50byAlJShhbGlnbikgbm9uIHJpY29ub3NjaXV0bzogJXMiCiAKLSM6IHJlZi1maWx0ZXIuYzo0MzYKKyM6IHJlZi1maWx0ZXIuYzo0MzkKICMsIGMtZm9ybWF0CiBtc2dpZCAicG9zaXRpdmUgd2lkdGggZXhwZWN0ZWQgd2l0aCB0aGUgJSUoYWxpZ24pIGF0b20iCiBtc2dzdHIgImF0dGVzYSBhbXBpZXp6YSBwb3NpdGl2YSBjb24gbCdhdG9tICUlKGFsaWduKSIKIAotIzogcmVmLWZpbHRlci5jOjQ1NAorIzogcmVmLWZpbHRlci5jOjQ1NwogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bnJlY29nbml6ZWQgJSUoaWYpIGFyZ3VtZW50OiAlcyIKIG1zZ3N0ciAiYXJnb21lbnRvICUlKGlmKSBub24gcmljb25vc2NpdXRvOiAlcyIKIAotIzogcmVmLWZpbHRlci5jOjU1NgorIzogcmVmLWZpbHRlci5jOjU1OQogIywgYy1mb3JtYXQKIG1zZ2lkICJtYWxmb3JtZWQgZmllbGQgbmFtZTogJS4qcyIKIG1zZ3N0ciAibm9tZSBjYW1wbyBtYWxmb3JtYXRvOiAlLipzIgogCi0jOiByZWYtZmlsdGVyLmM6NTgzCisjOiByZWYtZmlsdGVyLmM6NTg2CiAjLCBjLWZvcm1hdAogbXNnaWQgInVua25vd24gZmllbGQgbmFtZTogJS4qcyIKIG1zZ3N0ciAibm9tZSBjYW1wbyBzY29ub3NjaXV0bzogJS4qcyIKIAotIzogcmVmLWZpbHRlci5jOjU4NworIzogcmVmLWZpbHRlci5jOjU5MAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAibm90IGEgZ2l0IHJlcG9zaXRvcnksIGJ1dCB0aGUgZmllbGQgJyUuKnMnIHJlcXVpcmVzIGFjY2VzcyB0byBvYmplY3QgZGF0YSIKQEAgLTUyNTIsMTYwICs1Mjg3LDE2MCBAQAogIm5vbiDDqCB1biByZXBvc2l0b3J5IGdpdCwgbWEgaWwgY2FtcG8gJyUuKnMnIHJpY2hpZWRlIGwnYWNjZXNzbyBhaSBkYXRpICIKICJvZ2dldHRvIgogCi0jOiByZWYtZmlsdGVyLmM6NzExCisjOiByZWYtZmlsdGVyLmM6NzE0CiAjLCBjLWZvcm1hdAogbXNnaWQgImZvcm1hdDogJSUoaWYpIGF0b20gdXNlZCB3aXRob3V0IGEgJSUodGhlbikgYXRvbSIKIG1zZ3N0ciAiZm9ybWF0bzogYXRvbW8gJSUoaWYpIHVzYXRvIHNlbnphIHVuIGF0b21vICUlKHRoZW4pIgogCi0jOiByZWYtZmlsdGVyLmM6Nzc0CisjOiByZWYtZmlsdGVyLmM6Nzc3CiAjLCBjLWZvcm1hdAogbXNnaWQgImZvcm1hdDogJSUodGhlbikgYXRvbSB1c2VkIHdpdGhvdXQgYW4gJSUoaWYpIGF0b20iCiBtc2dzdHIgImZvcm1hdG86IGF0b21vICUlKHRoZW4pIHVzYXRvIHNlbnphIHVuIGF0b21vICUlKGlmKSIKIAotIzogcmVmLWZpbHRlci5jOjc3NgorIzogcmVmLWZpbHRlci5jOjc3OQogIywgYy1mb3JtYXQKIG1zZ2lkICJmb3JtYXQ6ICUlKHRoZW4pIGF0b20gdXNlZCBtb3JlIHRoYW4gb25jZSIKIG1zZ3N0ciAiZm9ybWF0bzogYXRvbW8gJSUodGhlbikgdXNhdG8gcGnDuSBkaSB1bmEgdm9sdGEiCiAKLSM6IHJlZi1maWx0ZXIuYzo3NzgKKyM6IHJlZi1maWx0ZXIuYzo3ODEKICMsIGMtZm9ybWF0CiBtc2dpZCAiZm9ybWF0OiAlJSh0aGVuKSBhdG9tIHVzZWQgYWZ0ZXIgJSUoZWxzZSkiCiBtc2dzdHIgImZvcm1hdG86IGF0b21vICUlKHRoZW4pIHVzYXRvIGRvcG8gJSUoZWxzZSkiCiAKLSM6IHJlZi1maWx0ZXIuYzo4MDYKKyM6IHJlZi1maWx0ZXIuYzo4MDkKICMsIGMtZm9ybWF0CiBtc2dpZCAiZm9ybWF0OiAlJShlbHNlKSBhdG9tIHVzZWQgd2l0aG91dCBhbiAlJShpZikgYXRvbSIKIG1zZ3N0ciAiZm9ybWF0bzogYXRvbW8gJSUoZWxzZSkgdXNhdG8gc2VuemEgdW4gYXRvbW8gJSUoaWYpIgogCi0jOiByZWYtZmlsdGVyLmM6ODA4CisjOiByZWYtZmlsdGVyLmM6ODExCiAjLCBjLWZvcm1hdAogbXNnaWQgImZvcm1hdDogJSUoZWxzZSkgYXRvbSB1c2VkIHdpdGhvdXQgYSAlJSh0aGVuKSBhdG9tIgogbXNnc3RyICJmb3JtYXRvOiBhdG9tbyAlJShlbHNlKSB1c2F0byBzZW56YSB1biBhdG9tbyAlJSh0aGVuKSIKIAotIzogcmVmLWZpbHRlci5jOjgxMAorIzogcmVmLWZpbHRlci5jOjgxMwogIywgYy1mb3JtYXQKIG1zZ2lkICJmb3JtYXQ6ICUlKGVsc2UpIGF0b20gdXNlZCBtb3JlIHRoYW4gb25jZSIKIG1zZ3N0ciAiZm9ybWF0bzogYXRvbW8gJSUoZWxzZSkgdXNhdG8gcGnDuSBkaSB1bmEgdm9sdGEiCiAKLSM6IHJlZi1maWx0ZXIuYzo4MjUKKyM6IHJlZi1maWx0ZXIuYzo4MjgKICMsIGMtZm9ybWF0CiBtc2dpZCAiZm9ybWF0OiAlJShlbmQpIGF0b20gdXNlZCB3aXRob3V0IGNvcnJlc3BvbmRpbmcgYXRvbSIKIG1zZ3N0ciAiZm9ybWF0bzogYXRvbW8gJSUoZW5kKSB1c2F0byBzZW56YSBsJ2F0b21vIGNvcnJpc3BvbmRlbnRlIgogCi0jOiByZWYtZmlsdGVyLmM6ODgyCisjOiByZWYtZmlsdGVyLmM6ODg1CiAjLCBjLWZvcm1hdAogbXNnaWQgIm1hbGZvcm1lZCBmb3JtYXQgc3RyaW5nICVzIgogbXNnc3RyICJzdHJpbmdhIGRpIGZvcm1hdG8gJXMgbWFsZm9ybWF0YSIKIAotIzogcmVmLWZpbHRlci5jOjE0ODUKKyM6IHJlZi1maWx0ZXIuYzoxNDg4CiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vIGJyYW5jaCwgcmViYXNpbmcgJXMiCiBtc2dzdHIgIm5lc3N1biBicmFuY2gsIGVzZWd1byBpbCByZWJhc2UgZGkgJXMiCiAKLSM6IHJlZi1maWx0ZXIuYzoxNDg4CisjOiByZWYtZmlsdGVyLmM6MTQ5MQogIywgYy1mb3JtYXQKIG1zZ2lkICJubyBicmFuY2gsIHJlYmFzaW5nIGRldGFjaGVkIEhFQUQgJXMiCiBtc2dzdHIgIm5lc3N1biBicmFuY2gsIGVzZWd1byBpbCByZWJhc2UgZGVsbCdIRUFEIHNjb2xsZWdhdG8gJXMiCiAKLSM6IHJlZi1maWx0ZXIuYzoxNDkxCisjOiByZWYtZmlsdGVyLmM6MTQ5NAogIywgYy1mb3JtYXQKIG1zZ2lkICJubyBicmFuY2gsIGJpc2VjdCBzdGFydGVkIG9uICVzIgogbXNnc3RyICJuZXNzdW4gYnJhbmNoLCBiaXNlemlvbmUgYXZ2aWF0YSBzdSAlcyIKIAotIzogcmVmLWZpbHRlci5jOjE1MDEKKyM6IHJlZi1maWx0ZXIuYzoxNTA0CiBtc2dpZCAibm8gYnJhbmNoIgogbXNnc3RyICJuZXNzdW4gYnJhbmNoIgogCi0jOiByZWYtZmlsdGVyLmM6MTUzNyByZWYtZmlsdGVyLmM6MTc0MworIzogcmVmLWZpbHRlci5jOjE1NDAgcmVmLWZpbHRlci5jOjE3NDkKICMsIGMtZm9ybWF0CiBtc2dpZCAibWlzc2luZyBvYmplY3QgJXMgZm9yICVzIgogbXNnc3RyICJvZ2dldHRvICVzIG1hbmNhbnRlIHBlciAlcyIKIAotIzogcmVmLWZpbHRlci5jOjE1NDcKKyM6IHJlZi1maWx0ZXIuYzoxNTUwCiAjLCBjLWZvcm1hdAogbXNnaWQgInBhcnNlX29iamVjdF9idWZmZXIgZmFpbGVkIG9uICVzIGZvciAlcyIKIG1zZ3N0ciAicGFyc2Vfb2JqZWN0X2J1ZmZlciBub24gcml1c2NpdG8gc3UgJXMgcGVyICVzIgogCi0jOiByZWYtZmlsdGVyLmM6MTk5OAorIzogcmVmLWZpbHRlci5jOjIwMDQKICMsIGMtZm9ybWF0CiBtc2dpZCAibWFsZm9ybWVkIG9iamVjdCBhdCAnJXMnIgogbXNnc3RyICJvZ2dldHRvIG1hbGZvcm1hdG8gaW4gJyVzJyIKIAotIzogcmVmLWZpbHRlci5jOjIwODcKKyM6IHJlZi1maWx0ZXIuYzoyMDkzCiAjLCBjLWZvcm1hdAogbXNnaWQgImlnbm9yaW5nIHJlZiB3aXRoIGJyb2tlbiBuYW1lICVzIgogbXNnc3RyICJpZ25vcm8gaWwgcmlmZXJpbWVudG8gY29uIGlsIG5vbWUgbWFsZm9ybWF0byAlcyIKIAotIzogcmVmLWZpbHRlci5jOjIzODIKKyM6IHJlZi1maWx0ZXIuYzoyMzg5CiAjLCBjLWZvcm1hdAogbXNnaWQgImZvcm1hdDogJSUoZW5kKSBhdG9tIG1pc3NpbmciCiBtc2dzdHIgImZvcm1hdG86IGF0b21vICUlKGVuZCkgbWFuY2FudGUiCiAKLSM6IHJlZi1maWx0ZXIuYzoyNDgyCisjOiByZWYtZmlsdGVyLmM6MjQ4OQogIywgYy1mb3JtYXQKIG1zZ2lkICJvcHRpb24gYCVzJyBpcyBpbmNvbXBhdGlibGUgd2l0aCAtLW1lcmdlZCIKIG1zZ3N0ciAibCdvcHppb25lIGAlcycgbm9uIMOoIGNvbXBhdGliaWxlIGNvbiAtLW1lcmdlZCIKIAotIzogcmVmLWZpbHRlci5jOjI0ODUKKyM6IHJlZi1maWx0ZXIuYzoyNDkyCiAjLCBjLWZvcm1hdAogbXNnaWQgIm9wdGlvbiBgJXMnIGlzIGluY29tcGF0aWJsZSB3aXRoIC0tbm8tbWVyZ2VkIgogbXNnc3RyICJsJ29wemlvbmUgYCVzJyBub24gw6ggY29tcGF0aWJpbGUgY29uIC0tbm8tbWVyZ2VkIgogCi0jOiByZWYtZmlsdGVyLmM6MjQ5NQorIzogcmVmLWZpbHRlci5jOjI1MDIKICMsIGMtZm9ybWF0CiBtc2dpZCAibWFsZm9ybWVkIG9iamVjdCBuYW1lICVzIgogbXNnc3RyICJub21lIGRlbGwnb2dnZXR0byAlcyBtYWxmb3JtYXRvIgogCi0jOiByZWYtZmlsdGVyLmM6MjUwMAorIzogcmVmLWZpbHRlci5jOjI1MDcKICMsIGMtZm9ybWF0CiBtc2dpZCAib3B0aW9uIGAlcycgbXVzdCBwb2ludCB0byBhIGNvbW1pdCIKIG1zZ3N0ciAibCdvcHppb25lIGAlcycgZGV2ZSBwdW50YXJlIGFkIHVuIGNvbW1pdCIKIAotIzogcmVtb3RlLmM6MzYzCisjOiByZW1vdGUuYzozNjYKICMsIGMtZm9ybWF0CiBtc2dpZCAiY29uZmlnIHJlbW90ZSBzaG9ydGhhbmQgY2Fubm90IGJlZ2luIHdpdGggJy8nOiAlcyIKIG1zZ3N0ciAiIgogImxhIGZvcm1hIGJyZXZlIGRlbGxhIGNvbmZpZ3VyYXppb25lIGRlbCByZW1vdG8gbm9uIHB1w7IgaW5pemlhcmUgY29uICcvJzogJXMiCiAKLSM6IHJlbW90ZS5jOjQxMAorIzogcmVtb3RlLmM6NDEzCiBtc2dpZCAibW9yZSB0aGFuIG9uZSByZWNlaXZlcGFjayBnaXZlbiwgdXNpbmcgdGhlIGZpcnN0IgogbXNnc3RyICLDqCBzdGF0YSBzcGVjaWZpY2F0YSBwacO5IGRpIHVuYSBkaXJldHRpdmEgcmVjZWl2ZXBhY2ssIHVzbyBsYSBwcmltYSIKIAotIzogcmVtb3RlLmM6NDE4CisjOiByZW1vdGUuYzo0MjEKIG1zZ2lkICJtb3JlIHRoYW4gb25lIHVwbG9hZHBhY2sgZ2l2ZW4sIHVzaW5nIHRoZSBmaXJzdCIKIG1zZ3N0ciAiw6ggc3RhdGEgc3BlY2lmaWNhdGEgcGnDuSBkaSB1bmEgZGlyZXR0aXZhIHVwbG9hZHBhY2ssIHVzbyBsYSBwcmltYSIKIAotIzogcmVtb3RlLmM6NjA4CisjOiByZW1vdGUuYzo2MTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ2Fubm90IGZldGNoIGJvdGggJXMgYW5kICVzIHRvICVzIgogbXNnc3RyICJJbXBvc3NpYmlsZSByZWN1cGVyYXJlIHNpYSAlcyBzaWEgJXMgaW4gJXMiCiAKLSM6IHJlbW90ZS5jOjYxMgorIzogcmVtb3RlLmM6NjE1CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIHVzdWFsbHkgdHJhY2tzICVzLCBub3QgJXMiCiBtc2dzdHIgIiVzIHNvbGl0YW1lbnRlIHRyYWNjaWEgJXMsIG5vbiAlcyIKIAotIzogcmVtb3RlLmM6NjE2CisjOiByZW1vdGUuYzo2MTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgdHJhY2tzIGJvdGggJXMgYW5kICVzIgogbXNnc3RyICIlcyB0cmFjY2lhIHNpYSAlcyBzaWEgJXMiCiAKLSM6IHJlbW90ZS5jOjY4NAorIzogcmVtb3RlLmM6Njg3CiAjLCBjLWZvcm1hdAogbXNnaWQgImtleSAnJXMnIG9mIHBhdHRlcm4gaGFkIG5vICcqJyIKIG1zZ3N0ciAibGEgY2hpYXZlICclcycgZGVsIHBhdHRlcm4gbm9uIGF2ZXZhIHVuICcqJyIKIAotIzogcmVtb3RlLmM6Njk0CisjOiByZW1vdGUuYzo2OTcKICMsIGMtZm9ybWF0CiBtc2dpZCAidmFsdWUgJyVzJyBvZiBwYXR0ZXJuIGhhcyBubyAnKiciCiBtc2dzdHIgImlsIHZhbG9yZSAnJXMnIGRlbCBwYXR0ZXJuIG5vbiBoYSB1biAnKiciCiAKLSM6IHJlbW90ZS5jOjEwMDAKKyM6IHJlbW90ZS5jOjEwMDMKICMsIGMtZm9ybWF0CiBtc2dpZCAic3JjIHJlZnNwZWMgJXMgZG9lcyBub3QgbWF0Y2ggYW55IgogbXNnc3RyICJuZXNzdW5hIGNvcnJpc3BvbmRlbnphIHBlciBsbyBzcGVjaWZpY2F0b3JlIHJpZmVyaW1lbnRvIHNvcmdlbnRlICVzIgogCi0jOiByZW1vdGUuYzoxMDA1CisjOiByZW1vdGUuYzoxMDA4CiAjLCBjLWZvcm1hdAogbXNnaWQgInNyYyByZWZzcGVjICVzIG1hdGNoZXMgbW9yZSB0aGFuIG9uZSIKIG1zZ3N0ciAiIgpAQCAtNTQxNiw3ICs1NDUxLDcgQEAKICMuIDxyZW1vdGU+IDxzcmM+Ojxkc3Q+IiBwdXNoLCBhbmQgImJlaW5nIHB1c2hlZCAoJyVzJykiIGlzCiAjLiB0aGUgPHNyYz4uCiAjLgotIzogcmVtb3RlLmM6MTAyMAorIzogcmVtb3RlLmM6MTAyMwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiVGhlIGRlc3RpbmF0aW9uIHlvdSBwcm92aWRlZCBpcyBub3QgYSBmdWxsIHJlZm5hbWUgKGkuZS4sXG4iCkBAIC01NDQyLDcgKzU0NzcsNyBAQAogIk5lc3N1bmEgZGVsbGUgZHVlIG9wemlvbmkgaGEgZnVuemlvbmF0bywgcXVpbmRpIGNpIHNpYW1vIGFycmVzaS5cbiIKICJEZXZpIHNwZWNpZmljYXJlIHVuIHJpZmVyaW1lbnRvIGNvbXBsZXRhbWVudGUgcXVhbGlmaWNhdG8uIgogCi0jOiByZW1vdGUuYzoxMDQwCisjOiByZW1vdGUuYzoxMDQzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgPHNyYz4gcGFydCBvZiB0aGUgcmVmc3BlYyBpcyBhIGNvbW1pdCBvYmplY3QuXG4iCkBAIC01NDUzLDcgKzU0ODgsNyBAQAogIsOoIHVuIG9nZ2V0dG8gdGFnLiBGb3JzZSBpbnRlbmRldmkgY3JlYXJlIHVuIG51b3ZvXG4iCiAiYnJhbmNoIGVzZWd1ZW5kbyBpbCBwdXNoIGEgJyVzOnJlZnMvaGVhZHMvJXMnPyIKIAotIzogcmVtb3RlLmM6MTA0NQorIzogcmVtb3RlLmM6MTA0OAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiVGhlIDxzcmM+IHBhcnQgb2YgdGhlIHJlZnNwZWMgaXMgYSB0YWcgb2JqZWN0LlxuIgpAQCAtNTQ2NCw3ICs1NDk5LDcgQEAKICLDqCB1biBvZ2dldHRvIHRhZy4gRm9yc2UgaW50ZW5kZXZpIGNyZWFyZSB1biBudW92b1xuIgogImJyYW5jaCBlc2VndWVuZG8gaWwgcHVzaCBhICclczpyZWZzL3RhZ3MvJXMnPyIKIAotIzogcmVtb3RlLmM6MTA1MAorIzogcmVtb3RlLmM6MTA1MwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiVGhlIDxzcmM+IHBhcnQgb2YgdGhlIHJlZnNwZWMgaXMgYSB0cmVlIG9iamVjdC5cbiIKQEAgLTU0NzYsNyArNTUxMSw3IEBACiAidGFnIGEgdW4gbnVvdm8gYWxiZXJvIGVzZWd1ZW5kbyBpbCBwdXNoIGFcbiIKICInJXM6cmVmcy90YWdzLyVzJz8iCiAKLSM6IHJlbW90ZS5jOjEwNTUKKyM6IHJlbW90ZS5jOjEwNTgKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlRoZSA8c3JjPiBwYXJ0IG9mIHRoZSByZWZzcGVjIGlzIGEgYmxvYiBvYmplY3QuXG4iCkBAIC01NDg4LDEyMSArNTUyMywxMjEgQEAKICJ0YWcgYSB1biBudW92byBibG9iIGVzZWd1ZW5kbyBpbCBwdXNoIGFcbiIKICInJXM6cmVmcy90YWdzLyVzJz8iCiAKLSM6IHJlbW90ZS5jOjEwOTEKKyM6IHJlbW90ZS5jOjEwOTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgY2Fubm90IGJlIHJlc29sdmVkIHRvIGJyYW5jaCIKIG1zZ3N0ciAiJXMgbm9uIHB1w7IgZXNzZXJlIHJpc29sdG8gaW4gdW4gYnJhbmNoIgogCi0jOiByZW1vdGUuYzoxMTAyCisjOiByZW1vdGUuYzoxMTA1CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBkZWxldGUgJyVzJzogcmVtb3RlIHJlZiBkb2VzIG5vdCBleGlzdCIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgZWxpbWluYXJlICclcyc6IGlsIHJpZmVyaW1lbnRvIHJlbW90byBub24gZXNpc3RlIgogCi0jOiByZW1vdGUuYzoxMTE0CisjOiByZW1vdGUuYzoxMTE3CiAjLCBjLWZvcm1hdAogbXNnaWQgImRzdCByZWZzcGVjICVzIG1hdGNoZXMgbW9yZSB0aGFuIG9uZSIKIG1zZ3N0ciAiIgogInNvbm8gc3RhdGUgdHJvdmF0ZSBwacO5IGNvcnJpc3BvbmRlbnplIHBlciBsbyBzcGVjaWZpY2F0b3JlIHJpZmVyaW1lbnRvICIKICJkZXN0aW5hemlvbmUgJXMiCiAKLSM6IHJlbW90ZS5jOjExMjEKKyM6IHJlbW90ZS5jOjExMjQKICMsIGMtZm9ybWF0CiBtc2dpZCAiZHN0IHJlZiAlcyByZWNlaXZlcyBmcm9tIG1vcmUgdGhhbiBvbmUgc3JjIgogbXNnc3RyICIiCiAibG8gc3BlY2lmaWNhdG9yZSByaWZlcmltZW50byBkZXN0aW5hemlvbmUgJXMgcmljZXZlIGRhdGkgZGEgcGnDuSBkaSB1bmEgIgogInNvcmdlbnRlIgogCi0jOiByZW1vdGUuYzoxNjI0IHJlbW90ZS5jOjE3MjUKKyM6IHJlbW90ZS5jOjE2MjcgcmVtb3RlLmM6MTcyOAogbXNnaWQgIkhFQUQgZG9lcyBub3QgcG9pbnQgdG8gYSBicmFuY2giCiBtc2dzdHIgIkhFQUQgbm9uIHB1bnRhIGFkIHVuIGJyYW5jaCIKIAotIzogcmVtb3RlLmM6MTYzMworIzogcmVtb3RlLmM6MTYzNgogIywgYy1mb3JtYXQKIG1zZ2lkICJubyBzdWNoIGJyYW5jaDogJyVzJyIKIG1zZ3N0ciAiYnJhbmNoICclcycgbm9uIGVzaXN0ZW50ZSIKIAotIzogcmVtb3RlLmM6MTYzNgorIzogcmVtb3RlLmM6MTYzOQogIywgYy1mb3JtYXQKIG1zZ2lkICJubyB1cHN0cmVhbSBjb25maWd1cmVkIGZvciBicmFuY2ggJyVzJyIKIG1zZ3N0ciAibmVzc3VuIHVwc3RyZWFtIGNvbmZpZ3VyYXRvIHBlciBpbCBicmFuY2ggJyVzJyIKIAotIzogcmVtb3RlLmM6MTY0MgorIzogcmVtb3RlLmM6MTY0NQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1cHN0cmVhbSBicmFuY2ggJyVzJyBub3Qgc3RvcmVkIGFzIGEgcmVtb3RlLXRyYWNraW5nIGJyYW5jaCIKIG1zZ3N0ciAiIgogImJyYW5jaCB1cHN0cmVhbSAnJXMnIG5vbiBtZW1vcml6emF0byBjb21lIGJyYW5jaCBjaGUgbmUgdHJhY2NpYSB1bm8gcmVtb3RvIgogCi0jOiByZW1vdGUuYzoxNjU3CisjOiByZW1vdGUuYzoxNjYwCiAjLCBjLWZvcm1hdAogbXNnaWQgInB1c2ggZGVzdGluYXRpb24gJyVzJyBvbiByZW1vdGUgJyVzJyBoYXMgbm8gbG9jYWwgdHJhY2tpbmcgYnJhbmNoIgogbXNnc3RyICIiCiAibGEgZGVzdGluYXppb25lIGRlbCBwdXNoICclcycgc3VsIHJlbW90byAnJXMnIG5vbiBoYSB1biBicmFuY2ggbG9jYWxlIGNoZSBsYSAiCiAidHJhY2NpYSIKIAotIzogcmVtb3RlLmM6MTY2OQorIzogcmVtb3RlLmM6MTY3MgogIywgYy1mb3JtYXQKIG1zZ2lkICJicmFuY2ggJyVzJyBoYXMgbm8gcmVtb3RlIGZvciBwdXNoaW5nIgogbXNnc3RyICJpbCBicmFuY2ggJyVzJyBub24gaGEgdW4gcmVtb3RvIHBlciBpbCBwdXNoIgogCi0jOiByZW1vdGUuYzoxNjc5CisjOiByZW1vdGUuYzoxNjgyCiAjLCBjLWZvcm1hdAogbXNnaWQgInB1c2ggcmVmc3BlY3MgZm9yICclcycgZG8gbm90IGluY2x1ZGUgJyVzJyIKIG1zZ3N0ciAiZ2xpIHNwZWNpZmljYXRvcmkgcmlmZXJpbWVudG8gcGVyICclcycgbm9uIGluY2x1ZG9ubyAnJXMnIgogCi0jOiByZW1vdGUuYzoxNjkyCisjOiByZW1vdGUuYzoxNjk1CiBtc2dpZCAicHVzaCBoYXMgbm8gZGVzdGluYXRpb24gKHB1c2guZGVmYXVsdCBpcyAnbm90aGluZycpIgogbXNnc3RyICJpbCBwdXNoIG5vbiBoYSB1bmEgZGVzdGluYXppb25lIChwdXNoLmRlZmF1bHQgw6ggJ25vdGhpbmcnKSIKIAotIzogcmVtb3RlLmM6MTcxNAorIzogcmVtb3RlLmM6MTcxNwogbXNnaWQgImNhbm5vdCByZXNvbHZlICdzaW1wbGUnIHB1c2ggdG8gYSBzaW5nbGUgZGVzdGluYXRpb24iCiBtc2dzdHIgImltcG9zc2liaWxlIHJpc29sdmVyZSBpbCBwdXNoICdzaW1wbGUnIGEgdW5hIHNpbmdvbGEgZGVzdGluYXppb25lIgogCi0jOiByZW1vdGUuYzoxODQwCisjOiByZW1vdGUuYzoxODQzCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkbid0IGZpbmQgcmVtb3RlIHJlZiAlcyIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgdHJvdmFyZSBpbCByaWZlcmltZW50byByZW1vdG8gJXMiCiAKLSM6IHJlbW90ZS5jOjE4NTMKKyM6IHJlbW90ZS5jOjE4NTYKICMsIGMtZm9ybWF0CiBtc2dpZCAiKiBJZ25vcmluZyBmdW5ueSByZWYgJyVzJyBsb2NhbGx5IgogbXNnc3RyICIqIElnbm9ybyBsb2NhbG1lbnRlIGlsIHJpZmVyaW1lbnRvIHN0cmFubyAnJXMnIgogCi0jOiByZW1vdGUuYzoyMDE2CisjOiByZW1vdGUuYzoyMDE5CiAjLCBjLWZvcm1hdAogbXNnaWQgIllvdXIgYnJhbmNoIGlzIGJhc2VkIG9uICclcycsIGJ1dCB0aGUgdXBzdHJlYW0gaXMgZ29uZS5cbiIKIG1zZ3N0ciAiSWwgdHVvIGJyYW5jaCDDqCBiYXNhdG8gc3UgJyVzJywgbWEgbCd1cHN0cmVhbSDDqCBzY29tcGFyc28uXG4iCiAKLSM6IHJlbW90ZS5jOjIwMjAKKyM6IHJlbW90ZS5jOjIwMjMKIG1zZ2lkICIgICh1c2UgXCJnaXQgYnJhbmNoIC0tdW5zZXQtdXBzdHJlYW1cIiB0byBmaXh1cClcbiIKIG1zZ3N0ciAiICAodXNhIFwiZ2l0IGJyYW5jaCAtLXVuc2V0LXVwc3RyZWFtXCIgcGVyIGNvcnJlZ2dlcmUgbGEgc2l0dWF6aW9uZSlcbiIKIAotIzogcmVtb3RlLmM6MjAyMworIzogcmVtb3RlLmM6MjAyNgogIywgYy1mb3JtYXQKIG1zZ2lkICJZb3VyIGJyYW5jaCBpcyB1cCB0byBkYXRlIHdpdGggJyVzJy5cbiIKIG1zZ3N0ciAiSWwgdHVvIGJyYW5jaCDDqCBhZ2dpb3JuYXRvIHJpc3BldHRvIGEgJyVzJy5cbiIKIAotIzogcmVtb3RlLmM6MjAyNworIzogcmVtb3RlLmM6MjAzMAogIywgYy1mb3JtYXQKIG1zZ2lkICJZb3VyIGJyYW5jaCBhbmQgJyVzJyByZWZlciB0byBkaWZmZXJlbnQgY29tbWl0cy5cbiIKIG1zZ3N0ciAiSWwgdHVvIGJyYW5jaCBlICclcycgZmFubm8gcmlmZXJpbWVudG8gYSBjb21taXQgZGlmZmVyZW50aS5cbiIKIAotIzogcmVtb3RlLmM6MjAzMAorIzogcmVtb3RlLmM6MjAzMwogIywgYy1mb3JtYXQKIG1zZ2lkICIgICh1c2UgXCIlc1wiIGZvciBkZXRhaWxzKVxuIgogbXNnc3RyICIgICh1c2EgXCIlc1wiIHBlciB2aXN1YWxpenphcmUgaSBkZXR0YWdsaSlcbiIKIAotIzogcmVtb3RlLmM6MjAzNAorIzogcmVtb3RlLmM6MjAzNwogIywgYy1mb3JtYXQKIG1zZ2lkICJZb3VyIGJyYW5jaCBpcyBhaGVhZCBvZiAnJXMnIGJ5ICVkIGNvbW1pdC5cbiIKIG1zZ2lkX3BsdXJhbCAiWW91ciBicmFuY2ggaXMgYWhlYWQgb2YgJyVzJyBieSAlZCBjb21taXRzLlxuIgogbXNnc3RyWzBdICJJbCB0dW8gYnJhbmNoIMOoIGF2YW50aSByaXNwZXR0byBhICclcycgZGkgJWQgY29tbWl0LlxuIgogbXNnc3RyWzFdICJJbCB0dW8gYnJhbmNoIMOoIGF2YW50aSByaXNwZXR0byBhICclcycgZGkgJWQgY29tbWl0LlxuIgogCi0jOiByZW1vdGUuYzoyMDQwCisjOiByZW1vdGUuYzoyMDQzCiBtc2dpZCAiICAodXNlIFwiZ2l0IHB1c2hcIiB0byBwdWJsaXNoIHlvdXIgbG9jYWwgY29tbWl0cylcbiIKIG1zZ3N0ciAiICAodXNhIFwiZ2l0IHB1c2hcIiBwZXIgcHViYmxpY2FyZSBpIHR1b2kgY29tbWl0IGxvY2FsaSlcbiIKIAotIzogcmVtb3RlLmM6MjA0MworIzogcmVtb3RlLmM6MjA0NgogIywgYy1mb3JtYXQKIG1zZ2lkICJZb3VyIGJyYW5jaCBpcyBiZWhpbmQgJyVzJyBieSAlZCBjb21taXQsIGFuZCBjYW4gYmUgZmFzdC1mb3J3YXJkZWQuXG4iCiBtc2dpZF9wbHVyYWwgIiIKQEAgLTU2MTQsMTEgKzU2NDksMTEgQEAKICJJbCB0dW8gYnJhbmNoLCByaXNwZXR0byBhICclcycsIMOoIGluZGlldHJvIGRpICVkIGNvbW1pdCBlIG5lIHBvc3NvIGVzZWd1aXJlICIKICJpbCBmYXN0IGZvcndhcmQuXG4iCiAKLSM6IHJlbW90ZS5jOjIwNTEKKyM6IHJlbW90ZS5jOjIwNTQKIG1zZ2lkICIgICh1c2UgXCJnaXQgcHVsbFwiIHRvIHVwZGF0ZSB5b3VyIGxvY2FsIGJyYW5jaClcbiIKIG1zZ3N0ciAiICAodXNhIFwiZ2l0IHB1bGxcIiBwZXIgYWdnaW9ybmFyZSBpbCB0dW8gYnJhbmNoIGxvY2FsZSlcbiIKIAotIzogcmVtb3RlLmM6MjA1NAorIzogcmVtb3RlLmM6MjA1NwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiWW91ciBicmFuY2ggYW5kICclcycgaGF2ZSBkaXZlcmdlZCxcbiIKQEAgLTU2MzMsMTEgKzU2NjgsMTEgQEAKICJJbCB0dW8gYnJhbmNoIGUgJyVzJyBzb25vIGRpdmVudGF0aSBkaXZlcmdlbnRpXG4iCiAiZSBoYW5ubyByaXNwZXR0aXZhbWVudGUgJWQgZSAlZCBjb21taXQgZGlmZmVyZW50aS5cbiIKIAotIzogcmVtb3RlLmM6MjA2NAorIzogcmVtb3RlLmM6MjA2NwogbXNnaWQgIiAgKHVzZSBcImdpdCBwdWxsXCIgdG8gbWVyZ2UgdGhlIHJlbW90ZSBicmFuY2ggaW50byB5b3VycylcbiIKIG1zZ3N0ciAiICAodXNhIFwiZ2l0IHB1bGxcIiBwZXIgZXNlZ3VpcmUgaWwgbWVyZ2UgZGVsIGJyYW5jaCByZW1vdG8gbmVsIHR1bylcbiIKIAotIzogcmVtb3RlLmM6MjI0NworIzogcmVtb3RlLmM6MjI1MAogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgcGFyc2UgZXhwZWN0ZWQgb2JqZWN0IG5hbWUgJyVzJyIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgYW5hbGl6emFyZSBpbCBub21lIG9nZ2V0dG8gYXR0ZXNvICclcyciCkBAIC01NzE1LDcgKzU3NTAsNyBAQAogbXNnaWQgIlJlY29yZGVkIHByZWltYWdlIGZvciAnJXMnIgogbXNnc3RyICJTYWx2YXRhIHByZWltbWFnaW5lIGRpICclcyciCiAKLSM6IHJlcmVyZS5jOjg4MSBzdWJtb2R1bGUuYzoyMDIzIGJ1aWx0aW4vbG9nLmM6MTc3MworIzogcmVyZXJlLmM6ODgxIHN1Ym1vZHVsZS5jOjIwMjMgYnVpbHRpbi9sb2cuYzoxNzkwCiAjOiBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6MTQxOCBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6MTQyOAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgY3JlYXRlIGRpcmVjdG9yeSAnJXMnIgpAQCAtNTc1MCwyMCArNTc4NSwyMCBAQAogbXNnaWQgInVuYWJsZSB0byBvcGVuIHJyLWNhY2hlIGRpcmVjdG9yeSIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgYXByaXJlIGxhIGRpcmVjdG9yeSBjYWNoZSByciIKIAotIzogcmV2aXNpb24uYzoyNTA3CisjOiByZXZpc2lvbi5jOjI1MDkKIG1zZ2lkICJ5b3VyIGN1cnJlbnQgYnJhbmNoIGFwcGVhcnMgdG8gYmUgYnJva2VuIgogbXNnc3RyICJzZW1icmEgY2hlIGlsIHR1byBicmFuY2ggY29ycmVudGUgc2lhIHJvdHRvIgogCi0jOiByZXZpc2lvbi5jOjI1MTAKKyM6IHJldmlzaW9uLmM6MjUxMgogIywgYy1mb3JtYXQKIG1zZ2lkICJ5b3VyIGN1cnJlbnQgYnJhbmNoICclcycgZG9lcyBub3QgaGF2ZSBhbnkgY29tbWl0cyB5ZXQiCiBtc2dzdHIgImlsIHR1byBicmFuY2ggY29ycmVudGUgJyVzJyBub24gaGEgYW5jb3JhIGNvbW1pdCIKIAotIzogcmV2aXNpb24uYzoyNzEwCisjOiByZXZpc2lvbi5jOjI3MjAKIG1zZ2lkICItLWZpcnN0LXBhcmVudCBpcyBpbmNvbXBhdGlibGUgd2l0aCAtLWJpc2VjdCIKIG1zZ3N0ciAiLS1maXJzdC1wYXJlbnQgbm9uIMOoIGNvbXBhdGliaWxlIGNvbiAtLWJpc2VjdCIKIAotIzogcmV2aXNpb24uYzoyNzE0CisjOiByZXZpc2lvbi5jOjI3MjQKIG1zZ2lkICItTCBkb2VzIG5vdCB5ZXQgc3VwcG9ydCBkaWZmIGZvcm1hdHMgYmVzaWRlcyAtcCBhbmQgLXMiCiBtc2dzdHIgIi1MIG5vbiBzdXBwb3J0YSBhbmNvcmEgZm9ybWF0aSBkaWZmIG9sdHJlIGEgLXAgZSAtcyIKIApAQCAtNTc4NSwzMSArNTgyMCwzMSBAQAogIkwnaG9vayAnJXMnIMOoIHN0YXRvIGlnbm9yYXRvIHBlcmNow6kgbm9uIMOoIGltcG9zdGF0byBjb21lIGVzZWd1aWJpbGUuXG4iCiAiUHVvaSBkaXNhYmlsaXRhcmUgcXVlc3QnYXZ2aXNvIGNvbiBgZ2l0IGNvbmZpZyBhZHZpY2UuaWdub3JlZEhvb2sgZmFsc2VgLiIKIAotIzogc2VuZC1wYWNrLmM6MTQxCisjOiBzZW5kLXBhY2suYzoxNDIKIG1zZ2lkICJ1bmV4cGVjdGVkIGZsdXNoIHBhY2tldCB3aGlsZSByZWFkaW5nIHJlbW90ZSB1bnBhY2sgc3RhdHVzIgogbXNnc3RyICIiCiAicGFjY2hldHRvIGZsdXNoIGluYXR0ZXNvIGR1cmFudGUgbGEgbGV0dHVyYSBkZWxsbyBzdGF0byBkZWNvbXByZXNzaW9uZSBkZWwgIgogInJlbW90byIKIAotIzogc2VuZC1wYWNrLmM6MTQzCisjOiBzZW5kLXBhY2suYzoxNDQKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHBhcnNlIHJlbW90ZSB1bnBhY2sgc3RhdHVzOiAlcyIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgYW5hbGl6emFyZSBsbyBzdGF0byBkZWNvbXByZXNzaW9uZSBkZWwgcmVtb3RvOiAlcyIKIAotIzogc2VuZC1wYWNrLmM6MTQ1CisjOiBzZW5kLXBhY2suYzoxNDYKICMsIGMtZm9ybWF0CiBtc2dpZCAicmVtb3RlIHVucGFjayBmYWlsZWQ6ICVzIgogbXNnc3RyICJkZWNvbXByZXNzaW9uZSBzdWwgcmVtb3RvIG5vbiByaXVzY2l0YTogJXMiCiAKLSM6IHNlbmQtcGFjay5jOjMwNgorIzogc2VuZC1wYWNrLmM6MzA3CiBtc2dpZCAiZmFpbGVkIHRvIHNpZ24gdGhlIHB1c2ggY2VydGlmaWNhdGUiCiBtc2dzdHIgImZpcm1hIGRlbCBjZXJ0aWZpY2F0byBwZXIgaWwgcHVzaCBub24gcml1c2NpdGEiCiAKLSM6IHNlbmQtcGFjay5jOjQyMAorIzogc2VuZC1wYWNrLmM6NDIxCiBtc2dpZCAidGhlIHJlY2VpdmluZyBlbmQgZG9lcyBub3Qgc3VwcG9ydCAtLXNpZ25lZCBwdXNoIgogbXNnc3RyICJpbCByaWNldmVudGUgbm9uIHN1cHBvcnRhIGkgcHVzaCAtLXNpZ25lZCIKIAotIzogc2VuZC1wYWNrLmM6NDIyCisjOiBzZW5kLXBhY2suYzo0MjMKIG1zZ2lkICIiCiAibm90IHNlbmRpbmcgYSBwdXNoIGNlcnRpZmljYXRlIHNpbmNlIHRoZSByZWNlaXZpbmcgZW5kIGRvZXMgbm90IHN1cHBvcnQgLS0iCiAic2lnbmVkIHB1c2giCkBAIC01ODE3LDExICs1ODUyLDExIEBACiAibm9uIGludmlvIHVuIGNlcnRpZmljYXRvIHB1c2ggcGVyY2jDqSBpbCByaWNldmVudGUgbm9uIHN1cHBvcnRhIGkgcHVzaCAtLSIKICJzaWduZWQiCiAKLSM6IHNlbmQtcGFjay5jOjQzNAorIzogc2VuZC1wYWNrLmM6NDM1CiBtc2dpZCAidGhlIHJlY2VpdmluZyBlbmQgZG9lcyBub3Qgc3VwcG9ydCAtLWF0b21pYyBwdXNoIgogbXNnc3RyICJpbCByaWNldmVudGUgbm9uIHN1cHBvcnRhIGkgcHVzaCAtLWF0b21pYyIKIAotIzogc2VuZC1wYWNrLmM6NDM5CisjOiBzZW5kLXBhY2suYzo0NDAKIG1zZ2lkICJ0aGUgcmVjZWl2aW5nIGVuZCBkb2VzIG5vdCBzdXBwb3J0IHB1c2ggb3B0aW9ucyIKIG1zZ3N0ciAiaWwgcmljZXZlbnRlIG5vbiBzdXBwb3J0YSBsZSBvcHppb25pIHB1c2giCiAKQEAgLTU4MzUsNyArNTg3MCw3IEBACiBtc2dpZCAiY291bGQgbm90IGRlbGV0ZSAnJXMnIgogbXNnc3RyICJpbXBvc3NpYmlsZSBlbGltaW5hcmUgJyVzJyIKIAotIzogc2VxdWVuY2VyLmM6MzExIGJ1aWx0aW4vcmViYXNlLmM6NzU5IGJ1aWx0aW4vcmViYXNlLmM6MTY0NSBidWlsdGluL3JtLmM6MzY5CisjOiBzZXF1ZW5jZXIuYzozMTEgYnVpbHRpbi9yZWJhc2UuYzo3NjAgYnVpbHRpbi9yZWJhc2UuYzoxNjc2IGJ1aWx0aW4vcm0uYzozNjkKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHJlbW92ZSAnJXMnIgogbXNnc3RyICJpbXBvc3NpYmlsZSByaW11b3ZlcmUgJyVzJyIKQEAgLTU4NzUsNyArNTkxMCw3IEBACiAiY29uICdnaXQgYWRkIDxwYXRoPicgbyAnZ2l0IHJtIDxwYXRoPicgZWQgZXNlZ3VpXG4iCiAiaWwgY29tbWl0IGRlbCByaXN1bHRhdG8gY29uICdnaXQgY29tbWl0JyIKIAotIzogc2VxdWVuY2VyLmM6NDAxIHNlcXVlbmNlci5jOjI5MDkKKyM6IHNlcXVlbmNlci5jOjQwMSBzZXF1ZW5jZXIuYzoyODQ3CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBsb2NrICclcyciCiBtc2dzdHIgImltcG9zc2liaWxlIGJsb2NjYXJlICclcyciCkBAIC01ODg1LDE1ICs1OTIwLDE1IEBACiBtc2dpZCAiY291bGQgbm90IHdyaXRlIGVvbCB0byAnJXMnIgogbXNnc3RyICJpbXBvc3NpYmlsZSBzY3JpdmVyZSBpbCBjYXJhdHRlcmUgZGkgZmluZSByaWdhIGluICclcyciCiAKLSM6IHNlcXVlbmNlci5jOjQxMyBzZXF1ZW5jZXIuYzoyNzE0IHNlcXVlbmNlci5jOjI5MTUgc2VxdWVuY2VyLmM6MjkyOQotIzogc2VxdWVuY2VyLmM6MzE5MgorIzogc2VxdWVuY2VyLmM6NDEzIHNlcXVlbmNlci5jOjI2NTIgc2VxdWVuY2VyLmM6Mjg1MyBzZXF1ZW5jZXIuYzoyODY3CisjOiBzZXF1ZW5jZXIuYzozMTMwCiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBmaW5hbGl6ZSAnJXMnIgogbXNnc3RyICJmaW5hbGl6emF6aW9uZSBkaSAnJXMnIG5vbiByaXVzY2l0YSIKIAotIzogc2VxdWVuY2VyLmM6NDM2IHNlcXVlbmNlci5jOjk4MSBzZXF1ZW5jZXIuYzoxNjU1IHNlcXVlbmNlci5jOjI3MzQKLSM6IHNlcXVlbmNlci5jOjMxNzQgc2VxdWVuY2VyLmM6MzI4MyBidWlsdGluL2FtLmM6MjQ1IGJ1aWx0aW4vY29tbWl0LmM6NzYzCi0jOiBidWlsdGluL21lcmdlLmM6MTExMiBidWlsdGluL3JlYmFzZS5jOjU2NworIzogc2VxdWVuY2VyLmM6NDM2IHNlcXVlbmNlci5jOjE1ODUgc2VxdWVuY2VyLmM6MjY3MiBzZXF1ZW5jZXIuYzozMTEyCisjOiBzZXF1ZW5jZXIuYzozMjIxIGJ1aWx0aW4vYW0uYzoyNDQgYnVpbHRpbi9jb21taXQuYzo3NjMgYnVpbHRpbi9tZXJnZS5jOjExMTcKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NTY4CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCByZWFkICclcyciCiBtc2dzdHIgImltcG9zc2liaWxlIGxlZ2dlcmUgJyVzJyIKQEAgLTU5MjAsNzAgKzU5NTUsNjUgQEAKICMuIFRSQU5TTEFUT1JTOiAlcyB3aWxsIGJlICJyZXZlcnQiLCAiY2hlcnJ5LXBpY2siIG9yCiAjLiAicmViYXNlIC1pIi4KICMuCi0jOiBzZXF1ZW5jZXIuYzo2MzIKKyM6IHNlcXVlbmNlci5jOjYzMQogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogVW5hYmxlIHRvIHdyaXRlIG5ldyBpbmRleCBmaWxlIgogbXNnc3RyICIlczogaW1wb3NzaWJpbGUgc2NyaXZlcmUgaWwgbnVvdm8gZmlsZSBpbmRpY2UiCiAKLSM6IHNlcXVlbmNlci5jOjY0OQorIzogc2VxdWVuY2VyLmM6NjQ4CiBtc2dpZCAidW5hYmxlIHRvIHVwZGF0ZSBjYWNoZSB0cmVlIgogbXNnc3RyICJpbXBvc3NpYmlsZSBhZ2dpb3JuYXJlIGwnYWxiZXJvIGNhY2hlIgogCi0jOiBzZXF1ZW5jZXIuYzo2NjMKKyM6IHNlcXVlbmNlci5jOjY2MgogbXNnaWQgImNvdWxkIG5vdCByZXNvbHZlIEhFQUQgY29tbWl0IgogbXNnc3RyICJpbXBvc3NpYmlsZSByaXNvbHZlcmUgaWwgY29tbWl0IEhFQUQiCiAKLSM6IHNlcXVlbmNlci5jOjc0MworIzogc2VxdWVuY2VyLmM6NzQyCiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vIGtleSBwcmVzZW50IGluICclLipzJyIKIG1zZ3N0ciAibmVzc3VuYSBjaGlhdmUgcHJlc2VudGUgaW4gJyUuKnMnIgogCi0jOiBzZXF1ZW5jZXIuYzo3NTQKKyM6IHNlcXVlbmNlci5jOjc1MwogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gZGVxdW90ZSB2YWx1ZSBvZiAnJXMnIgogbXNnc3RyICJpbXBvc3NpYmlsZSByaW11b3ZlcmUgZ2xpIGFwaWNpIGRhbCB2YWxvcmUgZGkgJyVzJyIKIAotIzogc2VxdWVuY2VyLmM6NzkxIHdyYXBwZXIuYzoyMjcgd3JhcHBlci5jOjM5NyBidWlsdGluL2FtLmM6NzA2Ci0jOiBidWlsdGluL2FtLmM6Nzk4IGJ1aWx0aW4vbWVyZ2UuYzoxMTA5IGJ1aWx0aW4vcmViYXNlLmM6MTA0NQorIzogc2VxdWVuY2VyLmM6NzkwIHdyYXBwZXIuYzoxOTAgd3JhcHBlci5jOjM2MCBidWlsdGluL2FtLmM6NzA1CisjOiBidWlsdGluL2FtLmM6Nzk3IGJ1aWx0aW4vbWVyZ2UuYzoxMTE0IGJ1aWx0aW4vcmViYXNlLmM6MTA0NgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3Qgb3BlbiAnJXMnIGZvciByZWFkaW5nIgogbXNnc3RyICJpbXBvc3NpYmlsZSBhcHJpcmUgJyVzJyBpbiBsZXR0dXJhIgogCi0jOiBzZXF1ZW5jZXIuYzo4MDEKKyM6IHNlcXVlbmNlci5jOjgwMAogbXNnaWQgIidHSVRfQVVUSE9SX05BTUUnIGFscmVhZHkgZ2l2ZW4iCiBtc2dzdHIgIidHSVRfQVVUSE9SX05BTUUnIGdpw6Agc3BlY2lmaWNhdG8iCiAKLSM6IHNlcXVlbmNlci5jOjgwNgorIzogc2VxdWVuY2VyLmM6ODA1CiBtc2dpZCAiJ0dJVF9BVVRIT1JfRU1BSUwnIGFscmVhZHkgZ2l2ZW4iCiBtc2dzdHIgIidHSVRfQVVUSE9SX0VNQUlMJyBnacOgIHNwZWNpZmljYXRvIgogCi0jOiBzZXF1ZW5jZXIuYzo4MTEKKyM6IHNlcXVlbmNlci5jOjgxMAogbXNnaWQgIidHSVRfQVVUSE9SX0RBVEUnIGFscmVhZHkgZ2l2ZW4iCiBtc2dzdHIgIidHSVRfQVVUSE9SX0RBVEUnIGdpw6Agc3BlY2lmaWNhdG8iCiAKLSM6IHNlcXVlbmNlci5jOjgxNQorIzogc2VxdWVuY2VyLmM6ODE0CiAjLCBjLWZvcm1hdAogbXNnaWQgInVua25vd24gdmFyaWFibGUgJyVzJyIKIG1zZ3N0ciAidmFyaWFiaWxlICclcycgc2Nvbm9zY2l1dGEiCiAKLSM6IHNlcXVlbmNlci5jOjgyMAorIzogc2VxdWVuY2VyLmM6ODE5CiBtc2dpZCAibWlzc2luZyAnR0lUX0FVVEhPUl9OQU1FJyIKIG1zZ3N0ciAiJ0dJVF9BVVRIT1JfTkFNRScgbWFuY2FudGUiCiAKLSM6IHNlcXVlbmNlci5jOjgyMgorIzogc2VxdWVuY2VyLmM6ODIxCiBtc2dpZCAibWlzc2luZyAnR0lUX0FVVEhPUl9FTUFJTCciCiBtc2dzdHIgIidHSVRfQVVUSE9SX0VNQUlMJyBtYW5jYW50ZSIKIAotIzogc2VxdWVuY2VyLmM6ODI0CisjOiBzZXF1ZW5jZXIuYzo4MjMKIG1zZ2lkICJtaXNzaW5nICdHSVRfQVVUSE9SX0RBVEUnIgogbXNnc3RyICInR0lUX0FVVEhPUl9EQVRFJyBtYW5jYW50ZSIKIAotIzogc2VxdWVuY2VyLmM6ODg0Ci0jLCBjLWZvcm1hdAotbXNnaWQgImludmFsaWQgZGF0ZSBmb3JtYXQgJyVzJyBpbiAnJXMnIgotbXNnc3RyICJmb3JtYXRvIGRhdGEgJyVzJyBub24gdmFsaWRvIGluICclcyciCi0KLSM6IHNlcXVlbmNlci5jOjkwMQorIzogc2VxdWVuY2VyLmM6ODcyCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJ5b3UgaGF2ZSBzdGFnZWQgY2hhbmdlcyBpbiB5b3VyIHdvcmtpbmcgdHJlZVxuIgpAQCAtNjAxMywxNSArNjA0MywxMSBAQAogIlxuIgogIiAgZ2l0IHJlYmFzZSAtLWNvbnRpbnVlXG4iCiAKLSM6IHNlcXVlbmNlci5jOjk5NQotbXNnaWQgIndyaXRpbmcgcm9vdCBjb21taXQiCi1tc2dzdHIgInNjcml0dHVyYSBjb21taXQgcmFkaWNlIGluIGNvcnNvIgotCi0jOiBzZXF1ZW5jZXIuYzoxMjE2CisjOiBzZXF1ZW5jZXIuYzoxMTQ2CiBtc2dpZCAiJ3ByZXBhcmUtY29tbWl0LW1zZycgaG9vayBmYWlsZWQiCiBtc2dzdHIgImhvb2sgJ3ByZXBhcmUtY29tbWl0LW1zZycgbm9uIHJpdXNjaXRvIgogCi0jOiBzZXF1ZW5jZXIuYzoxMjIzCisjOiBzZXF1ZW5jZXIuYzoxMTUzCiBtc2dpZCAiIgogIllvdXIgbmFtZSBhbmQgZW1haWwgYWRkcmVzcyB3ZXJlIGNvbmZpZ3VyZWQgYXV0b21hdGljYWxseSBiYXNlZFxuIgogIm9uIHlvdXIgdXNlcm5hbWUgYW5kIGhvc3RuYW1lLiBQbGVhc2UgY2hlY2sgdGhhdCB0aGV5IGFyZSBhY2N1cmF0ZS5cbiIKQEAgLTYwNDgsNyArNjA3NCw3IEBACiAiXG4iCiAiICAgIGdpdCBjb21taXQgLS1hbWVuZCAtLXJlc2V0LWF1dGhvclxuIgogCi0jOiBzZXF1ZW5jZXIuYzoxMjM2CisjOiBzZXF1ZW5jZXIuYzoxMTY2CiBtc2dpZCAiIgogIllvdXIgbmFtZSBhbmQgZW1haWwgYWRkcmVzcyB3ZXJlIGNvbmZpZ3VyZWQgYXV0b21hdGljYWxseSBiYXNlZFxuIgogIm9uIHlvdXIgdXNlcm5hbWUgYW5kIGhvc3RuYW1lLiBQbGVhc2UgY2hlY2sgdGhhdCB0aGV5IGFyZSBhY2N1cmF0ZS5cbiIKQEAgLTYwNzQsMzI5ICs2MTAwLDMyOSBAQAogIlxuIgogIiAgICBnaXQgY29tbWl0IC0tYW1lbmQgLS1yZXNldC1hdXRob3JcbiIKIAotIzogc2VxdWVuY2VyLmM6MTI3OAorIzogc2VxdWVuY2VyLmM6MTIwOAogbXNnaWQgImNvdWxkbid0IGxvb2sgdXAgbmV3bHkgY3JlYXRlZCBjb21taXQiCiBtc2dzdHIgImltcG9zc2liaWxlIHRyb3ZhcmUgaWwgY29tbWl0IGFwcGVuYSBjcmVhdG8iCiAKLSM6IHNlcXVlbmNlci5jOjEyODAKKyM6IHNlcXVlbmNlci5jOjEyMTAKIG1zZ2lkICJjb3VsZCBub3QgcGFyc2UgbmV3bHkgY3JlYXRlZCBjb21taXQiCiBtc2dzdHIgImltcG9zc2liaWxlIGFuYWxpenphcmUgaWwgY29tbWl0IGFwcGVuYSBjcmVhdG8iCiAKLSM6IHNlcXVlbmNlci5jOjEzMjYKKyM6IHNlcXVlbmNlci5jOjEyNTYKIG1zZ2lkICJ1bmFibGUgdG8gcmVzb2x2ZSBIRUFEIGFmdGVyIGNyZWF0aW5nIGNvbW1pdCIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgcmlzb2x2ZXJlIEhFQUQgZG9wbyBsYSBjcmVhemlvbmUgZGVsIGNvbW1pdCIKIAotIzogc2VxdWVuY2VyLmM6MTMyOAorIzogc2VxdWVuY2VyLmM6MTI1OAogbXNnaWQgImRldGFjaGVkIEhFQUQiCiBtc2dzdHIgIkhFQUQgc2NvbGxlZ2F0byIKIAotIzogc2VxdWVuY2VyLmM6MTMzMgorIzogc2VxdWVuY2VyLmM6MTI2MgogbXNnaWQgIiAocm9vdC1jb21taXQpIgogbXNnc3RyICIgKGNvbW1pdCByYWRpY2UpIgogCi0jOiBzZXF1ZW5jZXIuYzoxMzUzCisjOiBzZXF1ZW5jZXIuYzoxMjgzCiBtc2dpZCAiY291bGQgbm90IHBhcnNlIEhFQUQiCiBtc2dzdHIgImltcG9zc2liaWxlIGFuYWxpenphcmUgSEVBRCIKIAotIzogc2VxdWVuY2VyLmM6MTM1NQorIzogc2VxdWVuY2VyLmM6MTI4NQogIywgYy1mb3JtYXQKIG1zZ2lkICJIRUFEICVzIGlzIG5vdCBhIGNvbW1pdCEiCiBtc2dzdHIgIkwnSEVBRCAlcyBub24gw6ggdW4gY29tbWl0ISIKIAotIzogc2VxdWVuY2VyLmM6MTM1OSBidWlsdGluL2NvbW1pdC5jOjE1NzEKKyM6IHNlcXVlbmNlci5jOjEyODkgYnVpbHRpbi9jb21taXQuYzoxNTcxCiBtc2dpZCAiY291bGQgbm90IHBhcnNlIEhFQUQgY29tbWl0IgogbXNnc3RyICJpbXBvc3NpYmlsZSBhbmFsaXp6YXJlIGlsIGNvbW1pdCBIRUFEIgogCi0jOiBzZXF1ZW5jZXIuYzoxNDExIHNlcXVlbmNlci5jOjIwMDQKKyM6IHNlcXVlbmNlci5jOjEzNDEgc2VxdWVuY2VyLmM6MTkzMwogbXNnaWQgInVuYWJsZSB0byBwYXJzZSBjb21taXQgYXV0aG9yIgogbXNnc3RyICJpbXBvc3NpYmlsZSBhbmFsaXp6YXJlIGwnYXV0b3JlIGRlbCBjb21taXQiCiAKLSM6IHNlcXVlbmNlci5jOjE0MjEgYnVpbHRpbi9hbS5jOjE1NzMgYnVpbHRpbi9tZXJnZS5jOjY4NAorIzogc2VxdWVuY2VyLmM6MTM1MiBidWlsdGluL2FtLmM6MTU2MSBidWlsdGluL21lcmdlLmM6Njg0CiBtc2dpZCAiZ2l0IHdyaXRlLXRyZWUgZmFpbGVkIHRvIHdyaXRlIGEgdHJlZSIKIG1zZ3N0ciAiZ2l0IHdyaXRlLXRyZWUgbm9uIMOoIHJpdXNjaXRvIGEgc2NyaXZlcmUgdW4gYWxiZXJvIgogCi0jOiBzZXF1ZW5jZXIuYzoxNDM4IHNlcXVlbmNlci5jOjE0OTkKKyM6IHNlcXVlbmNlci5jOjEzNjkgc2VxdWVuY2VyLmM6MTQyOQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gcmVhZCBjb21taXQgbWVzc2FnZSBmcm9tICclcyciCiBtc2dzdHIgImltcG9zc2liaWxlIGxlZ2dlcmUgaWwgbWVzc2FnZ2lvIGRpIGNvbW1pdCBkYSAnJXMnIgogCi0jOiBzZXF1ZW5jZXIuYzoxNDY1IGJ1aWx0aW4vYW0uYzoxNTk1IGJ1aWx0aW4vY29tbWl0LmM6MTY3MCBidWlsdGluL21lcmdlLmM6ODc4Ci0jOiBidWlsdGluL21lcmdlLmM6OTAzCisjOiBzZXF1ZW5jZXIuYzoxMzk2IGJ1aWx0aW4vYW0uYzoxNTgzIGJ1aWx0aW4vY29tbWl0LmM6MTY3MCBidWlsdGluL21lcmdlLmM6ODgzCisjOiBidWlsdGluL21lcmdlLmM6OTA4CiBtc2dpZCAiZmFpbGVkIHRvIHdyaXRlIGNvbW1pdCBvYmplY3QiCiBtc2dzdHIgInNjcml0dHVyYSBkZWxsJ29nZ2V0dG8gZGVsIGNvbW1pdCBub24gcml1c2NpdGEiCiAKLSM6IHNlcXVlbmNlci5jOjE1MjYKKyM6IHNlcXVlbmNlci5jOjE0NTYKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHBhcnNlIGNvbW1pdCAlcyIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgYW5hbGl6emFyZSBpbCBjb21taXQgJXMiCiAKLSM6IHNlcXVlbmNlci5jOjE1MzEKKyM6IHNlcXVlbmNlci5jOjE0NjEKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHBhcnNlIHBhcmVudCBjb21taXQgJXMiCiBtc2dzdHIgImltcG9zc2liaWxlIGFuYWxpenphcmUgaWwgY29tbWl0IGdlbml0b3JlICVzIgogCi0jOiBzZXF1ZW5jZXIuYzoxNjA1IHNlcXVlbmNlci5jOjE3MTUKKyM6IHNlcXVlbmNlci5jOjE1MzUgc2VxdWVuY2VyLmM6MTY0NQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmtub3duIGNvbW1hbmQ6ICVkIgogbXNnc3RyICJjb21hbmRvIHNjb25vc2NpdXRvOiAlZCIKIAotIzogc2VxdWVuY2VyLmM6MTY2MiBzZXF1ZW5jZXIuYzoxNjg3CisjOiBzZXF1ZW5jZXIuYzoxNTkyIHNlcXVlbmNlci5jOjE2MTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiVGhpcyBpcyBhIGNvbWJpbmF0aW9uIG9mICVkIGNvbW1pdHMuIgogbXNnc3RyICJRdWVzdGEgw6ggdW5hIGNvbWJpbmF6aW9uZSBkaSAlZCBjb21taXQuIgogCi0jOiBzZXF1ZW5jZXIuYzoxNjcyCisjOiBzZXF1ZW5jZXIuYzoxNjAyCiBtc2dpZCAibmVlZCBhIEhFQUQgdG8gZml4dXAiCiBtc2dzdHIgIsOoIG5lY2Vzc2FyaWEgdW4nSEVBRCBwZXIgaWwgZml4dXAiCiAKLSM6IHNlcXVlbmNlci5jOjE2NzQgc2VxdWVuY2VyLmM6MzIxOQorIzogc2VxdWVuY2VyLmM6MTYwNCBzZXF1ZW5jZXIuYzozMTU3CiBtc2dpZCAiY291bGQgbm90IHJlYWQgSEVBRCIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgbGVnZ2VyZSBsJ0hFQUQiCiAKLSM6IHNlcXVlbmNlci5jOjE2NzYKKyM6IHNlcXVlbmNlci5jOjE2MDYKIG1zZ2lkICJjb3VsZCBub3QgcmVhZCBIRUFEJ3MgY29tbWl0IG1lc3NhZ2UiCiBtc2dzdHIgImltcG9zc2liaWxlIGxlZ2dlcmUgaWwgbWVzc2FnZ2lvIGRpIGNvbW1pdCBkZWxsJ0hFQUQiCiAKLSM6IHNlcXVlbmNlci5jOjE2ODIKKyM6IHNlcXVlbmNlci5jOjE2MTIKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IHdyaXRlICclcyciCiBtc2dzdHIgImltcG9zc2liaWxlIHNjcml2ZXJlICclcyciCiAKLSM6IHNlcXVlbmNlci5jOjE2ODkgZ2l0LXJlYmFzZS0tcHJlc2VydmUtbWVyZ2VzLnNoOjQ5NgorIzogc2VxdWVuY2VyLmM6MTYxOSBnaXQtcmViYXNlLS1wcmVzZXJ2ZS1tZXJnZXMuc2g6NDk2CiBtc2dpZCAiVGhpcyBpcyB0aGUgMXN0IGNvbW1pdCBtZXNzYWdlOiIKIG1zZ3N0ciAiUXVlc3RvIMOoIGlsIHByaW1vIG1lc3NhZ2dpbyBkaSBjb21taXQ6IgogCi0jOiBzZXF1ZW5jZXIuYzoxNjk3CisjOiBzZXF1ZW5jZXIuYzoxNjI3CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCByZWFkIGNvbW1pdCBtZXNzYWdlIG9mICVzIgogbXNnc3RyICJpbXBvc3NpYmlsZSBsZWdnZXJlIGlsIG1lc3NhZ2dpbyBkaSBjb21taXQgZGkgJXMiCiAKLSM6IHNlcXVlbmNlci5jOjE3MDQKKyM6IHNlcXVlbmNlci5jOjE2MzQKICMsIGMtZm9ybWF0CiBtc2dpZCAiVGhpcyBpcyB0aGUgY29tbWl0IG1lc3NhZ2UgIyVkOiIKIG1zZ3N0ciAiUXVlc3RvIMOoIGlsIG1lc3NhZ2dpbyBkaSBjb21taXQgbnVtZXJvICVkOiIKIAotIzogc2VxdWVuY2VyLmM6MTcxMAorIzogc2VxdWVuY2VyLmM6MTY0MAogIywgYy1mb3JtYXQKIG1zZ2lkICJUaGUgY29tbWl0IG1lc3NhZ2UgIyVkIHdpbGwgYmUgc2tpcHBlZDoiCiBtc2dzdHIgIklsIG1lc3NhZ2dpbyBkaSBjb21taXQgbnVtZXJvICVkIHNhcsOgIHNhbHRhdG86IgogCi0jOiBzZXF1ZW5jZXIuYzoxNzk4CisjOiBzZXF1ZW5jZXIuYzoxNzI4CiBtc2dpZCAieW91ciBpbmRleCBmaWxlIGlzIHVubWVyZ2VkLiIKIG1zZ3N0ciAiaWwgZmlsZSBpbmRpY2Ugbm9uIMOoIHN0YXRvIHNvdHRvcG9zdG8gYSBtZXJnZS4iCiAKLSM6IHNlcXVlbmNlci5jOjE4MDUKKyM6IHNlcXVlbmNlci5jOjE3MzUKIG1zZ2lkICJjYW5ub3QgZml4dXAgcm9vdCBjb21taXQiCiBtc2dzdHIgImltcG9zc2liaWxlIGVzZWd1aXJlIGlsIGZpeHVwIHN1bCBjb21taXQgcmFkaWNlIgogCi0jOiBzZXF1ZW5jZXIuYzoxODI0CisjOiBzZXF1ZW5jZXIuYzoxNzU0CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvbW1pdCAlcyBpcyBhIG1lcmdlIGJ1dCBubyAtbSBvcHRpb24gd2FzIGdpdmVuLiIKIG1zZ3N0ciAiaWwgY29tbWl0ICVzIMOoIHVuIG1lcmdlIG1hIG5vbiDDqCBzdGF0YSBzcGVjaWZpY2F0YSBsJ29wemlvbmUgLW0uIgogCi0jOiBzZXF1ZW5jZXIuYzoxODMyIHNlcXVlbmNlci5jOjE4NDAKKyM6IHNlcXVlbmNlci5jOjE3NjIgc2VxdWVuY2VyLmM6MTc3MAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb21taXQgJXMgZG9lcyBub3QgaGF2ZSBwYXJlbnQgJWQiCiBtc2dzdHIgImlsIGNvbW1pdCAlcyBub24gaGEgaWwgZ2VuaXRvcmUgJWQiCiAKLSM6IHNlcXVlbmNlci5jOjE4NDYKKyM6IHNlcXVlbmNlci5jOjE3NzYKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IGdldCBjb21taXQgbWVzc2FnZSBmb3IgJXMiCiBtc2dzdHIgImltcG9zc2liaWxlIG90dGVuZXJlIGlsIG1lc3NhZ2dpbyBkaSBjb21taXQgcGVyICVzIgogCiAjLiBUUkFOU0xBVE9SUzogVGhlIGZpcnN0ICVzIHdpbGwgYmUgYSAidG9kbyIgY29tbWFuZCBsaWtlCiAjLiAicmV2ZXJ0IiBvciAicGljayIsIHRoZSBzZWNvbmQgJXMgYSBTSEExLgotIzogc2VxdWVuY2VyLmM6MTg2NQorIzogc2VxdWVuY2VyLmM6MTc5NQogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogY2Fubm90IHBhcnNlIHBhcmVudCBjb21taXQgJXMiCiBtc2dzdHIgIiVzOiBpbXBvc3NpYmlsZSBhbmFsaXp6YXJlIGlsIGNvbW1pdCBnZW5pdG9yZSAlcyIKIAotIzogc2VxdWVuY2VyLmM6MTkzMAorIzogc2VxdWVuY2VyLmM6MTg2MAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcmVuYW1lICclcycgdG8gJyVzJyIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgcmlkZW5vbWluYXJlICclcycgaW4gJyVzJyIKIAotIzogc2VxdWVuY2VyLmM6MTk4NQorIzogc2VxdWVuY2VyLmM6MTkxNQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcmV2ZXJ0ICVzLi4uICVzIgogbXNnc3RyICJub24gw6ggc3RhdG8gcG9zc2liaWxlIGVzZWd1aXJlIGlsIHJldmVydCBkaSAlcy4uLiAlcyIKIAotIzogc2VxdWVuY2VyLmM6MTk4NgorIzogc2VxdWVuY2VyLmM6MTkxNgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgYXBwbHkgJXMuLi4gJXMiCiBtc2dzdHIgIm5vbiDDqCBzdGF0byBwb3NzaWJpbGUgYXBwbGljYXJlICVzLi4uICVzIgogCi0jOiBzZXF1ZW5jZXIuYzoyMDQ1CisjOiBzZXF1ZW5jZXIuYzoxOTgzCiAjLCBjLWZvcm1hdAogbXNnaWQgImdpdCAlczogZmFpbGVkIHRvIHJlYWQgdGhlIGluZGV4IgogbXNnc3RyICJnaXQgJXM6IGxldHR1cmEgZGVsbCdpbmRpY2Ugbm9uIHJpdXNjaXRhIgogCi0jOiBzZXF1ZW5jZXIuYzoyMDUyCisjOiBzZXF1ZW5jZXIuYzoxOTkwCiAjLCBjLWZvcm1hdAogbXNnaWQgImdpdCAlczogZmFpbGVkIHRvIHJlZnJlc2ggdGhlIGluZGV4IgogbXNnc3RyICJnaXQgJXM6IGFnZ2lvcm5hbWVudG8gZGVsbCdpbmRpY2Ugbm9uIHJpdXNjaXRvIgogCi0jOiBzZXF1ZW5jZXIuYzoyMTI4CisjOiBzZXF1ZW5jZXIuYzoyMDY2CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIGRvZXMgbm90IGFjY2VwdCBhcmd1bWVudHM6ICclcyciCiBtc2dzdHIgIiVzIG5vbiBhY2NldHRhIGFyZ29tZW50aTogJyVzJyIKIAotIzogc2VxdWVuY2VyLmM6MjEzNworIzogc2VxdWVuY2VyLmM6MjA3NQogIywgYy1mb3JtYXQKIG1zZ2lkICJtaXNzaW5nIGFyZ3VtZW50cyBmb3IgJXMiCiBtc2dzdHIgImFyZ29tZW50aSBtYW5jYW50aSBwZXIgJXMiCiAKLSM6IHNlcXVlbmNlci5jOjIxNzQKKyM6IHNlcXVlbmNlci5jOjIxMTIKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHBhcnNlICclLipzJyIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgYW5hbGl6emFyZSAnJS4qcyciCiAKLSM6IHNlcXVlbmNlci5jOjIyMjgKKyM6IHNlcXVlbmNlci5jOjIxNjYKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBsaW5lICVkOiAlLipzIgogbXNnc3RyICJyaWdhICVkIG5vbiB2YWxpZGE6ICUuKnMiCiAKLSM6IHNlcXVlbmNlci5jOjIyMzkKKyM6IHNlcXVlbmNlci5jOjIxNzcKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90ICclcycgd2l0aG91dCBhIHByZXZpb3VzIGNvbW1pdCIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgZXNlZ3VpcmUgJyVzJyBzZW56YSB1biBjb21taXQgcHJlY2VkZW50ZSIKIAotIzogc2VxdWVuY2VyLmM6MjI4NyBidWlsdGluL3JlYmFzZS5jOjE1MyBidWlsdGluL3JlYmFzZS5jOjE3OAorIzogc2VxdWVuY2VyLmM6MjIyNSBidWlsdGluL3JlYmFzZS5jOjE1MyBidWlsdGluL3JlYmFzZS5jOjE3OAogIzogYnVpbHRpbi9yZWJhc2UuYzoyMDQgYnVpbHRpbi9yZWJhc2UuYzoyMjkKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHJlYWQgJyVzJy4iCiBtc2dzdHIgImltcG9zc2liaWxlIGxlZ2dlcmUgJyVzJy4iCiAKLSM6IHNlcXVlbmNlci5jOjIzMjMKKyM6IHNlcXVlbmNlci5jOjIyNjEKIG1zZ2lkICJjYW5jZWxsaW5nIGEgY2hlcnJ5IHBpY2tpbmcgaW4gcHJvZ3Jlc3MiCiBtc2dzdHIgImFubnVsbG8gdW4nb3BlcmF6aW9uZSBkaSBjaGVycnktcGljayBpbiBjb3JzbyIKIAotIzogc2VxdWVuY2VyLmM6MjMzMAorIzogc2VxdWVuY2VyLmM6MjI2OAogbXNnaWQgImNhbmNlbGxpbmcgYSByZXZlcnQgaW4gcHJvZ3Jlc3MiCiBtc2dzdHIgImFubnVsbG8gdW4nb3BlcmF6aW9uZSBkaSByZXZlcnQgaW4gY29yc28iCiAKLSM6IHNlcXVlbmNlci5jOjIzNjQKKyM6IHNlcXVlbmNlci5jOjIzMDIKIG1zZ2lkICJwbGVhc2UgZml4IHRoaXMgdXNpbmcgJ2dpdCByZWJhc2UgLS1lZGl0LXRvZG8nLiIKIG1zZ3N0ciAiY29ycmVnZ2kgbGEgc2l0dWF6aW9uZSB1c2FuZG8gJ2dpdCByZWJhc2UgLS1lZGl0LXRvZG8nLiIKIAotIzogc2VxdWVuY2VyLmM6MjM2NgorIzogc2VxdWVuY2VyLmM6MjMwNAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bnVzYWJsZSBpbnN0cnVjdGlvbiBzaGVldDogJyVzJyIKIG1zZ3N0ciAiZm9nbGlvIGlzdHJ1emlvbmkgaW51dGlsaXp6YWJpbGU6ICclcyciCiAKLSM6IHNlcXVlbmNlci5jOjIzNzEKKyM6IHNlcXVlbmNlci5jOjIzMDkKIG1zZ2lkICJubyBjb21taXRzIHBhcnNlZC4iCiBtc2dzdHIgIm5lc3N1biBjb21taXQgYW5hbGl6emF0by4iCiAKLSM6IHNlcXVlbmNlci5jOjIzODIKKyM6IHNlcXVlbmNlci5jOjIzMjAKIG1zZ2lkICJjYW5ub3QgY2hlcnJ5LXBpY2sgZHVyaW5nIGEgcmV2ZXJ0LiIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgZXNlZ3VpcmUgdW4gY2hlcnJ5LXBpY2sgZHVyYW50ZSB1biByZXZlcnQuIgogCi0jOiBzZXF1ZW5jZXIuYzoyMzg0CisjOiBzZXF1ZW5jZXIuYzoyMzIyCiBtc2dpZCAiY2Fubm90IHJldmVydCBkdXJpbmcgYSBjaGVycnktcGljay4iCiBtc2dzdHIgImltcG9zc2liaWxlIGVzZWd1aXJlIHVuIHJldmVydCBkdXJhbnRlIHVuIGNoZXJyeS1waWNrLiIKIAotIzogc2VxdWVuY2VyLmM6MjQ2NgorIzogc2VxdWVuY2VyLmM6MjQwNAogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIHZhbHVlIGZvciAlczogJXMiCiBtc2dzdHIgInZhbG9yZSBub24gdmFsaWRvIHBlciAlczogJXMiCiAKLSM6IHNlcXVlbmNlci5jOjI1NTMKKyM6IHNlcXVlbmNlci5jOjI0OTEKIG1zZ2lkICJ1bnVzYWJsZSBzcXVhc2gtb250byIKIG1zZ3N0ciAic3F1YXNoLW9udG8gaW51dGlsaXp6YWJpbGUiCiAKLSM6IHNlcXVlbmNlci5jOjI1NjkKKyM6IHNlcXVlbmNlci5jOjI1MDcKICMsIGMtZm9ybWF0CiBtc2dpZCAibWFsZm9ybWVkIG9wdGlvbnMgc2hlZXQ6ICclcyciCiBtc2dzdHIgImZvZ2xpbyBvcHppb25pIG1hbGZvcm1hdGk6ICclcyciCiAKLSM6IHNlcXVlbmNlci5jOjI2NTIgc2VxdWVuY2VyLmM6NDM1MQorIzogc2VxdWVuY2VyLmM6MjU5MCBzZXF1ZW5jZXIuYzo0MzA4CiBtc2dpZCAiZW1wdHkgY29tbWl0IHNldCBwYXNzZWQiCiBtc2dzdHIgIsOoIHN0YXRvIHBhc3NhdG8gdW4gaW5zaWVtZSBkaSBjb21taXQgdnVvdG8iCiAKLSM6IHNlcXVlbmNlci5jOjI2NjgKKyM6IHNlcXVlbmNlci5jOjI2MDYKIG1zZ2lkICJyZXZlcnQgaXMgYWxyZWFkeSBpbiBwcm9ncmVzcyIKIG1zZ3N0ciAidW4nb3BlcmF6aW9uZSBkaSByZXZlcnQgw6ggZ2nDoCBpbiBjb3JzbyIKIAotIzogc2VxdWVuY2VyLmM6MjY3MAorIzogc2VxdWVuY2VyLmM6MjYwOAogIywgYy1mb3JtYXQKIG1zZ2lkICJ0cnkgXCJnaXQgcmV2ZXJ0ICgtLWNvbnRpbnVlIHwgJXMtLWFib3J0IHwgLS1xdWl0KVwiIgogbXNnc3RyICJwcm92YSBcImdpdCByZXZlcnQgKC0tY29udGludWUgfCAlcy0tYWJvcnQgfCAtLXF1aXQpXCIiCiAKLSM6IHNlcXVlbmNlci5jOjI2NzMKKyM6IHNlcXVlbmNlci5jOjI2MTEKIG1zZ2lkICJjaGVycnktcGljayBpcyBhbHJlYWR5IGluIHByb2dyZXNzIgogbXNnc3RyICJ1bidvcGVyYXppb25lIGRpIGNoZXJyeS1waWNrIMOoIGdpw6AgaW4gY29yc28iCiAKLSM6IHNlcXVlbmNlci5jOjI2NzUKKyM6IHNlcXVlbmNlci5jOjI2MTMKICMsIGMtZm9ybWF0CiBtc2dpZCAidHJ5IFwiZ2l0IGNoZXJyeS1waWNrICgtLWNvbnRpbnVlIHwgJXMtLWFib3J0IHwgLS1xdWl0KVwiIgogbXNnc3RyICJwcm92YSBcImdpdCBjaGVycnktcGljayAoLS1jb250aW51ZSB8ICVzLS1hYm9ydCB8IC0tcXVpdClcIiIKIAotIzogc2VxdWVuY2VyLmM6MjY4OQorIzogc2VxdWVuY2VyLmM6MjYyNwogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgY3JlYXRlIHNlcXVlbmNlciBkaXJlY3RvcnkgJyVzJyIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgY3JlYXJlIGxhIGRpcmVjdG9yeSBzZXF1ZW5jZXIgJyVzJyIKIAotIzogc2VxdWVuY2VyLmM6MjcwNAorIzogc2VxdWVuY2VyLmM6MjY0MgogbXNnaWQgImNvdWxkIG5vdCBsb2NrIEhFQUQiCiBtc2dzdHIgImltcG9zc2liaWxlIGJsb2NjYXJlIEhFQUQiCiAKLSM6IHNlcXVlbmNlci5jOjI3NjQgc2VxdWVuY2VyLmM6NDEwMworIzogc2VxdWVuY2VyLmM6MjcwMiBzZXF1ZW5jZXIuYzo0MDU3CiBtc2dpZCAibm8gY2hlcnJ5LXBpY2sgb3IgcmV2ZXJ0IGluIHByb2dyZXNzIgogbXNnc3RyICJuZXNzdW5hIG9wZXJhemlvbmUgZGkgY2hlcnJ5LXBpY2sgbyByZXZlcnQgaW4gY29yc28iCiAKLSM6IHNlcXVlbmNlci5jOjI3NjYgc2VxdWVuY2VyLmM6Mjc3NworIzogc2VxdWVuY2VyLmM6MjcwNCBzZXF1ZW5jZXIuYzoyNzE1CiBtc2dpZCAiY2Fubm90IHJlc29sdmUgSEVBRCIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgcmlzb2x2ZXJlIEhFQUQiCiAKLSM6IHNlcXVlbmNlci5jOjI3Njggc2VxdWVuY2VyLmM6MjgxMgorIzogc2VxdWVuY2VyLmM6MjcwNiBzZXF1ZW5jZXIuYzoyNzUwCiBtc2dpZCAiY2Fubm90IGFib3J0IGZyb20gYSBicmFuY2ggeWV0IHRvIGJlIGJvcm4iCiBtc2dzdHIgIiIKICJpbXBvc3NpYmlsZSBpbnRlcnJvbXBlcmUgbCdvcGVyYXppb25lIGRhIHVuIGJyYW5jaCBjaGUgZGV2ZSBlc3NlcmUgYW5jb3JhICIKICJjcmVhdG8iCiAKLSM6IHNlcXVlbmNlci5jOjI3OTggYnVpbHRpbi9ncmVwLmM6NzM0CisjOiBzZXF1ZW5jZXIuYzoyNzM2IGJ1aWx0aW4vZ3JlcC5jOjczNgogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3Qgb3BlbiAnJXMnIgogbXNnc3RyICJpbXBvc3NpYmlsZSBhcHJpcmUgJyVzJyIKIAotIzogc2VxdWVuY2VyLmM6MjgwMAorIzogc2VxdWVuY2VyLmM6MjczOAogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgcmVhZCAnJXMnOiAlcyIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgbGVnZ2VyZSAnJXMnOiAlcyIKIAotIzogc2VxdWVuY2VyLmM6MjgwMQorIzogc2VxdWVuY2VyLmM6MjczOQogbXNnaWQgInVuZXhwZWN0ZWQgZW5kIG9mIGZpbGUiCiBtc2dzdHIgImZpbmUgZGVsIGZpbGUgaW5hdHRlc2EiCiAKLSM6IHNlcXVlbmNlci5jOjI4MDcKKyM6IHNlcXVlbmNlci5jOjI3NDUKICMsIGMtZm9ybWF0CiBtc2dpZCAic3RvcmVkIHByZS1jaGVycnktcGljayBIRUFEIGZpbGUgJyVzJyBpcyBjb3JydXB0IgogbXNnc3RyICIiCiAiaWwgZmlsZSAnJXMnIGluIGN1aSDDqCBzdGF0byBzYWx2YXRvIGwnSEVBRCBwcmltYSBkZWwgY2hlcnJ5IHBpY2sgw6ggY29ycm90dG8iCiAKLSM6IHNlcXVlbmNlci5jOjI4MTgKKyM6IHNlcXVlbmNlci5jOjI3NTYKIG1zZ2lkICJZb3Ugc2VlbSB0byBoYXZlIG1vdmVkIEhFQUQuIE5vdCByZXdpbmRpbmcsIGNoZWNrIHlvdXIgSEVBRCEiCiBtc2dzdHIgIiIKICJTZW1icmEgY2hlIHR1IGFiYmlhIHNwb3N0YXRvIGwnSEVBRC4gTm9uIGVzZWd1byBpbCByZXdpbmQsIGNvbnRyb2xsYSBsJ0hFQUQhIgogCi0jOiBzZXF1ZW5jZXIuYzoyODU5CisjOiBzZXF1ZW5jZXIuYzoyNzk3CiBtc2dpZCAibm8gcmV2ZXJ0IGluIHByb2dyZXNzIgogbXNnc3RyICJuZXNzdW4gcmV2ZXJ0IGluIGNvcnNvIgogCi0jOiBzZXF1ZW5jZXIuYzoyODY3CisjOiBzZXF1ZW5jZXIuYzoyODA1CiBtc2dpZCAibm8gY2hlcnJ5LXBpY2sgaW4gcHJvZ3Jlc3MiCiBtc2dzdHIgIm5lc3N1biBjaGVycnktcGljayBpbiBjb3JzbyIKIAotIzogc2VxdWVuY2VyLmM6Mjg3NworIzogc2VxdWVuY2VyLmM6MjgxNQogbXNnaWQgImZhaWxlZCB0byBza2lwIHRoZSBjb21taXQiCiBtc2dzdHIgInNhbHRvIGRlbCBjb21taXQgbm9uIHJpdXNjaXRvIgogCi0jOiBzZXF1ZW5jZXIuYzoyODg0CisjOiBzZXF1ZW5jZXIuYzoyODIyCiBtc2dpZCAidGhlcmUgaXMgbm90aGluZyB0byBza2lwIgogbXNnc3RyICJub24gYyfDqCBudWxsYSBkYSBzYWx0YXJlIgogCi0jOiBzZXF1ZW5jZXIuYzoyODg3CisjOiBzZXF1ZW5jZXIuYzoyODI1CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJoYXZlIHlvdSBjb21taXR0ZWQgYWxyZWFkeT9cbiIKQEAgLTY0MDUsMjEgKzY0MzEsMjEgQEAKICJoYWkgZ2nDoCBlc2VndWl0byBpbCBjb21taXQ/XG4iCiAicHJvdmEgXCJnaXQgJXMgLS1jb250aW51ZVwiIgogCi0jOiBzZXF1ZW5jZXIuYzozMDExIHNlcXVlbmNlci5jOjQwMTUKKyM6IHNlcXVlbmNlci5jOjI5NDkgc2VxdWVuY2VyLmM6Mzk2OQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgdXBkYXRlICVzIgogbXNnc3RyICJpbXBvc3NpYmlsZSBhZ2dpb3JuYXJlICVzIgogCi0jOiBzZXF1ZW5jZXIuYzozMDQ5IHNlcXVlbmNlci5jOjM5OTUKKyM6IHNlcXVlbmNlci5jOjI5ODcgc2VxdWVuY2VyLmM6Mzk0OQogbXNnaWQgImNhbm5vdCByZWFkIEhFQUQiCiBtc2dzdHIgImltcG9zc2liaWxlIGxlZ2dlcmUgbCdIRUFEIgogCi0jOiBzZXF1ZW5jZXIuYzozMDY2CisjOiBzZXF1ZW5jZXIuYzozMDA0CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBjb3B5ICclcycgdG8gJyVzJyIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgY29waWFyZSAnJXMnIGluICclcyciCiAKLSM6IHNlcXVlbmNlci5jOjMwNzQKKyM6IHNlcXVlbmNlci5jOjMwMTIKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIllvdSBjYW4gYW1lbmQgdGhlIGNvbW1pdCBub3csIHdpdGhcbiIKQEAgLTY0MzgsMjcgKzY0NjQsMjcgQEAKICJcbiIKICIgIGdpdCByZWJhc2UgLS1jb250aW51ZVxuIgogCi0jOiBzZXF1ZW5jZXIuYzozMDg0CisjOiBzZXF1ZW5jZXIuYzozMDIyCiAjLCBjLWZvcm1hdAogbXNnaWQgIkNvdWxkIG5vdCBhcHBseSAlcy4uLiAlLipzIgogbXNnc3RyICJJbXBvc3NpYmlsZSBhcHBsaWNhcmUgJXMuLi4gJS4qcyIKIAotIzogc2VxdWVuY2VyLmM6MzA5MQorIzogc2VxdWVuY2VyLmM6MzAyOQogIywgYy1mb3JtYXQKIG1zZ2lkICJDb3VsZCBub3QgbWVyZ2UgJS4qcyIKIG1zZ3N0ciAiSW1wb3NzaWJpbGUgZXNlZ3VpcmUgaWwgbWVyZ2UgZGkgJS4qcyIKIAotIzogc2VxdWVuY2VyLmM6MzEwNSBzZXF1ZW5jZXIuYzozMTA5IGJ1aWx0aW4vZGlmZnRvb2wuYzo2MzMKKyM6IHNlcXVlbmNlci5jOjMwNDMgc2VxdWVuY2VyLmM6MzA0NyBidWlsdGluL2RpZmZ0b29sLmM6NjQxCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBjb3B5ICclcycgdG8gJyVzJyIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgY29waWFyZSAnJXMnIGluICclcyciCiAKLSM6IHNlcXVlbmNlci5jOjMxMzEgc2VxdWVuY2VyLmM6MzU1OCBidWlsdGluL3JlYmFzZS5jOjg0OSBidWlsdGluL3JlYmFzZS5jOjE1ODIKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTk1MyBidWlsdGluL3JlYmFzZS5jOjIwMDgKKyM6IHNlcXVlbmNlci5jOjMwNjkgc2VxdWVuY2VyLmM6MzUwNiBidWlsdGluL3JlYmFzZS5jOjg1MCBidWlsdGluL3JlYmFzZS5jOjE2MTMKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTk4NyBidWlsdGluL3JlYmFzZS5jOjIwMzEKIG1zZ2lkICJjb3VsZCBub3QgcmVhZCBpbmRleCIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgbGVnZ2VyZSBsJ2luZGljZSIKIAotIzogc2VxdWVuY2VyLmM6MzEzNgorIzogc2VxdWVuY2VyLmM6MzA3NAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiZXhlY3V0aW9uIGZhaWxlZDogJXNcbiIKQEAgLTY0NzMsMTEgKzY0OTksMTEgQEAKICIgIGdpdCByZWJhc2UgLS1jb250aW51ZVxuIgogIlxuIgogCi0jOiBzZXF1ZW5jZXIuYzozMTQyCisjOiBzZXF1ZW5jZXIuYzozMDgwCiBtc2dpZCAiYW5kIG1hZGUgY2hhbmdlcyB0byB0aGUgaW5kZXggYW5kL29yIHRoZSB3b3JraW5nIHRyZWVcbiIKIG1zZ3N0ciAiZSBzb25vIHN0YXRlIGFwcG9ydGF0ZSBtb2RpZmljaGUgYWxsJ2luZGljZSBlL28gYWxsJ2FsYmVybyBkaSBsYXZvcm9cbiIKIAotIzogc2VxdWVuY2VyLmM6MzE0OAorIzogc2VxdWVuY2VyLmM6MzA4NgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiZXhlY3V0aW9uIHN1Y2NlZWRlZDogJXNcbiIKQEAgLTY0OTQsNzYgKzY1MjAsNzYgQEAKICIgIGdpdCByZWJhc2UgLS1jb250aW51ZVxuIgogIlxuIgogCi0jOiBzZXF1ZW5jZXIuYzozMjA5CisjOiBzZXF1ZW5jZXIuYzozMTQ3CiAjLCBjLWZvcm1hdAogbXNnaWQgImlsbGVnYWwgbGFiZWwgbmFtZTogJyUuKnMnIgogbXNnc3RyICJub21lIGV0aWNoZXR0YSBpbGxlY2l0bzogJyUuKnMnIgogCi0jOiBzZXF1ZW5jZXIuYzozMjYzCisjOiBzZXF1ZW5jZXIuYzozMjAxCiBtc2dpZCAid3JpdGluZyBmYWtlIHJvb3QgY29tbWl0IgogbXNnc3RyICJzY3JpdHR1cmEgY29tbWl0IHJhZGljZSBmYWxzbyBpbiBjb3JzbyIKIAotIzogc2VxdWVuY2VyLmM6MzI2OAorIzogc2VxdWVuY2VyLmM6MzIwNgogbXNnaWQgIndyaXRpbmcgc3F1YXNoLW9udG8iCiBtc2dzdHIgInNjcml0dHVyYSBzcXVhc2gtb250byBpbiBjb3JzbyIKIAotIzogc2VxdWVuY2VyLmM6MzMwNiBidWlsdGluL3JlYmFzZS5jOjg1NCBidWlsdGluL3JlYmFzZS5jOjg2MAorIzogc2VxdWVuY2VyLmM6MzI0NCBidWlsdGluL3JlYmFzZS5jOjg1NSBidWlsdGluL3JlYmFzZS5jOjg2MQogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gZmluZCB0cmVlIG9mICVzIgogbXNnc3RyICJpbXBvc3NpYmlsZSB0cm92YXJlIGwnYWxiZXJvIGRpICVzIgogCi0jOiBzZXF1ZW5jZXIuYzozMzI0IGJ1aWx0aW4vcmViYXNlLmM6ODczCisjOiBzZXF1ZW5jZXIuYzozMjYyIGJ1aWx0aW4vcmViYXNlLmM6ODc0CiBtc2dpZCAiY291bGQgbm90IHdyaXRlIGluZGV4IgogbXNnc3RyICJpbXBvc3NpYmlsZSBzY3JpdmVyZSBsJ2luZGljZSIKIAotIzogc2VxdWVuY2VyLmM6MzM1MQorIzogc2VxdWVuY2VyLmM6MzI4OQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcmVzb2x2ZSAnJXMnIgogbXNnc3RyICJpbXBvc3NpYmlsZSByaXNvbHZlcmUgJyVzJyIKIAotIzogc2VxdWVuY2VyLmM6MzM3OQorIzogc2VxdWVuY2VyLmM6MzMyMAogbXNnaWQgImNhbm5vdCBtZXJnZSB3aXRob3V0IGEgY3VycmVudCByZXZpc2lvbiIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgZXNlZ3VpcmUgaWwgbWVyZ2Ugc2VuemEgdW5hIHJldmlzaW9uZSBjb3JyZW50ZSIKIAotIzogc2VxdWVuY2VyLmM6MzQwMQorIzogc2VxdWVuY2VyLmM6MzM0MgogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gcGFyc2UgJyUuKnMnIgogbXNnc3RyICJpbXBvc3NpYmlsZSBhbmFsaXp6YXJlICclLipzJyIKIAotIzogc2VxdWVuY2VyLmM6MzQxMAorIzogc2VxdWVuY2VyLmM6MzM1MQogIywgYy1mb3JtYXQKIG1zZ2lkICJub3RoaW5nIHRvIG1lcmdlOiAnJS4qcyciCiBtc2dzdHIgIm5vbiBjJ8OoIG51bGxhIGRpIGN1aSBlc2VndWlyZSBpbCBtZXJnZTogJyUuKnMnIgogCi0jOiBzZXF1ZW5jZXIuYzozNDIyCisjOiBzZXF1ZW5jZXIuYzozMzYzCiBtc2dpZCAib2N0b3B1cyBtZXJnZSBjYW5ub3QgYmUgZXhlY3V0ZWQgb24gdG9wIG9mIGEgW25ldyByb290XSIKIG1zZ3N0ciAiaWwgbWVyZ2Ugb2N0b3B1cyBub24gcHXDsiBlc3NlcmUgZXNlZ3VpdG8gc3UgdW4gW251b3ZvIGNvbW1pdCByYWRpY2VdIgogCi0jOiBzZXF1ZW5jZXIuYzozNDM3CisjOiBzZXF1ZW5jZXIuYzozMzc4CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBnZXQgY29tbWl0IG1lc3NhZ2Ugb2YgJyVzJyIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgb3R0ZW5lcmUgaWwgbWVzc2FnZ2lvIGRpIGNvbW1pdCBwZXIgJyVzJyIKIAotIzogc2VxdWVuY2VyLmM6MzU5MAorIzogc2VxdWVuY2VyLmM6MzUzOAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgZXZlbiBhdHRlbXB0IHRvIG1lcmdlICclLipzJyIKIG1zZ3N0ciAibm9uIMOoIHN0YXRvIG5lbW1lbm8gcG9zc2liaWxlIHRlbnRhcmUgZGkgZXNlZ3VpcmUgaWwgbWVyZ2UgZGkgJyUuKnMnIgogCi0jOiBzZXF1ZW5jZXIuYzozNjA2CisjOiBzZXF1ZW5jZXIuYzozNTU0CiBtc2dpZCAibWVyZ2U6IFVuYWJsZSB0byB3cml0ZSBuZXcgaW5kZXggZmlsZSIKIG1zZ3N0ciAibWVyZ2U6IGltcG9zc2liaWxlIHNjcml2ZXJlIGlsIG51b3ZvIGZpbGUgaW5kaWNlIgogCi0jOiBzZXF1ZW5jZXIuYzozNjc1IGJ1aWx0aW4vcmViYXNlLmM6NzExCisjOiBzZXF1ZW5jZXIuYzozNjIzIGJ1aWx0aW4vcmViYXNlLmM6NzEyCiAjLCBjLWZvcm1hdAogbXNnaWQgIkFwcGxpZWQgYXV0b3N0YXNoLlxuIgogbXNnc3RyICJTdGFzaCBhdXRvbWF0aWNvIGFwcGxpY2F0by5cbiIKIAotIzogc2VxdWVuY2VyLmM6MzY4NworIzogc2VxdWVuY2VyLmM6MzYzNQogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3Qgc3RvcmUgJXMiCiBtc2dzdHIgImltcG9zc2liaWxlIG1lbW9yaXp6YXJlICVzIgogCi0jOiBzZXF1ZW5jZXIuYzozNjkwIGJ1aWx0aW4vcmViYXNlLmM6NzI3IGdpdC1yZWJhc2UtLXByZXNlcnZlLW1lcmdlcy5zaDoxMTMKKyM6IHNlcXVlbmNlci5jOjM2MzggYnVpbHRpbi9yZWJhc2UuYzo3MjggZ2l0LXJlYmFzZS0tcHJlc2VydmUtbWVyZ2VzLnNoOjExMwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiQXBwbHlpbmcgYXV0b3N0YXNoIHJlc3VsdGVkIGluIGNvbmZsaWN0cy5cbiIKQEAgLTY1NzQsMzEgKzY2MDAsMzEgQEAKICJMZSB0dWUgbW9kaWZpY2hlIHNvbm8gYWwgc2ljdXJvIG5lbGxvIHN0YXNoLlxuIgogIlB1b2kgZXNlZ3VpcmUgXCJnaXQgc3Rhc2ggcG9wXCIgbyBcImdpdCBzdGFzaCBkcm9wXCIgaW4gcXVhbHVucXVlIG1vbWVudG8uXG4iCiAKLSM6IHNlcXVlbmNlci5jOjM3NTEKKyM6IHNlcXVlbmNlci5jOjM2OTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGNoZWNrb3V0ICVzIgogbXNnc3RyICJpbXBvc3NpYmlsZSBlc2VndWlyZSBpbCBjaGVja291dCBkaSAlcyIKIAotIzogc2VxdWVuY2VyLmM6Mzc2NQorIzogc2VxdWVuY2VyLmM6MzcxMwogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogbm90IGEgdmFsaWQgT0lEIgogbXNnc3RyICIlczogbm9uIMOoIHVuIE9JRCB2YWxpZG8iCiAKLSM6IHNlcXVlbmNlci5jOjM3NzAgZ2l0LXJlYmFzZS0tcHJlc2VydmUtbWVyZ2VzLnNoOjc3OQorIzogc2VxdWVuY2VyLmM6MzcxOCBnaXQtcmViYXNlLS1wcmVzZXJ2ZS1tZXJnZXMuc2g6Nzc5CiBtc2dpZCAiY291bGQgbm90IGRldGFjaCBIRUFEIgogbXNnc3RyICJpbXBvc3NpYmlsZSBzY29sbGVnYXJlIGwnSEVBRCIKIAotIzogc2VxdWVuY2VyLmM6Mzc4NQorIzogc2VxdWVuY2VyLmM6MzczMwogIywgYy1mb3JtYXQKIG1zZ2lkICJTdG9wcGVkIGF0IEhFQURcbiIKIG1zZ3N0ciAiRmVybWF0byBhIEhFQURcbiIKIAotIzogc2VxdWVuY2VyLmM6Mzc4NworIzogc2VxdWVuY2VyLmM6MzczNQogIywgYy1mb3JtYXQKIG1zZ2lkICJTdG9wcGVkIGF0ICVzXG4iCiBtc2dzdHIgIkZlcm1hdG8gYSAlc1xuIgogCi0jOiBzZXF1ZW5jZXIuYzozNzk1CisjOiBzZXF1ZW5jZXIuYzozNzQzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJDb3VsZCBub3QgZXhlY3V0ZSB0aGUgdG9kbyBjb21tYW5kXG4iCkBAIC02NjIwLDQ5ICs2NjQ2LDQ5IEBACiAiICAgIGdpdCByZWJhc2UgLS1lZGl0LXRvZG9cbiIKICIgICAgZ2l0IHJlYmFzZSAtLWNvbnRpbnVlXG4iCiAKLSM6IHNlcXVlbmNlci5jOjM4NzcKKyM6IHNlcXVlbmNlci5jOjM4MjcKICMsIGMtZm9ybWF0CiBtc2dpZCAiU3RvcHBlZCBhdCAlcy4uLiAgJS4qc1xuIgogbXNnc3RyICJGZXJtYXRvIGEgJXMuLi4gJS4qc1xuIgogCi0jOiBzZXF1ZW5jZXIuYzozOTU4CisjOiBzZXF1ZW5jZXIuYzozODk4CiAjLCBjLWZvcm1hdAogbXNnaWQgInVua25vd24gY29tbWFuZCAlZCIKIG1zZ3N0ciAiY29tYW5kbyAlZCBzY29ub3NjaXV0byIKIAotIzogc2VxdWVuY2VyLmM6NDAwMworIzogc2VxdWVuY2VyLmM6Mzk1NwogbXNnaWQgImNvdWxkIG5vdCByZWFkIG9yaWctaGVhZCIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgbGVnZ2VyZSBvcmlnLWhlYWQiCiAKLSM6IHNlcXVlbmNlci5jOjQwMDgKKyM6IHNlcXVlbmNlci5jOjM5NjIKIG1zZ2lkICJjb3VsZCBub3QgcmVhZCAnb250byciCiBtc2dzdHIgImltcG9zc2liaWxlIGxlZ2dlcmUgJ29udG8nIgogCi0jOiBzZXF1ZW5jZXIuYzo0MDIyCisjOiBzZXF1ZW5jZXIuYzozOTc2CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCB1cGRhdGUgSEVBRCB0byAlcyIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgYWdnaW9ybmFyZSBsJ0hFQUQgYSAlcyIKIAotIzogc2VxdWVuY2VyLmM6NDExNQorIzogc2VxdWVuY2VyLmM6NDA2OQogbXNnaWQgImNhbm5vdCByZWJhc2U6IFlvdSBoYXZlIHVuc3RhZ2VkIGNoYW5nZXMuIgogbXNnc3RyICIiCiAiaW1wb3NzaWJpbGUgZXNlZ3VpcmUgaWwgcmViYXNlOiBjaSBzb25vIGRlbGxlIG1vZGlmaWNoZSBub24gaW4gc3RhZ2luZy4iCiAKLSM6IHNlcXVlbmNlci5jOjQxMjQKKyM6IHNlcXVlbmNlci5jOjQwNzgKIG1zZ2lkICJjYW5ub3QgYW1lbmQgbm9uLWV4aXN0aW5nIGNvbW1pdCIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgbW9kaWZpY2FyZSB1biBjb21taXQgaW5lc2lzdGVudGUiCiAKLSM6IHNlcXVlbmNlci5jOjQxMjYKKyM6IHNlcXVlbmNlci5jOjQwODAKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBmaWxlOiAnJXMnIgogbXNnc3RyICJmaWxlIG5vbiB2YWxpZG86ICclcyciCiAKLSM6IHNlcXVlbmNlci5jOjQxMjgKKyM6IHNlcXVlbmNlci5jOjQwODIKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBjb250ZW50czogJyVzJyIKIG1zZ3N0ciAiY29udGVudXRpIG5vbiB2YWxpZGk6ICclcyciCiAKLSM6IHNlcXVlbmNlci5jOjQxMzEKKyM6IHNlcXVlbmNlci5jOjQwODUKIG1zZ2lkICIiCiAiXG4iCiAiWW91IGhhdmUgdW5jb21taXR0ZWQgY2hhbmdlcyBpbiB5b3VyIHdvcmtpbmcgdHJlZS4gUGxlYXNlLCBjb21taXQgdGhlbVxuIgpAQCAtNjY3Myw0MiArNjY5OSw0MiBAQAogImRpIGxhdm9yby4gRXNlZ3VpbmUgcHJpbWEgaWwgY29tbWl0IGUgcXVpbmRpIGVzZWd1aSBudW92YW1lbnRlICdnaXQgcmViYXNlXG4iCiAiLS1jb250aW51ZScuIgogCi0jOiBzZXF1ZW5jZXIuYzo0MTY3IHNlcXVlbmNlci5jOjQyMDUKKyM6IHNlcXVlbmNlci5jOjQxMjEgc2VxdWVuY2VyLmM6NDE1OQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3Qgd3JpdGUgZmlsZTogJyVzJyIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgc2NyaXZlcmUgaWwgZmlsZTogJyVzJyIKIAotIzogc2VxdWVuY2VyLmM6NDIyMAorIzogc2VxdWVuY2VyLmM6NDE3NAogbXNnaWQgImNvdWxkIG5vdCByZW1vdmUgQ0hFUlJZX1BJQ0tfSEVBRCIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgcmltdW92ZXJlIENIRVJSWV9QSUNLX0hFQUQiCiAKLSM6IHNlcXVlbmNlci5jOjQyMjcKKyM6IHNlcXVlbmNlci5jOjQxODEKIG1zZ2lkICJjb3VsZCBub3QgY29tbWl0IHN0YWdlZCBjaGFuZ2VzLiIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgZXNlZ3VpcmUgaWwgY29tbWl0IGRlbGxlIG1vZGlmaWNoZSBpbiBzdGFnaW5nLiIKIAotIzogc2VxdWVuY2VyLmM6NDMyOAorIzogc2VxdWVuY2VyLmM6NDI4NQogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogY2FuJ3QgY2hlcnJ5LXBpY2sgYSAlcyIKIG1zZ3N0ciAiJXM6IGltcG9zc2liaWxlIGVzZWd1aXJlIGlsIGNoZXJyeSBwaWNrIGRpIHVuICVzIgogCi0jOiBzZXF1ZW5jZXIuYzo0MzMyCisjOiBzZXF1ZW5jZXIuYzo0Mjg5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiBiYWQgcmV2aXNpb24iCiBtc2dzdHIgIiVzOiByZXZpc2lvbmUgbm9uIHZhbGlkYSIKIAotIzogc2VxdWVuY2VyLmM6NDM2NworIzogc2VxdWVuY2VyLmM6NDMyNAogbXNnaWQgImNhbid0IHJldmVydCBhcyBpbml0aWFsIGNvbW1pdCIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgZXNlZ3VpcmUgaWwgcmV2ZXJ0IGNvbWUgY29tbWl0IGluaXppYWxlIgogCi0jOiBzZXF1ZW5jZXIuYzo0ODEwCisjOiBzZXF1ZW5jZXIuYzo0Nzc0CiBtc2dpZCAibWFrZV9zY3JpcHQ6IHVuaGFuZGxlZCBvcHRpb25zIgogbXNnc3RyICJtYWtlX3NjcmlwdDogb3B6aW9uaSBub24gZ2VzdGl0ZSIKIAotIzogc2VxdWVuY2VyLmM6NDgxMworIzogc2VxdWVuY2VyLmM6NDc3NwogbXNnaWQgIm1ha2Vfc2NyaXB0OiBlcnJvciBwcmVwYXJpbmcgcmV2aXNpb25zIgogbXNnc3RyICJtYWtlX3NjcmlwdDogZXJyb3JlIGR1cmFudGUgbGEgcHJlcGFyYXppb25lIGRlbGxlIHJldmlzaW9uaSIKIAotIzogc2VxdWVuY2VyLmM6NDk3MQorIzogc2VxdWVuY2VyLmM6NDkzNQogbXNnaWQgIiIKICJZb3UgY2FuIGZpeCB0aGlzIHdpdGggJ2dpdCByZWJhc2UgLS1lZGl0LXRvZG8nIGFuZCB0aGVuIHJ1biAnZ2l0IHJlYmFzZSAtLSIKICJjb250aW51ZScuXG4iCkBAIC02NzE4LDI0ICs2NzQ0LDI0IEBACiAiZXNlZ3VpcmUgJ2dpdCByZWJhc2UgLS1jb250aW51ZScuXG4iCiAiT3BwdXJlIHB1b2kgaW50ZXJyb21wZXJlIGlsIHJlYmFzZSBjb24gJ2dpdCByZWJhc2UgLS1hYm9ydCcuXG4iCiAKLSM6IHNlcXVlbmNlci5jOjUwODMgc2VxdWVuY2VyLmM6NTEwMAorIzogc2VxdWVuY2VyLmM6NTA0NyBzZXF1ZW5jZXIuYzo1MDY0CiBtc2dpZCAibm90aGluZyB0byBkbyIKIG1zZ3N0ciAibnVsbGEgZGEgZmFyZSIKIAotIzogc2VxdWVuY2VyLmM6NTExNAorIzogc2VxdWVuY2VyLmM6NTA3OAogbXNnaWQgImNvdWxkIG5vdCBza2lwIHVubmVjZXNzYXJ5IHBpY2sgY29tbWFuZHMiCiBtc2dzdHIgImltcG9zc2liaWxlIHNhbHRhcmUgaSBjb21hbmRpIHBpY2sgbm9uIG5lY2Vzc2FyaSIKIAotIzogc2VxdWVuY2VyLmM6NTE5NworIzogc2VxdWVuY2VyLmM6NTE2NgogbXNnaWQgInRoZSBzY3JpcHQgd2FzIGFscmVhZHkgcmVhcnJhbmdlZC4iCiBtc2dzdHIgImxvIHNjcmlwdCDDqCBnacOgIHN0YXRvIHJpb3JkaW5hdG8uIgogCi0jOiBzZXR1cC5jOjEyMworIzogc2V0dXAuYzoxMjQKICMsIGMtZm9ybWF0CiBtc2dpZCAiJyVzJyBpcyBvdXRzaWRlIHJlcG9zaXRvcnkiCiBtc2dzdHIgIiclcycgw6ggYWwgZGkgZnVvcmkgZGVsIHJlcG9zaXRvcnkiCiAKLSM6IHNldHVwLmM6MTczCisjOiBzZXR1cC5jOjE3NAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiJXM6IG5vIHN1Y2ggcGF0aCBpbiB0aGUgd29ya2luZyB0cmVlLlxuIgpAQCAtNjc0NSw3ICs2NzcxLDcgQEAKICJVc2EgJ2dpdCA8Y29tYW5kbz4gLS0gPHBlcmNvcnNvPi4uLicgcGVyIHNwZWNpZmljYXJlIHBlcmNvcnNpIG5vbiBlc2lzdGVudGkgIgogImxvY2FsbWVudGUuIgogCi0jOiBzZXR1cC5jOjE4NgorIzogc2V0dXAuYzoxODcKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogImFtYmlndW91cyBhcmd1bWVudCAnJXMnOiB1bmtub3duIHJldmlzaW9uIG9yIHBhdGggbm90IGluIHRoZSB3b3JraW5nIHRyZWUuXG4iCkBAIC02NzU3LDE0ICs2NzgzLDE0IEBACiAiVXNhICctLScgcGVyIHNlcGFyYXJlIGkgcGVyY29yc2kgZGFsbGUgcmV2aXNpb25pLCBjb21lIHNlZ3VlOlxuIgogIidnaXQgPGNvbWFuZG8+IFs8cmV2aXNpb25lPi4uLl0gLS0gWzxmaWxlPi4uLl0nIgogCi0jOiBzZXR1cC5jOjIzNQorIzogc2V0dXAuYzoyMzYKICMsIGMtZm9ybWF0CiBtc2dpZCAib3B0aW9uICclcycgbXVzdCBjb21lIGJlZm9yZSBub24tb3B0aW9uIGFyZ3VtZW50cyIKIG1zZ3N0ciAiIgogImwnb3B6aW9uZSAnJXMnIGRldmUgZXNzZXJlIHNwZWNpZmljYXRhIHByaW1hIGRlZ2xpIGFyZ29tZW50aSBjaGUgbm9uICIKICJjb3N0aXR1aXNjb25vIHVuJ29wemlvbmUiCiAKLSM6IHNldHVwLmM6MjU0CisjOiBzZXR1cC5jOjI1NQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiYW1iaWd1b3VzIGFyZ3VtZW50ICclcyc6IGJvdGggcmV2aXNpb24gYW5kIGZpbGVuYW1lXG4iCkBAIC02Nzc1LDkzICs2ODAxLDkzIEBACiAiVXNhICctLScgcGVyIHNlcGFyYXJlIGkgcGVyY29yc2kgZGFsbGUgcmV2aXNpb25pLCBjb21lIHNlZ3VlOlxuIgogIidnaXQgPGNvbWFuZG8+IFs8cmV2aXNpb25lPi4uLl0gLS0gWzxmaWxlPi4uLl0nIgogCi0jOiBzZXR1cC5jOjM5MAorIzogc2V0dXAuYzozOTEKIG1zZ2lkICJ1bmFibGUgdG8gc2V0IHVwIHdvcmsgdHJlZSB1c2luZyBpbnZhbGlkIGNvbmZpZyIKIG1zZ3N0ciAiIgogImltcG9zc2liaWxlIHByZXBhcmFyZSBsJ2FsYmVybyBkaSBsYXZvcm8gdXNhbmRvIHVuYSBjb25maWd1cmF6aW9uZSBub24gdmFsaWRhIgogCi0jOiBzZXR1cC5jOjM5NAorIzogc2V0dXAuYzozOTUKIG1zZ2lkICJ0aGlzIG9wZXJhdGlvbiBtdXN0IGJlIHJ1biBpbiBhIHdvcmsgdHJlZSIKIG1zZ3N0ciAicXVlc3Qnb3BlcmF6aW9uZSBkZXZlIGVzc2VyZSBlc2VndWl0YSBpbiB1biBhbGJlcm8gZGkgbGF2b3JvIgogCi0jOiBzZXR1cC5jOjU0MAorIzogc2V0dXAuYzo1NDEKICMsIGMtZm9ybWF0CiBtc2dpZCAiRXhwZWN0ZWQgZ2l0IHJlcG8gdmVyc2lvbiA8PSAlZCwgZm91bmQgJWQiCiBtc2dzdHIgIkF0dGVzYSB2ZXJzaW9uZSByZXBvc2l0b3J5IEdpdCA8PSAlZCwgdHJvdmF0YSAlZCIKIAotIzogc2V0dXAuYzo1NDgKKyM6IHNldHVwLmM6NTQ5CiBtc2dpZCAidW5rbm93biByZXBvc2l0b3J5IGV4dGVuc2lvbnMgZm91bmQ6IgogbXNnc3RyICJ0cm92YXRlIGVzdGVuc2lvbmkgcmVwb3NpdG9yeSBzY29ub3NjaXV0ZToiCiAKLSM6IHNldHVwLmM6NTY3CisjOiBzZXR1cC5jOjU2OAogIywgYy1mb3JtYXQKIG1zZ2lkICJlcnJvciBvcGVuaW5nICclcyciCiBtc2dzdHIgImVycm9yZSBkdXJhbnRlIGwnYXBlcnR1cmEgZGkgJyVzJyIKIAotIzogc2V0dXAuYzo1NjkKKyM6IHNldHVwLmM6NTcwCiAjLCBjLWZvcm1hdAogbXNnaWQgInRvbyBsYXJnZSB0byBiZSBhIC5naXQgZmlsZTogJyVzJyIKIG1zZ3N0ciAiJyVzJyB0cm9wcG8gZ3JhbmRlIHBlciBlc3NlcmUgdW4gZmlsZSAuZ2l0IgogCi0jOiBzZXR1cC5jOjU3MQorIzogc2V0dXAuYzo1NzIKICMsIGMtZm9ybWF0CiBtc2dpZCAiZXJyb3IgcmVhZGluZyAlcyIKIG1zZ3N0ciAiZXJyb3JlIGR1cmFudGUgbGEgbGV0dHVyYSBkaSAlcyIKIAotIzogc2V0dXAuYzo1NzMKKyM6IHNldHVwLmM6NTc0CiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgZ2l0ZmlsZSBmb3JtYXQ6ICVzIgogbXNnc3RyICJmb3JtYXRvIGZpbGUgR2l0IG5vbiB2YWxpZG86ICVzIgogCi0jOiBzZXR1cC5jOjU3NQorIzogc2V0dXAuYzo1NzYKICMsIGMtZm9ybWF0CiBtc2dpZCAibm8gcGF0aCBpbiBnaXRmaWxlOiAlcyIKIG1zZ3N0ciAibmVzc3VuIHBlcmNvcnNvIHByZXNlbnRlIG5lbCBmaWxlIEdpdDogJXMiCiAKLSM6IHNldHVwLmM6NTc3CisjOiBzZXR1cC5jOjU3OAogIywgYy1mb3JtYXQKIG1zZ2lkICJub3QgYSBnaXQgcmVwb3NpdG9yeTogJXMiCiBtc2dzdHIgIiVzIG5vbiDDqCB1biByZXBvc2l0b3J5IEdpdCIKIAotIzogc2V0dXAuYzo2NzYKKyM6IHNldHVwLmM6Njc3CiAjLCBjLWZvcm1hdAogbXNnaWQgIickJXMnIHRvbyBiaWciCiBtc2dzdHIgIickJXMnIMOoIHRyb3BwbyBncmFuZGUiCiAKLSM6IHNldHVwLmM6NjkwCisjOiBzZXR1cC5jOjY5MQogIywgYy1mb3JtYXQKIG1zZ2lkICJub3QgYSBnaXQgcmVwb3NpdG9yeTogJyVzJyIKIG1zZ3N0ciAiJyVzJyBub24gw6ggdW4gcmVwb3NpdG9yeSBHaXQiCiAKLSM6IHNldHVwLmM6NzE5IHNldHVwLmM6NzIxIHNldHVwLmM6NzUyCisjOiBzZXR1cC5jOjcyMCBzZXR1cC5jOjcyMiBzZXR1cC5jOjc1MwogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgY2hkaXIgdG8gJyVzJyIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgbW9kaWZpY2FyZSBsYSBkaXJlY3RvcnkgY29ycmVudGUgaW4gJyVzJyIKIAotIzogc2V0dXAuYzo3MjQgc2V0dXAuYzo3ODAgc2V0dXAuYzo3OTAgc2V0dXAuYzo4Mjkgc2V0dXAuYzo4MzcKKyM6IHNldHVwLmM6NzI1IHNldHVwLmM6NzgxIHNldHVwLmM6NzkxIHNldHVwLmM6ODMwIHNldHVwLmM6ODM4CiBtc2dpZCAiY2Fubm90IGNvbWUgYmFjayB0byBjd2QiCiBtc2dzdHIgImltcG9zc2liaWxlIHRvcm5hcmUgYWxsYSBkaXJlY3RvcnkgZGkgbGF2b3JvIGNvcnJlbnRlIgogCi0jOiBzZXR1cC5jOjg1MQorIzogc2V0dXAuYzo4NTIKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIHN0YXQgJyUqcyVzJXMnIgogbXNnc3RyICJzdGF0IGRpICclKnMlcyVzJyBub24gcml1c2NpdG8iCiAKLSM6IHNldHVwLmM6MTA4MworIzogc2V0dXAuYzoxMDkwCiBtc2dpZCAiVW5hYmxlIHRvIHJlYWQgY3VycmVudCB3b3JraW5nIGRpcmVjdG9yeSIKIG1zZ3N0ciAiSW1wb3NzaWJpbGUgbGVnZ2VyZSBsYSBkaXJlY3RvcnkgZGkgbGF2b3JvIGNvcnJlbnRlIgogCi0jOiBzZXR1cC5jOjEwOTIgc2V0dXAuYzoxMDk4CisjOiBzZXR1cC5jOjEwOTkgc2V0dXAuYzoxMTA1CiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCBjaGFuZ2UgdG8gJyVzJyIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgZW50cmFyZSBpbiAnJXMnIgogCi0jOiBzZXR1cC5jOjExMDMKKyM6IHNldHVwLmM6MTExMAogIywgYy1mb3JtYXQKIG1zZ2lkICJub3QgYSBnaXQgcmVwb3NpdG9yeSAob3IgYW55IG9mIHRoZSBwYXJlbnQgZGlyZWN0b3JpZXMpOiAlcyIKIG1zZ3N0ciAiJXMgbm9uIMOoIHVuIHJlcG9zaXRvcnkgR2l0IChuw6kgbG8gw6ggYWxjdW5hIGRlbGxlIGRpcmVjdG9yeSBnZW5pdHJpY2kpIgogCi0jOiBzZXR1cC5jOjExMDkKKyM6IHNldHVwLmM6MTExNgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAibm90IGEgZ2l0IHJlcG9zaXRvcnkgKG9yIGFueSBwYXJlbnQgdXAgdG8gbW91bnQgcG9pbnQgJXMpXG4iCkBAIC02ODcxLDcgKzY4OTcsNyBAQAogIk1pIGZlcm1vIGFsIGxpbWl0ZSBkZWwgZmlsZXN5c3RlbSAobCdvcHppb25lIEdJVF9ESVNDT1ZFUllfQUNST1NTX0ZJTEVTWVNURU0gIgogIm5vbiDDqCBpbXBvc3RhdGEpLiIKIAotIzogc2V0dXAuYzoxMjIwCisjOiBzZXR1cC5jOjEyMjcKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogInByb2JsZW0gd2l0aCBjb3JlLnNoYXJlZFJlcG9zaXRvcnkgZmlsZW1vZGUgdmFsdWUgKDAlLjNvKS5cbiIKQEAgLTY4ODEsMjg5ICs2OTA3LDI4OSBAQAogIigwJS4zbykuXG4iCiAiSWwgcHJvcHJpZXRhcmlvIGRlaSBmaWxlIGRldmUgYXZlcmUgc2VtcHJlIGkgcGVybWVzc2kgZGkgbGV0dHVyYSBlIHNjcml0dHVyYS4iCiAKLSM6IHNldHVwLmM6MTI2NAorIzogc2V0dXAuYzoxMjcxCiBtc2dpZCAib3BlbiAvZGV2L251bGwgb3IgZHVwIGZhaWxlZCIKIG1zZ3N0ciAiYXBlcnR1cmEgZGkgL2Rldi9udWxsIG8gZHVwIG5vbiByaXVzY2l0YSIKIAotIzogc2V0dXAuYzoxMjc5CisjOiBzZXR1cC5jOjEyODYKIG1zZ2lkICJmb3JrIGZhaWxlZCIKIG1zZ3N0ciAiZm9yayBub24gcml1c2NpdGEiCiAKLSM6IHNldHVwLmM6MTI4NAorIzogc2V0dXAuYzoxMjkxCiBtc2dpZCAic2V0c2lkIGZhaWxlZCIKIG1zZ3N0ciAic2V0c2lkIG5vbiByaXVzY2l0YSIKIAotIzogc2hhMS1maWxlLmM6NDUzCisjOiBzaGExLWZpbGUuYzo0NTIKICMsIGMtZm9ybWF0CiBtc2dpZCAib2JqZWN0IGRpcmVjdG9yeSAlcyBkb2VzIG5vdCBleGlzdDsgY2hlY2sgLmdpdC9vYmplY3RzL2luZm8vYWx0ZXJuYXRlcyIKIG1zZ3N0ciAiIgogImxhIGRpcmVjdG9yeSBvZ2dldHRpICVzIG5vbiBlc2lzdGU7IGNvbnRyb2xsYSAuZ2l0L29iamVjdHMvaW5mby9hbHRlcm5hdGVzIgogCi0jOiBzaGExLWZpbGUuYzo1MDQKKyM6IHNoYTEtZmlsZS5jOjUwMwogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gbm9ybWFsaXplIGFsdGVybmF0ZSBvYmplY3QgcGF0aDogJXMiCiBtc2dzdHIgImltcG9zc2liaWxlIG5vcm1hbGl6emFyZSBpbCBwZXJjb3JzbyBhbHRlcm5hdGl2byBvZ2dldHRvOiAlcyIKIAotIzogc2hhMS1maWxlLmM6NTc2CisjOiBzaGExLWZpbGUuYzo1NzUKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXM6IGlnbm9yaW5nIGFsdGVybmF0ZSBvYmplY3Qgc3RvcmVzLCBuZXN0aW5nIHRvbyBkZWVwIgogbXNnc3RyICIiCiAiJXM6IGlnbm9ybyBnbGkgYXJjaGl2aSBvZ2dldHRvIGFsdGVybmF0aXZpLCBsYSBuaWRpZmljYXppb25lIMOoIHRyb3BwbyAiCiAicHJvZm9uZGEiCiAKLSM6IHNoYTEtZmlsZS5jOjU4MworIzogc2hhMS1maWxlLmM6NTgyCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBub3JtYWxpemUgb2JqZWN0IGRpcmVjdG9yeTogJXMiCiBtc2dzdHIgImltcG9zc2liaWxlIG5vcm1hbGl6emFyZSBsYSBkaXJlY3Rvcnkgb2dnZXR0aTogJXMiCiAKLSM6IHNoYTEtZmlsZS5jOjYyNgorIzogc2hhMS1maWxlLmM6NjI1CiBtc2dpZCAidW5hYmxlIHRvIGZkb3BlbiBhbHRlcm5hdGVzIGxvY2tmaWxlIgogbXNnc3RyICJpbXBvc3NpYmlsZSBlc2VndWlyZSBmZG9wZW4gc3VsIGZpbGUgZGkgbG9jayBhbHRlcm5hdGVzIgogCi0jOiBzaGExLWZpbGUuYzo2NDQKKyM6IHNoYTEtZmlsZS5jOjY0MwogbXNnaWQgInVuYWJsZSB0byByZWFkIGFsdGVybmF0ZXMgZmlsZSIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgbGVnZ2VyZSBpbCBmaWxlIGFsdGVybmF0ZXMiCiAKLSM6IHNoYTEtZmlsZS5jOjY1MQorIzogc2hhMS1maWxlLmM6NjUwCiBtc2dpZCAidW5hYmxlIHRvIG1vdmUgbmV3IGFsdGVybmF0ZXMgZmlsZSBpbnRvIHBsYWNlIgogbXNnc3RyICJpbXBvc3NpYmlsZSBzcG9zdGFyZSBpbCBudW92byBmaWxlIGFsdGVybmF0ZXMgbmVsbGEgcG9zaXppb25lIGNvcnJldHRhIgogCi0jOiBzaGExLWZpbGUuYzo2ODYKKyM6IHNoYTEtZmlsZS5jOjY4NQogIywgYy1mb3JtYXQKIG1zZ2lkICJwYXRoICclcycgZG9lcyBub3QgZXhpc3QiCiBtc2dzdHIgImlsIHBlcmNvcnNvICclcycgbm9uIGVzaXN0ZSIKIAotIzogc2hhMS1maWxlLmM6NzEyCisjOiBzaGExLWZpbGUuYzo3MTEKICMsIGMtZm9ybWF0CiBtc2dpZCAicmVmZXJlbmNlIHJlcG9zaXRvcnkgJyVzJyBhcyBhIGxpbmtlZCBjaGVja291dCBpcyBub3Qgc3VwcG9ydGVkIHlldC4iCiBtc2dzdHIgIiIKICJsJ2FnZ2l1bnRhIGRlbCByZXBvc2l0b3J5IGRpIHJpZmVyaW1lbnRvICclcycgY29tZSBjaGVja291dCBjb2xsZWdhdG8gbm9uIMOoICIKICJhbmNvcmEgc3VwcG9ydGF0YS4iCiAKLSM6IHNoYTEtZmlsZS5jOjcxOAorIzogc2hhMS1maWxlLmM6NzE3CiAjLCBjLWZvcm1hdAogbXNnaWQgInJlZmVyZW5jZSByZXBvc2l0b3J5ICclcycgaXMgbm90IGEgbG9jYWwgcmVwb3NpdG9yeS4iCiBtc2dzdHIgImlsIHJlcG9zaXRvcnkgZGkgcmlmZXJpbWVudG8gJyVzJyBub24gw6ggdW4gcmVwb3NpdG9yeSBsb2NhbGUuIgogCi0jOiBzaGExLWZpbGUuYzo3MjQKKyM6IHNoYTEtZmlsZS5jOjcyMwogIywgYy1mb3JtYXQKIG1zZ2lkICJyZWZlcmVuY2UgcmVwb3NpdG9yeSAnJXMnIGlzIHNoYWxsb3ciCiBtc2dzdHIgImlsIHJlcG9zaXRvcnkgZGkgcmlmZXJpbWVudG8gJyVzJyDDqCBzaGFsbG93IgogCi0jOiBzaGExLWZpbGUuYzo3MzIKKyM6IHNoYTEtZmlsZS5jOjczMQogIywgYy1mb3JtYXQKIG1zZ2lkICJyZWZlcmVuY2UgcmVwb3NpdG9yeSAnJXMnIGlzIGdyYWZ0ZWQiCiBtc2dzdHIgImlsIHJlcG9zaXRvcnkgZGkgcmlmZXJpbWVudG8gJyVzJyDDqCB1biBncmFmdCIKIAotIzogc2hhMS1maWxlLmM6NzkyCisjOiBzaGExLWZpbGUuYzo3OTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBsaW5lIHdoaWxlIHBhcnNpbmcgYWx0ZXJuYXRlIHJlZnM6ICVzIgogbXNnc3RyICJyaWdhIG5vbiB2YWxpZGEgZHVyYW50ZSBsJ2FuYWxpc2kgZGVpIHJpZmVyaW1lbnRpIGRlZ2xpIGFsdGVybmF0aTogJXMiCiAKLSM6IHNoYTEtZmlsZS5jOjk0NAorIzogc2hhMS1maWxlLmM6OTQzCiAjLCBjLWZvcm1hdAogbXNnaWQgImF0dGVtcHRpbmcgdG8gbW1hcCAlPFBSSXVNQVg+IG92ZXIgbGltaXQgJTxQUkl1TUFYPiIKIG1zZ3N0ciAidGVudG8gZGkgZXNlZ3VpcmUgbW1hcCAlPFBSSXVNQVg+IGFsIGRpIHNvcHJhIGRlbCBsaW1pdGUgJTxQUkl1TUFYPiIKIAotIzogc2hhMS1maWxlLmM6OTY5CisjOiBzaGExLWZpbGUuYzo5NjQKIG1zZ2lkICJtbWFwIGZhaWxlZCIKIG1zZ3N0ciAibW1hcCBub24gcml1c2NpdGEiCiAKLSM6IHNoYTEtZmlsZS5jOjExMzMKKyM6IHNoYTEtZmlsZS5jOjExMjgKICMsIGMtZm9ybWF0CiBtc2dpZCAib2JqZWN0IGZpbGUgJXMgaXMgZW1wdHkiCiBtc2dzdHIgImwnb2dnZXR0byAlcyDDqCB2dW90byIKIAotIzogc2hhMS1maWxlLmM6MTI1NyBzaGExLWZpbGUuYzoyMzk2CisjOiBzaGExLWZpbGUuYzoxMjUyIHNoYTEtZmlsZS5jOjIzOTIKICMsIGMtZm9ybWF0CiBtc2dpZCAiY29ycnVwdCBsb29zZSBvYmplY3QgJyVzJyIKIG1zZ3N0ciAib2dnZXR0byBzY2lvbHRvICclcycgY29ycm90dG8iCiAKLSM6IHNoYTEtZmlsZS5jOjEyNTkgc2hhMS1maWxlLmM6MjQwMAorIzogc2hhMS1maWxlLmM6MTI1NCBzaGExLWZpbGUuYzoyMzk2CiAjLCBjLWZvcm1hdAogbXNnaWQgImdhcmJhZ2UgYXQgZW5kIG9mIGxvb3NlIG9iamVjdCAnJXMnIgogbXNnc3RyICJkYXRpIGludXRpbGl6emFiaWxpIHByZXNlbnRpIGFsbGEgZmluZSBkZWxsJ29nZ2V0dG8gc2Npb2x0byAnJXMnIgogCi0jOiBzaGExLWZpbGUuYzoxMzAxCisjOiBzaGExLWZpbGUuYzoxMjk2CiBtc2dpZCAiaW52YWxpZCBvYmplY3QgdHlwZSIKIG1zZ3N0ciAidGlwbyBvZ2dldHRvIG5vbiB2YWxpZG8iCiAKLSM6IHNoYTEtZmlsZS5jOjEzODUKKyM6IHNoYTEtZmlsZS5jOjEzODAKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHVucGFjayAlcyBoZWFkZXIgd2l0aCAtLWFsbG93LXVua25vd24tdHlwZSIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgZGVjb21wcmltZXJlIGwnaW50ZXN0YXppb25lICVzIGNvbiAtLWFsbG93LXVua25vd24tdHlwZSIKIAotIzogc2hhMS1maWxlLmM6MTM4OAorIzogc2hhMS1maWxlLmM6MTM4MwogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gdW5wYWNrICVzIGhlYWRlciIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgZGVjb21wcmltZXJlIGwnaW50ZXN0YXppb25lICVzIgogCi0jOiBzaGExLWZpbGUuYzoxMzk0CisjOiBzaGExLWZpbGUuYzoxMzg5CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBwYXJzZSAlcyBoZWFkZXIgd2l0aCAtLWFsbG93LXVua25vd24tdHlwZSIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgYW5hbGl6emFyZSBsJ2ludGVzdGF6aW9uZSAlcyBjb24gLS1hbGxvdy11bmtub3duLXR5cGUiCiAKLSM6IHNoYTEtZmlsZS5jOjEzOTcKKyM6IHNoYTEtZmlsZS5jOjEzOTIKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHBhcnNlICVzIGhlYWRlciIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgYW5hbGl6emFyZSBsJ2ludGVzdGF6aW9uZSAlcyIKIAotIzogc2hhMS1maWxlLmM6MTU4OAorIzogc2hhMS1maWxlLmM6MTU4NAogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gcmVhZCBvYmplY3QgJXMiCiBtc2dzdHIgImxldHR1cmEgZGVsbCdvZ2dldHRvICVzIG5vbiByaXVzY2l0YSIKIAotIzogc2hhMS1maWxlLmM6MTU5MgorIzogc2hhMS1maWxlLmM6MTU4OAogIywgYy1mb3JtYXQKIG1zZ2lkICJyZXBsYWNlbWVudCAlcyBub3QgZm91bmQgZm9yICVzIgogbXNnc3RyICIlcyBzb3N0aXR1dGl2byBub24gdHJvdmF0byBwZXIgJXMiCiAKLSM6IHNoYTEtZmlsZS5jOjE1OTYKKyM6IHNoYTEtZmlsZS5jOjE1OTIKICMsIGMtZm9ybWF0CiBtc2dpZCAibG9vc2Ugb2JqZWN0ICVzIChzdG9yZWQgaW4gJXMpIGlzIGNvcnJ1cHQiCiBtc2dzdHIgImwnb2dnZXR0byBzY2lvbHRvICVzIChzYWx2YXRvIGluICVzKSDDqCBjb3Jyb3R0byIKIAotIzogc2hhMS1maWxlLmM6MTYwMAorIzogc2hhMS1maWxlLmM6MTU5NgogIywgYy1mb3JtYXQKIG1zZ2lkICJwYWNrZWQgb2JqZWN0ICVzIChzdG9yZWQgaW4gJXMpIGlzIGNvcnJ1cHQiCiBtc2dzdHIgImwnb2dnZXR0byBhcmNoaXZpYXRvICVzIChzYWx2YXRvIGluICVzKSDDqCBjb3Jyb3R0byIKIAotIzogc2hhMS1maWxlLmM6MTcwMworIzogc2hhMS1maWxlLmM6MTY5OQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gd3JpdGUgZmlsZSAlcyIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgc2NyaXZlcmUgaWwgZmlsZSAlcyIKIAotIzogc2hhMS1maWxlLmM6MTcxMAorIzogc2hhMS1maWxlLmM6MTcwNgogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gc2V0IHBlcm1pc3Npb24gdG8gJyVzJyIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgaW1wb3N0YXJlIGkgcGVybWVzc2kgYSAnJXMnIgogCi0jOiBzaGExLWZpbGUuYzoxNzE3CisjOiBzaGExLWZpbGUuYzoxNzEzCiBtc2dpZCAiZmlsZSB3cml0ZSBlcnJvciIKIG1zZ3N0ciAiZXJyb3JlIGRpIHNjcml0dHVyYSBkZWwgZmlsZSIKIAotIzogc2hhMS1maWxlLmM6MTczNgorIzogc2hhMS1maWxlLmM6MTczMgogbXNnaWQgImVycm9yIHdoZW4gY2xvc2luZyBsb29zZSBvYmplY3QgZmlsZSIKIG1zZ3N0ciAiZXJyb3JlIGR1cmFudGUgbGEgY2hpdXN1cmEgZGVsIGZpbGUgb2dnZXR0byBzY2lvbHRvIgogCi0jOiBzaGExLWZpbGUuYzoxODAxCisjOiBzaGExLWZpbGUuYzoxNzk3CiAjLCBjLWZvcm1hdAogbXNnaWQgImluc3VmZmljaWVudCBwZXJtaXNzaW9uIGZvciBhZGRpbmcgYW4gb2JqZWN0IHRvIHJlcG9zaXRvcnkgZGF0YWJhc2UgJXMiCiBtc2dzdHIgIiIKICJwZXJtZXNzaSBub24gc3VmZmljaWVudGkgcGVyIGwnYWdnaXVudGEgZGkgdW4gb2dnZXR0byBhbCBkYXRhYmFzZSByZXBvc2l0b3J5ICIKICIlcyIKIAotIzogc2hhMS1maWxlLmM6MTgwMworIzogc2hhMS1maWxlLmM6MTc5OQogbXNnaWQgInVuYWJsZSB0byBjcmVhdGUgdGVtcG9yYXJ5IGZpbGUiCiBtc2dzdHIgImltcG9zc2liaWxlIGNyZWFyZSBpbCBmaWxlIHRlbXBvcmFuZW8iCiAKLSM6IHNoYTEtZmlsZS5jOjE4MjcKKyM6IHNoYTEtZmlsZS5jOjE4MjMKIG1zZ2lkICJ1bmFibGUgdG8gd3JpdGUgbG9vc2Ugb2JqZWN0IGZpbGUiCiBtc2dzdHIgImltcG9zc2liaWxlIHNjcml2ZXJlIGlsIGZpbGUgb2dnZXR0byBzY2lvbHRvIgogCi0jOiBzaGExLWZpbGUuYzoxODMzCisjOiBzaGExLWZpbGUuYzoxODI5CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBkZWZsYXRlIG5ldyBvYmplY3QgJXMgKCVkKSIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgY29tcHJpbWVyZSBjb24gZGVmbGF0ZSBpbCBudW92byBvZ2dldHRvICVzICglZCkiCiAKLSM6IHNoYTEtZmlsZS5jOjE4MzcKKyM6IHNoYTEtZmlsZS5jOjE4MzMKICMsIGMtZm9ybWF0CiBtc2dpZCAiZGVmbGF0ZUVuZCBvbiBvYmplY3QgJXMgZmFpbGVkICglZCkiCiBtc2dzdHIgImRlZmxhdGVFbmQgbm9uIHJpdXNjaXRhIHN1bGwnb2dnZXR0byAlcyAoJWQpIgogCi0jOiBzaGExLWZpbGUuYzoxODQxCisjOiBzaGExLWZpbGUuYzoxODM3CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvbmZ1c2VkIGJ5IHVuc3RhYmxlIG9iamVjdCBzb3VyY2UgZGF0YSBmb3IgJXMiCiBtc2dzdHIgInNvbm8gY29uZnVzbyBkYWxsJ29yaWdpbmUgZGF0aSBvZ2dldHRvIG5vbiBzdGFiaWxlIHBlciAlcyIKIAotIzogc2hhMS1maWxlLmM6MTg1MSBidWlsdGluL3BhY2stb2JqZWN0cy5jOjkyNQorIzogc2hhMS1maWxlLmM6MTg0NyBidWlsdGluL3BhY2stb2JqZWN0cy5jOjkyNQogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdXRpbWUoKSBvbiAlcyIKIG1zZ3N0ciAidXRpbWUoKSBkaSAlcyBub24gcml1c2NpdGEiCiAKLSM6IHNoYTEtZmlsZS5jOjE5MjYKKyM6IHNoYTEtZmlsZS5jOjE5MjIKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IHJlYWQgb2JqZWN0IGZvciAlcyIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgbGVnZ2VyZSBsJ29nZ2V0dG8gcGVyICVzIgogCi0jOiBzaGExLWZpbGUuYzoxOTY2CisjOiBzaGExLWZpbGUuYzoxOTYyCiBtc2dpZCAiY29ycnVwdCBjb21taXQiCiBtc2dzdHIgImNvbW1pdCBjb3Jyb3R0byIKIAotIzogc2hhMS1maWxlLmM6MTk3NAorIzogc2hhMS1maWxlLmM6MTk3MAogbXNnaWQgImNvcnJ1cHQgdGFnIgogbXNnc3RyICJ0YWcgY29ycm90dG8iCiAKLSM6IHNoYTEtZmlsZS5jOjIwNzMKKyM6IHNoYTEtZmlsZS5jOjIwNjkKICMsIGMtZm9ybWF0CiBtc2dpZCAicmVhZCBlcnJvciB3aGlsZSBpbmRleGluZyAlcyIKIG1zZ3N0ciAiZXJyb3JlIGRpIGxldHR1cmEgZHVyYW50ZSBsJ2luZGljaXp6YXppb25lIGRpICVzIgogCi0jOiBzaGExLWZpbGUuYzoyMDc2CisjOiBzaGExLWZpbGUuYzoyMDcyCiAjLCBjLWZvcm1hdAogbXNnaWQgInNob3J0IHJlYWQgd2hpbGUgaW5kZXhpbmcgJXMiCiBtc2dzdHIgImxldHR1cmEgdHJvcHBvIGJyZXZlIGR1cmFudGUgbCdpbmRpY2l6emF6aW9uZSBkaSAlcyIKIAotIzogc2hhMS1maWxlLmM6MjE0OSBzaGExLWZpbGUuYzoyMTU4CisjOiBzaGExLWZpbGUuYzoyMTQ1IHNoYTEtZmlsZS5jOjIxNTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXM6IGZhaWxlZCB0byBpbnNlcnQgaW50byBkYXRhYmFzZSIKIG1zZ3N0ciAiJXM6IGluc2VyaW1lbnRvIGRlbCByZWNvcmQgbmVsIGRhdGFiYXNlIG5vbiByaXVzY2l0byIKIAotIzogc2hhMS1maWxlLmM6MjE2NAorIzogc2hhMS1maWxlLmM6MjE2MAogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogdW5zdXBwb3J0ZWQgZmlsZSB0eXBlIgogbXNnc3RyICIlczogdGlwbyBkaSBmaWxlIG5vbiBzdXBwb3J0YXRvIgogCi0jOiBzaGExLWZpbGUuYzoyMTg4CisjOiBzaGExLWZpbGUuYzoyMTg0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIGlzIG5vdCBhIHZhbGlkIG9iamVjdCIKIG1zZ3N0ciAiJXMgbm9uIMOoIHVuIG9nZ2V0dG8gdmFsaWRvIgogCi0jOiBzaGExLWZpbGUuYzoyMTkwCisjOiBzaGExLWZpbGUuYzoyMTg2CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIGlzIG5vdCBhIHZhbGlkICclcycgb2JqZWN0IgogbXNnc3RyICIlcyBub24gw6ggdW4gb2dnZXR0byAnJXMnIHZhbGlkbyIKIAotIzogc2hhMS1maWxlLmM6MjIxNyBidWlsdGluL2luZGV4LXBhY2suYzoxNTUKKyM6IHNoYTEtZmlsZS5jOjIyMTMgYnVpbHRpbi9pbmRleC1wYWNrLmM6MTU1CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBvcGVuICVzIgogbXNnc3RyICJpbXBvc3NpYmlsZSBhcHJpcmUgJXMiCiAKLSM6IHNoYTEtZmlsZS5jOjI0MDcgc2hhMS1maWxlLmM6MjQ1OQorIzogc2hhMS1maWxlLmM6MjQwMyBzaGExLWZpbGUuYzoyNDU1CiAjLCBjLWZvcm1hdAogbXNnaWQgImhhc2ggbWlzbWF0Y2ggZm9yICVzIChleHBlY3RlZCAlcykiCiBtc2dzdHIgIm1hbmNhdGEgY29ycmlzcG9uZGVuemEgcGVyICVzIChhdHRlc28gJXMpIgogCi0jOiBzaGExLWZpbGUuYzoyNDMxCisjOiBzaGExLWZpbGUuYzoyNDI3CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBtbWFwICVzIgogbXNnc3RyICJpbXBvc3NpYmlsZSBlc2VndWlyZSBtbWFwIHN1ICVzIgogCi0jOiBzaGExLWZpbGUuYzoyNDM2CisjOiBzaGExLWZpbGUuYzoyNDMyCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byB1bnBhY2sgaGVhZGVyIG9mICVzIgogbXNnc3RyICJpbXBvc3NpYmlsZSBkZWNvbXByaW1lcmUgbCdpbnRlc3RhemlvbmUgZGkgJXMiCiAKLSM6IHNoYTEtZmlsZS5jOjI0NDIKKyM6IHNoYTEtZmlsZS5jOjI0MzgKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHBhcnNlIGhlYWRlciBvZiAlcyIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgYW5hbGl6emFyZSBsJ2ludGVzdGF6aW9uZSBkaSAlcyIKIAotIzogc2hhMS1maWxlLmM6MjQ1MworIzogc2hhMS1maWxlLmM6MjQ0OQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gdW5wYWNrIGNvbnRlbnRzIG9mICVzIgogbXNnc3RyICJpbXBvc3NpYmlsZSBkZWNvbXByaW1lcmUgaSBjb250ZW51dGkgZGkgJXMiCiAKLSM6IHNoYTEtbmFtZS5jOjQ5MAorIzogc2hhMS1uYW1lLmM6NDg3CiAjLCBjLWZvcm1hdAogbXNnaWQgInNob3J0IFNIQTEgJXMgaXMgYW1iaWd1b3VzIgogbXNnc3RyICJsbyBTSEExIGJyZXZlICVzIMOoIGFtYmlndW8iCiAKLSM6IHNoYTEtbmFtZS5jOjUwMQorIzogc2hhMS1uYW1lLmM6NDk4CiBtc2dpZCAiVGhlIGNhbmRpZGF0ZXMgYXJlOiIKIG1zZ3N0ciAiSSBjYW5kaWRhdGkgc29ubzoiCiAKLSM6IHNoYTEtbmFtZS5jOjgwMAorIzogc2hhMS1uYW1lLmM6Nzk3CiBtc2dpZCAiIgogIkdpdCBub3JtYWxseSBuZXZlciBjcmVhdGVzIGEgcmVmIHRoYXQgZW5kcyB3aXRoIDQwIGhleCBjaGFyYWN0ZXJzXG4iCiAiYmVjYXVzZSBpdCB3aWxsIGJlIGlnbm9yZWQgd2hlbiB5b3UganVzdCBzcGVjaWZ5IDQwLWhleC4gVGhlc2UgcmVmc1xuIgpAQCAtNzE4OCw0MyArNzIxNCw0MyBAQAogIm1lc3NhZ2dpbyBlc2VndWVuZG8gXCJnaXQgY29uZmlnIGFkdmljZS5vYmplY3ROYW1lV2FybmluZyBmYWxzZVwiIgogCiAjLiBUUkFOU0xBVE9SUzogSUVDIDgwMDAwLTEzOjIwMDggZ2liaWJ5dGUKLSM6IHN0cmJ1Zi5jOjgyMQorIzogc3RyYnVmLmM6ODIyCiAjLCBjLWZvcm1hdAogbXNnaWQgIiV1LiUyLjJ1IEdpQiIKIG1zZ3N0ciAiJXUuJTIuMnUgR2lCIgogCiAjLiBUUkFOU0xBVE9SUzogSUVDIDgwMDAwLTEzOjIwMDggZ2liaWJ5dGUvc2Vjb25kCi0jOiBzdHJidWYuYzo4MjMKKyM6IHN0cmJ1Zi5jOjgyNAogIywgYy1mb3JtYXQKIG1zZ2lkICIldS4lMi4ydSBHaUIvcyIKIG1zZ3N0ciAiJXUuJTIuMnUgR2lCL3MiCiAKICMuIFRSQU5TTEFUT1JTOiBJRUMgODAwMDAtMTM6MjAwOCBtZWJpYnl0ZQotIzogc3RyYnVmLmM6ODMxCisjOiBzdHJidWYuYzo4MzIKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXUuJTIuMnUgTWlCIgogbXNnc3RyICIldS4lMi4ydSBNaUIiCiAKICMuIFRSQU5TTEFUT1JTOiBJRUMgODAwMDAtMTM6MjAwOCBtZWJpYnl0ZS9zZWNvbmQKLSM6IHN0cmJ1Zi5jOjgzMworIzogc3RyYnVmLmM6ODM0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiV1LiUyLjJ1IE1pQi9zIgogbXNnc3RyICIldS4lMi4ydSBNaUIvcyIKIAogIy4gVFJBTlNMQVRPUlM6IElFQyA4MDAwMC0xMzoyMDA4IGtpYmlieXRlCi0jOiBzdHJidWYuYzo4NDAKKyM6IHN0cmJ1Zi5jOjg0MQogIywgYy1mb3JtYXQKIG1zZ2lkICIldS4lMi4ydSBLaUIiCiBtc2dzdHIgIiV1LiUyLjJ1IEtpQiIKIAogIy4gVFJBTlNMQVRPUlM6IElFQyA4MDAwMC0xMzoyMDA4IGtpYmlieXRlL3NlY29uZAotIzogc3RyYnVmLmM6ODQyCisjOiBzdHJidWYuYzo4NDMKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXUuJTIuMnUgS2lCL3MiCiBtc2dzdHIgIiV1LiUyLjJ1IEtpQi9zIgogCiAjLiBUUkFOU0xBVE9SUzogSUVDIDgwMDAwLTEzOjIwMDggYnl0ZQotIzogc3RyYnVmLmM6ODQ4CisjOiBzdHJidWYuYzo4NDkKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXUgYnl0ZSIKIG1zZ2lkX3BsdXJhbCAiJXUgYnl0ZXMiCkBAIC03MjMyLDcgKzcyNTgsNyBAQAogbXNnc3RyWzFdICIldSBieXRlIgogCiAjLiBUUkFOU0xBVE9SUzogSUVDIDgwMDAwLTEzOjIwMDggYnl0ZS9zZWNvbmQKLSM6IHN0cmJ1Zi5jOjg1MAorIzogc3RyYnVmLmM6ODUxCiAjLCBjLWZvcm1hdAogbXNnaWQgIiV1IGJ5dGUvcyIKIG1zZ2lkX3BsdXJhbCAiJXUgYnl0ZXMvcyIKQEAgLTczNTMsMjggKzczNzksMjggQEAKIG1zZ2lkICJscy10cmVlIHJldHVybmVkIHVuZXhwZWN0ZWQgcmV0dXJuIGNvZGUgJWQiCiBtc2dzdHIgImxzLXRyZWUgaGEgcmVzdGl0dWl0byBpbCB2YWxvcmUgZGkgcml0b3JubyBpbmF0dGVzbyAlZCIKIAotIzogc3VibW9kdWxlLWNvbmZpZy5jOjIzMgorIzogc3VibW9kdWxlLWNvbmZpZy5jOjIzNgogIywgYy1mb3JtYXQKIG1zZ2lkICJpZ25vcmluZyBzdXNwaWNpb3VzIHN1Ym1vZHVsZSBuYW1lOiAlcyIKIG1zZ3N0ciAiaWdub3JvIHVuIG5vbWUgc290dG9tb2R1bG8gc29zcGV0dG86ICVzIgogCi0jOiBzdWJtb2R1bGUtY29uZmlnLmM6Mjk5CisjOiBzdWJtb2R1bGUtY29uZmlnLmM6MzAzCiBtc2dpZCAibmVnYXRpdmUgdmFsdWVzIG5vdCBhbGxvd2VkIGZvciBzdWJtb2R1bGUuZmV0Y2hqb2JzIgogbXNnc3RyICJpIHZhbG9yaSBuZWdhdGl2aSBub24gc29ubyBjb25zZW50aXRpIHBlciBzdWJtb2R1bGUuZmV0Y2hqb2JzIgogCi0jOiBzdWJtb2R1bGUtY29uZmlnLmM6Mzk3CisjOiBzdWJtb2R1bGUtY29uZmlnLmM6NDAxCiAjLCBjLWZvcm1hdAogbXNnaWQgImlnbm9yaW5nICclcycgd2hpY2ggbWF5IGJlIGludGVycHJldGVkIGFzIGEgY29tbWFuZC1saW5lIG9wdGlvbjogJXMiCiBtc2dzdHIgIiIKICJpZ25vcm8gJyVzJyBjaGUgcG90cmViYmUgZXNzZXJlIGludGVycHJldGF0byBjb21lIGFyZ29tZW50byBkZWxsYSByaWdhIGRpICIKICJjb21hbmRvOiAlcyIKIAotIzogc3VibW9kdWxlLWNvbmZpZy5jOjQ4NgorIzogc3VibW9kdWxlLWNvbmZpZy5jOjQ5MAogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIHZhbHVlIGZvciAlcyIKIG1zZ3N0ciAidmFsb3JlIG5vbiB2YWxpZG8gcGVyICVzIgogCi0jOiBzdWJtb2R1bGUtY29uZmlnLmM6NzU1CisjOiBzdWJtb2R1bGUtY29uZmlnLmM6NzYxCiAjLCBjLWZvcm1hdAogbXNnaWQgIkNvdWxkIG5vdCB1cGRhdGUgLmdpdG1vZHVsZXMgZW50cnkgJXMiCiBtc2dzdHIgIkltcG9zc2liaWxlIGFnZ2lvcm5hcmUgbGEgdm9jZSAuZ2l0bW9kdWxlcyAlcyIKQEAgLTc0MDksNyArNzQzNSw3IEBACiBtc2dpZCAiY291bGQgbm90IHJlYWQgZnJvbSBzdGRpbiIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgbGVnZ2VyZSBkYWxsbyBzdGFuZGFyZCBpbnB1dCIKIAotIzogdHJhaWxlci5jOjEwMTEgd3JhcHBlci5jOjcwMQorIzogdHJhaWxlci5jOjEwMTEgd3JhcHBlci5jOjY2NQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3Qgc3RhdCAlcyIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgZXNlZ3VpcmUgbG8gc3RhdCBkaSAnJXMnIgpAQCAtNzQzOCw0NyArNzQ2NCw0NyBAQAogbXNnaWQgIldvdWxkIHNldCB1cHN0cmVhbSBvZiAnJXMnIHRvICclcycgb2YgJyVzJ1xuIgogbXNnc3RyICJMJ3Vwc3RyZWFtIGRpICclcycgc2FyZWJiZSBpbXBvc3RhdG8gYSAnJXMnIGRpICclcydcbiIKIAotIzogdHJhbnNwb3J0LmM6MTQyCisjOiB0cmFuc3BvcnQuYzoxNDUKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHJlYWQgYnVuZGxlICclcyciCiBtc2dzdHIgImltcG9zc2liaWxlIGxlZ2dlcmUgaWwgYnVuZGxlICclcyciCiAKLSM6IHRyYW5zcG9ydC5jOjIwOAorIzogdHJhbnNwb3J0LmM6MjE0CiAjLCBjLWZvcm1hdAogbXNnaWQgInRyYW5zcG9ydDogaW52YWxpZCBkZXB0aCBvcHRpb24gJyVzJyIKIG1zZ3N0ciAidHJhc3BvcnRvOiBvcHppb25lIHByb2ZvbmRpdMOgICclcycgbm9uIHZhbGlkYSIKIAotIzogdHJhbnNwb3J0LmM6MjU5CisjOiB0cmFuc3BvcnQuYzoyNjYKIG1zZ2lkICJzZWUgcHJvdG9jb2wudmVyc2lvbiBpbiAnZ2l0IGhlbHAgY29uZmlnJyBmb3IgbW9yZSBkZXRhaWxzIgogbXNnc3RyICJ2ZWRpIHByb3RvY29sLnZlcnNpb24gaW4gJ2dpdCBoZWxwIGNvbmZpZycgcGVyIG1hZ2dpb3JpIGRldHRhZ2xpIgogCi0jOiB0cmFuc3BvcnQuYzoyNjAKKyM6IHRyYW5zcG9ydC5jOjI2NwogbXNnaWQgInNlcnZlciBvcHRpb25zIHJlcXVpcmUgcHJvdG9jb2wgdmVyc2lvbiAyIG9yIGxhdGVyIgogbXNnc3RyICJsZSBvcHppb25pIHNlcnZlciByaWNoaWVkb25vIGxhIHZlcnNpb25lIDIgbyBzdWNjZXNzaXZhIGRlbCBwcm90b2NvbGxvIgogCi0jOiB0cmFuc3BvcnQuYzo2MjUKKyM6IHRyYW5zcG9ydC5jOjYzMgogbXNnaWQgImNvdWxkIG5vdCBwYXJzZSB0cmFuc3BvcnQuY29sb3IuKiBjb25maWciCiBtc2dzdHIgImltcG9zc2liaWxlIGFuYWxpenphcmUgbGEgY29uZmlndXJhemlvbmUgdHJhbnNwb3J0LmNvbG9yLioiCiAKLSM6IHRyYW5zcG9ydC5jOjY5OAorIzogdHJhbnNwb3J0LmM6NzA1CiBtc2dpZCAic3VwcG9ydCBmb3IgcHJvdG9jb2wgdjIgbm90IGltcGxlbWVudGVkIHlldCIKIG1zZ3N0ciAic3VwcG9ydG8gYWxsYSB2ZXJzaW9uZSAyIGRlbCBwcm90b2NvbGxvIG5vbiBhbmNvcmEgaW1wbGVtZW50YXRvIgogCi0jOiB0cmFuc3BvcnQuYzo4MjUKKyM6IHRyYW5zcG9ydC5jOjgzMQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmtub3duIHZhbHVlIGZvciBjb25maWcgJyVzJzogJXMiCiBtc2dzdHIgInZhbG9yZSBzY29ub3NjaXV0byBwZXIgbGEgY29uZmlndXJhemlvbmUgJyVzJzogJXMiCiAKLSM6IHRyYW5zcG9ydC5jOjg5MQorIzogdHJhbnNwb3J0LmM6ODk3CiAjLCBjLWZvcm1hdAogbXNnaWQgInRyYW5zcG9ydCAnJXMnIG5vdCBhbGxvd2VkIgogbXNnc3RyICJ0cmFzcG9ydG8gJyVzJyBub24gY29uc2VudGl0byIKIAotIzogdHJhbnNwb3J0LmM6OTQ1CisjOiB0cmFuc3BvcnQuYzo5NDkKIG1zZ2lkICJnaXQtb3Zlci1yc3luYyBpcyBubyBsb25nZXIgc3VwcG9ydGVkIgogbXNnc3RyICJnaXQtb3Zlci1yc3luYyBub24gw6ggcGnDuSBzdXBwb3J0YXRvIgogCi0jOiB0cmFuc3BvcnQuYzoxMDQwCisjOiB0cmFuc3BvcnQuYzoxMDQ0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgZm9sbG93aW5nIHN1Ym1vZHVsZSBwYXRocyBjb250YWluIGNoYW5nZXMgdGhhdCBjYW5cbiIKQEAgLTc0ODcsNyArNzUxMyw3IEBACiAiSSBzZWd1ZW50aSBwZXJjb3JzaSBzb3R0b21vZHVsbyBjb250ZW5nb25vIG1vZGlmaWNoZVxuIgogIm5vbiB0cm92YXRlIHN1IG5lc3N1biByZW1vdG86XG4iCiAKLSM6IHRyYW5zcG9ydC5jOjEwNDQKKyM6IHRyYW5zcG9ydC5jOjEwNDgKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlxuIgpAQCAtNzUxNCwzMiArNzU0MCwzMiBAQAogInBlciBlc2VndWlybmUgaWwgcHVzaCBhIHVuIHJlbW90by5cbiIKICJcbiIKIAotIzogdHJhbnNwb3J0LmM6MTA1MgorIzogdHJhbnNwb3J0LmM6MTA1NgogbXNnaWQgIkFib3J0aW5nLiIKIG1zZ3N0ciAiSW50ZXJyb21wbyBsJ29wZXJhemlvbmUuIgogCi0jOiB0cmFuc3BvcnQuYzoxMTkzCisjOiB0cmFuc3BvcnQuYzoxMjAxCiBtc2dpZCAiZmFpbGVkIHRvIHB1c2ggYWxsIG5lZWRlZCBzdWJtb2R1bGVzIgogbXNnc3RyICJwdXNoIGRpIHR1dHRpIGkgc290dG9tb2R1bGkgcmljaGllc3RpIG5vbiByaXVzY2l0byIKIAotIzogdHJhbnNwb3J0LmM6MTM0MCB0cmFuc3BvcnQtaGVscGVyLmM6NjQ1CisjOiB0cmFuc3BvcnQuYzoxMzQ1IHRyYW5zcG9ydC1oZWxwZXIuYzo2NTUKIG1zZ2lkICJvcGVyYXRpb24gbm90IHN1cHBvcnRlZCBieSBwcm90b2NvbCIKIG1zZ3N0ciAib3BlcmF6aW9uZSBub24gc3VwcG9ydGF0YSBkYWwgcHJvdG9jb2xsbyIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjUxIHRyYW5zcG9ydC1oZWxwZXIuYzo4MAorIzogdHJhbnNwb3J0LWhlbHBlci5jOjYxIHRyYW5zcG9ydC1oZWxwZXIuYzo5MAogbXNnaWQgImZ1bGwgd3JpdGUgdG8gcmVtb3RlIGhlbHBlciBmYWlsZWQiCiBtc2dzdHIgInNjcml0dHVyYSBjb21wbGV0YSB2ZXJzbyBsJ2hlbHBlciByZW1vdG8gbm9uIHJpdXNjaXRhIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6MTM0CisjOiB0cmFuc3BvcnQtaGVscGVyLmM6MTQ0CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBmaW5kIHJlbW90ZSBoZWxwZXIgZm9yICclcyciCiBtc2dzdHIgImltcG9zc2liaWxlIHRyb3ZhcmUgbCdoZWxwZXIgcmVtb3RvIHBlciAnJXMnIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6MTUwIHRyYW5zcG9ydC1oZWxwZXIuYzo1NTkKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxNjAgdHJhbnNwb3J0LWhlbHBlci5jOjU2OQogbXNnaWQgImNhbid0IGR1cCBoZWxwZXIgb3V0cHV0IGZkIgogbXNnc3RyICJpbXBvc3NpYmlsZSBkdXBsaWNhcmUgaWwgZGVzY3JpdHRvcmUgZmlsZSBkZWxsJ291dHB1dCBoZWxwZXIiCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzoyMDEKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzoyMTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogInVua25vd24gbWFuZGF0b3J5IGNhcGFiaWxpdHkgJXM7IHRoaXMgcmVtb3RlIGhlbHBlciBwcm9iYWJseSBuZWVkcyBuZXdlciAiCkBAIC03NTQ4LDEwMyArNzU3NCwxMDggQEAKICJjYXBhYmlsaXR5IG5lY2Vzc2FyaWEgJXMgc2Nvbm9zY2l1dGE7IHF1ZXN0J2hlbHBlciByZW1vdG8gcHJvYmFiaWxtZW50ZSAiCiAicmljaGllZGUgdW5hIHZlcnNpb25lIGRpIEdpdCBwacO5IHJlY2VudGUiCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzoyMDcKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzoyMTcKIG1zZ2lkICJ0aGlzIHJlbW90ZSBoZWxwZXIgc2hvdWxkIGltcGxlbWVudCByZWZzcGVjIGNhcGFiaWxpdHkiCiBtc2dzdHIgInF1ZXN0byBoZWxwZXIgcmVtb3RvIGRvdnJlYmJlIGltcGxlbWVudGFyZSBsYSBjYXBhYmlsaXR5IHJlZnNwZWMiCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzoyNzQgdHJhbnNwb3J0LWhlbHBlci5jOjQxNAorIzogdHJhbnNwb3J0LWhlbHBlci5jOjI4NCB0cmFuc3BvcnQtaGVscGVyLmM6NDI0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIHVuZXhwZWN0ZWRseSBzYWlkOiAnJXMnIgogbXNnc3RyICIlcyBoYSBpbnZpYXRvIHVuIG1lc3NhZ2dpbyBpbmF0dGVzbzogJyVzJyIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjQwMworIzogdHJhbnNwb3J0LWhlbHBlci5jOjQxMwogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyBhbHNvIGxvY2tlZCAlcyIKIG1zZ3N0ciAiJXMgaGEgYmxvY2NhdG8gYW5jaGUgJXMiCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzo0ODEKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzo0OTEKIG1zZ2lkICJjb3VsZG4ndCBydW4gZmFzdC1pbXBvcnQiCiBtc2dzdHIgImltcG9zc2liaWxlIGVzZWd1aXJlIGZhc3QtaW1wb3J0IgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6NTA0CisjOiB0cmFuc3BvcnQtaGVscGVyLmM6NTE0CiBtc2dpZCAiZXJyb3Igd2hpbGUgcnVubmluZyBmYXN0LWltcG9ydCIKIG1zZ3N0ciAiZXJyb3JlIGR1cmFudGUgbCdlc2VjdXppb25lIGRpIGZhc3QtaW1wb3J0IgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6NTMzIHRyYW5zcG9ydC1oZWxwZXIuYzoxMTA1CisjOiB0cmFuc3BvcnQtaGVscGVyLmM6NTQzIHRyYW5zcG9ydC1oZWxwZXIuYzoxMTMyCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCByZWFkIHJlZiAlcyIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgbGVnZ2VyZSBpbCByaWZlcmltZW50byAlcyIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjU3OAorIzogdHJhbnNwb3J0LWhlbHBlci5jOjU4OAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmtub3duIHJlc3BvbnNlIHRvIGNvbm5lY3Q6ICVzIgogbXNnc3RyICJyaXNwb3N0YSBpbmF0dGVzYSBhIGNvbm5lY3Q6ICVzIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6NjAwCisjOiB0cmFuc3BvcnQtaGVscGVyLmM6NjEwCiBtc2dpZCAic2V0dGluZyByZW1vdGUgc2VydmljZSBwYXRoIG5vdCBzdXBwb3J0ZWQgYnkgcHJvdG9jb2wiCiBtc2dzdHIgIiIKICJsJ2ltcG9zdGF6aW9uZSBkZWwgcGVyY29yc28gZGVsIHNlcnZpemlvIHJlbW90byBub24gw6ggc3VwcG9ydGF0YSBkYWwgIgogInByb3RvY29sbG8iCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzo2MDIKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzo2MTIKIG1zZ2lkICJpbnZhbGlkIHJlbW90ZSBzZXJ2aWNlIHBhdGgiCiBtc2dzdHIgInBlcmNvcnNvIHNlcnZpemlvIHJlbW90byBub24gdmFsaWRvIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6NjQ4CisjOiB0cmFuc3BvcnQtaGVscGVyLmM6NjU4CiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbid0IGNvbm5lY3QgdG8gc3Vic2VydmljZSAlcyIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgY29ubmV0dGVyc2kgYWwgc290dG9zZXJ2aXppbyAlcyIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjcyMAorIzogdHJhbnNwb3J0LWhlbHBlci5jOjczNAogIywgYy1mb3JtYXQKIG1zZ2lkICJleHBlY3RlZCBvay9lcnJvciwgaGVscGVyIHNhaWQgJyVzJyIKIG1zZ3N0ciAiYXR0ZXNpIG9rL2Vycm9yLCBsJ2hlbHBlciBoYSBpbnZpYXRvICclcyciCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzo3NzMKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzo3ODcKICMsIGMtZm9ybWF0CiBtc2dpZCAiaGVscGVyIHJlcG9ydGVkIHVuZXhwZWN0ZWQgc3RhdHVzIG9mICVzIgogbXNnc3RyICJsJ2hlbHBlciBoYSBzZWduYWxhdG8gdW5vIHN0YXRvIGluYXR0ZXNvIGRpICVzIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6ODM0CisjOiB0cmFuc3BvcnQtaGVscGVyLmM6ODQ4CiAjLCBjLWZvcm1hdAogbXNnaWQgImhlbHBlciAlcyBkb2VzIG5vdCBzdXBwb3J0IGRyeS1ydW4iCiBtc2dzdHIgImwnaGVscGVyICVzIG5vbiBzdXBwb3J0YSBkcnktcnVuIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6ODM3CisjOiB0cmFuc3BvcnQtaGVscGVyLmM6ODUxCiAjLCBjLWZvcm1hdAogbXNnaWQgImhlbHBlciAlcyBkb2VzIG5vdCBzdXBwb3J0IC0tc2lnbmVkIgogbXNnc3RyICJsJ2hlbHBlciAlcyBub24gc3VwcG9ydGEgLS1zaWduZWQiCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzo4NDAKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzo4NTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiaGVscGVyICVzIGRvZXMgbm90IHN1cHBvcnQgLS1zaWduZWQ9aWYtYXNrZWQiCiBtc2dzdHIgImwnaGVscGVyICVzIG5vbiBzdXBwb3J0YSAtLXNpZ25lZD1pZi1hc2tlZCIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjg0NworIzogdHJhbnNwb3J0LWhlbHBlci5jOjg1OQorIywgYy1mb3JtYXQKK21zZ2lkICJoZWxwZXIgJXMgZG9lcyBub3Qgc3VwcG9ydCAtLWF0b21pYyIKK21zZ3N0ciAibCdoZWxwZXIgJXMgbm9uIHN1cHBvcnRhIC0tYXRvbWljIgorCisjOiB0cmFuc3BvcnQtaGVscGVyLmM6ODY1CiAjLCBjLWZvcm1hdAogbXNnaWQgImhlbHBlciAlcyBkb2VzIG5vdCBzdXBwb3J0ICdwdXNoLW9wdGlvbiciCiBtc2dzdHIgImwnaGVscGVyICVzIG5vbiBzdXBwb3J0YSAncHVzaC1vcHRpb24nIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6OTQ1CisjOiB0cmFuc3BvcnQtaGVscGVyLmM6OTYzCiBtc2dpZCAicmVtb3RlLWhlbHBlciBkb2Vzbid0IHN1cHBvcnQgcHVzaDsgcmVmc3BlYyBuZWVkZWQiCiBtc2dzdHIgIiIKICJsJ2hlbHBlciByZW1vdG8gbm9uIHN1cHBvcnRhIGlsIHB1c2g7IMOoIG5lY2Vzc2FyaW8gdW5vIHNwZWNpZmljYXRvcmUgIgogInJpZmVyaW1lbnRvIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6OTUwCisjOiB0cmFuc3BvcnQtaGVscGVyLmM6OTY4CiAjLCBjLWZvcm1hdAogbXNnaWQgImhlbHBlciAlcyBkb2VzIG5vdCBzdXBwb3J0ICdmb3JjZSciCiBtc2dzdHIgImwnaGVscGVyICVzIG5vbiBzdXBwb3J0YSAnZm9yY2UnIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6OTk3CisjOiB0cmFuc3BvcnQtaGVscGVyLmM6MTAxNQogbXNnaWQgImNvdWxkbid0IHJ1biBmYXN0LWV4cG9ydCIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgZXNlZ3VpcmUgZmFzdC1leHBvcnQiCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxMDAyCisjOiB0cmFuc3BvcnQtaGVscGVyLmM6MTAyMAogbXNnaWQgImVycm9yIHdoaWxlIHJ1bm5pbmcgZmFzdC1leHBvcnQiCiBtc2dzdHIgImVycm9yZSBkdXJhbnRlIGwnZXNlY3V6aW9uZSBkaSBmYXN0LWV4cG9ydCIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjEwMjcKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxMDQ1CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJObyByZWZzIGluIGNvbW1vbiBhbmQgbm9uZSBzcGVjaWZpZWQ7IGRvaW5nIG5vdGhpbmcuXG4iCkBAIC03NjUzLDQ3ICs3Njg0LDQ3IEBACiAiTmVzc3VuIHJpZmVyaW1lbnRvIGluIGNvbXVuZSBlIG5lc3N1bm8gc3BlY2lmaWNhdG87IG5vbiBlc2VndW8gbnVsbGEuXG4iCiAiRm9yc2UgZG92cmVzdGkgc3BlY2lmaWNhcmUgdW4gYnJhbmNoIGNvbWUgJ21hc3RlcicuXG4iCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxMDkxCisjOiB0cmFuc3BvcnQtaGVscGVyLmM6MTExOAogIywgYy1mb3JtYXQKIG1zZ2lkICJtYWxmb3JtZWQgcmVzcG9uc2UgaW4gcmVmIGxpc3Q6ICVzIgogbXNnc3RyICJyaXNwb3N0YSBtYWxmb3JtYXRhIG5lbGwnZWxlbmNvIHJpZmVyaW1lbnRpOiAlcyIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjEyNDQKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxMjcwCiAjLCBjLWZvcm1hdAogbXNnaWQgInJlYWQoJXMpIGZhaWxlZCIKIG1zZ3N0ciAicmVhZCglcykgbm9uIHJpdXNjaXRhIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6MTI3MQorIzogdHJhbnNwb3J0LWhlbHBlci5jOjEyOTcKICMsIGMtZm9ybWF0CiBtc2dpZCAid3JpdGUoJXMpIGZhaWxlZCIKIG1zZ3N0ciAid3JpdGUoJXMpIG5vbiByaXVzY2l0YSIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjEzMjAKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxMzQ2CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIHRocmVhZCBmYWlsZWQiCiBtc2dzdHIgInRocmVhZCAlcyBub24gcml1c2NpdG8iCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxMzI0CisjOiB0cmFuc3BvcnQtaGVscGVyLmM6MTM1MAogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyB0aHJlYWQgZmFpbGVkIHRvIGpvaW46ICVzIgogbXNnc3RyICJqb2luIG5vbiByaXVzY2l0YSBwZXIgaWwgdGhyZWFkICVzOiAlcyIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjEzNDMgdHJhbnNwb3J0LWhlbHBlci5jOjEzNDcKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxMzY5IHRyYW5zcG9ydC1oZWxwZXIuYzoxMzczCiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbid0IHN0YXJ0IHRocmVhZCBmb3IgY29weWluZyBkYXRhOiAlcyIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgYXZ2aWFyZSBpbCB0aHJlYWQgcGVyIGxhIGNvcGlhIGRlaSBkYXRpOiAlcyIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjEzODQKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxNDEwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIHByb2Nlc3MgZmFpbGVkIHRvIHdhaXQiCiBtc2dzdHIgIndhaXQgbm9uIHJpdXNjaXRhIHBlciBpbCBwcm9jZXNzbyAlcyIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjEzODgKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxNDE0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIHByb2Nlc3MgZmFpbGVkIgogbXNnc3RyICJwcm9jZXNzbyAlcyBub24gcml1c2NpdG8iCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxNDA2IHRyYW5zcG9ydC1oZWxwZXIuYzoxNDE1CisjOiB0cmFuc3BvcnQtaGVscGVyLmM6MTQzMiB0cmFuc3BvcnQtaGVscGVyLmM6MTQ0MQogbXNnaWQgImNhbid0IHN0YXJ0IHRocmVhZCBmb3IgY29weWluZyBkYXRhIgogbXNnc3RyICJpbXBvc3NpYmlsZSBhdnZpYXJlIGlsIHRocmVhZCBwZXIgbGEgY29waWEgZGVpIGRhdGkiCiAKQEAgLTc3MTMsNyArNzc0NCw3IEBACiBtc2dpZCAidG9vLXNob3J0IHRyZWUgZmlsZSIKIG1zZ3N0ciAiZmlsZSBhbGJlciB0cm9wcG8gY29ydG8iCiAKLSM6IHVucGFjay10cmVlcy5jOjExMQorIzogdW5wYWNrLXRyZWVzLmM6MTEwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJZb3VyIGxvY2FsIGNoYW5nZXMgdG8gdGhlIGZvbGxvd2luZyBmaWxlcyB3b3VsZCBiZSBvdmVyd3JpdHRlbiBieSBjaGVja291dDpcbiIKQEAgLTc3MjMsNyArNzc1NCw3IEBACiAiY2hlY2tvdXQ6XG4iCiAiJSVzRXNlZ3VpIGlsIGNvbW1pdCBvIGxvIHN0YXNoIGRlbGxlIG1vZGlmaWNoZSBwcmltYSBkaSBjYW1iaWFyZSBicmFuY2guIgogCi0jOiB1bnBhY2stdHJlZXMuYzoxMTMKKyM6IHVucGFjay10cmVlcy5jOjExMgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiWW91ciBsb2NhbCBjaGFuZ2VzIHRvIHRoZSBmb2xsb3dpbmcgZmlsZXMgd291bGQgYmUgb3ZlcndyaXR0ZW4gYnkgY2hlY2tvdXQ6XG4iCkBAIC03NzMzLDcgKzc3NjQsNyBAQAogImNoZWNrb3V0OlxuIgogIiUlcyIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTE2CisjOiB1bnBhY2stdHJlZXMuYzoxMTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIllvdXIgbG9jYWwgY2hhbmdlcyB0byB0aGUgZm9sbG93aW5nIGZpbGVzIHdvdWxkIGJlIG92ZXJ3cml0dGVuIGJ5IG1lcmdlOlxuIgpAQCAtNzc0Myw3ICs3Nzc0LDcgQEAKICJtZXJnZTpcbiIKICIlJXNFc2VndWkgaWwgY29tbWl0IG8gbG8gc3Rhc2ggZGVsbGUgbW9kaWZpY2hlIHByaW1hIGRpIGVzZWd1aXJlIGlsIG1lcmdlLiIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTE4CisjOiB1bnBhY2stdHJlZXMuYzoxMTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIllvdXIgbG9jYWwgY2hhbmdlcyB0byB0aGUgZm9sbG93aW5nIGZpbGVzIHdvdWxkIGJlIG92ZXJ3cml0dGVuIGJ5IG1lcmdlOlxuIgpAQCAtNzc1Myw3ICs3Nzg0LDcgQEAKICJtZXJnZTpcbiIKICIlJXMiCiAKLSM6IHVucGFjay10cmVlcy5jOjEyMQorIzogdW5wYWNrLXRyZWVzLmM6MTIwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJZb3VyIGxvY2FsIGNoYW5nZXMgdG8gdGhlIGZvbGxvd2luZyBmaWxlcyB3b3VsZCBiZSBvdmVyd3JpdHRlbiBieSAlczpcbiIKQEAgLTc3NjQsNyArNzc5NSw3IEBACiAiJSVzRXNlZ3VpIGlsIGNvbW1pdCBvIGxvIHN0YXNoIGRlbGxlIG1vZGlmaWNoZSBwcmltYSBkaSBlc2VndWlyZSAiCiAibCdvcGVyYXppb25lIGRpICVzLiIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTIzCisjOiB1bnBhY2stdHJlZXMuYzoxMjIKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIllvdXIgbG9jYWwgY2hhbmdlcyB0byB0aGUgZm9sbG93aW5nIGZpbGVzIHdvdWxkIGJlIG92ZXJ3cml0dGVuIGJ5ICVzOlxuIgpAQCAtNzc3NCw3ICs3ODA1LDcgQEAKICJsJ29wZXJhemlvbmUgZGkgJXM6XG4iCiAiJSVzIgogCi0jOiB1bnBhY2stdHJlZXMuYzoxMjgKKyM6IHVucGFjay10cmVlcy5jOjEyNwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiVXBkYXRpbmcgdGhlIGZvbGxvd2luZyBkaXJlY3RvcmllcyB3b3VsZCBsb3NlIHVudHJhY2tlZCBmaWxlcyBpbiB0aGVtOlxuIgpAQCAtNzc4NCw3ICs3ODE1LDcgQEAKICJ0cmFjY2lhdGkgaW4gZXNzZSBjb250ZW51dGkgdmVuZ2FubyBwZXJzaTpcbiIKICIlcyIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTMyCisjOiB1bnBhY2stdHJlZXMuYzoxMzEKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlRoZSBmb2xsb3dpbmcgdW50cmFja2VkIHdvcmtpbmcgdHJlZSBmaWxlcyB3b3VsZCBiZSByZW1vdmVkIGJ5IGNoZWNrb3V0OlxuIgpAQCAtNzc5NCw3ICs3ODI1LDcgQEAKICJlbGltaW5hdGkgY29uIGlsIGNoZWNrb3V0OlxuIgogIiUlc1Nwb3N0YWxpIG8gZWxpbWluYWxpIHByaW1hIGRpIGNhbWJpYXJlIGJyYW5jaC4iCiAKLSM6IHVucGFjay10cmVlcy5jOjEzNAorIzogdW5wYWNrLXRyZWVzLmM6MTMzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgZm9sbG93aW5nIHVudHJhY2tlZCB3b3JraW5nIHRyZWUgZmlsZXMgd291bGQgYmUgcmVtb3ZlZCBieSBjaGVja291dDpcbiIKQEAgLTc4MDQsNyArNzgzNSw3IEBACiAiZWxpbWluYXRpIGNvbiBpbCBjaGVja291dDpcbiIKICIlJXMiCiAKLSM6IHVucGFjay10cmVlcy5jOjEzNworIzogdW5wYWNrLXRyZWVzLmM6MTM2CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgZm9sbG93aW5nIHVudHJhY2tlZCB3b3JraW5nIHRyZWUgZmlsZXMgd291bGQgYmUgcmVtb3ZlZCBieSBtZXJnZTpcbiIKQEAgLTc4MTQsNyArNzg0NSw3IEBACiAiZWxpbWluYXRpIGRhbCBtZXJnZTpcbiIKICIlJXNTcG9zdGFsaSBvIGVsaW1pbmFsaSBwcmltYSBkaSBlc2VndWlyZSBpbCBtZXJnZS4iCiAKLSM6IHVucGFjay10cmVlcy5jOjEzOQorIzogdW5wYWNrLXRyZWVzLmM6MTM4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgZm9sbG93aW5nIHVudHJhY2tlZCB3b3JraW5nIHRyZWUgZmlsZXMgd291bGQgYmUgcmVtb3ZlZCBieSBtZXJnZTpcbiIKQEAgLTc4MjQsNyArNzg1NSw3IEBACiAiZWxpbWluYXRpIGRhbCBtZXJnZTpcbiIKICIlJXMiCiAKLSM6IHVucGFjay10cmVlcy5jOjE0MgorIzogdW5wYWNrLXRyZWVzLmM6MTQxCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgZm9sbG93aW5nIHVudHJhY2tlZCB3b3JraW5nIHRyZWUgZmlsZXMgd291bGQgYmUgcmVtb3ZlZCBieSAlczpcbiIKQEAgLTc4MzQsNyArNzg2NSw3IEBACiAiZWxpbWluYXRpIGNvbiBsJ29wZXJhemlvbmUgZGkgJXM6XG4iCiAiJSVzU3Bvc3RhbGkgbyBlbGltaW5hbGkgcHJpbWEgZGkgZXNlZ3VpcmUgbCdvcGVyYXppb25lIGRpICVzLiIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTQ0CisjOiB1bnBhY2stdHJlZXMuYzoxNDMKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlRoZSBmb2xsb3dpbmcgdW50cmFja2VkIHdvcmtpbmcgdHJlZSBmaWxlcyB3b3VsZCBiZSByZW1vdmVkIGJ5ICVzOlxuIgpAQCAtNzg0NCw3ICs3ODc1LDcgQEAKICJlbGltaW5hdGkgY29uIGwnb3BlcmF6aW9uZSBkaSAlczpcbiIKICIlJXMiCiAKLSM6IHVucGFjay10cmVlcy5jOjE1MAorIzogdW5wYWNrLXRyZWVzLmM6MTQ5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgZm9sbG93aW5nIHVudHJhY2tlZCB3b3JraW5nIHRyZWUgZmlsZXMgd291bGQgYmUgb3ZlcndyaXR0ZW4gYnkgIgpAQCAtNzg1NSw3ICs3ODg2LDcgQEAKICJzb3ZyYXNjcml0dGkgY29uIGlsIGNoZWNrb3V0OlxuIgogIiUlc1Nwb3N0YWxpIG8gZWxpbWluYWxpIHByaW1hIGRpIGNhbWJpYXJlIGJyYW5jaC4iCiAKLSM6IHVucGFjay10cmVlcy5jOjE1MgorIzogdW5wYWNrLXRyZWVzLmM6MTUxCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgZm9sbG93aW5nIHVudHJhY2tlZCB3b3JraW5nIHRyZWUgZmlsZXMgd291bGQgYmUgb3ZlcndyaXR0ZW4gYnkgIgpAQCAtNzg2Niw3ICs3ODk3LDcgQEAKICJzb3ZyYXNjcml0dGkgY29uIGlsIGNoZWNrb3V0OlxuIgogIiUlcyIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTU1CisjOiB1bnBhY2stdHJlZXMuYzoxNTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlRoZSBmb2xsb3dpbmcgdW50cmFja2VkIHdvcmtpbmcgdHJlZSBmaWxlcyB3b3VsZCBiZSBvdmVyd3JpdHRlbiBieSBtZXJnZTpcbiIKQEAgLTc4NzYsNyArNzkwNyw3IEBACiAic292cmFzY3JpdHRpIGRhbCBtZXJnZTpcbiIKICIlJXNTcG9zdGFsaSBvIGVsaW1pbmFsaSBwcmltYSBkaSBlc2VndWlyZSBpbCBtZXJnZS4iCiAKLSM6IHVucGFjay10cmVlcy5jOjE1NworIzogdW5wYWNrLXRyZWVzLmM6MTU2CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgZm9sbG93aW5nIHVudHJhY2tlZCB3b3JraW5nIHRyZWUgZmlsZXMgd291bGQgYmUgb3ZlcndyaXR0ZW4gYnkgbWVyZ2U6XG4iCkBAIC03ODg2LDcgKzc5MTcsNyBAQAogInNvdnJhc2NyaXR0aSBkYWwgbWVyZ2U6XG4iCiAiJSVzIgogCi0jOiB1bnBhY2stdHJlZXMuYzoxNjAKKyM6IHVucGFjay10cmVlcy5jOjE1OQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiVGhlIGZvbGxvd2luZyB1bnRyYWNrZWQgd29ya2luZyB0cmVlIGZpbGVzIHdvdWxkIGJlIG92ZXJ3cml0dGVuIGJ5ICVzOlxuIgpAQCAtNzg5Niw3ICs3OTI3LDcgQEAKICJzb3ZyYXNjcml0dGkgY29uIGwnb3BlcmF6aW9uZSBkaSAlczpcbiIKICIlJXNTcG9zdGFsaSBvIGVsaW1pbmFsaSBwcmltYSBkaSBlc2VndWlyZSBsJ29wZXJhemlvbmUgZGkgJXMuIgogCi0jOiB1bnBhY2stdHJlZXMuYzoxNjIKKyM6IHVucGFjay10cmVlcy5jOjE2MQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiVGhlIGZvbGxvd2luZyB1bnRyYWNrZWQgd29ya2luZyB0cmVlIGZpbGVzIHdvdWxkIGJlIG92ZXJ3cml0dGVuIGJ5ICVzOlxuIgpAQCAtNzkwNiwxMyArNzkzNywxMyBAQAogInNvdnJhc2NyaXR0aSBjb24gbCdvcGVyYXppb25lIGRpICVzOlxuIgogIiUlcyIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTcwCisjOiB1bnBhY2stdHJlZXMuYzoxNjkKICMsIGMtZm9ybWF0CiBtc2dpZCAiRW50cnkgJyVzJyBvdmVybGFwcyB3aXRoICclcycuICBDYW5ub3QgYmluZC4iCiBtc2dzdHIgIiIKICJMYSB2b2NlICclcycgc2kgc292cmFwcG9uZSBhICclcycuIEltcG9zc2liaWxlIGVzZWd1aXJlIGlsIGNvbGxlZ2FtZW50by4iCiAKLSM6IHVucGFjay10cmVlcy5jOjE3MworIzogdW5wYWNrLXRyZWVzLmM6MTcyCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJDYW5ub3QgdXBkYXRlIHNwYXJzZSBjaGVja291dDogdGhlIGZvbGxvd2luZyBlbnRyaWVzIGFyZSBub3QgdXAgdG8gZGF0ZTpcbiIKQEAgLTc5MjIsNyArNzk1Myw3IEBACiAiYWdnaW9ybmF0ZTpcbiIKICIlcyIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTc1CisjOiB1bnBhY2stdHJlZXMuYzoxNzQKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlRoZSBmb2xsb3dpbmcgd29ya2luZyB0cmVlIGZpbGVzIHdvdWxkIGJlIG92ZXJ3cml0dGVuIGJ5IHNwYXJzZSBjaGVja291dCAiCkBAIC03OTMzLDcgKzc5NjQsNyBAQAogImwnYWdnaW9ybmFtZW50byBkZWwgY2hlY2tvdXQgc3BhcnNlOlxuIgogIiVzIgogCi0jOiB1bnBhY2stdHJlZXMuYzoxNzcKKyM6IHVucGFjay10cmVlcy5jOjE3NgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiVGhlIGZvbGxvd2luZyB3b3JraW5nIHRyZWUgZmlsZXMgd291bGQgYmUgcmVtb3ZlZCBieSBzcGFyc2UgY2hlY2tvdXQgIgpAQCAtNzk0NCw3ICs3OTc1LDcgQEAKICJsJ2FnZ2lvcm5hbWVudG8gZGVsIGNoZWNrb3V0IHNwYXJzZTpcbiIKICIlcyIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTc5CisjOiB1bnBhY2stdHJlZXMuYzoxNzgKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkNhbm5vdCB1cGRhdGUgc3VibW9kdWxlOlxuIgpAQCAtNzk1MywxNiArNzk4NCwxNiBAQAogIkltcG9zc2liaWxlIGFnZ2lvcm5hcmUgaWwgc290dG9tb2R1bG86XG4iCiAiJXMiCiAKLSM6IHVucGFjay10cmVlcy5jOjI1NgorIzogdW5wYWNrLXRyZWVzLmM6MjU1CiAjLCBjLWZvcm1hdAogbXNnaWQgIkFib3J0aW5nXG4iCiBtc2dzdHIgIkludGVycm9tcG8gbCdvcGVyYXppb25lXG4iCiAKLSM6IHVucGFjay10cmVlcy5jOjMxOAorIzogdW5wYWNrLXRyZWVzLmM6MzE3CiBtc2dpZCAiVXBkYXRpbmcgZmlsZXMiCiBtc2dzdHIgIkFnZ2lvcm5hbWVudG8gZGVpIGZpbGUgaW4gY29yc28iCiAKLSM6IHVucGFjay10cmVlcy5jOjM1MAorIzogdW5wYWNrLXRyZWVzLmM6MzQ5CiBtc2dpZCAiIgogInRoZSBmb2xsb3dpbmcgcGF0aHMgaGF2ZSBjb2xsaWRlZCAoZS5nLiBjYXNlLXNlbnNpdGl2ZSBwYXRoc1xuIgogIm9uIGEgY2FzZS1pbnNlbnNpdGl2ZSBmaWxlc3lzdGVtKSBhbmQgb25seSBvbmUgZnJvbSB0aGUgc2FtZVxuIgpAQCAtODAwMiw3ICs4MDMzLDcgQEAKIG1zZ2lkICJpbnZhbGlkICcuLicgcGF0aCBzZWdtZW50IgogbXNnc3RyICJwYXJ0ZSBwZXJjb3JzbyAnLi4nIG5vbiB2YWxpZGEiCiAKLSM6IHdvcmt0cmVlLmM6MjU4IGJ1aWx0aW4vYW0uYzoyMDk1CisjOiB3b3JrdHJlZS5jOjI1OCBidWlsdGluL2FtLmM6MjA4NAogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gcmVhZCAnJXMnIgogbXNnc3RyICJsZXR0dXJhIGRpICclcycgbm9uIHJpdXNjaXRhIgpAQCAtODAzNSwxNyArODA2NiwxNyBAQAogbXNnaWQgIiclcycgZG9lcyBub3QgcG9pbnQgYmFjayB0byAnJXMnIgogbXNnc3RyICInJXMnIG5vbiBwdW50YSBhICclcyciCiAKLSM6IHdyYXBwZXIuYzoyMjMgd3JhcHBlci5jOjM5MworIzogd3JhcHBlci5jOjE4NiB3cmFwcGVyLmM6MzU2CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBvcGVuICclcycgZm9yIHJlYWRpbmcgYW5kIHdyaXRpbmciCiBtc2dzdHIgImltcG9zc2liaWxlIGFwcmlyZSAnJXMnIGluIGxldHR1cmEgZSBzY3JpdHR1cmEiCiAKLSM6IHdyYXBwZXIuYzo0MjQgd3JhcHBlci5jOjYyNAorIzogd3JhcHBlci5jOjM4NyB3cmFwcGVyLmM6NTg4CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBhY2Nlc3MgJyVzJyIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgYWNjZWRlcmUgYSAnJXMnIgogCi0jOiB3cmFwcGVyLmM6NjMyCisjOiB3cmFwcGVyLmM6NTk2CiBtc2dpZCAidW5hYmxlIHRvIGdldCBjdXJyZW50IHdvcmtpbmcgZGlyZWN0b3J5IgogbXNnc3RyICJpbXBvc3NpYmlsZSBvdHRlbmVyZSBsYSBkaXJlY3RvcnkgZGkgbGF2b3JvIGNvcnJlbnRlIgogCkBAIC04NDAyLDgyICs4NDMzLDkwIEBACiAiXCIpIgogCiAjOiB3dC1zdGF0dXMuYzoxNDM3Cittc2dpZCAiICAodXNlIFwiZ2l0IGNoZXJyeS1waWNrIC0tc2tpcFwiIHRvIHNraXAgdGhpcyBwYXRjaCkiCittc2dzdHIgIiAgKHVzYSBcImdpdCBjaGVycnktcGljayAtLXNraXBcIiBwZXIgc2FsdGFyZSBxdWVzdGEgcGF0Y2gpIgorCisjOiB3dC1zdGF0dXMuYzoxNDM5CiBtc2dpZCAiICAodXNlIFwiZ2l0IGNoZXJyeS1waWNrIC0tYWJvcnRcIiB0byBjYW5jZWwgdGhlIGNoZXJyeS1waWNrIG9wZXJhdGlvbikiCiBtc2dzdHIgIiIKICIgICh1c2EgXCJnaXQgY2hlcnJ5LXBpY2sgLS1hYm9ydFwiIHBlciBhbm51bGxhcmUgbCdvcGVyYXppb25lIGRpIGNoZXJyeS1waWNrKSIKIAotIzogd3Qtc3RhdHVzLmM6MTQ0NworIzogd3Qtc3RhdHVzLmM6MTQ0OQogbXNnaWQgIlJldmVydCBjdXJyZW50bHkgaW4gcHJvZ3Jlc3MuIgogbXNnc3RyICJSZXZlcnQgaW4gY29yc28uIgogCi0jOiB3dC1zdGF0dXMuYzoxNDUwCisjOiB3dC1zdGF0dXMuYzoxNDUyCiAjLCBjLWZvcm1hdAogbXNnaWQgIllvdSBhcmUgY3VycmVudGx5IHJldmVydGluZyBjb21taXQgJXMuIgogbXNnc3RyICJBdHR1YWxtZW50ZSBzdGFpIGVzZWd1ZW5kbyBpbCByZXZlcnQgZGVsIGNvbW1pdCAlcy4iCiAKLSM6IHd0LXN0YXR1cy5jOjE0NTYKKyM6IHd0LXN0YXR1cy5jOjE0NTgKIG1zZ2lkICIgIChmaXggY29uZmxpY3RzIGFuZCBydW4gXCJnaXQgcmV2ZXJ0IC0tY29udGludWVcIikiCiBtc2dzdHIgIiAgKHJpc29sdmkgaSBjb25mbGl0dGkgZWQgZXNlZ3VpIFwiZ2l0IHJldmVydCAtLWNvbnRpbnVlXCIpIgogCi0jOiB3dC1zdGF0dXMuYzoxNDU5CisjOiB3dC1zdGF0dXMuYzoxNDYxCiBtc2dpZCAiICAocnVuIFwiZ2l0IHJldmVydCAtLWNvbnRpbnVlXCIgdG8gY29udGludWUpIgogbXNnc3RyICIgIChlc2VndWkgXCJnaXQgcmV2ZXJ0IC0tY29udGludWVcIiBwZXIgY29udGludWFyZSkiCiAKLSM6IHd0LXN0YXR1cy5jOjE0NjIKKyM6IHd0LXN0YXR1cy5jOjE0NjQKIG1zZ2lkICIgIChhbGwgY29uZmxpY3RzIGZpeGVkOiBydW4gXCJnaXQgcmV2ZXJ0IC0tY29udGludWVcIikiCiBtc2dzdHIgIiIKICIgICh0dXR0aSBpIGNvbmZsaXR0aSBzb25vIHN0YXRpIHJpc29sdGk6IGVzZWd1aSBcImdpdCByZXZlcnQgLS1jb250aW51ZVwiKSIKIAotIzogd3Qtc3RhdHVzLmM6MTQ2NAorIzogd3Qtc3RhdHVzLmM6MTQ2NgorbXNnaWQgIiAgKHVzZSBcImdpdCByZXZlcnQgLS1za2lwXCIgdG8gc2tpcCB0aGlzIHBhdGNoKSIKK21zZ3N0ciAiICAodXNhIFwiZ2l0IHJldmVydCAtLXNraXBcIiBwZXIgc2FsdGFyZSBxdWVzdGEgcGF0Y2gpIgorCisjOiB3dC1zdGF0dXMuYzoxNDY4CiBtc2dpZCAiICAodXNlIFwiZ2l0IHJldmVydCAtLWFib3J0XCIgdG8gY2FuY2VsIHRoZSByZXZlcnQgb3BlcmF0aW9uKSIKIG1zZ3N0ciAiICAodXNhIFwiZ2l0IHJldmVydCAtLWFib3J0XCIgcGVyIGFubnVsbGFyZSBsJ29wZXJhemlvbmUgZGkgcmV2ZXJ0KSIKIAotIzogd3Qtc3RhdHVzLmM6MTQ3NAorIzogd3Qtc3RhdHVzLmM6MTQ3OAogIywgYy1mb3JtYXQKIG1zZ2lkICJZb3UgYXJlIGN1cnJlbnRseSBiaXNlY3RpbmcsIHN0YXJ0ZWQgZnJvbSBicmFuY2ggJyVzJy4iCiBtc2dzdHIgIkF0dHVhbG1lbnRlIHN0YWkgZXNlZ3VlbmRvIHVuYSBiaXNlemlvbmUgcGFydGVuZG8gZGFsIGJyYW5jaCAnJXMnLiIKIAotIzogd3Qtc3RhdHVzLmM6MTQ3OAorIzogd3Qtc3RhdHVzLmM6MTQ4MgogbXNnaWQgIllvdSBhcmUgY3VycmVudGx5IGJpc2VjdGluZy4iCiBtc2dzdHIgIkF0dHVhbG1lbnRlIHN0YWkgZXNlZ3VlbmRvIHVuYSBiaXNlemlvbmUuIgogCi0jOiB3dC1zdGF0dXMuYzoxNDgxCisjOiB3dC1zdGF0dXMuYzoxNDg1CiBtc2dpZCAiICAodXNlIFwiZ2l0IGJpc2VjdCByZXNldFwiIHRvIGdldCBiYWNrIHRvIHRoZSBvcmlnaW5hbCBicmFuY2gpIgogbXNnc3RyICIgICh1c2EgXCJnaXQgYmlzZWN0IHJlc2V0XCIgcGVyIHRvcm5hcmUgYWwgYnJhbmNoIG9yaWdpbmFyaW8pIgogCi0jOiB3dC1zdGF0dXMuYzoxNjkwCisjOiB3dC1zdGF0dXMuYzoxNjk0CiBtc2dpZCAiT24gYnJhbmNoICIKIG1zZ3N0ciAiU3VsIGJyYW5jaCAiCiAKLSM6IHd0LXN0YXR1cy5jOjE2OTcKKyM6IHd0LXN0YXR1cy5jOjE3MDEKIG1zZ2lkICJpbnRlcmFjdGl2ZSByZWJhc2UgaW4gcHJvZ3Jlc3M7IG9udG8gIgogbXNnc3RyICJyZWJhc2UgaW50ZXJhdHRpdm8gaW4gY29yc28gc3UgIgogCi0jOiB3dC1zdGF0dXMuYzoxNjk5CisjOiB3dC1zdGF0dXMuYzoxNzAzCiBtc2dpZCAicmViYXNlIGluIHByb2dyZXNzOyBvbnRvICIKIG1zZ3N0ciAicmViYXNlIGluIGNvcnNvIHN1ICIKIAotIzogd3Qtc3RhdHVzLmM6MTcwOQorIzogd3Qtc3RhdHVzLmM6MTcxMwogbXNnaWQgIk5vdCBjdXJyZW50bHkgb24gYW55IGJyYW5jaC4iCiBtc2dzdHIgIkF0dHVhbG1lbnRlIG5vbiBzZWkgc3UgYWxjdW4gYnJhbmNoLiIKIAotIzogd3Qtc3RhdHVzLmM6MTcyNgorIzogd3Qtc3RhdHVzLmM6MTczMAogbXNnaWQgIkluaXRpYWwgY29tbWl0IgogbXNnc3RyICJDb21taXQgaW5pemlhbGUiCiAKLSM6IHd0LXN0YXR1cy5jOjE3MjcKKyM6IHd0LXN0YXR1cy5jOjE3MzEKIG1zZ2lkICJObyBjb21taXRzIHlldCIKIG1zZ3N0ciAiTm9uIGNpIHNvbm8gYW5jb3JhIGNvbW1pdCIKIAotIzogd3Qtc3RhdHVzLmM6MTc0MQorIzogd3Qtc3RhdHVzLmM6MTc0NQogbXNnaWQgIlVudHJhY2tlZCBmaWxlcyIKIG1zZ3N0ciAiRmlsZSBub24gdHJhY2NpYXRpIgogCi0jOiB3dC1zdGF0dXMuYzoxNzQzCisjOiB3dC1zdGF0dXMuYzoxNzQ3CiBtc2dpZCAiSWdub3JlZCBmaWxlcyIKIG1zZ3N0ciAiRmlsZSBpZ25vcmF0aSIKIAotIzogd3Qtc3RhdHVzLmM6MTc0NworIzogd3Qtc3RhdHVzLmM6MTc1MQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiSXQgdG9vayAlLjJmIHNlY29uZHMgdG8gZW51bWVyYXRlIHVudHJhY2tlZCBmaWxlcy4gJ3N0YXR1cyAtdW5vJ1xuIgpAQCAtODQ4OSwzMSArODUyOCwzMSBAQAogIm1hIGRldmkgc3RhcmUgYXR0ZW50byBhIG5vbiBkaW1lbnRpY2FydGkgZGkgYWdnaXVuZ2VyZVxuIgogImF1dG9ub21hbWVudGUgaSBmaWxlIG51b3ZpICh2ZWRpICdnaXQgaGVscCBzdGF0dXMnKS4iCiAKLSM6IHd0LXN0YXR1cy5jOjE3NTMKKyM6IHd0LXN0YXR1cy5jOjE3NTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiVW50cmFja2VkIGZpbGVzIG5vdCBsaXN0ZWQlcyIKIG1zZ3N0ciAiRmlsZSBub24gdHJhY2NpYXRpIG5vbiBlbGVuY2F0aSVzIgogCi0jOiB3dC1zdGF0dXMuYzoxNzU1CisjOiB3dC1zdGF0dXMuYzoxNzU5CiBtc2dpZCAiICh1c2UgLXUgb3B0aW9uIHRvIHNob3cgdW50cmFja2VkIGZpbGVzKSIKIG1zZ3N0ciAiICh1c2EgbCdvcHppb25lIC11IHBlciB2aXN1YWxpenphcmUgaSBmaWxlIG5vbiB0cmFjY2lhdGkpIgogCi0jOiB3dC1zdGF0dXMuYzoxNzYxCisjOiB3dC1zdGF0dXMuYzoxNzY1CiBtc2dpZCAiTm8gY2hhbmdlcyIKIG1zZ3N0ciAiTmVzc3VuYSBtb2RpZmljYSIKIAotIzogd3Qtc3RhdHVzLmM6MTc2NgorIzogd3Qtc3RhdHVzLmM6MTc3MAogIywgYy1mb3JtYXQKIG1zZ2lkICJubyBjaGFuZ2VzIGFkZGVkIHRvIGNvbW1pdCAodXNlIFwiZ2l0IGFkZFwiIGFuZC9vciBcImdpdCBjb21taXQgLWFcIilcbiIKIG1zZ3N0ciAiIgogIm5lc3N1bmEgbW9kaWZpY2EgYWdnaXVudGEgYWwgY29tbWl0ICh1c2EgXCJnaXQgYWRkXCIgZS9vIFwiZ2l0IGNvbW1pdCAtYVwiKVxuIgogCi0jOiB3dC1zdGF0dXMuYzoxNzY5CisjOiB3dC1zdGF0dXMuYzoxNzczCiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vIGNoYW5nZXMgYWRkZWQgdG8gY29tbWl0XG4iCiBtc2dzdHIgIm5lc3N1bmEgbW9kaWZpY2EgYWdnaXVudGEgYWwgY29tbWl0XG4iCiAKLSM6IHd0LXN0YXR1cy5jOjE3NzIKKyM6IHd0LXN0YXR1cy5jOjE3NzYKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIm5vdGhpbmcgYWRkZWQgdG8gY29tbWl0IGJ1dCB1bnRyYWNrZWQgZmlsZXMgcHJlc2VudCAodXNlIFwiZ2l0IGFkZFwiIHRvICIKQEAgLTg1MjIsNzQgKzg1NjEsNzkgQEAKICJub24gw6ggc3RhdG8gYWdnaXVudG8gbnVsbGEgYWwgY29tbWl0IG1hIHNvbm8gcHJlc2VudGkgZmlsZSBub24gdHJhY2NpYXRpICIKICIodXNhIFwiZ2l0IGFkZFwiIHBlciB0cmFjY2lhcmxpKVxuIgogCi0jOiB3dC1zdGF0dXMuYzoxNzc1CisjOiB3dC1zdGF0dXMuYzoxNzc5CiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vdGhpbmcgYWRkZWQgdG8gY29tbWl0IGJ1dCB1bnRyYWNrZWQgZmlsZXMgcHJlc2VudFxuIgogbXNnc3RyICIiCiAibm9uIMOoIHN0YXRvIGFnZ2l1bnRvIG51bGxhIGFsIGNvbW1pdCBtYSBzb25vIHByZXNlbnRpIGZpbGUgbm9uIHRyYWNjaWF0aVxuIgogCi0jOiB3dC1zdGF0dXMuYzoxNzc4CisjOiB3dC1zdGF0dXMuYzoxNzgyCiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vdGhpbmcgdG8gY29tbWl0IChjcmVhdGUvY29weSBmaWxlcyBhbmQgdXNlIFwiZ2l0IGFkZFwiIHRvIHRyYWNrKVxuIgogbXNnc3RyICIiCiAibm9uIGMnw6ggbnVsbGEgZGkgY3VpIGVzZWd1aXJlIGlsIGNvbW1pdCAoY3JlYS9jb3BpYSBkZWkgZmlsZSBlIHVzYSBcImdpdCBhZGQiCiAiXCIgcGVyIHRyYWNjaWFybGkpXG4iCiAKLSM6IHd0LXN0YXR1cy5jOjE3ODEgd3Qtc3RhdHVzLmM6MTc4NgorIzogd3Qtc3RhdHVzLmM6MTc4NSB3dC1zdGF0dXMuYzoxNzkwCiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vdGhpbmcgdG8gY29tbWl0XG4iCiBtc2dzdHIgIm5vbiBjJ8OoIG51bGxhIGRpIGN1aSBlc2VndWlyZSBpbCBjb21taXRcbiIKIAotIzogd3Qtc3RhdHVzLmM6MTc4NAorIzogd3Qtc3RhdHVzLmM6MTc4OAogIywgYy1mb3JtYXQKIG1zZ2lkICJub3RoaW5nIHRvIGNvbW1pdCAodXNlIC11IHRvIHNob3cgdW50cmFja2VkIGZpbGVzKVxuIgogbXNnc3RyICIiCiAibm9uIGMnw6ggbnVsbGEgZGkgY3VpIGVzZWd1aXJlIGlsIGNvbW1pdCAodXNhIC11IHBlciB2aXN1YWxpenphcmUgaSBmaWxlIG5vbiAiCiAidHJhY2NpYXRpKVxuIgogCi0jOiB3dC1zdGF0dXMuYzoxNzg4CisjOiB3dC1zdGF0dXMuYzoxNzkyCiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vdGhpbmcgdG8gY29tbWl0LCB3b3JraW5nIHRyZWUgY2xlYW5cbiIKIG1zZ3N0ciAibm9uIGMnw6ggbnVsbGEgZGkgY3VpIGVzZWd1aXJlIGlsIGNvbW1pdCwgbCdhbGJlcm8gZGkgbGF2b3JvIMOoIHB1bGl0b1xuIgogCi0jOiB3dC1zdGF0dXMuYzoxOTAxCisjOiB3dC1zdGF0dXMuYzoxOTA1CiBtc2dpZCAiTm8gY29tbWl0cyB5ZXQgb24gIgogbXNnc3RyICJOb24gY2kgc29ubyBhbmNvcmEgY29tbWl0IHN1IgogCi0jOiB3dC1zdGF0dXMuYzoxOTA1CisjOiB3dC1zdGF0dXMuYzoxOTA5CiBtc2dpZCAiSEVBRCAobm8gYnJhbmNoKSIKIG1zZ3N0ciAiSEVBRCAobmVzc3VuIGJyYW5jaCkiCiAKLSM6IHd0LXN0YXR1cy5jOjE5MzYKKyM6IHd0LXN0YXR1cy5jOjE5NDAKIG1zZ2lkICJkaWZmZXJlbnQiCiBtc2dzdHIgImRpZmZlcmVudGUiCiAKLSM6IHd0LXN0YXR1cy5jOjE5Mzggd3Qtc3RhdHVzLmM6MTk0NgorIzogd3Qtc3RhdHVzLmM6MTk0MiB3dC1zdGF0dXMuYzoxOTUwCiBtc2dpZCAiYmVoaW5kICIKIG1zZ3N0ciAiaW5kaWV0cm8gIgogCi0jOiB3dC1zdGF0dXMuYzoxOTQxIHd0LXN0YXR1cy5jOjE5NDQKKyM6IHd0LXN0YXR1cy5jOjE5NDUgd3Qtc3RhdHVzLmM6MTk0OAogbXNnaWQgImFoZWFkICIKIG1zZ3N0ciAiYXZhbnRpICIKIAogIy4gVFJBTlNMQVRPUlM6IHRoZSBhY3Rpb24gaXMgZS5nLiAicHVsbCB3aXRoIHJlYmFzZSIKLSM6IHd0LXN0YXR1cy5jOjI0NjYKKyM6IHd0LXN0YXR1cy5jOjI0NzAKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90ICVzOiBZb3UgaGF2ZSB1bnN0YWdlZCBjaGFuZ2VzLiIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgZXNlZ3VpcmUgJXM6IGNpIHNvbm8gZGVsbGUgbW9kaWZpY2hlIG5vbiBpbiBzdGFnaW5nLiIKIAotIzogd3Qtc3RhdHVzLmM6MjQ3MgorIzogd3Qtc3RhdHVzLmM6MjQ3NgogbXNnaWQgImFkZGl0aW9uYWxseSwgeW91ciBpbmRleCBjb250YWlucyB1bmNvbW1pdHRlZCBjaGFuZ2VzLiIKIG1zZ3N0ciAiIgogImlub2x0cmUsIGwnaW5kaWNlIGNvbnRpZW5lIG1vZGlmaWNoZSBkaSBjdWkgbm9uIMOoIHN0YXRvIGVzZWd1aXRvIGlsIGNvbW1pdC4iCiAKLSM6IHd0LXN0YXR1cy5jOjI0NzQKKyM6IHd0LXN0YXR1cy5jOjI0NzgKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90ICVzOiBZb3VyIGluZGV4IGNvbnRhaW5zIHVuY29tbWl0dGVkIGNoYW5nZXMuIgogbXNnc3RyICIiCiAiaW1wb3NzaWJpbGUgZXNlZ3VpcmUgJXM6IGwnaW5kaWNlIGNvbnRpZW5lIG1vZGlmaWNoZSBkaSBjdWkgbm9uIMOoIHN0YXRvICIKICJlc2VndWl0byBpbCBjb21taXQuIgogCisjOiBjb21wYXQvcHJlY29tcG9zZV91dGY4LmM6NTggYnVpbHRpbi9jbG9uZS5jOjQ1MgorIywgYy1mb3JtYXQKK21zZ2lkICJmYWlsZWQgdG8gdW5saW5rICclcyciCittc2dzdHIgInVubGluayBkaSAnJXMnIG5vbiByaXVzY2l0byIKKwogIzogYnVpbHRpbi9hZGQuYzoyNQogbXNnaWQgImdpdCBhZGQgWzxvcHRpb25zPl0gWy0tXSA8cGF0aHNwZWM+Li4uIgogbXNnc3RyICJnaXQgYWRkIFs8b3B6aW9uaT5dIFstLV0gPHNwZWNpZmljYXRvcmUgcGVyY29yc28+Li4uIgpAQCAtODYxMiw3ICs4NjU2LDcgQEAKIG1zZ2lkICJVbnN0YWdlZCBjaGFuZ2VzIGFmdGVyIHJlZnJlc2hpbmcgdGhlIGluZGV4OiIKIG1zZ3N0ciAiTW9kaWZpY2hlIG5vbiBuZWxsJ2FyZWEgZGkgc3RhZ2luZyBkb3BvIGwnYWdnaW9ybmFtZW50byBkZWxsJ2luZGljZToiCiAKLSM6IGJ1aWx0aW4vYWRkLmM6MjM0IGJ1aWx0aW4vcmV2LXBhcnNlLmM6ODk2CisjOiBidWlsdGluL2FkZC5jOjIzNCBidWlsdGluL3Jldi1wYXJzZS5jOjg5NwogbXNnaWQgIkNvdWxkIG5vdCByZWFkIHRoZSBpbmRleCIKIG1zZ3N0ciAiSW1wb3NzaWJpbGUgbGVnZ2VyZSBsJ2luZGljZSIKIApAQCAtODY0Nyw4ICs4NjkxLDggQEAKIG1zZ2lkICJUaGUgZm9sbG93aW5nIHBhdGhzIGFyZSBpZ25vcmVkIGJ5IG9uZSBvZiB5b3VyIC5naXRpZ25vcmUgZmlsZXM6XG4iCiBtc2dzdHIgIkkgc2VndWVudGkgcGVyY29yc2kgc29ubyBpZ25vcmF0aSBkYSB1bm8gZGVpIGZpbGUgLmdpdGlnbm9yZTpcbiIKIAotIzogYnVpbHRpbi9hZGQuYzoyOTAgYnVpbHRpbi9jbGVhbi5jOjkwOSBidWlsdGluL2ZldGNoLmM6MTQ3IGJ1aWx0aW4vbXYuYzoxMjQKLSM6IGJ1aWx0aW4vcHJ1bmUtcGFja2VkLmM6NTYgYnVpbHRpbi9wdWxsLmM6MjIyIGJ1aWx0aW4vcHVzaC5jOjU2MAorIzogYnVpbHRpbi9hZGQuYzoyOTAgYnVpbHRpbi9jbGVhbi5jOjkxMCBidWlsdGluL2ZldGNoLmM6MTYyIGJ1aWx0aW4vbXYuYzoxMjQKKyM6IGJ1aWx0aW4vcHJ1bmUtcGFja2VkLmM6NTYgYnVpbHRpbi9wdWxsLmM6MjIzIGJ1aWx0aW4vcHVzaC5jOjU0NwogIzogYnVpbHRpbi9yZW1vdGUuYzoxMzQ1IGJ1aWx0aW4vcm0uYzoyNDEgYnVpbHRpbi9zZW5kLXBhY2suYzoxNjUKIG1zZ2lkICJkcnkgcnVuIgogbXNnc3RyICJ0ZXN0IGNvbnRyb2xsYXRvIgpAQCAtODcwNCw3ICs4NzQ4LDcgQEAKICJjb250cm9sbGEgc2UgaSBmaWxlIC0gYW5jaGUgcXVlbGxpIG1hbmNhbnRpIC0gc29ubyBpZ25vcmF0aSBkdXJhbnRlIGlsIHRlc3QgIgogImNvbnRyb2xsYXRvIgogCi0jOiBidWlsdGluL2FkZC5jOjMwOSBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMDEKKyM6IGJ1aWx0aW4vYWRkLmM6MzA5IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAwMgogbXNnaWQgIm92ZXJyaWRlIHRoZSBleGVjdXRhYmxlIGJpdCBvZiB0aGUgbGlzdGVkIGZpbGVzIgogbXNnc3RyICJlc2VndWkgbCdvdmVycmlkZSBkZWwgYml0IGVzZWd1aWJpbGUgZGVpIGZpbGUgZWxlbmNhdGkiCiAKQEAgLTg3ODAsMTE1ICs4ODI0LDExMSBAQAogbXNnaWQgIk1heWJlIHlvdSB3YW50ZWQgdG8gc2F5ICdnaXQgYWRkIC4nP1xuIgogbXNnc3RyICJGb3JzZSBpbnRlbmRldmkgZGlyZSAnZ2l0IGFkZCAuJz9cbiIKIAotIzogYnVpbHRpbi9hbS5jOjM0OAorIzogYnVpbHRpbi9hbS5jOjM0NwogbXNnaWQgImNvdWxkIG5vdCBwYXJzZSBhdXRob3Igc2NyaXB0IgogbXNnc3RyICJpbXBvc3NpYmlsZSBhbmFsaXp6YXJlIGxvIHNjcmlwdCBhdXRob3IiCiAKLSM6IGJ1aWx0aW4vYW0uYzo0MzIKKyM6IGJ1aWx0aW4vYW0uYzo0MzEKICMsIGMtZm9ybWF0CiBtc2dpZCAiJyVzJyB3YXMgZGVsZXRlZCBieSB0aGUgYXBwbHlwYXRjaC1tc2cgaG9vayIKIG1zZ3N0ciAiJyVzJyDDqCBzdGF0byBlbGltaW5hdG8gZGFsbCdob29rIGFwcGx5cGF0Y2gtbXNnIgogCi0jOiBidWlsdGluL2FtLmM6NDc0CisjOiBidWlsdGluL2FtLmM6NDczCiAjLCBjLWZvcm1hdAogbXNnaWQgIk1hbGZvcm1lZCBpbnB1dCBsaW5lOiAnJXMnLiIKIG1zZ3N0ciAiUmlnYSBkaSBpbnB1dCBtYWxmb3JtYXRhOiAnJXMnLiIKIAotIzogYnVpbHRpbi9hbS5jOjUxMgorIzogYnVpbHRpbi9hbS5jOjUxMQogIywgYy1mb3JtYXQKIG1zZ2lkICJGYWlsZWQgdG8gY29weSBub3RlcyBmcm9tICclcycgdG8gJyVzJyIKIG1zZ3N0ciAiQ29waWEgZGVsbGUgbm90ZSBkYSAnJXMnIGEgJyVzJyBub24gcml1c2NpdGEiCiAKLSM6IGJ1aWx0aW4vYW0uYzo1MzgKKyM6IGJ1aWx0aW4vYW0uYzo1MzcKIG1zZ2lkICJmc2VlayBmYWlsZWQiCiBtc2dzdHIgImZzZWVrIG5vbiByaXVzY2l0YSIKIAotIzogYnVpbHRpbi9hbS5jOjcyNgorIzogYnVpbHRpbi9hbS5jOjcyNQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcGFyc2UgcGF0Y2ggJyVzJyIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgYW5hbGl6emFyZSBsYSBwYXRjaCAnJXMnIgogCi0jOiBidWlsdGluL2FtLmM6NzkxCisjOiBidWlsdGluL2FtLmM6NzkwCiBtc2dpZCAiT25seSBvbmUgU3RHSVQgcGF0Y2ggc2VyaWVzIGNhbiBiZSBhcHBsaWVkIGF0IG9uY2UiCiBtc2dzdHIgIlB1w7IgZXNzZXJlIGFwcGxpY2F0YSBzb2xvIHVuYSBzZXJpZSBkaSBwYXRjaCBTdEdJVCBwZXIgdm9sdGEiCiAKLSM6IGJ1aWx0aW4vYW0uYzo4MzkKKyM6IGJ1aWx0aW4vYW0uYzo4MzgKIG1zZ2lkICJpbnZhbGlkIHRpbWVzdGFtcCIKIG1zZ3N0ciAidGltZXN0YW1wIG5vbiB2YWxpZG8iCiAKLSM6IGJ1aWx0aW4vYW0uYzo4NDQgYnVpbHRpbi9hbS5jOjg1NgorIzogYnVpbHRpbi9hbS5jOjg0MyBidWlsdGluL2FtLmM6ODU1CiBtc2dpZCAiaW52YWxpZCBEYXRlIGxpbmUiCiBtc2dzdHIgInJpZ2EgRGF0ZSBub24gdmFsaWRhIgogCi0jOiBidWlsdGluL2FtLmM6ODUxCisjOiBidWlsdGluL2FtLmM6ODUwCiBtc2dpZCAiaW52YWxpZCB0aW1lem9uZSBvZmZzZXQiCiBtc2dzdHIgIm9mZnNldCBmdXNvIG9yYXJpbyBub24gdmFsaWRvIgogCi0jOiBidWlsdGluL2FtLmM6OTQ0CisjOiBidWlsdGluL2FtLmM6OTQzCiBtc2dpZCAiUGF0Y2ggZm9ybWF0IGRldGVjdGlvbiBmYWlsZWQuIgogbXNnc3RyICJSaWxldmFtZW50byBkZWwgZm9ybWF0byBkZWxsYSBwYXRjaCBub24gcml1c2NpdG8uIgogCi0jOiBidWlsdGluL2FtLmM6OTQ5IGJ1aWx0aW4vY2xvbmUuYzo0MDcKKyM6IGJ1aWx0aW4vYW0uYzo5NDggYnVpbHRpbi9jbG9uZS5jOjQwNgogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gY3JlYXRlIGRpcmVjdG9yeSAnJXMnIgogbXNnc3RyICJjcmVhemlvbmUgZGVsbGEgZGlyZWN0b3J5ICclcycgbm9uIHJpdXNjaXRhIgogCi0jOiBidWlsdGluL2FtLmM6OTU0CisjOiBidWlsdGluL2FtLmM6OTUzCiBtc2dpZCAiRmFpbGVkIHRvIHNwbGl0IHBhdGNoZXMuIgogbXNnc3RyICJEaXZpc2lvbmUgZGVsbGUgcGF0Y2ggbm9uIHJpdXNjaXRhLiIKIAotIzogYnVpbHRpbi9hbS5jOjEwODQgYnVpbHRpbi9jb21taXQuYzozNzQKLW1zZ2lkICJ1bmFibGUgdG8gd3JpdGUgaW5kZXggZmlsZSIKLW1zZ3N0ciAiaW1wb3NzaWJpbGUgc2NyaXZlcmUgaWwgZmlsZSBpbmRpY2UiCi0KLSM6IGJ1aWx0aW4vYW0uYzoxMDk4CisjOiBidWlsdGluL2FtLmM6MTA4NAogIywgYy1mb3JtYXQKIG1zZ2lkICJXaGVuIHlvdSBoYXZlIHJlc29sdmVkIHRoaXMgcHJvYmxlbSwgcnVuIFwiJXMgLS1jb250aW51ZVwiLiIKIG1zZ3N0ciAiVW5hIHZvbHRhIHJpc29sdG8gcXVlc3RvIHByb2JsZW1hLCBlc2VndWkgXCIlcyAtLWNvbnRpbnVlXCIuIgogCi0jOiBidWlsdGluL2FtLmM6MTA5OQorIzogYnVpbHRpbi9hbS5jOjEwODUKICMsIGMtZm9ybWF0CiBtc2dpZCAiSWYgeW91IHByZWZlciB0byBza2lwIHRoaXMgcGF0Y2gsIHJ1biBcIiVzIC0tc2tpcFwiIGluc3RlYWQuIgogbXNnc3RyICJTZSBwcmVmZXJpc2NpIHNhbHRhcmUgcXVlc3RhIHBhdGNoLCBlc2VndWkgaW52ZWNlIFwiJXMgLS1za2lwXCIuIgogCi0jOiBidWlsdGluL2FtLmM6MTEwMAorIzogYnVpbHRpbi9hbS5jOjEwODYKICMsIGMtZm9ybWF0CiBtc2dpZCAiVG8gcmVzdG9yZSB0aGUgb3JpZ2luYWwgYnJhbmNoIGFuZCBzdG9wIHBhdGNoaW5nLCBydW4gXCIlcyAtLWFib3J0XCIuIgogbXNnc3RyICIiCiAiUGVyIHJpcHJpc3RpbmFyZSBpbCBicmFuY2ggb3JpZ2luYXJpbyBlIHRlcm1pbmFyZSBpbCBwYXRjaGluZywgZXNlZ3VpIFwiJXMgLS0iCiAiYWJvcnRcIi4iCiAKLSM6IGJ1aWx0aW4vYW0uYzoxMTgzCisjOiBidWlsdGluL2FtLmM6MTE2OQogbXNnaWQgIlBhdGNoIHNlbnQgd2l0aCBmb3JtYXQ9Zmxvd2VkOyBzcGFjZSBhdCB0aGUgZW5kIG9mIGxpbmVzIG1pZ2h0IGJlIGxvc3QuIgogbXNnc3RyICIiCiAiUGF0Y2ggaW52aWF0YSBjb24gZm9ybWF0PWZsb3dlZDsgZ2xpIHNwYXppIGFsIHRlcm1pbmUgZGVsbGUgcmlnaGUgcG90cmViYmVybyAiCiAiZXNzZXJlIGFuZGF0aSBwZXJkdXRpLiIKIAotIzogYnVpbHRpbi9hbS5jOjEyMTEKKyM6IGJ1aWx0aW4vYW0uYzoxMTk3CiBtc2dpZCAiUGF0Y2ggaXMgZW1wdHkuIgogbXNnc3RyICJMYSBwYXRjaCDDqCB2dW90YS4iCiAKLSM6IGJ1aWx0aW4vYW0uYzoxMjc3CisjOiBidWlsdGluL2FtLmM6MTI2MgorIywgYy1mb3JtYXQKK21zZ2lkICJtaXNzaW5nIGF1dGhvciBsaW5lIGluIGNvbW1pdCAlcyIKK21zZ3N0ciAicmlnYSBhdXRvcmUgbWFuY2FudGUgbmVsIGNvbW1pdCAlcyIKKworIzogYnVpbHRpbi9hbS5jOjEyNjUKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBpZGVudCBsaW5lOiAlLipzIgogbXNnc3RyICJyaWdhIGlkZW50IG5vbiB2YWxpZGE6ICUuKnMiCiAKLSM6IGJ1aWx0aW4vYW0uYzoxMjk5Ci0jLCBjLWZvcm1hdAotbXNnaWQgInVuYWJsZSB0byBwYXJzZSBjb21taXQgJXMiCi1tc2dzdHIgImltcG9zc2liaWxlIGFuYWxpenphcmUgaWwgY29tbWl0ICVzIgotCi0jOiBidWlsdGluL2FtLmM6MTQ5NgorIzogYnVpbHRpbi9hbS5jOjE0ODQKIG1zZ2lkICJSZXBvc2l0b3J5IGxhY2tzIG5lY2Vzc2FyeSBibG9icyB0byBmYWxsIGJhY2sgb24gMy13YXkgbWVyZ2UuIgogbXNnc3RyICIiCiAiRGFsIHJlcG9zaXRvcnkgbWFuY2FubyBpIGJsb2IgbmVjZXNzYXJpIHBlciByaXBpZWdhcmUgc3VsIG1lcmdlIGEgdHJlIHZpZS4iCiAKLSM6IGJ1aWx0aW4vYW0uYzoxNDk4CisjOiBidWlsdGluL2FtLmM6MTQ4NgogbXNnaWQgIlVzaW5nIGluZGV4IGluZm8gdG8gcmVjb25zdHJ1Y3QgYSBiYXNlIHRyZWUuLi4iCiBtc2dzdHIgIiIKICJVdGlsaXp6byBsZSBpbmZvcm1hemlvbmkgZGVsbCdpbmRpY2UgcGVyIHJpY29zdHJ1aXJlIHVuIGFsYmVybyBkaSBiYXNlLi4uIgogCi0jOiBidWlsdGluL2FtLmM6MTUxNworIzogYnVpbHRpbi9hbS5jOjE1MDUKIG1zZ2lkICIiCiAiRGlkIHlvdSBoYW5kIGVkaXQgeW91ciBwYXRjaD9cbiIKICJJdCBkb2VzIG5vdCBhcHBseSB0byBibG9icyByZWNvcmRlZCBpbiBpdHMgaW5kZXguIgpAQCAtODg5NiwyNCArODkzNiwyNCBAQAogIkhhaSBtb2RpZmljYXRvIG1hbnVhbG1lbnRlIGxhIHBhdGNoP1xuIgogIk5vbiBwdcOyIGVzc2VyZSBhcHBsaWNhdGEgYWkgYmxvYiByZWdpc3RyYXRpIG5lbCBzdW8gaW5kaWNlLiIKIAotIzogYnVpbHRpbi9hbS5jOjE1MjMKKyM6IGJ1aWx0aW4vYW0uYzoxNTExCiBtc2dpZCAiRmFsbGluZyBiYWNrIHRvIHBhdGNoaW5nIGJhc2UgYW5kIDMtd2F5IG1lcmdlLi4uIgogbXNnc3RyICJSaXBpZWdvIHN1bCBwYXRjaGluZyBkZWxsYSBiYXNlIGUgc3VsIG1lcmdlIGEgdHJlIHZpZS4uLiIKIAotIzogYnVpbHRpbi9hbS5jOjE1NDkKKyM6IGJ1aWx0aW4vYW0uYzoxNTM3CiBtc2dpZCAiRmFpbGVkIHRvIG1lcmdlIGluIHRoZSBjaGFuZ2VzLiIKIG1zZ3N0ciAiTWVyZ2UgZGVsbGUgbW9kaWZpY2hlIG5vbiByaXVzY2l0by4iCiAKLSM6IGJ1aWx0aW4vYW0uYzoxNTgxCisjOiBidWlsdGluL2FtLmM6MTU2OQogbXNnaWQgImFwcGx5aW5nIHRvIGFuIGVtcHR5IGhpc3RvcnkiCiBtc2dzdHIgImFwcGxpY2F6aW9uZSBhIHVuYSBjcm9ub2xvZ2lhIHZ1b3RhIgogCi0jOiBidWlsdGluL2FtLmM6MTYyOCBidWlsdGluL2FtLmM6MTYzMgorIzogYnVpbHRpbi9hbS5jOjE2MTYgYnVpbHRpbi9hbS5jOjE2MjAKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IHJlc3VtZTogJXMgZG9lcyBub3QgZXhpc3QuIgogbXNnc3RyICJpbXBvc3NpYmlsZSByaXByZW5kZXJlIGwnYXR0aXZpdMOgOiAlcyBub24gZXNpc3RlLiIKIAotIzogYnVpbHRpbi9hbS5jOjE2NTAKKyM6IGJ1aWx0aW4vYW0uYzoxNjM4CiBtc2dpZCAiQ29tbWl0IEJvZHkgaXM6IgogbXNnc3RyICJJbCBjb3JwbyBkZWwgY29tbWl0IMOoOiIKIApAQCAtODkyMSwzNyArODk2MSw0MSBAQAogIy4gaW4geW91ciB0cmFuc2xhdGlvbi4gVGhlIHByb2dyYW0gd2lsbCBvbmx5IGFjY2VwdCBFbmdsaXNoCiAjLiBpbnB1dCBhdCB0aGlzIHBvaW50LgogIy4KLSM6IGJ1aWx0aW4vYW0uYzoxNjYwCisjOiBidWlsdGluL2FtLmM6MTY0OAogIywgYy1mb3JtYXQKIG1zZ2lkICJBcHBseT8gW3ldZXMvW25dby9bZV1kaXQvW3ZdaWV3IHBhdGNoL1thXWNjZXB0IGFsbDogIgogbXNnc3RyICIiCiAiQXBwbGljbz8gU8OsIFt5XS9ObyBbbl0vTW9kaWZpY2EgW2VdL1tWXWlzdWFsaXp6YSBwYXRjaC9bQV1jY2V0dGEgdHV0dG86IgogCi0jOiBidWlsdGluL2FtLmM6MTcxMAorIzogYnVpbHRpbi9hbS5jOjE2OTUgYnVpbHRpbi9jb21taXQuYzozNzQKK21zZ2lkICJ1bmFibGUgdG8gd3JpdGUgaW5kZXggZmlsZSIKK21zZ3N0ciAiaW1wb3NzaWJpbGUgc2NyaXZlcmUgaWwgZmlsZSBpbmRpY2UiCisKKyM6IGJ1aWx0aW4vYW0uYzoxNjk5CiAjLCBjLWZvcm1hdAogbXNnaWQgIkRpcnR5IGluZGV4OiBjYW5ub3QgYXBwbHkgcGF0Y2hlcyAoZGlydHk6ICVzKSIKIG1zZ3N0ciAiSW5kaWNlIHNwb3JjbzogaW1wb3NzaWJpbGUgYXBwbGljYXJlIGxlIHBhdGNoIChlbGVtZW50byBzcG9yY286ICVzKSIKIAotIzogYnVpbHRpbi9hbS5jOjE3NTAgYnVpbHRpbi9hbS5jOjE4MTgKKyM6IGJ1aWx0aW4vYW0uYzoxNzM5IGJ1aWx0aW4vYW0uYzoxODA3CiAjLCBjLWZvcm1hdAogbXNnaWQgIkFwcGx5aW5nOiAlLipzIgogbXNnc3RyICJBcHBsaWNhemlvbmUgaW4gY29yc286ICUuKnMiCiAKLSM6IGJ1aWx0aW4vYW0uYzoxNzY3CisjOiBidWlsdGluL2FtLmM6MTc1NgogbXNnaWQgIk5vIGNoYW5nZXMgLS0gUGF0Y2ggYWxyZWFkeSBhcHBsaWVkLiIKIG1zZ3N0ciAiTmVzc3VuYSBtb2RpZmljYSAtLSBwYXRjaCBnacOgIGFwcGxpY2F0YS4iCiAKLSM6IGJ1aWx0aW4vYW0uYzoxNzczCisjOiBidWlsdGluL2FtLmM6MTc2MgogIywgYy1mb3JtYXQKIG1zZ2lkICJQYXRjaCBmYWlsZWQgYXQgJXMgJS4qcyIKIG1zZ3N0ciAiUGF0Y2ggbm9uIHJpdXNjaXRhIGEgJXMgJS4qcyIKIAotIzogYnVpbHRpbi9hbS5jOjE3NzcKKyM6IGJ1aWx0aW4vYW0uYzoxNzY2CiBtc2dpZCAiVXNlICdnaXQgYW0gLS1zaG93LWN1cnJlbnQtcGF0Y2gnIHRvIHNlZSB0aGUgZmFpbGVkIHBhdGNoIgogbXNnc3RyICIiCiAiVXNhICdnaXQgYW0gLS1zaG93LWN1cnJlbnQtcGF0Y2gnIHBlciB2aXN1YWxpenphcmUgbGEgcGF0Y2ggbm9uIHJpdXNjaXRhIgogCi0jOiBidWlsdGluL2FtLmM6MTgyMQorIzogYnVpbHRpbi9hbS5jOjE4MTAKIG1zZ2lkICIiCiAiTm8gY2hhbmdlcyAtIGRpZCB5b3UgZm9yZ2V0IHRvIHVzZSAnZ2l0IGFkZCc/XG4iCiAiSWYgdGhlcmUgaXMgbm90aGluZyBsZWZ0IHRvIHN0YWdlLCBjaGFuY2VzIGFyZSB0aGF0IHNvbWV0aGluZyBlbHNlXG4iCkBAIC04OTYxLDcgKzkwMDUsNyBAQAogIlNlIG5vbiByaW1hbmUgbnVsbGEgZGEgYWdnaXVuZ2VyZSBhbGwnYXJlYSBkaSBzdGFnaW5nLCBmb3JzZSBxdWFsY29zJ2FsdHJvXG4iCiAiaGEgZ2nDoCBpbnRyb2RvdHRvIGxlIHN0ZXNzZSBtb2RpZmljaGU7IHBvdHJlc3RpIHZvbGVyIHNhbHRhcmUgcXVlc3RhIHBhdGNoLiIKIAotIzogYnVpbHRpbi9hbS5jOjE4MjgKKyM6IGJ1aWx0aW4vYW0uYzoxODE3CiBtc2dpZCAiIgogIllvdSBzdGlsbCBoYXZlIHVubWVyZ2VkIHBhdGhzIGluIHlvdXIgaW5kZXguXG4iCiAiWW91IHNob3VsZCAnZ2l0IGFkZCcgZWFjaCBmaWxlIHdpdGggcmVzb2x2ZWQgY29uZmxpY3RzIHRvIG1hcmsgdGhlbSBhcyAiCkBAIC04OTc0LDE3ICs5MDE4LDE3IEBACiAiUG90cmVzdGkgZXNlZ3VpcmUgYGdpdCBybWAgc3UgdW4gZmlsZSBwZXIgYWNjZXR0YXJuZSBsYSByaXNvbHV6aW9uZSAiCiAiXCJlbGltaW5hdG8gZGEgbG9yb1wiLiIKIAotIzogYnVpbHRpbi9hbS5jOjE5MzUgYnVpbHRpbi9hbS5jOjE5MzkgYnVpbHRpbi9hbS5jOjE5NTEgYnVpbHRpbi9yZXNldC5jOjMyOQorIzogYnVpbHRpbi9hbS5jOjE5MjQgYnVpbHRpbi9hbS5jOjE5MjggYnVpbHRpbi9hbS5jOjE5NDAgYnVpbHRpbi9yZXNldC5jOjMyOQogIzogYnVpbHRpbi9yZXNldC5jOjMzNwogIywgYy1mb3JtYXQKIG1zZ2lkICJDb3VsZCBub3QgcGFyc2Ugb2JqZWN0ICclcycuIgogbXNnc3RyICJJbXBvc3NpYmlsZSBhbmFsaXp6YXJlIGwnb2dnZXR0byAnJXMnLiIKIAotIzogYnVpbHRpbi9hbS5jOjE5ODcKKyM6IGJ1aWx0aW4vYW0uYzoxOTc2CiBtc2dpZCAiZmFpbGVkIHRvIGNsZWFuIGluZGV4IgogbXNnc3RyICJwdWxpemlhIGRlbGwnaW5kaWNlIG5vbiByaXVzY2l0YSIKIAotIzogYnVpbHRpbi9hbS5jOjIwMzEKKyM6IGJ1aWx0aW4vYW0uYzoyMDIwCiBtc2dpZCAiIgogIllvdSBzZWVtIHRvIGhhdmUgbW92ZWQgSEVBRCBzaW5jZSB0aGUgbGFzdCAnYW0nIGZhaWx1cmUuXG4iCiAiTm90IHJld2luZGluZyB0byBPUklHX0hFQUQiCkBAIC04OTkzLDE0OCArOTAzNywxNDggQEAKICInYW0nLlxuIgogIk5vbiByaXRvcm5vIGluZGlldHJvIGEgT1JJR19IRUFEIgogCi0jOiBidWlsdGluL2FtLmM6MjEyOAorIzogYnVpbHRpbi9hbS5jOjIxMTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiSW52YWxpZCB2YWx1ZSBmb3IgLS1wYXRjaC1mb3JtYXQ6ICVzIgogbXNnc3RyICJWYWxvcmUgbm9uIHZhbGlkbyBwZXIgLS1wYXRjaC1mb3JtYXQ6ICVzIgogCi0jOiBidWlsdGluL2FtLmM6MjE2NAorIzogYnVpbHRpbi9hbS5jOjIxNTMKIG1zZ2lkICJnaXQgYW0gWzxvcHRpb25zPl0gWyg8bWJveD4gfCA8TWFpbGRpcj4pLi4uXSIKIG1zZ3N0ciAiZ2l0IGFtIFs8b3B6aW9uaT5dIFsoPG1ib3g+IHwgPE1haWxkaXI+KS4uLl0iCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMTY1CisjOiBidWlsdGluL2FtLmM6MjE1NAogbXNnaWQgImdpdCBhbSBbPG9wdGlvbnM+XSAoLS1jb250aW51ZSB8IC0tc2tpcCB8IC0tYWJvcnQpIgogbXNnc3RyICJnaXQgYW0gWzxvcHppb25pPl0gKC0tY29udGludWUgfCAtLXNraXAgfCAtLWFib3J0KSIKIAotIzogYnVpbHRpbi9hbS5jOjIxNzEKKyM6IGJ1aWx0aW4vYW0uYzoyMTYwCiBtc2dpZCAicnVuIGludGVyYWN0aXZlbHkiCiBtc2dzdHIgImVzZWd1aSBpbiBtb2RhbGl0w6AgaW50ZXJhdHRpdmEiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMTczCisjOiBidWlsdGluL2FtLmM6MjE2MgogbXNnaWQgImhpc3RvcmljYWwgb3B0aW9uIC0tIG5vLW9wIgogbXNnc3RyICJvcHppb25lIHN0b3JpY2EgLS0gbm9uIGVzZWd1ZSBudWxsYSIKIAotIzogYnVpbHRpbi9hbS5jOjIxNzUKKyM6IGJ1aWx0aW4vYW0uYzoyMTY0CiBtc2dpZCAiYWxsb3cgZmFsbCBiYWNrIG9uIDN3YXkgbWVyZ2luZyBpZiBuZWVkZWQiCiBtc2dzdHIgImNvbnNlbnRpIGlsIHJpcGllZ28gc3VsIG1lcmdlIGEgdHJlIHZpZSBzZSBuZWNlc3NhcmlvIgogCi0jOiBidWlsdGluL2FtLmM6MjE3NiBidWlsdGluL2luaXQtZGIuYzo0OTQgYnVpbHRpbi9wcnVuZS1wYWNrZWQuYzo1OAotIzogYnVpbHRpbi9yZXBhY2suYzoyOTYgYnVpbHRpbi9zdGFzaC5jOjgwNgorIzogYnVpbHRpbi9hbS5jOjIxNjUgYnVpbHRpbi9pbml0LWRiLmM6NDk0IGJ1aWx0aW4vcHJ1bmUtcGFja2VkLmM6NTgKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6Mjk3IGJ1aWx0aW4vc3Rhc2guYzo4MTIKIG1zZ2lkICJiZSBxdWlldCIKIG1zZ3N0ciAibm9uIHZpc3VhbGl6emFyZSBtZXNzYWdnaSIKIAotIzogYnVpbHRpbi9hbS5jOjIxNzgKKyM6IGJ1aWx0aW4vYW0uYzoyMTY3CiBtc2dpZCAiYWRkIGEgU2lnbmVkLW9mZi1ieSBsaW5lIHRvIHRoZSBjb21taXQgbWVzc2FnZSIKIG1zZ3N0ciAiYWdnaXVuZ2kgdW5hIHJpZ2EgU2lnbmVkLW9mZi1ieSBhbCBtZXNzYWdnaW8gZGkgY29tbWl0IgogCi0jOiBidWlsdGluL2FtLmM6MjE4MQorIzogYnVpbHRpbi9hbS5jOjIxNzAKIG1zZ2lkICJyZWNvZGUgaW50byB1dGY4IChkZWZhdWx0KSIKIG1zZ3N0ciAiY29udmVydGkgY29kaWZpY2EgaW4gVVRGLTggKGltcG9zdGF6aW9uZSBwcmVkZWZpbml0YSkiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMTgzCisjOiBidWlsdGluL2FtLmM6MjE3MgogbXNnaWQgInBhc3MgLWsgZmxhZyB0byBnaXQtbWFpbGluZm8iCiBtc2dzdHIgImZvcm5pc2NpIGwnYXJnb21lbnRvIC1rIGEgZ2l0LW1haWxpbmZvIgogCi0jOiBidWlsdGluL2FtLmM6MjE4NQorIzogYnVpbHRpbi9hbS5jOjIxNzQKIG1zZ2lkICJwYXNzIC1iIGZsYWcgdG8gZ2l0LW1haWxpbmZvIgogbXNnc3RyICJmb3JuaXNjaSBsJ2FyZ29tZW50byAtYiBhIGdpdC1tYWlsaW5mbyIKIAotIzogYnVpbHRpbi9hbS5jOjIxODcKKyM6IGJ1aWx0aW4vYW0uYzoyMTc2CiBtc2dpZCAicGFzcyAtbSBmbGFnIHRvIGdpdC1tYWlsaW5mbyIKIG1zZ3N0ciAiZm9ybmlzY2kgbCdhcmdvbWVudG8gLW0gYSBnaXQtbWFpbGluZm8iCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMTg5CisjOiBidWlsdGluL2FtLmM6MjE3OAogbXNnaWQgInBhc3MgLS1rZWVwLWNyIGZsYWcgdG8gZ2l0LW1haWxzcGxpdCBmb3IgbWJveCBmb3JtYXQiCiBtc2dzdHIgImZvcm5pc2NpIGEgZ2l0LW1haWxzcGxpdCBsJ2FyZ29tZW50byAtLWtlZXAtY3IgcGVyIGlsIGZvcm1hdG8gbWJveCIKIAotIzogYnVpbHRpbi9hbS5jOjIxOTIKKyM6IGJ1aWx0aW4vYW0uYzoyMTgxCiBtc2dpZCAiZG8gbm90IHBhc3MgLS1rZWVwLWNyIGZsYWcgdG8gZ2l0LW1haWxzcGxpdCBpbmRlcGVuZGVudCBvZiBhbS5rZWVwY3IiCiBtc2dzdHIgIiIKICJub24gZm9ybmlyZSBsJ2FyZ29tZW50byAtLWtlZXAtY3IgYSBnaXQtbWFpbHNwbGl0IGluZGlwZW5kZW50ZW1lbnRlIGRhbCAiCiAidmFsb3JlIGRpIGFtLmtlZXBjciIKIAotIzogYnVpbHRpbi9hbS5jOjIxOTUKKyM6IGJ1aWx0aW4vYW0uYzoyMTg0CiBtc2dpZCAic3RyaXAgZXZlcnl0aGluZyBiZWZvcmUgYSBzY2lzc29ycyBsaW5lIgogbXNnc3RyICJyaW11b3ZpIHR1dHRlIGxlIHJpZ2hlIHByaW1hIGRpIHVuYSByaWdhIFwidGFnbGlhIHF1aVwiIgogCi0jOiBidWlsdGluL2FtLmM6MjE5NyBidWlsdGluL2FtLmM6MjIwMCBidWlsdGluL2FtLmM6MjIwMyBidWlsdGluL2FtLmM6MjIwNgotIzogYnVpbHRpbi9hbS5jOjIyMDkgYnVpbHRpbi9hbS5jOjIyMTIgYnVpbHRpbi9hbS5jOjIyMTUgYnVpbHRpbi9hbS5jOjIyMTgKLSM6IGJ1aWx0aW4vYW0uYzoyMjI0CisjOiBidWlsdGluL2FtLmM6MjE4NiBidWlsdGluL2FtLmM6MjE4OSBidWlsdGluL2FtLmM6MjE5MiBidWlsdGluL2FtLmM6MjE5NQorIzogYnVpbHRpbi9hbS5jOjIxOTggYnVpbHRpbi9hbS5jOjIyMDEgYnVpbHRpbi9hbS5jOjIyMDQgYnVpbHRpbi9hbS5jOjIyMDcKKyM6IGJ1aWx0aW4vYW0uYzoyMjEzCiBtc2dpZCAicGFzcyBpdCB0aHJvdWdoIGdpdC1hcHBseSIKIG1zZ3N0ciAicGFzc2EgbCdhcmdvbWVudG8gYSBnaXQtYXBwbHkiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMjE0IGJ1aWx0aW4vY29tbWl0LmM6MTM2OCBidWlsdGluL2ZtdC1tZXJnZS1tc2cuYzo2NzEKLSM6IGJ1aWx0aW4vZm10LW1lcmdlLW1zZy5jOjY3NCBidWlsdGluL2dyZXAuYzo4ODEgYnVpbHRpbi9tZXJnZS5jOjI0OQotIzogYnVpbHRpbi9wdWxsLmM6MTU5IGJ1aWx0aW4vcHVsbC5jOjIxOCBidWlsdGluL3JlYmFzZS5jOjE0MTgKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MzA3IGJ1aWx0aW4vcmVwYWNrLmM6MzExIGJ1aWx0aW4vcmVwYWNrLmM6MzEzCisjOiBidWlsdGluL2FtLmM6MjIwMyBidWlsdGluL2NvbW1pdC5jOjEzNjggYnVpbHRpbi9mbXQtbWVyZ2UtbXNnLmM6NjcxCisjOiBidWlsdGluL2ZtdC1tZXJnZS1tc2cuYzo2NzQgYnVpbHRpbi9ncmVwLmM6ODgzIGJ1aWx0aW4vbWVyZ2UuYzoyNDkKKyM6IGJ1aWx0aW4vcHVsbC5jOjE2MCBidWlsdGluL3B1bGwuYzoyMTkgYnVpbHRpbi9yZWJhc2UuYzoxNDQyCisjOiBidWlsdGluL3JlcGFjay5jOjMwOCBidWlsdGluL3JlcGFjay5jOjMxMiBidWlsdGluL3JlcGFjay5jOjMxNAogIzogYnVpbHRpbi9zaG93LWJyYW5jaC5jOjY1MCBidWlsdGluL3Nob3ctcmVmLmM6MTcyIGJ1aWx0aW4vdGFnLmM6NDAzCi0jOiBwYXJzZS1vcHRpb25zLmg6MTQxIHBhcnNlLW9wdGlvbnMuaDoxNjIgcGFyc2Utb3B0aW9ucy5oOjMxMgorIzogcGFyc2Utb3B0aW9ucy5oOjE1MCBwYXJzZS1vcHRpb25zLmg6MTcxIHBhcnNlLW9wdGlvbnMuaDozMTIKIG1zZ2lkICJuIgogbXNnc3RyICJuIgogCi0jOiBidWlsdGluL2FtLmM6MjIyMCBidWlsdGluL2JyYW5jaC5jOjY2MSBidWlsdGluL2Zvci1lYWNoLXJlZi5jOjM4Ci0jOiBidWlsdGluL3JlcGxhY2UuYzo1NTQgYnVpbHRpbi90YWcuYzo0MzcgYnVpbHRpbi92ZXJpZnktdGFnLmM6MzgKKyM6IGJ1aWx0aW4vYW0uYzoyMjA5IGJ1aWx0aW4vYnJhbmNoLmM6NjYxIGJ1aWx0aW4vZm9yLWVhY2gtcmVmLmM6MzgKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU1NSBidWlsdGluL3RhZy5jOjQzNyBidWlsdGluL3ZlcmlmeS10YWcuYzozOAogbXNnaWQgImZvcm1hdCIKIG1zZ3N0ciAiZm9ybWF0byIKIAotIzogYnVpbHRpbi9hbS5jOjIyMjEKKyM6IGJ1aWx0aW4vYW0uYzoyMjEwCiBtc2dpZCAiZm9ybWF0IHRoZSBwYXRjaChlcykgYXJlIGluIgogbXNnc3RyICJpbCBmb3JtYXRvIGRlbGxlIHBhdGNoIgogCi0jOiBidWlsdGluL2FtLmM6MjIyNworIzogYnVpbHRpbi9hbS5jOjIyMTYKIG1zZ2lkICJvdmVycmlkZSBlcnJvciBtZXNzYWdlIHdoZW4gcGF0Y2ggZmFpbHVyZSBvY2N1cnMiCiBtc2dzdHIgIiIKICJlc2VndWkgbCdvdmVycmlkZSBkZWwgbWVzc2FnZ2lvIGQnZXJyb3JlIHF1YW5kbyBzaSB2ZXJpZmljYSB1biBlcnJvcmUgbGVnYXRvICIKICJhbGxlIHBhdGNoIgogCi0jOiBidWlsdGluL2FtLmM6MjIyOQorIzogYnVpbHRpbi9hbS5jOjIyMTgKIG1zZ2lkICJjb250aW51ZSBhcHBseWluZyBwYXRjaGVzIGFmdGVyIHJlc29sdmluZyBhIGNvbmZsaWN0IgogbXNnc3RyICIiCiAiY29udGludWEgbCdhcHBsaWNhemlvbmUgZGVsbGUgcGF0Y2ggZG9wbyBsYSByaXNvbHV6aW9uZSBkaSB1biBjb25mbGl0dG8iCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMjMyCisjOiBidWlsdGluL2FtLmM6MjIyMQogbXNnaWQgInN5bm9ueW1zIGZvciAtLWNvbnRpbnVlIgogbXNnc3RyICJzaW5vbmltaSBkaSAtLWNvbnRpbnVlIgogCi0jOiBidWlsdGluL2FtLmM6MjIzNQorIzogYnVpbHRpbi9hbS5jOjIyMjQKIG1zZ2lkICJza2lwIHRoZSBjdXJyZW50IHBhdGNoIgogbXNnc3RyICJzYWx0YSBsYSBwYXRjaCBjb3JyZW50ZSIKIAotIzogYnVpbHRpbi9hbS5jOjIyMzgKKyM6IGJ1aWx0aW4vYW0uYzoyMjI3CiBtc2dpZCAicmVzdG9yZSB0aGUgb3JpZ2luYWwgYnJhbmNoIGFuZCBhYm9ydCB0aGUgcGF0Y2hpbmcgb3BlcmF0aW9uLiIKIG1zZ3N0ciAicmlwcmlzdGluYSBpbCBicmFuY2ggb3JpZ2luYXJpbyBlIGludGVycm9tcGkgbCdvcGVyYXppb25lIGRpIHBhdGNoaW5nLiIKIAotIzogYnVpbHRpbi9hbS5jOjIyNDEKKyM6IGJ1aWx0aW4vYW0uYzoyMjMwCiBtc2dpZCAiYWJvcnQgdGhlIHBhdGNoaW5nIG9wZXJhdGlvbiBidXQga2VlcCBIRUFEIHdoZXJlIGl0IGlzLiIKIG1zZ3N0ciAiaW50ZXJyb21waSBsJ29wZXJhemlvbmUgZGkgcGF0Y2hpbmcgbWEgbWFudGllbmkgSEVBRCBkb3Ynw6guIgogCi0jOiBidWlsdGluL2FtLmM6MjI0NAorIzogYnVpbHRpbi9hbS5jOjIyMzMKIG1zZ2lkICJzaG93IHRoZSBwYXRjaCBiZWluZyBhcHBsaWVkLiIKIG1zZ3N0ciAidmlzdWFsaXp6YSBsYSBwYXRjaCBpbiBmYXNlIGRpIGFwcGxpY2F6aW9uZS4iCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMjQ4CisjOiBidWlsdGluL2FtLmM6MjIzNwogbXNnaWQgImxpZSBhYm91dCBjb21taXR0ZXIgZGF0ZSIKIG1zZ3N0ciAibWVudGkgc3VsbGEgZGF0YSBkZWwgY29tbWl0IgogCi0jOiBidWlsdGluL2FtLmM6MjI1MAorIzogYnVpbHRpbi9hbS5jOjIyMzkKIG1zZ2lkICJ1c2UgY3VycmVudCB0aW1lc3RhbXAgZm9yIGF1dGhvciBkYXRlIgogbXNnc3RyICJ1c2EgaWwgdGltZXN0YW1wIGNvcnJlbnRlIGNvbWUgZGF0YSBhdXRvcmUiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMjUyIGJ1aWx0aW4vY29tbWl0LXRyZWUuYzoxMjAgYnVpbHRpbi9jb21taXQuYzoxNTExCi0jOiBidWlsdGluL21lcmdlLmM6Mjg2IGJ1aWx0aW4vcHVsbC5jOjE5MyBidWlsdGluL3JlYmFzZS5jOjQ4OQotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDU5IGJ1aWx0aW4vcmV2ZXJ0LmM6MTE3IGJ1aWx0aW4vdGFnLmM6NDE4CisjOiBidWlsdGluL2FtLmM6MjI0MSBidWlsdGluL2NvbW1pdC10cmVlLmM6MTIwIGJ1aWx0aW4vY29tbWl0LmM6MTUxMQorIzogYnVpbHRpbi9tZXJnZS5jOjI4NiBidWlsdGluL3B1bGwuYzoxOTQgYnVpbHRpbi9yZWJhc2UuYzo0OTAKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ4MyBidWlsdGluL3JldmVydC5jOjExNyBidWlsdGluL3RhZy5jOjQxOAogbXNnaWQgImtleS1pZCIKIG1zZ3N0ciAiSUQgY2hpYXZlIgogCi0jOiBidWlsdGluL2FtLmM6MjI1MyBidWlsdGluL3JlYmFzZS5jOjQ5MCBidWlsdGluL3JlYmFzZS5jOjE0NjAKKyM6IGJ1aWx0aW4vYW0uYzoyMjQyIGJ1aWx0aW4vcmViYXNlLmM6NDkxIGJ1aWx0aW4vcmViYXNlLmM6MTQ4NAogbXNnaWQgIkdQRy1zaWduIGNvbW1pdHMiCiBtc2dzdHIgImZpcm1hIGkgY29tbWl0IGNvbiBHUEciCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMjU2CisjOiBidWlsdGluL2FtLmM6MjI0NQogbXNnaWQgIihpbnRlcm5hbCB1c2UgZm9yIGdpdC1yZWJhc2UpIgogbXNnc3RyICIoYSB1c28gaW50ZXJubyBwZXIgZ2l0LXJlYmFzZSkiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMjc0CisjOiBidWlsdGluL2FtLmM6MjI2MwogbXNnaWQgIiIKICJUaGUgLWIvLS1iaW5hcnkgb3B0aW9uIGhhcyBiZWVuIGEgbm8tb3AgZm9yIGxvbmcgdGltZSwgYW5kXG4iCiAiaXQgd2lsbCBiZSByZW1vdmVkLiBQbGVhc2UgZG8gbm90IHVzZSBpdCBhbnltb3JlLiIKQEAgLTkxNDIsMTggKzkxODYsMTggQEAKICJMJ29wemlvbmUgLWIvLS1iaW5hcnkgbm9uIGVzZWd1ZSBudWxsYSBkYSBtb2x0byB0ZW1wbyBlXG4iCiAic2Fyw6Agcmltb3NzYS4gTm9uIHVzYXJsYSBwacO5LiIKIAotIzogYnVpbHRpbi9hbS5jOjIyODEKKyM6IGJ1aWx0aW4vYW0uYzoyMjcwCiBtc2dpZCAiZmFpbGVkIHRvIHJlYWQgdGhlIGluZGV4IgogbXNnc3RyICJsZXR0dXJhIGRlbGwnaW5kaWNlIG5vbiByaXVzY2l0YSIKIAotIzogYnVpbHRpbi9hbS5jOjIyOTYKKyM6IGJ1aWx0aW4vYW0uYzoyMjg1CiAjLCBjLWZvcm1hdAogbXNnaWQgInByZXZpb3VzIHJlYmFzZSBkaXJlY3RvcnkgJXMgc3RpbGwgZXhpc3RzIGJ1dCBtYm94IGdpdmVuLiIKIG1zZ3N0ciAiIgogImxhIGRpcmVjdG9yeSBkaSByZWJhc2UgcHJlY2VkZW50ZSAlcyBlc2lzdGUgYW5jb3JhIG1hIMOoIHN0YXRhIHNwZWNpZmljYXRhICIKICJ1bidtYm94LiIKIAotIzogYnVpbHRpbi9hbS5jOjIzMjAKKyM6IGJ1aWx0aW4vYW0uYzoyMzA5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJTdHJheSAlcyBkaXJlY3RvcnkgZm91bmQuXG4iCkBAIC05MTYyLDExICs5MjA2LDExIEBACiAiVHJvdmF0YSBkaXJlY3Rvcnkgc21hcnJpdGEgJXMuXG4iCiAiVXNhIFwiZ2l0IGFtIC0tYWJvcnRcIiBwZXIgZWxpbWluYXJsYS4iCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMzI2CisjOiBidWlsdGluL2FtLmM6MjMxNQogbXNnaWQgIlJlc29sdmUgb3BlcmF0aW9uIG5vdCBpbiBwcm9ncmVzcywgd2UgYXJlIG5vdCByZXN1bWluZy4iCiBtc2dzdHIgIk9wZXJhemlvbmUgZGkgcmlzb2x1emlvbmUgbm9uIGluIGNvcnNvLCBub24gcmlwcmVuZGlhbW8uIgogCi0jOiBidWlsdGluL2FtLmM6MjMzNgorIzogYnVpbHRpbi9hbS5jOjIzMjUKIG1zZ2lkICJpbnRlcmFjdGl2ZSBtb2RlIHJlcXVpcmVzIHBhdGNoZXMgb24gdGhlIGNvbW1hbmQgbGluZSIKIG1zZ3N0ciAiIgogImxhIG1vZGFsaXTDoCBpbnRlcmF0dGl2YSByaWNoaWVkZSBjaGUgbGUgcGF0Y2ggc2lhbm8gZm9ybml0ZSBzdWxsYSByaWdhIGRpICIKQEAgLTk0ODksMTcyICs5NTMzLDE3MiBAQAogbXNnaWQgIi0tYmlzZWN0LXRlcm1zIHJlcXVpcmVzIDAgb3IgMSBhcmd1bWVudCIKIG1zZ3N0ciAiLS1iaXNlY3QtdGVybXMgcmljaGllZGUgemVybyBvIHVuIGFyZ29tZW50byIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjMyCisjOiBidWlsdGluL2JsYW1lLmM6MzEKIG1zZ2lkICJnaXQgYmxhbWUgWzxvcHRpb25zPl0gWzxyZXYtb3B0cz5dIFs8cmV2Pl0gWy0tXSA8ZmlsZT4iCiBtc2dzdHIgImdpdCBibGFtZSBbPG9wemlvbmk+XSBbPG9wemlvbmkgcmV2aXNpb25lPl0gWzxyZXZpc2lvbmU+XSBbLS1dIDxmaWxlPiIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjM3CisjOiBidWlsdGluL2JsYW1lLmM6MzYKIG1zZ2lkICI8cmV2LW9wdHM+IGFyZSBkb2N1bWVudGVkIGluIGdpdC1yZXYtbGlzdCgxKSIKIG1zZ3N0ciAibGUgPG9wemlvbmkgcmV2aXNpb25lPiBzb25vIGRvY3VtZW50YXRlIGluIGdpdC1yZXYtbGlzdCgxKSIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjQxMAorIzogYnVpbHRpbi9ibGFtZS5jOjQwOQogIywgYy1mb3JtYXQKIG1zZ2lkICJleHBlY3RpbmcgYSBjb2xvcjogJXMiCiBtc2dzdHIgImF0dGVzbyBjb2xvcmU6ICVzIgogCi0jOiBidWlsdGluL2JsYW1lLmM6NDE3CisjOiBidWlsdGluL2JsYW1lLmM6NDE2CiBtc2dpZCAibXVzdCBlbmQgd2l0aCBhIGNvbG9yIgogbXNnc3RyICJkZXZlIHRlcm1pbmFyZSBjb24gdW4gY29sb3JlIgogCi0jOiBidWlsdGluL2JsYW1lLmM6NzMwCisjOiBidWlsdGluL2JsYW1lLmM6NzI5CiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgY29sb3IgJyVzJyBpbiBjb2xvci5ibGFtZS5yZXBlYXRlZExpbmVzIgogbXNnc3RyICJjb2xvcmUgJyVzJyBub24gdmFsaWRvIGluIGNvbG9yLmJsYW1lLnJlcGVhdGVkTGluZXMiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo3NDgKKyM6IGJ1aWx0aW4vYmxhbWUuYzo3NDcKIG1zZ2lkICJpbnZhbGlkIHZhbHVlIGZvciBibGFtZS5jb2xvcmluZyIKIG1zZ3N0ciAidmFsb3JlIG5vbiB2YWxpZG8gcGVyIGJsYW1lLmNvbG9yaW5nIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODIzCisjOiBidWlsdGluL2JsYW1lLmM6ODIyCiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCBmaW5kIHJldmlzaW9uICVzIHRvIGlnbm9yZSIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgdHJvdmFyZSBsYSByZXZpc2lvbmUgJXMgZGEgaWdub3JhcmUiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NDUKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NDQKIG1zZ2lkICJTaG93IGJsYW1lIGVudHJpZXMgYXMgd2UgZmluZCB0aGVtLCBpbmNyZW1lbnRhbGx5IgogbXNnc3RyICIiCiAiVmlzdWFsaXp6YSBsZSB2b2NpIGJsYW1lIGluY3JlbWVudGFsbWVudGUsIGEgbWFubyBhIG1hbm8gY2hlIGxlIHRyb3ZpYW1vIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODQ2CisjOiBidWlsdGluL2JsYW1lLmM6ODQ1CiBtc2dpZCAiU2hvdyBibGFuayBTSEEtMSBmb3IgYm91bmRhcnkgY29tbWl0cyAoRGVmYXVsdDogb2ZmKSIKIG1zZ3N0ciAiIgogIlZpc3VhbGl6emEgdW4gaGFzaCBTSEEtMSB2dW90byBwZXIgaSBjb21taXQgbGltaXRlIChpbXBvc3RhemlvbmUgIgogInByZWRlZmluaXRhOiBvZmYpIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODQ3CisjOiBidWlsdGluL2JsYW1lLmM6ODQ2CiBtc2dpZCAiRG8gbm90IHRyZWF0IHJvb3QgY29tbWl0cyBhcyBib3VuZGFyaWVzIChEZWZhdWx0OiBvZmYpIgogbXNnc3RyICIiCiAiTm9uIGdlc3RpcmUgaSBjb21taXQgcmFkaWNlIGNvbWUgY29tbWl0IGxpbWl0ZSAoaW1wb3N0YXppb25lIHByZWRlZmluaXRhOiAiCiAib2ZmKSIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg0OAorIzogYnVpbHRpbi9ibGFtZS5jOjg0NwogbXNnaWQgIlNob3cgd29yayBjb3N0IHN0YXRpc3RpY3MiCiBtc2dzdHIgIlZpc3VhbGl6emEgbGUgc3RhdGlzdGljaGUgc3VsIGNvc3RvIGRlbGwnb3BlcmF6aW9uZSIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg0OQorIzogYnVpbHRpbi9ibGFtZS5jOjg0OAogbXNnaWQgIkZvcmNlIHByb2dyZXNzIHJlcG9ydGluZyIKIG1zZ3N0ciAiRm9yemEgbCdpbmRpY2F6aW9uZSBkJ2F2YW56YW1lbnRvIGRlbGwnb3BlcmF6aW9uZSIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg1MAorIzogYnVpbHRpbi9ibGFtZS5jOjg0OQogbXNnaWQgIlNob3cgb3V0cHV0IHNjb3JlIGZvciBibGFtZSBlbnRyaWVzIgogbXNnc3RyICJWaXN1YWxpenphIGlsIHB1bnRlZ2dpbyBkaSBvdXRwdXQgcGVyIGxlIHZvY2kgYmxhbWUiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NTEKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NTAKIG1zZ2lkICJTaG93IG9yaWdpbmFsIGZpbGVuYW1lIChEZWZhdWx0OiBhdXRvKSIKIG1zZ3N0ciAiIgogIlZpc3VhbGl6emEgaWwgbm9tZSBmaWxlIG9yaWdpbmFyaW8gKGltcG9zdGF6aW9uZSBwcmVkZWZpbml0YTogYXV0b21hdGljbykiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NTIKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NTEKIG1zZ2lkICJTaG93IG9yaWdpbmFsIGxpbmVudW1iZXIgKERlZmF1bHQ6IG9mZikiCiBtc2dzdHIgIiIKICJWaXN1YWxpenphIGlsIG51bWVybyBkaSByaWdhIG9yaWdpbmFyaW8gKGltcG9zdGF6aW9uZSBwcmVkZWZpbml0YTogb2ZmKSIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg1MworIzogYnVpbHRpbi9ibGFtZS5jOjg1MgogbXNnaWQgIlNob3cgaW4gYSBmb3JtYXQgZGVzaWduZWQgZm9yIG1hY2hpbmUgY29uc3VtcHRpb24iCiBtc2dzdHIgIiIKICJWaXN1YWxpenphIGwnb3V0cHV0IGluIHVuIGZvcm1hdG8gcHJvZ2V0dGF0byBwZXIgbCd1dGlsaXp6byBkYSBwYXJ0ZSBkaSB1bmEgIgogIm1hY2NoaW5hIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODU0CisjOiBidWlsdGluL2JsYW1lLmM6ODUzCiBtc2dpZCAiU2hvdyBwb3JjZWxhaW4gZm9ybWF0IHdpdGggcGVyLWxpbmUgY29tbWl0IGluZm9ybWF0aW9uIgogbXNnc3RyICIiCiAiVmlzdWFsaXp6YSBpbCBmb3JtYXRvIHBvcmNlbGFpbiBjb24gbGUgaW5mb3JtYXppb25pIHN1bCBjb21taXQgcGVyIG9nbmkgcmlnYSIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg1NQorIzogYnVpbHRpbi9ibGFtZS5jOjg1NAogbXNnaWQgIlVzZSB0aGUgc2FtZSBvdXRwdXQgbW9kZSBhcyBnaXQtYW5ub3RhdGUgKERlZmF1bHQ6IG9mZikiCiBtc2dzdHIgIiIKICJVc2EgbGEgc3Rlc3NhIG1vZGFsaXTDoCBkaSBvdXRwdXQgZGkgZ2l0LWFubm90YXRlIChpbXBvc3RhemlvbmUgcHJlZGVmaW5pdGE6ICIKICJvZmYpIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODU2CisjOiBidWlsdGluL2JsYW1lLmM6ODU1CiBtc2dpZCAiU2hvdyByYXcgdGltZXN0YW1wIChEZWZhdWx0OiBvZmYpIgogbXNnc3RyICJWaXN1YWxpenphIGlsIHRpbWVzdGFtcCBncmV6em8gKGltcG9zdGF6aW9uZSBwcmVkZWZpbml0YTogb2ZmKSIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg1NworIzogYnVpbHRpbi9ibGFtZS5jOjg1NgogbXNnaWQgIlNob3cgbG9uZyBjb21taXQgU0hBMSAoRGVmYXVsdDogb2ZmKSIKIG1zZ3N0ciAiIgogIlZpc3VhbGl6emEgbCdoYXNoIFNIQTEgZGVsIGNvbW1pdCBpbiBmb3JtYSBsdW5nYSAoaW1wb3N0YXppb25lIHByZWRlZmluaXRhOiAiCiAib2ZmKSIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg1OAorIzogYnVpbHRpbi9ibGFtZS5jOjg1NwogbXNnaWQgIlN1cHByZXNzIGF1dGhvciBuYW1lIGFuZCB0aW1lc3RhbXAgKERlZmF1bHQ6IG9mZikiCiBtc2dzdHIgIiIKICJOb24gdmlzdWFsaXp6YXJlIGlsIG5vbWUgYXV0b3JlIGUgaWwgdGltZXN0YW1wIChpbXBvc3RhemlvbmUgcHJlZGVmaW5pdGE6ICIKICJvZmYpIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODU5CisjOiBidWlsdGluL2JsYW1lLmM6ODU4CiBtc2dpZCAiU2hvdyBhdXRob3IgZW1haWwgaW5zdGVhZCBvZiBuYW1lIChEZWZhdWx0OiBvZmYpIgogbXNnc3RyICIiCiAiVmlzdWFsaXp6YSBsJ2luZGlyaXp6byBlLW1haWwgZGVsbCdhdXRvcmUgaW52ZWNlIGRlbCBub21lIChpbXBvc3RhemlvbmUgIgogInByZWRlZmluaXRhOiBvZmYpIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODYwCisjOiBidWlsdGluL2JsYW1lLmM6ODU5CiBtc2dpZCAiSWdub3JlIHdoaXRlc3BhY2UgZGlmZmVyZW5jZXMiCiBtc2dzdHIgIklnbm9yYSBsZSBkaWZmZXJlbnplIHJlbGF0aXZlIGFnbGkgc3BhemkgYmlhbmNoaSIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg2MSBidWlsdGluL2xvZy5jOjE2MjkKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NjAgYnVpbHRpbi9sb2cuYzoxNjMwCiBtc2dpZCAicmV2IgogbXNnc3RyICJyZXZpc2lvbmUiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NjEKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NjAKIG1zZ2lkICJJZ25vcmUgPHJldj4gd2hlbiBibGFtaW5nIgogbXNnc3RyICJJZ25vcmEgPHJldmlzaW9uZT4gZHVyYW50ZSBsJ2VzZWN1emlvbmUgZGVsIGJsYW1lIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODYyCisjOiBidWlsdGluL2JsYW1lLmM6ODYxCiBtc2dpZCAiSWdub3JlIHJldmlzaW9ucyBmcm9tIDxmaWxlPiIKIG1zZ3N0ciAiSWdub3JhIGxlIHJldmlzaW9uaSBzcGVjaWZpY2F0ZSBpbiA8ZmlsZT4iCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NjMKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NjIKIG1zZ2lkICJjb2xvciByZWR1bmRhbnQgbWV0YWRhdGEgZnJvbSBwcmV2aW91cyBsaW5lIGRpZmZlcmVudGx5IgogbXNnc3RyICJjb2xvcmEgaW4gbW9kbyBkaWZmZXJlbnRlIGkgbWV0YWRhdGkgcmlkb25kYW50aSBkZWxsYSByaWdhIHByZWNlZGVudGUiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NjQKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NjMKIG1zZ2lkICJjb2xvciBsaW5lcyBieSBhZ2UiCiBtc2dzdHIgImNvbG9yYSBsZSByaWdoZSBpbiBiYXNlIGFsbCdldMOgIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODcxCisjOiBidWlsdGluL2JsYW1lLmM6ODcwCiBtc2dpZCAiVXNlIGFuIGV4cGVyaW1lbnRhbCBoZXVyaXN0aWMgdG8gaW1wcm92ZSBkaWZmcyIKIG1zZ3N0ciAiVXNhIHVuJ2V1cmlzdGljYSBzcGVyaW1lbnRhbGUgcGVyIG1pZ2xpb3JhcmUgaSBkaWZmIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODczCisjOiBidWlsdGluL2JsYW1lLmM6ODcyCiBtc2dpZCAiU3BlbmQgZXh0cmEgY3ljbGVzIHRvIGZpbmQgYmV0dGVyIG1hdGNoIgogbXNnc3RyICJVc2EgY2ljbGkgZXh0cmEgcGVyIHRyb3ZhcmUgdW5hIGNvcnJpc3BvbmRlbnphIG1pZ2xpb3JlIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODc0CisjOiBidWlsdGluL2JsYW1lLmM6ODczCiBtc2dpZCAiVXNlIHJldmlzaW9ucyBmcm9tIDxmaWxlPiBpbnN0ZWFkIG9mIGNhbGxpbmcgZ2l0LXJldi1saXN0IgogbXNnc3RyICJVc2EgbGUgcmV2aXNpb25pIHNhbHZhdGUgaW4gPGZpbGU+IGFuemljaMOpIHJpY2hpYW1hcmUgZ2l0LXJldi1saXN0IgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODc1CisjOiBidWlsdGluL2JsYW1lLmM6ODc0CiBtc2dpZCAiVXNlIDxmaWxlPidzIGNvbnRlbnRzIGFzIHRoZSBmaW5hbCBpbWFnZSIKIG1zZ3N0ciAiVXNhIGkgY29udGVudXRpIGRpIDxmaWxlPiBjb21lIGltbWFnaW5lIGZpbmFsZSIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg3NiBidWlsdGluL2JsYW1lLmM6ODc3CisjOiBidWlsdGluL2JsYW1lLmM6ODc1IGJ1aWx0aW4vYmxhbWUuYzo4NzYKIG1zZ2lkICJzY29yZSIKIG1zZ3N0ciAicHVudGVnZ2lvIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODc2CisjOiBidWlsdGluL2JsYW1lLmM6ODc1CiBtc2dpZCAiRmluZCBsaW5lIGNvcGllcyB3aXRoaW4gYW5kIGFjcm9zcyBmaWxlcyIKIG1zZ3N0ciAiVHJvdmEgY29waWUgZGVsbGUgcmlnaGUgYWxsJ2ludGVybm8gZSBmcmEgZmlsZSIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg3NworIzogYnVpbHRpbi9ibGFtZS5jOjg3NgogbXNnaWQgIkZpbmQgbGluZSBtb3ZlbWVudHMgd2l0aGluIGFuZCBhY3Jvc3MgZmlsZXMiCiBtc2dzdHIgIlRyb3ZhIHJpZ2hlIHNwb3N0YXRlIGFsbCdpbnRlcm5vIGUgZnJhIGZpbGUiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NzgKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NzcKIG1zZ2lkICJuLG0iCiBtc2dzdHIgIm4sbSIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg3OAorIzogYnVpbHRpbi9ibGFtZS5jOjg3NwogbXNnaWQgIlByb2Nlc3Mgb25seSBsaW5lIHJhbmdlIG4sbSwgY291bnRpbmcgZnJvbSAxIgogbXNnc3RyICJFbGFib3JhIHNvbG8gbCdpbnRlcnZhbGxvIHJpZ2hlIG4sbSwgY29udGFuZG9sZSBkYSAxIgogCkBAIC05OTAwLDcgKzk5NDQsNyBAQAogbXNnaWQgImRvIG5vdCB1c2UiCiBtc2dzdHIgIm5vbiB1c2FyZSIKIAotIzogYnVpbHRpbi9icmFuY2guYzo2MjYgYnVpbHRpbi9yZWJhc2UuYzo0ODUKKyM6IGJ1aWx0aW4vYnJhbmNoLmM6NjI2IGJ1aWx0aW4vcmViYXNlLmM6NDg2CiBtc2dpZCAidXBzdHJlYW0iCiBtc2dzdHIgInVwc3RyZWFtIgogCkBAIC0xMDAxMiw3ICsxMDA1Niw3IEBACiBtc2dpZCAiZm9ybWF0IHRvIHVzZSBmb3IgdGhlIG91dHB1dCIKIG1zZ3N0ciAiZm9ybWF0byBkYSB1c2FyZSBwZXIgbCdvdXRwdXQiCiAKLSM6IGJ1aWx0aW4vYnJhbmNoLmM6Njg0IGJ1aWx0aW4vY2xvbmUuYzo3NjEKKyM6IGJ1aWx0aW4vYnJhbmNoLmM6Njg0IGJ1aWx0aW4vY2xvbmUuYzo3NjAKIG1zZ2lkICJIRUFEIG5vdCBmb3VuZCBiZWxvdyByZWZzL2hlYWRzISIKIG1zZ3N0ciAiSEVBRCBub24gdHJvdmF0byBmcmEgaSByaWZlcmltZW50aS9oZWFkISIKIApAQCAtMTAxMjEsNyArMTAxNjUsNyBAQAogbXNnaWQgIk5lZWQgYSByZXBvc2l0b3J5IHRvIHVuYnVuZGxlLiIKIG1zZ3N0ciAiUGVyIGRlY29tcHJpbWVyZSB1biBidW5kbGUgw6ggbmVjZXNzYXJpbyB1biByZXBvc2l0b3J5LiIKIAotIzogYnVpbHRpbi9jYXQtZmlsZS5jOjU5NAorIzogYnVpbHRpbi9jYXQtZmlsZS5jOjU5NQogbXNnaWQgIiIKICJnaXQgY2F0LWZpbGUgKC10IFstLWFsbG93LXVua25vd24tdHlwZV0gfCAtcyBbLS1hbGxvdy11bmtub3duLXR5cGVdIHwgLWUgfCAtIgogInAgfCA8dHlwZT4gfCAtLXRleHRjb252IHwgLS1maWx0ZXJzKSBbLS1wYXRoPTxwYXRoPl0gPG9iamVjdD4iCkBAIC0xMDEyOSw3ICsxMDE3Myw3IEBACiAiZ2l0IGNhdC1maWxlICgtdCBbLS1hbGxvdy11bmtub3duLXR5cGVdIHwgLXMgWy0tYWxsb3ctdW5rbm93bi10eXBlXSB8IC1lIHwgLSIKICJwIHwgPHRpcG8+IHwgLS10ZXh0Y29udiB8IC0tZmlsdGVycykgWy0tcGF0aD08cGVyY29yc28+XSA8b2dnZXR0bz4iCiAKLSM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo1OTUKKyM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo1OTYKIG1zZ2lkICIiCiAiZ2l0IGNhdC1maWxlICgtLWJhdGNoIHwgLS1iYXRjaC1jaGVjaykgWy0tZm9sbG93LXN5bWxpbmtzXSBbLS10ZXh0Y29udiB8IC0tIgogImZpbHRlcnNdIgpAQCAtMTAxMzcsNzUgKzEwMTgxLDc1IEBACiAiZ2l0IGNhdC1maWxlICgtLWJhdGNoIHwgLS1iYXRjaC1jaGVjaykgWy0tZm9sbG93LXN5bWxpbmtzXSBbLS10ZXh0Y29udiB8IC0tIgogImZpbHRlcnNdIgogCi0jOiBidWlsdGluL2NhdC1maWxlLmM6NjE2CisjOiBidWlsdGluL2NhdC1maWxlLmM6NjE3CiBtc2dpZCAib25seSBvbmUgYmF0Y2ggb3B0aW9uIG1heSBiZSBzcGVjaWZpZWQiCiBtc2dzdHIgInB1w7IgZXNzZXJlIHNwZWNpZmljYXRhIHNvbG8gdW4nb3B6aW9uZSBiYXRjaCIKIAotIzogYnVpbHRpbi9jYXQtZmlsZS5jOjYzNAorIzogYnVpbHRpbi9jYXQtZmlsZS5jOjYzNQogbXNnaWQgIjx0eXBlPiBjYW4gYmUgb25lIG9mOiBibG9iLCB0cmVlLCBjb21taXQsIHRhZyIKIG1zZ3N0ciAiPHRpcG8+IHB1w7IgZXNzZXJlIHVubyBmcmEgYmxvYiwgdHJlZSwgY29tbWl0LCB0YWciCiAKLSM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2MzUKKyM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2MzYKIG1zZ2lkICJzaG93IG9iamVjdCB0eXBlIgogbXNnc3RyICJ2aXN1YWxpenphIHRpcG8gb2dnZXR0byIKIAotIzogYnVpbHRpbi9jYXQtZmlsZS5jOjYzNgorIzogYnVpbHRpbi9jYXQtZmlsZS5jOjYzNwogbXNnaWQgInNob3cgb2JqZWN0IHNpemUiCiBtc2dzdHIgInZpc3VhbGl6emEgZGltZW5zaW9uaSBvZ2dldHRvIgogCi0jOiBidWlsdGluL2NhdC1maWxlLmM6NjM4CisjOiBidWlsdGluL2NhdC1maWxlLmM6NjM5CiBtc2dpZCAiZXhpdCB3aXRoIHplcm8gd2hlbiB0aGVyZSdzIG5vIGVycm9yIgogbXNnc3RyICJlc2NpIGNvbiBjb2RpY2UgZCd1c2NpdGEgemVybyBzZSBub24gc2kgc29ubyB2ZXJpZmljYXRpIGVycm9yaSIKIAotIzogYnVpbHRpbi9jYXQtZmlsZS5jOjYzOQorIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY0MAogbXNnaWQgInByZXR0eS1wcmludCBvYmplY3QncyBjb250ZW50IgogbXNnc3RyICJzdGFtcGEgaWwgY29udGVudXRvIGRlbGwnb2dnZXR0byBjb24gdW4gZm9ybWF0byBsZWdnaWJpbGUiCiAKLSM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NDEKKyM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NDIKIG1zZ2lkICJmb3IgYmxvYiBvYmplY3RzLCBydW4gdGV4dGNvbnYgb24gb2JqZWN0J3MgY29udGVudCIKIG1zZ3N0ciAiZXNlZ3VpIHRleHRjb252IHN1bCBjb250ZW51dG8gZGVsbCdvZ2dldHRvIChwZXIgZ2xpIG9nZ2V0dGkgYmxvYikiCiAKLSM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NDMKKyM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NDQKIG1zZ2lkICJmb3IgYmxvYiBvYmplY3RzLCBydW4gZmlsdGVycyBvbiBvYmplY3QncyBjb250ZW50IgogbXNnc3RyICJlc2VndWkgaSBmaWx0cmkgc3VsIGNvbnRlbnV0byBkZWxsJ29nZ2V0dG8gKHBlciBnbGkgb2dnZXR0aSBibG9iKSIKIAotIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY0NCBnaXQtc3VibW9kdWxlLnNoOjkzNgorIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY0NSBnaXQtc3VibW9kdWxlLnNoOjkzNgogbXNnaWQgImJsb2IiCiBtc2dzdHIgImJsb2IiCiAKLSM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NDUKKyM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NDYKIG1zZ2lkICJ1c2UgYSBzcGVjaWZpYyBwYXRoIGZvciAtLXRleHRjb252Ly0tZmlsdGVycyIKIG1zZ3N0ciAidXNhIHVuIHBlcmNvcnNvIHNwZWNpZmljbyBwZXIgLS10ZXh0Y29udi8tLWZpbHRlcnMiCiAKLSM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NDcKKyM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NDgKIG1zZ2lkICJhbGxvdyAtcyBhbmQgLXQgdG8gd29yayB3aXRoIGJyb2tlbi9jb3JydXB0IG9iamVjdHMiCiBtc2dzdHIgImNvbnNlbnRpIGEgLXMgZSAtdCBkaSBmdW56aW9uYXJlIGNvbiBvZ2dldHRpIG1hbGZvcm1hdGkvY29ycm90dGkiCiAKLSM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NDgKKyM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NDkKIG1zZ2lkICJidWZmZXIgLS1iYXRjaCBvdXRwdXQiCiBtc2dzdHIgImVzZWd1aSBpbCBidWZmZXJpbmcgZGVsbCdvdXRwdXQgZGkgLS1iYXRjaCIKIAotIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY1MAorIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY1MQogbXNnaWQgInNob3cgaW5mbyBhbmQgY29udGVudCBvZiBvYmplY3RzIGZlZCBmcm9tIHRoZSBzdGFuZGFyZCBpbnB1dCIKIG1zZ3N0ciAiIgogInZpc3VhbGl6emEgbGUgaW5mb3JtYXppb25pIGUgaWwgY29udGVudXRvIGRlZ2xpIG9nZ2V0dGkgZm9ybml0aSBuZWxsbyAiCiAic3RhbmRhcmQgaW5wdXQiCiAKLSM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NTQKKyM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NTUKIG1zZ2lkICJzaG93IGluZm8gYWJvdXQgb2JqZWN0cyBmZWQgZnJvbSB0aGUgc3RhbmRhcmQgaW5wdXQiCiBtc2dzdHIgInZpc3VhbGl6emEgbGUgaW5mb3JtYXppb25pIGRlZ2xpIG9nZ2V0dGkgZm9ybml0aSBuZWxsbyBzdGFuZGFyZCBpbnB1dCIKIAotIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY1OAorIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY1OQogbXNnaWQgImZvbGxvdyBpbi10cmVlIHN5bWxpbmtzICh1c2VkIHdpdGggLS1iYXRjaCBvciAtLWJhdGNoLWNoZWNrKSIKIG1zZ3N0ciAiIgogInNlZ3VpIGkgY29sbGVnYW1lbnRpIHNpbWJvbGljaSBlbnRybyBsJ2FsYmVybyAodXNhdG8gY29uIC0tYmF0Y2ggbyAtLWJhdGNoLSIKICJjaGVjaykiCiAKLSM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NjAKKyM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NjEKIG1zZ2lkICJzaG93IGFsbCBvYmplY3RzIHdpdGggLS1iYXRjaCBvciAtLWJhdGNoLWNoZWNrIgogbXNnc3RyICJ2aXN1YWxpenphIHR1dHRpIGdsaSBvZ2dldHRpIGNvbiAtLWJhdGNoIG8gLS1iYXRjaC1jaGVjayIKIAotIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY2MgorIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY2MwogbXNnaWQgImRvIG5vdCBvcmRlciAtLWJhdGNoLWFsbC1vYmplY3RzIG91dHB1dCIKIG1zZ3N0ciAibm9uIG9yZGluYXJlIGwnb3V0cHV0IGRpIC0tYmF0Y2gtYWxsLW9iamVjdHMiCiAKQEAgLTEwMjMzLDggKzEwMjc3LDggQEAKIG1zZ2lkICJ0ZXJtaW5hdGUgaW5wdXQgYW5kIG91dHB1dCByZWNvcmRzIGJ5IGEgTlVMIGNoYXJhY3RlciIKIG1zZ3N0ciAidGVybWluYSBpIHJlY29yZCBkaSBpbnB1dCBlIG91dHB1dCBjb24gdW4gY2FyYXR0ZXJlIE5VTCIKIAotIzogYnVpbHRpbi9jaGVjay1pZ25vcmUuYzoyMSBidWlsdGluL2NoZWNrb3V0LmM6MTQzMyBidWlsdGluL2djLmM6NTM4Ci0jOiBidWlsdGluL3dvcmt0cmVlLmM6NTA3CisjOiBidWlsdGluL2NoZWNrLWlnbm9yZS5jOjIxIGJ1aWx0aW4vY2hlY2tvdXQuYzoxNDMzIGJ1aWx0aW4vZ2MuYzo1MzcKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo1MDYKIG1zZ2lkICJzdXBwcmVzcyBwcm9ncmVzcyByZXBvcnRpbmciCiBtc2dzdHIgIm5vbiB2aXN1YWxpenphcmUgbCdhdmFuemFtZW50byBkZWxsJ29wZXJhemlvbmUiCiAKQEAgLTEwMzI2LDcgKzEwMzcwLDcgQEAKICM6IGJ1aWx0aW4vY2hlY2tvdXQtaW5kZXguYzoxNzggYnVpbHRpbi9jb2x1bW4uYzozMQogIzogYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjEzNzMgYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjEzNzYKICM6IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxMzg0IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxODU3Ci0jOiBidWlsdGluL3dvcmt0cmVlLmM6NjgwCisjOiBidWlsdGluL3dvcmt0cmVlLmM6Njc5CiBtc2dpZCAic3RyaW5nIgogbXNnc3RyICJzdHJpbmdhIgogCkBAIC0xMDM1NCwxMDAgKzEwMzk4LDEwMCBAQAogbXNnaWQgImdpdCByZXN0b3JlIFs8b3B0aW9ucz5dIFstLXNvdXJjZT08YnJhbmNoPl0gPGZpbGU+Li4uIgogbXNnc3RyICJnaXQgcmVzdG9yZSBbPG9wemlvbmk+XSBbLS1zb3VyY2U9PGJyYW5jaD5dIDxmaWxlPi4uLiIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjE3MiBidWlsdGluL2NoZWNrb3V0LmM6MjExCisjOiBidWlsdGluL2NoZWNrb3V0LmM6MTczIGJ1aWx0aW4vY2hlY2tvdXQuYzoyMTIKICMsIGMtZm9ybWF0CiBtc2dpZCAicGF0aCAnJXMnIGRvZXMgbm90IGhhdmUgb3VyIHZlcnNpb24iCiBtc2dzdHIgImlsIHBlcmNvcnNvICclcycgbm9uIGhhIGxhIG5vc3RyYSB2ZXJzaW9uZSIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjE3NCBidWlsdGluL2NoZWNrb3V0LmM6MjEzCisjOiBidWlsdGluL2NoZWNrb3V0LmM6MTc1IGJ1aWx0aW4vY2hlY2tvdXQuYzoyMTQKICMsIGMtZm9ybWF0CiBtc2dpZCAicGF0aCAnJXMnIGRvZXMgbm90IGhhdmUgdGhlaXIgdmVyc2lvbiIKIG1zZ3N0ciAiaWwgcGVyY29yc28gJyVzJyBub24gaGEgbGEgbG9ybyB2ZXJzaW9uZSIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjE5MAorIzogYnVpbHRpbi9jaGVja291dC5jOjE5MQogIywgYy1mb3JtYXQKIG1zZ2lkICJwYXRoICclcycgZG9lcyBub3QgaGF2ZSBhbGwgbmVjZXNzYXJ5IHZlcnNpb25zIgogbXNnc3RyICJpbCBwZXJjb3JzbyAnJXMnIG5vbiBoYSB0dXR0ZSBsZSB2ZXJzaW9uaSBuZWNlc3NhcmllIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6MjQwCisjOiBidWlsdGluL2NoZWNrb3V0LmM6MjQxCiAjLCBjLWZvcm1hdAogbXNnaWQgInBhdGggJyVzJyBkb2VzIG5vdCBoYXZlIG5lY2Vzc2FyeSB2ZXJzaW9ucyIKIG1zZ3N0ciAiaWwgcGVyY29yc28gJyVzJyBub24gaGEgbGUgdmVyc2lvbmkgbmVjZXNzYXJpZSIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjI1OAorIzogYnVpbHRpbi9jaGVja291dC5jOjI1OQogIywgYy1mb3JtYXQKIG1zZ2lkICJwYXRoICclcyc6IGNhbm5vdCBtZXJnZSIKIG1zZ3N0ciAicGVyY29yc28gJyVzJzogaW1wb3NzaWJpbGUgZXNlZ3VpcmUgaWwgbWVyZ2UiCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoyNzQKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoyNzUKICMsIGMtZm9ybWF0CiBtc2dpZCAiVW5hYmxlIHRvIGFkZCBtZXJnZSByZXN1bHQgZm9yICclcyciCiBtc2dzdHIgIkltcG9zc2liaWxlIGFnZ2l1bmdlcmUgaWwgcmlzdWx0YXRvIGRlbCBtZXJnZSBwZXIgJyVzJyIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjM3NAorIzogYnVpbHRpbi9jaGVja291dC5jOjM3NQogIywgYy1mb3JtYXQKIG1zZ2lkICJSZWNyZWF0ZWQgJWQgbWVyZ2UgY29uZmxpY3QiCiBtc2dpZF9wbHVyYWwgIlJlY3JlYXRlZCAlZCBtZXJnZSBjb25mbGljdHMiCiBtc2dzdHJbMF0gIlJpY3JlYXRvICVkIGNvbmZsaXR0byBkaSBtZXJnZSIKIG1zZ3N0clsxXSAiUmljcmVhdGkgJWQgY29uZmxpdHRpIGRpIG1lcmdlIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6Mzc5CisjOiBidWlsdGluL2NoZWNrb3V0LmM6MzgwCiAjLCBjLWZvcm1hdAogbXNnaWQgIlVwZGF0ZWQgJWQgcGF0aCBmcm9tICVzIgogbXNnaWRfcGx1cmFsICJVcGRhdGVkICVkIHBhdGhzIGZyb20gJXMiCiBtc2dzdHJbMF0gIkFnZ2lvcm5hdG8gJWQgcGVyY29yc28gZGEgJXMiCiBtc2dzdHJbMV0gIkFnZ2lvcm5hdGkgJWQgcGVyY29yc2kgZGEgJXMiCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzozODYKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzozODcKICMsIGMtZm9ybWF0CiBtc2dpZCAiVXBkYXRlZCAlZCBwYXRoIGZyb20gdGhlIGluZGV4IgogbXNnaWRfcGx1cmFsICJVcGRhdGVkICVkIHBhdGhzIGZyb20gdGhlIGluZGV4IgogbXNnc3RyWzBdICJBZ2dpb3JuYXRvICVkIHBlcmNvcnNvIGRhbGwnaW5kaWNlIgogbXNnc3RyWzFdICJBZ2dpb3JuYXRpICVkIHBlcmNvcnNpIGRhbGwnaW5kaWNlIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6NDA5IGJ1aWx0aW4vY2hlY2tvdXQuYzo0MTIgYnVpbHRpbi9jaGVja291dC5jOjQxNQotIzogYnVpbHRpbi9jaGVja291dC5jOjQxOQorIzogYnVpbHRpbi9jaGVja291dC5jOjQxMCBidWlsdGluL2NoZWNrb3V0LmM6NDEzIGJ1aWx0aW4vY2hlY2tvdXQuYzo0MTYKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo0MjAKICMsIGMtZm9ybWF0CiBtc2dpZCAiJyVzJyBjYW5ub3QgYmUgdXNlZCB3aXRoIHVwZGF0aW5nIHBhdGhzIgogbXNnc3RyICInJXMnIG5vbiBwdcOyIGVzc2VyZSB1c2F0byBjb24gaSBwZXJjb3JzaSBpbiBmYXNlIGRpIGFnZ2lvcm5hbWVudG8iCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo0MjIgYnVpbHRpbi9jaGVja291dC5jOjQyNQorIzogYnVpbHRpbi9jaGVja291dC5jOjQyMyBidWlsdGluL2NoZWNrb3V0LmM6NDI2CiAjLCBjLWZvcm1hdAogbXNnaWQgIiclcycgY2Fubm90IGJlIHVzZWQgd2l0aCAlcyIKIG1zZ3N0ciAiJyVzJyBub24gcHXDsiBlc3NlcmUgdXNhdG8gY29uICVzIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6NDI5CisjOiBidWlsdGluL2NoZWNrb3V0LmM6NDMwCiAjLCBjLWZvcm1hdAogbXNnaWQgIkNhbm5vdCB1cGRhdGUgcGF0aHMgYW5kIHN3aXRjaCB0byBicmFuY2ggJyVzJyBhdCB0aGUgc2FtZSB0aW1lLiIKIG1zZ3N0ciAiIgogIkltcG9zc2liaWxlIGFnZ2lvcm5hcmUgZGVpIHBlcmNvcnNpIGUgcGFzc2FyZSBhbCBicmFuY2ggJyVzJyAiCiAiY29udGVtcG9yYW5lYW1lbnRlLiIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjQzMworIzogYnVpbHRpbi9jaGVja291dC5jOjQzNAogIywgYy1mb3JtYXQKIG1zZ2lkICJuZWl0aGVyICclcycgb3IgJyVzJyBpcyBzcGVjaWZpZWQiCiBtc2dzdHIgIm7DqSAnJXMnIG7DqSAnJXMnIHNvbm8gc3RhdGkgc3BlY2lmaWNhdGkiCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo0MzcKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo0MzgKICMsIGMtZm9ybWF0CiBtc2dpZCAiJyVzJyBtdXN0IGJlIHVzZWQgd2hlbiAnJXMnIGlzIG5vdCBzcGVjaWZpZWQiCiBtc2dzdHIgIiclcycgZGV2J2Vzc2VyZSB1c2F0byBxdWFuZG8gJyVzJyBub24gw6ggc3BlY2lmaWNhdG8iCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo0NDIgYnVpbHRpbi9jaGVja291dC5jOjQ0NworIzogYnVpbHRpbi9jaGVja291dC5jOjQ0MyBidWlsdGluL2NoZWNrb3V0LmM6NDQ4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiclcycgb3IgJyVzJyBjYW5ub3QgYmUgdXNlZCB3aXRoICVzIgogbXNnc3RyICInJXMnIG8gJyVzJyBub24gcG9zc29ubyBlc3NlcmUgdXNhdGkgY29uICVzIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6NTA2IGJ1aWx0aW4vY2hlY2tvdXQuYzo1MTMKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo1MDcgYnVpbHRpbi9jaGVja291dC5jOjUxNAogIywgYy1mb3JtYXQKIG1zZ2lkICJwYXRoICclcycgaXMgdW5tZXJnZWQiCiBtc2dzdHIgImlsIHBlcmNvcnNvICclcycgbm9uIMOoIHN0YXRvIHNvdHRvcG9zdG8gYSBtZXJnZSIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjY3OQorIzogYnVpbHRpbi9jaGVja291dC5jOjY4MAogbXNnaWQgInlvdSBuZWVkIHRvIHJlc29sdmUgeW91ciBjdXJyZW50IGluZGV4IGZpcnN0IgogbXNnc3RyICJwcmltYSBkZXZpIHJpc29sdmVyZSBsJ2luZGljZSBjb3JyZW50ZSIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjcyOQorIzogYnVpbHRpbi9jaGVja291dC5jOjczMAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiY2Fubm90IGNvbnRpbnVlIHdpdGggc3RhZ2VkIGNoYW5nZXMgaW4gdGhlIGZvbGxvd2luZyBmaWxlczpcbiIKQEAgLTEwNDU2LDExICsxMDUwMCw2IEBACiAiaW1wb3NzaWJpbGUgY29udGludWFyZSBjb24gbW9kaWZpY2hlIGluIHN0YWdlIG5laSBmaWxlIHNlZ3VlbnRpOlxuIgogIiVzIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6NzM2Ci0jLCBjLWZvcm1hdAotbXNnaWQgInN0YWdlZCBjaGFuZ2VzIGluIHRoZSBmb2xsb3dpbmcgZmlsZXMgbWF5IGJlIGxvc3Q6ICVzIgotbXNnc3RyICJsZSBtb2RpZmljaGUgaW4gc3RhZ2UgbmVpIHNlZ3VlbnRpIGZpbGUgcG90cmViYmVybyBhbmRhcmUgcGVyZHV0ZTogJXMiCi0KICM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo4MzMKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ2FuIG5vdCBkbyByZWZsb2cgZm9yICclcyc6ICVzXG4iCkBAIC0xMDQ3MCw3ICsxMDUwOSw3IEBACiBtc2dpZCAiSEVBRCBpcyBub3cgYXQiCiBtc2dzdHIgIkhFQUQgc2kgdHJvdmEgb3JhIGEiCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo4NzkgYnVpbHRpbi9jbG9uZS5jOjcxNAorIzogYnVpbHRpbi9jaGVja291dC5jOjg3OSBidWlsdGluL2Nsb25lLmM6NzEzCiBtc2dpZCAidW5hYmxlIHRvIHVwZGF0ZSBIRUFEIgogbXNnc3RyICJpbXBvc3NpYmlsZSBhZ2dpb3JuYXJlIEhFQUQiCiAKQEAgLTEwNTg0LDcgKzEwNjIzLDcgQEAKICInJXMnIHBvdHJlYmJlIGVzc2VyZSBzaWEgdW4gZmlsZSBsb2NhbGUsIHNpYSB1biBicmFuY2ggZGEgdHJhY2NpYXJlLlxuIgogIlVzYSAtLSAoZSBmYWNvbHRhdGl2YW1lbnRlIC0tbm8tZ3Vlc3MpIHBlciByaW11b3ZlcmUgbCdhbWJpZ3VpdMOgIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6MTI0MyBidWlsdGluL3dvcmt0cmVlLmM6MjkxIGJ1aWx0aW4vd29ya3RyZWUuYzo0NTYKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxMjQzIGJ1aWx0aW4vd29ya3RyZWUuYzoyOTAgYnVpbHRpbi93b3JrdHJlZS5jOjQ1NQogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIHJlZmVyZW5jZTogJXMiCiBtc2dzdHIgInJpZmVyaW1lbnRvIG5vbiB2YWxpZG86ICVzIgpAQCAtMTA2ODcsOSArMTA3MjYsOSBAQAogbXNnaWQgIm1pc3NpbmcgYnJhbmNoIG9yIGNvbW1pdCBhcmd1bWVudCIKIG1zZ3N0ciAiYXJnb21lbnRvIGJyYW5jaCBvIGNvbW1pdCBtYW5jYW50ZSIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjE0MzcgYnVpbHRpbi9jbG9uZS5jOjkxIGJ1aWx0aW4vZmV0Y2guYzoxNTEKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoyODUgYnVpbHRpbi9wdWxsLmM6MTM3IGJ1aWx0aW4vcHVzaC5jOjU3NQotIzogYnVpbHRpbi9zZW5kLXBhY2suYzoxNzQKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNDM3IGJ1aWx0aW4vY2xvbmUuYzo5MCBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjU5CisjOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE4MCBidWlsdGluL2ZldGNoLmM6MTY2IGJ1aWx0aW4vbWVyZ2UuYzoyODUKKyM6IGJ1aWx0aW4vcHVsbC5jOjEzOCBidWlsdGluL3B1c2guYzo1NjIgYnVpbHRpbi9zZW5kLXBhY2suYzoxNzQKIG1zZ2lkICJmb3JjZSBwcm9ncmVzcyByZXBvcnRpbmciCiBtc2dzdHIgImZvcnphIGwnaW5kaWNhemlvbmUgZCdhdmFuemFtZW50byBkZWxsJ29wZXJhemlvbmUiCiAKQEAgLTEwNjk3LDcgKzEwNzM2LDcgQEAKIG1zZ2lkICJwZXJmb3JtIGEgMy13YXkgbWVyZ2Ugd2l0aCB0aGUgbmV3IGJyYW5jaCIKIG1zZ3N0ciAiZXNlZ3VpIHVuIG1lcmdlIGEgdHJlIHZpZSBjb24gaWwgbnVvdm8gYnJhbmNoIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6MTQzOSBidWlsdGluL2xvZy5jOjE2MTcgcGFyc2Utb3B0aW9ucy5oOjMxOAorIzogYnVpbHRpbi9jaGVja291dC5jOjE0MzkgYnVpbHRpbi9sb2cuYzoxNjE4IHBhcnNlLW9wdGlvbnMuaDozMTgKIG1zZ2lkICJzdHlsZSIKIG1zZ3N0ciAic3RpbGUiCiAKQEAgLTEwNzA1LDcgKzEwNzQ0LDcgQEAKIG1zZ2lkICJjb25mbGljdCBzdHlsZSAobWVyZ2Ugb3IgZGlmZjMpIgogbXNnc3RyICJzdGlsZSBjb25mbGl0dGkgKG1lcmdlIG8gZGlmZjMpIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6MTQ1MiBidWlsdGluL3dvcmt0cmVlLmM6NTA0CisjOiBidWlsdGluL2NoZWNrb3V0LmM6MTQ1MiBidWlsdGluL3dvcmt0cmVlLmM6NTAzCiBtc2dpZCAiZGV0YWNoIEhFQUQgYXQgbmFtZWQgY29tbWl0IgogbXNnc3RyICJzY29sbGVnYSBsJ0hFQUQgYWwgY29tbWl0IHNwZWNpZmljYXRvIgogCkBAIC0xMDgyOCw5ICsxMDg2Nyw5IEBACiAicmlzcGV0dG8gYSB1biBwYXJ0aWNvbGFyZSByZW1vdG8sIGFkIGVzLiAnb3JpZ2luJywgcG90cmVzdGkgdm9sZXJcbiIKICJpbXBvc3RhcmUgY2hlY2tvdXQuZGVmYXVsdFJlbW90ZT1vcmlnaW4gbmVsIHR1byBmaWxlIGRpIGNvbmZpZ3VyYXppb25lLiIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjE2OTEgYnVpbHRpbi9jaGVja291dC5jOjE2OTMgYnVpbHRpbi9jaGVja291dC5jOjE3MzMKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzM1IGJ1aWx0aW4vY2xvbmUuYzoxMjEgYnVpbHRpbi9yZW1vdGUuYzoxNjkKLSM6IGJ1aWx0aW4vcmVtb3RlLmM6MTcxIGJ1aWx0aW4vd29ya3RyZWUuYzo1MDAgYnVpbHRpbi93b3JrdHJlZS5jOjUwMgorIzogYnVpbHRpbi9jaGVja291dC5jOjE2OTEgYnVpbHRpbi9jaGVja291dC5jOjE2OTMgYnVpbHRpbi9jaGVja291dC5jOjE3NDIKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzQ0IGJ1aWx0aW4vY2xvbmUuYzoxMjAgYnVpbHRpbi9yZW1vdGUuYzoxNjkKKyM6IGJ1aWx0aW4vcmVtb3RlLmM6MTcxIGJ1aWx0aW4vd29ya3RyZWUuYzo0OTkgYnVpbHRpbi93b3JrdHJlZS5jOjUwMQogbXNnaWQgImJyYW5jaCIKIG1zZ3N0ciAiYnJhbmNoIgogCkBAIC0xMDg1NCwzOSArMTA4OTMsMzkgQEAKIG1zZ2lkICJ1c2Ugb3ZlcmxheSBtb2RlIChkZWZhdWx0KSIKIG1zZ3N0ciAidXNhIG1vZGFsaXTDoCBvdmVybGF5IChpbXBvc3RhemlvbmUgcHJlZGVmaW5pdGEpIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6MTczNAorIzogYnVpbHRpbi9jaGVja291dC5jOjE3NDMKIG1zZ2lkICJjcmVhdGUgYW5kIHN3aXRjaCB0byBhIG5ldyBicmFuY2giCiBtc2dzdHIgImNyZWEgdW4gbnVvdm8gYnJhbmNoIGUgcGFzc2EgYSBxdWVzdCd1bHRpbW8iCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzM2CisjOiBidWlsdGluL2NoZWNrb3V0LmM6MTc0NQogbXNnaWQgImNyZWF0ZS9yZXNldCBhbmQgc3dpdGNoIHRvIGEgYnJhbmNoIgogbXNnc3RyICJjcmVhL3JlaW1wb3N0YSB1biBicmFuY2ggZSBwYXNzYSBhIHF1ZXN0J3VsdGltbyIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjE3MzgKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzQ3CiBtc2dpZCAic2Vjb25kIGd1ZXNzICdnaXQgc3dpdGNoIDxuby1zdWNoLWJyYW5jaD4nIgogbXNnc3RyICJwcmV2ZWRpICdnaXQgc3dpdGNoIDxicmFuY2ggaW5lc2lzdGVudGU+JyIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjE3NDAKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzQ5CiBtc2dpZCAidGhyb3cgYXdheSBsb2NhbCBtb2RpZmljYXRpb25zIgogbXNnc3RyICJzY2FydGEgbGUgbW9kaWZpY2hlIGxvY2FsaSIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjE3NzIKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzgxCiBtc2dpZCAid2hpY2ggdHJlZS1pc2ggdG8gY2hlY2tvdXQgZnJvbSIKIG1zZ3N0ciAiYWxiZXJvIGRhIGN1aSBlc2VndWlyZSBpbCBjaGVja291dCIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjE3NzQKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzgzCiBtc2dpZCAicmVzdG9yZSB0aGUgaW5kZXgiCiBtc2dzdHIgInJpcHJpc3RpbmEgbCdpbmRpY2UiCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzc2CisjOiBidWlsdGluL2NoZWNrb3V0LmM6MTc4NQogbXNnaWQgInJlc3RvcmUgdGhlIHdvcmtpbmcgdHJlZSAoZGVmYXVsdCkiCiBtc2dzdHIgInJpcHJpc3RpbmEgbCdhbGJlcm8gZGkgbGF2b3JvIChpbXBvc3RhemlvbmUgcHJlZGVmaW5pdGEpIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6MTc3OAorIzogYnVpbHRpbi9jaGVja291dC5jOjE3ODcKIG1zZ2lkICJpZ25vcmUgdW5tZXJnZWQgZW50cmllcyIKIG1zZ3N0ciAiaWdub3JhIHZvY2kgbm9uIHNvdHRvcG9zdGUgYSBtZXJnZSIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjE3NzkKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzg4CiBtc2dpZCAidXNlIG92ZXJsYXkgbW9kZSIKIG1zZ3N0ciAidXNhIG1vZGFsaXTDoCBvdmVybGF5IgogCkBAIC0xMDkyNyw3ICsxMDk2Niw3IEBACiBtc2dpZCAiY291bGQgbm90IGxzdGF0ICVzXG4iCiBtc2dzdHIgImltcG9zc2liaWxlIGVzZWd1aXJlIGwnbHN0YXQgZGkgJXNcbiIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjMwMCBnaXQtYWRkLS1pbnRlcmFjdGl2ZS5wZXJsOjU5MworIzogYnVpbHRpbi9jbGVhbi5jOjMwMSBnaXQtYWRkLS1pbnRlcmFjdGl2ZS5wZXJsOjU5MwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiUHJvbXB0IGhlbHA6XG4iCkBAIC0xMDk0MCw3ICsxMDk3OSw3IEBACiAicGlwcG8gICAgICAtIHNlbGV6aW9uYSB1biBlbGVtZW50byBiYXNhbmRvdGkgc3UgdW4gcHJlZmlzc28gdW5pdm9jb1xuIgogIiAgICAgICAgICAgLSAodnVvdG8pIG5vbiBzZWxlemlvbmFyZSBuaWVudGVcbiIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjMwNCBnaXQtYWRkLS1pbnRlcmFjdGl2ZS5wZXJsOjYwMgorIzogYnVpbHRpbi9jbGVhbi5jOjMwNSBnaXQtYWRkLS1pbnRlcmFjdGl2ZS5wZXJsOjYwMgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiUHJvbXB0IGhlbHA6XG4iCkBAIC0xMDk2MSwzOCArMTEwMDAsMzggQEAKICIqICAgICAgICAgIC0gc2VsZXppb25hIHR1dHRpIGdsaSBlbGVtZW50aVxuIgogIiAgICAgICAgICAgLSAodnVvdG8pIHRlcm1pbmEgaWwgcHJvY2Vzc28gZGkgc2VsZXppb25lXG4iCiAKLSM6IGJ1aWx0aW4vY2xlYW4uYzo1MjAgZ2l0LWFkZC0taW50ZXJhY3RpdmUucGVybDo1NjgKKyM6IGJ1aWx0aW4vY2xlYW4uYzo1MjEgZ2l0LWFkZC0taW50ZXJhY3RpdmUucGVybDo1NjgKICM6IGdpdC1hZGQtLWludGVyYWN0aXZlLnBlcmw6NTczCiAjLCBjLWZvcm1hdCwgcGVybC1mb3JtYXQKIG1zZ2lkICJIdWggKCVzKT9cbiIKIG1zZ3N0ciAiRWggKCVzKT9cbiIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjY2MgorIzogYnVpbHRpbi9jbGVhbi5jOjY2MwogIywgYy1mb3JtYXQKIG1zZ2lkICJJbnB1dCBpZ25vcmUgcGF0dGVybnM+PiAiCiBtc2dzdHIgIkltbWV0dGkgaSBwYXR0ZXJuIGRhIGlnbm9yYXJlPj4gIgogCi0jOiBidWlsdGluL2NsZWFuLmM6Njk5CisjOiBidWlsdGluL2NsZWFuLmM6NzAwCiAjLCBjLWZvcm1hdAogbXNnaWQgIldBUk5JTkc6IENhbm5vdCBmaW5kIGl0ZW1zIG1hdGNoZWQgYnk6ICVzIgogbXNnc3RyICJBVFRFTlpJT05FOiBJbXBvc3NpYmlsZSB0cm92YXJlIGVsZW1lbnRpIGNvcnJpc3BvbmRlbnRpIGEgJXMiCiAKLSM6IGJ1aWx0aW4vY2xlYW4uYzo3MjAKKyM6IGJ1aWx0aW4vY2xlYW4uYzo3MjEKIG1zZ2lkICJTZWxlY3QgaXRlbXMgdG8gZGVsZXRlIgogbXNnc3RyICJTZWxlemlvbmEgZ2xpIGVsZW1lbnRpIGRhIGVsaW1pbmFyZSIKIAogIy4gVFJBTlNMQVRPUlM6IE1ha2Ugc3VyZSB0byBrZWVwIFt5L05dIGFzIGlzCi0jOiBidWlsdGluL2NsZWFuLmM6NzYxCisjOiBidWlsdGluL2NsZWFuLmM6NzYyCiAjLCBjLWZvcm1hdAogbXNnaWQgIlJlbW92ZSAlcyBbeS9OXT8gIgogbXNnc3RyICJFbGltaW5hcmUgJXMgW3kvTl0/ICIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjc4NiBnaXQtYWRkLS1pbnRlcmFjdGl2ZS5wZXJsOjE3NjMKKyM6IGJ1aWx0aW4vY2xlYW4uYzo3ODcgZ2l0LWFkZC0taW50ZXJhY3RpdmUucGVybDoxNzYzCiAjLCBjLWZvcm1hdAogbXNnaWQgIkJ5ZS5cbiIKIG1zZ3N0ciAiQ2lhby5cbiIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjc5NAorIzogYnVpbHRpbi9jbGVhbi5jOjc5NQogbXNnaWQgIiIKICJjbGVhbiAgICAgICAgICAgICAgIC0gc3RhcnQgY2xlYW5pbmdcbiIKICJmaWx0ZXIgYnkgcGF0dGVybiAgIC0gZXhjbHVkZSBpdGVtcyBmcm9tIGRlbGV0aW9uXG4iCkBAIC0xMTAxMSw2NCArMTEwNTAsNjQgQEAKICJoZWxwICAgICAgICAgICAgICAgIC0gdmlzdWFsaXp6YSBxdWVzdGEgc2NoZXJtYXRhXG4iCiAiPyAgICAgICAgICAgICAgICAgICAtIGd1aWRhIGFsIHByb21wdCBkaSBzZWxlemlvbmUiCiAKLSM6IGJ1aWx0aW4vY2xlYW4uYzo4MjEgZ2l0LWFkZC0taW50ZXJhY3RpdmUucGVybDoxODQ5CisjOiBidWlsdGluL2NsZWFuLmM6ODIyIGdpdC1hZGQtLWludGVyYWN0aXZlLnBlcmw6MTg0OQogbXNnaWQgIioqKiBDb21tYW5kcyAqKioiCiBtc2dzdHIgIioqKiBDb21hbmRpICoqKiIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjgyMiBnaXQtYWRkLS1pbnRlcmFjdGl2ZS5wZXJsOjE4NDYKKyM6IGJ1aWx0aW4vY2xlYW4uYzo4MjMgZ2l0LWFkZC0taW50ZXJhY3RpdmUucGVybDoxODQ2CiBtc2dpZCAiV2hhdCBub3ciCiBtc2dzdHIgIkNvc2EgZmFjY2lvIG9yYSIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjgzMAorIzogYnVpbHRpbi9jbGVhbi5jOjgzMQogbXNnaWQgIldvdWxkIHJlbW92ZSB0aGUgZm9sbG93aW5nIGl0ZW06IgogbXNnaWRfcGx1cmFsICJXb3VsZCByZW1vdmUgdGhlIGZvbGxvd2luZyBpdGVtczoiCiBtc2dzdHJbMF0gIkVsaW1pbmVyZWkgaWwgc2VndWVudGUgZWxlbWVudG86IgogbXNnc3RyWzFdICJFbGltaW5lcmVpIGkgc2VndWVudGkgZWxlbWVudGk6IgogCi0jOiBidWlsdGluL2NsZWFuLmM6ODQ2CisjOiBidWlsdGluL2NsZWFuLmM6ODQ3CiBtc2dpZCAiTm8gbW9yZSBmaWxlcyB0byBjbGVhbiwgZXhpdGluZy4iCiBtc2dzdHIgIk5vbiBjaSBzb25vIHBpw7kgZmlsZSBkYSByaXB1bGlyZSwgZXNjby4iCiAKLSM6IGJ1aWx0aW4vY2xlYW4uYzo5MDgKKyM6IGJ1aWx0aW4vY2xlYW4uYzo5MDkKIG1zZ2lkICJkbyBub3QgcHJpbnQgbmFtZXMgb2YgZmlsZXMgcmVtb3ZlZCIKIG1zZ3N0ciAibm9uIHN0YW1wYXJlIGkgbm9taSBkZWkgZmlsZSBlbGltaW5hdGkiCiAKLSM6IGJ1aWx0aW4vY2xlYW4uYzo5MTAKKyM6IGJ1aWx0aW4vY2xlYW4uYzo5MTEKIG1zZ2lkICJmb3JjZSIKIG1zZ3N0ciAiZm9yemEgbCdvcGVyYXppb25lIgogCi0jOiBidWlsdGluL2NsZWFuLmM6OTExCisjOiBidWlsdGluL2NsZWFuLmM6OTEyCiBtc2dpZCAiaW50ZXJhY3RpdmUgY2xlYW5pbmciCiBtc2dzdHIgInB1bGl6aWEgaW50ZXJhdHRpdmEiCiAKLSM6IGJ1aWx0aW4vY2xlYW4uYzo5MTMKKyM6IGJ1aWx0aW4vY2xlYW4uYzo5MTQKIG1zZ2lkICJyZW1vdmUgd2hvbGUgZGlyZWN0b3JpZXMiCiBtc2dzdHIgInJpbXVvdmkgaW50ZXJlIGRpcmVjdG9yeSIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjkxNCBidWlsdGluL2Rlc2NyaWJlLmM6NTQ2IGJ1aWx0aW4vZGVzY3JpYmUuYzo1NDgKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg5OSBidWlsdGluL2xvZy5jOjE3NiBidWlsdGluL2xvZy5jOjE3OAotIzogYnVpbHRpbi9scy1maWxlcy5jOjU1NyBidWlsdGluL25hbWUtcmV2LmM6NDEzIGJ1aWx0aW4vbmFtZS1yZXYuYzo0MTUKKyM6IGJ1aWx0aW4vY2xlYW4uYzo5MTUgYnVpbHRpbi9kZXNjcmliZS5jOjU0OCBidWlsdGluL2Rlc2NyaWJlLmM6NTUwCisjOiBidWlsdGluL2dyZXAuYzo5MDEgYnVpbHRpbi9sb2cuYzoxNzYgYnVpbHRpbi9sb2cuYzoxNzgKKyM6IGJ1aWx0aW4vbHMtZmlsZXMuYzo1NTcgYnVpbHRpbi9uYW1lLXJldi5jOjQxNyBidWlsdGluL25hbWUtcmV2LmM6NDE5CiAjOiBidWlsdGluL3Nob3ctcmVmLmM6MTc5CiBtc2dpZCAicGF0dGVybiIKIG1zZ3N0ciAicGF0dGVybiIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjkxNQorIzogYnVpbHRpbi9jbGVhbi5jOjkxNgogbXNnaWQgImFkZCA8cGF0dGVybj4gdG8gaWdub3JlIHJ1bGVzIgogbXNnc3RyICJhZ2dpdW5naSA8cGF0dGVybj4gYWxsZSByZWdvbGUgdXNhdGUgcGVyIGlnbm9yYXJlIGkgZmlsZSIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjkxNgorIzogYnVpbHRpbi9jbGVhbi5jOjkxNwogbXNnaWQgInJlbW92ZSBpZ25vcmVkIGZpbGVzLCB0b28iCiBtc2dzdHIgImVsaW1pbmEgYW5jaGUgaSBmaWxlIGlnbm9yYXRpIgogCi0jOiBidWlsdGluL2NsZWFuLmM6OTE4CisjOiBidWlsdGluL2NsZWFuLmM6OTE5CiBtc2dpZCAicmVtb3ZlIG9ubHkgaWdub3JlZCBmaWxlcyIKIG1zZ3N0ciAiZWxpbWluYSBzb2xvIGkgZmlsZSBpZ25vcmF0aSIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjkzNgorIzogYnVpbHRpbi9jbGVhbi5jOjkzNwogbXNnaWQgIi14IGFuZCAtWCBjYW5ub3QgYmUgdXNlZCB0b2dldGhlciIKIG1zZ3N0ciAiLXggZSAtWCBub24gcG9zc29ubyBlc3NlcmUgdXNhdGkgaW5zaWVtZSIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjk0MAorIzogYnVpbHRpbi9jbGVhbi5jOjk0MQogbXNnaWQgIiIKICJjbGVhbi5yZXF1aXJlRm9yY2Ugc2V0IHRvIHRydWUgYW5kIG5laXRoZXIgLWksIC1uLCBub3IgLWYgZ2l2ZW47IHJlZnVzaW5nIHRvICIKICJjbGVhbiIKQEAgLTExMDc2LDcgKzExMTE1LDcgQEAKICJjbGVhbi5yZXF1aXJlRm9yY2Ugw6ggaW1wb3N0YXRvIGEgdHJ1ZSBlIG7DqSAtaSwgbsOpIC1uLCBuw6kgLWYgc29ubyBzdGF0aSAiCiAic3BlY2lmaWNhdGk7IG1pIHJpZml1dG8gZGkgZXNlZ3VpcmUgbGEgcHVsaXppYSIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjk0MworIzogYnVpbHRpbi9jbGVhbi5jOjk0NAogbXNnaWQgIiIKICJjbGVhbi5yZXF1aXJlRm9yY2UgZGVmYXVsdHMgdG8gdHJ1ZSBhbmQgbmVpdGhlciAtaSwgLW4sIG5vciAtZiBnaXZlbjsgIgogInJlZnVzaW5nIHRvIGNsZWFuIgpAQCAtMTEwODQsMTY0ICsxMTEyMywxNjQgQEAKICJjbGVhbi5yZXF1aXJlRm9yY2Ugw6ggdHJ1ZSBwZXIgaW1wb3N0YXppb25lIHByZWRlZmluaXRhIGUgbsOpIC1pLCBuw6kgLW4sIG7DqSAtZiAiCiAic29ubyBzdGF0aSBzcGVjaWZpY2F0aTsgbWkgcmlmaXV0byBkaSBlc2VndWlyZSBsYSBwdWxpemlhIgogCi0jOiBidWlsdGluL2Nsb25lLmM6NDYKKyM6IGJ1aWx0aW4vY2xvbmUuYzo0NQogbXNnaWQgImdpdCBjbG9uZSBbPG9wdGlvbnM+XSBbLS1dIDxyZXBvPiBbPGRpcj5dIgogbXNnc3RyICJnaXQgY2xvbmUgWzxvcHppb25pPl0gWy0tXSA8cmVwb3NpdG9yeT4gWzxkaXJlY3Rvcnk+XSIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjkzCisjOiBidWlsdGluL2Nsb25lLmM6OTIKIG1zZ2lkICJkb24ndCBjcmVhdGUgYSBjaGVja291dCIKIG1zZ3N0ciAibm9uIGNyZWFyZSB1biBjaGVja291dCIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjk0IGJ1aWx0aW4vY2xvbmUuYzo5NiBidWlsdGluL2luaXQtZGIuYzo0ODkKKyM6IGJ1aWx0aW4vY2xvbmUuYzo5MyBidWlsdGluL2Nsb25lLmM6OTUgYnVpbHRpbi9pbml0LWRiLmM6NDg5CiBtc2dpZCAiY3JlYXRlIGEgYmFyZSByZXBvc2l0b3J5IgogbXNnc3RyICJjcmVhIHVuIHJlcG9zaXRvcnkgc3BvZ2xpbyIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjk4CisjOiBidWlsdGluL2Nsb25lLmM6OTcKIG1zZ2lkICJjcmVhdGUgYSBtaXJyb3IgcmVwb3NpdG9yeSAoaW1wbGllcyBiYXJlKSIKIG1zZ3N0ciAiY3JlYSB1biByZXBvc2l0b3J5IG1pcnJvciAoaW1wbGljYSBjaGUgc2lhIHNwb2dsaW8pIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTAwCisjOiBidWlsdGluL2Nsb25lLmM6OTkKIG1zZ2lkICJ0byBjbG9uZSBmcm9tIGEgbG9jYWwgcmVwb3NpdG9yeSIKIG1zZ3N0ciAicGVyIGNsb25hcmUgZGEgdW4gcmVwb3NpdG9yeSBsb2NhbGUiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMDIKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMDEKIG1zZ2lkICJkb24ndCB1c2UgbG9jYWwgaGFyZGxpbmtzLCBhbHdheXMgY29weSIKIG1zZ3N0ciAibm9uIHVzYXJlIGkgY29sbGVnYW1lbnRpIHJlYWxpIGxvY2FsaSwgY29waWEgc2VtcHJlIGkgZmlsZSIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEwNAorIzogYnVpbHRpbi9jbG9uZS5jOjEwMwogbXNnaWQgInNldHVwIGFzIHNoYXJlZCByZXBvc2l0b3J5IgogbXNnc3RyICJpbXBvc3RhIGlsIHJlcG9zaXRvcnkgY29tZSBjb25kaXZpc28iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMDcKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMDYKIG1zZ2lkICJwYXRoc3BlYyIKIG1zZ3N0ciAic3BlY2lmaWNhdG9yZSBwZXJjb3JzbyIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEwNworIzogYnVpbHRpbi9jbG9uZS5jOjEwNgogbXNnaWQgImluaXRpYWxpemUgc3VibW9kdWxlcyBpbiB0aGUgY2xvbmUiCiBtc2dzdHIgImluaXppYWxpenphIHNvdHRvbW9kdWxpIGR1cmFudGUgbGEgY2xvbmF6aW9uZSIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjExMAorIzogYnVpbHRpbi9jbG9uZS5jOjEwOQogbXNnaWQgIm51bWJlciBvZiBzdWJtb2R1bGVzIGNsb25lZCBpbiBwYXJhbGxlbCIKIG1zZ3N0ciAibnVtZXJvIGRpIHNvdHRvbW9kdWxpIGNsb25hdGkgaW4gcGFyYWxsZWxvIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTExIGJ1aWx0aW4vaW5pdC1kYi5jOjQ4NgorIzogYnVpbHRpbi9jbG9uZS5jOjExMCBidWlsdGluL2luaXQtZGIuYzo0ODYKIG1zZ2lkICJ0ZW1wbGF0ZS1kaXJlY3RvcnkiCiBtc2dzdHIgImRpcmVjdG9yeSBtb2RlbGxpIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTEyIGJ1aWx0aW4vaW5pdC1kYi5jOjQ4NworIzogYnVpbHRpbi9jbG9uZS5jOjExMSBidWlsdGluL2luaXQtZGIuYzo0ODcKIG1zZ2lkICJkaXJlY3RvcnkgZnJvbSB3aGljaCB0ZW1wbGF0ZXMgd2lsbCBiZSB1c2VkIgogbXNnc3RyICJkaXJlY3RvcnkgZGEgY3VpIHNhcmFubm8gcmVjdXBlcmF0aSBpIG1vZGVsbGkiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMTQgYnVpbHRpbi9jbG9uZS5jOjExNiBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6MTM4MAorIzogYnVpbHRpbi9jbG9uZS5jOjExMyBidWlsdGluL2Nsb25lLmM6MTE1IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxMzgwCiAjOiBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6MTg2MAogbXNnaWQgInJlZmVyZW5jZSByZXBvc2l0b3J5IgogbXNnc3RyICJyZXBvc2l0b3J5IGRpIHJpZmVyaW1lbnRvIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTE4IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxMzgyCisjOiBidWlsdGluL2Nsb25lLmM6MTE3IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxMzgyCiAjOiBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6MTg2MgogbXNnaWQgInVzZSAtLXJlZmVyZW5jZSBvbmx5IHdoaWxlIGNsb25pbmciCiBtc2dzdHIgInVzYSAtLXJlZmVyZW5jZSBzb2xvIGR1cmFudGUgbGEgY2xvbmF6aW9uZSIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjExOSBidWlsdGluL2NvbHVtbi5jOjI3IGJ1aWx0aW4vbWVyZ2UtZmlsZS5jOjQ2Ci0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMTQgYnVpbHRpbi9yZXBhY2suYzozMTkKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMTggYnVpbHRpbi9jb2x1bW4uYzoyNyBidWlsdGluL21lcmdlLWZpbGUuYzo0NgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjk0IGJ1aWx0aW4vcmVwYWNrLmM6MzIwCiBtc2dpZCAibmFtZSIKIG1zZ3N0ciAibm9tZSIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEyMAorIzogYnVpbHRpbi9jbG9uZS5jOjExOQogbXNnaWQgInVzZSA8bmFtZT4gaW5zdGVhZCBvZiAnb3JpZ2luJyB0byB0cmFjayB1cHN0cmVhbSIKIG1zZ3N0ciAidXNhIDxub21lPiBhbnppY2jDqSAnb3JpZ2luJyBwZXIgdHJhY2NpYXJlIGwndXBzdHJlYW0iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMjIKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMjEKIG1zZ2lkICJjaGVja291dCA8YnJhbmNoPiBpbnN0ZWFkIG9mIHRoZSByZW1vdGUncyBIRUFEIgogbXNnc3RyICJlc2VndWkgaWwgY2hlY2tvdXQgZGkgPGJyYW5jaD4gYW56aWNow6kgZGVsbCdIRUFEIGRlbCByZW1vdG8iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMjQKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMjMKIG1zZ2lkICJwYXRoIHRvIGdpdC11cGxvYWQtcGFjayBvbiB0aGUgcmVtb3RlIgogbXNnc3RyICJwZXJjb3JzbyBhbCBjb21hbmRvIHJlbW90byBnaXQtdXBsb2FkLXBhY2siCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMjUgYnVpbHRpbi9mZXRjaC5jOjE1MiBidWlsdGluL2dyZXAuYzo4MzgKLSM6IGJ1aWx0aW4vcHVsbC5jOjIyNgorIzogYnVpbHRpbi9jbG9uZS5jOjEyNCBidWlsdGluL2ZldGNoLmM6MTY3IGJ1aWx0aW4vZ3JlcC5jOjg0MAorIzogYnVpbHRpbi9wdWxsLmM6MjI3CiBtc2dpZCAiZGVwdGgiCiBtc2dzdHIgInByb2ZvbmRpdMOgIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTI2CisjOiBidWlsdGluL2Nsb25lLmM6MTI1CiBtc2dpZCAiY3JlYXRlIGEgc2hhbGxvdyBjbG9uZSBvZiB0aGF0IGRlcHRoIgogbXNnc3RyICJjcmVhIHVuIGNsb25lIHNoYWxsb3cgY29uIHF1ZXN0YSBwcm9mb25kaXTDoCIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEyNyBidWlsdGluL2ZldGNoLmM6MTU0IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMwMworIzogYnVpbHRpbi9jbG9uZS5jOjEyNiBidWlsdGluL2ZldGNoLmM6MTY5IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI4MwogbXNnaWQgInRpbWUiCiBtc2dzdHIgInRlbXBvIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTI4CisjOiBidWlsdGluL2Nsb25lLmM6MTI3CiBtc2dpZCAiY3JlYXRlIGEgc2hhbGxvdyBjbG9uZSBzaW5jZSBhIHNwZWNpZmljIHRpbWUiCiBtc2dzdHIgImNyZWEgdW4gY2xvbmUgc2hhbGxvdyBhIHBhcnRpcmUgZGFsbCdpc3RhbnRlIHNwZWNpZmljYXRvIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTI5IGJ1aWx0aW4vZmV0Y2guYzoxNTYgYnVpbHRpbi9mZXRjaC5jOjE3OQotIzogYnVpbHRpbi9yZWJhc2UuYzoxMzk1CisjOiBidWlsdGluL2Nsb25lLmM6MTI4IGJ1aWx0aW4vZmV0Y2guYzoxNzEgYnVpbHRpbi9mZXRjaC5jOjE5NAorIzogYnVpbHRpbi9yZWJhc2UuYzoxNDE3CiBtc2dpZCAicmV2aXNpb24iCiBtc2dzdHIgInJldmlzaW9uZSIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEzMCBidWlsdGluL2ZldGNoLmM6MTU3CisjOiBidWlsdGluL2Nsb25lLmM6MTI5IGJ1aWx0aW4vZmV0Y2guYzoxNzIKIG1zZ2lkICJkZWVwZW4gaGlzdG9yeSBvZiBzaGFsbG93IGNsb25lLCBleGNsdWRpbmcgcmV2IgogbXNnc3RyICIiCiAiYXVtZW50YSBsYSBwcm9mb25kaXTDoCBkZWxsYSBjcm9ub2xvZ2lhIGRlbCBjbG9uZSBzaGFsbG93IGZpbm8gYWxsYSByZXZpc2lvbmUgIgogInNwZWNpZmljYXRhIGVzY2x1c2EiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMzIKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMzEKIG1zZ2lkICJjbG9uZSBvbmx5IG9uZSBicmFuY2gsIEhFQUQgb3IgLS1icmFuY2giCiBtc2dzdHIgImNsb25hIHNvbG8gdW4gYnJhbmNoLCBIRUFEIG8gcXVlbGxvIHNwZWNpZmljYXRvIGNvbiAtLWJyYW5jaCIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEzNAorIzogYnVpbHRpbi9jbG9uZS5jOjEzMwogbXNnaWQgImRvbid0IGNsb25lIGFueSB0YWdzLCBhbmQgbWFrZSBsYXRlciBmZXRjaGVzIG5vdCB0byBmb2xsb3cgdGhlbSIKIG1zZ3N0ciAibm9uIGNsb25hcmUgYWxjdW4gdGFnIGUgZmFpIHPDrCBjaGUgaSBmZXRjaCBzdWNjZXNzaXZpIG5vbiBsaSBzZWd1YW5vIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTM2CisjOiBidWlsdGluL2Nsb25lLmM6MTM1CiBtc2dpZCAiYW55IGNsb25lZCBzdWJtb2R1bGVzIHdpbGwgYmUgc2hhbGxvdyIKIG1zZ3N0ciAidHV0dGkgaSBzb3R0b21vZHVsaSBjbG9uYXRpIHNhcmFubm8gc2hhbGxvdyIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEzNyBidWlsdGluL2luaXQtZGIuYzo0OTUKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMzYgYnVpbHRpbi9pbml0LWRiLmM6NDk1CiBtc2dpZCAiZ2l0ZGlyIgogbXNnc3RyICJkaXJlY3RvcnkgR2l0IgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTM4IGJ1aWx0aW4vaW5pdC1kYi5jOjQ5NgorIzogYnVpbHRpbi9jbG9uZS5jOjEzNyBidWlsdGluL2luaXQtZGIuYzo0OTYKIG1zZ2lkICJzZXBhcmF0ZSBnaXQgZGlyIGZyb20gd29ya2luZyB0cmVlIgogbXNnc3RyICJzZXBhcmEgbGEgZGlyZWN0b3J5IEdpdCBkYWxsJ2FsYmVybyBkaSBsYXZvcm8iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMzkKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMzgKIG1zZ2lkICJrZXk9dmFsdWUiCiBtc2dzdHIgImNoaWF2ZT12YWxvcmUiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxNDAKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMzkKIG1zZ2lkICJzZXQgY29uZmlnIGluc2lkZSB0aGUgbmV3IHJlcG9zaXRvcnkiCiBtc2dzdHIgImltcG9zdGEgbGEgY29uZmlndXJhemlvbmUgbmVsIG51b3ZvIHJlcG9zaXRvcnkiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxNDIgYnVpbHRpbi9mZXRjaC5jOjE3NCBidWlsdGluL2xzLXJlbW90ZS5jOjc2Ci0jOiBidWlsdGluL3B1c2guYzo1ODUgYnVpbHRpbi9zZW5kLXBhY2suYzoxNzIKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxNDEgYnVpbHRpbi9mZXRjaC5jOjE4OSBidWlsdGluL2xzLXJlbW90ZS5jOjc2CisjOiBidWlsdGluL3B1c2guYzo1NzIgYnVpbHRpbi9zZW5kLXBhY2suYzoxNzIKIG1zZ2lkICJzZXJ2ZXItc3BlY2lmaWMiCiBtc2dzdHIgInNwZWNpZmljYSBkZWwgc2VydmVyIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTQyIGJ1aWx0aW4vZmV0Y2guYzoxNzQgYnVpbHRpbi9scy1yZW1vdGUuYzo3NgotIzogYnVpbHRpbi9wdXNoLmM6NTg1IGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTczCisjOiBidWlsdGluL2Nsb25lLmM6MTQxIGJ1aWx0aW4vZmV0Y2guYzoxODkgYnVpbHRpbi9scy1yZW1vdGUuYzo3NgorIzogYnVpbHRpbi9wdXNoLmM6NTcyIGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTczCiBtc2dpZCAib3B0aW9uIHRvIHRyYW5zbWl0IgogbXNnc3RyICJvcHppb25lIGRhIHRyYXNtZXR0ZXJlIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTQzIGJ1aWx0aW4vZmV0Y2guYzoxNzUgYnVpbHRpbi9wdWxsLmM6MjM5Ci0jOiBidWlsdGluL3B1c2guYzo1ODYKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxNDIgYnVpbHRpbi9mZXRjaC5jOjE5MCBidWlsdGluL3B1bGwuYzoyNDAKKyM6IGJ1aWx0aW4vcHVzaC5jOjU3MwogbXNnaWQgInVzZSBJUHY0IGFkZHJlc3NlcyBvbmx5IgogbXNnc3RyICJ1c2Egc29sbyBpbmRpcml6emkgSVB2NCIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjE0NSBidWlsdGluL2ZldGNoLmM6MTc3IGJ1aWx0aW4vcHVsbC5jOjI0MgotIzogYnVpbHRpbi9wdXNoLmM6NTg4CisjOiBidWlsdGluL2Nsb25lLmM6MTQ0IGJ1aWx0aW4vZmV0Y2guYzoxOTIgYnVpbHRpbi9wdWxsLmM6MjQzCisjOiBidWlsdGluL3B1c2guYzo1NzUKIG1zZ2lkICJ1c2UgSVB2NiBhZGRyZXNzZXMgb25seSIKIG1zZ3N0ciAidXNhIHNvbG8gaW5kaXJpenppIElQdjYiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxNDkKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxNDgKIG1zZ2lkICJhbnkgY2xvbmVkIHN1Ym1vZHVsZXMgd2lsbCB1c2UgdGhlaXIgcmVtb3RlLXRyYWNraW5nIGJyYW5jaCIKIG1zZ3N0ciAiIgogInR1dHRpIGkgc290dG9tb2R1bGkgY2xvbmF0aSB1c2VyYW5ubyBpbCBsb3JvIHJpc3BldHRpdm8gYnJhbmNoIHJlbW90byAiCiAidHJhY2NpYXRvIgogCi0jOiBidWlsdGluL2Nsb25lLmM6Mjg1CisjOiBidWlsdGluL2Nsb25lLmM6Mjg0CiBtc2dpZCAiIgogIk5vIGRpcmVjdG9yeSBuYW1lIGNvdWxkIGJlIGd1ZXNzZWQuXG4iCiAiUGxlYXNlIHNwZWNpZnkgYSBkaXJlY3Rvcnkgb24gdGhlIGNvbW1hbmQgbGluZSIKQEAgLTExMjQ5LDQ3ICsxMTI4OCw0MiBAQAogIk5vbiDDqCBzdGF0byBwb3NzaWJpbGUgaW5kb3ZpbmFyZSBhbGN1biBub21lIGRpcmVjdG9yeS5cbiIKICJTcGVjaWZpY2EgdW5hIGRpcmVjdG9yeSB0cmFtaXRlIGxhIHJpZ2EgZGkgY29tYW5kbyIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjMzOAorIzogYnVpbHRpbi9jbG9uZS5jOjMzNwogIywgYy1mb3JtYXQKIG1zZ2lkICJpbmZvOiBDb3VsZCBub3QgYWRkIGFsdGVybmF0ZSBmb3IgJyVzJzogJXNcbiIKIG1zZ3N0ciAiaW5mb3JtYXppb25lOiBJbXBvc3NpYmlsZSBhZ2dpdW5nZXJlIHVuIGFsdGVybmF0byBhICclcyc6ICVzXG4iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo0MTEKKyM6IGJ1aWx0aW4vY2xvbmUuYzo0MTAKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgZXhpc3RzIGFuZCBpcyBub3QgYSBkaXJlY3RvcnkiCiBtc2dzdHIgIiVzIGVzaXN0ZSBlIG5vbiDDqCB1bmEgZGlyZWN0b3J5IgogCi0jOiBidWlsdGluL2Nsb25lLmM6NDI4CisjOiBidWlsdGluL2Nsb25lLmM6NDI3CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBzdGFydCBpdGVyYXRvciBvdmVyICclcyciCiBtc2dzdHIgImltcG9zc2liaWxlIGF2dmlhcmUgbCdpdGVyYXRvcmUgc3UgJyVzJyIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjQ1MwotIywgYy1mb3JtYXQKLW1zZ2lkICJmYWlsZWQgdG8gdW5saW5rICclcyciCi1tc2dzdHIgInVubGluayBkaSAnJXMnIG5vbiByaXVzY2l0byIKLQotIzogYnVpbHRpbi9jbG9uZS5jOjQ1OAorIzogYnVpbHRpbi9jbG9uZS5jOjQ1NwogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gY3JlYXRlIGxpbmsgJyVzJyIKIG1zZ3N0ciAiY3JlYXppb25lIGRlbCBjb2xsZWdhbWVudG8gJyVzJyBub24gcml1c2NpdGEiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo0NjIKKyM6IGJ1aWx0aW4vY2xvbmUuYzo0NjEKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIGNvcHkgZmlsZSB0byAnJXMnIgogbXNnc3RyICJjb3BpYSBkZWwgZmlsZSBpbiAnJXMnIG5vbiByaXVzY2l0YSIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjQ2NworIzogYnVpbHRpbi9jbG9uZS5jOjQ2NgogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gaXRlcmF0ZSBvdmVyICclcyciCiBtc2dzdHIgIml0ZXJhemlvbmUgc3UgJyVzJyBub24gcml1c2NpdGEiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo0OTIKKyM6IGJ1aWx0aW4vY2xvbmUuYzo0OTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiZG9uZS5cbiIKIG1zZ3N0ciAiZmF0dG8uXG4iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo1MDYKKyM6IGJ1aWx0aW4vY2xvbmUuYzo1MDUKIG1zZ2lkICIiCiAiQ2xvbmUgc3VjY2VlZGVkLCBidXQgY2hlY2tvdXQgZmFpbGVkLlxuIgogIllvdSBjYW4gaW5zcGVjdCB3aGF0IHdhcyBjaGVja2VkIG91dCB3aXRoICdnaXQgc3RhdHVzJ1xuIgpAQCAtMTEzMDAsOTggKzExMzM0LDk4IEBACiAiY29uICdnaXQgc3RhdHVzJyBlIHJpcHJvdmFyZSBhZCBlc2VndWlyZSBpbCBjaGVja291dCBjb25cbiIKICInZ2l0IHJlc3RvcmUgLS1zb3VyY2U9SEVBRCA6LydcbiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjU4MworIzogYnVpbHRpbi9jbG9uZS5jOjU4MgogIywgYy1mb3JtYXQKIG1zZ2lkICJDb3VsZCBub3QgZmluZCByZW1vdGUgYnJhbmNoICVzIHRvIGNsb25lLiIKIG1zZ3N0ciAiSW1wb3NzaWJpbGUgdHJvdmFyZSBpbCBicmFuY2ggcmVtb3RvICVzIGRhIGNsb25hcmUuIgogCi0jOiBidWlsdGluL2Nsb25lLmM6NzAyCisjOiBidWlsdGluL2Nsb25lLmM6NzAxCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byB1cGRhdGUgJXMiCiBtc2dzdHIgImltcG9zc2liaWxlIGFnZ2lvcm5hcmUgJXMiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo3NTIKKyM6IGJ1aWx0aW4vY2xvbmUuYzo3NTEKIG1zZ2lkICJyZW1vdGUgSEVBRCByZWZlcnMgdG8gbm9uZXhpc3RlbnQgcmVmLCB1bmFibGUgdG8gY2hlY2tvdXQuXG4iCiBtc2dzdHIgIiIKICJsJ0hFQUQgcmVtb3RvIGZhIHJpZmVyaW1lbnRvIGEgdW4gcmlmZXJpbWVudG8gaW5lc2lzdGVudGUsIGltcG9zc2liaWxlICIKICJlc2VndWlyZSBpbCBjaGVja291dC5cbiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjc4MworIzogYnVpbHRpbi9jbG9uZS5jOjc4MgogbXNnaWQgInVuYWJsZSB0byBjaGVja291dCB3b3JraW5nIHRyZWUiCiBtc2dzdHIgImltcG9zc2liaWxlIGVzZWd1aXJlIGlsIGNoZWNrb3V0IGRlbGwnYWxiZXJvIGRpIGxhdm9ybyIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjgzMworIzogYnVpbHRpbi9jbG9uZS5jOjgzMgogbXNnaWQgInVuYWJsZSB0byB3cml0ZSBwYXJhbWV0ZXJzIHRvIGNvbmZpZyBmaWxlIgogbXNnc3RyICJpbXBvc3NpYmlsZSBzY3JpdmVyZSBpIHBhcmFtZXRyaSBuZWwgZmlsZSBkaSBjb25maWd1cmF6aW9uZSIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjg5NgorIzogYnVpbHRpbi9jbG9uZS5jOjg5NQogbXNnaWQgImNhbm5vdCByZXBhY2sgdG8gY2xlYW4gdXAiCiBtc2dzdHIgImltcG9zc2liaWxlIGVzZWd1aXJlIGlsIHJlcGFjayBwZXIgcHVsaXJlIGwnYXJlYSBkaSBsYXZvcm8iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo4OTgKKyM6IGJ1aWx0aW4vY2xvbmUuYzo4OTcKIG1zZ2lkICJjYW5ub3QgdW5saW5rIHRlbXBvcmFyeSBhbHRlcm5hdGVzIGZpbGUiCiBtc2dzdHIgImltcG9zc2liaWxlIGVzZWd1aXJlIGwndW5saW5rIGRlbCBmaWxlIGFsdGVybmF0ZXMgdGVtcG9yYW5lbyIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjkzOCBidWlsdGluL3JlY2VpdmUtcGFjay5jOjE5NTAKKyM6IGJ1aWx0aW4vY2xvbmUuYzo5MzcgYnVpbHRpbi9yZWNlaXZlLXBhY2suYzoxOTQ4CiBtc2dpZCAiVG9vIG1hbnkgYXJndW1lbnRzLiIKIG1zZ3N0ciAiVHJvcHBpIGFyZ29tZW50aS4iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo5NDIKKyM6IGJ1aWx0aW4vY2xvbmUuYzo5NDEKIG1zZ2lkICJZb3UgbXVzdCBzcGVjaWZ5IGEgcmVwb3NpdG9yeSB0byBjbG9uZS4iCiBtc2dzdHIgIkRldmkgc3BlY2lmaWNhcmUgdW4gcmVwb3NpdG9yeSBkYSBjbG9uYXJlLiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjk1NQorIzogYnVpbHRpbi9jbG9uZS5jOjk1NAogIywgYy1mb3JtYXQKIG1zZ2lkICItLWJhcmUgYW5kIC0tb3JpZ2luICVzIG9wdGlvbnMgYXJlIGluY29tcGF0aWJsZS4iCiBtc2dzdHIgImxlIG9wemlvbmkgLS1iYXJlIGUgLS1vcmlnaW4gJXMgbm9uIHNvbm8gY29tcGF0aWJpbGkuIgogCi0jOiBidWlsdGluL2Nsb25lLmM6OTU4CisjOiBidWlsdGluL2Nsb25lLmM6OTU3CiBtc2dpZCAiLS1iYXJlIGFuZCAtLXNlcGFyYXRlLWdpdC1kaXIgYXJlIGluY29tcGF0aWJsZS4iCiBtc2dzdHIgImxlIG9wemlvbmkgLS1iYXJlIGUgLS1zZXBhcmF0ZS1naXQtZGlyIG5vbiBzb25vIGNvbXBhdGliaWxpLiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjk3MQorIzogYnVpbHRpbi9jbG9uZS5jOjk3MAogIywgYy1mb3JtYXQKIG1zZ2lkICJyZXBvc2l0b3J5ICclcycgZG9lcyBub3QgZXhpc3QiCiBtc2dzdHIgImlsIHJlcG9zaXRvcnkgJyVzJyBub24gZXNpc3RlIgogCi0jOiBidWlsdGluL2Nsb25lLmM6OTc3IGJ1aWx0aW4vZmV0Y2guYzoxNjYwCisjOiBidWlsdGluL2Nsb25lLmM6OTc2IGJ1aWx0aW4vZmV0Y2guYzoxNzkwCiAjLCBjLWZvcm1hdAogbXNnaWQgImRlcHRoICVzIGlzIG5vdCBhIHBvc2l0aXZlIG51bWJlciIKIG1zZ3N0ciAibGEgcHJvZm9uZGl0w6AgJXMgbm9uIMOoIHVuIG51bWVybyBwb3NpdGl2byIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjk4NworIzogYnVpbHRpbi9jbG9uZS5jOjk4NgogIywgYy1mb3JtYXQKIG1zZ2lkICJkZXN0aW5hdGlvbiBwYXRoICclcycgYWxyZWFkeSBleGlzdHMgYW5kIGlzIG5vdCBhbiBlbXB0eSBkaXJlY3RvcnkuIgogbXNnc3RyICIiCiAiaWwgcGVyY29yc28gZGkgZGVzdGluYXppb25lICclcycgZXNpc3RlIGdpw6AgZSBub24gw6ggdW5hIGRpcmVjdG9yeSB2dW90YS4iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo5OTcKKyM6IGJ1aWx0aW4vY2xvbmUuYzo5OTYKICMsIGMtZm9ybWF0CiBtc2dpZCAid29ya2luZyB0cmVlICclcycgYWxyZWFkeSBleGlzdHMuIgogbXNnc3RyICJsJ2FsYmVybyBkaSBsYXZvcm8gJyVzJyBlc2lzdGUgZ2nDoC4iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMDEyIGJ1aWx0aW4vY2xvbmUuYzoxMDMzIGJ1aWx0aW4vZGlmZnRvb2wuYzoyNjQKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzozMDMgYnVpbHRpbi93b3JrdHJlZS5jOjMzNQorIzogYnVpbHRpbi9jbG9uZS5jOjEwMTEgYnVpbHRpbi9jbG9uZS5jOjEwMzIgYnVpbHRpbi9kaWZmdG9vbC5jOjI3MQorIzogYnVpbHRpbi9sb2cuYzoxNzg1IGJ1aWx0aW4vd29ya3RyZWUuYzozMDIgYnVpbHRpbi93b3JrdHJlZS5jOjMzNAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgY3JlYXRlIGxlYWRpbmcgZGlyZWN0b3JpZXMgb2YgJyVzJyIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgY3JlYXJlIGxlIHByaW1lIGRpcmVjdG9yeSBkaSAnJXMnIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTAxNworIzogYnVpbHRpbi9jbG9uZS5jOjEwMTYKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGNyZWF0ZSB3b3JrIHRyZWUgZGlyICclcyciCiBtc2dzdHIgImltcG9zc2liaWxlIGNyZWFyZSBsYSBkaXJlY3RvcnkgZGVsbCdhbGJlcm8gZGkgbGF2b3JvICclcyciCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMDM3CisjOiBidWlsdGluL2Nsb25lLmM6MTAzNgogIywgYy1mb3JtYXQKIG1zZ2lkICJDbG9uaW5nIGludG8gYmFyZSByZXBvc2l0b3J5ICclcycuLi5cbiIKIG1zZ3N0ciAiQ2xvbmUgbmVsIHJlcG9zaXRvcnkgc3BvZ2xpbyAnJXMnIGluIGNvcnNvLi4uXG4iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMDM5CisjOiBidWlsdGluL2Nsb25lLmM6MTAzOAogIywgYy1mb3JtYXQKIG1zZ2lkICJDbG9uaW5nIGludG8gJyVzJy4uLlxuIgogbXNnc3RyICJDbG9uZSBpbiAnJXMnIGluIGNvcnNvLi4uXG4iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMDYzCisjOiBidWlsdGluL2Nsb25lLmM6MTA2MgogbXNnaWQgIiIKICJjbG9uZSAtLXJlY3Vyc2l2ZSBpcyBub3QgY29tcGF0aWJsZSB3aXRoIGJvdGggLS1yZWZlcmVuY2UgYW5kIC0tcmVmZXJlbmNlLWlmLSIKICJhYmxlIgpAQCAtMTEzOTksMzYgKzExNDMzLDM2IEBACiAiaWwgY2xvbmUgLS1yZWN1cnNpdmUgbm9uIMOoIGNvbXBhdGliaWxlIG7DqSBjb24gLS1yZWZlcmVuY2UgbsOpIGNvbiAtLXJlZmVyZW5jZS0iCiAiaWYtYWJsZSIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjExMjQKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMTIzCiBtc2dpZCAiLS1kZXB0aCBpcyBpZ25vcmVkIGluIGxvY2FsIGNsb25lczsgdXNlIGZpbGU6Ly8gaW5zdGVhZC4iCiBtc2dzdHIgIkwnb3B6aW9uZSAtLWRlcHRoIMOoIGlnbm9yYXRhIG5laSBjbG9uaSBsb2NhbGk7IHVzYSBmaWxlOi8vLiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjExMjYKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMTI1CiBtc2dpZCAiLS1zaGFsbG93LXNpbmNlIGlzIGlnbm9yZWQgaW4gbG9jYWwgY2xvbmVzOyB1c2UgZmlsZTovLyBpbnN0ZWFkLiIKIG1zZ3N0ciAiTCdvcHppb25lIC0tc2hhbGxvdy1zaW5jZSDDqCBpZ25vcmF0YSBuZWkgY2xvbmkgbG9jYWxpOyB1c2EgZmlsZTovLy4iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMTI4CisjOiBidWlsdGluL2Nsb25lLmM6MTEyNwogbXNnaWQgIi0tc2hhbGxvdy1leGNsdWRlIGlzIGlnbm9yZWQgaW4gbG9jYWwgY2xvbmVzOyB1c2UgZmlsZTovLyBpbnN0ZWFkLiIKIG1zZ3N0ciAiTCdvcHppb25lIC0tc2hhbGxvdy1leGNsdWRlIMOoIGlnbm9yYXRhIG5laSBjbG9uaSBsb2NhbGk7IHVzYSBmaWxlOi8vLiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjExMzAKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMTI5CiBtc2dpZCAiLS1maWx0ZXIgaXMgaWdub3JlZCBpbiBsb2NhbCBjbG9uZXM7IHVzZSBmaWxlOi8vIGluc3RlYWQuIgogbXNnc3RyICJMJ29wemlvbmUgLS1maWx0ZXIgw6ggaWdub3JhdGEgbmVpIGNsb25pIGxvY2FsaTsgdXNhIGZpbGU6Ly8uIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTEzMworIzogYnVpbHRpbi9jbG9uZS5jOjExMzIKIG1zZ2lkICJzb3VyY2UgcmVwb3NpdG9yeSBpcyBzaGFsbG93LCBpZ25vcmluZyAtLWxvY2FsIgogbXNnc3RyICJpbCByZXBvc2l0b3J5IHNvcmdlbnRlIMOoIHNoYWxsb3csIGlnbm9ybyBsJ29wemlvbmUgLS1sb2NhbCIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjExMzgKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMTM3CiBtc2dpZCAiLS1sb2NhbCBpcyBpZ25vcmVkIgogbXNnc3RyICJsJ29wemlvbmUgLS1sb2NhbCDDqCBpZ25vcmF0YSIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEyMTUgYnVpbHRpbi9jbG9uZS5jOjEyMjMKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMjEyIGJ1aWx0aW4vY2xvbmUuYzoxMjIwCiAjLCBjLWZvcm1hdAogbXNnaWQgIlJlbW90ZSBicmFuY2ggJXMgbm90IGZvdW5kIGluIHVwc3RyZWFtICVzIgogbXNnc3RyICJJbCBicmFuY2ggcmVtb3RvICVzIG5vbiDDqCBzdGF0byB0cm92YXRvIG5lbGwndXBzdHJlYW0gJXMiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMjI2CisjOiBidWlsdGluL2Nsb25lLmM6MTIyMwogbXNnaWQgIllvdSBhcHBlYXIgdG8gaGF2ZSBjbG9uZWQgYW4gZW1wdHkgcmVwb3NpdG9yeS4iCiBtc2dzdHIgIlNlbWJyYSBjaGUgdHUgYWJiaWEgY2xvbmF0byB1biByZXBvc2l0b3J5IHZ1b3RvLiIKIApAQCAtMTE1MDYsNyArMTE1NDAsNyBAQAogbXNnc3RyICJJRCBkaSB1biBvZ2dldHRvIGNvbW1pdCBnZW5pdG9yZSIKIAogIzogYnVpbHRpbi9jb21taXQtdHJlZS5jOjExNCBidWlsdGluL2NvbW1pdC5jOjE1MDAgYnVpbHRpbi9tZXJnZS5jOjI3MAotIzogYnVpbHRpbi9ub3Rlcy5jOjQwOSBidWlsdGluL25vdGVzLmM6NTc1IGJ1aWx0aW4vc3Rhc2guYzoxNDYwCisjOiBidWlsdGluL25vdGVzLmM6NDA5IGJ1aWx0aW4vbm90ZXMuYzo1NzUgYnVpbHRpbi9zdGFzaC5jOjE0NjkKICM6IGJ1aWx0aW4vdGFnLmM6NDEyCiBtc2dpZCAibWVzc2FnZSIKIG1zZ3N0ciAibWVzc2FnZ2lvIgpAQCAtMTE1MjAsNyArMTE1NTQsNyBAQAogbXNnc3RyICJsZWdnaSBpbCBtZXNzYWdnaW8gZGkgbG9nIGRlbCBjb21taXQgZGEgdW4gZmlsZSIKIAogIzogYnVpbHRpbi9jb21taXQtdHJlZS5jOjEyMSBidWlsdGluL2NvbW1pdC5jOjE1MTIgYnVpbHRpbi9tZXJnZS5jOjI4NwotIzogYnVpbHRpbi9wdWxsLmM6MTk0IGJ1aWx0aW4vcmV2ZXJ0LmM6MTE4CisjOiBidWlsdGluL3B1bGwuYzoxOTUgYnVpbHRpbi9yZXZlcnQuYzoxMTgKIG1zZ2lkICJHUEcgc2lnbiBjb21taXQiCiBtc2dzdHIgImZpcm1hIGlsIGNvbW1pdCBjb24gR1BHIgogCkBAIC0xMTg1Miw4ICsxMTg4Niw4IEBACiBtc2dpZCAidmVyc2lvbiIKIG1zZ3N0ciAidmVyc2lvbmUiCiAKLSM6IGJ1aWx0aW4vY29tbWl0LmM6MTM0NyBidWlsdGluL2NvbW1pdC5jOjE1MjkgYnVpbHRpbi9wdXNoLmM6NTYxCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NjUxCisjOiBidWlsdGluL2NvbW1pdC5jOjEzNDcgYnVpbHRpbi9jb21taXQuYzoxNTI5IGJ1aWx0aW4vcHVzaC5jOjU0OAorIzogYnVpbHRpbi93b3JrdHJlZS5jOjY1MAogbXNnaWQgIm1hY2hpbmUtcmVhZGFibGUgb3V0cHV0IgogbXNnc3RyICJvdXRwdXQgbGVnZ2liaWxlIGRhIHVuYSBtYWNjaGluYSIKIApAQCAtMTE4NjYsOCArMTE5MDAsOCBAQAogbXNnc3RyICJ0ZXJtaW5hIGxlIHZvY2kgY29uIE5VTCIKIAogIzogYnVpbHRpbi9jb21taXQuYzoxMzU1IGJ1aWx0aW4vY29tbWl0LmM6MTM1OSBidWlsdGluL2NvbW1pdC5jOjE1MzcKLSM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTI1IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTI4Ci0jOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTEzMSBidWlsdGluL3JlYmFzZS5jOjE0NzEgcGFyc2Utb3B0aW9ucy5oOjMzMgorIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNTMgYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNTYKKyM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTU5IGJ1aWx0aW4vcmViYXNlLmM6MTQ5NSBwYXJzZS1vcHRpb25zLmg6MzMyCiBtc2dpZCAibW9kZSIKIG1zZ3N0ciAibW9kbyIKIApAQCAtMTE4ODUsNyArMTE5MTksNyBAQAogInZpc3VhbGl6emEgZmlsZSBpZ25vcmF0aSwgbW9kYWxpdMOgIGZhY29sdGF0aXZlOiB0cmFkaXRpb25hbCwgbWF0Y2hpbmcsIG5vLiAiCiAiKEltcG9zdGF6aW9uZSBwcmVkZWZpbml0YTogdHJhZGl0aW9uYWwpIgogCi0jOiBidWlsdGluL2NvbW1pdC5jOjEzNjIgcGFyc2Utb3B0aW9ucy5oOjE3OQorIzogYnVpbHRpbi9jb21taXQuYzoxMzYyIHBhcnNlLW9wdGlvbnMuaDoxODgKIG1zZ2lkICJ3aGVuIgogbXNnc3RyICJxdWFuZG8iCiAKQEAgLTExOTQwLDcgKzExOTc0LDcgQEAKIG1zZ2lkICJvdmVycmlkZSBhdXRob3IgZm9yIGNvbW1pdCIKIG1zZ3N0ciAic292cmFzY3JpdmkgbCdhdXRvcmUgcGVyIGlsIGNvbW1pdCIKIAotIzogYnVpbHRpbi9jb21taXQuYzoxNDk5IGJ1aWx0aW4vZ2MuYzo1MzkKKyM6IGJ1aWx0aW4vY29tbWl0LmM6MTQ5OSBidWlsdGluL2djLmM6NTM4CiBtc2dpZCAiZGF0ZSIKIG1zZ3N0ciAiZGF0YSIKIApAQCAtMTE5NzYsOCArMTIwMTAsOCBAQAogbXNnaWQgInRoZSBjb21taXQgaXMgYXV0aG9yZWQgYnkgbWUgbm93ICh1c2VkIHdpdGggLUMvLWMvLS1hbWVuZCkiCiBtc2dzdHIgImlsIGNvbW1pdCBvcmEgaGEgbWUgY29tZSBhdXRvcmUgKG9wemlvbmUgdXNhdGEgY29uIC1DLy1jLy0tYW1lbmQpIgogCi0jOiBidWlsdGluL2NvbW1pdC5jOjE1MDYgYnVpbHRpbi9sb2cuYzoxNTY0IGJ1aWx0aW4vbWVyZ2UuYzoyODkKLSM6IGJ1aWx0aW4vcHVsbC5jOjE2MyBidWlsdGluL3JldmVydC5jOjExMAorIzogYnVpbHRpbi9jb21taXQuYzoxNTA2IGJ1aWx0aW4vbG9nLmM6MTU2NSBidWlsdGluL21lcmdlLmM6Mjg5CisjOiBidWlsdGluL3B1bGwuYzoxNjQgYnVpbHRpbi9yZXZlcnQuYzoxMTAKIG1zZ2lkICJhZGQgU2lnbmVkLW9mZi1ieToiCiBtc2dzdHIgImFnZ2l1bmdpIFNpZ25lZC1vZmYtYnk6IgogCkBAIC0xMjA4Niw2NyArMTIxMjAsNzAgQEAKIG1zZ3N0ciAiZ2l0IGNvbW1pdC1ncmFwaCByZWFkIFstLW9iamVjdC1kaXIgPGRpcmVjdG9yeSBvZ2dldHRpPl0iCiAKICM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTMgYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxOQotbXNnaWQgImdpdCBjb21taXQtZ3JhcGggdmVyaWZ5IFstLW9iamVjdC1kaXIgPG9iamRpcj5dIFstLXNoYWxsb3ddIgotbXNnc3RyICJnaXQgY29tbWl0LWdyYXBoIHZlcmlmeSBbLS1vYmplY3QtZGlyIDxkaXJlY3Rvcnkgb2dnZXR0aT5dIFstLXNoYWxsb3ddIgorbXNnaWQgIiIKKyJnaXQgY29tbWl0LWdyYXBoIHZlcmlmeSBbLS1vYmplY3QtZGlyIDxvYmpkaXI+XSBbLS1zaGFsbG93XSBbLS1bbm8tXXByb2dyZXNzXSIKK21zZ3N0ciAiIgorImdpdCBjb21taXQtZ3JhcGggdmVyaWZ5IFstLW9iamVjdC1kaXIgPGRpcmVjdG9yeSBvZ2dldHRpPl0gWy0tc2hhbGxvd10gWy0tIgorIltuby1dcHJvZ3Jlc3NdIgogCiAjOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE0IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MjkKIG1zZ2lkICIiCiAiZ2l0IGNvbW1pdC1ncmFwaCB3cml0ZSBbLS1vYmplY3QtZGlyIDxvYmpkaXI+XSBbLS1hcHBlbmR8LS1zcGxpdF0gWy0tIgotInJlYWNoYWJsZXwtLXN0ZGluLXBhY2tzfC0tc3RkaW4tY29tbWl0c10gPHNwbGl0IG9wdGlvbnM+IgorInJlYWNoYWJsZXwtLXN0ZGluLXBhY2tzfC0tc3RkaW4tY29tbWl0c10gWy0tW25vLV1wcm9ncmVzc10gPHNwbGl0IG9wdGlvbnM+IgogbXNnc3RyICIiCiAiZ2l0IGNvbW1pdC1ncmFwaCB3cml0ZSBbLS1vYmplY3QtZGlyIDxkaXJlY3Rvcnkgb2dnZXR0aT5dIFstLWFwcGVuZHwtLXNwbGl0XSAiCi0iWy0tcmVhY2hhYmxlfC0tc3RkaW4tcGFja3N8LS1zdGRpbi1jb21taXRzXSA8b3B6aW9uaSBzcGxpdD4iCisiWy0tcmVhY2hhYmxlfC0tc3RkaW4tcGFja3N8LS1zdGRpbi1jb21taXRzXSBbLS1bbm8tXXByb2dyZXNzXSA8b3B6aW9uaSBzcGxpdD4iCiAKLSM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6NTQgYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxMDAKLSM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTYxIGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MjM3IGJ1aWx0aW4vZmV0Y2guYzoxNjMKLSM6IGJ1aWx0aW4vbG9nLmM6MTU4NAorIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzo1NSBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjEwNworIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxNzAgYnVpbHRpbi9jb21taXQtZ3JhcGguYzoyNTQgYnVpbHRpbi9mZXRjaC5jOjE3OAorIzogYnVpbHRpbi9sb2cuYzoxNTg1CiBtc2dpZCAiZGlyIgogbXNnc3RyICJkaXJlY3RvcnkiCiAKLSM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6NTUgYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxMDEKLSM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTYyIGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MjM4CisjOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjU2IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTA4CisjOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE3MSBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjI1NQogbXNnaWQgIlRoZSBvYmplY3QgZGlyZWN0b3J5IHRvIHN0b3JlIHRoZSBncmFwaCIKIG1zZ3N0ciAiTGEgZGlyZWN0b3J5IG9nZ2V0dGkgaW4gY3VpIG1lbW9yaXp6YXJlIGlsIGdyYWZvIgogCi0jOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjU3CisjOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjU4CiBtc2dpZCAiaWYgdGhlIGNvbW1pdC1ncmFwaCBpcyBzcGxpdCwgb25seSB2ZXJpZnkgdGhlIHRpcCBmaWxlIgogbXNnc3RyICJzZSBpbCBncmFmbyBkZWkgY29tbWl0IMOoIGRpdmlzbywgdmVyaWZpY2Egc29sbyBsJ3VsdGltbyBmaWxlIgogCi0jOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjczIGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTE2CisjOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjgwIGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTI1CiAjLCBjLWZvcm1hdAogbXNnaWQgIkNvdWxkIG5vdCBvcGVuIGNvbW1pdC1ncmFwaCAnJXMnIgogbXNnc3RyICJJbXBvc3NpYmlsZSBhcHJpcmUgaWwgZ3JhZm8gZGVpIGNvbW1pdCAnJXMnIgogCi0jOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE2NAorIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxNzMKIG1zZ2lkICJzdGFydCB3YWxrIGF0IGFsbCByZWZzIgogbXNnc3RyICJpbml6aWEgbGEgdmlzaXRhIGRhIHR1dHRpIGkgcmlmZXJpbWVudGkiCiAKLSM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTY2CisjOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE3NQogbXNnaWQgInNjYW4gcGFjay1pbmRleGVzIGxpc3RlZCBieSBzdGRpbiBmb3IgY29tbWl0cyIKIG1zZ3N0ciAiIgogImVzYW1pbmEgaSBwYWNrLWluZGV4IGVsZW5jYXRpIHN1bGxvIHN0YW5kYXJkIGlucHV0IGFsbGEgcmljZXJjYSBkaSBjb21taXQiCiAKLSM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTY4CisjOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE3NwogbXNnaWQgInN0YXJ0IHdhbGsgYXQgY29tbWl0cyBsaXN0ZWQgYnkgc3RkaW4iCiBtc2dzdHIgImluaXppYSBsYSB2aXNpdGEgYWkgY29tbWl0IGVsZW5jYXRpIHN1bGxvIHN0YW5kYXJkIGlucHV0IgogCi0jOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE3MAorIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxNzkKIG1zZ2lkICJpbmNsdWRlIGFsbCBjb21taXRzIGFscmVhZHkgaW4gdGhlIGNvbW1pdC1ncmFwaCBmaWxlIgogbXNnc3RyICJpbmNsdWRpIHR1dHRpIGkgY29tbWl0IGdpw6AgcHJlc2VudGkgbmVsIGZpbGUgY29tbWl0LWdyYXBoIgogCi0jOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE3MgorIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxODIKIG1zZ2lkICJhbGxvdyB3cml0aW5nIGFuIGluY3JlbWVudGFsIGNvbW1pdC1ncmFwaCBmaWxlIgogbXNnc3RyICJjb25zZW50aSBsYSBzY3JpdHR1cmEgZGkgdW4gZmlsZSBncmFmbyBkZWkgY29tbWl0IGluY3JlbWVudGFsZSIKIAotIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxNzQgYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxNzgKKyM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTg0IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTg4CiBtc2dpZCAibWF4aW11bSBudW1iZXIgb2YgY29tbWl0cyBpbiBhIG5vbi1iYXNlIHNwbGl0IGNvbW1pdC1ncmFwaCIKIG1zZ3N0ciAibnVtZXJvIG1hc3NpbW8gZGkgY29tbWl0IGluIHVuIGdyYWZvIGRlaSBjb21taXQgZGl2aXNvIG5vbiBkaSBiYXNlIgogCi0jOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE3NgorIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxODYKIG1zZ2lkICJtYXhpbXVtIHJhdGlvIGJldHdlZW4gdHdvIGxldmVscyBvZiBhIHNwbGl0IGNvbW1pdC1ncmFwaCIKIG1zZ3N0ciAicmFwcG9ydG8gbWFzc2ltbyBmcmEgZHVlIGxpdmVsbGkgZGkgdW4gZ3JhZm8gZGVpIGNvbW1pdCBkaXZpc28iCiAKLSM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTkxCisjOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjIwNAogbXNnaWQgInVzZSBhdCBtb3N0IG9uZSBvZiAtLXJlYWNoYWJsZSwgLS1zdGRpbi1jb21taXRzLCBvciAtLXN0ZGluLXBhY2tzIgogbXNnc3RyICJ1c2EgYWwgcGnDuSB1bidvcHppb25lIGZyYSAtLXJlYWNoYWJsZSwgLS1zdGRpbi1jb21taXRzIG8gLS1zdGRpbi1wYWNrcyIKIApAQCAtMTI0NjgsNTkgKzEyNTA1LDU5IEBACiBtc2dpZCAicHJpbnQgc2l6ZXMgaW4gaHVtYW4gcmVhZGFibGUgZm9ybWF0IgogbXNnc3RyICJzdGFtcGEgbGUgZGltZW5zaW9uaSBpbiB1biBmb3JtYXRvIGxlZ2dpYmlsZSIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjI3CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6MjYKIG1zZ2lkICJnaXQgZGVzY3JpYmUgWzxvcHRpb25zPl0gWzxjb21taXQtaXNoPi4uLl0iCiBtc2dzdHIgImdpdCBkZXNjcmliZSBbPG9wemlvbmk+XSBbPGVzcHJlc3Npb25lIGNvbW1pdD4uLi5dIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6MjgKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzoyNwogbXNnaWQgImdpdCBkZXNjcmliZSBbPG9wdGlvbnM+XSAtLWRpcnR5IgogbXNnc3RyICJnaXQgZGVzY3JpYmUgWzxvcHppb25pPl0gLS1kaXJ0eSIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjYzCisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NjIKIG1zZ2lkICJoZWFkIgogbXNnc3RyICJoZWFkIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NjMKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo2MgogbXNnaWQgImxpZ2h0d2VpZ2h0IgogbXNnc3RyICJsZWdnZXJvIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NjMKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo2MgogbXNnaWQgImFubm90YXRlZCIKIG1zZ3N0ciAiYW5ub3RhdG8iCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzoyNzMKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzoyNzUKICMsIGMtZm9ybWF0CiBtc2dpZCAiYW5ub3RhdGVkIHRhZyAlcyBub3QgYXZhaWxhYmxlIgogbXNnc3RyICJpbCB0YWcgYW5ub3RhdG8gJXMgbm9uIMOoIGRpc3BvbmliaWxlIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6Mjc3CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6Mjc5CiAjLCBjLWZvcm1hdAogbXNnaWQgImFubm90YXRlZCB0YWcgJXMgaGFzIG5vIGVtYmVkZGVkIG5hbWUiCiBtc2dzdHIgImlsIHRhZyBhbm5vdGF0byAlcyBub24gaGEgdW4gbm9tZSBpbmNvcnBvcmF0byIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjI3OQorIzogYnVpbHRpbi9kZXNjcmliZS5jOjI4MQogIywgYy1mb3JtYXQKIG1zZ2lkICJ0YWcgJyVzJyBpcyByZWFsbHkgJyVzJyBoZXJlIgogbXNnc3RyICJpbCB0YWcgJyVzJyBpbiByZWFsdMOgIHF1aSDDqCAnJXMnIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6MzIzCisjOiBidWlsdGluL2Rlc2NyaWJlLmM6MzI1CiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vIHRhZyBleGFjdGx5IG1hdGNoZXMgJyVzJyIKIG1zZ3N0ciAibmVzc3VuIHRhZyBjb3JyaXNwb25kZSBlc2F0dGFtZW50ZSBhICclcyciCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzozMjUKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzozMjcKICMsIGMtZm9ybWF0CiBtc2dpZCAiTm8gZXhhY3QgbWF0Y2ggb24gcmVmcyBvciB0YWdzLCBzZWFyY2hpbmcgdG8gZGVzY3JpYmVcbiIKIG1zZ3N0ciAiIgogIk5lc3N1bmEgY29ycmlzcG9uZGVuemEgZXNhdHRhIHN1aSByaWZlcmltZW50aSBvIHN1aSB0YWcsIHN0byBlc2VndWVuZG8gdW5hICIKICJyaWNlcmNhIHBlciBkZXNjcml2ZXJlIGlsIGNvbW1pdFxuIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6Mzc5CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6MzgxCiAjLCBjLWZvcm1hdAogbXNnaWQgImZpbmlzaGVkIHNlYXJjaCBhdCAlc1xuIgogbXNnc3RyICJyaWNlcmNhIHRlcm1pbmF0YSBpbiAlc1xuIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NDA1CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NDA3CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJObyBhbm5vdGF0ZWQgdGFncyBjYW4gZGVzY3JpYmUgJyVzJy5cbiIKQEAgLTEyNTI5LDcgKzEyNTY2LDcgQEAKICJOZXNzdW4gdGFnIGFubm90YXRvIHB1w7IgZGVzY3JpdmVyZSAnJXMnLlxuIgogIkNpw7Igbm9ub3N0YW50ZSwgYydlcmFubyBkZWkgdGFnIG5vbiBhbm5vdGF0aTogcHJvdmEgY29uIC0tdGFncy4iCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo0MDkKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo0MTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIk5vIHRhZ3MgY2FuIGRlc2NyaWJlICclcycuXG4iCkBAIC0xMjUzOCwxMiArMTI1NzUsMTIgQEAKICJOZXNzdW4gdGFnIHB1w7IgZGVzY3JpdmVyZSAnJXMnLlxuIgogIlByb3ZhIGNvbiAtLWFsd2F5cyBvIGNyZWEgZGVpIHRhZy4iCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo0MzkKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo0NDEKICMsIGMtZm9ybWF0CiBtc2dpZCAidHJhdmVyc2VkICVsdSBjb21taXRzXG4iCiBtc2dzdHIgImhvIGF0dHJhdmVyc2F0byAlbHUgY29tbWl0XG4iCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo0NDIKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo0NDQKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIm1vcmUgdGhhbiAlaSB0YWdzIGZvdW5kOyBsaXN0ZWQgJWkgbW9zdCByZWNlbnRcbiIKQEAgLTEyNTUyLDk0ICsxMjU4OSw5NCBAQAogInRyb3ZhdGkgcGnDuSBkaSAlaSB0YWc7IGhvIGVsZW5jYXRvIGkgJWkgcGnDuSByZWNlbnRpXG4iCiAiaG8gdGVybWluYXRvIGxhIHJpY2VyY2EgaW4gJXNcbiIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjUxMAorIzogYnVpbHRpbi9kZXNjcmliZS5jOjUxMgogIywgYy1mb3JtYXQKIG1zZ2lkICJkZXNjcmliZSAlc1xuIgogbXNnc3RyICJkZXNjcml2aSAlc1xuIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NTEzCisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NTE1CiAjLCBjLWZvcm1hdAogbXNnaWQgIk5vdCBhIHZhbGlkIG9iamVjdCBuYW1lICVzIgogbXNnc3RyICIlcyBub24gw6ggdW4gbm9tZSBvZ2dldHRvIHZhbGlkbyIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjUyMQorIzogYnVpbHRpbi9kZXNjcmliZS5jOjUyMwogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyBpcyBuZWl0aGVyIGEgY29tbWl0IG5vciBibG9iIgogbXNnc3RyICIlcyBub24gw6ggbsOpIHVuIGNvbW1pdCBuw6kgdW4gYmxvYiIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjUzNQorIzogYnVpbHRpbi9kZXNjcmliZS5jOjUzNwogbXNnaWQgImZpbmQgdGhlIHRhZyB0aGF0IGNvbWVzIGFmdGVyIHRoZSBjb21taXQiCiBtc2dzdHIgInRyb3ZhIGlsIHRhZyBzdWNjZXNzaXZvIGFsIGNvbW1pdCIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjUzNgorIzogYnVpbHRpbi9kZXNjcmliZS5jOjUzOAogbXNnaWQgImRlYnVnIHNlYXJjaCBzdHJhdGVneSBvbiBzdGRlcnIiCiBtc2dzdHIgImVzZWd1aSBpbCBkZWJ1ZyBkZWxsYSBzdHJhdGVnaWEgZGkgcmljZXJjYSBzdWxsbyBzdGFuZGFyZCBlcnJvciIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjUzNworIzogYnVpbHRpbi9kZXNjcmliZS5jOjUzOQogbXNnaWQgInVzZSBhbnkgcmVmIgogbXNnc3RyICJ1c2EgcXVhbHVucXVlIHJpZmVyaW1lbnRvIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NTM4CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NTQwCiBtc2dpZCAidXNlIGFueSB0YWcsIGV2ZW4gdW5hbm5vdGF0ZWQiCiBtc2dzdHIgInVzYSBxdWFsdW5xdWUgdGFnLCBhbmNoZSBxdWVsbGkgbm9uIGFubm90YXRpIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NTM5CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NTQxCiBtc2dpZCAiYWx3YXlzIHVzZSBsb25nIGZvcm1hdCIKIG1zZ3N0ciAidXNhIHNlbXByZSBpbCBmb3JtYXRvIGx1bmdvIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NTQwCisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NTQyCiBtc2dpZCAib25seSBmb2xsb3cgZmlyc3QgcGFyZW50IgogbXNnc3RyICJzZWd1aSBzb2xvIGlsIHByaW1vIGdlbml0b3JlIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NTQzCisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NTQ1CiBtc2dpZCAib25seSBvdXRwdXQgZXhhY3QgbWF0Y2hlcyIKIG1zZ3N0ciAidmlzdWFsaXp6YSBzb2xvIGxlIGNvcnJpc3BvbmRlbnplIGVzYXR0ZSIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjU0NQorIzogYnVpbHRpbi9kZXNjcmliZS5jOjU0NwogbXNnaWQgImNvbnNpZGVyIDxuPiBtb3N0IHJlY2VudCB0YWdzIChkZWZhdWx0OiAxMCkiCiBtc2dzdHIgImNvbnNpZGVyYSBnbGkgPG4+IHRhZyBwacO5IHJlY2VudGkgKGltcG9zdGF6aW9uZSBwcmVkZWZpbml0YTogMTApIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NTQ3CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NTQ5CiBtc2dpZCAib25seSBjb25zaWRlciB0YWdzIG1hdGNoaW5nIDxwYXR0ZXJuPiIKIG1zZ3N0ciAiY29uc2lkZXJhIHNvbG8gaSB0YWcgY29ycmlzcG9uZGVudGkgYWwgPHBhdHRlcm4+IgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NTQ5CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NTUxCiBtc2dpZCAiZG8gbm90IGNvbnNpZGVyIHRhZ3MgbWF0Y2hpbmcgPHBhdHRlcm4+IgogbXNnc3RyICJub24gY29uc2lkZXJhcmUgaSB0YWcgY29ycmlzcG9uZGVudGkgYWwgPHBhdHRlcm4+IgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NTUxIGJ1aWx0aW4vbmFtZS1yZXYuYzo0MjIKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1NTMgYnVpbHRpbi9uYW1lLXJldi5jOjQyNgogbXNnaWQgInNob3cgYWJicmV2aWF0ZWQgY29tbWl0IG9iamVjdCBhcyBmYWxsYmFjayIKIG1zZ3N0ciAidmlzdWFsaXp6YSBsJ29nZ2V0dG8gY29tbWl0IGFiYnJldmlhdG8gY29tZSBmYWxsYmFjayIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjU1MiBidWlsdGluL2Rlc2NyaWJlLmM6NTU1CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NTU0IGJ1aWx0aW4vZGVzY3JpYmUuYzo1NTcKIG1zZ2lkICJtYXJrIgogbXNnc3RyICJjb250cmFzc2Vnbm8iCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1NTMKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1NTUKIG1zZ2lkICJhcHBlbmQgPG1hcms+IG9uIGRpcnR5IHdvcmtpbmcgdHJlZSAoZGVmYXVsdDogXCItZGlydHlcIikiCiBtc2dzdHIgIiIKICJhZ2dpdW5naSA8Y29udHJhc3NlZ25vPiBhbGwnYWxiZXJvIGRpIGxhdm9ybyBzcG9yY28gKGltcG9zdGF6aW9uZSAiCiAicHJlZGVmaW5pdGE6IFwiLWRpcnR5XCIpIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NTU2CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NTU4CiBtc2dpZCAiYXBwZW5kIDxtYXJrPiBvbiBicm9rZW4gd29ya2luZyB0cmVlIChkZWZhdWx0OiBcIi1icm9rZW5cIikiCiBtc2dzdHIgIiIKICJhZ2dpdW5naSA8Y29udHJhc3NlZ25vPiBhbGwnYWxiZXJvIGRpIGxhdm9ybyByb3R0byAoaW1wb3N0YXppb25lICIKICJwcmVkZWZpbml0YTogXCItYnJva2VuXCIpIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NTc0CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NTc2CiBtc2dpZCAiLS1sb25nIGlzIGluY29tcGF0aWJsZSB3aXRoIC0tYWJicmV2PTAiCiBtc2dzdHIgIi0tbG9uZyBub24gw6ggY29tcGF0aWJpbGUgY29uIC0tYWJicmV2PTAiCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo2MDMKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo2MDUKIG1zZ2lkICJObyBuYW1lcyBmb3VuZCwgY2Fubm90IGRlc2NyaWJlIGFueXRoaW5nLiIKIG1zZ3N0ciAiTmVzc3VuIG5vbWUgdHJvdmF0bywgbm9uIMOoIHBvc3NpYmlsZSBkZXNjcml2ZXJlIG51bGxhLiIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjY1NAorIzogYnVpbHRpbi9kZXNjcmliZS5jOjY1NgogbXNnaWQgIi0tZGlydHkgaXMgaW5jb21wYXRpYmxlIHdpdGggY29tbWl0LWlzaGVzIgogbXNnc3RyICItLWRpcnR5IG5vbiDDqCBjb21wYXRpYmlsZSBjb24gbGUgZXNwcmVzc2lvbmkgY29tbWl0IgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NjU2CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NjU4CiBtc2dpZCAiLS1icm9rZW4gaXMgaW5jb21wYXRpYmxlIHdpdGggY29tbWl0LWlzaGVzIgogbXNnc3RyICItLWJyb2tlbiBub24gw6ggY29tcGF0aWJpbGUgY29uIGxlIGVzcHJlc3Npb25pIGNvbW1pdCIKIApAQCAtMTI2NzYsMjcgKzEyNzEzLDI3IEBACiBtc2dpZCAiZ2l0IGRpZmZ0b29sIFs8b3B0aW9ucz5dIFs8Y29tbWl0PiBbPGNvbW1pdD5dXSBbLS1dIFs8cGF0aD4uLi5dIgogbXNnc3RyICJnaXQgZGlmZnRvb2wgWzxvcHppb25pPl0gWzxjb21taXQ+IFs8Y29tbWl0Pl1dIFstLV0gWzxwZXJjb3Jzbz4uLi5dIgogCi0jOiBidWlsdGluL2RpZmZ0b29sLmM6MjUzCisjOiBidWlsdGluL2RpZmZ0b29sLmM6MjYwCiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZDogJWQiCiBtc2dzdHIgIm5vbiByaXVzY2l0bzogJWQiCiAKLSM6IGJ1aWx0aW4vZGlmZnRvb2wuYzoyOTUKKyM6IGJ1aWx0aW4vZGlmZnRvb2wuYzozMDIKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHJlYWQgc3ltbGluayAlcyIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgbGVnZ2VyZSBpbCBjb2xsZWdhbWVudG8gc2ltYm9saWNvICVzIgogCi0jOiBidWlsdGluL2RpZmZ0b29sLmM6Mjk3CisjOiBidWlsdGluL2RpZmZ0b29sLmM6MzA0CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCByZWFkIHN5bWxpbmsgZmlsZSAlcyIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgbGVnZ2VyZSBpbCBmaWxlIGNvbGxlZ2FtZW50byBzaW1ib2xpY28gJXMiCiAKLSM6IGJ1aWx0aW4vZGlmZnRvb2wuYzozMDUKKyM6IGJ1aWx0aW4vZGlmZnRvb2wuYzozMTIKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHJlYWQgb2JqZWN0ICVzIGZvciBzeW1saW5rICVzIgogbXNnc3RyICJpbXBvc3NpYmlsZSBsZWdnZXJlIGwnb2dnZXR0byAlcyBwZXIgaWwgY29sbGVnYW1lbnRvIHNpbWJvbGljbyAlcyIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjQwNgorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjQxMwogbXNnaWQgIiIKICJjb21iaW5lZCBkaWZmIGZvcm1hdHMoJy1jJyBhbmQgJy0tY2MnKSBhcmUgbm90IHN1cHBvcnRlZCBpblxuIgogImRpcmVjdG9yeSBkaWZmIG1vZGUoJy1kJyBhbmQgJy0tZGlyLWRpZmYnKS4iCkBAIC0xMjcwNCw1NCArMTI3NDEsNTQgQEAKICJpIGZvcm1hdGkgZGlmZiBjb21iaW5hdGkgKCctYycgZSAnLS1jYycpIG5vbiBzb25vIHN1cHBvcnRhdGkgaW5cbiIKICJtb2RhbGl0w6AgZGlmZiBkaXJlY3RvcnkgKCctZCcgZSAnLS1kaXItZGlmZicpLiIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjYyNgorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjYzNAogIywgYy1mb3JtYXQKIG1zZ2lkICJib3RoIGZpbGVzIG1vZGlmaWVkOiAnJXMnIGFuZCAnJXMnLiIKIG1zZ3N0ciAiZW50cmFtYmkgaSBmaWxlIHJpc3VsdGFubyBtb2RpZmljYXRpOiAnJXMnIGUgJyVzJy4iCiAKLSM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo2MjgKKyM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo2MzYKIG1zZ2lkICJ3b3JraW5nIHRyZWUgZmlsZSBoYXMgYmVlbiBsZWZ0LiIKIG1zZ3N0ciAiaWwgZmlsZSBuZWxsJ2FsYmVybyBkaSBsYXZvcm8gw6ggc3RhdG8gbWFudGVudXRvLiIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjYzOQorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjY0NwogIywgYy1mb3JtYXQKIG1zZ2lkICJ0ZW1wb3JhcnkgZmlsZXMgZXhpc3QgaW4gJyVzJy4iCiBtc2dzdHIgImVzaXN0b25vIGZpbGUgdGVtcG9yYW5laSBpbiAnJXMnLiIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjY0MAorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjY0OAogbXNnaWQgInlvdSBtYXkgd2FudCB0byBjbGVhbnVwIG9yIHJlY292ZXIgdGhlc2UuIgogbXNnc3RyICJwb3RyZXN0aSB2b2xlciByaXB1bGlybGkgbyByaXByaXN0aW5hcmxpLiIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjY4OQorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjY5NwogbXNnaWQgInVzZSBgZGlmZi5ndWl0b29sYCBpbnN0ZWFkIG9mIGBkaWZmLnRvb2xgIgogbXNnc3RyICJ1c2EgYGRpZmYuZ3VpdG9vbGAgYW56aWNow6kgYGRpZmYudG9vbGAiCiAKLSM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo2OTEKKyM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo2OTkKIG1zZ2lkICJwZXJmb3JtIGEgZnVsbC1kaXJlY3RvcnkgZGlmZiIKIG1zZ3N0ciAiZXNlZ3VpIHVuIGRpZmYgZGlyZWN0b3J5IGNvbXBsZXRvIgogCi0jOiBidWlsdGluL2RpZmZ0b29sLmM6NjkzCisjOiBidWlsdGluL2RpZmZ0b29sLmM6NzAxCiBtc2dpZCAiZG8gbm90IHByb21wdCBiZWZvcmUgbGF1bmNoaW5nIGEgZGlmZiB0b29sIgogbXNnc3RyICJub24gY2hpZWRlcmUgY29uZmVybWEgcHJpbWEgZGkgbGFuY2lhcmUgdW4gdG9vbCBkaWZmIgogCi0jOiBidWlsdGluL2RpZmZ0b29sLmM6Njk4CisjOiBidWlsdGluL2RpZmZ0b29sLmM6NzA2CiBtc2dpZCAidXNlIHN5bWxpbmtzIGluIGRpci1kaWZmIG1vZGUiCiBtc2dzdHIgInVzYSBjb2xsZWdhbWVudGkgc2ltYm9saWNpIGluIG1vZGFsaXTDoCBkaWZmIGRpcmVjdG9yeSIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjY5OQorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjcwNwogbXNnaWQgInRvb2wiCiBtc2dzdHIgInN0cnVtZW50byIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjcwMAorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjcwOAogbXNnaWQgInVzZSB0aGUgc3BlY2lmaWVkIGRpZmYgdG9vbCIKIG1zZ3N0ciAidXNhIGxvIHN0cnVtZW50byBkaWZmIHNwZWNpZmljYXRvIgogCi0jOiBidWlsdGluL2RpZmZ0b29sLmM6NzAyCisjOiBidWlsdGluL2RpZmZ0b29sLmM6NzEwCiBtc2dpZCAicHJpbnQgYSBsaXN0IG9mIGRpZmYgdG9vbHMgdGhhdCBtYXkgYmUgdXNlZCB3aXRoIGAtLXRvb2xgIgogbXNnc3RyICIiCiAic3RhbXBhIHVuIGVsZW5jbyBkaSBzdHJ1bWVudGkgZGlmZiBjaGUgcG9zc29ubyBlc3NlcmUgdXNhdGkgY29uIGAtLXRvb2xgIgogCi0jOiBidWlsdGluL2RpZmZ0b29sLmM6NzA1CisjOiBidWlsdGluL2RpZmZ0b29sLmM6NzEzCiBtc2dpZCAiIgogIm1ha2UgJ2dpdC1kaWZmdG9vbCcgZXhpdCB3aGVuIGFuIGludm9rZWQgZGlmZiB0b29sIHJldHVybnMgYSBub24gLSB6ZXJvIGV4aXQgIgogImNvZGUiCkBAIC0xMjc1OSwzMSArMTI3OTYsMzEgQEAKICJmYWkgc8OsIGNoZSAnZ2l0LWRpZmZ0b29sJyBlc2NhIHF1YW5kbyB1bm8gc3RydW1lbnRvIGRpZmYgaW52b2NhdG8gIgogInJlc3RpdHVpc2NlIHVuIGNvZGljZSBkJ3VzY2l0YSBkaXZlcnNvIGRhIHplcm8iCiAKLSM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo3MDgKKyM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo3MTYKIG1zZ2lkICJzcGVjaWZ5IGEgY3VzdG9tIGNvbW1hbmQgZm9yIHZpZXdpbmcgZGlmZnMiCiBtc2dzdHIgInNwZWNpZmljYSB1biBjb21hbmRvIHBlcnNvbmFsaXp6YXRvIHBlciB2aXN1YWxpenphcmUgaSBkaWZmIgogCi0jOiBidWlsdGluL2RpZmZ0b29sLmM6NzA5CisjOiBidWlsdGluL2RpZmZ0b29sLmM6NzE3CiBtc2dpZCAicGFzc2VkIHRvIGBkaWZmYCIKIG1zZ3N0ciAiZm9ybml0byBhIGBkaWZmYCIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjcyNAorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjczMgogbXNnaWQgImRpZmZ0b29sIHJlcXVpcmVzIHdvcmt0cmVlIG9yIC0tbm8taW5kZXgiCiBtc2dzdHIgImRpZmZ0b29sIHJpY2hpZWRlIHVuIGFsYmVybyBkaSBsYXZvcm8gbyAtLW5vLWluZGV4IgogCi0jOiBidWlsdGluL2RpZmZ0b29sLmM6NzMxCisjOiBidWlsdGluL2RpZmZ0b29sLmM6NzM5CiBtc2dpZCAiLS1kaXItZGlmZiBpcyBpbmNvbXBhdGlibGUgd2l0aCAtLW5vLWluZGV4IgogbXNnc3RyICItLWRpci1kaWZmIG5vbiDDqCBjb21wYXRpYmlsZSBjb24gLS1uby1pbmRleCIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjczNAorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjc0MgogbXNnaWQgIi0tZ3VpLCAtLXRvb2wgYW5kIC0tZXh0Y21kIGFyZSBtdXR1YWxseSBleGNsdXNpdmUiCiBtc2dzdHIgImxlIG9wemlvbmkgLS1ndWksIC0tdG9vbCBlZCAtLWV4dGNtZCBzb25vIG11dHVhbG1lbnRlIGVzY2x1c2l2ZSIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjc0MgorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjc1MAogbXNnaWQgIm5vIDx0b29sPiBnaXZlbiBmb3IgLS10b29sPTx0b29sPiIKIG1zZ3N0ciAibmVzc3VubyA8c3RydW1lbnRvPiBzcGVjaWZpY2F0byBwZXIgLS10b29sPTxzdHJ1bWVudG8+IgogCi0jOiBidWlsdGluL2RpZmZ0b29sLmM6NzQ5CisjOiBidWlsdGluL2RpZmZ0b29sLmM6NzU3CiBtc2dpZCAibm8gPGNtZD4gZ2l2ZW4gZm9yIC0tZXh0Y21kPTxjbWQ+IgogbXNnc3RyICJuZXNzdW4gPGNvbWFuZG8+IHNwZWNpZmljYXRvIHBlciAtLWV4dGNtZD08Y29tYW5kbz4iCiAKQEAgLTEyODI1LDE2MSArMTI4NjIsMTg5IEBACiBtc2dpZCAiZ2l0IGZhc3QtZXhwb3J0IFtyZXYtbGlzdC1vcHRzXSIKIG1zZ3N0ciAiZ2l0IGZhc3QtZXhwb3J0IFtvcHppb25pLWVsZW5jby1yZXZdIgogCi0jOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTEyNAorIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjg1MgorbXNnaWQgIkVycm9yOiBDYW5ub3QgZXhwb3J0IG5lc3RlZCB0YWdzIHVubGVzcyAtLW1hcmstdGFncyBpcyBzcGVjaWZpZWQuIgorbXNnc3RyICIiCisiRXJyb3JlOiBJbXBvc3NpYmlsZSBlc3BvcnRhcmUgaSB0YWcgbmlkaWZpY2F0aSBhIG1lbm8gY2hlIG5vbiBzaWEgIgorInNwZWNpZmljYXRhIGwnb3B6aW9uZSAtLW1hcmstdGFncy4iCisKKyM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTUyCiBtc2dpZCAic2hvdyBwcm9ncmVzcyBhZnRlciA8bj4gb2JqZWN0cyIKIG1zZ3N0ciAidmlzdWFsaXp6YSBsJ2F2YW56YW1lbnRvIGRvcG8gPG4+IG9nZ2V0dGkiCiAKLSM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTI2CisjOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE1NAogbXNnaWQgInNlbGVjdCBoYW5kbGluZyBvZiBzaWduZWQgdGFncyIKIG1zZ3N0ciAic2VsZXppb25hIGxhIGdlc3Rpb25lIGRlaSB0YWcgZmlybWF0aSIKIAotIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExMjkKKyM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTU3CiBtc2dpZCAic2VsZWN0IGhhbmRsaW5nIG9mIHRhZ3MgdGhhdCB0YWcgZmlsdGVyZWQgb2JqZWN0cyIKIG1zZ3N0ciAic2VsZXppb25hIGxhIGdlc3Rpb25lIGRlaSB0YWcgY2hlIGNvbnRyYXNzZWduYW5vIG9nZ2V0dGkgZmlsdHJhdGkiCiAKLSM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTMyCisjOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE2MAogbXNnaWQgInNlbGVjdCBoYW5kbGluZyBvZiBjb21taXQgbWVzc2FnZXMgaW4gYW4gYWx0ZXJuYXRlIGVuY29kaW5nIgogbXNnc3RyICIiCiAic2VsZXppb25hIGxhIGdlc3Rpb25lIGRlaSBtZXNzYWdnaSBkaSBjb21taXQgaW4gdW5hIGNvZGlmaWNhIGFsdGVybmF0aXZhIgogCi0jOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTEzNQorIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNjMKIG1zZ2lkICJEdW1wIG1hcmtzIHRvIHRoaXMgZmlsZSIKIG1zZ3N0ciAiRXNlZ3VpIGlsIGR1bXAgZGVpIGNvbnRyYXNzZWduaSBpbiBxdWVzdG8gZmlsZSIKIAotIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExMzcKKyM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTY1CiBtc2dpZCAiSW1wb3J0IG1hcmtzIGZyb20gdGhpcyBmaWxlIgogbXNnc3RyICJJbXBvcnRhIGkgY29udHJhc3NlZ25pIGRhIHF1ZXN0byBmaWxlIgogCi0jOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTEzOQorIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNjkKK21zZ2lkICJJbXBvcnQgbWFya3MgZnJvbSB0aGlzIGZpbGUgaWYgaXQgZXhpc3RzIgorbXNnc3RyICJJbXBvcnRhIGkgY29udHJhc3NlZ25pIGRhIHF1ZXN0byBmaWxlIHNlIGVzaXN0ZSIKKworIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNzEKIG1zZ2lkICJGYWtlIGEgdGFnZ2VyIHdoZW4gdGFncyBsYWNrIG9uZSIKIG1zZ3N0ciAiVXNhIHVuIHRhZ2dlciBmYWxzbyBzZSBpIHRhZyBub24gbmUgaGFubm8gdW5vIgogCi0jOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE0MQorIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNzMKIG1zZ2lkICJPdXRwdXQgZnVsbCB0cmVlIGZvciBlYWNoIGNvbW1pdCIKIG1zZ3N0ciAiVmlzdWFsaXp6YSBpbiBvdXRwdXQgbCdhbGJlcm8gY29tcGxldG8gcGVyIG9nbmkgY29tbWl0IgogCi0jOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE0MworIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNzUKIG1zZ2lkICJVc2UgdGhlIGRvbmUgZmVhdHVyZSB0byB0ZXJtaW5hdGUgdGhlIHN0cmVhbSIKIG1zZ3N0ciAiVXNhIGxhIGZ1bnppb25hbGl0w6AgXCJmYXR0b1wiIHBlciB0ZXJtaW5hcmUgaWwgZmx1c3NvIgogCi0jOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE0NAorIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNzYKIG1zZ2lkICJTa2lwIG91dHB1dCBvZiBibG9iIGRhdGEiCiBtc2dzdHIgIk9tZXR0aSBsJ291dHB1dCBkZWkgZGF0aSBkZWkgYmxvYiIKIAotIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNDUgYnVpbHRpbi9sb2cuYzoxNjMyCisjOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE3NyBidWlsdGluL2xvZy5jOjE2MzMKIG1zZ2lkICJyZWZzcGVjIgogbXNnc3RyICJzcGVjaWZpY2F0b3JlIHJpZmVyaW1lbnRvIgogCi0jOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE0NgorIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNzgKIG1zZ2lkICJBcHBseSByZWZzcGVjIHRvIGV4cG9ydGVkIHJlZnMiCiBtc2dzdHIgIkFwcGxpY2EgbG8gc3BlY2lmaWNhdG9yZSByaWZlcmltZW50byBhaSByaWZlcmltZW50aSBlc3BvcnRhdGkiCiAKLSM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTQ3CisjOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE3OQogbXNnaWQgImFub255bWl6ZSBvdXRwdXQiCiBtc2dzdHIgInJlbmRpIGFub25pbW8gbCdvdXRwdXQiCiAKLSM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTQ5CisjOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE4MQogbXNnaWQgIlJlZmVyZW5jZSBwYXJlbnRzIHdoaWNoIGFyZSBub3QgaW4gZmFzdC1leHBvcnQgc3RyZWFtIGJ5IG9iamVjdCBpZCIKIG1zZ3N0ciAiIgogIkZhaSByaWZlcmltZW50byBhaSBnZW5pdG9yaSBub24gbmVsIGZsdXNzbyBmYXN0LWV4cG9ydCB0cmFtaXRlIGwnSUQgb2dnZXR0byIKIAotIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNTEKKyM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTgzCiBtc2dpZCAiU2hvdyBvcmlnaW5hbCBvYmplY3QgaWRzIG9mIGJsb2JzL2NvbW1pdHMiCiBtc2dzdHIgIlZpc3VhbGl6emEgZ2xpIElEIG9nZ2V0dG8gb3JpZ2luYXJpIGRlaSBibG9iL2NvbW1pdCIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjMwCisjOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE4NQorbXNnaWQgIkxhYmVsIHRhZ3Mgd2l0aCBtYXJrIGlkcyIKK21zZ3N0ciAiRXRpY2hldHRhIGkgdGFnIGNvbiBJRCBjb250cmFzc2Vnbm8iCisKKyM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMjIwCittc2dpZCAiQ2Fubm90IHBhc3MgYm90aCAtLWltcG9ydC1tYXJrcyBhbmQgLS1pbXBvcnQtbWFya3MtaWYtZXhpc3RzIgorbXNnc3RyICIiCisiSW1wb3NzaWJpbGUgZm9ybmlyZSBlbnRyYW1iZSBsZSBvcHppb25pIC0taW1wb3J0LW1hcmtzIGUgLS1pbXBvcnQtbWFya3MtaWYtIgorImV4aXN0cyIKKworIzogYnVpbHRpbi9mZXRjaC5jOjM0CiBtc2dpZCAiZ2l0IGZldGNoIFs8b3B0aW9ucz5dIFs8cmVwb3NpdG9yeT4gWzxyZWZzcGVjPi4uLl1dIgogbXNnc3RyICJnaXQgZmV0Y2ggWzxvcHppb25pPl0gWzxyZXBvc2l0b3J5PiBbPHNwZWNpZmljYXRvcmUgcmlmZXJpbWVudG8+Li4uXV0iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzozMQorIzogYnVpbHRpbi9mZXRjaC5jOjM1CiBtc2dpZCAiZ2l0IGZldGNoIFs8b3B0aW9ucz5dIDxncm91cD4iCiBtc2dzdHIgImdpdCBmZXRjaCBbPG9wemlvbmk+XSA8Z3J1cHBvPiIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjMyCisjOiBidWlsdGluL2ZldGNoLmM6MzYKIG1zZ2lkICJnaXQgZmV0Y2ggLS1tdWx0aXBsZSBbPG9wdGlvbnM+XSBbKDxyZXBvc2l0b3J5PiB8IDxncm91cD4pLi4uXSIKIG1zZ3N0ciAiZ2l0IGZldGNoIC0tbXVsdGlwbGUgWzxvcHppb25pPl0gWyg8cmVwb3NpdG9yeT4gfCA8Z3J1cHBvPikuLi5dIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MzMKKyM6IGJ1aWx0aW4vZmV0Y2guYzozNwogbXNnaWQgImdpdCBmZXRjaCAtLWFsbCBbPG9wdGlvbnM+XSIKIG1zZ3N0ciAiZ2l0IGZldGNoIC0tYWxsIFs8b3B6aW9uaT5dIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTI1IGJ1aWx0aW4vcHVsbC5jOjIwMworIzogYnVpbHRpbi9mZXRjaC5jOjExNQorbXNnaWQgImZldGNoLnBhcmFsbGVsIGNhbm5vdCBiZSBuZWdhdGl2ZSIKK21zZ3N0ciAiZmV0Y2gucGFyYWxsZWwgbm9uIHB1w7IgZXNzZXJlIG5lZ2F0aXZvIgorCisjOiBidWlsdGluL2ZldGNoLmM6MTM4IGJ1aWx0aW4vcHVsbC5jOjIwNAogbXNnaWQgImZldGNoIGZyb20gYWxsIHJlbW90ZXMiCiBtc2dzdHIgImVzZWd1aSBpbCBmZXRjaCBkYSB0dXR0aSBpIHJlbW90aSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjEyNyBidWlsdGluL3B1bGwuYzoyMDYKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNDAgYnVpbHRpbi9wdWxsLmM6MjQ4Cittc2dpZCAic2V0IHVwc3RyZWFtIGZvciBnaXQgcHVsbC9mZXRjaCIKK21zZ3N0ciAiaW1wb3N0YSBsJ3Vwc3RyZWFtIHBlciBnaXQgcHVsbC9mZXRjaCIKKworIzogYnVpbHRpbi9mZXRjaC5jOjE0MiBidWlsdGluL3B1bGwuYzoyMDcKIG1zZ2lkICJhcHBlbmQgdG8gLmdpdC9GRVRDSF9IRUFEIGluc3RlYWQgb2Ygb3ZlcndyaXRpbmciCiBtc2dzdHIgImFnZ2l1bmdpIGkgZGF0aSBhIC5naXQvRkVUQ0hfSEVBRCBhbnppY2jDqSBzb3ZyYXNjcml2ZXJsaSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjEyOSBidWlsdGluL3B1bGwuYzoyMDkKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNDQgYnVpbHRpbi9wdWxsLmM6MjEwCiBtc2dpZCAicGF0aCB0byB1cGxvYWQgcGFjayBvbiByZW1vdGUgZW5kIgogbXNnc3RyICJwZXJjb3JzbyBpbiBjdWkgY2FyaWNhcmUgaWwgcGFjayBzdWwgcmVtb3RvIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTMwCisjOiBidWlsdGluL2ZldGNoLmM6MTQ1CiBtc2dpZCAiZm9yY2Ugb3ZlcndyaXRlIG9mIGxvY2FsIHJlZmVyZW5jZSIKIG1zZ3N0ciAiZm9yemEgbGEgc292cmFzY3JpdHR1cmEgZGVsIHJpZmVyaW1lbnRvIGxvY2FsZSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjEzMgorIzogYnVpbHRpbi9mZXRjaC5jOjE0NwogbXNnaWQgImZldGNoIGZyb20gbXVsdGlwbGUgcmVtb3RlcyIKIG1zZ3N0ciAiZXNlZ3VpIGlsIGZldGNoIGRhIHBpw7kgcmVtb3RpIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTM0IGJ1aWx0aW4vcHVsbC5jOjIxMworIzogYnVpbHRpbi9mZXRjaC5jOjE0OSBidWlsdGluL3B1bGwuYzoyMTQKIG1zZ2lkICJmZXRjaCBhbGwgdGFncyBhbmQgYXNzb2NpYXRlZCBvYmplY3RzIgogbXNnc3RyICJlc2VndWkgaWwgZmV0Y2ggZGkgdHV0dGkgaSB0YWcgZSBkZWdsaSBvZ2dldHRpIGFzc29jaWF0aSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjEzNgorIzogYnVpbHRpbi9mZXRjaC5jOjE1MQogbXNnaWQgImRvIG5vdCBmZXRjaCBhbGwgdGFncyAoLS1uby10YWdzKSIKIG1zZ3N0ciAibm9uIGVzZWd1aXJlIGlsIGZldGNoIGRpIGFsY3VuIHRhZyAoLS1uby10YWdzKSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjEzOAorIzogYnVpbHRpbi9mZXRjaC5jOjE1MwogbXNnaWQgIm51bWJlciBvZiBzdWJtb2R1bGVzIGZldGNoZWQgaW4gcGFyYWxsZWwiCiBtc2dzdHIgIm51bWVybyBkaSBzb3R0b21vZHVsaSByZWN1cGVyYXRpIGluIHBhcmFsbGVsbyIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE0MCBidWlsdGluL3B1bGwuYzoyMTYKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNTUgYnVpbHRpbi9wdWxsLmM6MjE3CiBtc2dpZCAicHJ1bmUgcmVtb3RlLXRyYWNraW5nIGJyYW5jaGVzIG5vIGxvbmdlciBvbiByZW1vdGUiCiBtc2dzdHIgIiIKICJlbGltaW5hIGkgYnJhbmNoIGNoZSBuZSB0cmFjY2lhbm8gdW5vIHJlbW90byBtYSBub24gcGnDuSBwcmVzZW50aSBzdWwgcmVtb3RvIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTQyCisjOiBidWlsdGluL2ZldGNoLmM6MTU3CiBtc2dpZCAicHJ1bmUgbG9jYWwgdGFncyBubyBsb25nZXIgb24gcmVtb3RlIGFuZCBjbG9iYmVyIGNoYW5nZWQgdGFncyIKIG1zZ3N0ciAiIgogImVsaW1pbmEgaSB0YWcgbG9jYWxpIG5vbiBwacO5IHByZXNlbnRpIHN1bCByZW1vdG8gZSBzb3ZyYXNjcml2aSBpIHRhZyAiCiAibW9kaWZpY2F0aSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE0MyBidWlsdGluL2ZldGNoLmM6MTY2IGJ1aWx0aW4vcHVsbC5jOjE0MAorIzogYnVpbHRpbi9mZXRjaC5jOjE1OCBidWlsdGluL2ZldGNoLmM6MTgxIGJ1aWx0aW4vcHVsbC5jOjE0MQogbXNnaWQgIm9uLWRlbWFuZCIKIG1zZ3N0ciAiYSByaWNoaWVzdGEiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNDQKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNTkKIG1zZ2lkICJjb250cm9sIHJlY3Vyc2l2ZSBmZXRjaGluZyBvZiBzdWJtb2R1bGVzIgogbXNnc3RyICJjb250cm9sbGEgaWwgcmVjdXBlcm8gcmljb3JzaXZvIGRlaSBzb3R0b21vZHVsaSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE0OCBidWlsdGluL3B1bGwuYzoyMjQKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNjMgYnVpbHRpbi9wdWxsLmM6MjI1CiBtc2dpZCAia2VlcCBkb3dubG9hZGVkIHBhY2siCiBtc2dzdHIgIm1hbnRpZW5pIGlsIHBhY2sgc2NhcmljYXRvIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTUwCisjOiBidWlsdGluL2ZldGNoLmM6MTY1CiBtc2dpZCAiYWxsb3cgdXBkYXRpbmcgb2YgSEVBRCByZWYiCiBtc2dzdHIgImNvbnNlbnRpIGwnYWdnaW9ybmFtZW50byBkZWwgcmlmZXJpbWVudG8gSEVBRCIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE1MyBidWlsdGluL2ZldGNoLmM6MTU5IGJ1aWx0aW4vcHVsbC5jOjIyNworIzogYnVpbHRpbi9mZXRjaC5jOjE2OCBidWlsdGluL2ZldGNoLmM6MTc0IGJ1aWx0aW4vcHVsbC5jOjIyOAogbXNnaWQgImRlZXBlbiBoaXN0b3J5IG9mIHNoYWxsb3cgY2xvbmUiCiBtc2dzdHIgImF1bWVudGEgbGEgcHJvZm9uZGl0w6AgZGVsbGEgY3Jvbm9sb2dpYSBkaSB1biBjbG9uZSBzaGFsbG93IgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTU1CisjOiBidWlsdGluL2ZldGNoLmM6MTcwCiBtc2dpZCAiZGVlcGVuIGhpc3Rvcnkgb2Ygc2hhbGxvdyByZXBvc2l0b3J5IGJhc2VkIG9uIHRpbWUiCiBtc2dzdHIgIiIKICJhdW1lbnRhIGxhIHByb2ZvbmRpdMOgIGRlbGxhIGNyb25vbG9naWEgZGkgdW4gY2xvbmUgc2hhbGxvdyBpbiBiYXNlIGFsIHRlbXBvIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTYxIGJ1aWx0aW4vcHVsbC5jOjIzMAorIzogYnVpbHRpbi9mZXRjaC5jOjE3NiBidWlsdGluL3B1bGwuYzoyMzEKIG1zZ2lkICJjb252ZXJ0IHRvIGEgY29tcGxldGUgcmVwb3NpdG9yeSIKIG1zZ3N0ciAiY29udmVydGkgaW4gdW4gcmVwb3NpdG9yeSBjb21wbGV0byIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE2NAorIzogYnVpbHRpbi9mZXRjaC5jOjE3OQogbXNnaWQgInByZXBlbmQgdGhpcyB0byBzdWJtb2R1bGUgcGF0aCBvdXRwdXQiCiBtc2dzdHIgImFudGVwb25pIHF1ZXN0byBwcmVmaXNzbyBhbGwnb3V0cHV0IGRlbCBwZXJjb3JzbyBkZWwgc290dG9tb2R1bG8iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNjcKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxODIKIG1zZ2lkICIiCiAiZGVmYXVsdCBmb3IgcmVjdXJzaXZlIGZldGNoaW5nIG9mIHN1Ym1vZHVsZXMgKGxvd2VyIHByaW9yaXR5IHRoYW4gY29uZmlnICIKICJmaWxlcykiCkBAIC0xMjk4Nyw5MCArMTMwNTIsOTAgQEAKICJpbXBvc3RhemlvbmUgcHJlZGVmaW5pdGEgcGVyIGlsIHJlY3VwZXJvIHJpY29yc2l2byBkZWkgc290dG9tb2R1bGkgKGEgIgogInByaW9yaXTDoCBtaW5vcmUgcmlzcGV0dG8gYWkgZmlsZSBkaSBjb25maWd1cmF6aW9uZSkiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNzEgYnVpbHRpbi9wdWxsLmM6MjMzCisjOiBidWlsdGluL2ZldGNoLmM6MTg2IGJ1aWx0aW4vcHVsbC5jOjIzNAogbXNnaWQgImFjY2VwdCByZWZzIHRoYXQgdXBkYXRlIC5naXQvc2hhbGxvdyIKIG1zZ3N0ciAiYWNjZXR0YSBpIHJpZmVyaW1lbnRpIGNoZSBhZ2dpb3JuYW5vIC5naXQvc2hhbGxvdyIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE3MiBidWlsdGluL3B1bGwuYzoyMzUKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxODcgYnVpbHRpbi9wdWxsLmM6MjM2CiBtc2dpZCAicmVmbWFwIgogbXNnc3RyICJtYXBwYSByaWZlcmltZW50aSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE3MyBidWlsdGluL3B1bGwuYzoyMzYKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxODggYnVpbHRpbi9wdWxsLmM6MjM3CiBtc2dpZCAic3BlY2lmeSBmZXRjaCByZWZtYXAiCiBtc2dzdHIgInNwZWNpZmljYSBsYSBtYXBwYSBkZWkgcmlmZXJpbWVudGkgcGVyIGlsIGZldGNoIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTgwCisjOiBidWlsdGluL2ZldGNoLmM6MTk1CiBtc2dpZCAicmVwb3J0IHRoYXQgd2UgaGF2ZSBvbmx5IG9iamVjdHMgcmVhY2hhYmxlIGZyb20gdGhpcyBvYmplY3QiCiBtc2dzdHIgInNlZ25hbGEgY2hlIGFiYmlhbW8gc29sbyBvZ2dldHRpIHJhZ2dpdW5naWJpbGkgZGEgcXVlc3Qnb2dnZXR0byIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE4MworIzogYnVpbHRpbi9mZXRjaC5jOjE5OAogbXNnaWQgInJ1biAnZ2MgLS1hdXRvJyBhZnRlciBmZXRjaGluZyIKIG1zZ3N0ciAiZXNlZ3VpICdnYyAtLWF1dG8nIGRvcG8gaWwgZmV0Y2giCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxODUgYnVpbHRpbi9wdWxsLmM6MjQ1CisjOiBidWlsdGluL2ZldGNoLmM6MjAwIGJ1aWx0aW4vcHVsbC5jOjI0NgogbXNnaWQgImNoZWNrIGZvciBmb3JjZWQtdXBkYXRlcyBvbiBhbGwgdXBkYXRlZCBicmFuY2hlcyIKIG1zZ3N0ciAiY29udHJvbGxhIGFnZ2lvcm5hbWVudGkgZm9yemF0aSBzdSB0dXR0aSBpIGJyYW5jaCBhZ2dpb3JuYXRpIgogCi0jOiBidWlsdGluL2ZldGNoLmM6NDkxCisjOiBidWlsdGluL2ZldGNoLmM6NTEwCiBtc2dpZCAiQ291bGRuJ3QgZmluZCByZW1vdGUgcmVmIEhFQUQiCiBtc2dzdHIgIkltcG9zc2liaWxlIHRyb3ZhcmUgbCdIRUFEIGRlbCByaWZlcmltZW50byByZW1vdG8iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzo2MzAKKyM6IGJ1aWx0aW4vZmV0Y2guYzo2NTAKICMsIGMtZm9ybWF0CiBtc2dpZCAiY29uZmlndXJhdGlvbiBmZXRjaC5vdXRwdXQgY29udGFpbnMgaW52YWxpZCB2YWx1ZSAlcyIKIG1zZ3N0ciAiaWwgdmFsb3JlIGRlbGwnb3B6aW9uZSBmZXRjaC5vdXRwdXQgY29udGllbmUgaWwgdmFsb3JlIG5vbiB2YWxpZG8gJXMiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzo3MjgKKyM6IGJ1aWx0aW4vZmV0Y2guYzo3NDgKICMsIGMtZm9ybWF0CiBtc2dpZCAib2JqZWN0ICVzIG5vdCBmb3VuZCIKIG1zZ3N0ciAib2dnZXR0byAlcyBub24gdHJvdmF0byIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjczMgorIzogYnVpbHRpbi9mZXRjaC5jOjc1MgogbXNnaWQgIlt1cCB0byBkYXRlXSIKIG1zZ3N0ciAiW2FnZ2lvcm5hdG9dIgogCi0jOiBidWlsdGluL2ZldGNoLmM6NzQ1IGJ1aWx0aW4vZmV0Y2guYzo3NjEgYnVpbHRpbi9mZXRjaC5jOjgzMworIzogYnVpbHRpbi9mZXRjaC5jOjc2NSBidWlsdGluL2ZldGNoLmM6NzgxIGJ1aWx0aW4vZmV0Y2guYzo4NTMKIG1zZ2lkICJbcmVqZWN0ZWRdIgogbXNnc3RyICJbcmlmaXV0YXRvXSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjc0NgorIzogYnVpbHRpbi9mZXRjaC5jOjc2NgogbXNnaWQgImNhbid0IGZldGNoIGluIGN1cnJlbnQgYnJhbmNoIgogbXNnc3RyICJpbXBvc3NpYmlsZSBlc2VndWlyZSBpbCBmZXRjaCBuZWwgYnJhbmNoIGNvcnJlbnRlIgogCi0jOiBidWlsdGluL2ZldGNoLmM6NzU2CisjOiBidWlsdGluL2ZldGNoLmM6Nzc2CiBtc2dpZCAiW3RhZyB1cGRhdGVdIgogbXNnc3RyICJbdGFnIGFnZ2lvcm5hdG9dIgogCi0jOiBidWlsdGluL2ZldGNoLmM6NzU3IGJ1aWx0aW4vZmV0Y2guYzo3OTQgYnVpbHRpbi9mZXRjaC5jOjgxNgotIzogYnVpbHRpbi9mZXRjaC5jOjgyOAorIzogYnVpbHRpbi9mZXRjaC5jOjc3NyBidWlsdGluL2ZldGNoLmM6ODE0IGJ1aWx0aW4vZmV0Y2guYzo4MzYKKyM6IGJ1aWx0aW4vZmV0Y2guYzo4NDgKIG1zZ2lkICJ1bmFibGUgdG8gdXBkYXRlIGxvY2FsIHJlZiIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgYWdnaW9ybmFyZSBpbCByaWZlcmltZW50byBsb2NhbGUiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzo3NjEKKyM6IGJ1aWx0aW4vZmV0Y2guYzo3ODEKIG1zZ2lkICJ3b3VsZCBjbG9iYmVyIGV4aXN0aW5nIHRhZyIKIG1zZ3N0ciAic292cmFzY3JpdmVyZWJiZSBpbCB0YWcgZXNpc3RlbnRlIgogCi0jOiBidWlsdGluL2ZldGNoLmM6NzgzCisjOiBidWlsdGluL2ZldGNoLmM6ODAzCiBtc2dpZCAiW25ldyB0YWddIgogbXNnc3RyICJbbnVvdm8gdGFnXSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjc4NgorIzogYnVpbHRpbi9mZXRjaC5jOjgwNgogbXNnaWQgIltuZXcgYnJhbmNoXSIKIG1zZ3N0ciAiW251b3ZvIGJyYW5jaF0iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzo3ODkKKyM6IGJ1aWx0aW4vZmV0Y2guYzo4MDkKIG1zZ2lkICJbbmV3IHJlZl0iCiBtc2dzdHIgIltudW92byByaWZlcmltZW50b10iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzo4MjgKKyM6IGJ1aWx0aW4vZmV0Y2guYzo4NDgKIG1zZ2lkICJmb3JjZWQgdXBkYXRlIgogbXNnc3RyICJhZ2dpb3JuYW1lbnRvIGZvcnphdG8iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzo4MzMKKyM6IGJ1aWx0aW4vZmV0Y2guYzo4NTMKIG1zZ2lkICJub24tZmFzdC1mb3J3YXJkIgogbXNnc3RyICJub24gZmFzdCBmb3J3YXJkIgogCi0jOiBidWlsdGluL2ZldGNoLmM6ODU0CisjOiBidWlsdGluL2ZldGNoLmM6ODc0CiBtc2dpZCAiIgogIkZldGNoIG5vcm1hbGx5IGluZGljYXRlcyB3aGljaCBicmFuY2hlcyBoYWQgYSBmb3JjZWQgdXBkYXRlLFxuIgogImJ1dCB0aGF0IGNoZWNrIGhhcyBiZWVuIGRpc2FibGVkLiBUbyByZS1lbmFibGUsIHVzZSAnLS1zaG93LWZvcmNlZC11cGRhdGVzJ1xuIgpAQCAtMTMwODEsNyArMTMxNDYsNyBAQAogInJpYWJpbGl0YXJsbywgdXNhIGwnb3B6aW9uZSAnLS1zaG93LWZvcmNlZC11cGRhdGVzJyBvIGVzZWd1aSAnZ2l0IGNvbmZpZ1xuIgogImZldGNoLnNob3dGb3JjZWRVcGRhdGVzIHRydWUnLiIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjg1OAorIzogYnVpbHRpbi9mZXRjaC5jOjg3OAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiSXQgdG9vayAlLjJmIHNlY29uZHMgdG8gY2hlY2sgZm9yY2VkIHVwZGF0ZXMuIFlvdSBjYW4gdXNlXG4iCkBAIC0xMzA5MywyMiArMTMxNTgsMjIgQEAKICJhZ2dpb3JuYW1lbnRpIGZvcnphdGkuIFB1b2kgdXNhcmUgJy0tbm8tc2hvdy1mb3JjZWQtdXBkYXRlcycgbyBlc2VndWlyZVxuIgogIidnaXQgY29uZmlnIGZldGNoLnNob3dGb3JjZWRVcGRhdGVzIGZhbHNlJyBwZXIgb21ldHRlcmUgcXVlc3RvIGNvbnRyb2xsby5cbiIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjg4OAorIzogYnVpbHRpbi9mZXRjaC5jOjkwOAogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyBkaWQgbm90IHNlbmQgYWxsIG5lY2Vzc2FyeSBvYmplY3RzXG4iCiBtc2dzdHIgIiVzIG5vbiBoYSBpbnZpYXRvIHR1dHRpIGdsaSBvZ2dldHRpIG5lY2Vzc2FyaVxuIgogCi0jOiBidWlsdGluL2ZldGNoLmM6OTA5CisjOiBidWlsdGluL2ZldGNoLmM6OTI5CiAjLCBjLWZvcm1hdAogbXNnaWQgInJlamVjdCAlcyBiZWNhdXNlIHNoYWxsb3cgcm9vdHMgYXJlIG5vdCBhbGxvd2VkIHRvIGJlIHVwZGF0ZWQiCiBtc2dzdHIgIiVzIHJpZml1dGF0byBwZXJjaMOpIG5vbiDDqCBjb25zZW50aXRvIGFnZ2lvcm5hcmUgcmFkaWNpIHNoYWxsb3ciCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxMDAwIGJ1aWx0aW4vZmV0Y2guYzoxMTMxCisjOiBidWlsdGluL2ZldGNoLmM6MTAyMCBidWlsdGluL2ZldGNoLmM6MTE1NwogIywgYy1mb3JtYXQKIG1zZ2lkICJGcm9tICUuKnNcbiIKIG1zZ3N0ciAiRGEgJS4qc1xuIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTAxMQorIzogYnVpbHRpbi9mZXRjaC5jOjEwMzEKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogInNvbWUgbG9jYWwgcmVmcyBjb3VsZCBub3QgYmUgdXBkYXRlZDsgdHJ5IHJ1bm5pbmdcbiIKQEAgLTEzMTE4LDYwICsxMzE4Myw4MSBAQAogImVzZWd1aXJlXG4iCiAiICdnaXQgcmVtb3RlIHBydW5lICVzJyBwZXIgcmltdW92ZXJlIG9nbmkgYnJhbmNoIHZlY2NoaW8gaW4gY29uZmxpdHRvIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTEwMQorIzogYnVpbHRpbi9mZXRjaC5jOjExMjcKICMsIGMtZm9ybWF0CiBtc2dpZCAiICAgKCVzIHdpbGwgYmVjb21lIGRhbmdsaW5nKSIKIG1zZ3N0ciAiICAgKCVzIGRpdmVudGVyw6AgcGVuZGVudGUpIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTEwMgorIzogYnVpbHRpbi9mZXRjaC5jOjExMjgKICMsIGMtZm9ybWF0CiBtc2dpZCAiICAgKCVzIGhhcyBiZWNvbWUgZGFuZ2xpbmcpIgogbXNnc3RyICIgICAoJXMgw6ggZGl2ZW50YXRvIHBlbmRlbnRlKSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjExMzQKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxMTYwCiBtc2dpZCAiW2RlbGV0ZWRdIgogbXNnc3RyICJbZWxpbWluYXRvXSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjExMzUgYnVpbHRpbi9yZW1vdGUuYzoxMDM2CisjOiBidWlsdGluL2ZldGNoLmM6MTE2MSBidWlsdGluL3JlbW90ZS5jOjEwMzYKIG1zZ2lkICIobm9uZSkiCiBtc2dzdHIgIihuZXNzdW5vKSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjExNTgKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxMTg0CiAjLCBjLWZvcm1hdAogbXNnaWQgIlJlZnVzaW5nIHRvIGZldGNoIGludG8gY3VycmVudCBicmFuY2ggJXMgb2Ygbm9uLWJhcmUgcmVwb3NpdG9yeSIKIG1zZ3N0ciAiIgogIk1pIHJpZml1dG8gZGkgZXNlZ3VpcmUgaWwgZmV0Y2ggbmVsIGJyYW5jaCBjb3JyZW50ZSAlcyBkaSB1biByZXBvc2l0b3J5IG5vbiAiCiAiYmFyZSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjExNzcKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxMjAzCiAjLCBjLWZvcm1hdAogbXNnaWQgIk9wdGlvbiBcIiVzXCIgdmFsdWUgXCIlc1wiIGlzIG5vdCB2YWxpZCBmb3IgJXMiCiBtc2dzdHIgIkwnb3B6aW9uZSBcIiVzXCIgY29uIGlsIHZhbG9yZSBcIiVzXCIgbm9uIMOoIHZhbGlkYSBwZXIgJXMiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxMTgwCisjOiBidWlsdGluL2ZldGNoLmM6MTIwNgogIywgYy1mb3JtYXQKIG1zZ2lkICJPcHRpb24gXCIlc1wiIGlzIGlnbm9yZWQgZm9yICVzXG4iCiBtc2dzdHIgIkwnb3B6aW9uZSBcIiVzXCIgw6ggaWdub3JhdGEgcGVyICVzXG4iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNDg0CisjOiBidWlsdGluL2ZldGNoLmM6MTQxNAorbXNnaWQgIm11bHRpcGxlIGJyYW5jaCBkZXRlY3RlZCwgaW5jb21wYXRpYmxlIHdpdGggLS1zZXQtdXBzdHJlYW0iCittc2dzdHIgInJpbGV2YXRpIGJyYW5jaCBtdWx0aXBsaSwgc3RhdG8gaW5jb21wYXRpYmlsZSBjb24gLS1zZXQtdXBzdHJlYW0iCisKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNDI5Cittc2dpZCAibm90IHNldHRpbmcgdXBzdHJlYW0gZm9yIGEgcmVtb3RlIHJlbW90ZS10cmFja2luZyBicmFuY2giCittc2dzdHIgIm5vbiBpbXBvc3RvIGwndXBzdHJlYW0gcGVyIHVuIGJyYW5jaCByZW1vdG8gY2hlIG5lIHRyYWNjaWEgdW5vIHJlbW90byIKKworIzogYnVpbHRpbi9mZXRjaC5jOjE0MzEKK21zZ2lkICJub3Qgc2V0dGluZyB1cHN0cmVhbSBmb3IgYSByZW1vdGUgdGFnIgorbXNnc3RyICJub24gaW1wb3N0byBsJ3Vwc3RyZWFtIHBlciB1biB0YWcgcmVtb3RvIgorCisjOiBidWlsdGluL2ZldGNoLmM6MTQzMworbXNnaWQgInVua25vd24gYnJhbmNoIHR5cGUiCittc2dzdHIgInRpcG8gYnJhbmNoIHNjb25vc2NpdXRvIgorCisjOiBidWlsdGluL2ZldGNoLmM6MTQzNQorbXNnaWQgIiIKKyJubyBzb3VyY2UgYnJhbmNoIGZvdW5kLlxuIgorInlvdSBuZWVkIHRvIHNwZWNpZnkgZXhhY3RseSBvbmUgYnJhbmNoIHdpdGggdGhlIC0tc2V0LXVwc3RyZWFtIG9wdGlvbi4iCittc2dzdHIgIiIKKyJuZXNzdW4gYnJhbmNoIHNvcmdlbnRlIHRyb3ZhdG8uXG4iCisiZGV2aSBzcGVjaWZpY2FyZSBlc2F0dGFtZW50ZSB1biBicmFuY2ggY29uIGwnb3B6aW9uZSAtLXNldC11cHN0cmVhbS4iCisKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNTYxIGJ1aWx0aW4vZmV0Y2guYzoxNjIzCiAjLCBjLWZvcm1hdAogbXNnaWQgIkZldGNoaW5nICVzXG4iCiBtc2dzdHIgIlJlY3VwZXJvIGRpICVzIGluIGNvcnNvXG4iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNDg2IGJ1aWx0aW4vcmVtb3RlLmM6MTAwCisjOiBidWlsdGluL2ZldGNoLmM6MTU3MSBidWlsdGluL2ZldGNoLmM6MTYyNSBidWlsdGluL3JlbW90ZS5jOjEwMAogIywgYy1mb3JtYXQKIG1zZ2lkICJDb3VsZCBub3QgZmV0Y2ggJXMiCiBtc2dzdHIgIkltcG9zc2liaWxlIHJlY3VwZXJhcmUgJXMiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNTMyCi1tc2dpZCAiIgotIi0tZmlsdGVyIGNhbiBvbmx5IGJlIHVzZWQgd2l0aCB0aGUgcmVtb3RlIGNvbmZpZ3VyZWQgaW4gZXh0ZW5zaW9ucy4iCi0icGFydGlhbENsb25lIgotbXNnc3RyICIiCi0iLS1maWx0ZXIgcHXDsiBlc3NlcmUgdXNhdG8gc29sbyBjb24gaWwgcmVtb3RvIGNvbmZpZ3VyYXRvIG5lbGxlIGVzdGVuc2lvbmkuIgotInBhcnRpYWxDbG9uZSIKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNTgzCisjLCBjLWZvcm1hdAorbXNnaWQgImNvdWxkIG5vdCBmZXRjaCAnJXMnIChleGl0IGNvZGU6ICVkKVxuIgorbXNnc3RyICJpbXBvc3NpYmlsZSByZWN1cGVyYXJlICclcycgKGNvZGljZSBkaSB1c2NpdGE6ICVkKVxuIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTU1NgorIzogYnVpbHRpbi9mZXRjaC5jOjE2ODUKIG1zZ2lkICIiCiAiTm8gcmVtb3RlIHJlcG9zaXRvcnkgc3BlY2lmaWVkLiAgUGxlYXNlLCBzcGVjaWZ5IGVpdGhlciBhIFVSTCBvciBhXG4iCiAicmVtb3RlIG5hbWUgZnJvbSB3aGljaCBuZXcgcmV2aXNpb25zIHNob3VsZCBiZSBmZXRjaGVkLiIKQEAgLTEzMTc5LDQ1ICsxMzI2NSw0NSBAQAogIk5vbiDDqCBzdGF0byBzcGVjaWZpY2F0byBhbGN1biByZXBvc2l0b3J5IHJlbW90by4gU3BlY2lmaWNhIHVuIFVSTCBvIGlsXG4iCiAibm9tZSBkaSB1biByZW1vdG8gZGEgY3VpIGRvdnJhbm5vIGVzc2VyZSByZWN1cGVyYXRlIGxlIG51b3ZlIHJldmlzaW9uaS4iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNTkzCisjOiBidWlsdGluL2ZldGNoLmM6MTcyMgogbXNnaWQgIllvdSBuZWVkIHRvIHNwZWNpZnkgYSB0YWcgbmFtZS4iCiBtc2dzdHIgIkRldmkgc3BlY2lmaWNhcmUgaWwgbm9tZSBkaSB1biB0YWcuIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTY0NAorIzogYnVpbHRpbi9mZXRjaC5jOjE3NzQKIG1zZ2lkICJOZWdhdGl2ZSBkZXB0aCBpbiAtLWRlZXBlbiBpcyBub3Qgc3VwcG9ydGVkIgogbXNnc3RyICJMZSBwcm9mb25kaXTDoCBuZWdhdGl2ZSBpbiAtLWRlZXBlbiBub24gc29ubyBzdXBwb3J0YXRlIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTY0NgorIzogYnVpbHRpbi9mZXRjaC5jOjE3NzYKIG1zZ2lkICItLWRlZXBlbiBhbmQgLS1kZXB0aCBhcmUgbXV0dWFsbHkgZXhjbHVzaXZlIgogbXNnc3RyICJsZSBvcHppb25pIC0tZGVlcGVuIGUgLS1kZXB0aCBzb25vIG11dHVhbG1lbnRlIGVzY2x1c2l2ZSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE2NTEKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNzgxCiBtc2dpZCAiLS1kZXB0aCBhbmQgLS11bnNoYWxsb3cgY2Fubm90IGJlIHVzZWQgdG9nZXRoZXIiCiBtc2dzdHIgIi0tZGVwdGggZSAtLXVuc2hhbGxvdyBub24gcG9zc29ubyBlc3NlcmUgdXNhdGkgaW5zaWVtZS4iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNjUzCisjOiBidWlsdGluL2ZldGNoLmM6MTc4MwogbXNnaWQgIi0tdW5zaGFsbG93IG9uIGEgY29tcGxldGUgcmVwb3NpdG9yeSBkb2VzIG5vdCBtYWtlIHNlbnNlIgogbXNnc3RyICItLXVuc2hhbGxvdyBzdSB1biByZXBvc2l0b3J5IGNvbXBsZXRvIG5vbiBoYSBzZW5zbyIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE2NjkKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNzk5CiBtc2dpZCAiZmV0Y2ggLS1hbGwgZG9lcyBub3QgdGFrZSBhIHJlcG9zaXRvcnkgYXJndW1lbnQiCiBtc2dzdHIgImZldGNoIC0tYWxsIG5vbiByaWNoaWVkZSB1biByZXBvc2l0b3J5IGNvbWUgYXJnb21lbnRvIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTY3MQorIzogYnVpbHRpbi9mZXRjaC5jOjE4MDEKIG1zZ2lkICJmZXRjaCAtLWFsbCBkb2VzIG5vdCBtYWtlIHNlbnNlIHdpdGggcmVmc3BlY3MiCiBtc2dzdHIgImZldGNoIC0tYWxsIG5vbiBoYSBzZW5zbyBjb24gZGVnbGkgc3BlY2lmaWNhdG9yaSByaWZlcmltZW50byIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE2ODAKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxODEwCiAjLCBjLWZvcm1hdAogbXNnaWQgIk5vIHN1Y2ggcmVtb3RlIG9yIHJlbW90ZSBncm91cDogJXMiCiBtc2dzdHIgIlJlbW90byBvIGdydXBwbyByZW1vdGkgbm9uIGVzaXN0ZW50ZTogJXMiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNjg3CisjOiBidWlsdGluL2ZldGNoLmM6MTgxNwogbXNnaWQgIkZldGNoaW5nIGEgZ3JvdXAgYW5kIHNwZWNpZnlpbmcgcmVmc3BlY3MgZG9lcyBub3QgbWFrZSBzZW5zZSIKIG1zZ3N0ciAiIgogIlJlY3VwZXJhcmUgdW4gZ3J1cHBvIGUgc3BlY2lmaWNhcmUgZ2xpIHNwZWNpZmljYXRvcmkgcmlmZXJpbWVudG8gbm9uIGhhIHNlbnNvIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTcwMworIzogYnVpbHRpbi9mZXRjaC5jOjE4MzUKIG1zZ2lkICIiCiAiLS1maWx0ZXIgY2FuIG9ubHkgYmUgdXNlZCB3aXRoIHRoZSByZW1vdGUgY29uZmlndXJlZCBpbiBleHRlbnNpb25zLiIKICJwYXJ0aWFsY2xvbmUiCkBAIC0xMzU1Nyw3ICsxMzY0Myw3IEBACiBtc2dpZCAiaW52YWxpZCBwYXJhbWV0ZXI6IGV4cGVjdGVkIHNoYTEsIGdvdCAnJXMnIgogbXNnc3RyICJwYXJhbWV0cm8gbm9uIHZhbGlkbzogYXR0ZXNvIFNIQTEsIHByZXNlbnRlICclcyciCiAKLSM6IGJ1aWx0aW4vZ2MuYzozNAorIzogYnVpbHRpbi9nYy5jOjM1CiBtc2dpZCAiZ2l0IGdjIFs8b3B0aW9ucz5dIgogbXNnc3RyICJnaXQgZ2MgWzxvcHppb25pPl0iCiAKQEAgLTEzNTcxLDE3ICsxMzY1NywxNyBAQAogbXNnaWQgImZhaWxlZCB0byBwYXJzZSAnJXMnIHZhbHVlICclcyciCiBtc2dzdHIgImFuYWxpc2kgZGVsbCdvcHppb25lICclcycgY29uIHZhbG9yZSAnJXMnIG5vbiByaXVzY2l0YSIKIAotIzogYnVpbHRpbi9nYy5jOjQ3NiBidWlsdGluL2luaXQtZGIuYzo1NQorIzogYnVpbHRpbi9nYy5jOjQ3NSBidWlsdGluL2luaXQtZGIuYzo1NQogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3Qgc3RhdCAnJXMnIgogbXNnc3RyICJpbXBvc3NpYmlsZSBlc2VndWlyZSBsbyBzdGF0IGRpICclcyciCiAKLSM6IGJ1aWx0aW4vZ2MuYzo0ODUgYnVpbHRpbi9ub3Rlcy5jOjI0MCBidWlsdGluL3RhZy5jOjUyOQorIzogYnVpbHRpbi9nYy5jOjQ4NCBidWlsdGluL25vdGVzLmM6MjQwIGJ1aWx0aW4vdGFnLmM6NTI5CiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCByZWFkICclcyciCiBtc2dzdHIgImltcG9zc2liaWxlIGxlZ2dlcmUgJyVzJyIKIAotIzogYnVpbHRpbi9nYy5jOjQ5MgorIzogYnVpbHRpbi9nYy5jOjQ5MQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiVGhlIGxhc3QgZ2MgcnVuIHJlcG9ydGVkIHRoZSBmb2xsb3dpbmcuIFBsZWFzZSBjb3JyZWN0IHRoZSByb290IGNhdXNlXG4iCkBAIC0xMzU5Nyw1NiArMTM2ODMsNTYgQEAKICJcbiIKICIlcyIKIAotIzogYnVpbHRpbi9nYy5jOjU0MAorIzogYnVpbHRpbi9nYy5jOjUzOQogbXNnaWQgInBydW5lIHVucmVmZXJlbmNlZCBvYmplY3RzIgogbXNnc3RyICJlbGltaW5hIG9nZ2V0dGkgbm9uIHJlZmVyZW56aWF0aSIKIAotIzogYnVpbHRpbi9nYy5jOjU0MgorIzogYnVpbHRpbi9nYy5jOjU0MQogbXNnaWQgImJlIG1vcmUgdGhvcm91Z2ggKGluY3JlYXNlZCBydW50aW1lKSIKIG1zZ3N0ciAic2lpIHBpw7kgYWNjdXJhdG8gKHRlbXBpIGRpIGVzZWN1emlvbmUgbWFnZ2lvcmkpIgogCi0jOiBidWlsdGluL2djLmM6NTQzCisjOiBidWlsdGluL2djLmM6NTQyCiBtc2dpZCAiZW5hYmxlIGF1dG8tZ2MgbW9kZSIKIG1zZ3N0ciAiYWJpbGl0YSBtb2RhbGl0w6AgZ2FyYmFnZSBjb2xsZWN0b3IgYXV0b21hdGljYSIKIAotIzogYnVpbHRpbi9nYy5jOjU0NgorIzogYnVpbHRpbi9nYy5jOjU0NQogbXNnaWQgImZvcmNlIHJ1bm5pbmcgZ2MgZXZlbiBpZiB0aGVyZSBtYXkgYmUgYW5vdGhlciBnYyBydW5uaW5nIgogbXNnc3RyICIiCiAiZm9yemEgbCdlc2VjdXppb25lIGRlbCBnYXJiYWdlIGNvbGxlY3RvciBhbmNoZSBuZWwgY2FzbyBpbiBjdWkgdmUgbmUgIgogInBvdHJlYmJlIGVzc2VyZSB1biBhbHRybyBpbiBlc2VjdXppb25lIgogCi0jOiBidWlsdGluL2djLmM6NTQ5CisjOiBidWlsdGluL2djLmM6NTQ4CiBtc2dpZCAicmVwYWNrIGFsbCBvdGhlciBwYWNrcyBleGNlcHQgdGhlIGxhcmdlc3QgcGFjayIKIG1zZ3N0ciAiIgogImVzZWd1aSBpbCByZXBhY2sgZGkgdHV0dGkgZ2xpIGFsdHJpIHBhY2sgYWQgZWNjZXppb25lIGRpIHF1ZWxsbyBwacO5IGdyYW5kZSIKIAotIzogYnVpbHRpbi9nYy5jOjU2NgorIzogYnVpbHRpbi9nYy5jOjU2NQogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gcGFyc2UgZ2MubG9nZXhwaXJ5IHZhbHVlICVzIgogbXNnc3RyICJhbmFsaXNpIGRlbCB2YWxvcmUgJXMgZGkgZ2MubG9nZXhwaXJ5IG5vbiByaXVzY2l0YSIKIAotIzogYnVpbHRpbi9nYy5jOjU3NworIzogYnVpbHRpbi9nYy5jOjU3NgogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gcGFyc2UgcHJ1bmUgZXhwaXJ5IHZhbHVlICVzIgogbXNnc3RyICJhbmFsaXNpIGRlbCB2YWxvcmUgJXMgcGVyIGxhIHNjYWRlbnphIGRlbGxlIGVsaW1pbmF6aW9uaSBub24gcml1c2NpdGEiCiAKLSM6IGJ1aWx0aW4vZ2MuYzo1OTcKKyM6IGJ1aWx0aW4vZ2MuYzo1OTYKICMsIGMtZm9ybWF0CiBtc2dpZCAiQXV0byBwYWNraW5nIHRoZSByZXBvc2l0b3J5IGluIGJhY2tncm91bmQgZm9yIG9wdGltdW0gcGVyZm9ybWFuY2UuXG4iCiBtc2dzdHIgIiIKICJDb21wcmltbyBpbCByZXBvc2l0b3J5IGluIGJhY2tncm91bmQgcGVyIG90dGVuZXJlIGxlIG1pZ2xpb3JpIHByZXN0YXppb25pLlxuIgogCi0jOiBidWlsdGluL2djLmM6NTk5CisjOiBidWlsdGluL2djLmM6NTk4CiAjLCBjLWZvcm1hdAogbXNnaWQgIkF1dG8gcGFja2luZyB0aGUgcmVwb3NpdG9yeSBmb3Igb3B0aW11bSBwZXJmb3JtYW5jZS5cbiIKIG1zZ3N0ciAiQ29tcHJpbW8gaWwgcmVwb3NpdG9yeSBwZXIgb3R0ZW5lcmUgbGUgbWlnbGlvcmkgcHJlc3RhemlvbmkuXG4iCiAKLSM6IGJ1aWx0aW4vZ2MuYzo2MDAKKyM6IGJ1aWx0aW4vZ2MuYzo1OTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiU2VlIFwiZ2l0IGhlbHAgZ2NcIiBmb3IgbWFudWFsIGhvdXNla2VlcGluZy5cbiIKIG1zZ3N0ciAiVmVkaSBcImdpdCBoZWxwIGdjXCIgcGVyIGxlIG9wZXJhemlvbmkgZGkgbWFudXRlbnppb25lIG1hbnVhbGkuXG4iCiAKLSM6IGJ1aWx0aW4vZ2MuYzo2NDAKKyM6IGJ1aWx0aW4vZ2MuYzo2MzkKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogImdjIGlzIGFscmVhZHkgcnVubmluZyBvbiBtYWNoaW5lICclcycgcGlkICU8UFJJdU1BWD4gKHVzZSAtLWZvcmNlIGlmIG5vdCkiCkBAIC0xMzY1NCw3ICsxMzc0MCw3IEBACiAiZ2Mgw6ggZ2nDoCBpbiBlc2VjdXppb25lIHN1bCBjb21wdXRlciAnJXMnIGNvbiBQSUQgJTxQUkl1TUFYPiAodXNhIC0tZm9yY2Ugc2UgIgogIm5vbiBsbyDDqCkiCiAKLSM6IGJ1aWx0aW4vZ2MuYzo2OTUKKyM6IGJ1aWx0aW4vZ2MuYzo2OTQKIG1zZ2lkICIiCiAiVGhlcmUgYXJlIHRvbyBtYW55IHVucmVhY2hhYmxlIGxvb3NlIG9iamVjdHM7IHJ1biAnZ2l0IHBydW5lJyB0byByZW1vdmUgdGhlbS4iCiBtc2dzdHIgIiIKQEAgLTEzNjgxLDI2MiArMTM3NjcsMjYyIEBACiAjLiBncmVwLnRocmVhZHMKICMuCiAjOiBidWlsdGluL2dyZXAuYzoyODcgYnVpbHRpbi9pbmRleC1wYWNrLmM6MTUzNCBidWlsdGluL2luZGV4LXBhY2suYzoxNzI3Ci0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI3MjgKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjcwOAogIywgYy1mb3JtYXQKIG1zZ2lkICJubyB0aHJlYWRzIHN1cHBvcnQsIGlnbm9yaW5nICVzIgogbXNnc3RyICJub24gdmkgw6ggc3VwcG9ydG8gcGVyIGkgdGhyZWFkLCBpZ25vcm8gJXMiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjQ2NyBidWlsdGluL2dyZXAuYzo1OTEgYnVpbHRpbi9ncmVwLmM6NjMzCisjOiBidWlsdGluL2dyZXAuYzo0NjcgYnVpbHRpbi9ncmVwLmM6NTkyIGJ1aWx0aW4vZ3JlcC5jOjYzNQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gcmVhZCB0cmVlICglcykiCiBtc2dzdHIgImltcG9zc2liaWxlIGxlZ2dlcmUgaWwgdHJlZSAoJXMpIgogCi0jOiBidWlsdGluL2dyZXAuYzo2NDgKKyM6IGJ1aWx0aW4vZ3JlcC5jOjY1MAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gZ3JlcCBmcm9tIG9iamVjdCBvZiB0eXBlICVzIgogbXNnc3RyICJpbXBvc3NpYmlsZSBlc2VndWlyZSBncmVwIHN1IHVuIG9nZ2V0dG8gZGkgdGlwbyAlcyIKIAotIzogYnVpbHRpbi9ncmVwLmM6NzE0CisjOiBidWlsdGluL2dyZXAuYzo3MTYKICMsIGMtZm9ybWF0CiBtc2dpZCAic3dpdGNoIGAlYycgZXhwZWN0cyBhIG51bWVyaWNhbCB2YWx1ZSIKIG1zZ3N0ciAic3dpdGNoICclYycgcmljaGllZGUgdW4gdmFsb3JlIG51bWVyaWNvIgogCi0jOiBidWlsdGluL2dyZXAuYzo4MTMKKyM6IGJ1aWx0aW4vZ3JlcC5jOjgxNQogbXNnaWQgInNlYXJjaCBpbiBpbmRleCBpbnN0ZWFkIG9mIGluIHRoZSB3b3JrIHRyZWUiCiBtc2dzdHIgImNlcmNhIG5lbGwnaW5kZXggYW56aWNow6kgbmVsbCdhbGJlcm8gZGkgbGF2b3JvIgogCi0jOiBidWlsdGluL2dyZXAuYzo4MTUKKyM6IGJ1aWx0aW4vZ3JlcC5jOjgxNwogbXNnaWQgImZpbmQgaW4gY29udGVudHMgbm90IG1hbmFnZWQgYnkgZ2l0IgogbXNnc3RyICJsYSByaWNlcmNhIG5laSBjb250ZW51dGkgbm9uIMOoIGdlc3RpdGEgZGEgR2l0IgogCi0jOiBidWlsdGluL2dyZXAuYzo4MTcKKyM6IGJ1aWx0aW4vZ3JlcC5jOjgxOQogbXNnaWQgInNlYXJjaCBpbiBib3RoIHRyYWNrZWQgYW5kIHVudHJhY2tlZCBmaWxlcyIKIG1zZ3N0ciAiY2VyY2Egc2lhIG5laSBmaWxlIHRyYWNjaWF0aSBzaWEgaW4gcXVlbGxpIG5vbiB0cmFjY2lhdGkiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjgxOQorIzogYnVpbHRpbi9ncmVwLmM6ODIxCiBtc2dpZCAiaWdub3JlIGZpbGVzIHNwZWNpZmllZCB2aWEgJy5naXRpZ25vcmUnIgogbXNnc3RyICJpZ25vcmEgaSBmaWxlIHNwZWNpZmljYXRpIGluICcuZ2l0aWdub3JlJyIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODIxCisjOiBidWlsdGluL2dyZXAuYzo4MjMKIG1zZ2lkICJyZWN1cnNpdmVseSBzZWFyY2ggaW4gZWFjaCBzdWJtb2R1bGUiCiBtc2dzdHIgImNlcmNhIHJpY29yc2l2YW1lbnRlIGluIG9nbmkgc290dG9tb2R1bG8iCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjgyNAorIzogYnVpbHRpbi9ncmVwLmM6ODI2CiBtc2dpZCAic2hvdyBub24tbWF0Y2hpbmcgbGluZXMiCiBtc2dzdHIgInZpc3VhbGl6emEgbGUgcmlnaGUgbm9uIGNvcnJpc3BvbmRlbnRpIgogCi0jOiBidWlsdGluL2dyZXAuYzo4MjYKKyM6IGJ1aWx0aW4vZ3JlcC5jOjgyOAogbXNnaWQgImNhc2UgaW5zZW5zaXRpdmUgbWF0Y2hpbmciCiBtc2dzdHIgInJpY2VyY2EgY29ycmlzcG9uZGVuemUgc2VuemEgZGlmZmVyZW56ZSBtYWl1c2NvbGUvbWludXNjb2xlIgogCi0jOiBidWlsdGluL2dyZXAuYzo4MjgKKyM6IGJ1aWx0aW4vZ3JlcC5jOjgzMAogbXNnaWQgIm1hdGNoIHBhdHRlcm5zIG9ubHkgYXQgd29yZCBib3VuZGFyaWVzIgogbXNnc3RyICJjZXJjYSBjb3JyaXNwb25kZW56ZSBhaSBwYXR0ZXJuIHNvbG8gYSBpbml6aW8vZmluZSBwYXJvbGEiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjgzMAorIzogYnVpbHRpbi9ncmVwLmM6ODMyCiBtc2dpZCAicHJvY2VzcyBiaW5hcnkgZmlsZXMgYXMgdGV4dCIKIG1zZ3N0ciAiZWxhYm9yYSBpIGZpbGUgYmluYXJpIGNvbWUgdGVzdHVhbGkiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjgzMgorIzogYnVpbHRpbi9ncmVwLmM6ODM0CiBtc2dpZCAiZG9uJ3QgbWF0Y2ggcGF0dGVybnMgaW4gYmluYXJ5IGZpbGVzIgogbXNnc3RyICJub24gY2VyY2FyZSBjb3JyaXNwb25kZW56ZSBhaSBwYXR0ZXJuIG5laSBmaWxlIGJpbmFyaSIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODM1CisjOiBidWlsdGluL2dyZXAuYzo4MzcKIG1zZ2lkICJwcm9jZXNzIGJpbmFyeSBmaWxlcyB3aXRoIHRleHRjb252IGZpbHRlcnMiCiBtc2dzdHIgImVsYWJvcmEgaSBmaWxlIGJpbmFyaSBjb24gZmlsdHJpIGRpIGNvbnZlcnNpb25lIGluIHRlc3RvIgogCi0jOiBidWlsdGluL2dyZXAuYzo4MzcKKyM6IGJ1aWx0aW4vZ3JlcC5jOjgzOQogbXNnaWQgInNlYXJjaCBpbiBzdWJkaXJlY3RvcmllcyAoZGVmYXVsdCkiCiBtc2dzdHIgImNlcmNhIG5lbGxlIHNvdHRvZGlyZWN0b3J5IChpbXBvc3RhemlvbmUgcHJlZGVmaW5pdGEpIgogCi0jOiBidWlsdGluL2dyZXAuYzo4MzkKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg0MQogbXNnaWQgImRlc2NlbmQgYXQgbW9zdCA8ZGVwdGg+IGxldmVscyIKIG1zZ3N0ciAic2NlbmRpIGFsIHBpw7kgZGkgPHByb2ZvbmRpdMOgPiBsaXZlbGxpIgogCi0jOiBidWlsdGluL2dyZXAuYzo4NDMKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg0NQogbXNnaWQgInVzZSBleHRlbmRlZCBQT1NJWCByZWd1bGFyIGV4cHJlc3Npb25zIgogbXNnc3RyICJ1c2EgZXNwcmVzc2lvbmkgcmVnb2xhcmkgUE9TSVggZXN0ZXNlIgogCi0jOiBidWlsdGluL2dyZXAuYzo4NDYKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg0OAogbXNnaWQgInVzZSBiYXNpYyBQT1NJWCByZWd1bGFyIGV4cHJlc3Npb25zIChkZWZhdWx0KSIKIG1zZ3N0ciAidXNhIGVzcHJlc3Npb25pIHJlZ29sYXJpIFBPU0lYIGRpIGJhc2UgKGltcG9zdGF6aW9uZSBwcmVkZWZpbml0YSkiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg0OQorIzogYnVpbHRpbi9ncmVwLmM6ODUxCiBtc2dpZCAiaW50ZXJwcmV0IHBhdHRlcm5zIGFzIGZpeGVkIHN0cmluZ3MiCiBtc2dzdHIgImludGVycHJldGEgaSBwYXR0ZXJuIGNvbWUgc3RyaW5naGUgZmlzc2UiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg1MgorIzogYnVpbHRpbi9ncmVwLmM6ODU0CiBtc2dpZCAidXNlIFBlcmwtY29tcGF0aWJsZSByZWd1bGFyIGV4cHJlc3Npb25zIgogbXNnc3RyICJ1c2EgZXNwcmVzc2lvbmkgcmVnb2xhcmkgY29tcGF0aWJpbGkgY29uIFBlcmwiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg1NQorIzogYnVpbHRpbi9ncmVwLmM6ODU3CiBtc2dpZCAic2hvdyBsaW5lIG51bWJlcnMiCiBtc2dzdHIgInZpc3VhbGl6emEgbnVtZXJpIGRpIHJpZ2EiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg1NgorIzogYnVpbHRpbi9ncmVwLmM6ODU4CiBtc2dpZCAic2hvdyBjb2x1bW4gbnVtYmVyIG9mIGZpcnN0IG1hdGNoIgogbXNnc3RyICJ2aXN1YWxpenphIGlsIG51bWVybyBkaSBjb2xvbm5hIGRlbGxhIHByaW1hIGNvcnJpc3BvbmRlbnphIgogCi0jOiBidWlsdGluL2dyZXAuYzo4NTcKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg1OQogbXNnaWQgImRvbid0IHNob3cgZmlsZW5hbWVzIgogbXNnc3RyICJub24gdmlzdWFsaXp6YXJlIGkgbm9taSBmaWxlIgogCi0jOiBidWlsdGluL2dyZXAuYzo4NTgKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg2MAogbXNnaWQgInNob3cgZmlsZW5hbWVzIgogbXNnc3RyICJ2aXN1YWxpenphIGkgbm9taSBmaWxlIgogCi0jOiBidWlsdGluL2dyZXAuYzo4NjAKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg2MgogbXNnaWQgInNob3cgZmlsZW5hbWVzIHJlbGF0aXZlIHRvIHRvcCBkaXJlY3RvcnkiCiBtc2dzdHIgInZpc3VhbGl6emEgaSBub21pIGZpbGUgcmVsYXRpdmkgYWxsYSBkaXJlY3RvcnkgZGkgcHJpbW8gbGl2ZWxsbyIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODYyCisjOiBidWlsdGluL2dyZXAuYzo4NjQKIG1zZ2lkICJzaG93IG9ubHkgZmlsZW5hbWVzIGluc3RlYWQgb2YgbWF0Y2hpbmcgbGluZXMiCiBtc2dzdHIgInZpc3VhbGl6emEgc29sbyBpIG5vbWkgZmlsZSBhbnppY2jDqSBsZSByaWdoZSBjb3JyaXNwb25kZW50aSIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODY0CisjOiBidWlsdGluL2dyZXAuYzo4NjYKIG1zZ2lkICJzeW5vbnltIGZvciAtLWZpbGVzLXdpdGgtbWF0Y2hlcyIKIG1zZ3N0ciAic2lub25pbW8gZGkgLS1maWxlcy13aXRoLW1hdGNoZXMiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg2NworIzogYnVpbHRpbi9ncmVwLmM6ODY5CiBtc2dpZCAic2hvdyBvbmx5IHRoZSBuYW1lcyBvZiBmaWxlcyB3aXRob3V0IG1hdGNoIgogbXNnc3RyICJ2aXN1YWxpenphIHNvbG8gaSBub21pIGRlaSBmaWxlIG5vbiBjb3JyaXNwb25kZW50aSIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODY5CisjOiBidWlsdGluL2dyZXAuYzo4NzEKIG1zZ2lkICJwcmludCBOVUwgYWZ0ZXIgZmlsZW5hbWVzIgogbXNnc3RyICJzdGFtcGEgTlVMIGRvcG8gaSBub21pIGZpbGUiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg3MgorIzogYnVpbHRpbi9ncmVwLmM6ODc0CiBtc2dpZCAic2hvdyBvbmx5IG1hdGNoaW5nIHBhcnRzIG9mIGEgbGluZSIKIG1zZ3N0ciAidmlzdWFsaXp6YSBzb2xvIGxlIHBhcnRpIGNvcnJpc3BvbmRlbnRpIGRpIHVuYSByaWdhIgogCi0jOiBidWlsdGluL2dyZXAuYzo4NzQKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg3NgogbXNnaWQgInNob3cgdGhlIG51bWJlciBvZiBtYXRjaGVzIGluc3RlYWQgb2YgbWF0Y2hpbmcgbGluZXMiCiBtc2dzdHIgInZpc3VhbGl6emEgaWwgbnVtZXJvIGRpIGNvcnJpc3BvbmRlbnplIGFuemljaMOpIGxlIHJpZ2hlIGNvcnJpc3BvbmRlbnRpIgogCi0jOiBidWlsdGluL2dyZXAuYzo4NzUKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg3NwogbXNnaWQgImhpZ2hsaWdodCBtYXRjaGVzIgogbXNnc3RyICJldmlkZW56aWEgY29ycmlzcG9uZGVuemUiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg3NworIzogYnVpbHRpbi9ncmVwLmM6ODc5CiBtc2dpZCAicHJpbnQgZW1wdHkgbGluZSBiZXR3ZWVuIG1hdGNoZXMgZnJvbSBkaWZmZXJlbnQgZmlsZXMiCiBtc2dzdHIgInN0YW1wYSB1bmEgcmlnYSB2dW90YSBmcmEgbGUgY29ycmlzcG9uZGVuemUgaW4gZmlsZSBkaWZmZXJlbnRpIgogCi0jOiBidWlsdGluL2dyZXAuYzo4NzkKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg4MQogbXNnaWQgInNob3cgZmlsZW5hbWUgb25seSBvbmNlIGFib3ZlIG1hdGNoZXMgZnJvbSBzYW1lIGZpbGUiCiBtc2dzdHIgIiIKICJ2aXN1YWxpenphIGlsIG5vbWUgZmlsZSBzb2xvIHVuYSB2b2x0YSBwcmltYSBkZWxsZSBjb3JyaXNwb25kZW56ZSBuZWxsbyAiCiAic3Rlc3NvIGZpbGUiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg4MgorIzogYnVpbHRpbi9ncmVwLmM6ODg0CiBtc2dpZCAic2hvdyA8bj4gY29udGV4dCBsaW5lcyBiZWZvcmUgYW5kIGFmdGVyIG1hdGNoZXMiCiBtc2dzdHIgInZpc3VhbGl6emEgPG4+IHJpZ2hlIGRpIGNvbnRlc3RvIHByaW1hIGUgZG9wbyBsZSBjb3JyaXNwb25kZW56ZSIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODg1CisjOiBidWlsdGluL2dyZXAuYzo4ODcKIG1zZ2lkICJzaG93IDxuPiBjb250ZXh0IGxpbmVzIGJlZm9yZSBtYXRjaGVzIgogbXNnc3RyICJ2aXN1YWxpenphIDxuPiByaWdoZSBkaSBjb250ZXN0byBwcmltYSBkZWxsZSBjb3JyaXNwb25kZW56ZSIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODg3CisjOiBidWlsdGluL2dyZXAuYzo4ODkKIG1zZ2lkICJzaG93IDxuPiBjb250ZXh0IGxpbmVzIGFmdGVyIG1hdGNoZXMiCiBtc2dzdHIgInZpc3VhbGl6emEgPG4+IHJpZ2hlIGRpIGNvbnRlc3RvIGRvcG8gbGUgY29ycmlzcG9uZGVuemUiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg4OQorIzogYnVpbHRpbi9ncmVwLmM6ODkxCiBtc2dpZCAidXNlIDxuPiB3b3JrZXIgdGhyZWFkcyIKIG1zZ3N0ciAidXNhIDxuPiB0aHJlYWQgZGkgbGF2b3JvIgogCi0jOiBidWlsdGluL2dyZXAuYzo4OTAKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg5MgogbXNnaWQgInNob3J0Y3V0IGZvciAtQyBOVU0iCiBtc2dzdHIgInNjb3JjaWF0b2lhIHBlciAtQyBOVU0iCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg5MworIzogYnVpbHRpbi9ncmVwLmM6ODk1CiBtc2dpZCAic2hvdyBhIGxpbmUgd2l0aCB0aGUgZnVuY3Rpb24gbmFtZSBiZWZvcmUgbWF0Y2hlcyIKIG1zZ3N0ciAidmlzdWFsaXp6YSB1bmEgcmlnYSBjb24gaWwgbm9tZSBmdW56aW9uZSBwcmltYSBkZWxsZSBjb3JyaXNwb25kZW56ZSIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODk1CisjOiBidWlsdGluL2dyZXAuYzo4OTcKIG1zZ2lkICJzaG93IHRoZSBzdXJyb3VuZGluZyBmdW5jdGlvbiIKIG1zZ3N0ciAidmlzdWFsaXp6YSBsYSBmdW56aW9uZSBjaXJjb3N0YW50ZSIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODk4CisjOiBidWlsdGluL2dyZXAuYzo5MDAKIG1zZ2lkICJyZWFkIHBhdHRlcm5zIGZyb20gZmlsZSIKIG1zZ3N0ciAibGVnZ2kgbGUgY29ycmlzcG9uZGVuemUgZGEgdW4gZmlsZSIKIAotIzogYnVpbHRpbi9ncmVwLmM6OTAwCisjOiBidWlsdGluL2dyZXAuYzo5MDIKIG1zZ2lkICJtYXRjaCA8cGF0dGVybj4iCiBtc2dzdHIgImNlcmNhIGNvcnJpc3BvbmRlbnplIGNvbiA8cGF0dGVybj4iCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjkwMgorIzogYnVpbHRpbi9ncmVwLmM6OTA0CiBtc2dpZCAiY29tYmluZSBwYXR0ZXJucyBzcGVjaWZpZWQgd2l0aCAtZSIKIG1zZ3N0ciAiY29tYmluYSBpIHBhdHRlcm4gc3BlY2lmaWNhdGkgY29uIC1lIgogCi0jOiBidWlsdGluL2dyZXAuYzo5MTQKKyM6IGJ1aWx0aW4vZ3JlcC5jOjkxNgogbXNnaWQgImluZGljYXRlIGhpdCB3aXRoIGV4aXQgc3RhdHVzIHdpdGhvdXQgb3V0cHV0IgogbXNnc3RyICIiCiAic2VnbmFsYSB1bmEgY29ycmlzcG9uZGVuemEgY29uIGlsIGNvZGljZSBkaSB1c2NpdGEgc2VuemEgZW1ldHRlcmUgb3V0cHV0IgogCi0jOiBidWlsdGluL2dyZXAuYzo5MTYKKyM6IGJ1aWx0aW4vZ3JlcC5jOjkxOAogbXNnaWQgInNob3cgb25seSBtYXRjaGVzIGZyb20gZmlsZXMgdGhhdCBtYXRjaCBhbGwgcGF0dGVybnMiCiBtc2dzdHIgIiIKICJ2aXN1YWxpenphIHNvbG8gbGUgY29ycmlzcG9uZGVuemUgbmVpIGZpbGUgaW4gY3VpIHZpIHNvbm8gY29ycmlzcG9uZGVuemUgcGVyICIKICJ0dXR0aSBpIHBhdHRlcm4iCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjkxOAorIzogYnVpbHRpbi9ncmVwLmM6OTIwCiBtc2dpZCAic2hvdyBwYXJzZSB0cmVlIGZvciBncmVwIGV4cHJlc3Npb24iCiBtc2dzdHIgInZpc3VhbGl6emEgbCdhbGJlcm8gZGkgYW5hbGlzaSBwZXIgbCdlc3ByZXNzaW9uZSBncmVwIgogCi0jOiBidWlsdGluL2dyZXAuYzo5MjIKKyM6IGJ1aWx0aW4vZ3JlcC5jOjkyNAogbXNnaWQgInBhZ2VyIgogbXNnc3RyICJwYWdlciIKIAotIzogYnVpbHRpbi9ncmVwLmM6OTIyCisjOiBidWlsdGluL2dyZXAuYzo5MjQKIG1zZ2lkICJzaG93IG1hdGNoaW5nIGZpbGVzIGluIHRoZSBwYWdlciIKIG1zZ3N0ciAidmlzdWFsaXp6YSBpIGZpbGUgY29ycmlzcG9uZGVudGkgbmVsIHBhZ2VyIgogCi0jOiBidWlsdGluL2dyZXAuYzo5MjYKKyM6IGJ1aWx0aW4vZ3JlcC5jOjkyOAogbXNnaWQgImFsbG93IGNhbGxpbmcgb2YgZ3JlcCgxKSAoaWdub3JlZCBieSB0aGlzIGJ1aWxkKSIKIG1zZ3N0ciAiY29uc2VudGkiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjk5MAorIzogYnVpbHRpbi9ncmVwLmM6OTkyCiBtc2dpZCAibm8gcGF0dGVybiBnaXZlbiIKIG1zZ3N0ciAibmVzc3VuIHBhdHRlcm4gc3BlY2lmaWNhdG8iCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjEwMjYKKyM6IGJ1aWx0aW4vZ3JlcC5jOjEwMjgKIG1zZ2lkICItLW5vLWluZGV4IG9yIC0tdW50cmFja2VkIGNhbm5vdCBiZSB1c2VkIHdpdGggcmV2cyIKIG1zZ3N0ciAiLS1uby1pbmRleCBvIC0tdW50cmFja2VkIG5vbiBwb3Nzb25vIGVzc2VyZSB1c2F0ZSBjb24gbGUgcmV2aXNpb25pIgogCi0jOiBidWlsdGluL2dyZXAuYzoxMDM0CisjOiBidWlsdGluL2dyZXAuYzoxMDM2CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byByZXNvbHZlIHJldmlzaW9uOiAlcyIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgcmlzb2x2ZXJlIGxhIHJldmlzaW9uZSAlcyIKIAotIzogYnVpbHRpbi9ncmVwLmM6MTA2NQorIzogYnVpbHRpbi9ncmVwLmM6MTA2NwogbXNnaWQgImludmFsaWQgb3B0aW9uIGNvbWJpbmF0aW9uLCBpZ25vcmluZyAtLXRocmVhZHMiCiBtc2dzdHIgImNvbWJpbmF6aW9uZSBkaSBvcHppb25pIG5vbiB2YWxpZGEsIGlnbm9ybyAtLXRocmVhZHMiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjEwNjggYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozNDE2CisjOiBidWlsdGluL2dyZXAuYzoxMDcwIGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzQwMAogbXNnaWQgIm5vIHRocmVhZHMgc3VwcG9ydCwgaWdub3JpbmcgLS10aHJlYWRzIgogbXNnc3RyICJub24gdmkgw6ggc3VwcG9ydG8gcGVyIGkgdGhyZWFkLCBpZ25vcm8gLS10aHJlYWRzIgogCi0jOiBidWlsdGluL2dyZXAuYzoxMDcxIGJ1aWx0aW4vaW5kZXgtcGFjay5jOjE1MzEgYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNzI1CisjOiBidWlsdGluL2dyZXAuYzoxMDczIGJ1aWx0aW4vaW5kZXgtcGFjay5jOjE1MzEgYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNzA1CiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgbnVtYmVyIG9mIHRocmVhZHMgc3BlY2lmaWVkICglZCkiCiBtc2dzdHIgInNwZWNpZmljYXRvIG51bWVybyBub24gdmFsaWRvIGRpIHRocmVhZCAoJWQpIgogCi0jOiBidWlsdGluL2dyZXAuYzoxMDk0CisjOiBidWlsdGluL2dyZXAuYzoxMDk2CiBtc2dpZCAiLS1vcGVuLWZpbGVzLWluLXBhZ2VyIG9ubHkgd29ya3Mgb24gdGhlIHdvcmt0cmVlIgogbXNnc3RyICItLW9wZW4tZmlsZXMtaW4tcGFnZXIgZnVuemlvbmEgc29sbyBzdWxsJ2FsYmVybyBkaSBsYXZvcm8iCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjExMTcKKyM6IGJ1aWx0aW4vZ3JlcC5jOjExMTkKIG1zZ2lkICJvcHRpb24gbm90IHN1cHBvcnRlZCB3aXRoIC0tcmVjdXJzZS1zdWJtb2R1bGVzIgogbXNnc3RyICJvcHppb25lIG5vbiBzdXBwb3J0YXRhIGNvbiAtLXJlY3Vyc2Utc3VibW9kdWxlcyIKIAotIzogYnVpbHRpbi9ncmVwLmM6MTEyMworIzogYnVpbHRpbi9ncmVwLmM6MTEyNQogbXNnaWQgIi0tY2FjaGVkIG9yIC0tdW50cmFja2VkIGNhbm5vdCBiZSB1c2VkIHdpdGggLS1uby1pbmRleCIKIG1zZ3N0ciAiLS1jYWNoZWQgbyAtLXVudHJhY2tlZCBub24gcG9zc29ubyBlc3NlcmUgdXNhdGUgY29uIC0tbm8taW5kZXgiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjExMjkKKyM6IGJ1aWx0aW4vZ3JlcC5jOjExMzEKIG1zZ2lkICItLVtuby1dZXhjbHVkZS1zdGFuZGFyZCBjYW5ub3QgYmUgdXNlZCBmb3IgdHJhY2tlZCBjb250ZW50cyIKIG1zZ3N0ciAiLS1bbm8tXWV4Y2x1ZGUtc3RhbmRhcmQgbm9uIHB1w7IgZXNzZXJlIHVzYXRhIHBlciBpIGNvbnRlbnV0aSB0cmFjY2lhdGkiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjExMzcKKyM6IGJ1aWx0aW4vZ3JlcC5jOjExMzkKIG1zZ2lkICJib3RoIC0tY2FjaGVkIGFuZCB0cmVlcyBhcmUgZ2l2ZW4iCiBtc2dzdHIgInNvbm8gc3BlY2lmaWNhdGkgc2lhIC0tY2FjaGVkIHNpYSBkZWdsaSBhbGJlcmkiCiAKQEAgLTE0MjUwLDcgKzE0MzM2LDcgQEAKIG1zZ2lkICJSZXNvbHZpbmcgZGVsdGFzIgogbXNnc3RyICJSaXNvbHV6aW9uZSBkZWkgZGVsdGEiCiAKLSM6IGJ1aWx0aW4vaW5kZXgtcGFjay5jOjEyMDUgYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNDk3CisjOiBidWlsdGluL2luZGV4LXBhY2suYzoxMjA1IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjQ4MQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gY3JlYXRlIHRocmVhZDogJXMiCiBtc2dzdHIgImltcG9zc2liaWxlIGNyZWFyZSBpbCB0aHJlYWQ6ICVzIgpAQCAtMTQzMTUsNyArMTQ0MDEsNyBAQAogbXNnaWQgImNhbm5vdCBzdG9yZSBpbmRleCBmaWxlIgogbXNnc3RyICJpbXBvc3NpYmlsZSBhcmNoaXZpYXJlIGluZGV4IGZpbGUiCiAKLSM6IGJ1aWx0aW4vaW5kZXgtcGFjay5jOjE1MjUgYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNzM2CisjOiBidWlsdGluL2luZGV4LXBhY2suYzoxNTI1IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjcxNgogIywgYy1mb3JtYXQKIG1zZ2lkICJiYWQgcGFjay5pbmRleHZlcnNpb249JTxQUkl1MzI+IgogbXNnc3RyICJwYWNrLmluZGV4dmVyc2lvbj0lPFBSSXUzMj4gbm9uIHZhbGlkYSIKQEAgLTE0NTk2LDc0ICsxNDY4Miw3NCBAQAogbXNnaWQgImdpdCBzaG93ICVzOiBiYWQgZmlsZSIKIG1zZ3N0ciAiZ2l0IHNob3cgJXM6IGZpbGUgbm9uIHZhbGlkbyIKIAotIzogYnVpbHRpbi9sb2cuYzo1NDkgYnVpbHRpbi9sb2cuYzo2NDMKKyM6IGJ1aWx0aW4vbG9nLmM6NTQ5IGJ1aWx0aW4vbG9nLmM6NjQ0CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCByZWFkIG9iamVjdCAlcyIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgbGVnZ2VyZSBsJ29nZ2V0dG8gJXMiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6NjY4CisjOiBidWlsdGluL2xvZy5jOjY2OQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmtub3duIHR5cGU6ICVkIgogbXNnc3RyICJ0aXBvIHNjb25vc2NpdXRvOiAlZCIKIAotIzogYnVpbHRpbi9sb2cuYzo3OTEKKyM6IGJ1aWx0aW4vbG9nLmM6NzkyCiBtc2dpZCAiZm9ybWF0LmhlYWRlcnMgd2l0aG91dCB2YWx1ZSIKIG1zZ3N0ciAiZm9ybWF0LmhlYWRlcnMgbm9uIGhhIGFsY3VuIHZhbG9yZSIKIAotIzogYnVpbHRpbi9sb2cuYzo5MDgKKyM6IGJ1aWx0aW4vbG9nLmM6OTA5CiBtc2dpZCAibmFtZSBvZiBvdXRwdXQgZGlyZWN0b3J5IGlzIHRvbyBsb25nIgogbXNnc3RyICJpbCBub21lIGRlbGxhIGRpcmVjdG9yeSBkaSBvdXRwdXQgw6ggdHJvcHBvIGx1bmdvIgogCi0jOiBidWlsdGluL2xvZy5jOjkyNAorIzogYnVpbHRpbi9sb2cuYzo5MjUKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IG9wZW4gcGF0Y2ggZmlsZSAlcyIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgYXByaXJlIGlsIGZpbGUgcGF0Y2ggJXMiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6OTQxCisjOiBidWlsdGluL2xvZy5jOjk0MgogbXNnaWQgIm5lZWQgZXhhY3RseSBvbmUgcmFuZ2UiCiBtc2dzdHIgIsOoIG5lY2Vzc2FyaW8gc3BlY2lmaWNhcmUgZXNhdHRhbWVudGUgdW4gaW50ZXJ2YWxsbyIKIAotIzogYnVpbHRpbi9sb2cuYzo5NTEKKyM6IGJ1aWx0aW4vbG9nLmM6OTUyCiBtc2dpZCAibm90IGEgcmFuZ2UiCiBtc2dzdHIgImlsIHZhbG9yZSBub24gw6ggdW4gaW50ZXJ2YWxsbyIKIAotIzogYnVpbHRpbi9sb2cuYzoxMDc0CisjOiBidWlsdGluL2xvZy5jOjEwNzUKIG1zZ2lkICJjb3ZlciBsZXR0ZXIgbmVlZHMgZW1haWwgZm9ybWF0IgogbXNnc3RyICJsYSBsZXR0ZXJhIGRpIGFjY29tcGFnbmFtZW50byBkZXYnZXNzZXJlIGluIGZvcm1hdG8gZS1tYWlsIgogCi0jOiBidWlsdGluL2xvZy5jOjEwODAKKyM6IGJ1aWx0aW4vbG9nLmM6MTA4MQogbXNnaWQgImZhaWxlZCB0byBjcmVhdGUgY292ZXItbGV0dGVyIGZpbGUiCiBtc2dzdHIgImNyZWF6aW9uZSBkZWwgZmlsZSBsZXR0ZXJhIGRpIGFjY29tcGFnbmFtZW50byBub24gcml1c2NpdGEiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTE1OQorIzogYnVpbHRpbi9sb2cuYzoxMTYwCiAjLCBjLWZvcm1hdAogbXNnaWQgImluc2FuZSBpbi1yZXBseS10bzogJXMiCiBtc2dzdHIgInZhbG9yZSBpbi1yZXBseS10byBmb2xsZTogJXMiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTE4NgorIzogYnVpbHRpbi9sb2cuYzoxMTg3CiBtc2dpZCAiZ2l0IGZvcm1hdC1wYXRjaCBbPG9wdGlvbnM+XSBbPHNpbmNlPiB8IDxyZXZpc2lvbi1yYW5nZT5dIgogbXNnc3RyICJnaXQgZm9ybWF0LXBhdGNoIFs8b3B6aW9uaT5dIFs8ZGE+IHwgPGludGVydmFsbG8gcmV2aXNpb25pPl0iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTI0NAorIzogYnVpbHRpbi9sb2cuYzoxMjQ1CiBtc2dpZCAidHdvIG91dHB1dCBkaXJlY3Rvcmllcz8iCiBtc2dzdHIgImR1ZSBkaXJlY3RvcnkgZGkgb3V0cHV0PyIKIAotIzogYnVpbHRpbi9sb2cuYzoxMzU1IGJ1aWx0aW4vbG9nLmM6MjA5OSBidWlsdGluL2xvZy5jOjIxMDEgYnVpbHRpbi9sb2cuYzoyMTEzCisjOiBidWlsdGluL2xvZy5jOjEzNTYgYnVpbHRpbi9sb2cuYzoyMTE2IGJ1aWx0aW4vbG9nLmM6MjExOCBidWlsdGluL2xvZy5jOjIxMzAKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5rbm93biBjb21taXQgJXMiCiBtc2dzdHIgImNvbW1pdCAlcyBzY29ub3NjaXV0byIKIAotIzogYnVpbHRpbi9sb2cuYzoxMzY1IGJ1aWx0aW4vcmVwbGFjZS5jOjU4IGJ1aWx0aW4vcmVwbGFjZS5jOjIwNworIzogYnVpbHRpbi9sb2cuYzoxMzY2IGJ1aWx0aW4vcmVwbGFjZS5jOjU4IGJ1aWx0aW4vcmVwbGFjZS5jOjIwNwogIzogYnVpbHRpbi9yZXBsYWNlLmM6MjEwCiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byByZXNvbHZlICclcycgYXMgYSB2YWxpZCByZWYiCiBtc2dzdHIgImltcG9zc2liaWxlIHJpc29sdmVyZSAnJXMnIGNvbWUgcmlmZXJpbWVudG8gdmFsaWRvIgogCi0jOiBidWlsdGluL2xvZy5jOjEzNzAKKyM6IGJ1aWx0aW4vbG9nLmM6MTM3MQogbXNnaWQgImNvdWxkIG5vdCBmaW5kIGV4YWN0IG1lcmdlIGJhc2UiCiBtc2dzdHIgImltcG9zc2liaWxlIHRyb3ZhcmUgZXNhdHRhbWVudGUgbGEgYmFzZSBkZWwgbWVyZ2UiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTM3NAorIzogYnVpbHRpbi9sb2cuYzoxMzc1CiBtc2dpZCAiIgogImZhaWxlZCB0byBnZXQgdXBzdHJlYW0sIGlmIHlvdSB3YW50IHRvIHJlY29yZCBiYXNlIGNvbW1pdCBhdXRvbWF0aWNhbGx5LFxuIgogInBsZWFzZSB1c2UgZ2l0IGJyYW5jaCAtLXNldC11cHN0cmVhbS10byB0byB0cmFjayBhIHJlbW90ZSBicmFuY2guXG4iCkBAIC0xNDY3NSwyNzggKzE0NzYxLDI3OCBAQAogIkluIGFsdGVybmF0aXZhIHB1b2kgc3BlY2lmaWNhcmUgbWFudWFsbWVudGUgaWwgY29tbWl0IGRpIGJhc2UgY29uXG4iCiAiLS1iYXNlPTxJRCBjb21taXQgZGkgYmFzZT4iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTM5NAorIzogYnVpbHRpbi9sb2cuYzoxMzk1CiBtc2dpZCAiZmFpbGVkIHRvIGZpbmQgZXhhY3QgbWVyZ2UgYmFzZSIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgdHJvdmFyZSBlc2F0dGFtZW50ZSBsYSBiYXNlIGRlbCBtZXJnZSIKIAotIzogYnVpbHRpbi9sb2cuYzoxNDA1CisjOiBidWlsdGluL2xvZy5jOjE0MDYKIG1zZ2lkICJiYXNlIGNvbW1pdCBzaG91bGQgYmUgdGhlIGFuY2VzdG9yIG9mIHJldmlzaW9uIGxpc3QiCiBtc2dzdHIgImlsIGNvbW1pdCBkaSBiYXNlIGRvdnJlYmJlIGVzc2VyZSBsJ2FudGVuYXRvIGRlbGwnZWxlbmNvIHJldmlzaW9uaSIKIAotIzogYnVpbHRpbi9sb2cuYzoxNDA5CisjOiBidWlsdGluL2xvZy5jOjE0MTAKIG1zZ2lkICJiYXNlIGNvbW1pdCBzaG91bGRuJ3QgYmUgaW4gcmV2aXNpb24gbGlzdCIKIG1zZ3N0ciAiaWwgY29tbWl0IGRpIGJhc2Ugbm9uIGRvdnJlYmJlIGVzc2VyZSBuZWxsJ2VsZW5jbyByZXZpc2lvbmkiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTQ2MgorIzogYnVpbHRpbi9sb2cuYzoxNDYzCiBtc2dpZCAiY2Fubm90IGdldCBwYXRjaCBpZCIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgb3R0ZW5lcmUgbCdJRCBkZWxsYSBwYXRjaCIKIAotIzogYnVpbHRpbi9sb2cuYzoxNTE0CisjOiBidWlsdGluL2xvZy5jOjE1MTUKIG1zZ2lkICJmYWlsZWQgdG8gaW5mZXIgcmFuZ2UtZGlmZiByYW5nZXMiCiBtc2dzdHIgImluZmVyZW56YSBkZWdsaSBpbnRlcnZhbGxpIHJhbmdlLWRpZmYgbm9uIHJpdXNjaXRhIgogCi0jOiBidWlsdGluL2xvZy5jOjE1NTkKKyM6IGJ1aWx0aW4vbG9nLmM6MTU2MAogbXNnaWQgInVzZSBbUEFUQ0ggbi9tXSBldmVuIHdpdGggYSBzaW5nbGUgcGF0Y2giCiBtc2dzdHIgInVzYSBbUEFUQ0ggbi9tXSBhbmNoZSBjb24gdW5hIHNpbmdvbGEgcGF0Y2giCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTU2MgorIzogYnVpbHRpbi9sb2cuYzoxNTYzCiBtc2dpZCAidXNlIFtQQVRDSF0gZXZlbiB3aXRoIG11bHRpcGxlIHBhdGNoZXMiCiBtc2dzdHIgInVzYSBbUEFUQ0hdIGFuY2hlIGNvbiBwacO5IHBhdGNoIgogCi0jOiBidWlsdGluL2xvZy5jOjE1NjYKKyM6IGJ1aWx0aW4vbG9nLmM6MTU2NwogbXNnaWQgInByaW50IHBhdGNoZXMgdG8gc3RhbmRhcmQgb3V0IgogbXNnc3RyICJzdGFtcGEgbGUgcGF0Y2ggc3VsbG8gc3RhbmRhcmQgb3V0cHV0IgogCi0jOiBidWlsdGluL2xvZy5jOjE1NjgKKyM6IGJ1aWx0aW4vbG9nLmM6MTU2OQogbXNnaWQgImdlbmVyYXRlIGEgY292ZXIgbGV0dGVyIgogbXNnc3RyICJnZW5lcmEgdW5hIGxldHRlcmEgZGkgYWNjb21wYWduYW1lbnRvIgogCi0jOiBidWlsdGluL2xvZy5jOjE1NzAKKyM6IGJ1aWx0aW4vbG9nLmM6MTU3MQogbXNnaWQgInVzZSBzaW1wbGUgbnVtYmVyIHNlcXVlbmNlIGZvciBvdXRwdXQgZmlsZSBuYW1lcyIKIG1zZ3N0ciAidXNhIHVuYSBzZXF1ZW56YSBudW1lcmljYSBzZW1wbGljZSBwZXIgaSBub21pIGZpbGUgZGkgb3V0cHV0IgogCi0jOiBidWlsdGluL2xvZy5jOjE1NzEKKyM6IGJ1aWx0aW4vbG9nLmM6MTU3MgogbXNnaWQgInNmeCIKIG1zZ3N0ciAic3VmZiIKIAotIzogYnVpbHRpbi9sb2cuYzoxNTcyCisjOiBidWlsdGluL2xvZy5jOjE1NzMKIG1zZ2lkICJ1c2UgPHNmeD4gaW5zdGVhZCBvZiAnLnBhdGNoJyIKIG1zZ3N0ciAidXNhIDxzdWZmPiBhbnppY2jDqSAnLnBhdGNoJyIKIAotIzogYnVpbHRpbi9sb2cuYzoxNTc0CisjOiBidWlsdGluL2xvZy5jOjE1NzUKIG1zZ2lkICJzdGFydCBudW1iZXJpbmcgcGF0Y2hlcyBhdCA8bj4gaW5zdGVhZCBvZiAxIgogbXNnc3RyICJpbml6aWEgYSBudW1lcmFyZSBsZSBwYXRjaCBkYSA8bj4gYW56aWNow6kgZGEgMSIKIAotIzogYnVpbHRpbi9sb2cuYzoxNTc2CisjOiBidWlsdGluL2xvZy5jOjE1NzcKIG1zZ2lkICJtYXJrIHRoZSBzZXJpZXMgYXMgTnRoIHJlLXJvbGwiCiBtc2dzdHIgImNvbnRyYXNzZWduYSBsYSBzZXJpZSBjb21lIGwnbi1lc2ltYSB2ZXJzaW9uZSByZXZpc2lvbmF0YSIKIAotIzogYnVpbHRpbi9sb2cuYzoxNTc4CisjOiBidWlsdGluL2xvZy5jOjE1NzkKIG1zZ2lkICJVc2UgW1JGQyBQQVRDSF0gaW5zdGVhZCBvZiBbUEFUQ0hdIgogbXNnc3RyICJVc2EgW1JGQyBQQVRDSF0gYW56aWNow6kgW1BBVENIXSIKIAotIzogYnVpbHRpbi9sb2cuYzoxNTgxCisjOiBidWlsdGluL2xvZy5jOjE1ODIKIG1zZ2lkICJVc2UgWzxwcmVmaXg+XSBpbnN0ZWFkIG9mIFtQQVRDSF0iCiBtc2dzdHIgIlVzYSBbPHByZWZpc3NvPl0gYW56aWNow6kgW1BBVENIXSIKIAotIzogYnVpbHRpbi9sb2cuYzoxNTg0CisjOiBidWlsdGluL2xvZy5jOjE1ODUKIG1zZ2lkICJzdG9yZSByZXN1bHRpbmcgZmlsZXMgaW4gPGRpcj4iCiBtc2dzdHIgInNhbHZhIGkgZmlsZSByaXN1bHRhbnRpIGluIDxkaXI+IgogCi0jOiBidWlsdGluL2xvZy5jOjE1ODcKKyM6IGJ1aWx0aW4vbG9nLmM6MTU4OAogbXNnaWQgImRvbid0IHN0cmlwL2FkZCBbUEFUQ0hdIgogbXNnc3RyICJub24gZWxpbWluYXJlL2FnZ2l1bmdlcmUgW1BBVENIXSIKIAotIzogYnVpbHRpbi9sb2cuYzoxNTkwCisjOiBidWlsdGluL2xvZy5jOjE1OTEKIG1zZ2lkICJkb24ndCBvdXRwdXQgYmluYXJ5IGRpZmZzIgogbXNnc3RyICJub24gbWFuZGFyZSBpbiBvdXRwdXQgZGlmZiBiaW5hcmkiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTU5MgorIzogYnVpbHRpbi9sb2cuYzoxNTkzCiBtc2dpZCAib3V0cHV0IGFsbC16ZXJvIGhhc2ggaW4gRnJvbSBoZWFkZXIiCiBtc2dzdHIgIm1hbmRhIGluIG91dHB1dCB1biBoYXNoIGNvc3RpdHVpdG8gZGEgc29saSB6ZXJpIG5lbGwnaW50ZXN0YXppb25lIEZyb20iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTU5NAorIzogYnVpbHRpbi9sb2cuYzoxNTk1CiBtc2dpZCAiZG9uJ3QgaW5jbHVkZSBhIHBhdGNoIG1hdGNoaW5nIGEgY29tbWl0IHVwc3RyZWFtIgogbXNnc3RyICJub24gaW5jbHVkZXJlIHVuYSBwYXRjaCBjb3JyaXNwb25kZW50ZSBhIHVuIGNvbW1pdCB1cHN0cmVhbSIKIAotIzogYnVpbHRpbi9sb2cuYzoxNTk2CisjOiBidWlsdGluL2xvZy5jOjE1OTcKIG1zZ2lkICJzaG93IHBhdGNoIGZvcm1hdCBpbnN0ZWFkIG9mIGRlZmF1bHQgKHBhdGNoICsgc3RhdCkiCiBtc2dzdHIgIiIKICJ2aXN1YWxpenphIGlsIGZvcm1hdG8gZGVsbGEgcGF0Y2ggYW56aWNow6kgbCdpbXBvc3RhemlvbmUgcHJlZGVmaW5pdGEgKHBhdGNoICIKICIrIHN0YXQpIgogCi0jOiBidWlsdGluL2xvZy5jOjE1OTgKKyM6IGJ1aWx0aW4vbG9nLmM6MTU5OQogbXNnaWQgIk1lc3NhZ2luZyIKIG1zZ3N0ciAiTWVzc2FnZ2lzdGljYSIKIAotIzogYnVpbHRpbi9sb2cuYzoxNTk5CisjOiBidWlsdGluL2xvZy5jOjE2MDAKIG1zZ2lkICJoZWFkZXIiCiBtc2dzdHIgImludGVzdGF6aW9uZSIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjAwCisjOiBidWlsdGluL2xvZy5jOjE2MDEKIG1zZ2lkICJhZGQgZW1haWwgaGVhZGVyIgogbXNnc3RyICJhZ2dpdW5naSBpbnRlc3RhemlvbmUgZS1tYWlsIgogCi0jOiBidWlsdGluL2xvZy5jOjE2MDEgYnVpbHRpbi9sb2cuYzoxNjAzCisjOiBidWlsdGluL2xvZy5jOjE2MDIgYnVpbHRpbi9sb2cuYzoxNjA0CiBtc2dpZCAiZW1haWwiCiBtc2dzdHIgImUtbWFpbCIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjAxCisjOiBidWlsdGluL2xvZy5jOjE2MDIKIG1zZ2lkICJhZGQgVG86IGhlYWRlciIKIG1zZ3N0ciAiYWdnaXVuZ2kgaW50ZXN0YXppb25lIEE6IgogCi0jOiBidWlsdGluL2xvZy5jOjE2MDMKKyM6IGJ1aWx0aW4vbG9nLmM6MTYwNAogbXNnaWQgImFkZCBDYzogaGVhZGVyIgogbXNnc3RyICJhZ2dpdW5naSBpbnRlc3RhemlvbmUgQ2M6IgogCi0jOiBidWlsdGluL2xvZy5jOjE2MDUKKyM6IGJ1aWx0aW4vbG9nLmM6MTYwNgogbXNnaWQgImlkZW50IgogbXNnc3RyICJpZGVudGl0w6AiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTYwNgorIzogYnVpbHRpbi9sb2cuYzoxNjA3CiBtc2dpZCAic2V0IEZyb20gYWRkcmVzcyB0byA8aWRlbnQ+IChvciBjb21taXR0ZXIgaWRlbnQgaWYgYWJzZW50KSIKIG1zZ3N0ciAiIgogImltcG9zdGEgbCdpbmRpcml6em8gRGEgYSA8aWRlbnRpdMOgPiAobyBhbGwnaWRlbnRpdMOgIGRpIGNoaSBoYSBjcmVhdG8gaWwgIgogImNvbW1pdCBzZSBhc3NlbnRlKSIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjA4CisjOiBidWlsdGluL2xvZy5jOjE2MDkKIG1zZ2lkICJtZXNzYWdlLWlkIgogbXNnc3RyICJJRCBtZXNzYWdnaW8iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTYwOQorIzogYnVpbHRpbi9sb2cuYzoxNjEwCiBtc2dpZCAibWFrZSBmaXJzdCBtYWlsIGEgcmVwbHkgdG8gPG1lc3NhZ2UtaWQ+IgogbXNnc3RyICJyZW5kaSBsYSBwcmltYSBlLW1haWwgdW5hIHJpc3Bvc3RhIGEgPElEIG1lc3NhZ2dpbz4iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTYxMCBidWlsdGluL2xvZy5jOjE2MTMKKyM6IGJ1aWx0aW4vbG9nLmM6MTYxMSBidWlsdGluL2xvZy5jOjE2MTQKIG1zZ2lkICJib3VuZGFyeSIKIG1zZ3N0ciAiZGVsaW1pdGF0b3JlIgogCi0jOiBidWlsdGluL2xvZy5jOjE2MTEKKyM6IGJ1aWx0aW4vbG9nLmM6MTYxMgogbXNnaWQgImF0dGFjaCB0aGUgcGF0Y2giCiBtc2dzdHIgImFsbGVnYSBsYSBwYXRjaCIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjE0CisjOiBidWlsdGluL2xvZy5jOjE2MTUKIG1zZ2lkICJpbmxpbmUgdGhlIHBhdGNoIgogbXNnc3RyICJpbmNsdWRpIGxhIHBhdGNoIG5lbCBtZXNzYWdnaW8iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTYxOAorIzogYnVpbHRpbi9sb2cuYzoxNjE5CiBtc2dpZCAiZW5hYmxlIG1lc3NhZ2UgdGhyZWFkaW5nLCBzdHlsZXM6IHNoYWxsb3csIGRlZXAiCiBtc2dzdHIgIiIKICJhYmlsaXRhIGlsIHJhZ2dydXBwYW1lbnRvIG1lc3NhZ2dpIHBlciBjb252ZXJzYXppb25lLCBzdGlsaTogc3VwZXJmaWNpYWxlLCAiCiAicHJvZm9uZG8iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTYyMAorIzogYnVpbHRpbi9sb2cuYzoxNjIxCiBtc2dpZCAic2lnbmF0dXJlIgogbXNnc3RyICJmaXJtYSIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjIxCisjOiBidWlsdGluL2xvZy5jOjE2MjIKIG1zZ2lkICJhZGQgYSBzaWduYXR1cmUiCiBtc2dzdHIgImFnZ2l1bmdpIHVuYSBmaXJtYSIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjIyCisjOiBidWlsdGluL2xvZy5jOjE2MjMKIG1zZ2lkICJiYXNlLWNvbW1pdCIKIG1zZ3N0ciAiY29tbWl0IGRpIGJhc2UiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTYyMworIzogYnVpbHRpbi9sb2cuYzoxNjI0CiBtc2dpZCAiYWRkIHByZXJlcXVpc2l0ZSB0cmVlIGluZm8gdG8gdGhlIHBhdGNoIHNlcmllcyIKIG1zZ3N0ciAiIgogImFnZ2l1bmdpIGxlIGluZm9ybWF6aW9uaSBwcmVyZXF1aXNpdG8gcGVyIGwnYWxiZXJvIGFsbGEgc2VyaWUgZGVsbGUgcGF0Y2giCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTYyNQorIzogYnVpbHRpbi9sb2cuYzoxNjI2CiBtc2dpZCAiYWRkIGEgc2lnbmF0dXJlIGZyb20gYSBmaWxlIgogbXNnc3RyICJhZ2dpdW5naSB1bmEgZmlybWEgZGEgZmlsZSIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjI2CisjOiBidWlsdGluL2xvZy5jOjE2MjcKIG1zZ2lkICJkb24ndCBwcmludCB0aGUgcGF0Y2ggZmlsZW5hbWVzIgogbXNnc3RyICJub24gc3RhbXBhcmUgaSBub21pIGZpbGUgZGVsbGUgcGF0Y2giCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTYyOAorIzogYnVpbHRpbi9sb2cuYzoxNjI5CiBtc2dpZCAic2hvdyBwcm9ncmVzcyB3aGlsZSBnZW5lcmF0aW5nIHBhdGNoZXMiCiBtc2dzdHIgInZpc3VhbGl6emEgbCdhdmFuemFtZW50byBkZWxsJ29wZXJhemlvbmUgZGkgZ2VuZXJhemlvbmUgcGF0Y2giCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTYzMAorIzogYnVpbHRpbi9sb2cuYzoxNjMxCiBtc2dpZCAic2hvdyBjaGFuZ2VzIGFnYWluc3QgPHJldj4gaW4gY292ZXIgbGV0dGVyIG9yIHNpbmdsZSBwYXRjaCIKIG1zZ3N0ciAiIgogInZpc3VhbGl6emEgbGUgbW9kaWZpY2hlIHJpc3BldHRvIGEgPHJldmlzaW9uZT4gbmVsbGEgbGV0dGVyYSBkaSAiCiAiYWNjb21wYWduYW1lbnRvIG8gaW4gdW5hIHBhdGNoIHNpbmdvbGEiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTYzMworIzogYnVpbHRpbi9sb2cuYzoxNjM0CiBtc2dpZCAic2hvdyBjaGFuZ2VzIGFnYWluc3QgPHJlZnNwZWM+IGluIGNvdmVyIGxldHRlciBvciBzaW5nbGUgcGF0Y2giCiBtc2dzdHIgIiIKICJ2aXN1YWxpenphIGxlIG1vZGlmaWNoZSByaXNwZXR0byBhIDxzcGVjaWZpY2F0b3JlIHJldmlzaW9uZT4gbmVsbGEgbGV0dGVyYSAiCiAiZGkgYWNjb21wYWduYW1lbnRvIG8gaW4gdW5hIHBhdGNoIHNpbmdvbGEiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTYzNQorIzogYnVpbHRpbi9sb2cuYzoxNjM2CiBtc2dpZCAicGVyY2VudGFnZSBieSB3aGljaCBjcmVhdGlvbiBpcyB3ZWlnaHRlZCIKIG1zZ3N0ciAicGVyY2VudHVhbGUgaW4gYmFzZSBhIGN1aSB2aWVuZSBwZXNhdGEgbGEgY3JlYXppb25lIgogCi0jOiBidWlsdGluL2xvZy5jOjE3MTAKKyM6IGJ1aWx0aW4vbG9nLmM6MTcxMQogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIGlkZW50IGxpbmU6ICVzIgogbXNnc3RyICJyaWdhIGlkZW50IG5vbiB2YWxpZGE6ICVzIgogCi0jOiBidWlsdGluL2xvZy5jOjE3MjUKKyM6IGJ1aWx0aW4vbG9nLmM6MTcyNgogbXNnaWQgIi1uIGFuZCAtayBhcmUgbXV0dWFsbHkgZXhjbHVzaXZlIgogbXNnc3RyICJsZSBvcHppb25pIC1uIGUgLWsgc29ubyBtdXR1YW1lbnRlIGVzY2x1c2l2ZSIKIAotIzogYnVpbHRpbi9sb2cuYzoxNzI3CisjOiBidWlsdGluL2xvZy5jOjE3MjgKIG1zZ2lkICItLXN1YmplY3QtcHJlZml4Ly0tcmZjIGFuZCAtayBhcmUgbXV0dWFsbHkgZXhjbHVzaXZlIgogbXNnc3RyICJsZSBvcHppb25pIC0tc3ViamVjdC1wcmVmaXgvLS1yZmMgZSAtayBzb25vIG11dHVhbWVudGUgZXNjbHVzaXZlIgogCi0jOiBidWlsdGluL2xvZy5jOjE3MzUKKyM6IGJ1aWx0aW4vbG9nLmM6MTczNgogbXNnaWQgIi0tbmFtZS1vbmx5IGRvZXMgbm90IG1ha2Ugc2Vuc2UiCiBtc2dzdHIgIi0tbmFtZS1vbmx5IG5vbiBoYSBzZW5zbyIKIAotIzogYnVpbHRpbi9sb2cuYzoxNzM3CisjOiBidWlsdGluL2xvZy5jOjE3MzgKIG1zZ2lkICItLW5hbWUtc3RhdHVzIGRvZXMgbm90IG1ha2Ugc2Vuc2UiCiBtc2dzdHIgIi0tbmFtZS1zdGF0dXMgbm9uIGhhIHNlbnNvIgogCi0jOiBidWlsdGluL2xvZy5jOjE3MzkKKyM6IGJ1aWx0aW4vbG9nLmM6MTc0MAogbXNnaWQgIi0tY2hlY2sgZG9lcyBub3QgbWFrZSBzZW5zZSIKIG1zZ3N0ciAiLS1jaGVjayBub24gaGEgc2Vuc28iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTc3MQorIzogYnVpbHRpbi9sb2cuYzoxNzczCiBtc2dpZCAic3RhbmRhcmQgb3V0cHV0LCBvciBkaXJlY3RvcnksIHdoaWNoIG9uZT8iCiBtc2dzdHIgInN0YW5kYXJkIG91dHB1dCwgbyBkaXJlY3RvcnksIHF1YWxlIGRlaSBkdWU/IgogCi0jOiBidWlsdGluL2xvZy5jOjE4NjAKKyM6IGJ1aWx0aW4vbG9nLmM6MTg3NwogbXNnaWQgIi0taW50ZXJkaWZmIHJlcXVpcmVzIC0tY292ZXItbGV0dGVyIG9yIHNpbmdsZSBwYXRjaCIKIG1zZ3N0ciAiLS1pbnRlcmRpZmYgcmljaGllZGUgLS1jb3Zlci1sZXR0ZXIgbyB1bmEgc2luZ29sYSBwYXRjaCIKIAotIzogYnVpbHRpbi9sb2cuYzoxODY0CisjOiBidWlsdGluL2xvZy5jOjE4ODEKIG1zZ2lkICJJbnRlcmRpZmY6IgogbXNnc3RyICJJbnRlcmRpZmY6IgogCi0jOiBidWlsdGluL2xvZy5jOjE4NjUKKyM6IGJ1aWx0aW4vbG9nLmM6MTg4MgogIywgYy1mb3JtYXQKIG1zZ2lkICJJbnRlcmRpZmYgYWdhaW5zdCB2JWQ6IgogbXNnc3RyICJJbnRlcmRpZmYgcmlzcGV0dG8gYWxsYSB2ZXJzaW9uZSAlZDoiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTg3MQorIzogYnVpbHRpbi9sb2cuYzoxODg4CiBtc2dpZCAiLS1jcmVhdGlvbi1mYWN0b3IgcmVxdWlyZXMgLS1yYW5nZS1kaWZmIgogbXNnc3RyICItLWNyZWF0aW9uLWZhY3RvciByaWNoaWVkZSAtLXJhbmdlLWRpZmYiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTg3NQorIzogYnVpbHRpbi9sb2cuYzoxODkyCiBtc2dpZCAiLS1yYW5nZS1kaWZmIHJlcXVpcmVzIC0tY292ZXItbGV0dGVyIG9yIHNpbmdsZSBwYXRjaCIKIG1zZ3N0ciAiLS1yYW5nZS1kaWZmIHJpY2hpZWRlIC0tY292ZXItbGV0dGVyIG8gdW5hIHNpbmdvbGEgcGF0Y2giCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTg4MworIzogYnVpbHRpbi9sb2cuYzoxOTAwCiBtc2dpZCAiUmFuZ2UtZGlmZjoiCiBtc2dzdHIgIlJhbmdlLWRpZmY6IgogCi0jOiBidWlsdGluL2xvZy5jOjE4ODQKKyM6IGJ1aWx0aW4vbG9nLmM6MTkwMQogIywgYy1mb3JtYXQKIG1zZ2lkICJSYW5nZS1kaWZmIGFnYWluc3QgdiVkOiIKIG1zZ3N0ciAiUmFuZ2UtZGlmZiByaXNwZXR0byBhbGxhIHZlcnNpb25lICVkOiIKIAotIzogYnVpbHRpbi9sb2cuYzoxODk1CisjOiBidWlsdGluL2xvZy5jOjE5MTIKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHJlYWQgc2lnbmF0dXJlIGZpbGUgJyVzJyIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgbGVnZ2VyZSBpbCBmaWxlIGZpcm1hICclcyciCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTkzMQorIzogYnVpbHRpbi9sb2cuYzoxOTQ4CiBtc2dpZCAiR2VuZXJhdGluZyBwYXRjaGVzIgogbXNnc3RyICJHZW5lcmF6aW9uZSBkZWxsZSBwYXRjaCBpbiBjb3JzbyIKIAotIzogYnVpbHRpbi9sb2cuYzoxOTc1CisjOiBidWlsdGluL2xvZy5jOjE5OTIKIG1zZ2lkICJmYWlsZWQgdG8gY3JlYXRlIG91dHB1dCBmaWxlcyIKIG1zZ3N0ciAiY3JlYXppb25lIGRlaSBmaWxlIGRpIG91dHB1dCBub24gcml1c2NpdGEiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MjAzNAorIzogYnVpbHRpbi9sb2cuYzoyMDUxCiBtc2dpZCAiZ2l0IGNoZXJyeSBbLXZdIFs8dXBzdHJlYW0+IFs8aGVhZD4gWzxsaW1pdD5dXV0iCiBtc2dzdHIgImdpdCBjaGVycnkgWy12XSBbPHVwc3RyZWFtPiBbPGhlYWQ+IFs8bGltaXRlPl1dXSIKIAotIzogYnVpbHRpbi9sb2cuYzoyMDg4CisjOiBidWlsdGluL2xvZy5jOjIxMDUKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkNvdWxkIG5vdCBmaW5kIGEgdHJhY2tlZCByZW1vdGUgYnJhbmNoLCBwbGVhc2Ugc3BlY2lmeSA8dXBzdHJlYW0+IG1hbnVhbGx5LlxuIgpAQCAtMTUwNzgsNyArMTUxNjQsNyBAQAogbXNnaWQgImRvIG5vdCBwcmludCByZW1vdGUgVVJMIgogbXNnc3RyICJub24gc3RhbXBhcmUgbCdVUkwgZGVsIHJlbW90byIKIAotIzogYnVpbHRpbi9scy1yZW1vdGUuYzo2MCBidWlsdGluL2xzLXJlbW90ZS5jOjYyIGJ1aWx0aW4vcmViYXNlLmM6MTQ2NAorIzogYnVpbHRpbi9scy1yZW1vdGUuYzo2MCBidWlsdGluL2xzLXJlbW90ZS5jOjYyIGJ1aWx0aW4vcmViYXNlLmM6MTQ4OAogbXNnaWQgImV4ZWMiCiBtc2dzdHIgImVzZWd1aWJpbGUiCiAKQEAgLTE1MTkwLDMzICsxNTI3NiwzMyBAQAogbXNnaWQgIkF2YWlsYWJsZSBjdXN0b20gc3RyYXRlZ2llcyBhcmU6IgogbXNnc3RyICJMZSBzdHJhdGVnaWUgcGVyc29uYWxpenphdGUgZGlzcG9uaWJpbGkgc29ubzoiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoyNDQgYnVpbHRpbi9wdWxsLmM6MTUxCisjOiBidWlsdGluL21lcmdlLmM6MjQ0IGJ1aWx0aW4vcHVsbC5jOjE1MgogbXNnaWQgImRvIG5vdCBzaG93IGEgZGlmZnN0YXQgYXQgdGhlIGVuZCBvZiB0aGUgbWVyZ2UiCiBtc2dzdHIgIm5vbiB2aXN1YWxpenphcmUgdW4gZGlmZnN0YXQgYWwgdGVybWluZSBkZWwgbWVyZ2UiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoyNDcgYnVpbHRpbi9wdWxsLmM6MTU0CisjOiBidWlsdGluL21lcmdlLmM6MjQ3IGJ1aWx0aW4vcHVsbC5jOjE1NQogbXNnaWQgInNob3cgYSBkaWZmc3RhdCBhdCB0aGUgZW5kIG9mIHRoZSBtZXJnZSIKIG1zZ3N0ciAidmlzdWFsaXp6YSB1biBkaWZmc3RhdCBhbCB0ZXJtaW5lIGRlbCBtZXJnZSIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjI0OCBidWlsdGluL3B1bGwuYzoxNTcKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoyNDggYnVpbHRpbi9wdWxsLmM6MTU4CiBtc2dpZCAiKHN5bm9ueW0gdG8gLS1zdGF0KSIKIG1zZ3N0ciAiKHNpbm9uaW1vIGRpIC0tc3RhdCkiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoyNTAgYnVpbHRpbi9wdWxsLmM6MTYwCisjOiBidWlsdGluL21lcmdlLmM6MjUwIGJ1aWx0aW4vcHVsbC5jOjE2MQogbXNnaWQgImFkZCAoYXQgbW9zdCA8bj4pIGVudHJpZXMgZnJvbSBzaG9ydGxvZyB0byBtZXJnZSBjb21taXQgbWVzc2FnZSIKIG1zZ3N0ciAiIgogImFnZ2l1bmdpIChhbCBwacO5IDxuPikgdm9jaSBkYWwgcmVnaXN0cm8gYnJldmUgYWwgbWVzc2FnZ2lvIGRpIGNvbW1pdCBkZWwgIgogIm1lcmdlIgogCi0jOiBidWlsdGluL21lcmdlLmM6MjUzIGJ1aWx0aW4vcHVsbC5jOjE2NgorIzogYnVpbHRpbi9tZXJnZS5jOjI1MyBidWlsdGluL3B1bGwuYzoxNjcKIG1zZ2lkICJjcmVhdGUgYSBzaW5nbGUgY29tbWl0IGluc3RlYWQgb2YgZG9pbmcgYSBtZXJnZSIKIG1zZ3N0ciAiY3JlYSB1biBzaW5nb2xvIGNvbW1pdCBhbnppY2jDqSBlc2VndWlyZSB1biBtZXJnZSIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjI1NSBidWlsdGluL3B1bGwuYzoxNjkKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoyNTUgYnVpbHRpbi9wdWxsLmM6MTcwCiBtc2dpZCAicGVyZm9ybSBhIGNvbW1pdCBpZiB0aGUgbWVyZ2Ugc3VjY2VlZHMgKGRlZmF1bHQpIgogbXNnc3RyICJlc2VndWkgdW4gY29tbWl0IHNlIGlsIG1lcmdlIGhhIHN1Y2Nlc3NvIChpbXBvc3RhemlvbmUgcHJlZGVmaW5pdGEpIgogCi0jOiBidWlsdGluL21lcmdlLmM6MjU3IGJ1aWx0aW4vcHVsbC5jOjE3MgorIzogYnVpbHRpbi9tZXJnZS5jOjI1NyBidWlsdGluL3B1bGwuYzoxNzMKIG1zZ2lkICJlZGl0IG1lc3NhZ2UgYmVmb3JlIGNvbW1pdHRpbmciCiBtc2dzdHIgIm1vZGlmaWNhIGlsIG1lc3NhZ2dpbyBwcmltYSBkaSBlc2VndWlyZSBpbCBjb21taXQiCiAKQEAgLTE1MjI0LDI4ICsxNTMxMCwyOCBAQAogbXNnaWQgImFsbG93IGZhc3QtZm9yd2FyZCAoZGVmYXVsdCkiCiBtc2dzdHIgImNvbnNlbnRpIGZhc3QgZm9yd2FyZCAoaW1wb3N0YXppb25lIHByZWRlZmluaXRhKSIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjI2MSBidWlsdGluL3B1bGwuYzoxNzkKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoyNjEgYnVpbHRpbi9wdWxsLmM6MTgwCiBtc2dpZCAiYWJvcnQgaWYgZmFzdC1mb3J3YXJkIGlzIG5vdCBwb3NzaWJsZSIKIG1zZ3N0ciAiaW50ZXJyb21waSBzZSBpbCBmYXN0IGZvcndhcmQgbm9uIMOoIHBvc3NpYmlsZSIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjI2NSBidWlsdGluL3B1bGwuYzoxODIKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoyNjUgYnVpbHRpbi9wdWxsLmM6MTgzCiBtc2dpZCAidmVyaWZ5IHRoYXQgdGhlIG5hbWVkIGNvbW1pdCBoYXMgYSB2YWxpZCBHUEcgc2lnbmF0dXJlIgogbXNnc3RyICJ2ZXJpZmljYSBjaGUgaWwgY29tbWl0IHNwZWNpZmljYXRvIGFiYmlhIHVuYSBmaXJtYSBHUEcgdmFsaWRhIgogCi0jOiBidWlsdGluL21lcmdlLmM6MjY2IGJ1aWx0aW4vbm90ZXMuYzo3ODcgYnVpbHRpbi9wdWxsLmM6MTg2Ci0jOiBidWlsdGluL3JlYmFzZS5jOjQ5MiBidWlsdGluL3JlYmFzZS5jOjE0NzcgYnVpbHRpbi9yZXZlcnQuYzoxMTQKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoyNjYgYnVpbHRpbi9ub3Rlcy5jOjc4NyBidWlsdGluL3B1bGwuYzoxODcKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDkzIGJ1aWx0aW4vcmViYXNlLmM6MTUwMSBidWlsdGluL3JldmVydC5jOjExNAogbXNnaWQgInN0cmF0ZWd5IgogbXNnc3RyICJzdHJhdGVnaWEiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoyNjcgYnVpbHRpbi9wdWxsLmM6MTg3CisjOiBidWlsdGluL21lcmdlLmM6MjY3IGJ1aWx0aW4vcHVsbC5jOjE4OAogbXNnaWQgIm1lcmdlIHN0cmF0ZWd5IHRvIHVzZSIKIG1zZ3N0ciAic3RyYXRlZ2lhIGRpIG1lcmdlIGRhIHVzYXJlIgogCi0jOiBidWlsdGluL21lcmdlLmM6MjY4IGJ1aWx0aW4vcHVsbC5jOjE5MAorIzogYnVpbHRpbi9tZXJnZS5jOjI2OCBidWlsdGluL3B1bGwuYzoxOTEKIG1zZ2lkICJvcHRpb249dmFsdWUiCiBtc2dzdHIgIm9wemlvbmU9dmFsb3JlIgogCi0jOiBidWlsdGluL21lcmdlLmM6MjY5IGJ1aWx0aW4vcHVsbC5jOjE5MQorIzogYnVpbHRpbi9tZXJnZS5jOjI2OSBidWlsdGluL3B1bGwuYzoxOTIKIG1zZ2lkICJvcHRpb24gZm9yIHNlbGVjdGVkIG1lcmdlIHN0cmF0ZWd5IgogbXNnc3RyICJvcHppb25lIHBlciBsYSBzdHJhdGVnaWEgZGkgbWVyZ2Ugc2VsZXppb25hdGEiCiAKQEAgLTE1MjY1LDEzICsxNTM1MSwxMyBAQAogbXNnaWQgImNvbnRpbnVlIHRoZSBjdXJyZW50IGluLXByb2dyZXNzIG1lcmdlIgogbXNnc3RyICJjb250aW51YSBpbCBtZXJnZSBhdHR1YWxtZW50ZSBpbiBjb3JzbyIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjI4NCBidWlsdGluL3B1bGwuYzoxOTgKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoyODQgYnVpbHRpbi9wdWxsLmM6MTk5CiBtc2dpZCAiYWxsb3cgbWVyZ2luZyB1bnJlbGF0ZWQgaGlzdG9yaWVzIgogbXNnc3RyICJjb25zZW50aSBkaSB1bmlyZSBjcm9ub2xvZ2llIG5vbiBjb3JyZWxhdGUiCiAKICM6IGJ1aWx0aW4vbWVyZ2UuYzoyOTAKLW1zZ2lkICJ2ZXJpZnkgY29tbWl0LW1zZyBob29rIgotbXNnc3RyICJ2ZXJpZmljYSBob29rIGNvbW1pdC1tc2ciCittc2dpZCAiYnlwYXNzIHByZS1tZXJnZS1jb21taXQgYW5kIGNvbW1pdC1tc2cgaG9va3MiCittc2dzdHIgImlnbm9yYSBnbGkgaG9vayBwcmUtbWVyZ2UtY29tbWl0IGUgY29tbWl0LW1zZyIKIAogIzogYnVpbHRpbi9tZXJnZS5jOjMwNwogbXNnaWQgImNvdWxkIG5vdCBydW4gc3Rhc2guIgpAQCAtMTUzMTQsMzIgKzE1NDAwLDMyIEBACiBtc2dpZCAiQmFkIGJyYW5jaC4lcy5tZXJnZW9wdGlvbnMgc3RyaW5nOiAlcyIKIG1zZ3N0ciAiU3RyaW5nYSBicmFuY2guJXMubWVyZ2VvcHRpb25zIGVycmF0YTogJXMiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzo3MDgKKyM6IGJ1aWx0aW4vbWVyZ2UuYzo3MDUKIG1zZ2lkICJOb3QgaGFuZGxpbmcgYW55dGhpbmcgb3RoZXIgdGhhbiB0d28gaGVhZHMgbWVyZ2UuIgogbXNnc3RyICJOb24gZ2VzdGlzY28gbnVsbGEgY2hlIG5vbiBzaWEgaWwgbWVyZ2UgZGkgZHVlIGhlYWQuIgogCi0jOiBidWlsdGluL21lcmdlLmM6NzIyCisjOiBidWlsdGluL21lcmdlLmM6NzE5CiAjLCBjLWZvcm1hdAogbXNnaWQgIlVua25vd24gb3B0aW9uIGZvciBtZXJnZS1yZWN1cnNpdmU6IC1YJXMiCiBtc2dzdHIgIk9wemlvbmUgc2Nvbm9zY2l1dGEgcGVyIG1lcmdlLXJlY3Vyc2l2ZTogLVglcyIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjczNworIzogYnVpbHRpbi9tZXJnZS5jOjczNAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gd3JpdGUgJXMiCiBtc2dzdHIgImltcG9zc2liaWxlIHNjcml2ZXJlICVzIgogCi0jOiBidWlsdGluL21lcmdlLmM6Nzg5CisjOiBidWlsdGluL21lcmdlLmM6Nzg2CiAjLCBjLWZvcm1hdAogbXNnaWQgIkNvdWxkIG5vdCByZWFkIGZyb20gJyVzJyIKIG1zZ3N0ciAiTm9uIMOoIHN0YXRvIHBvc3NpYmlsZSBsZWdnZXJlIGRhICclcyciCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzo3OTgKKyM6IGJ1aWx0aW4vbWVyZ2UuYzo3OTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiTm90IGNvbW1pdHRpbmcgbWVyZ2U7IHVzZSAnZ2l0IGNvbW1pdCcgdG8gY29tcGxldGUgdGhlIG1lcmdlLlxuIgogbXNnc3RyICIiCiAiTm9uIGVzZWd1byBpbCBjb21taXQgZGVsIG1lcmdlOyB1c2EgJ2dpdCBjb21taXQnIHBlciBjb21wbGV0YXJlIGlsIG1lcmdlLlxuIgogCi0jOiBidWlsdGluL21lcmdlLmM6ODA0CisjOiBidWlsdGluL21lcmdlLmM6ODAxCiBtc2dpZCAiIgogIlBsZWFzZSBlbnRlciBhIGNvbW1pdCBtZXNzYWdlIHRvIGV4cGxhaW4gd2h5IHRoaXMgbWVyZ2UgaXMgbmVjZXNzYXJ5LFxuIgogImVzcGVjaWFsbHkgaWYgaXQgbWVyZ2VzIGFuIHVwZGF0ZWQgdXBzdHJlYW0gaW50byBhIHRvcGljIGJyYW5jaC5cbiIKQEAgLTE1MzUwLDExICsxNTQzNiwxMSBAQAogImFnZ2lvcm5hdG8gaW4gdW4gdG9waWMgYnJhbmNoLlxuIgogIlxuIgogCi0jOiBidWlsdGluL21lcmdlLmM6ODA5CisjOiBidWlsdGluL21lcmdlLmM6ODA2CiBtc2dpZCAiQW4gZW1wdHkgbWVzc2FnZSBhYm9ydHMgdGhlIGNvbW1pdC5cbiIKIG1zZ3N0ciAiVW4gbWVzc2FnZ2lvIHZ1b3RvIGludGVycm9tcGVyw6AgaWwgY29tbWl0LlxuIgogCi0jOiBidWlsdGluL21lcmdlLmM6ODEyCisjOiBidWlsdGluL21lcmdlLmM6ODA5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJMaW5lcyBzdGFydGluZyB3aXRoICclYycgd2lsbCBiZSBpZ25vcmVkLCBhbmQgYW4gZW1wdHkgbWVzc2FnZSBhYm9ydHNcbiIKQEAgLTE1MzYzLDc0ICsxNTQ0OSw3NCBAQAogIkxlIHJpZ2hlIGNoZSBpbml6aWFubyBjb24gJyVjJyBzYXJhbm5vIGlnbm9yYXRlIGUgdW4gbWVzc2FnZ2lvIHZ1b3RvXG4iCiAiaW50ZXJyb21wZXLDoCBpbCBjb21taXQuXG4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzo4NTMKKyM6IGJ1aWx0aW4vbWVyZ2UuYzo4NjIKIG1zZ2lkICJFbXB0eSBjb21taXQgbWVzc2FnZS4iCiBtc2dzdHIgIk1lc3NhZ2dpbyBkaSBjb21taXQgdnVvdG8uIgogCi0jOiBidWlsdGluL21lcmdlLmM6ODcyCisjOiBidWlsdGluL21lcmdlLmM6ODc3CiAjLCBjLWZvcm1hdAogbXNnaWQgIldvbmRlcmZ1bC5cbiIKIG1zZ3N0ciAiU3BsZW5kaWRvLlxuIgogCi0jOiBidWlsdGluL21lcmdlLmM6OTMzCisjOiBidWlsdGluL21lcmdlLmM6OTM4CiAjLCBjLWZvcm1hdAogbXNnaWQgIkF1dG9tYXRpYyBtZXJnZSBmYWlsZWQ7IGZpeCBjb25mbGljdHMgYW5kIHRoZW4gY29tbWl0IHRoZSByZXN1bHQuXG4iCiBtc2dzdHIgIiIKICJNZXJnZSBhdXRvbWF0aWNvIGZhbGxpdG87IHJpc29sdmkgaSBjb25mbGl0dGkgZWQgZXNlZ3VpIGlsIGNvbW1pdFxuIgogImRlbCByaXN1bHRhdG8uXG4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzo5NzIKKyM6IGJ1aWx0aW4vbWVyZ2UuYzo5NzcKIG1zZ2lkICJObyBjdXJyZW50IGJyYW5jaC4iCiBtc2dzdHIgIk5lc3N1biBicmFuY2ggY29ycmVudGUuIgogCi0jOiBidWlsdGluL21lcmdlLmM6OTc0CisjOiBidWlsdGluL21lcmdlLmM6OTc5CiBtc2dpZCAiTm8gcmVtb3RlIGZvciB0aGUgY3VycmVudCBicmFuY2guIgogbXNnc3RyICJOZXNzdW4gcmVtb3RlIHBlciBpbCBicmFuY2ggY29ycmVudGUuIgogCi0jOiBidWlsdGluL21lcmdlLmM6OTc2CisjOiBidWlsdGluL21lcmdlLmM6OTgxCiBtc2dpZCAiTm8gZGVmYXVsdCB1cHN0cmVhbSBkZWZpbmVkIGZvciB0aGUgY3VycmVudCBicmFuY2guIgogbXNnc3RyICJOZXNzdW4gdXBzdHJlYW0gZGkgZGVmYXVsdCBkZWZpbml0byBwZXIgaWwgYnJhbmNoIGNvcnJlbnRlLiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjk4MQorIzogYnVpbHRpbi9tZXJnZS5jOjk4NgogIywgYy1mb3JtYXQKIG1zZ2lkICJObyByZW1vdGUtdHJhY2tpbmcgYnJhbmNoIGZvciAlcyBmcm9tICVzIgogbXNnc3RyICJOZXNzdW4gYnJhbmNoIGNoZSB0cmFjY2kgdW4gcmVtb3RvIHBlciAlcyBkYSAlcyIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjEwMzgKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxMDQzCiAjLCBjLWZvcm1hdAogbXNnaWQgIkJhZCB2YWx1ZSAnJXMnIGluIGVudmlyb25tZW50ICclcyciCiBtc2dzdHIgIlZhbG9yZSBlcnJhdG8gJyVzJyBuZWxsJ2FtYmllbnRlICclcyciCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxMTQxCisjOiBidWlsdGluL21lcmdlLmM6MTE0NgogIywgYy1mb3JtYXQKIG1zZ2lkICJub3Qgc29tZXRoaW5nIHdlIGNhbiBtZXJnZSBpbiAlczogJXMiCiBtc2dzdHIgIm5vbiDDqCBxdWFsY29zYSBkaSBjdWkgcG9zc2lhbW8gZXNlZ3VpcmUgaWwgbWVyZ2UgaW4gJXM6ICVzIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTE3NQorIzogYnVpbHRpbi9tZXJnZS5jOjExODAKIG1zZ2lkICJub3Qgc29tZXRoaW5nIHdlIGNhbiBtZXJnZSIKIG1zZ3N0ciAibm9uIMOoIHF1YWxjb3NhIGRpIGN1aSBwb3NzaWFtbyBlc2VndWlyZSBpbCBtZXJnZSIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjEyNzgKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxMjgzCiBtc2dpZCAiLS1hYm9ydCBleHBlY3RzIG5vIGFyZ3VtZW50cyIKIG1zZ3N0ciAiLS1hYm9ydCBub24gcmljaGllZGUgYXJnb21lbnRpIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTI4MgorIzogYnVpbHRpbi9tZXJnZS5jOjEyODcKIG1zZ2lkICJUaGVyZSBpcyBubyBtZXJnZSB0byBhYm9ydCAoTUVSR0VfSEVBRCBtaXNzaW5nKS4iCiBtc2dzdHIgIk5vbiBjJ8OoIG5lc3N1biBtZXJnZSBkYSBpbnRlcnJvbXBlcmUgKE1FUkdFX0hFQUQgbWFuY2FudGUpLiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjEyOTEKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxMjk2CiBtc2dpZCAiLS1xdWl0IGV4cGVjdHMgbm8gYXJndW1lbnRzIgogbXNnc3RyICItLXF1aXQgbm9uIHJpY2hpZWRlIGFyZ29tZW50aSIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjEzMDQKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzA5CiBtc2dpZCAiLS1jb250aW51ZSBleHBlY3RzIG5vIGFyZ3VtZW50cyIKIG1zZ3N0ciAiLS1jb250aW51ZSBub24gcmljaGllZGUgYXJnb21lbnRpIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTMwOAorIzogYnVpbHRpbi9tZXJnZS5jOjEzMTMKIG1zZ2lkICJUaGVyZSBpcyBubyBtZXJnZSBpbiBwcm9ncmVzcyAoTUVSR0VfSEVBRCBtaXNzaW5nKS4iCiBtc2dzdHIgIk5vbiBjJ8OoIG5lc3N1biBtZXJnZSBpbiBjb3JzbyAoTUVSR0VfSEVBRCBtYW5jYW50ZSkuIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTMyNAorIzogYnVpbHRpbi9tZXJnZS5jOjEzMjkKIG1zZ2lkICIiCiAiWW91IGhhdmUgbm90IGNvbmNsdWRlZCB5b3VyIG1lcmdlIChNRVJHRV9IRUFEIGV4aXN0cykuXG4iCiAiUGxlYXNlLCBjb21taXQgeW91ciBjaGFuZ2VzIGJlZm9yZSB5b3UgbWVyZ2UuIgpAQCAtMTU0MzgsNyArMTU1MjQsNyBAQAogIk5vbiBoYWkgY29uY2x1c28gaWwgbWVyZ2UgKE1FUkdFX0hFQUQgZXNpc3RlKS5cbiIKICJFc2VndWkgaWwgY29tbWl0IGRlbGxlIG1vZGlmaWNoZSBwcmltYSBkaSBlc2VndWlyZSBpbCBtZXJnZS4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzMxCisjOiBidWlsdGluL21lcmdlLmM6MTMzNgogbXNnaWQgIiIKICJZb3UgaGF2ZSBub3QgY29uY2x1ZGVkIHlvdXIgY2hlcnJ5LXBpY2sgKENIRVJSWV9QSUNLX0hFQUQgZXhpc3RzKS5cbiIKICJQbGVhc2UsIGNvbW1pdCB5b3VyIGNoYW5nZXMgYmVmb3JlIHlvdSBtZXJnZS4iCkBAIC0xNTQ0Niw5NiArMTU1MzIsOTYgQEAKICJOb24gaGFpIGNvbmNsdXNvIGlsIGNoZXJyeS1waWNrIChDSEVSUllfUElDS19IRUFEIGVzaXN0ZSkuXG4iCiAiRXNlZ3VpIGlsIGNvbW1pdCBkZWxsZSBtb2RpZmljaGUgcHJpbWEgZGkgZXNlZ3VpcmUgaWwgbWVyZ2UuIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTMzNAorIzogYnVpbHRpbi9tZXJnZS5jOjEzMzkKIG1zZ2lkICJZb3UgaGF2ZSBub3QgY29uY2x1ZGVkIHlvdXIgY2hlcnJ5LXBpY2sgKENIRVJSWV9QSUNLX0hFQUQgZXhpc3RzKS4iCiBtc2dzdHIgIklsIGNoZXJyeS1waWNrIG5vbiDDqCBzdGF0byBjb25jbHVzbyAoQ0hFUlJZX1BJQ0tfSEVBRCBlc2lzdGUpLiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjEzNDgKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzUzCiBtc2dpZCAiWW91IGNhbm5vdCBjb21iaW5lIC0tc3F1YXNoIHdpdGggLS1uby1mZi4iCiBtc2dzdHIgIk5vbiDDqCBwb3NzaWJpbGUgY29tYmluYXJlIC0tc3F1YXNoIGNvbiAtLW5vLWZmLiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjEzNTAKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzU1CiBtc2dpZCAiWW91IGNhbm5vdCBjb21iaW5lIC0tc3F1YXNoIHdpdGggLS1jb21taXQuIgogbXNnc3RyICJOb24gw6ggcG9zc2liaWxlIGNvbWJpbmFyZSAtLXNxdWFzaCBjb24gLS1jb21taXQuIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTM2NgorIzogYnVpbHRpbi9tZXJnZS5jOjEzNzEKIG1zZ2lkICJObyBjb21taXQgc3BlY2lmaWVkIGFuZCBtZXJnZS5kZWZhdWx0VG9VcHN0cmVhbSBub3Qgc2V0LiIKIG1zZ3N0ciAiTmVzc3VuIGNvbW1pdCBzcGVjaWZpY2F0byBlIG1lcmdlLmRlZmF1bHRUb1Vwc3RyZWFtIG5vbiBpbXBvc3RhdG8uIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTM4MworIzogYnVpbHRpbi9tZXJnZS5jOjEzODgKIG1zZ2lkICJTcXVhc2ggY29tbWl0IGludG8gZW1wdHkgaGVhZCBub3Qgc3VwcG9ydGVkIHlldCIKIG1zZ3N0ciAiTG8gc3F1YXNoIGRpIHVuIGNvbW1pdCBpbiB1bidoZWFkIHZ1b3RhIG5vbiDDqCBhbmNvcmEgc3VwcG9ydGF0byIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjEzODUKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzkwCiBtc2dpZCAiTm9uLWZhc3QtZm9yd2FyZCBjb21taXQgZG9lcyBub3QgbWFrZSBzZW5zZSBpbnRvIGFuIGVtcHR5IGhlYWQiCiBtc2dzdHIgIlVuIGNvbW1pdCBub24gZmFzdCBmb3J3YXJkIG5vbiBoYSBzZW5zbyBpbiB1bidoZWFkIHZ1b3RhIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTM5MAorIzogYnVpbHRpbi9tZXJnZS5jOjEzOTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgLSBub3Qgc29tZXRoaW5nIHdlIGNhbiBtZXJnZSIKIG1zZ3N0ciAiJXMgLSBub24gw6ggcXVhbGNvc2EgcGVyIGN1aSBwb3NzaWFtbyBlc2VndWlyZSBpbCBtZXJnZSIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjEzOTIKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzk3CiBtc2dpZCAiQ2FuIG1lcmdlIG9ubHkgZXhhY3RseSBvbmUgY29tbWl0IGludG8gZW1wdHkgaGVhZCIKIG1zZ3N0ciAiU2kgcHXDsiBlc2VndWlyZSBzb2xvIGlsIG1lcmdlIGRpIHVubyBlIHVuIHNvbG8gY29tbWl0IGluIHVuJ2hlYWQgdnVvdGEiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxNDcxCisjOiBidWlsdGluL21lcmdlLmM6MTQ3NgogbXNnaWQgInJlZnVzaW5nIHRvIG1lcmdlIHVucmVsYXRlZCBoaXN0b3JpZXMiCiBtc2dzdHIgIm1pIHJpZml1dG8gZGkgZXNlZ3VpcmUgaWwgbWVyZ2UgZGkgY3Jvbm9sb2dpZSBub24gY29ycmVsYXRlIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTQ4MAorIzogYnVpbHRpbi9tZXJnZS5jOjE0ODUKIG1zZ2lkICJBbHJlYWR5IHVwIHRvIGRhdGUuIgogbXNnc3RyICJHacOgIGFnZ2lvcm5hdG8uIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTQ5MAorIzogYnVpbHRpbi9tZXJnZS5jOjE0OTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiVXBkYXRpbmcgJXMuLiVzXG4iCiBtc2dzdHIgIkFnZ2lvcm5hbWVudG8gZGkgJXMuLiVzXG4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxNTMyCisjOiBidWlsdGluL21lcmdlLmM6MTUzNwogIywgYy1mb3JtYXQKIG1zZ2lkICJUcnlpbmcgcmVhbGx5IHRyaXZpYWwgaW4taW5kZXggbWVyZ2UuLi5cbiIKIG1zZ3N0ciAiUHJvdm8gY29uIHVuIG1lcmdlIHZlcmFtZW50ZSBiYW5hbGUgZGVudHJvIGwnaW5kaWNlLi4uXG4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxNTM5CisjOiBidWlsdGluL21lcmdlLmM6MTU0NAogIywgYy1mb3JtYXQKIG1zZ2lkICJOb3BlLlxuIgogbXNnc3RyICJOby5cbiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjE1NjQKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxNTY5CiBtc2dpZCAiQWxyZWFkeSB1cCB0byBkYXRlLiBZZWVhaCEiCiBtc2dzdHIgIkdpw6AgYWdnaW9ybmF0by4gT2ggc8OsISIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjE1NzAKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxNTc1CiBtc2dpZCAiTm90IHBvc3NpYmxlIHRvIGZhc3QtZm9yd2FyZCwgYWJvcnRpbmcuIgogbXNnc3RyICJGYXN0IGZvcndhcmQgbm9uIHBvc3NpYmlsZSwgaW50ZXJyb21wbyBsJ29wZXJhemlvbmUuIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTU5MyBidWlsdGluL21lcmdlLmM6MTY1OAorIzogYnVpbHRpbi9tZXJnZS5jOjE1OTggYnVpbHRpbi9tZXJnZS5jOjE2NjMKICMsIGMtZm9ybWF0CiBtc2dpZCAiUmV3aW5kaW5nIHRoZSB0cmVlIHRvIHByaXN0aW5lLi4uXG4iCiBtc2dzdHIgIlJpcHJpc3Rpbm8gbCdhbGJlcm8gaW4gdW5vIHN0YXRvIHB1bGl0by4uLlxuIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTU5NworIzogYnVpbHRpbi9tZXJnZS5jOjE2MDIKICMsIGMtZm9ybWF0CiBtc2dpZCAiVHJ5aW5nIG1lcmdlIHN0cmF0ZWd5ICVzLi4uXG4iCiBtc2dzdHIgIlRlbnRhdGl2byBjb24gbGEgc3RyYXRlZ2lhIGRpIG1lcmdlICVzLi4uXG4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxNjQ5CisjOiBidWlsdGluL21lcmdlLmM6MTY1NAogIywgYy1mb3JtYXQKIG1zZ2lkICJObyBtZXJnZSBzdHJhdGVneSBoYW5kbGVkIHRoZSBtZXJnZS5cbiIKIG1zZ3N0ciAiTmVzc3VuYSBzdHJhdGVnaWEgZGkgbWVyZ2UgaGEgZ2VzdGl0byBpbCBtZXJnZS5cbiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjE2NTEKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxNjU2CiAjLCBjLWZvcm1hdAogbXNnaWQgIk1lcmdlIHdpdGggc3RyYXRlZ3kgJXMgZmFpbGVkLlxuIgogbXNnc3RyICJNZXJnZSBjb24gbGEgc3RyYXRlZ2lhICVzIGZhbGxpdG8uXG4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxNjYwCisjOiBidWlsdGluL21lcmdlLmM6MTY2NQogIywgYy1mb3JtYXQKIG1zZ2lkICJVc2luZyB0aGUgJXMgdG8gcHJlcGFyZSByZXNvbHZpbmcgYnkgaGFuZC5cbiIKIG1zZ3N0ciAiVXNvICVzIHBlciBwcmVwYXJhcmUgdW5hIHJpc29sdXppb25lIG1hbnVhbGUuXG4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxNjcyCisjOiBidWlsdGluL21lcmdlLmM6MTY3NwogIywgYy1mb3JtYXQKIG1zZ2lkICJBdXRvbWF0aWMgbWVyZ2Ugd2VudCB3ZWxsOyBzdG9wcGVkIGJlZm9yZSBjb21taXR0aW5nIGFzIHJlcXVlc3RlZFxuIgogbXNnc3RyICIiCkBAIC0xNTYyNCwzMyArMTU3MTAsMzMgQEAKIG1zZ2lkICJzZXQgbGFiZWxzIGZvciBmaWxlMS9vcmlnLWZpbGUvZmlsZTIiCiBtc2dzdHIgImltcG9zdGEgZXRpY2hldHRlIHBlciBmaWxlMS9maWxlIG9yaWdpbmFsZS9maWxlMiIKIAotIzogYnVpbHRpbi9tZXJnZS1yZWN1cnNpdmUuYzo0NgorIzogYnVpbHRpbi9tZXJnZS1yZWN1cnNpdmUuYzo0NwogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmtub3duIG9wdGlvbiAlcyIKIG1zZ3N0ciAib3B6aW9uZSBzY29ub3NjaXV0YSAlcyIKIAotIzogYnVpbHRpbi9tZXJnZS1yZWN1cnNpdmUuYzo1MgorIzogYnVpbHRpbi9tZXJnZS1yZWN1cnNpdmUuYzo1MwogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcGFyc2Ugb2JqZWN0ICclcyciCiBtc2dzdHIgImltcG9zc2liaWxlIGFuYWxpenphcmUgbCdvZ2dldHRvICclcyciCiAKLSM6IGJ1aWx0aW4vbWVyZ2UtcmVjdXJzaXZlLmM6NTYKKyM6IGJ1aWx0aW4vbWVyZ2UtcmVjdXJzaXZlLmM6NTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IGhhbmRsZSBtb3JlIHRoYW4gJWQgYmFzZS4gSWdub3JpbmcgJXMuIgogbXNnaWRfcGx1cmFsICJjYW5ub3QgaGFuZGxlIG1vcmUgdGhhbiAlZCBiYXNlcy4gSWdub3JpbmcgJXMuIgogbXNnc3RyWzBdICJpbXBvc3NpYmlsZSBnZXN0aXJlIHBpw7kgZGkgJWQgYmFzZS4gSWdub3JvICVzLiIKIG1zZ3N0clsxXSAiaW1wb3NzaWJpbGUgZ2VzdGlyZSBwacO5IGRpICVkIGJhc2kuIElnbm9ybyAlcy4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UtcmVjdXJzaXZlLmM6NjQKKyM6IGJ1aWx0aW4vbWVyZ2UtcmVjdXJzaXZlLmM6NjUKIG1zZ2lkICJub3QgaGFuZGxpbmcgYW55dGhpbmcgb3RoZXIgdGhhbiB0d28gaGVhZHMgbWVyZ2UuIgogbXNnc3RyICJub24gZ2VzdGlzY28gbnVsbGEgY2hlIG5vbiBzaWEgaWwgbWVyZ2UgZGkgZHVlIGhlYWQuIgogCi0jOiBidWlsdGluL21lcmdlLXJlY3Vyc2l2ZS5jOjcwIGJ1aWx0aW4vbWVyZ2UtcmVjdXJzaXZlLmM6NzIKKyM6IGJ1aWx0aW4vbWVyZ2UtcmVjdXJzaXZlLmM6NzQgYnVpbHRpbi9tZXJnZS1yZWN1cnNpdmUuYzo3NgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcmVzb2x2ZSByZWYgJyVzJyIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgcmlzb2x2ZXJlIGlsIHJpZmVyaW1lbnRvICclcyciCiAKLSM6IGJ1aWx0aW4vbWVyZ2UtcmVjdXJzaXZlLmM6NzgKKyM6IGJ1aWx0aW4vbWVyZ2UtcmVjdXJzaXZlLmM6ODIKICMsIGMtZm9ybWF0CiBtc2dpZCAiTWVyZ2luZyAlcyB3aXRoICVzXG4iCiBtc2dzdHIgIk1lcmdlIGRpICVzIGNvbiAlcyBpbiBjb3Jzb1xuIgpAQCAtMTU3OTQsNTIgKzE1ODgwLDUyIEBACiBtc2dpZCAiUmVuYW1pbmcgJXMgdG8gJXNcbiIKIG1zZ3N0ciAiUmlub21pbmF6aW9uZSBkaSAlcyBpbiAlcyBpbiBjb3Jzb1xuIgogCi0jOiBidWlsdGluL212LmM6Mjc3IGJ1aWx0aW4vcmVtb3RlLmM6NzE3IGJ1aWx0aW4vcmVwYWNrLmM6NTEwCisjOiBidWlsdGluL212LmM6Mjc3IGJ1aWx0aW4vcmVtb3RlLmM6NzE3IGJ1aWx0aW4vcmVwYWNrLmM6NTExCiAjLCBjLWZvcm1hdAogbXNnaWQgInJlbmFtaW5nICclcycgZmFpbGVkIgogbXNnc3RyICJyaW5vbWluYSBkaSAnJXMnIG5vbiByaXVzY2l0YSIKIAotIzogYnVpbHRpbi9uYW1lLXJldi5jOjM1MgorIzogYnVpbHRpbi9uYW1lLXJldi5jOjM1NgogbXNnaWQgImdpdCBuYW1lLXJldiBbPG9wdGlvbnM+XSA8Y29tbWl0Pi4uLiIKIG1zZ3N0ciAiZ2l0IG5hbWUtcmV2IFs8b3B6aW9uaT5dIDxjb21taXQ+Li4uIgogCi0jOiBidWlsdGluL25hbWUtcmV2LmM6MzUzCisjOiBidWlsdGluL25hbWUtcmV2LmM6MzU3CiBtc2dpZCAiZ2l0IG5hbWUtcmV2IFs8b3B0aW9ucz5dIC0tYWxsIgogbXNnc3RyICJnaXQgbmFtZS1yZXYgWzxvcHppb25pPl0gLS1hbGwiCiAKLSM6IGJ1aWx0aW4vbmFtZS1yZXYuYzozNTQKKyM6IGJ1aWx0aW4vbmFtZS1yZXYuYzozNTgKIG1zZ2lkICJnaXQgbmFtZS1yZXYgWzxvcHRpb25zPl0gLS1zdGRpbiIKIG1zZ3N0ciAiZ2l0IG5hbWUtcmV2IFs8b3B6aW9uaT5dIC0tc3RkaW4iCiAKLSM6IGJ1aWx0aW4vbmFtZS1yZXYuYzo0MTEKKyM6IGJ1aWx0aW4vbmFtZS1yZXYuYzo0MTUKIG1zZ2lkICJwcmludCBvbmx5IG5hbWVzIChubyBTSEEtMSkiCiBtc2dzdHIgInN0YW1wYSBzb2xvIGkgbm9taSAobm9uIGxvIFNIQS0xKSIKIAotIzogYnVpbHRpbi9uYW1lLXJldi5jOjQxMgorIzogYnVpbHRpbi9uYW1lLXJldi5jOjQxNgogbXNnaWQgIm9ubHkgdXNlIHRhZ3MgdG8gbmFtZSB0aGUgY29tbWl0cyIKIG1zZ3N0ciAidXNhIHNvbG8gdGFnIHBlciBkZW5vbWluYXJlIGkgY29tbWl0IgogCi0jOiBidWlsdGluL25hbWUtcmV2LmM6NDE0CisjOiBidWlsdGluL25hbWUtcmV2LmM6NDE4CiBtc2dpZCAib25seSB1c2UgcmVmcyBtYXRjaGluZyA8cGF0dGVybj4iCiBtc2dzdHIgInVzYSBzb2xvIGkgcmlmZXJpbWVudGkgY29ycmlzcG9uZGVudGkgYSA8cGF0dGVybj4iCiAKLSM6IGJ1aWx0aW4vbmFtZS1yZXYuYzo0MTYKKyM6IGJ1aWx0aW4vbmFtZS1yZXYuYzo0MjAKIG1zZ2lkICJpZ25vcmUgcmVmcyBtYXRjaGluZyA8cGF0dGVybj4iCiBtc2dzdHIgImlnbm9yYSBpIHJpZmVyaW1lbnRpIGNvcnJpc3BvbmRlbnRpIGEgPHBhdHRlcm4+IgogCi0jOiBidWlsdGluL25hbWUtcmV2LmM6NDE4CisjOiBidWlsdGluL25hbWUtcmV2LmM6NDIyCiBtc2dpZCAibGlzdCBhbGwgY29tbWl0cyByZWFjaGFibGUgZnJvbSBhbGwgcmVmcyIKIG1zZ3N0ciAiZWxlbmNhIHR1dHRpIGkgY29tbWl0IHJhZ2dpdW5naWJpbGkgZGEgdHV0dGkgaSByaWZlcmltZW50aSIKIAotIzogYnVpbHRpbi9uYW1lLXJldi5jOjQxOQorIzogYnVpbHRpbi9uYW1lLXJldi5jOjQyMwogbXNnaWQgInJlYWQgZnJvbSBzdGRpbiIKIG1zZ3N0ciAibGVnZ2kgZGFsbG8gc3RhbmRhcmQgaW5wdXQiCiAKLSM6IGJ1aWx0aW4vbmFtZS1yZXYuYzo0MjAKKyM6IGJ1aWx0aW4vbmFtZS1yZXYuYzo0MjQKIG1zZ2lkICJhbGxvdyB0byBwcmludCBgdW5kZWZpbmVkYCBuYW1lcyAoZGVmYXVsdCkiCiBtc2dzdHIgImNvbnNlbnRpIGRpIHN0YW1wYXJlIG5vbWkgYG5vbiBkZWZpbml0b2AgKGltcG9zdGF6aW9uZSBwcmVkZWZpbml0YSkiCiAKLSM6IGJ1aWx0aW4vbmFtZS1yZXYuYzo0MjYKKyM6IGJ1aWx0aW4vbmFtZS1yZXYuYzo0MzAKIG1zZ2lkICJkZXJlZmVyZW5jZSB0YWdzIGluIHRoZSBpbnB1dCAoaW50ZXJuYWwgdXNlKSIKIG1zZ3N0ciAiZGVyZWZlcmVuemlhIHRhZyBuZWxsJ2lucHV0ICh1c28gaW50ZXJubykiCiAKQEAgLTE2MjQzLDcgKzE2MzI5LDcgQEAKIG1zZ2lkICJyZWFkIG9iamVjdCBuYW1lcyBmcm9tIHRoZSBzdGFuZGFyZCBpbnB1dCIKIG1zZ3N0ciAibGVnZ2kgaSBub21pIGRlZ2xpIG9nZ2V0dGkgZGFsbG8gc3RhbmRhcmQgaW5wdXQiCiAKLSM6IGJ1aWx0aW4vbm90ZXMuYzo5NTQgYnVpbHRpbi9wcnVuZS5jOjEzMCBidWlsdGluL3dvcmt0cmVlLmM6MTY1CisjOiBidWlsdGluL25vdGVzLmM6OTU0IGJ1aWx0aW4vcHJ1bmUuYzoxMzAgYnVpbHRpbi93b3JrdHJlZS5jOjE2NAogbXNnaWQgImRvIG5vdCByZW1vdmUsIHNob3cgb25seSIKIG1zZ3N0ciAibm9uIHJpbXVvdmVyZSwgbGltaXRhdGkgYSB2aXN1YWxpenphcmUiCiAKQEAgLTE2MjU5LDcgKzE2MzQ1LDcgQEAKIG1zZ2lkICJ1c2Ugbm90ZXMgZnJvbSA8bm90ZXMtcmVmPiIKIG1zZ3N0ciAidXNhIGxlIG5vdGUgaW4gPHJpZmVyaW1lbnRvIG5vdGU+IgogCi0jOiBidWlsdGluL25vdGVzLmM6MTAzNCBidWlsdGluL3N0YXNoLmM6MTU5OAorIzogYnVpbHRpbi9ub3Rlcy5jOjEwMzQgYnVpbHRpbi9zdGFzaC5jOjE2MDcKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5rbm93biBzdWJjb21tYW5kOiAlcyIKIG1zZ3N0ciAic290dG9jb21hbmRvIHNjb25vc2NpdXRvOiAlcyIKQEAgLTE2MzM2LDcxICsxNjQyMiw3MSBAQAogbXNnaWQgIndyb3RlICU8UFJJdTMyPiBvYmplY3RzIHdoaWxlIGV4cGVjdGluZyAlPFBSSXUzMj4iCiBtc2dzdHIgInNjcml0dGkgJTxQUkl1MzI+IG9nZ2V0dGkgcXVhbmRvIG1lIG5lIGF0dGVuZGV2byAlPFBSSXUzMj4iCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MTE2NgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoxMTY0CiBtc2dpZCAiZGlzYWJsaW5nIGJpdG1hcCB3cml0aW5nLCBhcyBzb21lIG9iamVjdHMgYXJlIG5vdCBiZWluZyBwYWNrZWQiCiBtc2dzdHIgIiIKICJkaXNhYmlsaXRvIGxhIHNjcml0dHVyYSBkZWxsZSBiaXRtYXAgcGVyY2jDqSBhbGN1bmkgb2dnZXR0aSBub24gc2FyYW5ubyAiCiAic290dG9wb3N0aSBhIHBhY2siCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MTU5NworIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoxNTkyCiAjLCBjLWZvcm1hdAogbXNnaWQgImRlbHRhIGJhc2Ugb2Zmc2V0IG92ZXJmbG93IGluIHBhY2sgZm9yICVzIgogbXNnc3RyICJvdmVyZmxvdyBkZWxsJ29mZnNldCBiYXNlIGRlbCBkZWx0YSBuZWwgcGFjayBwZXIgJXMiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MTYwNgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoxNjAxCiAjLCBjLWZvcm1hdAogbXNnaWQgImRlbHRhIGJhc2Ugb2Zmc2V0IG91dCBvZiBib3VuZCBmb3IgJXMiCiBtc2dzdHIgIm9mZnNldCBiYXNlIGRlbCBkZWx0YSBmdW9yaSBkYWxsJ2ludGVydmFsbG8gY29uc2VudGl0byBwZXIgJXMiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MTg3NQorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoxODcwCiBtc2dpZCAiQ291bnRpbmcgb2JqZWN0cyIKIG1zZ3N0ciAiQ29udGVnZ2lvIGRlZ2xpIG9nZ2V0dGkgaW4gY29yc28iCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjAwNQorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyMDAwCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBnZXQgc2l6ZSBvZiAlcyIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgcmVjdXBlcmFyZSBsZSBkaW1lbnNpb25pIGRpICVzIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjIwMjAKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjAxNQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gcGFyc2Ugb2JqZWN0IGhlYWRlciBvZiAlcyIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgYW5hbGl6emFyZSBsJ2ludGVzdGF6aW9uZSBvZ2dldHRvIGRpICVzIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjIwOTAgYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyMTA2Ci0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjIxMTYKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjA4NSBidWlsdGluL3BhY2stb2JqZWN0cy5jOjIxMDEKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjExMQogIywgYy1mb3JtYXQKIG1zZ2lkICJvYmplY3QgJXMgY2Fubm90IGJlIHJlYWQiCiBtc2dzdHIgImltcG9zc2liaWxlIGxlZ2dlcmUgbCdvZ2dldHRvICVzIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjIwOTMgYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyMTIwCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjIwODggYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyMTE1CiAjLCBjLWZvcm1hdAogbXNnaWQgIm9iamVjdCAlcyBpbmNvbnNpc3RlbnQgb2JqZWN0IGxlbmd0aCAoJTxQUkl1TUFYPiB2cyAlPFBSSXVNQVg+KSIKIG1zZ3N0ciAiIgogIm9nZ2V0dG8gJXM6IGx1bmdoZXp6YSBvZ2dldHRvIGluY29uc2lzdGVudGUgKCU8UFJJdU1BWD4gY29udHJvICU8UFJJdU1BWD4pIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjIxMzAKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjEyNQogbXNnaWQgInN1Ym9wdGltYWwgcGFjayAtIG91dCBvZiBtZW1vcnkiCiBtc2dzdHIgInBhY2sgc3Vib3R0aW1vIC0gbWVtb3JpYSBlc2F1cml0YSIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNDU2CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI0NDAKICMsIGMtZm9ybWF0CiBtc2dpZCAiRGVsdGEgY29tcHJlc3Npb24gdXNpbmcgdXAgdG8gJWQgdGhyZWFkcyIKIG1zZ3N0ciAiQ29tcHJlc3Npb25lIGRlbHRhIGluIGNvcnNvLCB1c28gZmlubyBhICVkIHRocmVhZCIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNTg4CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI1NzIKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHBhY2sgb2JqZWN0cyByZWFjaGFibGUgZnJvbSB0YWcgJXMiCiBtc2dzdHIgImltcG9zc2liaWxlIGVzZWd1aXJlIGlsIHBhY2sgZGVnbGkgb2dnZXR0aSByYWdnaXVuZ2liaWxpIGRhbCB0YWcgJXMiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjY3NQorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNjU5CiBtc2dpZCAiQ29tcHJlc3Npbmcgb2JqZWN0cyIKIG1zZ3N0ciAiQ29tcHJlc3Npb25lIG9nZ2V0dGkgaW4gY29yc28iCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjY4MQorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNjY1CiBtc2dpZCAiaW5jb25zaXN0ZW5jeSB3aXRoIGRlbHRhIGNvdW50IgogbXNnc3RyICJpbmNvbnNpc3RlbnphIGNvbiBpbCBudW1lcm8gZGVpIGRlbHRhIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI3NjIKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6Mjc0MgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiZXhwZWN0ZWQgZWRnZSBvYmplY3QgSUQsIGdvdCBnYXJiYWdlOlxuIgpAQCAtMTY0MDksNyArMTY0OTUsNyBAQAogImF0dGVzbyBJRCBvZ2dldHRvIGFyY28sIHJpY2V2dXRpIGRhdGkgZXJyYXRpOlxuIgogIiAlcyIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNzY4CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI3NDgKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogImV4cGVjdGVkIG9iamVjdCBJRCwgZ290IGdhcmJhZ2U6XG4iCkBAIC0xNjQxOCwyNTEgKzE2NTA0LDI1MSBAQAogImF0dGVzbyBJRCBvZ2dldHRvLCByaWNldnV0aSBkYXRpIGVycmF0aTpcbiIKICIgJXMiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6Mjg2NgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyODQ2CiBtc2dpZCAiaW52YWxpZCB2YWx1ZSBmb3IgLS1taXNzaW5nIgogbXNnc3RyICJ2YWxvcmUgbm9uIHZhbGlkbyBwZXIgLS1taXNzaW5nIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI5MjUgYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMDMzCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI5MDUgYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMDEzCiBtc2dpZCAiY2Fubm90IG9wZW4gcGFjayBpbmRleCIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgYXByaXJlIGwnaW5kaWNlIHBhY2siCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6Mjk1NgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyOTM2CiAjLCBjLWZvcm1hdAogbXNnaWQgImxvb3NlIG9iamVjdCBhdCAlcyBjb3VsZCBub3QgYmUgZXhhbWluZWQiCiBtc2dzdHIgImltcG9zc2liaWxlIGVzYW1pbmFyZSBsJ29nZ2V0dG8gc2Npb2x0byAlcyIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMDQxCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMwMjEKIG1zZ2lkICJ1bmFibGUgdG8gZm9yY2UgbG9vc2Ugb2JqZWN0IgogbXNnc3RyICJpbXBvc3NpYmlsZSBmb3J6YXJlIGwnb2dnZXR0byBzY2lvbHRvIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMxMzMKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzExMwogIywgYy1mb3JtYXQKIG1zZ2lkICJub3QgYSByZXYgJyVzJyIKIG1zZ3N0ciAiJyVzJyBub24gw6ggdW5hIHJldmlzaW9uZSIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMTM2CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMxMTYKICMsIGMtZm9ybWF0CiBtc2dpZCAiYmFkIHJldmlzaW9uICclcyciCiBtc2dzdHIgInJldmlzaW9uZSAnJXMnIGVycmF0YSIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMTYxCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMxNDEKIG1zZ2lkICJ1bmFibGUgdG8gYWRkIHJlY2VudCBvYmplY3RzIgogbXNnc3RyICJpbXBvc3NpYmlsZSBhZ2dpdW5nZXJlIGdsaSBvZ2dldHRpIHJlY2VudGkiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzIxNAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMTk0CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuc3VwcG9ydGVkIGluZGV4IHZlcnNpb24gJXMiCiBtc2dzdHIgInZlcnNpb25lICVzIGRpIGluZGV4IG5vbiBzdXBwb3J0YXRhIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyMTgKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzE5OAogIywgYy1mb3JtYXQKIG1zZ2lkICJiYWQgaW5kZXggdmVyc2lvbiAnJXMnIgogbXNnc3RyICJ2ZXJzaW9uZSAnJXMnIGRpIGluZGV4IGVycmF0YSIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjQ4CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyMjgKIG1zZ2lkICJkbyBub3Qgc2hvdyBwcm9ncmVzcyBtZXRlciIKIG1zZ3N0ciAibm9uIHZpc3VhbGl6emFyZSBsYSBiYXJyYSBkaSBhdmFuemFtZW50byIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjUwCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyMzAKIG1zZ2lkICJzaG93IHByb2dyZXNzIG1ldGVyIgogbXNnc3RyICJ2aXN1YWxpenphIGxhIGJhcnJhIGRpIGF2YW56YW1lbnRvIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNTIKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzIzMgogbXNnaWQgInNob3cgcHJvZ3Jlc3MgbWV0ZXIgZHVyaW5nIG9iamVjdCB3cml0aW5nIHBoYXNlIgogbXNnc3RyICIiCiAidmlzdWFsaXp6YSBsYSBiYXJyYSBkaSBhdmFuemFtZW50byBkdXJhbnRlIGxhIGZhc2UgZGkgc2NyaXR0dXJhIG9nZ2V0dGkiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI1NQorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjM1CiBtc2dpZCAic2ltaWxhciB0byAtLWFsbC1wcm9ncmVzcyB3aGVuIHByb2dyZXNzIG1ldGVyIGlzIHNob3duIgogbXNnc3RyICJzaW1pbGUgYSAtLWFsbC1wcm9ncmVzcyBxdWFuZG8gw6ggdmlzdWFsaXp6YXRhIGxhIGJhcnJhIGRpIGF2YW56YW1lbnRvIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNTYKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzIzNgogbXNnaWQgIjx2ZXJzaW9uPlssPG9mZnNldD5dIgogbXNnc3RyICI8dmVyc2lvbmU+Wyw8b2Zmc2V0Pl0iCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI1NworIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjM3CiBtc2dpZCAid3JpdGUgdGhlIHBhY2sgaW5kZXggZmlsZSBpbiB0aGUgc3BlY2lmaWVkIGlkeCBmb3JtYXQgdmVyc2lvbiIKIG1zZ3N0ciAic2NyaXZpIGlsIGZpbGUgaW5kaWNlIHBhY2sgdXNhbmRvIGxhIHZlcnNpb25lIGZvcm1hdG8gaWR4IHNwZWNpZmljYXRhIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNjAKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI0MAogbXNnaWQgIm1heGltdW0gc2l6ZSBvZiBlYWNoIG91dHB1dCBwYWNrIGZpbGUiCiBtc2dzdHIgImRpbWVuc2lvbmUgbWFzc2ltYSBkaSBvZ25pIGZpbGUgcGFjayBpbiBvdXRwdXQiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI2MgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjQyCiBtc2dpZCAiaWdub3JlIGJvcnJvd2VkIG9iamVjdHMgZnJvbSBhbHRlcm5hdGUgb2JqZWN0IHN0b3JlIgogbXNnc3RyICJpZ25vcmEgZ2xpIG9nZ2V0dGkgcHJlc2kgaW4gcHJlc3RpdG8gZGFsbG8gc3RvcmUgb2dnZXR0aSBhbHRlcm5hdGl2byIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjY0CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNDQKIG1zZ2lkICJpZ25vcmUgcGFja2VkIG9iamVjdHMiCiBtc2dzdHIgImlnbm9yYSBnbGkgb2dnZXR0aSBzb3R0b3Bvc3RpIGEgcGFjayIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjY2CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNDYKIG1zZ2lkICJsaW1pdCBwYWNrIHdpbmRvdyBieSBvYmplY3RzIgogbXNnc3RyICJsaW1pdGEgbGEgZmluZXN0cmEgZGkgcGFjayBhbCBudW1lcm8gZGkgb2dnZXR0aSBzcGVjaWZpY2F0byIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjY4CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNDgKIG1zZ2lkICJsaW1pdCBwYWNrIHdpbmRvdyBieSBtZW1vcnkgaW4gYWRkaXRpb24gdG8gb2JqZWN0IGxpbWl0IgogbXNnc3RyICIiCiAibGltaXRhIGxhIGZpbmVzdHJhIGRpIHBhY2sgYWxsYSBtZW1vcmlhIHNwZWNpZmljYXRhIGluIGFnZ2l1bnRhIGFsIGxpbWl0ZSAiCiAic3VnbGkgb2dnZXR0aSIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjcwCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNTAKIG1zZ2lkICJtYXhpbXVtIGxlbmd0aCBvZiBkZWx0YSBjaGFpbiBhbGxvd2VkIGluIHRoZSByZXN1bHRpbmcgcGFjayIKIG1zZ3N0ciAibHVuZ2hlenphIG1hc3NpbWEgZGVsbGEgY2F0ZW5hIGRpIGRlbHRhIGNvbnNlbnRpdGEgbmVsIHBhY2sgcmlzdWx0YW50ZSIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjcyCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNTIKIG1zZ2lkICJyZXVzZSBleGlzdGluZyBkZWx0YXMiCiBtc2dzdHIgInJpdXNhIGkgZGVsdGEgZXNpc3RlbnRpIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNzQKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI1NAogbXNnaWQgInJldXNlIGV4aXN0aW5nIG9iamVjdHMiCiBtc2dzdHIgInJpdXNhIGdsaSBvZ2dldHRpIGVzaXN0ZW50aSIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjc2CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNTYKIG1zZ2lkICJ1c2UgT0ZTX0RFTFRBIG9iamVjdHMiCiBtc2dzdHIgInVzYSBvZ2dldHRpIE9GU19ERUxUQSIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjc4CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNTgKIG1zZ2lkICJ1c2UgdGhyZWFkcyB3aGVuIHNlYXJjaGluZyBmb3IgYmVzdCBkZWx0YSBtYXRjaGVzIgogbXNnc3RyICIiCiAidXNhIHBpw7kgdGhyZWFkIGR1cmFudGUgbGEgcmljZXJjYSBkZWxsZSBtaWdsaW9yaSBjb3JyaXNwb25kZW56ZSBwZXIgaSBkZWx0YSIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjgwCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNjAKIG1zZ2lkICJkbyBub3QgY3JlYXRlIGFuIGVtcHR5IHBhY2sgb3V0cHV0IgogbXNnc3RyICJub24gY3JlYXJlIHVuIG91dHB1dCBwYWNrIHZ1b3RvIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyODIKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI2MgogbXNnaWQgInJlYWQgcmV2aXNpb24gYXJndW1lbnRzIGZyb20gc3RhbmRhcmQgaW5wdXQiCiBtc2dzdHIgImxlZ2dpIGdsaSBhcmdvbWVudGkgcmV2aXNpb25lIGRhbGxvIHN0YW5kYXJkIGlucHV0IgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyODQKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI2NAogbXNnaWQgImxpbWl0IHRoZSBvYmplY3RzIHRvIHRob3NlIHRoYXQgYXJlIG5vdCB5ZXQgcGFja2VkIgogbXNnc3RyICJsaW1pdGEgZ2xpIG9nZ2V0dGkgYSBxdWVsbGkgbm9uIGFuY29yYSBzb3R0b3Bvc3RpIGEgcGFjayIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjg3CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNjcKIG1zZ2lkICJpbmNsdWRlIG9iamVjdHMgcmVhY2hhYmxlIGZyb20gYW55IHJlZmVyZW5jZSIKIG1zZ3N0ciAiaW5jbHVkaSBnbGkgb2dnZXR0aSByYWdnaXVuZ2liaWxpIGRhIHF1YWx1bnF1ZSByaWZlcmltZW50byIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjkwCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNzAKIG1zZ2lkICJpbmNsdWRlIG9iamVjdHMgcmVmZXJyZWQgYnkgcmVmbG9nIGVudHJpZXMiCiBtc2dzdHIgImluY2x1ZGkgZ2xpIG9nZ2V0dGkgcmVmZXJlbnppYXRpIGRhIHZvY2kgZGVsIGxvZyByaWZlcmltZW50aSIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjkzCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNzMKIG1zZ2lkICJpbmNsdWRlIG9iamVjdHMgcmVmZXJyZWQgdG8gYnkgdGhlIGluZGV4IgogbXNnc3RyICJpbmNsdWRpIGdsaSBvZ2dldHRpIHJlZmVyZW56aWF0aSBkYWxsJ2luZGljZSIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjk2CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNzYKIG1zZ2lkICJvdXRwdXQgcGFjayB0byBzdGRvdXQiCiBtc2dzdHIgImludmlhIGlsIHBhY2sgaW4gb3V0cHV0IHN1bGxvIHN0YW5kYXJkIG91dHB1dCIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjk4CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNzgKIG1zZ2lkICJpbmNsdWRlIHRhZyBvYmplY3RzIHRoYXQgcmVmZXIgdG8gb2JqZWN0cyB0byBiZSBwYWNrZWQiCiBtc2dzdHIgIiIKICJpbmNsdWRpIGdsaSBvZ2dldHRpIHRhZyBjaGUgZmFubm8gcmlmZXJpbWVudG8gYWdsaSBvZ2dldHRpIGRhIHNvdHRvcG9ycmUgYSAiCiAicGFjayIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzAwCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyODAKIG1zZ2lkICJrZWVwIHVucmVhY2hhYmxlIG9iamVjdHMiCiBtc2dzdHIgIm1hbnRpZW5pIGdsaSBvZ2dldHRpIG5vbiByYWdnaXVuZ2liaWxpIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMDIKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI4MgogbXNnaWQgInBhY2sgbG9vc2UgdW5yZWFjaGFibGUgb2JqZWN0cyIKIG1zZ3N0ciAiZXNlZ3VpIGlsIHBhY2sgZGVnbGkgb2dnZXR0aSBub24gcmFnZ2l1bmdpYmlsaSBzY2lvbHRpIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMDQKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI4NAogbXNnaWQgInVucGFjayB1bnJlYWNoYWJsZSBvYmplY3RzIG5ld2VyIHRoYW4gPHRpbWU+IgogbXNnc3RyICJkZWNvbXByaW1pIGdsaSBvZ2dldHRpIG5vbiByYWdnaXVuZ2liaWxpIHBpw7kgcmVjZW50aSBkaSA8dGVtcG8+IgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMDcKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI4NwogbXNnaWQgInVzZSB0aGUgc3BhcnNlIHJlYWNoYWJpbGl0eSBhbGdvcml0aG0iCiBtc2dzdHIgInVzYSBsJ2FsZ29yaXRtbyBkaSByYWdnaXVuZ2liaWxpdMOgIHNwYXJzZSIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzA5CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyODkKIG1zZ2lkICJjcmVhdGUgdGhpbiBwYWNrcyIKIG1zZ3N0ciAiY3JlYSBwYWNrIHRoaW4iCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMxMQorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjkxCiBtc2dpZCAiY3JlYXRlIHBhY2tzIHN1aXRhYmxlIGZvciBzaGFsbG93IGZldGNoZXMiCiBtc2dzdHIgImNyZWEgcGFjayBhZGF0dGkgcGVyIGZldGNoIHNoYWxsb3ciCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMxMworIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjkzCiBtc2dpZCAiaWdub3JlIHBhY2tzIHRoYXQgaGF2ZSBjb21wYW5pb24gLmtlZXAgZmlsZSIKIG1zZ3N0ciAiaWdub3JhIGkgcGFjayBjaGUgaGFubm8gdW4gZmlsZSAua2VlcCBjaGUgbGkgYWNjb21wYWduYSIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzE1CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyOTUKIG1zZ2lkICJpZ25vcmUgdGhpcyBwYWNrIgogbXNnc3RyICJpZ25vcmEgcXVlc3RvIHBhY2siCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMxNworIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjk3CiBtc2dpZCAicGFjayBjb21wcmVzc2lvbiBsZXZlbCIKIG1zZ3N0ciAibGl2ZWxsbyBjb21wcmVzc2lvbmUgcGFjayIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzE5CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyOTkKIG1zZ2lkICJkbyBub3QgaGlkZSBjb21taXRzIGJ5IGdyYWZ0cyIKIG1zZ3N0ciAibm9uIG5hc2NvbmRlcmUgaSBjb21taXQgaW5uZXN0YXRpIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMjEKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMwMQogbXNnaWQgInVzZSBhIGJpdG1hcCBpbmRleCBpZiBhdmFpbGFibGUgdG8gc3BlZWQgdXAgY291bnRpbmcgb2JqZWN0cyIKIG1zZ3N0ciAiIgogInVzYSB1biBpbmRpY2UgYml0bWFwIHNlIGRpc3BvbmliaWxlIHBlciB2ZWxvY2l6emFyZSBpbCBjb250ZWdnaW8gZGVnbGkgIgogIm9nZ2V0dGkiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMyMworIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzAzCiBtc2dpZCAid3JpdGUgYSBiaXRtYXAgaW5kZXggdG9nZXRoZXIgd2l0aCB0aGUgcGFjayBpbmRleCIKIG1zZ3N0ciAic2NyaXZpIHVuIGluZGljZSBiaXRtYXAgaW5zaWVtZSBhbGwnaW5kaWNlIHBhY2siCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMyNworIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzA3CiBtc2dpZCAid3JpdGUgYSBiaXRtYXAgaW5kZXggaWYgcG9zc2libGUiCiBtc2dzdHIgInNjcml2aSB1biBpbmRpY2UgYml0bWFwIHNlIHBvc3NpYmlsZSIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzMxCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMTEKIG1zZ2lkICJoYW5kbGluZyBmb3IgbWlzc2luZyBvYmplY3RzIgogbXNnc3RyICJhemlvbmUgZGEgZXNlZ3VpcmUgc3VnbGkgb2dnZXR0aSBtYW5jYW50aSIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzM0CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMTQKIG1zZ2lkICJkbyBub3QgcGFjayBvYmplY3RzIGluIHByb21pc29yIHBhY2tmaWxlcyIKIG1zZ3N0ciAibm9uIGVzZWd1aXJlIGlsIHBhY2sgZGVnbGkgb2dnZXR0aSBuZWkgZmlsZSBwYWNrIHByb21ldHRlbnRpIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMzYKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMxNgogbXNnaWQgInJlc3BlY3QgaXNsYW5kcyBkdXJpbmcgZGVsdGEgY29tcHJlc3Npb24iCiBtc2dzdHIgInJpc3BldHRhIGxlIGlzb2xlIGR1cmFudGUgbGEgY29tcHJlc3Npb25lIGRlbHRhIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzNjEKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzM0NQogIywgYy1mb3JtYXQKIG1zZ2lkICJkZWx0YSBjaGFpbiBkZXB0aCAlZCBpcyB0b28gZGVlcCwgZm9yY2luZyAlZCIKIG1zZ3N0ciAibGEgcHJvZm9uZGl0w6AgZGVsbGEgY2F0ZW5hIGRlaSBkZWx0YSAoJWQpIMOoIHRyb3BwbyBlbGV2YXRhLCBmb3J6byAlZCIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzY2CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzNTAKICMsIGMtZm9ybWF0CiBtc2dpZCAicGFjay5kZWx0YUNhY2hlTGltaXQgaXMgdG9vIGhpZ2gsIGZvcmNpbmcgJWQiCiBtc2dzdHIgImlsIHZhbG9yZSBwYWNrLmRlbHRhQ2FjaGVMaW1pdCDDqCB0cm9wcG8gZWxldmF0bywgZm9yem8gJWQiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzQyMAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozNDA0CiBtc2dpZCAiLS1tYXgtcGFjay1zaXplIGNhbm5vdCBiZSB1c2VkIHRvIGJ1aWxkIGEgcGFjayBmb3IgdHJhbnNmZXIiCiBtc2dzdHIgIiIKICItLW1heC1wYWNrLXNpemUgbm9uIHB1w7IgZXNzZXJlIHVzYXRvIHBlciBnZW5lcmFyZSB1biBwYWNrIGRhIHRyYXNmZXJpcmUiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzQyMgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozNDA2CiBtc2dpZCAibWluaW11bSBwYWNrIHNpemUgbGltaXQgaXMgMSBNaUIiCiBtc2dzdHIgImlsIGxpbWl0ZSBtaW5pbW8gZGVsbGUgZGltZW5zaW9uaSBkZWkgcGFjayDDqCAxIE1pQiIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozNDI3CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjM0MTEKIG1zZ2lkICItLXRoaW4gY2Fubm90IGJlIHVzZWQgdG8gYnVpbGQgYW4gaW5kZXhhYmxlIHBhY2siCiBtc2dzdHIgIi0tdGhpbiBub24gcHXDsiBlc3NlcmUgdXNhdG8gcGVyIGdlbmVyYXJlIHVuIHBhY2sgaW5kaWNpenphYmlsZSIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozNDMwCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjM0MTQKIG1zZ2lkICItLWtlZXAtdW5yZWFjaGFibGUgYW5kIC0tdW5wYWNrLXVucmVhY2hhYmxlIGFyZSBpbmNvbXBhdGlibGUiCiBtc2dzdHIgIi0ta2VlcC11bnJlYWNoYWJsZSBlIC0tdW5wYWNrLXVucmVhY2hhYmxlIG5vbiBzb25vIGNvbXBhdGliaWxpIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjM0MzYKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzQyMAogbXNnaWQgImNhbm5vdCB1c2UgLS1maWx0ZXIgd2l0aG91dCAtLXN0ZG91dCIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgdXNhcmUgLS1maWx0ZXIgc2VuemEgLS1zdGRvdXQiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzQ5NworIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozNDgxCiBtc2dpZCAiRW51bWVyYXRpbmcgb2JqZWN0cyIKIG1zZ3N0ciAiRW51bWVyYXppb25lIGRlZ2xpIG9nZ2V0dGkgaW4gY29yc28iCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzUyNworIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozNTExCiAjLCBjLWZvcm1hdAogbXNnaWQgIlRvdGFsICU8UFJJdTMyPiAoZGVsdGEgJTxQUkl1MzI+KSwgcmV1c2VkICU8UFJJdTMyPiAoZGVsdGEgJTxQUkl1MzI+KSIKIG1zZ3N0ciAiIgpAQCAtMTY3MTksNDQgKzE2ODA1LDQ0IEBACiBtc2dpZCAiZ2l0IHB1bGwgWzxvcHRpb25zPl0gWzxyZXBvc2l0b3J5PiBbPHJlZnNwZWM+Li4uXV0iCiBtc2dzdHIgImdpdCBwdWxsIFs8b3B6aW9uaT5dIFs8cmVwb3NpdG9yeT4gWzxzcGVjaWZpY2F0b3JlIHJpZmVyaW1lbnRvPi4uLl1dIgogCi0jOiBidWlsdGluL3B1bGwuYzoxNDEKKyM6IGJ1aWx0aW4vcHVsbC5jOjE0MgogbXNnaWQgImNvbnRyb2wgZm9yIHJlY3Vyc2l2ZSBmZXRjaGluZyBvZiBzdWJtb2R1bGVzIgogbXNnc3RyICJjb250cm9sbGEgaWwgcmVjdXBlcm8gcmljb3JzaXZvIGRlaSBzb3R0b21vZHVsaSIKIAotIzogYnVpbHRpbi9wdWxsLmM6MTQ1CisjOiBidWlsdGluL3B1bGwuYzoxNDYKIG1zZ2lkICJPcHRpb25zIHJlbGF0ZWQgdG8gbWVyZ2luZyIKIG1zZ3N0ciAiT3B6aW9uaSByZWxhdGl2ZSBhbCBtZXJnZSIKIAotIzogYnVpbHRpbi9wdWxsLmM6MTQ4CisjOiBidWlsdGluL3B1bGwuYzoxNDkKIG1zZ2lkICJpbmNvcnBvcmF0ZSBjaGFuZ2VzIGJ5IHJlYmFzaW5nIHJhdGhlciB0aGFuIG1lcmdpbmciCiBtc2dzdHIgImluY29ycG9yYSBsZSBtb2RpZmljaGUgZXNlZ3VlbmRvIHVuIHJlYmFzZSBhbnppY2jDqSB1biBtZXJnZSIKIAotIzogYnVpbHRpbi9wdWxsLmM6MTc2IGJ1aWx0aW4vcmViYXNlLmM6NDQ3IGJ1aWx0aW4vcmV2ZXJ0LmM6MTI2CisjOiBidWlsdGluL3B1bGwuYzoxNzcgYnVpbHRpbi9yZWJhc2UuYzo0NDggYnVpbHRpbi9yZXZlcnQuYzoxMjYKIG1zZ2lkICJhbGxvdyBmYXN0LWZvcndhcmQiCiBtc2dzdHIgImNvbnNlbnRpIGZhc3QgZm9yd2FyZCIKIAotIzogYnVpbHRpbi9wdWxsLmM6MTg1CisjOiBidWlsdGluL3B1bGwuYzoxODYKIG1zZ2lkICJhdXRvbWF0aWNhbGx5IHN0YXNoL3N0YXNoIHBvcCBiZWZvcmUgYW5kIGFmdGVyIHJlYmFzZSIKIG1zZ3N0ciAiZXNlZ3VpIHN0YXNoL3N0YXNoIHBvcCBhdXRvbWF0aWNhbWVudGUgcHJpbWEgZSBkb3BvIGlsIHJlYmFzZSIKIAotIzogYnVpbHRpbi9wdWxsLmM6MjAxCisjOiBidWlsdGluL3B1bGwuYzoyMDIKIG1zZ2lkICJPcHRpb25zIHJlbGF0ZWQgdG8gZmV0Y2hpbmciCiBtc2dzdHIgIk9wemlvbmkgcmVsYXRpdmUgYWwgZmV0Y2giCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjIxMQorIzogYnVpbHRpbi9wdWxsLmM6MjEyCiBtc2dpZCAiZm9yY2Ugb3ZlcndyaXRlIG9mIGxvY2FsIGJyYW5jaCIKIG1zZ3N0ciAiZm9yemEgbGEgc292cmFzY3JpdHR1cmEgZGVsIGJyYW5jaCBsb2NhbGUiCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjIxOQorIzogYnVpbHRpbi9wdWxsLmM6MjIwCiBtc2dpZCAibnVtYmVyIG9mIHN1Ym1vZHVsZXMgcHVsbGVkIGluIHBhcmFsbGVsIgogbXNnc3RyICJudW1lcm8gZGkgc290dG9tb2R1bGkgcmVjdXBlcmF0aSBpbiBwYXJhbGxlbG8iCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjMxNgorIzogYnVpbHRpbi9wdWxsLmM6MzIwCiAjLCBjLWZvcm1hdAogbXNnaWQgIkludmFsaWQgdmFsdWUgZm9yIHB1bGwuZmY6ICVzIgogbXNnc3RyICJWYWxvcmUgbm9uIHZhbGlkbyBwZXIgcHVsbC5mZjogJXMiCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjQzMworIzogYnVpbHRpbi9wdWxsLmM6NDM3CiBtc2dpZCAiIgogIlRoZXJlIGlzIG5vIGNhbmRpZGF0ZSBmb3IgcmViYXNpbmcgYWdhaW5zdCBhbW9uZyB0aGUgcmVmcyB0aGF0IHlvdSBqdXN0ICIKICJmZXRjaGVkLiIKQEAgLTE2NzY0LDE0ICsxNjg1MCwxNCBAQAogIk5vbiBjaSBzb25vIGNhbmRpZGF0aSBpbiBiYXNlIGFpIHF1YWxpIGVzZWd1aXJlIGlsIHJlYmFzZSBmcmEgaSByaWZlcmltZW50aSAiCiAiYXBwZW5hIHJlY3VwZXJhdGkuIgogCi0jOiBidWlsdGluL3B1bGwuYzo0MzUKKyM6IGJ1aWx0aW4vcHVsbC5jOjQzOQogbXNnaWQgIiIKICJUaGVyZSBhcmUgbm8gY2FuZGlkYXRlcyBmb3IgbWVyZ2luZyBhbW9uZyB0aGUgcmVmcyB0aGF0IHlvdSBqdXN0IGZldGNoZWQuIgogbXNnc3RyICIiCiAiTm9uIGNpIHNvbm8gY2FuZGlkYXRpIGluIGJhc2UgYWkgcXVhbGkgZXNlZ3VpcmUgaWwgbWVyZ2UgZnJhIGkgcmlmZXJpbWVudGkgIgogImFwcGVuYSByZWN1cGVyYXRpLiIKIAotIzogYnVpbHRpbi9wdWxsLmM6NDM2CisjOiBidWlsdGluL3B1bGwuYzo0NDAKIG1zZ2lkICIiCiAiR2VuZXJhbGx5IHRoaXMgbWVhbnMgdGhhdCB5b3UgcHJvdmlkZWQgYSB3aWxkY2FyZCByZWZzcGVjIHdoaWNoIGhhZCBub1xuIgogIm1hdGNoZXMgb24gdGhlIHJlbW90ZSBlbmQuIgpAQCAtMTY3NzksNyArMTY4NjUsNyBAQAogIkluIGdlbmVyYWxlLCBxdWVzdG8gc2lnbmlmaWNhIGNoZSBoYWkgZm9ybml0byB1bm8gc3BlY2lmaWNhdG9yZVxuIgogInJpZmVyaW1lbnRvIGNoZSBub24gYXZldmEgY29ycmlzcG9uZGVuemUgbmVsIHJlbW90by4iCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjQzOQorIzogYnVpbHRpbi9wdWxsLmM6NDQzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJZb3UgYXNrZWQgdG8gcHVsbCBmcm9tIHRoZSByZW1vdGUgJyVzJywgYnV0IGRpZCBub3Qgc3BlY2lmeVxuIgpAQCAtMTY3OTEsNDQgKzE2ODc3LDQ0IEBACiAiY29uZmlndXJhdG8gY29tZSBwcmVkZWZpbml0byBwZXIgaWwgYnJhbmNoIGNvcnJlbnRlLCBkZXZpXG4iCiAic3BlY2lmaWNhcmUgdW4gYnJhbmNoIHN1bGxhIHJpZ2EgZGkgY29tYW5kby4iCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjQ0NCBidWlsdGluL3JlYmFzZS5jOjEzMjYgZ2l0LXBhcnNlLXJlbW90ZS5zaDo3MworIzogYnVpbHRpbi9wdWxsLmM6NDQ4IGJ1aWx0aW4vcmViYXNlLmM6MTM0NyBnaXQtcGFyc2UtcmVtb3RlLnNoOjczCiBtc2dpZCAiWW91IGFyZSBub3QgY3VycmVudGx5IG9uIGEgYnJhbmNoLiIKIG1zZ3N0ciAiQXR0dWFsbWVudGUgbm9uIHNlaSBzdSB1biBicmFuY2guIgogCi0jOiBidWlsdGluL3B1bGwuYzo0NDYgYnVpbHRpbi9wdWxsLmM6NDYxIGdpdC1wYXJzZS1yZW1vdGUuc2g6NzkKKyM6IGJ1aWx0aW4vcHVsbC5jOjQ1MCBidWlsdGluL3B1bGwuYzo0NjUgZ2l0LXBhcnNlLXJlbW90ZS5zaDo3OQogbXNnaWQgIlBsZWFzZSBzcGVjaWZ5IHdoaWNoIGJyYW5jaCB5b3Ugd2FudCB0byByZWJhc2UgYWdhaW5zdC4iCiBtc2dzdHIgIlNwZWNpZmljYSBpbCBicmFuY2ggaW4gYmFzZSBhIGN1aSB2dW9pIGVmZmV0dHVhcmUgaWwgcmViYXNlLiIKIAotIzogYnVpbHRpbi9wdWxsLmM6NDQ4IGJ1aWx0aW4vcHVsbC5jOjQ2MyBnaXQtcGFyc2UtcmVtb3RlLnNoOjgyCisjOiBidWlsdGluL3B1bGwuYzo0NTIgYnVpbHRpbi9wdWxsLmM6NDY3IGdpdC1wYXJzZS1yZW1vdGUuc2g6ODIKIG1zZ2lkICJQbGVhc2Ugc3BlY2lmeSB3aGljaCBicmFuY2ggeW91IHdhbnQgdG8gbWVyZ2Ugd2l0aC4iCiBtc2dzdHIgIlNwZWNpZmljYSBpbCBicmFuY2ggaW4gYmFzZSBhIGN1aSB2dW9pIGVmZmV0dHVhcmUgaWwgbWVyZ2UuIgogCi0jOiBidWlsdGluL3B1bGwuYzo0NDkgYnVpbHRpbi9wdWxsLmM6NDY0CisjOiBidWlsdGluL3B1bGwuYzo0NTMgYnVpbHRpbi9wdWxsLmM6NDY4CiBtc2dpZCAiU2VlIGdpdC1wdWxsKDEpIGZvciBkZXRhaWxzLiIKIG1zZ3N0ciAiVmVkaSBnaXQtcHVsbCgxKSBwZXIgdWx0ZXJpb3JpIGRldHRhZ2xpLiIKIAotIzogYnVpbHRpbi9wdWxsLmM6NDUxIGJ1aWx0aW4vcHVsbC5jOjQ1NyBidWlsdGluL3B1bGwuYzo0NjYKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTMzMiBnaXQtcGFyc2UtcmVtb3RlLnNoOjY0CisjOiBidWlsdGluL3B1bGwuYzo0NTUgYnVpbHRpbi9wdWxsLmM6NDYxIGJ1aWx0aW4vcHVsbC5jOjQ3MAorIzogYnVpbHRpbi9yZWJhc2UuYzoxMzUzIGdpdC1wYXJzZS1yZW1vdGUuc2g6NjQKIG1zZ2lkICI8cmVtb3RlPiIKIG1zZ3N0ciAiPHJlbW90bz4iCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjQ1MSBidWlsdGluL3B1bGwuYzo0NjYgYnVpbHRpbi9wdWxsLmM6NDcxCisjOiBidWlsdGluL3B1bGwuYzo0NTUgYnVpbHRpbi9wdWxsLmM6NDcwIGJ1aWx0aW4vcHVsbC5jOjQ3NQogIzogZ2l0LXBhcnNlLXJlbW90ZS5zaDo2NQogbXNnaWQgIjxicmFuY2g+IgogbXNnc3RyICI8YnJhbmNoPiIKIAotIzogYnVpbHRpbi9wdWxsLmM6NDU5IGJ1aWx0aW4vcmViYXNlLmM6MTMyNCBnaXQtcGFyc2UtcmVtb3RlLnNoOjc1CisjOiBidWlsdGluL3B1bGwuYzo0NjMgYnVpbHRpbi9yZWJhc2UuYzoxMzQ1IGdpdC1wYXJzZS1yZW1vdGUuc2g6NzUKIG1zZ2lkICJUaGVyZSBpcyBubyB0cmFja2luZyBpbmZvcm1hdGlvbiBmb3IgdGhlIGN1cnJlbnQgYnJhbmNoLiIKIG1zZ3N0ciAiTm9uIGNpIHNvbm8gaW5mb3JtYXppb25pIGRpIHRyYWNjaWFtZW50byBwZXIgaWwgYnJhbmNoIGNvcnJlbnRlLiIKIAotIzogYnVpbHRpbi9wdWxsLmM6NDY4IGdpdC1wYXJzZS1yZW1vdGUuc2g6OTUKKyM6IGJ1aWx0aW4vcHVsbC5jOjQ3MiBnaXQtcGFyc2UtcmVtb3RlLnNoOjk1CiBtc2dpZCAiIgogIklmIHlvdSB3aXNoIHRvIHNldCB0cmFja2luZyBpbmZvcm1hdGlvbiBmb3IgdGhpcyBicmFuY2ggeW91IGNhbiBkbyBzbyB3aXRoOiIKIG1zZ3N0ciAiIgogIlNlIHZ1b2kgaW1wb3N0YXJlIGxlIGluZm9ybWF6aW9uaSBkaSB0cmFjY2lhbWVudG8gcGVyIHF1ZXN0byBicmFuY2ggcHVvaSAiCiAiZmFybG8gY29uOiIKIAotIzogYnVpbHRpbi9wdWxsLmM6NDczCisjOiBidWlsdGluL3B1bGwuYzo0NzcKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIllvdXIgY29uZmlndXJhdGlvbiBzcGVjaWZpZXMgdG8gbWVyZ2Ugd2l0aCB0aGUgcmVmICclcydcbiIKQEAgLTE2ODM4LDMyICsxNjkyNCwzMiBAQAogImlsIG1lcmdlIGNvbiBpbCByaWZlcmltZW50byAnJXMnIGRlbCByZW1vdG8sIG1hIHVuIHRhbGVcbiIKICJyaWZlcmltZW50byBub24gw6ggc3RhdG8gcmVjdXBlcmF0by4iCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjU4MQorIzogYnVpbHRpbi9wdWxsLmM6NTg3CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBhY2Nlc3MgY29tbWl0ICVzIgogbXNnc3RyICJpbXBvc3NpYmlsZSBhY2NlZGVyZSBhbCBjb21taXQgJXMiCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjg2MQorIzogYnVpbHRpbi9wdWxsLmM6ODY3CiBtc2dpZCAiaWdub3JpbmcgLS12ZXJpZnktc2lnbmF0dXJlcyBmb3IgcmViYXNlIgogbXNnc3RyICJpZ25vcm8gLS12ZXJpZnktc2lnbmF0dXJlIHBlciBpbCByZWJhc2UiCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjkxNgorIzogYnVpbHRpbi9wdWxsLmM6OTIyCiBtc2dpZCAiLS1bbm8tXWF1dG9zdGFzaCBvcHRpb24gaXMgb25seSB2YWxpZCB3aXRoIC0tcmViYXNlLiIKIG1zZ3N0ciAibCdvcHppb25lIC0tW25vLV1hdXRvc3Rhc2ggb3B0aW9uIMOoIHZhbGlkYSBzb2xvIGNvbiAtLXJlYmFzZS4iCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjkyNAorIzogYnVpbHRpbi9wdWxsLmM6OTMwCiBtc2dpZCAiVXBkYXRpbmcgYW4gdW5ib3JuIGJyYW5jaCB3aXRoIGNoYW5nZXMgYWRkZWQgdG8gdGhlIGluZGV4LiIKIG1zZ3N0ciAiQWdnaW9ybm8gdW4gYnJhbmNoIG5vbiBuYXRvIGNvbiBsZSBtb2RpZmljaGUgYWdnaXVudGUgYWxsJ2luZGljZS4iCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjkyOAorIzogYnVpbHRpbi9wdWxsLmM6OTM0CiBtc2dpZCAicHVsbCB3aXRoIHJlYmFzZSIKIG1zZ3N0ciAicHVsbCBjb24gcmViYXNlIgogCi0jOiBidWlsdGluL3B1bGwuYzo5MjkKKyM6IGJ1aWx0aW4vcHVsbC5jOjkzNQogbXNnaWQgInBsZWFzZSBjb21taXQgb3Igc3Rhc2ggdGhlbS4iCiBtc2dzdHIgImVzZWd1aW5lIGlsIGNvbW1pdCBvIGxvIHN0YXNoLiIKIAotIzogYnVpbHRpbi9wdWxsLmM6OTU0CisjOiBidWlsdGluL3B1bGwuYzo5NjAKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogImZldGNoIHVwZGF0ZWQgdGhlIGN1cnJlbnQgYnJhbmNoIGhlYWQuXG4iCkBAIC0xNjg3NSw3ICsxNjk2MSw3IEBACiAiRXNlZ3VvIGlsIGZhc3QgZm9yd2FyZCBkZWxsJ2FsYmVyb1xuIgogImRpIGxhdm9ybyBkYWwgY29tbWl0ICVzLiIKIAotIzogYnVpbHRpbi9wdWxsLmM6OTYwCisjOiBidWlsdGluL3B1bGwuYzo5NjYKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkNhbm5vdCBmYXN0LWZvcndhcmQgeW91ciB3b3JraW5nIHRyZWUuXG4iCkBAIC0xNjg5NCwxNSArMTY5ODAsMTUgQEAKICIkIGdpdCByZXNldCAtLWhhcmRcbiIKICJwZXIgZXNlZ3VpcmUgaWwgcmlwcmlzdGluby4iCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjk3NQorIzogYnVpbHRpbi9wdWxsLmM6OTgxCiBtc2dpZCAiQ2Fubm90IG1lcmdlIG11bHRpcGxlIGJyYW5jaGVzIGludG8gZW1wdHkgaGVhZC4iCiBtc2dzdHIgIkltcG9zc2liaWxlIGVzZWd1aXJlIGlsIG1lcmdlIGRpIHBpw7kgYnJhbmNoIGluIHVuIGhlYWQgdnVvdG8uIgogCi0jOiBidWlsdGluL3B1bGwuYzo5NzkKKyM6IGJ1aWx0aW4vcHVsbC5jOjk4NQogbXNnaWQgIkNhbm5vdCByZWJhc2Ugb250byBtdWx0aXBsZSBicmFuY2hlcy4iCiBtc2dzdHIgIkltcG9zc2liaWxlIGVzZWd1aXJlIGlsIHJlYmFzZSBzdSBwacO5IGJyYW5jaC4iCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjk4NgorIzogYnVpbHRpbi9wdWxsLmM6OTkyCiBtc2dpZCAiY2Fubm90IHJlYmFzZSB3aXRoIGxvY2FsbHkgcmVjb3JkZWQgc3VibW9kdWxlIG1vZGlmaWNhdGlvbnMiCiBtc2dzdHIgIiIKICJpbXBvc3NpYmlsZSBlc2VndWlyZSBpbCByZWJhc2Ugc2UgY2kgc29ubyBkZWxsZSBtb2RpZmljaGUgcmVnaXN0cmF0ZSAiCkBAIC0xNzA3MywxNyArMTcxNTksOTUgQEAKIG1zZ2lkICJQdXNoaW5nIHRvICVzXG4iCiBtc2dzdHIgIlB1c2ggc3UgJXMgaW4gY29yc29cbiIKIAotIzogYnVpbHRpbi9wdXNoLmM6MzY0CisjOiBidWlsdGluL3B1c2guYzozNjYKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIHB1c2ggc29tZSByZWZzIHRvICclcyciCiBtc2dzdHIgInB1c2ggZGkgYWxjdW5pIHJpZmVyaW1lbnRpIHN1ICclcycgbm9uIHJpdXNjaXRvIgogCi0jOiBidWlsdGluL3B1c2guYzozOTgKKyM6IGJ1aWx0aW4vcHVzaC5jOjU0MQorbXNnaWQgInJlcG9zaXRvcnkiCittc2dzdHIgInJlcG9zaXRvcnkiCisKKyM6IGJ1aWx0aW4vcHVzaC5jOjU0MiBidWlsdGluL3NlbmQtcGFjay5jOjE2NAorbXNnaWQgInB1c2ggYWxsIHJlZnMiCittc2dzdHIgImVzZWd1aSBpbCBwdXNoIGRpIHR1dHRpIGkgcmlmZXJpbWVudGkiCisKKyM6IGJ1aWx0aW4vcHVzaC5jOjU0MyBidWlsdGluL3NlbmQtcGFjay5jOjE2NgorbXNnaWQgIm1pcnJvciBhbGwgcmVmcyIKK21zZ3N0ciAiZXNlZ3VpIGlsIG1pcnJvciBkaSB0dXR0aSBpIHJpZmVyaW1lbnRpIgorCisjOiBidWlsdGluL3B1c2guYzo1NDUKK21zZ2lkICJkZWxldGUgcmVmcyIKK21zZ3N0ciAiZWxpbWluYSByaWZlcmltZW50aSIKKworIzogYnVpbHRpbi9wdXNoLmM6NTQ2Cittc2dpZCAicHVzaCB0YWdzIChjYW4ndCBiZSB1c2VkIHdpdGggLS1hbGwgb3IgLS1taXJyb3IpIgorbXNnc3RyICJlc2VndWkgaWwgcHVzaCBkZWkgdGFnIChub24gcHXDsiBlc3NlcmUgdXNhdG8gY29uIC0tYWxsIG8gLS1taXJyb3IpIgorCisjOiBidWlsdGluL3B1c2guYzo1NDkgYnVpbHRpbi9zZW5kLXBhY2suYzoxNjcKK21zZ2lkICJmb3JjZSB1cGRhdGVzIgorbXNnc3RyICJmb3J6YSBnbGkgYWdnaW9ybmFtZW50aSIKKworIzogYnVpbHRpbi9wdXNoLmM6NTUxIGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTgxCittc2dpZCAiPHJlZm5hbWU+OjxleHBlY3Q+IgorbXNnc3RyICI8bm9tZSByaWZlcmltZW50bz46PHZhbG9yZSBhdHRlc28+IgorCisjOiBidWlsdGluL3B1c2guYzo1NTIgYnVpbHRpbi9zZW5kLXBhY2suYzoxODIKK21zZ2lkICJyZXF1aXJlIG9sZCB2YWx1ZSBvZiByZWYgdG8gYmUgYXQgdGhpcyB2YWx1ZSIKK21zZ3N0ciAiIgorInJpY2hpZWRpIGNoZSBpbCB2ZWNjaGlvIHZhbG9yZSBkZWwgcmlmZXJpbWVudG8gY29ycmlzcG9uZGEgYSBxdWVzdG8gdmFsb3JlIgorCisjOiBidWlsdGluL3B1c2guYzo1NTUKK21zZ2lkICJjb250cm9sIHJlY3Vyc2l2ZSBwdXNoaW5nIG9mIHN1Ym1vZHVsZXMiCittc2dzdHIgImNvbnRyb2xsYSBpbCBwdXNoIHJpY29yc2l2byBkZWkgc290dG9tb2R1bGkiCisKKyM6IGJ1aWx0aW4vcHVzaC5jOjU1NyBidWlsdGluL3NlbmQtcGFjay5jOjE3NQorbXNnaWQgInVzZSB0aGluIHBhY2siCittc2dzdHIgInVzYSB1biB0aGluIHBhY2siCisKKyM6IGJ1aWx0aW4vcHVzaC5jOjU1OCBidWlsdGluL3B1c2guYzo1NTkgYnVpbHRpbi9zZW5kLXBhY2suYzoxNjEKKyM6IGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTYyCittc2dpZCAicmVjZWl2ZSBwYWNrIHByb2dyYW0iCittc2dzdHIgInByb2dyYW1tYSByaWNlemlvbmUgcGFjayIKKworIzogYnVpbHRpbi9wdXNoLmM6NTYwCittc2dpZCAic2V0IHVwc3RyZWFtIGZvciBnaXQgcHVsbC9zdGF0dXMiCittc2dzdHIgImltcG9zdGEgbCd1cHN0cmVhbSBwZXIgZ2l0IHB1bGwvc3RhdHVzIgorCisjOiBidWlsdGluL3B1c2guYzo1NjMKK21zZ2lkICJwcnVuZSBsb2NhbGx5IHJlbW92ZWQgcmVmcyIKK21zZ3N0ciAiZWxpbWluYSBpIHJpZmVyaW1lbnRpIHJpbW9zc2kgbG9jYWxtZW50ZSIKKworIzogYnVpbHRpbi9wdXNoLmM6NTY1Cittc2dpZCAiYnlwYXNzIHByZS1wdXNoIGhvb2siCittc2dzdHIgImlnbm9yYSBsJ2hvb2sgcHJlLXB1c2giCisKKyM6IGJ1aWx0aW4vcHVzaC5jOjU2NgorbXNnaWQgInB1c2ggbWlzc2luZyBidXQgcmVsZXZhbnQgdGFncyIKK21zZ3N0ciAiZXNlZ3VpIGlsIHB1c2ggZGVpIHRhZyBtYW5jYW50aSBtYSByaWxldmFudGkiCisKKyM6IGJ1aWx0aW4vcHVzaC5jOjU2OSBidWlsdGluL3NlbmQtcGFjay5jOjE2OQorbXNnaWQgIkdQRyBzaWduIHRoZSBwdXNoIgorbXNnc3RyICJmaXJtYSBpbCBwdXNoIGNvbiBHUEciCisKKyM6IGJ1aWx0aW4vcHVzaC5jOjU3MSBidWlsdGluL3NlbmQtcGFjay5jOjE3NgorbXNnaWQgInJlcXVlc3QgYXRvbWljIHRyYW5zYWN0aW9uIG9uIHJlbW90ZSBzaWRlIgorbXNnc3RyICJyaWNoaWVkaSBsJ2F0b21pY2l0w6AgZGVsbGEgdHJhbnNhemlvbmUgYWwgcmVtb3RvIgorCisjOiBidWlsdGluL3B1c2guYzo1ODkKK21zZ2lkICItLWRlbGV0ZSBpcyBpbmNvbXBhdGlibGUgd2l0aCAtLWFsbCwgLS1taXJyb3IgYW5kIC0tdGFncyIKK21zZ3N0ciAiLS1kZWxldGUgbm9uIMOoIGNvbXBhdGliaWxlIGNvbiAtLWFsbCwgLS1taXJyb3IgZSAtLXRhZ3MiCisKKyM6IGJ1aWx0aW4vcHVzaC5jOjU5MQorbXNnaWQgIi0tZGVsZXRlIGRvZXNuJ3QgbWFrZSBzZW5zZSB3aXRob3V0IGFueSByZWZzIgorbXNnc3RyICItLWRlbGV0ZSBub24gaGEgc2Vuc28gc2VuemEgYWxjdW4gcmVmIgorCisjOiBidWlsdGluL3B1c2guYzo2MTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiYmFkIHJlcG9zaXRvcnkgJyVzJyIKIG1zZ3N0ciAicmVwb3NpdG9yeSAnJXMnIGVycmF0byIKIAotIzogYnVpbHRpbi9wdXNoLmM6Mzk5CisjOiBidWlsdGluL3B1c2guYzo2MTIKIG1zZ2lkICIiCiAiTm8gY29uZmlndXJlZCBwdXNoIGRlc3RpbmF0aW9uLlxuIgogIkVpdGhlciBzcGVjaWZ5IHRoZSBVUkwgZnJvbSB0aGUgY29tbWFuZC1saW5lIG9yIGNvbmZpZ3VyZSBhIHJlbW90ZSAiCkBAIC0xNzEwNSwxMDUgKzE3MjY5LDI3IEBACiAiXG4iCiAiICAgIGdpdCBwdXNoIDxub21lPlxuIgogCi0jOiBidWlsdGluL3B1c2guYzo1NTQKLW1zZ2lkICJyZXBvc2l0b3J5IgotbXNnc3RyICJyZXBvc2l0b3J5IgotCi0jOiBidWlsdGluL3B1c2guYzo1NTUgYnVpbHRpbi9zZW5kLXBhY2suYzoxNjQKLW1zZ2lkICJwdXNoIGFsbCByZWZzIgotbXNnc3RyICJlc2VndWkgaWwgcHVzaCBkaSB0dXR0aSBpIHJpZmVyaW1lbnRpIgotCi0jOiBidWlsdGluL3B1c2guYzo1NTYgYnVpbHRpbi9zZW5kLXBhY2suYzoxNjYKLW1zZ2lkICJtaXJyb3IgYWxsIHJlZnMiCi1tc2dzdHIgImVzZWd1aSBpbCBtaXJyb3IgZGkgdHV0dGkgaSByaWZlcmltZW50aSIKLQotIzogYnVpbHRpbi9wdXNoLmM6NTU4Ci1tc2dpZCAiZGVsZXRlIHJlZnMiCi1tc2dzdHIgImVsaW1pbmEgcmlmZXJpbWVudGkiCi0KLSM6IGJ1aWx0aW4vcHVzaC5jOjU1OQotbXNnaWQgInB1c2ggdGFncyAoY2FuJ3QgYmUgdXNlZCB3aXRoIC0tYWxsIG9yIC0tbWlycm9yKSIKLW1zZ3N0ciAiZXNlZ3VpIGlsIHB1c2ggZGVpIHRhZyAobm9uIHB1w7IgZXNzZXJlIHVzYXRvIGNvbiAtLWFsbCBvIC0tbWlycm9yKSIKLQotIzogYnVpbHRpbi9wdXNoLmM6NTYyIGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTY3Ci1tc2dpZCAiZm9yY2UgdXBkYXRlcyIKLW1zZ3N0ciAiZm9yemEgZ2xpIGFnZ2lvcm5hbWVudGkiCi0KLSM6IGJ1aWx0aW4vcHVzaC5jOjU2NCBidWlsdGluL3NlbmQtcGFjay5jOjE4MQotbXNnaWQgIjxyZWZuYW1lPjo8ZXhwZWN0PiIKLW1zZ3N0ciAiPG5vbWUgcmlmZXJpbWVudG8+Ojx2YWxvcmUgYXR0ZXNvPiIKLQotIzogYnVpbHRpbi9wdXNoLmM6NTY1IGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTgyCi1tc2dpZCAicmVxdWlyZSBvbGQgdmFsdWUgb2YgcmVmIHRvIGJlIGF0IHRoaXMgdmFsdWUiCi1tc2dzdHIgIiIKLSJyaWNoaWVkaSBjaGUgaWwgdmVjY2hpbyB2YWxvcmUgZGVsIHJpZmVyaW1lbnRvIGNvcnJpc3BvbmRhIGEgcXVlc3RvIHZhbG9yZSIKLQotIzogYnVpbHRpbi9wdXNoLmM6NTY4Ci1tc2dpZCAiY29udHJvbCByZWN1cnNpdmUgcHVzaGluZyBvZiBzdWJtb2R1bGVzIgotbXNnc3RyICJjb250cm9sbGEgaWwgcHVzaCByaWNvcnNpdm8gZGVpIHNvdHRvbW9kdWxpIgotCi0jOiBidWlsdGluL3B1c2guYzo1NzAgYnVpbHRpbi9zZW5kLXBhY2suYzoxNzUKLW1zZ2lkICJ1c2UgdGhpbiBwYWNrIgotbXNnc3RyICJ1c2EgdW4gdGhpbiBwYWNrIgotCi0jOiBidWlsdGluL3B1c2guYzo1NzEgYnVpbHRpbi9wdXNoLmM6NTcyIGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTYxCi0jOiBidWlsdGluL3NlbmQtcGFjay5jOjE2MgotbXNnaWQgInJlY2VpdmUgcGFjayBwcm9ncmFtIgotbXNnc3RyICJwcm9ncmFtbWEgcmljZXppb25lIHBhY2siCi0KLSM6IGJ1aWx0aW4vcHVzaC5jOjU3MwotbXNnaWQgInNldCB1cHN0cmVhbSBmb3IgZ2l0IHB1bGwvc3RhdHVzIgotbXNnc3RyICJpbXBvc3RhIGwndXBzdHJlYW0gcGVyIGdpdCBwdWxsL3N0YXR1cyIKLQotIzogYnVpbHRpbi9wdXNoLmM6NTc2Ci1tc2dpZCAicHJ1bmUgbG9jYWxseSByZW1vdmVkIHJlZnMiCi1tc2dzdHIgImVsaW1pbmEgaSByaWZlcmltZW50aSByaW1vc3NpIGxvY2FsbWVudGUiCi0KLSM6IGJ1aWx0aW4vcHVzaC5jOjU3OAotbXNnaWQgImJ5cGFzcyBwcmUtcHVzaCBob29rIgotbXNnc3RyICJpZ25vcmEgbCdob29rIHByZS1wdXNoIgotCi0jOiBidWlsdGluL3B1c2guYzo1NzkKLW1zZ2lkICJwdXNoIG1pc3NpbmcgYnV0IHJlbGV2YW50IHRhZ3MiCi1tc2dzdHIgImVzZWd1aSBpbCBwdXNoIGRlaSB0YWcgbWFuY2FudGkgbWEgcmlsZXZhbnRpIgotCi0jOiBidWlsdGluL3B1c2guYzo1ODIgYnVpbHRpbi9zZW5kLXBhY2suYzoxNjkKLW1zZ2lkICJHUEcgc2lnbiB0aGUgcHVzaCIKLW1zZ3N0ciAiZmlybWEgaWwgcHVzaCBjb24gR1BHIgotCi0jOiBidWlsdGluL3B1c2guYzo1ODQgYnVpbHRpbi9zZW5kLXBhY2suYzoxNzYKLW1zZ2lkICJyZXF1ZXN0IGF0b21pYyB0cmFuc2FjdGlvbiBvbiByZW1vdGUgc2lkZSIKLW1zZ3N0ciAicmljaGllZGkgbCdhdG9taWNpdMOgIGRlbGxhIHRyYW5zYXppb25lIGFsIHJlbW90byIKLQotIzogYnVpbHRpbi9wdXNoLmM6NjAyCi1tc2dpZCAiLS1kZWxldGUgaXMgaW5jb21wYXRpYmxlIHdpdGggLS1hbGwsIC0tbWlycm9yIGFuZCAtLXRhZ3MiCi1tc2dzdHIgIi0tZGVsZXRlIG5vbiDDqCBjb21wYXRpYmlsZSBjb24gLS1hbGwsIC0tbWlycm9yIGUgLS10YWdzIgotCi0jOiBidWlsdGluL3B1c2guYzo2MDQKLW1zZ2lkICItLWRlbGV0ZSBkb2Vzbid0IG1ha2Ugc2Vuc2Ugd2l0aG91dCBhbnkgcmVmcyIKLW1zZ3N0ciAiLS1kZWxldGUgbm9uIGhhIHNlbnNvIHNlbnphIGFsY3VuIHJlZiIKLQotIzogYnVpbHRpbi9wdXNoLmM6NjA3CisjOiBidWlsdGluL3B1c2guYzo2MjcKIG1zZ2lkICItLWFsbCBhbmQgLS10YWdzIGFyZSBpbmNvbXBhdGlibGUiCiBtc2dzdHIgIi0tYWxsIGUgLS10YWdzIG5vbiBzb25vIGNvbXBhdGliaWxpIgogCi0jOiBidWlsdGluL3B1c2guYzo2MDkKKyM6IGJ1aWx0aW4vcHVzaC5jOjYyOQogbXNnaWQgIi0tYWxsIGNhbid0IGJlIGNvbWJpbmVkIHdpdGggcmVmc3BlY3MiCiBtc2dzdHIgIi0tYWxsIG5vbiBwdcOyIGVzc2VyZSBjb21iaW5hdG8gY29uIGRlZ2xpIHNwZWNpZmljYXRvcmkgcmlmZXJpbWVudG8iCiAKLSM6IGJ1aWx0aW4vcHVzaC5jOjYxMworIzogYnVpbHRpbi9wdXNoLmM6NjMzCiBtc2dpZCAiLS1taXJyb3IgYW5kIC0tdGFncyBhcmUgaW5jb21wYXRpYmxlIgogbXNnc3RyICItLW1pcnJvciBlIC0tdGFncyBub24gc29ubyBjb21wYXRpYmlsaSIKIAotIzogYnVpbHRpbi9wdXNoLmM6NjE1CisjOiBidWlsdGluL3B1c2guYzo2MzUKIG1zZ2lkICItLW1pcnJvciBjYW4ndCBiZSBjb21iaW5lZCB3aXRoIHJlZnNwZWNzIgogbXNnc3RyICItLW1pcnJvciBub24gcHXDsiBlc3NlcmUgY29tYmluYXRvIGNvbiBkZWdsaSBzcGVjaWZpY2F0b3JpIHJpZmVyaW1lbnRvIgogCi0jOiBidWlsdGluL3B1c2guYzo2MTgKKyM6IGJ1aWx0aW4vcHVzaC5jOjYzOAogbXNnaWQgIi0tYWxsIGFuZCAtLW1pcnJvciBhcmUgaW5jb21wYXRpYmxlIgogbXNnc3RyICItLWFsbCBlIC0tbWlycm9yIG5vbiBzb25vIGNvbXBhdGliaWxpIgogCi0jOiBidWlsdGluL3B1c2guYzo2MzcKKyM6IGJ1aWx0aW4vcHVzaC5jOjY0MgogbXNnaWQgInB1c2ggb3B0aW9ucyBtdXN0IG5vdCBoYXZlIG5ldyBsaW5lIGNoYXJhY3RlcnMiCiBtc2dzdHIgImxlIG9wemlvbmkgcHVzaCBub24gZGV2b25vIGF2ZXJlIGNhcmF0dGVyaSBkaSBmaW5lIHJpZ2EiCiAKQEAgLTE3MzI2LDExICsxNzQxMiwxMSBAQAogCiAjOiBidWlsdGluL3JlYmFzZS5jOjMyCiBtc2dpZCAiIgotImdpdCByZWJhc2UgWy1pXSBbb3B0aW9uc10gWy0tZXhlYyA8Y21kPl0gWy0tb250byA8bmV3YmFzZT5dIFs8dXBzdHJlYW0+XSAiCi0iWzxicmFuY2g+XSIKKyJnaXQgcmViYXNlIFstaV0gW29wdGlvbnNdIFstLWV4ZWMgPGNtZD5dIFstLW9udG8gPG5ld2Jhc2U+IHwgLS1rZWVwLWJhc2VdICIKKyJbPHVwc3RyZWFtPiBbPGJyYW5jaD5dXSIKIG1zZ3N0ciAiIgotImdpdCByZWJhc2UgWy1pXSBbb3B0aW9uc10gWy0tZXhlYyA8Y29tYW5kbz5dIFstLW9udG8gPG51b3ZhIGJhc2U+XSAiCi0iWzx1cHN0cmVhbT5dIFs8YnJhbmNoPl0iCisiZ2l0IHJlYmFzZSBbLWldIFtvcHppb25pXSBbLS1leGVjIDxjb21hbmRvPl0gWy0tb250byA8bnVvdmEgYmFzZT4gfCAtLWtlZXAtIgorImJhc2VdIFs8dXBzdHJlYW0+IFs8YnJhbmNoPl1dIgogCiAjOiBidWlsdGluL3JlYmFzZS5jOjM0CiBtc2dpZCAiIgpAQCAtMTczNzAsMTkwICsxNzQ1NiwxOTAgQEAKIG1zZ2lkICJjb3VsZCBub3QgZ2VuZXJhdGUgdG9kbyBsaXN0IgogbXNnc3RyICJpbXBvc3NpYmlsZSBnZW5lcmFyZSBsJ2VsZW5jbyB0b2RvIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjM4MgorIzogYnVpbHRpbi9yZWJhc2UuYzozODMKIG1zZ2lkICJhIGJhc2UgY29tbWl0IG11c3QgYmUgcHJvdmlkZWQgd2l0aCAtLXVwc3RyZWFtIG9yIC0tb250byIKIG1zZ3N0ciAiIgogImxlIG9wemlvbmkgLS11cHN0cmVhbSBvIC0tb250byByaWNoaWVkb25vIGNoZSBzaWEgZm9ybml0byB1biBjb21taXQgZGkgYmFzZSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0MzcKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDM4CiBtc2dpZCAiZ2l0IHJlYmFzZS0taW50ZXJhY3RpdmUgWzxvcHRpb25zPl0iCiBtc2dzdHIgImdpdCByZWJhc2UgLS1pbnRlcmFjdGl2ZSBbPG9wemlvbmk+XSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0NDkKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDUwCiBtc2dpZCAia2VlcCBlbXB0eSBjb21taXRzIgogbXNnc3RyICJtYW50aWVuaSBpIGNvbW1pdCB2dW90aSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0NTEgYnVpbHRpbi9yZXZlcnQuYzoxMjgKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDUyIGJ1aWx0aW4vcmV2ZXJ0LmM6MTI4CiBtc2dpZCAiYWxsb3cgY29tbWl0cyB3aXRoIGVtcHR5IG1lc3NhZ2VzIgogbXNnc3RyICJjb25zZW50aSBjb21taXQgY29uIG1lc3NhZ2dpIHZ1b3RpIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ1MgorIzogYnVpbHRpbi9yZWJhc2UuYzo0NTMKIG1zZ2lkICJyZWJhc2UgbWVyZ2UgY29tbWl0cyIKIG1zZ3N0ciAiZXNlZ3VpIGlsIHJlYmFzZSBkZWkgY29tbWl0IGRpIG1lcmdlIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ1NAorIzogYnVpbHRpbi9yZWJhc2UuYzo0NTUKIG1zZ2lkICJrZWVwIG9yaWdpbmFsIGJyYW5jaCBwb2ludHMgb2YgY291c2lucyIKIG1zZ3N0ciAibWFudGllbmkgaSBwdW50aSBkaSBicmFuY2ggb3JpZ2luYWxpIGRlaSBjdWdpbmkiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDU2CisjOiBidWlsdGluL3JlYmFzZS5jOjQ1NwogbXNnaWQgIm1vdmUgY29tbWl0cyB0aGF0IGJlZ2luIHdpdGggc3F1YXNoIS9maXh1cCEiCiBtc2dzdHIgInNwb3N0YSBpIGNvbW1pdCBjaGUgaW5pemlhbm8gY29uIHNxdWFzaCEvZml4dXAhIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ1NworIzogYnVpbHRpbi9yZWJhc2UuYzo0NTgKIG1zZ2lkICJzaWduIGNvbW1pdHMiCiBtc2dzdHIgImZpcm1hIGkgY29tbWl0IgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ1OSBidWlsdGluL3JlYmFzZS5jOjE0MDMKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDYwIGJ1aWx0aW4vcmViYXNlLmM6MTQyNwogbXNnaWQgImRpc3BsYXkgYSBkaWZmc3RhdCBvZiB3aGF0IGNoYW5nZWQgdXBzdHJlYW0iCiBtc2dzdHIgInZpc3VhbGl6emEgdW4gZGlmZnN0YXQgZGVsbGUgbW9kaWZpY2hlIHVwc3RyZWFtIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ2MQorIzogYnVpbHRpbi9yZWJhc2UuYzo0NjIKIG1zZ2lkICJjb250aW51ZSByZWJhc2UiCiBtc2dzdHIgImNvbnRpbnVhIGlsIHJlYmFzZSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0NjMKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDY0CiBtc2dpZCAic2tpcCBjb21taXQiCiBtc2dzdHIgInNhbHRhIGlsIGNvbW1pdCIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0NjQKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDY1CiBtc2dpZCAiZWRpdCB0aGUgdG9kbyBsaXN0IgogbXNnc3RyICJtb2RpZmljYSBsJ2VsZW5jbyB0b2RvIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ2NgorIzogYnVpbHRpbi9yZWJhc2UuYzo0NjcKIG1zZ2lkICJzaG93IHRoZSBjdXJyZW50IHBhdGNoIgogbXNnc3RyICJ2aXN1YWxpenphIGxhIHBhdGNoIGNvcnJlbnRlIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ2OQorIzogYnVpbHRpbi9yZWJhc2UuYzo0NzAKIG1zZ2lkICJzaG9ydGVuIGNvbW1pdCBpZHMgaW4gdGhlIHRvZG8gbGlzdCIKIG1zZ3N0ciAiYWJicmV2aWEgZ2xpIElEIGRlaSBjb21taXQgbmVsbCdlbGVuY28gdG9kbyIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0NzEKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDcyCiBtc2dpZCAiZXhwYW5kIGNvbW1pdCBpZHMgaW4gdGhlIHRvZG8gbGlzdCIKIG1zZ3N0ciAiZXNwYW5kaSBnbGkgSUQgZGVpIGNvbW1pdCBuZWxsJ2VsZW5jbyB0b2RvIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ3MworIzogYnVpbHRpbi9yZWJhc2UuYzo0NzQKIG1zZ2lkICJjaGVjayB0aGUgdG9kbyBsaXN0IgogbXNnc3RyICJjb250cm9sbGEgbCdlbGVuY28gdG9kbyIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0NzUKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDc2CiBtc2dpZCAicmVhcnJhbmdlIGZpeHVwL3NxdWFzaCBsaW5lcyIKIG1zZ3N0ciAicmlkaXNwb25pIGxlIHJpZ2hlIGZpeHVwL3NxdWFzaCIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0NzcKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDc4CiBtc2dpZCAiaW5zZXJ0IGV4ZWMgY29tbWFuZHMgaW4gdG9kbyBsaXN0IgogbXNnc3RyICJpbnNlcmlzY2kgaSBjb21hbmRpIGV4ZWMgbmVsbCdlbGVuY28gdG9kbyIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0NzgKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDc5CiBtc2dpZCAib250byIKIG1zZ3N0ciAic3UiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDgxCisjOiBidWlsdGluL3JlYmFzZS5jOjQ4MgogbXNnaWQgInJlc3RyaWN0LXJldmlzaW9uIgogbXNnc3RyICJyZXZpc2lvbmktbGltaXRlIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ4MQorIzogYnVpbHRpbi9yZWJhc2UuYzo0ODIKIG1zZ2lkICJyZXN0cmljdCByZXZpc2lvbiIKIG1zZ3N0ciAibGltaXRhIGxhIHJldmlzaW9uZSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0ODMKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDg0CiBtc2dpZCAic3F1YXNoLW9udG8iCiBtc2dzdHIgInNxdWFzaC1zdSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0ODQKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDg1CiBtc2dpZCAic3F1YXNoIG9udG8iCiBtc2dzdHIgImVzZWd1aSBsbyBzcXVhc2ggc3UiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDg2CisjOiBidWlsdGluL3JlYmFzZS5jOjQ4NwogbXNnaWQgInRoZSB1cHN0cmVhbSBjb21taXQiCiBtc2dzdHIgImlsIGNvbW1pdCB1cHN0cmVhbSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0ODgKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDg5CiBtc2dpZCAiaGVhZC1uYW1lIgogbXNnc3RyICJub21lIGhlYWQiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDg4CisjOiBidWlsdGluL3JlYmFzZS5jOjQ4OQogbXNnaWQgImhlYWQgbmFtZSIKIG1zZ3N0ciAibm9tZSBoZWFkIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ5MworIzogYnVpbHRpbi9yZWJhc2UuYzo0OTQKIG1zZ2lkICJyZWJhc2Ugc3RyYXRlZ3kiCiBtc2dzdHIgInN0cmF0ZWdpYSBkaSByZWJhc2UiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDk0CisjOiBidWlsdGluL3JlYmFzZS5jOjQ5NQogbXNnaWQgInN0cmF0ZWd5LW9wdHMiCiBtc2dzdHIgIm9wemlvbmkgc3RyYXRlZ2lhIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ5NQorIzogYnVpbHRpbi9yZWJhc2UuYzo0OTYKIG1zZ2lkICJzdHJhdGVneSBvcHRpb25zIgogbXNnc3RyICJvcHppb25pIHN0cmF0ZWdpYSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0OTYKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDk3CiBtc2dpZCAic3dpdGNoLXRvIgogbXNnc3RyICJwYXNzYSBhIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ5NworIzogYnVpbHRpbi9yZWJhc2UuYzo0OTgKIG1zZ2lkICJ0aGUgYnJhbmNoIG9yIGNvbW1pdCB0byBjaGVja291dCIKIG1zZ3N0ciAiaWwgYnJhbmNoIG8gaWwgY29tbWl0IGRpIGN1aSBlc2VndWlyZSBpbCBjaGVja291dCIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0OTgKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDk5CiBtc2dpZCAib250by1uYW1lIgogbXNnc3RyICJub21lIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ5OAorIzogYnVpbHRpbi9yZWJhc2UuYzo0OTkKIG1zZ2lkICJvbnRvIG5hbWUiCiBtc2dzdHIgInN1bCBub21lIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ5OQorIzogYnVpbHRpbi9yZWJhc2UuYzo1MDAKIG1zZ2lkICJjbWQiCiBtc2dzdHIgImNvbWFuZG8iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDk5CisjOiBidWlsdGluL3JlYmFzZS5jOjUwMAogbXNnaWQgInRoZSBjb21tYW5kIHRvIHJ1biIKIG1zZ3N0ciAiaWwgY29tYW5kbyBkYSBlc2VndWlyZSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo1MDIgYnVpbHRpbi9yZWJhc2UuYzoxNDg2CisjOiBidWlsdGluL3JlYmFzZS5jOjUwMyBidWlsdGluL3JlYmFzZS5jOjE1MTAKIG1zZ2lkICJhdXRvbWF0aWNhbGx5IHJlLXNjaGVkdWxlIGFueSBgZXhlY2AgdGhhdCBmYWlscyIKIG1zZ3N0ciAic2NoZWR1bGEgbnVvdmFtZW50ZSBsZSBvcGVyYXppb25pIGBleGVjYCBub24gcml1c2NpdGUgYXV0b21hdGljYW1lbnRlIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjUxOAorIzogYnVpbHRpbi9yZWJhc2UuYzo1MTkKIG1zZ2lkICItLVtuby1dcmViYXNlLWNvdXNpbnMgaGFzIG5vIGVmZmVjdCB3aXRob3V0IC0tcmViYXNlLW1lcmdlcyIKIG1zZ3N0ciAiLS1bbm8tXXJlYmFzZS1jb3VzaW5zIG5vbiBoYSBlZmZldHRvIHNlbnphIC0tcmViYXNlLW1lcmdlcyIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo1MzQKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NTM1CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIHJlcXVpcmVzIGFuIGludGVyYWN0aXZlIHJlYmFzZSIKIG1zZ3N0ciAiJXMgcmljaGllZGUgdW4gcmViYXNlIGludGVyYXR0aXZvIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjU4NgorIzogYnVpbHRpbi9yZWJhc2UuYzo1ODcKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGdldCAnb250byc6ICclcyciCiBtc2dzdHIgImltcG9zc2liaWxlIG90dGVuZXJlICdvbnRvJzogJyVzJyIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo2MDEKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NjAyCiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgb3JpZy1oZWFkOiAnJXMnIgogbXNnc3RyICJvcmlnLWhlYWQgbm9uIHZhbGlkYTogJyVzJyIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo2MjYKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NjI3CiAjLCBjLWZvcm1hdAogbXNnaWQgImlnbm9yaW5nIGludmFsaWQgYWxsb3dfcmVyZXJlX2F1dG91cGRhdGU6ICclcyciCiBtc2dzdHIgImlnbm9ybyBpbCB2YWxvcmUgbm9uIHZhbGlkbyBwZXIgYWxsb3dfcmVyZXJlX2F1dG91cGRhdGU6ICclcyciCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NzAyCisjOiBidWlsdGluL3JlYmFzZS5jOjcwMwogIywgYy1mb3JtYXQKIG1zZ2lkICJDb3VsZCBub3QgcmVhZCAnJXMnIgogbXNnc3RyICJJbXBvc3NpYmlsZSBsZWdnZXJlICclcyciCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NzIwCisjOiBidWlsdGluL3JlYmFzZS5jOjcyMQogIywgYy1mb3JtYXQKIG1zZ2lkICJDYW5ub3Qgc3RvcmUgJXMiCiBtc2dzdHIgIkltcG9zc2liaWxlIG1lbW9yaXp6YXJlICVzIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjgyNworIzogYnVpbHRpbi9yZWJhc2UuYzo4MjgKIG1zZ2lkICJjb3VsZCBub3QgZGV0ZXJtaW5lIEhFQUQgcmV2aXNpb24iCiBtc2dzdHIgImltcG9zc2liaWxlIGRldGVybWluYXJlIGxhIHJldmlzaW9uZSBIRUFEIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjk1MCBnaXQtcmViYXNlLS1wcmVzZXJ2ZS1tZXJnZXMuc2g6ODEKKyM6IGJ1aWx0aW4vcmViYXNlLmM6OTUxIGdpdC1yZWJhc2UtLXByZXNlcnZlLW1lcmdlcy5zaDo4MQogbXNnaWQgIiIKICJSZXNvbHZlIGFsbCBjb25mbGljdHMgbWFudWFsbHksIG1hcmsgdGhlbSBhcyByZXNvbHZlZCB3aXRoXG4iCiAiXCJnaXQgYWRkL3JtIDxjb25mbGljdGVkX2ZpbGVzPlwiLCB0aGVuIHJ1biBcImdpdCByZWJhc2UgLS1jb250aW51ZVwiLlxuIgpAQCAtMTc1NjksNyArMTc2NTUsNyBAQAogIlBlciBpbnRlcnJvbXBlcmUgbCdvcGVyYXppb25lIGUgdG9ybmFyZSBhbGxvIHN0YXRvIHByZWNlZGVudGVcbiIKICJpbCBcImdpdCByZWJhc2VcIiwgZXNlZ3VpIFwiZ2l0IHJlYmFzZSAtLWFib3J0XCIuIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjEwMzEKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTAzMgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiXG4iCkBAIC0xNzU4OCw3ICsxNzY3NCw3IEBACiAiXG4iCiAiRGkgY29uc2VndWVuemEsIEdpdCBub24gcHXDsiBlc2VndWlybmUgaWwgcmViYXNlLiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxMzE4CisjOiBidWlsdGluL3JlYmFzZS5jOjEzMzkKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIiVzXG4iCkBAIC0xNzYwNSw3ICsxNzY5MSw3IEBACiAiICAgIGdpdCByZWJhc2UgJzxicmFuY2g+J1xuIgogIlxuIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjEzMzQKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTM1NQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiSWYgeW91IHdpc2ggdG8gc2V0IHRyYWNraW5nIGluZm9ybWF0aW9uIGZvciB0aGlzIGJyYW5jaCB5b3UgY2FuIGRvIHNvIHdpdGg6XG4iCkBAIC0xNzYxOSwxMzEgKzE3NzA1LDEzNSBAQAogIiAgICBnaXQgYnJhbmNoIC0tc2V0LXVwc3RyZWFtLXRvPSVzLzxicmFuY2g+ICVzXG4iCiAiXG4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTM2NAorIzogYnVpbHRpbi9yZWJhc2UuYzoxMzg1CiBtc2dpZCAiZXhlYyBjb21tYW5kcyBjYW5ub3QgY29udGFpbiBuZXdsaW5lcyIKIG1zZ3N0ciAiaSBjb21hbmRpIGV4ZWMgbm9uIHBvc3Nvbm8gY29udGVuZXJlIGNhcmF0dGVyaSBkaSBmaW5lIHJpZ2EiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTM2OAorIzogYnVpbHRpbi9yZWJhc2UuYzoxMzg5CiBtc2dpZCAiZW1wdHkgZXhlYyBjb21tYW5kIgogbXNnc3RyICJjb21hbmRvIGV4ZWMgdnVvdG8iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTM5NgorIzogYnVpbHRpbi9yZWJhc2UuYzoxNDE4CiBtc2dpZCAicmViYXNlIG9udG8gZ2l2ZW4gYnJhbmNoIGluc3RlYWQgb2YgdXBzdHJlYW0iCiBtc2dzdHIgImVzZWd1aSBpbCByZWJhc2Ugc3VsIGJyYW5jaCBzcGVjaWZpY2F0byBhbnppY2jDqSBzdSBxdWVsbG8gdXBzdHJlYW0iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTM5OAorIzogYnVpbHRpbi9yZWJhc2UuYzoxNDIwCittc2dpZCAidXNlIHRoZSBtZXJnZS1iYXNlIG9mIHVwc3RyZWFtIGFuZCBicmFuY2ggYXMgdGhlIGN1cnJlbnQgYmFzZSIKK21zZ3N0ciAidXNhIGxhIGJhc2UgZGVsIG1lcmdlIGRlbGwndXBzdHJlYW0gZSBkZWwgYnJhbmNoIGNvbWUgYmFzZSBjb3JyZW50ZSIKKworIzogYnVpbHRpbi9yZWJhc2UuYzoxNDIyCiBtc2dpZCAiYWxsb3cgcHJlLXJlYmFzZSBob29rIHRvIHJ1biIKIG1zZ3N0ciAiY29uc2VudGkgbCdlc2VjdXppb25lIGRlbGwnaG9vayBwcmUtcmViYXNlIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0MDAKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQyNAogbXNnaWQgImJlIHF1aWV0LiBpbXBsaWVzIC0tbm8tc3RhdCIKIG1zZ3N0ciAic2lpIHNpbGVuemlvc28uIGltcGxpY2EgLS1uby1zdGF0IgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0MDYKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQzMAogbXNnaWQgImRvIG5vdCBzaG93IGRpZmZzdGF0IG9mIHdoYXQgY2hhbmdlZCB1cHN0cmVhbSIKIG1zZ3N0ciAibm9uIHZpc3VhbGl6emFyZSB1biBkaWZmc3RhdCBkZWxsZSBtb2RpZmljaGUgdXBzdHJlYW0iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQwOQorIzogYnVpbHRpbi9yZWJhc2UuYzoxNDMzCiBtc2dpZCAiYWRkIGEgU2lnbmVkLW9mZi1ieTogbGluZSB0byBlYWNoIGNvbW1pdCIKIG1zZ3N0ciAiYWdnaXVuZ2kgdW5hIHJpZ2EgU2lnbmVkLW9mZi1ieTogYSBvZ25pIGNvbW1pdCIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDExIGJ1aWx0aW4vcmViYXNlLmM6MTQxNSBidWlsdGluL3JlYmFzZS5jOjE0MTcKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQzNSBidWlsdGluL3JlYmFzZS5jOjE0MzkgYnVpbHRpbi9yZWJhc2UuYzoxNDQxCiBtc2dpZCAicGFzc2VkIHRvICdnaXQgYW0nIgogbXNnc3RyICJwYXNzYXRvIGEgJ2dpdCBhbSciCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQxOSBidWlsdGluL3JlYmFzZS5jOjE0MjEKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ0MyBidWlsdGluL3JlYmFzZS5jOjE0NDUKIG1zZ2lkICJwYXNzZWQgdG8gJ2dpdCBhcHBseSciCiBtc2dzdHIgInBhc3NhdG8gYSAnZ2l0IGFwcGx5JyIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDIzIGJ1aWx0aW4vcmViYXNlLmM6MTQyNgorIzogYnVpbHRpbi9yZWJhc2UuYzoxNDQ3IGJ1aWx0aW4vcmViYXNlLmM6MTQ1MAogbXNnaWQgImNoZXJyeS1waWNrIGFsbCBjb21taXRzLCBldmVuIGlmIHVuY2hhbmdlZCIKIG1zZ3N0ciAiZXNlZ3VpIGlsIGNoZXJyeS1waWNrIGRpIHR1dHRpIGkgY29tbWl0LCBhbmNoZSBzZSBub24gbW9kaWZpY2F0aSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDI4CisjOiBidWlsdGluL3JlYmFzZS5jOjE0NTIKIG1zZ2lkICJjb250aW51ZSIKIG1zZ3N0ciAiY29udGludWEiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQzMQorIzogYnVpbHRpbi9yZWJhc2UuYzoxNDU1CiBtc2dpZCAic2tpcCBjdXJyZW50IHBhdGNoIGFuZCBjb250aW51ZSIKIG1zZ3N0ciAic2FsdGEgbGEgcGF0Y2ggY29ycmVudGUgZSBjb250aW51YSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDMzCisjOiBidWlsdGluL3JlYmFzZS5jOjE0NTcKIG1zZ2lkICJhYm9ydCBhbmQgY2hlY2sgb3V0IHRoZSBvcmlnaW5hbCBicmFuY2giCiBtc2dzdHIgImludGVycm9tcGkgZWQgZXNlZ3VpIGlsIGNoZWNrb3V0IGRlbCBicmFuY2ggb3JpZ2luYXJpbyIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDM2CisjOiBidWlsdGluL3JlYmFzZS5jOjE0NjAKIG1zZ2lkICJhYm9ydCBidXQga2VlcCBIRUFEIHdoZXJlIGl0IGlzIgogbXNnc3RyICJpbnRlcnJvbXBpIG1hIG1hbnRpZW5pIGwnSEVBRCBkb3Ynw6giCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQzNworIzogYnVpbHRpbi9yZWJhc2UuYzoxNDYxCiBtc2dpZCAiZWRpdCB0aGUgdG9kbyBsaXN0IGR1cmluZyBhbiBpbnRlcmFjdGl2ZSByZWJhc2UiCiBtc2dzdHIgIm1vZGlmaWNhIGwnZWxlbmNvIHRvZG8gZHVyYW50ZSB1biByZWJhc2UgaW50ZXJhdHRpdm8iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ0MAorIzogYnVpbHRpbi9yZWJhc2UuYzoxNDY0CiBtc2dpZCAic2hvdyB0aGUgcGF0Y2ggZmlsZSBiZWluZyBhcHBsaWVkIG9yIG1lcmdlZCIKIG1zZ3N0ciAiIgogInZpc3VhbGl6emEgaWwgZmlsZSBwYXRjaCBjaGUgc3RhIHBlciBlc3NlcmUgYXBwbGljYXRvIG8gc290dG9wb3N0byBhIG1lcmdlIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0NDMKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ2NwogbXNnaWQgInVzZSBtZXJnaW5nIHN0cmF0ZWdpZXMgdG8gcmViYXNlIgogbXNnc3RyICJ1c2EgbGUgc3RyYXRlZ2llIGRpIG1lcmdlIHBlciBlc2VndWlyZSBpbCByZWJhc2UiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ0NworIzogYnVpbHRpbi9yZWJhc2UuYzoxNDcxCiBtc2dpZCAibGV0IHRoZSB1c2VyIGVkaXQgdGhlIGxpc3Qgb2YgY29tbWl0cyB0byByZWJhc2UiCiBtc2dzdHIgIiIKICJjb25zZW50aSBhbGwndXRlbnRlIGRpIG1vZGlmaWNhcmUgbCdlbGVuY28gZGVpIGNvbW1pdCBkaSBjdWkgZXNlZ3VpcmUgaWwgIgogInJlYmFzZSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDUxCisjOiBidWlsdGluL3JlYmFzZS5jOjE0NzUKIG1zZ2lkICIoREVQUkVDQVRFRCkgdHJ5IHRvIHJlY3JlYXRlIG1lcmdlcyBpbnN0ZWFkIG9mIGlnbm9yaW5nIHRoZW0iCiBtc2dzdHIgIihERVBSRUNBVE8pIHByb3ZhIGEgcmljcmVhcmUgaSBtZXJnZSBhbnppY2jDqSBpZ25vcmFybGkiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ1NQorIzogYnVpbHRpbi9yZWJhc2UuYzoxNDc5CiBtc2dpZCAicHJlc2VydmUgZW1wdHkgY29tbWl0cyBkdXJpbmcgcmViYXNlIgogbXNnc3RyICJtYW50aWVuaSBpIGNvbW1pdCB2dW90aSBkdXJhbnRlIGlsIHJlYmFzZSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDU3CisjOiBidWlsdGluL3JlYmFzZS5jOjE0ODEKIG1zZ2lkICJtb3ZlIGNvbW1pdHMgdGhhdCBiZWdpbiB3aXRoIHNxdWFzaCEvZml4dXAhIHVuZGVyIC1pIgogbXNnc3RyICJzcG9zdGEgaSBjb21taXQgY2hlIGluaXppYW5vIGNvbiBzcXVhc2ghL2ZpeHVwISBpbiAtaSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDYzCisjOiBidWlsdGluL3JlYmFzZS5jOjE0ODcKIG1zZ2lkICJhdXRvbWF0aWNhbGx5IHN0YXNoL3N0YXNoIHBvcCBiZWZvcmUgYW5kIGFmdGVyIgogbXNnc3RyICJlc2VndWkgc3Rhc2gvc3Rhc2ggcG9wIGF1dG9tYXRpY2FtZW50ZSBwcmltYSBlIGRvcG8iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ2NQorIzogYnVpbHRpbi9yZWJhc2UuYzoxNDg5CiBtc2dpZCAiYWRkIGV4ZWMgbGluZXMgYWZ0ZXIgZWFjaCBjb21taXQgb2YgdGhlIGVkaXRhYmxlIGxpc3QiCiBtc2dzdHIgImFnZ2l1bmdpIHJpZ2hlIGV4ZWMgZG9wbyBvZ25pIGNvbW1pdCBkZWxsYSBsaXN0YSBtb2RpZmljYWJpbGUiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ2OQorIzogYnVpbHRpbi9yZWJhc2UuYzoxNDkzCiBtc2dpZCAiYWxsb3cgcmViYXNpbmcgY29tbWl0cyB3aXRoIGVtcHR5IG1lc3NhZ2VzIgogbXNnc3RyICJjb25zZW50aSBpbCByZWJhc2UgZGkgY29tbWl0IGNvbiBtZXNzYWdnaSB2dW90aSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDcyCisjOiBidWlsdGluL3JlYmFzZS5jOjE0OTYKIG1zZ2lkICJ0cnkgdG8gcmViYXNlIG1lcmdlcyBpbnN0ZWFkIG9mIHNraXBwaW5nIHRoZW0iCiBtc2dzdHIgInByb3ZhIGFkIGVzZWd1aXJlIGlsIHJlYmFzZSBkZWkgbWVyZ2UgYW56aWNow6kgc2FsdGFybGkiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ3NQorIzogYnVpbHRpbi9yZWJhc2UuYzoxNDk5CiBtc2dpZCAidXNlICdtZXJnZS1iYXNlIC0tZm9yay1wb2ludCcgdG8gcmVmaW5lIHVwc3RyZWFtIgogbXNnc3RyICIiCiAidXNhICdtZXJnZS1iYXNlIC0tZm9yay1wb2ludCcgcGVyIHJpZGVmaW5pcmUgcGnDuSBwcmVjaXNhbWVudGUgbCd1cHN0cmVhbSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDc3CisjOiBidWlsdGluL3JlYmFzZS5jOjE1MDEKIG1zZ2lkICJ1c2UgdGhlIGdpdmVuIG1lcmdlIHN0cmF0ZWd5IgogbXNnc3RyICJ1c2EgbGEgc3RyYXRlZ2lhIGRpIG1lcmdlIHNwZWNpZmljYXRhIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0NzkgYnVpbHRpbi9yZXZlcnQuYzoxMTUKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTUwMyBidWlsdGluL3JldmVydC5jOjExNQogbXNnaWQgIm9wdGlvbiIKIG1zZ3N0ciAib3B6aW9uZSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDgwCisjOiBidWlsdGluL3JlYmFzZS5jOjE1MDQKIG1zZ2lkICJwYXNzIHRoZSBhcmd1bWVudCB0aHJvdWdoIHRvIHRoZSBtZXJnZSBzdHJhdGVneSIKIG1zZ3N0ciAicGFzc2EgbCdhcmdvbWVudG8gYWxsYSBzdHJhdGVnaWEgZGkgbWVyZ2UiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ4MworIzogYnVpbHRpbi9yZWJhc2UuYzoxNTA3CiBtc2dpZCAicmViYXNlIGFsbCByZWFjaGFibGUgY29tbWl0cyB1cCB0byB0aGUgcm9vdChzKSIKIG1zZ3N0ciAiZXNlZ3VpIGlsIHJlYmFzZSBkaSB0dXR0aSBpIGNvbW1pdCByYWdnaXVuZ2liaWxpIGZpbm8gYSBxdWVsbGkgcmFkaWNlIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE1MDAKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTUyNAogbXNnaWQgIiIKICJ0aGUgcmViYXNlLnVzZUJ1aWx0aW4gc3VwcG9ydCBoYXMgYmVlbiByZW1vdmVkIVxuIgogIlNlZSBpdHMgZW50cnkgaW4gJ2dpdCBoZWxwIGNvbmZpZycgZm9yIGRldGFpbHMuIgpAQCAtMTc3NTEsMjkgKzE3ODQxLDM3IEBACiAiaWwgc3VwcG9ydG8gcGVyIHJlYmFzZS51c2VCdWlsdGluIMOoIHN0YXRvIHJpbW9zc28hXG4iCiAiVmVkaSBsYSB2b2NlIHJlbGF0aXZhIGluICdnaXQgaGVscCBjb25maWcnIHBlciBpIGRldHRhZ2xpLiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNTA2CisjOiBidWlsdGluL3JlYmFzZS5jOjE1MzAKIG1zZ2lkICJJdCBsb29rcyBsaWtlICdnaXQgYW0nIGlzIGluIHByb2dyZXNzLiBDYW5ub3QgcmViYXNlLiIKIG1zZ3N0ciAiU2VtYnJhIGNoZSAnZ2l0IGFtJyBzaWEgaW4gY29yc28uIEltcG9zc2liaWxlIGVzZWd1aXJlIGlsIHJlYmFzZS4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTU0NworIzogYnVpbHRpbi9yZWJhc2UuYzoxNTcxCiBtc2dpZCAiIgogImdpdCByZWJhc2UgLS1wcmVzZXJ2ZS1tZXJnZXMgaXMgZGVwcmVjYXRlZC4gVXNlIC0tcmViYXNlLW1lcmdlcyBpbnN0ZWFkLiIKIG1zZ3N0ciAiZ2l0IHJlYmFzZSAtLXByZXNlcnZlLW1lcmdlcyDDqCBkZXByZWNhdG8uIFVzYSAtLXJlYmFzZS1tZXJnZXMuIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE1NTEKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTU3NgorbXNnaWQgImNhbm5vdCBjb21iaW5lICctLWtlZXAtYmFzZScgd2l0aCAnLS1vbnRvJyIKK21zZ3N0ciAiaW1wb3NzaWJpbGUgY29tYmluYXJlICctLWtlZXAtYmFzZScgY29uICctLW9udG8nIgorCisjOiBidWlsdGluL3JlYmFzZS5jOjE1NzgKK21zZ2lkICJjYW5ub3QgY29tYmluZSAnLS1rZWVwLWJhc2UnIHdpdGggJy0tcm9vdCciCittc2dzdHIgImltcG9zc2liaWxlIGNvbWJpbmFyZSAnLS1rZWVwLWJhc2UnIGNvbiAnLS1yb290JyIKKworIzogYnVpbHRpbi9yZWJhc2UuYzoxNTgyCiBtc2dpZCAiTm8gcmViYXNlIGluIHByb2dyZXNzPyIKIG1zZ3N0ciAiTmVzc3VuIHJlYmFzZSBpbiBjb3Jzbz8iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTU1NQorIzogYnVpbHRpbi9yZWJhc2UuYzoxNTg2CiBtc2dpZCAiVGhlIC0tZWRpdC10b2RvIGFjdGlvbiBjYW4gb25seSBiZSB1c2VkIGR1cmluZyBpbnRlcmFjdGl2ZSByZWJhc2UuIgogbXNnc3RyICIiCiAiTCdhemlvbmUgLS1lZGl0LXRvZG8gcHXDsiBlc3NlcmUgdXNhdGEgc29sbyBkdXJhbnRlIHVuIHJlYmFzZSBpbnRlcmF0dGl2by4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTU3OAorIzogYnVpbHRpbi9yZWJhc2UuYzoxNjA5CiBtc2dpZCAiQ2Fubm90IHJlYWQgSEVBRCIKIG1zZ3N0ciAiSW1wb3NzaWJpbGUgbGVnZ2VyZSBsJ0hFQUQiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTU5MAorIzogYnVpbHRpbi9yZWJhc2UuYzoxNjIxCiBtc2dpZCAiIgogIllvdSBtdXN0IGVkaXQgYWxsIG1lcmdlIGNvbmZsaWN0cyBhbmQgdGhlblxuIgogIm1hcmsgdGhlbSBhcyByZXNvbHZlZCB1c2luZyBnaXQgYWRkIgpAQCAtMTc3ODIsMTYgKzE3ODgwLDE2IEBACiAicXVpbmRpIGNvbnRyYXNzZWduYXJsaSBjb21lIHJpc29sdGkgdXNhbmRvXG4iCiAiZ2l0IGFkZCIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNjA5CisjOiBidWlsdGluL3JlYmFzZS5jOjE2NDAKIG1zZ2lkICJjb3VsZCBub3QgZGlzY2FyZCB3b3JrdHJlZSBjaGFuZ2VzIgogbXNnc3RyICJpbXBvc3NpYmlsZSBzY2FydGFyZSBsZSBtb2RpZmljaGUgYWxsJ2FsYmVybyBkaSBsYXZvcm8iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTYyOAorIzogYnVpbHRpbi9yZWJhc2UuYzoxNjU5CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBtb3ZlIGJhY2sgdG8gJXMiCiBtc2dzdHIgImltcG9zc2liaWxlIHJpdG9ybmFyZSBhICVzIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE2NzMKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTcwNAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiSXQgc2VlbXMgdGhhdCB0aGVyZSBpcyBhbHJlYWR5IGEgJXMgZGlyZWN0b3J5LCBhbmRcbiIKQEAgLTE3ODEyLDE2NiArMTc5MTAsMTYwIEBACiAiZWQgZXNlZ3VpbWkgZGkgbnVvdm8uIE1pIGZlcm1vIG5lbCBjYXNvIGluIGN1aSB0dSBhYmJpYSBhbmNvcmFcbiIKICJzYWx2YXRvIHF1YWxjb3NhIGRpIGltcG9ydGFudGUgbMOsLlxuIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE2OTQKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTcyNQogbXNnaWQgInN3aXRjaCBgQycgZXhwZWN0cyBhIG51bWVyaWNhbCB2YWx1ZSIKIG1zZ3N0ciAibCdvcHppb25lIGBDYCByaWNoaWVkZSB1biB2YWxvcmUgbnVtZXJpY28iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTczNQorIzogYnVpbHRpbi9yZWJhc2UuYzoxNzY2CiAjLCBjLWZvcm1hdAogbXNnaWQgIlVua25vd24gbW9kZTogJXMiCiBtc2dzdHIgIk1vZG8gc2Nvbm9zY2l1dG86ICVzIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE3NTcKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTc4OAogbXNnaWQgIi0tc3RyYXRlZ3kgcmVxdWlyZXMgLS1tZXJnZSBvciAtLWludGVyYWN0aXZlIgogbXNnc3RyICItLXN0cmF0ZWd5IHJpY2hpZWRlIC0tbWVyZ2UgbyAtLWludGVyYWN0aXZlIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE3OTcKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTgyOAogbXNnaWQgIi0tcmVzY2hlZHVsZS1mYWlsZWQtZXhlYyByZXF1aXJlcyAtLWV4ZWMgb3IgLS1pbnRlcmFjdGl2ZSIKIG1zZ3N0ciAiLS1yZXNjaGVkdWxlLWZhaWxlZC1leGVjIHJpY2hpZWRlIC0tZXhlYyBvIC0taW50ZXJhY3RpdmUiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTgwOQorIzogYnVpbHRpbi9yZWJhc2UuYzoxODQwCiBtc2dpZCAiY2Fubm90IGNvbWJpbmUgYW0gb3B0aW9ucyB3aXRoIGVpdGhlciBpbnRlcmFjdGl2ZSBvciBtZXJnZSBvcHRpb25zIgogbXNnc3RyICJub24gw6ggcG9zc2liaWxlIGNvbWJpbmFyZSBsZSBvcHppb25pIGFtIGNvbiBxdWVsbGUgaW50ZXJhY3RpdmUgbyBtZXJnZSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxODI4CisjOiBidWlsdGluL3JlYmFzZS5jOjE4NTkKIG1zZ2lkICJjYW5ub3QgY29tYmluZSAnLS1wcmVzZXJ2ZS1tZXJnZXMnIHdpdGggJy0tcmViYXNlLW1lcmdlcyciCiBtc2dzdHIgImltcG9zc2liaWxlIGNvbWJpbmFyZSAnLS1wcmVzZXJ2ZS1tZXJnZXMnIGNvbiAnLS1yZWJhc2UtbWVyZ2VzJyIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxODMyCisjOiBidWlsdGluL3JlYmFzZS5jOjE4NjMKIG1zZ2lkICIiCiAiZXJyb3I6IGNhbm5vdCBjb21iaW5lICctLXByZXNlcnZlLW1lcmdlcycgd2l0aCAnLS1yZXNjaGVkdWxlLWZhaWxlZC1leGVjJyIKIG1zZ3N0ciAiIgogImVycm9yZTogaW1wb3NzaWJpbGUgY29tYmluYXJlICctLXByZXNlcnZlLW1lcmdlcycgY29uICctLXJlc2NoZWR1bGUtZmFpbGVkLSIKICJleGVjJyIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxODM4Ci1tc2dpZCAiY2Fubm90IGNvbWJpbmUgJy0tcmViYXNlLW1lcmdlcycgd2l0aCAnLS1zdHJhdGVneS1vcHRpb24nIgotbXNnc3RyICJpbXBvc3NpYmlsZSBjb21iaW5hcmUgJy0tcmViYXNlLW1lcmdlcycgY29uICctLXN0cmF0ZWd5LW9wdGlvbiciCi0KLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTg0MQotbXNnaWQgImNhbm5vdCBjb21iaW5lICctLXJlYmFzZS1tZXJnZXMnIHdpdGggJy0tc3RyYXRlZ3knIgotbXNnc3RyICJpbXBvc3NpYmlsZSBjb21iaW5hcmUgJy0tcmViYXNlLW1lcmdlcycgY29uICctLXN0cmF0ZWd5JyIKLQotIzogYnVpbHRpbi9yZWJhc2UuYzoxODY1CisjOiBidWlsdGluL3JlYmFzZS5jOjE4ODcKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCB1cHN0cmVhbSAnJXMnIgogbXNnc3RyICJ1cHN0cmVhbSBub24gdmFsaWRvOiAnJXMnIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE4NzEKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTg5MwogbXNnaWQgIkNvdWxkIG5vdCBjcmVhdGUgbmV3IHJvb3QgY29tbWl0IgogbXNnc3RyICJJbXBvc3NpYmlsZSBjcmVhcmUgaWwgbnVvdm8gY29tbWl0IHJhZGljZSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxODg5CisjOiBidWlsdGluL3JlYmFzZS5jOjE5MTkKKyMsIGMtZm9ybWF0Cittc2dpZCAiJyVzJzogbmVlZCBleGFjdGx5IG9uZSBtZXJnZSBiYXNlIHdpdGggYnJhbmNoIgorbXNnc3RyICIiCisiJyVzJzogw6ggbmVjZXNzYXJpbyBzcGVjaWZpY2FyZSBlc2F0dGFtZW50ZSB1bmEgYmFzZSBwZXIgaWwgbWVyZ2UgY29uIGlsICIKKyJicmFuY2giCisKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTkyMgogIywgYy1mb3JtYXQKIG1zZ2lkICInJXMnOiBuZWVkIGV4YWN0bHkgb25lIG1lcmdlIGJhc2UiCiBtc2dzdHIgIiclcyc6IMOoIG5lY2Vzc2FyaW8gc3BlY2lmaWNhcmUgZXNhdHRhbWVudGUgdW5hIGJhc2UgcGVyIGlsIG1lcmdlIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE4OTYKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTkzMAogIywgYy1mb3JtYXQKIG1zZ2lkICJEb2VzIG5vdCBwb2ludCB0byBhIHZhbGlkIGNvbW1pdCAnJXMnIgogbXNnc3RyICInJXMnIG5vbiBwdW50YSBhIHVuIGNvbW1pdCB2YWxpZG8iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTkyMQorIzogYnVpbHRpbi9yZWJhc2UuYzoxOTU1CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhdGFsOiBubyBzdWNoIGJyYW5jaC9jb21taXQgJyVzJyIKIG1zZ3N0ciAiZXJyb3JlIGZhdGFsZTogYnJhbmNoL2NvbW1pdCAnJXMnIGluZXNpc3RlbnRlIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE5MjkgYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjM4CisjOiBidWlsdGluL3JlYmFzZS5jOjE5NjMgYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjM4CiAjOiBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6MTkzNAogIywgYy1mb3JtYXQKIG1zZ2lkICJObyBzdWNoIHJlZjogJXMiCiBtc2dzdHIgIlJpZmVyaW1lbnRvIG5vbiBlc2lzdGVudGU6ICVzIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE5NDAKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTk3NAogbXNnaWQgIkNvdWxkIG5vdCByZXNvbHZlIEhFQUQgdG8gYSByZXZpc2lvbiIKIG1zZ3N0ciAiSW1wb3NzaWJpbGUgcmlzb2x2ZXJlIEhFQUQgY29tZSByZXZpc2lvbmUiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTk4MQorIzogYnVpbHRpbi9yZWJhc2UuYzoyMDEyCiBtc2dpZCAiQ2Fubm90IGF1dG9zdGFzaCIKIG1zZ3N0ciAiSW1wb3NzaWJpbGUgZXNlZ3VpcmUgbG8gc3Rhc2ggYXV0b21hdGljbyIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxOTg0CisjOiBidWlsdGluL3JlYmFzZS5jOjIwMTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiVW5leHBlY3RlZCBzdGFzaCByZXNwb25zZTogJyVzJyIKIG1zZ3N0ciAiUmlzcG9zdGEgc3Rhc2ggbm9uIGF0dGVzYTogJyVzJyIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxOTkwCisjOiBidWlsdGluL3JlYmFzZS5jOjIwMjEKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ291bGQgbm90IGNyZWF0ZSBkaXJlY3RvcnkgZm9yICclcyciCiBtc2dzdHIgIkltcG9zc2liaWxlIGNyZWFyZSBsYSBkaXJlY3RvcnkgJyVzJyIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxOTkzCisjOiBidWlsdGluL3JlYmFzZS5jOjIwMjQKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ3JlYXRlZCBhdXRvc3Rhc2g6ICVzXG4iCiBtc2dzdHIgIlN0YXNoIGF1dG9tYXRpY28gY3JlYXRvOiAlc1xuIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE5OTYKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MjAyNwogbXNnaWQgImNvdWxkIG5vdCByZXNldCAtLWhhcmQiCiBtc2dzdHIgImltcG9zc2liaWxlIGVzZWd1aXJlIHJlc2V0IC0taGFyZCIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxOTk3IGJ1aWx0aW4vcmVzZXQuYzoxMTQKLSMsIGMtZm9ybWF0Ci1tc2dpZCAiSEVBRCBpcyBub3cgYXQgJXMiCi1tc2dzdHIgIkhFQUQgb3JhIHNpIHRyb3ZhIGEgJXMiCi0KLSM6IGJ1aWx0aW4vcmViYXNlLmM6MjAxMworIzogYnVpbHRpbi9yZWJhc2UuYzoyMDM2CiBtc2dpZCAiUGxlYXNlIGNvbW1pdCBvciBzdGFzaCB0aGVtLiIKIG1zZ3N0ciAiRXNlZ3VpbmUgaWwgY29tbWl0IG8gbG8gc3Rhc2guIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjIwNDAKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MjA2MwogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcGFyc2UgJyVzJyIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgYW5hbGl6emFyZSAnJXMnIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjIwNTMKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MjA3NgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3Qgc3dpdGNoIHRvICVzIgogbXNnc3RyICJpbXBvc3NpYmlsZSBwYXNzYXJlIGEgJXMiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MjA2NAorIzogYnVpbHRpbi9yZWJhc2UuYzoyMDg3CiBtc2dpZCAiSEVBRCBpcyB1cCB0byBkYXRlLiIKIG1zZ3N0ciAiSEVBRCDDqCBhZ2dpb3JuYXRvLiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoyMDY2CisjOiBidWlsdGluL3JlYmFzZS5jOjIwODkKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ3VycmVudCBicmFuY2ggJXMgaXMgdXAgdG8gZGF0ZS5cbiIKIG1zZ3N0ciAiSWwgYnJhbmNoIGNvcnJlbnRlICVzIMOoIGFnZ2lvcm5hdG8uXG4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MjA3NAorIzogYnVpbHRpbi9yZWJhc2UuYzoyMDk3CiBtc2dpZCAiSEVBRCBpcyB1cCB0byBkYXRlLCByZWJhc2UgZm9yY2VkLiIKIG1zZ3N0ciAiSEVBRCDDqCBhZ2dpb3JuYXRvLCBmb3J6byBpbCByZWJhc2UuIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjIwNzYKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MjA5OQogIywgYy1mb3JtYXQKIG1zZ2lkICJDdXJyZW50IGJyYW5jaCAlcyBpcyB1cCB0byBkYXRlLCByZWJhc2UgZm9yY2VkLlxuIgogbXNnc3RyICJJbCBicmFuY2ggY29ycmVudGUgJXMgw6ggYWdnaW9ybmF0bywgZm9yem8gaWwgcmViYXNlLlxuIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjIwODQKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MjEwNwogbXNnaWQgIlRoZSBwcmUtcmViYXNlIGhvb2sgcmVmdXNlZCB0byByZWJhc2UuIgogbXNnc3RyICJMJ2hvb2sgcHJlLXJlYmFzZSBoYSByaWZpdXRhdG8gZGkgY29uc2VudGlyZSBpbCByZWJhc2UuIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjIwOTEKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MjExNAogIywgYy1mb3JtYXQKIG1zZ2lkICJDaGFuZ2VzIHRvICVzOlxuIgogbXNnc3RyICJNb2RpZmljaGUgYSAlczpcbiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoyMDk0CisjOiBidWlsdGluL3JlYmFzZS5jOjIxMTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ2hhbmdlcyBmcm9tICVzIHRvICVzOlxuIgogbXNnc3RyICJNb2RpZmljaGUgZGEgJXMgYSAlczpcbiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoyMTE5CisjOiBidWlsdGluL3JlYmFzZS5jOjIxNDIKICMsIGMtZm9ybWF0CiBtc2dpZCAiRmlyc3QsIHJld2luZGluZyBoZWFkIHRvIHJlcGxheSB5b3VyIHdvcmsgb24gdG9wIG9mIGl0Li4uXG4iCiBtc2dzdHIgIiIKICJQZXIgcHJpbWEgY29zYSwgcmlwcmlzdGlubyBsJ2hlYWQgcGVyIHJpYXBwbGljYXJlIGxlIHR1ZSBtb2RpZmljaGUgc3UgZGkgIgogImVzc28uLi5cbiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoyMTI4CisjOiBidWlsdGluL3JlYmFzZS5jOjIxNTEKIG1zZ2lkICJDb3VsZCBub3QgZGV0YWNoIEhFQUQiCiBtc2dzdHIgIkltcG9zc2liaWxlIHNjb2xsZWdhcmUgbCdIRUFEIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjIxMzcKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MjE2MAogIywgYy1mb3JtYXQKIG1zZ2lkICJGYXN0LWZvcndhcmRlZCAlcyB0byAlcy5cbiIKIG1zZ3N0ciAiRmFzdCBmb3J3YXJkIGRhICVzIGEgJXMgZXNlZ3VpdG8uXG4iCkBAIC0xNzk4MCw3ICsxODA3Miw3IEBACiBtc2dpZCAiZ2l0IHJlY2VpdmUtcGFjayA8Z2l0LWRpcj4iCiBtc2dzdHIgImdpdCByZWNlaXZlLXBhY2sgPGRpcmVjdG9yeSBHaXQ+IgogCi0jOiBidWlsdGluL3JlY2VpdmUtcGFjay5jOjgzMgorIzogYnVpbHRpbi9yZWNlaXZlLXBhY2suYzo4MzAKIG1zZ2lkICIiCiAiQnkgZGVmYXVsdCwgdXBkYXRpbmcgdGhlIGN1cnJlbnQgYnJhbmNoIGluIGEgbm9uLWJhcmUgcmVwb3NpdG9yeVxuIgogImlzIGRlbmllZCwgYmVjYXVzZSBpdCB3aWxsIG1ha2UgdGhlIGluZGV4IGFuZCB3b3JrIHRyZWUgaW5jb25zaXN0ZW50XG4iCkBAIC0xODAxMyw3ICsxODEwNSw3IEBACiAiaWwgY29tcG9ydGFtZW50byBwcmVkZWZpbml0bywgaW1wb3N0YSBsYSB2YXJpYWJpbGUgZGlcbiIKICJjb25maWd1cmF6aW9uZSAncmVjZWl2ZS5kZW55Q3VycmVudEJyYW5jaCcgYSAncmVmdXNlJy4iCiAKLSM6IGJ1aWx0aW4vcmVjZWl2ZS1wYWNrLmM6ODUyCisjOiBidWlsdGluL3JlY2VpdmUtcGFjay5jOjg1MAogbXNnaWQgIiIKICJCeSBkZWZhdWx0LCBkZWxldGluZyB0aGUgY3VycmVudCBicmFuY2ggaXMgZGVuaWVkLCBiZWNhdXNlIHRoZSBuZXh0XG4iCiAiJ2dpdCBjbG9uZScgd29uJ3QgcmVzdWx0IGluIGFueSBmaWxlIGNoZWNrZWQgb3V0LCBjYXVzaW5nIGNvbmZ1c2lvbi5cbiIKQEAgLTE4MDM2LDExICsxODEyOCwxMSBAQAogIlBlciBub24gdmlzdWFsaXp6YXJlIHBpw7kgcXVlc3RvIG1lc3NhZ2dpbywgcHVvaSBpbXBvc3RhcmxhIGFcbiIKICIncmVmdXNlJy4iCiAKLSM6IGJ1aWx0aW4vcmVjZWl2ZS1wYWNrLmM6MTkzOAorIzogYnVpbHRpbi9yZWNlaXZlLXBhY2suYzoxOTM2CiBtc2dpZCAicXVpZXQiCiBtc2dzdHIgIm5vbiB2aXN1YWxpenphcmUgbWVzc2FnZ2kiCiAKLSM6IGJ1aWx0aW4vcmVjZWl2ZS1wYWNrLmM6MTk1MgorIzogYnVpbHRpbi9yZWNlaXZlLXBhY2suYzoxOTUwCiBtc2dpZCAiWW91IG11c3Qgc3BlY2lmeSBhIGRpcmVjdG9yeS4iCiBtc2dzdHIgIkRldmkgc3BlY2lmaWNhcmUgdW5hIGRpcmVjdG9yeS4iCiAKQEAgLTE4NjIyLDExICsxODcxNCwxMSBAQAogbXNnaWQgIlVua25vd24gc3ViY29tbWFuZDogJXMiCiBtc2dzdHIgIlNvdHRvY29tYW5kbyBzY29ub3NjaXV0bzogJXMiCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MjIKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6MjMKIG1zZ2lkICJnaXQgcmVwYWNrIFs8b3B0aW9ucz5dIgogbXNnc3RyICJnaXQgcmVwYWNrIFs8b3B6aW9uaT5dIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjI3CisjOiBidWlsdGluL3JlcGFjay5jOjI4CiBtc2dpZCAiIgogIkluY3JlbWVudGFsIHJlcGFja3MgYXJlIGluY29tcGF0aWJsZSB3aXRoIGJpdG1hcCBpbmRleGVzLiAgVXNlXG4iCiAiLS1uby13cml0ZS1iaXRtYXAtaW5kZXggb3IgZGlzYWJsZSB0aGUgcGFjay53cml0ZWJpdG1hcHMgY29uZmlndXJhdGlvbi4iCkBAIC0xODYzNSwxMTggKzE4NzI3LDExOCBAQAogIlVzYSAtLW5vLXdyaXRlLWJpdG1hcC1pbmRleCBvIGRpc2FiaWxpdGEgbCdvcHppb25lIGRpIGNvbmZpZ3VyYXppb25lXG4iCiAicGFjay53cml0ZWJpdG1hcHMuIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjE5MAorIzogYnVpbHRpbi9yZXBhY2suYzoxOTEKIG1zZ2lkICJjb3VsZCBub3Qgc3RhcnQgcGFjay1vYmplY3RzIHRvIHJlcGFjayBwcm9taXNvciBvYmplY3RzIgogbXNnc3RyICIiCiAiaW1wb3NzaWJpbGUgYXZ2aWFyZSBwYWNrLW9iamVjdHMgcGVyIGVzZWd1aXJlIGlsIHJlcGFjayBkZWdsaSBvZ2dldHRpICIKICJwcm9tZXR0ZW50aSIKIAotIzogYnVpbHRpbi9yZXBhY2suYzoyMjkgYnVpbHRpbi9yZXBhY2suYzo0MDgKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6MjMwIGJ1aWx0aW4vcmVwYWNrLmM6NDA5CiBtc2dpZCAicmVwYWNrOiBFeHBlY3RpbmcgZnVsbCBoZXggb2JqZWN0IElEIGxpbmVzIG9ubHkgZnJvbSBwYWNrLW9iamVjdHMuIgogbXNnc3RyICIiCiAicmVwYWNrOiBEYSBwYWNrLW9iamVjdHMgbWkgYXR0ZW5kZXZvIHNvbG8gcmlnaGUgY29uIGdsaSBJRCBjb21wbGV0aSAiCiAiZXNhZGVjaW1hbGkgZGVnbGkgb2dnZXR0aS4iCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MjQ2CisjOiBidWlsdGluL3JlcGFjay5jOjI0NwogbXNnaWQgImNvdWxkIG5vdCBmaW5pc2ggcGFjay1vYmplY3RzIHRvIHJlcGFjayBwcm9taXNvciBvYmplY3RzIgogbXNnc3RyICIiCiAiaW1wb3NzaWJpbGUgcG9ydGFyZSBhIHRlcm1pbmUgcGFjay1vYmplY3RzIHBlciBlc2VndWlyZSBpbCByZXBhY2sgZGVnbGkgIgogIm9nZ2V0dGkgcHJvbWV0dGVudGkiCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6Mjg0CisjOiBidWlsdGluL3JlcGFjay5jOjI4NQogbXNnaWQgInBhY2sgZXZlcnl0aGluZyBpbiBhIHNpbmdsZSBwYWNrIgogbXNnc3RyICJlc2VndWkgaWwgcGFjayBkaSB0dXR0byBpbiB1biBzaW5nb2xvIHBhY2siCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6Mjg2CisjOiBidWlsdGluL3JlcGFjay5jOjI4NwogbXNnaWQgInNhbWUgYXMgLWEsIGFuZCB0dXJuIHVucmVhY2hhYmxlIG9iamVjdHMgbG9vc2UiCiBtc2dzdHIgImNvbWUgLWEgZSByZW5kaSBzY2lvbHRpIGdsaSBvZ2dldHRpIG5vbiByYWdnaXVuZ2liaWxpIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjI4OQorIzogYnVpbHRpbi9yZXBhY2suYzoyOTAKIG1zZ2lkICJyZW1vdmUgcmVkdW5kYW50IHBhY2tzLCBhbmQgcnVuIGdpdC1wcnVuZS1wYWNrZWQiCiBtc2dzdHIgInJpbXVvdmkgaSBwYWNrIHJpZG9uZGFudGkgZWQgZXNlZ3VpIGdpdC1wcnVuZS1wYWNrZWQiCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MjkxCisjOiBidWlsdGluL3JlcGFjay5jOjI5MgogbXNnaWQgInBhc3MgLS1uby1yZXVzZS1kZWx0YSB0byBnaXQtcGFjay1vYmplY3RzIgogbXNnc3RyICJmb3JuaXNjaSBsJ29wemlvbmUgLS1uby1yZXVzZS1kZWx0YSBhIGdpdC1wYWNrLW9iamVjdHMiCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MjkzCisjOiBidWlsdGluL3JlcGFjay5jOjI5NAogbXNnaWQgInBhc3MgLS1uby1yZXVzZS1vYmplY3QgdG8gZ2l0LXBhY2stb2JqZWN0cyIKIG1zZ3N0ciAiZm9ybmlzY2kgbCdvcHppb25lIC0tbm8tcmV1c2Utb2JqZWN0IGEgZ2l0LXBhY2stb2JqZWN0cyIKIAotIzogYnVpbHRpbi9yZXBhY2suYzoyOTUKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6Mjk2CiBtc2dpZCAiZG8gbm90IHJ1biBnaXQtdXBkYXRlLXNlcnZlci1pbmZvIgogbXNnc3RyICJub24gZXNlZ3VpcmUgZ2l0LXVwZGF0ZS1zZXJ2ZXItaW5mbyIKIAotIzogYnVpbHRpbi9yZXBhY2suYzoyOTgKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6Mjk5CiBtc2dpZCAicGFzcyAtLWxvY2FsIHRvIGdpdC1wYWNrLW9iamVjdHMiCiBtc2dzdHIgImZvcm5pc2NpIGwnb3B6aW9uZSAtLWxvY2FsIGEgZ2l0LXBhY2stb2JqZWN0cyIKIAotIzogYnVpbHRpbi9yZXBhY2suYzozMDAKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6MzAxCiBtc2dpZCAid3JpdGUgYml0bWFwIGluZGV4IgogbXNnc3RyICJzY3JpdmkgbCdpbmRpY2UgYml0bWFwIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjMwMgorIzogYnVpbHRpbi9yZXBhY2suYzozMDMKIG1zZ2lkICJwYXNzIC0tZGVsdGEtaXNsYW5kcyB0byBnaXQtcGFjay1vYmplY3RzIgogbXNnc3RyICJmb3JuaXNjaSBsJ29wemlvbmUgLS1kZWx0YS1pc2xhbmRzIGEgZ2l0LXBhY2stb2JqZWN0cyIKIAotIzogYnVpbHRpbi9yZXBhY2suYzozMDMKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6MzA0CiBtc2dpZCAiYXBwcm94aWRhdGUiCiBtc2dzdHIgImRhdGEgYXBwcm9zc2ltYXRpdmEiCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MzA0CisjOiBidWlsdGluL3JlcGFjay5jOjMwNQogbXNnaWQgIndpdGggLUEsIGRvIG5vdCBsb29zZW4gb2JqZWN0cyBvbGRlciB0aGFuIHRoaXMiCiBtc2dzdHIgImNvbiAtQSwgbm9uIHJlbmRlcmUgc2Npb2x0aSBnbGkgb2dnZXR0aSBtZW5vIHJlY2VudGkgZGkgcXVlc3RhIGRhdGEiCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MzA2CisjOiBidWlsdGluL3JlcGFjay5jOjMwNwogbXNnaWQgIndpdGggLWEsIHJlcGFjayB1bnJlYWNoYWJsZSBvYmplY3RzIgogbXNnc3RyICJjb24gLWEsIGVzZWd1aSBpbCByZXBhY2sgZGVnbGkgb2dnZXR0aSBub24gcmFnZ2l1bmdpYmlsaSIKIAotIzogYnVpbHRpbi9yZXBhY2suYzozMDgKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6MzA5CiBtc2dpZCAic2l6ZSBvZiB0aGUgd2luZG93IHVzZWQgZm9yIGRlbHRhIGNvbXByZXNzaW9uIgogbXNnc3RyICJkaW1lbnNpb25lIGRlbGxhIGZpbmVzdHJhIHVzYXRhIHBlciBsYSBjb21wcmVzc2lvbmUgZGVsdGEiCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MzA5IGJ1aWx0aW4vcmVwYWNrLmM6MzE1CisjOiBidWlsdGluL3JlcGFjay5jOjMxMCBidWlsdGluL3JlcGFjay5jOjMxNgogbXNnaWQgImJ5dGVzIgogbXNnc3RyICJieXRlIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjMxMAorIzogYnVpbHRpbi9yZXBhY2suYzozMTEKIG1zZ2lkICJzYW1lIGFzIHRoZSBhYm92ZSwgYnV0IGxpbWl0IG1lbW9yeSBzaXplIGluc3RlYWQgb2YgZW50cmllcyBjb3VudCIKIG1zZ3N0ciAiIgogImNvbWUgc29wcmEsIG1hIGxpbWl0YSBsZSBkaW1lbnNpb25pIGRlbGxhIG1lbW9yaWEgaW52ZWNlIGRlbCBudW1lcm8gZGkgdm9jaSIKIAotIzogYnVpbHRpbi9yZXBhY2suYzozMTIKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6MzEzCiBtc2dpZCAibGltaXRzIHRoZSBtYXhpbXVtIGRlbHRhIGRlcHRoIgogbXNnc3RyICJsaW1pdGEgbGEgcHJvZm9uZGl0w6AgbWFzc2ltYSBkZWkgZGVsdGEiCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MzE0CisjOiBidWlsdGluL3JlcGFjay5jOjMxNQogbXNnaWQgImxpbWl0cyB0aGUgbWF4aW11bSBudW1iZXIgb2YgdGhyZWFkcyIKIG1zZ3N0ciAibGltaXRhIGlsIG51bWVybyBtYXNzaW1vIGRpIHRocmVhZCIKIAotIzogYnVpbHRpbi9yZXBhY2suYzozMTYKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6MzE3CiBtc2dpZCAibWF4aW11bSBzaXplIG9mIGVhY2ggcGFja2ZpbGUiCiBtc2dzdHIgImRpbWVuc2lvbmUgbWFzc2ltYSBkaSBvZ25pIGZpbGUgcGFjayIKIAotIzogYnVpbHRpbi9yZXBhY2suYzozMTgKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6MzE5CiBtc2dpZCAicmVwYWNrIG9iamVjdHMgaW4gcGFja3MgbWFya2VkIHdpdGggLmtlZXAiCiBtc2dzdHIgImVzZWd1aSBpbCByZXBhY2sgZGVnbGkgb2dnZXR0aSBuZWkgcGFjayBjb250cmFzc2VnbmF0aSBjb24gLmtlZXAiCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MzIwCisjOiBidWlsdGluL3JlcGFjay5jOjMyMQogbXNnaWQgImRvIG5vdCByZXBhY2sgdGhpcyBwYWNrIgogbXNnc3RyICJub24gZXNlZ3VpcmUgaWwgcmVwYWNrIGRpIHF1ZXN0byBwYWNrIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjMzMAorIzogYnVpbHRpbi9yZXBhY2suYzozMzEKIG1zZ2lkICJjYW5ub3QgZGVsZXRlIHBhY2tzIGluIGEgcHJlY2lvdXMtb2JqZWN0cyByZXBvIgogbXNnc3RyICJpbXBvc3NpYmlsZSBlbGltaW5hcmUgaSBwYWNrIGluIHVuIHJlcG9zaXRvcnkgJ29nZ2V0dGkgcHJlemlvc2knIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjMzNAorIzogYnVpbHRpbi9yZXBhY2suYzozMzUKIG1zZ2lkICItLWtlZXAtdW5yZWFjaGFibGUgYW5kIC1BIGFyZSBpbmNvbXBhdGlibGUiCiBtc2dzdHIgIi0ta2VlcC11bnJlYWNoYWJsZSBlIC1BIG5vbiBzb25vIGNvbXBhdGliaWxpIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjQxNworIzogYnVpbHRpbi9yZXBhY2suYzo0MTgKIG1zZ2lkICJOb3RoaW5nIG5ldyB0byBwYWNrLiIKIG1zZ3N0ciAiTm9uIGNpIHNvbm8gb2dnZXR0aSBudW92aSBkaSBjdWkgZXNlZ3VpcmUgaWwgcGFjay4iCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6NDc4CisjOiBidWlsdGluL3JlcGFjay5jOjQ3OQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiV0FSTklORzogU29tZSBwYWNrcyBpbiB1c2UgaGF2ZSBiZWVuIHJlbmFtZWQgYnlcbiIKQEAgLTE4NzY2LDcgKzE4ODU4LDcgQEAKICJBVlZJU086IG5vbiDDqCByaXVzY2l0by4gUmlkZW5vbWluYWxpIG1hbnVhbG1lbnRlXG4iCiAiQVZWSVNPOiBlbnRybyAlczpcbiIKIAotIzogYnVpbHRpbi9yZXBhY2suYzo1MjYKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6NTI3CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byByZW1vdmUgJyVzJyIKIG1zZ3N0ciAiZWxpbWluYXppb25lIGRpICclcycgbm9uIHJpdXNjaXRhIgpAQCAtMTg4NzQsOCArMTg5NjYsOCBAQAogbXNnaWQgInVuYWJsZSB0byB3cml0ZSBvYmplY3QgdG8gZGF0YWJhc2UiCiBtc2dzdHIgImltcG9zc2liaWxlIHNjcml2ZXJlIGwnb2dnZXR0byBuZWwgZGF0YWJhc2UiCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjMyMiBidWlsdGluL3JlcGxhY2UuYzozNzcgYnVpbHRpbi9yZXBsYWNlLmM6NDIyCi0jOiBidWlsdGluL3JlcGxhY2UuYzo0NTIKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjMyMiBidWlsdGluL3JlcGxhY2UuYzozNzggYnVpbHRpbi9yZXBsYWNlLmM6NDIzCisjOiBidWlsdGluL3JlcGxhY2UuYzo0NTMKICMsIGMtZm9ybWF0CiBtc2dpZCAibm90IGEgdmFsaWQgb2JqZWN0IG5hbWU6ICclcyciCiBtc2dzdHIgIm5vbWUgb2dnZXR0byBub24gdmFsaWRvOiAnJXMnIgpAQCAtMTg4OTQsMjIgKzE4OTg2LDIyIEBACiBtc2dpZCAibmV3IG9iamVjdCBpcyB0aGUgc2FtZSBhcyB0aGUgb2xkIG9uZTogJyVzJyIKIG1zZ3N0ciAiaWwgbnVvdm8gb2dnZXR0byDDqCBsbyBzdGVzc28gZGkgcXVlbGxvIHZlY2NoaW86ICclcyciCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjM4MworIzogYnVpbHRpbi9yZXBsYWNlLmM6Mzg0CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBwYXJzZSAlcyBhcyBhIGNvbW1pdCIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgYW5hbGl6emFyZSAlcyBjb21lIGNvbW1pdCIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NDE0CisjOiBidWlsdGluL3JlcGxhY2UuYzo0MTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiYmFkIG1lcmdldGFnIGluIGNvbW1pdCAnJXMnIgogbXNnc3RyICJ0YWcgbWVyZ2Ugbm9uIHZhbGlkbyBuZWwgY29tbWl0ICclcyciCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjQxNgorIzogYnVpbHRpbi9yZXBsYWNlLmM6NDE3CiAjLCBjLWZvcm1hdAogbXNnaWQgIm1hbGZvcm1lZCBtZXJnZXRhZyBpbiBjb21taXQgJyVzJyIKIG1zZ3N0ciAidGFnIG1lcmdlIG1hbGZvcm1hdG8gbmVsIGNvbW1pdCAnJXMnIgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo0MjgKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjQyOQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAib3JpZ2luYWwgY29tbWl0ICclcycgY29udGFpbnMgbWVyZ2V0YWcgJyVzJyB0aGF0IGlzIGRpc2NhcmRlZDsgdXNlIC0tZWRpdCAiCkBAIC0xODkxOCwzMSArMTkwMTAsMzEgQEAKICJpbCBjb21taXQgb3JpZ2luYXJpbyAnJXMnIGNvbnRpZW5lIGlsIHRhZyBtZXJnZSAnJXMnIGNoZSDDqCBzdGF0byBzY2FydGF0bzsgIgogInVzYSAtLWVkaXQgYW56aWNow6kgLS1ncmFmdCIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NDY3CisjOiBidWlsdGluL3JlcGxhY2UuYzo0NjgKICMsIGMtZm9ybWF0CiBtc2dpZCAidGhlIG9yaWdpbmFsIGNvbW1pdCAnJXMnIGhhcyBhIGdwZyBzaWduYXR1cmUiCiBtc2dzdHIgImlsIGNvbW1pdCBvcmlnaW5hcmlvICclcycgaGEgdW5hIGZpcm1hIEdQRyIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NDY4CisjOiBidWlsdGluL3JlcGxhY2UuYzo0NjkKIG1zZ2lkICJ0aGUgc2lnbmF0dXJlIHdpbGwgYmUgcmVtb3ZlZCBpbiB0aGUgcmVwbGFjZW1lbnQgY29tbWl0ISIKIG1zZ3N0ciAibGEgZmlybWEgc2Fyw6Agcmltb3NzYSBuZWwgY29tbWl0IHNvc3RpdHV0aXZvISIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NDc4CisjOiBidWlsdGluL3JlcGxhY2UuYzo0NzkKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHdyaXRlIHJlcGxhY2VtZW50IGNvbW1pdCBmb3I6ICclcyciCiBtc2dzdHIgImltcG9zc2liaWxlIHNjcml2ZXJlIGlsIGNvbW1pdCBzb3N0aXR1dGl2byBwZXIgJyVzJyIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NDg2CisjOiBidWlsdGluL3JlcGxhY2UuYzo0ODcKICMsIGMtZm9ybWF0CiBtc2dpZCAiZ3JhZnQgZm9yICclcycgdW5uZWNlc3NhcnkiCiBtc2dzdHIgImdyYWZ0IHBlciAnJXMnIG5vbiBuZWNlc3NhcmlvIgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo0OTAKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjQ5MQogIywgYy1mb3JtYXQKIG1zZ2lkICJuZXcgY29tbWl0IGlzIHRoZSBzYW1lIGFzIHRoZSBvbGQgb25lOiAnJXMnIgogbXNnc3RyICJpbCBudW92byBjb21taXQgw6ggbG8gc3Rlc3NvIGRpIHF1ZWxsbyB2ZWNjaGlvOiAnJXMnIgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo1MjUKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjUyNgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiY291bGQgbm90IGNvbnZlcnQgdGhlIGZvbGxvd2luZyBncmFmdChzKTpcbiIKQEAgLTE4OTUxLDcxICsxOTA0Myw3MSBAQAogImltcG9zc2liaWxlIGNvbnZlcnRpcmUgaSBzZWd1ZW50aSBncmFmdDpcbiIKICIlcyIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NTQ2CisjOiBidWlsdGluL3JlcGxhY2UuYzo1NDcKIG1zZ2lkICJsaXN0IHJlcGxhY2UgcmVmcyIKIG1zZ3N0ciAiZWxlbmNhIGkgcmlmZXJpbWVudGkgc29zdGl0dXRpdmkiCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU0NworIzogYnVpbHRpbi9yZXBsYWNlLmM6NTQ4CiBtc2dpZCAiZGVsZXRlIHJlcGxhY2UgcmVmcyIKIG1zZ3N0ciAiZWxpbWluYSBpIHJpZmVyaW1lbnRpIHNvc3RpdHV0aXZpIgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo1NDgKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU0OQogbXNnaWQgImVkaXQgZXhpc3Rpbmcgb2JqZWN0IgogbXNnc3RyICJtb2RpZmljYSBsJ29nZ2V0dG8gZXNpc3RlbnRlIgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo1NDkKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU1MAogbXNnaWQgImNoYW5nZSBhIGNvbW1pdCdzIHBhcmVudHMiCiBtc2dzdHIgImNhbWJpYSBpIGdlbml0b3JpIGRpIHVuIGNvbW1pdCIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NTUwCisjOiBidWlsdGluL3JlcGxhY2UuYzo1NTEKIG1zZ2lkICJjb252ZXJ0IGV4aXN0aW5nIGdyYWZ0IGZpbGUiCiBtc2dzdHIgImNvbnZlcnRpIHVuIGZpbGUgZ3JhZnQgZXNpc3RlbnRlIgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo1NTEKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU1MgogbXNnaWQgInJlcGxhY2UgdGhlIHJlZiBpZiBpdCBleGlzdHMiCiBtc2dzdHIgInNvc3RpdHVpc2NpIGlsIHJpZmVyaW1lbnRvIHNlIGVzaXN0ZSIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NTUzCisjOiBidWlsdGluL3JlcGxhY2UuYzo1NTQKIG1zZ2lkICJkbyBub3QgcHJldHR5LXByaW50IGNvbnRlbnRzIGZvciAtLWVkaXQiCiBtc2dzdHIgIm5vbiBzdGFtcGFyZSBpIGNvbnRlbnV0aSBpbiB1biBmb3JtYXRvIGxlZ2dpYmlsZSAocGVyIC0tZWRpdCkiCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU1NAorIzogYnVpbHRpbi9yZXBsYWNlLmM6NTU1CiBtc2dpZCAidXNlIHRoaXMgZm9ybWF0IgogbXNnc3RyICJ1c2EgcXVlc3RvIGZvcm1hdG8iCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU2NworIzogYnVpbHRpbi9yZXBsYWNlLmM6NTY4CiBtc2dpZCAiLS1mb3JtYXQgY2Fubm90IGJlIHVzZWQgd2hlbiBub3QgbGlzdGluZyIKIG1zZ3N0ciAiLS1mb3JtYXQgbm9uIHB1w7IgZXNzZXJlIHVzYXRvIHF1YW5kbyBub24gc2kgZWxlbmNhbm8gdm9jaSIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NTc1CisjOiBidWlsdGluL3JlcGxhY2UuYzo1NzYKIG1zZ2lkICItZiBvbmx5IG1ha2VzIHNlbnNlIHdoZW4gd3JpdGluZyBhIHJlcGxhY2VtZW50IgogbXNnc3RyICItZiBoYSBzZW5zbyBzb2xvIHNlIHNpIHN0YSBzY3JpdmVuZG8gdW4gb2dnZXR0byBzb3N0aXR1dGl2byIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NTc5CisjOiBidWlsdGluL3JlcGxhY2UuYzo1ODAKIG1zZ2lkICItLXJhdyBvbmx5IG1ha2VzIHNlbnNlIHdpdGggLS1lZGl0IgogbXNnc3RyICItLXJhdyBoYSBzZW5zbyBzb2xvIGNvbiAtLWVkaXQiCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU4NQorIzogYnVpbHRpbi9yZXBsYWNlLmM6NTg2CiBtc2dpZCAiLWQgbmVlZHMgYXQgbGVhc3Qgb25lIGFyZ3VtZW50IgogbXNnc3RyICItZCByaWNoaWVkZSBhbG1lbm8gdW4gYXJnb21lbnRvIgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo1OTEKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU5MgogbXNnaWQgImJhZCBudW1iZXIgb2YgYXJndW1lbnRzIgogbXNnc3RyICJudW1lcm8gZGkgYXJnb21lbnRpIGVycmF0byIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NTk3CisjOiBidWlsdGluL3JlcGxhY2UuYzo1OTgKIG1zZ2lkICItZSBuZWVkcyBleGFjdGx5IG9uZSBhcmd1bWVudCIKIG1zZ3N0ciAiLWUgcmljaGllZGUgZXNhdHRhbWVudGUgdW4gYXJnb21lbnRvIgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo2MDMKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjYwNAogbXNnaWQgIi1nIG5lZWRzIGF0IGxlYXN0IG9uZSBhcmd1bWVudCIKIG1zZ3N0ciAiLWcgcmljaGllZGUgYWxtZW5vIHVuIGFyZ29tZW50byIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NjA5CisjOiBidWlsdGluL3JlcGxhY2UuYzo2MTAKIG1zZ2lkICItLWNvbnZlcnQtZ3JhZnQtZmlsZSB0YWtlcyBubyBhcmd1bWVudCIKIG1zZ3N0ciAiLS1jb252ZXJ0LWdyYWZ0LWZpbGUgbm9uIHJpY2hpZWRlIGFyZ29tZW50aSIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NjE1CisjOiBidWlsdGluL3JlcGxhY2UuYzo2MTYKIG1zZ2lkICJvbmx5IG9uZSBwYXR0ZXJuIGNhbiBiZSBnaXZlbiB3aXRoIC1sIgogbXNnc3RyICJjb24gLWwgcHXDsiBlc3NlcmUgc3BlY2lmaWNhdG8gc29sbyB1biBwYXR0ZXJuIgogCkBAIC0xOTA4NCwxMyArMTkxNzYsMTggQEAKIG1zZ2lkICJGYWlsZWQgdG8gZmluZCB0cmVlIG9mICVzLiIKIG1zZ3N0ciAiSW1wb3NzaWJpbGUgdHJvdmFyZSBsJ2FsYmVybyBkaSAlcy4iCiAKKyM6IGJ1aWx0aW4vcmVzZXQuYzoxMTQKKyMsIGMtZm9ybWF0Cittc2dpZCAiSEVBRCBpcyBub3cgYXQgJXMiCittc2dzdHIgIkhFQUQgb3JhIHNpIHRyb3ZhIGEgJXMiCisKICM6IGJ1aWx0aW4vcmVzZXQuYzoxOTMKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ2Fubm90IGRvIGEgJXMgcmVzZXQgaW4gdGhlIG1pZGRsZSBvZiBhIG1lcmdlLiIKIG1zZ3N0ciAiSW1wb3NzaWJpbGUgZXNlZ3VpcmUgdW4gJXMgcmVzZXQgbmVsIGNvcnNvIGRpIHVuIG1lcmdlLiIKIAotIzogYnVpbHRpbi9yZXNldC5jOjI5MyBidWlsdGluL3N0YXNoLmM6NTE0IGJ1aWx0aW4vc3Rhc2guYzo1ODkKLSM6IGJ1aWx0aW4vc3Rhc2guYzo2MTMKKyM6IGJ1aWx0aW4vcmVzZXQuYzoyOTMgYnVpbHRpbi9zdGFzaC5jOjUyMCBidWlsdGluL3N0YXNoLmM6NTk1CisjOiBidWlsdGluL3N0YXNoLmM6NjE5CiBtc2dpZCAiYmUgcXVpZXQsIG9ubHkgcmVwb3J0IGVycm9ycyIKIG1zZ3N0ciAibm9uIHZpc3VhbGl6emFyZSBtZXNzYWdnaSwgc2VnbmFsYSBzb2xvIGdsaSBlcnJvcmkiCiAKQEAgLTE5MTc0LDI0ICsxOTI3MSwxOSBAQAogbXNnaWQgIkNvdWxkIG5vdCB3cml0ZSBuZXcgaW5kZXggZmlsZS4iCiBtc2dzdHIgIkltcG9zc2liaWxlIHNjcml2ZXJlIGlsIG51b3ZvIGZpbGUgaW5kaWNlLiIKIAotIzogYnVpbHRpbi9yZXYtbGlzdC5jOjQxMgorIzogYnVpbHRpbi9yZXYtbGlzdC5jOjQxMQogbXNnaWQgImNhbm5vdCBjb21iaW5lIC0tZXhjbHVkZS1wcm9taXNvci1vYmplY3RzIGFuZCAtLW1pc3NpbmciCiBtc2dzdHIgImltcG9zc2liaWxlIGNvbWJpbmFyZSAtLWV4Y2x1ZGUtcHJvbWlzb3Itb2JqZWN0cyBlIC0tbWlzc2luZyIKIAotIzogYnVpbHRpbi9yZXYtbGlzdC5jOjQ3MworIzogYnVpbHRpbi9yZXYtbGlzdC5jOjQ3MgogbXNnaWQgIm9iamVjdCBmaWx0ZXJpbmcgcmVxdWlyZXMgLS1vYmplY3RzIgogbXNnc3RyICJpbCBmaWx0cmFnZ2lvIG9nZ2V0dGkgcmljaGllZGUgLS1vYmplY3RzIgogCi0jOiBidWlsdGluL3Jldi1saXN0LmM6NDc2Ci0jLCBjLWZvcm1hdAotbXNnaWQgImludmFsaWQgc3BhcnNlIHZhbHVlICclcyciCi1tc2dzdHIgInZhbG9yZSBzcGFyc2Ugbm9uIHZhbGlkbzogJyVzJyIKLQotIzogYnVpbHRpbi9yZXYtbGlzdC5jOjUyNworIzogYnVpbHRpbi9yZXYtbGlzdC5jOjUyMgogbXNnaWQgInJldi1saXN0IGRvZXMgbm90IHN1cHBvcnQgZGlzcGxheSBvZiBub3RlcyIKIG1zZ3N0ciAicmV2LWxpc3Qgbm9uIHN1cHBvcnRhIGxhIHZpc3VhbGl6emF6aW9uZSBkZWxsZSBub3RlIgogCi0jOiBidWlsdGluL3Jldi1saXN0LmM6NTMwCisjOiBidWlsdGluL3Jldi1saXN0LmM6NTI1CiBtc2dpZCAiY2Fubm90IGNvbWJpbmUgLS11c2UtYml0bWFwLWluZGV4IHdpdGggb2JqZWN0IGZpbHRlcmluZyIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgY29tYmluYXJlIC0tdXNlLWJpdG1hcC1pbmRleCBjb24gaWwgZmlsdHJhZ2dpbyBvZ2dldHRpIgogCkBAIC0xOTc0MiwxMzYgKzE5ODM0LDEzNiBAQAogbXNnaWQgImNvdWxkIG5vdCBzYXZlIGluZGV4IHRyZWUiCiBtc2dzdHIgImltcG9zc2liaWxlIHNhbHZhcmUgbCdhbGJlcm8gaW5kaWNlIgogCi0jOiBidWlsdGluL3N0YXNoLmM6NDM0CisjOiBidWlsdGluL3N0YXNoLmM6NDM2CiBtc2dpZCAiY291bGQgbm90IHJlc3RvcmUgdW50cmFja2VkIGZpbGVzIGZyb20gc3Rhc2giCiBtc2dzdHIgIm5vbiDDqCBzdGF0byBwb3NzaWJpbGUgcmlwcmlzdGluYXJlIGkgZmlsZSBub24gdHJhY2NpYXRpIGRhbGxvIHN0YXNoIgogCi0jOiBidWlsdGluL3N0YXNoLmM6NDQ4CisjOiBidWlsdGluL3N0YXNoLmM6NDUwCiAjLCBjLWZvcm1hdAogbXNnaWQgIk1lcmdpbmcgJXMgd2l0aCAlcyIKIG1zZ3N0ciAiTWVyZ2UgZGkgJXMgY29uICVzIGluIGNvcnNvIgogCi0jOiBidWlsdGluL3N0YXNoLmM6NDU4IGdpdC1sZWdhY3ktc3Rhc2guc2g6NjgwCisjOiBidWlsdGluL3N0YXNoLmM6NDYwIGdpdC1sZWdhY3ktc3Rhc2guc2g6NjgwCiBtc2dpZCAiSW5kZXggd2FzIG5vdCB1bnN0YXNoZWQuIgogbXNnc3RyICJMJ2luZGljZSBub24gw6ggc3RhdG8gcmltb3NzbyBkYWxsbyBzdGFzaC4iCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzo1MTYgYnVpbHRpbi9zdGFzaC5jOjYxNQorIzogYnVpbHRpbi9zdGFzaC5jOjUyMiBidWlsdGluL3N0YXNoLmM6NjIxCiBtc2dpZCAiYXR0ZW1wdCB0byByZWNyZWF0ZSB0aGUgaW5kZXgiCiBtc2dzdHIgInRlbnRhIGRpIHJpY3JlYXJlIGwnaW5kaWNlIgogCi0jOiBidWlsdGluL3N0YXNoLmM6NTQ5CisjOiBidWlsdGluL3N0YXNoLmM6NTU1CiAjLCBjLWZvcm1hdAogbXNnaWQgIkRyb3BwZWQgJXMgKCVzKSIKIG1zZ3N0ciAiSG8gc2NhcnRhdG8gJXMgKCVzKSIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjU1MgorIzogYnVpbHRpbi9zdGFzaC5jOjU1OAogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogQ291bGQgbm90IGRyb3Agc3Rhc2ggZW50cnkiCiBtc2dzdHIgIiVzOiBJbXBvc3NpYmlsZSBzY2FydGFyZSBsYSB2b2NlIGRpIHN0YXNoIgogCi0jOiBidWlsdGluL3N0YXNoLmM6NTc3CisjOiBidWlsdGluL3N0YXNoLmM6NTgzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiclcycgaXMgbm90IGEgc3Rhc2ggcmVmZXJlbmNlIgogbXNnc3RyICInJXMnIG5vbiDDqCB1biByaWZlcmltZW50byBzdGFzaCIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjYyNyBnaXQtbGVnYWN5LXN0YXNoLnNoOjY5NAorIzogYnVpbHRpbi9zdGFzaC5jOjYzMyBnaXQtbGVnYWN5LXN0YXNoLnNoOjY5NAogbXNnaWQgIlRoZSBzdGFzaCBlbnRyeSBpcyBrZXB0IGluIGNhc2UgeW91IG5lZWQgaXQgYWdhaW4uIgogbXNnc3RyICIiCiAiTGEgdm9jZSBkaSBzdGFzaCDDqCBtYW50ZW51dGEgbmVsIGNhc28gaW4gY3VpIHR1IG5lIGFiYmlhIG51b3ZhbWVudGUgYmlzb2duby4iCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzo2NTAgZ2l0LWxlZ2FjeS1zdGFzaC5zaDo3MTIKKyM6IGJ1aWx0aW4vc3Rhc2guYzo2NTYgZ2l0LWxlZ2FjeS1zdGFzaC5zaDo3MTIKIG1zZ2lkICJObyBicmFuY2ggbmFtZSBzcGVjaWZpZWQiCiBtc2dzdHIgIk5vbWUgZGVsIGJyYW5jaCBub24gc3BlY2lmaWNhdG8iCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzo3OTAgYnVpbHRpbi9zdGFzaC5jOjgyNworIzogYnVpbHRpbi9zdGFzaC5jOjc5NiBidWlsdGluL3N0YXNoLmM6ODMzCiAjLCBjLWZvcm1hdAogbXNnaWQgIkNhbm5vdCB1cGRhdGUgJXMgd2l0aCAlcyIKIG1zZ3N0ciAiSW1wb3NzaWJpbGUgYWdnaW9ybmFyZSAlcyBjb24gJXMiCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzo4MDggYnVpbHRpbi9zdGFzaC5jOjE0NjEgYnVpbHRpbi9zdGFzaC5jOjE0OTcKKyM6IGJ1aWx0aW4vc3Rhc2guYzo4MTQgYnVpbHRpbi9zdGFzaC5jOjE0NzAgYnVpbHRpbi9zdGFzaC5jOjE1MDYKIG1zZ2lkICJzdGFzaCBtZXNzYWdlIgogbXNnc3RyICJtZXNzYWdnaW8gZGkgc3Rhc2giCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzo4MTgKKyM6IGJ1aWx0aW4vc3Rhc2guYzo4MjQKIG1zZ2lkICJcImdpdCBzdGFzaCBzdG9yZVwiIHJlcXVpcmVzIG9uZSA8Y29tbWl0PiBhcmd1bWVudCIKIG1zZ3N0ciAiXCJnaXQgc3Rhc2ggc3RvcmVcIiByaWNoaWVkZSB1biBhcmdvbWVudG8gPGNvbW1pdD4iCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzoxMDQwIGdpdC1sZWdhY3ktc3Rhc2guc2g6MjE3CisjOiBidWlsdGluL3N0YXNoLmM6MTA0NiBnaXQtbGVnYWN5LXN0YXNoLnNoOjIxNwogbXNnaWQgIk5vIGNoYW5nZXMgc2VsZWN0ZWQiCiBtc2dzdHIgIk5lc3N1bmEgbW9kaWZpY2Egc2VsZXppb25hdGEiCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzoxMTM2IGdpdC1sZWdhY3ktc3Rhc2guc2g6MTUwCisjOiBidWlsdGluL3N0YXNoLmM6MTE0NSBnaXQtbGVnYWN5LXN0YXNoLnNoOjE1MAogbXNnaWQgIllvdSBkbyBub3QgaGF2ZSB0aGUgaW5pdGlhbCBjb21taXQgeWV0IgogbXNnc3RyICJOb24gaGFpIGFuY29yYSB1biBjb21taXQgaW5pemlhbGUiCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzoxMTYzIGdpdC1sZWdhY3ktc3Rhc2guc2g6MTY1CisjOiBidWlsdGluL3N0YXNoLmM6MTE3MiBnaXQtbGVnYWN5LXN0YXNoLnNoOjE2NQogbXNnaWQgIkNhbm5vdCBzYXZlIHRoZSBjdXJyZW50IGluZGV4IHN0YXRlIgogbXNnc3RyICJJbXBvc3NpYmlsZSBzYWx2YXJlIGxvIHN0YXRvIGNvcnJlbnRlIGRpIGluZGV4IgogCi0jOiBidWlsdGluL3N0YXNoLmM6MTE3MiBnaXQtbGVnYWN5LXN0YXNoLnNoOjE4MAorIzogYnVpbHRpbi9zdGFzaC5jOjExODEgZ2l0LWxlZ2FjeS1zdGFzaC5zaDoxODAKIG1zZ2lkICJDYW5ub3Qgc2F2ZSB0aGUgdW50cmFja2VkIGZpbGVzIgogbXNnc3RyICJJbXBvc3NpYmlsZSBzYWx2YXJlIGkgZmlsZSBub24gdHJhY2NpYXRpIgogCi0jOiBidWlsdGluL3N0YXNoLmM6MTE4MyBidWlsdGluL3N0YXNoLmM6MTE5MiBnaXQtbGVnYWN5LXN0YXNoLnNoOjIwMAorIzogYnVpbHRpbi9zdGFzaC5jOjExOTIgYnVpbHRpbi9zdGFzaC5jOjEyMDEgZ2l0LWxlZ2FjeS1zdGFzaC5zaDoyMDAKICM6IGdpdC1sZWdhY3ktc3Rhc2guc2g6MjEzCiBtc2dpZCAiQ2Fubm90IHNhdmUgdGhlIGN1cnJlbnQgd29ya3RyZWUgc3RhdGUiCiBtc2dzdHIgIkltcG9zc2liaWxlIHNhbHZhcmUgbG8gc3RhdG8gY29ycmVudGUgZGVsbCdhbGJlcm8gZGkgbGF2b3JvIgogCi0jOiBidWlsdGluL3N0YXNoLmM6MTIyMCBnaXQtbGVnYWN5LXN0YXNoLnNoOjIzMworIzogYnVpbHRpbi9zdGFzaC5jOjEyMjkgZ2l0LWxlZ2FjeS1zdGFzaC5zaDoyMzMKIG1zZ2lkICJDYW5ub3QgcmVjb3JkIHdvcmtpbmcgdHJlZSBzdGF0ZSIKIG1zZ3N0ciAiSW1wb3NzaWJpbGUgcmVnaXN0cmFyZSBsbyBzdGF0byBkZWxsJ2FsYmVybyBkaSBsYXZvcm8iCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzoxMjY5IGdpdC1sZWdhY3ktc3Rhc2guc2g6MzM3CisjOiBidWlsdGluL3N0YXNoLmM6MTI3OCBnaXQtbGVnYWN5LXN0YXNoLnNoOjMzNwogbXNnaWQgIkNhbid0IHVzZSAtLXBhdGNoIGFuZCAtLWluY2x1ZGUtdW50cmFja2VkIG9yIC0tYWxsIGF0IHRoZSBzYW1lIHRpbWUiCiBtc2dzdHIgIiIKICJJbXBvc3NpYmlsZSB1c2FyZSAtLXBhdGNoIGUgLS1pbmNsdWRlLXVudHJhY2tlZCBvIC0tYWxsIGFsbG8gc3Rlc3NvIHRlbXBvIgogCi0jOiBidWlsdGluL3N0YXNoLmM6MTI4NQorIzogYnVpbHRpbi9zdGFzaC5jOjEyOTQKIG1zZ2lkICJEaWQgeW91IGZvcmdldCB0byAnZ2l0IGFkZCc/IgogbXNnc3RyICJUaSBzZWkgc2NvcmRhdG8gZGkgZXNlZ3VpcmUgJ2dpdCBhZGQnPyIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjEzMDAgZ2l0LWxlZ2FjeS1zdGFzaC5zaDozNDUKKyM6IGJ1aWx0aW4vc3Rhc2guYzoxMzA5IGdpdC1sZWdhY3ktc3Rhc2guc2g6MzQ1CiBtc2dpZCAiTm8gbG9jYWwgY2hhbmdlcyB0byBzYXZlIgogbXNnc3RyICJOZXNzdW5hIG1vZGlmaWNhIGxvY2FsZSBkYSBzYWx2YXJlIgogCi0jOiBidWlsdGluL3N0YXNoLmM6MTMwNyBnaXQtbGVnYWN5LXN0YXNoLnNoOjM1MAorIzogYnVpbHRpbi9zdGFzaC5jOjEzMTYgZ2l0LWxlZ2FjeS1zdGFzaC5zaDozNTAKIG1zZ2lkICJDYW5ub3QgaW5pdGlhbGl6ZSBzdGFzaCIKIG1zZ3N0ciAiSW1wb3NzaWJpbGUgaW5pemlhbGl6emFyZSBzdGFzaCIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjEzMjIgZ2l0LWxlZ2FjeS1zdGFzaC5zaDozNTQKKyM6IGJ1aWx0aW4vc3Rhc2guYzoxMzMxIGdpdC1sZWdhY3ktc3Rhc2guc2g6MzU0CiBtc2dpZCAiQ2Fubm90IHNhdmUgdGhlIGN1cnJlbnQgc3RhdHVzIgogbXNnc3RyICJJbXBvc3NpYmlsZSBzYWx2YXJlIGxvIHN0YXRvIGF0dHVhbGUiCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzoxMzI3CisjOiBidWlsdGluL3N0YXNoLmM6MTMzNgogIywgYy1mb3JtYXQKIG1zZ2lkICJTYXZlZCB3b3JraW5nIGRpcmVjdG9yeSBhbmQgaW5kZXggc3RhdGUgJXMiCiBtc2dzdHIgIkRpcmVjdG9yeSBkaSBsYXZvcm8gZSBzdGF0byBpbmRpY2Ugc2FsdmF0aTogJXMiCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzoxNDE3IGdpdC1sZWdhY3ktc3Rhc2guc2g6Mzg0CisjOiBidWlsdGluL3N0YXNoLmM6MTQyNiBnaXQtbGVnYWN5LXN0YXNoLnNoOjM4NAogbXNnaWQgIkNhbm5vdCByZW1vdmUgd29ya3RyZWUgY2hhbmdlcyIKIG1zZ3N0ciAiSW1wb3NzaWJpbGUgcmltdW92ZXJlIGxlIG1vZGlmaWNoZSBhbGwnYWxiZXJvIGRpIGxhdm9ybyIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjE0NTIgYnVpbHRpbi9zdGFzaC5jOjE0ODgKKyM6IGJ1aWx0aW4vc3Rhc2guYzoxNDYxIGJ1aWx0aW4vc3Rhc2guYzoxNDk3CiBtc2dpZCAia2VlcCBpbmRleCIKIG1zZ3N0ciAibWFudGllbmkgbCdpbmRpY2UiCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzoxNDU0IGJ1aWx0aW4vc3Rhc2guYzoxNDkwCisjOiBidWlsdGluL3N0YXNoLmM6MTQ2MyBidWlsdGluL3N0YXNoLmM6MTQ5OQogbXNnaWQgInN0YXNoIGluIHBhdGNoIG1vZGUiCiBtc2dzdHIgImVzZWd1aSBsbyBzdGFzaCBpbiBtb2RhbGl0w6AgcGF0Y2giCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzoxNDU1IGJ1aWx0aW4vc3Rhc2guYzoxNDkxCisjOiBidWlsdGluL3N0YXNoLmM6MTQ2NCBidWlsdGluL3N0YXNoLmM6MTUwMAogbXNnaWQgInF1aWV0IG1vZGUiCiBtc2dzdHIgIm1vZGFsaXTDoCBzaWxlbnppb3NhIgogCi0jOiBidWlsdGluL3N0YXNoLmM6MTQ1NyBidWlsdGluL3N0YXNoLmM6MTQ5MworIzogYnVpbHRpbi9zdGFzaC5jOjE0NjYgYnVpbHRpbi9zdGFzaC5jOjE1MDIKIG1zZ2lkICJpbmNsdWRlIHVudHJhY2tlZCBmaWxlcyBpbiBzdGFzaCIKIG1zZ3N0ciAiaW5jbHVkaSBpIGZpbGUgbm9uIHRyYWNjaWF0aSBuZWxsbyBzdGFzaCIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjE0NTkgYnVpbHRpbi9zdGFzaC5jOjE0OTUKKyM6IGJ1aWx0aW4vc3Rhc2guYzoxNDY4IGJ1aWx0aW4vc3Rhc2guYzoxNTA0CiBtc2dpZCAiaW5jbHVkZSBpZ25vcmUgZmlsZXMiCiBtc2dzdHIgImluY2x1ZGkgaSBmaWxlIGlnbm9yYXRpIgogCi0jOiBidWlsdGluL3N0YXNoLmM6MTU1NQorIzogYnVpbHRpbi9zdGFzaC5jOjE1NjQKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGV4ZWMgJXMiCiBtc2dzdHIgImltcG9zc2liaWxlIGVzZWd1aXJlICVzIgpAQCAtMjAyNTAsOSArMjAzNDIsOSBAQAogbXNnc3RyICJub24gc3RhbXBhcmUgbCdpbmRpY2F6aW9uZSBkaSBhdmFuemFtZW50byBkZWxsYSBjbG9uYXppb25lIgogCiAjOiBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6MTg3NwotbXNnaWQgImdpdCBzdWJtb2R1bGUtLWhlbHBlciB1cGRhdGVfY2xvbmUgWy0tcHJlZml4PTxwYXRoPl0gWzxwYXRoPi4uLl0iCittc2dpZCAiZ2l0IHN1Ym1vZHVsZS0taGVscGVyIHVwZGF0ZS1jbG9uZSBbLS1wcmVmaXg9PHBhdGg+XSBbPHBhdGg+Li4uXSIKIG1zZ3N0ciAiIgotImdpdCBzdWJtb2R1bGUtLWhlbHBlciB1cGRhdGVfY2xvbmUgWy0tcHJlZml4PTxwZXJjb3Jzbz5dIFs8cGVyY29yc28+Li4uXSIKKyJnaXQgc3VibW9kdWxlLS1oZWxwZXIgdXBkYXRlLWNsb25lIFstLXByZWZpeD08cGVyY29yc28+XSBbPHBlcmNvcnNvPi4uLl0iCiAKICM6IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxODkwCiBtc2dpZCAiYmFkIHZhbHVlIGZvciB1cGRhdGUgcGFyYW1ldGVyIgpAQCAtMjAzMDUsNyArMjAzOTcsNyBAQAogbXNnaWQgInBsZWFzZSBtYWtlIHN1cmUgdGhhdCB0aGUgLmdpdG1vZHVsZXMgZmlsZSBpcyBpbiB0aGUgd29ya2luZyB0cmVlIgogbXNnc3RyICJhc3NpY3VyYXRpIGNoZSBpbCBmaWxlIC5naXRtb2R1bGVzIHNpYSBuZWxsJ2FsYmVybyBkaSBsYXZvcm8iCiAKLSM6IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoyMjM1IGdpdC5jOjQzNCBnaXQuYzo2ODQKKyM6IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoyMjM1IGdpdC5jOjQzMyBnaXQuYzo2ODMKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgZG9lc24ndCBzdXBwb3J0IC0tc3VwZXItcHJlZml4IgogbXNnc3RyICIlcyBub24gc3VwcG9ydGEgLS1zdXBlci1wcmVmaXgiCkBAIC0yMDY0MCwxNDYgKzIwNzMyLDE0NiBAQAogbXNnaWQgImdpdCB1cGRhdGUtaW5kZXggWzxvcHRpb25zPl0gWy0tXSBbPGZpbGU+Li4uXSIKIG1zZ3N0ciAiZ2l0IHVwZGF0ZS1pbmRleCBbPG9wemlvbmk+XSBbLS1dIFs8ZmlsZT4uLi5dIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjk3MQorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzo5NzIKIG1zZ2lkICJjb250aW51ZSByZWZyZXNoIGV2ZW4gd2hlbiBpbmRleCBuZWVkcyB1cGRhdGUiCiBtc2dzdHIgIiIKICJjb250aW51YSBsJ2FnZ2lvcm5hbWVudG8gYW5jaGUgbmVsIGNhc28gaW4gY3VpIGwnaW5kaWNlIHJpY2hpZWRhIGRpIGVzc2VyZSAiCiAiYWdnaW9ybmF0byIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzo5NzQKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6OTc1CiBtc2dpZCAicmVmcmVzaDogaWdub3JlIHN1Ym1vZHVsZXMiCiBtc2dzdHIgImFnZ2lvcm5hbWVudG86IGlnbm9yYSBpIHNvdHRvbW9kdWxpIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjk3NworIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzo5NzgKIG1zZ2lkICJkbyBub3QgaWdub3JlIG5ldyBmaWxlcyIKIG1zZ3N0ciAibm9uIGlnbm9yYXJlIGkgbnVvdmkgZmlsZSIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzo5NzkKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6OTgwCiBtc2dpZCAibGV0IGZpbGVzIHJlcGxhY2UgZGlyZWN0b3JpZXMgYW5kIHZpY2UtdmVyc2EiCiBtc2dzdHIgImNvbnNlbnRpIGNoZSBkZWkgZmlsZSBzb3N0aXR1aXNjYW5vIGRlbGxlIGRpcmVjdG9yeSBlIHZpY2V2ZXJzYSIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzo5ODEKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6OTgyCiBtc2dpZCAibm90aWNlIGZpbGVzIG1pc3NpbmcgZnJvbSB3b3JrdHJlZSIKIG1zZ3N0ciAibm90YSBzZSBkZWkgZmlsZSBtYW5jYW5vIGRhbGwnYWxiZXJvIGRpIGxhdm9ybyIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzo5ODMKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6OTg0CiBtc2dpZCAicmVmcmVzaCBldmVuIGlmIGluZGV4IGNvbnRhaW5zIHVubWVyZ2VkIGVudHJpZXMiCiBtc2dzdHIgIiIKICJlc2VndWkgbCdhZ2dpb3JuYW1lbnRvIGFuY2hlIHNlIGwnaW5kaWNlIGNvbnRpZW5lIGRlbGxlIHZvY2kgbm9uIHNvdHRvcG9zdGUgIgogImEgbWVyZ2UiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6OTg2CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjk4NwogbXNnaWQgInJlZnJlc2ggc3RhdCBpbmZvcm1hdGlvbiIKIG1zZ3N0ciAiYWdnaW9ybmEgbGUgaW5mb3JtYXppb25pIHN0YXQiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6OTkwCisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjk5MQogbXNnaWQgImxpa2UgLS1yZWZyZXNoLCBidXQgaWdub3JlIGFzc3VtZS11bmNoYW5nZWQgc2V0dGluZyIKIG1zZ3N0ciAiY29tZSAtLXJlZnJlc2gsIG1hIGlnbm9yYSBsJ2ltcG9zdGF6aW9uZSBhc3N1bWUtdW5jaGFuZ2VkIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjk5NAorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzo5OTUKIG1zZ2lkICI8bW9kZT4sPG9iamVjdD4sPHBhdGg+IgogbXNnc3RyICI8bW9kbz4sPG9nZ2V0dG8+LDxwZXJjb3Jzbz4iCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6OTk1CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjk5NgogbXNnaWQgImFkZCB0aGUgc3BlY2lmaWVkIGVudHJ5IHRvIHRoZSBpbmRleCIKIG1zZ3N0ciAiYWdnaXVuZ2UgbGEgdm9jZSBzcGVjaWZpY2F0YSBhbGwnaW5kaWNlIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMDUKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAwNgogbXNnaWQgIm1hcmsgZmlsZXMgYXMgXCJub3QgY2hhbmdpbmdcIiIKIG1zZ3N0ciAiY29udHJhc3NlZ25hIGkgZmlsZSBjb21lIFwibm9uIHNhcmFubm8gbW9kaWZpY2F0aVwiIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMDgKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAwOQogbXNnaWQgImNsZWFyIGFzc3VtZWQtdW5jaGFuZ2VkIGJpdCIKIG1zZ3N0ciAicmVpbXBvc3RhIGEgemVybyBpbCBiaXQgXCJub24gc2FyYW5ubyBtb2RpZmljYXRpXCIiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAxMQorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDEyCiBtc2dpZCAibWFyayBmaWxlcyBhcyBcImluZGV4LW9ubHlcIiIKIG1zZ3N0ciAiY29udHJhc3NlZ25hIGkgZmlsZSBjb21lIFwic29sYW1lbnRlIGRhIGluZGljaXp6YXJlXCIiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAxNAorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDE1CiBtc2dpZCAiY2xlYXIgc2tpcC13b3JrdHJlZSBiaXQiCiBtc2dzdHIgInJlaW1wb3N0YSBhIHplcm8gaWwgYml0IFwic29sYW1lbnRlIGRhIGluZGljaXp6YXJlXCIiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAxNworIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDE4CiBtc2dpZCAiYWRkIHRvIGluZGV4IG9ubHk7IGRvIG5vdCBhZGQgY29udGVudCB0byBvYmplY3QgZGF0YWJhc2UiCiBtc2dzdHIgIiIKICJhZ2dpdW5naSBzb2xvIGFsbCdpbmRpY2U7IG5vbiBhZ2dpdW5nZXJlIGlsIGNvbnRlbnV0byBhbCBkYXRhYmFzZSBvZ2dldHRpIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMTkKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAyMAogbXNnaWQgInJlbW92ZSBuYW1lZCBwYXRocyBldmVuIGlmIHByZXNlbnQgaW4gd29ya3RyZWUiCiBtc2dzdHIgInJpbXVvdmkgaSBwZXJjb3JzaSBzcGVjaWZpY2F0aSBhbmNoZSBzZSBwcmVzZW50aSBuZWxsJ2FsYmVybyBkaSBsYXZvcm8iCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAyMQorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDIyCiBtc2dpZCAid2l0aCAtLXN0ZGluOiBpbnB1dCBsaW5lcyBhcmUgdGVybWluYXRlZCBieSBudWxsIGJ5dGVzIgogbXNnc3RyICJjb24gLS1zdGRpbjogbGUgcmlnaGUgZGkgaW5wdXQgc29ubyB0ZXJtaW5hdGUgZGEgYnl0ZSBOVUxMIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMjMKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAyNAogbXNnaWQgInJlYWQgbGlzdCBvZiBwYXRocyB0byBiZSB1cGRhdGVkIGZyb20gc3RhbmRhcmQgaW5wdXQiCiBtc2dzdHIgImxlZ2dpIGwnZWxlbmNvIGRlaSBwZXJjb3JzaSBkYSBhZ2dpb3JuYXJlIGRhbGxvIHN0YW5kYXJkIGlucHV0IgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMjcKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAyOAogbXNnaWQgImFkZCBlbnRyaWVzIGZyb20gc3RhbmRhcmQgaW5wdXQgdG8gdGhlIGluZGV4IgogbXNnc3RyICJhZ2dpdW5naSBsZSB2b2NpIHNwZWNpZmljYXRlIHN1bGxvIHN0YW5kYXJkIGlucHV0IGFsbCdpbmRpY2UiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAzMQorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDMyCiBtc2dpZCAicmVwb3B1bGF0ZSBzdGFnZXMgIzIgYW5kICMzIGZvciB0aGUgbGlzdGVkIHBhdGhzIgogbXNnc3RyICJyaXBvcG9sYSBsZSBmYXNpIDIgZSAzIHBlciBpIHBlcmNvcnNpIGVsZW5jYXRpIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMzUKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAzNgogbXNnaWQgIm9ubHkgdXBkYXRlIGVudHJpZXMgdGhhdCBkaWZmZXIgZnJvbSBIRUFEIgogbXNnc3RyICJhZ2dpb3JuYSBzb2xvIGxlIHZvY2kgZGlmZmVyZW50aSByaXNwZXR0byBhbGwnSEVBRCIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDM5CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwNDAKIG1zZ2lkICJpZ25vcmUgZmlsZXMgbWlzc2luZyBmcm9tIHdvcmt0cmVlIgogbXNnc3RyICJpZ25vcmEgaSBmaWxlIG1hbmNhbnRpIG5lbGwnYWxiZXJvIGRpIGxhdm9ybyIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDQyCisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwNDMKIG1zZ2lkICJyZXBvcnQgYWN0aW9ucyB0byBzdGFuZGFyZCBvdXRwdXQiCiBtc2dzdHIgInN0YW1wYSBsZSBhemlvbmkgc3VsbG8gc3RhbmRhcmQgb3V0cHV0IgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwNDQKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTA0NQogbXNnaWQgIihmb3IgcG9yY2VsYWlucykgZm9yZ2V0IHNhdmVkIHVucmVzb2x2ZWQgY29uZmxpY3RzIgogbXNnc3RyICIiCiAiKHBlciBpIGNvbWFuZGkgYWQgYWx0byBsaXZlbGxvKSBkaW1lbnRpY2EgaSBjb25mbGl0dGkgbm9uIHJpc29sdGkgc2FsdmF0aSIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDQ4CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwNDkKIG1zZ2lkICJ3cml0ZSBpbmRleCBpbiB0aGlzIGZvcm1hdCIKIG1zZ3N0ciAic2NyaXZpIGwnaW5kaWNlIGluIHF1ZXN0byBmb3JtYXRvIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwNTAKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTA1MQogbXNnaWQgImVuYWJsZSBvciBkaXNhYmxlIHNwbGl0IGluZGV4IgogbXNnc3RyICJhYmlsaXRhIG8gZGlzYWJpbGl0YSBsJ2luZGljZSBzdWRkaXZpc28iCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTA1MgorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDUzCiBtc2dpZCAiZW5hYmxlL2Rpc2FibGUgdW50cmFja2VkIGNhY2hlIgogbXNnc3RyICJhYmlsaXRhL2Rpc2FiaWxpdGEgbGEgY2FjaGUgbm9uIHRyYWNjaWF0YSIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDU0CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwNTUKIG1zZ2lkICJ0ZXN0IGlmIHRoZSBmaWxlc3lzdGVtIHN1cHBvcnRzIHVudHJhY2tlZCBjYWNoZSIKIG1zZ3N0ciAidmVyaWZpY2Egc2UgaWwgZmlsZXN5c3RlbSBzdXBwb3J0YSBsYSBjYWNoZSBub24gdHJhY2NpYXRhIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwNTYKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTA1NwogbXNnaWQgImVuYWJsZSB1bnRyYWNrZWQgY2FjaGUgd2l0aG91dCB0ZXN0aW5nIHRoZSBmaWxlc3lzdGVtIgogbXNnc3RyICJhYmlsaXRhIGxhIGNhY2hlIG5vbiB0cmFjY2lhdGEgc2VuemEgdGVzdGFyZSBpbCBmaWxlc3lzdGVtIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwNTgKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTA1OQogbXNnaWQgIndyaXRlIG91dCB0aGUgaW5kZXggZXZlbiBpZiBpcyBub3QgZmxhZ2dlZCBhcyBjaGFuZ2VkIgogbXNnc3RyICJzY3JpdmkgbCdpbmRpY2UgYW5jaGUgc2Ugbm9uIMOoIHN0YXRvIGNvbnRyYXNzZWduYXRvIGNvbWUgbW9kaWZpY2F0byIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDYwCisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwNjEKIG1zZ2lkICJlbmFibGUgb3IgZGlzYWJsZSBmaWxlIHN5c3RlbSBtb25pdG9yIgogbXNnc3RyICJhYmlsaXRhIG8gZGlzYWJpbGl0YSBpbCBtb25pdG9yIGRlbCBmaWxlc3lzdGVtIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwNjIKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTA2MwogbXNnaWQgIm1hcmsgZmlsZXMgYXMgZnNtb25pdG9yIHZhbGlkIgogbXNnc3RyICJjb250cmFzc2VnbmEgaSBmaWxlIGNvbWUgdmFsaWRpIHJpc3BldHRvIGFsIG1vbml0b3IgZGVsIGZpbGVzeXN0ZW0iCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTA2NQorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDY2CiBtc2dpZCAiY2xlYXIgZnNtb25pdG9yIHZhbGlkIGJpdCIKIG1zZ3N0ciAiIgogInJlaW1wb3N0YSBhIHplcm8gaWwgYml0IFwiZmlsZSB2YWxpZGkgcmlzcGV0dG8gYWwgbW9uaXRvciBkZWwgZmlsZXN5c3RlbVwiIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjExNjgKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTE2OQogbXNnaWQgIiIKICJjb3JlLnNwbGl0SW5kZXggaXMgc2V0IHRvIGZhbHNlOyByZW1vdmUgb3IgY2hhbmdlIGl0LCBpZiB5b3UgcmVhbGx5IHdhbnQgdG8gIgogImVuYWJsZSBzcGxpdCBpbmRleCIKQEAgLTIwNzg3LDcgKzIwODc5LDcgQEAKICJjb3JlLnNwbGl0SW5kZXggw6ggaW1wb3N0YXRvIGEgZmFsc2U7IHJpbXVvdmlsbyBvIG1vZGlmaWNhbG8gc2UgdnVvaSAiCiAidmVyYW1lbnRlIGFiaWxpdGFyZSBsJ2luZGljZSBzdWRkaXZpc28iCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTE3NworIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMTc4CiBtc2dpZCAiIgogImNvcmUuc3BsaXRJbmRleCBpcyBzZXQgdG8gdHJ1ZTsgcmVtb3ZlIG9yIGNoYW5nZSBpdCwgaWYgeW91IHJlYWxseSB3YW50IHRvICIKICJkaXNhYmxlIHNwbGl0IGluZGV4IgpAQCAtMjA3OTUsNyArMjA4ODcsNyBAQAogImNvcmUuc3BsaXRJbmRleCDDqCBpbXBvc3RhdG8gYSB0cnVlOyByaW11b3ZpbG8gbyBtb2RpZmljYWxvIHNlIHZ1b2kgdmVyYW1lbnRlICIKICJkaXNhYmlsaXRhcmUgbCdpbmRpY2Ugc3VkZGl2aXNvIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjExODgKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTE5MAogbXNnaWQgIiIKICJjb3JlLnVudHJhY2tlZENhY2hlIGlzIHNldCB0byB0cnVlOyByZW1vdmUgb3IgY2hhbmdlIGl0LCBpZiB5b3UgcmVhbGx5IHdhbnQgIgogInRvIGRpc2FibGUgdGhlIHVudHJhY2tlZCBjYWNoZSIKQEAgLTIwODAzLDExICsyMDg5NSwxMSBAQAogImNvcmUudW50cmFja2VkQ2FjaGUgw6ggaW1wb3N0YXRvIGEgdHJ1ZTsgcmltdW92aWxvIG8gbW9kaWZpY2FsbyBzZSB2dW9pICIKICJ2ZXJhbWVudGUgZGlzYWJpbGl0YXJlIGxhIGNhY2hlIG5vbiB0cmFjY2lhdGEiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTE5MgorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMTk0CiBtc2dpZCAiVW50cmFja2VkIGNhY2hlIGRpc2FibGVkIgogbXNnc3RyICJDYWNoZSBub24gdHJhY2NpYXRhIGRpc2FiaWxpdGF0YSIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMjAwCisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEyMDIKIG1zZ2lkICIiCiAiY29yZS51bnRyYWNrZWRDYWNoZSBpcyBzZXQgdG8gZmFsc2U7IHJlbW92ZSBvciBjaGFuZ2UgaXQsIGlmIHlvdSByZWFsbHkgd2FudCAiCiAidG8gZW5hYmxlIHRoZSB1bnRyYWNrZWQgY2FjaGUiCkBAIC0yMDgxNSwyOSArMjA5MDcsMjkgQEAKICJjb3JlLnVudHJhY2tlZENhY2hlIMOoIGltcG9zdGF0byBhIGZhbHNlOyByaW11b3ZpbG8gbyBtb2RpZmljYWxvIHNlIHZ1b2kgIgogInZlcmFtZW50ZSBhYmlsaXRhcmUgbGEgY2FjaGUgbm9uIHRyYWNjaWF0YSIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMjA0CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEyMDYKICMsIGMtZm9ybWF0CiBtc2dpZCAiVW50cmFja2VkIGNhY2hlIGVuYWJsZWQgZm9yICclcyciCiBtc2dzdHIgIkNhY2hlIG5vbiB0cmFjY2lhdGEgYWJpbGl0YXRhIHBlciAnJXMnIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEyMTIKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTIxNAogbXNnaWQgImNvcmUuZnNtb25pdG9yIGlzIHVuc2V0OyBzZXQgaXQgaWYgeW91IHJlYWxseSB3YW50IHRvIGVuYWJsZSBmc21vbml0b3IiCiBtc2dzdHIgIiIKICJjb3JlLmZzbW9uaXRvciBub24gw6ggaW1wb3N0YXRvOyBpbXBvc3RhbG8gc2UgdnVvaSB2ZXJhbWVudGUgYWJpbGl0YXJlIGlsICIKICJtb25pdG9yIGRlbCBmaWxlc3lzdGVtIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEyMTYKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTIxOAogbXNnaWQgImZzbW9uaXRvciBlbmFibGVkIgogbXNnc3RyICJtb25pdG9yIGZpbGVzeXN0ZW0gYWJpbGl0YXRvIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEyMTkKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTIyMQogbXNnaWQgIiIKICJjb3JlLmZzbW9uaXRvciBpcyBzZXQ7IHJlbW92ZSBpdCBpZiB5b3UgcmVhbGx5IHdhbnQgdG8gZGlzYWJsZSBmc21vbml0b3IiCiBtc2dzdHIgIiIKICJjb3JlLmZzbW9uaXRvciDDqCBpbXBvc3RhdG87IHJpbXVvdmkgdGFsZSBpbXBvc3RhemlvbmUgc2UgdnVvaSB2ZXJhbWVudGUgIgogImRpc2FiaWxpdGFyZSBpbCBtb25pdG9yIGRlbCBmaWxlc3lzdGVtIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEyMjMKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTIyNQogbXNnaWQgImZzbW9uaXRvciBkaXNhYmxlZCIKIG1zZ3N0ciAibW9uaXRvciBmaWxlc3lzdGVtIGRpc2FiaWxpdGF0byIKIApAQCAtMjA5MzMsNTUgKzIxMDI1LDU1IEBACiBtc2dpZCAicHJpbnQgdGFnIGNvbnRlbnRzIgogbXNnc3RyICJzdGFtcGEgaSBjb250ZW51dGkgZGVsIHRhZyIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjE4CisjOiBidWlsdGluL3dvcmt0cmVlLmM6MTcKIG1zZ2lkICJnaXQgd29ya3RyZWUgYWRkIFs8b3B0aW9ucz5dIDxwYXRoPiBbPGNvbW1pdC1pc2g+XSIKIG1zZ3N0ciAiZ2l0IHdvcmt0cmVlIGFkZCBbPG9wemlvbmk+XSA8cGVyY29yc28+IFs8ZXNwcmVzc2lvbmUgY29tbWl0Pl0iCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzoxOQorIzogYnVpbHRpbi93b3JrdHJlZS5jOjE4CiBtc2dpZCAiZ2l0IHdvcmt0cmVlIGxpc3QgWzxvcHRpb25zPl0iCiBtc2dzdHIgImdpdCB3b3JrdHJlZSBsaXN0IFs8b3B6aW9uaT5dIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6MjAKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzoxOQogbXNnaWQgImdpdCB3b3JrdHJlZSBsb2NrIFs8b3B0aW9ucz5dIDxwYXRoPiIKIG1zZ3N0ciAiZ2l0IHdvcmt0cmVlIGxvY2sgWzxvcHppb25pPl0gPHBlcmNvcnNvPiIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjIxCisjOiBidWlsdGluL3dvcmt0cmVlLmM6MjAKIG1zZ2lkICJnaXQgd29ya3RyZWUgbW92ZSA8d29ya3RyZWU+IDxuZXctcGF0aD4iCiBtc2dzdHIgImdpdCB3b3JrdHJlZSBtb3ZlIDxhbGJlcm8gZGkgbGF2b3JvPiA8bnVvdm8gcGVyY29yc28+IgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6MjIKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzoyMQogbXNnaWQgImdpdCB3b3JrdHJlZSBwcnVuZSBbPG9wdGlvbnM+XSIKIG1zZ3N0ciAiZ2l0IHdvcmt0cmVlIHBydW5lIFs8b3B6aW9uaT5dIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6MjMKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzoyMgogbXNnaWQgImdpdCB3b3JrdHJlZSByZW1vdmUgWzxvcHRpb25zPl0gPHdvcmt0cmVlPiIKIG1zZ3N0ciAiZ2l0IHdvcmt0cmVlIHJlbW92ZSBbPG9wemlvbmk+XSA8YWxiZXJvIGRpIGxhdm9ybz4iCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzoyNAorIzogYnVpbHRpbi93b3JrdHJlZS5jOjIzCiBtc2dpZCAiZ2l0IHdvcmt0cmVlIHVubG9jayA8cGF0aD4iCiBtc2dzdHIgImdpdCB3b3JrdHJlZSB1bmxvY2sgPHBlcmNvcnNvPiIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjYxIGJ1aWx0aW4vd29ya3RyZWUuYzo4OTkKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo2MCBidWlsdGluL3dvcmt0cmVlLmM6ODk4CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBkZWxldGUgJyVzJyIKIG1zZ3N0ciAiZWxpbWluYXppb25lIGRpICclcycgbm9uIHJpdXNjaXRhIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6ODAKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo3OQogIywgYy1mb3JtYXQKIG1zZ2lkICJSZW1vdmluZyB3b3JrdHJlZXMvJXM6IG5vdCBhIHZhbGlkIGRpcmVjdG9yeSIKIG1zZ3N0ciAiUmltdW92byB3b3JrdHJlZXMvJXM6IG5vbiDDqCB1bmEgZGlyZWN0b3J5IHZhbGlkYSIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjg2CisjOiBidWlsdGluL3dvcmt0cmVlLmM6ODUKICMsIGMtZm9ybWF0CiBtc2dpZCAiUmVtb3Zpbmcgd29ya3RyZWVzLyVzOiBnaXRkaXIgZmlsZSBkb2VzIG5vdCBleGlzdCIKIG1zZ3N0ciAiUmltdW92byB3b3JrdHJlZXMvJXM6IGlsIGZpbGUgZ2l0ZGlyIG5vbiBlc2lzdGUiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo5MSBidWlsdGluL3dvcmt0cmVlLmM6MTAwCisjOiBidWlsdGluL3dvcmt0cmVlLmM6OTAgYnVpbHRpbi93b3JrdHJlZS5jOjk5CiAjLCBjLWZvcm1hdAogbXNnaWQgIlJlbW92aW5nIHdvcmt0cmVlcy8lczogdW5hYmxlIHRvIHJlYWQgZ2l0ZGlyIGZpbGUgKCVzKSIKIG1zZ3N0ciAiUmltdW92byB3b3JrdHJlZXMvJXM6IGltcG9zc2liaWxlIGxlZ2dlcmUgaWwgZmlsZSBnaXRkaXIgKCVzKSIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjExMAorIzogYnVpbHRpbi93b3JrdHJlZS5jOjEwOQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiUmVtb3Zpbmcgd29ya3RyZWVzLyVzOiBzaG9ydCByZWFkIChleHBlY3RlZCAlPFBSSXVNQVg+IGJ5dGVzLCByZWFkICIKQEAgLTIwOTkwLDM1ICsyMTA4MiwzNSBAQAogIlJpbXVvdm8gd29ya3RyZWVzLyVzOiBsZXR0aSBtZW5vIGRhdGkgZGVsIHByZXZpc3RvIChhdHRlc2kgJTxQUkl1TUFYPmJ5dGUsICIKICIlPFBSSXVNQVg+IGxldHRpKSIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjExOAorIzogYnVpbHRpbi93b3JrdHJlZS5jOjExNwogIywgYy1mb3JtYXQKIG1zZ2lkICJSZW1vdmluZyB3b3JrdHJlZXMvJXM6IGludmFsaWQgZ2l0ZGlyIGZpbGUiCiBtc2dzdHIgIlJpbXVvdm8gd29ya3RyZWVzLyVzOiBmaWxlIGdpdGRpciBub24gdmFsaWRvIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6MTI3CisjOiBidWlsdGluL3dvcmt0cmVlLmM6MTI2CiAjLCBjLWZvcm1hdAogbXNnaWQgIlJlbW92aW5nIHdvcmt0cmVlcy8lczogZ2l0ZGlyIGZpbGUgcG9pbnRzIHRvIG5vbi1leGlzdGVudCBsb2NhdGlvbiIKIG1zZ3N0ciAiUmltdW92byB3b3JrdHJlZXMvJXM6IGlsIGZpbGUgZ2l0ZGlyIHB1bnRhIGEgdW4gcGVyY29yc28gbm9uIGVzaXN0ZW50ZSIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjE2NgorIzogYnVpbHRpbi93b3JrdHJlZS5jOjE2NQogbXNnaWQgInJlcG9ydCBwcnVuZWQgd29ya2luZyB0cmVlcyIKIG1zZ3N0ciAic2VnbmFsYSBnbGkgYWxiZXJpIGRpIGxhdm9ybyBlbGltaW5hdGkiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzoxNjgKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzoxNjcKIG1zZ2lkICJleHBpcmUgd29ya2luZyB0cmVlcyBvbGRlciB0aGFuIDx0aW1lPiIKIG1zZ3N0ciAiZmFpIHNjYWRlcmUgZ2xpIGFsYmVyaSBkaSBsYXZvcm8gcGnDuSB2ZWNjaGkgZGkgPHRlbXBvPiIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjIzNQorIzogYnVpbHRpbi93b3JrdHJlZS5jOjIzNAogIywgYy1mb3JtYXQKIG1zZ2lkICInJXMnIGFscmVhZHkgZXhpc3RzIgogbXNnc3RyICInJXMnIGVzaXN0ZSBnacOgIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6MjUyCisjOiBidWlsdGluL3dvcmt0cmVlLmM6MjUxCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byByZS1hZGQgd29ya3RyZWUgJyVzJyIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgYWdnaXVuZ2VyZSBudW92YW1lbnRlIGwnYWxiZXJvIGRpIGxhdm9ybyAnJXMnIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6MjU3CisjOiBidWlsdGluL3dvcmt0cmVlLmM6MjU2CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICInJXMnIGlzIGEgbWlzc2luZyBidXQgbG9ja2VkIHdvcmt0cmVlO1xuIgpAQCAtMjEwMjgsNyArMjExMjAsNyBAQAogInVzYSAnYWRkIC1mIC1mJyBwZXIgZXNlZ3VpcmUgbCdvdmVycmlkZSwgbyAndW5sb2NrJyBlICdwcnVuZScgbyAncmVtb3ZlJyBwZXIgIgogInJpbXVvdmVybG8iCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzoyNTkKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzoyNTgKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIiclcycgaXMgYSBtaXNzaW5nIGJ1dCBhbHJlYWR5IHJlZ2lzdGVyZWQgd29ya3RyZWU7XG4iCkBAIC0yMTAzNywxMjkgKzIxMTI5LDEyOSBAQAogIiclcycgw6ggdW4gYWxiZXJvIGRpIGxhdm9ybyBtYW5jYW50ZSBtYSBnacOgIHJlZ2lzdHJhdG87XG4iCiAidXNhICdhZGQgLWYnIHBlciBlc2VndWlyZSBsJ292ZXJyaWRlLCBvICdwcnVuZScgbyAncmVtb3ZlJyBwZXIgcmltdW92ZXJsbyIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjMwOQorIzogYnVpbHRpbi93b3JrdHJlZS5jOjMwOAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgY3JlYXRlIGRpcmVjdG9yeSBvZiAnJXMnIgogbXNnc3RyICJpbXBvc3NpYmlsZSBjcmVhcmUgbGEgZGlyZWN0b3J5IGRpICclcyciCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo0NDAgYnVpbHRpbi93b3JrdHJlZS5jOjQ0NgorIzogYnVpbHRpbi93b3JrdHJlZS5jOjQzOSBidWlsdGluL3dvcmt0cmVlLmM6NDQ1CiAjLCBjLWZvcm1hdAogbXNnaWQgIlByZXBhcmluZyB3b3JrdHJlZSAobmV3IGJyYW5jaCAnJXMnKSIKIG1zZ3N0ciAiUHJlcGFyYXppb25lIGRlbGwnYWxiZXJvIGRpIGxhdm9ybyBpbiBjb3JzbyAobnVvdm8gYnJhbmNoICclcycpIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NDQyCisjOiBidWlsdGluL3dvcmt0cmVlLmM6NDQxCiAjLCBjLWZvcm1hdAogbXNnaWQgIlByZXBhcmluZyB3b3JrdHJlZSAocmVzZXR0aW5nIGJyYW5jaCAnJXMnOyB3YXMgYXQgJXMpIgogbXNnc3RyICIiCiAiUHJlcGFyYXppb25lIGRlbGwnYWxiZXJvIGRpIGxhdm9ybyBpbiBjb3JzbyAocmVpbXBvc3RvIGlsIGJyYW5jaCAnJXMnOyBlcmEgYSAiCiAiJXMpIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NDUxCisjOiBidWlsdGluL3dvcmt0cmVlLmM6NDUwCiAjLCBjLWZvcm1hdAogbXNnaWQgIlByZXBhcmluZyB3b3JrdHJlZSAoY2hlY2tpbmcgb3V0ICclcycpIgogbXNnc3RyICJQcmVwYXJhemlvbmUgZGVsbCdhbGJlcm8gZGkgbGF2b3JvIGluIGNvcnNvIChjaGVja291dCBkaSAnJXMnKSIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjQ1NworIzogYnVpbHRpbi93b3JrdHJlZS5jOjQ1NgogIywgYy1mb3JtYXQKIG1zZ2lkICJQcmVwYXJpbmcgd29ya3RyZWUgKGRldGFjaGVkIEhFQUQgJXMpIgogbXNnc3RyICJQcmVwYXJhemlvbmUgZGVsbCdhbGJlcm8gZGkgbGF2b3JvIGluIGNvcnNvIChIRUFEIHNjb2xsZWdhdG8gJXMpIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NDk4CisjOiBidWlsdGluL3dvcmt0cmVlLmM6NDk3CiBtc2dpZCAiY2hlY2tvdXQgPGJyYW5jaD4gZXZlbiBpZiBhbHJlYWR5IGNoZWNrZWQgb3V0IGluIG90aGVyIHdvcmt0cmVlIgogbXNnc3RyICIiCiAiZXNlZ3VpIGlsIGNoZWNrb3V0IGRpIDxicmFuY2g+IGFuY2hlIHNlIHRhbGUgb3BlcmF6aW9uZSDDqCBzdGF0YSBlc2VndWl0YSBpbiAiCiAidW4gYWx0cm8gYWxiZXJvIGRpIGxhdm9ybyIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjUwMQorIzogYnVpbHRpbi93b3JrdHJlZS5jOjUwMAogbXNnaWQgImNyZWF0ZSBhIG5ldyBicmFuY2giCiBtc2dzdHIgImNyZWEgdW4gbnVvdm8gYnJhbmNoIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NTAzCisjOiBidWlsdGluL3dvcmt0cmVlLmM6NTAyCiBtc2dpZCAiY3JlYXRlIG9yIHJlc2V0IGEgYnJhbmNoIgogbXNnc3RyICJjcmVhIG8gcmVpbXBvc3RhIHVuIGJyYW5jaCIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjUwNQorIzogYnVpbHRpbi93b3JrdHJlZS5jOjUwNAogbXNnaWQgInBvcHVsYXRlIHRoZSBuZXcgd29ya2luZyB0cmVlIgogbXNnc3RyICJwb3BvbGEgaWwgbnVvdm8gYWxiZXJvIGRpIGxhdm9ybyIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjUwNgorIzogYnVpbHRpbi93b3JrdHJlZS5jOjUwNQogbXNnaWQgImtlZXAgdGhlIG5ldyB3b3JraW5nIHRyZWUgbG9ja2VkIgogbXNnc3RyICJtYW50aWVuaSBibG9jY2F0byBpbCBudW92byBhbGJlcm8gZGkgbGF2b3JvIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NTA5CisjOiBidWlsdGluL3dvcmt0cmVlLmM6NTA4CiBtc2dpZCAic2V0IHVwIHRyYWNraW5nIG1vZGUgKHNlZSBnaXQtYnJhbmNoKDEpKSIKIG1zZ3N0ciAiaW1wb3N0YSBsYSBtb2RhbGl0w6AgdHJhY2tpbmcgKHZlZGkgZ2l0LWJyYW5jaCgxKSkiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo1MTIKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo1MTEKIG1zZ2lkICJ0cnkgdG8gbWF0Y2ggdGhlIG5ldyBicmFuY2ggbmFtZSB3aXRoIGEgcmVtb3RlLXRyYWNraW5nIGJyYW5jaCIKIG1zZ3N0ciAiIgogInRlbnRhIGRpIGNlcmNhcmUgdW5hIGNvcnJpc3BvbmRlbnphIGZyYSBpbCBub21lIGRlbCBudW92byBicmFuY2ggZSB1biBicmFuY2ggIgogInJlbW90byBkYSB0cmFjY2lhcmUiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo1MjAKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo1MTkKIG1zZ2lkICItYiwgLUIsIGFuZCAtLWRldGFjaCBhcmUgbXV0dWFsbHkgZXhjbHVzaXZlIgogbXNnc3RyICJsZSBvcHppb25pIC1iLCAtQiBlIC0tZGV0YWNoIHNvbm8gbXV0dWFsbWVudGUgZXNjbHVzaXZlIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NTgxCisjOiBidWlsdGluL3dvcmt0cmVlLmM6NTgwCiBtc2dpZCAiLS1bbm8tXXRyYWNrIGNhbiBvbmx5IGJlIHVzZWQgaWYgYSBuZXcgYnJhbmNoIGlzIGNyZWF0ZWQiCiBtc2dzdHIgIiIKICJsJ29wemlvbmUgLS1bbm8tXXRyYWNrIHB1w7IgZXNzZXJlIHVzYXRhIHNvbG8gc2UgdmllbmUgY3JlYXRvIHVuIG51b3ZvIGJyYW5jaCIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjY4MQorIzogYnVpbHRpbi93b3JrdHJlZS5jOjY4MAogbXNnaWQgInJlYXNvbiBmb3IgbG9ja2luZyIKIG1zZ3N0ciAibW90aXZvIGRpIGJsb2NjbyIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjY5MyBidWlsdGluL3dvcmt0cmVlLmM6NzI2IGJ1aWx0aW4vd29ya3RyZWUuYzo4MDAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo5MjcKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo2OTIgYnVpbHRpbi93b3JrdHJlZS5jOjcyNSBidWlsdGluL3dvcmt0cmVlLmM6Nzk5CisjOiBidWlsdGluL3dvcmt0cmVlLmM6OTI2CiAjLCBjLWZvcm1hdAogbXNnaWQgIiclcycgaXMgbm90IGEgd29ya2luZyB0cmVlIgogbXNnc3RyICInJXMnIG5vbiDDqCB1biBhbGJlcm8gZGkgbGF2b3JvIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6Njk1IGJ1aWx0aW4vd29ya3RyZWUuYzo3MjgKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo2OTQgYnVpbHRpbi93b3JrdHJlZS5jOjcyNwogbXNnaWQgIlRoZSBtYWluIHdvcmtpbmcgdHJlZSBjYW5ub3QgYmUgbG9ja2VkIG9yIHVubG9ja2VkIgogbXNnc3RyICJOb24gw6ggcG9zc2liaWxlIGJsb2NjYXJlIG8gc2Jsb2NjYXJlIGwnYWxiZXJvIGRpIGxhdm9ybyBwcmluY2lwYWxlIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NzAwCisjOiBidWlsdGluL3dvcmt0cmVlLmM6Njk5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiclcycgaXMgYWxyZWFkeSBsb2NrZWQsIHJlYXNvbjogJXMiCiBtc2dzdHIgIiclcycgw6ggZ2nDoCBibG9jY2F0byBwZXIgcXVlc3RvIG1vdGl2bzogJXMiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo3MDIKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo3MDEKICMsIGMtZm9ybWF0CiBtc2dpZCAiJyVzJyBpcyBhbHJlYWR5IGxvY2tlZCIKIG1zZ3N0ciAiJyVzJyDDqCBnacOgIGJsb2NjYXRvIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NzMwCisjOiBidWlsdGluL3dvcmt0cmVlLmM6NzI5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiclcycgaXMgbm90IGxvY2tlZCIKIG1zZ3N0ciAiJyVzJyBub24gw6ggYmxvY2NhdG8iCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo3NzEKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo3NzAKIG1zZ2lkICJ3b3JraW5nIHRyZWVzIGNvbnRhaW5pbmcgc3VibW9kdWxlcyBjYW5ub3QgYmUgbW92ZWQgb3IgcmVtb3ZlZCIKIG1zZ3N0ciAiIgogImdsaSBhbGJlcmkgZGkgbGF2b3JvIGNvbnRlbmVudGkgc290dG9tb2R1bGkgbm9uIHBvc3Nvbm8gZXNzZXJlIHNwb3N0YXRpIG8gIgogInJpbW9zc2kiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo3NzkKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo3NzgKIG1zZ2lkICJmb3JjZSBtb3ZlIGV2ZW4gaWYgd29ya3RyZWUgaXMgZGlydHkgb3IgbG9ja2VkIgogbXNnc3RyICJmb3J6YSBsbyBzcG9zdGFtZW50byBhbmNoZSBzZSBsJ2FsYmVybyBkaSBsYXZvcm8gw6ggc3BvcmNvIG8gYmxvY2NhdG8iCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4MDIgYnVpbHRpbi93b3JrdHJlZS5jOjkyOQorIzogYnVpbHRpbi93b3JrdHJlZS5jOjgwMSBidWlsdGluL3dvcmt0cmVlLmM6OTI4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiclcycgaXMgYSBtYWluIHdvcmtpbmcgdHJlZSIKIG1zZ3N0ciAiJyVzJyDDqCB1biBhbGJlcm8gZGkgbGF2b3JvIHByaW5jaXBhbGUiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4MDcKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4MDYKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGZpZ3VyZSBvdXQgZGVzdGluYXRpb24gbmFtZSBmcm9tICclcyciCiBtc2dzdHIgImltcG9zc2liaWxlIGRldGVybWluYXJlIGlsIG5vbWUgZGVzdGluYXppb25lIGRhICclcyciCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4MTMKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4MTIKICMsIGMtZm9ybWF0CiBtc2dpZCAidGFyZ2V0ICclcycgYWxyZWFkeSBleGlzdHMiCiBtc2dzdHIgImxhIGRlc3RpbmF6aW9uZSAnJXMnIGVzaXN0ZSBnacOgIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6ODIxCisjOiBidWlsdGluL3dvcmt0cmVlLmM6ODIwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJjYW5ub3QgbW92ZSBhIGxvY2tlZCB3b3JraW5nIHRyZWUsIGxvY2sgcmVhc29uOiAlc1xuIgpAQCAtMjExNjksNyArMjEyNjEsNyBAQAogInVzYSAnbW92ZSAtZiAtZicgcGVyIGVzZWd1aXJuZSBsJ292ZXJyaWRlIG8gc2Jsb2NjYWxvIHByaW1hIGRpIGVzZWd1aXJlICIKICJsJ29wZXJhemlvbmUiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4MjMKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4MjIKIG1zZ2lkICIiCiAiY2Fubm90IG1vdmUgYSBsb2NrZWQgd29ya2luZyB0cmVlO1xuIgogInVzZSAnbW92ZSAtZiAtZicgdG8gb3ZlcnJpZGUgb3IgdW5sb2NrIGZpcnN0IgpAQCAtMjExNzgsMzYgKzIxMjcwLDM3IEBACiAidXNhICdtb3ZlIC1mIC1mJyBwZXIgZXNlZ3Vpcm5lIGwnb3ZlcnJpZGUgbyBzYmxvY2NhbG8gcHJpbWEgZGkgZXNlZ3VpcmUgIgogImwnb3BlcmF6aW9uZSIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjgyNgorIzogYnVpbHRpbi93b3JrdHJlZS5jOjgyNQogIywgYy1mb3JtYXQKIG1zZ2lkICJ2YWxpZGF0aW9uIGZhaWxlZCwgY2Fubm90IG1vdmUgd29ya2luZyB0cmVlOiAlcyIKIG1zZ3N0ciAidmFsaWRhemlvbmUgbm9uIHJpdXNjaXRhLCBpbXBvc3NpYmlsZSBzcG9zdGFyZSBsJ2FsYmVybyBkaSBsYXZvcm86ICVzIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6ODMxCisjOiBidWlsdGluL3dvcmt0cmVlLmM6ODMwCiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBtb3ZlICclcycgdG8gJyVzJyIKIG1zZ3N0ciAic3Bvc3RhbWVudG8gZGkgJyVzJyBpbiAnJXMnIG5vbiByaXVzY2l0byIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjg3OQorIzogYnVpbHRpbi93b3JrdHJlZS5jOjg3OAogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gcnVuICdnaXQgc3RhdHVzJyBvbiAnJXMnIgogbXNnc3RyICJlc2VjdXppb25lIGRpICdnaXQgc3RhdHVzJyBzdSAnJXMnIG5vbiByaXVzY2l0YSIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjg4MworIzogYnVpbHRpbi93b3JrdHJlZS5jOjg4MgogIywgYy1mb3JtYXQKLW1zZ2lkICInJXMnIGlzIGRpcnR5LCB1c2UgLS1mb3JjZSB0byBkZWxldGUgaXQiCi1tc2dzdHIgIiclcycgw6ggc3BvcmNvLCB1c2EgLS1mb3JjZSBwZXIgZWxpbWluYXJsbyIKK21zZ2lkICInJXMnIGNvbnRhaW5zIG1vZGlmaWVkIG9yIHVudHJhY2tlZCBmaWxlcywgdXNlIC0tZm9yY2UgdG8gZGVsZXRlIGl0IgorbXNnc3RyICIiCisiJyVzJyBjb250aWVuZSBmaWxlIG1vZGlmaWNhdGkgbyBub24gdHJhY2NpYXRpLCB1c2EgLS1mb3JjZSBwZXIgZWxpbWluYXJsbyIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjg4OAorIzogYnVpbHRpbi93b3JrdHJlZS5jOjg4NwogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gcnVuICdnaXQgc3RhdHVzJyBvbiAnJXMnLCBjb2RlICVkIgogbXNnc3RyICJlc2VjdXppb25lIGRpICdnaXQgc3RhdHVzJyBzdSAnJXMnIG5vbiByaXVzY2l0YSwgY29kaWNlICVkIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6OTExCisjOiBidWlsdGluL3dvcmt0cmVlLmM6OTEwCiBtc2dpZCAiZm9yY2UgcmVtb3ZhbCBldmVuIGlmIHdvcmt0cmVlIGlzIGRpcnR5IG9yIGxvY2tlZCIKIG1zZ3N0ciAiZm9yemEgbGEgcmltb3ppb25lIGFuY2hlIHNlIGwnYWxiZXJvIGRpIGxhdm9ybyDDqCBzcG9yY28gbyBibG9jY2F0byIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjkzNAorIzogYnVpbHRpbi93b3JrdHJlZS5jOjkzMwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiY2Fubm90IHJlbW92ZSBhIGxvY2tlZCB3b3JraW5nIHRyZWUsIGxvY2sgcmVhc29uOiAlc1xuIgpAQCAtMjEyMTcsNyArMjEzMTAsNyBAQAogInVzYSAncmVtb3ZlIC1mIC1mJyBwZXIgZXNlZ3Vpcm5lIGwnb3ZlcnJpZGUgbyBzYmxvY2NhbG8gcHJpbWEgZGkgZXNlZ3VpcmUgIgogImwnb3BlcmF6aW9uZSIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjkzNgorIzogYnVpbHRpbi93b3JrdHJlZS5jOjkzNQogbXNnaWQgIiIKICJjYW5ub3QgcmVtb3ZlIGEgbG9ja2VkIHdvcmtpbmcgdHJlZTtcbiIKICJ1c2UgJ3JlbW92ZSAtZiAtZicgdG8gb3ZlcnJpZGUgb3IgdW5sb2NrIGZpcnN0IgpAQCAtMjEyMjYsNyArMjEzMTksNyBAQAogInVzYSAncmVtb3ZlIC1mIC1mJyBwZXIgZXNlZ3Vpcm5lIGwnb3ZlcnJpZGUgbyBzYmxvY2NhbG8gcHJpbWEgZGkgZXNlZ3VpcmUgIgogImwnb3BlcmF6aW9uZSIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjkzOQorIzogYnVpbHRpbi93b3JrdHJlZS5jOjkzOAogIywgYy1mb3JtYXQKIG1zZ2lkICJ2YWxpZGF0aW9uIGZhaWxlZCwgY2Fubm90IHJlbW92ZSB3b3JraW5nIHRyZWU6ICVzIgogbXNnc3RyICJ2YWxpZGF6aW9uZSBub24gcml1c2NpdGEsIGltcG9zc2liaWxlIHJpbXVvdmVyZSBsJ2FsYmVybyBkaSBsYXZvcm86ICVzIgpAQCAtMjEyNDcsNiArMjEzNDAsMTYgQEAKIG1zZ2lkICJvbmx5IHVzZWZ1bCBmb3IgZGVidWdnaW5nIgogbXNnc3RyICJ1dGlsZSBzb2xvIHBlciBpbCBkZWJ1ZyIKIAorIzogZmFzdC1pbXBvcnQuYzozMTE4CisjLCBjLWZvcm1hdAorbXNnaWQgIkV4cGVjdGVkICdtYXJrJyBjb21tYW5kLCBnb3QgJXMiCittc2dzdHIgIkF0dGVzbyBjb21hbmRvICdtYXJrJywgcmljZXZ1dG8gJXMiCisKKyM6IGZhc3QtaW1wb3J0LmM6MzEyMworIywgYy1mb3JtYXQKK21zZ2lkICJFeHBlY3RlZCAndG8nIGNvbW1hbmQsIGdvdCAlcyIKK21zZ3N0ciAiQXR0ZXNvIGNvbWFuZG8gJ3RvJywgcmljZXZ1dG8gJXMiCisKICM6IGNyZWRlbnRpYWwtY2FjaGUtLWRhZW1vbi5jOjIyMwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCkBAIC0yMTM2MiwzOSArMjE0NjUsMzkgQEAKICJsJ2FsaWFzICclcycgbW9kaWZpY2EgbGUgdmFyaWFiaWxpIGQnYW1iaWVudGUuXG4iCiAiUHVvaSB1c2FyZSAnIWdpdCcgbmVsbCdhbGlhcyBwZXIgZmFybG8iCiAKLSM6IGdpdC5jOjM3NworIzogZ2l0LmM6Mzc2CiAjLCBjLWZvcm1hdAogbXNnaWQgImVtcHR5IGFsaWFzIGZvciAlcyIKIG1zZ3N0ciAiYWxpYXMgdnVvdG8gcGVyICVzIgogCi0jOiBnaXQuYzozODAKKyM6IGdpdC5jOjM3OQogIywgYy1mb3JtYXQKIG1zZ2lkICJyZWN1cnNpdmUgYWxpYXM6ICVzIgogbXNnc3RyICJhbGlhcyByaWNvcnNpdm86ICVzIgogCi0jOiBnaXQuYzo0NjAKKyM6IGdpdC5jOjQ1OQogbXNnaWQgIndyaXRlIGZhaWx1cmUgb24gc3RhbmRhcmQgb3V0cHV0IgogbXNnc3RyICJlcnJvcmUgZGkgc2NyaXR0dXJhIHN1bGxvIHN0YW5kYXJkIG91dHB1dCIKIAotIzogZ2l0LmM6NDYyCisjOiBnaXQuYzo0NjEKIG1zZ2lkICJ1bmtub3duIHdyaXRlIGZhaWx1cmUgb24gc3RhbmRhcmQgb3V0cHV0IgogbXNnc3RyICJlcnJvcmUgZGkgc2NyaXR0dXJhIHNjb25vc2NpdXRvIHN1bGxvIHN0YW5kYXJkIG91dHB1dCIKIAotIzogZ2l0LmM6NDY0CisjOiBnaXQuYzo0NjMKIG1zZ2lkICJjbG9zZSBmYWlsZWQgb24gc3RhbmRhcmQgb3V0cHV0IgogbXNnc3RyICJjaGl1c3VyYSBkZWxsbyBzdGFuZGFyZCBvdXRwdXQgbm9uIHJpdXNjaXRhIgogCi0jOiBnaXQuYzo3OTMKKyM6IGdpdC5jOjc5MgogIywgYy1mb3JtYXQKIG1zZ2lkICJhbGlhcyBsb29wIGRldGVjdGVkOiBleHBhbnNpb24gb2YgJyVzJyBkb2VzIG5vdCB0ZXJtaW5hdGU6JXMiCiBtc2dzdHIgInJpbGV2YXRvIGNpY2xvIGFsaWFzOiBsJ2VzcGFuc2lvbmUgZGkgJyVzJyBub24gdGVybWluYTolcyIKIAotIzogZ2l0LmM6ODQzCisjOiBnaXQuYzo4NDIKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IGhhbmRsZSAlcyBhcyBhIGJ1aWx0aW4iCiBtc2dzdHIgImltcG9zc2liaWxlIGdlc3RpcmUgJXMgY29tZSBjb21hbmRvIGluY29ycG9yYXRvIgogCi0jOiBnaXQuYzo4NTYKKyM6IGdpdC5jOjg1NQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAidXNhZ2U6ICVzXG4iCkBAIC0yMTQwMywxMiArMjE1MDYsMTIgQEAKICJ1c286ICVzXG4iCiAiXG4iCiAKLSM6IGdpdC5jOjg3NgorIzogZ2l0LmM6ODc1CiAjLCBjLWZvcm1hdAogbXNnaWQgImV4cGFuc2lvbiBvZiBhbGlhcyAnJXMnIGZhaWxlZDsgJyVzJyBpcyBub3QgYSBnaXQgY29tbWFuZFxuIgogbXNnc3RyICJlc3BhbnNpb25lIGRlbGwnYWxpYXMgJyVzJyBub24gcml1c2NpdGE7ICclcycgbm9uIMOoIHVuIGNvbWFuZG8gR2l0XG4iCiAKLSM6IGdpdC5jOjg4OAorIzogZ2l0LmM6ODg3CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBydW4gY29tbWFuZCAnJXMnOiAlc1xuIgogbXNnc3RyICJlc2VjdXppb25lIGRlbCBjb21hbmRvICclcycgbm9uIHJpdXNjaXRhOiAlc1xuIgpAQCAtMjE0MjYsMzIgKzIxNTI5LDMyIEBACiBtc2dpZCAiUHVibGljIGtleSBwaW5uaW5nIG5vdCBzdXBwb3J0ZWQgd2l0aCBjVVJMIDwgNy40NC4wIgogbXNnc3RyICJJbCBwaW5uaW5nIGRlbGxlIGNoaWF2aSBwdWJibGljaGUgbm9uIMOoIHN1cHBvcnRhdG8gY29uIGNVUkwgPCA3LjQ0LjAiCiAKLSM6IGh0dHAuYzo4NzYKKyM6IGh0dHAuYzo4NzgKIG1zZ2lkICJDVVJMU1NMT1BUX05PX1JFVk9LRSBub3Qgc3VwcG9ydGVkIHdpdGggY1VSTCA8IDcuNDQuMCIKIG1zZ3N0ciAiQ1VSTFNTTE9QVF9OT19SRVZPS0Ugbm9uIMOoIHN1cHBvcnRhdG8gY29uIGNVUkwgPCA3LjQ0LjAiCiAKLSM6IGh0dHAuYzo5NDkKKyM6IGh0dHAuYzo5NTEKIG1zZ2lkICJQcm90b2NvbCByZXN0cmljdGlvbnMgbm90IHN1cHBvcnRlZCB3aXRoIGNVUkwgPCA3LjE5LjQiCiBtc2dzdHIgIkxlIHJlc3RyaXppb25pIHByb3RvY29sbG8gbm9uIHNvbm8gc3VwcG9ydGF0ZSBjb24gY1VSTCA8IDcuMTkuNCIKIAotIzogaHR0cC5jOjEwODUKKyM6IGh0dHAuYzoxMDg4CiAjLCBjLWZvcm1hdAogbXNnaWQgIlVuc3VwcG9ydGVkIFNTTCBiYWNrZW5kICclcycuIFN1cHBvcnRlZCBTU0wgYmFja2VuZHM6IgogbXNnc3RyICJCYWNrZW5kIFNTTCAnJXMnIG5vbiBzdXBwb3J0YXRvLiBCYWNrZW5kIFNTTCBzdXBwb3J0YXRpOiIKIAotIzogaHR0cC5jOjEwOTIKKyM6IGh0dHAuYzoxMDk1CiAjLCBjLWZvcm1hdAogbXNnaWQgIkNvdWxkIG5vdCBzZXQgU1NMIGJhY2tlbmQgdG8gJyVzJzogY1VSTCB3YXMgYnVpbHQgd2l0aG91dCBTU0wgYmFja2VuZHMiCiBtc2dzdHIgIiIKICJJbXBvc3NpYmlsZSBpbXBvc3RhcmUgaWwgYmFja2VuZCBTU0wgYSAnJXMnOiBjVVJMIMOoIHN0YXRvIGNvbXBpbGF0byBzZW56YSAiCiAiYmFja2VuZCBTU0wiCiAKLSM6IGh0dHAuYzoxMDk2CisjOiBodHRwLmM6MTA5OQogIywgYy1mb3JtYXQKIG1zZ2lkICJDb3VsZCBub3Qgc2V0IFNTTCBiYWNrZW5kIHRvICclcyc6IGFscmVhZHkgc2V0IgogbXNnc3RyICJJbXBvc3NpYmlsZSBpbXBvc3RhcmUgaWwgYmFja2VuZCBTU0wgYSAnJXMnOiBnacOgIGltcG9zdGF0byIKIAotIzogaHR0cC5jOjE5NjUKKyM6IGh0dHAuYzoxOTY4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJ1bmFibGUgdG8gdXBkYXRlIHVybCBiYXNlIGZyb20gcmVkaXJlY3Rpb246XG4iCkBAIC0yMTQ2MiwxMzYgKzIxNTY1LDEzNiBAQAogIiAgcmljaGllc3RhOiAlc1xuIgogIiAgIHJlZGlyZWN0OiAlcyIKIAotIzogcmVtb3RlLWN1cmwuYzoxNTcKKyM6IHJlbW90ZS1jdXJsLmM6MTY2CiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgcXVvdGluZyBpbiBwdXNoLW9wdGlvbiB2YWx1ZTogJyVzJyIKIG1zZ3N0ciAidmlyZ29sZXR0ZSBub24gdmFsaWRlIG5lbCB2YWxvcmUgcHVzaC1vcHRpb246ICclcyciCiAKLSM6IHJlbW90ZS1jdXJsLmM6MjU0CisjOiByZW1vdGUtY3VybC5jOjI2MwogIywgYy1mb3JtYXQKIG1zZ2lkICIlc2luZm8vcmVmcyBub3QgdmFsaWQ6IGlzIHRoaXMgYSBnaXQgcmVwb3NpdG9yeT8iCiBtc2dzdHIgIiVzaW5mby9yZWZzIG5vbiB2YWxpZG86IMOoIHVuIHJlcG9zaXRvcnkgR2l0PyIKIAotIzogcmVtb3RlLWN1cmwuYzozNTUKKyM6IHJlbW90ZS1jdXJsLmM6MzY0CiBtc2dpZCAiaW52YWxpZCBzZXJ2ZXIgcmVzcG9uc2U7IGV4cGVjdGVkIHNlcnZpY2UsIGdvdCBmbHVzaCBwYWNrZXQiCiBtc2dzdHIgIiIKICJyaXNwb3N0YSBkZWwgc2VydmVyIG5vbiB2YWxpZGE7IGF0dGVzbyBzZXJ2aXppbywgcmljZXZ1dG8gcGFjY2hldHRvIGZsdXNoIgogCi0jOiByZW1vdGUtY3VybC5jOjM4NgorIzogcmVtb3RlLWN1cmwuYzozOTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBzZXJ2ZXIgcmVzcG9uc2U7IGdvdCAnJXMnIgogbXNnc3RyICJyaXNwb3N0YSBkZWwgc2VydmVyIG5vbiB2YWxpZGE7IHJpY2V2dXRvICclcyciCiAKLSM6IHJlbW90ZS1jdXJsLmM6NDQ2CisjOiByZW1vdGUtY3VybC5jOjQ1NQogIywgYy1mb3JtYXQKIG1zZ2lkICJyZXBvc2l0b3J5ICclcycgbm90IGZvdW5kIgogbXNnc3RyICJyZXBvc2l0b3J5ICclcycgbm9uIHRyb3ZhdG8iCiAKLSM6IHJlbW90ZS1jdXJsLmM6NDUwCisjOiByZW1vdGUtY3VybC5jOjQ1OQogIywgYy1mb3JtYXQKIG1zZ2lkICJBdXRoZW50aWNhdGlvbiBmYWlsZWQgZm9yICclcyciCiBtc2dzdHIgIkF1dGVudGljYXppb25lIG5vbiByaXVzY2l0YSBwZXIgJyVzJyIKIAotIzogcmVtb3RlLWN1cmwuYzo0NTQKKyM6IHJlbW90ZS1jdXJsLmM6NDYzCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBhY2Nlc3MgJyVzJzogJXMiCiBtc2dzdHIgImltcG9zc2liaWxlIGFjY2VkZXJlIGEgJyVzJzogJXMiCiAKLSM6IHJlbW90ZS1jdXJsLmM6NDYwCisjOiByZW1vdGUtY3VybC5jOjQ2OQogIywgYy1mb3JtYXQKIG1zZ2lkICJyZWRpcmVjdGluZyB0byAlcyIKIG1zZ3N0ciAicmVkaXJlemlvbmUgYSAlcyBpbiBjb3JzbyIKIAotIzogcmVtb3RlLWN1cmwuYzo1ODQKKyM6IHJlbW90ZS1jdXJsLmM6NTkzCiBtc2dpZCAic2hvdWxkbid0IGhhdmUgRU9GIHdoZW4gbm90IGdlbnRsZSBvbiBFT0YiCiBtc2dzdHIgIiIKICJub24gZG92cmViYmUgZXNzZXJjaSB1biBwYWNjaGV0dG8gZmluZSBmaWxlIHNlIG5vbiBzaSDDqCBhY2NvbW9kYW50aSBjb24gIgogInF1ZXN0aSB1bHRpbWkiCiAKLSM6IHJlbW90ZS1jdXJsLmM6NjY0CisjOiByZW1vdGUtY3VybC5jOjY3MwogbXNnaWQgInVuYWJsZSB0byByZXdpbmQgcnBjIHBvc3QgZGF0YSAtIHRyeSBpbmNyZWFzaW5nIGh0dHAucG9zdEJ1ZmZlciIKIG1zZ3N0ciAiIgogImltcG9zc2liaWxlIHJpdG9ybmFyZSBhIHVuIHB1bnRvIHByZWNlZGVudGUgZGVpIGRhdGkgUE9TVCBSUEMgLSBwcm92YSBhZCAiCiAiYXVtZW50YXJlIGlsIHZhbG9yZSBkaSBodHRwLnBvc3RCdWZmZXIiCiAKLSM6IHJlbW90ZS1jdXJsLmM6NzI0CisjOiByZW1vdGUtY3VybC5jOjczMwogIywgYy1mb3JtYXQKIG1zZ2lkICJSUEMgZmFpbGVkOyAlcyIKIG1zZ3N0ciAiUlBDIG5vbiByaXVzY2l0YTsgJXMiCiAKLSM6IHJlbW90ZS1jdXJsLmM6NzY0CisjOiByZW1vdGUtY3VybC5jOjc3MwogbXNnaWQgImNhbm5vdCBoYW5kbGUgcHVzaGVzIHRoaXMgYmlnIgogbXNnc3RyICJpbXBvc3NpYmlsZSBnZXN0aXJlIHB1c2ggY29zw6wgZ3JhbmRpIgogCi0jOiByZW1vdGUtY3VybC5jOjg3OQorIzogcmVtb3RlLWN1cmwuYzo4ODgKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IGRlZmxhdGUgcmVxdWVzdDsgemxpYiBkZWZsYXRlIGVycm9yICVkIgogbXNnc3RyICIiCiAiaW1wb3NzaWJpbGUgZXNlZ3VpcmUgaWwgZGVmbGF0ZSBkZWxsYSByaWNoaWVzdGE7IGVycm9yZSBkZWZsYXRlIHpsaWIgJWQiCiAKLSM6IHJlbW90ZS1jdXJsLmM6ODgzCisjOiByZW1vdGUtY3VybC5jOjg5MgogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgZGVmbGF0ZSByZXF1ZXN0OyB6bGliIGVuZCBlcnJvciAlZCIKIG1zZ3N0ciAiaW1wb3NzaWJpbGUgZXNlZ3VpcmUgaWwgZGVmbGF0ZSBkZWxsYSByaWNoaWVzdGE7IGVycm9yZSBmaW5lIHpsaWIgJWQiCiAKLSM6IHJlbW90ZS1jdXJsLmM6MTAxNAorIzogcmVtb3RlLWN1cmwuYzoxMDIzCiBtc2dpZCAiZHVtYiBodHRwIHRyYW5zcG9ydCBkb2VzIG5vdCBzdXBwb3J0IHNoYWxsb3cgY2FwYWJpbGl0aWVzIgogbXNnc3RyICJpbCB0cmFzcG9ydG8gaHR0cCBzdHVwaWRvIG5vbiBzdXBwb3J0YSBsZSBmdW56aW9uYWxpdMOgIHNoYWxsb3ciCiAKLSM6IHJlbW90ZS1jdXJsLmM6MTAyOAorIzogcmVtb3RlLWN1cmwuYzoxMDM3CiBtc2dpZCAiZmV0Y2ggZmFpbGVkLiIKIG1zZ3N0ciAicmVjdXBlcm8gbm9uIHJpdXNjaXRvLiIKIAotIzogcmVtb3RlLWN1cmwuYzoxMDc2CisjOiByZW1vdGUtY3VybC5jOjEwODUKIG1zZ2lkICJjYW5ub3QgZmV0Y2ggYnkgc2hhMSBvdmVyIHNtYXJ0IGh0dHAiCiBtc2dzdHIgIiIKICJpbXBvc3NpYmlsZSByZWN1cGVyYXJlIGkgZGF0aSBpbiBiYXNlIGFsbG8gU0hBMSBjb24gaWwgdHJhc3BvcnRvIEhUVFAgIgogImludGVsbGlnZW50ZSIKIAotIzogcmVtb3RlLWN1cmwuYzoxMTIwIHJlbW90ZS1jdXJsLmM6MTEyNgorIzogcmVtb3RlLWN1cmwuYzoxMTI5IHJlbW90ZS1jdXJsLmM6MTEzNQogIywgYy1mb3JtYXQKIG1zZ2lkICJwcm90b2NvbCBlcnJvcjogZXhwZWN0ZWQgc2hhL3JlZiwgZ290ICclcyciCiBtc2dzdHIgImVycm9yZSBwcm90b2NvbGxvOiBhdHRlc28gU0hBL3JpZmVyaW1lbnRvLCByaWNldnV0byAnJXMnIgogCi0jOiByZW1vdGUtY3VybC5jOjExMzggcmVtb3RlLWN1cmwuYzoxMjUyCisjOiByZW1vdGUtY3VybC5jOjExNDcgcmVtb3RlLWN1cmwuYzoxMjYxCiAjLCBjLWZvcm1hdAogbXNnaWQgImh0dHAgdHJhbnNwb3J0IGRvZXMgbm90IHN1cHBvcnQgJXMiCiBtc2dzdHIgImlsIHRyYXNwb3J0byBIVFRQIG5vbiBzdXBwb3J0YSAlcyIKIAotIzogcmVtb3RlLWN1cmwuYzoxMTc0CisjOiByZW1vdGUtY3VybC5jOjExODMKIG1zZ2lkICJnaXQtaHR0cC1wdXNoIGZhaWxlZCIKIG1zZ3N0ciAiZ2l0LWh0dHAtcHVzaCBub24gcml1c2NpdG8iCiAKLSM6IHJlbW90ZS1jdXJsLmM6MTM2MAorIzogcmVtb3RlLWN1cmwuYzoxMzY3CiBtc2dpZCAicmVtb3RlLWN1cmw6IHVzYWdlOiBnaXQgcmVtb3RlLWN1cmwgPHJlbW90ZT4gWzx1cmw+XSIKIG1zZ3N0ciAicmVtb3RlLWN1cmw6IHVzbzogZ2l0IHJlbW90ZS1jdXJsIDxyZW1vdG8+IFs8VVJMPl0iCiAKLSM6IHJlbW90ZS1jdXJsLmM6MTM5MgorIzogcmVtb3RlLWN1cmwuYzoxMzk5CiBtc2dpZCAicmVtb3RlLWN1cmw6IGVycm9yIHJlYWRpbmcgY29tbWFuZCBzdHJlYW0gZnJvbSBnaXQiCiBtc2dzdHIgInJlbW90ZS1jdXJsOiBlcnJvcmUgZHVyYW50ZSBsYSBsZXR0dXJhIGRlbCBmbHVzc28gZGVpIGNvbWFuZGkgZGEgR2l0IgogCi0jOiByZW1vdGUtY3VybC5jOjEzOTkKKyM6IHJlbW90ZS1jdXJsLmM6MTQwNgogbXNnaWQgInJlbW90ZS1jdXJsOiBmZXRjaCBhdHRlbXB0ZWQgd2l0aG91dCBhIGxvY2FsIHJlcG8iCiBtc2dzdHIgInJlbW90ZS1jdXJsOiB0ZW50YXRvIHVuIGZldGNoIHNlbnphIHVuIHJlcG9zaXRvcnkgbG9jYWxlIgogCi0jOiByZW1vdGUtY3VybC5jOjE0MzkKKyM6IHJlbW90ZS1jdXJsLmM6MTQ0NgogIywgYy1mb3JtYXQKIG1zZ2lkICJyZW1vdGUtY3VybDogdW5rbm93biBjb21tYW5kICclcycgZnJvbSBnaXQiCiBtc2dzdHIgInJlbW90ZS1jdXJsOiByaWNldnV0byBjb21hbmRvIHNjb25vc2NpdXRvICclcycgZGEgR2l0IgogCi0jOiBsaXN0LW9iamVjdHMtZmlsdGVyLW9wdGlvbnMuaDo2MQorIzogbGlzdC1vYmplY3RzLWZpbHRlci1vcHRpb25zLmg6ODUKIG1zZ2lkICJhcmdzIgogbXNnc3RyICJhcmdvbWVudGkiCiAKLSM6IGxpc3Qtb2JqZWN0cy1maWx0ZXItb3B0aW9ucy5oOjYyCisjOiBsaXN0LW9iamVjdHMtZmlsdGVyLW9wdGlvbnMuaDo4NgogbXNnaWQgIm9iamVjdCBmaWx0ZXJpbmciCiBtc2dzdHIgImZpbHRyYWdnaW8gb2dnZXR0aSIKIAotIzogcGFyc2Utb3B0aW9ucy5oOjE3MAorIzogcGFyc2Utb3B0aW9ucy5oOjE3OQogbXNnaWQgImV4cGlyeS1kYXRlIgogbXNnc3RyICJkYXRhLXNjYWRlbnphIgogCi0jOiBwYXJzZS1vcHRpb25zLmg6MTg0CisjOiBwYXJzZS1vcHRpb25zLmg6MTkzCiBtc2dpZCAibm8tb3AgKGJhY2t3YXJkIGNvbXBhdGliaWxpdHkpIgogbXNnc3RyICJuby1vcCAocmV0cm9jb21wYXRpYmlsaXTDoCkiCiAKQEAgLTI0MDYwLDYgKzI0MTYzLDQ3IEBACiBtc2dpZCAiRG8geW91IHJlYWxseSB3YW50IHRvIHNlbmQgJXM/IFt5fE5dOiAiCiBtc2dzdHIgIkludmlhcmUgJXM/IFt5fE5dOiAiCiAKKyMsIGMtZm9ybWF0CisjfiBtc2dpZCAidW5rbm93biBjb3JlLnVudHJhY2tlZENhY2hlIHZhbHVlICclcyc7IHVzaW5nICdrZWVwJyBkZWZhdWx0IHZhbHVlIgorI34gbXNnc3RyICIiCisjfiAidmFsb3JlIGNvcmUudW50cmFja2VkQ2FjaGUgJyVzJyBub24gdmFsaWRvOyB1dGlsaXp6ZXLDsiBpbCB2YWxvcmUgIgorI34gInByZWRlZmluaXRvICdrZWVwJyIKKworI34gbXNnaWQgImNhbm5vdCBjaGFuZ2UgcGFydGlhbCBjbG9uZSBwcm9taXNvciByZW1vdGUiCisjfiBtc2dzdHIgImltcG9zc2liaWxlIG1vZGlmaWNhcmUgaWwgcmVtb3RvIHByb21ldHRlbnRlIGRlbCBjbG9uZSBwYXJ6aWFsZSIKKworI34gbXNnaWQgImVycm9yIGJ1aWxkaW5nIHRyZWVzIgorI34gbXNnc3RyICJlcnJvcmUgZHVyYW50ZSBsYSBjb3N0cnV6aW9uZSBkZWdsaSBhbGJlcmkiCisKKyMsIGMtZm9ybWF0CisjfiBtc2dpZCAiaW52YWxpZCBkYXRlIGZvcm1hdCAnJXMnIGluICclcyciCisjfiBtc2dzdHIgImZvcm1hdG8gZGF0YSAnJXMnIG5vbiB2YWxpZG8gaW4gJyVzJyIKKworI34gbXNnaWQgIndyaXRpbmcgcm9vdCBjb21taXQiCisjfiBtc2dzdHIgInNjcml0dHVyYSBjb21taXQgcmFkaWNlIGluIGNvcnNvIgorCisjLCBjLWZvcm1hdAorI34gbXNnaWQgInN0YWdlZCBjaGFuZ2VzIGluIHRoZSBmb2xsb3dpbmcgZmlsZXMgbWF5IGJlIGxvc3Q6ICVzIgorI34gbXNnc3RyICIiCisjfiAibGUgbW9kaWZpY2hlIGluIHN0YWdlIG5laSBzZWd1ZW50aSBmaWxlIHBvdHJlYmJlcm8gYW5kYXJlIHBlcmR1dGU6ICVzIgorCisjfiBtc2dpZCAiIgorI34gIi0tZmlsdGVyIGNhbiBvbmx5IGJlIHVzZWQgd2l0aCB0aGUgcmVtb3RlIGNvbmZpZ3VyZWQgaW4gZXh0ZW5zaW9ucy4iCisjfiAicGFydGlhbENsb25lIgorI34gbXNnc3RyICIiCisjfiAiLS1maWx0ZXIgcHXDsiBlc3NlcmUgdXNhdG8gc29sbyBjb24gaWwgcmVtb3RvIGNvbmZpZ3VyYXRvIG5lbGxlIGVzdGVuc2lvbmkuIgorI34gInBhcnRpYWxDbG9uZSIKKworI34gbXNnaWQgInZlcmlmeSBjb21taXQtbXNnIGhvb2siCisjfiBtc2dzdHIgInZlcmlmaWNhIGhvb2sgY29tbWl0LW1zZyIKKworI34gbXNnaWQgImNhbm5vdCBjb21iaW5lICctLXJlYmFzZS1tZXJnZXMnIHdpdGggJy0tc3RyYXRlZ3ktb3B0aW9uJyIKKyN+IG1zZ3N0ciAiaW1wb3NzaWJpbGUgY29tYmluYXJlICctLXJlYmFzZS1tZXJnZXMnIGNvbiAnLS1zdHJhdGVneS1vcHRpb24nIgorCisjLCBjLWZvcm1hdAorI34gbXNnaWQgImludmFsaWQgc3BhcnNlIHZhbHVlICclcyciCisjfiBtc2dzdHIgInZhbG9yZSBzcGFyc2Ugbm9uIHZhbGlkbzogJyVzJyIKKwogI34gbXNnaWQgIiIKICN+ICJGZXRjaCBub3JtYWxseSBpbmRpY2F0ZXMgd2hpY2ggYnJhbmNoZXMgaGFkIGEgZm9yY2VkIHVwZGF0ZSwgYnV0IHRoYXQgIgogI34gImNoZWNrIGhhcyBiZWVuIGRpc2FibGVkLiIKZGlmZiAtLWdpdCBhL3BvL3N2LnBvIGIvcG8vc3YucG8KaW5kZXggNGFkMjA2ZC4uMjVmMjQ1ZSAxMDA2NDQKLS0tIGEvcG8vc3YucG8KKysrIGIvcG8vc3YucG8KQEAgLTUsMTAgKzUsMTAgQEAKICMKIG1zZ2lkICIiCiBtc2dzdHIgIiIKLSJQcm9qZWN0LUlkLVZlcnNpb246IGdpdCAyLjIzLjBcbiIKKyJQcm9qZWN0LUlkLVZlcnNpb246IGdpdCAyLjI0LjBcbiIKICJSZXBvcnQtTXNnaWQtQnVncy1UbzogR2l0IE1haWxpbmcgTGlzdCA8Z2l0QHZnZXIua2VybmVsLm9yZz5cbiIKLSJQT1QtQ3JlYXRpb24tRGF0ZTogMjAxOS0wNy0zMCAwOTo1OSswODAwXG4iCi0iUE8tUmV2aXNpb24tRGF0ZTogMjAxOS0wNy0zMSAxMjo0MCswMjAwXG4iCisiUE9ULUNyZWF0aW9uLURhdGU6IDIwMTktMTAtMjggMTM6MTkrMDgwMFxuIgorIlBPLVJldmlzaW9uLURhdGU6IDIwMTktMTAtMzAgMjM6MTgrMDEwMFxuIgogIkxhc3QtVHJhbnNsYXRvcjogUGV0ZXIgS3JlZnRpbmcgPHBldGVyQHNvZnR3b2x2ZXMucHAuc2U+XG4iCiAiTGFuZ3VhZ2UtVGVhbTogU3dlZGlzaCA8dHAtc3ZAbGlzdG9yLnRwLXN2LnNlPlxuIgogIkxhbmd1YWdlOiBzdlxuIgpAQCAtMTYsNyArMTYsNyBAQAogIkNvbnRlbnQtVHlwZTogdGV4dC9wbGFpbjsgY2hhcnNldD1VVEYtOFxuIgogIkNvbnRlbnQtVHJhbnNmZXItRW5jb2Rpbmc6IDhiaXRcbiIKICJQbHVyYWwtRm9ybXM6IG5wbHVyYWxzPTI7IHBsdXJhbD0obiAhPSAxKTtcbiIKLSJYLUdlbmVyYXRvcjogUG9lZGl0IDIuMC4yXG4iCisiWC1HZW5lcmF0b3I6IEd0cmFuc2xhdG9yIDIuOTEuN1xuIgogCiAjOiBhZHZpY2UuYzoxMDkKICMsIGMtZm9ybWF0CkBAIC03MCw3ICs3MCw3IEBACiBtc2dpZCAiRXhpdGluZyBiZWNhdXNlIG9mIGFuIHVucmVzb2x2ZWQgY29uZmxpY3QuIgogbXNnc3RyICJBdnNsdXRhciBww6UgZ3J1bmQgYXYgb2zDtnN0IGtvbmZsaWtndC4iCiAKLSM6IGFkdmljZS5jOjE5MyBidWlsdGluL21lcmdlLmM6MTMyNworIzogYWR2aWNlLmM6MTkzIGJ1aWx0aW4vbWVyZ2UuYzoxMzMyCiBtc2dpZCAiWW91IGhhdmUgbm90IGNvbmNsdWRlZCB5b3VyIG1lcmdlIChNRVJHRV9IRUFEIGV4aXN0cykuIgogbXNnc3RyICJEdSBoYXIgaW50ZSBhdnNsdXRhdCBzYW1tYW5zbGFnbmluZ2VuIChNRVJHRV9IRUFEIGZpbm5zKS4iCiAKQEAgLTIwOCwxNyArMjA4LDcgQEAKIG1zZ2lkICJpbmNvbnNpc3RlbnQgaGVhZGVyIGxpbmVzICVkIGFuZCAlZCIKIG1zZ3N0ciAiaHV2dWRldCDDpHIgaW5rb25zZWt2ZW50IG1lbGxhbiByYWQgJWQgb2NoICVkIgogCi0jOiBhcHBseS5jOjE0NjAKLSMsIGMtZm9ybWF0Ci1tc2dpZCAicmVjb3VudDogdW5leHBlY3RlZCBsaW5lOiAlLipzIgotbXNnc3RyICJyZWNvdW50OiBmw7ZydsOkbnRhZGUgcmFkOiAlLipzIgotCi0jOiBhcHBseS5jOjE1MjkKLSMsIGMtZm9ybWF0Ci1tc2dpZCAicGF0Y2ggZnJhZ21lbnQgd2l0aG91dCBoZWFkZXIgYXQgbGluZSAlZDogJS4qcyIKLW1zZ3N0ciAicGF0Y2gtZnJhZ21lbnQgdXRhbiBodXZ1ZCBww6UgcmFkICVkOiAlLipzIgotCi0jOiBhcHBseS5jOjE1NTEKKyM6IGFwcGx5LmM6MTM3MgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiZ2l0IGRpZmYgaGVhZGVyIGxhY2tzIGZpbGVuYW1lIGluZm9ybWF0aW9uIHdoZW4gcmVtb3ZpbmcgJWQgbGVhZGluZyBwYXRobmFtZSAiCkBAIC0yMzQsODIgKzIyNCw5MiBAQAogInPDtmt2w6Rnc2tvbXBvbmVudGVyXG4iCiAidGFzIGJvcnQgKHJhZCAlZCkiCiAKLSM6IGFwcGx5LmM6MTU2NAorIzogYXBwbHkuYzoxMzg1CiAjLCBjLWZvcm1hdAogbXNnaWQgImdpdCBkaWZmIGhlYWRlciBsYWNrcyBmaWxlbmFtZSBpbmZvcm1hdGlvbiAobGluZSAlZCkiCiBtc2dzdHIgImdpdC1kaWZmLWh1dnVkZXQgc2FrbmFyIGZpbG5hbW5zaW5mb3JtYXRpb24gKHJhZCAlZCkiCiAKLSM6IGFwcGx5LmM6MTc1MgorIzogYXBwbHkuYzoxNDgxCisjLCBjLWZvcm1hdAorbXNnaWQgInJlY291bnQ6IHVuZXhwZWN0ZWQgbGluZTogJS4qcyIKK21zZ3N0ciAicmVjb3VudDogZsO2cnbDpG50YWRlIHJhZDogJS4qcyIKKworIzogYXBwbHkuYzoxNTUwCisjLCBjLWZvcm1hdAorbXNnaWQgInBhdGNoIGZyYWdtZW50IHdpdGhvdXQgaGVhZGVyIGF0IGxpbmUgJWQ6ICUuKnMiCittc2dzdHIgInBhdGNoLWZyYWdtZW50IHV0YW4gaHV2dWQgcMOlIHJhZCAlZDogJS4qcyIKKworIzogYXBwbHkuYzoxNzUzCiBtc2dpZCAibmV3IGZpbGUgZGVwZW5kcyBvbiBvbGQgY29udGVudHMiCiBtc2dzdHIgIm55IGZpbCBiZXJvciBww6UgZ2FtbWFsdCBpbm5laMOlbGwiCiAKLSM6IGFwcGx5LmM6MTc1NAorIzogYXBwbHkuYzoxNzU1CiBtc2dpZCAiZGVsZXRlZCBmaWxlIHN0aWxsIGhhcyBjb250ZW50cyIKIG1zZ3N0ciAiYm9ydHRhZ2VuIGZpbCBoYXIgZm9ydGZhcmFuZGUgaW5uZWjDpWxsIgogCi0jOiBhcHBseS5jOjE3ODgKKyM6IGFwcGx5LmM6MTc4OQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3JydXB0IHBhdGNoIGF0IGxpbmUgJWQiCiBtc2dzdHIgInRyYXNpZyBwYXRjaCBww6UgcmFkICVkIgogCi0jOiBhcHBseS5jOjE4MjUKKyM6IGFwcGx5LmM6MTgyNgogIywgYy1mb3JtYXQKIG1zZ2lkICJuZXcgZmlsZSAlcyBkZXBlbmRzIG9uIG9sZCBjb250ZW50cyIKIG1zZ3N0ciAibnlhIGZpbGVuICVzIGJlcm9yIHDDpSBnYW1tYWx0IGlubmVow6VsbCIKIAotIzogYXBwbHkuYzoxODI3CisjOiBhcHBseS5jOjE4MjgKICMsIGMtZm9ybWF0CiBtc2dpZCAiZGVsZXRlZCBmaWxlICVzIHN0aWxsIGhhcyBjb250ZW50cyIKIG1zZ3N0ciAiYm9ydHRhZ25hIGZpbGVuICVzIGhhciBmb3J0ZmFyYW5kZSBpbm5laMOlbGwiCiAKLSM6IGFwcGx5LmM6MTgzMAorIzogYXBwbHkuYzoxODMxCiAjLCBjLWZvcm1hdAogbXNnaWQgIioqIHdhcm5pbmc6IGZpbGUgJXMgYmVjb21lcyBlbXB0eSBidXQgaXMgbm90IGRlbGV0ZWQiCiBtc2dzdHIgIioqIHZhcm5pbmc6IGZpbGVuICVzIGJsaXIgdG9tIG1lbiBoYXIgaW50ZSB0YWdpdHMgYm9ydCIKIAotIzogYXBwbHkuYzoxOTc3CisjOiBhcHBseS5jOjE5NzgKICMsIGMtZm9ybWF0CiBtc2dpZCAiY29ycnVwdCBiaW5hcnkgcGF0Y2ggYXQgbGluZSAlZDogJS4qcyIKIG1zZ3N0ciAidHJhc2lnIGJpbsOkcnBhdGNoIHDDpSByYWQgJWQ6ICUuKnMiCiAKLSM6IGFwcGx5LmM6MjAxNAorIzogYXBwbHkuYzoyMDE1CiAjLCBjLWZvcm1hdAogbXNnaWQgInVucmVjb2duaXplZCBiaW5hcnkgcGF0Y2ggYXQgbGluZSAlZCIKIG1zZ3N0ciAiYmluw6RycGF0Y2hlbiBww6UgcmFkICVkIGvDpG5ucyBpbnRlIGlnZW4iCiAKLSM6IGFwcGx5LmM6MjE3NgorIzogYXBwbHkuYzoyMTc3CiAjLCBjLWZvcm1hdAogbXNnaWQgInBhdGNoIHdpdGggb25seSBnYXJiYWdlIGF0IGxpbmUgJWQiCiBtc2dzdHIgInBhdGNoIG1lZCBiYXJhIHNrcsOkcCBww6UgcmFkICVkIgogCi0jOiBhcHBseS5jOjIyNjIKKyM6IGFwcGx5LmM6MjI2MwogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gcmVhZCBzeW1saW5rICVzIgogbXNnc3RyICJrdW5kZSBpbnRlIGzDpHNhIHN5bWJvbGlza2EgbMOkbmtlbiAlcyIKIAotIzogYXBwbHkuYzoyMjY2CisjOiBhcHBseS5jOjIyNjcKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIG9wZW4gb3IgcmVhZCAlcyIKIG1zZ3N0ciAia3VuZGUgaW50ZSDDtnBwbmEgZWxsZXIgbMOkc2EgJXMiCiAKLSM6IGFwcGx5LmM6MjkyNQorIzogYXBwbHkuYzoyOTI2CiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgc3RhcnQgb2YgbGluZTogJyVjJyIKIG1zZ3N0ciAiZmVsYWt0aWcgaW5sZWRuaW5nIHDDpSByYWQ6IFwiJWNcIiIKIAotIzogYXBwbHkuYzozMDQ2CisjOiBhcHBseS5jOjMwNDcKICMsIGMtZm9ybWF0CiBtc2dpZCAiSHVuayAjJWQgc3VjY2VlZGVkIGF0ICVkIChvZmZzZXQgJWQgbGluZSkuIgogbXNnaWRfcGx1cmFsICJIdW5rICMlZCBzdWNjZWVkZWQgYXQgJWQgKG9mZnNldCAlZCBsaW5lcykuIgogbXNnc3RyWzBdICJTdHlja2UgJWQgbHlja2FkZXMgcMOlICVkIChvZmZzZXQgJWQgcmFkKS4iCiBtc2dzdHJbMV0gIlN0eWNrZSAlZCBseWNrYWRlcyBww6UgJWQgKG9mZnNldCAlZCByYWRlcikuIgogCi0jOiBhcHBseS5jOjMwNTgKKyM6IGFwcGx5LmM6MzA1OQogIywgYy1mb3JtYXQKIG1zZ2lkICJDb250ZXh0IHJlZHVjZWQgdG8gKCVsZC8lbGQpIHRvIGFwcGx5IGZyYWdtZW50IGF0ICVkIgogbXNnc3RyICJTYW1tYW5oYW5nIHJlZHVjZXJhdCB0aWxsICglbGQvJWxkKSBmw7ZyIGF0dCB0aWxsw6RtcGEgZnJhZ21lbnQgdmlkICVkIgogCi0jOiBhcHBseS5jOjMwNjQKKyM6IGFwcGx5LmM6MzA2NQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAid2hpbGUgc2VhcmNoaW5nIGZvcjpcbiIKQEAgLTMxOCwyNSArMzE4LDI1IEBACiAidmlkIHPDtmtuaW5nIGVmdGVyOlxuIgogIiUuKnMiCiAKLSM6IGFwcGx5LmM6MzA4NgorIzogYXBwbHkuYzozMDg3CiAjLCBjLWZvcm1hdAogbXNnaWQgIm1pc3NpbmcgYmluYXJ5IHBhdGNoIGRhdGEgZm9yICclcyciCiBtc2dzdHIgInNha25hciBiaW7DpHJhIHBhdGNoZGF0YSBmw7ZyIFwiJXNcIiIKIAotIzogYXBwbHkuYzozMDk0CisjOiBhcHBseS5jOjMwOTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IHJldmVyc2UtYXBwbHkgYSBiaW5hcnkgcGF0Y2ggd2l0aG91dCB0aGUgcmV2ZXJzZSBodW5rIHRvICclcyciCiBtc2dzdHIgIiIKICJrYW4gaW50ZSBhcHBsaWNlcmEgZW4gYmluw6RycGF0Y2ggYmFrbMOkbmdlcyB1dGFuIGRlbiBvbXbDpG5kYSBwYXRjaGVuIGbDtnIgXCIlcyIKICJcIiIKIAotIzogYXBwbHkuYzozMTQxCisjOiBhcHBseS5jOjMxNDIKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IGFwcGx5IGJpbmFyeSBwYXRjaCB0byAnJXMnIHdpdGhvdXQgZnVsbCBpbmRleCBsaW5lIgogbXNnc3RyICIiCiAia2FuIGludGUgYXBwbGljZXJhIGJpbsOkcnBhdGNoIHDDpSBcIiVzXCIgdXRhbiBkZW4gZnVsbHN0w6RuZGlnYSBpbmRleHJhZGVuIgogCi0jOiBhcHBseS5jOjMxNTEKKyM6IGFwcGx5LmM6MzE1MgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAidGhlIHBhdGNoIGFwcGxpZXMgdG8gJyVzJyAoJXMpLCB3aGljaCBkb2VzIG5vdCBtYXRjaCB0aGUgY3VycmVudCBjb250ZW50cy4iCkBAIC0zNDQsNDI2ICszNDQsNDI2IEBACiAicGF0Y2hlbiBhcHBsaWNlcmFzIHDDpSBcIiVzXCIgKCVzKSwgc29tIGludGUgbW90c3ZhcmFyIGRldCBudXZhcmFuZGUgIgogImlubmVow6VsbGV0LiIKIAotIzogYXBwbHkuYzozMTU5CisjOiBhcHBseS5jOjMxNjAKICMsIGMtZm9ybWF0CiBtc2dpZCAidGhlIHBhdGNoIGFwcGxpZXMgdG8gYW4gZW1wdHkgJyVzJyBidXQgaXQgaXMgbm90IGVtcHR5IgogbXNnc3RyICJwYXRjaGVuIGFwcGxpY2VyYXMgcMOlIGVuIHRvbSBcIiVzXCIsIG1lbiBkZW4gw6RyIGludGUgdG9tIgogCi0jOiBhcHBseS5jOjMxNzcKKyM6IGFwcGx5LmM6MzE3OAogIywgYy1mb3JtYXQKIG1zZ2lkICJ0aGUgbmVjZXNzYXJ5IHBvc3RpbWFnZSAlcyBmb3IgJyVzJyBjYW5ub3QgYmUgcmVhZCIKIG1zZ3N0ciAibsO2ZHbDpG5kaWcgZWZ0ZXJiaWxkICVzIGbDtnIgXCIlc1wiIGthbiBpbnRlIGzDpHNhcyIKIAotIzogYXBwbHkuYzozMTkwCisjOiBhcHBseS5jOjMxOTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiYmluYXJ5IHBhdGNoIGRvZXMgbm90IGFwcGx5IHRvICclcyciCiBtc2dzdHIgImJpbsOkcnBhdGNoZW4ga2FuIGludGUgdGlsbMOkbXBhcyBww6UgXCIlc1wiIgogCi0jOiBhcHBseS5jOjMxOTYKKyM6IGFwcGx5LmM6MzE5NwogIywgYy1mb3JtYXQKIG1zZ2lkICJiaW5hcnkgcGF0Y2ggdG8gJyVzJyBjcmVhdGVzIGluY29ycmVjdCByZXN1bHQgKGV4cGVjdGluZyAlcywgZ290ICVzKSIKIG1zZ3N0ciAiYmluw6RycGF0Y2hlbiBww6UgXCIlc1wiIGdlciBmZWxha3RpZ3QgcmVzdWx0YXQgKGbDtnJ2w6RudGFkZSAlcywgZmljayAlcykiCiAKLSM6IGFwcGx5LmM6MzIxNworIzogYXBwbHkuYzozMjE4CiAjLCBjLWZvcm1hdAogbXNnaWQgInBhdGNoIGZhaWxlZDogJXM6JWxkIgogbXNnc3RyICJwYXRjaCBtaXNzbHlja2FkZXM6ICVzOiVsZCIKIAotIzogYXBwbHkuYzozMzQwCisjOiBhcHBseS5jOjMzNDEKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IGNoZWNrb3V0ICVzIgogbXNnc3RyICJrYW4gaW50ZSBjaGVja2EgdXQgJXMiCiAKLSM6IGFwcGx5LmM6MzM5MiBhcHBseS5jOjM0MDMgYXBwbHkuYzozNDQ5IG1pZHguYzo2MiBzZXR1cC5jOjI3OQorIzogYXBwbHkuYzozMzkzIGFwcGx5LmM6MzQwNCBhcHBseS5jOjM0NTAgbWlkeC5jOjYxIHNldHVwLmM6MjgwCiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byByZWFkICVzIgogbXNnc3RyICJtaXNzbHlja2FkZXMgbMOkc2EgJXMiCiAKLSM6IGFwcGx5LmM6MzQwMAorIzogYXBwbHkuYzozNDAxCiAjLCBjLWZvcm1hdAogbXNnaWQgInJlYWRpbmcgZnJvbSAnJXMnIGJleW9uZCBhIHN5bWJvbGljIGxpbmsiCiBtc2dzdHIgImzDpHNlciBmcsOlbiBcIiVzXCIgc29tIMOkciBww6UgYW5kcmEgc2lkYW4gYXYgZW4gc3ltYm9saXNrIGzDpG5rIgogCi0jOiBhcHBseS5jOjM0MjkgYXBwbHkuYzozNjcyCisjOiBhcHBseS5jOjM0MzAgYXBwbHkuYzozNjczCiAjLCBjLWZvcm1hdAogbXNnaWQgInBhdGggJXMgaGFzIGJlZW4gcmVuYW1lZC9kZWxldGVkIgogbXNnc3RyICJzw7ZrdsOkZ2VuICVzIGhhciDDpG5kcmF0IG5hbW4vdGFnaXRzIGJvcnQiCiAKLSM6IGFwcGx5LmM6MzUxNSBhcHBseS5jOjM2ODcKKyM6IGFwcGx5LmM6MzUxNiBhcHBseS5jOjM2ODgKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXM6IGRvZXMgbm90IGV4aXN0IGluIGluZGV4IgogbXNnc3RyICIlczogZmlubnMgaW50ZSBpIGluZGV4ZXQiCiAKLSM6IGFwcGx5LmM6MzUyNCBhcHBseS5jOjM2OTUKKyM6IGFwcGx5LmM6MzUyNSBhcHBseS5jOjM2OTYKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXM6IGRvZXMgbm90IG1hdGNoIGluZGV4IgogbXNnc3RyICIlczogbW90c3ZhcmFyIGludGUgaW5kZXhldCIKIAotIzogYXBwbHkuYzozNTU5CisjOiBhcHBseS5jOjM1NjAKIG1zZ2lkICJyZXBvc2l0b3J5IGxhY2tzIHRoZSBuZWNlc3NhcnkgYmxvYiB0byBmYWxsIGJhY2sgb24gMy13YXkgbWVyZ2UuIgogbXNnc3RyICIiCiAiYXJraXZldCBzYWtuYXIgb2JqZWt0IHNvbSBiZWjDtnZzIGbDtnIgYXR0IGZhbGxhIHRpbGxiYWthIHDDpSAzLSIKICJ2w6Rnc3NhbW1hbnNsYWduaW5nLiIKIAotIzogYXBwbHkuYzozNTYyCisjOiBhcHBseS5jOjM1NjMKICMsIGMtZm9ybWF0CiBtc2dpZCAiRmFsbGluZyBiYWNrIHRvIHRocmVlLXdheSBtZXJnZS4uLlxuIgogbXNnc3RyICJGYWxsZXIgdGlsbGJha2EgcMOlIHRyZXbDpGdzc2FtbWFuc2xhZ25pbmcuLi5cbiIKIAotIzogYXBwbHkuYzozNTc4IGFwcGx5LmM6MzU4MgorIzogYXBwbHkuYzozNTc5IGFwcGx5LmM6MzU4MwogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgcmVhZCB0aGUgY3VycmVudCBjb250ZW50cyBvZiAnJXMnIgogbXNnc3RyICJrdW5kZSBpbnRlIGzDpHNhIGFrdHVlbGx0IGlubmVow6VsbCBpIFwiJXNcIiIKIAotIzogYXBwbHkuYzozNTk0CisjOiBhcHBseS5jOjM1OTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiRmFpbGVkIHRvIGZhbGwgYmFjayBvbiB0aHJlZS13YXkgbWVyZ2UuLi5cbiIKIG1zZ3N0ciAiTWlzc2x5Y2thZGVzIGZhbGxhIHRpbGxiYWthIHDDpSB0cmV2w6Rnc3NhbW1hbnNsYWduaW5nLi4uXG4iCiAKLSM6IGFwcGx5LmM6MzYwOAorIzogYXBwbHkuYzozNjA5CiAjLCBjLWZvcm1hdAogbXNnaWQgIkFwcGxpZWQgcGF0Y2ggdG8gJyVzJyB3aXRoIGNvbmZsaWN0cy5cbiIKIG1zZ3N0ciAiQXBwbGljZXJhZGUgcGF0Y2hlbiBww6UgXCIlc1wiIG1lZCBrb25mbGlrdGVyLlxuIgogCi0jOiBhcHBseS5jOjM2MTMKKyM6IGFwcGx5LmM6MzYxNAogIywgYy1mb3JtYXQKIG1zZ2lkICJBcHBsaWVkIHBhdGNoIHRvICclcycgY2xlYW5seS5cbiIKIG1zZ3N0ciAiVGlsbMOkbXBhZGUgcGF0Y2hlbiBww6UgIFwiJXNcIiByZW50LlxuIgogCi0jOiBhcHBseS5jOjM2MzkKKyM6IGFwcGx5LmM6MzY0MAogbXNnaWQgInJlbW92YWwgcGF0Y2ggbGVhdmVzIGZpbGUgY29udGVudHMiCiBtc2dzdHIgInBhdGNoIGbDtnIgYm9ydHRhZ25pbmcgbMOkbW5hciBrdmFyIGZpbGlubmVow6VsbCIKIAotIzogYXBwbHkuYzozNzEyCisjOiBhcHBseS5jOjM3MTMKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXM6IHdyb25nIHR5cGUiCiBtc2dzdHIgIiVzOiBmZWwgdHlwIgogCi0jOiBhcHBseS5jOjM3MTQKKyM6IGFwcGx5LmM6MzcxNQogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyBoYXMgdHlwZSAlbywgZXhwZWN0ZWQgJW8iCiBtc2dzdHIgIiVzIGhhciB0eXBlbiAlbywgZsO2cnbDpG50YWRlICVvIgogCi0jOiBhcHBseS5jOjM4NjUgYXBwbHkuYzozODY3IHJlYWQtY2FjaGUuYzo4MzAgcmVhZC1jYWNoZS5jOjg1NgorIzogYXBwbHkuYzozODY2IGFwcGx5LmM6Mzg2OCByZWFkLWNhY2hlLmM6ODMwIHJlYWQtY2FjaGUuYzo4NTYKICM6IHJlYWQtY2FjaGUuYzoxMzA5CiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgcGF0aCAnJXMnIgogbXNnc3RyICJvZ2lsdGlnIHPDtmt2w6RnIFwiJXNcIiIKIAotIzogYXBwbHkuYzozOTIzCisjOiBhcHBseS5jOjM5MjQKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXM6IGFscmVhZHkgZXhpc3RzIGluIGluZGV4IgogbXNnc3RyICIlczogZmlubnMgcmVkYW4gaSBpbmRleGV0IgogCi0jOiBhcHBseS5jOjM5MjYKKyM6IGFwcGx5LmM6MzkyNwogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogYWxyZWFkeSBleGlzdHMgaW4gd29ya2luZyBkaXJlY3RvcnkiCiBtc2dzdHIgIiVzOiBmaW5ucyByZWRhbiBpIGFyYmV0c2thdGFsb2dlbiIKIAotIzogYXBwbHkuYzozOTQ2CisjOiBhcHBseS5jOjM5NDcKICMsIGMtZm9ybWF0CiBtc2dpZCAibmV3IG1vZGUgKCVvKSBvZiAlcyBkb2VzIG5vdCBtYXRjaCBvbGQgbW9kZSAoJW8pIgogbXNnc3RyICJueXR0IGzDpGdlICglbykgZsO2ciAlcyBtb3RzdmFyYXIgaW50ZSBnYW1tYWx0IGzDpGdlICglbykiCiAKLSM6IGFwcGx5LmM6Mzk1MQorIzogYXBwbHkuYzozOTUyCiAjLCBjLWZvcm1hdAogbXNnaWQgIm5ldyBtb2RlICglbykgb2YgJXMgZG9lcyBub3QgbWF0Y2ggb2xkIG1vZGUgKCVvKSBvZiAlcyIKIG1zZ3N0ciAibnl0dCBsw6RnZSAoJW8pIGbDtnIgJXMgbW90c3ZhcmFyIGludGUgZ2FtbWFsdCBsw6RnZSAoJW8pIGbDtnIgJXMiCiAKLSM6IGFwcGx5LmM6Mzk3MQorIzogYXBwbHkuYzozOTcyCiAjLCBjLWZvcm1hdAogbXNnaWQgImFmZmVjdGVkIGZpbGUgJyVzJyBpcyBiZXlvbmQgYSBzeW1ib2xpYyBsaW5rIgogbXNnc3RyICJkZW4gYmVyw7ZyZGEgZmlsZW4gXCIlc1wiIMOkciBww6UgYW5kcmEgc2lkYW4gYXYgZW4gc3ltYm9saXNrIGzDpG5rIgogCi0jOiBhcHBseS5jOjM5NzUKKyM6IGFwcGx5LmM6Mzk3NgogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogcGF0Y2ggZG9lcyBub3QgYXBwbHkiCiBtc2dzdHIgIiVzOiBwYXRjaGVuIGthbiBpbnRlIHRpbGzDpG1wYXMiCiAKLSM6IGFwcGx5LmM6Mzk5MAorIzogYXBwbHkuYzozOTkxCiAjLCBjLWZvcm1hdAogbXNnaWQgIkNoZWNraW5nIHBhdGNoICVzLi4uIgogbXNnc3RyICJLb250cm9sbGVyYXIgcGF0Y2hlbiAlcy4uLiIKIAotIzogYXBwbHkuYzo0MDgyCisjOiBhcHBseS5jOjQwODMKICMsIGMtZm9ybWF0CiBtc2dpZCAic2hhMSBpbmZvcm1hdGlvbiBpcyBsYWNraW5nIG9yIHVzZWxlc3MgZm9yIHN1Ym1vZHVsZSAlcyIKIG1zZ3N0ciAic2hhMS1pbmZvcm1hdGlvbmVuIHNha25hcyBlbGxlciDDpHIgb2FudsOkbmRiYXIgZsO2ciB1bmRlcm1vZHVsZW4gJXMiCiAKLSM6IGFwcGx5LmM6NDA4OQorIzogYXBwbHkuYzo0MDkwCiAjLCBjLWZvcm1hdAogbXNnaWQgIm1vZGUgY2hhbmdlIGZvciAlcywgd2hpY2ggaXMgbm90IGluIGN1cnJlbnQgSEVBRCIKIG1zZ3N0ciAibnl0dCBsw6RnZSBmw7ZyICVzLCBzb20gaW50ZSBmaW5ucyBpIG51dmFyYW5kZSBIRUFEIgogCi0jOiBhcHBseS5jOjQwOTIKKyM6IGFwcGx5LmM6NDA5MwogIywgYy1mb3JtYXQKIG1zZ2lkICJzaGExIGluZm9ybWF0aW9uIGlzIGxhY2tpbmcgb3IgdXNlbGVzcyAoJXMpLiIKIG1zZ3N0ciAic2hhMS1pbmZvcm1hdGlvbmVuIHNha25hcyBlbGxlciDDpHIgb2FudsOkbmRiYXIgKCVzKS4iCiAKLSM6IGFwcGx5LmM6NDA5NyBidWlsdGluL2NoZWNrb3V0LmM6Mjc4IGJ1aWx0aW4vcmVzZXQuYzoxNDMKKyM6IGFwcGx5LmM6NDA5OCBidWlsdGluL2NoZWNrb3V0LmM6Mjc5IGJ1aWx0aW4vcmVzZXQuYzoxNDMKICMsIGMtZm9ybWF0CiBtc2dpZCAibWFrZV9jYWNoZV9lbnRyeSBmYWlsZWQgZm9yIHBhdGggJyVzJyIKIG1zZ3N0ciAibWFrZV9jYWNoZV9lbnRyeSBtaXNzbHlja2FkZXMgZsO2ciBzw7ZrdsOkZ2VuIFwiJXNcIiIKIAotIzogYXBwbHkuYzo0MTAxCisjOiBhcHBseS5jOjQxMDIKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGFkZCAlcyB0byB0ZW1wb3JhcnkgaW5kZXgiCiBtc2dzdHIgImt1bmRlIGludGUgbMOkZ2dhIHRpbGwgJXMgdGlsbCB0ZW1wb3LDpHJ0IGluZGV4IgogCi0jOiBhcHBseS5jOjQxMTEKKyM6IGFwcGx5LmM6NDExMgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3Qgd3JpdGUgdGVtcG9yYXJ5IGluZGV4IHRvICVzIgogbXNnc3RyICJrdW5kZSBpbnRlIHNrcml2YSB0ZW1wb3LDpHJ0IGluZGV4IHRpbGwgJXMiCiAKLSM6IGFwcGx5LmM6NDI0OQorIzogYXBwbHkuYzo0MjUwCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byByZW1vdmUgJXMgZnJvbSBpbmRleCIKIG1zZ3N0ciAia2FuIGludGUgdGEgYm9ydCAlcyBmcsOlbiBpbmRleGV0IgogCi0jOiBhcHBseS5jOjQyODMKKyM6IGFwcGx5LmM6NDI4NAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3JydXB0IHBhdGNoIGZvciBzdWJtb2R1bGUgJXMiCiBtc2dzdHIgInRyYXNpZyBwYXRjaCBmw7ZyIHVuZGVybW9kdWxlbiAlcyIKIAotIzogYXBwbHkuYzo0Mjg5CisjOiBhcHBseS5jOjQyOTAKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHN0YXQgbmV3bHkgY3JlYXRlZCBmaWxlICclcyciCiBtc2dzdHIgImthbiBpbnRlIHRhIHN0YXR1cyBww6UgbnlsaWdlbiBza2FwYWRlIGZpbGVuIFwiJXNcIiIKIAotIzogYXBwbHkuYzo0Mjk3CisjOiBhcHBseS5jOjQyOTgKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGNyZWF0ZSBiYWNraW5nIHN0b3JlIGZvciBuZXdseSBjcmVhdGVkIGZpbGUgJXMiCiBtc2dzdHIgImthbiBpbnRlIHNrYXBhIHPDpGtlcmhldHNtaW5uZSBmw7ZyIG55bGlnZW4gc2thcGFkZSBmaWxlbiAlcyIKIAotIzogYXBwbHkuYzo0MzAzIGFwcGx5LmM6NDQ0OAorIzogYXBwbHkuYzo0MzA0IGFwcGx5LmM6NDQ0OQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gYWRkIGNhY2hlIGVudHJ5IGZvciAlcyIKIG1zZ3N0ciAia2FuIGludGUgbMOkZ2dhIHRpbGwgY2FjaGVwb3N0IGbDtnIgJXMiCiAKLSM6IGFwcGx5LmM6NDM0NgorIzogYXBwbHkuYzo0MzQ3CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byB3cml0ZSB0byAnJXMnIgogbXNnc3RyICJtaXNzbHlja2FkZXMgc2tyaXZhIHRpbGwgXCIlc1wiIgogCi0jOiBhcHBseS5jOjQzNTAKKyM6IGFwcGx5LmM6NDM1MQogIywgYy1mb3JtYXQKIG1zZ2lkICJjbG9zaW5nIGZpbGUgJyVzJyIKIG1zZ3N0ciAic3TDpG5nZXIgZmlsZW4gXCIlc1wiIgogCi0jOiBhcHBseS5jOjQ0MjAKKyM6IGFwcGx5LmM6NDQyMQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gd3JpdGUgZmlsZSAnJXMnIG1vZGUgJW8iCiBtc2dzdHIgImthbiBpbnRlIHNrcml2YSBmaWxlbiBcIiVzXCIgbMOkZ2UgJW8iCiAKLSM6IGFwcGx5LmM6NDUxOAorIzogYXBwbHkuYzo0NTE5CiAjLCBjLWZvcm1hdAogbXNnaWQgIkFwcGxpZWQgcGF0Y2ggJXMgY2xlYW5seS4iCiBtc2dzdHIgIlRpbGzDpG1wYWRlIHBhdGNoZW4gJXMgcmVudC4iCiAKLSM6IGFwcGx5LmM6NDUyNgorIzogYXBwbHkuYzo0NTI3CiBtc2dpZCAiaW50ZXJuYWwgZXJyb3IiCiBtc2dzdHIgImludGVybnQgZmVsIgogCi0jOiBhcHBseS5jOjQ1MjkKKyM6IGFwcGx5LmM6NDUzMAogIywgYy1mb3JtYXQKIG1zZ2lkICJBcHBseWluZyBwYXRjaCAlJXMgd2l0aCAlZCByZWplY3QuLi4iCiBtc2dpZF9wbHVyYWwgIkFwcGx5aW5nIHBhdGNoICUlcyB3aXRoICVkIHJlamVjdHMuLi4iCiBtc2dzdHJbMF0gIlRpbGzDpG1wYWRlIHBhdGNoZW4gJSVzIG1lZCAlZCByZWZ1c2VyYWQuLi4iCiBtc2dzdHJbMV0gIlRpbGzDpG1wYWRlIHBhdGNoZW4gJSVzIG1lZCAlZCByZWZ1c2VyYWRlLi4uIgogCi0jOiBhcHBseS5jOjQ1NDAKKyM6IGFwcGx5LmM6NDU0MQogIywgYy1mb3JtYXQKIG1zZ2lkICJ0cnVuY2F0aW5nIC5yZWogZmlsZW5hbWUgdG8gJS4qcy5yZWoiCiBtc2dzdHIgInRydW5rZXJhciAucmVqLWZpbG5hbW5ldCB0aWxsICUuKnMucmVqIgogCi0jOiBhcHBseS5jOjQ1NDggYnVpbHRpbi9mZXRjaC5jOjg2OSBidWlsdGluL2ZldGNoLmM6MTE2MQorIzogYXBwbHkuYzo0NTQ5IGJ1aWx0aW4vZmV0Y2guYzo4OTggYnVpbHRpbi9mZXRjaC5jOjExOTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IG9wZW4gJXMiCiBtc2dzdHIgImthbiBpbnRlIMO2cHBuYSAlcyIKIAotIzogYXBwbHkuYzo0NTYyCisjOiBhcHBseS5jOjQ1NjMKICMsIGMtZm9ybWF0CiBtc2dpZCAiSHVuayAjJWQgYXBwbGllZCBjbGVhbmx5LiIKIG1zZ3N0ciAiU3R5Y2tlICVkIHRpbGzDpG1wYWRlcyByZW50LiIKIAotIzogYXBwbHkuYzo0NTY2CisjOiBhcHBseS5jOjQ1NjcKICMsIGMtZm9ybWF0CiBtc2dpZCAiUmVqZWN0ZWQgaHVuayAjJWQuIgogbXNnc3RyICJSZWZ1c2VyYXIgc3R5Y2tlICVkLiIKIAotIzogYXBwbHkuYzo0Njc2CisjOiBhcHBseS5jOjQ2ODYKICMsIGMtZm9ybWF0CiBtc2dpZCAiU2tpcHBlZCBwYXRjaCAnJXMnLiIKIG1zZ3N0ciAiSWdub3JlcmFyIHBhdGNoIFwiJXNcIi4iCiAKLSM6IGFwcGx5LmM6NDY4NAorIzogYXBwbHkuYzo0Njk0CiBtc2dpZCAidW5yZWNvZ25pemVkIGlucHV0IgogbXNnc3RyICJpbmRhdGEga8Okbm5zIGludGUgaWdlbiIKIAotIzogYXBwbHkuYzo0NzA0CisjOiBhcHBseS5jOjQ3MTQKIG1zZ2lkICJ1bmFibGUgdG8gcmVhZCBpbmRleCBmaWxlIgogbXNnc3RyICJrYW4gaW50ZSBsw6RzYSBpbmRleGZpbGVuIgogCi0jOiBhcHBseS5jOjQ4NTkKKyM6IGFwcGx5LmM6NDg3MQogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW4ndCBvcGVuIHBhdGNoICclcyc6ICVzIgogbXNnc3RyICJrYW4gaW50ZSDDtnBwbmEgcGF0Y2hlbiBcIiVzXCI6ICVzIgogCi0jOiBhcHBseS5jOjQ4ODYKKyM6IGFwcGx5LmM6NDg5OAogIywgYy1mb3JtYXQKIG1zZ2lkICJzcXVlbGNoZWQgJWQgd2hpdGVzcGFjZSBlcnJvciIKIG1zZ2lkX3BsdXJhbCAic3F1ZWxjaGVkICVkIHdoaXRlc3BhY2UgZXJyb3JzIgogbXNnc3RyWzBdICJ1bmRlcnRyeWNrdGUgJWQgZmVsIGkgYmxhbmtzdGVnIgogbXNnc3RyWzFdICJ1bmRlcnRyeWNrdGUgJWQgZmVsIGkgYmxhbmtzdGVnIgogCi0jOiBhcHBseS5jOjQ4OTIgYXBwbHkuYzo0OTA3CisjOiBhcHBseS5jOjQ5MDQgYXBwbHkuYzo0OTE5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVkIGxpbmUgYWRkcyB3aGl0ZXNwYWNlIGVycm9ycy4iCiBtc2dpZF9wbHVyYWwgIiVkIGxpbmVzIGFkZCB3aGl0ZXNwYWNlIGVycm9ycy4iCiBtc2dzdHJbMF0gIiVkIHJhZCBsw6RnZ2VyIHRpbGwgZmVsIGkgYmxhbmtzdGVnLiIKIG1zZ3N0clsxXSAiJWQgcmFkZXIgbMOkZ2dlciB0aWxsIGZlbCBpIGJsYW5rc3RlZy4iCiAKLSM6IGFwcGx5LmM6NDkwMAorIzogYXBwbHkuYzo0OTEyCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVkIGxpbmUgYXBwbGllZCBhZnRlciBmaXhpbmcgd2hpdGVzcGFjZSBlcnJvcnMuIgogbXNnaWRfcGx1cmFsICIlZCBsaW5lcyBhcHBsaWVkIGFmdGVyIGZpeGluZyB3aGl0ZXNwYWNlIGVycm9ycy4iCiBtc2dzdHJbMF0gIiVkIHJhZCBhcHBsaWNlcmFkZSBlZnRlciBhdHQgaGEgcsOkdHRhdCBmZWwgaSBibGFua3N0ZWcuIgogbXNnc3RyWzFdICIlZCByYWRlciBhcHBsaWNlcmFkZSBlZnRlciBhdHQgaGEgcsOkdHRhdCBmZWwgaSBibGFua3N0ZWcuIgogCi0jOiBhcHBseS5jOjQ5MTYgYnVpbHRpbi9hZGQuYzo1NDAgYnVpbHRpbi9tdi5jOjMwMSBidWlsdGluL3JtLmM6MzkwCisjOiBhcHBseS5jOjQ5MjggYnVpbHRpbi9hZGQuYzo1NDAgYnVpbHRpbi9tdi5jOjMwMSBidWlsdGluL3JtLmM6MzkwCiBtc2dpZCAiVW5hYmxlIHRvIHdyaXRlIG5ldyBpbmRleCBmaWxlIgogbXNnc3RyICJLdW5kZSBpbnRlIHNrcml2YSBueSBpbmRleGZpbCIKIAotIzogYXBwbHkuYzo0OTQzIGFwcGx5LmM6NDk0NiBidWlsdGluL2FtLmM6MjIwOCBidWlsdGluL2FtLmM6MjIxMQotIzogYnVpbHRpbi9jbG9uZS5jOjEyMyBidWlsdGluL2ZldGNoLmM6MTI4IGJ1aWx0aW4vbWVyZ2UuYzoyNzMKLSM6IGJ1aWx0aW4vcHVsbC5jOjIwOCBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6NDA3CisjOiBhcHBseS5jOjQ5NTUgYXBwbHkuYzo0OTU4IGJ1aWx0aW4vYW0uYzoyMTk3IGJ1aWx0aW4vYW0uYzoyMjAwCisjOiBidWlsdGluL2Nsb25lLmM6MTIyIGJ1aWx0aW4vZmV0Y2guYzoxNDMgYnVpbHRpbi9tZXJnZS5jOjI3MworIzogYnVpbHRpbi9wdWxsLmM6MjA5IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzo0MDcKICM6IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxMzY3IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxMzcwCiAjOiBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6MTg1MCBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6MTg1MwogIzogYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjIwOTIgZ2l0LWFkZC0taW50ZXJhY3RpdmUucGVybDoyMTEKIG1zZ2lkICJwYXRoIgogbXNnc3RyICJzw7ZrdsOkZyIKIAotIzogYXBwbHkuYzo0OTQ0CisjOiBhcHBseS5jOjQ5NTYKIG1zZ2lkICJkb24ndCBhcHBseSBjaGFuZ2VzIG1hdGNoaW5nIHRoZSBnaXZlbiBwYXRoIgogbXNnc3RyICJ0aWxsw6RtcGEgaW50ZSDDpG5kcmluZ2FyIHNvbSBtb3RzdmFyYXIgZ2l2ZW4gc8O2a3bDpGciCiAKLSM6IGFwcGx5LmM6NDk0NworIzogYXBwbHkuYzo0OTU5CiBtc2dpZCAiYXBwbHkgY2hhbmdlcyBtYXRjaGluZyB0aGUgZ2l2ZW4gcGF0aCIKIG1zZ3N0ciAidGlsbMOkbXBhIMOkbmRyaW5nYXIgc29tIG1vdHN2YXJhciBnaXZlbiBzw7ZrdsOkZyIKIAotIzogYXBwbHkuYzo0OTQ5IGJ1aWx0aW4vYW0uYzoyMjE3CisjOiBhcHBseS5jOjQ5NjEgYnVpbHRpbi9hbS5jOjIyMDYKIG1zZ2lkICJudW0iCiBtc2dzdHIgImFudGFsIgogCi0jOiBhcHBseS5jOjQ5NTAKKyM6IGFwcGx5LmM6NDk2MgogbXNnaWQgInJlbW92ZSA8bnVtPiBsZWFkaW5nIHNsYXNoZXMgZnJvbSB0cmFkaXRpb25hbCBkaWZmIHBhdGhzIgogbXNnc3RyICJ0YSBib3J0IDxhbnRhbD4gaW5sZWRhbmRlIHNuZWRzdHJlY2sgZnLDpW4gdHJhZGl0aW9uZWxsYSBkaWZmLXPDtmt2w6RnYXIiCiAKLSM6IGFwcGx5LmM6NDk1MworIzogYXBwbHkuYzo0OTY1CiBtc2dpZCAiaWdub3JlIGFkZGl0aW9ucyBtYWRlIGJ5IHRoZSBwYXRjaCIKIG1zZ3N0ciAiaWdub3JlcmEgdGlsbMOkZ2cgZ2pvcmRhIGF2IHBhdGNoZW4iCiAKLSM6IGFwcGx5LmM6NDk1NQorIzogYXBwbHkuYzo0OTY3CiBtc2dpZCAiaW5zdGVhZCBvZiBhcHBseWluZyB0aGUgcGF0Y2gsIG91dHB1dCBkaWZmc3RhdCBmb3IgdGhlIGlucHV0IgogbXNnc3RyICJpc3TDpGxsZXQgZsO2ciBhdHQgdGlsbMOkbXBhIHBhdGNoZW4sIHNrcml2IHV0IGRpZmZzdGF0IGbDtnIgaW5kYXRhIgogCi0jOiBhcHBseS5jOjQ5NTkKKyM6IGFwcGx5LmM6NDk3MQogbXNnaWQgInNob3cgbnVtYmVyIG9mIGFkZGVkIGFuZCBkZWxldGVkIGxpbmVzIGluIGRlY2ltYWwgbm90YXRpb24iCiBtc2dzdHIgInZpc2EgYW50YWwgdGlsbGFnZGEgb2NoIGJvcnR0YWduYSByYWRlciBkZWNpbWFsdCIKIAotIzogYXBwbHkuYzo0OTYxCisjOiBhcHBseS5jOjQ5NzMKIG1zZ2lkICJpbnN0ZWFkIG9mIGFwcGx5aW5nIHRoZSBwYXRjaCwgb3V0cHV0IGEgc3VtbWFyeSBmb3IgdGhlIGlucHV0IgogbXNnc3RyICJpc3TDpGxsZXQgZsO2ciBhdHQgdGlsbMOkbXBhIHBhdGNoZW4sIHNrcml2IHV0IGVuIHN1bW1lcmluZyBhdiBpbmRhdGEiCiAKLSM6IGFwcGx5LmM6NDk2MworIzogYXBwbHkuYzo0OTc1CiBtc2dpZCAiaW5zdGVhZCBvZiBhcHBseWluZyB0aGUgcGF0Y2gsIHNlZSBpZiB0aGUgcGF0Y2ggaXMgYXBwbGljYWJsZSIKIG1zZ3N0ciAiaXN0w6RsbGV0IGbDtnIgYXR0IHRpbGzDpG1wYSBwYXRjaGVuLCBzZSBvbSBwYXRjaGVuIGthbiB0aWxsw6RtcGFzIgogCi0jOiBhcHBseS5jOjQ5NjUKKyM6IGFwcGx5LmM6NDk3NwogbXNnaWQgIm1ha2Ugc3VyZSB0aGUgcGF0Y2ggaXMgYXBwbGljYWJsZSB0byB0aGUgY3VycmVudCBpbmRleCIKIG1zZ3N0ciAic2UgdGlsbCBhdHQgcGF0Y2hlbiBrYW4gdGlsbMOkbXBhcyBww6UgYWt0dWVsbHQgaW5kZXgiCiAKLSM6IGFwcGx5LmM6NDk2NworIzogYXBwbHkuYzo0OTc5CiBtc2dpZCAibWFyayBuZXcgZmlsZXMgd2l0aCBgZ2l0IGFkZCAtLWludGVudC10by1hZGRgIgogbXNnc3RyICJtYXJrZXJhIG55YSBmaWxlciBtZWQgXCJnaXQgYWRkIC0taW50ZW50LXRvLWFkZFwiIgogCi0jOiBhcHBseS5jOjQ5NjkKKyM6IGFwcGx5LmM6NDk4MQogbXNnaWQgImFwcGx5IGEgcGF0Y2ggd2l0aG91dCB0b3VjaGluZyB0aGUgd29ya2luZyB0cmVlIgogbXNnc3RyICJ0aWxsw6RtcGEgZW4gcGF0Y2ggdXRhbiBhdHQgcsO2cmEgYXJiZXRza2F0YWxvZ2VuIgogCi0jOiBhcHBseS5jOjQ5NzEKKyM6IGFwcGx5LmM6NDk4MwogbXNnaWQgImFjY2VwdCBhIHBhdGNoIHRoYXQgdG91Y2hlcyBvdXRzaWRlIHRoZSB3b3JraW5nIGFyZWEiCiBtc2dzdHIgImdvZHRhIGVuIHBhdGNoIHNvbSByw7ZyIGZpbGVyIHV0YW5mw7ZyIGFyYmV0c2thdGFsb2dlbiIKIAotIzogYXBwbHkuYzo0OTc0CisjOiBhcHBseS5jOjQ5ODYKIG1zZ2lkICJhbHNvIGFwcGx5IHRoZSBwYXRjaCAodXNlIHdpdGggLS1zdGF0Ly0tc3VtbWFyeS8tLWNoZWNrKSIKIG1zZ3N0ciAidGlsbMOkbXBhIG9ja3PDpSBwYXRjaGVuIChhbnbDpG5kIG1lZCAtLXN0YXQvLS1zdW1tYXJ5Ly0tY2hlY2spIgogCi0jOiBhcHBseS5jOjQ5NzYKKyM6IGFwcGx5LmM6NDk4OAogbXNnaWQgImF0dGVtcHQgdGhyZWUtd2F5IG1lcmdlIGlmIGEgcGF0Y2ggZG9lcyBub3QgYXBwbHkiCiBtc2dzdHIgImbDtnJzw7ZrIGVuIHRyZXbDpGdzc2FtbWFuc2xhZ25pbmcgb20gcGF0Y2hlbiBpbnRlIGthbiB0aWxsw6RtcGFzIgogCi0jOiBhcHBseS5jOjQ5NzgKKyM6IGFwcGx5LmM6NDk5MAogbXNnaWQgImJ1aWxkIGEgdGVtcG9yYXJ5IGluZGV4IGJhc2VkIG9uIGVtYmVkZGVkIGluZGV4IGluZm9ybWF0aW9uIgogbXNnc3RyICJieWdnIGV0dCB0ZW1wb3LDpHJ0IGluZGV4IGJhc2VyYXQgcMOlIGluYnlnZ2QgaW5kZXhpbmZvcm1hdGlvbiIKIAotIzogYXBwbHkuYzo0OTgxIGJ1aWx0aW4vY2hlY2tvdXQtaW5kZXguYzoxNzMgYnVpbHRpbi9scy1maWxlcy5jOjUyNAorIzogYXBwbHkuYzo0OTkzIGJ1aWx0aW4vY2hlY2tvdXQtaW5kZXguYzoxNzMgYnVpbHRpbi9scy1maWxlcy5jOjUyNAogbXNnaWQgInBhdGhzIGFyZSBzZXBhcmF0ZWQgd2l0aCBOVUwgY2hhcmFjdGVyIgogbXNnc3RyICJzw7ZrdsOkZ2FyIGF2ZGVsYXMgbWVkIE5VTC10ZWNrZW4iCiAKLSM6IGFwcGx5LmM6NDk4MworIzogYXBwbHkuYzo0OTk1CiBtc2dpZCAiZW5zdXJlIGF0IGxlYXN0IDxuPiBsaW5lcyBvZiBjb250ZXh0IG1hdGNoIgogbXNnc3RyICJzZSB0aWxsIGF0dCDDpXRtaW5zdG9uZSA8bj4gcmFkZXIgc2FtbWFuaGFuZyDDpHIgbGlrYSIKIAotIzogYXBwbHkuYzo0OTg0IGJ1aWx0aW4vYW0uYzoyMTk2IGJ1aWx0aW4vaW50ZXJwcmV0LXRyYWlsZXJzLmM6OTgKKyM6IGFwcGx5LmM6NDk5NiBidWlsdGluL2FtLmM6MjE4NSBidWlsdGluL2ludGVycHJldC10cmFpbGVycy5jOjk4CiAjOiBidWlsdGluL2ludGVycHJldC10cmFpbGVycy5jOjEwMCBidWlsdGluL2ludGVycHJldC10cmFpbGVycy5jOjEwMgotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzE5IGJ1aWx0aW4vcmViYXNlLmM6MTQyMQorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzEwIGJ1aWx0aW4vcmViYXNlLmM6MTQ0NQogbXNnaWQgImFjdGlvbiIKIG1zZ3N0ciAiw6V0Z8OkcmQiCiAKLSM6IGFwcGx5LmM6NDk4NQorIzogYXBwbHkuYzo0OTk3CiBtc2dpZCAiZGV0ZWN0IG5ldyBvciBtb2RpZmllZCBsaW5lcyB0aGF0IGhhdmUgd2hpdGVzcGFjZSBlcnJvcnMiCiBtc2dzdHIgImRldGVrdGVyYSBueWEgZWxsZXIgw6RuZHJhZGUgcmFkZXIgc29tIGhhciBmZWwgaSBibGFua3RlY2tlbiIKIAotIzogYXBwbHkuYzo0OTg4IGFwcGx5LmM6NDk5MQorIzogYXBwbHkuYzo1MDAwIGFwcGx5LmM6NTAwMwogbXNnaWQgImlnbm9yZSBjaGFuZ2VzIGluIHdoaXRlc3BhY2Ugd2hlbiBmaW5kaW5nIGNvbnRleHQiCiBtc2dzdHIgImlnbm9yZXJhIMOkbmRyaW5nYXIgaSBibGFua3RlY2tlbiBmw7ZyIHNhbW1hbmhhbmciCiAKLSM6IGFwcGx5LmM6NDk5NAorIzogYXBwbHkuYzo1MDA2CiBtc2dpZCAiYXBwbHkgdGhlIHBhdGNoIGluIHJldmVyc2UiCiBtc2dzdHIgInRpbGzDpG1wYSBwYXRjaGVuIGJha2zDpG5nZXMiCiAKLSM6IGFwcGx5LmM6NDk5NgorIzogYXBwbHkuYzo1MDA4CiBtc2dpZCAiZG9uJ3QgZXhwZWN0IGF0IGxlYXN0IG9uZSBsaW5lIG9mIGNvbnRleHQiCiBtc2dzdHIgImbDtnJ2w6RudGEgaW50ZSBtaW5zdCBlbiByYWQgc2FtbWFuaGFuZyIKIAotIzogYXBwbHkuYzo0OTk4CisjOiBhcHBseS5jOjUwMTAKIG1zZ2lkICJsZWF2ZSB0aGUgcmVqZWN0ZWQgaHVua3MgaW4gY29ycmVzcG9uZGluZyAqLnJlaiBmaWxlcyIKIG1zZ3N0ciAibMOkbW5hIHJlZnVzZXJhZGUgc3R5Y2tlbiBpIG1vdHN2YXJhbmRlICoucmVqLWZpbGVyIgogCi0jOiBhcHBseS5jOjUwMDAKKyM6IGFwcGx5LmM6NTAxMgogbXNnaWQgImFsbG93IG92ZXJsYXBwaW5nIGh1bmtzIgogbXNnc3RyICJ0aWxsw6V0IMO2dmVybGFwcGFuZGUgc3R5Y2tlbiIKIAotIzogYXBwbHkuYzo1MDAxIGJ1aWx0aW4vYWRkLmM6MjkxIGJ1aWx0aW4vY2hlY2staWdub3JlLmM6MjIKKyM6IGFwcGx5LmM6NTAxMyBidWlsdGluL2FkZC5jOjI5MSBidWlsdGluL2NoZWNrLWlnbm9yZS5jOjIyCiAjOiBidWlsdGluL2NvbW1pdC5jOjEzMzcgYnVpbHRpbi9jb3VudC1vYmplY3RzLmM6OTggYnVpbHRpbi9mc2NrLmM6Nzg2CiAjOiBidWlsdGluL2xvZy5jOjIwODUgYnVpbHRpbi9tdi5jOjEyMyBidWlsdGluL3JlYWQtdHJlZS5jOjEyOAogbXNnaWQgImJlIHZlcmJvc2UiCiBtc2dzdHIgInZhciBwcmF0c2FtIgogCi0jOiBhcHBseS5jOjUwMDMKKyM6IGFwcGx5LmM6NTAxNQogbXNnaWQgInRvbGVyYXRlIGluY29ycmVjdGx5IGRldGVjdGVkIG1pc3NpbmcgbmV3LWxpbmUgYXQgdGhlIGVuZCBvZiBmaWxlIgogbXNnc3RyICJ0b2xlcmVyYSBmZWxha3RpZ3QgZGV0ZWt0ZXJhZGUgc2FrbmFkZSBueXJhZHN0ZWNrZW4gdmlkIGZpbHNsdXQiCiAKLSM6IGFwcGx5LmM6NTAwNgorIzogYXBwbHkuYzo1MDE4CiBtc2dpZCAiZG8gbm90IHRydXN0IHRoZSBsaW5lIGNvdW50cyBpbiB0aGUgaHVuayBoZWFkZXJzIgogbXNnc3RyICJsaXRlIGludGUgcMOlIGFudGFsZXQgbGluamVyIGkgc3R5Y2tlaHV2dWRlbiIKIAotIzogYXBwbHkuYzo1MDA4IGJ1aWx0aW4vYW0uYzoyMjA1CisjOiBhcHBseS5jOjUwMjAgYnVpbHRpbi9hbS5jOjIxOTQKIG1zZ2lkICJyb290IgogbXNnc3RyICJyb3QiCiAKLSM6IGFwcGx5LmM6NTAwOQorIzogYXBwbHkuYzo1MDIxCiBtc2dpZCAicHJlcGVuZCA8cm9vdD4gdG8gYWxsIGZpbGVuYW1lcyIKIG1zZ3N0ciAibMOkZ2cgdGlsbCA8cm90PiBpIGFsbGEgZmlsbmFtbiIKIApAQCAtODE4LDcgKzgxOCw3IEBACiBtc2dpZCAiYXJjaGl2ZSBmb3JtYXQiCiBtc2dzdHIgImFya2l2Zm9ybWF0IgogCi0jOiBhcmNoaXZlLmM6NDU4IGJ1aWx0aW4vbG9nLmM6MTU5NworIzogYXJjaGl2ZS5jOjQ1OCBidWlsdGluL2xvZy5jOjE1ODEKIG1zZ2lkICJwcmVmaXgiCiBtc2dzdHIgInByZWZpeCIKIApAQCAtODI2LDExICs4MjYsMTIgQEAKIG1zZ2lkICJwcmVwZW5kIHByZWZpeCB0byBlYWNoIHBhdGhuYW1lIGluIHRoZSBhcmNoaXZlIgogbXNnc3RyICJsw6RnZyB0aWxsIHByZWZpeCB0aWxsIHZhcmplIHPDtmt2w6RnIGkgYXJraXZldCIKIAotIzogYXJjaGl2ZS5jOjQ2MCBidWlsdGluL2JsYW1lLmM6ODYyIGJ1aWx0aW4vYmxhbWUuYzo4NzQgYnVpbHRpbi9ibGFtZS5jOjg3NQotIzogYnVpbHRpbi9jb21taXQtdHJlZS5jOjExNyBidWlsdGluL2NvbmZpZy5jOjEyOSBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTEzNAotIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExMzYgYnVpbHRpbi9ncmVwLmM6ODk3IGJ1aWx0aW4vaGFzaC1vYmplY3QuYzoxMDUKLSM6IGJ1aWx0aW4vbHMtZmlsZXMuYzo1NjAgYnVpbHRpbi9scy1maWxlcy5jOjU2MyBidWlsdGluL25vdGVzLmM6NDEyCi0jOiBidWlsdGluL25vdGVzLmM6NTc4IGJ1aWx0aW4vcmVhZC10cmVlLmM6MTIzIHBhcnNlLW9wdGlvbnMuaDoxNzcKKyM6IGFyY2hpdmUuYzo0NjAgYnVpbHRpbi9ibGFtZS5jOjg2MSBidWlsdGluL2JsYW1lLmM6ODczIGJ1aWx0aW4vYmxhbWUuYzo4NzQKKyM6IGJ1aWx0aW4vY29tbWl0LXRyZWUuYzoxMTcgYnVpbHRpbi9jb25maWcuYzoxMjkgYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNjIKKyM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTY0IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTY4IGJ1aWx0aW4vZ3JlcC5jOjg5OQorIzogYnVpbHRpbi9oYXNoLW9iamVjdC5jOjEwNSBidWlsdGluL2xzLWZpbGVzLmM6NTYwIGJ1aWx0aW4vbHMtZmlsZXMuYzo1NjMKKyM6IGJ1aWx0aW4vbm90ZXMuYzo0MTIgYnVpbHRpbi9ub3Rlcy5jOjU3OCBidWlsdGluL3JlYWQtdHJlZS5jOjEyMworIzogcGFyc2Utb3B0aW9ucy5oOjE4NgogbXNnaWQgImZpbGUiCiBtc2dzdHIgImZpbCIKIApAQCAtODYyLDcgKzg2Myw3IEBACiBtc2dpZCAibGlzdCBzdXBwb3J0ZWQgYXJjaGl2ZSBmb3JtYXRzIgogbXNnc3RyICJ2aXNhIHVuZGVyc3TDtmRkYSBhcmtpdmZvcm1hdCIKIAotIzogYXJjaGl2ZS5jOjQ3OSBidWlsdGluL2FyY2hpdmUuYzo5MSBidWlsdGluL2Nsb25lLmM6MTEzIGJ1aWx0aW4vY2xvbmUuYzoxMTYKKyM6IGFyY2hpdmUuYzo0NzkgYnVpbHRpbi9hcmNoaXZlLmM6OTEgYnVpbHRpbi9jbG9uZS5jOjExMiBidWlsdGluL2Nsb25lLmM6MTE1CiAjOiBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6MTM3OSBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6MTg1OQogbXNnaWQgInJlcG8iCiBtc2dzdHIgImFya2l2IgpAQCAtODcxLDcgKzg3Miw3IEBACiBtc2dpZCAicmV0cmlldmUgdGhlIGFyY2hpdmUgZnJvbSByZW1vdGUgcmVwb3NpdG9yeSA8cmVwbz4iCiBtc2dzdHIgImjDpG10YSBhcmtpdmV0IGZyw6VuIGZqw6RycmFya2l2ZXQgPGFya2l2PiIKIAotIzogYXJjaGl2ZS5jOjQ4MSBidWlsdGluL2FyY2hpdmUuYzo5MyBidWlsdGluL2RpZmZ0b29sLmM6NzA3CisjOiBhcmNoaXZlLmM6NDgxIGJ1aWx0aW4vYXJjaGl2ZS5jOjkzIGJ1aWx0aW4vZGlmZnRvb2wuYzo3MTUKICM6IGJ1aWx0aW4vbm90ZXMuYzo0OTgKIG1zZ2lkICJjb21tYW5kIgogbXNnc3RyICJrb21tYW5kbyIKQEAgLTkwNywyNiArOTA4LDI2IEBACiBtc2dpZCAiY2Fubm90IHN0cmVhbSBibG9iICVzIgogbXNnc3RyICJrYW4gaW50ZSBzdHLDtm1tYSBibG9iOmVuICVzIgogCi0jOiBhcmNoaXZlLXRhci5jOjI2MCBhcmNoaXZlLXppcC5jOjM2MworIzogYXJjaGl2ZS10YXIuYzoyNjYgYXJjaGl2ZS16aXAuYzozNjMKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5zdXBwb3J0ZWQgZmlsZSBtb2RlOiAwJW8gKFNIQTE6ICVzKSIKIG1zZ3N0ciAiZmlsZW5zIGzDpGdlIHN0w7ZkcyBlajogMCVvIChTSEExOiAlcykiCiAKLSM6IGFyY2hpdmUtdGFyLmM6Mjg3IGFyY2hpdmUtemlwLmM6MzUzCisjOiBhcmNoaXZlLXRhci5jOjI5MyBhcmNoaXZlLXppcC5jOjM1MwogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgcmVhZCAlcyIKIG1zZ3N0ciAia2FuIGludGUgbMOkc2EgJXMiCiAKLSM6IGFyY2hpdmUtdGFyLmM6NDU5CisjOiBhcmNoaXZlLXRhci5jOjQ2NQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gc3RhcnQgJyVzJyBmaWx0ZXIiCiBtc2dzdHIgImt1bmRlIGludGUgc3RhcnRhIGZpbHRyZXQgXCIlc1wiIgogCi0jOiBhcmNoaXZlLXRhci5jOjQ2MgorIzogYXJjaGl2ZS10YXIuYzo0NjgKIG1zZ2lkICJ1bmFibGUgdG8gcmVkaXJlY3QgZGVzY3JpcHRvciIKIG1zZ3N0ciAia2FuIGludGUgb21kaXJpZ2VyYSBoYW5kdGFnIgogCi0jOiBhcmNoaXZlLXRhci5jOjQ2OQorIzogYXJjaGl2ZS10YXIuYzo0NzUKICMsIGMtZm9ybWF0CiBtc2dpZCAiJyVzJyBmaWx0ZXIgcmVwb3J0ZWQgZXJyb3IiCiBtc2dzdHIgImZpbHRyZXQgXCIlc1wiIHJhcHBvcnRlcmFkZSBmZWwiCkBAIC05NDEsNyArOTQyLDcgQEAKIG1zZ2lkICJwYXRoIHRvbyBsb25nICglZCBjaGFycywgU0hBMTogJXMpOiAlcyIKIG1zZ3N0ciAic8O2a3bDpGdlbiBmw7ZyIGzDpW5nICglZCB0ZWNrZW4sIFNIQTE6ICVzKTogJXMiCiAKLSM6IGFyY2hpdmUtemlwLmM6NDc0IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjI2IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjI5CisjOiBhcmNoaXZlLXppcC5jOjQ3NCBidWlsdGluL3BhY2stb2JqZWN0cy5jOjIzMCBidWlsdGluL3BhY2stb2JqZWN0cy5jOjIzMwogIywgYy1mb3JtYXQKIG1zZ2lkICJkZWZsYXRlIGVycm9yICglZCkiCiBtc2dzdHIgImZlbCBpIGRlZmxhdGUgKCVkKSIKQEAgLTk1MSwxNyArOTUyLDE3IEBACiBtc2dpZCAidGltZXN0YW1wIHRvbyBsYXJnZSBmb3IgdGhpcyBzeXN0ZW06ICU8UFJJdU1BWD4iCiBtc2dzdHIgInRpZHNzdMOkbXBlbG4gZsO2ciBzdG9yIGbDtnIgZGV0dGEgc3lzdGVtOiAlPFBSSXVNQVg+IgogCi0jOiBhdHRyLmM6MjExCisjOiBhdHRyLmM6MjEzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiUuKnMgaXMgbm90IGEgdmFsaWQgYXR0cmlidXRlIG5hbWUiCiBtc2dzdHIgIiUtKnMgw6RyIGludGUgZXR0IGdpbHRpZ3QgbmFtbiBww6UgYXR0cmlidXQiCiAKLSM6IGF0dHIuYzozNjgKKyM6IGF0dHIuYzozNzAKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgbm90IGFsbG93ZWQ6ICVzOiVkIgogbXNnc3RyICIlcyBpbnRlIHRpbGzDpXRldDogJXM6JWQiCiAKLSM6IGF0dHIuYzo0MDgKKyM6IGF0dHIuYzo0MTAKIG1zZ2lkICIiCiAiTmVnYXRpdmUgcGF0dGVybnMgYXJlIGlnbm9yZWQgaW4gZ2l0IGF0dHJpYnV0ZXNcbiIKICJVc2UgJ1xcIScgZm9yIGxpdGVyYWwgbGVhZGluZyBleGNsYW1hdGlvbi4iCkBAIC0xMDg5LDQxICsxMDkwLDQxIEBACiBtc2dzdHJbMF0gIkJpc2VjdDogJWQgcmV2aXNpb24ga3ZhciBhdHQgdGVzdGEgZWZ0ZXIgZGVubmEgJXNcbiIKIG1zZ3N0clsxXSAiQmlzZWN0OiAlZCByZXZpc2lvbmVyIGt2YXIgYXR0IHRlc3RhIGVmdGVyIGRlbm5hICVzXG4iCiAKLSM6IGJsYW1lLmM6MjY5NworIzogYmxhbWUuYzoyNzAwCiBtc2dpZCAiLS1jb250ZW50cyBhbmQgLS1yZXZlcnNlIGRvIG5vdCBibGVuZCB3ZWxsLiIKIG1zZ3N0ciAiLS1jb250ZW50cyBvY2ggLS1yZXZlcnNlIGZ1bmdlcmFyIGludGUgc8OlIGJyYSB0aWxsc2FtbWFucy4iCiAKLSM6IGJsYW1lLmM6MjcxMQorIzogYmxhbWUuYzoyNzE0CiBtc2dpZCAiY2Fubm90IHVzZSAtLWNvbnRlbnRzIHdpdGggZmluYWwgY29tbWl0IG9iamVjdCBuYW1lIgogbXNnc3RyICJrYW4gaW50ZSBhbnbDpG5kYSAtLWNvbnRlbnRzIG1lZCBuYW1uIHDDpSBzbHV0Z2lsdGlndCBpbmNoZWNrbmluZ3NvYmpla3QiCiAKLSM6IGJsYW1lLmM6MjczMgorIzogYmxhbWUuYzoyNzM1CiBtc2dpZCAiLS1yZXZlcnNlIGFuZCAtLWZpcnN0LXBhcmVudCB0b2dldGhlciByZXF1aXJlIHNwZWNpZmllZCBsYXRlc3QgY29tbWl0IgogbXNnc3RyICIiCiAiLS1yZXZlcnNlIG9jaCAtLWZpcnN0LXBhcmVudCB0aWxsc2FtbWFucyBrcsOkdmVyIGF0dCBkdSBhbmdlciBzZW5hc3RlICIKICJpbmNoZWNrbmluZ2VuIgogCi0jOiBibGFtZS5jOjI3NDEgYnVuZGxlLmM6MTY3IHJlZi1maWx0ZXIuYzoyMTk2IHJlbW90ZS5jOjE5Mzggc2VxdWVuY2VyLmM6MjAzMwotIzogc2VxdWVuY2VyLmM6NDM0OCBidWlsdGluL2NvbW1pdC5jOjEwMjAgYnVpbHRpbi9sb2cuYzo0MDQgYnVpbHRpbi9sb2cuYzo5ODAKLSM6IGJ1aWx0aW4vbG9nLmM6MTQ2OCBidWlsdGluL2xvZy5jOjE4NDQgYnVpbHRpbi9sb2cuYzoyMTM0IGJ1aWx0aW4vbWVyZ2UuYzo0MTEKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzE0MiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMxNTcKKyM6IGJsYW1lLmM6Mjc0NCBidW5kbGUuYzoxNjcgcmVmLWZpbHRlci5jOjIyMDMgcmVtb3RlLmM6MTk0MSBzZXF1ZW5jZXIuYzoxOTcxCisjOiBzZXF1ZW5jZXIuYzo0MzA1IGJ1aWx0aW4vY29tbWl0LmM6MTAyMCBidWlsdGluL2xvZy5jOjM4NyBidWlsdGluL2xvZy5jOjk2NAorIzogYnVpbHRpbi9sb2cuYzoxNDUyIGJ1aWx0aW4vbG9nLmM6MTg0NCBidWlsdGluL2xvZy5jOjIxMzQgYnVpbHRpbi9tZXJnZS5jOjQxMQorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMTI4IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzE0MwogIzogYnVpbHRpbi9zaG9ydGxvZy5jOjE5MgogbXNnaWQgInJldmlzaW9uIHdhbGsgc2V0dXAgZmFpbGVkIgogbXNnc3RyICJtaXNzbHlja2FkZXMgc2thcGEgcmV2aXNpb25zdHJhdmVyc2VyaW5nIgogCi0jOiBibGFtZS5jOjI3NTkKKyM6IGJsYW1lLmM6Mjc2MgogbXNnaWQgIiIKICItLXJldmVyc2UgLS1maXJzdC1wYXJlbnQgdG9nZXRoZXIgcmVxdWlyZSByYW5nZSBhbG9uZyBmaXJzdC1wYXJlbnQgY2hhaW4iCiBtc2dzdHIgIiIKICItLXJldmVyc2UgLS1maXJzdC1wYXJlbnQgdGlsbHNhbW1hbnMga3LDpHZlciBldHQgaW50ZXJ2YWxsIHDDpSBmw7Zyc3RhLWbDtnLDpGxkZXItIgogImtlZGphbiIKIAotIzogYmxhbWUuYzoyNzcwCisjOiBibGFtZS5jOjI3NzMKICMsIGMtZm9ybWF0CiBtc2dpZCAibm8gc3VjaCBwYXRoICVzIGluICVzIgogbXNnc3RyICJzw7ZrdsOkZ2VuICVzIGkgJXMgZmlubnMgaW50ZSIKIAotIzogYmxhbWUuYzoyNzgxCisjOiBibGFtZS5jOjI3ODQKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IHJlYWQgYmxvYiAlcyBmb3IgcGF0aCAlcyIKIG1zZ3N0ciAia2FuIGludGUgbMOkc2Egb2JqZWt0ZXQgJXMgZsO2ciBzw7ZrdsOkZ2VuICVzIgpAQCAtMTI4MSw3ICsxMjgyLDcgQEAKIG1zZ2lkICJ1bnJlY29nbml6ZWQgaGVhZGVyOiAlcyVzICglZCkiCiBtc2dzdHIgIm9rw6RudCBodXZ1ZDogJXMlcyAoJWQpIgogCi0jOiBidW5kbGUuYzo5MCByZXJlcmUuYzo0ODAgcmVyZXJlLmM6NjkwIHNlcXVlbmNlci5jOjIyODMgc2VxdWVuY2VyLmM6MzAyNAorIzogYnVuZGxlLmM6OTAgcmVyZXJlLmM6NDgwIHJlcmVyZS5jOjY5MCBzZXF1ZW5jZXIuYzoyMjIxIHNlcXVlbmNlci5jOjI5NjIKICM6IGJ1aWx0aW4vY29tbWl0LmM6NzkxCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBvcGVuICclcyciCkBAIC0xMzM0LDcgKzEzMzUsNyBAQAogbXNnaWQgInJlZiAnJXMnIGlzIGV4Y2x1ZGVkIGJ5IHRoZSByZXYtbGlzdCBvcHRpb25zIgogbXNnc3RyICJyZWZlcmVuc2VuIFwiJXNcIiBleGtsdWRlcmFzIGF2IGFyZ3VtZW50ZW4gdGlsbCByZXYtbGlzdCIKIAotIzogYnVuZGxlLmM6NDYwIGJ1aWx0aW4vbG9nLmM6MjEyIGJ1aWx0aW4vbG9nLmM6MTc0OSBidWlsdGluL3Nob3J0bG9nLmM6MzA2CisjOiBidW5kbGUuYzo0NjAgYnVpbHRpbi9sb2cuYzoyMDIgYnVpbHRpbi9sb2cuYzoxNzMzIGJ1aWx0aW4vc2hvcnRsb2cuYzozMDYKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5yZWNvZ25pemVkIGFyZ3VtZW50OiAlcyIKIG1zZ3N0ciAib2vDpG50IGFyZ3VtZW50OiAlcyIKQEAgLTEzNTcsOCArMTM1OCw4IEBACiBtc2dpZCAiaW52YWxpZCBjb2xvciB2YWx1ZTogJS4qcyIKIG1zZ3N0ciAiZmVsYWt0aWd0IGbDpHJndsOkcmRlOiAlLipzIgogCi0jOiBjb21taXQuYzo1MCBzZXF1ZW5jZXIuYzoyNzI3IGJ1aWx0aW4vYW0uYzozNTUgYnVpbHRpbi9hbS5jOjM5OQotIzogYnVpbHRpbi9hbS5jOjEzNzggYnVpbHRpbi9hbS5jOjIwMjAgYnVpbHRpbi9yZXBsYWNlLmM6NDU1CisjOiBjb21taXQuYzo1MCBzZXF1ZW5jZXIuYzoyNjY1IGJ1aWx0aW4vYW0uYzozNTQgYnVpbHRpbi9hbS5jOjM5OAorIzogYnVpbHRpbi9hbS5jOjEzNjYgYnVpbHRpbi9hbS5jOjIwMDkgYnVpbHRpbi9yZXBsYWNlLmM6NDU2CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBwYXJzZSAlcyIKIG1zZ3N0ciAia3VuZGUgaW50ZSB0b2xrYSAlcyIKQEAgLTEzODgsMjkgKzEzODksMjkgQEAKICJTbMOlIGF2IGRldHRhIG1lZGRlbGFuZGUgZ2Vub20gYXR0IHNrcml2YVxuIgogIlwiZ2l0IGNvbmZpZyBhZHZpY2UuZ3JhZnRGaWxlRGVwcmVjYXRlZCBmYWxzZVwiIgogCi0jOiBjb21taXQuYzoxMTI3CisjOiBjb21taXQuYzoxMTI4CiAjLCBjLWZvcm1hdAogbXNnaWQgIkNvbW1pdCAlcyBoYXMgYW4gdW50cnVzdGVkIEdQRyBzaWduYXR1cmUsIGFsbGVnZWRseSBieSAlcy4iCiBtc2dzdHIgIiIKICJJbmNoZWNrbmluZ2VuICVzIGhhciBlbiBvYmV0cm9kZCBHUEctc2lnbmF0dXIgc29tIHDDpXN0w6VzIHZhcmEgZ2pvcmQgYXYgJXMuIgogCi0jOiBjb21taXQuYzoxMTMwCisjOiBjb21taXQuYzoxMTMxCiAjLCBjLWZvcm1hdAogbXNnaWQgIkNvbW1pdCAlcyBoYXMgYSBiYWQgR1BHIHNpZ25hdHVyZSBhbGxlZ2VkbHkgYnkgJXMuIgogbXNnc3RyICIiCiAiSW5jaGVja25pbmdlbiAlcyBoYXIgZW4gZmVsYWt0aWcgR1BHLXNpZ25hdHVyIHNvbSBww6VzdMOlcyB2YXJhIGdqb3JkIGF2ICVzLiIKIAotIzogY29tbWl0LmM6MTEzMworIzogY29tbWl0LmM6MTEzNAogIywgYy1mb3JtYXQKIG1zZ2lkICJDb21taXQgJXMgZG9lcyBub3QgaGF2ZSBhIEdQRyBzaWduYXR1cmUuIgogbXNnc3RyICJJbmNoZWNrbmluZyAlcyBoYXIgaW50ZSBuw6Vnb24gR1BHLXNpZ25hdHVyLiIKIAotIzogY29tbWl0LmM6MTEzNgorIzogY29tbWl0LmM6MTEzNwogIywgYy1mb3JtYXQKIG1zZ2lkICJDb21taXQgJXMgaGFzIGEgZ29vZCBHUEcgc2lnbmF0dXJlIGJ5ICVzXG4iCiBtc2dzdHIgIkluY2hlY2tuaW5nZW4gJXMgaGFyIGVuIGtvcnJla3QgR1BHLXNpZ25hdHVyIGF2ICVzXG4iCiAKLSM6IGNvbW1pdC5jOjEzOTAKKyM6IGNvbW1pdC5jOjEzOTEKIG1zZ2lkICIiCiAiV2FybmluZzogY29tbWl0IG1lc3NhZ2UgZGlkIG5vdCBjb25mb3JtIHRvIFVURi04LlxuIgogIllvdSBtYXkgd2FudCB0byBhbWVuZCBpdCBhZnRlciBmaXhpbmcgdGhlIG1lc3NhZ2UsIG9yIHNldCB0aGUgY29uZmlnXG4iCkBAIC0xNDcyLDE4MCArMTQ3MywxOTUgQEAKIG1zZ2lkICJ1bmFibGUgdG8gZmluZCBhbGwgY29tbWl0LWdyYXBoIGZpbGVzIgogbXNnc3RyICJrYW4gaW50ZSBoaXR0YSBhbGxhIGluY2hlY2tpbmdzZ3JhZmZpbGVyIgogCi0jOiBjb21taXQtZ3JhcGguYzo1NTMgY29tbWl0LWdyYXBoLmM6NjEzCisjOiBjb21taXQtZ3JhcGguYzo1NjEgY29tbWl0LWdyYXBoLmM6NjIxCiBtc2dpZCAiaW52YWxpZCBjb21taXQgcG9zaXRpb24uIGNvbW1pdC1ncmFwaCBpcyBsaWtlbHkgY29ycnVwdCIKIG1zZ3N0ciAib2dpbHRpZyBpbmNoZWNrbmluZ3Nwb3NpdGlvbi4gaW5jaGVja25pbmdzZ3JhZmVuIMOkciB0cm9saWd0dmlzIHRyYXNpZyIKIAotIzogY29tbWl0LWdyYXBoLmM6NTc0CisjOiBjb21taXQtZ3JhcGguYzo1ODIKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGZpbmQgY29tbWl0ICVzIgogbXNnc3RyICJrdW5kZSBpbnRlIGhpdHRhIGluY2hlY2tuaW5nZW4gJXMiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjEwMDEgYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNjUxCisjOiBjb21taXQtZ3JhcGguYzo4NTUgYnVpbHRpbi9hbS5jOjEyODcKKyMsIGMtZm9ybWF0Cittc2dpZCAidW5hYmxlIHRvIHBhcnNlIGNvbW1pdCAlcyIKK21zZ3N0ciAia3VuZGUgaW50ZSB0b2xrYSBpbmNoZWNrbmluZ2VuICVzIgorCisjOiBjb21taXQtZ3JhcGguYzo4NTkKKyMsIGMtZm9ybWF0Cittc2dpZCAidW5hYmxlIHRvIGdldCB0cmVlIGZvciAlcyIKK21zZ3N0ciAia3VuZGUgaW50ZSBow6RtdGEgdHLDpGRldCBww6UgJXMiCisKKyM6IGNvbW1pdC1ncmFwaC5jOjEwMTcgYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNjQxCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBnZXQgdHlwZSBvZiBvYmplY3QgJXMiCiBtc2dzdHIgImt1bmRlIGludGUgaMOkbXRhIHR5cCBmw7ZyIG9iamVrdGV0ICVzIgogCi0jOiBjb21taXQtZ3JhcGguYzoxMDMzCisjOiBjb21taXQtZ3JhcGguYzoxMDQ5CiBtc2dpZCAiTG9hZGluZyBrbm93biBjb21taXRzIGluIGNvbW1pdCBncmFwaCIKIG1zZ3N0ciAiTMOkc2VyIGluIGvDpG5kYSBpbmNoZWNrbmluZ2FyIGkgaW5jaGVja25pbmdzZ3JhZiIKIAotIzogY29tbWl0LWdyYXBoLmM6MTA1MAorIzogY29tbWl0LWdyYXBoLmM6MTA2NgogbXNnaWQgIkV4cGFuZGluZyByZWFjaGFibGUgY29tbWl0cyBpbiBjb21taXQgZ3JhcGgiCiBtc2dzdHIgIkV4cGFuZGVyYXIgbsOlYmFyYSBpbmNoZWNrbmluZ2FyIGkgaW5jaGVja25pbmdzZ3JhZiIKIAotIzogY29tbWl0LWdyYXBoLmM6MTA2OQorIzogY29tbWl0LWdyYXBoLmM6MTA4NQogbXNnaWQgIkNsZWFyaW5nIGNvbW1pdCBtYXJrcyBpbiBjb21taXQgZ3JhcGgiCiBtc2dzdHIgIlJlbnNhciBpbmNoZWNrbmluZ3Ntw6Rya2VuIGkgaW5jaGVja25pbmdzZ3JhZiIKIAotIzogY29tbWl0LWdyYXBoLmM6MTA4OAorIzogY29tbWl0LWdyYXBoLmM6MTEwNAogbXNnaWQgIkNvbXB1dGluZyBjb21taXQgZ3JhcGggZ2VuZXJhdGlvbiBudW1iZXJzIgogbXNnc3RyICJCZXLDpGtuYXIgZ2VuZXJhdGlvbnN2w6RyZGVuIGbDtnIgaW5jaGVja25pbmdzZ3JhZiIKIAotIzogY29tbWl0LWdyYXBoLmM6MTE2MgorIzogY29tbWl0LWdyYXBoLmM6MTE3OQogIywgYy1mb3JtYXQKIG1zZ2lkICJGaW5kaW5nIGNvbW1pdHMgZm9yIGNvbW1pdCBncmFwaCBpbiAlZCBwYWNrIgogbXNnaWRfcGx1cmFsICJGaW5kaW5nIGNvbW1pdHMgZm9yIGNvbW1pdCBncmFwaCBpbiAlZCBwYWNrcyIKIG1zZ3N0clswXSAiU8O2a2VyIGluY2hlY2tuaW5nYXIgZsO2ciBpbmNoZWNraW5nc2dyYWYgaSAlZCBwYWtldCIKIG1zZ3N0clsxXSAiU8O2a2VyIGluY2hlY2tuaW5nYXIgZsO2ciBpbmNoZWNraW5nc2dyYWYgaSAlZCBwYWtldCIKIAotIzogY29tbWl0LWdyYXBoLmM6MTE3NQorIzogY29tbWl0LWdyYXBoLmM6MTE5MgogIywgYy1mb3JtYXQKIG1zZ2lkICJlcnJvciBhZGRpbmcgcGFjayAlcyIKIG1zZ3N0ciAiZmVsIHZpZCB0aWxsw6RnZyBhdiBwYWtldGV0ICVzIgogCi0jOiBjb21taXQtZ3JhcGguYzoxMTc5CisjOiBjb21taXQtZ3JhcGguYzoxMTk2CiAjLCBjLWZvcm1hdAogbXNnaWQgImVycm9yIG9wZW5pbmcgaW5kZXggZm9yICVzIgogbXNnc3RyICJmZWwgdmlkIMO2cHBuaW5nIGF2IGluZGV4ZXQgZsO2ciAlcyIKIAotIzogY29tbWl0LWdyYXBoLmM6MTIwMworIzogY29tbWl0LWdyYXBoLmM6MTIyMAogIywgYy1mb3JtYXQKIG1zZ2lkICJGaW5kaW5nIGNvbW1pdHMgZm9yIGNvbW1pdCBncmFwaCBmcm9tICVkIHJlZiIKIG1zZ2lkX3BsdXJhbCAiRmluZGluZyBjb21taXRzIGZvciBjb21taXQgZ3JhcGggZnJvbSAlZCByZWZzIgogbXNnc3RyWzBdICJTw7ZrZXIgaW5jaGVja25pbmdhciBmw7ZyIGluY2hlY2tpbmdzZ3JhZiBmcsOlbiAlZCByZWZlcmVucyIKIG1zZ3N0clsxXSAiU8O2a2VyIGluY2hlY2tuaW5nYXIgZsO2ciBpbmNoZWNraW5nc2dyYWYgZnLDpW4gJWQgcmVmZXJlbnNlciIKIAotIzogY29tbWl0LWdyYXBoLmM6MTIzNworIzogY29tbWl0LWdyYXBoLmM6MTI0MAorIywgYy1mb3JtYXQKK21zZ2lkICJpbnZhbGlkIGNvbW1pdCBvYmplY3QgaWQ6ICVzIgorbXNnc3RyICJvZ2lsdGlndCBpbmNoZWNrbmluZ3Mtb2JqZWt0LWlkICVzIgorCisjOiBjb21taXQtZ3JhcGguYzoxMjU1CiBtc2dpZCAiRmluZGluZyBjb21taXRzIGZvciBjb21taXQgZ3JhcGggYW1vbmcgcGFja2VkIG9iamVjdHMiCiBtc2dzdHIgIlPDtmtlciBpbmNoZWNrbmluZ2FyIGbDtnIgaW5jaGVja2luZ3NncmFmIGkgcGFja2FkZSBvYmpla3QiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjEyNTIKKyM6IGNvbW1pdC1ncmFwaC5jOjEyNzAKIG1zZ2lkICJDb3VudGluZyBkaXN0aW5jdCBjb21taXRzIGluIGNvbW1pdCBncmFwaCIKIG1zZ3N0ciAiUsOka25hciBvbGlrYSBpbmNoZWNrbmluZ2FyIGkgaW5jaGVja25pbmdzZ3JhZiIKIAotIzogY29tbWl0LWdyYXBoLmM6MTI4MworIzogY29tbWl0LWdyYXBoLmM6MTMwMAogbXNnaWQgIkZpbmRpbmcgZXh0cmEgZWRnZXMgaW4gY29tbWl0IGdyYXBoIgogbXNnc3RyICJTw7ZrZXIgeXR0ZXJsaWdhcmUga2FudGVyIGkgaW5jaGVja2luZ3NncmFmIgogCi0jOiBjb21taXQtZ3JhcGguYzoxMzMxCisjOiBjb21taXQtZ3JhcGguYzoxMzQ2CiBtc2dpZCAiZmFpbGVkIHRvIHdyaXRlIGNvcnJlY3QgbnVtYmVyIG9mIGJhc2UgZ3JhcGggaWRzIgogbXNnc3RyICJrdW5kZSBpbnRlIHNrcml2YSBrb3JyZWt0IGFudGFsIGJhcy1ncmFmLWlkOm4iCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjEzNjQgbWlkeC5jOjgxMQorIzogY29tbWl0LWdyYXBoLmM6MTM3OSBtaWR4LmM6ODEwCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBjcmVhdGUgbGVhZGluZyBkaXJlY3RvcmllcyBvZiAlcyIKIG1zZ3N0ciAia3VuZGUgaW50ZSBza2FwYSBpbmxlZGFuZGUga2F0YWxvZ2VyIGbDtnIgJXMiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjEzNzYgYnVpbHRpbi9pbmRleC1wYWNrLmM6MzA2IGJ1aWx0aW4vcmVwYWNrLmM6MjUxCisjOiBjb21taXQtZ3JhcGguYzoxMzkxIGJ1aWx0aW4vaW5kZXgtcGFjay5jOjMwNiBidWlsdGluL3JlcGFjay5jOjI0MQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gY3JlYXRlICclcyciCiBtc2dzdHIgImt1bmRlIGludGUgc2thcGEgXCIlc1wiIgogCi0jOiBjb21taXQtZ3JhcGguYzoxNDM2CisjOiBjb21taXQtZ3JhcGguYzoxNDUxCiAjLCBjLWZvcm1hdAogbXNnaWQgIldyaXRpbmcgb3V0IGNvbW1pdCBncmFwaCBpbiAlZCBwYXNzIgogbXNnaWRfcGx1cmFsICJXcml0aW5nIG91dCBjb21taXQgZ3JhcGggaW4gJWQgcGFzc2VzIgogbXNnc3RyWzBdICJTa3JpdmVyIHV0IGluY2hlY2tuaW5nc2dyYWYgaSAlZCBwYXNzIgogbXNnc3RyWzFdICJTa3JpdmVyIHV0IGluY2hlY2tuaW5nc2dyYWYgaSAlZCBwYXNzIgogCi0jOiBjb21taXQtZ3JhcGguYzoxNDc3CisjOiBjb21taXQtZ3JhcGguYzoxNDkyCiBtc2dpZCAidW5hYmxlIHRvIG9wZW4gY29tbWl0LWdyYXBoIGNoYWluIGZpbGUiCiBtc2dzdHIgIkt1bmRlIGludGUgw7ZwcG5hIGluY2hlY2tuaW5nc2dyYWZrZWRqZWZpbGVuIgogCi0jOiBjb21taXQtZ3JhcGguYzoxNDg5CisjOiBjb21taXQtZ3JhcGguYzoxNTA0CiBtc2dpZCAiZmFpbGVkIHRvIHJlbmFtZSBiYXNlIGNvbW1pdC1ncmFwaCBmaWxlIgogbXNnc3RyICJrdW5kZSBpbnRlIGJ5dGEgbmFtbiBww6UgYmFzLWluY2hlY2tpbmdzZ3JhZmZpbGVuIgogCi0jOiBjb21taXQtZ3JhcGguYzoxNTA5CisjOiBjb21taXQtZ3JhcGguYzoxNTI0CiBtc2dpZCAiZmFpbGVkIHRvIHJlbmFtZSB0ZW1wb3JhcnkgY29tbWl0LWdyYXBoIGZpbGUiCiBtc2dzdHIgImt1bmRlIGludGUgYnl0YSBuYW1uIHDDpSB0ZW1wb3LDpHIgaW5jaGVja25pbmdzZ3JhZmZpbCIKIAotIzogY29tbWl0LWdyYXBoLmM6MTYyMAorIzogY29tbWl0LWdyYXBoLmM6MTYzNQogbXNnaWQgIlNjYW5uaW5nIG1lcmdlZCBjb21taXRzIgogbXNnc3RyICJTw7ZrZXIgc2FtbWFuc2xhZ25hIGluY2hlY2tuaW5nYXIiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjE2MzEKKyM6IGNvbW1pdC1ncmFwaC5jOjE2NDYKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5leHBlY3RlZCBkdXBsaWNhdGUgY29tbWl0IGlkICVzIgogbXNnc3RyICJvdsOkbnRhdCBkdXBsaWNlcmF0IGluY2hlY2tuaW5ncy1pZCAlcyIKIAotIzogY29tbWl0LWdyYXBoLmM6MTY1NgorIzogY29tbWl0LWdyYXBoLmM6MTY3MAogbXNnaWQgIk1lcmdpbmcgY29tbWl0LWdyYXBoIgogbXNnc3RyICJTbMOlciBpaG9wIGluY2hlY2tuaW5nc2dyYWYiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjE4NDIKKyM6IGNvbW1pdC1ncmFwaC5jOjE4NjAKICMsIGMtZm9ybWF0CiBtc2dpZCAidGhlIGNvbW1pdCBncmFwaCBmb3JtYXQgY2Fubm90IHdyaXRlICVkIGNvbW1pdHMiCiBtc2dzdHIgImZvcm1hdGV0IHDDpSBpbmNoZWNrbmluZ3NncmFmZW4ga2FuIGludGUgdmlzYSAlZCBpbmNoZWNrbmluZ2FyIgogCi0jOiBjb21taXQtZ3JhcGguYzoxODUzCisjOiBjb21taXQtZ3JhcGguYzoxODcxCiBtc2dpZCAidG9vIG1hbnkgY29tbWl0cyB0byB3cml0ZSBncmFwaCIKIG1zZ3N0ciAiZsO2ciBtw6VuZ2EgaW5jaGVja25pbmdhciBmw7ZyIGF0dCBza3JpdmEgZ3JhZiIKIAotIzogY29tbWl0LWdyYXBoLmM6MTk0MworIzogY29tbWl0LWdyYXBoLmM6MTk2MQogbXNnaWQgInRoZSBjb21taXQtZ3JhcGggZmlsZSBoYXMgaW5jb3JyZWN0IGNoZWNrc3VtIGFuZCBpcyBsaWtlbHkgY29ycnVwdCIKIG1zZ3N0ciAiIgogImZpbGVuIG1lZCBpbmNoZWNrbmluZ3NncmFmIGhhciBmZWxha3RpZyBjaGVja3N1bW1hIG9jaCDDpHIgdHJvbGlndHZpcyB0cmFzaWciCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjE5NTMKKyM6IGNvbW1pdC1ncmFwaC5jOjE5NzEKICMsIGMtZm9ybWF0CiBtc2dpZCAiY29tbWl0LWdyYXBoIGhhcyBpbmNvcnJlY3QgT0lEIG9yZGVyOiAlcyB0aGVuICVzIgogbXNnc3RyICJpbmNoZWNrbmluZ3NncmFmZW4gaGFyIGZlbGFrdGlnIE9JRC1vcmRuaW5nOiAlcyBzw6UgJXMiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjE5NjMgY29tbWl0LWdyYXBoLmM6MTk3OAorIzogY29tbWl0LWdyYXBoLmM6MTk4MSBjb21taXQtZ3JhcGguYzoxOTk2CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvbW1pdC1ncmFwaCBoYXMgaW5jb3JyZWN0IGZhbm91dCB2YWx1ZTogZmFub3V0WyVkXSA9ICV1ICE9ICV1IgogbXNnc3RyICIiCiAiaW5jaGVja25pbmdzZ3JhZmVuIGhhciBmZWxha3RpZyB1dGJyZWRuaW5nc3bDpHJkZTogZmFub3V0WyVkXSA9ICV1ICE9ICV1IgogCi0jOiBjb21taXQtZ3JhcGguYzoxOTcwCisjOiBjb21taXQtZ3JhcGguYzoxOTg4CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBwYXJzZSBjb21taXQgJXMgZnJvbSBjb21taXQtZ3JhcGgiCiBtc2dzdHIgImt1bmRlIGludGUgdG9sa2EgaW5jaGVja25pbmcgJXMgZnLDpW4gaW5jaGVja25pbmdzZ3JhZiIKIAotIzogY29tbWl0LWdyYXBoLmM6MTk4NworIzogY29tbWl0LWdyYXBoLmM6MjAwNgogbXNnaWQgIlZlcmlmeWluZyBjb21taXRzIGluIGNvbW1pdCBncmFwaCIKIG1zZ3N0ciAiQmVrcsOkZnRhciBpbmNoZWNrbmluZ2FyIGkgaW5jaGVja25pbmdzZ3JhZmVuIgogCi0jOiBjb21taXQtZ3JhcGguYzoyMDAwCisjOiBjb21taXQtZ3JhcGguYzoyMDIwCiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBwYXJzZSBjb21taXQgJXMgZnJvbSBvYmplY3QgZGF0YWJhc2UgZm9yIGNvbW1pdC1ncmFwaCIKIG1zZ3N0ciAiIgogIm1pc3NseWNrYWRlcyB0b2xrYSBpbmNoZWNrbmluZyAlcyBmcsOlbiBvYmpla3RkYXRhYmFzZW4gZsO2ciBpbmNoZWNrbmluZ3NncmFmIgogCi0jOiBjb21taXQtZ3JhcGguYzoyMDA3CisjOiBjb21taXQtZ3JhcGguYzoyMDI3CiAjLCBjLWZvcm1hdAogbXNnaWQgInJvb3QgdHJlZSBPSUQgZm9yIGNvbW1pdCAlcyBpbiBjb21taXQtZ3JhcGggaXMgJXMgIT0gJXMiCiBtc2dzdHIgInJvdC10csOkZGV0cyBPSUQgZsO2ciBpbmNoZWNrbmluZ2VuICVzIGkgaW5jaGVja25pbmdzZ3JhZmVuIMOkciAlcyAhPSAlcyIKIAotIzogY29tbWl0LWdyYXBoLmM6MjAxNworIzogY29tbWl0LWdyYXBoLmM6MjAzNwogIywgYy1mb3JtYXQKIG1zZ2lkICJjb21taXQtZ3JhcGggcGFyZW50IGxpc3QgZm9yIGNvbW1pdCAlcyBpcyB0b28gbG9uZyIKIG1zZ3N0ciAiaW5jaGVja25pbmdzZ3JhZmVucyBmw7Zyw6RsZHJhbGlzdGEgZsO2ciBpbmNoZWNrbmluZ2VuICVzIMOkciBmw7ZyIGzDpW5nIgogCi0jOiBjb21taXQtZ3JhcGguYzoyMDI2CisjOiBjb21taXQtZ3JhcGguYzoyMDQ2CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvbW1pdC1ncmFwaCBwYXJlbnQgZm9yICVzIGlzICVzICE9ICVzIgogbXNnc3RyICJpbmNoZWNrbmluZ3NncmFmZW5zIGbDtnLDpGxkZXIgZsO2ciAlcyDDpHIgJXMgIT0gJXMiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjIwMzkKKyM6IGNvbW1pdC1ncmFwaC5jOjIwNTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiY29tbWl0LWdyYXBoIHBhcmVudCBsaXN0IGZvciBjb21taXQgJXMgdGVybWluYXRlcyBlYXJseSIKIG1zZ3N0ciAiIgogImluY2hlY2tuaW5nc2dyYWZlbnMgZsO2csOkbGRyYWxpc3RhIGbDtnIgaW5jaGVja25pbmdlbiAlcyBhdnNsdXRhcyBmw7ZyIHRpZGlndCIKIAotIzogY29tbWl0LWdyYXBoLmM6MjA0NAorIzogY29tbWl0LWdyYXBoLmM6MjA2NAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiY29tbWl0LWdyYXBoIGhhcyBnZW5lcmF0aW9uIG51bWJlciB6ZXJvIGZvciBjb21taXQgJXMsIGJ1dCBub24temVybyBlbHNld2hlcmUiCkBAIC0xNjUzLDcgKzE2NjksNyBAQAogImluY2hlY2tuaW5nc2dyYWZlbiBoYXIgZ2VuZXJhdGlvbnNudW1tZXIgbm9sbCBmw7ZyIGluY2hlY2tuaW5nZW4gJXMsIG1lbiBpY2tlLSIKICJub2xsIHDDpSBhbm5hbiBwbGF0cyIKIAotIzogY29tbWl0LWdyYXBoLmM6MjA0OAorIzogY29tbWl0LWdyYXBoLmM6MjA2OAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiY29tbWl0LWdyYXBoIGhhcyBub24temVybyBnZW5lcmF0aW9uIG51bWJlciBmb3IgY29tbWl0ICVzLCBidXQgemVybyBlbHNld2hlcmUiCkBAIC0xNjYxLDEyICsxNjc3LDEyIEBACiAiaW5jaGVja25pbmdzZ3JhZmVuIGhhciBnZW5lcmF0aW9uc251bW1lciBza2lsdCBmcsOlbiBub2xsIGbDtnIgaW5jaGVja25pbmdlbiAiCiAiJXMsIG1lbiBub2xsIHDDpSBhbm5hbiBwbGF0cyIKIAotIzogY29tbWl0LWdyYXBoLmM6MjA2MworIzogY29tbWl0LWdyYXBoLmM6MjA4MwogIywgYy1mb3JtYXQKIG1zZ2lkICJjb21taXQtZ3JhcGggZ2VuZXJhdGlvbiBmb3IgY29tbWl0ICVzIGlzICV1ICE9ICV1IgogbXNnc3RyICJpbmNoZWNrbmluZ3NncmFmZW5zIGdlbmVyYXRpb24gZsO2ciBpbmNoZWNrbmluZ2VuICVzIMOkciAldSAhPSAldSIKIAotIzogY29tbWl0LWdyYXBoLmM6MjA2OQorIzogY29tbWl0LWdyYXBoLmM6MjA4OQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb21taXQgZGF0ZSBmb3IgY29tbWl0ICVzIGluIGNvbW1pdC1ncmFwaCBpcyAlPFBSSXVNQVg+ICE9ICU8UFJJdU1BWD4iCiBtc2dzdHIgIiIKQEAgLTE3MDUsMjg5ICsxNzIxLDI4MyBAQAogbXNnaWQgInJlbGF0aXZlIGNvbmZpZyBpbmNsdWRlIGNvbmRpdGlvbmFscyBtdXN0IGNvbWUgZnJvbSBmaWxlcyIKIG1zZ3N0ciAicmVsYXRpdmEga29uZmlndXJlcmluZ3NpbmtsdWRlcmluZ3N2aWxsa29yIG3DpXN0ZSBrb21tYSBmcsOlbiBmaWxlciIKIAotIzogY29uZmlnLmM6Mzc1CisjOiBjb25maWcuYzozNzYKICMsIGMtZm9ybWF0CiBtc2dpZCAia2V5IGRvZXMgbm90IGNvbnRhaW4gYSBzZWN0aW9uOiAlcyIKIG1zZ3N0ciAibnlja2VsbiBpbm5laMOlbGxlciBpbnRlIGV0dCBzdHlja2U6ICVzIgogCi0jOiBjb25maWcuYzozODEKKyM6IGNvbmZpZy5jOjM4MgogIywgYy1mb3JtYXQKIG1zZ2lkICJrZXkgZG9lcyBub3QgY29udGFpbiB2YXJpYWJsZSBuYW1lOiAlcyIKIG1zZ3N0ciAibnlja2VsbiBpbm5laMOlbGxlciBpbnRlIHZhcmlhYmVsbmFtbjogJXMiCiAKLSM6IGNvbmZpZy5jOjQwNSBzZXF1ZW5jZXIuYzoyNDYzCisjOiBjb25maWcuYzo0MDYgc2VxdWVuY2VyLmM6MjQwMQogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIGtleTogJXMiCiBtc2dzdHIgImZlbGFrdGlnIG55Y2tlbDogJXMiCiAKLSM6IGNvbmZpZy5jOjQxMQorIzogY29uZmlnLmM6NDEyCiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQga2V5IChuZXdsaW5lKTogJXMiCiBtc2dzdHIgIm9naWx0aWcgbnlja2VsIChueXJhZHN0ZWNrZW4pOiAlcyIKIAotIzogY29uZmlnLmM6NDQ3IGNvbmZpZy5jOjQ1OQorIzogY29uZmlnLmM6NDQ4IGNvbmZpZy5jOjQ2MAogIywgYy1mb3JtYXQKIG1zZ2lkICJib2d1cyBjb25maWcgcGFyYW1ldGVyOiAlcyIKIG1zZ3N0ciAiZmFsc2sga29uZmlndXJlcmluZ3NwYXJhbWV0ZXI6ICVzIgogCi0jOiBjb25maWcuYzo0OTQKKyM6IGNvbmZpZy5jOjQ5NQogIywgYy1mb3JtYXQKIG1zZ2lkICJib2d1cyBmb3JtYXQgaW4gJXMiCiBtc2dzdHIgImZlbGFrdGlndCBmb3JtYXQgaSAlcyIKIAotIzogY29uZmlnLmM6ODIwCisjOiBjb25maWcuYzo4MjEKICMsIGMtZm9ybWF0CiBtc2dpZCAiYmFkIGNvbmZpZyBsaW5lICVkIGluIGJsb2IgJXMiCiBtc2dzdHIgImZlbGFrdGlnIGtvbmZpZ3VyYXRpb25zZmlsIHJhZCAlZCBpIGJsb2I6ZW4gJXMiCiAKLSM6IGNvbmZpZy5jOjgyNAorIzogY29uZmlnLmM6ODI1CiAjLCBjLWZvcm1hdAogbXNnaWQgImJhZCBjb25maWcgbGluZSAlZCBpbiBmaWxlICVzIgogbXNnc3RyICJmZWxha3RpZyBrb25maWd1cmF0aW9uc2ZpbCByYWQgJWQgaSBmaWxlbiAlcyIKIAotIzogY29uZmlnLmM6ODI4CisjOiBjb25maWcuYzo4MjkKICMsIGMtZm9ybWF0CiBtc2dpZCAiYmFkIGNvbmZpZyBsaW5lICVkIGluIHN0YW5kYXJkIGlucHV0IgogbXNnc3RyICJmZWxha3RpZyBrb25maWd1cmF0aW9uc2ZpbCByYWQgJWQgaSBzdGFuZGFyZCBpbiIKIAotIzogY29uZmlnLmM6ODMyCisjOiBjb25maWcuYzo4MzMKICMsIGMtZm9ybWF0CiBtc2dpZCAiYmFkIGNvbmZpZyBsaW5lICVkIGluIHN1Ym1vZHVsZS1ibG9iICVzIgogbXNnc3RyICJmZWxha3RpZyBrb25maWd1cmF0aW9uc2ZpbCByYWQgJWQgaSB1bmRlcm1vZHVscy1ibG9iOmVuICVzIgogCi0jOiBjb25maWcuYzo4MzYKKyM6IGNvbmZpZy5jOjgzNwogIywgYy1mb3JtYXQKIG1zZ2lkICJiYWQgY29uZmlnIGxpbmUgJWQgaW4gY29tbWFuZCBsaW5lICVzIgogbXNnc3RyICJmZWxha3RpZyBrb25maWd1cmF0aW9uc2ZpbCByYWQgJWQgaSBrb21tYW5kb3JhZGVuICVzIgogCi0jOiBjb25maWcuYzo4NDAKKyM6IGNvbmZpZy5jOjg0MQogIywgYy1mb3JtYXQKIG1zZ2lkICJiYWQgY29uZmlnIGxpbmUgJWQgaW4gJXMiCiBtc2dzdHIgImZlbGFrdGlnIGtvbmZpZ3VyYXRpb25zZmlsIHJhZCAlZCBpICVzIgogCi0jOiBjb25maWcuYzo5NzcKKyM6IGNvbmZpZy5jOjk3OAogbXNnaWQgIm91dCBvZiByYW5nZSIKIG1zZ3N0ciAidXRhbmbDtnIgaW50ZXJ2YWxsZXQiCiAKLSM6IGNvbmZpZy5jOjk3NworIzogY29uZmlnLmM6OTc4CiBtc2dpZCAiaW52YWxpZCB1bml0IgogbXNnc3RyICJvZ2lsdGlnIGVuaGV0IgogCi0jOiBjb25maWcuYzo5NzgKKyM6IGNvbmZpZy5jOjk3OQogIywgYy1mb3JtYXQKIG1zZ2lkICJiYWQgbnVtZXJpYyBjb25maWcgdmFsdWUgJyVzJyBmb3IgJyVzJzogJXMiCiBtc2dzdHIgImZlbGFrdGlndCBudW1lcmlza3Qga29uZmlndXJhdGlvbnN2w6RyZGUgXCIlc1wiIGbDtnIgXCIlc1wiOiAlcyIKIAotIzogY29uZmlnLmM6OTk3CisjOiBjb25maWcuYzo5OTgKICMsIGMtZm9ybWF0CiBtc2dpZCAiYmFkIG51bWVyaWMgY29uZmlnIHZhbHVlICclcycgZm9yICclcycgaW4gYmxvYiAlczogJXMiCiBtc2dzdHIgIiIKICJmZWxha3RpZ3QgbnVtZXJpc2t0IGtvbmZpZ3VyYXRpb25zdsOkcmRlIFwiJXNcIiBmw7ZyIFwiJXNcIiBpIGJsb2I6ZW4gJXM6ICVzIgogCi0jOiBjb25maWcuYzoxMDAwCisjOiBjb25maWcuYzoxMDAxCiAjLCBjLWZvcm1hdAogbXNnaWQgImJhZCBudW1lcmljIGNvbmZpZyB2YWx1ZSAnJXMnIGZvciAnJXMnIGluIGZpbGUgJXM6ICVzIgogbXNnc3RyICIiCiAiZmVsYWt0aWd0IG51bWVyaXNrdCBrb25maWd1cmF0aW9uc3bDpHJkZSBcIiVzXCIgZsO2ciBcIiVzXCIgaSBmaWxlbiAlczogJXMiCiAKLSM6IGNvbmZpZy5jOjEwMDMKKyM6IGNvbmZpZy5jOjEwMDQKICMsIGMtZm9ybWF0CiBtc2dpZCAiYmFkIG51bWVyaWMgY29uZmlnIHZhbHVlICclcycgZm9yICclcycgaW4gc3RhbmRhcmQgaW5wdXQ6ICVzIgogbXNnc3RyICIiCiAiZmVsYWt0aWd0IG51bWVyaXNrdCBrb25maWd1cmF0aW9uc3bDpHJkZSBcIiVzXCIgZsO2ciBcIiVzXCIgaSBzdGFuZGFyZCBpbjogJXMiCiAKLSM6IGNvbmZpZy5jOjEwMDYKKyM6IGNvbmZpZy5jOjEwMDcKICMsIGMtZm9ybWF0CiBtc2dpZCAiYmFkIG51bWVyaWMgY29uZmlnIHZhbHVlICclcycgZm9yICclcycgaW4gc3VibW9kdWxlLWJsb2IgJXM6ICVzIgogbXNnc3RyICIiCiAiZmVsYWt0aWd0IG51bWVyaXNrdCBrb25maWd1cmF0aW9uc3bDpHJkZSBcIiVzXCIgZsO2ciBcIiVzXCIgaSB1bmRlcm1vZHVsLWJsb2I6IgogImVuICVzOiAlcyIKIAotIzogY29uZmlnLmM6MTAwOQorIzogY29uZmlnLmM6MTAxMAogIywgYy1mb3JtYXQKIG1zZ2lkICJiYWQgbnVtZXJpYyBjb25maWcgdmFsdWUgJyVzJyBmb3IgJyVzJyBpbiBjb21tYW5kIGxpbmUgJXM6ICVzIgogbXNnc3RyICIiCiAiZmVsYWt0aWd0IG51bWVyaXNrdCBrb25maWd1cmF0aW9uc3bDpHJkZSBcIiVzXCIgZsO2ciBcIiVzXCIgaSBrb21tYW5kb3JhZGVuICIKICIlczogJXMiCiAKLSM6IGNvbmZpZy5jOjEwMTIKKyM6IGNvbmZpZy5jOjEwMTMKICMsIGMtZm9ybWF0CiBtc2dpZCAiYmFkIG51bWVyaWMgY29uZmlnIHZhbHVlICclcycgZm9yICclcycgaW4gJXM6ICVzIgogbXNnc3RyICJmZWxha3RpZ3QgbnVtZXJpc2t0IGtvbmZpZ3VyYXRpb25zdsOkcmRlIFwiJXNcIiBmw7ZyIFwiJXNcIiBpICVzOiAlcyIKIAotIzogY29uZmlnLmM6MTEwNworIzogY29uZmlnLmM6MTEwOAogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gZXhwYW5kIHVzZXIgZGlyIGluOiAnJXMnIgogbXNnc3RyICJtaXNzbHlja2FkZXMgZXhwYW5kZXJhIGFudsOkbmRhcmthdGFsb2cgaTogXCIlc1wiIgogCi0jOiBjb25maWcuYzoxMTE2CisjOiBjb25maWcuYzoxMTE3CiAjLCBjLWZvcm1hdAogbXNnaWQgIiclcycgZm9yICclcycgaXMgbm90IGEgdmFsaWQgdGltZXN0YW1wIgogbXNnc3RyICJcIiVzXCIgZsO2ciBcIiVzXCIgw6RyIGludGUgZW4gZ2lsdGlnIHRpZHNzdMOkbXBlbCIKIAotIzogY29uZmlnLmM6MTIwNworIzogY29uZmlnLmM6MTIwOAogIywgYy1mb3JtYXQKIG1zZ2lkICJhYmJyZXYgbGVuZ3RoIG91dCBvZiByYW5nZTogJWQiCiBtc2dzdHIgImbDtnJrb3J0bmluZ3Nsw6RuZ2QgdXRhbmbDtnIgaW50ZXJ2YWxsZXQ6ICVkIgogCi0jOiBjb25maWcuYzoxMjIxIGNvbmZpZy5jOjEyMzIKKyM6IGNvbmZpZy5jOjEyMjIgY29uZmlnLmM6MTIzMwogIywgYy1mb3JtYXQKIG1zZ2lkICJiYWQgemxpYiBjb21wcmVzc2lvbiBsZXZlbCAlZCIKIG1zZ3N0ciAiZmVsYWt0aWd0IHpsaWIta29tcHJpbWVyaW5nc2dyYWQgJWQiCiAKLSM6IGNvbmZpZy5jOjEzMjQKKyM6IGNvbmZpZy5jOjEzMjUKIG1zZ2lkICJjb3JlLmNvbW1lbnRDaGFyIHNob3VsZCBvbmx5IGJlIG9uZSBjaGFyYWN0ZXIiCiBtc2dzdHIgImNvcmUuY29tbWVudENoYXIga2FuIGJhcmEgdmFyYSBldHQgdGVja2VuIgogCi0jOiBjb25maWcuYzoxMzU3CisjOiBjb25maWcuYzoxMzU4CiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgbW9kZSBmb3Igb2JqZWN0IGNyZWF0aW9uOiAlcyIKIG1zZ3N0ciAiZmVsYWt0aWd0IGzDpGdlIGbDtnIgc2thcGFuZGUgYXYgb2JqZWt0OiAlcyIKIAotIzogY29uZmlnLmM6MTQyOQorIzogY29uZmlnLmM6MTQyNQogIywgYy1mb3JtYXQKIG1zZ2lkICJtYWxmb3JtZWQgdmFsdWUgZm9yICVzIgogbXNnc3RyICJmZWxmb3JtYXQgdsOkcmRlIGbDtnIgJXMiCiAKLSM6IGNvbmZpZy5jOjE0NTUKKyM6IGNvbmZpZy5jOjE0NTEKICMsIGMtZm9ybWF0CiBtc2dpZCAibWFsZm9ybWVkIHZhbHVlIGZvciAlczogJXMiCiBtc2dzdHIgImZlbGZvcm1hdCB2w6RyZGUgZsO2ciAlczogJXMiCiAKLSM6IGNvbmZpZy5jOjE0NTYKKyM6IGNvbmZpZy5jOjE0NTIKIG1zZ2lkICJtdXN0IGJlIG9uZSBvZiBub3RoaW5nLCBtYXRjaGluZywgc2ltcGxlLCB1cHN0cmVhbSBvciBjdXJyZW50IgogbXNnc3RyICJtw6VzdGUgdmFyYSBlbiBhdiBub3RoaW5nLCBtYXRjaGluZywgc2ltcGxlLCB1cHN0cmVhbSBlbGxlciBjdXJyZW50IgogCi0jOiBjb25maWcuYzoxNTE3IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzM5OQorIzogY29uZmlnLmM6MTUxMyBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzOTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiYmFkIHBhY2sgY29tcHJlc3Npb24gbGV2ZWwgJWQiCiBtc2dzdHIgImZlbGFrdGlnIHBha2V0a29tcHJpbWVyaW5nc2dyYWQgJWQiCiAKLSM6IGNvbmZpZy5jOjE2MzgKKyM6IGNvbmZpZy5jOjE2MzQKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGxvYWQgY29uZmlnIGJsb2Igb2JqZWN0ICclcyciCiBtc2dzdHIgImt1bmRlIGludGUgbMOkc2Ega29uZmlndXJlcmluZ3MtYmxvYm9iamVrdGV0IFwiJXNcIiIKIAotIzogY29uZmlnLmM6MTY0MQorIzogY29uZmlnLmM6MTYzNwogIywgYy1mb3JtYXQKIG1zZ2lkICJyZWZlcmVuY2UgJyVzJyBkb2VzIG5vdCBwb2ludCB0byBhIGJsb2IiCiBtc2dzdHIgInJlZmVyZW5zZW4gXCIlc1wiIHBla2FyIGludGUgcMOlIGVuIGJsb2IiCiAKLSM6IGNvbmZpZy5jOjE2NTgKKyM6IGNvbmZpZy5jOjE2NTQKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHJlc29sdmUgY29uZmlnIGJsb2IgJyVzJyIKIG1zZ3N0ciAia2FuIGludGUgc2zDpSB1cHAga29uZmlndXJlcmluZ3MtYmxvYmVuIFwiJXNcIiIKIAotIzogY29uZmlnLmM6MTY4OAorIzogY29uZmlnLmM6MTY4NAogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gcGFyc2UgJXMiCiBtc2dzdHIgImt1bmRlIGludGUgdG9sa2EgJXMiCiAKLSM6IGNvbmZpZy5jOjE3NDQKKyM6IGNvbmZpZy5jOjE3NDAKIG1zZ2lkICJ1bmFibGUgdG8gcGFyc2UgY29tbWFuZC1saW5lIGNvbmZpZyIKIG1zZ3N0ciAia2FuIGludGUgdG9sa2Ega29tbWFuZG9yYWRza29uZmlndXJhdGlvbiIKIAotIzogY29uZmlnLmM6MjA5MworIzogY29uZmlnLmM6MjA5MQogbXNnaWQgInVua25vd24gZXJyb3Igb2NjdXJyZWQgd2hpbGUgcmVhZGluZyB0aGUgY29uZmlndXJhdGlvbiBmaWxlcyIKIG1zZ3N0ciAib2vDpG50IGZlbCB1cHBzdG9kIHZpZCBsw6RzbmluZyBhdiBrb25maWd1cmF0aW9uc2ZpbGVybmEiCiAKLSM6IGNvbmZpZy5jOjIyNjMKKyM6IGNvbmZpZy5jOjIyNjEKICMsIGMtZm9ybWF0CiBtc2dpZCAiSW52YWxpZCAlczogJyVzJyIKIG1zZ3N0ciAiRmVsYWt0aWd0ICVzOiBcIiVzXCIiCiAKICM6IGNvbmZpZy5jOjIzMDYKICMsIGMtZm9ybWF0Ci1tc2dpZCAidW5rbm93biBjb3JlLnVudHJhY2tlZENhY2hlIHZhbHVlICclcyc7IHVzaW5nICdrZWVwJyBkZWZhdWx0IHZhbHVlIgotbXNnc3RyICIiCi0ib2vDpG50IHbDpHJkZSBcIiVzXCIgZsO2ciBjb3JlLnVudHJhY2tlZENhY2hlOyBhbnbDpG5kZXIgc3RhbmRhcmR2w6RyZGV0IFwia2VlcFwiIgotCi0jOiBjb25maWcuYzoyMzMyCi0jLCBjLWZvcm1hdAogbXNnaWQgInNwbGl0SW5kZXgubWF4UGVyY2VudENoYW5nZSB2YWx1ZSAnJWQnIHNob3VsZCBiZSBiZXR3ZWVuIDAgYW5kIDEwMCIKIG1zZ3N0ciAidsOkcmRldCBcIiVkXCIgZsO2ciBzcGxpdEluZGV4Lm1heFBlcmNlbnRhZ2UgYm9yZGUgdmFyYSBtZWxsYW4gMCBvY2ggMTAwIgogCi0jOiBjb25maWcuYzoyMzc4CisjOiBjb25maWcuYzoyMzUyCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBwYXJzZSAnJXMnIGZyb20gY29tbWFuZC1saW5lIGNvbmZpZyIKIG1zZ3N0ciAia3VuZGUgaW50ZSB0b2xrYSB2w6RyZGV0IFwiJXNcIiBmcsOlbiBrb21tYW5kb3JhZHNrb25maWd1cmF0aW9uIgogCi0jOiBjb25maWcuYzoyMzgwCisjOiBjb25maWcuYzoyMzU0CiAjLCBjLWZvcm1hdAogbXNnaWQgImJhZCBjb25maWcgdmFyaWFibGUgJyVzJyBpbiBmaWxlICclcycgYXQgbGluZSAlZCIKIG1zZ3N0ciAiZmVsYWt0aWcga29uZmlndXJhdGlvbnN2YXJpYWJlbCBcIiVzXCIgaSBmaWxlbiBcIiVzXCIgcMOlIHJhZCAlZCIKIAotIzogY29uZmlnLmM6MjQ2MQorIzogY29uZmlnLmM6MjQzNQogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIHNlY3Rpb24gbmFtZSAnJXMnIgogbXNnc3RyICJmZWxha3RpZ3Qgc2VrdGlvbnNuYW1uIFwiJXNcIiIKIAotIzogY29uZmlnLmM6MjQ5MworIzogY29uZmlnLmM6MjQ2NwogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyBoYXMgbXVsdGlwbGUgdmFsdWVzIgogbXNnc3RyICIlcyBoYXIgZmxlcmEgdsOkcmRlbiIKIAotIzogY29uZmlnLmM6MjUyMgorIzogY29uZmlnLmM6MjQ5NgogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gd3JpdGUgbmV3IGNvbmZpZ3VyYXRpb24gZmlsZSAlcyIKIG1zZ3N0ciAia2FuIGludGUgc2tyaXZhIG55YSBrb25maWd1cmF0aW9uc2ZpbGVuIFwiJXNcIiIKIAotIzogY29uZmlnLmM6Mjc3NCBjb25maWcuYzozMDk4CisjOiBjb25maWcuYzoyNzQ4IGNvbmZpZy5jOjMwNzIKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGxvY2sgY29uZmlnIGZpbGUgJXMiCiBtc2dzdHIgImt1bmRlIGludGUgbMOlc2Ega29uZmlndXJhdGlvbnNmaWxlbiAlcyIKIAotIzogY29uZmlnLmM6Mjc4NQorIzogY29uZmlnLmM6Mjc1OQogIywgYy1mb3JtYXQKIG1zZ2lkICJvcGVuaW5nICVzIgogbXNnc3RyICLDtnBwbmFyICVzIgogCi0jOiBjb25maWcuYzoyODIwIGJ1aWx0aW4vY29uZmlnLmM6MzI4CisjOiBjb25maWcuYzoyNzk0IGJ1aWx0aW4vY29uZmlnLmM6MzI4CiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgcGF0dGVybjogJXMiCiBtc2dzdHIgIm9naWx0aWd0IG3Dtm5zdGVyOiAlcyIKIAotIzogY29uZmlnLmM6Mjg0NQorIzogY29uZmlnLmM6MjgxOQogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIGNvbmZpZyBmaWxlICVzIgogbXNnc3RyICJvZ2lsdGlnIGtvbmZpZ3VyYXRpb25zZmlsOiBcIiVzXCIiCiAKLSM6IGNvbmZpZy5jOjI4NTggY29uZmlnLmM6MzExMQorIzogY29uZmlnLmM6MjgzMiBjb25maWcuYzozMDg1CiAjLCBjLWZvcm1hdAogbXNnaWQgImZzdGF0IG9uICVzIGZhaWxlZCIKIG1zZ3N0ciAiZnN0YXQgbWlzc2x5Y2thZGVzIHDDpSAlcyIKIAotIzogY29uZmlnLmM6Mjg2OQorIzogY29uZmlnLmM6Mjg0MwogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gbW1hcCAnJXMnIgogbXNnc3RyICJrdW5kZSBpbnRlIHV0ZsO2cmEgbW1hcCBww6UgXCIlc1wiIgogCi0jOiBjb25maWcuYzoyODc4IGNvbmZpZy5jOjMxMTYKKyM6IGNvbmZpZy5jOjI4NTIgY29uZmlnLmM6MzA5MAogIywgYy1mb3JtYXQKIG1zZ2lkICJjaG1vZCBvbiAlcyBmYWlsZWQiCiBtc2dzdHIgImNobW9kIG1pc3NseWNrYWRlcyBww6UgJXMiCiAKLSM6IGNvbmZpZy5jOjI5NjMgY29uZmlnLmM6MzIxMworIzogY29uZmlnLmM6MjkzNyBjb25maWcuYzozMTg3CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCB3cml0ZSBjb25maWcgZmlsZSAlcyIKIG1zZ3N0ciAia3VuZGUgaW50ZSBza3JpdmEga29uZmlndXJhdGlvbnNmaWxlbiAlcyIKIAotIzogY29uZmlnLmM6Mjk5NworIzogY29uZmlnLmM6Mjk3MQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3Qgc2V0ICclcycgdG8gJyVzJyIKIG1zZ3N0ciAia3VuZGUgaW50ZSBzdMOkbGxhIGluIFwiJXNcIiB0aWxsIFwiJXNcIiIKIAotIzogY29uZmlnLmM6Mjk5OSBidWlsdGluL3JlbW90ZS5jOjc4MgorIzogY29uZmlnLmM6Mjk3MyBidWlsdGluL3JlbW90ZS5jOjc4MgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgdW5zZXQgJyVzJyIKIG1zZ3N0ciAia3VuZGUgaW50ZSB0YSBib3J0IGluc3TDpGxsbmluZyBmw7ZyIFwiJXNcIiIKIAotIzogY29uZmlnLmM6MzA4OQorIzogY29uZmlnLmM6MzA2MwogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIHNlY3Rpb24gbmFtZTogJXMiCiBtc2dzdHIgImZlbGFrdGlndCBuYW1uIHDDpSBzdHlja2U6ICVzIgogCi0jOiBjb25maWcuYzozMjU2CisjOiBjb25maWcuYzozMjMwCiAjLCBjLWZvcm1hdAogbXNnaWQgIm1pc3NpbmcgdmFsdWUgZm9yICclcyciCiBtc2dzdHIgInbDpHJkZSBzYWtuYXMgZsO2ciBcIiVzXCIiCkBAIC0yMTExLDcgKzIxMjEsNyBAQAogbXNnaWQgInVua25vd24gcG9ydCAlcyIKIG1zZ3N0ciAib2vDpG5kIHBvcnQgJXMiCiAKLSM6IGNvbm5lY3QuYzo4NDUgY29ubmVjdC5jOjExNzEKKyM6IGNvbm5lY3QuYzo4NDUgY29ubmVjdC5jOjExNzUKICMsIGMtZm9ybWF0CiBtc2dpZCAic3RyYW5nZSBob3N0bmFtZSAnJXMnIGJsb2NrZWQiCiBtc2dzdHIgImtvbnN0aWd0IHbDpHJkbmFtbiBcIiVzXCIgYmxvY2tlcmF0IgpAQCAtMjEyNiw2MCArMjEzNiw2MCBAQAogbXNnaWQgImNhbm5vdCBzdGFydCBwcm94eSAlcyIKIG1zZ3N0ciAia2FuIGludGUgc3RhcnRhIG1lbGxhbnNlcnZlciAocHJveHkpICVzIgogCi0jOiBjb25uZWN0LmM6OTI0CisjOiBjb25uZWN0LmM6OTI4CiBtc2dpZCAibm8gcGF0aCBzcGVjaWZpZWQ7IHNlZSAnZ2l0IGhlbHAgcHVsbCcgZm9yIHZhbGlkIHVybCBzeW50YXgiCiBtc2dzdHIgImluZ2VuIHPDtmt2w6RnIGFuZ2F2czsgc2UgXCJnaXQgaGVscCBwdWxsXCIgZsO2ciBnaWx0aWcgVVJMLXN5bnRheCIKIAotIzogY29ubmVjdC5jOjExMTkKKyM6IGNvbm5lY3QuYzoxMTIzCiBtc2dpZCAic3NoIHZhcmlhbnQgJ3NpbXBsZScgZG9lcyBub3Qgc3VwcG9ydCAtNCIKIG1zZ3N0ciAic3NoLXZhcmlhbnRlbiBcInNpbXBsZVwiIHN0w7ZkZXIgaW50ZSAtNCIKIAotIzogY29ubmVjdC5jOjExMzEKKyM6IGNvbm5lY3QuYzoxMTM1CiBtc2dpZCAic3NoIHZhcmlhbnQgJ3NpbXBsZScgZG9lcyBub3Qgc3VwcG9ydCAtNiIKIG1zZ3N0ciAic3NoLXZhcmlhbnRlbiBcInNpbXBsZVwiIHN0w7ZkZXIgaW50ZSAtNiIKIAotIzogY29ubmVjdC5jOjExNDgKKyM6IGNvbm5lY3QuYzoxMTUyCiBtc2dpZCAic3NoIHZhcmlhbnQgJ3NpbXBsZScgZG9lcyBub3Qgc3VwcG9ydCBzZXR0aW5nIHBvcnQiCiBtc2dzdHIgInNzaC12YXJpYW50ZW4gXCJzaW1wbGVcIiBzdMO2ZGVyIGludGUgdmFsIGF2IHBvcnQiCiAKLSM6IGNvbm5lY3QuYzoxMjYwCisjOiBjb25uZWN0LmM6MTI2NAogIywgYy1mb3JtYXQKIG1zZ2lkICJzdHJhbmdlIHBhdGhuYW1lICclcycgYmxvY2tlZCIKIG1zZ3N0ciAia29uc3RpZ3Qgc8O2a3bDpGdzbmFtbiBcIiVzXCIgYmxvY2tlcmF0IgogCi0jOiBjb25uZWN0LmM6MTMwNworIzogY29ubmVjdC5jOjEzMTEKIG1zZ2lkICJ1bmFibGUgdG8gZm9yayIKIG1zZ3N0ciAia3VuZGUgaW50ZSBncmVuYSAoZm9yaykiCiAKICMgVmFndWUgb3JpZ2luYWwsIG5vdCBuZXR3b3JraW5nLXJlbGF0ZWQsIGJ1dCByYXRoZXIgcmVsYXRlZCB0byB0aGUgYWN0dWFsCiAjIG9iamVjdHMgaW4gdGhlIGRhdGFiYXNlLgotIzogY29ubmVjdGVkLmM6ODYgYnVpbHRpbi9mc2NrLmM6MjIxIGJ1aWx0aW4vcHJ1bmUuYzo0MworIzogY29ubmVjdGVkLmM6ODggYnVpbHRpbi9mc2NrLmM6MjIxIGJ1aWx0aW4vcHJ1bmUuYzo0MwogbXNnaWQgIkNoZWNraW5nIGNvbm5lY3Rpdml0eSIKIG1zZ3N0ciAiS29udHJvbGxlcmFyIGtvbm5la3Rpdml0ZXQiCiAKLSM6IGNvbm5lY3RlZC5jOjk4CisjOiBjb25uZWN0ZWQuYzoxMDAKIG1zZ2lkICJDb3VsZCBub3QgcnVuICdnaXQgcmV2LWxpc3QnIgogbXNnc3RyICJLdW5kZSBpbnRlIGvDtnJhIFwiZ2l0IHJldi1saXN0XCIiCiAKLSM6IGNvbm5lY3RlZC5jOjExOAorIzogY29ubmVjdGVkLmM6MTIwCiBtc2dpZCAiZmFpbGVkIHdyaXRlIHRvIHJldi1saXN0IgogbXNnc3RyICJrdW5kZSBpbnRlIHNrcml2YSB0aWxsIHJldi1saXN0IgogCi0jOiBjb25uZWN0ZWQuYzoxMjUKKyM6IGNvbm5lY3RlZC5jOjEyNwogbXNnaWQgImZhaWxlZCB0byBjbG9zZSByZXYtbGlzdCdzIHN0ZGluIgogbXNnc3RyICJrdW5kZSBpbnRlIHN0w6RuZ2EgcmV2LWxpc3Q6cyBzdGFuZGFyZCBpbiIKIAotIzogY29udmVydC5jOjE5MworIzogY29udmVydC5jOjE5NAogIywgYy1mb3JtYXQKIG1zZ2lkICJpbGxlZ2FsIGNybGZfYWN0aW9uICVkIgogbXNnc3RyICJmZWxha3RpZyBjcmxmX2FjdGlvbiAlZCIKIAotIzogY29udmVydC5jOjIwNgorIzogY29udmVydC5jOjIwNwogIywgYy1mb3JtYXQKIG1zZ2lkICJDUkxGIHdvdWxkIGJlIHJlcGxhY2VkIGJ5IExGIGluICVzIgogbXNnc3RyICJDUkxGIHNrdWxsZSBlcnPDpHR0YXMgYXYgTEYgaSAlcyIKIAotIzogY29udmVydC5jOjIwOAorIzogY29udmVydC5jOjIwOQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiQ1JMRiB3aWxsIGJlIHJlcGxhY2VkIGJ5IExGIGluICVzLlxuIgpAQCAtMjE4OCwxMiArMjE5OCwxMiBAQAogIkNSTEYga29tbWVyIGF0dCBlcnPDpHR0YXMgYXYgTEYgaSAlcy5cbiIKICJGaWxlbiBrb21tZXIgYXR0IGhhIHNpbmEgdXJzcHJ1bmdsaWdhIHJhZGJyeXRuaW5nYXIgaSBkaW4gYXJiZXRza2F0YWxvZyIKIAotIzogY29udmVydC5jOjIxNgorIzogY29udmVydC5jOjIxNwogIywgYy1mb3JtYXQKIG1zZ2lkICJMRiB3b3VsZCBiZSByZXBsYWNlZCBieSBDUkxGIGluICVzIgogbXNnc3RyICJMRiBza3VsbGUgZXJzw6R0dGFzIGF2IENSTEYgaSAlcyIKIAotIzogY29udmVydC5jOjIxOAorIzogY29udmVydC5jOjIxOQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiTEYgd2lsbCBiZSByZXBsYWNlZCBieSBDUkxGIGluICVzLlxuIgpAQCAtMjIwMiwxMiArMjIxMiwxMiBAQAogIkxGIGtvbW1lciBhdHQgZXJzw6R0dGFzIGF2IENSTEYgaSAlcy5cbiIKICJGaWxlbiBrb21tZXIgYXR0IGhhIHNpbmEgdXJzcHJ1bmdsaWdhIHJhZGJyeXRuaW5nYXIgaSBkaW4gYXJiZXRza2F0YWxvZyIKIAotIzogY29udmVydC5jOjI3OQorIzogY29udmVydC5jOjI4MAogIywgYy1mb3JtYXQKIG1zZ2lkICJCT00gaXMgcHJvaGliaXRlZCBpbiAnJXMnIGlmIGVuY29kZWQgYXMgJXMiCiBtc2dzdHIgIkJPTSDDpHIgZsO2cmJqdWRldCBpIFwiJXNcIiBvbSBrb2RhdCBzb20gJXMiCiAKLSM6IGNvbnZlcnQuYzoyODYKKyM6IGNvbnZlcnQuYzoyODcKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlRoZSBmaWxlICclcycgY29udGFpbnMgYSBieXRlIG9yZGVyIG1hcmsgKEJPTSkuIFBsZWFzZSB1c2UgVVRGLSVzIGFzIHdvcmtpbmctIgpAQCAtMjIxNiwxMiArMjIyNiwxMiBAQAogIkZpbGVuIFwiJXNcIiBpbm5laMOlbGxlciBieXRlIG9yZGVyIG1hcmsgKEJPTSkuIEFudsOkbmQgVVRGLSVzIHNvbSAiCiAidGVja2Vua29kbmluZyBpIGFyYmV0c2thdGFsb2dlbi4iCiAKLSM6IGNvbnZlcnQuYzozMDQKKyM6IGNvbnZlcnQuYzozMDUKICMsIGMtZm9ybWF0CiBtc2dpZCAiQk9NIGlzIHJlcXVpcmVkIGluICclcycgaWYgZW5jb2RlZCBhcyAlcyIKIG1zZ3N0ciAiQk9NIGtyw6R2cyBvbSBcIiVzXCIga29kYXMgc29tICVzIgogCi0jOiBjb252ZXJ0LmM6MzA2CisjOiBjb252ZXJ0LmM6MzA3CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgZmlsZSAnJXMnIGlzIG1pc3NpbmcgYSBieXRlIG9yZGVyIG1hcmsgKEJPTSkuIFBsZWFzZSB1c2UgVVRGLSVzQkUgb3IgVVRGLSIKQEAgLTIyMzAsNTEgKzIyNDAsNTEgQEAKICJGaWxlbiBcIiVzXCIgc2FrbmFyIGJ5dGUgb3JkZXIgbWFyayAoQk9NKS4gQW52w6RuZCBVVEYtJXNCRSBlbGxlciBVVEYtJXNMRSAiCiAiKGJlcm9lbmRlIHDDpSBieXRlb3JkbmluZykgc29tIHRlY2tlbmtvZG5pbmcgaSBhcmJldHNrYXRhbG9nZW4uIgogCi0jOiBjb252ZXJ0LmM6NDI0IGNvbnZlcnQuYzo0OTUKKyM6IGNvbnZlcnQuYzo0MjUgY29udmVydC5jOjQ5NgogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gZW5jb2RlICclcycgZnJvbSAlcyB0byAlcyIKIG1zZ3N0ciAibWlzc2x5Y2thZGVzIG9ta29kYSBcIiVzXCIgZnLDpW4gJXMgdGlsbCAlcyIKIAotIzogY29udmVydC5jOjQ2NworIzogY29udmVydC5jOjQ2OAogIywgYy1mb3JtYXQKIG1zZ2lkICJlbmNvZGluZyAnJXMnIGZyb20gJXMgdG8gJXMgYW5kIGJhY2sgaXMgbm90IHRoZSBzYW1lIgogbXNnc3RyICIiCiAib21rb2RuaW5nIGF2IFwiJXNcIiBmcsOlbiAlcyB0aWxsICVzIG9jaCB0aWxsYmFrYSBnZXIgaW50ZSBzYW1tYSByZXN1bHRhdCIKIAotIzogY29udmVydC5jOjY3MworIzogY29udmVydC5jOjY3NAogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgZm9yayB0byBydW4gZXh0ZXJuYWwgZmlsdGVyICclcyciCiBtc2dzdHIgImthbiBpbnRlIGdyZW5hIChmb3JrKSBmw7ZyIGF0dCBrw7ZyYSBleHRlcm50IGZpbHRlciBcIiVzXCIiCiAKLSM6IGNvbnZlcnQuYzo2OTMKKyM6IGNvbnZlcnQuYzo2OTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IGZlZWQgdGhlIGlucHV0IHRvIGV4dGVybmFsIGZpbHRlciAnJXMnIgogbXNnc3RyICJrdW5kZSBpbnRlIHNraWNrYSBpbmRhdGEgdGlsbCBleHRlcm50IGZpbHRlciBcIiVzXCIiCiAKLSM6IGNvbnZlcnQuYzo3MDAKKyM6IGNvbnZlcnQuYzo3MDEKICMsIGMtZm9ybWF0CiBtc2dpZCAiZXh0ZXJuYWwgZmlsdGVyICclcycgZmFpbGVkICVkIgogbXNnc3RyICJleHRlcm50IGZpbHRlciBcIiVzXCIgbWlzc2x5Y2thZGVzICVkIgogCi0jOiBjb252ZXJ0LmM6NzM1IGNvbnZlcnQuYzo3MzgKKyM6IGNvbnZlcnQuYzo3MzYgY29udmVydC5jOjczOQogIywgYy1mb3JtYXQKIG1zZ2lkICJyZWFkIGZyb20gZXh0ZXJuYWwgZmlsdGVyICclcycgZmFpbGVkIgogbXNnc3RyICJsw6RzbmluZyBmcsOlbiBleHRlcm50IGZpbHRlciBcIiVzXCIgbWlzc2x5Y2thZGVzIgogCi0jOiBjb252ZXJ0LmM6NzQxIGNvbnZlcnQuYzo3OTYKKyM6IGNvbnZlcnQuYzo3NDIgY29udmVydC5jOjc5NwogIywgYy1mb3JtYXQKIG1zZ2lkICJleHRlcm5hbCBmaWx0ZXIgJyVzJyBmYWlsZWQiCiBtc2dzdHIgImV4dGVybnQgZmlsdGVyIFwiJXNcIiBtaXNzbHlja2FkZXMiCiAKLSM6IGNvbnZlcnQuYzo4NDQKKyM6IGNvbnZlcnQuYzo4NDUKIG1zZ2lkICJ1bmV4cGVjdGVkIGZpbHRlciB0eXBlIgogbXNnc3RyICJvdsOkbnRhZCBmaWx0ZXJ0eXAiCiAKLSM6IGNvbnZlcnQuYzo4NTUKKyM6IGNvbnZlcnQuYzo4NTYKIG1zZ2lkICJwYXRoIG5hbWUgdG9vIGxvbmcgZm9yIGV4dGVybmFsIGZpbHRlciIKIG1zZ3N0ciAic8O2a3bDpGdlbiBmw7ZyIGzDpW5nIGbDtnIgZXh0ZXJudCBmaWx0ZXIiCiAKLSM6IGNvbnZlcnQuYzo5MjkKKyM6IGNvbnZlcnQuYzo5MzAKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogImV4dGVybmFsIGZpbHRlciAnJXMnIGlzIG5vdCBhdmFpbGFibGUgYW55bW9yZSBhbHRob3VnaCBub3QgYWxsIHBhdGhzIGhhdmUgIgpAQCAtMjI4Myw2NyArMjI5Myw2NyBAQAogImV4dGVybnQgZmlsdGVyIFwiJXNcIiDDpHIgaW50ZSBsw6RuZ3JlIHRpbGxnw6RuZ2xpZ3QgdHJvdHMgYXR0IGFsbGEgc8O2a3bDpGdhciAiCiAiaW50ZSBoYXIgZmlsdHJlcmF0cyIKIAotIzogY29udmVydC5jOjEyMjgKKyM6IGNvbnZlcnQuYzoxMjI5CiBtc2dpZCAidHJ1ZS9mYWxzZSBhcmUgbm8gdmFsaWQgd29ya2luZy10cmVlLWVuY29kaW5ncyIKIG1zZ3N0ciAidHJ1ZS9mYWxzZSDDpHIgaW50ZSBnaWx0aWcgdGVja2Vua29kbmluZyBmw7ZyIGFyYmV0c2thdGFsb2dlbiIKIAotIzogY29udmVydC5jOjEzOTggY29udmVydC5jOjE0MzIKKyM6IGNvbnZlcnQuYzoxNDE3IGNvbnZlcnQuYzoxNDUxCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiBjbGVhbiBmaWx0ZXIgJyVzJyBmYWlsZWQiCiBtc2dzdHIgIiVzOiBcImNsZWFuXCItZmlsdHJldCBcIiVzXCIgbWlzc2x5Y2thZGVzIgogCi0jOiBjb252ZXJ0LmM6MTQ3NgorIzogY29udmVydC5jOjE0OTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXM6IHNtdWRnZSBmaWx0ZXIgJXMgZmFpbGVkIgogbXNnc3RyICIlczogXCJzbXVkZ2VcIi1maWx0cmV0IFwiJXNcIiBtaXNzbHlja2FkZXMiCiAKLSM6IGRhdGUuYzoxMzcKKyM6IGRhdGUuYzoxMzgKIG1zZ2lkICJpbiB0aGUgZnV0dXJlIgogbXNnc3RyICJpIGZyYW10aWRlbiIKIAotIzogZGF0ZS5jOjE0MworIzogZGF0ZS5jOjE0NAogIywgYy1mb3JtYXQKIG1zZ2lkICIlPFBSSXVNQVg+IHNlY29uZCBhZ28iCiBtc2dpZF9wbHVyYWwgIiU8UFJJdU1BWD4gc2Vjb25kcyBhZ28iCiBtc2dzdHJbMF0gIiU8UFJJdU1BWD4gc2VrdW5kIHNlZGFuIgogbXNnc3RyWzFdICIlPFBSSXVNQVg+IHNla3VuZGVyIHNlZGFuIgogCi0jOiBkYXRlLmM6MTUwCisjOiBkYXRlLmM6MTUxCiAjLCBjLWZvcm1hdAogbXNnaWQgIiU8UFJJdU1BWD4gbWludXRlIGFnbyIKIG1zZ2lkX3BsdXJhbCAiJTxQUkl1TUFYPiBtaW51dGVzIGFnbyIKIG1zZ3N0clswXSAiJTxQUkl1TUFYPiBtaW51dCBzZWRhbiIKIG1zZ3N0clsxXSAiJTxQUkl1TUFYPiBtaW51dGVyIHNlZGFuIgogCi0jOiBkYXRlLmM6MTU3CisjOiBkYXRlLmM6MTU4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiU8UFJJdU1BWD4gaG91ciBhZ28iCiBtc2dpZF9wbHVyYWwgIiU8UFJJdU1BWD4gaG91cnMgYWdvIgogbXNnc3RyWzBdICIlPFBSSXVNQVg+IHRpbW1lIHNlZGFuIgogbXNnc3RyWzFdICIlPFBSSXVNQVg+IHRpbW1hciBzZWRhbiIKIAotIzogZGF0ZS5jOjE2NAorIzogZGF0ZS5jOjE2NQogIywgYy1mb3JtYXQKIG1zZ2lkICIlPFBSSXVNQVg+IGRheSBhZ28iCiBtc2dpZF9wbHVyYWwgIiU8UFJJdU1BWD4gZGF5cyBhZ28iCiBtc2dzdHJbMF0gIiU8UFJJdU1BWD4gZGFnIHNlZGFuIgogbXNnc3RyWzFdICIlPFBSSXVNQVg+IGRhZ2FyIHNlZGFuIgogCi0jOiBkYXRlLmM6MTcwCisjOiBkYXRlLmM6MTcxCiAjLCBjLWZvcm1hdAogbXNnaWQgIiU8UFJJdU1BWD4gd2VlayBhZ28iCiBtc2dpZF9wbHVyYWwgIiU8UFJJdU1BWD4gd2Vla3MgYWdvIgogbXNnc3RyWzBdICIlPFBSSXVNQVg+IHZlY2thIHNlZGFuIgogbXNnc3RyWzFdICIlPFBSSXVNQVg+IHZlY2tvciBzZWRhbiIKIAotIzogZGF0ZS5jOjE3NworIzogZGF0ZS5jOjE3OAogIywgYy1mb3JtYXQKIG1zZ2lkICIlPFBSSXVNQVg+IG1vbnRoIGFnbyIKIG1zZ2lkX3BsdXJhbCAiJTxQUkl1TUFYPiBtb250aHMgYWdvIgogbXNnc3RyWzBdICIlPFBSSXVNQVg+IG3DpW5hZCBzZWRhbiIKIG1zZ3N0clsxXSAiJTxQUkl1TUFYPiBtw6VuYWRlciBzZWRhbiIKIAotIzogZGF0ZS5jOjE4OAorIzogZGF0ZS5jOjE4OQogIywgYy1mb3JtYXQKIG1zZ2lkICIlPFBSSXVNQVg+IHllYXIiCiBtc2dpZF9wbHVyYWwgIiU8UFJJdU1BWD4geWVhcnMiCkBAIC0yMzUxLDE0ICsyMzYxLDE0IEBACiBtc2dzdHJbMV0gIiU8UFJJdU1BWD4gw6VyIgogCiAjLiBUUkFOU0xBVE9SUzogIiVzIiBpcyAiPG4+IHllYXJzIgotIzogZGF0ZS5jOjE5MQorIzogZGF0ZS5jOjE5MgogIywgYy1mb3JtYXQKIG1zZ2lkICIlcywgJTxQUkl1TUFYPiBtb250aCBhZ28iCiBtc2dpZF9wbHVyYWwgIiVzLCAlPFBSSXVNQVg+IG1vbnRocyBhZ28iCiBtc2dzdHJbMF0gIiVzLCAlPFBSSXVNQVg+IG3DpW5hZCBzZWRhbiIKIG1zZ3N0clsxXSAiJXMsICU8UFJJdU1BWD4gbcOlbmFkZXIgc2VkYW4iCiAKLSM6IGRhdGUuYzoxOTYgZGF0ZS5jOjIwMQorIzogZGF0ZS5jOjE5NyBkYXRlLmM6MjAyCiAjLCBjLWZvcm1hdAogbXNnaWQgIiU8UFJJdU1BWD4geWVhciBhZ28iCiBtc2dpZF9wbHVyYWwgIiU8UFJJdU1BWD4geWVhcnMgYWdvIgpAQCAtMjM5NCw3ICsyNDA0LDcgQEAKIG1zZ2lkICJmYWlsZWQgdG8gcmVhZCBvcmRlcmZpbGUgJyVzJyIKIG1zZ3N0ciAia3VuZGUgaW50ZSBsw6RzYSBvcmRlcmZpbGVuIFwiJXNcIiIKIAotIzogZGlmZmNvcmUtcmVuYW1lLmM6NTQ0CisjOiBkaWZmY29yZS1yZW5hbWUuYzo1NDMKIG1zZ2lkICJQZXJmb3JtaW5nIGluZXhhY3QgcmVuYW1lIGRldGVjdGlvbiIKIG1zZ3N0ciAiVXRmw7ZyIG9uw7ZqYWt0aWcgbmFtbmJ5dGVzZGV0ZWt0ZXJpbmciCiAKQEAgLTI0NjAsMzUgKzI0NzAsMzUgQEAKICJIaXR0YWRlIGZlbCBpIGtvbmZpZ3VyYXRpb25zdmFyaWFiZWxuIFwiZGlmZi5kaXJzdGF0XCI6XG4iCiAiJXMiCiAKLSM6IGRpZmYuYzo0MjE1CisjOiBkaWZmLmM6NDIxOAogIywgYy1mb3JtYXQKIG1zZ2lkICJleHRlcm5hbCBkaWZmIGRpZWQsIHN0b3BwaW5nIGF0ICVzIgogbXNnc3RyICJleHRlcm4gZGlmZiBkb2csIHN0YW5uYXIgdmlkICVzIgogCi0jOiBkaWZmLmM6NDU2MAorIzogZGlmZi5jOjQ1NjMKIG1zZ2lkICItLW5hbWUtb25seSwgLS1uYW1lLXN0YXR1cywgLS1jaGVjayBhbmQgLXMgYXJlIG11dHVhbGx5IGV4Y2x1c2l2ZSIKIG1zZ3N0ciAiLS1uYW1lLW9ubHksIC0tbmFtZS1zdGF0dXMsIC1jaGVjayBvY2ggLXMgw6RyIMO2bXNlc2lkaWd0IHV0ZXNsdXRhbmRlIgogCi0jOiBkaWZmLmM6NDU2MworIzogZGlmZi5jOjQ1NjYKIG1zZ2lkICItRywgLVMgYW5kIC0tZmluZC1vYmplY3QgYXJlIG11dHVhbGx5IGV4Y2x1c2l2ZSIKIG1zZ3N0ciAiLUcsIC1TIG9jaCAtLWZpbmQtb2JqZWN0IMOkciDDtm1zZXNpZGlndCB1dGVzbHV0YW5kZSIKIAotIzogZGlmZi5jOjQ2NDEKKyM6IGRpZmYuYzo0NjQ0CiBtc2dpZCAiLS1mb2xsb3cgcmVxdWlyZXMgZXhhY3RseSBvbmUgcGF0aHNwZWMiCiBtc2dzdHIgIi0tZm9sbG93IGtyw6R2ZXIgZXhha3QgZW4gc8O2a3bDpGdzYW5naXZlbHNlIgogCi0jOiBkaWZmLmM6NDY4OQorIzogZGlmZi5jOjQ2OTIKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCAtLXN0YXQgdmFsdWU6ICVzIgogbXNnc3RyICJvZ2lsdGlndCB2w6RyZGUgZsO2ciAtLXN0YXQ6ICVzIgogCi0jOiBkaWZmLmM6NDY5NCBkaWZmLmM6NDY5OSBkaWZmLmM6NDcwNCBkaWZmLmM6NDcwOSBkaWZmLmM6NTIyMgorIzogZGlmZi5jOjQ2OTcgZGlmZi5jOjQ3MDIgZGlmZi5jOjQ3MDcgZGlmZi5jOjQ3MTIgZGlmZi5jOjUyMjUKICM6IHBhcnNlLW9wdGlvbnMuYzoxOTkgcGFyc2Utb3B0aW9ucy5jOjIwMwogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyBleHBlY3RzIGEgbnVtZXJpY2FsIHZhbHVlIgogbXNnc3RyICIlcyBmw7ZydsOkbnRhciBldHQgbnVtZXJpc2t0IHbDpHJkZSIKIAotIzogZGlmZi5jOjQ3MjYKKyM6IGRpZmYuYzo0NzI5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJGYWlsZWQgdG8gcGFyc2UgLS1kaXJzdGF0Ly1YIG9wdGlvbiBwYXJhbWV0ZXI6XG4iCkBAIC0yNDk3LDQyICsyNTA3LDQyIEBACiAiTWlzc2x5Y2thZGVzIHRvbGthIGFyZ3VtZW50IHRpbGwgZmxhZ2dhbiAtLWRpcnN0YXQvLVg7XG4iCiAiJXMiCiAKLSM6IGRpZmYuYzo0ODExCisjOiBkaWZmLmM6NDgxNAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmtub3duIGNoYW5nZSBjbGFzcyAnJWMnIGluIC0tZGlmZi1maWx0ZXI9JXMiCiBtc2dzdHIgIm9rw6RuZCDDpG5kcmluZ3NrbGFzcyBcIiVjXCIgaSAtLWRpZmYtZmlsdGVyPSVzIgogCi0jOiBkaWZmLmM6NDgzNQorIzogZGlmZi5jOjQ4MzgKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5rbm93biB2YWx1ZSBhZnRlciB3cy1lcnJvci1oaWdobGlnaHQ9JS4qcyIKIG1zZ3N0ciAib2vDpG50IHbDpHJkZSBlZnRlciB3cy1lcnJvci1oaWdobGlnaHQ9JS4qcyIKIAotIzogZGlmZi5jOjQ4NDkKKyM6IGRpZmYuYzo0ODUyCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byByZXNvbHZlICclcyciCiBtc2dzdHIgImt1bmRlIGludGUgc2zDpSB1cHAgXCIlc1wiIgogCi0jOiBkaWZmLmM6NDg5OSBkaWZmLmM6NDkwNQorIzogZGlmZi5jOjQ5MDIgZGlmZi5jOjQ5MDgKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgZXhwZWN0cyA8bj4vPG0+IGZvcm0iCiBtc2dzdHIgIiVzIGbDtnJ2w6RudGFyIGZvcm1lbiA8bj4vPG0+IgogCi0jOiBkaWZmLmM6NDkxNworIzogZGlmZi5jOjQ5MjAKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgZXhwZWN0cyBhIGNoYXJhY3RlciwgZ290ICclcyciCiBtc2dzdHIgIiVzIGbDtnJ2w6RudGFyIGV0dCB0ZWNrZW4sIGZpY2sgXCIlc1wiIgogCi0jOiBkaWZmLmM6NDkzOAorIzogZGlmZi5jOjQ5NDEKICMsIGMtZm9ybWF0CiBtc2dpZCAiYmFkIC0tY29sb3ItbW92ZWQgYXJndW1lbnQ6ICVzIgogbXNnc3RyICJmZWxha3RpZ3QgYXJndW1lbnQgdGlsbCAtLWNvbG9yLW1vdmVkOiAlcyIKIAotIzogZGlmZi5jOjQ5NTcKKyM6IGRpZmYuYzo0OTYwCiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgbW9kZSAnJXMnIGluIC0tY29sb3ItbW92ZWQtd3MiCiBtc2dzdHIgIm9naWx0aWd0IGzDpGdlICVzXCIgaSAtLWNvbG9yLW1vdmVkLXdzIgogCi0jOiBkaWZmLmM6NDk5NworIzogZGlmZi5jOjUwMDAKIG1zZ2lkICIiCiAib3B0aW9uIGRpZmYtYWxnb3JpdGhtIGFjY2VwdHMgXCJteWVyc1wiLCBcIm1pbmltYWxcIiwgXCJwYXRpZW5jZVwiIGFuZCAiCiAiXCJoaXN0b2dyYW1cIiIKQEAgLTI1NDAsMTQ5ICsyNTUwLDE0OSBAQAogImZsYWdnYW4gZGlmZi1hbGdvcml0aG0gZ29kdGFyXCJteWVyc1wiLCBcIm1pbmltYWxcIiwgXCJwYXRpZW5jZVwiIG9jaCAiCiAiXCJoaXN0b2dyYW1cIiIKIAotIzogZGlmZi5jOjUwMzMgZGlmZi5jOjUwNTMKKyM6IGRpZmYuYzo1MDM2IGRpZmYuYzo1MDU2CiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgYXJndW1lbnQgdG8gJXMiCiBtc2dzdHIgIm9naWx0aWd0IGFyZ3VtZW50IGbDtnIgJXMiCiAKLSM6IGRpZmYuYzo1MTkxCisjOiBkaWZmLmM6NTE5NAogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gcGFyc2UgLS1zdWJtb2R1bGUgb3B0aW9uIHBhcmFtZXRlcjogJyVzJyIKIG1zZ3N0ciAibWlzc2x5Y2thZGVzIHRvbGthIGFyZ3VtZW50IHRpbGwgZmxhZ2dhbiAtLXN1Ym1vZHVsZTogXCIlc1wiIgogCi0jOiBkaWZmLmM6NTI0NworIzogZGlmZi5jOjUyNTAKICMsIGMtZm9ybWF0CiBtc2dpZCAiYmFkIC0td29yZC1kaWZmIGFyZ3VtZW50OiAlcyIKIG1zZ3N0ciAiZmVsYWt0aWd0IGFyZ3VtZW50IC0td29yZC1kaWZmOiAlcyIKIAotIzogZGlmZi5jOjUyNzAKKyM6IGRpZmYuYzo1MjczCiBtc2dpZCAiRGlmZiBvdXRwdXQgZm9ybWF0IG9wdGlvbnMiCiBtc2dzdHIgIkZvcm1hdGZsYWdnb3IgZsO2ciBkaWZmLXV0ZGF0YSIKIAotIzogZGlmZi5jOjUyNzIgZGlmZi5jOjUyNzgKKyM6IGRpZmYuYzo1Mjc1IGRpZmYuYzo1MjgxCiBtc2dpZCAiZ2VuZXJhdGUgcGF0Y2giCiBtc2dzdHIgInNrYXBhciBwYXRjaCIKIAotIzogZGlmZi5jOjUyNzUgYnVpbHRpbi9sb2cuYzoxODIKKyM6IGRpZmYuYzo1Mjc4IGJ1aWx0aW4vbG9nLmM6MTcyCiBtc2dpZCAic3VwcHJlc3MgZGlmZiBvdXRwdXQiCiBtc2dzdHIgInVuZGVydHJ5Y2sgZGlmZi11dGRhdGEiCiAKLSM6IGRpZmYuYzo1MjgwIGRpZmYuYzo1Mzk0IGRpZmYuYzo1NDAxCisjOiBkaWZmLmM6NTI4MyBkaWZmLmM6NTM5NyBkaWZmLmM6NTQwNAogbXNnaWQgIjxuPiIKIG1zZ3N0ciAiPG4+IgogCi0jOiBkaWZmLmM6NTI4MSBkaWZmLmM6NTI4NAorIzogZGlmZi5jOjUyODQgZGlmZi5jOjUyODcKIG1zZ2lkICJnZW5lcmF0ZSBkaWZmcyB3aXRoIDxuPiBsaW5lcyBjb250ZXh0IgogbXNnc3RyICJza2FwYSBkaWZmYXIgbWVkIDxuPiByYWRlciBzYW1tYW5oYW5nIgogCi0jOiBkaWZmLmM6NTI4NgorIzogZGlmZi5jOjUyODkKIG1zZ2lkICJnZW5lcmF0ZSB0aGUgZGlmZiBpbiByYXcgZm9ybWF0IgogbXNnc3RyICJnZW5lcmVyYSBkaWZmIGkgcsOlZm9ybWF0IgogCi0jOiBkaWZmLmM6NTI4OQorIzogZGlmZi5jOjUyOTIKIG1zZ2lkICJzeW5vbnltIGZvciAnLXAgLS1yYXcnIgogbXNnc3RyICJzeW5vbnltIHRpbGwgXCItcCAtLXJhd1wiIgogCi0jOiBkaWZmLmM6NTI5MworIzogZGlmZi5jOjUyOTYKIG1zZ2lkICJzeW5vbnltIGZvciAnLXAgLS1zdGF0JyIKIG1zZ3N0ciAic3lub255bSB0aWxsIFwiLXAgLS1zdGF0XCIiCiAKLSM6IGRpZmYuYzo1Mjk3CisjOiBkaWZmLmM6NTMwMAogbXNnaWQgIm1hY2hpbmUgZnJpZW5kbHkgLS1zdGF0IgogbXNnc3RyICJtYXNraW5sw6RzYmFyIC0tc3RhdCIKIAotIzogZGlmZi5jOjUzMDAKKyM6IGRpZmYuYzo1MzAzCiBtc2dpZCAib3V0cHV0IG9ubHkgdGhlIGxhc3QgbGluZSBvZiAtLXN0YXQiCiBtc2dzdHIgInNrcml2IGJhcmEgdXQgZGVuIHNpc3RhIHJhZGVuIGbDtnIgLS1zdGF0IgogCi0jOiBkaWZmLmM6NTMwMiBkaWZmLmM6NTMxMAorIzogZGlmZi5jOjUzMDUgZGlmZi5jOjUzMTMKIG1zZ2lkICI8cGFyYW0xLHBhcmFtMj4uLi4iCiBtc2dzdHIgIjxwYXJhbTEscGFyYW0yPi4uLiIKIAotIzogZGlmZi5jOjUzMDMKKyM6IGRpZmYuYzo1MzA2CiBtc2dpZCAiIgogIm91dHB1dCB0aGUgZGlzdHJpYnV0aW9uIG9mIHJlbGF0aXZlIGFtb3VudCBvZiBjaGFuZ2VzIGZvciBlYWNoIHN1Yi1kaXJlY3RvcnkiCiBtc2dzdHIgIiIKICJza3JpdiB1dCBkaXN0cmlidXRpb25lbiBhdiByZWxhdGl2YSBtw6RuZ2RlciDDpG5kcmluZ2FyIGbDtnIgdmFyamUgdW5kZXJrYXRhbG9nIgogCi0jOiBkaWZmLmM6NTMwNworIzogZGlmZi5jOjUzMTAKIG1zZ2lkICJzeW5vbnltIGZvciAtLWRpcnN0YXQ9Y3VtdWxhdGl2ZSIKIG1zZ3N0ciAic3lub255bSBmw7ZyIC0tZGlyc3RhdD1jdW11bGF0aXZlIgogCi0jOiBkaWZmLmM6NTMxMQorIzogZGlmZi5jOjUzMTQKIG1zZ2lkICJzeW5vbnltIGZvciAtLWRpcnN0YXQ9ZmlsZXMscGFyYW0xLHBhcmFtMi4uLiIKIG1zZ3N0ciAic3lub255bSBmw7ZyIC0tZGlyc3RhdD1maWxlcixwYXJhbTEscGFyYW0yLi4uIgogCi0jOiBkaWZmLmM6NTMxNQorIzogZGlmZi5jOjUzMTgKIG1zZ2lkICJ3YXJuIGlmIGNoYW5nZXMgaW50cm9kdWNlIGNvbmZsaWN0IG1hcmtlcnMgb3Igd2hpdGVzcGFjZSBlcnJvcnMiCiBtc2dzdHIgInZhcm5hIG9tIMOkbmRyaW5nYXIgaW50cm9kdWNlcmFyIGtvbmZsaWt0bWFya8O2cmVyIGVsbGVyIGJsYW5rc3RlZ3NmZWwiCiAKLSM6IGRpZmYuYzo1MzE4CisjOiBkaWZmLmM6NTMyMQogbXNnaWQgImNvbmRlbnNlZCBzdW1tYXJ5IHN1Y2ggYXMgY3JlYXRpb25zLCByZW5hbWVzIGFuZCBtb2RlIGNoYW5nZXMiCiBtc2dzdHIgImtvcnRmYXR0YWQgc3VtbWVyaW5nIHPDpXNvbSBza2FwYWRlLCBuYW1uYnl0ZW4gb2NoIMOkbmRyYWRlIGzDpGdlbiIKIAotIzogZGlmZi5jOjUzMjEKKyM6IGRpZmYuYzo1MzI0CiBtc2dpZCAic2hvdyBvbmx5IG5hbWVzIG9mIGNoYW5nZWQgZmlsZXMiCiBtc2dzdHIgInZpc2EgZW5kYXN0IG5hbW5lbiBww6Ugw6RuZHJhZGUgZmlsZXIiCiAKLSM6IGRpZmYuYzo1MzI0CisjOiBkaWZmLmM6NTMyNwogbXNnaWQgInNob3cgb25seSBuYW1lcyBhbmQgc3RhdHVzIG9mIGNoYW5nZWQgZmlsZXMiCiBtc2dzdHIgInZpc2EgZW5kYXN0IG5hbW4gb2NoIHN0YXR1cyBmw7ZyIMOkbmRyYWRlIGZpbGVyIgogCi0jOiBkaWZmLmM6NTMyNgorIzogZGlmZi5jOjUzMjkKIG1zZ2lkICI8d2lkdGg+Wyw8bmFtZS13aWR0aD5bLDxjb3VudD5dXSIKIG1zZ3N0ciAiPGJyZWRkPlssPG5hbW4tYnJlZGQ+Wyw8YW50YWw+XV0iCiAKLSM6IGRpZmYuYzo1MzI3CisjOiBkaWZmLmM6NTMzMAogbXNnaWQgImdlbmVyYXRlIGRpZmZzdGF0IgogbXNnc3RyICJza2FwYSBkaWZmc3RhdCIKIAotIzogZGlmZi5jOjUzMjkgZGlmZi5jOjUzMzIgZGlmZi5jOjUzMzUKKyM6IGRpZmYuYzo1MzMyIGRpZmYuYzo1MzM1IGRpZmYuYzo1MzM4CiBtc2dpZCAiPHdpZHRoPiIKIG1zZ3N0ciAiPGJyZWRkPiIKIAotIzogZGlmZi5jOjUzMzAKKyM6IGRpZmYuYzo1MzMzCiBtc2dpZCAiZ2VuZXJhdGUgZGlmZnN0YXQgd2l0aCBhIGdpdmVuIHdpZHRoIgogbXNnc3RyICJnZW5lcmVyYSBlbiBkaWZmc3RhdCBtZWQgZ2l2ZW4gYnJlZGQiCiAKLSM6IGRpZmYuYzo1MzMzCisjOiBkaWZmLmM6NTMzNgogbXNnaWQgImdlbmVyYXRlIGRpZmZzdGF0IHdpdGggYSBnaXZlbiBuYW1lIHdpZHRoIgogbXNnc3RyICJnZW5lcmVyYSBlbiBkaWZmc3RhdCBtZWQgZ2l2ZW4gbmFtbmJyZWRkIgogCi0jOiBkaWZmLmM6NTMzNgorIzogZGlmZi5jOjUzMzkKIG1zZ2lkICJnZW5lcmF0ZSBkaWZmc3RhdCB3aXRoIGEgZ2l2ZW4gZ3JhcGggd2lkdGgiCiBtc2dzdHIgImdlbmVyZXJhIGVuIGRpZmZzdGF0IG1lZCBnaXZlbiBncmFmYnJlZGQiCiAKLSM6IGRpZmYuYzo1MzM4CisjOiBkaWZmLmM6NTM0MQogbXNnaWQgIjxjb3VudD4iCiBtc2dzdHIgIjxhbnRhbD4iCiAKLSM6IGRpZmYuYzo1MzM5CisjOiBkaWZmLmM6NTM0MgogbXNnaWQgImdlbmVyYXRlIGRpZmZzdGF0IHdpdGggbGltaXRlZCBsaW5lcyIKIG1zZ3N0ciAiZ2VuZXJlcmEgZGlmZnN0YXQgbWVkIGJlZ3LDpG5zYWRlIHJhZGVyIgogCi0jOiBkaWZmLmM6NTM0MgorIzogZGlmZi5jOjUzNDUKIG1zZ2lkICJnZW5lcmF0ZSBjb21wYWN0IHN1bW1hcnkgaW4gZGlmZnN0YXQiCiBtc2dzdHIgInNrYXBhIGtvbXBha3Qgw7Z2ZXJzaWt0IGkgZGlmZnN0YXQiCiAKLSM6IGRpZmYuYzo1MzQ1CisjOiBkaWZmLmM6NTM0OAogbXNnaWQgIm91dHB1dCBhIGJpbmFyeSBkaWZmIHRoYXQgY2FuIGJlIGFwcGxpZWQiCiBtc2dzdHIgInNrYXBhIGVuIGJpbsOkcmRpZmYgc29tIGthbiBhcHBsaWNlcmFzIgogCi0jOiBkaWZmLmM6NTM0OAorIzogZGlmZi5jOjUzNTEKIG1zZ2lkICJzaG93IGZ1bGwgcHJlLSBhbmQgcG9zdC1pbWFnZSBvYmplY3QgbmFtZXMgb24gdGhlIFwiaW5kZXhcIiBsaW5lcyIKIG1zZ3N0ciAiIgogInZpc2EgZnVsbHN0w6RuZGlnYSBvYmpla3RuYW1uIGkgXCJpbmRleFwiLXJhZGVyIGbDtnIgbMOkZ2V0IGLDpWRlIGbDtnJlIG9jaCBlZnRlciIKIAotIzogZGlmZi5jOjUzNTAKKyM6IGRpZmYuYzo1MzUzCiBtc2dpZCAic2hvdyBjb2xvcmVkIGRpZmYiCiBtc2dzdHIgInZpc2EgZsOkcmdhZCBkaWZmIgogCi0jOiBkaWZmLmM6NTM1MQorIzogZGlmZi5jOjUzNTQKIG1zZ2lkICI8a2luZD4iCiBtc2dzdHIgIjx0eXA+IgogCi0jOiBkaWZmLmM6NTM1MgorIzogZGlmZi5jOjUzNTUKIG1zZ2lkICIiCiAiaGlnaGxpZ2h0IHdoaXRlc3BhY2UgZXJyb3JzIGluIHRoZSAnY29udGV4dCcsICdvbGQnIG9yICduZXcnIGxpbmVzIGluIHRoZSAiCiAiZGlmZiIKQEAgLTI2OTAsNyArMjcwMCw3IEBACiAibGp1c21hcmtlcmEgYmxhbmtzdGVnc2ZlbCBpIFwiY29udGV4dFwiIChzYW1tYW5oYW5nKSwgXCJvbGRcIiAoZ2FtbGEpIGVsbGVyICIKICJcIm5ld1wiIChueWEpIHJhZGVyIGkgZGlmZmVuIgogCi0jOiBkaWZmLmM6NTM1NQorIzogZGlmZi5jOjUzNTgKIG1zZ2lkICIiCiAiZG8gbm90IG11bmdlIHBhdGhuYW1lcyBhbmQgdXNlIE5VTHMgYXMgb3V0cHV0IGZpZWxkIHRlcm1pbmF0b3JzIGluIC0tcmF3IG9yICIKICItLW51bXN0YXQiCkBAIC0yNjk4LDg3ICsyNzA4LDg3IEBACiAic2tyaXYgaW50ZSBvbSBzw7ZrdsOkZ3NuYW1uIG9jaCBhbnbDpG5kIE5VTC10ZWNrZW4gc29tIGbDpGx0c2VwYXJlcmFyZSBpIC0tcmF3ICIKICJlbGxlciAtLW51bXN0YXQiCiAKLSM6IGRpZmYuYzo1MzU4IGRpZmYuYzo1MzYxIGRpZmYuYzo1MzY0IGRpZmYuYzo1NDcwCisjOiBkaWZmLmM6NTM2MSBkaWZmLmM6NTM2NCBkaWZmLmM6NTM2NyBkaWZmLmM6NTQ3MwogbXNnaWQgIjxwcmVmaXg+IgogbXNnc3RyICI8cHJlZml4PiIKIAotIzogZGlmZi5jOjUzNTkKKyM6IGRpZmYuYzo1MzYyCiBtc2dpZCAic2hvdyB0aGUgZ2l2ZW4gc291cmNlIHByZWZpeCBpbnN0ZWFkIG9mIFwiYS9cIiIKIG1zZ3N0ciAidmlzYSBnaXZldCBrw6RsbHByZWZpeCBpc3TDpGxsZXQgZsO2ciBcImEvXCIiCiAKLSM6IGRpZmYuYzo1MzYyCisjOiBkaWZmLmM6NTM2NQogbXNnaWQgInNob3cgdGhlIGdpdmVuIGRlc3RpbmF0aW9uIHByZWZpeCBpbnN0ZWFkIG9mIFwiYi9cIiIKIG1zZ3N0ciAidmlzYSBnaXZldCBtw6VscHJlZml4IGlzdMOkbGxldCBmw7ZyIFwiYi9cIiIKIAotIzogZGlmZi5jOjUzNjUKKyM6IGRpZmYuYzo1MzY4CiBtc2dpZCAicHJlcGVuZCBhbiBhZGRpdGlvbmFsIHByZWZpeCB0byBldmVyeSBsaW5lIG9mIG91dHB1dCIKIG1zZ3N0ciAibMOkZ2cgdGlsbCB5dHRlcmxpZ2FyZSBwcmVmaXggcMOlIGFsbGEgcmFkZXIgaSB1dGRhdGEiCiAKLSM6IGRpZmYuYzo1MzY4CisjOiBkaWZmLmM6NTM3MQogbXNnaWQgImRvIG5vdCBzaG93IGFueSBzb3VyY2Ugb3IgZGVzdGluYXRpb24gcHJlZml4IgogbXNnc3RyICJ2aXNhIGludGUga8OkbGwtIGVsbGVyIG3DpWxwcmVmaXgiCiAKLSM6IGRpZmYuYzo1MzcxCisjOiBkaWZmLmM6NTM3NAogbXNnaWQgInNob3cgY29udGV4dCBiZXR3ZWVuIGRpZmYgaHVua3MgdXAgdG8gdGhlIHNwZWNpZmllZCBudW1iZXIgb2YgbGluZXMiCiBtc2dzdHIgInZpc2Egc2FtbW5oYW5nIG1lbGxhbiBkaWZmLXN0eWNrZW4gdXBwIHRpbGwgYW5naXZldCBhbnRhbCByYWRlciIKIAotIzogZGlmZi5jOjUzNzUgZGlmZi5jOjUzODAgZGlmZi5jOjUzODUKKyM6IGRpZmYuYzo1Mzc4IGRpZmYuYzo1MzgzIGRpZmYuYzo1Mzg4CiBtc2dpZCAiPGNoYXI+IgogbXNnc3RyICI8dGVja2VuPiIKIAotIzogZGlmZi5jOjUzNzYKKyM6IGRpZmYuYzo1Mzc5CiBtc2dpZCAic3BlY2lmeSB0aGUgY2hhcmFjdGVyIHRvIGluZGljYXRlIGEgbmV3IGxpbmUgaW5zdGVhZCBvZiAnKyciCiBtc2dzdHIgImFuZ2UgdGVja2VuIGbDtnIgYXR0IGFuZ2UgbnkgcmFkIGlzdMOkbGxldCBmw7ZyIFwiK1wiIgogCi0jOiBkaWZmLmM6NTM4MQorIzogZGlmZi5jOjUzODQKIG1zZ2lkICJzcGVjaWZ5IHRoZSBjaGFyYWN0ZXIgdG8gaW5kaWNhdGUgYW4gb2xkIGxpbmUgaW5zdGVhZCBvZiAnLSciCiBtc2dzdHIgImFuZ2UgdGVja2VuIGbDtnIgYXR0IGFuZ2UgZ2FtbWFsIHJhZCBpc3TDpGxsZXQgZsO2ciBcIi1cIiIKIAotIzogZGlmZi5jOjUzODYKKyM6IGRpZmYuYzo1Mzg5CiBtc2dpZCAic3BlY2lmeSB0aGUgY2hhcmFjdGVyIHRvIGluZGljYXRlIGEgY29udGV4dCBpbnN0ZWFkIG9mICcgJyIKIG1zZ3N0ciAiYW5nZSB0ZWNrZW4gZsO2ciBhdHQgYW5nZSBzYW1tYW5oYW5nIGlzdMOkbGxldCBmw7ZyIFwiIFwiIgogCi0jOiBkaWZmLmM6NTM4OQorIzogZGlmZi5jOjUzOTIKIG1zZ2lkICJEaWZmIHJlbmFtZSBvcHRpb25zIgogbXNnc3RyICJEaWZmLW5hbW5ieXRlc2ZsYWdnb3IiCiAKLSM6IGRpZmYuYzo1MzkwCisjOiBkaWZmLmM6NTM5MwogbXNnaWQgIjxuPlsvPG0+XSIKIG1zZ3N0ciAiPG4+Wy88bT5dIgogCi0jOiBkaWZmLmM6NTM5MQorIzogZGlmZi5jOjUzOTQKIG1zZ2lkICJicmVhayBjb21wbGV0ZSByZXdyaXRlIGNoYW5nZXMgaW50byBwYWlycyBvZiBkZWxldGUgYW5kIGNyZWF0ZSIKIG1zZ3N0ciAiZGVsYSB1cHAga29tcGxldHRhIG9tc2tyaXZuaW5nYXIgdGlsbCB0YSBib3J0IG9jaCBza2FwYS1wYXIiCiAKLSM6IGRpZmYuYzo1Mzk1CisjOiBkaWZmLmM6NTM5OAogbXNnaWQgImRldGVjdCByZW5hbWVzIgogbXNnc3RyICJkZXRla3RlcmEgbmFtbsOkbmRyaW5nYXIiCiAKLSM6IGRpZmYuYzo1Mzk5CisjOiBkaWZmLmM6NTQwMgogbXNnaWQgIm9taXQgdGhlIHByZWltYWdlIGZvciBkZWxldGVzIgogbXNnc3RyICJ0YSBib3J0IGbDtnItdmVyc2lvbiBmw7ZyIGJvcnR0YWduaW5nYXIiCiAKLSM6IGRpZmYuYzo1NDAyCisjOiBkaWZmLmM6NTQwNQogbXNnaWQgImRldGVjdCBjb3BpZXMiCiBtc2dzdHIgImRldGVrdGVyYSBrb3Bpb3IiCiAKLSM6IGRpZmYuYzo1NDA2CisjOiBkaWZmLmM6NTQwOQogbXNnaWQgInVzZSB1bm1vZGlmaWVkIGZpbGVzIGFzIHNvdXJjZSB0byBmaW5kIGNvcGllcyIKIG1zZ3N0ciAiYW52w6RuZCBvZsO2csOkbmRyYWRlIHNvbSBrw6RsbGEgZsO2ciBhdHQgaGl0dGEga29waW9yIgogCi0jOiBkaWZmLmM6NTQwOAorIzogZGlmZi5jOjU0MTEKIG1zZ2lkICJkaXNhYmxlIHJlbmFtZSBkZXRlY3Rpb24iCiBtc2dzdHIgImluYWt0aXZlcmEgZGV0ZWt0ZXJpbmcgYXYgbmFtbmJ5dGVuIgogCi0jOiBkaWZmLmM6NTQxMQorIzogZGlmZi5jOjU0MTQKIG1zZ2lkICJ1c2UgZW1wdHkgYmxvYnMgYXMgcmVuYW1lIHNvdXJjZSIKIG1zZ3N0ciAiYW52w6RuZCB0b21tYSBibG9iOmFyIHNvbSBuYW1uw6RuZHJpbmdza8OkbGxhIgogCi0jOiBkaWZmLmM6NTQxMworIzogZGlmZi5jOjU0MTYKIG1zZ2lkICJjb250aW51ZSBsaXN0aW5nIHRoZSBoaXN0b3J5IG9mIGEgZmlsZSBiZXlvbmQgcmVuYW1lcyIKIG1zZ3N0ciAiZm9ydHPDpHR0IGxpc3RhIGhpc3RvcmlrZW4gZsO2ciBlbiBmaWwgYm9ydG9tIG5hbW7DpG5kcmluZ2FyIgogCi0jOiBkaWZmLmM6NTQxNgorIzogZGlmZi5jOjU0MTkKIG1zZ2lkICIiCiAicHJldmVudCByZW5hbWUvY29weSBkZXRlY3Rpb24gaWYgdGhlIG51bWJlciBvZiByZW5hbWUvY29weSB0YXJnZXRzIGV4Y2VlZHMgIgogImdpdmVuIGxpbWl0IgpAQCAtMjc4NiwxNTkgKzI3OTYsMTU5IEBACiAiZsO2cmhpbmRyYSBuYW1uYnl0ZS9rb3BpZS1kZXRla3RlcmluZyBvbSBhbnRhbGV0IG5hbW5ieXRlbi9rb3Bpb3Igw7Z2ZXJza3JpdmVyICIKICJnaXZlbiBncsOkbnMiCiAKLSM6IGRpZmYuYzo1NDE4CisjOiBkaWZmLmM6NTQyMQogbXNnaWQgIkRpZmYgYWxnb3JpdGhtIG9wdGlvbnMiCiBtc2dzdHIgIkFsdGVybmF0aXYgZsO2ciBkaWZmLWFsZ29yaXRtIgogCi0jOiBkaWZmLmM6NTQyMAorIzogZGlmZi5jOjU0MjMKIG1zZ2lkICJwcm9kdWNlIHRoZSBzbWFsbGVzdCBwb3NzaWJsZSBkaWZmIgogbXNnc3RyICJza2FwYSBtaW5zdGEgbcO2amxpZ2EgZGlmZiIKIAotIzogZGlmZi5jOjU0MjMKKyM6IGRpZmYuYzo1NDI2CiBtc2dpZCAiaWdub3JlIHdoaXRlc3BhY2Ugd2hlbiBjb21wYXJpbmcgbGluZXMiCiBtc2dzdHIgImlnbm9yZXJhIGJsYW5rdGVja2VuIHZpZCByYWRqw6RtZsO2cmVsc2UiCiAKLSM6IGRpZmYuYzo1NDI2CisjOiBkaWZmLmM6NTQyOQogbXNnaWQgImlnbm9yZSBjaGFuZ2VzIGluIGFtb3VudCBvZiB3aGl0ZXNwYWNlIgogbXNnc3RyICJpZ25vcmVyYSDDpG5kcmluZ2FyIGkgYW50YWwgYmxhbmt0ZWNrZW4gdmlkIHJhZGrDpG1mw7ZyZWxzZSIKIAotIzogZGlmZi5jOjU0MjkKKyM6IGRpZmYuYzo1NDMyCiBtc2dpZCAiaWdub3JlIGNoYW5nZXMgaW4gd2hpdGVzcGFjZSBhdCBFT0wiCiBtc2dzdHIgImlnbm9yZXJhIGJsYW5rdGVja2VuIHZpZCByYWRzbHV0IgogCi0jOiBkaWZmLmM6NTQzMgorIzogZGlmZi5jOjU0MzUKIG1zZ2lkICJpZ25vcmUgY2Fycmllci1yZXR1cm4gYXQgdGhlIGVuZCBvZiBsaW5lIgogbXNnc3RyICJpZ25vcmVyYSBDUi10ZWNrZW4gdmlkIHJhZHNsdXQiCiAKLSM6IGRpZmYuYzo1NDM1CisjOiBkaWZmLmM6NTQzOAogbXNnaWQgImlnbm9yZSBjaGFuZ2VzIHdob3NlIGxpbmVzIGFyZSBhbGwgYmxhbmsiCiBtc2dzdHIgImlnbm9yZXJhIMOkbmRyaW5nYXIgaSByYWRlciBzb20gw6RyIGhlbHQgYmxhbmthIgogCi0jOiBkaWZmLmM6NTQzOAorIzogZGlmZi5jOjU0NDEKIG1zZ2lkICJoZXVyaXN0aWMgdG8gc2hpZnQgZGlmZiBodW5rIGJvdW5kYXJpZXMgZm9yIGVhc3kgcmVhZGluZyIKIG1zZ3N0ciAiaGV1cmlzdGlrIGbDtnIgYXR0IGZseXR0YSBkaWZmLWdyw6Ruc2VyIGbDtnIgbMOkdHRhcmUgbMOkc25pbmciCiAKLSM6IGRpZmYuYzo1NDQxCisjOiBkaWZmLmM6NTQ0NAogbXNnaWQgImdlbmVyYXRlIGRpZmYgdXNpbmcgdGhlIFwicGF0aWVuY2UgZGlmZlwiIGFsZ29yaXRobSIKIG1zZ3N0ciAic2thcGEgZGlmZmFyIG1lZCBhbGdvcml0bWVuIFwicGF0aWVuY2UgZGlmZlwiIgogCi0jOiBkaWZmLmM6NTQ0NQorIzogZGlmZi5jOjU0NDgKIG1zZ2lkICJnZW5lcmF0ZSBkaWZmIHVzaW5nIHRoZSBcImhpc3RvZ3JhbSBkaWZmXCIgYWxnb3JpdGhtIgogbXNnc3RyICJza2FwYSBkaWZmYXIgbWVkIGFsZ29yaXRtZW4gXCJoaXN0b2dyYW0gZGlmZlwiIgogCi0jOiBkaWZmLmM6NTQ0NworIzogZGlmZi5jOjU0NTAKIG1zZ2lkICI8YWxnb3JpdGhtPiIKIG1zZ3N0ciAiPGFsZ29yaXRtPiIKIAotIzogZGlmZi5jOjU0NDgKKyM6IGRpZmYuYzo1NDUxCiBtc2dpZCAiY2hvb3NlIGEgZGlmZiBhbGdvcml0aG0iCiBtc2dzdHIgInbDpGxqIGVuIGRpZmYtYWxnb3JpdG0iCiAKLSM6IGRpZmYuYzo1NDUwCisjOiBkaWZmLmM6NTQ1MwogbXNnaWQgIjx0ZXh0PiIKIG1zZ3N0ciAiPHRleHQ+IgogCi0jOiBkaWZmLmM6NTQ1MQorIzogZGlmZi5jOjU0NTQKIG1zZ2lkICJnZW5lcmF0ZSBkaWZmIHVzaW5nIHRoZSBcImFuY2hvcmVkIGRpZmZcIiBhbGdvcml0aG0iCiBtc2dzdHIgInNrYXBhIGRpZmZhciBtZWQgYWxnb3JpdG1lbiBcImFuY2hvcmVkIGRpZmZcIiIKIAotIzogZGlmZi5jOjU0NTMgZGlmZi5jOjU0NjIgZGlmZi5jOjU0NjUKKyM6IGRpZmYuYzo1NDU2IGRpZmYuYzo1NDY1IGRpZmYuYzo1NDY4CiBtc2dpZCAiPG1vZGU+IgogbXNnc3RyICI8bMOkZ2U+IgogCi0jOiBkaWZmLmM6NTQ1NAorIzogZGlmZi5jOjU0NTcKIG1zZ2lkICJzaG93IHdvcmQgZGlmZiwgdXNpbmcgPG1vZGU+IHRvIGRlbGltaXQgY2hhbmdlZCB3b3JkcyIKIG1zZ3N0ciAidmlzYSBvcmRkaWZmLCBkw6RyIDxsw6RnZT4gYXZncsOkbnNhciDDpG5kcmFkZSBvcmQiCiAKLSM6IGRpZmYuYzo1NDU2IGRpZmYuYzo1NDU5IGRpZmYuYzo1NTA0CisjOiBkaWZmLmM6NTQ1OSBkaWZmLmM6NTQ2MiBkaWZmLmM6NTUwNwogbXNnaWQgIjxyZWdleD4iCiBtc2dzdHIgIjxyZWd1dHRyPiIKIAotIzogZGlmZi5jOjU0NTcKKyM6IGRpZmYuYzo1NDYwCiBtc2dpZCAidXNlIDxyZWdleD4gdG8gZGVjaWRlIHdoYXQgYSB3b3JkIGlzIgogbXNnc3RyICJhbnbDpG5kIDxyZWd1dHRyPiBmw7ZyIGF0dCBiZXN0w6RtbWEgdmFkIHNvbSDDpHIgZXR0IG9yZCIKIAotIzogZGlmZi5jOjU0NjAKKyM6IGRpZmYuYzo1NDYzCiBtc2dpZCAiZXF1aXZhbGVudCB0byAtLXdvcmQtZGlmZj1jb2xvciAtLXdvcmQtZGlmZi1yZWdleD08cmVnZXg+IgogbXNnc3RyICJtb3RzdmFyYXIgLS13b3JkLWRpZmY9Y29sb3IgLS13b3JkLWRpZmYtcmVnZXg9PHJlZ3V0dHI+IgogCi0jOiBkaWZmLmM6NTQ2MworIzogZGlmZi5jOjU0NjYKIG1zZ2lkICJtb3ZlZCBsaW5lcyBvZiBjb2RlIGFyZSBjb2xvcmVkIGRpZmZlcmVudGx5IgogbXNnc3RyICJmbHl0dGFkZSBrb2RyYWRlciBmw6RyZ2FzIHDDpSBhbm5hdCBzw6R0dCIKIAotIzogZGlmZi5jOjU0NjYKKyM6IGRpZmYuYzo1NDY5CiBtc2dpZCAiaG93IHdoaXRlIHNwYWNlcyBhcmUgaWdub3JlZCBpbiAtLWNvbG9yLW1vdmVkIgogbXNnc3RyICJodXIgYmxhbmt0ZWNrZW4gaWdub3JlcmFzIGkgLS1jb2xvci1tb3ZlZCIKIAotIzogZGlmZi5jOjU0NjkKKyM6IGRpZmYuYzo1NDcyCiBtc2dpZCAiT3RoZXIgZGlmZiBvcHRpb25zIgogbXNnc3RyICJBbmRyYSBkaWZmLWZsYWdnb3IiCiAKLSM6IGRpZmYuYzo1NDcxCisjOiBkaWZmLmM6NTQ3NAogbXNnaWQgIndoZW4gcnVuIGZyb20gc3ViZGlyLCBleGNsdWRlIGNoYW5nZXMgb3V0c2lkZSBhbmQgc2hvdyByZWxhdGl2ZSBwYXRocyIKIG1zZ3N0ciAiIgogInZpZCBzdGFydCBmcsOlbiB1bmRlcmthdGFsb2csIHV0ZXNsdXQgw6RuZHJpbmdhciB1dGFuZsO2ciBvY2ggdmlzYSByZWxhdGl2YSAiCiAic8O2a3bDpGdhciIKIAotIzogZGlmZi5jOjU0NzUKKyM6IGRpZmYuYzo1NDc4CiBtc2dpZCAidHJlYXQgYWxsIGZpbGVzIGFzIHRleHQiCiBtc2dzdHIgImhhbnRlcmEgYWxsYSBmaWxlciBzb20gdGV4dCIKIAotIzogZGlmZi5jOjU0NzcKKyM6IGRpZmYuYzo1NDgwCiBtc2dpZCAic3dhcCB0d28gaW5wdXRzLCByZXZlcnNlIHRoZSBkaWZmIgogbXNnc3RyICJ2w6R4bGEgdHbDpSBpbmRhdGFmaWxlciwgdsOkbmQgZGlmZmVuIgogCi0jOiBkaWZmLmM6NTQ3OQorIzogZGlmZi5jOjU0ODIKIG1zZ2lkICJleGl0IHdpdGggMSBpZiB0aGVyZSB3ZXJlIGRpZmZlcmVuY2VzLCAwIG90aGVyd2lzZSIKIG1zZ3N0ciAiYXZzbHV0YSBtZWQgMSB2aWQgw6RuZHJpbmdhciwgYW5uYXJzIDAiCiAKLSM6IGRpZmYuYzo1NDgxCisjOiBkaWZmLmM6NTQ4NAogbXNnaWQgImRpc2FibGUgYWxsIG91dHB1dCBvZiB0aGUgcHJvZ3JhbSIKIG1zZ3N0ciAic2zDpSBhdiBhbGxhIHV0ZGF0YSBmcsOlbiBwcm9ncmFtbWV0IgogCi0jOiBkaWZmLmM6NTQ4MworIzogZGlmZi5jOjU0ODYKIG1zZ2lkICJhbGxvdyBhbiBleHRlcm5hbCBkaWZmIGhlbHBlciB0byBiZSBleGVjdXRlZCIKIG1zZ3N0ciAidGlsbMOldCBrw7ZyYSBlbiBleHRlcm4gZGlmZi1oasOkbHBhcmUiCiAKLSM6IGRpZmYuYzo1NDg1CisjOiBkaWZmLmM6NTQ4OAogbXNnaWQgInJ1biBleHRlcm5hbCB0ZXh0IGNvbnZlcnNpb24gZmlsdGVycyB3aGVuIGNvbXBhcmluZyBiaW5hcnkgZmlsZXMiCiBtc2dzdHIgImvDtnIgZXh0ZXJudCB0ZXh0a29udmVydGVyaW5nc2ZpbGVyIG7DpHIgYmluw6RyZmlsZXIgasOkbWbDtnJzIgogCi0jOiBkaWZmLmM6NTQ4NworIzogZGlmZi5jOjU0OTAKIG1zZ2lkICI8d2hlbj4iCiBtc2dzdHIgIjxuw6RyPiIKIAotIzogZGlmZi5jOjU0ODgKKyM6IGRpZmYuYzo1NDkxCiBtc2dpZCAiaWdub3JlIGNoYW5nZXMgdG8gc3VibW9kdWxlcyBpbiB0aGUgZGlmZiBnZW5lcmF0aW9uIgogbXNnc3RyICJpZ25vcmVyYSDDpG5kcmluZ2FyIGkgdW5kZXJtb2R1bGVyIG7DpHIgZGlmZmVuIHNrYXBhcyIKIAotIzogZGlmZi5jOjU0OTEKKyM6IGRpZmYuYzo1NDk0CiBtc2dpZCAiPGZvcm1hdD4iCiBtc2dzdHIgIjxmb3JtYXQ+IgogCi0jOiBkaWZmLmM6NTQ5MgorIzogZGlmZi5jOjU0OTUKIG1zZ2lkICJzcGVjaWZ5IGhvdyBkaWZmZXJlbmNlcyBpbiBzdWJtb2R1bGVzIGFyZSBzaG93biIKIG1zZ3N0ciAiYW5nZSBodXIgw6RuZHJpbmdhciBpIHVuZGVybW9kdWxlciB2aXNhcyIKIAotIzogZGlmZi5jOjU0OTYKKyM6IGRpZmYuYzo1NDk5CiBtc2dpZCAiaGlkZSAnZ2l0IGFkZCAtTicgZW50cmllcyBmcm9tIHRoZSBpbmRleCIKIG1zZ3N0ciAiZMO2bGogXCJnaXQgYWRkIC1OXCItcG9zdGVyIGZyw6VuIGluZGV4ZXQiCiAKLSM6IGRpZmYuYzo1NDk5CisjOiBkaWZmLmM6NTUwMgogbXNnaWQgInRyZWF0ICdnaXQgYWRkIC1OJyBlbnRyaWVzIGFzIHJlYWwgaW4gdGhlIGluZGV4IgogbXNnc3RyICJ0b2xrYSBcImdpdCBhZGQgLU5cIi1wb3N0ZXIgc29tIMOka3RhIGkgaW5kZXhldCIKIAotIzogZGlmZi5jOjU1MDEKKyM6IGRpZmYuYzo1NTA0CiBtc2dpZCAiPHN0cmluZz4iCiBtc2dzdHIgIjxzdHLDpG5nPiIKIAotIzogZGlmZi5jOjU1MDIKKyM6IGRpZmYuYzo1NTA1CiBtc2dpZCAiIgogImxvb2sgZm9yIGRpZmZlcmVuY2VzIHRoYXQgY2hhbmdlIHRoZSBudW1iZXIgb2Ygb2NjdXJyZW5jZXMgb2YgdGhlIHNwZWNpZmllZCAiCiAic3RyaW5nIgogbXNnc3RyICJzZSBlZnRlciDDpG5kcmluZ2FyIHNvbSDDpG5kcmFyIGFudGFsZXQgZsO2cmVrb21zdGVyIGF2IGFuZ2l2ZW4gc3Ryw6RuZyIKIAotIzogZGlmZi5jOjU1MDUKKyM6IGRpZmYuYzo1NTA4CiBtc2dpZCAiIgogImxvb2sgZm9yIGRpZmZlcmVuY2VzIHRoYXQgY2hhbmdlIHRoZSBudW1iZXIgb2Ygb2NjdXJyZW5jZXMgb2YgdGhlIHNwZWNpZmllZCAiCiAicmVnZXgiCkBAIC0yOTQ2LDk0ICsyOTU2LDk0IEBACiAic2UgZWZ0ZXIgw6RuZHJpbmdhciBzb20gw6RuZHJhciBhbnRhbGV0IGbDtnJla29tc3RlciBhdiBhbmdpdmV0IHJlZ3VsasOkcnQgIgogInV0dHJ5Y2siCiAKLSM6IGRpZmYuYzo1NTA4CisjOiBkaWZmLmM6NTUxMQogbXNnaWQgInNob3cgYWxsIGNoYW5nZXMgaW4gdGhlIGNoYW5nZXNldCB3aXRoIC1TIG9yIC1HIgogbXNnc3RyICJ2aXNhIGFsbGEgw6RuZHJpbmdhciBpIMOkbmRyaW5nc3VwcHPDpHR0bmluZ2VuIG1lZCAtUyBlbGxlciAtRyIKIAotIzogZGlmZi5jOjU1MTEKKyM6IGRpZmYuYzo1NTE0CiBtc2dpZCAidHJlYXQgPHN0cmluZz4gaW4gLVMgYXMgZXh0ZW5kZWQgUE9TSVggcmVndWxhciBleHByZXNzaW9uIgogbXNnc3RyICJ0b2xrYSA8c3Ryw6RuZz4gaSAtUyBzb20gdXTDtmthZGUgUE9TSVgtcmVndWxqw6RyYSB1dHRyeWNrIgogCi0jOiBkaWZmLmM6NTUxNAorIzogZGlmZi5jOjU1MTcKIG1zZ2lkICJjb250cm9sIHRoZSBvcmRlciBpbiB3aGljaCBmaWxlcyBhcHBlYXIgaW4gdGhlIG91dHB1dCIKIG1zZ3N0ciAic3R5ciBvcmRuaW5nZW4gaSB2aWxrZW4gZmlsZXIgdmlzYXMgaSB1dGRhdGEiCiAKLSM6IGRpZmYuYzo1NTE1CisjOiBkaWZmLmM6NTUxOAogbXNnaWQgIjxvYmplY3QtaWQ+IgogbXNnc3RyICI8b2JqZWt0LWlkPiIKIAotIzogZGlmZi5jOjU1MTYKKyM6IGRpZmYuYzo1NTE5CiBtc2dpZCAiIgogImxvb2sgZm9yIGRpZmZlcmVuY2VzIHRoYXQgY2hhbmdlIHRoZSBudW1iZXIgb2Ygb2NjdXJyZW5jZXMgb2YgdGhlIHNwZWNpZmllZCAiCiAib2JqZWN0IgogbXNnc3RyICJzZSBlZnRlciDDpG5kcmluZ2FyIHNvbSDDpG5kcmFyIGFudGFsZXQgZsO2cmVrb21zdGVyIGF2IGFuZ2l2ZXQgb2JqZWt0IgogCi0jOiBkaWZmLmM6NTUxOAorIzogZGlmZi5jOjU1MjEKIG1zZ2lkICJbKEF8Q3xEfE18UnxUfFV8WHxCKS4uLlsqXV0iCiBtc2dzdHIgIlsoQXxDfER8TXxSfFR8VXxYfEIpLi4uWypdXSIKIAotIzogZGlmZi5jOjU1MTkKKyM6IGRpZmYuYzo1NTIyCiBtc2dpZCAic2VsZWN0IGZpbGVzIGJ5IGRpZmYgdHlwZSIKIG1zZ3N0ciAidsOkbGogZmlsdGVyIGVmdGVyIGRpZmYtdHlwIgogCi0jOiBkaWZmLmM6NTUyMQorIzogZGlmZi5jOjU1MjQKIG1zZ2lkICI8ZmlsZT4iCiBtc2dzdHIgIjxmaWw+IgogCi0jOiBkaWZmLmM6NTUyMgorIzogZGlmZi5jOjU1MjUKIG1zZ2lkICJPdXRwdXQgdG8gYSBzcGVjaWZpYyBmaWxlIgogbXNnc3RyICJTa3JpdiB1dGRhdGEgdGlsbCBlbiBzcGVjaWZpayBmaWwiCiAKLSM6IGRpZmYuYzo2MTc3CisjOiBkaWZmLmM6NjE4MAogbXNnaWQgImluZXhhY3QgcmVuYW1lIGRldGVjdGlvbiB3YXMgc2tpcHBlZCBkdWUgdG8gdG9vIG1hbnkgZmlsZXMuIgogbXNnc3RyICIiCiAib27Dtmpha3RpZyBuYW1uYnl0ZXNkZXRla3RlcmluZyB1dGbDtnJkZXMgaW50ZSBww6UgZ3J1bmQgYXYgZsO2ciBtw6VuZ2EgZmlsZXIuIgogCi0jOiBkaWZmLmM6NjE4MAorIzogZGlmZi5jOjYxODMKIG1zZ2lkICJvbmx5IGZvdW5kIGNvcGllcyBmcm9tIG1vZGlmaWVkIHBhdGhzIGR1ZSB0byB0b28gbWFueSBmaWxlcy4iCiBtc2dzdHIgImhpdHRhZGUgYmFyYSBrb3Bpb3IgZnLDpW4gw6RuZHJhZGUgc8O2a3bDpGdhciBww6UgZ3J1bmQgYXYgZsO2ciBtw6VuZ2EgZmlsZXIuIgogCi0jOiBkaWZmLmM6NjE4MworIzogZGlmZi5jOjYxODYKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogInlvdSBtYXkgd2FudCB0byBzZXQgeW91ciAlcyB2YXJpYWJsZSB0byBhdCBsZWFzdCAlZCBhbmQgcmV0cnkgdGhlIGNvbW1hbmQuIgogbXNnc3RyICIiCiAiZHUga2FuIHPDpHR0YSB2YXJpYWJlbG4gJXMgdGlsbCDDpXRtaW5zdG9uZSAlZCBvY2ggZsO2cnPDtmthIGtvbW1hbmRvdCBww6Ugbnl0dC4iCiAKLSM6IGRpci5jOjUzNworIzogZGlyLmM6NTQ5CiAjLCBjLWZvcm1hdAogbXNnaWQgInBhdGhzcGVjICclcycgZGlkIG5vdCBtYXRjaCBhbnkgZmlsZShzKSBrbm93biB0byBnaXQiCiBtc2dzdHIgInPDtmt2w6Rnc2FuZ2l2ZWxzZW4gXCIlc1wiIG1vdHN2YXJhZGUgaW50ZSBuw6VncmEgYXYgZ2l0IGvDpG5kYSBmaWxlciIKIAotIzogZGlyLmM6OTI2CisjOiBkaXIuYzo5MzgKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IHVzZSAlcyBhcyBhbiBleGNsdWRlIGZpbGUiCiBtc2dzdHIgImthbiBpbnRlIGFudsOkbmRhICVzIHNvbSBleGtsdWRlcmluZ3NmaWwiCiAKLSM6IGRpci5jOjE4NDMKKyM6IGRpci5jOjE4NzcKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IG9wZW4gZGlyZWN0b3J5ICclcyciCiBtc2dzdHIgImt1bmRlIGludGUgw7ZwcG5hIGthdGFsb2dlbiBcIiVzXCIiCiAKLSM6IGRpci5jOjIwODUKKyM6IGRpci5jOjIxMjgKIG1zZ2lkICJmYWlsZWQgdG8gZ2V0IGtlcm5lbCBuYW1lIGFuZCBpbmZvcm1hdGlvbiIKIG1zZ3N0ciAibWlzc2x5Y2thZGVzIGjDpG10YSBrw6RybmFucyBuYW1uIG9jaCBpbmZvcm1hdGlvbiIKIAotIzogZGlyLmM6MjIwOQorIzogZGlyLmM6MjI1MgogbXNnaWQgInVudHJhY2tlZCBjYWNoZSBpcyBkaXNhYmxlZCBvbiB0aGlzIHN5c3RlbSBvciBsb2NhdGlvbiIKIG1zZ3N0ciAib3Nww6VyYWQgY2FjaGUgw6RyIGluYWt0aXZlcmFkIHDDpSBzeXN0ZW1ldCBlbGxlciBwbGF0c2VuIgogCi0jOiBkaXIuYzozMDEzCisjOiBkaXIuYzozMDU2CiAjLCBjLWZvcm1hdAogbXNnaWQgImluZGV4IGZpbGUgY29ycnVwdCBpbiByZXBvICVzIgogbXNnc3RyICJpbmRleGZpbGVuIHRyYXNpZyBpIGFya2l2ZXQgJXMiCiAKLSM6IGRpci5jOjMwNTggZGlyLmM6MzA2MworIzogZGlyLmM6MzEwMSBkaXIuYzozMTA2CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBjcmVhdGUgZGlyZWN0b3JpZXMgZm9yICVzIgogbXNnc3RyICJrdW5kZSBpbnRlIHNrYXBhIGthdGFsb2dlciBmw7ZyICVzIgogCi0jOiBkaXIuYzozMDkyCisjOiBkaXIuYzozMTM1CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBtaWdyYXRlIGdpdCBkaXJlY3RvcnkgZnJvbSAnJXMnIHRvICclcyciCiBtc2dzdHIgImt1bmRlIGludGUgbWlncmVyYSBnaXQta2F0YWxvZyBmcsOlbiBcIiVzXCIgdGlsbCBcIiVzXCIiCkBAIC0zMDUyLDEyICszMDYyLDEyIEBACiBtc2dpZCAiY291bGQgbm90IHN0YXQgZmlsZSAnJXMnIgogbXNnc3RyICJrdW5kZSBpbnRlIHRhIHN0YXR1cyBww6UgZmlsZW4gXCIlc1wiIgogCi0jOiBlbnZpcm9ubWVudC5jOjE1MAorIzogZW52aXJvbm1lbnQuYzoxNDgKICMsIGMtZm9ybWF0CiBtc2dpZCAiYmFkIGdpdCBuYW1lc3BhY2UgcGF0aCBcIiVzXCIiCiBtc2dzdHIgImZlbGFrdGlnIGdpdC1uYW1ucnltZHNzw7ZrdsOkZyBcIiVzXCIiCiAKLSM6IGVudmlyb25tZW50LmM6MzMyCisjOiBlbnZpcm9ubWVudC5jOjMzMAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3Qgc2V0IEdJVF9ESVIgdG8gJyVzJyIKIG1zZ3N0ciAia3VuZGUgaW50ZSBzdMOkbGxhIGluIEdJVF9ESVIgdGlsbCBcIiVzXCIiCkBAIC0zMDY3LDE1OCArMzA3NywxNTQgQEAKIG1zZ2lkICJ0b28gbWFueSBhcmdzIHRvIHJ1biAlcyIKIG1zZ3N0ciAiZsO2ciBtw6VuZ2EgZmxhZ2dvciBmw7ZyIGF0dCBrw7ZyYSAlcyIKIAotIzogZmV0Y2gtb2JqZWN0LmM6MTcKLW1zZ2lkICJSZW1vdGUgd2l0aCBubyBVUkwiCi1tc2dzdHIgIkZqw6RyciB1dGFuIFVSTCIKLQotIzogZmV0Y2gtcGFjay5jOjE1MQorIzogZmV0Y2gtcGFjay5jOjE1MAogbXNnaWQgImdpdCBmZXRjaC1wYWNrOiBleHBlY3RlZCBzaGFsbG93IGxpc3QiCiBtc2dzdHIgImdpdCBmZXRjaC1wYWNrOiBmw7ZydsOkbnRhZGUgZ3J1bmQgbGlzdGEiCiAKLSM6IGZldGNoLXBhY2suYzoxNTQKKyM6IGZldGNoLXBhY2suYzoxNTMKIG1zZ2lkICJnaXQgZmV0Y2gtcGFjazogZXhwZWN0ZWQgYSBmbHVzaCBwYWNrZXQgYWZ0ZXIgc2hhbGxvdyBsaXN0IgogbXNnc3RyICJnaXQgZmV0Y2gtcGFjazogZsO2cnbDpG50YWRlIGV0dCBmbHVzaC1wYWtldCBlZnRlciBncnVuZCBsaXN0YSIKIAotIzogZmV0Y2gtcGFjay5jOjE2NQorIzogZmV0Y2gtcGFjay5jOjE2NAogbXNnaWQgImdpdCBmZXRjaC1wYWNrOiBleHBlY3RlZCBBQ0svTkFLLCBnb3QgYSBmbHVzaCBwYWNrZXQiCiBtc2dzdHIgImdpdCBmZXRjaC1wYWNrOiBmw7ZydsOkbnRhZGUgQUNLL05BSywgZmljayBmbHVzaC1wYWtldCIKIAotIzogZmV0Y2gtcGFjay5jOjE4NQorIzogZmV0Y2gtcGFjay5jOjE4NAogIywgYy1mb3JtYXQKIG1zZ2lkICJnaXQgZmV0Y2gtcGFjazogZXhwZWN0ZWQgQUNLL05BSywgZ290ICclcyciCiBtc2dzdHIgImdpdCBmZXRjaC1wYWNrOiBmw7ZydsOkbnRhZGUgQUNLL05BSywgZmljayBcIiVzXCIiCiAKLSM6IGZldGNoLXBhY2suYzoxOTYKKyM6IGZldGNoLXBhY2suYzoxOTUKIG1zZ2lkICJ1bmFibGUgdG8gd3JpdGUgdG8gcmVtb3RlIgogbXNnc3RyICJrdW5kZSBpbnRlIHNrcml2YSB0aWxsIGZqw6RycmVuIgogCi0jOiBmZXRjaC1wYWNrLmM6MjU4CisjOiBmZXRjaC1wYWNrLmM6MjU3CiBtc2dpZCAiLS1zdGF0ZWxlc3MtcnBjIHJlcXVpcmVzIG11bHRpX2Fja19kZXRhaWxlZCIKIG1zZ3N0ciAiLS1zdGF0ZWxlc3MtcnBjIGtyw6R2ZXIgXCJtdWx0aV9hY2tfZGV0YWlsZWRcIiIKIAotIzogZmV0Y2gtcGFjay5jOjM2MCBmZXRjaC1wYWNrLmM6MTI4NAorIzogZmV0Y2gtcGFjay5jOjM1NiBmZXRjaC1wYWNrLmM6MTI4MAogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIHNoYWxsb3cgbGluZTogJXMiCiBtc2dzdHIgIm9naWx0aWcgXCJzaGFsbG93XCItcmFkOiAlcyIKIAotIzogZmV0Y2gtcGFjay5jOjM2NiBmZXRjaC1wYWNrLmM6MTI5MAorIzogZmV0Y2gtcGFjay5jOjM2MiBmZXRjaC1wYWNrLmM6MTI4NgogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIHVuc2hhbGxvdyBsaW5lOiAlcyIKIG1zZ3N0ciAib2dpbHRpZyBcInVuc2hhbGxvd1wiLXJhZDogJXMiCiAKLSM6IGZldGNoLXBhY2suYzozNjggZmV0Y2gtcGFjay5jOjEyOTIKKyM6IGZldGNoLXBhY2suYzozNjQgZmV0Y2gtcGFjay5jOjEyODgKICMsIGMtZm9ybWF0CiBtc2dpZCAib2JqZWN0IG5vdCBmb3VuZDogJXMiCiBtc2dzdHIgIm9iamVrdGV0IGhpdHRhZGVzIGludGU6ICVzIgogCi0jOiBmZXRjaC1wYWNrLmM6MzcxIGZldGNoLXBhY2suYzoxMjk1CisjOiBmZXRjaC1wYWNrLmM6MzY3IGZldGNoLXBhY2suYzoxMjkxCiAjLCBjLWZvcm1hdAogbXNnaWQgImVycm9yIGluIG9iamVjdDogJXMiCiBtc2dzdHIgImZlbCBpIG9iamVrdDogJXMiCiAKLSM6IGZldGNoLXBhY2suYzozNzMgZmV0Y2gtcGFjay5jOjEyOTcKKyM6IGZldGNoLXBhY2suYzozNjkgZmV0Y2gtcGFjay5jOjEyOTMKICMsIGMtZm9ybWF0CiBtc2dpZCAibm8gc2hhbGxvdyBmb3VuZDogJXMiCiBtc2dzdHIgImluZ2VuIFwic2hhbGxvd1wiIGhpdHRhZGVzOiAlcyIKIAotIzogZmV0Y2gtcGFjay5jOjM3NiBmZXRjaC1wYWNrLmM6MTMwMQorIzogZmV0Y2gtcGFjay5jOjM3MiBmZXRjaC1wYWNrLmM6MTI5NwogIywgYy1mb3JtYXQKIG1zZ2lkICJleHBlY3RlZCBzaGFsbG93L3Vuc2hhbGxvdywgZ290ICVzIgogbXNnc3RyICJmw7ZydsOkbnRhZGUgc2hhbGxvdy91bnNoYWxsb3csIGZpY2sgJXMiCiAKLSM6IGZldGNoLXBhY2suYzo0MTcKKyM6IGZldGNoLXBhY2suYzo0MTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiZ290ICVzICVkICVzIgogbXNnc3RyICJmaWNrICVzICVkICVzIgogCi0jOiBmZXRjaC1wYWNrLmM6NDM0CisjOiBmZXRjaC1wYWNrLmM6NDMxCiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgY29tbWl0ICVzIgogbXNnc3RyICJvZ2lsdGlnIGluY2hlY2tuaW5nICVzIgogCi0jOiBmZXRjaC1wYWNrLmM6NDY1CisjOiBmZXRjaC1wYWNrLmM6NDYyCiBtc2dpZCAiZ2l2aW5nIHVwIgogbXNnc3RyICJnZXIgdXBwIgogCi0jOiBmZXRjaC1wYWNrLmM6NDc3IHByb2dyZXNzLmM6Mjc3CisjOiBmZXRjaC1wYWNrLmM6NDc1IHByb2dyZXNzLmM6MzEyCiBtc2dpZCAiZG9uZSIKIG1zZ3N0ciAia2xhcnQiCiAKLSM6IGZldGNoLXBhY2suYzo0ODkKKyM6IGZldGNoLXBhY2suYzo0ODcKICMsIGMtZm9ybWF0CiBtc2dpZCAiZ290ICVzICglZCkgJXMiCiBtc2dzdHIgImZpY2sgJXMgKCVkKSAlcyIKIAotIzogZmV0Y2gtcGFjay5jOjUzNQorIzogZmV0Y2gtcGFjay5jOjUzMwogIywgYy1mb3JtYXQKIG1zZ2lkICJNYXJraW5nICVzIGFzIGNvbXBsZXRlIgogbXNnc3RyICJNYXJrZXJhciAlcyBzb20ga29tcGxldHQiCiAKLSM6IGZldGNoLXBhY2suYzo3NDQKKyM6IGZldGNoLXBhY2suYzo3NDIKICMsIGMtZm9ybWF0CiBtc2dpZCAiYWxyZWFkeSBoYXZlICVzICglcykiCiBtc2dzdHIgImhhciByZWRhbiAlcyAoJXMpIgogCi0jOiBmZXRjaC1wYWNrLmM6NzgzCisjOiBmZXRjaC1wYWNrLmM6NzgxCiBtc2dpZCAiZmV0Y2gtcGFjazogdW5hYmxlIHRvIGZvcmsgb2ZmIHNpZGViYW5kIGRlbXVsdGlwbGV4ZXIiCiBtc2dzdHIgImZldGNoLXBhdGNoOiBrdW5kZSBpbnRlIGdyZW5hIGF2IHNpZGJhbmRzbXVsdGlwbGV4YXJlIgogCi0jOiBmZXRjaC1wYWNrLmM6NzkxCisjOiBmZXRjaC1wYWNrLmM6Nzg5CiBtc2dpZCAicHJvdG9jb2wgZXJyb3I6IGJhZCBwYWNrIGhlYWRlciIKIG1zZ3N0ciAicHJvdG9rb2xsZmVsOiBmZWxha3RpZ3QgcGFja2h1dnVkIgogCi0jOiBmZXRjaC1wYWNrLmM6ODU5CisjOiBmZXRjaC1wYWNrLmM6ODU3CiAjLCBjLWZvcm1hdAogbXNnaWQgImZldGNoLXBhY2s6IHVuYWJsZSB0byBmb3JrIG9mZiAlcyIKIG1zZ3N0ciAiZmV0Y2gtcGF0Y2g6IGt1bmRlIGludGUgZ3JlbmEgYXYgJXMiCiAKLSM6IGZldGNoLXBhY2suYzo4NzUKKyM6IGZldGNoLXBhY2suYzo4NzMKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgZmFpbGVkIgogbXNnc3RyICIlcyBtaXNzbHlja2FkZXMiCiAKLSM6IGZldGNoLXBhY2suYzo4NzcKKyM6IGZldGNoLXBhY2suYzo4NzUKIG1zZ2lkICJlcnJvciBpbiBzaWRlYmFuZCBkZW11bHRpcGxleGVyIgogbXNnc3RyICJmZWwgaSBzaWRiYW5kcy1hdm11bHRpcGxleGFyZSIKIAotIzogZmV0Y2gtcGFjay5jOjkwOAorIzogZmV0Y2gtcGFjay5jOjkwNwogIywgYy1mb3JtYXQKIG1zZ2lkICJTZXJ2ZXIgdmVyc2lvbiBpcyAlLipzIgogbXNnc3RyICJTZXJ2ZXJ2ZXJzaW9uZW4gw6RyICUuKnMiCiAKLSM6IGZldGNoLXBhY2suYzo5MTMgZmV0Y2gtcGFjay5jOjkxOSBmZXRjaC1wYWNrLmM6OTIyIGZldGNoLXBhY2suYzo5MjgKLSM6IGZldGNoLXBhY2suYzo5MzIgZmV0Y2gtcGFjay5jOjkzNiBmZXRjaC1wYWNrLmM6OTQwIGZldGNoLXBhY2suYzo5NDQKLSM6IGZldGNoLXBhY2suYzo5NDggZmV0Y2gtcGFjay5jOjk1MiBmZXRjaC1wYWNrLmM6OTU2IGZldGNoLXBhY2suYzo5NjAKLSM6IGZldGNoLXBhY2suYzo5NjYgZmV0Y2gtcGFjay5jOjk3MiBmZXRjaC1wYWNrLmM6OTc3IGZldGNoLXBhY2suYzo5ODIKKyM6IGZldGNoLXBhY2suYzo5MTIgZmV0Y2gtcGFjay5jOjkxOCBmZXRjaC1wYWNrLmM6OTIxIGZldGNoLXBhY2suYzo5MjcKKyM6IGZldGNoLXBhY2suYzo5MzEgZmV0Y2gtcGFjay5jOjkzNSBmZXRjaC1wYWNrLmM6OTM5IGZldGNoLXBhY2suYzo5NDMKKyM6IGZldGNoLXBhY2suYzo5NDcgZmV0Y2gtcGFjay5jOjk1MSBmZXRjaC1wYWNrLmM6OTU1IGZldGNoLXBhY2suYzo5NTkKKyM6IGZldGNoLXBhY2suYzo5NjUgZmV0Y2gtcGFjay5jOjk3MSBmZXRjaC1wYWNrLmM6OTc2IGZldGNoLXBhY2suYzo5ODEKICMsIGMtZm9ybWF0CiBtc2dpZCAiU2VydmVyIHN1cHBvcnRzICVzIgogbXNnc3RyICJTZXJ2ZXJuIHN0w7ZkZXIgJXMiCiAKLSM6IGZldGNoLXBhY2suYzo5MTUKKyM6IGZldGNoLXBhY2suYzo5MTQKIG1zZ2lkICJTZXJ2ZXIgZG9lcyBub3Qgc3VwcG9ydCBzaGFsbG93IGNsaWVudHMiCiBtc2dzdHIgIlNlcnZlcm4gc3TDtmRlciBpbnRlIGtsaWVudGVyIG1lZCBncnVuZGEgYXJraXYiCiAKLSM6IGZldGNoLXBhY2suYzo5NzUKKyM6IGZldGNoLXBhY2suYzo5NzQKIG1zZ2lkICJTZXJ2ZXIgZG9lcyBub3Qgc3VwcG9ydCAtLXNoYWxsb3ctc2luY2UiCiBtc2dzdHIgIlNlcnZlcm4gc3TDtmRlciBpbnRlIC0tc2hhbGxvdy1zaW5jZSIKIAotIzogZmV0Y2gtcGFjay5jOjk4MAorIzogZmV0Y2gtcGFjay5jOjk3OQogbXNnaWQgIlNlcnZlciBkb2VzIG5vdCBzdXBwb3J0IC0tc2hhbGxvdy1leGNsdWRlIgogbXNnc3RyICJTZXJ2ZXJuIHN0w7ZkZXIgaW50ZSAtLXNoYWxsb3ctZXhjbHVkZSIKIAotIzogZmV0Y2gtcGFjay5jOjk4NAorIzogZmV0Y2gtcGFjay5jOjk4MwogbXNnaWQgIlNlcnZlciBkb2VzIG5vdCBzdXBwb3J0IC0tZGVlcGVuIgogbXNnc3RyICJTZXJ2ZXJuIHN0w7ZkZXIgaW50ZSAtLWRlZXBlbiIKIAotIzogZmV0Y2gtcGFjay5jOjEwMDEKKyM6IGZldGNoLXBhY2suYzoxMDAwCiBtc2dpZCAibm8gY29tbW9uIGNvbW1pdHMiCiBtc2dzdHIgImluZ2EgZ2VtZW5zYW1tYSBpbmNoZWNrbmluZ2FyIgogCi0jOiBmZXRjaC1wYWNrLmM6MTAxMyBmZXRjaC1wYWNrLmM6MTQ2MgorIzogZmV0Y2gtcGFjay5jOjEwMTIgZmV0Y2gtcGFjay5jOjE0NjgKIG1zZ2lkICJnaXQgZmV0Y2gtcGFjazogZmV0Y2ggZmFpbGVkLiIKIG1zZ3N0ciAiZ2l0IGZldGNoLXBhdGNoOiBow6RtdG5pbmcgbWlzc2x5Y2thZGVzLiIKIAotIzogZmV0Y2gtcGFjay5jOjExNTEKKyM6IGZldGNoLXBhY2suYzoxMTUwCiBtc2dpZCAiU2VydmVyIGRvZXMgbm90IHN1cHBvcnQgc2hhbGxvdyByZXF1ZXN0cyIKIG1zZ3N0ciAiU2VydmVybiBzdMO2ZGVyIGludGUgZ3J1bmRhIGbDtnJmcsOlZ25pbmdhciIKIApAQCAtMzIyNiw3MyArMzIzMiw3MyBAQAogbXNnaWQgIlNlcnZlciBzdXBwb3J0cyBmaWx0ZXIiCiBtc2dzdHIgIlNlcnZlcm4gc3TDtmRlciBmaWx0ZXIiCiAKLSM6IGZldGNoLXBhY2suYzoxMTg0CisjOiBmZXRjaC1wYWNrLmM6MTE4MAogbXNnaWQgInVuYWJsZSB0byB3cml0ZSByZXF1ZXN0IHRvIHJlbW90ZSIKIG1zZ3N0ciAia3VuZGUgaW50ZSBza3JpdmEgYW5yb3AgdGlsbCBmasOkcnJlbiIKIAotIzogZmV0Y2gtcGFjay5jOjEyMDIKKyM6IGZldGNoLXBhY2suYzoxMTk4CiAjLCBjLWZvcm1hdAogbXNnaWQgImVycm9yIHJlYWRpbmcgc2VjdGlvbiBoZWFkZXIgJyVzJyIKIG1zZ3N0ciAiZmVsIHZpZCBsw6RzbmluZyBhdiBzdHlja2VodXZ1ZGV0IFwiJXNcIiIKIAotIzogZmV0Y2gtcGFjay5jOjEyMDgKKyM6IGZldGNoLXBhY2suYzoxMjA0CiAjLCBjLWZvcm1hdAogbXNnaWQgImV4cGVjdGVkICclcycsIHJlY2VpdmVkICclcyciCiBtc2dzdHIgImbDtnJ2w6RudGFkZSBcIiVzXCIsIHRvZyBlbW90IFwiJXNcIiIKIAotIzogZmV0Y2gtcGFjay5jOjEyNDcKKyM6IGZldGNoLXBhY2suYzoxMjQzCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuZXhwZWN0ZWQgYWNrbm93bGVkZ21lbnQgbGluZTogJyVzJyIKIG1zZ3N0ciAiZsO2cnbDpG50YWRlIGJla3LDpGZ0ZWxzZXJhZDogXCIlc1wiIgogCi0jOiBmZXRjaC1wYWNrLmM6MTI1MgorIzogZmV0Y2gtcGFjay5jOjEyNDgKICMsIGMtZm9ybWF0CiBtc2dpZCAiZXJyb3IgcHJvY2Vzc2luZyBhY2tzOiAlZCIKIG1zZ3N0ciAiZmVsIHZpZCBoYW50ZXJpbmcgYXYgYmVrcsOkZnRlbHNlcjogJWQiCiAKLSM6IGZldGNoLXBhY2suYzoxMjYyCisjOiBmZXRjaC1wYWNrLmM6MTI1OAogbXNnaWQgImV4cGVjdGVkIHBhY2tmaWxlIHRvIGJlIHNlbnQgYWZ0ZXIgJ3JlYWR5JyIKIG1zZ3N0ciAidsOkbnRhZGUgYXR0IHBha2V0ZmlsIHNrdWxsZSBzw6RuZGFzIGVmdGVyIFwicmVhZHlcIiIKIAotIzogZmV0Y2gtcGFjay5jOjEyNjQKKyM6IGZldGNoLXBhY2suYzoxMjYwCiBtc2dpZCAiZXhwZWN0ZWQgbm8gb3RoZXIgc2VjdGlvbnMgdG8gYmUgc2VudCBhZnRlciBubyAncmVhZHknIgogbXNnc3RyICIiCiAidsOkbnRhZGUgaW50ZSBhdHQgbsOlZ3JhIHl0dGVybGlnYXJlIHNla3Rpb25lciBza3VsbGUgc8OkbmRhcyBlZnRlciBcInJlYWR5XCIiCiAKLSM6IGZldGNoLXBhY2suYzoxMzA2CisjOiBmZXRjaC1wYWNrLmM6MTMwMgogIywgYy1mb3JtYXQKIG1zZ2lkICJlcnJvciBwcm9jZXNzaW5nIHNoYWxsb3cgaW5mbzogJWQiCiBtc2dzdHIgImZlbCB2aWQgaGFudGVyaW5nIGF2IGdydW5kIChcInNoYWxsb3dcIikgaW5mbzogJWQiCiAKLSM6IGZldGNoLXBhY2suYzoxMzUzCisjOiBmZXRjaC1wYWNrLmM6MTM0OQogIywgYy1mb3JtYXQKIG1zZ2lkICJleHBlY3RlZCB3YW50ZWQtcmVmLCBnb3QgJyVzJyIKIG1zZ3N0ciAiZsO2cnbDpG50YWRlIHdhbnRlZC1yZWYsIGZpY2sgJXMiCiAKLSM6IGZldGNoLXBhY2suYzoxMzU4CisjOiBmZXRjaC1wYWNrLmM6MTM1NAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmV4cGVjdGVkIHdhbnRlZC1yZWY6ICclcyciCiBtc2dzdHIgIm92w6RudGFkIHdhbnRlZC1yZWY6IFwiJXNcIiIKIAotIzogZmV0Y2gtcGFjay5jOjEzNjMKKyM6IGZldGNoLXBhY2suYzoxMzU5CiAjLCBjLWZvcm1hdAogbXNnaWQgImVycm9yIHByb2Nlc3Npbmcgd2FudGVkIHJlZnM6ICVkIgogbXNnc3RyICJmZWwgdmlkIGhhbnRlcmluZyBhdiDDtm5za2FkZSByZWZlcmVuc2VyOiAlZCIKIAotIzogZmV0Y2gtcGFjay5jOjE2ODkKKyM6IGZldGNoLXBhY2suYzoxNjkzCiBtc2dpZCAibm8gbWF0Y2hpbmcgcmVtb3RlIGhlYWQiCiBtc2dzdHIgImluZ2V0IG1vdHN2YXJhbmRlIGZqw6Rycmh1dnVkIgogCi0jOiBmZXRjaC1wYWNrLmM6MTcxMiBidWlsdGluL2Nsb25lLmM6Njg2CisjOiBmZXRjaC1wYWNrLmM6MTcxNiBidWlsdGluL2Nsb25lLmM6Njg1CiBtc2dpZCAicmVtb3RlIGRpZCBub3Qgc2VuZCBhbGwgbmVjZXNzYXJ5IG9iamVjdHMiCiBtc2dzdHIgImZqw6RycmVuIHPDpG5kZSBpbnRlIGFsbGEgbsO2ZHbDpG5kaWdhIG9iamVrdCIKIAotIzogZmV0Y2gtcGFjay5jOjE3MzkKKyM6IGZldGNoLXBhY2suYzoxNzQzCiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vIHN1Y2ggcmVtb3RlIHJlZiAlcyIKIG1zZ3N0ciAiaW5nZW4gc8OlZGFuIGZqw6RycmVmZXJlbnM6ICVzIgogCi0jOiBmZXRjaC1wYWNrLmM6MTc0MgorIzogZmV0Y2gtcGFjay5jOjE3NDYKICMsIGMtZm9ybWF0CiBtc2dpZCAiU2VydmVyIGRvZXMgbm90IGFsbG93IHJlcXVlc3QgZm9yIHVuYWR2ZXJ0aXNlZCBvYmplY3QgJXMiCiBtc2dzdHIgIlNlcnZlcm4gdGlsbMOldGVyIGludGUgZsO2cmZyw6VnYW4gb20gZWogdGlsbGvDpG5uYWdpdmV0IG9iamVrdCAlcyIKQEAgLTMzMTUsMTggKzMzMjEsMjYgQEAKIG1zZ2lkICJpZ25vcmUgaW52YWxpZCBjb2xvciAnJS4qcycgaW4gbG9nLmdyYXBoQ29sb3JzIgogbXNnc3RyICJpZ25vcmVyYSBmZWxha3RpZyBmw6RyZyBcIiUuKnNcIiBpIGxvZy5ncmFwaENvbG9ycyIKIAotIzogZ3JlcC5jOjIxMTcKKyM6IGdyZXAuYzo2NjgKK21zZ2lkICIiCisiZ2l2ZW4gcGF0dGVybiBjb250YWlucyBOVUxMIGJ5dGUgKHZpYSAtZiA8ZmlsZT4pLiBUaGlzIGlzIG9ubHkgc3VwcG9ydGVkICIKKyJ3aXRoIC1QIHVuZGVyIFBDUkUgdjIiCittc2dzdHIgIiIKKyJhbmdpdmV0IG3Dtm5zdGVyIGlubmVow6VsbGVyIE5VTEwtYnl0ZSAodmlhIC1mIDxmaWw+KS4gRGV0dGEgc3TDtmRzIGVuZGFzdCBtZWQgLSIKKyJQIHVuZGVyIFBDUkUgdjIiCisKKyM6IGdyZXAuYzoyMTI0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiclcyc6IHVuYWJsZSB0byByZWFkICVzIgogbXNnc3RyICJcIiVzXCIga3VuZGUgaW50ZSBsw6RzYSAlcyIKIAotIzogZ3JlcC5jOjIxMzQgc2V0dXAuYzoxNjQgYnVpbHRpbi9jbG9uZS5jOjQwOSBidWlsdGluL2RpZmYuYzo4MgorIzogZ3JlcC5jOjIxNDEgc2V0dXAuYzoxNjUgYnVpbHRpbi9jbG9uZS5jOjQwOCBidWlsdGluL2RpZmYuYzo4MgogIzogYnVpbHRpbi9ybS5jOjEzNQogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gc3RhdCAnJXMnIgogbXNnc3RyICJtaXNzbHlja2FkZXMgdGEgc3RhdHVzIHDDpSBcIiVzXCIiCiAKLSM6IGdyZXAuYzoyMTQ1CisjOiBncmVwLmM6MjE1MgogIywgYy1mb3JtYXQKIG1zZ2lkICInJXMnOiBzaG9ydCByZWFkIgogbXNnc3RyICJcIiVzXCI6IGtvcnQgbMOkc25pbmciCkBAIC0zNDY5LDEyICszNDgzLDEyIEBACiBtc2dpZCAiZ2l0IHZlcnNpb24gWzxvcHRpb25zPl0iCiBtc2dzdHIgImdpdCB2ZXJzaW9uIFs8ZmxhZ2dvcj5dIgogCi0jOiBoZWxwLmM6NzgyCisjOiBoZWxwLmM6NzgzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiAlcyAtICVzIgogbXNnc3RyICIlczogJXMgLSAlcyIKIAotIzogaGVscC5jOjc4NgorIzogaGVscC5jOjc4NwogbXNnaWQgIiIKICJcbiIKICJEaWQgeW91IG1lYW4gdGhpcz8iCkBAIC0zNTQ3LDQxICszNTYxLDU2IEBACiBtc2dpZCAiaW52YWxpZCBkYXRlIGZvcm1hdDogJXMiCiBtc2dzdHIgImZlbGFrdGlndCBkYXR1bWZvcm1hdDogJXMiCiAKLSM6IGxpc3Qtb2JqZWN0cy5jOjEyOQorIzogbGlzdC1vYmplY3RzLmM6MTI3CiAjLCBjLWZvcm1hdAogbXNnaWQgImVudHJ5ICclcycgaW4gdHJlZSAlcyBoYXMgdHJlZSBtb2RlLCBidXQgaXMgbm90IGEgdHJlZSIKIG1zZ3N0ciAicG9zdGVuIFwiJXNcIiBpIHRyw6RkZXQgJXMgaGFyIHRyw6RkLWzDpGdlLCBtZW4gw6RyIGludGUgZXR0IHRyw6RkIgogCi0jOiBsaXN0LW9iamVjdHMuYzoxNDIKKyM6IGxpc3Qtb2JqZWN0cy5jOjE0MAogIywgYy1mb3JtYXQKIG1zZ2lkICJlbnRyeSAnJXMnIGluIHRyZWUgJXMgaGFzIGJsb2IgbW9kZSwgYnV0IGlzIG5vdCBhIGJsb2IiCiBtc2dzdHIgInBvc3RlbiBcIiVzXCIgaSB0csOkZGV0ICVzIGhhciBibG9iLWzDpGdlLCBtZW4gw6RyIGludGUgZW4gYmxvYiIKIAotIzogbGlzdC1vYmplY3RzLmM6Mzc4CisjOiBsaXN0LW9iamVjdHMuYzozNzUKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGxvYWQgcm9vdCB0cmVlIGZvciBjb21taXQgJXMiCiBtc2dzdHIgImt1bmRlIGludGUgbMOkc2EgaW4gcm90LXRyw6RkZXQgZsO2ciBpbmNoZWNrbmluZ2VuICVzIgogCi0jOiBsaXN0LW9iamVjdHMtZmlsdGVyLW9wdGlvbnMuYzozNgotbXNnaWQgIm11bHRpcGxlIGZpbHRlci1zcGVjcyBjYW5ub3QgYmUgY29tYmluZWQiCi1tc2dzdHIgImZsZXJhIGZpbHRlcnNwZWNpZmlrYXRpb25lciBrYW4gaW50ZSBrb21iaW5lcmFzIgorIzogbGlzdC1vYmplY3RzLWZpbHRlci5jOjQ5MgorIywgYy1mb3JtYXQKK21zZ2lkICJ1bmFibGUgdG8gYWNjZXNzIHNwYXJzZSBibG9iIGluICclcyciCittc2dzdHIgImt1bmRlIGludGUgbsOlIGdsZXMgYmxvYiBww6UgXCIlc1wiIgorCisjOiBsaXN0LW9iamVjdHMtZmlsdGVyLmM6NDk1CisjLCBjLWZvcm1hdAorbXNnaWQgInVuYWJsZSB0byBwYXJzZSBzcGFyc2UgZmlsdGVyIGRhdGEgaW4gJXMiCittc2dzdHIgImt1bmRlIGludGUgdG9sa2EgZ2xlcyBmaWx0ZXJkYXRhIGkgJXMiCiAKICM6IGxpc3Qtb2JqZWN0cy1maWx0ZXItb3B0aW9ucy5jOjU4CiBtc2dpZCAiZXhwZWN0ZWQgJ3RyZWU6PGRlcHRoPiciCiBtc2dzdHIgImbDtnJ2w6RudGFkZSBcInRyZWU6PGRqdXA+XCIiCiAKLSM6IGxpc3Qtb2JqZWN0cy1maWx0ZXItb3B0aW9ucy5jOjg0CisjOiBsaXN0LW9iamVjdHMtZmlsdGVyLW9wdGlvbnMuYzo3MwogbXNnaWQgInNwYXJzZTpwYXRoIGZpbHRlcnMgc3VwcG9ydCBoYXMgYmVlbiBkcm9wcGVkIgogbXNnc3RyICJzcGFyc2U6c8O2a3bDpGctZmlsdGVyIHN0w7ZkcyBpbnRlIGzDpG5ncmUiCiAKLSM6IGxpc3Qtb2JqZWN0cy1maWx0ZXItb3B0aW9ucy5jOjk0CisjOiBsaXN0LW9iamVjdHMtZmlsdGVyLW9wdGlvbnMuYzo4NgogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIGZpbHRlci1zcGVjICclcyciCiBtc2dzdHIgImZlbGFrdGlnIGZpbHRlcnNwZWNpZmlrYXRpb246IFwiJXNcIiIKIAotIzogbGlzdC1vYmplY3RzLWZpbHRlci1vcHRpb25zLmM6MTU4Ci1tc2dpZCAiY2Fubm90IGNoYW5nZSBwYXJ0aWFsIGNsb25lIHByb21pc29yIHJlbW90ZSIKLW1zZ3N0ciAia2FuIGludGUgw6RuZHJhIGtvbnRyYWt0c2Zqw6RyciBmw7ZyIGRlbHZpcyBrbG9uaW5nIgorIzogbGlzdC1vYmplY3RzLWZpbHRlci1vcHRpb25zLmM6MTAyCisjLCBjLWZvcm1hdAorbXNnaWQgIm11c3QgZXNjYXBlIGNoYXIgaW4gc3ViLWZpbHRlci1zcGVjOiAnJWMnIgorbXNnc3RyICJtw6VzdGUgYW52w6RuZGEgc3BlY2lhbHNla3ZlbnMgaSBkZWxmaWx0ZXItc3BlYzogXCIlY1wiIgorCisjOiBsaXN0LW9iamVjdHMtZmlsdGVyLW9wdGlvbnMuYzoxNDQKK21zZ2lkICJleHBlY3RlZCBzb21ldGhpbmcgYWZ0ZXIgY29tYmluZToiCittc2dzdHIgImbDtnJ2w6RudGFkZSBuw6Vnb250aW5nIGVmdGVyIGNvbWJpbmU6IgorCisjOiBsaXN0LW9iamVjdHMtZmlsdGVyLW9wdGlvbnMuYzoyMjYKK21zZ2lkICJtdWx0aXBsZSBmaWx0ZXItc3BlY3MgY2Fubm90IGJlIGNvbWJpbmVkIgorbXNnc3RyICJmbGVyYSBmaWx0ZXJzcGVjaWZpa2F0aW9uZXIga2FuIGludGUga29tYmluZXJhcyIKIAogIzogbG9ja2ZpbGUuYzoxNTEKICMsIGMtZm9ybWF0CkBAIC0zNjEyLDEyMSArMzY0MSwxMTcgQEAKIG1zZ2lkICJmYWlsZWQgdG8gcmVhZCB0aGUgY2FjaGUiCiBtc2dzdHIgIm1pc3NseWNrYWRlcyBsw6RzYSBjYWNoZW4iCiAKLSM6IG1lcmdlLmM6MTA3IHJlcmVyZS5jOjcyMCBidWlsdGluL2FtLmM6MTg4NSBidWlsdGluL2FtLmM6MTkxOQotIzogYnVpbHRpbi9jaGVja291dC5jOjUzNiBidWlsdGluL2NoZWNrb3V0LmM6Nzk2IGJ1aWx0aW4vY2xvbmUuYzo3ODYKKyM6IG1lcmdlLmM6MTA3IHJlcmVyZS5jOjcyMCBidWlsdGluL2FtLmM6MTg3NCBidWlsdGluL2FtLmM6MTkwOAorIzogYnVpbHRpbi9jaGVja291dC5jOjUzNyBidWlsdGluL2NoZWNrb3V0LmM6Nzk2IGJ1aWx0aW4vY2xvbmUuYzo3ODUKICM6IGJ1aWx0aW4vc3Rhc2guYzoyNjQKIG1zZ2lkICJ1bmFibGUgdG8gd3JpdGUgbmV3IGluZGV4IGZpbGUiCiBtc2dzdHIgImt1bmRlIGludGUgc2tyaXZhIG55IGluZGV4ZmlsIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozMjIKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjM2NwogbXNnaWQgIihiYWQgY29tbWl0KVxuIgogbXNnc3RyICIoZmVsYWt0aWcgaW5jaGVja25pbmcpXG4iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjM0NQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzkwCiAjLCBjLWZvcm1hdAogbXNnaWQgImFkZF9jYWNoZWluZm8gZmFpbGVkIGZvciBwYXRoICclcyc7IG1lcmdlIGFib3J0aW5nLiIKIG1zZ3N0ciAiIgogImFkZF9jYWhjZWluZm8gbWlzc2x5Y2thZGVzIGbDtnIgc8O2a3bDpGdlbiBcIiVzXCI7IGF2c2x1dGFyIHNhbW1hbnNsYWduaW5nZW4uIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozNTQKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjM5OQogIywgYy1mb3JtYXQKIG1zZ2lkICJhZGRfY2FjaGVpbmZvIGZhaWxlZCB0byByZWZyZXNoIGZvciBwYXRoICclcyc7IG1lcmdlIGFib3J0aW5nLiIKIG1zZ3N0ciAiIgogImFkZF9jYWNoZWluZm8gbWlzc2x5Y2thZGVzIHVwcGRhdGVyYSBmw7ZyIHPDtmt2w6RnZW4gXCIlc1wiOyBhdnNsdXRhciAiCiAic2FtbWFuc2xhZ25pbmdlbi4iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjQzNwotbXNnaWQgImVycm9yIGJ1aWxkaW5nIHRyZWVzIgotbXNnc3RyICJmZWwgdmlkIGJ5Z2dhbmRlIGF2IHRyw6RkIgotCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzo4NjMKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjg4NQogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gY3JlYXRlIHBhdGggJyVzJyVzIgogbXNnc3RyICJtaXNzbHlja2FkZXMgc2thcGEgc8O2a3bDpGdlbiBcIiVzXCIlcyIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6ODc0CisjOiBtZXJnZS1yZWN1cnNpdmUuYzo4OTYKICMsIGMtZm9ybWF0CiBtc2dpZCAiUmVtb3ZpbmcgJXMgdG8gbWFrZSByb29tIGZvciBzdWJkaXJlY3RvcnlcbiIKIG1zZ3N0ciAiVGFyIGJvcnQgJXMgZsO2ciBhdHQgZ8O2cmEgcGxhdHMgZsO2ciB1bmRlcmthdGFsb2dcbiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6ODg4IG1lcmdlLXJlY3Vyc2l2ZS5jOjkwNworIzogbWVyZ2UtcmVjdXJzaXZlLmM6OTEwIG1lcmdlLXJlY3Vyc2l2ZS5jOjkyOQogbXNnaWQgIjogcGVyaGFwcyBhIEQvRiBjb25mbGljdD8iCiBtc2dzdHIgIjoga2Fuc2tlIGVuIEsvRi1rb25mbGlrdD8iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjg5NworIzogbWVyZ2UtcmVjdXJzaXZlLmM6OTE5CiAjLCBjLWZvcm1hdAogbXNnaWQgInJlZnVzaW5nIHRvIGxvc2UgdW50cmFja2VkIGZpbGUgYXQgJyVzJyIKIG1zZ3N0ciAidsOkZ3JhciBmw7ZybG9yYSBvc3DDpXJhZCBmaWwgdmlkIFwiJXNcIiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6OTM4IGJ1aWx0aW4vY2F0LWZpbGUuYzo0MAorIzogbWVyZ2UtcmVjdXJzaXZlLmM6OTYwIGJ1aWx0aW4vY2F0LWZpbGUuYzo0MQogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgcmVhZCBvYmplY3QgJXMgJyVzJyIKIG1zZ3N0ciAia2FuIGludGUgbMOkc2Egb2JqZWt0ZXQgJXM6IFwiJXNcIiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6OTQxCisjOiBtZXJnZS1yZWN1cnNpdmUuYzo5NjUKICMsIGMtZm9ybWF0CiBtc2dpZCAiYmxvYiBleHBlY3RlZCBmb3IgJXMgJyVzJyIKIG1zZ3N0ciAiYmxvYiBmw7ZydsOkbnRhZGVzIGbDtnIgJXMgXCIlc1wiIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzo5NjUKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjk5MAogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gb3BlbiAnJXMnOiAlcyIKIG1zZ3N0ciAibWlzc2x5Y2thZGVzIMO2cHBuYSBcIiVzXCI6ICVzIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzo5NzYKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEwMDEKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIHN5bWxpbmsgJyVzJzogJXMiCiBtc2dzdHIgIm1pc3NseWNrYWRlcyBza2FwYSBzeW1ib2xpc2thIGzDpG5rZW4gXCIlc1wiOiAlcyIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6OTgxCisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxMDA2CiAjLCBjLWZvcm1hdAogbXNnaWQgImRvIG5vdCBrbm93IHdoYXQgdG8gZG8gd2l0aCAlMDZvICVzICclcyciCiBtc2dzdHIgInZldCBpbnRlIGh1ciAlMDZvICVzIFwiJXNcIiBza2FsbCBoYW50ZXJhcyIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTE3NworIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTE5OQogIywgYy1mb3JtYXQKIG1zZ2lkICJGYWlsZWQgdG8gbWVyZ2Ugc3VibW9kdWxlICVzIChub3QgY2hlY2tlZCBvdXQpIgogbXNnc3RyICJNaXNzbHlja2FkZXMgc2zDpSBpaG9wIHVuZGVybW9kdWxlbiAlcyAoZWogdXRjaGVja2FkKSIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTE4NAorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTIwNgogIywgYy1mb3JtYXQKIG1zZ2lkICJGYWlsZWQgdG8gbWVyZ2Ugc3VibW9kdWxlICVzIChjb21taXRzIG5vdCBwcmVzZW50KSIKIG1zZ3N0ciAiTWlzc2x5Y2thZGVzIHNsw6UgaWhvcCB1bmRlcm1vZHVsZW4gJXMgKGluY2hlY2tuaW5nYXIgc2FrbmFzKSIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTE5MQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTIxMwogIywgYy1mb3JtYXQKIG1zZ2lkICJGYWlsZWQgdG8gbWVyZ2Ugc3VibW9kdWxlICVzIChjb21taXRzIGRvbid0IGZvbGxvdyBtZXJnZS1iYXNlKSIKIG1zZ3N0ciAiIgogIk1pc3NseWNrYWRlcyBzbMOlIGlob3AgdW5kZXJtb2R1bGVuICVzIChpbmNoZWNrbmluZ2FyIGbDtmxqZXIgaW50ZSAiCiAic2FtbWFuc2xhZ25pbmdzYmFzZW4pIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxMTk5IG1lcmdlLXJlY3Vyc2l2ZS5jOjEyMTEKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEyMjEgbWVyZ2UtcmVjdXJzaXZlLmM6MTIzMwogIywgYy1mb3JtYXQKIG1zZ2lkICJGYXN0LWZvcndhcmRpbmcgc3VibW9kdWxlICVzIHRvIHRoZSBmb2xsb3dpbmcgY29tbWl0OiIKIG1zZ3N0ciAiU25hYmJzcG9sYXIgdW5kZXJtb2R1bGVuICVzIHRpbGwgZsO2bGphbmRlIGluY2hlY2tuaW5nOiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTIwMiBtZXJnZS1yZWN1cnNpdmUuYzoxMjE0CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxMjI0IG1lcmdlLXJlY3Vyc2l2ZS5jOjEyMzYKICMsIGMtZm9ybWF0CiBtc2dpZCAiRmFzdC1mb3J3YXJkaW5nIHN1Ym1vZHVsZSAlcyIKIG1zZ3N0ciAiU25hYmJzcG9sYXIgdW5kZXJtb2R1bGVuICVzIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxMjM3CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxMjU5CiAjLCBjLWZvcm1hdAogbXNnaWQgIkZhaWxlZCB0byBtZXJnZSBzdWJtb2R1bGUgJXMgKG1lcmdlIGZvbGxvd2luZyBjb21taXRzIG5vdCBmb3VuZCkiCiBtc2dzdHIgIiIKICJNaXNzbHlja2FkZXMgc2zDpSBpaG9wIHVuZGVybW9kdWxlbiAlcyAoc2FtbWFuc2xhZ25pbmcgZWZ0ZXIgaW5jaGVja25pbmdhciAiCiAiaGl0dGFkZXMgaW50ZSkiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEyNDEKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEyNjMKICMsIGMtZm9ybWF0CiBtc2dpZCAiRmFpbGVkIHRvIG1lcmdlIHN1Ym1vZHVsZSAlcyAobm90IGZhc3QtZm9yd2FyZCkiCiBtc2dzdHIgIk1pc3NseWNrYWRlcyBzbMOlIGlob3AgdW5kZXJtb2R1bGVuICVzIChlaiBzbmFiYnNwb2xuaW5nKSIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTI0MgorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTI2NAogbXNnaWQgIkZvdW5kIGEgcG9zc2libGUgbWVyZ2UgcmVzb2x1dGlvbiBmb3IgdGhlIHN1Ym1vZHVsZTpcbiIKIG1zZ3N0ciAiSGl0dGFkZSBlbiBtw7ZqbGlnIGzDtnNuaW5nIGF2IHNhbW1hbnNsYWduaW5nIGbDtnIgdW5kZXJtb2R1bGVuOlxuIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxMjQ1CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxMjY3CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJJZiB0aGlzIGlzIGNvcnJlY3Qgc2ltcGx5IGFkZCBpdCB0byB0aGUgaW5kZXggZm9yIGV4YW1wbGVcbiIKQEAgLTM3NDMsMzIgKzM3NjgsMzIgQEAKICJcbiIKICJ2aWxrZXQgZ29kdGFyIGzDtnNuaW5nZW4uXG4iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEyNTQKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEyNzYKICMsIGMtZm9ybWF0CiBtc2dpZCAiRmFpbGVkIHRvIG1lcmdlIHN1Ym1vZHVsZSAlcyAobXVsdGlwbGUgbWVyZ2VzIGZvdW5kKSIKIG1zZ3N0ciAiIgogIk1pc3NseWNrYWRlcyBzbMOlIGlob3AgdW5kZXJtb2R1bGVuICVzIChmbGVyYSBzYW1tYW5zbGFnbmluZ2FyIGhpdHRhZGVzKSIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTMyNworIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTM0OQogbXNnaWQgIkZhaWxlZCB0byBleGVjdXRlIGludGVybmFsIG1lcmdlIgogbXNnc3RyICJNaXNzbHlja2FkZXMgZXhla3ZlcmEgaW50ZXJuIHNhbW1hbnNsYWduaW5nIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxMzMyCisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxMzU0CiAjLCBjLWZvcm1hdAogbXNnaWQgIlVuYWJsZSB0byBhZGQgJXMgdG8gZGF0YWJhc2UiCiBtc2dzdHIgIkt1bmRlIGludGUgbMOkZ2dhIHRpbGwgJXMgdGlsbCBkYXRhYmFzZW4iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEzNjQKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEzODYKICMsIGMtZm9ybWF0CiBtc2dpZCAiQXV0by1tZXJnaW5nICVzIgogbXNnc3RyICJTbMOlciBpaG9wICVzIGF1dG9tYXRpc2t0IgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxMzg3CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxNDEwCiAjLCBjLWZvcm1hdAogbXNnaWQgIkVycm9yOiBSZWZ1c2luZyB0byBsb3NlIHVudHJhY2tlZCBmaWxlIGF0ICVzOyB3cml0aW5nIHRvICVzIGluc3RlYWQuIgogbXNnc3RyICJGZWw6IFbDpGdyYXIgZsO2cmxvcmEgb3Nww6VyYWQgZmlsIHZpZCAlczsgc2tyaXZlciB0aWxsICVzIGlzdMOkbGxldC4iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE0NTkKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE0ODIKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkNPTkZMSUNUICglcy9kZWxldGUpOiAlcyBkZWxldGVkIGluICVzIGFuZCAlcyBpbiAlcy4gVmVyc2lvbiAlcyBvZiAlcyBsZWZ0ICIKQEAgLTM3NzcsNyArMzgwMiw3IEBACiAiS09ORkxJS1QgKCVzL3JhZGVyYSk6ICVzIHJhZGVyYWQgaSAlcyBvY2ggJXMgaSAlcy4gVmVyc2lvbmVuICVzIGF2ICVzIGzDpG1uYWQgIgogImkgdHLDpGRldC4iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE0NjQKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE0ODcKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkNPTkZMSUNUICglcy9kZWxldGUpOiAlcyBkZWxldGVkIGluICVzIGFuZCAlcyB0byAlcyBpbiAlcy4gVmVyc2lvbiAlcyBvZiAlcyAiCkBAIC0zNzg2LDcgKzM4MTEsNyBAQAogIktPTkZMSUtUICglcy9yYWRlcmEpOiAlcyByYWRlcmFkIGkgJXMgb2NoICVzIHRpbGwgJXMgaSAlcy4gVmVyc2lvbmVuICVzIGF2ICIKICIlcyBsw6RtbmFkIGkgdHLDpGRldC4iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE0NzEKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE0OTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkNPTkZMSUNUICglcy9kZWxldGUpOiAlcyBkZWxldGVkIGluICVzIGFuZCAlcyBpbiAlcy4gVmVyc2lvbiAlcyBvZiAlcyBsZWZ0ICIKQEAgLTM3OTUsNyArMzgyMCw3IEBACiAiS09ORkxJS1QgKCVzL3JhZGVyYSk6ICVzIHJhZGVyYWQgaSAlcyBvY2ggJXMgaSAlcy4gVmVyc2lvbmVuICVzIGF2ICVzIGzDpG1uYWQgIgogImkgdHLDpGRldCB2aWQgJXMuIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxNDc2CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxNDk5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJDT05GTElDVCAoJXMvZGVsZXRlKTogJXMgZGVsZXRlZCBpbiAlcyBhbmQgJXMgdG8gJXMgaW4gJXMuIFZlcnNpb24gJXMgb2YgJXMgIgpAQCAtMzgwNCw0MCArMzgyOSw0MCBAQAogIktPTkZMSUtUICglcy9yYWRlcmEpOiAlcyByYWRlcmFkIGkgJXMgb2NoICVzIHRpbGwgJXMgaSAlcy4gVmVyc2lvbmVuICVzIGF2ICIKICIlcyBsw6RtbmFkIGkgdHLDpGRldCB2aWQgJXMuIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxNTExCisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxNTM0CiBtc2dpZCAicmVuYW1lIgogbXNnc3RyICJuYW1uYnl0ZSIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTUxMQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTUzNAogbXNnaWQgInJlbmFtZWQiCiBtc2dzdHIgIm5hbW5ieXR0IgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxNTkxIG1lcmdlLXJlY3Vyc2l2ZS5jOjI0NTAgbWVyZ2UtcmVjdXJzaXZlLmM6MzA5MworIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTYxNCBtZXJnZS1yZWN1cnNpdmUuYzoyNDcyIG1lcmdlLXJlY3Vyc2l2ZS5jOjMxMTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiUmVmdXNpbmcgdG8gbG9zZSBkaXJ0eSBmaWxlIGF0ICVzIgogbXNnc3RyICJWw6RncmFyIGbDtnJsb3JhIGxvcnRpZyBmaWwgdmlkIFwiJXNcIiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTYwMQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTYyNAogIywgYy1mb3JtYXQKIG1zZ2lkICJSZWZ1c2luZyB0byBsb3NlIHVudHJhY2tlZCBmaWxlIGF0ICVzLCBldmVuIHRob3VnaCBpdCdzIGluIHRoZSB3YXkuIgogbXNnc3RyICJWw6RncmFyIGbDtnJsb3JhIG9zcMOlcmFkIGZpbCB2aWQgJXMsIHRyb3RzIGF0dCBkZW4gw6RyIGkgdsOkZ2VuLiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTY1OQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTY4MgogIywgYy1mb3JtYXQKIG1zZ2lkICJDT05GTElDVCAocmVuYW1lL2FkZCk6IFJlbmFtZSAlcy0+JXMgaW4gJXMuICBBZGRlZCAlcyBpbiAlcyIKIG1zZ3N0ciAiS09ORkxJS1QgKG5hbW5ieXRlL3RpbGzDpGdnKTogTmFtbmJ5dGUgJXMtPiVzIGkgJXMuIExhZGUgdGlsbCAlcyBpICVzIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxNjkwCisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxNzEzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIGlzIGEgZGlyZWN0b3J5IGluICVzIGFkZGluZyBhcyAlcyBpbnN0ZWFkIgogbXNnc3RyICIlcyDDpHIgZW4ga2F0YWxvZyBpICVzIGzDpGdnZXIgdGlsbCBzb20gJXMgaXN0w6RsbGV0IgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxNjk1CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxNzE4CiAjLCBjLWZvcm1hdAogbXNnaWQgIlJlZnVzaW5nIHRvIGxvc2UgdW50cmFja2VkIGZpbGUgYXQgJXM7IGFkZGluZyBhcyAlcyBpbnN0ZWFkIgogbXNnc3RyICJWw6RncmFyIGbDtnJsb3JhIG9zcMOlcmFkIGZpbCB2aWQgJXM7IGzDpGdnZXIgdGlsbCBzb20gJXMgaXN0w6RsbGV0IgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxNzE0CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxNzM3CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJDT05GTElDVCAocmVuYW1lL3JlbmFtZSk6IFJlbmFtZSBcIiVzXCItPlwiJXNcIiBpbiBicmFuY2ggXCIlc1wiIHJlbmFtZSBcIiVzIgpAQCAtMzg0NiwxNyArMzg3MSwxNyBAQAogIktPTkZMSUtUIChuYW1uYnl0ZS9uYW1uYnl0ZSk6IE5hbW5ieXRlIFwiJXNcIi0+XCIlc1wiIHDDpSBncmVuZW4gXCIlc1wiICIKICJuYW1uYnl0ZSBcIiVzXCItPlwiJXNcIiBpIFwiJXNcIiVzIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxNzE5CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxNzQyCiBtc2dpZCAiIChsZWZ0IHVucmVzb2x2ZWQpIgogbXNnc3RyICIgKGzDpG1uYWQgb2zDtnN0KSIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTgyOAorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTg1MQogIywgYy1mb3JtYXQKIG1zZ2lkICJDT05GTElDVCAocmVuYW1lL3JlbmFtZSk6IFJlbmFtZSAlcy0+JXMgaW4gJXMuIFJlbmFtZSAlcy0+JXMgaW4gJXMiCiBtc2dzdHIgIiIKICJLT05GTElLVCAobmFtbmJ5dGUvbmFtbmJ5dGUpOiBOYW1uYnl0ZSAlcy0+JXMgaSAlcy4gTmFtbmJ5dGUgJXMtPiVzIGkgJXMiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjIwMzUKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjIwNTYKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkNPTkZMSUNUIChkaXJlY3RvcnkgcmVuYW1lIHNwbGl0KTogVW5jbGVhciB3aGVyZSB0byBwbGFjZSAlcyBiZWNhdXNlICIKQEAgLTM4NjcsNyArMzg5Miw3IEBACiAia2F0YWxvZ2VuICVzIGJ5dHRlIG5hbW4gdGlsbCBmbGVyYSBhbmRyYSBrYXRhbG9nZXIsIHV0YW4gYXR0IG7DpWdvbiAiCiAiZGVzdGluYXRpb24gZmljayBlbiBtYWpvcml0ZXQgYXYgZmlsZXJuYS4iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjIwNjcKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjIwODgKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkNPTkZMSUNUIChpbXBsaWNpdCBkaXIgcmVuYW1lKTogRXhpc3RpbmcgZmlsZS9kaXIgYXQgJXMgaW4gdGhlIHdheSBvZiAiCkBAIC0zODc2LDcgKzM5MDEsNyBAQAogIktPTkZMSUtUIChpbXBsaWNpdCBuw6RtbsOkbmRyYWQga2F0KTogQmVmaW50bGlnIGZpbC9rYXQgdmlkICVzIMOkciBpIHbDpGdlbiBmw7ZyICIKICJpbXBsaWNpdCBuYW1uw6RuZHJhZChlKSBrYXRhbG9nKGVyKSBzb20gbMOkZ2dlciBkaXQgZsO2bGphbmRlIHPDtmt2w6RnKGFyKTogJXMuIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoyMDc3CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoyMDk4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJDT05GTElDVCAoaW1wbGljaXQgZGlyIHJlbmFtZSk6IENhbm5vdCBtYXAgbW9yZSB0aGFuIG9uZSBwYXRoIHRvICVzOyAiCkBAIC0zODg1LDcgKzM5MTAsNyBAQAogIktPTkZMSUtUIChpbXBsaWNpdCBuYW1uw6RuZHJhZCBrYXQpOiBLYW4gaW50ZSBrb3BwbGEgbWVyIMOkbiBlbiBzw7ZrdsOkZyB0aWxsICIKICIlczsgaW1wbGljaXRhIGthdGFsb2duYW1uw6RuZHJpbmdhciBmw7Zyc8O2a3RlIGzDpGdnYSBmw7ZsamFuZGUgc8O2a3bDpGdhciBkw6RyOiAlcyIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MjE2OQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MjE5MAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiQ09ORkxJQ1QgKHJlbmFtZS9yZW5hbWUpOiBSZW5hbWUgZGlyZWN0b3J5ICVzLT4lcyBpbiAlcy4gUmVuYW1lIGRpcmVjdG9yeSAlcy0iCkBAIC0zODk0LDcgKzM5MTksNyBAQAogIktPTkZMSUtUIChuYW1uYnl0ZS9uYW1uYnl0ZSk6IE5hbW5ieXR0IGthdGFsb2cgJXMtPiVzIGkgJXMuIE5hbW5ieXR0IGthdGFsb2cgIgogIiVzLT4lcyBpICVzIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoyNDEzCisjOiBtZXJnZS1yZWN1cnNpdmUuYzoyNDM1CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJXQVJOSU5HOiBBdm9pZGluZyBhcHBseWluZyAlcyAtPiAlcyByZW5hbWUgdG8gJXMsIGJlY2F1c2UgJXMgaXRzZWxmIHdhcyAiCkBAIC0zOTAzLDUyICszOTI4LDUyIEBACiAiVkFSTklORzogVW5kdmlrZXIgYXR0IGFwcGxpY2VyYSBuYW1uw6RuZHJpbmcgJXMgLT4gJXMgcMOlICVzLCBkw6UgJXMgc2rDpGx2IGhhciAiCiAiYnl0dCBuYW1uLiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MjkzNworIzogbWVyZ2UtcmVjdXJzaXZlLmM6Mjk2MQogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgcmVhZCBvYmplY3QgJXMiCiBtc2dzdHIgImthbiBpbnRlIGzDpHNhIG9iamVrdGV0ICVzIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoyOTQwCisjOiBtZXJnZS1yZWN1cnNpdmUuYzoyOTY0CiAjLCBjLWZvcm1hdAogbXNnaWQgIm9iamVjdCAlcyBpcyBub3QgYSBibG9iIgogbXNnc3RyICJvYmpla3RldCAlcyDDpHIgaW50ZSBlbiBibG9iIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozMDA0CisjOiBtZXJnZS1yZWN1cnNpdmUuYzozMDI4CiBtc2dpZCAibW9kaWZ5IgogbXNnc3RyICLDpG5kcmEiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMwMDQKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMwMjgKIG1zZ2lkICJtb2RpZmllZCIKIG1zZ3N0ciAiw6RuZHJhZCIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzAxNgorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzA0MAogbXNnaWQgImNvbnRlbnQiCiBtc2dzdHIgImlubmVow6VsbCIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzAyMAorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzA0NAogbXNnaWQgImFkZC9hZGQiCiBtc2dzdHIgInRpbGzDpGdnL3RpbGzDpGdnIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozMDQzCisjOiBtZXJnZS1yZWN1cnNpdmUuYzozMDY3CiAjLCBjLWZvcm1hdAogbXNnaWQgIlNraXBwZWQgJXMgKG1lcmdlZCBzYW1lIGFzIGV4aXN0aW5nKSIKIG1zZ3N0ciAiSG9wcGFkZSDDtnZlciAlcyAoc2FtbWFuc2xhZ2VuIHNhbW1hIHNvbSBiZWZpbnRsaWcpIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozMDY1IGdpdC1zdWJtb2R1bGUuc2g6OTM3CisjOiBtZXJnZS1yZWN1cnNpdmUuYzozMDg5IGdpdC1zdWJtb2R1bGUuc2g6OTM3CiBtc2dpZCAic3VibW9kdWxlIgogbXNnc3RyICJ1bmRlcm1vZHVsIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozMDY2CisjOiBtZXJnZS1yZWN1cnNpdmUuYzozMDkwCiAjLCBjLWZvcm1hdAogbXNnaWQgIkNPTkZMSUNUICglcyk6IE1lcmdlIGNvbmZsaWN0IGluICVzIgogbXNnc3RyICJLT05GTElLVCAoJXMpOiBTYW1tYW5zbGFnbmluZ3Nrb25mbGlrdCBpICVzIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozMDk2CisjOiBtZXJnZS1yZWN1cnNpdmUuYzozMTIwCiAjLCBjLWZvcm1hdAogbXNnaWQgIkFkZGluZyBhcyAlcyBpbnN0ZWFkIgogbXNnc3RyICJMw6RnZ2VyIHRpbGwgc29tICVzIGlzdMOkbGxldCIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzE3OAorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzIwMwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiUGF0aCB1cGRhdGVkOiAlcyBhZGRlZCBpbiAlcyBpbnNpZGUgYSBkaXJlY3RvcnkgdGhhdCB3YXMgcmVuYW1lZCBpbiAlczsgIgpAQCAtMzk1Nyw3ICszOTgyLDcgQEAKICJVcHBkYXRlcmFkIHPDtmt2w6RnOiAlcyBsYWRlIHRpbGwgJXMgaW51dGkgZW4ga2F0YWxvZyBzb20gYnl0dGUgbmFtbiBpICVzOyAiCiAiZmx5dHRhciBkZW4gdGlsbCAlcy4iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMxODEKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMyMDYKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkNPTkZMSUNUIChmaWxlIGxvY2F0aW9uKTogJXMgYWRkZWQgaW4gJXMgaW5zaWRlIGEgZGlyZWN0b3J5IHRoYXQgd2FzIHJlbmFtZWQgIgpAQCAtMzk2Niw3ICszOTkxLDcgQEAKICJLT05GTElLVCAoZmlscGxhY2VyaW5nKTogJXMgbGFkZSB0aWxsICVzIGludXRpIGVuIGthdGFsb2cgc29tIGJ5dHRlIG5hbW4gaSAiCiAiJXMsIGbDtnJlc2zDpXIgYXR0IGRlbiBiw7ZyIGZseXR0YXMgdGlsbCVzLiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzE4NQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzIxMAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiUGF0aCB1cGRhdGVkOiAlcyByZW5hbWVkIHRvICVzIGluICVzLCBpbnNpZGUgYSBkaXJlY3RvcnkgdGhhdCB3YXMgcmVuYW1lZCBpbiAiCkBAIC0zOTc1LDcgKzQwMDAsNyBAQAogIlVwcGRhdGVyYWQgc8O2a3bDpGc6ICVzIGJ5dHRlIG5hbW4gdGlsbCAlcyBpICVzLCBpbnV0aSBlbiBrYXRhbG9nIHNvbSBieXR0ZSAiCiAibmFtbiBpICVzOyBmbHl0dGFyIGRlbiB0aWxsICVzLiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzE4OAorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzIxMwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiQ09ORkxJQ1QgKGZpbGUgbG9jYXRpb24pOiAlcyByZW5hbWVkIHRvICVzIGluICVzLCBpbnNpZGUgYSBkaXJlY3RvcnkgdGhhdCAiCkBAIC0zOTg0LDM2ICs0MDA5LDYwIEBACiAiS09ORkxJS1QgKGZpbHBsYWNlcmluZyk6ICVzIGJ5dHRlIG5hbW4gdGlsbCAlcyBpICVzLCBpbnV0aSBlbiBrYXRhbG9nIHNvbSAiCiAiYnl0dGUgbmFtbiBpICVzOyBmbHl0dGFyIGRlbiB0aWxsICVzLiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzMwMgorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzMyNwogIywgYy1mb3JtYXQKIG1zZ2lkICJSZW1vdmluZyAlcyIKIG1zZ3N0ciAiVGFyIGJvcnQgJXMiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMzMjUKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMzNTAKIG1zZ2lkICJmaWxlL2RpcmVjdG9yeSIKIG1zZ3N0ciAiZmlsL2thdGFsb2ciCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMzMzAKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMzNTUKIG1zZ2lkICJkaXJlY3RvcnkvZmlsZSIKIG1zZ3N0ciAia2F0YWxvZy9maWwiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMzMzcKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMzNjIKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ09ORkxJQ1QgKCVzKTogVGhlcmUgaXMgYSBkaXJlY3Rvcnkgd2l0aCBuYW1lICVzIGluICVzLiBBZGRpbmcgJXMgYXMgJXMiCiBtc2dzdHIgIiIKICJLT05GTElLVCAoJXMpOiBEZXQgZmlubnMgZW4ga2F0YWxvZyBtZWQgbmFtbmV0ICVzIGkgJXMuIEzDpGdnZXIgdGlsbCAlcyBzb20gJXMiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMzNDYKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMzNzEKICMsIGMtZm9ybWF0CiBtc2dpZCAiQWRkaW5nICVzIgogbXNnc3RyICJMw6RnZ2VyIHRpbGwgJXMiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMzNTUKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMzODAKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ09ORkxJQ1QgKGFkZC9hZGQpOiBNZXJnZSBjb25mbGljdCBpbiAlcyIKIG1zZ3N0ciAiS09ORkxJS1QgKHRpbGzDpGdnL3RpbGzDpGdnKTogU2FtbWFuc2xhZ25pbmdza29uZmxpa3QgaSAlcyIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzM5MworIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzQyNAorbXNnaWQgIkFscmVhZHkgdXAgdG8gZGF0ZSEiCittc2dzdHIgIlJlZGFuIMOgIGpvdXIhIgorCisjOiBtZXJnZS1yZWN1cnNpdmUuYzozNDMzCisjLCBjLWZvcm1hdAorbXNnaWQgIm1lcmdpbmcgb2YgdHJlZXMgJXMgYW5kICVzIGZhaWxlZCIKK21zZ3N0ciAic2FtbWFuc2xhZ25pbmcgYXYgdHLDpGRlbiAlcyBvY2ggJXMgbWlzc2x5Y2thZGVzIgorCisjOiBtZXJnZS1yZWN1cnNpdmUuYzozNTM3Cittc2dpZCAiTWVyZ2luZzoiCittc2dzdHIgIlNsw6VyIGlob3A6IgorCisjOiBtZXJnZS1yZWN1cnNpdmUuYzozNTUwCisjLCBjLWZvcm1hdAorbXNnaWQgImZvdW5kICV1IGNvbW1vbiBhbmNlc3RvcjoiCittc2dpZF9wbHVyYWwgImZvdW5kICV1IGNvbW1vbiBhbmNlc3RvcnM6IgorbXNnc3RyWzBdICJoaXR0YWRlICV1IGdlbWVuc2FtIGbDtnJmYWRlcjoiCittc2dzdHJbMV0gImhpdHRhZGUgJXUgZ2VtZW5zYW1tYSBmw7ZyZsOkZGVyOiIKKworIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzYwMAorbXNnaWQgIm1lcmdlIHJldHVybmVkIG5vIGNvbW1pdCIKK21zZ3N0ciAic2FtbWFuc2xhZ25pbmdlbiByZXR1cm5lcmFkZSBpbmdlbiBpbmNoZWNrbmluZyIKKworIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzY1OQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiWW91ciBsb2NhbCBjaGFuZ2VzIHRvIHRoZSBmb2xsb3dpbmcgZmlsZXMgd291bGQgYmUgb3ZlcndyaXR0ZW4gYnkgbWVyZ2U6XG4iCkBAIC00MDIzLDE4OCArNDA3MiwxNjQgQEAKICJzYW1tYW5zbGFnbmluZzpcbiIKICIgICVzIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozNDA0Ci1tc2dpZCAiQWxyZWFkeSB1cCB0byBkYXRlISIKLW1zZ3N0ciAiUmVkYW4gw6Agam91ciEiCi0KLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjM0MTMKLSMsIGMtZm9ybWF0Ci1tc2dpZCAibWVyZ2luZyBvZiB0cmVlcyAlcyBhbmQgJXMgZmFpbGVkIgotbXNnc3RyICJzYW1tYW5zbGFnbmluZyBhdiB0csOkZGVuICVzIG9jaCAlcyBtaXNzbHlja2FkZXMiCi0KLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjM1MTIKLW1zZ2lkICJNZXJnaW5nOiIKLW1zZ3N0ciAiU2zDpXIgaWhvcDoiCi0KLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjM1MjUKLSMsIGMtZm9ybWF0Ci1tc2dpZCAiZm91bmQgJXUgY29tbW9uIGFuY2VzdG9yOiIKLW1zZ2lkX3BsdXJhbCAiZm91bmQgJXUgY29tbW9uIGFuY2VzdG9yczoiCi1tc2dzdHJbMF0gImhpdHRhZGUgJXUgZ2VtZW5zYW0gZsO2cmZhZGVyOiIKLW1zZ3N0clsxXSAiaGl0dGFkZSAldSBnZW1lbnNhbW1hIGbDtnJmw6RkZXI6IgotCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozNTY0Ci1tc2dpZCAibWVyZ2UgcmV0dXJuZWQgbm8gY29tbWl0IgotbXNnc3RyICJzYW1tYW5zbGFnbmluZ2VuIHJldHVybmVyYWRlIGluZ2VuIGluY2hlY2tuaW5nIgotCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozNjMwCisjOiBtZXJnZS1yZWN1cnNpdmUuYzozNzU2CiAjLCBjLWZvcm1hdAogbXNnaWQgIkNvdWxkIG5vdCBwYXJzZSBvYmplY3QgJyVzJyIKIG1zZ3N0ciAiS3VuZGUgaW50ZSB0b2xrYSBvYmpla3RldCBcIiVzXCIiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjM2NDYgYnVpbHRpbi9tZXJnZS5jOjY5OCBidWlsdGluL21lcmdlLmM6ODY5CisjOiBtZXJnZS1yZWN1cnNpdmUuYzozNzc0IGJ1aWx0aW4vbWVyZ2UuYzo2OTQgYnVpbHRpbi9tZXJnZS5jOjg3NAogbXNnaWQgIlVuYWJsZSB0byB3cml0ZSBpbmRleC4iCiBtc2dzdHIgIkt1bmRlIGludGUgc2tyaXZhIGluZGV4ZXQuIgogCi0jOiBtaWR4LmM6NjkKKyM6IG1pZHguYzo2OAogIywgYy1mb3JtYXQKIG1zZ2lkICJtdWx0aS1wYWNrLWluZGV4IGZpbGUgJXMgaXMgdG9vIHNtYWxsIgogbXNnc3RyICJtdWx0aS1wYWNrLWluZGV4ZmlsZW4gJXMgw6RyIGbDtnIgbGl0ZW4iCiAKLSM6IG1pZHguYzo4NQorIzogbWlkeC5jOjg0CiAjLCBjLWZvcm1hdAogbXNnaWQgIm11bHRpLXBhY2staW5kZXggc2lnbmF0dXJlIDB4JTA4eCBkb2VzIG5vdCBtYXRjaCBzaWduYXR1cmUgMHglMDh4IgogbXNnc3RyICJtdWx0aS1wYWNrLWluZGV4c2lnbmF0dXJlbiAweCUwOHggc3TDpG1tZXIgaW50ZSBtZWQgc2lnbmF0dXJlbiAweCUwOHgiCiAKLSM6IG1pZHguYzo5MAorIzogbWlkeC5jOjg5CiAjLCBjLWZvcm1hdAogbXNnaWQgIm11bHRpLXBhY2staW5kZXggdmVyc2lvbiAlZCBub3QgcmVjb2duaXplZCIKIG1zZ3N0ciAibXVsdGktcGFjay1pbmRleHZlcnNpb25lbiAlZCBzdMO2ZHMgaW50ZSIKIAotIzogbWlkeC5jOjk1CisjOiBtaWR4LmM6OTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiaGFzaCB2ZXJzaW9uICV1IGRvZXMgbm90IG1hdGNoIgogbXNnc3RyICJoYXNoLXZlcnNpb25lbiAldSBzdMOkbW1lciBpbnRlIgogCi0jOiBtaWR4LmM6MTA5CisjOiBtaWR4LmM6MTA4CiBtc2dpZCAiaW52YWxpZCBjaHVuayBvZmZzZXQgKHRvbyBsYXJnZSkiCiBtc2dzdHIgImZlbGFrdGlndCBvZmZzZXQgZsO2ciBzdHlja2UgKGbDtnIgc3RvcnQpIgogCi0jOiBtaWR4LmM6MTMzCisjOiBtaWR4LmM6MTMyCiBtc2dpZCAidGVybWluYXRpbmcgbXVsdGktcGFjay1pbmRleCBjaHVuayBpZCBhcHBlYXJzIGVhcmxpZXIgdGhhbiBleHBlY3RlZCIKLW1zZ3N0ciAiYXZzbHV0YW5kZSBtdWx0aS1wYWNrLWluZGV4LXN0eWNrZS1JRCBmw7ZyZWtvbW1lciB0aWRpZ2FyZSDDpG4gZsO2cnbDpG50YXQiCittc2dzdHIgImF2c2x1dGFuZGUgbXVsdGktcGFjay1pbmRleC1zdHlja2UtaWQgZsO2cmVrb21tZXIgdGlkaWdhcmUgw6RuIGbDtnJ2w6RudGF0IgogCi0jOiBtaWR4LmM6MTQ2CisjOiBtaWR4LmM6MTQ1CiBtc2dpZCAibXVsdGktcGFjay1pbmRleCBtaXNzaW5nIHJlcXVpcmVkIHBhY2stbmFtZSBjaHVuayIKIG1zZ3N0ciAibXVsdGktcGFjay1pbmRleCBzYWtuYXIga3LDpHZkIHBha2V0bmFtbi1zdHlja2UiCiAKLSM6IG1pZHguYzoxNDgKKyM6IG1pZHguYzoxNDcKIG1zZ2lkICJtdWx0aS1wYWNrLWluZGV4IG1pc3NpbmcgcmVxdWlyZWQgT0lEIGZhbm91dCBjaHVuayIKIG1zZ3N0ciAibXVsdGktcGFjay1pbmRleCBzYWtuYXIga3LDpHZ0IE9JRC11dGJyZWRuaW5nc3N0eWNrZSIKIAotIzogbWlkeC5jOjE1MAorIzogbWlkeC5jOjE0OQogbXNnaWQgIm11bHRpLXBhY2staW5kZXggbWlzc2luZyByZXF1aXJlZCBPSUQgbG9va3VwIGNodW5rIgogbXNnc3RyICJtdWx0aS1wYWNrLWluZGV4IHNha25hciBrcsOkdnQgT0lELXVwcHNsYWduaWduc3N0eWNrZSIKIAotIzogbWlkeC5jOjE1MgorIzogbWlkeC5jOjE1MQogbXNnaWQgIm11bHRpLXBhY2staW5kZXggbWlzc2luZyByZXF1aXJlZCBvYmplY3Qgb2Zmc2V0cyBjaHVuayIKIG1zZ3N0ciAibXVsdGktcGFjay1pbmRleCBzYWtuYXIga3LDpHZ0IG9iamVrdC1vZmZzZXRzdHlja2UiCiAKLSM6IG1pZHguYzoxNjYKKyM6IG1pZHguYzoxNjUKICMsIGMtZm9ybWF0CiBtc2dpZCAibXVsdGktcGFjay1pbmRleCBwYWNrIG5hbWVzIG91dCBvZiBvcmRlcjogJyVzJyBiZWZvcmUgJyVzJyIKIG1zZ3N0ciAibXVsdGktcGFjay1pbmRleC1wYWtldG5hbW4gaSBmZWwgb3JkbmluZzogXCIlc1wiIGbDtnJlIFwiJXNcIiIKIAotIzogbWlkeC5jOjIxMQorIzogbWlkeC5jOjIxMAogIywgYy1mb3JtYXQKIG1zZ2lkICJiYWQgcGFjay1pbnQtaWQ6ICV1ICgldSB0b3RhbCBwYWNrcykiCiBtc2dzdHIgImJhZCBwYWNrLWludC1pZDogJXUgKCV1IHBha2V0IHRvdGFsdCkiCiAKLSM6IG1pZHguYzoyNjEKKyM6IG1pZHguYzoyNjAKIG1zZ2lkICJtdWx0aS1wYWNrLWluZGV4IHN0b3JlcyBhIDY0LWJpdCBvZmZzZXQsIGJ1dCBvZmZfdCBpcyB0b28gc21hbGwiCiBtc2dzdHIgIm11bHRpLXBhY2staW5kZXggc2tyaXZlciA2NC1iaXRhcnMgb2Zmc2V0LCBtZW4gb2ZmX3Qgw6RyIGbDtnIgbGl0ZW4iCiAKLSM6IG1pZHguYzoyODkKKyM6IG1pZHguYzoyODgKIG1zZ2lkICJlcnJvciBwcmVwYXJpbmcgcGFja2ZpbGUgZnJvbSBtdWx0aS1wYWNrLWluZGV4IgogbXNnc3RyICJmZWwgbsOkciBwYWtldGZpbGVyIGZyw6VuIG11bHRpLXBhY2staW5kZXggc2t1bGxlIGbDtnJiZXJlZGFzIgogCi0jOiBtaWR4LmM6NDcwCisjOiBtaWR4LmM6NDY5CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBhZGQgcGFja2ZpbGUgJyVzJyIKIG1zZ3N0ciAibWlzc2x5Y2thZGVzIGzDpHNhIHBha2V0ZmlsZW4gXCIlc1wiIgogCi0jOiBtaWR4LmM6NDc2CisjOiBtaWR4LmM6NDc1CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBvcGVuIHBhY2staW5kZXggJyVzJyIKIG1zZ3N0ciAibWlzc2x5Y2thZGVzIMO2cHBuYSBwYWtldGluZGV4ZXQgXCIlc1wiIgogCi0jOiBtaWR4LmM6NTM2CisjOiBtaWR4LmM6NTM1CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBsb2NhdGUgb2JqZWN0ICVkIGluIHBhY2tmaWxlIgogbXNnc3RyICJtaXNzbHlja2FkZXMgaGl0dGEgb2JqZWt0ICVkIGkgcGFrZXRmaWxlbiIKIAotIzogbWlkeC5jOjg2NQorIzogbWlkeC5jOjg2NAogIywgYy1mb3JtYXQKIG1zZ2lkICJkaWQgbm90IHNlZSBwYWNrLWZpbGUgJXMgdG8gZHJvcCIKIG1zZ3N0ciAic8OlZyBpbnRlIHBha2V0ZmlsZW4gJXMgc29tIHNrdWxsZSBrYXN0YXMiCiAKLSM6IG1pZHguYzoxMDM2CisjOiBtaWR4LmM6MTAzNQogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gY2xlYXIgbXVsdGktcGFjay1pbmRleCBhdCAlcyIKIG1zZ3N0ciAibWlzc2x5Y2thZGVzIHN0w6RkYSBtdWx0aS1wYWNrLWluZGV4IHDDpSAlcyIKIAotIzogbWlkeC5jOjEwOTEKKyM6IG1pZHguYzoxMDkwCiBtc2dpZCAiTG9va2luZyBmb3IgcmVmZXJlbmNlZCBwYWNrZmlsZXMiCiBtc2dzdHIgIlNlciBlZnRlciByZWZlcmVyYWRlIHBhY2tmaWxlciIKIAotIzogbWlkeC5jOjExMDYKKyM6IG1pZHguYzoxMTA1CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJvaWQgZmFub3V0IG91dCBvZiBvcmRlcjogZmFub3V0WyVkXSA9ICU8UFJJeDMyPiA+ICU8UFJJeDMyPiA9IGZhbm91dFslZF0iCiBtc2dzdHIgIiIKICJvaWQtdXRicmVkbmluZyBpIGZlbCBvcmRuaW5nOiBmYW5vdXRbJWRdID0gJTxQUkl4MzI+ID4gJTxQUkl4MzI+ID0gZmFub3V0WyVkXSIKIAotIzogbWlkeC5jOjExMTAKKyM6IG1pZHguYzoxMTA5CiBtc2dpZCAiVmVyaWZ5aW5nIE9JRCBvcmRlciBpbiBNSURYIgogbXNnc3RyICJCZWtyw6RmdGFyIE9JRC1vcmRuaW5nIGkgTUlEWCIKIAotIzogbWlkeC5jOjExMTkKKyM6IG1pZHguYzoxMTE4CiAjLCBjLWZvcm1hdAogbXNnaWQgIm9pZCBsb29rdXAgb3V0IG9mIG9yZGVyOiBvaWRbJWRdID0gJXMgPj0gJXMgPSBvaWRbJWRdIgogbXNnc3RyICJvaWQtdXBwc2xhZ25pbmcgaSBmZWwgb3JkbmluZzogb2lkWyVkXSA9ICVzID49ICVzID0gb2lkWyVkXSIKIAotIzogbWlkeC5jOjExMzgKKyM6IG1pZHguYzoxMTM3CiBtc2dpZCAiU29ydGluZyBvYmplY3RzIGJ5IHBhY2tmaWxlIgogbXNnc3RyICJTb3J0ZXJhciBvYmpla3QgZWZ0ZXIgcGFja2ZpbCIKIAotIzogbWlkeC5jOjExNDQKKyM6IG1pZHguYzoxMTQzCiBtc2dpZCAiVmVyaWZ5aW5nIG9iamVjdCBvZmZzZXRzIgogbXNnc3RyICJCZWtyw6RmdGFyIG9mZnNldCBmw7ZyIG9iamVrdCIKIAotIzogbWlkeC5jOjExNjAKKyM6IG1pZHguYzoxMTU5CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBsb2FkIHBhY2sgZW50cnkgZm9yIG9pZFslZF0gPSAlcyIKIG1zZ3N0ciAibWlzc2x5Y2thZGVzIGzDpHNhIHBha2V0cG9zdCBmw7ZyIG9pZFslZF0gPSAlcyIKIAotIzogbWlkeC5jOjExNjYKKyM6IG1pZHguYzoxMTY1CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBsb2FkIHBhY2staW5kZXggZm9yIHBhY2tmaWxlICVzIgogbXNnc3RyICJtaXNzbHlja2FkZXMgbMOkc2EgcGFrZXRpbmRleCBmw7ZyIHBha2V0ZmlsICVzIgogCi0jOiBtaWR4LmM6MTE3NQorIzogbWlkeC5jOjExNzQKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW5jb3JyZWN0IG9iamVjdCBvZmZzZXQgZm9yIG9pZFslZF0gPSAlczogJTxQUkl4NjQ+ICE9ICU8UFJJeDY0PiIKIG1zZ3N0ciAiZmVsYWt0aWd0IG9iamVrdC1vZmZzZXQgZsO2ciBvaWRbJWRdID0gJXM6ICU8UFJJeDY0PiAhPSAlPFBSSXg2ND4iCiAKLSM6IG1pZHguYzoxMzUwCisjOiBtaWR4LmM6MTM0OQogbXNnaWQgImNvdWxkIG5vdCBzdGFydCBwYWNrLW9iamVjdHMiCiBtc2dzdHIgImt1bmRlIGludGUgc3RhcnRhIHBhY2stb2JqZWN0cyIKIAotIzogbWlkeC5jOjEzNjkKKyM6IG1pZHguYzoxMzY4CiBtc2dpZCAiY291bGQgbm90IGZpbmlzaCBwYWNrLW9iamVjdHMiCiBtc2dzdHIgImt1bmRlIGludGUgYXZzbHV0YSBwYWNrLW9iamVjdHMiCiAKLSM6IG5hbWUtaGFzaC5jOjUzMgorIzogbmFtZS1oYXNoLmM6NTM3CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBjcmVhdGUgbGF6eV9kaXIgdGhyZWFkOiAlcyIKIG1zZ3N0ciAibWlzc2x5Y2thZGVzIHNrYXBhIGxhenlfZGlyLXRyw6VkOiAlcyIKIAotIzogbmFtZS1oYXNoLmM6NTU0CisjOiBuYW1lLWhhc2guYzo1NTkKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGNyZWF0ZSBsYXp5X25hbWUgdGhyZWFkOiAlcyIKIG1zZ3N0ciAibWlzc2x5Y2thZGVzIHNrYXBhIGxhenlfbmFtZS10csOlZDogJXMiCiAKLSM6IG5hbWUtaGFzaC5jOjU2MAorIzogbmFtZS1oYXNoLmM6NTY1CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBqb2luIGxhenlfbmFtZSB0aHJlYWQ6ICVzIgogbXNnc3RyICJtaXNzbHlja2FkZXMgdXRmw7ZyYSBqb2luIHDDpSBsYXp5X25hbWUtdHLDpWQ6ICVzIgpAQCAtNDI0OSw0MSArNDI3NCw0MSBAQAogbXNnaWQgIkJhZCAlcyB2YWx1ZTogJyVzJyIKIG1zZ3N0ciAiRmVsYWt0aWd0IHbDpHJkZSBww6UgJXM6IFwiJXNcIiIKIAotIzogb2JqZWN0LmM6NTQKKyM6IG9iamVjdC5jOjUzCiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgb2JqZWN0IHR5cGUgXCIlc1wiIgogbXNnc3RyICJvZ2lsdGlnIG9iamVrdHR5cCBcIiVzXCIiCiAKLSM6IG9iamVjdC5jOjE3NAorIzogb2JqZWN0LmM6MTczCiAjLCBjLWZvcm1hdAogbXNnaWQgIm9iamVjdCAlcyBpcyBhICVzLCBub3QgYSAlcyIKIG1zZ3N0ciAib2JqZWt0ZXQgJXMgw6RyIGVuICVzLCBpbnRlIGVuICVzIgogCi0jOiBvYmplY3QuYzoyMzQKKyM6IG9iamVjdC5jOjIzMwogIywgYy1mb3JtYXQKIG1zZ2lkICJvYmplY3QgJXMgaGFzIHVua25vd24gdHlwZSBpZCAlZCIKIG1zZ3N0ciAib2JqZWt0ZXQgJXMgaGFyIG9rw6RuZCB0eXAtaWQgJWQiCiAKLSM6IG9iamVjdC5jOjI0NworIzogb2JqZWN0LmM6MjQ2CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBwYXJzZSBvYmplY3Q6ICVzIgogbXNnc3RyICJrdW5kZSBpbnRlIHRvbGthIG9iamVrdGV0OiAlcyIKIAotIzogb2JqZWN0LmM6MjY3IG9iamVjdC5jOjI3OAorIzogb2JqZWN0LmM6MjY2IG9iamVjdC5jOjI3NwogIywgYy1mb3JtYXQKIG1zZ2lkICJoYXNoIG1pc21hdGNoICVzIgogbXNnc3RyICJoYXNodsOkcmRlIHN0w6RtbWVyIGludGUgw7Z2ZXJlbnMgJXMiCiAKLSM6IHBhY2tmaWxlLmM6NjQ4CisjOiBwYWNrZmlsZS5jOjY0MQogbXNnaWQgIm9mZnNldCBiZWZvcmUgZW5kIG9mIHBhY2tmaWxlIChicm9rZW4gLmlkeD8pIgogbXNnc3RyICJvZmZzZXQgZsO2cmUgc2x1dGV0IGF2IHBhY2tmaWxlbiAodHJhc2lnIC5pZHg/KSIKIAotIzogcGFja2ZpbGUuYzoxODk5CisjOiBwYWNrZmlsZS5jOjE4ODcKICMsIGMtZm9ybWF0CiBtc2dpZCAib2Zmc2V0IGJlZm9yZSBzdGFydCBvZiBwYWNrIGluZGV4IGZvciAlcyAoY29ycnVwdCBpbmRleD8pIgogbXNnc3RyICJvZmZzZXQgZsO2cmUgc2x1dGV0IGF2IHBhY2tpbmRleCBmw7ZyICVzICh0cmFzaWd0IGluZGV4PykiCiAKLSM6IHBhY2tmaWxlLmM6MTkwMworIzogcGFja2ZpbGUuYzoxODkxCiAjLCBjLWZvcm1hdAogbXNnaWQgIm9mZnNldCBiZXlvbmQgZW5kIG9mIHBhY2sgaW5kZXggZm9yICVzICh0cnVuY2F0ZWQgaW5kZXg/KSIKIG1zZ3N0ciAib2Zmc2V0IGJvcnRvbiBzbHV0ZXQgYXYgcGFja2luZGV4IGbDtnIgJXMgKHRydW5rZXJhdCBpbmRleD8pIgpAQCAtNDMyOCwyNiArNDM1MywyNiBAQAogbXNnaWQgImRpZCB5b3UgbWVhbiBgLS0lc2AgKHdpdGggdHdvIGRhc2hlcyA/KSIKIG1zZ3N0ciAibWVuYWRlIGR1IFwiLS0lc1wiIChtZWQgdHbDpSBiaW5kZXN0cmVjaz8pIgogCi0jOiBwYXJzZS1vcHRpb25zLmM6ODU5CisjOiBwYXJzZS1vcHRpb25zLmM6ODYwCiAjLCBjLWZvcm1hdAogbXNnaWQgInVua25vd24gb3B0aW9uIGAlcyciCiBtc2dzdHIgIm9rw6RuZCBmbGFnZ2EgXCIlc1wiIgogCi0jOiBwYXJzZS1vcHRpb25zLmM6ODYxCisjOiBwYXJzZS1vcHRpb25zLmM6ODYyCiAjLCBjLWZvcm1hdAogbXNnaWQgInVua25vd24gc3dpdGNoIGAlYyciCiBtc2dzdHIgIm9rw6RuZCBmbGFnZ2EgXCIlY1wiIgogCi0jOiBwYXJzZS1vcHRpb25zLmM6ODYzCisjOiBwYXJzZS1vcHRpb25zLmM6ODY0CiAjLCBjLWZvcm1hdAogbXNnaWQgInVua25vd24gbm9uLWFzY2lpIG9wdGlvbiBpbiBzdHJpbmc6IGAlcyciCiBtc2dzdHIgIm9rw6RuZCBpY2tlLWFzY2lpLWZsYWdnYSBpIHN0csOkbmdlbjogXCIlc1wiIgogCi0jOiBwYXJzZS1vcHRpb25zLmM6ODg3CisjOiBwYXJzZS1vcHRpb25zLmM6ODg4CiBtc2dpZCAiLi4uIgogbXNnc3RyICIuLi4iCiAKLSM6IHBhcnNlLW9wdGlvbnMuYzo5MDYKKyM6IHBhcnNlLW9wdGlvbnMuYzo5MDcKICMsIGMtZm9ybWF0CiBtc2dpZCAidXNhZ2U6ICVzIgogbXNnc3RyICJhbnbDpG5kbmluZzogJXMiCkBAIC00MzU1LDIxICs0MzgwLDIxIEBACiAjLiBUUkFOU0xBVE9SUzogdGhlIGNvbG9uIGhlcmUgc2hvdWxkIGFsaWduIHdpdGggdGhlCiAjLiBvbmUgaW4gInVzYWdlOiAlcyIgdHJhbnNsYXRpb24uCiAjLgotIzogcGFyc2Utb3B0aW9ucy5jOjkxMgorIzogcGFyc2Utb3B0aW9ucy5jOjkxMwogIywgYy1mb3JtYXQKIG1zZ2lkICIgICBvcjogJXMiCiBtc2dzdHIgIiAgICAgZWxsZXI6ICVzIgogCi0jOiBwYXJzZS1vcHRpb25zLmM6OTE1CisjOiBwYXJzZS1vcHRpb25zLmM6OTE2CiAjLCBjLWZvcm1hdAogbXNnaWQgIiAgICAlcyIKIG1zZ3N0ciAiICAgICVzIgogCi0jOiBwYXJzZS1vcHRpb25zLmM6OTU0CisjOiBwYXJzZS1vcHRpb25zLmM6OTU1CiBtc2dpZCAiLU5VTSIKIG1zZ3N0ciAiLVRBTCIKIAotIzogcGFyc2Utb3B0aW9ucy5jOjk2OAorIzogcGFyc2Utb3B0aW9ucy5jOjk2OQogIywgYy1mb3JtYXQKIG1zZ2lkICJhbGlhcyBvZiAtLSVzIgogbXNnc3RyICJhbGlhcyBmw7ZyIC0tJXMiCkBAIC00NTM4LDI5ICs0NTYzLDM4IEBACiBtc2dpZCAidW5hYmxlIHRvIHBhcnNlIC0tcHJldHR5IGZvcm1hdCIKIG1zZ3N0ciAia3VuZGUgaW50ZSB0b2xrYSBmb3JtYXQgZsO2ciAtLXByZXR0eSIKIAotIzogcmFuZ2UtZGlmZi5jOjcwCisjOiBwcm9taXNvci1yZW1vdGUuYzoyNQorbXNnaWQgIlJlbW90ZSB3aXRoIG5vIFVSTCIKK21zZ3N0ciAiRmrDpHJyIHV0YW4gVVJMIgorCisjOiBwcm9taXNvci1yZW1vdGUuYzo2MQorIywgYy1mb3JtYXQKK21zZ2lkICJwcm9taXNvciByZW1vdGUgbmFtZSBjYW5ub3QgYmVnaW4gd2l0aCAnLyc6ICVzIgorbXNnc3RyICJrb250cmFrdHNmasOkcnIga2FuIGludGUgYsO2cmphIG1lZCBcIi9cIjogJXMiCisKKyM6IHJhbmdlLWRpZmYuYzo3MQogbXNnaWQgImNvdWxkIG5vdCBzdGFydCBgbG9nYCIKIG1zZ3N0ciAia3VuZGUgaW50ZSBzdGFydGEgXCJsb2dcIiIKIAotIzogcmFuZ2UtZGlmZi5jOjcyCisjOiByYW5nZS1kaWZmLmM6NzMKIG1zZ2lkICJjb3VsZCBub3QgcmVhZCBgbG9nYCBvdXRwdXQiCiBtc2dzdHIgImt1bmRlIGludGUgbMOkc2EgdXRkYXRhIGZyw6VuIFwibG9nXCIiCiAKLSM6IHJhbmdlLWRpZmYuYzo5MSBzZXF1ZW5jZXIuYzo1MDIxCisjOiByYW5nZS1kaWZmLmM6OTIgc2VxdWVuY2VyLmM6NDk4NQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcGFyc2UgY29tbWl0ICclcyciCiBtc2dzdHIgImt1bmRlIGludGUgdG9sa2EgaW5jaGVja25pbmdlbiBcIiVzXCIiCiAKLSM6IHJhbmdlLWRpZmYuYzoxMTcKKyM6IHJhbmdlLWRpZmYuYzoxMTgKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHBhcnNlIGdpdCBoZWFkZXIgJyUuKnMnIgogbXNnc3RyICJrdW5kZSBpbnRlIHRvbGthIGdpdC1odXZ1ZGV0IFwiJS4qc1wiIgogCi0jOiByYW5nZS1kaWZmLmM6Mjc0CisjOiByYW5nZS1kaWZmLmM6Mjc1CiBtc2dpZCAiZmFpbGVkIHRvIGdlbmVyYXRlIGRpZmYiCiBtc2dzdHIgIm1pc3NseWNrYWRlcyBza2FwYSBkaWZmIgogCi0jOiByYW5nZS1kaWZmLmM6NTA2IHJhbmdlLWRpZmYuYzo1MDgKKyM6IHJhbmdlLWRpZmYuYzo1MDcgcmFuZ2UtZGlmZi5jOjUwOQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcGFyc2UgbG9nIGZvciAnJXMnIgogbXNnc3RyICJrdW5kZSBpbnRlIHRvbGthIGxvZ2dlbiBmw7ZyIFwiJXNcIiIKQEAgLTQ2MDUsMTEgKzQ2MzksMTEgQEAKIG1zZ2lkICInJXMnIGFwcGVhcnMgYXMgYm90aCBhIGZpbGUgYW5kIGFzIGEgZGlyZWN0b3J5IgogbXNnc3RyICJcIiVzXCIgZmlubnMgYsOlZGUgc29tIGVuIGZpbCBvY2ggZW4ga2F0YWxvZyIKIAotIzogcmVhZC1jYWNoZS5jOjE0OTkKKyM6IHJlYWQtY2FjaGUuYzoxNTIwCiBtc2dpZCAiUmVmcmVzaCBpbmRleCIKIG1zZ3N0ciAiVXBwZGF0ZXJhIGluZGV4ZXQiCiAKLSM6IHJlYWQtY2FjaGUuYzoxNjEzCisjOiByZWFkLWNhY2hlLmM6MTYzNQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiaW5kZXgudmVyc2lvbiBzZXQsIGJ1dCB0aGUgdmFsdWUgaXMgaW52YWxpZC5cbiIKQEAgLTQ2MTgsNyArNDY1Miw3IEBACiAiaW5kZXgudmVyc2lvbiBzYXR0LCBtZW4gdsOkcmRldCDDpHIgb2dpbHRpZ3QuXG4iCiAiQW52w6RuZGVyIHZlcnNpb24gJWkiCiAKLSM6IHJlYWQtY2FjaGUuYzoxNjIzCisjOiByZWFkLWNhY2hlLmM6MTY0NQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiR0lUX0lOREVYX1ZFUlNJT04gc2V0LCBidXQgdGhlIHZhbHVlIGlzIGludmFsaWQuXG4iCkBAIC00NjI3LDEzOCArNDY2MSwxMzggQEAKICJHSVRfSU5ERVhfVkVSU0lPTiBzYXR0LCBtZW4gdsOkcmRldCDDpHIgb2dpbHRpZ3QuXG4iCiAiQW52w6RuZGVyIHZlcnNpb24gJWkiCiAKLSM6IHJlYWQtY2FjaGUuYzoxNjc5CisjOiByZWFkLWNhY2hlLmM6MTcwMQogIywgYy1mb3JtYXQKIG1zZ2lkICJiYWQgc2lnbmF0dXJlIDB4JTA4eCIKIG1zZ3N0ciAiZmVsYWt0aWcgc2lnbmF0dXIgMHglMDh4IgogCi0jOiByZWFkLWNhY2hlLmM6MTY4MgorIzogcmVhZC1jYWNoZS5jOjE3MDQKICMsIGMtZm9ybWF0CiBtc2dpZCAiYmFkIGluZGV4IHZlcnNpb24gJWQiCiBtc2dzdHIgImZlbGFrdGlnIGluZGV4dmVyc2lvbiAlZCIKIAotIzogcmVhZC1jYWNoZS5jOjE2OTEKKyM6IHJlYWQtY2FjaGUuYzoxNzEzCiBtc2dpZCAiYmFkIGluZGV4IGZpbGUgc2hhMSBzaWduYXR1cmUiCiBtc2dzdHIgImZlbGFrdGlnIHNoYTEtc2lnbmF0dXIgZsO2ciBpbmRleGZpbCIKIAotIzogcmVhZC1jYWNoZS5jOjE3MjEKKyM6IHJlYWQtY2FjaGUuYzoxNzQzCiAjLCBjLWZvcm1hdAogbXNnaWQgImluZGV4IHVzZXMgJS40cyBleHRlbnNpb24sIHdoaWNoIHdlIGRvIG5vdCB1bmRlcnN0YW5kIgogbXNnc3RyICJpbmRleCBhbnbDpG5kZXIgZmlsdGlsbMOkZ2dldCAlLjRzLCB2aWxrZXQgdmkgaW50ZSBmw7Zyc3TDpXIiCiAKLSM6IHJlYWQtY2FjaGUuYzoxNzIzCisjOiByZWFkLWNhY2hlLmM6MTc0NQogIywgYy1mb3JtYXQKIG1zZ2lkICJpZ25vcmluZyAlLjRzIGV4dGVuc2lvbiIKIG1zZ3N0ciAiaWdub3JlcmFyIGZpbHRpbGzDpGdnZXQgJS40cyIKIAotIzogcmVhZC1jYWNoZS5jOjE3NjAKKyM6IHJlYWQtY2FjaGUuYzoxNzgyCiAjLCBjLWZvcm1hdAogbXNnaWQgInVua25vd24gaW5kZXggZW50cnkgZm9ybWF0IDB4JTA4eCIKIG1zZ3N0ciAib2vDpG50IGZvcm1hdCAweCUwOHggcMOlIGluZGV4cG9zdCIKIAotIzogcmVhZC1jYWNoZS5jOjE3NzYKKyM6IHJlYWQtY2FjaGUuYzoxNzk4CiAjLCBjLWZvcm1hdAogbXNnaWQgIm1hbGZvcm1lZCBuYW1lIGZpZWxkIGluIHRoZSBpbmRleCwgbmVhciBwYXRoICclcyciCiBtc2dzdHIgImZlbGZvcm1hdCBuYW1uZsOkbHQgaSBpbmRleGV0LCBuw6RyYSBzw7ZrdsOkZ2VuIFwiJXNcIiIKIAotIzogcmVhZC1jYWNoZS5jOjE4MzMKKyM6IHJlYWQtY2FjaGUuYzoxODU1CiBtc2dpZCAidW5vcmRlcmVkIHN0YWdlIGVudHJpZXMgaW4gaW5kZXgiCiBtc2dzdHIgIm9zb3J0ZXJhZGUga8O2cG9zdGVyIGkgaW5kZXgiCiAKLSM6IHJlYWQtY2FjaGUuYzoxODM2CisjOiByZWFkLWNhY2hlLmM6MTg1OAogIywgYy1mb3JtYXQKIG1zZ2lkICJtdWx0aXBsZSBzdGFnZSBlbnRyaWVzIGZvciBtZXJnZWQgZmlsZSAnJXMnIgogbXNnc3RyICJmbGVyYSBrw7Zwb3N0ZXIgZsO2ciBkZW4gc2FtbWFuc2xhZ25hIGZpbGVuIFwiJXNcIiIKIAotIzogcmVhZC1jYWNoZS5jOjE4MzkKKyM6IHJlYWQtY2FjaGUuYzoxODYxCiAjLCBjLWZvcm1hdAogbXNnaWQgInVub3JkZXJlZCBzdGFnZSBlbnRyaWVzIGZvciAnJXMnIgogbXNnc3RyICJvc29ydGVyYWRlIGvDtnBvc3RlciBmw7ZyIFwiJXNcIiIKIAotIzogcmVhZC1jYWNoZS5jOjE5NDYgcmVhZC1jYWNoZS5jOjIyMzQgcmVyZXJlLmM6NTY1IHJlcmVyZS5jOjU5OSByZXJlcmUuYzoxMTExCi0jOiBidWlsdGluL2FkZC5jOjQ2MCBidWlsdGluL2NoZWNrLWlnbm9yZS5jOjE3OCBidWlsdGluL2NoZWNrb3V0LmM6NDY3Ci0jOiBidWlsdGluL2NoZWNrb3V0LmM6NjUxIGJ1aWx0aW4vY2xlYW4uYzo5NTYgYnVpbHRpbi9jb21taXQuYzozNDcKKyM6IHJlYWQtY2FjaGUuYzoxOTY3IHJlYWQtY2FjaGUuYzoyMjU1IHJlcmVyZS5jOjU2NSByZXJlcmUuYzo1OTkgcmVyZXJlLmM6MTExMQorIzogYnVpbHRpbi9hZGQuYzo0NjAgYnVpbHRpbi9jaGVjay1pZ25vcmUuYzoxNzggYnVpbHRpbi9jaGVja291dC5jOjQ2OAorIzogYnVpbHRpbi9jaGVja291dC5jOjY1MiBidWlsdGluL2NsZWFuLmM6OTY3IGJ1aWx0aW4vY29tbWl0LmM6MzQ3CiAjOiBidWlsdGluL2RpZmYtdHJlZS5jOjEyMCBidWlsdGluL2dyZXAuYzo0OTkgYnVpbHRpbi9tdi5jOjE0NQogIzogYnVpbHRpbi9yZXNldC5jOjI0NSBidWlsdGluL3JtLmM6MjcxIGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzozMzAKIG1zZ2lkICJpbmRleCBmaWxlIGNvcnJ1cHQiCiBtc2dzdHIgImluZGV4ZmlsZW4gdHJhc2lnIgogCi0jOiByZWFkLWNhY2hlLmM6MjA4NworIzogcmVhZC1jYWNoZS5jOjIxMDgKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGNyZWF0ZSBsb2FkX2NhY2hlX2VudHJpZXMgdGhyZWFkOiAlcyIKIG1zZ3N0ciAia3VuZGUgaW50ZSBsw6RzYSBpbiBjYWNoZV9lbnRyaWVzLXRyw6VkZW46ICVzIgogCi0jOiByZWFkLWNhY2hlLmM6MjEwMAorIzogcmVhZC1jYWNoZS5jOjIxMjEKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGpvaW4gbG9hZF9jYWNoZV9lbnRyaWVzIHRocmVhZDogJXMiCiBtc2dzdHIgImt1bmRlIGludGUgdXRmw7ZyYSBqb2luIHDDpSBjYWNoZV9lbnRyaWVzLXRyw6VkZW46ICVzIgogCi0jOiByZWFkLWNhY2hlLmM6MjEzMworIzogcmVhZC1jYWNoZS5jOjIxNTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXM6IGluZGV4IGZpbGUgb3BlbiBmYWlsZWQiCiBtc2dzdHIgIiVzOiDDtnBwbmluZyBhdiBpbmRleGZpbGVuIG1pc3NseWNrYWRlcyIKIAotIzogcmVhZC1jYWNoZS5jOjIxMzcKKyM6IHJlYWQtY2FjaGUuYzoyMTU4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiBjYW5ub3Qgc3RhdCB0aGUgb3BlbiBpbmRleCIKIG1zZ3N0ciAiJXM6IGthbiBpbnRlIHRhIHN0YXJ0dXMgcMOlIGRldCDDtnBwbmEgaW5kZXhldCIKIAotIzogcmVhZC1jYWNoZS5jOjIxNDEKKyM6IHJlYWQtY2FjaGUuYzoyMTYyCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiBpbmRleCBmaWxlIHNtYWxsZXIgdGhhbiBleHBlY3RlZCIKIG1zZ3N0ciAiJXM6IGluZGV4ZmlsZW4gbWluZHJlIMOkbiBmw7ZydsOkbnRhdCIKIAotIzogcmVhZC1jYWNoZS5jOjIxNDUKKyM6IHJlYWQtY2FjaGUuYzoyMTY2CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiB1bmFibGUgdG8gbWFwIGluZGV4IGZpbGUiCiBtc2dzdHIgIiVzOiBrYW4gaW50ZSBrb3BwbGEgaW5kZXhmaWxlbiIKIAotIzogcmVhZC1jYWNoZS5jOjIxODcKKyM6IHJlYWQtY2FjaGUuYzoyMjA4CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBjcmVhdGUgbG9hZF9pbmRleF9leHRlbnNpb25zIHRocmVhZDogJXMiCiBtc2dzdHIgImt1bmRlIGludGUgc2thcGEgbG9hZF9pbmRleF9leHRlbnNpb25zLXRyw6VkZW46ICVzIgogCi0jOiByZWFkLWNhY2hlLmM6MjIxNAorIzogcmVhZC1jYWNoZS5jOjIyMzUKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGpvaW4gbG9hZF9pbmRleF9leHRlbnNpb25zIHRocmVhZDogJXMiCiBtc2dzdHIgImt1bmRlIGludGUgdXRmw7ZyYSBqb2luIHDDpSBsb2FkX2luZGV4X2V4dGVuc2lvbnMtdHLDpWRlbjogJXMiCiAKLSM6IHJlYWQtY2FjaGUuYzoyMjQ2CisjOiByZWFkLWNhY2hlLmM6MjI2NwogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgZnJlc2hlbiBzaGFyZWQgaW5kZXggJyVzJyIKIG1zZ3N0ciAia3VuZGUgaW50ZSB1cHBkYXRlcmEgZGVsYXQgaW5kZXggXCIlc1wiIgogCi0jOiByZWFkLWNhY2hlLmM6MjI5MworIzogcmVhZC1jYWNoZS5jOjIzMTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiYnJva2VuIGluZGV4LCBleHBlY3QgJXMgaW4gJXMsIGdvdCAlcyIKIG1zZ3N0ciAidHJhc2lndCBpbmRleCwgZsO2cnbDpG50YWRlICVzIGkgJXMsIGZpY2sgJXMiCiAKLSM6IHJlYWQtY2FjaGUuYzoyOTg5IHdyYXBwZXIuYzo2NTggYnVpbHRpbi9tZXJnZS5jOjExMTQKKyM6IHJlYWQtY2FjaGUuYzozMDEwIHdyYXBwZXIuYzo2MjIgYnVpbHRpbi9tZXJnZS5jOjExMTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGNsb3NlICclcyciCiBtc2dzdHIgImt1bmRlIGludGUgc3TDpG5nYSBcIiVzXCIiCiAKLSM6IHJlYWQtY2FjaGUuYzozMDkyIHNlcXVlbmNlci5jOjIzNTggc2VxdWVuY2VyLmM6MzkyOAorIzogcmVhZC1jYWNoZS5jOjMxMTMgc2VxdWVuY2VyLmM6MjI5NiBzZXF1ZW5jZXIuYzozOTE3CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBzdGF0ICclcyciCiBtc2dzdHIgImt1bmRlIGludGUgdGEgc3RhdHVzIHDDpSBcIiVzXCIiCiAKLSM6IHJlYWQtY2FjaGUuYzozMTA1CisjOiByZWFkLWNhY2hlLmM6MzEyNgogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gb3BlbiBnaXQgZGlyOiAlcyIKIG1zZ3N0ciAia3VuZGUgaW50ZSDDtnBwbmEgZ2l0LWthdGFsb2c6ICVzIgogCi0jOiByZWFkLWNhY2hlLmM6MzExNworIzogcmVhZC1jYWNoZS5jOjMxMzgKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHVubGluazogJXMiCiBtc2dzdHIgIm1pc3NseWNrYWRlcyB0YSBib3J0IGzDpG5rZW46ICVzIgogCi0jOiByZWFkLWNhY2hlLmM6MzE0MgorIzogcmVhZC1jYWNoZS5jOjMxNjMKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IGZpeCBwZXJtaXNzaW9uIGJpdHMgb24gJyVzJyIKIG1zZ3N0ciAia2FuIGludGUgcsOkdHRhIGJlaMO2cmlnaGV0c2JpdGFyIHDDpSBcIiVzXCIiCiAKLSM6IHJlYWQtY2FjaGUuYzozMjkxCisjOiByZWFkLWNhY2hlLmM6MzMxMgogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogY2Fubm90IGRyb3AgdG8gc3RhZ2UgIzAiCiBtc2dzdHIgIiVzOiBrYW4gaW50ZSDDpXRlcmfDpSB0aWxsIGvDtiAwIgpAQCAtNDg2Niw4ICs0OTAwLDggQEAKIG1zZ2lkICJOb3RlIHRoYXQgZW1wdHkgY29tbWl0cyBhcmUgY29tbWVudGVkIG91dCIKIG1zZ3N0ciAiT2JzZXJ2ZXJhIGF0dCB0b21tYSBpbmNoZWNrbmluZ2FyIMOkciB1dGtvbW1lbnRlcmFkZSIKIAotIzogcmViYXNlLWludGVyYWN0aXZlLmM6MTA1IHJlcmVyZS5jOjQ4NSByZXJlcmUuYzo2OTIgc2VxdWVuY2VyLmM6MzQ0NwotIzogc2VxdWVuY2VyLmM6MzQ3MyBzZXF1ZW5jZXIuYzo1MTIwIGJ1aWx0aW4vZnNjay5jOjM1NiBidWlsdGluL3JlYmFzZS5jOjIzNQorIzogcmViYXNlLWludGVyYWN0aXZlLmM6MTA1IHJlcmVyZS5jOjQ4NSByZXJlcmUuYzo2OTIgc2VxdWVuY2VyLmM6MzM4OAorIzogc2VxdWVuY2VyLmM6MzQxNCBzZXF1ZW5jZXIuYzo1MDg0IGJ1aWx0aW4vZnNjay5jOjM1NiBidWlsdGluL3JlYmFzZS5jOjIzNQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3Qgd3JpdGUgJyVzJyIKIG1zZ3N0ciAia3VuZGUgaW50ZSBza3JpdmEgXCIlc1wiIgpAQCAtNDkxNiw3ICs0OTUwLDcgQEAKIG1zZ2lkICJpZ25vcmluZyBkYW5nbGluZyBzeW1yZWYgJXMiCiBtc2dzdHIgImlnbm9yZXJhciBkaW5nbGFuZGUgc3ltYm9saXNrIHJlZmVyZW5zICVzIgogCi0jOiByZWZzLmM6NjY5IHJlZi1maWx0ZXIuYzoyMDkyCisjOiByZWZzLmM6NjY5IHJlZi1maWx0ZXIuYzoyMDk4CiAjLCBjLWZvcm1hdAogbXNnaWQgImlnbm9yaW5nIGJyb2tlbiByZWYgJXMiCiBtc2dzdHIgImlnbm9yZXJhciB0cmFzaWcgcmVmZXJlbnMgJXMiCkBAIC00OTQxLDE0ICs0OTc1LDE0IEBACiBtc2dpZCAidW5leHBlY3RlZCBvYmplY3QgSUQgd2hlbiB3cml0aW5nICclcyciCiBtc2dzdHIgIm92w6RudGF0IG9iamVrdC1pZCB2aWQgc2tyaXZuaW5nIFwiJXNcIiIKIAotIzogcmVmcy5jOjgzMyBzZXF1ZW5jZXIuYzo0MDMgc2VxdWVuY2VyLmM6MjcwOSBzZXF1ZW5jZXIuYzoyOTEzCi0jOiBzZXF1ZW5jZXIuYzoyOTI3IHNlcXVlbmNlci5jOjMxODQgc2VxdWVuY2VyLmM6NTAzNyB3cmFwcGVyLmM6NjU2CisjOiByZWZzLmM6ODMzIHNlcXVlbmNlci5jOjQwMyBzZXF1ZW5jZXIuYzoyNjQ3IHNlcXVlbmNlci5jOjI4NTEKKyM6IHNlcXVlbmNlci5jOjI4NjUgc2VxdWVuY2VyLmM6MzEyMiBzZXF1ZW5jZXIuYzo1MDAxIHdyYXBwZXIuYzo2MjAKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHdyaXRlIHRvICclcyciCiBtc2dzdHIgImt1bmRlIGludGUgc2tyaXZhIHRpbGwgXCIlc1wiIgogCi0jOiByZWZzLmM6ODYwIHdyYXBwZXIuYzoyMjUgd3JhcHBlci5jOjM5NSBidWlsdGluL2FtLmM6NzE1Ci0jOiBidWlsdGluL3JlYmFzZS5jOjEwMDMKKyM6IHJlZnMuYzo4NjAgd3JhcHBlci5jOjE4OCB3cmFwcGVyLmM6MzU4IGJ1aWx0aW4vYW0uYzo3MTQKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTAwNAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3Qgb3BlbiAnJXMnIGZvciB3cml0aW5nIgogbXNnc3RyICJrdW5kZSBpbnRlIMO2cHBuYSBcIiVzXCIgZsO2ciBza3Jpdm5pbmciCkBAIC00OTgzLDIxICs1MDE3LDIxIEBACiBtc2dpZCAidXBkYXRlX3JlZiBmYWlsZWQgZm9yIHJlZiAnJXMnOiAlcyIKIG1zZ3N0ciAidXBkYXRlX3JlZiBtaXNzbHlja2FkZXMgZsO2ciByZWZlcmVuc2VuIFwiJXNcIjogJXMiCiAKLSM6IHJlZnMuYzoyMDEyCisjOiByZWZzLmM6MjAyMwogIywgYy1mb3JtYXQKIG1zZ2lkICJtdWx0aXBsZSB1cGRhdGVzIGZvciByZWYgJyVzJyBub3QgYWxsb3dlZCIKIG1zZ3N0ciAiZmxlcmEgdXBwZGF0ZXJpbmdhciBmw7ZyIHJlZmVyZW5zZW4gXCIlc1wiIHRpbGzDpXRzIGludGUiCiAKLSM6IHJlZnMuYzoyMDQ0CisjOiByZWZzLmM6MjA1NQogbXNnaWQgInJlZiB1cGRhdGVzIGZvcmJpZGRlbiBpbnNpZGUgcXVhcmFudGluZSBlbnZpcm9ubWVudCIKIG1zZ3N0ciAicmVmZXJlbnN1cHBkYXRlcmluZ2FyIGbDtnJianVkbmEgaSBrYXJhbnTDpG5taWxqw7YiCiAKLSM6IHJlZnMuYzoyMTQwIHJlZnMuYzoyMTcwCisjOiByZWZzLmM6MjE1MSByZWZzLmM6MjE4MQogIywgYy1mb3JtYXQKIG1zZ2lkICInJXMnIGV4aXN0czsgY2Fubm90IGNyZWF0ZSAnJXMnIgogbXNnc3RyICJcIiVzXCIgZmlubnM7IGthbiBpbnRlIHNrYXBhIFwiJXNcIiIKIAotIzogcmVmcy5jOjIxNDYgcmVmcy5jOjIxODEKKyM6IHJlZnMuYzoyMTU3IHJlZnMuYzoyMTkyCiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCBwcm9jZXNzICclcycgYW5kICclcycgYXQgdGhlIHNhbWUgdGltZSIKIG1zZ3N0ciAia2FuIGludGUgaGFudGVyYSBcIiVzXCIgb2NoIFwiJXNcIiBzYW10aWRpZ3QiCkBAIC01MDA3LDEzICs1MDQxLDEzIEBACiBtc2dpZCAiY291bGQgbm90IHJlbW92ZSByZWZlcmVuY2UgJXMiCiBtc2dzdHIgImt1bmRlIGludGUgdGEgYm9ydCByZWZlcmVuc2VuICVzIgogCi0jOiByZWZzL2ZpbGVzLWJhY2tlbmQuYzoxMjQ4IHJlZnMvcGFja2VkLWJhY2tlbmQuYzoxNTMyCi0jOiByZWZzL3BhY2tlZC1iYWNrZW5kLmM6MTU0MgorIzogcmVmcy9maWxlcy1iYWNrZW5kLmM6MTI0OCByZWZzL3BhY2tlZC1iYWNrZW5kLmM6MTU0MQorIzogcmVmcy9wYWNrZWQtYmFja2VuZC5jOjE1NTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGRlbGV0ZSByZWZlcmVuY2UgJXM6ICVzIgogbXNnc3RyICJrdW5kZSBpbnRlIHRhIGJvcnQgcmVmZXJlbnNlbiAlczogJXMiCiAKLSM6IHJlZnMvZmlsZXMtYmFja2VuZC5jOjEyNTEgcmVmcy9wYWNrZWQtYmFja2VuZC5jOjE1NDUKKyM6IHJlZnMvZmlsZXMtYmFja2VuZC5jOjEyNTEgcmVmcy9wYWNrZWQtYmFja2VuZC5jOjE1NTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGRlbGV0ZSByZWZlcmVuY2VzOiAlcyIKIG1zZ3N0ciAia3VuZGUgaW50ZSB0YSBib3J0IHJlZmVyZW5zZXI6ICVzIgpAQCAtNTAyMyw3ICs1MDU3LDcgQEAKIG1zZ2lkICJpbnZhbGlkIHJlZnNwZWMgJyVzJyIKIG1zZ3N0ciAiZmVsYWt0aWcgcmVmZXJlbnNzcGVjaWZpa2F0aW9uOiBcIiVzXCIiCiAKLSM6IHJlZi1maWx0ZXIuYzo0MiB3dC1zdGF0dXMuYzoxOTM0CisjOiByZWYtZmlsdGVyLmM6NDIgd3Qtc3RhdHVzLmM6MTkzOAogbXNnaWQgImdvbmUiCiBtc2dzdHIgImbDtnJzdnVubmVuIgogCkBAIC01MDQyLDI4MSArNTA3NiwyODEgQEAKIG1zZ2lkICJhaGVhZCAlZCwgYmVoaW5kICVkIgogbXNnc3RyICJmw7ZyZSAlZCwgYmFrb20gJWQiCiAKLSM6IHJlZi1maWx0ZXIuYzoxNjIKKyM6IHJlZi1maWx0ZXIuYzoxNjUKICMsIGMtZm9ybWF0CiBtc2dpZCAiZXhwZWN0ZWQgZm9ybWF0OiAlJShjb2xvcjo8Y29sb3I+KSIKIG1zZ3N0ciAiZsO2cnbDpG50YXQgZm9ybWF0OiAlJShjb2xvcjo8Y29sb3I+KSIKIAotIzogcmVmLWZpbHRlci5jOjE2NAorIzogcmVmLWZpbHRlci5jOjE2NwogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bnJlY29nbml6ZWQgY29sb3I6ICUlKGNvbG9yOiVzKSIKIG1zZ3N0ciAib2vDpG5kIGbDpHJnOiAlJShjb2xvcjolcykiCiAKLSM6IHJlZi1maWx0ZXIuYzoxODYKKyM6IHJlZi1maWx0ZXIuYzoxODkKICMsIGMtZm9ybWF0CiBtc2dpZCAiSW50ZWdlciB2YWx1ZSBleHBlY3RlZCByZWZuYW1lOmxzdHJpcD0lcyIKIG1zZ3N0ciAiSGVsdGFsc3bDpHJkZSBmw7ZydsOkbnRhZGVzIHJlZm5hbWU6bHN0cmlwPSVzIgogCi0jOiByZWYtZmlsdGVyLmM6MTkwCisjOiByZWYtZmlsdGVyLmM6MTkzCiAjLCBjLWZvcm1hdAogbXNnaWQgIkludGVnZXIgdmFsdWUgZXhwZWN0ZWQgcmVmbmFtZTpyc3RyaXA9JXMiCiBtc2dzdHIgIkhlbHRhbHN2w6RyZGUgZsO2cnbDpG50YWRlcyByZWZuYW1lOnJzdHJpcD0lcyIKIAotIzogcmVmLWZpbHRlci5jOjE5MgorIzogcmVmLWZpbHRlci5jOjE5NQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bnJlY29nbml6ZWQgJSUoJXMpIGFyZ3VtZW50OiAlcyIKIG1zZ3N0ciAib2vDpG50ICUlKCVzKS1hcmd1bWVudDogJXMiCiAKLSM6IHJlZi1maWx0ZXIuYzoyNDcKKyM6IHJlZi1maWx0ZXIuYzoyNTAKICMsIGMtZm9ybWF0CiBtc2dpZCAiJSUob2JqZWN0dHlwZSkgZG9lcyBub3QgdGFrZSBhcmd1bWVudHMiCiBtc2dzdHIgIiUlKG9iamVjdHR5cGUpIHRhciBpbnRlIGFyZ3VtZW50IgogCi0jOiByZWYtZmlsdGVyLmM6MjY5CisjOiByZWYtZmlsdGVyLmM6MjcyCiAjLCBjLWZvcm1hdAogbXNnaWQgInVucmVjb2duaXplZCAlJShvYmplY3RzaXplKSBhcmd1bWVudDogJXMiCiBtc2dzdHIgIm9rw6RudCAlJShvYmplY3RzaXplKS1hcmd1bWVudDogJXMiCiAKLSM6IHJlZi1maWx0ZXIuYzoyNzcKKyM6IHJlZi1maWx0ZXIuYzoyODAKICMsIGMtZm9ybWF0CiBtc2dpZCAiJSUoZGVsdGFiYXNlKSBkb2VzIG5vdCB0YWtlIGFyZ3VtZW50cyIKIG1zZ3N0ciAiJSUoZGVsdGFiYXNlKSB0YXIgaW50ZSBhcmd1bWVudCIKIAotIzogcmVmLWZpbHRlci5jOjI4OQorIzogcmVmLWZpbHRlci5jOjI5MgogIywgYy1mb3JtYXQKIG1zZ2lkICIlJShib2R5KSBkb2VzIG5vdCB0YWtlIGFyZ3VtZW50cyIKIG1zZ3N0ciAiJSUoYm9keSkgdGFyIGludGUgYXJndW1lbnQiCiAKLSM6IHJlZi1maWx0ZXIuYzoyOTgKKyM6IHJlZi1maWx0ZXIuYzozMDEKICMsIGMtZm9ybWF0CiBtc2dpZCAiJSUoc3ViamVjdCkgZG9lcyBub3QgdGFrZSBhcmd1bWVudHMiCiBtc2dzdHIgIiUlKHN1YmplY3QpIHRhciBpbnRlIGFyZ3VtZW50IgogCi0jOiByZWYtZmlsdGVyLmM6MzIwCisjOiByZWYtZmlsdGVyLmM6MzIzCiAjLCBjLWZvcm1hdAogbXNnaWQgInVua25vd24gJSUodHJhaWxlcnMpIGFyZ3VtZW50OiAlcyIKIG1zZ3N0ciAib2vDpG50ICUlKHRyYWlsZXJzKS1hcmd1bWVudDogJXMiCiAKLSM6IHJlZi1maWx0ZXIuYzozNDkKKyM6IHJlZi1maWx0ZXIuYzozNTIKICMsIGMtZm9ybWF0CiBtc2dpZCAicG9zaXRpdmUgdmFsdWUgZXhwZWN0ZWQgY29udGVudHM6bGluZXM9JXMiCiBtc2dzdHIgInBvc2l0aXZ0IHbDpHJkZSBmw7ZydsOkbnRhdCBjb250ZW50czpsaW5lcz0lcyIKIAotIzogcmVmLWZpbHRlci5jOjM1MQorIzogcmVmLWZpbHRlci5jOjM1NAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bnJlY29nbml6ZWQgJSUoY29udGVudHMpIGFyZ3VtZW50OiAlcyIKIG1zZ3N0ciAib2vDpG50ICUlKGNvbnRlbnRzKS1hcmd1bWVudDogJXMiCiAKLSM6IHJlZi1maWx0ZXIuYzozNjYKKyM6IHJlZi1maWx0ZXIuYzozNjkKICMsIGMtZm9ybWF0CiBtc2dpZCAicG9zaXRpdmUgdmFsdWUgZXhwZWN0ZWQgb2JqZWN0bmFtZTpzaG9ydD0lcyIKIG1zZ3N0ciAicG9zaXRpdnQgdsOkcmRlIGbDtnJ2w6RudGF0IG9iamVjdG5hbWU6c2hvcnQ9JXMiCiAKLSM6IHJlZi1maWx0ZXIuYzozNzAKKyM6IHJlZi1maWx0ZXIuYzozNzMKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5yZWNvZ25pemVkICUlKG9iamVjdG5hbWUpIGFyZ3VtZW50OiAlcyIKIG1zZ3N0ciAib2vDpG50ICUlKG9iamVjdG5hbWUpLWFyZ3VtZW50OiAlcyIKIAotIzogcmVmLWZpbHRlci5jOjQwMAorIzogcmVmLWZpbHRlci5jOjQwMwogIywgYy1mb3JtYXQKIG1zZ2lkICJleHBlY3RlZCBmb3JtYXQ6ICUlKGFsaWduOjx3aWR0aD4sPHBvc2l0aW9uPikiCiBtc2dzdHIgImbDtnJ2w6RudGF0IGZvcm1hdDogJSUoYWxpZ246PGJyZWRkPiw8cG9zaXRpb24+KSIKIAotIzogcmVmLWZpbHRlci5jOjQxMgorIzogcmVmLWZpbHRlci5jOjQxNQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bnJlY29nbml6ZWQgcG9zaXRpb246JXMiCiBtc2dzdHIgIm9rw6RuZCBwb3NpdGlvbjolcyIKIAotIzogcmVmLWZpbHRlci5jOjQxOQorIzogcmVmLWZpbHRlci5jOjQyMgogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bnJlY29nbml6ZWQgd2lkdGg6JXMiCiBtc2dzdHIgIm9rw6RuZCBicmVkZDolcyIKIAotIzogcmVmLWZpbHRlci5jOjQyOAorIzogcmVmLWZpbHRlci5jOjQzMQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bnJlY29nbml6ZWQgJSUoYWxpZ24pIGFyZ3VtZW50OiAlcyIKIG1zZ3N0ciAib2vDpG50ICUlKGFsaWduKS1hcmd1bWVudDogJXMiCiAKLSM6IHJlZi1maWx0ZXIuYzo0MzYKKyM6IHJlZi1maWx0ZXIuYzo0MzkKICMsIGMtZm9ybWF0CiBtc2dpZCAicG9zaXRpdmUgd2lkdGggZXhwZWN0ZWQgd2l0aCB0aGUgJSUoYWxpZ24pIGF0b20iCiBtc2dzdHIgInBvc2l0aXYgYnJlZGQgZsO2cnbDpG50YWQgbWVkIGF0b21lbiAlJShhbGlnbikiCiAKLSM6IHJlZi1maWx0ZXIuYzo0NTQKKyM6IHJlZi1maWx0ZXIuYzo0NTcKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5yZWNvZ25pemVkICUlKGlmKSBhcmd1bWVudDogJXMiCiBtc2dzdHIgIm9rw6RudCAlJShpZiktYXJndW1lbnQ6ICVzIgogCi0jOiByZWYtZmlsdGVyLmM6NTU2CisjOiByZWYtZmlsdGVyLmM6NTU5CiAjLCBjLWZvcm1hdAogbXNnaWQgIm1hbGZvcm1lZCBmaWVsZCBuYW1lOiAlLipzIgogbXNnc3RyICJmZWxmb3JtYXQgZsOkbHRuYW1uOiAlLipzIgogCi0jOiByZWYtZmlsdGVyLmM6NTgzCisjOiByZWYtZmlsdGVyLmM6NTg2CiAjLCBjLWZvcm1hdAogbXNnaWQgInVua25vd24gZmllbGQgbmFtZTogJS4qcyIKIG1zZ3N0ciAib2vDpG50IGbDpGx0bmFtbjogJS4qcyIKIAotIzogcmVmLWZpbHRlci5jOjU4NworIzogcmVmLWZpbHRlci5jOjU5MAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAibm90IGEgZ2l0IHJlcG9zaXRvcnksIGJ1dCB0aGUgZmllbGQgJyUuKnMnIHJlcXVpcmVzIGFjY2VzcyB0byBvYmplY3QgZGF0YSIKIG1zZ3N0ciAiIgogImludGUgZXR0IGdpdC1hcmtpdiwgbWVuIGbDpGx0ZXQgXCIlLipzXCIga3LDpHZlciB0aWxsZ8OlbmcgdGlsbCBvYmpla3RkYXRhIgogCi0jOiByZWYtZmlsdGVyLmM6NzExCisjOiByZWYtZmlsdGVyLmM6NzE0CiAjLCBjLWZvcm1hdAogbXNnaWQgImZvcm1hdDogJSUoaWYpIGF0b20gdXNlZCB3aXRob3V0IGEgJSUodGhlbikgYXRvbSIKIG1zZ3N0ciAiZm9ybWF0OiBhdG9tZW4gJSUoaWYpIGFudsOkbmQgdXRhbiBlbiAlJSh0aGVuKS1hdG9tIgogCi0jOiByZWYtZmlsdGVyLmM6Nzc0CisjOiByZWYtZmlsdGVyLmM6Nzc3CiAjLCBjLWZvcm1hdAogbXNnaWQgImZvcm1hdDogJSUodGhlbikgYXRvbSB1c2VkIHdpdGhvdXQgYW4gJSUoaWYpIGF0b20iCiBtc2dzdHIgImZvcm1hdDogYXRvbWVuICUlKHRoZW4pIGFudsOkbmQgdXRhbiBlbiAlJShpZiktYXRvbSIKIAotIzogcmVmLWZpbHRlci5jOjc3NgorIzogcmVmLWZpbHRlci5jOjc3OQogIywgYy1mb3JtYXQKIG1zZ2lkICJmb3JtYXQ6ICUlKHRoZW4pIGF0b20gdXNlZCBtb3JlIHRoYW4gb25jZSIKIG1zZ3N0ciAiZm9ybWF0OiBhdG9tZW4gJSUodGhlbikgYW52w6RuZCBtZXIgw6RuIGVuIGfDpW5nIgogCi0jOiByZWYtZmlsdGVyLmM6Nzc4CisjOiByZWYtZmlsdGVyLmM6NzgxCiAjLCBjLWZvcm1hdAogbXNnaWQgImZvcm1hdDogJSUodGhlbikgYXRvbSB1c2VkIGFmdGVyICUlKGVsc2UpIgogbXNnc3RyICJmb3JtYXQ6IGF0b21lbiAlJSh0aGVuKSBhbnbDpG5kIGVmdGVyICUlKGVsc2UpIgogCi0jOiByZWYtZmlsdGVyLmM6ODA2CisjOiByZWYtZmlsdGVyLmM6ODA5CiAjLCBjLWZvcm1hdAogbXNnaWQgImZvcm1hdDogJSUoZWxzZSkgYXRvbSB1c2VkIHdpdGhvdXQgYW4gJSUoaWYpIGF0b20iCiBtc2dzdHIgImZvcm1hdDogYXRvbWVuICUlKGVsc2UpIGFudsOkbmQgdXRhbiBlbiAlJShpZiktYXRvbSIKIAotIzogcmVmLWZpbHRlci5jOjgwOAorIzogcmVmLWZpbHRlci5jOjgxMQogIywgYy1mb3JtYXQKIG1zZ2lkICJmb3JtYXQ6ICUlKGVsc2UpIGF0b20gdXNlZCB3aXRob3V0IGEgJSUodGhlbikgYXRvbSIKIG1zZ3N0ciAiZm9ybWF0OiBhdG9tZW4gJSUoZWxzZSkgYW52w6RuZCB1dGFuIGVuICUlKHRoZW4pLWF0b20iCiAKLSM6IHJlZi1maWx0ZXIuYzo4MTAKKyM6IHJlZi1maWx0ZXIuYzo4MTMKICMsIGMtZm9ybWF0CiBtc2dpZCAiZm9ybWF0OiAlJShlbHNlKSBhdG9tIHVzZWQgbW9yZSB0aGFuIG9uY2UiCiBtc2dzdHIgImZvcm1hdDogYXRvbWVuICUlKGVsc2UpIGFudsOkbmQgbWVyIMOkbiBlbiBnw6VuZyIKIAotIzogcmVmLWZpbHRlci5jOjgyNQorIzogcmVmLWZpbHRlci5jOjgyOAogIywgYy1mb3JtYXQKIG1zZ2lkICJmb3JtYXQ6ICUlKGVuZCkgYXRvbSB1c2VkIHdpdGhvdXQgY29ycmVzcG9uZGluZyBhdG9tIgogbXNnc3RyICJmb3JtYXQ6IGF0b21lbiAlJShlbmQpIGFudsOkbmQgdXRhbiBtb3RzdmFyYW5kZSBhdG9tIgogCi0jOiByZWYtZmlsdGVyLmM6ODgyCisjOiByZWYtZmlsdGVyLmM6ODg1CiAjLCBjLWZvcm1hdAogbXNnaWQgIm1hbGZvcm1lZCBmb3JtYXQgc3RyaW5nICVzIgogbXNnc3RyICJmZWxmb3JtYWQgZm9ybWF0c3Ryw6RuZyAlcyIKIAotIzogcmVmLWZpbHRlci5jOjE0ODUKKyM6IHJlZi1maWx0ZXIuYzoxNDg4CiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vIGJyYW5jaCwgcmViYXNpbmcgJXMiCiBtc2dzdHIgImluZ2VuIGdyZW4sIG9tYmFzZXJhciAlcyIKIAotIzogcmVmLWZpbHRlci5jOjE0ODgKKyM6IHJlZi1maWx0ZXIuYzoxNDkxCiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vIGJyYW5jaCwgcmViYXNpbmcgZGV0YWNoZWQgSEVBRCAlcyIKIG1zZ3N0ciAiaW5nZW4gZ3Jlbiwgb21iYXNlcmFyIGZyw6Vua29wcGxhdCBIRUFEICVzIgogCi0jOiByZWYtZmlsdGVyLmM6MTQ5MQorIzogcmVmLWZpbHRlci5jOjE0OTQKICMsIGMtZm9ybWF0CiBtc2dpZCAibm8gYnJhbmNoLCBiaXNlY3Qgc3RhcnRlZCBvbiAlcyIKIG1zZ3N0ciAiaW5nZW4gZ3JlbiwgXCJiaXNlY3RcIiBzdGFydGFkIHDDpSAlcyIKIAotIzogcmVmLWZpbHRlci5jOjE1MDEKKyM6IHJlZi1maWx0ZXIuYzoxNTA0CiBtc2dpZCAibm8gYnJhbmNoIgogbXNnc3RyICJpbmdlbiBncmVuIgogCi0jOiByZWYtZmlsdGVyLmM6MTUzNyByZWYtZmlsdGVyLmM6MTc0MworIzogcmVmLWZpbHRlci5jOjE1NDAgcmVmLWZpbHRlci5jOjE3NDkKICMsIGMtZm9ybWF0CiBtc2dpZCAibWlzc2luZyBvYmplY3QgJXMgZm9yICVzIgogbXNnc3RyICJvYmpla3RldCAlcyBzYWtuYXMgZsO2ciAlcyIKIAotIzogcmVmLWZpbHRlci5jOjE1NDcKKyM6IHJlZi1maWx0ZXIuYzoxNTUwCiAjLCBjLWZvcm1hdAogbXNnaWQgInBhcnNlX29iamVjdF9idWZmZXIgZmFpbGVkIG9uICVzIGZvciAlcyIKIG1zZ3N0ciAicGFyc2Vfb2JqZWN0X2J1ZmZlciBtaXNzbHlja2FkZXMgcMOlICVzIGbDtnIgJXMiCiAKLSM6IHJlZi1maWx0ZXIuYzoxOTk4CisjOiByZWYtZmlsdGVyLmM6MjAwNAogIywgYy1mb3JtYXQKIG1zZ2lkICJtYWxmb3JtZWQgb2JqZWN0IGF0ICclcyciCiBtc2dzdHIgImZlbGZvcm1hdCBvYmpla3QgdmlkIFwiJXNcIiIKIAotIzogcmVmLWZpbHRlci5jOjIwODcKKyM6IHJlZi1maWx0ZXIuYzoyMDkzCiAjLCBjLWZvcm1hdAogbXNnaWQgImlnbm9yaW5nIHJlZiB3aXRoIGJyb2tlbiBuYW1lICVzIgogbXNnc3RyICJpZ25vcmVyYXIgcmVmZXJlbnMgbWVkIHRyYXNpZ3QgbmFtbiAlcyIKIAotIzogcmVmLWZpbHRlci5jOjIzODIKKyM6IHJlZi1maWx0ZXIuYzoyMzg5CiAjLCBjLWZvcm1hdAogbXNnaWQgImZvcm1hdDogJSUoZW5kKSBhdG9tIG1pc3NpbmciCiBtc2dzdHIgImZvcm1hdDogYXRvbWVuICUlKGVuZCkgc2FrbmFzIgogCi0jOiByZWYtZmlsdGVyLmM6MjQ4MgorIzogcmVmLWZpbHRlci5jOjI0ODkKICMsIGMtZm9ybWF0CiBtc2dpZCAib3B0aW9uIGAlcycgaXMgaW5jb21wYXRpYmxlIHdpdGggLS1tZXJnZWQiCiBtc2dzdHIgImZsYWdnYW4gXCIlc1wiIMOkciBpbmtvbXBhdGliZWwgbWVkIC0tbWVyZ2VkIgogCi0jOiByZWYtZmlsdGVyLmM6MjQ4NQorIzogcmVmLWZpbHRlci5jOjI0OTIKICMsIGMtZm9ybWF0CiBtc2dpZCAib3B0aW9uIGAlcycgaXMgaW5jb21wYXRpYmxlIHdpdGggLS1uby1tZXJnZWQiCiBtc2dzdHIgImZsYWdnYW4gXCIlc1wiIMOkciBpbmtvbXBhdGliZWwgbWVkIC0tbm8tbWVyZ2VkIgogCi0jOiByZWYtZmlsdGVyLmM6MjQ5NQorIzogcmVmLWZpbHRlci5jOjI1MDIKICMsIGMtZm9ybWF0CiBtc2dpZCAibWFsZm9ybWVkIG9iamVjdCBuYW1lICVzIgogbXNnc3RyICJmZWxmb3JtYXQgb2JqZWt0bmFtbiAlcyIKIAotIzogcmVmLWZpbHRlci5jOjI1MDAKKyM6IHJlZi1maWx0ZXIuYzoyNTA3CiAjLCBjLWZvcm1hdAogbXNnaWQgIm9wdGlvbiBgJXMnIG11c3QgcG9pbnQgdG8gYSBjb21taXQiCiBtc2dzdHIgImZsYWdnYW4gXCIlc1wiIG3DpXN0ZSBwZWthIHDDpSBlbiBpbmNoZWNrbmluZyIKIAotIzogcmVtb3RlLmM6MzYzCisjOiByZW1vdGUuYzozNjYKICMsIGMtZm9ybWF0CiBtc2dpZCAiY29uZmlnIHJlbW90ZSBzaG9ydGhhbmQgY2Fubm90IGJlZ2luIHdpdGggJy8nOiAlcyIKIG1zZ3N0ciAia29uZmlndXJlcmFkIGtvcnRmb3JtIGbDtnIgZmrDpHJyIGthbiBpbnRlIGLDtnJqYSBtZWQgXCIvXCI6ICVzIgogCi0jOiByZW1vdGUuYzo0MTAKKyM6IHJlbW90ZS5jOjQxMwogbXNnaWQgIm1vcmUgdGhhbiBvbmUgcmVjZWl2ZXBhY2sgZ2l2ZW4sIHVzaW5nIHRoZSBmaXJzdCIKIG1zZ3N0ciAibWVyIMOkbiBlbiByZWNlaXZlcGFjayBhbmdhdnMsIGFudsOkbmRlciBkZW4gZsO2cnN0YSIKIAotIzogcmVtb3RlLmM6NDE4CisjOiByZW1vdGUuYzo0MjEKIG1zZ2lkICJtb3JlIHRoYW4gb25lIHVwbG9hZHBhY2sgZ2l2ZW4sIHVzaW5nIHRoZSBmaXJzdCIKIG1zZ3N0ciAibWVyIMOkbiBlbiB1cGxvYWRwYWNrIGFuZ2F2cywgYW52w6RuZGVyIGRlbiBmw7Zyc3RhIgogCi0jOiByZW1vdGUuYzo2MDgKKyM6IHJlbW90ZS5jOjYxMQogIywgYy1mb3JtYXQKIG1zZ2lkICJDYW5ub3QgZmV0Y2ggYm90aCAlcyBhbmQgJXMgdG8gJXMiCiBtc2dzdHIgIkthbiBpbnRlIGjDpG10YSBiw6VkZSAlcyBvY2ggJXMgdGlsbCAlcyIKIAotIzogcmVtb3RlLmM6NjEyCisjOiByZW1vdGUuYzo2MTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgdXN1YWxseSB0cmFja3MgJXMsIG5vdCAlcyIKIG1zZ3N0ciAiJXMgc3DDpXJhciB2YW5saWd0dmlzICVzLCBpbnRlICVzIgogCi0jOiByZW1vdGUuYzo2MTYKKyM6IHJlbW90ZS5jOjYxOQogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyB0cmFja3MgYm90aCAlcyBhbmQgJXMiCiBtc2dzdHIgIiVzIHNww6VyYXIgYsOlZGUgJXMgb2NoICVzIgogCi0jOiByZW1vdGUuYzo2ODQKKyM6IHJlbW90ZS5jOjY4NwogIywgYy1mb3JtYXQKIG1zZ2lkICJrZXkgJyVzJyBvZiBwYXR0ZXJuIGhhZCBubyAnKiciCiBtc2dzdHIgIm55Y2tlbG4gXCIlc1wiIGkgbcO2bnN0cmV0IGlubmVow6VsbGVyIGluZ2VuIFwiKlwiIgogCi0jOiByZW1vdGUuYzo2OTQKKyM6IHJlbW90ZS5jOjY5NwogIywgYy1mb3JtYXQKIG1zZ2lkICJ2YWx1ZSAnJXMnIG9mIHBhdHRlcm4gaGFzIG5vICcqJyIKIG1zZ3N0ciAidsOkcmRldCBcIiVzXCIgaSBtw7Zuc3RyZXQgaW5uZWjDpWxsZXIgaW5nZW4gXCIqXCIiCiAKLSM6IHJlbW90ZS5jOjEwMDAKKyM6IHJlbW90ZS5jOjEwMDMKICMsIGMtZm9ybWF0CiBtc2dpZCAic3JjIHJlZnNwZWMgJXMgZG9lcyBub3QgbWF0Y2ggYW55IgogbXNnc3RyICJrw6RsbC1yZWZlcmVuc3NwZWNpZmlrYXRpb25lbiAlcyBtb3RzdmFyYXIgaW5nZW4iCiAKLSM6IHJlbW90ZS5jOjEwMDUKKyM6IHJlbW90ZS5jOjEwMDgKICMsIGMtZm9ybWF0CiBtc2dpZCAic3JjIHJlZnNwZWMgJXMgbWF0Y2hlcyBtb3JlIHRoYW4gb25lIgogbXNnc3RyICJrw6RsbC1yZWZlcmVuc3NwZWNpZmlrYXRpb25lbiAlcyBtb3RzdmFyYXIgbWVyIMOkbiBlbiIKQEAgLTUzMjUsNyArNTM1OSw3IEBACiAjLiA8cmVtb3RlPiA8c3JjPjo8ZHN0PiIgcHVzaCwgYW5kICJiZWluZyBwdXNoZWQgKCclcycpIiBpcwogIy4gdGhlIDxzcmM+LgogIy4KLSM6IHJlbW90ZS5jOjEwMjAKKyM6IHJlbW90ZS5jOjEwMjMKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlRoZSBkZXN0aW5hdGlvbiB5b3UgcHJvdmlkZWQgaXMgbm90IGEgZnVsbCByZWZuYW1lIChpLmUuLFxuIgpAQCAtNTM0OCw3ICs1MzgyLDcgQEAKICJcbiIKICJJbmdldCBhdiBkZW0gZnVuZ2VyYWRlLCBzw6UgdmkgZ2F2IHVwcC4gQW5nZSBmdWxsc3TDpG5kaWcgcmVmZXJlbnMuIgogCi0jOiByZW1vdGUuYzoxMDQwCisjOiByZW1vdGUuYzoxMDQzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgPHNyYz4gcGFydCBvZiB0aGUgcmVmc3BlYyBpcyBhIGNvbW1pdCBvYmplY3QuXG4iCkBAIC01MzU5LDcgKzUzOTMsNyBAQAogIlZhciBkZXQgbWVuaW5nZW4gYXR0IHNrYXBhIGVuIG55IGdyZW4gZ2Vub20gYXR0IHPDpG5kYVxuIgogInRpbGwgXCIlczpyZWZzL2hlYWRzLyVzXCI/IgogCi0jOiByZW1vdGUuYzoxMDQ1CisjOiByZW1vdGUuYzoxMDQ4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgPHNyYz4gcGFydCBvZiB0aGUgcmVmc3BlYyBpcyBhIHRhZyBvYmplY3QuXG4iCkBAIC01MzcwLDcgKzU0MDQsNyBAQAogIlZhciBkZXQgbWVuaW5nZW4gYXR0IHNrYXBhIGVuIG55IHRhZ2cgZ2Vub20gYXR0IHPDpG5kYVxuIgogInRpbGwgXCIlczpyZWZzL3RhZ3MvJXNcIj8iCiAKLSM6IHJlbW90ZS5jOjEwNTAKKyM6IHJlbW90ZS5jOjEwNTMKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlRoZSA8c3JjPiBwYXJ0IG9mIHRoZSByZWZzcGVjIGlzIGEgdHJlZSBvYmplY3QuXG4iCkBAIC01MzgxLDcgKzU0MTUsNyBAQAogIlZhciBkZXQgbWVuaW5nZW4gYXR0IHRhZ2dhIGV0dCBueXR0IHRyw6RkIGdlbm9tIGF0dCBzw6RuZGFcbiIKICJ0aWxsIFwiJXM6cmVmcy90YWdzLyVzXCI/IgogCi0jOiByZW1vdGUuYzoxMDU1CisjOiByZW1vdGUuYzoxMDU4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgPHNyYz4gcGFydCBvZiB0aGUgcmVmc3BlYyBpcyBhIGJsb2Igb2JqZWN0LlxuIgpAQCAtNTM5MiwxMTQgKzU0MjYsMTE0IEBACiAiVmFyIGRldCBtZW5pbmdlbiBhdHQgdGFnZ2EgZW4gbnkgYmxvYiBnZW5vbSBhdHQgc8OkbmRhXG4iCiAidGlsbCBcIiVzOnJlZnMvdGFncy8lc1wiPyIKIAotIzogcmVtb3RlLmM6MTA5MQorIzogcmVtb3RlLmM6MTA5NAogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyBjYW5ub3QgYmUgcmVzb2x2ZWQgdG8gYnJhbmNoIgogbXNnc3RyICIlcyBrYW4gaW50ZSBzbMOlcyB1cHAgdGlsbCBlbiBncmVuIgogCi0jOiByZW1vdGUuYzoxMTAyCisjOiByZW1vdGUuYzoxMTA1CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBkZWxldGUgJyVzJzogcmVtb3RlIHJlZiBkb2VzIG5vdCBleGlzdCIKIG1zZ3N0ciAia2FuIGludGUgdGEgYm9ydCBcIiVzXCI6IGZqw6RycmVmZXJlbnNlbiBmaW5ucyBpbnRlIgogCi0jOiByZW1vdGUuYzoxMTE0CisjOiByZW1vdGUuYzoxMTE3CiAjLCBjLWZvcm1hdAogbXNnaWQgImRzdCByZWZzcGVjICVzIG1hdGNoZXMgbW9yZSB0aGFuIG9uZSIKIG1zZ3N0ciAiZmrDpHJyLXJlZmVyZW5zc3BlY2lmaWthdGlvbmVuIFwiJXNcIiBtb3RzdmFyYXIgbWVyIMOkbiBlbiIKIAotIzogcmVtb3RlLmM6MTEyMQorIzogcmVtb3RlLmM6MTEyNAogIywgYy1mb3JtYXQKIG1zZ2lkICJkc3QgcmVmICVzIHJlY2VpdmVzIGZyb20gbW9yZSB0aGFuIG9uZSBzcmMiCiBtc2dzdHIgImZqw6Ryci1yZWZlcmVuc2VuIFwiJXNcIiBow6RtdGFyIGZyw6VuIG1lciDDpG4gZW4ga8OkbGxhIgogCi0jOiByZW1vdGUuYzoxNjI0IHJlbW90ZS5jOjE3MjUKKyM6IHJlbW90ZS5jOjE2MjcgcmVtb3RlLmM6MTcyOAogbXNnaWQgIkhFQUQgZG9lcyBub3QgcG9pbnQgdG8gYSBicmFuY2giCiBtc2dzdHIgIkhFQUQgcGVrYXIgaW50ZSBww6UgZW4gZ3JlbiIKIAotIzogcmVtb3RlLmM6MTYzMworIzogcmVtb3RlLmM6MTYzNgogIywgYy1mb3JtYXQKIG1zZ2lkICJubyBzdWNoIGJyYW5jaDogJyVzJyIKIG1zZ3N0ciAib2vDpG5kIGdyZW46IFwiJXNcIiIKIAotIzogcmVtb3RlLmM6MTYzNgorIzogcmVtb3RlLmM6MTYzOQogIywgYy1mb3JtYXQKIG1zZ2lkICJubyB1cHN0cmVhbSBjb25maWd1cmVkIGZvciBicmFuY2ggJyVzJyIKIG1zZ3N0ciAiaW5nZW4gc3RhbmRhcmR1cHBzdHLDtm0gYW5naXZlbiBmw7ZyIGdyZW5lbiBcIiVzXCIiCiAKLSM6IHJlbW90ZS5jOjE2NDIKKyM6IHJlbW90ZS5jOjE2NDUKICMsIGMtZm9ybWF0CiBtc2dpZCAidXBzdHJlYW0gYnJhbmNoICclcycgbm90IHN0b3JlZCBhcyBhIHJlbW90ZS10cmFja2luZyBicmFuY2giCiBtc2dzdHIgInVwcHN0csO2bXNncmVuZW4gXCIlc1wiIMOkciBpbnRlIGxhZ3JhZCBzb20gZW4gZmrDpHJyc3DDpXJhbmRlIGdyZW4iCiAKLSM6IHJlbW90ZS5jOjE2NTcKKyM6IHJlbW90ZS5jOjE2NjAKICMsIGMtZm9ybWF0CiBtc2dpZCAicHVzaCBkZXN0aW5hdGlvbiAnJXMnIG9uIHJlbW90ZSAnJXMnIGhhcyBubyBsb2NhbCB0cmFja2luZyBicmFuY2giCiBtc2dzdHIgInB1c2gtbcOlbGV0IFwiJXNcIiBww6UgZmrDpHJyZW4gXCIlc1wiIGhhciBpbmdlbiBsb2thbHQgc3DDpXJhbmRlIGdyZW4iCiAKLSM6IHJlbW90ZS5jOjE2NjkKKyM6IHJlbW90ZS5jOjE2NzIKICMsIGMtZm9ybWF0CiBtc2dpZCAiYnJhbmNoICclcycgaGFzIG5vIHJlbW90ZSBmb3IgcHVzaGluZyIKIG1zZ3N0ciAiZ3JlbmVuIFwiJXNcIiBoYXIgaW5nZW4gZmrDpHJyIGbDtnIgXCJwdXNoXCIiCiAKLSM6IHJlbW90ZS5jOjE2NzkKKyM6IHJlbW90ZS5jOjE2ODIKICMsIGMtZm9ybWF0CiBtc2dpZCAicHVzaCByZWZzcGVjcyBmb3IgJyVzJyBkbyBub3QgaW5jbHVkZSAnJXMnIgogbXNnc3RyICJcInB1c2hcIi1yZWZlcmVuc3NwZWNpZmlrYXRpb24gZsO2ciBcIiVzXCIgaW5uZWjDpWxsZXIgaW50ZSBcIiVzXCIiCiAKLSM6IHJlbW90ZS5jOjE2OTIKKyM6IHJlbW90ZS5jOjE2OTUKIG1zZ2lkICJwdXNoIGhhcyBubyBkZXN0aW5hdGlvbiAocHVzaC5kZWZhdWx0IGlzICdub3RoaW5nJykiCiBtc2dzdHIgIlwicHVzaFwiIGhhciBpbmdldCBtw6VsIChwdXNoLmRlZmF1bHQgw6RyIFwiaW5nZW50aW5nXCIpIgogCi0jOiByZW1vdGUuYzoxNzE0CisjOiByZW1vdGUuYzoxNzE3CiBtc2dpZCAiY2Fubm90IHJlc29sdmUgJ3NpbXBsZScgcHVzaCB0byBhIHNpbmdsZSBkZXN0aW5hdGlvbiIKIG1zZ3N0ciAiXCJlbmtlbCBwdXNoXCIgbW90c3ZhcmFyIGZsZXJhIG9saWthIG3DpWwiCiAKLSM6IHJlbW90ZS5jOjE4NDAKKyM6IHJlbW90ZS5jOjE4NDMKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGRuJ3QgZmluZCByZW1vdGUgcmVmICVzIgogbXNnc3RyICJLdW5kZSBpbnRlIGhpdHRhIGZqw6Ryci1yZWZlcmVuc2VuICVzIgogCi0jOiByZW1vdGUuYzoxODUzCisjOiByZW1vdGUuYzoxODU2CiAjLCBjLWZvcm1hdAogbXNnaWQgIiogSWdub3JpbmcgZnVubnkgcmVmICclcycgbG9jYWxseSIKIG1zZ3N0ciAiKiBJZ25vcmVyYXIgbcOkcmtsaWcgcmVmZXJlbnMgXCIlc1wiIGxva2FsdCIKIAotIzogcmVtb3RlLmM6MjAxNgorIzogcmVtb3RlLmM6MjAxOQogIywgYy1mb3JtYXQKIG1zZ2lkICJZb3VyIGJyYW5jaCBpcyBiYXNlZCBvbiAnJXMnLCBidXQgdGhlIHVwc3RyZWFtIGlzIGdvbmUuXG4iCiBtc2dzdHIgIkRpbiBncmVuIMOkciBiYXNlcmFkIHDDpSBcIiVzXCIsIG1lbiBkZW4gaGFyIGbDtnJzdnVubml0IHVwcHN0csO2bXMuXG4iCiAKLSM6IHJlbW90ZS5jOjIwMjAKKyM6IHJlbW90ZS5jOjIwMjMKIG1zZ2lkICIgICh1c2UgXCJnaXQgYnJhbmNoIC0tdW5zZXQtdXBzdHJlYW1cIiB0byBmaXh1cClcbiIKIG1zZ3N0ciAiICAoYW52w6RuZCBcImdpdCBicmFuY2ggLS11bnNldC11cHN0cmVhbVwiIGbDtnIgYXR0IHLDpHR0YSlcbiIKIAotIzogcmVtb3RlLmM6MjAyMworIzogcmVtb3RlLmM6MjAyNgogIywgYy1mb3JtYXQKIG1zZ2lkICJZb3VyIGJyYW5jaCBpcyB1cCB0byBkYXRlIHdpdGggJyVzJy5cbiIKIG1zZ3N0ciAiRGluIGdyZW4gw6RyIMOgIGpvdXIgbWVkIFwiJXNcIi5cbiIKIAotIzogcmVtb3RlLmM6MjAyNworIzogcmVtb3RlLmM6MjAzMAogIywgYy1mb3JtYXQKIG1zZ2lkICJZb3VyIGJyYW5jaCBhbmQgJyVzJyByZWZlciB0byBkaWZmZXJlbnQgY29tbWl0cy5cbiIKIG1zZ3N0ciAiRGluIGdyZW4gb2NoIFwiJXNcIiBwZWthciBww6Ugb2xpa2EgaW5jaGVja25pbmdhci5cbiIKIAotIzogcmVtb3RlLmM6MjAzMAorIzogcmVtb3RlLmM6MjAzMwogIywgYy1mb3JtYXQKIG1zZ2lkICIgICh1c2UgXCIlc1wiIGZvciBkZXRhaWxzKVxuIgogbXNnc3RyICIgIChhbnbDpG5kIFwiJXNcIiBmw7ZyIGRldGFsamVyKVxuIgogCi0jOiByZW1vdGUuYzoyMDM0CisjOiByZW1vdGUuYzoyMDM3CiAjLCBjLWZvcm1hdAogbXNnaWQgIllvdXIgYnJhbmNoIGlzIGFoZWFkIG9mICclcycgYnkgJWQgY29tbWl0LlxuIgogbXNnaWRfcGx1cmFsICJZb3VyIGJyYW5jaCBpcyBhaGVhZCBvZiAnJXMnIGJ5ICVkIGNvbW1pdHMuXG4iCiBtc2dzdHJbMF0gIkRpbiBncmVuIGxpZ2dlciBmw7ZyZSBcIiVzXCIgbWVkICVkIGluY2hlY2tuaW5nLlxuIgogbXNnc3RyWzFdICJEaW4gZ3JlbiBsaWdnZXIgZsO2cmUgXCIlc1wiIG1lZCAlZCBpbmNoZWNrbmluZ2FyLlxuIgogCi0jOiByZW1vdGUuYzoyMDQwCisjOiByZW1vdGUuYzoyMDQzCiBtc2dpZCAiICAodXNlIFwiZ2l0IHB1c2hcIiB0byBwdWJsaXNoIHlvdXIgbG9jYWwgY29tbWl0cylcbiIKIG1zZ3N0ciAiICAoYW52w6RuZCBcImdpdCBwdXNoXCIgZsO2ciBhdHQgcHVibGljZXJhIGRpbmEgbG9rYWxhIGluY2hlY2tuaW5nYXIpXG4iCiAKLSM6IHJlbW90ZS5jOjIwNDMKKyM6IHJlbW90ZS5jOjIwNDYKICMsIGMtZm9ybWF0CiBtc2dpZCAiWW91ciBicmFuY2ggaXMgYmVoaW5kICclcycgYnkgJWQgY29tbWl0LCBhbmQgY2FuIGJlIGZhc3QtZm9yd2FyZGVkLlxuIgogbXNnaWRfcGx1cmFsICIiCkBAIC01NTA5LDExICs1NTQzLDExIEBACiBtc2dzdHJbMV0gIiIKICJEaW4gZ3JlbiBsaWdnZXIgZWZ0ZXIgXCIlc1wiIG1lZCAlZCBpbmNoZWNrbmluZ2FyLCBvY2gga2FuIHNuYWJic3BvbGFzLlxuIgogCi0jOiByZW1vdGUuYzoyMDUxCisjOiByZW1vdGUuYzoyMDU0CiBtc2dpZCAiICAodXNlIFwiZ2l0IHB1bGxcIiB0byB1cGRhdGUgeW91ciBsb2NhbCBicmFuY2gpXG4iCiBtc2dzdHIgIiAgKGFudsOkbmQgXCJnaXQgcHVsbFwiIGbDtnIgYXR0IHVwcGRhdGVyYSBkaW4gbG9rYWxhIGdyZW4pXG4iCiAKLSM6IHJlbW90ZS5jOjIwNTQKKyM6IHJlbW90ZS5jOjIwNTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIllvdXIgYnJhbmNoIGFuZCAnJXMnIGhhdmUgZGl2ZXJnZWQsXG4iCkBAIC01NTI4LDExICs1NTYyLDExIEBACiAiRGluIGdyZW4gb2NoIFwiJXNcIiBoYXIgZGl2ZXJnZXJhdCxcbiIKICJvY2ggaGFyICVkIHJlc3Bla3RpdmUgJWQgb2xpa2EgaW5jaGVja25pbmdhci5cbiIKIAotIzogcmVtb3RlLmM6MjA2NAorIzogcmVtb3RlLmM6MjA2NwogbXNnaWQgIiAgKHVzZSBcImdpdCBwdWxsXCIgdG8gbWVyZ2UgdGhlIHJlbW90ZSBicmFuY2ggaW50byB5b3VycylcbiIKIG1zZ3N0ciAiICAoYW52w6RuZCBcImdpdCBwdWxsXCIgZsO2ciBhdHQgc2zDpSBpaG9wIGZqw6RycmdyZW5lbiBtZWQgZGluIGVnZW4pXG4iCiAKLSM6IHJlbW90ZS5jOjIyNDcKKyM6IHJlbW90ZS5jOjIyNTAKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IHBhcnNlIGV4cGVjdGVkIG9iamVjdCBuYW1lICclcyciCiBtc2dzdHIgImthbiBpbnRlIHRvbGthIGbDtnJ2w6RudGF0IG9iamVrdG5hbW4gXCIlc1wiIgpAQCAtNTY0NSwyMCArNTY3OSwyMCBAQAogbXNnaWQgInVuYWJsZSB0byBvcGVuIHJyLWNhY2hlIGRpcmVjdG9yeSIKIG1zZ3N0ciAia2FuIGludGUgdXBwZGF0ZXJhIGthdGFsb2dlbiByci1jYWNoZSIKIAotIzogcmV2aXNpb24uYzoyNTA3CisjOiByZXZpc2lvbi5jOjI1MDkKIG1zZ2lkICJ5b3VyIGN1cnJlbnQgYnJhbmNoIGFwcGVhcnMgdG8gYmUgYnJva2VuIgogbXNnc3RyICJkaW4gbnV2YXJhbmRlIGdyZW4gdmVya2FyIHZhcmEgdHJhc2lnIgogCi0jOiByZXZpc2lvbi5jOjI1MTAKKyM6IHJldmlzaW9uLmM6MjUxMgogIywgYy1mb3JtYXQKIG1zZ2lkICJ5b3VyIGN1cnJlbnQgYnJhbmNoICclcycgZG9lcyBub3QgaGF2ZSBhbnkgY29tbWl0cyB5ZXQiCiBtc2dzdHIgImRpbiBudXZhcmFuZGUgZ3JlbiBcIiVzXCIgaW5uZWjDpWxsZXIgw6RubnUgaW50ZSBuw6VncmEgaW5jaGVja25pbmdhciIKIAotIzogcmV2aXNpb24uYzoyNzEwCisjOiByZXZpc2lvbi5jOjI3MjAKIG1zZ2lkICItLWZpcnN0LXBhcmVudCBpcyBpbmNvbXBhdGlibGUgd2l0aCAtLWJpc2VjdCIKIG1zZ3N0ciAiLS1maXJzdC1wYXJlbnQgw6RyIGlua29tcGF0aWJlbHQgbWVkIC0tYmlzZWN0IgogCi0jOiByZXZpc2lvbi5jOjI3MTQKKyM6IHJldmlzaW9uLmM6MjcyNAogbXNnaWQgIi1MIGRvZXMgbm90IHlldCBzdXBwb3J0IGRpZmYgZm9ybWF0cyBiZXNpZGVzIC1wIGFuZCAtcyIKIG1zZ3N0ciAiLUwgc3TDtmRlciDDpG5udSBpbnRlIGFuZHJhIGRpZmYtZm9ybWF0IMOkbiAtcCBvY2ggLXMiCiAKQEAgLTU2ODAsMjkgKzU3MTQsMjkgQEAKICJLcm9rZW4gXCIlc1wiIGlnbm9yZXJhZGVzIGVmdGVyc29tIGRlbiBpbnRlIMOkciBtYXJrZXJhZCBzb20ga8O2cmJhci5cbiIKICJEdSBrYW4gaW5ha3RpdmVyYSB2YXJuaW5nZW4gbWVkIFwiZ2l0IGNvbmZpZyBhZHZpY2UuaWdub3JlZEhvb2sgZmFsc2VcIi4iCiAKLSM6IHNlbmQtcGFjay5jOjE0MQorIzogc2VuZC1wYWNrLmM6MTQyCiBtc2dpZCAidW5leHBlY3RlZCBmbHVzaCBwYWNrZXQgd2hpbGUgcmVhZGluZyByZW1vdGUgdW5wYWNrIHN0YXR1cyIKIG1zZ3N0ciAib3bDpG50YXQgZmx1c2gtcGFrZXQgdmlkIGzDpHNuaW5nIGF2IGZqw6RycnVwcGFja25pbmdzc3RhdHVzIgogCi0jOiBzZW5kLXBhY2suYzoxNDMKKyM6IHNlbmQtcGFjay5jOjE0NAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gcGFyc2UgcmVtb3RlIHVucGFjayBzdGF0dXM6ICVzIgogbXNnc3RyICJrdW5kZSBpbnRlIHRvbGthIGZqw6RycnVwcGFja25pbmdzc3RhdHVzOiAlcyIKIAotIzogc2VuZC1wYWNrLmM6MTQ1CisjOiBzZW5kLXBhY2suYzoxNDYKICMsIGMtZm9ybWF0CiBtc2dpZCAicmVtb3RlIHVucGFjayBmYWlsZWQ6ICVzIgogbXNnc3RyICJmasOkcnJ1cHBhY2tuaW5nIG1pc3NseWNrYWRlczogJXMiCiAKLSM6IHNlbmQtcGFjay5jOjMwNgorIzogc2VuZC1wYWNrLmM6MzA3CiBtc2dpZCAiZmFpbGVkIHRvIHNpZ24gdGhlIHB1c2ggY2VydGlmaWNhdGUiCiBtc2dzdHIgIm1pc3NseWNrYWRlcyB1bmRlcnRlY2tuYSBwdXNoLWNlcnRpZmlrYXRldCIKIAotIzogc2VuZC1wYWNrLmM6NDIwCisjOiBzZW5kLXBhY2suYzo0MjEKIG1zZ2lkICJ0aGUgcmVjZWl2aW5nIGVuZCBkb2VzIG5vdCBzdXBwb3J0IC0tc2lnbmVkIHB1c2giCiBtc2dzdHIgIm1vdHRhZ2Fyc2lkYW4gc3TDtmRlciBpbnRlIHB1c2ggbWVkIC0tc2lnbmVkIgogCi0jOiBzZW5kLXBhY2suYzo0MjIKKyM6IHNlbmQtcGFjay5jOjQyMwogbXNnaWQgIiIKICJub3Qgc2VuZGluZyBhIHB1c2ggY2VydGlmaWNhdGUgc2luY2UgdGhlIHJlY2VpdmluZyBlbmQgZG9lcyBub3Qgc3VwcG9ydCAtLSIKICJzaWduZWQgcHVzaCIKQEAgLTU3MTAsMTEgKzU3NDQsMTEgQEAKICJzw6RuZGVyIGludGUgcHVzaC1jZXJ0aWZpa2F0IGVmdGVyc29tIG1vdHRhZ2Fyc2lkYW4gaW50ZSBzdGxkZXIgcHVzaCBtZWQgLS0iCiAic2lnbmVkIgogCi0jOiBzZW5kLXBhY2suYzo0MzQKKyM6IHNlbmQtcGFjay5jOjQzNQogbXNnaWQgInRoZSByZWNlaXZpbmcgZW5kIGRvZXMgbm90IHN1cHBvcnQgLS1hdG9taWMgcHVzaCIKIG1zZ3N0ciAibW90dGFnYXJzaWRhbiBzdMO2ZGVyIGludGUgcHVzaCBtZWQgLS1hdG9taWMiCiAKLSM6IHNlbmQtcGFjay5jOjQzOQorIzogc2VuZC1wYWNrLmM6NDQwCiBtc2dpZCAidGhlIHJlY2VpdmluZyBlbmQgZG9lcyBub3Qgc3VwcG9ydCBwdXNoIG9wdGlvbnMiCiBtc2dzdHIgIm1vdHRhZ2Fyc2lkYW4gc3TDtmRlciBpbnRlIHB1c2gtZmxhZ2dvciIKIApAQCAtNTcyOCw3ICs1NzYyLDcgQEAKIG1zZ2lkICJjb3VsZCBub3QgZGVsZXRlICclcyciCiBtc2dzdHIgImt1bmRlIGludGUgdGEgYm9ydCBcIiVzXCIiCiAKLSM6IHNlcXVlbmNlci5jOjMxMSBidWlsdGluL3JlYmFzZS5jOjc1OSBidWlsdGluL3JlYmFzZS5jOjE2NDUgYnVpbHRpbi9ybS5jOjM2OQorIzogc2VxdWVuY2VyLmM6MzExIGJ1aWx0aW4vcmViYXNlLmM6NzYwIGJ1aWx0aW4vcmViYXNlLmM6MTY3NiBidWlsdGluL3JtLmM6MzY5CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCByZW1vdmUgJyVzJyIKIG1zZ3N0ciAia3VuZGUgaW50ZSB0YSBib3J0IFwiJXNcIiIKQEAgLTU3NjgsNyArNTgwMiw3IEBACiAibWVkIFwiZ2l0IGFkZCA8c8O2a3bDpGdhcj5cIiBlbGxlciBcImdpdCBybSA8c8O2a3bDpGdhcj5cIlxuIgogIm9jaCBjaGVja2EgaW4gcmVzdWx0YXRldCBtZWQgXCJnaXQgY29tbWl0XCIiCiAKLSM6IHNlcXVlbmNlci5jOjQwMSBzZXF1ZW5jZXIuYzoyOTA5CisjOiBzZXF1ZW5jZXIuYzo0MDEgc2VxdWVuY2VyLmM6Mjg0NwogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgbG9jayAnJXMnIgogbXNnc3RyICJrdW5kZSBpbnRlIGzDpXNhIFwiJXNcIiIKQEAgLTU3NzgsMTUgKzU4MTIsMTUgQEAKIG1zZ2lkICJjb3VsZCBub3Qgd3JpdGUgZW9sIHRvICclcyciCiBtc2dzdHIgImt1bmRlIGludGUgc2tyaXZhIHJhZHNsdXQgdGlsbCBcIiVzXCIiCiAKLSM6IHNlcXVlbmNlci5jOjQxMyBzZXF1ZW5jZXIuYzoyNzE0IHNlcXVlbmNlci5jOjI5MTUgc2VxdWVuY2VyLmM6MjkyOQotIzogc2VxdWVuY2VyLmM6MzE5MgorIzogc2VxdWVuY2VyLmM6NDEzIHNlcXVlbmNlci5jOjI2NTIgc2VxdWVuY2VyLmM6Mjg1MyBzZXF1ZW5jZXIuYzoyODY3CisjOiBzZXF1ZW5jZXIuYzozMTMwCiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBmaW5hbGl6ZSAnJXMnIgogbXNnc3RyICJtaXNzbHlja2FkZXMgZsOkcmRpZ3N0w6RsbGEgXCIlc1wiIgogCi0jOiBzZXF1ZW5jZXIuYzo0MzYgc2VxdWVuY2VyLmM6OTgxIHNlcXVlbmNlci5jOjE2NTUgc2VxdWVuY2VyLmM6MjczNAotIzogc2VxdWVuY2VyLmM6MzE3NCBzZXF1ZW5jZXIuYzozMjgzIGJ1aWx0aW4vYW0uYzoyNDUgYnVpbHRpbi9jb21taXQuYzo3NjMKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxMTEyIGJ1aWx0aW4vcmViYXNlLmM6NTY3CisjOiBzZXF1ZW5jZXIuYzo0MzYgc2VxdWVuY2VyLmM6MTU4NSBzZXF1ZW5jZXIuYzoyNjcyIHNlcXVlbmNlci5jOjMxMTIKKyM6IHNlcXVlbmNlci5jOjMyMjEgYnVpbHRpbi9hbS5jOjI0NCBidWlsdGluL2NvbW1pdC5jOjc2MyBidWlsdGluL21lcmdlLmM6MTExNworIzogYnVpbHRpbi9yZWJhc2UuYzo1NjgKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHJlYWQgJyVzJyIKIG1zZ3N0ciAia3VuZGUgaW50ZSBsw6RzYSBcIiVzXCIiCkBAIC01ODEzLDcwICs1ODQ3LDY1IEBACiAjLiBUUkFOU0xBVE9SUzogJXMgd2lsbCBiZSAicmV2ZXJ0IiwgImNoZXJyeS1waWNrIiBvcgogIy4gInJlYmFzZSAtaSIuCiAjLgotIzogc2VxdWVuY2VyLmM6NjMyCisjOiBzZXF1ZW5jZXIuYzo2MzEKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXM6IFVuYWJsZSB0byB3cml0ZSBuZXcgaW5kZXggZmlsZSIKIG1zZ3N0ciAiJXM6IEt1bmRlIGludGUgc2tyaXZhIG55IGluZGV4ZmlsIgogCi0jOiBzZXF1ZW5jZXIuYzo2NDkKKyM6IHNlcXVlbmNlci5jOjY0OAogbXNnaWQgInVuYWJsZSB0byB1cGRhdGUgY2FjaGUgdHJlZSIKIG1zZ3N0ciAia2FuIGludGUgdXBwZGF0ZXJhIGNhY2hldHLDpGQiCiAKLSM6IHNlcXVlbmNlci5jOjY2MworIzogc2VxdWVuY2VyLmM6NjYyCiBtc2dpZCAiY291bGQgbm90IHJlc29sdmUgSEVBRCBjb21taXQiCiBtc2dzdHIgImt1bmRlIGludGUgYmVzdMOkbW1hIEhFQUQ6cyBpbmNoZWNrbmluZyIKIAotIzogc2VxdWVuY2VyLmM6NzQzCisjOiBzZXF1ZW5jZXIuYzo3NDIKICMsIGMtZm9ybWF0CiBtc2dpZCAibm8ga2V5IHByZXNlbnQgaW4gJyUuKnMnIgogbXNnc3RyICJpbmdlbiBueWNrZWwgaSAgXCIlLipzXCIiCiAKLSM6IHNlcXVlbmNlci5jOjc1NAorIzogc2VxdWVuY2VyLmM6NzUzCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBkZXF1b3RlIHZhbHVlIG9mICclcyciCiBtc2dzdHIgImthbiBpbnRlIHRhIGJvcnQgY2l0ZXJpbmcgYXYgdsOkcmRldCBcIiVzXCIiCiAKLSM6IHNlcXVlbmNlci5jOjc5MSB3cmFwcGVyLmM6MjI3IHdyYXBwZXIuYzozOTcgYnVpbHRpbi9hbS5jOjcwNgotIzogYnVpbHRpbi9hbS5jOjc5OCBidWlsdGluL21lcmdlLmM6MTEwOSBidWlsdGluL3JlYmFzZS5jOjEwNDUKKyM6IHNlcXVlbmNlci5jOjc5MCB3cmFwcGVyLmM6MTkwIHdyYXBwZXIuYzozNjAgYnVpbHRpbi9hbS5jOjcwNQorIzogYnVpbHRpbi9hbS5jOjc5NyBidWlsdGluL21lcmdlLmM6MTExNCBidWlsdGluL3JlYmFzZS5jOjEwNDYKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IG9wZW4gJyVzJyBmb3IgcmVhZGluZyIKIG1zZ3N0ciAia3VuZGUgaW50ZSDDtnBwbmEgXCIlc1wiIGbDtnIgbMOkc25pbmciCiAKLSM6IHNlcXVlbmNlci5jOjgwMQorIzogc2VxdWVuY2VyLmM6ODAwCiBtc2dpZCAiJ0dJVF9BVVRIT1JfTkFNRScgYWxyZWFkeSBnaXZlbiIKIG1zZ3N0ciAiXCJHSVRfQVVUSE9SX05BTUVcIiBoYXIgcmVkYW4gYW5naXZpdHMiCiAKLSM6IHNlcXVlbmNlci5jOjgwNgorIzogc2VxdWVuY2VyLmM6ODA1CiBtc2dpZCAiJ0dJVF9BVVRIT1JfRU1BSUwnIGFscmVhZHkgZ2l2ZW4iCiBtc2dzdHIgIlwiR0lUX0FVVEhPUl9FTUFJTFwiIGhhciByZWRhbiBhbmdpdml0cyIKIAotIzogc2VxdWVuY2VyLmM6ODExCisjOiBzZXF1ZW5jZXIuYzo4MTAKIG1zZ2lkICInR0lUX0FVVEhPUl9EQVRFJyBhbHJlYWR5IGdpdmVuIgogbXNnc3RyICJcIkdJVF9BVVRIT1JfREFURVwiIGhhciByZWRhbiBhbmdpdml0cyIKIAotIzogc2VxdWVuY2VyLmM6ODE1CisjOiBzZXF1ZW5jZXIuYzo4MTQKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5rbm93biB2YXJpYWJsZSAnJXMnIgogbXNnc3RyICJva8OkbmQgdmFyaWFiZWwgXCIlc1wiIgogCi0jOiBzZXF1ZW5jZXIuYzo4MjAKKyM6IHNlcXVlbmNlci5jOjgxOQogbXNnaWQgIm1pc3NpbmcgJ0dJVF9BVVRIT1JfTkFNRSciCiBtc2dzdHIgIlwiR0lUX0FVVEhPUl9OQU1FXCIgc2FrbmFzIgogCi0jOiBzZXF1ZW5jZXIuYzo4MjIKKyM6IHNlcXVlbmNlci5jOjgyMQogbXNnaWQgIm1pc3NpbmcgJ0dJVF9BVVRIT1JfRU1BSUwnIgogbXNnc3RyICJcIkdJVF9BVVRIT1JfRU1BSUxcIiBzYWtuYXMiCiAKLSM6IHNlcXVlbmNlci5jOjgyNAorIzogc2VxdWVuY2VyLmM6ODIzCiBtc2dpZCAibWlzc2luZyAnR0lUX0FVVEhPUl9EQVRFJyIKIG1zZ3N0ciAiXCJHSVRfQVVUSE9SX0RBVEVcIiBzYWtuYXMiCiAKLSM6IHNlcXVlbmNlci5jOjg4NAotIywgYy1mb3JtYXQKLW1zZ2lkICJpbnZhbGlkIGRhdGUgZm9ybWF0ICclcycgaW4gJyVzJyIKLW1zZ3N0ciAib2dpbHRpZ3QgZGF0dW1mb3JtYXQgXCIlc1wiIGkgXCIlc1wiIgotCi0jOiBzZXF1ZW5jZXIuYzo5MDEKKyM6IHNlcXVlbmNlci5jOjg3MgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAieW91IGhhdmUgc3RhZ2VkIGNoYW5nZXMgaW4geW91ciB3b3JraW5nIHRyZWVcbiIKQEAgLTU5MDUsMTUgKzU5MzQsMTEgQEAKICJcbiIKICIgIGdpdCByZWJhc2UgLS1jb250aW51ZVxuIgogCi0jOiBzZXF1ZW5jZXIuYzo5OTUKLW1zZ2lkICJ3cml0aW5nIHJvb3QgY29tbWl0IgotbXNnc3RyICJza3JpdmVyIHJvdGluY2hlY2tuaW5nIgotCi0jOiBzZXF1ZW5jZXIuYzoxMjE2CisjOiBzZXF1ZW5jZXIuYzoxMTQ2CiBtc2dpZCAiJ3ByZXBhcmUtY29tbWl0LW1zZycgaG9vayBmYWlsZWQiCiBtc2dzdHIgImtyb2tlbiBcInByZXBhcmUtY29tbWl0LW1zZ1wiIG1pc3NseWNrYWRlcyIKIAotIzogc2VxdWVuY2VyLmM6MTIyMworIzogc2VxdWVuY2VyLmM6MTE1MwogbXNnaWQgIiIKICJZb3VyIG5hbWUgYW5kIGVtYWlsIGFkZHJlc3Mgd2VyZSBjb25maWd1cmVkIGF1dG9tYXRpY2FsbHkgYmFzZWRcbiIKICJvbiB5b3VyIHVzZXJuYW1lIGFuZCBob3N0bmFtZS4gUGxlYXNlIGNoZWNrIHRoYXQgdGhleSBhcmUgYWNjdXJhdGUuXG4iCkBAIC01OTQwLDcgKzU5NjUsNyBAQAogIlxuIgogIiAgICBnaXQgY29tbWl0IC0tYW1lbmQgLS1yZXNldC1hdXRob3JcbiIKIAotIzogc2VxdWVuY2VyLmM6MTIzNgorIzogc2VxdWVuY2VyLmM6MTE2NgogbXNnaWQgIiIKICJZb3VyIG5hbWUgYW5kIGVtYWlsIGFkZHJlc3Mgd2VyZSBjb25maWd1cmVkIGF1dG9tYXRpY2FsbHkgYmFzZWRcbiIKICJvbiB5b3VyIHVzZXJuYW1lIGFuZCBob3N0bmFtZS4gUGxlYXNlIGNoZWNrIHRoYXQgdGhleSBhcmUgYWNjdXJhdGUuXG4iCkBAIC01OTY1LDMyNyArNTk5MCwzMjcgQEAKICJcbiIKICIgICAgZ2l0IGNvbW1pdCAtLWFtZW5kIC0tcmVzZXQtYXV0aG9yXG4iCiAKLSM6IHNlcXVlbmNlci5jOjEyNzgKKyM6IHNlcXVlbmNlci5jOjEyMDgKIG1zZ2lkICJjb3VsZG4ndCBsb29rIHVwIG5ld2x5IGNyZWF0ZWQgY29tbWl0IgogbXNnc3RyICJrdW5kZSBpbnRlIHNsw6UgdXBwIGVuIHByZWNpcyBza2FwYWQgaW5jaGVja25pbmciCiAKLSM6IHNlcXVlbmNlci5jOjEyODAKKyM6IHNlcXVlbmNlci5jOjEyMTAKIG1zZ2lkICJjb3VsZCBub3QgcGFyc2UgbmV3bHkgY3JlYXRlZCBjb21taXQiCiBtc2dzdHIgImt1bmRlIGludGUgdG9sa2EgZW4gcHJlY2lzIHNrYXBhZCBpbmNoZWNrbmluZyIKIAotIzogc2VxdWVuY2VyLmM6MTMyNgorIzogc2VxdWVuY2VyLmM6MTI1NgogbXNnaWQgInVuYWJsZSB0byByZXNvbHZlIEhFQUQgYWZ0ZXIgY3JlYXRpbmcgY29tbWl0IgogbXNnc3RyICJrdW5kZSBpbnRlIGJlc3TDpG1tYSBIRUFEIGVmdGVyIGF0dCBoYSBza2FwYXQgaW5jaGVja25pbmciCiAKLSM6IHNlcXVlbmNlci5jOjEzMjgKKyM6IHNlcXVlbmNlci5jOjEyNTgKIG1zZ2lkICJkZXRhY2hlZCBIRUFEIgogbXNnc3RyICJmcsOlbmtvcHBsYWQgSEVBRCIKIAotIzogc2VxdWVuY2VyLmM6MTMzMgorIzogc2VxdWVuY2VyLmM6MTI2MgogbXNnaWQgIiAocm9vdC1jb21taXQpIgogbXNnc3RyICIgKHJvdGluY2hlY2tuaW5nKSIKIAotIzogc2VxdWVuY2VyLmM6MTM1MworIzogc2VxdWVuY2VyLmM6MTI4MwogbXNnaWQgImNvdWxkIG5vdCBwYXJzZSBIRUFEIgogbXNnc3RyICJrdW5kZSBpbnRlIHRvbGthIEhFQUQiCiAKLSM6IHNlcXVlbmNlci5jOjEzNTUKKyM6IHNlcXVlbmNlci5jOjEyODUKICMsIGMtZm9ybWF0CiBtc2dpZCAiSEVBRCAlcyBpcyBub3QgYSBjb21taXQhIgogbXNnc3RyICJIRUFEICVzIMOkciBpbnRlIGVuIGluY2hlY2tuaW5nISIKIAotIzogc2VxdWVuY2VyLmM6MTM1OSBidWlsdGluL2NvbW1pdC5jOjE1NzEKKyM6IHNlcXVlbmNlci5jOjEyODkgYnVpbHRpbi9jb21taXQuYzoxNTcxCiBtc2dpZCAiY291bGQgbm90IHBhcnNlIEhFQUQgY29tbWl0IgogbXNnc3RyICJrdW5kZSBpbnRlIHRvbGthIEhFQUQ6cyBpbmNoZWNrbmluZyIKIAotIzogc2VxdWVuY2VyLmM6MTQxMSBzZXF1ZW5jZXIuYzoyMDA0CisjOiBzZXF1ZW5jZXIuYzoxMzQxIHNlcXVlbmNlci5jOjE5MzMKIG1zZ2lkICJ1bmFibGUgdG8gcGFyc2UgY29tbWl0IGF1dGhvciIKIG1zZ3N0ciAia3VuZGUgaW50ZSB0b2xrYSBpbmNoZWNrbmluZ2VucyBmw7ZyZmF0dGFyZSIKIAotIzogc2VxdWVuY2VyLmM6MTQyMSBidWlsdGluL2FtLmM6MTU3MyBidWlsdGluL21lcmdlLmM6Njg0CisjOiBzZXF1ZW5jZXIuYzoxMzUyIGJ1aWx0aW4vYW0uYzoxNTYxIGJ1aWx0aW4vbWVyZ2UuYzo2ODQKIG1zZ2lkICJnaXQgd3JpdGUtdHJlZSBmYWlsZWQgdG8gd3JpdGUgYSB0cmVlIgogbXNnc3RyICJnaXQgd3JpdGUtdHJlZSBtaXNzbHlja2FkZXMgc2tyaXZhIGV0dCB0csOkZCIKIAotIzogc2VxdWVuY2VyLmM6MTQzOCBzZXF1ZW5jZXIuYzoxNDk5CisjOiBzZXF1ZW5jZXIuYzoxMzY5IHNlcXVlbmNlci5jOjE0MjkKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHJlYWQgY29tbWl0IG1lc3NhZ2UgZnJvbSAnJXMnIgogbXNnc3RyICJrdW5kZSBpbnRlIGzDpHNhIGluY2hlY2tuaW5nc21lZGRlbGFuZGUgZnLDpW4gXCIlc1wiIgogCi0jOiBzZXF1ZW5jZXIuYzoxNDY1IGJ1aWx0aW4vYW0uYzoxNTk1IGJ1aWx0aW4vY29tbWl0LmM6MTY3MCBidWlsdGluL21lcmdlLmM6ODc4Ci0jOiBidWlsdGluL21lcmdlLmM6OTAzCisjOiBzZXF1ZW5jZXIuYzoxMzk2IGJ1aWx0aW4vYW0uYzoxNTgzIGJ1aWx0aW4vY29tbWl0LmM6MTY3MCBidWlsdGluL21lcmdlLmM6ODgzCisjOiBidWlsdGluL21lcmdlLmM6OTA4CiBtc2dpZCAiZmFpbGVkIHRvIHdyaXRlIGNvbW1pdCBvYmplY3QiCiBtc2dzdHIgImt1bmRlIGludGUgc2tyaXZhIGluY2hlY2tuaW5nc29iamVrdCIKIAotIzogc2VxdWVuY2VyLmM6MTUyNgorIzogc2VxdWVuY2VyLmM6MTQ1NgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcGFyc2UgY29tbWl0ICVzIgogbXNnc3RyICJrdW5kZSBpbnRlIHRvbGthIGluY2hlY2tuaW5nZW4gJXMiCiAKLSM6IHNlcXVlbmNlci5jOjE1MzEKKyM6IHNlcXVlbmNlci5jOjE0NjEKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHBhcnNlIHBhcmVudCBjb21taXQgJXMiCiBtc2dzdHIgImt1bmRlIGludGUgdG9sa2EgZsO2csOkbGRyYWluY2hlY2tuaW5nZW4gJXMiCiAKLSM6IHNlcXVlbmNlci5jOjE2MDUgc2VxdWVuY2VyLmM6MTcxNQorIzogc2VxdWVuY2VyLmM6MTUzNSBzZXF1ZW5jZXIuYzoxNjQ1CiAjLCBjLWZvcm1hdAogbXNnaWQgInVua25vd24gY29tbWFuZDogJWQiCiBtc2dzdHIgIm9rw6RudCBrb21tYW5kbzogJWQiCiAKLSM6IHNlcXVlbmNlci5jOjE2NjIgc2VxdWVuY2VyLmM6MTY4NworIzogc2VxdWVuY2VyLmM6MTU5MiBzZXF1ZW5jZXIuYzoxNjE3CiAjLCBjLWZvcm1hdAogbXNnaWQgIlRoaXMgaXMgYSBjb21iaW5hdGlvbiBvZiAlZCBjb21taXRzLiIKIG1zZ3N0ciAiRGV0IGjDpHIgw6RyIGVuIGtvbWJpbmF0aW9uIGF2ICVkIGluY2hlY2tuaW5nYXIuIgogCi0jOiBzZXF1ZW5jZXIuYzoxNjcyCisjOiBzZXF1ZW5jZXIuYzoxNjAyCiBtc2dpZCAibmVlZCBhIEhFQUQgdG8gZml4dXAiCiBtc2dzdHIgImJlaMO2dmVyIGVuIEhFQUQtaW5jaGVja25pbmcgYXR0IHLDpHR0YSIKIAotIzogc2VxdWVuY2VyLmM6MTY3NCBzZXF1ZW5jZXIuYzozMjE5CisjOiBzZXF1ZW5jZXIuYzoxNjA0IHNlcXVlbmNlci5jOjMxNTcKIG1zZ2lkICJjb3VsZCBub3QgcmVhZCBIRUFEIgogbXNnc3RyICJrdW5kZSBpbnRlIGzDpHNhIEhFQUQiCiAKLSM6IHNlcXVlbmNlci5jOjE2NzYKKyM6IHNlcXVlbmNlci5jOjE2MDYKIG1zZ2lkICJjb3VsZCBub3QgcmVhZCBIRUFEJ3MgY29tbWl0IG1lc3NhZ2UiCiBtc2dzdHIgImt1bmRlIGludGUgbMOkc2EgSEVBRDpzIGluY2hlY2tuaW5nc21lZGRlbGFuZGUiCiAKLSM6IHNlcXVlbmNlci5jOjE2ODIKKyM6IHNlcXVlbmNlci5jOjE2MTIKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IHdyaXRlICclcyciCiBtc2dzdHIgImthbiBpbnRlIHNrcml2YSBcIiVzXCIiCiAKLSM6IHNlcXVlbmNlci5jOjE2ODkgZ2l0LXJlYmFzZS0tcHJlc2VydmUtbWVyZ2VzLnNoOjQ5NgorIzogc2VxdWVuY2VyLmM6MTYxOSBnaXQtcmViYXNlLS1wcmVzZXJ2ZS1tZXJnZXMuc2g6NDk2CiBtc2dpZCAiVGhpcyBpcyB0aGUgMXN0IGNvbW1pdCBtZXNzYWdlOiIKIG1zZ3N0ciAiRGV0IGjDpHIgw6RyIDE6YSBpbmNoZWNrbmluZ3NtZWRkZWxhbmRldDoiCiAKLSM6IHNlcXVlbmNlci5jOjE2OTcKKyM6IHNlcXVlbmNlci5jOjE2MjcKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHJlYWQgY29tbWl0IG1lc3NhZ2Ugb2YgJXMiCiBtc2dzdHIgImt1bmRlIGludGUgbMOkc2EgaW5jaGVja25pbmdzbWVkZGVsYW5kZSBmw7ZyICVzIgogCi0jOiBzZXF1ZW5jZXIuYzoxNzA0CisjOiBzZXF1ZW5jZXIuYzoxNjM0CiAjLCBjLWZvcm1hdAogbXNnaWQgIlRoaXMgaXMgdGhlIGNvbW1pdCBtZXNzYWdlICMlZDoiCiBtc2dzdHIgIkRldCBow6RyIMOkciBpbmNoZWNrbmluZ3NtZWRkZWxhbmRlICVkOiIKIAotIzogc2VxdWVuY2VyLmM6MTcxMAorIzogc2VxdWVuY2VyLmM6MTY0MAogIywgYy1mb3JtYXQKIG1zZ2lkICJUaGUgY29tbWl0IG1lc3NhZ2UgIyVkIHdpbGwgYmUgc2tpcHBlZDoiCiBtc2dzdHIgIkluY2hlY2tuaW5nc21lZGRlbGFuZGUgJWQga29tbWVyIGhvcHBhcyDDtnZlcjoiCiAKLSM6IHNlcXVlbmNlci5jOjE3OTgKKyM6IHNlcXVlbmNlci5jOjE3MjgKIG1zZ2lkICJ5b3VyIGluZGV4IGZpbGUgaXMgdW5tZXJnZWQuIgogbXNnc3RyICJkaW4gaW5kZXhmaWwgaGFyIGludGUgc2xhZ2l0cyBpaG9wLiIKIAotIzogc2VxdWVuY2VyLmM6MTgwNQorIzogc2VxdWVuY2VyLmM6MTczNQogbXNnaWQgImNhbm5vdCBmaXh1cCByb290IGNvbW1pdCIKIG1zZ3N0ciAia2FuIGludGUgZ8O2cmEgXCJmaXh1cFwiIHDDpSByb3RpbmNoZWNrbmluZyIKIAotIzogc2VxdWVuY2VyLmM6MTgyNAorIzogc2VxdWVuY2VyLmM6MTc1NAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb21taXQgJXMgaXMgYSBtZXJnZSBidXQgbm8gLW0gb3B0aW9uIHdhcyBnaXZlbi4iCiBtc2dzdHIgImluY2hlY2tuaW5nICVzIMOkciBlbiBzYW1tYW5zbGFnbmluZywgbWVuIGZsYWdnYW4gLW0gYW5nYXZzIGludGUuIgogCi0jOiBzZXF1ZW5jZXIuYzoxODMyIHNlcXVlbmNlci5jOjE4NDAKKyM6IHNlcXVlbmNlci5jOjE3NjIgc2VxdWVuY2VyLmM6MTc3MAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb21taXQgJXMgZG9lcyBub3QgaGF2ZSBwYXJlbnQgJWQiCiBtc2dzdHIgImluY2hlY2tuaW5nICVzIGhhciBpbnRlIGbDtnLDpGxkZXIgJWQiCiAKLSM6IHNlcXVlbmNlci5jOjE4NDYKKyM6IHNlcXVlbmNlci5jOjE3NzYKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IGdldCBjb21taXQgbWVzc2FnZSBmb3IgJXMiCiBtc2dzdHIgImthbiBpbnRlIGjDpG10YSBpbmNoZWNrbmluZ3NtZWRkZWxhbmRlIGbDtnIgJXMiCiAKICMuIFRSQU5TTEFUT1JTOiBUaGUgZmlyc3QgJXMgd2lsbCBiZSBhICJ0b2RvIiBjb21tYW5kIGxpa2UKICMuICJyZXZlcnQiIG9yICJwaWNrIiwgdGhlIHNlY29uZCAlcyBhIFNIQTEuCi0jOiBzZXF1ZW5jZXIuYzoxODY1CisjOiBzZXF1ZW5jZXIuYzoxNzk1CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiBjYW5ub3QgcGFyc2UgcGFyZW50IGNvbW1pdCAlcyIKIG1zZ3N0ciAiJXM6IGthbiBpbnRlIHRvbGthIGbDtnLDpGxkcmFpbmNoZWNrbmluZ2VuICVzIgogCi0jOiBzZXF1ZW5jZXIuYzoxOTMwCisjOiBzZXF1ZW5jZXIuYzoxODYwCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCByZW5hbWUgJyVzJyB0byAnJXMnIgogbXNnc3RyICJrdW5kZSBpbnRlIGJ5dGEgbmFtbiBww6UgXCIlc1wiIHRpbGwgXCIlc1wiIgogCi0jOiBzZXF1ZW5jZXIuYzoxOTg1CisjOiBzZXF1ZW5jZXIuYzoxOTE1CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCByZXZlcnQgJXMuLi4gJXMiCiBtc2dzdHIgImt1bmRlIGludGUgw6VuZ3JhICVzLi4uICVzIgogCi0jOiBzZXF1ZW5jZXIuYzoxOTg2CisjOiBzZXF1ZW5jZXIuYzoxOTE2CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBhcHBseSAlcy4uLiAlcyIKIG1zZ3N0ciAia3VuZGUgaW50ZSB0aWxsw6RtcGEgJXMuLi4gJXMiCiAKLSM6IHNlcXVlbmNlci5jOjIwNDUKKyM6IHNlcXVlbmNlci5jOjE5ODMKICMsIGMtZm9ybWF0CiBtc2dpZCAiZ2l0ICVzOiBmYWlsZWQgdG8gcmVhZCB0aGUgaW5kZXgiCiBtc2dzdHIgImdpdCAlczogbWlzc2x5Y2thZGVzIGzDpHNhIGluZGV4ZXQiCiAKLSM6IHNlcXVlbmNlci5jOjIwNTIKKyM6IHNlcXVlbmNlci5jOjE5OTAKICMsIGMtZm9ybWF0CiBtc2dpZCAiZ2l0ICVzOiBmYWlsZWQgdG8gcmVmcmVzaCB0aGUgaW5kZXgiCiBtc2dzdHIgImdpdCAlczogbWlzc2x5Y2thZGVzIHVwcGRhdGVyYSBpbmRleGV0IgogCi0jOiBzZXF1ZW5jZXIuYzoyMTI4CisjOiBzZXF1ZW5jZXIuYzoyMDY2CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIGRvZXMgbm90IGFjY2VwdCBhcmd1bWVudHM6ICclcyciCiBtc2dzdHIgIiVzIHRhciBpbnRlIGFyZ3VtZW50OiBcIiVzXCIiCiAKLSM6IHNlcXVlbmNlci5jOjIxMzcKKyM6IHNlcXVlbmNlci5jOjIwNzUKICMsIGMtZm9ybWF0CiBtc2dpZCAibWlzc2luZyBhcmd1bWVudHMgZm9yICVzIgogbXNnc3RyICJhcmd1bWVudCBzYWtuYXMgZsO2ciAlcyIKIAotIzogc2VxdWVuY2VyLmM6MjE3NAorIzogc2VxdWVuY2VyLmM6MjExMgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcGFyc2UgJyUuKnMnIgogbXNnc3RyICJrdW5kZSBpbnRlIHRvbGthIFwiJS4qc1wiIgogCi0jOiBzZXF1ZW5jZXIuYzoyMjI4CisjOiBzZXF1ZW5jZXIuYzoyMTY2CiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgbGluZSAlZDogJS4qcyIKIG1zZ3N0ciAib2dpbHRpZyByYWQgJWQ6ICUuKnMiCiAKLSM6IHNlcXVlbmNlci5jOjIyMzkKKyM6IHNlcXVlbmNlci5jOjIxNzcKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90ICclcycgd2l0aG91dCBhIHByZXZpb3VzIGNvbW1pdCIKIG1zZ3N0ciAia2FuIGludGUgdXRmw7ZyYSBcIiVzXCIgdXRhbiBlbiBmw7ZyZWfDpWVuZGUgaW5jaGVja25pbmciCiAKLSM6IHNlcXVlbmNlci5jOjIyODcgYnVpbHRpbi9yZWJhc2UuYzoxNTMgYnVpbHRpbi9yZWJhc2UuYzoxNzgKKyM6IHNlcXVlbmNlci5jOjIyMjUgYnVpbHRpbi9yZWJhc2UuYzoxNTMgYnVpbHRpbi9yZWJhc2UuYzoxNzgKICM6IGJ1aWx0aW4vcmViYXNlLmM6MjA0IGJ1aWx0aW4vcmViYXNlLmM6MjI5CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCByZWFkICclcycuIgogbXNnc3RyICJrdW5kZSBpbnRlIGzDpHNhIFwiJXNcIi4iCiAKLSM6IHNlcXVlbmNlci5jOjIzMjMKKyM6IHNlcXVlbmNlci5jOjIyNjEKIG1zZ2lkICJjYW5jZWxsaW5nIGEgY2hlcnJ5IHBpY2tpbmcgaW4gcHJvZ3Jlc3MiCiBtc2dzdHIgImF2YnJ5dGVyIHDDpWfDpWVuZGUgXCJjaGVycnktcGlja1wiIgogCi0jOiBzZXF1ZW5jZXIuYzoyMzMwCisjOiBzZXF1ZW5jZXIuYzoyMjY4CiBtc2dpZCAiY2FuY2VsbGluZyBhIHJldmVydCBpbiBwcm9ncmVzcyIKIG1zZ3N0ciAiYXZicnl0ZXIgcMOlZ8OlZW5kZSBcInJldmVydFwiIgogCi0jOiBzZXF1ZW5jZXIuYzoyMzY0CisjOiBzZXF1ZW5jZXIuYzoyMzAyCiBtc2dpZCAicGxlYXNlIGZpeCB0aGlzIHVzaW5nICdnaXQgcmViYXNlIC0tZWRpdC10b2RvJy4iCiBtc2dzdHIgInLDpHR0YSBkZXQgbWVkIFwiZ2l0IHJlYmFzZSAtLWVkaXQtdG9kb1wiLiIKIAotIzogc2VxdWVuY2VyLmM6MjM2NgorIzogc2VxdWVuY2VyLmM6MjMwNAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bnVzYWJsZSBpbnN0cnVjdGlvbiBzaGVldDogJyVzJyIKIG1zZ3N0ciAib2FudsOkbmRiYXJ0IG1hbnVzOiBcIiVzXCIiCiAKLSM6IHNlcXVlbmNlci5jOjIzNzEKKyM6IHNlcXVlbmNlci5jOjIzMDkKIG1zZ2lkICJubyBjb21taXRzIHBhcnNlZC4iCiBtc2dzdHIgImluZ2EgaW5jaGVja25pbmdhciBsw6RzdGVzLiIKIAotIzogc2VxdWVuY2VyLmM6MjM4MgorIzogc2VxdWVuY2VyLmM6MjMyMAogbXNnaWQgImNhbm5vdCBjaGVycnktcGljayBkdXJpbmcgYSByZXZlcnQuIgogbXNnc3RyICJrYW4gaW50ZSB1dGbDtnJhIFwiY2hlcnJ5LXBpY2tcIiB1bmRlciBlbiBcInJldmVydFwiLiIKIAotIzogc2VxdWVuY2VyLmM6MjM4NAorIzogc2VxdWVuY2VyLmM6MjMyMgogbXNnaWQgImNhbm5vdCByZXZlcnQgZHVyaW5nIGEgY2hlcnJ5LXBpY2suIgogbXNnc3RyICJrYW4gaW50ZSB1dGbDtnJhIFwicmV2ZXJ0XCIgdW5kZXIgZW4gXCJjaGVycnktcGlja1wiLiIKIAotIzogc2VxdWVuY2VyLmM6MjQ2NgorIzogc2VxdWVuY2VyLmM6MjQwNAogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIHZhbHVlIGZvciAlczogJXMiCiBtc2dzdHIgImZlbGFrdGlndCB2w6RyZGUgZsO2ciAlczogJXMiCiAKLSM6IHNlcXVlbmNlci5jOjI1NTMKKyM6IHNlcXVlbmNlci5jOjI0OTEKIG1zZ2lkICJ1bnVzYWJsZSBzcXVhc2gtb250byIKIG1zZ3N0ciAib2FudsOkbmRiYXIgc3F1YXNoLW9udG8iCiAKLSM6IHNlcXVlbmNlci5jOjI1NjkKKyM6IHNlcXVlbmNlci5jOjI1MDcKICMsIGMtZm9ybWF0CiBtc2dpZCAibWFsZm9ybWVkIG9wdGlvbnMgc2hlZXQ6ICclcyciCiBtc2dzdHIgInRyYXNpZ3QgbWFudXM6IFwiJXNcIiIKIAotIzogc2VxdWVuY2VyLmM6MjY1MiBzZXF1ZW5jZXIuYzo0MzUxCisjOiBzZXF1ZW5jZXIuYzoyNTkwIHNlcXVlbmNlci5jOjQzMDgKIG1zZ2lkICJlbXB0eSBjb21taXQgc2V0IHBhc3NlZCIKIG1zZ3N0ciAiZGVuIGFuZ2l2bmEgdXBwc8OkdHRuaW5nZW4gaW5jaGVja25pbmdhciDDpHIgdG9tIgogCi0jOiBzZXF1ZW5jZXIuYzoyNjY4CisjOiBzZXF1ZW5jZXIuYzoyNjA2CiBtc2dpZCAicmV2ZXJ0IGlzIGFscmVhZHkgaW4gcHJvZ3Jlc3MiCiBtc2dzdHIgImVuIFwicmV2ZXJ0XCIgcMOlZ8OlciByZWRhbiIKIAotIzogc2VxdWVuY2VyLmM6MjY3MAorIzogc2VxdWVuY2VyLmM6MjYwOAogIywgYy1mb3JtYXQKIG1zZ2lkICJ0cnkgXCJnaXQgcmV2ZXJ0ICgtLWNvbnRpbnVlIHwgJXMtLWFib3J0IHwgLS1xdWl0KVwiIgogbXNnc3RyICJ0ZXN0YSBcImdpdCByZXZlcnQgKC0tY29udGludWUgfCAlcy0tYWJvcnQgfCAtLXF1aXQpXCIiCiAKLSM6IHNlcXVlbmNlci5jOjI2NzMKKyM6IHNlcXVlbmNlci5jOjI2MTEKIG1zZ2lkICJjaGVycnktcGljayBpcyBhbHJlYWR5IGluIHByb2dyZXNzIgogbXNnc3RyICJlbiBcImNoZXJyeS1waWNrXCIgcMOlZ8OlciByZWRhbiIKIAotIzogc2VxdWVuY2VyLmM6MjY3NQorIzogc2VxdWVuY2VyLmM6MjYxMwogIywgYy1mb3JtYXQKIG1zZ2lkICJ0cnkgXCJnaXQgY2hlcnJ5LXBpY2sgKC0tY29udGludWUgfCAlcy0tYWJvcnQgfCAtLXF1aXQpXCIiCiBtc2dzdHIgInRlc3RhIFwiZ2l0IGNoZXJyeS1waWNrICgtLWNvbnRpbnVlIHwgJXMtLWFib3J0IHwgLS1xdWl0KVwiIgogCi0jOiBzZXF1ZW5jZXIuYzoyNjg5CisjOiBzZXF1ZW5jZXIuYzoyNjI3CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBjcmVhdGUgc2VxdWVuY2VyIGRpcmVjdG9yeSAnJXMnIgogbXNnc3RyICJrdW5kZSBpbnRlIHNrYXBhIFwic2VxdWVuY2VyXCIta2F0YWxvZ2VuIFwiJXNcIiIKIAotIzogc2VxdWVuY2VyLmM6MjcwNAorIzogc2VxdWVuY2VyLmM6MjY0MgogbXNnaWQgImNvdWxkIG5vdCBsb2NrIEhFQUQiCiBtc2dzdHIgImt1bmRlIGludGUgbMOlc2EgSEVBRCIKIAotIzogc2VxdWVuY2VyLmM6Mjc2NCBzZXF1ZW5jZXIuYzo0MTAzCisjOiBzZXF1ZW5jZXIuYzoyNzAyIHNlcXVlbmNlci5jOjQwNTcKIG1zZ2lkICJubyBjaGVycnktcGljayBvciByZXZlcnQgaW4gcHJvZ3Jlc3MiCiBtc2dzdHIgImluZ2VuIFwiY2hlcnJ5LXBpY2tcIiBlbGxlciBcInJldmVydFwiIHDDpWfDpXIiCiAKLSM6IHNlcXVlbmNlci5jOjI3NjYgc2VxdWVuY2VyLmM6Mjc3NworIzogc2VxdWVuY2VyLmM6MjcwNCBzZXF1ZW5jZXIuYzoyNzE1CiBtc2dpZCAiY2Fubm90IHJlc29sdmUgSEVBRCIKIG1zZ3N0ciAia2FuIGludGUgYmVzdMOkbW1hIEhFQUQiCiAKLSM6IHNlcXVlbmNlci5jOjI3Njggc2VxdWVuY2VyLmM6MjgxMgorIzogc2VxdWVuY2VyLmM6MjcwNiBzZXF1ZW5jZXIuYzoyNzUwCiBtc2dpZCAiY2Fubm90IGFib3J0IGZyb20gYSBicmFuY2ggeWV0IHRvIGJlIGJvcm4iCiBtc2dzdHIgImthbiBpbnRlIGF2YnJ5dGEgZnLDpW4gZW4gZ3JlbiBzb20gw6RubnUgaW50ZSDDpHIgZsO2ZGQiCiAKLSM6IHNlcXVlbmNlci5jOjI3OTggYnVpbHRpbi9ncmVwLmM6NzM0CisjOiBzZXF1ZW5jZXIuYzoyNzM2IGJ1aWx0aW4vZ3JlcC5jOjczNgogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3Qgb3BlbiAnJXMnIgogbXNnc3RyICJrYW4gaW50ZSDDtnBwbmEgXCIlc1wiIgogCi0jOiBzZXF1ZW5jZXIuYzoyODAwCisjOiBzZXF1ZW5jZXIuYzoyNzM4CiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCByZWFkICclcyc6ICVzIgogbXNnc3RyICJrYW4gaW50ZSBsw6RzYSBcIiVzXCI6ICVzIgogCi0jOiBzZXF1ZW5jZXIuYzoyODAxCisjOiBzZXF1ZW5jZXIuYzoyNzM5CiBtc2dpZCAidW5leHBlY3RlZCBlbmQgb2YgZmlsZSIKIG1zZ3N0ciAib3bDpG50YXQgZmlsc2x1dCIKIAotIzogc2VxdWVuY2VyLmM6MjgwNworIzogc2VxdWVuY2VyLmM6Mjc0NQogIywgYy1mb3JtYXQKIG1zZ2lkICJzdG9yZWQgcHJlLWNoZXJyeS1waWNrIEhFQUQgZmlsZSAnJXMnIGlzIGNvcnJ1cHQiCiBtc2dzdHIgInNwYXJhZCBIRUFELWZpbCBmcsOlbiBmw7ZyZSBcImNoZXJyeS1waWNrXCIsIFwiJXNcIiwgw6RyIHRyYXNpZyIKIAotIzogc2VxdWVuY2VyLmM6MjgxOAorIzogc2VxdWVuY2VyLmM6Mjc1NgogbXNnaWQgIllvdSBzZWVtIHRvIGhhdmUgbW92ZWQgSEVBRC4gTm90IHJld2luZGluZywgY2hlY2sgeW91ciBIRUFEISIKIG1zZ3N0ciAiIgogIkR1IHZlcmthciBoYSBmbHl0dGF0IEhFQUQuXG4iCiAiU3BvbGFyIGludGUgdGlsbGJha2EsIGtvbnRyb2xsZXJhIEhFQUQhIgogCi0jOiBzZXF1ZW5jZXIuYzoyODU5CisjOiBzZXF1ZW5jZXIuYzoyNzk3CiBtc2dpZCAibm8gcmV2ZXJ0IGluIHByb2dyZXNzIgogbXNnc3RyICJpbmdlbiBcInJldmVyc1wiIHDDpWfDpXIiCiAKLSM6IHNlcXVlbmNlci5jOjI4NjcKKyM6IHNlcXVlbmNlci5jOjI4MDUKIG1zZ2lkICJubyBjaGVycnktcGljayBpbiBwcm9ncmVzcyIKIG1zZ3N0ciAiaW5nZW4gXCJjaGVycnktcGlja1wiIHDDpWfDpXIiCiAKLSM6IHNlcXVlbmNlci5jOjI4NzcKKyM6IHNlcXVlbmNlci5jOjI4MTUKIG1zZ2lkICJmYWlsZWQgdG8gc2tpcCB0aGUgY29tbWl0IgogbXNnc3RyICJrdW5kZSBpbnRlIGhvcHBhIMO2dmVyIGluY2hlY2tuaW5nZW4iCiAKLSM6IHNlcXVlbmNlci5jOjI4ODQKKyM6IHNlcXVlbmNlci5jOjI4MjIKIG1zZ2lkICJ0aGVyZSBpcyBub3RoaW5nIHRvIHNraXAiCiBtc2dzdHIgImluZ2VudGluZyBhdHQgaG9wcGEgw7Z2ZXIiCiAKLSM6IHNlcXVlbmNlci5jOjI4ODcKKyM6IHNlcXVlbmNlci5jOjI4MjUKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogImhhdmUgeW91IGNvbW1pdHRlZCBhbHJlYWR5P1xuIgpAQCAtNjI5NCwyMSArNjMxOSwyMSBAQAogImhhciBkdSByZWRhbiBjaGVja2F0IGluP1xuIgogInRlc3RhIFwiZ2l0ICVzIC0tY29udGludWVcIiIKIAotIzogc2VxdWVuY2VyLmM6MzAxMSBzZXF1ZW5jZXIuYzo0MDE1CisjOiBzZXF1ZW5jZXIuYzoyOTQ5IHNlcXVlbmNlci5jOjM5NjkKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHVwZGF0ZSAlcyIKIG1zZ3N0ciAia3VuZGUgaW50ZSB1cHBkYXRlcmEgJXMiCiAKLSM6IHNlcXVlbmNlci5jOjMwNDkgc2VxdWVuY2VyLmM6Mzk5NQorIzogc2VxdWVuY2VyLmM6Mjk4NyBzZXF1ZW5jZXIuYzozOTQ5CiBtc2dpZCAiY2Fubm90IHJlYWQgSEVBRCIKIG1zZ3N0ciAia2FuIGludGUgbMOkc2EgSEVBRCIKIAotIzogc2VxdWVuY2VyLmM6MzA2NgorIzogc2VxdWVuY2VyLmM6MzAwNAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gY29weSAnJXMnIHRvICclcyciCiBtc2dzdHIgImthbiBpbnRlIGtvcGllcmEgaW4gXCIlc1wiIHRpbGwgXCIlc1wiIgogCi0jOiBzZXF1ZW5jZXIuYzozMDc0CisjOiBzZXF1ZW5jZXIuYzozMDEyCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJZb3UgY2FuIGFtZW5kIHRoZSBjb21taXQgbm93LCB3aXRoXG4iCkBAIC02MzI3LDI3ICs2MzUyLDI3IEBACiAiXG4iCiAiXHRnaXQgcmViYXNlIC0tY29udGludWVcbiIKIAotIzogc2VxdWVuY2VyLmM6MzA4NAorIzogc2VxdWVuY2VyLmM6MzAyMgogIywgYy1mb3JtYXQKIG1zZ2lkICJDb3VsZCBub3QgYXBwbHkgJXMuLi4gJS4qcyIKIG1zZ3N0ciAiS3VuZGUgaW50ZSB0aWxsw6RtcGEgJXMuLi4gJS4qcyIKIAotIzogc2VxdWVuY2VyLmM6MzA5MQorIzogc2VxdWVuY2VyLmM6MzAyOQogIywgYy1mb3JtYXQKIG1zZ2lkICJDb3VsZCBub3QgbWVyZ2UgJS4qcyIKIG1zZ3N0ciAiS3VuZGUgaW50ZSBzbMOlIGlob3AgJS4qcyIKIAotIzogc2VxdWVuY2VyLmM6MzEwNSBzZXF1ZW5jZXIuYzozMTA5IGJ1aWx0aW4vZGlmZnRvb2wuYzo2MzMKKyM6IHNlcXVlbmNlci5jOjMwNDMgc2VxdWVuY2VyLmM6MzA0NyBidWlsdGluL2RpZmZ0b29sLmM6NjQxCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBjb3B5ICclcycgdG8gJyVzJyIKIG1zZ3N0ciAia3VuZGUgaW50ZSBrb3BpZXJhIGluIFwiJXNcIiB0aWxsIFwiJXNcIiIKIAotIzogc2VxdWVuY2VyLmM6MzEzMSBzZXF1ZW5jZXIuYzozNTU4IGJ1aWx0aW4vcmViYXNlLmM6ODQ5IGJ1aWx0aW4vcmViYXNlLmM6MTU4MgotIzogYnVpbHRpbi9yZWJhc2UuYzoxOTUzIGJ1aWx0aW4vcmViYXNlLmM6MjAwOAorIzogc2VxdWVuY2VyLmM6MzA2OSBzZXF1ZW5jZXIuYzozNTA2IGJ1aWx0aW4vcmViYXNlLmM6ODUwIGJ1aWx0aW4vcmViYXNlLmM6MTYxMworIzogYnVpbHRpbi9yZWJhc2UuYzoxOTg3IGJ1aWx0aW4vcmViYXNlLmM6MjAzMQogbXNnaWQgImNvdWxkIG5vdCByZWFkIGluZGV4IgogbXNnc3RyICJrdW5kZSBpbnRlIGzDpHNhIGluZGV4ZXQiCiAKLSM6IHNlcXVlbmNlci5jOjMxMzYKKyM6IHNlcXVlbmNlci5jOjMwNzQKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogImV4ZWN1dGlvbiBmYWlsZWQ6ICVzXG4iCkBAIC02MzYyLDExICs2Mzg3LDExIEBACiAiXHRnaXQgcmViYXNlIC0tY29udGludWVcbiIKICJcbiIKIAotIzogc2VxdWVuY2VyLmM6MzE0MgorIzogc2VxdWVuY2VyLmM6MzA4MAogbXNnaWQgImFuZCBtYWRlIGNoYW5nZXMgdG8gdGhlIGluZGV4IGFuZC9vciB0aGUgd29ya2luZyB0cmVlXG4iCiBtc2dzdHIgIm9jaCBnam9yZGUgw6RuZHJpbmdhciB0aWxsIGluZGV4ZXQgb2NoL2VsbGVyIGFyYmV0c2thdGFsb2dlblxuIgogCi0jOiBzZXF1ZW5jZXIuYzozMTQ4CisjOiBzZXF1ZW5jZXIuYzozMDg2CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJleGVjdXRpb24gc3VjY2VlZGVkOiAlc1xuIgpAQCAtNjM4Myw3NiArNjQwOCw3NiBAQAogIlx0Z2l0IHJlYmFzZSAtLWNvbnRpbnVlXG4iCiAiXG4iCiAKLSM6IHNlcXVlbmNlci5jOjMyMDkKKyM6IHNlcXVlbmNlci5jOjMxNDcKICMsIGMtZm9ybWF0CiBtc2dpZCAiaWxsZWdhbCBsYWJlbCBuYW1lOiAnJS4qcyciCiBtc2dzdHIgIm9naWx0aWd0IGV0aWtldHRuYW1uOiBcIiUuKnNcIiIKIAotIzogc2VxdWVuY2VyLmM6MzI2MworIzogc2VxdWVuY2VyLmM6MzIwMQogbXNnaWQgIndyaXRpbmcgZmFrZSByb290IGNvbW1pdCIKIG1zZ3N0ciAic2tyaXZlciBmZWprYWQgcm90aW5jaGVja25pbmciCiAKLSM6IHNlcXVlbmNlci5jOjMyNjgKKyM6IHNlcXVlbmNlci5jOjMyMDYKIG1zZ2lkICJ3cml0aW5nIHNxdWFzaC1vbnRvIgogbXNnc3RyICJza3JpdmVyIHNxdWFzaC1vbnRvIgogCi0jOiBzZXF1ZW5jZXIuYzozMzA2IGJ1aWx0aW4vcmViYXNlLmM6ODU0IGJ1aWx0aW4vcmViYXNlLmM6ODYwCisjOiBzZXF1ZW5jZXIuYzozMjQ0IGJ1aWx0aW4vcmViYXNlLmM6ODU1IGJ1aWx0aW4vcmViYXNlLmM6ODYxCiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBmaW5kIHRyZWUgb2YgJXMiCiBtc2dzdHIgImt1bmRlIGludGUgaGl0dGEgdHLDpGRldCBmw7ZyICVzLiIKIAotIzogc2VxdWVuY2VyLmM6MzMyNCBidWlsdGluL3JlYmFzZS5jOjg3MworIzogc2VxdWVuY2VyLmM6MzI2MiBidWlsdGluL3JlYmFzZS5jOjg3NAogbXNnaWQgImNvdWxkIG5vdCB3cml0ZSBpbmRleCIKIG1zZ3N0ciAia3VuZGUgaW50ZSBza3JpdmEgaW5kZXhldCIKIAotIzogc2VxdWVuY2VyLmM6MzM1MQorIzogc2VxdWVuY2VyLmM6MzI4OQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcmVzb2x2ZSAnJXMnIgogbXNnc3RyICJrdW5kZSBpbnRlIHVwcGzDtnNhIFwiJXNcIiIKIAotIzogc2VxdWVuY2VyLmM6MzM3OQorIzogc2VxdWVuY2VyLmM6MzMyMAogbXNnaWQgImNhbm5vdCBtZXJnZSB3aXRob3V0IGEgY3VycmVudCByZXZpc2lvbiIKIG1zZ3N0ciAia2FuIGludGUgc2zDpSBpaG9wIHV0YW4gZW4gYWt0dWVsbCBpbmNoZWNrbmluZyIKIAotIzogc2VxdWVuY2VyLmM6MzQwMQorIzogc2VxdWVuY2VyLmM6MzM0MgogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gcGFyc2UgJyUuKnMnIgogbXNnc3RyICJrYW4gaW50ZSB0b2xrYSBcIiUuKnNcIiIKIAotIzogc2VxdWVuY2VyLmM6MzQxMAorIzogc2VxdWVuY2VyLmM6MzM1MQogIywgYy1mb3JtYXQKIG1zZ2lkICJub3RoaW5nIHRvIG1lcmdlOiAnJS4qcyciCiBtc2dzdHIgImluZ2V0IGF0dCBzbMOlIHNhbW1hbjogXCIlLipzXCIiCiAKLSM6IHNlcXVlbmNlci5jOjM0MjIKKyM6IHNlcXVlbmNlci5jOjMzNjMKIG1zZ2lkICJvY3RvcHVzIG1lcmdlIGNhbm5vdCBiZSBleGVjdXRlZCBvbiB0b3Agb2YgYSBbbmV3IHJvb3RdIgogbXNnc3RyICJcIm9jdG9wdXNcIi1zYW1tYW5zbGFnbmluZyBrYW4gaW50ZSBrw7ZyYXMgb3ZhbnDDpSBlbiBbbnkgcm90XSIKIAotIzogc2VxdWVuY2VyLmM6MzQzNworIzogc2VxdWVuY2VyLmM6MzM3OAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgZ2V0IGNvbW1pdCBtZXNzYWdlIG9mICclcyciCiBtc2dzdHIgImt1bmRlIGludGUgbMOkc2EgaW5jaGVja25pbmdzbWVkZGVsYW5kZSBmw7ZyIFwiJXNcIiIKIAotIzogc2VxdWVuY2VyLmM6MzU5MAorIzogc2VxdWVuY2VyLmM6MzUzOAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgZXZlbiBhdHRlbXB0IHRvIG1lcmdlICclLipzJyIKIG1zZ3N0ciAia3VuZGUgaW50ZSBlbnMgZsO2cnPDtmthIHNsw6UgaWhvcCBcIiUuKnNcIiIKIAotIzogc2VxdWVuY2VyLmM6MzYwNgorIzogc2VxdWVuY2VyLmM6MzU1NAogbXNnaWQgIm1lcmdlOiBVbmFibGUgdG8gd3JpdGUgbmV3IGluZGV4IGZpbGUiCiBtc2dzdHIgInNhbW1hbnNsYWduaW5nOiBLdW5kZSBpbnRlIHNrcml2YSBueSBpbmRleGZpbCIKIAotIzogc2VxdWVuY2VyLmM6MzY3NSBidWlsdGluL3JlYmFzZS5jOjcxMQorIzogc2VxdWVuY2VyLmM6MzYyMyBidWlsdGluL3JlYmFzZS5jOjcxMgogIywgYy1mb3JtYXQKIG1zZ2lkICJBcHBsaWVkIGF1dG9zdGFzaC5cbiIKIG1zZ3N0ciAiVGlsbMOkbXBhZGUgYXV0b3N0YXNoLlxuIgogCi0jOiBzZXF1ZW5jZXIuYzozNjg3CisjOiBzZXF1ZW5jZXIuYzozNjM1CiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCBzdG9yZSAlcyIKIG1zZ3N0ciAia2FuIGludGUgc3BhcmEgJXMiCiAKLSM6IHNlcXVlbmNlci5jOjM2OTAgYnVpbHRpbi9yZWJhc2UuYzo3MjcgZ2l0LXJlYmFzZS0tcHJlc2VydmUtbWVyZ2VzLnNoOjExMworIzogc2VxdWVuY2VyLmM6MzYzOCBidWlsdGluL3JlYmFzZS5jOjcyOCBnaXQtcmViYXNlLS1wcmVzZXJ2ZS1tZXJnZXMuc2g6MTEzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJBcHBseWluZyBhdXRvc3Rhc2ggcmVzdWx0ZWQgaW4gY29uZmxpY3RzLlxuIgpAQCAtNjQ2MywzMSArNjQ4OCwzMSBAQAogIkRpbmEgw6RuZHJpbmdhciDDpHIgc8Oka3JhIGkgc3Rhc2hlbi5cbiIKICJEdSBrYW4gbsOkciBzb20gaGVsc3QgYW52w6RuZGEgXCJnaXQgc3Rhc2ggcG9wXCIgZWxsZXIgXCJnaXQgc3Rhc2ggZHJvcFwiLlxuIgogCi0jOiBzZXF1ZW5jZXIuYzozNzUxCisjOiBzZXF1ZW5jZXIuYzozNjk5CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBjaGVja291dCAlcyIKIG1zZ3N0ciAia3VuZGUgaW50ZSBjaGVja2EgdXQgJXMiCiAKLSM6IHNlcXVlbmNlci5jOjM3NjUKKyM6IHNlcXVlbmNlci5jOjM3MTMKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXM6IG5vdCBhIHZhbGlkIE9JRCIKIG1zZ3N0ciAiJXM6IGludGUgZXR0IGdpbHRpZ3QgT0lEIgogCi0jOiBzZXF1ZW5jZXIuYzozNzcwIGdpdC1yZWJhc2UtLXByZXNlcnZlLW1lcmdlcy5zaDo3NzkKKyM6IHNlcXVlbmNlci5jOjM3MTggZ2l0LXJlYmFzZS0tcHJlc2VydmUtbWVyZ2VzLnNoOjc3OQogbXNnaWQgImNvdWxkIG5vdCBkZXRhY2ggSEVBRCIKIG1zZ3N0ciAia3VuZGUgaW50ZSBrb3BwbGEgZnLDpW4gSEVBRCIKIAotIzogc2VxdWVuY2VyLmM6Mzc4NQorIzogc2VxdWVuY2VyLmM6MzczMwogIywgYy1mb3JtYXQKIG1zZ2lkICJTdG9wcGVkIGF0IEhFQURcbiIKIG1zZ3N0ciAiU3RvcHBhZGUgcMOlIEhFQURcbiIKIAotIzogc2VxdWVuY2VyLmM6Mzc4NworIzogc2VxdWVuY2VyLmM6MzczNQogIywgYy1mb3JtYXQKIG1zZ2lkICJTdG9wcGVkIGF0ICVzXG4iCiBtc2dzdHIgIlN0b3BwYWRlIHDDpSAlc1xuIgogCi0jOiBzZXF1ZW5jZXIuYzozNzk1CisjOiBzZXF1ZW5jZXIuYzozNzQzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJDb3VsZCBub3QgZXhlY3V0ZSB0aGUgdG9kbyBjb21tYW5kXG4iCkBAIC02NTA4LDQ4ICs2NTMzLDQ4IEBACiAiICAgIGdpdCByZWJhc2UgLS1lZGl0LXRvZG9cbiIKICIgICAgZ2l0IHJlYmFzZSAtLWNvbnRpbnVlXG4iCiAKLSM6IHNlcXVlbmNlci5jOjM4NzcKKyM6IHNlcXVlbmNlci5jOjM4MjcKICMsIGMtZm9ybWF0CiBtc2dpZCAiU3RvcHBlZCBhdCAlcy4uLiAgJS4qc1xuIgogbXNnc3RyICJTdG9wcGFkZSBww6UgJXMuLi4gJS4qc1xuIgogCi0jOiBzZXF1ZW5jZXIuYzozOTU4CisjOiBzZXF1ZW5jZXIuYzozODk4CiAjLCBjLWZvcm1hdAogbXNnaWQgInVua25vd24gY29tbWFuZCAlZCIKIG1zZ3N0ciAib2vDpG50IGtvbW1hbmRvICVkIgogCi0jOiBzZXF1ZW5jZXIuYzo0MDAzCisjOiBzZXF1ZW5jZXIuYzozOTU3CiBtc2dpZCAiY291bGQgbm90IHJlYWQgb3JpZy1oZWFkIgogbXNnc3RyICJrdW5kZSBpbnRlIGzDpHNhIG9yaWctaGVhZCIKIAotIzogc2VxdWVuY2VyLmM6NDAwOAorIzogc2VxdWVuY2VyLmM6Mzk2MgogbXNnaWQgImNvdWxkIG5vdCByZWFkICdvbnRvJyIKIG1zZ3N0ciAia3VuZGUgaW50ZSBsw6RzYSBcIm9udG9cIiIKIAotIzogc2VxdWVuY2VyLmM6NDAyMgorIzogc2VxdWVuY2VyLmM6Mzk3NgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgdXBkYXRlIEhFQUQgdG8gJXMiCiBtc2dzdHIgImt1bmRlIGludGUgdXBwZGF0ZXJhIEhFQUQgdGlsbCAlcyIKIAotIzogc2VxdWVuY2VyLmM6NDExNQorIzogc2VxdWVuY2VyLmM6NDA2OQogbXNnaWQgImNhbm5vdCByZWJhc2U6IFlvdSBoYXZlIHVuc3RhZ2VkIGNoYW5nZXMuIgogbXNnc3RyICJrYW4gaW50ZSBvbWJhc2VyYTogRHUgaGFyIG9rw7ZhZGUgw6RuZHJpbmdhci4iCiAKLSM6IHNlcXVlbmNlci5jOjQxMjQKKyM6IHNlcXVlbmNlci5jOjQwNzgKIG1zZ2lkICJjYW5ub3QgYW1lbmQgbm9uLWV4aXN0aW5nIGNvbW1pdCIKIG1zZ3N0ciAia2FuIGludGUgbMOkZ2dhIHRpbGwgaW5jaGVja25pbmcgc29tIGludGUgZmlubnMiCiAKLSM6IHNlcXVlbmNlci5jOjQxMjYKKyM6IHNlcXVlbmNlci5jOjQwODAKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBmaWxlOiAnJXMnIgogbXNnc3RyICJvZ2lsdGlnIGZpbDogXCIlc1wiIgogCi0jOiBzZXF1ZW5jZXIuYzo0MTI4CisjOiBzZXF1ZW5jZXIuYzo0MDgyCiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgY29udGVudHM6ICclcyciCiBtc2dzdHIgIm9naWx0aWd0IGlubmVow6VsbDogXCIlc1wiIgogCi0jOiBzZXF1ZW5jZXIuYzo0MTMxCisjOiBzZXF1ZW5jZXIuYzo0MDg1CiBtc2dpZCAiIgogIlxuIgogIllvdSBoYXZlIHVuY29tbWl0dGVkIGNoYW5nZXMgaW4geW91ciB3b3JraW5nIHRyZWUuIFBsZWFzZSwgY29tbWl0IHRoZW1cbiIKQEAgLTY1NTksNDIgKzY1ODQsNDIgQEAKICJEdSBoYXIgw6RuZHJpbmdhciBpIGFyYmV0c2thdGFsb2dlbiBzb20gaW50ZSBjaGVja2F0cyBpbi4gQ2hlY2thIGluIGRlbVxuIgogImbDtnJzdCBvY2gga8O2ciBzZWRhbiBcImdpdCByZWJhc2UgLS1jb250aW51ZVwiIGlnZW4uIgogCi0jOiBzZXF1ZW5jZXIuYzo0MTY3IHNlcXVlbmNlci5jOjQyMDUKKyM6IHNlcXVlbmNlci5jOjQxMjEgc2VxdWVuY2VyLmM6NDE1OQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3Qgd3JpdGUgZmlsZTogJyVzJyIKIG1zZ3N0ciAia3VuZGUgaW50ZSBza3JpdmEgZmlsOiBcIiVzXCIiCiAKLSM6IHNlcXVlbmNlci5jOjQyMjAKKyM6IHNlcXVlbmNlci5jOjQxNzQKIG1zZ2lkICJjb3VsZCBub3QgcmVtb3ZlIENIRVJSWV9QSUNLX0hFQUQiCiBtc2dzdHIgImt1bmRlIGludGUgdGEgYm9ydCBDSEVSUllfUElDS19IRUFEIgogCi0jOiBzZXF1ZW5jZXIuYzo0MjI3CisjOiBzZXF1ZW5jZXIuYzo0MTgxCiBtc2dpZCAiY291bGQgbm90IGNvbW1pdCBzdGFnZWQgY2hhbmdlcy4iCiBtc2dzdHIgImt1bmRlIGludGUgY2hlY2thIGluIGvDtmFkZSDDpG5kcmluZ2FyLiIKIAotIzogc2VxdWVuY2VyLmM6NDMyOAorIzogc2VxdWVuY2VyLmM6NDI4NQogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogY2FuJ3QgY2hlcnJ5LXBpY2sgYSAlcyIKIG1zZ3N0ciAiJXM6IGthbiBpbnRlIGfDtnJhIFwiY2hlcnJ5LXBpY2tcIiBww6UgdHlwZW4gXCIlc1wiIgogCi0jOiBzZXF1ZW5jZXIuYzo0MzMyCisjOiBzZXF1ZW5jZXIuYzo0Mjg5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiBiYWQgcmV2aXNpb24iCiBtc2dzdHIgIiVzOiBmZWxha3RpZyByZXZpc2lvbiIKIAotIzogc2VxdWVuY2VyLmM6NDM2NworIzogc2VxdWVuY2VyLmM6NDMyNAogbXNnaWQgImNhbid0IHJldmVydCBhcyBpbml0aWFsIGNvbW1pdCIKIG1zZ3N0ciAia2FuIGludGUgw6VuZ3JhIHNvbSBmw7Zyc3RhIGluY2hlY2tuaW5nIgogCi0jOiBzZXF1ZW5jZXIuYzo0ODEwCisjOiBzZXF1ZW5jZXIuYzo0Nzc0CiBtc2dpZCAibWFrZV9zY3JpcHQ6IHVuaGFuZGxlZCBvcHRpb25zIgogbXNnc3RyICJtYWtlX3NjcmlwdDogZmxhZ2dvciBzb20gaW50ZSBzdMO2ZHMiCiAKLSM6IHNlcXVlbmNlci5jOjQ4MTMKKyM6IHNlcXVlbmNlci5jOjQ3NzcKIG1zZ2lkICJtYWtlX3NjcmlwdDogZXJyb3IgcHJlcGFyaW5nIHJldmlzaW9ucyIKIG1zZ3N0ciAibWFrZV9zY3JpcHQ6IGZlbCBuw6RyIHJldmlzaW9uZXIgc2t1bGxlIGbDtnJiZXJlZGFzIgogCi0jOiBzZXF1ZW5jZXIuYzo0OTcxCisjOiBzZXF1ZW5jZXIuYzo0OTM1CiBtc2dpZCAiIgogIllvdSBjYW4gZml4IHRoaXMgd2l0aCAnZ2l0IHJlYmFzZSAtLWVkaXQtdG9kbycgYW5kIHRoZW4gcnVuICdnaXQgcmViYXNlIC0tIgogImNvbnRpbnVlJy5cbiIKQEAgLTY2MDQsMjQgKzY2MjksMjQgQEAKICJjb250aW51ZVwiLlxuIgogIkF2YnJ5dCBvbWJhc2VyaW5nZW4gbWVkIFwiZ2l0IHJlYmFzZSAtLWFib3J0XCIuXG4iCiAKLSM6IHNlcXVlbmNlci5jOjUwODMgc2VxdWVuY2VyLmM6NTEwMAorIzogc2VxdWVuY2VyLmM6NTA0NyBzZXF1ZW5jZXIuYzo1MDY0CiBtc2dpZCAibm90aGluZyB0byBkbyIKIG1zZ3N0ciAiaW5nZXQgYXR0IGfDtnJhIgogCi0jOiBzZXF1ZW5jZXIuYzo1MTE0CisjOiBzZXF1ZW5jZXIuYzo1MDc4CiBtc2dpZCAiY291bGQgbm90IHNraXAgdW5uZWNlc3NhcnkgcGljayBjb21tYW5kcyIKIG1zZ3N0ciAia3VuZGUgaW50ZSBob3BwYSDDtnZlciBvbsO2ZGlnYSBcInBpY2tcIi1rb21tYW5kb24iCiAKLSM6IHNlcXVlbmNlci5jOjUxOTcKKyM6IHNlcXVlbmNlci5jOjUxNjYKIG1zZ2lkICJ0aGUgc2NyaXB0IHdhcyBhbHJlYWR5IHJlYXJyYW5nZWQuIgogbXNnc3RyICJza3JpcHRldCBoYXIgcmVkYW4gb21vcmRuYXRzLiIKIAotIzogc2V0dXAuYzoxMjMKKyM6IHNldHVwLmM6MTI0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiclcycgaXMgb3V0c2lkZSByZXBvc2l0b3J5IgogbXNnc3RyICJcIiVzXCIgw6RyIHV0YW5mw7ZyIGFya2l2ZXQiCiAKLSM6IHNldHVwLmM6MTczCisjOiBzZXR1cC5jOjE3NAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiJXM6IG5vIHN1Y2ggcGF0aCBpbiB0aGUgd29ya2luZyB0cmVlLlxuIgpAQCAtNjYzMSw3ICs2NjU2LDcgQEAKICJBbnbDpG5kIFwiZ2l0IDxrb21tYW5kbz4gLS0gPHPDtmt2w6RnPi4uXCIgZsO2ciBhdHQgYW5nZSBzw7ZrdsOkZ2FyIHNvbSBpbnRlIGZpbm5zICIKICJsb2thbHQuIgogCi0jOiBzZXR1cC5jOjE4NgorIzogc2V0dXAuYzoxODcKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogImFtYmlndW91cyBhcmd1bWVudCAnJXMnOiB1bmtub3duIHJldmlzaW9uIG9yIHBhdGggbm90IGluIHRoZSB3b3JraW5nIHRyZWUuXG4iCkBAIC02NjQzLDEyICs2NjY4LDEyIEBACiAiQW52w6RuZCBcIi0tXCIgZsO2ciBhdHQgc2tpbGphIHPDtmt2w6RnYXIgZnLDpW4gcmV2aXNpb25lciwgc8OlIGjDpHI6XG4iCiAiXCJnaXQgPGtvbW1hbmRvPiBbPHJldmlzaW9uPi4uLl0gLS0gWzxmaWw+Li4uXVwiIgogCi0jOiBzZXR1cC5jOjIzNQorIzogc2V0dXAuYzoyMzYKICMsIGMtZm9ybWF0CiBtc2dpZCAib3B0aW9uICclcycgbXVzdCBjb21lIGJlZm9yZSBub24tb3B0aW9uIGFyZ3VtZW50cyIKIG1zZ3N0ciAiZmxhZ2dhbiBcIiVzXCIgbcOlc3RlIGFuZ2VzIGbDtnJlIGFyZ3VtZW50IHNvbSBpbnRlIMOkciBmbGFnZ29yIgogCi0jOiBzZXR1cC5jOjI1NAorIzogc2V0dXAuYzoyNTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogImFtYmlndW91cyBhcmd1bWVudCAnJXMnOiBib3RoIHJldmlzaW9uIGFuZCBmaWxlbmFtZVxuIgpAQCAtNjY1OSw5MiArNjY4NCw5MiBAQAogIkFudsOkbmQgXCItLVwiIGbDtnIgYXR0IHNraWxqYSBzw7ZrdsOkZ2FyIGZyw6VuIHJldmlzaW9uZXIsIHPDpSBow6RyOlxuIgogIlwiZ2l0IDxrb21tYW5kbz4gWzxyZXZpc2lvbj4uLi5dIC0tIFs8ZmlsPi4uLl1cIiIKIAotIzogc2V0dXAuYzozOTAKKyM6IHNldHVwLmM6MzkxCiBtc2dpZCAidW5hYmxlIHRvIHNldCB1cCB3b3JrIHRyZWUgdXNpbmcgaW52YWxpZCBjb25maWciCiBtc2dzdHIgImthbiBpbnRlIHNrYXBhIGFyYmV0c2thdGFsb2cgbWVkIGZlbGFrdGlnIGtvbmZpZ3VyYXRpb24iCiAKLSM6IHNldHVwLmM6Mzk0CisjOiBzZXR1cC5jOjM5NQogbXNnaWQgInRoaXMgb3BlcmF0aW9uIG11c3QgYmUgcnVuIGluIGEgd29yayB0cmVlIgogbXNnc3RyICJmdW5rdGlvbmVuIG3DpXN0ZSBrw7ZyYXMgaSBlbiBhcmJldHNrYXRhbG9nIgogCi0jOiBzZXR1cC5jOjU0MAorIzogc2V0dXAuYzo1NDEKICMsIGMtZm9ybWF0CiBtc2dpZCAiRXhwZWN0ZWQgZ2l0IHJlcG8gdmVyc2lvbiA8PSAlZCwgZm91bmQgJWQiCiBtc2dzdHIgIkbDtnJ2w6RudGFkZSBnaXQtYXJraXZ2ZXJzaW9uIDw9ICVkLCBoaXR0YWRlICVkIgogCi0jOiBzZXR1cC5jOjU0OAorIzogc2V0dXAuYzo1NDkKIG1zZ2lkICJ1bmtub3duIHJlcG9zaXRvcnkgZXh0ZW5zaW9ucyBmb3VuZDoiCiBtc2dzdHIgIm9rw6RuZGEgYXJraXZ1dMO2a25pbmdhciBoaXR0YWRlczoiCiAKLSM6IHNldHVwLmM6NTY3CisjOiBzZXR1cC5jOjU2OAogIywgYy1mb3JtYXQKIG1zZ2lkICJlcnJvciBvcGVuaW5nICclcyciCiBtc2dzdHIgImZlbCB2aWQgw7ZwcG5pbmcgYXYgXCIlc1wiIgogCi0jOiBzZXR1cC5jOjU2OQorIzogc2V0dXAuYzo1NzAKICMsIGMtZm9ybWF0CiBtc2dpZCAidG9vIGxhcmdlIHRvIGJlIGEgLmdpdCBmaWxlOiAnJXMnIgogbXNnc3RyICJmw7ZyIHN0b3IgZsO2ciBhdHQgdmFyYSBlbiAuZ2l0LWZpbDogXCIlc1wiIgogCi0jOiBzZXR1cC5jOjU3MQorIzogc2V0dXAuYzo1NzIKICMsIGMtZm9ybWF0CiBtc2dpZCAiZXJyb3IgcmVhZGluZyAlcyIKIG1zZ3N0ciAiZmVsIHZpZCBsw6RzbmluZyBhdiAlcyIKIAotIzogc2V0dXAuYzo1NzMKKyM6IHNldHVwLmM6NTc0CiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgZ2l0ZmlsZSBmb3JtYXQ6ICVzIgogbXNnc3RyICJvZ2lsdGlndCBnaXRmaWxmb3JtYXQ6ICVzIgogCi0jOiBzZXR1cC5jOjU3NQorIzogc2V0dXAuYzo1NzYKICMsIGMtZm9ybWF0CiBtc2dpZCAibm8gcGF0aCBpbiBnaXRmaWxlOiAlcyIKIG1zZ3N0ciAiaW5nZW4gc8O2a3bDpGcgaSBnaXRmaWw6ICVzIgogCi0jOiBzZXR1cC5jOjU3NworIzogc2V0dXAuYzo1NzgKICMsIGMtZm9ybWF0CiBtc2dpZCAibm90IGEgZ2l0IHJlcG9zaXRvcnk6ICVzIgogbXNnc3RyICJpbnRlIGV0dCBnaXQtYXJraXY6ICVzIgogCi0jOiBzZXR1cC5jOjY3NgorIzogc2V0dXAuYzo2NzcKICMsIGMtZm9ybWF0CiBtc2dpZCAiJyQlcycgdG9vIGJpZyIKIG1zZ3N0ciAiXCIkJXNcIiBmw7ZyIHN0b3IiCiAKLSM6IHNldHVwLmM6NjkwCisjOiBzZXR1cC5jOjY5MQogIywgYy1mb3JtYXQKIG1zZ2lkICJub3QgYSBnaXQgcmVwb3NpdG9yeTogJyVzJyIKIG1zZ3N0ciAiaW50ZSBldHQgZ2l0LWFya2l2OiBcIiVzXCIiCiAKLSM6IHNldHVwLmM6NzE5IHNldHVwLmM6NzIxIHNldHVwLmM6NzUyCisjOiBzZXR1cC5jOjcyMCBzZXR1cC5jOjcyMiBzZXR1cC5jOjc1MwogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgY2hkaXIgdG8gJyVzJyIKIG1zZ3N0ciAia2FuIGludGUgYnl0YSBrYXRhbG9nIChjaGRpcikgdGlsbCBcIiVzXCIiCiAKLSM6IHNldHVwLmM6NzI0IHNldHVwLmM6NzgwIHNldHVwLmM6NzkwIHNldHVwLmM6ODI5IHNldHVwLmM6ODM3CisjOiBzZXR1cC5jOjcyNSBzZXR1cC5jOjc4MSBzZXR1cC5jOjc5MSBzZXR1cC5jOjgzMCBzZXR1cC5jOjgzOAogbXNnaWQgImNhbm5vdCBjb21lIGJhY2sgdG8gY3dkIgogbXNnc3RyICJrYW4gaW50ZSBnw6UgdGlsbGJha2EgdGlsbCBhcmJldHNrYXRhbG9nZW4gKGN3ZCkiCiAKLSM6IHNldHVwLmM6ODUxCisjOiBzZXR1cC5jOjg1MgogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gc3RhdCAnJSpzJXMlcyciCiBtc2dzdHIgIm1pc3NseWNrYWRlcyB0YSBzdGF0dXMgcMOlIFwiJSpzcyVzJXNcIiIKIAotIzogc2V0dXAuYzoxMDgzCisjOiBzZXR1cC5jOjEwOTAKIG1zZ2lkICJVbmFibGUgdG8gcmVhZCBjdXJyZW50IHdvcmtpbmcgZGlyZWN0b3J5IgogbXNnc3RyICJLYW4gaW50ZSBsw6RzYSBha3R1ZWxsIGFyYmV0c2thdGFsb2ciCiAKLSM6IHNldHVwLmM6MTA5MiBzZXR1cC5jOjEwOTgKKyM6IHNldHVwLmM6MTA5OSBzZXR1cC5jOjExMDUKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IGNoYW5nZSB0byAnJXMnIgogbXNnc3RyICJrYW4gaW50ZSBieXRhIHRpbGwgXCIlc1wiIgogCi0jOiBzZXR1cC5jOjExMDMKKyM6IHNldHVwLmM6MTExMAogIywgYy1mb3JtYXQKIG1zZ2lkICJub3QgYSBnaXQgcmVwb3NpdG9yeSAob3IgYW55IG9mIHRoZSBwYXJlbnQgZGlyZWN0b3JpZXMpOiAlcyIKIG1zZ3N0ciAiaW50ZSBldHQgZ2l0LWFya2l2IChlbGxlciBuw6Vnb24gYXYgZsO2csOkbGRyYWthdGFsb2dlcm5hKTogJXMiCiAKLSM6IHNldHVwLmM6MTEwOQorIzogc2V0dXAuYzoxMTE2CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJub3QgYSBnaXQgcmVwb3NpdG9yeSAob3IgYW55IHBhcmVudCB1cCB0byBtb3VudCBwb2ludCAlcylcbiIKQEAgLTY3NTQsNyArNjc3OSw3IEBACiAibW9udGVyaW5nc3B1bmt0ZW4gJXMpXG4iCiAiU3RvcHBhciB2aWQgZmlsc3lzdGVtc2dyw6RucyAoR0lUX0RJU0NPVkVSWV9BQ1JPU1NfRklMRVNZU1RFTSDDpHIgaW50ZSBzYXR0KS4iCiAKLSM6IHNldHVwLmM6MTIyMAorIzogc2V0dXAuYzoxMjI3CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJwcm9ibGVtIHdpdGggY29yZS5zaGFyZWRSZXBvc2l0b3J5IGZpbGVtb2RlIHZhbHVlICgwJS4zbykuXG4iCkBAIC02NzYzLDc2ICs2Nzg4LDc2IEBACiAicHJvYmxlbSBtZWQgZmlsbMOkZ2VzLXbDpHJkZXQgaSBjb3JlLnNoYXJlZFJlcG9zaXRvcnkgKDAlLjNvKS5cbiIKICLDhGdhcmVuIGF2IGZpbGVybmEgbcOlc3RlIGFsbHRpZCBoYSBsw6RzLSBvY2ggc2tyaXZiZWjDtnJpZ2hldC4iCiAKLSM6IHNldHVwLmM6MTI2NAorIzogc2V0dXAuYzoxMjcxCiBtc2dpZCAib3BlbiAvZGV2L251bGwgb3IgZHVwIGZhaWxlZCIKIG1zZ3N0ciAibWlzc2x5Y2thZGVzIMO2cHBuYSAvZGV2L251bGwgZWxsZXIgXCJkdXBcIiIKIAotIzogc2V0dXAuYzoxMjc5CisjOiBzZXR1cC5jOjEyODYKIG1zZ2lkICJmb3JrIGZhaWxlZCIKIG1zZ3N0ciAiXCJmb3JrXCIgbWlzc2x5Y2thZGVzIgogCi0jOiBzZXR1cC5jOjEyODQKKyM6IHNldHVwLmM6MTI5MQogbXNnaWQgInNldHNpZCBmYWlsZWQiCiBtc2dzdHIgIlwic2V0c2lkXCIgbWlzc2x5Y2thZGVzIgogCi0jOiBzaGExLWZpbGUuYzo0NTMKKyM6IHNoYTEtZmlsZS5jOjQ1MgogIywgYy1mb3JtYXQKIG1zZ2lkICJvYmplY3QgZGlyZWN0b3J5ICVzIGRvZXMgbm90IGV4aXN0OyBjaGVjayAuZ2l0L29iamVjdHMvaW5mby9hbHRlcm5hdGVzIgogbXNnc3RyICJvYmpla3RrYXRhbG9nZW4gJXMgZmlubnMgaW50ZTsgc2UgLmdpdC9vYmplY3RzL2luZm8vYWx0ZXJuYXRlcyIKIAotIzogc2hhMS1maWxlLmM6NTA0CisjOiBzaGExLWZpbGUuYzo1MDMKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIG5vcm1hbGl6ZSBhbHRlcm5hdGUgb2JqZWN0IHBhdGg6ICVzIgogbXNnc3RyICJrdW5kZSBpbnRlIG5vcm1hbGlzZXJhIGFsdGVybmF0aXYgb2JqZWt0c8O2a3bDpGc6ICVzIgogCi0jOiBzaGExLWZpbGUuYzo1NzYKKyM6IHNoYTEtZmlsZS5jOjU3NQogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogaWdub3JpbmcgYWx0ZXJuYXRlIG9iamVjdCBzdG9yZXMsIG5lc3RpbmcgdG9vIGRlZXAiCiBtc2dzdHIgIiVzOiBpZ25vcmVyYXIgYWx0ZXJuYXRpdmEgb2JqZWt0bGFncmluZ2FyLCBmw7ZyIGRqdXAgbsOkc3RsaW5nIgogCi0jOiBzaGExLWZpbGUuYzo1ODMKKyM6IHNoYTEtZmlsZS5jOjU4MgogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gbm9ybWFsaXplIG9iamVjdCBkaXJlY3Rvcnk6ICVzIgogbXNnc3RyICJrYW4gaW50ZSBub3JtYWxpc2VyYSBvYmpla3RrYXRhbG9nZW46ICVzIgogCi0jOiBzaGExLWZpbGUuYzo2MjYKKyM6IHNoYTEtZmlsZS5jOjYyNQogbXNnaWQgInVuYWJsZSB0byBmZG9wZW4gYWx0ZXJuYXRlcyBsb2NrZmlsZSIKIG1zZ3N0ciAia2FuIGludGUgdXRmw7ZyYSBcImZkb3BlblwiIHDDpSBsw6VzZmlsIGbDtnIgXCJhbHRlcm5hdGVzXCIiCiAKLSM6IHNoYTEtZmlsZS5jOjY0NAorIzogc2hhMS1maWxlLmM6NjQzCiBtc2dpZCAidW5hYmxlIHRvIHJlYWQgYWx0ZXJuYXRlcyBmaWxlIgogbXNnc3RyICJrYW4gaW50ZSBsw6RzYSBcImFsdGVybmF0ZXNcIi1maWxlbiIKIAotIzogc2hhMS1maWxlLmM6NjUxCisjOiBzaGExLWZpbGUuYzo2NTAKIG1zZ2lkICJ1bmFibGUgdG8gbW92ZSBuZXcgYWx0ZXJuYXRlcyBmaWxlIGludG8gcGxhY2UiCiBtc2dzdHIgImthbiBpbnRlIGZseXR0YSBueSBcImFsdGVybmF0ZXNcIi1maWwgcMOlIHBsYXRzIgogCi0jOiBzaGExLWZpbGUuYzo2ODYKKyM6IHNoYTEtZmlsZS5jOjY4NQogIywgYy1mb3JtYXQKIG1zZ2lkICJwYXRoICclcycgZG9lcyBub3QgZXhpc3QiCiBtc2dzdHIgInPDtmt2w6RnZW4gXCIlc1wiIGZpbm5zIGludGUiCiAKLSM6IHNoYTEtZmlsZS5jOjcxMgorIzogc2hhMS1maWxlLmM6NzExCiAjLCBjLWZvcm1hdAogbXNnaWQgInJlZmVyZW5jZSByZXBvc2l0b3J5ICclcycgYXMgYSBsaW5rZWQgY2hlY2tvdXQgaXMgbm90IHN1cHBvcnRlZCB5ZXQuIgogbXNnc3RyICJyZWZlcmVuc2Fya2l2ZXQgXCIlc1wiIHNvbSBlbiBsw6Rua2FkIHV0Y2hlY2tuaW5nIHN0w7ZkcyBpbnRlIMOkbm51LiIKIAotIzogc2hhMS1maWxlLmM6NzE4CisjOiBzaGExLWZpbGUuYzo3MTcKICMsIGMtZm9ybWF0CiBtc2dpZCAicmVmZXJlbmNlIHJlcG9zaXRvcnkgJyVzJyBpcyBub3QgYSBsb2NhbCByZXBvc2l0b3J5LiIKIG1zZ3N0ciAicmVmZXJlbnNhcmtpdmV0IFwiJXNcIiDDpHIgaW50ZSBldHQgbG9rYWx0IGFya2l2LiIKIAotIzogc2hhMS1maWxlLmM6NzI0CisjOiBzaGExLWZpbGUuYzo3MjMKICMsIGMtZm9ybWF0CiBtc2dpZCAicmVmZXJlbmNlIHJlcG9zaXRvcnkgJyVzJyBpcyBzaGFsbG93IgogbXNnc3RyICJyZWZlcmVuc2Fya2l2ZXQgXCIlc1wiIMOkciBncnVudCIKIAotIzogc2hhMS1maWxlLmM6NzMyCisjOiBzaGExLWZpbGUuYzo3MzEKICMsIGMtZm9ybWF0CiBtc2dpZCAicmVmZXJlbmNlIHJlcG9zaXRvcnkgJyVzJyBpcyBncmFmdGVkIgogbXNnc3RyICJyZWZlcmVuc2Fya2l2ZXQgXCIlc1wiIMOkciB5bXBhdCIKIAotIzogc2hhMS1maWxlLmM6NzkyCisjOiBzaGExLWZpbGUuYzo3OTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBsaW5lIHdoaWxlIHBhcnNpbmcgYWx0ZXJuYXRlIHJlZnM6ICVzIgogbXNnc3RyICJmZWxha3RpZyByYWQgdmlkIHRvbGtuaW5nIGF2IGFsdGVybmF0aXZhIHJlZmVyZW5zZXI6ICVzIgpAQCAtNjg0MiwyMDQgKzY4NjcsMjA0IEBACiBtc2dpZCAiYXR0ZW1wdGluZyB0byBtbWFwICU8UFJJdU1BWD4gb3ZlciBsaW1pdCAlPFBSSXVNQVg+IgogbXNnc3RyICJmw7Zyc8O2ayBhdHQgdXRmw7ZyYSBcIm1tYXBcIiBww6UgJTxQUkl1TUFYPiDDtnZlciBncsOkbnNlbiAlPFBSSXVNQVg+IgogCi0jOiBzaGExLWZpbGUuYzo5NjgKKyM6IHNoYTEtZmlsZS5jOjk2NAogbXNnaWQgIm1tYXAgZmFpbGVkIgogbXNnc3RyICJtbWFwIG1pc3NseWNrYWRlcyIKIAotIzogc2hhMS1maWxlLmM6MTEzMgorIzogc2hhMS1maWxlLmM6MTEyOAogIywgYy1mb3JtYXQKIG1zZ2lkICJvYmplY3QgZmlsZSAlcyBpcyBlbXB0eSIKIG1zZ3N0ciAib2JqZWt0ZmlsZW4gJXMgw6RyIHRvbSIKIAotIzogc2hhMS1maWxlLmM6MTI1NiBzaGExLWZpbGUuYzoyMzk1CisjOiBzaGExLWZpbGUuYzoxMjUyIHNoYTEtZmlsZS5jOjIzOTIKICMsIGMtZm9ybWF0CiBtc2dpZCAiY29ycnVwdCBsb29zZSBvYmplY3QgJyVzJyIKIG1zZ3N0ciAidHJhc2lndCBsw7ZzdCBvYmpla3QgXCIlc1wiIgogCi0jOiBzaGExLWZpbGUuYzoxMjU4IHNoYTEtZmlsZS5jOjIzOTkKKyM6IHNoYTEtZmlsZS5jOjEyNTQgc2hhMS1maWxlLmM6MjM5NgogIywgYy1mb3JtYXQKIG1zZ2lkICJnYXJiYWdlIGF0IGVuZCBvZiBsb29zZSBvYmplY3QgJyVzJyIKIG1zZ3N0ciAic2tyw6RwIGkgc2x1dGV0IGF2IGzDtnN0IG9iamVrdCBcIiVzXCIiCiAKLSM6IHNoYTEtZmlsZS5jOjEzMDAKKyM6IHNoYTEtZmlsZS5jOjEyOTYKIG1zZ2lkICJpbnZhbGlkIG9iamVjdCB0eXBlIgogbXNnc3RyICJmZWxha3RpZyBvYmpla3R0eXAiCiAKLSM6IHNoYTEtZmlsZS5jOjEzODQKKyM6IHNoYTEtZmlsZS5jOjEzODAKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHVucGFjayAlcyBoZWFkZXIgd2l0aCAtLWFsbG93LXVua25vd24tdHlwZSIKIG1zZ3N0ciAia2FuIGludGUgcGFja2EgdXBwICVzLWh1dnVkIG1lZCAtLWFsbG93LXVua25vd24tdHlwZSIKIAotIzogc2hhMS1maWxlLmM6MTM4NworIzogc2hhMS1maWxlLmM6MTM4MwogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gdW5wYWNrICVzIGhlYWRlciIKIG1zZ3N0ciAia2FuIGludGUgcGFja2EgdXBwICVzLWh1dnVkZXQiCiAKLSM6IHNoYTEtZmlsZS5jOjEzOTMKKyM6IHNoYTEtZmlsZS5jOjEzODkKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHBhcnNlICVzIGhlYWRlciB3aXRoIC0tYWxsb3ctdW5rbm93bi10eXBlIgogbXNnc3RyICJrYW4gaW50ZSB0b2xrYSAlcy1odXZ1ZCBtZWQgLS1hbGxvdy11bmtub3duLXR5cGUiCiAKLSM6IHNoYTEtZmlsZS5jOjEzOTYKKyM6IHNoYTEtZmlsZS5jOjEzOTIKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHBhcnNlICVzIGhlYWRlciIKIG1zZ3N0ciAia2FuIGludGUgdG9sa2EgJXMtaHV2dWQiCiAKLSM6IHNoYTEtZmlsZS5jOjE1ODcKKyM6IHNoYTEtZmlsZS5jOjE1ODQKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIHJlYWQgb2JqZWN0ICVzIgogbXNnc3RyICJtaXNzbHlja2FkZXMgbMOkc2Egb2JqZWt0ZXQgJXMiCiAKLSM6IHNoYTEtZmlsZS5jOjE1OTEKKyM6IHNoYTEtZmlsZS5jOjE1ODgKICMsIGMtZm9ybWF0CiBtc2dpZCAicmVwbGFjZW1lbnQgJXMgbm90IGZvdW5kIGZvciAlcyIKIG1zZ3N0ciAiZXJzw6R0dG5pbmdlbiAlcyBoaXR0YWRlcyBpbnRlIGbDtnIgJXMiCiAKLSM6IHNoYTEtZmlsZS5jOjE1OTUKKyM6IHNoYTEtZmlsZS5jOjE1OTIKICMsIGMtZm9ybWF0CiBtc2dpZCAibG9vc2Ugb2JqZWN0ICVzIChzdG9yZWQgaW4gJXMpIGlzIGNvcnJ1cHQiCiBtc2dzdHIgImzDtnN0IG9iamVrdCAlcyAobGFncmF0IGkgJXMpIMOkciB0cmFzaWd0IgogCi0jOiBzaGExLWZpbGUuYzoxNTk5CisjOiBzaGExLWZpbGUuYzoxNTk2CiAjLCBjLWZvcm1hdAogbXNnaWQgInBhY2tlZCBvYmplY3QgJXMgKHN0b3JlZCBpbiAlcykgaXMgY29ycnVwdCIKIG1zZ3N0ciAicGFja2F0IG9iamVrdCAlcyAobGFncmF0IGkgJXMpIMOkciB0cmFzaWd0IgogCi0jOiBzaGExLWZpbGUuYzoxNzAyCisjOiBzaGExLWZpbGUuYzoxNjk5CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byB3cml0ZSBmaWxlICVzIgogbXNnc3RyICJrdW5kZSBpbnRlIHNrcml2YSBmaWxlbiAlcyIKIAotIzogc2hhMS1maWxlLmM6MTcwOQorIzogc2hhMS1maWxlLmM6MTcwNgogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gc2V0IHBlcm1pc3Npb24gdG8gJyVzJyIKIG1zZ3N0ciAia2FuIGludGUgc8OkdHRhIGJlaMO2cmlnaGV0ZW4gdGlsbCBcIiVzXCIiCiAKLSM6IHNoYTEtZmlsZS5jOjE3MTYKKyM6IHNoYTEtZmlsZS5jOjE3MTMKIG1zZ2lkICJmaWxlIHdyaXRlIGVycm9yIgogbXNnc3RyICJmZWwgdmlkIHNrcml2bmluZyBhdiBmaWwiCiAKLSM6IHNoYTEtZmlsZS5jOjE3MzUKKyM6IHNoYTEtZmlsZS5jOjE3MzIKIG1zZ2lkICJlcnJvciB3aGVuIGNsb3NpbmcgbG9vc2Ugb2JqZWN0IGZpbGUiCiBtc2dzdHIgImZlbCB2aWQgc3TDpG5nbmluZyBhdiBmaWwgZsO2ciBsw7ZzdCBvYmpla3QiCiAKLSM6IHNoYTEtZmlsZS5jOjE4MDAKKyM6IHNoYTEtZmlsZS5jOjE3OTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW5zdWZmaWNpZW50IHBlcm1pc3Npb24gZm9yIGFkZGluZyBhbiBvYmplY3QgdG8gcmVwb3NpdG9yeSBkYXRhYmFzZSAlcyIKIG1zZ3N0ciAiIgogIm90aWxscsOkY2tsaWcgYmVow7ZyaWdoZXQgZsO2ciBhdHQgbMOkZ2dhIHRpbGwgb2JqZWt0IHRpbGwgYXJraXZkYXRhYmFzZW4gJXMiCiAKLSM6IHNoYTEtZmlsZS5jOjE4MDIKKyM6IHNoYTEtZmlsZS5jOjE3OTkKIG1zZ2lkICJ1bmFibGUgdG8gY3JlYXRlIHRlbXBvcmFyeSBmaWxlIgogbXNnc3RyICJrYW4gaW50ZSBza2FwYSB0ZW1wb3LDpHIgZmlsIgogCi0jOiBzaGExLWZpbGUuYzoxODI2CisjOiBzaGExLWZpbGUuYzoxODIzCiBtc2dpZCAidW5hYmxlIHRvIHdyaXRlIGxvb3NlIG9iamVjdCBmaWxlIgogbXNnc3RyICJrdW5kZSBpbnRlIHNrcml2YSBmaWwgZsO2ciBsw7ZzdCBvYmpla3QiCiAKLSM6IHNoYTEtZmlsZS5jOjE4MzIKKyM6IHNoYTEtZmlsZS5jOjE4MjkKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGRlZmxhdGUgbmV3IG9iamVjdCAlcyAoJWQpIgogbXNnc3RyICJrYW4gaW50ZSB1dGbDtnJhIFwiZGVmbGF0ZVwiIHDDpSBueXR0IG9iamVrdCAlcyAoJWQpIgogCi0jOiBzaGExLWZpbGUuYzoxODM2CisjOiBzaGExLWZpbGUuYzoxODMzCiAjLCBjLWZvcm1hdAogbXNnaWQgImRlZmxhdGVFbmQgb24gb2JqZWN0ICVzIGZhaWxlZCAoJWQpIgogbXNnc3RyICJcImRlZmxhdGVlbmRcIiBww6Ugb2JqZWt0ZXQgJXMgbWlzc2x5Y2thZGVzICglZCkiCiAKLSM6IHNoYTEtZmlsZS5jOjE4NDAKKyM6IHNoYTEtZmlsZS5jOjE4MzcKICMsIGMtZm9ybWF0CiBtc2dpZCAiY29uZnVzZWQgYnkgdW5zdGFibGUgb2JqZWN0IHNvdXJjZSBkYXRhIGZvciAlcyIKIG1zZ3N0ciAiZsO2cnZpcnJhZCBhdiBpbnN0YWJpbCBvYmpla3Rrw6RsbGRhdGEgZsO2ciAlcyIKIAotIzogc2hhMS1maWxlLmM6MTg1MCBidWlsdGluL3BhY2stb2JqZWN0cy5jOjkyMAorIzogc2hhMS1maWxlLmM6MTg0NyBidWlsdGluL3BhY2stb2JqZWN0cy5jOjkyNQogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdXRpbWUoKSBvbiAlcyIKIG1zZ3N0ciAiXCJ1dGltZSgpXCIgbWlzc2x5Y2thZGVzIHDDpSAlcyIKIAotIzogc2hhMS1maWxlLmM6MTkyNQorIzogc2hhMS1maWxlLmM6MTkyMgogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgcmVhZCBvYmplY3QgZm9yICVzIgogbXNnc3RyICJrYW4gaW50ZSBsw6RzYSBvYmpla3QgZsO2ciAlcyIKIAotIzogc2hhMS1maWxlLmM6MTk2NQorIzogc2hhMS1maWxlLmM6MTk2MgogbXNnaWQgImNvcnJ1cHQgY29tbWl0IgogbXNnc3RyICJ0cmFzaWsgaW5jaGVja25pbmciCiAKLSM6IHNoYTEtZmlsZS5jOjE5NzMKKyM6IHNoYTEtZmlsZS5jOjE5NzAKIG1zZ2lkICJjb3JydXB0IHRhZyIKIG1zZ3N0ciAidHJhc2lnIHRhZ2ciCiAKLSM6IHNoYTEtZmlsZS5jOjIwNzIKKyM6IHNoYTEtZmlsZS5jOjIwNjkKICMsIGMtZm9ybWF0CiBtc2dpZCAicmVhZCBlcnJvciB3aGlsZSBpbmRleGluZyAlcyIKIG1zZ3N0ciAibMOkc2ZlbCB2aWQgaW5kZXhlcmluZyBhdiAlcyIKIAotIzogc2hhMS1maWxlLmM6MjA3NQorIzogc2hhMS1maWxlLmM6MjA3MgogIywgYy1mb3JtYXQKIG1zZ2lkICJzaG9ydCByZWFkIHdoaWxlIGluZGV4aW5nICVzIgogbXNnc3RyICJmw7ZyIGxpdGUgbMOkc3RlcyB2aWQgaW5kZXhlcmluZyBhdiAlcyIKIAotIzogc2hhMS1maWxlLmM6MjE0OCBzaGExLWZpbGUuYzoyMTU3CisjOiBzaGExLWZpbGUuYzoyMTQ1IHNoYTEtZmlsZS5jOjIxNTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXM6IGZhaWxlZCB0byBpbnNlcnQgaW50byBkYXRhYmFzZSIKIG1zZ3N0ciAiJXM6IG1pc3NseWNrYWRlcyBsw6RnZ2EgaW4gaSBkYXRhYmFzZW4iCiAKLSM6IHNoYTEtZmlsZS5jOjIxNjMKKyM6IHNoYTEtZmlsZS5jOjIxNjAKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXM6IHVuc3VwcG9ydGVkIGZpbGUgdHlwZSIKIG1zZ3N0ciAiJXM6IGZpbHR5cGVuIHN0w7ZkcyBlaiIKIAotIzogc2hhMS1maWxlLmM6MjE4NworIzogc2hhMS1maWxlLmM6MjE4NAogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyBpcyBub3QgYSB2YWxpZCBvYmplY3QiCiBtc2dzdHIgIiVzIMOkciBpbnRlIGV0dCBnaWx0aWd0IG9iamVrdCIKIAotIzogc2hhMS1maWxlLmM6MjE4OQorIzogc2hhMS1maWxlLmM6MjE4NgogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyBpcyBub3QgYSB2YWxpZCAnJXMnIG9iamVjdCIKIG1zZ3N0ciAiJXMgw6RyIGludGUgZXR0IGdpbHRpZ3QgXCIlc1wiLW9iamVrdCIKIAotIzogc2hhMS1maWxlLmM6MjIxNiBidWlsdGluL2luZGV4LXBhY2suYzoxNTUKKyM6IHNoYTEtZmlsZS5jOjIyMTMgYnVpbHRpbi9pbmRleC1wYWNrLmM6MTU1CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBvcGVuICVzIgogbXNnc3RyICJrYW4gaW50ZSDDtnBwbmEgJXMiCiAKLSM6IHNoYTEtZmlsZS5jOjI0MDYgc2hhMS1maWxlLmM6MjQ1OAorIzogc2hhMS1maWxlLmM6MjQwMyBzaGExLWZpbGUuYzoyNDU1CiAjLCBjLWZvcm1hdAogbXNnaWQgImhhc2ggbWlzbWF0Y2ggZm9yICVzIChleHBlY3RlZCAlcykiCiBtc2dzdHIgImhhc2ggc3TDpG1tZXIgaW50ZSBmw7ZyICVzIChmw7ZydsOkbnRhZGUgJXMpIgogCi0jOiBzaGExLWZpbGUuYzoyNDMwCisjOiBzaGExLWZpbGUuYzoyNDI3CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBtbWFwICVzIgogbXNnc3RyICJrYW4gaW50ZSB1dGbDtnJhIFwibW1hcFwiIGbDtnIgJXMiCiAKLSM6IHNoYTEtZmlsZS5jOjI0MzUKKyM6IHNoYTEtZmlsZS5jOjI0MzIKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHVucGFjayBoZWFkZXIgb2YgJXMiCiBtc2dzdHIgImthbiBpbnRlIHBhY2thIHVwcCBodXZ1ZCBmw7ZyICVzIgogCi0jOiBzaGExLWZpbGUuYzoyNDQxCisjOiBzaGExLWZpbGUuYzoyNDM4CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBwYXJzZSBoZWFkZXIgb2YgJXMiCiBtc2dzdHIgImthbiBpbnRlIHRvbGthIGh1dnVkIGbDtnIgJXMiCiAKLSM6IHNoYTEtZmlsZS5jOjI0NTIKKyM6IHNoYTEtZmlsZS5jOjI0NDkKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHVucGFjayBjb250ZW50cyBvZiAlcyIKIG1zZ3N0ciAia2FuIGludGUgdG9sa2EgaW5uZWjDpWxsIGkgJXMiCiAKLSM6IHNoYTEtbmFtZS5jOjQ5MAorIzogc2hhMS1uYW1lLmM6NDg3CiAjLCBjLWZvcm1hdAogbXNnaWQgInNob3J0IFNIQTEgJXMgaXMgYW1iaWd1b3VzIgogbXNnc3RyICJrb3J0IFNIQTEgJXMgw6RyIHR2ZXR5ZGlnIgogCi0jOiBzaGExLW5hbWUuYzo1MDEKKyM6IHNoYTEtbmFtZS5jOjQ5OAogbXNnaWQgIlRoZSBjYW5kaWRhdGVzIGFyZToiCiBtc2dzdHIgIkthbmRpZGF0ZXJuYSDDpHI6IgogCi0jOiBzaGExLW5hbWUuYzo4MDAKKyM6IHNoYTEtbmFtZS5jOjc5NwogbXNnaWQgIiIKICJHaXQgbm9ybWFsbHkgbmV2ZXIgY3JlYXRlcyBhIHJlZiB0aGF0IGVuZHMgd2l0aCA0MCBoZXggY2hhcmFjdGVyc1xuIgogImJlY2F1c2UgaXQgd2lsbCBiZSBpZ25vcmVkIHdoZW4geW91IGp1c3Qgc3BlY2lmeSA0MC1oZXguIFRoZXNlIHJlZnNcbiIKQEAgLTcwNjIsNDMgKzcwODcsNDMgQEAKICJnZW5vbSBhdHQga8O2cmEgXCJnaXQgY29uZmlnIGFkdmljZS5vYmplY3ROYW1lV2FybmluZyBmYWxzZVwiIgogCiAjLiBUUkFOU0xBVE9SUzogSUVDIDgwMDAwLTEzOjIwMDggZ2liaWJ5dGUKLSM6IHN0cmJ1Zi5jOjgyMQorIzogc3RyYnVmLmM6ODIyCiAjLCBjLWZvcm1hdAogbXNnaWQgIiV1LiUyLjJ1IEdpQiIKIG1zZ3N0ciAiJXUsJTIuMnUgR2lCIgogCiAjLiBUUkFOU0xBVE9SUzogSUVDIDgwMDAwLTEzOjIwMDggZ2liaWJ5dGUvc2Vjb25kCi0jOiBzdHJidWYuYzo4MjMKKyM6IHN0cmJ1Zi5jOjgyNAogIywgYy1mb3JtYXQKIG1zZ2lkICIldS4lMi4ydSBHaUIvcyIKIG1zZ3N0ciAiJXUsJTIuMnUgR2lCL3MiCiAKICMuIFRSQU5TTEFUT1JTOiBJRUMgODAwMDAtMTM6MjAwOCBtZWJpYnl0ZQotIzogc3RyYnVmLmM6ODMxCisjOiBzdHJidWYuYzo4MzIKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXUuJTIuMnUgTWlCIgogbXNnc3RyICIldSwlMi4ydSBNaUIiCiAKICMuIFRSQU5TTEFUT1JTOiBJRUMgODAwMDAtMTM6MjAwOCBtZWJpYnl0ZS9zZWNvbmQKLSM6IHN0cmJ1Zi5jOjgzMworIzogc3RyYnVmLmM6ODM0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiV1LiUyLjJ1IE1pQi9zIgogbXNnc3RyICIldSwlMi4ydSBNaUIvcyIKIAogIy4gVFJBTlNMQVRPUlM6IElFQyA4MDAwMC0xMzoyMDA4IGtpYmlieXRlCi0jOiBzdHJidWYuYzo4NDAKKyM6IHN0cmJ1Zi5jOjg0MQogIywgYy1mb3JtYXQKIG1zZ2lkICIldS4lMi4ydSBLaUIiCiBtc2dzdHIgIiV1LCUyLjJ1IEtpQiIKIAogIy4gVFJBTlNMQVRPUlM6IElFQyA4MDAwMC0xMzoyMDA4IGtpYmlieXRlL3NlY29uZAotIzogc3RyYnVmLmM6ODQyCisjOiBzdHJidWYuYzo4NDMKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXUuJTIuMnUgS2lCL3MiCiBtc2dzdHIgIiV1LCUyLjJ1IEtpQi9zIgogCiAjLiBUUkFOU0xBVE9SUzogSUVDIDgwMDAwLTEzOjIwMDggYnl0ZQotIzogc3RyYnVmLmM6ODQ4CisjOiBzdHJidWYuYzo4NDkKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXUgYnl0ZSIKIG1zZ2lkX3BsdXJhbCAiJXUgYnl0ZXMiCkBAIC03MTA2LDcgKzcxMzEsNyBAQAogbXNnc3RyWzFdICIldSBieXRlcyIKIAogIy4gVFJBTlNMQVRPUlM6IElFQyA4MDAwMC0xMzoyMDA4IGJ5dGUvc2Vjb25kCi0jOiBzdHJidWYuYzo4NTAKKyM6IHN0cmJ1Zi5jOjg1MQogIywgYy1mb3JtYXQKIG1zZ2lkICIldSBieXRlL3MiCiBtc2dpZF9wbHVyYWwgIiV1IGJ5dGVzL3MiCkBAIC03MjI1LDI2ICs3MjUwLDI2IEBACiBtc2dpZCAibHMtdHJlZSByZXR1cm5lZCB1bmV4cGVjdGVkIHJldHVybiBjb2RlICVkIgogbXNnc3RyICJscy10cmVlIHJldHVybmVyYWRlIGVuIG92w6RudGFkIHJldHVya29kICVkIgogCi0jOiBzdWJtb2R1bGUtY29uZmlnLmM6MjMyCisjOiBzdWJtb2R1bGUtY29uZmlnLmM6MjM2CiAjLCBjLWZvcm1hdAogbXNnaWQgImlnbm9yaW5nIHN1c3BpY2lvdXMgc3VibW9kdWxlIG5hbWU6ICVzIgogbXNnc3RyICJpZ25vcmVyYXIgbWlzc3TDpG5rdCB1bmRlcm1vZHVsbmFtbjogJXMiCiAKLSM6IHN1Ym1vZHVsZS1jb25maWcuYzoyOTkKKyM6IHN1Ym1vZHVsZS1jb25maWcuYzozMDMKIG1zZ2lkICJuZWdhdGl2ZSB2YWx1ZXMgbm90IGFsbG93ZWQgZm9yIHN1Ym1vZHVsZS5mZXRjaGpvYnMiCiBtc2dzdHIgIm5lZ2F0aXZhIHbDpHJkZW4gw6RyIGludGUgdGlsbMOldG5hIGbDtnIgc3VibW9kdWxlLmZldGNoam9icyIKIAotIzogc3VibW9kdWxlLWNvbmZpZy5jOjM5NworIzogc3VibW9kdWxlLWNvbmZpZy5jOjQwMQogIywgYy1mb3JtYXQKIG1zZ2lkICJpZ25vcmluZyAnJXMnIHdoaWNoIG1heSBiZSBpbnRlcnByZXRlZCBhcyBhIGNvbW1hbmQtbGluZSBvcHRpb246ICVzIgogbXNnc3RyICJpZ25vcmVyYXIgXCIlc1wiIHNvbSBrYW4gdG9sa2FzIHNvbSBlbiBrb21tYW5kb3JhZHNmbGFnZ2E6ICVzIgogCi0jOiBzdWJtb2R1bGUtY29uZmlnLmM6NDg2CisjOiBzdWJtb2R1bGUtY29uZmlnLmM6NDkwCiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgdmFsdWUgZm9yICVzIgogbXNnc3RyICJvZ2lsdGlndCB2w6RyZGUgZsO2ciAlcyIKIAotIzogc3VibW9kdWxlLWNvbmZpZy5jOjc1NQorIzogc3VibW9kdWxlLWNvbmZpZy5jOjc2MQogIywgYy1mb3JtYXQKIG1zZ2lkICJDb3VsZCBub3QgdXBkYXRlIC5naXRtb2R1bGVzIGVudHJ5ICVzIgogbXNnc3RyICJLdW5kZSBpbnRlIHVwcGRhdGVyYSAuZ2l0bW9kdWxlcy1wb3N0ZW4gJXMiCkBAIC03Mjc5LDcgKzczMDQsNyBAQAogbXNnaWQgImNvdWxkIG5vdCByZWFkIGZyb20gc3RkaW4iCiBtc2dzdHIgImt1bmRlIGludGUgbMOkc2EgZnLDpW4gc3RhbmRhcmQgaW4iCiAKLSM6IHRyYWlsZXIuYzoxMDExIHdyYXBwZXIuYzo3MDEKKyM6IHRyYWlsZXIuYzoxMDExIHdyYXBwZXIuYzo2NjUKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHN0YXQgJXMiCiBtc2dzdHIgImt1bmRlIGludGUgdGEgc3RhdHVzIHDDpSAlcyIKQEAgLTczMDgsNDcgKzczMzMsNDcgQEAKIG1zZ2lkICJXb3VsZCBzZXQgdXBzdHJlYW0gb2YgJyVzJyB0byAnJXMnIG9mICclcydcbiIKIG1zZ3N0ciAiU2t1bGxlIHPDpHR0YSB1cHBzdHLDtm1zIGbDtnIgXCIlc1wiIHRpbGwgXCIlc1wiIGZyw6VuIFwiJXNcIlxuIgogCi0jOiB0cmFuc3BvcnQuYzoxNDIKKyM6IHRyYW5zcG9ydC5jOjE0NQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcmVhZCBidW5kbGUgJyVzJyIKIG1zZ3N0ciAia3VuZGUgaW50ZSBsw6RzYSBwYWtldGV0IChidW5kbGVuKSBcIiVzXCIiCiAKLSM6IHRyYW5zcG9ydC5jOjIwOAorIzogdHJhbnNwb3J0LmM6MjE0CiAjLCBjLWZvcm1hdAogbXNnaWQgInRyYW5zcG9ydDogaW52YWxpZCBkZXB0aCBvcHRpb24gJyVzJyIKIG1zZ3N0ciAidHJhbnNwb3J0OiBvZ2lsdGlnIGZsYWdnYSBmw7ZyIGRlcHRoOiBcIiVzXCIiCiAKLSM6IHRyYW5zcG9ydC5jOjI1OQorIzogdHJhbnNwb3J0LmM6MjY2CiBtc2dpZCAic2VlIHByb3RvY29sLnZlcnNpb24gaW4gJ2dpdCBoZWxwIGNvbmZpZycgZm9yIG1vcmUgZGV0YWlscyIKIG1zZ3N0ciAic2UgcHJvdG9jb2wudmVyc2lvbiBpIFwiZ2l0IGhlbHAgY29uZmlnXCIgZsO2ciBtZXIgaW5mb3JtYXRpb24iCiAKLSM6IHRyYW5zcG9ydC5jOjI2MAorIzogdHJhbnNwb3J0LmM6MjY3CiBtc2dpZCAic2VydmVyIG9wdGlvbnMgcmVxdWlyZSBwcm90b2NvbCB2ZXJzaW9uIDIgb3IgbGF0ZXIiCiBtc2dzdHIgInNlcnZlcmZsYWdnb3Iga3LDpHZlciBwcm90b2tvbGx2ZXJzaW9uIDIgZWxsZXIgc2VuYXJlIgogCi0jOiB0cmFuc3BvcnQuYzo2MjUKKyM6IHRyYW5zcG9ydC5jOjYzMgogbXNnaWQgImNvdWxkIG5vdCBwYXJzZSB0cmFuc3BvcnQuY29sb3IuKiBjb25maWciCiBtc2dzdHIgImt1bmRlIGludGUgdG9sa2EgaW5zdMOkbGxuaW5nZW4gZsO2ciB0cmFuc3BvcnQuY29sb3IuKiIKIAotIzogdHJhbnNwb3J0LmM6Njk4CisjOiB0cmFuc3BvcnQuYzo3MDUKIG1zZ2lkICJzdXBwb3J0IGZvciBwcm90b2NvbCB2MiBub3QgaW1wbGVtZW50ZWQgeWV0IgogbXNnc3RyICJzdMO2ZCBmw7ZyIHByb3Rva29sbCB2MiDDpG5udSBlaiBpbXBsZW1lbnRlcmF0IgogCi0jOiB0cmFuc3BvcnQuYzo4MjUKKyM6IHRyYW5zcG9ydC5jOjgzMQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmtub3duIHZhbHVlIGZvciBjb25maWcgJyVzJzogJXMiCiBtc2dzdHIgIm9rw6RudCB2w6RyZGUgZsO2ciBpbnN0w6RsbG5pbmdlbiBcIiVzXCI6ICVzIgogCi0jOiB0cmFuc3BvcnQuYzo4OTEKKyM6IHRyYW5zcG9ydC5jOjg5NwogIywgYy1mb3JtYXQKIG1zZ2lkICJ0cmFuc3BvcnQgJyVzJyBub3QgYWxsb3dlZCIKIG1zZ3N0ciAidHJhbnNwb3J0ZW4gXCIlc1wiIHRpbGzDpXRzIGludGUiCiAKLSM6IHRyYW5zcG9ydC5jOjk0NQorIzogdHJhbnNwb3J0LmM6OTQ5CiBtc2dpZCAiZ2l0LW92ZXItcnN5bmMgaXMgbm8gbG9uZ2VyIHN1cHBvcnRlZCIKIG1zZ3N0ciAiZ2l0LW92ZXItcnN5bmMgc3TDtmRzIGludGUgbMOkbmdyZSIKIAotIzogdHJhbnNwb3J0LmM6MTA0MAorIzogdHJhbnNwb3J0LmM6MTA0NAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiVGhlIGZvbGxvd2luZyBzdWJtb2R1bGUgcGF0aHMgY29udGFpbiBjaGFuZ2VzIHRoYXQgY2FuXG4iCkBAIC03MzU3LDcgKzczODIsNyBAQAogIkbDtmxqYW5kZSB1bmRlcm1vZHVsc8O2a3bDpGdhciBpbm5laMOlbGxlciDDpG5kcmluZ2FyIHNvbVxuIgogImludGUga2FuIGhpdHRhcyBhdiBmasOkcnJhcm5hOlxuIgogCi0jOiB0cmFuc3BvcnQuYzoxMDQ0CisjOiB0cmFuc3BvcnQuYzoxMDQ4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJcbiIKQEAgLTczODQsMzIgKzc0MDksMzIgQEAKICJmw7ZyIGF0dCBzw6RuZGEgZGVtIHRpbGwgZmrDpHJyZW4uXG4iCiAiXG4iCiAKLSM6IHRyYW5zcG9ydC5jOjEwNTIKKyM6IHRyYW5zcG9ydC5jOjEwNTYKIG1zZ2lkICJBYm9ydGluZy4iCiBtc2dzdHIgIkF2YnJ5dGVyLiIKIAotIzogdHJhbnNwb3J0LmM6MTE5MworIzogdHJhbnNwb3J0LmM6MTIwMQogbXNnaWQgImZhaWxlZCB0byBwdXNoIGFsbCBuZWVkZWQgc3VibW9kdWxlcyIKIG1zZ3N0ciAia3VuZGUgaW50ZSBzw6RuZGEgYWxsYSBuw7ZkdsOkbmRpZ2EgdW5kZXJtb2R1bGVyIgogCi0jOiB0cmFuc3BvcnQuYzoxMzQwIHRyYW5zcG9ydC1oZWxwZXIuYzo2NDUKKyM6IHRyYW5zcG9ydC5jOjEzNDUgdHJhbnNwb3J0LWhlbHBlci5jOjY1NQogbXNnaWQgIm9wZXJhdGlvbiBub3Qgc3VwcG9ydGVkIGJ5IHByb3RvY29sIgogbXNnc3RyICJmdW5rdGlvbmVuIHN0w7ZkcyBpbnRlIGF2IHByb3Rva29sbGV0IgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6NTEgdHJhbnNwb3J0LWhlbHBlci5jOjgwCisjOiB0cmFuc3BvcnQtaGVscGVyLmM6NjEgdHJhbnNwb3J0LWhlbHBlci5jOjkwCiBtc2dpZCAiZnVsbCB3cml0ZSB0byByZW1vdGUgaGVscGVyIGZhaWxlZCIKIG1zZ3N0ciAia29tcGxldHQgc2tyaXZuaW5nIHRpbGwgZmrDpHJyaGrDpGxwYXJlIG1pc3NseWNrYWRlcyIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjEzNAorIzogdHJhbnNwb3J0LWhlbHBlci5jOjE0NAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gZmluZCByZW1vdGUgaGVscGVyIGZvciAnJXMnIgogbXNnc3RyICJrYW4gaW50ZSBoaXR0YSBmasOkcnJoasOkbHBhcmUgZsO2ciBcIiVzXCIiCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxNTAgdHJhbnNwb3J0LWhlbHBlci5jOjU1OQorIzogdHJhbnNwb3J0LWhlbHBlci5jOjE2MCB0cmFuc3BvcnQtaGVscGVyLmM6NTY5CiBtc2dpZCAiY2FuJ3QgZHVwIGhlbHBlciBvdXRwdXQgZmQiCiBtc2dzdHIgImt1bmRlIGludGUgZHVwbGljZXJhIHV0ZGF0YS1maWxoYW5kdGFnIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6MjAxCisjOiB0cmFuc3BvcnQtaGVscGVyLmM6MjExCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJ1bmtub3duIG1hbmRhdG9yeSBjYXBhYmlsaXR5ICVzOyB0aGlzIHJlbW90ZSBoZWxwZXIgcHJvYmFibHkgbmVlZHMgbmV3ZXIgIgpAQCAtNzQxOCwxMDEgKzc0NDMsMTA2IEBACiAib2vDpG5kIGtyw6R2ZCBmw7ZybcOlZ2EgKGNhcGFiaWxpdHkpICVzOyBmasOkcnJoasOkbHBhcmVuIGJlaMO2dmVyIGFudGFnbGlnZW4gZW4gIgogIm55YXJlIHZlcnNpb24gYXYgR2l0IgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6MjA3CisjOiB0cmFuc3BvcnQtaGVscGVyLmM6MjE3CiBtc2dpZCAidGhpcyByZW1vdGUgaGVscGVyIHNob3VsZCBpbXBsZW1lbnQgcmVmc3BlYyBjYXBhYmlsaXR5IgogbXNnc3RyICIiCiAiZmrDpHJyaGrDpGxwYXJlbiBiZWjDtnZlciBpbXBsZW1lbnRlcmEgZsO2cm3DpWdhIGbDtnIgcmVmZXJlbnNzcGVjaWZpa2F0aW9uZXIgIgogIihyZWZzcGVjKSIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjI3NCB0cmFuc3BvcnQtaGVscGVyLmM6NDE0CisjOiB0cmFuc3BvcnQtaGVscGVyLmM6Mjg0IHRyYW5zcG9ydC1oZWxwZXIuYzo0MjQKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgdW5leHBlY3RlZGx5IHNhaWQ6ICclcyciCiBtc2dzdHIgIiVzIHNhZGUgb3bDpG50YXQ6IFwiJXNcIiIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjQwMworIzogdHJhbnNwb3J0LWhlbHBlci5jOjQxMwogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyBhbHNvIGxvY2tlZCAlcyIKIG1zZ3N0ciAiJXMgbMOlc3RlIG9ja3PDpSAlcyIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjQ4MQorIzogdHJhbnNwb3J0LWhlbHBlci5jOjQ5MQogbXNnaWQgImNvdWxkbid0IHJ1biBmYXN0LWltcG9ydCIKIG1zZ3N0ciAia3VuZGUgaW50ZSBrw7ZyYSBmYXN0LWltcG9ydCIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjUwNAorIzogdHJhbnNwb3J0LWhlbHBlci5jOjUxNAogbXNnaWQgImVycm9yIHdoaWxlIHJ1bm5pbmcgZmFzdC1pbXBvcnQiCiBtc2dzdHIgImZlbCBuw6RyIGZhc3QtaW1wb3J0IGvDtnJkZXMiCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzo1MzMgdHJhbnNwb3J0LWhlbHBlci5jOjExMDUKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzo1NDMgdHJhbnNwb3J0LWhlbHBlci5jOjExMzIKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHJlYWQgcmVmICVzIgogbXNnc3RyICJrdW5kZSBpbnRlIGzDpHNhIHJlZmVyZW5zZW4gJXMiCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzo1NzgKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzo1ODgKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5rbm93biByZXNwb25zZSB0byBjb25uZWN0OiAlcyIKIG1zZ3N0ciAib2vDpG50IHN2YXIgcMOlIGFuc2x1bnRuaW5nOiAlcyIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjYwMAorIzogdHJhbnNwb3J0LWhlbHBlci5jOjYxMAogbXNnaWQgInNldHRpbmcgcmVtb3RlIHNlcnZpY2UgcGF0aCBub3Qgc3VwcG9ydGVkIGJ5IHByb3RvY29sIgogbXNnc3RyICJwcm90a29sbGV0IHN0w7ZkZXIgaW50ZSBhdHQgc8OkdHRhIHPDtmt2w6RnIHRpbGwgZmrDpHJydGrDpG5zdCIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjYwMgorIzogdHJhbnNwb3J0LWhlbHBlci5jOjYxMgogbXNnaWQgImludmFsaWQgcmVtb3RlIHNlcnZpY2UgcGF0aCIKIG1zZ3N0ciAiZmVsYWt0aWcgc8O2a3bDpGcgdGlsbCBmasOkcnJ0asOkbnN0IgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6NjQ4CisjOiB0cmFuc3BvcnQtaGVscGVyLmM6NjU4CiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbid0IGNvbm5lY3QgdG8gc3Vic2VydmljZSAlcyIKIG1zZ3N0ciAia2FuIGludGUgYW5zbHV0YSB0aWxsIHVuZGVydGrDpG5zdGVuICVzIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6NzIwCisjOiB0cmFuc3BvcnQtaGVscGVyLmM6NzM0CiAjLCBjLWZvcm1hdAogbXNnaWQgImV4cGVjdGVkIG9rL2Vycm9yLCBoZWxwZXIgc2FpZCAnJXMnIgogbXNnc3RyICJmw7ZydsOkbnRhZGUgb2svZXJyb3IsIGhqw6RscHByb2dyYW1tZXQgc3ZhcmFkZSBcIiVzXCIiCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzo3NzMKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzo3ODcKICMsIGMtZm9ybWF0CiBtc2dpZCAiaGVscGVyIHJlcG9ydGVkIHVuZXhwZWN0ZWQgc3RhdHVzIG9mICVzIgogbXNnc3RyICJoasOkbHBhcmVuIHJldHVybmVyYWRlIG92w6RudGFkIHN0YXR1cyAlcyIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjgzNAorIzogdHJhbnNwb3J0LWhlbHBlci5jOjg0OAogIywgYy1mb3JtYXQKIG1zZ2lkICJoZWxwZXIgJXMgZG9lcyBub3Qgc3VwcG9ydCBkcnktcnVuIgogbXNnc3RyICJoasOkbHBhcmVuICVzIHN0w7ZkZXIgaW50ZSBkcnktcnVuIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6ODM3CisjOiB0cmFuc3BvcnQtaGVscGVyLmM6ODUxCiAjLCBjLWZvcm1hdAogbXNnaWQgImhlbHBlciAlcyBkb2VzIG5vdCBzdXBwb3J0IC0tc2lnbmVkIgogbXNnc3RyICJoasOkbHBhcmVuICVzIHN0w7ZkZXIgaW50ZSAtLXNpZ25lZCIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjg0MAorIzogdHJhbnNwb3J0LWhlbHBlci5jOjg1NAogIywgYy1mb3JtYXQKIG1zZ2lkICJoZWxwZXIgJXMgZG9lcyBub3Qgc3VwcG9ydCAtLXNpZ25lZD1pZi1hc2tlZCIKIG1zZ3N0ciAiaGrDpGxwYXJlbiAlcyBzdMO2ZGVyIGludGUgLS1zaWduZWQ9aWYtYXNrZWQiCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzo4NDcKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzo4NTkKKyMsIGMtZm9ybWF0Cittc2dpZCAiaGVscGVyICVzIGRvZXMgbm90IHN1cHBvcnQgLS1hdG9taWMiCittc2dzdHIgImhqw6RscGFyZW4gJXMgc3TDtmRlciBpbnRlIC0tYXRvbWljIgorCisjOiB0cmFuc3BvcnQtaGVscGVyLmM6ODY1CiAjLCBjLWZvcm1hdAogbXNnaWQgImhlbHBlciAlcyBkb2VzIG5vdCBzdXBwb3J0ICdwdXNoLW9wdGlvbiciCiBtc2dzdHIgImhqw6RscGFyZW4gJXMgc3TDtmRlciBpbnRlIFwicHVzaC1vcHRpb25cIiIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjk0NQorIzogdHJhbnNwb3J0LWhlbHBlci5jOjk2MwogbXNnaWQgInJlbW90ZS1oZWxwZXIgZG9lc24ndCBzdXBwb3J0IHB1c2g7IHJlZnNwZWMgbmVlZGVkIgogbXNnc3RyICJmasOkcnJoasOkbHBhcmVuIHN0w7ZkZXIgaW50ZSBwdXNoOyByZWZlcmVuc3NwZWNpZmlrYXRpb24ga3LDpHZzIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6OTUwCisjOiB0cmFuc3BvcnQtaGVscGVyLmM6OTY4CiAjLCBjLWZvcm1hdAogbXNnaWQgImhlbHBlciAlcyBkb2VzIG5vdCBzdXBwb3J0ICdmb3JjZSciCiBtc2dzdHIgImhqw6RscGFyZW4gJXMgc3TDtmRlciBpbnRlIFwiZm9yY2VcIiIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjk5NworIzogdHJhbnNwb3J0LWhlbHBlci5jOjEwMTUKIG1zZ2lkICJjb3VsZG4ndCBydW4gZmFzdC1leHBvcnQiCiBtc2dzdHIgImt1bmRlIGludGUga8O2cmEgZmFzdC1leHBvcnQiCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxMDAyCisjOiB0cmFuc3BvcnQtaGVscGVyLmM6MTAyMAogbXNnaWQgImVycm9yIHdoaWxlIHJ1bm5pbmcgZmFzdC1leHBvcnQiCiBtc2dzdHIgImZlbCB2aWQga8O2cm5pbmcgYXYgZmFzdC1leHBvcnQiCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxMDI3CisjOiB0cmFuc3BvcnQtaGVscGVyLmM6MTA0NQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiTm8gcmVmcyBpbiBjb21tb24gYW5kIG5vbmUgc3BlY2lmaWVkOyBkb2luZyBub3RoaW5nLlxuIgpAQCAtNzUyMSw0NyArNzU1MSw0NyBAQAogIkluZ2EgZ2VtZW5zYW1tYSByZWZlcmVuc2VyIG9jaCBpbmdhIGFuZ2F2czsgZ8O2ciBpbmdldC5cbiIKICJEdSBrYW5za2UgYm9yZGUgYW5nZSBlbiBncmVuIHPDpXNvbSBcIm1hc3RlclwiLlxuIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6MTA5MQorIzogdHJhbnNwb3J0LWhlbHBlci5jOjExMTgKICMsIGMtZm9ybWF0CiBtc2dpZCAibWFsZm9ybWVkIHJlc3BvbnNlIGluIHJlZiBsaXN0OiAlcyIKIG1zZ3N0ciAiZmVsZm9ybWF0IHN2YXIgaSByZWZlcmVuc2xpc3RhbjogJXMiCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxMjQ0CisjOiB0cmFuc3BvcnQtaGVscGVyLmM6MTI3MAogIywgYy1mb3JtYXQKIG1zZ2lkICJyZWFkKCVzKSBmYWlsZWQiCiBtc2dzdHIgImzDpHMoJXMpIG1pc3NseWNrYWRlcyIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjEyNzEKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxMjk3CiAjLCBjLWZvcm1hdAogbXNnaWQgIndyaXRlKCVzKSBmYWlsZWQiCiBtc2dzdHIgInNrcml2KCVzKSBtaXNzbHlja2FkZXMiCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxMzIwCisjOiB0cmFuc3BvcnQtaGVscGVyLmM6MTM0NgogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyB0aHJlYWQgZmFpbGVkIgogbXNnc3RyICIlcy10csOlZGVuIG1pc3NseWNrYWRlcyIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjEzMjQKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxMzUwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIHRocmVhZCBmYWlsZWQgdG8gam9pbjogJXMiCiBtc2dzdHIgIiVzLXRyw6VkZW4gbWlzc2x5Y2thZGVzIGFuc2x1dGE6ICVzIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6MTM0MyB0cmFuc3BvcnQtaGVscGVyLmM6MTM0NworIzogdHJhbnNwb3J0LWhlbHBlci5jOjEzNjkgdHJhbnNwb3J0LWhlbHBlci5jOjEzNzMKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2FuJ3Qgc3RhcnQgdGhyZWFkIGZvciBjb3B5aW5nIGRhdGE6ICVzIgogbXNnc3RyICJrYW4gaW50ZSBzdGFydGEgdHLDpWQgZsO2ciBrb3BpZXJpbmcgYXYgZGF0YTogJXMiCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxMzg0CisjOiB0cmFuc3BvcnQtaGVscGVyLmM6MTQxMAogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyBwcm9jZXNzIGZhaWxlZCB0byB3YWl0IgogbXNnc3RyICJwcm9jZXNzZW4gJXMgbWlzc2x5Y2thZGVzIHbDpG50YSIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjEzODgKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxNDE0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIHByb2Nlc3MgZmFpbGVkIgogbXNnc3RyICJwcm9jZXNzZW4gJXMgbWlzc2x5Y2thZGVzIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6MTQwNiB0cmFuc3BvcnQtaGVscGVyLmM6MTQxNQorIzogdHJhbnNwb3J0LWhlbHBlci5jOjE0MzIgdHJhbnNwb3J0LWhlbHBlci5jOjE0NDEKIG1zZ2lkICJjYW4ndCBzdGFydCB0aHJlYWQgZm9yIGNvcHlpbmcgZGF0YSIKIG1zZ3N0ciAia2FuIGludGUgc2thcGEgdHLDpWQgZsO2ciBrb3BpZXJpbmcgYXYgZGF0YSIKIApAQCAtNzU4MSw3ICs3NjExLDcgQEAKIG1zZ2lkICJ0b28tc2hvcnQgdHJlZSBmaWxlIgogbXNnc3RyICJ0csOkZGZpbCBmw7ZyIGtvcnQiCiAKLSM6IHVucGFjay10cmVlcy5jOjExMQorIzogdW5wYWNrLXRyZWVzLmM6MTEwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJZb3VyIGxvY2FsIGNoYW5nZXMgdG8gdGhlIGZvbGxvd2luZyBmaWxlcyB3b3VsZCBiZSBvdmVyd3JpdHRlbiBieSBjaGVja291dDpcbiIKQEAgLTc1OTAsNyArNzYyMCw3IEBACiAiRGluYSBsb2thbGEgw6RuZHJpbmdhciBhdiBmw7ZsamFuZGUgZmlsZXIgc2t1bGxlIHNrcml2YXMgw7Z2ZXIgYXYgdXRjaGVja25pbmc6XG4iCiAiJSVzQ2hlY2thIGluIGRpbmEgw6RuZHJpbmdhciBlbGxlciBhbnbDpG5kIFwic3Rhc2hcIiBpbm5hbiBkdSBieXRlciBncmVuLiIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTEzCisjOiB1bnBhY2stdHJlZXMuYzoxMTIKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIllvdXIgbG9jYWwgY2hhbmdlcyB0byB0aGUgZm9sbG93aW5nIGZpbGVzIHdvdWxkIGJlIG92ZXJ3cml0dGVuIGJ5IGNoZWNrb3V0OlxuIgpAQCAtNzU5OSw3ICs3NjI5LDcgQEAKICJEaW5hIGxva2FsYSDDpG5kcmluZ2FyIGF2IGbDtmxqYW5kZSBmaWxlciBza3VsbGUgc2tyaXZhcyDDtnZlciBhdiB1dGNoZWNrbmluZzpcbiIKICIlJXMiCiAKLSM6IHVucGFjay10cmVlcy5jOjExNgorIzogdW5wYWNrLXRyZWVzLmM6MTE1CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJZb3VyIGxvY2FsIGNoYW5nZXMgdG8gdGhlIGZvbGxvd2luZyBmaWxlcyB3b3VsZCBiZSBvdmVyd3JpdHRlbiBieSBtZXJnZTpcbiIKQEAgLTc2MDksNyArNzYzOSw3IEBACiAic2FtbWFuc2xhZ25pbmc6XG4iCiAiJSVzQ2hlY2thIGluIGRpbmEgw6RuZHJpbmdhciBlbGxlciBhbnbDpG5kIFwic3Rhc2hcIiBpbm5hbiBkdSBieXRlciBncmVuLiIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTE4CisjOiB1bnBhY2stdHJlZXMuYzoxMTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIllvdXIgbG9jYWwgY2hhbmdlcyB0byB0aGUgZm9sbG93aW5nIGZpbGVzIHdvdWxkIGJlIG92ZXJ3cml0dGVuIGJ5IG1lcmdlOlxuIgpAQCAtNzYxOSw3ICs3NjQ5LDcgQEAKICJzYW1tYW5zbGFnbmluZzpcbiIKICIlJXMiCiAKLSM6IHVucGFjay10cmVlcy5jOjEyMQorIzogdW5wYWNrLXRyZWVzLmM6MTIwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJZb3VyIGxvY2FsIGNoYW5nZXMgdG8gdGhlIGZvbGxvd2luZyBmaWxlcyB3b3VsZCBiZSBvdmVyd3JpdHRlbiBieSAlczpcbiIKQEAgLTc2MjgsNyArNzY1OCw3IEBACiAiRGluYSBsb2thbGEgw6RuZHJpbmdhciBhdiBmw7ZsamFuZGUgZmlsZXIgc2t1bGxlIHNrcml2YXMgw7Z2ZXIgYXYgXCIlc1wiOlxuIgogIiUlc0NoZWNrYSBpbiBkaW5hIMOkbmRyaW5nYXIgZWxsZXIgYW52w6RuZCBcInN0YXNoXCIgaW5uYW4gZHUgXCIlc1wiLiIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTIzCisjOiB1bnBhY2stdHJlZXMuYzoxMjIKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIllvdXIgbG9jYWwgY2hhbmdlcyB0byB0aGUgZm9sbG93aW5nIGZpbGVzIHdvdWxkIGJlIG92ZXJ3cml0dGVuIGJ5ICVzOlxuIgpAQCAtNzYzNyw3ICs3NjY3LDcgQEAKICJEaW5hIGxva2FsYSDDpG5kcmluZ2FyIGF2IGbDtmxqYW5kZSBmaWxlciBza3VsbGUgc2tyaXZhcyDDtnZlciBhdiBcIiVzXCI6XG4iCiAiJSVzIgogCi0jOiB1bnBhY2stdHJlZXMuYzoxMjgKKyM6IHVucGFjay10cmVlcy5jOjEyNwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiVXBkYXRpbmcgdGhlIGZvbGxvd2luZyBkaXJlY3RvcmllcyB3b3VsZCBsb3NlIHVudHJhY2tlZCBmaWxlcyBpbiB0aGVtOlxuIgpAQCAtNzY0Nyw3ICs3Njc3LDcgQEAKICJkZW06XG4iCiAiJXMiCiAKLSM6IHVucGFjay10cmVlcy5jOjEzMgorIzogdW5wYWNrLXRyZWVzLmM6MTMxCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgZm9sbG93aW5nIHVudHJhY2tlZCB3b3JraW5nIHRyZWUgZmlsZXMgd291bGQgYmUgcmVtb3ZlZCBieSBjaGVja291dDpcbiIKQEAgLTc2NTYsNyArNzY4Niw3IEBACiAiRsO2bGphbmRlIG9zcMOlcmFkZSBmaWxlciBpIGFyYmV0c2thdGFsb2dlbiBza3VsbGUgdGFzIGJvcnQgYXYgdXRjaGVja25pbmdlbjpcbiIKICIlJXNGbHl0dGEgZWxsZXIgdGEgYm9ydCBkZW0gaW5uYW4gZHUgYnl0ZXIgZ3Jlbi4iCiAKLSM6IHVucGFjay10cmVlcy5jOjEzNAorIzogdW5wYWNrLXRyZWVzLmM6MTMzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgZm9sbG93aW5nIHVudHJhY2tlZCB3b3JraW5nIHRyZWUgZmlsZXMgd291bGQgYmUgcmVtb3ZlZCBieSBjaGVja291dDpcbiIKQEAgLTc2NjUsNyArNzY5NSw3IEBACiAiRsO2bGphbmRlIG9zcMOlcmFkZSBmaWxlciBpIGFyYmV0c2thdGFsb2dlbiBza3VsbGUgdGFzIGJvcnQgYXYgdXRjaGVja25pbmdlbjpcbiIKICIlJXMiCiAKLSM6IHVucGFjay10cmVlcy5jOjEzNworIzogdW5wYWNrLXRyZWVzLmM6MTM2CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgZm9sbG93aW5nIHVudHJhY2tlZCB3b3JraW5nIHRyZWUgZmlsZXMgd291bGQgYmUgcmVtb3ZlZCBieSBtZXJnZTpcbiIKQEAgLTc2NzUsNyArNzcwNSw3IEBACiAic2FtbWFuc2xhZ25pbmdlbjpcbiIKICIlJXNGbHl0dGEgZWxsZXIgdGEgYm9ydCBkZW0gaW5uYW4gZHUgc2zDpXIgc2FtbWFuLiIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTM5CisjOiB1bnBhY2stdHJlZXMuYzoxMzgKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlRoZSBmb2xsb3dpbmcgdW50cmFja2VkIHdvcmtpbmcgdHJlZSBmaWxlcyB3b3VsZCBiZSByZW1vdmVkIGJ5IG1lcmdlOlxuIgpAQCAtNzY4NSw3ICs3NzE1LDcgQEAKICJzYW1tYW5zbGFnbmluZ2VuOlxuIgogIiUlcyIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTQyCisjOiB1bnBhY2stdHJlZXMuYzoxNDEKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlRoZSBmb2xsb3dpbmcgdW50cmFja2VkIHdvcmtpbmcgdHJlZSBmaWxlcyB3b3VsZCBiZSByZW1vdmVkIGJ5ICVzOlxuIgpAQCAtNzY5NCw3ICs3NzI0LDcgQEAKICJGw7ZsamFuZGUgb3Nww6VyYWRlIGZpbGVyIGkgYXJiZXRza2F0YWxvZ2VuIHNrdWxsZSB0YXMgYm9ydCBhdiBcIiVzXCI6XG4iCiAiJSVzRmx5dHRhIGVsbGVyIHRhIGJvcnQgZGVtIGlubmFuIGR1IFwiJXNcIi4iCiAKLSM6IHVucGFjay10cmVlcy5jOjE0NAorIzogdW5wYWNrLXRyZWVzLmM6MTQzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgZm9sbG93aW5nIHVudHJhY2tlZCB3b3JraW5nIHRyZWUgZmlsZXMgd291bGQgYmUgcmVtb3ZlZCBieSAlczpcbiIKQEAgLTc3MDMsNyArNzczMyw3IEBACiAiRsO2bGphbmRlIG9zcMOlcmFkZSBmaWxlciBpIGFyYmV0c2thdGFsb2dlbiBza3VsbGUgdGFzIGJvcnQgYXYgXCIlc1wiOlxuIgogIiUlcyIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTUwCisjOiB1bnBhY2stdHJlZXMuYzoxNDkKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlRoZSBmb2xsb3dpbmcgdW50cmFja2VkIHdvcmtpbmcgdHJlZSBmaWxlcyB3b3VsZCBiZSBvdmVyd3JpdHRlbiBieSAiCkBAIC03NzE0LDcgKzc3NDQsNyBAQAogInV0Y2hlY2tuaW5nZW46XG4iCiAiJSVzRmx5dHRhIGVsbGVyIHRhIGJvcnQgZGVtIGlubmFuIGR1IGJ5dGVyIGdyZW4uIgogCi0jOiB1bnBhY2stdHJlZXMuYzoxNTIKKyM6IHVucGFjay10cmVlcy5jOjE1MQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiVGhlIGZvbGxvd2luZyB1bnRyYWNrZWQgd29ya2luZyB0cmVlIGZpbGVzIHdvdWxkIGJlIG92ZXJ3cml0dGVuIGJ5ICIKQEAgLTc3MjUsNyArNzc1NSw3IEBACiAidXRjaGVja25pbmdlbjpcbiIKICIlJXMiCiAKLSM6IHVucGFjay10cmVlcy5jOjE1NQorIzogdW5wYWNrLXRyZWVzLmM6MTU0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgZm9sbG93aW5nIHVudHJhY2tlZCB3b3JraW5nIHRyZWUgZmlsZXMgd291bGQgYmUgb3ZlcndyaXR0ZW4gYnkgbWVyZ2U6XG4iCkBAIC03NzM1LDcgKzc3NjUsNyBAQAogInNhbW1hbnNsYWduaW5nZW46XG4iCiAiJSVzRmx5dHRhIGVsbGVyIHRhIGJvcnQgZGVtIGlubmFuIGR1IGJ5dGVyIGdyZW4uIgogCi0jOiB1bnBhY2stdHJlZXMuYzoxNTcKKyM6IHVucGFjay10cmVlcy5jOjE1NgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiVGhlIGZvbGxvd2luZyB1bnRyYWNrZWQgd29ya2luZyB0cmVlIGZpbGVzIHdvdWxkIGJlIG92ZXJ3cml0dGVuIGJ5IG1lcmdlOlxuIgpAQCAtNzc0NSw3ICs3Nzc1LDcgQEAKICJzYW1tYW5zbGFnbmluZ2VuOlxuIgogIiUlcyIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTYwCisjOiB1bnBhY2stdHJlZXMuYzoxNTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlRoZSBmb2xsb3dpbmcgdW50cmFja2VkIHdvcmtpbmcgdHJlZSBmaWxlcyB3b3VsZCBiZSBvdmVyd3JpdHRlbiBieSAlczpcbiIKQEAgLTc3NTQsNyArNzc4NCw3IEBACiAiRsO2bGphbmRlIG9zcMOlcmFkZSBmaWxlciBpIGFyYmV0c2thdGFsb2dlbiBza3VsbGUgc2tyaXZhcyDDtnZlciBhdiBcIiVzXCI6XG4iCiAiJSVzRmx5dHRhIGVsbGVyIHRhIGJvcnQgZGVtIGlubmFuIGR1IFwiJXNcIi4iCiAKLSM6IHVucGFjay10cmVlcy5jOjE2MgorIzogdW5wYWNrLXRyZWVzLmM6MTYxCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgZm9sbG93aW5nIHVudHJhY2tlZCB3b3JraW5nIHRyZWUgZmlsZXMgd291bGQgYmUgb3ZlcndyaXR0ZW4gYnkgJXM6XG4iCkBAIC03NzYzLDEyICs3NzkzLDEyIEBACiAiRsO2bGphbmRlIG9zcMOlcmFkZSBmaWxlciBpIGFyYmV0c2thdGFsb2dlbiBza3VsbGUgc2tyaXZhcyDDtnZlciBhdiBcIiVzXCI6XG4iCiAiJSVzIgogCi0jOiB1bnBhY2stdHJlZXMuYzoxNzAKKyM6IHVucGFjay10cmVlcy5jOjE2OQogIywgYy1mb3JtYXQKIG1zZ2lkICJFbnRyeSAnJXMnIG92ZXJsYXBzIHdpdGggJyVzJy4gIENhbm5vdCBiaW5kLiIKIG1zZ3N0ciAiUG9zdGVuIFwiJXNcIiDDtnZlcmxhcHBhciBcIiVzXCIuIEthbiBpbnRlIGJpbmRhLiIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTczCisjOiB1bnBhY2stdHJlZXMuYzoxNzIKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkNhbm5vdCB1cGRhdGUgc3BhcnNlIGNoZWNrb3V0OiB0aGUgZm9sbG93aW5nIGVudHJpZXMgYXJlIG5vdCB1cCB0byBkYXRlOlxuIgpAQCAtNzc3Nyw3ICs3ODA3LDcgQEAKICJLYW4gaW50ZSB1cHBkYXRlcmEgZ2xlcyB1dGNoZWNrbmluZzogZsO2bGphbmRlIHBvc3RlciDDpHIgaW50ZSDDoCBqb3VyOlxuIgogIiVzIgogCi0jOiB1bnBhY2stdHJlZXMuYzoxNzUKKyM6IHVucGFjay10cmVlcy5jOjE3NAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiVGhlIGZvbGxvd2luZyB3b3JraW5nIHRyZWUgZmlsZXMgd291bGQgYmUgb3ZlcndyaXR0ZW4gYnkgc3BhcnNlIGNoZWNrb3V0ICIKQEAgLTc3ODgsNyArNzgxOCw3IEBACiAidXRjaGVja25pbmc6XG4iCiAiJXMiCiAKLSM6IHVucGFjay10cmVlcy5jOjE3NworIzogdW5wYWNrLXRyZWVzLmM6MTc2CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgZm9sbG93aW5nIHdvcmtpbmcgdHJlZSBmaWxlcyB3b3VsZCBiZSByZW1vdmVkIGJ5IHNwYXJzZSBjaGVja291dCAiCkBAIC03Nzk5LDcgKzc4MjksNyBAQAogInV0Y2hlY2tuaW5nOlxuIgogIiVzIgogCi0jOiB1bnBhY2stdHJlZXMuYzoxNzkKKyM6IHVucGFjay10cmVlcy5jOjE3OAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiQ2Fubm90IHVwZGF0ZSBzdWJtb2R1bGU6XG4iCkBAIC03ODA4LDE2ICs3ODM4LDE2IEBACiAiS2FuIGludGUgdXBwZGF0ZXJhIHVuZGVybW9kdWw6XG4iCiAiJXMiCiAKLSM6IHVucGFjay10cmVlcy5jOjI1NgorIzogdW5wYWNrLXRyZWVzLmM6MjU1CiAjLCBjLWZvcm1hdAogbXNnaWQgIkFib3J0aW5nXG4iCiBtc2dzdHIgIkF2YnJ5dGVyXG4iCiAKLSM6IHVucGFjay10cmVlcy5jOjMxOAorIzogdW5wYWNrLXRyZWVzLmM6MzE3CiBtc2dpZCAiVXBkYXRpbmcgZmlsZXMiCiBtc2dzdHIgIlVwcGRhdGVyYXIgZmlsZXIiCiAKLSM6IHVucGFjay10cmVlcy5jOjM1MAorIzogdW5wYWNrLXRyZWVzLmM6MzQ5CiBtc2dpZCAiIgogInRoZSBmb2xsb3dpbmcgcGF0aHMgaGF2ZSBjb2xsaWRlZCAoZS5nLiBjYXNlLXNlbnNpdGl2ZSBwYXRoc1xuIgogIm9uIGEgY2FzZS1pbnNlbnNpdGl2ZSBmaWxlc3lzdGVtKSBhbmQgb25seSBvbmUgZnJvbSB0aGUgc2FtZVxuIgpAQCAtNzg1Niw3ICs3ODg2LDcgQEAKIG1zZ2lkICJpbnZhbGlkICcuLicgcGF0aCBzZWdtZW50IgogbXNnc3RyICJmZWxha3RpZ3QgXCIuLlwiLXPDtmt2w6Rnc3NlZ21lbnQiCiAKLSM6IHdvcmt0cmVlLmM6MjU4IGJ1aWx0aW4vYW0uYzoyMDk1CisjOiB3b3JrdHJlZS5jOjI1OCBidWlsdGluL2FtLmM6MjA4NAogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gcmVhZCAnJXMnIgogbXNnc3RyICJtaXNzbHlja2FkZXMgbMOkc2EgXCIlc1wiIgpAQCAtNzg4NiwxNyArNzkxNiwxNyBAQAogbXNnaWQgIiclcycgZG9lcyBub3QgcG9pbnQgYmFjayB0byAnJXMnIgogbXNnc3RyICJcIiVzXCIgcGVrYXIgaW50ZSB0aWxsYmFrYSB0aWxsIFwiJXNcIiIKIAotIzogd3JhcHBlci5jOjIyMyB3cmFwcGVyLmM6MzkzCisjOiB3cmFwcGVyLmM6MTg2IHdyYXBwZXIuYzozNTYKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IG9wZW4gJyVzJyBmb3IgcmVhZGluZyBhbmQgd3JpdGluZyIKIG1zZ3N0ciAia3VuZGUgaW50ZSDDtnBwbmEgXCIlc1wiIGbDtnIgbMOkc25pbmcgb2NoIHNrcml2bmluZyIKIAotIzogd3JhcHBlci5jOjQyNCB3cmFwcGVyLmM6NjI0CisjOiB3cmFwcGVyLmM6Mzg3IHdyYXBwZXIuYzo1ODgKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGFjY2VzcyAnJXMnIgogbXNnc3RyICJrYW4gaW50ZSBrb21tYSDDpXQgXCIlc1wiIgogCi0jOiB3cmFwcGVyLmM6NjMyCisjOiB3cmFwcGVyLmM6NTk2CiBtc2dpZCAidW5hYmxlIHRvIGdldCBjdXJyZW50IHdvcmtpbmcgZGlyZWN0b3J5IgogbXNnc3RyICJrYW4gaW50ZSBow6RtdGEgYWt0dWVsbCBhcmJldHNrYXRhbG9nIgogCkBAIC04MjMyLDgzICs4MjYyLDkxIEBACiBtc2dzdHIgIiAgKGFsbGEga29uZmxpa3RlciByw6R0dGFkZToga8O2ciBcImdpdCBjaGVycnktcGljayAtLWNvbnRpbnVlXCIpIgogCiAjOiB3dC1zdGF0dXMuYzoxNDM3Cittc2dpZCAiICAodXNlIFwiZ2l0IGNoZXJyeS1waWNrIC0tc2tpcFwiIHRvIHNraXAgdGhpcyBwYXRjaCkiCittc2dzdHIgIiAgKGFudsOkbmQgXCJnaXQgY2hlcnJ5LXBpY2sgLS1za2lwXCIgZsO2ciBhdHQgaG9wcGEgw7Z2ZXIgcGF0Y2hlbikiCisKKyM6IHd0LXN0YXR1cy5jOjE0MzkKIG1zZ2lkICIgICh1c2UgXCJnaXQgY2hlcnJ5LXBpY2sgLS1hYm9ydFwiIHRvIGNhbmNlbCB0aGUgY2hlcnJ5LXBpY2sgb3BlcmF0aW9uKSIKIG1zZ3N0ciAiIgogIiAgKGFudsOkbmQgXCJnaXQgY2hlcnJ5LXBpY2sgLS1hYm9ydFwiIGbDtnIgYXR0IGF2YnJ5dGEgXCJjaGVycnktcGlja1wiLSIKICJvcGVyYXRpb25lbikiCiAKLSM6IHd0LXN0YXR1cy5jOjE0NDcKKyM6IHd0LXN0YXR1cy5jOjE0NDkKIG1zZ2lkICJSZXZlcnQgY3VycmVudGx5IGluIHByb2dyZXNzLiIKIG1zZ3N0ciAiw4VuZ3JpbmcgcMOlZ8Olci4iCiAKLSM6IHd0LXN0YXR1cy5jOjE0NTAKKyM6IHd0LXN0YXR1cy5jOjE0NTIKICMsIGMtZm9ybWF0CiBtc2dpZCAiWW91IGFyZSBjdXJyZW50bHkgcmV2ZXJ0aW5nIGNvbW1pdCAlcy4iCiBtc2dzdHIgIkR1IGjDpWxsZXIgcMOlIG1lZCBhdHQgw6VuZ3JhIGluY2hlY2tuaW5nZW4gJXMuIgogCi0jOiB3dC1zdGF0dXMuYzoxNDU2CisjOiB3dC1zdGF0dXMuYzoxNDU4CiBtc2dpZCAiICAoZml4IGNvbmZsaWN0cyBhbmQgcnVuIFwiZ2l0IHJldmVydCAtLWNvbnRpbnVlXCIpIgogbXNnc3RyICIgIChyw6R0dGEga29uZmxpa3RlciBvY2gga8O2ciBzZWRhbiBcImdpdCByZXZlcnQgLS1jb250aW51ZVwiKSIKIAotIzogd3Qtc3RhdHVzLmM6MTQ1OQorIzogd3Qtc3RhdHVzLmM6MTQ2MQogbXNnaWQgIiAgKHJ1biBcImdpdCByZXZlcnQgLS1jb250aW51ZVwiIHRvIGNvbnRpbnVlKSIKIG1zZ3N0ciAiICAoa8O2ciBcImdpdCByZXZlcnQgLS1jb250aW51ZVwiIGbDtnIgYXR0IGZvcnRzw6R0dGEpIgogCi0jOiB3dC1zdGF0dXMuYzoxNDYyCisjOiB3dC1zdGF0dXMuYzoxNDY0CiBtc2dpZCAiICAoYWxsIGNvbmZsaWN0cyBmaXhlZDogcnVuIFwiZ2l0IHJldmVydCAtLWNvbnRpbnVlXCIpIgogbXNnc3RyICIgIChhbGxhIGtvbmZsaWt0ZXIgcsOkdHRhZGU6IGvDtnIgXCJnaXQgcmV2ZXJ0IC0tY29udGludWVcIikiCiAKLSM6IHd0LXN0YXR1cy5jOjE0NjQKKyM6IHd0LXN0YXR1cy5jOjE0NjYKK21zZ2lkICIgICh1c2UgXCJnaXQgcmV2ZXJ0IC0tc2tpcFwiIHRvIHNraXAgdGhpcyBwYXRjaCkiCittc2dzdHIgIiAgKGFudsOkbmQgXCJnaXQgcmV2ZXJ0IC0tc2tpcFwiIGbDtnIgYXR0IGhvcHBhIMO2dmVyIHBhdGNoZW4pIgorCisjOiB3dC1zdGF0dXMuYzoxNDY4CiBtc2dpZCAiICAodXNlIFwiZ2l0IHJldmVydCAtLWFib3J0XCIgdG8gY2FuY2VsIHRoZSByZXZlcnQgb3BlcmF0aW9uKSIKIG1zZ3N0ciAiICAoYW52w6RuZCBcImdpdCByZXZlcnQgLS1hYm9ydFwiIGbDtnIgYXR0IGF2YnJ5dGEgw6VuZ3JhbmRldCkiCiAKLSM6IHd0LXN0YXR1cy5jOjE0NzQKKyM6IHd0LXN0YXR1cy5jOjE0NzgKICMsIGMtZm9ybWF0CiBtc2dpZCAiWW91IGFyZSBjdXJyZW50bHkgYmlzZWN0aW5nLCBzdGFydGVkIGZyb20gYnJhbmNoICclcycuIgogbXNnc3RyICJEdSBow6VsbGVyIHDDpSBtZWQgZW4gXCJiaXNlY3RcIiwgc3RhcnRhZCBmcsOlbiBncmVuZW4gXCIlc1wiLiIKIAotIzogd3Qtc3RhdHVzLmM6MTQ3OAorIzogd3Qtc3RhdHVzLmM6MTQ4MgogbXNnaWQgIllvdSBhcmUgY3VycmVudGx5IGJpc2VjdGluZy4iCiBtc2dzdHIgIkR1IGjDpWxsZXIgcMOlIG1lZCBlbiBcImJpc2VjdFwiLiIKIAotIzogd3Qtc3RhdHVzLmM6MTQ4MQorIzogd3Qtc3RhdHVzLmM6MTQ4NQogbXNnaWQgIiAgKHVzZSBcImdpdCBiaXNlY3QgcmVzZXRcIiB0byBnZXQgYmFjayB0byB0aGUgb3JpZ2luYWwgYnJhbmNoKSIKIG1zZ3N0ciAiIgogIiAgKGFudsOkbmQgXCJnaXQgYmlzZWN0IHJlc2V0XCIgZsO2ciBhdHQga29tbWEgdGlsbGJha2EgdGlsbCB1cnNwcnVuZ3NncmVuZW4pIgogCi0jOiB3dC1zdGF0dXMuYzoxNjkwCisjOiB3dC1zdGF0dXMuYzoxNjk0CiBtc2dpZCAiT24gYnJhbmNoICIKIG1zZ3N0ciAiUMOlIGdyZW5lbiAiCiAKLSM6IHd0LXN0YXR1cy5jOjE2OTcKKyM6IHd0LXN0YXR1cy5jOjE3MDEKIG1zZ2lkICJpbnRlcmFjdGl2ZSByZWJhc2UgaW4gcHJvZ3Jlc3M7IG9udG8gIgogbXNnc3RyICJpbnRlcmFrdGl2IG9tYmFzZXJpbmcgcMOlZ8Olcjsgb3ZhbnDDpSAiCiAKLSM6IHd0LXN0YXR1cy5jOjE2OTkKKyM6IHd0LXN0YXR1cy5jOjE3MDMKIG1zZ2lkICJyZWJhc2UgaW4gcHJvZ3Jlc3M7IG9udG8gIgogbXNnc3RyICJvbWJhc2VyaW5nIHDDpWfDpXI7IG92YW5ww6UgIgogCi0jOiB3dC1zdGF0dXMuYzoxNzA5CisjOiB3dC1zdGF0dXMuYzoxNzEzCiBtc2dpZCAiTm90IGN1cnJlbnRseSBvbiBhbnkgYnJhbmNoLiIKIG1zZ3N0ciAiSW50ZSBww6UgbsOlZ29uIGdyZW4gZsO2ciBuw6RydmFyYW5kZS4iCiAKLSM6IHd0LXN0YXR1cy5jOjE3MjYKKyM6IHd0LXN0YXR1cy5jOjE3MzAKIG1zZ2lkICJJbml0aWFsIGNvbW1pdCIKIG1zZ3N0ciAiRsO2cnN0YSBpbmNoZWNrbmluZyIKIAotIzogd3Qtc3RhdHVzLmM6MTcyNworIzogd3Qtc3RhdHVzLmM6MTczMQogbXNnaWQgIk5vIGNvbW1pdHMgeWV0IgogbXNnc3RyICJJbmdhIGluY2hlY2tuaW5nYXIgw6RubnUiCiAKLSM6IHd0LXN0YXR1cy5jOjE3NDEKKyM6IHd0LXN0YXR1cy5jOjE3NDUKIG1zZ2lkICJVbnRyYWNrZWQgZmlsZXMiCiBtc2dzdHIgIk9zcMOlcmFkZSBmaWxlciIKIAotIzogd3Qtc3RhdHVzLmM6MTc0MworIzogd3Qtc3RhdHVzLmM6MTc0NwogbXNnaWQgIklnbm9yZWQgZmlsZXMiCiBtc2dzdHIgIklnbm9yZXJhZGUgZmlsZXIiCiAKLSM6IHd0LXN0YXR1cy5jOjE3NDcKKyM6IHd0LXN0YXR1cy5jOjE3NTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkl0IHRvb2sgJS4yZiBzZWNvbmRzIHRvIGVudW1lcmF0ZSB1bnRyYWNrZWQgZmlsZXMuICdzdGF0dXMgLXVubydcbiIKQEAgLTgzMjAsMzIgKzgzNTgsMzIgQEAKICJsw6RnZ2EgdGlsbCBueWEgZmlsZXIgc2rDpGx2IChzZSBcImdpdCBoZWxwIHN0YXR1c1wiKS4iCiAKICMgJXMgw6RyIG7DpHN0YSBzdHLDpG5nIGVsbGVyIHRvbS4KLSM6IHd0LXN0YXR1cy5jOjE3NTMKKyM6IHd0LXN0YXR1cy5jOjE3NTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiVW50cmFja2VkIGZpbGVzIG5vdCBsaXN0ZWQlcyIKIG1zZ3N0ciAiT3Nww6VyYWRlIGZpbGVyIHZpc2FzIGVqJXMiCiAKLSM6IHd0LXN0YXR1cy5jOjE3NTUKKyM6IHd0LXN0YXR1cy5jOjE3NTkKIG1zZ2lkICIgKHVzZSAtdSBvcHRpb24gdG8gc2hvdyB1bnRyYWNrZWQgZmlsZXMpIgogbXNnc3RyICIgKGFudsOkbmQgZmxhZ2dhbiAtdSBmw7ZyIGF0dCB2aXNhIG9zcMOlcmFkZSBmaWxlcikiCiAKLSM6IHd0LXN0YXR1cy5jOjE3NjEKKyM6IHd0LXN0YXR1cy5jOjE3NjUKIG1zZ2lkICJObyBjaGFuZ2VzIgogbXNnc3RyICJJbmdhIMOkbmRyaW5nYXIiCiAKLSM6IHd0LXN0YXR1cy5jOjE3NjYKKyM6IHd0LXN0YXR1cy5jOjE3NzAKICMsIGMtZm9ybWF0CiBtc2dpZCAibm8gY2hhbmdlcyBhZGRlZCB0byBjb21taXQgKHVzZSBcImdpdCBhZGRcIiBhbmQvb3IgXCJnaXQgY29tbWl0IC1hXCIpXG4iCiBtc2dzdHIgIiIKICJpbmdhIMOkbmRyaW5nYXIgYXR0IGNoZWNrYSBpbiAoYW52w6RuZCBcImdpdCBhZGRcIiBvY2gvZWxsZXIgXCJnaXQgY29tbWl0IC1hIgogIlwiKVxuIgogCi0jOiB3dC1zdGF0dXMuYzoxNzY5CisjOiB3dC1zdGF0dXMuYzoxNzczCiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vIGNoYW5nZXMgYWRkZWQgdG8gY29tbWl0XG4iCiBtc2dzdHIgImluZ2Egw6RuZHJpbmdhciBhdHQgY2hlY2thIGluXG4iCiAKLSM6IHd0LXN0YXR1cy5jOjE3NzIKKyM6IHd0LXN0YXR1cy5jOjE3NzYKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIm5vdGhpbmcgYWRkZWQgdG8gY29tbWl0IGJ1dCB1bnRyYWNrZWQgZmlsZXMgcHJlc2VudCAodXNlIFwiZ2l0IGFkZFwiIHRvICIKQEAgLTgzNTQsNjYgKzgzOTIsNzEgQEAKICJpbmdldCBrw7ZhdCBmw7ZyIGluY2hlY2tuaW5nLCBtZW4gb3Nww6VyYWRlIGZpbGVyIGZpbm5zIChzcMOlcmEgbWVkIFwiZ2l0IGFkZCIKICJcIilcbiIKIAotIzogd3Qtc3RhdHVzLmM6MTc3NQorIzogd3Qtc3RhdHVzLmM6MTc3OQogIywgYy1mb3JtYXQKIG1zZ2lkICJub3RoaW5nIGFkZGVkIHRvIGNvbW1pdCBidXQgdW50cmFja2VkIGZpbGVzIHByZXNlbnRcbiIKIG1zZ3N0ciAiaW5nZXQga8O2YXQgZsO2ciBpbmNoZWNrbmluZywgbWVuIG9zcMOlcmFkZSBmaWxlciBmaW5uc1xuIgogCi0jOiB3dC1zdGF0dXMuYzoxNzc4CisjOiB3dC1zdGF0dXMuYzoxNzgyCiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vdGhpbmcgdG8gY29tbWl0IChjcmVhdGUvY29weSBmaWxlcyBhbmQgdXNlIFwiZ2l0IGFkZFwiIHRvIHRyYWNrKVxuIgogbXNnc3RyICJpbmdldCBhdHQgY2hlY2thIGluIChza2FwYS9rb3BpZXJhIGZpbGVyIG9jaCBzcMOlcmEgbWVkIFwiZ2l0IGFkZFwiKVxuIgogCi0jOiB3dC1zdGF0dXMuYzoxNzgxIHd0LXN0YXR1cy5jOjE3ODYKKyM6IHd0LXN0YXR1cy5jOjE3ODUgd3Qtc3RhdHVzLmM6MTc5MAogIywgYy1mb3JtYXQKIG1zZ2lkICJub3RoaW5nIHRvIGNvbW1pdFxuIgogbXNnc3RyICJpbmdldCBhdHQgY2hlY2thIGluXG4iCiAKLSM6IHd0LXN0YXR1cy5jOjE3ODQKKyM6IHd0LXN0YXR1cy5jOjE3ODgKICMsIGMtZm9ybWF0CiBtc2dpZCAibm90aGluZyB0byBjb21taXQgKHVzZSAtdSB0byBzaG93IHVudHJhY2tlZCBmaWxlcylcbiIKIG1zZ3N0ciAiaW5nZXQgYXR0IGNoZWNrYSBpbiAoYW52w6RuZCAtdSBmw7ZyIGF0dCB2aXNhIG9zcMOlcmFkZSBmaWxlcilcbiIKIAotIzogd3Qtc3RhdHVzLmM6MTc4OAorIzogd3Qtc3RhdHVzLmM6MTc5MgogIywgYy1mb3JtYXQKIG1zZ2lkICJub3RoaW5nIHRvIGNvbW1pdCwgd29ya2luZyB0cmVlIGNsZWFuXG4iCiBtc2dzdHIgImluZ2V0IGF0dCBjaGVja2EgaW4sIGFyYmV0c2thdGFsb2dlbiByZW5cbiIKIAotIzogd3Qtc3RhdHVzLmM6MTkwMQorIzogd3Qtc3RhdHVzLmM6MTkwNQogbXNnaWQgIk5vIGNvbW1pdHMgeWV0IG9uICIKIG1zZ3N0ciAiSW5nYSBpbmNoZWNrbmluZ2FyIMOkbm51IHDDpSAiCiAKLSM6IHd0LXN0YXR1cy5jOjE5MDUKKyM6IHd0LXN0YXR1cy5jOjE5MDkKIG1zZ2lkICJIRUFEIChubyBicmFuY2gpIgogbXNnc3RyICJIRUFEIChpbmdlbiBncmVuKSIKIAotIzogd3Qtc3RhdHVzLmM6MTkzNgorIzogd3Qtc3RhdHVzLmM6MTk0MAogbXNnaWQgImRpZmZlcmVudCIKIG1zZ3N0ciAib2xpa2EiCiAKLSM6IHd0LXN0YXR1cy5jOjE5Mzggd3Qtc3RhdHVzLmM6MTk0NgorIzogd3Qtc3RhdHVzLmM6MTk0MiB3dC1zdGF0dXMuYzoxOTUwCiBtc2dpZCAiYmVoaW5kICIKIG1zZ3N0ciAiZWZ0ZXIgIgogCi0jOiB3dC1zdGF0dXMuYzoxOTQxIHd0LXN0YXR1cy5jOjE5NDQKKyM6IHd0LXN0YXR1cy5jOjE5NDUgd3Qtc3RhdHVzLmM6MTk0OAogbXNnaWQgImFoZWFkICIKIG1zZ3N0ciAiZsO2cmUgIgogCiAjLiBUUkFOU0xBVE9SUzogdGhlIGFjdGlvbiBpcyBlLmcuICJwdWxsIHdpdGggcmViYXNlIgotIzogd3Qtc3RhdHVzLmM6MjQ2NgorIzogd3Qtc3RhdHVzLmM6MjQ3MAogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgJXM6IFlvdSBoYXZlIHVuc3RhZ2VkIGNoYW5nZXMuIgogbXNnc3RyICJrYW4gaW50ZSAlczogRHUgaGFyIG9rw7ZhZGUgw6RuZHJpbmdhci4iCiAKLSM6IHd0LXN0YXR1cy5jOjI0NzIKKyM6IHd0LXN0YXR1cy5jOjI0NzYKIG1zZ2lkICJhZGRpdGlvbmFsbHksIHlvdXIgaW5kZXggY29udGFpbnMgdW5jb21taXR0ZWQgY2hhbmdlcy4iCiBtc2dzdHIgImRlc3N1dG9tIGlubmVow6VsbGVyIGRpdCBpbmRleCDDpG5kcmluZ2FyIHNvbSBpbnRlIGhhciBjaGVja2F0cyBpbi4iCiAKLSM6IHd0LXN0YXR1cy5jOjI0NzQKKyM6IHd0LXN0YXR1cy5jOjI0NzgKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90ICVzOiBZb3VyIGluZGV4IGNvbnRhaW5zIHVuY29tbWl0dGVkIGNoYW5nZXMuIgogbXNnc3RyICJrYW4gaW50ZSAlczogRGl0dCBpbmRleCBpbm5laMOlbGxlciDDpG5kcmluZ2FyIHNvbSBpbnRlIGNoZWNrYXRzIGluLiIKIAorIzogY29tcGF0L3ByZWNvbXBvc2VfdXRmOC5jOjU4IGJ1aWx0aW4vY2xvbmUuYzo0NTIKKyMsIGMtZm9ybWF0Cittc2dpZCAiZmFpbGVkIHRvIHVubGluayAnJXMnIgorbXNnc3RyICJtaXNzbHlja2FkZXMgdGEgYm9ydCBsw6Rua2VuIFwiJXNcIiIKKwogIzogYnVpbHRpbi9hZGQuYzoyNQogbXNnaWQgImdpdCBhZGQgWzxvcHRpb25zPl0gWy0tXSA8cGF0aHNwZWM+Li4uIgogbXNnc3RyICJnaXQgYWRkIFs8ZmxhZ2dvcj5dIFstLV0gPHPDtmt2w6RnPi4uLiIKQEAgLTg0MzYsNyArODQ3OSw3IEBACiBtc2dpZCAiVW5zdGFnZWQgY2hhbmdlcyBhZnRlciByZWZyZXNoaW5nIHRoZSBpbmRleDoiCiBtc2dzdHIgIk9rw7ZhZGUgw6RuZHJpbmdhciBlZnRlciBhdHQgaGEgdXBwZGF0ZXJhdCBpbmRleGV0OiIKIAotIzogYnVpbHRpbi9hZGQuYzoyMzQgYnVpbHRpbi9yZXYtcGFyc2UuYzo4OTYKKyM6IGJ1aWx0aW4vYWRkLmM6MjM0IGJ1aWx0aW4vcmV2LXBhcnNlLmM6ODk3CiBtc2dpZCAiQ291bGQgbm90IHJlYWQgdGhlIGluZGV4IgogbXNnc3RyICJLdW5kZSBpbnRlIGzDpHNhIGluZGV4ZXQiCiAKQEAgLTg0NzEsOCArODUxNCw4IEBACiBtc2dpZCAiVGhlIGZvbGxvd2luZyBwYXRocyBhcmUgaWdub3JlZCBieSBvbmUgb2YgeW91ciAuZ2l0aWdub3JlIGZpbGVzOlxuIgogbXNnc3RyICJGw7ZsamFuZGUgc8O2a3bDpGdhciBpZ25vcmVyYXMgYXYgZW4gYXYgZGluYSAuZ2l0aWdub3JlLWZpbGVyOlxuIgogCi0jOiBidWlsdGluL2FkZC5jOjI5MCBidWlsdGluL2NsZWFuLmM6OTA5IGJ1aWx0aW4vZmV0Y2guYzoxNDcgYnVpbHRpbi9tdi5jOjEyNAotIzogYnVpbHRpbi9wcnVuZS1wYWNrZWQuYzo1NiBidWlsdGluL3B1bGwuYzoyMjIgYnVpbHRpbi9wdXNoLmM6NTYwCisjOiBidWlsdGluL2FkZC5jOjI5MCBidWlsdGluL2NsZWFuLmM6OTEwIGJ1aWx0aW4vZmV0Y2guYzoxNjIgYnVpbHRpbi9tdi5jOjEyNAorIzogYnVpbHRpbi9wcnVuZS1wYWNrZWQuYzo1NiBidWlsdGluL3B1bGwuYzoyMjMgYnVpbHRpbi9wdXNoLmM6NTQ3CiAjOiBidWlsdGluL3JlbW90ZS5jOjEzNDUgYnVpbHRpbi9ybS5jOjI0MSBidWlsdGluL3NlbmQtcGFjay5jOjE2NQogbXNnaWQgImRyeSBydW4iCiBtc2dzdHIgInRlc3Rrw7ZybmluZyIKQEAgLTg1MjUsNyArODU2OCw3IEBACiBtc2dpZCAiY2hlY2sgaWYgLSBldmVuIG1pc3NpbmcgLSBmaWxlcyBhcmUgaWdub3JlZCBpbiBkcnkgcnVuIgogbXNnc3RyICJzZSBvbSAtIMOkdmVuIHNha25hZGUgLSBmaWxlciBpZ25vcmVyYXMgaSB0ZXN0a8O2cm5pbmciCiAKLSM6IGJ1aWx0aW4vYWRkLmM6MzA5IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAwMQorIzogYnVpbHRpbi9hZGQuYzozMDkgYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDAyCiBtc2dpZCAib3ZlcnJpZGUgdGhlIGV4ZWN1dGFibGUgYml0IG9mIHRoZSBsaXN0ZWQgZmlsZXMiCiBtc2dzdHIgIsO2dmVyc3R5ciBleGVrdmVyaW5nc2JpdGVuIGbDtnIgYW5naXZuYSBmaWxlciIKIApAQCAtODYwMSwxMTMgKzg2NDQsMTA5IEBACiBtc2dpZCAiTWF5YmUgeW91IHdhbnRlZCB0byBzYXkgJ2dpdCBhZGQgLic/XG4iCiBtc2dzdHIgIkthbnNrZSBtZW5hZGUgZHUgYXR0IHNrcml2YSBcImdpdCBhZGQgLlwiP1xuIgogCi0jOiBidWlsdGluL2FtLmM6MzQ4CisjOiBidWlsdGluL2FtLmM6MzQ3CiBtc2dpZCAiY291bGQgbm90IHBhcnNlIGF1dGhvciBzY3JpcHQiCiBtc2dzdHIgImt1bmRlIGludGUgdG9sa2EgZsO2cmZhdHRhcnNrcmlwdCIKIAotIzogYnVpbHRpbi9hbS5jOjQzMgorIzogYnVpbHRpbi9hbS5jOjQzMQogIywgYy1mb3JtYXQKIG1zZ2lkICInJXMnIHdhcyBkZWxldGVkIGJ5IHRoZSBhcHBseXBhdGNoLW1zZyBob29rIgogbXNnc3RyICJcIiVzXCIgdG9ncyBib3J0IGF2IGtyb2tlbiBhcHBseXBhdGNoLW1zZyIKIAotIzogYnVpbHRpbi9hbS5jOjQ3NAorIzogYnVpbHRpbi9hbS5jOjQ3MwogIywgYy1mb3JtYXQKIG1zZ2lkICJNYWxmb3JtZWQgaW5wdXQgbGluZTogJyVzJy4iCiBtc2dzdHIgIkZlbGFrdGlnIGluZGF0YXJhZDogXCIlc1wiLiIKIAotIzogYnVpbHRpbi9hbS5jOjUxMgorIzogYnVpbHRpbi9hbS5jOjUxMQogIywgYy1mb3JtYXQKIG1zZ2lkICJGYWlsZWQgdG8gY29weSBub3RlcyBmcm9tICclcycgdG8gJyVzJyIKIG1zZ3N0ciAiTWlzc2x5Y2thZGVzIGtvcGllcmEgYW50ZWNrbmluZ2FyIGZyw6VuIFwiJXNcIiB0aWxsIFwiJXNcIiIKIAotIzogYnVpbHRpbi9hbS5jOjUzOAorIzogYnVpbHRpbi9hbS5jOjUzNwogbXNnaWQgImZzZWVrIGZhaWxlZCIKIG1zZ3N0ciAiXCJmc2Vla1wiIG1pc3NseWNrYWRlcyIKIAotIzogYnVpbHRpbi9hbS5jOjcyNgorIzogYnVpbHRpbi9hbS5jOjcyNQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcGFyc2UgcGF0Y2ggJyVzJyIKIG1zZ3N0ciAia3VuZGUgaW50ZSB0b2xrYSBwYXRjaGVuIFwiJXNcIiIKIAotIzogYnVpbHRpbi9hbS5jOjc5MQorIzogYnVpbHRpbi9hbS5jOjc5MAogbXNnaWQgIk9ubHkgb25lIFN0R0lUIHBhdGNoIHNlcmllcyBjYW4gYmUgYXBwbGllZCBhdCBvbmNlIgogbXNnc3RyICJFbmRhc3QgZW4gU3RHSVQtcGF0Y2hzZXJpZSBrYW4gdGlsbMOkbXBhcyDDpXQgZ8OlbmdlbiIKIAotIzogYnVpbHRpbi9hbS5jOjgzOQorIzogYnVpbHRpbi9hbS5jOjgzOAogbXNnaWQgImludmFsaWQgdGltZXN0YW1wIgogbXNnc3RyICJvZ2lsdGlnIHRpZHNzdMOkbXBlbCIKIAotIzogYnVpbHRpbi9hbS5jOjg0NCBidWlsdGluL2FtLmM6ODU2CisjOiBidWlsdGluL2FtLmM6ODQzIGJ1aWx0aW4vYW0uYzo4NTUKIG1zZ2lkICJpbnZhbGlkIERhdGUgbGluZSIKIG1zZ3N0ciAib2dpbHRpZyBcIkRhdGVcIi1yYWQiCiAKLSM6IGJ1aWx0aW4vYW0uYzo4NTEKKyM6IGJ1aWx0aW4vYW0uYzo4NTAKIG1zZ2lkICJpbnZhbGlkIHRpbWV6b25lIG9mZnNldCIKIG1zZ3N0ciAib2dpbHRpZyB0aWRzem9ucy1vZmZzZXQiCiAKLSM6IGJ1aWx0aW4vYW0uYzo5NDQKKyM6IGJ1aWx0aW4vYW0uYzo5NDMKIG1zZ2lkICJQYXRjaCBmb3JtYXQgZGV0ZWN0aW9uIGZhaWxlZC4iCiBtc2dzdHIgIk1pc3NseWNrYWRlcyBkZXRla3RlcmEgcGF0Y2hmb3JtYXQuIgogCi0jOiBidWlsdGluL2FtLmM6OTQ5IGJ1aWx0aW4vY2xvbmUuYzo0MDcKKyM6IGJ1aWx0aW4vYW0uYzo5NDggYnVpbHRpbi9jbG9uZS5jOjQwNgogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gY3JlYXRlIGRpcmVjdG9yeSAnJXMnIgogbXNnc3RyICJtaXNzbHlja2FkZXMgc2thcGEga2F0YWxvZ2VuIFwiJXNcIiIKIAotIzogYnVpbHRpbi9hbS5jOjk1NAorIzogYnVpbHRpbi9hbS5jOjk1MwogbXNnaWQgIkZhaWxlZCB0byBzcGxpdCBwYXRjaGVzLiIKIG1zZ3N0ciAiTWlzc2x5Y2thZGVzIGRlbGEgcGF0Y2hhci4iCiAKLSM6IGJ1aWx0aW4vYW0uYzoxMDg0IGJ1aWx0aW4vY29tbWl0LmM6Mzc0Ci1tc2dpZCAidW5hYmxlIHRvIHdyaXRlIGluZGV4IGZpbGUiCi1tc2dzdHIgImthbiBpbnRlIHNrcml2YSBpbmRleGZpbCIKLQotIzogYnVpbHRpbi9hbS5jOjEwOTgKKyM6IGJ1aWx0aW4vYW0uYzoxMDg0CiAjLCBjLWZvcm1hdAogbXNnaWQgIldoZW4geW91IGhhdmUgcmVzb2x2ZWQgdGhpcyBwcm9ibGVtLCBydW4gXCIlcyAtLWNvbnRpbnVlXCIuIgogbXNnc3RyICJOw6RyIGR1IGhhciBsw7ZzdCBwcm9ibGVtZXQsIGvDtnIgXCIlcyAtLWNvbnRpbnVlXCIuIgogCi0jOiBidWlsdGluL2FtLmM6MTA5OQorIzogYnVpbHRpbi9hbS5jOjEwODUKICMsIGMtZm9ybWF0CiBtc2dpZCAiSWYgeW91IHByZWZlciB0byBza2lwIHRoaXMgcGF0Y2gsIHJ1biBcIiVzIC0tc2tpcFwiIGluc3RlYWQuIgogbXNnc3RyICJPbSBkdSBoZWxscmUgdmlsbCBob3BwYSDDtnZlciBwYXRjaGVuLCBrw7ZyIFwiJXMgLS1za2lwXCIgaSBzdMOkbGxldC4iCiAKLSM6IGJ1aWx0aW4vYW0uYzoxMTAwCisjOiBidWlsdGluL2FtLmM6MTA4NgogIywgYy1mb3JtYXQKIG1zZ2lkICJUbyByZXN0b3JlIHRoZSBvcmlnaW5hbCBicmFuY2ggYW5kIHN0b3AgcGF0Y2hpbmcsIHJ1biBcIiVzIC0tYWJvcnRcIi4iCiBtc2dzdHIgIiIKICJGw7ZyIGF0dCDDpXRlcmfDpSB0aWxsIHVyc3BydW5nbGlnIGdyZW4gb2NoIHNsdXRhIHBhdGNoYSwga8O2ciBcIiVzIC0tYWJvcnRcIi4iCiAKLSM6IGJ1aWx0aW4vYW0uYzoxMTgzCisjOiBidWlsdGluL2FtLmM6MTE2OQogbXNnaWQgIlBhdGNoIHNlbnQgd2l0aCBmb3JtYXQ9Zmxvd2VkOyBzcGFjZSBhdCB0aGUgZW5kIG9mIGxpbmVzIG1pZ2h0IGJlIGxvc3QuIgogbXNnc3RyICIiCiAiUGF0Y2ggc8OkbmQgbWVkIGZvcm1hdD1mbG93ZWQ7IGJsYW5rc3RlZyBww6Ugc2x1dCBhdiByYWRlciBrYW4gaGEgdGFwcGF0cy4iCiAKLSM6IGJ1aWx0aW4vYW0uYzoxMjExCisjOiBidWlsdGluL2FtLmM6MTE5NwogbXNnaWQgIlBhdGNoIGlzIGVtcHR5LiIKIG1zZ3N0ciAiUGF0Y2hlbiDDpHIgdG9tLiIKIAotIzogYnVpbHRpbi9hbS5jOjEyNzcKKyM6IGJ1aWx0aW4vYW0uYzoxMjYyCisjLCBjLWZvcm1hdAorbXNnaWQgIm1pc3NpbmcgYXV0aG9yIGxpbmUgaW4gY29tbWl0ICVzIgorbXNnc3RyICJzYWtuYWQgXCJhdXRob3JcIi1yYWQgaSBpbmNoZWNrbmluZ2VuICVzIgorCisjOiBidWlsdGluL2FtLmM6MTI2NQogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIGlkZW50IGxpbmU6ICUuKnMiCiBtc2dzdHIgIm9naWx0aWcgaWRlbnQtcmFkOiAlLipzIgogCi0jOiBidWlsdGluL2FtLmM6MTI5OQotIywgYy1mb3JtYXQKLW1zZ2lkICJ1bmFibGUgdG8gcGFyc2UgY29tbWl0ICVzIgotbXNnc3RyICJrdW5kZSBpbnRlIHRvbGthIGluY2hlY2tuaW5nZW4gJXMiCi0KLSM6IGJ1aWx0aW4vYW0uYzoxNDk2CisjOiBidWlsdGluL2FtLmM6MTQ4NAogbXNnaWQgIlJlcG9zaXRvcnkgbGFja3MgbmVjZXNzYXJ5IGJsb2JzIHRvIGZhbGwgYmFjayBvbiAzLXdheSBtZXJnZS4iCiBtc2dzdHIgIiIKICJBcmtpdmV0IHNha25hciBvYmpla3Qgc29tIGJlaMO2dnMgZsO2ciBhdHQgZmFsbGEgdGlsbGJha2EgcMOlIDMtIgogInbDpGdzc2FtbWFuc2xhZ25pbmcuIgogCi0jOiBidWlsdGluL2FtLmM6MTQ5OAorIzogYnVpbHRpbi9hbS5jOjE0ODYKIG1zZ2lkICJVc2luZyBpbmRleCBpbmZvIHRvIHJlY29uc3RydWN0IGEgYmFzZSB0cmVlLi4uIgogbXNnc3RyICJBbnbDpG5kZXIgaW5kZXhpbmZvIGbDtnIgYXR0IMOldGVyc2thcGEgZXR0IGJhc3Ryw6RkLi4uIgogCi0jOiBidWlsdGluL2FtLmM6MTUxNworIzogYnVpbHRpbi9hbS5jOjE1MDUKIG1zZ2lkICIiCiAiRGlkIHlvdSBoYW5kIGVkaXQgeW91ciBwYXRjaD9cbiIKICJJdCBkb2VzIG5vdCBhcHBseSB0byBibG9icyByZWNvcmRlZCBpbiBpdHMgaW5kZXguIgpAQCAtODcxNSwyNSArODc1NCwyNSBAQAogIkhhciBkdSBoYW5kcmVkaWdlcmF0IGRpbiBwYXRjaD9cbiIKICJEZW4ga2FuIGludGUgdGlsbMOkbXBhcyBww6UgYmxvYmJhciBzb20gYW50ZWNrbmF0cyBpIGRlc3MgaW5kZXguIgogCi0jOiBidWlsdGluL2FtLmM6MTUyMworIzogYnVpbHRpbi9hbS5jOjE1MTEKIG1zZ2lkICJGYWxsaW5nIGJhY2sgdG8gcGF0Y2hpbmcgYmFzZSBhbmQgMy13YXkgbWVyZ2UuLi4iCiBtc2dzdHIgIiIKICJGYWxsZXIgdGlsbGJha2EgcMOlIGF0dCBwYXRjaGEgZ3J1bmR2ZXJzaW9uZW4gb2NoIHRyZXbDpGdzc2FtbWFuc2xhZ25pbmcuLi4iCiAKLSM6IGJ1aWx0aW4vYW0uYzoxNTQ5CisjOiBidWlsdGluL2FtLmM6MTUzNwogbXNnaWQgIkZhaWxlZCB0byBtZXJnZSBpbiB0aGUgY2hhbmdlcy4iCiBtc2dzdHIgIk1pc3NseWNrYWRlcyBzbMOlIGlob3Agw6RuZHJpbmdhcm5hLiIKIAotIzogYnVpbHRpbi9hbS5jOjE1ODEKKyM6IGJ1aWx0aW4vYW0uYzoxNTY5CiBtc2dpZCAiYXBwbHlpbmcgdG8gYW4gZW1wdHkgaGlzdG9yeSIKIG1zZ3N0ciAidGlsbMOkbXBhciBww6UgZW4gdG9tIGhpc3RvcmlrIgogCi0jOiBidWlsdGluL2FtLmM6MTYyOCBidWlsdGluL2FtLmM6MTYzMgorIzogYnVpbHRpbi9hbS5jOjE2MTYgYnVpbHRpbi9hbS5jOjE2MjAKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IHJlc3VtZTogJXMgZG9lcyBub3QgZXhpc3QuIgogbXNnc3RyICJrYW4gaW50ZSDDpXRlcnVwcHRhOiAlcyBmaW5ucyBpbnRlLiIKIAotIzogYnVpbHRpbi9hbS5jOjE2NTAKKyM6IGJ1aWx0aW4vYW0uYzoxNjM4CiBtc2dpZCAiQ29tbWl0IEJvZHkgaXM6IgogbXNnc3RyICJJbmNoZWNrbmluZ3Nrcm9wcGVuIMOkcjoiCiAKQEAgLTg3NDEsMzYgKzg3ODAsNDAgQEAKICMuIGluIHlvdXIgdHJhbnNsYXRpb24uIFRoZSBwcm9ncmFtIHdpbGwgb25seSBhY2NlcHQgRW5nbGlzaAogIy4gaW5wdXQgYXQgdGhpcyBwb2ludC4KICMuCi0jOiBidWlsdGluL2FtLmM6MTY2MAorIzogYnVpbHRpbi9hbS5jOjE2NDgKICMsIGMtZm9ybWF0CiBtc2dpZCAiQXBwbHk/IFt5XWVzL1tuXW8vW2VdZGl0L1t2XWlldyBwYXRjaC9bYV1jY2VwdCBhbGw6ICIKIG1zZ3N0ciAiVGlsbMOkbXBhPyBZPWphL049bmVqL0U9cmVkaWdlcmEvVj12aXNhIHBhdGNoL0E9Z29kdGEgYWxsYTogIgogCi0jOiBidWlsdGluL2FtLmM6MTcxMAorIzogYnVpbHRpbi9hbS5jOjE2OTUgYnVpbHRpbi9jb21taXQuYzozNzQKK21zZ2lkICJ1bmFibGUgdG8gd3JpdGUgaW5kZXggZmlsZSIKK21zZ3N0ciAia2FuIGludGUgc2tyaXZhIGluZGV4ZmlsIgorCisjOiBidWlsdGluL2FtLmM6MTY5OQogIywgYy1mb3JtYXQKIG1zZ2lkICJEaXJ0eSBpbmRleDogY2Fubm90IGFwcGx5IHBhdGNoZXMgKGRpcnR5OiAlcykiCiBtc2dzdHIgIlNtdXRzaWd0IGluZGV4OiBrYW4gaW50ZSB0aWxsw6RtcGEgcGF0Y2hhciAoc211dHNpZ2E6ICVzKSIKIAotIzogYnVpbHRpbi9hbS5jOjE3NTAgYnVpbHRpbi9hbS5jOjE4MTgKKyM6IGJ1aWx0aW4vYW0uYzoxNzM5IGJ1aWx0aW4vYW0uYzoxODA3CiAjLCBjLWZvcm1hdAogbXNnaWQgIkFwcGx5aW5nOiAlLipzIgogbXNnc3RyICJUaWxsw6RtcGFyOiAlLipzIgogCi0jOiBidWlsdGluL2FtLmM6MTc2NworIzogYnVpbHRpbi9hbS5jOjE3NTYKIG1zZ2lkICJObyBjaGFuZ2VzIC0tIFBhdGNoIGFscmVhZHkgYXBwbGllZC4iCiBtc2dzdHIgIkluZ2Egw6RuZHJpbmdhciAtLSBQYXRjaGVuIGhhciByZWRhbiB0aWxsw6RtcGF0cy4iCiAKLSM6IGJ1aWx0aW4vYW0uYzoxNzczCisjOiBidWlsdGluL2FtLmM6MTc2MgogIywgYy1mb3JtYXQKIG1zZ2lkICJQYXRjaCBmYWlsZWQgYXQgJXMgJS4qcyIKIG1zZ3N0ciAiUGF0Y2ggbWlzc2x5Y2thZGVzIHDDpSAlcyAlLipzIgogCi0jOiBidWlsdGluL2FtLmM6MTc3NworIzogYnVpbHRpbi9hbS5jOjE3NjYKIG1zZ2lkICJVc2UgJ2dpdCBhbSAtLXNob3ctY3VycmVudC1wYXRjaCcgdG8gc2VlIHRoZSBmYWlsZWQgcGF0Y2giCiBtc2dzdHIgIiIKICJBbnbDpG5kIFwiZ2l0IGFtIC0tc2hvdy1jdXJyZW50LXBhdGNoXCIgZsO2ciBhdHQgc2UgcGF0Y2hlbiBzb20gbWlzc2x5Y2thZGVzIgogCi0jOiBidWlsdGluL2FtLmM6MTgyMQorIzogYnVpbHRpbi9hbS5jOjE4MTAKIG1zZ2lkICIiCiAiTm8gY2hhbmdlcyAtIGRpZCB5b3UgZm9yZ2V0IHRvIHVzZSAnZ2l0IGFkZCc/XG4iCiAiSWYgdGhlcmUgaXMgbm90aGluZyBsZWZ0IHRvIHN0YWdlLCBjaGFuY2VzIGFyZSB0aGF0IHNvbWV0aGluZyBlbHNlXG4iCkBAIC04NzgwLDcgKzg4MjMsNyBAQAogIk9tIGRldCBpbnRlIMOkciBuw6Vnb3Qga3ZhciBhdHQga8O2YSBrYW4gZGV0IGjDpG5kYSBhdHQgbsOlZ290IGFubmF0IHJlZGFuXG4iCiAiaW50cm9kdWNlcmF0IHNhbW1hIMOkbmRyaW5nYXI7IGthbnNrZSBkdSBiw7ZyIGhvcHBhIMO2dmVyIHBhdGNoZW4uIgogCi0jOiBidWlsdGluL2FtLmM6MTgyOAorIzogYnVpbHRpbi9hbS5jOjE4MTcKIG1zZ2lkICIiCiAiWW91IHN0aWxsIGhhdmUgdW5tZXJnZWQgcGF0aHMgaW4geW91ciBpbmRleC5cbiIKICJZb3Ugc2hvdWxkICdnaXQgYWRkJyBlYWNoIGZpbGUgd2l0aCByZXNvbHZlZCBjb25mbGljdHMgdG8gbWFyayB0aGVtIGFzICIKQEAgLTg3OTIsMTcgKzg4MzUsMTcgQEAKICJsw7ZzdGEuXG4iCiAiRHUga2FuIGvDtnJhIFwiZ2l0IHJtXCIgZsO2ciBhdHQgZ29kdGEgXCJib3J0dGFnZW4gYXYgZGVtXCIgZsO2ciBkZW4uIgogCi0jOiBidWlsdGluL2FtLmM6MTkzNSBidWlsdGluL2FtLmM6MTkzOSBidWlsdGluL2FtLmM6MTk1MSBidWlsdGluL3Jlc2V0LmM6MzI5CisjOiBidWlsdGluL2FtLmM6MTkyNCBidWlsdGluL2FtLmM6MTkyOCBidWlsdGluL2FtLmM6MTk0MCBidWlsdGluL3Jlc2V0LmM6MzI5CiAjOiBidWlsdGluL3Jlc2V0LmM6MzM3CiAjLCBjLWZvcm1hdAogbXNnaWQgIkNvdWxkIG5vdCBwYXJzZSBvYmplY3QgJyVzJy4iCiBtc2dzdHIgIkthbiBpbnRlIHRvbGthIG9iamVrdGV0IFwiJXNcIi4iCiAKLSM6IGJ1aWx0aW4vYW0uYzoxOTg3CisjOiBidWlsdGluL2FtLmM6MTk3NgogbXNnaWQgImZhaWxlZCB0byBjbGVhbiBpbmRleCIKIG1zZ3N0ciAibWlzc2x5Y2thZGVzIHN0w6RkYSB1cHAgaW5kZXhldCIKIAotIzogYnVpbHRpbi9hbS5jOjIwMzEKKyM6IGJ1aWx0aW4vYW0uYzoyMDIwCiBtc2dpZCAiIgogIllvdSBzZWVtIHRvIGhhdmUgbW92ZWQgSEVBRCBzaW5jZSB0aGUgbGFzdCAnYW0nIGZhaWx1cmUuXG4iCiAiTm90IHJld2luZGluZyB0byBPUklHX0hFQUQiCkBAIC04ODEwLDE0MyArODg1MywxNDMgQEAKICJEdSB2ZXJrYXIgaGEgZmx5dHRhdCBIRUFEIHNlZGFuIFwiYW1cIiBzaXN0IG1pc3NseWNrYWRlcy5cbiIKICLDhXRlcnN0w6RsbGVyIGludGUgdGlsbCBPUklHX0hFQUQiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMTI4CisjOiBidWlsdGluL2FtLmM6MjExNwogIywgYy1mb3JtYXQKIG1zZ2lkICJJbnZhbGlkIHZhbHVlIGZvciAtLXBhdGNoLWZvcm1hdDogJXMiCiBtc2dzdHIgIkZlbGFrdGlndCB2w6RyZGUgZsO2ciAtLXBhdGNoLWZvcm1hdDogJXMiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMTY0CisjOiBidWlsdGluL2FtLmM6MjE1MwogbXNnaWQgImdpdCBhbSBbPG9wdGlvbnM+XSBbKDxtYm94PiB8IDxNYWlsZGlyPikuLi5dIgogbXNnc3RyICJnaXQgYW0gWzxmbGFnZ29yPl0gWyg8bWJveD4gfCA8TWFpbGRpcj4pLi4uXSIKIAotIzogYnVpbHRpbi9hbS5jOjIxNjUKKyM6IGJ1aWx0aW4vYW0uYzoyMTU0CiBtc2dpZCAiZ2l0IGFtIFs8b3B0aW9ucz5dICgtLWNvbnRpbnVlIHwgLS1za2lwIHwgLS1hYm9ydCkiCiBtc2dzdHIgImdpdCBhbSBbPGZsYWdnb3I+XSAoLS1jb250aW51ZSB8IC0tc2tpcCB8IC0tYWJvcnQpIgogCi0jOiBidWlsdGluL2FtLmM6MjE3MQorIzogYnVpbHRpbi9hbS5jOjIxNjAKIG1zZ2lkICJydW4gaW50ZXJhY3RpdmVseSIKIG1zZ3N0ciAia8O2ciBpbnRlcmFrdGl2dCIKIAotIzogYnVpbHRpbi9hbS5jOjIxNzMKKyM6IGJ1aWx0aW4vYW0uYzoyMTYyCiBtc2dpZCAiaGlzdG9yaWNhbCBvcHRpb24gLS0gbm8tb3AiCiBtc2dzdHIgImhpc3RvcmlzayBmbGFnZ2EgLS0gbm8tb3AiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMTc1CisjOiBidWlsdGluL2FtLmM6MjE2NAogbXNnaWQgImFsbG93IGZhbGwgYmFjayBvbiAzd2F5IG1lcmdpbmcgaWYgbmVlZGVkIgogbXNnc3RyICJ0aWxsw6V0IGZhbGxhIHRpbGxiYWthIHDDpSB0cmV2w6Rnc3NhbW1hbnNsYWduaW5nIG9tIG7DtmR2w6RuZGlndCIKIAotIzogYnVpbHRpbi9hbS5jOjIxNzYgYnVpbHRpbi9pbml0LWRiLmM6NDk0IGJ1aWx0aW4vcHJ1bmUtcGFja2VkLmM6NTgKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MzA3IGJ1aWx0aW4vc3Rhc2guYzo4MDYKKyM6IGJ1aWx0aW4vYW0uYzoyMTY1IGJ1aWx0aW4vaW5pdC1kYi5jOjQ5NCBidWlsdGluL3BydW5lLXBhY2tlZC5jOjU4CisjOiBidWlsdGluL3JlcGFjay5jOjI5NyBidWlsdGluL3N0YXNoLmM6ODEyCiBtc2dpZCAiYmUgcXVpZXQiCiBtc2dzdHIgInZhciB0eXN0IgogCi0jOiBidWlsdGluL2FtLmM6MjE3OAorIzogYnVpbHRpbi9hbS5jOjIxNjcKIG1zZ2lkICJhZGQgYSBTaWduZWQtb2ZmLWJ5IGxpbmUgdG8gdGhlIGNvbW1pdCBtZXNzYWdlIgogbXNnc3RyICJsw6RnZyB0aWxsIFwiU2lnbmVkLW9mZi1ieVwiLXJhZCBpIGluY2hlY2tuaW5nc21lZGRlbGFuZGV0IgogCi0jOiBidWlsdGluL2FtLmM6MjE4MQorIzogYnVpbHRpbi9hbS5jOjIxNzAKIG1zZ2lkICJyZWNvZGUgaW50byB1dGY4IChkZWZhdWx0KSIKIG1zZ3N0ciAia29kYSBvbSB0aWxsIHV0ZjggKHN0YW5kYXJkKSIKIAotIzogYnVpbHRpbi9hbS5jOjIxODMKKyM6IGJ1aWx0aW4vYW0uYzoyMTcyCiBtc2dpZCAicGFzcyAtayBmbGFnIHRvIGdpdC1tYWlsaW5mbyIKIG1zZ3N0ciAic8OkbmQgZmxhZ2dhbiAtayB0aWxsIGdpdC1tYWlsaW5mbyIKIAotIzogYnVpbHRpbi9hbS5jOjIxODUKKyM6IGJ1aWx0aW4vYW0uYzoyMTc0CiBtc2dpZCAicGFzcyAtYiBmbGFnIHRvIGdpdC1tYWlsaW5mbyIKIG1zZ3N0ciAic8OkbmQgZmxhZ2dhbiAtYiB0aWxsIGdpdC1tYWlsaW5mbyIKIAotIzogYnVpbHRpbi9hbS5jOjIxODcKKyM6IGJ1aWx0aW4vYW0uYzoyMTc2CiBtc2dpZCAicGFzcyAtbSBmbGFnIHRvIGdpdC1tYWlsaW5mbyIKIG1zZ3N0ciAic8OkbmQgZmxhZ2dhbiAtbSB0aWxsIGdpdC1tYWlsaW5mbyIKIAotIzogYnVpbHRpbi9hbS5jOjIxODkKKyM6IGJ1aWx0aW4vYW0uYzoyMTc4CiBtc2dpZCAicGFzcyAtLWtlZXAtY3IgZmxhZyB0byBnaXQtbWFpbHNwbGl0IGZvciBtYm94IGZvcm1hdCIKIG1zZ3N0ciAic8OkbmQgZmxhZ2dhbiAtLWtlZXAtY3IgdGlsbCBnaXQtbWFpbHNwbGl0IGbDtnIgbWJveC1mb3JtYXRldCIKIAotIzogYnVpbHRpbi9hbS5jOjIxOTIKKyM6IGJ1aWx0aW4vYW0uYzoyMTgxCiBtc2dpZCAiZG8gbm90IHBhc3MgLS1rZWVwLWNyIGZsYWcgdG8gZ2l0LW1haWxzcGxpdCBpbmRlcGVuZGVudCBvZiBhbS5rZWVwY3IiCiBtc2dzdHIgInPDpG5kIGludGUgZmxhZ2dhbiAtLWtlZXAtY3IgdGlsbCBnaXQtbWFpbHNwbGl0IG9iZXJvZW5kZSBhdiBhbS5rZWVwY3IiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMTk1CisjOiBidWlsdGluL2FtLmM6MjE4NAogbXNnaWQgInN0cmlwIGV2ZXJ5dGhpbmcgYmVmb3JlIGEgc2Npc3NvcnMgbGluZSIKIG1zZ3N0ciAidGEgYm9ydCBhbGx0aW5nIGbDtnJlIGVuIHNheGxpbmplIgogCi0jOiBidWlsdGluL2FtLmM6MjE5NyBidWlsdGluL2FtLmM6MjIwMCBidWlsdGluL2FtLmM6MjIwMyBidWlsdGluL2FtLmM6MjIwNgotIzogYnVpbHRpbi9hbS5jOjIyMDkgYnVpbHRpbi9hbS5jOjIyMTIgYnVpbHRpbi9hbS5jOjIyMTUgYnVpbHRpbi9hbS5jOjIyMTgKLSM6IGJ1aWx0aW4vYW0uYzoyMjI0CisjOiBidWlsdGluL2FtLmM6MjE4NiBidWlsdGluL2FtLmM6MjE4OSBidWlsdGluL2FtLmM6MjE5MiBidWlsdGluL2FtLmM6MjE5NQorIzogYnVpbHRpbi9hbS5jOjIxOTggYnVpbHRpbi9hbS5jOjIyMDEgYnVpbHRpbi9hbS5jOjIyMDQgYnVpbHRpbi9hbS5jOjIyMDcKKyM6IGJ1aWx0aW4vYW0uYzoyMjEzCiBtc2dpZCAicGFzcyBpdCB0aHJvdWdoIGdpdC1hcHBseSIKIG1zZ3N0ciAic8OkbmQgZGV0IGdlbm9tIGdpdC1hcHBseSIKIAotIzogYnVpbHRpbi9hbS5jOjIyMTQgYnVpbHRpbi9jb21taXQuYzoxMzY4IGJ1aWx0aW4vZm10LW1lcmdlLW1zZy5jOjY3MQotIzogYnVpbHRpbi9mbXQtbWVyZ2UtbXNnLmM6Njc0IGJ1aWx0aW4vZ3JlcC5jOjg4MSBidWlsdGluL21lcmdlLmM6MjQ5Ci0jOiBidWlsdGluL3B1bGwuYzoxNTkgYnVpbHRpbi9wdWxsLmM6MjE4IGJ1aWx0aW4vcmViYXNlLmM6MTQxOAotIzogYnVpbHRpbi9yZXBhY2suYzozMTggYnVpbHRpbi9yZXBhY2suYzozMjIgYnVpbHRpbi9yZXBhY2suYzozMjQKKyM6IGJ1aWx0aW4vYW0uYzoyMjAzIGJ1aWx0aW4vY29tbWl0LmM6MTM2OCBidWlsdGluL2ZtdC1tZXJnZS1tc2cuYzo2NzEKKyM6IGJ1aWx0aW4vZm10LW1lcmdlLW1zZy5jOjY3NCBidWlsdGluL2dyZXAuYzo4ODMgYnVpbHRpbi9tZXJnZS5jOjI0OQorIzogYnVpbHRpbi9wdWxsLmM6MTYwIGJ1aWx0aW4vcHVsbC5jOjIxOSBidWlsdGluL3JlYmFzZS5jOjE0NDIKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6MzA4IGJ1aWx0aW4vcmVwYWNrLmM6MzEyIGJ1aWx0aW4vcmVwYWNrLmM6MzE0CiAjOiBidWlsdGluL3Nob3ctYnJhbmNoLmM6NjUwIGJ1aWx0aW4vc2hvdy1yZWYuYzoxNzIgYnVpbHRpbi90YWcuYzo0MDMKLSM6IHBhcnNlLW9wdGlvbnMuaDoxNDEgcGFyc2Utb3B0aW9ucy5oOjE2MiBwYXJzZS1vcHRpb25zLmg6MzEyCisjOiBwYXJzZS1vcHRpb25zLmg6MTUwIHBhcnNlLW9wdGlvbnMuaDoxNzEgcGFyc2Utb3B0aW9ucy5oOjMxMgogbXNnaWQgIm4iCiBtc2dzdHIgIm4iCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMjIwIGJ1aWx0aW4vYnJhbmNoLmM6NjYxIGJ1aWx0aW4vZm9yLWVhY2gtcmVmLmM6MzgKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU1NCBidWlsdGluL3RhZy5jOjQzNyBidWlsdGluL3ZlcmlmeS10YWcuYzozOQorIzogYnVpbHRpbi9hbS5jOjIyMDkgYnVpbHRpbi9icmFuY2guYzo2NjEgYnVpbHRpbi9mb3ItZWFjaC1yZWYuYzozOAorIzogYnVpbHRpbi9yZXBsYWNlLmM6NTU1IGJ1aWx0aW4vdGFnLmM6NDM3IGJ1aWx0aW4vdmVyaWZ5LXRhZy5jOjM4CiBtc2dpZCAiZm9ybWF0IgogbXNnc3RyICJmb3JtYXQiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMjIxCisjOiBidWlsdGluL2FtLmM6MjIxMAogbXNnaWQgImZvcm1hdCB0aGUgcGF0Y2goZXMpIGFyZSBpbiIKIG1zZ3N0ciAiZm9ybWF0IGbDtnIgcGF0Y2goYXIpIgogCi0jOiBidWlsdGluL2FtLmM6MjIyNworIzogYnVpbHRpbi9hbS5jOjIyMTYKIG1zZ2lkICJvdmVycmlkZSBlcnJvciBtZXNzYWdlIHdoZW4gcGF0Y2ggZmFpbHVyZSBvY2N1cnMiCiBtc2dzdHIgIsO2dmVyc3R5ciBmZWxtZWRkZWxhbmRlbiBuw6RyIHBhdGNoZmVsIHVwcHN0w6VyIgogCi0jOiBidWlsdGluL2FtLmM6MjIyOQorIzogYnVpbHRpbi9hbS5jOjIyMTgKIG1zZ2lkICJjb250aW51ZSBhcHBseWluZyBwYXRjaGVzIGFmdGVyIHJlc29sdmluZyBhIGNvbmZsaWN0IgogbXNnc3RyICJmb3J0c8OkdHQgYXBwbGljZXJhIHBhdGNoYXIgZWZ0ZXIgYXR0IGhhIGzDtnN0IGVuIGtvbmZsaWt0IgogCi0jOiBidWlsdGluL2FtLmM6MjIzMgorIzogYnVpbHRpbi9hbS5jOjIyMjEKIG1zZ2lkICJzeW5vbnltcyBmb3IgLS1jb250aW51ZSIKIG1zZ3N0ciAic3lub255bWVyIHRpbGwgLS1jb250aW51ZSIKIAotIzogYnVpbHRpbi9hbS5jOjIyMzUKKyM6IGJ1aWx0aW4vYW0uYzoyMjI0CiBtc2dpZCAic2tpcCB0aGUgY3VycmVudCBwYXRjaCIKIG1zZ3N0ciAiaG9wcGEgw7Z2ZXIgZGVuIGFrdHVlbGxhIGdyZW5lbiIKIAotIzogYnVpbHRpbi9hbS5jOjIyMzgKKyM6IGJ1aWx0aW4vYW0uYzoyMjI3CiBtc2dpZCAicmVzdG9yZSB0aGUgb3JpZ2luYWwgYnJhbmNoIGFuZCBhYm9ydCB0aGUgcGF0Y2hpbmcgb3BlcmF0aW9uLiIKIG1zZ3N0ciAiw6V0ZXJzdMOkbGwgb3JpZ2luYWxncmVuZW4gb2NoIGF2YnJ5dCBwYXRjaG5pbmdlbi4iCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMjQxCisjOiBidWlsdGluL2FtLmM6MjIzMAogbXNnaWQgImFib3J0IHRoZSBwYXRjaGluZyBvcGVyYXRpb24gYnV0IGtlZXAgSEVBRCB3aGVyZSBpdCBpcy4iCiBtc2dzdHIgImF2YnJ5dCBwYXRjaG5pbmdlbiBtZW4gYmVow6VsbCBIRUFEIGTDpHIgZGV0IMOkci4iCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMjQ0CisjOiBidWlsdGluL2FtLmM6MjIzMwogbXNnaWQgInNob3cgdGhlIHBhdGNoIGJlaW5nIGFwcGxpZWQuIgogbXNnc3RyICJ2aXNhIHBhdGNoZW4gc29tIHRpbGzDpG1wYXMuIgogCi0jOiBidWlsdGluL2FtLmM6MjI0OAorIzogYnVpbHRpbi9hbS5jOjIyMzcKIG1zZ2lkICJsaWUgYWJvdXQgY29tbWl0dGVyIGRhdGUiCiBtc2dzdHIgImxqdWcgb20gaW5jaGVja25pbmdzZGF0dW0iCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMjUwCisjOiBidWlsdGluL2FtLmM6MjIzOQogbXNnaWQgInVzZSBjdXJyZW50IHRpbWVzdGFtcCBmb3IgYXV0aG9yIGRhdGUiCiBtc2dzdHIgImFudsOkbmQgbnV2YXJhbmRlIHRpZHNzdMOkbXBlbCBmw7ZyIGbDtnJmYXR0YXJkYXR1bSIKIAotIzogYnVpbHRpbi9hbS5jOjIyNTIgYnVpbHRpbi9jb21taXQtdHJlZS5jOjEyMCBidWlsdGluL2NvbW1pdC5jOjE1MTEKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoyODYgYnVpbHRpbi9wdWxsLmM6MTkzIGJ1aWx0aW4vcmViYXNlLmM6NDg5Ci0jOiBidWlsdGluL3JlYmFzZS5jOjE0NTkgYnVpbHRpbi9yZXZlcnQuYzoxMTcgYnVpbHRpbi90YWcuYzo0MTgKKyM6IGJ1aWx0aW4vYW0uYzoyMjQxIGJ1aWx0aW4vY29tbWl0LXRyZWUuYzoxMjAgYnVpbHRpbi9jb21taXQuYzoxNTExCisjOiBidWlsdGluL21lcmdlLmM6Mjg2IGJ1aWx0aW4vcHVsbC5jOjE5NCBidWlsdGluL3JlYmFzZS5jOjQ5MAorIzogYnVpbHRpbi9yZWJhc2UuYzoxNDgzIGJ1aWx0aW4vcmV2ZXJ0LmM6MTE3IGJ1aWx0aW4vdGFnLmM6NDE4CiBtc2dpZCAia2V5LWlkIgogbXNnc3RyICJueWNrZWwtaWQiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMjUzIGJ1aWx0aW4vcmViYXNlLmM6NDkwIGJ1aWx0aW4vcmViYXNlLmM6MTQ2MAorIzogYnVpbHRpbi9hbS5jOjIyNDIgYnVpbHRpbi9yZWJhc2UuYzo0OTEgYnVpbHRpbi9yZWJhc2UuYzoxNDg0CiBtc2dpZCAiR1BHLXNpZ24gY29tbWl0cyIKIG1zZ3N0ciAiR1BHLXNpZ25lcmEgaW5jaGVja25pbmdhciIKIAotIzogYnVpbHRpbi9hbS5jOjIyNTYKKyM6IGJ1aWx0aW4vYW0uYzoyMjQ1CiBtc2dpZCAiKGludGVybmFsIHVzZSBmb3IgZ2l0LXJlYmFzZSkiCiBtc2dzdHIgIihhbnbDpG5kcyBpbnRlcm50IGF2IGdpdC1yZWJhc2UpIgogCi0jOiBidWlsdGluL2FtLmM6MjI3NAorIzogYnVpbHRpbi9hbS5jOjIyNjMKIG1zZ2lkICIiCiAiVGhlIC1iLy0tYmluYXJ5IG9wdGlvbiBoYXMgYmVlbiBhIG5vLW9wIGZvciBsb25nIHRpbWUsIGFuZFxuIgogIml0IHdpbGwgYmUgcmVtb3ZlZC4gUGxlYXNlIGRvIG5vdCB1c2UgaXQgYW55bW9yZS4iCkBAIC04OTU0LDE2ICs4OTk3LDE2IEBACiAiRmxhZ2dhbiAtYi8tLWJpbmFyeSBoYXIgdmFyaXQgdXRhbiBmdW5rdGlvbiBsw6RuZ2UsIG9jaFxuIgogImtvbW1lciB0YXMgYm9ydC4gVmkgYmVyIGRpZyBhdHQgaW50ZSBhbnbDpG5kYSBkZW4gbMOkbmdyZS4iCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMjgxCisjOiBidWlsdGluL2FtLmM6MjI3MAogbXNnaWQgImZhaWxlZCB0byByZWFkIHRoZSBpbmRleCIKIG1zZ3N0ciAibWlzc2x5Y2thZGVzIGzDpHNhIGluZGV4ZXQiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMjk2CisjOiBidWlsdGluL2FtLmM6MjI4NQogIywgYy1mb3JtYXQKIG1zZ2lkICJwcmV2aW91cyByZWJhc2UgZGlyZWN0b3J5ICVzIHN0aWxsIGV4aXN0cyBidXQgbWJveCBnaXZlbi4iCiBtc2dzdHIgInRpZGlnYXJlIHJlYmFzZS1rYXRhbG9nICVzIGZpbm5zIGZvcnRmYXJhbmRlLCBtZW4gbWJveCBhbmdhdnMuIgogCi0jOiBidWlsdGluL2FtLmM6MjMyMAorIzogYnVpbHRpbi9hbS5jOjIzMDkKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlN0cmF5ICVzIGRpcmVjdG9yeSBmb3VuZC5cbiIKQEAgLTg5NzIsMTEgKzkwMTUsMTEgQEAKICJLdmFyYmxpdmVuIGthdGFsb2cgJXMgaGl0dGFkZXMuXG4iCiAiQW52w6RuZCBcImdpdCBhbSAtLWFib3J0XCIgZsO2ciBhdHQgdGEgYm9ydCBkZW4uIgogCi0jOiBidWlsdGluL2FtLmM6MjMyNgorIzogYnVpbHRpbi9hbS5jOjIzMTUKIG1zZ2lkICJSZXNvbHZlIG9wZXJhdGlvbiBub3QgaW4gcHJvZ3Jlc3MsIHdlIGFyZSBub3QgcmVzdW1pbmcuIgogbXNnc3RyICJMw7ZzbmluZ3NvcGVyYXRpb24gcMOlZ8OlciBpbnRlLCB2aSDDpXRlcnVwcHRhciBpbnRlLiIKIAotIzogYnVpbHRpbi9hbS5jOjIzMzYKKyM6IGJ1aWx0aW4vYW0uYzoyMzI1CiBtc2dpZCAiaW50ZXJhY3RpdmUgbW9kZSByZXF1aXJlcyBwYXRjaGVzIG9uIHRoZSBjb21tYW5kIGxpbmUiCiBtc2dzdHIgImludGVyYWt0aXZ0IGzDpGdlIGtyw6R2ZXIgcGF0Y2hhciBww6Uga29tbWFuZG9yYWRlbiIKIApAQCAtOTIwMCw3ICs5MjQzLDggQEAKICM6IGJ1aWx0aW4vYmlzZWN0LS1oZWxwZXIuYzo1MjYKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2hlY2tpbmcgb3V0ICclcycgZmFpbGVkLiBUcnkgJ2dpdCBiaXNlY3Qgc3RhcnQgPHZhbGlkLWJyYW5jaD4nLiIKLW1zZ3N0ciAibWlzc2x5Y2thZGVzIGNoZWNrYSB1dCBcIiVzXCIuIEbDtnJzw7ZrIFwiZ2l0IGJpc2VjdCByZXNldCA8Z2lsdGlnX2dyZW4+XCIuIgorbXNnc3RyICIiCisibWlzc2x5Y2thZGVzIGNoZWNrYSB1dCBcIiVzXCIuIEbDtnJzw7ZrIFwiZ2l0IGJpc2VjdCByZXNldCA8Z2lsdGlnX2dyZW4+XCIuIgogCiAjIGNvZ2l0by1yZWxhdGVyYXQKICM6IGJ1aWx0aW4vYmlzZWN0LS1oZWxwZXIuYzo1NDcKQEAgLTkyOTIsMTU0ICs5MzM2LDE1NCBAQAogbXNnaWQgIi0tYmlzZWN0LXRlcm1zIHJlcXVpcmVzIDAgb3IgMSBhcmd1bWVudCIKIG1zZ3N0ciAiLS1iaXNlY3QtdGVybXMga3LDpHZlciBub2xsIGVsbGVyIGV0dCBhcmd1bWVudCIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjMyCisjOiBidWlsdGluL2JsYW1lLmM6MzEKIG1zZ2lkICJnaXQgYmxhbWUgWzxvcHRpb25zPl0gWzxyZXYtb3B0cz5dIFs8cmV2Pl0gWy0tXSA8ZmlsZT4iCiBtc2dzdHIgImdpdCBibGFtZSBbPGZsYWdnb3I+XSBbPHJldi1mbGFnZ29yPl0gWzxyZXY+XSBbLS1dIDxmaWw+IgogCi0jOiBidWlsdGluL2JsYW1lLmM6MzcKKyM6IGJ1aWx0aW4vYmxhbWUuYzozNgogbXNnaWQgIjxyZXYtb3B0cz4gYXJlIGRvY3VtZW50ZWQgaW4gZ2l0LXJldi1saXN0KDEpIgogbXNnc3RyICI8cmV2LWZsYWdnb3I+IGRva3VtZW50ZXJhcyBpIGdpdC1yZXYtbGlzdCgxKSIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjQxMAorIzogYnVpbHRpbi9ibGFtZS5jOjQwOQogIywgYy1mb3JtYXQKIG1zZ2lkICJleHBlY3RpbmcgYSBjb2xvcjogJXMiCiBtc2dzdHIgImbDtnJ2w6RudGFkZSBlbiBmw6RyZzogJXMiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo0MTcKKyM6IGJ1aWx0aW4vYmxhbWUuYzo0MTYKIG1zZ2lkICJtdXN0IGVuZCB3aXRoIGEgY29sb3IiCiBtc2dzdHIgIm3DpXN0ZSBzbHV0YSBtZWQgZW4gZsOkcmciCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo3MzAKKyM6IGJ1aWx0aW4vYmxhbWUuYzo3MjkKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBjb2xvciAnJXMnIGluIGNvbG9yLmJsYW1lLnJlcGVhdGVkTGluZXMiCiBtc2dzdHIgImZlbGFrdGlnIGbDpHJnIFwiJXNcIiBpIGNvbG9yLmJsYW1lLnJlcGVhdGVkTGluZXMiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo3NDgKKyM6IGJ1aWx0aW4vYmxhbWUuYzo3NDcKIG1zZ2lkICJpbnZhbGlkIHZhbHVlIGZvciBibGFtZS5jb2xvcmluZyIKIG1zZ3N0ciAib2dpbHRpZ3QgdsOkcmRlIGbDtnIgYmxhbWUuY29sb3JpbmciCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4MjMKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4MjIKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IGZpbmQgcmV2aXNpb24gJXMgdG8gaWdub3JlIgogbXNnc3RyICJrYW4gaW50ZSBoaXR0YSByZXZpc2lvbiAlcyBhdHQgaWdub3JlcmEiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NDUKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NDQKIG1zZ2lkICJTaG93IGJsYW1lIGVudHJpZXMgYXMgd2UgZmluZCB0aGVtLCBpbmNyZW1lbnRhbGx5IgogbXNnc3RyICJWaXNhIGtsYW5kcmluZ3Nwb3N0ZXIgbsOkciB2aSBoaXR0YXIgZGVtLCBpbnRlcmFrdGl2dCIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg0NgorIzogYnVpbHRpbi9ibGFtZS5jOjg0NQogbXNnaWQgIlNob3cgYmxhbmsgU0hBLTEgZm9yIGJvdW5kYXJ5IGNvbW1pdHMgKERlZmF1bHQ6IG9mZikiCiBtc2dzdHIgIlZpc2EgYmxhbmsgU0hBLTEgZsO2ciBncsOkbnNpbmNoZWNrbmluZ2FyIChTdGFuZGFyZDogYXYpIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODQ3CisjOiBidWlsdGluL2JsYW1lLmM6ODQ2CiBtc2dpZCAiRG8gbm90IHRyZWF0IHJvb3QgY29tbWl0cyBhcyBib3VuZGFyaWVzIChEZWZhdWx0OiBvZmYpIgogbXNnc3RyICJCZWhhbmRsYSBpbnRlIHJvdGluY2hlY2tuaW5nYXIgc29tIGdyw6Ruc2VyIChTdGFuZGFyZDogYXYpIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODQ4CisjOiBidWlsdGluL2JsYW1lLmM6ODQ3CiBtc2dpZCAiU2hvdyB3b3JrIGNvc3Qgc3RhdGlzdGljcyIKIG1zZ3N0ciAiVmlzYSBzdGF0aXN0aWsgw7Z2ZXIgYXJiZXRza29zdG5hZCIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg0OQorIzogYnVpbHRpbi9ibGFtZS5jOjg0OAogbXNnaWQgIkZvcmNlIHByb2dyZXNzIHJlcG9ydGluZyIKIG1zZ3N0ciAiVHZpbmdhIGbDtnJsb3Bwc3JhcHBvcnRlcmluZyIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg1MAorIzogYnVpbHRpbi9ibGFtZS5jOjg0OQogbXNnaWQgIlNob3cgb3V0cHV0IHNjb3JlIGZvciBibGFtZSBlbnRyaWVzIgogbXNnc3RyICJWaXNhIHV0ZGF0YXBvw6RuZyBmw7ZyIGtsYW5kcmluZ3Nwb3N0ZXIiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NTEKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NTAKIG1zZ2lkICJTaG93IG9yaWdpbmFsIGZpbGVuYW1lIChEZWZhdWx0OiBhdXRvKSIKIG1zZ3N0ciAiVmlzYSBvcmlnaW5hbGZpbG5hbW4gKFN0YW5kYXJkOiBhdXRvKSIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg1MgorIzogYnVpbHRpbi9ibGFtZS5jOjg1MQogbXNnaWQgIlNob3cgb3JpZ2luYWwgbGluZW51bWJlciAoRGVmYXVsdDogb2ZmKSIKIG1zZ3N0ciAiVmlzYSB1cnNwcnVuZ2xpZ3QgcmFkbnVtbWVyIChTdGFuZGFyZDogYXYpIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODUzCisjOiBidWlsdGluL2JsYW1lLmM6ODUyCiBtc2dpZCAiU2hvdyBpbiBhIGZvcm1hdCBkZXNpZ25lZCBmb3IgbWFjaGluZSBjb25zdW1wdGlvbiIKIG1zZ3N0ciAiVmlzYSBpIGV0dCBmb3JtYXQgYXZzZXR0IGbDtnIgbWFza2lua29uc3VtdGlvbiIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg1NAorIzogYnVpbHRpbi9ibGFtZS5jOjg1MwogbXNnaWQgIlNob3cgcG9yY2VsYWluIGZvcm1hdCB3aXRoIHBlci1saW5lIGNvbW1pdCBpbmZvcm1hdGlvbiIKIG1zZ3N0ciAiVmlzYSBwb3JzbGluc2Zvcm1hdCBtZWQgcGVyLXJhZC1pbmNoZWNrbmluZ3NpbmZvcm1hdGlvbiIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg1NQorIzogYnVpbHRpbi9ibGFtZS5jOjg1NAogbXNnaWQgIlVzZSB0aGUgc2FtZSBvdXRwdXQgbW9kZSBhcyBnaXQtYW5ub3RhdGUgKERlZmF1bHQ6IG9mZikiCiBtc2dzdHIgIkFudsOkbmQgc2FtbWEgdXRkYXRhbMOkZ2Ugc29tIGdpdC1hbm5vdGF0ZSAoU3RhbmRhcmQ6IGF2KSIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg1NgorIzogYnVpbHRpbi9ibGFtZS5jOjg1NQogbXNnaWQgIlNob3cgcmF3IHRpbWVzdGFtcCAoRGVmYXVsdDogb2ZmKSIKIG1zZ3N0ciAiVmlzYSByw6UgdGlkc3N0w6RtcGVsIChTdGFuZGFyZDogYXYpIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODU3CisjOiBidWlsdGluL2JsYW1lLmM6ODU2CiBtc2dpZCAiU2hvdyBsb25nIGNvbW1pdCBTSEExIChEZWZhdWx0OiBvZmYpIgogbXNnc3RyICJWaXNhIGzDpW5nIGluY2hlY2tuaW5ncy1TSEExIChTdGFuZGFyZDogYXYpIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODU4CisjOiBidWlsdGluL2JsYW1lLmM6ODU3CiBtc2dpZCAiU3VwcHJlc3MgYXV0aG9yIG5hbWUgYW5kIHRpbWVzdGFtcCAoRGVmYXVsdDogb2ZmKSIKIG1zZ3N0ciAiVW5kZXJ0cnljayBmw7ZyZmF0dGFybmFtbiBvY2ggdGlkc3N0w6RtcGVsIChTdGFuZGFyZDogYXYpIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODU5CisjOiBidWlsdGluL2JsYW1lLmM6ODU4CiBtc2dpZCAiU2hvdyBhdXRob3IgZW1haWwgaW5zdGVhZCBvZiBuYW1lIChEZWZhdWx0OiBvZmYpIgogbXNnc3RyICJWaXNhIGbDtnJmYXR0YXJlbnMgZS1wb3N0IGlzdMOkbGxldCBmw7ZyIG5hbW4gKFN0YW5kYXJkOiBhdikiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NjAKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NTkKIG1zZ2lkICJJZ25vcmUgd2hpdGVzcGFjZSBkaWZmZXJlbmNlcyIKIG1zZ3N0ciAiSWdub3JlcmEgw6RuZHJpbmdhciBpIGJsYW5rc3RlZyIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg2MSBidWlsdGluL2xvZy5jOjE2NDYKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NjAgYnVpbHRpbi9sb2cuYzoxNjMwCiBtc2dpZCAicmV2IgogbXNnc3RyICJyZXYiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NjEKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NjAKIG1zZ2lkICJJZ25vcmUgPHJldj4gd2hlbiBibGFtaW5nIgogbXNnc3RyICJpZ25vcmVyYSA8cmV2PiB2aWQga2xhbmRyZW4iCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NjIKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NjEKIG1zZ2lkICJJZ25vcmUgcmV2aXNpb25zIGZyb20gPGZpbGU+IgogbXNnc3RyICJpZ25vcmVyYSByZXZpc2lvbmVyIGZyw6VuIDxmaWw+IgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODYzCisjOiBidWlsdGluL2JsYW1lLmM6ODYyCiBtc2dpZCAiY29sb3IgcmVkdW5kYW50IG1ldGFkYXRhIGZyb20gcHJldmlvdXMgbGluZSBkaWZmZXJlbnRseSIKIG1zZ3N0ciAiZsOkcmdsw6RnZyByZWR1bmRhbnQgbWV0YWRhdGEgZnLDpW4gdGlkaWdhcmUgcmFkZXIgYW5ub3JsdW5kYSIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg2NAorIzogYnVpbHRpbi9ibGFtZS5jOjg2MwogbXNnaWQgImNvbG9yIGxpbmVzIGJ5IGFnZSIKIG1zZ3N0ciAiZsOkcmdsw6RnZyByYWRlciBlZnRlciDDpWxkZXIiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NzEKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NzAKIG1zZ2lkICJVc2UgYW4gZXhwZXJpbWVudGFsIGhldXJpc3RpYyB0byBpbXByb3ZlIGRpZmZzIgogbXNnc3RyICJBbnbDpG5kIGVuIGV4cGVyaW1lbnRlbGwgYWxnb3JpdG0gZsO2ciBhdHQgZsO2cmLDpHR0cmEgZGlmZmFyIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODczCisjOiBidWlsdGluL2JsYW1lLmM6ODcyCiBtc2dpZCAiU3BlbmQgZXh0cmEgY3ljbGVzIHRvIGZpbmQgYmV0dGVyIG1hdGNoIgogbXNnc3RyICJTbMO2c2EgZXh0cmEgY3lrbGVyIG1lZCBhdHQgaGl0dGEgYsOkdHRyZSB0csOkZmYiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NzQKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NzMKIG1zZ2lkICJVc2UgcmV2aXNpb25zIGZyb20gPGZpbGU+IGluc3RlYWQgb2YgY2FsbGluZyBnaXQtcmV2LWxpc3QiCiBtc2dzdHIgIkFudsOkbmQgcmV2aXNpb25lciBmcsOlbiA8ZmlsPiBpc3TDpGxsZXQgZsO2ciBhdHQgYW5yb3BhIGdpdC1yZXYtbGlzdCIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg3NQorIzogYnVpbHRpbi9ibGFtZS5jOjg3NAogbXNnaWQgIlVzZSA8ZmlsZT4ncyBjb250ZW50cyBhcyB0aGUgZmluYWwgaW1hZ2UiCiBtc2dzdHIgIkFudsOkbmQgPGZpbD5zIGlubmVow6VsbCBzb20gc2x1dGdpbHRpZyBiaWxkIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODc2IGJ1aWx0aW4vYmxhbWUuYzo4NzcKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NzUgYnVpbHRpbi9ibGFtZS5jOjg3NgogbXNnaWQgInNjb3JlIgogbXNnc3RyICJwb8OkbmciCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NzYKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NzUKIG1zZ2lkICJGaW5kIGxpbmUgY29waWVzIHdpdGhpbiBhbmQgYWNyb3NzIGZpbGVzIgogbXNnc3RyICJIaXR0YSBrb3BpZXJhZGUgcmFkZXIgaW51dGkgb2NoIG1lbGxhbiBmaWxlciIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg3NworIzogYnVpbHRpbi9ibGFtZS5jOjg3NgogbXNnaWQgIkZpbmQgbGluZSBtb3ZlbWVudHMgd2l0aGluIGFuZCBhY3Jvc3MgZmlsZXMiCiBtc2dzdHIgIkhpdHRhIGZseXR0YWRlIHJhZGVyIGludXRpIG9jaCBtZWxsYW4gZmlsZXIiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NzgKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NzcKIG1zZ2lkICJuLG0iCiBtc2dzdHIgIm4sbSIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg3OAorIzogYnVpbHRpbi9ibGFtZS5jOjg3NwogbXNnaWQgIlByb2Nlc3Mgb25seSBsaW5lIHJhbmdlIG4sbSwgY291bnRpbmcgZnJvbSAxIgogbXNnc3RyICJCZWhhbmRsYSBlbmRhc3QgcmFkaW50ZXJ2YWxsZXQgbixtLCBtZWQgYsO2cmphbiBww6UgMSIKIApAQCAtOTY3Niw3ICs5NzIwLDcgQEAKIG1zZ2lkICJkbyBub3QgdXNlIgogbXNnc3RyICJhbnbDpG5kIGVqIgogCi0jOiBidWlsdGluL2JyYW5jaC5jOjYyNiBidWlsdGluL3JlYmFzZS5jOjQ4NQorIzogYnVpbHRpbi9icmFuY2guYzo2MjYgYnVpbHRpbi9yZWJhc2UuYzo0ODYKIG1zZ2lkICJ1cHN0cmVhbSIKIG1zZ3N0ciAidXBwc3Ryw7ZtcyIKIApAQCAtOTc4MywxMSArOTgyNywxMSBAQAogbXNnc3RyICJzb3J0ZXJpbmcgb2NoIGZpbHRyZXJpbmcgc2tpbGplciBnZW1lbmVyIG9jaCBWRVJTQUxFUiIKIAogIzogYnVpbHRpbi9icmFuY2guYzo2NjEgYnVpbHRpbi9mb3ItZWFjaC1yZWYuYzozOCBidWlsdGluL3RhZy5jOjQzOAotIzogYnVpbHRpbi92ZXJpZnktdGFnLmM6MzkKKyM6IGJ1aWx0aW4vdmVyaWZ5LXRhZy5jOjM4CiBtc2dpZCAiZm9ybWF0IHRvIHVzZSBmb3IgdGhlIG91dHB1dCIKIG1zZ3N0ciAiZm9ybWF0IGF0dCBhbnbDpG5kYSBmw7ZyIHV0ZGF0YSIKIAotIzogYnVpbHRpbi9icmFuY2guYzo2ODQgYnVpbHRpbi9jbG9uZS5jOjc2MQorIzogYnVpbHRpbi9icmFuY2guYzo2ODQgYnVpbHRpbi9jbG9uZS5jOjc2MAogbXNnaWQgIkhFQUQgbm90IGZvdW5kIGJlbG93IHJlZnMvaGVhZHMhIgogbXNnc3RyICJIRUFEIGhpdHRhZGVzIGludGUgdW5kZXIgcmVmcy9oZWFkcyEiCiAKQEAgLTk4ODksNyArOTkzMyw3IEBACiBtc2dpZCAiTmVlZCBhIHJlcG9zaXRvcnkgdG8gdW5idW5kbGUuIgogbXNnc3RyICJCZWjDtnZlciBldHQgYXJraXYgZsO2ciBhdHQgcGFja2EgdXBwIGV0dCBwYWtldCAoYnVuZGxlKS4iCiAKLSM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo1OTQKKyM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo1OTUKIG1zZ2lkICIiCiAiZ2l0IGNhdC1maWxlICgtdCBbLS1hbGxvdy11bmtub3duLXR5cGVdIHwgLXMgWy0tYWxsb3ctdW5rbm93bi10eXBlXSB8IC1lIHwgLSIKICJwIHwgPHR5cGU+IHwgLS10ZXh0Y29udiB8IC0tZmlsdGVycykgWy0tcGF0aD08cGF0aD5dIDxvYmplY3Q+IgpAQCAtOTg5Nyw3ICs5OTQxLDcgQEAKICJnaXQgY2F0LWZpbGUgKC10IFstLWFsbG93LXVua25vd24tdHlwZV0gfCAtcyBbLS1hbGxvdy11bmtub3duLXR5cGVdIHwgLWUgfCAtIgogInAgfCA8dHlwPiB8IC0tdGV4dGNvbnYgfCAtLWZpbHRlcnMpIFstLXBhdGg9PHPDtmt2w6RnPl0gPG9iamVrdD4iCiAKLSM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo1OTUKKyM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo1OTYKIG1zZ2lkICIiCiAiZ2l0IGNhdC1maWxlICgtLWJhdGNoIHwgLS1iYXRjaC1jaGVjaykgWy0tZm9sbG93LXN5bWxpbmtzXSBbLS10ZXh0Y29udiB8IC0tIgogImZpbHRlcnNdIgpAQCAtOTkwNSw3MiArOTk0OSw3MiBAQAogImdpdCBjYXQtZmlsZSAoLS1iYXRjaCB8IC0tYmF0Y2gtY2hlY2spIFstLWZvbGxvdy1zeW1saW5rc10gWy0tdGV4dGNvbnYgfCAtLSIKICJmaWx0ZXJzXSIKIAotIzogYnVpbHRpbi9jYXQtZmlsZS5jOjYxNgorIzogYnVpbHRpbi9jYXQtZmlsZS5jOjYxNwogbXNnaWQgIm9ubHkgb25lIGJhdGNoIG9wdGlvbiBtYXkgYmUgc3BlY2lmaWVkIgogbXNnc3RyICJlbmRhc3QgZW4gYnVudGZsYWdnYSBrYW4gYW5nZXMiCiAKLSM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2MzQKKyM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2MzUKIG1zZ2lkICI8dHlwZT4gY2FuIGJlIG9uZSBvZjogYmxvYiwgdHJlZSwgY29tbWl0LCB0YWciCiBtc2dzdHIgIjx0eXA+IGthbiB2YXJhIGVuIGF2OiBibG9iLCB0cmVlLCBjb21taXQsIHRhZyIKIAotIzogYnVpbHRpbi9jYXQtZmlsZS5jOjYzNQorIzogYnVpbHRpbi9jYXQtZmlsZS5jOjYzNgogbXNnaWQgInNob3cgb2JqZWN0IHR5cGUiCiBtc2dzdHIgInZpc2Egb2JqZWt0dHlwIgogCi0jOiBidWlsdGluL2NhdC1maWxlLmM6NjM2CisjOiBidWlsdGluL2NhdC1maWxlLmM6NjM3CiBtc2dpZCAic2hvdyBvYmplY3Qgc2l6ZSIKIG1zZ3N0ciAidmlzYSBvYmpla3RzdG9ybGVrIgogCi0jOiBidWlsdGluL2NhdC1maWxlLmM6NjM4CisjOiBidWlsdGluL2NhdC1maWxlLmM6NjM5CiBtc2dpZCAiZXhpdCB3aXRoIHplcm8gd2hlbiB0aGVyZSdzIG5vIGVycm9yIgogbXNnc3RyICJhdnNsdXRhIG1lZCBub2xsIG7DpHIgZGV0IGludGUgdXBwc3TDpXR0IG7DpWdvdCBmZWwiCiAKLSM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2MzkKKyM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NDAKIG1zZ2lkICJwcmV0dHktcHJpbnQgb2JqZWN0J3MgY29udGVudCIKIG1zZ3N0ciAidmlzYSBvYmpla3RldHMgaW5uZWjDpWxsIHNueWdndCIKIAotIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY0MQorIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY0MgogbXNnaWQgImZvciBibG9iIG9iamVjdHMsIHJ1biB0ZXh0Y29udiBvbiBvYmplY3QncyBjb250ZW50IgogbXNnc3RyICJmw7ZyIGJsb2Itb2JqZWt0LCBrw7ZyIGZpbHRlciBww6Ugb2JqZWt0ZXRzIGlubmVow6VsbCIKIAotIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY0MworIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY0NAogbXNnaWQgImZvciBibG9iIG9iamVjdHMsIHJ1biBmaWx0ZXJzIG9uIG9iamVjdCdzIGNvbnRlbnQiCiBtc2dzdHIgImbDtnIgYmxvYi1vYmpla3QsIGvDtnIgZmlsZ2VyIHDDpSBvYmpla3RldHMgaW5uZWjDpWxsIgogCi0jOiBidWlsdGluL2NhdC1maWxlLmM6NjQ0IGdpdC1zdWJtb2R1bGUuc2g6OTM2CisjOiBidWlsdGluL2NhdC1maWxlLmM6NjQ1IGdpdC1zdWJtb2R1bGUuc2g6OTM2CiBtc2dpZCAiYmxvYiIKIG1zZ3N0ciAiYmxvYiIKIAotIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY0NQorIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY0NgogbXNnaWQgInVzZSBhIHNwZWNpZmljIHBhdGggZm9yIC0tdGV4dGNvbnYvLS1maWx0ZXJzIgogbXNnc3RyICJhbnbDpG5kIHNwZWNpZmlrIHPDtmt2w6RnIGbDtnIgLS10ZXh0Y29udi8tLWZpbHRlcnMiCiAKLSM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NDcKKyM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NDgKIG1zZ2lkICJhbGxvdyAtcyBhbmQgLXQgdG8gd29yayB3aXRoIGJyb2tlbi9jb3JydXB0IG9iamVjdHMiCiBtc2dzdHIgImzDpXRlciAtcyBvY2ggLXQgYXR0IGZ1bmdlcmEgbWVkIHRyYXNpZ2Evc8O2bmRlcnNrcml2bmEgb2JqZWt0IgogCi0jOiBidWlsdGluL2NhdC1maWxlLmM6NjQ4CisjOiBidWlsdGluL2NhdC1maWxlLmM6NjQ5CiBtc2dpZCAiYnVmZmVyIC0tYmF0Y2ggb3V0cHV0IgogbXNnc3RyICJidWZmcmEgdXRkYXRhIGZyw6VuIC0tYmF0Y2giCiAKLSM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NTAKKyM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NTEKIG1zZ2lkICJzaG93IGluZm8gYW5kIGNvbnRlbnQgb2Ygb2JqZWN0cyBmZWQgZnJvbSB0aGUgc3RhbmRhcmQgaW5wdXQiCiBtc2dzdHIgInZpc2EgaW5mb3JtYXRpb24gb2NoIGlubmVow6VsbCBmw7ZyIG9iamVrdCBzb20gbGlzdGFzIHDDpSBzdGFuZGFyZCBpbiIKIAotIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY1NAorIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY1NQogbXNnaWQgInNob3cgaW5mbyBhYm91dCBvYmplY3RzIGZlZCBmcm9tIHRoZSBzdGFuZGFyZCBpbnB1dCIKIG1zZ3N0ciAidmlzYSBpbmZvcm1hdGlvbiBmw7ZyIG9iamVrdCBzb20gbGlzdGFzIHDDpSBzdGFuZGFyZCBpbiIKIAotIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY1OAorIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY1OQogbXNnaWQgImZvbGxvdyBpbi10cmVlIHN5bWxpbmtzICh1c2VkIHdpdGggLS1iYXRjaCBvciAtLWJhdGNoLWNoZWNrKSIKIG1zZ3N0ciAiIgogImbDtmxqIHN5bWJvbGlza2EgbMOkbmthciBpIHRyw6RkZXQgKGFudsOkbmQgbWVkIC0tYmF0Y2ggZWxsZXIgLS1iYXRjaC1jaGVjaykiCiAKLSM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NjAKKyM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NjEKIG1zZ2lkICJzaG93IGFsbCBvYmplY3RzIHdpdGggLS1iYXRjaCBvciAtLWJhdGNoLWNoZWNrIgogbXNnc3RyICJ2aXNhIGFsbGEgb2JqZWt0IG1lZCAtLWJhdGNoIGVsbGVyIC0tYmF0Y2gtY2hlY2siCiAKLSM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NjIKKyM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NjMKIG1zZ2lkICJkbyBub3Qgb3JkZXIgLS1iYXRjaC1hbGwtb2JqZWN0cyBvdXRwdXQiCiBtc2dzdHIgIm9yZG5hIGludGUgLS1iYXRjaC1hbGwtb2JqZWN0cyBvdXRwdXQiCiAKQEAgLTk5OTgsOCArMTAwNDIsOCBAQAogbXNnaWQgInRlcm1pbmF0ZSBpbnB1dCBhbmQgb3V0cHV0IHJlY29yZHMgYnkgYSBOVUwgY2hhcmFjdGVyIgogbXNnc3RyICJhdnNsdXRhIGluLSBvY2ggdXRkYXRhcG9zdGVyIG1lZCBOVUwtdGVja2VuIgogCi0jOiBidWlsdGluL2NoZWNrLWlnbm9yZS5jOjIxIGJ1aWx0aW4vY2hlY2tvdXQuYzoxNDMzIGJ1aWx0aW4vZ2MuYzo1MzgKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo1MDcKKyM6IGJ1aWx0aW4vY2hlY2staWdub3JlLmM6MjEgYnVpbHRpbi9jaGVja291dC5jOjE0MzMgYnVpbHRpbi9nYy5jOjUzNworIzogYnVpbHRpbi93b3JrdHJlZS5jOjUwNgogbXNnaWQgInN1cHByZXNzIHByb2dyZXNzIHJlcG9ydGluZyIKIG1zZ3N0ciAidW5kZXJ0cnljayBmw7ZybG9wcHNyYXBwb3J0ZXJpbmciCiAKQEAgLTEwMDkxLDcgKzEwMTM1LDcgQEAKICM6IGJ1aWx0aW4vY2hlY2tvdXQtaW5kZXguYzoxNzggYnVpbHRpbi9jb2x1bW4uYzozMQogIzogYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjEzNzMgYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjEzNzYKICM6IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxMzg0IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxODU3Ci0jOiBidWlsdGluL3dvcmt0cmVlLmM6NjgwCisjOiBidWlsdGluL3dvcmt0cmVlLmM6Njc5CiBtc2dpZCAic3RyaW5nIgogbXNnc3RyICJzdHLDpG5nIgogCkBAIC0xMDExOSw5OCArMTAxNjMsOTggQEAKIG1zZ2lkICJnaXQgcmVzdG9yZSBbPG9wdGlvbnM+XSBbLS1zb3VyY2U9PGJyYW5jaD5dIDxmaWxlPi4uLiIKIG1zZ3N0ciAiZ2l0IHJlc3RvcmUgWzxmbGFnZ29yPl0gWy0tc291cmNlPTxncmVuPl0gPGZpbD4uLi4iCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzIgYnVpbHRpbi9jaGVja291dC5jOjIxMQorIzogYnVpbHRpbi9jaGVja291dC5jOjE3MyBidWlsdGluL2NoZWNrb3V0LmM6MjEyCiAjLCBjLWZvcm1hdAogbXNnaWQgInBhdGggJyVzJyBkb2VzIG5vdCBoYXZlIG91ciB2ZXJzaW9uIgogbXNnc3RyICJzw7ZrdsOkZ2VuIFwiJXNcIiBoYXIgaW50ZSB2w6VyIHZlcnNpb24iCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzQgYnVpbHRpbi9jaGVja291dC5jOjIxMworIzogYnVpbHRpbi9jaGVja291dC5jOjE3NSBidWlsdGluL2NoZWNrb3V0LmM6MjE0CiAjLCBjLWZvcm1hdAogbXNnaWQgInBhdGggJyVzJyBkb2VzIG5vdCBoYXZlIHRoZWlyIHZlcnNpb24iCiBtc2dzdHIgInPDtmt2w6RnZW4gXCIlc1wiIGhhciBpbnRlIGRlcmFzIHZlcnNpb24iCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxOTAKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxOTEKICMsIGMtZm9ybWF0CiBtc2dpZCAicGF0aCAnJXMnIGRvZXMgbm90IGhhdmUgYWxsIG5lY2Vzc2FyeSB2ZXJzaW9ucyIKIG1zZ3N0ciAic8O2a3bDpGdlbiBcIiVzXCIgaW5uZWjDpWxsZXIgaW50ZSBhbGxhIG7DtmR2w6RuZGlnYSB2ZXJzaW9uZXIiCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoyNDAKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoyNDEKICMsIGMtZm9ybWF0CiBtc2dpZCAicGF0aCAnJXMnIGRvZXMgbm90IGhhdmUgbmVjZXNzYXJ5IHZlcnNpb25zIgogbXNnc3RyICJzw7ZrdsOkZ2VuIFwiJXNcIiBpbm5laMOlbGxlciBpbnRlIG7DtmR2w6RuZGlnYSB2ZXJzaW9uZXIiCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoyNTgKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoyNTkKICMsIGMtZm9ybWF0CiBtc2dpZCAicGF0aCAnJXMnOiBjYW5ub3QgbWVyZ2UiCiBtc2dzdHIgInPDtmt2w6RnIFwiJXNcIjoga2FuIGludGUgc2zDpSBpaG9wIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6Mjc0CisjOiBidWlsdGluL2NoZWNrb3V0LmM6Mjc1CiAjLCBjLWZvcm1hdAogbXNnaWQgIlVuYWJsZSB0byBhZGQgbWVyZ2UgcmVzdWx0IGZvciAnJXMnIgogbXNnc3RyICJLdW5kZSBpbnRlIGzDpGdnYSB0aWxsIHNhbW1hbnNsYWduaW5nc3Jlc3VsdGF0IGbDtnIgXCIlc1wiIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6Mzc0CisjOiBidWlsdGluL2NoZWNrb3V0LmM6Mzc1CiAjLCBjLWZvcm1hdAogbXNnaWQgIlJlY3JlYXRlZCAlZCBtZXJnZSBjb25mbGljdCIKIG1zZ2lkX3BsdXJhbCAiUmVjcmVhdGVkICVkIG1lcmdlIGNvbmZsaWN0cyIKIG1zZ3N0clswXSAiw4V0ZXJza2FwYWRlICVkIHNhbW1hbnNsYWduaW5nc2tvbmZsaWt0IgogbXNnc3RyWzFdICLDhXRlcnNrYXBhZGUgJWQgc2FtbWFuc2xhZ25pbmdza29uZmxpa3RlciIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjM3OQorIzogYnVpbHRpbi9jaGVja291dC5jOjM4MAogIywgYy1mb3JtYXQKIG1zZ2lkICJVcGRhdGVkICVkIHBhdGggZnJvbSAlcyIKIG1zZ2lkX3BsdXJhbCAiVXBkYXRlZCAlZCBwYXRocyBmcm9tICVzIgogbXNnc3RyWzBdICJVcHBkYXRlcmFkZSAlZCBzw7ZrdsOkZyBmcsOlbiAlcyIKIG1zZ3N0clsxXSAiVXBwZGF0ZXJhZGUgJWQgc8O2a3bDpGdhciBmcsOlbiAlcyIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjM4NgorIzogYnVpbHRpbi9jaGVja291dC5jOjM4NwogIywgYy1mb3JtYXQKIG1zZ2lkICJVcGRhdGVkICVkIHBhdGggZnJvbSB0aGUgaW5kZXgiCiBtc2dpZF9wbHVyYWwgIlVwZGF0ZWQgJWQgcGF0aHMgZnJvbSB0aGUgaW5kZXgiCiBtc2dzdHJbMF0gIlVwcGRhdGVyYWRlICVkIHPDtmt2w6RnIGZyw6VuIGluZGV4ZXQiCiBtc2dzdHJbMV0gIlVwcGRhdGVyYWRlICVkIHPDtmt2w6RnYXIgZnLDpW4gaW5kZXhldCIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjQwOSBidWlsdGluL2NoZWNrb3V0LmM6NDEyIGJ1aWx0aW4vY2hlY2tvdXQuYzo0MTUKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo0MTkKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo0MTAgYnVpbHRpbi9jaGVja291dC5jOjQxMyBidWlsdGluL2NoZWNrb3V0LmM6NDE2CisjOiBidWlsdGluL2NoZWNrb3V0LmM6NDIwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiclcycgY2Fubm90IGJlIHVzZWQgd2l0aCB1cGRhdGluZyBwYXRocyIKIG1zZ3N0ciAiXCIlc1wiIGthbiBpbnRlIGFudsOkbmRhcyB2aWQgdXBwZGF0ZXJpbmcgYXYgc8O2a3bDpGdhciIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjQyMiBidWlsdGluL2NoZWNrb3V0LmM6NDI1CisjOiBidWlsdGluL2NoZWNrb3V0LmM6NDIzIGJ1aWx0aW4vY2hlY2tvdXQuYzo0MjYKICMsIGMtZm9ybWF0CiBtc2dpZCAiJyVzJyBjYW5ub3QgYmUgdXNlZCB3aXRoICVzIgogbXNnc3RyICJcIiVzXCIga2FuIGludGUgYW52w6RuZGFzIG1lZCAlcyIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjQyOQorIzogYnVpbHRpbi9jaGVja291dC5jOjQzMAogIywgYy1mb3JtYXQKIG1zZ2lkICJDYW5ub3QgdXBkYXRlIHBhdGhzIGFuZCBzd2l0Y2ggdG8gYnJhbmNoICclcycgYXQgdGhlIHNhbWUgdGltZS4iCiBtc2dzdHIgIkthbiBpbnRlIHVwcGRhdGVyYSBzw7ZrdsOkZ2FyIG9jaCB2w6R4bGEgdGlsbCBncmVuZW4gXCIlc1wiIHNhbXRpZGlndC4iCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo0MzMKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo0MzQKICMsIGMtZm9ybWF0CiBtc2dpZCAibmVpdGhlciAnJXMnIG9yICclcycgaXMgc3BlY2lmaWVkIgogbXNnc3RyICJ2YXJrZW4gXCIlc1wiIGVsbGVyIFwiJXNcIiBoYXIgYW5naXZpdHMiCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo0MzcKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo0MzgKICMsIGMtZm9ybWF0CiBtc2dpZCAiJyVzJyBtdXN0IGJlIHVzZWQgd2hlbiAnJXMnIGlzIG5vdCBzcGVjaWZpZWQiCiBtc2dzdHIgIlwiJXNcIiBtw6VzdGUgYW52w6RuZGFzIG7DpHIgXCIlc1wiIGludGUgYW5nZXMiCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo0NDIgYnVpbHRpbi9jaGVja291dC5jOjQ0NworIzogYnVpbHRpbi9jaGVja291dC5jOjQ0MyBidWlsdGluL2NoZWNrb3V0LmM6NDQ4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiclcycgb3IgJyVzJyBjYW5ub3QgYmUgdXNlZCB3aXRoICVzIgogbXNnc3RyICJcIiVzXCIgZWxsZXIgXCIlc1wiIGthbiBpbnRlIGFudsOkbmRhcyBtZWQgJXMiCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo1MDYgYnVpbHRpbi9jaGVja291dC5jOjUxMworIzogYnVpbHRpbi9jaGVja291dC5jOjUwNyBidWlsdGluL2NoZWNrb3V0LmM6NTE0CiAjLCBjLWZvcm1hdAogbXNnaWQgInBhdGggJyVzJyBpcyB1bm1lcmdlZCIKIG1zZ3N0ciAic8O2a3bDpGdlbiBcIiVzXCIgaGFyIGludGUgc2xhZ2l0cyBpaG9wIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6Njc5CisjOiBidWlsdGluL2NoZWNrb3V0LmM6NjgwCiBtc2dpZCAieW91IG5lZWQgdG8gcmVzb2x2ZSB5b3VyIGN1cnJlbnQgaW5kZXggZmlyc3QiCiBtc2dzdHIgImR1IG3DpXN0ZSBsw7ZzYSBkaXR0IGJlZmludGxpZ2EgaW5kZXggZsO2cnN0IgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6NzI5CisjOiBidWlsdGluL2NoZWNrb3V0LmM6NzMwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJjYW5ub3QgY29udGludWUgd2l0aCBzdGFnZWQgY2hhbmdlcyBpbiB0aGUgZm9sbG93aW5nIGZpbGVzOlxuIgpAQCAtMTAyMTksMTEgKzEwMjYzLDYgQEAKICJrYW4gaW50ZSBmb3J0c8OkdHRhIG1lZCBrw7ZhZGUgw6RuZHJpbmdhciBpIGbDtmxqYW5kZSBmaWxlcjpcbiIKICIlcyIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjczNgotIywgYy1mb3JtYXQKLW1zZ2lkICJzdGFnZWQgY2hhbmdlcyBpbiB0aGUgZm9sbG93aW5nIGZpbGVzIG1heSBiZSBsb3N0OiAlcyIKLW1zZ3N0ciAia8O2YWRlIMOkbmRyaW5nYXIgaSBmw7ZsamFuZGUgZmlsZXIga2FuIGfDpSBmw7ZybG9yYWRlOiAlcyIKLQogIzogYnVpbHRpbi9jaGVja291dC5jOjgzMwogIywgYy1mb3JtYXQKIG1zZ2lkICJDYW4gbm90IGRvIHJlZmxvZyBmb3IgJyVzJzogJXNcbiIKQEAgLTEwMjMzLDcgKzEwMjcyLDcgQEAKIG1zZ2lkICJIRUFEIGlzIG5vdyBhdCIKIG1zZ3N0ciAiSEVBRCDDpHIgbnUgcMOlIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6ODc5IGJ1aWx0aW4vY2xvbmUuYzo3MTQKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo4NzkgYnVpbHRpbi9jbG9uZS5jOjcxMwogbXNnaWQgInVuYWJsZSB0byB1cGRhdGUgSEVBRCIKIG1zZ3N0ciAia2FuIGludGUgdXBwZGF0ZXJhIEhFQUQiCiAKQEAgLTEwMzQ3LDcgKzEwMzg2LDcgQEAKICJcIiVzXCIga2FuIHZhcmEgYsOlZGUgZW4gbG9rYWwgZmlsIG9jaCBlbiBzcMOlcmFuZGUgZ3Jlbi5cbiIKICJBbnbDpG5kIC0tIChvY2ggbcO2amxpZ2VuIC0tbm8tZ3Vlc3MpIGbDtnIgYXR0IGfDtnJhIG90dmV0eWRpZyIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjEyNDMgYnVpbHRpbi93b3JrdHJlZS5jOjI5MSBidWlsdGluL3dvcmt0cmVlLmM6NDU2CisjOiBidWlsdGluL2NoZWNrb3V0LmM6MTI0MyBidWlsdGluL3dvcmt0cmVlLmM6MjkwIGJ1aWx0aW4vd29ya3RyZWUuYzo0NTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCByZWZlcmVuY2U6ICVzIgogbXNnc3RyICJmZWxha3RpZyByZWZlcmVuczogJXMiCkBAIC0xMDQ1MCw5ICsxMDQ4OSw5IEBACiBtc2dpZCAibWlzc2luZyBicmFuY2ggb3IgY29tbWl0IGFyZ3VtZW50IgogbXNnc3RyICJzYWtuYXIgZ3Jlbi0gZWxsZXIgaW5jaGVja2luZ3Nhcmd1bWVudCIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjE0MzcgYnVpbHRpbi9jbG9uZS5jOjkxIGJ1aWx0aW4vZmV0Y2guYzoxNTEKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoyODUgYnVpbHRpbi9wdWxsLmM6MTM3IGJ1aWx0aW4vcHVzaC5jOjU3NQotIzogYnVpbHRpbi9zZW5kLXBhY2suYzoxNzQKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNDM3IGJ1aWx0aW4vY2xvbmUuYzo5MCBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjU5CisjOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE4MCBidWlsdGluL2ZldGNoLmM6MTY2IGJ1aWx0aW4vbWVyZ2UuYzoyODUKKyM6IGJ1aWx0aW4vcHVsbC5jOjEzOCBidWlsdGluL3B1c2guYzo1NjIgYnVpbHRpbi9zZW5kLXBhY2suYzoxNzQKIG1zZ2lkICJmb3JjZSBwcm9ncmVzcyByZXBvcnRpbmciCiBtc2dzdHIgInR2aW5nYSBmw7ZybG9wcHNyYXBwb3J0ZXJpbmciCiAKQEAgLTEwNDYwLDcgKzEwNDk5LDcgQEAKIG1zZ2lkICJwZXJmb3JtIGEgMy13YXkgbWVyZ2Ugd2l0aCB0aGUgbmV3IGJyYW5jaCIKIG1zZ3N0ciAidXRmw7ZyIGVuIDMtdsOkZ3NzYW1tYW5zbGFnbmluZyBmw7ZyIGRlbiBueWEgZ3JlbmVuIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6MTQzOSBidWlsdGluL2xvZy5jOjE2MzQgcGFyc2Utb3B0aW9ucy5oOjMxOAorIzogYnVpbHRpbi9jaGVja291dC5jOjE0MzkgYnVpbHRpbi9sb2cuYzoxNjE4IHBhcnNlLW9wdGlvbnMuaDozMTgKIG1zZ2lkICJzdHlsZSIKIG1zZ3N0ciAic3RpbCIKIApAQCAtMTA0NjgsNyArMTA1MDcsNyBAQAogbXNnaWQgImNvbmZsaWN0IHN0eWxlIChtZXJnZSBvciBkaWZmMykiCiBtc2dzdHIgImtvbmZsaWt0c3RpbCAobWVyZ2UgZWxsZXIgZGlmZjMpIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6MTQ1MiBidWlsdGluL3dvcmt0cmVlLmM6NTA0CisjOiBidWlsdGluL2NoZWNrb3V0LmM6MTQ1MiBidWlsdGluL3dvcmt0cmVlLmM6NTAzCiBtc2dpZCAiZGV0YWNoIEhFQUQgYXQgbmFtZWQgY29tbWl0IgogbXNnc3RyICJrb3BwbGEgZnLDpW4gSEVBRCB2aWQgbmFtbmdpdmVuIGluY2hlY2tuaW5nIgogCkBAIC0xMDU0MSw3ICsxMDU4MCw4IEBACiAjOiBidWlsdGluL2NoZWNrb3V0LmM6MTYzOAogIywgYy1mb3JtYXQKIG1zZ2lkICInJXMnIGlzIG5vdCBhIGNvbW1pdCBhbmQgYSBicmFuY2ggJyVzJyBjYW5ub3QgYmUgY3JlYXRlZCBmcm9tIGl0IgotbXNnc3RyICJcIiVzXCIgw6RyIGludGUgZW4gaW5jaGVja25pbmcgb2NoIGdyZW5lbiBcIiVzXCIga2FuIGludGUgc2thcGFzIGZyw6VuIGRlbiIKK21zZ3N0ciAiIgorIlwiJXNcIiDDpHIgaW50ZSBlbiBpbmNoZWNrbmluZyBvY2ggZ3JlbmVuIFwiJXNcIiBrYW4gaW50ZSBza2FwYXMgZnLDpW4gZGVuIgogCiAjOiBidWlsdGluL2NoZWNrb3V0LmM6MTY0MgogIywgYy1mb3JtYXQKQEAgLTEwNTg1LDkgKzEwNjI1LDkgQEAKICJmw7ZyZWRyYSBlbiBmasOkcnIsIHQuZXggZmrDpHJyZW4gXCJvcmlnaW5cIiBrYW4gZHUgc3TDpGxsYSBpblxuIgogImNoZWNrb3V0LmRlZmF1bHRSZW1vdGU9b3JpZ2luIGkgZGluIGtvbmZpZ3VyYXRpb24uIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6MTY5MSBidWlsdGluL2NoZWNrb3V0LmM6MTY5MyBidWlsdGluL2NoZWNrb3V0LmM6MTczMwotIzogYnVpbHRpbi9jaGVja291dC5jOjE3MzUgYnVpbHRpbi9jbG9uZS5jOjEyMSBidWlsdGluL3JlbW90ZS5jOjE2OQotIzogYnVpbHRpbi9yZW1vdGUuYzoxNzEgYnVpbHRpbi93b3JrdHJlZS5jOjUwMCBidWlsdGluL3dvcmt0cmVlLmM6NTAyCisjOiBidWlsdGluL2NoZWNrb3V0LmM6MTY5MSBidWlsdGluL2NoZWNrb3V0LmM6MTY5MyBidWlsdGluL2NoZWNrb3V0LmM6MTc0MgorIzogYnVpbHRpbi9jaGVja291dC5jOjE3NDQgYnVpbHRpbi9jbG9uZS5jOjEyMCBidWlsdGluL3JlbW90ZS5jOjE2OQorIzogYnVpbHRpbi9yZW1vdGUuYzoxNzEgYnVpbHRpbi93b3JrdHJlZS5jOjQ5OSBidWlsdGluL3dvcmt0cmVlLmM6NTAxCiBtc2dpZCAiYnJhbmNoIgogbXNnc3RyICJncmVuIgogCkBAIC0xMDYxMSwzOSArMTA2NTEsMzkgQEAKIG1zZ2lkICJ1c2Ugb3ZlcmxheSBtb2RlIChkZWZhdWx0KSIKIG1zZ3N0ciAiYW52w6RuZCDDtnZlcmzDpGdnc2zDpGdlIChzdGFuZGFyZCkiCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzM0CisjOiBidWlsdGluL2NoZWNrb3V0LmM6MTc0MwogbXNnaWQgImNyZWF0ZSBhbmQgc3dpdGNoIHRvIGEgbmV3IGJyYW5jaCIKIG1zZ3N0ciAic2thcGEgb2NoIHbDpHhsYSB0aWxsIGVuIG55IGdyZW4iCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzM2CisjOiBidWlsdGluL2NoZWNrb3V0LmM6MTc0NQogbXNnaWQgImNyZWF0ZS9yZXNldCBhbmQgc3dpdGNoIHRvIGEgYnJhbmNoIgogbXNnc3RyICJza2FwYS9ub2xsc3TDpGxsIG9jaCB2w6R4bGEgdGlsbCBlbiBncmVuIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6MTczOAorIzogYnVpbHRpbi9jaGVja291dC5jOjE3NDcKIG1zZ2lkICJzZWNvbmQgZ3Vlc3MgJ2dpdCBzd2l0Y2ggPG5vLXN1Y2gtYnJhbmNoPiciCiBtc2dzdHIgImbDtnJ1dHNww6UgXCJnaXQgY2hlY2tvdXQgPGdyZW4tc2FrbmFzPlwiIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6MTc0MAorIzogYnVpbHRpbi9jaGVja291dC5jOjE3NDkKIG1zZ2lkICJ0aHJvdyBhd2F5IGxvY2FsIG1vZGlmaWNhdGlvbnMiCiBtc2dzdHIgImthc3RhIGJvcnQgbG9rYWxhIMOkbmRyaW5nYXIiCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzcyCi1tc2dpZCAid2hlcmUgdGhlIGNoZWNrb3V0IGZyb20iCi1tc2dzdHIgImvDpGxsYSB0aWxsIHV0Y2hlY2tuaW5nIgorIzogYnVpbHRpbi9jaGVja291dC5jOjE3ODEKK21zZ2lkICJ3aGljaCB0cmVlLWlzaCB0byBjaGVja291dCBmcm9tIgorbXNnc3RyICJ2aWxrZW4gdHLDpGQtaWd0IGF0dCBjaGVja2EgdXQgZnLDpW4iCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzc0CisjOiBidWlsdGluL2NoZWNrb3V0LmM6MTc4MwogbXNnaWQgInJlc3RvcmUgdGhlIGluZGV4IgogbXNnc3RyICLDpXRlcnN0w6RsbCBpbmRleGV0IgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6MTc3NgorIzogYnVpbHRpbi9jaGVja291dC5jOjE3ODUKIG1zZ2lkICJyZXN0b3JlIHRoZSB3b3JraW5nIHRyZWUgKGRlZmF1bHQpIgogbXNnc3RyICLDpXRlcnN0w6RsbCBhcmJldHNrYXRhbG9nZW4gKGbDtnJ2YWwpIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6MTc3OAorIzogYnVpbHRpbi9jaGVja291dC5jOjE3ODcKIG1zZ2lkICJpZ25vcmUgdW5tZXJnZWQgZW50cmllcyIKIG1zZ3N0ciAiaWdub3JlcmEgZWogc2FtbWFuc2xhZ25hIHBvc3RlciIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjE3NzkKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzg4CiBtc2dpZCAidXNlIG92ZXJsYXkgbW9kZSIKIG1zZ3N0ciAiYW52w6RuZCDDtnZlcmzDpGdnc2zDpGdlIgogCkBAIC0xMDY4NCw3ICsxMDcyNCw3IEBACiBtc2dpZCAiY291bGQgbm90IGxzdGF0ICVzXG4iCiBtc2dzdHIgImt1bmRlIGludGUgdGEgc3RhdHVzIChcImxzdGF0XCIpIHDDpSAlc1xuIgogCi0jOiBidWlsdGluL2NsZWFuLmM6MzAwIGdpdC1hZGQtLWludGVyYWN0aXZlLnBlcmw6NTkzCisjOiBidWlsdGluL2NsZWFuLmM6MzAxIGdpdC1hZGQtLWludGVyYWN0aXZlLnBlcmw6NTkzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJQcm9tcHQgaGVscDpcbiIKQEAgLTEwNjk3LDcgKzEwNzM3LDcgQEAKICJmb28gICAgICAgIC0gbWFya2VyYSBwb3N0IGJhc2VyYWQgcMOlIHVuaWt0IHByZWZpeFxuIgogIiAgICAgICAgICAgLSAodG9tdCkgbWFya2VyYSBpbmdlbnRpbmdcbiIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjMwNCBnaXQtYWRkLS1pbnRlcmFjdGl2ZS5wZXJsOjYwMgorIzogYnVpbHRpbi9jbGVhbi5jOjMwNSBnaXQtYWRkLS1pbnRlcmFjdGl2ZS5wZXJsOjYwMgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiUHJvbXB0IGhlbHA6XG4iCkBAIC0xMDcxOCwzOCArMTA3NTgsMzggQEAKICIqICAgICAgICAgIC0gdsOkbGogYWxsYSBwb3N0ZXJcbiIKICIgICAgICAgICAgIC0gKHRvbXQpIGF2c2x1dGEgbWFya2VyaW5nXG4iCiAKLSM6IGJ1aWx0aW4vY2xlYW4uYzo1MjAgZ2l0LWFkZC0taW50ZXJhY3RpdmUucGVybDo1NjgKKyM6IGJ1aWx0aW4vY2xlYW4uYzo1MjEgZ2l0LWFkZC0taW50ZXJhY3RpdmUucGVybDo1NjgKICM6IGdpdC1hZGQtLWludGVyYWN0aXZlLnBlcmw6NTczCiAjLCBjLWZvcm1hdCwgcGVybC1mb3JtYXQKIG1zZ2lkICJIdWggKCVzKT9cbiIKIG1zZ3N0ciAiVmFkw6UgKCVzKT9cbiIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjY2MgorIzogYnVpbHRpbi9jbGVhbi5jOjY2MwogIywgYy1mb3JtYXQKIG1zZ2lkICJJbnB1dCBpZ25vcmUgcGF0dGVybnM+PiAiCiBtc2dzdHIgIkFuZ2UgaWdub3JlcmluZ3Ntw7Zuc3Rlcj4+IgogCi0jOiBidWlsdGluL2NsZWFuLmM6Njk5CisjOiBidWlsdGluL2NsZWFuLmM6NzAwCiAjLCBjLWZvcm1hdAogbXNnaWQgIldBUk5JTkc6IENhbm5vdCBmaW5kIGl0ZW1zIG1hdGNoZWQgYnk6ICVzIgogbXNnc3RyICJWQVJOSU5HOiBIaXR0YXIgaW50ZSBwb3N0ZXIgc29tIG1vdHN2YXJhcjogJXMiCiAKLSM6IGJ1aWx0aW4vY2xlYW4uYzo3MjAKKyM6IGJ1aWx0aW4vY2xlYW4uYzo3MjEKIG1zZ2lkICJTZWxlY3QgaXRlbXMgdG8gZGVsZXRlIgogbXNnc3RyICJWw6RsaiBwb3N0ZXIgYXR0IHRhIGJvcnQiCiAKICMuIFRSQU5TTEFUT1JTOiBNYWtlIHN1cmUgdG8ga2VlcCBbeS9OXSBhcyBpcwotIzogYnVpbHRpbi9jbGVhbi5jOjc2MQorIzogYnVpbHRpbi9jbGVhbi5jOjc2MgogIywgYy1mb3JtYXQKIG1zZ2lkICJSZW1vdmUgJXMgW3kvTl0/ICIKIG1zZ3N0ciAiVGEgYm9ydCAlcyBbWT1qYSAvIE49bmVqXT8gIgogCi0jOiBidWlsdGluL2NsZWFuLmM6Nzg2IGdpdC1hZGQtLWludGVyYWN0aXZlLnBlcmw6MTc2MworIzogYnVpbHRpbi9jbGVhbi5jOjc4NyBnaXQtYWRkLS1pbnRlcmFjdGl2ZS5wZXJsOjE3NjMKICMsIGMtZm9ybWF0CiBtc2dpZCAiQnllLlxuIgogbXNnc3RyICJIZWogZMOlLlxuIgogCi0jOiBidWlsdGluL2NsZWFuLmM6Nzk0CisjOiBidWlsdGluL2NsZWFuLmM6Nzk1CiBtc2dpZCAiIgogImNsZWFuICAgICAgICAgICAgICAgLSBzdGFydCBjbGVhbmluZ1xuIgogImZpbHRlciBieSBwYXR0ZXJuICAgLSBleGNsdWRlIGl0ZW1zIGZyb20gZGVsZXRpb25cbiIKQEAgLTEwNzY3LDY0ICsxMDgwNyw2NCBAQAogImhlbHAgICAgICAgICAgICAgICAgLSBkZW5uYSBza8Okcm1cbiIKICI/ICAgICAgICAgICAgICAgICAgIC0gaGrDpGxwIGbDtnIga29tbWFuZG92YWwiCiAKLSM6IGJ1aWx0aW4vY2xlYW4uYzo4MjEgZ2l0LWFkZC0taW50ZXJhY3RpdmUucGVybDoxODQ5CisjOiBidWlsdGluL2NsZWFuLmM6ODIyIGdpdC1hZGQtLWludGVyYWN0aXZlLnBlcmw6MTg0OQogbXNnaWQgIioqKiBDb21tYW5kcyAqKioiCiBtc2dzdHIgIioqKiBLb21tYW5kb24gKioqIgogCi0jOiBidWlsdGluL2NsZWFuLmM6ODIyIGdpdC1hZGQtLWludGVyYWN0aXZlLnBlcmw6MTg0NgorIzogYnVpbHRpbi9jbGVhbi5jOjgyMyBnaXQtYWRkLS1pbnRlcmFjdGl2ZS5wZXJsOjE4NDYKIG1zZ2lkICJXaGF0IG5vdyIKIG1zZ3N0ciAiVmFkIG51IgogCi0jOiBidWlsdGluL2NsZWFuLmM6ODMwCisjOiBidWlsdGluL2NsZWFuLmM6ODMxCiBtc2dpZCAiV291bGQgcmVtb3ZlIHRoZSBmb2xsb3dpbmcgaXRlbToiCiBtc2dpZF9wbHVyYWwgIldvdWxkIHJlbW92ZSB0aGUgZm9sbG93aW5nIGl0ZW1zOiIKIG1zZ3N0clswXSAiU2t1bGxlIHRhIGJvcnQgZsO2bGphbmRlIHBvc3Q6IgogbXNnc3RyWzFdICJTa3VsbGUgdGEgYm9ydCBmw7ZsamFuZGUgcG9zdGVyOiIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjg0NgorIzogYnVpbHRpbi9jbGVhbi5jOjg0NwogbXNnaWQgIk5vIG1vcmUgZmlsZXMgdG8gY2xlYW4sIGV4aXRpbmcuIgogbXNnc3RyICJJbmdhIGZsZXIgZmlsZXIgYXR0IHN0w6RkYSwgYXZzbHV0YXIuIgogCi0jOiBidWlsdGluL2NsZWFuLmM6OTA4CisjOiBidWlsdGluL2NsZWFuLmM6OTA5CiBtc2dpZCAiZG8gbm90IHByaW50IG5hbWVzIG9mIGZpbGVzIHJlbW92ZWQiCiBtc2dzdHIgInNrcml2IGludGUgdXQgbmFtbiBww6UgYm9ydHRhZ25hIGZpbGVyIgogCi0jOiBidWlsdGluL2NsZWFuLmM6OTEwCisjOiBidWlsdGluL2NsZWFuLmM6OTExCiBtc2dpZCAiZm9yY2UiCiBtc2dzdHIgInR2aW5nYSIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjkxMQorIzogYnVpbHRpbi9jbGVhbi5jOjkxMgogbXNnaWQgImludGVyYWN0aXZlIGNsZWFuaW5nIgogbXNnc3RyICJzdMOkZGEgaW50ZXJha3RpdnQiCiAKLSM6IGJ1aWx0aW4vY2xlYW4uYzo5MTMKKyM6IGJ1aWx0aW4vY2xlYW4uYzo5MTQKIG1zZ2lkICJyZW1vdmUgd2hvbGUgZGlyZWN0b3JpZXMiCiBtc2dzdHIgInRhIGJvcnQgaGVsYSBrYXRhbG9nZXIiCiAKLSM6IGJ1aWx0aW4vY2xlYW4uYzo5MTQgYnVpbHRpbi9kZXNjcmliZS5jOjU0NiBidWlsdGluL2Rlc2NyaWJlLmM6NTQ4Ci0jOiBidWlsdGluL2dyZXAuYzo4OTkgYnVpbHRpbi9sb2cuYzoxODYgYnVpbHRpbi9sb2cuYzoxODgKLSM6IGJ1aWx0aW4vbHMtZmlsZXMuYzo1NTcgYnVpbHRpbi9uYW1lLXJldi5jOjQxMyBidWlsdGluL25hbWUtcmV2LmM6NDE1CisjOiBidWlsdGluL2NsZWFuLmM6OTE1IGJ1aWx0aW4vZGVzY3JpYmUuYzo1NDggYnVpbHRpbi9kZXNjcmliZS5jOjU1MAorIzogYnVpbHRpbi9ncmVwLmM6OTAxIGJ1aWx0aW4vbG9nLmM6MTc2IGJ1aWx0aW4vbG9nLmM6MTc4CisjOiBidWlsdGluL2xzLWZpbGVzLmM6NTU3IGJ1aWx0aW4vbmFtZS1yZXYuYzo0MTcgYnVpbHRpbi9uYW1lLXJldi5jOjQxOQogIzogYnVpbHRpbi9zaG93LXJlZi5jOjE3OQogbXNnaWQgInBhdHRlcm4iCiBtc2dzdHIgIm3Dtm5zdGVyIgogCi0jOiBidWlsdGluL2NsZWFuLmM6OTE1CisjOiBidWlsdGluL2NsZWFuLmM6OTE2CiBtc2dpZCAiYWRkIDxwYXR0ZXJuPiB0byBpZ25vcmUgcnVsZXMiCiBtc2dzdHIgImzDpGdnIHRpbGwgPG3Dtm5zdGVyPiB0aWxsIGlnbm9yZXJpbmdzcmVnbGVyIgogCi0jOiBidWlsdGluL2NsZWFuLmM6OTE2CisjOiBidWlsdGluL2NsZWFuLmM6OTE3CiBtc2dpZCAicmVtb3ZlIGlnbm9yZWQgZmlsZXMsIHRvbyIKIG1zZ3N0ciAidGEgw6R2ZW4gYm9ydCBpZ25vcmVyYWRlIGZpbGVyIgogCi0jOiBidWlsdGluL2NsZWFuLmM6OTE4CisjOiBidWlsdGluL2NsZWFuLmM6OTE5CiBtc2dpZCAicmVtb3ZlIG9ubHkgaWdub3JlZCBmaWxlcyIKIG1zZ3N0ciAidGEgZW5kYXN0IGJvcnQgaWdub3JlcmFkZSBmaWxlciIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjkzNgorIzogYnVpbHRpbi9jbGVhbi5jOjkzNwogbXNnaWQgIi14IGFuZCAtWCBjYW5ub3QgYmUgdXNlZCB0b2dldGhlciIKIG1zZ3N0ciAiLXggb2NoIC1YIGthbiBpbnRlIGFudsOkbmRhcyBzYW10aWRpZ3QiCiAKLSM6IGJ1aWx0aW4vY2xlYW4uYzo5NDAKKyM6IGJ1aWx0aW4vY2xlYW4uYzo5NDEKIG1zZ2lkICIiCiAiY2xlYW4ucmVxdWlyZUZvcmNlIHNldCB0byB0cnVlIGFuZCBuZWl0aGVyIC1pLCAtbiwgbm9yIC1mIGdpdmVuOyByZWZ1c2luZyB0byAiCiAiY2xlYW4iCkBAIC0xMDgzMiw3ICsxMDg3Miw3IEBACiAiY2xlYW4ucmVxdWlyZUZvcmNlIHNhdHQgdGlsbCB0cnVlLCBtZW4gdmFya2VuIC1pLCAtbiBlbGxlciAtZiBhbmdhdnM7IHbDpGdyYXIgIgogInN0w6RkYSIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjk0MworIzogYnVpbHRpbi9jbGVhbi5jOjk0NAogbXNnaWQgIiIKICJjbGVhbi5yZXF1aXJlRm9yY2UgZGVmYXVsdHMgdG8gdHJ1ZSBhbmQgbmVpdGhlciAtaSwgLW4sIG5vciAtZiBnaXZlbjsgIgogInJlZnVzaW5nIHRvIGNsZWFuIgpAQCAtMTA4NDAsMTYyICsxMDg4MCwxNjIgQEAKICJjbGVhbi5yZXF1aXJlRm9yY2UgaGFyIHN0YW5kYXJkdsOkcmRldCB0cnVlIG9jaCB2YXJrZW4gLWksIC1uIGVsbGVyIC1mICIKICJhbmdhdnM7IHbDpGdyYXIgc3TDpGRhIgogCi0jOiBidWlsdGluL2Nsb25lLmM6NDYKKyM6IGJ1aWx0aW4vY2xvbmUuYzo0NQogbXNnaWQgImdpdCBjbG9uZSBbPG9wdGlvbnM+XSBbLS1dIDxyZXBvPiBbPGRpcj5dIgogbXNnc3RyICJnaXQgY2xvbmUgWzxmbGFnZ29yPl0gWy0tXSA8YXJraXY+IFs8a2F0Pl0iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo5MworIzogYnVpbHRpbi9jbG9uZS5jOjkyCiBtc2dpZCAiZG9uJ3QgY3JlYXRlIGEgY2hlY2tvdXQiCiBtc2dzdHIgInNrYXBhIGludGUgbsOlZ29uIHV0Y2hlY2tuaW5nIgogCi0jOiBidWlsdGluL2Nsb25lLmM6OTQgYnVpbHRpbi9jbG9uZS5jOjk2IGJ1aWx0aW4vaW5pdC1kYi5jOjQ4OQorIzogYnVpbHRpbi9jbG9uZS5jOjkzIGJ1aWx0aW4vY2xvbmUuYzo5NSBidWlsdGluL2luaXQtZGIuYzo0ODkKIG1zZ2lkICJjcmVhdGUgYSBiYXJlIHJlcG9zaXRvcnkiCiBtc2dzdHIgInNrYXBhIGV0dCBuYWtldCAoXCJiYXJlXCIpIGFya2l2IgogCi0jOiBidWlsdGluL2Nsb25lLmM6OTgKKyM6IGJ1aWx0aW4vY2xvbmUuYzo5NwogbXNnaWQgImNyZWF0ZSBhIG1pcnJvciByZXBvc2l0b3J5IChpbXBsaWVzIGJhcmUpIgogbXNnc3RyICJza2FwYSBldHQgc3BlZ2VsYXJraXYgKGltcGxpY2VyYXIgXCJiYXJlXCIpIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTAwCisjOiBidWlsdGluL2Nsb25lLmM6OTkKIG1zZ2lkICJ0byBjbG9uZSBmcm9tIGEgbG9jYWwgcmVwb3NpdG9yeSIKIG1zZ3N0ciAiZsO2ciBhdHQga2xvbmEgZnLDpW4gZXR0IGxva2FsdCBhcmtpdiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEwMgorIzogYnVpbHRpbi9jbG9uZS5jOjEwMQogbXNnaWQgImRvbid0IHVzZSBsb2NhbCBoYXJkbGlua3MsIGFsd2F5cyBjb3B5IgogbXNnc3RyICJza2FwYSBpbnRlIGxva2FsYSBow6VyZGEgbMOkbmthciwga29waWVyYSBhbGx0aWQiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMDQKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMDMKIG1zZ2lkICJzZXR1cCBhcyBzaGFyZWQgcmVwb3NpdG9yeSIKIG1zZ3N0ciAic2thcGEgc29tIGV0dCBkZWxhdCBhcmtpdiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEwNworIzogYnVpbHRpbi9jbG9uZS5jOjEwNgogbXNnaWQgInBhdGhzcGVjIgogbXNnc3RyICJzw7ZrdsOkZ3NhbmdpdmVsc2UiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMDcKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMDYKIG1zZ2lkICJpbml0aWFsaXplIHN1Ym1vZHVsZXMgaW4gdGhlIGNsb25lIgogbXNnc3RyICJpbml0aWVyYSB1bmRlcm1vZHVsZXIgaSBrbG9uZW4iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMTAKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMDkKIG1zZ2lkICJudW1iZXIgb2Ygc3VibW9kdWxlcyBjbG9uZWQgaW4gcGFyYWxsZWwiCiBtc2dzdHIgImFudGFsIHVuZGVybW9kdWxlciBzb20ga2xvbmFzIHBhcmFsbGVsbHQiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMTEgYnVpbHRpbi9pbml0LWRiLmM6NDg2CisjOiBidWlsdGluL2Nsb25lLmM6MTEwIGJ1aWx0aW4vaW5pdC1kYi5jOjQ4NgogbXNnaWQgInRlbXBsYXRlLWRpcmVjdG9yeSIKIG1zZ3N0ciAibWFsbGthdGFsb2ciCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMTIgYnVpbHRpbi9pbml0LWRiLmM6NDg3CisjOiBidWlsdGluL2Nsb25lLmM6MTExIGJ1aWx0aW4vaW5pdC1kYi5jOjQ4NwogbXNnaWQgImRpcmVjdG9yeSBmcm9tIHdoaWNoIHRlbXBsYXRlcyB3aWxsIGJlIHVzZWQiCiBtc2dzdHIgImthdGFsb2cgYXR0IGFudsOkbmRhIG1hbGxhciBmcsOlbiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjExNCBidWlsdGluL2Nsb25lLmM6MTE2IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxMzgwCisjOiBidWlsdGluL2Nsb25lLmM6MTEzIGJ1aWx0aW4vY2xvbmUuYzoxMTUgYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjEzODAKICM6IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxODYwCiBtc2dpZCAicmVmZXJlbmNlIHJlcG9zaXRvcnkiCiBtc2dzdHIgInJlZmVyZW5zYXJraXYiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMTggYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjEzODIKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMTcgYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjEzODIKICM6IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxODYyCiBtc2dpZCAidXNlIC0tcmVmZXJlbmNlIG9ubHkgd2hpbGUgY2xvbmluZyIKIG1zZ3N0ciAiYW52w6RuZCAtLXJlZmVyZW5jZSBlbmRhc3QgdW5kZXIga2xvbmluZ2VuIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTE5IGJ1aWx0aW4vY29sdW1uLmM6MjcgYnVpbHRpbi9tZXJnZS1maWxlLmM6NDYKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMwOCBidWlsdGluL3JlcGFjay5jOjMzMAorIzogYnVpbHRpbi9jbG9uZS5jOjExOCBidWlsdGluL2NvbHVtbi5jOjI3IGJ1aWx0aW4vbWVyZ2UtZmlsZS5jOjQ2CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyOTQgYnVpbHRpbi9yZXBhY2suYzozMjAKIG1zZ2lkICJuYW1lIgogbXNnc3RyICJuYW1uIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTIwCisjOiBidWlsdGluL2Nsb25lLmM6MTE5CiBtc2dpZCAidXNlIDxuYW1lPiBpbnN0ZWFkIG9mICdvcmlnaW4nIHRvIHRyYWNrIHVwc3RyZWFtIgogbXNnc3RyICJhbnbDpG5kIDxuYW1uPiBpc3TDpGxsZXQgZsO2ciBcIm9yaWdpblwiIGbDtnIgYXR0IHNww6VyYSB1cHBzdHLDtm1zIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTIyCisjOiBidWlsdGluL2Nsb25lLmM6MTIxCiBtc2dpZCAiY2hlY2tvdXQgPGJyYW5jaD4gaW5zdGVhZCBvZiB0aGUgcmVtb3RlJ3MgSEVBRCIKIG1zZ3N0ciAiY2hlY2thIHV0IDxncmVuPiBpc3TDpGxsZXQgZsO2ciBmasOkcnJlbnMgSEVBRCIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEyNAorIzogYnVpbHRpbi9jbG9uZS5jOjEyMwogbXNnaWQgInBhdGggdG8gZ2l0LXVwbG9hZC1wYWNrIG9uIHRoZSByZW1vdGUiCiBtc2dzdHIgInPDtmt2w6RnIHRpbGwgZ2l0LXVwbG9hZC1wYWNrIHDDpSBmasOkcnJlbiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEyNSBidWlsdGluL2ZldGNoLmM6MTUyIGJ1aWx0aW4vZ3JlcC5jOjgzOAotIzogYnVpbHRpbi9wdWxsLmM6MjI2CisjOiBidWlsdGluL2Nsb25lLmM6MTI0IGJ1aWx0aW4vZmV0Y2guYzoxNjcgYnVpbHRpbi9ncmVwLmM6ODQwCisjOiBidWlsdGluL3B1bGwuYzoyMjcKIG1zZ2lkICJkZXB0aCIKIG1zZ3N0ciAiZGp1cCIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEyNgorIzogYnVpbHRpbi9jbG9uZS5jOjEyNQogbXNnaWQgImNyZWF0ZSBhIHNoYWxsb3cgY2xvbmUgb2YgdGhhdCBkZXB0aCIKIG1zZ3N0ciAic2thcGEgZW4gZ3J1bmQga2xvbiBww6UgZGV0dGEgZGp1cCIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEyNyBidWlsdGluL2ZldGNoLmM6MTU0IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI5NworIzogYnVpbHRpbi9jbG9uZS5jOjEyNiBidWlsdGluL2ZldGNoLmM6MTY5IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI4MwogbXNnaWQgInRpbWUiCiBtc2dzdHIgInRpZCIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEyOAorIzogYnVpbHRpbi9jbG9uZS5jOjEyNwogbXNnaWQgImNyZWF0ZSBhIHNoYWxsb3cgY2xvbmUgc2luY2UgYSBzcGVjaWZpYyB0aW1lIgogbXNnc3RyICJza2FwYSBlbiBncnVuZCBrbG9uIGZyw6VuIGVuIGFuZ2l2ZW4gdGlkcHVua3QiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMjkgYnVpbHRpbi9mZXRjaC5jOjE1NiBidWlsdGluL2ZldGNoLmM6MTc5Ci0jOiBidWlsdGluL3JlYmFzZS5jOjEzOTUKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMjggYnVpbHRpbi9mZXRjaC5jOjE3MSBidWlsdGluL2ZldGNoLmM6MTk0CisjOiBidWlsdGluL3JlYmFzZS5jOjE0MTcKIG1zZ2lkICJyZXZpc2lvbiIKIG1zZ3N0ciAicmV2aXNpb24iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMzAgYnVpbHRpbi9mZXRjaC5jOjE1NworIzogYnVpbHRpbi9jbG9uZS5jOjEyOSBidWlsdGluL2ZldGNoLmM6MTcyCiBtc2dpZCAiZGVlcGVuIGhpc3Rvcnkgb2Ygc2hhbGxvdyBjbG9uZSwgZXhjbHVkaW5nIHJldiIKIG1zZ3N0ciAiZsO2cmRqdXBhIGhpc3RvcmlrIGbDtnIgZ3J1bmQga2xvbiwgZXhrbHVkZXJhIHJldmlzaW9uZW4iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMzIKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMzEKIG1zZ2lkICJjbG9uZSBvbmx5IG9uZSBicmFuY2gsIEhFQUQgb3IgLS1icmFuY2giCiBtc2dzdHIgImtsb25hIGVuZGFzdCBlbiBncmVuLCBIRUFEIGVsbGVyIC0tYnJhbmNoIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTM0CisjOiBidWlsdGluL2Nsb25lLmM6MTMzCiBtc2dpZCAiZG9uJ3QgY2xvbmUgYW55IHRhZ3MsIGFuZCBtYWtlIGxhdGVyIGZldGNoZXMgbm90IHRvIGZvbGxvdyB0aGVtIgogbXNnc3RyICJrbG9uYSBpbmdhIHRhZ2dhciBvY2ggZ8O2ciBhdHQgc2VuYXJlIGjDpG10bmluZ2FyIGludGUgZsO2bGplciBkZW0iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMzYKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMzUKIG1zZ2lkICJhbnkgY2xvbmVkIHN1Ym1vZHVsZXMgd2lsbCBiZSBzaGFsbG93IgogbXNnc3RyICJrbG9uYWRlIHVuZGVybW9kdWxlciBrb21tZXIgdmFyYSBncnVuZGEiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMzcgYnVpbHRpbi9pbml0LWRiLmM6NDk1CisjOiBidWlsdGluL2Nsb25lLmM6MTM2IGJ1aWx0aW4vaW5pdC1kYi5jOjQ5NQogbXNnaWQgImdpdGRpciIKIG1zZ3N0ciAiZ2l0a2F0IgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTM4IGJ1aWx0aW4vaW5pdC1kYi5jOjQ5NgorIzogYnVpbHRpbi9jbG9uZS5jOjEzNyBidWlsdGluL2luaXQtZGIuYzo0OTYKIG1zZ2lkICJzZXBhcmF0ZSBnaXQgZGlyIGZyb20gd29ya2luZyB0cmVlIgogbXNnc3RyICJzZXBhcmVyYSBnaXRrYXRhbG9nZW4gZnLDpW4gYXJiZXRza2F0YWxvZ2VuIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTM5CisjOiBidWlsdGluL2Nsb25lLmM6MTM4CiBtc2dpZCAia2V5PXZhbHVlIgogbXNnc3RyICJueWNrZWw9dsOkcmRlIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTQwCisjOiBidWlsdGluL2Nsb25lLmM6MTM5CiBtc2dpZCAic2V0IGNvbmZpZyBpbnNpZGUgdGhlIG5ldyByZXBvc2l0b3J5IgogbXNnc3RyICJzdMOkbGwgaW4ga29uZmlndXJhdGlvbiBpIGRldCBueWEgYXJraXZldCIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjE0MiBidWlsdGluL2ZldGNoLmM6MTc0IGJ1aWx0aW4vbHMtcmVtb3RlLmM6NzYKLSM6IGJ1aWx0aW4vcHVzaC5jOjU4NSBidWlsdGluL3NlbmQtcGFjay5jOjE3MgorIzogYnVpbHRpbi9jbG9uZS5jOjE0MSBidWlsdGluL2ZldGNoLmM6MTg5IGJ1aWx0aW4vbHMtcmVtb3RlLmM6NzYKKyM6IGJ1aWx0aW4vcHVzaC5jOjU3MiBidWlsdGluL3NlbmQtcGFjay5jOjE3MgogbXNnaWQgInNlcnZlci1zcGVjaWZpYyIKIG1zZ3N0ciAic2VydmVyc3BlY2lmaWsiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxNDIgYnVpbHRpbi9mZXRjaC5jOjE3NCBidWlsdGluL2xzLXJlbW90ZS5jOjc2Ci0jOiBidWlsdGluL3B1c2guYzo1ODUgYnVpbHRpbi9zZW5kLXBhY2suYzoxNzMKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxNDEgYnVpbHRpbi9mZXRjaC5jOjE4OSBidWlsdGluL2xzLXJlbW90ZS5jOjc2CisjOiBidWlsdGluL3B1c2guYzo1NzIgYnVpbHRpbi9zZW5kLXBhY2suYzoxNzMKIG1zZ2lkICJvcHRpb24gdG8gdHJhbnNtaXQiCiBtc2dzdHIgIiIKICJpbmdldCBhdHQgY2hlY2thIGluXG4iCiAiZmxhZ2dhIGF0dCBzw6RuZGEiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxNDMgYnVpbHRpbi9mZXRjaC5jOjE3NSBidWlsdGluL3B1bGwuYzoyMzkKLSM6IGJ1aWx0aW4vcHVzaC5jOjU4NgorIzogYnVpbHRpbi9jbG9uZS5jOjE0MiBidWlsdGluL2ZldGNoLmM6MTkwIGJ1aWx0aW4vcHVsbC5jOjI0MAorIzogYnVpbHRpbi9wdXNoLmM6NTczCiBtc2dpZCAidXNlIElQdjQgYWRkcmVzc2VzIG9ubHkiCiBtc2dzdHIgImFudsOkbmQgZW5kYXN0IElQdjQtYWRyZXNzZXIiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxNDUgYnVpbHRpbi9mZXRjaC5jOjE3NyBidWlsdGluL3B1bGwuYzoyNDIKLSM6IGJ1aWx0aW4vcHVzaC5jOjU4OAorIzogYnVpbHRpbi9jbG9uZS5jOjE0NCBidWlsdGluL2ZldGNoLmM6MTkyIGJ1aWx0aW4vcHVsbC5jOjI0MworIzogYnVpbHRpbi9wdXNoLmM6NTc1CiBtc2dpZCAidXNlIElQdjYgYWRkcmVzc2VzIG9ubHkiCiBtc2dzdHIgImFudsOkbmQgZW5kYXN0IElQdjYtYWRyZXNzZXIiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxNDkKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxNDgKIG1zZ2lkICJhbnkgY2xvbmVkIHN1Ym1vZHVsZXMgd2lsbCB1c2UgdGhlaXIgcmVtb3RlLXRyYWNraW5nIGJyYW5jaCIKIG1zZ3N0ciAia2xvbmFkZSB1bmRlcm1vZHVsZXIga29tbWVyIGFudsOkbmRhIHNpbiBmasOkcnJzcMOlcm5pbmdzZ3JlbiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjI4NQorIzogYnVpbHRpbi9jbG9uZS5jOjI4NAogbXNnaWQgIiIKICJObyBkaXJlY3RvcnkgbmFtZSBjb3VsZCBiZSBndWVzc2VkLlxuIgogIlBsZWFzZSBzcGVjaWZ5IGEgZGlyZWN0b3J5IG9uIHRoZSBjb21tYW5kIGxpbmUiCkBAIC0xMTAwMyw0NyArMTEwNDMsNDIgQEAKICJLdW5kZSBpbnRlIGdpc3NhIGthdGFsb2duYW1uLlxuIgogIkFuZ2UgZW4ga2F0YWxvZyBww6Uga29tbWFuZG9yYWRlbiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjMzOAorIzogYnVpbHRpbi9jbG9uZS5jOjMzNwogIywgYy1mb3JtYXQKIG1zZ2lkICJpbmZvOiBDb3VsZCBub3QgYWRkIGFsdGVybmF0ZSBmb3IgJyVzJzogJXNcbiIKIG1zZ3N0ciAiaW5mbzogS2FuIGludGUgc2thcGEgYWx0ZXJuYXRpdiBmw7ZyIFwiJXNcIjogJXNcbiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjQxMQorIzogYnVpbHRpbi9jbG9uZS5jOjQxMAogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyBleGlzdHMgYW5kIGlzIG5vdCBhIGRpcmVjdG9yeSIKIG1zZ3N0ciAiJXMgZmlubnMgb2NoIMOkciBpbmdlbiBrYXRhbG9nIgogCi0jOiBidWlsdGluL2Nsb25lLmM6NDI4CisjOiBidWlsdGluL2Nsb25lLmM6NDI3CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBzdGFydCBpdGVyYXRvciBvdmVyICclcyciCiBtc2dzdHIgIm1pc3NseWNrYWRlcyBzdGFydGEgaXRlcmF0b3Igw7Z2ZXIgXCIlc1wiIgogCi0jOiBidWlsdGluL2Nsb25lLmM6NDUzCi0jLCBjLWZvcm1hdAotbXNnaWQgImZhaWxlZCB0byB1bmxpbmsgJyVzJyIKLW1zZ3N0ciAibWlzc2x5Y2thZGVzIHRhIGJvcnQgbMOkbmtlbiBcIiVzXCIiCi0KLSM6IGJ1aWx0aW4vY2xvbmUuYzo0NTgKKyM6IGJ1aWx0aW4vY2xvbmUuYzo0NTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIGNyZWF0ZSBsaW5rICclcyciCiBtc2dzdHIgIm1pc3NseWNrYWRlcyBza2FwYSBsw6Rua2VuIFwiJXNcIiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjQ2MgorIzogYnVpbHRpbi9jbG9uZS5jOjQ2MQogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gY29weSBmaWxlIHRvICclcyciCiBtc2dzdHIgIm1pc3NseWNrYWRlcyBrb3BpZXJhIGZpbGVuIHRpbGwgXCIlc1wiIgogCi0jOiBidWlsdGluL2Nsb25lLmM6NDY3CisjOiBidWlsdGluL2Nsb25lLmM6NDY2CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBpdGVyYXRlIG92ZXIgJyVzJyIKIG1zZ3N0ciAibWlzc2x5Y2thZGVzIGl0ZXJlcmEgw7Z2ZXIgXCIlc1wiIgogCi0jOiBidWlsdGluL2Nsb25lLmM6NDkyCisjOiBidWlsdGluL2Nsb25lLmM6NDkxCiAjLCBjLWZvcm1hdAogbXNnaWQgImRvbmUuXG4iCiBtc2dzdHIgImtsYXJ0LlxuIgogCi0jOiBidWlsdGluL2Nsb25lLmM6NTA2CisjOiBidWlsdGluL2Nsb25lLmM6NTA1CiBtc2dpZCAiIgogIkNsb25lIHN1Y2NlZWRlZCwgYnV0IGNoZWNrb3V0IGZhaWxlZC5cbiIKICJZb3UgY2FuIGluc3BlY3Qgd2hhdCB3YXMgY2hlY2tlZCBvdXQgd2l0aCAnZ2l0IHN0YXR1cydcbiIKQEAgLTExMDUzLDEzMyArMTEwODgsMTMzIEBACiAiRHUga2FuIGluc3Bla3RlcmEgZGV0IHNvbSBjaGVja2FkZXMgdXQgbWVkIFwiZ2l0IHN0YXR1c1wiXG4iCiAib2NoIGbDtnJzw7ZrYSBtZWQgXCJnaXQgcmVzdG9yZSAtc291cmNlPUhFQUQgOi9cIlxuIgogCi0jOiBidWlsdGluL2Nsb25lLmM6NTgzCisjOiBidWlsdGluL2Nsb25lLmM6NTgyCiAjLCBjLWZvcm1hdAogbXNnaWQgIkNvdWxkIG5vdCBmaW5kIHJlbW90ZSBicmFuY2ggJXMgdG8gY2xvbmUuIgogbXNnc3RyICJLdW5kZSBpbnRlIGhpdHRhIGZqw6RycmdyZW5lbiAlcyBmw7ZyIGF0dCBrbG9uYS4iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo3MDIKKyM6IGJ1aWx0aW4vY2xvbmUuYzo3MDEKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHVwZGF0ZSAlcyIKIG1zZ3N0ciAia2FuIGludGUgdXBwZGF0ZXJhICVzIgogCi0jOiBidWlsdGluL2Nsb25lLmM6NzUyCisjOiBidWlsdGluL2Nsb25lLmM6NzUxCiBtc2dpZCAicmVtb3RlIEhFQUQgcmVmZXJzIHRvIG5vbmV4aXN0ZW50IHJlZiwgdW5hYmxlIHRvIGNoZWNrb3V0LlxuIgogbXNnc3RyICIiCiAiSEVBRCBob3MgZmrDpHJyZW4gcGVrYXIgcMOlIGVuIG9iZWZpbnRsaWcgcmVmZXJlbnMsIGthbiBpbnRlIGNoZWNrYSB1dC5cbiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjc4MworIzogYnVpbHRpbi9jbG9uZS5jOjc4MgogbXNnaWQgInVuYWJsZSB0byBjaGVja291dCB3b3JraW5nIHRyZWUiCiBtc2dzdHIgImt1bmRlIGludGUgY2hlY2thIHV0IGFyYmV0c2thdGFsb2dlbiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjgzMworIzogYnVpbHRpbi9jbG9uZS5jOjgzMgogbXNnaWQgInVuYWJsZSB0byB3cml0ZSBwYXJhbWV0ZXJzIHRvIGNvbmZpZyBmaWxlIgogbXNnc3RyICJrdW5kZSBpbnRlIHNrcml2YSBwYXJhbWV0cmFyIHRpbGwga29uZmlndXJhdGlvbnNmaWxlbiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjg5NgorIzogYnVpbHRpbi9jbG9uZS5jOjg5NQogbXNnaWQgImNhbm5vdCByZXBhY2sgdG8gY2xlYW4gdXAiCiBtc2dzdHIgImthbiBpbnRlIHBhY2thIG9tIGbDtnIgYXR0IHN0w6RkYSB1cHAiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo4OTgKKyM6IGJ1aWx0aW4vY2xvbmUuYzo4OTcKIG1zZ2lkICJjYW5ub3QgdW5saW5rIHRlbXBvcmFyeSBhbHRlcm5hdGVzIGZpbGUiCiBtc2dzdHIgImt1bmRlIGludGUgdGEgYm9ydCB0ZW1wb3LDpHIgXCJhbHRlcm5hdGVzXCItZmlsIgogCi0jOiBidWlsdGluL2Nsb25lLmM6OTM4IGJ1aWx0aW4vcmVjZWl2ZS1wYWNrLmM6MTk1MAorIzogYnVpbHRpbi9jbG9uZS5jOjkzNyBidWlsdGluL3JlY2VpdmUtcGFjay5jOjE5NDgKIG1zZ2lkICJUb28gbWFueSBhcmd1bWVudHMuIgogbXNnc3RyICJGw7ZyIG3DpW5nYSBhcmd1bWVudC4iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo5NDIKKyM6IGJ1aWx0aW4vY2xvbmUuYzo5NDEKIG1zZ2lkICJZb3UgbXVzdCBzcGVjaWZ5IGEgcmVwb3NpdG9yeSB0byBjbG9uZS4iCiBtc2dzdHIgIkR1IG3DpXN0ZSBhbmdlIGV0dCBhcmtpdiBhdHQga2xvbmEuIgogCi0jOiBidWlsdGluL2Nsb25lLmM6OTU1CisjOiBidWlsdGluL2Nsb25lLmM6OTU0CiAjLCBjLWZvcm1hdAogbXNnaWQgIi0tYmFyZSBhbmQgLS1vcmlnaW4gJXMgb3B0aW9ucyBhcmUgaW5jb21wYXRpYmxlLiIKIG1zZ3N0ciAiZmxhZ2dvcm5hIC0tYmFyZSBvY2ggLS1vcmlnaW4gJXMgw6RyIGlua29tcGF0aWJsYS4iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo5NTgKKyM6IGJ1aWx0aW4vY2xvbmUuYzo5NTcKIG1zZ2lkICItLWJhcmUgYW5kIC0tc2VwYXJhdGUtZ2l0LWRpciBhcmUgaW5jb21wYXRpYmxlLiIKIG1zZ3N0ciAiZmxhZ2dvcm5hIC0tYmFyZSBvY2ggLS1zZXBhcmF0ZS1naXQtZGlyIMOkciBpbmtvbXBhdGlibGEuIgogCi0jOiBidWlsdGluL2Nsb25lLmM6OTcxCisjOiBidWlsdGluL2Nsb25lLmM6OTcwCiAjLCBjLWZvcm1hdAogbXNnaWQgInJlcG9zaXRvcnkgJyVzJyBkb2VzIG5vdCBleGlzdCIKIG1zZ3N0ciAiYXJraXZldCBcIiVzXCIgZmlubnMgaW50ZSIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjk3NyBidWlsdGluL2ZldGNoLmM6MTY1MworIzogYnVpbHRpbi9jbG9uZS5jOjk3NiBidWlsdGluL2ZldGNoLmM6MTc5MAogIywgYy1mb3JtYXQKIG1zZ2lkICJkZXB0aCAlcyBpcyBub3QgYSBwb3NpdGl2ZSBudW1iZXIiCiBtc2dzdHIgImRqdXBldCAlcyDDpHIgaW50ZSBldHQgcG9zaXRpdnQgdGFsIgogCi0jOiBidWlsdGluL2Nsb25lLmM6OTg3CisjOiBidWlsdGluL2Nsb25lLmM6OTg2CiAjLCBjLWZvcm1hdAogbXNnaWQgImRlc3RpbmF0aW9uIHBhdGggJyVzJyBhbHJlYWR5IGV4aXN0cyBhbmQgaXMgbm90IGFuIGVtcHR5IGRpcmVjdG9yeS4iCiBtc2dzdHIgImRlc3RpbmF0aW9uc3PDtmt2w6RnZW4gXCIlc1wiIGZpbm5zIHJlZGFuIG9jaCDDpHIgaW50ZSBlbiB0b20ga2F0YWxvZy4iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo5OTcKKyM6IGJ1aWx0aW4vY2xvbmUuYzo5OTYKICMsIGMtZm9ybWF0CiBtc2dpZCAid29ya2luZyB0cmVlICclcycgYWxyZWFkeSBleGlzdHMuIgogbXNnc3RyICJhcmJldHN0csOkZGV0IFwiJXNcIiBmaW5ucyByZWRhbi4iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMDEyIGJ1aWx0aW4vY2xvbmUuYzoxMDMzIGJ1aWx0aW4vZGlmZnRvb2wuYzoyNjQKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzozMDMgYnVpbHRpbi93b3JrdHJlZS5jOjMzNQorIzogYnVpbHRpbi9jbG9uZS5jOjEwMTEgYnVpbHRpbi9jbG9uZS5jOjEwMzIgYnVpbHRpbi9kaWZmdG9vbC5jOjI3MQorIzogYnVpbHRpbi9sb2cuYzoxNzg1IGJ1aWx0aW4vd29ya3RyZWUuYzozMDIgYnVpbHRpbi93b3JrdHJlZS5jOjMzNAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgY3JlYXRlIGxlYWRpbmcgZGlyZWN0b3JpZXMgb2YgJyVzJyIKIG1zZ3N0ciAia3VuZGUgaW50ZSBza2FwYSBpbmxlZGFuZGUga2F0YWxvZ2VyIGbDtnIgXCIlc1wiIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTAxNworIzogYnVpbHRpbi9jbG9uZS5jOjEwMTYKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGNyZWF0ZSB3b3JrIHRyZWUgZGlyICclcyciCiBtc2dzdHIgImt1bmRlIGludGUgc2thcGEgYXJiZXRza2F0YWxvZ2VuIFwiJXNcIiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEwMzcKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMDM2CiAjLCBjLWZvcm1hdAogbXNnaWQgIkNsb25pbmcgaW50byBiYXJlIHJlcG9zaXRvcnkgJyVzJy4uLlxuIgogbXNnc3RyICJLbG9uYXIgdGlsbCBldHQgbmFrZXQgYXJraXYgXCIlc1wiLi4uXG4iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMDM5CisjOiBidWlsdGluL2Nsb25lLmM6MTAzOAogIywgYy1mb3JtYXQKIG1zZ2lkICJDbG9uaW5nIGludG8gJyVzJy4uLlxuIgogbXNnc3RyICJLbG9uYXIgdGlsbCBcIiVzXCIuLi5cbiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEwNjMKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMDYyCiBtc2dpZCAiIgogImNsb25lIC0tcmVjdXJzaXZlIGlzIG5vdCBjb21wYXRpYmxlIHdpdGggYm90aCAtLXJlZmVyZW5jZSBhbmQgLS1yZWZlcmVuY2UtaWYtIgogImFibGUiCiBtc2dzdHIgIiIKICJjbG9uZSAtLXJlY3Vyc2l2ZSDDpHIgaW50ZSBrb21wYXRpYmVsIG1lZCAtLXJlZmVyZW5jZSBvY2ggLS1yZWZlcmVuY2UtaWYtYWJsZSIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjExMjQKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMTIzCiBtc2dpZCAiLS1kZXB0aCBpcyBpZ25vcmVkIGluIGxvY2FsIGNsb25lczsgdXNlIGZpbGU6Ly8gaW5zdGVhZC4iCiBtc2dzdHIgIi0tZGVwdGggaWdub3JlcmFzIGkgbG9rYWxhIGtsb25pbmdhcjsgYW52w6RuZCBmaWxlOi8vIGlzdMOkbGxldC4iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMTI2CisjOiBidWlsdGluL2Nsb25lLmM6MTEyNQogbXNnaWQgIi0tc2hhbGxvdy1zaW5jZSBpcyBpZ25vcmVkIGluIGxvY2FsIGNsb25lczsgdXNlIGZpbGU6Ly8gaW5zdGVhZC4iCiBtc2dzdHIgIi0tc2hhbGxvdy1zaW5jZSBpZ25vcmVyYXMgaSBsb2thbGEga2xvbmluZ2FyOyBhbnbDpG5kIGZpbGU6Ly8gaXN0w6RsbGV0LiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjExMjgKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMTI3CiBtc2dpZCAiLS1zaGFsbG93LWV4Y2x1ZGUgaXMgaWdub3JlZCBpbiBsb2NhbCBjbG9uZXM7IHVzZSBmaWxlOi8vIGluc3RlYWQuIgogbXNnc3RyICIiCiAiLS1zaGFsbG93LWV4Y2x1ZGUgaWdub3JlcmFzIGkgbG9rYWxhIGtsb25pbmdhcjsgYW52w6RuZCBmaWxlOi8vIGlzdMOkbGxldC4iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMTMwCisjOiBidWlsdGluL2Nsb25lLmM6MTEyOQogbXNnaWQgIi0tZmlsdGVyIGlzIGlnbm9yZWQgaW4gbG9jYWwgY2xvbmVzOyB1c2UgZmlsZTovLyBpbnN0ZWFkLiIKIG1zZ3N0ciAiLS1maWx0ZXIgaWdub3JlcmFzIGkgbG9rYWxhIGtsb25pbmdhcjsgYW52w6RuZCBmaWxlOi8vIGlzdMOkbGxldC4iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMTMzCisjOiBidWlsdGluL2Nsb25lLmM6MTEzMgogbXNnaWQgInNvdXJjZSByZXBvc2l0b3J5IGlzIHNoYWxsb3csIGlnbm9yaW5nIC0tbG9jYWwiCiBtc2dzdHIgImvDpGxsYXJraXZldCDDpHIgZ3J1bnQsIGlnbm9yZXJhciAtLWxvY2FsIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTEzOAorIzogYnVpbHRpbi9jbG9uZS5jOjExMzcKIG1zZ2lkICItLWxvY2FsIGlzIGlnbm9yZWQiCiBtc2dzdHIgIi0tbG9jYWwgaWdub3JlcmFzIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTIxNSBidWlsdGluL2Nsb25lLmM6MTIyMworIzogYnVpbHRpbi9jbG9uZS5jOjEyMTIgYnVpbHRpbi9jbG9uZS5jOjEyMjAKICMsIGMtZm9ybWF0CiBtc2dpZCAiUmVtb3RlIGJyYW5jaCAlcyBub3QgZm91bmQgaW4gdXBzdHJlYW0gJXMiCiBtc2dzdHIgIkZqw6RycmdyZW5lbiAlcyBoaXR0YWRlcyBpbnRlIGkgdXBwc3Ryw7Ztc2Fya2l2ZXQgJXMiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMjI2CisjOiBidWlsdGluL2Nsb25lLmM6MTIyMwogbXNnaWQgIllvdSBhcHBlYXIgdG8gaGF2ZSBjbG9uZWQgYW4gZW1wdHkgcmVwb3NpdG9yeS4iCiBtc2dzdHIgIkR1IHZlcmthciBoYSBrbG9uYXQgZXR0IHRvbXQgYXJraXYuIgogCkBAIC0xMTIyOCw3ICsxMTI2Myw3IEBACiBtc2dpZCAiZHVwbGljYXRlIHBhcmVudCAlcyBpZ25vcmVkIgogbXNnc3RyICJkdXBsaWNlcmFkIGbDtnLDpGxkZXIgJXMgaWdub3JlcmFkZXMiCiAKLSM6IGJ1aWx0aW4vY29tbWl0LXRyZWUuYzo1NiBidWlsdGluL2NvbW1pdC10cmVlLmM6MTM2IGJ1aWx0aW4vbG9nLmM6NTQyCisjOiBidWlsdGluL2NvbW1pdC10cmVlLmM6NTYgYnVpbHRpbi9jb21taXQtdHJlZS5jOjEzNiBidWlsdGluL2xvZy5jOjUyNQogIywgYy1mb3JtYXQKIG1zZ2lkICJub3QgYSB2YWxpZCBvYmplY3QgbmFtZSAlcyIKIG1zZ3N0ciAib2JqZWt0bmFtbmV0IMOkciBpbnRlIGdpbHRpZ3Q6ICVzIgpAQCAtMTEyNTcsNyArMTEyOTIsNyBAQAogbXNnc3RyICJpZCBww6UgZXR0IGbDtnLDpGxkZXJpbmNoZWNrbmluZ3NvYmpla3QiCiAKICM6IGJ1aWx0aW4vY29tbWl0LXRyZWUuYzoxMTQgYnVpbHRpbi9jb21taXQuYzoxNTAwIGJ1aWx0aW4vbWVyZ2UuYzoyNzAKLSM6IGJ1aWx0aW4vbm90ZXMuYzo0MDkgYnVpbHRpbi9ub3Rlcy5jOjU3NSBidWlsdGluL3N0YXNoLmM6MTQ2MAorIzogYnVpbHRpbi9ub3Rlcy5jOjQwOSBidWlsdGluL25vdGVzLmM6NTc1IGJ1aWx0aW4vc3Rhc2guYzoxNDY5CiAjOiBidWlsdGluL3RhZy5jOjQxMgogbXNnaWQgIm1lc3NhZ2UiCiBtc2dzdHIgIm1lZGRlbGFuZGUiCkBAIC0xMTI3MSw3ICsxMTMwNiw3IEBACiBtc2dzdHIgImzDpHMgaW5jaGVja25pbmdzbG9nZ21lZGRlbGFuZGUgZnLDpW4gZmlsIgogCiAjOiBidWlsdGluL2NvbW1pdC10cmVlLmM6MTIxIGJ1aWx0aW4vY29tbWl0LmM6MTUxMiBidWlsdGluL21lcmdlLmM6Mjg3Ci0jOiBidWlsdGluL3B1bGwuYzoxOTQgYnVpbHRpbi9yZXZlcnQuYzoxMTgKKyM6IGJ1aWx0aW4vcHVsbC5jOjE5NSBidWlsdGluL3JldmVydC5jOjExOAogbXNnaWQgIkdQRyBzaWduIGNvbW1pdCIKIG1zZ3N0ciAiR1BHLXNpZ25lcmEgaW5jaGVja25pbmciCiAKQEAgLTExNTk5LDggKzExNjM0LDggQEAKIG1zZ2lkICJ2ZXJzaW9uIgogbXNnc3RyICJ2ZXJzaW9uIgogCi0jOiBidWlsdGluL2NvbW1pdC5jOjEzNDcgYnVpbHRpbi9jb21taXQuYzoxNTI5IGJ1aWx0aW4vcHVzaC5jOjU2MQotIzogYnVpbHRpbi93b3JrdHJlZS5jOjY1MQorIzogYnVpbHRpbi9jb21taXQuYzoxMzQ3IGJ1aWx0aW4vY29tbWl0LmM6MTUyOSBidWlsdGluL3B1c2guYzo1NDgKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo2NTAKIG1zZ2lkICJtYWNoaW5lLXJlYWRhYmxlIG91dHB1dCIKIG1zZ3N0ciAibWFza2lubMOkc2JhciB1dGRhdGEiCiAKQEAgLTExNjEzLDggKzExNjQ4LDggQEAKIG1zZ3N0ciAidGVybWluZXJhIHBvc3RlciBtZWQgTlVMIgogCiAjOiBidWlsdGluL2NvbW1pdC5jOjEzNTUgYnVpbHRpbi9jb21taXQuYzoxMzU5IGJ1aWx0aW4vY29tbWl0LmM6MTUzNwotIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExMjUgYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExMjgKLSM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTMxIGJ1aWx0aW4vcmViYXNlLmM6MTQ3MSBwYXJzZS1vcHRpb25zLmg6MzMyCisjOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE1MyBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE1NgorIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNTkgYnVpbHRpbi9yZWJhc2UuYzoxNDk1IHBhcnNlLW9wdGlvbnMuaDozMzIKIG1zZ2lkICJtb2RlIgogbXNnc3RyICJsw6RnZSIKIApAQCAtMTE2MzAsNyArMTE2NjUsNyBAQAogInZpc2EgaWdub3JlcmFkZSBmaWxlciwgdmFsZnJpYSBsw6RnZW46IHRyYWRpdGlvbmFsLCBtYXRjaGluZywgbm8gKFN0YW5kYXJkOiAiCiAidHJhZGl0aW9uYWwpIgogCi0jOiBidWlsdGluL2NvbW1pdC5jOjEzNjIgcGFyc2Utb3B0aW9ucy5oOjE3OQorIzogYnVpbHRpbi9jb21taXQuYzoxMzYyIHBhcnNlLW9wdGlvbnMuaDoxODgKIG1zZ2lkICJ3aGVuIgogbXNnc3RyICJuw6RyIgogCkBAIC0xMTY4Miw3ICsxMTcxNyw3IEBACiBtc2dpZCAib3ZlcnJpZGUgYXV0aG9yIGZvciBjb21taXQiCiBtc2dzdHIgIsO2dmVyc3R5ciBmw7ZyZmF0dGFyZSBmw7ZyIGluY2hlY2tuaW5nZW4iCiAKLSM6IGJ1aWx0aW4vY29tbWl0LmM6MTQ5OSBidWlsdGluL2djLmM6NTM5CisjOiBidWlsdGluL2NvbW1pdC5jOjE0OTkgYnVpbHRpbi9nYy5jOjUzOAogbXNnaWQgImRhdGUiCiBtc2dzdHIgImRhdHVtIgogCkBAIC0xMTcxOCw4ICsxMTc1Myw4IEBACiBtc2dpZCAidGhlIGNvbW1pdCBpcyBhdXRob3JlZCBieSBtZSBub3cgKHVzZWQgd2l0aCAtQy8tYy8tLWFtZW5kKSIKIG1zZ3N0ciAiamFnIMOkciBudSBmw7ZyZmF0dGFyZSBhdiBpbmNoZWNrbmluZ2VuIChhbnbDpG5kcyBtZWQgLUMvLWMvLS1hbWVuZCkiCiAKLSM6IGJ1aWx0aW4vY29tbWl0LmM6MTUwNiBidWlsdGluL2xvZy5jOjE1ODEgYnVpbHRpbi9tZXJnZS5jOjI4OQotIzogYnVpbHRpbi9wdWxsLmM6MTYzIGJ1aWx0aW4vcmV2ZXJ0LmM6MTEwCisjOiBidWlsdGluL2NvbW1pdC5jOjE1MDYgYnVpbHRpbi9sb2cuYzoxNTY1IGJ1aWx0aW4vbWVyZ2UuYzoyODkKKyM6IGJ1aWx0aW4vcHVsbC5jOjE2NCBidWlsdGluL3JldmVydC5jOjExMAogbXNnaWQgImFkZCBTaWduZWQtb2ZmLWJ5OiIKIG1zZ3N0ciAibMOkZ2cgdGlsbCBTaWduZWQtb2ZmLWJ5OiIKIApAQCAtMTE4MjcsNjcgKzExODYyLDY5IEBACiBtc2dzdHIgImdpdCBjb21taXQtZ3JhcGggcmVhZCBbLS1vYmplY3QtZGlyIDxvYmprYXQ+XSIKIAogIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxMyBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE5Ci1tc2dpZCAiZ2l0IGNvbW1pdC1ncmFwaCB2ZXJpZnkgWy0tb2JqZWN0LWRpciA8b2JqZGlyPl0gWy0tc2hhbGxvd10iCi1tc2dzdHIgImdpdCBjb21taXQtZ3JhcGggdmVyaWZ5IFstLW9iamVjdC1kaXIgPG9iamthdD5dIFstLXNoYWxsb3ddIgorbXNnaWQgIiIKKyJnaXQgY29tbWl0LWdyYXBoIHZlcmlmeSBbLS1vYmplY3QtZGlyIDxvYmpkaXI+XSBbLS1zaGFsbG93XSBbLS1bbm8tXXByb2dyZXNzXSIKK21zZ3N0ciAiIgorImdpdCBjb21taXQtZ3JhcGggdmVyaWZ5IFstLW9iamVjdC1kaXIgPG9iamthdD5dIFstLXNoYWxsb3ddIFstLVtuby1dcHJvZ3Jlc3NdIgogCiAjOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE0IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MjkKIG1zZ2lkICIiCiAiZ2l0IGNvbW1pdC1ncmFwaCB3cml0ZSBbLS1vYmplY3QtZGlyIDxvYmpkaXI+XSBbLS1hcHBlbmR8LS1zcGxpdF0gWy0tIgotInJlYWNoYWJsZXwtLXN0ZGluLXBhY2tzfC0tc3RkaW4tY29tbWl0c10gPHNwbGl0IG9wdGlvbnM+IgorInJlYWNoYWJsZXwtLXN0ZGluLXBhY2tzfC0tc3RkaW4tY29tbWl0c10gWy0tW25vLV1wcm9ncmVzc10gPHNwbGl0IG9wdGlvbnM+IgogbXNnc3RyICIiCiAiZ2l0IGNvbW1pdC1ncmFwaCB3cml0ZSBbLS1vYmplY3QtZGlyIDxvYmprYXQ+XSBbLS1hcHBlbmR8LS1zcGxpdF0gWy0tIgotInJlYWNoYWJsZXwtLXN0ZGluLXBhY2tzfC0tc3RkaW4tY29tbWl0c10gPGRlbG5pbmdzLWZsYWdnb3I+IgorInJlYWNoYWJsZXwtLXN0ZGluLXBhY2tzfC0tc3RkaW4tY29tbWl0c10gWy0tW25vLV1wcm9ncmVzc10gPGRlbG5pbmdzLWZsYWdnb3I+IgogCi0jOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjU0IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTAwCi0jOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE2MSBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjIzNyBidWlsdGluL2ZldGNoLmM6MTYzCi0jOiBidWlsdGluL2xvZy5jOjE2MDEKKyM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6NTUgYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxMDcKKyM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTcwIGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MjU0IGJ1aWx0aW4vZmV0Y2guYzoxNzgKKyM6IGJ1aWx0aW4vbG9nLmM6MTU4NQogbXNnaWQgImRpciIKIG1zZ3N0ciAia2F0IgogCi0jOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjU1IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTAxCi0jOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE2MiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjIzOAorIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzo1NiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjEwOAorIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxNzEgYnVpbHRpbi9jb21taXQtZ3JhcGguYzoyNTUKIG1zZ2lkICJUaGUgb2JqZWN0IGRpcmVjdG9yeSB0byBzdG9yZSB0aGUgZ3JhcGgiCiBtc2dzdHIgIk9iamVrdGthdGFsb2dlbiBkw6RyIGdyYWZlbiBza2FsbCBsYWdyYXMiCiAKLSM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6NTcKKyM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6NTgKIG1zZ2lkICJpZiB0aGUgY29tbWl0LWdyYXBoIGlzIHNwbGl0LCBvbmx5IHZlcmlmeSB0aGUgdGlwIGZpbGUiCiBtc2dzdHIgIm9tIGluY2hlY2tuaWduc2dyYWZlbiDDpHIgZGVsYWQsIGtvbnRyb2xsZXJhIGJhcmEgc3BldHNmaWxlbiIKIAotIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzo3MyBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjExNgorIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzo4MCBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjEyNQogIywgYy1mb3JtYXQKIG1zZ2lkICJDb3VsZCBub3Qgb3BlbiBjb21taXQtZ3JhcGggJyVzJyIKIG1zZ3N0ciAiS3VuZGUgaW50ZSDDtnBwbmEgaW5jaGVja25pbmdzZ3JhZmVuIFwiJXNcIiIKIAotIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxNjQKKyM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTczCiBtc2dpZCAic3RhcnQgd2FsayBhdCBhbGwgcmVmcyIKIG1zZ3N0ciAic3RhcnRhIHRyYXZlcnNlcmluZyB2aWQgYWxsYSByZWZlcmVuc2VyIgogCi0jOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE2NgorIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxNzUKIG1zZ2lkICJzY2FuIHBhY2staW5kZXhlcyBsaXN0ZWQgYnkgc3RkaW4gZm9yIGNvbW1pdHMiCiBtc2dzdHIgInPDtmsgcGFrZXRpbmRleCBsaXN0YWRlIHDDpSBzdGFuZGFyZCBpbiBlZnRlciBpbmNoZWNrbmluZ2FyIgogCi0jOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE2OAorIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxNzcKIG1zZ2lkICJzdGFydCB3YWxrIGF0IGNvbW1pdHMgbGlzdGVkIGJ5IHN0ZGluIgogbXNnc3RyICJiw7ZyamEgZ8OlIGdlbm9tIGluY2hlY2tuaW5nYXIgbGlzdGFkZSBww6Ugc3RhbmRhcmQgaW4iCiAKLSM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTcwCisjOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE3OQogbXNnaWQgImluY2x1ZGUgYWxsIGNvbW1pdHMgYWxyZWFkeSBpbiB0aGUgY29tbWl0LWdyYXBoIGZpbGUiCiBtc2dzdHIgInRhIG1lZCBhbGxhIGluY2hlY2tuaW5nYXIgcmVkYW4gaSBmaWxlbiBjb21taXQtZ3JhcGgiCiAKLSM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTcyCisjOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE4MgogbXNnaWQgImFsbG93IHdyaXRpbmcgYW4gaW5jcmVtZW50YWwgY29tbWl0LWdyYXBoIGZpbGUiCiBtc2dzdHIgInRpbGzDpXQgc2tyaXZhIGVuIGlua3JlbWVudGVsbCBpbmNoZWNrbmluZ3NncmFmZmlsIgogCi0jOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE3NCBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE3OAorIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxODQgYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxODgKIG1zZ2lkICJtYXhpbXVtIG51bWJlciBvZiBjb21taXRzIGluIGEgbm9uLWJhc2Ugc3BsaXQgY29tbWl0LWdyYXBoIgogbXNnc3RyICIiCiAibWF4aW1hbHQgYW50YWwgaW5jaGVja25pbmdhciBpIGVuIGRlbGFkIGluY2hlY2tpbmdzZ3JhZiBzb20gaW50ZSDDpHIgYmFkIgogCi0jOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE3NgorIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxODYKIG1zZ2lkICJtYXhpbXVtIHJhdGlvIGJldHdlZW4gdHdvIGxldmVscyBvZiBhIHNwbGl0IGNvbW1pdC1ncmFwaCIKIG1zZ3N0ciAibWF4aW1hbHQgZsO2cmjDpWxsYW5kZSBtZWxsYW4gdHbDpSBuaXbDpWVyIGF2IGVuIGRlbGFkIGluY2hlY2tuaW5nc2dyYWYiCiAKLSM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTkxCisjOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjIwNAogbXNnaWQgInVzZSBhdCBtb3N0IG9uZSBvZiAtLXJlYWNoYWJsZSwgLS1zdGRpbi1jb21taXRzLCBvciAtLXN0ZGluLXBhY2tzIgogbXNnc3RyICJhbnbDpG5kIHNvbSBtZXN0IGVuIGF2IC0tcmVhY2hhYmxlLCAtLXN0ZGluLWNvbW1pdCBvY2ggLS1zdGRpbi1wYWNrcyIKIApAQCAtMTIyMDEsNTggKzEyMjM4LDU4IEBACiBtc2dpZCAicHJpbnQgc2l6ZXMgaW4gaHVtYW4gcmVhZGFibGUgZm9ybWF0IgogbXNnc3RyICJza3JpdiBzdG9ybGVrYXIgaSBtw6Rubmlza29sw6RzYmFydCBmb3JtYXQiCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzoyNworIzogYnVpbHRpbi9kZXNjcmliZS5jOjI2CiBtc2dpZCAiZ2l0IGRlc2NyaWJlIFs8b3B0aW9ucz5dIFs8Y29tbWl0LWlzaD4uLi5dIgogbXNnc3RyICJnaXQgZGVzY3JpYmUgWzxmbGFnZ29yPl0gWzxpbmNoZWNrbmluZy1pZ3Q+Li4uXSIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjI4CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6MjcKIG1zZ2lkICJnaXQgZGVzY3JpYmUgWzxvcHRpb25zPl0gLS1kaXJ0eSIKIG1zZ3N0ciAiZ2l0IGRlc2NyaWJlIFs8ZmxhZ2dvcj5dIC0tZGlydHkiCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo2MworIzogYnVpbHRpbi9kZXNjcmliZS5jOjYyCiBtc2dpZCAiaGVhZCIKIG1zZ3N0ciAiaHV2dWQiCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo2MworIzogYnVpbHRpbi9kZXNjcmliZS5jOjYyCiBtc2dpZCAibGlnaHR3ZWlnaHQiCiBtc2dzdHIgImzDpHR0dmlrdGlnIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NjMKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo2MgogbXNnaWQgImFubm90YXRlZCIKIG1zZ3N0ciAiYW5ub3RlcmFkIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6MjczCisjOiBidWlsdGluL2Rlc2NyaWJlLmM6Mjc1CiAjLCBjLWZvcm1hdAogbXNnaWQgImFubm90YXRlZCB0YWcgJXMgbm90IGF2YWlsYWJsZSIKIG1zZ3N0ciAiZGVuIGFubm90ZXJhZGUgdGFnZ2VuICVzIGludGUgdGlsbGfDpG5nbGlnIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6Mjc3CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6Mjc5CiAjLCBjLWZvcm1hdAogbXNnaWQgImFubm90YXRlZCB0YWcgJXMgaGFzIG5vIGVtYmVkZGVkIG5hbWUiCiBtc2dzdHIgImRlbiBhbm5vdGVyYWRlIHRhZ2dlbiAlcyBoYXIgaW5nZXQgaW5iw6RkZGF0IG5hbW4iCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzoyNzkKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzoyODEKICMsIGMtZm9ybWF0CiBtc2dpZCAidGFnICclcycgaXMgcmVhbGx5ICclcycgaGVyZSIKIG1zZ3N0ciAidGFnZ2VuIFwiJXNcIiDDpHIgaSB2ZXJrbGlnaGV0ZW4gXCIlc1wiIGjDpHIiCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzozMjMKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzozMjUKICMsIGMtZm9ybWF0CiBtc2dpZCAibm8gdGFnIGV4YWN0bHkgbWF0Y2hlcyAnJXMnIgogbXNnc3RyICJpbmdlbiB0YWdnIG1vdHN2YXJhciBcIiVzXCIgZXhha3QiCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzozMjUKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzozMjcKICMsIGMtZm9ybWF0CiBtc2dpZCAiTm8gZXhhY3QgbWF0Y2ggb24gcmVmcyBvciB0YWdzLCBzZWFyY2hpbmcgdG8gZGVzY3JpYmVcbiIKIG1zZ3N0ciAiIgogIkluZ2VuIGV4YWt0IHRyw6RmZiBtb3QgcmVmZXJlbnNlciBlbGxlciB0YWdnYXIsIHPDtmtlciBmw7ZyIGF0dCBiZXNrcml2YVxuIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6Mzc5CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6MzgxCiAjLCBjLWZvcm1hdAogbXNnaWQgImZpbmlzaGVkIHNlYXJjaCBhdCAlc1xuIgogbXNnc3RyICJhdnNsdXRhZGUgc8O2a25pbmcgcMOlICVzXG4iCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo0MDUKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo0MDcKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIk5vIGFubm90YXRlZCB0YWdzIGNhbiBkZXNjcmliZSAnJXMnLlxuIgpAQCAtMTIyNjEsNyArMTIyOTgsNyBAQAogIkluZ2EgYW5ub3RlcmFkZSB0YWdnYXIga2FuIGJlc2tyaXZhIFwiJXNcIi5cbiIKICJEZXQgZmlubnMgZG9jayBvYW5ub3RlcmFkZSB0YWdnYXI6IHRlc3RhIC0tdGFncy4iCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo0MDkKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo0MTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIk5vIHRhZ3MgY2FuIGRlc2NyaWJlICclcycuXG4iCkBAIC0xMjI3MCwxMiArMTIzMDcsMTIgQEAKICJJbmdhIHRhZ2dhciBrYW4gYmVza3JpdmEgXCIlc1wiLlxuIgogIlRlc3RhIC0tYWx3YXlzLCBlbGxlciBza2FwYSBuw6VncmEgdGFnZ2FyLiIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjQzOQorIzogYnVpbHRpbi9kZXNjcmliZS5jOjQ0MQogIywgYy1mb3JtYXQKIG1zZ2lkICJ0cmF2ZXJzZWQgJWx1IGNvbW1pdHNcbiIKIG1zZ3N0ciAidHJhdmVyc2VyYWRlICVsdSBpbmNoZWNrbmluZ2FyXG4iCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo0NDIKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo0NDQKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIm1vcmUgdGhhbiAlaSB0YWdzIGZvdW5kOyBsaXN0ZWQgJWkgbW9zdCByZWNlbnRcbiIKQEAgLTEyMjg0LDkwICsxMjMyMSw5MCBAQAogIm1lciDDpG4gJWkgdGFnZ2FyIGhpdHRhZGVzOyBsaXN0YXIgZGUgJWkgc2VuYXN0ZVxuIgogImdhdiB1cHAgc8O2a25pbmdlbiB2aWQgJXNcbiIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjUxMAorIzogYnVpbHRpbi9kZXNjcmliZS5jOjUxMgogIywgYy1mb3JtYXQKIG1zZ2lkICJkZXNjcmliZSAlc1xuIgogbXNnc3RyICJiZXNrcml2YSAlc1xuIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NTEzCisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NTE1CiAjLCBjLWZvcm1hdAogbXNnaWQgIk5vdCBhIHZhbGlkIG9iamVjdCBuYW1lICVzIgogbXNnc3RyICJPYmpla3RuYW1uZXQgw6RyIGludGUgZ2lsdGlndDogJXMiCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1MjEKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1MjMKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgaXMgbmVpdGhlciBhIGNvbW1pdCBub3IgYmxvYiIKIG1zZ3N0ciAiJXMgw6RyIHZhcmtlbiBpbmNoZWNrbmluZyBlbGxlciBibG9iIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NTM1CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NTM3CiBtc2dpZCAiZmluZCB0aGUgdGFnIHRoYXQgY29tZXMgYWZ0ZXIgdGhlIGNvbW1pdCIKIG1zZ3N0ciAiaGl0dGEgdGFnZ2VuIHNvbSBrb21tZXIgZWZ0ZXIgaW5jaGVja25pbmdlbiIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjUzNgorIzogYnVpbHRpbi9kZXNjcmliZS5jOjUzOAogbXNnaWQgImRlYnVnIHNlYXJjaCBzdHJhdGVneSBvbiBzdGRlcnIiCiBtc2dzdHIgImZlbHPDtmsgc8O2a3N0cmF0ZWdpbiBww6Ugc3RhbmRhcmQgZmVsIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NTM3CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NTM5CiBtc2dpZCAidXNlIGFueSByZWYiCiBtc2dzdHIgImFudsOkbmQgYWxsYSByZWZlcmVuc2VyIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NTM4CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NTQwCiBtc2dpZCAidXNlIGFueSB0YWcsIGV2ZW4gdW5hbm5vdGF0ZWQiCiBtc2dzdHIgImFudsOkbmQgYWxsYSB0YWdnYXIsIMOkdmVuIG9hbm5vdGVyYWRlIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NTM5CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NTQxCiBtc2dpZCAiYWx3YXlzIHVzZSBsb25nIGZvcm1hdCIKIG1zZ3N0ciAiYW52w6RuZCBhbGx0aWQgbMOlbmd0IGZvcm1hdCIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjU0MAorIzogYnVpbHRpbi9kZXNjcmliZS5jOjU0MgogbXNnaWQgIm9ubHkgZm9sbG93IGZpcnN0IHBhcmVudCIKIG1zZ3N0ciAiZsO2bGogZW5kYXN0IGbDtnJzdGEgZsO2csOkbGRlcm4iCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1NDMKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1NDUKIG1zZ2lkICJvbmx5IG91dHB1dCBleGFjdCBtYXRjaGVzIgogbXNnc3RyICJza3JpdiBlbmRhc3QgdXQgZXhha3RhIHRyw6RmZmFyIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NTQ1CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NTQ3CiBtc2dpZCAiY29uc2lkZXIgPG4+IG1vc3QgcmVjZW50IHRhZ3MgKGRlZmF1bHQ6IDEwKSIKIG1zZ3N0ciAiw7Z2ZXJ2w6RnIGRlIDxuPiBueWFzdGUgdGFnZ2FybmEgKHN0YW5kYXJkOiAxMCkiCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1NDcKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1NDkKIG1zZ2lkICJvbmx5IGNvbnNpZGVyIHRhZ3MgbWF0Y2hpbmcgPHBhdHRlcm4+IgogbXNnc3RyICLDtnZlcnbDpGcgZW5kYXN0IHRhZ2dhciBzb20gbW90c3ZhcmFyIDxtw7Zuc3Rlcj4iCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1NDkKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1NTEKIG1zZ2lkICJkbyBub3QgY29uc2lkZXIgdGFncyBtYXRjaGluZyA8cGF0dGVybj4iCiBtc2dzdHIgIsO2dmVydsOkZyBpbnRlIHRhZ2dhciBzb20gbW90c3ZhcmFyIDxtw7Zuc3Rlcj4iCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1NTEgYnVpbHRpbi9uYW1lLXJldi5jOjQyMgorIzogYnVpbHRpbi9kZXNjcmliZS5jOjU1MyBidWlsdGluL25hbWUtcmV2LmM6NDI2CiBtc2dpZCAic2hvdyBhYmJyZXZpYXRlZCBjb21taXQgb2JqZWN0IGFzIGZhbGxiYWNrIgogbXNnc3RyICJ2aXNhIGbDtnJrb3J0YWRlIGluY2hlY2tuaW5nc29iamVrdCBzb20gc3RhbmRhcmQiCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1NTIgYnVpbHRpbi9kZXNjcmliZS5jOjU1NQorIzogYnVpbHRpbi9kZXNjcmliZS5jOjU1NCBidWlsdGluL2Rlc2NyaWJlLmM6NTU3CiBtc2dpZCAibWFyayIKIG1zZ3N0ciAibcOkcmtlIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NTUzCisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NTU1CiBtc2dpZCAiYXBwZW5kIDxtYXJrPiBvbiBkaXJ0eSB3b3JraW5nIHRyZWUgKGRlZmF1bHQ6IFwiLWRpcnR5XCIpIgogbXNnc3RyICJsw6RnZyB0aWxsIDxtw6Rya2U+IHDDpSBsb3J0aWd0IGFyYmV0c3Ryw6RkIChzdGFuZGFyZDogXCItZGlydHlcIikiCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1NTYKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1NTgKIG1zZ2lkICJhcHBlbmQgPG1hcms+IG9uIGJyb2tlbiB3b3JraW5nIHRyZWUgKGRlZmF1bHQ6IFwiLWJyb2tlblwiKSIKIG1zZ3N0ciAibMOkZ2cgdGlsbCA8bcOkcmtlPiBww6UgdHJhc2lndCBhcmJldHN0csOkZCAoc3RhbmRhcmQ6IFwiLWJyb2tlblwiKSIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjU3NAorIzogYnVpbHRpbi9kZXNjcmliZS5jOjU3NgogbXNnaWQgIi0tbG9uZyBpcyBpbmNvbXBhdGlibGUgd2l0aCAtLWFiYnJldj0wIgogbXNnc3RyICItLWxvbmcgw6RyIGlua29tcGF0aWJlbCBtZWQgLS1hYmJyZXY9MCIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjYwMworIzogYnVpbHRpbi9kZXNjcmliZS5jOjYwNQogbXNnaWQgIk5vIG5hbWVzIGZvdW5kLCBjYW5ub3QgZGVzY3JpYmUgYW55dGhpbmcuIgogbXNnc3RyICJJbmdhIG5hbW4gaGl0dGFkZXMsIGthbiBpbnRlIGJlc2tyaXZhIG7DpWdvdC4iCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo2NTQKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo2NTYKIG1zZ2lkICItLWRpcnR5IGlzIGluY29tcGF0aWJsZSB3aXRoIGNvbW1pdC1pc2hlcyIKIG1zZ3N0ciAiLS1kaXJ0eSDDpHIgaW5rb21wYXRpYmVsdCBtZWQgXCJjb21taXQtaXNoXCItdsOkcmRlbiIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjY1NgorIzogYnVpbHRpbi9kZXNjcmliZS5jOjY1OAogbXNnaWQgIi0tYnJva2VuIGlzIGluY29tcGF0aWJsZSB3aXRoIGNvbW1pdC1pc2hlcyIKIG1zZ3N0ciAiLS1icm9rZW4gw6RyIGlua29tcGF0aWJlbHQgbWVkIFwiY29tbWl0LWlzaFwiLXbDpHJkZW4iCiAKQEAgLTEyNDA1LDI3ICsxMjQ0MiwyNyBAQAogbXNnc3RyICIiCiAiZ2l0IGRpZmZ0b29sIFs8ZmxhZ2dvcj5dIFs8aW5jaGVja25pbmc+IFs8aW5jaGVja25pbmc+XV0gWy0tXSBbPHPDtmt2w6RnPi4uLl0iCiAKLSM6IGJ1aWx0aW4vZGlmZnRvb2wuYzoyNTMKKyM6IGJ1aWx0aW4vZGlmZnRvb2wuYzoyNjAKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkOiAlZCIKIG1zZ3N0ciAibWlzc2x5Y2thZGVzOiAlZCIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjI5NQorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjMwMgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcmVhZCBzeW1saW5rICVzIgogbXNnc3RyICJrdW5kZSBpbnRlIGzDpHNhIHN5bWJvbGlza2EgbMOkbmtlbiAlcyIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjI5NworIzogYnVpbHRpbi9kaWZmdG9vbC5jOjMwNAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcmVhZCBzeW1saW5rIGZpbGUgJXMiCiBtc2dzdHIgImt1bmRlIGludGUgbMOkc2Egc3ltYm9saXNrIGzDpG5rLWZpbCAlcyIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjMwNQorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjMxMgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcmVhZCBvYmplY3QgJXMgZm9yIHN5bWxpbmsgJXMiCiBtc2dzdHIgImt1bmRlIGludGUgbMOkc2Egb2JqZWt0ZXQgJXMgZsO2ciBzeW1ib2xpc2thIGzDpG5rZW4gJXMiCiAKLSM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo0MDYKKyM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo0MTMKIG1zZ2lkICIiCiAiY29tYmluZWQgZGlmZiBmb3JtYXRzKCctYycgYW5kICctLWNjJykgYXJlIG5vdCBzdXBwb3J0ZWQgaW5cbiIKICJkaXJlY3RvcnkgZGlmZiBtb2RlKCctZCcgYW5kICctLWRpci1kaWZmJykuIgpAQCAtMTI0MzMsNTMgKzEyNDcwLDUzIEBACiAia29tYmluZXJhZGUgZGlmZi1mb3JtYXQgKFwiLWNcIiBvY2ggXCItLWNjXCIpIHN0w7ZkcyBpbnRlIGlcbiIKICJrYXRhbG9nZGlmZmzDpGdlIChcIi1kXCIgb2NoIFwiLS1kaXItZGlmZlwiKS4iCiAKLSM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo2MjYKKyM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo2MzQKICMsIGMtZm9ybWF0CiBtc2dpZCAiYm90aCBmaWxlcyBtb2RpZmllZDogJyVzJyBhbmQgJyVzJy4iCiBtc2dzdHIgImLDpGdnZSBmaWxlcm5hIMOkbmRyYWRlOiBcIiVzXCIgb2NoIFwiJXNcIi4iCiAKLSM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo2MjgKKyM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo2MzYKIG1zZ2lkICJ3b3JraW5nIHRyZWUgZmlsZSBoYXMgYmVlbiBsZWZ0LiIKIG1zZ3N0ciAiZmlsZW4gaSBhcmJldHNrYXRhbG9nZW4gbMOkbW5hZGVzIGt2YXIuIgogCi0jOiBidWlsdGluL2RpZmZ0b29sLmM6NjM5CisjOiBidWlsdGluL2RpZmZ0b29sLmM6NjQ3CiAjLCBjLWZvcm1hdAogbXNnaWQgInRlbXBvcmFyeSBmaWxlcyBleGlzdCBpbiAnJXMnLiIKIG1zZ3N0ciAidGVtcG9yw6RyYSBmaWxlciBmaW5ucyBpIFwiJXNcIi4iCiAKLSM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo2NDAKKyM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo2NDgKIG1zZ2lkICJ5b3UgbWF5IHdhbnQgdG8gY2xlYW51cCBvciByZWNvdmVyIHRoZXNlLiIKIG1zZ3N0ciAiZHUga2Fuc2tlIHZpbGwgc3TDpGRhIGVsbGVyIHLDpGRkYSBkZW0uIgogCi0jOiBidWlsdGluL2RpZmZ0b29sLmM6Njg5CisjOiBidWlsdGluL2RpZmZ0b29sLmM6Njk3CiBtc2dpZCAidXNlIGBkaWZmLmd1aXRvb2xgIGluc3RlYWQgb2YgYGRpZmYudG9vbGAiCiBtc2dzdHIgImFudsOkbmQgXCJkaWZmLmd1aXRvb2xcIiBpc3TDpGxsZXQgZsO2ciBcImRpZmYudG9vbFwiIgogCi0jOiBidWlsdGluL2RpZmZ0b29sLmM6NjkxCisjOiBidWlsdGluL2RpZmZ0b29sLmM6Njk5CiBtc2dpZCAicGVyZm9ybSBhIGZ1bGwtZGlyZWN0b3J5IGRpZmYiCiBtc2dzdHIgInV0ZsO2ciBkaWZmIGbDtnIgaGVsYSBrYXRhbG9nZW4iCiAKLSM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo2OTMKKyM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo3MDEKIG1zZ2lkICJkbyBub3QgcHJvbXB0IGJlZm9yZSBsYXVuY2hpbmcgYSBkaWZmIHRvb2wiCiBtc2dzdHIgImZyw6VnYSBpbnRlIHZpZCBzdGFydCBhdiBkaWZmLXZlcmt0eWciCiAKLSM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo2OTgKKyM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo3MDYKIG1zZ2lkICJ1c2Ugc3ltbGlua3MgaW4gZGlyLWRpZmYgbW9kZSIKIG1zZ3N0ciAiYW52w6RuZCBzeW1ib2xpc2thIGzDpG5rYXIgaSBrYXRhbG9nZGlmZmzDpGdlIgogCi0jOiBidWlsdGluL2RpZmZ0b29sLmM6Njk5CisjOiBidWlsdGluL2RpZmZ0b29sLmM6NzA3CiBtc2dpZCAidG9vbCIKIG1zZ3N0ciAidmVya3R5ZyIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjcwMAorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjcwOAogbXNnaWQgInVzZSB0aGUgc3BlY2lmaWVkIGRpZmYgdG9vbCIKIG1zZ3N0ciAiYW52w6RuZCBhbmdpdmV0IGRpZmYtdmVya3R5ZyIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjcwMgorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjcxMAogbXNnaWQgInByaW50IGEgbGlzdCBvZiBkaWZmIHRvb2xzIHRoYXQgbWF5IGJlIHVzZWQgd2l0aCBgLS10b29sYCIKIG1zZ3N0ciAidmlzYSBlbiBsaXN0YSDDtnZlciBkaWZmLXZlcmt0eWcgc29tIGthbiBhbnbDpG5kYXMgbWVkIFwiLS10b29sXCIiCiAKLSM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo3MDUKKyM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo3MTMKIG1zZ2lkICIiCiAibWFrZSAnZ2l0LWRpZmZ0b29sJyBleGl0IHdoZW4gYW4gaW52b2tlZCBkaWZmIHRvb2wgcmV0dXJucyBhIG5vbiAtIHplcm8gZXhpdCAiCiAiY29kZSIKQEAgLTEyNDg3LDMxICsxMjUyNCwzMSBAQAogImzDpXQgXCJnaXQtZGlmZnRvb2xcIiBhdmJyeXRhIG7DpHIgZXR0IGFucm9wYXQgZGlmZi12ZXJrdHlnIGdlciByZXR1cnbDpHJkZSAiCiAic2tpbHQgZnLDpW4gbm9sbCIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjcwOAorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjcxNgogbXNnaWQgInNwZWNpZnkgYSBjdXN0b20gY29tbWFuZCBmb3Igdmlld2luZyBkaWZmcyIKIG1zZ3N0ciAiYW5nZSBlZ2V0IGtvbW1hbmRvIGbDtnIgYXR0IHZpc2EgZGlmZmFyIgogCi0jOiBidWlsdGluL2RpZmZ0b29sLmM6NzA5CisjOiBidWlsdGluL2RpZmZ0b29sLmM6NzE3CiBtc2dpZCAicGFzc2VkIHRvIGBkaWZmYCIKIG1zZ3N0ciAic8OkbmRlcyB0aWxsIFwiZGlmZlwiIgogCi0jOiBidWlsdGluL2RpZmZ0b29sLmM6NzI0CisjOiBidWlsdGluL2RpZmZ0b29sLmM6NzMyCiBtc2dpZCAiZGlmZnRvb2wgcmVxdWlyZXMgd29ya3RyZWUgb3IgLS1uby1pbmRleCIKIG1zZ3N0ciAiZGlmZnRvb2wga3LDpHZlciBlbiBhcmJldHNrYXRhbG9nIGVsbGVyIC0tbm8taW5kZXgiCiAKLSM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo3MzEKKyM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo3MzkKIG1zZ2lkICItLWRpci1kaWZmIGlzIGluY29tcGF0aWJsZSB3aXRoIC0tbm8taW5kZXgiCiBtc2dzdHIgIi0tZGlyLWRpZmYgw6RyIGlua29tcGF0aWJlbHQgbWVkIC0tbm8taW5kZXgiCiAKLSM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo3MzQKKyM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo3NDIKIG1zZ2lkICItLWd1aSwgLS10b29sIGFuZCAtLWV4dGNtZCBhcmUgbXV0dWFsbHkgZXhjbHVzaXZlIgogbXNnc3RyICItLWd1aSwgLS10b29sIG9jaCAtLWV4dGNtZCDDpHIgw7Ztc2VzaWRpZ3QgdXRlc2x1dGFuZGUiCiAKLSM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo3NDIKKyM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo3NTAKIG1zZ2lkICJubyA8dG9vbD4gZ2l2ZW4gZm9yIC0tdG9vbD08dG9vbD4iCiBtc2dzdHIgImluZ2V0IDx2ZXJrdHlnPiBhbmdhdnMgZsO2ciAtLXRvb2w9PHZlcmt0eWc+IgogCi0jOiBidWlsdGluL2RpZmZ0b29sLmM6NzQ5CisjOiBidWlsdGluL2RpZmZ0b29sLmM6NzU3CiBtc2dpZCAibm8gPGNtZD4gZ2l2ZW4gZm9yIC0tZXh0Y21kPTxjbWQ+IgogbXNnc3RyICJpbmdldCA8a29tbWFuZG8+IGFuZ2F2cyBmw7ZyIC0tZXh0Y21kPTxrb21tYW5kbz4iCiAKQEAgLTEyNTUxLDE1NiArMTI1ODgsMTgwIEBACiBtc2dpZCAiZ2l0IGZhc3QtZXhwb3J0IFtyZXYtbGlzdC1vcHRzXSIKIG1zZ3N0ciAiZ2l0IGZhc3QtZXhwb3J0IFtyZXYtbGlzdC1mbGFnZ29yXSIKIAotIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExMjQKKyM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzo4NTIKK21zZ2lkICJFcnJvcjogQ2Fubm90IGV4cG9ydCBuZXN0ZWQgdGFncyB1bmxlc3MgLS1tYXJrLXRhZ3MgaXMgc3BlY2lmaWVkLiIKK21zZ3N0ciAiRmVsOiBLYW4gaW50ZSBleHBvcnRlcmEgbsOkc3RsYWRlIHRhZ2dhciBzw6V2aWRhIGludGUgLS1tYXJrLXRhZ3MgYW5nZXMuIgorCisjOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE1MgogbXNnaWQgInNob3cgcHJvZ3Jlc3MgYWZ0ZXIgPG4+IG9iamVjdHMiCiBtc2dzdHIgInZpc2EgZsO2cmxvcHAgZWZ0ZXIgPG4+IG9iamVrdCIKIAotIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExMjYKKyM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTU0CiBtc2dpZCAic2VsZWN0IGhhbmRsaW5nIG9mIHNpZ25lZCB0YWdzIgogbXNnc3RyICJ2w6RsaiBoYW50ZXJpbmcgYXYgc2lnbmVyYWRlIHRhZ2dhciIKIAotIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExMjkKKyM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTU3CiBtc2dpZCAic2VsZWN0IGhhbmRsaW5nIG9mIHRhZ3MgdGhhdCB0YWcgZmlsdGVyZWQgb2JqZWN0cyIKIG1zZ3N0ciAidsOkbGogaGFudGVyaW5nIGF2IHRhZ2dhciBzb20gaGFyIHRhZ2dmaWx0cmVyYWRlIG9iamVrdCIKIAotIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExMzIKKyM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTYwCiBtc2dpZCAic2VsZWN0IGhhbmRsaW5nIG9mIGNvbW1pdCBtZXNzYWdlcyBpbiBhbiBhbHRlcm5hdGUgZW5jb2RpbmciCiBtc2dzdHIgInbDpGxqIGhhbnRlcmluZyBhdiBpbmNoZWNrbmluZ3NtZWRkZWxhbmRlbiBpIGFsdGVybmF0aXYgdGVja2Vua29kbmluZyIKIAotIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExMzUKKyM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTYzCiBtc2dpZCAiRHVtcCBtYXJrcyB0byB0aGlzIGZpbGUiCiBtc2dzdHIgIkR1bXBhIG3DpHJrZW4gdGlsbCBmaWxlbiIKIAotIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExMzcKKyM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTY1CiBtc2dpZCAiSW1wb3J0IG1hcmtzIGZyb20gdGhpcyBmaWxlIgogbXNnc3RyICJJbXBvcnRlcmEgbcOkcmtlbiBmcsOlbiBmaWxlbiIKIAotIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExMzkKKyM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTY5Cittc2dpZCAiSW1wb3J0IG1hcmtzIGZyb20gdGhpcyBmaWxlIGlmIGl0IGV4aXN0cyIKK21zZ3N0ciAiSW1wb3J0ZXJhIG3DpHJrZW4gZnLDpW4gZmlsZW4sIG9tIGRlbiBmaW5ucyIKKworIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNzEKIG1zZ2lkICJGYWtlIGEgdGFnZ2VyIHdoZW4gdGFncyBsYWNrIG9uZSIKIG1zZ3N0ciAiRmVqa2EgdGFnZ2FyZSBuw6RyIHRhZ2dlbiBzYWtuYXIgZW4iCiAKLSM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTQxCisjOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE3MwogbXNnaWQgIk91dHB1dCBmdWxsIHRyZWUgZm9yIGVhY2ggY29tbWl0IgogbXNnc3RyICJTa3JpdiB1dCBoZWxhIHRyw6RkZXQgZsO2ciB2YXJqZSBpbmNoZWNrbmluZyIKIAotIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNDMKKyM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTc1CiBtc2dpZCAiVXNlIHRoZSBkb25lIGZlYXR1cmUgdG8gdGVybWluYXRlIHRoZSBzdHJlYW0iCiBtc2dzdHIgIkFudsOkbmQgZG9uZS1mdW5rdGlvbmVuIGbDtnIgYXR0IGF2c2x1dGEgc3Ryw7ZtbWVuIgogCi0jOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE0NAorIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNzYKIG1zZ2lkICJTa2lwIG91dHB1dCBvZiBibG9iIGRhdGEiCiBtc2dzdHIgIkhvcHBhIMO2dmVyIHNrcml2bmluZyBhdiBibG9iLWRhdGEiCiAKLSM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTQ1IGJ1aWx0aW4vbG9nLmM6MTY0OQorIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNzcgYnVpbHRpbi9sb2cuYzoxNjMzCiBtc2dpZCAicmVmc3BlYyIKIG1zZ3N0ciAicmVmZXJlbnNzcGVjaWZpa2F0aW9uIgogCi0jOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE0NgorIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNzgKIG1zZ2lkICJBcHBseSByZWZzcGVjIHRvIGV4cG9ydGVkIHJlZnMiCiBtc2dzdHIgIkFwcGxpY2VyYSByZWZlcmVuc3NwZWNpZmlrYXRpb24gcMOlIGV4cG9ydGVyYWRlIHJlZmVyZW5zZXIiCiAKLSM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTQ3CisjOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE3OQogbXNnaWQgImFub255bWl6ZSBvdXRwdXQiCiBtc2dzdHIgImFub255bWlzZXJhIHV0ZGF0YSIKIAotIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNDkKKyM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTgxCiBtc2dpZCAiUmVmZXJlbmNlIHBhcmVudHMgd2hpY2ggYXJlIG5vdCBpbiBmYXN0LWV4cG9ydCBzdHJlYW0gYnkgb2JqZWN0IGlkIgogbXNnc3RyICJSZWZlcmVyYSBmw7Zyw6RsZHJhciBzb20gaW50ZSBmaW5ucyBpIGZhc3QtZXhwb3J0LXN0csO2bSBtZWQgb2JqZWt0LWlkIgogCi0jOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE1MQorIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExODMKIG1zZ2lkICJTaG93IG9yaWdpbmFsIG9iamVjdCBpZHMgb2YgYmxvYnMvY29tbWl0cyIKLW1zZ3N0ciAiVmlzYSB1cnNwcnVuZ2xpZ2Egb2JqZWt0LUlEIGbDtnIgYmxvYmJhci9pbmNoZWNrbmluZ2FyIgorbXNnc3RyICJWaXNhIHVyc3BydW5nbGlnYSBvYmpla3QtaWQgZsO2ciBibG9iYmFyL2luY2hlY2tuaW5nYXIiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzozMAorIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExODUKK21zZ2lkICJMYWJlbCB0YWdzIHdpdGggbWFyayBpZHMiCittc2dzdHIgIk3DpHJrIHRhZ2dhciBtZWQgbcOkcmtlLWlkIgorCisjOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTIyMAorbXNnaWQgIkNhbm5vdCBwYXNzIGJvdGggLS1pbXBvcnQtbWFya3MgYW5kIC0taW1wb3J0LW1hcmtzLWlmLWV4aXN0cyIKK21zZ3N0ciAiS2FuIGludGUgYW5nZSBiw6VkZSAtLWltcG9ydC1tYXJrcyBvY2ggLS1pbXBvcnQtbWFya3MtaWYtZXhpc3RzIgorCisjOiBidWlsdGluL2ZldGNoLmM6MzQKIG1zZ2lkICJnaXQgZmV0Y2ggWzxvcHRpb25zPl0gWzxyZXBvc2l0b3J5PiBbPHJlZnNwZWM+Li4uXV0iCiBtc2dzdHIgImdpdCBmZXRjaCBbPGZsYWdnb3I+XSBbPGFya2l2PiBbPHJlZnNwZWM+Li4uXV0iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzozMQorIzogYnVpbHRpbi9mZXRjaC5jOjM1CiBtc2dpZCAiZ2l0IGZldGNoIFs8b3B0aW9ucz5dIDxncm91cD4iCiBtc2dzdHIgImdpdCBmZXRjaCBbPGZsYWdnb3I+XSA8Z3J1cHA+IgogCi0jOiBidWlsdGluL2ZldGNoLmM6MzIKKyM6IGJ1aWx0aW4vZmV0Y2guYzozNgogbXNnaWQgImdpdCBmZXRjaCAtLW11bHRpcGxlIFs8b3B0aW9ucz5dIFsoPHJlcG9zaXRvcnk+IHwgPGdyb3VwPikuLi5dIgogbXNnc3RyICJnaXQgZmV0Y2ggLS1tdWx0aXBsZSBbPGZsYWdnb3I+XSBbKDxhcmtpdj4gfCA8Z3J1cHA+KS4uLl0iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzozMworIzogYnVpbHRpbi9mZXRjaC5jOjM3CiBtc2dpZCAiZ2l0IGZldGNoIC0tYWxsIFs8b3B0aW9ucz5dIgogbXNnc3RyICJnaXQgZmV0Y2ggLS1hbGwgWzxmbGFnZ29yPl0iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxMjUgYnVpbHRpbi9wdWxsLmM6MjAzCisjOiBidWlsdGluL2ZldGNoLmM6MTE1Cittc2dpZCAiZmV0Y2gucGFyYWxsZWwgY2Fubm90IGJlIG5lZ2F0aXZlIgorbXNnc3RyICJmZXRjaC5wYXJhbGxlbCBrYW4gaW50ZSB2YXJhIG5lZ2F0aXZ0IgorCisjOiBidWlsdGluL2ZldGNoLmM6MTM4IGJ1aWx0aW4vcHVsbC5jOjIwNAogbXNnaWQgImZldGNoIGZyb20gYWxsIHJlbW90ZXMiCiBtc2dzdHIgImjDpG10YSBmcsOlbiBhbGxhIGZqw6RycmFyIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTI3IGJ1aWx0aW4vcHVsbC5jOjIwNgorIzogYnVpbHRpbi9mZXRjaC5jOjE0MCBidWlsdGluL3B1bGwuYzoyNDgKK21zZ2lkICJzZXQgdXBzdHJlYW0gZm9yIGdpdCBwdWxsL2ZldGNoIgorbXNnc3RyICJzdMOkbGwgaW4gdXBwc3Ryw7ZtIGbDtnIgZ2l0IHB1bGwvZmV0Y2giCisKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNDIgYnVpbHRpbi9wdWxsLmM6MjA3CiBtc2dpZCAiYXBwZW5kIHRvIC5naXQvRkVUQ0hfSEVBRCBpbnN0ZWFkIG9mIG92ZXJ3cml0aW5nIgogbXNnc3RyICJsw6RnZyB0aWxsIGkgLmdpdC9GRVRDSF9IRUFEIGlzdMOkbGxldCBmw7ZyIGF0dCBza3JpdmEgw7Z2ZXIiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxMjkgYnVpbHRpbi9wdWxsLmM6MjA5CisjOiBidWlsdGluL2ZldGNoLmM6MTQ0IGJ1aWx0aW4vcHVsbC5jOjIxMAogbXNnaWQgInBhdGggdG8gdXBsb2FkIHBhY2sgb24gcmVtb3RlIGVuZCIKIG1zZ3N0ciAic8O2a3bDpGcgdGlsbCB1cGxvYWQgcGFjayBww6UgZmrDpHJyZW4iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxMzAKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNDUKIG1zZ2lkICJmb3JjZSBvdmVyd3JpdGUgb2YgbG9jYWwgcmVmZXJlbmNlIgogbXNnc3RyICJ0dmluZ2Egw7Z2ZXJza3Jpdm5pbmcgYXYgbG9rYWwgcmVmZXJlbnMiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxMzIKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNDcKIG1zZ2lkICJmZXRjaCBmcm9tIG11bHRpcGxlIHJlbW90ZXMiCiBtc2dzdHIgImjDpG10YSBmcsOlbiBmbGVyYSBmasOkcnJhciIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjEzNCBidWlsdGluL3B1bGwuYzoyMTMKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNDkgYnVpbHRpbi9wdWxsLmM6MjE0CiBtc2dpZCAiZmV0Y2ggYWxsIHRhZ3MgYW5kIGFzc29jaWF0ZWQgb2JqZWN0cyIKIG1zZ3N0ciAiaMOkbXRhIGFsbGEgdGFnZ2FyIG9jaCBhc3NvY2llcmFkZSBvYmpla3QiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxMzYKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNTEKIG1zZ2lkICJkbyBub3QgZmV0Y2ggYWxsIHRhZ3MgKC0tbm8tdGFncykiCiBtc2dzdHIgImjDpG10YSBpbnRlIGFsbGEgdGFnZ2FyICgtLW5vLXRhZ3MpIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTM4CisjOiBidWlsdGluL2ZldGNoLmM6MTUzCiBtc2dpZCAibnVtYmVyIG9mIHN1Ym1vZHVsZXMgZmV0Y2hlZCBpbiBwYXJhbGxlbCIKIG1zZ3N0ciAiYW50YWwgdW5kZXJtb2R1bGVyIHNvbSBow6RtdGFzIHBhcmFsbGVsbHQiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNDAgYnVpbHRpbi9wdWxsLmM6MjE2CisjOiBidWlsdGluL2ZldGNoLmM6MTU1IGJ1aWx0aW4vcHVsbC5jOjIxNwogbXNnaWQgInBydW5lIHJlbW90ZS10cmFja2luZyBicmFuY2hlcyBubyBsb25nZXIgb24gcmVtb3RlIgogbXNnc3RyICJyZW5zYSBmasOkcnJzcMOlcmFuZGUgZ3JlbmFyIGVqIGzDpG5ncmUgcMOlIGZqw6RycmVuIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTQyCisjOiBidWlsdGluL2ZldGNoLmM6MTU3CiBtc2dpZCAicHJ1bmUgbG9jYWwgdGFncyBubyBsb25nZXIgb24gcmVtb3RlIGFuZCBjbG9iYmVyIGNoYW5nZWQgdGFncyIKIG1zZ3N0ciAiIgogInJlbnNhIGxva2FsYSB0YWdnYXIgaW50ZSBsw6RuZ3JlIHDDpSBmasOkcnJlbiBvY2ggc2tyaXYgw7Z2ZXIgw6RuZHJhZGUgdGFnZ2FyIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTQzIGJ1aWx0aW4vZmV0Y2guYzoxNjYgYnVpbHRpbi9wdWxsLmM6MTQwCisjOiBidWlsdGluL2ZldGNoLmM6MTU4IGJ1aWx0aW4vZmV0Y2guYzoxODEgYnVpbHRpbi9wdWxsLmM6MTQxCiBtc2dpZCAib24tZGVtYW5kIgogbXNnc3RyICJvbi1kZW1hbmQiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNDQKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNTkKIG1zZ2lkICJjb250cm9sIHJlY3Vyc2l2ZSBmZXRjaGluZyBvZiBzdWJtb2R1bGVzIgogbXNnc3RyICJzdHlyIHJla3Vyc2l2IGjDpG10bmluZyBhdiB1bmRlcm1vZHVsZXIiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNDggYnVpbHRpbi9wdWxsLmM6MjI0CisjOiBidWlsdGluL2ZldGNoLmM6MTYzIGJ1aWx0aW4vcHVsbC5jOjIyNQogbXNnaWQgImtlZXAgZG93bmxvYWRlZCBwYWNrIgogbXNnc3RyICJiZWjDpWxsIGjDpG10YWRlIHBha2V0IgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTUwCisjOiBidWlsdGluL2ZldGNoLmM6MTY1CiBtc2dpZCAiYWxsb3cgdXBkYXRpbmcgb2YgSEVBRCByZWYiCiBtc2dzdHIgInRpbGzDpXQgdXBwZGF0ZXJpbmcgYXYgSEVBRC1yZWZlcmVucyIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE1MyBidWlsdGluL2ZldGNoLmM6MTU5IGJ1aWx0aW4vcHVsbC5jOjIyNworIzogYnVpbHRpbi9mZXRjaC5jOjE2OCBidWlsdGluL2ZldGNoLmM6MTc0IGJ1aWx0aW4vcHVsbC5jOjIyOAogbXNnaWQgImRlZXBlbiBoaXN0b3J5IG9mIHNoYWxsb3cgY2xvbmUiCiBtc2dzdHIgImbDtnJkanVwYSBoaXN0b3JpayBmw7ZyIGdydW5kIGtsb24iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNTUKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNzAKIG1zZ2lkICJkZWVwZW4gaGlzdG9yeSBvZiBzaGFsbG93IHJlcG9zaXRvcnkgYmFzZWQgb24gdGltZSIKIG1zZ3N0ciAiZsO2cmRqdXBhIGhpc3RvcmlrIGbDtnIgZ3J1bmQga2xvbiBiYXNlcmFkIHDDpSB0aWQiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNjEgYnVpbHRpbi9wdWxsLmM6MjMwCisjOiBidWlsdGluL2ZldGNoLmM6MTc2IGJ1aWx0aW4vcHVsbC5jOjIzMQogbXNnaWQgImNvbnZlcnQgdG8gYSBjb21wbGV0ZSByZXBvc2l0b3J5IgogbXNnc3RyICJrb252ZXJ0ZXJhIHRpbGwga29tcGxldHQgYXJraXYiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNjQKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNzkKIG1zZ2lkICJwcmVwZW5kIHRoaXMgdG8gc3VibW9kdWxlIHBhdGggb3V0cHV0IgogbXNnc3RyICJsw6RnZyB0aWxsIGkgYsO2cmphbiBhdiB1bmRlcm1vZHVsZW5zIHPDtmt2w6Rnc3V0ZGF0YSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE2NworIzogYnVpbHRpbi9mZXRjaC5jOjE4MgogbXNnaWQgIiIKICJkZWZhdWx0IGZvciByZWN1cnNpdmUgZmV0Y2hpbmcgb2Ygc3VibW9kdWxlcyAobG93ZXIgcHJpb3JpdHkgdGhhbiBjb25maWcgIgogImZpbGVzKSIKQEAgLTEyNzA4LDEwNSArMTI3NjksMTI5IEBACiAic3RhbmRhcmQgZsO2ciByZWt1cnNpdiBow6RtdG5pbmcgYXYgdW5kZXJtb2R1bGVyIChsw6RncmUgcHJpb3JpdGV0IMOkbiAiCiAia29uZmlndXJhdGlvbnNmaWxlcikiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNzEgYnVpbHRpbi9wdWxsLmM6MjMzCisjOiBidWlsdGluL2ZldGNoLmM6MTg2IGJ1aWx0aW4vcHVsbC5jOjIzNAogbXNnaWQgImFjY2VwdCByZWZzIHRoYXQgdXBkYXRlIC5naXQvc2hhbGxvdyIKIG1zZ3N0ciAidGFyIGVtb3QgcmVmZXJlbnNlciBzb20gdXBwZGF0ZXJhciAuZ2l0L3NoYWxsb3ciCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNzIgYnVpbHRpbi9wdWxsLmM6MjM1CisjOiBidWlsdGluL2ZldGNoLmM6MTg3IGJ1aWx0aW4vcHVsbC5jOjIzNgogbXNnaWQgInJlZm1hcCIKIG1zZ3N0ciAicmVmZXJlbnNrYXJ0YSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE3MyBidWlsdGluL3B1bGwuYzoyMzYKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxODggYnVpbHRpbi9wdWxsLmM6MjM3CiBtc2dpZCAic3BlY2lmeSBmZXRjaCByZWZtYXAiCiBtc2dzdHIgImFuZ2UgcmVmZXJlbnNrYXJ0YSBmw7ZyIFwiZmV0Y2hcIiIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE4MAorIzogYnVpbHRpbi9mZXRjaC5jOjE5NQogbXNnaWQgInJlcG9ydCB0aGF0IHdlIGhhdmUgb25seSBvYmplY3RzIHJlYWNoYWJsZSBmcm9tIHRoaXMgb2JqZWN0IgogbXNnc3RyICJyYXBwb3J0ZXJhIGF0dCB2aSBiYXJhIGhhciBvYmpla3QgbsOlYmFyYSBmcsOlbiBkZXR0YSBvYmpla3RldCIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE4MworIzogYnVpbHRpbi9mZXRjaC5jOjE5OAogbXNnaWQgInJ1biAnZ2MgLS1hdXRvJyBhZnRlciBmZXRjaGluZyIKIG1zZ3N0ciAia8O2ciBcImdjIC0tYXV0b1wiIGVmdGVyIGjDpG10bmluZyIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE4NSBidWlsdGluL3B1bGwuYzoyNDUKKyM6IGJ1aWx0aW4vZmV0Y2guYzoyMDAgYnVpbHRpbi9wdWxsLmM6MjQ2CiBtc2dpZCAiY2hlY2sgZm9yIGZvcmNlZC11cGRhdGVzIG9uIGFsbCB1cGRhdGVkIGJyYW5jaGVzIgogbXNnc3RyICJzZSBlZnRlciB0dmluZ2FkZSB1cHBkYXRlcmluZ2FyIGkgYWxsYSB1cHBkYXRlcmFkZSBncmVuYXIiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzo0OTEKKyM6IGJ1aWx0aW4vZmV0Y2guYzo1MTAKIG1zZ2lkICJDb3VsZG4ndCBmaW5kIHJlbW90ZSByZWYgSEVBRCIKIG1zZ3N0ciAiS3VuZGUgaW50ZSBoaXR0YSBmasOkcnItcmVmZXJlbnNlbiBIRUFEIgogCi0jOiBidWlsdGluL2ZldGNoLmM6NjMwCisjOiBidWlsdGluL2ZldGNoLmM6NjUwCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvbmZpZ3VyYXRpb24gZmV0Y2gub3V0cHV0IGNvbnRhaW5zIGludmFsaWQgdmFsdWUgJXMiCiBtc2dzdHIgImtvbmZpZ3VyYXRpb25lbiBmw7ZyIGZldGNoLm91dHB1dCBpbm5laMOlbGxlciBvZ2lsdGlndCB2w6RyZGUgJXMiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzo3MjgKKyM6IGJ1aWx0aW4vZmV0Y2guYzo3NDgKICMsIGMtZm9ybWF0CiBtc2dpZCAib2JqZWN0ICVzIG5vdCBmb3VuZCIKIG1zZ3N0ciAib2JqZWt0ZXQgJXMgaGl0dGFkZXMgaW50ZSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjczMgorIzogYnVpbHRpbi9mZXRjaC5jOjc1MgogbXNnaWQgIlt1cCB0byBkYXRlXSIKIG1zZ3N0ciAiW8Ogam91cl0iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzo3NDUgYnVpbHRpbi9mZXRjaC5jOjc2MSBidWlsdGluL2ZldGNoLmM6ODMzCisjOiBidWlsdGluL2ZldGNoLmM6NzY1IGJ1aWx0aW4vZmV0Y2guYzo3ODEgYnVpbHRpbi9mZXRjaC5jOjg1MwogbXNnaWQgIltyZWplY3RlZF0iCiBtc2dzdHIgIltyZWZ1c2VyYWRdIgogCi0jOiBidWlsdGluL2ZldGNoLmM6NzQ2CisjOiBidWlsdGluL2ZldGNoLmM6NzY2CiBtc2dpZCAiY2FuJ3QgZmV0Y2ggaW4gY3VycmVudCBicmFuY2giCiBtc2dzdHIgImthbiBpbnRlIGjDpG10YSBpIGFrdHVlbGwgZ3JlbiIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjc1NgorIzogYnVpbHRpbi9mZXRjaC5jOjc3NgogbXNnaWQgIlt0YWcgdXBkYXRlXSIKIG1zZ3N0ciAiW3VwcGRhdGVyYWQgdGFnZ10iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzo3NTcgYnVpbHRpbi9mZXRjaC5jOjc5NCBidWlsdGluL2ZldGNoLmM6ODE2Ci0jOiBidWlsdGluL2ZldGNoLmM6ODI4CisjOiBidWlsdGluL2ZldGNoLmM6Nzc3IGJ1aWx0aW4vZmV0Y2guYzo4MTQgYnVpbHRpbi9mZXRjaC5jOjgzNgorIzogYnVpbHRpbi9mZXRjaC5jOjg0OAogbXNnaWQgInVuYWJsZSB0byB1cGRhdGUgbG9jYWwgcmVmIgogbXNnc3RyICJrdW5kZSBpbnRlIHVwcGRhdGVyYSBsb2thbCByZWYiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzo3NjEKKyM6IGJ1aWx0aW4vZmV0Y2guYzo3ODEKIG1zZ2lkICJ3b3VsZCBjbG9iYmVyIGV4aXN0aW5nIHRhZyIKIG1zZ3N0ciAic2t1bGxlIHNrcml2YSDDtnZlciBiZWZpbnRsaWcgdGFnZyIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjc4MworIzogYnVpbHRpbi9mZXRjaC5jOjgwMwogbXNnaWQgIltuZXcgdGFnXSIKIG1zZ3N0ciAiW255IHRhZ2ddIgogCi0jOiBidWlsdGluL2ZldGNoLmM6Nzg2CisjOiBidWlsdGluL2ZldGNoLmM6ODA2CiBtc2dpZCAiW25ldyBicmFuY2hdIgogbXNnc3RyICJbbnkgZ3Jlbl0iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzo3ODkKKyM6IGJ1aWx0aW4vZmV0Y2guYzo4MDkKIG1zZ2lkICJbbmV3IHJlZl0iCiBtc2dzdHIgIltueSByZWZdIgogCi0jOiBidWlsdGluL2ZldGNoLmM6ODI4CisjOiBidWlsdGluL2ZldGNoLmM6ODQ4CiBtc2dpZCAiZm9yY2VkIHVwZGF0ZSIKIG1zZ3N0ciAidHZpbmdhZCB1cHBkYXRlcmluZyIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjgzMworIzogYnVpbHRpbi9mZXRjaC5jOjg1MwogbXNnaWQgIm5vbi1mYXN0LWZvcndhcmQiCiBtc2dzdHIgImVqIHNuYWJic3BvbGFkIgogCi0jOiBidWlsdGluL2ZldGNoLmM6ODc5CisjOiBidWlsdGluL2ZldGNoLmM6ODc0Cittc2dpZCAiIgorIkZldGNoIG5vcm1hbGx5IGluZGljYXRlcyB3aGljaCBicmFuY2hlcyBoYWQgYSBmb3JjZWQgdXBkYXRlLFxuIgorImJ1dCB0aGF0IGNoZWNrIGhhcyBiZWVuIGRpc2FibGVkLiBUbyByZS1lbmFibGUsIHVzZSAnLS1zaG93LWZvcmNlZC11cGRhdGVzJ1xuIgorImZsYWcgb3IgcnVuICdnaXQgY29uZmlnIGZldGNoLnNob3dGb3JjZWRVcGRhdGVzIHRydWUnLiIKK21zZ3N0ciAiIgorIkZldGNoIHZpc2FyIG5vcm1hbHQgdmlsa2EgZ3JlbmFyIHNvbSB0dsOlbmdzdXBwZGF0ZXJhdHMsIG1lbiB0ZXN0ZXQgaGFyICIKKyJzbGFnaXRzXG4iCisiYXYuIEbDtnIgYXR0IHNsw6UgcMOlIGlnZW4sIGFudsOkbmQgZmxhZ2dhbiBcIi0tc2hvdy1mb3JjZWQtdXBkYXRlc1wiIGVsbGVyIGvDtnJcbiIKKyJcImdpdCBjb25maWcgZmV0Y2guc2hvd0ZvcmNlZFVwZGF0ZXMgdHJ1ZVwiLiIKKworIzogYnVpbHRpbi9mZXRjaC5jOjg3OAorIywgYy1mb3JtYXQKK21zZ2lkICIiCisiSXQgdG9vayAlLjJmIHNlY29uZHMgdG8gY2hlY2sgZm9yY2VkIHVwZGF0ZXMuIFlvdSBjYW4gdXNlXG4iCisiJy0tbm8tc2hvdy1mb3JjZWQtdXBkYXRlcycgb3IgcnVuICdnaXQgY29uZmlnIGZldGNoLnNob3dGb3JjZWRVcGRhdGVzICIKKyJmYWxzZSdcbiIKKyIgdG8gYXZvaWQgdGhpcyBjaGVjay5cbiIKK21zZ3N0ciAiIgorIkRldCB0b2cgJS4yZiBzZWt1bmRlciBhdHQgc2UgZWZ0ZXIgdHbDpW5nc3VwcGRhdGVyaW5nYXIuIER1IGthbiBhbnbDpG5kYVxuIgorIlwiLS1uby1zaG93LWZvcmNlZC11cGRhdGVzXCIgZWxsZXIga8O2cmEgXCJnaXQgY29uZmlnIGZldGNoLiIKKyJzaG93Rm9yY2VkVXBkYXRlc1xuIgorImZhbHNlXCIgZsO2ciBhdHQgdW5kdmlrYSB0ZXN0ZXQuXG4iCisKKyM6IGJ1aWx0aW4vZmV0Y2guYzo5MDgKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgZGlkIG5vdCBzZW5kIGFsbCBuZWNlc3Nhcnkgb2JqZWN0c1xuIgogbXNnc3RyICIlcyBzw6RuZGUgaW50ZSBhbGxhIG7DtmR2w6RuZGlnYSBvYmpla3RcbiIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjkwMAorIzogYnVpbHRpbi9mZXRjaC5jOjkyOQogIywgYy1mb3JtYXQKIG1zZ2lkICJyZWplY3QgJXMgYmVjYXVzZSBzaGFsbG93IHJvb3RzIGFyZSBub3QgYWxsb3dlZCB0byBiZSB1cGRhdGVkIgogbXNnc3RyICJhdnZpc2EgJXMgZMOlIGdydW5kYSByw7Z0dGVyIGludGUga2FuIHVwcGRhdGVyYXMiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzo5OTEgYnVpbHRpbi9mZXRjaC5jOjExMjQKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxMDIwIGJ1aWx0aW4vZmV0Y2guYzoxMTU3CiAjLCBjLWZvcm1hdAogbXNnaWQgIkZyb20gJS4qc1xuIgogbXNnc3RyICJGcsOlbiAlLipzXG4iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxMDAyCisjOiBidWlsdGluL2ZldGNoLmM6MTAzMQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAic29tZSBsb2NhbCByZWZzIGNvdWxkIG5vdCBiZSB1cGRhdGVkOyB0cnkgcnVubmluZ1xuIgpAQCAtMTI4MTUsODkgKzEyOTAwLDc5IEBACiAidmlzc2EgbG9rYWxhIHJlZmVyZW5zZXIga3VuZGUgaW50ZSB1cHBkYXRlcmFzOyB0ZXN0YSBhdHQga8O2cmFcbiIKICIgXCJnaXQgcmVtb3RlIHBydW5lICVzXCIgZsO2ciBhdHQgdGEgYm9ydCBnYW1sYSBncmVuYXIgc29tIHN0w6VyIGkga29uZmxpa3QiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxMDA4Ci1tc2dpZCAiIgotIkZldGNoIG5vcm1hbGx5IGluZGljYXRlcyB3aGljaCBicmFuY2hlcyBoYWQgYSBmb3JjZWQgdXBkYXRlLCBidXQgdGhhdCBjaGVjayAiCi0iaGFzIGJlZW4gZGlzYWJsZWQuIgotbXNnc3RyICIiCi0iSMOkbXRuaW5nIHZpc2FyIHZhbmxpZ3R2aXMgdmlsa2EgZ3JlbmFyIHNvbSBoYXIgZW4gdHZpbmdhZCB1cHBkYXRlcmluZywgbWVuICIKLSJkZXQgdGVzdGV0IGhhciBzbGFnaXRzIGF2LiIKLQotIzogYnVpbHRpbi9mZXRjaC5jOjEwMDkKLW1zZ2lkICIiCi0iVG8gcmUtZW5hYmxlLCB1c2UgJy0tc2hvdy1mb3JjZWQtdXBkYXRlcycgZmxhZyBvciBydW4gJ2dpdCBjb25maWcgZmV0Y2guIgotInNob3dGb3JjZWRVcGRhdGVzIHRydWUnLiIKLW1zZ3N0ciAiIgotIkbDtnIgYXR0IHNsw6UgcMOlIGlnZW4sIGFudsOkbmQgZmxhZ2dhbiBcIi0tc2hvdy1mb3JjZWQtdXBkYXRlc1wiIGVsbGVyIGvDtnIgIgotIlwiZ2l0IGNvbmZpZyBmZXRjaC5zaG93Rm9yY2VkVXBkYXRlcyB0cnVlXCIuIgotCi0jOiBidWlsdGluL2ZldGNoLmM6MTAxMQotIywgYy1mb3JtYXQKLW1zZ2lkICIiCi0iSXQgdG9vayAlLjJmIHNlY29uZHMgdG8gY2hlY2sgZm9yY2VkIHVwZGF0ZXMuIFlvdSBjYW4gdXNlICctLW5vLXNob3ctZm9yY2VkLSIKLSJ1cGRhdGVzJ1xuIgotbXNnc3RyICIiCi0iRGV0IHRvZyAlLjJmIHNla3VuZGVyIGF0dCBzZSBlZnRlciB0dmluZ2FkZSB1cHBkYXRlcmluZ2FyLiBEdSBrYW4gYW52w6RuZGEgIgotIlwiLS1uby1zaG93LWZvcmNlZC11cGRhdGVzXCJcbiIKLQotIzogYnVpbHRpbi9mZXRjaC5jOjEwMTMKLW1zZ2lkICIiCi0ib3IgcnVuICdnaXQgY29uZmlnIGZldGNoLnNob3dGb3JjZWRVcGRhdGVzIGZhbHNlJyB0byBhdm9pZCB0aGlzIGNoZWNrLlxuIgotbXNnc3RyICIiCi0iZWxsZXIga8O2ciBcImdpdCBjb25maWcgZmV0Y2guc2hvd0ZvcmNlZFVwZGF0ZXMgZmFsc2VcIiBmw7ZyIHVuZHZpa2EgdGVzdGV0LlxuIgotCi0jOiBidWlsdGluL2ZldGNoLmM6MTA5NAorIzogYnVpbHRpbi9mZXRjaC5jOjExMjcKICMsIGMtZm9ybWF0CiBtc2dpZCAiICAgKCVzIHdpbGwgYmVjb21lIGRhbmdsaW5nKSIKIG1zZ3N0ciAiICAgKCVzIGtvbW1lciBibGkgZGluZ2xhbmRlKSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjEwOTUKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxMTI4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiAgICglcyBoYXMgYmVjb21lIGRhbmdsaW5nKSIKIG1zZ3N0ciAiICAgKCVzIGhhciBibGl2aXQgZGluZ2xhbmRlKSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjExMjcKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxMTYwCiBtc2dpZCAiW2RlbGV0ZWRdIgogbXNnc3RyICJbYm9ydHRhZ2VuXSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjExMjggYnVpbHRpbi9yZW1vdGUuYzoxMDM2CisjOiBidWlsdGluL2ZldGNoLmM6MTE2MSBidWlsdGluL3JlbW90ZS5jOjEwMzYKIG1zZ2lkICIobm9uZSkiCiBtc2dzdHIgIihpbmdlbikiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxMTUxCisjOiBidWlsdGluL2ZldGNoLmM6MTE4NAogIywgYy1mb3JtYXQKIG1zZ2lkICJSZWZ1c2luZyB0byBmZXRjaCBpbnRvIGN1cnJlbnQgYnJhbmNoICVzIG9mIG5vbi1iYXJlIHJlcG9zaXRvcnkiCiBtc2dzdHIgIlbDpGdyYXIgaMOkbXRhIHRpbGwgYWt0dWVsbCBncmVuICVzIGkgZXR0IGlja2UtbmFrZXQgYXJraXYiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxMTcwCisjOiBidWlsdGluL2ZldGNoLmM6MTIwMwogIywgYy1mb3JtYXQKIG1zZ2lkICJPcHRpb24gXCIlc1wiIHZhbHVlIFwiJXNcIiBpcyBub3QgdmFsaWQgZm9yICVzIgogbXNnc3RyICJGbGFnZ2FuIFwiJXNcIiBvY2ggdsOkcmRldCBcIiVzXCIgw6RyIGludGUgZ2lsdGlndCBmw7ZyICVzIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTE3MworIzogYnVpbHRpbi9mZXRjaC5jOjEyMDYKICMsIGMtZm9ybWF0CiBtc2dpZCAiT3B0aW9uIFwiJXNcIiBpcyBpZ25vcmVkIGZvciAlc1xuIgogbXNnc3RyICJGbGFnZ2FuIFwiJXNcIiBpZ25vcmVyYXMgZsO2ciAlc1xuIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTQ3NworIzogYnVpbHRpbi9mZXRjaC5jOjE0MTQKK21zZ2lkICJtdWx0aXBsZSBicmFuY2ggZGV0ZWN0ZWQsIGluY29tcGF0aWJsZSB3aXRoIC0tc2V0LXVwc3RyZWFtIgorbXNnc3RyICJmbGVyYSBncmVuYXIgdXBwdMOkY2t0ZXMsIGlua29tcGF0aWJlbHQgbWVkIC0tc2V0LXVwc3RyZWFtIgorCisjOiBidWlsdGluL2ZldGNoLmM6MTQyOQorbXNnaWQgIm5vdCBzZXR0aW5nIHVwc3RyZWFtIGZvciBhIHJlbW90ZSByZW1vdGUtdHJhY2tpbmcgYnJhbmNoIgorbXNnc3RyICJzdMOkbGxlciBpbnRlIGluIHVwcHN0csO2bXNncmVuIGbDtnIgZW4gZmrDpHJyc3DDpXJhbmRlIGdyZW4gcMOlIGZqw6RycmVuIgorCisjOiBidWlsdGluL2ZldGNoLmM6MTQzMQorbXNnaWQgIm5vdCBzZXR0aW5nIHVwc3RyZWFtIGZvciBhIHJlbW90ZSB0YWciCittc2dzdHIgInN0w6RsbGVyIGludGUgaW4gdXBwc3Ryw7ZtIGbDtnIgZW4gZmrDpHJydGFnIgorCisjOiBidWlsdGluL2ZldGNoLmM6MTQzMworbXNnaWQgInVua25vd24gYnJhbmNoIHR5cGUiCittc2dzdHIgIm9rw6RuZCBncmVudHlwIgorCisjOiBidWlsdGluL2ZldGNoLmM6MTQzNQorbXNnaWQgIiIKKyJubyBzb3VyY2UgYnJhbmNoIGZvdW5kLlxuIgorInlvdSBuZWVkIHRvIHNwZWNpZnkgZXhhY3RseSBvbmUgYnJhbmNoIHdpdGggdGhlIC0tc2V0LXVwc3RyZWFtIG9wdGlvbi4iCittc2dzdHIgIiIKKyJoaXR0YWRlIGluZ2VuIGvDpGxsZ3Jlbi5cbiIKKyJkdSBtw6VzdGUgYW5nZSBleGFrdCBlbiBncmVuIG1lZCBmbGFnZ2FuIC0tc2V0LXVwc3RyZWFtLiIKKworIzogYnVpbHRpbi9mZXRjaC5jOjE1NjEgYnVpbHRpbi9mZXRjaC5jOjE2MjMKICMsIGMtZm9ybWF0CiBtc2dpZCAiRmV0Y2hpbmcgJXNcbiIKIG1zZ3N0ciAiSMOkbXRhciAlc1xuIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTQ3OSBidWlsdGluL3JlbW90ZS5jOjEwMAorIzogYnVpbHRpbi9mZXRjaC5jOjE1NzEgYnVpbHRpbi9mZXRjaC5jOjE2MjUgYnVpbHRpbi9yZW1vdGUuYzoxMDAKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ291bGQgbm90IGZldGNoICVzIgogbXNnc3RyICJLdW5kZSBpbnRlIGjDpG10YSAlcyIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE1MjUKLW1zZ2lkICIiCi0iLS1maWx0ZXIgY2FuIG9ubHkgYmUgdXNlZCB3aXRoIHRoZSByZW1vdGUgY29uZmlndXJlZCBpbiBleHRlbnNpb25zLiIKLSJwYXJ0aWFsQ2xvbmUiCi1tc2dzdHIgIiIKLSItLWZpbHRlciBrYW4gZW5kYXN0IGFudsOkbmRhcyBtZWQgZmrDpHJyZW4ga29uZmlndXJlcmFkIGkgZXh0ZW5zaW9ucy4iCi0icGFydGlhbENsb25lIgorIzogYnVpbHRpbi9mZXRjaC5jOjE1ODMKKyMsIGMtZm9ybWF0Cittc2dpZCAiY291bGQgbm90IGZldGNoICclcycgKGV4aXQgY29kZTogJWQpXG4iCittc2dzdHIgImt1bmRlIGludGUgaMOkbXRhIFwiJXNcIiAoZmVsa29kOiAlZClcbiIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE1NDkKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNjg1CiBtc2dpZCAiIgogIk5vIHJlbW90ZSByZXBvc2l0b3J5IHNwZWNpZmllZC4gIFBsZWFzZSwgc3BlY2lmeSBlaXRoZXIgYSBVUkwgb3IgYVxuIgogInJlbW90ZSBuYW1lIGZyb20gd2hpY2ggbmV3IHJldmlzaW9ucyBzaG91bGQgYmUgZmV0Y2hlZC4iCkBAIC0xMjkwNSw0NCArMTI5ODAsNDQgQEAKICJJbmdldCBmasOkcnJhcmtpdiBhbmdhdnMuIEFuZ2UgYW50aW5nZW4gZW4gVVJMIGVsbGVyIG5hbW5ldCBww6UgZXR0XG4iCiAiZmrDpHJyYXJraXYgc29tIG55YSBpbmNoZWNrbmluZ2FyIHNrYWxsIGjDpG10YXMgZnLDpW4uIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTU4NgorIzogYnVpbHRpbi9mZXRjaC5jOjE3MjIKIG1zZ2lkICJZb3UgbmVlZCB0byBzcGVjaWZ5IGEgdGFnIG5hbWUuIgogbXNnc3RyICJEdSBtw6VzdGUgYW5nZSBuYW1uZXQgcMOlIGVuIHRhZ2cuIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTYzNworIzogYnVpbHRpbi9mZXRjaC5jOjE3NzQKIG1zZ2lkICJOZWdhdGl2ZSBkZXB0aCBpbiAtLWRlZXBlbiBpcyBub3Qgc3VwcG9ydGVkIgogbXNnc3RyICJOZWdhdGl2YSBkanVwIHN0w7ZkcyBpbnRlIGkgLS1kZWVwZW4iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNjM5CisjOiBidWlsdGluL2ZldGNoLmM6MTc3NgogbXNnaWQgIi0tZGVlcGVuIGFuZCAtLWRlcHRoIGFyZSBtdXR1YWxseSBleGNsdXNpdmUiCiBtc2dzdHIgIi0tZGVlcGVuIG9jaCAtLWRlcHRoIMOkciDDtm1zZXNpZGlndCB1dGVzbHV0YW5kZSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE2NDQKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNzgxCiBtc2dpZCAiLS1kZXB0aCBhbmQgLS11bnNoYWxsb3cgY2Fubm90IGJlIHVzZWQgdG9nZXRoZXIiCiBtc2dzdHIgIi0tZGVwdGggb2NoIC0tdW5zaGFsbG93IGthbiBpbnRlIGFudsOkbmRhcyBzYW10aWRpZ3QiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNjQ2CisjOiBidWlsdGluL2ZldGNoLmM6MTc4MwogbXNnaWQgIi0tdW5zaGFsbG93IG9uIGEgY29tcGxldGUgcmVwb3NpdG9yeSBkb2VzIG5vdCBtYWtlIHNlbnNlIgogbXNnc3RyICItLXVuc2hhbGxvdyBrYW4gaW50ZSBhbnbDpG5kYXMgcMOlIGV0dCBrb21wbGV0dCBhcmtpdiIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE2NjIKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNzk5CiBtc2dpZCAiZmV0Y2ggLS1hbGwgZG9lcyBub3QgdGFrZSBhIHJlcG9zaXRvcnkgYXJndW1lbnQiCiBtc2dzdHIgImZldGNoIC0tYWxsIHRhciBpbnRlIG5hbW5ldCBww6UgZXR0IGFya2l2IHNvbSBhcmd1bWVudCIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE2NjQKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxODAxCiBtc2dpZCAiZmV0Y2ggLS1hbGwgZG9lcyBub3QgbWFrZSBzZW5zZSB3aXRoIHJlZnNwZWNzIgogbXNnc3RyICJmZXRjaCAtLWFsbCBrYW4gaW50ZSBhbmdlcyBtZWQgcmVmZXJlbnNzcGVjaWZpa2F0aW9uZXIiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNjczCisjOiBidWlsdGluL2ZldGNoLmM6MTgxMAogIywgYy1mb3JtYXQKIG1zZ2lkICJObyBzdWNoIHJlbW90ZSBvciByZW1vdGUgZ3JvdXA6ICVzIgogbXNnc3RyICJGasOkcnJlbiBlbGxlciBmasOkcnJncnVwcGVuIGZpbm5zIGludGU6ICVzIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTY4MAorIzogYnVpbHRpbi9mZXRjaC5jOjE4MTcKIG1zZ2lkICJGZXRjaGluZyBhIGdyb3VwIGFuZCBzcGVjaWZ5aW5nIHJlZnNwZWNzIGRvZXMgbm90IG1ha2Ugc2Vuc2UiCiBtc2dzdHIgIkthbiBpbnRlIGjDpG10YSBmcsOlbiBncnVwcCBvY2ggYW5nZSByZWZlcmVuc3NwZWNpZmlrYXRpb25lciIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE2OTYKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxODM1CiBtc2dpZCAiIgogIi0tZmlsdGVyIGNhbiBvbmx5IGJlIHVzZWQgd2l0aCB0aGUgcmVtb3RlIGNvbmZpZ3VyZWQgaW4gZXh0ZW5zaW9ucy4iCiAicGFydGlhbGNsb25lIgpAQCAtMTMyODQsNyArMTMzNTksNyBAQAogbXNnaWQgImludmFsaWQgcGFyYW1ldGVyOiBleHBlY3RlZCBzaGExLCBnb3QgJyVzJyIKIG1zZ3N0ciAib2dpbHRpZyBwYXJhbWV0ZXI6IGbDtnJ2w6RudGFkZSBzaGExLCBmaWNrIFwiJXNcIiIKIAotIzogYnVpbHRpbi9nYy5jOjM0CisjOiBidWlsdGluL2djLmM6MzUKIG1zZ2lkICJnaXQgZ2MgWzxvcHRpb25zPl0iCiBtc2dzdHIgImdpdCBnYyBbPGZsYWdnb3I+XSIKIApAQCAtMTMyOTgsMTcgKzEzMzczLDE3IEBACiBtc2dpZCAiZmFpbGVkIHRvIHBhcnNlICclcycgdmFsdWUgJyVzJyIKIG1zZ3N0ciAibWlzc2x5Y2thZGVzIHRvbGthIFwiJXNcIiB2w6RyZGUgXCIlc1wiIgogCi0jOiBidWlsdGluL2djLmM6NDc2IGJ1aWx0aW4vaW5pdC1kYi5jOjU1CisjOiBidWlsdGluL2djLmM6NDc1IGJ1aWx0aW4vaW5pdC1kYi5jOjU1CiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCBzdGF0ICclcyciCiBtc2dzdHIgImthbiBpbnRlIHRhIHN0YXR1cyBww6UgXCIlc1wiIgogCi0jOiBidWlsdGluL2djLmM6NDg1IGJ1aWx0aW4vbm90ZXMuYzoyNDAgYnVpbHRpbi90YWcuYzo1MjkKKyM6IGJ1aWx0aW4vZ2MuYzo0ODQgYnVpbHRpbi9ub3Rlcy5jOjI0MCBidWlsdGluL3RhZy5jOjUyOQogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgcmVhZCAnJXMnIgogbXNnc3RyICJrdW5kZSBpbnRlIGzDpHNhIFwiJXNcIiIKIAotIzogYnVpbHRpbi9nYy5jOjQ5MgorIzogYnVpbHRpbi9nYy5jOjQ5MQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiVGhlIGxhc3QgZ2MgcnVuIHJlcG9ydGVkIHRoZSBmb2xsb3dpbmcuIFBsZWFzZSBjb3JyZWN0IHRoZSByb290IGNhdXNlXG4iCkBAIC0xMzMyMyw1MiArMTMzOTgsNTIgQEAKICJcbiIKICIlcyIKIAotIzogYnVpbHRpbi9nYy5jOjU0MAorIzogYnVpbHRpbi9nYy5jOjUzOQogbXNnaWQgInBydW5lIHVucmVmZXJlbmNlZCBvYmplY3RzIgogbXNnc3RyICJyZW5zYSBlaiByZWZlcmVyYWRlIG9iamVrdCIKIAotIzogYnVpbHRpbi9nYy5jOjU0MgorIzogYnVpbHRpbi9nYy5jOjU0MQogbXNnaWQgImJlIG1vcmUgdGhvcm91Z2ggKGluY3JlYXNlZCBydW50aW1lKSIKIG1zZ3N0ciAidmFyIG1lciBncnVuZGxpZyAow7ZrYXIga8O2cnRpZGVuKSIKIAotIzogYnVpbHRpbi9nYy5jOjU0MworIzogYnVpbHRpbi9nYy5jOjU0MgogbXNnaWQgImVuYWJsZSBhdXRvLWdjIG1vZGUiCiBtc2dzdHIgImFrdGl2ZXJhIGF1dG8tZ2MtbMOkZ2UiCiAKLSM6IGJ1aWx0aW4vZ2MuYzo1NDYKKyM6IGJ1aWx0aW4vZ2MuYzo1NDUKIG1zZ2lkICJmb3JjZSBydW5uaW5nIGdjIGV2ZW4gaWYgdGhlcmUgbWF5IGJlIGFub3RoZXIgZ2MgcnVubmluZyIKIG1zZ3N0ciAidHZpbmdhIGdjLWvDtnJuaW5nIMOkdmVuIG9tIGVuIGFubmFuIGdjIGthbnNrZSBrw7ZycyIKIAotIzogYnVpbHRpbi9nYy5jOjU0OQorIzogYnVpbHRpbi9nYy5jOjU0OAogbXNnaWQgInJlcGFjayBhbGwgb3RoZXIgcGFja3MgZXhjZXB0IHRoZSBsYXJnZXN0IHBhY2siCiBtc2dzdHIgInBhY2thIG9tIGFsbGEgcGFrZXQgZsO2cnV0b20gZGV0IHN0w7Zyc3RhIHBha2V0ZXQiCiAKLSM6IGJ1aWx0aW4vZ2MuYzo1NjYKKyM6IGJ1aWx0aW4vZ2MuYzo1NjUKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIHBhcnNlIGdjLmxvZ2V4cGlyeSB2YWx1ZSAlcyIKIG1zZ3N0ciAia3VuZGUgaW50ZSB0b2xrYSB2w6RyZGV0ICVzIGbDtnIgZ2MubG9nZXhwaXJ5IgogCi0jOiBidWlsdGluL2djLmM6NTc3CisjOiBidWlsdGluL2djLmM6NTc2CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBwYXJzZSBwcnVuZSBleHBpcnkgdmFsdWUgJXMiCiBtc2dzdHIgImt1bmRlIGludGUgdG9sa2EgdsOkcmRldCAlcyBmw7ZyIHBydW5lIGV4cGlyeSIKIAotIzogYnVpbHRpbi9nYy5jOjU5NworIzogYnVpbHRpbi9nYy5jOjU5NgogIywgYy1mb3JtYXQKIG1zZ2lkICJBdXRvIHBhY2tpbmcgdGhlIHJlcG9zaXRvcnkgaW4gYmFja2dyb3VuZCBmb3Igb3B0aW11bSBwZXJmb3JtYW5jZS5cbiIKIG1zZ3N0ciAiUGFja2FyIGFya2l2ZXQgYXV0b21hdGlza3QgaSBiYWtncnVuZGVuIGbDtnIgb3B0aW1hbCBwcmVzdGFuZGEuXG4iCiAKLSM6IGJ1aWx0aW4vZ2MuYzo1OTkKKyM6IGJ1aWx0aW4vZ2MuYzo1OTgKICMsIGMtZm9ybWF0CiBtc2dpZCAiQXV0byBwYWNraW5nIHRoZSByZXBvc2l0b3J5IGZvciBvcHRpbXVtIHBlcmZvcm1hbmNlLlxuIgogbXNnc3RyICJQYWNrYXIgYXJraXZldCBhdXRvbWF0aXNrdCBmw7ZyIG9wdGltYWwgcHJlc3RhbmRhLlxuIgogCi0jOiBidWlsdGluL2djLmM6NjAwCisjOiBidWlsdGluL2djLmM6NTk5CiAjLCBjLWZvcm1hdAogbXNnaWQgIlNlZSBcImdpdCBoZWxwIGdjXCIgZm9yIG1hbnVhbCBob3VzZWtlZXBpbmcuXG4iCiBtc2dzdHIgIlNlIFwiZ2l0IGhlbHAgZ2NcIiBmw7ZyIG1hbnVlbGwgaHVzaMOlbGxuaW5nLlxuIgogCi0jOiBidWlsdGluL2djLmM6NjQwCisjOiBidWlsdGluL2djLmM6NjM5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJnYyBpcyBhbHJlYWR5IHJ1bm5pbmcgb24gbWFjaGluZSAnJXMnIHBpZCAlPFBSSXVNQVg+ICh1c2UgLS1mb3JjZSBpZiBub3QpIgpAQCAtMTMzNzYsNyArMTM0NTEsNyBAQAogImdjIGvDtnJzIHJlZGFuIHDDpSBtYXNraW5lbiBcIiVzXCIgcGlkICU8UFJJdU1BWD4gKGFudsOkbmQgLS1mb3JjZSBvbSBzw6UgaW50ZSAiCiAiw6RyIGZhbGxldCkiCiAKLSM6IGJ1aWx0aW4vZ2MuYzo2OTUKKyM6IGJ1aWx0aW4vZ2MuYzo2OTQKIG1zZ2lkICIiCiAiVGhlcmUgYXJlIHRvbyBtYW55IHVucmVhY2hhYmxlIGxvb3NlIG9iamVjdHM7IHJ1biAnZ2l0IHBydW5lJyB0byByZW1vdmUgdGhlbS4iCiBtc2dzdHIgIiIKQEAgLTEzNDAyLDI1NyArMTM0NzcsMjU3IEBACiAjLiBncmVwLnRocmVhZHMKICMuCiAjOiBidWlsdGluL2dyZXAuYzoyODcgYnVpbHRpbi9pbmRleC1wYWNrLmM6MTUzNCBidWlsdGluL2luZGV4LXBhY2suYzoxNzI3Ci0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI3MjIKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjcwOAogIywgYy1mb3JtYXQKIG1zZ2lkICJubyB0aHJlYWRzIHN1cHBvcnQsIGlnbm9yaW5nICVzIgogbXNnc3RyICJ0csOlZHN0w7ZkIHNha25hcywgaWdub3JlcmFyICVzIgogCi0jOiBidWlsdGluL2dyZXAuYzo0NjcgYnVpbHRpbi9ncmVwLmM6NTkxIGJ1aWx0aW4vZ3JlcC5jOjYzMworIzogYnVpbHRpbi9ncmVwLmM6NDY3IGJ1aWx0aW4vZ3JlcC5jOjU5MiBidWlsdGluL2dyZXAuYzo2MzUKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHJlYWQgdHJlZSAoJXMpIgogbXNnc3RyICJrdW5kZSBpbnRlIGzDpHNhIHRyw6RkICglcykiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjY0OAorIzogYnVpbHRpbi9ncmVwLmM6NjUwCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBncmVwIGZyb20gb2JqZWN0IG9mIHR5cGUgJXMiCiBtc2dzdHIgImt1bmRlIGludGUgXCJncmVwXCIgZnLDpW4gb2JqZWt0IGF2IHR5cGVuICVzIgogCi0jOiBidWlsdGluL2dyZXAuYzo3MTQKKyM6IGJ1aWx0aW4vZ3JlcC5jOjcxNgogIywgYy1mb3JtYXQKIG1zZ2lkICJzd2l0Y2ggYCVjJyBleHBlY3RzIGEgbnVtZXJpY2FsIHZhbHVlIgogbXNnc3RyICJmbGFnZ2FuIFwiJWNcIiBhbnRhciBldHQgbnVtZXJpc2t0IHbDpHJkZSIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODEzCisjOiBidWlsdGluL2dyZXAuYzo4MTUKIG1zZ2lkICJzZWFyY2ggaW4gaW5kZXggaW5zdGVhZCBvZiBpbiB0aGUgd29yayB0cmVlIgogbXNnc3RyICJzw7ZrIGkgaW5kZXhldCBpc3TDpGxsZXQgZsO2ciBpIGFyYmV0c2thdGFsb2dlbiIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODE1CisjOiBidWlsdGluL2dyZXAuYzo4MTcKIG1zZ2lkICJmaW5kIGluIGNvbnRlbnRzIG5vdCBtYW5hZ2VkIGJ5IGdpdCIKIG1zZ3N0ciAic8O2ayBpIGlubmVow6VsbCBzb20gaW50ZSBoYW50ZXJhcyBhdiBnaXQiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjgxNworIzogYnVpbHRpbi9ncmVwLmM6ODE5CiBtc2dpZCAic2VhcmNoIGluIGJvdGggdHJhY2tlZCBhbmQgdW50cmFja2VkIGZpbGVzIgogbXNnc3RyICJzw7ZrIGkgYsOlZGUgc3DDpXJhZGUgb2NoIG9zcMOlcmFkZSBmaWxlciIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODE5CisjOiBidWlsdGluL2dyZXAuYzo4MjEKIG1zZ2lkICJpZ25vcmUgZmlsZXMgc3BlY2lmaWVkIHZpYSAnLmdpdGlnbm9yZSciCiBtc2dzdHIgImlnbm9yZXJhIGZpbGVyIGFuZ2l2bmEgaSBcIi5naXRpZ25vcmVcIiIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODIxCisjOiBidWlsdGluL2dyZXAuYzo4MjMKIG1zZ2lkICJyZWN1cnNpdmVseSBzZWFyY2ggaW4gZWFjaCBzdWJtb2R1bGUiCiBtc2dzdHIgInPDtmsgdmFyamUgdW5kZXJtb2R1bCByZWt1cnNpdnQiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjgyNAorIzogYnVpbHRpbi9ncmVwLmM6ODI2CiBtc2dpZCAic2hvdyBub24tbWF0Y2hpbmcgbGluZXMiCiBtc2dzdHIgInZpc2EgcmFkZXIgc29tIGludGUgdHLDpGZmYXMiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjgyNgorIzogYnVpbHRpbi9ncmVwLmM6ODI4CiBtc2dpZCAiY2FzZSBpbnNlbnNpdGl2ZSBtYXRjaGluZyIKIG1zZ3N0ciAic2tpZnRsw6RnZXNva8OkbnNsaWcgc8O2a25pbmciCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjgyOAorIzogYnVpbHRpbi9ncmVwLmM6ODMwCiBtc2dpZCAibWF0Y2ggcGF0dGVybnMgb25seSBhdCB3b3JkIGJvdW5kYXJpZXMiCiBtc2dzdHIgIm1hdGNoYSBlbmRhc3QgbcO2bnN0ZXIgdmlkIG9yZGdyw6Ruc2VyIgogCi0jOiBidWlsdGluL2dyZXAuYzo4MzAKKyM6IGJ1aWx0aW4vZ3JlcC5jOjgzMgogbXNnaWQgInByb2Nlc3MgYmluYXJ5IGZpbGVzIGFzIHRleHQiCiBtc2dzdHIgImhhbnRlcmEgYmluw6RyZmlsZXIgc29tIHRleHQiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjgzMgorIzogYnVpbHRpbi9ncmVwLmM6ODM0CiBtc2dpZCAiZG9uJ3QgbWF0Y2ggcGF0dGVybnMgaW4gYmluYXJ5IGZpbGVzIgogbXNnc3RyICJ0csOkZmZhIGludGUgbcO2bnN0ZXIgaSBiaW7DpHJmaWxlciIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODM1CisjOiBidWlsdGluL2dyZXAuYzo4MzcKIG1zZ2lkICJwcm9jZXNzIGJpbmFyeSBmaWxlcyB3aXRoIHRleHRjb252IGZpbHRlcnMiCiBtc2dzdHIgImhhbnRlcmEgYmluw6RyZmlsZXIgbWVkIHRleHRjb252LWZpbHRlciIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODM3CisjOiBidWlsdGluL2dyZXAuYzo4MzkKIG1zZ2lkICJzZWFyY2ggaW4gc3ViZGlyZWN0b3JpZXMgKGRlZmF1bHQpIgogbXNnc3RyICJzw7ZrIGkgdW5kZXJrYXRhbG9nZXIgKHN0YW5kYXJkKSIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODM5CisjOiBidWlsdGluL2dyZXAuYzo4NDEKIG1zZ2lkICJkZXNjZW5kIGF0IG1vc3QgPGRlcHRoPiBsZXZlbHMiCiBtc2dzdHIgImfDpSBzb20gbWVzdCBuZWQgPGRqdXA+IG5pdsOlZXIiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg0MworIzogYnVpbHRpbi9ncmVwLmM6ODQ1CiBtc2dpZCAidXNlIGV4dGVuZGVkIFBPU0lYIHJlZ3VsYXIgZXhwcmVzc2lvbnMiCiBtc2dzdHIgImFudsOkbmQgdXTDtmthZGUgUE9TSVgtcmVndWxqw6RyYSB1dHRyeWNrIgogCi0jOiBidWlsdGluL2dyZXAuYzo4NDYKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg0OAogbXNnaWQgInVzZSBiYXNpYyBQT1NJWCByZWd1bGFyIGV4cHJlc3Npb25zIChkZWZhdWx0KSIKIG1zZ3N0ciAiYW52w6RuZCBncnVuZGzDpGdnYW5kZSBQT1NJWC1yZWd1bGrDpHJhIHV0dHJ5Y2sgKHN0YW5kYXJkKSIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODQ5CisjOiBidWlsdGluL2dyZXAuYzo4NTEKIG1zZ2lkICJpbnRlcnByZXQgcGF0dGVybnMgYXMgZml4ZWQgc3RyaW5ncyIKIG1zZ3N0ciAidG9sa2EgbcO2bnN0ZXIgc29tIGZpeGVyYWRlIHN0csOkbmdhciIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODUyCisjOiBidWlsdGluL2dyZXAuYzo4NTQKIG1zZ2lkICJ1c2UgUGVybC1jb21wYXRpYmxlIHJlZ3VsYXIgZXhwcmVzc2lvbnMiCiBtc2dzdHIgImFudsOkbmQgUGVybGtvbXBhdGlibGEgcmVndWxqw6RyYSB1dHRyeWNrIgogCi0jOiBidWlsdGluL2dyZXAuYzo4NTUKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg1NwogbXNnaWQgInNob3cgbGluZSBudW1iZXJzIgogbXNnc3RyICJ2aXNhIHJhZG51bW1lciIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODU2CisjOiBidWlsdGluL2dyZXAuYzo4NTgKIG1zZ2lkICJzaG93IGNvbHVtbiBudW1iZXIgb2YgZmlyc3QgbWF0Y2giCiBtc2dzdHIgInZpc2Ega29sdW1ubnVtbWVyIGbDtnIgZsO2cnN0YSB0csOkZmYiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg1NworIzogYnVpbHRpbi9ncmVwLmM6ODU5CiBtc2dpZCAiZG9uJ3Qgc2hvdyBmaWxlbmFtZXMiCiBtc2dzdHIgInZpc2EgaW50ZSBmaWxuYW1uIgogCi0jOiBidWlsdGluL2dyZXAuYzo4NTgKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg2MAogbXNnaWQgInNob3cgZmlsZW5hbWVzIgogbXNnc3RyICJ2aXNhIGZpbG5hbW4iCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg2MAorIzogYnVpbHRpbi9ncmVwLmM6ODYyCiBtc2dpZCAic2hvdyBmaWxlbmFtZXMgcmVsYXRpdmUgdG8gdG9wIGRpcmVjdG9yeSIKIG1zZ3N0ciAidmlzYSBmaWxuYW1uIHJlbGF0aXZhIHRpbGwgdG9wcGthdGFsb2dlbiIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODYyCisjOiBidWlsdGluL2dyZXAuYzo4NjQKIG1zZ2lkICJzaG93IG9ubHkgZmlsZW5hbWVzIGluc3RlYWQgb2YgbWF0Y2hpbmcgbGluZXMiCiBtc2dzdHIgInZpc2EgZW5kYXN0IGZpbG5hbW4gaXN0w6RsbGV0IGbDtnIgdHLDpGZmYWRlIHJhZGVyIgogCi0jOiBidWlsdGluL2dyZXAuYzo4NjQKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg2NgogbXNnaWQgInN5bm9ueW0gZm9yIC0tZmlsZXMtd2l0aC1tYXRjaGVzIgogbXNnc3RyICJzeW5vbnltIGbDtnIgLS1maWxlcy13aXRoLW1hdGNoZXMiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg2NworIzogYnVpbHRpbi9ncmVwLmM6ODY5CiBtc2dpZCAic2hvdyBvbmx5IHRoZSBuYW1lcyBvZiBmaWxlcyB3aXRob3V0IG1hdGNoIgogbXNnc3RyICJ2aXNhIGVuZGFzdCBuYW1uIHDDpSBmaWxlciB1dGFuIHRyw6RmZmFyIgogCi0jOiBidWlsdGluL2dyZXAuYzo4NjkKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg3MQogbXNnaWQgInByaW50IE5VTCBhZnRlciBmaWxlbmFtZXMiCiBtc2dzdHIgInNrcml2IE5VTCBlZnRlciBmaWxuYW1uIgogCi0jOiBidWlsdGluL2dyZXAuYzo4NzIKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg3NAogbXNnaWQgInNob3cgb25seSBtYXRjaGluZyBwYXJ0cyBvZiBhIGxpbmUiCiBtc2dzdHIgInZpc2EgZW5kYXN0IHRyw6RmZmFkZSBkZWxhciBhdiByYWRlciIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODc0CisjOiBidWlsdGluL2dyZXAuYzo4NzYKIG1zZ2lkICJzaG93IHRoZSBudW1iZXIgb2YgbWF0Y2hlcyBpbnN0ZWFkIG9mIG1hdGNoaW5nIGxpbmVzIgogbXNnc3RyICJ2aXNhIGFudGFsIHRyw6RmZmFyIGlzdMOkbGxldCBmw7ZyIHRyw6RmZmFkZSByYWRlciIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODc1CisjOiBidWlsdGluL2dyZXAuYzo4NzcKIG1zZ2lkICJoaWdobGlnaHQgbWF0Y2hlcyIKIG1zZ3N0ciAibGp1c21hcmtlcmEgdHLDpGZmYXIiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg3NworIzogYnVpbHRpbi9ncmVwLmM6ODc5CiBtc2dpZCAicHJpbnQgZW1wdHkgbGluZSBiZXR3ZWVuIG1hdGNoZXMgZnJvbSBkaWZmZXJlbnQgZmlsZXMiCiBtc2dzdHIgInNrcml2IHRvbW1hIHJhZGVyIG1lbGxhbiB0csOkZmZhciBmcsOlbiBvbGlrYSBmaWxlciIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODc5CisjOiBidWlsdGluL2dyZXAuYzo4ODEKIG1zZ2lkICJzaG93IGZpbGVuYW1lIG9ubHkgb25jZSBhYm92ZSBtYXRjaGVzIGZyb20gc2FtZSBmaWxlIgogbXNnc3RyICJ2aXNhIGZpbG5hbW4gZW5kYXN0IGVuIGfDpW5nIG92YW5mw7ZyIHRyw6RmZmFyIGZyw6VuIHNhbW1hIGZpbCIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODgyCisjOiBidWlsdGluL2dyZXAuYzo4ODQKIG1zZ2lkICJzaG93IDxuPiBjb250ZXh0IGxpbmVzIGJlZm9yZSBhbmQgYWZ0ZXIgbWF0Y2hlcyIKIG1zZ3N0ciAidmlzYSA8bj4gcmFkZXIgc2FtbWFuaGFuZyBmw7ZyZSBvY2ggZWZ0ZXIgdHLDpGZmYXIiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg4NQorIzogYnVpbHRpbi9ncmVwLmM6ODg3CiBtc2dpZCAic2hvdyA8bj4gY29udGV4dCBsaW5lcyBiZWZvcmUgbWF0Y2hlcyIKIG1zZ3N0ciAidmlzYSA8bj4gcmFkZXIgc2FtbWFuaGFuZyBmw7ZyZSB0csOkZmZhciIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODg3CisjOiBidWlsdGluL2dyZXAuYzo4ODkKIG1zZ2lkICJzaG93IDxuPiBjb250ZXh0IGxpbmVzIGFmdGVyIG1hdGNoZXMiCiBtc2dzdHIgInZpc2EgPG4+IHJhZGVyIHNhbW1hbmhhbmcgZWZ0ZXIgdHLDpGZmYXIiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg4OQorIzogYnVpbHRpbi9ncmVwLmM6ODkxCiBtc2dpZCAidXNlIDxuPiB3b3JrZXIgdGhyZWFkcyIKIG1zZ3N0ciAiYW52w6RuZCA8bj4gam9iYnRyw6VkYXIiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg5MAorIzogYnVpbHRpbi9ncmVwLmM6ODkyCiBtc2dpZCAic2hvcnRjdXQgZm9yIC1DIE5VTSIKIG1zZ3N0ciAiZ2VudsOkZyBmw7ZyIC1DIE5VTSIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODkzCisjOiBidWlsdGluL2dyZXAuYzo4OTUKIG1zZ2lkICJzaG93IGEgbGluZSB3aXRoIHRoZSBmdW5jdGlvbiBuYW1lIGJlZm9yZSBtYXRjaGVzIgogbXNnc3RyICJ2aXNhIGVuIHJhZCBtZWQgZnVua3Rpb25zbmFtbmV0IGbDtnJlIHRyw6RmZmVuIgogCi0jOiBidWlsdGluL2dyZXAuYzo4OTUKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg5NwogbXNnaWQgInNob3cgdGhlIHN1cnJvdW5kaW5nIGZ1bmN0aW9uIgogbXNnc3RyICJ2aXNhIGRlbiBvbWtyaW5nbGlnZ2FuZGUgZnVua3Rpb25lbiIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODk4CisjOiBidWlsdGluL2dyZXAuYzo5MDAKIG1zZ2lkICJyZWFkIHBhdHRlcm5zIGZyb20gZmlsZSIKIG1zZ3N0ciAibMOkcyBtw7Zuc3RlciBmcsOlbiBmaWwiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjkwMAorIzogYnVpbHRpbi9ncmVwLmM6OTAyCiBtc2dpZCAibWF0Y2ggPHBhdHRlcm4+IgogbXNnc3RyICJ0csOkZmZhIDxtw7Zuc3Rlcj4iCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjkwMgorIzogYnVpbHRpbi9ncmVwLmM6OTA0CiBtc2dpZCAiY29tYmluZSBwYXR0ZXJucyBzcGVjaWZpZWQgd2l0aCAtZSIKIG1zZ3N0ciAia29tYmluZXJhIG3Dtm5zdGVyIHNvbSBhbmdlcyBtZWQgLWUiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjkxNAorIzogYnVpbHRpbi9ncmVwLmM6OTE2CiBtc2dpZCAiaW5kaWNhdGUgaGl0IHdpdGggZXhpdCBzdGF0dXMgd2l0aG91dCBvdXRwdXQiCiBtc2dzdHIgImFuZ2UgdHLDpGZmIG1lZCBzbHV0c3RhdHVza29kIHV0YW4gdXRkYXRhIgogCi0jOiBidWlsdGluL2dyZXAuYzo5MTYKKyM6IGJ1aWx0aW4vZ3JlcC5jOjkxOAogbXNnaWQgInNob3cgb25seSBtYXRjaGVzIGZyb20gZmlsZXMgdGhhdCBtYXRjaCBhbGwgcGF0dGVybnMiCiBtc2dzdHIgInZpc2EgZW5kYXN0IHRyw6RmZmFyIGZyw6VuIGZpbGVyIHNvbSB0csOkZmZhciBhbGxhIG3Dtm5zdGVyIgogCi0jOiBidWlsdGluL2dyZXAuYzo5MTgKKyM6IGJ1aWx0aW4vZ3JlcC5jOjkyMAogbXNnaWQgInNob3cgcGFyc2UgdHJlZSBmb3IgZ3JlcCBleHByZXNzaW9uIgogbXNnc3RyICJ2aXNhIGFuYWx5c3Ryw6RkIGbDtnIgZ3JlcC11dHRyeWNrIgogCi0jOiBidWlsdGluL2dyZXAuYzo5MjIKKyM6IGJ1aWx0aW4vZ3JlcC5jOjkyNAogbXNnaWQgInBhZ2VyIgogbXNnc3RyICJibMOkZGRyYXJlIgogCi0jOiBidWlsdGluL2dyZXAuYzo5MjIKKyM6IGJ1aWx0aW4vZ3JlcC5jOjkyNAogbXNnaWQgInNob3cgbWF0Y2hpbmcgZmlsZXMgaW4gdGhlIHBhZ2VyIgogbXNnc3RyICJ2aXNhIHRyw6RmZmFkZSBmaWxlciBpIGZpbGJsw6RkZHJhcmVuIgogCi0jOiBidWlsdGluL2dyZXAuYzo5MjYKKyM6IGJ1aWx0aW4vZ3JlcC5jOjkyOAogbXNnaWQgImFsbG93IGNhbGxpbmcgb2YgZ3JlcCgxKSAoaWdub3JlZCBieSB0aGlzIGJ1aWxkKSIKIG1zZ3N0ciAidGlsbMOldCBhbnJvcGEgZ3JlcCgxKSAoaWdub3JlcmFzIGF2IGRldHRhIGJ5Z2dlKSIKIAotIzogYnVpbHRpbi9ncmVwLmM6OTkwCisjOiBidWlsdGluL2dyZXAuYzo5OTIKIG1zZ2lkICJubyBwYXR0ZXJuIGdpdmVuIgogbXNnc3RyICJpbmdldCBtw7Zuc3RlciBhbmdhdnMiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjEwMjYKKyM6IGJ1aWx0aW4vZ3JlcC5jOjEwMjgKIG1zZ2lkICItLW5vLWluZGV4IG9yIC0tdW50cmFja2VkIGNhbm5vdCBiZSB1c2VkIHdpdGggcmV2cyIKIG1zZ3N0ciAiLS1uby1pbmRleCBvY2ggLS11bnRyYWNrZWQga2FuIGludGUgYW52w6RuZGFzIG1lZCByZXZpc2lvbmVyIgogCi0jOiBidWlsdGluL2dyZXAuYzoxMDM0CisjOiBidWlsdGluL2dyZXAuYzoxMDM2CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byByZXNvbHZlIHJldmlzaW9uOiAlcyIKIG1zZ3N0ciAia2FuIGludGUgc2zDpSB1cHAgcmV2aXNpb246ICVzIgogCi0jOiBidWlsdGluL2dyZXAuYzoxMDY1CisjOiBidWlsdGluL2dyZXAuYzoxMDY3CiBtc2dpZCAiaW52YWxpZCBvcHRpb24gY29tYmluYXRpb24sIGlnbm9yaW5nIC0tdGhyZWFkcyIKIG1zZ3N0ciAib2dpbHRpZyBrb21iaW5hdGlvbiBhdiBmbGFnZ29yLCBpZ25vcmVyYXIgLS10aHJlYWRzIgogCi0jOiBidWlsdGluL2dyZXAuYzoxMDY4IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzQwNQorIzogYnVpbHRpbi9ncmVwLmM6MTA3MCBidWlsdGluL3BhY2stb2JqZWN0cy5jOjM0MDAKIG1zZ2lkICJubyB0aHJlYWRzIHN1cHBvcnQsIGlnbm9yaW5nIC0tdGhyZWFkcyIKIG1zZ3N0ciAidHLDpWRzdMO2ZCBzYWtuYXMsIGlnbm9yZXJhciAtLXRocmVhZHMiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjEwNzEgYnVpbHRpbi9pbmRleC1wYWNrLmM6MTUzMSBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI3MTkKKyM6IGJ1aWx0aW4vZ3JlcC5jOjEwNzMgYnVpbHRpbi9pbmRleC1wYWNrLmM6MTUzMSBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI3MDUKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBudW1iZXIgb2YgdGhyZWFkcyBzcGVjaWZpZWQgKCVkKSIKIG1zZ3N0ciAiZmVsYWt0aWd0IGFudGFsIHRyw6VkYXIgYW5naXZldCAoJWQpIgogCi0jOiBidWlsdGluL2dyZXAuYzoxMDk0CisjOiBidWlsdGluL2dyZXAuYzoxMDk2CiBtc2dpZCAiLS1vcGVuLWZpbGVzLWluLXBhZ2VyIG9ubHkgd29ya3Mgb24gdGhlIHdvcmt0cmVlIgogbXNnc3RyICItLW9wZW4tZmlsZXMtaW4tcGFnZXIgZnVuZ2VyYXIgZW5kYXN0IGkgYXJiZXRza2F0YWxvZ2VuIgogCi0jOiBidWlsdGluL2dyZXAuYzoxMTE3CisjOiBidWlsdGluL2dyZXAuYzoxMTE5CiBtc2dpZCAib3B0aW9uIG5vdCBzdXBwb3J0ZWQgd2l0aCAtLXJlY3Vyc2Utc3VibW9kdWxlcyIKIG1zZ3N0ciAiZmxhZ2dhbiBzdMO2ZHMgaW50ZSBtZWQgLS1yZWN1cnNlLXN1Ym1vZHVsZXMiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjExMjMKKyM6IGJ1aWx0aW4vZ3JlcC5jOjExMjUKIG1zZ2lkICItLWNhY2hlZCBvciAtLXVudHJhY2tlZCBjYW5ub3QgYmUgdXNlZCB3aXRoIC0tbm8taW5kZXgiCiBtc2dzdHIgIi0tY2FjaGVkIG9jaCAtLXVudHJhY2tlZCBrYW4gaW50ZSBhbnbDpG5kYXMgbWVkIC0tbm8taW5kZXgiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjExMjkKKyM6IGJ1aWx0aW4vZ3JlcC5jOjExMzEKIG1zZ2lkICItLVtuby1dZXhjbHVkZS1zdGFuZGFyZCBjYW5ub3QgYmUgdXNlZCBmb3IgdHJhY2tlZCBjb250ZW50cyIKIG1zZ3N0ciAiLS1bbm8tXWV4Y2x1ZGUtc3RhbmRhcmQga2FuIGludGUgYW52w6RuZGFzIGbDtnIgc3DDpXJhdCBpbm5laMOlbGwiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjExMzcKKyM6IGJ1aWx0aW4vZ3JlcC5jOjExMzkKIG1zZ2lkICJib3RoIC0tY2FjaGVkIGFuZCB0cmVlcyBhcmUgZ2l2ZW4iCiBtc2dzdHIgImLDpWRlIC0tY2FjaGVkIG9jaCB0csOkZCBhbmdhdnMiCiAKQEAgLTEzODM3LDcgKzEzOTEyLDcgQEAKIG1zZ2lkICJ1c2VkIG1vcmUgYnl0ZXMgdGhhbiB3ZXJlIGF2YWlsYWJsZSIKIG1zZ3N0ciAiYW52w6RuZGUgZmxlciBieXRlIMOkbiB0aWxsZ8OkbmdsaWd0IgogCi0jOiBidWlsdGluL2luZGV4LXBhY2suYzoyODggYnVpbHRpbi9wYWNrLW9iamVjdHMuYzo2MDAKKyM6IGJ1aWx0aW4vaW5kZXgtcGFjay5jOjI4OCBidWlsdGluL3BhY2stb2JqZWN0cy5jOjYwNAogbXNnaWQgInBhY2sgdG9vIGxhcmdlIGZvciBjdXJyZW50IGRlZmluaXRpb24gb2Ygb2ZmX3QiCiBtc2dzdHIgInBha2V0IGbDtnIgc3RvcnQgZsO2ciBudXZhcmFuZGUgZGVmaW5pdGlvbiBhdiBvZmZfdCIKIApAQCAtMTM5MDMsOCArMTM5NzgsOCBAQAogbXNnaWQgIlNIQTEgQ09MTElTSU9OIEZPVU5EIFdJVEggJXMgISIKIG1zZ3N0ciAiU0hBMS1LT0xMSVNJT04gVVBQVMOEQ0tUIFZJRCAlcyAhIgogCi0jOiBidWlsdGluL2luZGV4LXBhY2suYzo3MzggYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoxNTMKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjEzIGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzA3CisjOiBidWlsdGluL2luZGV4LXBhY2suYzo3MzggYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoxNTcKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjE3IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzExCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byByZWFkICVzIgogbXNnc3RyICJrdW5kZSBpbnRlIGzDpHNhICVzIgpAQCAtMTM5NjUsNyArMTQwNDAsNyBAQAogbXNnaWQgIlJlc29sdmluZyBkZWx0YXMiCiBtc2dzdHIgIkFuYWx5c2VyYXIgZGVsdGEiCiAKLSM6IGJ1aWx0aW4vaW5kZXgtcGFjay5jOjEyMDUgYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNDkxCisjOiBidWlsdGluL2luZGV4LXBhY2suYzoxMjA1IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjQ4MQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gY3JlYXRlIHRocmVhZDogJXMiCiBtc2dzdHIgImt1bmRlIGludGUgc2thcGEgdHLDpWQ6ICVzIgpAQCAtMTQwMzAsNyArMTQxMDUsNyBAQAogbXNnaWQgImNhbm5vdCBzdG9yZSBpbmRleCBmaWxlIgogbXNnc3RyICJrYW4gaW50ZSBzcGFyYSBpbmRleGZpbCIKIAotIzogYnVpbHRpbi9pbmRleC1wYWNrLmM6MTUyNSBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI3MzAKKyM6IGJ1aWx0aW4vaW5kZXgtcGFjay5jOjE1MjUgYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNzE2CiAjLCBjLWZvcm1hdAogbXNnaWQgImJhZCBwYWNrLmluZGV4dmVyc2lvbj0lPFBSSXUzMj4iCiBtc2dzdHIgImZlbGFrdGlnIHBhY2suaW5kZXh2ZXJzaW9uPSU8UFJJdTMyPiIKQEAgLTE0Mjc3LDEyOCArMTQzNTIsMTA4IEBACiBtc2dpZCAiaW52YWxpZCAtLWRlY29yYXRlIG9wdGlvbjogJXMiCiBtc2dzdHIgIm9naWx0aWcgZmxhZ2dhIGbDtnIgLS1kZWNvcmF0ZTogJXMiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTYwCi1tc2dpZCAiIgotImxvZy5tYWlsbWFwIGlzIG5vdCBzZXQ7IGl0cyBpbXBsaWNpdCB2YWx1ZSB3aWxsIGNoYW5nZSBpbiBhblxuIgotInVwY29taW5nIHJlbGVhc2UuIFRvIHNxdWVsY2ggdGhpcyBtZXNzYWdlIGFuZCBwcmVzZXJ2ZSBjdXJyZW50XG4iCi0iYmVoYXZpb3VyLCBzZXQgdGhlIGxvZy5tYWlsbWFwIGNvbmZpZ3VyYXRpb24gdmFsdWUgdG8gZmFsc2UuXG4iCi0iXG4iCi0iVG8gc3F1ZWxjaCB0aGlzIG1lc3NhZ2UgYW5kIGFkb3B0IHRoZSBuZXcgYmVoYXZpb3VyIG5vdywgc2V0IHRoZVxuIgotImxvZy5tYWlsbWFwIGNvbmZpZ3VyYXRpb24gdmFsdWUgdG8gdHJ1ZS5cbiIKLSJcbiIKLSJTZWUgJ2dpdCBoZWxwIGNvbmZpZycgYW5kIHNlYXJjaCBmb3IgJ2xvZy5tYWlsbWFwJyBmb3IgZnVydGhlciBpbmZvcm1hdGlvbi4iCi1tc2dzdHIgIiIKLSJsb2cubWFpbG1hcCBoYXIgaW50ZSBzYXR0czogZsO2cnZhbGV0IGtvbW1lciDDpG5kcmFzIGkgZW4ga29tbWFuZGVcbiIKLSJ2ZXJzaW9uLiBGw7ZyIGF0dCBkw7ZsamEgZGV0IGjDpHIgbWVkZGVsYW5kZXQgb2NoIGJlaMOlbGxhIG51dmFyYW5kZVxuIgotImJldGVlbmRlLCBzw6R0dCBrb25maWd1cmF0aW9uc3ZhcmlhYmVsbiBsb2cubWFpbG1hcCB0aWxsIGZhbHNlLlxuIgotIlxuIgotIkbDtnIgYXR0IGTDtmxqYSBkZXQgaMOkciBtZWRkZWxhbmRldCBvY2ggYW52w6RuZGEgZGV0IG55YSBiZXRlZW5kZXQsXG4iCi0ic8OkdHQga29uZmlndXJhdGlvbnN2YXJpYWJlbG4gbG9nLm1haWxtYXAgdGlsbCB0cnVlLlxuIgotIlxuIgotIlNlIFwiZ2l0IGhlbHAgY29uZmlnXCIgb2NoIHPDtmsgZWZ0ZXIgXCJsb2cubWFpbG1hcFwiIGbDtnIgbWVyIGluZm9ybWF0aW9uLiIKLQotIzogYnVpbHRpbi9sb2cuYzoxODMKKyM6IGJ1aWx0aW4vbG9nLmM6MTczCiBtc2dpZCAic2hvdyBzb3VyY2UiCiBtc2dzdHIgInZpc2Ega8OkbGxrb2QiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTg0CisjOiBidWlsdGluL2xvZy5jOjE3NAogbXNnaWQgIlVzZSBtYWlsIG1hcCBmaWxlIgogbXNnc3RyICJBbnbDpG5kIGUtcG9zdG1hcHBuaW5nc2ZpbCIKIAotIzogYnVpbHRpbi9sb2cuYzoxODYKKyM6IGJ1aWx0aW4vbG9nLmM6MTc2CiBtc2dpZCAib25seSBkZWNvcmF0ZSByZWZzIHRoYXQgbWF0Y2ggPHBhdHRlcm4+IgogbXNnc3RyICJkZWtvcmVyYSBlbmRhc3QgcmVmZXJlbnNlciBzb20gbW90c3ZhcmFyIDxtw7Zuc3Rlcj4iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTg4CisjOiBidWlsdGluL2xvZy5jOjE3OAogbXNnaWQgImRvIG5vdCBkZWNvcmF0ZSByZWZzIHRoYXQgbWF0Y2ggPHBhdHRlcm4+IgogbXNnc3RyICJkZWtvcmVyYSBpbnRlIHJlZmVyZW5zZXIgc29tIG1vdHN2YXJhciA8bcO2bnN0ZXI+IgogCi0jOiBidWlsdGluL2xvZy5jOjE4OQorIzogYnVpbHRpbi9sb2cuYzoxNzkKIG1zZ2lkICJkZWNvcmF0ZSBvcHRpb25zIgogbXNnc3RyICJkZWtvcmVyaW5nc2ZsYWdnb3IiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTkyCisjOiBidWlsdGluL2xvZy5jOjE4MgogbXNnaWQgIlByb2Nlc3MgbGluZSByYW5nZSBuLG0gaW4gZmlsZSwgY291bnRpbmcgZnJvbSAxIgogbXNnc3RyICJCZWhhbmRsYSByYWRpbnRlcnZhbGxldCBuLG0gaSBmaWxlbiwgbWVkIGLDtnJqYW4gcMOlIDEiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6Mjk3CisjOiBidWlsdGluL2xvZy5jOjI4MAogIywgYy1mb3JtYXQKIG1zZ2lkICJGaW5hbCBvdXRwdXQ6ICVkICVzXG4iCiBtc2dzdHIgIlNsdXR1dGRhdGE6ICVkICVzXG4iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6NTUxCisjOiBidWlsdGluL2xvZy5jOjUzNAogIywgYy1mb3JtYXQKIG1zZ2lkICJnaXQgc2hvdyAlczogYmFkIGZpbGUiCiBtc2dzdHIgImdpdCBzaG93ICVzOiBmZWxha3RpZyBmaWwiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6NTY2IGJ1aWx0aW4vbG9nLmM6NjYwCisjOiBidWlsdGluL2xvZy5jOjU0OSBidWlsdGluL2xvZy5jOjY0NAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcmVhZCBvYmplY3QgJXMiCiBtc2dzdHIgImt1bmRlIGludGUgbMOkc2Egb2JqZWt0ZXQgJXMiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6Njg1CisjOiBidWlsdGluL2xvZy5jOjY2OQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmtub3duIHR5cGU6ICVkIgogbXNnc3RyICJva8OkbmQgdHlwOiAlZCIKIAotIzogYnVpbHRpbi9sb2cuYzo4MDgKKyM6IGJ1aWx0aW4vbG9nLmM6NzkyCiBtc2dpZCAiZm9ybWF0LmhlYWRlcnMgd2l0aG91dCB2YWx1ZSIKIG1zZ3N0ciAiZm9ybWF0LmhlYWRlcnMgdXRhbiB2w6RyZGUiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6OTI1CisjOiBidWlsdGluL2xvZy5jOjkwOQogbXNnaWQgIm5hbWUgb2Ygb3V0cHV0IGRpcmVjdG9yeSBpcyB0b28gbG9uZyIKIG1zZ3N0ciAibmFtbmV0IHDDpSB1dGRhdGFrYXRhbG9nZW4gw6RyIGbDtnIgbMOlbmd0IgogCi0jOiBidWlsdGluL2xvZy5jOjk0MQorIzogYnVpbHRpbi9sb2cuYzo5MjUKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IG9wZW4gcGF0Y2ggZmlsZSAlcyIKIG1zZ3N0ciAia2FuIGludGUgw7ZwcG5hIHBhdGNoZmlsZW4gJXMiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6OTU4CisjOiBidWlsdGluL2xvZy5jOjk0MgogbXNnaWQgIm5lZWQgZXhhY3RseSBvbmUgcmFuZ2UiCiBtc2dzdHIgImJlaMO2dmVyIHByZWNpcyBldHQgaW50ZXJ2YWxsIgogCi0jOiBidWlsdGluL2xvZy5jOjk2OAorIzogYnVpbHRpbi9sb2cuYzo5NTIKIG1zZ2lkICJub3QgYSByYW5nZSIKIG1zZ3N0ciAiaW50ZSBldHQgaW50ZXJ2YWxsIgogCi0jOiBidWlsdGluL2xvZy5jOjEwOTEKKyM6IGJ1aWx0aW4vbG9nLmM6MTA3NQogbXNnaWQgImNvdmVyIGxldHRlciBuZWVkcyBlbWFpbCBmb3JtYXQiCiBtc2dzdHIgIm9tc2xhZ3NicmV2ZXQgYmVow7Z2ZXIgZS1wb3N0Zm9ybWF0IgogCi0jOiBidWlsdGluL2xvZy5jOjEwOTcKKyM6IGJ1aWx0aW4vbG9nLmM6MTA4MQogbXNnaWQgImZhaWxlZCB0byBjcmVhdGUgY292ZXItbGV0dGVyIGZpbGUiCiBtc2dzdHIgIm1pc3NseWNrYWRlcyBza2FwYSBmaWwgZsO2ciBvbXNsYWdzYnJldiIKIAotIzogYnVpbHRpbi9sb2cuYzoxMTc2CisjOiBidWlsdGluL2xvZy5jOjExNjAKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW5zYW5lIGluLXJlcGx5LXRvOiAlcyIKIG1zZ3N0ciAidG9raWd0IGluLXJlcGx5LXRvOiAlcyIKIAotIzogYnVpbHRpbi9sb2cuYzoxMjAzCisjOiBidWlsdGluL2xvZy5jOjExODcKIG1zZ2lkICJnaXQgZm9ybWF0LXBhdGNoIFs8b3B0aW9ucz5dIFs8c2luY2U+IHwgPHJldmlzaW9uLXJhbmdlPl0iCiBtc2dzdHIgImdpdCBmb3JtYXQtcGF0Y2ggWzxmbGFnZ29yPl0gWzxzZWRhbj4gfCA8cmV2aXNpb25zaW50ZXJ2YWxsPl0iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTI2MQorIzogYnVpbHRpbi9sb2cuYzoxMjQ1CiBtc2dpZCAidHdvIG91dHB1dCBkaXJlY3Rvcmllcz8iCiBtc2dzdHIgInR2w6UgdXRkYXRha2F0YWxvZ2VyPyIKIAotIzogYnVpbHRpbi9sb2cuYzoxMzcyIGJ1aWx0aW4vbG9nLmM6MjExNiBidWlsdGluL2xvZy5jOjIxMTggYnVpbHRpbi9sb2cuYzoyMTMwCisjOiBidWlsdGluL2xvZy5jOjEzNTYgYnVpbHRpbi9sb2cuYzoyMTE2IGJ1aWx0aW4vbG9nLmM6MjExOCBidWlsdGluL2xvZy5jOjIxMzAKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5rbm93biBjb21taXQgJXMiCiBtc2dzdHIgIm9rw6RuZCBpbmNoZWNrbmluZyAlcyIKIAotIzogYnVpbHRpbi9sb2cuYzoxMzgyIGJ1aWx0aW4vcmVwbGFjZS5jOjU4IGJ1aWx0aW4vcmVwbGFjZS5jOjIwNworIzogYnVpbHRpbi9sb2cuYzoxMzY2IGJ1aWx0aW4vcmVwbGFjZS5jOjU4IGJ1aWx0aW4vcmVwbGFjZS5jOjIwNwogIzogYnVpbHRpbi9yZXBsYWNlLmM6MjEwCiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byByZXNvbHZlICclcycgYXMgYSB2YWxpZCByZWYiCiBtc2dzdHIgIm1pc3NseWNrYWRlcyBzbMOlIHVwcCBcIiVzXCIgc29tIGVuIGdpbHRpZyByZWZlcmVucyIKIAotIzogYnVpbHRpbi9sb2cuYzoxMzg3CisjOiBidWlsdGluL2xvZy5jOjEzNzEKIG1zZ2lkICJjb3VsZCBub3QgZmluZCBleGFjdCBtZXJnZSBiYXNlIgogbXNnc3RyICJrdW5kZSBpbnRlIGhpdHRhIGV4YWt0IHNhbW1hbnNsYWduaW5nc2JhcyIKIAotIzogYnVpbHRpbi9sb2cuYzoxMzkxCisjOiBidWlsdGluL2xvZy5jOjEzNzUKIG1zZ2lkICIiCiAiZmFpbGVkIHRvIGdldCB1cHN0cmVhbSwgaWYgeW91IHdhbnQgdG8gcmVjb3JkIGJhc2UgY29tbWl0IGF1dG9tYXRpY2FsbHksXG4iCiAicGxlYXNlIHVzZSBnaXQgYnJhbmNoIC0tc2V0LXVwc3RyZWFtLXRvIHRvIHRyYWNrIGEgcmVtb3RlIGJyYW5jaC5cbiIKQEAgLTE0NDA4LDIxNiArMTQ0NjMsMjE2IEBACiAiYW52w6RuZCBnaXQgYnJhbmNoIC0tc2V0LXVwc3RyZWFtLXRvIGbDtnIgYXR0IHNww6VyYSBlbiBmasOkcnJncmVuLlxuIgogIkVsbGVyIHPDpSBrYW4gZHUgYW5nZSBiYXNpbmNoZWNrbmluZyBtZWQgLS1iYXNlPTxiYXMtaW5jaGVja25pbmdzLWlkPiBtYW51ZWxsdCIKIAotIzogYnVpbHRpbi9sb2cuYzoxNDExCisjOiBidWlsdGluL2xvZy5jOjEzOTUKIG1zZ2lkICJmYWlsZWQgdG8gZmluZCBleGFjdCBtZXJnZSBiYXNlIgogbXNnc3RyICJrdW5kZSBpbnRlIGhpdHRhIGV4YWt0IHNhbW1hbnNsYWduaW5nc2JhcyIKIAotIzogYnVpbHRpbi9sb2cuYzoxNDIyCisjOiBidWlsdGluL2xvZy5jOjE0MDYKIG1zZ2lkICJiYXNlIGNvbW1pdCBzaG91bGQgYmUgdGhlIGFuY2VzdG9yIG9mIHJldmlzaW9uIGxpc3QiCiBtc2dzdHIgImJhc2luY2hlY2tuaW5nZW4gYsO2ciB2YXJhIGbDtnJmYWRlciB0aWxsIHJldmlzaW9uc2xpc3RhbiIKIAotIzogYnVpbHRpbi9sb2cuYzoxNDI2CisjOiBidWlsdGluL2xvZy5jOjE0MTAKIG1zZ2lkICJiYXNlIGNvbW1pdCBzaG91bGRuJ3QgYmUgaW4gcmV2aXNpb24gbGlzdCIKIG1zZ3N0ciAiYmFzaW5jaGVja25pbmdlbiBiw7ZyIGludGUgdmFyYSBpIHJldmlzaW9uc2xpc3RhbiIKIAotIzogYnVpbHRpbi9sb2cuYzoxNDc5CisjOiBidWlsdGluL2xvZy5jOjE0NjMKIG1zZ2lkICJjYW5ub3QgZ2V0IHBhdGNoIGlkIgogbXNnc3RyICJrYW4gaW50ZSBow6RtdGEgcGF0Y2gtaWQiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTUzMQorIzogYnVpbHRpbi9sb2cuYzoxNTE1CiBtc2dpZCAiZmFpbGVkIHRvIGluZmVyIHJhbmdlLWRpZmYgcmFuZ2VzIgogbXNnc3RyICJtaXNzbHlja2FkZXMgcsOka25hIHV0IGludGVydmFsbCByYW5nZS1kaWZmIgogCi0jOiBidWlsdGluL2xvZy5jOjE1NzYKKyM6IGJ1aWx0aW4vbG9nLmM6MTU2MAogbXNnaWQgInVzZSBbUEFUQ0ggbi9tXSBldmVuIHdpdGggYSBzaW5nbGUgcGF0Y2giCiBtc2dzdHIgImFudsOkbmQgW1BBVENIIG4vbV0gw6R2ZW4gZsO2ciBlbiBlbnNhbSBwYXRjaCIKIAotIzogYnVpbHRpbi9sb2cuYzoxNTc5CisjOiBidWlsdGluL2xvZy5jOjE1NjMKIG1zZ2lkICJ1c2UgW1BBVENIXSBldmVuIHdpdGggbXVsdGlwbGUgcGF0Y2hlcyIKIG1zZ3N0ciAiYW52w6RuZCBbUEFUQ0hdIMOkdmVuIGbDtnIgZmxlcmEgcGF0Y2hhciIKIAotIzogYnVpbHRpbi9sb2cuYzoxNTgzCisjOiBidWlsdGluL2xvZy5jOjE1NjcKIG1zZ2lkICJwcmludCBwYXRjaGVzIHRvIHN0YW5kYXJkIG91dCIKIG1zZ3N0ciAic2tyaXYgcGF0Y2hhcm5hIHDDpSBzdGFuZGFyZCB1dCIKIAotIzogYnVpbHRpbi9sb2cuYzoxNTg1CisjOiBidWlsdGluL2xvZy5jOjE1NjkKIG1zZ2lkICJnZW5lcmF0ZSBhIGNvdmVyIGxldHRlciIKIG1zZ3N0ciAiZ2VuZXJlcmEgZXR0IGbDtmxqZWJyZXYiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTU4NworIzogYnVpbHRpbi9sb2cuYzoxNTcxCiBtc2dpZCAidXNlIHNpbXBsZSBudW1iZXIgc2VxdWVuY2UgZm9yIG91dHB1dCBmaWxlIG5hbWVzIgogbXNnc3RyICJhbnbDpG5kIGVua2VsIG51bW1lcnNla3ZlbnMgZsO2ciB1dGRhdGFmaWxuYW1uIgogCi0jOiBidWlsdGluL2xvZy5jOjE1ODgKKyM6IGJ1aWx0aW4vbG9nLmM6MTU3MgogbXNnaWQgInNmeCIKIG1zZ3N0ciAic2Z4IgogCi0jOiBidWlsdGluL2xvZy5jOjE1ODkKKyM6IGJ1aWx0aW4vbG9nLmM6MTU3MwogbXNnaWQgInVzZSA8c2Z4PiBpbnN0ZWFkIG9mICcucGF0Y2gnIgogbXNnc3RyICJhbnbDpG5kIDxzZng+IGlzdMOkbGxldCBmw7ZyIFwiLnBhdGNoXCIiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTU5MQorIzogYnVpbHRpbi9sb2cuYzoxNTc1CiBtc2dpZCAic3RhcnQgbnVtYmVyaW5nIHBhdGNoZXMgYXQgPG4+IGluc3RlYWQgb2YgMSIKIG1zZ3N0ciAiYsO2cmphIG51bXJlcmEgcGF0Y2hhciBww6UgPG4+IGlzdMOkbGxldCBmw7ZyIDEiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTU5MworIzogYnVpbHRpbi9sb2cuYzoxNTc3CiBtc2dpZCAibWFyayB0aGUgc2VyaWVzIGFzIE50aCByZS1yb2xsIgogbXNnc3RyICJtYXJrZXJhIHNlcmllbiBzb20gTjp0ZSBmw7Zyc8O2ayIKIAotIzogYnVpbHRpbi9sb2cuYzoxNTk1CisjOiBidWlsdGluL2xvZy5jOjE1NzkKIG1zZ2lkICJVc2UgW1JGQyBQQVRDSF0gaW5zdGVhZCBvZiBbUEFUQ0hdIgogbXNnc3RyICJBbnbDpG5kICBbUkZDIFBBVENIXSBpc3TDpGxsZXQgZsO2ciBbUEFUQ0hdIgogCi0jOiBidWlsdGluL2xvZy5jOjE1OTgKKyM6IGJ1aWx0aW4vbG9nLmM6MTU4MgogbXNnaWQgIlVzZSBbPHByZWZpeD5dIGluc3RlYWQgb2YgW1BBVENIXSIKIG1zZ3N0ciAiQW52w6RuZCBbPHByZWZpeD5dIGlzdMOkbGxldCBmw7ZyIFtQQVRDSF0iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTYwMQorIzogYnVpbHRpbi9sb2cuYzoxNTg1CiBtc2dpZCAic3RvcmUgcmVzdWx0aW5nIGZpbGVzIGluIDxkaXI+IgogbXNnc3RyICJzcGFyYSBmaWxlcm5hIGkgPGthdGFsb2c+IgogCi0jOiBidWlsdGluL2xvZy5jOjE2MDQKKyM6IGJ1aWx0aW4vbG9nLmM6MTU4OAogbXNnaWQgImRvbid0IHN0cmlwL2FkZCBbUEFUQ0hdIgogbXNnc3RyICJ0YSBpbnRlIGJvcnQgZWxsZXIgbMOkZ2cgdGlsbCBbUEFUQ0hdIgogCi0jOiBidWlsdGluL2xvZy5jOjE2MDcKKyM6IGJ1aWx0aW4vbG9nLmM6MTU5MQogbXNnaWQgImRvbid0IG91dHB1dCBiaW5hcnkgZGlmZnMiCiBtc2dzdHIgInNrcml2IGludGUgYmluw6RyYSBkaWZmYXIiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTYwOQorIzogYnVpbHRpbi9sb2cuYzoxNTkzCiBtc2dpZCAib3V0cHV0IGFsbC16ZXJvIGhhc2ggaW4gRnJvbSBoZWFkZXIiCiBtc2dzdHIgImFudsOkbmQgaGFzaHbDpHJkZSBtZWQgbm9sbG9yIGkgRnJvbS1odXZ1ZCIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjExCisjOiBidWlsdGluL2xvZy5jOjE1OTUKIG1zZ2lkICJkb24ndCBpbmNsdWRlIGEgcGF0Y2ggbWF0Y2hpbmcgYSBjb21taXQgdXBzdHJlYW0iCiBtc2dzdHIgInRhIGludGUgbWVkIHBhdGNoYXIgc29tIG1vdHN2YXJhciBlbiB1cHBzdHLDtm1zaW5jaGVja25pbmciCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTYxMworIzogYnVpbHRpbi9sb2cuYzoxNTk3CiBtc2dpZCAic2hvdyBwYXRjaCBmb3JtYXQgaW5zdGVhZCBvZiBkZWZhdWx0IChwYXRjaCArIHN0YXQpIgogbXNnc3RyICJ2aXNhIHBhdGNoZm9ybWF0IGlzdMOkbGxldCBmw7ZyIHN0YW5kYXJkIChwYXRjaCArIHN0YXQpIgogCi0jOiBidWlsdGluL2xvZy5jOjE2MTUKKyM6IGJ1aWx0aW4vbG9nLmM6MTU5OQogbXNnaWQgIk1lc3NhZ2luZyIKIG1zZ3N0ciAiRS1wb3N0IgogCi0jOiBidWlsdGluL2xvZy5jOjE2MTYKKyM6IGJ1aWx0aW4vbG9nLmM6MTYwMAogbXNnaWQgImhlYWRlciIKIG1zZ3N0ciAiaHV2dWQiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTYxNworIzogYnVpbHRpbi9sb2cuYzoxNjAxCiBtc2dpZCAiYWRkIGVtYWlsIGhlYWRlciIKIG1zZ3N0ciAibMOkZ2cgdGlsbCBlLXBvc3RodXZ1ZCIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjE4IGJ1aWx0aW4vbG9nLmM6MTYyMAorIzogYnVpbHRpbi9sb2cuYzoxNjAyIGJ1aWx0aW4vbG9nLmM6MTYwNAogbXNnaWQgImVtYWlsIgogbXNnc3RyICJlcG9zdCIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjE4CisjOiBidWlsdGluL2xvZy5jOjE2MDIKIG1zZ2lkICJhZGQgVG86IGhlYWRlciIKIG1zZ3N0ciAibMOkZ2cgdGlsbCBtb3R0YWdhcmh1dnVkIChcIlRvOlwiKSIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjIwCisjOiBidWlsdGluL2xvZy5jOjE2MDQKIG1zZ2lkICJhZGQgQ2M6IGhlYWRlciIKIG1zZ3N0ciAibMOkZ2cgdGlsbCBrb3BpZWh1dnVkIChcIkNjOlwiKSIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjIyCisjOiBidWlsdGluL2xvZy5jOjE2MDYKIG1zZ2lkICJpZGVudCIKIG1zZ3N0ciAiaWRlbnQiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTYyMworIzogYnVpbHRpbi9sb2cuYzoxNjA3CiBtc2dpZCAic2V0IEZyb20gYWRkcmVzcyB0byA8aWRlbnQ+IChvciBjb21taXR0ZXIgaWRlbnQgaWYgYWJzZW50KSIKIG1zZ3N0ciAic8OkdHQgRnLDpW4tYWRyZXNzIHRpbGwgPGlkZW50PiAoZWxsZXIgaW5jaGVja2FyZSBvbSBpZGVudCBzYWtuYXMpIgogCi0jOiBidWlsdGluL2xvZy5jOjE2MjUKKyM6IGJ1aWx0aW4vbG9nLmM6MTYwOQogbXNnaWQgIm1lc3NhZ2UtaWQiCiBtc2dzdHIgIm1lZGRlbGFuZGUtaWQiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTYyNgorIzogYnVpbHRpbi9sb2cuYzoxNjEwCiBtc2dpZCAibWFrZSBmaXJzdCBtYWlsIGEgcmVwbHkgdG8gPG1lc3NhZ2UtaWQ+IgogbXNnc3RyICJnw7ZyIGRldCBmw7Zyc3RhIGJyZXZldCBldHQgc3ZhciB0aWxsIDxtZWRkZWxhbmRlLWlkPiIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjI3IGJ1aWx0aW4vbG9nLmM6MTYzMAorIzogYnVpbHRpbi9sb2cuYzoxNjExIGJ1aWx0aW4vbG9nLmM6MTYxNAogbXNnaWQgImJvdW5kYXJ5IgogbXNnc3RyICJncsOkbnMiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTYyOAorIzogYnVpbHRpbi9sb2cuYzoxNjEyCiBtc2dpZCAiYXR0YWNoIHRoZSBwYXRjaCIKIG1zZ3N0ciAiYmlmb2dhIHBhdGNoZW4iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTYzMQorIzogYnVpbHRpbi9sb2cuYzoxNjE1CiBtc2dpZCAiaW5saW5lIHRoZSBwYXRjaCIKIG1zZ3N0ciAiZ8O2ciBwYXRjaGVuIGV0dCBpbmxpbmUtb2JqZWt0IgogCi0jOiBidWlsdGluL2xvZy5jOjE2MzUKKyM6IGJ1aWx0aW4vbG9nLmM6MTYxOQogbXNnaWQgImVuYWJsZSBtZXNzYWdlIHRocmVhZGluZywgc3R5bGVzOiBzaGFsbG93LCBkZWVwIgogbXNnc3RyICJha3RpdmVyYSBicmV2dHLDpWRuaW5nLCB0eXBlcjogc2hhbGxvdywgZGVlcCIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjM3CisjOiBidWlsdGluL2xvZy5jOjE2MjEKIG1zZ2lkICJzaWduYXR1cmUiCiBtc2dzdHIgInNpZ25hdHVyIgogCi0jOiBidWlsdGluL2xvZy5jOjE2MzgKKyM6IGJ1aWx0aW4vbG9nLmM6MTYyMgogbXNnaWQgImFkZCBhIHNpZ25hdHVyZSIKIG1zZ3N0ciAibMOkZ2cgdGlsbCBzaWduYXR1ciIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjM5CisjOiBidWlsdGluL2xvZy5jOjE2MjMKIG1zZ2lkICJiYXNlLWNvbW1pdCIKIG1zZ3N0ciAiYmFzaW5jaGVja25pbmciCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTY0MAorIzogYnVpbHRpbi9sb2cuYzoxNjI0CiBtc2dpZCAiYWRkIHByZXJlcXVpc2l0ZSB0cmVlIGluZm8gdG8gdGhlIHBhdGNoIHNlcmllcyIKIG1zZ3N0ciAibMOkZ2cgdGlsbCBmw7ZyaGFuZHNrcsOkdmQgdHLDpGRpbmZvIGkgcGF0Y2hzZXJpZW4iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTY0MgorIzogYnVpbHRpbi9sb2cuYzoxNjI2CiBtc2dpZCAiYWRkIGEgc2lnbmF0dXJlIGZyb20gYSBmaWxlIgogbXNnc3RyICJsw6RnZyB0aWxsIHNpZ25hdHVyIGZyw6VuIGZpbCIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjQzCisjOiBidWlsdGluL2xvZy5jOjE2MjcKIG1zZ2lkICJkb24ndCBwcmludCB0aGUgcGF0Y2ggZmlsZW5hbWVzIgogbXNnc3RyICJ2aXNhIGludGUgZmlsbmFtbiBmw7ZyIHBhdGNoYXIiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTY0NQorIzogYnVpbHRpbi9sb2cuYzoxNjI5CiBtc2dpZCAic2hvdyBwcm9ncmVzcyB3aGlsZSBnZW5lcmF0aW5nIHBhdGNoZXMiCiBtc2dzdHIgInZpc2EgZsO2cmxvcHBzaW5kaWthdG9yIG1lZGFuIHBhdGNoYXIgc2thcGFzIgogCi0jOiBidWlsdGluL2xvZy5jOjE2NDcKKyM6IGJ1aWx0aW4vbG9nLmM6MTYzMQogbXNnaWQgInNob3cgY2hhbmdlcyBhZ2FpbnN0IDxyZXY+IGluIGNvdmVyIGxldHRlciBvciBzaW5nbGUgcGF0Y2giCiBtc2dzdHIgInZpc2Egw6RuZHJpbmdhciBtb3QgPHJldj4gaSBvbXNsYWdzYnJldiBlbGxlciBlbnNhbSBwYXRjaCIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjUwCisjOiBidWlsdGluL2xvZy5jOjE2MzQKIG1zZ2lkICJzaG93IGNoYW5nZXMgYWdhaW5zdCA8cmVmc3BlYz4gaW4gY292ZXIgbGV0dGVyIG9yIHNpbmdsZSBwYXRjaCIKIG1zZ3N0ciAidmlzYSDDpG5kcmluZ2FyIG1vdCA8cmVmc3BlYz4gaSBvbXNsYWdzYnJldiBlbGxlciBlbnNhbSBwYXRjaCIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjUyCisjOiBidWlsdGluL2xvZy5jOjE2MzYKIG1zZ2lkICJwZXJjZW50YWdlIGJ5IHdoaWNoIGNyZWF0aW9uIGlzIHdlaWdodGVkIgogbXNnc3RyICJwcm9jZW50IHNvbSBza2FwZWxzZSB2w6RncyBtZWQiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTcyNworIzogYnVpbHRpbi9sb2cuYzoxNzExCiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgaWRlbnQgbGluZTogJXMiCiBtc2dzdHIgIm9naWx0aWcgaWRlbnQtcmFkOiAlcyIKIAotIzogYnVpbHRpbi9sb2cuYzoxNzQyCisjOiBidWlsdGluL2xvZy5jOjE3MjYKIG1zZ2lkICItbiBhbmQgLWsgYXJlIG11dHVhbGx5IGV4Y2x1c2l2ZSIKIG1zZ3N0ciAiLW4gb2NoIC1rIGthbiBpbnRlIGFudsOkbmRhcyBzYW10aWRpZ3QiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTc0NAorIzogYnVpbHRpbi9sb2cuYzoxNzI4CiBtc2dpZCAiLS1zdWJqZWN0LXByZWZpeC8tLXJmYyBhbmQgLWsgYXJlIG11dHVhbGx5IGV4Y2x1c2l2ZSIKIG1zZ3N0ciAiLS1zdWJqZWN0LXByZWZpeC8tLXJmYyBvY2ggLWsga2FuIGludGUgYW52w6RuZGFzIHNhbXRpZGlndCIKIAotIzogYnVpbHRpbi9sb2cuYzoxNzUyCisjOiBidWlsdGluL2xvZy5jOjE3MzYKIG1zZ2lkICItLW5hbWUtb25seSBkb2VzIG5vdCBtYWtlIHNlbnNlIgogbXNnc3RyICJrYW4gaW50ZSBhbnbDpG5kYSAtLW5hbWUtb25seSIKIAotIzogYnVpbHRpbi9sb2cuYzoxNzU0CisjOiBidWlsdGluL2xvZy5jOjE3MzgKIG1zZ2lkICItLW5hbWUtc3RhdHVzIGRvZXMgbm90IG1ha2Ugc2Vuc2UiCiBtc2dzdHIgImthbiBpbnRlIGFudsOkbmRhIC0tbmFtZS1zdGF0dXMiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTc1NgorIzogYnVpbHRpbi9sb2cuYzoxNzQwCiBtc2dpZCAiLS1jaGVjayBkb2VzIG5vdCBtYWtlIHNlbnNlIgogbXNnc3RyICJrYW4gaW50ZSBhbnbDpG5kYSAtLWNoZWNrIgogCi0jOiBidWlsdGluL2xvZy5jOjE3ODgKKyM6IGJ1aWx0aW4vbG9nLmM6MTc3MwogbXNnaWQgInN0YW5kYXJkIG91dHB1dCwgb3IgZGlyZWN0b3J5LCB3aGljaCBvbmU/IgogbXNnc3RyICJzdGFuZGFyZCB1dCwgZWxsZXIga2F0YWxvZywgdmlsa2VuIHNrYWxsIGRldCB2YXJhPyIKIApAQCAtMTQ3OTIsNyArMTQ4NDcsNyBAQAogbXNnaWQgImRvIG5vdCBwcmludCByZW1vdGUgVVJMIgogbXNnc3RyICJ2aXNhIGludGUgZmrDpHJyLVVSTCIKIAotIzogYnVpbHRpbi9scy1yZW1vdGUuYzo2MCBidWlsdGluL2xzLXJlbW90ZS5jOjYyIGJ1aWx0aW4vcmViYXNlLmM6MTQ2NAorIzogYnVpbHRpbi9scy1yZW1vdGUuYzo2MCBidWlsdGluL2xzLXJlbW90ZS5jOjYyIGJ1aWx0aW4vcmViYXNlLmM6MTQ4OAogbXNnaWQgImV4ZWMiCiBtc2dzdHIgImV4ZWMiCiAKQEAgLTE0OTAxLDMyICsxNDk1NiwzMiBAQAogbXNnaWQgIkF2YWlsYWJsZSBjdXN0b20gc3RyYXRlZ2llcyBhcmU6IgogbXNnc3RyICJUaWxsZ8OkbmdsaWdhIHNrcsOkZGRhcnN5ZGRhIHN0cmF0ZWdpZXIgw6RyOiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjI0NCBidWlsdGluL3B1bGwuYzoxNTEKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoyNDQgYnVpbHRpbi9wdWxsLmM6MTUyCiBtc2dpZCAiZG8gbm90IHNob3cgYSBkaWZmc3RhdCBhdCB0aGUgZW5kIG9mIHRoZSBtZXJnZSIKIG1zZ3N0ciAidmlzYSBpbnRlIGVuIGRpZmZzdGF0IG7DpHIgc2FtbWFuc2xhZ25pbmdlbiDDpHIgZsOkcmRpZyIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjI0NyBidWlsdGluL3B1bGwuYzoxNTQKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoyNDcgYnVpbHRpbi9wdWxsLmM6MTU1CiBtc2dpZCAic2hvdyBhIGRpZmZzdGF0IGF0IHRoZSBlbmQgb2YgdGhlIG1lcmdlIgogbXNnc3RyICJ2aXNhIGVuIGRpZmZzdGF0IG7DpHIgc2FtbWFuc2xhZ25pbmdlbiDDpHIgZsOkcmRpZyIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjI0OCBidWlsdGluL3B1bGwuYzoxNTcKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoyNDggYnVpbHRpbi9wdWxsLmM6MTU4CiBtc2dpZCAiKHN5bm9ueW0gdG8gLS1zdGF0KSIKIG1zZ3N0ciAiKHN5bm9ueW0gdGlsbCAtLXN0YXQpIgogCi0jOiBidWlsdGluL21lcmdlLmM6MjUwIGJ1aWx0aW4vcHVsbC5jOjE2MAorIzogYnVpbHRpbi9tZXJnZS5jOjI1MCBidWlsdGluL3B1bGwuYzoxNjEKIG1zZ2lkICJhZGQgKGF0IG1vc3QgPG4+KSBlbnRyaWVzIGZyb20gc2hvcnRsb2cgdG8gbWVyZ2UgY29tbWl0IG1lc3NhZ2UiCiBtc2dzdHIgIiIKICJsw6RnZyB0aWxsIChzb20gbWVzdCA8bj4pIHBvc3RlciBmcsOlbiBzaG9ydGxvZyB0aWxsIGluY2hlY2tuaW5nc21lZGRlbGFuZGV0IgogCi0jOiBidWlsdGluL21lcmdlLmM6MjUzIGJ1aWx0aW4vcHVsbC5jOjE2NgorIzogYnVpbHRpbi9tZXJnZS5jOjI1MyBidWlsdGluL3B1bGwuYzoxNjcKIG1zZ2lkICJjcmVhdGUgYSBzaW5nbGUgY29tbWl0IGluc3RlYWQgb2YgZG9pbmcgYSBtZXJnZSIKIG1zZ3N0ciAic2thcGEgZW4gZW5zYW0gaW5jaGVja25pbmcgaXN0w6RsbGV0IGbDtnIgZW4gc2FtbWFuc2xhZ25pbmciCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoyNTUgYnVpbHRpbi9wdWxsLmM6MTY5CisjOiBidWlsdGluL21lcmdlLmM6MjU1IGJ1aWx0aW4vcHVsbC5jOjE3MAogbXNnaWQgInBlcmZvcm0gYSBjb21taXQgaWYgdGhlIG1lcmdlIHN1Y2NlZWRzIChkZWZhdWx0KSIKIG1zZ3N0ciAidXRmw7ZyIGVuIGluY2hlY2tuaW5nIG9tIHNhbW1hbnNsYWduaW5nZW4gbHlja2FkZXMgKHN0YW5kYXJkKSIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjI1NyBidWlsdGluL3B1bGwuYzoxNzIKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoyNTcgYnVpbHRpbi9wdWxsLmM6MTczCiBtc2dpZCAiZWRpdCBtZXNzYWdlIGJlZm9yZSBjb21taXR0aW5nIgogbXNnc3RyICJyZWRpZ2VyYSBtZWRkZWxhbmRlIGlubmFuIGluY2hlY2tuaW5nIgogCkBAIC0xNDkzNCwyOCArMTQ5ODksMjggQEAKIG1zZ2lkICJhbGxvdyBmYXN0LWZvcndhcmQgKGRlZmF1bHQpIgogbXNnc3RyICJ0aWxsw6V0IHNuYWJic3BvbG5pbmcgKHN0YW5kYXJkKSIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjI2MSBidWlsdGluL3B1bGwuYzoxNzkKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoyNjEgYnVpbHRpbi9wdWxsLmM6MTgwCiBtc2dpZCAiYWJvcnQgaWYgZmFzdC1mb3J3YXJkIGlzIG5vdCBwb3NzaWJsZSIKIG1zZ3N0ciAiYXZicnl0IG9tIHNuYWJic3BvbG5pbmcgaW50ZSDDpHIgbcO2amxpZyIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjI2NSBidWlsdGluL3B1bGwuYzoxODIKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoyNjUgYnVpbHRpbi9wdWxsLmM6MTgzCiBtc2dpZCAidmVyaWZ5IHRoYXQgdGhlIG5hbWVkIGNvbW1pdCBoYXMgYSB2YWxpZCBHUEcgc2lnbmF0dXJlIgogbXNnc3RyICJiZWtyw6RmdGEgYXR0IGRlbiBuYW1uZ2l2bmEgaW5jaGVja25pbmdlbiBoYXIgZW4gZ2lsdGlnIEdQRy1zaWduYXR1ciIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjI2NiBidWlsdGluL25vdGVzLmM6Nzg3IGJ1aWx0aW4vcHVsbC5jOjE4NgotIzogYnVpbHRpbi9yZWJhc2UuYzo0OTIgYnVpbHRpbi9yZWJhc2UuYzoxNDc3IGJ1aWx0aW4vcmV2ZXJ0LmM6MTE0CisjOiBidWlsdGluL21lcmdlLmM6MjY2IGJ1aWx0aW4vbm90ZXMuYzo3ODcgYnVpbHRpbi9wdWxsLmM6MTg3CisjOiBidWlsdGluL3JlYmFzZS5jOjQ5MyBidWlsdGluL3JlYmFzZS5jOjE1MDEgYnVpbHRpbi9yZXZlcnQuYzoxMTQKIG1zZ2lkICJzdHJhdGVneSIKIG1zZ3N0ciAic3RyYXRlZ2kiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoyNjcgYnVpbHRpbi9wdWxsLmM6MTg3CisjOiBidWlsdGluL21lcmdlLmM6MjY3IGJ1aWx0aW4vcHVsbC5jOjE4OAogbXNnaWQgIm1lcmdlIHN0cmF0ZWd5IHRvIHVzZSIKIG1zZ3N0ciAic2FtbWFuc2xhZ25pbmdzc3RyYXRlZ2kgYXR0IGFudsOkbmRhIgogCi0jOiBidWlsdGluL21lcmdlLmM6MjY4IGJ1aWx0aW4vcHVsbC5jOjE5MAorIzogYnVpbHRpbi9tZXJnZS5jOjI2OCBidWlsdGluL3B1bGwuYzoxOTEKIG1zZ2lkICJvcHRpb249dmFsdWUiCiBtc2dzdHIgImFsdGVybmF0aXY9dsOkcmRlIgogCi0jOiBidWlsdGluL21lcmdlLmM6MjY5IGJ1aWx0aW4vcHVsbC5jOjE5MQorIzogYnVpbHRpbi9tZXJnZS5jOjI2OSBidWlsdGluL3B1bGwuYzoxOTIKIG1zZ2lkICJvcHRpb24gZm9yIHNlbGVjdGVkIG1lcmdlIHN0cmF0ZWd5IgogbXNnc3RyICJhbHRlcm5hdGl2IGbDtnIgdmFsZCBzYW1tYW5zbGFnbmluZ3NzdHJhdGVnaSIKIApAQCAtMTQ5NzUsMTMgKzE1MDMwLDEzIEBACiBtc2dpZCAiY29udGludWUgdGhlIGN1cnJlbnQgaW4tcHJvZ3Jlc3MgbWVyZ2UiCiBtc2dzdHIgImZvcnRzw6R0dCBkZW4gcMOlZ8OlZW5kZSBzYW1tYW5zbGFnbmluZ2VuIgogCi0jOiBidWlsdGluL21lcmdlLmM6Mjg0IGJ1aWx0aW4vcHVsbC5jOjE5OAorIzogYnVpbHRpbi9tZXJnZS5jOjI4NCBidWlsdGluL3B1bGwuYzoxOTkKIG1zZ2lkICJhbGxvdyBtZXJnaW5nIHVucmVsYXRlZCBoaXN0b3JpZXMiCiBtc2dzdHIgInRpbGzDpXQgc2FtbWFuc2xhZ25pbmcgYXYgb3JlbGF0ZXJhZGUgaGlzdG9yaWVyIgogCiAjOiBidWlsdGluL21lcmdlLmM6MjkwCi1tc2dpZCAidmVyaWZ5IGNvbW1pdC1tc2cgaG9vayIKLW1zZ3N0ciAiYmVrcsOkZnRhIGNvbW1pdC1tc2cta3JvayIKK21zZ2lkICJieXBhc3MgcHJlLW1lcmdlLWNvbW1pdCBhbmQgY29tbWl0LW1zZyBob29rcyIKK21zZ3N0ciAiZsO2cmJpZ8OlIHByZS1tZXJnZS1jb21taXQtIG9jaCBjb21taXQtbXNnLWtyb2thciIKIAogIzogYnVpbHRpbi9tZXJnZS5jOjMwNwogbXNnaWQgImNvdWxkIG5vdCBydW4gc3Rhc2guIgpAQCAtMTUwMjQsMzMgKzE1MDc5LDMzIEBACiBtc2dpZCAiQmFkIGJyYW5jaC4lcy5tZXJnZW9wdGlvbnMgc3RyaW5nOiAlcyIKIG1zZ3N0ciAiRmVsYWt0aWcgYnJhbmNoLiVzLm1lcmdlb3B0aW9ucy1zdHLDpG5nOiAlcyIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjcwOAorIzogYnVpbHRpbi9tZXJnZS5jOjcwNQogbXNnaWQgIk5vdCBoYW5kbGluZyBhbnl0aGluZyBvdGhlciB0aGFuIHR3byBoZWFkcyBtZXJnZS4iCiBtc2dzdHIgIkhhbnRlcmFyIGludGUgbsOlZ290IGFubmF0IMOkbiBlbiBzYW1tYW5zbGFnbmluZyBhdiB0dsOlIGh1dnVkZW4uIgogCi0jOiBidWlsdGluL21lcmdlLmM6NzIyCisjOiBidWlsdGluL21lcmdlLmM6NzE5CiAjLCBjLWZvcm1hdAogbXNnaWQgIlVua25vd24gb3B0aW9uIGZvciBtZXJnZS1yZWN1cnNpdmU6IC1YJXMiCiBtc2dzdHIgIkZlbGFrdGlnIGZsYWdnYSBmw7ZyIG1lcmdlLXJlY3Vyc2l2ZTogLVglcyIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjczNworIzogYnVpbHRpbi9tZXJnZS5jOjczNAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gd3JpdGUgJXMiCiBtc2dzdHIgImt1bmRlIGludGUgc2tyaXZhICVzIgogCi0jOiBidWlsdGluL21lcmdlLmM6Nzg5CisjOiBidWlsdGluL21lcmdlLmM6Nzg2CiAjLCBjLWZvcm1hdAogbXNnaWQgIkNvdWxkIG5vdCByZWFkIGZyb20gJyVzJyIKIG1zZ3N0ciAiS3VuZGUgaW50ZSBsw6RzYSBmcsOlbiBcIiVzXCIiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzo3OTgKKyM6IGJ1aWx0aW4vbWVyZ2UuYzo3OTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiTm90IGNvbW1pdHRpbmcgbWVyZ2U7IHVzZSAnZ2l0IGNvbW1pdCcgdG8gY29tcGxldGUgdGhlIG1lcmdlLlxuIgogbXNnc3RyICIiCiAiQ2hlY2thciBpbnRlIGluIHNhbW1hbnNsYWduaW5nZW47IGFudsOkbmQgXCJnaXQgY29tbWl0XCIgZsO2ciBhdHQgc2x1dGbDtnJhICIKICJkZW4uXG4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzo4MDQKKyM6IGJ1aWx0aW4vbWVyZ2UuYzo4MDEKIG1zZ2lkICIiCiAiUGxlYXNlIGVudGVyIGEgY29tbWl0IG1lc3NhZ2UgdG8gZXhwbGFpbiB3aHkgdGhpcyBtZXJnZSBpcyBuZWNlc3NhcnksXG4iCiAiZXNwZWNpYWxseSBpZiBpdCBtZXJnZXMgYW4gdXBkYXRlZCB1cHN0cmVhbSBpbnRvIGEgdG9waWMgYnJhbmNoLlxuIgpAQCAtMTUwNjEsMTEgKzE1MTE2LDExIEBACiAidGVtYWdyZW4uXG4iCiAiXG4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzo4MDkKKyM6IGJ1aWx0aW4vbWVyZ2UuYzo4MDYKIG1zZ2lkICJBbiBlbXB0eSBtZXNzYWdlIGFib3J0cyB0aGUgY29tbWl0LlxuIgogbXNnc3RyICJFdHQgdG9tdCBtZWRkZWxhbmRlIGF2YnJ5dGVyIGluY2hlY2tuaW5nZW4uXG4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzo4MTIKKyM6IGJ1aWx0aW4vbWVyZ2UuYzo4MDkKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkxpbmVzIHN0YXJ0aW5nIHdpdGggJyVjJyB3aWxsIGJlIGlnbm9yZWQsIGFuZCBhbiBlbXB0eSBtZXNzYWdlIGFib3J0c1xuIgpAQCAtMTUwNzQsNzMgKzE1MTI5LDczIEBACiAiUmFkZXIgc29tIGlubGVkcyBtZWQgXCIlY1wiIGtvbW1lciBpZ25vcmVyYXMsIG9jaCBldHQgdG9tdCBtZWRkZWxhbmRlXG4iCiAiYXZicnl0ZXIgaW5jaGVja25pbmdlbi5cbiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjg1MworIzogYnVpbHRpbi9tZXJnZS5jOjg2MgogbXNnaWQgIkVtcHR5IGNvbW1pdCBtZXNzYWdlLiIKIG1zZ3N0ciAiVG9tdCBpbmNoZWNrbmluZ3NtZWRkZWxhbmRlLiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjg3MgorIzogYnVpbHRpbi9tZXJnZS5jOjg3NwogIywgYy1mb3JtYXQKIG1zZ2lkICJXb25kZXJmdWwuXG4iCiBtc2dzdHIgIlVuZGVyYmFydC5cbiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjkzMworIzogYnVpbHRpbi9tZXJnZS5jOjkzOAogIywgYy1mb3JtYXQKIG1zZ2lkICJBdXRvbWF0aWMgbWVyZ2UgZmFpbGVkOyBmaXggY29uZmxpY3RzIGFuZCB0aGVuIGNvbW1pdCB0aGUgcmVzdWx0LlxuIgogbXNnc3RyICIiCiAiS3VuZGUgaW50ZSBzbMOlIGlob3AgYXV0b21hdGlza3Q7IGZpeGEga29uZmxpa3RlciBvY2ggY2hlY2thIGluIHJlc3VsdGF0ZXQuXG4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzo5NzIKKyM6IGJ1aWx0aW4vbWVyZ2UuYzo5NzcKIG1zZ2lkICJObyBjdXJyZW50IGJyYW5jaC4iCiBtc2dzdHIgIkludGUgcMOlIG7DpWdvbiBncmVuLiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjk3NAorIzogYnVpbHRpbi9tZXJnZS5jOjk3OQogbXNnaWQgIk5vIHJlbW90ZSBmb3IgdGhlIGN1cnJlbnQgYnJhbmNoLiIKIG1zZ3N0ciAiSW5nZW4gZmrDpHJyIGbDtnIgYWt0dWVsbCBncmVuLiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjk3NgorIzogYnVpbHRpbi9tZXJnZS5jOjk4MQogbXNnaWQgIk5vIGRlZmF1bHQgdXBzdHJlYW0gZGVmaW5lZCBmb3IgdGhlIGN1cnJlbnQgYnJhbmNoLiIKIG1zZ3N0ciAiSW5nZW4gc3RhbmRhcmR1cHBzdHLDtm0gYW5naXZlbiBmw7ZyIGFrdHVlbGwgZ3Jlbi4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzo5ODEKKyM6IGJ1aWx0aW4vbWVyZ2UuYzo5ODYKICMsIGMtZm9ybWF0CiBtc2dpZCAiTm8gcmVtb3RlLXRyYWNraW5nIGJyYW5jaCBmb3IgJXMgZnJvbSAlcyIKIG1zZ3N0ciAiSW5nZW4gZmrDpHJyc3DDpXJhbmRlIGdyZW4gZsO2ciAlcyBmcsOlbiAlcyIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjEwMzgKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxMDQzCiAjLCBjLWZvcm1hdAogbXNnaWQgIkJhZCB2YWx1ZSAnJXMnIGluIGVudmlyb25tZW50ICclcyciCiBtc2dzdHIgIkZlbGFrdGlndCB2w6RyZGUgXCIlc1wiIGkgbWlsasO2dmFyaWFiZWxuIFwiJXNcIiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjExNDEKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxMTQ2CiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vdCBzb21ldGhpbmcgd2UgY2FuIG1lcmdlIGluICVzOiAlcyIKIG1zZ3N0ciAiaW50ZSBuw6Vnb3Qgdmkga2FuIHNsw6UgaWhvcCBtZWQgJXM6ICVzIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTE3NQorIzogYnVpbHRpbi9tZXJnZS5jOjExODAKIG1zZ2lkICJub3Qgc29tZXRoaW5nIHdlIGNhbiBtZXJnZSIKIG1zZ3N0ciAiaW50ZSBuw6Vnb3Qgdmkga2FuIHNsw6UgaWhvcCIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjEyNzgKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxMjgzCiBtc2dpZCAiLS1hYm9ydCBleHBlY3RzIG5vIGFyZ3VtZW50cyIKIG1zZ3N0ciAiLS1hYm9ydCB0YXIgaW5nYSBhcmd1bWVudCIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjEyODIKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxMjg3CiBtc2dpZCAiVGhlcmUgaXMgbm8gbWVyZ2UgdG8gYWJvcnQgKE1FUkdFX0hFQUQgbWlzc2luZykuIgogbXNnc3RyICJJbmdlbiBzYW1tYW5zbGFnbmluZyBhdHQgYXZicnl0YSAoTUVSR0VfSEVBRCBzYWtuYXMpLiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjEyOTEKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxMjk2CiBtc2dpZCAiLS1xdWl0IGV4cGVjdHMgbm8gYXJndW1lbnRzIgogbXNnc3RyICItLXF1aXQgdGFyIGluZ2EgYXJndW1lbnQiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzA0CisjOiBidWlsdGluL21lcmdlLmM6MTMwOQogbXNnaWQgIi0tY29udGludWUgZXhwZWN0cyBubyBhcmd1bWVudHMiCiBtc2dzdHIgIi0tY29udGludWUgdGFyIGluZ2EgYXJndW1lbnQiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzA4CisjOiBidWlsdGluL21lcmdlLmM6MTMxMwogbXNnaWQgIlRoZXJlIGlzIG5vIG1lcmdlIGluIHByb2dyZXNzIChNRVJHRV9IRUFEIG1pc3NpbmcpLiIKIG1zZ3N0ciAiSW5nZW4gc2FtbWFuc2xhZ25pbmcgcMOlZ8OlciAoTUVSR0VfSEVBRCBzYWtuYXMpLiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjEzMjQKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzI5CiBtc2dpZCAiIgogIllvdSBoYXZlIG5vdCBjb25jbHVkZWQgeW91ciBtZXJnZSAoTUVSR0VfSEVBRCBleGlzdHMpLlxuIgogIlBsZWFzZSwgY29tbWl0IHlvdXIgY2hhbmdlcyBiZWZvcmUgeW91IG1lcmdlLiIKQEAgLTE1MTQ4LDcgKzE1MjAzLDcgQEAKICJEdSBoYXIgaW50ZSBhdnNsdXRhdCBzYW1tYW5zbGFnbmluZ2VuIChNRVJHRV9IRUFEIGZpbm5zKS5cbiIKICJDaGVja2EgaW4gZGluYSDDpG5kcmluZ2FyIGlubmFuIGR1IHNsw6VyIGlob3AuIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTMzMQorIzogYnVpbHRpbi9tZXJnZS5jOjEzMzYKIG1zZ2lkICIiCiAiWW91IGhhdmUgbm90IGNvbmNsdWRlZCB5b3VyIGNoZXJyeS1waWNrIChDSEVSUllfUElDS19IRUFEIGV4aXN0cykuXG4iCiAiUGxlYXNlLCBjb21taXQgeW91ciBjaGFuZ2VzIGJlZm9yZSB5b3UgbWVyZ2UuIgpAQCAtMTUxNTYsOTYgKzE1MjExLDk2IEBACiAiRHUgaGFyIGludGUgYXZzbHV0YXQgZGluIFwiY2hlcnJ5LXBpY2tcIiAoQ0hFUlJZX1BJQ0tfSEVBRCBmaW5ucykuXG4iCiAiQ2hlY2thIGluIGRpbmEgw6RuZHJpbmdhciBpbm5hbiBkdSBzbMOlciBpaG9wLiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjEzMzQKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzM5CiBtc2dpZCAiWW91IGhhdmUgbm90IGNvbmNsdWRlZCB5b3VyIGNoZXJyeS1waWNrIChDSEVSUllfUElDS19IRUFEIGV4aXN0cykuIgogbXNnc3RyICJEdSBoYXIgaW50ZSBhdnNsdXRhdCBkaW4gXCJjaGVycnktcGlja1wiIChDSEVSUllfUElDS19IRUFEIGZpbm5zKS4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzQ4CisjOiBidWlsdGluL21lcmdlLmM6MTM1MwogbXNnaWQgIllvdSBjYW5ub3QgY29tYmluZSAtLXNxdWFzaCB3aXRoIC0tbm8tZmYuIgogbXNnc3RyICJEdSBrYW4gaW50ZSBrb21iaW5lcmEgLS1zcXVhc2ggbWVkIC0tbm8tZmYuIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTM1MAorIzogYnVpbHRpbi9tZXJnZS5jOjEzNTUKIG1zZ2lkICJZb3UgY2Fubm90IGNvbWJpbmUgLS1zcXVhc2ggd2l0aCAtLWNvbW1pdC4iCiBtc2dzdHIgIkR1IGthbiBpbnRlIGtvbWJpbmVyYSAtLXNxdWFzaCBtZWQgLS1jb21taXQuIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTM2NgorIzogYnVpbHRpbi9tZXJnZS5jOjEzNzEKIG1zZ2lkICJObyBjb21taXQgc3BlY2lmaWVkIGFuZCBtZXJnZS5kZWZhdWx0VG9VcHN0cmVhbSBub3Qgc2V0LiIKIG1zZ3N0ciAiSW5nZW4gaW5jaGVja25pbmcgYW5naXZlbiBvY2ggbWVyZ2UuZGVmYXVsdFRvVXBzdHJlYW0gw6RyIGVqIHNhdHQuIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTM4MworIzogYnVpbHRpbi9tZXJnZS5jOjEzODgKIG1zZ2lkICJTcXVhc2ggY29tbWl0IGludG8gZW1wdHkgaGVhZCBub3Qgc3VwcG9ydGVkIHlldCIKIG1zZ3N0ciAiU3TDtmRlciBpbnRlIGVuIHRpbGxwbGF0dG5pbmdzaW5jaGVja25pbmcgcMOlIGV0dCB0b210IGh1dnVkIMOkbm51IgogCi0jOiBidWlsdGluL21lcmdlLmM6MTM4NQorIzogYnVpbHRpbi9tZXJnZS5jOjEzOTAKIG1zZ2lkICJOb24tZmFzdC1mb3J3YXJkIGNvbW1pdCBkb2VzIG5vdCBtYWtlIHNlbnNlIGludG8gYW4gZW1wdHkgaGVhZCIKIG1zZ3N0ciAiSWNrZS1zbmFiYnNwb2xhZCBpbmNoZWNrbmluZyBrYW4gaW50ZSBhbnbDpG5kYXMgbWVkIGV0dCB0b210IGh1dnVkIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTM5MAorIzogYnVpbHRpbi9tZXJnZS5jOjEzOTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgLSBub3Qgc29tZXRoaW5nIHdlIGNhbiBtZXJnZSIKIG1zZ3N0ciAiJXMgLSBpbnRlIG7DpWdvdCB2aSBrYW4gc2zDpSBpaG9wIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTM5MgorIzogYnVpbHRpbi9tZXJnZS5jOjEzOTcKIG1zZ2lkICJDYW4gbWVyZ2Ugb25seSBleGFjdGx5IG9uZSBjb21taXQgaW50byBlbXB0eSBoZWFkIgogbXNnc3RyICJLYW4gZW5kYXN0IHNsw6UgaWhvcCBlbiBlbmRhIGluY2hlY2tuaW5nIGkgZXR0IHRvbXQgaHV2dWQiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxNDcxCisjOiBidWlsdGluL21lcmdlLmM6MTQ3NgogbXNnaWQgInJlZnVzaW5nIHRvIG1lcmdlIHVucmVsYXRlZCBoaXN0b3JpZXMiCiBtc2dzdHIgInbDpGdyYXIgc2zDpSBzYW1tYW4gb3JlbGF0ZXJhZCBoaXN0b3JpayIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjE0ODAKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxNDg1CiBtc2dpZCAiQWxyZWFkeSB1cCB0byBkYXRlLiIKIG1zZ3N0ciAiUmVkYW4gw6Agam91ci4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxNDkwCisjOiBidWlsdGluL21lcmdlLmM6MTQ5NQogIywgYy1mb3JtYXQKIG1zZ2lkICJVcGRhdGluZyAlcy4uJXNcbiIKIG1zZ3N0ciAiVXBwZGF0ZXJhciAlcy4uJXNcbiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjE1MzIKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxNTM3CiAjLCBjLWZvcm1hdAogbXNnaWQgIlRyeWluZyByZWFsbHkgdHJpdmlhbCBpbi1pbmRleCBtZXJnZS4uLlxuIgogbXNnc3RyICJGw7Zyc8O2a2VyIHJpa3RpZ3QgZW5rZWwgc2FtbWFuc2xhZ25pbmcgaSBpbmRleGV0Li4uXG4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxNTM5CisjOiBidWlsdGluL21lcmdlLmM6MTU0NAogIywgYy1mb3JtYXQKIG1zZ2lkICJOb3BlLlxuIgogbXNnc3RyICJOZWouXG4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxNTY0CisjOiBidWlsdGluL21lcmdlLmM6MTU2OQogbXNnaWQgIkFscmVhZHkgdXAgdG8gZGF0ZS4gWWVlYWghIgogbXNnc3RyICJSZWRhbiDDoCBqb3VyLiBUb3BwZW4hIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTU3MAorIzogYnVpbHRpbi9tZXJnZS5jOjE1NzUKIG1zZ2lkICJOb3QgcG9zc2libGUgdG8gZmFzdC1mb3J3YXJkLCBhYm9ydGluZy4iCiBtc2dzdHIgIkthbiBpbnRlIHNuYWJic3BvbGEsIGF2YnJ5dGVyLiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjE1OTMgYnVpbHRpbi9tZXJnZS5jOjE2NTgKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxNTk4IGJ1aWx0aW4vbWVyZ2UuYzoxNjYzCiAjLCBjLWZvcm1hdAogbXNnaWQgIlJld2luZGluZyB0aGUgdHJlZSB0byBwcmlzdGluZS4uLlxuIgogbXNnc3RyICLDhXRlcnNwb2xhciB0csOkZGV0IHRpbGwgb3LDtnJ0Li4uXG4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxNTk3CisjOiBidWlsdGluL21lcmdlLmM6MTYwMgogIywgYy1mb3JtYXQKIG1zZ2lkICJUcnlpbmcgbWVyZ2Ugc3RyYXRlZ3kgJXMuLi5cbiIKIG1zZ3N0ciAiRsO2cnPDtmtlciBzYW1tYW5zbGFnbmluZ3NzdHJhdGVnaW4gJXMuLi5cbiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjE2NDkKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxNjU0CiAjLCBjLWZvcm1hdAogbXNnaWQgIk5vIG1lcmdlIHN0cmF0ZWd5IGhhbmRsZWQgdGhlIG1lcmdlLlxuIgogbXNnc3RyICJJbmdlbiBzYW1tYW5zbGFnbmluZ3NzdHJhdGVnaSBoYW50ZXJhZGUgc2FtbWFuc2xhZ25pbmdlbi5cbiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjE2NTEKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxNjU2CiAjLCBjLWZvcm1hdAogbXNnaWQgIk1lcmdlIHdpdGggc3RyYXRlZ3kgJXMgZmFpbGVkLlxuIgogbXNnc3RyICJTYW1tYW5zbGFnbmluZyBtZWQgc3RyYXRlZ2luICVzIG1pc3NseWNrYWRlcy5cbiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjE2NjAKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxNjY1CiAjLCBjLWZvcm1hdAogbXNnaWQgIlVzaW5nIHRoZSAlcyB0byBwcmVwYXJlIHJlc29sdmluZyBieSBoYW5kLlxuIgogbXNnc3RyICJBbnbDpG5kZXIgJXMgZsO2ciBhdHQgZsO2cmJlcmVkYSBsw7ZzbmluZyBmw7ZyIGhhbmQuXG4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxNjcyCisjOiBidWlsdGluL21lcmdlLmM6MTY3NwogIywgYy1mb3JtYXQKIG1zZ2lkICJBdXRvbWF0aWMgbWVyZ2Ugd2VudCB3ZWxsOyBzdG9wcGVkIGJlZm9yZSBjb21taXR0aW5nIGFzIHJlcXVlc3RlZFxuIgogbXNnc3RyICIiCkBAIC0xNTMzMSwzMyArMTUzODYsMzMgQEAKIG1zZ2lkICJzZXQgbGFiZWxzIGZvciBmaWxlMS9vcmlnLWZpbGUvZmlsZTIiCiBtc2dzdHIgInPDpHR0IGV0aWtldHRlciBmw7ZyIGZpbDEvb3JpZ2ZpbC9maWwyIgogCi0jOiBidWlsdGluL21lcmdlLXJlY3Vyc2l2ZS5jOjQ2CisjOiBidWlsdGluL21lcmdlLXJlY3Vyc2l2ZS5jOjQ3CiAjLCBjLWZvcm1hdAogbXNnaWQgInVua25vd24gb3B0aW9uICVzIgogbXNnc3RyICJva8OkbmQgZmxhZ2dhICVzIgogCi0jOiBidWlsdGluL21lcmdlLXJlY3Vyc2l2ZS5jOjUyCisjOiBidWlsdGluL21lcmdlLXJlY3Vyc2l2ZS5jOjUzCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBwYXJzZSBvYmplY3QgJyVzJyIKIG1zZ3N0ciAia3VuZGUgaW50ZSB0b2xrYSBvYmpla3RldCBcIiVzXCIiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UtcmVjdXJzaXZlLmM6NTYKKyM6IGJ1aWx0aW4vbWVyZ2UtcmVjdXJzaXZlLmM6NTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IGhhbmRsZSBtb3JlIHRoYW4gJWQgYmFzZS4gSWdub3JpbmcgJXMuIgogbXNnaWRfcGx1cmFsICJjYW5ub3QgaGFuZGxlIG1vcmUgdGhhbiAlZCBiYXNlcy4gSWdub3JpbmcgJXMuIgogbXNnc3RyWzBdICJrYW4gaW50ZSBoYW50ZXJhIG1lciDDpG4gJWQgYmFzLiBJZ25vcmVyYXIgJXMuIgogbXNnc3RyWzFdICJrYW4gaW50ZSBoYW50ZXJhIG1lciDDpG4gJWQgYmFzZXIuIElnbm9yZXJhciAlcy4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UtcmVjdXJzaXZlLmM6NjQKKyM6IGJ1aWx0aW4vbWVyZ2UtcmVjdXJzaXZlLmM6NjUKIG1zZ2lkICJub3QgaGFuZGxpbmcgYW55dGhpbmcgb3RoZXIgdGhhbiB0d28gaGVhZHMgbWVyZ2UuIgogbXNnc3RyICJoYW50ZXJhciBpbnRlIG7DpWdvdCBhbm5hdCDDpG4gZW4gc2FtbWFuc2xhZ25pbmcgYXYgdHbDpSBodXZ1ZGVuLiIKIAotIzogYnVpbHRpbi9tZXJnZS1yZWN1cnNpdmUuYzo3MCBidWlsdGluL21lcmdlLXJlY3Vyc2l2ZS5jOjcyCisjOiBidWlsdGluL21lcmdlLXJlY3Vyc2l2ZS5jOjc0IGJ1aWx0aW4vbWVyZ2UtcmVjdXJzaXZlLmM6NzYKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHJlc29sdmUgcmVmICclcyciCiBtc2dzdHIgImt1bmRlIGludGUgYmVzdMOkbW1hIHJlZmVyZW5zZW4gXCIlc1wiIgogCi0jOiBidWlsdGluL21lcmdlLXJlY3Vyc2l2ZS5jOjc4CisjOiBidWlsdGluL21lcmdlLXJlY3Vyc2l2ZS5jOjgyCiAjLCBjLWZvcm1hdAogbXNnaWQgIk1lcmdpbmcgJXMgd2l0aCAlc1xuIgogbXNnc3RyICJTbMOlciBpaG9wICVzIG1lZCAlc1xuIgpAQCAtMTU0OTksNTIgKzE1NTU0LDUyIEBACiBtc2dpZCAiUmVuYW1pbmcgJXMgdG8gJXNcbiIKIG1zZ3N0ciAiQnl0ZXIgbmFtbiBww6UgJXMgdGlsbCAlc1xuIgogCi0jOiBidWlsdGluL212LmM6Mjc3IGJ1aWx0aW4vcmVtb3RlLmM6NzE3IGJ1aWx0aW4vcmVwYWNrLmM6NTIwCisjOiBidWlsdGluL212LmM6Mjc3IGJ1aWx0aW4vcmVtb3RlLmM6NzE3IGJ1aWx0aW4vcmVwYWNrLmM6NTExCiAjLCBjLWZvcm1hdAogbXNnaWQgInJlbmFtaW5nICclcycgZmFpbGVkIgogbXNnc3RyICJtaXNzbHlja2FkZXMgYnl0YSBuYW1uIHDDpSBcIiVzXCIiCiAKLSM6IGJ1aWx0aW4vbmFtZS1yZXYuYzozNTIKKyM6IGJ1aWx0aW4vbmFtZS1yZXYuYzozNTYKIG1zZ2lkICJnaXQgbmFtZS1yZXYgWzxvcHRpb25zPl0gPGNvbW1pdD4uLi4iCiBtc2dzdHIgImdpdCBuYW1lLXJldiBbPGZsYWdnb3I+XSA8aW5jaGVja25pbmc+Li4uIgogCi0jOiBidWlsdGluL25hbWUtcmV2LmM6MzUzCisjOiBidWlsdGluL25hbWUtcmV2LmM6MzU3CiBtc2dpZCAiZ2l0IG5hbWUtcmV2IFs8b3B0aW9ucz5dIC0tYWxsIgogbXNnc3RyICJnaXQgbmFtZS1yZXYgWzxmbGFnZ29yPl0gLS1hbGwiCiAKLSM6IGJ1aWx0aW4vbmFtZS1yZXYuYzozNTQKKyM6IGJ1aWx0aW4vbmFtZS1yZXYuYzozNTgKIG1zZ2lkICJnaXQgbmFtZS1yZXYgWzxvcHRpb25zPl0gLS1zdGRpbiIKIG1zZ3N0ciAiZ2l0IG5hbWUtcmV2IFs8ZmxhZ2dvcj5dIC0tc3RkaW4iCiAKLSM6IGJ1aWx0aW4vbmFtZS1yZXYuYzo0MTEKKyM6IGJ1aWx0aW4vbmFtZS1yZXYuYzo0MTUKIG1zZ2lkICJwcmludCBvbmx5IG5hbWVzIChubyBTSEEtMSkiCiBtc2dzdHIgInNrcml2IGVuZGFzdCBuYW1uIChpbmdlbiBTSEEtMSkiCiAKLSM6IGJ1aWx0aW4vbmFtZS1yZXYuYzo0MTIKKyM6IGJ1aWx0aW4vbmFtZS1yZXYuYzo0MTYKIG1zZ2lkICJvbmx5IHVzZSB0YWdzIHRvIG5hbWUgdGhlIGNvbW1pdHMiCiBtc2dzdHIgImFudsOkbmQgZW5kYXN0IHRhZ2dhciBmw7ZyIGF0dCBuYW1uZ2UgaW5jaGVja25pbmdhciIKIAotIzogYnVpbHRpbi9uYW1lLXJldi5jOjQxNAorIzogYnVpbHRpbi9uYW1lLXJldi5jOjQxOAogbXNnaWQgIm9ubHkgdXNlIHJlZnMgbWF0Y2hpbmcgPHBhdHRlcm4+IgogbXNnc3RyICJhbnbDpG5kIGVuZGFzdCByZWZlcmVuc2VyIHNvbSBtb3RzdmFyYXIgPG3Dtm5zdGVyPiIKIAotIzogYnVpbHRpbi9uYW1lLXJldi5jOjQxNgorIzogYnVpbHRpbi9uYW1lLXJldi5jOjQyMAogbXNnaWQgImlnbm9yZSByZWZzIG1hdGNoaW5nIDxwYXR0ZXJuPiIKIG1zZ3N0ciAiaWdub3JlcmEgcmVmZXJlbnNlciBzb20gbW90c3ZhcmFyIDxtw7Zuc3Rlcj4iCiAKLSM6IGJ1aWx0aW4vbmFtZS1yZXYuYzo0MTgKKyM6IGJ1aWx0aW4vbmFtZS1yZXYuYzo0MjIKIG1zZ2lkICJsaXN0IGFsbCBjb21taXRzIHJlYWNoYWJsZSBmcm9tIGFsbCByZWZzIgogbXNnc3RyICJsaXN0YSBhbGxhIGluY2hlY2tuaW5nYXIgc29tIGthbiBuw6VzIGFsbGEgcmVmZXJlbnNlciIKIAotIzogYnVpbHRpbi9uYW1lLXJldi5jOjQxOQorIzogYnVpbHRpbi9uYW1lLXJldi5jOjQyMwogbXNnaWQgInJlYWQgZnJvbSBzdGRpbiIKIG1zZ3N0ciAibMOkcyBmcsOlbiBzdGFuZGFyZCBpbiIKIAotIzogYnVpbHRpbi9uYW1lLXJldi5jOjQyMAorIzogYnVpbHRpbi9uYW1lLXJldi5jOjQyNAogbXNnaWQgImFsbG93IHRvIHByaW50IGB1bmRlZmluZWRgIG5hbWVzIChkZWZhdWx0KSIKIG1zZ3N0ciAidGlsbMOldCBhdHQgc2tyaXZhIFwib2RlZmluaWVyYWRlXCIgbmFtbiAoc3RhbmRhcmQpIgogCi0jOiBidWlsdGluL25hbWUtcmV2LmM6NDI2CisjOiBidWlsdGluL25hbWUtcmV2LmM6NDMwCiBtc2dpZCAiZGVyZWZlcmVuY2UgdGFncyBpbiB0aGUgaW5wdXQgKGludGVybmFsIHVzZSkiCiBtc2dzdHIgImF2cmVmZXJlcmEgdGFnZ2FyIGkgaW5kYXRhIChhbnbDpG5kcyBpbnRlcm50KSIKIApAQCAtMTU5NDMsNyArMTU5OTgsNyBAQAogbXNnaWQgInJlYWQgb2JqZWN0IG5hbWVzIGZyb20gdGhlIHN0YW5kYXJkIGlucHV0IgogbXNnc3RyICJsw6RzIG9iamVrdG5hbW4gZnLDpW4gc3RhbmRhcmQgaW4iCiAKLSM6IGJ1aWx0aW4vbm90ZXMuYzo5NTQgYnVpbHRpbi9wcnVuZS5jOjEzMCBidWlsdGluL3dvcmt0cmVlLmM6MTY1CisjOiBidWlsdGluL25vdGVzLmM6OTU0IGJ1aWx0aW4vcHJ1bmUuYzoxMzAgYnVpbHRpbi93b3JrdHJlZS5jOjE2NAogbXNnaWQgImRvIG5vdCByZW1vdmUsIHNob3cgb25seSIKIG1zZ3N0ciAidGEgaW50ZSBib3J0LCBiYXJhIHZpc2EiCiAKQEAgLTE1OTU5LDcgKzE2MDE0LDcgQEAKIG1zZ2lkICJ1c2Ugbm90ZXMgZnJvbSA8bm90ZXMtcmVmPiIKIG1zZ3N0ciAiYW52w6RuZCBhbnRlY2tuaW5nYXIgZnLDpW4gPGFudGVja25pbmdzcmVmPiIKIAotIzogYnVpbHRpbi9ub3Rlcy5jOjEwMzQgYnVpbHRpbi9zdGFzaC5jOjE1OTgKKyM6IGJ1aWx0aW4vbm90ZXMuYzoxMDM0IGJ1aWx0aW4vc3Rhc2guYzoxNjA3CiAjLCBjLWZvcm1hdAogbXNnaWQgInVua25vd24gc3ViY29tbWFuZDogJXMiCiBtc2dzdHIgIm9rw6RudCB1bmRlcmtvbW1hbmRvOiAlcyIKQEAgLTE1OTc2LDEyNSArMTYwMzEsMTI1IEBACiBtc2dzdHIgIiIKICJnaXQgcGFjay1vYmplY3RzIFs8ZmxhZ2dvcj4uLi5dIDxiYXNuYW1uPiBbPCA8cmVmbGlzdGE+IHwgPCA8b2JqZWt0bGlzdGE+XSIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzo0MjQKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6NDI4CiAjLCBjLWZvcm1hdAogbXNnaWQgImJhZCBwYWNrZWQgb2JqZWN0IENSQyBmb3IgJXMiCiBtc2dzdHIgImZlbGFrdGlnIENSQyBmw7ZyIHBhY2thdCBvYmpla3QgJXMiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6NDM1CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjQzOQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3JydXB0IHBhY2tlZCBvYmplY3QgZm9yICVzIgogbXNnc3RyICJ0cmFzaWd0IHBhY2thdCBvYmpla3QgZsO2ciAlcyIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzo1NjYKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6NTcwCiAjLCBjLWZvcm1hdAogbXNnaWQgInJlY3Vyc2l2ZSBkZWx0YSBkZXRlY3RlZCBmb3Igb2JqZWN0ICVzIgogbXNnc3RyICJyZWt1cnNpdnQgZGVsdGEgdXBwdMOkY2t0ZXMgZsO2ciBvYmpla3RldCAlcyIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzo3NzcKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6NzgxCiAjLCBjLWZvcm1hdAogbXNnaWQgIm9yZGVyZWQgJXUgb2JqZWN0cywgZXhwZWN0ZWQgJTxQUkl1MzI+IgogbXNnc3RyICJvcmRuYWRlICV1IG9iamVrdCwgZsO2cnbDpG50YWRlICU8UFJJdTMyPiIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzo3OTAKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6Nzk0CiAjLCBjLWZvcm1hdAogbXNnaWQgInBhY2tmaWxlIGlzIGludmFsaWQ6ICVzIgogbXNnc3RyICJwYWNrZmlsIMOkciBvZ2lsdGlnOiAlcyIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzo3OTQKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6Nzk4CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBvcGVuIHBhY2tmaWxlIGZvciByZXVzZTogJXMiCiBtc2dzdHIgImthbiBpbnRlIMO2cHBuYSBwYWNrZmlsIGbDtnIgw6V0ZXJhbnbDpG5kbmluZzogJXMiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6Nzk4CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjgwMgogbXNnaWQgInVuYWJsZSB0byBzZWVrIGluIHJldXNlZCBwYWNrZmlsZSIKIG1zZ3N0ciAia2FuIGludGUgc8O2a2EgaSDDpXRlcmFudsOkbmQgcGFja2ZpbCIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzo4MDkKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6ODEzCiBtc2dpZCAidW5hYmxlIHRvIHJlYWQgZnJvbSByZXVzZWQgcGFja2ZpbGUiCiBtc2dzdHIgImthbiBpbnRlIGzDpHNhIGZyw6VuIMOldGVyYW52w6RuZCBwYWNrZmlsIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjgzNworIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzo4NDEKIG1zZ2lkICJkaXNhYmxpbmcgYml0bWFwIHdyaXRpbmcsIHBhY2tzIGFyZSBzcGxpdCBkdWUgdG8gcGFjay5wYWNrU2l6ZUxpbWl0IgogbXNnc3RyICIiCiAiaW5ha3RpdmVyYXIgc2tyaXZuaW5nIGF2IGJpdGthcnRhLCBwYWtldCBkZWxhcyBww6UgZ3J1bmQgYXYgcGFjay5wYWNrU2l6ZUxpbWl0IgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjg1MAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzo4NTQKIG1zZ2lkICJXcml0aW5nIG9iamVjdHMiCiBtc2dzdHIgIlNrcml2ZXIgb2JqZWt0IgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjkxMiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjg5CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjkxNyBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjg5CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBzdGF0ICVzIgogbXNnc3RyICJtaXNzbHlja2FkZXMgdGEgc3RhdHVzIHDDpSAlcyIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzo5NjUKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6OTcwCiAjLCBjLWZvcm1hdAogbXNnaWQgIndyb3RlICU8UFJJdTMyPiBvYmplY3RzIHdoaWxlIGV4cGVjdGluZyAlPFBSSXUzMj4iCiBtc2dzdHIgInNrcmV2ICU8UFJJdTMyPiBvYmpla3QgbWVkYW4gJTxQUkl1MzI+IGbDtnJ2w6RudGFkZXMiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MTE2MQorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoxMTY0CiBtc2dpZCAiZGlzYWJsaW5nIGJpdG1hcCB3cml0aW5nLCBhcyBzb21lIG9iamVjdHMgYXJlIG5vdCBiZWluZyBwYWNrZWQiCiBtc2dzdHIgImluYWt0aXZlcmFyIHNrcml2bmluZyBhdiBiaXRrYXJ0YSBkw6UgbsOlZ3JhIG9iamVrdCBpbnRlIHBhY2thcyIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoxNTkxCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjE1OTIKICMsIGMtZm9ybWF0CiBtc2dpZCAiZGVsdGEgYmFzZSBvZmZzZXQgb3ZlcmZsb3cgaW4gcGFjayBmb3IgJXMiCiBtc2dzdHIgImRlbHRhYmFzb2Zmc2V0IHV0YW5mw7ZyIGdyw6Ruc2VuIGkgcGFjayBmw7ZyICVzIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjE2MDAKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MTYwMQogIywgYy1mb3JtYXQKIG1zZ2lkICJkZWx0YSBiYXNlIG9mZnNldCBvdXQgb2YgYm91bmQgZm9yICVzIgogbXNnc3RyICJkZWx0YWJhc29mZnNldCB1dGFuZsO2ciBncsOkbnN2w6RyZGVuIGbDtnIgJXMiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MTg2OQorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoxODcwCiBtc2dpZCAiQ291bnRpbmcgb2JqZWN0cyIKIG1zZ3N0ciAiUsOka25hciBvYmpla3QiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MTk5OQorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyMDAwCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBnZXQgc2l6ZSBvZiAlcyIKIG1zZ3N0ciAia2FuIGludGUgaMOkbXRhIHN0b3JsZWsgcMOlICVzIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjIwMTQKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjAxNQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gcGFyc2Ugb2JqZWN0IGhlYWRlciBvZiAlcyIKIG1zZ3N0ciAia3VuZGUgaW50ZSB0b2xrYSBvYmpla3RodXZ1ZCBmw7ZyICVzIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjIwODQgYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyMTAwCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjIxMTAKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjA4NSBidWlsdGluL3BhY2stb2JqZWN0cy5jOjIxMDEKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjExMQogIywgYy1mb3JtYXQKIG1zZ2lkICJvYmplY3QgJXMgY2Fubm90IGJlIHJlYWQiCiBtc2dzdHIgIm9iamVrdGV0ICVzIGt1bmRlIGludGUgbMOkc2FzIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjIwODcgYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyMTE0CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjIwODggYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyMTE1CiAjLCBjLWZvcm1hdAogbXNnaWQgIm9iamVjdCAlcyBpbmNvbnNpc3RlbnQgb2JqZWN0IGxlbmd0aCAoJTxQUkl1TUFYPiB2cyAlPFBSSXVNQVg+KSIKIG1zZ3N0ciAib2JqZWt0ZXQgJXMgaGFyIGlua29uc2lzdGVudCBvYmpla3Rsw6RuZ2QgKCU8UFJJdU1BWD4gbW90ICU8UFJJdU1BWD4pIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjIxMjQKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjEyNQogbXNnaWQgInN1Ym9wdGltYWwgcGFjayAtIG91dCBvZiBtZW1vcnkiCiBtc2dzdHIgImlja2Utb3B0aW1hbHQgcGFjayAtIG1pbm5ldCBzbHV0IgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI0NTAKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjQ0MAogIywgYy1mb3JtYXQKIG1zZ2lkICJEZWx0YSBjb21wcmVzc2lvbiB1c2luZyB1cCB0byAlZCB0aHJlYWRzIgogbXNnc3RyICJEZWx0YWtvbXByaW1lcmluZyBhbnbDpG5kZXIgdXBwIHRpbGwgJWQgdHLDpWRhciIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNTgyCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI1NzIKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHBhY2sgb2JqZWN0cyByZWFjaGFibGUgZnJvbSB0YWcgJXMiCiBtc2dzdHIgImthbiBpbnRlIHBhY2thIG9iamVrdCBuw6ViYXJhIGZyw6VuIHRhZ2dlbiAlcyIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNjY5CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI2NTkKIG1zZ2lkICJDb21wcmVzc2luZyBvYmplY3RzIgogbXNnc3RyICJLb21wcmltZXJhciBvYmpla3QiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjY3NQorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNjY1CiBtc2dpZCAiaW5jb25zaXN0ZW5jeSB3aXRoIGRlbHRhIGNvdW50IgogbXNnc3RyICJkZWx0YXLDpGtuYXJlbiDDpHIgaW5rb25zZWt2ZW50IgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI3NTYKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6Mjc0MgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiZXhwZWN0ZWQgZWRnZSBvYmplY3QgSUQsIGdvdCBnYXJiYWdlOlxuIgpAQCAtMTYxMDMsNyArMTYxNTgsNyBAQAogImbDtnJ2w6RudGFkZSBrYW50LW9iamVrdC1pZCwgZmljayBza3LDpHA6XG4iCiAiICVzIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI3NjIKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6Mjc0OAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiZXhwZWN0ZWQgb2JqZWN0IElELCBnb3QgZ2FyYmFnZTpcbiIKQEAgLTE2MTEyLDIzOSArMTYxNjcsMjQzIEBACiAiZsO2cnbDpG50YWRlIG9iamVrdC1pZCwgZmljayBza3LDpHA6XG4iCiAiICVzIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI4NjAKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6Mjg0NgogbXNnaWQgImludmFsaWQgdmFsdWUgZm9yIC0tbWlzc2luZyIKIG1zZ3N0ciAib2dpbHRpZ3QgdsOkcmRlIGbDtnIgLS1taXNzaW5nIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI5MTkgYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMDI3CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI5MDUgYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMDEzCiBtc2dpZCAiY2Fubm90IG9wZW4gcGFjayBpbmRleCIKIG1zZ3N0ciAia2FuIGludGUgw7ZwcG5hIHBha2V0ZmlsZW4iCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6Mjk1MAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyOTM2CiAjLCBjLWZvcm1hdAogbXNnaWQgImxvb3NlIG9iamVjdCBhdCAlcyBjb3VsZCBub3QgYmUgZXhhbWluZWQiCiBtc2dzdHIgImzDtnNhIG9iamVrdCBww6UgJXMga3VuZGUgaW50ZSB1bmRlcsO2a2FzIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMwMzUKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzAyMQogbXNnaWQgInVuYWJsZSB0byBmb3JjZSBsb29zZSBvYmplY3QiCiBtc2dzdHIgImthbiBpbnRlIHR2aW5nYSBsw7ZzYSBvYmpla3QiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzEyNworIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMTEzCiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vdCBhIHJldiAnJXMnIgogbXNnc3RyICJpbnRlIGVuIHJlZmVyZW5zIFwiJXNcIiIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMTMwCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMxMTYKICMsIGMtZm9ybWF0CiBtc2dpZCAiYmFkIHJldmlzaW9uICclcyciCiBtc2dzdHIgImZlbGFrdGlnIHJldmlzaW9uIFwiJXNcIiIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMTU1CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMxNDEKIG1zZ2lkICJ1bmFibGUgdG8gYWRkIHJlY2VudCBvYmplY3RzIgogbXNnc3RyICJrYW4gaW50ZSBsw6RnZ2EgdGlsbCBueWEgb2JqZWt0IgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyMDgKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzE5NAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bnN1cHBvcnRlZCBpbmRleCB2ZXJzaW9uICVzIgogbXNnc3RyICJpbmRleHZlcnNpb25lbiAlcyBzdMO2ZHMgZWoiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzIxMgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMTk4CiAjLCBjLWZvcm1hdAogbXNnaWQgImJhZCBpbmRleCB2ZXJzaW9uICclcyciCiBtc2dzdHIgImZlbGFrdGlnIGluZGV4dmVyc2lvbiBcIiVzXCIiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI0MgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjI4CiBtc2dpZCAiZG8gbm90IHNob3cgcHJvZ3Jlc3MgbWV0ZXIiCiBtc2dzdHIgInZpc2EgaW50ZSBmw7ZybG9wcHNpbmRpa2F0b3IiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI0NAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjMwCiBtc2dpZCAic2hvdyBwcm9ncmVzcyBtZXRlciIKIG1zZ3N0ciAidmlzYSBmw7ZybG9wcHNpbmRpa2F0b3IiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI0NgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjMyCiBtc2dpZCAic2hvdyBwcm9ncmVzcyBtZXRlciBkdXJpbmcgb2JqZWN0IHdyaXRpbmcgcGhhc2UiCiBtc2dzdHIgInZpc2EgZsO2cmxvcHBzaW5kaWthdG9yIHVuZGVyIG9iamVrdHNrcml2bmluZ3NmYXNlbiIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjQ5CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyMzUKIG1zZ2lkICJzaW1pbGFyIHRvIC0tYWxsLXByb2dyZXNzIHdoZW4gcHJvZ3Jlc3MgbWV0ZXIgaXMgc2hvd24iCiBtc2dzdHIgInNvbSAtLWFsbC1wcm9ncmVzcyBuw6RyIGbDtnJsb3Bwc2luZGlrYXRvcm4gdmlzYXMiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI1MAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjM2CiBtc2dpZCAiPHZlcnNpb24+Wyw8b2Zmc2V0Pl0iCiBtc2dzdHIgIjx2ZXJzaW9uPlssPG9mZnNldD5dIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNTEKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzIzNwogbXNnaWQgIndyaXRlIHRoZSBwYWNrIGluZGV4IGZpbGUgaW4gdGhlIHNwZWNpZmllZCBpZHggZm9ybWF0IHZlcnNpb24iCiBtc2dzdHIgInNrcml2IHBha2V0aW5kZXhmaWxlbiBpIGFuZ2l2ZW4gaW5kZXhmb3JtYXR2ZXJzaW9uIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNTQKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI0MAogbXNnaWQgIm1heGltdW0gc2l6ZSBvZiBlYWNoIG91dHB1dCBwYWNrIGZpbGUiCiBtc2dzdHIgIm1heGltYWwgc3RvcmxlayBww6UgdmFyamUgdXRkYXRhcGFrZXRmaWwiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI1NgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjQyCiBtc2dpZCAiaWdub3JlIGJvcnJvd2VkIG9iamVjdHMgZnJvbSBhbHRlcm5hdGUgb2JqZWN0IHN0b3JlIgogbXNnc3RyICJpZ25vcmVyYSBsw6VuYWRlIG9iamVrdCBmcsOlbiBhbHRlcm5hdGl2YSBvYmpla3RsYWdlciIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjU4CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNDQKIG1zZ2lkICJpZ25vcmUgcGFja2VkIG9iamVjdHMiCiBtc2dzdHIgImlnbm9yZXJhIHBhY2thZGUgb2JqZWt0IgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNjAKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI0NgogbXNnaWQgImxpbWl0IHBhY2sgd2luZG93IGJ5IG9iamVjdHMiCiBtc2dzdHIgImJlZ3LDpG5zYSBwYWtldGbDtm5zdGVyIGVmdGVyIG9iamVrdCIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjYyCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNDgKIG1zZ2lkICJsaW1pdCBwYWNrIHdpbmRvdyBieSBtZW1vcnkgaW4gYWRkaXRpb24gdG8gb2JqZWN0IGxpbWl0IgogbXNnc3RyICJiZWdyw6Ruc2EgcGFrZXRmw7Zuc3RlciBlZnRlciBtaW5uZSBmw7ZydXRvbSBvYmpla3RncsOkbnMiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI2NAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjUwCiBtc2dpZCAibWF4aW11bSBsZW5ndGggb2YgZGVsdGEgY2hhaW4gYWxsb3dlZCBpbiB0aGUgcmVzdWx0aW5nIHBhY2siCiBtc2dzdHIgIm1heGltYWwgbMOkbmdkIHDDpSBkZWx0YWtlZGphIHRpbGzDpXRlbiBpIHNsdXRsaWd0IHBha2V0IgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNjYKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI1MgogbXNnaWQgInJldXNlIGV4aXN0aW5nIGRlbHRhcyIKIG1zZ3N0ciAiw6V0ZXJhbnbDpG5kIGJlZmludGxpZ2EgZGVsdGEiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI2OAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjU0CiBtc2dpZCAicmV1c2UgZXhpc3Rpbmcgb2JqZWN0cyIKIG1zZ3N0ciAiw6V0ZXJhbnbDpG5kIGJlZmludGxpZ2Egb2JqZWt0IgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNzAKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI1NgogbXNnaWQgInVzZSBPRlNfREVMVEEgb2JqZWN0cyIKIG1zZ3N0ciAiYW52w6RuZCBPRlNfREVMVEEtb2JqZWt0IgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNzIKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI1OAogbXNnaWQgInVzZSB0aHJlYWRzIHdoZW4gc2VhcmNoaW5nIGZvciBiZXN0IGRlbHRhIG1hdGNoZXMiCiBtc2dzdHIgImFudsOkbmQgdHLDpWRhciB2aWQgc8O2a25pbmcgZWZ0ZXIgYsOkc3RhIGRlbHRhdHLDpGZmYXIiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI3NAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjYwCiBtc2dpZCAiZG8gbm90IGNyZWF0ZSBhbiBlbXB0eSBwYWNrIG91dHB1dCIKIG1zZ3N0ciAiZsO2cnPDtmsgaW50ZSBza2FwYSB0b20gcGFrZXR1dGRhdGEiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI3NgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjYyCiBtc2dpZCAicmVhZCByZXZpc2lvbiBhcmd1bWVudHMgZnJvbSBzdGFuZGFyZCBpbnB1dCIKIG1zZ3N0ciAibMOkcyByZXZpc2lvbnNhcmd1bWVudCBmcsOlbiBzdGFuZGFyZCBpbiIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjc4CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNjQKIG1zZ2lkICJsaW1pdCB0aGUgb2JqZWN0cyB0byB0aG9zZSB0aGF0IGFyZSBub3QgeWV0IHBhY2tlZCIKIG1zZ3N0ciAiYmVncsOkbnNhIG9iamVrdCB0aWxsIGRlbSBzb20gw6RubnUgaW50ZSBwYWNrYXRzIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyODEKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI2NwogbXNnaWQgImluY2x1ZGUgb2JqZWN0cyByZWFjaGFibGUgZnJvbSBhbnkgcmVmZXJlbmNlIgogbXNnc3RyICJpbmtsdWRlcmEgb2JqZWt0IHNvbSBrYW4gbsOlcyBmcsOlbiBuw6Vnb24gcmVmZXJlbnMiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI4NAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjcwCiBtc2dpZCAiaW5jbHVkZSBvYmplY3RzIHJlZmVycmVkIGJ5IHJlZmxvZyBlbnRyaWVzIgogbXNnc3RyICJpbmtsdWRlcmEgb2JqZWt0IHNvbSByZWZlcmVyYXMgZnLDpW4gcmVmZXJlbnNsb2dncG9zdGVyIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyODcKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI3MwogbXNnaWQgImluY2x1ZGUgb2JqZWN0cyByZWZlcnJlZCB0byBieSB0aGUgaW5kZXgiCiBtc2dzdHIgImlua2x1ZGVyYSBvYmpla3Qgc29tIHJlZmVyZXJhcyBmcsOlbiBpbmRleGV0IgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyOTAKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI3NgogbXNnaWQgIm91dHB1dCBwYWNrIHRvIHN0ZG91dCIKIG1zZ3N0ciAic2tyaXYgcGFrZXQgcMOlIHN0YW5kYXJkIHV0IgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyOTIKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI3OAogbXNnaWQgImluY2x1ZGUgdGFnIG9iamVjdHMgdGhhdCByZWZlciB0byBvYmplY3RzIHRvIGJlIHBhY2tlZCIKIG1zZ3N0ciAiaW5rbHVkZXJhIHRhZ2dvYmpla3Qgc29tIHJlZmVyZXJhciBvYmpla3Qgc29tIHNrYWxsIHBhY2thcyIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjk0CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyODAKIG1zZ2lkICJrZWVwIHVucmVhY2hhYmxlIG9iamVjdHMiCiBtc2dzdHIgImJlaMOlbGwgb27DpWJhcmEgb2JqZWt0IgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyOTYKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI4MgogbXNnaWQgInBhY2sgbG9vc2UgdW5yZWFjaGFibGUgb2JqZWN0cyIKIG1zZ3N0ciAicGFja2EgbMO2c2Egb27DpWJhcmEgb2JqZWt0IgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyOTgKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI4NAogbXNnaWQgInVucGFjayB1bnJlYWNoYWJsZSBvYmplY3RzIG5ld2VyIHRoYW4gPHRpbWU+IgogbXNnc3RyICJwYWNrYSB1cHAgb27DpWJhcmEgb2JqZWt0IG55YXJlIMOkbiA8dGlkPiIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzAxCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyODcKIG1zZ2lkICJ1c2UgdGhlIHNwYXJzZSByZWFjaGFiaWxpdHkgYWxnb3JpdGhtIgogbXNnc3RyICJhbnbDpG5kIGdsZXMtbsOlYmFyaGV0c2FsZ29yaXRtZW4iCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMwMworIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjg5CiBtc2dpZCAiY3JlYXRlIHRoaW4gcGFja3MiCiBtc2dzdHIgInNrYXBhIHR1bm5hIHBha2V0IgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMDUKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI5MQogbXNnaWQgImNyZWF0ZSBwYWNrcyBzdWl0YWJsZSBmb3Igc2hhbGxvdyBmZXRjaGVzIgogbXNnc3RyICJza2FwYSBwYWNrZmlsZXIgbMOkbXBhZGUgZsO2ciBncnVuZGEgaMOkbXRuaW5nYXIiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMwNworIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjkzCiBtc2dpZCAiaWdub3JlIHBhY2tzIHRoYXQgaGF2ZSBjb21wYW5pb24gLmtlZXAgZmlsZSIKIG1zZ3N0ciAiaWdub3JlcmEgcGFrZXQgc29tIGhhciB0aWxsaMO2cmFuZGUgLmtlZXAtZmlsIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMDkKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI5NQogbXNnaWQgImlnbm9yZSB0aGlzIHBhY2siCiBtc2dzdHIgImlnbm9yZXJhIGRldHRhIHBha2V0IgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMTEKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI5NwogbXNnaWQgInBhY2sgY29tcHJlc3Npb24gbGV2ZWwiCiBtc2dzdHIgImtvbXByaW1lcmluZ3NncmFkIGbDtnIgcGFrZXQiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMxMworIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjk5CiBtc2dpZCAiZG8gbm90IGhpZGUgY29tbWl0cyBieSBncmFmdHMiCiBtc2dzdHIgImfDtm0gaW50ZSBpbmNoZWNrbmluZ2FyIG1lZCB5bXBuaW5nYXIgKFwiZ3JhZnRzXCIpIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMTUKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMwMQogbXNnaWQgInVzZSBhIGJpdG1hcCBpbmRleCBpZiBhdmFpbGFibGUgdG8gc3BlZWQgdXAgY291bnRpbmcgb2JqZWN0cyIKIG1zZ3N0ciAiYW52w6RuZCBiaXRrYXJ0aW5kZXggb20gdGlsbGfDpG5nbGlndCBmw7ZyIGF0dCByw6RrbmEgb2JqZWt0IHNuYWJiYXJlIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMTcKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMwMwogbXNnaWQgIndyaXRlIGEgYml0bWFwIGluZGV4IHRvZ2V0aGVyIHdpdGggdGhlIHBhY2sgaW5kZXgiCiBtc2dzdHIgImFudsOkbmQgYml0a2FydGluZGV4IHRpbGxzYW1tYW5zIG1lZCBwYWNraW5kZXhldCIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzIwCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMDcKK21zZ2lkICJ3cml0ZSBhIGJpdG1hcCBpbmRleCBpZiBwb3NzaWJsZSIKK21zZ3N0ciAic2tyaXYgYml0a2FydGluZGV4IG9tIG3DtmpsaWd0IgorCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMTEKIG1zZ2lkICJoYW5kbGluZyBmb3IgbWlzc2luZyBvYmplY3RzIgogbXNnc3RyICJoYW50ZXJpbmcgYXYgc2FrbmFkZSBvYmpla3QiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMyMworIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzE0CiBtc2dpZCAiZG8gbm90IHBhY2sgb2JqZWN0cyBpbiBwcm9taXNvciBwYWNrZmlsZXMiCiBtc2dzdHIgInBhY2thIGludGUgb2JqZWt0IGkga29udHJha3RzcGFja2ZpbGVyIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMjUKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMxNgogbXNnaWQgInJlc3BlY3QgaXNsYW5kcyBkdXJpbmcgZGVsdGEgY29tcHJlc3Npb24iCiBtc2dzdHIgInJlc3Bla3RlcmEgw7ZhciB1bmRlciBkZWx0YWtvbXByaW1lcmluZyIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzUwCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzNDUKICMsIGMtZm9ybWF0CiBtc2dpZCAiZGVsdGEgY2hhaW4gZGVwdGggJWQgaXMgdG9vIGRlZXAsIGZvcmNpbmcgJWQiCiBtc2dzdHIgImRlbHRha2VkamVkanVwZXQgJWQgw6RyIGbDtnIgZGp1cHQsIHDDpXR2aW5nYXIgJWQiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzM1NQorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzUwCiAjLCBjLWZvcm1hdAogbXNnaWQgInBhY2suZGVsdGFDYWNoZUxpbWl0IGlzIHRvbyBoaWdoLCBmb3JjaW5nICVkIgogbXNnc3RyICJwYWNrLmRlbHRhQ2FjaGVMaW1pdCDDpHIgZsO2ciBow7ZndCwgcMOldHZpbmdhciAlZCIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozNDA5CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjM0MDQKIG1zZ2lkICItLW1heC1wYWNrLXNpemUgY2Fubm90IGJlIHVzZWQgdG8gYnVpbGQgYSBwYWNrIGZvciB0cmFuc2ZlciIKIG1zZ3N0ciAiIgogIi0tbWF4LXBhY2stc2l6ZSBrYW4gaW50ZSBhbnbDpG5kYXMgZsO2ciBhdHQgYnlnZ2EgZXR0IHBha2V0IHNvbSBza2FsbCDDtnZlcmbDtnJhcyIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozNDExCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjM0MDYKIG1zZ2lkICJtaW5pbXVtIHBhY2sgc2l6ZSBsaW1pdCBpcyAxIE1pQiIKIG1zZ3N0ciAibWluc3RhIHBhY2tzdG9ybGVrIMOkciAxIE1pQiIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozNDE2CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjM0MTEKIG1zZ2lkICItLXRoaW4gY2Fubm90IGJlIHVzZWQgdG8gYnVpbGQgYW4gaW5kZXhhYmxlIHBhY2siCiBtc2dzdHIgIi0tdGhpbiBrYW4gaW50ZSBhbnbDpG5kYXMgZsO2ciBhdHQgYnlnZ2EgZXR0IGluZGV4ZXJiYXJ0IHBha2V0IgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjM0MTkKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzQxNAogbXNnaWQgIi0ta2VlcC11bnJlYWNoYWJsZSBhbmQgLS11bnBhY2stdW5yZWFjaGFibGUgYXJlIGluY29tcGF0aWJsZSIKIG1zZ3N0ciAiLS1rZWVwLXVucmVhY2hhYmxlIG9jaCAtdW5wYWNrLXVucmVhY2hhYmxlIGthbiBpbnRlIGFudsOkbmRhcyBzYW10aWRpZ3QiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzQyNQorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozNDIwCiBtc2dpZCAiY2Fubm90IHVzZSAtLWZpbHRlciB3aXRob3V0IC0tc3Rkb3V0IgogbXNnc3RyICJrYW4gaW50ZSBhbnbDpG5kYSAtLWZpbHRlciB1dGFuIC0tc3Rkb3V0IgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjM0ODYKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzQ4MQogbXNnaWQgIkVudW1lcmF0aW5nIG9iamVjdHMiCiBtc2dzdHIgIlLDpGtuYXIgdXBwIG9iamVrdCIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozNTE2CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjM1MTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiVG90YWwgJTxQUkl1MzI+IChkZWx0YSAlPFBSSXUzMj4pLCByZXVzZWQgJTxQUkl1MzI+IChkZWx0YSAlPFBSSXUzMj4pIgogbXNnc3RyICIiCkBAIC0xNjM5OSw0NCArMTY0NTgsNDQgQEAKIG1zZ2lkICJnaXQgcHVsbCBbPG9wdGlvbnM+XSBbPHJlcG9zaXRvcnk+IFs8cmVmc3BlYz4uLi5dXSIKIG1zZ3N0ciAiZ2l0IHB1bGwgWzxmbGFnZ29yPl0gWzxhcmtpdj4gWzxyZWZzcGVjPi4uLl1dIgogCi0jOiBidWlsdGluL3B1bGwuYzoxNDEKKyM6IGJ1aWx0aW4vcHVsbC5jOjE0MgogbXNnaWQgImNvbnRyb2wgZm9yIHJlY3Vyc2l2ZSBmZXRjaGluZyBvZiBzdWJtb2R1bGVzIgogbXNnc3RyICJzdHlybmluZyBmw7ZyIHJla3Vyc2l2IGjDpG10bmluZyBhdiB1bmRlcm1vZHVsZXIiCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjE0NQorIzogYnVpbHRpbi9wdWxsLmM6MTQ2CiBtc2dpZCAiT3B0aW9ucyByZWxhdGVkIHRvIG1lcmdpbmciCiBtc2dzdHIgIkFsdGVybmF0aXYgZ8OkbGxhbmRlIHNhbW1hbnNsYWduaW5nIgogCi0jOiBidWlsdGluL3B1bGwuYzoxNDgKKyM6IGJ1aWx0aW4vcHVsbC5jOjE0OQogbXNnaWQgImluY29ycG9yYXRlIGNoYW5nZXMgYnkgcmViYXNpbmcgcmF0aGVyIHRoYW4gbWVyZ2luZyIKIG1zZ3N0ciAiaW5sZW1tYSDDpG5kcmluZ2FyIGdlbm9tIG9tYmFzZXJpbmcgaSBzdMOkbGxldCBmw7ZyIHNhbW1hbnNsYWduaW5nIgogCi0jOiBidWlsdGluL3B1bGwuYzoxNzYgYnVpbHRpbi9yZWJhc2UuYzo0NDcgYnVpbHRpbi9yZXZlcnQuYzoxMjYKKyM6IGJ1aWx0aW4vcHVsbC5jOjE3NyBidWlsdGluL3JlYmFzZS5jOjQ0OCBidWlsdGluL3JldmVydC5jOjEyNgogbXNnaWQgImFsbG93IGZhc3QtZm9yd2FyZCIKIG1zZ3N0ciAidGlsbMOldCBzbmFiYnNwb2xuaW5nIgogCi0jOiBidWlsdGluL3B1bGwuYzoxODUKKyM6IGJ1aWx0aW4vcHVsbC5jOjE4NgogbXNnaWQgImF1dG9tYXRpY2FsbHkgc3Rhc2gvc3Rhc2ggcG9wIGJlZm9yZSBhbmQgYWZ0ZXIgcmViYXNlIgogbXNnc3RyICJ1dGbDtnIgYXV0b21hdGlza3Qgc3Rhc2gvc3Rhc2ggcG9wIGbDtnJlIG9jaCBlZnRlciBvbWJhc2VyaW5nIgogCi0jOiBidWlsdGluL3B1bGwuYzoyMDEKKyM6IGJ1aWx0aW4vcHVsbC5jOjIwMgogbXNnaWQgIk9wdGlvbnMgcmVsYXRlZCB0byBmZXRjaGluZyIKIG1zZ3N0ciAiQWx0ZXJuYXRpdiBnw6RsbGFuZGUgaMOkbXRuaW5nYXIiCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjIxMQorIzogYnVpbHRpbi9wdWxsLmM6MjEyCiBtc2dpZCAiZm9yY2Ugb3ZlcndyaXRlIG9mIGxvY2FsIGJyYW5jaCIKIG1zZ3N0ciAidHZpbmdhIMO2dmVyc2tyaXZuaW5nIGF2IGxva2FsIGdyZW4iCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjIxOQorIzogYnVpbHRpbi9wdWxsLmM6MjIwCiBtc2dpZCAibnVtYmVyIG9mIHN1Ym1vZHVsZXMgcHVsbGVkIGluIHBhcmFsbGVsIgogbXNnc3RyICJhbnRhbCB1bmRlcm1vZHVsZXIgc29tIGjDpG10YXMgcGFyYWxsZWxsdCIKIAotIzogYnVpbHRpbi9wdWxsLmM6MzE2CisjOiBidWlsdGluL3B1bGwuYzozMjAKICMsIGMtZm9ybWF0CiBtc2dpZCAiSW52YWxpZCB2YWx1ZSBmb3IgcHVsbC5mZjogJXMiCiBtc2dzdHIgIkZlbGFrdGlndCB2w6RyZGUgZsO2ciBwdWxsLmZmOiAlcyIKIAotIzogYnVpbHRpbi9wdWxsLmM6NDMzCisjOiBidWlsdGluL3B1bGwuYzo0MzcKIG1zZ2lkICIiCiAiVGhlcmUgaXMgbm8gY2FuZGlkYXRlIGZvciByZWJhc2luZyBhZ2FpbnN0IGFtb25nIHRoZSByZWZzIHRoYXQgeW91IGp1c3QgIgogImZldGNoZWQuIgpAQCAtMTY0NDQsMTQgKzE2NTAzLDE0IEBACiAiRGV0IGZpbm5zIGluZ2VuIGthbmRpZGF0IGbDtnIgb21iYXNlcmluZyBibGFuZCByZWZlcmVuc2VybmEgZHUgcHJlY2lzIGhhciAiCiAiaMOkbXRhdC4iCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjQzNQorIzogYnVpbHRpbi9wdWxsLmM6NDM5CiBtc2dpZCAiIgogIlRoZXJlIGFyZSBubyBjYW5kaWRhdGVzIGZvciBtZXJnaW5nIGFtb25nIHRoZSByZWZzIHRoYXQgeW91IGp1c3QgZmV0Y2hlZC4iCiBtc2dzdHIgIiIKICJEZXQgZmlubnMgaW5nZW4ga2FuZGlkYXQgZsO2ciBzYW1tYW5zbGFnbmluZyBibGFuZCByZWZlcmVuc2VybmEgZHUgcHJlY2lzIGhhciAiCiAiaMOkbXRhdC4iCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjQzNgorIzogYnVpbHRpbi9wdWxsLmM6NDQwCiBtc2dpZCAiIgogIkdlbmVyYWxseSB0aGlzIG1lYW5zIHRoYXQgeW91IHByb3ZpZGVkIGEgd2lsZGNhcmQgcmVmc3BlYyB3aGljaCBoYWQgbm9cbiIKICJtYXRjaGVzIG9uIHRoZSByZW1vdGUgZW5kLiIKQEAgLTE2NDU5LDcgKzE2NTE4LDcgQEAKICJEZXQgYmV0eWRlciB2YW5saWd0dmlzIGF0dCBkdSBhbnbDpG50IGVuIGpva2VydGVja2VuLXJlZnNwZWMgc29tIGludGVcbiIKICJtb3RzdmFyYWRlIG7DpWdvdCBpIGZqw6RycsOkbmRlbi4iCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjQzOQorIzogYnVpbHRpbi9wdWxsLmM6NDQzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJZb3UgYXNrZWQgdG8gcHVsbCBmcm9tIHRoZSByZW1vdGUgJyVzJywgYnV0IGRpZCBub3Qgc3BlY2lmeVxuIgpAQCAtMTY0NzAsNDIgKzE2NTI5LDQyIEBACiAiZ3Jlbi4gRWZ0ZXJzb20gZGV0IGludGUgw6RyIGRlbiBmasOkcnIgc29tIMOkciBrb25maWd1cmVyYWQgc29tXG4iCiAic3RhbmRhcmQgZsO2ciBha3R1ZWxsIGdyZW4gbcOlc3RlIGR1IGFuZ2UgZW4gZ3JlbiBww6Uga29tbWFuZG9yYWRlbi4iCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjQ0NCBidWlsdGluL3JlYmFzZS5jOjEzMjYgZ2l0LXBhcnNlLXJlbW90ZS5zaDo3MworIzogYnVpbHRpbi9wdWxsLmM6NDQ4IGJ1aWx0aW4vcmViYXNlLmM6MTM0NyBnaXQtcGFyc2UtcmVtb3RlLnNoOjczCiBtc2dpZCAiWW91IGFyZSBub3QgY3VycmVudGx5IG9uIGEgYnJhbmNoLiIKIG1zZ3N0ciAiRHUgw6RyIGludGUgcMOlIG7DpWdvbiBncmVuIGbDtnIgbsOkcnZhcmFuZGUuIgogCi0jOiBidWlsdGluL3B1bGwuYzo0NDYgYnVpbHRpbi9wdWxsLmM6NDYxIGdpdC1wYXJzZS1yZW1vdGUuc2g6NzkKKyM6IGJ1aWx0aW4vcHVsbC5jOjQ1MCBidWlsdGluL3B1bGwuYzo0NjUgZ2l0LXBhcnNlLXJlbW90ZS5zaDo3OQogbXNnaWQgIlBsZWFzZSBzcGVjaWZ5IHdoaWNoIGJyYW5jaCB5b3Ugd2FudCB0byByZWJhc2UgYWdhaW5zdC4iCiBtc2dzdHIgIkFuZ2Ugdmlsa2VuIGdyZW4gZHUgdmlsbCBvbWJhc2VyYSBtb3QuIgogCi0jOiBidWlsdGluL3B1bGwuYzo0NDggYnVpbHRpbi9wdWxsLmM6NDYzIGdpdC1wYXJzZS1yZW1vdGUuc2g6ODIKKyM6IGJ1aWx0aW4vcHVsbC5jOjQ1MiBidWlsdGluL3B1bGwuYzo0NjcgZ2l0LXBhcnNlLXJlbW90ZS5zaDo4MgogbXNnaWQgIlBsZWFzZSBzcGVjaWZ5IHdoaWNoIGJyYW5jaCB5b3Ugd2FudCB0byBtZXJnZSB3aXRoLiIKIG1zZ3N0ciAiQW5nZSB2aWxrZW4gZ3JlbiBkdSB2aWxsIHNsw6Ugc2FtbWFuIG1lZC4iCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjQ0OSBidWlsdGluL3B1bGwuYzo0NjQKKyM6IGJ1aWx0aW4vcHVsbC5jOjQ1MyBidWlsdGluL3B1bGwuYzo0NjgKIG1zZ2lkICJTZWUgZ2l0LXB1bGwoMSkgZm9yIGRldGFpbHMuIgogbXNnc3RyICJTZSBnaXQtcHVsbCgxKSBmw7ZyIGRldGFsamVyLiIKIAotIzogYnVpbHRpbi9wdWxsLmM6NDUxIGJ1aWx0aW4vcHVsbC5jOjQ1NyBidWlsdGluL3B1bGwuYzo0NjYKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTMzMiBnaXQtcGFyc2UtcmVtb3RlLnNoOjY0CisjOiBidWlsdGluL3B1bGwuYzo0NTUgYnVpbHRpbi9wdWxsLmM6NDYxIGJ1aWx0aW4vcHVsbC5jOjQ3MAorIzogYnVpbHRpbi9yZWJhc2UuYzoxMzUzIGdpdC1wYXJzZS1yZW1vdGUuc2g6NjQKIG1zZ2lkICI8cmVtb3RlPiIKIG1zZ3N0ciAiPGZqw6Rycj4iCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjQ1MSBidWlsdGluL3B1bGwuYzo0NjYgYnVpbHRpbi9wdWxsLmM6NDcxCisjOiBidWlsdGluL3B1bGwuYzo0NTUgYnVpbHRpbi9wdWxsLmM6NDcwIGJ1aWx0aW4vcHVsbC5jOjQ3NQogIzogZ2l0LXBhcnNlLXJlbW90ZS5zaDo2NQogbXNnaWQgIjxicmFuY2g+IgogbXNnc3RyICI8Z3Jlbj4iCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjQ1OSBidWlsdGluL3JlYmFzZS5jOjEzMjQgZ2l0LXBhcnNlLXJlbW90ZS5zaDo3NQorIzogYnVpbHRpbi9wdWxsLmM6NDYzIGJ1aWx0aW4vcmViYXNlLmM6MTM0NSBnaXQtcGFyc2UtcmVtb3RlLnNoOjc1CiBtc2dpZCAiVGhlcmUgaXMgbm8gdHJhY2tpbmcgaW5mb3JtYXRpb24gZm9yIHRoZSBjdXJyZW50IGJyYW5jaC4iCiBtc2dzdHIgIkRldCBmaW5ucyBpbmdlbiBzcMOlcm5pbmdzaW5mb3JtYXRpb24gZsO2ciBha3R1ZWxsIGdyZW4uIgogCi0jOiBidWlsdGluL3B1bGwuYzo0NjggZ2l0LXBhcnNlLXJlbW90ZS5zaDo5NQorIzogYnVpbHRpbi9wdWxsLmM6NDcyIGdpdC1wYXJzZS1yZW1vdGUuc2g6OTUKIG1zZ2lkICIiCiAiSWYgeW91IHdpc2ggdG8gc2V0IHRyYWNraW5nIGluZm9ybWF0aW9uIGZvciB0aGlzIGJyYW5jaCB5b3UgY2FuIGRvIHNvIHdpdGg6IgogbXNnc3RyICJPbSBkdSB2aWxsIGFuZ2Ugc3DDpXJuaW5nc2luZm9ybWF0aW9uIGbDtnIgZ3JlbmVuIGthbiBkdSBnw7ZyYSBkZXQgbWVkOiIKIAotIzogYnVpbHRpbi9wdWxsLmM6NDczCisjOiBidWlsdGluL3B1bGwuYzo0NzcKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIllvdXIgY29uZmlndXJhdGlvbiBzcGVjaWZpZXMgdG8gbWVyZ2Ugd2l0aCB0aGUgcmVmICclcydcbiIKQEAgLTE2NTE0LDMyICsxNjU3MywzMiBAQAogIkRpbmEgaW5zdMOkbGxuaW5nYXIgYW5nZXIgc2FtbWFuc2xhZ25pbmcgbWVkIHJlZmVyZW5zZW4gXCIlc1wiXG4iCiAiZnLDpW4gZmrDpHJyZW4sIG1lbiBuw6Vnb24gc8OlZGFuIHJlZmVyZW5zIHRvZ3MgaW50ZSBlbW90LiIKIAotIzogYnVpbHRpbi9wdWxsLmM6NTgxCisjOiBidWlsdGluL3B1bGwuYzo1ODcKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGFjY2VzcyBjb21taXQgJXMiCiBtc2dzdHIgImt1bmRlIGludGUga29tbWEgw6V0IGluY2hlY2tuaW5nZW4gJXMiCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjg2MQorIzogYnVpbHRpbi9wdWxsLmM6ODY3CiBtc2dpZCAiaWdub3JpbmcgLS12ZXJpZnktc2lnbmF0dXJlcyBmb3IgcmViYXNlIgogbXNnc3RyICJpZ25vcmVyYSAtLXZlcmlmeS1zaWduYXR1cmVzIGbDtnIgb21iYXNlcmluZyIKIAotIzogYnVpbHRpbi9wdWxsLmM6OTE2CisjOiBidWlsdGluL3B1bGwuYzo5MjIKIG1zZ2lkICItLVtuby1dYXV0b3N0YXNoIG9wdGlvbiBpcyBvbmx5IHZhbGlkIHdpdGggLS1yZWJhc2UuIgogbXNnc3RyICItLVtuby1dYXV0b3N0YXNoIMOkciBlbmRhc3QgZ2lsdGlnIG1lZCAtLXJlYmFzZS4iCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjkyNAorIzogYnVpbHRpbi9wdWxsLmM6OTMwCiBtc2dpZCAiVXBkYXRpbmcgYW4gdW5ib3JuIGJyYW5jaCB3aXRoIGNoYW5nZXMgYWRkZWQgdG8gdGhlIGluZGV4LiIKIG1zZ3N0ciAiVXBwZGF0ZXJhciBlbiBvZsO2ZGQgZ3JlbiBtZWQgw6RuZHJpbmdhciBzb20gbGFndHMgdGlsbCBpIGluZGV4ZXQuIgogCi0jOiBidWlsdGluL3B1bGwuYzo5MjgKKyM6IGJ1aWx0aW4vcHVsbC5jOjkzNAogbXNnaWQgInB1bGwgd2l0aCByZWJhc2UiCiBtc2dzdHIgInB1bGwgbWVkIG9tYmFzZXJpbmciCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjkyOQorIzogYnVpbHRpbi9wdWxsLmM6OTM1CiBtc2dpZCAicGxlYXNlIGNvbW1pdCBvciBzdGFzaCB0aGVtLiIKIG1zZ3N0ciAiY2hlY2thIGluIGVsbGVyIGFudsOkbmQgXCJzdGFzaFwiIHDDpSBkZW0uIgogCi0jOiBidWlsdGluL3B1bGwuYzo5NTQKKyM6IGJ1aWx0aW4vcHVsbC5jOjk2MAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiZmV0Y2ggdXBkYXRlZCB0aGUgY3VycmVudCBicmFuY2ggaGVhZC5cbiIKQEAgLTE2NTUwLDcgKzE2NjA5LDcgQEAKICJzbmFiYnNwb2xhciBkaW4gYXJiZXRza2F0YWxvZyBmcsOlblxuIgogImluY2hlY2tuaW5nZW4gJXMuIgogCi0jOiBidWlsdGluL3B1bGwuYzo5NjAKKyM6IGJ1aWx0aW4vcHVsbC5jOjk2NgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiQ2Fubm90IGZhc3QtZm9yd2FyZCB5b3VyIHdvcmtpbmcgdHJlZS5cbiIKQEAgLTE2NTY3LDE1ICsxNjYyNiwxNSBAQAogIiQgZ2l0IHJlc2V0IC0taGFyZFxuIgogImbDtnIgYXR0IMOldGVyZ8OlLiIKIAotIzogYnVpbHRpbi9wdWxsLmM6OTc1CisjOiBidWlsdGluL3B1bGwuYzo5ODEKIG1zZ2lkICJDYW5ub3QgbWVyZ2UgbXVsdGlwbGUgYnJhbmNoZXMgaW50byBlbXB0eSBoZWFkLiIKIG1zZ3N0ciAiS2FuIGludGUgc2zDpSBpaG9wIGZsZXJhIGdyZW5hciBpIGV0dCB0b210IGh1dnVkLiIKIAotIzogYnVpbHRpbi9wdWxsLmM6OTc5CisjOiBidWlsdGluL3B1bGwuYzo5ODUKIG1zZ2lkICJDYW5ub3QgcmViYXNlIG9udG8gbXVsdGlwbGUgYnJhbmNoZXMuIgogbXNnc3RyICJLYW4gaW50ZSBvbWJhc2VyYSBvdmFucMOlIGZsZXJhIGdyZW5hci4iCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjk4NgorIzogYnVpbHRpbi9wdWxsLmM6OTkyCiBtc2dpZCAiY2Fubm90IHJlYmFzZSB3aXRoIGxvY2FsbHkgcmVjb3JkZWQgc3VibW9kdWxlIG1vZGlmaWNhdGlvbnMiCiBtc2dzdHIgImthbiBpbnRlIG9tYmFzZXJhIG1lZCBsb2thbHQgbGFncmFkZSDDpG5kcmluZ2FyIGkgdW5kZXJtb2Z1bCIKIApAQCAtMTY3MzQsMTcgKzE2NzkzLDk0IEBACiBtc2dpZCAiUHVzaGluZyB0byAlc1xuIgogbXNnc3RyICJTw6RuZGVyIHRpbGwgJXNcbiIKIAotIzogYnVpbHRpbi9wdXNoLmM6MzY0CisjOiBidWlsdGluL3B1c2guYzozNjYKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIHB1c2ggc29tZSByZWZzIHRvICclcyciCiBtc2dzdHIgIm1pc3NseWNrYWRlcyBzw6RuZGEgdmlzc2EgcmVmZXJlbnNlciB0aWxsIFwiJXNcIiIKIAotIzogYnVpbHRpbi9wdXNoLmM6Mzk4CisjOiBidWlsdGluL3B1c2guYzo1NDEKK21zZ2lkICJyZXBvc2l0b3J5IgorbXNnc3RyICJhcmtpdiIKKworIzogYnVpbHRpbi9wdXNoLmM6NTQyIGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTY0Cittc2dpZCAicHVzaCBhbGwgcmVmcyIKK21zZ3N0ciAic8OkbmQgYWxsYSByZWZlcmVuc2VyIgorCisjOiBidWlsdGluL3B1c2guYzo1NDMgYnVpbHRpbi9zZW5kLXBhY2suYzoxNjYKK21zZ2lkICJtaXJyb3IgYWxsIHJlZnMiCittc2dzdHIgInNwZWdsYSBhbGxhIHJlZmVyZW5zZXIiCisKKyM6IGJ1aWx0aW4vcHVzaC5jOjU0NQorbXNnaWQgImRlbGV0ZSByZWZzIgorbXNnc3RyICJ0YSBib3J0IHJlZmVyZW5zZXIiCisKKyM6IGJ1aWx0aW4vcHVzaC5jOjU0NgorbXNnaWQgInB1c2ggdGFncyAoY2FuJ3QgYmUgdXNlZCB3aXRoIC0tYWxsIG9yIC0tbWlycm9yKSIKK21zZ3N0ciAic8OkbmQgdGFnZ2FyIChrYW4gaW50ZSBhbnbDpG5kYXMgbWVkIC0tYWxsIGVsbGVyIC0tbWlycm9yKSIKKworIzogYnVpbHRpbi9wdXNoLmM6NTQ5IGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTY3Cittc2dpZCAiZm9yY2UgdXBkYXRlcyIKK21zZ3N0ciAidHZpbmdhIHVwcGRhdGVyaW5nYXIiCisKKyM6IGJ1aWx0aW4vcHVzaC5jOjU1MSBidWlsdGluL3NlbmQtcGFjay5jOjE4MQorbXNnaWQgIjxyZWZuYW1lPjo8ZXhwZWN0PiIKK21zZ3N0ciAiPHJlZm5hbW4+Ojxmw7ZydsOkbnRhPiIKKworIzogYnVpbHRpbi9wdXNoLmM6NTUyIGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTgyCittc2dpZCAicmVxdWlyZSBvbGQgdmFsdWUgb2YgcmVmIHRvIGJlIGF0IHRoaXMgdmFsdWUiCittc2dzdHIgImtyw6R2IGF0dCByZWY6cyB0aWRpZ2FyZSB2w6RyZGUgw6RyIGRldHRhIgorCisjOiBidWlsdGluL3B1c2guYzo1NTUKK21zZ2lkICJjb250cm9sIHJlY3Vyc2l2ZSBwdXNoaW5nIG9mIHN1Ym1vZHVsZXMiCittc2dzdHIgInN0eXIgcmVrdXJzaXYgaW5zw6RuZG5pbmcgYXYgdW5kZXJtb2R1bGVyIgorCisjOiBidWlsdGluL3B1c2guYzo1NTcgYnVpbHRpbi9zZW5kLXBhY2suYzoxNzUKK21zZ2lkICJ1c2UgdGhpbiBwYWNrIgorbXNnc3RyICJhbnbDpG5kIHR1bm5hIHBha2V0IgorCisjOiBidWlsdGluL3B1c2guYzo1NTggYnVpbHRpbi9wdXNoLmM6NTU5IGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTYxCisjOiBidWlsdGluL3NlbmQtcGFjay5jOjE2MgorbXNnaWQgInJlY2VpdmUgcGFjayBwcm9ncmFtIgorbXNnc3RyICJwcm9ncmFtIGbDtnIgYXR0IHRhIGVtb3QgcGFrZXQiCisKKyM6IGJ1aWx0aW4vcHVzaC5jOjU2MAorbXNnaWQgInNldCB1cHN0cmVhbSBmb3IgZ2l0IHB1bGwvc3RhdHVzIgorbXNnc3RyICJzdMOkbGwgaW4gdXBwc3Ryw7ZtIGbDtnIgZ2l0IHB1bGwvc3RhdHVzIgorCisjOiBidWlsdGluL3B1c2guYzo1NjMKK21zZ2lkICJwcnVuZSBsb2NhbGx5IHJlbW92ZWQgcmVmcyIKK21zZ3N0ciAidGEgYm9ydCBsb2thbHQgYm9ydHRhZ25hIHJlZmVyZW5zZXIiCisKKyM6IGJ1aWx0aW4vcHVzaC5jOjU2NQorbXNnaWQgImJ5cGFzcyBwcmUtcHVzaCBob29rIgorbXNnc3RyICJmw7ZyYmlnw6UgcHJlLXB1c2gta3JvayIKKworIzogYnVpbHRpbi9wdXNoLmM6NTY2Cittc2dpZCAicHVzaCBtaXNzaW5nIGJ1dCByZWxldmFudCB0YWdzIgorbXNnc3RyICJzw6RuZCBpbiBzYWtuYWRlIG1lbiByZWxldmFudGEgdGFnZ2FyIgorCisjOiBidWlsdGluL3B1c2guYzo1NjkgYnVpbHRpbi9zZW5kLXBhY2suYzoxNjkKK21zZ2lkICJHUEcgc2lnbiB0aGUgcHVzaCIKK21zZ3N0ciAiR1BHLXNpZ25lcmEgaW5zw6RuZG5pbmdlbiIKKworIzogYnVpbHRpbi9wdXNoLmM6NTcxIGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTc2Cittc2dpZCAicmVxdWVzdCBhdG9taWMgdHJhbnNhY3Rpb24gb24gcmVtb3RlIHNpZGUiCittc2dzdHIgImJlZ8OkciBhdG9taXNrYSB0cmFuc2FrdGlvbmVyIHDDpSBmasOkcnJzaWRhbiIKKworIzogYnVpbHRpbi9wdXNoLmM6NTg5Cittc2dpZCAiLS1kZWxldGUgaXMgaW5jb21wYXRpYmxlIHdpdGggLS1hbGwsIC0tbWlycm9yIGFuZCAtLXRhZ3MiCittc2dzdHIgIi0tZGVsZXRlIMOkciBpbmtvbXBhdGliZWwgbWVkIC0tYWxsLCAtLW1pcnJvciBvY2ggLS10YWdzIgorCisjOiBidWlsdGluL3B1c2guYzo1OTEKK21zZ2lkICItLWRlbGV0ZSBkb2Vzbid0IG1ha2Ugc2Vuc2Ugd2l0aG91dCBhbnkgcmVmcyIKK21zZ3N0ciAiLS1kZWxldGUga2FuIGludGUgYW52w6RuZGFzIHV0YW4gcmVmZXJlbnNlciIKKworIzogYnVpbHRpbi9wdXNoLmM6NjExCiAjLCBjLWZvcm1hdAogbXNnaWQgImJhZCByZXBvc2l0b3J5ICclcyciCiBtc2dzdHIgImZlbGFrdGlndCBhcmtpdiBcIiVzXCIiCiAKLSM6IGJ1aWx0aW4vcHVzaC5jOjM5OQorIzogYnVpbHRpbi9wdXNoLmM6NjEyCiBtc2dpZCAiIgogIk5vIGNvbmZpZ3VyZWQgcHVzaCBkZXN0aW5hdGlvbi5cbiIKICJFaXRoZXIgc3BlY2lmeSB0aGUgVVJMIGZyb20gdGhlIGNvbW1hbmQtbGluZSBvciBjb25maWd1cmUgYSByZW1vdGUgIgpAQCAtMTY3NjUsMTA0ICsxNjkwMSwyNyBAQAogIlxuIgogIiAgICBnaXQgcHVzaCA8bmFtbj5cbiIKIAotIzogYnVpbHRpbi9wdXNoLmM6NTU0Ci1tc2dpZCAicmVwb3NpdG9yeSIKLW1zZ3N0ciAiYXJraXYiCi0KLSM6IGJ1aWx0aW4vcHVzaC5jOjU1NSBidWlsdGluL3NlbmQtcGFjay5jOjE2NAotbXNnaWQgInB1c2ggYWxsIHJlZnMiCi1tc2dzdHIgInPDpG5kIGFsbGEgcmVmZXJlbnNlciIKLQotIzogYnVpbHRpbi9wdXNoLmM6NTU2IGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTY2Ci1tc2dpZCAibWlycm9yIGFsbCByZWZzIgotbXNnc3RyICJzcGVnbGEgYWxsYSByZWZlcmVuc2VyIgotCi0jOiBidWlsdGluL3B1c2guYzo1NTgKLW1zZ2lkICJkZWxldGUgcmVmcyIKLW1zZ3N0ciAidGEgYm9ydCByZWZlcmVuc2VyIgotCi0jOiBidWlsdGluL3B1c2guYzo1NTkKLW1zZ2lkICJwdXNoIHRhZ3MgKGNhbid0IGJlIHVzZWQgd2l0aCAtLWFsbCBvciAtLW1pcnJvcikiCi1tc2dzdHIgInPDpG5kIHRhZ2dhciAoa2FuIGludGUgYW52w6RuZGFzIG1lZCAtLWFsbCBlbGxlciAtLW1pcnJvcikiCi0KLSM6IGJ1aWx0aW4vcHVzaC5jOjU2MiBidWlsdGluL3NlbmQtcGFjay5jOjE2NwotbXNnaWQgImZvcmNlIHVwZGF0ZXMiCi1tc2dzdHIgInR2aW5nYSB1cHBkYXRlcmluZ2FyIgotCi0jOiBidWlsdGluL3B1c2guYzo1NjQgYnVpbHRpbi9zZW5kLXBhY2suYzoxODEKLW1zZ2lkICI8cmVmbmFtZT46PGV4cGVjdD4iCi1tc2dzdHIgIjxyZWZuYW1uPjo8ZsO2cnbDpG50YT4iCi0KLSM6IGJ1aWx0aW4vcHVzaC5jOjU2NSBidWlsdGluL3NlbmQtcGFjay5jOjE4MgotbXNnaWQgInJlcXVpcmUgb2xkIHZhbHVlIG9mIHJlZiB0byBiZSBhdCB0aGlzIHZhbHVlIgotbXNnc3RyICJrcsOkdiBhdHQgcmVmOnMgdGlkaWdhcmUgdsOkcmRlIMOkciBkZXR0YSIKLQotIzogYnVpbHRpbi9wdXNoLmM6NTY4Ci1tc2dpZCAiY29udHJvbCByZWN1cnNpdmUgcHVzaGluZyBvZiBzdWJtb2R1bGVzIgotbXNnc3RyICJzdHlyIHJla3Vyc2l2IGluc8OkbmRuaW5nIGF2IHVuZGVybW9kdWxlciIKLQotIzogYnVpbHRpbi9wdXNoLmM6NTcwIGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTc1Ci1tc2dpZCAidXNlIHRoaW4gcGFjayIKLW1zZ3N0ciAiYW52w6RuZCB0dW5uYSBwYWtldCIKLQotIzogYnVpbHRpbi9wdXNoLmM6NTcxIGJ1aWx0aW4vcHVzaC5jOjU3MiBidWlsdGluL3NlbmQtcGFjay5jOjE2MQotIzogYnVpbHRpbi9zZW5kLXBhY2suYzoxNjIKLW1zZ2lkICJyZWNlaXZlIHBhY2sgcHJvZ3JhbSIKLW1zZ3N0ciAicHJvZ3JhbSBmw7ZyIGF0dCB0YSBlbW90IHBha2V0IgotCi0jOiBidWlsdGluL3B1c2guYzo1NzMKLW1zZ2lkICJzZXQgdXBzdHJlYW0gZm9yIGdpdCBwdWxsL3N0YXR1cyIKLW1zZ3N0ciAic3TDpGxsIGluIHVwcHN0csO2bSBmw7ZyIGdpdCBwdWxsL3N0YXR1cyIKLQotIzogYnVpbHRpbi9wdXNoLmM6NTc2Ci1tc2dpZCAicHJ1bmUgbG9jYWxseSByZW1vdmVkIHJlZnMiCi1tc2dzdHIgInRhIGJvcnQgbG9rYWx0IGJvcnR0YWduYSByZWZlcmVuc2VyIgotCi0jOiBidWlsdGluL3B1c2guYzo1NzgKLW1zZ2lkICJieXBhc3MgcHJlLXB1c2ggaG9vayIKLW1zZ3N0ciAiZsO2cmJpZ8OlIHByZS1wdXNoLWtyb2siCi0KLSM6IGJ1aWx0aW4vcHVzaC5jOjU3OQotbXNnaWQgInB1c2ggbWlzc2luZyBidXQgcmVsZXZhbnQgdGFncyIKLW1zZ3N0ciAic8OkbmQgaW4gc2FrbmFkZSBtZW4gcmVsZXZhbnRhIHRhZ2dhciIKLQotIzogYnVpbHRpbi9wdXNoLmM6NTgyIGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTY5Ci1tc2dpZCAiR1BHIHNpZ24gdGhlIHB1c2giCi1tc2dzdHIgIkdQRy1zaWduZXJhIGluc8OkbmRuaW5nZW4iCi0KLSM6IGJ1aWx0aW4vcHVzaC5jOjU4NCBidWlsdGluL3NlbmQtcGFjay5jOjE3NgotbXNnaWQgInJlcXVlc3QgYXRvbWljIHRyYW5zYWN0aW9uIG9uIHJlbW90ZSBzaWRlIgotbXNnc3RyICJiZWfDpHIgYXRvbWlza2EgdHJhbnNha3Rpb25lciBww6UgZmrDpHJyc2lkYW4iCi0KLSM6IGJ1aWx0aW4vcHVzaC5jOjYwMgotbXNnaWQgIi0tZGVsZXRlIGlzIGluY29tcGF0aWJsZSB3aXRoIC0tYWxsLCAtLW1pcnJvciBhbmQgLS10YWdzIgotbXNnc3RyICItLWRlbGV0ZSDDpHIgaW5rb21wYXRpYmVsIG1lZCAtLWFsbCwgLS1taXJyb3Igb2NoIC0tdGFncyIKLQotIzogYnVpbHRpbi9wdXNoLmM6NjA0Ci1tc2dpZCAiLS1kZWxldGUgZG9lc24ndCBtYWtlIHNlbnNlIHdpdGhvdXQgYW55IHJlZnMiCi1tc2dzdHIgIi0tZGVsZXRlIGthbiBpbnRlIGFudsOkbmRhcyB1dGFuIHJlZmVyZW5zZXIiCi0KLSM6IGJ1aWx0aW4vcHVzaC5jOjYwNworIzogYnVpbHRpbi9wdXNoLmM6NjI3CiBtc2dpZCAiLS1hbGwgYW5kIC0tdGFncyBhcmUgaW5jb21wYXRpYmxlIgogbXNnc3RyICItLWFsbCBvY2ggLS10YWdzIMOkciBpbmtvbXBhdGlibGEiCiAKLSM6IGJ1aWx0aW4vcHVzaC5jOjYwOQorIzogYnVpbHRpbi9wdXNoLmM6NjI5CiBtc2dpZCAiLS1hbGwgY2FuJ3QgYmUgY29tYmluZWQgd2l0aCByZWZzcGVjcyIKIG1zZ3N0ciAiLS1hbGwga2FuIGludGUga29tYmluZXJhcyBtZWQgcmVmZXJlbnNzcGVjaWZpa2F0aW9uZXIiCiAKLSM6IGJ1aWx0aW4vcHVzaC5jOjYxMworIzogYnVpbHRpbi9wdXNoLmM6NjMzCiBtc2dpZCAiLS1taXJyb3IgYW5kIC0tdGFncyBhcmUgaW5jb21wYXRpYmxlIgogbXNnc3RyICItLW1pcnJvciBvY2ggLS10YWdzIMOkciBpbmtvbXBhdGlibGEiCiAKLSM6IGJ1aWx0aW4vcHVzaC5jOjYxNQorIzogYnVpbHRpbi9wdXNoLmM6NjM1CiBtc2dpZCAiLS1taXJyb3IgY2FuJ3QgYmUgY29tYmluZWQgd2l0aCByZWZzcGVjcyIKIG1zZ3N0ciAiLS1taXJyb3Iga2FuIGludGUga29tYmluZXJhcyBtZWQgcmVmZXJlbnNzcGVjaWZpa2F0aW9uZXIiCiAKLSM6IGJ1aWx0aW4vcHVzaC5jOjYxOAorIzogYnVpbHRpbi9wdXNoLmM6NjM4CiBtc2dpZCAiLS1hbGwgYW5kIC0tbWlycm9yIGFyZSBpbmNvbXBhdGlibGUiCiBtc2dzdHIgIi0tYWxsIG9jaCAtLW1pcnJvciDDpHIgaW5rb21wYXRpYmxhIgogCi0jOiBidWlsdGluL3B1c2guYzo2MzcKKyM6IGJ1aWx0aW4vcHVzaC5jOjY0MgogbXNnaWQgInB1c2ggb3B0aW9ucyBtdXN0IG5vdCBoYXZlIG5ldyBsaW5lIGNoYXJhY3RlcnMiCiBtc2dzdHIgInB1c2gtZmxhZ2dvciBrYW4gaW50ZSBpbm5laMOlbGxhIHJhZGJyeXRuaW5nIgogCkBAIC0xNjk4MCwxMSArMTcwMzksMTEgQEAKIAogIzogYnVpbHRpbi9yZWJhc2UuYzozMgogbXNnaWQgIiIKLSJnaXQgcmViYXNlIFstaV0gW29wdGlvbnNdIFstLWV4ZWMgPGNtZD5dIFstLW9udG8gPG5ld2Jhc2U+XSBbPHVwc3RyZWFtPl0gIgotIls8YnJhbmNoPl0iCisiZ2l0IHJlYmFzZSBbLWldIFtvcHRpb25zXSBbLS1leGVjIDxjbWQ+XSBbLS1vbnRvIDxuZXdiYXNlPiB8IC0ta2VlcC1iYXNlXSAiCisiWzx1cHN0cmVhbT4gWzxicmFuY2g+XV0iCiBtc2dzdHIgIiIKLSJnaXQgcmViYXNlIFstaV0gW2ZsYWdnb3JdIFstLWV4ZWMgPGttZD5dIFstLW9udG8gPG55YmFzPl0gWzx1cHBzdHLDtm0+XSAiCi0iWzxncmVuPl0iCisiZ2l0IHJlYmFzZSBbLWldIFtmbGFnZ29yXSBbLS1leGVjIDxrbWQ+XSBbLS1vbnRvIDxueWJhcz4gfCAtLWtlZXAtYmFzZV0gIgorIls8dXBwc3Ryw7ZtPiBbPGdyZW4+XV0iCiAKICM6IGJ1aWx0aW4vcmViYXNlLmM6MzQKIG1zZ2lkICIiCkBAIC0xNzAyMywxODkgKzE3MDgyLDE4OSBAQAogbXNnaWQgImNvdWxkIG5vdCBnZW5lcmF0ZSB0b2RvIGxpc3QiCiBtc2dzdHIgIkt1bmRlIGludGUgc2thcGEgYXR0Z8O2cmEtbGlzdGEiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MzgyCisjOiBidWlsdGluL3JlYmFzZS5jOjM4MwogbXNnaWQgImEgYmFzZSBjb21taXQgbXVzdCBiZSBwcm92aWRlZCB3aXRoIC0tdXBzdHJlYW0gb3IgLS1vbnRvIgogbXNnc3RyICJlbiBiYXNpbmNoZWNrbmluZyBtw6VzdGUgYW5nZXMgbWVkIC0tdXBzdHJlYW0gZWxsZXIgLS1vbnRvIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQzNworIzogYnVpbHRpbi9yZWJhc2UuYzo0MzgKIG1zZ2lkICJnaXQgcmViYXNlLS1pbnRlcmFjdGl2ZSBbPG9wdGlvbnM+XSIKIG1zZ3N0ciAiZ2l0IHJlYmFzZS0taW50ZXJhY3RpdmUgWzxmbGFnZ29yPl0iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDQ5CisjOiBidWlsdGluL3JlYmFzZS5jOjQ1MAogbXNnaWQgImtlZXAgZW1wdHkgY29tbWl0cyIKIG1zZ3N0ciAiYmVow6VsbCB0b21tYSBpbmNoZWNrbmluZ2FyIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ1MSBidWlsdGluL3JldmVydC5jOjEyOAorIzogYnVpbHRpbi9yZWJhc2UuYzo0NTIgYnVpbHRpbi9yZXZlcnQuYzoxMjgKIG1zZ2lkICJhbGxvdyBjb21taXRzIHdpdGggZW1wdHkgbWVzc2FnZXMiCiBtc2dzdHIgInRpbGzDpXQgaW5jaGVja25pbmdhciBtZWQgdG9tdCBtZWRkZWxhbmRlIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ1MgorIzogYnVpbHRpbi9yZWJhc2UuYzo0NTMKIG1zZ2lkICJyZWJhc2UgbWVyZ2UgY29tbWl0cyIKIG1zZ3N0ciAib21iYXNlcmEgc2FtbWFuc2xhZ25pbmdhciIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0NTQKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDU1CiBtc2dpZCAia2VlcCBvcmlnaW5hbCBicmFuY2ggcG9pbnRzIG9mIGNvdXNpbnMiCiBtc2dzdHIgImJlaMOlbGwgdXJzcHJ1bmdsaWdhIGbDtnJncmVuaW5nc3B1bmt0ZXIgZsO2ciBrdXNpbmVyIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ1NgorIzogYnVpbHRpbi9yZWJhc2UuYzo0NTcKIG1zZ2lkICJtb3ZlIGNvbW1pdHMgdGhhdCBiZWdpbiB3aXRoIHNxdWFzaCEvZml4dXAhIgogbXNnc3RyICJmbHl0dGEgaW5jaGVja25pbmdhciBzb20gaW5sZWRzIG1lZCBzcXVhc2ghL2ZpeHVwISIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0NTcKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDU4CiBtc2dpZCAic2lnbiBjb21taXRzIgogbXNnc3RyICJzaWduZXJhIGluY2hlY2tuaW5nYXIiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDU5IGJ1aWx0aW4vcmViYXNlLmM6MTQwMworIzogYnVpbHRpbi9yZWJhc2UuYzo0NjAgYnVpbHRpbi9yZWJhc2UuYzoxNDI3CiBtc2dpZCAiZGlzcGxheSBhIGRpZmZzdGF0IG9mIHdoYXQgY2hhbmdlZCB1cHN0cmVhbSIKIG1zZ3N0ciAidmlzIGRpZmZzdGF0IGbDtnIgdmFkIHNvbSDDpG5kcmF0cyB1cHBzdHLDtm1zIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ2MQorIzogYnVpbHRpbi9yZWJhc2UuYzo0NjIKIG1zZ2lkICJjb250aW51ZSByZWJhc2UiCiBtc2dzdHIgImZvcnRzw6R0dCBvbWJhc2VyaW5nIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ2MworIzogYnVpbHRpbi9yZWJhc2UuYzo0NjQKIG1zZ2lkICJza2lwIGNvbW1pdCIKIG1zZ3N0ciAiaG9wcGEgw7Z2ZXIgaW5jaGVja25pbmciCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDY0CisjOiBidWlsdGluL3JlYmFzZS5jOjQ2NQogbXNnaWQgImVkaXQgdGhlIHRvZG8gbGlzdCIKIG1zZ3N0ciAicmVkaWdlcmEgYXR0Z8O2cmEtbGlzdGFuIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ2NgorIzogYnVpbHRpbi9yZWJhc2UuYzo0NjcKIG1zZ2lkICJzaG93IHRoZSBjdXJyZW50IHBhdGNoIgogbXNnc3RyICJ2aXNhIG51dmFyYW5kZSBwYXRjaCIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0NjkKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDcwCiBtc2dpZCAic2hvcnRlbiBjb21taXQgaWRzIGluIHRoZSB0b2RvIGxpc3QiCiBtc2dzdHIgImbDtnJrb3J0YSBpbmNoZWNrbmluZ3MtaWQgaSB0b2RvLWxpc3RhbiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0NzEKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDcyCiBtc2dpZCAiZXhwYW5kIGNvbW1pdCBpZHMgaW4gdGhlIHRvZG8gbGlzdCIKIG1zZ3N0ciAidXTDtmthIGluY2hlY2tuaW5ncy1pZCBpIHRvZG8tbGlzdGFuIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ3MworIzogYnVpbHRpbi9yZWJhc2UuYzo0NzQKIG1zZ2lkICJjaGVjayB0aGUgdG9kbyBsaXN0IgogbXNnc3RyICJrb250cm9sbGVyYSB0b2RvLWxpc3RhbiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0NzUKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDc2CiBtc2dpZCAicmVhcnJhbmdlIGZpeHVwL3NxdWFzaCBsaW5lcyIKIG1zZ3N0ciAib3JkbmEgb20gZml4dXAtL3NxdWFzaC1yYWRlciIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0NzcKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDc4CiBtc2dpZCAiaW5zZXJ0IGV4ZWMgY29tbWFuZHMgaW4gdG9kbyBsaXN0IgogbXNnc3RyICJsw6RnZyBpbiBleGVjLWtvbW1hbmRvbiBpIHRvZG8tbGlzdGFuIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ3OAorIzogYnVpbHRpbi9yZWJhc2UuYzo0NzkKIG1zZ2lkICJvbnRvIgogbXNnc3RyICJvdmFucMOlIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ4MQorIzogYnVpbHRpbi9yZWJhc2UuYzo0ODIKIG1zZ2lkICJyZXN0cmljdC1yZXZpc2lvbiIKIG1zZ3N0ciAicmVzdHJpY3QtcmV2aXNpb24iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDgxCisjOiBidWlsdGluL3JlYmFzZS5jOjQ4MgogbXNnaWQgInJlc3RyaWN0IHJldmlzaW9uIgogbXNnc3RyICJiZWdyw6Ruc2EgcmV2aXNpb24iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDgzCisjOiBidWlsdGluL3JlYmFzZS5jOjQ4NAogbXNnaWQgInNxdWFzaC1vbnRvIgogbXNnc3RyICJzcXVhc2gtb250byIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0ODQKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDg1CiBtc2dpZCAic3F1YXNoIG9udG8iCiBtc2dzdHIgInRyeWNrIGlob3Agb3ZhbnDDpSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0ODYKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDg3CiBtc2dpZCAidGhlIHVwc3RyZWFtIGNvbW1pdCIKIG1zZ3N0ciAidXBwc3Ryw7Ztc2luY2hlY2tuaW5nZW4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDg4CisjOiBidWlsdGluL3JlYmFzZS5jOjQ4OQogbXNnaWQgImhlYWQtbmFtZSIKIG1zZ3N0ciAiaGVhZC1uYW1lIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ4OAorIzogYnVpbHRpbi9yZWJhc2UuYzo0ODkKIG1zZ2lkICJoZWFkIG5hbWUiCiBtc2dzdHIgIm5hbW4gcMOlIGh1dnVkIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ5MworIzogYnVpbHRpbi9yZWJhc2UuYzo0OTQKIG1zZ2lkICJyZWJhc2Ugc3RyYXRlZ3kiCiBtc2dzdHIgInNhbW1hbnNsYWduaW5nc3N0cmF0ZWdpIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ5NAorIzogYnVpbHRpbi9yZWJhc2UuYzo0OTUKIG1zZ2lkICJzdHJhdGVneS1vcHRzIgogbXNnc3RyICJzdHJhdGVneS1vcHRzIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ5NQorIzogYnVpbHRpbi9yZWJhc2UuYzo0OTYKIG1zZ2lkICJzdHJhdGVneSBvcHRpb25zIgogbXNnc3RyICJzdHJhdGVnaWZsYWdnb3IiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDk2CisjOiBidWlsdGluL3JlYmFzZS5jOjQ5NwogbXNnaWQgInN3aXRjaC10byIKIG1zZ3N0ciAic3dpdGNoLXRvIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ5NworIzogYnVpbHRpbi9yZWJhc2UuYzo0OTgKIG1zZ2lkICJ0aGUgYnJhbmNoIG9yIGNvbW1pdCB0byBjaGVja291dCIKIG1zZ3N0ciAiZ3JlbiBlbGxlciBpbmNoZWNraW5nIGF0dCBjaGVja2EgdXQiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDk4CisjOiBidWlsdGluL3JlYmFzZS5jOjQ5OQogbXNnaWQgIm9udG8tbmFtZSIKIG1zZ3N0ciAib250by1uYW1lIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ5OAorIzogYnVpbHRpbi9yZWJhc2UuYzo0OTkKIG1zZ2lkICJvbnRvIG5hbWUiCiBtc2dzdHIgInDDpS1uYW1uIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ5OQorIzogYnVpbHRpbi9yZWJhc2UuYzo1MDAKIG1zZ2lkICJjbWQiCiBtc2dzdHIgImttZCIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0OTkKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NTAwCiBtc2dpZCAidGhlIGNvbW1hbmQgdG8gcnVuIgogbXNnc3RyICJrb21tYW5kbyBhdHQga8O2cmEiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NTAyIGJ1aWx0aW4vcmViYXNlLmM6MTQ4NgorIzogYnVpbHRpbi9yZWJhc2UuYzo1MDMgYnVpbHRpbi9yZWJhc2UuYzoxNTEwCiBtc2dpZCAiYXV0b21hdGljYWxseSByZS1zY2hlZHVsZSBhbnkgYGV4ZWNgIHRoYXQgZmFpbHMiCiBtc2dzdHIgImvDtnIgYXV0b21hdGlza3QgYWxsYSBcImV4ZWNcIiBzb20gbWlzc2x5Y2thcyBww6Ugbnl0dCIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo1MTgKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NTE5CiBtc2dpZCAiLS1bbm8tXXJlYmFzZS1jb3VzaW5zIGhhcyBubyBlZmZlY3Qgd2l0aG91dCAtLXJlYmFzZS1tZXJnZXMiCiBtc2dzdHIgIi0tW25vLV1yZWJhc2UtY291c2lucyBoYXIgaW5nZW4gZWZmZWt0IHV0YW4gLS1yZWJhc2UtbWVyZ2VzIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjUzNAorIzogYnVpbHRpbi9yZWJhc2UuYzo1MzUKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgcmVxdWlyZXMgYW4gaW50ZXJhY3RpdmUgcmViYXNlIgogbXNnc3RyICIlcyBrcsOkdmVyIGVuIGludGVyYWt0aXYgb21iYXNlcmluZyIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo1ODYKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NTg3CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBnZXQgJ29udG8nOiAnJXMnIgogbXNnc3RyICJrdW5kZSBpbnRlIGjDpG10YSBcIm9udG9cIjogXCIlc1wiIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjYwMQorIzogYnVpbHRpbi9yZWJhc2UuYzo2MDIKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBvcmlnLWhlYWQ6ICclcyciCiBtc2dzdHIgIm9naWx0aWd0IG9yaWctaGVhZDogXCIlc1wiIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjYyNgorIzogYnVpbHRpbi9yZWJhc2UuYzo2MjcKICMsIGMtZm9ybWF0CiBtc2dpZCAiaWdub3JpbmcgaW52YWxpZCBhbGxvd19yZXJlcmVfYXV0b3VwZGF0ZTogJyVzJyIKIG1zZ3N0ciAiaWdub3JlcmEgb2dpbHRpZ3QgYWxsb3dfcmVyZXJlX2F1dG91cGRhdGU6IFwiJXNcIiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo3MDIKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NzAzCiAjLCBjLWZvcm1hdAogbXNnaWQgIkNvdWxkIG5vdCByZWFkICclcyciCiBtc2dzdHIgIkt1bmRlIGludGUgbMOkc2EgXCIlc1wiIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjcyMAorIzogYnVpbHRpbi9yZWJhc2UuYzo3MjEKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ2Fubm90IHN0b3JlICVzIgogbXNnc3RyICJLYW4gaW50ZSBzcGFyYSAlcyIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo4MjcKKyM6IGJ1aWx0aW4vcmViYXNlLmM6ODI4CiBtc2dpZCAiY291bGQgbm90IGRldGVybWluZSBIRUFEIHJldmlzaW9uIgogbXNnc3RyICJrdW5kZSBpbnRlIGJlc3TDpG1tYSBIRUFELXJldmlzaW9uIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjk1MCBnaXQtcmViYXNlLS1wcmVzZXJ2ZS1tZXJnZXMuc2g6ODEKKyM6IGJ1aWx0aW4vcmViYXNlLmM6OTUxIGdpdC1yZWJhc2UtLXByZXNlcnZlLW1lcmdlcy5zaDo4MQogbXNnaWQgIiIKICJSZXNvbHZlIGFsbCBjb25mbGljdHMgbWFudWFsbHksIG1hcmsgdGhlbSBhcyByZXNvbHZlZCB3aXRoXG4iCiAiXCJnaXQgYWRkL3JtIDxjb25mbGljdGVkX2ZpbGVzPlwiLCB0aGVuIHJ1biBcImdpdCByZWJhc2UgLS1jb250aW51ZVwiLlxuIgpAQCAtMTcyMTksNyArMTcyNzgsNyBAQAogIkbDtnIgYXR0IGF2YnJ5dGEgb2NoIMOldGVyZ8OlIHRpbGwgZMOkciBkdSB2YXIgZsO2cmUgb21iYXNlcmluZ2VuLCBrw7ZyIFwiZ2l0ICIKICJyZWJhc2UgLS1hYm9ydFwiLiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxMDMxCisjOiBidWlsdGluL3JlYmFzZS5jOjEwMzIKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlxuIgpAQCAtMTcyMzgsNyArMTcyOTcsNyBAQAogIlxuIgogIkTDpHJmw7ZyIGthbiBpbnRlIGdpdCBvbWJhc2VyYSBkZXNzYS4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTMxOAorIzogYnVpbHRpbi9yZWJhc2UuYzoxMzM5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICIlc1xuIgpAQCAtMTcyNTUsNyArMTczMTQsNyBAQAogIiAgICBnaXQgcmViYXNlICc8Z3Jlbj4nXG4iCiAiXG4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTMzNAorIzogYnVpbHRpbi9yZWJhc2UuYzoxMzU1CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJJZiB5b3Ugd2lzaCB0byBzZXQgdHJhY2tpbmcgaW5mb3JtYXRpb24gZm9yIHRoaXMgYnJhbmNoIHlvdSBjYW4gZG8gc28gd2l0aDpcbiIKQEAgLTE3MjY4LDEyOCArMTczMjcsMTMyIEBACiAiICAgIGdpdCBicmFuY2ggLS1zZXQtdXBzdHJlYW0tdG89JXMvPGdyZW4+ICVzXG4iCiAiXG4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTM2NAorIzogYnVpbHRpbi9yZWJhc2UuYzoxMzg1CiBtc2dpZCAiZXhlYyBjb21tYW5kcyBjYW5ub3QgY29udGFpbiBuZXdsaW5lcyIKIG1zZ3N0ciAiZXhlYy1rb21tYW5kb24ga2FuIGludGUgaW5uZWjDpWxsYSBueXJhZHN0ZWNrZW4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTM2OAorIzogYnVpbHRpbi9yZWJhc2UuYzoxMzg5CiBtc2dpZCAiZW1wdHkgZXhlYyBjb21tYW5kIgogbXNnc3RyICJ0b210IGV4ZWMta29tbWFuZG8iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTM5NgorIzogYnVpbHRpbi9yZWJhc2UuYzoxNDE4CiBtc2dpZCAicmViYXNlIG9udG8gZ2l2ZW4gYnJhbmNoIGluc3RlYWQgb2YgdXBzdHJlYW0iCiBtc2dzdHIgIm9tYmFzZXJhIG1vdCBnaXZlbiBncmVuZW4gaXN0w6RsbGV0IGbDtnIgdXBwc3Ryw7ZtIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjEzOTgKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQyMAorbXNnaWQgInVzZSB0aGUgbWVyZ2UtYmFzZSBvZiB1cHN0cmVhbSBhbmQgYnJhbmNoIGFzIHRoZSBjdXJyZW50IGJhc2UiCittc2dzdHIgImFudsOkbmQgc2FtbWFuc2xhZ25pbmdzYmFzZW4gbWVsbGFuIHVwcHN0csO2bXMgb2NoIGdyZW4gc29tIGFrdHVlbGwgYmFzIgorCisjOiBidWlsdGluL3JlYmFzZS5jOjE0MjIKIG1zZ2lkICJhbGxvdyBwcmUtcmViYXNlIGhvb2sgdG8gcnVuIgogbXNnc3RyICJ0aWxsw6V0IHByZS1yZWJhc2Uta3JvayBhdHQga8O2cmEiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQwMAorIzogYnVpbHRpbi9yZWJhc2UuYzoxNDI0CiBtc2dpZCAiYmUgcXVpZXQuIGltcGxpZXMgLS1uby1zdGF0IgogbXNnc3RyICJ2YXIgdHlzdC4gaW1wbGljZXJhciAtLW5vLXN0YXQiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQwNgorIzogYnVpbHRpbi9yZWJhc2UuYzoxNDMwCiBtc2dpZCAiZG8gbm90IHNob3cgZGlmZnN0YXQgb2Ygd2hhdCBjaGFuZ2VkIHVwc3RyZWFtIgogbXNnc3RyICJ2aXNhIGludGUgZW4gZGlmZnN0YXQgZsO2ciB2YWQgc29tIMOkbmRyYXRzIHVwcHN0csO2bXMiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQwOQorIzogYnVpbHRpbi9yZWJhc2UuYzoxNDMzCiBtc2dpZCAiYWRkIGEgU2lnbmVkLW9mZi1ieTogbGluZSB0byBlYWNoIGNvbW1pdCIKIG1zZ3N0ciAibMOkZ2cgXCJTaWduZWQtb2ZmLWJ5OlwiLXJhZCB0aWxsIHZhcmplIGluY2hlY2tuaW5nIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0MTEgYnVpbHRpbi9yZWJhc2UuYzoxNDE1IGJ1aWx0aW4vcmViYXNlLmM6MTQxNworIzogYnVpbHRpbi9yZWJhc2UuYzoxNDM1IGJ1aWx0aW4vcmViYXNlLmM6MTQzOSBidWlsdGluL3JlYmFzZS5jOjE0NDEKIG1zZ2lkICJwYXNzZWQgdG8gJ2dpdCBhbSciCiBtc2dzdHIgInPDpG5kcyB0aWxsIFwiZ2l0IGFtXCIiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQxOSBidWlsdGluL3JlYmFzZS5jOjE0MjEKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ0MyBidWlsdGluL3JlYmFzZS5jOjE0NDUKIG1zZ2lkICJwYXNzZWQgdG8gJ2dpdCBhcHBseSciCiBtc2dzdHIgInPDpG5kcyB0aWxsIFwiZ2l0IGFwcGx5XCIiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQyMyBidWlsdGluL3JlYmFzZS5jOjE0MjYKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ0NyBidWlsdGluL3JlYmFzZS5jOjE0NTAKIG1zZ2lkICJjaGVycnktcGljayBhbGwgY29tbWl0cywgZXZlbiBpZiB1bmNoYW5nZWQiCiBtc2dzdHIgInV0ZsO2ciBjaGVycnktcGljayBww6UgYWxsYSBpbmNoZWNrbmluZ2FyLCDDpHZlbiBvbSBvw6RuZHJhZCIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDI4CisjOiBidWlsdGluL3JlYmFzZS5jOjE0NTIKIG1zZ2lkICJjb250aW51ZSIKIG1zZ3N0ciAiZm9ydHPDpHR0IgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0MzEKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ1NQogbXNnaWQgInNraXAgY3VycmVudCBwYXRjaCBhbmQgY29udGludWUiCiBtc2dzdHIgImhvcHBhIMO2dmVyIG51dmFyYW5kZSBwYXRjaCBvY2ggZm9ydHPDpHR0IgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0MzMKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ1NwogbXNnaWQgImFib3J0IGFuZCBjaGVjayBvdXQgdGhlIG9yaWdpbmFsIGJyYW5jaCIKIG1zZ3N0ciAiYXZicnl0IG9jaCBjaGVja2EgdXQgdXJzcHJ1bmdzZ3JlbmVuIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0MzYKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ2MAogbXNnaWQgImFib3J0IGJ1dCBrZWVwIEhFQUQgd2hlcmUgaXQgaXMiCiBtc2dzdHIgImF2YnJ5dCBtZW4gYmVow6VsbCBIRUFEIGTDpHIgZGV0IMOkciIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDM3CisjOiBidWlsdGluL3JlYmFzZS5jOjE0NjEKIG1zZ2lkICJlZGl0IHRoZSB0b2RvIGxpc3QgZHVyaW5nIGFuIGludGVyYWN0aXZlIHJlYmFzZSIKIG1zZ3N0ciAicmVkaWdlcmEgYXR0Z8O2cmEtbGlzdGFuIHVuZGVyIGludGVyYWt0aXYgb21iYXNlcmluZy4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ0MAorIzogYnVpbHRpbi9yZWJhc2UuYzoxNDY0CiBtc2dpZCAic2hvdyB0aGUgcGF0Y2ggZmlsZSBiZWluZyBhcHBsaWVkIG9yIG1lcmdlZCIKIG1zZ3N0ciAidmlzYSBwYXRjaGVuIHNvbSB0aWxsw6RtcGFzIGVsbGVyIHNsw6VzIHNhbW1hbiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDQzCisjOiBidWlsdGluL3JlYmFzZS5jOjE0NjcKIG1zZ2lkICJ1c2UgbWVyZ2luZyBzdHJhdGVnaWVzIHRvIHJlYmFzZSIKIG1zZ3N0ciAiYW52w6RuZCBzYW1tYW5zbGFnbmluZ3NzdHJhdGVnaWVyIGbDtnIgc2FtbWFuc2xhZ25pbmciCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ0NworIzogYnVpbHRpbi9yZWJhc2UuYzoxNDcxCiBtc2dpZCAibGV0IHRoZSB1c2VyIGVkaXQgdGhlIGxpc3Qgb2YgY29tbWl0cyB0byByZWJhc2UiCiBtc2dzdHIgImzDpXQgYW52w6RuZGFyZW4gcmVkaWdlcmEgbGlzdGFuIMO2dmVyIGluY2hlY2tuaW5nYXIgYXR0IG9tYmFzZXJhIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0NTEKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ3NQogbXNnaWQgIihERVBSRUNBVEVEKSB0cnkgdG8gcmVjcmVhdGUgbWVyZ2VzIGluc3RlYWQgb2YgaWdub3JpbmcgdGhlbSIKIG1zZ3N0ciAiIgogIihBVlLDhURTKSBmw7Zyc8O2ayDDpXRlcnNrYXBhIHNhbW1hbnNsYWduaW5nYXIgaXN0w6RsbGV0IGbDtnIgYXR0IGlnbm9yZXJhIGRlbSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDU1CisjOiBidWlsdGluL3JlYmFzZS5jOjE0NzkKIG1zZ2lkICJwcmVzZXJ2ZSBlbXB0eSBjb21taXRzIGR1cmluZyByZWJhc2UiCiBtc2dzdHIgImJlaMOlbGwgdG9tbWEgaW5jaGVja25pbmdhciB1bmRlciBvbWJhc2VyaW5nIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0NTcKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ4MQogbXNnaWQgIm1vdmUgY29tbWl0cyB0aGF0IGJlZ2luIHdpdGggc3F1YXNoIS9maXh1cCEgdW5kZXIgLWkiCiBtc2dzdHIgImZseXR0YSBpbmNoZWNrbmluZ2FyIHNvbSBiw7ZyamFyIG1lZCBzcXVhc2ghL2ZpeHVwISB1bmRlciAtaSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDYzCisjOiBidWlsdGluL3JlYmFzZS5jOjE0ODcKIG1zZ2lkICJhdXRvbWF0aWNhbGx5IHN0YXNoL3N0YXNoIHBvcCBiZWZvcmUgYW5kIGFmdGVyIgogbXNnc3RyICJ1dGbDtnIgYXV0b21hdGlza3Qgc3Rhc2gvc3Rhc2ggcG9wIGbDtnJlIG9jaCBlZnRlciIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDY1CisjOiBidWlsdGluL3JlYmFzZS5jOjE0ODkKIG1zZ2lkICJhZGQgZXhlYyBsaW5lcyBhZnRlciBlYWNoIGNvbW1pdCBvZiB0aGUgZWRpdGFibGUgbGlzdCIKIG1zZ3N0ciAibMOkZ2cgdGlsbCBleGVjLXJhZGVyIGVmdGVyIHZhcmplIGluY2hlY2tuaW5nIGkgZGVuIHJlZGlnZXJiYXJhIGxpc3RhbiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDY5CisjOiBidWlsdGluL3JlYmFzZS5jOjE0OTMKIG1zZ2lkICJhbGxvdyByZWJhc2luZyBjb21taXRzIHdpdGggZW1wdHkgbWVzc2FnZXMiCiBtc2dzdHIgInRpbGzDpXQgb21iYXNlcmluZyBhdiBpbmNoZWNrbmluZ2FyIG1lZCB0b210IG1lZGRlbGFuZGUiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ3MgorIzogYnVpbHRpbi9yZWJhc2UuYzoxNDk2CiBtc2dpZCAidHJ5IHRvIHJlYmFzZSBtZXJnZXMgaW5zdGVhZCBvZiBza2lwcGluZyB0aGVtIgogbXNnc3RyICJmw7Zyc8O2ayBvbWJhc2VyYSBzYW1tYW5zbGFnbmluZ2FyIGlzdMOkbGxldCBmw7ZyIGF0dCBpZ25vcmVyYSBkZW0iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ3NQorIzogYnVpbHRpbi9yZWJhc2UuYzoxNDk5CiBtc2dpZCAidXNlICdtZXJnZS1iYXNlIC0tZm9yay1wb2ludCcgdG8gcmVmaW5lIHVwc3RyZWFtIgogbXNnc3RyICJhbnbDpG5kIFwibWVyZ2UtYmFzZSAtLWZvcmstcG9pbnRcIiBmw7ZyIGF0dCBmw7ZyZmluYSB1cHBzdHLDtm0iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ3NworIzogYnVpbHRpbi9yZWJhc2UuYzoxNTAxCiBtc2dpZCAidXNlIHRoZSBnaXZlbiBtZXJnZSBzdHJhdGVneSIKIG1zZ3N0ciAiYW52w6RuZCBhbmdpdmVuIHNhbW1hbnNsYWduaW5nc3N0cmF0ZWdpIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0NzkgYnVpbHRpbi9yZXZlcnQuYzoxMTUKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTUwMyBidWlsdGluL3JldmVydC5jOjExNQogbXNnaWQgIm9wdGlvbiIKIG1zZ3N0ciAiYWx0ZXJuYXRpdiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDgwCisjOiBidWlsdGluL3JlYmFzZS5jOjE1MDQKIG1zZ2lkICJwYXNzIHRoZSBhcmd1bWVudCB0aHJvdWdoIHRvIHRoZSBtZXJnZSBzdHJhdGVneSIKIG1zZ3N0ciAic8OkbmQgZmxhZ2dhbiB0aWxsIHNhbW1hbnNsYWduaW5nc3N0cmF0ZWdpbiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDgzCisjOiBidWlsdGluL3JlYmFzZS5jOjE1MDcKIG1zZ2lkICJyZWJhc2UgYWxsIHJlYWNoYWJsZSBjb21taXRzIHVwIHRvIHRoZSByb290KHMpIgogbXNnc3RyICJvbWJhc2VyYSBhbGxhIG7DpWJhcmEgaW5jaGVja25pbmdhciB1cHAgdGlsbCByb3Rlbi9yw7Z0dGVybmEiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTUwMAorIzogYnVpbHRpbi9yZWJhc2UuYzoxNTI0CiBtc2dpZCAiIgogInRoZSByZWJhc2UudXNlQnVpbHRpbiBzdXBwb3J0IGhhcyBiZWVuIHJlbW92ZWQhXG4iCiAiU2VlIGl0cyBlbnRyeSBpbiAnZ2l0IGhlbHAgY29uZmlnJyBmb3IgZGV0YWlscy4iCkBAIC0xNzM5NywyOSArMTc0NjAsMzcgQEAKICJzdMO2ZGV0IGbDtnIgcmViYXNlLnVzZUJ1aWx0aW4gaGFyIHRhZ2l0cyBib3J0IVxuIgogIlNlIHBvc3RlbiBmw7ZyIGRldCBpIFwiZ2l0IGhlbHAgY29uZmlnXCIgZsO2ciBkZXRhbGplci4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTUwNgorIzogYnVpbHRpbi9yZWJhc2UuYzoxNTMwCiBtc2dpZCAiSXQgbG9va3MgbGlrZSAnZ2l0IGFtJyBpcyBpbiBwcm9ncmVzcy4gQ2Fubm90IHJlYmFzZS4iCiBtc2dzdHIgIkRldCB2ZXJrYXIgc29tIGVuIFwiZ2l0IGFtXCIga8O2cnMuIEthbiBpbnRlIG9tYmFzZXJhLiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNTQ3CisjOiBidWlsdGluL3JlYmFzZS5jOjE1NzEKIG1zZ2lkICIiCiAiZ2l0IHJlYmFzZSAtLXByZXNlcnZlLW1lcmdlcyBpcyBkZXByZWNhdGVkLiBVc2UgLS1yZWJhc2UtbWVyZ2VzIGluc3RlYWQuIgogbXNnc3RyICIiCiAiZ2l0IHJlYmFzZSAtLXByZXNlcnZlLW1lcmdlcyBhdnLDpWRzIGZyw6VuLiBBbnbDpG5kIC0tcmViYXNlLW1lcmdlcyBpc3TDpGxsZXQuIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE1NTEKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTU3NgorbXNnaWQgImNhbm5vdCBjb21iaW5lICctLWtlZXAtYmFzZScgd2l0aCAnLS1vbnRvJyIKK21zZ3N0ciAia2FuIGludGUga29tYmluZXJhIFwiLS1rZWVwLWJhc2VcIiBtZWQgXCItLW9udG9cIiIKKworIzogYnVpbHRpbi9yZWJhc2UuYzoxNTc4Cittc2dpZCAiY2Fubm90IGNvbWJpbmUgJy0ta2VlcC1iYXNlJyB3aXRoICctLXJvb3QnIgorbXNnc3RyICJrYW4gaW50ZSBrb21iaW5lcmEgXCItLWtlZXAtYmFzZVwiIG1lZCBcIi0tcm9vdFwiIgorCisjOiBidWlsdGluL3JlYmFzZS5jOjE1ODIKIG1zZ2lkICJObyByZWJhc2UgaW4gcHJvZ3Jlc3M/IgogbXNnc3RyICJJbmdlbiBvbWJhc2VyaW5nIHDDpWfDpXI/IgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE1NTUKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTU4NgogbXNnaWQgIlRoZSAtLWVkaXQtdG9kbyBhY3Rpb24gY2FuIG9ubHkgYmUgdXNlZCBkdXJpbmcgaW50ZXJhY3RpdmUgcmViYXNlLiIKIG1zZ3N0ciAiw4V0Z8OkcmRlbiAtLWVkaXQtdG9kbyBrYW4gZW5kYXN0IGFudsOkbmRhcyB1bmRlciBpbnRlcmFrdGl2IG9tYmFzZXJpbmcuIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE1NzgKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTYwOQogbXNnaWQgIkNhbm5vdCByZWFkIEhFQUQiCiBtc2dzdHIgIkthbiBpbnRlIGzDpHNhIEhFQUQiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTU5MAorIzogYnVpbHRpbi9yZWJhc2UuYzoxNjIxCiBtc2dpZCAiIgogIllvdSBtdXN0IGVkaXQgYWxsIG1lcmdlIGNvbmZsaWN0cyBhbmQgdGhlblxuIgogIm1hcmsgdGhlbSBhcyByZXNvbHZlZCB1c2luZyBnaXQgYWRkIgpAQCAtMTc0MjcsMTYgKzE3NDk4LDE2IEBACiAiRHUgbcOlc3RlIHJlZGlnZXJhIGFsbGEgc2FtbWFuc2xhZ25pbmdza29uZmxpa3RlciBvY2hcbiIKICJkw6RyZWZ0ZXIgbWFya2VyYSBkZW0gc29tIGzDtnN0YSBtZWQgZ2l0IGFkZCIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNjA5CisjOiBidWlsdGluL3JlYmFzZS5jOjE2NDAKIG1zZ2lkICJjb3VsZCBub3QgZGlzY2FyZCB3b3JrdHJlZSBjaGFuZ2VzIgogbXNnc3RyICJrdW5kZSBpbnRlIGthc3RhIMOkbmRyaW5nYXIgaSBhcmJldHNrYXRhbG9nZW4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTYyOAorIzogYnVpbHRpbi9yZWJhc2UuYzoxNjU5CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBtb3ZlIGJhY2sgdG8gJXMiCiBtc2dzdHIgImt1bmRlIGludGUgZmx5dHRhIHRpbGxiYWthIHRpbGwgJXMiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTY3MworIzogYnVpbHRpbi9yZWJhc2UuYzoxNzA0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJJdCBzZWVtcyB0aGF0IHRoZXJlIGlzIGFscmVhZHkgYSAlcyBkaXJlY3RvcnksIGFuZFxuIgpAQCAtMTc0NTcsMTY3ICsxNzUyOCwxNTkgQEAKICJvY2gga8O2ciBwcm9ncmFtbWV0IGlnZW4uIEphZyBhdnNsdXRhciBpZmFsbCBkdSBmb3J0ZmFyYW5kZSBoYXJcbiIKICJuw6Vnb3QgYXYgdsOkcmRlIGTDpHIuXG4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTY5NAorIzogYnVpbHRpbi9yZWJhc2UuYzoxNzI1CiBtc2dpZCAic3dpdGNoIGBDJyBleHBlY3RzIGEgbnVtZXJpY2FsIHZhbHVlIgogbXNnc3RyICJmbGFnZ2FuIFwiQ1wiIGbDtnJ2w6RudGFyIGV0dCBudW1lcmlza3QgdsOkcmRlIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE3MzUKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTc2NgogIywgYy1mb3JtYXQKIG1zZ2lkICJVbmtub3duIG1vZGU6ICVzIgogbXNnc3RyICJPa8OkbnQgbMOkZ2U6ICVzIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE3NTcKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTc4OAogbXNnaWQgIi0tc3RyYXRlZ3kgcmVxdWlyZXMgLS1tZXJnZSBvciAtLWludGVyYWN0aXZlIgogbXNnc3RyICItLXN0cmF0ZWd5IGtyw6R2ZXIgLS1tZXJnZSBlbGxlciAtLWludGVyYWN0aXZlIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE3OTcKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTgyOAogbXNnaWQgIi0tcmVzY2hlZHVsZS1mYWlsZWQtZXhlYyByZXF1aXJlcyAtLWV4ZWMgb3IgLS1pbnRlcmFjdGl2ZSIKIG1zZ3N0ciAiLS1yZXNjaGVkdWxlLWZhaWxlZC1leGVjIGtyw6R2ZXIgLS1leGVjIGVsbGVyIC0taW50ZXJhY3RpdmUiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTgwOQorIzogYnVpbHRpbi9yZWJhc2UuYzoxODQwCiBtc2dpZCAiY2Fubm90IGNvbWJpbmUgYW0gb3B0aW9ucyB3aXRoIGVpdGhlciBpbnRlcmFjdGl2ZSBvciBtZXJnZSBvcHRpb25zIgogbXNnc3RyICIiCiAia2FuIGludGUga29tYmluZXJhIGFtLWZsYWdnb3IgbWVkIHZhcmtlbiBpbnRlcmFrdGl2LSBlbGxlciAiCiAic2FtbWFuc2xhZ25pbmdzZmxhZ2dvciIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxODI4CisjOiBidWlsdGluL3JlYmFzZS5jOjE4NTkKIG1zZ2lkICJjYW5ub3QgY29tYmluZSAnLS1wcmVzZXJ2ZS1tZXJnZXMnIHdpdGggJy0tcmViYXNlLW1lcmdlcyciCiBtc2dzdHIgImthbiBpbnRlIGtvbWJpbmVyYSBcIi0tcHJlc2VydmUtbWVyZ2VzXCIgbWVkIFwiLS1yZWJhc2UtbWVyZ2VzXCIiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTgzMgorIzogYnVpbHRpbi9yZWJhc2UuYzoxODYzCiBtc2dpZCAiIgogImVycm9yOiBjYW5ub3QgY29tYmluZSAnLS1wcmVzZXJ2ZS1tZXJnZXMnIHdpdGggJy0tcmVzY2hlZHVsZS1mYWlsZWQtZXhlYyciCiBtc2dzdHIgIiIKICJmZWw6IGthbiBpbnRlIGtvbWJpbmVyYSBcIi0tcHJlc2VydmUtbWVyZ2VzXCIgbWVkIFwiLS1yZXNjaGVkdWxlLWZhaWxlZC1leGVjIgogIlwiIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE4MzgKLW1zZ2lkICJjYW5ub3QgY29tYmluZSAnLS1yZWJhc2UtbWVyZ2VzJyB3aXRoICctLXN0cmF0ZWd5LW9wdGlvbiciCi1tc2dzdHIgImthbiBpbnRlIGtvbWJpbmVyYSBcIi0tcmViYXNlLW1lcmdlc1wiIG1lZCBcIi0tc3RyYXRlZ3ktb3B0aW9uXCIiCi0KLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTg0MQotbXNnaWQgImNhbm5vdCBjb21iaW5lICctLXJlYmFzZS1tZXJnZXMnIHdpdGggJy0tc3RyYXRlZ3knIgotbXNnc3RyICJrYW4gaW50ZSBrb21iaW5lcmEgXCItLXJlYmFzZS1tZXJnZXNcIiBtZWQgXCItLXN0cmF0ZWd5XCIiCi0KLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTg2NQorIzogYnVpbHRpbi9yZWJhc2UuYzoxODg3CiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgdXBzdHJlYW0gJyVzJyIKIG1zZ3N0ciAiZmVsYWt0aWcgdXBwc3Ryw7ZtIFwiJXNcIiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxODcxCisjOiBidWlsdGluL3JlYmFzZS5jOjE4OTMKIG1zZ2lkICJDb3VsZCBub3QgY3JlYXRlIG5ldyByb290IGNvbW1pdCIKIG1zZ3N0ciAia3VuZGUgaW50ZSBza2FwYSBueSByb3RpbmNoZWNrbmluZyIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxODg5CisjOiBidWlsdGluL3JlYmFzZS5jOjE5MTkKKyMsIGMtZm9ybWF0Cittc2dpZCAiJyVzJzogbmVlZCBleGFjdGx5IG9uZSBtZXJnZSBiYXNlIHdpdGggYnJhbmNoIgorbXNnc3RyICJcIiVzXCI6IGJlaMO2dmVyIHByZWNpcyBlbiBzYW1tYW5zbGFnbmluZ3NiYXMgbWVkIGdyZW4iCisKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTkyMgogIywgYy1mb3JtYXQKIG1zZ2lkICInJXMnOiBuZWVkIGV4YWN0bHkgb25lIG1lcmdlIGJhc2UiCiBtc2dzdHIgIlwiJXNcIjogYmVow7Z2ZXIgcHJlY2lzIGVuIHNhbW1hbnNsYWduaW5nc2JhcyIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxODk2CisjOiBidWlsdGluL3JlYmFzZS5jOjE5MzAKICMsIGMtZm9ybWF0CiBtc2dpZCAiRG9lcyBub3QgcG9pbnQgdG8gYSB2YWxpZCBjb21taXQgJyVzJyIKIG1zZ3N0ciAiUGVrYXIgaW50ZSBww6UgZW4gZ2lsdGlnIGluY2hlY2tuaW5nOiBcIiVzXCIiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTkyMQorIzogYnVpbHRpbi9yZWJhc2UuYzoxOTU1CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhdGFsOiBubyBzdWNoIGJyYW5jaC9jb21taXQgJyVzJyIKIG1zZ3N0ciAiw7ZkZXNkaWdlcnQ6IGluZ2VuIHPDpWRhbiBncmVuL2luY2hlY2tuaW5nOiBcIiVzXCIiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTkyOSBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6MzgKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTk2MyBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6MzgKICM6IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxOTM0CiAjLCBjLWZvcm1hdAogbXNnaWQgIk5vIHN1Y2ggcmVmOiAlcyIKIG1zZ3N0ciAiSW5nZW4gc8OlZGFuIHJlZmVyZW5zOiAlcyIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxOTQwCisjOiBidWlsdGluL3JlYmFzZS5jOjE5NzQKIG1zZ2lkICJDb3VsZCBub3QgcmVzb2x2ZSBIRUFEIHRvIGEgcmV2aXNpb24iCiBtc2dzdHIgIkt1bmRlIGludGUgYmVzdMOkbW1hIEhFQUQ6cyBpbmNoZWNrbmluZyIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxOTgxCisjOiBidWlsdGluL3JlYmFzZS5jOjIwMTIKIG1zZ2lkICJDYW5ub3QgYXV0b3N0YXNoIgogbXNnc3RyICJLYW4gaW50ZSB1dGbDtnJhIFwiYXV0b3N0YXNoXCIiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTk4NAorIzogYnVpbHRpbi9yZWJhc2UuYzoyMDE1CiAjLCBjLWZvcm1hdAogbXNnaWQgIlVuZXhwZWN0ZWQgc3Rhc2ggcmVzcG9uc2U6ICclcyciCiBtc2dzdHIgIk92w6RudGF0IHN2YXIgZnLDpW4gc3Rhc2g6IFwiJXNcIiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxOTkwCisjOiBidWlsdGluL3JlYmFzZS5jOjIwMjEKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ291bGQgbm90IGNyZWF0ZSBkaXJlY3RvcnkgZm9yICclcyciCiBtc2dzdHIgIkt1bmRlIGludGUgc2thcGEga2F0YWxvZyBmw7ZyIFwiJXNcIiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxOTkzCisjOiBidWlsdGluL3JlYmFzZS5jOjIwMjQKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ3JlYXRlZCBhdXRvc3Rhc2g6ICVzXG4iCiBtc2dzdHIgIlNrYXBhZGUgYXV0b3N0YXNoOiAlc1xuIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE5OTYKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MjAyNwogbXNnaWQgImNvdWxkIG5vdCByZXNldCAtLWhhcmQiCiBtc2dzdHIgImt1bmRlIGludGUgdXRmw7ZyYSBcInJlc2V0IC0taGFyZFwiIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE5OTcgYnVpbHRpbi9yZXNldC5jOjExNAotIywgYy1mb3JtYXQKLW1zZ2lkICJIRUFEIGlzIG5vdyBhdCAlcyIKLW1zZ3N0ciAiSEVBRCDDpHIgbnUgcMOlICVzIgotCi0jOiBidWlsdGluL3JlYmFzZS5jOjIwMTMKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MjAzNgogbXNnaWQgIlBsZWFzZSBjb21taXQgb3Igc3Rhc2ggdGhlbS4iCiBtc2dzdHIgIkNoZWNrYSBpbiBlbGxlciBhbnbDpG5kIFwic3Rhc2hcIiBww6UgZGVtLiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoyMDQwCisjOiBidWlsdGluL3JlYmFzZS5jOjIwNjMKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHBhcnNlICclcyciCiBtc2dzdHIgImt1bmRlIGludGUgdG9sa2EgXCIlc1wiIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjIwNTMKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MjA3NgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3Qgc3dpdGNoIHRvICVzIgogbXNnc3RyICJrdW5kZSBpbnRlIHbDpHhsYSB0aWxsICVzIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjIwNjQKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MjA4NwogbXNnaWQgIkhFQUQgaXMgdXAgdG8gZGF0ZS4iCiBtc2dzdHIgIkhFQUQgw6RyIMOgIGpvdXIuIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjIwNjYKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MjA4OQogIywgYy1mb3JtYXQKIG1zZ2lkICJDdXJyZW50IGJyYW5jaCAlcyBpcyB1cCB0byBkYXRlLlxuIgogbXNnc3RyICJBa3R1ZWxsIGdyZW4gJXMgw6RyIMOgIGpvdXIuXG4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MjA3NAorIzogYnVpbHRpbi9yZWJhc2UuYzoyMDk3CiBtc2dpZCAiSEVBRCBpcyB1cCB0byBkYXRlLCByZWJhc2UgZm9yY2VkLiIKIG1zZ3N0ciAiSEVBRCDDpHIgw6Agam91ciwgb21iYXNlcmluZyBmcmFtdHZpbmdhZC4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MjA3NgorIzogYnVpbHRpbi9yZWJhc2UuYzoyMDk5CiAjLCBjLWZvcm1hdAogbXNnaWQgIkN1cnJlbnQgYnJhbmNoICVzIGlzIHVwIHRvIGRhdGUsIHJlYmFzZSBmb3JjZWQuXG4iCiBtc2dzdHIgIkFrdHVlbGwgZ3JlbiAlcyDDpHIgw6Agam91ciwgb21iYXNlcmluZyBmcmFtdHZpbmdhZC5cbiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoyMDg0CisjOiBidWlsdGluL3JlYmFzZS5jOjIxMDcKIG1zZ2lkICJUaGUgcHJlLXJlYmFzZSBob29rIHJlZnVzZWQgdG8gcmViYXNlLiIKIG1zZ3N0ciAiS3Jva2VuIHByZS1yZWJhc2UgdsOkZ3JhZGUgb21iYXNlcmluZ2VuLiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoyMDkxCisjOiBidWlsdGluL3JlYmFzZS5jOjIxMTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ2hhbmdlcyB0byAlczpcbiIKIG1zZ3N0ciAiw4RuZHJpbmdhciB0aWxsICVzOlxuIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjIwOTQKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MjExNwogIywgYy1mb3JtYXQKIG1zZ2lkICJDaGFuZ2VzIGZyb20gJXMgdG8gJXM6XG4iCiBtc2dzdHIgIsOEbmRyaW5nYXIgZnLDpW4gJXMgdGlsbCAlczpcbiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoyMTE5CisjOiBidWlsdGluL3JlYmFzZS5jOjIxNDIKICMsIGMtZm9ybWF0CiBtc2dpZCAiRmlyc3QsIHJld2luZGluZyBoZWFkIHRvIHJlcGxheSB5b3VyIHdvcmsgb24gdG9wIG9mIGl0Li4uXG4iCiBtc2dzdHIgIiIKICJGw7Zyc3QsIHNwb2xhciB0aWxsYmFrYSBodXZ1ZGV0IGbDtnIgYXR0IHNwZWxhIGF2IGRpdHQgYXJiZXRlIG92YW5ww6UgZGV0Li4uXG4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MjEyOAorIzogYnVpbHRpbi9yZWJhc2UuYzoyMTUxCiBtc2dpZCAiQ291bGQgbm90IGRldGFjaCBIRUFEIgogbXNnc3RyICJLdW5kZSBpbnRlIGtvcHBsYSBmcsOlbiBIRUFEIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjIxMzcKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MjE2MAogIywgYy1mb3JtYXQKIG1zZ2lkICJGYXN0LWZvcndhcmRlZCAlcyB0byAlcy5cbiIKIG1zZ3N0ciAiU25hYmJzcG9sYWRlICVzIHRpbGwgJXMuXG4iCkBAIC0xNzYyNiw3ICsxNzY4OSw3IEBACiBtc2dpZCAiZ2l0IHJlY2VpdmUtcGFjayA8Z2l0LWRpcj4iCiBtc2dzdHIgImdpdCByZWNlaXZlLXBhY2sgPGdpdC1rYXRhbG9nPiIKIAotIzogYnVpbHRpbi9yZWNlaXZlLXBhY2suYzo4MzIKKyM6IGJ1aWx0aW4vcmVjZWl2ZS1wYWNrLmM6ODMwCiBtc2dpZCAiIgogIkJ5IGRlZmF1bHQsIHVwZGF0aW5nIHRoZSBjdXJyZW50IGJyYW5jaCBpbiBhIG5vbi1iYXJlIHJlcG9zaXRvcnlcbiIKICJpcyBkZW5pZWQsIGJlY2F1c2UgaXQgd2lsbCBtYWtlIHRoZSBpbmRleCBhbmQgd29yayB0cmVlIGluY29uc2lzdGVudFxuIgpAQCAtMTc2NTYsNyArMTc3MTksNyBAQAogIkbDtnIgYXR0IHVuZHZpa2EgZGV0dGEgbWVkZGVsYW5kZSBvY2ggZm9ydGZhcmFuZGUgYmVow6VsbGEgZGV0XG4iCiAibm9ybWFsYSBiZXRlZW5kZXQsIHPDpHR0IFwicmVjZWl2ZS5kZW55Q3VycmVudEJyYW5jaFwiIHRpbGwgXCJyZWZ1c2VcIi4iCiAKLSM6IGJ1aWx0aW4vcmVjZWl2ZS1wYWNrLmM6ODUyCisjOiBidWlsdGluL3JlY2VpdmUtcGFjay5jOjg1MAogbXNnaWQgIiIKICJCeSBkZWZhdWx0LCBkZWxldGluZyB0aGUgY3VycmVudCBicmFuY2ggaXMgZGVuaWVkLCBiZWNhdXNlIHRoZSBuZXh0XG4iCiAiJ2dpdCBjbG9uZScgd29uJ3QgcmVzdWx0IGluIGFueSBmaWxlIGNoZWNrZWQgb3V0LCBjYXVzaW5nIGNvbmZ1c2lvbi5cbiIKQEAgLTE3Njc3LDExICsxNzc0MCwxMSBAQAogIlxuIgogIkbDtnIgYXR0IHVuZHZpa2EgZGV0dGEgbWVkZGVsYW5kZSBrYW4gZHUgc8OkdHRhIGRldCB0aWxsIFwicmVmdXNlXCIuIgogCi0jOiBidWlsdGluL3JlY2VpdmUtcGFjay5jOjE5MzgKKyM6IGJ1aWx0aW4vcmVjZWl2ZS1wYWNrLmM6MTkzNgogbXNnaWQgInF1aWV0IgogbXNnc3RyICJ0eXN0IgogCi0jOiBidWlsdGluL3JlY2VpdmUtcGFjay5jOjE5NTIKKyM6IGJ1aWx0aW4vcmVjZWl2ZS1wYWNrLmM6MTk1MAogbXNnaWQgIllvdSBtdXN0IHNwZWNpZnkgYSBkaXJlY3RvcnkuIgogbXNnc3RyICJEdSBtw6VzdGUgYW5nZSBlbiBrYXRhbG9nLiIKIApAQCAtMTgyNTEsMTEgKzE4MzE0LDExIEBACiBtc2dpZCAiVW5rbm93biBzdWJjb21tYW5kOiAlcyIKIG1zZ3N0ciAiT2vDpG50IHVuZGVya29tbWFuZG86ICVzIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjIyCisjOiBidWlsdGluL3JlcGFjay5jOjIzCiBtc2dpZCAiZ2l0IHJlcGFjayBbPG9wdGlvbnM+XSIKIG1zZ3N0ciAiZ2l0IHJlcGFjayBbPGZsYWdnb3I+XSIKIAotIzogYnVpbHRpbi9yZXBhY2suYzoyNworIzogYnVpbHRpbi9yZXBhY2suYzoyOAogbXNnaWQgIiIKICJJbmNyZW1lbnRhbCByZXBhY2tzIGFyZSBpbmNvbXBhdGlibGUgd2l0aCBiaXRtYXAgaW5kZXhlcy4gIFVzZVxuIgogIi0tbm8td3JpdGUtYml0bWFwLWluZGV4IG9yIGRpc2FibGUgdGhlIHBhY2sud3JpdGViaXRtYXBzIGNvbmZpZ3VyYXRpb24uIgpAQCAtMTgyNjQsMTEyICsxODMyNywxMTIgQEAKICJBbnbDpG5kIC0tbm8td3JpdGUtYml0bWFwLWluZGV4IGVsbGVyIGluYWt0aXZlcmEgaW5zdMOkbGxuaW5nZW5cbiIKICJwYWNrLndyaXRlYml0bWFwcyIKIAotIzogYnVpbHRpbi9yZXBhY2suYzoyMDEKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6MTkxCiBtc2dpZCAiY291bGQgbm90IHN0YXJ0IHBhY2stb2JqZWN0cyB0byByZXBhY2sgcHJvbWlzb3Igb2JqZWN0cyIKIG1zZ3N0ciAia3VuZGUgaW50ZSBzdGFydGEgcGFjay1vYmplY3RzIGbDtnIgYXR0IHBhY2thIG9tIGtvbnRyYWt0c29iamVrdCIKIAotIzogYnVpbHRpbi9yZXBhY2suYzoyNDAgYnVpbHRpbi9yZXBhY2suYzo0MTgKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6MjMwIGJ1aWx0aW4vcmVwYWNrLmM6NDA5CiBtc2dpZCAicmVwYWNrOiBFeHBlY3RpbmcgZnVsbCBoZXggb2JqZWN0IElEIGxpbmVzIG9ubHkgZnJvbSBwYWNrLW9iamVjdHMuIgogbXNnc3RyICIiCi0icmVwYWNrOiBGw7ZydsOkbnRhciBrb21wbGV0dGEgaGV4LW9iamVrdC1JRC1yYWRlciBlbmRhc3QgZnLDpW4gcGFjay1vYmplY3RzLiIKKyJyZXBhY2s6IEbDtnJ2w6RudGFyIGtvbXBsZXR0YSBoZXgtb2JqZWt0LWlkLXJhZGVyIGVuZGFzdCBmcsOlbiBwYWNrLW9iamVjdHMuIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjI1NworIzogYnVpbHRpbi9yZXBhY2suYzoyNDcKIG1zZ2lkICJjb3VsZCBub3QgZmluaXNoIHBhY2stb2JqZWN0cyB0byByZXBhY2sgcHJvbWlzb3Igb2JqZWN0cyIKIG1zZ3N0ciAia3VuZGUgaW50ZSBhdnNsdXRhIHBhY2stb2JqZWN0cyBmw7ZyIGF0dCBwYWNrYSBvbSBrb250cmFrdHNvYmpla3QiCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6Mjk1CisjOiBidWlsdGluL3JlcGFjay5jOjI4NQogbXNnaWQgInBhY2sgZXZlcnl0aGluZyBpbiBhIHNpbmdsZSBwYWNrIgogbXNnc3RyICJwYWNrYSBhbGx0IGkgZXR0IGVuZGEgcGFrZXQiCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6Mjk3CisjOiBidWlsdGluL3JlcGFjay5jOjI4NwogbXNnaWQgInNhbWUgYXMgLWEsIGFuZCB0dXJuIHVucmVhY2hhYmxlIG9iamVjdHMgbG9vc2UiCiBtc2dzdHIgInNhbW1hIHNvbSAtYSwgb2NoIGfDtnIgb27DpWJhcmEgb2JqZWt0IGzDtnNhIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjMwMAorIzogYnVpbHRpbi9yZXBhY2suYzoyOTAKIG1zZ2lkICJyZW1vdmUgcmVkdW5kYW50IHBhY2tzLCBhbmQgcnVuIGdpdC1wcnVuZS1wYWNrZWQiCiBtc2dzdHIgInRhIGJvcnQgw7Z2ZXJmbMO2ZGlnYSBwYWtldCwgb2NoIGvDtnIgZ2l0LXBydW5lLXBhY2tlZCIKIAotIzogYnVpbHRpbi9yZXBhY2suYzozMDIKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6MjkyCiBtc2dpZCAicGFzcyAtLW5vLXJldXNlLWRlbHRhIHRvIGdpdC1wYWNrLW9iamVjdHMiCiBtc2dzdHIgInPDpG5kIC0tbm8tcmV1c2UtZGVsdGEgdGlsbCBnaXQtcGFjay1vYmplY3RzIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjMwNAorIzogYnVpbHRpbi9yZXBhY2suYzoyOTQKIG1zZ2lkICJwYXNzIC0tbm8tcmV1c2Utb2JqZWN0IHRvIGdpdC1wYWNrLW9iamVjdHMiCiBtc2dzdHIgInPDpG5kIC0tbm8tcmV1c2Utb2JqZWN0IHRpbGwgZ2l0LXBhY2stb2JqZWN0cyIKIAotIzogYnVpbHRpbi9yZXBhY2suYzozMDYKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6Mjk2CiBtc2dpZCAiZG8gbm90IHJ1biBnaXQtdXBkYXRlLXNlcnZlci1pbmZvIgogbXNnc3RyICJrw7ZyIGludGUgZ2l0LXVwZGF0ZS1zZXJ2ZXItaW5mbyIKIAotIzogYnVpbHRpbi9yZXBhY2suYzozMDkKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6Mjk5CiBtc2dpZCAicGFzcyAtLWxvY2FsIHRvIGdpdC1wYWNrLW9iamVjdHMiCiBtc2dzdHIgInPDpG5kIC0tbG9jYWwgdGlsbCBnaXQtcGFjay1vYmplY3RzIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjMxMQorIzogYnVpbHRpbi9yZXBhY2suYzozMDEKIG1zZ2lkICJ3cml0ZSBiaXRtYXAgaW5kZXgiCiBtc2dzdHIgInNrcml2IGJpdGthcnRpbmRleCIKIAotIzogYnVpbHRpbi9yZXBhY2suYzozMTMKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6MzAzCiBtc2dpZCAicGFzcyAtLWRlbHRhLWlzbGFuZHMgdG8gZ2l0LXBhY2stb2JqZWN0cyIKIG1zZ3N0ciAic8OkbmQgLS1kZWx0YS1pc2xhbmRzIHRpbGwgZ2l0LXBhY2stb2JqZWN0cyIKIAotIzogYnVpbHRpbi9yZXBhY2suYzozMTQKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6MzA0CiBtc2dpZCAiYXBwcm94aWRhdGUiCiBtc2dzdHIgImNpcmthZGF0dW0iCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MzE1CisjOiBidWlsdGluL3JlcGFjay5jOjMwNQogbXNnaWQgIndpdGggLUEsIGRvIG5vdCBsb29zZW4gb2JqZWN0cyBvbGRlciB0aGFuIHRoaXMiCiBtc2dzdHIgIm1lZCAtQSwgbMO2cyBpbnRlIHVwcCBvYmpla3Qgw6RsZHJlIMOkbiBkZXR0YSIKIAotIzogYnVpbHRpbi9yZXBhY2suYzozMTcKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6MzA3CiBtc2dpZCAid2l0aCAtYSwgcmVwYWNrIHVucmVhY2hhYmxlIG9iamVjdHMiCiBtc2dzdHIgIm1lZCAtYSwgcGFja2Egb20gb27DpWJhcmEgb2JqZWt0IgogCi0jOiBidWlsdGluL3JlcGFjay5jOjMxOQorIzogYnVpbHRpbi9yZXBhY2suYzozMDkKIG1zZ2lkICJzaXplIG9mIHRoZSB3aW5kb3cgdXNlZCBmb3IgZGVsdGEgY29tcHJlc3Npb24iCiBtc2dzdHIgInN0b3JsZWsgcMOlIGbDtm5zdGVyIGFudsOkbnQgZsO2ciBkZWx0YWtvbXByaW1lcmluZyIKIAotIzogYnVpbHRpbi9yZXBhY2suYzozMjAgYnVpbHRpbi9yZXBhY2suYzozMjYKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6MzEwIGJ1aWx0aW4vcmVwYWNrLmM6MzE2CiBtc2dpZCAiYnl0ZXMiCiBtc2dzdHIgImJ5dGUiCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MzIxCisjOiBidWlsdGluL3JlcGFjay5jOjMxMQogbXNnaWQgInNhbWUgYXMgdGhlIGFib3ZlLCBidXQgbGltaXQgbWVtb3J5IHNpemUgaW5zdGVhZCBvZiBlbnRyaWVzIGNvdW50IgogbXNnc3RyICJzYW1tYSBzb20gb3ZhbiwgbWVuIGJlZ3LDpG5zYSBtaW5uZXNzdG9ybGVrZW4gaXN0w6RsbGV0IGbDtnIgcG9zdGFudGFsIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjMyMworIzogYnVpbHRpbi9yZXBhY2suYzozMTMKIG1zZ2lkICJsaW1pdHMgdGhlIG1heGltdW0gZGVsdGEgZGVwdGgiCiBtc2dzdHIgImJlZ3LDpG5zYSBtYXhpbWFsdCBkZWx0YWRqdXAiCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MzI1CisjOiBidWlsdGluL3JlcGFjay5jOjMxNQogbXNnaWQgImxpbWl0cyB0aGUgbWF4aW11bSBudW1iZXIgb2YgdGhyZWFkcyIKIG1zZ3N0ciAiYmVncsOkbnNhciBtYXhpbWFsdCBhbnRhbCB0csOlZGFyIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjMyNworIzogYnVpbHRpbi9yZXBhY2suYzozMTcKIG1zZ2lkICJtYXhpbXVtIHNpemUgb2YgZWFjaCBwYWNrZmlsZSIKIG1zZ3N0ciAibWF4aW1hbCBzdG9ybGVrIHDDpSB2YXJqZSBwYWtldGZpbCIKIAotIzogYnVpbHRpbi9yZXBhY2suYzozMjkKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6MzE5CiBtc2dpZCAicmVwYWNrIG9iamVjdHMgaW4gcGFja3MgbWFya2VkIHdpdGggLmtlZXAiCiBtc2dzdHIgInBhY2thIG9tIG9iamVrdCBpIHBha2V0IG3DpHJrdGEgbWVkIC5rZWVwIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjMzMQorIzogYnVpbHRpbi9yZXBhY2suYzozMjEKIG1zZ2lkICJkbyBub3QgcmVwYWNrIHRoaXMgcGFjayIKIG1zZ3N0ciAicGFja2EgaW50ZSBvbSBkZXR0YSBwYWtldCIKIAotIzogYnVpbHRpbi9yZXBhY2suYzozNDEKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6MzMxCiBtc2dpZCAiY2Fubm90IGRlbGV0ZSBwYWNrcyBpbiBhIHByZWNpb3VzLW9iamVjdHMgcmVwbyIKIG1zZ3N0ciAia2FuIGludGUgdGEgYm9ydCBwYWtldCBpIGV0dCBcInByZWNpb3VzLW9iamVjdHNcIi1hcmtpdiIKIAotIzogYnVpbHRpbi9yZXBhY2suYzozNDUKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6MzM1CiBtc2dpZCAiLS1rZWVwLXVucmVhY2hhYmxlIGFuZCAtQSBhcmUgaW5jb21wYXRpYmxlIgogbXNnc3RyICItLWtlZXAtdW5yZWFjaGFibGUgb2NoIC1BIGthbiBpbnRlIGFudsOkbmRhcyBzYW10aWRpZ3QiCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6NDI3CisjOiBidWlsdGluL3JlcGFjay5jOjQxOAogbXNnaWQgIk5vdGhpbmcgbmV3IHRvIHBhY2suIgogbXNnc3RyICJJbmdldCBueXR0IGF0dCBwYWNrYS4iCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6NDg4CisjOiBidWlsdGluL3JlcGFjay5jOjQ3OQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiV0FSTklORzogU29tZSBwYWNrcyBpbiB1c2UgaGF2ZSBiZWVuIHJlbmFtZWQgYnlcbiIKQEAgLTE4Mzg4LDcgKzE4NDUxLDcgQEAKICJWQVJOSU5HOiBuYW1uZXQgbWlzc2x5Y2thZGVzIG9ja3PDpS5cbiIKICJWQVJOSU5HOiBCeXQgbmFtbiBww6UgZGVtIGkgJXMgbWFudWVsbHQ6XG4iCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6NTM2CisjOiBidWlsdGluL3JlcGFjay5jOjUyNwogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gcmVtb3ZlICclcyciCiBtc2dzdHIgIm1pc3NseWNrYWRlcyB0YSBib3J0IFwiJXNcIiIKQEAgLTE4NDk2LDggKzE4NTU5LDggQEAKIG1zZ2lkICJ1bmFibGUgdG8gd3JpdGUgb2JqZWN0IHRvIGRhdGFiYXNlIgogbXNnc3RyICJrYW4gaW50ZSBza3JpdmEgb2JqZWt0ZXQgdGlsbCBkYXRhYmFzZW4iCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjMyMiBidWlsdGluL3JlcGxhY2UuYzozNzcgYnVpbHRpbi9yZXBsYWNlLmM6NDIyCi0jOiBidWlsdGluL3JlcGxhY2UuYzo0NTIKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjMyMiBidWlsdGluL3JlcGxhY2UuYzozNzggYnVpbHRpbi9yZXBsYWNlLmM6NDIzCisjOiBidWlsdGluL3JlcGxhY2UuYzo0NTMKICMsIGMtZm9ybWF0CiBtc2dpZCAibm90IGEgdmFsaWQgb2JqZWN0IG5hbWU6ICclcyciCiBtc2dzdHIgIm9iamVrdG5hbW5ldCDDpHIgaW50ZSBnaWx0aWd0OiBcIiVzXCIiCkBAIC0xODUxNiwyMiArMTg1NzksMjIgQEAKIG1zZ2lkICJuZXcgb2JqZWN0IGlzIHRoZSBzYW1lIGFzIHRoZSBvbGQgb25lOiAnJXMnIgogbXNnc3RyICJueXR0IG9iamVrdCDDpHIgc2FtbWEgc29tIGRldCBnYW1sYTogXCIlc1wiIgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzozODMKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjM4NAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcGFyc2UgJXMgYXMgYSBjb21taXQiCiBtc2dzdHIgImt1bmRlIGludGUgdG9sa2EgJXMgc29tIGluY2hlY2tuaW5nIgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo0MTQKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjQxNQogIywgYy1mb3JtYXQKIG1zZ2lkICJiYWQgbWVyZ2V0YWcgaW4gY29tbWl0ICclcyciCiBtc2dzdHIgImZlbGFrdGlnIHNhbW1hbnNsYWduaW5nc3RhZ2cgaSBpbmNoZWNrbmluZ2VuIFwiJXNcIiIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NDE2CisjOiBidWlsdGluL3JlcGxhY2UuYzo0MTcKICMsIGMtZm9ybWF0CiBtc2dpZCAibWFsZm9ybWVkIG1lcmdldGFnIGluIGNvbW1pdCAnJXMnIgogbXNnc3RyICJmZWxmb3JtYWQgc2FtbWFuc2xhZ25pbmdzdGFnZyBpIGluY2hlY2tuaW5nZW4gXCIlc1wiIgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo0MjgKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjQyOQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAib3JpZ2luYWwgY29tbWl0ICclcycgY29udGFpbnMgbWVyZ2V0YWcgJyVzJyB0aGF0IGlzIGRpc2NhcmRlZDsgdXNlIC0tZWRpdCAiCkBAIC0xODU0MCwzMSArMTg2MDMsMzEgQEAKICJkZW4gdXJzcHJ1bmdsaWdhIGluY2hlY2tuaW5nZW4gXCIlc1wiIGlubmVow6VsbGVyIHNhbW1hbnNsYWduaW5nc3RhZ2dlbiBcIiVzIgogIlwiIHNvbSBoYXIgZsO2cmthc3RhdHM7IGFudsOkbmQgLS1lZGl0IGlzdMOkbGxldCBmw7ZyIC0tZ3JhZnQiCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjQ2NworIzogYnVpbHRpbi9yZXBsYWNlLmM6NDY4CiAjLCBjLWZvcm1hdAogbXNnaWQgInRoZSBvcmlnaW5hbCBjb21taXQgJyVzJyBoYXMgYSBncGcgc2lnbmF0dXJlIgogbXNnc3RyICJkZW4gdXJzcHJ1bmdsaWdhIGluY2hlY2tuaW5nZW4gXCIlc1wiIGhhciBlbiBncGctc2lnbmF0dXIiCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjQ2OAorIzogYnVpbHRpbi9yZXBsYWNlLmM6NDY5CiBtc2dpZCAidGhlIHNpZ25hdHVyZSB3aWxsIGJlIHJlbW92ZWQgaW4gdGhlIHJlcGxhY2VtZW50IGNvbW1pdCEiCiBtc2dzdHIgInNpZ25hdHVyZW4ga29tbWVyIGF0dCB0YXMgYm9ydCBpIGVyc8OkdHRuaW5nc2luY2hlY2tuaW5nZW4hIgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo0NzgKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjQ3OQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3Qgd3JpdGUgcmVwbGFjZW1lbnQgY29tbWl0IGZvcjogJyVzJyIKIG1zZ3N0ciAia3VuZGUgaW50ZSBza3JpdmEgZXJzw6R0dG5pbmdzaW5jaGVja25pbmcgZsO2cjogXCIlc1wiIgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo0ODYKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjQ4NwogIywgYy1mb3JtYXQKIG1zZ2lkICJncmFmdCBmb3IgJyVzJyB1bm5lY2Vzc2FyeSIKIG1zZ3N0ciAieW1wbmluZyBmw7ZyIFwiJXNcIiBiZWjDtnZzIGludGUiCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjQ5MAorIzogYnVpbHRpbi9yZXBsYWNlLmM6NDkxCiAjLCBjLWZvcm1hdAogbXNnaWQgIm5ldyBjb21taXQgaXMgdGhlIHNhbWUgYXMgdGhlIG9sZCBvbmU6ICclcyciCiBtc2dzdHIgIm55IGluY2hlY2tuaW5nIMOkciBzYW1tYSBzb20gZGVuIGdhbWxhOiBcIiVzXCIiCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjUyNQorIzogYnVpbHRpbi9yZXBsYWNlLmM6NTI2CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJjb3VsZCBub3QgY29udmVydCB0aGUgZm9sbG93aW5nIGdyYWZ0KHMpOlxuIgpAQCAtMTg1NzMsNzEgKzE4NjM2LDcxIEBACiAia3VuZGUgaW50ZSBrb252ZXJ0ZXJhIGbDtmxqYW5kZSB5bXBuaW5nKGFyKTpcbiIKICIlcyIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NTQ2CisjOiBidWlsdGluL3JlcGxhY2UuYzo1NDcKIG1zZ2lkICJsaXN0IHJlcGxhY2UgcmVmcyIKIG1zZ3N0ciAidmlzYSBlcnPDpHR0bmluZ3NyZWZlcmVuc2VyIgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo1NDcKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU0OAogbXNnaWQgImRlbGV0ZSByZXBsYWNlIHJlZnMiCiBtc2dzdHIgInRhIGJvcnQgZXJzw6R0dG5pbmdzcmVmZXJlbnNlciIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NTQ4CisjOiBidWlsdGluL3JlcGxhY2UuYzo1NDkKIG1zZ2lkICJlZGl0IGV4aXN0aW5nIG9iamVjdCIKIG1zZ3N0ciAicmVkaWdlcmEgYmVmaW50bGlndCBvYmpla3QiCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU0OQorIzogYnVpbHRpbi9yZXBsYWNlLmM6NTUwCiBtc2dpZCAiY2hhbmdlIGEgY29tbWl0J3MgcGFyZW50cyIKIG1zZ3N0ciAiw6RuZHJhIGVuIGluY2hlY2tuaW5ncyBmw7Zyw6RsZHJhciIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NTUwCisjOiBidWlsdGluL3JlcGxhY2UuYzo1NTEKIG1zZ2lkICJjb252ZXJ0IGV4aXN0aW5nIGdyYWZ0IGZpbGUiCiBtc2dzdHIgImtvbnZlcnRlcmEgYmVmaW50bGlnIHltcG5pbmdzZmlsIgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo1NTEKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU1MgogbXNnaWQgInJlcGxhY2UgdGhlIHJlZiBpZiBpdCBleGlzdHMiCiBtc2dzdHIgImVyc8OkdHQgcmVmZXJlbnNlbiBvbSBkZW4gZmlubnMiCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU1MworIzogYnVpbHRpbi9yZXBsYWNlLmM6NTU0CiBtc2dpZCAiZG8gbm90IHByZXR0eS1wcmludCBjb250ZW50cyBmb3IgLS1lZGl0IgogbXNnc3RyICJhbnbDpG5kIGludGUgc255Z2cgdmlzbmluZyBhdiBpbm5laMOlbGwgZsO2ciAtLWVkaXQiCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU1NAorIzogYnVpbHRpbi9yZXBsYWNlLmM6NTU1CiBtc2dpZCAidXNlIHRoaXMgZm9ybWF0IgogbXNnc3RyICJhbnbDpG5kIGRldHRhIGZvcm1hdCIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NTY3CisjOiBidWlsdGluL3JlcGxhY2UuYzo1NjgKIG1zZ2lkICItLWZvcm1hdCBjYW5ub3QgYmUgdXNlZCB3aGVuIG5vdCBsaXN0aW5nIgogbXNnc3RyICItLWZvcm1hdCBrYW4gaW50ZSBhbnbDpG5kYXMgdXRhbmbDtnIgbGlzdG5pbmciCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU3NQorIzogYnVpbHRpbi9yZXBsYWNlLmM6NTc2CiBtc2dpZCAiLWYgb25seSBtYWtlcyBzZW5zZSB3aGVuIHdyaXRpbmcgYSByZXBsYWNlbWVudCIKIG1zZ3N0ciAiLWYga2FuIGVuZGFzdCBhbnbDpG5kYXMgdmlkIHNrcml2bmluZyBhdiBlcnPDpHR0bmluZyIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NTc5CisjOiBidWlsdGluL3JlcGxhY2UuYzo1ODAKIG1zZ2lkICItLXJhdyBvbmx5IG1ha2VzIHNlbnNlIHdpdGggLS1lZGl0IgogbXNnc3RyICItLXJhdyBrYW4gYmFyYSBhbnbDpG5kYXMgbWVkIC0tZWRpdCIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NTg1CisjOiBidWlsdGluL3JlcGxhY2UuYzo1ODYKIG1zZ2lkICItZCBuZWVkcyBhdCBsZWFzdCBvbmUgYXJndW1lbnQiCiBtc2dzdHIgIi1kIGJlaMO2dmVyIG1pbnN0IGV0dCBhcmd1bWVudCIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NTkxCisjOiBidWlsdGluL3JlcGxhY2UuYzo1OTIKIG1zZ2lkICJiYWQgbnVtYmVyIG9mIGFyZ3VtZW50cyIKIG1zZ3N0ciAiZmVsIGFudGFsIGFyZ3VtZW50IgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo1OTcKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU5OAogbXNnaWQgIi1lIG5lZWRzIGV4YWN0bHkgb25lIGFyZ3VtZW50IgogbXNnc3RyICItZSB0YXIgZXhha3QgZXR0IGFyZ3VtZW50IgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo2MDMKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjYwNAogbXNnaWQgIi1nIG5lZWRzIGF0IGxlYXN0IG9uZSBhcmd1bWVudCIKIG1zZ3N0ciAiLWcgdGFyIG1pbnN0IGV0dCBhcmd1bWVudCIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NjA5CisjOiBidWlsdGluL3JlcGxhY2UuYzo2MTAKIG1zZ2lkICItLWNvbnZlcnQtZ3JhZnQtZmlsZSB0YWtlcyBubyBhcmd1bWVudCIKIG1zZ3N0ciAiLS1jb252ZXJ0LWdyYWZ0LWZpbGUgdGFyIGluZ2EgYXJndW1lbnQiCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjYxNQorIzogYnVpbHRpbi9yZXBsYWNlLmM6NjE2CiBtc2dpZCAib25seSBvbmUgcGF0dGVybiBjYW4gYmUgZ2l2ZW4gd2l0aCAtbCIKIG1zZ3N0ciAiZW5kYXN0IGV0dCBtw7Zuc3RlciBrYW4gYW5nZXMgbWVkIC1sIgogCkBAIC0xODcwNSwxMyArMTg3NjgsMTggQEAKIG1zZ2lkICJGYWlsZWQgdG8gZmluZCB0cmVlIG9mICVzLiIKIG1zZ3N0ciAiS3VuZGUgaW50ZSBoaXR0YSB0csOkZGV0IGbDtnIgJXMuIgogCisjOiBidWlsdGluL3Jlc2V0LmM6MTE0CisjLCBjLWZvcm1hdAorbXNnaWQgIkhFQUQgaXMgbm93IGF0ICVzIgorbXNnc3RyICJIRUFEIMOkciBudSBww6UgJXMiCisKICM6IGJ1aWx0aW4vcmVzZXQuYzoxOTMKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ2Fubm90IGRvIGEgJXMgcmVzZXQgaW4gdGhlIG1pZGRsZSBvZiBhIG1lcmdlLiIKIG1zZ3N0ciAiS2FuIGludGUgdXRmw7ZyYSBlbiAlcyDDpXRlcnN0w6RsbG5pbmcgbWl0dCBpIGVuIHNhbW1hbnNsYWduaW5nLiIKIAotIzogYnVpbHRpbi9yZXNldC5jOjI5MyBidWlsdGluL3N0YXNoLmM6NTE0IGJ1aWx0aW4vc3Rhc2guYzo1ODkKLSM6IGJ1aWx0aW4vc3Rhc2guYzo2MTMKKyM6IGJ1aWx0aW4vcmVzZXQuYzoyOTMgYnVpbHRpbi9zdGFzaC5jOjUyMCBidWlsdGluL3N0YXNoLmM6NTk1CisjOiBidWlsdGluL3N0YXNoLmM6NjE5CiBtc2dpZCAiYmUgcXVpZXQsIG9ubHkgcmVwb3J0IGVycm9ycyIKIG1zZ3N0ciAidmFyIHR5c3QsIHJhcHBvcnRlcmEgZW5kYXN0IGZlbCIKIApAQCAtMTg3OTUsMjQgKzE4ODYzLDE5IEBACiBtc2dpZCAiQ291bGQgbm90IHdyaXRlIG5ldyBpbmRleCBmaWxlLiIKIG1zZ3N0ciAiS3VuZGUgaW50ZSBza3JpdmEgbnkgaW5kZXhmaWwuIgogCi0jOiBidWlsdGluL3Jldi1saXN0LmM6NDEyCisjOiBidWlsdGluL3Jldi1saXN0LmM6NDExCiBtc2dpZCAiY2Fubm90IGNvbWJpbmUgLS1leGNsdWRlLXByb21pc29yLW9iamVjdHMgYW5kIC0tbWlzc2luZyIKIG1zZ3N0ciAia2FuIGludGUga29tYmluZXJhIC0tZXhjbHVkZS1wcm9taXNvci1vYmplY3RzIG9jaCAtLW1pc3NpbmciCiAKLSM6IGJ1aWx0aW4vcmV2LWxpc3QuYzo0NzMKKyM6IGJ1aWx0aW4vcmV2LWxpc3QuYzo0NzIKIG1zZ2lkICJvYmplY3QgZmlsdGVyaW5nIHJlcXVpcmVzIC0tb2JqZWN0cyIKIG1zZ3N0ciAib2JqZWt0ZmlsdHJlcmluZyBrcsOkdmVyIC0tb2JqZWN0cyIKIAotIzogYnVpbHRpbi9yZXYtbGlzdC5jOjQ3NgotIywgYy1mb3JtYXQKLW1zZ2lkICJpbnZhbGlkIHNwYXJzZSB2YWx1ZSAnJXMnIgotbXNnc3RyICJvZ2lsdGlndCB2w6RyZGUgZsO2ciBzcGFyc2U6IFwiJXNcIiIKLQotIzogYnVpbHRpbi9yZXYtbGlzdC5jOjUyNworIzogYnVpbHRpbi9yZXYtbGlzdC5jOjUyMgogbXNnaWQgInJldi1saXN0IGRvZXMgbm90IHN1cHBvcnQgZGlzcGxheSBvZiBub3RlcyIKIG1zZ3N0ciAicmV2LWxpc3Qgc3TDtmRlciBpbnRlIHZpc25pbmcgYXYgYW50ZWNrbmluZ2FyIgogCi0jOiBidWlsdGluL3Jldi1saXN0LmM6NTMwCisjOiBidWlsdGluL3Jldi1saXN0LmM6NTI1CiBtc2dpZCAiY2Fubm90IGNvbWJpbmUgLS11c2UtYml0bWFwLWluZGV4IHdpdGggb2JqZWN0IGZpbHRlcmluZyIKIG1zZ3N0ciAia2FuIGludGUga29tYmluZXJhIC0tdXNlLWJpdG1hcC1pbmRleCBtZWQgb2JqZWt0ZmlsdHJlcmluZyIKIApAQCAtMTkzNTAsMTM0ICsxOTQxMywxMzQgQEAKIG1zZ2lkICJjb3VsZCBub3Qgc2F2ZSBpbmRleCB0cmVlIgogbXNnc3RyICJrdW5kZSBpbnRlIHNwYXJhIGluZGV4dHLDpGQiCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzo0MzQKKyM6IGJ1aWx0aW4vc3Rhc2guYzo0MzYKIG1zZ2lkICJjb3VsZCBub3QgcmVzdG9yZSB1bnRyYWNrZWQgZmlsZXMgZnJvbSBzdGFzaCIKIG1zZ3N0ciAia3VuZGUgaW50ZSDDpXRlcnN0w6RsbGEgb3Nww6VyYWRlIGZpbGVyIGZyw6VuIHN0YXNoLXBvc3QiCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzo0NDgKKyM6IGJ1aWx0aW4vc3Rhc2guYzo0NTAKICMsIGMtZm9ybWF0CiBtc2dpZCAiTWVyZ2luZyAlcyB3aXRoICVzIgogbXNnc3RyICJTbMOlciBpaG9wICVzIG1lZCAlcyIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjQ1OCBnaXQtbGVnYWN5LXN0YXNoLnNoOjY4MAorIzogYnVpbHRpbi9zdGFzaC5jOjQ2MCBnaXQtbGVnYWN5LXN0YXNoLnNoOjY4MAogbXNnaWQgIkluZGV4IHdhcyBub3QgdW5zdGFzaGVkLiIKIG1zZ3N0ciAiSW5kZXhldCBoYXIgaW50ZSB0YWdpdHMgdXBwIHVyIFwic3Rhc2hcIjplbiIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjUxNiBidWlsdGluL3N0YXNoLmM6NjE1CisjOiBidWlsdGluL3N0YXNoLmM6NTIyIGJ1aWx0aW4vc3Rhc2guYzo2MjEKIG1zZ2lkICJhdHRlbXB0IHRvIHJlY3JlYXRlIHRoZSBpbmRleCIKIG1zZ3N0ciAiZsO2cnPDtmsgw6V0ZXJza2FwYSBpbmRleGV0IgogCi0jOiBidWlsdGluL3N0YXNoLmM6NTQ5CisjOiBidWlsdGluL3N0YXNoLmM6NTU1CiAjLCBjLWZvcm1hdAogbXNnaWQgIkRyb3BwZWQgJXMgKCVzKSIKIG1zZ3N0ciAiS2FzdGFkZSAlcyAoJXMpIgogCi0jOiBidWlsdGluL3N0YXNoLmM6NTUyCisjOiBidWlsdGluL3N0YXNoLmM6NTU4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiBDb3VsZCBub3QgZHJvcCBzdGFzaCBlbnRyeSIKIG1zZ3N0ciAiJXM6IEt1bmRlIGludGUga2FzdGEgXCJzdGFzaFwiLXBvc3QiCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzo1NzcKKyM6IGJ1aWx0aW4vc3Rhc2guYzo1ODMKICMsIGMtZm9ybWF0CiBtc2dpZCAiJyVzJyBpcyBub3QgYSBzdGFzaCByZWZlcmVuY2UiCiBtc2dzdHIgIlwiJXNcIiDDpHIgaW50ZSBlbiBcInN0YXNoXCItcmVmZXJlbnMiCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzo2MjcgZ2l0LWxlZ2FjeS1zdGFzaC5zaDo2OTQKKyM6IGJ1aWx0aW4vc3Rhc2guYzo2MzMgZ2l0LWxlZ2FjeS1zdGFzaC5zaDo2OTQKIG1zZ2lkICJUaGUgc3Rhc2ggZW50cnkgaXMga2VwdCBpbiBjYXNlIHlvdSBuZWVkIGl0IGFnYWluLiIKIG1zZ3N0ciAiU3Rhc2gtcG9zdGVuIGJlaMOlbGxzIGlmYWxsIGR1IGJlaMO2dmVyIGRlbiBpZ2VuLiIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjY1MCBnaXQtbGVnYWN5LXN0YXNoLnNoOjcxMgorIzogYnVpbHRpbi9zdGFzaC5jOjY1NiBnaXQtbGVnYWN5LXN0YXNoLnNoOjcxMgogbXNnaWQgIk5vIGJyYW5jaCBuYW1lIHNwZWNpZmllZCIKIG1zZ3N0ciAiSW5nZXQgZ3Jlbm5hbW4gYW5nYXZzIgogCi0jOiBidWlsdGluL3N0YXNoLmM6NzkwIGJ1aWx0aW4vc3Rhc2guYzo4MjcKKyM6IGJ1aWx0aW4vc3Rhc2guYzo3OTYgYnVpbHRpbi9zdGFzaC5jOjgzMwogIywgYy1mb3JtYXQKIG1zZ2lkICJDYW5ub3QgdXBkYXRlICVzIHdpdGggJXMiCiBtc2dzdHIgIkthbiBpbnRlIHVwcGRhdGVyYSAlcyBtZWQgJXMiCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzo4MDggYnVpbHRpbi9zdGFzaC5jOjE0NjEgYnVpbHRpbi9zdGFzaC5jOjE0OTcKKyM6IGJ1aWx0aW4vc3Rhc2guYzo4MTQgYnVpbHRpbi9zdGFzaC5jOjE0NzAgYnVpbHRpbi9zdGFzaC5jOjE1MDYKIG1zZ2lkICJzdGFzaCBtZXNzYWdlIgogbXNnc3RyICJcInN0YXNoXCItbWVkZGVsYW5kZSIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjgxOAorIzogYnVpbHRpbi9zdGFzaC5jOjgyNAogbXNnaWQgIlwiZ2l0IHN0YXNoIHN0b3JlXCIgcmVxdWlyZXMgb25lIDxjb21taXQ+IGFyZ3VtZW50IgogbXNnc3RyICJcImdpdCBzdGFzaCBzdG9yZVwiIGtyw6R2ZXIgZXR0IDxpbmNoZWNrbmluZz4tYXJndW1lbnQiCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzoxMDQwIGdpdC1sZWdhY3ktc3Rhc2guc2g6MjE3CisjOiBidWlsdGluL3N0YXNoLmM6MTA0NiBnaXQtbGVnYWN5LXN0YXNoLnNoOjIxNwogbXNnaWQgIk5vIGNoYW5nZXMgc2VsZWN0ZWQiCiBtc2dzdHIgIkluZ2Egw6RuZHJpbmdhciB2YWxkYSIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjExMzYgZ2l0LWxlZ2FjeS1zdGFzaC5zaDoxNTAKKyM6IGJ1aWx0aW4vc3Rhc2guYzoxMTQ1IGdpdC1sZWdhY3ktc3Rhc2guc2g6MTUwCiBtc2dpZCAiWW91IGRvIG5vdCBoYXZlIHRoZSBpbml0aWFsIGNvbW1pdCB5ZXQiCiBtc2dzdHIgIkR1IGhhciBpbnRlIGRlbiBmw7Zyc3RhIGluY2hlY2tuaW5nZW4gw6RubnUiCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzoxMTYzIGdpdC1sZWdhY3ktc3Rhc2guc2g6MTY1CisjOiBidWlsdGluL3N0YXNoLmM6MTE3MiBnaXQtbGVnYWN5LXN0YXNoLnNoOjE2NQogbXNnaWQgIkNhbm5vdCBzYXZlIHRoZSBjdXJyZW50IGluZGV4IHN0YXRlIgogbXNnc3RyICJLYW4gaW50ZSBzcGFyYSBha3R1ZWxsdCB0aWxsc3TDpW5kIGbDtnIgaW5kZXhldCIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjExNzIgZ2l0LWxlZ2FjeS1zdGFzaC5zaDoxODAKKyM6IGJ1aWx0aW4vc3Rhc2guYzoxMTgxIGdpdC1sZWdhY3ktc3Rhc2guc2g6MTgwCiBtc2dpZCAiQ2Fubm90IHNhdmUgdGhlIHVudHJhY2tlZCBmaWxlcyIKIG1zZ3N0ciAiS2FuIGludGUgc3BhcmEgb3Nww6VyYWRlIGZpbGVyIgogCi0jOiBidWlsdGluL3N0YXNoLmM6MTE4MyBidWlsdGluL3N0YXNoLmM6MTE5MiBnaXQtbGVnYWN5LXN0YXNoLnNoOjIwMAorIzogYnVpbHRpbi9zdGFzaC5jOjExOTIgYnVpbHRpbi9zdGFzaC5jOjEyMDEgZ2l0LWxlZ2FjeS1zdGFzaC5zaDoyMDAKICM6IGdpdC1sZWdhY3ktc3Rhc2guc2g6MjEzCiBtc2dpZCAiQ2Fubm90IHNhdmUgdGhlIGN1cnJlbnQgd29ya3RyZWUgc3RhdGUiCiBtc2dzdHIgIkthbiBpbnRlIHNwYXJhIGFrdHVlbGx0IHRpbGxzdMOlbmQgZsO2ciBhcmJldHNrYXRhbG9nZW4iCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzoxMjIwIGdpdC1sZWdhY3ktc3Rhc2guc2g6MjMzCisjOiBidWlsdGluL3N0YXNoLmM6MTIyOSBnaXQtbGVnYWN5LXN0YXNoLnNoOjIzMwogbXNnaWQgIkNhbm5vdCByZWNvcmQgd29ya2luZyB0cmVlIHN0YXRlIgogbXNnc3RyICJLYW4gaW50ZSByZWdpc3RyZXJhIHRpbGxzdMOlbmQgZsO2ciBhcmJldHNrYXRhbG9nIgogCi0jOiBidWlsdGluL3N0YXNoLmM6MTI2OSBnaXQtbGVnYWN5LXN0YXNoLnNoOjMzNworIzogYnVpbHRpbi9zdGFzaC5jOjEyNzggZ2l0LWxlZ2FjeS1zdGFzaC5zaDozMzcKIG1zZ2lkICJDYW4ndCB1c2UgLS1wYXRjaCBhbmQgLS1pbmNsdWRlLXVudHJhY2tlZCBvciAtLWFsbCBhdCB0aGUgc2FtZSB0aW1lIgogbXNnc3RyICJLYW4gaW50ZSBhbnbDpG5kYSAtLXBhdGNoIG9jaCAtLWluY2x1ZGUtdW50cmFja2VkIGVsbGVyIC0tYWxsIHNhbXRpZGlndCIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjEyODUKKyM6IGJ1aWx0aW4vc3Rhc2guYzoxMjk0CiBtc2dpZCAiRGlkIHlvdSBmb3JnZXQgdG8gJ2dpdCBhZGQnPyIKIG1zZ3N0ciAiR2zDtm1kZSBkdSBhbnbDpG5kYSBcImdpdCBhZGRcIj8iCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzoxMzAwIGdpdC1sZWdhY3ktc3Rhc2guc2g6MzQ1CisjOiBidWlsdGluL3N0YXNoLmM6MTMwOSBnaXQtbGVnYWN5LXN0YXNoLnNoOjM0NQogbXNnaWQgIk5vIGxvY2FsIGNoYW5nZXMgdG8gc2F2ZSIKIG1zZ3N0ciAiSW5nYSBsb2thbGEgw6RuZHJpbmdhciBhdHQgc3BhcmEiCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzoxMzA3IGdpdC1sZWdhY3ktc3Rhc2guc2g6MzUwCisjOiBidWlsdGluL3N0YXNoLmM6MTMxNiBnaXQtbGVnYWN5LXN0YXNoLnNoOjM1MAogbXNnaWQgIkNhbm5vdCBpbml0aWFsaXplIHN0YXNoIgogbXNnc3RyICJLYW4gaW50ZSBpbml0aWVyYSBcInN0YXNoXCIiCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzoxMzIyIGdpdC1sZWdhY3ktc3Rhc2guc2g6MzU0CisjOiBidWlsdGluL3N0YXNoLmM6MTMzMSBnaXQtbGVnYWN5LXN0YXNoLnNoOjM1NAogbXNnaWQgIkNhbm5vdCBzYXZlIHRoZSBjdXJyZW50IHN0YXR1cyIKIG1zZ3N0ciAiS2FuIGludGUgc3BhcmEgYWt0dWVsbCBzdGF0dXMiCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzoxMzI3CisjOiBidWlsdGluL3N0YXNoLmM6MTMzNgogIywgYy1mb3JtYXQKIG1zZ2lkICJTYXZlZCB3b3JraW5nIGRpcmVjdG9yeSBhbmQgaW5kZXggc3RhdGUgJXMiCiBtc2dzdHIgIlNwYXJhZGUgYXJiZXRza2F0YWxvZ2VuIG9jaCBpbmRleHN0YXR1cyAlcyIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjE0MTcgZ2l0LWxlZ2FjeS1zdGFzaC5zaDozODQKKyM6IGJ1aWx0aW4vc3Rhc2guYzoxNDI2IGdpdC1sZWdhY3ktc3Rhc2guc2g6Mzg0CiBtc2dpZCAiQ2Fubm90IHJlbW92ZSB3b3JrdHJlZSBjaGFuZ2VzIgogbXNnc3RyICJLYW4gaW50ZSB0YSBib3J0IMOkbmRyaW5nYXIgaSBhcmJldHNrYXRhbG9nZW4iCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzoxNDUyIGJ1aWx0aW4vc3Rhc2guYzoxNDg4CisjOiBidWlsdGluL3N0YXNoLmM6MTQ2MSBidWlsdGluL3N0YXNoLmM6MTQ5NwogbXNnaWQgImtlZXAgaW5kZXgiCiBtc2dzdHIgImJlaMOlbGwgaW5kZXhldCIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjE0NTQgYnVpbHRpbi9zdGFzaC5jOjE0OTAKKyM6IGJ1aWx0aW4vc3Rhc2guYzoxNDYzIGJ1aWx0aW4vc3Rhc2guYzoxNDk5CiBtc2dpZCAic3Rhc2ggaW4gcGF0Y2ggbW9kZSIKIG1zZ3N0ciAiXCJzdGFzaFwiIGkgXCJwYXRjaFwiLWzDpGdlIgogCi0jOiBidWlsdGluL3N0YXNoLmM6MTQ1NSBidWlsdGluL3N0YXNoLmM6MTQ5MQorIzogYnVpbHRpbi9zdGFzaC5jOjE0NjQgYnVpbHRpbi9zdGFzaC5jOjE1MDAKIG1zZ2lkICJxdWlldCBtb2RlIgogbXNnc3RyICJ0eXN0IGzDpGdlIgogCi0jOiBidWlsdGluL3N0YXNoLmM6MTQ1NyBidWlsdGluL3N0YXNoLmM6MTQ5MworIzogYnVpbHRpbi9zdGFzaC5jOjE0NjYgYnVpbHRpbi9zdGFzaC5jOjE1MDIKIG1zZ2lkICJpbmNsdWRlIHVudHJhY2tlZCBmaWxlcyBpbiBzdGFzaCIKIG1zZ3N0ciAidGEgbWVkIG9zcMOlcmFkZSBmaWxlciBpIFwic3Rhc2hcIiIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjE0NTkgYnVpbHRpbi9zdGFzaC5jOjE0OTUKKyM6IGJ1aWx0aW4vc3Rhc2guYzoxNDY4IGJ1aWx0aW4vc3Rhc2guYzoxNTA0CiBtc2dpZCAiaW5jbHVkZSBpZ25vcmUgZmlsZXMiCiBtc2dzdHIgInRhIG1lZCBpZ25vcmVyYWRlIGZpbGVyIgogCi0jOiBidWlsdGluL3N0YXNoLmM6MTU1NQorIzogYnVpbHRpbi9zdGFzaC5jOjE1NjQKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGV4ZWMgJXMiCiBtc2dzdHIgImt1bmRlIGludGUga8O2cmEgJXMiCkBAIC0xOTg0Niw4ICsxOTkwOSw4IEBACiBtc2dzdHIgInNrcml2IGludGUga2xvbmbDtnJsb3BwIgogCiAjOiBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6MTg3NwotbXNnaWQgImdpdCBzdWJtb2R1bGUtLWhlbHBlciB1cGRhdGVfY2xvbmUgWy0tcHJlZml4PTxwYXRoPl0gWzxwYXRoPi4uLl0iCi1tc2dzdHIgImdpdCBzdWJtb2R1bGUtLWhlbHBlciB1cGRhdGVfY2xvbmUgWy0tcHJlZml4PTxzw7ZrdsOkZz5dIFs8c8O2a3bDpGc+Li4uXSIKK21zZ2lkICJnaXQgc3VibW9kdWxlLS1oZWxwZXIgdXBkYXRlLWNsb25lIFstLXByZWZpeD08cGF0aD5dIFs8cGF0aD4uLi5dIgorbXNnc3RyICJnaXQgc3VibW9kdWxlLS1oZWxwZXIgdXBkYXRlLWNsb25lIFstLXByZWZpeD08c8O2a3bDpGc+XSBbPHPDtmt2w6RnPi4uLl0iCiAKICM6IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxODkwCiBtc2dpZCAiYmFkIHZhbHVlIGZvciB1cGRhdGUgcGFyYW1ldGVyIgpAQCAtMTk5MDAsNyArMTk5NjMsNyBAQAogbXNnaWQgInBsZWFzZSBtYWtlIHN1cmUgdGhhdCB0aGUgLmdpdG1vZHVsZXMgZmlsZSBpcyBpbiB0aGUgd29ya2luZyB0cmVlIgogbXNnc3RyICJzZSB0aWxsIGF0dCAuZ2l0bW9kdWxlcyBmaW5ucyBpIGFyYmV0c2thdGFsb2dlbiIKIAotIzogYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjIyMzUgZ2l0LmM6NDM0IGdpdC5jOjY4NAorIzogYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjIyMzUgZ2l0LmM6NDMzIGdpdC5jOjY4MwogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyBkb2Vzbid0IHN1cHBvcnQgLS1zdXBlci1wcmVmaXgiCiBtc2dzdHIgIiVzIHN0w7ZkZXIgaW50ZSAtLXN1cGVyLXByZWZpeCIKQEAgLTIwMjI0LDEzOSArMjAyODcsMTM5IEBACiBtc2dpZCAiZ2l0IHVwZGF0ZS1pbmRleCBbPG9wdGlvbnM+XSBbLS1dIFs8ZmlsZT4uLi5dIgogbXNnc3RyICJnaXQgdXBkYXRlLWluZGV4IFs8ZmxhZ2dvcj5dIFstLV0gWzxmaWw+Li4uXSIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzo5NzEKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6OTcyCiBtc2dpZCAiY29udGludWUgcmVmcmVzaCBldmVuIHdoZW4gaW5kZXggbmVlZHMgdXBkYXRlIgogbXNnc3RyICJmb3J0c8OkdHQgdXBwZGF0ZXJhIMOkdmVuIG7DpHIgaW5kZXggaW50ZSDDpHIgw6Bqb3VyIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjk3NAorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzo5NzUKIG1zZ2lkICJyZWZyZXNoOiBpZ25vcmUgc3VibW9kdWxlcyIKIG1zZ3N0ciAicmVmcmVzaDogaWdub3JlcmEgdW5kZXJtb2R1bGVyIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjk3NworIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzo5NzgKIG1zZ2lkICJkbyBub3QgaWdub3JlIG5ldyBmaWxlcyIKIG1zZ3N0ciAiaWdub3JlcmEgaW50ZSBueWEgZmlsZXIiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6OTc5CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjk4MAogbXNnaWQgImxldCBmaWxlcyByZXBsYWNlIGRpcmVjdG9yaWVzIGFuZCB2aWNlLXZlcnNhIgogbXNnc3RyICJsw6V0IGZpbGVyIGVyc8OkdHRhIGthdGFsb2dlciBvY2ggb212w6RudCIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzo5ODEKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6OTgyCiBtc2dpZCAibm90aWNlIGZpbGVzIG1pc3NpbmcgZnJvbSB3b3JrdHJlZSIKIG1zZ3N0ciAibMOkZ2cgbcOkcmtlIHRpbGwgZmlsZXIgc29tIHNha25hcyBpIGFyYmV0c2thdGFsb2dlbiIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzo5ODMKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6OTg0CiBtc2dpZCAicmVmcmVzaCBldmVuIGlmIGluZGV4IGNvbnRhaW5zIHVubWVyZ2VkIGVudHJpZXMiCiBtc2dzdHIgInVwcGRhdGVyYSDDpHZlbiBvbSBpbmRleGV0IGlubmVow6VsbGVyIGVqIHNhbW1hbnNsYWduYSBwb3N0ZXIiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6OTg2CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjk4NwogbXNnaWQgInJlZnJlc2ggc3RhdCBpbmZvcm1hdGlvbiIKIG1zZ3N0ciAidXBwZGF0ZXJhIHN0YXR1c2luZm9ybWF0aW9uIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjk5MAorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzo5OTEKIG1zZ2lkICJsaWtlIC0tcmVmcmVzaCwgYnV0IGlnbm9yZSBhc3N1bWUtdW5jaGFuZ2VkIHNldHRpbmciCiBtc2dzdHIgInNvbSAtLXJlZnJlc2gsIG1lbiBpZ25vcmVyYSBhc3N1bWUtdW5jaGFuZ2VkLWluc3TDpGxsbmluZyIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzo5OTQKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6OTk1CiBtc2dpZCAiPG1vZGU+LDxvYmplY3Q+LDxwYXRoPiIKIG1zZ3N0ciAiPGzDpGdlPiw8b2JqZWt0Piw8c8O2a3bDpGc+IgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjk5NQorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzo5OTYKIG1zZ2lkICJhZGQgdGhlIHNwZWNpZmllZCBlbnRyeSB0byB0aGUgaW5kZXgiCiBtc2dzdHIgImzDpGdnIHRpbGwgYW5naXZlbiBwb3N0IGkgaW5kZXhldCIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDA1CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMDYKIG1zZ2lkICJtYXJrIGZpbGVzIGFzIFwibm90IGNoYW5naW5nXCIiCiBtc2dzdHIgIm1hcmtlcmEgZmlsZXIgc29tIFwiw6RuZHJhcyBpbnRlXCIiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAwOAorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDA5CiBtc2dpZCAiY2xlYXIgYXNzdW1lZC11bmNoYW5nZWQgYml0IgogbXNnc3RyICJyZW5zYSBcImFzc3VtZS11bmNoYW5nZWRcIi1iaXRlbiIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDExCisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMTIKIG1zZ2lkICJtYXJrIGZpbGVzIGFzIFwiaW5kZXgtb25seVwiIgogbXNnc3RyICJtYXJrZXJhIGZpbGVyIHNvbSBcImVuZGFzdCBpbmRleFwiIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMTQKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAxNQogbXNnaWQgImNsZWFyIHNraXAtd29ya3RyZWUgYml0IgogbXNnc3RyICJ0w7ZtIFwic2tpcC13b3JrdHJlZVwiLWJpdGVuIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMTcKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAxOAogbXNnaWQgImFkZCB0byBpbmRleCBvbmx5OyBkbyBub3QgYWRkIGNvbnRlbnQgdG8gb2JqZWN0IGRhdGFiYXNlIgogbXNnc3RyICJsw6RnZyBlbmRhc3QgdGlsbCBpbmRleGV0OyBsw6RnZyBpbnRlIHRpbGwgaW5uZWjDpWxsZXQgaSBvYmpla3RkYXRhYmFzZW4iCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAxOQorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDIwCiBtc2dpZCAicmVtb3ZlIG5hbWVkIHBhdGhzIGV2ZW4gaWYgcHJlc2VudCBpbiB3b3JrdHJlZSIKIG1zZ3N0ciAidGEgYm9ydCBuYW1uZ2l2bmEgc8O2a3bDpGdhciDDpHZlbiBvbSBkZSBmaW5ucyBpIGFyYmV0c2thdGFsb2dlbiIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDIxCisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMjIKIG1zZ2lkICJ3aXRoIC0tc3RkaW46IGlucHV0IGxpbmVzIGFyZSB0ZXJtaW5hdGVkIGJ5IG51bGwgYnl0ZXMiCiBtc2dzdHIgIm1lZCAtLXN0ZGluOiBpbmRhdGFyYWRlciB0ZXJtaW5lcmFzIG1lZCBudWxsLWJ5dGUiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAyMworIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDI0CiBtc2dpZCAicmVhZCBsaXN0IG9mIHBhdGhzIHRvIGJlIHVwZGF0ZWQgZnJvbSBzdGFuZGFyZCBpbnB1dCIKIG1zZ3N0ciAibMOkcyBsaXN0YSDDtnZlciBzw7ZrdsOkZ2FyIGF0dCB1cHBkYXRlcmEgZnLDpW4gc3RhbmRhcmQgaW4iCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAyNworIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDI4CiBtc2dpZCAiYWRkIGVudHJpZXMgZnJvbSBzdGFuZGFyZCBpbnB1dCB0byB0aGUgaW5kZXgiCiBtc2dzdHIgImzDpGdnIHBvc3RlciBmcsOlbiBzdGFuZGFyZCBpbiB0aWxsIGluZGV4ZXQiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAzMQorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDMyCiBtc2dpZCAicmVwb3B1bGF0ZSBzdGFnZXMgIzIgYW5kICMzIGZvciB0aGUgbGlzdGVkIHBhdGhzIgogbXNnc3RyICLDpXRlcmZ5bGwgZXRhcHAgMiBvY2ggMyBmcsOlbiBhbmdpdm5hIHPDtmt2w6RnYXIiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAzNQorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDM2CiBtc2dpZCAib25seSB1cGRhdGUgZW50cmllcyB0aGF0IGRpZmZlciBmcm9tIEhFQUQiCiBtc2dzdHIgInVwcGRhdGVyYSBlbmRhc3QgcG9zdGVyIHNvbSBza2lsamVyIHNpZyBmcsOlbiBIRUFEIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMzkKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTA0MAogbXNnaWQgImlnbm9yZSBmaWxlcyBtaXNzaW5nIGZyb20gd29ya3RyZWUiCiBtc2dzdHIgImlnbm9yZXJhIGZpbGVyIHNvbSBzYWtuYXMgaSBhcmJldHNrYXRhbG9nZW4iCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTA0MgorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDQzCiBtc2dpZCAicmVwb3J0IGFjdGlvbnMgdG8gc3RhbmRhcmQgb3V0cHV0IgogbXNnc3RyICJyYXBwb3J0ZXJhIMOldGfDpHJkZXIgcMOlIHN0YW5kYXJkIHV0IgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwNDQKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTA0NQogbXNnaWQgIihmb3IgcG9yY2VsYWlucykgZm9yZ2V0IHNhdmVkIHVucmVzb2x2ZWQgY29uZmxpY3RzIgogbXNnc3RyICIoZsO2ciBwb3JzbGluKSBnbMO2bSBzcGFyYWRlIG9sw7ZzdGEga29uZmxpa3RlciIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDQ4CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwNDkKIG1zZ2lkICJ3cml0ZSBpbmRleCBpbiB0aGlzIGZvcm1hdCIKIG1zZ3N0ciAic2tyaXYgaW5kZXggaSBkZXR0YSBmb3JtYXQiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTA1MAorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDUxCiBtc2dpZCAiZW5hYmxlIG9yIGRpc2FibGUgc3BsaXQgaW5kZXgiCiBtc2dzdHIgImFrdGl2ZXJhIGVsbGVyIGluYWt0aXZlcmEgZGVsYXQgaW5kZXgiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTA1MgorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDUzCiBtc2dpZCAiZW5hYmxlL2Rpc2FibGUgdW50cmFja2VkIGNhY2hlIgogbXNnc3RyICJha3RpdmVyYS9pbmFrdGl2ZXJhIG9zcMOlcmFkIGNhY2hlIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwNTQKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTA1NQogbXNnaWQgInRlc3QgaWYgdGhlIGZpbGVzeXN0ZW0gc3VwcG9ydHMgdW50cmFja2VkIGNhY2hlIgogbXNnc3RyICJ0ZXN0YSBvbSBmaWxzeXN0ZW1ldCBzdMO2ZGVyIG9zcMOlcmFkIGNhY2hlIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwNTYKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTA1NwogbXNnaWQgImVuYWJsZSB1bnRyYWNrZWQgY2FjaGUgd2l0aG91dCB0ZXN0aW5nIHRoZSBmaWxlc3lzdGVtIgogbXNnc3RyICJha3RpdmVyYSBvc3DDpXJhZCBjYWNoZSB1dGFuIGF0dCB0ZXN0YSBmaWxzeXN0ZW1ldCIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDU4CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwNTkKIG1zZ2lkICJ3cml0ZSBvdXQgdGhlIGluZGV4IGV2ZW4gaWYgaXMgbm90IGZsYWdnZWQgYXMgY2hhbmdlZCIKIG1zZ3N0ciAic2tyaXYgdXQgaW5kZXhldCDDpHZlbiBvbSBkZXQgaW50ZSBhbmdpdml0cyBzb20gw6RuZHJhdCIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDYwCisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwNjEKIG1zZ2lkICJlbmFibGUgb3IgZGlzYWJsZSBmaWxlIHN5c3RlbSBtb25pdG9yIgogbXNnc3RyICJha3RpdmVyYSBlbGxlciBpbmFrdGl2ZXJhIGZpbHN5c3RlbXPDtnZlcnZha25pbmciCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTA2MgorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDYzCiBtc2dpZCAibWFyayBmaWxlcyBhcyBmc21vbml0b3IgdmFsaWQiCiBtc2dzdHIgIm1hcmtlcmEgZmlsZXIgc29tIFwiZnNtb25pdG9yIHZhbGlkXCIiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTA2NQorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDY2CiBtc2dpZCAiY2xlYXIgZnNtb25pdG9yIHZhbGlkIGJpdCIKIG1zZ3N0ciAidMO2bSBcImZzbW9uaXRvciB2YWxpZFwiLWJpdCIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMTY4CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjExNjkKIG1zZ2lkICIiCiAiY29yZS5zcGxpdEluZGV4IGlzIHNldCB0byBmYWxzZTsgcmVtb3ZlIG9yIGNoYW5nZSBpdCwgaWYgeW91IHJlYWxseSB3YW50IHRvICIKICJlbmFibGUgc3BsaXQgaW5kZXgiCkBAIC0yMDM2NCw3ICsyMDQyNyw3IEBACiAiY29yZS5zcGxpdEluZGV4IMOkciBzYXR0IHRpbGwgZmFsc2U7IHRhIGJvcnQgZWxsZXIgw6RuZHJhIGRldCBvbSBkdSB2ZXJrbGlnZW4gIgogInZpbGwgYWt0aXZlcmEgZGVsYXQgaW5kZXgiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTE3NworIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMTc4CiBtc2dpZCAiIgogImNvcmUuc3BsaXRJbmRleCBpcyBzZXQgdG8gdHJ1ZTsgcmVtb3ZlIG9yIGNoYW5nZSBpdCwgaWYgeW91IHJlYWxseSB3YW50IHRvICIKICJkaXNhYmxlIHNwbGl0IGluZGV4IgpAQCAtMjAzNzIsNyArMjA0MzUsNyBAQAogImNvcmUuc3BsaXRJbmRleCDDpHIgc2F0dCB0aWxsIHRydWU7IHRhIGJvcnQgZWxsZXIgw6RuZHJhIGRldCBvbSBkdSB2ZXJrbGlnZW4gIgogInZpbGwgaW5ha3RpdmVyYSBkZWxhdCBpbmRleCIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMTg4CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjExOTAKIG1zZ2lkICIiCiAiY29yZS51bnRyYWNrZWRDYWNoZSBpcyBzZXQgdG8gdHJ1ZTsgcmVtb3ZlIG9yIGNoYW5nZSBpdCwgaWYgeW91IHJlYWxseSB3YW50ICIKICJ0byBkaXNhYmxlIHRoZSB1bnRyYWNrZWQgY2FjaGUiCkBAIC0yMDM4MCwxMSArMjA0NDMsMTEgQEAKICJjb3JlLnVudHJhY2tlZENhY2hlIMOkciBzYXR0IHRpbGwgdHJ1ZTsgdGEgYm9ydCBlbGxlciDDpG5kcmEgZGV0IG9tIGR1ICIKICJ2ZXJrbGlnZW4gdmlsbCBpbmFrdGl2ZXJhIGRlbiBvc3DDpXJhZGUgY2FjaGVuIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjExOTIKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTE5NAogbXNnaWQgIlVudHJhY2tlZCBjYWNoZSBkaXNhYmxlZCIKIG1zZ3N0ciAiT3Nww6VyYWQgY2FjaGUgw6RyIGluYWt0aXZlcmFkIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEyMDAKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTIwMgogbXNnaWQgIiIKICJjb3JlLnVudHJhY2tlZENhY2hlIGlzIHNldCB0byBmYWxzZTsgcmVtb3ZlIG9yIGNoYW5nZSBpdCwgaWYgeW91IHJlYWxseSB3YW50ICIKICJ0byBlbmFibGUgdGhlIHVudHJhY2tlZCBjYWNoZSIKQEAgLTIwMzkyLDI2ICsyMDQ1NSwyNiBAQAogImNvcmUudW50cmFja2VkQ2FjaGUgw6RyIHNhdHQgdGlsbCBmYWxzZTsgdGEgYm9ydCBlbGxlciDDpG5kcmEgZGV0IG9tIGR1ICIKICJ2ZXJrbGlnZW4gdmlsbCBha3RpdmVyYSBkZW4gb3Nww6VyYWRlIGNhY2hlbiIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMjA0CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEyMDYKICMsIGMtZm9ybWF0CiBtc2dpZCAiVW50cmFja2VkIGNhY2hlIGVuYWJsZWQgZm9yICclcyciCiBtc2dzdHIgIk9zcMOlcmFkIGNhY2hlIMOkciBha3RpdmVyYWQgZsO2ciBcIiVzXCIiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTIxMgorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMjE0CiBtc2dpZCAiY29yZS5mc21vbml0b3IgaXMgdW5zZXQ7IHNldCBpdCBpZiB5b3UgcmVhbGx5IHdhbnQgdG8gZW5hYmxlIGZzbW9uaXRvciIKIG1zZ3N0ciAiY29yZS5mc21vbml0b3IgaW50ZSBzYXR0OyBzw6R0dCBvbSBkdSB2ZXJrbGlnZW4gdmlsbCBha3RpdmVyYSBmc21vbml0b3IiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTIxNgorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMjE4CiBtc2dpZCAiZnNtb25pdG9yIGVuYWJsZWQiCiBtc2dzdHIgImZzbW9uaXRvciBha3RpdmVyYXQiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTIxOQorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMjIxCiBtc2dpZCAiIgogImNvcmUuZnNtb25pdG9yIGlzIHNldDsgcmVtb3ZlIGl0IGlmIHlvdSByZWFsbHkgd2FudCB0byBkaXNhYmxlIGZzbW9uaXRvciIKIG1zZ3N0ciAiIgogImNvcmUuZnNtb25pdG9yIMOkciBzYXR0OyB0YSBib3J0IG9tIGR1IHZlcmtsaWdlbiB2aWxsIGluYWt0aXZlcmEgZnNtb25pdG9yIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEyMjMKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTIyNQogbXNnaWQgImZzbW9uaXRvciBkaXNhYmxlZCIKIG1zZ3N0ciAiZnNtb25pdG9yIGluYWt0aXZlcmF0IgogCkBAIC0yMDQ3MSwxNSArMjA1MzQsMTUgQEAKIG1zZ2lkICJpbnRlcnJ1cHQgdHJhbnNmZXIgYWZ0ZXIgPG4+IHNlY29uZHMgb2YgaW5hY3Rpdml0eSIKIG1zZ3N0ciAiYXZicnl0IMO2dmVyZsO2cmluZ2VuIGVmdGVyIDxuPiBzZWt1bmRlcnMgaW5ha3Rpdml0ZXQiCiAKLSM6IGJ1aWx0aW4vdmVyaWZ5LWNvbW1pdC5jOjIwCisjOiBidWlsdGluL3ZlcmlmeS1jb21taXQuYzoxOQogbXNnaWQgImdpdCB2ZXJpZnktY29tbWl0IFstdiB8IC0tdmVyYm9zZV0gPGNvbW1pdD4uLi4iCiBtc2dzdHIgImdpdCB2ZXJpZnktY29tbWl0IFstdiB8IC0tdmVyYm9zZV0gPGluY2hlY2tuaW5nPi4uLiIKIAotIzogYnVpbHRpbi92ZXJpZnktY29tbWl0LmM6NjkKKyM6IGJ1aWx0aW4vdmVyaWZ5LWNvbW1pdC5jOjY4CiBtc2dpZCAicHJpbnQgY29tbWl0IGNvbnRlbnRzIgogbXNnc3RyICJ2aXNhIGlubmVow6VsbCBmw7ZyIGluY2hlY2tuaW5nIgogCi0jOiBidWlsdGluL3ZlcmlmeS1jb21taXQuYzo3MCBidWlsdGluL3ZlcmlmeS10YWcuYzozOAorIzogYnVpbHRpbi92ZXJpZnktY29tbWl0LmM6NjkgYnVpbHRpbi92ZXJpZnktdGFnLmM6MzcKIG1zZ2lkICJwcmludCByYXcgZ3BnIHN0YXR1cyBvdXRwdXQiCiBtc2dzdHIgInZpc2EgcsOlYSBncGctc3RhdHVzZGF0YSIKIApAQCAtMjA0OTUsNjMgKzIwNTU4LDYzIEBACiBtc2dpZCAic2hvdyBzdGF0aXN0aWNzIG9ubHkiCiBtc2dzdHIgInZpc2EgZW5kYXN0IHN0YXRpc3RpayIKIAotIzogYnVpbHRpbi92ZXJpZnktdGFnLmM6MTkKKyM6IGJ1aWx0aW4vdmVyaWZ5LXRhZy5jOjE4CiBtc2dpZCAiZ2l0IHZlcmlmeS10YWcgWy12IHwgLS12ZXJib3NlXSBbLS1mb3JtYXQ9PGZvcm1hdD5dIDx0YWc+Li4uIgogbXNnc3RyICJnaXQgdmVyaWZ5LXRhZyBbLXYgfCAtLXZlcmJvc2VdIFstLWZvcm1hdD08Zm9ybWF0XSA8dGFnZz4uLi4iCiAKLSM6IGJ1aWx0aW4vdmVyaWZ5LXRhZy5jOjM3CisjOiBidWlsdGluL3ZlcmlmeS10YWcuYzozNgogbXNnaWQgInByaW50IHRhZyBjb250ZW50cyIKIG1zZ3N0ciAidmlzYSBpbm5laMOlbGwgZsO2ciB0YWciCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzoxOAorIzogYnVpbHRpbi93b3JrdHJlZS5jOjE3CiBtc2dpZCAiZ2l0IHdvcmt0cmVlIGFkZCBbPG9wdGlvbnM+XSA8cGF0aD4gWzxjb21taXQtaXNoPl0iCiBtc2dzdHIgImdpdCB3b3JrdHJlZSBhZGQgWzxmbGFnZ29yPl0gPHPDtmt2w6RnPiBbPGluY2hlY2tuaW5nLWlndD5dIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6MTkKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzoxOAogbXNnaWQgImdpdCB3b3JrdHJlZSBsaXN0IFs8b3B0aW9ucz5dIgogbXNnc3RyICJnaXQgd29ya3RyZWUgbGlzdCBbPGZsYWdnb3I+XSIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjIwCisjOiBidWlsdGluL3dvcmt0cmVlLmM6MTkKIG1zZ2lkICJnaXQgd29ya3RyZWUgbG9jayBbPG9wdGlvbnM+XSA8cGF0aD4iCiBtc2dzdHIgImdpdCB3b3JrdHJlZSBsb2NrIFs8ZmxhZ2dvcj5dIDxzw7ZrdsOkZz4iCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzoyMQorIzogYnVpbHRpbi93b3JrdHJlZS5jOjIwCiBtc2dpZCAiZ2l0IHdvcmt0cmVlIG1vdmUgPHdvcmt0cmVlPiA8bmV3LXBhdGg+IgogbXNnc3RyICJnaXQgd29ya3RyZWUgbW92ZSA8YXJiZXRza2F0YWxvZz4gPG55LXPDtmt2w6RnPiIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjIyCisjOiBidWlsdGluL3dvcmt0cmVlLmM6MjEKIG1zZ2lkICJnaXQgd29ya3RyZWUgcHJ1bmUgWzxvcHRpb25zPl0iCiBtc2dzdHIgImdpdCB3b3JrdHJlZSBwcnVuZSBbPGZsYWdnb3I+XSIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjIzCisjOiBidWlsdGluL3dvcmt0cmVlLmM6MjIKIG1zZ2lkICJnaXQgd29ya3RyZWUgcmVtb3ZlIFs8b3B0aW9ucz5dIDx3b3JrdHJlZT4iCiBtc2dzdHIgImdpdCB3b3JrdHJlZSByZW1vdmUgWzxmbGFnZ29yPl0gPGFyYmV0c2thdGFsb2c+IgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6MjQKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzoyMwogbXNnaWQgImdpdCB3b3JrdHJlZSB1bmxvY2sgPHBhdGg+IgogbXNnc3RyICJnaXQgd29ya3RyZWUgdW5sb2NrIDxzw7ZrdsOkZz4iCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo2MSBidWlsdGluL3dvcmt0cmVlLmM6ODk5CisjOiBidWlsdGluL3dvcmt0cmVlLmM6NjAgYnVpbHRpbi93b3JrdHJlZS5jOjg5OAogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gZGVsZXRlICclcyciCiBtc2dzdHIgIm1pc3NseWNrYWRlcyB0YSBib3J0IFwiJXNcIiIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjgwCisjOiBidWlsdGluL3dvcmt0cmVlLmM6NzkKICMsIGMtZm9ybWF0CiBtc2dpZCAiUmVtb3Zpbmcgd29ya3RyZWVzLyVzOiBub3QgYSB2YWxpZCBkaXJlY3RvcnkiCiBtc2dzdHIgIlRhciBib3J0IHdvcmt0cmVlcy8lczogaW50ZSBlbiBnaWx0aWcga2F0YWxvZyIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjg2CisjOiBidWlsdGluL3dvcmt0cmVlLmM6ODUKICMsIGMtZm9ybWF0CiBtc2dpZCAiUmVtb3Zpbmcgd29ya3RyZWVzLyVzOiBnaXRkaXIgZmlsZSBkb2VzIG5vdCBleGlzdCIKIG1zZ3N0ciAiVGFyIGJvcnQgd29ya3RyZWVzLyVzOiBnaXRkaXItZmlsZW4gZXhpc3RlcmFyIGludGUiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo5MSBidWlsdGluL3dvcmt0cmVlLmM6MTAwCisjOiBidWlsdGluL3dvcmt0cmVlLmM6OTAgYnVpbHRpbi93b3JrdHJlZS5jOjk5CiAjLCBjLWZvcm1hdAogbXNnaWQgIlJlbW92aW5nIHdvcmt0cmVlcy8lczogdW5hYmxlIHRvIHJlYWQgZ2l0ZGlyIGZpbGUgKCVzKSIKIG1zZ3N0ciAiVGFyIGJvcnQgd29ya3RyZWVzLyVzOiBrYW4gaW50ZSBsw6RzYSBnaXRkaXItZmlsZW4gKCVzKSIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjExMAorIzogYnVpbHRpbi93b3JrdHJlZS5jOjEwOQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiUmVtb3Zpbmcgd29ya3RyZWVzLyVzOiBzaG9ydCByZWFkIChleHBlY3RlZCAlPFBSSXVNQVg+IGJ5dGVzLCByZWFkICIKQEAgLTIwNTYwLDM1ICsyMDYyMywzNSBAQAogIlRhciBib3J0IHdvcmt0cmVlcy8lczoga29ydCBsw6RzbmluZyAoZsO2cnbDpG50YWRlICU8UFJJdU1BWD4gYnl0ZSwgbMOkc3RlICIKICIlPFBSSXVNQVg+KSIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjExOAorIzogYnVpbHRpbi93b3JrdHJlZS5jOjExNwogIywgYy1mb3JtYXQKIG1zZ2lkICJSZW1vdmluZyB3b3JrdHJlZXMvJXM6IGludmFsaWQgZ2l0ZGlyIGZpbGUiCiBtc2dzdHIgIlRhciBib3J0IHdvcmt0cmVlcy8lczogZmVsYWt0aWcgZ2l0ZGlyLWZpbCIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjEyNworIzogYnVpbHRpbi93b3JrdHJlZS5jOjEyNgogIywgYy1mb3JtYXQKIG1zZ2lkICJSZW1vdmluZyB3b3JrdHJlZXMvJXM6IGdpdGRpciBmaWxlIHBvaW50cyB0byBub24tZXhpc3RlbnQgbG9jYXRpb24iCiBtc2dzdHIgIlRhciBib3J0IHdvcmt0cmVlcy8lczogZ2l0ZGlyLWZpbGVuIHBla2FyIHDDpSBlbiBpY2tlZXhpc3RlcmFuZGUgcGxhdHMiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzoxNjYKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzoxNjUKIG1zZ2lkICJyZXBvcnQgcHJ1bmVkIHdvcmtpbmcgdHJlZXMiCiBtc2dzdHIgInJhcHBvcnRlcmEgYm9ydHRhZ25hIGFyYmV0c2thdGFsb2dlciIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjE2OAorIzogYnVpbHRpbi93b3JrdHJlZS5jOjE2NwogbXNnaWQgImV4cGlyZSB3b3JraW5nIHRyZWVzIG9sZGVyIHRoYW4gPHRpbWU+IgogbXNnc3RyICJsw6V0IHRpZCBnw6UgdXQgZsO2ciBhcmJldHNrYXRhbG9nZXIgw6RsZHJlIMOkbiA8dGlkPiIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjIzNQorIzogYnVpbHRpbi93b3JrdHJlZS5jOjIzNAogIywgYy1mb3JtYXQKIG1zZ2lkICInJXMnIGFscmVhZHkgZXhpc3RzIgogbXNnc3RyICJcIiVzXCIgZmlubnMgcmVkYW4iCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzoyNTIKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzoyNTEKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHJlLWFkZCB3b3JrdHJlZSAnJXMnIgogbXNnc3RyICJrdW5kZSBpbnRlIGzDpGdnYSBpbiBhcmJldHNrYXRhbG9nZW4gXCIlc1wiIGlnZW4iCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzoyNTcKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzoyNTYKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIiclcycgaXMgYSBtaXNzaW5nIGJ1dCBsb2NrZWQgd29ya3RyZWU7XG4iCkBAIC0yMDU5OCw3ICsyMDY2MSw3IEBACiAiYW52w6RuZCBcImFkZCAtZiAtZlwiIGbDtnIgYXR0IMO2dmVyc3R5cmEsIGVsbGVyIFwidW5sb2NrXCIgb2NoIFwicHJ1bmVcIiBlbGxlciAiCiAiXCJyZW1vdmVcIiBmw7ZyIGF0dCByZW5zYSIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjI1OQorIzogYnVpbHRpbi93b3JrdHJlZS5jOjI1OAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiJyVzJyBpcyBhIG1pc3NpbmcgYnV0IGFscmVhZHkgcmVnaXN0ZXJlZCB3b3JrdHJlZTtcbiIKQEAgLTIwNjA4LDEyMSArMjA2NzEsMTIxIEBACiAiYW52w6RuZCBcImFkZCAtZlwiIGbDtnIgYXR0IMO2dmVyc3R5cmEsIGVsbGVyIFwicHJ1bmVcIiBlbGxlciBcInJlbW92ZVwiIGbDtnIgIgogImF0dCByZW5zYSIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjMwOQorIzogYnVpbHRpbi93b3JrdHJlZS5jOjMwOAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgY3JlYXRlIGRpcmVjdG9yeSBvZiAnJXMnIgogbXNnc3RyICJrdW5kZSBpbnRlIHNrYXBhIGthdGFsb2dlbiBcIiVzXCIiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo0NDAgYnVpbHRpbi93b3JrdHJlZS5jOjQ0NgorIzogYnVpbHRpbi93b3JrdHJlZS5jOjQzOSBidWlsdGluL3dvcmt0cmVlLmM6NDQ1CiAjLCBjLWZvcm1hdAogbXNnaWQgIlByZXBhcmluZyB3b3JrdHJlZSAobmV3IGJyYW5jaCAnJXMnKSIKIG1zZ3N0ciAiRsO2cmJlcmVkZXIgYXJiZXRza2F0YWxvZyAobnkgZ3JlbiBcIiVzXCIpIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NDQyCisjOiBidWlsdGluL3dvcmt0cmVlLmM6NDQxCiAjLCBjLWZvcm1hdAogbXNnaWQgIlByZXBhcmluZyB3b3JrdHJlZSAocmVzZXR0aW5nIGJyYW5jaCAnJXMnOyB3YXMgYXQgJXMpIgogbXNnc3RyICJGw7ZyYmVyZWRlciBhcmJldHNrYXRhbG9nICjDpXRlcnN0w6RsbGVyIGdyZW4gXCIlc1wiOyB2YXIgcMOlICVzKSIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjQ1MQorIzogYnVpbHRpbi93b3JrdHJlZS5jOjQ1MAogIywgYy1mb3JtYXQKIG1zZ2lkICJQcmVwYXJpbmcgd29ya3RyZWUgKGNoZWNraW5nIG91dCAnJXMnKSIKIG1zZ3N0ciAiRsO2cmJlcmVkZXIgYXJiZXRza2F0YWxvZyAoY2hlY2thciB1dCBcIiVzXCIpIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NDU3CisjOiBidWlsdGluL3dvcmt0cmVlLmM6NDU2CiAjLCBjLWZvcm1hdAogbXNnaWQgIlByZXBhcmluZyB3b3JrdHJlZSAoZGV0YWNoZWQgSEVBRCAlcykiCiBtc2dzdHIgIkbDtnJiZXJlZGVyIGFyYmV0c2thdGFsb2cgKGZyw6Vua29wcGxhdCBIRUFEICVzKSIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjQ5OAorIzogYnVpbHRpbi93b3JrdHJlZS5jOjQ5NwogbXNnaWQgImNoZWNrb3V0IDxicmFuY2g+IGV2ZW4gaWYgYWxyZWFkeSBjaGVja2VkIG91dCBpbiBvdGhlciB3b3JrdHJlZSIKIG1zZ3N0ciAiIgogImNoZWNrYSB1dCA8Z3Jlbj4gw6R2ZW4gb20gZGVuIHJlZGFuIMOkciB1dGNoZWNrYWQgaSBlbiBhbm5hbiBhcmJldHNrYXRhbG9nIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NTAxCisjOiBidWlsdGluL3dvcmt0cmVlLmM6NTAwCiBtc2dpZCAiY3JlYXRlIGEgbmV3IGJyYW5jaCIKIG1zZ3N0ciAic2thcGEgZW4gbnkgZ3JlbiIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjUwMworIzogYnVpbHRpbi93b3JrdHJlZS5jOjUwMgogbXNnaWQgImNyZWF0ZSBvciByZXNldCBhIGJyYW5jaCIKIG1zZ3N0ciAic2thcGEgZWxsZXIgw6V0ZXJzdMOkbGwgZW4gZ3JlbiIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjUwNQorIzogYnVpbHRpbi93b3JrdHJlZS5jOjUwNAogbXNnaWQgInBvcHVsYXRlIHRoZSBuZXcgd29ya2luZyB0cmVlIgogbXNnc3RyICJiZWZvbGthIGRlbiBueWEgYXJiZXRza2F0YWxvZ2VuIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NTA2CisjOiBidWlsdGluL3dvcmt0cmVlLmM6NTA1CiBtc2dpZCAia2VlcCB0aGUgbmV3IHdvcmtpbmcgdHJlZSBsb2NrZWQiCiBtc2dzdHIgImzDpXQgYXJiZXRza2F0YWxvZ2VuIGbDtnJibGkgbMOlc3QiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo1MDkKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo1MDgKIG1zZ2lkICJzZXQgdXAgdHJhY2tpbmcgbW9kZSAoc2VlIGdpdC1icmFuY2goMSkpIgogbXNnc3RyICJzdMOkbGwgaW4gc3DDpXJuaW5nc2zDpGdlIChzZSBnaXQtYnJhbmNoKDEpKSIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjUxMgorIzogYnVpbHRpbi93b3JrdHJlZS5jOjUxMQogbXNnaWQgInRyeSB0byBtYXRjaCB0aGUgbmV3IGJyYW5jaCBuYW1lIHdpdGggYSByZW1vdGUtdHJhY2tpbmcgYnJhbmNoIgogbXNnc3RyICJmw7Zyc8O2ayBtYXRjaGEgbmFtbiBww6UgbnkgZ3JlbiBtb3QgZW4gZmrDpHJyc3DDpXJhbmRlIGdyZW4iCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo1MjAKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo1MTkKIG1zZ2lkICItYiwgLUIsIGFuZCAtLWRldGFjaCBhcmUgbXV0dWFsbHkgZXhjbHVzaXZlIgogbXNnc3RyICItYiwgLUIgb2NoIC0tZGV0YWNoIMOkciDDtm1zZXNpZGlndCB1dGVzbHV0YW5kZSIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjU4MQorIzogYnVpbHRpbi93b3JrdHJlZS5jOjU4MAogbXNnaWQgIi0tW25vLV10cmFjayBjYW4gb25seSBiZSB1c2VkIGlmIGEgbmV3IGJyYW5jaCBpcyBjcmVhdGVkIgogbXNnc3RyICItLVtuby1ddHJhY2sga2FuIGVuZGFzdCBhbnbDpG5kYXMgbsOkciBueSBncmFuIHNrYXBhcyIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjY4MQorIzogYnVpbHRpbi93b3JrdHJlZS5jOjY4MAogbXNnaWQgInJlYXNvbiBmb3IgbG9ja2luZyIKIG1zZ3N0ciAib3JzYWsgdGlsbCBsw6VzIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NjkzIGJ1aWx0aW4vd29ya3RyZWUuYzo3MjYgYnVpbHRpbi93b3JrdHJlZS5jOjgwMAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjkyNworIzogYnVpbHRpbi93b3JrdHJlZS5jOjY5MiBidWlsdGluL3dvcmt0cmVlLmM6NzI1IGJ1aWx0aW4vd29ya3RyZWUuYzo3OTkKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo5MjYKICMsIGMtZm9ybWF0CiBtc2dpZCAiJyVzJyBpcyBub3QgYSB3b3JraW5nIHRyZWUiCiBtc2dzdHIgIlwiJXNcIiDDpHIgaW50ZSBlbiBhcmJldHNrYXRhbG9nIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6Njk1IGJ1aWx0aW4vd29ya3RyZWUuYzo3MjgKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo2OTQgYnVpbHRpbi93b3JrdHJlZS5jOjcyNwogbXNnaWQgIlRoZSBtYWluIHdvcmtpbmcgdHJlZSBjYW5ub3QgYmUgbG9ja2VkIG9yIHVubG9ja2VkIgogbXNnc3RyICJIdXZ1ZGFyYmV0c2thdGFsb2dlbiBrYW4gaW50ZSBsw6VzYXMgZWxsZXIgbMOlc2FzIHVwcCIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjcwMAorIzogYnVpbHRpbi93b3JrdHJlZS5jOjY5OQogIywgYy1mb3JtYXQKIG1zZ2lkICInJXMnIGlzIGFscmVhZHkgbG9ja2VkLCByZWFzb246ICVzIgogbXNnc3RyICJcIiVzXCIgw6RyIHJlZGFuIGzDpXN0LCBvcnNhazogJXMiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo3MDIKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo3MDEKICMsIGMtZm9ybWF0CiBtc2dpZCAiJyVzJyBpcyBhbHJlYWR5IGxvY2tlZCIKIG1zZ3N0ciAiXCIlc1wiIMOkciByZWRhbiBsw6VzdCIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjczMAorIzogYnVpbHRpbi93b3JrdHJlZS5jOjcyOQogIywgYy1mb3JtYXQKIG1zZ2lkICInJXMnIGlzIG5vdCBsb2NrZWQiCiBtc2dzdHIgIlwiJXNcIiDDpHIgaW50ZSBsw6VzdCIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjc3MQorIzogYnVpbHRpbi93b3JrdHJlZS5jOjc3MAogbXNnaWQgIndvcmtpbmcgdHJlZXMgY29udGFpbmluZyBzdWJtb2R1bGVzIGNhbm5vdCBiZSBtb3ZlZCBvciByZW1vdmVkIgogbXNnc3RyICJhcmJldHNrYXRhbG9nZXIgbWVkIHVuZGVybW9kdWxlciBrYW4gaW50ZSBmbHl0dGFzIGVsbGVyIHRhcyBib3J0IgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6Nzc5CisjOiBidWlsdGluL3dvcmt0cmVlLmM6Nzc4CiBtc2dpZCAiZm9yY2UgbW92ZSBldmVuIGlmIHdvcmt0cmVlIGlzIGRpcnR5IG9yIGxvY2tlZCIKIG1zZ3N0ciAidHZpbmdhIGZseXR0bmluZyDDpHZlbiBvbSBhcmJldHNrYXRhbG9nZW4gw6RyIHNtdXRzaWcgZWxsZXIgbMOlc3QiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4MDIgYnVpbHRpbi93b3JrdHJlZS5jOjkyOQorIzogYnVpbHRpbi93b3JrdHJlZS5jOjgwMSBidWlsdGluL3dvcmt0cmVlLmM6OTI4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiclcycgaXMgYSBtYWluIHdvcmtpbmcgdHJlZSIKIG1zZ3N0ciAiXCIlc1wiIMOkciBpbnRlIGVuIGh1dnVkYXJiZXRza2F0YWxvZyIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjgwNworIzogYnVpbHRpbi93b3JrdHJlZS5jOjgwNgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgZmlndXJlIG91dCBkZXN0aW5hdGlvbiBuYW1lIGZyb20gJyVzJyIKIG1zZ3N0ciAia3VuZGUgaW50ZSBsaXN0YSB1dCBtw6VsbmFtbiBmcsOlbiBcIiVzXCIiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4MTMKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4MTIKICMsIGMtZm9ybWF0CiBtc2dpZCAidGFyZ2V0ICclcycgYWxyZWFkeSBleGlzdHMiCiBtc2dzdHIgIm3DpWxldCBcIiVzXCIgZmlubnMgcmVkYW4iCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4MjEKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4MjAKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogImNhbm5vdCBtb3ZlIGEgbG9ja2VkIHdvcmtpbmcgdHJlZSwgbG9jayByZWFzb246ICVzXG4iCkBAIC0yMDczMSw3ICsyMDc5NCw3IEBACiAia2FuIGludGUgZmx5dHRhIGVuIGzDpXN0IGFyYmV0c2thdGFsb2csIG9yc2FrIHRpbGwgbMOlczogJXNcbiIKICJhbnbDpG5kIFwibW92ZSAtZiAtZlwiIGbDtnIgYXR0IMO2dmVyc3R5cmEsIGVsbGVyIGzDpXMgdXBwIGbDtnJzdCIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjgyMworIzogYnVpbHRpbi93b3JrdHJlZS5jOjgyMgogbXNnaWQgIiIKICJjYW5ub3QgbW92ZSBhIGxvY2tlZCB3b3JraW5nIHRyZWU7XG4iCiAidXNlICdtb3ZlIC1mIC1mJyB0byBvdmVycmlkZSBvciB1bmxvY2sgZmlyc3QiCkBAIC0yMDczOSwzNiArMjA4MDIsMzggQEAKICJrYW4gaW50ZSBmbHl0dGEgZW4gbMOlc3QgYXJiZXRza2F0YWxvZztcbiIKICJhbnbDpG5kIFwibW92ZSAtZiAtZlwiIGbDtnIgYXR0IMO2dmVyc3R5cmEsIGVsbGVyIGzDpXMgdXBwIGbDtnJzdCIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjgyNgorIzogYnVpbHRpbi93b3JrdHJlZS5jOjgyNQogIywgYy1mb3JtYXQKIG1zZ2lkICJ2YWxpZGF0aW9uIGZhaWxlZCwgY2Fubm90IG1vdmUgd29ya2luZyB0cmVlOiAlcyIKIG1zZ3N0ciAia29udHJvbGwgbWlzc2x5Y2thZGVzLCBrYW4gaW50ZSBmbHl0dGEgYXJiZXRza2F0YWxvZzogJXMiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4MzEKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4MzAKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIG1vdmUgJyVzJyB0byAnJXMnIgogbXNnc3RyICJtaXNzbHlja2FkZXMgZmx5dHRhIFwiJXNcIiB0aWxsIFwiJXNcIiIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjg3OQorIzogYnVpbHRpbi93b3JrdHJlZS5jOjg3OAogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gcnVuICdnaXQgc3RhdHVzJyBvbiAnJXMnIgogbXNnc3RyICJtaXNzbHlja2FkZXMga8O2cmEgXCJnaXQgc3RhdHVzXCIgcMOlIFwiJXNcIiIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjg4MworIzogYnVpbHRpbi93b3JrdHJlZS5jOjg4MgogIywgYy1mb3JtYXQKLW1zZ2lkICInJXMnIGlzIGRpcnR5LCB1c2UgLS1mb3JjZSB0byBkZWxldGUgaXQiCi1tc2dzdHIgIlwiJXNcIiDDpHIgc211dHNpZ3QsIGFudsOkbmQgLS1mb3JjZSBmw7ZyIGF0dCB0YSBib3J0IGRldCIKK21zZ2lkICInJXMnIGNvbnRhaW5zIG1vZGlmaWVkIG9yIHVudHJhY2tlZCBmaWxlcywgdXNlIC0tZm9yY2UgdG8gZGVsZXRlIGl0IgorbXNnc3RyICIiCisiXCIlc1wiIGlubmVow6VsbGVyIMOkbmRyYWRlIGVsbGVyIG9zcMOlcmFkZSBmaWxlciwgYW52w6RuZCAtLWZvcmNlIGbDtnIgYXR0IHRhICIKKyJib3J0IGRldCIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjg4OAorIzogYnVpbHRpbi93b3JrdHJlZS5jOjg4NwogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gcnVuICdnaXQgc3RhdHVzJyBvbiAnJXMnLCBjb2RlICVkIgogbXNnc3RyICJtaXNzbHlja2FkZXMga8O2cmEgXCJnaXQgc3RhdHVzXCIgcMOlIFwiJXNcIiwga29kICVkIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6OTExCisjOiBidWlsdGluL3dvcmt0cmVlLmM6OTEwCiBtc2dpZCAiZm9yY2UgcmVtb3ZhbCBldmVuIGlmIHdvcmt0cmVlIGlzIGRpcnR5IG9yIGxvY2tlZCIKIG1zZ3N0ciAidHZpbmdhIHRhIGJvcnQgw6R2ZW4gb20gYXJiZXRza2F0YWxvZ2VuIMOkciBzbXV0c2lnIGVsbGVyIGzDpXN0IgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6OTM0CisjOiBidWlsdGluL3dvcmt0cmVlLmM6OTMzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJjYW5ub3QgcmVtb3ZlIGEgbG9ja2VkIHdvcmtpbmcgdHJlZSwgbG9jayByZWFzb246ICVzXG4iCkBAIC0yMDc3Nyw3ICsyMDg0Miw3IEBACiAia2FuIGludGUgdGEgYm9ydCBlbiBsw6VzdCBhcmJldHNrYXRhbG9nLCBvcnNhayB0aWxsIGzDpXNldDogJXNcbiIKICJhbnbDpG5kIFwicmVtb3ZlIC1mIC1mXCIgZsO2ciBhdHQgw7Z2ZXJzdHlyYSwgZWxsZXIgbMOlcyB1cHAgZsO2cnN0IgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6OTM2CisjOiBidWlsdGluL3dvcmt0cmVlLmM6OTM1CiBtc2dpZCAiIgogImNhbm5vdCByZW1vdmUgYSBsb2NrZWQgd29ya2luZyB0cmVlO1xuIgogInVzZSAncmVtb3ZlIC1mIC1mJyB0byBvdmVycmlkZSBvciB1bmxvY2sgZmlyc3QiCkBAIC0yMDc4NSw3ICsyMDg1MCw3IEBACiAia2FuIGludGUgdGEgYm9ydCBlbiBsw6VzdCBhcmJldHNrYXRhbG9nO1xuIgogImFudsOkbmQgXCJyZW1vdmUgLWYgLWZcIiBmw7ZyIGF0dCDDtnZlcnN0eXJhLCBlbGxlciBsw6VzIHVwcCBmw7Zyc3QiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo5MzkKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo5MzgKICMsIGMtZm9ybWF0CiBtc2dpZCAidmFsaWRhdGlvbiBmYWlsZWQsIGNhbm5vdCByZW1vdmUgd29ya2luZyB0cmVlOiAlcyIKIG1zZ3N0ciAia29udHJvbGwgbWlzc2x5Y2thZGVzLCBrYW4gaW50ZSB0YSBib3J0IGFyYmV0c2thdGFsb2c6ICVzIgpAQCAtMjA4MDYsNiArMjA4NzEsMTYgQEAKIG1zZ2lkICJvbmx5IHVzZWZ1bCBmb3IgZGVidWdnaW5nIgogbXNnc3RyICJlbmRhc3QgYW52w6RuZGJhcnQgdmlkIGZlbHPDtmtuaW5nIgogCisjOiBmYXN0LWltcG9ydC5jOjMxMTgKKyMsIGMtZm9ybWF0Cittc2dpZCAiRXhwZWN0ZWQgJ21hcmsnIGNvbW1hbmQsIGdvdCAlcyIKK21zZ3N0ciAiRsO2cnbDpG50YWRlIFwibWFya1wiLWtvbW1hbmRvLCBmaWNrICVzIgorCisjOiBmYXN0LWltcG9ydC5jOjMxMjMKKyMsIGMtZm9ybWF0Cittc2dpZCAiRXhwZWN0ZWQgJ3RvJyBjb21tYW5kLCBnb3QgJXMiCittc2dzdHIgIkbDtnJ2w6RudGFkZSBcInRvXCIta29tbWFuZG8sIGZpY2sgJXMiCisKICM6IGNyZWRlbnRpYWwtY2FjaGUtLWRhZW1vbi5jOjIyMwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCkBAIC0yMDkxOCwzOSArMjA5OTMsMzkgQEAKICJhbGlhc2V0IFwiJXNcIiDDpG5kcmFyIG1pbGrDtnZhcmlhYmxlci5cbiIKICJEdSBrYW4gYW52w6RuZGEgXCIhZ2l0XCIgaSBhbGlhc2V0IGbDtnIgYXR0IGfDtnJhIGRldCIKIAotIzogZ2l0LmM6Mzc3CisjOiBnaXQuYzozNzYKICMsIGMtZm9ybWF0CiBtc2dpZCAiZW1wdHkgYWxpYXMgZm9yICVzIgogbXNnc3RyICJ0b210IGFsaWFzIGbDtnIgJXMiCiAKLSM6IGdpdC5jOjM4MAorIzogZ2l0LmM6Mzc5CiAjLCBjLWZvcm1hdAogbXNnaWQgInJlY3Vyc2l2ZSBhbGlhczogJXMiCiBtc2dzdHIgInJla3Vyc2l2dCBhbGlhczogJXMiCiAKLSM6IGdpdC5jOjQ2MAorIzogZ2l0LmM6NDU5CiBtc2dpZCAid3JpdGUgZmFpbHVyZSBvbiBzdGFuZGFyZCBvdXRwdXQiCiBtc2dzdHIgInNrcml2ZmVsIHDDpSBzdGFuZGFyZCB1dCIKIAotIzogZ2l0LmM6NDYyCisjOiBnaXQuYzo0NjEKIG1zZ2lkICJ1bmtub3duIHdyaXRlIGZhaWx1cmUgb24gc3RhbmRhcmQgb3V0cHV0IgogbXNnc3RyICJva8OkbnQgc2tyaXZmZWwgcMOlIHN0YW5kYXJkIHV0IgogCi0jOiBnaXQuYzo0NjQKKyM6IGdpdC5jOjQ2MwogbXNnaWQgImNsb3NlIGZhaWxlZCBvbiBzdGFuZGFyZCBvdXRwdXQiCiBtc2dzdHIgInN0w6RuZyBtaXNzbHlja2FkZXMgcMOlIHN0YW5kYXJkIHV0IgogCi0jOiBnaXQuYzo3OTYKKyM6IGdpdC5jOjc5MgogIywgYy1mb3JtYXQKIG1zZ2lkICJhbGlhcyBsb29wIGRldGVjdGVkOiBleHBhbnNpb24gb2YgJyVzJyBkb2VzIG5vdCB0ZXJtaW5hdGU6JXMiCiBtc2dzdHIgImFsaWFzLXNsaW5nYSBkZXRla3RlcmFkZXM6IGV4cGFuc2lvbmVuIGF2IFwiJXNcIiBhdnNsdXRhcyBhbGRyaWc6JXMiCiAKLSM6IGdpdC5jOjg0NgorIzogZ2l0LmM6ODQyCiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCBoYW5kbGUgJXMgYXMgYSBidWlsdGluIgogbXNnc3RyICJrYW4gaW50ZSBoYW50ZXJhICVzIHNvbSBpbmJ5Z2dkIgogCi0jOiBnaXQuYzo4NTkKKyM6IGdpdC5jOjg1NQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAidXNhZ2U6ICVzXG4iCkBAIC0yMDk1OSwxMyArMjEwMzQsMTMgQEAKICJhbnbDpG5kbmluZzogJXNcbiIKICJcbiIKIAotIzogZ2l0LmM6ODc5CisjOiBnaXQuYzo4NzUKICMsIGMtZm9ybWF0CiBtc2dpZCAiZXhwYW5zaW9uIG9mIGFsaWFzICclcycgZmFpbGVkOyAnJXMnIGlzIG5vdCBhIGdpdCBjb21tYW5kXG4iCiBtc2dzdHIgIiIKICJleHBhbmRlcmluZyBhdiBhbGlhcyBcIiVzXCIgbWlzc2x5Y2thZGVzOyBcIiVzXCIgw6RyIGludGUgZXR0IGdpdC1rb21tYW5kb1xuIgogCi0jOiBnaXQuYzo4OTEKKyM6IGdpdC5jOjg4NwogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gcnVuIGNvbW1hbmQgJyVzJzogJXNcbiIKIG1zZ3N0ciAibWlzc2x5Y2thZGVzIGvDtnJhIGtvbW1hbmRvdCBcIiVzXCI6ICVzXG4iCkBAIC0yMDk4MywzMCArMjEwNTgsMzAgQEAKIG1zZ2lkICJQdWJsaWMga2V5IHBpbm5pbmcgbm90IHN1cHBvcnRlZCB3aXRoIGNVUkwgPCA3LjQ0LjAiCiBtc2dzdHIgIkZhc3Ruw6VsbmluZyBhdiDDtnBwZW4gbnlja2VsIHN0w7ZkcyBpbnRlIGF2IGNVUkwgPCA3LjQ0LjAiCiAKLSM6IGh0dHAuYzo4NzYKKyM6IGh0dHAuYzo4NzgKIG1zZ2lkICJDVVJMU1NMT1BUX05PX1JFVk9LRSBub3Qgc3VwcG9ydGVkIHdpdGggY1VSTCA8IDcuNDQuMCIKIG1zZ3N0ciAiQ1VSTFNTTE9QVF9OT19SRVZPS0Ugc3TDtmRzIGludGUgYXYgY1VSTCA8IDcuNDQuMCIKIAotIzogaHR0cC5jOjk0OQorIzogaHR0cC5jOjk1MQogbXNnaWQgIlByb3RvY29sIHJlc3RyaWN0aW9ucyBub3Qgc3VwcG9ydGVkIHdpdGggY1VSTCA8IDcuMTkuNCIKIG1zZ3N0ciAiUHJ0b2tvbGxiZWdyw6Ruc25pbmdhciBzdMO2ZHMgaW50ZSBhdiBjVVJMIDwgNy4xOS40IgogCi0jOiBodHRwLmM6MTA4NQorIzogaHR0cC5jOjEwODgKICMsIGMtZm9ybWF0CiBtc2dpZCAiVW5zdXBwb3J0ZWQgU1NMIGJhY2tlbmQgJyVzJy4gU3VwcG9ydGVkIFNTTCBiYWNrZW5kczoiCiBtc2dzdHIgIlNTTC1iYWvDpG5kYW4gXCIlc1wiIHN0w7ZkcyBpbnRlLiBEZXNzYSBTU0wtYmFrw6RuZG9yIHN0w7ZkczoiCiAKLSM6IGh0dHAuYzoxMDkyCisjOiBodHRwLmM6MTA5NQogIywgYy1mb3JtYXQKIG1zZ2lkICJDb3VsZCBub3Qgc2V0IFNTTCBiYWNrZW5kIHRvICclcyc6IGNVUkwgd2FzIGJ1aWx0IHdpdGhvdXQgU1NMIGJhY2tlbmRzIgogbXNnc3RyICJLYW4gaW50ZSBzw6R0dGEgU1NMLWJha8OkbmRhIHRpbGwgXCIlc1wiOiBjVVJMIGJ5Z2dkZXMgdXRhbiBTU0wtYmFrw6RuZG9yIgogCi0jOiBodHRwLmM6MTA5NgorIzogaHR0cC5jOjEwOTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ291bGQgbm90IHNldCBTU0wgYmFja2VuZCB0byAnJXMnOiBhbHJlYWR5IHNldCIKIG1zZ3N0ciAiS3VuZGUgaW50ZSBzw6R0dGEgU1NMLWJha8OkbmRhIHRpbGwgXCIlc1wiOiByZWRhbiB2YWx0IgogCi0jOiBodHRwLmM6MTk2NQorIzogaHR0cC5jOjE5NjgKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogInVuYWJsZSB0byB1cGRhdGUgdXJsIGJhc2UgZnJvbSByZWRpcmVjdGlvbjpcbiIKQEAgLTIxMDE3LDEyOCArMjEwOTIsMTI4IEBACiAiICAgICAgICBiYWQgb206ICVzXG4iCiAiICBvbWRpcmlnZXJpbmc6ICVzIgogCi0jOiByZW1vdGUtY3VybC5jOjE1NworIzogcmVtb3RlLWN1cmwuYzoxNjYKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBxdW90aW5nIGluIHB1c2gtb3B0aW9uIHZhbHVlOiAnJXMnIgogbXNnc3RyICJmZWxha3RpZyBjaXRlcmluZyBww6UgdsOkcmRlIGbDtnIgcHVzaC1vcHRpb246IFwiJXNcIiIKIAotIzogcmVtb3RlLWN1cmwuYzoyNTQKKyM6IHJlbW90ZS1jdXJsLmM6MjYzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzaW5mby9yZWZzIG5vdCB2YWxpZDogaXMgdGhpcyBhIGdpdCByZXBvc2l0b3J5PyIKIG1zZ3N0ciAiJXNpbmZvL3JlZnMgaW50ZSBnaWx0aWc6IMOkciBkZXR0YSBldHQgZ2l0LWFya2l2PyIKIAotIzogcmVtb3RlLWN1cmwuYzozNTUKKyM6IHJlbW90ZS1jdXJsLmM6MzY0CiBtc2dpZCAiaW52YWxpZCBzZXJ2ZXIgcmVzcG9uc2U7IGV4cGVjdGVkIHNlcnZpY2UsIGdvdCBmbHVzaCBwYWNrZXQiCiBtc2dzdHIgIm9naWx0aWd0IHN2YXIgZnLDpW4gc2VydmVybjsgZsO2cnbDpG50YWRlIHRqw6Ruc3QsIGZpY2sgZmx1c2gtcGFrZXQiCiAKLSM6IHJlbW90ZS1jdXJsLmM6Mzg2CisjOiByZW1vdGUtY3VybC5jOjM5NQogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIHNlcnZlciByZXNwb25zZTsgZ290ICclcyciCiBtc2dzdHIgIm9naWx0aWd0IHN2YXIgZnLDpW4gc2VydmVybjsgZmljayBcIiVzXCIiCiAKLSM6IHJlbW90ZS1jdXJsLmM6NDQ2CisjOiByZW1vdGUtY3VybC5jOjQ1NQogIywgYy1mb3JtYXQKIG1zZ2lkICJyZXBvc2l0b3J5ICclcycgbm90IGZvdW5kIgogbXNnc3RyICJhcmtpdmV0IFwiJXNcIiBoaXR0YWRlcyBpbnRlIgogCi0jOiByZW1vdGUtY3VybC5jOjQ1MAorIzogcmVtb3RlLWN1cmwuYzo0NTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiQXV0aGVudGljYXRpb24gZmFpbGVkIGZvciAnJXMnIgogbXNnc3RyICJBdXRlbnRpc2VyaW5nIG1pc3NseWNrYWRlcyBcIiVzXCIiCiAKLSM6IHJlbW90ZS1jdXJsLmM6NDU0CisjOiByZW1vdGUtY3VybC5jOjQ2MwogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gYWNjZXNzICclcyc6ICVzIgogbXNnc3RyICJrYW4gaW50ZSBrb21tYSDDpXQgXCIlc1wiOiAlcyIKIAotIzogcmVtb3RlLWN1cmwuYzo0NjAKKyM6IHJlbW90ZS1jdXJsLmM6NDY5CiAjLCBjLWZvcm1hdAogbXNnaWQgInJlZGlyZWN0aW5nIHRvICVzIgogbXNnc3RyICJvbWRpcmlnZXJhciB0aWxsICVzIgogCi0jOiByZW1vdGUtY3VybC5jOjU4NAorIzogcmVtb3RlLWN1cmwuYzo1OTMKIG1zZ2lkICJzaG91bGRuJ3QgaGF2ZSBFT0Ygd2hlbiBub3QgZ2VudGxlIG9uIEVPRiIKIG1zZ3N0ciAiYm9yZGUgaW50ZSBoYSBFT0YgbsOkciBpbnRlIGbDtnJzaWt0aWcgcMOlIEVPRiIKIAotIzogcmVtb3RlLWN1cmwuYzo2NjQKKyM6IHJlbW90ZS1jdXJsLmM6NjczCiBtc2dpZCAidW5hYmxlIHRvIHJld2luZCBycGMgcG9zdCBkYXRhIC0gdHJ5IGluY3JlYXNpbmcgaHR0cC5wb3N0QnVmZmVyIgogbXNnc3RyICJrdW5kZSBpbnRlIHNwb2xhIHRpbGxiYWthIHJwYy1wb3N0ZGF0YSAtIGbDtnJzw7ZrIMO2a2EgaHR0cC5wb3N0QnVmZmVyIgogCi0jOiByZW1vdGUtY3VybC5jOjcyNAorIzogcmVtb3RlLWN1cmwuYzo3MzMKICMsIGMtZm9ybWF0CiBtc2dpZCAiUlBDIGZhaWxlZDsgJXMiCiBtc2dzdHIgIlJQQyBtaXNzbHlja2FkZXM7ICVzIgogCi0jOiByZW1vdGUtY3VybC5jOjc2NAorIzogcmVtb3RlLWN1cmwuYzo3NzMKIG1zZ2lkICJjYW5ub3QgaGFuZGxlIHB1c2hlcyB0aGlzIGJpZyIKIG1zZ3N0ciAia2FuIGludGUgaGFudGVyYSBzw6Ugc3RvcmEgc8OkbmRuaW5nYXIiCiAKLSM6IHJlbW90ZS1jdXJsLmM6ODc5CisjOiByZW1vdGUtY3VybC5jOjg4OAogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgZGVmbGF0ZSByZXF1ZXN0OyB6bGliIGRlZmxhdGUgZXJyb3IgJWQiCiBtc2dzdHIgImthbiBpbnRlIHBhY2thIHVwcCBhbnJvcDsgemxpYi1kZWZsYXRlLWZlbCAlZCIKIAotIzogcmVtb3RlLWN1cmwuYzo4ODMKKyM6IHJlbW90ZS1jdXJsLmM6ODkyCiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCBkZWZsYXRlIHJlcXVlc3Q7IHpsaWIgZW5kIGVycm9yICVkIgogbXNnc3RyICJrYW4gaW50ZSBwYWNrYSB1cHAgYW5yb3A7IHpsaWItc2x1dGZlbCAlZCIKIAotIzogcmVtb3RlLWN1cmwuYzoxMDE0CisjOiByZW1vdGUtY3VybC5jOjEwMjMKIG1zZ2lkICJkdW1iIGh0dHAgdHJhbnNwb3J0IGRvZXMgbm90IHN1cHBvcnQgc2hhbGxvdyBjYXBhYmlsaXRpZXMiCiBtc2dzdHIgImR1bSBodHRwLXRyYW5zcG9ydCBzdMO2ZGVyIGludGUgZ3J1bmRhIGFya2l2IgogCi0jOiByZW1vdGUtY3VybC5jOjEwMjgKKyM6IHJlbW90ZS1jdXJsLmM6MTAzNwogbXNnaWQgImZldGNoIGZhaWxlZC4iCiBtc2dzdHIgIm1vdHRhZ25pbmcgbWlzc2x5Y2thZGVzLiIKIAotIzogcmVtb3RlLWN1cmwuYzoxMDc2CisjOiByZW1vdGUtY3VybC5jOjEwODUKIG1zZ2lkICJjYW5ub3QgZmV0Y2ggYnkgc2hhMSBvdmVyIHNtYXJ0IGh0dHAiCiBtc2dzdHIgImthbiBpbnRlIGjDpG10YSBtZWQgc2hhMSDDtnZlciBzbWFydCBodHRwIgogCi0jOiByZW1vdGUtY3VybC5jOjExMjAgcmVtb3RlLWN1cmwuYzoxMTI2CisjOiByZW1vdGUtY3VybC5jOjExMjkgcmVtb3RlLWN1cmwuYzoxMTM1CiAjLCBjLWZvcm1hdAogbXNnaWQgInByb3RvY29sIGVycm9yOiBleHBlY3RlZCBzaGEvcmVmLCBnb3QgJyVzJyIKIG1zZ3N0ciAicHJvdG9rb2xsZmVsOiBmw7ZydsOkbnRhZGUgc2hhL3JlZiwgZmljayBcIiVzXCIiCiAKLSM6IHJlbW90ZS1jdXJsLmM6MTEzOCByZW1vdGUtY3VybC5jOjEyNTIKKyM6IHJlbW90ZS1jdXJsLmM6MTE0NyByZW1vdGUtY3VybC5jOjEyNjEKICMsIGMtZm9ybWF0CiBtc2dpZCAiaHR0cCB0cmFuc3BvcnQgZG9lcyBub3Qgc3VwcG9ydCAlcyIKIG1zZ3N0ciAiaHR0cC10cmFuc3BvcnRlbiBzdMO2ZGVyIGludGUgJXMiCiAKLSM6IHJlbW90ZS1jdXJsLmM6MTE3NAorIzogcmVtb3RlLWN1cmwuYzoxMTgzCiBtc2dpZCAiZ2l0LWh0dHAtcHVzaCBmYWlsZWQiCiBtc2dzdHIgImdpdC1odHRwLXB1c2ggbWlzc2x5Y2thZGVzIgogCi0jOiByZW1vdGUtY3VybC5jOjEzNjAKKyM6IHJlbW90ZS1jdXJsLmM6MTM2NwogbXNnaWQgInJlbW90ZS1jdXJsOiB1c2FnZTogZ2l0IHJlbW90ZS1jdXJsIDxyZW1vdGU+IFs8dXJsPl0iCiBtc2dzdHIgInJlbW90ZS1jdXJsOiBhbnbDpG5kbmluZzogZ2l0IHJlbW90ZS1jdXJsIDxmasOkcnI+IFs8dXJsPl0iCiAKLSM6IHJlbW90ZS1jdXJsLmM6MTM5MgorIzogcmVtb3RlLWN1cmwuYzoxMzk5CiBtc2dpZCAicmVtb3RlLWN1cmw6IGVycm9yIHJlYWRpbmcgY29tbWFuZCBzdHJlYW0gZnJvbSBnaXQiCiBtc2dzdHIgInJlbW90ZS1jdXJsOiBmZWwgdmlkIGzDpHNuaW5nIGF2IGtvbW1hbmRvc3Ryw7ZtIGZyw6VuIGdpdCIKIAotIzogcmVtb3RlLWN1cmwuYzoxMzk5CisjOiByZW1vdGUtY3VybC5jOjE0MDYKIG1zZ2lkICJyZW1vdGUtY3VybDogZmV0Y2ggYXR0ZW1wdGVkIHdpdGhvdXQgYSBsb2NhbCByZXBvIgogbXNnc3RyICJyZW1vdGUtY3VybDogZsO2cnPDtmt0ZSB0YSBlbW90IHV0YW4gbG9rYWx0IGFya2l2IgogCi0jOiByZW1vdGUtY3VybC5jOjE0MzkKKyM6IHJlbW90ZS1jdXJsLmM6MTQ0NgogIywgYy1mb3JtYXQKIG1zZ2lkICJyZW1vdGUtY3VybDogdW5rbm93biBjb21tYW5kICclcycgZnJvbSBnaXQiCiBtc2dzdHIgInJlbW90ZS1jdXJsOiBva8OkbnQga29tbWFuZG8gXCIlc1wiIGZyw6VuIGdpdCIKIAotIzogbGlzdC1vYmplY3RzLWZpbHRlci1vcHRpb25zLmg6NjEKKyM6IGxpc3Qtb2JqZWN0cy1maWx0ZXItb3B0aW9ucy5oOjg1CiBtc2dpZCAiYXJncyIKIG1zZ3N0ciAiYXJndW1lbnQiCiAKLSM6IGxpc3Qtb2JqZWN0cy1maWx0ZXItb3B0aW9ucy5oOjYyCisjOiBsaXN0LW9iamVjdHMtZmlsdGVyLW9wdGlvbnMuaDo4NgogbXNnaWQgIm9iamVjdCBmaWx0ZXJpbmciCiBtc2dzdHIgIm9iamVrdGZpbHRyZXJpbmciCiAKLSM6IHBhcnNlLW9wdGlvbnMuaDoxNzAKKyM6IHBhcnNlLW9wdGlvbnMuaDoxNzkKIG1zZ2lkICJleHBpcnktZGF0ZSIKIG1zZ3N0ciAiZ2lsdGlnLXRpbGwiCiAKLSM6IHBhcnNlLW9wdGlvbnMuaDoxODQKKyM6IHBhcnNlLW9wdGlvbnMuaDoxOTMKIG1zZ2lkICJuby1vcCAoYmFja3dhcmQgY29tcGF0aWJpbGl0eSkiCiBtc2dzdHIgImluZ2VuIGZ1bmt0aW9uIChiYWvDpXRrb21wYXRpYmlsaXRldCkiCiAKQEAgLTIxMTcwLDExICsyMTI0NSwxMSBAQAogbXNnaWQgInVwZGF0ZSB0aGUgaW5kZXggd2l0aCByZXVzZWQgY29uZmxpY3QgcmVzb2x1dGlvbiBpZiBwb3NzaWJsZSIKIG1zZ3N0ciAidXBwZGF0ZXJhIGluZGV4ZXQgbWVkIMOldGVyYW52w6RuZCBrb25mbGlrdGzDtnNuaW5nIG9tIG3DtmpsaWd0IgogCi0jOiB3dC1zdGF0dXMuaDo2OAorIzogd3Qtc3RhdHVzLmg6NjcKIG1zZ2lkICJIRUFEIGRldGFjaGVkIGF0ICIKIG1zZ3N0ciAiSEVBRCBmcsOlbmtvcHBsYWQgdmlkICIKIAotIzogd3Qtc3RhdHVzLmg6NjkKKyM6IHd0LXN0YXR1cy5oOjY4CiBtc2dpZCAiSEVBRCBkZXRhY2hlZCBmcm9tICIKIG1zZ3N0ciAiSEVBRCBmcsOlbmtvcHBsYWQgZnLDpW4gIgogCkBAIC0yMTM4NSw3ICsyMTQ2MCw3IEBACiAKICM6IGNvbW1hbmQtbGlzdC5oOjEwMQogbXNnaWQgIkV4dHJhY3QgY29tbWl0IElEIGZyb20gYW4gYXJjaGl2ZSBjcmVhdGVkIHVzaW5nIGdpdC1hcmNoaXZlIgotbXNnc3RyICJIw6RtdGEgaW5jaGVja25pbmdzLUlEIGZyw6VuIGV0dCBhcmtpdiBza2FwYXQgbWVkIGdpdC1hcmNoaXZlIgorbXNnc3RyICJIw6RtdGEgaW5jaGVja25pbmdzLWlkIGZyw6VuIGV0dCBhcmtpdiBza2FwYXQgbWVkIGdpdC1hcmNoaXZlIgogCiAjOiBjb21tYW5kLWxpc3QuaDoxMDIKIG1zZ2lkICJQcmludCBsaW5lcyBtYXRjaGluZyBhIHBhdHRlcm4iCkBAIC0yMTM5Nyw3ICsyMTQ3Miw3IEBACiAKICM6IGNvbW1hbmQtbGlzdC5oOjEwNAogbXNnaWQgIkNvbXB1dGUgb2JqZWN0IElEIGFuZCBvcHRpb25hbGx5IGNyZWF0ZXMgYSBibG9iIGZyb20gYSBmaWxlIgotbXNnc3RyICJCZXLDpGtuYSBvYmpla3QtSUQgb2NoIG3DtmpsaWdlbiBza2FwYSBlbiBibG9iIGZyw6VuIGVuIGZpbCIKK21zZ3N0ciAiQmVyw6RrbmEgb2JqZWt0LWlkIG9jaCBtw7ZqbGlnZW4gc2thcGEgZW4gYmxvYiBmcsOlbiBlbiBmaWwiCiAKICM6IGNvbW1hbmQtbGlzdC5oOjEwNQogbXNnaWQgIkRpc3BsYXkgaGVscCBpbmZvcm1hdGlvbiBhYm91dCBHaXQiCkBAIC0yMzUyNCw2ICsyMzU5OSw3NSBAQAogbXNnaWQgIkRvIHlvdSByZWFsbHkgd2FudCB0byBzZW5kICVzPyBbeXxOXTogIgogbXNnc3RyICJWaWxsIGR1IHZlcmtsaWdlbiBzw6RuZGEgJXM/IFt5PWphLCBuPW5lal06ICIKIAorI34gbXNnaWQgInVua25vd24gY29yZS51bnRyYWNrZWRDYWNoZSB2YWx1ZSAnJXMnOyB1c2luZyAna2VlcCcgZGVmYXVsdCB2YWx1ZSIKKyN+IG1zZ3N0ciAiIgorI34gIm9rw6RudCB2w6RyZGUgXCIlc1wiIGbDtnIgY29yZS51bnRyYWNrZWRDYWNoZTsgYW52w6RuZGVyIHN0YW5kYXJkdsOkcmRldCBcImtlZXAiCisjfiAiXCIiCisKKyN+IG1zZ2lkICJjYW5ub3QgY2hhbmdlIHBhcnRpYWwgY2xvbmUgcHJvbWlzb3IgcmVtb3RlIgorI34gbXNnc3RyICJrYW4gaW50ZSDDpG5kcmEga29udHJha3RzZmrDpHJyIGbDtnIgZGVsdmlzIGtsb25pbmciCisKKyN+IG1zZ2lkICJlcnJvciBidWlsZGluZyB0cmVlcyIKKyN+IG1zZ3N0ciAiZmVsIHZpZCBieWdnYW5kZSBhdiB0csOkZCIKKworI34gbXNnaWQgImludmFsaWQgZGF0ZSBmb3JtYXQgJyVzJyBpbiAnJXMnIgorI34gbXNnc3RyICJvZ2lsdGlndCBkYXR1bWZvcm1hdCBcIiVzXCIgaSBcIiVzXCIiCisKKyN+IG1zZ2lkICJ3cml0aW5nIHJvb3QgY29tbWl0IgorI34gbXNnc3RyICJza3JpdmVyIHJvdGluY2hlY2tuaW5nIgorCisjfiBtc2dpZCAic3RhZ2VkIGNoYW5nZXMgaW4gdGhlIGZvbGxvd2luZyBmaWxlcyBtYXkgYmUgbG9zdDogJXMiCisjfiBtc2dzdHIgImvDtmFkZSDDpG5kcmluZ2FyIGkgZsO2bGphbmRlIGZpbGVyIGthbiBnw6UgZsO2cmxvcmFkZTogJXMiCisKKyN+IG1zZ2lkICIiCisjfiAiLS1maWx0ZXIgY2FuIG9ubHkgYmUgdXNlZCB3aXRoIHRoZSByZW1vdGUgY29uZmlndXJlZCBpbiBleHRlbnNpb25zLiIKKyN+ICJwYXJ0aWFsQ2xvbmUiCisjfiBtc2dzdHIgIiIKKyN+ICItLWZpbHRlciBrYW4gZW5kYXN0IGFudsOkbmRhcyBtZWQgZmrDpHJyZW4ga29uZmlndXJlcmFkIGkgZXh0ZW5zaW9ucy4iCisjfiAicGFydGlhbENsb25lIgorCisjfiBtc2dpZCAidmVyaWZ5IGNvbW1pdC1tc2cgaG9vayIKKyN+IG1zZ3N0ciAiYmVrcsOkZnRhIGNvbW1pdC1tc2cta3JvayIKKworI34gbXNnaWQgImNhbm5vdCBjb21iaW5lICctLXJlYmFzZS1tZXJnZXMnIHdpdGggJy0tc3RyYXRlZ3ktb3B0aW9uJyIKKyN+IG1zZ3N0ciAia2FuIGludGUga29tYmluZXJhIFwiLS1yZWJhc2UtbWVyZ2VzXCIgbWVkIFwiLS1zdHJhdGVneS1vcHRpb25cIiIKKworI34gbXNnaWQgImludmFsaWQgc3BhcnNlIHZhbHVlICclcyciCisjfiBtc2dzdHIgIm9naWx0aWd0IHbDpHJkZSBmw7ZyIHNwYXJzZTogXCIlc1wiIgorCisjfiBtc2dpZCAiIgorI34gIkZldGNoIG5vcm1hbGx5IGluZGljYXRlcyB3aGljaCBicmFuY2hlcyBoYWQgYSBmb3JjZWQgdXBkYXRlLCBidXQgdGhhdCAiCisjfiAiY2hlY2sgaGFzIGJlZW4gZGlzYWJsZWQuIgorI34gbXNnc3RyICIiCisjfiAiSMOkbXRuaW5nIHZpc2FyIHZhbmxpZ3R2aXMgdmlsa2EgZ3JlbmFyIHNvbSBoYXIgZW4gdHZpbmdhZCB1cHBkYXRlcmluZywgIgorI34gIm1lbiBkZXQgdGVzdGV0IGhhciBzbGFnaXRzIGF2LiIKKworI34gbXNnaWQgIiIKKyN+ICJvciBydW4gJ2dpdCBjb25maWcgZmV0Y2guc2hvd0ZvcmNlZFVwZGF0ZXMgZmFsc2UnIHRvIGF2b2lkIHRoaXMgY2hlY2suXG4iCisjfiBtc2dzdHIgIiIKKyN+ICJlbGxlciBrw7ZyIFwiZ2l0IGNvbmZpZyBmZXRjaC5zaG93Rm9yY2VkVXBkYXRlcyBmYWxzZVwiIGbDtnIgdW5kdmlrYSAiCisjfiAidGVzdGV0LlxuIgorCisjfiBtc2dpZCAiIgorI34gImxvZy5tYWlsbWFwIGlzIG5vdCBzZXQ7IGl0cyBpbXBsaWNpdCB2YWx1ZSB3aWxsIGNoYW5nZSBpbiBhblxuIgorI34gInVwY29taW5nIHJlbGVhc2UuIFRvIHNxdWVsY2ggdGhpcyBtZXNzYWdlIGFuZCBwcmVzZXJ2ZSBjdXJyZW50XG4iCisjfiAiYmVoYXZpb3VyLCBzZXQgdGhlIGxvZy5tYWlsbWFwIGNvbmZpZ3VyYXRpb24gdmFsdWUgdG8gZmFsc2UuXG4iCisjfiAiXG4iCisjfiAiVG8gc3F1ZWxjaCB0aGlzIG1lc3NhZ2UgYW5kIGFkb3B0IHRoZSBuZXcgYmVoYXZpb3VyIG5vdywgc2V0IHRoZVxuIgorI34gImxvZy5tYWlsbWFwIGNvbmZpZ3VyYXRpb24gdmFsdWUgdG8gdHJ1ZS5cbiIKKyN+ICJcbiIKKyN+ICJTZWUgJ2dpdCBoZWxwIGNvbmZpZycgYW5kIHNlYXJjaCBmb3IgJ2xvZy5tYWlsbWFwJyBmb3IgZnVydGhlciAiCisjfiAiaW5mb3JtYXRpb24uIgorI34gbXNnc3RyICIiCisjfiAibG9nLm1haWxtYXAgaGFyIGludGUgc2F0dHM6IGbDtnJ2YWxldCBrb21tZXIgw6RuZHJhcyBpIGVuIGtvbW1hbmRlXG4iCisjfiAidmVyc2lvbi4gRsO2ciBhdHQgZMO2bGphIGRldCBow6RyIG1lZGRlbGFuZGV0IG9jaCBiZWjDpWxsYSBudXZhcmFuZGVcbiIKKyN+ICJiZXRlZW5kZSwgc8OkdHQga29uZmlndXJhdGlvbnN2YXJpYWJlbG4gbG9nLm1haWxtYXAgdGlsbCBmYWxzZS5cbiIKKyN+ICJcbiIKKyN+ICJGw7ZyIGF0dCBkw7ZsamEgZGV0IGjDpHIgbWVkZGVsYW5kZXQgb2NoIGFudsOkbmRhIGRldCBueWEgYmV0ZWVuZGV0LFxuIgorI34gInPDpHR0IGtvbmZpZ3VyYXRpb25zdmFyaWFiZWxuIGxvZy5tYWlsbWFwIHRpbGwgdHJ1ZS5cbiIKKyN+ICJcbiIKKyN+ICJTZSBcImdpdCBoZWxwIGNvbmZpZ1wiIG9jaCBzw7ZrIGVmdGVyIFwibG9nLm1haWxtYXBcIiBmw7ZyIG1lciBpbmZvcm1hdGlvbi4iCisKICN+IG1zZ2lkICJTZXJ2ZXIgc3VwcG9ydHMgbXVsdGlfYWNrX2RldGFpbGVkIgogI34gbXNnc3RyICJTZXJ2ZXJuIHN0w7ZkZXIgXCJtdWx0aV9hY2tfZGV0YWlsZWRcIiIKIApAQCAtMjQ0MDUsOSArMjQ1NDksNiBAQAogI34gbXNnaWQgIkNvdWxkIG5vdCBhcHBlbmQgJyVzJyIKICN+IG1zZ3N0ciAiS3VuZGUgaW50ZSBsw6RnZ2EgdGlsbCBww6UgXCIlc1wiIgogCi0jfiBtc2dpZCAiTWlzc2luZyBhdXRob3I6ICVzIgotI34gbXNnc3RyICJGw7ZyZmF0dGFyZSBzYWtuYXM6ICVzIgotCiAjfiBtc2dpZCAiVGVzdGluZyAiCiAjfiBtc2dzdHIgIlRlc3RhciIKIApAQCAtMjQ0NjUsOSArMjQ2MDYsNiBAQAogI34gbXNnaWQgIm9wdGlvbiAlcyBkb2VzIG5vdCBhY2NlcHQgbmVnYXRpdmUgZm9ybSIKICN+IG1zZ3N0ciAiZmxhZ2dhbiAlcyBnb2R0YXIgaW50ZSBuZWdhdGl2IGZvcm0iCiAKLSN+IG1zZ2lkICJ1bmFibGUgdG8gcGFyc2UgdmFsdWUgJyVzJyBmb3Igb3B0aW9uICVzIgotI34gbXNnc3RyICJrdW5kZSBpbnRlIHRvbGthIHbDpHJkZXQgXCIlc1wiIGbDtnIgZmxhZ2dhbiAlcyIKLQogI34gbXNnaWQgIi1iIGFuZCAtQiBhcmUgbXV0dWFsbHkgZXhjbHVzaXZlIgogI34gbXNnc3RyICItYiBvY2ggLUIga2FuIGludGUgYW52w6RuZGFzIHNhbXRpZGlndCIKIApkaWZmIC0tZ2l0IGEvcG8vdmkucG8gYi9wby92aS5wbwppbmRleCBiOGFhOTNhLi5hMDAyMTFmIDEwMDY0NAotLS0gYS9wby92aS5wbworKysgYi9wby92aS5wbwpAQCAtNiwxMCArNiwxMCBAQAogIwogbXNnaWQgIiIKIG1zZ3N0ciAiIgotIlByb2plY3QtSWQtVmVyc2lvbjogZ2l0IHYyLjIzLjAtcmMyXG4iCisiUHJvamVjdC1JZC1WZXJzaW9uOiBnaXQgdjIuMjQuMFxuIgogIlJlcG9ydC1Nc2dpZC1CdWdzLVRvOiBHaXQgTWFpbGluZyBMaXN0IDxnaXRAdmdlci5rZXJuZWwub3JnPlxuIgotIlBPVC1DcmVhdGlvbi1EYXRlOiAyMDE5LTA4LTEwIDIwOjEyKzA4MDBcbiIKLSJQTy1SZXZpc2lvbi1EYXRlOiAyMDE5LTA4LTExIDA3OjA4KzA3MDBcbiIKKyJQT1QtQ3JlYXRpb24tRGF0ZTogMjAxOS0xMC0yOCAxMzoxOSswODAwXG4iCisiUE8tUmV2aXNpb24tRGF0ZTogMjAxOS0xMC0yOSAxNDozNSswNzAwXG4iCiAiTGFzdC1UcmFuc2xhdG9yOiBUcuG6p24gTmfhu41jIFF1w6JuIDx2bndpbGRtYW5AZ21haWwuY29tPlxuIgogIkxhbmd1YWdlLVRlYW06IFZpZXRuYW1lc2UgPHRyYW5zbGF0aW9uLXRlYW0tdmlAbGlzdHMuc291cmNlZm9yZ2UubmV0PlxuIgogIkxhbmd1YWdlOiB2aVxuIgpAQCAtNzIsNyArNzIsNyBAQAogbXNnaWQgIkV4aXRpbmcgYmVjYXVzZSBvZiBhbiB1bnJlc29sdmVkIGNvbmZsaWN0LiIKIG1zZ3N0ciAiVGhvw6F0IHJhIGLhu59pIHbDrCB4dW5nIMSR4buZdCBraMO0bmcgdGjhu4MgZ2nhuqNpIHF1eeG6v3QuIgogCi0jOiBhZHZpY2UuYzoxOTMgYnVpbHRpbi9tZXJnZS5jOjEzMjcKKyM6IGFkdmljZS5jOjE5MyBidWlsdGluL21lcmdlLmM6MTMzMgogbXNnaWQgIllvdSBoYXZlIG5vdCBjb25jbHVkZWQgeW91ciBtZXJnZSAoTUVSR0VfSEVBRCBleGlzdHMpLiIKIG1zZ3N0ciAiQuG6oW4gY2jGsGEga+G6v3QgdGjDumMgdmnhu4djIGjDsmEgdHLhu5luIChNRVJHRV9IRUFEIHbhuqtuIHThu5NuIHThuqFpKS4iCiAKQEAgLTIxMiwxNyArMjEyLDcgQEAKIG1zZ2lkICJpbmNvbnNpc3RlbnQgaGVhZGVyIGxpbmVzICVkIGFuZCAlZCIKIG1zZ3N0ciAicGjhuqduIMSR4bqndSBtw6J1IHRodeG6q24gZMOybmcgJWQgdsOgICVkIgogCi0jOiBhcHBseS5jOjE0NjAKLSMsIGMtZm9ybWF0Ci1tc2dpZCAicmVjb3VudDogdW5leHBlY3RlZCBsaW5lOiAlLipzIgotbXNnc3RyICJjaGkgdGnhur90OiBkw7JuZyBraMO0bmcgY+G6p246ICUuKnMiCi0KLSM6IGFwcGx5LmM6MTUyOQotIywgYy1mb3JtYXQKLW1zZ2lkICJwYXRjaCBmcmFnbWVudCB3aXRob3V0IGhlYWRlciBhdCBsaW5lICVkOiAlLipzIgotbXNnc3RyICJtaeG6v25nIHbDoSBwaMOibiBt4bqjbmggbcOgIGtow7RuZyBjw7MgcGjhuqduIMSR4bqndSB04bqhaSBkw7JuZyAlZDogJS4qcyIKLQotIzogYXBwbHkuYzoxNTUxCisjOiBhcHBseS5jOjEzNzIKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogImdpdCBkaWZmIGhlYWRlciBsYWNrcyBmaWxlbmFtZSBpbmZvcm1hdGlvbiB3aGVuIHJlbW92aW5nICVkIGxlYWRpbmcgcGF0aG5hbWUgIgpAQCAtMjM0LDgxICsyMjQsOTEgQEAKICJwaOG6p24gxJHhuqd1IGRpZmYgY2hvIGdpdCAgdGhp4bq/dSB0aMO0bmcgdGluIHTDqm4gdOG6rXAgdGluIGtoaSBn4buhIGLhu48gxJFpICVkIHRyb25nICIKICJ0aMOgbmggcGjhuqduIGThuqtuIMSR4bqndSB0w6puIGPhu6dhIMSRxrDhu51uZyBk4bqrbiAoZMOybmcgJWQpIgogCi0jOiBhcHBseS5jOjE1NjQKKyM6IGFwcGx5LmM6MTM4NQogIywgYy1mb3JtYXQKIG1zZ2lkICJnaXQgZGlmZiBoZWFkZXIgbGFja3MgZmlsZW5hbWUgaW5mb3JtYXRpb24gKGxpbmUgJWQpIgogbXNnc3RyICJwaOG6p24gxJHhuqd1IGRpZmYgY2hvIGdpdCB0aGnhur91IHRow7RuZyB0aW4gdMOqbiB04bqtcCB0aW4gKGTDsm5nICVkKSIKIAotIzogYXBwbHkuYzoxNzUyCisjOiBhcHBseS5jOjE0ODEKKyMsIGMtZm9ybWF0Cittc2dpZCAicmVjb3VudDogdW5leHBlY3RlZCBsaW5lOiAlLipzIgorbXNnc3RyICJjaGkgdGnhur90OiBkw7JuZyBraMO0bmcgY+G6p246ICUuKnMiCisKKyM6IGFwcGx5LmM6MTU1MAorIywgYy1mb3JtYXQKK21zZ2lkICJwYXRjaCBmcmFnbWVudCB3aXRob3V0IGhlYWRlciBhdCBsaW5lICVkOiAlLipzIgorbXNnc3RyICJtaeG6v25nIHbDoSBwaMOibiBt4bqjbmggbcOgIGtow7RuZyBjw7MgcGjhuqduIMSR4bqndSB04bqhaSBkw7JuZyAlZDogJS4qcyIKKworIzogYXBwbHkuYzoxNzUzCiBtc2dpZCAibmV3IGZpbGUgZGVwZW5kcyBvbiBvbGQgY29udGVudHMiCiBtc2dzdHIgInThuq1wIHRpbiBt4bubaSBwaOG7pSB0aHXhu5ljIHbDoG8gbuG7mWkgZHVuZyBjxakiCiAKLSM6IGFwcGx5LmM6MTc1NAorIzogYXBwbHkuYzoxNzU1CiBtc2dpZCAiZGVsZXRlZCBmaWxlIHN0aWxsIGhhcyBjb250ZW50cyIKIG1zZ3N0ciAidOG6rXAgdGluIMSRw6MgeMOzYSB24bqrbiBjw7JuIG7hu5lpIGR1bmciCiAKLSM6IGFwcGx5LmM6MTc4OAorIzogYXBwbHkuYzoxNzg5CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvcnJ1cHQgcGF0Y2ggYXQgbGluZSAlZCIKIG1zZ3N0ciAibWnhur9uZyB2w6EgaOG7j25nIHThuqFpIGTDsm5nICVkIgogCi0jOiBhcHBseS5jOjE4MjUKKyM6IGFwcGx5LmM6MTgyNgogIywgYy1mb3JtYXQKIG1zZ2lkICJuZXcgZmlsZSAlcyBkZXBlbmRzIG9uIG9sZCBjb250ZW50cyIKIG1zZ3N0ciAidOG6rXAgdGluIG3hu5tpICVzIHBo4bulIHRodeG7mWMgdsOgbyBu4buZaSBkdW5nIGPFqSIKIAotIzogYXBwbHkuYzoxODI3CisjOiBhcHBseS5jOjE4MjgKICMsIGMtZm9ybWF0CiBtc2dpZCAiZGVsZXRlZCBmaWxlICVzIHN0aWxsIGhhcyBjb250ZW50cyIKIG1zZ3N0ciAidOG6rXAgdGluIMSRw6MgeMOzYSAlcyB24bqrbiBjw7JuIG7hu5lpIGR1bmciCiAKLSM6IGFwcGx5LmM6MTgzMAorIzogYXBwbHkuYzoxODMxCiAjLCBjLWZvcm1hdAogbXNnaWQgIioqIHdhcm5pbmc6IGZpbGUgJXMgYmVjb21lcyBlbXB0eSBidXQgaXMgbm90IGRlbGV0ZWQiCiBtc2dzdHIgIioqIGPhuqNuaCBiw6FvOiB04bqtcCB0aW4gJXMgdHLhu58gbsOqbiB0cuG7kW5nIHLhu5duZyBuaMawbmcga2jDtG5nIGLhu4sgeMOzYSIKIAotIzogYXBwbHkuYzoxOTc3CisjOiBhcHBseS5jOjE5NzgKICMsIGMtZm9ybWF0CiBtc2dpZCAiY29ycnVwdCBiaW5hcnkgcGF0Y2ggYXQgbGluZSAlZDogJS4qcyIKIG1zZ3N0ciAibWnhur9uZyB2w6EgxJHhu4tuaCBk4bqhbmcgbmjhu4sgcGjDom4gc2FpIGjhu49uZyB04bqhaSBkw7JuZyAlZDogJS4qcyIKIAotIzogYXBwbHkuYzoyMDE0CisjOiBhcHBseS5jOjIwMTUKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5yZWNvZ25pemVkIGJpbmFyeSBwYXRjaCBhdCBsaW5lICVkIgogbXNnc3RyICJtaeG6v25nIHbDoSDEkeG7i25oIGThuqFuZyBuaOG7iyBwaMOibiBraMO0bmcgxJHGsOG7o2Mgbmjhuq1uIHJhIHThuqFpIGTDsm5nICVkIgogCi0jOiBhcHBseS5jOjIxNzYKKyM6IGFwcGx5LmM6MjE3NwogIywgYy1mb3JtYXQKIG1zZ2lkICJwYXRjaCB3aXRoIG9ubHkgZ2FyYmFnZSBhdCBsaW5lICVkIgogbXNnc3RyICJ2w6EgY2jhu4kgduG7m2kg4oCccsOhY+KAnSB04bqhaSBkw7JuZyAlZCIKIAotIzogYXBwbHkuYzoyMjYyCisjOiBhcHBseS5jOjIyNjMKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHJlYWQgc3ltbGluayAlcyIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIMSR4buNYyBsacOqbiBr4bq/dCBt4buBbSAlcyIKIAotIzogYXBwbHkuYzoyMjY2CisjOiBhcHBseS5jOjIyNjcKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIG9wZW4gb3IgcmVhZCAlcyIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIG3hu58gaGF5IMSR4buNYyAlcyIKIAotIzogYXBwbHkuYzoyOTI1CisjOiBhcHBseS5jOjI5MjYKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBzdGFydCBvZiBsaW5lOiAnJWMnIgogbXNnc3RyICJzYWkga2jhu59pIMSR4bqndSBkw7JuZzog4oCcJWPigJ0iCiAKLSM6IGFwcGx5LmM6MzA0NgorIzogYXBwbHkuYzozMDQ3CiAjLCBjLWZvcm1hdAogbXNnaWQgIkh1bmsgIyVkIHN1Y2NlZWRlZCBhdCAlZCAob2Zmc2V0ICVkIGxpbmUpLiIKIG1zZ2lkX3BsdXJhbCAiSHVuayAjJWQgc3VjY2VlZGVkIGF0ICVkIChvZmZzZXQgJWQgbGluZXMpLiIKIG1zZ3N0clswXSAiS2jhu5FpIGThu68gbGnhu4d1ICMlZCB0aMOgbmggY8O0bmcgdOG6oWkgJWQgKG9mZnNldCAlZCBkw7JuZykuIgogCi0jOiBhcHBseS5jOjMwNTgKKyM6IGFwcGx5LmM6MzA1OQogIywgYy1mb3JtYXQKIG1zZ2lkICJDb250ZXh0IHJlZHVjZWQgdG8gKCVsZC8lbGQpIHRvIGFwcGx5IGZyYWdtZW50IGF0ICVkIgogbXNnc3RyICJO4buZaSBkdW5nIGLhu4sgZ2nhuqNtIHh14buRbmcgY8OybiAoJWxkLyVsZCkgxJHhu4Mgw6FwIGThu6VuZyBt4bqjbmggZOG7ryBsaeG7h3UgdOG6oWkgJWQiCiAKLSM6IGFwcGx5LmM6MzA2NAorIzogYXBwbHkuYzozMDY1CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJ3aGlsZSBzZWFyY2hpbmcgZm9yOlxuIgpAQCAtMzE3LDQ1MyArMzE3LDQ1MyBAQAogInRyb25nIGtoaSDEkWFuZyB0w6xtIGtp4bq/bSBjaG86XG4iCiAiJS4qcyIKIAotIzogYXBwbHkuYzozMDg2CisjOiBhcHBseS5jOjMwODcKICMsIGMtZm9ybWF0CiBtc2dpZCAibWlzc2luZyBiaW5hcnkgcGF0Y2ggZGF0YSBmb3IgJyVzJyIKIG1zZ3N0ciAidGhp4bq/dSBk4buvIGxp4buHdSBj4bunYSBtaeG6v25nIHbDoSDEkeG7i25oIGThuqFuZyBuaOG7iyBwaMOibiBjaG8g4oCcJXPigJ0iCiAKLSM6IGFwcGx5LmM6MzA5NAorIzogYXBwbHkuYzozMDk1CiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCByZXZlcnNlLWFwcGx5IGEgYmluYXJ5IHBhdGNoIHdpdGhvdXQgdGhlIHJldmVyc2UgaHVuayB0byAnJXMnIgogbXNnc3RyICIiCiAia2jDtG5nIHRo4buDIHJldmVyc2UtYXBwbHkgbeG7mXQgbWnhur9uZyB2w6Egbmjhu4sgcGjDom4gbcOgIGtow7RuZyDEkeG6o28gbmfGsOG7o2Mga2jDumMgdGjDoG5oICIKICLigJwlc+KAnSIKIAotIzogYXBwbHkuYzozMTQxCisjOiBhcHBseS5jOjMxNDIKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IGFwcGx5IGJpbmFyeSBwYXRjaCB0byAnJXMnIHdpdGhvdXQgZnVsbCBpbmRleCBsaW5lIgogbXNnc3RyICIiCiAia2jDtG5nIHRo4buDIMOhcCBk4bulbmcgbWnhur9uZyB2w6Egbmjhu4sgcGjDom4gdGjDoG5oIOKAnCVz4oCdIG3DoCBraMO0bmcgY8OzIGTDsm5nIGNo4buJIG3hu6VjIMSR4bqneSAiCiAixJHhu6ciCiAKLSM6IGFwcGx5LmM6MzE1MQorIzogYXBwbHkuYzozMTUyCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJ0aGUgcGF0Y2ggYXBwbGllcyB0byAnJXMnICglcyksIHdoaWNoIGRvZXMgbm90IG1hdGNoIHRoZSBjdXJyZW50IGNvbnRlbnRzLiIKIG1zZ3N0ciAiIgogIm1p4bq/bmcgdsOhIMOhcCBk4bulbmcgY2hvIOKAnCVz4oCdICglcyksIGPDoWkgbcOgIGtow7RuZyBraOG7m3AgduG7m2kgY8OhYyBu4buZaSBkdW5nIGhp4buHbiB04bqhaS4iCiAKLSM6IGFwcGx5LmM6MzE1OQorIzogYXBwbHkuYzozMTYwCiAjLCBjLWZvcm1hdAogbXNnaWQgInRoZSBwYXRjaCBhcHBsaWVzIHRvIGFuIGVtcHR5ICclcycgYnV0IGl0IGlzIG5vdCBlbXB0eSIKIG1zZ3N0ciAibWnhur9uZyB2w6Egw6FwIGThu6VuZyBjaG8gbeG7mXQg4oCcJXPigJ0gdHLhu5FuZyBy4buXbmcgbmjGsG5nIG7DsyBs4bqhaSBraMO0bmcgdHLhu5FuZyIKIAotIzogYXBwbHkuYzozMTc3CisjOiBhcHBseS5jOjMxNzgKICMsIGMtZm9ybWF0CiBtc2dpZCAidGhlIG5lY2Vzc2FyeSBwb3N0aW1hZ2UgJXMgZm9yICclcycgY2Fubm90IGJlIHJlYWQiCiBtc2dzdHIgImtow7RuZyB0aOG7gyDEkeG7jWMgcG9zdGltYWdlICVzIGPhuqduIHRoaeG6v3QgY2hvIOKAnCVz4oCdIgogCi0jOiBhcHBseS5jOjMxOTAKKyM6IGFwcGx5LmM6MzE5MQogIywgYy1mb3JtYXQKIG1zZ2lkICJiaW5hcnkgcGF0Y2ggZG9lcyBub3QgYXBwbHkgdG8gJyVzJyIKIG1zZ3N0ciAibWnhur9uZyB2w6EgxJHhu4tuaCBk4bqhbmcgbmjhu4sgcGjDom4ga2jDtG5nIMSRxrDhu6NjIMOhcCBk4bulbmcgY2hvIOKAnCVz4oCdIgogCi0jOiBhcHBseS5jOjMxOTYKKyM6IGFwcGx5LmM6MzE5NwogIywgYy1mb3JtYXQKIG1zZ2lkICJiaW5hcnkgcGF0Y2ggdG8gJyVzJyBjcmVhdGVzIGluY29ycmVjdCByZXN1bHQgKGV4cGVjdGluZyAlcywgZ290ICVzKSIKIG1zZ3N0ciAiIgogInbDoSBuaOG7iyBwaMOibiBjaG8g4oCcJXPigJ0gdOG6oW8gcmEga+G6v3QgcXXhuqMga2jDtG5nIGNow61uaCB4w6FjIChtb25nIGNo4budICVzLCBs4bqhaSBuaOG6rW4gIgogIiVzKSIKIAotIzogYXBwbHkuYzozMjE3CisjOiBhcHBseS5jOjMyMTgKICMsIGMtZm9ybWF0CiBtc2dpZCAicGF0Y2ggZmFpbGVkOiAlczolbGQiCiBtc2dzdHIgImfhurdwIGzhu5dpIGtoaSB2w6E6ICVzOiVsZCIKIAotIzogYXBwbHkuYzozMzQwCisjOiBhcHBseS5jOjMzNDEKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IGNoZWNrb3V0ICVzIgogbXNnc3RyICJraMO0bmcgdGjhu4MgbOG6pXkgcmEgJXMiCiAKLSM6IGFwcGx5LmM6MzM5MiBhcHBseS5jOjM0MDMgYXBwbHkuYzozNDQ5IG1pZHguYzo2MiBzZXR1cC5jOjI3OQorIzogYXBwbHkuYzozMzkzIGFwcGx5LmM6MzQwNCBhcHBseS5jOjM0NTAgbWlkeC5jOjYxIHNldHVwLmM6MjgwCiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byByZWFkICVzIgogbXNnc3RyICJn4bq3cCBs4buXaSBraGkgxJHhu41jICVzIgogCi0jOiBhcHBseS5jOjM0MDAKKyM6IGFwcGx5LmM6MzQwMQogIywgYy1mb3JtYXQKIG1zZ2lkICJyZWFkaW5nIGZyb20gJyVzJyBiZXlvbmQgYSBzeW1ib2xpYyBsaW5rIgogbXNnc3RyICLEkeG7jWMgdOG7qyDigJwlc+KAnSB2xrDhu6N0IHJhIG5nb8OgaSBsacOqbiBr4bq/dCBt4buBbSIKIAotIzogYXBwbHkuYzozNDI5IGFwcGx5LmM6MzY3MgorIzogYXBwbHkuYzozNDMwIGFwcGx5LmM6MzY3MwogIywgYy1mb3JtYXQKIG1zZ2lkICJwYXRoICVzIGhhcyBiZWVuIHJlbmFtZWQvZGVsZXRlZCIKIG1zZ3N0ciAixJHGsOG7nW5nIGThuqtuICVzIMSRw6MgYuG7iyB4w7NhIGhv4bq3YyDEkeG7lWkgdMOqbiIKIAotIzogYXBwbHkuYzozNTE1IGFwcGx5LmM6MzY4NworIzogYXBwbHkuYzozNTE2IGFwcGx5LmM6MzY4OAogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogZG9lcyBub3QgZXhpc3QgaW4gaW5kZXgiCiBtc2dzdHIgIiVzOiBraMO0bmcgdOG7k24gdOG6oWkgdHJvbmcgYuG6o25nIG3hu6VjIGzhu6VjIgogCi0jOiBhcHBseS5jOjM1MjQgYXBwbHkuYzozNjk1CisjOiBhcHBseS5jOjM1MjUgYXBwbHkuYzozNjk2CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiBkb2VzIG5vdCBtYXRjaCBpbmRleCIKIG1zZ3N0ciAiJXM6IGtow7RuZyBraOG7m3AgdHJvbmcgbeG7pWMgbOG7pWMiCiAKLSM6IGFwcGx5LmM6MzU1OQorIzogYXBwbHkuYzozNTYwCiBtc2dpZCAicmVwb3NpdG9yeSBsYWNrcyB0aGUgbmVjZXNzYXJ5IGJsb2IgdG8gZmFsbCBiYWNrIG9uIDMtd2F5IG1lcmdlLiIKIG1zZ3N0ciAia2hvIHRoaeG6v3UgxJHhu5FpIHTGsOG7o25nIGJsb2IgY+G6p24gdGhp4bq/dCDEkeG7gyB0cuG7nyB24buBIHRyw6puIOKAnDMtd2F5IG1lcmdl4oCdLiIKIAotIzogYXBwbHkuYzozNTYyCisjOiBhcHBseS5jOjM1NjMKICMsIGMtZm9ybWF0CiBtc2dpZCAiRmFsbGluZyBiYWNrIHRvIHRocmVlLXdheSBtZXJnZS4uLlxuIgogbXNnc3RyICLEkGFuZyB0cuG7nyBs4bqhaSBow7JhIHRy4buZbiDigJwzLcSRxrDhu51uZ+KAneKAplxuIgogCi0jOiBhcHBseS5jOjM1NzggYXBwbHkuYzozNTgyCisjOiBhcHBseS5jOjM1NzkgYXBwbHkuYzozNTgzCiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCByZWFkIHRoZSBjdXJyZW50IGNvbnRlbnRzIG9mICclcyciCiBtc2dzdHIgImtow7RuZyB0aOG7gyDEkeG7jWMgbuG7mWkgZHVuZyBoaeG7h24gaMOgbmggY+G7p2Eg4oCcJXPigJ0iCiAKLSM6IGFwcGx5LmM6MzU5NAorIzogYXBwbHkuYzozNTk1CiAjLCBjLWZvcm1hdAogbXNnaWQgIkZhaWxlZCB0byBmYWxsIGJhY2sgb24gdGhyZWUtd2F5IG1lcmdlLi4uXG4iCiBtc2dzdHIgIkfhurdwIGzhu5dpIGtoaSBxdWF5IHRy4bufIGzhuqFpIMSR4buDIGjDsmEgdHLhu5luIGtp4buDdSDigJx0aHJlZS13YXnigJ3igKZcbiIKIAotIzogYXBwbHkuYzozNjA4CisjOiBhcHBseS5jOjM2MDkKICMsIGMtZm9ybWF0CiBtc2dpZCAiQXBwbGllZCBwYXRjaCB0byAnJXMnIHdpdGggY29uZmxpY3RzLlxuIgogbXNnc3RyICLEkMOjIMOhcCBk4bulbmcgbWnhur9uZyB2w6EgJXMgduG7m2kgY8OhYyB4dW5nIMSR4buZdC5cbiIKIAotIzogYXBwbHkuYzozNjEzCisjOiBhcHBseS5jOjM2MTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiQXBwbGllZCBwYXRjaCB0byAnJXMnIGNsZWFubHkuXG4iCiBtc2dzdHIgIsSQw6Mgw6FwIGThu6VuZyBtaeG6v25nIHbDoSAlcyBt4buZdCBjw6FjaCBz4bqhY2ggc+G6vS5cbiIKIAotIzogYXBwbHkuYzozNjM5CisjOiBhcHBseS5jOjM2NDAKIG1zZ2lkICJyZW1vdmFsIHBhdGNoIGxlYXZlcyBmaWxlIGNvbnRlbnRzIgogbXNnc3RyICJsb+G6oWkgYuG7jyBtaeG6v25nIHbDoSDEkeG7gyBs4bqhaSBu4buZaSBkdW5nIHThuq1wIHRpbiIKIAotIzogYXBwbHkuYzozNzEyCisjOiBhcHBseS5jOjM3MTMKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXM6IHdyb25nIHR5cGUiCiBtc2dzdHIgIiVzOiBzYWkga2nhu4N1IgogCi0jOiBhcHBseS5jOjM3MTQKKyM6IGFwcGx5LmM6MzcxNQogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyBoYXMgdHlwZSAlbywgZXhwZWN0ZWQgJW8iCiBtc2dzdHIgIiVzIGPDsyBraeG7g3UgJW8sIGPhuqduICVvIgogCi0jOiBhcHBseS5jOjM4NjUgYXBwbHkuYzozODY3IHJlYWQtY2FjaGUuYzo4MzAgcmVhZC1jYWNoZS5jOjg1NgorIzogYXBwbHkuYzozODY2IGFwcGx5LmM6Mzg2OCByZWFkLWNhY2hlLmM6ODMwIHJlYWQtY2FjaGUuYzo4NTYKICM6IHJlYWQtY2FjaGUuYzoxMzA5CiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgcGF0aCAnJXMnIgogbXNnc3RyICLEkcaw4budbmcgZOG6q24ga2jDtG5nIGjhu6NwIGzhu4cg4oCcJXPigJ0iCiAKLSM6IGFwcGx5LmM6MzkyMworIzogYXBwbHkuYzozOTI0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiBhbHJlYWR5IGV4aXN0cyBpbiBpbmRleCIKIG1zZ3N0ciAiJXM6IMSRw6MgY8OzIHThu6sgdHLGsOG7m2MgdHJvbmcgYuG6o25nIG3hu6VjIGzhu6VjIgogCi0jOiBhcHBseS5jOjM5MjYKKyM6IGFwcGx5LmM6MzkyNwogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogYWxyZWFkeSBleGlzdHMgaW4gd29ya2luZyBkaXJlY3RvcnkiCiBtc2dzdHIgIiVzOiDEkcOjIHPhurVuIGPDsyB0cm9uZyB0aMawIG3hu6VjIMSRYW5nIGzDoG0gdmnhu4djIgogCi0jOiBhcHBseS5jOjM5NDYKKyM6IGFwcGx5LmM6Mzk0NwogIywgYy1mb3JtYXQKIG1zZ2lkICJuZXcgbW9kZSAoJW8pIG9mICVzIGRvZXMgbm90IG1hdGNoIG9sZCBtb2RlICglbykiCiBtc2dzdHIgImNo4bq/IMSR4buZIG3hu5tpICglbykgY+G7p2EgJXMga2jDtG5nIGto4bubcCB24bubaSBjaOG6vyDEkeG7mSBjxakgKCVvKSIKIAotIzogYXBwbHkuYzozOTUxCisjOiBhcHBseS5jOjM5NTIKICMsIGMtZm9ybWF0CiBtc2dpZCAibmV3IG1vZGUgKCVvKSBvZiAlcyBkb2VzIG5vdCBtYXRjaCBvbGQgbW9kZSAoJW8pIG9mICVzIgogbXNnc3RyICJjaOG6vyDEkeG7mSBt4bubaSAoJW8pIGPhu6dhICVzIGtow7RuZyBraOG7m3AgduG7m2kgY2jhur8gxJHhu5kgY8WpICglbykgY+G7p2EgJXMiCiAKLSM6IGFwcGx5LmM6Mzk3MQorIzogYXBwbHkuYzozOTcyCiAjLCBjLWZvcm1hdAogbXNnaWQgImFmZmVjdGVkIGZpbGUgJyVzJyBpcyBiZXlvbmQgYSBzeW1ib2xpYyBsaW5rIgogbXNnc3RyICJ04bqtcCB0aW4gY2jhu4t1IHTDoWMgxJHhu5luZyDigJwlc+KAnSB2xrDhu6N0IHJhIG5nb8OgaSBsacOqbiBr4bq/dCBt4buBbSIKIAotIzogYXBwbHkuYzozOTc1CisjOiBhcHBseS5jOjM5NzYKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXM6IHBhdGNoIGRvZXMgbm90IGFwcGx5IgogbXNnc3RyICIlczogbWnhur9uZyB2w6Ega2jDtG5nIMSRxrDhu6NjIMOhcCBk4bulbmciCiAKLSM6IGFwcGx5LmM6Mzk5MAorIzogYXBwbHkuYzozOTkxCiAjLCBjLWZvcm1hdAogbXNnaWQgIkNoZWNraW5nIHBhdGNoICVzLi4uIgogbXNnc3RyICLEkGFuZyBraeG7g20gdHJhIG1p4bq/bmcgdsOhICVz4oCmIgogCi0jOiBhcHBseS5jOjQwODIKKyM6IGFwcGx5LmM6NDA4MwogIywgYy1mb3JtYXQKIG1zZ2lkICJzaGExIGluZm9ybWF0aW9uIGlzIGxhY2tpbmcgb3IgdXNlbGVzcyBmb3Igc3VibW9kdWxlICVzIgogbXNnc3RyICJ0aMO0bmcgdGluIHNoYTEgdGhp4bq/dSBob+G6t2Mga2jDtG5nIGTDuW5nIMSRxrDhu6NjIGNobyBtw7QtxJF1biAlcyIKIAotIzogYXBwbHkuYzo0MDg5CisjOiBhcHBseS5jOjQwOTAKICMsIGMtZm9ybWF0CiBtc2dpZCAibW9kZSBjaGFuZ2UgZm9yICVzLCB3aGljaCBpcyBub3QgaW4gY3VycmVudCBIRUFEIgogbXNnc3RyICJ0aGF5IMSR4buVaSBjaOG6vyDEkeG7mSBjaG8gJXMsIGPDoWkgbcOgIGtow7RuZyBwaOG6o2kgbMOgIEhFQUQgaGnhu4duIHThuqFpIgogCi0jOiBhcHBseS5jOjQwOTIKKyM6IGFwcGx5LmM6NDA5MwogIywgYy1mb3JtYXQKIG1zZ2lkICJzaGExIGluZm9ybWF0aW9uIGlzIGxhY2tpbmcgb3IgdXNlbGVzcyAoJXMpLiIKIG1zZ3N0ciAidGjDtG5nIHRpbiBzaGExIGPDsm4gdGhp4bq/dSBoYXkga2jDtG5nIGTDuW5nIMSRxrDhu6NjKCVzKS4iCiAKLSM6IGFwcGx5LmM6NDA5NyBidWlsdGluL2NoZWNrb3V0LmM6Mjc4IGJ1aWx0aW4vcmVzZXQuYzoxNDMKKyM6IGFwcGx5LmM6NDA5OCBidWlsdGluL2NoZWNrb3V0LmM6Mjc5IGJ1aWx0aW4vcmVzZXQuYzoxNDMKICMsIGMtZm9ybWF0CiBtc2dpZCAibWFrZV9jYWNoZV9lbnRyeSBmYWlsZWQgZm9yIHBhdGggJyVzJyIKIG1zZ3N0ciAibWFrZV9jYWNoZV9lbnRyeSBn4bq3cCBs4buXaSDEkeG7kWkgduG7m2kgxJHGsOG7nW5nIGThuqtuIOKAnCVz4oCdIgogCi0jOiBhcHBseS5jOjQxMDEKKyM6IGFwcGx5LmM6NDEwMgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgYWRkICVzIHRvIHRlbXBvcmFyeSBpbmRleCIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIHRow6ptICVzIHbDoG8gY2jhu4kgbeG7pWMgdOG6oW0gdGjhu51pIgogCi0jOiBhcHBseS5jOjQxMTEKKyM6IGFwcGx5LmM6NDExMgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3Qgd3JpdGUgdGVtcG9yYXJ5IGluZGV4IHRvICVzIgogbXNnc3RyICJraMO0bmcgdGjhu4MgZ2hpIG3hu6VjIGzhu6VjIHThuqFtIHbDoG8gJXMiCiAKLSM6IGFwcGx5LmM6NDI0OQorIzogYXBwbHkuYzo0MjUwCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byByZW1vdmUgJXMgZnJvbSBpbmRleCIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIGfhu6EgYuG7jyAlcyB04burIG3hu6VjIGzhu6VjIgogCi0jOiBhcHBseS5jOjQyODMKKyM6IGFwcGx5LmM6NDI4NAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3JydXB0IHBhdGNoIGZvciBzdWJtb2R1bGUgJXMiCiBtc2dzdHIgIm1p4bq/bmcgdsOhIHNhaSBo4buPbmcgY2hvIG3DtC3EkXVuLWNvbiAlcyIKIAotIzogYXBwbHkuYzo0Mjg5CisjOiBhcHBseS5jOjQyOTAKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHN0YXQgbmV3bHkgY3JlYXRlZCBmaWxlICclcyciCiBtc2dzdHIgImtow7RuZyB0aOG7gyBs4bqleSB0aOG7kW5nIGvDqiB24buBIHThuq1wIHRpbiAlcyBt4bubaSBoxqFuIMSRw6MgxJHGsOG7o2MgdOG6oW8iCiAKLSM6IGFwcGx5LmM6NDI5NworIzogYXBwbHkuYzo0Mjk4CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBjcmVhdGUgYmFja2luZyBzdG9yZSBmb3IgbmV3bHkgY3JlYXRlZCBmaWxlICVzIgogbXNnc3RyICJraMO0bmcgdGjhu4MgdOG6oW8g4oCca2hvIGzGsHUgxJHhurFuZyBzYXXigJ0gY2hvIHThuq1wIHRpbiDEkcaw4bujYyB04bqhbyBt4bubaSBoxqFuICVzIgogCi0jOiBhcHBseS5jOjQzMDMgYXBwbHkuYzo0NDQ4CisjOiBhcHBseS5jOjQzMDQgYXBwbHkuYzo0NDQ5CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBhZGQgY2FjaGUgZW50cnkgZm9yICVzIgogbXNnc3RyICJraMO0bmcgdGjhu4MgdGjDqm0gbeG7pWMgbmjhu5sgxJHhu4dtIGNobyAlcyIKIAotIzogYXBwbHkuYzo0MzQ2CisjOiBhcHBseS5jOjQzNDcKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIHdyaXRlIHRvICclcyciCiBtc2dzdHIgImfhurdwIGzhu5dpIGtoaSBnaGkgdsOgbyDigJwlc+KAnSIKIAotIzogYXBwbHkuYzo0MzUwCisjOiBhcHBseS5jOjQzNTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2xvc2luZyBmaWxlICclcyciCiBtc2dzdHIgIsSRYW5nIMSRw7NuZyB04bqtcCB0aW4g4oCcJXPigJ0iCiAKLSM6IGFwcGx5LmM6NDQyMAorIzogYXBwbHkuYzo0NDIxCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byB3cml0ZSBmaWxlICclcycgbW9kZSAlbyIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIGdoaSB2w6BvIHThuq1wIHRpbiDigJwlc+KAnSBjaOG6vyDEkeG7mSAlbyIKIAotIzogYXBwbHkuYzo0NTE4CisjOiBhcHBseS5jOjQ1MTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiQXBwbGllZCBwYXRjaCAlcyBjbGVhbmx5LiIKIG1zZ3N0ciAixJDDoyDDoXAgZOG7pW5nIG1p4bq/bmcgdsOhICVzIG3hu5l0IGPDoWNoIHPhuqFjaCBz4bq9LiIKIAotIzogYXBwbHkuYzo0NTI2CisjOiBhcHBseS5jOjQ1MjcKIG1zZ2lkICJpbnRlcm5hbCBlcnJvciIKIG1zZ3N0ciAibOG7l2kgbuG7mWkgYuG7mSIKIAotIzogYXBwbHkuYzo0NTI5CisjOiBhcHBseS5jOjQ1MzAKICMsIGMtZm9ybWF0CiBtc2dpZCAiQXBwbHlpbmcgcGF0Y2ggJSVzIHdpdGggJWQgcmVqZWN0Li4uIgogbXNnaWRfcGx1cmFsICJBcHBseWluZyBwYXRjaCAlJXMgd2l0aCAlZCByZWplY3RzLi4uIgogbXNnc3RyWzBdICLEkGFuZyDDoXAgZOG7pW5nIG1p4bq/bmcgdsOhICUlcyB24bubaSAlZCBs4bqnbiB04burIGNo4buRaeKApiIKIAotIzogYXBwbHkuYzo0NTQwCisjOiBhcHBseS5jOjQ1NDEKICMsIGMtZm9ybWF0CiBtc2dpZCAidHJ1bmNhdGluZyAucmVqIGZpbGVuYW1lIHRvICUuKnMucmVqIgogbXNnc3RyICLEkWFuZyBj4bqvdCBuZ+G6r24gdMOqbiB04bqtcCB0aW4gLnJlaiB0aMOgbmggJS4qcy5yZWoiCiAKLSM6IGFwcGx5LmM6NDU0OCBidWlsdGluL2ZldGNoLmM6ODc4IGJ1aWx0aW4vZmV0Y2guYzoxMTY4CisjOiBhcHBseS5jOjQ1NDkgYnVpbHRpbi9mZXRjaC5jOjg5OCBidWlsdGluL2ZldGNoLmM6MTE5NAogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3Qgb3BlbiAlcyIKIG1zZ3N0ciAia2jDtG5nIG3hu58gxJHGsOG7o2Mg4oCcJXPigJ0iCiAKLSM6IGFwcGx5LmM6NDU2MgorIzogYXBwbHkuYzo0NTYzCiAjLCBjLWZvcm1hdAogbXNnaWQgIkh1bmsgIyVkIGFwcGxpZWQgY2xlYW5seS4iCiBtc2dzdHIgIkto4buRaSBuaOG7myAjJWQgxJHGsOG7o2Mgw6FwIGThu6VuZyBn4buNbiBnw6BuZy4iCiAKLSM6IGFwcGx5LmM6NDU2NgorIzogYXBwbHkuYzo0NTY3CiAjLCBjLWZvcm1hdAogbXNnaWQgIlJlamVjdGVkIGh1bmsgIyVkLiIKIG1zZ3N0ciAixJBv4bqhbiBk4buvIGxp4buHdSAjJWQgYuG7iyB04burIGNo4buRaS4iCiAKLSM6IGFwcGx5LmM6NDY3NgorIzogYXBwbHkuYzo0Njg2CiAjLCBjLWZvcm1hdAogbXNnaWQgIlNraXBwZWQgcGF0Y2ggJyVzJy4iCiBtc2dzdHIgIkLhu48gcXVhIMSRxrDhu51uZyBk4bqrbiDigJwlc+KAnS4iCiAKLSM6IGFwcGx5LmM6NDY4NAorIzogYXBwbHkuYzo0Njk0CiBtc2dpZCAidW5yZWNvZ25pemVkIGlucHV0IgogbXNnc3RyICJraMO0bmcgdGjhu6thIG5o4bqtbiDEkeG6p3UgdsOgbyIKIAotIzogYXBwbHkuYzo0NzA0CisjOiBhcHBseS5jOjQ3MTQKIG1zZ2lkICJ1bmFibGUgdG8gcmVhZCBpbmRleCBmaWxlIgogbXNnc3RyICJraMO0bmcgdGjhu4MgxJHhu41jIHThuq1wIHRpbiBsxrB1IGLhuqNuZyBt4bulYyBs4bulYyIKIAotIzogYXBwbHkuYzo0ODU5CisjOiBhcHBseS5jOjQ4NzEKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2FuJ3Qgb3BlbiBwYXRjaCAnJXMnOiAlcyIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIG3hu58gbWnhur9uZyB2w6Eg4oCcJXPigJ06ICVzIgogCi0jOiBhcHBseS5jOjQ4ODYKKyM6IGFwcGx5LmM6NDg5OAogIywgYy1mb3JtYXQKIG1zZ2lkICJzcXVlbGNoZWQgJWQgd2hpdGVzcGFjZSBlcnJvciIKIG1zZ2lkX3BsdXJhbCAic3F1ZWxjaGVkICVkIHdoaXRlc3BhY2UgZXJyb3JzIgogbXNnc3RyWzBdICLEkcOjIGNo4bqlbSBk4bupdCAlZCBs4buXaSBraG/huqNuZyB0cuG6r25nIgogCi0jOiBhcHBseS5jOjQ4OTIgYXBwbHkuYzo0OTA3CisjOiBhcHBseS5jOjQ5MDQgYXBwbHkuYzo0OTE5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVkIGxpbmUgYWRkcyB3aGl0ZXNwYWNlIGVycm9ycy4iCiBtc2dpZF9wbHVyYWwgIiVkIGxpbmVzIGFkZCB3aGl0ZXNwYWNlIGVycm9ycy4iCiBtc2dzdHJbMF0gIiVkIGTDsm5nIHRow6ptIGtob+G6o25nIHRy4bqvbmcgbOG7l2kuIgogCi0jOiBhcHBseS5jOjQ5MDAKKyM6IGFwcGx5LmM6NDkxMgogIywgYy1mb3JtYXQKIG1zZ2lkICIlZCBsaW5lIGFwcGxpZWQgYWZ0ZXIgZml4aW5nIHdoaXRlc3BhY2UgZXJyb3JzLiIKIG1zZ2lkX3BsdXJhbCAiJWQgbGluZXMgYXBwbGllZCBhZnRlciBmaXhpbmcgd2hpdGVzcGFjZSBlcnJvcnMuIgogbXNnc3RyWzBdICIlZCBkw7JuZyDEkcaw4bujYyDDoXAgZOG7pW5nIHNhdSBraGkgc+G7rWEgY8OhYyBs4buXaSBraG/huqNuZyB0cuG6r25nLiIKIAotIzogYXBwbHkuYzo0OTE2IGJ1aWx0aW4vYWRkLmM6NTQwIGJ1aWx0aW4vbXYuYzozMDEgYnVpbHRpbi9ybS5jOjM5MAorIzogYXBwbHkuYzo0OTI4IGJ1aWx0aW4vYWRkLmM6NTQwIGJ1aWx0aW4vbXYuYzozMDEgYnVpbHRpbi9ybS5jOjM5MAogbXNnaWQgIlVuYWJsZSB0byB3cml0ZSBuZXcgaW5kZXggZmlsZSIKIG1zZ3N0ciAiS2jDtG5nIHRo4buDIGdoaSB04bqtcCB0aW4gbMawdSBi4bqjbmcgbeG7pWMgbOG7pWMgbeG7m2kiCiAKLSM6IGFwcGx5LmM6NDk0MyBhcHBseS5jOjQ5NDYgYnVpbHRpbi9hbS5jOjIyMDggYnVpbHRpbi9hbS5jOjIyMTEKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMjMgYnVpbHRpbi9mZXRjaC5jOjEyOCBidWlsdGluL21lcmdlLmM6MjczCi0jOiBidWlsdGluL3B1bGwuYzoyMDggYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjQwNworIzogYXBwbHkuYzo0OTU1IGFwcGx5LmM6NDk1OCBidWlsdGluL2FtLmM6MjE5NyBidWlsdGluL2FtLmM6MjIwMAorIzogYnVpbHRpbi9jbG9uZS5jOjEyMiBidWlsdGluL2ZldGNoLmM6MTQzIGJ1aWx0aW4vbWVyZ2UuYzoyNzMKKyM6IGJ1aWx0aW4vcHVsbC5jOjIwOSBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6NDA3CiAjOiBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6MTM2NyBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6MTM3MAogIzogYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjE4NTAgYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjE4NTMKICM6IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoyMDkyIGdpdC1hZGQtLWludGVyYWN0aXZlLnBlcmw6MjExCiBtc2dpZCAicGF0aCIKIG1zZ3N0ciAixJHGsOG7nW5nLWThuqtuIgogCi0jOiBhcHBseS5jOjQ5NDQKKyM6IGFwcGx5LmM6NDk1NgogbXNnaWQgImRvbid0IGFwcGx5IGNoYW5nZXMgbWF0Y2hpbmcgdGhlIGdpdmVuIHBhdGgiCiBtc2dzdHIgImtow7RuZyDDoXAgZOG7pW5nIGPDoWMgdGhheSDEkeG7lWkga2jhu5twIHbhu5tpIMSRxrDhu51uZyBk4bqrbiDEkcOjIGNobyIKIAotIzogYXBwbHkuYzo0OTQ3CisjOiBhcHBseS5jOjQ5NTkKIG1zZ2lkICJhcHBseSBjaGFuZ2VzIG1hdGNoaW5nIHRoZSBnaXZlbiBwYXRoIgogbXNnc3RyICLDoXAgZOG7pW5nIGPDoWMgdGhheSDEkeG7lWkga2jhu5twIHbhu5tpIMSRxrDhu51uZyBk4bqrbiDEkcOjIGNobyIKIAotIzogYXBwbHkuYzo0OTQ5IGJ1aWx0aW4vYW0uYzoyMjE3CisjOiBhcHBseS5jOjQ5NjEgYnVpbHRpbi9hbS5jOjIyMDYKIG1zZ2lkICJudW0iCiBtc2dzdHIgInPhu5EiCiAKLSM6IGFwcGx5LmM6NDk1MAorIzogYXBwbHkuYzo0OTYyCiBtc2dpZCAicmVtb3ZlIDxudW0+IGxlYWRpbmcgc2xhc2hlcyBmcm9tIHRyYWRpdGlvbmFsIGRpZmYgcGF0aHMiCiBtc2dzdHIgImfhu6EgYuG7jyA8c+G7kT4gZOG6pXUgZ+G6oWNoIGNow6lvIGThuqtuIMSR4bqndSB04burIMSRxrDhu51uZyBk4bqrbiBkaWZmIGPhu5UgxJFp4buDbiIKIAotIzogYXBwbHkuYzo0OTUzCisjOiBhcHBseS5jOjQ5NjUKIG1zZ2lkICJpZ25vcmUgYWRkaXRpb25zIG1hZGUgYnkgdGhlIHBhdGNoIgogbXNnc3RyICJs4budIMSRaSBwaOG6p24gYuG7lSB4dW5nIMSRxrDhu6NjIHThuqFvIHJhIGLhu59pIG1p4bq/bmcgdsOhIgogCi0jOiBhcHBseS5jOjQ5NTUKKyM6IGFwcGx5LmM6NDk2NwogbXNnaWQgImluc3RlYWQgb2YgYXBwbHlpbmcgdGhlIHBhdGNoLCBvdXRwdXQgZGlmZnN0YXQgZm9yIHRoZSBpbnB1dCIKIG1zZ3N0ciAiIgogInRoYXkgdsOsIMOhcCBk4bulbmcgbeG7mXQgbWnhur9uZyB2w6EsIGvhur90IHh14bqldCBr4bq/dCBxdeG6oyB04burIGzhu4duaCBkaWZmc3RhdCBjaG8gxJHhuqd1IHJhIgogCi0jOiBhcHBseS5jOjQ5NTkKKyM6IGFwcGx5LmM6NDk3MQogbXNnaWQgInNob3cgbnVtYmVyIG9mIGFkZGVkIGFuZCBkZWxldGVkIGxpbmVzIGluIGRlY2ltYWwgbm90YXRpb24iCiBtc2dzdHIgIiIKICJoaeG7g24gdGjhu4sgc+G7kSBsxrDhu6NuZyBjw6FjIGTDsm5nIMSRxrDhu6NjIHRow6ptIHbDoG8gdsOgIHjDs2EgxJFpIHRoZW8ga8O9IGhp4buHdSB0aOG6rXAgcGjDom4iCiAKLSM6IGFwcGx5LmM6NDk2MQorIzogYXBwbHkuYzo0OTczCiBtc2dpZCAiaW5zdGVhZCBvZiBhcHBseWluZyB0aGUgcGF0Y2gsIG91dHB1dCBhIHN1bW1hcnkgZm9yIHRoZSBpbnB1dCIKIG1zZ3N0ciAidGhheSB2w6wgw6FwIGThu6VuZyBt4buZdCBtaeG6v25nIHbDoSwga+G6v3QgeHXhuqV0IGvhur90IHF14bqjIGNobyDEkeG6p3UgdsOgbyIKIAotIzogYXBwbHkuYzo0OTYzCisjOiBhcHBseS5jOjQ5NzUKIG1zZ2lkICJpbnN0ZWFkIG9mIGFwcGx5aW5nIHRoZSBwYXRjaCwgc2VlIGlmIHRoZSBwYXRjaCBpcyBhcHBsaWNhYmxlIgogbXNnc3RyICJ0aGF5IHbDrCDDoXAgZOG7pW5nIG1p4bq/bmcgdsOhLCBow6N5IHhlbSB4ZW0gbWnhur9uZyB2w6EgY8OzIHRow61jaCBo4bujcCBraMO0bmciCiAKLSM6IGFwcGx5LmM6NDk2NQorIzogYXBwbHkuYzo0OTc3CiBtc2dpZCAibWFrZSBzdXJlIHRoZSBwYXRjaCBpcyBhcHBsaWNhYmxlIHRvIHRoZSBjdXJyZW50IGluZGV4IgogbXNnc3RyICJow6N5IGNo4bqvYyBjaOG6r24gbMOgIG1p4bq/bmcgdsOhIHRow61jaCBo4bujcCB24bubaSBi4bqjbmcgbeG7pWMgbOG7pWMgaGnhu4duIGjDoG5oIgogCi0jOiBhcHBseS5jOjQ5NjcKKyM6IGFwcGx5LmM6NDk3OQogbXNnaWQgIm1hcmsgbmV3IGZpbGVzIHdpdGggYGdpdCBhZGQgLS1pbnRlbnQtdG8tYWRkYCIKIG1zZ3N0ciAixJHDoW5oIGThuqV1IGPDoWMgdOG6rXAgdGluIG3hu5tpIHbhu5tpIOKAnGdpdCBhZGQgLS1pbnRlbnQtdG8tYWRk4oCdIgogCi0jOiBhcHBseS5jOjQ5NjkKKyM6IGFwcGx5LmM6NDk4MQogbXNnaWQgImFwcGx5IGEgcGF0Y2ggd2l0aG91dCB0b3VjaGluZyB0aGUgd29ya2luZyB0cmVlIgogbXNnc3RyICLDoXAgZOG7pW5nIG3hu5l0IG1p4bq/bmcgdsOhIG3DoCBraMO0bmcgxJHhu5luZyBjaOG6oW0gxJHhur9uIGPDonkgbMOgbSB2aeG7h2MiCiAKLSM6IGFwcGx5LmM6NDk3MQorIzogYXBwbHkuYzo0OTgzCiBtc2dpZCAiYWNjZXB0IGEgcGF0Y2ggdGhhdCB0b3VjaGVzIG91dHNpZGUgdGhlIHdvcmtpbmcgYXJlYSIKIG1zZ3N0ciAiY2jhuqVwIG5o4bqtbiBt4buZdCBtaeG6v25nIHbDoSBtw6Aga2jDtG5nIMSR4buZbmcgY2jhuqFtIMSR4bq/biBjw6J5IGzDoG0gdmnhu4djIgogCi0jOiBhcHBseS5jOjQ5NzQKKyM6IGFwcGx5LmM6NDk4NgogbXNnaWQgImFsc28gYXBwbHkgdGhlIHBhdGNoICh1c2Ugd2l0aCAtLXN0YXQvLS1zdW1tYXJ5Ly0tY2hlY2spIgogbXNnc3RyICIiCiAixJHhu5NuZyB0aOG7nWkgw6FwIGThu6VuZyBtaeG6v25nIHbDoSAoZMO5bmcgduG7m2kgdMO5eSBjaOG7jW4gLS1zdGF0Ly0tc3VtbWFyeS8tLWNoZWNrKSIKIAotIzogYXBwbHkuYzo0OTc2CisjOiBhcHBseS5jOjQ5ODgKIG1zZ2lkICJhdHRlbXB0IHRocmVlLXdheSBtZXJnZSBpZiBhIHBhdGNoIGRvZXMgbm90IGFwcGx5IgogbXNnc3RyICJ0aOG7rSBow7JhIHRy4buZbiBraeG7g3UgdGhyZWUtd2F5IG7hur91IHZp4buHYyB2w6Ega2jDtG5nIHRo4buDIHRo4buxYyBoaeG7h24gxJHGsOG7o2MiCiAKLSM6IGFwcGx5LmM6NDk3OAorIzogYXBwbHkuYzo0OTkwCiBtc2dpZCAiYnVpbGQgYSB0ZW1wb3JhcnkgaW5kZXggYmFzZWQgb24gZW1iZWRkZWQgaW5kZXggaW5mb3JtYXRpb24iCiBtc2dzdHIgIiIKICJ4w6J5IGThu7FuZyBi4bqjbmcgbeG7pWMgbOG7pWMgdOG6oW0gdGjhu51pIHRyw6puIGPGoSBz4bufIHRow7RuZyB0aW4gYuG6o25nIG3hu6VjIGzhu6VjIMSRxrDhu6NjIG5ow7puZyIKIAotIzogYXBwbHkuYzo0OTgxIGJ1aWx0aW4vY2hlY2tvdXQtaW5kZXguYzoxNzMgYnVpbHRpbi9scy1maWxlcy5jOjUyNAorIzogYXBwbHkuYzo0OTkzIGJ1aWx0aW4vY2hlY2tvdXQtaW5kZXguYzoxNzMgYnVpbHRpbi9scy1maWxlcy5jOjUyNAogbXNnaWQgInBhdGhzIGFyZSBzZXBhcmF0ZWQgd2l0aCBOVUwgY2hhcmFjdGVyIgogbXNnc3RyICJjw6FjIMSRxrDhu51uZyBk4bqrbiBi4buLIG5nxINuIGPDoWNoIGLhu59pIGvDvSB04buxIE5VTEwiCiAKLSM6IGFwcGx5LmM6NDk4MworIzogYXBwbHkuYzo0OTk1CiBtc2dpZCAiZW5zdXJlIGF0IGxlYXN0IDxuPiBsaW5lcyBvZiBjb250ZXh0IG1hdGNoIgogbXNnc3RyICLEkeG6o20gYuG6o28gcuG6sW5nIGPDsyDDrXQgbmjhuqV0IDxuPiBkw7JuZyBu4buZaSBkdW5nIGto4bubcCIKIAotIzogYXBwbHkuYzo0OTg0IGJ1aWx0aW4vYW0uYzoyMTk2IGJ1aWx0aW4vaW50ZXJwcmV0LXRyYWlsZXJzLmM6OTgKKyM6IGFwcGx5LmM6NDk5NiBidWlsdGluL2FtLmM6MjE4NSBidWlsdGluL2ludGVycHJldC10cmFpbGVycy5jOjk4CiAjOiBidWlsdGluL2ludGVycHJldC10cmFpbGVycy5jOjEwMCBidWlsdGluL2ludGVycHJldC10cmFpbGVycy5jOjEwMgotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzMwIGJ1aWx0aW4vcmViYXNlLmM6MTQyMQorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzEwIGJ1aWx0aW4vcmViYXNlLmM6MTQ0NQogbXNnaWQgImFjdGlvbiIKIG1zZ3N0ciAiaMOgbmggxJHhu5luZyIKIAotIzogYXBwbHkuYzo0OTg1CisjOiBhcHBseS5jOjQ5OTcKIG1zZ2lkICJkZXRlY3QgbmV3IG9yIG1vZGlmaWVkIGxpbmVzIHRoYXQgaGF2ZSB3aGl0ZXNwYWNlIGVycm9ycyIKIG1zZ3N0ciAidMOsbSB0aOG6pXkgbeG7mXQgZMOybmcgbeG7m2kgaG/hurdjIGLhu4sgc+G7rWEgxJHhu5VpIG3DoCBuw7MgY8OzIGzhu5dpIGRvIGtob+G6o25nIHRy4bqvbmciCiAKLSM6IGFwcGx5LmM6NDk4OCBhcHBseS5jOjQ5OTEKKyM6IGFwcGx5LmM6NTAwMCBhcHBseS5jOjUwMDMKIG1zZ2lkICJpZ25vcmUgY2hhbmdlcyBpbiB3aGl0ZXNwYWNlIHdoZW4gZmluZGluZyBjb250ZXh0IgogbXNnc3RyICJs4budIMSRaSBz4buxIHRoYXkgxJHhu5VpIGRvIGtob+G6o25nIHRy4bqvbmcgZ8OieSByYSBraGkgcXXDqXQgbuG7mWkgZHVuZyIKIAotIzogYXBwbHkuYzo0OTk0CisjOiBhcHBseS5jOjUwMDYKIG1zZ2lkICJhcHBseSB0aGUgcGF0Y2ggaW4gcmV2ZXJzZSIKIG1zZ3N0ciAiw6FwIGThu6VuZyBtaeG6v25nIHbDoSB0aGVvIGNoaeG7gXUgbmfGsOG7o2MiCiAKLSM6IGFwcGx5LmM6NDk5NgorIzogYXBwbHkuYzo1MDA4CiBtc2dpZCAiZG9uJ3QgZXhwZWN0IGF0IGxlYXN0IG9uZSBsaW5lIG9mIGNvbnRleHQiCiBtc2dzdHIgIsSR4burbmcgaHkgduG7jW5nIGPDsyDDrXQgbmjhuqV0IG3hu5l0IGTDsm5nIG7hu5lpIGR1bmciCiAKLSM6IGFwcGx5LmM6NDk5OAorIzogYXBwbHkuYzo1MDEwCiBtc2dpZCAibGVhdmUgdGhlIHJlamVjdGVkIGh1bmtzIGluIGNvcnJlc3BvbmRpbmcgKi5yZWogZmlsZXMiCiBtc2dzdHIgIsSR4buDIGzhuqFpIGto4buRaSBk4buvIGxp4buHdSBi4buLIHThu6sgY2jhu5FpIHRyb25nIGPDoWMgdOG6rXAgdGluICoucmVqIHTGsMahbmcg4bupbmciCiAKLSM6IGFwcGx5LmM6NTAwMAorIzogYXBwbHkuYzo1MDEyCiBtc2dpZCAiYWxsb3cgb3ZlcmxhcHBpbmcgaHVua3MiCiBtc2dzdHIgImNobyBwaMOpcCBjaOG7k25nIGto4buRaSBuaOG7myIKIAotIzogYXBwbHkuYzo1MDAxIGJ1aWx0aW4vYWRkLmM6MjkxIGJ1aWx0aW4vY2hlY2staWdub3JlLmM6MjIKKyM6IGFwcGx5LmM6NTAxMyBidWlsdGluL2FkZC5jOjI5MSBidWlsdGluL2NoZWNrLWlnbm9yZS5jOjIyCiAjOiBidWlsdGluL2NvbW1pdC5jOjEzMzcgYnVpbHRpbi9jb3VudC1vYmplY3RzLmM6OTggYnVpbHRpbi9mc2NrLmM6Nzg2Ci0jOiBidWlsdGluL2xvZy5jOjIwNjggYnVpbHRpbi9tdi5jOjEyMyBidWlsdGluL3JlYWQtdHJlZS5jOjEyOAorIzogYnVpbHRpbi9sb2cuYzoyMDg1IGJ1aWx0aW4vbXYuYzoxMjMgYnVpbHRpbi9yZWFkLXRyZWUuYzoxMjgKIG1zZ2lkICJiZSB2ZXJib3NlIgogbXNnc3RyICJjaGkgdGnhur90IgogCi0jOiBhcHBseS5jOjUwMDMKKyM6IGFwcGx5LmM6NTAxNQogbXNnaWQgInRvbGVyYXRlIGluY29ycmVjdGx5IGRldGVjdGVkIG1pc3NpbmcgbmV3LWxpbmUgYXQgdGhlIGVuZCBvZiBmaWxlIgogbXNnc3RyICIiCiAixJHDoyBkw7IgdMOsbSB0aOG6pXkgZHVuZyBzYWkga2jDtG5nIGNow61uaCB4w6FjIHRoaeG6v3UgZMOybmcgbeG7m2kgdOG6oWkgY3Xhu5FpIHThuq1wIHRpbiIKIAotIzogYXBwbHkuYzo1MDA2CisjOiBhcHBseS5jOjUwMTgKIG1zZ2lkICJkbyBub3QgdHJ1c3QgdGhlIGxpbmUgY291bnRzIGluIHRoZSBodW5rIGhlYWRlcnMiCiBtc2dzdHIgImtow7RuZyB0aW4gc+G7kSBsxrDhu6NuZyBkw7JuZyB0cm9uZyBwaOG6p24gxJHhuqd1IGto4buRaSBk4buvIGxp4buHdSIKIAotIzogYXBwbHkuYzo1MDA4IGJ1aWx0aW4vYW0uYzoyMjA1CisjOiBhcHBseS5jOjUwMjAgYnVpbHRpbi9hbS5jOjIxOTQKIG1zZ2lkICJyb290IgogbXNnc3RyICJn4buRYyIKIAotIzogYXBwbHkuYzo1MDA5CisjOiBhcHBseS5jOjUwMjEKIG1zZ2lkICJwcmVwZW5kIDxyb290PiB0byBhbGwgZmlsZW5hbWVzIgogbXNnc3RyICJ0cmVvIHRow6ptIDxyb290PiB2w6BvIHThuqV0IGPhuqMgY8OhYyB0w6puIHThuq1wIHRpbiIKIApAQCAtODE4LDcgKzgxOCw3IEBACiBtc2dpZCAiYXJjaGl2ZSBmb3JtYXQiCiBtc2dzdHIgIsSR4buLbmggZOG6oW5nIGzGsHUgdHLhu68iCiAKLSM6IGFyY2hpdmUuYzo0NTggYnVpbHRpbi9sb2cuYzoxNTgwCisjOiBhcmNoaXZlLmM6NDU4IGJ1aWx0aW4vbG9nLmM6MTU4MQogbXNnaWQgInByZWZpeCIKIG1zZ3N0ciAidGnhu4FuX3Thu5EiCiAKQEAgLTgyNiwxMSArODI2LDEyIEBACiBtc2dpZCAicHJlcGVuZCBwcmVmaXggdG8gZWFjaCBwYXRobmFtZSBpbiB0aGUgYXJjaGl2ZSIKIG1zZ3N0ciAibuG7kWkgdGjDqm0gdGnhu4FuIHThu5EgdsOgbyB04burbmcgxJHGsOG7nW5nIGThuqtuIHThuq1wIHRpbiB0cm9uZyBraG8gbMawdSIKIAotIzogYXJjaGl2ZS5jOjQ2MCBidWlsdGluL2JsYW1lLmM6ODYyIGJ1aWx0aW4vYmxhbWUuYzo4NzQgYnVpbHRpbi9ibGFtZS5jOjg3NQotIzogYnVpbHRpbi9jb21taXQtdHJlZS5jOjExNyBidWlsdGluL2NvbmZpZy5jOjEyOSBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTEzNAotIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExMzYgYnVpbHRpbi9ncmVwLmM6ODk3IGJ1aWx0aW4vaGFzaC1vYmplY3QuYzoxMDUKLSM6IGJ1aWx0aW4vbHMtZmlsZXMuYzo1NjAgYnVpbHRpbi9scy1maWxlcy5jOjU2MyBidWlsdGluL25vdGVzLmM6NDEyCi0jOiBidWlsdGluL25vdGVzLmM6NTc4IGJ1aWx0aW4vcmVhZC10cmVlLmM6MTIzIHBhcnNlLW9wdGlvbnMuaDoxNzcKKyM6IGFyY2hpdmUuYzo0NjAgYnVpbHRpbi9ibGFtZS5jOjg2MSBidWlsdGluL2JsYW1lLmM6ODczIGJ1aWx0aW4vYmxhbWUuYzo4NzQKKyM6IGJ1aWx0aW4vY29tbWl0LXRyZWUuYzoxMTcgYnVpbHRpbi9jb25maWcuYzoxMjkgYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNjIKKyM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTY0IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTY4IGJ1aWx0aW4vZ3JlcC5jOjg5OQorIzogYnVpbHRpbi9oYXNoLW9iamVjdC5jOjEwNSBidWlsdGluL2xzLWZpbGVzLmM6NTYwIGJ1aWx0aW4vbHMtZmlsZXMuYzo1NjMKKyM6IGJ1aWx0aW4vbm90ZXMuYzo0MTIgYnVpbHRpbi9ub3Rlcy5jOjU3OCBidWlsdGluL3JlYWQtdHJlZS5jOjEyMworIzogcGFyc2Utb3B0aW9ucy5oOjE4NgogbXNnaWQgImZpbGUiCiBtc2dzdHIgInThuq1wX3RpbiIKIApAQCAtODYyLDcgKzg2Myw3IEBACiBtc2dpZCAibGlzdCBzdXBwb3J0ZWQgYXJjaGl2ZSBmb3JtYXRzIgogbXNnc3RyICJsaeG7h3Qga8OqIGPDoWMga2nhu4N1IG7DqW4gxJHGsOG7o2MgaOG7lyB0cuG7oyIKIAotIzogYXJjaGl2ZS5jOjQ3OSBidWlsdGluL2FyY2hpdmUuYzo5MSBidWlsdGluL2Nsb25lLmM6MTEzIGJ1aWx0aW4vY2xvbmUuYzoxMTYKKyM6IGFyY2hpdmUuYzo0NzkgYnVpbHRpbi9hcmNoaXZlLmM6OTEgYnVpbHRpbi9jbG9uZS5jOjExMiBidWlsdGluL2Nsb25lLmM6MTE1CiAjOiBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6MTM3OSBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6MTg1OQogbXNnaWQgInJlcG8iCiBtc2dzdHIgImtobyIKQEAgLTg3MSw3ICs4NzIsNyBAQAogbXNnaWQgInJldHJpZXZlIHRoZSBhcmNoaXZlIGZyb20gcmVtb3RlIHJlcG9zaXRvcnkgPHJlcG8+IgogbXNnc3RyICJuaOG6rW4ga2hvIG7DqW4gdOG7qyBraG8gY2jhu6lhIDxraG8+IHRyw6puIG3DoXkgY2jhu6ciCiAKLSM6IGFyY2hpdmUuYzo0ODEgYnVpbHRpbi9hcmNoaXZlLmM6OTMgYnVpbHRpbi9kaWZmdG9vbC5jOjcwNworIzogYXJjaGl2ZS5jOjQ4MSBidWlsdGluL2FyY2hpdmUuYzo5MyBidWlsdGluL2RpZmZ0b29sLmM6NzE1CiAjOiBidWlsdGluL25vdGVzLmM6NDk4CiBtc2dpZCAiY29tbWFuZCIKIG1zZ3N0ciAibOG7h25oIgpAQCAtOTA3LDI2ICs5MDgsMjYgQEAKIG1zZ2lkICJjYW5ub3Qgc3RyZWFtIGJsb2IgJXMiCiBtc2dzdHIgImtow7RuZyB0aOG7gyBzdHJlYW0gYmxvYiDigJwlc+KAnSIKIAotIzogYXJjaGl2ZS10YXIuYzoyNjAgYXJjaGl2ZS16aXAuYzozNjMKKyM6IGFyY2hpdmUtdGFyLmM6MjY2IGFyY2hpdmUtemlwLmM6MzYzCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuc3VwcG9ydGVkIGZpbGUgbW9kZTogMCVvIChTSEExOiAlcykiCiBtc2dzdHIgImNo4bq/IMSR4buZIHThuq1wIHRpbiBs4bulYyBraMO0bmcgxJHGsOG7o2MgaOG7lyB0cuG7ozogMCVvIChTSEExOiAlcykiCiAKLSM6IGFyY2hpdmUtdGFyLmM6Mjg3IGFyY2hpdmUtemlwLmM6MzUzCisjOiBhcmNoaXZlLXRhci5jOjI5MyBhcmNoaXZlLXppcC5jOjM1MwogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgcmVhZCAlcyIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIMSR4buNYyAlcyIKIAotIzogYXJjaGl2ZS10YXIuYzo0NTkKKyM6IGFyY2hpdmUtdGFyLmM6NDY1CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBzdGFydCAnJXMnIGZpbHRlciIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIGLhuq90IMSR4bqndSBi4buZIGzhu41jIOKAnCVz4oCdIgogCi0jOiBhcmNoaXZlLXRhci5jOjQ2MgorIzogYXJjaGl2ZS10YXIuYzo0NjgKIG1zZ2lkICJ1bmFibGUgdG8gcmVkaXJlY3QgZGVzY3JpcHRvciIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIGNodXnhu4NuIGjGsOG7m25nIG3DtCB04bqjIgogCi0jOiBhcmNoaXZlLXRhci5jOjQ2OQorIzogYXJjaGl2ZS10YXIuYzo0NzUKICMsIGMtZm9ybWF0CiBtc2dpZCAiJyVzJyBmaWx0ZXIgcmVwb3J0ZWQgZXJyb3IiCiBtc2dzdHIgImLhu5kgbOG7jWMg4oCcJXPigJ0gxJHDoyBiw6FvIGPDoW8gbOG7l2kiCkBAIC05NTEsMTcgKzk1MiwxNyBAQAogbXNnaWQgInRpbWVzdGFtcCB0b28gbGFyZ2UgZm9yIHRoaXMgc3lzdGVtOiAlPFBSSXVNQVg+IgogbXNnc3RyICJk4bqldSB24bq/dCB0aOG7nWkgZ2lhbiBsw6AgcXXDoSBs4bubbiBjaG8gaOG7hyB0aOG7kW5nIG7DoHk6ICU8UFJJdU1BWD4iCiAKLSM6IGF0dHIuYzoyMTEKKyM6IGF0dHIuYzoyMTMKICMsIGMtZm9ybWF0CiBtc2dpZCAiJS4qcyBpcyBub3QgYSB2YWxpZCBhdHRyaWJ1dGUgbmFtZSIKIG1zZ3N0ciAiJS4qcyBraMO0bmcgcGjhuqNpIHTDqm4gdGh14buZYyB0w61uaCBo4bujcCBs4buHIgogCi0jOiBhdHRyLmM6MzY4CisjOiBhdHRyLmM6MzcwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIG5vdCBhbGxvd2VkOiAlczolZCIKIG1zZ3N0ciAiJXMga2jDtG5nIMSRxrDhu6NjIHBow6lwOiAlczolZCIKIAotIzogYXR0ci5jOjQwOAorIzogYXR0ci5jOjQxMAogbXNnaWQgIiIKICJOZWdhdGl2ZSBwYXR0ZXJucyBhcmUgaWdub3JlZCBpbiBnaXQgYXR0cmlidXRlc1xuIgogIlVzZSAnXFwhJyBmb3IgbGl0ZXJhbCBsZWFkaW5nIGV4Y2xhbWF0aW9uLiIKQEAgLTEwODcsNDAgKzEwODgsNDAgQEAKIG1zZ2lkX3BsdXJhbCAiQmlzZWN0aW5nOiAlZCByZXZpc2lvbnMgbGVmdCB0byB0ZXN0IGFmdGVyIHRoaXMgJXNcbiIKIG1zZ3N0clswXSAiQmlzZWN0aW5nOiBjw7JuICVkIMSRaeG7g20geMOpdCBkdXnhu4d0IMSR4buDIGtp4buDbSBzYXUgJXMgbsOgeVxuIgogCi0jOiBibGFtZS5jOjI2OTcKKyM6IGJsYW1lLmM6MjcwMAogbXNnaWQgIi0tY29udGVudHMgYW5kIC0tcmV2ZXJzZSBkbyBub3QgYmxlbmQgd2VsbC4iCiBtc2dzdHIgInTDuXkgY2jhu41uLS1jb250ZW50cyB2w6AgLS1yZXZlcnNlIGtow7RuZyDEkcaw4bujYyB0cuG7mW4gdsOgbyBuaGF1LiIKIAotIzogYmxhbWUuYzoyNzExCisjOiBibGFtZS5jOjI3MTQKIG1zZ2lkICJjYW5ub3QgdXNlIC0tY29udGVudHMgd2l0aCBmaW5hbCBjb21taXQgb2JqZWN0IG5hbWUiCiBtc2dzdHIgImtow7RuZyB0aOG7gyBkw7luZyAtLWNvbnRlbnRzIHbhu5tpIHTDqm4gxJHhu5FpIHTGsOG7o25nIGNodXnhu4NuIGdpYW8gY3Xhu5FpIGPDuW5nIgogCi0jOiBibGFtZS5jOjI3MzIKKyM6IGJsYW1lLmM6MjczNQogbXNnaWQgIi0tcmV2ZXJzZSBhbmQgLS1maXJzdC1wYXJlbnQgdG9nZXRoZXIgcmVxdWlyZSBzcGVjaWZpZWQgbGF0ZXN0IGNvbW1pdCIKIG1zZ3N0ciAiIgogImPDuW5nIHPhu60gZOG7pW5nIC0tcmV2ZXJzZSB2w6AgLS1maXJzdC1wYXJlbnQgY+G6p24gY2jhu4kgxJHhu4tuaCBs4bqnbiBjaHV54buDbiBnaWFvIGN14buRaSIKIAotIzogYmxhbWUuYzoyNzQxIGJ1bmRsZS5jOjE2NyByZWYtZmlsdGVyLmM6MjE5NiByZW1vdGUuYzoxOTM4IHNlcXVlbmNlci5jOjIwMzMKLSM6IHNlcXVlbmNlci5jOjQzNDggYnVpbHRpbi9jb21taXQuYzoxMDIwIGJ1aWx0aW4vbG9nLmM6Mzg3IGJ1aWx0aW4vbG9nLmM6OTYzCi0jOiBidWlsdGluL2xvZy5jOjE0NTEgYnVpbHRpbi9sb2cuYzoxODI3IGJ1aWx0aW4vbG9nLmM6MjExNyBidWlsdGluL21lcmdlLmM6NDExCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMxNDggYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMTYzCisjOiBibGFtZS5jOjI3NDQgYnVuZGxlLmM6MTY3IHJlZi1maWx0ZXIuYzoyMjAzIHJlbW90ZS5jOjE5NDEgc2VxdWVuY2VyLmM6MTk3MQorIzogc2VxdWVuY2VyLmM6NDMwNSBidWlsdGluL2NvbW1pdC5jOjEwMjAgYnVpbHRpbi9sb2cuYzozODcgYnVpbHRpbi9sb2cuYzo5NjQKKyM6IGJ1aWx0aW4vbG9nLmM6MTQ1MiBidWlsdGluL2xvZy5jOjE4NDQgYnVpbHRpbi9sb2cuYzoyMTM0IGJ1aWx0aW4vbWVyZ2UuYzo0MTEKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzEyOCBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMxNDMKICM6IGJ1aWx0aW4vc2hvcnRsb2cuYzoxOTIKIG1zZ2lkICJyZXZpc2lvbiB3YWxrIHNldHVwIGZhaWxlZCIKIG1zZ3N0ciAiY8OgaSDEkeG6t3Qgdmnhu4djIGRpIGNodXnhu4NuIHF1YSBjw6FjIMSRaeG7g20geMOpdCBkdXnhu4d0IGfhurdwIGzhu5dpIgogCi0jOiBibGFtZS5jOjI3NTkKKyM6IGJsYW1lLmM6Mjc2MgogbXNnaWQgIiIKICItLXJldmVyc2UgLS1maXJzdC1wYXJlbnQgdG9nZXRoZXIgcmVxdWlyZSByYW5nZSBhbG9uZyBmaXJzdC1wYXJlbnQgY2hhaW4iCiBtc2dzdHIgIiIKICJjw7luZyBz4butIGThu6VuZyAtLXJldmVyc2UgLS1maXJzdC1wYXJlbnQgecOqdSBj4bqndSB2w7luZyBjw7luZyB24bubaSBjaHXhu5dpIGNoYS1t4bq5LcSR4bqndS0iCiAidGnDqm4iCiAKLSM6IGJsYW1lLmM6Mjc3MAorIzogYmxhbWUuYzoyNzczCiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vIHN1Y2ggcGF0aCAlcyBpbiAlcyIKIG1zZ3N0ciAia2jDtG5nIGPDsyDEkcaw4budbmcgZOG6q24gJXMgdHJvbmcg4oCcJXPigJ0iCiAKLSM6IGJsYW1lLmM6Mjc4MQorIzogYmxhbWUuYzoyNzg0CiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCByZWFkIGJsb2IgJXMgZm9yIHBhdGggJXMiCiBtc2dzdHIgImtow7RuZyB0aOG7gyDEkeG7jWMgYmxvYiAlcyBjaG8gxJHGsOG7nW5nIGThuqtuIOKAnCVz4oCdIgpAQCAtMTI3Niw3ICsxMjc3LDcgQEAKIG1zZ2lkICJ1bnJlY29nbml6ZWQgaGVhZGVyOiAlcyVzICglZCkiCiBtc2dzdHIgInBo4bqnbiDEkeG6p3Uga2jDtG5nIMSRxrDhu6NjIHRo4burYSBuaOG6rW46ICVzJXMgKCVkKSIKIAotIzogYnVuZGxlLmM6OTAgcmVyZXJlLmM6NDgwIHJlcmVyZS5jOjY5MCBzZXF1ZW5jZXIuYzoyMjgzIHNlcXVlbmNlci5jOjMwMjQKKyM6IGJ1bmRsZS5jOjkwIHJlcmVyZS5jOjQ4MCByZXJlcmUuYzo2OTAgc2VxdWVuY2VyLmM6MjIyMSBzZXF1ZW5jZXIuYzoyOTYyCiAjOiBidWlsdGluL2NvbW1pdC5jOjc5MQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3Qgb3BlbiAnJXMnIgpAQCAtMTMyNyw3ICsxMzI4LDcgQEAKIG1zZ2lkICJyZWYgJyVzJyBpcyBleGNsdWRlZCBieSB0aGUgcmV2LWxpc3Qgb3B0aW9ucyIKIG1zZ3N0ciAidGguY2hp4bq/dSDigJwlc+KAnSBi4buLIGxv4bqhaSB0cuG7qyBi4bufaSBjw6FjIHTDuXkgY2jhu41uIHJldi1saXN0IgogCi0jOiBidW5kbGUuYzo0NjAgYnVpbHRpbi9sb2cuYzoyMDIgYnVpbHRpbi9sb2cuYzoxNzMyIGJ1aWx0aW4vc2hvcnRsb2cuYzozMDYKKyM6IGJ1bmRsZS5jOjQ2MCBidWlsdGluL2xvZy5jOjIwMiBidWlsdGluL2xvZy5jOjE3MzMgYnVpbHRpbi9zaG9ydGxvZy5jOjMwNgogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bnJlY29nbml6ZWQgYXJndW1lbnQ6ICVzIgogbXNnc3RyICLEkeG7kWkgc+G7kSBraMO0bmcgxJHGsOG7o2MgdGjhu6thIG5o4bqtbjogJXMiCkBAIC0xMzUwLDggKzEzNTEsOCBAQAogbXNnaWQgImludmFsaWQgY29sb3IgdmFsdWU6ICUuKnMiCiBtc2dzdHIgImdpw6EgdHLhu4sgbcOgdSBraMO0bmcgaOG7o3AgbOG7hzogJS4qcyIKIAotIzogY29tbWl0LmM6NTAgc2VxdWVuY2VyLmM6MjcyNyBidWlsdGluL2FtLmM6MzU1IGJ1aWx0aW4vYW0uYzozOTkKLSM6IGJ1aWx0aW4vYW0uYzoxMzc4IGJ1aWx0aW4vYW0uYzoyMDIwIGJ1aWx0aW4vcmVwbGFjZS5jOjQ1NQorIzogY29tbWl0LmM6NTAgc2VxdWVuY2VyLmM6MjY2NSBidWlsdGluL2FtLmM6MzU0IGJ1aWx0aW4vYW0uYzozOTgKKyM6IGJ1aWx0aW4vYW0uYzoxMzY2IGJ1aWx0aW4vYW0uYzoyMDA5IGJ1aWx0aW4vcmVwbGFjZS5jOjQ1NgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcGFyc2UgJXMiCiBtc2dzdHIgImtow7RuZyB0aOG7gyBwaMOibiB0w61jaCBjw7ogcGjDoXAgJXMiCkBAIC0xMzgxLDI4ICsxMzgyLDI4IEBACiAiVOG6r3QgbOG7nWkgbmjhuq9uIG7DoHkgYuG6sW5nIGPDoWNoIGNo4bqheVxuIgogIlwiZ2l0IGNvbmZpZyBhZHZpY2UuZ3JhZnRGaWxlRGVwcmVjYXRlZCBmYWxzZVwiIgogCi0jOiBjb21taXQuYzoxMTI3CisjOiBjb21taXQuYzoxMTI4CiAjLCBjLWZvcm1hdAogbXNnaWQgIkNvbW1pdCAlcyBoYXMgYW4gdW50cnVzdGVkIEdQRyBzaWduYXR1cmUsIGFsbGVnZWRseSBieSAlcy4iCiBtc2dzdHIgIiIKICJM4bqnbiBjaHV54buDbiBnaWFvICVzIGPDsyBt4buZdCBjaOG7ryBrw70gR1BHIGtow7RuZyDEkcOhbmcgdGluLCDEkcaw4bujYyBjaG8gbMOgIGLhu59pICVzLiIKIAotIzogY29tbWl0LmM6MTEzMAorIzogY29tbWl0LmM6MTEzMQogIywgYy1mb3JtYXQKIG1zZ2lkICJDb21taXQgJXMgaGFzIGEgYmFkIEdQRyBzaWduYXR1cmUgYWxsZWdlZGx5IGJ5ICVzLiIKIG1zZ3N0ciAiTOG6p24gY2h1eeG7g24gZ2lhbyAlcyBjw7MgbeG7mXQgY2jhu68ga8O9IEdQRyBzYWksIMSRxrDhu6NjIGNobyBsw6AgYuG7n2kgJXMuIgogCi0jOiBjb21taXQuYzoxMTMzCisjOiBjb21taXQuYzoxMTM0CiAjLCBjLWZvcm1hdAogbXNnaWQgIkNvbW1pdCAlcyBkb2VzIG5vdCBoYXZlIGEgR1BHIHNpZ25hdHVyZS4iCiBtc2dzdHIgIkzhuqduIGNodXnhu4NuIGdpYW8gJXMga2jDtG5nIGPDsyBjaOG7ryBrw70gR1BHLiIKIAotIzogY29tbWl0LmM6MTEzNgorIzogY29tbWl0LmM6MTEzNwogIywgYy1mb3JtYXQKIG1zZ2lkICJDb21taXQgJXMgaGFzIGEgZ29vZCBHUEcgc2lnbmF0dXJlIGJ5ICVzXG4iCiBtc2dzdHIgIkzhuqduIGNodXnhu4NuIGdpYW8gJXMgY8OzIG3hu5l0IGNo4buvIGvDvSBHUEcgdOG7kXQgYuG7n2kgJXNcbiIKIAotIzogY29tbWl0LmM6MTM5MAorIzogY29tbWl0LmM6MTM5MQogbXNnaWQgIiIKICJXYXJuaW5nOiBjb21taXQgbWVzc2FnZSBkaWQgbm90IGNvbmZvcm0gdG8gVVRGLTguXG4iCiAiWW91IG1heSB3YW50IHRvIGFtZW5kIGl0IGFmdGVyIGZpeGluZyB0aGUgbWVzc2FnZSwgb3Igc2V0IHRoZSBjb25maWdcbiIKQEAgLTE0NjYsMTkyICsxNDY3LDIwNyBAQAogbXNnaWQgInVuYWJsZSB0byBmaW5kIGFsbCBjb21taXQtZ3JhcGggZmlsZXMiCiBtc2dzdHIgImtow7RuZyB0aOG7gyB0w6xtIHRo4bqleSB04bqldCBj4bqjIGPDoWMgdOG6rXAgdGluIMSR4buTLXRo4buLLWPDoWMtbOG6p24tY2h1eeG7g24tZ2lhbyIKIAotIzogY29tbWl0LWdyYXBoLmM6NTU0IGNvbW1pdC1ncmFwaC5jOjYxNAorIzogY29tbWl0LWdyYXBoLmM6NTYxIGNvbW1pdC1ncmFwaC5jOjYyMQogbXNnaWQgImludmFsaWQgY29tbWl0IHBvc2l0aW9uLiBjb21taXQtZ3JhcGggaXMgbGlrZWx5IGNvcnJ1cHQiCiBtc2dzdHIgIiIKICJ24buLIHRyw60gbOG6p24gY2h1eeG7g24gZ2lhbyBraMO0bmcgaOG7o3AgbOG7hy4gxJHhu5MtdGjhu4stY8OhYy1s4bqnbi1jaHV54buDbi1naWFvIGPDsyB24bq7IG5oxrAgxJHDoyAiCiAiYuG7iyBo4buPbmciCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjU3NQorIzogY29tbWl0LWdyYXBoLmM6NTgyCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBmaW5kIGNvbW1pdCAlcyIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIHTDrG0gdGjhuqV5IGzhuqduIGNodXnhu4NuIGdpYW8gJXMiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjEwMDIgYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNjU3CisjOiBjb21taXQtZ3JhcGguYzo4NTUgYnVpbHRpbi9hbS5jOjEyODcKKyMsIGMtZm9ybWF0Cittc2dpZCAidW5hYmxlIHRvIHBhcnNlIGNvbW1pdCAlcyIKK21zZ3N0ciAia2jDtG5nIHRo4buDIHBow6JuIHTDrWNoIGzhuqduIGNodXnhu4NuIGdpYW8g4oCcJXPigJ0iCisKKyM6IGNvbW1pdC1ncmFwaC5jOjg1OQorIywgYy1mb3JtYXQKK21zZ2lkICJ1bmFibGUgdG8gZ2V0IHRyZWUgZm9yICVzIgorbXNnc3RyICJraMO0bmcgdGjhu4MgbOG6pXkgY8OieSBjaG8gJXMiCisKKyM6IGNvbW1pdC1ncmFwaC5jOjEwMTcgYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNjQxCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBnZXQgdHlwZSBvZiBvYmplY3QgJXMiCiBtc2dzdHIgImtow7RuZyB0aOG7gyBs4bqleSBraeG7g3UgY+G7p2EgxJHhu5FpIHTGsOG7o25nIOKAnCVz4oCdIgogCi0jOiBjb21taXQtZ3JhcGguYzoxMDM0CisjOiBjb21taXQtZ3JhcGguYzoxMDQ5CiBtc2dpZCAiTG9hZGluZyBrbm93biBjb21taXRzIGluIGNvbW1pdCBncmFwaCIKIG1zZ3N0ciAixJBhbmcgdOG6o2kgY8OhYyBs4bqnbiBjaHV54buDbiBnaWFvIGNoxrBhIGJp4bq/dCB0cm9uZyDEkeG7kyB0aOG7iyBs4bqnbiBjaHV54buDbiBnaWFvIgogCi0jOiBjb21taXQtZ3JhcGguYzoxMDUxCisjOiBjb21taXQtZ3JhcGguYzoxMDY2CiBtc2dpZCAiRXhwYW5kaW5nIHJlYWNoYWJsZSBjb21taXRzIGluIGNvbW1pdCBncmFwaCIKIG1zZ3N0ciAiIgogIk3hu58gcuG7mW5nIGPDoWMgbOG6p24gY2h1eeG7g24gZ2lhbyBjw7MgdGjhu4MgdGnhur9wIGPhuq1uIMSRxrDhu6NjIHRyb25nIHRyb25nIMSR4buTIHRo4buLIGzhuqduICIKICJjaHV54buDbiBnaWFvIgogCi0jOiBjb21taXQtZ3JhcGguYzoxMDcwCisjOiBjb21taXQtZ3JhcGguYzoxMDg1CiBtc2dpZCAiQ2xlYXJpbmcgY29tbWl0IG1hcmtzIGluIGNvbW1pdCBncmFwaCIKIG1zZ3N0ciAixJBhbmcgZOG7jW4gZOG6uXAgY8OhYyDEkcOhbmggZOG6pXUgbOG6p24gY2h1eeG7g24gZ2lhbyB0cm9uZyDEkeG7kyB0aOG7iyBs4bqnbiBjaHV54buDbiBnaWFvIgogCi0jOiBjb21taXQtZ3JhcGguYzoxMDg5CisjOiBjb21taXQtZ3JhcGguYzoxMTA0CiBtc2dpZCAiQ29tcHV0aW5nIGNvbW1pdCBncmFwaCBnZW5lcmF0aW9uIG51bWJlcnMiCiBtc2dzdHIgIsSQYW5nIHTDrW5oIHRvw6FuIHPhu5EgdOG6oW8gxJHhu5MgdGjhu4sgY8OhYyBs4bqnbiBjaHV54buDbiBnaWFvIgogCi0jOiBjb21taXQtZ3JhcGguYzoxMTYzCisjOiBjb21taXQtZ3JhcGguYzoxMTc5CiAjLCBjLWZvcm1hdAogbXNnaWQgIkZpbmRpbmcgY29tbWl0cyBmb3IgY29tbWl0IGdyYXBoIGluICVkIHBhY2siCiBtc2dpZF9wbHVyYWwgIkZpbmRpbmcgY29tbWl0cyBmb3IgY29tbWl0IGdyYXBoIGluICVkIHBhY2tzIgogbXNnc3RyWzBdICIiCiAixJBhbmcgdMOsbSBjw6FjIGzhuqduIGNodXnhu4NuIGdpYW8gY2hvIMSR4buTIHRo4buLIGzhuqduIGNodXnhu4NuIGdpYW8gdHJvbmcgJWQgZ8OzaSIKIAotIzogY29tbWl0LWdyYXBoLmM6MTE3NgorIzogY29tbWl0LWdyYXBoLmM6MTE5MgogIywgYy1mb3JtYXQKIG1zZ2lkICJlcnJvciBhZGRpbmcgcGFjayAlcyIKIG1zZ3N0ciAiZ+G6t3AgbOG7l2kgdGjDqm0gZ8OzaSAlcyIKIAotIzogY29tbWl0LWdyYXBoLmM6MTE4MAorIzogY29tbWl0LWdyYXBoLmM6MTE5NgogIywgYy1mb3JtYXQKIG1zZ2lkICJlcnJvciBvcGVuaW5nIGluZGV4IGZvciAlcyIKIG1zZ3N0ciAiZ+G6t3AgbOG7l2kga2hpIG3hu58gbeG7pWMgbOG7pWMgY2hvIOKAnCVz4oCdIgogCi0jOiBjb21taXQtZ3JhcGguYzoxMjA0CisjOiBjb21taXQtZ3JhcGguYzoxMjIwCiAjLCBjLWZvcm1hdAogbXNnaWQgIkZpbmRpbmcgY29tbWl0cyBmb3IgY29tbWl0IGdyYXBoIGZyb20gJWQgcmVmIgogbXNnaWRfcGx1cmFsICJGaW5kaW5nIGNvbW1pdHMgZm9yIGNvbW1pdCBncmFwaCBmcm9tICVkIHJlZnMiCiBtc2dzdHJbMF0gIiIKICLEkGFuZyB0w6xtIGPDoWMgbOG6p24gY2h1eeG7g24gZ2lhbyBjaG8gxJHhu5MgdGjhu4sgbOG6p24gY2h1eeG7g24gZ2lhbyB04burICVkIHRoYW0gY2hp4bq/dSIKIAotIzogY29tbWl0LWdyYXBoLmM6MTIzOAorIzogY29tbWl0LWdyYXBoLmM6MTI0MAorIywgYy1mb3JtYXQKK21zZ2lkICJpbnZhbGlkIGNvbW1pdCBvYmplY3QgaWQ6ICVzIgorbXNnc3RyICJtw6Mgc+G7kSDEkeG7kWkgdMaw4bujbmcgbOG6p24gY2h1eeG7g24gZ2lhbyBraMO0bmcgaOG7o3AgbOG7hzogJXMiCisKKyM6IGNvbW1pdC1ncmFwaC5jOjEyNTUKIG1zZ2lkICJGaW5kaW5nIGNvbW1pdHMgZm9yIGNvbW1pdCBncmFwaCBhbW9uZyBwYWNrZWQgb2JqZWN0cyIKIG1zZ3N0ciAiIgogIsSQYW5nIHTDrG0gY8OhYyBs4bqnbiBjaHV54buDbiBnaWFvIGNobyDEkeG7kyB0aOG7iyBs4bqnbiBjaHV54buDbiBnaWFvIHRyb25nIHPhu5EgY8OhYyDEkeG7kWkgIgogInTGsOG7o25nIMSRw6MgxJHDs25nIGfDs2kiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjEyNTMKKyM6IGNvbW1pdC1ncmFwaC5jOjEyNzAKIG1zZ2lkICJDb3VudGluZyBkaXN0aW5jdCBjb21taXRzIGluIGNvbW1pdCBncmFwaCIKIG1zZ3N0ciAixJBhbmcgxJHhur9tIGPDoWMgbOG6p24gY2h1eeG7g24gZ2lhbyBraMOhYyBuaGF1IHRyb25nIMSR4buTIHRo4buLIGzhuqduIGNodXnhu4NuIGdpYW8iCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjEyODQKKyM6IGNvbW1pdC1ncmFwaC5jOjEzMDAKIG1zZ2lkICJGaW5kaW5nIGV4dHJhIGVkZ2VzIGluIGNvbW1pdCBncmFwaCIKIG1zZ3N0ciAixJBhbmcgdMOsbSBjw6FjIGPhuqFuaCBt4bufIHThu5luZyB0cm9uZyDEkeG7kyB0aOG7iyBs4bqnbiBjaHV54buDbiBnaWFvIgogCi0jOiBjb21taXQtZ3JhcGguYzoxMzMyCisjOiBjb21taXQtZ3JhcGguYzoxMzQ2CiBtc2dpZCAiZmFpbGVkIHRvIHdyaXRlIGNvcnJlY3QgbnVtYmVyIG9mIGJhc2UgZ3JhcGggaWRzIgogbXNnc3RyICJn4bq3cCBs4buXaSBraGkgZ2hpIHPhu5EgxJHDum5nIGPhu6dhIG3DoyDEkeG7kyBo4buNYSBjxqEgc+G7nyIKIAotIzogY29tbWl0LWdyYXBoLmM6MTM2NSBtaWR4LmM6ODExCisjOiBjb21taXQtZ3JhcGguYzoxMzc5IG1pZHguYzo4MTAKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGNyZWF0ZSBsZWFkaW5nIGRpcmVjdG9yaWVzIG9mICVzIgogbXNnc3RyICJraMO0bmcgdGjhu4MgdOG6oW8gY8OhYyB0aMawIG3hu6VjIGThuqtuIMSR4bqndSBj4bunYSDigJwlc+KAnSIKIAotIzogY29tbWl0LWdyYXBoLmM6MTM3NyBidWlsdGluL2luZGV4LXBhY2suYzozMDYgYnVpbHRpbi9yZXBhY2suYzoyNDAKKyM6IGNvbW1pdC1ncmFwaC5jOjEzOTEgYnVpbHRpbi9pbmRleC1wYWNrLmM6MzA2IGJ1aWx0aW4vcmVwYWNrLmM6MjQxCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBjcmVhdGUgJyVzJyIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIHThuqFvIOKAnCVz4oCdIgogCi0jOiBjb21taXQtZ3JhcGguYzoxNDM3CisjOiBjb21taXQtZ3JhcGguYzoxNDUxCiAjLCBjLWZvcm1hdAogbXNnaWQgIldyaXRpbmcgb3V0IGNvbW1pdCBncmFwaCBpbiAlZCBwYXNzIgogbXNnaWRfcGx1cmFsICJXcml0aW5nIG91dCBjb21taXQgZ3JhcGggaW4gJWQgcGFzc2VzIgogbXNnc3RyWzBdICLEkGFuZyBnaGkgcmEgxJHhu5MgdGjhu4sgY8OhYyBs4bqnbiBjaHV54buDbiBnaWFvIHRyb25nIGzhuqduICVkIgogCi0jOiBjb21taXQtZ3JhcGguYzoxNDc4CisjOiBjb21taXQtZ3JhcGguYzoxNDkyCiBtc2dpZCAidW5hYmxlIHRvIG9wZW4gY29tbWl0LWdyYXBoIGNoYWluIGZpbGUiCiBtc2dzdHIgImtow7RuZyB0aOG7gyBt4bufIHThuq1wIHRpbiBt4bqvdCB4w61jaCDEkeG7kyB0aOG7iyBjaHV54buDbiBnaWFvIgogCi0jOiBjb21taXQtZ3JhcGguYzoxNDkwCisjOiBjb21taXQtZ3JhcGguYzoxNTA0CiBtc2dpZCAiZmFpbGVkIHRvIHJlbmFtZSBiYXNlIGNvbW1pdC1ncmFwaCBmaWxlIgogbXNnc3RyICJn4bq3cCBs4buXaSBraGkgxJHhu5VpIHTDqm4gdOG6rXAgdGluIMSR4buTLXRo4buLLWPDoWMtbOG6p24tY2h1eeG7g24tZ2lhbyIKIAotIzogY29tbWl0LWdyYXBoLmM6MTUxMAorIzogY29tbWl0LWdyYXBoLmM6MTUyNAogbXNnaWQgImZhaWxlZCB0byByZW5hbWUgdGVtcG9yYXJ5IGNvbW1pdC1ncmFwaCBmaWxlIgogbXNnc3RyICJn4bq3cCBs4buXaSBraGkgxJHhu5VpIHTDqm4gdOG6rXAgdGluIMSR4buTLXRo4buLLWPDoWMtbOG6p24tY2h1eeG7g24tZ2lhbyB04bqhbSB0aOG7nWkiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjE2MjEKKyM6IGNvbW1pdC1ncmFwaC5jOjE2MzUKIG1zZ2lkICJTY2FubmluZyBtZXJnZWQgY29tbWl0cyIKIG1zZ3N0ciAixJBhbmcgcXXDqXQgY8OhYyBs4bqnbiBjaHV54buDbiBnaWFvIMSRw6MgaMOyYSB0cuG7mW4iCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjE2MzIKKyM6IGNvbW1pdC1ncmFwaC5jOjE2NDYKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5leHBlY3RlZCBkdXBsaWNhdGUgY29tbWl0IGlkICVzIgogbXNnc3RyICJn4bq3cCBtw6Mgc+G7kSB0w61jaCBs4bqnbiBjaHV54buDbiBnaWFvIGLhu4sgdHLDuW5nIGzhurdwIOKAnCVz4oCdIgogCi0jOiBjb21taXQtZ3JhcGguYzoxNjU3CisjOiBjb21taXQtZ3JhcGguYzoxNjcwCiBtc2dpZCAiTWVyZ2luZyBjb21taXQtZ3JhcGgiCiBtc2dzdHIgIsSQYW5nIGjDsmEgdHLhu5luIMSR4buTLXRo4buLLWPDoWMtbOG6p24tY2h1eeG7g24tZ2lhbyIKIAotIzogY29tbWl0LWdyYXBoLmM6MTg0NAorIzogY29tbWl0LWdyYXBoLmM6MTg2MAogIywgYy1mb3JtYXQKIG1zZ2lkICJ0aGUgY29tbWl0IGdyYXBoIGZvcm1hdCBjYW5ub3Qgd3JpdGUgJWQgY29tbWl0cyIKIG1zZ3N0ciAixJHhu4tuaCBk4bqhbmcgxJHhu5MgaOG7jWEgY8OhYyBs4bqnbiBjaHV54buDbiBnaWFvIGtow7RuZyB0aOG7gyBnaGkgJWQgbOG6p24gY2h1eeG7g24gZ2lhbyIKIAotIzogY29tbWl0LWdyYXBoLmM6MTg1NQorIzogY29tbWl0LWdyYXBoLmM6MTg3MQogbXNnaWQgInRvbyBtYW55IGNvbW1pdHMgdG8gd3JpdGUgZ3JhcGgiCiBtc2dzdHIgImPDsyBxdcOhIG5oaeG7gXUgbOG6p24gY2h1eeG7g24gZ2lhbyDEkeG7gyBnaGkgxJHhu5MgdGjhu4siCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjE5NDUKKyM6IGNvbW1pdC1ncmFwaC5jOjE5NjEKIG1zZ2lkICJ0aGUgY29tbWl0LWdyYXBoIGZpbGUgaGFzIGluY29ycmVjdCBjaGVja3N1bSBhbmQgaXMgbGlrZWx5IGNvcnJ1cHQiCiBtc2dzdHIgIiIKICJ04bqtcCB0aW4gxJHhu5MtdGjhu4stY8OhYy1s4bqnbi1jaHV54buDbi1naWFvIGPDsyB04buVbmcga2nhu4NtIGtow7RuZyDEkcO6bmcgdsOgIGPDsyB24bq7IG5oxrAgbMOgICIKICLEkcOjIGjhu49uZyIKIAotIzogY29tbWl0LWdyYXBoLmM6MTk1NQorIzogY29tbWl0LWdyYXBoLmM6MTk3MQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb21taXQtZ3JhcGggaGFzIGluY29ycmVjdCBPSUQgb3JkZXI6ICVzIHRoZW4gJXMiCiBtc2dzdHIgIsSR4buTLXRo4buLLWPDoWMtbOG6p24tY2h1eeG7g24tZ2lhbyBjw7MgdGjhu6kgdOG7sSBPSUQga2jDtG5nIMSRw7puZzogJXMgc2F1ICVzIgogCi0jOiBjb21taXQtZ3JhcGguYzoxOTY1IGNvbW1pdC1ncmFwaC5jOjE5ODAKKyM6IGNvbW1pdC1ncmFwaC5jOjE5ODEgY29tbWl0LWdyYXBoLmM6MTk5NgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb21taXQtZ3JhcGggaGFzIGluY29ycmVjdCBmYW5vdXQgdmFsdWU6IGZhbm91dFslZF0gPSAldSAhPSAldSIKIG1zZ3N0ciAiIgogIsSR4buTLXRo4buLLWPDoWMtbOG6p24tY2h1eeG7g24tZ2lhbyBjw7MgZ2nDoSB0cuG7iyBmYW5vdXQga2jDtG5nIMSRw7puZzogZmFub3V0WyVkXSA9ICV1ICE9ICIKICIldSIKIAotIzogY29tbWl0LWdyYXBoLmM6MTk3MgorIzogY29tbWl0LWdyYXBoLmM6MTk4OAogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gcGFyc2UgY29tbWl0ICVzIGZyb20gY29tbWl0LWdyYXBoIgogbXNnc3RyICJn4bq3cCBs4buXaSBraGkgcGjDom4gdMOtY2ggbOG6p24gY2h1eeG7g24gZ2lhbyB04burICVzIMSR4buTLXRo4buLLWPDoWMtbOG6p24tY2h1eeG7g24tZ2lhbyIKIAotIzogY29tbWl0LWdyYXBoLmM6MTk4OQorIzogY29tbWl0LWdyYXBoLmM6MjAwNgogbXNnaWQgIlZlcmlmeWluZyBjb21taXRzIGluIGNvbW1pdCBncmFwaCIKIG1zZ3N0ciAixJBhbmcgdGjhuqltIHRyYSBjw6FjIGzhuqduIGNodXnhu4NuIGdpYW8gdHJvbmcgxJHhu5MgdGjhu4sgbOG6p24gY2h1eeG7g24gZ2lhbyIKIAotIzogY29tbWl0LWdyYXBoLmM6MjAwMgorIzogY29tbWl0LWdyYXBoLmM6MjAyMAogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gcGFyc2UgY29tbWl0ICVzIGZyb20gb2JqZWN0IGRhdGFiYXNlIGZvciBjb21taXQtZ3JhcGgiCiBtc2dzdHIgIiIKICJn4bq3cCBs4buXaSBraGkgcGjDom4gdMOtY2ggbOG6p24gY2h1eeG7g24gZ2lhbyAlcyB04burIGPGoSBz4bufIGThu68gbGnhu4d1IMSR4buRaSB0xrDhu6NuZyBjaG8gxJHhu5MgIgogInRo4buLIGzhuqduIGNodXnhu4NuIGdpYW8iCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjIwMDkKKyM6IGNvbW1pdC1ncmFwaC5jOjIwMjcKICMsIGMtZm9ybWF0CiBtc2dpZCAicm9vdCB0cmVlIE9JRCBmb3IgY29tbWl0ICVzIGluIGNvbW1pdC1ncmFwaCBpcyAlcyAhPSAlcyIKIG1zZ3N0ciAiIgogIk9JRCBjw6J5IGfhu5FjIGNobyBs4bqnbiBjaHV54buDbiBnaWFvICVzIHRyb25nIMSR4buTLXRo4buLLWPDoWMtbOG6p24tY2h1eeG7g24tZ2lhbyBsw6AgJXMgIT0gIgogIiVzIgogCi0jOiBjb21taXQtZ3JhcGguYzoyMDE5CisjOiBjb21taXQtZ3JhcGguYzoyMDM3CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvbW1pdC1ncmFwaCBwYXJlbnQgbGlzdCBmb3IgY29tbWl0ICVzIGlzIHRvbyBsb25nIgogbXNnc3RyICIiCiAiZGFuaCBzw6FjaCBjaGEgbeG6uSDEkeG7ky10aOG7iy1jw6FjLWzhuqduLWNodXnhu4NuLWdpYW8gY2hvIGzhuqduIGNodXnhu4NuIGdpYW8gJXMgbMOgIHF1w6EgZMOgaSIKIAotIzogY29tbWl0LWdyYXBoLmM6MjAyOAorIzogY29tbWl0LWdyYXBoLmM6MjA0NgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb21taXQtZ3JhcGggcGFyZW50IGZvciAlcyBpcyAlcyAhPSAlcyIKIG1zZ3N0ciAiY2hhIG3hurkgxJHhu5MtdGjhu4stY8OhYy1s4bqnbi1jaHV54buDbi1naWFvIGNobyAlcyBsw6AgJXMgIT0gJXMiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjIwNDEKKyM6IGNvbW1pdC1ncmFwaC5jOjIwNTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiY29tbWl0LWdyYXBoIHBhcmVudCBsaXN0IGZvciBjb21taXQgJXMgdGVybWluYXRlcyBlYXJseSIKIG1zZ3N0ciAiIgogImRhbmggc8OhY2ggY2hhIG3hurkgxJHhu5MtdGjhu4stY8OhYy1s4bqnbi1jaHV54buDbi1naWFvIGNobyBs4bqnbiBjaHV54buDbiBnaWFvICVzIGLhu4sgY2jhuqVtICIKICJk4bupdCBxdcOhIHPhu5ttIgogCi0jOiBjb21taXQtZ3JhcGguYzoyMDQ2CisjOiBjb21taXQtZ3JhcGguYzoyMDY0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJjb21taXQtZ3JhcGggaGFzIGdlbmVyYXRpb24gbnVtYmVyIHplcm8gZm9yIGNvbW1pdCAlcywgYnV0IG5vbi16ZXJvIGVsc2V3aGVyZSIKQEAgLTE2NTksNyArMTY3NSw3IEBACiAixJHhu5MtdGjhu4stY8OhYy1s4bqnbi1jaHV54buDbi1naWFvIGPDsyBjb24gc+G7kSBraMO0bmcgbOG6p24gdOG6oW8gY2hvIGzhuqduIGNodXnhu4NuIGdpYW8gJXMsICIKICJuaMawbmcga2jDtG5nIHBo4bqjaSBz4buRIGtow7RuZyDhu58gY2jhu5cga2jDoWMiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjIwNTAKKyM6IGNvbW1pdC1ncmFwaC5jOjIwNjgKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogImNvbW1pdC1ncmFwaCBoYXMgbm9uLXplcm8gZ2VuZXJhdGlvbiBudW1iZXIgZm9yIGNvbW1pdCAlcywgYnV0IHplcm8gZWxzZXdoZXJlIgpAQCAtMTY2NywxMiArMTY4MywxMiBAQAogIsSR4buTLXRo4buLLWPDoWMtbOG6p24tY2h1eeG7g24tZ2lhbyBjw7MgY29uIHPhu5Ega2jDtG5nIHBo4bqjaSBraMO0bmcgbOG6p24gdOG6oW8gY2hvIGzhuqduIGNodXnhu4NuICIKICJnaWFvICVzLCBuaMawbmcgc+G7kSBraMO0bmcg4bufIGNo4buXIGtow6FjIgogCi0jOiBjb21taXQtZ3JhcGguYzoyMDY1CisjOiBjb21taXQtZ3JhcGguYzoyMDgzCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvbW1pdC1ncmFwaCBnZW5lcmF0aW9uIGZvciBjb21taXQgJXMgaXMgJXUgIT0gJXUiCiBtc2dzdHIgInThuqFvIMSR4buTLXRo4buLLWPDoWMtbOG6p24tY2h1eeG7g24tZ2lhbyBjaG8gbOG6p24gY2h1eeG7g24gZ2lhbyAlcyBsw6AgJXUgIT0gJXUiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjIwNzEKKyM6IGNvbW1pdC1ncmFwaC5jOjIwODkKICMsIGMtZm9ybWF0CiBtc2dpZCAiY29tbWl0IGRhdGUgZm9yIGNvbW1pdCAlcyBpbiBjb21taXQtZ3JhcGggaXMgJTxQUkl1TUFYPiAhPSAlPFBSSXVNQVg+IgogbXNnc3RyICIiCkBAIC0xNzIxLDcgKzE3MzcsNyBAQAogbXNnaWQgImtleSBkb2VzIG5vdCBjb250YWluIHZhcmlhYmxlIG5hbWU6ICVzIgogbXNnc3RyICJraMOzYSBraMO0bmcgY2jhu6lhIGLhuqV0IGvhu7MgbeG7mXQgdMOqbiBiaeG6v24gbsOgbzogJXMiCiAKLSM6IGNvbmZpZy5jOjQwNiBzZXF1ZW5jZXIuYzoyNDYzCisjOiBjb25maWcuYzo0MDYgc2VxdWVuY2VyLmM6MjQwMQogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIGtleTogJXMiCiBtc2dzdHIgImtow7NhIGtow7RuZyDEkcO6bmc6ICVzIgpAQCAtMTg0NSwxNTAgKzE4NjEsMTQ0IEBACiBtc2dpZCAiaW52YWxpZCBtb2RlIGZvciBvYmplY3QgY3JlYXRpb246ICVzIgogbXNnc3RyICJjaOG6vyDEkeG7mSBraMO0bmcgaOG7o3AgbOG7hyDEkeG7kWkgduG7m2kgdmnhu4djIHThuqFvIMSR4buRaSB0xrDhu6NuZzogJXMiCiAKLSM6IGNvbmZpZy5jOjE0MzAKKyM6IGNvbmZpZy5jOjE0MjUKICMsIGMtZm9ybWF0CiBtc2dpZCAibWFsZm9ybWVkIHZhbHVlIGZvciAlcyIKIG1zZ3N0ciAiZ2nDoSB0cuG7iyBjaG8gJXMgc2FpIGThuqFuZyIKIAotIzogY29uZmlnLmM6MTQ1NgorIzogY29uZmlnLmM6MTQ1MQogIywgYy1mb3JtYXQKIG1zZ2lkICJtYWxmb3JtZWQgdmFsdWUgZm9yICVzOiAlcyIKIG1zZ3N0ciAiZ2nDoSB0cuG7iyBjaG8gJXMgc2FpIGThuqFuZzogJXMiCiAKLSM6IGNvbmZpZy5jOjE0NTcKKyM6IGNvbmZpZy5jOjE0NTIKIG1zZ2lkICJtdXN0IGJlIG9uZSBvZiBub3RoaW5nLCBtYXRjaGluZywgc2ltcGxlLCB1cHN0cmVhbSBvciBjdXJyZW50IgogbXNnc3RyICJwaOG6o2kgbMOgIG3hu5l0IHRyb25nIHPhu5Egbm90aGluZywgbWF0Y2hpbmcsIHNpbXBsZSwgdXBzdHJlYW0gaGF5IGN1cnJlbnQiCiAKLSM6IGNvbmZpZy5jOjE1MTggYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozNDEwCisjOiBjb25maWcuYzoxNTEzIGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzM5NAogIywgYy1mb3JtYXQKIG1zZ2lkICJiYWQgcGFjayBjb21wcmVzc2lvbiBsZXZlbCAlZCIKIG1zZ3N0ciAibeG7qWMgbsOpbiBnw7NpICVkIGtow7RuZyBo4bujcCBs4buHIgogCi0jOiBjb25maWcuYzoxNjM5CisjOiBjb25maWcuYzoxNjM0CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBsb2FkIGNvbmZpZyBibG9iIG9iamVjdCAnJXMnIgogbXNnc3RyICJraMO0bmcgdGjhu4MgdOG6o2kgxJHhu5FpIHTGsOG7o25nIGJsb2IgY+G6pXUgaMOsbmgg4oCcJXPigJ0iCiAKLSM6IGNvbmZpZy5jOjE2NDIKKyM6IGNvbmZpZy5jOjE2MzcKICMsIGMtZm9ybWF0CiBtc2dpZCAicmVmZXJlbmNlICclcycgZG9lcyBub3QgcG9pbnQgdG8gYSBibG9iIgogbXNnc3RyICJ0aGFtIGNoaeG6v3Ug4oCcJXPigJ0ga2jDtG5nIGNo4buJIMSR4bq/biBt4buZdCBibG9iIG7DoG8gY+G6oyIKIAotIzogY29uZmlnLmM6MTY1OQorIzogY29uZmlnLmM6MTY1NAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gcmVzb2x2ZSBjb25maWcgYmxvYiAnJXMnIgogbXNnc3RyICJraMO0bmcgdGjhu4MgcGjDom4gZ2nhuqNpIMSRaeG7g20geMOpdCBkdXnhu4d0IOKAnCVz4oCdIgogCi0jOiBjb25maWcuYzoxNjg5CisjOiBjb25maWcuYzoxNjg0CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBwYXJzZSAlcyIKIG1zZ3N0ciAiZ+G6t3AgbOG7l2kga2hpIHBow6JuIHTDrWNoIGPDuiBwaMOhcCAlcyIKIAotIzogY29uZmlnLmM6MTc0NQorIzogY29uZmlnLmM6MTc0MAogbXNnaWQgInVuYWJsZSB0byBwYXJzZSBjb21tYW5kLWxpbmUgY29uZmlnIgogbXNnc3RyICJraMO0bmcgdGjhu4MgcGjDom4gdMOtY2ggY+G6pXUgaMOsbmggZMOybmcgbOG7h25oIgogCi0jOiBjb25maWcuYzoyMDk0CisjOiBjb25maWcuYzoyMDkxCiBtc2dpZCAidW5rbm93biBlcnJvciBvY2N1cnJlZCB3aGlsZSByZWFkaW5nIHRoZSBjb25maWd1cmF0aW9uIGZpbGVzIgogbXNnc3RyICLEkcOjIGPDsyBs4buXaSBjaMawYSBiaeG6v3QgeOG6o3kgcmEgdHJvbmcga2hpIMSR4buNYyBjw6FjIHThuq1wIHRpbiBj4bqldSBow6xuaCIKIAotIzogY29uZmlnLmM6MjI2NAorIzogY29uZmlnLmM6MjI2MQogIywgYy1mb3JtYXQKIG1zZ2lkICJJbnZhbGlkICVzOiAnJXMnIgogbXNnc3RyICIlcyBraMO0bmcgaOG7o3AgbOG7hzog4oCcJXPigJ0iCiAKLSM6IGNvbmZpZy5jOjIzMDcKLSMsIGMtZm9ybWF0Ci1tc2dpZCAidW5rbm93biBjb3JlLnVudHJhY2tlZENhY2hlIHZhbHVlICclcyc7IHVzaW5nICdrZWVwJyBkZWZhdWx0IHZhbHVlIgotbXNnc3RyICIiCi0ia2jDtG5nIGhp4buDdSBnacOhIHRy4buLIGNvcmUudW50cmFja2VkQ2FjaGUg4oCcJXPigJ07IGTDuW5nIGdpw6EgdHLhu4sgbeG6t2MgxJHhu4tuaCDigJxrZWVw4oCdIgotCi0jOiBjb25maWcuYzoyMzMzCisjOiBjb25maWcuYzoyMzA2CiAjLCBjLWZvcm1hdAogbXNnaWQgInNwbGl0SW5kZXgubWF4UGVyY2VudENoYW5nZSB2YWx1ZSAnJWQnIHNob3VsZCBiZSBiZXR3ZWVuIDAgYW5kIDEwMCIKIG1zZ3N0ciAiZ2nDoSB0cuG7iyBzcGxpdEluZGV4Lm1heFBlcmNlbnRDaGFuZ2Ug4oCcJWTigJ0gcGjhuqNpIG7hurFtIGdp4buvYSAwIHbDoCAxMDAiCiAKLSM6IGNvbmZpZy5jOjIzNzkKKyM6IGNvbmZpZy5jOjIzNTIKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHBhcnNlICclcycgZnJvbSBjb21tYW5kLWxpbmUgY29uZmlnIgogbXNnc3RyICJraMO0bmcgdGjhu4MgcGjDom4gdMOtY2gg4oCcJXPigJ0gdOG7qyBj4bqldSBow6xuaCBkw7JuZyBs4buHbmgiCiAKLSM6IGNvbmZpZy5jOjIzODEKKyM6IGNvbmZpZy5jOjIzNTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiYmFkIGNvbmZpZyB2YXJpYWJsZSAnJXMnIGluIGZpbGUgJyVzJyBhdCBsaW5lICVkIgogbXNnc3RyICJzYWkgYmnhur9uIGPhuqV1IGjDrG5oIOKAnCVz4oCdIHRyb25nIHThuq1wIHRpbiDigJwlc+KAnSB04bqhaSBkw7JuZyAlZCIKIAotIzogY29uZmlnLmM6MjQ2MgorIzogY29uZmlnLmM6MjQzNQogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIHNlY3Rpb24gbmFtZSAnJXMnIgogbXNnc3RyICJ0w6puIGPhu6dhIHBo4bqnbiBraMO0bmcgaOG7o3AgbOG7hyDigJwlc+KAnSIKIAotIzogY29uZmlnLmM6MjQ5NAorIzogY29uZmlnLmM6MjQ2NwogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyBoYXMgbXVsdGlwbGUgdmFsdWVzIgogbXNnc3RyICIlcyBjw7MgxJFhIGdpw6EgdHLhu4siCiAKLSM6IGNvbmZpZy5jOjI1MjMKKyM6IGNvbmZpZy5jOjI0OTYKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIHdyaXRlIG5ldyBjb25maWd1cmF0aW9uIGZpbGUgJXMiCiBtc2dzdHIgImfhurdwIGzhu5dpIGtoaSBnaGkgdOG6rXAgdGluIGPhuqV1IGjDrG5oIOKAnCVz4oCdIgogCi0jOiBjb25maWcuYzoyNzc1IGNvbmZpZy5jOjMwOTkKKyM6IGNvbmZpZy5jOjI3NDggY29uZmlnLmM6MzA3MgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgbG9jayBjb25maWcgZmlsZSAlcyIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIGtow7NhIHThuq1wIHRpbiBj4bqldSBow6xuaCAlcyIKIAotIzogY29uZmlnLmM6Mjc4NgorIzogY29uZmlnLmM6Mjc1OQogIywgYy1mb3JtYXQKIG1zZ2lkICJvcGVuaW5nICVzIgogbXNnc3RyICLEkWFuZyBt4bufIOKAnCVz4oCdIgogCi0jOiBjb25maWcuYzoyODIxIGJ1aWx0aW4vY29uZmlnLmM6MzI4CisjOiBjb25maWcuYzoyNzk0IGJ1aWx0aW4vY29uZmlnLmM6MzI4CiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgcGF0dGVybjogJXMiCiBtc2dzdHIgIm3huqt1IGtow7RuZyBo4bujcCBs4buHOiAlcyIKIAotIzogY29uZmlnLmM6Mjg0NgorIzogY29uZmlnLmM6MjgxOQogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIGNvbmZpZyBmaWxlICVzIgogbXNnc3RyICJ04bqtcCB0aW4gY+G6pXUgaMOsbmgg4oCcJXPigJ0ga2jDtG5nIGjhu6NwIGzhu4ciCiAKLSM6IGNvbmZpZy5jOjI4NTkgY29uZmlnLmM6MzExMgorIzogY29uZmlnLmM6MjgzMiBjb25maWcuYzozMDg1CiAjLCBjLWZvcm1hdAogbXNnaWQgImZzdGF0IG9uICVzIGZhaWxlZCIKIG1zZ3N0ciAiZnN0YXQgdHLDqm4gJXMgZ+G6t3AgbOG7l2kiCiAKLSM6IGNvbmZpZy5jOjI4NzAKKyM6IGNvbmZpZy5jOjI4NDMKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIG1tYXAgJyVzJyIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIG1tYXAg4oCcJXPigJ0iCiAKLSM6IGNvbmZpZy5jOjI4NzkgY29uZmlnLmM6MzExNworIzogY29uZmlnLmM6Mjg1MiBjb25maWcuYzozMDkwCiAjLCBjLWZvcm1hdAogbXNnaWQgImNobW9kIG9uICVzIGZhaWxlZCIKIG1zZ3N0ciAiY2htb2QgdHLDqm4gJXMgZ+G6t3AgbOG7l2kiCiAKLSM6IGNvbmZpZy5jOjI5NjQgY29uZmlnLmM6MzIxNAorIzogY29uZmlnLmM6MjkzNyBjb25maWcuYzozMTg3CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCB3cml0ZSBjb25maWcgZmlsZSAlcyIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIGdoaSB04bqtcCB0aW4gY+G6pXUgaMOsbmgg4oCcJXPigJ0iCiAKLSM6IGNvbmZpZy5jOjI5OTgKKyM6IGNvbmZpZy5jOjI5NzEKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHNldCAnJXMnIHRvICclcyciCiBtc2dzdHIgImtow7RuZyB0aOG7gyDEkeG6t3Qg4oCcJXPigJ0gdGjDoG5oIOKAnCVz4oCdIgogCi0jOiBjb25maWcuYzozMDAwIGJ1aWx0aW4vcmVtb3RlLmM6NzgyCisjOiBjb25maWcuYzoyOTczIGJ1aWx0aW4vcmVtb3RlLmM6NzgyCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCB1bnNldCAnJXMnIgogbXNnc3RyICJraMO0bmcgdGjhu4MgdGjDtGkgxJHhurd0IOKAnCVz4oCdIgogCi0jOiBjb25maWcuYzozMDkwCisjOiBjb25maWcuYzozMDYzCiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgc2VjdGlvbiBuYW1lOiAlcyIKIG1zZ3N0ciAidMOqbiBj4bunYSBwaOG6p24ga2jDtG5nIGjhu6NwIGzhu4c6ICVzIgogCi0jOiBjb25maWcuYzozMjU3CisjOiBjb25maWcuYzozMjMwCiAjLCBjLWZvcm1hdAogbXNnaWQgIm1pc3NpbmcgdmFsdWUgZm9yICclcyciCiBtc2dzdHIgInRoaeG6v3UgZ2nDoSB0cuG7iyBjaG8gY2hvIOKAnCVz4oCdIgpAQCAtMjExMiw3ICsyMTIyLDcgQEAKIG1zZ2lkICJ1bmtub3duIHBvcnQgJXMiCiBtc2dzdHIgImtow7RuZyBoaeG7g3UgY+G7lW5nICVzIgogCi0jOiBjb25uZWN0LmM6ODQ1IGNvbm5lY3QuYzoxMTcxCisjOiBjb25uZWN0LmM6ODQ1IGNvbm5lY3QuYzoxMTc1CiAjLCBjLWZvcm1hdAogbXNnaWQgInN0cmFuZ2UgaG9zdG5hbWUgJyVzJyBibG9ja2VkIgogbXNnc3RyICLEkcOjIGtow7NhIHTDqm4gbcOheSBs4bqhIOKAnCVz4oCdIgpAQCAtMjEyNyw1OCArMjEzNyw1OCBAQAogbXNnaWQgImNhbm5vdCBzdGFydCBwcm94eSAlcyIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIGto4bufaSBjaOG6oXkg4buneSBuaGnhu4dtIOKAnCVz4oCdIgogCi0jOiBjb25uZWN0LmM6OTI0CisjOiBjb25uZWN0LmM6OTI4CiBtc2dpZCAibm8gcGF0aCBzcGVjaWZpZWQ7IHNlZSAnZ2l0IGhlbHAgcHVsbCcgZm9yIHZhbGlkIHVybCBzeW50YXgiCiBtc2dzdHIgImNoxrBhIGNo4buJIMSR4buLbmggxJHGsOG7nW5nIGThuqtuOyB4ZW0nZ2l0IGhlbHAgcHVsbOKAnSDEkeG7gyBiaeG6v3QgY8O6IHBow6FwIHVybCBo4bujcCBs4buHIgogCi0jOiBjb25uZWN0LmM6MTExOQorIzogY29ubmVjdC5jOjExMjMKIG1zZ2lkICJzc2ggdmFyaWFudCAnc2ltcGxlJyBkb2VzIG5vdCBzdXBwb3J0IC00IgogbXNnc3RyICJzc2ggYmnhur9uIHRo4buDIOKAnHNpbXBsZeKAnSBraMO0bmcgaOG7lyB0cuG7oyAtNCIKIAotIzogY29ubmVjdC5jOjExMzEKKyM6IGNvbm5lY3QuYzoxMTM1CiBtc2dpZCAic3NoIHZhcmlhbnQgJ3NpbXBsZScgZG9lcyBub3Qgc3VwcG9ydCAtNiIKIG1zZ3N0ciAic3NoIGJp4bq/biB0aOG7gyDigJxzaW1wbGXigJ0ga2jDtG5nIGjhu5cgdHLhu6MgLTYiCiAKLSM6IGNvbm5lY3QuYzoxMTQ4CisjOiBjb25uZWN0LmM6MTE1MgogbXNnaWQgInNzaCB2YXJpYW50ICdzaW1wbGUnIGRvZXMgbm90IHN1cHBvcnQgc2V0dGluZyBwb3J0IgogbXNnc3RyICJzc2ggYmnhur9uIHRo4buDIOKAnHNpbXBsZeKAnSBraMO0bmcgaOG7lyB0cuG7oyDEkeG6t3QgY+G7lW5nIgogCi0jOiBjb25uZWN0LmM6MTI2MAorIzogY29ubmVjdC5jOjEyNjQKICMsIGMtZm9ybWF0CiBtc2dpZCAic3RyYW5nZSBwYXRobmFtZSAnJXMnIGJsb2NrZWQiCiBtc2dzdHIgIsSRw6Mga2jDs2EgdMOqbiDEkcaw4budbmcgZOG6q24gbOG6oSDigJwlc+KAnSIKIAotIzogY29ubmVjdC5jOjEzMDcKKyM6IGNvbm5lY3QuYzoxMzExCiBtc2dpZCAidW5hYmxlIHRvIGZvcmsiCiBtc2dzdHIgImtow7RuZyB0aOG7gyBy4bq9IG5ow6FuaCB0aeG6v24gdHLDrG5oIGNvbiIKIAotIzogY29ubmVjdGVkLmM6ODYgYnVpbHRpbi9mc2NrLmM6MjIxIGJ1aWx0aW4vcHJ1bmUuYzo0MworIzogY29ubmVjdGVkLmM6ODggYnVpbHRpbi9mc2NrLmM6MjIxIGJ1aWx0aW4vcHJ1bmUuYzo0MwogbXNnaWQgIkNoZWNraW5nIGNvbm5lY3Rpdml0eSIKIG1zZ3N0ciAixJBhbmcga2nhu4NtIHRyYSBr4bq/dCBu4buRaSIKIAotIzogY29ubmVjdGVkLmM6OTgKKyM6IGNvbm5lY3RlZC5jOjEwMAogbXNnaWQgIkNvdWxkIG5vdCBydW4gJ2dpdCByZXYtbGlzdCciCiBtc2dzdHIgIktow7RuZyB0aOG7gyBjaOG6oXkg4oCcZ2l0IHJldi1saXN04oCdIgogCi0jOiBjb25uZWN0ZWQuYzoxMTgKKyM6IGNvbm5lY3RlZC5jOjEyMAogbXNnaWQgImZhaWxlZCB3cml0ZSB0byByZXYtbGlzdCIKIG1zZ3N0ciAiZ+G6t3AgbOG7l2kga2hpIGdoaSB2w6BvIHJldi1saXN0IgogCi0jOiBjb25uZWN0ZWQuYzoxMjUKKyM6IGNvbm5lY3RlZC5jOjEyNwogbXNnaWQgImZhaWxlZCB0byBjbG9zZSByZXYtbGlzdCdzIHN0ZGluIgogbXNnc3RyICJn4bq3cCBs4buXaSBraGkgxJHDs25nIMSR4bqndSB2w6BvIGNodeG6qW4gc3RkaW4gY+G7p2EgcmV2LWxpc3QiCiAKLSM6IGNvbnZlcnQuYzoxOTMKKyM6IGNvbnZlcnQuYzoxOTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiaWxsZWdhbCBjcmxmX2FjdGlvbiAlZCIKIG1zZ3N0ciAiY3JsZl9hY3Rpb24gJWQga2jDtG5nIGjhu6NwIGzhu4ciCiAKLSM6IGNvbnZlcnQuYzoyMDYKKyM6IGNvbnZlcnQuYzoyMDcKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ1JMRiB3b3VsZCBiZSByZXBsYWNlZCBieSBMRiBpbiAlcyIKIG1zZ3N0ciAiQ1JMRiBuw6puIMSRxrDhu6NjIHRoYXkgYuG6sW5nIExGIHRyb25nICVzIgogCi0jOiBjb252ZXJ0LmM6MjA4CisjOiBjb252ZXJ0LmM6MjA5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJDUkxGIHdpbGwgYmUgcmVwbGFjZWQgYnkgTEYgaW4gJXMuXG4iCkBAIC0yMTg3LDEyICsyMTk3LDEyIEBACiAiQ1JMRiBz4bq9IGLhu4sgdGhheSB0aOG6vyBi4bqxbmcgTEYgdHJvbmcgJXMuXG4iCiAiVOG6rXAgdGluIHPhur0gY8OzIGtp4buDdSB4deG7kW5nIGTDsm5nIG5oxrAgYuG6o24gZ+G7kWMgdHJvbmcgdGjGsCBt4bulYyBsw6BtIHZp4buHYyBj4bunYSBi4bqhbiIKIAotIzogY29udmVydC5jOjIxNgorIzogY29udmVydC5jOjIxNwogIywgYy1mb3JtYXQKIG1zZ2lkICJMRiB3b3VsZCBiZSByZXBsYWNlZCBieSBDUkxGIGluICVzIgogbXNnc3RyICJMRiBuw6puIHRoYXkgYuG6sW5nIENSTEYgdHJvbmcgJXMiCiAKLSM6IGNvbnZlcnQuYzoyMTgKKyM6IGNvbnZlcnQuYzoyMTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkxGIHdpbGwgYmUgcmVwbGFjZWQgYnkgQ1JMRiBpbiAlcy5cbiIKQEAgLTIyMDEsMTIgKzIyMTEsMTIgQEAKICJMRiBz4bq9IGLhu4sgdGhheSB0aOG6vyBi4bqxbmcgQ1JMRiB0cm9uZyAlcy5cbiIKICJU4bqtcCB0aW4gc+G6vSBjw7Mga2nhu4N1IHh14buRbmcgZMOybmcgbmjGsCBi4bqjbiBn4buRYyB0cm9uZyB0aMawIG3hu6VjIGzDoG0gdmnhu4djIGPhu6dhIGLhuqFuIgogCi0jOiBjb252ZXJ0LmM6Mjc5CisjOiBjb252ZXJ0LmM6MjgwCiAjLCBjLWZvcm1hdAogbXNnaWQgIkJPTSBpcyBwcm9oaWJpdGVkIGluICclcycgaWYgZW5jb2RlZCBhcyAlcyIKIG1zZ3N0ciAiQk9NIGLhu4sgY+G6pW0gdHJvbmcg4oCcJXPigJ0gbuG6v3UgxJHGsOG7o2MgbcOjIGjDs2EgbMOgICVzIgogCi0jOiBjb252ZXJ0LmM6Mjg2CisjOiBjb252ZXJ0LmM6Mjg3CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgZmlsZSAnJXMnIGNvbnRhaW5zIGEgYnl0ZSBvcmRlciBtYXJrIChCT00pLiBQbGVhc2UgdXNlIFVURi0lcyBhcyB3b3JraW5nLSIKQEAgLTIyMTUsMTIgKzIyMjUsMTIgQEAKICJU4bqtcCB0aW4g4oCcJXPigJ0gY8OzIGNo4bupYSBrw70gaGnhu4d1IHRo4bupIHThu7EgYnl0ZSAoQk9NKS4gVnVpIGzDsm5nIGTDuW5nIFVURi0lcyBuaMawIGzDoCAiCiAiYuG6o25nIG3DoyBjw6J5IGzDoG0gdmnhu4djLiIKIAotIzogY29udmVydC5jOjMwNAorIzogY29udmVydC5jOjMwNQogIywgYy1mb3JtYXQKIG1zZ2lkICJCT00gaXMgcmVxdWlyZWQgaW4gJyVzJyBpZiBlbmNvZGVkIGFzICVzIgogbXNnc3RyICJCT00gbMOgIGLhuq90IGJ14buZYyB0cm9uZyDigJwlc+KAnSBu4bq/dSDEkcaw4bujYyBtw6MgaMOzYSBsw6AgJXMiCiAKLSM6IGNvbnZlcnQuYzozMDYKKyM6IGNvbnZlcnQuYzozMDcKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlRoZSBmaWxlICclcycgaXMgbWlzc2luZyBhIGJ5dGUgb3JkZXIgbWFyayAoQk9NKS4gUGxlYXNlIHVzZSBVVEYtJXNCRSBvciBVVEYtIgpAQCAtMjIyOSw1MCArMjIzOSw1MCBAQAogIlThuq1wIHRpbiDigJwlc+KAnSBjw7JuIHRoaeG6v3Uga8O9IGhp4buHdSB0aOG7qSB04buxIGJ5dGUgKEJPTSkuIFZ1aSBsw7JuZyBkw7luZyBVVEYtJXNCRSBoYXkgIgogIlVURi0lc0xFIChjw7JuIHBo4bulYyB0aHXhu5ljIHbDoG8gdGjhu6kgdOG7sSBieXRlKSBuaMawIGzDoCBi4bqjbmcgbcOjIGPDonkgbMOgbSB2aeG7h2MuIgogCi0jOiBjb252ZXJ0LmM6NDI0IGNvbnZlcnQuYzo0OTUKKyM6IGNvbnZlcnQuYzo0MjUgY29udmVydC5jOjQ5NgogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gZW5jb2RlICclcycgZnJvbSAlcyB0byAlcyIKIG1zZ3N0ciAiZ+G6t3AgbOG7l2kga2hpIG3DoyBow7NhIOKAnCVz4oCdICB04burIOKAnCVz4oCdIHNhbmcg4oCcJXPigJ0iCiAKLSM6IGNvbnZlcnQuYzo0NjcKKyM6IGNvbnZlcnQuYzo0NjgKICMsIGMtZm9ybWF0CiBtc2dpZCAiZW5jb2RpbmcgJyVzJyBmcm9tICVzIHRvICVzIGFuZCBiYWNrIGlzIG5vdCB0aGUgc2FtZSIKIG1zZ3N0ciAibcOjIGjDs2Eg4oCcJXPigJ0gdOG7qyAlcyB0aMOgbmggJXMgdsOgIG5nxrDhu6NjIHRy4bufIGzhuqFpIGtow7RuZyBwaOG6o2kgbMOgIGPDuW5nIgogCi0jOiBjb252ZXJ0LmM6NjczCisjOiBjb252ZXJ0LmM6Njc0CiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCBmb3JrIHRvIHJ1biBleHRlcm5hbCBmaWx0ZXIgJyVzJyIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIHLhur0gbmjDoW5oIHRp4bq/biB0csOsbmggxJHhu4MgY2jhuqF5IGLhu5kgbOG7jWMgYsOqbiBuZ2/DoGkg4oCcJXPigJ0iCiAKLSM6IGNvbnZlcnQuYzo2OTMKKyM6IGNvbnZlcnQuYzo2OTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IGZlZWQgdGhlIGlucHV0IHRvIGV4dGVybmFsIGZpbHRlciAnJXMnIgogbXNnc3RyICJraMO0bmcgdGjhu4MgY+G6pXAgxJHhuqd1IHbDoG8gY2hvIGLhu5kgbOG7jWMgYsOqbiBuZ2/DoGkg4oCcJXPigJ0iCiAKLSM6IGNvbnZlcnQuYzo3MDAKKyM6IGNvbnZlcnQuYzo3MDEKICMsIGMtZm9ybWF0CiBtc2dpZCAiZXh0ZXJuYWwgZmlsdGVyICclcycgZmFpbGVkICVkIgogbXNnc3RyICJjaOG6oXkgYuG7mSBs4buNYyBiw6puIG5nb8OgaSDigJwlc+KAnSBn4bq3cCBs4buXaSAlZCIKIAotIzogY29udmVydC5jOjczNSBjb252ZXJ0LmM6NzM4CisjOiBjb252ZXJ0LmM6NzM2IGNvbnZlcnQuYzo3MzkKICMsIGMtZm9ybWF0CiBtc2dpZCAicmVhZCBmcm9tIGV4dGVybmFsIGZpbHRlciAnJXMnIGZhaWxlZCIKIG1zZ3N0ciAixJHhu41jIHThu6sgYuG7mSBs4buNYyBiw6puIG5nb8OgaSDigJwlc+KAnSBn4bq3cCBs4buXaSIKIAotIzogY29udmVydC5jOjc0MSBjb252ZXJ0LmM6Nzk2CisjOiBjb252ZXJ0LmM6NzQyIGNvbnZlcnQuYzo3OTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiZXh0ZXJuYWwgZmlsdGVyICclcycgZmFpbGVkIgogbXNnc3RyICJn4bq3cCBs4buXaSBraGkgY2jhuqF5IGLhu5kgbOG7jWMgYsOqbiBuZ2/DoGkg4oCcJXPigJ0iCiAKLSM6IGNvbnZlcnQuYzo4NDQKKyM6IGNvbnZlcnQuYzo4NDUKIG1zZ2lkICJ1bmV4cGVjdGVkIGZpbHRlciB0eXBlIgogbXNnc3RyICJn4bq3cCBraeG7g3UgYuG7mSBs4buNYyB0aOG7q2EiCiAKLSM6IGNvbnZlcnQuYzo4NTUKKyM6IGNvbnZlcnQuYzo4NTYKIG1zZ2lkICJwYXRoIG5hbWUgdG9vIGxvbmcgZm9yIGV4dGVybmFsIGZpbHRlciIKIG1zZ3N0ciAidMOqbiDEkcaw4budbmcgZOG6q24gcXXDoSBkw6BpIGNobyBi4buZIGzhu41jIGLDqm4gbmdvw6BpIgogCi0jOiBjb252ZXJ0LmM6OTI5CisjOiBjb252ZXJ0LmM6OTMwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJleHRlcm5hbCBmaWx0ZXIgJyVzJyBpcyBub3QgYXZhaWxhYmxlIGFueW1vcmUgYWx0aG91Z2ggbm90IGFsbCBwYXRocyBoYXZlICIKQEAgLTIyODEsNzQgKzIyOTEsNzQgQEAKICJi4buZIGzhu41jIGLDqm4gbmdvw6BpIOKAnCVz4oCdIGtow7RuZyBz4bq1biBzw6BuZyBu4buvYSBt4bq3YyBkw7kga2jDtG5nIHBo4bqjaSB04bqldCBj4bqjIGPDoWMgxJHGsOG7nW5nICIKICJk4bqrbiDEkcOjIMSRxrDhu6NjIGzhu41jIgogCi0jOiBjb252ZXJ0LmM6MTIyOAorIzogY29udmVydC5jOjEyMjkKIG1zZ2lkICJ0cnVlL2ZhbHNlIGFyZSBubyB2YWxpZCB3b3JraW5nLXRyZWUtZW5jb2RpbmdzIgogbXNnc3RyICJ0cnVlL2ZhbHNlIGzDoCBraMO0bmcgcGjhuqNpIGLhuqNuZy1tw6MtY8OieS1sw6BtLXZp4buHYyBo4bujcCBs4buHIgogCi0jOiBjb252ZXJ0LmM6MTM5OCBjb252ZXJ0LmM6MTQzMgorIzogY29udmVydC5jOjE0MTcgY29udmVydC5jOjE0NTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXM6IGNsZWFuIGZpbHRlciAnJXMnIGZhaWxlZCIKIG1zZ3N0ciAiJXM6IGfhurdwIGzhu5dpIGtoaSB4w7NhIGLhu5kgbOG7jWMg4oCcJXPigJ0iCiAKLSM6IGNvbnZlcnQuYzoxNDc2CisjOiBjb252ZXJ0LmM6MTQ5NQogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogc211ZGdlIGZpbHRlciAlcyBmYWlsZWQiCiBtc2dzdHIgIiVzOiBzbXVkZ2UgYuG7mSBs4buNYyAlcyBn4bq3cCBs4buXaSIKIAotIzogZGF0ZS5jOjEzNworIzogZGF0ZS5jOjEzOAogbXNnaWQgImluIHRoZSBmdXR1cmUiCiBtc2dzdHIgIuG7nyB0aOG7nWkgdMawxqFuZyBsYWkiCiAKLSM6IGRhdGUuYzoxNDMKKyM6IGRhdGUuYzoxNDQKICMsIGMtZm9ybWF0CiBtc2dpZCAiJTxQUkl1TUFYPiBzZWNvbmQgYWdvIgogbXNnaWRfcGx1cmFsICIlPFBSSXVNQVg+IHNlY29uZHMgYWdvIgogbXNnc3RyWzBdICIlPFBSSXVNQVg+IGdpw6J5IHRyxrDhu5tjIgogCi0jOiBkYXRlLmM6MTUwCisjOiBkYXRlLmM6MTUxCiAjLCBjLWZvcm1hdAogbXNnaWQgIiU8UFJJdU1BWD4gbWludXRlIGFnbyIKIG1zZ2lkX3BsdXJhbCAiJTxQUkl1TUFYPiBtaW51dGVzIGFnbyIKIG1zZ3N0clswXSAiJTxQUkl1TUFYPiBwaMO6dCB0csaw4bubYyIKIAotIzogZGF0ZS5jOjE1NworIzogZGF0ZS5jOjE1OAogIywgYy1mb3JtYXQKIG1zZ2lkICIlPFBSSXVNQVg+IGhvdXIgYWdvIgogbXNnaWRfcGx1cmFsICIlPFBSSXVNQVg+IGhvdXJzIGFnbyIKIG1zZ3N0clswXSAiJTxQUkl1TUFYPiBnaeG7nSB0csaw4bubYyIKIAotIzogZGF0ZS5jOjE2NAorIzogZGF0ZS5jOjE2NQogIywgYy1mb3JtYXQKIG1zZ2lkICIlPFBSSXVNQVg+IGRheSBhZ28iCiBtc2dpZF9wbHVyYWwgIiU8UFJJdU1BWD4gZGF5cyBhZ28iCiBtc2dzdHJbMF0gIiU8UFJJdU1BWD4gbmfDoHkgdHLGsOG7m2MiCiAKLSM6IGRhdGUuYzoxNzAKKyM6IGRhdGUuYzoxNzEKICMsIGMtZm9ybWF0CiBtc2dpZCAiJTxQUkl1TUFYPiB3ZWVrIGFnbyIKIG1zZ2lkX3BsdXJhbCAiJTxQUkl1TUFYPiB3ZWVrcyBhZ28iCiBtc2dzdHJbMF0gIiU8UFJJdU1BWD4gdHXhuqduIHRyxrDhu5tjIgogCi0jOiBkYXRlLmM6MTc3CisjOiBkYXRlLmM6MTc4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiU8UFJJdU1BWD4gbW9udGggYWdvIgogbXNnaWRfcGx1cmFsICIlPFBSSXVNQVg+IG1vbnRocyBhZ28iCiBtc2dzdHJbMF0gIiU8UFJJdU1BWD4gdGjDoW5nIHRyxrDhu5tjIgogCi0jOiBkYXRlLmM6MTg4CisjOiBkYXRlLmM6MTg5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiU8UFJJdU1BWD4geWVhciIKIG1zZ2lkX3BsdXJhbCAiJTxQUkl1TUFYPiB5ZWFycyIKIG1zZ3N0clswXSAiJTxQUkl1TUFYPiBuxINtIgogCiAjLiBUUkFOU0xBVE9SUzogIiVzIiBpcyAiPG4+IHllYXJzIgotIzogZGF0ZS5jOjE5MQorIzogZGF0ZS5jOjE5MgogIywgYy1mb3JtYXQKIG1zZ2lkICIlcywgJTxQUkl1TUFYPiBtb250aCBhZ28iCiBtc2dpZF9wbHVyYWwgIiVzLCAlPFBSSXVNQVg+IG1vbnRocyBhZ28iCiBtc2dzdHJbMF0gIiVzLCAlPFBSSXVNQVg+IHRow6FuZyB0csaw4bubYyIKIAotIzogZGF0ZS5jOjE5NiBkYXRlLmM6MjAxCisjOiBkYXRlLmM6MTk3IGRhdGUuYzoyMDIKICMsIGMtZm9ybWF0CiBtc2dpZCAiJTxQUkl1TUFYPiB5ZWFyIGFnbyIKIG1zZ2lkX3BsdXJhbCAiJTxQUkl1TUFYPiB5ZWFycyBhZ28iCkBAIC0yMzg0LDcgKzIzOTQsNyBAQAogbXNnaWQgImZhaWxlZCB0byByZWFkIG9yZGVyZmlsZSAnJXMnIgogbXNnc3RyICJn4bq3cCBs4buXaSBraGkgxJHhu41jIHThuq1wLXRpbi10aOG7qS104buxIOKAnCVz4oCdIgogCi0jOiBkaWZmY29yZS1yZW5hbWUuYzo1NDQKKyM6IGRpZmZjb3JlLXJlbmFtZS5jOjU0MwogbXNnaWQgIlBlcmZvcm1pbmcgaW5leGFjdCByZW5hbWUgZGV0ZWN0aW9uIgogbXNnc3RyICLEkGFuZyB0aOG7sWMgaGnhu4duIGTDsiB0w6xtIMSR4buVaSB0w6puIGtow7RuZyBjaMOtbmggeMOhYyIKIApAQCAtMjQ1MCwzNSArMjQ2MCwzNSBAQAogIlTDrG0gdGjhuqV5IGPDoWMgbOG7l2kgdHJvbmcgYmnhur9uIGPhuqV1IGjDrG5oIOKAnGRpZmYuZGlyc3RhdOKAnTpcbiIKICIlcyIKIAotIzogZGlmZi5jOjQyMTUKKyM6IGRpZmYuYzo0MjE4CiAjLCBjLWZvcm1hdAogbXNnaWQgImV4dGVybmFsIGRpZmYgZGllZCwgc3RvcHBpbmcgYXQgJXMiCiBtc2dzdHIgInBo4bqnbiBt4buBbSBkaWZmIOG7nyBiw6puIG5nb8OgaSDEkcOjIGNo4bq/dCwgZOG7q25nIHThuqFpICVzIgogCi0jOiBkaWZmLmM6NDU2MAorIzogZGlmZi5jOjQ1NjMKIG1zZ2lkICItLW5hbWUtb25seSwgLS1uYW1lLXN0YXR1cywgLS1jaGVjayBhbmQgLXMgYXJlIG11dHVhbGx5IGV4Y2x1c2l2ZSIKIG1zZ3N0ciAiLS1uYW1lLW9ubHksIC0tbmFtZS1zdGF0dXMsIC0tY2hlY2sgdsOgIC1zIGxv4bqhaSB04burIGzhuqtuIG5oYXUiCiAKLSM6IGRpZmYuYzo0NTYzCisjOiBkaWZmLmM6NDU2NgogbXNnaWQgIi1HLCAtUyBhbmQgLS1maW5kLW9iamVjdCBhcmUgbXV0dWFsbHkgZXhjbHVzaXZlIgogbXNnc3RyICJDw6FjIHTDuXkgY2jhu41uIC1HLCAtUywgdsOgIC0tZmluZC1vYmplY3QgbG/huqFpIHThu6sgbOG6q24gbmhhdSIKIAotIzogZGlmZi5jOjQ2NDEKKyM6IGRpZmYuYzo0NjQ0CiBtc2dpZCAiLS1mb2xsb3cgcmVxdWlyZXMgZXhhY3RseSBvbmUgcGF0aHNwZWMiCiBtc2dzdHIgIi0tZm9sbG93IGPhuqduIGNow61uaCB4w6FjIG3hu5l0IMSR4bq3YyB04bqjIMSRxrDhu51uZyBk4bqrbiIKIAotIzogZGlmZi5jOjQ2ODkKKyM6IGRpZmYuYzo0NjkyCiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgLS1zdGF0IHZhbHVlOiAlcyIKIG1zZ3N0ciAiZ2nDoSB0cuG7iyAtLXN0YXQga2jDtG5nIGjhu6NwIGzhu4c6IOKAnCVz4oCdIgogCi0jOiBkaWZmLmM6NDY5NCBkaWZmLmM6NDY5OSBkaWZmLmM6NDcwNCBkaWZmLmM6NDcwOSBkaWZmLmM6NTIyMgorIzogZGlmZi5jOjQ2OTcgZGlmZi5jOjQ3MDIgZGlmZi5jOjQ3MDcgZGlmZi5jOjQ3MTIgZGlmZi5jOjUyMjUKICM6IHBhcnNlLW9wdGlvbnMuYzoxOTkgcGFyc2Utb3B0aW9ucy5jOjIwMwogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyBleHBlY3RzIGEgbnVtZXJpY2FsIHZhbHVlIgogbXNnc3RyICJ0w7l5IGNo4buNbiDigJwlc+KAnSBj4bqnbiBt4buZdCBnacOhIHRy4buLIGLhurFuZyBz4buRIgogCi0jOiBkaWZmLmM6NDcyNgorIzogZGlmZi5jOjQ3MjkKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkZhaWxlZCB0byBwYXJzZSAtLWRpcnN0YXQvLVggb3B0aW9uIHBhcmFtZXRlcjpcbiIKQEAgLTI0ODcsNDIgKzI0OTcsNDIgQEAKICJH4bq3cCBs4buXaSBraGkgcGjDom4gdMOtY2ggxJHhu5FpIHPhu5EgdMO5eSBjaOG7jW4gLS1kaXJzdGF0Ly1YOlxuIgogIiVzIgogCi0jOiBkaWZmLmM6NDgxMQorIzogZGlmZi5jOjQ4MTQKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5rbm93biBjaGFuZ2UgY2xhc3MgJyVjJyBpbiAtLWRpZmYtZmlsdGVyPSVzIgogbXNnc3RyICJraMO0bmcgaGnhu4N1IGzhu5twIHRoYXkgxJHhu5VpIOKAnCVj4oCdIHRyb25nIC0tZGlmZi1maWx0ZXI9JXMiCiAKLSM6IGRpZmYuYzo0ODM1CisjOiBkaWZmLmM6NDgzOAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmtub3duIHZhbHVlIGFmdGVyIHdzLWVycm9yLWhpZ2hsaWdodD0lLipzIgogbXNnc3RyICJraMO0bmcgaGnhu4N1IGdpw6EgdHLhu4sgc2F1IHdzLWVycm9yLWhpZ2hsaWdodD0lLipzIgogCi0jOiBkaWZmLmM6NDg0OQorIzogZGlmZi5jOjQ4NTIKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHJlc29sdmUgJyVzJyIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIHBow6JuIGdp4bqjaSDigJwlc+KAnSIKIAotIzogZGlmZi5jOjQ4OTkgZGlmZi5jOjQ5MDUKKyM6IGRpZmYuYzo0OTAyIGRpZmYuYzo0OTA4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIGV4cGVjdHMgPG4+LzxtPiBmb3JtIgogbXNnc3RyICIlcyBj4bqnbiBk4bqhbmcgPG4+LzxtPiIKIAotIzogZGlmZi5jOjQ5MTcKKyM6IGRpZmYuYzo0OTIwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIGV4cGVjdHMgYSBjaGFyYWN0ZXIsIGdvdCAnJXMnIgogbXNnc3RyICIlcyBj4bqnbiBt4buZdCBrw70gdOG7sSwgbmjGsG5nIGzhuqFpIG5o4bqtbiDEkcaw4bujYyDigJwlc+KAnSIKIAotIzogZGlmZi5jOjQ5MzgKKyM6IGRpZmYuYzo0OTQxCiAjLCBjLWZvcm1hdAogbXNnaWQgImJhZCAtLWNvbG9yLW1vdmVkIGFyZ3VtZW50OiAlcyIKIG1zZ3N0ciAixJHhu5FpIHPhu5EgLS1jb2xvci1tb3ZlZCBzYWk6ICVzIgogCi0jOiBkaWZmLmM6NDk1NworIzogZGlmZi5jOjQ5NjAKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBtb2RlICclcycgaW4gLS1jb2xvci1tb3ZlZC13cyIKIG1zZ3N0ciAiY2jhur8gxJHhu5kg4oCcJXPigJ0ga2jDtG5nIGjhu6NwIGzhu4cgdHJvbmcgLS1jb2xvci1tb3ZlZC13cyIKIAotIzogZGlmZi5jOjQ5OTcKKyM6IGRpZmYuYzo1MDAwCiBtc2dpZCAiIgogIm9wdGlvbiBkaWZmLWFsZ29yaXRobSBhY2NlcHRzIFwibXllcnNcIiwgXCJtaW5pbWFsXCIsIFwicGF0aWVuY2VcIiBhbmQgIgogIlwiaGlzdG9ncmFtXCIiCkBAIC0yNTMwLDE1MCArMjU0MCwxNTAgQEAKICJ0w7l5IGNo4buNbiAgZGlmZi1hbGdvcml0aG0gY2jhuqVwIG5o4bqtbiBcIm15ZXJzXCIsIFwibWluaW1hbFwiLCBcInBhdGllbmNlXCIgdsOgICIKICJcImhpc3RvZ3JhbVwiIgogCi0jOiBkaWZmLmM6NTAzMyBkaWZmLmM6NTA1MworIzogZGlmZi5jOjUwMzYgZGlmZi5jOjUwNTYKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBhcmd1bWVudCB0byAlcyIKIG1zZ3N0ciAidGhhbSBz4buRIGNobyAlcyBraMO0bmcgaOG7o3AgbOG7hyIKIAotIzogZGlmZi5jOjUxOTEKKyM6IGRpZmYuYzo1MTk0CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBwYXJzZSAtLXN1Ym1vZHVsZSBvcHRpb24gcGFyYW1ldGVyOiAnJXMnIgogbXNnc3RyICJn4bq3cCBs4buXaSBraGkgcGjDom4gdMOtY2ggxJHhu5FpIHPhu5EgdMO5eSBjaOG7jW4gLS1zdWJtb2R1bGU6IOKAnCVz4oCdIgogCi0jOiBkaWZmLmM6NTI0NworIzogZGlmZi5jOjUyNTAKICMsIGMtZm9ybWF0CiBtc2dpZCAiYmFkIC0td29yZC1kaWZmIGFyZ3VtZW50OiAlcyIKIG1zZ3N0ciAixJHhu5FpIHPhu5EgLS13b3JkLWRpZmYgc2FpOiAlcyIKIAotIzogZGlmZi5jOjUyNzAKKyM6IGRpZmYuYzo1MjczCiBtc2dpZCAiRGlmZiBvdXRwdXQgZm9ybWF0IG9wdGlvbnMiCiBtc2dzdHIgIkPDoWMgdMO5eSBjaOG7jW4gxJHhu4tuaCBk4bqhbmcga2hpIHh14bqldCBjw6FjIGtow6FjIGJp4buHdCIKIAotIzogZGlmZi5jOjUyNzIgZGlmZi5jOjUyNzgKKyM6IGRpZmYuYzo1Mjc1IGRpZmYuYzo1MjgxCiBtc2dpZCAiZ2VuZXJhdGUgcGF0Y2giCiBtc2dzdHIgInThuqFvIG1p4bq/bmcgdsOhIgogCi0jOiBkaWZmLmM6NTI3NSBidWlsdGluL2xvZy5jOjE3MgorIzogZGlmZi5jOjUyNzggYnVpbHRpbi9sb2cuYzoxNzIKIG1zZ2lkICJzdXBwcmVzcyBkaWZmIG91dHB1dCIKIG1zZ3N0ciAiY2jhurduIG3hu41pIGvhur90IHh14bqldCB04burIGRpZmYiCiAKLSM6IGRpZmYuYzo1MjgwIGRpZmYuYzo1Mzk0IGRpZmYuYzo1NDAxCisjOiBkaWZmLmM6NTI4MyBkaWZmLmM6NTM5NyBkaWZmLmM6NTQwNAogbXNnaWQgIjxuPiIKIG1zZ3N0ciAiPG4+IgogCi0jOiBkaWZmLmM6NTI4MSBkaWZmLmM6NTI4NAorIzogZGlmZi5jOjUyODQgZGlmZi5jOjUyODcKIG1zZ2lkICJnZW5lcmF0ZSBkaWZmcyB3aXRoIDxuPiBsaW5lcyBjb250ZXh0IgogbXNnc3RyICJ04bqhbyBraMOhYyBiaeG7h3QgduG7m2kgPG4+IGTDsm5nIG5n4buvIGPhuqNuaCIKIAotIzogZGlmZi5jOjUyODYKKyM6IGRpZmYuYzo1Mjg5CiBtc2dpZCAiZ2VuZXJhdGUgdGhlIGRpZmYgaW4gcmF3IGZvcm1hdCIKIG1zZ3N0ciAidOG6oW8ga2jDoWMgYmnhu4d0IOG7nyDEkeG7i25oIGThuqFuZyB0aMO0IgogCi0jOiBkaWZmLmM6NTI4OQorIzogZGlmZi5jOjUyOTIKIG1zZ2lkICJzeW5vbnltIGZvciAnLXAgLS1yYXcnIgogbXNnc3RyICLEkeG7k25nIG5naMSpYSB24bubaSDigJwtcCAtLXJhd+KAnSIKIAotIzogZGlmZi5jOjUyOTMKKyM6IGRpZmYuYzo1Mjk2CiBtc2dpZCAic3lub255bSBmb3IgJy1wIC0tc3RhdCciCiBtc2dzdHIgIsSR4buTbmcgbmdoxKlhIHbhu5tpIOKAnC1wIC0tc3RhdOKAnSIKIAotIzogZGlmZi5jOjUyOTcKKyM6IGRpZmYuYzo1MzAwCiBtc2dpZCAibWFjaGluZSBmcmllbmRseSAtLXN0YXQiCiBtc2dzdHIgIi0tc3RhdCB0aHXhuq1uIHRp4buHbiBjaG8gbcOheSDEkeG7jWMiCiAKLSM6IGRpZmYuYzo1MzAwCisjOiBkaWZmLmM6NTMwMwogbXNnaWQgIm91dHB1dCBvbmx5IHRoZSBsYXN0IGxpbmUgb2YgLS1zdGF0IgogbXNnc3RyICJjaOG7iSB4deG6pXQgbmjhu69uZyBkw7JuZyBjdeG7kWkgY+G7p2EgLS1zdGF0IgogCi0jOiBkaWZmLmM6NTMwMiBkaWZmLmM6NTMxMAorIzogZGlmZi5jOjUzMDUgZGlmZi5jOjUzMTMKIG1zZ2lkICI8cGFyYW0xLHBhcmFtMj4uLi4iCiBtc2dzdHIgIjx0aGFtX3Phu5FfMSx0aGFtX3Phu5FfMj7igKYiCiAKLSM6IGRpZmYuYzo1MzAzCisjOiBkaWZmLmM6NTMwNgogbXNnaWQgIiIKICJvdXRwdXQgdGhlIGRpc3RyaWJ1dGlvbiBvZiByZWxhdGl2ZSBhbW91bnQgb2YgY2hhbmdlcyBmb3IgZWFjaCBzdWItZGlyZWN0b3J5IgogbXNnc3RyICLEkeG6p3UgcmEgcGjDom4gcGjhu5FpIGPhu6dhIHPhu5EgbMaw4bujbmcgdGhheSDEkeG7lWkgdMawxqFuZyDEkeG7kWkgY2hvIG3hu5dpIHRoxrAgbeG7pWMgY29uIgogCi0jOiBkaWZmLmM6NTMwNworIzogZGlmZi5jOjUzMTAKIG1zZ2lkICJzeW5vbnltIGZvciAtLWRpcnN0YXQ9Y3VtdWxhdGl2ZSIKIG1zZ3N0ciAixJHhu5NuZyBuZ2jEqWEgduG7m2kgLS1kaXJzdGF0PWN1bXVsYXRpdmUiCiAKLSM6IGRpZmYuYzo1MzExCisjOiBkaWZmLmM6NTMxNAogbXNnaWQgInN5bm9ueW0gZm9yIC0tZGlyc3RhdD1maWxlcyxwYXJhbTEscGFyYW0yLi4uIgogbXNnc3RyICLEkeG7k25nIG5naMSpYSB24bubaSAtLWRpcnN0YXQ9ZmlsZXMscGFyYW0xLHBhcmFtMuKApiIKIAotIzogZGlmZi5jOjUzMTUKKyM6IGRpZmYuYzo1MzE4CiBtc2dpZCAid2FybiBpZiBjaGFuZ2VzIGludHJvZHVjZSBjb25mbGljdCBtYXJrZXJzIG9yIHdoaXRlc3BhY2UgZXJyb3JzIgogbXNnc3RyICIiCiAiY+G6o25oIGLDoW8gbuG6v3UgY8OhYyB0aGF5IMSR4buVaSDEkcawYSByYSBjw6FjIGLhu5kgdOG6oW8geHVuZyDEkeG7mXQgaGF5IGzhu5dpIGtob+G6o25nIHRy4bqvbmciCiAKLSM6IGRpZmYuYzo1MzE4CisjOiBkaWZmLmM6NTMyMQogbXNnaWQgImNvbmRlbnNlZCBzdW1tYXJ5IHN1Y2ggYXMgY3JlYXRpb25zLCByZW5hbWVzIGFuZCBtb2RlIGNoYW5nZXMiCiBtc2dzdHIgInThu5VuZyBo4bujcCBk4bqhbmcgeMO6YyB0w61jaCBuaMawIGzDoCB04bqhbywgxJHhu5VpIHTDqm4gdsOgIGPDoWMgdGhheSDEkeG7lWkgY2jhur8gxJHhu5kiCiAKLSM6IGRpZmYuYzo1MzIxCisjOiBkaWZmLmM6NTMyNAogbXNnaWQgInNob3cgb25seSBuYW1lcyBvZiBjaGFuZ2VkIGZpbGVzIgogbXNnc3RyICJjaOG7iSBoaeG7g24gdGjhu4sgdMOqbiBj4bunYSBjw6FjIHThuq1wIHRpbiDEkeG7lWkiCiAKLSM6IGRpZmYuYzo1MzI0CisjOiBkaWZmLmM6NTMyNwogbXNnaWQgInNob3cgb25seSBuYW1lcyBhbmQgc3RhdHVzIG9mIGNoYW5nZWQgZmlsZXMiCiBtc2dzdHIgImNo4buJIGhp4buDbiB0aOG7iyB0w6puIHThuq1wIHRpbiB2w6AgdMOsbmggdHLhuqFuZyBj4bunYSBjw6FjIHThuq1wIHRpbiBi4buLIHRoYXkgxJHhu5VpIgogCi0jOiBkaWZmLmM6NTMyNgorIzogZGlmZi5jOjUzMjkKIG1zZ2lkICI8d2lkdGg+Wyw8bmFtZS13aWR0aD5bLDxjb3VudD5dXSIKIG1zZ3N0ciAiPHLhu5luZz5bLDxuYW1lLXdpZHRoPlssPHPhu5EtbMaw4bujbmc+XV0iCiAKLSM6IGRpZmYuYzo1MzI3CisjOiBkaWZmLmM6NTMzMAogbXNnaWQgImdlbmVyYXRlIGRpZmZzdGF0IgogbXNnc3RyICJ04bqhbyBkaWZmc3RhdCIKIAotIzogZGlmZi5jOjUzMjkgZGlmZi5jOjUzMzIgZGlmZi5jOjUzMzUKKyM6IGRpZmYuYzo1MzMyIGRpZmYuYzo1MzM1IGRpZmYuYzo1MzM4CiBtc2dpZCAiPHdpZHRoPiIKIG1zZ3N0ciAiPHLhu5luZz4iCiAKLSM6IGRpZmYuYzo1MzMwCisjOiBkaWZmLmM6NTMzMwogbXNnaWQgImdlbmVyYXRlIGRpZmZzdGF0IHdpdGggYSBnaXZlbiB3aWR0aCIKIG1zZ3N0ciAidOG6oW8gZGlmZnN0YXQgduG7m2kgxJHhu5kgcuG7mW5nIMSRw6MgY2hvIgogCi0jOiBkaWZmLmM6NTMzMworIzogZGlmZi5jOjUzMzYKIG1zZ2lkICJnZW5lcmF0ZSBkaWZmc3RhdCB3aXRoIGEgZ2l2ZW4gbmFtZSB3aWR0aCIKIG1zZ3N0ciAidOG6oW8gZGlmZnN0YXQgduG7m2kgdMOqbiDEkeG7mSBy4buZbmcgxJHDoyBjaG8iCiAKLSM6IGRpZmYuYzo1MzM2CisjOiBkaWZmLmM6NTMzOQogbXNnaWQgImdlbmVyYXRlIGRpZmZzdGF0IHdpdGggYSBnaXZlbiBncmFwaCB3aWR0aCIKIG1zZ3N0ciAidOG6oW8gZGlmZnN0YXQgduG7m2kgxJHhu5kgcuG7mW5nIMSR4buTIHRo4buLIMSRw6MgY2hvIgogCi0jOiBkaWZmLmM6NTMzOAorIzogZGlmZi5jOjUzNDEKIG1zZ2lkICI8Y291bnQ+IgogbXNnc3RyICI8c+G7kV9sxrDhu6NuZz4iCiAKLSM6IGRpZmYuYzo1MzM5CisjOiBkaWZmLmM6NTM0MgogbXNnaWQgImdlbmVyYXRlIGRpZmZzdGF0IHdpdGggbGltaXRlZCBsaW5lcyIKIG1zZ3N0ciAidOG6oW8gZGlmZnN0YXQgduG7m2kgY8OhYyBkw7JuZyBi4buLIGdp4bubaSBo4bqhbiIKIAotIzogZGlmZi5jOjUzNDIKKyM6IGRpZmYuYzo1MzQ1CiBtc2dpZCAiZ2VuZXJhdGUgY29tcGFjdCBzdW1tYXJ5IGluIGRpZmZzdGF0IgogbXNnc3RyICJ04bqhbyB04buVbmcgaOG7o3AgeMO6YyB0w61jaCB0cm9uZyBkaWZmc3RhdCIKIAotIzogZGlmZi5jOjUzNDUKKyM6IGRpZmYuYzo1MzQ4CiBtc2dpZCAib3V0cHV0IGEgYmluYXJ5IGRpZmYgdGhhdCBjYW4gYmUgYXBwbGllZCIKIG1zZ3N0ciAieHXhuqV0IHJhIG3hu5l0IGtow6FjIGJp4buHdCBk4bqhbmcgbmjhu4sgcGjDom4gY8OhaSBtw6AgY8OzIHRo4buDIMSRxrDhu6NjIMOhcCBk4bulbmciCiAKLSM6IGRpZmYuYzo1MzQ4CisjOiBkaWZmLmM6NTM1MQogbXNnaWQgInNob3cgZnVsbCBwcmUtIGFuZCBwb3N0LWltYWdlIG9iamVjdCBuYW1lcyBvbiB0aGUgXCJpbmRleFwiIGxpbmVzIgogbXNnc3RyICIiCiAiaGnhu4NuIHRo4buLIMSR4bqneSDEkeG7pyBjw6FjIHTDqm4gxJHhu5FpIHTGsOG7o25nIHByZS0gdsOgIHBvc3QtaW1hZ2UgdHLDqm4gY8OhYyBkw7JuZyBcIm3hu6VjIGzhu6VjIgogIlwiIgogCi0jOiBkaWZmLmM6NTM1MAorIzogZGlmZi5jOjUzNTMKIG1zZ2lkICJzaG93IGNvbG9yZWQgZGlmZiIKIG1zZ3N0ciAiaGnhu4NuIHRo4buLIHRoYXkgxJHhu5VpIMSRxrDhu6NjIHTDtCBtw6B1IgogCi0jOiBkaWZmLmM6NTM1MQorIzogZGlmZi5jOjUzNTQKIG1zZ2lkICI8a2luZD4iCiBtc2dzdHIgIjxraeG7g3U+IgogCi0jOiBkaWZmLmM6NTM1MgorIzogZGlmZi5jOjUzNTUKIG1zZ2lkICIiCiAiaGlnaGxpZ2h0IHdoaXRlc3BhY2UgZXJyb3JzIGluIHRoZSAnY29udGV4dCcsICdvbGQnIG9yICduZXcnIGxpbmVzIGluIHRoZSAiCiAiZGlmZiIKQEAgLTI2ODEsNyArMjY5MSw3IEBACiAidMO0IHNhbmcgY8OhYyBs4buXaSB24buBIGtob+G6o25nIHRy4bqvbmcgdHJvbmcgY8OhYyBkw7JuZyDigJxjb250ZXh04oCdLCDigJxvbGTigJ0gdsOgIOKAnG5ld+KAnSAiCiAidHJvbmcga2jDoWMgYmnhu4d0IgogCi0jOiBkaWZmLmM6NTM1NQorIzogZGlmZi5jOjUzNTgKIG1zZ2lkICIiCiAiZG8gbm90IG11bmdlIHBhdGhuYW1lcyBhbmQgdXNlIE5VTHMgYXMgb3V0cHV0IGZpZWxkIHRlcm1pbmF0b3JzIGluIC0tcmF3IG9yICIKICItLW51bXN0YXQiCkBAIC0yNjg5LDg5ICsyNjk5LDg5IEBACiAia2jDtG5nIG11bmdlIHTDqm4gxJHGsOG7nW5nIGThuqtuIHbDoCBz4butIGThu6VuZyBOVUwgbMOgbSBi4buZIHBow6JuIHTDoWNoIHRyxrDhu51uZyDEkeG6p3UgcmEgIgogInRyb25nIC0tcmF3IGhheSAtLW51bXN0YXQiCiAKLSM6IGRpZmYuYzo1MzU4IGRpZmYuYzo1MzYxIGRpZmYuYzo1MzY0IGRpZmYuYzo1NDcwCisjOiBkaWZmLmM6NTM2MSBkaWZmLmM6NTM2NCBkaWZmLmM6NTM2NyBkaWZmLmM6NTQ3MwogbXNnaWQgIjxwcmVmaXg+IgogbXNnc3RyICI8dGnhu4FuX3Thu5E+IgogCi0jOiBkaWZmLmM6NTM1OQorIzogZGlmZi5jOjUzNjIKIG1zZ2lkICJzaG93IHRoZSBnaXZlbiBzb3VyY2UgcHJlZml4IGluc3RlYWQgb2YgXCJhL1wiIgogbXNnc3RyICJoaeG7g24gdGjhu4sgdGnhu4FuIHThu5Egbmd14buTbiDEkcOjIGNobyB0aGF5IGNobyBcImEvXCIiCiAKLSM6IGRpZmYuYzo1MzYyCisjOiBkaWZmLmM6NTM2NQogbXNnaWQgInNob3cgdGhlIGdpdmVuIGRlc3RpbmF0aW9uIHByZWZpeCBpbnN0ZWFkIG9mIFwiYi9cIiIKIG1zZ3N0ciAiaGnhu4NuIHRo4buLIHRp4buBbiB04buRIMSRw61jaCDEkcOjIGNobyB0aGF5IGNobyBcImIvXCIiCiAKLSM6IGRpZmYuYzo1MzY1CisjOiBkaWZmLmM6NTM2OAogbXNnaWQgInByZXBlbmQgYW4gYWRkaXRpb25hbCBwcmVmaXggdG8gZXZlcnkgbGluZSBvZiBvdXRwdXQiCiBtc2dzdHIgInRyZW8gdsOgbyB0csaw4bubYyBt4buZdCB0aeG7gW4gdOG7kSBi4buVIHN1bmcgY2hvIG3hu5dpIGTDsm5nIGvhur90IHh14bqldCIKIAotIzogZGlmZi5jOjUzNjgKKyM6IGRpZmYuYzo1MzcxCiBtc2dpZCAiZG8gbm90IHNob3cgYW55IHNvdXJjZSBvciBkZXN0aW5hdGlvbiBwcmVmaXgiCiBtc2dzdHIgIsSR4burbmcgaGnhu4NuIHRo4buLIGLhuqV0IGvhu7MgdGnhu4FuIHThu5Egbmd14buTbiBoYXkgxJHDrWNoIgogCi0jOiBkaWZmLmM6NTM3MQorIzogZGlmZi5jOjUzNzQKIG1zZ2lkICJzaG93IGNvbnRleHQgYmV0d2VlbiBkaWZmIGh1bmtzIHVwIHRvIHRoZSBzcGVjaWZpZWQgbnVtYmVyIG9mIGxpbmVzIgogbXNnc3RyICIiCiAiaGnhu4NuIHRo4buLIG5n4buvIGPhuqNuaCBnaeG7r2EgY8OhYyBraMO6YyBraMOhYyBiaeG7h3Qga2hpIMSR4bqhdCDEkeG6v24gc+G7kSBsxrDhu6NuZyBkw7JuZyDEkcOjIGNo4buJICIKICLEkeG7i25oIgogCi0jOiBkaWZmLmM6NTM3NSBkaWZmLmM6NTM4MCBkaWZmLmM6NTM4NQorIzogZGlmZi5jOjUzNzggZGlmZi5jOjUzODMgZGlmZi5jOjUzODgKIG1zZ2lkICI8Y2hhcj4iCiBtc2dzdHIgIjxrw71fdOG7sT4iCiAKLSM6IGRpZmYuYzo1Mzc2CisjOiBkaWZmLmM6NTM3OQogbXNnaWQgInNwZWNpZnkgdGhlIGNoYXJhY3RlciB0byBpbmRpY2F0ZSBhIG5ldyBsaW5lIGluc3RlYWQgb2YgJysnIgogbXNnc3RyICJjaOG7iSDEkeG7i25oIG3hu5l0IGvDvSB04buxIMSR4buDIGJp4buDdSB0aOG7iyBt4buZdCBkw7JuZyDEkcaw4bujYyB0aMOqbSBt4bubaSB0aGF5IGNobyDigJwr4oCdIgogCi0jOiBkaWZmLmM6NTM4MQorIzogZGlmZi5jOjUzODQKIG1zZ2lkICJzcGVjaWZ5IHRoZSBjaGFyYWN0ZXIgdG8gaW5kaWNhdGUgYW4gb2xkIGxpbmUgaW5zdGVhZCBvZiAnLSciCiBtc2dzdHIgImNo4buJIMSR4buLbmggbeG7mXQga8O9IHThu7EgxJHhu4MgYmnhu4N1IHRo4buLIG3hu5l0IGTDsm5nIMSRw6MgY8WpIHRoYXkgY2hvIOKAnC3igJ0iCiAKLSM6IGRpZmYuYzo1Mzg2CisjOiBkaWZmLmM6NTM4OQogbXNnaWQgInNwZWNpZnkgdGhlIGNoYXJhY3RlciB0byBpbmRpY2F0ZSBhIGNvbnRleHQgaW5zdGVhZCBvZiAnICciCiBtc2dzdHIgImNo4buJIMSR4buLbmggbeG7mXQga8O9IHThu7EgxJHhu4MgYmnhu4N1IHRo4buLIG3hu5l0IG5n4buvIGPhuqNuaCB0aGF5IGNobyDigJzigJ0iCiAKLSM6IGRpZmYuYzo1Mzg5CisjOiBkaWZmLmM6NTM5MgogbXNnaWQgIkRpZmYgcmVuYW1lIG9wdGlvbnMiCiBtc2dzdHIgIlTDuXkgY2jhu41uIGtow6FjIGJp4buHdCDEkeG7lWkgdMOqbiIKIAotIzogZGlmZi5jOjUzOTAKKyM6IGRpZmYuYzo1MzkzCiBtc2dpZCAiPG4+Wy88bT5dIgogbXNnc3RyICI8bj5bLzxtPl0iCiAKLSM6IGRpZmYuYzo1MzkxCisjOiBkaWZmLmM6NTM5NAogbXNnaWQgImJyZWFrIGNvbXBsZXRlIHJld3JpdGUgY2hhbmdlcyBpbnRvIHBhaXJzIG9mIGRlbGV0ZSBhbmQgY3JlYXRlIgogbXNnc3RyICJuZ+G6r3QgY8OhYyB0aGF5IMSR4buVaSBnaGkgbOG6oWkgaG/DoG4gdGhp4buHbiB0aMOgbmggY+G6t3AgY+G7p2EgeMOzYSB2w6AgdOG6oW8iCiAKLSM6IGRpZmYuYzo1Mzk1CisjOiBkaWZmLmM6NTM5OAogbXNnaWQgImRldGVjdCByZW5hbWVzIgogbXNnc3RyICJkw7IgdMOsbSBjw6FjIHTDqm4gdGhheSDEkeG7lWkiCiAKLSM6IGRpZmYuYzo1Mzk5CisjOiBkaWZmLmM6NTQwMgogbXNnaWQgIm9taXQgdGhlIHByZWltYWdlIGZvciBkZWxldGVzIgogbXNnc3RyICJi4buPIHF1YSBwcmVpbWFnZSAodGnhu4FuIOG6o25oPz8pIGNobyBjw6FjIHZp4buHYyB4w7NhIgogCi0jOiBkaWZmLmM6NTQwMgorIzogZGlmZi5jOjU0MDUKIG1zZ2lkICJkZXRlY3QgY29waWVzIgogbXNnc3RyICJkw7IgYuG6o24gc2FvIgogCi0jOiBkaWZmLmM6NTQwNgorIzogZGlmZi5jOjU0MDkKIG1zZ2lkICJ1c2UgdW5tb2RpZmllZCBmaWxlcyBhcyBzb3VyY2UgdG8gZmluZCBjb3BpZXMiCiBtc2dzdHIgImTDuW5nIGPDoWMgdOG6rXAgdGluIGtow7RuZyBi4buLIGNo4buJbmggc+G7rWEgbmjGsCBsw6Agbmd14buTbiDEkeG7gyB0w6xtIGPDoWMgYuG6o24gc2FvIgogCi0jOiBkaWZmLmM6NTQwOAorIzogZGlmZi5jOjU0MTEKIG1zZ2lkICJkaXNhYmxlIHJlbmFtZSBkZXRlY3Rpb24iCiBtc2dzdHIgInThuq90IGTDsiB0w6xtIMSR4buVaSB0w6puIgogCi0jOiBkaWZmLmM6NTQxMQorIzogZGlmZi5jOjU0MTQKIG1zZ2lkICJ1c2UgZW1wdHkgYmxvYnMgYXMgcmVuYW1lIHNvdXJjZSIKIG1zZ3N0ciAiZHVuZyBjw6FjIGJsb2IgdHLhu5FuZyBy4buRbmcgbmjGsCBsw6Agbmd14buTbiDEkeG7lWkgdMOqbiIKIAotIzogZGlmZi5jOjU0MTMKKyM6IGRpZmYuYzo1NDE2CiBtc2dpZCAiY29udGludWUgbGlzdGluZyB0aGUgaGlzdG9yeSBvZiBhIGZpbGUgYmV5b25kIHJlbmFtZXMiCiBtc2dzdHIgInRp4bq/cCB04bulYyBsaeG7h3Qga8OqIGzhu4tjaCBz4butIGPhu6dhIG3hu5l0IHThuq1wIHRpbiBuZ2/DoGkgxJHhu5VpIHTDqm4iCiAKLSM6IGRpZmYuYzo1NDE2CisjOiBkaWZmLmM6NTQxOQogbXNnaWQgIiIKICJwcmV2ZW50IHJlbmFtZS9jb3B5IGRldGVjdGlvbiBpZiB0aGUgbnVtYmVyIG9mIHJlbmFtZS9jb3B5IHRhcmdldHMgZXhjZWVkcyAiCiAiZ2l2ZW4gbGltaXQiCkBAIC0yNzc5LDE1NiArMjc4OSwxNTYgQEAKICJuZ8SDbiBj4bqjbiBkw7IgdMOsbSDEkeG7lWkgdMOqbi9i4bqjbiBzYW8gbuG6v3Ugc+G7kSBsxrDhu6NuZyBj4bunYSDEkcOtY2ggxJHhu5VpIHTDqm4vYuG6o24gc2FvIHbGsOG7o3QgIgogInF1w6EgZ2nhu5tpIGjhuqFuIMSRxrBhIHJhIgogCi0jOiBkaWZmLmM6NTQxOAorIzogZGlmZi5jOjU0MjEKIG1zZ2lkICJEaWZmIGFsZ29yaXRobSBvcHRpb25zIgogbXNnc3RyICJUw7l5IGNo4buNbiB0aHXhuq10IHRvw6FuIGtow6FjIGJp4buHdCIKIAotIzogZGlmZi5jOjU0MjAKKyM6IGRpZmYuYzo1NDIzCiBtc2dpZCAicHJvZHVjZSB0aGUgc21hbGxlc3QgcG9zc2libGUgZGlmZiIKIG1zZ3N0ciAic+G6o24gc2luaCBraMOhYyBiaeG7h3Qgw610IG5o4bqldCBjw7MgdGjhu4MiCiAKLSM6IGRpZmYuYzo1NDIzCisjOiBkaWZmLmM6NTQyNgogbXNnaWQgImlnbm9yZSB3aGl0ZXNwYWNlIHdoZW4gY29tcGFyaW5nIGxpbmVzIgogbXNnc3RyICJs4budIMSRaSBz4buxIHRoYXkgxJHhu5VpIGRvIGtob+G6o25nIHRy4bqvbmcgZ8OieSByYSBraGkgc28gc8OhbmggY8OhYyBkw7JuZyIKIAotIzogZGlmZi5jOjU0MjYKKyM6IGRpZmYuYzo1NDI5CiBtc2dpZCAiaWdub3JlIGNoYW5nZXMgaW4gYW1vdW50IG9mIHdoaXRlc3BhY2UiCiBtc2dzdHIgImzhu50gxJFpIHPhu7EgdGhheSDEkeG7lWkgZG8gc+G7kSBsxrDhu6NuZyBraG/huqNuZyB0cuG6r25nIGfDonkgcmEiCiAKLSM6IGRpZmYuYzo1NDI5CisjOiBkaWZmLmM6NTQzMgogbXNnaWQgImlnbm9yZSBjaGFuZ2VzIGluIHdoaXRlc3BhY2UgYXQgRU9MIgogbXNnc3RyICJs4budIMSRaSBz4buxIHRoYXkgxJHhu5VpIGRvIGtob+G6o25nIHRy4bqvbmcgZ8OieSByYSBraGkg4bufIGN14buRaSBkw7JuZyBFT0wiCiAKLSM6IGRpZmYuYzo1NDMyCisjOiBkaWZmLmM6NTQzNQogbXNnaWQgImlnbm9yZSBjYXJyaWVyLXJldHVybiBhdCB0aGUgZW5kIG9mIGxpbmUiCiBtc2dzdHIgImLhu48gcXVhIGvDvSB04buxIHbhu4EgxJHhuqd1IGTDsm5nIHThuqFpIGN14buRaSBkw7JuZyIKIAotIzogZGlmZi5jOjU0MzUKKyM6IGRpZmYuYzo1NDM4CiBtc2dpZCAiaWdub3JlIGNoYW5nZXMgd2hvc2UgbGluZXMgYXJlIGFsbCBibGFuayIKIG1zZ3N0ciAiYuG7jyBxdWEgY8OhYyB0aGF5IMSR4buVaSBjaG8gdG/DoG4gYuG7mSBjw6FjIGTDsm5nIGzDoCB0cuG7kW5nIgogCi0jOiBkaWZmLmM6NTQzOAorIzogZGlmZi5jOjU0NDEKIG1zZ2lkICJoZXVyaXN0aWMgdG8gc2hpZnQgZGlmZiBodW5rIGJvdW5kYXJpZXMgZm9yIGVhc3kgcmVhZGluZyIKIG1zZ3N0ciAiaGV1cmlzdGljIMSR4buDIGThu4tjaCBo4bqhbiBiacOqbiBj4bunYSBraOG7kWkga2jDoWMgYmnhu4d0IGNobyBk4buFIMSR4buNYyIKIAotIzogZGlmZi5jOjU0NDEKKyM6IGRpZmYuYzo1NDQ0CiBtc2dpZCAiZ2VuZXJhdGUgZGlmZiB1c2luZyB0aGUgXCJwYXRpZW5jZSBkaWZmXCIgYWxnb3JpdGhtIgogbXNnc3RyICJ04bqhbyBraMOhYyBiaeG7h3Qgc+G7rSBkdW5nIHRodeG6rXQgdG/DoW4gXCJwYXRpZW5jZSBkaWZmXCIiCiAKLSM6IGRpZmYuYzo1NDQ1CisjOiBkaWZmLmM6NTQ0OAogbXNnaWQgImdlbmVyYXRlIGRpZmYgdXNpbmcgdGhlIFwiaGlzdG9ncmFtIGRpZmZcIiBhbGdvcml0aG0iCiBtc2dzdHIgInThuqFvIGtow6FjIGJp4buHdCBz4butIGR1bmcgdGh14bqtdCB0b8OhbiBcImhpc3RvZ3JhbSBkaWZmXCIiCiAKLSM6IGRpZmYuYzo1NDQ3CisjOiBkaWZmLmM6NTQ1MAogbXNnaWQgIjxhbGdvcml0aG0+IgogbXNnc3RyICI8dGh14bqtdCB0b8Ohbj4iCiAKLSM6IGRpZmYuYzo1NDQ4CisjOiBkaWZmLmM6NTQ1MQogbXNnaWQgImNob29zZSBhIGRpZmYgYWxnb3JpdGhtIgogbXNnc3RyICJjaOG7jW4gbeG7mXQgdGh14bqtdCB0b8OhbiBraMOhYyBiaeG7h3QiCiAKLSM6IGRpZmYuYzo1NDUwCisjOiBkaWZmLmM6NTQ1MwogbXNnaWQgIjx0ZXh0PiIKIG1zZ3N0ciAiPHbEg24gYuG6o24+IgogCi0jOiBkaWZmLmM6NTQ1MQorIzogZGlmZi5jOjU0NTQKIG1zZ2lkICJnZW5lcmF0ZSBkaWZmIHVzaW5nIHRoZSBcImFuY2hvcmVkIGRpZmZcIiBhbGdvcml0aG0iCiBtc2dzdHIgInThuqFvIGtow6FjIGJp4buHdCBz4butIGR1bmcgdGh14bqtdCB0b8OhbiBcImFuY2hvcmVkIGRpZmZcIiIKIAotIzogZGlmZi5jOjU0NTMgZGlmZi5jOjU0NjIgZGlmZi5jOjU0NjUKKyM6IGRpZmYuYzo1NDU2IGRpZmYuYzo1NDY1IGRpZmYuYzo1NDY4CiBtc2dpZCAiPG1vZGU+IgogbXNnc3RyICI8Y2jhur8gxJHhu5k+IgogCi0jOiBkaWZmLmM6NTQ1NAorIzogZGlmZi5jOjU0NTcKIG1zZ2lkICJzaG93IHdvcmQgZGlmZiwgdXNpbmcgPG1vZGU+IHRvIGRlbGltaXQgY2hhbmdlZCB3b3JkcyIKIG1zZ3N0ciAiIgogImhp4buDbiB0aOG7iyBraMOhYyBiaeG7h3QgdOG7qywgc+G7rSBkdW5nIDxjaOG6vyDEkeG7mT4gxJHhu4MgYuG7jyBnaeG7m2kgaOG6oW4gY8OhYyB04burIGLhu4sgdGhheSDEkeG7lWkiCiAKLSM6IGRpZmYuYzo1NDU2IGRpZmYuYzo1NDU5IGRpZmYuYzo1NTA0CisjOiBkaWZmLmM6NTQ1OSBkaWZmLmM6NTQ2MiBkaWZmLmM6NTUwNwogbXNnaWQgIjxyZWdleD4iCiBtc2dzdHIgIjxyZWdleD4iCiAKLSM6IGRpZmYuYzo1NDU3CisjOiBkaWZmLmM6NTQ2MAogbXNnaWQgInVzZSA8cmVnZXg+IHRvIGRlY2lkZSB3aGF0IGEgd29yZCBpcyIKIG1zZ3N0ciAiZMO5bmcgPHJlZ2V4PiDEkeG7gyBxdXnhur90IMSR4buLbmggdOG7qyBsw6AgY8OhaSBnw6wiCiAKLSM6IGRpZmYuYzo1NDYwCisjOiBkaWZmLmM6NTQ2MwogbXNnaWQgImVxdWl2YWxlbnQgdG8gLS13b3JkLWRpZmY9Y29sb3IgLS13b3JkLWRpZmYtcmVnZXg9PHJlZ2V4PiIKIG1zZ3N0ciAidMawxqFuZyDEkcawxqFuZyB24bubaSAtLXdvcmQtZGlmZj1jb2xvciAtLXdvcmQtZGlmZi1yZWdleD08cmVnZXg+IgogCi0jOiBkaWZmLmM6NTQ2MworIzogZGlmZi5jOjU0NjYKIG1zZ2lkICJtb3ZlZCBsaW5lcyBvZiBjb2RlIGFyZSBjb2xvcmVkIGRpZmZlcmVudGx5IgogbXNnc3RyICJjw6FjIGTDsm5nIGRpIGNodXnhu4NuIGPhu6dhIG3DoyBtw6AgxJHGsOG7o2MgdMO0IG3DoHUga2jDoWMgbmhhdSIKIAotIzogZGlmZi5jOjU0NjYKKyM6IGRpZmYuYzo1NDY5CiBtc2dpZCAiaG93IHdoaXRlIHNwYWNlcyBhcmUgaWdub3JlZCBpbiAtLWNvbG9yLW1vdmVkIgogbXNnc3RyICJi4buPIHF1YSBraG/huqNuZyB0cuG6r25nIG5oxrAgdGjhur8gbsOgbyB0cm9uZyAtLWNvbG9yLW1vdmVkIgogCi0jOiBkaWZmLmM6NTQ2OQorIzogZGlmZi5jOjU0NzIKIG1zZ2lkICJPdGhlciBkaWZmIG9wdGlvbnMiCiBtc2dzdHIgIkPDoWMgdMO5eSBjaOG7jW4ga2jDoWMgYmnhu4d0IGtow6FjIgogCi0jOiBkaWZmLmM6NTQ3MQorIzogZGlmZi5jOjU0NzQKIG1zZ2lkICJ3aGVuIHJ1biBmcm9tIHN1YmRpciwgZXhjbHVkZSBjaGFuZ2VzIG91dHNpZGUgYW5kIHNob3cgcmVsYXRpdmUgcGF0aHMiCiBtc2dzdHIgIiIKICJraGkgY2jhuqF5IHThu6sgdGjGsCBt4bulYyBjb24sIHRo4buxIHRoaSBjw6FjIHRoYXkgxJHhu5VpIGLDqm4gbmdvw6BpIHbDoCBoaeG7g24gdGjhu4sgY8OhYyAiCiAixJHGsOG7nW5nIGThuqtuIGxpw6puIHF1YW4iCiAKLSM6IGRpZmYuYzo1NDc1CisjOiBkaWZmLmM6NTQ3OAogbXNnaWQgInRyZWF0IGFsbCBmaWxlcyBhcyB0ZXh0IgogbXNnc3RyICJjb2kgbeG7jWkgdOG6rXAgdGluIGzDoCBk4bqhbmcgdsSDbiBi4bqjbiB0aMaw4budbmciCiAKLSM6IGRpZmYuYzo1NDc3CisjOiBkaWZmLmM6NTQ4MAogbXNnaWQgInN3YXAgdHdvIGlucHV0cywgcmV2ZXJzZSB0aGUgZGlmZiIKIG1zZ3N0ciAidHLDoW8gxJHhu5VpIGhhaSDEkeG6p3UgdsOgbywgxJHhuqNvIG5nxrDhu6NjIGtow6FjIGJp4buHdCIKIAotIzogZGlmZi5jOjU0NzkKKyM6IGRpZmYuYzo1NDgyCiBtc2dpZCAiZXhpdCB3aXRoIDEgaWYgdGhlcmUgd2VyZSBkaWZmZXJlbmNlcywgMCBvdGhlcndpc2UiCiBtc2dzdHIgInRob8OhdCB24bubaSBtw6MgMSBu4bq/dSBraMO0bmcgY8OzIGtow6FjIGJp4buHdCBnw6wsIDAgbuG6v3UgbmfGsOG7o2MgbOG6oWkiCiAKLSM6IGRpZmYuYzo1NDgxCisjOiBkaWZmLmM6NTQ4NAogbXNnaWQgImRpc2FibGUgYWxsIG91dHB1dCBvZiB0aGUgcHJvZ3JhbSIKIG1zZ3N0ciAidOG6r3QgbeG7jWkga+G6v3QgeHXhuqV0IGPhu6dhIGNoxrDGoW5nIHRyw6xuaCIKIAotIzogZGlmZi5jOjU0ODMKKyM6IGRpZmYuYzo1NDg2CiBtc2dpZCAiYWxsb3cgYW4gZXh0ZXJuYWwgZGlmZiBoZWxwZXIgdG8gYmUgZXhlY3V0ZWQiCiBtc2dzdHIgImNobyBwaMOpcCBt4buZIGLhu5kgaOG7lyB0cuG7oyB4deG6pXQga2jDoWMgYmnhu4d0IOG7nyBiw6puIG5nb8OgaSDEkcaw4bujYyBwaMOpcCB0aOG7sWMgdGhpIgogCi0jOiBkaWZmLmM6NTQ4NQorIzogZGlmZi5jOjU0ODgKIG1zZ2lkICJydW4gZXh0ZXJuYWwgdGV4dCBjb252ZXJzaW9uIGZpbHRlcnMgd2hlbiBjb21wYXJpbmcgYmluYXJ5IGZpbGVzIgogbXNnc3RyICIiCiAiY2jhuqF5IGPDoWMgYuG7mSBs4buNYyB2xINuIGLhuqNuIHRow7RuZyB0aMaw4budbmcgYsOqbiBuZ2/DoGkga2hpIHNvIHPDoW5oIGPDoWMgdOG6rXAgdGluIG5o4buLICIKICJwaMOibiIKIAotIzogZGlmZi5jOjU0ODcKKyM6IGRpZmYuYzo1NDkwCiBtc2dpZCAiPHdoZW4+IgogbXNnc3RyICI8a2hpPiIKIAotIzogZGlmZi5jOjU0ODgKKyM6IGRpZmYuYzo1NDkxCiBtc2dpZCAiaWdub3JlIGNoYW5nZXMgdG8gc3VibW9kdWxlcyBpbiB0aGUgZGlmZiBnZW5lcmF0aW9uIgogbXNnc3RyICJi4buPIHF1YSBjw6FjIHRoYXkgxJHhu5VpIHRyb25nIG3DtC3EkXVuLWNvbiB0cm9uZyBraGkgdOG6oW8ga2jDoWMgYmnhu4d0IgogCi0jOiBkaWZmLmM6NTQ5MQorIzogZGlmZi5jOjU0OTQKIG1zZ2lkICI8Zm9ybWF0PiIKIG1zZ3N0ciAiPMSR4buLbmggZOG6oW5nPiIKIAotIzogZGlmZi5jOjU0OTIKKyM6IGRpZmYuYzo1NDk1CiBtc2dpZCAic3BlY2lmeSBob3cgZGlmZmVyZW5jZXMgaW4gc3VibW9kdWxlcyBhcmUgc2hvd24iCiBtc2dzdHIgImNoaSDEkeG7i25oIGtow6FjIGJp4buHdCBiYW8gbmhpw6p1IHRyb25nIGPDoWMgbcO0IMSRdW4gY29uIMSRxrDhu6NjIGhp4buDbiB0aOG7iyIKIAotIzogZGlmZi5jOjU0OTYKKyM6IGRpZmYuYzo1NDk5CiBtc2dpZCAiaGlkZSAnZ2l0IGFkZCAtTicgZW50cmllcyBmcm9tIHRoZSBpbmRleCIKIG1zZ3N0ciAi4bqpbiBjw6FjIG3hu6VjIOKAnGdpdCBhZGQgLU7igJ0gdOG7qyBi4bqjbmcgbeG7pWMgbOG7pWMiCiAKLSM6IGRpZmYuYzo1NDk5CisjOiBkaWZmLmM6NTUwMgogbXNnaWQgInRyZWF0ICdnaXQgYWRkIC1OJyBlbnRyaWVzIGFzIHJlYWwgaW4gdGhlIGluZGV4IgogbXNnc3RyICJjb2kgY8OhYyBt4bulYyDigJxnaXQgYWRkIC1O4oCdIG5oxrAgbMOgIGPDsyB0aOG6rXQgdHJvbmcgYuG6o25nIG3hu6VjIGzhu6VjIgogCi0jOiBkaWZmLmM6NTUwMQorIzogZGlmZi5jOjU1MDQKIG1zZ2lkICI8c3RyaW5nPiIKIG1zZ3N0ciAiPGNodeG7l2k+IgogCi0jOiBkaWZmLmM6NTUwMgorIzogZGlmZi5jOjU1MDUKIG1zZ2lkICIiCiAibG9vayBmb3IgZGlmZmVyZW5jZXMgdGhhdCBjaGFuZ2UgdGhlIG51bWJlciBvZiBvY2N1cnJlbmNlcyBvZiB0aGUgc3BlY2lmaWVkICIKICJzdHJpbmciCkBAIC0yOTM2LDcgKzI5NDYsNyBAQAogInTDrG0gY8OhYyBraMOhYyBiaeG7h3QgY8OhaSBtw6AgdGhheSDEkeG7lWkgc+G7kSBsxrDhu6NuZyB44bqjeSByYSBj4bunYSBjw6FjIHBow6F0IHNpbmggY+G7p2EgIgogImNodeG7l2kgxJHGsOG7o2MgY2jhu4kgcmEiCiAKLSM6IGRpZmYuYzo1NTA1CisjOiBkaWZmLmM6NTUwOAogbXNnaWQgIiIKICJsb29rIGZvciBkaWZmZXJlbmNlcyB0aGF0IGNoYW5nZSB0aGUgbnVtYmVyIG9mIG9jY3VycmVuY2VzIG9mIHRoZSBzcGVjaWZpZWQgIgogInJlZ2V4IgpAQCAtMjk0NCwyMyArMjk1NCwyMyBAQAogInTDrG0gY8OhYyBraMOhYyBiaeG7h3QgY8OhaSBtw6AgdGhheSDEkeG7lWkgc+G7kSBsxrDhu6NuZyB44bqjeSByYSBj4bunYSBjw6FjIHBow6F0IHNpbmggY+G7p2EgYmnhu4N1ICIKICJ0aOG7qWMgY2jDrW5oIHF1eSDEkcaw4bujYyBjaOG7iSByYSIKIAotIzogZGlmZi5jOjU1MDgKKyM6IGRpZmYuYzo1NTExCiBtc2dpZCAic2hvdyBhbGwgY2hhbmdlcyBpbiB0aGUgY2hhbmdlc2V0IHdpdGggLVMgb3IgLUciCiBtc2dzdHIgImhp4buDbiB0aOG7iyB04bqldCBj4bqjIGPDoWMgdGhheSDEkeG7lWkgdHJvbmcgbeG7mXQgYuG7mSBjw6FjIHRoYXkgxJHhu5VpIHbhu5tpIC1TIGhheSAtRyIKIAotIzogZGlmZi5jOjU1MTEKKyM6IGRpZmYuYzo1NTE0CiBtc2dpZCAidHJlYXQgPHN0cmluZz4gaW4gLVMgYXMgZXh0ZW5kZWQgUE9TSVggcmVndWxhciBleHByZXNzaW9uIgogbXNnc3RyICJjb2kgPGNodeG7l2k+IHRyb25nIC1TIG5oxrAgbMOgIGJp4buDdSB0aOG7qWMgY2jDrW5oIHF1aSBQT1NJWCBjw7MgbeG7nyBy4buZbmciCiAKLSM6IGRpZmYuYzo1NTE0CisjOiBkaWZmLmM6NTUxNwogbXNnaWQgImNvbnRyb2wgdGhlIG9yZGVyIGluIHdoaWNoIGZpbGVzIGFwcGVhciBpbiB0aGUgb3V0cHV0IgogbXNnc3RyICLEkWnhu4F1IGtoaeG7g24gdGjhu6kgdOG7sSB4dcOhdCBoaeG7h24gY8OhYyB04bqtcCB0aW4gdHJvbmcga+G6v3QgeHXhuqV0IgogCi0jOiBkaWZmLmM6NTUxNQorIzogZGlmZi5jOjU1MTgKIG1zZ2lkICI8b2JqZWN0LWlkPiIKIG1zZ3N0ciAiPG3Doy1z4buRLcSR4buRaS10xrDhu6NuZz4iCiAKLSM6IGRpZmYuYzo1NTE2CisjOiBkaWZmLmM6NTUxOQogbXNnaWQgIiIKICJsb29rIGZvciBkaWZmZXJlbmNlcyB0aGF0IGNoYW5nZSB0aGUgbnVtYmVyIG9mIG9jY3VycmVuY2VzIG9mIHRoZSBzcGVjaWZpZWQgIgogIm9iamVjdCIKQEAgLTI5NjgsMzMgKzI5NzgsMzMgQEAKICJ0w6xtIGPDoWMga2jDoWMgYmnhu4d0IGPDoWkgbcOgIHRoYXkgxJHhu5VpIHPhu5EgbMaw4bujbmcgeOG6o3kgcmEgY+G7p2EgY8OhYyBwaMOhdCBzaW5oIGPhu6dhIMSR4buRaSAiCiAidMaw4bujbmcgxJHGsOG7o2MgY2jhu4kgcmEiCiAKLSM6IGRpZmYuYzo1NTE4CisjOiBkaWZmLmM6NTUyMQogbXNnaWQgIlsoQXxDfER8TXxSfFR8VXxYfEIpLi4uWypdXSIKIG1zZ3N0ciAiWyhBfEN8RHxNfFJ8VHxVfFh8QinigKZbKl1dIgogCi0jOiBkaWZmLmM6NTUxOQorIzogZGlmZi5jOjU1MjIKIG1zZ2lkICJzZWxlY3QgZmlsZXMgYnkgZGlmZiB0eXBlIgogbXNnc3RyICJjaOG7jW4gY8OhYyB04bqtcCB0aW4gdGhlbyBraeG7g3Uga2jDoWMgYmnhu4d0IgogCi0jOiBkaWZmLmM6NTUyMQorIzogZGlmZi5jOjU1MjQKIG1zZ2lkICI8ZmlsZT4iCiBtc2dzdHIgIjx04bqtcF90aW4+IgogCi0jOiBkaWZmLmM6NTUyMgorIzogZGlmZi5jOjU1MjUKIG1zZ2lkICJPdXRwdXQgdG8gYSBzcGVjaWZpYyBmaWxlIgogbXNnc3RyICJYdeG6pXQgcmEgbeG7mXQgdOG6rXAgdGluIGPhu6UgdGjhu4MiCiAKLSM6IGRpZmYuYzo2MTc3CisjOiBkaWZmLmM6NjE4MAogbXNnaWQgImluZXhhY3QgcmVuYW1lIGRldGVjdGlvbiB3YXMgc2tpcHBlZCBkdWUgdG8gdG9vIG1hbnkgZmlsZXMuIgogbXNnc3RyICIiCiAibmjhuq1uIHRo4bqleSDEkeG7lWkgdMOqbiBraMO0bmcgY2jDrW5oIHjDoWMgxJHDoyBi4buLIGLhu48gcXVhIGLhu59pIGPDsyBxdcOhIG5oaeG7gXUgdOG6rXAgdGluLiIKIAotIzogZGlmZi5jOjYxODAKKyM6IGRpZmYuYzo2MTgzCiBtc2dpZCAib25seSBmb3VuZCBjb3BpZXMgZnJvbSBtb2RpZmllZCBwYXRocyBkdWUgdG8gdG9vIG1hbnkgZmlsZXMuIgogbXNnc3RyICIiCiAiY2jhu4kgdMOsbSB0aOG6pXkgY8OhYyBi4bqjbiBzYW8gdOG7qyDEkcaw4budbmcgZOG6q24gxJHDoyBz4butYSDEkeG7lWkgYuG7n2kgdsOsIGPDsyBxdcOhIG5oaeG7gXUgdOG6rXAgdGluLiIKIAotIzogZGlmZi5jOjYxODMKKyM6IGRpZmYuYzo2MTg2CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJ5b3UgbWF5IHdhbnQgdG8gc2V0IHlvdXIgJXMgdmFyaWFibGUgdG8gYXQgbGVhc3QgJWQgYW5kIHJldHJ5IHRoZSBjb21tYW5kLiIKQEAgLTMwMDIsNDAgKzMwMTIsNDAgQEAKICJi4bqhbiBjw7MgbOG6vSBtdeG7kW4gxJHhurd0IGJp4bq/biAlcyBj4bunYSBi4bqhbiB0aMOgbmggw610IG5o4bqldCBsw6AgJWQgdsOgIHRo4butIGzhuqFpIGzhu4duaCBs4bqnbiAiCiAibuG7r2EuIgogCi0jOiBkaXIuYzo1MzcKKyM6IGRpci5jOjU0OQogIywgYy1mb3JtYXQKIG1zZ2lkICJwYXRoc3BlYyAnJXMnIGRpZCBub3QgbWF0Y2ggYW55IGZpbGUocykga25vd24gdG8gZ2l0IgogbXNnc3RyICLEkeG6t2MgdOG6oyDEkcaw4budbmcgZOG6q24g4oCcJXPigJ0ga2jDtG5nIGto4bubcCB24bubaSBi4bqldCBr4buzIHThuq1wIHRpbiBuw6BvIG3DoCBnaXQgYmnhur90IgogCi0jOiBkaXIuYzo5MjYKKyM6IGRpci5jOjkzOAogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgdXNlICVzIGFzIGFuIGV4Y2x1ZGUgZmlsZSIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIGTDuW5nICVzIG5oxrAgbMOgIG3hu5l0IHThuq1wIHRpbiBsb+G6oWkgdHLhu6siCiAKLSM6IGRpci5jOjE4NDMKKyM6IGRpci5jOjE4NzcKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IG9wZW4gZGlyZWN0b3J5ICclcyciCiBtc2dzdHIgImtow7RuZyB0aOG7gyBt4bufIHRoxrAgbeG7pWMg4oCcJXPigJ0iCiAKLSM6IGRpci5jOjIwODUKKyM6IGRpci5jOjIxMjgKIG1zZ2lkICJmYWlsZWQgdG8gZ2V0IGtlcm5lbCBuYW1lIGFuZCBpbmZvcm1hdGlvbiIKIG1zZ3N0ciAiZ+G6t3AgbOG7l2kga2hpIGzhuqV5IHTDqm4gdsOgIHRow7RuZyB0aW4gY+G7p2EgbmjDom4iCiAKLSM6IGRpci5jOjIyMDkKKyM6IGRpci5jOjIyNTIKIG1zZ2lkICJ1bnRyYWNrZWQgY2FjaGUgaXMgZGlzYWJsZWQgb24gdGhpcyBzeXN0ZW0gb3IgbG9jYXRpb24iCiBtc2dzdHIgImLhu5kgbmjhu5sgdOG6oW0ga2jDtG5nIHRoZW8gduG6v3QgYuG7iyB04bqvdCB0csOqbiBo4buHIHRo4buRbmcgaGF5IHbhu4sgdHLDrSBuw6B5IgogCi0jOiBkaXIuYzozMDEzCisjOiBkaXIuYzozMDU2CiAjLCBjLWZvcm1hdAogbXNnaWQgImluZGV4IGZpbGUgY29ycnVwdCBpbiByZXBvICVzIgogbXNnc3RyICJ04bqtcCB0aW4gZ2hpIGLhuqNuZyBt4bulYyBs4bulYyBi4buLIGjhu49uZyB0cm9uZyBraG8gJXMiCiAKLSM6IGRpci5jOjMwNTggZGlyLmM6MzA2MworIzogZGlyLmM6MzEwMSBkaXIuYzozMTA2CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBjcmVhdGUgZGlyZWN0b3JpZXMgZm9yICVzIgogbXNnc3RyICJraMO0bmcgdGjhu4MgdOG6oW8gdGjGsCBt4bulYyBjaG8gJXMiCiAKLSM6IGRpci5jOjMwOTIKKyM6IGRpci5jOjMxMzUKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IG1pZ3JhdGUgZ2l0IGRpcmVjdG9yeSBmcm9tICclcycgdG8gJyVzJyIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIGRpIGPGsCB0aMawIG3hu6VjIGdpdCB04burIOKAnCVz4oCdIHNhbmcg4oCcJXPigJ0iCkBAIC0zMDU0LDEyICszMDY0LDEyIEBACiBtc2dpZCAiY291bGQgbm90IHN0YXQgZmlsZSAnJXMnIgogbXNnc3RyICJraMO0bmcgdGjhu4MgbOG6pXkgdGjhu5FuZyBrw6ogdOG6rXAgdGluIOKAnCVz4oCdIgogCi0jOiBlbnZpcm9ubWVudC5jOjE1MAorIzogZW52aXJvbm1lbnQuYzoxNDgKICMsIGMtZm9ybWF0CiBtc2dpZCAiYmFkIGdpdCBuYW1lc3BhY2UgcGF0aCBcIiVzXCIiCiBtc2dzdHIgIsSRxrDhu51uZyBk4bqrbiBraMO0bmcgZ2lhbiB0w6puIGdpdCBcIiVzXCIgc2FpIgogCi0jOiBlbnZpcm9ubWVudC5jOjMzMgorIzogZW52aXJvbm1lbnQuYzozMzAKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHNldCBHSVRfRElSIHRvICclcyciCiBtc2dzdHIgImtow7RuZyB0aOG7gyDEkeG6t3QgR0lUX0RJUiB0aMOgbmgg4oCcJXPigJ0iCkBAIC0zMDY5LDE1OCArMzA3OSwxNTQgQEAKIG1zZ2lkICJ0b28gbWFueSBhcmdzIHRvIHJ1biAlcyIKIG1zZ3N0ciAicXXDoSBuaGnhu4F1IHRoYW0gc+G7kSDEkeG7gyBjaOG6oXkgJXMiCiAKLSM6IGZldGNoLW9iamVjdC5jOjE3Ci1tc2dpZCAiUmVtb3RlIHdpdGggbm8gVVJMIgotbXNnc3RyICJNw6F5IGNo4bunIGtow7RuZyBjw7MgxJHhu4thIGNo4buJIFVSTCIKLQotIzogZmV0Y2gtcGFjay5jOjE1MQorIzogZmV0Y2gtcGFjay5jOjE1MAogbXNnaWQgImdpdCBmZXRjaC1wYWNrOiBleHBlY3RlZCBzaGFsbG93IGxpc3QiCiBtc2dzdHIgImdpdCBmZXRjaC1wYWNrOiBj4bqnbiBkYW5oIHPDoWNoIHNoYWxsb3ciCiAKLSM6IGZldGNoLXBhY2suYzoxNTQKKyM6IGZldGNoLXBhY2suYzoxNTMKIG1zZ2lkICJnaXQgZmV0Y2gtcGFjazogZXhwZWN0ZWQgYSBmbHVzaCBwYWNrZXQgYWZ0ZXIgc2hhbGxvdyBsaXN0IgogbXNnc3RyICJnaXQgZmV0Y2gtcGFjazogY+G6p24gbeG7mXQgZ8OzaSDEkeG6qXkgc2F1IGRhbmggc8OhY2ggc2hhbGxvdyIKIAotIzogZmV0Y2gtcGFjay5jOjE2NQorIzogZmV0Y2gtcGFjay5jOjE2NAogbXNnaWQgImdpdCBmZXRjaC1wYWNrOiBleHBlY3RlZCBBQ0svTkFLLCBnb3QgYSBmbHVzaCBwYWNrZXQiCiBtc2dzdHIgImdpdCBmZXRjaC1wYWNrOiBj4bqnbiBBQ0svTkFLLCBuaMawbmcgbOG6oWkgbmjhuq1uIMSRxrDhu6NjIG3hu5l0IGfDs2kgZmx1c2giCiAKLSM6IGZldGNoLXBhY2suYzoxODUKKyM6IGZldGNoLXBhY2suYzoxODQKICMsIGMtZm9ybWF0CiBtc2dpZCAiZ2l0IGZldGNoLXBhY2s6IGV4cGVjdGVkIEFDSy9OQUssIGdvdCAnJXMnIgogbXNnc3RyICJnaXQgZmV0Y2gtcGFjazogY+G6p24gQUNLL05BSywgbmjGsG5nIGzhuqFpIG5o4bqtbiDEkcaw4bujYyDigJwlc+KAnSIKIAotIzogZmV0Y2gtcGFjay5jOjE5NgorIzogZmV0Y2gtcGFjay5jOjE5NQogbXNnaWQgInVuYWJsZSB0byB3cml0ZSB0byByZW1vdGUiCiBtc2dzdHIgImtow7RuZyB0aOG7gyBnaGkgbMOqbiBtw6F5IHBo4bulYyB24bulIgogCi0jOiBmZXRjaC1wYWNrLmM6MjU4CisjOiBmZXRjaC1wYWNrLmM6MjU3CiBtc2dpZCAiLS1zdGF0ZWxlc3MtcnBjIHJlcXVpcmVzIG11bHRpX2Fja19kZXRhaWxlZCIKIG1zZ3N0ciAiLS1zdGF0ZWxlc3MtcnBjIGPhuqduIG11bHRpX2Fja19kZXRhaWxlZCIKIAotIzogZmV0Y2gtcGFjay5jOjM2MCBmZXRjaC1wYWNrLmM6MTI4NAorIzogZmV0Y2gtcGFjay5jOjM1NiBmZXRjaC1wYWNrLmM6MTI4MAogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIHNoYWxsb3cgbGluZTogJXMiCiBtc2dzdHIgImTDsm5nIHNoYWxsb3cga2jDtG5nIGjhu6NwIGzhu4c6ICVzIgogCi0jOiBmZXRjaC1wYWNrLmM6MzY2IGZldGNoLXBhY2suYzoxMjkwCisjOiBmZXRjaC1wYWNrLmM6MzYyIGZldGNoLXBhY2suYzoxMjg2CiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgdW5zaGFsbG93IGxpbmU6ICVzIgogbXNnc3RyICJkw7JuZyB1bnNoYWxsb3cga2jDtG5nIGjhu6NwIGzhu4c6ICVzIgogCi0jOiBmZXRjaC1wYWNrLmM6MzY4IGZldGNoLXBhY2suYzoxMjkyCisjOiBmZXRjaC1wYWNrLmM6MzY0IGZldGNoLXBhY2suYzoxMjg4CiAjLCBjLWZvcm1hdAogbXNnaWQgIm9iamVjdCBub3QgZm91bmQ6ICVzIgogbXNnc3RyICJraMO0bmcgdMOsbSB0aOG6pXkgxJHhu5FpIHTGsOG7o25nOiAlcyIKIAotIzogZmV0Y2gtcGFjay5jOjM3MSBmZXRjaC1wYWNrLmM6MTI5NQorIzogZmV0Y2gtcGFjay5jOjM2NyBmZXRjaC1wYWNrLmM6MTI5MQogIywgYy1mb3JtYXQKIG1zZ2lkICJlcnJvciBpbiBvYmplY3Q6ICVzIgogbXNnc3RyICJs4buXaSB0cm9uZyDEkeG7kWkgdMaw4bujbmc6ICVzIgogCi0jOiBmZXRjaC1wYWNrLmM6MzczIGZldGNoLXBhY2suYzoxMjk3CisjOiBmZXRjaC1wYWNrLmM6MzY5IGZldGNoLXBhY2suYzoxMjkzCiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vIHNoYWxsb3cgZm91bmQ6ICVzIgogbXNnc3RyICJraMO0bmcgdMOsbSBzaGFsbG93IG7DoG86ICVzIgogCi0jOiBmZXRjaC1wYWNrLmM6Mzc2IGZldGNoLXBhY2suYzoxMzAxCisjOiBmZXRjaC1wYWNrLmM6MzcyIGZldGNoLXBhY2suYzoxMjk3CiAjLCBjLWZvcm1hdAogbXNnaWQgImV4cGVjdGVkIHNoYWxsb3cvdW5zaGFsbG93LCBnb3QgJXMiCiBtc2dzdHIgImPhuqduIHNoYWxsb3cvdW5zaGFsbG93LCBuaMawbmcgbOG6oWkgbmjhuq1uIMSRxrDhu6NjICVzIgogCi0jOiBmZXRjaC1wYWNrLmM6NDE3CisjOiBmZXRjaC1wYWNrLmM6NDE0CiAjLCBjLWZvcm1hdAogbXNnaWQgImdvdCAlcyAlZCAlcyIKIG1zZ3N0ciAibmjhuq1uICVzICVkIC0gJXMiCiAKLSM6IGZldGNoLXBhY2suYzo0MzQKKyM6IGZldGNoLXBhY2suYzo0MzEKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBjb21taXQgJXMiCiBtc2dzdHIgImzhuqduIGNodXnhu4NuIGdpYW8gJXMga2jDtG5nIGjhu6NwIGzhu4ciCiAKLSM6IGZldGNoLXBhY2suYzo0NjUKKyM6IGZldGNoLXBhY2suYzo0NjIKIG1zZ2lkICJnaXZpbmcgdXAiCiBtc2dzdHIgImNo4buLdSB0aHVhIgogCi0jOiBmZXRjaC1wYWNrLmM6NDc3IHByb2dyZXNzLmM6Mjc3CisjOiBmZXRjaC1wYWNrLmM6NDc1IHByb2dyZXNzLmM6MzEyCiBtc2dpZCAiZG9uZSIKIG1zZ3N0ciAieG9uZyIKIAotIzogZmV0Y2gtcGFjay5jOjQ4OQorIzogZmV0Y2gtcGFjay5jOjQ4NwogIywgYy1mb3JtYXQKIG1zZ2lkICJnb3QgJXMgKCVkKSAlcyIKIG1zZ3N0ciAibmjhuq1uICVzICglZCkgJXMiCiAKLSM6IGZldGNoLXBhY2suYzo1MzUKKyM6IGZldGNoLXBhY2suYzo1MzMKICMsIGMtZm9ybWF0CiBtc2dpZCAiTWFya2luZyAlcyBhcyBjb21wbGV0ZSIKIG1zZ3N0ciAixJDDoW5oIGThuqV1ICVzIGzDoCDEkcOjIGhvw6BuIHRow6BuaCIKIAotIzogZmV0Y2gtcGFjay5jOjc0NAorIzogZmV0Y2gtcGFjay5jOjc0MgogIywgYy1mb3JtYXQKIG1zZ2lkICJhbHJlYWR5IGhhdmUgJXMgKCVzKSIKIG1zZ3N0ciAixJHDoyBz4bq1biBjw7MgJXMgKCVzKSIKIAotIzogZmV0Y2gtcGFjay5jOjc4MworIzogZmV0Y2gtcGFjay5jOjc4MQogbXNnaWQgImZldGNoLXBhY2s6IHVuYWJsZSB0byBmb3JrIG9mZiBzaWRlYmFuZCBkZW11bHRpcGxleGVyIgogbXNnc3RyICJmZXRjaC1wYWNrOiBraMO0bmcgdGjhu4MgcuG6vSBuaMOhbmggc2lkZWJhbmQgZGVtdWx0aXBsZXhlciIKIAotIzogZmV0Y2gtcGFjay5jOjc5MQorIzogZmV0Y2gtcGFjay5jOjc4OQogbXNnaWQgInByb3RvY29sIGVycm9yOiBiYWQgcGFjayBoZWFkZXIiCiBtc2dzdHIgImzhu5dpIGdpYW8gdGjhu6ljOiBwaOG6p24gxJHhuqd1IGfDs2kgYuG7iyBzYWkiCiAKLSM6IGZldGNoLXBhY2suYzo4NTkKKyM6IGZldGNoLXBhY2suYzo4NTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmV0Y2gtcGFjazogdW5hYmxlIHRvIGZvcmsgb2ZmICVzIgogbXNnc3RyICJmZXRjaC1wYWNrOiBraMO0bmcgdGjhu4MgcuG6vSBuaMOhbmggJXMiCiAKLSM6IGZldGNoLXBhY2suYzo4NzUKKyM6IGZldGNoLXBhY2suYzo4NzMKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgZmFpbGVkIgogbXNnc3RyICIlcyBn4bq3cCBs4buXaSIKIAotIzogZmV0Y2gtcGFjay5jOjg3NworIzogZmV0Y2gtcGFjay5jOjg3NQogbXNnaWQgImVycm9yIGluIHNpZGViYW5kIGRlbXVsdGlwbGV4ZXIiCiBtc2dzdHIgImPDsyBs4buXaSB0cm9uZyBzaWRlYmFuZCBkZW11bHRpcGxleGVyIgogCi0jOiBmZXRjaC1wYWNrLmM6OTA4CisjOiBmZXRjaC1wYWNrLmM6OTA3CiAjLCBjLWZvcm1hdAogbXNnaWQgIlNlcnZlciB2ZXJzaW9uIGlzICUuKnMiCiBtc2dzdHIgIlBoacOqbiBi4bqjbiBtw6F5IGNo4bunIGzDoCAlLipzIgogCi0jOiBmZXRjaC1wYWNrLmM6OTEzIGZldGNoLXBhY2suYzo5MTkgZmV0Y2gtcGFjay5jOjkyMiBmZXRjaC1wYWNrLmM6OTI4Ci0jOiBmZXRjaC1wYWNrLmM6OTMyIGZldGNoLXBhY2suYzo5MzYgZmV0Y2gtcGFjay5jOjk0MCBmZXRjaC1wYWNrLmM6OTQ0Ci0jOiBmZXRjaC1wYWNrLmM6OTQ4IGZldGNoLXBhY2suYzo5NTIgZmV0Y2gtcGFjay5jOjk1NiBmZXRjaC1wYWNrLmM6OTYwCi0jOiBmZXRjaC1wYWNrLmM6OTY2IGZldGNoLXBhY2suYzo5NzIgZmV0Y2gtcGFjay5jOjk3NyBmZXRjaC1wYWNrLmM6OTgyCisjOiBmZXRjaC1wYWNrLmM6OTEyIGZldGNoLXBhY2suYzo5MTggZmV0Y2gtcGFjay5jOjkyMSBmZXRjaC1wYWNrLmM6OTI3CisjOiBmZXRjaC1wYWNrLmM6OTMxIGZldGNoLXBhY2suYzo5MzUgZmV0Y2gtcGFjay5jOjkzOSBmZXRjaC1wYWNrLmM6OTQzCisjOiBmZXRjaC1wYWNrLmM6OTQ3IGZldGNoLXBhY2suYzo5NTEgZmV0Y2gtcGFjay5jOjk1NSBmZXRjaC1wYWNrLmM6OTU5CisjOiBmZXRjaC1wYWNrLmM6OTY1IGZldGNoLXBhY2suYzo5NzEgZmV0Y2gtcGFjay5jOjk3NiBmZXRjaC1wYWNrLmM6OTgxCiAjLCBjLWZvcm1hdAogbXNnaWQgIlNlcnZlciBzdXBwb3J0cyAlcyIKIG1zZ3N0ciAiTcOheSBjaOG7pyBo4buXIHRy4bujICVzIgogCi0jOiBmZXRjaC1wYWNrLmM6OTE1CisjOiBmZXRjaC1wYWNrLmM6OTE0CiBtc2dpZCAiU2VydmVyIGRvZXMgbm90IHN1cHBvcnQgc2hhbGxvdyBjbGllbnRzIgogbXNnc3RyICJNw6F5IGNo4bunIGtow7RuZyBo4buXIHRy4bujIG3DoXkga2jDoWNoIHNoYWxsb3ciCiAKLSM6IGZldGNoLXBhY2suYzo5NzUKKyM6IGZldGNoLXBhY2suYzo5NzQKIG1zZ2lkICJTZXJ2ZXIgZG9lcyBub3Qgc3VwcG9ydCAtLXNoYWxsb3ctc2luY2UiCiBtc2dzdHIgIk3DoXkgY2jhu6cga2jDtG5nIGjhu5cgdHLhu6MgLS1zaGFsbG93LXNpbmNlIgogCi0jOiBmZXRjaC1wYWNrLmM6OTgwCisjOiBmZXRjaC1wYWNrLmM6OTc5CiBtc2dpZCAiU2VydmVyIGRvZXMgbm90IHN1cHBvcnQgLS1zaGFsbG93LWV4Y2x1ZGUiCiBtc2dzdHIgIk3DoXkgY2jhu6cga2jDtG5nIGjhu5cgdHLhu6MgLS1zaGFsbG93LWV4Y2x1ZGUiCiAKLSM6IGZldGNoLXBhY2suYzo5ODQKKyM6IGZldGNoLXBhY2suYzo5ODMKIG1zZ2lkICJTZXJ2ZXIgZG9lcyBub3Qgc3VwcG9ydCAtLWRlZXBlbiIKIG1zZ3N0ciAiTcOheSBjaOG7pyBraMO0bmcgaOG7lyB0cuG7oyAtLWRlZXBlbiIKIAotIzogZmV0Y2gtcGFjay5jOjEwMDEKKyM6IGZldGNoLXBhY2suYzoxMDAwCiBtc2dpZCAibm8gY29tbW9uIGNvbW1pdHMiCiBtc2dzdHIgImtow7RuZyBjw7MgbOG6p24gY2h1eeG7g24gZ2lhbyBjaHVuZyBuw6BvIgogCi0jOiBmZXRjaC1wYWNrLmM6MTAxMyBmZXRjaC1wYWNrLmM6MTQ2MgorIzogZmV0Y2gtcGFjay5jOjEwMTIgZmV0Y2gtcGFjay5jOjE0NjgKIG1zZ2lkICJnaXQgZmV0Y2gtcGFjazogZmV0Y2ggZmFpbGVkLiIKIG1zZ3N0ciAiZ2l0IGZldGNoLXBhY2s6IGZldGNoIGfhurdwIGzhu5dpLiIKIAotIzogZmV0Y2gtcGFjay5jOjExNTEKKyM6IGZldGNoLXBhY2suYzoxMTUwCiBtc2dpZCAiU2VydmVyIGRvZXMgbm90IHN1cHBvcnQgc2hhbGxvdyByZXF1ZXN0cyIKIG1zZ3N0ciAiTcOheSBjaOG7pyBraMO0bmcgaOG7lyB0cuG7oyB5w6p1IGPhuqd1IHNoYWxsb3ciCiAKQEAgLTMyMjgsNzIgKzMyMzQsNzIgQEAKIG1zZ2lkICJTZXJ2ZXIgc3VwcG9ydHMgZmlsdGVyIgogbXNnc3RyICJNw6F5IGNo4bunIGjhu5cgdHLhu6MgYuG7mSBs4buNYyIKIAotIzogZmV0Y2gtcGFjay5jOjExODQKKyM6IGZldGNoLXBhY2suYzoxMTgwCiBtc2dpZCAidW5hYmxlIHRvIHdyaXRlIHJlcXVlc3QgdG8gcmVtb3RlIgogbXNnc3RyICJraMO0bmcgdGjhu4MgZ2hpIGPDoWMgecOqdSBj4bqndSBsw6puIG3DoXkgcGjhu6VjIHbhu6UiCiAKLSM6IGZldGNoLXBhY2suYzoxMjAyCisjOiBmZXRjaC1wYWNrLmM6MTE5OAogIywgYy1mb3JtYXQKIG1zZ2lkICJlcnJvciByZWFkaW5nIHNlY3Rpb24gaGVhZGVyICclcyciCiBtc2dzdHIgImfhurdwIGzhu5dpIGtoaSDEkeG7jWMgcGjhuqduIMSR4bqndSBj4bunYSDEkW/huqFuICVzIgogCi0jOiBmZXRjaC1wYWNrLmM6MTIwOAorIzogZmV0Y2gtcGFjay5jOjEyMDQKICMsIGMtZm9ybWF0CiBtc2dpZCAiZXhwZWN0ZWQgJyVzJywgcmVjZWl2ZWQgJyVzJyIKIG1zZ3N0ciAiY+G6p24g4oCcJXPigJ0sIG5oxrBuZyBs4bqhaSBuaOG6rW4g4oCcJXPigJ0iCiAKLSM6IGZldGNoLXBhY2suYzoxMjQ3CisjOiBmZXRjaC1wYWNrLmM6MTI0MwogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmV4cGVjdGVkIGFja25vd2xlZGdtZW50IGxpbmU6ICclcyciCiBtc2dzdHIgImfhurdwIGTDsm5nIGtow7RuZyDEkcaw4bujYyB0aOG7q2Egbmjhuq1uOiDigJwlc+KAnSIKIAotIzogZmV0Y2gtcGFjay5jOjEyNTIKKyM6IGZldGNoLXBhY2suYzoxMjQ4CiAjLCBjLWZvcm1hdAogbXNnaWQgImVycm9yIHByb2Nlc3NpbmcgYWNrczogJWQiCiBtc2dzdHIgImfhurdwIGzhu5dpIGtoaSB44butIGzDvSB0w61uIGhp4buHdSB0cuG6oyBs4budaTogJWQiCiAKLSM6IGZldGNoLXBhY2suYzoxMjYyCisjOiBmZXRjaC1wYWNrLmM6MTI1OAogbXNnaWQgImV4cGVjdGVkIHBhY2tmaWxlIHRvIGJlIHNlbnQgYWZ0ZXIgJ3JlYWR5JyIKIG1zZ3N0ciAiY+G6p24gdOG6rXAgdGluIGfDs2kgxJHhu4MgZ+G7rWkgc2F1IOKAnHJlYWR54oCdIgogCi0jOiBmZXRjaC1wYWNrLmM6MTI2NAorIzogZmV0Y2gtcGFjay5jOjEyNjAKIG1zZ2lkICJleHBlY3RlZCBubyBvdGhlciBzZWN0aW9ucyB0byBiZSBzZW50IGFmdGVyIG5vICdyZWFkeSciCiBtc2dzdHIgImtow7RuZyBj4bqnbiB0aMOqbSBwaOG6p24gbsOgbyDEkeG7gyBn4butaSBzYXUg4oCccmVhZHnigJ0iCiAKLSM6IGZldGNoLXBhY2suYzoxMzA2CisjOiBmZXRjaC1wYWNrLmM6MTMwMgogIywgYy1mb3JtYXQKIG1zZ2lkICJlcnJvciBwcm9jZXNzaW5nIHNoYWxsb3cgaW5mbzogJWQiCiBtc2dzdHIgImzhu5dpIHjhu60gbMO9IHRow7RuZyB0aW4gc2hhbGxvdzogJWQiCiAKLSM6IGZldGNoLXBhY2suYzoxMzUzCisjOiBmZXRjaC1wYWNrLmM6MTM0OQogIywgYy1mb3JtYXQKIG1zZ2lkICJleHBlY3RlZCB3YW50ZWQtcmVmLCBnb3QgJyVzJyIKIG1zZ3N0ciAiY+G6p24gd2FudGVkLXJlZiwgbmjGsG5nIGzhuqFpIG5o4bqtbiDEkcaw4bujYyDigJwlc+KAnSIKIAotIzogZmV0Y2gtcGFjay5jOjEzNTgKKyM6IGZldGNoLXBhY2suYzoxMzU0CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuZXhwZWN0ZWQgd2FudGVkLXJlZjogJyVzJyIKIG1zZ3N0ciAia2jDtG5nIGPhuqduIHdhbnRlZC1yZWY6IOKAnCVz4oCdIgogCi0jOiBmZXRjaC1wYWNrLmM6MTM2MworIzogZmV0Y2gtcGFjay5jOjEzNTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiZXJyb3IgcHJvY2Vzc2luZyB3YW50ZWQgcmVmczogJWQiCiBtc2dzdHIgImzhu5dpIGtoaSB44butIGzDvSB3YW50ZWQgcmVmczogJWQiCiAKLSM6IGZldGNoLXBhY2suYzoxNjg5CisjOiBmZXRjaC1wYWNrLmM6MTY5MwogbXNnaWQgIm5vIG1hdGNoaW5nIHJlbW90ZSBoZWFkIgogbXNnc3RyICJraMO0bmcga2jhu5twIHBo4bqnbiDEkeG6p3UgbcOheSBjaOG7pyIKIAotIzogZmV0Y2gtcGFjay5jOjE3MTIgYnVpbHRpbi9jbG9uZS5jOjY4NgorIzogZmV0Y2gtcGFjay5jOjE3MTYgYnVpbHRpbi9jbG9uZS5jOjY4NQogbXNnaWQgInJlbW90ZSBkaWQgbm90IHNlbmQgYWxsIG5lY2Vzc2FyeSBvYmplY3RzIgogbXNnc3RyICJtw6F5IGNo4bunIMSRw6Mga2jDtG5nIGfhu61pIHThuqV0IGPhuqMgY8OhYyDEkeG7kWkgdMaw4bujbmcgY+G6p24gdGhp4bq/dCIKIAotIzogZmV0Y2gtcGFjay5jOjE3MzkKKyM6IGZldGNoLXBhY2suYzoxNzQzCiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vIHN1Y2ggcmVtb3RlIHJlZiAlcyIKIG1zZ3N0ciAia2jDtG5nIGPDsyBtw6F5IGNo4bunIHRoYW0gY2hp4bq/dSBuw6BvIG5oxrAgJXMiCiAKLSM6IGZldGNoLXBhY2suYzoxNzQyCisjOiBmZXRjaC1wYWNrLmM6MTc0NgogIywgYy1mb3JtYXQKIG1zZ2lkICJTZXJ2ZXIgZG9lcyBub3QgYWxsb3cgcmVxdWVzdCBmb3IgdW5hZHZlcnRpc2VkIG9iamVjdCAlcyIKIG1zZ3N0ciAiIgpAQCAtMzMxNywxOCArMzMyMywyNiBAQAogbXNnaWQgImlnbm9yZSBpbnZhbGlkIGNvbG9yICclLipzJyBpbiBsb2cuZ3JhcGhDb2xvcnMiCiBtc2dzdHIgImLhu48gcXVhIG3DoHUga2jDtG5nIGjhu6NwIGzhu4cg4oCcJS4qc+KAnSB0cm9uZyBsb2cuZ3JhcGhDb2xvcnMiCiAKLSM6IGdyZXAuYzoyMTE3CisjOiBncmVwLmM6NjY4Cittc2dpZCAiIgorImdpdmVuIHBhdHRlcm4gY29udGFpbnMgTlVMTCBieXRlICh2aWEgLWYgPGZpbGU+KS4gVGhpcyBpcyBvbmx5IHN1cHBvcnRlZCAiCisid2l0aCAtUCB1bmRlciBQQ1JFIHYyIgorbXNnc3RyICIiCisibeG6q3UgxJHDoyBjaG8gY8OzIGNo4bupYSBOVUxMIGJ5dGUgKHF1YSAtZiA8ZmlsZT4pLiDEkGnhu4F1IG7DoHkgY2jhu4kgxJHGsOG7o2MgaOG7lyB0cuG7oyB24bubaSAtIgorIlAgZMaw4bubaSBQQ1JFIHYyIgorCisjOiBncmVwLmM6MjEyNAogIywgYy1mb3JtYXQKIG1zZ2lkICInJXMnOiB1bmFibGUgdG8gcmVhZCAlcyIKIG1zZ3N0ciAi4oCcJXPigJ06IGtow7RuZyB0aOG7gyDEkeG7jWMgJXMiCiAKLSM6IGdyZXAuYzoyMTM0IHNldHVwLmM6MTY0IGJ1aWx0aW4vY2xvbmUuYzo0MDkgYnVpbHRpbi9kaWZmLmM6ODIKKyM6IGdyZXAuYzoyMTQxIHNldHVwLmM6MTY1IGJ1aWx0aW4vY2xvbmUuYzo0MDggYnVpbHRpbi9kaWZmLmM6ODIKICM6IGJ1aWx0aW4vcm0uYzoxMzUKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIHN0YXQgJyVzJyIKIG1zZ3N0ciAiZ+G6t3AgbOG7l2kga2hpIGzhuqV5IHRo4buRbmcga8OqIHbhu4Eg4oCcJXPigJ0iCiAKLSM6IGdyZXAuYzoyMTQ1CisjOiBncmVwLmM6MjE1MgogIywgYy1mb3JtYXQKIG1zZ2lkICInJXMnOiBzaG9ydCByZWFkIgogbXNnc3RyICLigJwlc+KAnTogxJHhu41jIG5n4bqvbiIKQEAgLTM0NjcsMTIgKzM0ODEsMTIgQEAKIG1zZ2lkICJnaXQgdmVyc2lvbiBbPG9wdGlvbnM+XSIKIG1zZ3N0ciAiZ2l0IHZlcnNpb24gWzxjw6FjIHTDuXkgY2jhu41uPl0iCiAKLSM6IGhlbHAuYzo3ODIKKyM6IGhlbHAuYzo3ODMKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXM6ICVzIC0gJXMiCiBtc2dzdHIgIiVzOiAlcyAtICVzIgogCi0jOiBoZWxwLmM6Nzg2CisjOiBoZWxwLmM6Nzg3CiBtc2dpZCAiIgogIlxuIgogIkRpZCB5b3UgbWVhbiB0aGlzPyIKQEAgLTM1NDIsNDEgKzM1NTYsNTYgQEAKIG1zZ2lkICJpbnZhbGlkIGRhdGUgZm9ybWF0OiAlcyIKIG1zZ3N0ciAibmfDoHkgdGjDoW5nIGtow7RuZyBo4bujcCBs4buHOiAlcyIKIAotIzogbGlzdC1vYmplY3RzLmM6MTI5CisjOiBsaXN0LW9iamVjdHMuYzoxMjcKICMsIGMtZm9ybWF0CiBtc2dpZCAiZW50cnkgJyVzJyBpbiB0cmVlICVzIGhhcyB0cmVlIG1vZGUsIGJ1dCBpcyBub3QgYSB0cmVlIgogbXNnc3RyICJt4bulYyDigJwlc+KAnSB0cm9uZyBjw6J5ICVzIGPDsyBuw7p0IGPDonksIG5oxrBuZyBraMO0bmcgcGjhuqNpIGzDoCBt4buZdCBjw6J5IgogCi0jOiBsaXN0LW9iamVjdHMuYzoxNDIKKyM6IGxpc3Qtb2JqZWN0cy5jOjE0MAogIywgYy1mb3JtYXQKIG1zZ2lkICJlbnRyeSAnJXMnIGluIHRyZWUgJXMgaGFzIGJsb2IgbW9kZSwgYnV0IGlzIG5vdCBhIGJsb2IiCiBtc2dzdHIgIm3hu6VjIOKAnCVz4oCdIHRyb25nIGPDonkgJXMgY8OzIG7DunQgYmxvYiwgbmjGsG5nIGtow7RuZyBwaOG6o2kgbMOgIG3hu5l0IGJsb2IiCiAKLSM6IGxpc3Qtb2JqZWN0cy5jOjM3OAorIzogbGlzdC1vYmplY3RzLmM6Mzc1CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBsb2FkIHJvb3QgdHJlZSBmb3IgY29tbWl0ICVzIgogbXNnc3RyICJraMO0bmcgdGjhu4MgdOG6o2kgY8OieSBn4buRYyBjaG8gbOG6p24gY2h1eeG7g24gZ2lhbyDigJwlc+KAnSIKIAotIzogbGlzdC1vYmplY3RzLWZpbHRlci1vcHRpb25zLmM6MzYKLW1zZ2lkICJtdWx0aXBsZSBmaWx0ZXItc3BlY3MgY2Fubm90IGJlIGNvbWJpbmVkIgotbXNnc3RyICJraMO0bmcgdGjhu4MgdOG7lSBo4bujcCBuaGnhu4F1IMSR4bq3YyB04bqjIGtp4buDdSBs4buNYyIKKyM6IGxpc3Qtb2JqZWN0cy1maWx0ZXIuYzo0OTIKKyMsIGMtZm9ybWF0Cittc2dpZCAidW5hYmxlIHRvIGFjY2VzcyBzcGFyc2UgYmxvYiBpbiAnJXMnIgorbXNnc3RyICJraMO0bmcgdGjhu4MgdHJ1eSBj4bqtcCBjw6FjIGJsb2IgcuG6o2kgcsOhYyB0cm9uZyAnJXMnIgorCisjOiBsaXN0LW9iamVjdHMtZmlsdGVyLmM6NDk1CisjLCBjLWZvcm1hdAorbXNnaWQgInVuYWJsZSB0byBwYXJzZSBzcGFyc2UgZmlsdGVyIGRhdGEgaW4gJXMiCittc2dzdHIgImtow7RuZyB0aOG7gyBwaMOibiB0w61jaCBk4buvIGxp4buHdSBi4buZIGzhu41jIHLhuqNpIHLDoWMgdHJvbmcgJXMiCiAKICM6IGxpc3Qtb2JqZWN0cy1maWx0ZXItb3B0aW9ucy5jOjU4CiBtc2dpZCAiZXhwZWN0ZWQgJ3RyZWU6PGRlcHRoPiciCiBtc2dzdHIgImPhuqduIOKAnHRyZWU6PGRlcHRoPuKAnSIKIAotIzogbGlzdC1vYmplY3RzLWZpbHRlci1vcHRpb25zLmM6ODQKKyM6IGxpc3Qtb2JqZWN0cy1maWx0ZXItb3B0aW9ucy5jOjczCiBtc2dpZCAic3BhcnNlOnBhdGggZmlsdGVycyBzdXBwb3J0IGhhcyBiZWVuIGRyb3BwZWQiCiBtc2dzdHIgInZp4buHYyBo4buXIHRy4bujIGLhu5kgbOG7jWMgc3BhcnNlOsSRxrDhu51uZy9k4bqrbiDEkcOjIGLhu4sgYuG7jyIKIAotIzogbGlzdC1vYmplY3RzLWZpbHRlci1vcHRpb25zLmM6OTQKKyM6IGxpc3Qtb2JqZWN0cy1maWx0ZXItb3B0aW9ucy5jOjg2CiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgZmlsdGVyLXNwZWMgJyVzJyIKIG1zZ3N0ciAixJHhurdjIHThuqMgYuG7mSBs4buNYyBraMO0bmcgaOG7o3AgbOG7hyDigJwlc+KAnSIKIAotIzogbGlzdC1vYmplY3RzLWZpbHRlci1vcHRpb25zLmM6MTU4Ci1tc2dpZCAiY2Fubm90IGNoYW5nZSBwYXJ0aWFsIGNsb25lIHByb21pc29yIHJlbW90ZSIKLW1zZ3N0ciAia2jDtG5nIHRo4buDIHRoYXkgxJHhu5VpIG5ow6JuIGLhuqNuIHThu6tuZyBwaOG6p24gbcOheSBjaOG7pyBwcm9taXNvciIKKyM6IGxpc3Qtb2JqZWN0cy1maWx0ZXItb3B0aW9ucy5jOjEwMgorIywgYy1mb3JtYXQKK21zZ2lkICJtdXN0IGVzY2FwZSBjaGFyIGluIHN1Yi1maWx0ZXItc3BlYzogJyVjJyIKK21zZ3N0ciAicGjhuqNpIHRob8OhdCBjaGFyIHRyb25nIHN1Yi1maWx0ZXItc3BlYzogJyVjJyIKKworIzogbGlzdC1vYmplY3RzLWZpbHRlci1vcHRpb25zLmM6MTQ0Cittc2dpZCAiZXhwZWN0ZWQgc29tZXRoaW5nIGFmdGVyIGNvbWJpbmU6IgorbXNnc3RyICJtb25nIMSR4bujaSBt4buZdCBjw6FpIGfDrCDEkcOzIHNhdSBraGkga+G6v3QgaOG7o3A6IgorCisjOiBsaXN0LW9iamVjdHMtZmlsdGVyLW9wdGlvbnMuYzoyMjYKK21zZ2lkICJtdWx0aXBsZSBmaWx0ZXItc3BlY3MgY2Fubm90IGJlIGNvbWJpbmVkIgorbXNnc3RyICJraMO0bmcgdGjhu4MgdOG7lSBo4bujcCBuaGnhu4F1IMSR4bq3YyB04bqjIGtp4buDdSBs4buNYyIKIAogIzogbG9ja2ZpbGUuYzoxNTEKICMsIGMtZm9ybWF0CkBAIC0zNjA2LDEyMCArMzYzNSwxMTYgQEAKIG1zZ2lkICJmYWlsZWQgdG8gcmVhZCB0aGUgY2FjaGUiCiBtc2dzdHIgImfhurdwIGzhu5dpIGtoaSDEkeG7jWMgYuG7mSBuaOG7myDEkeG7h20iCiAKLSM6IG1lcmdlLmM6MTA3IHJlcmVyZS5jOjcyMCBidWlsdGluL2FtLmM6MTg4NSBidWlsdGluL2FtLmM6MTkxOQotIzogYnVpbHRpbi9jaGVja291dC5jOjUzNiBidWlsdGluL2NoZWNrb3V0LmM6Nzk2IGJ1aWx0aW4vY2xvbmUuYzo3ODYKKyM6IG1lcmdlLmM6MTA3IHJlcmVyZS5jOjcyMCBidWlsdGluL2FtLmM6MTg3NCBidWlsdGluL2FtLmM6MTkwOAorIzogYnVpbHRpbi9jaGVja291dC5jOjUzNyBidWlsdGluL2NoZWNrb3V0LmM6Nzk2IGJ1aWx0aW4vY2xvbmUuYzo3ODUKICM6IGJ1aWx0aW4vc3Rhc2guYzoyNjQKIG1zZ2lkICJ1bmFibGUgdG8gd3JpdGUgbmV3IGluZGV4IGZpbGUiCiBtc2dzdHIgImtow7RuZyB0aOG7gyBnaGkgdOG6rXAgdGluIGzGsHUgYuG6o25nIG3hu6VjIGzhu6VjIG3hu5tpIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozMjIKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjM2NwogbXNnaWQgIihiYWQgY29tbWl0KVxuIgogbXNnc3RyICIoY29tbWl0IHNhaSlcbiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzQ1CisjOiBtZXJnZS1yZWN1cnNpdmUuYzozOTAKICMsIGMtZm9ybWF0CiBtc2dpZCAiYWRkX2NhY2hlaW5mbyBmYWlsZWQgZm9yIHBhdGggJyVzJzsgbWVyZ2UgYWJvcnRpbmcuIgogbXNnc3RyICJhZGRpbmZvX2NhY2hlIGfhurdwIGzhu5dpIMSR4buRaSB24bubaSDEkcaw4budbmcgZOG6q24g4oCcJXPigJ07IHZp4buHYyBow7JhIHRy4buZbiBi4buLIGLDo2kgYuG7jy4iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjM1NAorIzogbWVyZ2UtcmVjdXJzaXZlLmM6Mzk5CiAjLCBjLWZvcm1hdAogbXNnaWQgImFkZF9jYWNoZWluZm8gZmFpbGVkIHRvIHJlZnJlc2ggZm9yIHBhdGggJyVzJzsgbWVyZ2UgYWJvcnRpbmcuIgogbXNnc3RyICIiCiAiYWRkaW5mb19jYWNoZSBn4bq3cCBs4buXaSBraGkgbMOgbSBt4bubaSDEkeG7kWkgduG7m2kgxJHGsOG7nW5nIGThuqtuIOKAnCVz4oCdOyB2aeG7h2MgaMOyYSB0cuG7mW4gYuG7iyAiCiAiYsOjaSBi4buPLiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6NDM3Ci1tc2dpZCAiZXJyb3IgYnVpbGRpbmcgdHJlZXMiCi1tc2dzdHIgImfhurdwIGzhu5dpIGtoaSB4w6J5IGThu7FuZyBjw6J5IgotCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzo4NjMKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjg4NQogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gY3JlYXRlIHBhdGggJyVzJyVzIgogbXNnc3RyICJn4bq3cCBs4buXaSBraGkgdOG6oW8gxJHGsOG7nW5nIGThuqtuIOKAnCVz4oCdJXMiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjg3NAorIzogbWVyZ2UtcmVjdXJzaXZlLmM6ODk2CiAjLCBjLWZvcm1hdAogbXNnaWQgIlJlbW92aW5nICVzIHRvIG1ha2Ugcm9vbSBmb3Igc3ViZGlyZWN0b3J5XG4iCiBtc2dzdHIgIkfhu6EgYuG7jyAlcyDEkeG7gyB04bqhbyBjaOG7lyAocm9vbSkgY2hvIHRoxrAgbeG7pWMgY29uXG4iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjg4OCBtZXJnZS1yZWN1cnNpdmUuYzo5MDcKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjkxMCBtZXJnZS1yZWN1cnNpdmUuYzo5MjkKIG1zZ2lkICI6IHBlcmhhcHMgYSBEL0YgY29uZmxpY3Q/IgogbXNnc3RyICI6IGPDsyBs4bq9IGzDoCBt4buZdCB4dW5nIMSR4buZdCBEL0Y/IgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzo4OTcKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjkxOQogIywgYy1mb3JtYXQKIG1zZ2lkICJyZWZ1c2luZyB0byBsb3NlIHVudHJhY2tlZCBmaWxlIGF0ICclcyciCiBtc2dzdHIgInThu6sgY2jhu5FpIMSRw7NuZyB04bqtcCB0aW4ga2jDtG5nIMSRxrDhu6NjIHRoZW8gZMO1aSB04bqhaSDigJwlc+KAnSIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6OTM4IGJ1aWx0aW4vY2F0LWZpbGUuYzo0MAorIzogbWVyZ2UtcmVjdXJzaXZlLmM6OTYwIGJ1aWx0aW4vY2F0LWZpbGUuYzo0MQogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgcmVhZCBvYmplY3QgJXMgJyVzJyIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIMSR4buNYyDEkeG7kWkgdMaw4bujbmcgJXMg4oCcJXPigJ0iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjk0MQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6OTY1CiAjLCBjLWZvcm1hdAogbXNnaWQgImJsb2IgZXhwZWN0ZWQgZm9yICVzICclcyciCiBtc2dzdHIgIm1vbmcgxJHhu6NpIMSR4buRaSB0xrDhu6NuZyBibG9iIGNobyAlcyDigJwlc+KAnSIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6OTY1CisjOiBtZXJnZS1yZWN1cnNpdmUuYzo5OTAKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIG9wZW4gJyVzJzogJXMiCiBtc2dzdHIgImfhurdwIGzhu5dpIGtoaSBt4bufIOKAnCVz4oCdOiAlcyIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6OTc2CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxMDAxCiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBzeW1saW5rICclcyc6ICVzIgogbXNnc3RyICJn4bq3cCBs4buXaSBraGkgdOG6oW8gbGnDqm4ga+G6v3QgbeG7gW0gKHN5bWxpbmspIOKAnCVz4oCdOiAlcyIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6OTgxCisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxMDA2CiAjLCBjLWZvcm1hdAogbXNnaWQgImRvIG5vdCBrbm93IHdoYXQgdG8gZG8gd2l0aCAlMDZvICVzICclcyciCiBtc2dzdHIgImtow7RuZyBoaeG7g3UgcGjhuqNpIGzDoG0gZ8OsIHbhu5tpICUwNm8gJXMg4oCcJXPigJ0iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjExNzcKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjExOTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiRmFpbGVkIHRvIG1lcmdlIHN1Ym1vZHVsZSAlcyAobm90IGNoZWNrZWQgb3V0KSIKIG1zZ3N0ciAiR+G6t3AgbOG7l2kga2hpIGjDsmEgdHLhu5luIG3DtC3EkXVuLWNvbiDigJwlc+KAnSAoa2jDtG5nIGzhuqV5IHJhIMSRxrDhu6NjKSIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTE4NAorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTIwNgogIywgYy1mb3JtYXQKIG1zZ2lkICJGYWlsZWQgdG8gbWVyZ2Ugc3VibW9kdWxlICVzIChjb21taXRzIG5vdCBwcmVzZW50KSIKIG1zZ3N0ciAiR+G6t3AgbOG7l2kga2hpIGjDsmEgdHLhu5luIG3DtC3EkXVuLWNvbiDigJwlc+KAnSAobOG6p24gY2h1eeG7g24gZ2lhbyBraMO0bmcgaGnhu4duIGRp4buHbikiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjExOTEKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEyMTMKICMsIGMtZm9ybWF0CiBtc2dpZCAiRmFpbGVkIHRvIG1lcmdlIHN1Ym1vZHVsZSAlcyAoY29tbWl0cyBkb24ndCBmb2xsb3cgbWVyZ2UtYmFzZSkiCiBtc2dzdHIgIiIKICJH4bq3cCBs4buXaSBraGkgaMOyYSB0cuG7mW4gbcO0LcSRdW4tY29uIOKAnCVz4oCdIChs4bqnbiBjaHV54buDbiBnaWFvIGtow7RuZyB0aGVvIHNhdSBu4buBbi1ow7JhLSIKICJ0cuG7mW4pIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxMTk5IG1lcmdlLXJlY3Vyc2l2ZS5jOjEyMTEKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEyMjEgbWVyZ2UtcmVjdXJzaXZlLmM6MTIzMwogIywgYy1mb3JtYXQKIG1zZ2lkICJGYXN0LWZvcndhcmRpbmcgc3VibW9kdWxlICVzIHRvIHRoZSBmb2xsb3dpbmcgY29tbWl0OiIKIG1zZ3N0ciAiQ2h1eeG7g24tdGnhur9wLW5oYW5oIG3DtC3EkXVuLWNvbiDigJwlc+KAnSDEkeG6v24gbOG6p24gY2h1eeG7g24gZ2lhbyBzYXUgxJHDonk6IgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxMjAyIG1lcmdlLXJlY3Vyc2l2ZS5jOjEyMTQKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEyMjQgbWVyZ2UtcmVjdXJzaXZlLmM6MTIzNgogIywgYy1mb3JtYXQKIG1zZ2lkICJGYXN0LWZvcndhcmRpbmcgc3VibW9kdWxlICVzIgogbXNnc3RyICJDaHV54buDbi10aeG6v3AtbmhhbmggbcO0LcSRdW4tY29uIOKAnCVz4oCdIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxMjM3CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxMjU5CiAjLCBjLWZvcm1hdAogbXNnaWQgIkZhaWxlZCB0byBtZXJnZSBzdWJtb2R1bGUgJXMgKG1lcmdlIGZvbGxvd2luZyBjb21taXRzIG5vdCBmb3VuZCkiCiBtc2dzdHIgIiIKICJH4bq3cCBs4buXaSBraGkgaMOyYSB0cuG7mW4gbcO0LcSRdW4tY29uIOKAnCVz4oCdIChraMO0bmcgdMOsbSB0aOG6pXkgY8OhYyBs4bqnbiBjaHV54buDbiBnaWFvICIKICJ0aGVvIHNhdSBow7JhIHRy4buZbikiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEyNDEKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEyNjMKICMsIGMtZm9ybWF0CiBtc2dpZCAiRmFpbGVkIHRvIG1lcmdlIHN1Ym1vZHVsZSAlcyAobm90IGZhc3QtZm9yd2FyZCkiCiBtc2dzdHIgIkfhurdwIGzhu5dpIGtoaSBow7JhIHRy4buZbiBtw7QtxJF1bi1jb24g4oCcJXPigJ0gKGtow7RuZyBjaHV54buDbiB0aeG6v3AgbmhhbmggxJHGsOG7o2MpIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxMjQyCisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxMjY0CiBtc2dpZCAiRm91bmQgYSBwb3NzaWJsZSBtZXJnZSByZXNvbHV0aW9uIGZvciB0aGUgc3VibW9kdWxlOlxuIgogbXNnc3RyICJUw6xtIHRo4bqleSBt4buZdCBnaeG6o2kgcGjDoXAgaMOyYSB0cuG7mW4gY8OzIHRo4buDIGNobyBtw7QtxJF1bi1jb246XG4iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEyNDUKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEyNjcKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIklmIHRoaXMgaXMgY29ycmVjdCBzaW1wbHkgYWRkIGl0IHRvIHRoZSBpbmRleCBmb3IgZXhhbXBsZVxuIgpAQCAtMzczNiwzMyArMzc2MSwzMyBAQAogIlxuIgogImPDoWkgbcOgIHPhur0gY2jhuqVwIG5o4bqtbiBn4bujaSDDvSBuw6B5LlxuIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxMjU0CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxMjc2CiAjLCBjLWZvcm1hdAogbXNnaWQgIkZhaWxlZCB0byBtZXJnZSBzdWJtb2R1bGUgJXMgKG11bHRpcGxlIG1lcmdlcyBmb3VuZCkiCiBtc2dzdHIgIkfhurdwIGzhu5dpIGtoaSBow7JhIHRy4buZbiBtw7QtxJF1bi1jb24g4oCcJXPigJ0gKHRo4bqleSBuaGnhu4F1IGjDsmEgdHLhu5luIMSRYSB0csO5bmcpIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxMzI3CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxMzQ5CiBtc2dpZCAiRmFpbGVkIHRvIGV4ZWN1dGUgaW50ZXJuYWwgbWVyZ2UiCiBtc2dzdHIgIkfhurdwIGzhu5dpIGtoaSB0aOG7sWMgaGnhu4duIHRy4buZbiBu4buZaSBi4buZIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxMzMyCisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxMzU0CiAjLCBjLWZvcm1hdAogbXNnaWQgIlVuYWJsZSB0byBhZGQgJXMgdG8gZGF0YWJhc2UiCiBtc2dzdHIgIktow7RuZyB0aOG7gyB0aMOqbSAlcyB2w6BvIGPGoSBz4bufIGThu68gbGnhu4d1IgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxMzY0CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxMzg2CiAjLCBjLWZvcm1hdAogbXNnaWQgIkF1dG8tbWVyZ2luZyAlcyIKIG1zZ3N0ciAiVOG7sS3EkeG7mW5nLWjDsmEtdHLhu5luICVzIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxMzg3CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxNDEwCiAjLCBjLWZvcm1hdAogbXNnaWQgIkVycm9yOiBSZWZ1c2luZyB0byBsb3NlIHVudHJhY2tlZCBmaWxlIGF0ICVzOyB3cml0aW5nIHRvICVzIGluc3RlYWQuIgogbXNnc3RyICIiCiAiTOG7l2k6IHThu6sgY2jhu5FpIMSRw7NuZyB04bqtcCB0aW4ga2jDtG5nIMSRxrDhu6NjIHRoZW8gZMO1aSB04bqhaSDigJwlc+KAnTsgdGhheSB2w6BvIMSRw7MgZ2hpIHbDoG8gIgogIiVzLiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTQ1OQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTQ4MgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiQ09ORkxJQ1QgKCVzL2RlbGV0ZSk6ICVzIGRlbGV0ZWQgaW4gJXMgYW5kICVzIGluICVzLiBWZXJzaW9uICVzIG9mICVzIGxlZnQgIgpAQCAtMzc3MSw3ICszNzk2LDcgQEAKICJYVU5HIMSQ4buYVCAoJXMveMOzYSk6ICVzIGLhu4sgeMOzYSB0cm9uZyAlcyB2w6AgJXMgdHJvbmcgJXMuIFBoacOqbiBi4bqjbiAlcyBj4bunYSAlcyAiCiAiY8OybiBs4bqhaSB0cm9uZyBjw6J5ICh0cmVlKS4iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE0NjQKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE0ODcKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkNPTkZMSUNUICglcy9kZWxldGUpOiAlcyBkZWxldGVkIGluICVzIGFuZCAlcyB0byAlcyBpbiAlcy4gVmVyc2lvbiAlcyBvZiAlcyAiCkBAIC0zNzgwLDcgKzM4MDUsNyBAQAogIlhVTkcgxJDhu5hUICglcy94w7NhKTogJXMgYuG7iyB4w7NhIHRyb25nICVzIHbDoCAlcyDEkeG6v24gJXMgdHJvbmcgJXMuIFBoacOqbiBi4bqjbiAlcyAiCiAiY+G7p2EgJXMgY8OybiBs4bqhaSB0cm9uZyBjw6J5ICh0cmVlKS4iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE0NzEKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE0OTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkNPTkZMSUNUICglcy9kZWxldGUpOiAlcyBkZWxldGVkIGluICVzIGFuZCAlcyBpbiAlcy4gVmVyc2lvbiAlcyBvZiAlcyBsZWZ0ICIKQEAgLTM3ODksNyArMzgxNCw3IEBACiAiWFVORyDEkOG7mFQgKCVzL3jDs2EpOiAlcyBi4buLIHjDs2EgdHJvbmcgJXMgdsOgICVzIHRyb25nICVzLiBQaGnDqm4gYuG6o24gJXMgY+G7p2EgJXMgIgogImPDsm4gbOG6oWkgdHJvbmcgY8OieSAodHJlZSkgdOG6oWkgJXMuIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxNDc2CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxNDk5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJDT05GTElDVCAoJXMvZGVsZXRlKTogJXMgZGVsZXRlZCBpbiAlcyBhbmQgJXMgdG8gJXMgaW4gJXMuIFZlcnNpb24gJXMgb2YgJXMgIgpAQCAtMzc5OCw0NSArMzgyMyw0NSBAQAogIlhVTkcgxJDhu5hUICglcy94w7NhKTogJXMgYuG7iyB4w7NhIHRyb25nICVzIHbDoCAlcyDEkeG6v24gJXMgdHJvbmcgJXMuIFBoacOqbiBi4bqjbiAlcyAiCiAiY+G7p2EgJXMgY8OybiBs4bqhaSB0cm9uZyBjw6J5ICh0cmVlKSB04bqhaSAlcy4iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE1MTEKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE1MzQKIG1zZ2lkICJyZW5hbWUiCiBtc2dzdHIgIsSR4buVaSB0w6puIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxNTExCisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxNTM0CiBtc2dpZCAicmVuYW1lZCIKIG1zZ3N0ciAixJHDoyDEkeG7lWkgdMOqbiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTU5MSBtZXJnZS1yZWN1cnNpdmUuYzoyNDUwIG1lcmdlLXJlY3Vyc2l2ZS5jOjMwOTQKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE2MTQgbWVyZ2UtcmVjdXJzaXZlLmM6MjQ3MiBtZXJnZS1yZWN1cnNpdmUuYzozMTE3CiAjLCBjLWZvcm1hdAogbXNnaWQgIlJlZnVzaW5nIHRvIGxvc2UgZGlydHkgZmlsZSBhdCAlcyIKIG1zZ3N0ciAiVOG7qyBjaOG7kWkgxJHDs25nIHThuq1wIHRpbiBraMO0bmcgxJHGsOG7o2MgdGhlbyBkw7VpIHThuqFpIOKAnCVz4oCdIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxNjAxCisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxNjI0CiAjLCBjLWZvcm1hdAogbXNnaWQgIlJlZnVzaW5nIHRvIGxvc2UgdW50cmFja2VkIGZpbGUgYXQgJXMsIGV2ZW4gdGhvdWdoIGl0J3MgaW4gdGhlIHdheS4iCiBtc2dzdHIgIiIKICJU4burIGNo4buRaSDEkcOzbmcgdOG6rXAgdGluIGtow7RuZyDEkcaw4bujYyB0aGVvIGTDtWkgdOG6oWkg4oCcJXPigJ0sIG5nYXkgY+G6oyBraGkgbsOzIOG7nyB0csOqbiAiCiAixJHGsOG7nW5nLiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTY1OQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTY4MgogIywgYy1mb3JtYXQKIG1zZ2lkICJDT05GTElDVCAocmVuYW1lL2FkZCk6IFJlbmFtZSAlcy0+JXMgaW4gJXMuICBBZGRlZCAlcyBpbiAlcyIKIG1zZ3N0ciAiIgogIlhVTkcgxJDhu5hUICjEkeG7lWktdMOqbi90aMOqbSk6IMSQ4buVaSB0w6puICVzLT4lcyB0cm9uZyAlcy4gJXMgxJHGsOG7o2MgdGjDqm0gdHJvbmcgJXMiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE2OTAKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE3MTMKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgaXMgYSBkaXJlY3RvcnkgaW4gJXMgYWRkaW5nIGFzICVzIGluc3RlYWQiCiBtc2dzdHIgIiVzIGzDoCBt4buZdCB0aMawIG3hu6VjIHRyb25nICVzIHRoYXkgdsOgbyDEkcOzIHRow6ptIHbDoG8gbmjGsCBsw6AgJXMiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE2OTUKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE3MTgKICMsIGMtZm9ybWF0CiBtc2dpZCAiUmVmdXNpbmcgdG8gbG9zZSB1bnRyYWNrZWQgZmlsZSBhdCAlczsgYWRkaW5nIGFzICVzIGluc3RlYWQiCiBtc2dzdHIgIiIKICJU4burIGNo4buRaSDEkcOzbmcgdOG6rXAgdGluIGtow7RuZyDEkcaw4bujYyB0aGVvIGTDtWkgdOG6oWkg4oCcJXPigJ07IHRoYXkgdsOgbyDEkcOzIMSRYW5nIHRow6ptICIKICJ0aMOgbmggJXMiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE3MTQKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE3MzcKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkNPTkZMSUNUIChyZW5hbWUvcmVuYW1lKTogUmVuYW1lIFwiJXNcIi0+XCIlc1wiIGluIGJyYW5jaCBcIiVzXCIgcmVuYW1lIFwiJXMiCkBAIC0zODQ1LDE3ICszODcwLDE3IEBACiAiWFVORyDEkOG7mFQgKMSR4buVaS10w6puL8SR4buVaS10w6puKTogxJDhu5VpIHTDqm4gXCIlc1wiLT5cIiVzXCIgdHJvbmcgbmjDoW5oIFwiJXNcIiDEkeG7lWkgIgogInTDqm4gXCIlc1wiLT5cIiVzXCIgdHJvbmcgXCIlc1wiJXMiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE3MTkKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE3NDIKIG1zZ2lkICIgKGxlZnQgdW5yZXNvbHZlZCkiCiBtc2dzdHIgIiAoY+G6p24gZ2nhuqNpIHF1eeG6v3QpIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxODI4CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxODUxCiAjLCBjLWZvcm1hdAogbXNnaWQgIkNPTkZMSUNUIChyZW5hbWUvcmVuYW1lKTogUmVuYW1lICVzLT4lcyBpbiAlcy4gUmVuYW1lICVzLT4lcyBpbiAlcyIKIG1zZ3N0ciAiIgogIlhVTkcgxJDhu5hUICjEkeG7lWktdMOqbi/EkeG7lWktdMOqbik6IMSQ4buVaSB0w6puICVzLT4lcyB0cm9uZyAlcy4gxJDhu5VpIHTDqm4gJXMtPiVzIHRyb25nICVzIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoyMDM1CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoyMDU2CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJDT05GTElDVCAoZGlyZWN0b3J5IHJlbmFtZSBzcGxpdCk6IFVuY2xlYXIgd2hlcmUgdG8gcGxhY2UgJXMgYmVjYXVzZSAiCkBAIC0zODY2LDcgKzM4OTEsNyBAQAogInbDrCB0aMawIG3hu6VjICVzIMSRw6MgYuG7iyDEkeG7lWkgdMOqbiB0aMOgbmggbmhp4buBdSB0aMawIG3hu6VjIGtow6FjLCB24bubaSBraMO0bmcgxJHDrWNoIMSR4bq/biAiCiAibmjhuq1uIG3hu5l0IHBo4bqnbiBuaGnhu4F1IGPhu6dhIGPDoWMgdOG6rXAgdGluLiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MjA2NworIzogbWVyZ2UtcmVjdXJzaXZlLmM6MjA4OAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiQ09ORkxJQ1QgKGltcGxpY2l0IGRpciByZW5hbWUpOiBFeGlzdGluZyBmaWxlL2RpciBhdCAlcyBpbiB0aGUgd2F5IG9mICIKQEAgLTM4NzUsNyArMzkwMCw3IEBACiAiWFVORyDEkOG7mFQ6IChuZ+G6p20gxJHhu5VpIHTDqm4gdGjGsCBt4bulYyk6IFThuq1wIHRpbi90aMawIG3hu6VjIMSRw6Mgc+G6tW4gY8OzIHThuqFpICVzIHRoZW8gY8OhY2ggIgogImPhu6dhIGPDoWMgxJHhu5VpIHTDqm4gdGjGsCBt4bulYyBuZ+G6p20gxJHhurd0IChjw6FjKSDEkcaw4budbmcgZOG6q24gc2F1IOG7nyDEkcOieTogJXMuIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoyMDc3CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoyMDk4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJDT05GTElDVCAoaW1wbGljaXQgZGlyIHJlbmFtZSk6IENhbm5vdCBtYXAgbW9yZSB0aGFuIG9uZSBwYXRoIHRvICVzOyAiCkBAIC0zODg0LDcgKzM5MDksNyBAQAogIlhVTkcgxJDhu5hUOiAobmfhuqdtIMSR4buVaSB0w6puIHRoxrAgbeG7pWMpOiBLaMO0bmcgdGjhu4Mgw6FuaCB44bqhIG3hu5l0IMSRxrDhu51uZyBk4bqrbiB0aMOgbmggJXM7ICIKICJjw6FjIMSR4buVaSB0w6puIHRoxrAgbeG7pWMgbmfhuqdtIGPhu5EgxJHhurd0IGPDoWMgxJHGsOG7nW5nIGThuqtuIOG7nyDEkcOieTogJXMiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjIxNjkKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjIxOTAKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkNPTkZMSUNUIChyZW5hbWUvcmVuYW1lKTogUmVuYW1lIGRpcmVjdG9yeSAlcy0+JXMgaW4gJXMuIFJlbmFtZSBkaXJlY3RvcnkgJXMtIgpAQCAtMzg5Myw3ICszOTE4LDcgQEAKICJYVU5HIMSQ4buYVCAoxJHhu5VpLXTDqm4vxJHhu5VpLXTDqm4pOiDEkOG7lWkgdMOqbiB0aMawIG3hu6VjICVzLT4lcyB0cm9uZyAlcy4gxJDhu5VpIHTDqm4gdGjGsCBt4bulYyAiCiAiJXMtPiVzIHRyb25nICVzIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoyNDEzCisjOiBtZXJnZS1yZWN1cnNpdmUuYzoyNDM1CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJXQVJOSU5HOiBBdm9pZGluZyBhcHBseWluZyAlcyAtPiAlcyByZW5hbWUgdG8gJXMsIGJlY2F1c2UgJXMgaXRzZWxmIHdhcyAiCkBAIC0zOTAyLDUyICszOTI3LDUyIEBACiAiQ+G6ok5IIELDgU86IHRyw6FuaCDDoXAgZOG7pW5nICVzIC0+ICVzIMSR4buVaSB0aMOqbiB0aMOgbmggJXMsIGLhu59pIHbDrCBi4bqjbiB0aMOibiAlcyBjxaluZyAiCiAiYuG7iyDEkeG7lWkgdMOqbi4iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjI5MzgKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjI5NjEKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IHJlYWQgb2JqZWN0ICVzIgogbXNnc3RyICJraMO0bmcgdGjhu4MgxJHhu41jIMSR4buRaSB0xrDhu6NuZyAlcyIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6Mjk0MQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6Mjk2NAogIywgYy1mb3JtYXQKIG1zZ2lkICJvYmplY3QgJXMgaXMgbm90IGEgYmxvYiIKIG1zZ3N0ciAixJHhu5FpIHTGsOG7o25nICVzIGtow7RuZyBwaOG6o2kgbMOgIG3hu5l0IGJsb2IiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMwMDUKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMwMjgKIG1zZ2lkICJtb2RpZnkiCiBtc2dzdHIgInPhu61hIMSR4buVaSIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzAwNQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzAyOAogbXNnaWQgIm1vZGlmaWVkIgogbXNnc3RyICLEkcOjIHPhu61hIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozMDE3CisjOiBtZXJnZS1yZWN1cnNpdmUuYzozMDQwCiBtc2dpZCAiY29udGVudCIKIG1zZ3N0ciAibuG7mWkgZHVuZyIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzAyMQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzA0NAogbXNnaWQgImFkZC9hZGQiCiBtc2dzdHIgInRow6ptL3Row6ptIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozMDQ0CisjOiBtZXJnZS1yZWN1cnNpdmUuYzozMDY3CiAjLCBjLWZvcm1hdAogbXNnaWQgIlNraXBwZWQgJXMgKG1lcmdlZCBzYW1lIGFzIGV4aXN0aW5nKSIKIG1zZ3N0ciAixJDDoyBi4buPIHF1YSAlcyAoxJHDoyBjw7Mgc+G6tW4gbOG6p24gaMOyYSB0cuG7mW4gbsOgeSkiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMwNjYgZ2l0LXN1Ym1vZHVsZS5zaDo5MzcKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMwODkgZ2l0LXN1Ym1vZHVsZS5zaDo5MzcKIG1zZ2lkICJzdWJtb2R1bGUiCiBtc2dzdHIgIm3DtC3EkXVuLWNvbiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzA2NworIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzA5MAogIywgYy1mb3JtYXQKIG1zZ2lkICJDT05GTElDVCAoJXMpOiBNZXJnZSBjb25mbGljdCBpbiAlcyIKIG1zZ3N0ciAiWFVORyDEkOG7mFQgKCVzKTogWHVuZyDEkeG7mXQgaMOyYSB0cuG7mW4gdHJvbmcgJXMiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMwOTcKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMxMjAKICMsIGMtZm9ybWF0CiBtc2dpZCAiQWRkaW5nIGFzICVzIGluc3RlYWQiCiBtc2dzdHIgIlRoYXkgdsOgbyDEkcOzIHRow6ptIHbDoG8gJXMiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMxNzkKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMyMDMKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlBhdGggdXBkYXRlZDogJXMgYWRkZWQgaW4gJXMgaW5zaWRlIGEgZGlyZWN0b3J5IHRoYXQgd2FzIHJlbmFtZWQgaW4gJXM7ICIKQEAgLTM5NTYsNyArMzk4MSw3IEBACiAixJDGsOG7nW5nIGThuqtuIMSRw6MgxJHGsOG7o2MgY+G6rXAgbmjhuq10OiAlcyDEkcaw4bujYyB0aMOqbSB2w6BvIHRyb25nICVzIGLDqm4gdHJvbmcgbeG7mXQgdGjGsCBt4bulYyAiCiAixJHDoyDEkcaw4bujYyDEkeG7lWkgdMOqbiB0cm9uZyAlczsgZGkgY2h1eeG7g24gbsOzIMSR4bq/biAlcy4iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMxODIKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMyMDYKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkNPTkZMSUNUIChmaWxlIGxvY2F0aW9uKTogJXMgYWRkZWQgaW4gJXMgaW5zaWRlIGEgZGlyZWN0b3J5IHRoYXQgd2FzIHJlbmFtZWQgIgpAQCAtMzk2NSw3ICszOTkwLDcgQEAKICJYVU5HIMSQ4buYVCAoduG7iyB0csOtIHThu4dwKTogJXMgxJHGsOG7o2MgdGjDqm0gdsOgbyB0cm9uZyAlcyB0cm9uZyBt4buZdCB0aMawIG3hu6VjIMSRw6MgxJHGsOG7o2MgIgogIsSR4buVaSB0w6puIHRow6BuaCAlcywgxJFvw6FuIGzDoCBuw7MgbsOqbiDEkcaw4bujYyBkaSBjaHV54buDbiDEkeG6v24gJXMuIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozMTg2CisjOiBtZXJnZS1yZWN1cnNpdmUuYzozMjEwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJQYXRoIHVwZGF0ZWQ6ICVzIHJlbmFtZWQgdG8gJXMgaW4gJXMsIGluc2lkZSBhIGRpcmVjdG9yeSB0aGF0IHdhcyByZW5hbWVkIGluICIKQEAgLTM5NzQsNyArMzk5OSw3IEBACiAixJDGsOG7nW5nIGThuqtuIMSRw6MgxJHGsOG7o2MgY+G6rXAgbmjhuq10OiAlcyDEkcaw4bujYyDEkeG7lWkgdMOqbiB0aMOgbmggJXMgdHJvbmcgJXMsIGLDqm4gdHJvbmcgbeG7mXQgIgogInRoxrAgbeG7pWMgxJHDoyDEkcaw4bujYyDEkeG7lWkgdMOqbiB0cm9uZyAlczsgZGkgY2h1eeG7g24gbsOzIMSR4bq/biAlcy4iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMxODkKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMyMTMKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkNPTkZMSUNUIChmaWxlIGxvY2F0aW9uKTogJXMgcmVuYW1lZCB0byAlcyBpbiAlcywgaW5zaWRlIGEgZGlyZWN0b3J5IHRoYXQgIgpAQCAtMzk4MywzNyArNDAwOCw2MCBAQAogIlhVTkcgxJDhu5hUICh24buLIHRyw60gdOG7h3ApOiAlcyDEkcaw4bujYyDEkeG7lWkgdMOqbiB0aMOgbmggJXMgdHJvbmcgJXMsIGLDqm4gdHJvbmcgbeG7mXQgdGjGsCAiCiAibeG7pWMgxJHDoyDEkcaw4bujYyDEkeG7lWkgdMOqbiB0aMOgbmggJXMsIMSRb8OhbiBsw6AgbsOzIG7Dqm4gxJHGsOG7o2MgZGkgY2h1eeG7g24gxJHhur9uICVzLiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzMwMworIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzMyNwogIywgYy1mb3JtYXQKIG1zZ2lkICJSZW1vdmluZyAlcyIKIG1zZ3N0ciAixJBhbmcgeMOzYSAlcyIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzMyNgorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzM1MAogbXNnaWQgImZpbGUvZGlyZWN0b3J5IgogbXNnc3RyICJ04bqtcC10aW4vdGjGsC1t4bulYyIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzMzMQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzM1NQogbXNnaWQgImRpcmVjdG9yeS9maWxlIgogbXNnc3RyICJ0aMawLW3hu6VjL3Thuq1wLXRpbiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzMzOAorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzM2MgogIywgYy1mb3JtYXQKIG1zZ2lkICJDT05GTElDVCAoJXMpOiBUaGVyZSBpcyBhIGRpcmVjdG9yeSB3aXRoIG5hbWUgJXMgaW4gJXMuIEFkZGluZyAlcyBhcyAlcyIKIG1zZ3N0ciAiIgogIlhVTkcgxJDhu5hUICglcyk6IOG7niDEkcOieSBraMO0bmcgY8OzIHRoxrAgbeG7pWMgbsOgbyBjw7MgdMOqbiAlcyB0cm9uZyAlcy4gVGjDqm0gJXMgbmjGsCBsw6AgIgogIiVzIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozMzQ3CisjOiBtZXJnZS1yZWN1cnNpdmUuYzozMzcxCiAjLCBjLWZvcm1hdAogbXNnaWQgIkFkZGluZyAlcyIKIG1zZ3N0ciAiVGjDqm0gXCIlc1wiIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozMzU2CisjOiBtZXJnZS1yZWN1cnNpdmUuYzozMzgwCiAjLCBjLWZvcm1hdAogbXNnaWQgIkNPTkZMSUNUIChhZGQvYWRkKTogTWVyZ2UgY29uZmxpY3QgaW4gJXMiCiBtc2dzdHIgIlhVTkcgxJDhu5hUICh0aMOqbS90aMOqbSk6IFh1bmcgxJHhu5l0IGjDsmEgdHLhu5luIHRyb25nICVzIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozMzk0CisjOiBtZXJnZS1yZWN1cnNpdmUuYzozNDI0Cittc2dpZCAiQWxyZWFkeSB1cCB0byBkYXRlISIKK21zZ3N0ciAixJDDoyBj4bqtcCBuaOG6rXQgcuG7k2khIgorCisjOiBtZXJnZS1yZWN1cnNpdmUuYzozNDMzCisjLCBjLWZvcm1hdAorbXNnaWQgIm1lcmdpbmcgb2YgdHJlZXMgJXMgYW5kICVzIGZhaWxlZCIKK21zZ3N0ciAiaMOyYSB0cuG7mW4gY8OhYyBjw6J5ICVzIHbDoCAlcyBn4bq3cCBs4buXaSIKKworIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzUzNworbXNnaWQgIk1lcmdpbmc6IgorbXNnc3RyICLEkGFuZyB0cuG7mW46IgorCisjOiBtZXJnZS1yZWN1cnNpdmUuYzozNTUwCisjLCBjLWZvcm1hdAorbXNnaWQgImZvdW5kICV1IGNvbW1vbiBhbmNlc3RvcjoiCittc2dpZF9wbHVyYWwgImZvdW5kICV1IGNvbW1vbiBhbmNlc3RvcnM6IgorbXNnc3RyWzBdICJ0w6xtIHRo4bqleSAldSB04buVIHRpw6puIGNodW5nOiIKKworIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzYwMAorbXNnaWQgIm1lcmdlIHJldHVybmVkIG5vIGNvbW1pdCIKK21zZ3N0ciAiaMOyYSB0cuG7mW4ga2jDtG5nIHRy4bqjIHbhu4EgbOG6p24gY2h1eeG7g24gZ2lhbyBuw6BvIgorCisjOiBtZXJnZS1yZWN1cnNpdmUuYzozNjU5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJZb3VyIGxvY2FsIGNoYW5nZXMgdG8gdGhlIGZvbGxvd2luZyBmaWxlcyB3b3VsZCBiZSBvdmVyd3JpdHRlbiBieSBtZXJnZTpcbiIKQEAgLTQwMjMsMTg3ICs0MDcxLDE2NCBAQAogImjDsmEgdHLhu5luOlxuIgogIiAgJXMiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjM0MDUKLW1zZ2lkICJBbHJlYWR5IHVwIHRvIGRhdGUhIgotbXNnc3RyICLEkMOjIGPhuq1wIG5o4bqtdCBy4buTaSEiCi0KLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjM0MTQKLSMsIGMtZm9ybWF0Ci1tc2dpZCAibWVyZ2luZyBvZiB0cmVlcyAlcyBhbmQgJXMgZmFpbGVkIgotbXNnc3RyICJow7JhIHRy4buZbiBjw6FjIGPDonkgJXMgdsOgICVzIGfhurdwIGzhu5dpIgotCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozNTEzCi1tc2dpZCAiTWVyZ2luZzoiCi1tc2dzdHIgIsSQYW5nIHRy4buZbjoiCi0KLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjM1MjYKLSMsIGMtZm9ybWF0Ci1tc2dpZCAiZm91bmQgJXUgY29tbW9uIGFuY2VzdG9yOiIKLW1zZ2lkX3BsdXJhbCAiZm91bmQgJXUgY29tbW9uIGFuY2VzdG9yczoiCi1tc2dzdHJbMF0gInTDrG0gdGjhuqV5ICV1IHThu5UgdGnDqm4gY2h1bmc6IgotCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozNTY1Ci1tc2dpZCAibWVyZ2UgcmV0dXJuZWQgbm8gY29tbWl0IgotbXNnc3RyICJow7JhIHRy4buZbiBraMO0bmcgdHLhuqMgduG7gSBs4bqnbiBjaHV54buDbiBnaWFvIG7DoG8iCi0KLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjM2MzEKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjM3NTYKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ291bGQgbm90IHBhcnNlIG9iamVjdCAnJXMnIgogbXNnc3RyICJLaMO0bmcgdGjhu4MgcGjDom4gdMOtY2ggxJHhu5FpIHTGsOG7o25nIOKAnCVz4oCdIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozNjQ3IGJ1aWx0aW4vbWVyZ2UuYzo2OTggYnVpbHRpbi9tZXJnZS5jOjg2OQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6Mzc3NCBidWlsdGluL21lcmdlLmM6Njk0IGJ1aWx0aW4vbWVyZ2UuYzo4NzQKIG1zZ2lkICJVbmFibGUgdG8gd3JpdGUgaW5kZXguIgogbXNnc3RyICJLaMO0bmcgdGjhu4MgZ2hpIGLhuqNuZyBt4bulYyBs4bulYy4iCiAKLSM6IG1pZHguYzo2OQorIzogbWlkeC5jOjY4CiAjLCBjLWZvcm1hdAogbXNnaWQgIm11bHRpLXBhY2staW5kZXggZmlsZSAlcyBpcyB0b28gc21hbGwiCiBtc2dzdHIgInThuq1wIHRpbiDEkeG7kyB0aOG7iyBtdWx0aS1wYWNrLWluZGV4ICVzIHF1w6Egbmjhu48iCiAKLSM6IG1pZHguYzo4NQorIzogbWlkeC5jOjg0CiAjLCBjLWZvcm1hdAogbXNnaWQgIm11bHRpLXBhY2staW5kZXggc2lnbmF0dXJlIDB4JTA4eCBkb2VzIG5vdCBtYXRjaCBzaWduYXR1cmUgMHglMDh4IgogbXNnc3RyICJjaOG7ryBrw70gbXVsdGktcGFjay1pbmRleCAweCUwOHgga2jDtG5nIGto4bubcCBjaOG7ryBrw70gMHglMDh4IgogCi0jOiBtaWR4LmM6OTAKKyM6IG1pZHguYzo4OQogIywgYy1mb3JtYXQKIG1zZ2lkICJtdWx0aS1wYWNrLWluZGV4IHZlcnNpb24gJWQgbm90IHJlY29nbml6ZWQiCiBtc2dzdHIgImtow7RuZyBuaOG6rW4gcmEgcGhpw6puIGLhuqNuICVkIGPhu6dhIG11bHRpLXBhY2staW5kZXgiCiAKLSM6IG1pZHguYzo5NQorIzogbWlkeC5jOjk0CiAjLCBjLWZvcm1hdAogbXNnaWQgImhhc2ggdmVyc2lvbiAldSBkb2VzIG5vdCBtYXRjaCIKIG1zZ3N0ciAicGhpw6puIGLhuqNuIGLEg20g4oCcJXXigJ0ga2jDtG5nIGto4bubcCIKIAotIzogbWlkeC5jOjEwOQorIzogbWlkeC5jOjEwOAogbXNnaWQgImludmFsaWQgY2h1bmsgb2Zmc2V0ICh0b28gbGFyZ2UpIgogbXNnc3RyICJraG/huqNuZyBiw7kgxJFv4bqhbiBraMO0bmcgaOG7o3AgbOG7hyAocXXDoSBs4bubbikiCiAKLSM6IG1pZHguYzoxMzMKKyM6IG1pZHguYzoxMzIKIG1zZ2lkICJ0ZXJtaW5hdGluZyBtdWx0aS1wYWNrLWluZGV4IGNodW5rIGlkIGFwcGVhcnMgZWFybGllciB0aGFuIGV4cGVjdGVkIgogbXNnc3RyICJtw6MgbeG6o25oIGvhur90IHRow7pjIG11bHRpLXBhY2staW5kZXggeHXhuqV0IGhp4buHbiBz4bubbSBoxqFuIGLDrG5oIHRoxrDhu51uZyIKIAotIzogbWlkeC5jOjE0NgorIzogbWlkeC5jOjE0NQogbXNnaWQgIm11bHRpLXBhY2staW5kZXggbWlzc2luZyByZXF1aXJlZCBwYWNrLW5hbWUgY2h1bmsiCiBtc2dzdHIgIm11bHRpLXBhY2staW5kZXggdGhp4bq/dSBt4bqjbmggcGFjay1uYW1lIGPhuqduIHRoaeG6v3QiCiAKLSM6IG1pZHguYzoxNDgKKyM6IG1pZHguYzoxNDcKIG1zZ2lkICJtdWx0aS1wYWNrLWluZGV4IG1pc3NpbmcgcmVxdWlyZWQgT0lEIGZhbm91dCBjaHVuayIKIG1zZ3N0ciAibXVsdGktcGFjay1pbmRleCB0aGnhur91IG3huqNuaCBPSUQgZmFub3V0IGPhuqduIHRoaeG6v3QiCiAKLSM6IG1pZHguYzoxNTAKKyM6IG1pZHguYzoxNDkKIG1zZ2lkICJtdWx0aS1wYWNrLWluZGV4IG1pc3NpbmcgcmVxdWlyZWQgT0lEIGxvb2t1cCBjaHVuayIKIG1zZ3N0ciAibXVsdGktcGFjay1pbmRleCB0aGnhur91IG3huqNuaCBPSUQgbG9va3VwIGPhuqduIHRoaeG6v3QiCiAKLSM6IG1pZHguYzoxNTIKKyM6IG1pZHguYzoxNTEKIG1zZ2lkICJtdWx0aS1wYWNrLWluZGV4IG1pc3NpbmcgcmVxdWlyZWQgb2JqZWN0IG9mZnNldHMgY2h1bmsiCiBtc2dzdHIgIm11bHRpLXBhY2staW5kZXggdGhp4bq/dSBt4bqjbmggY8OhYyBraG/huqNuZyBiw7kgxJHhu5FpIHTGsOG7o25nIGPhuqduIHRoaeG6v3QiCiAKLSM6IG1pZHguYzoxNjYKKyM6IG1pZHguYzoxNjUKICMsIGMtZm9ybWF0CiBtc2dpZCAibXVsdGktcGFjay1pbmRleCBwYWNrIG5hbWVzIG91dCBvZiBvcmRlcjogJyVzJyBiZWZvcmUgJyVzJyIKIG1zZ3N0ciAiY8OhYyB0w6puIGfDs2kgbXVsdGktcGFjay1pbmRleCBraMO0bmcgxJHDum5nIHRo4bupIHThu7E6IOKAnCVz4oCdIHRyxrDhu5tjIOKAnCVz4oCdIgogCi0jOiBtaWR4LmM6MjExCisjOiBtaWR4LmM6MjEwCiAjLCBjLWZvcm1hdAogbXNnaWQgImJhZCBwYWNrLWludC1pZDogJXUgKCV1IHRvdGFsIHBhY2tzKSIKIG1zZ3N0ciAicGFjay1pbnQtaWQgc2FpOiAldSAoJXUgY8OhYyBnw7NpIHThu5VuZykiCiAKLSM6IG1pZHguYzoyNjEKKyM6IG1pZHguYzoyNjAKIG1zZ2lkICJtdWx0aS1wYWNrLWluZGV4IHN0b3JlcyBhIDY0LWJpdCBvZmZzZXQsIGJ1dCBvZmZfdCBpcyB0b28gc21hbGwiCiBtc2dzdHIgIm11bHRpLXBhY2staW5kZXggbMawdSB0cuG7ryBt4buZdCBraG/huqNuZyBiw7kgNjQtYsOtdCwgbmjGsG5nIG9mZl90IGzDoCBxdcOhIG5o4buPIgogCi0jOiBtaWR4LmM6Mjg5CisjOiBtaWR4LmM6Mjg4CiBtc2dpZCAiZXJyb3IgcHJlcGFyaW5nIHBhY2tmaWxlIGZyb20gbXVsdGktcGFjay1pbmRleCIKIG1zZ3N0ciAibOG7l2kgY2h14bqpbiBi4buLIHThuq1wIHRpbiBnw7NpIHThu6sgbXVsdGktcGFjay1pbmRleCIKIAotIzogbWlkeC5jOjQ3MAorIzogbWlkeC5jOjQ2OQogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gYWRkIHBhY2tmaWxlICclcyciCiBtc2dzdHIgImfhurdwIGzhu5dpIGtoaSB0aMOqbSB04bqtcCB0aW4gZ8OzaSDigJwlc+KAnSIKIAotIzogbWlkeC5jOjQ3NgorIzogbWlkeC5jOjQ3NQogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gb3BlbiBwYWNrLWluZGV4ICclcyciCiBtc2dzdHIgImfhurdwIGzhu5dpIGtoaSBt4bufIHBhY2staW5kZXgg4oCcJXPigJ0iCiAKLSM6IG1pZHguYzo1MzYKKyM6IG1pZHguYzo1MzUKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIGxvY2F0ZSBvYmplY3QgJWQgaW4gcGFja2ZpbGUiCiBtc2dzdHIgImfhurdwIGzhu5dpIGtoaSBwaMOibiBi4buVIMSR4buRaSB0xrDhu6NuZyDigJwlZOKAnSB0cm9uZyB04bqtcCB0aW4gZ8OzaSIKIAotIzogbWlkeC5jOjg2NQorIzogbWlkeC5jOjg2NAogIywgYy1mb3JtYXQKIG1zZ2lkICJkaWQgbm90IHNlZSBwYWNrLWZpbGUgJXMgdG8gZHJvcCIKIG1zZ3N0ciAixJHDoyBraMO0bmcgdGjhuqV5IHThuq1wIHRpbiBnw7NpICVzIMSR4buDIG3DoCB4w7NhIgogCi0jOiBtaWR4LmM6MTAzNgorIzogbWlkeC5jOjEwMzUKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIGNsZWFyIG11bHRpLXBhY2staW5kZXggYXQgJXMiCiBtc2dzdHIgImfhurdwIGzhu5dpIGtoaSB4w7NhIG11bHRpLXBhY2staW5kZXggdOG6oWkgJXMiCiAKLSM6IG1pZHguYzoxMDkxCisjOiBtaWR4LmM6MTA5MAogbXNnaWQgIkxvb2tpbmcgZm9yIHJlZmVyZW5jZWQgcGFja2ZpbGVzIgogbXNnc3RyICLEkGFuZyBraMOzYSBjaG8gY8OhYyBnw7NpIGLhu4sgdGhhbSBjaGnhur91IgogCi0jOiBtaWR4LmM6MTEwNgorIzogbWlkeC5jOjExMDUKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIm9pZCBmYW5vdXQgb3V0IG9mIG9yZGVyOiBmYW5vdXRbJWRdID0gJTxQUkl4MzI+ID4gJTxQUkl4MzI+ID0gZmFub3V0WyVkXSIKIG1zZ3N0ciAiZmFub3V0IGPFqSBzYWkgdGjhu6kgdOG7sTogZmFub3V0WyVkXSA9ICU8UFJJeDMyPiA+ICU8UFJJeDMyPiA9IGZhbm91dFslZF0iCiAKLSM6IG1pZHguYzoxMTEwCisjOiBtaWR4LmM6MTEwOQogbXNnaWQgIlZlcmlmeWluZyBPSUQgb3JkZXIgaW4gTUlEWCIKIG1zZ3N0ciAiVGjhuqltIHRyYSB0aOG7qSB04buxIE9JRCB0cm9uZyBNSURYIgogCi0jOiBtaWR4LmM6MTExOQorIzogbWlkeC5jOjExMTgKICMsIGMtZm9ybWF0CiBtc2dpZCAib2lkIGxvb2t1cCBvdXQgb2Ygb3JkZXI6IG9pZFslZF0gPSAlcyA+PSAlcyA9IG9pZFslZF0iCiBtc2dzdHIgImxvb2t1cCBjxakgc2FpIHRo4bupIHThu7E6IG9pZFslZF0gPSAlcyA+PSAlcyA9IG9pZFslZF0iCiAKLSM6IG1pZHguYzoxMTM4CisjOiBtaWR4LmM6MTEzNwogbXNnaWQgIlNvcnRpbmcgb2JqZWN0cyBieSBwYWNrZmlsZSIKIG1zZ3N0ciAixJBhbmcgc+G6r3AgeOG6v3AgY8OhYyDEkeG7kWkgdMaw4bujbmcgdGhlbyB04bqtcCB0aW4gZ8OzaSIKIAotIzogbWlkeC5jOjExNDQKKyM6IG1pZHguYzoxMTQzCiBtc2dpZCAiVmVyaWZ5aW5nIG9iamVjdCBvZmZzZXRzIgogbXNnc3RyICLEkGFuZyB0aOG6qW0gdHJhIGPDoWMga2hv4bqjbmcgYsO5IMSR4buRaSB0xrDhu6NuZyIKIAotIzogbWlkeC5jOjExNjAKKyM6IG1pZHguYzoxMTU5CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBsb2FkIHBhY2sgZW50cnkgZm9yIG9pZFslZF0gPSAlcyIKIG1zZ3N0ciAiZ+G6t3AgbOG7l2kga2hpIHThuqNpIG3hu6VjIGfDs2kgY2hvIG9pZFslZF0gPSAlcyIKIAotIzogbWlkeC5jOjExNjYKKyM6IG1pZHguYzoxMTY1CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBsb2FkIHBhY2staW5kZXggZm9yIHBhY2tmaWxlICVzIgogbXNnc3RyICJn4bq3cCBs4buXaSBraGkgdOG6o2kgcGFjay1pbmRleCBjaG8gdOG6rXAgdGluIGfDs2kgJXMiCiAKLSM6IG1pZHguYzoxMTc1CisjOiBtaWR4LmM6MTE3NAogIywgYy1mb3JtYXQKIG1zZ2lkICJpbmNvcnJlY3Qgb2JqZWN0IG9mZnNldCBmb3Igb2lkWyVkXSA9ICVzOiAlPFBSSXg2ND4gIT0gJTxQUkl4NjQ+IgogbXNnc3RyICIiCiAia2hv4bqjbmcgYsO5IMSR4buRaSB0xrDhu6NuZyBraMO0bmcgxJHDum5nIGNobyBvaWRbJWRdID0gJXM6ICU8UFJJeDY0PiAhPSAlPFBSSXg2ND4iCiAKLSM6IG1pZHguYzoxMzUwCisjOiBtaWR4LmM6MTM0OQogbXNnaWQgImNvdWxkIG5vdCBzdGFydCBwYWNrLW9iamVjdHMiCiBtc2dzdHIgImtow7RuZyB0aOG7gyBs4bqleSB0aMO0bmcgdGluIHRo4buRbmcga8OqIHbhu4EgY8OhYyDEkeG7kWkgdMaw4bujbmcgZ8OzaSIKIAotIzogbWlkeC5jOjEzNjkKKyM6IG1pZHguYzoxMzY4CiBtc2dpZCAiY291bGQgbm90IGZpbmlzaCBwYWNrLW9iamVjdHMiCiBtc2dzdHIgImtow7RuZyB0aOG7gyBob8OgbiB0aGnhu4duIGPDoWMgxJHhu5FpIHTGsOG7o25nIGfDs2kiCiAKLSM6IG5hbWUtaGFzaC5jOjUzMgorIzogbmFtZS1oYXNoLmM6NTM3CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBjcmVhdGUgbGF6eV9kaXIgdGhyZWFkOiAlcyIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIHThuqFvIHR1eeG6v24gbGF6eV9kaXI6ICVzIgogCi0jOiBuYW1lLWhhc2guYzo1NTQKKyM6IG5hbWUtaGFzaC5jOjU1OQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gY3JlYXRlIGxhenlfbmFtZSB0aHJlYWQ6ICVzIgogbXNnc3RyICJraMO0bmcgdGjhu4MgdOG6oW8gdHV54bq/biBsYXp5X25hbWU6ICVzIgogCi0jOiBuYW1lLWhhc2guYzo1NjAKKyM6IG5hbWUtaGFzaC5jOjU2NQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gam9pbiBsYXp5X25hbWUgdGhyZWFkOiAlcyIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIGdpYSBuaOG6rXAgdHV54bq/biBsYXp5X25hbWU6ICVzIgpAQCAtNDI1MCw0MSArNDI3NSw0MSBAQAogbXNnaWQgIkJhZCAlcyB2YWx1ZTogJyVzJyIKIG1zZ3N0ciAiR2nDoSB0cuG7iyAlcyBzYWk6IOKAnCVz4oCdIgogCi0jOiBvYmplY3QuYzo1NAorIzogb2JqZWN0LmM6NTMKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBvYmplY3QgdHlwZSBcIiVzXCIiCiBtc2dzdHIgImtp4buDdSDEkeG7kWkgdMaw4bujbmcgXCIlc1wiIGtow7RuZyBo4bujcCBs4buHIgogCi0jOiBvYmplY3QuYzoxNzQKKyM6IG9iamVjdC5jOjE3MwogIywgYy1mb3JtYXQKIG1zZ2lkICJvYmplY3QgJXMgaXMgYSAlcywgbm90IGEgJXMiCiBtc2dzdHIgIsSR4buRaSB0xrDhu6NuZyAlcyBsw6AgbeG7mXQgJXMsIGtow7RuZyBwaOG6o2kgbMOgIG3hu5l0ICVzIgogCi0jOiBvYmplY3QuYzoyMzQKKyM6IG9iamVjdC5jOjIzMwogIywgYy1mb3JtYXQKIG1zZ2lkICJvYmplY3QgJXMgaGFzIHVua25vd24gdHlwZSBpZCAlZCIKIG1zZ3N0ciAixJHhu5FpIHTGsOG7o25nICVzIGPDsyBtw6Mga2nhu4N1ICVkIGNoxrBhIGJp4bq/dCIKIAotIzogb2JqZWN0LmM6MjQ3CisjOiBvYmplY3QuYzoyNDYKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHBhcnNlIG9iamVjdDogJXMiCiBtc2dzdHIgImtow7RuZyB0aOG7gyBwaMOibiB0w61jaCDEkeG7kWkgdMaw4bujbmc6IOKAnCVz4oCdIgogCi0jOiBvYmplY3QuYzoyNjcgb2JqZWN0LmM6Mjc4CisjOiBvYmplY3QuYzoyNjYgb2JqZWN0LmM6Mjc3CiAjLCBjLWZvcm1hdAogbXNnaWQgImhhc2ggbWlzbWF0Y2ggJXMiCiBtc2dzdHIgIm3DoyBixINtIGtow7RuZyBraOG7m3AgJXMiCiAKLSM6IHBhY2tmaWxlLmM6NjQ4CisjOiBwYWNrZmlsZS5jOjY0MQogbXNnaWQgIm9mZnNldCBiZWZvcmUgZW5kIG9mIHBhY2tmaWxlIChicm9rZW4gLmlkeD8pIgogbXNnc3RyICJ24buLIHRyw60gdMawxqFuZyDEkeG7kWkgdHLGsOG7m2MgxJFp4buDbSBr4bq/dCB0aMO6YyBj4bunYSB04bqtcCB0aW4gZ8OzaSAoLmlkeCBo4buPbmcgw6A/KSIKIAotIzogcGFja2ZpbGUuYzoxODk5CisjOiBwYWNrZmlsZS5jOjE4ODcKICMsIGMtZm9ybWF0CiBtc2dpZCAib2Zmc2V0IGJlZm9yZSBzdGFydCBvZiBwYWNrIGluZGV4IGZvciAlcyAoY29ycnVwdCBpbmRleD8pIgogbXNnc3RyICJ24buLIHRyw60gdMawxqFuZyDEkeG7kWkgbuG6sW0gdHLGsOG7m2MgY2jhu4kgbeG7pWMgZ8OzaSBjaG8gJXMgKG3hu6VjIGzhu6VjIGLhu4sgaOG7j25nIMOgPykiCiAKLSM6IHBhY2tmaWxlLmM6MTkwMworIzogcGFja2ZpbGUuYzoxODkxCiAjLCBjLWZvcm1hdAogbXNnaWQgIm9mZnNldCBiZXlvbmQgZW5kIG9mIHBhY2sgaW5kZXggZm9yICVzICh0cnVuY2F0ZWQgaW5kZXg/KSIKIG1zZ3N0ciAiIgpAQCAtNDMzMCwyNiArNDM1NSwyNiBAQAogbXNnaWQgImRpZCB5b3UgbWVhbiBgLS0lc2AgKHdpdGggdHdvIGRhc2hlcyA/KSIKIG1zZ3N0ciAiY8OzIHBo4bqjaSDDvSBi4bqhbiBsw6Ag4oCcLS0lc+KAnCAoduG7m2kgaGFpIGThuqV1IGfhuqFjaCBuZ2FuZz8pIgogCi0jOiBwYXJzZS1vcHRpb25zLmM6ODU5CisjOiBwYXJzZS1vcHRpb25zLmM6ODYwCiAjLCBjLWZvcm1hdAogbXNnaWQgInVua25vd24gb3B0aW9uIGAlcyciCiBtc2dzdHIgImtow7RuZyBoaeG7g3UgdMO5eSBjaOG7jW4g4oCcJXPigJ0iCiAKLSM6IHBhcnNlLW9wdGlvbnMuYzo4NjEKKyM6IHBhcnNlLW9wdGlvbnMuYzo4NjIKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5rbm93biBzd2l0Y2ggYCVjJyIKIG1zZ3N0ciAia2jDtG5nIGhp4buDdSB0w7l5IGNo4buNbiDigJwlY+KAnSIKIAotIzogcGFyc2Utb3B0aW9ucy5jOjg2MworIzogcGFyc2Utb3B0aW9ucy5jOjg2NAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmtub3duIG5vbi1hc2NpaSBvcHRpb24gaW4gc3RyaW5nOiBgJXMnIgogbXNnc3RyICJraMO0bmcgaGnhu4N1IHTDuXkgY2jhu41uIG5vbi1hc2NpaSB0cm9uZyBjaHXhu5dpOiDigJwlc+KAnSIKIAotIzogcGFyc2Utb3B0aW9ucy5jOjg4NworIzogcGFyc2Utb3B0aW9ucy5jOjg4OAogbXNnaWQgIi4uLiIKIG1zZ3N0ciAi4oCmIgogCi0jOiBwYXJzZS1vcHRpb25zLmM6OTA2CisjOiBwYXJzZS1vcHRpb25zLmM6OTA3CiAjLCBjLWZvcm1hdAogbXNnaWQgInVzYWdlOiAlcyIKIG1zZ3N0ciAiY8OhY2ggZMO5bmc6ICVzIgpAQCAtNDM1NywyMSArNDM4MiwyMSBAQAogIy4gVFJBTlNMQVRPUlM6IHRoZSBjb2xvbiBoZXJlIHNob3VsZCBhbGlnbiB3aXRoIHRoZQogIy4gb25lIGluICJ1c2FnZTogJXMiIHRyYW5zbGF0aW9uLgogIy4KLSM6IHBhcnNlLW9wdGlvbnMuYzo5MTIKKyM6IHBhcnNlLW9wdGlvbnMuYzo5MTMKICMsIGMtZm9ybWF0CiBtc2dpZCAiICAgb3I6ICVzIgogbXNnc3RyICIgICAgIGhv4bq3YzogJXMiCiAKLSM6IHBhcnNlLW9wdGlvbnMuYzo5MTUKKyM6IHBhcnNlLW9wdGlvbnMuYzo5MTYKICMsIGMtZm9ybWF0CiBtc2dpZCAiICAgICVzIgogbXNnc3RyICIgICAgJXMiCiAKLSM6IHBhcnNlLW9wdGlvbnMuYzo5NTQKKyM6IHBhcnNlLW9wdGlvbnMuYzo5NTUKIG1zZ2lkICItTlVNIgogbXNnc3RyICItU+G7kCIKIAotIzogcGFyc2Utb3B0aW9ucy5jOjk2OAorIzogcGFyc2Utb3B0aW9ucy5jOjk2OQogIywgYy1mb3JtYXQKIG1zZ2lkICJhbGlhcyBvZiAtLSVzIgogbXNnc3RyICJiw60gZGFuaCBj4bunYSAtLSVzIgpAQCAtNDU0MCwyOSArNDU2NSwzOCBAQAogbXNnaWQgInVuYWJsZSB0byBwYXJzZSAtLXByZXR0eSBmb3JtYXQiCiBtc2dzdHIgImtow7RuZyB0aOG7gyBwaMOibiB0w61jaCDEkeG7i25oIGThuqFuZyAtLXByZXR0eSIKIAotIzogcmFuZ2UtZGlmZi5jOjcwCisjOiBwcm9taXNvci1yZW1vdGUuYzoyNQorbXNnaWQgIlJlbW90ZSB3aXRoIG5vIFVSTCIKK21zZ3N0ciAiTcOheSBjaOG7pyBraMO0bmcgY8OzIMSR4buLYSBjaOG7iSBVUkwiCisKKyM6IHByb21pc29yLXJlbW90ZS5jOjYxCisjLCBjLWZvcm1hdAorbXNnaWQgInByb21pc29yIHJlbW90ZSBuYW1lIGNhbm5vdCBiZWdpbiB3aXRoICcvJzogJXMiCittc2dzdHIgInTDqm4gbcOheSBjaOG7pyBo4bupYSBo4bq5biBraMO0bmcgdGjhu4MgYuG6r3QgxJHhuqd1IGLhurFuZyAnLyc6ICVzIgorCisjOiByYW5nZS1kaWZmLmM6NzEKIG1zZ2lkICJjb3VsZCBub3Qgc3RhcnQgYGxvZ2AiCiBtc2dzdHIgImtow7RuZyB0aOG7gyBs4bqleSB0aMO0bmcgdGluIHRo4buRbmcga8OqIHbhu4Eg4oCcbG9n4oCcIgogCi0jOiByYW5nZS1kaWZmLmM6NzIKKyM6IHJhbmdlLWRpZmYuYzo3MwogbXNnaWQgImNvdWxkIG5vdCByZWFkIGBsb2dgIG91dHB1dCIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIMSR4buNYyBr4bq/dCB4deG6pXQg4oCcbG9n4oCdIgogCi0jOiByYW5nZS1kaWZmLmM6OTEgc2VxdWVuY2VyLmM6NTAyMQorIzogcmFuZ2UtZGlmZi5jOjkyIHNlcXVlbmNlci5jOjQ5ODUKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHBhcnNlIGNvbW1pdCAnJXMnIgogbXNnc3RyICJraMO0bmcgdGjhu4MgcGjDom4gdMOtY2ggbOG6p24gY2h1eeG7g24gZ2lhbyDigJwlc+KAnSIKIAotIzogcmFuZ2UtZGlmZi5jOjExNworIzogcmFuZ2UtZGlmZi5jOjExOAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcGFyc2UgZ2l0IGhlYWRlciAnJS4qcyciCiBtc2dzdHIgImtow7RuZyB0aOG7gyBwaMOibiB0w61jaCBjw7ogcGjDoXAgcGjhuqduIMSR4bqndSBnaXQg4oCcJS4qc+KAnSIKIAotIzogcmFuZ2UtZGlmZi5jOjI3NAorIzogcmFuZ2UtZGlmZi5jOjI3NQogbXNnaWQgImZhaWxlZCB0byBnZW5lcmF0ZSBkaWZmIgogbXNnc3RyICJn4bq3cCBs4buXaSBraGkgdOG6oW8ga2jDoWMgYmnhu4d0IgogCi0jOiByYW5nZS1kaWZmLmM6NTA2IHJhbmdlLWRpZmYuYzo1MDgKKyM6IHJhbmdlLWRpZmYuYzo1MDcgcmFuZ2UtZGlmZi5jOjUwOQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcGFyc2UgbG9nIGZvciAnJXMnIgogbXNnc3RyICJraMO0bmcgdGjhu4MgcGjDom4gdMOtY2ggbmjhuq10IGvDvSBjaG8g4oCcJXPigJ0iCkBAIC00NjA4LDExICs0NjQyLDExIEBACiBtc2dpZCAiJyVzJyBhcHBlYXJzIGFzIGJvdGggYSBmaWxlIGFuZCBhcyBhIGRpcmVjdG9yeSIKIG1zZ3N0ciAiJXMgY8OzIHbhursga2jDtG5nIHBo4bqjaSBsw6AgdOG6rXAgdGluIHbDoCBjxaluZyBjaOG6s25nIHBo4bqjaSBsw6AgbeG7mXQgdGjGsCBt4bulYyIKIAotIzogcmVhZC1jYWNoZS5jOjE0OTkKKyM6IHJlYWQtY2FjaGUuYzoxNTIwCiBtc2dpZCAiUmVmcmVzaCBpbmRleCIKIG1zZ3N0ciAiTMOgbSB0xrDGoWkgbeG7m2kgYuG6o25nIG3hu6VjIGzhu6VjIgogCi0jOiByZWFkLWNhY2hlLmM6MTYxMworIzogcmVhZC1jYWNoZS5jOjE2MzUKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogImluZGV4LnZlcnNpb24gc2V0LCBidXQgdGhlIHZhbHVlIGlzIGludmFsaWQuXG4iCkBAIC00NjIxLDcgKzQ2NTUsNyBAQAogImluZGV4LnZlcnNpb24gxJHGsOG7o2MgxJHhurd0LCBuaMawbmcgZ2nDoSB0cuG7iyBj4bunYSBuw7MgbOG6oWkga2jDtG5nIGjhu6NwIGzhu4cuXG4iCiAiRMO5bmcgcGhpw6puIGLhuqNuICVpIgogCi0jOiByZWFkLWNhY2hlLmM6MTYyMworIzogcmVhZC1jYWNoZS5jOjE2NDUKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkdJVF9JTkRFWF9WRVJTSU9OIHNldCwgYnV0IHRoZSB2YWx1ZSBpcyBpbnZhbGlkLlxuIgpAQCAtNDYzMCwxMzggKzQ2NjQsMTM4IEBACiAiR0lUX0lOREVYX1ZFUlNJT04gxJHGsOG7o2MgxJHhurd0LCBuaMawbmcgZ2nDoSB0cuG7iyBj4bunYSBuw7MgbOG6oWkga2jDtG5nIGjhu6NwIGzhu4cuXG4iCiAiRMO5bmcgcGhpw6puIGLhuqNuICVpIgogCi0jOiByZWFkLWNhY2hlLmM6MTY3OQorIzogcmVhZC1jYWNoZS5jOjE3MDEKICMsIGMtZm9ybWF0CiBtc2dpZCAiYmFkIHNpZ25hdHVyZSAweCUwOHgiCiBtc2dzdHIgImNo4buvIGvDvSBzYWkgMHglMDh4IgogCi0jOiByZWFkLWNhY2hlLmM6MTY4MgorIzogcmVhZC1jYWNoZS5jOjE3MDQKICMsIGMtZm9ybWF0CiBtc2dpZCAiYmFkIGluZGV4IHZlcnNpb24gJWQiCiBtc2dzdHIgInBoacOqbiBi4bqjbiBt4bulYyBs4bulYyBzYWkgJWQiCiAKLSM6IHJlYWQtY2FjaGUuYzoxNjkxCisjOiByZWFkLWNhY2hlLmM6MTcxMwogbXNnaWQgImJhZCBpbmRleCBmaWxlIHNoYTEgc2lnbmF0dXJlIgogbXNnc3RyICJjaOG7ryBrw70gZOG6oW5nIHNoYTEgY2hvIHThuq1wIHRpbiBt4bulYyBs4bulYyBraMO0bmcgxJHDum5nIgogCi0jOiByZWFkLWNhY2hlLmM6MTcyMQorIzogcmVhZC1jYWNoZS5jOjE3NDMKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW5kZXggdXNlcyAlLjRzIGV4dGVuc2lvbiwgd2hpY2ggd2UgZG8gbm90IHVuZGVyc3RhbmQiCiBtc2dzdHIgIm3hu6VjIGzhu6VjIGTDuW5nIHBo4bqnbiBt4bufIHLhu5luZyAlLjRzLCBjw6FpIG3DoCBjaMO6bmcgdMO0aSBraMO0bmcgaGnhu4N1IMSRxrDhu6NjIgogCi0jOiByZWFkLWNhY2hlLmM6MTcyMworIzogcmVhZC1jYWNoZS5jOjE3NDUKICMsIGMtZm9ybWF0CiBtc2dpZCAiaWdub3JpbmcgJS40cyBleHRlbnNpb24iCiBtc2dzdHIgIsSRYW5nIGzhu50gxJFpIHBo4bqnbiBt4bufIHLhu5luZyAlLjRzIgogCi0jOiByZWFkLWNhY2hlLmM6MTc2MAorIzogcmVhZC1jYWNoZS5jOjE3ODIKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5rbm93biBpbmRleCBlbnRyeSBmb3JtYXQgMHglMDh4IgogbXNnc3RyICJraMO0bmcgaGnhu4N1IMSR4buLbmggZOG6oW5nIG3hu6VjIGzhu6VjIDB4JTA4eCIKIAotIzogcmVhZC1jYWNoZS5jOjE3NzYKKyM6IHJlYWQtY2FjaGUuYzoxNzk4CiAjLCBjLWZvcm1hdAogbXNnaWQgIm1hbGZvcm1lZCBuYW1lIGZpZWxkIGluIHRoZSBpbmRleCwgbmVhciBwYXRoICclcyciCiBtc2dzdHIgInRyxrDhu51uZyB0w6puIHNhaSBz4bqhbmcgdHJvbmcgbeG7pWMgbOG7pWMsIGfhuqduIMSRxrDhu51uZyBk4bqrbiDigJwlc+KAnSIKIAotIzogcmVhZC1jYWNoZS5jOjE4MzMKKyM6IHJlYWQtY2FjaGUuYzoxODU1CiBtc2dpZCAidW5vcmRlcmVkIHN0YWdlIGVudHJpZXMgaW4gaW5kZXgiCiBtc2dzdHIgImPDoWMgbeG7pWMgdGluIHN0YWdlIGtow7RuZyDEkcO6bmcgdGjhu6kgdOG7sSB0cm9uZyBt4bulYyBs4bulYyIKIAotIzogcmVhZC1jYWNoZS5jOjE4MzYKKyM6IHJlYWQtY2FjaGUuYzoxODU4CiAjLCBjLWZvcm1hdAogbXNnaWQgIm11bHRpcGxlIHN0YWdlIGVudHJpZXMgZm9yIG1lcmdlZCBmaWxlICclcyciCiBtc2dzdHIgIm5oaeG7gXUgbeG7pWMgc3RhZ2UgY2hvIHThuq1wIHRpbiBow7JhIHRy4buZbiDigJwlc+KAnSIKIAotIzogcmVhZC1jYWNoZS5jOjE4MzkKKyM6IHJlYWQtY2FjaGUuYzoxODYxCiAjLCBjLWZvcm1hdAogbXNnaWQgInVub3JkZXJlZCBzdGFnZSBlbnRyaWVzIGZvciAnJXMnIgogbXNnc3RyICJjw6FjIG3hu6VjIHRpbiBzdGFnZSBraMO0bmcgxJHDum5nIHRo4bupIHThu7EgY2hvIOKAnCVz4oCdIgogCi0jOiByZWFkLWNhY2hlLmM6MTk0NiByZWFkLWNhY2hlLmM6MjIzNCByZXJlcmUuYzo1NjUgcmVyZXJlLmM6NTk5IHJlcmVyZS5jOjExMTEKLSM6IGJ1aWx0aW4vYWRkLmM6NDYwIGJ1aWx0aW4vY2hlY2staWdub3JlLmM6MTc4IGJ1aWx0aW4vY2hlY2tvdXQuYzo0NjcKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo2NTEgYnVpbHRpbi9jbGVhbi5jOjk1NiBidWlsdGluL2NvbW1pdC5jOjM0NworIzogcmVhZC1jYWNoZS5jOjE5NjcgcmVhZC1jYWNoZS5jOjIyNTUgcmVyZXJlLmM6NTY1IHJlcmVyZS5jOjU5OSByZXJlcmUuYzoxMTExCisjOiBidWlsdGluL2FkZC5jOjQ2MCBidWlsdGluL2NoZWNrLWlnbm9yZS5jOjE3OCBidWlsdGluL2NoZWNrb3V0LmM6NDY4CisjOiBidWlsdGluL2NoZWNrb3V0LmM6NjUyIGJ1aWx0aW4vY2xlYW4uYzo5NjcgYnVpbHRpbi9jb21taXQuYzozNDcKICM6IGJ1aWx0aW4vZGlmZi10cmVlLmM6MTIwIGJ1aWx0aW4vZ3JlcC5jOjQ5OSBidWlsdGluL212LmM6MTQ1CiAjOiBidWlsdGluL3Jlc2V0LmM6MjQ1IGJ1aWx0aW4vcm0uYzoyNzEgYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjMzMAogbXNnaWQgImluZGV4IGZpbGUgY29ycnVwdCIKIG1zZ3N0ciAidOG6rXAgdGluIGdoaSBi4bqjbmcgbeG7pWMgbOG7pWMgYuG7iyBo4buPbmciCiAKLSM6IHJlYWQtY2FjaGUuYzoyMDg3CisjOiByZWFkLWNhY2hlLmM6MjEwOAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gY3JlYXRlIGxvYWRfY2FjaGVfZW50cmllcyB0aHJlYWQ6ICVzIgogbXNnc3RyICJraMO0bmcgdGjhu4MgdOG6oW8gdHV54bq/biBsb2FkX2NhY2hlX2VudHJpZXM6ICVzIgogCi0jOiByZWFkLWNhY2hlLmM6MjEwMAorIzogcmVhZC1jYWNoZS5jOjIxMjEKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGpvaW4gbG9hZF9jYWNoZV9lbnRyaWVzIHRocmVhZDogJXMiCiBtc2dzdHIgImtow7RuZyB0aOG7gyBnaWEgbmjhuq1wIHR1eeG6v24gbG9hZF9jYWNoZV9lbnRyaWVzOiAlcyIKIAotIzogcmVhZC1jYWNoZS5jOjIxMzMKKyM6IHJlYWQtY2FjaGUuYzoyMTU0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiBpbmRleCBmaWxlIG9wZW4gZmFpbGVkIgogbXNnc3RyICIlczogbeG7nyB04bqtcCB0aW4gbeG7pWMgbOG7pWMgZ+G6t3AgbOG7l2kiCiAKLSM6IHJlYWQtY2FjaGUuYzoyMTM3CisjOiByZWFkLWNhY2hlLmM6MjE1OAogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogY2Fubm90IHN0YXQgdGhlIG9wZW4gaW5kZXgiCiBtc2dzdHIgIiVzOiBraMO0bmcgdGjhu4MgbOG6pXkgdGjhu5FuZyBrw6ogYuG6o25nIG3hu6VjIGzhu6VjIMSRw6MgbeG7nyIKIAotIzogcmVhZC1jYWNoZS5jOjIxNDEKKyM6IHJlYWQtY2FjaGUuYzoyMTYyCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiBpbmRleCBmaWxlIHNtYWxsZXIgdGhhbiBleHBlY3RlZCIKIG1zZ3N0ciAiJXM6IHThuq1wIHRpbiBt4bulYyBs4bulYyBuaOG7jyBoxqFuIG1vbmcgxJHhu6NpIgogCi0jOiByZWFkLWNhY2hlLmM6MjE0NQorIzogcmVhZC1jYWNoZS5jOjIxNjYKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXM6IHVuYWJsZSB0byBtYXAgaW5kZXggZmlsZSIKIG1zZ3N0ciAiJXM6IGtow7RuZyB0aOG7gyDDoW5oIHjhuqEgdOG6rXAgdGluIG3hu6VjIGzhu6VjIgogCi0jOiByZWFkLWNhY2hlLmM6MjE4NworIzogcmVhZC1jYWNoZS5jOjIyMDgKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGNyZWF0ZSBsb2FkX2luZGV4X2V4dGVuc2lvbnMgdGhyZWFkOiAlcyIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIHThuqFvIHR1eeG6v24gbG9hZF9pbmRleF9leHRlbnNpb25zOiAlcyIKIAotIzogcmVhZC1jYWNoZS5jOjIyMTQKKyM6IHJlYWQtY2FjaGUuYzoyMjM1CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBqb2luIGxvYWRfaW5kZXhfZXh0ZW5zaW9ucyB0aHJlYWQ6ICVzIgogbXNnc3RyICJraMO0bmcgdGjhu4MgZ2lhIG5o4bqtcCB0dXnhur9uIGxvYWRfaW5kZXhfZXh0ZW5zaW9uczogJXMiCiAKLSM6IHJlYWQtY2FjaGUuYzoyMjQ2CisjOiByZWFkLWNhY2hlLmM6MjI2NwogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgZnJlc2hlbiBzaGFyZWQgaW5kZXggJyVzJyIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIGzDoG0gdMawxqFpIG3hu5tpIG3hu6VjIGzhu6VjIMSRw6MgY2hpYSBz4bq7IOKAnCVz4oCdIgogCi0jOiByZWFkLWNhY2hlLmM6MjI5MworIzogcmVhZC1jYWNoZS5jOjIzMTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiYnJva2VuIGluZGV4LCBleHBlY3QgJXMgaW4gJXMsIGdvdCAlcyIKIG1zZ3N0ciAibeG7pWMgbOG7pWMgYuG7iyBo4buPbmcsIGPhuqduICVzIHRyb25nICVzLCBuaMawbmcgbOG6oWkgbmjhuq1uIMSRxrDhu6NjICVzIgogCi0jOiByZWFkLWNhY2hlLmM6Mjk4OSB3cmFwcGVyLmM6NjU4IGJ1aWx0aW4vbWVyZ2UuYzoxMTE0CisjOiByZWFkLWNhY2hlLmM6MzAxMCB3cmFwcGVyLmM6NjIyIGJ1aWx0aW4vbWVyZ2UuYzoxMTE5CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBjbG9zZSAnJXMnIgogbXNnc3RyICJraMO0bmcgdGjhu4MgxJHDs25nIOKAnCVz4oCdIgogCi0jOiByZWFkLWNhY2hlLmM6MzA5MiBzZXF1ZW5jZXIuYzoyMzU4IHNlcXVlbmNlci5jOjM5MjgKKyM6IHJlYWQtY2FjaGUuYzozMTEzIHNlcXVlbmNlci5jOjIyOTYgc2VxdWVuY2VyLmM6MzkxNwogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3Qgc3RhdCAnJXMnIgogbXNnc3RyICJraMO0bmcgdGjhu4MgbOG6pXkgdGjDtG5nIHRpbiB0aOG7kW5nIGvDqiB24buBIOKAnCVz4oCdIgogCi0jOiByZWFkLWNhY2hlLmM6MzEwNQorIzogcmVhZC1jYWNoZS5jOjMxMjYKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIG9wZW4gZ2l0IGRpcjogJXMiCiBtc2dzdHIgImtow7RuZyB0aOG7gyBt4bufIHRoxrAgbeG7pWMgZ2l0OiAlcyIKIAotIzogcmVhZC1jYWNoZS5jOjMxMTcKKyM6IHJlYWQtY2FjaGUuYzozMTM4CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byB1bmxpbms6ICVzIgogbXNnc3RyICJraMO0bmcgdGjhu4MgYuG7jyBsacOqbiBr4bq/dCAodW5saW5rKTog4oCcJXPigJ0iCiAKLSM6IHJlYWQtY2FjaGUuYzozMTQyCisjOiByZWFkLWNhY2hlLmM6MzE2MwogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgZml4IHBlcm1pc3Npb24gYml0cyBvbiAnJXMnIgogbXNnc3RyICJraMO0bmcgdGjhu4Mgc+G7rWEgY8OhYyBiw610IHBow6JuIHF1eeG7gW4gdHLDqm4g4oCcJXPigJ0iCiAKLSM6IHJlYWQtY2FjaGUuYzozMjkxCisjOiByZWFkLWNhY2hlLmM6MzMxMgogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogY2Fubm90IGRyb3AgdG8gc3RhZ2UgIzAiCiBtc2dzdHIgIiVzOiBraMO0bmcgdGjhu4MgeMOzYSBi4buPIHN0YWdlICMwIgpAQCAtNDg3MCw4ICs0OTA0LDggQEAKIG1zZ2lkICJOb3RlIHRoYXQgZW1wdHkgY29tbWl0cyBhcmUgY29tbWVudGVkIG91dCIKIG1zZ3N0ciAiQ2jDuiDDvSBy4bqxbmcgbOG6p24gY2h1eeG7g24gZ2lhbyB0cuG7kW5nIHLhu5duZyBsw6AgZ2hpIGNow7oiCiAKLSM6IHJlYmFzZS1pbnRlcmFjdGl2ZS5jOjEwNSByZXJlcmUuYzo0ODUgcmVyZXJlLmM6NjkyIHNlcXVlbmNlci5jOjM0NDcKLSM6IHNlcXVlbmNlci5jOjM0NzMgc2VxdWVuY2VyLmM6NTEyMCBidWlsdGluL2ZzY2suYzozNTYgYnVpbHRpbi9yZWJhc2UuYzoyMzUKKyM6IHJlYmFzZS1pbnRlcmFjdGl2ZS5jOjEwNSByZXJlcmUuYzo0ODUgcmVyZXJlLmM6NjkyIHNlcXVlbmNlci5jOjMzODgKKyM6IHNlcXVlbmNlci5jOjM0MTQgc2VxdWVuY2VyLmM6NTA4NCBidWlsdGluL2ZzY2suYzozNTYgYnVpbHRpbi9yZWJhc2UuYzoyMzUKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHdyaXRlICclcyciCiBtc2dzdHIgImtow7RuZyB0aOG7gyBnaGkg4oCcJXPigJ0iCkBAIC00OTE4LDcgKzQ5NTIsNyBAQAogbXNnaWQgImlnbm9yaW5nIGRhbmdsaW5nIHN5bXJlZiAlcyIKIG1zZ3N0ciAixJFhbmcgbOG7nSDEkWkgdGhhbSBjaGnhur91IG3hu4FtIHRo4burYSAlcyIKIAotIzogcmVmcy5jOjY2OSByZWYtZmlsdGVyLmM6MjA5MgorIzogcmVmcy5jOjY2OSByZWYtZmlsdGVyLmM6MjA5OAogIywgYy1mb3JtYXQKIG1zZ2lkICJpZ25vcmluZyBicm9rZW4gcmVmICVzIgogbXNnc3RyICLEkWFuZyBs4budIMSRaSB0aGFtIGNoaeG6v3UgaOG7j25nICVzIgpAQCAtNDk0MywxNCArNDk3NywxNCBAQAogbXNnaWQgInVuZXhwZWN0ZWQgb2JqZWN0IElEIHdoZW4gd3JpdGluZyAnJXMnIgogbXNnc3RyICJraMO0bmcgY+G6p24gSUQgxJHhu5FpIHTGsOG7o25nIGtoaSBnaGkg4oCcJXPigJ0iCiAKLSM6IHJlZnMuYzo4MzMgc2VxdWVuY2VyLmM6NDAzIHNlcXVlbmNlci5jOjI3MDkgc2VxdWVuY2VyLmM6MjkxMwotIzogc2VxdWVuY2VyLmM6MjkyNyBzZXF1ZW5jZXIuYzozMTg0IHNlcXVlbmNlci5jOjUwMzcgd3JhcHBlci5jOjY1NgorIzogcmVmcy5jOjgzMyBzZXF1ZW5jZXIuYzo0MDMgc2VxdWVuY2VyLmM6MjY0NyBzZXF1ZW5jZXIuYzoyODUxCisjOiBzZXF1ZW5jZXIuYzoyODY1IHNlcXVlbmNlci5jOjMxMjIgc2VxdWVuY2VyLmM6NTAwMSB3cmFwcGVyLmM6NjIwCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCB3cml0ZSB0byAnJXMnIgogbXNnc3RyICJraMO0bmcgdGjhu4MgZ2hpIHbDoG8g4oCcJXPigJ0iCiAKLSM6IHJlZnMuYzo4NjAgd3JhcHBlci5jOjIyNSB3cmFwcGVyLmM6Mzk1IGJ1aWx0aW4vYW0uYzo3MTUKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTAwMworIzogcmVmcy5jOjg2MCB3cmFwcGVyLmM6MTg4IHdyYXBwZXIuYzozNTggYnVpbHRpbi9hbS5jOjcxNAorIzogYnVpbHRpbi9yZWJhc2UuYzoxMDA0CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBvcGVuICclcycgZm9yIHdyaXRpbmciCiBtc2dzdHIgImtow7RuZyB0aOG7gyBt4bufIOKAnCVz4oCdIMSR4buDIGdoaSIKQEAgLTQ5ODUsMjEgKzUwMTksMjEgQEAKIG1zZ2lkICJ1cGRhdGVfcmVmIGZhaWxlZCBmb3IgcmVmICclcyc6ICVzIgogbXNnc3RyICJ1cGRhdGVfcmVmIGLhu4sgbOG7l2kgY2hvIHJlZiDigJwlc+KAnTogJXMiCiAKLSM6IHJlZnMuYzoyMDEyCisjOiByZWZzLmM6MjAyMwogIywgYy1mb3JtYXQKIG1zZ2lkICJtdWx0aXBsZSB1cGRhdGVzIGZvciByZWYgJyVzJyBub3QgYWxsb3dlZCIKIG1zZ3N0ciAia2jDtG5nIGNobyBwaMOpcCDEkWEgY+G6rXAgbmjhuq10IGNobyB0aGFtIGNoaeG6v3Ug4oCcJXPigJ0iCiAKLSM6IHJlZnMuYzoyMDQ0CisjOiByZWZzLmM6MjA1NQogbXNnaWQgInJlZiB1cGRhdGVzIGZvcmJpZGRlbiBpbnNpZGUgcXVhcmFudGluZSBlbnZpcm9ubWVudCIKIG1zZ3N0ciAiY+G6rXAgbmjhuq10IHRoYW0gY2hp4bq/dSBi4buLIGPhuqVtIHRyb25nIG3DtGkgdHLGsOG7nW5nIGtp4buDbSB0cmEiCiAKLSM6IHJlZnMuYzoyMTQwIHJlZnMuYzoyMTcwCisjOiByZWZzLmM6MjE1MSByZWZzLmM6MjE4MQogIywgYy1mb3JtYXQKIG1zZ2lkICInJXMnIGV4aXN0czsgY2Fubm90IGNyZWF0ZSAnJXMnIgogbXNnc3RyICLigJwlc+KAnSBz4bq1biBjw7M7IGtow7RuZyB0aOG7gyB04bqhbyDigJwlc+KAnSIKIAotIzogcmVmcy5jOjIxNDYgcmVmcy5jOjIxODEKKyM6IHJlZnMuYzoyMTU3IHJlZnMuYzoyMTkyCiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCBwcm9jZXNzICclcycgYW5kICclcycgYXQgdGhlIHNhbWUgdGltZSIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIHjhu60gbMO9IOKAnCVz4oCdIHbDoCDigJwlc+KAnSBjw7luZyBt4buZdCBsw7pjIgpAQCAtNTAwOSwxMyArNTA0MywxMyBAQAogbXNnaWQgImNvdWxkIG5vdCByZW1vdmUgcmVmZXJlbmNlICVzIgogbXNnc3RyICJraMO0bmcgdGjhu4MgZ+G7oSBi4buPIHRoYW0gY2hp4bq/dTogJXMiCiAKLSM6IHJlZnMvZmlsZXMtYmFja2VuZC5jOjEyNDggcmVmcy9wYWNrZWQtYmFja2VuZC5jOjE1MzIKLSM6IHJlZnMvcGFja2VkLWJhY2tlbmQuYzoxNTQyCisjOiByZWZzL2ZpbGVzLWJhY2tlbmQuYzoxMjQ4IHJlZnMvcGFja2VkLWJhY2tlbmQuYzoxNTQxCisjOiByZWZzL3BhY2tlZC1iYWNrZW5kLmM6MTU1MQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgZGVsZXRlIHJlZmVyZW5jZSAlczogJXMiCiBtc2dzdHIgImtow7RuZyB0aOG7gyB4w7NhIGLhu48gdGhhbSBjaGnhur91ICVzOiAlcyIKIAotIzogcmVmcy9maWxlcy1iYWNrZW5kLmM6MTI1MSByZWZzL3BhY2tlZC1iYWNrZW5kLmM6MTU0NQorIzogcmVmcy9maWxlcy1iYWNrZW5kLmM6MTI1MSByZWZzL3BhY2tlZC1iYWNrZW5kLmM6MTU1NAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgZGVsZXRlIHJlZmVyZW5jZXM6ICVzIgogbXNnc3RyICJraMO0bmcgdGjhu4MgeMOzYSBi4buPIHRoYW0gY2hp4bq/dTogJXMiCkBAIC01MDI1LDcgKzUwNTksNyBAQAogbXNnaWQgImludmFsaWQgcmVmc3BlYyAnJXMnIgogbXNnc3RyICJyZWZzcGVjIGtow7RuZyBo4bujcCBs4buHIOKAnCVz4oCdIgogCi0jOiByZWYtZmlsdGVyLmM6NDIgd3Qtc3RhdHVzLmM6MTkzNAorIzogcmVmLWZpbHRlci5jOjQyIHd0LXN0YXR1cy5jOjE5MzgKIG1zZ2lkICJnb25lIgogbXNnc3RyICLEkcOjIHJhIMSRaSIKIApAQCAtNTA0NCwxMjIgKzUwNzgsMTIyIEBACiBtc2dpZCAiYWhlYWQgJWQsIGJlaGluZCAlZCIKIG1zZ3N0ciAidHLGsOG7m2MgJWQsIHNhdSAlZCIKIAotIzogcmVmLWZpbHRlci5jOjE2MgorIzogcmVmLWZpbHRlci5jOjE2NQogIywgYy1mb3JtYXQKIG1zZ2lkICJleHBlY3RlZCBmb3JtYXQ6ICUlKGNvbG9yOjxjb2xvcj4pIgogbXNnc3RyICJj4bqnbiDEkeG7i25oIGThuqFuZzogJSUoY29sb3I6PGNvbG9yPikiCiAKLSM6IHJlZi1maWx0ZXIuYzoxNjQKKyM6IHJlZi1maWx0ZXIuYzoxNjcKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5yZWNvZ25pemVkIGNvbG9yOiAlJShjb2xvcjolcykiCiBtc2dzdHIgImtow7RuZyBuaOG6rW4gcmEgbcOgdTogJSUobcOgdTolcykiCiAKLSM6IHJlZi1maWx0ZXIuYzoxODYKKyM6IHJlZi1maWx0ZXIuYzoxODkKICMsIGMtZm9ybWF0CiBtc2dpZCAiSW50ZWdlciB2YWx1ZSBleHBlY3RlZCByZWZuYW1lOmxzdHJpcD0lcyIKIG1zZ3N0ciAiR2nDoSB0cuG7iyBuZ3V5w6puIGPhuqduIHTDqm4gdGhhbSBjaGnhur91OmxzdHJpcD0lcyIKIAotIzogcmVmLWZpbHRlci5jOjE5MAorIzogcmVmLWZpbHRlci5jOjE5MwogIywgYy1mb3JtYXQKIG1zZ2lkICJJbnRlZ2VyIHZhbHVlIGV4cGVjdGVkIHJlZm5hbWU6cnN0cmlwPSVzIgogbXNnc3RyICJHacOhIHRy4buLIG5ndXnDqm4gY+G6p24gdMOqbiB0aGFtIGNoaeG6v3U6cnN0cmlwPSVzIgogCi0jOiByZWYtZmlsdGVyLmM6MTkyCisjOiByZWYtZmlsdGVyLmM6MTk1CiAjLCBjLWZvcm1hdAogbXNnaWQgInVucmVjb2duaXplZCAlJSglcykgYXJndW1lbnQ6ICVzIgogbXNnc3RyICLEkeG7kWkgc+G7kSBraMO0bmcgxJHGsOG7o2MgdGjhu6thIG5o4bqtbiAlJSglcyk6ICVzIgogCi0jOiByZWYtZmlsdGVyLmM6MjQ3CisjOiByZWYtZmlsdGVyLmM6MjUwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiUlKG9iamVjdHR5cGUpIGRvZXMgbm90IHRha2UgYXJndW1lbnRzIgogbXNnc3RyICIlJShvYmplY3R0eXBlKSBraMO0bmcgbmjhuq1uIGPDoWMgxJHhu5FpIHPhu5EiCiAKLSM6IHJlZi1maWx0ZXIuYzoyNjkKKyM6IHJlZi1maWx0ZXIuYzoyNzIKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5yZWNvZ25pemVkICUlKG9iamVjdHNpemUpIGFyZ3VtZW50OiAlcyIKIG1zZ3N0ciAidGhhbSBz4buRIGtow7RuZyDEkcaw4bujYyB0aOG7q2Egbmjhuq1uICUlKG9iamVjdG5hbWUpOiAlcyIKIAotIzogcmVmLWZpbHRlci5jOjI3NworIzogcmVmLWZpbHRlci5jOjI4MAogIywgYy1mb3JtYXQKIG1zZ2lkICIlJShkZWx0YWJhc2UpIGRvZXMgbm90IHRha2UgYXJndW1lbnRzIgogbXNnc3RyICIlJShkZWx0YWJhc2UpIGtow7RuZyBuaOG6rW4gY8OhYyDEkeG7kWkgc+G7kSIKIAotIzogcmVmLWZpbHRlci5jOjI4OQorIzogcmVmLWZpbHRlci5jOjI5MgogIywgYy1mb3JtYXQKIG1zZ2lkICIlJShib2R5KSBkb2VzIG5vdCB0YWtlIGFyZ3VtZW50cyIKIG1zZ3N0ciAiJSUoYm9keSkga2jDtG5nIG5o4bqtbiBjw6FjIMSR4buRaSBz4buRIgogCi0jOiByZWYtZmlsdGVyLmM6Mjk4CisjOiByZWYtZmlsdGVyLmM6MzAxCiAjLCBjLWZvcm1hdAogbXNnaWQgIiUlKHN1YmplY3QpIGRvZXMgbm90IHRha2UgYXJndW1lbnRzIgogbXNnc3RyICIlJShzdWJqZWN0KSBraMO0bmcgbmjhuq1uIGPDoWMgxJHhu5FpIHPhu5EiCiAKLSM6IHJlZi1maWx0ZXIuYzozMjAKKyM6IHJlZi1maWx0ZXIuYzozMjMKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5rbm93biAlJSh0cmFpbGVycykgYXJndW1lbnQ6ICVzIgogbXNnc3RyICJraMO0bmcgaGnhu4N1IHRoYW0gc+G7kSAlJSh0cmFpbGVycyk6ICVzIgogCi0jOiByZWYtZmlsdGVyLmM6MzQ5CisjOiByZWYtZmlsdGVyLmM6MzUyCiAjLCBjLWZvcm1hdAogbXNnaWQgInBvc2l0aXZlIHZhbHVlIGV4cGVjdGVkIGNvbnRlbnRzOmxpbmVzPSVzIgogbXNnc3RyICJj4bqnbiBu4buZaSBkdW5nIG1hbmcgZ2nDoSB0cuG7iyBkxrDGoW5nOmxpbmVzPSVzIgogCi0jOiByZWYtZmlsdGVyLmM6MzUxCisjOiByZWYtZmlsdGVyLmM6MzU0CiAjLCBjLWZvcm1hdAogbXNnaWQgInVucmVjb2duaXplZCAlJShjb250ZW50cykgYXJndW1lbnQ6ICVzIgogbXNnc3RyICLEkeG7kWkgc+G7kSBraMO0bmcgxJHGsOG7o2MgdGjhu6thIG5o4bqtbiAlJShjb250ZW50cyk6ICVzIgogCi0jOiByZWYtZmlsdGVyLmM6MzY2CisjOiByZWYtZmlsdGVyLmM6MzY5CiAjLCBjLWZvcm1hdAogbXNnaWQgInBvc2l0aXZlIHZhbHVlIGV4cGVjdGVkIG9iamVjdG5hbWU6c2hvcnQ9JXMiCiBtc2dzdHIgImPhuqduIG7hu5lpIGR1bmcgbWFuZyBnacOhIHRy4buLIGTGsMahbmc6c2hvdD0lcyIKIAotIzogcmVmLWZpbHRlci5jOjM3MAorIzogcmVmLWZpbHRlci5jOjM3MwogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bnJlY29nbml6ZWQgJSUob2JqZWN0bmFtZSkgYXJndW1lbnQ6ICVzIgogbXNnc3RyICLEkeG7kWkgc+G7kSBraMO0bmcgxJHGsOG7o2MgdGjhu6thIG5o4bqtbiAlJShvYmplY3RuYW1lKTogJXMiCiAKLSM6IHJlZi1maWx0ZXIuYzo0MDAKKyM6IHJlZi1maWx0ZXIuYzo0MDMKICMsIGMtZm9ybWF0CiBtc2dpZCAiZXhwZWN0ZWQgZm9ybWF0OiAlJShhbGlnbjo8d2lkdGg+LDxwb3NpdGlvbj4pIgogbXNnc3RyICJj4bqnbiDEkeG7i25oIGThuqFuZzogJSUoYWxpZ246PHdpZHRoPiw8cG9zaXRpb24+KSIKIAotIzogcmVmLWZpbHRlci5jOjQxMgorIzogcmVmLWZpbHRlci5jOjQxNQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bnJlY29nbml6ZWQgcG9zaXRpb246JXMiCiBtc2dzdHIgInbhu4sgdHLDrSBraMO0bmcgxJHGsOG7o2MgdGjhu6thIG5o4bqtbjolcyIKIAotIzogcmVmLWZpbHRlci5jOjQxOQorIzogcmVmLWZpbHRlci5jOjQyMgogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bnJlY29nbml6ZWQgd2lkdGg6JXMiCiBtc2dzdHIgImNoaeG7gXUgcuG7mW5nIGtow7RuZyDEkcaw4bujYyB0aOG7q2Egbmjhuq1uOiVzIgogCi0jOiByZWYtZmlsdGVyLmM6NDI4CisjOiByZWYtZmlsdGVyLmM6NDMxCiAjLCBjLWZvcm1hdAogbXNnaWQgInVucmVjb2duaXplZCAlJShhbGlnbikgYXJndW1lbnQ6ICVzIgogbXNnc3RyICLEkeG7kWkgc+G7kSBraMO0bmcgxJHGsOG7o2MgdGjhu6thIG5o4bqtbiAlJShhbGlnbik6ICVzIgogCi0jOiByZWYtZmlsdGVyLmM6NDM2CisjOiByZWYtZmlsdGVyLmM6NDM5CiAjLCBjLWZvcm1hdAogbXNnaWQgInBvc2l0aXZlIHdpZHRoIGV4cGVjdGVkIHdpdGggdGhlICUlKGFsaWduKSBhdG9tIgogbXNnc3RyICJj4bqnbiBnacOhIHRy4buLIMSR4buZIHLhu5luZyBkxrDGoW5nIHbhu5tpIG5ndXnDqm4gdOG7rSAlJShhbGlnbikiCiAKLSM6IHJlZi1maWx0ZXIuYzo0NTQKKyM6IHJlZi1maWx0ZXIuYzo0NTcKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5yZWNvZ25pemVkICUlKGlmKSBhcmd1bWVudDogJXMiCiBtc2dzdHIgIsSR4buRaSBz4buRIGtow7RuZyDEkcaw4bujYyB0aOG7q2Egbmjhuq1uICUlKGlmKTogJXMiCiAKLSM6IHJlZi1maWx0ZXIuYzo1NTYKKyM6IHJlZi1maWx0ZXIuYzo1NTkKICMsIGMtZm9ybWF0CiBtc2dpZCAibWFsZm9ybWVkIGZpZWxkIG5hbWU6ICUuKnMiCiBtc2dzdHIgInTDqm4gdHLGsOG7nW5nIGThu4sgaMOsbmg6ICUuKnMiCiAKLSM6IHJlZi1maWx0ZXIuYzo1ODMKKyM6IHJlZi1maWx0ZXIuYzo1ODYKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5rbm93biBmaWVsZCBuYW1lOiAlLipzIgogbXNnc3RyICJraMO0bmcgaGnhu4N1IHTDqm4gdHLGsOG7nW5nOiAlLipzIgogCi0jOiByZWYtZmlsdGVyLmM6NTg3CisjOiByZWYtZmlsdGVyLmM6NTkwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJub3QgYSBnaXQgcmVwb3NpdG9yeSwgYnV0IHRoZSBmaWVsZCAnJS4qcycgcmVxdWlyZXMgYWNjZXNzIHRvIG9iamVjdCBkYXRhIgpAQCAtNTE2NywxNTkgKzUyMDEsMTU5IEBACiAia2jDtG5nIHBo4bqjaSBsw6AgbeG7mXQga2hvIGdpdCwgbmjGsG5nIHRyxrDhu51uZyDigJwlLipz4oCdIHnDqnUgY+G6p3UgdHJ1eSBj4bqtcCB2w6BvIGThu68gbGnhu4d1ICIKICLEkeG7kWkgdMaw4bujbmciCiAKLSM6IHJlZi1maWx0ZXIuYzo3MTEKKyM6IHJlZi1maWx0ZXIuYzo3MTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiZm9ybWF0OiAlJShpZikgYXRvbSB1c2VkIHdpdGhvdXQgYSAlJSh0aGVuKSBhdG9tIgogbXNnc3RyICLEkeG7i25oIGThuqFuZzogbmd1ecOqbiB04butICUlKGlmKSDEkcaw4bujYyBkw7luZyBtw6Aga2jDtG5nIGPDsyBuZ3V5w6puIHThu60gJSUodGhlbikiCiAKLSM6IHJlZi1maWx0ZXIuYzo3NzQKKyM6IHJlZi1maWx0ZXIuYzo3NzcKICMsIGMtZm9ybWF0CiBtc2dpZCAiZm9ybWF0OiAlJSh0aGVuKSBhdG9tIHVzZWQgd2l0aG91dCBhbiAlJShpZikgYXRvbSIKIG1zZ3N0ciAixJHhu4tuaCBk4bqhbmc6IG5ndXnDqm4gdOG7rSAlJSh0aGVuKSDEkcaw4bujYyBkw7luZyBtw6Aga2jDtG5nIGPDsyBuZ3V5w6puIHThu60gJSUoaWYpIgogCi0jOiByZWYtZmlsdGVyLmM6Nzc2CisjOiByZWYtZmlsdGVyLmM6Nzc5CiAjLCBjLWZvcm1hdAogbXNnaWQgImZvcm1hdDogJSUodGhlbikgYXRvbSB1c2VkIG1vcmUgdGhhbiBvbmNlIgogbXNnc3RyICLEkeG7i25oIGThuqFuZzogbmd1ecOqbiB04butICUlKHRoZW4pIMSRxrDhu6NjIGTDuW5nIG5oaeG7gXUgaMahbiBt4buZdCBs4bqnbiIKIAotIzogcmVmLWZpbHRlci5jOjc3OAorIzogcmVmLWZpbHRlci5jOjc4MQogIywgYy1mb3JtYXQKIG1zZ2lkICJmb3JtYXQ6ICUlKHRoZW4pIGF0b20gdXNlZCBhZnRlciAlJShlbHNlKSIKIG1zZ3N0ciAixJHhu4tuaCBk4bqhbmc6IG5ndXnDqm4gdOG7rSAlJSh0aGVuKSDEkcaw4bujYyBkw7luZyBzYXUgJSUoZWxzZSkiCiAKLSM6IHJlZi1maWx0ZXIuYzo4MDYKKyM6IHJlZi1maWx0ZXIuYzo4MDkKICMsIGMtZm9ybWF0CiBtc2dpZCAiZm9ybWF0OiAlJShlbHNlKSBhdG9tIHVzZWQgd2l0aG91dCBhbiAlJShpZikgYXRvbSIKIG1zZ3N0ciAixJHhu4tuaCBk4bqhbmc6IG5ndXnDqm4gdOG7rSAlJShlbHNlKSDEkcaw4bujYyBkw7luZyBtw6Aga2jDtG5nIGPDsyBuZ3V5w6puIHThu60gJSUoaWYpIgogCi0jOiByZWYtZmlsdGVyLmM6ODA4CisjOiByZWYtZmlsdGVyLmM6ODExCiAjLCBjLWZvcm1hdAogbXNnaWQgImZvcm1hdDogJSUoZWxzZSkgYXRvbSB1c2VkIHdpdGhvdXQgYSAlJSh0aGVuKSBhdG9tIgogbXNnc3RyICLEkeG7i25oIGThuqFuZzogbmd1ecOqbiB04butICUlKGVsc2UpIMSRxrDhu6NjIGTDuW5nIG3DoCBraMO0bmcgY8OzIG5ndXnDqm4gdOG7rSAlJSh0aGVuKSIKIAotIzogcmVmLWZpbHRlci5jOjgxMAorIzogcmVmLWZpbHRlci5jOjgxMwogIywgYy1mb3JtYXQKIG1zZ2lkICJmb3JtYXQ6ICUlKGVsc2UpIGF0b20gdXNlZCBtb3JlIHRoYW4gb25jZSIKIG1zZ3N0ciAixJHhu4tuaCBk4bqhbmc6IG5ndXnDqm4gdOG7rSAlJShlbHNlKSDEkcaw4bujYyBkw7luZyBuaGnhu4F1IGjGoW4gbeG7mXQgbOG6p24iCiAKLSM6IHJlZi1maWx0ZXIuYzo4MjUKKyM6IHJlZi1maWx0ZXIuYzo4MjgKICMsIGMtZm9ybWF0CiBtc2dpZCAiZm9ybWF0OiAlJShlbmQpIGF0b20gdXNlZCB3aXRob3V0IGNvcnJlc3BvbmRpbmcgYXRvbSIKIG1zZ3N0ciAixJHhu4tuaCBk4bqhbmc6IG5ndXnDqm4gdOG7rSAlJShlbmQpIMSRxrDhu6NjIGTDuW5nIG3DoCBraMO0bmcgY8OzIG5ndXnDqm4gdOG7rSB0xrDGoW5nIOG7qW5nIgogCi0jOiByZWYtZmlsdGVyLmM6ODgyCisjOiByZWYtZmlsdGVyLmM6ODg1CiAjLCBjLWZvcm1hdAogbXNnaWQgIm1hbGZvcm1lZCBmb3JtYXQgc3RyaW5nICVzIgogbXNnc3RyICJjaHXhu5dpIMSR4buLbmggZOG6oW5nIGThu4sgaMOsbmggJXMiCiAKLSM6IHJlZi1maWx0ZXIuYzoxNDg1CisjOiByZWYtZmlsdGVyLmM6MTQ4OAogIywgYy1mb3JtYXQKIG1zZ2lkICJubyBicmFuY2gsIHJlYmFzaW5nICVzIgogbXNnc3RyICJraMO0bmcgbmjDoW5oLCDEkWFuZyBj4bqjaSB04buVICVzIgogCi0jOiByZWYtZmlsdGVyLmM6MTQ4OAorIzogcmVmLWZpbHRlci5jOjE0OTEKICMsIGMtZm9ybWF0CiBtc2dpZCAibm8gYnJhbmNoLCByZWJhc2luZyBkZXRhY2hlZCBIRUFEICVzIgogbXNnc3RyICJraMO0bmcgbmjDoW5oLCDEkWFuZyBj4bqjaSB04buVIEhFQUQgJXMgxJHDoyB0w6FjaCBy4budaSIKIAotIzogcmVmLWZpbHRlci5jOjE0OTEKKyM6IHJlZi1maWx0ZXIuYzoxNDk0CiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vIGJyYW5jaCwgYmlzZWN0IHN0YXJ0ZWQgb24gJXMiCiBtc2dzdHIgImtow7RuZyBuaMOhbmgsIGRpIGNodXnhu4NuIG7hu61hIGLGsOG7m2MgxJHGsOG7o2MgYuG6r3QgxJHhuqd1IHThuqFpICVzIgogCi0jOiByZWYtZmlsdGVyLmM6MTUwMQorIzogcmVmLWZpbHRlci5jOjE1MDQKIG1zZ2lkICJubyBicmFuY2giCiBtc2dzdHIgImtow7RuZyBuaMOhbmgiCiAKLSM6IHJlZi1maWx0ZXIuYzoxNTM3IHJlZi1maWx0ZXIuYzoxNzQzCisjOiByZWYtZmlsdGVyLmM6MTU0MCByZWYtZmlsdGVyLmM6MTc0OQogIywgYy1mb3JtYXQKIG1zZ2lkICJtaXNzaW5nIG9iamVjdCAlcyBmb3IgJXMiCiBtc2dzdHIgInRoaeG6v3UgxJHhu5FpIHTGsOG7o25nICVzIGNobyAlcyIKIAotIzogcmVmLWZpbHRlci5jOjE1NDcKKyM6IHJlZi1maWx0ZXIuYzoxNTUwCiAjLCBjLWZvcm1hdAogbXNnaWQgInBhcnNlX29iamVjdF9idWZmZXIgZmFpbGVkIG9uICVzIGZvciAlcyIKIG1zZ3N0ciAicGFyc2Vfb2JqZWN0X2J1ZmZlciBn4bq3cCBs4buXaSB0csOqbiAlcyBjaG8gJXMiCiAKLSM6IHJlZi1maWx0ZXIuYzoxOTk4CisjOiByZWYtZmlsdGVyLmM6MjAwNAogIywgYy1mb3JtYXQKIG1zZ2lkICJtYWxmb3JtZWQgb2JqZWN0IGF0ICclcyciCiBtc2dzdHIgIsSR4buRaSB0xrDhu6NuZyBk4buLIGjDrG5oIHThuqFpIOKAnCVz4oCdIgogCi0jOiByZWYtZmlsdGVyLmM6MjA4NworIzogcmVmLWZpbHRlci5jOjIwOTMKICMsIGMtZm9ybWF0CiBtc2dpZCAiaWdub3JpbmcgcmVmIHdpdGggYnJva2VuIG5hbWUgJXMiCiBtc2dzdHIgIsSRYW5nIGzhu50gxJFpIHRoYW0gY2hp4bq/dSB24bubaSB0w6puIGjhu49uZyAlcyIKIAotIzogcmVmLWZpbHRlci5jOjIzODIKKyM6IHJlZi1maWx0ZXIuYzoyMzg5CiAjLCBjLWZvcm1hdAogbXNnaWQgImZvcm1hdDogJSUoZW5kKSBhdG9tIG1pc3NpbmciCiBtc2dzdHIgIsSR4buLbmggZOG6oW5nOiB0aGnhur91IG5ndXnDqm4gdOG7rSAlJShlbmQpIgogCi0jOiByZWYtZmlsdGVyLmM6MjQ4MgorIzogcmVmLWZpbHRlci5jOjI0ODkKICMsIGMtZm9ybWF0CiBtc2dpZCAib3B0aW9uIGAlcycgaXMgaW5jb21wYXRpYmxlIHdpdGggLS1tZXJnZWQiCiBtc2dzdHIgInTDuXkgY2jhu41uIOKAnCVz4oCdIGzDoCB4dW5nIGto4bqvYyB24bubaSB0w7l5IGNo4buNbiAtLW1lcmdlZCIKIAotIzogcmVmLWZpbHRlci5jOjI0ODUKKyM6IHJlZi1maWx0ZXIuYzoyNDkyCiAjLCBjLWZvcm1hdAogbXNnaWQgIm9wdGlvbiBgJXMnIGlzIGluY29tcGF0aWJsZSB3aXRoIC0tbm8tbWVyZ2VkIgogbXNnc3RyICJ0w7l5IGNo4buNbiDigJwlc+KAnSBsw6AgeHVuZyBraOG6r2MgduG7m2kgdMO5eSBjaOG7jW4gLS1uby1tZXJnZWQiCiAKLSM6IHJlZi1maWx0ZXIuYzoyNDk1CisjOiByZWYtZmlsdGVyLmM6MjUwMgogIywgYy1mb3JtYXQKIG1zZ2lkICJtYWxmb3JtZWQgb2JqZWN0IG5hbWUgJXMiCiBtc2dzdHIgInTDqm4gxJHhu5FpIHTGsOG7o25nIGThu4sgaMOsbmggJXMiCiAKLSM6IHJlZi1maWx0ZXIuYzoyNTAwCisjOiByZWYtZmlsdGVyLmM6MjUwNwogIywgYy1mb3JtYXQKIG1zZ2lkICJvcHRpb24gYCVzJyBtdXN0IHBvaW50IHRvIGEgY29tbWl0IgogbXNnc3RyICJ0w7l5IGNo4buNbiDigJwlc+KAnSBwaOG6o2kgY2jhu4kgxJHhur9uIG3hu5l0IGzhuqduIGNodXnhu4NuIGdpYW8iCiAKLSM6IHJlbW90ZS5jOjM2MworIzogcmVtb3RlLmM6MzY2CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvbmZpZyByZW1vdGUgc2hvcnRoYW5kIGNhbm5vdCBiZWdpbiB3aXRoICcvJzogJXMiCiBtc2dzdHIgImPhuqV1IGjDrG5oIHZp4bq/dCB04bqvdCBtw6F5IGNo4bunIGtow7RuZyB0aOG7gyBi4bqvdCDEkeG6p3UgYuG6sW5nIOKAnC/igJ06ICVzIgogCi0jOiByZW1vdGUuYzo0MTAKKyM6IHJlbW90ZS5jOjQxMwogbXNnaWQgIm1vcmUgdGhhbiBvbmUgcmVjZWl2ZXBhY2sgZ2l2ZW4sIHVzaW5nIHRoZSBmaXJzdCIKIG1zZ3N0ciAixJHDoyDEkcawYSByYSBuaGnhu4F1IGjGoW4gbeG7mXQgZ8OzaSBuaOG6rW4gduG7gSwgxJFhbmcgc+G7rSBk4bulbmcgY8OhaSDEkeG6p3UgdGnDqm4iCiAKLSM6IHJlbW90ZS5jOjQxOAorIzogcmVtb3RlLmM6NDIxCiBtc2dpZCAibW9yZSB0aGFuIG9uZSB1cGxvYWRwYWNrIGdpdmVuLCB1c2luZyB0aGUgZmlyc3QiCiBtc2dzdHIgIsSRw6MgxJHGsGEgcmEgbmhp4buBdSBoxqFuIG3hu5l0IGfDs2kgdOG6o2kgbMOqbiwgxJFhbmcgc+G7rSBk4bulbmcgY8OhaSDEkeG6p3UgdGnDqm4iCiAKLSM6IHJlbW90ZS5jOjYwOAorIzogcmVtb3RlLmM6NjExCiAjLCBjLWZvcm1hdAogbXNnaWQgIkNhbm5vdCBmZXRjaCBib3RoICVzIGFuZCAlcyB0byAlcyIKIG1zZ3N0ciAiS2jDtG5nIHRo4buDIGzhuqV5IHbhu4EgY+G6oyAlcyB2w6AgJXMgY2hvICVzIgogCi0jOiByZW1vdGUuYzo2MTIKKyM6IHJlbW90ZS5jOjYxNQogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyB1c3VhbGx5IHRyYWNrcyAlcywgbm90ICVzIgogbXNnc3RyICIlcyB0aMaw4budbmcgdGhlbyBkw7VpICVzLCBraMO0bmcgcGjhuqNpICVzIgogCi0jOiByZW1vdGUuYzo2MTYKKyM6IHJlbW90ZS5jOjYxOQogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyB0cmFja3MgYm90aCAlcyBhbmQgJXMiCiBtc2dzdHIgIiVzIHRoZW8gZMO1aSBj4bqjICVzIHbDoCAlcyIKIAotIzogcmVtb3RlLmM6Njg0CisjOiByZW1vdGUuYzo2ODcKICMsIGMtZm9ybWF0CiBtc2dpZCAia2V5ICclcycgb2YgcGF0dGVybiBoYWQgbm8gJyonIgogbXNnc3RyICJraMOzYSDigJwlc+KAnSBj4bunYSBt4bqrdSBrIGPDsyDigJwq4oCdIgogCi0jOiByZW1vdGUuYzo2OTQKKyM6IHJlbW90ZS5jOjY5NwogIywgYy1mb3JtYXQKIG1zZ2lkICJ2YWx1ZSAnJXMnIG9mIHBhdHRlcm4gaGFzIG5vICcqJyIKIG1zZ3N0ciAiZ2nDoSB0cuG7iyDigJwlc+KAnSBj4bunYSBt4bqrdSBrIGPDsyDigJwq4oCdIgogCi0jOiByZW1vdGUuYzoxMDAwCisjOiByZW1vdGUuYzoxMDAzCiAjLCBjLWZvcm1hdAogbXNnaWQgInNyYyByZWZzcGVjICVzIGRvZXMgbm90IG1hdGNoIGFueSIKIG1zZ3N0ciAicmVmc3BlYyAlcyBuZ3Xhu5NuIGtow7RuZyBraOG7m3AgYuG6pXQga+G7syBjw6FpIGfDrCIKIAotIzogcmVtb3RlLmM6MTAwNQorIzogcmVtb3RlLmM6MTAwOAogIywgYy1mb3JtYXQKIG1zZ2lkICJzcmMgcmVmc3BlYyAlcyBtYXRjaGVzIG1vcmUgdGhhbiBvbmUiCiBtc2dzdHIgInJlZnNwZWMgJXMgbmd14buTbiBraOG7m3Agbmhp4buBdSBoxqFuIG3hu5l0IgpAQCAtNTMyOCw3ICs1MzYyLDcgQEAKICMuIDxyZW1vdGU+IDxzcmM+Ojxkc3Q+IiBwdXNoLCBhbmQgImJlaW5nIHB1c2hlZCAoJyVzJykiIGlzCiAjLiB0aGUgPHNyYz4uCiAjLgotIzogcmVtb3RlLmM6MTAyMAorIzogcmVtb3RlLmM6MTAyMwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiVGhlIGRlc3RpbmF0aW9uIHlvdSBwcm92aWRlZCBpcyBub3QgYSBmdWxsIHJlZm5hbWUgKGkuZS4sXG4iCkBAIC01MzUzLDcgKzUzODcsNyBAQAogIk7hur91IGPhuqMgaGFpIGzDoCBraMO0bmcgdGjhu4MsIHRow6wgY2jDum5nIHTDtGkgY8WpbmcgY2jhu4t1IHRodWEuIELhuqFuIHBo4bqjaSBkw7luZyB0aGFtICIKICJjaGnhur91IGThuqFuZyDEkeG6p3kgxJHhu6cuIgogCi0jOiByZW1vdGUuYzoxMDQwCisjOiByZW1vdGUuYzoxMDQzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgPHNyYz4gcGFydCBvZiB0aGUgcmVmc3BlYyBpcyBhIGNvbW1pdCBvYmplY3QuXG4iCkBAIC01MzY0LDcgKzUzOTgsNyBAQAogIkPDsyBwaOG6o2kgw70gYuG6oW4gbMOgIG3hu5l0IHThuqFvIG3hu5l0IG5ow6FuaCBt4bubaSBi4bqxbmcgY8OhY2ggxJHhuql5IGzDqm5cbiIKICLigJwlczpyZWZzL2hlYWRzLyVz4oCdPyIKIAotIzogcmVtb3RlLmM6MTA0NQorIzogcmVtb3RlLmM6MTA0OAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiVGhlIDxzcmM+IHBhcnQgb2YgdGhlIHJlZnNwZWMgaXMgYSB0YWcgb2JqZWN0LlxuIgpAQCAtNTM3NSw3ICs1NDA5LDcgQEAKICJDw7MgcGjhuqNpIMO9IGLhuqFuIGzDoCBt4buZdCB04bqhbyBt4buZdCB0aOG6uyBt4bubaSBi4bqxbmcgY8OhY2ggxJHhuql5IGzDqm5cbiIKICLigJwlczpyZWZzL3RhZ3MvJXPigJ0/IgogCi0jOiByZW1vdGUuYzoxMDUwCisjOiByZW1vdGUuYzoxMDUzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgPHNyYz4gcGFydCBvZiB0aGUgcmVmc3BlYyBpcyBhIHRyZWUgb2JqZWN0LlxuIgpAQCAtNTM4Niw3ICs1NDIwLDcgQEAKICJDw7MgcGjhuqNpIMO9IGLhuqFuIGzDoCBt4buZdCB04bqhbyBt4buZdCBjw6J5IG3hu5tpIGLhurFuZyBjw6FjaCDEkeG6qXkgbMOqblxuIgogIuKAnCVzOnJlZnMvdGFncy8lc+KAnT8iCiAKLSM6IHJlbW90ZS5jOjEwNTUKKyM6IHJlbW90ZS5jOjEwNTgKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlRoZSA8c3JjPiBwYXJ0IG9mIHRoZSByZWZzcGVjIGlzIGEgYmxvYiBvYmplY3QuXG4iCkBAIC01Mzk3LDExNSArNTQzMSwxMTUgQEAKICJDw7MgcGjhuqNpIMO9IGLhuqFuIGzDoCBt4buZdCB04bqhbyBt4buZdCBibG9iIG3hu5tpIGLhurFuZyBjw6FjaCDEkeG6qXkgbMOqblxuIgogIuKAnCVzOnJlZnMvdGFncy8lc+KAnT8iCiAKLSM6IHJlbW90ZS5jOjEwOTEKKyM6IHJlbW90ZS5jOjEwOTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgY2Fubm90IGJlIHJlc29sdmVkIHRvIGJyYW5jaCIKIG1zZ3N0ciAi4oCcJXPigJ0ga2jDtG5nIHRo4buDIMSRxrDhu6NjIHBow6JuIGdp4bqjaSB0aMOgbmggbmjDoW5oIgogCi0jOiByZW1vdGUuYzoxMTAyCisjOiByZW1vdGUuYzoxMTA1CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBkZWxldGUgJyVzJzogcmVtb3RlIHJlZiBkb2VzIG5vdCBleGlzdCIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIHjDs2Eg4oCcJXPigJ06IHRoYW0gY2hp4bq/dSB0csOqbiBtw6F5IGNo4bunIGtow7RuZyB04buTbiB04bqhaSIKIAotIzogcmVtb3RlLmM6MTExNAorIzogcmVtb3RlLmM6MTExNwogIywgYy1mb3JtYXQKIG1zZ2lkICJkc3QgcmVmc3BlYyAlcyBtYXRjaGVzIG1vcmUgdGhhbiBvbmUiCiBtc2dzdHIgImRzdCByZWZzcGVjICVzIGto4bubcCBuaGnhu4F1IGjGoW4gbeG7mXQiCiAKLSM6IHJlbW90ZS5jOjExMjEKKyM6IHJlbW90ZS5jOjExMjQKICMsIGMtZm9ybWF0CiBtc2dpZCAiZHN0IHJlZiAlcyByZWNlaXZlcyBmcm9tIG1vcmUgdGhhbiBvbmUgc3JjIgogbXNnc3RyICJkc3QgcmVmICVzIG5o4bqtbiB04burIGjGoW4gbeG7mXQgbmd14buTbiIKIAotIzogcmVtb3RlLmM6MTYyNCByZW1vdGUuYzoxNzI1CisjOiByZW1vdGUuYzoxNjI3IHJlbW90ZS5jOjE3MjgKIG1zZ2lkICJIRUFEIGRvZXMgbm90IHBvaW50IHRvIGEgYnJhbmNoIgogbXNnc3RyICJIRUFEIGtow7RuZyBjaOG7iSDEkeG6v24gbeG7mXQgbmjDoW5oIG7DoG8gY+G6oyIKIAotIzogcmVtb3RlLmM6MTYzMworIzogcmVtb3RlLmM6MTYzNgogIywgYy1mb3JtYXQKIG1zZ2lkICJubyBzdWNoIGJyYW5jaDogJyVzJyIKIG1zZ3N0ciAia2jDtG5nIGPDsyBuaMOhbmggbsOgbyBuaMawIHRo4bq/OiDigJwlc+KAnSIKIAotIzogcmVtb3RlLmM6MTYzNgorIzogcmVtb3RlLmM6MTYzOQogIywgYy1mb3JtYXQKIG1zZ2lkICJubyB1cHN0cmVhbSBjb25maWd1cmVkIGZvciBicmFuY2ggJyVzJyIKIG1zZ3N0ciAia2jDtG5nIGPDsyB0aMaw4bujbmcgbmd14buTbiDEkcaw4bujYyBj4bqldSBow6xuaCBjaG8gbmjDoW5oIOKAnCVz4oCdIgogCi0jOiByZW1vdGUuYzoxNjQyCisjOiByZW1vdGUuYzoxNjQ1CiAjLCBjLWZvcm1hdAogbXNnaWQgInVwc3RyZWFtIGJyYW5jaCAnJXMnIG5vdCBzdG9yZWQgYXMgYSByZW1vdGUtdHJhY2tpbmcgYnJhbmNoIgogbXNnc3RyICIiCiAibmjDoW5oIHRoxrDhu6NuZyBuZ3Xhu5NuIOKAnCVz4oCdIGtow7RuZyDEkcaw4bujYyBsxrB1IGzhuqFpIG5oxrAgbMOgIG3hu5l0IG5ow6FuaCB0aGVvIGTDtWkgbcOheSBjaOG7pyIKIAotIzogcmVtb3RlLmM6MTY1NworIzogcmVtb3RlLmM6MTY2MAogIywgYy1mb3JtYXQKIG1zZ2lkICJwdXNoIGRlc3RpbmF0aW9uICclcycgb24gcmVtb3RlICclcycgaGFzIG5vIGxvY2FsIHRyYWNraW5nIGJyYW5jaCIKIG1zZ3N0ciAixJHhuql5IGzDqm4gxJHDrWNoIOKAnCVz4oCdIHRyw6puIG3DoXkgY2jhu6cg4oCcJXPigJ0ga2jDtG5nIGPDsyBuaMOhbmggdGhlbyBkw7VpIG7hu5lpIGLhu5kiCiAKLSM6IHJlbW90ZS5jOjE2NjkKKyM6IHJlbW90ZS5jOjE2NzIKICMsIGMtZm9ybWF0CiBtc2dpZCAiYnJhbmNoICclcycgaGFzIG5vIHJlbW90ZSBmb3IgcHVzaGluZyIKIG1zZ3N0ciAibmjDoW5oIOKAnCVz4oCdIGtow7RuZyBjw7MgbcOheSBjaOG7pyDEkeG7gyDEkeG6qXkgbMOqbiIKIAotIzogcmVtb3RlLmM6MTY3OQorIzogcmVtb3RlLmM6MTY4MgogIywgYy1mb3JtYXQKIG1zZ2lkICJwdXNoIHJlZnNwZWNzIGZvciAnJXMnIGRvIG5vdCBpbmNsdWRlICclcyciCiBtc2dzdHIgIsSR4bqpeSByZWZzcGVjcyBjaG8g4oCcJXPigJ0ga2jDtG5nIGJhbyBn4buTbSDigJwlc+KAnSIKIAotIzogcmVtb3RlLmM6MTY5MgorIzogcmVtb3RlLmM6MTY5NQogbXNnaWQgInB1c2ggaGFzIG5vIGRlc3RpbmF0aW9uIChwdXNoLmRlZmF1bHQgaXMgJ25vdGhpbmcnKSIKIG1zZ3N0ciAixJHhuql5IGzDqm4gbcOgIGtow7RuZyBjw7MgxJHDrWNoIChwdXNoLmRlZmF1bHQgbMOgIOKAnG5vdGhpbmfigJ0pIgogCi0jOiByZW1vdGUuYzoxNzE0CisjOiByZW1vdGUuYzoxNzE3CiBtc2dpZCAiY2Fubm90IHJlc29sdmUgJ3NpbXBsZScgcHVzaCB0byBhIHNpbmdsZSBkZXN0aW5hdGlvbiIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIHBow6JuIGdp4bqjaSDEkeG6qXkg4oCcxJHGoW4gZ2nhuqNu4oCdIMSR4bq/biBt4buZdCDEkcOtY2ggxJHGoW4iCiAKLSM6IHJlbW90ZS5jOjE4NDAKKyM6IHJlbW90ZS5jOjE4NDMKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGRuJ3QgZmluZCByZW1vdGUgcmVmICVzIgogbXNnc3RyICJraMO0bmcgdGjhu4MgdMOsbSB0aOG6pXkgdGhhbSBjaGnhur91IG3DoXkgY2jhu6cgJXMiCiAKLSM6IHJlbW90ZS5jOjE4NTMKKyM6IHJlbW90ZS5jOjE4NTYKICMsIGMtZm9ybWF0CiBtc2dpZCAiKiBJZ25vcmluZyBmdW5ueSByZWYgJyVzJyBsb2NhbGx5IgogbXNnc3RyICIqIMSQYW5nIGLhu48gcXVhIHRoYW0gY2hp4bq/dSB0aMO6IHbhu4sgbuG7mWkgYuG7mSDigJwlc+KAnSIKIAotIzogcmVtb3RlLmM6MjAxNgorIzogcmVtb3RlLmM6MjAxOQogIywgYy1mb3JtYXQKIG1zZ2lkICJZb3VyIGJyYW5jaCBpcyBiYXNlZCBvbiAnJXMnLCBidXQgdGhlIHVwc3RyZWFtIGlzIGdvbmUuXG4iCiBtc2dzdHIgIiIKICJOaMOhbmggY+G7p2EgYuG6oW4gZOG7sWEgdHLDqm4gY8ahIHPhu58gbMOgIOKAnCVz4oCdLCBuaMawbmcgdHLDqm4gdGjGsOG7o25nIG5ndeG7k24ga2jDtG5nIGPDsm4uXG4iCiAKLSM6IHJlbW90ZS5jOjIwMjAKKyM6IHJlbW90ZS5jOjIwMjMKIG1zZ2lkICIgICh1c2UgXCJnaXQgYnJhbmNoIC0tdW5zZXQtdXBzdHJlYW1cIiB0byBmaXh1cClcbiIKIG1zZ3N0ciAiICAgKGTDuW5nIFwiIGdpdCBicmFuY2ggLS11bnNldC11cHN0cmVhbVwiIMSR4buDIHPhu61hKVxuIgogCi0jOiByZW1vdGUuYzoyMDIzCisjOiByZW1vdGUuYzoyMDI2CiAjLCBjLWZvcm1hdAogbXNnaWQgIllvdXIgYnJhbmNoIGlzIHVwIHRvIGRhdGUgd2l0aCAnJXMnLlxuIgogbXNnc3RyICJOaMOhbmggY+G7p2EgYuG6oW4gxJHDoyBj4bqtcCBuaOG6rXQgduG7m2kg4oCcJXPigJ0uXG4iCiAKLSM6IHJlbW90ZS5jOjIwMjcKKyM6IHJlbW90ZS5jOjIwMzAKICMsIGMtZm9ybWF0CiBtc2dpZCAiWW91ciBicmFuY2ggYW5kICclcycgcmVmZXIgdG8gZGlmZmVyZW50IGNvbW1pdHMuXG4iCiBtc2dzdHIgIk5ow6FuaCBj4bunYSBi4bqhbiB2w6Ag4oCcJXPigJ0gdGhhbSBjaGnhur91IMSR4bq/biBjw6FjIGzhuqduIGNodXnhu4NuIGdpYW8ga2jDoWMgbmhhdS5cbiIKIAotIzogcmVtb3RlLmM6MjAzMAorIzogcmVtb3RlLmM6MjAzMwogIywgYy1mb3JtYXQKIG1zZ2lkICIgICh1c2UgXCIlc1wiIGZvciBkZXRhaWxzKVxuIgogbXNnc3RyICIgIChkw7luZyBcIiVzXCIgxJHhu4MgYmnhur90IHRow6ptIGNoaSB0aeG6v3QpXG4iCiAKLSM6IHJlbW90ZS5jOjIwMzQKKyM6IHJlbW90ZS5jOjIwMzcKICMsIGMtZm9ybWF0CiBtc2dpZCAiWW91ciBicmFuY2ggaXMgYWhlYWQgb2YgJyVzJyBieSAlZCBjb21taXQuXG4iCiBtc2dpZF9wbHVyYWwgIllvdXIgYnJhbmNoIGlzIGFoZWFkIG9mICclcycgYnkgJWQgY29tbWl0cy5cbiIKIG1zZ3N0clswXSAiTmjDoW5oIGPhu6dhIGLhuqFuIMSR4bupbmcgdHLGsOG7m2Mg4oCcJXPigJ0gJWQgbOG6p24gY2h1eeG7g24gZ2lhby5cbiIKIAotIzogcmVtb3RlLmM6MjA0MAorIzogcmVtb3RlLmM6MjA0MwogbXNnaWQgIiAgKHVzZSBcImdpdCBwdXNoXCIgdG8gcHVibGlzaCB5b3VyIGxvY2FsIGNvbW1pdHMpXG4iCiBtc2dzdHIgIiAgKGTDuW5nIFwiZ2l0IHB1c2hcIiDEkeG7gyB4deG6pXQgYuG6o24gY8OhYyBs4bqnbiBjaHV54buDbiBnaWFvIG7hu5lpIGLhu5kgY+G7p2EgYuG6oW4pXG4iCiAKLSM6IHJlbW90ZS5jOjIwNDMKKyM6IHJlbW90ZS5jOjIwNDYKICMsIGMtZm9ybWF0CiBtc2dpZCAiWW91ciBicmFuY2ggaXMgYmVoaW5kICclcycgYnkgJWQgY29tbWl0LCBhbmQgY2FuIGJlIGZhc3QtZm9yd2FyZGVkLlxuIgogbXNnaWRfcGx1cmFsICIiCkBAIC01NTE0LDExICs1NTQ4LDExIEBACiAiTmjDoW5oIGPhu6dhIGLhuqFuIMSR4bupbmcgxJHhurFuZyBzYXUg4oCcJXPigJ0gJWQgbOG6p24gY2h1eeG7g24gZ2lhbywgdsOgIGPDsyB0aOG7gyDEkcaw4bujYyBjaHV54buDbi0iCiAidGnhur9wLW5oYW5oLlxuIgogCi0jOiByZW1vdGUuYzoyMDUxCisjOiByZW1vdGUuYzoyMDU0CiBtc2dpZCAiICAodXNlIFwiZ2l0IHB1bGxcIiB0byB1cGRhdGUgeW91ciBsb2NhbCBicmFuY2gpXG4iCiBtc2dzdHIgIiAgKGTDuW5nIFwiZ2l0IHB1bGxcIiDEkeG7gyBj4bqtcCBuaOG6rXQgbmjDoW5oIG7hu5lpIGLhu5kgY+G7p2EgYuG6oW4pXG4iCiAKLSM6IHJlbW90ZS5jOjIwNTQKKyM6IHJlbW90ZS5jOjIwNTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIllvdXIgYnJhbmNoIGFuZCAnJXMnIGhhdmUgZGl2ZXJnZWQsXG4iCkBAIC01NTMxLDEzICs1NTY1LDEzIEBACiAidsOgIGPDsyAlZCB2w6AgJWQgbOG6p24gY2h1eeG7g24gZ2lhbyBraMOhYyBuaGF1IGNobyB04burbmcgY8OhaSxcbiIKICJ0xrDGoW5nIOG7qW5nIHbhu5tpIG3hu5dpIGzhuqduLlxuIgogCi0jOiByZW1vdGUuYzoyMDY0CisjOiByZW1vdGUuYzoyMDY3CiBtc2dpZCAiICAodXNlIFwiZ2l0IHB1bGxcIiB0byBtZXJnZSB0aGUgcmVtb3RlIGJyYW5jaCBpbnRvIHlvdXJzKVxuIgogbXNnc3RyICIiCiAiICAoZMO5bmcgXCJnaXQgcHVsbFwiIMSR4buDIGjDsmEgdHLhu5luIG5ow6FuaCB0csOqbiBtw6F5IGNo4bunIHbDoG8gdHJvbmcgbmjDoW5oIGPhu6dhICIKICJi4bqhbilcbiIKIAotIzogcmVtb3RlLmM6MjI0NworIzogcmVtb3RlLmM6MjI1MAogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgcGFyc2UgZXhwZWN0ZWQgb2JqZWN0IG5hbWUgJyVzJyIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIHBow6JuIHTDrWNoIHTDqm4gxJHhu5FpIHTGsOG7o25nIG1vbmcgbXXhu5FuIOKAnCVz4oCdIgpAQCAtNTYxNSw3ICs1NjQ5LDcgQEAKIG1zZ2lkICJSZWNvcmRlZCBwcmVpbWFnZSBmb3IgJyVzJyIKIG1zZ3N0ciAiUHJlaW1hZ2UgxJHDoyDEkcaw4bujYyBnaGkgbOG6oWkgY2hvIOKAnCVz4oCdIgogCi0jOiByZXJlcmUuYzo4ODEgc3VibW9kdWxlLmM6MjAyMyBidWlsdGluL2xvZy5jOjE3NzMKKyM6IHJlcmVyZS5jOjg4MSBzdWJtb2R1bGUuYzoyMDIzIGJ1aWx0aW4vbG9nLmM6MTc5MAogIzogYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjE0MTggYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjE0MjgKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGNyZWF0ZSBkaXJlY3RvcnkgJyVzJyIKQEAgLTU2NTAsMjAgKzU2ODQsMjAgQEAKIG1zZ2lkICJ1bmFibGUgdG8gb3BlbiByci1jYWNoZSBkaXJlY3RvcnkiCiBtc2dzdHIgImtow7RuZyB0aOG7gyBt4bufIHRoxrAgbeG7pWMgcnItY2FjaGUiCiAKLSM6IHJldmlzaW9uLmM6MjUwNworIzogcmV2aXNpb24uYzoyNTA5CiBtc2dpZCAieW91ciBjdXJyZW50IGJyYW5jaCBhcHBlYXJzIHRvIGJlIGJyb2tlbiIKIG1zZ3N0ciAibmjDoW5oIGhp4buHbiB04bqhaSBj4bunYSBi4bqhbiBjw7MgduG6uyBuaMawIGLhu4sgaOG7j25nIgogCi0jOiByZXZpc2lvbi5jOjI1MTAKKyM6IHJldmlzaW9uLmM6MjUxMgogIywgYy1mb3JtYXQKIG1zZ2lkICJ5b3VyIGN1cnJlbnQgYnJhbmNoICclcycgZG9lcyBub3QgaGF2ZSBhbnkgY29tbWl0cyB5ZXQiCiBtc2dzdHIgIm5ow6FuaCBoaeG7h24gdOG6oWkgY+G7p2EgYuG6oW4g4oCcJXPigJ0ga2jDtG5nIGPDsyBt4buZdCBs4bqnbiBjaHV54buDbiBnaWFvIG7DoG8gY+G6oyIKIAotIzogcmV2aXNpb24uYzoyNzEwCisjOiByZXZpc2lvbi5jOjI3MjAKIG1zZ2lkICItLWZpcnN0LXBhcmVudCBpcyBpbmNvbXBhdGlibGUgd2l0aCAtLWJpc2VjdCIKIG1zZ3N0ciAiLS1maXJzdC1wYXJlbnQgeHVuZyBraOG6r2MgduG7m2kgLS1iaXNlY3QiCiAKLSM6IHJldmlzaW9uLmM6MjcxNAorIzogcmV2aXNpb24uYzoyNzI0CiBtc2dpZCAiLUwgZG9lcyBub3QgeWV0IHN1cHBvcnQgZGlmZiBmb3JtYXRzIGJlc2lkZXMgLXAgYW5kIC1zIgogbXNnc3RyICItTCB24bqrbiBjaMawYSBo4buXIHRy4bujIMSR4buLbmggZOG6oW5nIGtow6FjIGJp4buHdCBuw6BvIG5nb8OgaSAtcCB2w6AgLXMiCiAKQEAgLTU2ODUsMzAgKzU3MTksMzAgQEAKICJNw7NjIOKAnCVz4oCdIGLhu4sgYuG7jyBxdWEgYuG7n2kgdsOsIG7DsyBraMO0bmcgdGjhu4MgxJHhurd0IGzDoCB0aOG7sWMgdGhpIMSRxrDhu6NjLlxuIgogIkLhuqFuIGPDsyB0aOG7gyB04bqvdCBj4bqjbmggYsOhbyBuw6B5IGLhurFuZyDigJxnaXQgY29uZmlnIGFkdmljZS5pZ25vcmVkSG9vayBmYWxzZeKAnC4iCiAKLSM6IHNlbmQtcGFjay5jOjE0MQorIzogc2VuZC1wYWNrLmM6MTQyCiBtc2dpZCAidW5leHBlY3RlZCBmbHVzaCBwYWNrZXQgd2hpbGUgcmVhZGluZyByZW1vdGUgdW5wYWNrIHN0YXR1cyIKIG1zZ3N0ciAiIgogImfhurdwIGfDs2kgZmx1c2gga2jDtG5nIGPhuqduIHRyb25nIGtoaSDEkeG7jWMgdMOsbmggdHLhuqFuZyBnaeG6o2kgbsOpbiBnw7NpIHRyw6puIG3DoXkgY2jhu6ciCiAKLSM6IHNlbmQtcGFjay5jOjE0MworIzogc2VuZC1wYWNrLmM6MTQ0CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBwYXJzZSByZW1vdGUgdW5wYWNrIHN0YXR1czogJXMiCiBtc2dzdHIgImtow7RuZyB0aOG7gyBwaMOibiB0w61jaCB0w6xuaCB0cuG6oW5nIHVucGFjayBtw6F5IGNo4bunOiAlcyIKIAotIzogc2VuZC1wYWNrLmM6MTQ1CisjOiBzZW5kLXBhY2suYzoxNDYKICMsIGMtZm9ybWF0CiBtc2dpZCAicmVtb3RlIHVucGFjayBmYWlsZWQ6ICVzIgogbXNnc3RyICJtw6F5IGNo4bunIGfhurdwIGzhu5dpIHVucGFjazogJXMiCiAKLSM6IHNlbmQtcGFjay5jOjMwNgorIzogc2VuZC1wYWNrLmM6MzA3CiBtc2dpZCAiZmFpbGVkIHRvIHNpZ24gdGhlIHB1c2ggY2VydGlmaWNhdGUiCiBtc2dzdHIgImfhurdwIGzhu5dpIGtoaSBrw70gY2jhu6luZyB0aOG7sWMgxJHhuql5IgogCi0jOiBzZW5kLXBhY2suYzo0MjAKKyM6IHNlbmQtcGFjay5jOjQyMQogbXNnaWQgInRoZSByZWNlaXZpbmcgZW5kIGRvZXMgbm90IHN1cHBvcnQgLS1zaWduZWQgcHVzaCIKIG1zZ3N0ciAia+G6v3QgdGjDumMgbmjhuq1uIGtow7RuZyBo4buXIHRy4bujIMSR4bqpeSAtLXNpZ25lZCIKIAotIzogc2VuZC1wYWNrLmM6NDIyCisjOiBzZW5kLXBhY2suYzo0MjMKIG1zZ2lkICIiCiAibm90IHNlbmRpbmcgYSBwdXNoIGNlcnRpZmljYXRlIHNpbmNlIHRoZSByZWNlaXZpbmcgZW5kIGRvZXMgbm90IHN1cHBvcnQgLS0iCiAic2lnbmVkIHB1c2giCkBAIC01NzE2LDExICs1NzUwLDExIEBACiAixJHhu6tuZyBn4butaSBnaeG6pXkgY2jhu6luZyBuaOG6rW4gxJHhuql5IHRyxrDhu5tjIGtoaSBr4bq/dCB0aMO6YyBuaOG6rW4ga2jDtG5nIGjhu5cgdHLhu6MgxJHhuql5IC0tIgogInNpZ25lZCIKIAotIzogc2VuZC1wYWNrLmM6NDM0CisjOiBzZW5kLXBhY2suYzo0MzUKIG1zZ2lkICJ0aGUgcmVjZWl2aW5nIGVuZCBkb2VzIG5vdCBzdXBwb3J0IC0tYXRvbWljIHB1c2giCiBtc2dzdHIgImvhur90IHRow7pjIG5o4bqtbiBraMO0bmcgaOG7lyB0cuG7oyDEkeG6qXkgLS1hdG9taWMiCiAKLSM6IHNlbmQtcGFjay5jOjQzOQorIzogc2VuZC1wYWNrLmM6NDQwCiBtc2dpZCAidGhlIHJlY2VpdmluZyBlbmQgZG9lcyBub3Qgc3VwcG9ydCBwdXNoIG9wdGlvbnMiCiBtc2dzdHIgImvhur90IHRow7pjIG5o4bqtbiBraMO0bmcgaOG7lyB0cuG7oyBjw6FjIHTDuXkgY2jhu41uIGPhu6dhIGzhu4duaCBwdXNoIgogCkBAIC01NzM0LDcgKzU3NjgsNyBAQAogbXNnaWQgImNvdWxkIG5vdCBkZWxldGUgJyVzJyIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIHjDs2EgYuG7jyDigJwlc+KAnSIKIAotIzogc2VxdWVuY2VyLmM6MzExIGJ1aWx0aW4vcmViYXNlLmM6NzU5IGJ1aWx0aW4vcmViYXNlLmM6MTY0NSBidWlsdGluL3JtLmM6MzY5CisjOiBzZXF1ZW5jZXIuYzozMTEgYnVpbHRpbi9yZWJhc2UuYzo3NjAgYnVpbHRpbi9yZWJhc2UuYzoxNjc2IGJ1aWx0aW4vcm0uYzozNjkKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHJlbW92ZSAnJXMnIgogbXNnc3RyICJraMO0bmcgdGjhu4MgZ+G7oSBi4buPIOKAnCVz4oCdIgpAQCAtNTc3NCw3ICs1ODA4LDcgQEAKICJ24bubaSBs4buHbmgg4oCcZ2l0IGFkZCA8L2PDoWMvxJHGsOG7nW5nL2ThuqtuPuKAnSBob+G6t2Mg4oCcZ2l0IHJtIDwvY8OhYy/Ekcaw4budbmcvZOG6q24+4oCdXG4iCiAidsOgIGNodXnhu4NuIGdpYW8ga+G6v3QgcXXhuqMgYuG6sW5nIGzhu4duaCDigJxnaXQgY29tbWl04oCdIgogCi0jOiBzZXF1ZW5jZXIuYzo0MDEgc2VxdWVuY2VyLmM6MjkwOQorIzogc2VxdWVuY2VyLmM6NDAxIHNlcXVlbmNlci5jOjI4NDcKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGxvY2sgJyVzJyIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIGtow7NhIOKAnCVz4oCdIgpAQCAtNTc4NCwxNSArNTgxOCwxNSBAQAogbXNnaWQgImNvdWxkIG5vdCB3cml0ZSBlb2wgdG8gJyVzJyIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIGdoaSBlb2wgdsOgbyDigJwlc+KAnSIKIAotIzogc2VxdWVuY2VyLmM6NDEzIHNlcXVlbmNlci5jOjI3MTQgc2VxdWVuY2VyLmM6MjkxNSBzZXF1ZW5jZXIuYzoyOTI5Ci0jOiBzZXF1ZW5jZXIuYzozMTkyCisjOiBzZXF1ZW5jZXIuYzo0MTMgc2VxdWVuY2VyLmM6MjY1MiBzZXF1ZW5jZXIuYzoyODUzIHNlcXVlbmNlci5jOjI4NjcKKyM6IHNlcXVlbmNlci5jOjMxMzAKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIGZpbmFsaXplICclcyciCiBtc2dzdHIgImfhurdwIGzhu5dpIGtoaSBob8OgbiB0aMOgbmgg4oCcJXPigJ0iCiAKLSM6IHNlcXVlbmNlci5jOjQzNiBzZXF1ZW5jZXIuYzo5ODEgc2VxdWVuY2VyLmM6MTY1NSBzZXF1ZW5jZXIuYzoyNzM0Ci0jOiBzZXF1ZW5jZXIuYzozMTc0IHNlcXVlbmNlci5jOjMyODMgYnVpbHRpbi9hbS5jOjI0NSBidWlsdGluL2NvbW1pdC5jOjc2MwotIzogYnVpbHRpbi9tZXJnZS5jOjExMTIgYnVpbHRpbi9yZWJhc2UuYzo1NjcKKyM6IHNlcXVlbmNlci5jOjQzNiBzZXF1ZW5jZXIuYzoxNTg1IHNlcXVlbmNlci5jOjI2NzIgc2VxdWVuY2VyLmM6MzExMgorIzogc2VxdWVuY2VyLmM6MzIyMSBidWlsdGluL2FtLmM6MjQ0IGJ1aWx0aW4vY29tbWl0LmM6NzYzIGJ1aWx0aW4vbWVyZ2UuYzoxMTE3CisjOiBidWlsdGluL3JlYmFzZS5jOjU2OAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcmVhZCAnJXMnIgogbXNnc3RyICJraMO0bmcgdGjhu4MgxJHhu41jIOKAnCVz4oCdIgpAQCAtNTgxOSw3MCArNTg1Myw2NSBAQAogIy4gVFJBTlNMQVRPUlM6ICVzIHdpbGwgYmUgInJldmVydCIsICJjaGVycnktcGljayIgb3IKICMuICJyZWJhc2UgLWkiLgogIy4KLSM6IHNlcXVlbmNlci5jOjYzMgorIzogc2VxdWVuY2VyLmM6NjMxCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiBVbmFibGUgdG8gd3JpdGUgbmV3IGluZGV4IGZpbGUiCiBtc2dzdHIgIiVzOiBLaMO0bmcgdGjhu4MgZ2hpIHThuq1wIHRpbiBsxrB1IGLhuqNuZyBt4bulYyBs4bulYyBt4bubaSIKIAotIzogc2VxdWVuY2VyLmM6NjQ5CisjOiBzZXF1ZW5jZXIuYzo2NDgKIG1zZ2lkICJ1bmFibGUgdG8gdXBkYXRlIGNhY2hlIHRyZWUiCiBtc2dzdHIgImtow7RuZyB0aOG7gyBj4bqtcCBuaOG6rXQgY8OieSBi4buZIG5o4bubIMSR4buHbSIKIAotIzogc2VxdWVuY2VyLmM6NjYzCisjOiBzZXF1ZW5jZXIuYzo2NjIKIG1zZ2lkICJjb3VsZCBub3QgcmVzb2x2ZSBIRUFEIGNvbW1pdCIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIHBow6JuIGdp4bqjaSBs4bqnbiBjaHV54buDbiBnaWFvIEhFQUQiCiAKLSM6IHNlcXVlbmNlci5jOjc0MworIzogc2VxdWVuY2VyLmM6NzQyCiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vIGtleSBwcmVzZW50IGluICclLipzJyIKIG1zZ3N0ciAia2jDtG5nIGPDsyBraMOzYSBoaeG7h24gZGnhu4duIHRyb25nIOKAnCUuKnPigJ0iCiAKLSM6IHNlcXVlbmNlci5jOjc1NAorIzogc2VxdWVuY2VyLmM6NzUzCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBkZXF1b3RlIHZhbHVlIG9mICclcyciCiBtc2dzdHIgImtow7RuZyB0aOG7gyBnaeG6o2kgdHLDrWNoIGThuqtuIGdpw6EgdHLhu4sgY+G7p2Eg4oCcJXPigJ0iCiAKLSM6IHNlcXVlbmNlci5jOjc5MSB3cmFwcGVyLmM6MjI3IHdyYXBwZXIuYzozOTcgYnVpbHRpbi9hbS5jOjcwNgotIzogYnVpbHRpbi9hbS5jOjc5OCBidWlsdGluL21lcmdlLmM6MTEwOSBidWlsdGluL3JlYmFzZS5jOjEwNDUKKyM6IHNlcXVlbmNlci5jOjc5MCB3cmFwcGVyLmM6MTkwIHdyYXBwZXIuYzozNjAgYnVpbHRpbi9hbS5jOjcwNQorIzogYnVpbHRpbi9hbS5jOjc5NyBidWlsdGluL21lcmdlLmM6MTExNCBidWlsdGluL3JlYmFzZS5jOjEwNDYKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IG9wZW4gJyVzJyBmb3IgcmVhZGluZyIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIG3hu58g4oCcJXPigJ0gxJHhu4MgxJHhu41jIgogCi0jOiBzZXF1ZW5jZXIuYzo4MDEKKyM6IHNlcXVlbmNlci5jOjgwMAogbXNnaWQgIidHSVRfQVVUSE9SX05BTUUnIGFscmVhZHkgZ2l2ZW4iCiBtc2dzdHIgIuKAnEdJVF9BVVRIT1JfTkFNReKAnSDEkcOjIHPhurVuIMSRxrBhIHJhIHLhu5NpIgogCi0jOiBzZXF1ZW5jZXIuYzo4MDYKKyM6IHNlcXVlbmNlci5jOjgwNQogbXNnaWQgIidHSVRfQVVUSE9SX0VNQUlMJyBhbHJlYWR5IGdpdmVuIgogbXNnc3RyICLigJxHSVRfQVVUSE9SX0VNQUlM4oCdIMSRw6Mgc+G6tW4gxJHGsGEgcmEgcuG7k2kiCiAKLSM6IHNlcXVlbmNlci5jOjgxMQorIzogc2VxdWVuY2VyLmM6ODEwCiBtc2dpZCAiJ0dJVF9BVVRIT1JfREFURScgYWxyZWFkeSBnaXZlbiIKIG1zZ3N0ciAi4oCcR0lUX0FVVEhPUl9EQVRF4oCdIMSRw6Mgc+G6tW4gxJHGsGEgcmEgcuG7k2kiCiAKLSM6IHNlcXVlbmNlci5jOjgxNQorIzogc2VxdWVuY2VyLmM6ODE0CiAjLCBjLWZvcm1hdAogbXNnaWQgInVua25vd24gdmFyaWFibGUgJyVzJyIKIG1zZ3N0ciAia2jDtG5nIGhp4buDdSBiaeG6v24g4oCcJXPigJ0iCiAKLSM6IHNlcXVlbmNlci5jOjgyMAorIzogc2VxdWVuY2VyLmM6ODE5CiBtc2dpZCAibWlzc2luZyAnR0lUX0FVVEhPUl9OQU1FJyIKIG1zZ3N0ciAidGhp4bq/dSDigJxHSVRfQVVUSE9SX05BTUXigJ0iCiAKLSM6IHNlcXVlbmNlci5jOjgyMgorIzogc2VxdWVuY2VyLmM6ODIxCiBtc2dpZCAibWlzc2luZyAnR0lUX0FVVEhPUl9FTUFJTCciCiBtc2dzdHIgInRoaeG6v3Ug4oCcR0lUX0FVVEhPUl9FTUFJTOKAnSIKIAotIzogc2VxdWVuY2VyLmM6ODI0CisjOiBzZXF1ZW5jZXIuYzo4MjMKIG1zZ2lkICJtaXNzaW5nICdHSVRfQVVUSE9SX0RBVEUnIgogbXNnc3RyICJ0aGnhur91IOKAnEdJVF9BVVRIT1JfREFUReKAnSIKIAotIzogc2VxdWVuY2VyLmM6ODg0Ci0jLCBjLWZvcm1hdAotbXNnaWQgImludmFsaWQgZGF0ZSBmb3JtYXQgJyVzJyBpbiAnJXMnIgotbXNnc3RyICLEkeG7i25oIGThuqFuZyBuZ8OgeSB0aMOhbmcga2jDtG5nIGjhu6NwIGzhu4cg4oCcJXPigJ0gdHJvbmcg4oCcJXPigJ0iCi0KLSM6IHNlcXVlbmNlci5jOjkwMQorIzogc2VxdWVuY2VyLmM6ODcyCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJ5b3UgaGF2ZSBzdGFnZWQgY2hhbmdlcyBpbiB5b3VyIHdvcmtpbmcgdHJlZVxuIgpAQCAtNTkxMSwxNSArNTk0MCwxMSBAQAogIlxuIgogIiAgZ2l0IHJlYmFzZSAtLWNvbnRpbnVlXG4iCiAKLSM6IHNlcXVlbmNlci5jOjk5NQotbXNnaWQgIndyaXRpbmcgcm9vdCBjb21taXQiCi1tc2dzdHIgImdoaSBjaHV54buDbiBnaWFvIGfhu5FjIgotCi0jOiBzZXF1ZW5jZXIuYzoxMjE2CisjOiBzZXF1ZW5jZXIuYzoxMTQ2CiBtc2dpZCAiJ3ByZXBhcmUtY29tbWl0LW1zZycgaG9vayBmYWlsZWQiCiBtc2dzdHIgIm3Ds2Mg4oCccHJlcGFyZS1jb21taXQtbXNn4oCdIGLhu4sgbOG7l2kiCiAKLSM6IHNlcXVlbmNlci5jOjEyMjMKKyM6IHNlcXVlbmNlci5jOjExNTMKIG1zZ2lkICIiCiAiWW91ciBuYW1lIGFuZCBlbWFpbCBhZGRyZXNzIHdlcmUgY29uZmlndXJlZCBhdXRvbWF0aWNhbGx5IGJhc2VkXG4iCiAib24geW91ciB1c2VybmFtZSBhbmQgaG9zdG5hbWUuIFBsZWFzZSBjaGVjayB0aGF0IHRoZXkgYXJlIGFjY3VyYXRlLlxuIgpAQCAtNTk1MCw3ICs1OTc1LDcgQEAKICJcbiIKICIgICAgZ2l0IGNvbW1pdCAtLWFtZW5kIC0tcmVzZXQtYXV0aG9yXG4iCiAKLSM6IHNlcXVlbmNlci5jOjEyMzYKKyM6IHNlcXVlbmNlci5jOjExNjYKIG1zZ2lkICIiCiAiWW91ciBuYW1lIGFuZCBlbWFpbCBhZGRyZXNzIHdlcmUgY29uZmlndXJlZCBhdXRvbWF0aWNhbGx5IGJhc2VkXG4iCiAib24geW91ciB1c2VybmFtZSBhbmQgaG9zdG5hbWUuIFBsZWFzZSBjaGVjayB0aGF0IHRoZXkgYXJlIGFjY3VyYXRlLlxuIgpAQCAtNTk3OCwzMjggKzYwMDMsMzI4IEBACiAiXG4iCiAiICAgIGdpdCBjb21taXQgLS1hbWVuZCAtLXJlc2V0LWF1dGhvclxuIgogCi0jOiBzZXF1ZW5jZXIuYzoxMjc4CisjOiBzZXF1ZW5jZXIuYzoxMjA4CiBtc2dpZCAiY291bGRuJ3QgbG9vayB1cCBuZXdseSBjcmVhdGVkIGNvbW1pdCIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIHTDrG0gdGjhuqV5IGzhuqduIGNodXnhu4NuIGdpYW8gbeG7m2kgaMahbiDEkcOjIMSRxrDhu6NjIHThuqFvIgogCi0jOiBzZXF1ZW5jZXIuYzoxMjgwCisjOiBzZXF1ZW5jZXIuYzoxMjEwCiBtc2dpZCAiY291bGQgbm90IHBhcnNlIG5ld2x5IGNyZWF0ZWQgY29tbWl0IgogbXNnc3RyICIiCiAia2jDtG5nIHRo4buDIHBow6JuIHTDrWNoIGPDuiBwaMOhcCBj4bunYSDEkeG7kWkgdMaw4bujbmcgY2h1eeG7g24gZ2lhbyBt4bubaSBoxqFuIMSRw6MgxJHGsOG7o2MgdOG6oW8iCiAKLSM6IHNlcXVlbmNlci5jOjEzMjYKKyM6IHNlcXVlbmNlci5jOjEyNTYKIG1zZ2lkICJ1bmFibGUgdG8gcmVzb2x2ZSBIRUFEIGFmdGVyIGNyZWF0aW5nIGNvbW1pdCIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIHBow6JuIGdp4bqjaSBIRUFEIHNhdSBraGkgdOG6oW8gbOG6p24gY2h1eeG7g24gZ2lhbyIKIAotIzogc2VxdWVuY2VyLmM6MTMyOAorIzogc2VxdWVuY2VyLmM6MTI1OAogbXNnaWQgImRldGFjaGVkIEhFQUQiCiBtc2dzdHIgIsSRw6MgcuG7nWkga2jhu49pIEhFQUQiCiAKLSM6IHNlcXVlbmNlci5jOjEzMzIKKyM6IHNlcXVlbmNlci5jOjEyNjIKIG1zZ2lkICIgKHJvb3QtY29tbWl0KSIKIG1zZ3N0ciAiIChyb290LWNvbW1pdCkiCiAKLSM6IHNlcXVlbmNlci5jOjEzNTMKKyM6IHNlcXVlbmNlci5jOjEyODMKIG1zZ2lkICJjb3VsZCBub3QgcGFyc2UgSEVBRCIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIHBow6JuIHTDrWNoIEhFQUQiCiAKLSM6IHNlcXVlbmNlci5jOjEzNTUKKyM6IHNlcXVlbmNlci5jOjEyODUKICMsIGMtZm9ybWF0CiBtc2dpZCAiSEVBRCAlcyBpcyBub3QgYSBjb21taXQhIgogbXNnc3RyICJIRUFEICVzIGtow7RuZyBwaOG6o2kgbMOgIG3hu5l0IGzhuqduIGNodXnhu4NuIGdpYW8hIgogCi0jOiBzZXF1ZW5jZXIuYzoxMzU5IGJ1aWx0aW4vY29tbWl0LmM6MTU3MQorIzogc2VxdWVuY2VyLmM6MTI4OSBidWlsdGluL2NvbW1pdC5jOjE1NzEKIG1zZ2lkICJjb3VsZCBub3QgcGFyc2UgSEVBRCBjb21taXQiCiBtc2dzdHIgImtow7RuZyB0aOG7gyBwaMOibiB0w61jaCBjb21taXQgKGzhuqduIGNodXnhu4NuIGdpYW8pIEhFQUQiCiAKLSM6IHNlcXVlbmNlci5jOjE0MTEgc2VxdWVuY2VyLmM6MjAwNAorIzogc2VxdWVuY2VyLmM6MTM0MSBzZXF1ZW5jZXIuYzoxOTMzCiBtc2dpZCAidW5hYmxlIHRvIHBhcnNlIGNvbW1pdCBhdXRob3IiCiBtc2dzdHIgImtow7RuZyB0aOG7gyBwaMOibiB0w61jaCB0w6FjIGdp4bqjIGPhu6dhIGzhuqduIGNodXnhu4NuIGdpYW8iCiAKLSM6IHNlcXVlbmNlci5jOjE0MjEgYnVpbHRpbi9hbS5jOjE1NzMgYnVpbHRpbi9tZXJnZS5jOjY4NAorIzogc2VxdWVuY2VyLmM6MTM1MiBidWlsdGluL2FtLmM6MTU2MSBidWlsdGluL21lcmdlLmM6Njg0CiBtc2dpZCAiZ2l0IHdyaXRlLXRyZWUgZmFpbGVkIHRvIHdyaXRlIGEgdHJlZSIKIG1zZ3N0ciAibOG7h25oIGdpdCB3cml0ZS10cmVlIGfhurdwIGzhu5dpIGtoaSBnaGkgbeG7mXQgY8OieSIKIAotIzogc2VxdWVuY2VyLmM6MTQzOCBzZXF1ZW5jZXIuYzoxNDk5CisjOiBzZXF1ZW5jZXIuYzoxMzY5IHNlcXVlbmNlci5jOjE0MjkKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHJlYWQgY29tbWl0IG1lc3NhZ2UgZnJvbSAnJXMnIgogbXNnc3RyICJraMO0bmcgdGjhu4MgxJHhu41jIHBo4bqnbiBjaMO6IHRow61jaCAobWVzc2FnZSkgdOG7qyDigJwlc+KAnSIKIAotIzogc2VxdWVuY2VyLmM6MTQ2NSBidWlsdGluL2FtLmM6MTU5NSBidWlsdGluL2NvbW1pdC5jOjE2NzAgYnVpbHRpbi9tZXJnZS5jOjg3OAotIzogYnVpbHRpbi9tZXJnZS5jOjkwMworIzogc2VxdWVuY2VyLmM6MTM5NiBidWlsdGluL2FtLmM6MTU4MyBidWlsdGluL2NvbW1pdC5jOjE2NzAgYnVpbHRpbi9tZXJnZS5jOjg4MworIzogYnVpbHRpbi9tZXJnZS5jOjkwOAogbXNnaWQgImZhaWxlZCB0byB3cml0ZSBjb21taXQgb2JqZWN0IgogbXNnc3RyICJn4bq3cCBs4buXaSBraGkgZ2hpIMSR4buRaSB0xrDhu6NuZyBjaHV54buDbiBnaWFvIgogCi0jOiBzZXF1ZW5jZXIuYzoxNTI2CisjOiBzZXF1ZW5jZXIuYzoxNDU2CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBwYXJzZSBjb21taXQgJXMiCiBtc2dzdHIgImtow7RuZyB0aOG7gyBwaMOibiB0w61jaCBs4bqnbiBjaHV54buDbiBnaWFvICVzIgogCi0jOiBzZXF1ZW5jZXIuYzoxNTMxCisjOiBzZXF1ZW5jZXIuYzoxNDYxCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBwYXJzZSBwYXJlbnQgY29tbWl0ICVzIgogbXNnc3RyICJraMO0bmcgdGjhu4MgcGjDom4gdMOtY2ggbOG6p24gY2h1eeG7g24gZ2lhbyBjaGEgbeG6uSDigJwlc+KAnSIKIAotIzogc2VxdWVuY2VyLmM6MTYwNSBzZXF1ZW5jZXIuYzoxNzE1CisjOiBzZXF1ZW5jZXIuYzoxNTM1IHNlcXVlbmNlci5jOjE2NDUKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5rbm93biBjb21tYW5kOiAlZCIKIG1zZ3N0ciAia2jDtG5nIGhp4buDdSBjw6J1IGzhu4duaCAlZCIKIAotIzogc2VxdWVuY2VyLmM6MTY2MiBzZXF1ZW5jZXIuYzoxNjg3CisjOiBzZXF1ZW5jZXIuYzoxNTkyIHNlcXVlbmNlci5jOjE2MTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiVGhpcyBpcyBhIGNvbWJpbmF0aW9uIG9mICVkIGNvbW1pdHMuIgogbXNnc3RyICLEkMOieSBsw6AgdOG7lSBo4bujcCBj4bunYSAlZCBs4bqnbiBjaHV54buDbiBnaWFvLiIKIAotIzogc2VxdWVuY2VyLmM6MTY3MgorIzogc2VxdWVuY2VyLmM6MTYwMgogbXNnaWQgIm5lZWQgYSBIRUFEIHRvIGZpeHVwIgogbXNnc3RyICJj4bqnbiBt4buZdCBIRUFEIMSR4buDIHPhu61hIgogCi0jOiBzZXF1ZW5jZXIuYzoxNjc0IHNlcXVlbmNlci5jOjMyMTkKKyM6IHNlcXVlbmNlci5jOjE2MDQgc2VxdWVuY2VyLmM6MzE1NwogbXNnaWQgImNvdWxkIG5vdCByZWFkIEhFQUQiCiBtc2dzdHIgImtow7RuZyB0aOG7gyDEkeG7jWMgSEVBRCIKIAotIzogc2VxdWVuY2VyLmM6MTY3NgorIzogc2VxdWVuY2VyLmM6MTYwNgogbXNnaWQgImNvdWxkIG5vdCByZWFkIEhFQUQncyBjb21taXQgbWVzc2FnZSIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIMSR4buNYyBwaOG6p24gY2jDuiB0aMOtY2ggKG1lc3NhZ2UpIGPhu6dhIEhFQUQiCiAKLSM6IHNlcXVlbmNlci5jOjE2ODIKKyM6IHNlcXVlbmNlci5jOjE2MTIKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IHdyaXRlICclcyciCiBtc2dzdHIgImtow7RuZyB0aOG7gyBnaGkg4oCcJXPigJ0iCiAKLSM6IHNlcXVlbmNlci5jOjE2ODkgZ2l0LXJlYmFzZS0tcHJlc2VydmUtbWVyZ2VzLnNoOjQ5NgorIzogc2VxdWVuY2VyLmM6MTYxOSBnaXQtcmViYXNlLS1wcmVzZXJ2ZS1tZXJnZXMuc2g6NDk2CiBtc2dpZCAiVGhpcyBpcyB0aGUgMXN0IGNvbW1pdCBtZXNzYWdlOiIKIG1zZ3N0ciAixJDDonkgbMOgIGNow7ogdGjDrWNoIGNobyBs4bqnbiBjaHV54buDbiBnaWFvIHRo4bupIG5o4bqldDoiCiAKLSM6IHNlcXVlbmNlci5jOjE2OTcKKyM6IHNlcXVlbmNlci5jOjE2MjcKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHJlYWQgY29tbWl0IG1lc3NhZ2Ugb2YgJXMiCiBtc2dzdHIgImtow7RuZyB0aOG7gyDEkeG7jWMgcGjhuqduIGNow7ogdGjDrWNoIChtZXNzYWdlKSBj4bunYSAlcyIKIAotIzogc2VxdWVuY2VyLmM6MTcwNAorIzogc2VxdWVuY2VyLmM6MTYzNAogIywgYy1mb3JtYXQKIG1zZ2lkICJUaGlzIGlzIHRoZSBjb21taXQgbWVzc2FnZSAjJWQ6IgogbXNnc3RyICLEkMOieSBsw6AgY2jDuiB0aMOtY2ggY2hvIGzhuqduIGNodXnhu4NuIGdpYW8gdGjhu6kgIyVkOiIKIAotIzogc2VxdWVuY2VyLmM6MTcxMAorIzogc2VxdWVuY2VyLmM6MTY0MAogIywgYy1mb3JtYXQKIG1zZ2lkICJUaGUgY29tbWl0IG1lc3NhZ2UgIyVkIHdpbGwgYmUgc2tpcHBlZDoiCiBtc2dzdHIgIkNow7ogdGjDrWNoIGNobyBs4bqnbiBjaHV54buDbiBnaWFvIHRo4bupICMlZCBz4bq9IGLhu4sgYuG7jyBxdWE6IgogCi0jOiBzZXF1ZW5jZXIuYzoxNzk4CisjOiBzZXF1ZW5jZXIuYzoxNzI4CiBtc2dpZCAieW91ciBpbmRleCBmaWxlIGlzIHVubWVyZ2VkLiIKIG1zZ3N0ciAidOG6rXAgdGluIGzGsHUgbeG7pWMgbOG7pWMgY+G7p2EgYuG6oW4ga2jDtG5nIMSRxrDhu6NjIGjDsmEgdHLhu5luLiIKIAotIzogc2VxdWVuY2VyLmM6MTgwNQorIzogc2VxdWVuY2VyLmM6MTczNQogbXNnaWQgImNhbm5vdCBmaXh1cCByb290IGNvbW1pdCIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIHPhu61hIGNo4buvYSBs4bqnbiBjaHV54buDbiBnaWFvIGfhu5FjIgogCi0jOiBzZXF1ZW5jZXIuYzoxODI0CisjOiBzZXF1ZW5jZXIuYzoxNzU0CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvbW1pdCAlcyBpcyBhIG1lcmdlIGJ1dCBubyAtbSBvcHRpb24gd2FzIGdpdmVuLiIKIG1zZ3N0ciAibOG6p24gY2h1eeG7g24gZ2lhbyAlcyBsw6AgbeG7mXQgbOG6p24gaMOyYSB0cuG7mW4gbmjGsG5nIGtow7RuZyDEkcawYSByYSB0w7l5IGNo4buNbiAtbS4iCiAKLSM6IHNlcXVlbmNlci5jOjE4MzIgc2VxdWVuY2VyLmM6MTg0MAorIzogc2VxdWVuY2VyLmM6MTc2MiBzZXF1ZW5jZXIuYzoxNzcwCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvbW1pdCAlcyBkb2VzIG5vdCBoYXZlIHBhcmVudCAlZCIKIG1zZ3N0ciAibOG6p24gY2h1eeG7g24gZ2lhbyAlcyBraMO0bmcgY8OzIGNoYSBt4bq5ICVkIgogCi0jOiBzZXF1ZW5jZXIuYzoxODQ2CisjOiBzZXF1ZW5jZXIuYzoxNzc2CiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCBnZXQgY29tbWl0IG1lc3NhZ2UgZm9yICVzIgogbXNnc3RyICJraMO0bmcgdGjhu4MgbOG6pXkgZ2hpIGNow7ogbOG6p24gY2h1eeG7g24gZ2lhbyBjaG8gJXMiCiAKICMuIFRSQU5TTEFUT1JTOiBUaGUgZmlyc3QgJXMgd2lsbCBiZSBhICJ0b2RvIiBjb21tYW5kIGxpa2UKICMuICJyZXZlcnQiIG9yICJwaWNrIiwgdGhlIHNlY29uZCAlcyBhIFNIQTEuCi0jOiBzZXF1ZW5jZXIuYzoxODY1CisjOiBzZXF1ZW5jZXIuYzoxNzk1CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiBjYW5ub3QgcGFyc2UgcGFyZW50IGNvbW1pdCAlcyIKIG1zZ3N0ciAiJXM6IGtow7RuZyB0aOG7gyBwaMOibiB0w61jaCBs4bqnbiBjaHV54buDbiBnaWFvIG3hurkgY+G7p2EgJXMiCiAKLSM6IHNlcXVlbmNlci5jOjE5MzAKKyM6IHNlcXVlbmNlci5jOjE4NjAKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHJlbmFtZSAnJXMnIHRvICclcyciCiBtc2dzdHIgImtow7RuZyB0aOG7gyDEkeG7lWkgdMOqbiDigJwlc+KAnSB0aMOgbmgg4oCcJXPigJ0iCiAKLSM6IHNlcXVlbmNlci5jOjE5ODUKKyM6IHNlcXVlbmNlci5jOjE5MTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHJldmVydCAlcy4uLiAlcyIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIGhvw6BuIG5ndXnDqm4gJXPigKYgJXMiCiAKLSM6IHNlcXVlbmNlci5jOjE5ODYKKyM6IHNlcXVlbmNlci5jOjE5MTYKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGFwcGx5ICVzLi4uICVzIgogbXNnc3RyICJraMO0bmcgdGjhu4Mgw6FwIGThu6VuZyBtaeG6v25nIHbDoSAlc+KApiAlcyIKIAotIzogc2VxdWVuY2VyLmM6MjA0NQorIzogc2VxdWVuY2VyLmM6MTk4MwogIywgYy1mb3JtYXQKIG1zZ2lkICJnaXQgJXM6IGZhaWxlZCB0byByZWFkIHRoZSBpbmRleCIKIG1zZ3N0ciAiZ2l0ICVzOiBn4bq3cCBs4buXaSDEkeG7jWMgYuG6o25nIG3hu6VjIGzhu6VjIgogCi0jOiBzZXF1ZW5jZXIuYzoyMDUyCisjOiBzZXF1ZW5jZXIuYzoxOTkwCiAjLCBjLWZvcm1hdAogbXNnaWQgImdpdCAlczogZmFpbGVkIHRvIHJlZnJlc2ggdGhlIGluZGV4IgogbXNnc3RyICJnaXQgJXM6IGfhurdwIGzhu5dpIGtoaSBsw6BtIHTGsMahaSBt4bubaSBi4bqjbmcgbeG7pWMgbOG7pWMiCiAKLSM6IHNlcXVlbmNlci5jOjIxMjgKKyM6IHNlcXVlbmNlci5jOjIwNjYKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgZG9lcyBub3QgYWNjZXB0IGFyZ3VtZW50czogJyVzJyIKIG1zZ3N0ciAiJXMga2jDtG5nIG5o4bqtbiBjw6FjIMSR4buRaSBz4buROiDigJwlc+KAnSIKIAotIzogc2VxdWVuY2VyLmM6MjEzNworIzogc2VxdWVuY2VyLmM6MjA3NQogIywgYy1mb3JtYXQKIG1zZ2lkICJtaXNzaW5nIGFyZ3VtZW50cyBmb3IgJXMiCiBtc2dzdHIgInRoaeG6v3UgxJHhu5FpIHPhu5EgY2hvICVzIgogCi0jOiBzZXF1ZW5jZXIuYzoyMTc0CisjOiBzZXF1ZW5jZXIuYzoyMTEyCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBwYXJzZSAnJS4qcyciCiBtc2dzdHIgImtow7RuZyB0aOG7gyBwaMOibiB0w61jaCBjw7ogcGjDoXAg4oCcJS4qc+KAnSIKIAotIzogc2VxdWVuY2VyLmM6MjIyOAorIzogc2VxdWVuY2VyLmM6MjE2NgogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIGxpbmUgJWQ6ICUuKnMiCiBtc2dzdHIgImTDsm5nIGtow7RuZyBo4bujcCBs4buHICVkOiAlLipzIgogCi0jOiBzZXF1ZW5jZXIuYzoyMjM5CisjOiBzZXF1ZW5jZXIuYzoyMTc3CiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCAnJXMnIHdpdGhvdXQgYSBwcmV2aW91cyBjb21taXQiCiBtc2dzdHIgImtow7RuZyB0aOG7gyDigJwlc+KAnSB0aOG7gyBtw6Aga2jDtG5nIGPDsyBs4bqnbiBjaHV54buDbiBnaWFvIGvhur8gdHLGsOG7m2MiCiAKLSM6IHNlcXVlbmNlci5jOjIyODcgYnVpbHRpbi9yZWJhc2UuYzoxNTMgYnVpbHRpbi9yZWJhc2UuYzoxNzgKKyM6IHNlcXVlbmNlci5jOjIyMjUgYnVpbHRpbi9yZWJhc2UuYzoxNTMgYnVpbHRpbi9yZWJhc2UuYzoxNzgKICM6IGJ1aWx0aW4vcmViYXNlLmM6MjA0IGJ1aWx0aW4vcmViYXNlLmM6MjI5CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCByZWFkICclcycuIgogbXNnc3RyICJraMO0bmcgdGjhu4MgxJHhu41jIOKAnCVz4oCdLiIKIAotIzogc2VxdWVuY2VyLmM6MjMyMworIzogc2VxdWVuY2VyLmM6MjI2MQogbXNnaWQgImNhbmNlbGxpbmcgYSBjaGVycnkgcGlja2luZyBpbiBwcm9ncmVzcyIKIG1zZ3N0ciAixJFhbmcgaOG7p3kgYuG7jyB0aGFvIHTDoWMgY2hlcnJ5IHBpY2sgxJFhbmcgdGjhu7FjIGhp4buHbiIKIAotIzogc2VxdWVuY2VyLmM6MjMzMAorIzogc2VxdWVuY2VyLmM6MjI2OAogbXNnaWQgImNhbmNlbGxpbmcgYSByZXZlcnQgaW4gcHJvZ3Jlc3MiCiBtc2dzdHIgIsSRYW5nIGjhu6d5IGLhu48gY8OhYyB0aGFvIHTDoWMgaG/DoG4gbmd1ecOqbiDEkWFuZyB0aOG7sWMgaGnhu4duIgogCi0jOiBzZXF1ZW5jZXIuYzoyMzY0CisjOiBzZXF1ZW5jZXIuYzoyMzAyCiBtc2dpZCAicGxlYXNlIGZpeCB0aGlzIHVzaW5nICdnaXQgcmViYXNlIC0tZWRpdC10b2RvJy4iCiBtc2dzdHIgInZ1aSBsw7JuZyBz4butYSBs4buXaSBuw6B5IGLhurFuZyBjw6FjaCBkw7luZyDigJxnaXQgcmViYXNlIC0tZWRpdC10b2Rv4oCdLiIKIAotIzogc2VxdWVuY2VyLmM6MjM2NgorIzogc2VxdWVuY2VyLmM6MjMwNAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bnVzYWJsZSBpbnN0cnVjdGlvbiBzaGVldDogJyVzJyIKIG1zZ3N0ciAiYuG6o25nIGNo4buJIHRo4buLIGtow7RuZyB0aOG7gyBkw7luZyDEkcaw4bujYzogJXMiCiAKLSM6IHNlcXVlbmNlci5jOjIzNzEKKyM6IHNlcXVlbmNlci5jOjIzMDkKIG1zZ2lkICJubyBjb21taXRzIHBhcnNlZC4iCiBtc2dzdHIgImtow7RuZyBjw7MgbOG6p24gY2h1eeG7g24gZ2lhbyBuw6BvIMSRxrDhu6NjIHBow6JuIHTDrWNoLiIKIAotIzogc2VxdWVuY2VyLmM6MjM4MgorIzogc2VxdWVuY2VyLmM6MjMyMAogbXNnaWQgImNhbm5vdCBjaGVycnktcGljayBkdXJpbmcgYSByZXZlcnQuIgogbXNnc3RyICJraMO0bmcgdGjhu4MgY2hlcnJ5LXBpY2sgdHJvbmcga2hpIGhvw6BuIG5ndXnDqm4uIgogCi0jOiBzZXF1ZW5jZXIuYzoyMzg0CisjOiBzZXF1ZW5jZXIuYzoyMzIyCiBtc2dpZCAiY2Fubm90IHJldmVydCBkdXJpbmcgYSBjaGVycnktcGljay4iCiBtc2dzdHIgImtow7RuZyB0aOG7gyB0aOG7sWMgaGnhu4duIHZp4buHYyBob8OgbiBuZ3V5w6puIHRyb25nIGtoaSDEkWFuZyBjaGVycnktcGljay4iCiAKLSM6IHNlcXVlbmNlci5jOjI0NjYKKyM6IHNlcXVlbmNlci5jOjI0MDQKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCB2YWx1ZSBmb3IgJXM6ICVzIgogbXNnc3RyICJnacOhIHRy4buLIGNobyAlcyBraMO0bmcgaOG7o3AgbOG7hzogJXMiCiAKLSM6IHNlcXVlbmNlci5jOjI1NTMKKyM6IHNlcXVlbmNlci5jOjI0OTEKIG1zZ2lkICJ1bnVzYWJsZSBzcXVhc2gtb250byIKIG1zZ3N0ciAic3F1YXNoLW9udG8ga2jDtG5nIGTDuW5nIMSRxrDhu6NjIgogCi0jOiBzZXF1ZW5jZXIuYzoyNTY5CisjOiBzZXF1ZW5jZXIuYzoyNTA3CiAjLCBjLWZvcm1hdAogbXNnaWQgIm1hbGZvcm1lZCBvcHRpb25zIHNoZWV0OiAnJXMnIgogbXNnc3RyICJi4bqjbmcgdMO5eSBjaOG7jW4gZOG7iyBow6xuaDog4oCcJXPigJ0iCiAKLSM6IHNlcXVlbmNlci5jOjI2NTIgc2VxdWVuY2VyLmM6NDM1MQorIzogc2VxdWVuY2VyLmM6MjU5MCBzZXF1ZW5jZXIuYzo0MzA4CiBtc2dpZCAiZW1wdHkgY29tbWl0IHNldCBwYXNzZWQiCiBtc2dzdHIgImzhuqduIGNodXnhu4NuIGdpYW8gdHLhu5FuZyBy4buXbmcgxJHhurd0IGzDoCBo4bujcCBxdXkgY8OhY2giCiAKLSM6IHNlcXVlbmNlci5jOjI2NjgKKyM6IHNlcXVlbmNlci5jOjI2MDYKIG1zZ2lkICJyZXZlcnQgaXMgYWxyZWFkeSBpbiBwcm9ncmVzcyIKIG1zZ3N0ciAiY8OzIHRoYW8gdMOhYyBob8OgbiBuZ3V5w6puIMSRYW5nIMSRxrDhu6NjIHRo4buxYyBoaeG7h24iCiAKLSM6IHNlcXVlbmNlci5jOjI2NzAKKyM6IHNlcXVlbmNlci5jOjI2MDgKICMsIGMtZm9ybWF0CiBtc2dpZCAidHJ5IFwiZ2l0IHJldmVydCAoLS1jb250aW51ZSB8ICVzLS1hYm9ydCB8IC0tcXVpdClcIiIKIG1zZ3N0ciAiaMOjeSB0aOG7rSBcImdpdCByZXZlcnQgKC0tY29udGludWUgfCAlcy0tYWJvcnQgfCAtLXF1aXQpXCIiCiAKLSM6IHNlcXVlbmNlci5jOjI2NzMKKyM6IHNlcXVlbmNlci5jOjI2MTEKIG1zZ2lkICJjaGVycnktcGljayBpcyBhbHJlYWR5IGluIHByb2dyZXNzIgogbXNnc3RyICJjw7MgdGhhbyB0w6FjIOKAnGNoZXJyeS1waWNr4oCdIMSRYW5nIMSRxrDhu6NjIHRo4buxYyBoaeG7h24iCiAKLSM6IHNlcXVlbmNlci5jOjI2NzUKKyM6IHNlcXVlbmNlci5jOjI2MTMKICMsIGMtZm9ybWF0CiBtc2dpZCAidHJ5IFwiZ2l0IGNoZXJyeS1waWNrICgtLWNvbnRpbnVlIHwgJXMtLWFib3J0IHwgLS1xdWl0KVwiIgogbXNnc3RyICJow6N5IHRo4butIFwiZ2l0IGNoZXJyeS1waWNrICgtLWNvbnRpbnVlIHwgJXMtLWFib3J0IHwgLS1xdWl0KVwiIgogCi0jOiBzZXF1ZW5jZXIuYzoyNjg5CisjOiBzZXF1ZW5jZXIuYzoyNjI3CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBjcmVhdGUgc2VxdWVuY2VyIGRpcmVjdG9yeSAnJXMnIgogbXNnc3RyICJraMO0bmcgdGjhu4MgdOG6oW8gdGjGsCBt4bulYyB44bq/cCBkw6N5IOKAnCVz4oCdIgogCi0jOiBzZXF1ZW5jZXIuYzoyNzA0CisjOiBzZXF1ZW5jZXIuYzoyNjQyCiBtc2dpZCAiY291bGQgbm90IGxvY2sgSEVBRCIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIGtow7NhIEhFQUQiCiAKLSM6IHNlcXVlbmNlci5jOjI3NjQgc2VxdWVuY2VyLmM6NDEwMworIzogc2VxdWVuY2VyLmM6MjcwMiBzZXF1ZW5jZXIuYzo0MDU3CiBtc2dpZCAibm8gY2hlcnJ5LXBpY2sgb3IgcmV2ZXJ0IGluIHByb2dyZXNzIgogbXNnc3RyICJraMO0bmcgY2hlcnJ5LXBpY2sgaGF5IGhvw6BuIG5ndXnDqm4gdHJvbmcgdGnhur9uIHRyw6xuaCIKIAotIzogc2VxdWVuY2VyLmM6Mjc2NiBzZXF1ZW5jZXIuYzoyNzc3CisjOiBzZXF1ZW5jZXIuYzoyNzA0IHNlcXVlbmNlci5jOjI3MTUKIG1zZ2lkICJjYW5ub3QgcmVzb2x2ZSBIRUFEIgogbXNnc3RyICJraMO0bmcgdGjhu4MgcGjDom4gZ2nhuqNpIEhFQUQiCiAKLSM6IHNlcXVlbmNlci5jOjI3Njggc2VxdWVuY2VyLmM6MjgxMgorIzogc2VxdWVuY2VyLmM6MjcwNiBzZXF1ZW5jZXIuYzoyNzUwCiBtc2dpZCAiY2Fubm90IGFib3J0IGZyb20gYSBicmFuY2ggeWV0IHRvIGJlIGJvcm4iCiBtc2dzdHIgImtow7RuZyB0aOG7gyBo4buneSBi4buPIHThu6sgbeG7mXQgbmjDoW5oIG3DoCBuw7MgY8OybiBjaMawYSDEkcaw4bujYyB04bqhbyByYSIKIAotIzogc2VxdWVuY2VyLmM6Mjc5OCBidWlsdGluL2dyZXAuYzo3MzQKKyM6IHNlcXVlbmNlci5jOjI3MzYgYnVpbHRpbi9ncmVwLmM6NzM2CiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCBvcGVuICclcyciCiBtc2dzdHIgImtow7RuZyBt4bufIMSRxrDhu6NjIOKAnCVz4oCdIgogCi0jOiBzZXF1ZW5jZXIuYzoyODAwCisjOiBzZXF1ZW5jZXIuYzoyNzM4CiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCByZWFkICclcyc6ICVzIgogbXNnc3RyICJraMO0bmcgdGjhu4MgxJHhu41jIOKAnCVz4oCdOiAlcyIKIAotIzogc2VxdWVuY2VyLmM6MjgwMQorIzogc2VxdWVuY2VyLmM6MjczOQogbXNnaWQgInVuZXhwZWN0ZWQgZW5kIG9mIGZpbGUiCiBtc2dzdHIgImfhurdwIGvhur90IHRow7pjIHThuq1wIHRpbiDEkeG7mXQgeHXhuqV0IgogCi0jOiBzZXF1ZW5jZXIuYzoyODA3CisjOiBzZXF1ZW5jZXIuYzoyNzQ1CiAjLCBjLWZvcm1hdAogbXNnaWQgInN0b3JlZCBwcmUtY2hlcnJ5LXBpY2sgSEVBRCBmaWxlICclcycgaXMgY29ycnVwdCIKIG1zZ3N0ciAidOG6rXAgdGluIEhFQUQg4oCccHJlLWNoZXJyeS1waWNr4oCdIMSRw6MgbMawdSDigJwlc+KAnSBi4buLIGjhu49uZyIKIAotIzogc2VxdWVuY2VyLmM6MjgxOAorIzogc2VxdWVuY2VyLmM6Mjc1NgogbXNnaWQgIllvdSBzZWVtIHRvIGhhdmUgbW92ZWQgSEVBRC4gTm90IHJld2luZGluZywgY2hlY2sgeW91ciBIRUFEISIKIG1zZ3N0ciAiIgogIkLhuqFuIGPDsyBs4bq9IMSRw6MgY8OzIEhFQUQgxJHDoyBi4buLIGRpIGNodXnhu4NuIMSRaSwgS2jDtG5nIHRo4buDIHR1YSwga2nhu4NtIHRyYSBIRUFEIGPhu6dhICIKICJi4bqhbiEiCiAKLSM6IHNlcXVlbmNlci5jOjI4NTkKKyM6IHNlcXVlbmNlci5jOjI3OTcKIG1zZ2lkICJubyByZXZlcnQgaW4gcHJvZ3Jlc3MiCiBtc2dzdHIgImtow7RuZyBjw7MgdGnhur9uIHRyw6xuaCBob8OgbiBuZ3V5w6puIG7DoG8iCiAKLSM6IHNlcXVlbmNlci5jOjI4NjcKKyM6IHNlcXVlbmNlci5jOjI4MDUKIG1zZ2lkICJubyBjaGVycnktcGljayBpbiBwcm9ncmVzcyIKIG1zZ3N0ciAia2jDtG5nIGPDsyBjaGVycnktcGljayDEkWFuZyDEkcaw4bujYyB0aOG7sWMgaGnhu4duIgogCi0jOiBzZXF1ZW5jZXIuYzoyODc3CisjOiBzZXF1ZW5jZXIuYzoyODE1CiBtc2dpZCAiZmFpbGVkIHRvIHNraXAgdGhlIGNvbW1pdCIKIG1zZ3N0ciAiZ+G6t3AgbOG7l2kga2hpIGLhu48gcXVhIMSR4buRaSB0xrDhu6NuZyBjaHV54buDbiBnaWFvIgogCi0jOiBzZXF1ZW5jZXIuYzoyODg0CisjOiBzZXF1ZW5jZXIuYzoyODIyCiBtc2dpZCAidGhlcmUgaXMgbm90aGluZyB0byBza2lwIgogbXNnc3RyICLhu58gxJHDonkga2jDtG5nIGPDsyBnw6wgxJHhu4MgbcOgIGLhu48gcXVhIGPhuqMiCiAKLSM6IHNlcXVlbmNlci5jOjI4ODcKKyM6IHNlcXVlbmNlci5jOjI4MjUKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogImhhdmUgeW91IGNvbW1pdHRlZCBhbHJlYWR5P1xuIgpAQCAtNjMwOCwyMSArNjMzMywyMSBAQAogImLhuqFuIMSRw6Mgc+G6tW4gc8OgbmcgY2h1eeG7g24gZ2lhbyBjaMawYT9cbiIKICJ0aOG7rSBcImdpdCAlcyAtLWNvbnRpbnVlXCIiCiAKLSM6IHNlcXVlbmNlci5jOjMwMTEgc2VxdWVuY2VyLmM6NDAxNQorIzogc2VxdWVuY2VyLmM6Mjk0OSBzZXF1ZW5jZXIuYzozOTY5CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCB1cGRhdGUgJXMiCiBtc2dzdHIgImtow7RuZyB0aOG7gyBj4bqtcCBuaOG6rXQgJXMiCiAKLSM6IHNlcXVlbmNlci5jOjMwNDkgc2VxdWVuY2VyLmM6Mzk5NQorIzogc2VxdWVuY2VyLmM6Mjk4NyBzZXF1ZW5jZXIuYzozOTQ5CiBtc2dpZCAiY2Fubm90IHJlYWQgSEVBRCIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIMSR4buNYyBIRUFEIgogCi0jOiBzZXF1ZW5jZXIuYzozMDY2CisjOiBzZXF1ZW5jZXIuYzozMDA0CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBjb3B5ICclcycgdG8gJyVzJyIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIGNow6lwIOKAnCVz4oCdIHNhbmcg4oCcJXPigJ0iCiAKLSM6IHNlcXVlbmNlci5jOjMwNzQKKyM6IHNlcXVlbmNlci5jOjMwMTIKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIllvdSBjYW4gYW1lbmQgdGhlIGNvbW1pdCBub3csIHdpdGhcbiIKQEAgLTYzNDEsMjcgKzYzNjYsMjcgQEAKICJcbiIKICIgIGdpdCByZWJhc2UgLS1jb250aW51ZVxuIgogCi0jOiBzZXF1ZW5jZXIuYzozMDg0CisjOiBzZXF1ZW5jZXIuYzozMDIyCiAjLCBjLWZvcm1hdAogbXNnaWQgIkNvdWxkIG5vdCBhcHBseSAlcy4uLiAlLipzIgogbXNnc3RyICJLaMO0bmcgdGjhu4Mgw6FwIGThu6VuZyAlc+KApiAlLipzIgogCi0jOiBzZXF1ZW5jZXIuYzozMDkxCisjOiBzZXF1ZW5jZXIuYzozMDI5CiAjLCBjLWZvcm1hdAogbXNnaWQgIkNvdWxkIG5vdCBtZXJnZSAlLipzIgogbXNnc3RyICJLaMO0bmcgaMOyYSB0cuG7mW4gJS4qcyIKIAotIzogc2VxdWVuY2VyLmM6MzEwNSBzZXF1ZW5jZXIuYzozMTA5IGJ1aWx0aW4vZGlmZnRvb2wuYzo2MzMKKyM6IHNlcXVlbmNlci5jOjMwNDMgc2VxdWVuY2VyLmM6MzA0NyBidWlsdGluL2RpZmZ0b29sLmM6NjQxCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBjb3B5ICclcycgdG8gJyVzJyIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIGNow6lwIOKAnCVz4oCdIHNhbmcg4oCcJXPigJ0iCiAKLSM6IHNlcXVlbmNlci5jOjMxMzEgc2VxdWVuY2VyLmM6MzU1OCBidWlsdGluL3JlYmFzZS5jOjg0OSBidWlsdGluL3JlYmFzZS5jOjE1ODIKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTk1MyBidWlsdGluL3JlYmFzZS5jOjIwMDgKKyM6IHNlcXVlbmNlci5jOjMwNjkgc2VxdWVuY2VyLmM6MzUwNiBidWlsdGluL3JlYmFzZS5jOjg1MCBidWlsdGluL3JlYmFzZS5jOjE2MTMKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTk4NyBidWlsdGluL3JlYmFzZS5jOjIwMzEKIG1zZ2lkICJjb3VsZCBub3QgcmVhZCBpbmRleCIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIMSR4buNYyBi4bqjbmcgbeG7pWMgbOG7pWMiCiAKLSM6IHNlcXVlbmNlci5jOjMxMzYKKyM6IHNlcXVlbmNlci5jOjMwNzQKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogImV4ZWN1dGlvbiBmYWlsZWQ6ICVzXG4iCkBAIC02Mzc2LDExICs2NDAxLDExIEBACiAiICBnaXQgcmViYXNlIC0tY29udGludWVcbiIKICJcbiIKIAotIzogc2VxdWVuY2VyLmM6MzE0MgorIzogc2VxdWVuY2VyLmM6MzA4MAogbXNnaWQgImFuZCBtYWRlIGNoYW5nZXMgdG8gdGhlIGluZGV4IGFuZC9vciB0aGUgd29ya2luZyB0cmVlXG4iCiBtc2dzdHIgInbDoCB04bqhbyBjw6FjIHRoYXkgxJHhu5VpIGLhuqNuZyBt4bulYyBs4bulYyB2w6AvaGF5IGPDonkgbMOgbSB2aeG7h2NcbiIKIAotIzogc2VxdWVuY2VyLmM6MzE0OAorIzogc2VxdWVuY2VyLmM6MzA4NgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiZXhlY3V0aW9uIHN1Y2NlZWRlZDogJXNcbiIKQEAgLTYzOTcsNzYgKzY0MjIsNzYgQEAKICIgIGdpdCByZWJhc2UgLS1jb250aW51ZVxuIgogIlxuIgogCi0jOiBzZXF1ZW5jZXIuYzozMjA5CisjOiBzZXF1ZW5jZXIuYzozMTQ3CiAjLCBjLWZvcm1hdAogbXNnaWQgImlsbGVnYWwgbGFiZWwgbmFtZTogJyUuKnMnIgogbXNnc3RyICJ0w6puIG5ow6NuIGThu4sgaMOsbmg6IOKAnCUuKnPigJ0iCiAKLSM6IHNlcXVlbmNlci5jOjMyNjMKKyM6IHNlcXVlbmNlci5jOjMyMDEKIG1zZ2lkICJ3cml0aW5nIGZha2Ugcm9vdCBjb21taXQiCiBtc2dzdHIgImdoaSBs4bqnbiBjaHV54buDbiBnaWFvIGfhu5FjIGdp4bqjIgogCi0jOiBzZXF1ZW5jZXIuYzozMjY4CisjOiBzZXF1ZW5jZXIuYzozMjA2CiBtc2dpZCAid3JpdGluZyBzcXVhc2gtb250byIKIG1zZ3N0ciAixJFhbmcgZ2hpIHNxdWFzaC1vbnRvIgogCi0jOiBzZXF1ZW5jZXIuYzozMzA2IGJ1aWx0aW4vcmViYXNlLmM6ODU0IGJ1aWx0aW4vcmViYXNlLmM6ODYwCisjOiBzZXF1ZW5jZXIuYzozMjQ0IGJ1aWx0aW4vcmViYXNlLmM6ODU1IGJ1aWx0aW4vcmViYXNlLmM6ODYxCiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBmaW5kIHRyZWUgb2YgJXMiCiBtc2dzdHIgImfhurdwIGzhu5dpIGtoaSB0w6xtIGPDonkgY+G7p2EgJXMiCiAKLSM6IHNlcXVlbmNlci5jOjMzMjQgYnVpbHRpbi9yZWJhc2UuYzo4NzMKKyM6IHNlcXVlbmNlci5jOjMyNjIgYnVpbHRpbi9yZWJhc2UuYzo4NzQKIG1zZ2lkICJjb3VsZCBub3Qgd3JpdGUgaW5kZXgiCiBtc2dzdHIgImtow7RuZyB0aOG7gyBnaGkgYuG6o25nIG3hu6VjIGzhu6VjIgogCi0jOiBzZXF1ZW5jZXIuYzozMzUxCisjOiBzZXF1ZW5jZXIuYzozMjg5CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCByZXNvbHZlICclcyciCiBtc2dzdHIgImtow7RuZyB0aOG7gyBwaMOibiBnaeG6o2kg4oCcJXPigJ0iCiAKLSM6IHNlcXVlbmNlci5jOjMzNzkKKyM6IHNlcXVlbmNlci5jOjMzMjAKIG1zZ2lkICJjYW5ub3QgbWVyZ2Ugd2l0aG91dCBhIGN1cnJlbnQgcmV2aXNpb24iCiBtc2dzdHIgImtow7RuZyB0aOG7gyBow7JhIHRy4buZbiBtw6Aga2jDtG5nIGPDsyBt4buZdCDEkWnhu4NtIHjDqXQgZHV54buHdCBoaeG7h24gdOG6oWkiCiAKLSM6IHNlcXVlbmNlci5jOjM0MDEKKyM6IHNlcXVlbmNlci5jOjMzNDIKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHBhcnNlICclLipzJyIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIHBow6JuIHTDrWNoIOKAnCUuKnPigJ0iCiAKLSM6IHNlcXVlbmNlci5jOjM0MTAKKyM6IHNlcXVlbmNlci5jOjMzNTEKICMsIGMtZm9ybWF0CiBtc2dpZCAibm90aGluZyB0byBtZXJnZTogJyUuKnMnIgogbXNnc3RyICJjaOG6s25nIGPDsyBnw6wgxJHhu4MgaMOyYSB0cuG7mW46IOKAnCUuKnPigJ0iCiAKLSM6IHNlcXVlbmNlci5jOjM0MjIKKyM6IHNlcXVlbmNlci5jOjMzNjMKIG1zZ2lkICJvY3RvcHVzIG1lcmdlIGNhbm5vdCBiZSBleGVjdXRlZCBvbiB0b3Agb2YgYSBbbmV3IHJvb3RdIgogbXNnc3RyICJow7JhIHRy4buZbiBvY3RvcHVzIGtow7RuZyB0aOG7gyDEkcaw4bujYyB0aOG7sWMgdGhpIHRyw6puIMSR4buJbmggY+G7p2EgbeG7mXQgW25ldyByb290XSIKIAotIzogc2VxdWVuY2VyLmM6MzQzNworIzogc2VxdWVuY2VyLmM6MzM3OAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgZ2V0IGNvbW1pdCBtZXNzYWdlIG9mICclcyciCiBtc2dzdHIgImtow7RuZyB0aOG7gyBs4bqleSBjaMO6IHRow61jaCBj4bunYSBs4bqnbiBjaHV54buDbiBnaWFvIGPhu6dhIOKAnCVz4oCdIgogCi0jOiBzZXF1ZW5jZXIuYzozNTkwCisjOiBzZXF1ZW5jZXIuYzozNTM4CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBldmVuIGF0dGVtcHQgdG8gbWVyZ2UgJyUuKnMnIgogbXNnc3RyICJraMO0bmcgdGjhu4MgbmdheSBj4bqjIGtoaSB0aOG7rSBow7JhIHRy4buZbiDigJwlLipz4oCdIgogCi0jOiBzZXF1ZW5jZXIuYzozNjA2CisjOiBzZXF1ZW5jZXIuYzozNTU0CiBtc2dpZCAibWVyZ2U6IFVuYWJsZSB0byB3cml0ZSBuZXcgaW5kZXggZmlsZSIKIG1zZ3N0ciAibWVyZ2U6IEtow7RuZyB0aOG7gyBnaGkgdOG6rXAgdGluIGzGsHUgYuG6o25nIG3hu6VjIGzhu6VjIG3hu5tpIgogCi0jOiBzZXF1ZW5jZXIuYzozNjc1IGJ1aWx0aW4vcmViYXNlLmM6NzExCisjOiBzZXF1ZW5jZXIuYzozNjIzIGJ1aWx0aW4vcmViYXNlLmM6NzEyCiAjLCBjLWZvcm1hdAogbXNnaWQgIkFwcGxpZWQgYXV0b3N0YXNoLlxuIgogbXNnc3RyICLEkMOjIMOhcCBk4bulbmcgYXV0b3N0YXNoLlxuIgogCi0jOiBzZXF1ZW5jZXIuYzozNjg3CisjOiBzZXF1ZW5jZXIuYzozNjM1CiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCBzdG9yZSAlcyIKIG1zZ3N0ciAia2jDtG5nIHRo4butIGzGsHUg4oCcJXPigJ0iCiAKLSM6IHNlcXVlbmNlci5jOjM2OTAgYnVpbHRpbi9yZWJhc2UuYzo3MjcgZ2l0LXJlYmFzZS0tcHJlc2VydmUtbWVyZ2VzLnNoOjExMworIzogc2VxdWVuY2VyLmM6MzYzOCBidWlsdGluL3JlYmFzZS5jOjcyOCBnaXQtcmViYXNlLS1wcmVzZXJ2ZS1tZXJnZXMuc2g6MTEzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJBcHBseWluZyBhdXRvc3Rhc2ggcmVzdWx0ZWQgaW4gY29uZmxpY3RzLlxuIgpAQCAtNjQ3OCwzMSArNjUwMywzMSBAQAogIkLhuqFuIGPDsyB0aOG7gyBjaOG6oXkgbOG7h25oIFwiZ2l0IHN0YXNoIHBvcFwiIGhheSBcImdpdCBzdGFzaCBkcm9wXCIgYuG6pXQga+G7syBsw7pjICIKICJuw6BvLlxuIgogCi0jOiBzZXF1ZW5jZXIuYzozNzUxCisjOiBzZXF1ZW5jZXIuYzozNjk5CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBjaGVja291dCAlcyIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIGzhuqV5IHJhICVzIgogCi0jOiBzZXF1ZW5jZXIuYzozNzY1CisjOiBzZXF1ZW5jZXIuYzozNzEzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiBub3QgYSB2YWxpZCBPSUQiCiBtc2dzdHIgIiVzIGtow7RuZyBwaOG6o2kgbMOgIG3hu5l0IE9JRCBo4bujcCBs4buHIgogCi0jOiBzZXF1ZW5jZXIuYzozNzcwIGdpdC1yZWJhc2UtLXByZXNlcnZlLW1lcmdlcy5zaDo3NzkKKyM6IHNlcXVlbmNlci5jOjM3MTggZ2l0LXJlYmFzZS0tcHJlc2VydmUtbWVyZ2VzLnNoOjc3OQogbXNnaWQgImNvdWxkIG5vdCBkZXRhY2ggSEVBRCIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIHTDoWNoIHLhu51pIEhFQUQiCiAKLSM6IHNlcXVlbmNlci5jOjM3ODUKKyM6IHNlcXVlbmNlci5jOjM3MzMKICMsIGMtZm9ybWF0CiBtc2dpZCAiU3RvcHBlZCBhdCBIRUFEXG4iCiBtc2dzdHIgIkThu6tuZyBs4bqhaSDhu58gSEVBRFxuIgogCi0jOiBzZXF1ZW5jZXIuYzozNzg3CisjOiBzZXF1ZW5jZXIuYzozNzM1CiAjLCBjLWZvcm1hdAogbXNnaWQgIlN0b3BwZWQgYXQgJXNcbiIKIG1zZ3N0ciAiROG7q25nIGzhuqFpIOG7nyAlc1xuIgogCi0jOiBzZXF1ZW5jZXIuYzozNzk1CisjOiBzZXF1ZW5jZXIuYzozNzQzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJDb3VsZCBub3QgZXhlY3V0ZSB0aGUgdG9kbyBjb21tYW5kXG4iCkBAIC02NTIzLDQ4ICs2NTQ4LDQ4IEBACiAiICAgIGdpdCByZWJhc2UgLS1lZGl0LXRvZG9cbiIKICIgICAgZ2l0IHJlYmFzZSAtLWNvbnRpbnVlXG4iCiAKLSM6IHNlcXVlbmNlci5jOjM4NzcKKyM6IHNlcXVlbmNlci5jOjM4MjcKICMsIGMtZm9ybWF0CiBtc2dpZCAiU3RvcHBlZCBhdCAlcy4uLiAgJS4qc1xuIgogbXNnc3RyICJE4burbmcgbOG6oWkg4bufICVz4oCmICAlLipzXG4iCiAKLSM6IHNlcXVlbmNlci5jOjM5NTgKKyM6IHNlcXVlbmNlci5jOjM4OTgKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5rbm93biBjb21tYW5kICVkIgogbXNnc3RyICJraMO0bmcgaGnhu4N1IGPDonUgbOG7h25oICVkIgogCi0jOiBzZXF1ZW5jZXIuYzo0MDAzCisjOiBzZXF1ZW5jZXIuYzozOTU3CiBtc2dpZCAiY291bGQgbm90IHJlYWQgb3JpZy1oZWFkIgogbXNnc3RyICJraMO0bmcgdGjhu4MgxJHhu41jIG9yaWctaGVhZCIKIAotIzogc2VxdWVuY2VyLmM6NDAwOAorIzogc2VxdWVuY2VyLmM6Mzk2MgogbXNnaWQgImNvdWxkIG5vdCByZWFkICdvbnRvJyIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIMSR4buNYyDigJxvbnRv4oCdLiIKIAotIzogc2VxdWVuY2VyLmM6NDAyMgorIzogc2VxdWVuY2VyLmM6Mzk3NgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgdXBkYXRlIEhFQUQgdG8gJXMiCiBtc2dzdHIgImtow7RuZyB0aOG7gyBj4bqtcCBuaOG6rXQgSEVBRCB0aMOgbmggJXMiCiAKLSM6IHNlcXVlbmNlci5jOjQxMTUKKyM6IHNlcXVlbmNlci5jOjQwNjkKIG1zZ2lkICJjYW5ub3QgcmViYXNlOiBZb3UgaGF2ZSB1bnN0YWdlZCBjaGFuZ2VzLiIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIGPhuqNpIHThu5U6IELhuqFuIGPDsyBjw6FjIHRoYXkgxJHhu5VpIGNoxrBhIMSRxrDhu6NjIMSRxrBhIGzDqm4gYuG7hyBwaMOzbmcuIgogCi0jOiBzZXF1ZW5jZXIuYzo0MTI0CisjOiBzZXF1ZW5jZXIuYzo0MDc4CiBtc2dpZCAiY2Fubm90IGFtZW5kIG5vbi1leGlzdGluZyBjb21taXQiCiBtc2dzdHIgImtow7RuZyB0aOG7gyB0dSBi4buPIG3hu5l0IGzhuqduIGNodXnhu4NuIGdpYW8ga2jDtG5nIHThu5NuIHThuqFpIgogCi0jOiBzZXF1ZW5jZXIuYzo0MTI2CisjOiBzZXF1ZW5jZXIuYzo0MDgwCiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgZmlsZTogJyVzJyIKIG1zZ3N0ciAidOG6rXAgdGluIGtow7RuZyBo4bujcCBs4buHOiDigJwlc+KAnSIKIAotIzogc2VxdWVuY2VyLmM6NDEyOAorIzogc2VxdWVuY2VyLmM6NDA4MgogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIGNvbnRlbnRzOiAnJXMnIgogbXNnc3RyICJu4buZaSBkdW5nIGtow7RuZyBo4bujcCBs4buHOiDigJwlc+KAnSIKIAotIzogc2VxdWVuY2VyLmM6NDEzMQorIzogc2VxdWVuY2VyLmM6NDA4NQogbXNnaWQgIiIKICJcbiIKICJZb3UgaGF2ZSB1bmNvbW1pdHRlZCBjaGFuZ2VzIGluIHlvdXIgd29ya2luZyB0cmVlLiBQbGVhc2UsIGNvbW1pdCB0aGVtXG4iCkBAIC02NTc0LDQyICs2NTk5LDQyIEBACiAiQuG6oW4gY8OzIGPDoWMgdGhheSDEkeG7lWkgY2jGsGEgY2h1eeG7g24gZ2lhbyB0cm9uZyB0aMawIG3hu6VjIGzDoG0gdmnhu4djLiBWdWkgbMOybmdcbiIKICJjaHV54buDbiBnaWFvIGNow7puZyB0csaw4bubYyB2w6Agc2F1IMSRw7MgY2jhuqF5IGzhu4duaCDigJxnaXQgcmViYXNlIC0tY29udGludWXigJ0gbOG6p24gbuG7r2EuIgogCi0jOiBzZXF1ZW5jZXIuYzo0MTY3IHNlcXVlbmNlci5jOjQyMDUKKyM6IHNlcXVlbmNlci5jOjQxMjEgc2VxdWVuY2VyLmM6NDE1OQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3Qgd3JpdGUgZmlsZTogJyVzJyIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIGdoaSB04bqtcCB0aW46IOKAnCVz4oCdIgogCi0jOiBzZXF1ZW5jZXIuYzo0MjIwCisjOiBzZXF1ZW5jZXIuYzo0MTc0CiBtc2dpZCAiY291bGQgbm90IHJlbW92ZSBDSEVSUllfUElDS19IRUFEIgogbXNnc3RyICJraMO0bmcgdGjhu4MgeMOzYSBi4buPIENIRVJSWV9QSUNLX0hFQUQiCiAKLSM6IHNlcXVlbmNlci5jOjQyMjcKKyM6IHNlcXVlbmNlci5jOjQxODEKIG1zZ2lkICJjb3VsZCBub3QgY29tbWl0IHN0YWdlZCBjaGFuZ2VzLiIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIGNodXnhu4NuIGdpYW8gY8OhYyB0aGF5IMSR4buVaSDEkcOjIMSRxrBhIGzDqm4gYuG7hyBwaMOzbmcuIgogCi0jOiBzZXF1ZW5jZXIuYzo0MzI4CisjOiBzZXF1ZW5jZXIuYzo0Mjg1CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiBjYW4ndCBjaGVycnktcGljayBhICVzIgogbXNnc3RyICIlczoga2jDtG5nIHRo4buDIGNoZXJyeS1waWNrIG3hu5l0ICVzIgogCi0jOiBzZXF1ZW5jZXIuYzo0MzMyCisjOiBzZXF1ZW5jZXIuYzo0Mjg5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiBiYWQgcmV2aXNpb24iCiBtc2dzdHIgIiVzOiDEkWnhu4NtIHjDqXQgZHV54buHdCBzYWkiCiAKLSM6IHNlcXVlbmNlci5jOjQzNjcKKyM6IHNlcXVlbmNlci5jOjQzMjQKIG1zZ2lkICJjYW4ndCByZXZlcnQgYXMgaW5pdGlhbCBjb21taXQiCiBtc2dzdHIgImtow7RuZyB0aOG7gyBob8OgbiBuZ3V5w6puIG3hu5l0IGzhuqduIGNodXnhu4NuIGdpYW8ga2jhu59pIHThuqFvIgogCi0jOiBzZXF1ZW5jZXIuYzo0ODEwCisjOiBzZXF1ZW5jZXIuYzo0Nzc0CiBtc2dpZCAibWFrZV9zY3JpcHQ6IHVuaGFuZGxlZCBvcHRpb25zIgogbXNnc3RyICJtYWtlX3NjcmlwdDogY8OhYyB0w7l5IGNo4buNbiDEkcaw4bujYyBraMO0bmcgeOG7rSBsw70iCiAKLSM6IHNlcXVlbmNlci5jOjQ4MTMKKyM6IHNlcXVlbmNlci5jOjQ3NzcKIG1zZ2lkICJtYWtlX3NjcmlwdDogZXJyb3IgcHJlcGFyaW5nIHJldmlzaW9ucyIKIG1zZ3N0ciAibWFrZV9zY3JpcHQ6IGzhu5dpIGNodeG6qW4gYuG7iyDEkWnhu4NtIGhp4buHdSBjaOG7iW5oIgogCi0jOiBzZXF1ZW5jZXIuYzo0OTcxCisjOiBzZXF1ZW5jZXIuYzo0OTM1CiBtc2dpZCAiIgogIllvdSBjYW4gZml4IHRoaXMgd2l0aCAnZ2l0IHJlYmFzZSAtLWVkaXQtdG9kbycgYW5kIHRoZW4gcnVuICdnaXQgcmViYXNlIC0tIgogImNvbnRpbnVlJy5cbiIKQEAgLTY2MTksMjQgKzY2NDQsMjQgQEAKICJjb250aW51ZeKAnS5cbiIKICJIb+G6t2MgbMOgIGLhuqFuIGPDsyB0aOG7gyBiw6NpIGLhu48gdmnhu4djIGPhuqNpIHThu5UgYuG6sW5nIOKAnGdpdCByZWJhc2UgLS1hYm9ydOKAnS5cbiIKIAotIzogc2VxdWVuY2VyLmM6NTA4MyBzZXF1ZW5jZXIuYzo1MTAwCisjOiBzZXF1ZW5jZXIuYzo1MDQ3IHNlcXVlbmNlci5jOjUwNjQKIG1zZ2lkICJub3RoaW5nIHRvIGRvIgogbXNnc3RyICJraMO0bmcgY8OzIGfDrCDEkeG7gyBsw6BtIgogCi0jOiBzZXF1ZW5jZXIuYzo1MTE0CisjOiBzZXF1ZW5jZXIuYzo1MDc4CiBtc2dpZCAiY291bGQgbm90IHNraXAgdW5uZWNlc3NhcnkgcGljayBjb21tYW5kcyIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIGLhu48gcXVhIGPDoWMgbOG7h25oIGPhuq15IChwaWNrKSBraMO0bmcgY+G6p24gdGhp4bq/dCIKIAotIzogc2VxdWVuY2VyLmM6NTE5NworIzogc2VxdWVuY2VyLmM6NTE2NgogbXNnaWQgInRoZSBzY3JpcHQgd2FzIGFscmVhZHkgcmVhcnJhbmdlZC4iCiBtc2dzdHIgInbEg24gbOG7h25oIMSRw6Mgc+G6tW4gxJHGsOG7o2Mgc+G6r3AgxJHhurd0IHLhu5NpLiIKIAotIzogc2V0dXAuYzoxMjMKKyM6IHNldHVwLmM6MTI0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiclcycgaXMgb3V0c2lkZSByZXBvc2l0b3J5IgogbXNnc3RyICLigJwlc+KAnSDhu58gbmdvw6BpIG3hu5l0IGtobyBjaOG7qWEiCiAKLSM6IHNldHVwLmM6MTczCisjOiBzZXR1cC5jOjE3NAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiJXM6IG5vIHN1Y2ggcGF0aCBpbiB0aGUgd29ya2luZyB0cmVlLlxuIgpAQCAtNjY0Niw3ICs2NjcxLDcgQEAKICJEw7luZyDigJxnaXQgPGzhu4duaD4gLS0gPMSRxrDhu51uZy9k4bqrbj7igKbigJ0gxJHhu4MgY2jhu4kgxJHhu4tuaCDEkcaw4budbmcgZOG6q24gbcOgIG7DsyBraMO0bmcgdOG7k24gdOG6oWkgIgogIm3hu5l0IGPDoWNoIG7hu5lpIGLhu5kuIgogCi0jOiBzZXR1cC5jOjE4NgorIzogc2V0dXAuYzoxODcKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogImFtYmlndW91cyBhcmd1bWVudCAnJXMnOiB1bmtub3duIHJldmlzaW9uIG9yIHBhdGggbm90IGluIHRoZSB3b3JraW5nIHRyZWUuXG4iCkBAIC02NjU4LDEyICs2NjgzLDEyIEBACiAiRMO5bmcg4oCcLS3igJ0gxJHhu4MgbmfEg24gY8OhY2ggY8OhYyDEkcaw4budbmcgZOG6q24ga2jhu49pIMSRaeG7g20geGVtIHjDqXQsIG5oxrAgdGjhur8gbsOgeTpcbiIKICLigJxnaXQgPGzhu4duaD4gWzzEkWnhu4NtIHhlbSB4w6l0PuKApl0gLS0gWzx04bqtcCB0aW4+4oCmXeKAnSIKIAotIzogc2V0dXAuYzoyMzUKKyM6IHNldHVwLmM6MjM2CiAjLCBjLWZvcm1hdAogbXNnaWQgIm9wdGlvbiAnJXMnIG11c3QgY29tZSBiZWZvcmUgbm9uLW9wdGlvbiBhcmd1bWVudHMiCiBtc2dzdHIgInTDuXkgY2jhu41uIOKAnCVz4oCdIHBo4bqjaSB0csaw4bubYyBjw6FjIMSR4buRaSBz4buRIMSR4bqndSB0acOqbiBraMO0bmcgY8OzIHTDuXkgY2jhu41uIgogCi0jOiBzZXR1cC5jOjI1NAorIzogc2V0dXAuYzoyNTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogImFtYmlndW91cyBhcmd1bWVudCAnJXMnOiBib3RoIHJldmlzaW9uIGFuZCBmaWxlbmFtZVxuIgpAQCAtNjY3NCw5MiArNjY5OSw5MiBAQAogIkTDuW5nIOKAnC0t4oCdIMSR4buDIG5nxINuIGPDoWNoIGPDoWMgxJHGsOG7nW5nIGThuqtuIGto4buPaSDEkWnhu4NtIHhlbSB4w6l0LCBuaMawIHRo4bq/IG7DoHk6XG4iCiAi4oCcZ2l0IDxs4buHbmg+IFs8xJFp4buDbSB4ZW0geMOpdD7igKZdIC0tIFs8dOG6rXAgdGluPuKApl3igJ0iCiAKLSM6IHNldHVwLmM6MzkwCisjOiBzZXR1cC5jOjM5MQogbXNnaWQgInVuYWJsZSB0byBzZXQgdXAgd29yayB0cmVlIHVzaW5nIGludmFsaWQgY29uZmlnIgogbXNnc3RyICJraMO0bmcgdGjhu4MgY8OgaSDEkeG6t3QgdGjGsCBt4bulYyBsw6BtIHZp4buHYyBz4butIGThu6VuZyBj4bqldSBow6xuaCBraMO0bmcgaOG7o3AgbOG7hyIKIAotIzogc2V0dXAuYzozOTQKKyM6IHNldHVwLmM6Mzk1CiBtc2dpZCAidGhpcyBvcGVyYXRpb24gbXVzdCBiZSBydW4gaW4gYSB3b3JrIHRyZWUiCiBtc2dzdHIgInRoYW8gdMOhYyBuw6B5IHBo4bqjaSDEkcaw4bujYyB0aOG7sWMgaGnhu4duIHRyb25nIHRoxrAgbeG7pWMgbMOgbSB2aeG7h2MiCiAKLSM6IHNldHVwLmM6NTQwCisjOiBzZXR1cC5jOjU0MQogIywgYy1mb3JtYXQKIG1zZ2lkICJFeHBlY3RlZCBnaXQgcmVwbyB2ZXJzaW9uIDw9ICVkLCBmb3VuZCAlZCIKIG1zZ3N0ciAiQ+G6p24gcGhpw6puIGLhuqNuIGtobyBnaXQgPD0gJWQsIG5oxrBuZyBs4bqhaSBuaOG6rW4gxJHGsOG7o2MgJWQiCiAKLSM6IHNldHVwLmM6NTQ4CisjOiBzZXR1cC5jOjU0OQogbXNnaWQgInVua25vd24gcmVwb3NpdG9yeSBleHRlbnNpb25zIGZvdW5kOiIKIG1zZ3N0ciAidMOsbSB0aOG6pXkgcGjhuqduIG3hu58gcuG7mW5nIGtobyBjaMawYSBiaeG6v3Q6IgogCi0jOiBzZXR1cC5jOjU2NworIzogc2V0dXAuYzo1NjgKICMsIGMtZm9ybWF0CiBtc2dpZCAiZXJyb3Igb3BlbmluZyAnJXMnIgogbXNnc3RyICJn4bq3cCBs4buXaSBraGkgbeG7nyDigJwlc+KAnSIKIAotIzogc2V0dXAuYzo1NjkKKyM6IHNldHVwLmM6NTcwCiAjLCBjLWZvcm1hdAogbXNnaWQgInRvbyBsYXJnZSB0byBiZSBhIC5naXQgZmlsZTogJyVzJyIKIG1zZ3N0ciAidOG6rXAgdGluIC5naXQgbMOgIHF1w6EgbOG7m246IOKAnCVz4oCdIgogCi0jOiBzZXR1cC5jOjU3MQorIzogc2V0dXAuYzo1NzIKICMsIGMtZm9ybWF0CiBtc2dpZCAiZXJyb3IgcmVhZGluZyAlcyIKIG1zZ3N0ciAiZ+G6t3AgbOG7l2kga2hpIMSR4buNYyAlcyIKIAotIzogc2V0dXAuYzo1NzMKKyM6IHNldHVwLmM6NTc0CiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgZ2l0ZmlsZSBmb3JtYXQ6ICVzIgogbXNnc3RyICLEkeG7i25oIGThuqFuZyB04bqtcCB0aW4gZ2l0IGtow7RuZyBo4bujcCBs4buHOiAlcyIKIAotIzogc2V0dXAuYzo1NzUKKyM6IHNldHVwLmM6NTc2CiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vIHBhdGggaW4gZ2l0ZmlsZTogJXMiCiBtc2dzdHIgImtow7RuZyBjw7MgxJHGsOG7nW5nIGThuqtuIHRyb25nIHThuq1wIHRpbiBnaXQ6ICVzIgogCi0jOiBzZXR1cC5jOjU3NworIzogc2V0dXAuYzo1NzgKICMsIGMtZm9ybWF0CiBtc2dpZCAibm90IGEgZ2l0IHJlcG9zaXRvcnk6ICVzIgogbXNnc3RyICJraMO0bmcgcGjhuqNpIGzDoCBraG8gZ2l0OiAlcyIKIAotIzogc2V0dXAuYzo2NzYKKyM6IHNldHVwLmM6Njc3CiAjLCBjLWZvcm1hdAogbXNnaWQgIickJXMnIHRvbyBiaWciCiBtc2dzdHIgIuKAnCQlc+KAnSBxdcOhIGzhu5tuIgogCi0jOiBzZXR1cC5jOjY5MAorIzogc2V0dXAuYzo2OTEKICMsIGMtZm9ybWF0CiBtc2dpZCAibm90IGEgZ2l0IHJlcG9zaXRvcnk6ICclcyciCiBtc2dzdHIgImtow7RuZyBwaOG6o2kgbMOgIGtobyBnaXQ6IOKAnCVz4oCdIgogCi0jOiBzZXR1cC5jOjcxOSBzZXR1cC5jOjcyMSBzZXR1cC5jOjc1MgorIzogc2V0dXAuYzo3MjAgc2V0dXAuYzo3MjIgc2V0dXAuYzo3NTMKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IGNoZGlyIHRvICclcyciCiBtc2dzdHIgImtow7RuZyB0aOG7gyBjaGRpciAoY2h1eeG7g24gxJHhu5VpIHRoxrAgbeG7pWMpIHNhbmcg4oCcJXPigJ0iCiAKLSM6IHNldHVwLmM6NzI0IHNldHVwLmM6NzgwIHNldHVwLmM6NzkwIHNldHVwLmM6ODI5IHNldHVwLmM6ODM3CisjOiBzZXR1cC5jOjcyNSBzZXR1cC5jOjc4MSBzZXR1cC5jOjc5MSBzZXR1cC5jOjgzMCBzZXR1cC5jOjgzOAogbXNnaWQgImNhbm5vdCBjb21lIGJhY2sgdG8gY3dkIgogbXNnc3RyICJraMO0bmcgdGjhu4MgcXVheSBs4bqhaSBjd2QiCiAKLSM6IHNldHVwLmM6ODUxCisjOiBzZXR1cC5jOjg1MgogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gc3RhdCAnJSpzJXMlcyciCiBtc2dzdHIgImfhurdwIGzhu5dpIGtoaSBs4bqleSB0aOG7kW5nIGvDqiB24buBIOKAnCUqcyVzJXPigJ0iCiAKLSM6IHNldHVwLmM6MTA4MworIzogc2V0dXAuYzoxMDkwCiBtc2dpZCAiVW5hYmxlIHRvIHJlYWQgY3VycmVudCB3b3JraW5nIGRpcmVjdG9yeSIKIG1zZ3N0ciAiS2jDtG5nIHRo4buDIMSR4buNYyB0aMawIG3hu6VjIGzDoG0gdmnhu4djIGhp4buHbiBow6BuaCIKIAotIzogc2V0dXAuYzoxMDkyIHNldHVwLmM6MTA5OAorIzogc2V0dXAuYzoxMDk5IHNldHVwLmM6MTEwNQogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgY2hhbmdlIHRvICclcyciCiBtc2dzdHIgImtow7RuZyB0aOG7gyBjaHV54buDbiBzYW5nIOKAnCVz4oCdIgogCi0jOiBzZXR1cC5jOjExMDMKKyM6IHNldHVwLmM6MTExMAogIywgYy1mb3JtYXQKIG1zZ2lkICJub3QgYSBnaXQgcmVwb3NpdG9yeSAob3IgYW55IG9mIHRoZSBwYXJlbnQgZGlyZWN0b3JpZXMpOiAlcyIKIG1zZ3N0ciAia2jDtG5nIHBo4bqjaSBsw6Aga2hvIGdpdCAoaG/hurdjIGLhuqV0IGvhu7MgdGjGsCBt4bulYyBjaGEgbeG6uSBuw6BvKTogJXMiCiAKLSM6IHNldHVwLmM6MTEwOQorIzogc2V0dXAuYzoxMTE2CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJub3QgYSBnaXQgcmVwb3NpdG9yeSAob3IgYW55IHBhcmVudCB1cCB0byBtb3VudCBwb2ludCAlcylcbiIKQEAgLTY3NjksNyArNjc5NCw3IEBACiAiROG7q25nIHThuqFpIGJpw6puIGPhu6dhIGjhu4cgdGjhu5FuZyB04bqtcCB0aW4gKEdJVF9ESVNDT1ZFUllfQUNST1NTX0ZJTEVTWVNURU0gY2jGsGEgIgogIsSR4bq3dCkuIgogCi0jOiBzZXR1cC5jOjEyMjAKKyM6IHNldHVwLmM6MTIyNwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAicHJvYmxlbSB3aXRoIGNvcmUuc2hhcmVkUmVwb3NpdG9yeSBmaWxlbW9kZSB2YWx1ZSAoMCUuM28pLlxuIgpAQCAtNjc3OCwyODQgKzY4MDMsMjg0IEBACiAiZ+G6t3AgduG6pW4gxJHhu4EgduG7m2kgZ2nDoSB0cuG7iyBjaOG6vyDEkeG7mSB04bqtcCB0aW4gY29yZS5zaGFyZWRSZXBvc2l0b3J5ICgwJS4zbykuXG4iCiAibmfGsOG7nWkgc+G7nyBo4buvdSB04bqtcCB0aW4gcGjhuqNpIGx1w7RuIGPDsyBxdXnhu4FuIMSR4buNYyB2w6AgZ2hpLiIKIAotIzogc2V0dXAuYzoxMjY0CisjOiBzZXR1cC5jOjEyNzEKIG1zZ2lkICJvcGVuIC9kZXYvbnVsbCBvciBkdXAgZmFpbGVkIgogbXNnc3RyICJn4bq3cCBs4buXaSBraGkgbeG7nyDigJwvZGV2L251bGzigJ0gaGF5IGR1cCIKIAotIzogc2V0dXAuYzoxMjc5CisjOiBzZXR1cC5jOjEyODYKIG1zZ2lkICJmb3JrIGZhaWxlZCIKIG1zZ3N0ciAiZ+G6t3AgbOG7l2kga2hpIHLhur0gbmjDoW5oIHRp4bq/biB0csOsbmgiCiAKLSM6IHNldHVwLmM6MTI4NAorIzogc2V0dXAuYzoxMjkxCiBtc2dpZCAic2V0c2lkIGZhaWxlZCIKIG1zZ3N0ciAic2V0c2lkIGfhurdwIGzhu5dpIgogCi0jOiBzaGExLWZpbGUuYzo0NTMKKyM6IHNoYTEtZmlsZS5jOjQ1MgogIywgYy1mb3JtYXQKIG1zZ2lkICJvYmplY3QgZGlyZWN0b3J5ICVzIGRvZXMgbm90IGV4aXN0OyBjaGVjayAuZ2l0L29iamVjdHMvaW5mby9hbHRlcm5hdGVzIgogbXNnc3RyICIiCiAidGjGsCBt4bulYyDEkeG7kWkgdMaw4bujbmcgJXMga2jDtG5nIHThu5NuIHThuqFpOyBraeG7g20gdHJhIC5naXQvb2JqZWN0cy9pbmZvL2FsdGVybmF0ZXMiCiAKLSM6IHNoYTEtZmlsZS5jOjUwNAorIzogc2hhMS1maWxlLmM6NTAzCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBub3JtYWxpemUgYWx0ZXJuYXRlIG9iamVjdCBwYXRoOiAlcyIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIHRoxrDhu51uZyBow7NhIMSRxrDhu51uZyBk4bqrbiDEkeG7kWkgdMaw4bujbmcgdGhheSB0aOG6vzog4oCcJXPigJ0iCiAKLSM6IHNoYTEtZmlsZS5jOjU3NgorIzogc2hhMS1maWxlLmM6NTc1CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiBpZ25vcmluZyBhbHRlcm5hdGUgb2JqZWN0IHN0b3JlcywgbmVzdGluZyB0b28gZGVlcCIKIG1zZ3N0ciAiJXM6IMSRYW5nIGLhu48gcXVhIGtobyDEkeG7kWkgdMaw4bujbmcgdGhheSB0aOG6vywgbOG7k25nIG5oYXUgcXXDoSBzw6J1IgogCi0jOiBzaGExLWZpbGUuYzo1ODMKKyM6IHNoYTEtZmlsZS5jOjU4MgogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gbm9ybWFsaXplIG9iamVjdCBkaXJlY3Rvcnk6ICVzIgogbXNnc3RyICJraMO0bmcgdGjhu4MgY2h14bqpbiBow7NhIHRoxrAgbeG7pWMgxJHhu5FpIHTGsOG7o25nOiDigJwlc+KAnSIKIAotIzogc2hhMS1maWxlLmM6NjI2CisjOiBzaGExLWZpbGUuYzo2MjUKIG1zZ2lkICJ1bmFibGUgdG8gZmRvcGVuIGFsdGVybmF0ZXMgbG9ja2ZpbGUiCiBtc2dzdHIgImtow7RuZyB0aOG7gyBmZG9wZW4gdOG6rXAgdGluIGtow7NhIHRoYXkgdGjhur8iCiAKLSM6IHNoYTEtZmlsZS5jOjY0NAorIzogc2hhMS1maWxlLmM6NjQzCiBtc2dpZCAidW5hYmxlIHRvIHJlYWQgYWx0ZXJuYXRlcyBmaWxlIgogbXNnc3RyICJraMO0bmcgdGjhu4MgxJHhu41jIHThuq1wIHRpbiB0aGF5IHRo4bq/IgogCi0jOiBzaGExLWZpbGUuYzo2NTEKKyM6IHNoYTEtZmlsZS5jOjY1MAogbXNnaWQgInVuYWJsZSB0byBtb3ZlIG5ldyBhbHRlcm5hdGVzIGZpbGUgaW50byBwbGFjZSIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIGRpIGNodXnhu4NuIHThuq1wIHRpbiB0aGF5IHRo4bq/IHbDoG8gY2jhu5ciCiAKLSM6IHNoYTEtZmlsZS5jOjY4NgorIzogc2hhMS1maWxlLmM6Njg1CiAjLCBjLWZvcm1hdAogbXNnaWQgInBhdGggJyVzJyBkb2VzIG5vdCBleGlzdCIKIG1zZ3N0ciAixJHGsOG7nW5nIGThuqtuIOKAnCVz4oCdIGtow7RuZyB04buTbiB04bqhaSIKIAotIzogc2hhMS1maWxlLmM6NzEyCisjOiBzaGExLWZpbGUuYzo3MTEKICMsIGMtZm9ybWF0CiBtc2dpZCAicmVmZXJlbmNlIHJlcG9zaXRvcnkgJyVzJyBhcyBhIGxpbmtlZCBjaGVja291dCBpcyBub3Qgc3VwcG9ydGVkIHlldC4iCiBtc2dzdHIgImtobyB0aGFtIGNoaeG6v3Ug4oCcJXPigJ0gbmjGsCBsw6AgbOG6pXkgcmEgbGnDqm4ga+G6v3QgduG6q24gY2jGsGEgxJHGsOG7o2MgaOG7lyB0cuG7oy4iCiAKLSM6IHNoYTEtZmlsZS5jOjcxOAorIzogc2hhMS1maWxlLmM6NzE3CiAjLCBjLWZvcm1hdAogbXNnaWQgInJlZmVyZW5jZSByZXBvc2l0b3J5ICclcycgaXMgbm90IGEgbG9jYWwgcmVwb3NpdG9yeS4iCiBtc2dzdHIgImtobyB0aGFtIGNoaeG6v3Ug4oCcJXPigJ0ga2jDtG5nIHBo4bqjaSBsw6AgbeG7mXQga2hvIG7hu5lpIGLhu5kuIgogCi0jOiBzaGExLWZpbGUuYzo3MjQKKyM6IHNoYTEtZmlsZS5jOjcyMwogIywgYy1mb3JtYXQKIG1zZ2lkICJyZWZlcmVuY2UgcmVwb3NpdG9yeSAnJXMnIGlzIHNoYWxsb3ciCiBtc2dzdHIgImtobyB0aGFtIGNoaeG6v3Ug4oCcJXPigJ0gbMOgIG7DtG5nIgogCi0jOiBzaGExLWZpbGUuYzo3MzIKKyM6IHNoYTEtZmlsZS5jOjczMQogIywgYy1mb3JtYXQKIG1zZ2lkICJyZWZlcmVuY2UgcmVwb3NpdG9yeSAnJXMnIGlzIGdyYWZ0ZWQiCiBtc2dzdHIgImtobyB0aGFtIGNoaeG6v3Ug4oCcJXPigJ0gYuG7iyBj4bqleSBnaMOpcCIKIAotIzogc2hhMS1maWxlLmM6NzkyCisjOiBzaGExLWZpbGUuYzo3OTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBsaW5lIHdoaWxlIHBhcnNpbmcgYWx0ZXJuYXRlIHJlZnM6ICVzIgogbXNnc3RyICJkw7JuZyBraMO0bmcgaOG7o3AgbOG7hyB0cm9uZyBraGkgcGjDom4gdMOtY2ggY8OhYyB0aGFtIGNoaeG6v3UgdGhheSB0aOG6vzogJXMiCiAKLSM6IHNoYTEtZmlsZS5jOjk0NAorIzogc2hhMS1maWxlLmM6OTQzCiAjLCBjLWZvcm1hdAogbXNnaWQgImF0dGVtcHRpbmcgdG8gbW1hcCAlPFBSSXVNQVg+IG92ZXIgbGltaXQgJTxQUkl1TUFYPiIKIG1zZ3N0ciAixJFhbmcgY+G7kSDEkeG7gyBtbWFwICU8UFJJdU1BWD4gdsaw4bujdCBxdcOhIGdp4bubaSBo4bqhbiAlPFBSSXVNQVg+IgogCi0jOiBzaGExLWZpbGUuYzo5NjkKKyM6IHNoYTEtZmlsZS5jOjk2NAogbXNnaWQgIm1tYXAgZmFpbGVkIgogbXNnc3RyICJtbWFwIGfhurdwIGzhu5dpIgogCi0jOiBzaGExLWZpbGUuYzoxMTMzCisjOiBzaGExLWZpbGUuYzoxMTI4CiAjLCBjLWZvcm1hdAogbXNnaWQgIm9iamVjdCBmaWxlICVzIGlzIGVtcHR5IgogbXNnc3RyICJ04bqtcCB0aW4gxJHhu5FpIHTGsOG7o25nICVzIHRy4buRbmcgcuG7l25nIgogCi0jOiBzaGExLWZpbGUuYzoxMjU3IHNoYTEtZmlsZS5jOjIzOTYKKyM6IHNoYTEtZmlsZS5jOjEyNTIgc2hhMS1maWxlLmM6MjM5MgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3JydXB0IGxvb3NlIG9iamVjdCAnJXMnIgogbXNnc3RyICLEkeG7kWkgdMaw4bujbmcgbeG6pXQgaOG7j25nIOKAnCVz4oCdIgogCi0jOiBzaGExLWZpbGUuYzoxMjU5IHNoYTEtZmlsZS5jOjI0MDAKKyM6IHNoYTEtZmlsZS5jOjEyNTQgc2hhMS1maWxlLmM6MjM5NgogIywgYy1mb3JtYXQKIG1zZ2lkICJnYXJiYWdlIGF0IGVuZCBvZiBsb29zZSBvYmplY3QgJyVzJyIKIG1zZ3N0ciAiZ+G6t3AgcsOhYyB04bqhaSBjdeG7kWkgY+G7p2EgxJHhu5FpIHTGsOG7o25nIGLhu4sgbeG6pXQg4oCcJXPigJ0iCiAKLSM6IHNoYTEtZmlsZS5jOjEzMDEKKyM6IHNoYTEtZmlsZS5jOjEyOTYKIG1zZ2lkICJpbnZhbGlkIG9iamVjdCB0eXBlIgogbXNnc3RyICJraeG7g3UgxJHhu5FpIHTGsOG7o25nIGtow7RuZyBo4bujcCBs4buHIgogCi0jOiBzaGExLWZpbGUuYzoxMzg1CisjOiBzaGExLWZpbGUuYzoxMzgwCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byB1bnBhY2sgJXMgaGVhZGVyIHdpdGggLS1hbGxvdy11bmtub3duLXR5cGUiCiBtc2dzdHIgImtow7RuZyB0aOG7gyBnaeG6o2kgbsOpbiBwaOG6p24gxJHhuqd1IGfDs2kgJXMgduG7m2kgLS1hbGxvdy11bmtub3duLXR5cGUiCiAKLSM6IHNoYTEtZmlsZS5jOjEzODgKKyM6IHNoYTEtZmlsZS5jOjEzODMKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHVucGFjayAlcyBoZWFkZXIiCiBtc2dzdHIgImtow7RuZyB0aOG7gyBnaeG6o2kgZ8OzaSBwaOG6p24gxJHhuqd1ICVzIgogCi0jOiBzaGExLWZpbGUuYzoxMzk0CisjOiBzaGExLWZpbGUuYzoxMzg5CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBwYXJzZSAlcyBoZWFkZXIgd2l0aCAtLWFsbG93LXVua25vd24tdHlwZSIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIHBow6JuIHTDrWNoIHBo4bqnbiDEkeG6p3UgZ8OzaSAlcyB24bubaSAtLWFsbG93LXVua25vd24tdHlwZSIKIAotIzogc2hhMS1maWxlLmM6MTM5NworIzogc2hhMS1maWxlLmM6MTM5MgogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gcGFyc2UgJXMgaGVhZGVyIgogbXNnc3RyICJraMO0bmcgdGjhu4MgcGjDom4gdMOtY2ggcGjhuqduIMSR4bqndSBj4bunYSDigJwlc+KAnSIKIAotIzogc2hhMS1maWxlLmM6MTU4OAorIzogc2hhMS1maWxlLmM6MTU4NAogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gcmVhZCBvYmplY3QgJXMiCiBtc2dzdHIgImfhurdwIGzhu5dpIGtoaSDEkeG7jWMgxJHhu5FpIHTGsOG7o25nIOKAnCVz4oCdIgogCi0jOiBzaGExLWZpbGUuYzoxNTkyCisjOiBzaGExLWZpbGUuYzoxNTg4CiAjLCBjLWZvcm1hdAogbXNnaWQgInJlcGxhY2VtZW50ICVzIG5vdCBmb3VuZCBmb3IgJXMiCiBtc2dzdHIgImMlcyB0aGF5IHRo4bq/IGtow7RuZyDEkcaw4bujYyB0w6xtIHRo4bqleSBjaG8gJXMiCiAKLSM6IHNoYTEtZmlsZS5jOjE1OTYKKyM6IHNoYTEtZmlsZS5jOjE1OTIKICMsIGMtZm9ybWF0CiBtc2dpZCAibG9vc2Ugb2JqZWN0ICVzIChzdG9yZWQgaW4gJXMpIGlzIGNvcnJ1cHQiCiBtc2dzdHIgIsSR4buRaSB0xrDhu6NuZyBt4bqldCAlcyAoxJHGsOG7o2MgbMawdSB0cm9uZyAlcykgYuG7iyBo4buPbmciCiAKLSM6IHNoYTEtZmlsZS5jOjE2MDAKKyM6IHNoYTEtZmlsZS5jOjE1OTYKICMsIGMtZm9ybWF0CiBtc2dpZCAicGFja2VkIG9iamVjdCAlcyAoc3RvcmVkIGluICVzKSBpcyBjb3JydXB0IgogbXNnc3RyICLEkeG7kWkgdMaw4bujbmcgxJHDoyDEkcOzbmcgZ8OzaSAlcyAoxJHGsOG7o2MgbMawdSB0cm9uZyAlcykgYuG7iyBo4buPbmciCiAKLSM6IHNoYTEtZmlsZS5jOjE3MDMKKyM6IHNoYTEtZmlsZS5jOjE2OTkKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHdyaXRlIGZpbGUgJXMiCiBtc2dzdHIgImtow7RuZyB0aOG7gyBnaGkgdOG6rXAgdGluICVzIgogCi0jOiBzaGExLWZpbGUuYzoxNzEwCisjOiBzaGExLWZpbGUuYzoxNzA2CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBzZXQgcGVybWlzc2lvbiB0byAnJXMnIgogbXNnc3RyICJraMO0bmcgdGjhu4MgxJHhurd0IHF1eeG7gW4gdGjDoG5oIOKAnCVz4oCdIgogCi0jOiBzaGExLWZpbGUuYzoxNzE3CisjOiBzaGExLWZpbGUuYzoxNzEzCiBtc2dpZCAiZmlsZSB3cml0ZSBlcnJvciIKIG1zZ3N0ciAibOG7l2kgZ2hpIHThuq1wIHRpbiIKIAotIzogc2hhMS1maWxlLmM6MTczNgorIzogc2hhMS1maWxlLmM6MTczMgogbXNnaWQgImVycm9yIHdoZW4gY2xvc2luZyBsb29zZSBvYmplY3QgZmlsZSIKIG1zZ3N0ciAiZ+G6t3AgbOG7l2kgdHJvbmcga2hpIMSRw7NuZyB04bqtcCB0aW4gxJHhu5FpIHTGsOG7o25nIgogCi0jOiBzaGExLWZpbGUuYzoxODAxCisjOiBzaGExLWZpbGUuYzoxNzk3CiAjLCBjLWZvcm1hdAogbXNnaWQgImluc3VmZmljaWVudCBwZXJtaXNzaW9uIGZvciBhZGRpbmcgYW4gb2JqZWN0IHRvIHJlcG9zaXRvcnkgZGF0YWJhc2UgJXMiCiBtc2dzdHIgIiIKICJraMO0bmcgxJHhu6cgdGjhuqltIHF1eeG7gW4gxJHhu4MgdGjDqm0gbeG7mXQgxJHhu5FpIHTGsOG7o25nIHbDoG8gY8ahIHPhu58gZOG7ryBsaeG7h3Uga2hvIGNo4bupYSAlcyIKIAotIzogc2hhMS1maWxlLmM6MTgwMworIzogc2hhMS1maWxlLmM6MTc5OQogbXNnaWQgInVuYWJsZSB0byBjcmVhdGUgdGVtcG9yYXJ5IGZpbGUiCiBtc2dzdHIgImtow7RuZyB0aOG7gyB04bqhbyB04bqtcCB0aW4gdOG6oW0gdGjhu51pIgogCi0jOiBzaGExLWZpbGUuYzoxODI3CisjOiBzaGExLWZpbGUuYzoxODIzCiBtc2dpZCAidW5hYmxlIHRvIHdyaXRlIGxvb3NlIG9iamVjdCBmaWxlIgogbXNnc3RyICJraMO0bmcgdGjhu4MgZ2hpIHThuq1wIHRpbiDEkeG7kWkgdMaw4bujbmcgxJHDoyBt4bqldCIKIAotIzogc2hhMS1maWxlLmM6MTgzMworIzogc2hhMS1maWxlLmM6MTgyOQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gZGVmbGF0ZSBuZXcgb2JqZWN0ICVzICglZCkiCiBtc2dzdHIgImtow7RuZyB0aOG7gyB44bqjIG7DqW4gxJHhu5FpIHTGsOG7o25nIG3hu5tpICVzICglZCkiCiAKLSM6IHNoYTEtZmlsZS5jOjE4MzcKKyM6IHNoYTEtZmlsZS5jOjE4MzMKICMsIGMtZm9ybWF0CiBtc2dpZCAiZGVmbGF0ZUVuZCBvbiBvYmplY3QgJXMgZmFpbGVkICglZCkiCiBtc2dzdHIgImRlZmxhdGVFbmQgdHLDqm4gxJHhu5FpIHTGsOG7o25nICVzIGfhurdwIGzhu5dpICglZCkiCiAKLSM6IHNoYTEtZmlsZS5jOjE4NDEKKyM6IHNoYTEtZmlsZS5jOjE4MzcKICMsIGMtZm9ybWF0CiBtc2dpZCAiY29uZnVzZWQgYnkgdW5zdGFibGUgb2JqZWN0IHNvdXJjZSBkYXRhIGZvciAlcyIKIG1zZ3N0ciAiY2jGsGEgcsO1IHLDoG5nIGJhb3dpciBk4buvIGxp4buHdSBuZ3Xhu5NuIMSR4buRaSB0xrDhu6NuZyBraMO0bmcg4buVbiDEkeG7i25oIGNobyAlcyIKIAotIzogc2hhMS1maWxlLmM6MTg1MSBidWlsdGluL3BhY2stb2JqZWN0cy5jOjkyNQorIzogc2hhMS1maWxlLmM6MTg0NyBidWlsdGluL3BhY2stb2JqZWN0cy5jOjkyNQogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdXRpbWUoKSBvbiAlcyIKIG1zZ3N0ciAiZ+G6t3AgbOG7l2kgdXRpbWUoKSB0csOqbiDigJwlc+KAnSIKIAotIzogc2hhMS1maWxlLmM6MTkyNgorIzogc2hhMS1maWxlLmM6MTkyMgogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgcmVhZCBvYmplY3QgZm9yICVzIgogbXNnc3RyICJraMO0bmcgdGjhu4MgxJHhu41jIMSR4buRaSB0xrDhu6NuZyBjaG8gJXMiCiAKLSM6IHNoYTEtZmlsZS5jOjE5NjYKKyM6IHNoYTEtZmlsZS5jOjE5NjIKIG1zZ2lkICJjb3JydXB0IGNvbW1pdCIKIG1zZ3N0ciAibOG6p24gY2h1eeG7g24gZ2lhbyBzYWkgaOG7j25nIgogCi0jOiBzaGExLWZpbGUuYzoxOTc0CisjOiBzaGExLWZpbGUuYzoxOTcwCiBtc2dpZCAiY29ycnVwdCB0YWciCiBtc2dzdHIgInRo4bq7IHNhaSBo4buPbmciCiAKLSM6IHNoYTEtZmlsZS5jOjIwNzMKKyM6IHNoYTEtZmlsZS5jOjIwNjkKICMsIGMtZm9ybWF0CiBtc2dpZCAicmVhZCBlcnJvciB3aGlsZSBpbmRleGluZyAlcyIKIG1zZ3N0ciAiZ+G6t3AgbOG7l2kgxJHhu41jIGtoaSDEkcOhbmggbeG7pWMgbOG7pWMgJXMiCiAKLSM6IHNoYTEtZmlsZS5jOjIwNzYKKyM6IHNoYTEtZmlsZS5jOjIwNzIKICMsIGMtZm9ybWF0CiBtc2dpZCAic2hvcnQgcmVhZCB3aGlsZSBpbmRleGluZyAlcyIKIG1zZ3N0ciAia2jDtG5nIMSR4buNYyBuZ+G6r24ga2hpIMSRw6FuaCBt4bulYyBs4bulYyAlcyIKIAotIzogc2hhMS1maWxlLmM6MjE0OSBzaGExLWZpbGUuYzoyMTU4CisjOiBzaGExLWZpbGUuYzoyMTQ1IHNoYTEtZmlsZS5jOjIxNTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXM6IGZhaWxlZCB0byBpbnNlcnQgaW50byBkYXRhYmFzZSIKIG1zZ3N0ciAiJXM6IGfhurdwIGzhu5dpIGtoaSB0aMOqbSB2w6BvIGPGoSBz4bufIGThu68gbGnhu4d1IgogCi0jOiBzaGExLWZpbGUuYzoyMTY0CisjOiBzaGExLWZpbGUuYzoyMTYwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiB1bnN1cHBvcnRlZCBmaWxlIHR5cGUiCiBtc2dzdHIgIiVzOiBraeG7g3UgdOG6rXAgdGluIGtow7RuZyDEkcaw4bujYyBo4buXIHRy4bujIgogCi0jOiBzaGExLWZpbGUuYzoyMTg4CisjOiBzaGExLWZpbGUuYzoyMTg0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIGlzIG5vdCBhIHZhbGlkIG9iamVjdCIKIG1zZ3N0ciAiJXMga2jDtG5nIHBo4bqjaSBsw6AgbeG7mXQgxJHhu5FpIHTGsOG7o25nIGjhu6NwIGzhu4ciCiAKLSM6IHNoYTEtZmlsZS5jOjIxOTAKKyM6IHNoYTEtZmlsZS5jOjIxODYKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgaXMgbm90IGEgdmFsaWQgJyVzJyBvYmplY3QiCiBtc2dzdHIgIiVzIGtow7RuZyBwaOG6o2kgbMOgIG3hu5l0IMSR4buRaSB0xrDhu6NuZyDigJwlc+KAnSBo4bujcCBs4buHIgogCi0jOiBzaGExLWZpbGUuYzoyMjE3IGJ1aWx0aW4vaW5kZXgtcGFjay5jOjE1NQorIzogc2hhMS1maWxlLmM6MjIxMyBidWlsdGluL2luZGV4LXBhY2suYzoxNTUKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIG9wZW4gJXMiCiBtc2dzdHIgImtow7RuZyB0aOG7gyBt4bufICVzIgogCi0jOiBzaGExLWZpbGUuYzoyNDA3IHNoYTEtZmlsZS5jOjI0NTkKKyM6IHNoYTEtZmlsZS5jOjI0MDMgc2hhMS1maWxlLmM6MjQ1NQogIywgYy1mb3JtYXQKIG1zZ2lkICJoYXNoIG1pc21hdGNoIGZvciAlcyAoZXhwZWN0ZWQgJXMpIgogbXNnc3RyICJtw6MgYsSDbSBraMO0bmcga2jhu5twIGNobyAlcyAoY+G6p24gJXMpIgogCi0jOiBzaGExLWZpbGUuYzoyNDMxCisjOiBzaGExLWZpbGUuYzoyNDI3CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBtbWFwICVzIgogbXNnc3RyICJraMO0bmcgdGjhu4MgbW1hcCAlcyIKIAotIzogc2hhMS1maWxlLmM6MjQzNgorIzogc2hhMS1maWxlLmM6MjQzMgogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gdW5wYWNrIGhlYWRlciBvZiAlcyIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIGdp4bqjaSBnw7NpIHBo4bqnbiDEkeG6p3UgY+G7p2Eg4oCcJXPigJ0iCiAKLSM6IHNoYTEtZmlsZS5jOjI0NDIKKyM6IHNoYTEtZmlsZS5jOjI0MzgKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHBhcnNlIGhlYWRlciBvZiAlcyIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIHBow6JuIHTDrWNoIHBo4bqnbiDEkeG6p3UgY+G7p2Eg4oCcJXPigJ0iCiAKLSM6IHNoYTEtZmlsZS5jOjI0NTMKKyM6IHNoYTEtZmlsZS5jOjI0NDkKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHVucGFjayBjb250ZW50cyBvZiAlcyIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIGdp4bqjaSBnw7NpIG7hu5lpIGR1bmcgY+G7p2Eg4oCcJXPigJ0iCiAKLSM6IHNoYTEtbmFtZS5jOjQ5MAorIzogc2hhMS1uYW1lLmM6NDg3CiAjLCBjLWZvcm1hdAogbXNnaWQgInNob3J0IFNIQTEgJXMgaXMgYW1iaWd1b3VzIgogbXNnc3RyICJ0w7NtIGzGsOG7o2MgU0hBMSAlcyBjaMawYSByw7UgcsOgbmciCiAKLSM6IHNoYTEtbmFtZS5jOjUwMQorIzogc2hhMS1uYW1lLmM6NDk4CiBtc2dpZCAiVGhlIGNhbmRpZGF0ZXMgYXJlOiIKIG1zZ3N0ciAiQ8OhYyDhu6luZyBj4butIGzDoDoiCiAKLSM6IHNoYTEtbmFtZS5jOjgwMAorIzogc2hhMS1uYW1lLmM6Nzk3CiBtc2dpZCAiIgogIkdpdCBub3JtYWxseSBuZXZlciBjcmVhdGVzIGEgcmVmIHRoYXQgZW5kcyB3aXRoIDQwIGhleCBjaGFyYWN0ZXJzXG4iCiAiYmVjYXVzZSBpdCB3aWxsIGJlIGlnbm9yZWQgd2hlbiB5b3UganVzdCBzcGVjaWZ5IDQwLWhleC4gVGhlc2UgcmVmc1xuIgpAQCAtNzA4MCw1MCArNzEwNSw1MCBAQAogImLhurFuZyBjw6FjaCBjaOG6oXkgbOG7h25oIFwiZ2l0IGNvbmZpZyBhZHZpY2Uub2JqZWN0TmFtZVdhcm5pbmcgZmFsc2VcIiIKIAogIy4gVFJBTlNMQVRPUlM6IElFQyA4MDAwMC0xMzoyMDA4IGdpYmlieXRlCi0jOiBzdHJidWYuYzo4MjEKKyM6IHN0cmJ1Zi5jOjgyMgogIywgYy1mb3JtYXQKIG1zZ2lkICIldS4lMi4ydSBHaUIiCiBtc2dzdHIgIiV1LiUyLjJ1IEdpQiIKIAogIy4gVFJBTlNMQVRPUlM6IElFQyA4MDAwMC0xMzoyMDA4IGdpYmlieXRlL3NlY29uZAotIzogc3RyYnVmLmM6ODIzCisjOiBzdHJidWYuYzo4MjQKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXUuJTIuMnUgR2lCL3MiCiBtc2dzdHIgIiV1LiUyLjJ1IEdpQi9nacOieSIKIAogIy4gVFJBTlNMQVRPUlM6IElFQyA4MDAwMC0xMzoyMDA4IG1lYmlieXRlCi0jOiBzdHJidWYuYzo4MzEKKyM6IHN0cmJ1Zi5jOjgzMgogIywgYy1mb3JtYXQKIG1zZ2lkICIldS4lMi4ydSBNaUIiCiBtc2dzdHIgIiV1LiUyLjJ1IE1pQiIKIAogIy4gVFJBTlNMQVRPUlM6IElFQyA4MDAwMC0xMzoyMDA4IG1lYmlieXRlL3NlY29uZAotIzogc3RyYnVmLmM6ODMzCisjOiBzdHJidWYuYzo4MzQKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXUuJTIuMnUgTWlCL3MiCiBtc2dzdHIgIiV1LiUyLjJ1IE1pQi9nacOieSIKIAogIy4gVFJBTlNMQVRPUlM6IElFQyA4MDAwMC0xMzoyMDA4IGtpYmlieXRlCi0jOiBzdHJidWYuYzo4NDAKKyM6IHN0cmJ1Zi5jOjg0MQogIywgYy1mb3JtYXQKIG1zZ2lkICIldS4lMi4ydSBLaUIiCiBtc2dzdHIgIiV1LiUyLjJ1IEtpQiIKIAogIy4gVFJBTlNMQVRPUlM6IElFQyA4MDAwMC0xMzoyMDA4IGtpYmlieXRlL3NlY29uZAotIzogc3RyYnVmLmM6ODQyCisjOiBzdHJidWYuYzo4NDMKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXUuJTIuMnUgS2lCL3MiCiBtc2dzdHIgIiV1LiUyLjJ1IEtpQi9nacOieSIKIAogIy4gVFJBTlNMQVRPUlM6IElFQyA4MDAwMC0xMzoyMDA4IGJ5dGUKLSM6IHN0cmJ1Zi5jOjg0OAorIzogc3RyYnVmLmM6ODQ5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiV1IGJ5dGUiCiBtc2dpZF9wbHVyYWwgIiV1IGJ5dGVzIgogbXNnc3RyWzBdICIldSBieXRlIgogCiAjLiBUUkFOU0xBVE9SUzogSUVDIDgwMDAwLTEzOjIwMDggYnl0ZS9zZWNvbmQKLSM6IHN0cmJ1Zi5jOjg1MAorIzogc3RyYnVmLmM6ODUxCiAjLCBjLWZvcm1hdAogbXNnaWQgIiV1IGJ5dGUvcyIKIG1zZ2lkX3BsdXJhbCAiJXUgYnl0ZXMvcyIKQEAgLTcyNDIsMjggKzcyNjcsMjggQEAKIG1zZ2lkICJscy10cmVlIHJldHVybmVkIHVuZXhwZWN0ZWQgcmV0dXJuIGNvZGUgJWQiCiBtc2dzdHIgImxzLXRyZWUgdHLhuqMgduG7gSBtw6Mga2jDtG5nIG5oxrAgbW9uZyDEkeG7o2kgJWQiCiAKLSM6IHN1Ym1vZHVsZS1jb25maWcuYzoyMzIKKyM6IHN1Ym1vZHVsZS1jb25maWcuYzoyMzYKICMsIGMtZm9ybWF0CiBtc2dpZCAiaWdub3Jpbmcgc3VzcGljaW91cyBzdWJtb2R1bGUgbmFtZTogJXMiCiBtc2dzdHIgIsSRYW5nIGzhu50gxJFpIHTDqm4gbcO0LcSRdW4tY29uIG3huq1wIG3hu506ICVzIgogCi0jOiBzdWJtb2R1bGUtY29uZmlnLmM6Mjk5CisjOiBzdWJtb2R1bGUtY29uZmlnLmM6MzAzCiBtc2dpZCAibmVnYXRpdmUgdmFsdWVzIG5vdCBhbGxvd2VkIGZvciBzdWJtb2R1bGUuZmV0Y2hqb2JzIgogbXNnc3RyICJraMO0bmcgY2hvIHBow6lwIGdpw6EgdHLhu4sgw6JtIOG7nyBzdWJtb2R1bGUuZmV0Y2hKb2JzIgogCi0jOiBzdWJtb2R1bGUtY29uZmlnLmM6Mzk3CisjOiBzdWJtb2R1bGUtY29uZmlnLmM6NDAxCiAjLCBjLWZvcm1hdAogbXNnaWQgImlnbm9yaW5nICclcycgd2hpY2ggbWF5IGJlIGludGVycHJldGVkIGFzIGEgY29tbWFuZC1saW5lIG9wdGlvbjogJXMiCiBtc2dzdHIgIiIKICLEkWFuZyBi4buPIHF1YSDigJwlc+KAnSBjw6FpIG3DoCBjw7MgdGjhu4MgxJHGsOG7o2MgcGhpw6puIGThu4tjaCBuaMawIGzDoCBt4buZdCB0w7l5IGNo4buNbiBkw7JuZyAiCiAibOG7h25oOiAlcyIKIAotIzogc3VibW9kdWxlLWNvbmZpZy5jOjQ4NgorIzogc3VibW9kdWxlLWNvbmZpZy5jOjQ5MAogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIHZhbHVlIGZvciAlcyIKIG1zZ3N0ciAiZ2nDoSB0cuG7iyBjaG8gJXMga2jDtG5nIGjhu6NwIGzhu4ciCiAKLSM6IHN1Ym1vZHVsZS1jb25maWcuYzo3NTUKKyM6IHN1Ym1vZHVsZS1jb25maWcuYzo3NjEKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ291bGQgbm90IHVwZGF0ZSAuZ2l0bW9kdWxlcyBlbnRyeSAlcyIKIG1zZ3N0ciAiS2jDtG5nIHRo4buDIGPhuq1wIG5o4bqtdCBt4bulYyAuZ2l0bW9kdWxlcyAlcyIKQEAgLTcyOTgsNyArNzMyMyw3IEBACiBtc2dpZCAiY291bGQgbm90IHJlYWQgZnJvbSBzdGRpbiIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIMSR4buNYyB04burIMSR4bqndSB2w6BvIHRpw6p1IGNodeG6qW4iCiAKLSM6IHRyYWlsZXIuYzoxMDExIHdyYXBwZXIuYzo3MDEKKyM6IHRyYWlsZXIuYzoxMDExIHdyYXBwZXIuYzo2NjUKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHN0YXQgJXMiCiBtc2dzdHIgImtow7RuZyB0aOG7gyBs4bqleSB0aMO0bmcgdGluIHRo4buRbmcga8OqIHbhu4EgJXMiCkBAIC03MzI3LDQ3ICs3MzUyLDQ3IEBACiBtc2dpZCAiV291bGQgc2V0IHVwc3RyZWFtIG9mICclcycgdG8gJyVzJyBvZiAnJXMnXG4iCiBtc2dzdHIgIktow7RuZyB0aOG7gyDEkeG6t3QgdGjGsOG7o25nIG5ndeG7k24gY+G7p2Eg4oCcJXPigJ0gdGjDoG5oIOKAnCVz4oCdIGPhu6dhIOKAnCVz4oCdXG4iCiAKLSM6IHRyYW5zcG9ydC5jOjE0MgorIzogdHJhbnNwb3J0LmM6MTQ1CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCByZWFkIGJ1bmRsZSAnJXMnIgogbXNnc3RyICJraMO0bmcgdGjhu4MgxJHhu41jIGLDsyDigJwlc+KAnSIKIAotIzogdHJhbnNwb3J0LmM6MjA4CisjOiB0cmFuc3BvcnQuYzoyMTQKICMsIGMtZm9ybWF0CiBtc2dpZCAidHJhbnNwb3J0OiBpbnZhbGlkIGRlcHRoIG9wdGlvbiAnJXMnIgogbXNnc3RyICJ24bqtbiBjaHV54buDbjogdMO5eSBjaOG7jW4gxJHhu5kgc8OidSDigJwlc+KAnSBraMO0bmcgaOG7o3AgbOG7hyIKIAotIzogdHJhbnNwb3J0LmM6MjU5CisjOiB0cmFuc3BvcnQuYzoyNjYKIG1zZ2lkICJzZWUgcHJvdG9jb2wudmVyc2lvbiBpbiAnZ2l0IGhlbHAgY29uZmlnJyBmb3IgbW9yZSBkZXRhaWxzIgogbXNnc3RyICJ4ZW0gcHJvdG9jb2wudmVyc2lvbiB0cm9uZyDigJxnaXQgaGVscCBjb25maWfigJ0gxJHhu4MgY8OzIHRow6ptIHRow7RuZyB0aW4iCiAKLSM6IHRyYW5zcG9ydC5jOjI2MAorIzogdHJhbnNwb3J0LmM6MjY3CiBtc2dpZCAic2VydmVyIG9wdGlvbnMgcmVxdWlyZSBwcm90b2NvbCB2ZXJzaW9uIDIgb3IgbGF0ZXIiCiBtc2dzdHIgImPDoWMgdMO5eSBjaOG7jW4gbcOheSBjaOG7pyB5w6p1IGPhuqd1IGdpYW8gdGjhu6ljIHBoacOqbiBi4bqjbiAyIGhv4bq3YyBt4bubaSBoxqFuIgogCi0jOiB0cmFuc3BvcnQuYzo2MjUKKyM6IHRyYW5zcG9ydC5jOjYzMgogbXNnaWQgImNvdWxkIG5vdCBwYXJzZSB0cmFuc3BvcnQuY29sb3IuKiBjb25maWciCiBtc2dzdHIgImtow7RuZyB0aOG7gyBwaMOibiB0w61jaCBjw7ogcGjDoXAgY+G6pXUgaMOsbmggdHJhbnNwb3J0LmNvbG9yLioiCiAKLSM6IHRyYW5zcG9ydC5jOjY5OAorIzogdHJhbnNwb3J0LmM6NzA1CiBtc2dpZCAic3VwcG9ydCBmb3IgcHJvdG9jb2wgdjIgbm90IGltcGxlbWVudGVkIHlldCIKIG1zZ3N0ciAidmnhu4djIGjhu5cgdHLhu6MgZ2lhbyB0aOG7qWMgdjIgY2jGsGEgxJHGsOG7o2MgdGjhu7FjIGhp4buHbiIKIAotIzogdHJhbnNwb3J0LmM6ODI1CisjOiB0cmFuc3BvcnQuYzo4MzEKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5rbm93biB2YWx1ZSBmb3IgY29uZmlnICclcyc6ICVzIgogbXNnc3RyICJraMO0bmcgaGnhu4N1IGdpw6EgdHLhu4sgY2hvIGNobyBj4bqldSBow6xuaCDigJwlc+KAnTogJXMiCiAKLSM6IHRyYW5zcG9ydC5jOjg5MQorIzogdHJhbnNwb3J0LmM6ODk3CiAjLCBjLWZvcm1hdAogbXNnaWQgInRyYW5zcG9ydCAnJXMnIG5vdCBhbGxvd2VkIgogbXNnc3RyICJraMO0bmcgY2hvIHBow6lwIHBoxrDGoW5nIHRo4bupYyB24bqtbiBjaHV54buDbiDigJwlc+KAnSIKIAotIzogdHJhbnNwb3J0LmM6OTQ1CisjOiB0cmFuc3BvcnQuYzo5NDkKIG1zZ2lkICJnaXQtb3Zlci1yc3luYyBpcyBubyBsb25nZXIgc3VwcG9ydGVkIgogbXNnc3RyICJnaXQtb3Zlci1yc3luYyBraMO0bmcgY8OybiDEkcaw4bujYyBo4buXIHRy4bujIG7hu69hIgogCi0jOiB0cmFuc3BvcnQuYzoxMDQwCisjOiB0cmFuc3BvcnQuYzoxMDQ0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgZm9sbG93aW5nIHN1Ym1vZHVsZSBwYXRocyBjb250YWluIGNoYW5nZXMgdGhhdCBjYW5cbiIKQEAgLTczNzYsNyArNzQwMSw3IEBACiAiQ8OhYyDEkcaw4budbmcgZOG6q24gbcO0LcSRdW4tY29uIHNhdSDEkcOieSBjw7MgY2jhu6lhIGPDoWMgdGhheSDEkeG7lWkgY8OhaSBtw6BcbiIKICJjw7MgdGjhu4MgxJHGsOG7o2MgdMOsbSB0aOG6pXkgdHLDqm4gbeG7jWkgbcOheSBwaOG7pWMgduG7pTpcbiIKIAotIzogdHJhbnNwb3J0LmM6MTA0NAorIzogdHJhbnNwb3J0LmM6MTA0OAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiXG4iCkBAIC03NDAzLDMyICs3NDI4LDMyIEBACiAixJHhu4MgxJHhuql5IGNow7puZyBsw6puIG3DoXkgcGjhu6VjIHbhu6UuXG4iCiAiXG4iCiAKLSM6IHRyYW5zcG9ydC5jOjEwNTIKKyM6IHRyYW5zcG9ydC5jOjEwNTYKIG1zZ2lkICJBYm9ydGluZy4iCiBtc2dzdHIgIkLDo2kgYuG7jy4iCiAKLSM6IHRyYW5zcG9ydC5jOjExOTMKKyM6IHRyYW5zcG9ydC5jOjEyMDEKIG1zZ2lkICJmYWlsZWQgdG8gcHVzaCBhbGwgbmVlZGVkIHN1Ym1vZHVsZXMiCiBtc2dzdHIgImfhurdwIGzhu5dpIGtoaSDEkeG6qXkgZOG7ryBsaeG7h3UgY+G7p2EgdOG6pXQgY+G6oyBjw6FjIG3DtC3EkXVuLWNvbiBj4bqnbiB0aGnhur90IgogCi0jOiB0cmFuc3BvcnQuYzoxMzQwIHRyYW5zcG9ydC1oZWxwZXIuYzo2NDUKKyM6IHRyYW5zcG9ydC5jOjEzNDUgdHJhbnNwb3J0LWhlbHBlci5jOjY1NQogbXNnaWQgIm9wZXJhdGlvbiBub3Qgc3VwcG9ydGVkIGJ5IHByb3RvY29sIgogbXNnc3RyICJ0aGFvIHTDoWMga2jDtG5nIMSRxrDhu6NjIGdpYSB0aOG7qWMgaOG7lyB0cuG7oyIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjUxIHRyYW5zcG9ydC1oZWxwZXIuYzo4MAorIzogdHJhbnNwb3J0LWhlbHBlci5jOjYxIHRyYW5zcG9ydC1oZWxwZXIuYzo5MAogbXNnaWQgImZ1bGwgd3JpdGUgdG8gcmVtb3RlIGhlbHBlciBmYWlsZWQiCiBtc2dzdHIgImdoaSDEkeG6p3kgxJHhu6cgbMOqbiBi4buZIGjhu5cgdHLhu6MgbcOheSBjaOG7pyBn4bq3cCBs4buXaSIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjEzNAorIzogdHJhbnNwb3J0LWhlbHBlci5jOjE0NAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gZmluZCByZW1vdGUgaGVscGVyIGZvciAnJXMnIgogbXNnc3RyICJraMO0bmcgdGjhu4MgdMOsbSB0aOG6pXkgYuG7mSBo4buXIHRy4bujIG3DoXkgY2jhu6cgY2hvIOKAnCVz4oCdIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6MTUwIHRyYW5zcG9ydC1oZWxwZXIuYzo1NTkKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxNjAgdHJhbnNwb3J0LWhlbHBlci5jOjU2OQogbXNnaWQgImNhbid0IGR1cCBoZWxwZXIgb3V0cHV0IGZkIgogbXNnc3RyICJraMO0bmcgdGjhu4MgbmjDom4gxJHDtGkgZmQgZOG6p3UgcmEgYuG7mSBo4buXIHRy4bujIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6MjAxCisjOiB0cmFuc3BvcnQtaGVscGVyLmM6MjExCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJ1bmtub3duIG1hbmRhdG9yeSBjYXBhYmlsaXR5ICVzOyB0aGlzIHJlbW90ZSBoZWxwZXIgcHJvYmFibHkgbmVlZHMgbmV3ZXIgIgpAQCAtNzQzNyw5OSArNzQ2MiwxMDQgQEAKICJraMO0bmcgaGnhu4N1IGNhcGFiaWxpdHkgYuG6r3QgYnXhu5ljICVzOyBi4buZIGjhu5cgdHLhu6MgbcOheSBjaOG7pyBuw6B5IGfhuqduIG5oxrAgY2jhuq9jIGNo4bqvbiAiCiAibMOgIGPhuqduIHBoacOqbiBi4bqjbiBHaXQgbeG7m2kgaMahbiIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjIwNworIzogdHJhbnNwb3J0LWhlbHBlci5jOjIxNwogbXNnaWQgInRoaXMgcmVtb3RlIGhlbHBlciBzaG91bGQgaW1wbGVtZW50IHJlZnNwZWMgY2FwYWJpbGl0eSIKIG1zZ3N0ciAiYuG7mSBo4buXIHRy4bujIG3DoXkgY2jhu6cgbsOgeSBj4bqnbiBwaOG6o2kgdGjhu7FjIHRoaSBjYXBhYmlsaXR5IMSR4bq3YyB04bqjIHRoYW0gY2hp4bq/dSIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjI3NCB0cmFuc3BvcnQtaGVscGVyLmM6NDE0CisjOiB0cmFuc3BvcnQtaGVscGVyLmM6Mjg0IHRyYW5zcG9ydC1oZWxwZXIuYzo0MjQKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgdW5leHBlY3RlZGx5IHNhaWQ6ICclcyciCiBtc2dzdHIgIiVzIHNhaWQgYuG6pXQgbmfhu506IOKAnCVz4oCdIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6NDAzCisjOiB0cmFuc3BvcnQtaGVscGVyLmM6NDEzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIGFsc28gbG9ja2VkICVzIgogbXNnc3RyICIlcyBjxaluZyBraMOzYSAlcyIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjQ4MQorIzogdHJhbnNwb3J0LWhlbHBlci5jOjQ5MQogbXNnaWQgImNvdWxkbid0IHJ1biBmYXN0LWltcG9ydCIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIGNo4bqheSBmYXN0LWltcG9ydCIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjUwNAorIzogdHJhbnNwb3J0LWhlbHBlci5jOjUxNAogbXNnaWQgImVycm9yIHdoaWxlIHJ1bm5pbmcgZmFzdC1pbXBvcnQiCiBtc2dzdHIgImfhurdwIGzhu5dpIHRyb25nIGtoaSBjaOG6oXkgZmFzdC1pbXBvcnQiCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzo1MzMgdHJhbnNwb3J0LWhlbHBlci5jOjExMDUKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzo1NDMgdHJhbnNwb3J0LWhlbHBlci5jOjExMzIKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHJlYWQgcmVmICVzIgogbXNnc3RyICJraMO0bmcgdGjhu4MgxJHhu41jIHRoYW0gY2hp4bq/dSAlcyIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjU3OAorIzogdHJhbnNwb3J0LWhlbHBlci5jOjU4OAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmtub3duIHJlc3BvbnNlIHRvIGNvbm5lY3Q6ICVzIgogbXNnc3RyICJraMO0bmcgaGnhu4N1IMSRw6FwIOG7qW5nIMSR4buDIGvhur90IG7hu5FpOiAlcyIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjYwMAorIzogdHJhbnNwb3J0LWhlbHBlci5jOjYxMAogbXNnaWQgInNldHRpbmcgcmVtb3RlIHNlcnZpY2UgcGF0aCBub3Qgc3VwcG9ydGVkIGJ5IHByb3RvY29sIgogbXNnc3RyICJnaWFvIHRo4bupYyBuw6B5IGtow7RuZyBo4buXIHRy4bujIGPDoGkgxJHhurd0IMSRxrDhu51uZyBk4bqrbiBk4buLY2ggduG7pSBtw6F5IGNo4bunIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6NjAyCisjOiB0cmFuc3BvcnQtaGVscGVyLmM6NjEyCiBtc2dpZCAiaW52YWxpZCByZW1vdGUgc2VydmljZSBwYXRoIgogbXNnc3RyICLEkcaw4budbmcgZOG6q24gZOG7i2NoIHbhu6UgbcOheSBjaOG7pyBraMO0bmcgaOG7o3AgbOG7hyIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjY0OAorIzogdHJhbnNwb3J0LWhlbHBlci5jOjY1OAogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW4ndCBjb25uZWN0IHRvIHN1YnNlcnZpY2UgJXMiCiBtc2dzdHIgImtow7RuZyB0aOG7gyBr4bq/dCBu4buRaSDEkeG6v24gZOG7i2NoIHbhu6UgcGjhu6UgJXMiCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzo3MjAKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzo3MzQKICMsIGMtZm9ybWF0CiBtc2dpZCAiZXhwZWN0ZWQgb2svZXJyb3IsIGhlbHBlciBzYWlkICclcyciCiBtc2dzdHIgImPhuqduIG9rL2Vycm9yLCBuaMawbmcgYuG7mSBo4buXIHRy4bujIGzhuqFpIG7Ds2kg4oCcJXPigJ0iCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzo3NzMKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzo3ODcKICMsIGMtZm9ybWF0CiBtc2dpZCAiaGVscGVyIHJlcG9ydGVkIHVuZXhwZWN0ZWQgc3RhdHVzIG9mICVzIgogbXNnc3RyICJi4buZIGjhu5cgdHLhu6MgYsOhbyBjw6FvIHLhurFuZyBraMO0bmcgY+G6p24gdMOsbmggdHLhuqFuZyBj4bunYSAlcyIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjgzNAorIzogdHJhbnNwb3J0LWhlbHBlci5jOjg0OAogIywgYy1mb3JtYXQKIG1zZ2lkICJoZWxwZXIgJXMgZG9lcyBub3Qgc3VwcG9ydCBkcnktcnVuIgogbXNnc3RyICJoZWxwZXIgJXMga2jDtG5nIGjhu5cgdHLhu6MgZHJ5LXJ1biIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjgzNworIzogdHJhbnNwb3J0LWhlbHBlci5jOjg1MQogIywgYy1mb3JtYXQKIG1zZ2lkICJoZWxwZXIgJXMgZG9lcyBub3Qgc3VwcG9ydCAtLXNpZ25lZCIKIG1zZ3N0ciAiaGVscGVyICVzIGtow7RuZyBo4buXIHRy4bujIC0tc2lnbmVkIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6ODQwCisjOiB0cmFuc3BvcnQtaGVscGVyLmM6ODU0CiAjLCBjLWZvcm1hdAogbXNnaWQgImhlbHBlciAlcyBkb2VzIG5vdCBzdXBwb3J0IC0tc2lnbmVkPWlmLWFza2VkIgogbXNnc3RyICJoZWxwZXIgJXMga2jDtG5nIGjhu5cgdHLhu6MgLS1zaWduZWQ9aWYtYXNrZWQiCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzo4NDcKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzo4NTkKKyMsIGMtZm9ybWF0Cittc2dpZCAiaGVscGVyICVzIGRvZXMgbm90IHN1cHBvcnQgLS1hdG9taWMiCittc2dzdHIgImhlbHBlciAlcyBraMO0bmcgaOG7lyB0cuG7oyAtLWF0b21pYyIKKworIzogdHJhbnNwb3J0LWhlbHBlci5jOjg2NQogIywgYy1mb3JtYXQKIG1zZ2lkICJoZWxwZXIgJXMgZG9lcyBub3Qgc3VwcG9ydCAncHVzaC1vcHRpb24nIgogbXNnc3RyICJoZWxwZXIgJXMga2jDtG5nIGjhu5cgdHLhu6Mg4oCccHVzaC1vcHRpb27igJ0iCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzo5NDUKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzo5NjMKIG1zZ2lkICJyZW1vdGUtaGVscGVyIGRvZXNuJ3Qgc3VwcG9ydCBwdXNoOyByZWZzcGVjIG5lZWRlZCIKIG1zZ3N0ciAicmVtb3RlLWhlbHBlciBraMO0bmcgaOG7lyB0cuG7oyBwdXNoOyBj4bqnbiDEkeG6t2MgdOG6oyB0aGFtIGNoaeG6v3UiCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzo5NTAKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzo5NjgKICMsIGMtZm9ybWF0CiBtc2dpZCAiaGVscGVyICVzIGRvZXMgbm90IHN1cHBvcnQgJ2ZvcmNlJyIKIG1zZ3N0ciAiaGVscGVyICVzIGtow7RuZyBo4buXIHRy4bujIOKAnGZvcmNl4oCdIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6OTk3CisjOiB0cmFuc3BvcnQtaGVscGVyLmM6MTAxNQogbXNnaWQgImNvdWxkbid0IHJ1biBmYXN0LWV4cG9ydCIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIGNo4bqheSBmYXN0LWV4cG9ydCIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjEwMDIKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxMDIwCiBtc2dpZCAiZXJyb3Igd2hpbGUgcnVubmluZyBmYXN0LWV4cG9ydCIKIG1zZ3N0ciAiZ+G6t3AgbOG7l2kgdHJvbmcga2hpIGNo4bqheSBmYXN0LWV4cG9ydCIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjEwMjcKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxMDQ1CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJObyByZWZzIGluIGNvbW1vbiBhbmQgbm9uZSBzcGVjaWZpZWQ7IGRvaW5nIG5vdGhpbmcuXG4iCkBAIC03NTM5LDQ3ICs3NTY5LDQ3IEBACiAiY+G6oy5cbiIKICJUdXkgbmhpw6puIGLhuqFuIG7Dqm4gY2jhu4kgxJHhu4tuaCBt4buZdCBuaMOhbmggbmjGsCDigJxtYXN0ZXLigJ0gY2jhurNuZyBo4bqhbi5cbiIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjEwOTEKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxMTE4CiAjLCBjLWZvcm1hdAogbXNnaWQgIm1hbGZvcm1lZCByZXNwb25zZSBpbiByZWYgbGlzdDogJXMiCiBtc2dzdHIgIsSRw6FwIOG7qW5nIHNhaSBk4bqhbmcgdHJvbmcgZGFuaCBzw6FjaCB0aGFtIGNoaeG6v3U6ICVzIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6MTI0NAorIzogdHJhbnNwb3J0LWhlbHBlci5jOjEyNzAKICMsIGMtZm9ybWF0CiBtc2dpZCAicmVhZCglcykgZmFpbGVkIgogbXNnc3RyICJyZWFkKCVzKSBn4bq3cCBs4buXaSIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjEyNzEKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxMjk3CiAjLCBjLWZvcm1hdAogbXNnaWQgIndyaXRlKCVzKSBmYWlsZWQiCiBtc2dzdHIgIndyaXRlKCVzKSBn4bq3cCBs4buXaSIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjEzMjAKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxMzQ2CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIHRocmVhZCBmYWlsZWQiCiBtc2dzdHIgInR1eeG6v24gdHLDrG5oICVzIGfhurdwIGzhu5dpIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6MTMyNAorIzogdHJhbnNwb3J0LWhlbHBlci5jOjEzNTAKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgdGhyZWFkIGZhaWxlZCB0byBqb2luOiAlcyIKIG1zZ3N0ciAidHV54bq/biB0csOsbmggJXMgZ+G6t3AgbOG7l2kga2hpIGdpYSBuaOG6rXA6ICVzIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6MTM0MyB0cmFuc3BvcnQtaGVscGVyLmM6MTM0NworIzogdHJhbnNwb3J0LWhlbHBlci5jOjEzNjkgdHJhbnNwb3J0LWhlbHBlci5jOjEzNzMKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2FuJ3Qgc3RhcnQgdGhyZWFkIGZvciBjb3B5aW5nIGRhdGE6ICVzIgogbXNnc3RyICJraMO0bmcgdGjhu4Mga2jhu59pIGNo4bqheSB0dXnhur9uIHRyw6xuaCDEkeG7gyBzYW8gY2jDqXAgZOG7ryBsaeG7h3U6ICVzIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6MTM4NAorIzogdHJhbnNwb3J0LWhlbHBlci5jOjE0MTAKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgcHJvY2VzcyBmYWlsZWQgdG8gd2FpdCIKIG1zZ3N0ciAieOG7rSBsw70gJXMgZ+G6t3AgbOG7l2kga2hpIMSR4bujaSIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjEzODgKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxNDE0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIHByb2Nlc3MgZmFpbGVkIgogbXNnc3RyICJ44butIGzDvSAlcyBn4bq3cCBs4buXaSIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjE0MDYgdHJhbnNwb3J0LWhlbHBlci5jOjE0MTUKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxNDMyIHRyYW5zcG9ydC1oZWxwZXIuYzoxNDQxCiBtc2dpZCAiY2FuJ3Qgc3RhcnQgdGhyZWFkIGZvciBjb3B5aW5nIGRhdGEiCiBtc2dzdHIgImtow7RuZyB0aOG7gyBraOG7n2kgY2jhuqF5IHR1eeG6v24gdHLDrG5oIGNobyB2aeG7h2MgY2jDqXAgZOG7ryBsaeG7h3UiCiAKQEAgLTc1OTksNyArNzYyOSw3IEBACiBtc2dpZCAidG9vLXNob3J0IHRyZWUgZmlsZSIKIG1zZ3N0ciAidOG6rXAgdGluIGPDonkgcXXDoSBuZ+G6r24iCiAKLSM6IHVucGFjay10cmVlcy5jOjExMQorIzogdW5wYWNrLXRyZWVzLmM6MTEwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJZb3VyIGxvY2FsIGNoYW5nZXMgdG8gdGhlIGZvbGxvd2luZyBmaWxlcyB3b3VsZCBiZSBvdmVyd3JpdHRlbiBieSBjaGVja291dDpcbiIKQEAgLTc2MTAsNyArNzY0MCw3IEBACiAiJSVzVnVpIGzDsm5nIGNodXnhu4NuIGdpYW8gY8OhYyB0aGF5IMSR4buVaSBoYXkgdOG6oW0gY+G6pXQgY2jDum5nIMSRaSB0csaw4bubYyBraGkgYuG6oW4gIgogImNodXnhu4NuIG5ow6FuaC4iCiAKLSM6IHVucGFjay10cmVlcy5jOjExMworIzogdW5wYWNrLXRyZWVzLmM6MTEyCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJZb3VyIGxvY2FsIGNoYW5nZXMgdG8gdGhlIGZvbGxvd2luZyBmaWxlcyB3b3VsZCBiZSBvdmVyd3JpdHRlbiBieSBjaGVja291dDpcbiIKQEAgLTc2MjAsNyArNzY1MCw3IEBACiAiY2hlY2tvdXQ6XG4iCiAiJSVzIgogCi0jOiB1bnBhY2stdHJlZXMuYzoxMTYKKyM6IHVucGFjay10cmVlcy5jOjExNQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiWW91ciBsb2NhbCBjaGFuZ2VzIHRvIHRoZSBmb2xsb3dpbmcgZmlsZXMgd291bGQgYmUgb3ZlcndyaXR0ZW4gYnkgbWVyZ2U6XG4iCkBAIC03NjMxLDcgKzc2NjEsNyBAQAogIiUlc1Z1aSBsw7JuZyBjaHV54buDbiBnaWFvIGPDoWMgdGhheSDEkeG7lWkgaGF5IHThuqFtIGPhuqV0IGNow7puZyDEkWkgdHLGsOG7m2Mga2hpIGLhuqFuIGjDsmEgIgogInRy4buZbi4iCiAKLSM6IHVucGFjay10cmVlcy5jOjExOAorIzogdW5wYWNrLXRyZWVzLmM6MTE3CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJZb3VyIGxvY2FsIGNoYW5nZXMgdG8gdGhlIGZvbGxvd2luZyBmaWxlcyB3b3VsZCBiZSBvdmVyd3JpdHRlbiBieSBtZXJnZTpcbiIKQEAgLTc2NDEsNyArNzY3MSw3IEBACiAiaMOyYSB0cuG7mW46XG4iCiAiJSVzIgogCi0jOiB1bnBhY2stdHJlZXMuYzoxMjEKKyM6IHVucGFjay10cmVlcy5jOjEyMAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiWW91ciBsb2NhbCBjaGFuZ2VzIHRvIHRoZSBmb2xsb3dpbmcgZmlsZXMgd291bGQgYmUgb3ZlcndyaXR0ZW4gYnkgJXM6XG4iCkBAIC03NjUxLDcgKzc2ODEsNyBAQAogIiVzOlxuIgogIiUlc1Z1aSBsw7JuZyBjaHV54buDbiBnaWFvIGPDoWMgdGhheSDEkeG7lWkgaGF5IHThuqFtIGPhuqV0IGNow7puZyDEkWkgdHLGsOG7m2Mga2hpIGLhuqFuICVzLiIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTIzCisjOiB1bnBhY2stdHJlZXMuYzoxMjIKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIllvdXIgbG9jYWwgY2hhbmdlcyB0byB0aGUgZm9sbG93aW5nIGZpbGVzIHdvdWxkIGJlIG92ZXJ3cml0dGVuIGJ5ICVzOlxuIgpAQCAtNzY2MSw3ICs3NjkxLDcgQEAKICIlczpcbiIKICIlJXMiCiAKLSM6IHVucGFjay10cmVlcy5jOjEyOAorIzogdW5wYWNrLXRyZWVzLmM6MTI3CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJVcGRhdGluZyB0aGUgZm9sbG93aW5nIGRpcmVjdG9yaWVzIHdvdWxkIGxvc2UgdW50cmFja2VkIGZpbGVzIGluIHRoZW06XG4iCkBAIC03NjcxLDcgKzc3MDEsNyBAQAogInRyb25nIG7DszpcbiIKICIlcyIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTMyCisjOiB1bnBhY2stdHJlZXMuYzoxMzEKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlRoZSBmb2xsb3dpbmcgdW50cmFja2VkIHdvcmtpbmcgdHJlZSBmaWxlcyB3b3VsZCBiZSByZW1vdmVkIGJ5IGNoZWNrb3V0OlxuIgpAQCAtNzY4MSw3ICs3NzExLDcgQEAKICJjaGVja291dDpcbiIKICIlJXNWdWkgbMOybmcgZGkgY2h1eeG7g24gaGF5IGfhu6EgYuG7jyBjaMO6bmcgdHLGsOG7m2Mga2hpIGLhuqFuIGNodXnhu4NuIG5ow6FuaC4iCiAKLSM6IHVucGFjay10cmVlcy5jOjEzNAorIzogdW5wYWNrLXRyZWVzLmM6MTMzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgZm9sbG93aW5nIHVudHJhY2tlZCB3b3JraW5nIHRyZWUgZmlsZXMgd291bGQgYmUgcmVtb3ZlZCBieSBjaGVja291dDpcbiIKQEAgLTc2OTEsNyArNzcyMSw3IEBACiAiY2hlY2tvdXQ6XG4iCiAiJSVzIgogCi0jOiB1bnBhY2stdHJlZXMuYzoxMzcKKyM6IHVucGFjay10cmVlcy5jOjEzNgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiVGhlIGZvbGxvd2luZyB1bnRyYWNrZWQgd29ya2luZyB0cmVlIGZpbGVzIHdvdWxkIGJlIHJlbW92ZWQgYnkgbWVyZ2U6XG4iCkBAIC03NzAxLDcgKzc3MzEsNyBAQAogInRy4buZbjpcbiIKICIlJXNWdWkgbMOybmcgZGkgY2h1eeG7g24gaGF5IGfhu6EgYuG7jyBjaMO6bmcgdHLGsOG7m2Mga2hpIGLhuqFuIGjDsmEgdHLhu5luLiIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTM5CisjOiB1bnBhY2stdHJlZXMuYzoxMzgKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlRoZSBmb2xsb3dpbmcgdW50cmFja2VkIHdvcmtpbmcgdHJlZSBmaWxlcyB3b3VsZCBiZSByZW1vdmVkIGJ5IG1lcmdlOlxuIgpAQCAtNzcxMSw3ICs3NzQxLDcgQEAKICJ0cuG7mW46XG4iCiAiJSVzIgogCi0jOiB1bnBhY2stdHJlZXMuYzoxNDIKKyM6IHVucGFjay10cmVlcy5jOjE0MQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiVGhlIGZvbGxvd2luZyB1bnRyYWNrZWQgd29ya2luZyB0cmVlIGZpbGVzIHdvdWxkIGJlIHJlbW92ZWQgYnkgJXM6XG4iCkBAIC03NzIwLDcgKzc3NTAsNyBAQAogIkPDoWMgdOG6rXAgdGluIGPDonkgbMOgbSB2aeG7h2MgY2jGsGEgxJHGsOG7o2MgdGhlbyBkw7VpIHNhdSDEkcOieSBz4bq9IGLhu4sgZ+G7oSBi4buPIGLhu59pICVzOlxuIgogIiUlc1Z1aSBsw7JuZyBkaSBjaHV54buDbiBoYXkgZ+G7oSBi4buPIGNow7puZyB0csaw4bubYyBraGkgYuG6oW4gJXMuIgogCi0jOiB1bnBhY2stdHJlZXMuYzoxNDQKKyM6IHVucGFjay10cmVlcy5jOjE0MwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiVGhlIGZvbGxvd2luZyB1bnRyYWNrZWQgd29ya2luZyB0cmVlIGZpbGVzIHdvdWxkIGJlIHJlbW92ZWQgYnkgJXM6XG4iCkBAIC03NzI5LDcgKzc3NTksNyBAQAogIkPDoWMgdOG6rXAgdGluIGPDonkgbMOgbSB2aeG7h2MgY2jGsGEgxJHGsOG7o2MgdGhlbyBkw7VpIHNhdSDEkcOieSBz4bq9IGLhu4sgZ+G7oSBi4buPIGLhu59pICVzOlxuIgogIiUlcyIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTUwCisjOiB1bnBhY2stdHJlZXMuYzoxNDkKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlRoZSBmb2xsb3dpbmcgdW50cmFja2VkIHdvcmtpbmcgdHJlZSBmaWxlcyB3b3VsZCBiZSBvdmVyd3JpdHRlbiBieSAiCkBAIC03NzQwLDcgKzc3NzAsNyBAQAogImNoZWNrb3V0OlxuIgogIiUlc1Z1aSBsw7JuZyBkaSBjaHV54buDbiBoYXkgZ+G7oSBi4buPIGNow7puZyB0csaw4bubYyBraGkgYuG6oW4gY2h1eeG7g24gbmjDoW5oLiIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTUyCisjOiB1bnBhY2stdHJlZXMuYzoxNTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlRoZSBmb2xsb3dpbmcgdW50cmFja2VkIHdvcmtpbmcgdHJlZSBmaWxlcyB3b3VsZCBiZSBvdmVyd3JpdHRlbiBieSAiCkBAIC03NzUxLDcgKzc3ODEsNyBAQAogImNoZWNrb3V0OlxuIgogIiUlcyIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTU1CisjOiB1bnBhY2stdHJlZXMuYzoxNTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlRoZSBmb2xsb3dpbmcgdW50cmFja2VkIHdvcmtpbmcgdHJlZSBmaWxlcyB3b3VsZCBiZSBvdmVyd3JpdHRlbiBieSBtZXJnZTpcbiIKQEAgLTc3NjEsNyArNzc5MSw3IEBACiAiaMOyYSB0cuG7mW46XG4iCiAiJSVzVnVpIGzDsm5nIGRpIGNodXnhu4NuIGhheSBn4buhIGLhu48gY2jDum5nIHRyxrDhu5tjIGtoaSBi4bqhbiBow7JhIHRy4buZbi4iCiAKLSM6IHVucGFjay10cmVlcy5jOjE1NworIzogdW5wYWNrLXRyZWVzLmM6MTU2CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgZm9sbG93aW5nIHVudHJhY2tlZCB3b3JraW5nIHRyZWUgZmlsZXMgd291bGQgYmUgb3ZlcndyaXR0ZW4gYnkgbWVyZ2U6XG4iCkBAIC03NzcxLDcgKzc4MDEsNyBAQAogImjDsmEgdHLhu5luOlxuIgogIiUlcyIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTYwCisjOiB1bnBhY2stdHJlZXMuYzoxNTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlRoZSBmb2xsb3dpbmcgdW50cmFja2VkIHdvcmtpbmcgdHJlZSBmaWxlcyB3b3VsZCBiZSBvdmVyd3JpdHRlbiBieSAlczpcbiIKQEAgLTc3ODEsNyArNzgxMSw3IEBACiAiJXM6XG4iCiAiJSVzVnVpIGzDsm5nIGRpIGNodXnhu4NuIGhheSBn4buhIGLhu48gY2jDum5nIHRyxrDhu5tjIGtoaSBi4bqhbiAlcy4iCiAKLSM6IHVucGFjay10cmVlcy5jOjE2MgorIzogdW5wYWNrLXRyZWVzLmM6MTYxCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgZm9sbG93aW5nIHVudHJhY2tlZCB3b3JraW5nIHRyZWUgZmlsZXMgd291bGQgYmUgb3ZlcndyaXR0ZW4gYnkgJXM6XG4iCkBAIC03NzkxLDEyICs3ODIxLDEyIEBACiAiJXM6XG4iCiAiJSVzIgogCi0jOiB1bnBhY2stdHJlZXMuYzoxNzAKKyM6IHVucGFjay10cmVlcy5jOjE2OQogIywgYy1mb3JtYXQKIG1zZ2lkICJFbnRyeSAnJXMnIG92ZXJsYXBzIHdpdGggJyVzJy4gIENhbm5vdCBiaW5kLiIKIG1zZ3N0ciAiTeG7pWMg4oCcJXPigJ0gxJHDqCBsw6puIOKAnCVz4oCdLiBLaMO0bmcgdGjhu4MgYnXhu5ljLiIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTczCisjOiB1bnBhY2stdHJlZXMuYzoxNzIKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkNhbm5vdCB1cGRhdGUgc3BhcnNlIGNoZWNrb3V0OiB0aGUgZm9sbG93aW5nIGVudHJpZXMgYXJlIG5vdCB1cCB0byBkYXRlOlxuIgpAQCAtNzgwNSw3ICs3ODM1LDcgQEAKICJLaMO0bmcgdGjhu4MgY+G6rXAgbmjhuq10IGNoZWNrb3V0IHLhuqNpIHLDoWM6IGPDoWMgbeG7pWMgdGluIHNhdSDEkcOieSBjaMawYSBj4bqtcCBuaOG6rXQ6XG4iCiAiJXMiCiAKLSM6IHVucGFjay10cmVlcy5jOjE3NQorIzogdW5wYWNrLXRyZWVzLmM6MTc0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgZm9sbG93aW5nIHdvcmtpbmcgdHJlZSBmaWxlcyB3b3VsZCBiZSBvdmVyd3JpdHRlbiBieSBzcGFyc2UgY2hlY2tvdXQgIgpAQCAtNzgxNiw3ICs3ODQ2LDcgQEAKICJuaOG6rXQgY2hlY2tvdXQgcuG6o2kgcsOhYzpcbiIKICIlcyIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTc3CisjOiB1bnBhY2stdHJlZXMuYzoxNzYKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlRoZSBmb2xsb3dpbmcgd29ya2luZyB0cmVlIGZpbGVzIHdvdWxkIGJlIHJlbW92ZWQgYnkgc3BhcnNlIGNoZWNrb3V0ICIKQEAgLTc4MjcsNyArNzg1Nyw3IEBACiAibmjhuq10IGNoZWNrb3V0IHLhuqNpIHLDoWM6XG4iCiAiJXMiCiAKLSM6IHVucGFjay10cmVlcy5jOjE3OQorIzogdW5wYWNrLXRyZWVzLmM6MTc4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJDYW5ub3QgdXBkYXRlIHN1Ym1vZHVsZTpcbiIKQEAgLTc4MzYsMTYgKzc4NjYsMTYgQEAKICJLaMO0bmcgdGjhu4MgY+G6rXAgbmjhuq10IG3DtC3EkXVuLWNvbjpcbiIKICIlcyIKIAotIzogdW5wYWNrLXRyZWVzLmM6MjU2CisjOiB1bnBhY2stdHJlZXMuYzoyNTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiQWJvcnRpbmdcbiIKIG1zZ3N0ciAiQsOjaSBi4buPXG4iCiAKLSM6IHVucGFjay10cmVlcy5jOjMxOAorIzogdW5wYWNrLXRyZWVzLmM6MzE3CiBtc2dpZCAiVXBkYXRpbmcgZmlsZXMiCiBtc2dzdHIgIsSQYW5nIGPhuq1wIG5o4bqtdCBjw6FjIHThuq1wIHRpbiIKIAotIzogdW5wYWNrLXRyZWVzLmM6MzUwCisjOiB1bnBhY2stdHJlZXMuYzozNDkKIG1zZ2lkICIiCiAidGhlIGZvbGxvd2luZyBwYXRocyBoYXZlIGNvbGxpZGVkIChlLmcuIGNhc2Utc2Vuc2l0aXZlIHBhdGhzXG4iCiAib24gYSBjYXNlLWluc2Vuc2l0aXZlIGZpbGVzeXN0ZW0pIGFuZCBvbmx5IG9uZSBmcm9tIHRoZSBzYW1lXG4iCkBAIC03ODg0LDcgKzc5MTQsNyBAQAogbXNnaWQgImludmFsaWQgJy4uJyBwYXRoIHNlZ21lbnQiCiBtc2dzdHIgIsSRb+G6oW4gxJHGsOG7nW5nIGThuqtuIOKAnC4u4oCdIGtow7RuZyBo4bujcCBs4buHIgogCi0jOiB3b3JrdHJlZS5jOjI1OCBidWlsdGluL2FtLmM6MjA5NQorIzogd29ya3RyZWUuYzoyNTggYnVpbHRpbi9hbS5jOjIwODQKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIHJlYWQgJyVzJyIKIG1zZ3N0ciAiZ+G6t3AgbOG7l2kga2hpIMSR4buNYyDigJwlc+KAnSIKQEAgLTc5MTUsMTcgKzc5NDUsMTcgQEAKIG1zZ2lkICInJXMnIGRvZXMgbm90IHBvaW50IGJhY2sgdG8gJyVzJyIKIG1zZ3N0ciAi4oCcJXPigJ0ga2jDtG5nIGNo4buJIG5nxrDhu6NjIMSR4bq/biDigJwlc+KAnSIKIAotIzogd3JhcHBlci5jOjIyMyB3cmFwcGVyLmM6MzkzCisjOiB3cmFwcGVyLmM6MTg2IHdyYXBwZXIuYzozNTYKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IG9wZW4gJyVzJyBmb3IgcmVhZGluZyBhbmQgd3JpdGluZyIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIG3hu58g4oCcJXPigJ0gxJHhu4MgxJHhu41jIHbDoCBnaGkiCiAKLSM6IHdyYXBwZXIuYzo0MjQgd3JhcHBlci5jOjYyNAorIzogd3JhcHBlci5jOjM4NyB3cmFwcGVyLmM6NTg4CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBhY2Nlc3MgJyVzJyIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIHRydXkgY+G6rXAg4oCcJXPigJ0iCiAKLSM6IHdyYXBwZXIuYzo2MzIKKyM6IHdyYXBwZXIuYzo1OTYKIG1zZ2lkICJ1bmFibGUgdG8gZ2V0IGN1cnJlbnQgd29ya2luZyBkaXJlY3RvcnkiCiBtc2dzdHIgImtow7RuZyB0aOG7gyBs4bqleSB0aMawIG3hu6VjIGzDoG0gdmnhu4djIGhp4buHbiBow6BuaCIKIApAQCAtODI3Miw4MyArODMwMiw5MSBAQAogImNvbnRpbnVlXCIpIgogCiAjOiB3dC1zdGF0dXMuYzoxNDM3Cittc2dpZCAiICAodXNlIFwiZ2l0IGNoZXJyeS1waWNrIC0tc2tpcFwiIHRvIHNraXAgdGhpcyBwYXRjaCkiCittc2dzdHIgIiAgKGTDuW5nIFwiZ2l0IGNoZXJyeS1waWNrIC0tc2tpcFwiIMSR4buDIGLhu48gcXVhIG1p4bq/bmcgdsOhIG7DoHkpIgorCisjOiB3dC1zdGF0dXMuYzoxNDM5CiBtc2dpZCAiICAodXNlIFwiZ2l0IGNoZXJyeS1waWNrIC0tYWJvcnRcIiB0byBjYW5jZWwgdGhlIGNoZXJyeS1waWNrIG9wZXJhdGlvbikiCiBtc2dzdHIgIiAgKGTDuW5nIFwiZ2l0IGNoZXJyeS1waWNrIC0tYWJvcnRcIiDEkeG7gyBo4buneSBi4buPIHRoYW8gdMOhYyBjaGVycnktcGljaykiCiAKLSM6IHd0LXN0YXR1cy5jOjE0NDcKKyM6IHd0LXN0YXR1cy5jOjE0NDkKIG1zZ2lkICJSZXZlcnQgY3VycmVudGx5IGluIHByb2dyZXNzLiIKIG1zZ3N0ciAiSG/DoG4gbmd1ecOqbiBoaeG7h24gdOG6oWkgxJFhbmcgdGjhu7FjIGhp4buHbi4iCiAKLSM6IHd0LXN0YXR1cy5jOjE0NTAKKyM6IHd0LXN0YXR1cy5jOjE0NTIKICMsIGMtZm9ybWF0CiBtc2dpZCAiWW91IGFyZSBjdXJyZW50bHkgcmV2ZXJ0aW5nIGNvbW1pdCAlcy4iCiBtc2dzdHIgIkLhuqFuIGhp4buHbiBuYXkgxJFhbmcgdGjhu7FjIGhp4buHbiB0aGFvIHTDoWMgaG/DoG4gbmd1ecOqbiBs4bqnbiBjaHV54buDbiBnaWFvIOKAnCVz4oCdLiIKIAotIzogd3Qtc3RhdHVzLmM6MTQ1NgorIzogd3Qtc3RhdHVzLmM6MTQ1OAogbXNnaWQgIiAgKGZpeCBjb25mbGljdHMgYW5kIHJ1biBcImdpdCByZXZlcnQgLS1jb250aW51ZVwiKSIKIG1zZ3N0ciAiICAoc+G7rWEgY8OhYyB4dW5nIMSR4buZdCB2w6Agc2F1IMSRw7MgY2jhuqF5IGzhu4duaCBcImdpdCByZXZlcnQgLS1jb250aW51ZVwiKSIKIAotIzogd3Qtc3RhdHVzLmM6MTQ1OQorIzogd3Qtc3RhdHVzLmM6MTQ2MQogbXNnaWQgIiAgKHJ1biBcImdpdCByZXZlcnQgLS1jb250aW51ZVwiIHRvIGNvbnRpbnVlKSIKIG1zZ3N0ciAiICAoY2jhuqF5IGzhu4duaCBcImdpdCByZXZlcnQgLS1jb250aW51ZVwiIMSR4buDIHRp4bq/cCB04bulYykiCiAKLSM6IHd0LXN0YXR1cy5jOjE0NjIKKyM6IHd0LXN0YXR1cy5jOjE0NjQKIG1zZ2lkICIgIChhbGwgY29uZmxpY3RzIGZpeGVkOiBydW4gXCJnaXQgcmV2ZXJ0IC0tY29udGludWVcIikiCiBtc2dzdHIgIiIKICIgIChraGkgdOG6pXQgY+G6oyBjw6FjIHh1bmcgxJHhu5l0IMSRw6Mgc+G7rWEgeG9uZzogY2jhuqF5IGzhu4duaCBcImdpdCByZXZlcnQgLS1jb250aW51ZVwiKSIKIAotIzogd3Qtc3RhdHVzLmM6MTQ2NAorIzogd3Qtc3RhdHVzLmM6MTQ2NgorbXNnaWQgIiAgKHVzZSBcImdpdCByZXZlcnQgLS1za2lwXCIgdG8gc2tpcCB0aGlzIHBhdGNoKSIKK21zZ3N0ciAiICAoZMO5bmcgbOG7h25oIFwiZ2l0IHJldmVydCAtLXNraXBcIiDEkeG7gyBi4buPIHF1YSBs4bqnbiB2w6EgbsOgeSkiCisKKyM6IHd0LXN0YXR1cy5jOjE0NjgKIG1zZ2lkICIgICh1c2UgXCJnaXQgcmV2ZXJ0IC0tYWJvcnRcIiB0byBjYW5jZWwgdGhlIHJldmVydCBvcGVyYXRpb24pIgogbXNnc3RyICIgIChkw7luZyBcImdpdCByZXZlcnQgLS1hYm9ydFwiIMSR4buDIGjhu6d5IGLhu48gdGhhbyB0w6FjIGhvw6BuIG5ndXnDqm4pIgogCi0jOiB3dC1zdGF0dXMuYzoxNDc0CisjOiB3dC1zdGF0dXMuYzoxNDc4CiAjLCBjLWZvcm1hdAogbXNnaWQgIllvdSBhcmUgY3VycmVudGx5IGJpc2VjdGluZywgc3RhcnRlZCBmcm9tIGJyYW5jaCAnJXMnLiIKIG1zZ3N0ciAiIgogIkLhuqFuIGhp4buHbiBuYXkgxJFhbmcgdGjhu7FjIGhp4buHbiB0aGFvIHTDoWMgZGkgY2h1eeG7g24gbuG7rWEgYsaw4bubYyAoYmlzZWN0KSwgYuG6r3QgxJHhuqd1IHThu6sgIgogIm5ow6FuaCDigJwlc+KAnS4iCiAKLSM6IHd0LXN0YXR1cy5jOjE0NzgKKyM6IHd0LXN0YXR1cy5jOjE0ODIKIG1zZ2lkICJZb3UgYXJlIGN1cnJlbnRseSBiaXNlY3RpbmcuIgogbXNnc3RyICJC4bqhbiBoaeG7h24gdOG6oWkgxJFhbmcgdGjhu7FjIGhp4buHbiB2aeG7h2MgYmlzZWN0IChkaSBjaHV54buDbiBu4butYSBixrDhu5tjKS4iCiAKLSM6IHd0LXN0YXR1cy5jOjE0ODEKKyM6IHd0LXN0YXR1cy5jOjE0ODUKIG1zZ2lkICIgICh1c2UgXCJnaXQgYmlzZWN0IHJlc2V0XCIgdG8gZ2V0IGJhY2sgdG8gdGhlIG9yaWdpbmFsIGJyYW5jaCkiCiBtc2dzdHIgIiAgKGTDuW5nIFwiZ2l0IGJpc2VjdCByZXNldFwiIMSR4buDIHF1YXkgdHLhu58gbOG6oWkgbmjDoW5oIG5ndXnDqm4gdGjhu6d5KSIKIAotIzogd3Qtc3RhdHVzLmM6MTY5MAorIzogd3Qtc3RhdHVzLmM6MTY5NAogbXNnaWQgIk9uIGJyYW5jaCAiCiBtc2dzdHIgIlRyw6puIG5ow6FuaCAiCiAKLSM6IHd0LXN0YXR1cy5jOjE2OTcKKyM6IHd0LXN0YXR1cy5jOjE3MDEKIG1zZ2lkICJpbnRlcmFjdGl2ZSByZWJhc2UgaW4gcHJvZ3Jlc3M7IG9udG8gIgogbXNnc3RyICJyZWJhc2Ug4bufIGNo4bq/IMSR4buZIHTGsMahbmcgdMOhYyDEkWFuZyDEkcaw4bujYyB0aOG7sWMgaGnhu4duOyBsw6puIHRyw6puICIKIAotIzogd3Qtc3RhdHVzLmM6MTY5OQorIzogd3Qtc3RhdHVzLmM6MTcwMwogbXNnaWQgInJlYmFzZSBpbiBwcm9ncmVzczsgb250byAiCiBtc2dzdHIgInJlYmFzZSDEkWFuZyDEkcaw4bujYyB0aOG7sWMgaGnhu4duOiBsw6puIHRyw6puICIKIAotIzogd3Qtc3RhdHVzLmM6MTcwOQorIzogd3Qtc3RhdHVzLmM6MTcxMwogbXNnaWQgIk5vdCBjdXJyZW50bHkgb24gYW55IGJyYW5jaC4iCiBtc2dzdHIgIkhp4buHbiB04bqhaSBjaOG6s25nIOG7nyBuaMOhbmggbsOgbyBj4bqjLiIKIAotIzogd3Qtc3RhdHVzLmM6MTcyNgorIzogd3Qtc3RhdHVzLmM6MTczMAogbXNnaWQgIkluaXRpYWwgY29tbWl0IgogbXNnc3RyICJM4bqnbiBjaHV54buDbiBnaWFvIGto4bufaSB04bqhbyIKIAotIzogd3Qtc3RhdHVzLmM6MTcyNworIzogd3Qtc3RhdHVzLmM6MTczMQogbXNnaWQgIk5vIGNvbW1pdHMgeWV0IgogbXNnc3RyICJW4bqrbiBjaMawYSBjaHV54buDbiBnaWFvIgogCi0jOiB3dC1zdGF0dXMuYzoxNzQxCisjOiB3dC1zdGF0dXMuYzoxNzQ1CiBtc2dpZCAiVW50cmFja2VkIGZpbGVzIgogbXNnc3RyICJOaOG7r25nIHThuq1wIHRpbiBjaMawYSDEkcaw4bujYyB0aGVvIGTDtWkiCiAKLSM6IHd0LXN0YXR1cy5jOjE3NDMKKyM6IHd0LXN0YXR1cy5jOjE3NDcKIG1zZ2lkICJJZ25vcmVkIGZpbGVzIgogbXNnc3RyICJOaOG7r25nIHThuq1wIHRpbiBi4buLIGzhu50gxJFpIgogCi0jOiB3dC1zdGF0dXMuYzoxNzQ3CisjOiB3dC1zdGF0dXMuYzoxNzUxCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJJdCB0b29rICUuMmYgc2Vjb25kcyB0byBlbnVtZXJhdGUgdW50cmFja2VkIGZpbGVzLiAnc3RhdHVzIC11bm8nXG4iCkBAIC04MzYwLDMyICs4Mzk4LDMyIEBACiAiY8OzIGzhur0gbMOgbSBuw7MgbmhhbmggaMahbiwgbmjGsG5nIGLhuqFuIHBo4bqjaSBj4bqpbiB0aOG6rW4gxJHhu6tuZyBxdcOqbiBtw6xuaCBwaOG6o2lcbiIKICJ04buxIHRow6ptIGPDoWMgdOG6rXAgdGluIG3hu5tpICh4ZW0g4oCcZ2l0IGhlbHAgc3RhdHVz4oCdLi4iCiAKLSM6IHd0LXN0YXR1cy5jOjE3NTMKKyM6IHd0LXN0YXR1cy5jOjE3NTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiVW50cmFja2VkIGZpbGVzIG5vdCBsaXN0ZWQlcyIKIG1zZ3N0ciAiTmjhu69uZyB04bqtcCB0aW4gY2jGsGEgxJHGsOG7o2MgdGhlbyBkw7VpIGtow7RuZyDEkcaw4bujYyBsaeG7h3Qga8OqIHJhICVzIgogCi0jOiB3dC1zdGF0dXMuYzoxNzU1CisjOiB3dC1zdGF0dXMuYzoxNzU5CiBtc2dpZCAiICh1c2UgLXUgb3B0aW9uIHRvIHNob3cgdW50cmFja2VkIGZpbGVzKSIKIG1zZ3N0ciAiIChkw7luZyB0w7l5IGNo4buNbiAtdSDEkeG7gyBoaeG7g24gdGjhu4sgY8OhYyB04bqtcCB0aW4gY2jGsGEgxJHGsOG7o2MgdGhlbyBkw7VpKSIKIAotIzogd3Qtc3RhdHVzLmM6MTc2MQorIzogd3Qtc3RhdHVzLmM6MTc2NQogbXNnaWQgIk5vIGNoYW5nZXMiCiBtc2dzdHIgIktow7RuZyBjw7MgdGhheSDEkeG7lWkgbsOgbyIKIAotIzogd3Qtc3RhdHVzLmM6MTc2NgorIzogd3Qtc3RhdHVzLmM6MTc3MAogIywgYy1mb3JtYXQKIG1zZ2lkICJubyBjaGFuZ2VzIGFkZGVkIHRvIGNvbW1pdCAodXNlIFwiZ2l0IGFkZFwiIGFuZC9vciBcImdpdCBjb21taXQgLWFcIilcbiIKIG1zZ3N0ciAiIgogImtow7RuZyBjw7MgdGhheSDEkeG7lWkgbsOgbyDEkcaw4bujYyB0aMOqbSB2w6BvIMSR4buDIGNodXnhu4NuIGdpYW8gKGTDuW5nIFwiZ2l0IGFkZFwiIHbDoC9ob+G6t2MgIgogIlwiZ2l0IGNvbW1pdCAtYVwiKVxuIgogCi0jOiB3dC1zdGF0dXMuYzoxNzY5CisjOiB3dC1zdGF0dXMuYzoxNzczCiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vIGNoYW5nZXMgYWRkZWQgdG8gY29tbWl0XG4iCiBtc2dzdHIgImtow7RuZyBjw7MgdGhheSDEkeG7lWkgbsOgbyDEkcaw4bujYyB0aMOqbSB2w6BvIMSR4buDIGNodXnhu4NuIGdpYW9cbiIKIAotIzogd3Qtc3RhdHVzLmM6MTc3MgorIzogd3Qtc3RhdHVzLmM6MTc3NgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAibm90aGluZyBhZGRlZCB0byBjb21taXQgYnV0IHVudHJhY2tlZCBmaWxlcyBwcmVzZW50ICh1c2UgXCJnaXQgYWRkXCIgdG8gIgpAQCAtODM5NCw3MyArODQzMiw3OCBAQAogImtow7RuZyBjw7MgZ8OsIMSRxrDhu6NjIHRow6ptIHbDoG8gbOG6p24gY2h1eeG7g24gZ2lhbyBuaMawbmcgY8OzIG5o4buvbmcgdOG6rXAgdGluIGNoxrBhIMSRxrDhu6NjICIKICJ0aGVvIGTDtWkgaGnhu4duIGRp4buHbiAoZMO5bmcgXCJnaXQgYWRkXCIgxJHhu4MgxJHGsGEgdsOgbyB0aGVvIGTDtWkpXG4iCiAKLSM6IHd0LXN0YXR1cy5jOjE3NzUKKyM6IHd0LXN0YXR1cy5jOjE3NzkKICMsIGMtZm9ybWF0CiBtc2dpZCAibm90aGluZyBhZGRlZCB0byBjb21taXQgYnV0IHVudHJhY2tlZCBmaWxlcyBwcmVzZW50XG4iCiBtc2dzdHIgIiIKICJraMO0bmcgY8OzIGfDrCDEkcaw4bujYyB0aMOqbSB2w6BvIGzhuqduIGNodXnhu4NuIGdpYW8gbmjGsG5nIGPDsyBuaOG7r25nIHThuq1wIHRpbiBjaMawYSDEkcaw4bujYyAiCiAidGhlbyBkw7VpIGhp4buHbiBkaeG7h25cbiIKIAotIzogd3Qtc3RhdHVzLmM6MTc3OAorIzogd3Qtc3RhdHVzLmM6MTc4MgogIywgYy1mb3JtYXQKIG1zZ2lkICJub3RoaW5nIHRvIGNvbW1pdCAoY3JlYXRlL2NvcHkgZmlsZXMgYW5kIHVzZSBcImdpdCBhZGRcIiB0byB0cmFjaylcbiIKIG1zZ3N0ciAiIgogImtow7RuZyBjw7MgZ8OsIMSR4buDIGNodXnhu4NuIGdpYW8gKHThuqFvL3Nhby1jaMOpcCBjw6FjIHThuq1wIHRpbiB2w6AgZMO5bmcgXCJnaXQgYWRkXCIgxJHhu4MgIgogIsSRxrBhIHbDoG8gdGhlbyBkw7VpKVxuIgogCi0jOiB3dC1zdGF0dXMuYzoxNzgxIHd0LXN0YXR1cy5jOjE3ODYKKyM6IHd0LXN0YXR1cy5jOjE3ODUgd3Qtc3RhdHVzLmM6MTc5MAogIywgYy1mb3JtYXQKIG1zZ2lkICJub3RoaW5nIHRvIGNvbW1pdFxuIgogbXNnc3RyICJraMO0bmcgY8OzIGfDrCDEkeG7gyBjaHV54buDbiBnaWFvXG4iCiAKLSM6IHd0LXN0YXR1cy5jOjE3ODQKKyM6IHd0LXN0YXR1cy5jOjE3ODgKICMsIGMtZm9ybWF0CiBtc2dpZCAibm90aGluZyB0byBjb21taXQgKHVzZSAtdSB0byBzaG93IHVudHJhY2tlZCBmaWxlcylcbiIKIG1zZ3N0ciAiIgogImtow7RuZyBjw7MgZ8OsIMSR4buDIGNodXnhu4NuIGdpYW8gKGTDuW5nIC11IHhlbSBjw6FjIHThuq1wIHRpbiBjaMawYSDEkcaw4bujYyB0aGVvIGTDtWkpXG4iCiAKLSM6IHd0LXN0YXR1cy5jOjE3ODgKKyM6IHd0LXN0YXR1cy5jOjE3OTIKICMsIGMtZm9ybWF0CiBtc2dpZCAibm90aGluZyB0byBjb21taXQsIHdvcmtpbmcgdHJlZSBjbGVhblxuIgogbXNnc3RyICJraMO0bmcgY8OzIGfDrCDEkeG7gyBjaHV54buDbiBnaWFvLCB0aMawIG3hu6VjIGzDoG0gdmnhu4djIHPhuqFjaCBz4bq9XG4iCiAKLSM6IHd0LXN0YXR1cy5jOjE5MDEKKyM6IHd0LXN0YXR1cy5jOjE5MDUKIG1zZ2lkICJObyBjb21taXRzIHlldCBvbiAiCiBtc2dzdHIgIlbhuqtuIGtow7RuZyB0aOG7sWMgaGnhu4duIGzhu4duaCBjaHV54buDbiBnaWFvIG7DoG8gIgogCi0jOiB3dC1zdGF0dXMuYzoxOTA1CisjOiB3dC1zdGF0dXMuYzoxOTA5CiBtc2dpZCAiSEVBRCAobm8gYnJhbmNoKSIKIG1zZ3N0ciAiSEVBRCAoa2jDtG5nIG5ow6FuaCkiCiAKLSM6IHd0LXN0YXR1cy5jOjE5MzYKKyM6IHd0LXN0YXR1cy5jOjE5NDAKIG1zZ2lkICJkaWZmZXJlbnQiCiBtc2dzdHIgImtow6FjIgogCi0jOiB3dC1zdGF0dXMuYzoxOTM4IHd0LXN0YXR1cy5jOjE5NDYKKyM6IHd0LXN0YXR1cy5jOjE5NDIgd3Qtc3RhdHVzLmM6MTk1MAogbXNnaWQgImJlaGluZCAiCiBtc2dzdHIgIsSR4bqxbmcgc2F1ICIKIAotIzogd3Qtc3RhdHVzLmM6MTk0MSB3dC1zdGF0dXMuYzoxOTQ0CisjOiB3dC1zdGF0dXMuYzoxOTQ1IHd0LXN0YXR1cy5jOjE5NDgKIG1zZ2lkICJhaGVhZCAiCiBtc2dzdHIgInBow61hIHRyxrDhu5tjICIKIAogIy4gVFJBTlNMQVRPUlM6IHRoZSBhY3Rpb24gaXMgZS5nLiAicHVsbCB3aXRoIHJlYmFzZSIKLSM6IHd0LXN0YXR1cy5jOjI0NjYKKyM6IHd0LXN0YXR1cy5jOjI0NzAKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90ICVzOiBZb3UgaGF2ZSB1bnN0YWdlZCBjaGFuZ2VzLiIKIG1zZ3N0ciAia2jDtG5nIHRo4buDICVzOiBC4bqhbiBjw7MgY8OhYyB0aGF5IMSR4buVaSBjaMawYSDEkcaw4bujYyDEkcawYSBsw6puIGLhu4cgcGjDs25nLiIKIAotIzogd3Qtc3RhdHVzLmM6MjQ3MgorIzogd3Qtc3RhdHVzLmM6MjQ3NgogbXNnaWQgImFkZGl0aW9uYWxseSwgeW91ciBpbmRleCBjb250YWlucyB1bmNvbW1pdHRlZCBjaGFuZ2VzLiIKIG1zZ3N0ciAiIgogInRow6ptIHbDoG8gxJHDsywgYuG6o25nIG3hu6VjIGzhu6VjIGPhu6dhIGLhuqFuIGPDsyBjaOG7qWEgY8OhYyB0aGF5IMSR4buVaSBjaMawYSDEkcaw4bujYyBjaHV54buDbiBnaWFvLiIKIAotIzogd3Qtc3RhdHVzLmM6MjQ3NAorIzogd3Qtc3RhdHVzLmM6MjQ3OAogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgJXM6IFlvdXIgaW5kZXggY29udGFpbnMgdW5jb21taXR0ZWQgY2hhbmdlcy4iCiBtc2dzdHIgIiIKICJraMO0bmcgdGjhu4MgJXM6IE3hu6VjIGzhu6VjIGPhu6dhIGLhuqFuIGPDsyBjaOG7qWEgY8OhYyB0aGF5IMSR4buVaSBjaMawYSDEkcaw4bujYyBjaHV54buDbiBnaWFvLiIKIAorIzogY29tcGF0L3ByZWNvbXBvc2VfdXRmOC5jOjU4IGJ1aWx0aW4vY2xvbmUuYzo0NTIKKyMsIGMtZm9ybWF0Cittc2dpZCAiZmFpbGVkIHRvIHVubGluayAnJXMnIgorbXNnc3RyICJn4bq3cCBs4buXaSBraGkgYuG7jyBsacOqbiBr4bq/dCAodW5saW5rKSDigJwlc+KAnSIKKwogIzogYnVpbHRpbi9hZGQuYzoyNQogbXNnaWQgImdpdCBhZGQgWzxvcHRpb25zPl0gWy0tXSA8cGF0aHNwZWM+Li4uIgogbXNnc3RyICJnaXQgYWRkIFs8Y8OhYyB0w7l5IGNo4buNbj5dIFstLV0gIDxwYXRoc3BlYz7igKYiCkBAIC04NDg0LDcgKzg1MjcsNyBAQAogbXNnc3RyICIiCiAixJDGsGEgcmEga2jhu49pIGLhu4cgcGjDs25nIGPDoWMgdGhheSDEkeG7lWkgc2F1IGtoaSBsw6BtIHTGsMahaSBt4bubaSBs4bqhaSBi4bqjbmcgbeG7pWMgbOG7pWM6IgogCi0jOiBidWlsdGluL2FkZC5jOjIzNCBidWlsdGluL3Jldi1wYXJzZS5jOjg5NgorIzogYnVpbHRpbi9hZGQuYzoyMzQgYnVpbHRpbi9yZXYtcGFyc2UuYzo4OTcKIG1zZ2lkICJDb3VsZCBub3QgcmVhZCB0aGUgaW5kZXgiCiBtc2dzdHIgIktow7RuZyB0aOG7gyDEkeG7jWMgYuG6o25nIG3hu6VjIGzhu6VjIgogCkBAIC04NTIxLDggKzg1NjQsOCBAQAogIkPDoWMgxJHGsOG7nW5nIGThuqtuIHRoZW8gc2F1IMSRw6J5IHPhur0gYuG7iyBs4budIMSRaSBi4bufaSBt4buZdCB0cm9uZyBjw6FjIHThuq1wIHRpbiAuZ2l0aWdub3JlICIKICJj4bunYSBi4bqhbjpcbiIKIAotIzogYnVpbHRpbi9hZGQuYzoyOTAgYnVpbHRpbi9jbGVhbi5jOjkwOSBidWlsdGluL2ZldGNoLmM6MTQ3IGJ1aWx0aW4vbXYuYzoxMjQKLSM6IGJ1aWx0aW4vcHJ1bmUtcGFja2VkLmM6NTYgYnVpbHRpbi9wdWxsLmM6MjIyIGJ1aWx0aW4vcHVzaC5jOjU2MAorIzogYnVpbHRpbi9hZGQuYzoyOTAgYnVpbHRpbi9jbGVhbi5jOjkxMCBidWlsdGluL2ZldGNoLmM6MTYyIGJ1aWx0aW4vbXYuYzoxMjQKKyM6IGJ1aWx0aW4vcHJ1bmUtcGFja2VkLmM6NTYgYnVpbHRpbi9wdWxsLmM6MjIzIGJ1aWx0aW4vcHVzaC5jOjU0NwogIzogYnVpbHRpbi9yZW1vdGUuYzoxMzQ1IGJ1aWx0aW4vcm0uYzoyNDEgYnVpbHRpbi9zZW5kLXBhY2suYzoxNjUKIG1zZ2lkICJkcnkgcnVuIgogbXNnc3RyICJjaOG6oXkgdGjhu60iCkBAIC04NTc5LDcgKzg2MjIsNyBAQAogbXNnc3RyICIiCiAia2nhu4NtIHRyYSB4ZW0gLSB0aOG6rW0gY2jDrSB0aGnhur91IC0gdOG6rXAgdGluIGLhu4sgYuG7jyBxdWEgdHJvbmcgcXXDoSB0csOsbmggY2jhuqF5IHRo4butIgogCi0jOiBidWlsdGluL2FkZC5jOjMwOSBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMDEKKyM6IGJ1aWx0aW4vYWRkLmM6MzA5IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAwMgogbXNnaWQgIm92ZXJyaWRlIHRoZSBleGVjdXRhYmxlIGJpdCBvZiB0aGUgbGlzdGVkIGZpbGVzIgogbXNnc3RyICJnaGkgxJHDqCBsw6puIGLDrXQgdGhpIGjDoG5oIGPhu6dhIGPDoWMgdOG6rXAgdGluIMSRxrDhu6NjIGxp4buHdCBrw6oiCiAKQEAgLTg2NTUsMTEzICs4Njk4LDEwOSBAQAogbXNnaWQgIk1heWJlIHlvdSB3YW50ZWQgdG8gc2F5ICdnaXQgYWRkIC4nP1xuIgogbXNnc3RyICJDw7MgbOG6vSDDvSBi4bqhbiBsw6Ag4oCcZ2l0IGFkZCAu4oCdIHBo4bqjaSBraMO0bmc/XG4iCiAKLSM6IGJ1aWx0aW4vYW0uYzozNDgKKyM6IGJ1aWx0aW4vYW0uYzozNDcKIG1zZ2lkICJjb3VsZCBub3QgcGFyc2UgYXV0aG9yIHNjcmlwdCIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIHBow6JuIHTDrWNoIGPDuiBwaMOhcCB2xINuIGzhu4duaCB0w6FjIGdp4bqjIgogCi0jOiBidWlsdGluL2FtLmM6NDMyCisjOiBidWlsdGluL2FtLmM6NDMxCiAjLCBjLWZvcm1hdAogbXNnaWQgIiclcycgd2FzIGRlbGV0ZWQgYnkgdGhlIGFwcGx5cGF0Y2gtbXNnIGhvb2siCiBtc2dzdHIgIuKAnCVz4oCdIGLhu4sgeMOzYSBi4bufaSBtw7NjIGFwcGx5cGF0Y2gtbXNnIgogCi0jOiBidWlsdGluL2FtLmM6NDc0CisjOiBidWlsdGluL2FtLmM6NDczCiAjLCBjLWZvcm1hdAogbXNnaWQgIk1hbGZvcm1lZCBpbnB1dCBsaW5lOiAnJXMnLiIKIG1zZ3N0ciAiRMOybmcgxJHhuqd1IHbDoG8gZOG7iyBow6xuaDog4oCcJXPigJ0uIgogCi0jOiBidWlsdGluL2FtLmM6NTEyCisjOiBidWlsdGluL2FtLmM6NTExCiAjLCBjLWZvcm1hdAogbXNnaWQgIkZhaWxlZCB0byBjb3B5IG5vdGVzIGZyb20gJyVzJyB0byAnJXMnIgogbXNnc3RyICJH4bq3cCBs4buXaSBraGkgc2FvIGNow6lwIGdoaSBjaMO6IChub3RlKSB04burIOKAnCVz4oCdIHThu5tpIOKAnCVz4oCdIgogCi0jOiBidWlsdGluL2FtLmM6NTM4CisjOiBidWlsdGluL2FtLmM6NTM3CiBtc2dpZCAiZnNlZWsgZmFpbGVkIgogbXNnc3RyICJmc2VlayBn4bq3cCBs4buXaSIKIAotIzogYnVpbHRpbi9hbS5jOjcyNgorIzogYnVpbHRpbi9hbS5jOjcyNQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcGFyc2UgcGF0Y2ggJyVzJyIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIHBow6JuIHTDrWNoIGPDuiBwaMOhcCDigJwlc+KAnSIKIAotIzogYnVpbHRpbi9hbS5jOjc5MQorIzogYnVpbHRpbi9hbS5jOjc5MAogbXNnaWQgIk9ubHkgb25lIFN0R0lUIHBhdGNoIHNlcmllcyBjYW4gYmUgYXBwbGllZCBhdCBvbmNlIgogbXNnc3RyICJDaOG7iSBjw7MgbeG7mXQgc8OqLXJpIG1p4bq/bmcgdsOhIFN0R0lUIMSRxrDhu6NjIMOhcCBk4bulbmcgbeG7mXQgbMO6YyIKIAotIzogYnVpbHRpbi9hbS5jOjgzOQorIzogYnVpbHRpbi9hbS5jOjgzOAogbXNnaWQgImludmFsaWQgdGltZXN0YW1wIgogbXNnc3RyICJk4bqldSB0aOG7nWkgZ2lhbiBraMO0bmcgaOG7o3AgbOG7hyIKIAotIzogYnVpbHRpbi9hbS5jOjg0NCBidWlsdGluL2FtLmM6ODU2CisjOiBidWlsdGluL2FtLmM6ODQzIGJ1aWx0aW4vYW0uYzo4NTUKIG1zZ2lkICJpbnZhbGlkIERhdGUgbGluZSIKIG1zZ3N0ciAiZMOybmcgTmfDoHkgdGjDoW5nIGtow7RuZyBo4bujcCBs4buHIgogCi0jOiBidWlsdGluL2FtLmM6ODUxCisjOiBidWlsdGluL2FtLmM6ODUwCiBtc2dpZCAiaW52YWxpZCB0aW1lem9uZSBvZmZzZXQiCiBtc2dzdHIgIsSR4buZIGzhu4djaCBtw7ppIGdp4budIGtow7RuZyBo4bujcCBs4buHIgogCi0jOiBidWlsdGluL2FtLmM6OTQ0CisjOiBidWlsdGluL2FtLmM6OTQzCiBtc2dpZCAiUGF0Y2ggZm9ybWF0IGRldGVjdGlvbiBmYWlsZWQuIgogbXNnc3RyICJEw7IgdMOsbSDEkeG7i25oIGThuqFuZyBtaeG6v25nIHbDoSBn4bq3cCBs4buXaS4iCiAKLSM6IGJ1aWx0aW4vYW0uYzo5NDkgYnVpbHRpbi9jbG9uZS5jOjQwNworIzogYnVpbHRpbi9hbS5jOjk0OCBidWlsdGluL2Nsb25lLmM6NDA2CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBjcmVhdGUgZGlyZWN0b3J5ICclcyciCiBtc2dzdHIgInThuqFvIHRoxrAgbeG7pWMgXCIlc1wiIGfhurdwIGzhu5dpIgogCi0jOiBidWlsdGluL2FtLmM6OTU0CisjOiBidWlsdGluL2FtLmM6OTUzCiBtc2dpZCAiRmFpbGVkIHRvIHNwbGl0IHBhdGNoZXMuIgogbXNnc3RyICJH4bq3cCBs4buXaSBraGkgY2hpYSBuaOG7jyBjw6FjIG1p4bq/bmcgdsOhLiIKIAotIzogYnVpbHRpbi9hbS5jOjEwODQgYnVpbHRpbi9jb21taXQuYzozNzQKLW1zZ2lkICJ1bmFibGUgdG8gd3JpdGUgaW5kZXggZmlsZSIKLW1zZ3N0ciAia2jDtG5nIHRo4buDIGdoaSB04bqtcCB0aW4gbMawdSBt4bulYyBs4bulYyIKLQotIzogYnVpbHRpbi9hbS5jOjEwOTgKKyM6IGJ1aWx0aW4vYW0uYzoxMDg0CiAjLCBjLWZvcm1hdAogbXNnaWQgIldoZW4geW91IGhhdmUgcmVzb2x2ZWQgdGhpcyBwcm9ibGVtLCBydW4gXCIlcyAtLWNvbnRpbnVlXCIuIgogbXNnc3RyICJLaGkgYuG6oW4gxJHDoyBwaMOibiBnaeG6o2kgeG9uZyB0cuG7pWMgdHLhurdjIG7DoHksIGjDo3kgY2jhuqF5IFwiJXMgLS1jb250aW51ZVwiLiIKIAotIzogYnVpbHRpbi9hbS5jOjEwOTkKKyM6IGJ1aWx0aW4vYW0uYzoxMDg1CiAjLCBjLWZvcm1hdAogbXNnaWQgIklmIHlvdSBwcmVmZXIgdG8gc2tpcCB0aGlzIHBhdGNoLCBydW4gXCIlcyAtLXNraXBcIiBpbnN0ZWFkLiIKIG1zZ3N0ciAiIgogIk7hur91IGLhuqFuIG114buRbiBi4buPIHF1YSBtaeG6v25nIHbDoSBuw6B5LCBow6N5IGNo4bqheSBs4buHbmggXCIlcyAtLXNraXBcIiDEkeG7gyB0aGF5IHRo4bq/LiIKIAotIzogYnVpbHRpbi9hbS5jOjExMDAKKyM6IGJ1aWx0aW4vYW0uYzoxMDg2CiAjLCBjLWZvcm1hdAogbXNnaWQgIlRvIHJlc3RvcmUgdGhlIG9yaWdpbmFsIGJyYW5jaCBhbmQgc3RvcCBwYXRjaGluZywgcnVuIFwiJXMgLS1hYm9ydFwiLiIKIG1zZ3N0ciAixJDhu4MgcGjhu6VjIGjhu5NpIGzhuqFpIG5ow6FuaCBn4buRYyB2w6AgZOG7q25nIHbDoSwgaMOjeSBjaOG6oXkgXCIlcyAtLWFib3J0XCIuIgogCi0jOiBidWlsdGluL2FtLmM6MTE4MworIzogYnVpbHRpbi9hbS5jOjExNjkKIG1zZ2lkICJQYXRjaCBzZW50IHdpdGggZm9ybWF0PWZsb3dlZDsgc3BhY2UgYXQgdGhlIGVuZCBvZiBsaW5lcyBtaWdodCBiZSBsb3N0LiIKIG1zZ3N0ciAiIgogIk1p4bq/bmcgdsOhIMSRxrDhu6NjIGfhu61pIHbhu5tpIGZvcm1hdD1mbG93ZWQ7IGtob+G6o25nIHRy4buRbmcg4bufIGN14buRaSBj4bunYSBjw6FjIGTDsm5nIGPDsyB0aOG7gyAiCiAiYuG7iyBt4bqldC4iCiAKLSM6IGJ1aWx0aW4vYW0uYzoxMjExCisjOiBidWlsdGluL2FtLmM6MTE5NwogbXNnaWQgIlBhdGNoIGlzIGVtcHR5LiIKIG1zZ3N0ciAiTWnhur9uZyB2w6EgdHLhu5FuZyBy4buXbmcuIgogCi0jOiBidWlsdGluL2FtLmM6MTI3NworIzogYnVpbHRpbi9hbS5jOjEyNjIKKyMsIGMtZm9ybWF0Cittc2dpZCAibWlzc2luZyBhdXRob3IgbGluZSBpbiBjb21taXQgJXMiCittc2dzdHIgInRoaeG6v3UgZMOybmcgdMOhYyBnaeG6oyB0cm9uZyBs4bqnbiBjaHV54buDbiBnaWEgJXMiCisKKyM6IGJ1aWx0aW4vYW0uYzoxMjY1CiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgaWRlbnQgbGluZTogJS4qcyIKIG1zZ3N0ciAiZMOybmcgdGjhu6V0IGzhu4Ega2jDtG5nIGjhu6NwIGzhu4c6ICUuKnMiCiAKLSM6IGJ1aWx0aW4vYW0uYzoxMjk5Ci0jLCBjLWZvcm1hdAotbXNnaWQgInVuYWJsZSB0byBwYXJzZSBjb21taXQgJXMiCi1tc2dzdHIgImtow7RuZyB0aOG7gyBwaMOibiB0w61jaCBs4bqnbiBjaHV54buDbiBnaWFvIOKAnCVz4oCdIgotCi0jOiBidWlsdGluL2FtLmM6MTQ5NgorIzogYnVpbHRpbi9hbS5jOjE0ODQKIG1zZ2lkICJSZXBvc2l0b3J5IGxhY2tzIG5lY2Vzc2FyeSBibG9icyB0byBmYWxsIGJhY2sgb24gMy13YXkgbWVyZ2UuIgogbXNnc3RyICJLaG8gdGhp4bq/dSDEkeG7kWkgdMaw4bujbmcgYmxvYiBj4bqnbiB0aGnhur90IMSR4buDIHRy4bufIHbhu4EgdHLDqm4g4oCcMy13YXkgbWVyZ2XigJ0uIgogCi0jOiBidWlsdGluL2FtLmM6MTQ5OAorIzogYnVpbHRpbi9hbS5jOjE0ODYKIG1zZ2lkICJVc2luZyBpbmRleCBpbmZvIHRvIHJlY29uc3RydWN0IGEgYmFzZSB0cmVlLi4uIgogbXNnc3RyICIiCiAiU+G7rSBk4bulbmcgdGjDtG5nIHRpbiB0cm9uZyBi4bqjbmcgbeG7pWMgbOG7pWMgxJHhu4MgY+G6pXUgdHLDumMgbOG6oWkgbeG7mXQgY8OieSAodHJlZSkgY8ahIHPhu5/igKYiCiAKLSM6IGJ1aWx0aW4vYW0uYzoxNTE3CisjOiBidWlsdGluL2FtLmM6MTUwNQogbXNnaWQgIiIKICJEaWQgeW91IGhhbmQgZWRpdCB5b3VyIHBhdGNoP1xuIgogIkl0IGRvZXMgbm90IGFwcGx5IHRvIGJsb2JzIHJlY29yZGVkIGluIGl0cyBpbmRleC4iCkBAIC04NzY5LDI0ICs4ODA4LDI0IEBACiAiQuG6oW4gxJHDoyBz4butYSBtaeG6v25nIHbDoSBj4bunYSBtw6xuaCBi4bqxbmcgY8OhY2ggdGjhu6cgY8O0bmcgw6A/XG4iCiAiTsOzIGtow7RuZyB0aOG7gyDDoXAgZOG7pW5nIGPDoWMgYmxvYiDEkcOjIMSRxrDhu6NjIGdoaSBs4bqhaSB0cm9uZyBi4bqjbmcgbeG7pWMgbOG7pWMgY+G7p2EgbsOzLiIKIAotIzogYnVpbHRpbi9hbS5jOjE1MjMKKyM6IGJ1aWx0aW4vYW0uYzoxNTExCiBtc2dpZCAiRmFsbGluZyBiYWNrIHRvIHBhdGNoaW5nIGJhc2UgYW5kIDMtd2F5IG1lcmdlLi4uIgogbXNnc3RyICLEkGFuZyB0cuG7nyBs4bqhaSDEkeG7gyB2w6EgY8ahIHPhu58gdsOgIOKAnGjDsmEgdHLhu5luIDMtxJHGsOG7nW5n4oCd4oCmIgogCi0jOiBidWlsdGluL2FtLmM6MTU0OQorIzogYnVpbHRpbi9hbS5jOjE1MzcKIG1zZ2lkICJGYWlsZWQgdG8gbWVyZ2UgaW4gdGhlIGNoYW5nZXMuIgogbXNnc3RyICJH4bq3cCBs4buXaSBraGkgdHLhu5luIHbDoG8gY8OhYyB0aGF5IMSR4buVaS4iCiAKLSM6IGJ1aWx0aW4vYW0uYzoxNTgxCisjOiBidWlsdGluL2FtLmM6MTU2OQogbXNnaWQgImFwcGx5aW5nIHRvIGFuIGVtcHR5IGhpc3RvcnkiCiBtc2dzdHIgIsOhcCBk4bulbmcgdsOgbyBt4buZdCBs4buLY2ggc+G7rSB0cuG7kW5nIHLhu5duZyIKIAotIzogYnVpbHRpbi9hbS5jOjE2MjggYnVpbHRpbi9hbS5jOjE2MzIKKyM6IGJ1aWx0aW4vYW0uYzoxNjE2IGJ1aWx0aW4vYW0uYzoxNjIwCiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCByZXN1bWU6ICVzIGRvZXMgbm90IGV4aXN0LiIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIHBo4bulYyBo4buTaTogJXMga2jDtG5nIHThu5NuIHThuqFpLiIKIAotIzogYnVpbHRpbi9hbS5jOjE2NTAKKyM6IGJ1aWx0aW4vYW0uYzoxNjM4CiBtc2dpZCAiQ29tbWl0IEJvZHkgaXM6IgogbXNnc3RyICJUaMOibiBj4bunYSBs4bqnbiBjaHV54buDbiBnaWFvIGzDoDoiCiAKQEAgLTg3OTQsMzcgKzg4MzMsNDEgQEAKICMuIGluIHlvdXIgdHJhbnNsYXRpb24uIFRoZSBwcm9ncmFtIHdpbGwgb25seSBhY2NlcHQgRW5nbGlzaAogIy4gaW5wdXQgYXQgdGhpcyBwb2ludC4KICMuCi0jOiBidWlsdGluL2FtLmM6MTY2MAorIzogYnVpbHRpbi9hbS5jOjE2NDgKICMsIGMtZm9ybWF0CiBtc2dpZCAiQXBwbHk/IFt5XWVzL1tuXW8vW2VdZGl0L1t2XWlldyBwYXRjaC9bYV1jY2VwdCBhbGw6ICIKIG1zZ3N0ciAiIgogIsOBcCBk4bulbmc/IMSR4buTbmcgw70gW3ldL2tow7Rbbl1nL2No4buJbmggc+G7rWEgW2VdL2hp4buDbiB0aOG7iyBtaeG6v25nIFt2XcOhL2No4bqlcCBuaOG6rW4gdOG6pXQgIgogImPhuqMgW2FdOiAiCiAKLSM6IGJ1aWx0aW4vYW0uYzoxNzEwCisjOiBidWlsdGluL2FtLmM6MTY5NSBidWlsdGluL2NvbW1pdC5jOjM3NAorbXNnaWQgInVuYWJsZSB0byB3cml0ZSBpbmRleCBmaWxlIgorbXNnc3RyICJraMO0bmcgdGjhu4MgZ2hpIHThuq1wIHRpbiBsxrB1IG3hu6VjIGzhu6VjIgorCisjOiBidWlsdGluL2FtLmM6MTY5OQogIywgYy1mb3JtYXQKIG1zZ2lkICJEaXJ0eSBpbmRleDogY2Fubm90IGFwcGx5IHBhdGNoZXMgKGRpcnR5OiAlcykiCiBtc2dzdHIgIkLhuqNuZyBt4bulYyBs4bulYyBi4bqpbjoga2jDtG5nIHRo4buDIMOhcCBk4bulbmcgY8OhYyBtaeG6v25nIHbDoSAoYuG6qW46ICVzKSIKIAotIzogYnVpbHRpbi9hbS5jOjE3NTAgYnVpbHRpbi9hbS5jOjE4MTgKKyM6IGJ1aWx0aW4vYW0uYzoxNzM5IGJ1aWx0aW4vYW0uYzoxODA3CiAjLCBjLWZvcm1hdAogbXNnaWQgIkFwcGx5aW5nOiAlLipzIgogbXNnc3RyICLDgXAgZOG7pW5nOiAlLipzIgogCi0jOiBidWlsdGluL2FtLmM6MTc2NworIzogYnVpbHRpbi9hbS5jOjE3NTYKIG1zZ2lkICJObyBjaGFuZ2VzIC0tIFBhdGNoIGFscmVhZHkgYXBwbGllZC4iCiBtc2dzdHIgIktow7RuZyB0aGF5IMSR4buVaSBnw6wgY+G6oyAtLSBNaeG6v25nIHbDoSDEkcOjIMSRxrDhu6NjIMOhcCBk4bulbmcgcuG7k2kuIgogCi0jOiBidWlsdGluL2FtLmM6MTc3MworIzogYnVpbHRpbi9hbS5jOjE3NjIKICMsIGMtZm9ybWF0CiBtc2dpZCAiUGF0Y2ggZmFpbGVkIGF0ICVzICUuKnMiCiBtc2dzdHIgIkfhurdwIGzhu5dpIGtoaSB2w6EgdOG6oWkgJXMgJS4qcyIKIAotIzogYnVpbHRpbi9hbS5jOjE3NzcKKyM6IGJ1aWx0aW4vYW0uYzoxNzY2CiBtc2dpZCAiVXNlICdnaXQgYW0gLS1zaG93LWN1cnJlbnQtcGF0Y2gnIHRvIHNlZSB0aGUgZmFpbGVkIHBhdGNoIgogbXNnc3RyICJEw7luZyDigJxnaXQgYW0gLS1zaG93LWN1cnJlbnQtcGF0Y2jigJ0gxJHhu4MgeGVtIG1p4bq/bmcgdsOhIGLhu4sgbOG7l2kiCiAKLSM6IGJ1aWx0aW4vYW0uYzoxODIxCisjOiBidWlsdGluL2FtLmM6MTgxMAogbXNnaWQgIiIKICJObyBjaGFuZ2VzIC0gZGlkIHlvdSBmb3JnZXQgdG8gdXNlICdnaXQgYWRkJz9cbiIKICJJZiB0aGVyZSBpcyBub3RoaW5nIGxlZnQgdG8gc3RhZ2UsIGNoYW5jZXMgYXJlIHRoYXQgc29tZXRoaW5nIGVsc2VcbiIKQEAgLTg4MzUsNyArODg3OCw3IEBACiAixJHDoyBz4bq1biDEkcaw4bujYyDEkcawYSB2w6BvIHbhu5tpIGPDuW5nIG7hu5lpIGR1bmcgdGhheSDEkeG7lWk7IGLhuqFuIGPDsyBs4bq9IG114buRbiBi4buPIHF1YSBtaeG6v25nICIKICJ2w6EgbsOgeS4iCiAKLSM6IGJ1aWx0aW4vYW0uYzoxODI4CisjOiBidWlsdGluL2FtLmM6MTgxNwogbXNnaWQgIiIKICJZb3Ugc3RpbGwgaGF2ZSB1bm1lcmdlZCBwYXRocyBpbiB5b3VyIGluZGV4LlxuIgogIllvdSBzaG91bGQgJ2dpdCBhZGQnIGVhY2ggZmlsZSB3aXRoIHJlc29sdmVkIGNvbmZsaWN0cyB0byBtYXJrIHRoZW0gYXMgIgpAQCAtODg0OCwxNyArODg5MSwxNyBAQAogIkLhuqFuIGPDsyBs4bq9IG114buRbiBjaOG6oXkg4oCcZ2l0IHJt4oCcIHRyw6puIG3hu5l0IHThuq1wIHRpbiDEkeG7gyBjaOG6pXAgbmjhuq1uIFwixJHGsOG7o2MgeMOzYSBi4bufaSBo4buNIgogIlwiIGNobyBuw7MuIgogCi0jOiBidWlsdGluL2FtLmM6MTkzNSBidWlsdGluL2FtLmM6MTkzOSBidWlsdGluL2FtLmM6MTk1MSBidWlsdGluL3Jlc2V0LmM6MzI5CisjOiBidWlsdGluL2FtLmM6MTkyNCBidWlsdGluL2FtLmM6MTkyOCBidWlsdGluL2FtLmM6MTk0MCBidWlsdGluL3Jlc2V0LmM6MzI5CiAjOiBidWlsdGluL3Jlc2V0LmM6MzM3CiAjLCBjLWZvcm1hdAogbXNnaWQgIkNvdWxkIG5vdCBwYXJzZSBvYmplY3QgJyVzJy4iCiBtc2dzdHIgIktow7RuZyB0aOG7gyBwaMOibiB0w61jaCDEkeG7kWkgdMaw4bujbmcg4oCcJXPigJ0uIgogCi0jOiBidWlsdGluL2FtLmM6MTk4NworIzogYnVpbHRpbi9hbS5jOjE5NzYKIG1zZ2lkICJmYWlsZWQgdG8gY2xlYW4gaW5kZXgiCiBtc2dzdHIgImfhurdwIGzhu5dpIGtoaSBk4buNbiBi4bqjbmcgbeG7pWMgbOG7pWMiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMDMxCisjOiBidWlsdGluL2FtLmM6MjAyMAogbXNnaWQgIiIKICJZb3Ugc2VlbSB0byBoYXZlIG1vdmVkIEhFQUQgc2luY2UgdGhlIGxhc3QgJ2FtJyBmYWlsdXJlLlxuIgogIk5vdCByZXdpbmRpbmcgdG8gT1JJR19IRUFEIgpAQCAtODg2NiwxNDQgKzg5MDksMTQ0IEBACiAiQuG6oW4gY8OzIGzhur0gxJHDoyBjw7MgSEVBRCDEkcOjIGLhu4sgZGkgY2h1eeG7g24gxJFpIGvhu4MgdOG7qyBs4bqnbiDigJxhbeKAnSB0aOG6pXQgYuG6oWkgY3Xhu5FpIGPDuW5nLlxuIgogIktow7RuZyB0aOG7gyBjaHV54buDbiB04bubaSBPUklHX0hFQUQiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMTI4CisjOiBidWlsdGluL2FtLmM6MjExNwogIywgYy1mb3JtYXQKIG1zZ2lkICJJbnZhbGlkIHZhbHVlIGZvciAtLXBhdGNoLWZvcm1hdDogJXMiCiBtc2dzdHIgIkdpw6EgdHLhu4sga2jDtG5nIGjhu6NwIGzhu4cgY2hvIC0tcGF0Y2gtZm9ybWF0OiAlcyIKIAotIzogYnVpbHRpbi9hbS5jOjIxNjQKKyM6IGJ1aWx0aW4vYW0uYzoyMTUzCiBtc2dpZCAiZ2l0IGFtIFs8b3B0aW9ucz5dIFsoPG1ib3g+IHwgPE1haWxkaXI+KS4uLl0iCiBtc2dzdHIgImdpdCBhbSBbPGPDoWMgdMO5eSBjaOG7jW4+XSBbKDxtYm94Pnw8TWFpbGRpcj4p4oCmXSIKIAotIzogYnVpbHRpbi9hbS5jOjIxNjUKKyM6IGJ1aWx0aW4vYW0uYzoyMTU0CiBtc2dpZCAiZ2l0IGFtIFs8b3B0aW9ucz5dICgtLWNvbnRpbnVlIHwgLS1za2lwIHwgLS1hYm9ydCkiCiBtc2dzdHIgImdpdCBhbSBbPGPDoWMgdMO5eSBjaOG7jW4+XSAoLS1jb250aW51ZSB8IC0tc2tpcCB8IC0tYWJvcnQpIgogCi0jOiBidWlsdGluL2FtLmM6MjE3MQorIzogYnVpbHRpbi9hbS5jOjIxNjAKIG1zZ2lkICJydW4gaW50ZXJhY3RpdmVseSIKIG1zZ3N0ciAiY2jhuqF5IGtp4buDdSB0xrDGoW5nIHTDoWMiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMTczCisjOiBidWlsdGluL2FtLmM6MjE2MgogbXNnaWQgImhpc3RvcmljYWwgb3B0aW9uIC0tIG5vLW9wIgogbXNnc3RyICJ0w7l5IGNo4buNbiBs4buLY2ggc+G7rSAtLSBraMO0bmctdG/DoW4tdOG7rSIKIAotIzogYnVpbHRpbi9hbS5jOjIxNzUKKyM6IGJ1aWx0aW4vYW0uYzoyMTY0CiBtc2dpZCAiYWxsb3cgZmFsbCBiYWNrIG9uIDN3YXkgbWVyZ2luZyBpZiBuZWVkZWQiCiBtc2dzdHIgImNobyBwaMOpcCBxdWF5IHRy4bufIGzhuqFpIMSR4buDIGjDsmEgdHLhu5luIGtp4buDdSDigJwzd2F54oCdIG7hur91IGPhuqduIgogCi0jOiBidWlsdGluL2FtLmM6MjE3NiBidWlsdGluL2luaXQtZGIuYzo0OTQgYnVpbHRpbi9wcnVuZS1wYWNrZWQuYzo1OAotIzogYnVpbHRpbi9yZXBhY2suYzoyOTYgYnVpbHRpbi9zdGFzaC5jOjgwNgorIzogYnVpbHRpbi9hbS5jOjIxNjUgYnVpbHRpbi9pbml0LWRiLmM6NDk0IGJ1aWx0aW4vcHJ1bmUtcGFja2VkLmM6NTgKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6Mjk3IGJ1aWx0aW4vc3Rhc2guYzo4MTIKIG1zZ2lkICJiZSBxdWlldCIKIG1zZ3N0ciAiaW0gbOG6t25nIgogCi0jOiBidWlsdGluL2FtLmM6MjE3OAorIzogYnVpbHRpbi9hbS5jOjIxNjcKIG1zZ2lkICJhZGQgYSBTaWduZWQtb2ZmLWJ5IGxpbmUgdG8gdGhlIGNvbW1pdCBtZXNzYWdlIgogbXNnc3RyICJ0aMOqbSBkw7JuZyBTaWduZWQtb2ZmLWJ5IGNobyBnaGkgY2jDuiBj4bunYSBs4bqnbiBjaHV54buDbiBnaWFvIgogCi0jOiBidWlsdGluL2FtLmM6MjE4MQorIzogYnVpbHRpbi9hbS5jOjIxNzAKIG1zZ2lkICJyZWNvZGUgaW50byB1dGY4IChkZWZhdWx0KSIKIG1zZ3N0ciAiY2h1eeG7g24gbcOjIHRow6BuaCB1dGY4ICht4bq3YyDEkeG7i25oKSIKIAotIzogYnVpbHRpbi9hbS5jOjIxODMKKyM6IGJ1aWx0aW4vYW0uYzoyMTcyCiBtc2dpZCAicGFzcyAtayBmbGFnIHRvIGdpdC1tYWlsaW5mbyIKIG1zZ3N0ciAiY2h1eeG7g24gY+G7nSAtayBjaG8gZ2l0LW1haWxpbmZvIgogCi0jOiBidWlsdGluL2FtLmM6MjE4NQorIzogYnVpbHRpbi9hbS5jOjIxNzQKIG1zZ2lkICJwYXNzIC1iIGZsYWcgdG8gZ2l0LW1haWxpbmZvIgogbXNnc3RyICJjaHV54buDbiBj4budIC1iIGNobyBnaXQtbWFpbGluZm8iCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMTg3CisjOiBidWlsdGluL2FtLmM6MjE3NgogbXNnaWQgInBhc3MgLW0gZmxhZyB0byBnaXQtbWFpbGluZm8iCiBtc2dzdHIgImNodXnhu4NuIGPhu50gLW0gY2hvIGdpdC1tYWlsaW5mbyIKIAotIzogYnVpbHRpbi9hbS5jOjIxODkKKyM6IGJ1aWx0aW4vYW0uYzoyMTc4CiBtc2dpZCAicGFzcyAtLWtlZXAtY3IgZmxhZyB0byBnaXQtbWFpbHNwbGl0IGZvciBtYm94IGZvcm1hdCIKIG1zZ3N0ciAiY2h1eeG7g24gY+G7nSAtLWtlZXAtY3IgY2hvIGdpdC1tYWlsc3BsaXQgduG7m2kgxJHhu4tuaCBk4bqhbmcgbWJveCIKIAotIzogYnVpbHRpbi9hbS5jOjIxOTIKKyM6IGJ1aWx0aW4vYW0uYzoyMTgxCiBtc2dpZCAiZG8gbm90IHBhc3MgLS1rZWVwLWNyIGZsYWcgdG8gZ2l0LW1haWxzcGxpdCBpbmRlcGVuZGVudCBvZiBhbS5rZWVwY3IiCiBtc2dzdHIgIiIKICLEkeG7q25nIGNodXnhu4NuIGPhu50gLS1rZWVwLWNyIGNobyBnaXQtbWFpbHNwbGl0IGtow7RuZyBwaOG7pSB0aHXhu5ljIHbDoG8gYW0ua2VlcGNyIgogCi0jOiBidWlsdGluL2FtLmM6MjE5NQorIzogYnVpbHRpbi9hbS5jOjIxODQKIG1zZ2lkICJzdHJpcCBldmVyeXRoaW5nIGJlZm9yZSBhIHNjaXNzb3JzIGxpbmUiCiBtc2dzdHIgImPhuq90IG3hu41pIHRo4bupIHRyxrDhu5tjIGTDsm5nIHNjaXNzb3JzIgogCi0jOiBidWlsdGluL2FtLmM6MjE5NyBidWlsdGluL2FtLmM6MjIwMCBidWlsdGluL2FtLmM6MjIwMyBidWlsdGluL2FtLmM6MjIwNgotIzogYnVpbHRpbi9hbS5jOjIyMDkgYnVpbHRpbi9hbS5jOjIyMTIgYnVpbHRpbi9hbS5jOjIyMTUgYnVpbHRpbi9hbS5jOjIyMTgKLSM6IGJ1aWx0aW4vYW0uYzoyMjI0CisjOiBidWlsdGluL2FtLmM6MjE4NiBidWlsdGluL2FtLmM6MjE4OSBidWlsdGluL2FtLmM6MjE5MiBidWlsdGluL2FtLmM6MjE5NQorIzogYnVpbHRpbi9hbS5jOjIxOTggYnVpbHRpbi9hbS5jOjIyMDEgYnVpbHRpbi9hbS5jOjIyMDQgYnVpbHRpbi9hbS5jOjIyMDcKKyM6IGJ1aWx0aW4vYW0uYzoyMjEzCiBtc2dpZCAicGFzcyBpdCB0aHJvdWdoIGdpdC1hcHBseSIKIG1zZ3N0ciAiY2h1eeG7g24gbsOzIHF1YSBnaXQtYXBwbHkiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMjE0IGJ1aWx0aW4vY29tbWl0LmM6MTM2OCBidWlsdGluL2ZtdC1tZXJnZS1tc2cuYzo2NzEKLSM6IGJ1aWx0aW4vZm10LW1lcmdlLW1zZy5jOjY3NCBidWlsdGluL2dyZXAuYzo4ODEgYnVpbHRpbi9tZXJnZS5jOjI0OQotIzogYnVpbHRpbi9wdWxsLmM6MTU5IGJ1aWx0aW4vcHVsbC5jOjIxOCBidWlsdGluL3JlYmFzZS5jOjE0MTgKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MzA3IGJ1aWx0aW4vcmVwYWNrLmM6MzExIGJ1aWx0aW4vcmVwYWNrLmM6MzEzCisjOiBidWlsdGluL2FtLmM6MjIwMyBidWlsdGluL2NvbW1pdC5jOjEzNjggYnVpbHRpbi9mbXQtbWVyZ2UtbXNnLmM6NjcxCisjOiBidWlsdGluL2ZtdC1tZXJnZS1tc2cuYzo2NzQgYnVpbHRpbi9ncmVwLmM6ODgzIGJ1aWx0aW4vbWVyZ2UuYzoyNDkKKyM6IGJ1aWx0aW4vcHVsbC5jOjE2MCBidWlsdGluL3B1bGwuYzoyMTkgYnVpbHRpbi9yZWJhc2UuYzoxNDQyCisjOiBidWlsdGluL3JlcGFjay5jOjMwOCBidWlsdGluL3JlcGFjay5jOjMxMiBidWlsdGluL3JlcGFjay5jOjMxNAogIzogYnVpbHRpbi9zaG93LWJyYW5jaC5jOjY1MCBidWlsdGluL3Nob3ctcmVmLmM6MTcyIGJ1aWx0aW4vdGFnLmM6NDAzCi0jOiBwYXJzZS1vcHRpb25zLmg6MTQxIHBhcnNlLW9wdGlvbnMuaDoxNjIgcGFyc2Utb3B0aW9ucy5oOjMxMgorIzogcGFyc2Utb3B0aW9ucy5oOjE1MCBwYXJzZS1vcHRpb25zLmg6MTcxIHBhcnNlLW9wdGlvbnMuaDozMTIKIG1zZ2lkICJuIgogbXNnc3RyICJuIgogCi0jOiBidWlsdGluL2FtLmM6MjIyMCBidWlsdGluL2JyYW5jaC5jOjY2MSBidWlsdGluL2Zvci1lYWNoLXJlZi5jOjM4Ci0jOiBidWlsdGluL3JlcGxhY2UuYzo1NTQgYnVpbHRpbi90YWcuYzo0MzcgYnVpbHRpbi92ZXJpZnktdGFnLmM6MzgKKyM6IGJ1aWx0aW4vYW0uYzoyMjA5IGJ1aWx0aW4vYnJhbmNoLmM6NjYxIGJ1aWx0aW4vZm9yLWVhY2gtcmVmLmM6MzgKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU1NSBidWlsdGluL3RhZy5jOjQzNyBidWlsdGluL3ZlcmlmeS10YWcuYzozOAogbXNnaWQgImZvcm1hdCIKIG1zZ3N0ciAixJHhu4tuaCBk4bqhbmciCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMjIxCisjOiBidWlsdGluL2FtLmM6MjIxMAogbXNnaWQgImZvcm1hdCB0aGUgcGF0Y2goZXMpIGFyZSBpbiIKIG1zZ3N0ciAixJHhu4tuaCBk4bqhbmcgKGPDoWMpIG1p4bq/bmcgdsOhIHRoZW8iCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMjI3CisjOiBidWlsdGluL2FtLmM6MjIxNgogbXNnaWQgIm92ZXJyaWRlIGVycm9yIG1lc3NhZ2Ugd2hlbiBwYXRjaCBmYWlsdXJlIG9jY3VycyIKIG1zZ3N0ciAixJHDqCBsw6puIGPDoWMgbOG7nWkgbmjhuq9uIGzhu5dpIGtoaSB44bqjeSByYSBs4buXaSB2w6EgbmdoacOqbSB0cuG7jW5nIgogCi0jOiBidWlsdGluL2FtLmM6MjIyOQorIzogYnVpbHRpbi9hbS5jOjIyMTgKIG1zZ2lkICJjb250aW51ZSBhcHBseWluZyBwYXRjaGVzIGFmdGVyIHJlc29sdmluZyBhIGNvbmZsaWN0IgogbXNnc3RyICJ0aeG6v3AgdOG7pWMgw6FwIGThu6VuZyBjw6FjIG1p4bq/bmcgdsOhIHNhdSBraGkgZ2nhuqNpIHF1eeG6v3QgeHVuZyDEkeG7mXQiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMjMyCisjOiBidWlsdGluL2FtLmM6MjIyMQogbXNnaWQgInN5bm9ueW1zIGZvciAtLWNvbnRpbnVlIgogbXNnc3RyICLEkeG7k25nIG5naMSpYSB24bubaSAtLWNvbnRpbnVlIgogCi0jOiBidWlsdGluL2FtLmM6MjIzNQorIzogYnVpbHRpbi9hbS5jOjIyMjQKIG1zZ2lkICJza2lwIHRoZSBjdXJyZW50IHBhdGNoIgogbXNnc3RyICJi4buPIHF1YSBtaeG6v25nIHbDoSBoaeG7h24gaMOgbmgiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMjM4CisjOiBidWlsdGluL2FtLmM6MjIyNwogbXNnaWQgInJlc3RvcmUgdGhlIG9yaWdpbmFsIGJyYW5jaCBhbmQgYWJvcnQgdGhlIHBhdGNoaW5nIG9wZXJhdGlvbi4iCiBtc2dzdHIgInBo4bulYyBo4buTaSBs4bqhaSBuaMOhbmggZ+G7kWMgdsOgIGxv4bqhaSBi4buPIHRoYW8gdMOhYyB2w6EuIgogCi0jOiBidWlsdGluL2FtLmM6MjI0MQorIzogYnVpbHRpbi9hbS5jOjIyMzAKIG1zZ2lkICJhYm9ydCB0aGUgcGF0Y2hpbmcgb3BlcmF0aW9uIGJ1dCBrZWVwIEhFQUQgd2hlcmUgaXQgaXMuIgogbXNnc3RyICJi4buPIHF1YSB0aGFvIHTDoWMgdsOhIG5oxrBuZyB24bqrbiBnaeG7ryBIRUFEIGNo4buJIMSR4bq/biBuw7MuIgogCi0jOiBidWlsdGluL2FtLmM6MjI0NAorIzogYnVpbHRpbi9hbS5jOjIyMzMKIG1zZ2lkICJzaG93IHRoZSBwYXRjaCBiZWluZyBhcHBsaWVkLiIKIG1zZ3N0ciAiaGnhu4NuIHRo4buLIG1p4bq/bmcgdsOhIMSRw6MgxJHGsOG7o2Mgw6FwIGThu6VuZyBy4buTaS4iCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMjQ4CisjOiBidWlsdGluL2FtLmM6MjIzNwogbXNnaWQgImxpZSBhYm91dCBjb21taXR0ZXIgZGF0ZSIKIG1zZ3N0ciAibsOzaSBk4buRaSB24buBIG5nw6B5IGNodXnhu4NuIGdpYW8iCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMjUwCisjOiBidWlsdGluL2FtLmM6MjIzOQogbXNnaWQgInVzZSBjdXJyZW50IHRpbWVzdGFtcCBmb3IgYXV0aG9yIGRhdGUiCiBtc2dzdHIgImTDuW5nIGThuqV1IHRo4budaSBnaWFuIGhp4buHbiB04bqhaSBjaG8gbmfDoHkgdMOhYyBnaeG6oyIKIAotIzogYnVpbHRpbi9hbS5jOjIyNTIgYnVpbHRpbi9jb21taXQtdHJlZS5jOjEyMCBidWlsdGluL2NvbW1pdC5jOjE1MTEKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoyODYgYnVpbHRpbi9wdWxsLmM6MTkzIGJ1aWx0aW4vcmViYXNlLmM6NDg5Ci0jOiBidWlsdGluL3JlYmFzZS5jOjE0NTkgYnVpbHRpbi9yZXZlcnQuYzoxMTcgYnVpbHRpbi90YWcuYzo0MTgKKyM6IGJ1aWx0aW4vYW0uYzoyMjQxIGJ1aWx0aW4vY29tbWl0LXRyZWUuYzoxMjAgYnVpbHRpbi9jb21taXQuYzoxNTExCisjOiBidWlsdGluL21lcmdlLmM6Mjg2IGJ1aWx0aW4vcHVsbC5jOjE5NCBidWlsdGluL3JlYmFzZS5jOjQ5MAorIzogYnVpbHRpbi9yZWJhc2UuYzoxNDgzIGJ1aWx0aW4vcmV2ZXJ0LmM6MTE3IGJ1aWx0aW4vdGFnLmM6NDE4CiBtc2dpZCAia2V5LWlkIgogbXNnc3RyICJtw6Mtc+G7kS1raMOzYSIKIAotIzogYnVpbHRpbi9hbS5jOjIyNTMgYnVpbHRpbi9yZWJhc2UuYzo0OTAgYnVpbHRpbi9yZWJhc2UuYzoxNDYwCisjOiBidWlsdGluL2FtLmM6MjI0MiBidWlsdGluL3JlYmFzZS5jOjQ5MSBidWlsdGluL3JlYmFzZS5jOjE0ODQKIG1zZ2lkICJHUEctc2lnbiBjb21taXRzIgogbXNnc3RyICJDw6FjIGzhuqduIGNodXnhu4NuIGdpYW8ga8O9LUdQRyIKIAotIzogYnVpbHRpbi9hbS5jOjIyNTYKKyM6IGJ1aWx0aW4vYW0uYzoyMjQ1CiBtc2dpZCAiKGludGVybmFsIHVzZSBmb3IgZ2l0LXJlYmFzZSkiCiBtc2dzdHIgIihkw7luZyBu4buZaSBi4buZIGNobyBnaXQtcmViYXNlKSIKIAotIzogYnVpbHRpbi9hbS5jOjIyNzQKKyM6IGJ1aWx0aW4vYW0uYzoyMjYzCiBtc2dpZCAiIgogIlRoZSAtYi8tLWJpbmFyeSBvcHRpb24gaGFzIGJlZW4gYSBuby1vcCBmb3IgbG9uZyB0aW1lLCBhbmRcbiIKICJpdCB3aWxsIGJlIHJlbW92ZWQuIFBsZWFzZSBkbyBub3QgdXNlIGl0IGFueW1vcmUuIgpAQCAtOTAxMSwxNiArOTA1NCwxNiBAQAogIlTDuXkgY2jhu41uIC1iLy0tYmluYXJ5IMSRw6Mga2jDtG5nIGTDuW5nIHThu6sgbMOidSBy4buTaSwgdsOgXG4iCiAibsOzIHPhur0gxJHGsOG7o2MgYuG7jyDEkWkuIFhpbiDEkeG7q25nIHPhu60gZOG7pW5nIG7DsyB0aMOqbSBu4buvYS4iCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMjgxCisjOiBidWlsdGluL2FtLmM6MjI3MAogbXNnaWQgImZhaWxlZCB0byByZWFkIHRoZSBpbmRleCIKIG1zZ3N0ciAiZ+G6t3AgbOG7l2kgxJHhu41jIGLhuqNuZyBt4bulYyBs4bulYyIKIAotIzogYnVpbHRpbi9hbS5jOjIyOTYKKyM6IGJ1aWx0aW4vYW0uYzoyMjg1CiAjLCBjLWZvcm1hdAogbXNnaWQgInByZXZpb3VzIHJlYmFzZSBkaXJlY3RvcnkgJXMgc3RpbGwgZXhpc3RzIGJ1dCBtYm94IGdpdmVuLiIKIG1zZ3N0ciAidGjGsCBt4bulYyByZWJhc2UgdHLGsOG7m2MgJXMga2jDtG5nIHPhurVuIGPDsyBuaMawbmcgbWJveCBs4bqhaSDEkcawYSByYS4iCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMzIwCisjOiBidWlsdGluL2FtLmM6MjMwOQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiU3RyYXkgJXMgZGlyZWN0b3J5IGZvdW5kLlxuIgpAQCAtOTAyOSwxMSArOTA3MiwxMSBAQAogIlTDrG0gdGjhuqV5IHRoxrAgbeG7pWMgbOG6oWMgJXMuXG4iCiAiRMO5bmcgXCJnaXQgYW0gLS1hYm9ydFwiIMSR4buDIGxv4bqhaSBi4buPIG7DsyDEkWkuIgogCi0jOiBidWlsdGluL2FtLmM6MjMyNgorIzogYnVpbHRpbi9hbS5jOjIzMTUKIG1zZ2lkICJSZXNvbHZlIG9wZXJhdGlvbiBub3QgaW4gcHJvZ3Jlc3MsIHdlIGFyZSBub3QgcmVzdW1pbmcuIgogbXNnc3RyICJUaGFvIHTDoWMgcGjDom4gZ2nhuqNpIGtow7RuZyDEkcaw4bujYyB0aeG6v24gaMOgbmgsIGNow7puZyB0YSBraMO0bmcgcGjhu6VjIGjhu5NpIGzhuqFpLiIKIAotIzogYnVpbHRpbi9hbS5jOjIzMzYKKyM6IGJ1aWx0aW4vYW0uYzoyMzI1CiBtc2dpZCAiaW50ZXJhY3RpdmUgbW9kZSByZXF1aXJlcyBwYXRjaGVzIG9uIHRoZSBjb21tYW5kIGxpbmUiCiBtc2dzdHIgImNo4bq/IMSR4buZIHTGsMahbmcgdMOhYyB5w6p1IGPhuqd1IGPDsyBjw6FjIG1p4bq/bmcgdsOhIHRyw6puIGTDsm5nIGzDqm5oIgogCkBAIC05MzQ5LDE1NiArOTM5MiwxNTYgQEAKIG1zZ2lkICItLWJpc2VjdC10ZXJtcyByZXF1aXJlcyAwIG9yIDEgYXJndW1lbnQiCiBtc2dzdHIgIi0tYmlzZWN0LXRlcm1zIGPhuqduIDAgaG/hurdjIDEgdGhhbSBz4buRIgogCi0jOiBidWlsdGluL2JsYW1lLmM6MzIKKyM6IGJ1aWx0aW4vYmxhbWUuYzozMQogbXNnaWQgImdpdCBibGFtZSBbPG9wdGlvbnM+XSBbPHJldi1vcHRzPl0gWzxyZXY+XSBbLS1dIDxmaWxlPiIKIG1zZ3N0ciAiZ2l0IGJsYW1lIFs8Y8OhYyB0w7l5IGNo4buNbj5dIFs8cmV2LW9wdHM+XSBbPHJldj5dIFstLV0gPHThuq1wLXRpbj4iCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzozNworIzogYnVpbHRpbi9ibGFtZS5jOjM2CiBtc2dpZCAiPHJldi1vcHRzPiBhcmUgZG9jdW1lbnRlZCBpbiBnaXQtcmV2LWxpc3QoMSkiCiBtc2dzdHIgIjxyZXYtb3B0cz4gxJHGsOG7o2MgbcO0IHThuqMgdHJvbmcgdMOgaSBsaeG7h3UgZ2l0LXJldi1saXN0KDEpIgogCi0jOiBidWlsdGluL2JsYW1lLmM6NDEwCisjOiBidWlsdGluL2JsYW1lLmM6NDA5CiAjLCBjLWZvcm1hdAogbXNnaWQgImV4cGVjdGluZyBhIGNvbG9yOiAlcyIKIG1zZ3N0ciAiY+G6p24gbeG7mXQgbcOgdTogJXMiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo0MTcKKyM6IGJ1aWx0aW4vYmxhbWUuYzo0MTYKIG1zZ2lkICJtdXN0IGVuZCB3aXRoIGEgY29sb3IiCiBtc2dzdHIgInBo4bqjaSBr4bq/dCB0aMO6YyBi4bqxbmcgbeG7mXQgbcOgdSIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjczMAorIzogYnVpbHRpbi9ibGFtZS5jOjcyOQogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIGNvbG9yICclcycgaW4gY29sb3IuYmxhbWUucmVwZWF0ZWRMaW5lcyIKIG1zZ3N0ciAibcOgdSBraMO0bmcgaOG7o3AgbOG7hyDigJwlc+KAnSB0cm9uZyBjb2xvci5ibGFtZS5yZXBlYXRlZExpbmVzIgogCi0jOiBidWlsdGluL2JsYW1lLmM6NzQ4CisjOiBidWlsdGluL2JsYW1lLmM6NzQ3CiBtc2dpZCAiaW52YWxpZCB2YWx1ZSBmb3IgYmxhbWUuY29sb3JpbmciCiBtc2dzdHIgIm3DoHUga2jDtG5nIGjhu6NwIGzhu4cgY2hvIGJsYW1lLmNvbG9yaW5nIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODIzCisjOiBidWlsdGluL2JsYW1lLmM6ODIyCiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCBmaW5kIHJldmlzaW9uICVzIHRvIGlnbm9yZSIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIHTDrG0gdGjhuqV5IMSRaeG7g20geMOpdCBkdXnhu4d0ICVzIMSR4buDIG3DoCBi4buPIHF1YSIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg0NQorIzogYnVpbHRpbi9ibGFtZS5jOjg0NAogbXNnaWQgIlNob3cgYmxhbWUgZW50cmllcyBhcyB3ZSBmaW5kIHRoZW0sIGluY3JlbWVudGFsbHkiCiBtc2dzdHIgIkhp4buDbiB0aOG7iyBjw6FjIG3hu6VjIOKAnGJsYW1l4oCdIG5oxrAgbMOgIGNow7puZyB0YSB0aOG6pXkgY2jDum5nLCB0xINuZyBk4bqnbiIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg0NgorIzogYnVpbHRpbi9ibGFtZS5jOjg0NQogbXNnaWQgIlNob3cgYmxhbmsgU0hBLTEgZm9yIGJvdW5kYXJ5IGNvbW1pdHMgKERlZmF1bHQ6IG9mZikiCiBtc2dzdHIgIiIKICJIaeG7g24gdGjhu4sgU0hBLTEgdHLhuq9uZyBjaG8gbmjhu69uZyBs4bqnbiBjaHV54buDbiBnaWFvIGJpw6puIGdp4bubaSAoTeG6t2MgxJHhu4tuaDogb2ZmKSIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg0NworIzogYnVpbHRpbi9ibGFtZS5jOjg0NgogbXNnaWQgIkRvIG5vdCB0cmVhdCByb290IGNvbW1pdHMgYXMgYm91bmRhcmllcyAoRGVmYXVsdDogb2ZmKSIKIG1zZ3N0ciAiS2jDtG5nIGNvaSBjw6FjIGzhuqduIGNodXnhu4NuIGdpYW8gZ+G7kWMgbMOgIGdp4bubaSBo4bqhbiAoTeG6t2MgxJHhu4tuaDogb2ZmKSIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg0OAorIzogYnVpbHRpbi9ibGFtZS5jOjg0NwogbXNnaWQgIlNob3cgd29yayBjb3N0IHN0YXRpc3RpY3MiCiBtc2dzdHIgIkhp4buDbiB0aOG7iyB0aOG7kW5nIGvDqiBjw7RuZyBz4bupYyBsw6BtIHZp4buHYyIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg0OQorIzogYnVpbHRpbi9ibGFtZS5jOjg0OAogbXNnaWQgIkZvcmNlIHByb2dyZXNzIHJlcG9ydGluZyIKIG1zZ3N0ciAiw4lwIGJ14buZYyBiw6FvIGPDoW8gdGnhur9uIHRyaeG7g24gY8O0bmcgdmnhu4djIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODUwCisjOiBidWlsdGluL2JsYW1lLmM6ODQ5CiBtc2dpZCAiU2hvdyBvdXRwdXQgc2NvcmUgZm9yIGJsYW1lIGVudHJpZXMiCiBtc2dzdHIgIkhp4buDbiB0aOG7iyBr4bq/dCB4deG6pXQgxJFp4buDbSBz4buRIGPDsyBjw6FjIG3hu6VjIHRpbiDigJxibGFtZeKAnSIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg1MQorIzogYnVpbHRpbi9ibGFtZS5jOjg1MAogbXNnaWQgIlNob3cgb3JpZ2luYWwgZmlsZW5hbWUgKERlZmF1bHQ6IGF1dG8pIgogbXNnc3RyICJIaeG7g24gdGjhu4sgdMOqbiB04bqtcCB0aW4gZ+G7kWMgKE3hurdjIMSR4buLbmg6IGF1dG8pIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODUyCisjOiBidWlsdGluL2JsYW1lLmM6ODUxCiBtc2dpZCAiU2hvdyBvcmlnaW5hbCBsaW5lbnVtYmVyIChEZWZhdWx0OiBvZmYpIgogbXNnc3RyICJIaeG7g24gdGjhu4sgc+G7kSBkw7JuZyBn4buRYyAoTeG6t2MgxJHhu4tuaDogb2ZmKSIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg1MworIzogYnVpbHRpbi9ibGFtZS5jOjg1MgogbXNnaWQgIlNob3cgaW4gYSBmb3JtYXQgZGVzaWduZWQgZm9yIG1hY2hpbmUgY29uc3VtcHRpb24iCiBtc2dzdHIgIkhp4buDbiB0aOG7iyDhu58gxJHhu4tuaCBk4bqhbmcgxJHDoyB0aGnhur90IGvhur8gY2hvIHPhu7EgdGnDqnUgZMO5bmcgYuG6sW5nIG3DoXkiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NTQKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NTMKIG1zZ2lkICJTaG93IHBvcmNlbGFpbiBmb3JtYXQgd2l0aCBwZXItbGluZSBjb21taXQgaW5mb3JtYXRpb24iCiBtc2dzdHIgIkhp4buDbiB0aOG7iyDEkeG7i25oIGThuqFuZyDigJxwb3JjZWxhaW7igJ0gduG7m2kgdGjDtG5nIHRpbiBjaHV54buDbiBnaWFvIG3hu5dpIGTDsm5nIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODU1CisjOiBidWlsdGluL2JsYW1lLmM6ODU0CiBtc2dpZCAiVXNlIHRoZSBzYW1lIG91dHB1dCBtb2RlIGFzIGdpdC1hbm5vdGF0ZSAoRGVmYXVsdDogb2ZmKSIKIG1zZ3N0ciAiRMO5bmcgY8O5bmcgY2jhur8gxJHhu5kgeHXhuqV0IHJhIHbhu5tpIGdpdC1hbm5vdGF0ZSAoTeG6t2MgxJHhu4tuaDogb2ZmKSIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg1NgorIzogYnVpbHRpbi9ibGFtZS5jOjg1NQogbXNnaWQgIlNob3cgcmF3IHRpbWVzdGFtcCAoRGVmYXVsdDogb2ZmKSIKIG1zZ3N0ciAiSGnhu4NuIHRo4buLIGThuqV1IHbhur90IHRo4budaSBnaWFuIGThuqFuZyB0aMO0IChN4bq3YyDEkeG7i25oOiBvZmYpIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODU3CisjOiBidWlsdGluL2JsYW1lLmM6ODU2CiBtc2dpZCAiU2hvdyBsb25nIGNvbW1pdCBTSEExIChEZWZhdWx0OiBvZmYpIgogbXNnc3RyICJIaeG7g24gdGjhu4sgU0hBMSBj4bunYSBs4bqnbiBjaHV54buDbiBnaWFvIGThuqFuZyBkw6BpIChN4bq3YyDEkeG7i25oOiBvZmYpIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODU4CisjOiBidWlsdGluL2JsYW1lLmM6ODU3CiBtc2dpZCAiU3VwcHJlc3MgYXV0aG9yIG5hbWUgYW5kIHRpbWVzdGFtcCAoRGVmYXVsdDogb2ZmKSIKIG1zZ3N0ciAiS2jDtG5nIGhp4buDbiB0aOG7iyB0w6puIHTDoWMgZ2nhuqMgdsOgIGThuqV1IHbhur90IHRo4budaSBnaWFuIChN4bq3YyDEkeG7i25oOiBvZmYpIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODU5CisjOiBidWlsdGluL2JsYW1lLmM6ODU4CiBtc2dpZCAiU2hvdyBhdXRob3IgZW1haWwgaW5zdGVhZCBvZiBuYW1lIChEZWZhdWx0OiBvZmYpIgogbXNnc3RyICJIaeG7g24gdGjhu4sgdGjGsCDEkWnhu4duIHThu60gY+G7p2EgdMOhYyBnaeG6oyB0aGF5IHbDrCB0w6puIChN4bq3YyDEkeG7i25oOiBvZmYpIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODYwCisjOiBidWlsdGluL2JsYW1lLmM6ODU5CiBtc2dpZCAiSWdub3JlIHdoaXRlc3BhY2UgZGlmZmVyZW5jZXMiCiBtc2dzdHIgIkLhu48gcXVhIGPDoWMga2jDoWMgYmnhu4d0IGRvIGtob+G6o25nIHRy4bqvbmcgZ8OieSByYSIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg2MSBidWlsdGluL2xvZy5jOjE2MjkKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NjAgYnVpbHRpbi9sb2cuYzoxNjMwCiBtc2dpZCAicmV2IgogbXNnc3RyICJyZXYiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NjEKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NjAKIG1zZ2lkICJJZ25vcmUgPHJldj4gd2hlbiBibGFtaW5nIgotbXNnc3RyICJi4buPIHF1YSA8cmV2PiBraGkgYmxhbWUiCittc2dzdHIgIkLhu48gcXVhIDxyZXY+IGtoaSBibGFtZSIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg2MgorIzogYnVpbHRpbi9ibGFtZS5jOjg2MQogbXNnaWQgIklnbm9yZSByZXZpc2lvbnMgZnJvbSA8ZmlsZT4iCiBtc2dzdHIgIkLhu48gcXVhIGPDoWMgxJFp4buDbSB4w6l0IGR1eeG7h3QgdOG7qyA8dOG6rXAgdGluPiIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg2MworIzogYnVpbHRpbi9ibGFtZS5jOjg2MgogbXNnaWQgImNvbG9yIHJlZHVuZGFudCBtZXRhZGF0YSBmcm9tIHByZXZpb3VzIGxpbmUgZGlmZmVyZW50bHkiCiBtc2dzdHIgInNpw6p1IGThu68gbGnhu4d1IGTGsCB0aOG7q2EgbcOgdSB04burIGTDsm5nIHRyxrDhu5tjIGtow6FjIGjhurNuIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODY0CisjOiBidWlsdGluL2JsYW1lLmM6ODYzCiBtc2dpZCAiY29sb3IgbGluZXMgYnkgYWdlIgogbXNnc3RyICJjw6FjIGTDsm5nIG3DoHUgdGhlbyB0deG7lWkiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NzEKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NzAKIG1zZ2lkICJVc2UgYW4gZXhwZXJpbWVudGFsIGhldXJpc3RpYyB0byBpbXByb3ZlIGRpZmZzIgogbXNnc3RyICJEw7luZyBt4buZdCBwaOG7j25nIMSRb8OhbiB0aOG7rSBuZ2hp4buHbSDEkeG7gyB0xINuZyBjxrDhu51uZyBjw6FjIGRpZmYiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NzMKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NzIKIG1zZ2lkICJTcGVuZCBleHRyYSBjeWNsZXMgdG8gZmluZCBiZXR0ZXIgbWF0Y2giCiBtc2dzdHIgIlRpw6p1IHRo4bulIHRow6ptIG7Eg25nIHTDoGkgbmd1ecOqbiBtw6F5IG3Ds2MgxJHhu4MgdMOsbSBraeG6v20gdOG7kXQgaMahbiBu4buvYSIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg3NAorIzogYnVpbHRpbi9ibGFtZS5jOjg3MwogbXNnaWQgIlVzZSByZXZpc2lvbnMgZnJvbSA8ZmlsZT4gaW5zdGVhZCBvZiBjYWxsaW5nIGdpdC1yZXYtbGlzdCIKIG1zZ3N0ciAiIgogIlPhu60gZOG7pW5nIMSRaeG7g20geMOpdCBkdXnhu4d0IChyZXZpc2lvbikgdOG7qyA8dOG6rXAgdGluPiB0aGF5IHbDrCBn4buNaSDigJxnaXQtcmV2LWxpc3TigJ0iCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NzUKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NzQKIG1zZ2lkICJVc2UgPGZpbGU+J3MgY29udGVudHMgYXMgdGhlIGZpbmFsIGltYWdlIgogbXNnc3RyICJT4butIGThu6VuZyBu4buZaSBkdW5nIGPhu6dhIDx04bqtcCB0aW4+IG5oxrAgbMOgIOG6o25oIGN14buRaSBjw7luZyIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg3NiBidWlsdGluL2JsYW1lLmM6ODc3CisjOiBidWlsdGluL2JsYW1lLmM6ODc1IGJ1aWx0aW4vYmxhbWUuYzo4NzYKIG1zZ2lkICJzY29yZSIKIG1zZ3N0ciAixJFp4buDbSBz4buRIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODc2CisjOiBidWlsdGluL2JsYW1lLmM6ODc1CiBtc2dpZCAiRmluZCBsaW5lIGNvcGllcyB3aXRoaW4gYW5kIGFjcm9zcyBmaWxlcyIKIG1zZ3N0ciAiVMOsbSBjw6FjIGLhuqNuIHNhbyBjaMOpcCBkw7JuZyB0cm9uZyB2w6AgbmdhbmcgcXVhIHThuq1wIHRpbiIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg3NworIzogYnVpbHRpbi9ibGFtZS5jOjg3NgogbXNnaWQgIkZpbmQgbGluZSBtb3ZlbWVudHMgd2l0aGluIGFuZCBhY3Jvc3MgZmlsZXMiCiBtc2dzdHIgIlTDrG0gY8OhYyBkaSBjaHV54buDbiBkw7JuZyB0cm9uZyB2w6AgbmdhbmcgcXVhIHThuq1wIHRpbiIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg3OAorIzogYnVpbHRpbi9ibGFtZS5jOjg3NwogbXNnaWQgIm4sbSIKIG1zZ3N0ciAibixtIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODc4CisjOiBidWlsdGluL2JsYW1lLmM6ODc3CiBtc2dpZCAiUHJvY2VzcyBvbmx5IGxpbmUgcmFuZ2UgbixtLCBjb3VudGluZyBmcm9tIDEiCiBtc2dzdHIgIljhu60gbMO9IGNo4buJIGTDsm5nIHbDuW5nIG4sbSwgdMOtbmggdOG7qyAxIgogCkBAIC05NzM0LDcgKzk3NzcsNyBAQAogbXNnaWQgImRvIG5vdCB1c2UiCiBtc2dzdHIgImtow7RuZyBkw7luZyIKIAotIzogYnVpbHRpbi9icmFuY2guYzo2MjYgYnVpbHRpbi9yZWJhc2UuYzo0ODUKKyM6IGJ1aWx0aW4vYnJhbmNoLmM6NjI2IGJ1aWx0aW4vcmViYXNlLmM6NDg2CiBtc2dpZCAidXBzdHJlYW0iCiBtc2dzdHIgInRoxrDhu6NuZyBuZ3Xhu5NuIgogCkBAIC05ODQ1LDcgKzk4ODgsNyBAQAogbXNnaWQgImZvcm1hdCB0byB1c2UgZm9yIHRoZSBvdXRwdXQiCiBtc2dzdHIgIsSR4buLbmggZOG6oW5nIHPhur0gZMO5bmcgY2hvIMSR4bqndSByYSIKIAotIzogYnVpbHRpbi9icmFuY2guYzo2ODQgYnVpbHRpbi9jbG9uZS5jOjc2MQorIzogYnVpbHRpbi9icmFuY2guYzo2ODQgYnVpbHRpbi9jbG9uZS5jOjc2MAogbXNnaWQgIkhFQUQgbm90IGZvdW5kIGJlbG93IHJlZnMvaGVhZHMhIgogbXNnc3RyICJLaMO0bmcgdMOsbSB0aOG6pXkgSEVBRCDhu58gZMaw4bubaSByZWZzL2hlYWRzISIKIApAQCAtOTk0OCw3ICs5OTkxLDcgQEAKIG1zZ2lkICJOZWVkIGEgcmVwb3NpdG9yeSB0byB1bmJ1bmRsZS4iCiBtc2dzdHIgIkPhuqduIG3hu5l0IGtobyBjaOG7qWEgxJHhu4MgY8OzIHRo4buDIGdp4bqjaSBuw6luIG3hu5l0IGJ1bmRsZS4iCiAKLSM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo1OTQKKyM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo1OTUKIG1zZ2lkICIiCiAiZ2l0IGNhdC1maWxlICgtdCBbLS1hbGxvdy11bmtub3duLXR5cGVdIHwgLXMgWy0tYWxsb3ctdW5rbm93bi10eXBlXSB8IC1lIHwgLSIKICJwIHwgPHR5cGU+IHwgLS10ZXh0Y29udiB8IC0tZmlsdGVycykgWy0tcGF0aD08cGF0aD5dIDxvYmplY3Q+IgpAQCAtOTk1Niw3ICs5OTk5LDcgQEAKICJnaXQgY2F0LWZpbGUgKC10IFstLWFsbG93LXVua25vd24tdHlwZV0gfCAtcyBbLS1hbGxvdy11bmtub3duLXR5cGVdIHwgLWUgfCAtIgogInAgfCA8a2nhu4N1PiB8IC0tdGV4dGNvbnYpIHwgLS1maWx0ZXJzKSBbLS1wYXRoPTzEkcaw4budbmcvZOG6q24+XSA8xJHhu5FpX3TGsOG7o25nPiIKIAotIzogYnVpbHRpbi9jYXQtZmlsZS5jOjU5NQorIzogYnVpbHRpbi9jYXQtZmlsZS5jOjU5NgogbXNnaWQgIiIKICJnaXQgY2F0LWZpbGUgKC0tYmF0Y2ggfCAtLWJhdGNoLWNoZWNrKSBbLS1mb2xsb3ctc3ltbGlua3NdIFstLXRleHRjb252IHwgLS0iCiAiZmlsdGVyc10iCkBAIC05OTY0LDcyICsxMDAwNyw3MiBAQAogImdpdCBjYXQtZmlsZSAoLS1iYXRjaCB8IC0tYmF0Y2gtY2hlY2spIFstLWZvbGxvdy1zeW1saW5rc10gWy0tdGV4dGNvbnYgfCAtLSIKICJmaWx0ZXJzXSIKIAotIzogYnVpbHRpbi9jYXQtZmlsZS5jOjYxNgorIzogYnVpbHRpbi9jYXQtZmlsZS5jOjYxNwogbXNnaWQgIm9ubHkgb25lIGJhdGNoIG9wdGlvbiBtYXkgYmUgc3BlY2lmaWVkIgogbXNnc3RyICJjaOG7iSBt4buZdCB0w7l5IGNo4buNbiBiYXRjaCDEkcaw4bujYyBjaOG7iSByYSIKIAotIzogYnVpbHRpbi9jYXQtZmlsZS5jOjYzNAorIzogYnVpbHRpbi9jYXQtZmlsZS5jOjYzNQogbXNnaWQgIjx0eXBlPiBjYW4gYmUgb25lIG9mOiBibG9iLCB0cmVlLCBjb21taXQsIHRhZyIKIG1zZ3N0ciAiPGtp4buDdT4gbMOgIG3hu5l0IHRyb25nIHPhu5E6IGJsb2IsIHRyZWUsIGNvbW1pdCBob+G6t2MgdGFnIgogCi0jOiBidWlsdGluL2NhdC1maWxlLmM6NjM1CisjOiBidWlsdGluL2NhdC1maWxlLmM6NjM2CiBtc2dpZCAic2hvdyBvYmplY3QgdHlwZSIKIG1zZ3N0ciAiaGnhu4NuIHRo4buLIGtp4buDdSDEkeG7kWkgdMaw4bujbmciCiAKLSM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2MzYKKyM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2MzcKIG1zZ2lkICJzaG93IG9iamVjdCBzaXplIgogbXNnc3RyICJoaeG7g24gdGjhu4sga8OtY2ggdGjGsOG7m2MgxJHhu5FpIHTGsOG7o25nIgogCi0jOiBidWlsdGluL2NhdC1maWxlLmM6NjM4CisjOiBidWlsdGluL2NhdC1maWxlLmM6NjM5CiBtc2dpZCAiZXhpdCB3aXRoIHplcm8gd2hlbiB0aGVyZSdzIG5vIGVycm9yIgogbXNnc3RyICJ0aG/DoXQgduG7m2kgMCBraGkga2jDtG5nIGPDsyBs4buXaSIKIAotIzogYnVpbHRpbi9jYXQtZmlsZS5jOjYzOQorIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY0MAogbXNnaWQgInByZXR0eS1wcmludCBvYmplY3QncyBjb250ZW50IgogbXNnc3RyICJpbiBu4buZaSBkdW5nIMSR4buRaSB0xrDhu6NuZyBk4bqhbmcgZOG7hSDEkeG7jWMiCiAKLSM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NDEKKyM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NDIKIG1zZ2lkICJmb3IgYmxvYiBvYmplY3RzLCBydW4gdGV4dGNvbnYgb24gb2JqZWN0J3MgY29udGVudCIKIG1zZ3N0ciAiduG7m2kgxJHhu5FpIHTGsOG7o25nIGJsb2IsIGNo4bqheSBs4buHbmggdGV4dGNvbnYgdHLDqm4gbuG7mWkgZHVuZyBj4bunYSDEkeG7kWkgdMaw4bujbmciCiAKLSM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NDMKKyM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NDQKIG1zZ2lkICJmb3IgYmxvYiBvYmplY3RzLCBydW4gZmlsdGVycyBvbiBvYmplY3QncyBjb250ZW50IgogbXNnc3RyICJ24bubaSDEkeG7kWkgdMaw4bujbmcgYmxvYiwgY2jhuqF5IGzhu4duaCBmaWx0ZXJzIHRyw6puIG7hu5lpIGR1bmcgY+G7p2EgxJHhu5FpIHTGsOG7o25nIgogCi0jOiBidWlsdGluL2NhdC1maWxlLmM6NjQ0IGdpdC1zdWJtb2R1bGUuc2g6OTM2CisjOiBidWlsdGluL2NhdC1maWxlLmM6NjQ1IGdpdC1zdWJtb2R1bGUuc2g6OTM2CiBtc2dpZCAiYmxvYiIKIG1zZ3N0ciAiYmxvYiIKIAotIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY0NQorIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY0NgogbXNnaWQgInVzZSBhIHNwZWNpZmljIHBhdGggZm9yIC0tdGV4dGNvbnYvLS1maWx0ZXJzIgogbXNnc3RyICJkw7luZyBt4buZdCDEkcaw4budbmcgZOG6q24gcsO1IHLDoG5nIGNobyAtLXRleHRjb252Ly0tZmlsdGVycyIKIAotIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY0NworIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY0OAogbXNnaWQgImFsbG93IC1zIGFuZCAtdCB0byB3b3JrIHdpdGggYnJva2VuL2NvcnJ1cHQgb2JqZWN0cyIKIG1zZ3N0ciAiY2hvIHBow6lwIC1zIHbDoCAtdCDEkeG7gyBsw6BtIHZp4buHYyB24bubaSBjw6FjIMSR4buRaSB0xrDhu6NuZyBzYWkvaOG7j25nIgogCi0jOiBidWlsdGluL2NhdC1maWxlLmM6NjQ4CisjOiBidWlsdGluL2NhdC1maWxlLmM6NjQ5CiBtc2dpZCAiYnVmZmVyIC0tYmF0Y2ggb3V0cHV0IgogbXNnc3RyICLEkeG7h20ga+G6v3QgeHXhuqV0IC0tYmF0Y2giCiAKLSM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NTAKKyM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NTEKIG1zZ2lkICJzaG93IGluZm8gYW5kIGNvbnRlbnQgb2Ygb2JqZWN0cyBmZWQgZnJvbSB0aGUgc3RhbmRhcmQgaW5wdXQiCiBtc2dzdHIgIiIKICJoaeG7g24gdGjhu4sgdGjDtG5nIHRpbiB2w6AgbuG7mWkgZHVuZyBj4bunYSBjw6FjIMSR4buRaSB0xrDhu6NuZyBs4bqleSB04burIMSR4bqndSB2w6BvIHRpw6p1IGNodeG6qW4iCiAKLSM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NTQKKyM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NTUKIG1zZ2lkICJzaG93IGluZm8gYWJvdXQgb2JqZWN0cyBmZWQgZnJvbSB0aGUgc3RhbmRhcmQgaW5wdXQiCiBtc2dzdHIgImhp4buDbiB0aOG7iyBjw6FjIHRow7RuZyB0aW4gduG7gSDEkeG7kWkgdMaw4bujbmcgZmVkICB04burIMSR4bqndSB2w6BvIHRpw6p1IGNodeG6qW4iCiAKLSM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NTgKKyM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NTkKIG1zZ2lkICJmb2xsb3cgaW4tdHJlZSBzeW1saW5rcyAodXNlZCB3aXRoIC0tYmF0Y2ggb3IgLS1iYXRjaC1jaGVjaykiCiBtc2dzdHIgInRoZW8gbGnDqm4ga+G6v3QgbeG7gW0gdHJvbmctY8OieSAoxJHGsOG7o2MgZMO5bmcgduG7m2kgLS1iYXRjaCBoYXkgLS1iYXRjaC1jaGVjaykiCiAKLSM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NjAKKyM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NjEKIG1zZ2lkICJzaG93IGFsbCBvYmplY3RzIHdpdGggLS1iYXRjaCBvciAtLWJhdGNoLWNoZWNrIgogbXNnc3RyICJoaeG7g24gdGjhu4sgbeG7jWkgxJHhu5FpIHTGsOG7o25nIHbhu5tpIC0tYmF0Y2ggaGF5IC0tYmF0Y2gtY2hlY2siCiAKLSM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NjIKKyM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NjMKIG1zZ2lkICJkbyBub3Qgb3JkZXIgLS1iYXRjaC1hbGwtb2JqZWN0cyBvdXRwdXQiCiBtc2dzdHIgIsSR4burbmcgc+G6r3AgeOG6v3AgxJHhuqd1IHJhIC0tYmF0Y2gtYWxsLW9iamVjdHMiCiAKQEAgLTEwMDU3LDggKzEwMTAwLDggQEAKIG1zZ2lkICJ0ZXJtaW5hdGUgaW5wdXQgYW5kIG91dHB1dCByZWNvcmRzIGJ5IGEgTlVMIGNoYXJhY3RlciIKIG1zZ3N0ciAiY2jhuqVtIGThu6l0IGPDoWMgYuG6o24gZ2hpIHbDoG8gdsOgIHJhIGLhurFuZyBrw70gdOG7sSBOVUxMIgogCi0jOiBidWlsdGluL2NoZWNrLWlnbm9yZS5jOjIxIGJ1aWx0aW4vY2hlY2tvdXQuYzoxNDMzIGJ1aWx0aW4vZ2MuYzo1MzgKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo1MDcKKyM6IGJ1aWx0aW4vY2hlY2staWdub3JlLmM6MjEgYnVpbHRpbi9jaGVja291dC5jOjE0MzMgYnVpbHRpbi9nYy5jOjUzNworIzogYnVpbHRpbi93b3JrdHJlZS5jOjUwNgogbXNnaWQgInN1cHByZXNzIHByb2dyZXNzIHJlcG9ydGluZyIKIG1zZ3N0ciAiY2jhurduIGPDoWMgYsOhbyBjw6FvIHRp4bq/biB0csOsbmggaG/huqF0IMSR4buZbmciCiAKQEAgLTEwMTUxLDcgKzEwMTk0LDcgQEAKICM6IGJ1aWx0aW4vY2hlY2tvdXQtaW5kZXguYzoxNzggYnVpbHRpbi9jb2x1bW4uYzozMQogIzogYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjEzNzMgYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjEzNzYKICM6IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxMzg0IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxODU3Ci0jOiBidWlsdGluL3dvcmt0cmVlLmM6NjgwCisjOiBidWlsdGluL3dvcmt0cmVlLmM6Njc5CiBtc2dpZCAic3RyaW5nIgogbXNnc3RyICJjaHXhu5dpIgogCkBAIC0xMDE3OSw5NiArMTAyMjIsOTYgQEAKIG1zZ2lkICJnaXQgcmVzdG9yZSBbPG9wdGlvbnM+XSBbLS1zb3VyY2U9PGJyYW5jaD5dIDxmaWxlPi4uLiIKIG1zZ3N0ciAiZ2l0IHJlc3RvcmUgWzxjw6FjIHTDuXkgY2jhu41uPl0gWy0tc291cmNlPTxuaMOhbmg+XSA8dOG6rXAgdGluPi4uLiIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjE3MiBidWlsdGluL2NoZWNrb3V0LmM6MjExCisjOiBidWlsdGluL2NoZWNrb3V0LmM6MTczIGJ1aWx0aW4vY2hlY2tvdXQuYzoyMTIKICMsIGMtZm9ybWF0CiBtc2dpZCAicGF0aCAnJXMnIGRvZXMgbm90IGhhdmUgb3VyIHZlcnNpb24iCiBtc2dzdHIgIsSRxrDhu51uZyBk4bqrbiDigJwlc+KAnSBraMO0bmcgY8OzIGPDoWMgcGhpw6puIGLhuqNuIGPhu6dhIGNow7puZyB0YSIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjE3NCBidWlsdGluL2NoZWNrb3V0LmM6MjEzCisjOiBidWlsdGluL2NoZWNrb3V0LmM6MTc1IGJ1aWx0aW4vY2hlY2tvdXQuYzoyMTQKICMsIGMtZm9ybWF0CiBtc2dpZCAicGF0aCAnJXMnIGRvZXMgbm90IGhhdmUgdGhlaXIgdmVyc2lvbiIKIG1zZ3N0ciAixJHGsOG7nW5nIGThuqtuIOKAnCVz4oCdIGtow7RuZyBjw7MgY8OhYyBwaGnDqm4gYuG6o24gY+G7p2EgY2jDum5nIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6MTkwCisjOiBidWlsdGluL2NoZWNrb3V0LmM6MTkxCiAjLCBjLWZvcm1hdAogbXNnaWQgInBhdGggJyVzJyBkb2VzIG5vdCBoYXZlIGFsbCBuZWNlc3NhcnkgdmVyc2lvbnMiCiBtc2dzdHIgIsSRxrDhu51uZyBk4bqrbiDigJwlc+KAnSBraMO0bmcgY8OzIHThuqV0IGPhuqMgY8OhYyBwaGnDqm4gYuG6o24gY+G6p24gdGhp4bq/dCIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjI0MAorIzogYnVpbHRpbi9jaGVja291dC5jOjI0MQogIywgYy1mb3JtYXQKIG1zZ2lkICJwYXRoICclcycgZG9lcyBub3QgaGF2ZSBuZWNlc3NhcnkgdmVyc2lvbnMiCiBtc2dzdHIgIsSRxrDhu51uZyBk4bqrbiDigJwlc+KAnSBraMO0bmcgY8OzIGPDoWMgcGhpw6puIGLhuqNuIGPhuqduIHRoaeG6v3QiCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoyNTgKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoyNTkKICMsIGMtZm9ybWF0CiBtc2dpZCAicGF0aCAnJXMnOiBjYW5ub3QgbWVyZ2UiCiBtc2dzdHIgIsSRxrDhu51uZyBk4bqrbiDigJwlc+KAnToga2jDtG5nIHRo4buDIGjDsmEgdHLhu5luIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6Mjc0CisjOiBidWlsdGluL2NoZWNrb3V0LmM6Mjc1CiAjLCBjLWZvcm1hdAogbXNnaWQgIlVuYWJsZSB0byBhZGQgbWVyZ2UgcmVzdWx0IGZvciAnJXMnIgogbXNnc3RyICJLaMO0bmcgdGjhu4MgdGjDqm0ga+G6v3QgcXXhuqMgaMOyYSB0cuG7mW4gY2hvIOKAnCVz4oCdIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6Mzc0CisjOiBidWlsdGluL2NoZWNrb3V0LmM6Mzc1CiAjLCBjLWZvcm1hdAogbXNnaWQgIlJlY3JlYXRlZCAlZCBtZXJnZSBjb25mbGljdCIKIG1zZ2lkX3BsdXJhbCAiUmVjcmVhdGVkICVkIG1lcmdlIGNvbmZsaWN0cyIKIG1zZ3N0clswXSAixJDDoyB04bqhbyBs4bqhaSAlZCB4dW5nIMSR4buZdCBow7JhIHRy4buZbiIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjM3OQorIzogYnVpbHRpbi9jaGVja291dC5jOjM4MAogIywgYy1mb3JtYXQKIG1zZ2lkICJVcGRhdGVkICVkIHBhdGggZnJvbSAlcyIKIG1zZ2lkX3BsdXJhbCAiVXBkYXRlZCAlZCBwYXRocyBmcm9tICVzIgogbXNnc3RyWzBdICLEkMOjIGPhuq1wIG5o4bqtdCDEkcaw4budbmcgZOG6q24gJWQgdOG7qyAlcyIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjM4NgorIzogYnVpbHRpbi9jaGVja291dC5jOjM4NwogIywgYy1mb3JtYXQKIG1zZ2lkICJVcGRhdGVkICVkIHBhdGggZnJvbSB0aGUgaW5kZXgiCiBtc2dpZF9wbHVyYWwgIlVwZGF0ZWQgJWQgcGF0aHMgZnJvbSB0aGUgaW5kZXgiCiBtc2dzdHJbMF0gIsSQw6MgY+G6rXAgbmjhuq10IMSRxrDhu51uZyBk4bqrbiAlZCB04burIG3hu6VjIGzhu6VjIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6NDA5IGJ1aWx0aW4vY2hlY2tvdXQuYzo0MTIgYnVpbHRpbi9jaGVja291dC5jOjQxNQotIzogYnVpbHRpbi9jaGVja291dC5jOjQxOQorIzogYnVpbHRpbi9jaGVja291dC5jOjQxMCBidWlsdGluL2NoZWNrb3V0LmM6NDEzIGJ1aWx0aW4vY2hlY2tvdXQuYzo0MTYKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo0MjAKICMsIGMtZm9ybWF0CiBtc2dpZCAiJyVzJyBjYW5ub3QgYmUgdXNlZCB3aXRoIHVwZGF0aW5nIHBhdGhzIgogbXNnc3RyICJraMO0bmcgxJHGsOG7o2MgZMO5bmcg4oCcJXPigJ0gduG7m2kgY8OhYyDEkcaw4budbmcgZOG6q24gY+G6rXAgbmjhuq10IgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6NDIyIGJ1aWx0aW4vY2hlY2tvdXQuYzo0MjUKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo0MjMgYnVpbHRpbi9jaGVja291dC5jOjQyNgogIywgYy1mb3JtYXQKIG1zZ2lkICInJXMnIGNhbm5vdCBiZSB1c2VkIHdpdGggJXMiCiBtc2dzdHIgImtow7RuZyDEkcaw4bujYyBkw7luZyDigJwlc+KAnSB24bubaSAlcyIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjQyOQorIzogYnVpbHRpbi9jaGVja291dC5jOjQzMAogIywgYy1mb3JtYXQKIG1zZ2lkICJDYW5ub3QgdXBkYXRlIHBhdGhzIGFuZCBzd2l0Y2ggdG8gYnJhbmNoICclcycgYXQgdGhlIHNhbWUgdGltZS4iCiBtc2dzdHIgIiIKICJLaMO0bmcgdGjhu4MgY+G6rXAgbmjhuq10IGPDoWMgxJHGsOG7nW5nIGThuqtuIHbDoCBjaHV54buDbiDEkeG6v24gbmjDoW5oIOKAnCVz4oCdIGPDuW5nIG3hu5l0IGzDumMuIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6NDMzCisjOiBidWlsdGluL2NoZWNrb3V0LmM6NDM0CiAjLCBjLWZvcm1hdAogbXNnaWQgIm5laXRoZXIgJyVzJyBvciAnJXMnIGlzIHNwZWNpZmllZCIKIG1zZ3N0ciAia2jDtG5nIGNo4buJIMSR4buLbmggJyVzJyBraMO0bmcgJyVzJyIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjQzNworIzogYnVpbHRpbi9jaGVja291dC5jOjQzOAogIywgYy1mb3JtYXQKIG1zZ2lkICInJXMnIG11c3QgYmUgdXNlZCB3aGVuICclcycgaXMgbm90IHNwZWNpZmllZCIKIG1zZ3N0ciAicGjhuqNpIGPDsyDigJwlc+KAnSBraGkga2jDtG5nIGNo4buJIMSR4buLbmgg4oCcJXPigJ0iCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo0NDIgYnVpbHRpbi9jaGVja291dC5jOjQ0NworIzogYnVpbHRpbi9jaGVja291dC5jOjQ0MyBidWlsdGluL2NoZWNrb3V0LmM6NDQ4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiclcycgb3IgJyVzJyBjYW5ub3QgYmUgdXNlZCB3aXRoICVzIgogbXNnc3RyICInJXMnIGhheSAnJXMnIGtow7RuZyB0aOG7gyDEkcaw4bujYyBz4butIGThu6VuZyB24bubaSAlcyIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjUwNiBidWlsdGluL2NoZWNrb3V0LmM6NTEzCisjOiBidWlsdGluL2NoZWNrb3V0LmM6NTA3IGJ1aWx0aW4vY2hlY2tvdXQuYzo1MTQKICMsIGMtZm9ybWF0CiBtc2dpZCAicGF0aCAnJXMnIGlzIHVubWVyZ2VkIgogbXNnc3RyICLEkcaw4budbmcgZOG6q24g4oCcJXPigJ0ga2jDtG5nIMSRxrDhu6NjIGjDsmEgdHLhu5luIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6Njc5CisjOiBidWlsdGluL2NoZWNrb3V0LmM6NjgwCiBtc2dpZCAieW91IG5lZWQgdG8gcmVzb2x2ZSB5b3VyIGN1cnJlbnQgaW5kZXggZmlyc3QiCiBtc2dzdHIgImLhuqFuIGPhuqduIHBo4bqjaSBnaeG6o2kgcXV54bq/dCBi4bqjbmcgbeG7pWMgbOG7pWMgaGnhu4duIHThuqFpIGPhu6dhIGLhuqFuIHRyxrDhu5tjIMSRw6MiCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo3MjkKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo3MzAKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogImNhbm5vdCBjb250aW51ZSB3aXRoIHN0YWdlZCBjaGFuZ2VzIGluIHRoZSBmb2xsb3dpbmcgZmlsZXM6XG4iCkBAIC0xMDI3OCwxMiArMTAzMjEsNiBAQAogInNhdTpcbiIKICIlcyIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjczNgotIywgYy1mb3JtYXQKLW1zZ2lkICJzdGFnZWQgY2hhbmdlcyBpbiB0aGUgZm9sbG93aW5nIGZpbGVzIG1heSBiZSBsb3N0OiAlcyIKLW1zZ3N0ciAiIgotImPDoWMgdGhheSDEkeG7lWkgxJHDoyDEkcawYSBsw6puIGLhu4cgcGjDs25nIHRyb25nIGPDoWMgdOG6rXAgdGluIHNhdSDEkcOieSBjw7MgdGjhu4MgYuG7iyBt4bqldDogJXMiCi0KICM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo4MzMKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ2FuIG5vdCBkbyByZWZsb2cgZm9yICclcyc6ICVzXG4iCkBAIC0xMDI5Myw3ICsxMDMzMCw3IEBACiBtc2dpZCAiSEVBRCBpcyBub3cgYXQiCiBtc2dzdHIgIkhFQUQgaGnhu4duIGdp4budIHThuqFpIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6ODc5IGJ1aWx0aW4vY2xvbmUuYzo3MTQKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo4NzkgYnVpbHRpbi9jbG9uZS5jOjcxMwogbXNnaWQgInVuYWJsZSB0byB1cGRhdGUgSEVBRCIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIGPhuq1wIG5o4bqtdCBIRUFEIgogCkBAIC0xMDM5Nyw3ICsxMDQzNCw3IEBACiAi4oCcJXPigJ0ga2jDtG5nIHRo4buDIGzDoCBj4bqjIHThuq1wIHRpbiBu4buZaSBi4buZIHbDoCBt4buZdCBuaMOhbmggdGhlbyBkw7VpLlxuIgogIlZ1aSBsb25nIGTDuW5nIC0tICh2w6AgdMO5eSBjaOG7jW4gdGjDqm0gLS1uby1ndWVzcykgxJHhu4MgdHLDoW5oIGzhuqtuIGzhu5luIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6MTI0MyBidWlsdGluL3dvcmt0cmVlLmM6MjkxIGJ1aWx0aW4vd29ya3RyZWUuYzo0NTYKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxMjQzIGJ1aWx0aW4vd29ya3RyZWUuYzoyOTAgYnVpbHRpbi93b3JrdHJlZS5jOjQ1NQogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIHJlZmVyZW5jZTogJXMiCiBtc2dzdHIgInRoYW0gY2hp4bq/dSBraMO0bmcgaOG7o3AgbOG7hzogJXMiCkBAIC0xMDUwMiw5ICsxMDUzOSw5IEBACiBtc2dpZCAibWlzc2luZyBicmFuY2ggb3IgY29tbWl0IGFyZ3VtZW50IgogbXNnc3RyICJ0aGnhur91IHRoYW0gc+G7kSBsw6AgbmjDoW5oIGhv4bq3YyBs4bqnbiBjaHV54buDbiBnaWFvIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6MTQzNyBidWlsdGluL2Nsb25lLmM6OTEgYnVpbHRpbi9mZXRjaC5jOjE1MQotIzogYnVpbHRpbi9tZXJnZS5jOjI4NSBidWlsdGluL3B1bGwuYzoxMzcgYnVpbHRpbi9wdXNoLmM6NTc1Ci0jOiBidWlsdGluL3NlbmQtcGFjay5jOjE3NAorIzogYnVpbHRpbi9jaGVja291dC5jOjE0MzcgYnVpbHRpbi9jbG9uZS5jOjkwIGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6NTkKKyM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTgwIGJ1aWx0aW4vZmV0Y2guYzoxNjYgYnVpbHRpbi9tZXJnZS5jOjI4NQorIzogYnVpbHRpbi9wdWxsLmM6MTM4IGJ1aWx0aW4vcHVzaC5jOjU2MiBidWlsdGluL3NlbmQtcGFjay5jOjE3NAogbXNnaWQgImZvcmNlIHByb2dyZXNzIHJlcG9ydGluZyIKIG1zZ3N0ciAiw6lwIGJ14buZYyBiw6FvIGPDoW8gdGnhur9uIHRyaeG7g24gY8O0bmcgdmnhu4djIgogCkBAIC0xMDUxMiw3ICsxMDU0OSw3IEBACiBtc2dpZCAicGVyZm9ybSBhIDMtd2F5IG1lcmdlIHdpdGggdGhlIG5ldyBicmFuY2giCiBtc2dzdHIgInRo4buxYyBoaeG7h24gaMOyYSB0cuG7mW4ga2nhu4N1IDMtd2F5IHbhu5tpIG5ow6FuaCBt4bubaSIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjE0MzkgYnVpbHRpbi9sb2cuYzoxNjE3IHBhcnNlLW9wdGlvbnMuaDozMTgKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNDM5IGJ1aWx0aW4vbG9nLmM6MTYxOCBwYXJzZS1vcHRpb25zLmg6MzE4CiBtc2dpZCAic3R5bGUiCiBtc2dzdHIgImtp4buDdSIKIApAQCAtMTA1MjAsNyArMTA1NTcsNyBAQAogbXNnaWQgImNvbmZsaWN0IHN0eWxlIChtZXJnZSBvciBkaWZmMykiCiBtc2dzdHIgInh1bmcgxJHhu5l0IGtp4buDdSAoaMOyYSB0cuG7mW4gaG/hurdjIGRpZmYzKSIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjE0NTIgYnVpbHRpbi93b3JrdHJlZS5jOjUwNAorIzogYnVpbHRpbi9jaGVja291dC5jOjE0NTIgYnVpbHRpbi93b3JrdHJlZS5jOjUwMwogbXNnaWQgImRldGFjaCBIRUFEIGF0IG5hbWVkIGNvbW1pdCIKIG1zZ3N0ciAicuG7nWkgYuG7jyBIRUFEIHThuqFpIGzhuqduIGNodXnhu4NuIGdpYW8gdGhlbyB0w6puIgogCkBAIC0xMDU2MCw3ICsxMDU5Nyw3IEBACiAKICM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNDgyCiBtc2dpZCAiZG8gbm90IGxpbWl0IHBhdGhzcGVjcyB0byBzcGFyc2UgZW50cmllcyBvbmx5IgotbXNnc3RyICJraMO0bmcgZ2nhu5tpIGjhuqFuIMSR4bq3YyB04bqjIMSRxrDhu51uZyBk4bqrbiB0aMOgbmggY2jhu4kgY8OhYyBt4bulYyB0aMawYSB0aOG7m3QiCittc2dzdHIgImtow7RuZyBnaeG7m2kgaOG6oW4gxJHhurdjIHThuqMgxJHGsOG7nW5nIGThuqtuIHRow6BuaCBjaOG7iSBjw6FjIG3hu6VjIHLhuqNpIHLDoWMiCiAKICM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNTMzCiBtc2dpZCAiLWIsIC1CIGFuZCAtLW9ycGhhbiBhcmUgbXV0dWFsbHkgZXhjbHVzaXZlIgpAQCAtMTA2NDEsOSArMTA2NzgsOSBAQAogImNoxrBhIHLDtSByw6BuZywgdsOtIGThu6UgbcOheSBjaOG7pyDigJxvcmlnaW7igJ0sIGPDom4gbmjhuq9jIGPDoGkgxJHhurd0XG4iCiAiY2hlY2tvdXQuZGVmYXVsdFJlbW90ZT1vcmlnaW4gdHJvbmcgY+G6pXUgaMOsbmggY+G7p2EgYuG6oW4uIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6MTY5MSBidWlsdGluL2NoZWNrb3V0LmM6MTY5MyBidWlsdGluL2NoZWNrb3V0LmM6MTczMwotIzogYnVpbHRpbi9jaGVja291dC5jOjE3MzUgYnVpbHRpbi9jbG9uZS5jOjEyMSBidWlsdGluL3JlbW90ZS5jOjE2OQotIzogYnVpbHRpbi9yZW1vdGUuYzoxNzEgYnVpbHRpbi93b3JrdHJlZS5jOjUwMCBidWlsdGluL3dvcmt0cmVlLmM6NTAyCisjOiBidWlsdGluL2NoZWNrb3V0LmM6MTY5MSBidWlsdGluL2NoZWNrb3V0LmM6MTY5MyBidWlsdGluL2NoZWNrb3V0LmM6MTc0MgorIzogYnVpbHRpbi9jaGVja291dC5jOjE3NDQgYnVpbHRpbi9jbG9uZS5jOjEyMCBidWlsdGluL3JlbW90ZS5jOjE2OQorIzogYnVpbHRpbi9yZW1vdGUuYzoxNzEgYnVpbHRpbi93b3JrdHJlZS5jOjQ5OSBidWlsdGluL3dvcmt0cmVlLmM6NTAxCiBtc2dpZCAiYnJhbmNoIgogbXNnc3RyICJuaMOhbmgiCiAKQEAgLTEwNjY3LDM5ICsxMDcwNCwzOSBAQAogbXNnaWQgInVzZSBvdmVybGF5IG1vZGUgKGRlZmF1bHQpIgogbXNnc3RyICJkw7luZyBjaOG6vyDEkeG7mSBjaGUgcGjhu6cgKG3hurdjIMSR4buLbmgpIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6MTczNAorIzogYnVpbHRpbi9jaGVja291dC5jOjE3NDMKIG1zZ2lkICJjcmVhdGUgYW5kIHN3aXRjaCB0byBhIG5ldyBicmFuY2giCiBtc2dzdHIgInThuqFvIHbDoCBjaHV54buDbiDEkeG6v24gbeG7mXQgbmjDoW5oIG3hu5tpIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6MTczNgorIzogYnVpbHRpbi9jaGVja291dC5jOjE3NDUKIG1zZ2lkICJjcmVhdGUvcmVzZXQgYW5kIHN3aXRjaCB0byBhIGJyYW5jaCIKIG1zZ3N0ciAidOG6oW8vxJHhurd0X2zhuqFpIHbDoCBjaHV54buDbiDEkeG6v24gbeG7mXQgbmjDoW5oIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6MTczOAorIzogYnVpbHRpbi9jaGVja291dC5jOjE3NDcKIG1zZ2lkICJzZWNvbmQgZ3Vlc3MgJ2dpdCBzd2l0Y2ggPG5vLXN1Y2gtYnJhbmNoPiciCiBtc2dzdHIgImfhu6NpIMO9IHRo4bupIGhhaSBcImdpdCBjaGVja291dCA8a2jDtG5nLW5ow6FuaC1uw6BvLW5oxrAtduG6rXk+XCIiCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzQwCisjOiBidWlsdGluL2NoZWNrb3V0LmM6MTc0OQogbXNnaWQgInRocm93IGF3YXkgbG9jYWwgbW9kaWZpY2F0aW9ucyIKIG1zZ3N0ciAiduG7qXQgYuG7jyBjw6FjIHPhu61hIMSR4buVaSDEkeG7i2EgcGjGsMahbmciCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzcyCisjOiBidWlsdGluL2NoZWNrb3V0LmM6MTc4MQogbXNnaWQgIndoaWNoIHRyZWUtaXNoIHRvIGNoZWNrb3V0IGZyb20iCiBtc2dzdHIgImzhuqV5IHJhIHThu6sgdHJlZS1pc2ggbsOgbyIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjE3NzQKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzgzCiBtc2dpZCAicmVzdG9yZSB0aGUgaW5kZXgiCiBtc2dzdHIgInBo4bulYyBo4buTaSBi4bqjbmcgbeG7pWMgbOG7pWMiCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzc2CisjOiBidWlsdGluL2NoZWNrb3V0LmM6MTc4NQogbXNnaWQgInJlc3RvcmUgdGhlIHdvcmtpbmcgdHJlZSAoZGVmYXVsdCkiCiBtc2dzdHIgInBo4bulYyBo4buTaSBjw6J5IGzDoG0gdmnhu4djICht4bq3YyDEkeG7i25oKSIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjE3NzgKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzg3CiBtc2dpZCAiaWdub3JlIHVubWVyZ2VkIGVudHJpZXMiCiBtc2dzdHIgImLhu48gcXVhIG5o4buvbmcgdGjhu6kgY2jGsGEgaMOyYSB0cuG7mW46ICVzIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6MTc3OQorIzogYnVpbHRpbi9jaGVja291dC5jOjE3ODgKIG1zZ2lkICJ1c2Ugb3ZlcmxheSBtb2RlIgogbXNnc3RyICJkw7luZyBjaOG6vyDEkeG7mSBjaGUgcGjhu6ciCiAKQEAgLTEwNzQwLDcgKzEwNzc3LDcgQEAKIG1zZ2lkICJjb3VsZCBub3QgbHN0YXQgJXNcbiIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIGzhuqV5IHRow7RuZyB0aW4gdGjhu5FuZyBrw6ogxJHhuqd5IMSR4bunIGPhu6dhICVzXG4iCiAKLSM6IGJ1aWx0aW4vY2xlYW4uYzozMDAgZ2l0LWFkZC0taW50ZXJhY3RpdmUucGVybDo1OTMKKyM6IGJ1aWx0aW4vY2xlYW4uYzozMDEgZ2l0LWFkZC0taW50ZXJhY3RpdmUucGVybDo1OTMKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlByb21wdCBoZWxwOlxuIgpAQCAtMTA3NTMsNyArMTA3OTAsNyBAQAogImZvbyAgICAgICAgLSBjaOG7jW4gbeG7pWMgdHLDqm4gY8ahIHPhu58gdGnhu4FuIHThu5EgZHV5IG5o4bqldFxuIgogIiAgICAgICAgICAgLSAoxJHhu4MgdHLhu5FuZykga2jDtG5nIGNo4buNbiBnw6wgY+G6o1xuIgogCi0jOiBidWlsdGluL2NsZWFuLmM6MzA0IGdpdC1hZGQtLWludGVyYWN0aXZlLnBlcmw6NjAyCisjOiBidWlsdGluL2NsZWFuLmM6MzA1IGdpdC1hZGQtLWludGVyYWN0aXZlLnBlcmw6NjAyCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJQcm9tcHQgaGVscDpcbiIKQEAgLTEwNzc0LDM4ICsxMDgxMSwzOCBAQAogIiogICAgICAgICAgLSBjaOG7jW4gdOG6pXRcbiIKICIgICAgICAgICAgIC0gKMSR4buDIHRy4buRbmcpIGvhur90IHRow7pjIHZp4buHYyBjaOG7jW5cbiIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjUyMCBnaXQtYWRkLS1pbnRlcmFjdGl2ZS5wZXJsOjU2OAorIzogYnVpbHRpbi9jbGVhbi5jOjUyMSBnaXQtYWRkLS1pbnRlcmFjdGl2ZS5wZXJsOjU2OAogIzogZ2l0LWFkZC0taW50ZXJhY3RpdmUucGVybDo1NzMKICMsIGMtZm9ybWF0LCBwZXJsLWZvcm1hdAogbXNnaWQgIkh1aCAoJXMpP1xuIgogbXNnc3RyICJI4bqjICglcyk/XG4iCiAKLSM6IGJ1aWx0aW4vY2xlYW4uYzo2NjIKKyM6IGJ1aWx0aW4vY2xlYW4uYzo2NjMKICMsIGMtZm9ybWF0CiBtc2dpZCAiSW5wdXQgaWdub3JlIHBhdHRlcm5zPj4gIgogbXNnc3RyICJN4bqrdSDEkeG7gyBs4buNYyBjw6FjIHThuq1wIHRpbiDEkeG6p3UgdsOgbyBj4bqnbiBs4budIMSRaT4+ICIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjY5OQorIzogYnVpbHRpbi9jbGVhbi5jOjcwMAogIywgYy1mb3JtYXQKIG1zZ2lkICJXQVJOSU5HOiBDYW5ub3QgZmluZCBpdGVtcyBtYXRjaGVkIGJ5OiAlcyIKIG1zZ3N0ciAiQ+G6ok5IIELDgU86IEtow7RuZyB0w6xtIHRo4bqleSBjw6FjIG3hu6VjIMSRxrDhu6NjIGto4bubcCBi4bufaTogJXMiCiAKLSM6IGJ1aWx0aW4vY2xlYW4uYzo3MjAKKyM6IGJ1aWx0aW4vY2xlYW4uYzo3MjEKIG1zZ2lkICJTZWxlY3QgaXRlbXMgdG8gZGVsZXRlIgogbXNnc3RyICJDaOG7jW4gbeG7pWMgbXXhu5FuIHjDs2EiCiAKICMuIFRSQU5TTEFUT1JTOiBNYWtlIHN1cmUgdG8ga2VlcCBbeS9OXSBhcyBpcwotIzogYnVpbHRpbi9jbGVhbi5jOjc2MQorIzogYnVpbHRpbi9jbGVhbi5jOjc2MgogIywgYy1mb3JtYXQKIG1zZ2lkICJSZW1vdmUgJXMgW3kvTl0/ICIKIG1zZ3N0ciAiWMOzYSBi4buPIOKAnCVz4oCdIFt5L05dPyAiCiAKLSM6IGJ1aWx0aW4vY2xlYW4uYzo3ODYgZ2l0LWFkZC0taW50ZXJhY3RpdmUucGVybDoxNzYzCisjOiBidWlsdGluL2NsZWFuLmM6Nzg3IGdpdC1hZGQtLWludGVyYWN0aXZlLnBlcmw6MTc2MwogIywgYy1mb3JtYXQKIG1zZ2lkICJCeWUuXG4iCiBtc2dzdHIgIlThuqFtIGJp4buHdC5cbiIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjc5NAorIzogYnVpbHRpbi9jbGVhbi5jOjc5NQogbXNnaWQgIiIKICJjbGVhbiAgICAgICAgICAgICAgIC0gc3RhcnQgY2xlYW5pbmdcbiIKICJmaWx0ZXIgYnkgcGF0dGVybiAgIC0gZXhjbHVkZSBpdGVtcyBmcm9tIGRlbGV0aW9uXG4iCkBAIC0xMDgyMyw2MyArMTA4NjAsNjMgQEAKICJoZWxwICAgICAgICAgICAgICAgIC0gaGnhu4NuIHRo4buLIGNow61uaCB0cuG7oyBnacO6cCBuw6B5XG4iCiAiPyAgICAgICAgICAgICAgICAgICAtIHRy4bujIGdpw7pwIGTDoG5oIGNobyBjaOG7jW4gYuG6sW5nIGPDoWNoIG5o4bqvYyIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjgyMSBnaXQtYWRkLS1pbnRlcmFjdGl2ZS5wZXJsOjE4NDkKKyM6IGJ1aWx0aW4vY2xlYW4uYzo4MjIgZ2l0LWFkZC0taW50ZXJhY3RpdmUucGVybDoxODQ5CiBtc2dpZCAiKioqIENvbW1hbmRzICoqKiIKIG1zZ3N0ciAiKioqIEzhu4duaCAqKioiCiAKLSM6IGJ1aWx0aW4vY2xlYW4uYzo4MjIgZ2l0LWFkZC0taW50ZXJhY3RpdmUucGVybDoxODQ2CisjOiBidWlsdGluL2NsZWFuLmM6ODIzIGdpdC1hZGQtLWludGVyYWN0aXZlLnBlcmw6MTg0NgogbXNnaWQgIldoYXQgbm93IgogbXNnc3RyICJHaeG7nSB0aMOsIHNhbyIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjgzMAorIzogYnVpbHRpbi9jbGVhbi5jOjgzMQogbXNnaWQgIldvdWxkIHJlbW92ZSB0aGUgZm9sbG93aW5nIGl0ZW06IgogbXNnaWRfcGx1cmFsICJXb3VsZCByZW1vdmUgdGhlIGZvbGxvd2luZyBpdGVtczoiCiBtc2dzdHJbMF0gIkPDsyBtdeG7kW4gZ+G7oSBi4buPIChjw6FjKSBt4bulYyBzYXUgxJHDonkga2jDtG5nOiIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjg0NgorIzogYnVpbHRpbi9jbGVhbi5jOjg0NwogbXNnaWQgIk5vIG1vcmUgZmlsZXMgdG8gY2xlYW4sIGV4aXRpbmcuIgogbXNnc3RyICJLaMO0bmcgY8OybiB04bqtcC10aW4gbsOgbyDEkeG7gyBk4buNbiBk4bq5cCwgxJFhbmcgdGhvw6F0IHJhLiIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjkwOAorIzogYnVpbHRpbi9jbGVhbi5jOjkwOQogbXNnaWQgImRvIG5vdCBwcmludCBuYW1lcyBvZiBmaWxlcyByZW1vdmVkIgogbXNnc3RyICJraMO0bmcgaGnhu4NuIHRo4buLIHTDqm4gY+G7p2EgY8OhYyB04bqtcCB0aW4gxJHDoyBn4buhIGLhu48iCiAKLSM6IGJ1aWx0aW4vY2xlYW4uYzo5MTAKKyM6IGJ1aWx0aW4vY2xlYW4uYzo5MTEKIG1zZ2lkICJmb3JjZSIKIG1zZ3N0ciAiw6lwIGJ14buZYyIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjkxMQorIzogYnVpbHRpbi9jbGVhbi5jOjkxMgogbXNnaWQgImludGVyYWN0aXZlIGNsZWFuaW5nIgogbXNnc3RyICJk4buNbiBi4bqxbmcga2nhu4N1IHTGsMahbmcgdMOhYyIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjkxMworIzogYnVpbHRpbi9jbGVhbi5jOjkxNAogbXNnaWQgInJlbW92ZSB3aG9sZSBkaXJlY3RvcmllcyIKIG1zZ3N0ciAiZ+G7oSBi4buPIHRvw6BuIGLhu5kgdGjGsCBt4bulYyIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjkxNCBidWlsdGluL2Rlc2NyaWJlLmM6NTQ2IGJ1aWx0aW4vZGVzY3JpYmUuYzo1NDgKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg5OSBidWlsdGluL2xvZy5jOjE3NiBidWlsdGluL2xvZy5jOjE3OAotIzogYnVpbHRpbi9scy1maWxlcy5jOjU1NyBidWlsdGluL25hbWUtcmV2LmM6NDEzIGJ1aWx0aW4vbmFtZS1yZXYuYzo0MTUKKyM6IGJ1aWx0aW4vY2xlYW4uYzo5MTUgYnVpbHRpbi9kZXNjcmliZS5jOjU0OCBidWlsdGluL2Rlc2NyaWJlLmM6NTUwCisjOiBidWlsdGluL2dyZXAuYzo5MDEgYnVpbHRpbi9sb2cuYzoxNzYgYnVpbHRpbi9sb2cuYzoxNzgKKyM6IGJ1aWx0aW4vbHMtZmlsZXMuYzo1NTcgYnVpbHRpbi9uYW1lLXJldi5jOjQxNyBidWlsdGluL25hbWUtcmV2LmM6NDE5CiAjOiBidWlsdGluL3Nob3ctcmVmLmM6MTc5CiBtc2dpZCAicGF0dGVybiIKIG1zZ3N0ciAibeG6q3UiCiAKLSM6IGJ1aWx0aW4vY2xlYW4uYzo5MTUKKyM6IGJ1aWx0aW4vY2xlYW4uYzo5MTYKIG1zZ2lkICJhZGQgPHBhdHRlcm4+IHRvIGlnbm9yZSBydWxlcyIKIG1zZ3N0ciAidGjDqm0gPG3huqt1PiB2w6BvIHRyb25nIHF1aSB04bqvYyBi4buPIHF1YSIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjkxNgorIzogYnVpbHRpbi9jbGVhbi5jOjkxNwogbXNnaWQgInJlbW92ZSBpZ25vcmVkIGZpbGVzLCB0b28iCiBtc2dzdHIgIsSR4buTbmcgdGjhu51pIGfhu6EgYuG7jyBj4bqjIGPDoWMgdOG6rXAgdGluIGLhu4sgYuG7jyBxdWEiCiAKLSM6IGJ1aWx0aW4vY2xlYW4uYzo5MTgKKyM6IGJ1aWx0aW4vY2xlYW4uYzo5MTkKIG1zZ2lkICJyZW1vdmUgb25seSBpZ25vcmVkIGZpbGVzIgogbXNnc3RyICJjaOG7iSBn4buhIGLhu48gbmjhu69uZyB04bqtcCB0aW4gYuG7iyBi4buPIHF1YSIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjkzNgorIzogYnVpbHRpbi9jbGVhbi5jOjkzNwogbXNnaWQgIi14IGFuZCAtWCBjYW5ub3QgYmUgdXNlZCB0b2dldGhlciIKIG1zZ3N0ciAiLXggdsOgIC1YIGtow7RuZyB0aOG7gyBkw7luZyBjw7luZyBuaGF1IgogCi0jOiBidWlsdGluL2NsZWFuLmM6OTQwCisjOiBidWlsdGluL2NsZWFuLmM6OTQxCiBtc2dpZCAiIgogImNsZWFuLnJlcXVpcmVGb3JjZSBzZXQgdG8gdHJ1ZSBhbmQgbmVpdGhlciAtaSwgLW4sIG5vciAtZiBnaXZlbjsgcmVmdXNpbmcgdG8gIgogImNsZWFuIgpAQCAtMTA4ODcsNyArMTA5MjQsNyBAQAogImNsZWFuLnJlcXVpcmVGb3JjZSDEkcaw4bujYyDEkeG6t3QgdGjDoG5oIHRydWUgdsOgIGtow7RuZyDEkcawYSByYSB0w7l5IGNo4buNbiAtaSwgLW4gbcOgICIKICJjxaluZyBraMO0bmcgLWY7IHThu6sgY2jhu5FpIGzhu4duaCBk4buNbiBk4bq5cCAoY2xlYW4pIgogCi0jOiBidWlsdGluL2NsZWFuLmM6OTQzCisjOiBidWlsdGluL2NsZWFuLmM6OTQ0CiBtc2dpZCAiIgogImNsZWFuLnJlcXVpcmVGb3JjZSBkZWZhdWx0cyB0byB0cnVlIGFuZCBuZWl0aGVyIC1pLCAtbiwgbm9yIC1mIGdpdmVuOyAiCiAicmVmdXNpbmcgdG8gY2xlYW4iCkBAIC0xMDg5NSwxNjIgKzEwOTMyLDE2MiBAQAogImNsZWFuLnJlcXVpcmVGb3JjZSBt4bq3YyDEkeG7i25oIMSRxrDhu6NjIMSR4bq3dCBsw6AgdHJ1ZSB2w6Aga2jDtG5nIMSRxrBhIHJhIHTDuXkgY2jhu41uIC1pLCAtbiAiCiAibcOgIGPFqW5nIGtow7RuZyAtZjsgdOG7qyBjaOG7kWkgbOG7h25oIGThu41uIGThurlwIChjbGVhbikiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo0NgorIzogYnVpbHRpbi9jbG9uZS5jOjQ1CiBtc2dpZCAiZ2l0IGNsb25lIFs8b3B0aW9ucz5dIFstLV0gPHJlcG8+IFs8ZGlyPl0iCiBtc2dzdHIgImdpdCBjbG9uZSBbPGPDoWMgdMO5eSBjaOG7jW4+XSBbLS1dIDxraG8+IFs8dC5t4bulYz5dIgogCi0jOiBidWlsdGluL2Nsb25lLmM6OTMKKyM6IGJ1aWx0aW4vY2xvbmUuYzo5MgogbXNnaWQgImRvbid0IGNyZWF0ZSBhIGNoZWNrb3V0IgogbXNnc3RyICJraMO0bmcgdOG6oW8gbeG7mXQgY2hlY2tvdXQiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo5NCBidWlsdGluL2Nsb25lLmM6OTYgYnVpbHRpbi9pbml0LWRiLmM6NDg5CisjOiBidWlsdGluL2Nsb25lLmM6OTMgYnVpbHRpbi9jbG9uZS5jOjk1IGJ1aWx0aW4vaW5pdC1kYi5jOjQ4OQogbXNnaWQgImNyZWF0ZSBhIGJhcmUgcmVwb3NpdG9yeSIKIG1zZ3N0ciAidOG6oW8ga2hvIHRodeG6p24iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo5OAorIzogYnVpbHRpbi9jbG9uZS5jOjk3CiBtc2dpZCAiY3JlYXRlIGEgbWlycm9yIHJlcG9zaXRvcnkgKGltcGxpZXMgYmFyZSkiCiBtc2dzdHIgInThuqFvIGtobyBi4bqjbiBzYW8gKMO9IGzDoCBraG8gdGh14bqnbikiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMDAKKyM6IGJ1aWx0aW4vY2xvbmUuYzo5OQogbXNnaWQgInRvIGNsb25lIGZyb20gYSBsb2NhbCByZXBvc2l0b3J5IgogbXNnc3RyICLEkeG7gyBuaMOibiBi4bqjbiB04burIGtobyBu4buZaSBi4buZIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTAyCisjOiBidWlsdGluL2Nsb25lLmM6MTAxCiBtc2dpZCAiZG9uJ3QgdXNlIGxvY2FsIGhhcmRsaW5rcywgYWx3YXlzIGNvcHkiCiBtc2dzdHIgImtow7RuZyBz4butIGThu6VuZyBsacOqbiBr4bq/dCBj4bupbmcgbuG7mWkgYuG7mSwgbHXDtG4gc2FvIGNow6lwIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTA0CisjOiBidWlsdGluL2Nsb25lLmM6MTAzCiBtc2dpZCAic2V0dXAgYXMgc2hhcmVkIHJlcG9zaXRvcnkiCiBtc2dzdHIgImPDoGkgxJHhurd0IMSRw6J5IGzDoCBraG8gY2hpYSBz4bq7IgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTA3CisjOiBidWlsdGluL2Nsb25lLmM6MTA2CiBtc2dpZCAicGF0aHNwZWMiCiBtc2dzdHIgIsSR4bq3Yy104bqjLcSRxrDhu51uZy1k4bqrbiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEwNworIzogYnVpbHRpbi9jbG9uZS5jOjEwNgogbXNnaWQgImluaXRpYWxpemUgc3VibW9kdWxlcyBpbiB0aGUgY2xvbmUiCiBtc2dzdHIgImto4bufaSB04bqhbyBtw7QtxJF1bi1jb24gdHJvbmcgYuG6o24gc2FvIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTEwCisjOiBidWlsdGluL2Nsb25lLmM6MTA5CiBtc2dpZCAibnVtYmVyIG9mIHN1Ym1vZHVsZXMgY2xvbmVkIGluIHBhcmFsbGVsIgogbXNnc3RyICJz4buRIGzGsOG7o25nIG3DtC3EkXVuLWNvbiDEkcaw4bujYyBuaMOibiBi4bqjbiDEkeG7k25nIHRo4budaSIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjExMSBidWlsdGluL2luaXQtZGIuYzo0ODYKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMTAgYnVpbHRpbi9pbml0LWRiLmM6NDg2CiBtc2dpZCAidGVtcGxhdGUtZGlyZWN0b3J5IgogbXNnc3RyICJ0aMawLW3hu6VjLW3huqt1IgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTEyIGJ1aWx0aW4vaW5pdC1kYi5jOjQ4NworIzogYnVpbHRpbi9jbG9uZS5jOjExMSBidWlsdGluL2luaXQtZGIuYzo0ODcKIG1zZ2lkICJkaXJlY3RvcnkgZnJvbSB3aGljaCB0ZW1wbGF0ZXMgd2lsbCBiZSB1c2VkIgogbXNnc3RyICJ0aMawIG3hu6VjIG3DoCB04bqhaSDEkcOzIGPDoWMgbeG6q3Ugc+G6vSDEkcaw4bujYyBkw7luZyIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjExNCBidWlsdGluL2Nsb25lLmM6MTE2IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxMzgwCisjOiBidWlsdGluL2Nsb25lLmM6MTEzIGJ1aWx0aW4vY2xvbmUuYzoxMTUgYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjEzODAKICM6IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxODYwCiBtc2dpZCAicmVmZXJlbmNlIHJlcG9zaXRvcnkiCiBtc2dzdHIgImtobyB0aGFtIGNoaeG6v3UiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMTggYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjEzODIKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMTcgYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjEzODIKICM6IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxODYyCiBtc2dpZCAidXNlIC0tcmVmZXJlbmNlIG9ubHkgd2hpbGUgY2xvbmluZyIKIG1zZ3N0ciAiY2jhu4kgZMO5bmcgLS1yZWZlcmVuY2Uga2hpIG5ow6JuIGLhuqNuIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTE5IGJ1aWx0aW4vY29sdW1uLmM6MjcgYnVpbHRpbi9tZXJnZS1maWxlLmM6NDYKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMxNCBidWlsdGluL3JlcGFjay5jOjMxOQorIzogYnVpbHRpbi9jbG9uZS5jOjExOCBidWlsdGluL2NvbHVtbi5jOjI3IGJ1aWx0aW4vbWVyZ2UtZmlsZS5jOjQ2CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyOTQgYnVpbHRpbi9yZXBhY2suYzozMjAKIG1zZ2lkICJuYW1lIgogbXNnc3RyICJ0w6puIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTIwCisjOiBidWlsdGluL2Nsb25lLmM6MTE5CiBtc2dpZCAidXNlIDxuYW1lPiBpbnN0ZWFkIG9mICdvcmlnaW4nIHRvIHRyYWNrIHVwc3RyZWFtIgogbXNnc3RyICJkw7luZyA8dMOqbj4gdGhheSBjaG8g4oCcb3JpZ2lu4oCdIMSR4buDIHRoZW8gZMO1aSB0aMaw4bujbmcgbmd14buTbiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEyMgorIzogYnVpbHRpbi9jbG9uZS5jOjEyMQogbXNnaWQgImNoZWNrb3V0IDxicmFuY2g+IGluc3RlYWQgb2YgdGhlIHJlbW90ZSdzIEhFQUQiCiBtc2dzdHIgImzhuqV5IHJhIDxuaMOhbmg+IHRoYXkgY2hvIEhFQUQgY+G7p2EgbcOheSBjaOG7pyIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEyNAorIzogYnVpbHRpbi9jbG9uZS5jOjEyMwogbXNnaWQgInBhdGggdG8gZ2l0LXVwbG9hZC1wYWNrIG9uIHRoZSByZW1vdGUiCiBtc2dzdHIgIsSRxrDhu51uZyBk4bqrbiDEkeG6v24gZ2l0LXVwbG9hZC1wYWNrIHRyw6puIG3DoXkgY2jhu6ciCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMjUgYnVpbHRpbi9mZXRjaC5jOjE1MiBidWlsdGluL2dyZXAuYzo4MzgKLSM6IGJ1aWx0aW4vcHVsbC5jOjIyNgorIzogYnVpbHRpbi9jbG9uZS5jOjEyNCBidWlsdGluL2ZldGNoLmM6MTY3IGJ1aWx0aW4vZ3JlcC5jOjg0MAorIzogYnVpbHRpbi9wdWxsLmM6MjI3CiBtc2dpZCAiZGVwdGgiCiBtc2dzdHIgIsSR4buZLXPDonUiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMjYKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMjUKIG1zZ2lkICJjcmVhdGUgYSBzaGFsbG93IGNsb25lIG9mIHRoYXQgZGVwdGgiCiBtc2dzdHIgInThuqFvIGLhuqNuIHNhbyBraMO0bmcgxJHhuqd5IMSR4bunIGNobyBt4bupYyBzw6J1IMSRw6MgY2hvIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTI3IGJ1aWx0aW4vZmV0Y2guYzoxNTQgYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzAzCisjOiBidWlsdGluL2Nsb25lLmM6MTI2IGJ1aWx0aW4vZmV0Y2guYzoxNjkgYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjgzCiBtc2dpZCAidGltZSIKIG1zZ3N0ciAidGjhu51pLWdpYW4iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMjgKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMjcKIG1zZ2lkICJjcmVhdGUgYSBzaGFsbG93IGNsb25lIHNpbmNlIGEgc3BlY2lmaWMgdGltZSIKIG1zZ3N0ciAidOG6oW8gYuG6o24gc2FvIGtow7RuZyDEkeG6p3kgxJHhu6cgdOG7qyB0aOG7nWkgxJFp4buDbSDEkcOjIGNobyIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEyOSBidWlsdGluL2ZldGNoLmM6MTU2IGJ1aWx0aW4vZmV0Y2guYzoxNzkKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTM5NQorIzogYnVpbHRpbi9jbG9uZS5jOjEyOCBidWlsdGluL2ZldGNoLmM6MTcxIGJ1aWx0aW4vZmV0Y2guYzoxOTQKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQxNwogbXNnaWQgInJldmlzaW9uIgogbXNnc3RyICLEkWnhu4NtIHjDqXQgZHV54buHdCIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEzMCBidWlsdGluL2ZldGNoLmM6MTU3CisjOiBidWlsdGluL2Nsb25lLmM6MTI5IGJ1aWx0aW4vZmV0Y2guYzoxNzIKIG1zZ2lkICJkZWVwZW4gaGlzdG9yeSBvZiBzaGFsbG93IGNsb25lLCBleGNsdWRpbmcgcmV2IgogbXNnc3RyICJsw6BtIHPDonUgaMahbiBs4buLY2ggc+G7rSBj4bunYSBi4bqjbiBzYW8gc2hhbGxvdywgYuG6sW5nIMSRaeG7g20geMOpdCBkdXnhu4d0IGxv4bqhaSB0cuG7qyIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEzMgorIzogYnVpbHRpbi9jbG9uZS5jOjEzMQogbXNnaWQgImNsb25lIG9ubHkgb25lIGJyYW5jaCwgSEVBRCBvciAtLWJyYW5jaCIKIG1zZ3N0ciAiY2jhu4kgbmjDom4gYuG6o24gbeG7mXQgbmjDoW5oLCBIRUFEIGhv4bq3YyAtLWJyYW5jaCIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEzNAorIzogYnVpbHRpbi9jbG9uZS5jOjEzMwogbXNnaWQgImRvbid0IGNsb25lIGFueSB0YWdzLCBhbmQgbWFrZSBsYXRlciBmZXRjaGVzIG5vdCB0byBmb2xsb3cgdGhlbSIKIG1zZ3N0ciAiIgogIsSR4bupbmcgY8OzIG5ow6JuIGLhuqNuIGLhuqV0IGvhu7MgbmjDoW5oIG7DoG8sIHbDoCBsw6BtIGNobyBuaOG7r25nIGzhuqduIGzhuqV5IHbhu4Egc2F1IGtow7RuZyAiCiAidGhlbyBjaMO6bmcgbuG7r2EiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMzYKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMzUKIG1zZ2lkICJhbnkgY2xvbmVkIHN1Ym1vZHVsZXMgd2lsbCBiZSBzaGFsbG93IgogbXNnc3RyICJt4buNaSBtw7QtxJF1bi1jb24gbmjDom4gYuG6o24gc+G6vSBsw6Agc2hhbGxvdyAobsO0bmcpIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTM3IGJ1aWx0aW4vaW5pdC1kYi5jOjQ5NQorIzogYnVpbHRpbi9jbG9uZS5jOjEzNiBidWlsdGluL2luaXQtZGIuYzo0OTUKIG1zZ2lkICJnaXRkaXIiCiBtc2dzdHIgImdpdGRpciIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEzOCBidWlsdGluL2luaXQtZGIuYzo0OTYKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMzcgYnVpbHRpbi9pbml0LWRiLmM6NDk2CiBtc2dpZCAic2VwYXJhdGUgZ2l0IGRpciBmcm9tIHdvcmtpbmcgdHJlZSIKIG1zZ3N0ciAia2jDtG5nIGTDuW5nIGNodW5nIHRoxrAgbeG7pWMgZMOgbmggcmnDqm5nIGNobyBnaXQgdsOgIHRoxrAgbeG7pWMgbMOgbSB2aeG7h2MiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMzkKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMzgKIG1zZ2lkICJrZXk9dmFsdWUiCiBtc2dzdHIgImtow7NhPWdpw6FfdHLhu4siCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxNDAKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMzkKIG1zZ2lkICJzZXQgY29uZmlnIGluc2lkZSB0aGUgbmV3IHJlcG9zaXRvcnkiCiBtc2dzdHIgIsSR4bq3dCBj4bqldSBow6xuaCBiw6puIHRyb25nIG3hu5l0IGtobyBjaOG7qWEgbeG7m2kiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxNDIgYnVpbHRpbi9mZXRjaC5jOjE3NCBidWlsdGluL2xzLXJlbW90ZS5jOjc2Ci0jOiBidWlsdGluL3B1c2guYzo1ODUgYnVpbHRpbi9zZW5kLXBhY2suYzoxNzIKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxNDEgYnVpbHRpbi9mZXRjaC5jOjE4OSBidWlsdGluL2xzLXJlbW90ZS5jOjc2CisjOiBidWlsdGluL3B1c2guYzo1NzIgYnVpbHRpbi9zZW5kLXBhY2suYzoxNzIKIG1zZ2lkICJzZXJ2ZXItc3BlY2lmaWMiCiBtc2dzdHIgIsSR4bq3Yy104bqjLW3DoXktcGjhu6VjLXbhu6UiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxNDIgYnVpbHRpbi9mZXRjaC5jOjE3NCBidWlsdGluL2xzLXJlbW90ZS5jOjc2Ci0jOiBidWlsdGluL3B1c2guYzo1ODUgYnVpbHRpbi9zZW5kLXBhY2suYzoxNzMKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxNDEgYnVpbHRpbi9mZXRjaC5jOjE4OSBidWlsdGluL2xzLXJlbW90ZS5jOjc2CisjOiBidWlsdGluL3B1c2guYzo1NzIgYnVpbHRpbi9zZW5kLXBhY2suYzoxNzMKIG1zZ2lkICJvcHRpb24gdG8gdHJhbnNtaXQiCiBtc2dzdHIgInTDuXkgY2jhu41uIMSR4buDIGNodXnhu4NuIGdpYW8iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxNDMgYnVpbHRpbi9mZXRjaC5jOjE3NSBidWlsdGluL3B1bGwuYzoyMzkKLSM6IGJ1aWx0aW4vcHVzaC5jOjU4NgorIzogYnVpbHRpbi9jbG9uZS5jOjE0MiBidWlsdGluL2ZldGNoLmM6MTkwIGJ1aWx0aW4vcHVsbC5jOjI0MAorIzogYnVpbHRpbi9wdXNoLmM6NTczCiBtc2dpZCAidXNlIElQdjQgYWRkcmVzc2VzIG9ubHkiCiBtc2dzdHIgImNo4buJIGTDuW5nIMSR4buLYSBjaOG7iSBJUHY0IgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTQ1IGJ1aWx0aW4vZmV0Y2guYzoxNzcgYnVpbHRpbi9wdWxsLmM6MjQyCi0jOiBidWlsdGluL3B1c2guYzo1ODgKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxNDQgYnVpbHRpbi9mZXRjaC5jOjE5MiBidWlsdGluL3B1bGwuYzoyNDMKKyM6IGJ1aWx0aW4vcHVzaC5jOjU3NQogbXNnaWQgInVzZSBJUHY2IGFkZHJlc3NlcyBvbmx5IgogbXNnc3RyICJjaOG7iSBkw7luZyDEkeG7i2EgY2jhu4kgSVB2NiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjE0OQorIzogYnVpbHRpbi9jbG9uZS5jOjE0OAogbXNnaWQgImFueSBjbG9uZWQgc3VibW9kdWxlcyB3aWxsIHVzZSB0aGVpciByZW1vdGUtdHJhY2tpbmcgYnJhbmNoIgogbXNnc3RyICJt4buNaSBtw7QtxJF1bi1jb24gbmjDom4gYuG6o24gc+G6vSBkdW5nIG5ow6FuaCB0aGVvIGTDtWkgbcOheSBjaOG7pyBj4bunYSBjaMO6bmciCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoyODUKKyM6IGJ1aWx0aW4vY2xvbmUuYzoyODQKIG1zZ2lkICIiCiAiTm8gZGlyZWN0b3J5IG5hbWUgY291bGQgYmUgZ3Vlc3NlZC5cbiIKICJQbGVhc2Ugc3BlY2lmeSBhIGRpcmVjdG9yeSBvbiB0aGUgY29tbWFuZCBsaW5lIgpAQCAtMTEwNTgsNDcgKzExMDk1LDQyIEBACiAiS2jDtG5nIMSRb8OhbiDEkcaw4bujYyB0aMawIG3hu6VjIHTDqm4gbMOgIGfDrC5cbiIKICJWdWkgbMOybmcgY2jhu4kgxJHhu4tuaCB0w6puIG3hu5l0IHRoxrAgbeG7pWMgdHLDqm4gZMOybmcgbOG7h25oIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MzM4CisjOiBidWlsdGluL2Nsb25lLmM6MzM3CiAjLCBjLWZvcm1hdAogbXNnaWQgImluZm86IENvdWxkIG5vdCBhZGQgYWx0ZXJuYXRlIGZvciAnJXMnOiAlc1xuIgogbXNnc3RyICJ0aMO0bmcgdGluOiBraMO0bmcgdGjhu4MgdGjDqm0gdGhheSB0aOG6vyBjaG8g4oCcJXPigJ06ICVzXG4iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo0MTEKKyM6IGJ1aWx0aW4vY2xvbmUuYzo0MTAKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgZXhpc3RzIGFuZCBpcyBub3QgYSBkaXJlY3RvcnkiCiBtc2dzdHIgIiVzIGPDsyB04buTbiB04bqhaSBuaMawbmcgbOG6oWkga2jDtG5nIHBo4bqjaSBsw6AgbeG7mXQgdGjGsCBt4bulYyIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjQyOAorIzogYnVpbHRpbi9jbG9uZS5jOjQyNwogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gc3RhcnQgaXRlcmF0b3Igb3ZlciAnJXMnIgogbXNnc3RyICJn4bq3cCBs4buXaSBraGkgYuG6r3QgxJHhuqd1IGzhurdwIHF1YSDigJwlc+KAnSIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjQ1MwotIywgYy1mb3JtYXQKLW1zZ2lkICJmYWlsZWQgdG8gdW5saW5rICclcyciCi1tc2dzdHIgImfhurdwIGzhu5dpIGtoaSBi4buPIGxpw6puIGvhur90ICh1bmxpbmspIOKAnCVz4oCdIgotCi0jOiBidWlsdGluL2Nsb25lLmM6NDU4CisjOiBidWlsdGluL2Nsb25lLmM6NDU3CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBjcmVhdGUgbGluayAnJXMnIgogbXNnc3RyICJn4bq3cCBs4buXaSBraGkgdOG6oW8gxJHGsOG7o2MgbGnDqm4ga+G6v3QgbeG7gW0gJXMiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo0NjIKKyM6IGJ1aWx0aW4vY2xvbmUuYzo0NjEKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIGNvcHkgZmlsZSB0byAnJXMnIgogbXNnc3RyICJn4bq3cCBs4buXaSBraGkgc2FvIGNow6lwIHThuq1wIHRpbiB2w6Ag4oCcJXPigJ0iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo0NjcKKyM6IGJ1aWx0aW4vY2xvbmUuYzo0NjYKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIGl0ZXJhdGUgb3ZlciAnJXMnIgogbXNnc3RyICJn4bq3cCBs4buXaSBraGkgbOG6t3AgcXVhIOKAnCVz4oCdIgogCi0jOiBidWlsdGluL2Nsb25lLmM6NDkyCisjOiBidWlsdGluL2Nsb25lLmM6NDkxCiAjLCBjLWZvcm1hdAogbXNnaWQgImRvbmUuXG4iCiBtc2dzdHIgImhvw6BuIHThuqV0LlxuIgogCi0jOiBidWlsdGluL2Nsb25lLmM6NTA2CisjOiBidWlsdGluL2Nsb25lLmM6NTA1CiBtc2dpZCAiIgogIkNsb25lIHN1Y2NlZWRlZCwgYnV0IGNoZWNrb3V0IGZhaWxlZC5cbiIKICJZb3UgY2FuIGluc3BlY3Qgd2hhdCB3YXMgY2hlY2tlZCBvdXQgd2l0aCAnZ2l0IHN0YXR1cydcbiIKQEAgLTExMTA4LDk1ICsxMTE0MCw5NSBAQAogIkLhuqFuIGtp4buDbSB0cmEga+G7uSB4ZW0gY8OhaSBnw6wgxJHGsOG7o2MgbOG6pXkgcmEgYuG6sW5nIGzhu4duaCDigJxnaXQgc3RhdHVz4oCdXG4iCiAidsOgIHRo4butIGzhuqV5IHJhIHbhu5tpIGzhu4duaCAnZ2l0IHJlc3RvcmUgLS1zb3VyY2U9SEVBRCA6LydcbiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjU4MworIzogYnVpbHRpbi9jbG9uZS5jOjU4MgogIywgYy1mb3JtYXQKIG1zZ2lkICJDb3VsZCBub3QgZmluZCByZW1vdGUgYnJhbmNoICVzIHRvIGNsb25lLiIKIG1zZ3N0ciAiS2jDtG5nIHTDrG0gdGjhuqV5IG5ow6FuaCBtw6F5IGNo4bunICVzIMSR4buDIG5ow6JuIGLhuqNuIChjbG9uZSkuIgogCi0jOiBidWlsdGluL2Nsb25lLmM6NzAyCisjOiBidWlsdGluL2Nsb25lLmM6NzAxCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byB1cGRhdGUgJXMiCiBtc2dzdHIgImtow7RuZyB0aOG7gyBj4bqtcCBuaOG6rXQgJXMiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo3NTIKKyM6IGJ1aWx0aW4vY2xvbmUuYzo3NTEKIG1zZ2lkICJyZW1vdGUgSEVBRCByZWZlcnMgdG8gbm9uZXhpc3RlbnQgcmVmLCB1bmFibGUgdG8gY2hlY2tvdXQuXG4iCiBtc2dzdHIgInJlZmVycyBIRUFEIG3DoXkgY2jhu6cgIGNo4buJIMSR4bq/biByZWYga2jDtG5nIHThu5NuIHThuqFpLCBraMO0bmcgdGjhu4MgbOG6pXkgcmEuXG4iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo3ODMKKyM6IGJ1aWx0aW4vY2xvbmUuYzo3ODIKIG1zZ2lkICJ1bmFibGUgdG8gY2hlY2tvdXQgd29ya2luZyB0cmVlIgogbXNnc3RyICJraMO0bmcgdGjhu4MgbOG6pXkgcmEgKGNoZWNrb3V0KSBjw6J5IGzDoG0gdmnhu4djIgogCi0jOiBidWlsdGluL2Nsb25lLmM6ODMzCisjOiBidWlsdGluL2Nsb25lLmM6ODMyCiBtc2dpZCAidW5hYmxlIHRvIHdyaXRlIHBhcmFtZXRlcnMgdG8gY29uZmlnIGZpbGUiCiBtc2dzdHIgImtow7RuZyB0aOG7gyBnaGkgY8OhYyB0aGFtIHPhu5EgdsOgbyB04bqtcCB0aW4gY+G6pXUgaMOsbmgiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo4OTYKKyM6IGJ1aWx0aW4vY2xvbmUuYzo4OTUKIG1zZ2lkICJjYW5ub3QgcmVwYWNrIHRvIGNsZWFuIHVwIgogbXNnc3RyICJraMO0bmcgdGjhu4MgxJHDs25nIGfDs2kgxJHhu4MgZOG7jW4gZOG6uXAiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo4OTgKKyM6IGJ1aWx0aW4vY2xvbmUuYzo4OTcKIG1zZ2lkICJjYW5ub3QgdW5saW5rIHRlbXBvcmFyeSBhbHRlcm5hdGVzIGZpbGUiCiBtc2dzdHIgImtow7RuZyB0aOG7gyBi4buPIGxpw6puIGvhur90IHThuq1wIHRpbiB0aGF5IHRo4bq/IHThuqFtIHRo4budaSIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjkzOCBidWlsdGluL3JlY2VpdmUtcGFjay5jOjE5NTAKKyM6IGJ1aWx0aW4vY2xvbmUuYzo5MzcgYnVpbHRpbi9yZWNlaXZlLXBhY2suYzoxOTQ4CiBtc2dpZCAiVG9vIG1hbnkgYXJndW1lbnRzLiIKIG1zZ3N0ciAiQ8OzIHF1w6Egbmhp4buBdSDEkeG7kWkgc+G7kS4iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo5NDIKKyM6IGJ1aWx0aW4vY2xvbmUuYzo5NDEKIG1zZ2lkICJZb3UgbXVzdCBzcGVjaWZ5IGEgcmVwb3NpdG9yeSB0byBjbG9uZS4iCiBtc2dzdHIgIkLhuqFuIHBo4bqjaSBjaOG7iSDEkeG7i25oIG3hu5l0IGtobyDEkeG7gyBtw6AgbmjDom4gYuG6o24gKGNsb25lKS4iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo5NTUKKyM6IGJ1aWx0aW4vY2xvbmUuYzo5NTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiLS1iYXJlIGFuZCAtLW9yaWdpbiAlcyBvcHRpb25zIGFyZSBpbmNvbXBhdGlibGUuIgogbXNnc3RyICJ0w7l5IGNo4buNbiAtLWJhcmUgdsOgIC0tb3JpZ2luICVzIHh1bmcga2jhuq9jIG5oYXUuIgogCi0jOiBidWlsdGluL2Nsb25lLmM6OTU4CisjOiBidWlsdGluL2Nsb25lLmM6OTU3CiBtc2dpZCAiLS1iYXJlIGFuZCAtLXNlcGFyYXRlLWdpdC1kaXIgYXJlIGluY29tcGF0aWJsZS4iCiBtc2dzdHIgInTDuXkgY2jhu41uIC0tYmFyZSB2w6AgLS1zZXBhcmF0ZS1naXQtZGlyIHh1bmcga2jhuq9jIG5oYXUuIgogCi0jOiBidWlsdGluL2Nsb25lLmM6OTcxCisjOiBidWlsdGluL2Nsb25lLmM6OTcwCiAjLCBjLWZvcm1hdAogbXNnaWQgInJlcG9zaXRvcnkgJyVzJyBkb2VzIG5vdCBleGlzdCIKIG1zZ3N0ciAia2hvIGNo4bupYSDigJwlc+KAnSBjaMawYSB04buTbiB04bqhaSIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjk3NyBidWlsdGluL2ZldGNoLmM6MTY2MAorIzogYnVpbHRpbi9jbG9uZS5jOjk3NiBidWlsdGluL2ZldGNoLmM6MTc5MAogIywgYy1mb3JtYXQKIG1zZ2lkICJkZXB0aCAlcyBpcyBub3QgYSBwb3NpdGl2ZSBudW1iZXIiCiBtc2dzdHIgIsSR4buZIHPDonUgJXMga2jDtG5nIHBo4bqjaSBsw6AgbeG7mXQgc+G7kSBuZ3V5w6puIGTGsMahbmciCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo5ODcKKyM6IGJ1aWx0aW4vY2xvbmUuYzo5ODYKICMsIGMtZm9ybWF0CiBtc2dpZCAiZGVzdGluYXRpb24gcGF0aCAnJXMnIGFscmVhZHkgZXhpc3RzIGFuZCBpcyBub3QgYW4gZW1wdHkgZGlyZWN0b3J5LiIKIG1zZ3N0ciAixJHGsOG7nW5nIGThuqtuIMSRw61jaCDigJwlc+KAnSDEkcOjIGPDsyB04burIHRyxrDhu5tjIHbDoCBraMO0bmcgcGjhuqNpIGzDoCBt4buZdCB0aMawIG3hu6VjIHLhu5duZy4iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo5OTcKKyM6IGJ1aWx0aW4vY2xvbmUuYzo5OTYKICMsIGMtZm9ybWF0CiBtc2dpZCAid29ya2luZyB0cmVlICclcycgYWxyZWFkeSBleGlzdHMuIgogbXNnc3RyICJjw6J5IGzDoG0gdmnhu4djIOKAnCVz4oCdIMSRw6Mgc+G6tW4gdOG7k24gdOG6oWkgcuG7k2kuIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTAxMiBidWlsdGluL2Nsb25lLmM6MTAzMyBidWlsdGluL2RpZmZ0b29sLmM6MjY0Ci0jOiBidWlsdGluL3dvcmt0cmVlLmM6MzAzIGJ1aWx0aW4vd29ya3RyZWUuYzozMzUKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMDExIGJ1aWx0aW4vY2xvbmUuYzoxMDMyIGJ1aWx0aW4vZGlmZnRvb2wuYzoyNzEKKyM6IGJ1aWx0aW4vbG9nLmM6MTc4NSBidWlsdGluL3dvcmt0cmVlLmM6MzAyIGJ1aWx0aW4vd29ya3RyZWUuYzozMzQKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGNyZWF0ZSBsZWFkaW5nIGRpcmVjdG9yaWVzIG9mICclcyciCiBtc2dzdHIgImtow7RuZyB0aOG7gyB04bqhbyBjw6FjIHRoxrAgbeG7pWMgZOG6q24gxJHhuqd1IGPhu6dhIOKAnCVz4oCdIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTAxNworIzogYnVpbHRpbi9jbG9uZS5jOjEwMTYKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGNyZWF0ZSB3b3JrIHRyZWUgZGlyICclcyciCiBtc2dzdHIgImtow7RuZyB0aOG7gyB04bqhbyBjw6J5IHRoxrAgbeG7pWMgbMOgbSB2aeG7h2MgZGlyIOKAnCVz4oCdIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTAzNworIzogYnVpbHRpbi9jbG9uZS5jOjEwMzYKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ2xvbmluZyBpbnRvIGJhcmUgcmVwb3NpdG9yeSAnJXMnLi4uXG4iCiBtc2dzdHIgIsSQYW5nIG5ow6JuIGLhuqNuIHRow6BuaCBraG8gY2jhu6lhIGJhcmUg4oCcJXPigJ3igKZcbiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEwMzkKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMDM4CiAjLCBjLWZvcm1hdAogbXNnaWQgIkNsb25pbmcgaW50byAnJXMnLi4uXG4iCiBtc2dzdHIgIsSQYW5nIG5ow6JuIGLhuqNuIHRow6BuaCDigJwlc+KAneKAplxuIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTA2MworIzogYnVpbHRpbi9jbG9uZS5jOjEwNjIKIG1zZ2lkICIiCiAiY2xvbmUgLS1yZWN1cnNpdmUgaXMgbm90IGNvbXBhdGlibGUgd2l0aCBib3RoIC0tcmVmZXJlbmNlIGFuZCAtLXJlZmVyZW5jZS1pZi0iCiAiYWJsZSIKQEAgLTExMjA0LDQxICsxMTIzNiw0MSBAQAogIm5ow6JuIGLhuqNuIC0tcmVjdXJzaXZlIGtow7RuZyB0xrDGoW5nIHRow61jaCB24bubaSBj4bqjIGhhaSAtLXJlZmVyZW5jZSB2w6AgLS1yZWZlcmVuY2UtIgogImlmLWFibGUiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMTI0CisjOiBidWlsdGluL2Nsb25lLmM6MTEyMwogbXNnaWQgIi0tZGVwdGggaXMgaWdub3JlZCBpbiBsb2NhbCBjbG9uZXM7IHVzZSBmaWxlOi8vIGluc3RlYWQuIgogbXNnc3RyICItLWRlcHRoIGLhu4sgbOG7nSDEkWkga2hpIG5ow6JuIGLhuqNuIG7hu5lpIGLhu5k7IGjDo3kgc+G7rSBk4bulbmcgZmlsZTovLyDEkeG7gyB0aGF5IHRo4bq/LiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjExMjYKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMTI1CiBtc2dpZCAiLS1zaGFsbG93LXNpbmNlIGlzIGlnbm9yZWQgaW4gbG9jYWwgY2xvbmVzOyB1c2UgZmlsZTovLyBpbnN0ZWFkLiIKIG1zZ3N0ciAiIgogIi0tc2hhbGxvdy1zaW5jZSBi4buLIGzhu50gxJFpIGtoaSBuaMOibiBi4bqjbiBu4buZaSBi4buZOyBow6N5IHPhu60gZOG7pW5nIGZpbGU6Ly8gxJHhu4MgdGhheSAiCiAidGjhur8uIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTEyOAorIzogYnVpbHRpbi9jbG9uZS5jOjExMjcKIG1zZ2lkICItLXNoYWxsb3ctZXhjbHVkZSBpcyBpZ25vcmVkIGluIGxvY2FsIGNsb25lczsgdXNlIGZpbGU6Ly8gaW5zdGVhZC4iCiBtc2dzdHIgIiIKICItLXNoYWxsb3ctZXhjbHVkZSBi4buLIGzhu50gxJFpIGtoaSBuaMOibiBi4bqjbiBu4buZaSBi4buZOyBow6N5IHPhu60gZOG7pW5nIGZpbGU6Ly8gxJHhu4MgdGhheSAiCiAidGjhur8uIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTEzMAorIzogYnVpbHRpbi9jbG9uZS5jOjExMjkKIG1zZ2lkICItLWZpbHRlciBpcyBpZ25vcmVkIGluIGxvY2FsIGNsb25lczsgdXNlIGZpbGU6Ly8gaW5zdGVhZC4iCiBtc2dzdHIgIiIKICItLWZpbHRlciBi4buLIGzhu50gxJFpIGtoaSBuaMOibiBi4bqjbiBu4buZaSBi4buZOyBow6N5IHPhu60gZOG7pW5nIGZpbGU6Ly8gxJHhu4MgdGhheSB0aOG6vy4iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMTMzCisjOiBidWlsdGluL2Nsb25lLmM6MTEzMgogbXNnaWQgInNvdXJjZSByZXBvc2l0b3J5IGlzIHNoYWxsb3csIGlnbm9yaW5nIC0tbG9jYWwiCiBtc2dzdHIgImtobyBuZ3Xhu5NuIGzDoCBuw7RuZywgbsOqbiBi4buPIHF1YSAtLWxvY2FsIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTEzOAorIzogYnVpbHRpbi9jbG9uZS5jOjExMzcKIG1zZ2lkICItLWxvY2FsIGlzIGlnbm9yZWQiCiBtc2dzdHIgIi0tbG9jYWwgYuG7iyBs4budIMSRaSIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEyMTUgYnVpbHRpbi9jbG9uZS5jOjEyMjMKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMjEyIGJ1aWx0aW4vY2xvbmUuYzoxMjIwCiAjLCBjLWZvcm1hdAogbXNnaWQgIlJlbW90ZSBicmFuY2ggJXMgbm90IGZvdW5kIGluIHVwc3RyZWFtICVzIgogbXNnc3RyICJOaMOhbmggbcOheSBjaOG7pyAlcyBraMO0bmcgdMOsbSB0aOG6pXkgdHJvbmcgdGjGsOG7o25nIG5ndeG7k24gJXMiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMjI2CisjOiBidWlsdGluL2Nsb25lLmM6MTIyMwogbXNnaWQgIllvdSBhcHBlYXIgdG8gaGF2ZSBjbG9uZWQgYW4gZW1wdHkgcmVwb3NpdG9yeS4iCiBtc2dzdHIgIkLhuqFuIGjDrG5oIG5oxrAgbMOgIMSRw6MgbmjDom4gYuG6o24gbeG7mXQga2hvIHRy4buRbmcgcuG7l25nLiIKIApAQCAtMTEzMTYsNyArMTEzNDgsNyBAQAogbXNnc3RyICJtw6Mgc+G7kSBj4bunYSDEkeG7kWkgdMaw4bujbmcgY2h1eeG7g24gZ2lhbyBjaGEgbeG6uSIKIAogIzogYnVpbHRpbi9jb21taXQtdHJlZS5jOjExNCBidWlsdGluL2NvbW1pdC5jOjE1MDAgYnVpbHRpbi9tZXJnZS5jOjI3MAotIzogYnVpbHRpbi9ub3Rlcy5jOjQwOSBidWlsdGluL25vdGVzLmM6NTc1IGJ1aWx0aW4vc3Rhc2guYzoxNDYwCisjOiBidWlsdGluL25vdGVzLmM6NDA5IGJ1aWx0aW4vbm90ZXMuYzo1NzUgYnVpbHRpbi9zdGFzaC5jOjE0NjkKICM6IGJ1aWx0aW4vdGFnLmM6NDEyCiBtc2dpZCAibWVzc2FnZSIKIG1zZ3N0ciAiY2jDuiB0aMOtY2giCkBAIC0xMTMzMCw3ICsxMTM2Miw3IEBACiBtc2dzdHIgIsSR4buNYyBjaMO6IHRow61jaCBuaOG6rXQga8O9IGzhuqduIGNodXnhu4NuIGdpYW8gdOG7qyB04bqtcCB0aW4iCiAKICM6IGJ1aWx0aW4vY29tbWl0LXRyZWUuYzoxMjEgYnVpbHRpbi9jb21taXQuYzoxNTEyIGJ1aWx0aW4vbWVyZ2UuYzoyODcKLSM6IGJ1aWx0aW4vcHVsbC5jOjE5NCBidWlsdGluL3JldmVydC5jOjExOAorIzogYnVpbHRpbi9wdWxsLmM6MTk1IGJ1aWx0aW4vcmV2ZXJ0LmM6MTE4CiBtc2dpZCAiR1BHIHNpZ24gY29tbWl0IgogbXNnc3RyICJLw70gbOG6p24gY2h1eeG7g24gZ2lhbyBkw7luZyBHUEciCiAKQEAgLTExNjcyLDggKzExNzA0LDggQEAKIG1zZ2lkICJ2ZXJzaW9uIgogbXNnc3RyICJwaGnDqm4gYuG6o24iCiAKLSM6IGJ1aWx0aW4vY29tbWl0LmM6MTM0NyBidWlsdGluL2NvbW1pdC5jOjE1MjkgYnVpbHRpbi9wdXNoLmM6NTYxCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NjUxCisjOiBidWlsdGluL2NvbW1pdC5jOjEzNDcgYnVpbHRpbi9jb21taXQuYzoxNTI5IGJ1aWx0aW4vcHVzaC5jOjU0OAorIzogYnVpbHRpbi93b3JrdHJlZS5jOjY1MAogbXNnaWQgIm1hY2hpbmUtcmVhZGFibGUgb3V0cHV0IgogbXNnc3RyICJr4bq/dCB4deG6pXQgZOG6oW5nIG3DoXktY8OzLXRo4buDLcSR4buNYyIKIApAQCAtMTE2ODYsOCArMTE3MTgsOCBAQAogbXNnc3RyICJjaOG6pW0gZOG7qXQgY8OhYyBt4bulYyBi4bqxbmcgTlVMIgogCiAjOiBidWlsdGluL2NvbW1pdC5jOjEzNTUgYnVpbHRpbi9jb21taXQuYzoxMzU5IGJ1aWx0aW4vY29tbWl0LmM6MTUzNwotIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExMjUgYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExMjgKLSM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTMxIGJ1aWx0aW4vcmViYXNlLmM6MTQ3MSBwYXJzZS1vcHRpb25zLmg6MzMyCisjOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE1MyBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE1NgorIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNTkgYnVpbHRpbi9yZWJhc2UuYzoxNDk1IHBhcnNlLW9wdGlvbnMuaDozMzIKIG1zZ2lkICJtb2RlIgogbXNnc3RyICJjaOG6vyDEkeG7mSIKIApAQCAtMTE3MDUsNyArMTE3MzcsNyBAQAogImhp4buDbiB0aOG7iyBjw6FjIHThuq1wIHRpbiBi4buLIGLhu48gcXVhLCBjw6FjIGNo4bq/IMSR4buZIHTDuXkgY2jhu41uOiB0cmFkaXRpb25hbCwgbWF0Y2hpbmcsICIKICJuby4gKE3hurdjIMSR4buLbmg6IHRyYWRpdGlvbmFsKSIKIAotIzogYnVpbHRpbi9jb21taXQuYzoxMzYyIHBhcnNlLW9wdGlvbnMuaDoxNzkKKyM6IGJ1aWx0aW4vY29tbWl0LmM6MTM2MiBwYXJzZS1vcHRpb25zLmg6MTg4CiBtc2dpZCAid2hlbiIKIG1zZ3N0ciAia2hpIgogCkBAIC0xMTc1OCw3ICsxMTc5MCw3IEBACiBtc2dpZCAib3ZlcnJpZGUgYXV0aG9yIGZvciBjb21taXQiCiBtc2dzdHIgImdoaSDEkcOoIHTDoWMgZ2nhuqMgY2hvIGNvbW1pdCIKIAotIzogYnVpbHRpbi9jb21taXQuYzoxNDk5IGJ1aWx0aW4vZ2MuYzo1MzkKKyM6IGJ1aWx0aW4vY29tbWl0LmM6MTQ5OSBidWlsdGluL2djLmM6NTM4CiBtc2dpZCAiZGF0ZSIKIG1zZ3N0ciAibmfDoHkgdGjDoW5nIgogCkBAIC0xMTc5NSw4ICsxMTgyNyw4IEBACiBtc2dzdHIgIiIKICJs4bqnbiBjaHV54buDbiBnaWFvIG5o4bqtbiB0w7RpIGzDoCB0w6FjIGdp4bqjICjEkcaw4bujYyBkw7luZyB24bubaSB0w7l5IGNo4buNbiAtQy8tYy8tLWFtZW5kKSIKIAotIzogYnVpbHRpbi9jb21taXQuYzoxNTA2IGJ1aWx0aW4vbG9nLmM6MTU2NCBidWlsdGluL21lcmdlLmM6Mjg5Ci0jOiBidWlsdGluL3B1bGwuYzoxNjMgYnVpbHRpbi9yZXZlcnQuYzoxMTAKKyM6IGJ1aWx0aW4vY29tbWl0LmM6MTUwNiBidWlsdGluL2xvZy5jOjE1NjUgYnVpbHRpbi9tZXJnZS5jOjI4OQorIzogYnVpbHRpbi9wdWxsLmM6MTY0IGJ1aWx0aW4vcmV2ZXJ0LmM6MTEwCiBtc2dpZCAiYWRkIFNpZ25lZC1vZmYtYnk6IgogbXNnc3RyICIobsOqbiBkw7luZykgdGjDqm0gZMOybmcgU2lnbmVkLW9mZi1ieToiCiAKQEAgLTExOTA2LDc1ICsxMTkzOCw3OCBAQAogbXNnc3RyICJnaXQgY29tbWl0LWdyYXBoIHJlYWQgWy0tb2JqZWN0LWRpciA8b2JqZGlyPl0iCiAKICM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTMgYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxOQotbXNnaWQgImdpdCBjb21taXQtZ3JhcGggdmVyaWZ5IFstLW9iamVjdC1kaXIgPG9iamRpcj5dIFstLXNoYWxsb3ddIgorbXNnaWQgIiIKKyJnaXQgY29tbWl0LWdyYXBoIHZlcmlmeSBbLS1vYmplY3QtZGlyIDxvYmpkaXI+XSBbLS1zaGFsbG93XSBbLS1bbm8tXXByb2dyZXNzXSIKIG1zZ3N0ciAiIgotImdpdCBjb21taXQtZ3JhcGggdmVyaWZ5IFstLW9iamVjdC1kaXIgPC90aMawL23hu6VjL8SR4buRaS90xrDhu6NuZz5dIFstLXNoYWxsb3ddIgorImdpdCBjb21taXQtZ3JhcGggdmVyaWZ5IFstLW9iamVjdC1kaXIgPC90aMawL23hu6VjL8SR4buRaS90xrDhu6NuZz5dIFstLXNoYWxsb3ddIFstLSIKKyJbbm8tXXByb2dyZXNzXSIKIAogIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxNCBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjI5CiBtc2dpZCAiIgogImdpdCBjb21taXQtZ3JhcGggd3JpdGUgWy0tb2JqZWN0LWRpciA8b2JqZGlyPl0gWy0tYXBwZW5kfC0tc3BsaXRdIFstLSIKLSJyZWFjaGFibGV8LS1zdGRpbi1wYWNrc3wtLXN0ZGluLWNvbW1pdHNdIDxzcGxpdCBvcHRpb25zPiIKKyJyZWFjaGFibGV8LS1zdGRpbi1wYWNrc3wtLXN0ZGluLWNvbW1pdHNdIFstLVtuby1dcHJvZ3Jlc3NdIDxzcGxpdCBvcHRpb25zPiIKIG1zZ3N0ciAiIgogImdpdCBjb21taXQtZ3JhcGggd3JpdGUgWy0tb2JqZWN0LWRpciA8L3RoxrAvbeG7pWMvxJHhu5FpL3TGsOG7o25nPl0gWy0tYXBwZW5kfC0tIgotInNwbGl0XSBbLS1yZWFjaGFibGV8LS1zdGRpbi1wYWNrc3wtLXN0ZGluLWNvbW1pdHNdIDxjw6FjIHTDuXkgY2jhu41uIGNoaWEgdMOhY2g+IgorInNwbGl0XSBbLS1yZWFjaGFibGV8LS1zdGRpbi1wYWNrc3wtLXN0ZGluLWNvbW1pdHNdIFstLVtuby1dcHJvZ3Jlc3NdIDxjw6FjICIKKyJ0w7l5IGNo4buNbiBjaGlhIHTDoWNoPiIKIAotIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzo1NCBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjEwMAotIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxNjEgYnVpbHRpbi9jb21taXQtZ3JhcGguYzoyMzcgYnVpbHRpbi9mZXRjaC5jOjE2MwotIzogYnVpbHRpbi9sb2cuYzoxNTg0CisjOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjU1IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTA3CisjOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE3MCBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjI1NCBidWlsdGluL2ZldGNoLmM6MTc4CisjOiBidWlsdGluL2xvZy5jOjE1ODUKIG1zZ2lkICJkaXIiCiBtc2dzdHIgInRt4bulYyIKIAotIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzo1NSBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjEwMQotIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxNjIgYnVpbHRpbi9jb21taXQtZ3JhcGguYzoyMzgKKyM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6NTYgYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxMDgKKyM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTcxIGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MjU1CiBtc2dpZCAiVGhlIG9iamVjdCBkaXJlY3RvcnkgdG8gc3RvcmUgdGhlIGdyYXBoIgogbXNnc3RyICJUaMawIG3hu6VjIMSR4buRaSB0xrDhu6NuZyDEkeG7gyBsxrB1IMSR4buTIHRo4buLIgogCi0jOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjU3CisjOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjU4CiBtc2dpZCAiaWYgdGhlIGNvbW1pdC1ncmFwaCBpcyBzcGxpdCwgb25seSB2ZXJpZnkgdGhlIHRpcCBmaWxlIgogbXNnc3RyICIiCiAibuG6v3UgxJHhu5MtdGjhu4stY8OhYy1s4bqnbi1jaHV54buDbi1naWFvIGLhu4sgY2hpYSBj4bqvdCwgdGjDrCBjaOG7iSB0aOG6qW0gdHJhIHThuq1wIHRpbiDEkeG7iW5oIgogCi0jOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjczIGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTE2CisjOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjgwIGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTI1CiAjLCBjLWZvcm1hdAogbXNnaWQgIkNvdWxkIG5vdCBvcGVuIGNvbW1pdC1ncmFwaCAnJXMnIgogbXNnc3RyICJLaMO0bmcgdGjhu4MgbeG7nyDEkeG7kyB0aOG7iyBjaHV54buDbiBnaWFvIOKAnCVz4oCdIgogCi0jOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE2NAorIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxNzMKIG1zZ2lkICJzdGFydCB3YWxrIGF0IGFsbCByZWZzIgogbXNnc3RyICJi4bqvdCDEkeG6p3UgZGkgY2h1eeG7g24gdOG6oWkgbeG7jWkgdGhhbSBjaGnhur91IgogCi0jOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE2NgorIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxNzUKIG1zZ2lkICJzY2FuIHBhY2staW5kZXhlcyBsaXN0ZWQgYnkgc3RkaW4gZm9yIGNvbW1pdHMiCiBtc2dzdHIgIiIKICJxdcOpdCBkw7MgY8OhYyBt4bulYyBs4bulYyBnw7NpIMSRxrDhu6NjIGxp4buHdCBrw6ogYuG7n2kgxJHhuqd1IHbDoG8gdGnDqnUgY2h14bqpbiBjaG8gY8OhYyBs4bqnbiAiCiAiY2h1eeG7g24gZ2lhbyIKIAotIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxNjgKKyM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTc3CiBtc2dpZCAic3RhcnQgd2FsayBhdCBjb21taXRzIGxpc3RlZCBieSBzdGRpbiIKIG1zZ3N0ciAiIgogImLhuq90IMSR4bqndSBkaSBjaHV54buDbiB04bqhaSBjw6FjIGzhuqduIGNodXnhu4NuIGdpYW8gxJHGsOG7o2MgbGnhu4d0IGvDqiBi4bufaSDEkeG6p3UgdsOgbyB0acOqdSBjaHXhuqluIgogCi0jOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE3MAorIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxNzkKIG1zZ2lkICJpbmNsdWRlIGFsbCBjb21taXRzIGFscmVhZHkgaW4gdGhlIGNvbW1pdC1ncmFwaCBmaWxlIgogbXNnc3RyICIiCiAiYmFvIGfhu5NtIG3hu41pIGzhuqduIGNodXnhu4NuIGdpYW8gxJHDoyBz4bq1biBjw7MgdHJvbmfGsOG7nWkgdOG6rXAgdGluIMSR4buTLXRo4buLLWPDoWMtbOG6p24tY2h1eeG7g24tIgogImdpYW8iCiAKLSM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTcyCisjOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE4MgogbXNnaWQgImFsbG93IHdyaXRpbmcgYW4gaW5jcmVtZW50YWwgY29tbWl0LWdyYXBoIGZpbGUiCiBtc2dzdHIgImNobyBwaMOpcCBnaGkgbeG7mXQgdOG6rXAgdGluIMSR4buTIGjhu41hIGPDoWMgbOG6p24gY2h1eeG7g24gZ2lhbyBs4bubbiBsw6puIgogCi0jOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE3NCBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE3OAorIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxODQgYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxODgKIG1zZ2lkICJtYXhpbXVtIG51bWJlciBvZiBjb21taXRzIGluIGEgbm9uLWJhc2Ugc3BsaXQgY29tbWl0LWdyYXBoIgogbXNnc3RyICIiCiAic+G7kSBsxrDhu6NuZyB04buRaSDEkWEgY+G7p2EgY8OhYyBs4bqnbiBjaHV54buDbiBnaWFvIHRyb25nIG3hu5l0IMSR4buTLXRo4buLLWPDoWMtbOG6p24tY2h1eeG7g24tZ2lhbyAiCiAiY2hpYSBj4bqvdCBraMO0bmctY8ahLXPhu58iCiAKLSM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTc2CisjOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE4NgogbXNnaWQgIm1heGltdW0gcmF0aW8gYmV0d2VlbiB0d28gbGV2ZWxzIG9mIGEgc3BsaXQgY29tbWl0LWdyYXBoIgogbXNnc3RyICJ04bu3IGzhu4cgdOG7kWkgxJFhIGdp4buvYSBoYWkgbeG7qWMgY+G7p2EgbeG7mXQgxJHhu5MtdGjhu4stY8OhYy1s4bqnbi1jaHV54buDbi1naWFvIGNoaWEgY+G6r3QiCiAKLSM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTkxCisjOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjIwNAogbXNnaWQgInVzZSBhdCBtb3N0IG9uZSBvZiAtLXJlYWNoYWJsZSwgLS1zdGRpbi1jb21taXRzLCBvciAtLXN0ZGluLXBhY2tzIgogbXNnc3RyICIiCiAia2jDtG5nIHRo4buDIHPhu60gZOG7pW5nIGjGoW4gbeG7mXQgLS1yZWFjaGFibGUsIC0tc3RkaW4tY29tbWl0cywgaGF5IC0tc3RkaW4tcGFja3MiCkBAIC0xMjI5Miw1NyArMTIzMjcsNTcgQEAKIG1zZ2lkICJwcmludCBzaXplcyBpbiBodW1hbiByZWFkYWJsZSBmb3JtYXQiCiBtc2dzdHIgImhp4buDbiB0aOG7iyBrw61jaCBj4buhIHRoZW8gxJHhu4tuaCBk4bqhbmcgZMOgbmggY2hvIG5nxrDhu51pIMSR4buNYyIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjI3CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6MjYKIG1zZ2lkICJnaXQgZGVzY3JpYmUgWzxvcHRpb25zPl0gWzxjb21taXQtaXNoPi4uLl0iCiBtc2dzdHIgImdpdCBkZXNjcmliZSBbPGPDoWMgdMO5eSBjaOG7jW4+XSA8Y29tbWl0LWlzaD4qIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6MjgKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzoyNwogbXNnaWQgImdpdCBkZXNjcmliZSBbPG9wdGlvbnM+XSAtLWRpcnR5IgogbXNnc3RyICJnaXQgZGVzY3JpYmUgWzxjw6FjIHTDuXkgY2jhu41uPl0gLS1kaXJ0eSIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjYzCisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NjIKIG1zZ2lkICJoZWFkIgogbXNnc3RyICJwaMOtYSB0csaw4bubYyIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjYzCisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NjIKIG1zZ2lkICJsaWdodHdlaWdodCIKIG1zZ3N0ciAiaOG6oW5nIG5o4bq5IgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NjMKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo2MgogbXNnaWQgImFubm90YXRlZCIKIG1zZ3N0ciAiY8OzIGRp4buFbiBnaeG6o2kiCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzoyNzMKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzoyNzUKICMsIGMtZm9ybWF0CiBtc2dpZCAiYW5ub3RhdGVkIHRhZyAlcyBub3QgYXZhaWxhYmxlIgogbXNnc3RyICJ0aOG6uyDEkcOjIMSRxrDhu6NjIGdoaSBjaMO6ICVzIGtow7RuZyBz4bq1biDEkeG7gyBkw7luZyIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjI3NworIzogYnVpbHRpbi9kZXNjcmliZS5jOjI3OQogIywgYy1mb3JtYXQKIG1zZ2lkICJhbm5vdGF0ZWQgdGFnICVzIGhhcyBubyBlbWJlZGRlZCBuYW1lIgogbXNnc3RyICJ0aOG6uyDEkcaw4bujYyBjaMO6IGdp4bqjaSAlcyBraMO0bmcgY8OzIHTDqm4gbmjDum5nIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6Mjc5CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6MjgxCiAjLCBjLWZvcm1hdAogbXNnaWQgInRhZyAnJXMnIGlzIHJlYWxseSAnJXMnIGhlcmUiCiBtc2dzdHIgInRo4bq7IOKAnCVz4oCdIMSRw6MgdGjhu7FjIHPhu7Eg4bufIMSRw6J5IOKAnCVz4oCdIHLhu5NpIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6MzIzCisjOiBidWlsdGluL2Rlc2NyaWJlLmM6MzI1CiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vIHRhZyBleGFjdGx5IG1hdGNoZXMgJyVzJyIKIG1zZ3N0ciAia2jDtG5nIGPDsyB0aOG6uyBuw6BvIGto4bubcCBjaMOtbmggeMOhYyB24bubaSDigJwlc+KAnSIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjMyNQorIzogYnVpbHRpbi9kZXNjcmliZS5jOjMyNwogIywgYy1mb3JtYXQKIG1zZ2lkICJObyBleGFjdCBtYXRjaCBvbiByZWZzIG9yIHRhZ3MsIHNlYXJjaGluZyB0byBkZXNjcmliZVxuIgogbXNnc3RyICJLaMO0bmcgY8OzIHRoYW0gY2hp4bq/dSBoYXkgdGjhursga2jhu5twIMSRw7puZywgxJFhbmcgdMOsbSBraeG6v20gbcO0IHThuqNcbiIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjM3OQorIzogYnVpbHRpbi9kZXNjcmliZS5jOjM4MQogIywgYy1mb3JtYXQKIG1zZ2lkICJmaW5pc2hlZCBzZWFyY2ggYXQgJXNcbiIKIG1zZ3N0ciAidmnhu4djIHTDrG0ga2nhur9tIMSRw6Mga+G6v3QgdGjDumMgdOG6oWkgJXNcbiIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjQwNQorIzogYnVpbHRpbi9kZXNjcmliZS5jOjQwNwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiTm8gYW5ub3RhdGVkIHRhZ3MgY2FuIGRlc2NyaWJlICclcycuXG4iCkBAIC0xMjM1MSw3ICsxMjM4Niw3IEBACiAiS2jDtG5nIGPDsyB0aOG6uyDEkcaw4bujYyBjaMO6IGdp4bqjaSBuw6BvIMSRxrDhu6NjIG3DtCB04bqjIGzDoCDigJwlc+KAnS5cbiIKICJUdXkgbmhpw6puLCDhu58gxJHDonkgY8OzIG5o4buvbmcgdGjhursga2jDtG5nIMSRxrDhu6NjIGNow7ogZ2nhuqNpOiBow6N5IHRo4butIC0tdGFncy4iCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo0MDkKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo0MTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIk5vIHRhZ3MgY2FuIGRlc2NyaWJlICclcycuXG4iCkBAIC0xMjM2MCwxMiArMTIzOTUsMTIgQEAKICJLaMO0bmcgY8OzIHRo4bq7IGPDsyB0aOG7gyBtw7QgdOG6oyDigJwlc+KAnS5cbiIKICJIw6N5IHRo4butIC0tYWx3YXlzLCBob+G6t2MgdOG6oW8gbeG7mXQgc+G7kSB0aOG6uy4iCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo0MzkKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo0NDEKICMsIGMtZm9ybWF0CiBtc2dpZCAidHJhdmVyc2VkICVsdSBjb21taXRzXG4iCiBtc2dzdHIgIsSRw6MgeHV5w6puICVsdSBxdWEgbOG6p24gY2h1eeG7g24gZ2lhb1xuIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NDQyCisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NDQ0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJtb3JlIHRoYW4gJWkgdGFncyBmb3VuZDsgbGlzdGVkICVpIG1vc3QgcmVjZW50XG4iCkBAIC0xMjM3NCw5MCArMTI0MDksOTAgQEAKICJ0w6xtIHRo4bqleSBuaGnhu4F1IGjGoW4gJWkgdGjhurs7IMSRw6MgbGnhu4d0IGvDqiAlaSBjw6FpIGfhuqduXG4iCiAixJHDonkgbmjhuqV0IGLhu48gxJFpIHTDrG0ga2nhur9tIHThuqFpICVzXG4iCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1MTAKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1MTIKICMsIGMtZm9ybWF0CiBtc2dpZCAiZGVzY3JpYmUgJXNcbiIKIG1zZ3N0ciAibcO0IHThuqMgJXNcbiIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjUxMworIzogYnVpbHRpbi9kZXNjcmliZS5jOjUxNQogIywgYy1mb3JtYXQKIG1zZ2lkICJOb3QgYSB2YWxpZCBvYmplY3QgbmFtZSAlcyIKIG1zZ3N0ciAiS2jDtG5nIHBo4bqjaSB0w6puIMSR4buRaSB0xrDhu6NuZyAlcyBo4bujcCBs4buHIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NTIxCisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NTIzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIGlzIG5laXRoZXIgYSBjb21taXQgbm9yIGJsb2IiCiBtc2dzdHIgIiVzIGtow7RuZyBwaOG6o2kgbMOgIG3hu5l0IGzhuqduIGNvbW1pdCBjxaluZyBraMO0bmcgcGjhuqNpIGJsb2IiCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1MzUKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1MzcKIG1zZ2lkICJmaW5kIHRoZSB0YWcgdGhhdCBjb21lcyBhZnRlciB0aGUgY29tbWl0IgogbXNnc3RyICJ0w6xtIGPDoWMgdGjhursgbcOgIG7DsyDEkeG6v24gdHLGsOG7m2MgbOG6p24gY2h1eeG7g24gZ2lhbyIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjUzNgorIzogYnVpbHRpbi9kZXNjcmliZS5jOjUzOAogbXNnaWQgImRlYnVnIHNlYXJjaCBzdHJhdGVneSBvbiBzdGRlcnIiCiBtc2dzdHIgImNoaeG6v24gbMaw4bujYyB0w6xtIGtp4bq/bSBn4buhIGzhu5dpIHRyw6puIMSR4bqndSByYSBs4buXaSBjaHXhuqluIHN0ZGVyciIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjUzNworIzogYnVpbHRpbi9kZXNjcmliZS5jOjUzOQogbXNnaWQgInVzZSBhbnkgcmVmIgogbXNnc3RyICJkw7luZyByZWYgYuG6pXQga+G7syIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjUzOAorIzogYnVpbHRpbi9kZXNjcmliZS5jOjU0MAogbXNnaWQgInVzZSBhbnkgdGFnLCBldmVuIHVuYW5ub3RhdGVkIgogbXNnc3RyICJkw7luZyB0aOG6uyBi4bqldCBr4buzLCBj4bqjIGtoaSDigJx1bmFubm90YXRlZOKAnSIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjUzOQorIzogYnVpbHRpbi9kZXNjcmliZS5jOjU0MQogbXNnaWQgImFsd2F5cyB1c2UgbG9uZyBmb3JtYXQiCiBtc2dzdHIgImx1w7RuIGTDuW5nIMSR4buLbmggZOG6oW5nIGTDoGkiCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1NDAKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1NDIKIG1zZ2lkICJvbmx5IGZvbGxvdyBmaXJzdCBwYXJlbnQiCiBtc2dzdHIgImNo4buJIHRoZW8gY2hhIG3hurkgxJHhuqd1IHRpw6puIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NTQzCisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NTQ1CiBtc2dpZCAib25seSBvdXRwdXQgZXhhY3QgbWF0Y2hlcyIKIG1zZ3N0ciAiY2jhu4kgeHXhuqV0IG5o4buvbmcgZ8OsIGto4bubcCBjaMOtbmggeMOhYyIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjU0NQorIzogYnVpbHRpbi9kZXNjcmliZS5jOjU0NwogbXNnaWQgImNvbnNpZGVyIDxuPiBtb3N0IHJlY2VudCB0YWdzIChkZWZhdWx0OiAxMCkiCiBtc2dzdHIgImNvaSBuaMawIDxuPiB0aOG6uyBn4bqnbiDEkcOieSBuaOG6pXQgKG3hurdjIMSR4buLbmg6IDEwKSIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjU0NworIzogYnVpbHRpbi9kZXNjcmliZS5jOjU0OQogbXNnaWQgIm9ubHkgY29uc2lkZXIgdGFncyBtYXRjaGluZyA8cGF0dGVybj4iCiBtc2dzdHIgImNo4buJIGPDom4gbmjhuq9jIMSR4bq/biBuaOG7r25nIHRo4bq7IGto4bubcCB24bubaSA8beG6q3U+IgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NTQ5CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NTUxCiBtc2dpZCAiZG8gbm90IGNvbnNpZGVyIHRhZ3MgbWF0Y2hpbmcgPHBhdHRlcm4+IgogbXNnc3RyICJraMO0bmcgY29pIHLhurFuZyBjw6FjIHRo4bq7IGto4bubcCB24bubaSA8beG6q3U+IgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NTUxIGJ1aWx0aW4vbmFtZS1yZXYuYzo0MjIKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1NTMgYnVpbHRpbi9uYW1lLXJldi5jOjQyNgogbXNnaWQgInNob3cgYWJicmV2aWF0ZWQgY29tbWl0IG9iamVjdCBhcyBmYWxsYmFjayIKIG1zZ3N0ciAiaGnhu4NuIHRo4buLIMSR4buRaSB0xrDhu6NuZyBjaHV54buDbiBnaWFvIHbhuq9uIHThuq90IG5oxrAgbMOgIGZhbGxiYWNrIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NTUyIGJ1aWx0aW4vZGVzY3JpYmUuYzo1NTUKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1NTQgYnVpbHRpbi9kZXNjcmliZS5jOjU1NwogbXNnaWQgIm1hcmsiCiBtc2dzdHIgImThuqV1IgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NTUzCisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NTU1CiBtc2dpZCAiYXBwZW5kIDxtYXJrPiBvbiBkaXJ0eSB3b3JraW5nIHRyZWUgKGRlZmF1bHQ6IFwiLWRpcnR5XCIpIgogbXNnc3RyICJ0aMOqbSA8ZOG6pXU+IHRyw6puIGPDonkgdGjGsCBt4bulYyBsw6BtIHZp4buHYyBi4bqpbiAobeG6t2MgxJHhu4tuaCBcIi1kaXJ0eVwiKSIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjU1NgorIzogYnVpbHRpbi9kZXNjcmliZS5jOjU1OAogbXNnaWQgImFwcGVuZCA8bWFyaz4gb24gYnJva2VuIHdvcmtpbmcgdHJlZSAoZGVmYXVsdDogXCItYnJva2VuXCIpIgogbXNnc3RyICJ0aMOqbSA8ZOG6pXU+IHRyw6puIGPDonkgdGjGsCBt4bulYyBsw6BtIHZp4buHYyBi4buLIGjhu49uZyAobeG6t2MgxJHhu4tuaCBcIi1icm9rZW5cIikiCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1NzQKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1NzYKIG1zZ2lkICItLWxvbmcgaXMgaW5jb21wYXRpYmxlIHdpdGggLS1hYmJyZXY9MCIKIG1zZ3N0ciAiLS1sb25nIGzDoCB4dW5nIGto4bqvYyB24bubaSB0w7l5IGNo4buNbiAtLWFiYnJldj0wIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NjAzCisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NjA1CiBtc2dpZCAiTm8gbmFtZXMgZm91bmQsIGNhbm5vdCBkZXNjcmliZSBhbnl0aGluZy4iCiBtc2dzdHIgIktow7RuZyB0w6xtIHRo4bqleSBjw6FjIHTDqm4sIGtow7RuZyB0aOG7gyBtw7QgdOG6oyBnw6wgY+G6oy4iCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo2NTQKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo2NTYKIG1zZ2lkICItLWRpcnR5IGlzIGluY29tcGF0aWJsZSB3aXRoIGNvbW1pdC1pc2hlcyIKIG1zZ3N0ciAiLS1kaXJ0eSBsw6AgeHVuZyBraOG6r2MgduG7m2kgY8OhYyB0w7l5IGNo4buNbiBjb21taXQtaXNoIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NjU2CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NjU4CiBtc2dpZCAiLS1icm9rZW4gaXMgaW5jb21wYXRpYmxlIHdpdGggY29tbWl0LWlzaGVzIgogbXNnc3RyICItLWJyb2tlbiBsw6AgeHVuZyBraOG6r2MgduG7m2kgY29tbWl0LWlzaGVzIgogCkBAIC0xMjQ5NiwyNyArMTI1MzEsMjcgQEAKICJnaXQgZGlmZnRvb2wgWzxjw6FjIHTDuXkgY2jhu41uPl0gWzxs4bqnbl9jaHV54buDbl9naWFvPiBbPGzhuqduX2NodXnhu4NuX2dpYW8+XV0gWy0tXSA8LyIKICLEkcaw4budbmcvZOG6q24+4oCmXSIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjI1MworIzogYnVpbHRpbi9kaWZmdG9vbC5jOjI2MAogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQ6ICVkIgogbXNnc3RyICJn4bq3cCBs4buXaTogJWQiCiAKLSM6IGJ1aWx0aW4vZGlmZnRvb2wuYzoyOTUKKyM6IGJ1aWx0aW4vZGlmZnRvb2wuYzozMDIKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHJlYWQgc3ltbGluayAlcyIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIMSR4buNYyBsacOqbiBr4bq/dCBt4buBbSAlcyIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjI5NworIzogYnVpbHRpbi9kaWZmdG9vbC5jOjMwNAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcmVhZCBzeW1saW5rIGZpbGUgJXMiCiBtc2dzdHIgImtow7RuZyDEkeG7jWMgxJHGsOG7o2MgdOG6rXAgdGluIGxpw6puIGvhur90IG3hu4FtICVzIgogCi0jOiBidWlsdGluL2RpZmZ0b29sLmM6MzA1CisjOiBidWlsdGluL2RpZmZ0b29sLmM6MzEyCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCByZWFkIG9iamVjdCAlcyBmb3Igc3ltbGluayAlcyIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIMSR4buNYyDEkeG7kWkgdMaw4bujbmcgJXMgY2hvIGxpw6puIGvhur90IG3hu4FtICVzIgogCi0jOiBidWlsdGluL2RpZmZ0b29sLmM6NDA2CisjOiBidWlsdGluL2RpZmZ0b29sLmM6NDEzCiBtc2dpZCAiIgogImNvbWJpbmVkIGRpZmYgZm9ybWF0cygnLWMnIGFuZCAnLS1jYycpIGFyZSBub3Qgc3VwcG9ydGVkIGluXG4iCiAiZGlyZWN0b3J5IGRpZmYgbW9kZSgnLWQnIGFuZCAnLS1kaXItZGlmZicpLiIKQEAgLTEyNTI0LDUzICsxMjU1OSw1MyBAQAogImPDoWMgxJHhu4tuaCBk4bqhbmcgZGlmZiB04buVIGjhu6NwKOKAnC1j4oCdIHbDoCDigJwtLWNj4oCdKSBjaMawYSDEkcaw4bujYyBo4buXIHRy4bujIHRyb25nXG4iCiAiY2jhur8gxJHhu5kgZGlmZiB0aMawIG3hu6VjKOKAnC1k4oCdIHbDoCDigJwtLWRpci1kaWZm4oCdKS4iCiAKLSM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo2MjYKKyM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo2MzQKICMsIGMtZm9ybWF0CiBtc2dpZCAiYm90aCBmaWxlcyBtb2RpZmllZDogJyVzJyBhbmQgJyVzJy4iCiBtc2dzdHIgImPhuqMgaGFpIHThuq1wIHRpbiDEkcOjIGLhu4sgc+G7rWE6IOKAnCVz4oCdIHbDoCDigJwlc+KAnS4iCiAKLSM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo2MjgKKyM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo2MzYKIG1zZ2lkICJ3b3JraW5nIHRyZWUgZmlsZSBoYXMgYmVlbiBsZWZ0LiIKIG1zZ3N0ciAiY8OieSBsw6BtIHZp4buHYyDhu58gYsOqbiB0csOhaS4iCiAKLSM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo2MzkKKyM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo2NDcKICMsIGMtZm9ybWF0CiBtc2dpZCAidGVtcG9yYXJ5IGZpbGVzIGV4aXN0IGluICclcycuIgogbXNnc3RyICJjw6FjIHThuq1wIHRpbiB04bqhbSDEkcOjIHPhurVuIGPDsyB0cm9uZyDigJwlc+KAnS4iCiAKLSM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo2NDAKKyM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo2NDgKIG1zZ2lkICJ5b3UgbWF5IHdhbnQgdG8gY2xlYW51cCBvciByZWNvdmVyIHRoZXNlLiIKIG1zZ3N0ciAiYuG6oW4gY8OzIGzhur0gbXXhu5FuIGThu41uIGThurlwIGhheSBwaOG7pWMgaOG7k2kg4bufIMSRw6J5LiIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjY4OQorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjY5NwogbXNnaWQgInVzZSBgZGlmZi5ndWl0b29sYCBpbnN0ZWFkIG9mIGBkaWZmLnRvb2xgIgogbXNnc3RyICJkw7luZyDigJxkaWZmLmd1aXRvb2zigJwgdGhheSB2w6wgZMO5bmcg4oCcZGlmZi50b29s4oCcIgogCi0jOiBidWlsdGluL2RpZmZ0b29sLmM6NjkxCisjOiBidWlsdGluL2RpZmZ0b29sLmM6Njk5CiBtc2dpZCAicGVyZm9ybSBhIGZ1bGwtZGlyZWN0b3J5IGRpZmYiCiBtc2dzdHIgInRo4buxYyBoaeG7h24gbeG7mXQgZGlmZiB0b8OgbiB0aMawIG3hu6VjIgogCi0jOiBidWlsdGluL2RpZmZ0b29sLmM6NjkzCisjOiBidWlsdGluL2RpZmZ0b29sLmM6NzAxCiBtc2dpZCAiZG8gbm90IHByb21wdCBiZWZvcmUgbGF1bmNoaW5nIGEgZGlmZiB0b29sIgogbXNnc3RyICLEkeG7q25nIG5o4bqvYyBraGkga2jhu59pIGNo4bqheSBjw7RuZyBj4bulIGRpZmYiCiAKLSM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo2OTgKKyM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo3MDYKIG1zZ2lkICJ1c2Ugc3ltbGlua3MgaW4gZGlyLWRpZmYgbW9kZSIKIG1zZ3N0ciAiZMO5bmcgbGnDqm4ga+G6v3QgbeG7gW0gdHJvbmcgZGlmZi10aMawLW3hu6VjIgogCi0jOiBidWlsdGluL2RpZmZ0b29sLmM6Njk5CisjOiBidWlsdGluL2RpZmZ0b29sLmM6NzA3CiBtc2dpZCAidG9vbCIKIG1zZ3N0ciAiY8O0bmcgY+G7pSIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjcwMAorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjcwOAogbXNnaWQgInVzZSB0aGUgc3BlY2lmaWVkIGRpZmYgdG9vbCIKIG1zZ3N0ciAiZMO5bmcgY8O0bmcgY+G7pSBkaWZmIMSRw6MgY2hvIgogCi0jOiBidWlsdGluL2RpZmZ0b29sLmM6NzAyCisjOiBidWlsdGluL2RpZmZ0b29sLmM6NzEwCiBtc2dpZCAicHJpbnQgYSBsaXN0IG9mIGRpZmYgdG9vbHMgdGhhdCBtYXkgYmUgdXNlZCB3aXRoIGAtLXRvb2xgIgogbXNnc3RyICJpbiByYSBkYW5oIHPDoWNoIGPDoWMgY8O0bmcgY+G7pSBkaWYgY8OhaSBtw6AgY8OzIHRo4bq7IGTDuW5nIHbhu5tpIOKAnC0tdG9vbOKAnCIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjcwNQorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjcxMwogbXNnaWQgIiIKICJtYWtlICdnaXQtZGlmZnRvb2wnIGV4aXQgd2hlbiBhbiBpbnZva2VkIGRpZmYgdG9vbCByZXR1cm5zIGEgbm9uIC0gemVybyBleGl0ICIKICJjb2RlIgpAQCAtMTI1NzgsMzEgKzEyNjEzLDMxIEBACiAibMOgbSBjaG8g4oCcZ2l0LWRpZmZ0b29s4oCdIHRob8OhdCBraGkgZ+G7jWkgY8O0bmcgY+G7pSBkaWZmIHRy4bqjIHbhu4EgbcOjIGtow7RuZyBwaOG6o2kgc+G7kSAiCiAia2jDtG5nIgogCi0jOiBidWlsdGluL2RpZmZ0b29sLmM6NzA4CisjOiBidWlsdGluL2RpZmZ0b29sLmM6NzE2CiBtc2dpZCAic3BlY2lmeSBhIGN1c3RvbSBjb21tYW5kIGZvciB2aWV3aW5nIGRpZmZzIgogbXNnc3RyICJjaOG7iSDEkeG7i25oIG3hu5l0IGzhu4duaCB0w7l5IMO9IMSR4buDIHhlbSBkaWZmIgogCi0jOiBidWlsdGluL2RpZmZ0b29sLmM6NzA5CisjOiBidWlsdGluL2RpZmZ0b29sLmM6NzE3CiBtc2dpZCAicGFzc2VkIHRvIGBkaWZmYCIKIG1zZ3N0ciAiY2h1eeG7g24gY2hvIOKAnGRpZmbigJ0iCiAKLSM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo3MjQKKyM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo3MzIKIG1zZ2lkICJkaWZmdG9vbCByZXF1aXJlcyB3b3JrdHJlZSBvciAtLW5vLWluZGV4IgogbXNnc3RyICJkaWZmdG9vbCBj4bqnbiBjw6J5IGzDoG0gdmnhu4djIGhv4bq3YyAtLW5vLWluZGV4IgogCi0jOiBidWlsdGluL2RpZmZ0b29sLmM6NzMxCisjOiBidWlsdGluL2RpZmZ0b29sLmM6NzM5CiBtc2dpZCAiLS1kaXItZGlmZiBpcyBpbmNvbXBhdGlibGUgd2l0aCAtLW5vLWluZGV4IgogbXNnc3RyICItLWRpci1kaWZmIHh1bmcga2jhuq9jIHbhu5tpIC0tbm8taW5kZXgiCiAKLSM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo3MzQKKyM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo3NDIKIG1zZ2lkICItLWd1aSwgLS10b29sIGFuZCAtLWV4dGNtZCBhcmUgbXV0dWFsbHkgZXhjbHVzaXZlIgogbXNnc3RyICItLWd1aSwgLS10b29sIHbDoCAtLWV4dGNtZCBsb+G6oWkgdOG7qyBs4bqrbiBuaGF1IgogCi0jOiBidWlsdGluL2RpZmZ0b29sLmM6NzQyCisjOiBidWlsdGluL2RpZmZ0b29sLmM6NzUwCiBtc2dpZCAibm8gPHRvb2w+IGdpdmVuIGZvciAtLXRvb2w9PHRvb2w+IgogbXNnc3RyICJjaMawYSDEkcawYSByYSA8Y8O0bmdfY+G7pT4gY2hvIC0tdG9vbD08Y8O0bmdfY+G7pT4iCiAKLSM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo3NDkKKyM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo3NTcKIG1zZ2lkICJubyA8Y21kPiBnaXZlbiBmb3IgLS1leHRjbWQ9PGNtZD4iCiBtc2dzdHIgImNoxrBhIMSRxrBhIHJhIDxs4buHbmg+IGNobyAtLWV4dGNtZD08bOG7h25oPiIKIApAQCAtMTI2NDEsMTYwICsxMjY3NiwxODQgQEAKIG1zZ2lkICJnaXQgZmFzdC1leHBvcnQgW3Jldi1saXN0LW9wdHNdIgogbXNnc3RyICJnaXQgZmFzdC1leHBvcnQgW3Jldi1saXN0LW9wdHNdIgogCi0jOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTEyNAorIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjg1MgorbXNnaWQgIkVycm9yOiBDYW5ub3QgZXhwb3J0IG5lc3RlZCB0YWdzIHVubGVzcyAtLW1hcmstdGFncyBpcyBzcGVjaWZpZWQuIgorbXNnc3RyICJM4buXaToga2jDtG5nIHRo4buDIHh14bqldCB0aOG6uyBs4buTbmcgbmhhdSB0cuG7qyBraGkgLS1tYXJrLXRhZ3MgxJHGsOG7o2MgY2jhu4kgxJHhu4tuaC4iCisKKyM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTUyCiBtc2dpZCAic2hvdyBwcm9ncmVzcyBhZnRlciA8bj4gb2JqZWN0cyIKIG1zZ3N0ciAiaGnhu4NuIHRo4buLIHRp4bq/biB0cmnhu4NuIHNhdSA8bj4gxJHhu5FpIHTGsOG7o25nIgogCi0jOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTEyNgorIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNTQKIG1zZ2lkICJzZWxlY3QgaGFuZGxpbmcgb2Ygc2lnbmVkIHRhZ3MiCiBtc2dzdHIgImNo4buNbiDEkWnhu4F1IGtoaeG7g24gY+G7p2EgdGjhursgxJHDoyBrw70iCiAKLSM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTI5CisjOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE1NwogbXNnaWQgInNlbGVjdCBoYW5kbGluZyBvZiB0YWdzIHRoYXQgdGFnIGZpbHRlcmVkIG9iamVjdHMiCiBtc2dzdHIgImNo4buNbiBz4buxIHjhu60gbMO9IGPhu6dhIGPDoWMgdGjhurssIGPDoWkgbcOgIMSRw6FuaCB0aOG6uyBjw6FjIMSR4buRaSB0xrDhu6NuZyDEkcaw4bujYyBs4buNYyByYSIKIAotIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExMzIKKyM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTYwCiBtc2dpZCAic2VsZWN0IGhhbmRsaW5nIG9mIGNvbW1pdCBtZXNzYWdlcyBpbiBhbiBhbHRlcm5hdGUgZW5jb2RpbmciCiBtc2dzdHIgIiIKICJjaOG7jW4gYuG7mSB44butIGzDvSBjaG8gY8OhYyBnaGkgY2jDuiBj4bunYSBs4bqnbiBjaHV54buDbiBnaWFvIHRoZW8gbeG7mXQgYuG7mSBtw6MgdGhheSB0aOG6vyIKIAotIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExMzUKKyM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTYzCiBtc2dpZCAiRHVtcCBtYXJrcyB0byB0aGlzIGZpbGUiCiBtc2dzdHIgIsSQ4buVIGPDoWMgxJHDoW5oIGThuqV1IG7DoHkgdsOgbyB04bqtcC10aW4iCiAKLSM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTM3CisjOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE2NQogbXNnaWQgIkltcG9ydCBtYXJrcyBmcm9tIHRoaXMgZmlsZSIKIG1zZ3N0ciAiTmjhuq1wIHbDoG8gxJHDoW5oIGThuqV1IHThu6sgdOG6rXAgdGluIG7DoHkiCiAKLSM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTM5CisjOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE2OQorbXNnaWQgIkltcG9ydCBtYXJrcyBmcm9tIHRoaXMgZmlsZSBpZiBpdCBleGlzdHMiCittc2dzdHIgIk5o4bqtcCB2w6BvIMSRw6FuaCBk4bqldSB04burIHThuq1wIHRpbiBz4bq1biBjw7MiCisKKyM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTcxCiBtc2dpZCAiRmFrZSBhIHRhZ2dlciB3aGVuIHRhZ3MgbGFjayBvbmUiCiBtc2dzdHIgIkzDoG0gZ2nhuqMgbeG7mXQgY8OhaSB0aOG6uyBraGkgdGjhursgYuG7iyB0aGnhur91IG3hu5l0IGPDoWkiCiAKLSM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTQxCisjOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE3MwogbXNnaWQgIk91dHB1dCBmdWxsIHRyZWUgZm9yIGVhY2ggY29tbWl0IgogbXNnc3RyICJYdeG6pXQgcmEgdG/DoG4gYuG7mSBjw6J5IGNobyBt4buXaSBs4bqnbiBjaHV54buDbiBnaWFvIgogCi0jOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE0MworIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNzUKIG1zZ2lkICJVc2UgdGhlIGRvbmUgZmVhdHVyZSB0byB0ZXJtaW5hdGUgdGhlIHN0cmVhbSIKIG1zZ3N0ciAiU+G7rSBk4bulbmcgdMOtbmggbsSDbmcgZG9uZSDEkeG7gyBjaOG6pW0gZOG7qXQgbHXhu5NuZyBk4buvIGxp4buHdSIKIAotIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNDQKKyM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTc2CiBtc2dpZCAiU2tpcCBvdXRwdXQgb2YgYmxvYiBkYXRhIgogbXNnc3RyICJC4buPIHF1YSBr4bq/dCB4deG6pXQgY+G7p2EgZOG7ryBsaeG7h3UgYmxvYiIKIAotIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNDUgYnVpbHRpbi9sb2cuYzoxNjMyCisjOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE3NyBidWlsdGluL2xvZy5jOjE2MzMKIG1zZ2lkICJyZWZzcGVjIgogbXNnc3RyICJyZWZzcGVjIgogCi0jOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE0NgorIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNzgKIG1zZ2lkICJBcHBseSByZWZzcGVjIHRvIGV4cG9ydGVkIHJlZnMiCiBtc2dzdHIgIsOBcCBk4bulbmcgcmVmc3BlYyBjaG8gcmVmcyDEkcOjIHh14bqldCIKIAotIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNDcKKyM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTc5CiBtc2dpZCAiYW5vbnltaXplIG91dHB1dCIKIG1zZ3N0ciAia+G6v3QgeHXhuqV0IGFub255bWl6ZSIKIAotIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNDkKKyM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTgxCiBtc2dpZCAiUmVmZXJlbmNlIHBhcmVudHMgd2hpY2ggYXJlIG5vdCBpbiBmYXN0LWV4cG9ydCBzdHJlYW0gYnkgb2JqZWN0IGlkIgogbXNnc3RyICIiCiAiQ8OhYyBjaGEgbeG6uSB0aGFtIGNoaeG6v3UgY8OhaSBtw6AgayB0cm9uZyBsdeG7k25nIGThu68gbGnhu4d1IGZhc3QtZXhwb3J0IGLhu59pIG3DoyBpZCDEkeG7kWkgIgogInTGsOG7o25nIgogCi0jOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE1MQorIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExODMKIG1zZ2lkICJTaG93IG9yaWdpbmFsIG9iamVjdCBpZHMgb2YgYmxvYnMvY29tbWl0cyIKIG1zZ3N0ciAiSGnhu4NuIHRo4buLIGPDoWMgbcOjIGlkIG5ndXnDqm4gZ+G7kWMgY+G7p2EgYmxvYnMvY29tbWl0cyIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjMwCisjOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE4NQorbXNnaWQgIkxhYmVsIHRhZ3Mgd2l0aCBtYXJrIGlkcyIKK21zZ3N0ciAiR+G6r24gbmjDo24gdGjhursgSUQgZOG6pXUiCisKKyM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMjIwCittc2dpZCAiQ2Fubm90IHBhc3MgYm90aCAtLWltcG9ydC1tYXJrcyBhbmQgLS1pbXBvcnQtbWFya3MtaWYtZXhpc3RzIgorbXNnc3RyICJLaMO0bmcgdGjhu4MgY2h1eeG7g24gcXVhIGPhuqMgaGFpIC0taW1wb3J0LW1hcmtzIHbDoCAtLWltcG9ydC1tYXJrcy1pZi1leGlzdHMiCisKKyM6IGJ1aWx0aW4vZmV0Y2guYzozNAogbXNnaWQgImdpdCBmZXRjaCBbPG9wdGlvbnM+XSBbPHJlcG9zaXRvcnk+IFs8cmVmc3BlYz4uLi5dXSIKIG1zZ3N0ciAiZ2l0IGZldGNoIFs8Y8OhYyB0w7l5IGNo4buNbj5dIFs8a2hvLWNo4bupYT4gWzxyZWZzcGVjPuKApl1dIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MzEKKyM6IGJ1aWx0aW4vZmV0Y2guYzozNQogbXNnaWQgImdpdCBmZXRjaCBbPG9wdGlvbnM+XSA8Z3JvdXA+IgogbXNnc3RyICJnaXQgZmV0Y2ggWzxjw6FjIHTDuXkgY2jhu41uPl0gWzxuaMOzbT4iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzozMgorIzogYnVpbHRpbi9mZXRjaC5jOjM2CiBtc2dpZCAiZ2l0IGZldGNoIC0tbXVsdGlwbGUgWzxvcHRpb25zPl0gWyg8cmVwb3NpdG9yeT4gfCA8Z3JvdXA+KS4uLl0iCiBtc2dzdHIgImdpdCBmZXRjaCAtLW11bHRpcGxlIFs8Y8OhYyB0w7l5IGNo4buNbj5dIFsoPGtobz4gfCA8bmjDs20+KeKApl0iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzozMworIzogYnVpbHRpbi9mZXRjaC5jOjM3CiBtc2dpZCAiZ2l0IGZldGNoIC0tYWxsIFs8b3B0aW9ucz5dIgogbXNnc3RyICJnaXQgZmV0Y2ggLS1hbGwgWzxjw6FjIHTDuXkgY2jhu41uPl0iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxMjUgYnVpbHRpbi9wdWxsLmM6MjAzCisjOiBidWlsdGluL2ZldGNoLmM6MTE1Cittc2dpZCAiZmV0Y2gucGFyYWxsZWwgY2Fubm90IGJlIG5lZ2F0aXZlIgorbXNnc3RyICJmZXRjaC5wYXJhbGxlbCBraMO0bmcgdGjhu4Mgw6JtIgorCisjOiBidWlsdGluL2ZldGNoLmM6MTM4IGJ1aWx0aW4vcHVsbC5jOjIwNAogbXNnaWQgImZldGNoIGZyb20gYWxsIHJlbW90ZXMiCiBtc2dzdHIgImzhuqV5IHbhu4EgdOG7qyB04bqldCBj4bqjIGPDoWMgbcOheSBjaOG7pyIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjEyNyBidWlsdGluL3B1bGwuYzoyMDYKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNDAgYnVpbHRpbi9wdWxsLmM6MjQ4Cittc2dpZCAic2V0IHVwc3RyZWFtIGZvciBnaXQgcHVsbC9mZXRjaCIKK21zZ3N0ciAixJHhurd0IHRoxrDhu6NuZyBuZ3Xhu5NuIGNobyBnaXQgcHVsbC9mZXRjaCIKKworIzogYnVpbHRpbi9mZXRjaC5jOjE0MiBidWlsdGluL3B1bGwuYzoyMDcKIG1zZ2lkICJhcHBlbmQgdG8gLmdpdC9GRVRDSF9IRUFEIGluc3RlYWQgb2Ygb3ZlcndyaXRpbmciCiBtc2dzdHIgIm7hu5FpIHRow6ptIHbDoG8gLmdpdC9GRVRDSF9IRUFEIHRoYXkgdsOsIGdoaSDEkcOoIGzDqm4gbsOzIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTI5IGJ1aWx0aW4vcHVsbC5jOjIwOQorIzogYnVpbHRpbi9mZXRjaC5jOjE0NCBidWlsdGluL3B1bGwuYzoyMTAKIG1zZ2lkICJwYXRoIHRvIHVwbG9hZCBwYWNrIG9uIHJlbW90ZSBlbmQiCiBtc2dzdHIgIsSRxrDhu51uZyBk4bqrbiDEkeG6v24gZ8OzaSB04bqjaSBsw6puIHRyw6puIG3DoXkgY2jhu6cgY3Xhu5FpIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTMwCisjOiBidWlsdGluL2ZldGNoLmM6MTQ1CiBtc2dpZCAiZm9yY2Ugb3ZlcndyaXRlIG9mIGxvY2FsIHJlZmVyZW5jZSIKIG1zZ3N0ciAiw6lwIGJ14buZYyBnaGkgxJHDqCBsw6puIHRoYW0gY2hp4bq/dSBu4buZaSBi4buZIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTMyCisjOiBidWlsdGluL2ZldGNoLmM6MTQ3CiBtc2dpZCAiZmV0Y2ggZnJvbSBtdWx0aXBsZSByZW1vdGVzIgogbXNnc3RyICJs4bqleSB04burIG5oaeG7gXUgbcOheSBjaOG7pyBjw7luZyBsw7pjIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTM0IGJ1aWx0aW4vcHVsbC5jOjIxMworIzogYnVpbHRpbi9mZXRjaC5jOjE0OSBidWlsdGluL3B1bGwuYzoyMTQKIG1zZ2lkICJmZXRjaCBhbGwgdGFncyBhbmQgYXNzb2NpYXRlZCBvYmplY3RzIgogbXNnc3RyICJs4bqleSB04bqldCBj4bqjIGPDoWMgdGjhursgY8O5bmcgduG7m2kgY8OhYyDEkeG7kWkgdMaw4bujbmcgbGnDqm4gcXVhbiDEkeG6v24gbsOzIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTM2CisjOiBidWlsdGluL2ZldGNoLmM6MTUxCiBtc2dpZCAiZG8gbm90IGZldGNoIGFsbCB0YWdzICgtLW5vLXRhZ3MpIgogbXNnc3RyICJraMO0bmcgbOG6pXkgdOG6pXQgY+G6oyBjw6FjIHRo4bq7ICgtLW5vLXRhZ3MpIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTM4CisjOiBidWlsdGluL2ZldGNoLmM6MTUzCiBtc2dpZCAibnVtYmVyIG9mIHN1Ym1vZHVsZXMgZmV0Y2hlZCBpbiBwYXJhbGxlbCIKIG1zZ3N0ciAic+G7kSBsxrDhu6NuZyBtw7QtxJF1bi1jb24gxJHGsOG7o2MgbOG6pXkgxJHhu5NuZyB0aOG7nWkiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNDAgYnVpbHRpbi9wdWxsLmM6MjE2CisjOiBidWlsdGluL2ZldGNoLmM6MTU1IGJ1aWx0aW4vcHVsbC5jOjIxNwogbXNnaWQgInBydW5lIHJlbW90ZS10cmFja2luZyBicmFuY2hlcyBubyBsb25nZXIgb24gcmVtb3RlIgogbXNnc3RyICIiCiAiY+G6r3QgY+G7pXQgKHBydW5lKSBjw6FjIG5ow6FuaCDigJxyZW1vdGUtdHJhY2tpbmfigJ0ga2jDtG5nIGPDsm4gdOG7k24gdOG6oWkgdHLDqm4gbcOheSBjaOG7pyAiCiAibuG7r2EiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNDIKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNTcKIG1zZ2lkICJwcnVuZSBsb2NhbCB0YWdzIG5vIGxvbmdlciBvbiByZW1vdGUgYW5kIGNsb2JiZXIgY2hhbmdlZCB0YWdzIgogbXNnc3RyICJj4bqvdCB4w6ltIGPDoWMgdGjhursgbuG7mWkgYuG7mSBraMO0bmcgY8OybiDhu58gbcOheSBjaOG7pyB2w6AgeMOzYSBjw6FjIHRo4bq7IMSRw6MgdGhheSDEkeG7lWkiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNDMgYnVpbHRpbi9mZXRjaC5jOjE2NiBidWlsdGluL3B1bGwuYzoxNDAKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNTggYnVpbHRpbi9mZXRjaC5jOjE4MSBidWlsdGluL3B1bGwuYzoxNDEKIG1zZ2lkICJvbi1kZW1hbmQiCiBtc2dzdHIgImtoaS1j4bqnbiIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE0NAorIzogYnVpbHRpbi9mZXRjaC5jOjE1OQogbXNnaWQgImNvbnRyb2wgcmVjdXJzaXZlIGZldGNoaW5nIG9mIHN1Ym1vZHVsZXMiCiBtc2dzdHIgIsSRaeG7gXUga2hp4buDbiB2aeG7h2MgbOG6pXkgduG7gSDEkeG7hyBxdXkgdHJvbmcgY8OhYyBtw7QtxJF1bi1jb24iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNDggYnVpbHRpbi9wdWxsLmM6MjI0CisjOiBidWlsdGluL2ZldGNoLmM6MTYzIGJ1aWx0aW4vcHVsbC5jOjIyNQogbXNnaWQgImtlZXAgZG93bmxvYWRlZCBwYWNrIgogbXNnc3RyICJnaeG7ryBs4bqhaSBnw7NpIMSRw6MgdOG6o2kgduG7gSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE1MAorIzogYnVpbHRpbi9mZXRjaC5jOjE2NQogbXNnaWQgImFsbG93IHVwZGF0aW5nIG9mIEhFQUQgcmVmIgogbXNnc3RyICJjaG8gcGjDqXAgY+G6rXAgbmjhuq10IHRoLmNoaeG6v3UgSEVBRCIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE1MyBidWlsdGluL2ZldGNoLmM6MTU5IGJ1aWx0aW4vcHVsbC5jOjIyNworIzogYnVpbHRpbi9mZXRjaC5jOjE2OCBidWlsdGluL2ZldGNoLmM6MTc0IGJ1aWx0aW4vcHVsbC5jOjIyOAogbXNnaWQgImRlZXBlbiBoaXN0b3J5IG9mIHNoYWxsb3cgY2xvbmUiCiBtc2dzdHIgImzDoG0gc8OidSBoxqFuIGzhu4tjaCBz4butIGPhu6dhIGLhuqNuIHNhbyIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE1NQorIzogYnVpbHRpbi9mZXRjaC5jOjE3MAogbXNnaWQgImRlZXBlbiBoaXN0b3J5IG9mIHNoYWxsb3cgcmVwb3NpdG9yeSBiYXNlZCBvbiB0aW1lIgogbXNnc3RyICJsw6BtIHPDonUgaMahbiBs4buLY2ggc+G7rSBj4bunYSBraG8gYuG6o24gc2FvIHNoYWxsb3cgZOG7sWEgdHLDqm4gdGjhu51pIGdpYW4iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNjEgYnVpbHRpbi9wdWxsLmM6MjMwCisjOiBidWlsdGluL2ZldGNoLmM6MTc2IGJ1aWx0aW4vcHVsbC5jOjIzMQogbXNnaWQgImNvbnZlcnQgdG8gYSBjb21wbGV0ZSByZXBvc2l0b3J5IgogbXNnc3RyICJjaHV54buDbiDEkeG7lWkgaG/DoG4gdG/DoG4gc2FuZyBraG8gZ2l0IgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTY0CisjOiBidWlsdGluL2ZldGNoLmM6MTc5CiBtc2dpZCAicHJlcGVuZCB0aGlzIHRvIHN1Ym1vZHVsZSBwYXRoIG91dHB1dCIKIG1zZ3N0ciAic2/huqFuIHPhurVuIGPDoWkgbsOgeSBjaG8ga+G6v3QgeHXhuqV0IMSRxrDhu51uZyBk4bqrbiBtw7QtxJF1bi1jb24iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNjcKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxODIKIG1zZ2lkICIiCiAiZGVmYXVsdCBmb3IgcmVjdXJzaXZlIGZldGNoaW5nIG9mIHN1Ym1vZHVsZXMgKGxvd2VyIHByaW9yaXR5IHRoYW4gY29uZmlnICIKICJmaWxlcykiCkBAIC0xMjgwMiw5MSArMTI4NjEsOTEgQEAKICJt4bq3YyDEkeG7i25oIGNobyB2aeG7h2MgbOG6pXkgxJHhu4cgcXV5IGPDoWMgbcO0LcSRdW4tY29uIChjw7MgbeG7qWMgxrB1IHRpw6puIHRo4bqlcCBoxqFuIGPDoWMgdOG6rXAgIgogInRpbiBj4bqldSBow6xuaCBjb25maWcpIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTcxIGJ1aWx0aW4vcHVsbC5jOjIzMworIzogYnVpbHRpbi9mZXRjaC5jOjE4NiBidWlsdGluL3B1bGwuYzoyMzQKIG1zZ2lkICJhY2NlcHQgcmVmcyB0aGF0IHVwZGF0ZSAuZ2l0L3NoYWxsb3ciCiBtc2dzdHIgImNo4bqlcCBuaOG6rW4gdGhhbSBjaGnhur91IGPhuq1wIG5o4bqtdCAuZ2l0L3NoYWxsb3ciCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNzIgYnVpbHRpbi9wdWxsLmM6MjM1CisjOiBidWlsdGluL2ZldGNoLmM6MTg3IGJ1aWx0aW4vcHVsbC5jOjIzNgogbXNnaWQgInJlZm1hcCIKIG1zZ3N0ciAicmVmbWFwIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTczIGJ1aWx0aW4vcHVsbC5jOjIzNgorIzogYnVpbHRpbi9mZXRjaC5jOjE4OCBidWlsdGluL3B1bGwuYzoyMzcKIG1zZ2lkICJzcGVjaWZ5IGZldGNoIHJlZm1hcCIKIG1zZ3N0ciAiY2jhu4kgcmEgcmVmbWFwIGPhuqduIGzhuqV5IHbhu4EiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxODAKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxOTUKIG1zZ2lkICJyZXBvcnQgdGhhdCB3ZSBoYXZlIG9ubHkgb2JqZWN0cyByZWFjaGFibGUgZnJvbSB0aGlzIG9iamVjdCIKIG1zZ3N0ciAiIgogImLDoW8gY8OhbyBy4bqxbmcgY2jDum5nIHRhIGNo4buJIGPDsyBjw6FjIMSR4buRaSB0xrDhu6NuZyB0aeG6v3AgY+G6rW4gxJHGsOG7o2MgdOG7qyDEkeG7kWkgdMaw4bujbmcgbsOgeSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE4MworIzogYnVpbHRpbi9mZXRjaC5jOjE5OAogbXNnaWQgInJ1biAnZ2MgLS1hdXRvJyBhZnRlciBmZXRjaGluZyIKIG1zZ3N0ciAiY2jhuqF5ICdnYyAtLWF1dG8nIHNhdSBraGkgbOG6pXkgduG7gSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE4NSBidWlsdGluL3B1bGwuYzoyNDUKKyM6IGJ1aWx0aW4vZmV0Y2guYzoyMDAgYnVpbHRpbi9wdWxsLmM6MjQ2CiBtc2dpZCAiY2hlY2sgZm9yIGZvcmNlZC11cGRhdGVzIG9uIGFsbCB1cGRhdGVkIGJyYW5jaGVzIgogbXNnc3RyICJraeG7g20gY2hvIGPDoWMtY+G6rXAtbmjhuq10LWLhuq90LWJ14buZYyB0csOqbiBt4buNaSBuaMOhbmggxJHDoyBj4bqtcCBuaOG6rXQiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzo0OTEKKyM6IGJ1aWx0aW4vZmV0Y2guYzo1MTAKIG1zZ2lkICJDb3VsZG4ndCBmaW5kIHJlbW90ZSByZWYgSEVBRCIKIG1zZ3N0ciAiS2jDtG5nIHRo4buDIHTDrG0gdGjhuqV5IG3DoXkgY2jhu6cgY2hvIHRoYW0gY2hp4bq/dSBIRUFEIgogCi0jOiBidWlsdGluL2ZldGNoLmM6NjMwCisjOiBidWlsdGluL2ZldGNoLmM6NjUwCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvbmZpZ3VyYXRpb24gZmV0Y2gub3V0cHV0IGNvbnRhaW5zIGludmFsaWQgdmFsdWUgJXMiCiBtc2dzdHIgInBo4bqnbiBj4bqldSBow6xuaCBmZXRjaC5vdXRwdXQgY8OzIGNo4bupYSBnacOhLXRy4buLIGtow7RuZyBo4bujcCBs4buHICVzIgogCi0jOiBidWlsdGluL2ZldGNoLmM6NzI4CisjOiBidWlsdGluL2ZldGNoLmM6NzQ4CiAjLCBjLWZvcm1hdAogbXNnaWQgIm9iamVjdCAlcyBub3QgZm91bmQiCiBtc2dzdHIgImtow7RuZyB0w6xtIHRo4bqleSDEkeG7kWkgdMaw4bujbmcgJXMiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzo3MzIKKyM6IGJ1aWx0aW4vZmV0Y2guYzo3NTIKIG1zZ2lkICJbdXAgdG8gZGF0ZV0iCiBtc2dzdHIgIlvEkcOjIGPhuq1wIG5o4bqtdF0iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzo3NDUgYnVpbHRpbi9mZXRjaC5jOjc2MSBidWlsdGluL2ZldGNoLmM6ODMzCisjOiBidWlsdGluL2ZldGNoLmM6NzY1IGJ1aWx0aW4vZmV0Y2guYzo3ODEgYnVpbHRpbi9mZXRjaC5jOjg1MwogbXNnaWQgIltyZWplY3RlZF0iCiBtc2dzdHIgIltC4buLIHThu6sgY2jhu5FpXSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjc0NgorIzogYnVpbHRpbi9mZXRjaC5jOjc2NgogbXNnaWQgImNhbid0IGZldGNoIGluIGN1cnJlbnQgYnJhbmNoIgogbXNnc3RyICJraMO0bmcgdGjhu4MgZmV0Y2ggKGzhuqV5KSB24buBIG5ow6FuaCBoaeG7h24gaMOgbmgiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzo3NTYKKyM6IGJ1aWx0aW4vZmV0Y2guYzo3NzYKIG1zZ2lkICJbdGFnIHVwZGF0ZV0iCiBtc2dzdHIgIltj4bqtcCBuaOG6rXQgdGjhurtdIgogCi0jOiBidWlsdGluL2ZldGNoLmM6NzU3IGJ1aWx0aW4vZmV0Y2guYzo3OTQgYnVpbHRpbi9mZXRjaC5jOjgxNgotIzogYnVpbHRpbi9mZXRjaC5jOjgyOAorIzogYnVpbHRpbi9mZXRjaC5jOjc3NyBidWlsdGluL2ZldGNoLmM6ODE0IGJ1aWx0aW4vZmV0Y2guYzo4MzYKKyM6IGJ1aWx0aW4vZmV0Y2guYzo4NDgKIG1zZ2lkICJ1bmFibGUgdG8gdXBkYXRlIGxvY2FsIHJlZiIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIGPhuq1wIG5o4bqtdCB0aGFtIGNoaeG6v3UgbuG7mWkgYuG7mSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjc2MQorIzogYnVpbHRpbi9mZXRjaC5jOjc4MQogbXNnaWQgIndvdWxkIGNsb2JiZXIgZXhpc3RpbmcgdGFnIgogbXNnc3RyICJuw6puIHjDs2EgY2jhu5NuZyBjw6FjIHRo4bq7IGPDsyBz4bq1biIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjc4MworIzogYnVpbHRpbi9mZXRjaC5jOjgwMwogbXNnaWQgIltuZXcgdGFnXSIKIG1zZ3N0ciAiW3Ro4bq7IG3hu5tpXSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjc4NgorIzogYnVpbHRpbi9mZXRjaC5jOjgwNgogbXNnaWQgIltuZXcgYnJhbmNoXSIKIG1zZ3N0ciAiW25ow6FuaCBt4bubaV0iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzo3ODkKKyM6IGJ1aWx0aW4vZmV0Y2guYzo4MDkKIG1zZ2lkICJbbmV3IHJlZl0iCiBtc2dzdHIgIltyZWYgKHRoYW0gY2hp4bq/dSkgbeG7m2ldIgogCi0jOiBidWlsdGluL2ZldGNoLmM6ODI4CisjOiBidWlsdGluL2ZldGNoLmM6ODQ4CiBtc2dpZCAiZm9yY2VkIHVwZGF0ZSIKIG1zZ3N0ciAiY8aw4buhbmcgYuG7qWMgY+G6rXAgbmjhuq10IgogCi0jOiBidWlsdGluL2ZldGNoLmM6ODMzCisjOiBidWlsdGluL2ZldGNoLmM6ODUzCiBtc2dpZCAibm9uLWZhc3QtZm9yd2FyZCIKIG1zZ3N0ciAia2jDtG5nLXBo4bqjaS1jaHV54buDbi10aeG6v3AtbmhhbmgiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzo4NTQKKyM6IGJ1aWx0aW4vZmV0Y2guYzo4NzQKIG1zZ2lkICIiCiAiRmV0Y2ggbm9ybWFsbHkgaW5kaWNhdGVzIHdoaWNoIGJyYW5jaGVzIGhhZCBhIGZvcmNlZCB1cGRhdGUsXG4iCiAiYnV0IHRoYXQgY2hlY2sgaGFzIGJlZW4gZGlzYWJsZWQuIFRvIHJlLWVuYWJsZSwgdXNlICctLXNob3ctZm9yY2VkLXVwZGF0ZXMnXG4iCkBAIC0xMjg5Niw3ICsxMjk1NSw3IEBACiAibmjGsG5nIGzhu7FhIGNo4buNbiBi4buLIHThuq90LiDEkOG7gyBrw61jaCBob+G6oXQgbOG6oWksIHPhu60gZOG7pW5nIGPhu51cbiIKICInLS1zaG93LWZvcmNlZC11cGRhdGVzJyBob+G6t2MgY2jhuqF5ICdnaXQgY29uZmlnIGZldGNoLnNob3dGb3JjZWRVcGRhdGVzIHRydWUnLiIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjg1OAorIzogYnVpbHRpbi9mZXRjaC5jOjg3OAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiSXQgdG9vayAlLjJmIHNlY29uZHMgdG8gY2hlY2sgZm9yY2VkIHVwZGF0ZXMuIFlvdSBjYW4gdXNlXG4iCkBAIC0xMjkwOSwyMiArMTI5NjgsMjIgQEAKICJmYWxzZSdcbiIKICLEkeG7gyB0csOhbmgga2nhu4NtIHRyYSBuw6B5LlxuIgogCi0jOiBidWlsdGluL2ZldGNoLmM6ODg4CisjOiBidWlsdGluL2ZldGNoLmM6OTA4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIGRpZCBub3Qgc2VuZCBhbGwgbmVjZXNzYXJ5IG9iamVjdHNcbiIKIG1zZ3N0ciAiJXMgxJHDoyBraMO0bmcgZ+G7rWkgdOG6pXQgY+G6oyBjw6FjIMSR4buRaSB0xrDhu6NuZyBj4bqnbiB0aGnhur90XG4iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzo5MDkKKyM6IGJ1aWx0aW4vZmV0Y2guYzo5MjkKICMsIGMtZm9ybWF0CiBtc2dpZCAicmVqZWN0ICVzIGJlY2F1c2Ugc2hhbGxvdyByb290cyBhcmUgbm90IGFsbG93ZWQgdG8gYmUgdXBkYXRlZCIKIG1zZ3N0ciAidOG7qyBjaOG7kWkgJXMgYuG7n2kgdsOsIGPDoWMgZ+G7kWMgbsO0bmcgdGjDrCBraMO0bmcgxJHGsOG7o2MgcGjDqXAgY+G6rXAgbmjhuq10IgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTAwMCBidWlsdGluL2ZldGNoLmM6MTEzMQorIzogYnVpbHRpbi9mZXRjaC5jOjEwMjAgYnVpbHRpbi9mZXRjaC5jOjExNTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiRnJvbSAlLipzXG4iCiBtc2dzdHIgIlThu6sgJS4qc1xuIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTAxMQorIzogYnVpbHRpbi9mZXRjaC5jOjEwMzEKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogInNvbWUgbG9jYWwgcmVmcyBjb3VsZCBub3QgYmUgdXBkYXRlZDsgdHJ5IHJ1bm5pbmdcbiIKQEAgLTEyOTMzLDYwICsxMjk5Miw4MSBAQAogIm3hu5l0IHPhu5EgdGhhbSBjaGnhur91IG7hu5lpIGLhu5kga2jDtG5nIHRo4buDIMSRxrDhu6NjIGPhuq1wIG5o4bqtdDsgaMOjeSB0aOG7rSBjaOG6oXlcbiIKICIg4oCcZ2l0IHJlbW90ZSBwcnVuZSAlc+KAnSDEkeG7gyBi4buPIMSRaSBuaOG7r25nIG5ow6FuaCBjxaksIGhheSBi4buLIHh1bmcgxJHhu5l0IgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTEwMQorIzogYnVpbHRpbi9mZXRjaC5jOjExMjcKICMsIGMtZm9ybWF0CiBtc2dpZCAiICAgKCVzIHdpbGwgYmVjb21lIGRhbmdsaW5nKSIKIG1zZ3N0ciAiICAgKCVzIHPhur0gdHLhu58gdGjDoG5oIGtow7RuZyDEkeG6p3UgKGtow7RuZyDEkcaw4bujYyBxdeG6o24gbMO9KSkiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxMTAyCisjOiBidWlsdGluL2ZldGNoLmM6MTEyOAogIywgYy1mb3JtYXQKIG1zZ2lkICIgICAoJXMgaGFzIGJlY29tZSBkYW5nbGluZykiCiBtc2dzdHIgIiAgICglcyDEkcOjIHRy4bufIHRow6BuaCBraMO0bmcgxJHhuqd1IChraMO0bmcgxJHGsOG7o2MgcXXhuqNuIGzDvSkpIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTEzNAorIzogYnVpbHRpbi9mZXRjaC5jOjExNjAKIG1zZ2lkICJbZGVsZXRlZF0iCiBtc2dzdHIgIlvEkcOjIHjDs2FdIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTEzNSBidWlsdGluL3JlbW90ZS5jOjEwMzYKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxMTYxIGJ1aWx0aW4vcmVtb3RlLmM6MTAzNgogbXNnaWQgIihub25lKSIKIG1zZ3N0ciAiKGtow7RuZykiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxMTU4CisjOiBidWlsdGluL2ZldGNoLmM6MTE4NAogIywgYy1mb3JtYXQKIG1zZ2lkICJSZWZ1c2luZyB0byBmZXRjaCBpbnRvIGN1cnJlbnQgYnJhbmNoICVzIG9mIG5vbi1iYXJlIHJlcG9zaXRvcnkiCiBtc2dzdHIgIiIKICJU4burIGNo4buRaSB2aeG7h2MgbOG6pXkgdsOgbyB0cm9uZyBuaMOhbmggaGnhu4duIHThuqFpICVzIGPhu6dhIG3hu5l0IGtobyBjaOG7qWEga2jDtG5nIHBo4bqjaSBraG8gIgogInRy4bqnbiAoYmFyZSkiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxMTc3CisjOiBidWlsdGluL2ZldGNoLmM6MTIwMwogIywgYy1mb3JtYXQKIG1zZ2lkICJPcHRpb24gXCIlc1wiIHZhbHVlIFwiJXNcIiBpcyBub3QgdmFsaWQgZm9yICVzIgogbXNnc3RyICJUw7l5IGNo4buNbiBcIiVzXCIgY8OzIGdpw6EgdHLhu4sgXCIlc1wiIGzDoCBraMO0bmcgaOG7o3AgbOG7hyBjaG8gJXMiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxMTgwCisjOiBidWlsdGluL2ZldGNoLmM6MTIwNgogIywgYy1mb3JtYXQKIG1zZ2lkICJPcHRpb24gXCIlc1wiIGlzIGlnbm9yZWQgZm9yICVzXG4iCiBtc2dzdHIgIlTDuXkgY2jhu41uIFwiJXNcIiBi4buLIGLhu48gcXVhIHbhu5tpICVzXG4iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNDg0CisjOiBidWlsdGluL2ZldGNoLmM6MTQxNAorbXNnaWQgIm11bHRpcGxlIGJyYW5jaCBkZXRlY3RlZCwgaW5jb21wYXRpYmxlIHdpdGggLS1zZXQtdXBzdHJlYW0iCittc2dzdHIgInBow6F0IGhp4buHbiBuaGnhu4F1IG5ow6FuaCwga2jDtG5nIHTGsMahbmcgdGjDrWNoIHbhu5tpIC0tc2V0LXVwc3RyZWFtIgorCisjOiBidWlsdGluL2ZldGNoLmM6MTQyOQorbXNnaWQgIm5vdCBzZXR0aW5nIHVwc3RyZWFtIGZvciBhIHJlbW90ZSByZW1vdGUtdHJhY2tpbmcgYnJhbmNoIgorbXNnc3RyICJraMO0bmcgY8OgaSDEkeG6t3QgdGjGsOG7o25nIG5ndeG7k24gY2hvIG3hu5l0IG5ow6FuaCDEkcaw4bujYyB0aGVvIGTDtWkgdHLDqm4gbcOheSBjaOG7pyIKKworIzogYnVpbHRpbi9mZXRjaC5jOjE0MzEKK21zZ2lkICJub3Qgc2V0dGluZyB1cHN0cmVhbSBmb3IgYSByZW1vdGUgdGFnIgorbXNnc3RyICJraMO0bmcgY8OgaSDEkeG6t3QgdGjGsOG7o25nIG5ndeG7k24gY2hvIG3hu5l0IHRo4bq7IG5ow6FuaCB0csOqbiBtw6F5IGNo4bunIgorCisjOiBidWlsdGluL2ZldGNoLmM6MTQzMworbXNnaWQgInVua25vd24gYnJhbmNoIHR5cGUiCittc2dzdHIgImtow7RuZyBoaeG7g3Uga2nhu4N1IG5ow6FuaCIKKworIzogYnVpbHRpbi9mZXRjaC5jOjE0MzUKK21zZ2lkICIiCisibm8gc291cmNlIGJyYW5jaCBmb3VuZC5cbiIKKyJ5b3UgbmVlZCB0byBzcGVjaWZ5IGV4YWN0bHkgb25lIGJyYW5jaCB3aXRoIHRoZSAtLXNldC11cHN0cmVhbSBvcHRpb24uIgorbXNnc3RyICIiCisia2jDtG5nIHTDrG0gdGjhuqV5IG5ow6FuaCBuZ3Xhu5NuLlxuIgorImLhuqFuIGPhuqduIHBo4bqjaSBjaOG7iSDEkeG7i25oIGNow61uaCB4w6FjIG3hu5l0IG5ow6FuaCB24bubaSB0w7l5IGNo4buNbiAtLXNldC11cHN0cmVhbS4iCisKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNTYxIGJ1aWx0aW4vZmV0Y2guYzoxNjIzCiAjLCBjLWZvcm1hdAogbXNnaWQgIkZldGNoaW5nICVzXG4iCiBtc2dzdHIgIsSQYW5nIGzhuqV5IOKAnCVz4oCdIHbhu4FcbiIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE0ODYgYnVpbHRpbi9yZW1vdGUuYzoxMDAKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNTcxIGJ1aWx0aW4vZmV0Y2guYzoxNjI1IGJ1aWx0aW4vcmVtb3RlLmM6MTAwCiAjLCBjLWZvcm1hdAogbXNnaWQgIkNvdWxkIG5vdCBmZXRjaCAlcyIKIG1zZ3N0ciAiS2jDtG5nIHRo4buDIGzhuqV54oCcJXPigJ0gduG7gSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE1MzIKLW1zZ2lkICIiCi0iLS1maWx0ZXIgY2FuIG9ubHkgYmUgdXNlZCB3aXRoIHRoZSByZW1vdGUgY29uZmlndXJlZCBpbiBleHRlbnNpb25zLiIKLSJwYXJ0aWFsQ2xvbmUiCi1tc2dzdHIgIiIKLSItLWZpbHRlciBjaOG7iSBjw7MgdGjhu4MgxJHGsOG7o2MgZMO5bmcgduG7m2kgbcOheSBjaOG7pyDEkcaw4bujYyBj4bqldSBow6xuaCBi4bqxbmcgZXh0ZW5zaW9ucy4iCi0icGFydGlhbENsb25lIgorIzogYnVpbHRpbi9mZXRjaC5jOjE1ODMKKyMsIGMtZm9ybWF0Cittc2dpZCAiY291bGQgbm90IGZldGNoICclcycgKGV4aXQgY29kZTogJWQpXG4iCittc2dzdHIgImtow7RuZyB0aOG7gyBs4bqleSDigJwlc+KAnSAobcOjIHRob8OhdDogJWQpXG4iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNTU2CisjOiBidWlsdGluL2ZldGNoLmM6MTY4NQogbXNnaWQgIiIKICJObyByZW1vdGUgcmVwb3NpdG9yeSBzcGVjaWZpZWQuICBQbGVhc2UsIHNwZWNpZnkgZWl0aGVyIGEgVVJMIG9yIGFcbiIKICJyZW1vdGUgbmFtZSBmcm9tIHdoaWNoIG5ldyByZXZpc2lvbnMgc2hvdWxkIGJlIGZldGNoZWQuIgpAQCAtMTI5OTQsNDQgKzEzMDc0LDQ0IEBACiAiQ2jGsGEgY2jhu4kgcmEga2hvIGNo4bupYSBtw6F5IGNo4bunLiAgWGluIGjDo3kgY2jhu4kgxJHhu4tuaCBob+G6t2MgbMOgIFVSTCBob+G6t2NcbiIKICJ0w6puIG3DoXkgY2jhu6cgdOG7qyBjw6FpIG3DoCBuaOG7r25nIMSRaeG7g20geMOpdCBkdXnhu4d0IG3hu5tpIGPDsyB0aOG7gyDEkcaw4bujYyBmZXRjaCAobOG6pXkgduG7gSkuIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTU5MworIzogYnVpbHRpbi9mZXRjaC5jOjE3MjIKIG1zZ2lkICJZb3UgbmVlZCB0byBzcGVjaWZ5IGEgdGFnIG5hbWUuIgogbXNnc3RyICJC4bqhbiBwaOG6o2kgxJHhu4tuaCByw7UgdMOqbiB0aOG6uy4iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNjQ0CisjOiBidWlsdGluL2ZldGNoLmM6MTc3NAogbXNnaWQgIk5lZ2F0aXZlIGRlcHRoIGluIC0tZGVlcGVuIGlzIG5vdCBzdXBwb3J0ZWQiCiBtc2dzdHIgIk3hu6ljIHPDonUgbMOgIHPhu5Egw6JtIHRyb25nIC0tZGVlcGVuIGzDoCBraMO0bmcgxJHGsOG7o2MgaOG7lyB0cuG7oyIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE2NDYKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNzc2CiBtc2dpZCAiLS1kZWVwZW4gYW5kIC0tZGVwdGggYXJlIG11dHVhbGx5IGV4Y2x1c2l2ZSIKIG1zZ3N0ciAiQ8OhYyB0w7l5IGNo4buNbi0tZGVlcGVuIHbDoCAtLWRlcHRoIGxv4bqhaSB04burIGzhuqtuIG5oYXUiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNjUxCisjOiBidWlsdGluL2ZldGNoLmM6MTc4MQogbXNnaWQgIi0tZGVwdGggYW5kIC0tdW5zaGFsbG93IGNhbm5vdCBiZSB1c2VkIHRvZ2V0aGVyIgogbXNnc3RyICJ0w7l5IGNo4buNbiAtLWRlcHRoIHbDoCAtLXVuc2hhbGxvdyBraMO0bmcgdGjhu4Mgc+G7rSBk4bulbmcgY8O5bmcgduG7m2kgbmhhdSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE2NTMKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNzgzCiBtc2dpZCAiLS11bnNoYWxsb3cgb24gYSBjb21wbGV0ZSByZXBvc2l0b3J5IGRvZXMgbm90IG1ha2Ugc2Vuc2UiCiBtc2dzdHIgIi0tdW5zaGFsbG93IHRyw6puIGtobyBob8OgbiBjaOG7iW5oIGzDoCBraMO0bmcgaOG7o3AgbMO9IgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTY2OQorIzogYnVpbHRpbi9mZXRjaC5jOjE3OTkKIG1zZ2lkICJmZXRjaCAtLWFsbCBkb2VzIG5vdCB0YWtlIGEgcmVwb3NpdG9yeSBhcmd1bWVudCIKIG1zZ3N0ciAibOG7h25oIGzhuqV5IHbhu4EgXCJmZXRjaCAtLWFsbFwiIGtow7RuZyBs4bqleSDEkeG7kWkgc+G7kSBraG8gY2jhu6lhIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTY3MQorIzogYnVpbHRpbi9mZXRjaC5jOjE4MDEKIG1zZ2lkICJmZXRjaCAtLWFsbCBkb2VzIG5vdCBtYWtlIHNlbnNlIHdpdGggcmVmc3BlY3MiCiBtc2dzdHIgImzhu4duaCBs4bqleSB24buBIFwiZmV0Y2ggLS1hbGxcIiBraMO0bmcgaOG7o3AgbMO9IHbhu5tpIHJlZnNwZWNzIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTY4MAorIzogYnVpbHRpbi9mZXRjaC5jOjE4MTAKICMsIGMtZm9ybWF0CiBtc2dpZCAiTm8gc3VjaCByZW1vdGUgb3IgcmVtb3RlIGdyb3VwOiAlcyIKIG1zZ3N0ciAiS2jDtG5nIGPDsyBuaMOzbSBtw6F5IGNo4bunIGhheSBtw6F5IGNo4bunIG5oxrAgdGjhur86ICVzIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTY4NworIzogYnVpbHRpbi9mZXRjaC5jOjE4MTcKIG1zZ2lkICJGZXRjaGluZyBhIGdyb3VwIGFuZCBzcGVjaWZ5aW5nIHJlZnNwZWNzIGRvZXMgbm90IG1ha2Ugc2Vuc2UiCiBtc2dzdHIgIlZp4buHYyBs4bqleSB24buBIGPhuqMgbeG7mXQgbmjDs20gdsOgIGNo4buJIMSR4buLbmggcmVmc3BlY3Mga2jDtG5nIGjhu6NwIGzDvSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE3MDMKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxODM1CiBtc2dpZCAiIgogIi0tZmlsdGVyIGNhbiBvbmx5IGJlIHVzZWQgd2l0aCB0aGUgcmVtb3RlIGNvbmZpZ3VyZWQgaW4gZXh0ZW5zaW9ucy4iCiAicGFydGlhbGNsb25lIgpAQCAtMTMzNzEsNyArMTM0NTEsNyBAQAogbXNnaWQgImludmFsaWQgcGFyYW1ldGVyOiBleHBlY3RlZCBzaGExLCBnb3QgJyVzJyIKIG1zZ3N0ciAidGhhbSBz4buRIGtow7RuZyBo4bujcCBs4buHOiBj4bqnbiBzaGExLCBuaMawbmcgbOG6oWkgbmjhuq1uIMSRxrDhu6NjIOKAnCVz4oCdIgogCi0jOiBidWlsdGluL2djLmM6MzQKKyM6IGJ1aWx0aW4vZ2MuYzozNQogbXNnaWQgImdpdCBnYyBbPG9wdGlvbnM+XSIKIG1zZ3N0ciAiZ2l0IGdjIFs8Y8OhYyB0w7l5IGNo4buNbj5dIgogCkBAIC0xMzM4NSwxNyArMTM0NjUsMTcgQEAKIG1zZ2lkICJmYWlsZWQgdG8gcGFyc2UgJyVzJyB2YWx1ZSAnJXMnIgogbXNnc3RyICJn4bq3cCBs4buXaSBraGkgcGjDom4gdMOtY2gg4oCcJXPigJ0gZ2nDoSB0cuG7iyDigJwlc+KAnSIKIAotIzogYnVpbHRpbi9nYy5jOjQ3NiBidWlsdGluL2luaXQtZGIuYzo1NQorIzogYnVpbHRpbi9nYy5jOjQ3NSBidWlsdGluL2luaXQtZGIuYzo1NQogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3Qgc3RhdCAnJXMnIgogbXNnc3RyICJraMO0bmcgdGjhu4MgbOG6pXkgdGjDtG5nIHRpbiB0aOG7kW5nIGvDqiB24buBIOKAnCVz4oCdIgogCi0jOiBidWlsdGluL2djLmM6NDg1IGJ1aWx0aW4vbm90ZXMuYzoyNDAgYnVpbHRpbi90YWcuYzo1MjkKKyM6IGJ1aWx0aW4vZ2MuYzo0ODQgYnVpbHRpbi9ub3Rlcy5jOjI0MCBidWlsdGluL3RhZy5jOjUyOQogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgcmVhZCAnJXMnIgogbXNnc3RyICJraMO0bmcgdGjhu4MgxJHhu41jIOKAnCVz4oCdIgogCi0jOiBidWlsdGluL2djLmM6NDkyCisjOiBidWlsdGluL2djLmM6NDkxCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgbGFzdCBnYyBydW4gcmVwb3J0ZWQgdGhlIGZvbGxvd2luZy4gUGxlYXNlIGNvcnJlY3QgdGhlIHJvb3QgY2F1c2VcbiIKQEAgLTEzNDEwLDU0ICsxMzQ5MCw1NCBAQAogIlxuIgogIiVzIgogCi0jOiBidWlsdGluL2djLmM6NTQwCisjOiBidWlsdGluL2djLmM6NTM5CiBtc2dpZCAicHJ1bmUgdW5yZWZlcmVuY2VkIG9iamVjdHMiCiBtc2dzdHIgInjDs2EgYuG7jyBjw6FjIMSR4buRaSB0xrDhu6NuZyBraMO0bmcgxJHGsOG7o2MgdGhhbSBjaGnhur91IgogCi0jOiBidWlsdGluL2djLmM6NTQyCisjOiBidWlsdGluL2djLmM6NTQxCiBtc2dpZCAiYmUgbW9yZSB0aG9yb3VnaCAoaW5jcmVhc2VkIHJ1bnRpbWUpIgogbXNnc3RyICJj4bqpbiB0aOG6rW4gaMahbiBu4buvYSAodMSDbmcgdGjhu51pIGdpYW4gY2jhuqF5KSIKIAotIzogYnVpbHRpbi9nYy5jOjU0MworIzogYnVpbHRpbi9nYy5jOjU0MgogbXNnaWQgImVuYWJsZSBhdXRvLWdjIG1vZGUiCiBtc2dzdHIgImLhuq10IGNo4bq/IMSR4buZIGF1dG8tZ2MiCiAKLSM6IGJ1aWx0aW4vZ2MuYzo1NDYKKyM6IGJ1aWx0aW4vZ2MuYzo1NDUKIG1zZ2lkICJmb3JjZSBydW5uaW5nIGdjIGV2ZW4gaWYgdGhlcmUgbWF5IGJlIGFub3RoZXIgZ2MgcnVubmluZyIKIG1zZ3N0ciAiYnXhu5ljIGdjIGNo4bqheSBuZ2F5IGPhuqMga2hpIGPDsyB0aeG6v24gdHLDrG5oIGdjIGtow6FjIMSRYW5nIGNo4bqheSIKIAotIzogYnVpbHRpbi9nYy5jOjU0OQorIzogYnVpbHRpbi9nYy5jOjU0OAogbXNnaWQgInJlcGFjayBhbGwgb3RoZXIgcGFja3MgZXhjZXB0IHRoZSBsYXJnZXN0IHBhY2siCiBtc2dzdHIgIsSRw7NuZyBnw7NpIGzhuqFpIHThuqV0IGPhuqMgY8OhYyBnw7NpIGtow6FjIG5nb+G6oWkgdHLhu6sgZ8OzaSBs4bubbiBuaOG6pXQiCiAKLSM6IGJ1aWx0aW4vZ2MuYzo1NjYKKyM6IGJ1aWx0aW4vZ2MuYzo1NjUKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIHBhcnNlIGdjLmxvZ2V4cGlyeSB2YWx1ZSAlcyIKIG1zZ3N0ciAiZ+G6t3AgbOG7l2kga2hpIHBow6JuIHTDrWNoIGdpw6EgdHLhu4sgZ2MubG9nZXhwaXJ5ICVzIgogCi0jOiBidWlsdGluL2djLmM6NTc3CisjOiBidWlsdGluL2djLmM6NTc2CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBwYXJzZSBwcnVuZSBleHBpcnkgdmFsdWUgJXMiCiBtc2dzdHIgImfhurdwIGzhu5dpIGtoaSBwaMOibiB0w61jaCBnacOhIHRy4buLIHBydW5lICVzIgogCi0jOiBidWlsdGluL2djLmM6NTk3CisjOiBidWlsdGluL2djLmM6NTk2CiAjLCBjLWZvcm1hdAogbXNnaWQgIkF1dG8gcGFja2luZyB0aGUgcmVwb3NpdG9yeSBpbiBiYWNrZ3JvdW5kIGZvciBvcHRpbXVtIHBlcmZvcm1hbmNlLlxuIgogbXNnc3RyICIiCiAiVOG7sSDEkeG7mW5nIMSRw7NuZyBnw7NpIGtobyBjaOG7qWEgdHLDqm4gbuG7gW4gaOG7hyB0aOG7kW5nIMSR4buDIHThu5FpIMawdSBow7NhIGhp4buHdSBzdeG6pXQgbMOgbSAiCiAidmnhu4djLlxuIgogCi0jOiBidWlsdGluL2djLmM6NTk5CisjOiBidWlsdGluL2djLmM6NTk4CiAjLCBjLWZvcm1hdAogbXNnaWQgIkF1dG8gcGFja2luZyB0aGUgcmVwb3NpdG9yeSBmb3Igb3B0aW11bSBwZXJmb3JtYW5jZS5cbiIKIG1zZ3N0ciAiVOG7sSDEkeG7mW5nIMSRw7NuZyBnw7NpIGtobyBjaOG7qWEgxJHhu4MgdOG7kWkgxrB1IGjDs2EgaGnhu4d1IHN14bqldCBsw6BtIHZp4buHYy5cbiIKIAotIzogYnVpbHRpbi9nYy5jOjYwMAorIzogYnVpbHRpbi9nYy5jOjU5OQogIywgYy1mb3JtYXQKIG1zZ2lkICJTZWUgXCJnaXQgaGVscCBnY1wiIGZvciBtYW51YWwgaG91c2VrZWVwaW5nLlxuIgogbXNnc3RyICJYZW0gXCJnaXQgaGVscCBnY1wiIMSR4buDIGPDsyBoxrDhu5tuZyBk4bqrbiBj4bulIHRo4buDIHbhu4EgY8OhY2ggZOG7jW4gZOG6uXAga2hvIGdpdC5cbiIKIAotIzogYnVpbHRpbi9nYy5jOjY0MAorIzogYnVpbHRpbi9nYy5jOjYzOQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiZ2MgaXMgYWxyZWFkeSBydW5uaW5nIG9uIG1hY2hpbmUgJyVzJyBwaWQgJTxQUkl1TUFYPiAodXNlIC0tZm9yY2UgaWYgbm90KSIKQEAgLTEzNDY1LDcgKzEzNTQ1LDcgQEAKICJnYyDEkWFuZyDEkcaw4bujYyB0aOG7sWMgaGnhu4duIHRyw6puIG3DoXkg4oCcJXPigJ0gcGlkICU8UFJJdU1BWD4gKGTDuW5nIC0tZm9yY2UgbuG6v3Uga2jDtG5nICIKICJwaOG6o2kgdGjhur8pIgogCi0jOiBidWlsdGluL2djLmM6Njk1CisjOiBidWlsdGluL2djLmM6Njk0CiBtc2dpZCAiIgogIlRoZXJlIGFyZSB0b28gbWFueSB1bnJlYWNoYWJsZSBsb29zZSBvYmplY3RzOyBydW4gJ2dpdCBwcnVuZScgdG8gcmVtb3ZlIHRoZW0uIgogbXNnc3RyICIiCkBAIC0xMzQ5MSwyNTggKzEzNTcxLDI1OCBAQAogIy4gZ3JlcC50aHJlYWRzCiAjLgogIzogYnVpbHRpbi9ncmVwLmM6Mjg3IGJ1aWx0aW4vaW5kZXgtcGFjay5jOjE1MzQgYnVpbHRpbi9pbmRleC1wYWNrLmM6MTcyNwotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNzI4CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI3MDgKICMsIGMtZm9ybWF0CiBtc2dpZCAibm8gdGhyZWFkcyBzdXBwb3J0LCBpZ25vcmluZyAlcyIKIG1zZ3N0ciAia2jDtG5nIGjhu5cgdHLhu6MgxJFhIHR1eeG6v24sIGLhu48gcXVhICVzIgogCi0jOiBidWlsdGluL2dyZXAuYzo0NjcgYnVpbHRpbi9ncmVwLmM6NTkxIGJ1aWx0aW4vZ3JlcC5jOjYzMworIzogYnVpbHRpbi9ncmVwLmM6NDY3IGJ1aWx0aW4vZ3JlcC5jOjU5MiBidWlsdGluL2dyZXAuYzo2MzUKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHJlYWQgdHJlZSAoJXMpIgogbXNnc3RyICJraMO0bmcgdGjhu4MgxJHhu41jIGPDonkgKCVzKSIKIAotIzogYnVpbHRpbi9ncmVwLmM6NjQ4CisjOiBidWlsdGluL2dyZXAuYzo2NTAKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGdyZXAgZnJvbSBvYmplY3Qgb2YgdHlwZSAlcyIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIHRo4buxYyBoaeG7h24gbOG7h25oIGdyZXAgKGzhu41jIHTDrG0pIHThu6sgxJHhu5FpIHTGsOG7o25nIHRodeG7mWMga2nhu4N1ICVzIgogCi0jOiBidWlsdGluL2dyZXAuYzo3MTQKKyM6IGJ1aWx0aW4vZ3JlcC5jOjcxNgogIywgYy1mb3JtYXQKIG1zZ2lkICJzd2l0Y2ggYCVjJyBleHBlY3RzIGEgbnVtZXJpY2FsIHZhbHVlIgogbXNnc3RyICJjaHV54buDbiDEkeG6v24g4oCcJWPigJ0gY+G6p24gbeG7mXQgZ2nDoSB0cuG7iyBi4bqxbmcgc+G7kSIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODEzCisjOiBidWlsdGluL2dyZXAuYzo4MTUKIG1zZ2lkICJzZWFyY2ggaW4gaW5kZXggaW5zdGVhZCBvZiBpbiB0aGUgd29yayB0cmVlIgogbXNnc3RyICJ0w6xtIHRyb25nIGLhuqNuZyBt4bulYyBs4bulYyB0aGF5IHbDrCB0cm9uZyBjw6J5IGzDoG0gdmnhu4djIgogCi0jOiBidWlsdGluL2dyZXAuYzo4MTUKKyM6IGJ1aWx0aW4vZ3JlcC5jOjgxNwogbXNnaWQgImZpbmQgaW4gY29udGVudHMgbm90IG1hbmFnZWQgYnkgZ2l0IgogbXNnc3RyICJ0w6xtIHRyb25nIG7hu5lpIGR1bmcga2jDtG5nIMSRxrDhu6NjIHF14bqjbiBsw70gYuG7n2kgZ2l0IgogCi0jOiBidWlsdGluL2dyZXAuYzo4MTcKKyM6IGJ1aWx0aW4vZ3JlcC5jOjgxOQogbXNnaWQgInNlYXJjaCBpbiBib3RoIHRyYWNrZWQgYW5kIHVudHJhY2tlZCBmaWxlcyIKIG1zZ3N0ciAidMOsbSBraeG6v20gY8OhYyB04bqtcCB0aW4gxJHGsOG7o2MgdsOgIGNoxrBhIMSRxrDhu6NjIHRoZW8gZMO1aSBk4bqldSB24bq/dCIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODE5CisjOiBidWlsdGluL2dyZXAuYzo4MjEKIG1zZ2lkICJpZ25vcmUgZmlsZXMgc3BlY2lmaWVkIHZpYSAnLmdpdGlnbm9yZSciCiBtc2dzdHIgImPDoWMgdOG6rXAgdGluIGLhu4sgYuG7jyBxdWEgxJHGsOG7o2MgY2jhu4kgxJHhu4tuaCB0aMO0bmcgcXVhIOKAnC5naXRpZ25vcmXigJ0iCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjgyMQorIzogYnVpbHRpbi9ncmVwLmM6ODIzCiBtc2dpZCAicmVjdXJzaXZlbHkgc2VhcmNoIGluIGVhY2ggc3VibW9kdWxlIgogbXNnc3RyICJ0w6xtIGtp4bq/bSDEkeG7hyBxdXkgdHJvbmcgdOG7q25nIG3DtC3EkXVuLWNvbiIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODI0CisjOiBidWlsdGluL2dyZXAuYzo4MjYKIG1zZ2lkICJzaG93IG5vbi1tYXRjaGluZyBsaW5lcyIKIG1zZ3N0ciAiaGnhu4NuIHRo4buLIG5o4buvbmcgZMOybmcga2jDtG5nIGto4bubcCB24bubaSBt4bqrdSIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODI2CisjOiBidWlsdGluL2dyZXAuYzo4MjgKIG1zZ2lkICJjYXNlIGluc2Vuc2l0aXZlIG1hdGNoaW5nIgogbXNnc3RyICJwaMOibiBiaeG7h3QgSE9BL3RoxrDhu51uZyIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODI4CisjOiBidWlsdGluL2dyZXAuYzo4MzAKIG1zZ2lkICJtYXRjaCBwYXR0ZXJucyBvbmx5IGF0IHdvcmQgYm91bmRhcmllcyIKIG1zZ3N0ciAiY2jhu4kga2jhu5twIG3huqt1IHThuqFpIMSRxrDhu51uZyByYW5oIGdp4bubaSB04burIgogCi0jOiBidWlsdGluL2dyZXAuYzo4MzAKKyM6IGJ1aWx0aW4vZ3JlcC5jOjgzMgogbXNnaWQgInByb2Nlc3MgYmluYXJ5IGZpbGVzIGFzIHRleHQiCiBtc2dzdHIgInjhu60gbMO9IHThuq1wIHRpbiBuaOG7iyBwaMOibiBuaMawIGzDoCBk4bqhbmcgdsSDbiBi4bqjbiB0aMaw4budbmciCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjgzMgorIzogYnVpbHRpbi9ncmVwLmM6ODM0CiBtc2dpZCAiZG9uJ3QgbWF0Y2ggcGF0dGVybnMgaW4gYmluYXJ5IGZpbGVzIgogbXNnc3RyICJraMO0bmcga2jhu5twIG3huqt1IHRyb25nIGPDoWMgdOG6rXAgdGluIG5o4buLIHBow6JuIgogCi0jOiBidWlsdGluL2dyZXAuYzo4MzUKKyM6IGJ1aWx0aW4vZ3JlcC5jOjgzNwogbXNnaWQgInByb2Nlc3MgYmluYXJ5IGZpbGVzIHdpdGggdGV4dGNvbnYgZmlsdGVycyIKIG1zZ3N0ciAieOG7rSBsw70gdOG6rXAgdGluIG5o4buLIHBow6JuIHbhu5tpIGPDoWMgYuG7mSBs4buNYyDigJx0ZXh0Y29uduKAnSIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODM3CisjOiBidWlsdGluL2dyZXAuYzo4MzkKIG1zZ2lkICJzZWFyY2ggaW4gc3ViZGlyZWN0b3JpZXMgKGRlZmF1bHQpIgogbXNnc3RyICJ0w6xtIGtp4bq/bSB0cm9uZyB0aMawIG3hu6VjIGNvbiAobeG6t2MgxJHhu4tuaCkiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjgzOQorIzogYnVpbHRpbi9ncmVwLmM6ODQxCiBtc2dpZCAiZGVzY2VuZCBhdCBtb3N0IDxkZXB0aD4gbGV2ZWxzIgogbXNnc3RyICJo4bqhIHh14buRbmcgw610IG5o4bqldCBsw6AgbeG7qWMgPHPDonU+IgogCi0jOiBidWlsdGluL2dyZXAuYzo4NDMKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg0NQogbXNnaWQgInVzZSBleHRlbmRlZCBQT1NJWCByZWd1bGFyIGV4cHJlc3Npb25zIgogbXNnc3RyICJkw7luZyBiaeG7g3UgdGjhu6ljIGNow61uaCBxdWkgUE9TSVggY8OzIG3hu58gcuG7mW5nIgogCi0jOiBidWlsdGluL2dyZXAuYzo4NDYKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg0OAogbXNnaWQgInVzZSBiYXNpYyBQT1NJWCByZWd1bGFyIGV4cHJlc3Npb25zIChkZWZhdWx0KSIKIG1zZ3N0ciAic+G7rSBk4bulbmcgYmnhu4N1IHRo4bupYyBjaMOtbmggcXV5IGtp4buDdSBQT1NJWCAobeG6t2MgxJHhu4tuaCkiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg0OQorIzogYnVpbHRpbi9ncmVwLmM6ODUxCiBtc2dpZCAiaW50ZXJwcmV0IHBhdHRlcm5zIGFzIGZpeGVkIHN0cmluZ3MiCiBtc2dzdHIgImRp4buFbiBk4buLY2ggY8OhYyBt4bqrdSBuaMawIGzDoCBjaHXhu5dpIGPhu5EgxJHhu4tuaCIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODUyCisjOiBidWlsdGluL2dyZXAuYzo4NTQKIG1zZ2lkICJ1c2UgUGVybC1jb21wYXRpYmxlIHJlZ3VsYXIgZXhwcmVzc2lvbnMiCiBtc2dzdHIgInPhu60gZOG7pW5nIGJp4buDdSB0aOG7qWMgY2jDrW5oIHF1eSB0xrDGoW5nIHRow61jaCBQZXJsIgogCi0jOiBidWlsdGluL2dyZXAuYzo4NTUKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg1NwogbXNnaWQgInNob3cgbGluZSBudW1iZXJzIgogbXNnc3RyICJoaeG7g24gdGjhu4sgc+G7kSBj4bunYSBkw7JuZyIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODU2CisjOiBidWlsdGluL2dyZXAuYzo4NTgKIG1zZ2lkICJzaG93IGNvbHVtbiBudW1iZXIgb2YgZmlyc3QgbWF0Y2giCiBtc2dzdHIgImhp4buDbiB0aOG7iyBz4buRIGPhu5l0IGPhu6dhIGto4bubcCB24bubaSBt4bqrdSDEkeG6p3UgdGnDqm4iCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg1NworIzogYnVpbHRpbi9ncmVwLmM6ODU5CiBtc2dpZCAiZG9uJ3Qgc2hvdyBmaWxlbmFtZXMiCiBtc2dzdHIgImtow7RuZyBoaeG7g24gdGjhu4sgdMOqbiB04bqtcCB0aW4iCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg1OAorIzogYnVpbHRpbi9ncmVwLmM6ODYwCiBtc2dpZCAic2hvdyBmaWxlbmFtZXMiCiBtc2dzdHIgImhp4buDbiB0aOG7iyBjw6FjIHTDqm4gdOG6rXAgdGluIgogCi0jOiBidWlsdGluL2dyZXAuYzo4NjAKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg2MgogbXNnaWQgInNob3cgZmlsZW5hbWVzIHJlbGF0aXZlIHRvIHRvcCBkaXJlY3RvcnkiCiBtc2dzdHIgImhp4buDbiB0aOG7iyB0w6puIHThuq1wIHRpbiB0xrDGoW5nIMSR4buRaSB24bubaSB0aMawIG3hu6VjIMSR4buJbmggKHRvcCkiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg2MgorIzogYnVpbHRpbi9ncmVwLmM6ODY0CiBtc2dpZCAic2hvdyBvbmx5IGZpbGVuYW1lcyBpbnN0ZWFkIG9mIG1hdGNoaW5nIGxpbmVzIgogbXNnc3RyICJjaOG7iSBoaeG7g24gdGjhu4sgdMOqbiB04bqtcCB0aW4gdGhheSB2w6wgbmjhu69uZyBkw7JuZyBraOG7m3AgduG7m2kgbeG6q3UiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg2NAorIzogYnVpbHRpbi9ncmVwLmM6ODY2CiBtc2dpZCAic3lub255bSBmb3IgLS1maWxlcy13aXRoLW1hdGNoZXMiCiBtc2dzdHIgIsSR4buTbmcgbmdoxKlhIHbhu5tpIC0tZmlsZXMtd2l0aC1tYXRjaGVzIgogCi0jOiBidWlsdGluL2dyZXAuYzo4NjcKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg2OQogbXNnaWQgInNob3cgb25seSB0aGUgbmFtZXMgb2YgZmlsZXMgd2l0aG91dCBtYXRjaCIKIG1zZ3N0ciAiY2jhu4kgaGnhu4NuIHRo4buLIHTDqm4gY2hvIG5o4buvbmcgdOG6rXAgdGluIGtow7RuZyBraOG7m3AgduG7m2kgbeG6q3UiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg2OQorIzogYnVpbHRpbi9ncmVwLmM6ODcxCiBtc2dpZCAicHJpbnQgTlVMIGFmdGVyIGZpbGVuYW1lcyIKIG1zZ3N0ciAidGjDqm0gTlVMIHbDoG8gc2F1IHTDqm4gdOG6rXAgdGluIgogCi0jOiBidWlsdGluL2dyZXAuYzo4NzIKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg3NAogbXNnaWQgInNob3cgb25seSBtYXRjaGluZyBwYXJ0cyBvZiBhIGxpbmUiCiBtc2dzdHIgImNo4buJIGhp4buDbiB0aOG7iyBuaOG7r25nIHBo4bqnbiBraOG7m3AgduG7m2kgbeG6q3UgY+G7p2EgbeG7mXQgZMOybmciCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg3NAorIzogYnVpbHRpbi9ncmVwLmM6ODc2CiBtc2dpZCAic2hvdyB0aGUgbnVtYmVyIG9mIG1hdGNoZXMgaW5zdGVhZCBvZiBtYXRjaGluZyBsaW5lcyIKIG1zZ3N0ciAiaGnhu4NuIHRo4buLIHPhu5EgbMaw4bujbmcga2jhu5twIHRoYXkgdsOsIG5o4buvbmcgZMOybmcga2jhu5twIHbhu5tpIG3huqt1IgogCi0jOiBidWlsdGluL2dyZXAuYzo4NzUKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg3NwogbXNnaWQgImhpZ2hsaWdodCBtYXRjaGVzIgogbXNnc3RyICJ0w7Qgc8OhbmcgcGjhuqduIGto4bubcCBt4bqrdSIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODc3CisjOiBidWlsdGluL2dyZXAuYzo4NzkKIG1zZ2lkICJwcmludCBlbXB0eSBsaW5lIGJldHdlZW4gbWF0Y2hlcyBmcm9tIGRpZmZlcmVudCBmaWxlcyIKIG1zZ3N0ciAiaGnhu4NuIHRo4buLIGTDsm5nIHRy4buRbmcgZ2nhu69hIGPDoWMgbOG6p24ga2jhu5twIHThu6sgY8OhYyB04bqtcCB0aW4ga2jDoWMgYmnhu4d0IgogCi0jOiBidWlsdGluL2dyZXAuYzo4NzkKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg4MQogbXNnaWQgInNob3cgZmlsZW5hbWUgb25seSBvbmNlIGFib3ZlIG1hdGNoZXMgZnJvbSBzYW1lIGZpbGUiCiBtc2dzdHIgIiIKICJoaeG7g24gdGjhu4sgdMOqbiB04bqtcCB0aW4gbeG7mXQgbOG6p24gcGjDrWEgdHLDqm4gY8OhYyBs4bqnbiBraOG7m3AgdOG7qyBjw7luZyBt4buZdCB04bqtcCB0aW4iCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg4MgorIzogYnVpbHRpbi9ncmVwLmM6ODg0CiBtc2dpZCAic2hvdyA8bj4gY29udGV4dCBsaW5lcyBiZWZvcmUgYW5kIGFmdGVyIG1hdGNoZXMiCiBtc2dzdHIgImhp4buDbiB0aOG7iyA8bj4gZMOybmcgbuG7mWkgZHVuZyBwaMOtYSB0csaw4bubYyB2w6Agc2F1IGPDoWMgbOG6p24ga2jhu5twIgogCi0jOiBidWlsdGluL2dyZXAuYzo4ODUKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg4NwogbXNnaWQgInNob3cgPG4+IGNvbnRleHQgbGluZXMgYmVmb3JlIG1hdGNoZXMiCiBtc2dzdHIgImhp4buDbiB0aOG7iyA8bj4gZMOybmcgbuG7mWkgZHVuZyB0csaw4bubYyBraOG7m3AiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg4NworIzogYnVpbHRpbi9ncmVwLmM6ODg5CiBtc2dpZCAic2hvdyA8bj4gY29udGV4dCBsaW5lcyBhZnRlciBtYXRjaGVzIgogbXNnc3RyICJoaeG7g24gdGjhu4sgPG4+IGTDsm5nIG7hu5lpIGR1bmcgc2F1IGto4bubcCIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODg5CisjOiBidWlsdGluL2dyZXAuYzo4OTEKIG1zZ2lkICJ1c2UgPG4+IHdvcmtlciB0aHJlYWRzIgogbXNnc3RyICJkw7luZyA8bj4gdHV54bq/biB0csOsbmggbMOgbSB2aeG7h2MiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg5MAorIzogYnVpbHRpbi9ncmVwLmM6ODkyCiBtc2dpZCAic2hvcnRjdXQgZm9yIC1DIE5VTSIKIG1zZ3N0ciAiZOG6oW5nIHZp4bq/dCB04bqvdCBj4bunYSAtQyBT4buQIgogCi0jOiBidWlsdGluL2dyZXAuYzo4OTMKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg5NQogbXNnaWQgInNob3cgYSBsaW5lIHdpdGggdGhlIGZ1bmN0aW9uIG5hbWUgYmVmb3JlIG1hdGNoZXMiCiBtc2dzdHIgImhp4buDbiB0aOG7iyBkw7JuZyB2w7NpIHTDqm4gaMOgbSB0csaw4bubYyBjw6FjIGzhuqduIGto4bubcCIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODk1CisjOiBidWlsdGluL2dyZXAuYzo4OTcKIG1zZ2lkICJzaG93IHRoZSBzdXJyb3VuZGluZyBmdW5jdGlvbiIKIG1zZ3N0ciAiaGnhu4NuIHRo4buLIGjDoG0gYmFvIHF1YW5oIgogCi0jOiBidWlsdGluL2dyZXAuYzo4OTgKKyM6IGJ1aWx0aW4vZ3JlcC5jOjkwMAogbXNnaWQgInJlYWQgcGF0dGVybnMgZnJvbSBmaWxlIgogbXNnc3RyICLEkeG7jWMgbeG6q3UgdOG7qyB04bqtcC10aW4iCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjkwMAorIzogYnVpbHRpbi9ncmVwLmM6OTAyCiBtc2dpZCAibWF0Y2ggPHBhdHRlcm4+IgogbXNnc3RyICJtYXRjaCA8beG6q3U+IgogCi0jOiBidWlsdGluL2dyZXAuYzo5MDIKKyM6IGJ1aWx0aW4vZ3JlcC5jOjkwNAogbXNnaWQgImNvbWJpbmUgcGF0dGVybnMgc3BlY2lmaWVkIHdpdGggLWUiCiBtc2dzdHIgInThu5UgaOG7o3AgbeG6q3UgxJHGsOG7o2MgY2jhu4kgcmEgduG7m2kgdMO5eSBjaOG7jW4gLWUiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjkxNAorIzogYnVpbHRpbi9ncmVwLmM6OTE2CiBtc2dpZCAiaW5kaWNhdGUgaGl0IHdpdGggZXhpdCBzdGF0dXMgd2l0aG91dCBvdXRwdXQiCiBtc2dzdHIgIsSRxrBhIHJhIGfhu6NpIMO9IHbhu5tpIHRy4bqhbmcgdGjDoWkgdGhvw6F0IG3DoCBraMO0bmcgY8OzIGvhur90IHh14bqldCIKIAotIzogYnVpbHRpbi9ncmVwLmM6OTE2CisjOiBidWlsdGluL2dyZXAuYzo5MTgKIG1zZ2lkICJzaG93IG9ubHkgbWF0Y2hlcyBmcm9tIGZpbGVzIHRoYXQgbWF0Y2ggYWxsIHBhdHRlcm5zIgogbXNnc3RyICJjaOG7iSBoaeG7g24gdGjhu4sgbmjhu69uZyBjw6FpIGto4bubcCB04burIHThuq1wIHRpbiBtw6AgbsOzIGto4bubcCB0b8OgbiBi4buZIGPDoWMgbeG6q3UiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjkxOAorIzogYnVpbHRpbi9ncmVwLmM6OTIwCiBtc2dpZCAic2hvdyBwYXJzZSB0cmVlIGZvciBncmVwIGV4cHJlc3Npb24iCiBtc2dzdHIgImhp4buDbiB0aOG7iyBjw6J5IHBow6JuIHTDrWNoIGPDuiBwaMOhcCBjaG8gYmnhu4N1IHRo4bupYyDigJxncmVw4oCdICh0w6xtIGtp4bq/bSkiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjkyMgorIzogYnVpbHRpbi9ncmVwLmM6OTI0CiBtc2dpZCAicGFnZXIiCiBtc2dzdHIgImTDoG4gdHJhbmciCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjkyMgorIzogYnVpbHRpbi9ncmVwLmM6OTI0CiBtc2dpZCAic2hvdyBtYXRjaGluZyBmaWxlcyBpbiB0aGUgcGFnZXIiCiBtc2dzdHIgImhp4buDbiB0aOG7iyBjw6FjIHThuq1wIHRpbiBraOG7m3AgdHJvbmcgdHJhbmcgZ2nhuqV5IgogCi0jOiBidWlsdGluL2dyZXAuYzo5MjYKKyM6IGJ1aWx0aW4vZ3JlcC5jOjkyOAogbXNnaWQgImFsbG93IGNhbGxpbmcgb2YgZ3JlcCgxKSAoaWdub3JlZCBieSB0aGlzIGJ1aWxkKSIKIG1zZ3N0ciAiY2hvIHBow6lwIGfhu41pIGdyZXAoMSkgKGLhu4sgYuG7jyBxdWEgYuG7n2kgbOG6p24gZOG7i2NoIG7DoHkpIgogCi0jOiBidWlsdGluL2dyZXAuYzo5OTAKKyM6IGJ1aWx0aW4vZ3JlcC5jOjk5MgogbXNnaWQgIm5vIHBhdHRlcm4gZ2l2ZW4iCiBtc2dzdHIgImNoxrBhIGNo4buJIHJhIG3huqt1IgogCi0jOiBidWlsdGluL2dyZXAuYzoxMDI2CisjOiBidWlsdGluL2dyZXAuYzoxMDI4CiBtc2dpZCAiLS1uby1pbmRleCBvciAtLXVudHJhY2tlZCBjYW5ub3QgYmUgdXNlZCB3aXRoIHJldnMiCiBtc2dzdHIgIi0tbm8taW5kZXggaGF5IC0tdW50cmFja2VkIGtow7RuZyDEkcaw4bujYyBz4butIGThu6VuZyBjw7luZyB24bubaSByZXZzIgogCi0jOiBidWlsdGluL2dyZXAuYzoxMDM0CisjOiBidWlsdGluL2dyZXAuYzoxMDM2CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byByZXNvbHZlIHJldmlzaW9uOiAlcyIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIHBow6JuIGdp4bqjaSDEkWnhu4NtIHjDqXQgZHV54buHdDogJXMiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjEwNjUKKyM6IGJ1aWx0aW4vZ3JlcC5jOjEwNjcKIG1zZ2lkICJpbnZhbGlkIG9wdGlvbiBjb21iaW5hdGlvbiwgaWdub3JpbmcgLS10aHJlYWRzIgogbXNnc3RyICJ04buVIGjhu6NwIHTDuXkgY2jhu41uIGtow7RuZyBo4bujcCBs4buHLCBi4buPIHF1YSAtLXRocmVhZHMiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjEwNjggYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozNDE2CisjOiBidWlsdGluL2dyZXAuYzoxMDcwIGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzQwMAogbXNnaWQgIm5vIHRocmVhZHMgc3VwcG9ydCwgaWdub3JpbmcgLS10aHJlYWRzIgogbXNnc3RyICJraMO0bmcgaOG7lyB0cuG7oyDEkWEgdHV54bq/biwgYuG7jyBxdWEgLS10aHJlYWRzIgogCi0jOiBidWlsdGluL2dyZXAuYzoxMDcxIGJ1aWx0aW4vaW5kZXgtcGFjay5jOjE1MzEgYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNzI1CisjOiBidWlsdGluL2dyZXAuYzoxMDczIGJ1aWx0aW4vaW5kZXgtcGFjay5jOjE1MzEgYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNzA1CiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgbnVtYmVyIG9mIHRocmVhZHMgc3BlY2lmaWVkICglZCkiCiBtc2dzdHIgInPhu5EgdHV54bq/biBjaOG7iSByYSBraMO0bmcgaOG7o3AgbOG7hyAoJWQpIgogCi0jOiBidWlsdGluL2dyZXAuYzoxMDk0CisjOiBidWlsdGluL2dyZXAuYzoxMDk2CiBtc2dpZCAiLS1vcGVuLWZpbGVzLWluLXBhZ2VyIG9ubHkgd29ya3Mgb24gdGhlIHdvcmt0cmVlIgogbXNnc3RyICItLW9wZW4tZmlsZXMtaW4tcGFnZXIgY2jhu4kgbMOgbSB2aeG7h2MgdHLDqm4gY8OieS1sw6BtLXZp4buHYyIKIAotIzogYnVpbHRpbi9ncmVwLmM6MTExNworIzogYnVpbHRpbi9ncmVwLmM6MTExOQogbXNnaWQgIm9wdGlvbiBub3Qgc3VwcG9ydGVkIHdpdGggLS1yZWN1cnNlLXN1Ym1vZHVsZXMiCiBtc2dzdHIgInTDuXkgY2jhu41uIGtow7RuZyDEkcaw4bujYyBo4buXIHRy4bujIHbhu5tpIC0tcmVjdXJzZS1zdWJtb2R1bGVzIgogCi0jOiBidWlsdGluL2dyZXAuYzoxMTIzCisjOiBidWlsdGluL2dyZXAuYzoxMTI1CiBtc2dpZCAiLS1jYWNoZWQgb3IgLS11bnRyYWNrZWQgY2Fubm90IGJlIHVzZWQgd2l0aCAtLW5vLWluZGV4IgogbXNnc3RyICItLWNhY2hlZCBoYXkgLS11bnRyYWNrZWQga2jDtG5nIMSRxrDhu6NjIHPhu60gZOG7pW5nIHbhu5tpIC0tbm8taW5kZXgiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjExMjkKKyM6IGJ1aWx0aW4vZ3JlcC5jOjExMzEKIG1zZ2lkICItLVtuby1dZXhjbHVkZS1zdGFuZGFyZCBjYW5ub3QgYmUgdXNlZCBmb3IgdHJhY2tlZCBjb250ZW50cyIKIG1zZ3N0ciAiLS1bbm8tXWV4Y2x1ZGUtc3RhbmRhcmQga2jDtG5nIHRo4buDIHPhu60gZOG7pW5nIGNobyBu4buZaSBkdW5nIGzGsHUgZOG6pXUgduG6v3QiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjExMzcKKyM6IGJ1aWx0aW4vZ3JlcC5jOjExMzkKIG1zZ2lkICJib3RoIC0tY2FjaGVkIGFuZCB0cmVlcyBhcmUgZ2l2ZW4iCiBtc2dzdHIgImPhuqMgaGFpIC0tY2FjaGVkIHbDoCBjw6FjIGPDonkgcGjhuqNpIMSRxrDhu6NjIGNo4buJIHJhIgogCkBAIC0xNDA1Miw3ICsxNDEzMiw3IEBACiBtc2dpZCAiUmVzb2x2aW5nIGRlbHRhcyIKIG1zZ3N0ciAixJBhbmcgcGjDom4gZ2nhuqNpIGPDoWMgZGVsdGEiCiAKLSM6IGJ1aWx0aW4vaW5kZXgtcGFjay5jOjEyMDUgYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNDk3CisjOiBidWlsdGluL2luZGV4LXBhY2suYzoxMjA1IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjQ4MQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gY3JlYXRlIHRocmVhZDogJXMiCiBtc2dzdHIgImtow7RuZyB0aOG7gyB04bqhbyB0dXnhur9uOiAlcyIKQEAgLTE0MTE1LDcgKzE0MTk1LDcgQEAKIG1zZ2lkICJjYW5ub3Qgc3RvcmUgaW5kZXggZmlsZSIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIGzGsHUgdHLhu68gdOG6rXAgdGluIGdoaSBt4bulYyBs4bulYyIKIAotIzogYnVpbHRpbi9pbmRleC1wYWNrLmM6MTUyNSBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI3MzYKKyM6IGJ1aWx0aW4vaW5kZXgtcGFjay5jOjE1MjUgYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNzE2CiAjLCBjLWZvcm1hdAogbXNnaWQgImJhZCBwYWNrLmluZGV4dmVyc2lvbj0lPFBSSXUzMj4iCiBtc2dzdHIgInNhaSBwYWNrLmluZGV4dmVyc2lvbj0lPFBSSXUzMj4iCkBAIC0xNDM5NCw3NCArMTQ0NzQsNzQgQEAKIG1zZ2lkICJnaXQgc2hvdyAlczogYmFkIGZpbGUiCiBtc2dzdHIgImdpdCBzaG93ICVzOiBzYWkgdOG6rXAgdGluIgogCi0jOiBidWlsdGluL2xvZy5jOjU0OSBidWlsdGluL2xvZy5jOjY0MworIzogYnVpbHRpbi9sb2cuYzo1NDkgYnVpbHRpbi9sb2cuYzo2NDQKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHJlYWQgb2JqZWN0ICVzIgogbXNnc3RyICJraMO0bmcgdGjhu4MgxJHhu41jIMSR4buRaSB0xrDhu6NuZyAlcyIKIAotIzogYnVpbHRpbi9sb2cuYzo2NjgKKyM6IGJ1aWx0aW4vbG9nLmM6NjY5CiAjLCBjLWZvcm1hdAogbXNnaWQgInVua25vd24gdHlwZTogJWQiCiBtc2dzdHIgImtow7RuZyBuaOG6rW4gcmEga2nhu4N1OiAlZCIKIAotIzogYnVpbHRpbi9sb2cuYzo3OTEKKyM6IGJ1aWx0aW4vbG9nLmM6NzkyCiBtc2dpZCAiZm9ybWF0LmhlYWRlcnMgd2l0aG91dCB2YWx1ZSIKIG1zZ3N0ciAiZm9ybWF0LmhlYWRlcnMga2jDtG5nIGPDsyBnacOhIHRy4buLIGPhu6UgdGjhu4MiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6OTA4CisjOiBidWlsdGluL2xvZy5jOjkwOQogbXNnaWQgIm5hbWUgb2Ygb3V0cHV0IGRpcmVjdG9yeSBpcyB0b28gbG9uZyIKIG1zZ3N0ciAidMOqbiBj4bunYSB0aMawIG3hu6VjIGvhur90IHh14bqldCBxdcOhIGTDoGkiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6OTI0CisjOiBidWlsdGluL2xvZy5jOjkyNQogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3Qgb3BlbiBwYXRjaCBmaWxlICVzIgogbXNnc3RyICJraMO0bmcgdGjhu4MgbeG7nyB04bqtcCB0aW4gbWnhur9uZyB2w6E6ICVzIgogCi0jOiBidWlsdGluL2xvZy5jOjk0MQorIzogYnVpbHRpbi9sb2cuYzo5NDIKIG1zZ2lkICJuZWVkIGV4YWN0bHkgb25lIHJhbmdlIgogbXNnc3RyICJj4bqnbiBjaMOtbmggeMOhYyBt4buZdCB2w7luZyIKIAotIzogYnVpbHRpbi9sb2cuYzo5NTEKKyM6IGJ1aWx0aW4vbG9nLmM6OTUyCiBtc2dpZCAibm90IGEgcmFuZ2UiCiBtc2dzdHIgImtow7RuZyBwaOG6o2kgbMOgIG3hu5l0IHbDuW5nIgogCi0jOiBidWlsdGluL2xvZy5jOjEwNzQKKyM6IGJ1aWx0aW4vbG9nLmM6MTA3NQogbXNnaWQgImNvdmVyIGxldHRlciBuZWVkcyBlbWFpbCBmb3JtYXQiCiBtc2dzdHIgIuKAnGNvdmVyIGxldHRlcuKAnSBj4bqnbiBjaG8gxJHhu4tuaCBk4bqhbmcgdGjGsCIKIAotIzogYnVpbHRpbi9sb2cuYzoxMDgwCisjOiBidWlsdGluL2xvZy5jOjEwODEKIG1zZ2lkICJmYWlsZWQgdG8gY3JlYXRlIGNvdmVyLWxldHRlciBmaWxlIgogbXNnc3RyICJn4bq3cCBs4buXaSBraGkgdOG6oW8gY8OhYyB04bqtcCB0aW4gY292ZXItbGV0dGVyIgogCi0jOiBidWlsdGluL2xvZy5jOjExNTkKKyM6IGJ1aWx0aW4vbG9nLmM6MTE2MAogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnNhbmUgaW4tcmVwbHktdG86ICVzIgogbXNnc3RyICJpbi1yZXBseS10byDEkWnDqm4gcuG7kzogJXMiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTE4NgorIzogYnVpbHRpbi9sb2cuYzoxMTg3CiBtc2dpZCAiZ2l0IGZvcm1hdC1wYXRjaCBbPG9wdGlvbnM+XSBbPHNpbmNlPiB8IDxyZXZpc2lvbi1yYW5nZT5dIgogbXNnc3RyICJnaXQgZm9ybWF0LXBhdGNoIFs8Y8OhYyB0w7l5IGNo4buNbj5dIFs8a+G7gy104burPiB8IDx2w7luZy14ZW0teMOpdD5dIgogCi0jOiBidWlsdGluL2xvZy5jOjEyNDQKKyM6IGJ1aWx0aW4vbG9nLmM6MTI0NQogbXNnaWQgInR3byBvdXRwdXQgZGlyZWN0b3JpZXM/IgogbXNnc3RyICJoYWkgdGjGsCBt4bulYyBr4bq/dCB4deG6pXQ/IgogCi0jOiBidWlsdGluL2xvZy5jOjEzNTUgYnVpbHRpbi9sb2cuYzoyMDk5IGJ1aWx0aW4vbG9nLmM6MjEwMSBidWlsdGluL2xvZy5jOjIxMTMKKyM6IGJ1aWx0aW4vbG9nLmM6MTM1NiBidWlsdGluL2xvZy5jOjIxMTYgYnVpbHRpbi9sb2cuYzoyMTE4IGJ1aWx0aW4vbG9nLmM6MjEzMAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmtub3duIGNvbW1pdCAlcyIKIG1zZ3N0ciAia2jDtG5nIGhp4buDdSBs4bqnbiBjaHV54buDbiBnaWFvICVzIgogCi0jOiBidWlsdGluL2xvZy5jOjEzNjUgYnVpbHRpbi9yZXBsYWNlLmM6NTggYnVpbHRpbi9yZXBsYWNlLmM6MjA3CisjOiBidWlsdGluL2xvZy5jOjEzNjYgYnVpbHRpbi9yZXBsYWNlLmM6NTggYnVpbHRpbi9yZXBsYWNlLmM6MjA3CiAjOiBidWlsdGluL3JlcGxhY2UuYzoyMTAKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIHJlc29sdmUgJyVzJyBhcyBhIHZhbGlkIHJlZiIKIG1zZ3N0ciAiZ+G6t3AgbOG7l2kga2hpIHBow6JuIGdp4bqjaSDigJwlc+KAnSBuaMawIGzDoCBt4buZdCB0aGFtIGNoaeG6v3UgaOG7o3AgbOG7hyIKIAotIzogYnVpbHRpbi9sb2cuYzoxMzcwCisjOiBidWlsdGluL2xvZy5jOjEzNzEKIG1zZ2lkICJjb3VsZCBub3QgZmluZCBleGFjdCBtZXJnZSBiYXNlIgogbXNnc3RyICJraMO0bmcgdMOsbSB0aOG6pXkgbuG7gW4gaMOyYSB0cuG7mW4gY2jDrW5oIHjDoWMiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTM3NAorIzogYnVpbHRpbi9sb2cuYzoxMzc1CiBtc2dpZCAiIgogImZhaWxlZCB0byBnZXQgdXBzdHJlYW0sIGlmIHlvdSB3YW50IHRvIHJlY29yZCBiYXNlIGNvbW1pdCBhdXRvbWF0aWNhbGx5LFxuIgogInBsZWFzZSB1c2UgZ2l0IGJyYW5jaCAtLXNldC11cHN0cmVhbS10byB0byB0cmFjayBhIHJlbW90ZSBicmFuY2guXG4iCkBAIC0xNDQ3MiwyNzEgKzE0NTUyLDI3MSBAQAogIm5ow6FuaCBtw6F5IGNo4bunLiBIb+G6t2MgbMOgIGLhuqFuIGPDsyB0aOG7gyBjaOG7iSDEkeG7i25oIGzhuqduIGNodXnhu4NuIGdpYW8gbuG7gW4gYuG6sW5nXG4iCiAiXCItLWJhc2U9PGJhc2UtY29tbWl0LWlkPlwiIG3hu5l0IGPDoWNoIHRo4bunIGPDtG5nIgogCi0jOiBidWlsdGluL2xvZy5jOjEzOTQKKyM6IGJ1aWx0aW4vbG9nLmM6MTM5NQogbXNnaWQgImZhaWxlZCB0byBmaW5kIGV4YWN0IG1lcmdlIGJhc2UiCiBtc2dzdHIgImfhurdwIGzhu5dpIGtoaSB0w6xtIG7hu4FuIGjDsmEgdHLhu5luIGNow61uaCB4w6FjIgogCi0jOiBidWlsdGluL2xvZy5jOjE0MDUKKyM6IGJ1aWx0aW4vbG9nLmM6MTQwNgogbXNnaWQgImJhc2UgY29tbWl0IHNob3VsZCBiZSB0aGUgYW5jZXN0b3Igb2YgcmV2aXNpb24gbGlzdCIKIG1zZ3N0ciAibOG6p24gY2h1eeG7g24gZ2lhbyBu4buBbiBraMO0bmcgbMOgIHThu5UgdGnDqm4gY+G7p2EgZGFuaCBzw6FjaCDEkWnhu4NtIHjDqXQgZHV54buHdCIKIAotIzogYnVpbHRpbi9sb2cuYzoxNDA5CisjOiBidWlsdGluL2xvZy5jOjE0MTAKIG1zZ2lkICJiYXNlIGNvbW1pdCBzaG91bGRuJ3QgYmUgaW4gcmV2aXNpb24gbGlzdCIKIG1zZ3N0ciAibOG6p24gY2h1eeG7g24gZ2lhbyBu4buBbiBraMO0bmcgxJHGsOG7o2MgdHJvbmcgZGFuaCBzw6FjaCDEkWnhu4NtIHjDqXQgZHV54buHdCIKIAotIzogYnVpbHRpbi9sb2cuYzoxNDYyCisjOiBidWlsdGluL2xvZy5jOjE0NjMKIG1zZ2lkICJjYW5ub3QgZ2V0IHBhdGNoIGlkIgogbXNnc3RyICJraMO0bmcgdGjhu4MgbOG6pXkgbcOjIG1p4bq/bmcgdsOhIgogCi0jOiBidWlsdGluL2xvZy5jOjE1MTQKKyM6IGJ1aWx0aW4vbG9nLmM6MTUxNQogbXNnaWQgImZhaWxlZCB0byBpbmZlciByYW5nZS1kaWZmIHJhbmdlcyIKIG1zZ3N0ciAiZ+G6t3AgbOG7l2kga2hpIHN1eSBsdeG6rW4gcmFuZ2UtZGlmZiAodsO5bmcga2jDoWMgYmnhu4d0KSIKIAotIzogYnVpbHRpbi9sb2cuYzoxNTU5CisjOiBidWlsdGluL2xvZy5jOjE1NjAKIG1zZ2lkICJ1c2UgW1BBVENIIG4vbV0gZXZlbiB3aXRoIGEgc2luZ2xlIHBhdGNoIgogbXNnc3RyICJkw7luZyBbUEFUQ0ggbi9tXSBuZ2F5IGPhuqMgduG7m2kgbWnhur9uZyB2w6EgxJHGoW4iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTU2MgorIzogYnVpbHRpbi9sb2cuYzoxNTYzCiBtc2dpZCAidXNlIFtQQVRDSF0gZXZlbiB3aXRoIG11bHRpcGxlIHBhdGNoZXMiCiBtc2dzdHIgImTDuW5nIFtWw4FdIG5nYXkgY+G6oyB24bubaSBjw6FjIG1p4bq/bmcgdsOhIHBo4bupYyB04bqhcCIKIAotIzogYnVpbHRpbi9sb2cuYzoxNTY2CisjOiBidWlsdGluL2xvZy5jOjE1NjcKIG1zZ2lkICJwcmludCBwYXRjaGVzIHRvIHN0YW5kYXJkIG91dCIKIG1zZ3N0ciAiaGnhu4NuIHRo4buLIG1p4bq/bmcgdsOhIHJhIMSR4bqndSByYSBjaHXhuqluIgogCi0jOiBidWlsdGluL2xvZy5jOjE1NjgKKyM6IGJ1aWx0aW4vbG9nLmM6MTU2OQogbXNnaWQgImdlbmVyYXRlIGEgY292ZXIgbGV0dGVyIgogbXNnc3RyICJ04bqhbyBiw6wgdGjGsCIKIAotIzogYnVpbHRpbi9sb2cuYzoxNTcwCisjOiBidWlsdGluL2xvZy5jOjE1NzEKIG1zZ2lkICJ1c2Ugc2ltcGxlIG51bWJlciBzZXF1ZW5jZSBmb3Igb3V0cHV0IGZpbGUgbmFtZXMiCiBtc2dzdHIgInPhu60gZOG7pW5nIGNo4buXaSBkw6N5IHPhu5EgZOG6oW5nIMSRxqFuIGdp4bqjbiBjaG8gdMOqbiB04bqtcC10aW4geHXhuqV0IHJhIgogCi0jOiBidWlsdGluL2xvZy5jOjE1NzEKKyM6IGJ1aWx0aW4vbG9nLmM6MTU3MgogbXNnaWQgInNmeCIKIG1zZ3N0ciAic2Z4IgogCi0jOiBidWlsdGluL2xvZy5jOjE1NzIKKyM6IGJ1aWx0aW4vbG9nLmM6MTU3MwogbXNnaWQgInVzZSA8c2Z4PiBpbnN0ZWFkIG9mICcucGF0Y2gnIgogbXNnc3RyICJz4butIGThu6VuZyA8c2Z4PiB0aGF5IGNobyDigJwucGF0Y2jigJ0iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTU3NAorIzogYnVpbHRpbi9sb2cuYzoxNTc1CiBtc2dpZCAic3RhcnQgbnVtYmVyaW5nIHBhdGNoZXMgYXQgPG4+IGluc3RlYWQgb2YgMSIKIG1zZ3N0ciAiYuG6r3QgxJHhuqd1IMSRw6FuaCBz4buRIG1p4bq/bmcgdsOhIHThu6sgPG4+IHRoYXkgdsOsIDEiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTU3NgorIzogYnVpbHRpbi9sb2cuYzoxNTc3CiBtc2dpZCAibWFyayB0aGUgc2VyaWVzIGFzIE50aCByZS1yb2xsIgogbXNnc3RyICLEkcOhbmggZOG6pXUgY2h14buXaSBu4buRaSB0aeG6v3AgZOG6oW5nIHRo4bupLU4gcmUtcm9sbCIKIAotIzogYnVpbHRpbi9sb2cuYzoxNTc4CisjOiBidWlsdGluL2xvZy5jOjE1NzkKIG1zZ2lkICJVc2UgW1JGQyBQQVRDSF0gaW5zdGVhZCBvZiBbUEFUQ0hdIgogbXNnc3RyICJEw7luZyBbUkZDIFbDgV0gdGhheSBjaG8gW1bDgV0iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTU4MQorIzogYnVpbHRpbi9sb2cuYzoxNTgyCiBtc2dpZCAiVXNlIFs8cHJlZml4Pl0gaW5zdGVhZCBvZiBbUEFUQ0hdIgogbXNnc3RyICJEw7luZyBbPHRp4buBbi104buRPl0gdGhheSBjaG8gW1bDgV0iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTU4NAorIzogYnVpbHRpbi9sb2cuYzoxNTg1CiBtc2dpZCAic3RvcmUgcmVzdWx0aW5nIGZpbGVzIGluIDxkaXI+IgogbXNnc3RyICJsxrB1IGPDoWMgdOG6rXAgdGluIGvhur90IHF14bqjIHRyb25nIDx0Lm3hu6VjPiIKIAotIzogYnVpbHRpbi9sb2cuYzoxNTg3CisjOiBidWlsdGluL2xvZy5jOjE1ODgKIG1zZ2lkICJkb24ndCBzdHJpcC9hZGQgW1BBVENIXSIKIG1zZ3N0ciAia2jDtG5nIHN0cmlwL2FkZCBbVsOBXSIKIAotIzogYnVpbHRpbi9sb2cuYzoxNTkwCisjOiBidWlsdGluL2xvZy5jOjE1OTEKIG1zZ2lkICJkb24ndCBvdXRwdXQgYmluYXJ5IGRpZmZzIgogbXNnc3RyICJraMO0bmcga+G6v3QgeHXhuqV0IGRpZmYgKG5o4buvbmcga2jDoWMgYmnhu4d0KSBuaOG7iyBwaMOibiIKIAotIzogYnVpbHRpbi9sb2cuYzoxNTkyCisjOiBidWlsdGluL2xvZy5jOjE1OTMKIG1zZ2lkICJvdXRwdXQgYWxsLXplcm8gaGFzaCBpbiBGcm9tIGhlYWRlciIKIG1zZ3N0ciAieHXhuqV0IG3hu41pIG3DoyBixINtIGFsbC16ZXJvIHRyb25nIHBo4bqnbiDEkeG6p3UgRnJvbSIKIAotIzogYnVpbHRpbi9sb2cuYzoxNTk0CisjOiBidWlsdGluL2xvZy5jOjE1OTUKIG1zZ2lkICJkb24ndCBpbmNsdWRlIGEgcGF0Y2ggbWF0Y2hpbmcgYSBjb21taXQgdXBzdHJlYW0iCiBtc2dzdHIgImtow7RuZyBiYW8gZ+G7k20gbWnhur9uZyB2w6Ega2jhu5twIHbhu5tpIG3hu5l0IGzhuqduIGNodXnhu4NuIGdpYW8gdGjGsOG7o25nIG5ndeG7k24iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTU5NgorIzogYnVpbHRpbi9sb2cuYzoxNTk3CiBtc2dpZCAic2hvdyBwYXRjaCBmb3JtYXQgaW5zdGVhZCBvZiBkZWZhdWx0IChwYXRjaCArIHN0YXQpIgogbXNnc3RyICJoaeG7g24gdGjhu4sgxJHhu4tuaCBk4bqhbmcgbWnhur9uZyB2w6EgdGhheSB2w6wgbeG6t2MgxJHhu4tuaCAobWnhur9uZyB2w6EgKyB0aOG7kW5nIGvDqikiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTU5OAorIzogYnVpbHRpbi9sb2cuYzoxNTk5CiBtc2dpZCAiTWVzc2FnaW5nIgogbXNnc3RyICJM4budaSBuaOG6r24iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTU5OQorIzogYnVpbHRpbi9sb2cuYzoxNjAwCiBtc2dpZCAiaGVhZGVyIgogbXNnc3RyICLEkeG6p3UgxJHhu4EgdGjGsCIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjAwCisjOiBidWlsdGluL2xvZy5jOjE2MDEKIG1zZ2lkICJhZGQgZW1haWwgaGVhZGVyIgogbXNnc3RyICJ0aMOqbSDEkeG6p3UgxJHhu4EgdGjGsCIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjAxIGJ1aWx0aW4vbG9nLmM6MTYwMworIzogYnVpbHRpbi9sb2cuYzoxNjAyIGJ1aWx0aW4vbG9nLmM6MTYwNAogbXNnaWQgImVtYWlsIgogbXNnc3RyICJ0aMawIMSRaeG7h24gdOG7rSIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjAxCisjOiBidWlsdGluL2xvZy5jOjE2MDIKIG1zZ2lkICJhZGQgVG86IGhlYWRlciIKIG1zZ3N0ciAidGjDqm0gVG86IMSR4bqndSDEkeG7gSB0aMawIgogCi0jOiBidWlsdGluL2xvZy5jOjE2MDMKKyM6IGJ1aWx0aW4vbG9nLmM6MTYwNAogbXNnaWQgImFkZCBDYzogaGVhZGVyIgogbXNnc3RyICJ0aMOqbSBDYzogxJHhuqd1IMSR4buBIHRoxrAiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTYwNQorIzogYnVpbHRpbi9sb2cuYzoxNjA2CiBtc2dpZCAiaWRlbnQiCiBtc2dzdHIgInRo4buldCBs4buBIgogCi0jOiBidWlsdGluL2xvZy5jOjE2MDYKKyM6IGJ1aWx0aW4vbG9nLmM6MTYwNwogbXNnaWQgInNldCBGcm9tIGFkZHJlc3MgdG8gPGlkZW50PiAob3IgY29tbWl0dGVyIGlkZW50IGlmIGFic2VudCkiCiBtc2dzdHIgIiIKICLEkeG6t3Qg4oCcxJDhu4thIGNo4buJIGfhu61p4oCdIHRow6BuaCA8dGjhu6UgbOG7gT4gKGhv4bq3YyB0aOG7pXQgbOG7gSBuZ8aw4budaSBjb21taXQgbuG6v3UgYuG7jyBxdcOqbikiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTYwOAorIzogYnVpbHRpbi9sb2cuYzoxNjA5CiBtc2dpZCAibWVzc2FnZS1pZCIKIG1zZ3N0ciAibWVzc2FnZS1pZCIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjA5CisjOiBidWlsdGluL2xvZy5jOjE2MTAKIG1zZ2lkICJtYWtlIGZpcnN0IG1haWwgYSByZXBseSB0byA8bWVzc2FnZS1pZD4iCiBtc2dzdHIgImTDuW5nIHRoxrAgxJHhuqd1IHRpw6puIMSR4buDIHRy4bqjIGzhu51pIDxtZXNzYWdlLWlkPiIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjEwIGJ1aWx0aW4vbG9nLmM6MTYxMworIzogYnVpbHRpbi9sb2cuYzoxNjExIGJ1aWx0aW4vbG9nLmM6MTYxNAogbXNnaWQgImJvdW5kYXJ5IgogbXNnc3RyICJyYW5oIGdp4bubaSIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjExCisjOiBidWlsdGluL2xvZy5jOjE2MTIKIG1zZ2lkICJhdHRhY2ggdGhlIHBhdGNoIgogbXNnc3RyICLEkcOtbmgga8OobSBtaeG6v25nIHbDoSIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjE0CisjOiBidWlsdGluL2xvZy5jOjE2MTUKIG1zZ2lkICJpbmxpbmUgdGhlIHBhdGNoIgogbXNnc3RyICJkw7luZyBtaeG6v25nIHbDoSBsw6BtIG7hu5lpIGR1bmciCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTYxOAorIzogYnVpbHRpbi9sb2cuYzoxNjE5CiBtc2dpZCAiZW5hYmxlIG1lc3NhZ2UgdGhyZWFkaW5nLCBzdHlsZXM6IHNoYWxsb3csIGRlZXAiCiBtc2dzdHIgImNobyBwaMOpcCBsdeG7k25nIGzhu51pIG5o4bqvbiwga2nhu4N1OiDigJxzaGFsbG934oCdLCDigJxkZWVw4oCdIgogCi0jOiBidWlsdGluL2xvZy5jOjE2MjAKKyM6IGJ1aWx0aW4vbG9nLmM6MTYyMQogbXNnaWQgInNpZ25hdHVyZSIKIG1zZ3N0ciAiY2jhu68ga8O9IgogCi0jOiBidWlsdGluL2xvZy5jOjE2MjEKKyM6IGJ1aWx0aW4vbG9nLmM6MTYyMgogbXNnaWQgImFkZCBhIHNpZ25hdHVyZSIKIG1zZ3N0ciAidGjDqm0gY2jhu68ga8O9IgogCi0jOiBidWlsdGluL2xvZy5jOjE2MjIKKyM6IGJ1aWx0aW4vbG9nLmM6MTYyMwogbXNnaWQgImJhc2UtY29tbWl0IgogbXNnc3RyICJs4bqnbl9jaHV54buDbl9naWFvX27hu4FuIgogCi0jOiBidWlsdGluL2xvZy5jOjE2MjMKKyM6IGJ1aWx0aW4vbG9nLmM6MTYyNAogbXNnaWQgImFkZCBwcmVyZXF1aXNpdGUgdHJlZSBpbmZvIHRvIHRoZSBwYXRjaCBzZXJpZXMiCiBtc2dzdHIgImFkZCB0csaw4bubYyBo4bq/dCDEkcOyaSBo4buPaSB0aMO0bmcgdGluIGPDonkgdOG7m2kgc8OqLXJpIG1p4bq/bmcgdsOhIgogCi0jOiBidWlsdGluL2xvZy5jOjE2MjUKKyM6IGJ1aWx0aW4vbG9nLmM6MTYyNgogbXNnaWQgImFkZCBhIHNpZ25hdHVyZSBmcm9tIGEgZmlsZSIKIG1zZ3N0ciAidGjDqm0gY2jhu68ga8O9IHThu6sgbeG7mXQgdOG6rXAgdGluIgogCi0jOiBidWlsdGluL2xvZy5jOjE2MjYKKyM6IGJ1aWx0aW4vbG9nLmM6MTYyNwogbXNnaWQgImRvbid0IHByaW50IHRoZSBwYXRjaCBmaWxlbmFtZXMiCiBtc2dzdHIgImtow7RuZyBoaeG7g24gdGjhu4sgY8OhYyB0w6puIHThuq1wIHRpbiBj4bunYSBtaeG6v25nIHbDoSIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjI4CisjOiBidWlsdGluL2xvZy5jOjE2MjkKIG1zZ2lkICJzaG93IHByb2dyZXNzIHdoaWxlIGdlbmVyYXRpbmcgcGF0Y2hlcyIKIG1zZ3N0ciAiaGnhu4NuIHRo4buLIGLhu5kgxJFvIHRp4bq/biB0cmnhu4NuIHRyb25nIGtoaSB04bqhbyBjw6FjIG1p4bq/bmcgdsOhIgogCi0jOiBidWlsdGluL2xvZy5jOjE2MzAKKyM6IGJ1aWx0aW4vbG9nLmM6MTYzMQogbXNnaWQgInNob3cgY2hhbmdlcyBhZ2FpbnN0IDxyZXY+IGluIGNvdmVyIGxldHRlciBvciBzaW5nbGUgcGF0Y2giCiBtc2dzdHIgIiIKICJoaeG7g24gdGjhu4sgY8OhYyB0aGF5IMSR4buVaSBk4buxYSB0csOqbiA8cmV2PiB0cm9uZyBjw6FjIGNo4buvIGJhbyBi4buNYyBob+G6t2MgbWnhur9uZyB2w6EgxJHGoW4iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTYzMworIzogYnVpbHRpbi9sb2cuYzoxNjM0CiBtc2dpZCAic2hvdyBjaGFuZ2VzIGFnYWluc3QgPHJlZnNwZWM+IGluIGNvdmVyIGxldHRlciBvciBzaW5nbGUgcGF0Y2giCiBtc2dzdHIgIiIKICJoaeG7g24gdGjhu4sgY8OhYyB0aGF5IMSR4buVaSBk4buxYSB0csOqbiA8cmVmc3BlYz4gdHJvbmcgY8OhYyBjaOG7ryBiYW8gYuG7jWMgaG/hurdjIG1p4bq/bmcgdsOhICIKICLEkcahbiIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjM1CisjOiBidWlsdGluL2xvZy5jOjE2MzYKIG1zZ2lkICJwZXJjZW50YWdlIGJ5IHdoaWNoIGNyZWF0aW9uIGlzIHdlaWdodGVkIgogbXNnc3RyICJ04bu3IGzhu4cgcGjhuqduIHRyxINtIHRoZW8gY8OhaSB04bqhbyBsw6Agd2VpZ2h0ZWQiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTcxMAorIzogYnVpbHRpbi9sb2cuYzoxNzExCiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgaWRlbnQgbGluZTogJXMiCiBtc2dzdHIgImTDsm5nIHRo4buldCBs4buBIGtow7RuZyBo4bujcCBs4buHOiAlcyIKIAotIzogYnVpbHRpbi9sb2cuYzoxNzI1CisjOiBidWlsdGluL2xvZy5jOjE3MjYKIG1zZ2lkICItbiBhbmQgLWsgYXJlIG11dHVhbGx5IGV4Y2x1c2l2ZSIKIG1zZ3N0ciAiLW4gdsOgICAtayBsb+G6oWkgdOG7qyBs4bqrbiBuaGF1IgogCi0jOiBidWlsdGluL2xvZy5jOjE3MjcKKyM6IGJ1aWx0aW4vbG9nLmM6MTcyOAogbXNnaWQgIi0tc3ViamVjdC1wcmVmaXgvLS1yZmMgYW5kIC1rIGFyZSBtdXR1YWxseSBleGNsdXNpdmUiCiBtc2dzdHIgIi0tc3ViamVjdC1wcmVmaXgvLS1yZmMgdsOgIC1rIHh1bmcga2jhuq9jIG5oYXUiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTczNQorIzogYnVpbHRpbi9sb2cuYzoxNzM2CiBtc2dpZCAiLS1uYW1lLW9ubHkgZG9lcyBub3QgbWFrZSBzZW5zZSIKIG1zZ3N0ciAiLS1uYW1lLW9ubHkga2jDtG5nIGjhu6NwIGzDvSIKIAotIzogYnVpbHRpbi9sb2cuYzoxNzM3CisjOiBidWlsdGluL2xvZy5jOjE3MzgKIG1zZ2lkICItLW5hbWUtc3RhdHVzIGRvZXMgbm90IG1ha2Ugc2Vuc2UiCiBtc2dzdHIgIi0tbmFtZS1zdGF0dXMga2jDtG5nIGjhu6NwIGzDvSIKIAotIzogYnVpbHRpbi9sb2cuYzoxNzM5CisjOiBidWlsdGluL2xvZy5jOjE3NDAKIG1zZ2lkICItLWNoZWNrIGRvZXMgbm90IG1ha2Ugc2Vuc2UiCiBtc2dzdHIgIi0tY2hlY2sga2jDtG5nIGjhu6NwIGzDvSIKIAotIzogYnVpbHRpbi9sb2cuYzoxNzcxCisjOiBidWlsdGluL2xvZy5jOjE3NzMKIG1zZ2lkICJzdGFuZGFyZCBvdXRwdXQsIG9yIGRpcmVjdG9yeSwgd2hpY2ggb25lPyIKIG1zZ3N0ciAixJHhuqd1IHJhIGNodeG6qW4sIGhheSB0aMawIG3hu6VjLCBjaOG7jW4gY8OhaSBuw6BvPyIKIAotIzogYnVpbHRpbi9sb2cuYzoxODYwCisjOiBidWlsdGluL2xvZy5jOjE4NzcKIG1zZ2lkICItLWludGVyZGlmZiByZXF1aXJlcyAtLWNvdmVyLWxldHRlciBvciBzaW5nbGUgcGF0Y2giCiBtc2dzdHIgIi0taW50ZXJkaWZmIGPhuqduIC0tY292ZXItbGV0dGVyIGhv4bq3YyB2w6EgxJHGoW4iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTg2NAorIzogYnVpbHRpbi9sb2cuYzoxODgxCiBtc2dpZCAiSW50ZXJkaWZmOiIKIG1zZ3N0ciAiSW50ZXJkaWZmOiIKIAotIzogYnVpbHRpbi9sb2cuYzoxODY1CisjOiBidWlsdGluL2xvZy5jOjE4ODIKICMsIGMtZm9ybWF0CiBtc2dpZCAiSW50ZXJkaWZmIGFnYWluc3QgdiVkOiIKIG1zZ3N0ciAiSW50ZXJkaWZmIGThu7FhIHRyw6puIHYlZDoiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTg3MQorIzogYnVpbHRpbi9sb2cuYzoxODg4CiBtc2dpZCAiLS1jcmVhdGlvbi1mYWN0b3IgcmVxdWlyZXMgLS1yYW5nZS1kaWZmIgogbXNnc3RyICItLWNyZWF0aW9uLWZhY3RvciB5w6p1IGPhuqd1IC0tcmFuZ2UtZGlmZiIKIAotIzogYnVpbHRpbi9sb2cuYzoxODc1CisjOiBidWlsdGluL2xvZy5jOjE4OTIKIG1zZ2lkICItLXJhbmdlLWRpZmYgcmVxdWlyZXMgLS1jb3Zlci1sZXR0ZXIgb3Igc2luZ2xlIHBhdGNoIgogbXNnc3RyICItLXJhbmdlLWRpZmYgecOqdSBj4bqndSAtLWNvdmVyLWxldHRlciBob+G6t2MgbWnhur9uZyB2w6EgxJHGoW4iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTg4MworIzogYnVpbHRpbi9sb2cuYzoxOTAwCiBtc2dpZCAiUmFuZ2UtZGlmZjoiCiBtc2dzdHIgIlJhbmdlLWRpZmY6IgogCi0jOiBidWlsdGluL2xvZy5jOjE4ODQKKyM6IGJ1aWx0aW4vbG9nLmM6MTkwMQogIywgYy1mb3JtYXQKIG1zZ2lkICJSYW5nZS1kaWZmIGFnYWluc3QgdiVkOiIKIG1zZ3N0ciAiUmFuZ2UtZGlmZiBk4buxYSB0csOqbiB2JWQ6IgogCi0jOiBidWlsdGluL2xvZy5jOjE4OTUKKyM6IGJ1aWx0aW4vbG9nLmM6MTkxMgogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gcmVhZCBzaWduYXR1cmUgZmlsZSAnJXMnIgogbXNnc3RyICJraMO0bmcgdGjhu4MgxJHhu41jIHThuq1wIHRpbiBjaOG7ryBrw70g4oCcJXPigJ0iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTkzMQorIzogYnVpbHRpbi9sb2cuYzoxOTQ4CiBtc2dpZCAiR2VuZXJhdGluZyBwYXRjaGVzIgogbXNnc3RyICLEkGFuZyB04bqhbyBjw6FjIG1p4bq/bmcgdsOhIgogCi0jOiBidWlsdGluL2xvZy5jOjE5NzUKKyM6IGJ1aWx0aW4vbG9nLmM6MTk5MgogbXNnaWQgImZhaWxlZCB0byBjcmVhdGUgb3V0cHV0IGZpbGVzIgogbXNnc3RyICJn4bq3cCBs4buXaSBraGkgdOG6oW8gY8OhYyB04bqtcCB0aW4ga+G6v3QgeHXhuqV0IgogCi0jOiBidWlsdGluL2xvZy5jOjIwMzQKKyM6IGJ1aWx0aW4vbG9nLmM6MjA1MQogbXNnaWQgImdpdCBjaGVycnkgWy12XSBbPHVwc3RyZWFtPiBbPGhlYWQ+IFs8bGltaXQ+XV1dIgogbXNnc3RyICJnaXQgY2hlcnJ5IFstdl0gWzx0aMaw4bujbmctbmd14buTbj4gWzzEkeG6p3U+IFs8Z2nhu5tpLWjhuqFuPl1dXSIKIAotIzogYnVpbHRpbi9sb2cuYzoyMDg4CisjOiBidWlsdGluL2xvZy5jOjIxMDUKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkNvdWxkIG5vdCBmaW5kIGEgdHJhY2tlZCByZW1vdGUgYnJhbmNoLCBwbGVhc2Ugc3BlY2lmeSA8dXBzdHJlYW0+IG1hbnVhbGx5LlxuIgpAQCAtMTQ4NjUsNyArMTQ5NDUsNyBAQAogbXNnaWQgImRvIG5vdCBwcmludCByZW1vdGUgVVJMIgogbXNnc3RyICJraMO0bmcgaGnhu4NuIHRo4buLIFVSTCBtw6F5IGNo4bunIgogCi0jOiBidWlsdGluL2xzLXJlbW90ZS5jOjYwIGJ1aWx0aW4vbHMtcmVtb3RlLmM6NjIgYnVpbHRpbi9yZWJhc2UuYzoxNDY0CisjOiBidWlsdGluL2xzLXJlbW90ZS5jOjYwIGJ1aWx0aW4vbHMtcmVtb3RlLmM6NjIgYnVpbHRpbi9yZWJhc2UuYzoxNDg4CiBtc2dpZCAiZXhlYyIKIG1zZ3N0ciAidGjhu7FjIHRoaSIKIApAQCAtMTQ5NzQsMzEgKzE1MDU0LDMxIEBACiBtc2dpZCAiQXZhaWxhYmxlIGN1c3RvbSBzdHJhdGVnaWVzIGFyZToiCiBtc2dzdHIgIkPDoWMgY2hp4bq/biBsxrDhu6NjIHTDuXkgY2jhu4luaCBz4bq1biBzw6BuZyBsw6A6IgogCi0jOiBidWlsdGluL21lcmdlLmM6MjQ0IGJ1aWx0aW4vcHVsbC5jOjE1MQorIzogYnVpbHRpbi9tZXJnZS5jOjI0NCBidWlsdGluL3B1bGwuYzoxNTIKIG1zZ2lkICJkbyBub3Qgc2hvdyBhIGRpZmZzdGF0IGF0IHRoZSBlbmQgb2YgdGhlIG1lcmdlIgogbXNnc3RyICJraMO0bmcgaGnhu4NuIHRo4buLIHRo4buRbmcga8OqIGtow6FjIGJp4buHdCB04bqhaSBjdeG7kWkgY+G7p2EgbOG6p24gaMOyYSB0cuG7mW4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoyNDcgYnVpbHRpbi9wdWxsLmM6MTU0CisjOiBidWlsdGluL21lcmdlLmM6MjQ3IGJ1aWx0aW4vcHVsbC5jOjE1NQogbXNnaWQgInNob3cgYSBkaWZmc3RhdCBhdCB0aGUgZW5kIG9mIHRoZSBtZXJnZSIKIG1zZ3N0ciAiaGnhu4NuIHRo4buLIHRo4buRbmcga8OqIGtow6FjIGJp4buHdCB04bqhaSBjdeG7kWkgY+G7p2EgaMOyYSB0cuG7mW4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoyNDggYnVpbHRpbi9wdWxsLmM6MTU3CisjOiBidWlsdGluL21lcmdlLmM6MjQ4IGJ1aWx0aW4vcHVsbC5jOjE1OAogbXNnaWQgIihzeW5vbnltIHRvIC0tc3RhdCkiCiBtc2dzdHIgIijEkeG7k25nIG5naMSpYSB24bubaSAtLXN0YXQpIgogCi0jOiBidWlsdGluL21lcmdlLmM6MjUwIGJ1aWx0aW4vcHVsbC5jOjE2MAorIzogYnVpbHRpbi9tZXJnZS5jOjI1MCBidWlsdGluL3B1bGwuYzoxNjEKIG1zZ2lkICJhZGQgKGF0IG1vc3QgPG4+KSBlbnRyaWVzIGZyb20gc2hvcnRsb2cgdG8gbWVyZ2UgY29tbWl0IG1lc3NhZ2UiCiBtc2dzdHIgInRow6ptICjDrXQgbmjhuqV0IDxuPikgbeG7pWMgdOG7qyBzaG9ydGxvZyBjaG8gZ2hpIGNow7ogY2h1eeG7g24gZ2lhbyBow7JhIHRy4buZbiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjI1MyBidWlsdGluL3B1bGwuYzoxNjYKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoyNTMgYnVpbHRpbi9wdWxsLmM6MTY3CiBtc2dpZCAiY3JlYXRlIGEgc2luZ2xlIGNvbW1pdCBpbnN0ZWFkIG9mIGRvaW5nIGEgbWVyZ2UiCiBtc2dzdHIgInThuqFvIG3hu5l0IGzhuqduIGNodXnhu4NuIGdpYW8gxJHGsG9uIHRoYXkgdsOsIHRo4buxYyBoaeG7h24gdmnhu4djIGjDsmEgdHLhu5luIgogCi0jOiBidWlsdGluL21lcmdlLmM6MjU1IGJ1aWx0aW4vcHVsbC5jOjE2OQorIzogYnVpbHRpbi9tZXJnZS5jOjI1NSBidWlsdGluL3B1bGwuYzoxNzAKIG1zZ2lkICJwZXJmb3JtIGEgY29tbWl0IGlmIHRoZSBtZXJnZSBzdWNjZWVkcyAoZGVmYXVsdCkiCiBtc2dzdHIgInRo4buxYyBoaeG7h24gY2h1eeG7g24gZ2lhbyBu4bq/dSBow7JhIHRy4buZbiB0aMOgbmggY8O0bmcgKG3hurdjIMSR4buLbmgpIgogCi0jOiBidWlsdGluL21lcmdlLmM6MjU3IGJ1aWx0aW4vcHVsbC5jOjE3MgorIzogYnVpbHRpbi9tZXJnZS5jOjI1NyBidWlsdGluL3B1bGwuYzoxNzMKIG1zZ2lkICJlZGl0IG1lc3NhZ2UgYmVmb3JlIGNvbW1pdHRpbmciCiBtc2dzdHIgInPhu61hIGNow7ogdGjDrWNoIHRyxrDhu5tjIGtoaSBjaHV54buDbiBnaWFvIgogCkBAIC0xNTAwNiwyOCArMTUwODYsMjggQEAKIG1zZ2lkICJhbGxvdyBmYXN0LWZvcndhcmQgKGRlZmF1bHQpIgogbXNnc3RyICJjaG8gcGjDqXAgY2h1eeG7g24tdGnhur9wLW5oYW5oICht4bq3YyDEkeG7i25oKSIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjI2MSBidWlsdGluL3B1bGwuYzoxNzkKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoyNjEgYnVpbHRpbi9wdWxsLmM6MTgwCiBtc2dpZCAiYWJvcnQgaWYgZmFzdC1mb3J3YXJkIGlzIG5vdCBwb3NzaWJsZSIKIG1zZ3N0ciAiYuG7jyBxdWEgbuG6v3UgY2h1eeG7g24tdGnhur9wLW5oYW5oIGtow7RuZyB0aOG7gyDEkcaw4bujYyIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjI2NSBidWlsdGluL3B1bGwuYzoxODIKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoyNjUgYnVpbHRpbi9wdWxsLmM6MTgzCiBtc2dpZCAidmVyaWZ5IHRoYXQgdGhlIG5hbWVkIGNvbW1pdCBoYXMgYSB2YWxpZCBHUEcgc2lnbmF0dXJlIgogbXNnc3RyICJ0aOG6qW0gdHJhIHhlbSBs4bqnbiBjaHV54buDbiBnaWFvIGPDsyB0w6puIMSRw7MgY8OzIGNo4buvIGvDvSBHUEcgaOG7o3AgbOG7hyBoYXkga2jDtG5nIgogCi0jOiBidWlsdGluL21lcmdlLmM6MjY2IGJ1aWx0aW4vbm90ZXMuYzo3ODcgYnVpbHRpbi9wdWxsLmM6MTg2Ci0jOiBidWlsdGluL3JlYmFzZS5jOjQ5MiBidWlsdGluL3JlYmFzZS5jOjE0NzcgYnVpbHRpbi9yZXZlcnQuYzoxMTQKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoyNjYgYnVpbHRpbi9ub3Rlcy5jOjc4NyBidWlsdGluL3B1bGwuYzoxODcKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDkzIGJ1aWx0aW4vcmViYXNlLmM6MTUwMSBidWlsdGluL3JldmVydC5jOjExNAogbXNnaWQgInN0cmF0ZWd5IgogbXNnc3RyICJjaGnhur9uIGzGsOG7o2MiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoyNjcgYnVpbHRpbi9wdWxsLmM6MTg3CisjOiBidWlsdGluL21lcmdlLmM6MjY3IGJ1aWx0aW4vcHVsbC5jOjE4OAogbXNnaWQgIm1lcmdlIHN0cmF0ZWd5IHRvIHVzZSIKIG1zZ3N0ciAiY2hp4bq/biBsxrDhu6NjIGjDsmEgdHLhu5luIHPhur0gZMO5bmciCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoyNjggYnVpbHRpbi9wdWxsLmM6MTkwCisjOiBidWlsdGluL21lcmdlLmM6MjY4IGJ1aWx0aW4vcHVsbC5jOjE5MQogbXNnaWQgIm9wdGlvbj12YWx1ZSIKIG1zZ3N0ciAidMO5eV9jaOG7jW49Z2nDoV90cuG7iyIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjI2OSBidWlsdGluL3B1bGwuYzoxOTEKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoyNjkgYnVpbHRpbi9wdWxsLmM6MTkyCiBtc2dpZCAib3B0aW9uIGZvciBzZWxlY3RlZCBtZXJnZSBzdHJhdGVneSIKIG1zZ3N0ciAidMO5eSBjaOG7jW4gY2hvIGNoaeG6v24gbMaw4bujYyBow7JhIHRy4buZbiDEkcOjIGNo4buNbiIKIApAQCAtMTUwNDksMTMgKzE1MTI5LDEzIEBACiBtc2dpZCAiY29udGludWUgdGhlIGN1cnJlbnQgaW4tcHJvZ3Jlc3MgbWVyZ2UiCiBtc2dzdHIgInRp4bq/cCB04bulYyBxdcOhIHRyw6xuaCBow7JhIHRy4buZbiBoaeG7h24gdOG6oWkgxJFhbmcgdGjhu7FjIGhp4buHbiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjI4NCBidWlsdGluL3B1bGwuYzoxOTgKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoyODQgYnVpbHRpbi9wdWxsLmM6MTk5CiBtc2dpZCAiYWxsb3cgbWVyZ2luZyB1bnJlbGF0ZWQgaGlzdG9yaWVzIgogbXNnc3RyICJjaG8gcGjDqXAgaMOyYSB0cuG7mW4gbOG7i2NoIHPhu60ga2jDtG5nIGxpw6puIHF1YW4iCiAKICM6IGJ1aWx0aW4vbWVyZ2UuYzoyOTAKLW1zZ2lkICJ2ZXJpZnkgY29tbWl0LW1zZyBob29rIgotbXNnc3RyICJ0aOG6qW0gdHJhIG3Ds2MgKGhvb2spIGNvbW1pdC1tc2ciCittc2dpZCAiYnlwYXNzIHByZS1tZXJnZS1jb21taXQgYW5kIGNvbW1pdC1tc2cgaG9va3MiCittc2dzdHIgInbDsm5nIHF1YSBtw7NjIChob29rKSBwcmUtbWVyZ2UtY29tbWl0IHbDoCBjb21taXQtbXNnIgogCiAjOiBidWlsdGluL21lcmdlLmM6MzA3CiBtc2dpZCAiY291bGQgbm90IHJ1biBzdGFzaC4iCkBAIC0xNTA5OCwzMyArMTUxNzgsMzMgQEAKIG1zZ2lkICJCYWQgYnJhbmNoLiVzLm1lcmdlb3B0aW9ucyBzdHJpbmc6ICVzIgogbXNnc3RyICJDaHXhu5dpIGJyYW5jaC4lcy5tZXJnZW9wdGlvbnMgc2FpOiAlcyIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjcwOAorIzogYnVpbHRpbi9tZXJnZS5jOjcwNQogbXNnaWQgIk5vdCBoYW5kbGluZyBhbnl0aGluZyBvdGhlciB0aGFuIHR3byBoZWFkcyBtZXJnZS4iCiBtc2dzdHIgIktow7RuZyBj4bqnbSBu4bqvbSBnw6wgbmdvw6BpIGhhaSBoZWFkIGjDsmEgdHLhu5luLiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjcyMgorIzogYnVpbHRpbi9tZXJnZS5jOjcxOQogIywgYy1mb3JtYXQKIG1zZ2lkICJVbmtub3duIG9wdGlvbiBmb3IgbWVyZ2UtcmVjdXJzaXZlOiAtWCVzIgogbXNnc3RyICJLaMO0bmcgaGnhu4N1IHTDuXkgY2jhu41uIGNobyBtZXJnZS1yZWN1cnNpdmU6IC1YJXMiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzo3MzcKKyM6IGJ1aWx0aW4vbWVyZ2UuYzo3MzQKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHdyaXRlICVzIgogbXNnc3RyICJraMO0bmcgdGjhu4MgZ2hpICVzIgogCi0jOiBidWlsdGluL21lcmdlLmM6Nzg5CisjOiBidWlsdGluL21lcmdlLmM6Nzg2CiAjLCBjLWZvcm1hdAogbXNnaWQgIkNvdWxkIG5vdCByZWFkIGZyb20gJyVzJyIKIG1zZ3N0ciAiS2jDtG5nIHRo4buDIMSR4buNYyB04burIOKAnCVz4oCdIgogCi0jOiBidWlsdGluL21lcmdlLmM6Nzk4CisjOiBidWlsdGluL21lcmdlLmM6Nzk1CiAjLCBjLWZvcm1hdAogbXNnaWQgIk5vdCBjb21taXR0aW5nIG1lcmdlOyB1c2UgJ2dpdCBjb21taXQnIHRvIGNvbXBsZXRlIHRoZSBtZXJnZS5cbiIKIG1zZ3N0ciAiIgogIlbhuqtuIGNoxrBhIGjDsmEgdHLhu5luIGPDoWMgbOG6p24gY2h1eeG7g24gZ2lhbzsgc+G7rSBk4bulbmcgbOG7h25oIOKAnGdpdCBjb21taXTigJ0gxJHhu4MgaG/DoG4gdOG6pXQgIgogInZp4buHYyBow7JhIHRy4buZbi5cbiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjgwNAorIzogYnVpbHRpbi9tZXJnZS5jOjgwMQogbXNnaWQgIiIKICJQbGVhc2UgZW50ZXIgYSBjb21taXQgbWVzc2FnZSB0byBleHBsYWluIHdoeSB0aGlzIG1lcmdlIGlzIG5lY2Vzc2FyeSxcbiIKICJlc3BlY2lhbGx5IGlmIGl0IG1lcmdlcyBhbiB1cGRhdGVkIHVwc3RyZWFtIGludG8gYSB0b3BpYyBicmFuY2guXG4iCkBAIC0xNTEzNiwxMSArMTUyMTYsMTEgQEAKICJ0b3BpYy5cbiIKICJcbiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjgwOQorIzogYnVpbHRpbi9tZXJnZS5jOjgwNgogbXNnaWQgIkFuIGVtcHR5IG1lc3NhZ2UgYWJvcnRzIHRoZSBjb21taXQuXG4iCiBtc2dzdHIgIk7hur91IHBo4bqnbiBjaMO6IHRow61jaCBy4buXbmcgc+G6vSBo4buneSBi4buPIGzhuqduIGNodXnhu4NuIGdpYW8uXG4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzo4MTIKKyM6IGJ1aWx0aW4vbWVyZ2UuYzo4MDkKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkxpbmVzIHN0YXJ0aW5nIHdpdGggJyVjJyB3aWxsIGJlIGlnbm9yZWQsIGFuZCBhbiBlbXB0eSBtZXNzYWdlIGFib3J0c1xuIgpAQCAtMTUxNDksNzUgKzE1MjI5LDc1IEBACiAiTmjhu69uZyBkw7JuZyDEkcaw4bujYyBi4bqvdCDEkeG6p3UgYuG6sW5nIOKAnCVj4oCdIHPhur0gxJHGsOG7o2MgYuG7jyBxdWEsIHbDoCBu4bq/dSBwaOG6p24gY2jDulxuIgogInRow61jaCBy4buXbmcgc+G6vSBo4buneSBi4buPIGzhuqduIGNodXnhu4NuIGdpYW8uXG4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzo4NTMKKyM6IGJ1aWx0aW4vbWVyZ2UuYzo4NjIKIG1zZ2lkICJFbXB0eSBjb21taXQgbWVzc2FnZS4iCiBtc2dzdHIgIkNow7ogdGjDrWNoIGPhu6dhIGzhuqduIGNvbW1pdCAoY2h1eeG7g24gZ2lhbykgYuG7iyB0cuG7kW5nIHLhu5duZy4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzo4NzIKKyM6IGJ1aWx0aW4vbWVyZ2UuYzo4NzcKICMsIGMtZm9ybWF0CiBtc2dpZCAiV29uZGVyZnVsLlxuIgogbXNnc3RyICJUdXnhu4d0IHbhu51pLlxuIgogCi0jOiBidWlsdGluL21lcmdlLmM6OTMzCisjOiBidWlsdGluL21lcmdlLmM6OTM4CiAjLCBjLWZvcm1hdAogbXNnaWQgIkF1dG9tYXRpYyBtZXJnZSBmYWlsZWQ7IGZpeCBjb25mbGljdHMgYW5kIHRoZW4gY29tbWl0IHRoZSByZXN1bHQuXG4iCiBtc2dzdHIgIiIKICJWaeG7h2MgdOG7sSDEkeG7mW5nIGjDsmEgdHLhu5luIGfhurdwIGzhu5dpOyBow6N5IHPhu61hIGPDoWMgeHVuZyDEkeG7mXQgc2F1IMSRw7MgY2h1eeG7g24gZ2lhbyBr4bq/dCAiCiAicXXhuqMuXG4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzo5NzIKKyM6IGJ1aWx0aW4vbWVyZ2UuYzo5NzcKIG1zZ2lkICJObyBjdXJyZW50IGJyYW5jaC4iCiBtc2dzdHIgIktow7RuZyBwaOG6o2kgbmjDoW5oIGhp4buHbiBow6BuaC4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzo5NzQKKyM6IGJ1aWx0aW4vbWVyZ2UuYzo5NzkKIG1zZ2lkICJObyByZW1vdGUgZm9yIHRoZSBjdXJyZW50IGJyYW5jaC4iCiBtc2dzdHIgIktow7RuZyBjw7MgbcOheSBjaOG7pyBjaG8gbmjDoW5oIGhp4buHbiBow6BuaC4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzo5NzYKKyM6IGJ1aWx0aW4vbWVyZ2UuYzo5ODEKIG1zZ2lkICJObyBkZWZhdWx0IHVwc3RyZWFtIGRlZmluZWQgZm9yIHRoZSBjdXJyZW50IGJyYW5jaC4iCiBtc2dzdHIgIktow7RuZyBjw7MgdGjGsOG7o25nIG5ndeG7k24gbeG6t2MgxJHhu4tuaCDEkcaw4bujYyDEkeG7i25oIG5naMSpYSBjaG8gbmjDoW5oIGhp4buHbiBow6BuaC4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzo5ODEKKyM6IGJ1aWx0aW4vbWVyZ2UuYzo5ODYKICMsIGMtZm9ybWF0CiBtc2dpZCAiTm8gcmVtb3RlLXRyYWNraW5nIGJyYW5jaCBmb3IgJXMgZnJvbSAlcyIKIG1zZ3N0ciAiS2jDtG5nIG5ow6FuaCBt4bqhbmcgdGhlbyBkw7VpIGNobyAlcyB04burICVzIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTAzOAorIzogYnVpbHRpbi9tZXJnZS5jOjEwNDMKICMsIGMtZm9ybWF0CiBtc2dpZCAiQmFkIHZhbHVlICclcycgaW4gZW52aXJvbm1lbnQgJyVzJyIKIG1zZ3N0ciAiR2nDoSB0cuG7iyBzYWkg4oCcJXPigJ0gdHJvbmcgYmnhur9uIG3DtGkgdHLGsOG7nW5nIOKAnCVz4oCdIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTE0MQorIzogYnVpbHRpbi9tZXJnZS5jOjExNDYKICMsIGMtZm9ybWF0CiBtc2dpZCAibm90IHNvbWV0aGluZyB3ZSBjYW4gbWVyZ2UgaW4gJXM6ICVzIgogbXNnc3RyICJraMO0bmcgcGjhuqNpIGzDoCBt4buZdCB0aOG7qSBnw6wgxJHDsyBtw6AgY2jDum5nIHTDtGkgY8OzIHRo4buDIGjDsmEgdHLhu5luIHRyb25nICVzOiAlcyIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjExNzUKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxMTgwCiBtc2dpZCAibm90IHNvbWV0aGluZyB3ZSBjYW4gbWVyZ2UiCiBtc2dzdHIgImtow7RuZyBwaOG6o2kgbMOgIHRo4bupIGfDrCDEkcOzIG3DoCBjaMO6bmcgdMO0aSBjw7MgdGjhu4MgaMOyYSB0cuG7mW4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxMjc4CisjOiBidWlsdGluL21lcmdlLmM6MTI4MwogbXNnaWQgIi0tYWJvcnQgZXhwZWN0cyBubyBhcmd1bWVudHMiCiBtc2dzdHIgIi0tYWJvcnQga2jDtG5nIG5o4bqtbiBjw6FjIMSR4buRaSBz4buRIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTI4MgorIzogYnVpbHRpbi9tZXJnZS5jOjEyODcKIG1zZ2lkICJUaGVyZSBpcyBubyBtZXJnZSB0byBhYm9ydCAoTUVSR0VfSEVBRCBtaXNzaW5nKS4iCiBtc2dzdHIgIiIKICLhu54gxJHDonkga2jDtG5nIGPDsyBs4bqnbiBow7JhIHRy4buZbiBuw6BvIMSRxrDhu6NjIGjhu6d5IGLhu48gZ2nhu69hIGNo4burbmcgY+G6oyAodGhp4bq/dSBNRVJHRV9IRUFEKS4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxMjkxCisjOiBidWlsdGluL21lcmdlLmM6MTI5NgogbXNnaWQgIi0tcXVpdCBleHBlY3RzIG5vIGFyZ3VtZW50cyIKIG1zZ3N0ciAiLS1xdWl0IGtow7RuZyBuaOG6rW4gY8OhYyDEkeG7kWkgc+G7kSIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjEzMDQKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzA5CiBtc2dpZCAiLS1jb250aW51ZSBleHBlY3RzIG5vIGFyZ3VtZW50cyIKIG1zZ3N0ciAiLS1jb250aW51ZSBraMO0bmcgbmjhuq1uIMSR4buRaSBz4buRIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTMwOAorIzogYnVpbHRpbi9tZXJnZS5jOjEzMTMKIG1zZ2lkICJUaGVyZSBpcyBubyBtZXJnZSBpbiBwcm9ncmVzcyAoTUVSR0VfSEVBRCBtaXNzaW5nKS4iCiBtc2dzdHIgIuG7niDEkcOieSBraMO0bmcgY8OzIGzhuqduIGjDsmEgdHLhu5luIG7DoG8gxJFhbmcgxJHGsOG7o2MgeOG7rSBsw70gY+G6oyAodGhp4bq/dSBNRVJHRV9IRUFEKS4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzI0CisjOiBidWlsdGluL21lcmdlLmM6MTMyOQogbXNnaWQgIiIKICJZb3UgaGF2ZSBub3QgY29uY2x1ZGVkIHlvdXIgbWVyZ2UgKE1FUkdFX0hFQUQgZXhpc3RzKS5cbiIKICJQbGVhc2UsIGNvbW1pdCB5b3VyIGNoYW5nZXMgYmVmb3JlIHlvdSBtZXJnZS4iCkBAIC0xNTIyNSw3ICsxNTMwNSw3IEBACiAiQuG6oW4gY2jGsGEga+G6v3QgdGjDumMgdmnhu4djIGjDsmEgdHLhu5luIChNRVJHRV9IRUFEIHbhuqtuIHThu5NuIHThuqFpKS5cbiIKICJIw6N5IGNodXnhu4NuIGdpYW8gY8OhYyB0aGF5IMSR4buVaSB0csaw4bubYyBraGkgYuG6oW4gY8OzIHRo4buDIGjDsmEgdHLhu5luLiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjEzMzEKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzM2CiBtc2dpZCAiIgogIllvdSBoYXZlIG5vdCBjb25jbHVkZWQgeW91ciBjaGVycnktcGljayAoQ0hFUlJZX1BJQ0tfSEVBRCBleGlzdHMpLlxuIgogIlBsZWFzZSwgY29tbWl0IHlvdXIgY2hhbmdlcyBiZWZvcmUgeW91IG1lcmdlLiIKQEAgLTE1MjMzLDk4ICsxNTMxMyw5OCBAQAogIkLhuqFuIGNoxrBhIGvhur90IHRow7pjIHZp4buHYyBjaGVycnktcGljayAoQ0hFUlJZX1BJQ0tfSEVBRCB24bqrbiB04buTbiB04bqhaSkuXG4iCiAiSMOjeSBjaHV54buDbiBnaWFvIGPDoWMgdGhheSDEkeG7lWkgdHLGsOG7m2Mga2hpIGLhuqFuIGPDsyB0aOG7gyBow7JhIHRy4buZbi4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzM0CisjOiBidWlsdGluL21lcmdlLmM6MTMzOQogbXNnaWQgIllvdSBoYXZlIG5vdCBjb25jbHVkZWQgeW91ciBjaGVycnktcGljayAoQ0hFUlJZX1BJQ0tfSEVBRCBleGlzdHMpLiIKIG1zZ3N0ciAiQuG6oW4gY2jGsGEga+G6v3QgdGjDumMgdmnhu4djIGNoZXJyeS1waWNrIChDSEVSUllfUElDS19IRUFEIHbhuqtuIHThu5NuIHThuqFpKS4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzQ4CisjOiBidWlsdGluL21lcmdlLmM6MTM1MwogbXNnaWQgIllvdSBjYW5ub3QgY29tYmluZSAtLXNxdWFzaCB3aXRoIC0tbm8tZmYuIgogbXNnc3RyICJC4bqhbiBraMO0bmcgdGjhu4Mga+G6v3QgaOG7o3AgLS1zcXVhc2ggduG7m2kgLS1uby1mZi4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzUwCisjOiBidWlsdGluL21lcmdlLmM6MTM1NQogbXNnaWQgIllvdSBjYW5ub3QgY29tYmluZSAtLXNxdWFzaCB3aXRoIC0tY29tbWl0LiIKIG1zZ3N0ciAiQuG6oW4ga2jDtG5nIHRo4buDIGvhur90IGjhu6NwIC0tc3F1YXNoIHbhu5tpIC0tY29tbWl0LiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjEzNjYKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzcxCiBtc2dpZCAiTm8gY29tbWl0IHNwZWNpZmllZCBhbmQgbWVyZ2UuZGVmYXVsdFRvVXBzdHJlYW0gbm90IHNldC4iCiBtc2dzdHIgIktow7RuZyBjaOG7iSByYSBs4bqnbiBjaHV54buDbiBnaWFvIHbDoCBtZXJnZS5kZWZhdWx0VG9VcHN0cmVhbSBjaMawYSDEkcaw4bujYyDEkeG6t3QuIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTM4MworIzogYnVpbHRpbi9tZXJnZS5jOjEzODgKIG1zZ2lkICJTcXVhc2ggY29tbWl0IGludG8gZW1wdHkgaGVhZCBub3Qgc3VwcG9ydGVkIHlldCIKIG1zZ3N0ciAiU3F1YXNoIGNvbW1pdCB2w6BvIG3hu5l0IGhlYWQgdHLhu5FuZyBy4buXbmcgduG6q24gY2jGsGEgxJHGsOG7o2MgaOG7lyB0cuG7oyIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjEzODUKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzkwCiBtc2dpZCAiTm9uLWZhc3QtZm9yd2FyZCBjb21taXQgZG9lcyBub3QgbWFrZSBzZW5zZSBpbnRvIGFuIGVtcHR5IGhlYWQiCiBtc2dzdHIgIiIKICJDaHV54buDbiBnaWFvIGtow7RuZy1jaHV54buDbi10aeG6v3Atbmhhbmgga2jDtG5nIGjhu6NwIGzDvSDhu58gdHJvbmcgbeG7mXQgaGVhZCB0cuG7kW5nIHLhu5duZyIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjEzOTAKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzk1CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIC0gbm90IHNvbWV0aGluZyB3ZSBjYW4gbWVyZ2UiCiBtc2dzdHIgIiVzIC0ga2jDtG5nIHBo4bqjaSBsw6AgdGjhu6kgZ8OsIMSRw7MgbcOgIGNow7puZyB0w7RpIGPDsyB0aOG7gyBow7JhIHRy4buZbiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjEzOTIKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzk3CiBtc2dpZCAiQ2FuIG1lcmdlIG9ubHkgZXhhY3RseSBvbmUgY29tbWl0IGludG8gZW1wdHkgaGVhZCIKIG1zZ3N0ciAiIgogIktow7RuZyB0aOG7gyBow7JhIHRy4buZbiBt4buZdCBjw6FjaCDEkcO6bmcgxJHhuq9uIG3hu5l0IGzhuqduIGNodXnhu4NuIGdpYW8gdsOgbyBt4buZdCBoZWFkIHLhu5duZyIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjE0NzEKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxNDc2CiBtc2dpZCAicmVmdXNpbmcgdG8gbWVyZ2UgdW5yZWxhdGVkIGhpc3RvcmllcyIKIG1zZ3N0ciAidOG7qyBjaOG7kWkgaMOyYSB0cuG7mW4gbOG7i2NoIHPhu60ga2jDtG5nIGxpw6puIHF1YW4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxNDgwCisjOiBidWlsdGluL21lcmdlLmM6MTQ4NQogbXNnaWQgIkFscmVhZHkgdXAgdG8gZGF0ZS4iCiBtc2dzdHIgIsSQw6MgY+G6rXAgbmjhuq10IHLhu5NpLiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjE0OTAKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxNDk1CiAjLCBjLWZvcm1hdAogbXNnaWQgIlVwZGF0aW5nICVzLi4lc1xuIgogbXNnc3RyICLEkGFuZyBj4bqtcCBuaOG6rXQgJXMuLiVzXG4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxNTMyCisjOiBidWlsdGluL21lcmdlLmM6MTUzNwogIywgYy1mb3JtYXQKIG1zZ2lkICJUcnlpbmcgcmVhbGx5IHRyaXZpYWwgaW4taW5kZXggbWVyZ2UuLi5cbiIKIG1zZ3N0ciAixJBhbmcgdGjhu60gaMOyYSB0cuG7mW4ga2nhu4N1IOKAnHRyaXZpYWwgaW4taW5kZXjigJ3igKZcbiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjE1MzkKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxNTQ0CiAjLCBjLWZvcm1hdAogbXNnaWQgIk5vcGUuXG4iCiBtc2dzdHIgIktow7RuZy5cbiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjE1NjQKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxNTY5CiBtc2dpZCAiQWxyZWFkeSB1cCB0byBkYXRlLiBZZWVhaCEiCiBtc2dzdHIgIsSQw6MgY+G6rXAgbmjhuq10IHLhu5NpLiBZZWVhaCEiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxNTcwCisjOiBidWlsdGluL21lcmdlLmM6MTU3NQogbXNnaWQgIk5vdCBwb3NzaWJsZSB0byBmYXN0LWZvcndhcmQsIGFib3J0aW5nLiIKIG1zZ3N0ciAiVGjhu7FjIGhp4buHbiBs4buHbmggY2h1eeG7g24tdGnhur9wLW5oYW5oIGzDoCBraMO0bmcgdGjhu4MgxJHGsOG7o2MsIMSRYW5nIGLhu48gcXVhLiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjE1OTMgYnVpbHRpbi9tZXJnZS5jOjE2NTgKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxNTk4IGJ1aWx0aW4vbWVyZ2UuYzoxNjYzCiAjLCBjLWZvcm1hdAogbXNnaWQgIlJld2luZGluZyB0aGUgdHJlZSB0byBwcmlzdGluZS4uLlxuIgogbXNnc3RyICLEkGFuZyB0dWEgbOG6oWkgY8OieSB0aMOgbmggdGjhu51pIHhhIHjGsGHigKZcbiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjE1OTcKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxNjAyCiAjLCBjLWZvcm1hdAogbXNnaWQgIlRyeWluZyBtZXJnZSBzdHJhdGVneSAlcy4uLlxuIgogbXNnc3RyICLEkGFuZyB0aOG7rSBjaGnhur9uIGzGsOG7o2MgaMOyYSB0cuG7mW4gJXPigKZcbiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjE2NDkKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxNjU0CiAjLCBjLWZvcm1hdAogbXNnaWQgIk5vIG1lcmdlIHN0cmF0ZWd5IGhhbmRsZWQgdGhlIG1lcmdlLlxuIgogbXNnc3RyICJLaMO0bmcgY8OzIGNoaeG6v24gbMaw4bujYyBow7JhIHRy4buZbiBuw6BvIMSRxrDhu6NjIG7huq9tIGdp4buvIChoYW5kbGUpIHPhu7EgaMOyYSB0cuG7mW4uXG4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxNjUxCisjOiBidWlsdGluL21lcmdlLmM6MTY1NgogIywgYy1mb3JtYXQKIG1zZ2lkICJNZXJnZSB3aXRoIHN0cmF0ZWd5ICVzIGZhaWxlZC5cbiIKIG1zZ3N0ciAiSMOyYSB0cuG7mW4gduG7m2kgY2hp4bq/biBsxrDhu6NjICVzIGfhurdwIGzhu5dpLlxuIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTY2MAorIzogYnVpbHRpbi9tZXJnZS5jOjE2NjUKICMsIGMtZm9ybWF0CiBtc2dpZCAiVXNpbmcgdGhlICVzIHRvIHByZXBhcmUgcmVzb2x2aW5nIGJ5IGhhbmQuXG4iCiBtc2dzdHIgIlPhu60gZOG7pW5nICVzIMSR4buDIGNodeG6qW4gYuG7iyBnaeG6o2kgcXV54bq/dCBi4bqxbmcgdGF5LlxuIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTY3MgorIzogYnVpbHRpbi9tZXJnZS5jOjE2NzcKICMsIGMtZm9ybWF0CiBtc2dpZCAiQXV0b21hdGljIG1lcmdlIHdlbnQgd2VsbDsgc3RvcHBlZCBiZWZvcmUgY29tbWl0dGluZyBhcyByZXF1ZXN0ZWRcbiIKIG1zZ3N0ciAiIgpAQCAtMTU0MTEsMzIgKzE1NDkxLDMyIEBACiBtc2dpZCAic2V0IGxhYmVscyBmb3IgZmlsZTEvb3JpZy1maWxlL2ZpbGUyIgogbXNnc3RyICLEkeG6t3QgbmjDo24gY2hvIHThuq1wLXRpbi0xL3Thuq1wLXRpbi1n4buRYy904bqtcC10aW4tMiIKIAotIzogYnVpbHRpbi9tZXJnZS1yZWN1cnNpdmUuYzo0NgorIzogYnVpbHRpbi9tZXJnZS1yZWN1cnNpdmUuYzo0NwogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmtub3duIG9wdGlvbiAlcyIKIG1zZ3N0ciAia2jDtG5nIGhp4buDdSB0w7l5IGNo4buNbiAlcyIKIAotIzogYnVpbHRpbi9tZXJnZS1yZWN1cnNpdmUuYzo1MgorIzogYnVpbHRpbi9tZXJnZS1yZWN1cnNpdmUuYzo1MwogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcGFyc2Ugb2JqZWN0ICclcyciCiBtc2dzdHIgImtow7RuZyB0aOG7gyBwaMOibiB0w61jaCDEkeG7kWkgdMaw4bujbmcg4oCcJXPigJ0iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UtcmVjdXJzaXZlLmM6NTYKKyM6IGJ1aWx0aW4vbWVyZ2UtcmVjdXJzaXZlLmM6NTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IGhhbmRsZSBtb3JlIHRoYW4gJWQgYmFzZS4gSWdub3JpbmcgJXMuIgogbXNnaWRfcGx1cmFsICJjYW5ub3QgaGFuZGxlIG1vcmUgdGhhbiAlZCBiYXNlcy4gSWdub3JpbmcgJXMuIgogbXNnc3RyWzBdICJraMO0bmcgdGjhu4MgeOG7rSBsw70gbmhp4buBdSBoxqFuICVkIG7hu4FuLiBC4buPIHF1YSAlcy4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UtcmVjdXJzaXZlLmM6NjQKKyM6IGJ1aWx0aW4vbWVyZ2UtcmVjdXJzaXZlLmM6NjUKIG1zZ2lkICJub3QgaGFuZGxpbmcgYW55dGhpbmcgb3RoZXIgdGhhbiB0d28gaGVhZHMgbWVyZ2UuIgogbXNnc3RyICJraMO0bmcgeOG7rSBsw70gZ8OsIG5nb8OgaSBoYWkgaGVhZCBow7JhIHRy4buZbi4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UtcmVjdXJzaXZlLmM6NzAgYnVpbHRpbi9tZXJnZS1yZWN1cnNpdmUuYzo3MgorIzogYnVpbHRpbi9tZXJnZS1yZWN1cnNpdmUuYzo3NCBidWlsdGluL21lcmdlLXJlY3Vyc2l2ZS5jOjc2CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCByZXNvbHZlIHJlZiAnJXMnIgogbXNnc3RyICJraMO0bmcgdGjhu4MgcGjDom4gZ2nhuqNpIHRoYW0gY2hp4bq/dSAlcyIKIAotIzogYnVpbHRpbi9tZXJnZS1yZWN1cnNpdmUuYzo3OAorIzogYnVpbHRpbi9tZXJnZS1yZWN1cnNpdmUuYzo4MgogIywgYy1mb3JtYXQKIG1zZ2lkICJNZXJnaW5nICVzIHdpdGggJXNcbiIKIG1zZ3N0ciAixJBhbmcgaMOyYSB0cuG7mW4gJXMgduG7m2kgJXNcbiIKQEAgLTE1NTc4LDUzICsxNTY1OCw1MyBAQAogbXNnaWQgIlJlbmFtaW5nICVzIHRvICVzXG4iCiBtc2dzdHIgIsSQ4buVaSB0w6puICVzIHRow6BuaCAlc1xuIgogCi0jOiBidWlsdGluL212LmM6Mjc3IGJ1aWx0aW4vcmVtb3RlLmM6NzE3IGJ1aWx0aW4vcmVwYWNrLmM6NTEwCisjOiBidWlsdGluL212LmM6Mjc3IGJ1aWx0aW4vcmVtb3RlLmM6NzE3IGJ1aWx0aW4vcmVwYWNrLmM6NTExCiAjLCBjLWZvcm1hdAogbXNnaWQgInJlbmFtaW5nICclcycgZmFpbGVkIgogbXNnc3RyICJn4bq3cCBs4buXaSBraGkgxJHhu5VpIHTDqm4g4oCcJXPigJ0iCiAKLSM6IGJ1aWx0aW4vbmFtZS1yZXYuYzozNTIKKyM6IGJ1aWx0aW4vbmFtZS1yZXYuYzozNTYKIG1zZ2lkICJnaXQgbmFtZS1yZXYgWzxvcHRpb25zPl0gPGNvbW1pdD4uLi4iCiBtc2dzdHIgImdpdCBuYW1lLXJldiBbPGPDoWMgdMO5eSBjaOG7jW4+XSA8Y29tbWl0PuKApiIKIAotIzogYnVpbHRpbi9uYW1lLXJldi5jOjM1MworIzogYnVpbHRpbi9uYW1lLXJldi5jOjM1NwogbXNnaWQgImdpdCBuYW1lLXJldiBbPG9wdGlvbnM+XSAtLWFsbCIKIG1zZ3N0ciAiZ2l0IG5hbWUtcmV2IFs8Y8OhYyB0w7l5IGNo4buNbj5dIC0tYWxsIgogCi0jOiBidWlsdGluL25hbWUtcmV2LmM6MzU0CisjOiBidWlsdGluL25hbWUtcmV2LmM6MzU4CiBtc2dpZCAiZ2l0IG5hbWUtcmV2IFs8b3B0aW9ucz5dIC0tc3RkaW4iCiBtc2dzdHIgImdpdCBuYW1lLXJldiBbPGPDoWMgdMO5eSBjaOG7jW4+XSAtLXN0ZGluIgogCi0jOiBidWlsdGluL25hbWUtcmV2LmM6NDExCisjOiBidWlsdGluL25hbWUtcmV2LmM6NDE1CiBtc2dpZCAicHJpbnQgb25seSBuYW1lcyAobm8gU0hBLTEpIgogbXNnc3RyICJjaOG7iSBoaeG7g24gdGjhu4sgdMOqbiAoa2jDtG5nIFNIQS0xKSIKIAotIzogYnVpbHRpbi9uYW1lLXJldi5jOjQxMgorIzogYnVpbHRpbi9uYW1lLXJldi5jOjQxNgogbXNnaWQgIm9ubHkgdXNlIHRhZ3MgdG8gbmFtZSB0aGUgY29tbWl0cyIKIG1zZ3N0ciAiY2jhu4kgZMO5bmcgY8OhYyB0aOG6uyDEkeG7gyDEkeG6t3QgdMOqbiBjaG8gY8OhYyBs4bqnbiBjaHV54buDbiBnaWFvIgogCi0jOiBidWlsdGluL25hbWUtcmV2LmM6NDE0CisjOiBidWlsdGluL25hbWUtcmV2LmM6NDE4CiBtc2dpZCAib25seSB1c2UgcmVmcyBtYXRjaGluZyA8cGF0dGVybj4iCiBtc2dzdHIgImNo4buJIHPhu60gZOG7pW5nIGPDoWMgdGhhbSBjaGnhur91IGto4bubcCB24bubaSA8beG6q3U+IgogCi0jOiBidWlsdGluL25hbWUtcmV2LmM6NDE2CisjOiBidWlsdGluL25hbWUtcmV2LmM6NDIwCiBtc2dpZCAiaWdub3JlIHJlZnMgbWF0Y2hpbmcgPHBhdHRlcm4+IgogbXNnc3RyICJi4buPIHF1YSBjw6FjIHRoYW0gY2hp4bq/dSBraOG7m3AgduG7m2kgPG3huqt1PiIKIAotIzogYnVpbHRpbi9uYW1lLXJldi5jOjQxOAorIzogYnVpbHRpbi9uYW1lLXJldi5jOjQyMgogbXNnaWQgImxpc3QgYWxsIGNvbW1pdHMgcmVhY2hhYmxlIGZyb20gYWxsIHJlZnMiCiBtc2dzdHIgIiIKICJsaeG7h3Qga8OqIHThuqV0IGPhuqMgY8OhYyBs4bqnbiBjaHV54buDbiBnaWFvIGPDsyB0aOG7gyDEkeG7jWMgxJHGsOG7o2MgdOG7qyB04bqldCBj4bqjIGPDoWMgdGhhbSBjaGnhur91IgogCi0jOiBidWlsdGluL25hbWUtcmV2LmM6NDE5CisjOiBidWlsdGluL25hbWUtcmV2LmM6NDIzCiBtc2dpZCAicmVhZCBmcm9tIHN0ZGluIgogbXNnc3RyICLEkeG7jWMgdOG7qyDEkeG6p3UgdsOgbyB0acOqdSBjaHXhuqluIgogCi0jOiBidWlsdGluL25hbWUtcmV2LmM6NDIwCisjOiBidWlsdGluL25hbWUtcmV2LmM6NDI0CiBtc2dpZCAiYWxsb3cgdG8gcHJpbnQgYHVuZGVmaW5lZGAgbmFtZXMgKGRlZmF1bHQpIgogbXNnc3RyICJjaG8gcGjDqXAgaW4gY8OhYyB0w6puIOKAnGNoxrBhIMSR4buLbmggbmdoxKlh4oCdICht4bq3YyDEkeG7i25oKSIKIAotIzogYnVpbHRpbi9uYW1lLXJldi5jOjQyNgorIzogYnVpbHRpbi9uYW1lLXJldi5jOjQzMAogbXNnaWQgImRlcmVmZXJlbmNlIHRhZ3MgaW4gdGhlIGlucHV0IChpbnRlcm5hbCB1c2UpIgogbXNnc3RyICJiw6NpIGLhu48gdGhhbSBjaGnhur91IGPDoWMgdGjhursgdHJvbmcgxJHhuqd1IHbDoG8gKGTDuW5nIG7hu5lpIGLhu5kpIgogCkBAIC0xNjAyMiw3ICsxNjEwMiw3IEBACiBtc2dpZCAicmVhZCBvYmplY3QgbmFtZXMgZnJvbSB0aGUgc3RhbmRhcmQgaW5wdXQiCiBtc2dzdHIgIsSR4buNYyB0w6puIMSR4buRaSB0xrDhu6NuZyB04burIHRoaeG6v3QgYuG7iyBuaOG6rXAgY2h14bqpbiIKIAotIzogYnVpbHRpbi9ub3Rlcy5jOjk1NCBidWlsdGluL3BydW5lLmM6MTMwIGJ1aWx0aW4vd29ya3RyZWUuYzoxNjUKKyM6IGJ1aWx0aW4vbm90ZXMuYzo5NTQgYnVpbHRpbi9wcnVuZS5jOjEzMCBidWlsdGluL3dvcmt0cmVlLmM6MTY0CiBtc2dpZCAiZG8gbm90IHJlbW92ZSwgc2hvdyBvbmx5IgogbXNnc3RyICJraMO0bmcgZ+G7oSBi4buPLCBjaOG7iSBoaeG7g24gdGjhu4siCiAKQEAgLTE2MDM4LDcgKzE2MTE4LDcgQEAKIG1zZ2lkICJ1c2Ugbm90ZXMgZnJvbSA8bm90ZXMtcmVmPiIKIG1zZ3N0ciAiZMO5bmcg4oCcbm90ZXPigJ0gdOG7qyA8bm90ZXMtcmVmPiIKIAotIzogYnVpbHRpbi9ub3Rlcy5jOjEwMzQgYnVpbHRpbi9zdGFzaC5jOjE1OTgKKyM6IGJ1aWx0aW4vbm90ZXMuYzoxMDM0IGJ1aWx0aW4vc3Rhc2guYzoxNjA3CiAjLCBjLWZvcm1hdAogbXNnaWQgInVua25vd24gc3ViY29tbWFuZDogJXMiCiBtc2dzdHIgImtow7RuZyBoaeG7g3UgY8OidSBs4buHbmggY29uOiAlcyIKQEAgLTE2MTEzLDcwICsxNjE5Myw3MCBAQAogbXNnaWQgIndyb3RlICU8UFJJdTMyPiBvYmplY3RzIHdoaWxlIGV4cGVjdGluZyAlPFBSSXUzMj4iCiBtc2dzdHIgIsSRw6MgZ2hpICU8UFJJdTMyPiDEkeG7kWkgdMaw4bujbmcgdHJvbmcga2hpIGPhuqduICU8UFJJdTMyPiIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoxMTY2CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjExNjQKIG1zZ2lkICJkaXNhYmxpbmcgYml0bWFwIHdyaXRpbmcsIGFzIHNvbWUgb2JqZWN0cyBhcmUgbm90IGJlaW5nIHBhY2tlZCIKIG1zZ3N0ciAidOG6r3QgZ2hpIGJpdG1hcCwgbmjGsCB24bqteSBt4buZdCBz4buRIMSR4buRaSB0xrDhu6NuZyBz4bq9IGtow7RuZyDEkcaw4bujYyDEkcOzbmcgZ8OzaSIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoxNTk3CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjE1OTIKICMsIGMtZm9ybWF0CiBtc2dpZCAiZGVsdGEgYmFzZSBvZmZzZXQgb3ZlcmZsb3cgaW4gcGFjayBmb3IgJXMiCiBtc2dzdHIgImtob+G6o25nIGLDuSBjxqEgc+G7nyBjaG8gZGVsdGEgYuG7iyB0csOgbiB0cm9uZyBnw7NpIGNobyAlcyIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoxNjA2CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjE2MDEKICMsIGMtZm9ybWF0CiBtc2dpZCAiZGVsdGEgYmFzZSBvZmZzZXQgb3V0IG9mIGJvdW5kIGZvciAlcyIKIG1zZ3N0ciAia2hv4bqjbmcgYsO5IGPGoSBz4bufIGNobyBkZWx0YSBu4bqxbSBuZ2/DoGkgcGjhuqFtIGNobyAlcyIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoxODc1CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjE4NzAKIG1zZ2lkICJDb3VudGluZyBvYmplY3RzIgogbXNnc3RyICLEkGFuZyDEkeG6v20gY8OhYyDEkeG7kWkgdMaw4bujbmciCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjAwNQorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyMDAwCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBnZXQgc2l6ZSBvZiAlcyIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIGzhuqV5IGvDrWNoIGPhu6EgY+G7p2EgJXMiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjAyMAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyMDE1CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBwYXJzZSBvYmplY3QgaGVhZGVyIG9mICVzIgogbXNnc3RyICJraMO0bmcgdGjhu4MgcGjDom4gdMOtY2ggcGjhuqduIMSR4bqndSDEkeG7kWkgdMaw4bujbmcgY+G7p2Eg4oCcJXPigJ0iCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjA5MCBidWlsdGluL3BhY2stb2JqZWN0cy5jOjIxMDYKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjExNgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyMDg1IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjEwMQorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyMTExCiAjLCBjLWZvcm1hdAogbXNnaWQgIm9iamVjdCAlcyBjYW5ub3QgYmUgcmVhZCIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIMSR4buNYyDEkeG7kWkgdMaw4bujbmcgJXMiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjA5MyBidWlsdGluL3BhY2stb2JqZWN0cy5jOjIxMjAKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjA4OCBidWlsdGluL3BhY2stb2JqZWN0cy5jOjIxMTUKICMsIGMtZm9ybWF0CiBtc2dpZCAib2JqZWN0ICVzIGluY29uc2lzdGVudCBvYmplY3QgbGVuZ3RoICglPFBSSXVNQVg+IHZzICU8UFJJdU1BWD4pIgogbXNnc3RyICIiCiAixJHhu5FpIHTGsOG7o25nICVzIGtow7RuZyBuaOG6pXQgcXXDoW4gduG7gSBjaGnhu4F1IGTDoGkgxJHhu5FpIHTGsOG7o25nICglPFBSSXVNQVg+IHNvIHbhu5tpICIKICIlPFBSSXVNQVg+KSIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyMTMwCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjIxMjUKIG1zZ2lkICJzdWJvcHRpbWFsIHBhY2sgLSBvdXQgb2YgbWVtb3J5IgogbXNnc3RyICJzdWJvcHRpbWFsIHBhY2sgLSBo4bq/dCBi4buZIG5o4bubIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI0NTYKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjQ0MAogIywgYy1mb3JtYXQKIG1zZ2lkICJEZWx0YSBjb21wcmVzc2lvbiB1c2luZyB1cCB0byAlZCB0aHJlYWRzIgogbXNnc3RyICJOw6luIGRlbHRhIGTDuW5nIHThu5tpICVkIHR1eeG6v24gdHLDrG5oIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI1ODgKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjU3MgogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gcGFjayBvYmplY3RzIHJlYWNoYWJsZSBmcm9tIHRhZyAlcyIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIMSRw7NuZyBnw7NpIGPDoWMgxJHhu5FpIHTGsOG7o25nIHRp4bq/cCBj4bqtbiDEkcaw4bujYyB04burIHRo4bq7IOKAnCVz4oCdIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI2NzUKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjY1OQogbXNnaWQgIkNvbXByZXNzaW5nIG9iamVjdHMiCiBtc2dzdHIgIsSQYW5nIG7DqW4gY8OhYyDEkeG7kWkgdMaw4bujbmciCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjY4MQorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNjY1CiBtc2dpZCAiaW5jb25zaXN0ZW5jeSB3aXRoIGRlbHRhIGNvdW50IgogbXNnc3RyICJtw6J1IHRodeG6q24gduG7m2kgc+G7kSBsxrDhu6NuZyBkZWx0YSIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNzYyCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI3NDIKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogImV4cGVjdGVkIGVkZ2Ugb2JqZWN0IElELCBnb3QgZ2FyYmFnZTpcbiIKQEAgLTE2MTg1LDcgKzE2MjY1LDcgQEAKICJj4bqnbiBJRCDEkeG7kWkgdMaw4bujbmcgY+G6oW5oLCBuaOG6rW4gxJHGsOG7o2MgcsOhYzpcbiIKICIgJXMiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6Mjc2OAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNzQ4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJleHBlY3RlZCBvYmplY3QgSUQsIGdvdCBnYXJiYWdlOlxuIgpAQCAtMTYxOTQsMjQ0ICsxNjI3NCwyNDQgQEAKICJj4bqnbiBJRCDEkeG7kWkgdMaw4bujbmcsIG5o4bqtbiDEkcaw4bujYyByw6FjOlxuIgogIiAlcyIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyODY2CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI4NDYKIG1zZ2lkICJpbnZhbGlkIHZhbHVlIGZvciAtLW1pc3NpbmciCiBtc2dzdHIgImdpw6EgdHLhu4sgY2hvIC0tbWlzc2luZyBraMO0bmcgaOG7o3AgbOG7hyIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyOTI1IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzAzMworIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyOTA1IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzAxMwogbXNnaWQgImNhbm5vdCBvcGVuIHBhY2sgaW5kZXgiCiBtc2dzdHIgImtow7RuZyB0aOG7gyBt4bufIG3hu6VjIGzhu6VjIGPhu6dhIGfDs2kiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6Mjk1NgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyOTM2CiAjLCBjLWZvcm1hdAogbXNnaWQgImxvb3NlIG9iamVjdCBhdCAlcyBjb3VsZCBub3QgYmUgZXhhbWluZWQiCiBtc2dzdHIgIsSR4buRaSB0xrDhu6NuZyBt4bqldCB04bqhaSAlcyBraMO0bmcgdGjhu4MgxJHDoyBraeG7g20gdHJhIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMwNDEKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzAyMQogbXNnaWQgInVuYWJsZSB0byBmb3JjZSBsb29zZSBvYmplY3QiCiBtc2dzdHIgImtow7RuZyB0aOG7gyBideG7mWMgbeG6pXQgxJHhu5FpIHTGsOG7o25nIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMxMzMKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzExMwogIywgYy1mb3JtYXQKIG1zZ2lkICJub3QgYSByZXYgJyVzJyIKIG1zZ3N0ciAia2jDtG5nIHBo4bqjaSBt4buZdCByZXYg4oCcJXPigJ0iCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzEzNgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMTE2CiAjLCBjLWZvcm1hdAogbXNnaWQgImJhZCByZXZpc2lvbiAnJXMnIgogbXNnc3RyICLEkWnhu4NtIHhlbSB4w6l0IHNhaSDigJwlc+KAnSIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMTYxCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMxNDEKIG1zZ2lkICJ1bmFibGUgdG8gYWRkIHJlY2VudCBvYmplY3RzIgogbXNnc3RyICJraMO0bmcgdGjhu4MgdGjDqm0gY8OhYyDEkeG7kWkgdMaw4bujbmcgbeG7m2kgZMO5bmciCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzIxNAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMTk0CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuc3VwcG9ydGVkIGluZGV4IHZlcnNpb24gJXMiCiBtc2dzdHIgInBoacOqbiBi4bqjbiBt4bulYyBs4bulYyBraMO0bmcgxJHGsOG7o2MgaOG7lyB0cuG7oyAlcyIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjE4CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMxOTgKICMsIGMtZm9ybWF0CiBtc2dpZCAiYmFkIGluZGV4IHZlcnNpb24gJyVzJyIKIG1zZ3N0ciAicGhpw6puIGLhuqNuIG3hu6VjIGzhu6VjIHNhaSDigJwlc+KAnSIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjQ4CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyMjgKIG1zZ2lkICJkbyBub3Qgc2hvdyBwcm9ncmVzcyBtZXRlciIKIG1zZ3N0ciAia2jDtG5nIGhp4buDbiB0aOG7iyBi4buZIMSRbyB0aeG6v24gdHLDrG5oIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNTAKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzIzMAogbXNnaWQgInNob3cgcHJvZ3Jlc3MgbWV0ZXIiCiBtc2dzdHIgImhp4buDbiB0aOG7iyBi4buZIMSRbyB0aeG6v24gdHLDrG5oIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNTIKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzIzMgogbXNnaWQgInNob3cgcHJvZ3Jlc3MgbWV0ZXIgZHVyaW5nIG9iamVjdCB3cml0aW5nIHBoYXNlIgogbXNnc3RyICJoaeG7g24gdGjhu4sgYuG7mSDEkW8gdGnhur9uIHRyaeG7g24gdHJvbmcgc3Xhu5F0IHBoYSBnaGkgxJHhu5FpIHTGsOG7o25nIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNTUKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzIzNQogbXNnaWQgInNpbWlsYXIgdG8gLS1hbGwtcHJvZ3Jlc3Mgd2hlbiBwcm9ncmVzcyBtZXRlciBpcyBzaG93biIKIG1zZ3N0ciAidMawxqFuZyB04buxIC0tYWxsLXByb2dyZXNzIGtoaSBi4buZIMSRbyB0aeG6v24gdHLDrG5oIMSRxrDhu6NjIHh14bqldCBoaeG7h24iCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI1NgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjM2CiBtc2dpZCAiPHZlcnNpb24+Wyw8b2Zmc2V0Pl0iCiBtc2dzdHIgIjxwaGnDqm4gYuG6o24+WyxvZmZzZXRdIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNTcKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzIzNwogbXNnaWQgIndyaXRlIHRoZSBwYWNrIGluZGV4IGZpbGUgaW4gdGhlIHNwZWNpZmllZCBpZHggZm9ybWF0IHZlcnNpb24iCiBtc2dzdHIgImdoaSB04bqtcCB0aW4gYuG6o25nIG3hu6VjIGzhu6VjIGfDs2kgKHBhY2spIOG7nyBwaGnDqm4gYuG6o24gxJHhu4tuaCBk4bqhbmcgaWR4IMSRw6MgY2hvIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNjAKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI0MAogbXNnaWQgIm1heGltdW0gc2l6ZSBvZiBlYWNoIG91dHB1dCBwYWNrIGZpbGUiCiBtc2dzdHIgImtjw61oIHRoxrDhu5tjIHThu5FpIMSRYSBjaG8gdOG6rXAgdGluIGfDs2kgxJHGsOG7o2MgdOG6oW8iCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI2MgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjQyCiBtc2dpZCAiaWdub3JlIGJvcnJvd2VkIG9iamVjdHMgZnJvbSBhbHRlcm5hdGUgb2JqZWN0IHN0b3JlIgogbXNnc3RyICJi4buPIHF1YSBjw6FjIMSR4buRaSB0xrDhu6NuZyB2YXkgbcaw4bujbiB04burIGtobyDEkeG7kWkgdMaw4bujbmcgdGhheSB0aOG6vyIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjY0CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNDQKIG1zZ2lkICJpZ25vcmUgcGFja2VkIG9iamVjdHMiCiBtc2dzdHIgImLhu48gcXVhIGPDoWMgxJHhu5FpIHTGsOG7o25nIMSRw7NuZyBnw7NpIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNjYKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI0NgogbXNnaWQgImxpbWl0IHBhY2sgd2luZG93IGJ5IG9iamVjdHMiCiBtc2dzdHIgImdp4bubaSBo4bqhbiBj4butYSBz4buVIMSRw7NuZyBnw7NpIHRoZW8gxJHhu5FpIHTGsOG7o25nIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNjgKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI0OAogbXNnaWQgImxpbWl0IHBhY2sgd2luZG93IGJ5IG1lbW9yeSBpbiBhZGRpdGlvbiB0byBvYmplY3QgbGltaXQiCiBtc2dzdHIgImdp4bubaSBo4bqhbiBj4butYSBz4buVIMSRw7NuZyBnw7NpIHRoZW8gYuG7mSBuaOG7myBj4buZbmcgdGjDqm0gduG7m2kgZ2nhu5tpIGjhuqFuIMSR4buRaSB0xrDhu6NuZyIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjcwCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNTAKIG1zZ2lkICJtYXhpbXVtIGxlbmd0aCBvZiBkZWx0YSBjaGFpbiBhbGxvd2VkIGluIHRoZSByZXN1bHRpbmcgcGFjayIKIG1zZ3N0ciAixJHhu5kgZMOgaSB04buRaSDEkWEgY+G7p2EgY2h14buXaSBtw7NjIHjDrWNoIOKAnGRlbHRh4oCdIMSRxrDhu6NjIHBow6lwIHRyb25nIGfDs2kga+G6v3QgcXXhuqMiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI3MgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjUyCiBtc2dpZCAicmV1c2UgZXhpc3RpbmcgZGVsdGFzIgogbXNnc3RyICJkw7luZyBs4bqhaSBjw6FjIGRlbHRhIHPhurVuIGPDsyIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjc0CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNTQKIG1zZ2lkICJyZXVzZSBleGlzdGluZyBvYmplY3RzIgogbXNnc3RyICJkw7luZyBs4bqhaSBjw6FjIMSR4buRaSB0xrDhu6NuZyBz4bq1biBjw7MiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI3NgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjU2CiBtc2dpZCAidXNlIE9GU19ERUxUQSBvYmplY3RzIgogbXNnc3RyICJkw7luZyBjw6FjIMSR4buRaSB0xrDhu6NuZyBPRlNfREVMVEEiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI3OAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjU4CiBtc2dpZCAidXNlIHRocmVhZHMgd2hlbiBzZWFyY2hpbmcgZm9yIGJlc3QgZGVsdGEgbWF0Y2hlcyIKIG1zZ3N0ciAic+G7rSBk4bulbmcgY8OhYyB0dXnhur9uIHRyw6xuaCBraGkgdMOsbSBraeG6v20gY2hvIGPDoWMgbeG6q3Uga2jhu5twIGRlbHRhIHThu5F0IG5o4bqldCIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjgwCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNjAKIG1zZ2lkICJkbyBub3QgY3JlYXRlIGFuIGVtcHR5IHBhY2sgb3V0cHV0IgogbXNnc3RyICJraMO0bmcgdGjhu4MgdOG6oW8ga+G6v3QgeHXhuqV0IGfDs2kgdHLhu5FuZyBy4buXbmciCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI4MgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjYyCiBtc2dpZCAicmVhZCByZXZpc2lvbiBhcmd1bWVudHMgZnJvbSBzdGFuZGFyZCBpbnB1dCIKIG1zZ3N0ciAixJHhu41jIHRoYW0gc+G7kSDigJxyZXZpc2lvbuKAnSB04burIHRoaeG6v3QgYuG7iyBuaOG6rXAgY2h14bqpbiIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjg0CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNjQKIG1zZ2lkICJsaW1pdCB0aGUgb2JqZWN0cyB0byB0aG9zZSB0aGF0IGFyZSBub3QgeWV0IHBhY2tlZCIKIG1zZ3N0ciAiZ2nhu5tpIGjhuqFuIGPDoWMgxJHhu5FpIHTGsOG7o25nIHRow6BuaCBuaOG7r25nIGPDoWkgbcOgIGNow7puZyB24bqrbiBjaMawYSDEkcaw4bujYyDEkcOzbmcgZ8OzaSIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjg3CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNjcKIG1zZ2lkICJpbmNsdWRlIG9iamVjdHMgcmVhY2hhYmxlIGZyb20gYW55IHJlZmVyZW5jZSIKIG1zZ3N0ciAiYmFvIGfhu5NtIGPDoWMgxJHhu5FpIHTGsOG7o25nIGPDsyB0aOG7gyDEkeG7jWMgxJHGsOG7o2MgdOG7qyBi4bqldCBr4buzIHRoYW0gY2hp4bq/dSBuw6BvIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyOTAKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI3MAogbXNnaWQgImluY2x1ZGUgb2JqZWN0cyByZWZlcnJlZCBieSByZWZsb2cgZW50cmllcyIKIG1zZ3N0ciAiYmFvIGfhu5NtIGPDoWMgxJHhu5FpIHTGsOG7o25nIMSRxrDhu6NjIHRoYW0gY2hp4bq/dSBi4bufaSBjw6FjIG3hu6VjIHJlZmxvZyIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjkzCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNzMKIG1zZ2lkICJpbmNsdWRlIG9iamVjdHMgcmVmZXJyZWQgdG8gYnkgdGhlIGluZGV4IgogbXNnc3RyICJiYW8gZ+G7k20gY8OhYyDEkeG7kWkgdMaw4bujbmcgxJHGsOG7o2MgdGhhbSBjaGnhur91IGLhu59pIG3hu6VjIGzhu6VjIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyOTYKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI3NgogbXNnaWQgIm91dHB1dCBwYWNrIHRvIHN0ZG91dCIKIG1zZ3N0ciAieHXhuqV0IGfDs2kgcmEgxJHhuqd1IHJhIHRpw6p1IGNodeG6qW4iCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI5OAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjc4CiBtc2dpZCAiaW5jbHVkZSB0YWcgb2JqZWN0cyB0aGF0IHJlZmVyIHRvIG9iamVjdHMgdG8gYmUgcGFja2VkIgogbXNnc3RyICJiYW8gZ+G7k20gY8OhYyDEkeG7kWkgdMaw4bujbmcgdGhhbSBjaGnhur91IMSR4bq/biBjw6FjIMSR4buRaSB0xrDhu6NuZyDEkcaw4bujYyDEkcOzbmcgZ8OzaSIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzAwCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyODAKIG1zZ2lkICJrZWVwIHVucmVhY2hhYmxlIG9iamVjdHMiCiBtc2dzdHIgImdp4buvIGzhuqFpIGPDoWMgxJHhu5FpIHTGsOG7o25nIGtow7RuZyB0aOG7gyDEkeG7jWMgxJHGsOG7o2MiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMwMgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjgyCiBtc2dpZCAicGFjayBsb29zZSB1bnJlYWNoYWJsZSBvYmplY3RzIgogbXNnc3RyICJwYWNrIG3huqV0IGPDoWMgxJHhu5FpIHTGsOG7o25nIGtow7RuZyB0aOG7gyDEkeG7jWMgxJHGsOG7o2MiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMwNAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjg0CiBtc2dpZCAidW5wYWNrIHVucmVhY2hhYmxlIG9iamVjdHMgbmV3ZXIgdGhhbiA8dGltZT4iCiBtc2dzdHIgIiIKICJ44bqjIG7DqW4gKGfhu6Ega2jhu49pIGfDs2kpIGPDoWMgxJHhu5FpIHTGsOG7o25nIGtow7RuZyB0aOG7gyDEkeG7jWMgxJHGsOG7o2MgbeG7m2kgaMahbiA8dGjhu51pLWdpYW4+IgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMDcKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI4NwogbXNnaWQgInVzZSB0aGUgc3BhcnNlIHJlYWNoYWJpbGl0eSBhbGdvcml0aG0iCi1tc2dzdHIgImR1bmcgdGh14bqtdCB0b8OhbiDigJxzcGFyc2UgcmVhY2hhYmlsaXR54oCdIgorbXNnc3RyICJz4butIGThu6VuZyB0aHXhuq10IHRvw6FuIOKAnHNwYXJzZSByZWFjaGFiaWxpdHnigJ0iCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMwOQorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjg5CiBtc2dpZCAiY3JlYXRlIHRoaW4gcGFja3MiCiBtc2dzdHIgInThuqFvIGfDs2kgbmjhurkiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMxMQorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjkxCiBtc2dpZCAiY3JlYXRlIHBhY2tzIHN1aXRhYmxlIGZvciBzaGFsbG93IGZldGNoZXMiCiBtc2dzdHIgInThuqFvIGfDs2kgxJHhu4MgcGjDuSBo4bujcCBjaG8gbOG6pXkgduG7gSBuw7RuZyAoc2hhbGxvdykiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMxMworIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjkzCiBtc2dpZCAiaWdub3JlIHBhY2tzIHRoYXQgaGF2ZSBjb21wYW5pb24gLmtlZXAgZmlsZSIKIG1zZ3N0ciAiYuG7jyBxdWEgY8OhYyBnw7NpIG3DoCBuw7MgY8OzIHThuq1wIHRpbiAua2VlcCDEkWkga8OobSIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzE1CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyOTUKIG1zZ2lkICJpZ25vcmUgdGhpcyBwYWNrIgogbXNnc3RyICJi4buPIHF1YSBnw7NpIG7DoHkiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMxNworIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjk3CiBtc2dpZCAicGFjayBjb21wcmVzc2lvbiBsZXZlbCIKIG1zZ3N0ciAibeG7qWMgbsOpbiBnw7NpIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMTkKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI5OQogbXNnaWQgImRvIG5vdCBoaWRlIGNvbW1pdHMgYnkgZ3JhZnRzIgogbXNnc3RyICJraMO0bmcg4bqpbiBjw6FjIGzhuqduIGNodXnhu4NuIGdpYW8gYuG7n2kg4oCcZ3JhZnRz4oCdIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMjEKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMwMQogbXNnaWQgInVzZSBhIGJpdG1hcCBpbmRleCBpZiBhdmFpbGFibGUgdG8gc3BlZWQgdXAgY291bnRpbmcgb2JqZWN0cyIKIG1zZ3N0ciAiZMO5bmcgbeG7pWMgbOG7pWMgw6FuaCB44bqhIG7hur91IGPDsyB0aOG7gyDEkcaw4bujYyDEkeG7gyBuw6JuZyBjYW8gdOG7kWMgxJHhu5kgxJHhur9tIMSR4buRaSB0xrDhu6NuZyIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzIzCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMDMKIG1zZ2lkICJ3cml0ZSBhIGJpdG1hcCBpbmRleCB0b2dldGhlciB3aXRoIHRoZSBwYWNrIGluZGV4IgogbXNnc3RyICJnaGkgbeG7mXQgbeG7pWMgbOG7pWMgw6FuaCB44bqhIGPDuW5nIHbhu5tpIG3hu6VjIGzhu6VjIGfDs2kiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMyNworIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzA3CiBtc2dpZCAid3JpdGUgYSBiaXRtYXAgaW5kZXggaWYgcG9zc2libGUiCiBtc2dzdHIgImdoaSBt4bulYyBs4bulYyDDoW5oIHjhuqEgbuG6v3UgxJHGsOG7o2MiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMzMQorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzExCiBtc2dpZCAiaGFuZGxpbmcgZm9yIG1pc3Npbmcgb2JqZWN0cyIKIG1zZ3N0ciAieOG7rSBsw70gY2hvIHRoaeG6v3UgxJHhu5FpIHTGsOG7o25nIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMzQKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMxNAogbXNnaWQgImRvIG5vdCBwYWNrIG9iamVjdHMgaW4gcHJvbWlzb3IgcGFja2ZpbGVzIgogbXNnc3RyICJraMO0bmcgdGjhu4MgxJHDs25nIGfDs2kgY8OhYyDEkeG7kWkgdMaw4bujbmcgdHJvbmcgY8OhYyB04bqtcCB0aW4gZ8OzaSBo4bupYSBo4bq5biIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzM2CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMTYKIG1zZ2lkICJyZXNwZWN0IGlzbGFuZHMgZHVyaW5nIGRlbHRhIGNvbXByZXNzaW9uIgogbXNnc3RyICJ0w7RuIHRy4buNbmcgaXNsYW5kIHRyb25nIHN14buRdCBxdcOhIHRyw6xuaCBuw6luIOKAnGRlbHRh4oCdIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzNjEKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzM0NQogIywgYy1mb3JtYXQKIG1zZ2lkICJkZWx0YSBjaGFpbiBkZXB0aCAlZCBpcyB0b28gZGVlcCwgZm9yY2luZyAlZCIKIG1zZ3N0ciAibeG7qWMgc2F1IHjDrWNoIGRlbHRhICVkIGzDoCBxdcOhIHPDonUsIGJ14buZYyBkw7luZyAlZCIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzY2CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzNTAKICMsIGMtZm9ybWF0CiBtc2dpZCAicGFjay5kZWx0YUNhY2hlTGltaXQgaXMgdG9vIGhpZ2gsIGZvcmNpbmcgJWQiCiBtc2dzdHIgInBhY2suZGVsdGFDYWNoZUxpbWl0IGzDoCBxdcOhIGNhbywgw6lwIGTDuW5nICVkIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjM0MjAKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzQwNAogbXNnaWQgIi0tbWF4LXBhY2stc2l6ZSBjYW5ub3QgYmUgdXNlZCB0byBidWlsZCBhIHBhY2sgZm9yIHRyYW5zZmVyIgogbXNnc3RyICIiCiAiLS1tYXgtcGFjay1zaXplIGtow7RuZyB0aOG7gyDEkcaw4bujYyBz4butIGThu6VuZyDEkeG7gyB4w6J5IGThu7FuZyBt4buZdCBnw7NpIMSR4buDIHbhuq1uIGNodXnhu4NuIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjM0MjIKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzQwNgogbXNnaWQgIm1pbmltdW0gcGFjayBzaXplIGxpbWl0IGlzIDEgTWlCIgogbXNnc3RyICJnaeG7m2kgaOG6oW4ga8OtY2ggdGjGsOG7m2MgdOG7kWkgdGhp4buDdSBj4bunYSBnw7NpIGzDoCAxIE1pQiIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozNDI3CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjM0MTEKIG1zZ2lkICItLXRoaW4gY2Fubm90IGJlIHVzZWQgdG8gYnVpbGQgYW4gaW5kZXhhYmxlIHBhY2siCiBtc2dzdHIgIi0tdGhpbiBraMO0bmcgdGjhu4MgxJHGsOG7o2MgZMO5bmcgxJHhu4MgeMOieSBk4buxbmcgZ8OzaSDEkcOhbmggbeG7pWMgbOG7pWMgxJHGsOG7o2MiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzQzMAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozNDE0CiBtc2dpZCAiLS1rZWVwLXVucmVhY2hhYmxlIGFuZCAtLXVucGFjay11bnJlYWNoYWJsZSBhcmUgaW5jb21wYXRpYmxlIgogbXNnc3RyICItLWtlZXAtdW5yZWFjaGFibGUgdsOgIC0tdW5wYWNrLXVucmVhY2hhYmxlIHh1bmcga2jhuq9jIG5oYXUiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzQzNgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozNDIwCiBtc2dpZCAiY2Fubm90IHVzZSAtLWZpbHRlciB3aXRob3V0IC0tc3Rkb3V0IgogbXNnc3RyICJraMO0bmcgdGjhu4MgZMO5bmcgdMO5eSBjaOG7jW4gLS1maWx0ZXIgbcOgIGtow7RuZyBjw7MgLS1zdGRvdXQiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzQ5NworIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozNDgxCiBtc2dpZCAiRW51bWVyYXRpbmcgb2JqZWN0cyIKIG1zZ3N0ciAixJDDoW5oIHPhu5EgY8OhYyDEkeG7kWkgdMaw4bujbmciCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzUyNworIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozNTExCiAjLCBjLWZvcm1hdAogbXNnaWQgIlRvdGFsICU8UFJJdTMyPiAoZGVsdGEgJTxQUkl1MzI+KSwgcmV1c2VkICU8UFJJdTMyPiAoZGVsdGEgJTxQUkl1MzI+KSIKIG1zZ3N0ciAiVOG7lW5nICU8UFJJdTMyPiAoZGVsdGEgJTxQUkl1MzI+KSwgZMO5bmcgbOG6oWkgJTxQUkl1MzI+IChkZWx0YSAlPFBSSXUzMj4pIgpAQCAtMTY0ODUsNDQgKzE2NTY1LDQ0IEBACiBtc2dpZCAiZ2l0IHB1bGwgWzxvcHRpb25zPl0gWzxyZXBvc2l0b3J5PiBbPHJlZnNwZWM+Li4uXV0iCiBtc2dzdHIgImdpdCBwdWxsIFs8Y8OhYyB0w7l5IGNo4buNbj5dIFs8a2hvLWNo4bupYT4gWzxyZWZzcGVjPuKApl1dIgogCi0jOiBidWlsdGluL3B1bGwuYzoxNDEKKyM6IGJ1aWx0aW4vcHVsbC5jOjE0MgogbXNnaWQgImNvbnRyb2wgZm9yIHJlY3Vyc2l2ZSBmZXRjaGluZyBvZiBzdWJtb2R1bGVzIgogbXNnc3RyICLEkWnhu4F1IGtoaeG7g24gdmnhu4djIGzhuqV5IHbhu4EgxJHhu4cgcXV5IGPhu6dhIGPDoWMgbcO0LcSRdW4tY29uIgogCi0jOiBidWlsdGluL3B1bGwuYzoxNDUKKyM6IGJ1aWx0aW4vcHVsbC5jOjE0NgogbXNnaWQgIk9wdGlvbnMgcmVsYXRlZCB0byBtZXJnaW5nIgogbXNnc3RyICJDw6FjIHTDuXkgY2jhu41uIGxpw6puIHF1YW4gxJHhur9uIGjDsmEgdHLhu5luIgogCi0jOiBidWlsdGluL3B1bGwuYzoxNDgKKyM6IGJ1aWx0aW4vcHVsbC5jOjE0OQogbXNnaWQgImluY29ycG9yYXRlIGNoYW5nZXMgYnkgcmViYXNpbmcgcmF0aGVyIHRoYW4gbWVyZ2luZyIKIG1zZ3N0ciAiY8OhYyB0aGF5IMSR4buVaSBo4bujcCBuaOG6pXQgYuG6sW5nIGPhuqNpIHThu5UgdGhheSB2w6wgaMOyYSB0cuG7mW4iCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjE3NiBidWlsdGluL3JlYmFzZS5jOjQ0NyBidWlsdGluL3JldmVydC5jOjEyNgorIzogYnVpbHRpbi9wdWxsLmM6MTc3IGJ1aWx0aW4vcmViYXNlLmM6NDQ4IGJ1aWx0aW4vcmV2ZXJ0LmM6MTI2CiBtc2dpZCAiYWxsb3cgZmFzdC1mb3J3YXJkIgogbXNnc3RyICJjaG8gcGjDqXAgY2h1eeG7g24tdGnhur9wLW5oYW5oIgogCi0jOiBidWlsdGluL3B1bGwuYzoxODUKKyM6IGJ1aWx0aW4vcHVsbC5jOjE4NgogbXNnaWQgImF1dG9tYXRpY2FsbHkgc3Rhc2gvc3Rhc2ggcG9wIGJlZm9yZSBhbmQgYWZ0ZXIgcmViYXNlIgogbXNnc3RyICJ04buxIMSR4buZbmcgc3Rhc2gvc3Rhc2ggcG9wIHTGsOG7m2MgdsOgIHNhdSB0dSBi4buVIChyZWJhc2UpIgogCi0jOiBidWlsdGluL3B1bGwuYzoyMDEKKyM6IGJ1aWx0aW4vcHVsbC5jOjIwMgogbXNnaWQgIk9wdGlvbnMgcmVsYXRlZCB0byBmZXRjaGluZyIKIG1zZ3N0ciAiQ8OhYyB0w7l5IGNo4buNbiBsacOqbiBxdWFuIMSR4bq/biBs4buHbmggbOG6pXkgduG7gSIKIAotIzogYnVpbHRpbi9wdWxsLmM6MjExCisjOiBidWlsdGluL3B1bGwuYzoyMTIKIG1zZ2lkICJmb3JjZSBvdmVyd3JpdGUgb2YgbG9jYWwgYnJhbmNoIgogbXNnc3RyICLDqXAgYnXhu5ljIGdoaSDEkcOoIGzDqm4gbmjDoW5oIG7hu5lpIGLhu5kiCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjIxOQorIzogYnVpbHRpbi9wdWxsLmM6MjIwCiBtc2dpZCAibnVtYmVyIG9mIHN1Ym1vZHVsZXMgcHVsbGVkIGluIHBhcmFsbGVsIgogbXNnc3RyICJz4buRIGzGsOG7o25nIG3DtC3EkXVuLWNvbiDEkcaw4bujYyDEkeG6qXkgbMOqbiDEkeG7k25nIHRo4budaSIKIAotIzogYnVpbHRpbi9wdWxsLmM6MzE2CisjOiBidWlsdGluL3B1bGwuYzozMjAKICMsIGMtZm9ybWF0CiBtc2dpZCAiSW52YWxpZCB2YWx1ZSBmb3IgcHVsbC5mZjogJXMiCiBtc2dzdHIgIkdpw6EgdHLhu4sga2jDtG5nIGjhu6NwIGzhu4cgY2hvIHB1bGwuZmY6ICVzIgogCi0jOiBidWlsdGluL3B1bGwuYzo0MzMKKyM6IGJ1aWx0aW4vcHVsbC5jOjQzNwogbXNnaWQgIiIKICJUaGVyZSBpcyBubyBjYW5kaWRhdGUgZm9yIHJlYmFzaW5nIGFnYWluc3QgYW1vbmcgdGhlIHJlZnMgdGhhdCB5b3UganVzdCAiCiAiZmV0Y2hlZC4iCkBAIC0xNjUzMCwxNCArMTY2MTAsMTQgQEAKICLhu54gxJHDonkga2jDtG5nIGPDsyDhu6luZyBj4butIG7DoG8gxJHhu4MgY+G6o2kgdOG7lSBs4bqhaSB0cm9uZyBz4buRIGPDoWMgdGhhbSBjaGnhur91IG3DoCBi4bqhbiB24burYSAiCiAibOG6pXkgduG7gS4iCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjQzNQorIzogYnVpbHRpbi9wdWxsLmM6NDM5CiBtc2dpZCAiIgogIlRoZXJlIGFyZSBubyBjYW5kaWRhdGVzIGZvciBtZXJnaW5nIGFtb25nIHRoZSByZWZzIHRoYXQgeW91IGp1c3QgZmV0Y2hlZC4iCiBtc2dzdHIgIiIKICLhu54gxJHDonkga2jDtG5nIGPDsyDhu6luZyBj4butIG7DoG8gxJHhu4MgaMOyYSB0cuG7mW4gdHJvbmcgc+G7kSBjw6FjIHRoYW0gY2hp4bq/dSBtw6AgYuG6oW4gduG7q2EgbOG6pXkgIgogInbhu4EuIgogCi0jOiBidWlsdGluL3B1bGwuYzo0MzYKKyM6IGJ1aWx0aW4vcHVsbC5jOjQ0MAogbXNnaWQgIiIKICJHZW5lcmFsbHkgdGhpcyBtZWFucyB0aGF0IHlvdSBwcm92aWRlZCBhIHdpbGRjYXJkIHJlZnNwZWMgd2hpY2ggaGFkIG5vXG4iCiAibWF0Y2hlcyBvbiB0aGUgcmVtb3RlIGVuZC4iCkBAIC0xNjU0Niw3ICsxNjYyNiw3IEBACiAidOG7sVxuIgogIsSR4bqhaSBkaeG7h24gbcOgIG7DsyBs4bqhaSBraMO0bmcga2jhu5twIHRyw6puIMSRaeG7g20gY3Xhu5FpIG3DoXkgcGjhu6VjIHbhu6UuIgogCi0jOiBidWlsdGluL3B1bGwuYzo0MzkKKyM6IGJ1aWx0aW4vcHVsbC5jOjQ0MwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiWW91IGFza2VkIHRvIHB1bGwgZnJvbSB0aGUgcmVtb3RlICclcycsIGJ1dCBkaWQgbm90IHNwZWNpZnlcbiIKQEAgLTE2NTU4LDQzICsxNjYzOCw0MyBAQAogInRoZW8gbeG6t2MgxJHhu4tuaCBjaG8gbmjDoW5oIGhp4buHbiB04bqhaSBj4bunYSBi4bqhbiwgYuG6oW4gcGjhuqNpIGNo4buJIMSR4buLbmhcbiIKICJt4buZdCBuaMOhbmggdHLDqm4gZMOybmcgbOG7h25oLiIKIAotIzogYnVpbHRpbi9wdWxsLmM6NDQ0IGJ1aWx0aW4vcmViYXNlLmM6MTMyNiBnaXQtcGFyc2UtcmVtb3RlLnNoOjczCisjOiBidWlsdGluL3B1bGwuYzo0NDggYnVpbHRpbi9yZWJhc2UuYzoxMzQ3IGdpdC1wYXJzZS1yZW1vdGUuc2g6NzMKIG1zZ2lkICJZb3UgYXJlIG5vdCBjdXJyZW50bHkgb24gYSBicmFuY2guIgogbXNnc3RyICJIaeG7h24gdOG6oWkgYuG6oW4gY2jhurNuZyDhu58gbmjDoW5oIG7DoG8gY+G6oy4iCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjQ0NiBidWlsdGluL3B1bGwuYzo0NjEgZ2l0LXBhcnNlLXJlbW90ZS5zaDo3OQorIzogYnVpbHRpbi9wdWxsLmM6NDUwIGJ1aWx0aW4vcHVsbC5jOjQ2NSBnaXQtcGFyc2UtcmVtb3RlLnNoOjc5CiBtc2dpZCAiUGxlYXNlIHNwZWNpZnkgd2hpY2ggYnJhbmNoIHlvdSB3YW50IHRvIHJlYmFzZSBhZ2FpbnN0LiIKIG1zZ3N0ciAiVnVpIGzDsm5nIGNo4buJIMSR4buLbmggbmjDoW5oIG7DoG8gYuG6oW4gbXXhu5FuIGPhuqNpIHThu5UgbOG6oWkuIgogCi0jOiBidWlsdGluL3B1bGwuYzo0NDggYnVpbHRpbi9wdWxsLmM6NDYzIGdpdC1wYXJzZS1yZW1vdGUuc2g6ODIKKyM6IGJ1aWx0aW4vcHVsbC5jOjQ1MiBidWlsdGluL3B1bGwuYzo0NjcgZ2l0LXBhcnNlLXJlbW90ZS5zaDo4MgogbXNnaWQgIlBsZWFzZSBzcGVjaWZ5IHdoaWNoIGJyYW5jaCB5b3Ugd2FudCB0byBtZXJnZSB3aXRoLiIKIG1zZ3N0ciAiVnVpIGzDsm5nIGNo4buJIMSR4buLbmggbmjDoW5oIG7DoG8gYuG6oW4gbXXhu5FuIGjDsmEgdHLhu5luIHbDoG8uIgogCi0jOiBidWlsdGluL3B1bGwuYzo0NDkgYnVpbHRpbi9wdWxsLmM6NDY0CisjOiBidWlsdGluL3B1bGwuYzo0NTMgYnVpbHRpbi9wdWxsLmM6NDY4CiBtc2dpZCAiU2VlIGdpdC1wdWxsKDEpIGZvciBkZXRhaWxzLiIKIG1zZ3N0ciAiWGVtIGdpdC1wdWxsKDEpIMSR4buDIGJp4bq/dCB0aMOqbSBjaGkgdGnhur90LiIKIAotIzogYnVpbHRpbi9wdWxsLmM6NDUxIGJ1aWx0aW4vcHVsbC5jOjQ1NyBidWlsdGluL3B1bGwuYzo0NjYKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTMzMiBnaXQtcGFyc2UtcmVtb3RlLnNoOjY0CisjOiBidWlsdGluL3B1bGwuYzo0NTUgYnVpbHRpbi9wdWxsLmM6NDYxIGJ1aWx0aW4vcHVsbC5jOjQ3MAorIzogYnVpbHRpbi9yZWJhc2UuYzoxMzUzIGdpdC1wYXJzZS1yZW1vdGUuc2g6NjQKIG1zZ2lkICI8cmVtb3RlPiIKIG1zZ3N0ciAiPG3DoXkgY2jhu6c+IgogCi0jOiBidWlsdGluL3B1bGwuYzo0NTEgYnVpbHRpbi9wdWxsLmM6NDY2IGJ1aWx0aW4vcHVsbC5jOjQ3MQorIzogYnVpbHRpbi9wdWxsLmM6NDU1IGJ1aWx0aW4vcHVsbC5jOjQ3MCBidWlsdGluL3B1bGwuYzo0NzUKICM6IGdpdC1wYXJzZS1yZW1vdGUuc2g6NjUKIG1zZ2lkICI8YnJhbmNoPiIKIG1zZ3N0ciAiPG5ow6FuaD4iCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjQ1OSBidWlsdGluL3JlYmFzZS5jOjEzMjQgZ2l0LXBhcnNlLXJlbW90ZS5zaDo3NQorIzogYnVpbHRpbi9wdWxsLmM6NDYzIGJ1aWx0aW4vcmViYXNlLmM6MTM0NSBnaXQtcGFyc2UtcmVtb3RlLnNoOjc1CiBtc2dpZCAiVGhlcmUgaXMgbm8gdHJhY2tpbmcgaW5mb3JtYXRpb24gZm9yIHRoZSBjdXJyZW50IGJyYW5jaC4iCiBtc2dzdHIgIuG7niDEkcOieSBraMO0bmcgY8OzIHRow7RuZyB0aW4gdGhlbyBkw7VpIGNobyBuaMOhbmggaGnhu4duIGjDoG5oLiIKIAotIzogYnVpbHRpbi9wdWxsLmM6NDY4IGdpdC1wYXJzZS1yZW1vdGUuc2g6OTUKKyM6IGJ1aWx0aW4vcHVsbC5jOjQ3MiBnaXQtcGFyc2UtcmVtb3RlLnNoOjk1CiBtc2dpZCAiIgogIklmIHlvdSB3aXNoIHRvIHNldCB0cmFja2luZyBpbmZvcm1hdGlvbiBmb3IgdGhpcyBicmFuY2ggeW91IGNhbiBkbyBzbyB3aXRoOiIKIG1zZ3N0ciAiIgogIk7hur91IGLhuqFuIG114buRbiB0aGVvIGTDtWkgdGjDtG5nIHRpbiBjaG8gbmjDoW5oIG7DoHkgYuG6oW4gY8OzIHRo4buDIHRo4buxYyBoaeG7h24gYuG6sW5nIGzhu4duaDoiCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjQ3MworIzogYnVpbHRpbi9wdWxsLmM6NDc3CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJZb3VyIGNvbmZpZ3VyYXRpb24gc3BlY2lmaWVzIHRvIG1lcmdlIHdpdGggdGhlIHJlZiAnJXMnXG4iCkBAIC0xNjYwMywzNCArMTY2ODMsMzQgQEAKICJDw6FjIMSR4bq3YyB04bqjIGPhuqV1IGjDrG5oIGPhu6dhIGLhuqFuIMSR4buDIGjDsmEgdHLhu5luIHbhu5tpIHRoYW0gY2hp4bq/dSDigJwlc+KAnVxuIgogInThu6sgbcOheSBk4buLY2ggduG7pSwgbmjGsG5nIGtow7RuZyBjw7MgbmjDoW5oIG7DoG8gbmjGsCB0aOG6vyDEkcaw4bujYyBs4bqleSB24buBLiIKIAotIzogYnVpbHRpbi9wdWxsLmM6NTgxCisjOiBidWlsdGluL3B1bGwuYzo1ODcKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGFjY2VzcyBjb21taXQgJXMiCiBtc2dzdHIgImtow7RuZyB0aOG7gyB0cnV5IGPhuq1wIGzhuqduIGNodXnhu4NuIGdpYW8g4oCcJXPigJ0iCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjg2MQorIzogYnVpbHRpbi9wdWxsLmM6ODY3CiBtc2dpZCAiaWdub3JpbmcgLS12ZXJpZnktc2lnbmF0dXJlcyBmb3IgcmViYXNlIgogbXNnc3RyICJi4buPIHF1YSAtLXZlcmlmeS1zaWduYXR1cmVzIGtoaSByZWJhc2UiCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjkxNgorIzogYnVpbHRpbi9wdWxsLmM6OTIyCiBtc2dpZCAiLS1bbm8tXWF1dG9zdGFzaCBvcHRpb24gaXMgb25seSB2YWxpZCB3aXRoIC0tcmViYXNlLiIKIG1zZ3N0ciAidMO5eSBjaOG7jW4gLS1bbm8tXWF1dG9zdGFzaCBjaOG7iSBo4bujcCBs4buHIGtoaSBkw7luZyB24bubaSAtLXJlYmFzZS4iCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjkyNAorIzogYnVpbHRpbi9wdWxsLmM6OTMwCiBtc2dpZCAiVXBkYXRpbmcgYW4gdW5ib3JuIGJyYW5jaCB3aXRoIGNoYW5nZXMgYWRkZWQgdG8gdGhlIGluZGV4LiIKIG1zZ3N0ciAiIgogIsSQYW5nIGPhuq1wIG5o4bqtdCBt4buZdCBuaMOhbmggY2jGsGEgxJHGsOG7o2Mgc2luaCByYSB24bubaSBjw6FjIHRoYXkgxJHhu5VpIMSRxrDhu6NjIHRow6ptIHbDoG8gIgogImLhuqNuZyBt4bulYyBs4bulYy4iCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjkyOAorIzogYnVpbHRpbi9wdWxsLmM6OTM0CiBtc2dpZCAicHVsbCB3aXRoIHJlYmFzZSIKIG1zZ3N0ciAicHVsbCB24bubaSByZWJhc2UiCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjkyOQorIzogYnVpbHRpbi9wdWxsLmM6OTM1CiBtc2dpZCAicGxlYXNlIGNvbW1pdCBvciBzdGFzaCB0aGVtLiIKIG1zZ3N0ciAieGluIGjDo3kgY2h1eeG7g24gZ2lhbyBob+G6t2MgdOG6oW0gY+G6pXQgKHN0YXNoKSBjaMO6bmcuIgogCi0jOiBidWlsdGluL3B1bGwuYzo5NTQKKyM6IGJ1aWx0aW4vcHVsbC5jOjk2MAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiZmV0Y2ggdXBkYXRlZCB0aGUgY3VycmVudCBicmFuY2ggaGVhZC5cbiIKQEAgLTE2NjQxLDcgKzE2NzIxLDcgQEAKICLEkWFuZyBjaHV54buDbi10aeG6v3AtbmhhbmggY8OieSBsw6BtIHZp4buHYyBj4bunYSBi4bqhbiB04burXG4iCiAibOG6p24gY2h1eeG7g24gZ2lhb3QgJXMuIgogCi0jOiBidWlsdGluL3B1bGwuYzo5NjAKKyM6IGJ1aWx0aW4vcHVsbC5jOjk2NgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiQ2Fubm90IGZhc3QtZm9yd2FyZCB5b3VyIHdvcmtpbmcgdHJlZS5cbiIKQEAgLTE2NjU5LDE1ICsxNjczOSwxNSBAQAogIiQgZ2l0IHJlc2V0IC0taGFyZFxuIgogIsSR4buDIGtow7RpIHBo4bulYyBs4bqhaS4iCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjk3NQorIzogYnVpbHRpbi9wdWxsLmM6OTgxCiBtc2dpZCAiQ2Fubm90IG1lcmdlIG11bHRpcGxlIGJyYW5jaGVzIGludG8gZW1wdHkgaGVhZC4iCiBtc2dzdHIgIktow7RuZyB0aOG7gyBow7JhIHRy4buZbiBuaGnhu4F1IG5ow6FuaCB2w6BvIHRyb25nIG3hu5l0IGhlYWQgdHLhu5FuZyBy4buXbmcuIgogCi0jOiBidWlsdGluL3B1bGwuYzo5NzkKKyM6IGJ1aWx0aW4vcHVsbC5jOjk4NQogbXNnaWQgIkNhbm5vdCByZWJhc2Ugb250byBtdWx0aXBsZSBicmFuY2hlcy4iCiBtc2dzdHIgIktow7RuZyB0aOG7gyB0aOG7sWMgaGnhu4duIGzhu4duaCByZWJhc2UgKGPhuqNpIHThu5UpIHRyw6puIG5oaeG7gXUgbmjDoW5oLiIKIAotIzogYnVpbHRpbi9wdWxsLmM6OTg2CisjOiBidWlsdGluL3B1bGwuYzo5OTIKIG1zZ2lkICJjYW5ub3QgcmViYXNlIHdpdGggbG9jYWxseSByZWNvcmRlZCBzdWJtb2R1bGUgbW9kaWZpY2F0aW9ucyIKIG1zZ3N0ciAiIgogImtow7RuZyB0aOG7gyBj4bqjaSB04buVIHbhu5tpIGPDoWMgdGhheSDEkeG7lWkgbcO0LcSRdW4tY29uIMSRxrDhu6NjIGdoaSBs4bqhaSBt4buZdCBjw6FjaCBj4bulYyBi4buZIgpAQCAtMTY4MzQsMTcgKzE2OTE0LDk0IEBACiBtc2dpZCAiUHVzaGluZyB0byAlc1xuIgogbXNnc3RyICLEkGFuZyDEkeG6qXkgbMOqbiAlc1xuIgogCi0jOiBidWlsdGluL3B1c2guYzozNjQKKyM6IGJ1aWx0aW4vcHVzaC5jOjM2NgogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gcHVzaCBzb21lIHJlZnMgdG8gJyVzJyIKIG1zZ3N0ciAiZ+G6t3AgbOG7l2kga2hpIMSR4bqpeSB04bubaSBt4buZdCBz4buRIHRoYW0gY2hp4bq/dSDEkeG6v24g4oCcJXPigJ0iCiAKLSM6IGJ1aWx0aW4vcHVzaC5jOjM5OAorIzogYnVpbHRpbi9wdXNoLmM6NTQxCittc2dpZCAicmVwb3NpdG9yeSIKK21zZ3N0ciAia2hvIgorCisjOiBidWlsdGluL3B1c2guYzo1NDIgYnVpbHRpbi9zZW5kLXBhY2suYzoxNjQKK21zZ2lkICJwdXNoIGFsbCByZWZzIgorbXNnc3RyICLEkeG6qXkgdOG6pXQgY+G6oyBjw6FjIHRoYW0gY2hp4bq/dSIKKworIzogYnVpbHRpbi9wdXNoLmM6NTQzIGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTY2Cittc2dpZCAibWlycm9yIGFsbCByZWZzIgorbXNnc3RyICJtaXJyb3IgdOG6pXQgY+G6oyBjw6FjIHRoYW0gY2hp4bq/dSIKKworIzogYnVpbHRpbi9wdXNoLmM6NTQ1Cittc2dpZCAiZGVsZXRlIHJlZnMiCittc2dzdHIgInjDs2EgY8OhYyB0aGFtIGNoaeG6v3UiCisKKyM6IGJ1aWx0aW4vcHVzaC5jOjU0NgorbXNnaWQgInB1c2ggdGFncyAoY2FuJ3QgYmUgdXNlZCB3aXRoIC0tYWxsIG9yIC0tbWlycm9yKSIKK21zZ3N0ciAixJHhuql5IGPDoWMgdGjhursgKGtow7RuZyBkw7luZyBjw7luZyB24bubaSAtLWFsbCBoYXkgLS1taXJyb3IpIgorCisjOiBidWlsdGluL3B1c2guYzo1NDkgYnVpbHRpbi9zZW5kLXBhY2suYzoxNjcKK21zZ2lkICJmb3JjZSB1cGRhdGVzIgorbXNnc3RyICLDqXAgYnXhu5ljIGPhuq1wIG5o4bqtdCIKKworIzogYnVpbHRpbi9wdXNoLmM6NTUxIGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTgxCittc2dpZCAiPHJlZm5hbWU+OjxleHBlY3Q+IgorbXNnc3RyICI8dMOqbi10aGFtLWNoaeG6v3U+Ojxj4bqnbj4iCisKKyM6IGJ1aWx0aW4vcHVzaC5jOjU1MiBidWlsdGluL3NlbmQtcGFjay5jOjE4MgorbXNnaWQgInJlcXVpcmUgb2xkIHZhbHVlIG9mIHJlZiB0byBiZSBhdCB0aGlzIHZhbHVlIgorbXNnc3RyICJ5w6p1IGPhuqd1IGdpw6EtdHLhu4sgY8WpIGPhu6dhIHRoYW0gY2hp4bq/dSB0aMOsIGzDoCBnacOhLXRy4buLIG7DoHkiCisKKyM6IGJ1aWx0aW4vcHVzaC5jOjU1NQorbXNnaWQgImNvbnRyb2wgcmVjdXJzaXZlIHB1c2hpbmcgb2Ygc3VibW9kdWxlcyIKK21zZ3N0ciAixJFp4buBdSBraGnhu4NuIHZp4buHYyDEkeG6qXkgbMOqbiAocHVzaCkgxJHhu4cgcXVpIGPhu6dhIG3DtC3EkXVuLWNvbiIKKworIzogYnVpbHRpbi9wdXNoLmM6NTU3IGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTc1Cittc2dpZCAidXNlIHRoaW4gcGFjayIKK21zZ3N0ciAidOG6oW8gZ8OzaSBuaOG6uSIKKworIzogYnVpbHRpbi9wdXNoLmM6NTU4IGJ1aWx0aW4vcHVzaC5jOjU1OSBidWlsdGluL3NlbmQtcGFjay5jOjE2MQorIzogYnVpbHRpbi9zZW5kLXBhY2suYzoxNjIKK21zZ2lkICJyZWNlaXZlIHBhY2sgcHJvZ3JhbSIKK21zZ3N0ciAiY2jGsMahbmcgdHLDrG5oIG5o4bqtbiBnw7NpIgorCisjOiBidWlsdGluL3B1c2guYzo1NjAKK21zZ2lkICJzZXQgdXBzdHJlYW0gZm9yIGdpdCBwdWxsL3N0YXR1cyIKK21zZ3N0ciAixJHhurd0IHRoxrDhu6NuZyBuZ3Xhu5NuIGNobyBnaXQgcHVsbC9zdGF0dXMiCisKKyM6IGJ1aWx0aW4vcHVzaC5jOjU2MworbXNnaWQgInBydW5lIGxvY2FsbHkgcmVtb3ZlZCByZWZzIgorbXNnc3RyICJ4w6luIHThu4lhIG5o4buvbmcgdGhhbSBjaGnhur91IGLhu4sgZ+G7oSBi4buPIgorCisjOiBidWlsdGluL3B1c2guYzo1NjUKK21zZ2lkICJieXBhc3MgcHJlLXB1c2ggaG9vayIKK21zZ3N0ciAidsOybmcgcXVhIG3Ds2MgdGnhu4FuLcSR4bqpeSAocHJlLXB1c2gpIgorCisjOiBidWlsdGluL3B1c2guYzo1NjYKK21zZ2lkICJwdXNoIG1pc3NpbmcgYnV0IHJlbGV2YW50IHRhZ3MiCittc2dzdHIgInB1c2ggcGjhuqduIGLhu4sgdGhp4bq/dSBuaMawbmcgY8OhYyB0aOG6uyBs4bqhaSB0aMOtY2ggaOG7o3AiCisKKyM6IGJ1aWx0aW4vcHVzaC5jOjU2OSBidWlsdGluL3NlbmQtcGFjay5jOjE2OQorbXNnaWQgIkdQRyBzaWduIHRoZSBwdXNoIgorbXNnc3RyICJrw70gbOG6p24gxJHhuql5IGTDuW5nIEdQRyIKKworIzogYnVpbHRpbi9wdXNoLmM6NTcxIGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTc2Cittc2dpZCAicmVxdWVzdCBhdG9taWMgdHJhbnNhY3Rpb24gb24gcmVtb3RlIHNpZGUiCittc2dzdHIgInnDqnUgY+G6p3UgZ2lhbyBk4buLY2ggaOG6oXQgbmjDom4gYsOqbiBwaMOtYSBtw6F5IGNo4bunIgorCisjOiBidWlsdGluL3B1c2guYzo1ODkKK21zZ2lkICItLWRlbGV0ZSBpcyBpbmNvbXBhdGlibGUgd2l0aCAtLWFsbCwgLS1taXJyb3IgYW5kIC0tdGFncyIKK21zZ3N0ciAiLS1kZWxldGUgbMOgIHh1bmcga2jhuq9jIHbhu5tpIGPDoWMgdMO5eSBjaOG7jW4gLS1hbGwsIC0tbWlycm9yIHbDoCAtLXRhZ3MiCisKKyM6IGJ1aWx0aW4vcHVzaC5jOjU5MQorbXNnaWQgIi0tZGVsZXRlIGRvZXNuJ3QgbWFrZSBzZW5zZSB3aXRob3V0IGFueSByZWZzIgorbXNnc3RyICItLWRlbGV0ZSBraMO0bmcgaOG7o3AgbMO9IG7hur91IGtow7RuZyBjw7MgYuG6pXQga+G7syB0aGFtIGNoaeG6v3UgbsOgbyIKKworIzogYnVpbHRpbi9wdXNoLmM6NjExCiAjLCBjLWZvcm1hdAogbXNnaWQgImJhZCByZXBvc2l0b3J5ICclcyciCiBtc2dzdHIgInJlcG9zaXRvcnkgKGtobykgc2FpIOKAnCVz4oCdIgogCi0jOiBidWlsdGluL3B1c2guYzozOTkKKyM6IGJ1aWx0aW4vcHVzaC5jOjYxMgogbXNnaWQgIiIKICJObyBjb25maWd1cmVkIHB1c2ggZGVzdGluYXRpb24uXG4iCiAiRWl0aGVyIHNwZWNpZnkgdGhlIFVSTCBmcm9tIHRoZSBjb21tYW5kLWxpbmUgb3IgY29uZmlndXJlIGEgcmVtb3RlICIKQEAgLTE2ODY1LDEwNCArMTcwMjIsMjcgQEAKICJcbiIKICIgICAgZ2l0IHB1c2ggPHTDqm4+XG4iCiAKLSM6IGJ1aWx0aW4vcHVzaC5jOjU1NAotbXNnaWQgInJlcG9zaXRvcnkiCi1tc2dzdHIgImtobyIKLQotIzogYnVpbHRpbi9wdXNoLmM6NTU1IGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTY0Ci1tc2dpZCAicHVzaCBhbGwgcmVmcyIKLW1zZ3N0ciAixJHhuql5IHThuqV0IGPhuqMgY8OhYyB0aGFtIGNoaeG6v3UiCi0KLSM6IGJ1aWx0aW4vcHVzaC5jOjU1NiBidWlsdGluL3NlbmQtcGFjay5jOjE2NgotbXNnaWQgIm1pcnJvciBhbGwgcmVmcyIKLW1zZ3N0ciAibWlycm9yIHThuqV0IGPhuqMgY8OhYyB0aGFtIGNoaeG6v3UiCi0KLSM6IGJ1aWx0aW4vcHVzaC5jOjU1OAotbXNnaWQgImRlbGV0ZSByZWZzIgotbXNnc3RyICJ4w7NhIGPDoWMgdGhhbSBjaGnhur91IgotCi0jOiBidWlsdGluL3B1c2guYzo1NTkKLW1zZ2lkICJwdXNoIHRhZ3MgKGNhbid0IGJlIHVzZWQgd2l0aCAtLWFsbCBvciAtLW1pcnJvcikiCi1tc2dzdHIgIsSR4bqpeSBjw6FjIHRo4bq7IChraMO0bmcgZMO5bmcgY8O5bmcgduG7m2kgLS1hbGwgaGF5IC0tbWlycm9yKSIKLQotIzogYnVpbHRpbi9wdXNoLmM6NTYyIGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTY3Ci1tc2dpZCAiZm9yY2UgdXBkYXRlcyIKLW1zZ3N0ciAiw6lwIGJ14buZYyBj4bqtcCBuaOG6rXQiCi0KLSM6IGJ1aWx0aW4vcHVzaC5jOjU2NCBidWlsdGluL3NlbmQtcGFjay5jOjE4MQotbXNnaWQgIjxyZWZuYW1lPjo8ZXhwZWN0PiIKLW1zZ3N0ciAiPHTDqm4tdGhhbS1jaGnhur91Pjo8Y+G6p24+IgotCi0jOiBidWlsdGluL3B1c2guYzo1NjUgYnVpbHRpbi9zZW5kLXBhY2suYzoxODIKLW1zZ2lkICJyZXF1aXJlIG9sZCB2YWx1ZSBvZiByZWYgdG8gYmUgYXQgdGhpcyB2YWx1ZSIKLW1zZ3N0ciAiecOqdSBj4bqndSBnacOhLXRy4buLIGPFqSBj4bunYSB0aGFtIGNoaeG6v3UgdGjDrCBsw6AgZ2nDoS10cuG7iyBuw6B5IgotCi0jOiBidWlsdGluL3B1c2guYzo1NjgKLW1zZ2lkICJjb250cm9sIHJlY3Vyc2l2ZSBwdXNoaW5nIG9mIHN1Ym1vZHVsZXMiCi1tc2dzdHIgIsSRaeG7gXUga2hp4buDbiB2aeG7h2MgxJHhuql5IGzDqm4gKHB1c2gpIMSR4buHIHF1aSBj4bunYSBtw7QtxJF1bi1jb24iCi0KLSM6IGJ1aWx0aW4vcHVzaC5jOjU3MCBidWlsdGluL3NlbmQtcGFjay5jOjE3NQotbXNnaWQgInVzZSB0aGluIHBhY2siCi1tc2dzdHIgInThuqFvIGfDs2kgbmjhurkiCi0KLSM6IGJ1aWx0aW4vcHVzaC5jOjU3MSBidWlsdGluL3B1c2guYzo1NzIgYnVpbHRpbi9zZW5kLXBhY2suYzoxNjEKLSM6IGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTYyCi1tc2dpZCAicmVjZWl2ZSBwYWNrIHByb2dyYW0iCi1tc2dzdHIgImNoxrDGoW5nIHRyw6xuaCBuaOG6rW4gZ8OzaSIKLQotIzogYnVpbHRpbi9wdXNoLmM6NTczCi1tc2dpZCAic2V0IHVwc3RyZWFtIGZvciBnaXQgcHVsbC9zdGF0dXMiCi1tc2dzdHIgIsSR4bq3dCB0aMaw4bujbmcgbmd14buTbiBjaG8gZ2l0IHB1bGwvc3RhdHVzIgotCi0jOiBidWlsdGluL3B1c2guYzo1NzYKLW1zZ2lkICJwcnVuZSBsb2NhbGx5IHJlbW92ZWQgcmVmcyIKLW1zZ3N0ciAieMOpbiB04buJYSBuaOG7r25nIHRoYW0gY2hp4bq/dSBi4buLIGfhu6EgYuG7jyIKLQotIzogYnVpbHRpbi9wdXNoLmM6NTc4Ci1tc2dpZCAiYnlwYXNzIHByZS1wdXNoIGhvb2siCi1tc2dzdHIgInbDsm5nIHF1YSBtw7NjIHRp4buBbi3EkeG6qXkgKHByZS1wdXNoKSIKLQotIzogYnVpbHRpbi9wdXNoLmM6NTc5Ci1tc2dpZCAicHVzaCBtaXNzaW5nIGJ1dCByZWxldmFudCB0YWdzIgotbXNnc3RyICJwdXNoIHBo4bqnbiBi4buLIHRoaeG6v3UgbmjGsG5nIGPDoWMgdGjhursgbOG6oWkgdGjDrWNoIGjhu6NwIgotCi0jOiBidWlsdGluL3B1c2guYzo1ODIgYnVpbHRpbi9zZW5kLXBhY2suYzoxNjkKLW1zZ2lkICJHUEcgc2lnbiB0aGUgcHVzaCIKLW1zZ3N0ciAia8O9IGzhuqduIMSR4bqpeSBkw7luZyBHUEciCi0KLSM6IGJ1aWx0aW4vcHVzaC5jOjU4NCBidWlsdGluL3NlbmQtcGFjay5jOjE3NgotbXNnaWQgInJlcXVlc3QgYXRvbWljIHRyYW5zYWN0aW9uIG9uIHJlbW90ZSBzaWRlIgotbXNnc3RyICJ5w6p1IGPhuqd1IGdpYW8gZOG7i2NoIGjhuqF0IG5ow6JuIGLDqm4gcGjDrWEgbcOheSBjaOG7pyIKLQotIzogYnVpbHRpbi9wdXNoLmM6NjAyCi1tc2dpZCAiLS1kZWxldGUgaXMgaW5jb21wYXRpYmxlIHdpdGggLS1hbGwsIC0tbWlycm9yIGFuZCAtLXRhZ3MiCi1tc2dzdHIgIi0tZGVsZXRlIGzDoCB4dW5nIGto4bqvYyB24bubaSBjw6FjIHTDuXkgY2jhu41uIC0tYWxsLCAtLW1pcnJvciB2w6AgLS10YWdzIgotCi0jOiBidWlsdGluL3B1c2guYzo2MDQKLW1zZ2lkICItLWRlbGV0ZSBkb2Vzbid0IG1ha2Ugc2Vuc2Ugd2l0aG91dCBhbnkgcmVmcyIKLW1zZ3N0ciAiLS1kZWxldGUga2jDtG5nIGjhu6NwIGzDvSBu4bq/dSBraMO0bmcgY8OzIGLhuqV0IGvhu7MgdGhhbSBjaGnhur91IG7DoG8iCi0KLSM6IGJ1aWx0aW4vcHVzaC5jOjYwNworIzogYnVpbHRpbi9wdXNoLmM6NjI3CiBtc2dpZCAiLS1hbGwgYW5kIC0tdGFncyBhcmUgaW5jb21wYXRpYmxlIgogbXNnc3RyICItLWFsbCB2w6AgLS10YWdzIHh1bmcga2jhuq9jIG5oYXUiCiAKLSM6IGJ1aWx0aW4vcHVzaC5jOjYwOQorIzogYnVpbHRpbi9wdXNoLmM6NjI5CiBtc2dpZCAiLS1hbGwgY2FuJ3QgYmUgY29tYmluZWQgd2l0aCByZWZzcGVjcyIKIG1zZ3N0ciAiLS1hbGwga2jDtG5nIHRo4buDIMSRxrDhu6NjIHThu5UgaOG7o3AgY8O5bmcgduG7m2kgxJHhurdjIHThuqMgxJHGsOG7nW5nIGThuqtuIgogCi0jOiBidWlsdGluL3B1c2guYzo2MTMKKyM6IGJ1aWx0aW4vcHVzaC5jOjYzMwogbXNnaWQgIi0tbWlycm9yIGFuZCAtLXRhZ3MgYXJlIGluY29tcGF0aWJsZSIKIG1zZ3N0ciAiLS1taXJyb3IgdsOgIC0tdGFncyB4dW5nIGto4bqvYyBuaGF1IgogCi0jOiBidWlsdGluL3B1c2guYzo2MTUKKyM6IGJ1aWx0aW4vcHVzaC5jOjYzNQogbXNnaWQgIi0tbWlycm9yIGNhbid0IGJlIGNvbWJpbmVkIHdpdGggcmVmc3BlY3MiCiBtc2dzdHIgIi0tbWlycm9yIGtow7RuZyB0aOG7gyDEkcaw4bujYyB04buVIGjhu6NwIGPDuW5nIHbhu5tpIMSR4bq3YyB04bqjIMSRxrDhu51uZyBk4bqrbiIKIAotIzogYnVpbHRpbi9wdXNoLmM6NjE4CisjOiBidWlsdGluL3B1c2guYzo2MzgKIG1zZ2lkICItLWFsbCBhbmQgLS1taXJyb3IgYXJlIGluY29tcGF0aWJsZSIKIG1zZ3N0ciAiLS1hbGwgdsOgIC0tbWlycm9yIHh1bmcga2jhuq9jIG5oYXUiCiAKLSM6IGJ1aWx0aW4vcHVzaC5jOjYzNworIzogYnVpbHRpbi9wdXNoLmM6NjQyCiBtc2dpZCAicHVzaCBvcHRpb25zIG11c3Qgbm90IGhhdmUgbmV3IGxpbmUgY2hhcmFjdGVycyIKIG1zZ3N0ciAiY8OhYyB0w7l5IGNo4buNbiBwdXNoIHBo4bqjaSBraMO0bmcgY8OzIGvDvSB04buxIGTDsm5nIG3hu5tpIgogCkBAIC0xNzA4MiwxMSArMTcxNjIsMTEgQEAKIAogIzogYnVpbHRpbi9yZWJhc2UuYzozMgogbXNnaWQgIiIKLSJnaXQgcmViYXNlIFstaV0gW29wdGlvbnNdIFstLWV4ZWMgPGNtZD5dIFstLW9udG8gPG5ld2Jhc2U+XSBbPHVwc3RyZWFtPl0gIgotIls8YnJhbmNoPl0iCisiZ2l0IHJlYmFzZSBbLWldIFtvcHRpb25zXSBbLS1leGVjIDxjbWQ+XSBbLS1vbnRvIDxuZXdiYXNlPiB8IC0ta2VlcC1iYXNlXSAiCisiWzx1cHN0cmVhbT4gWzxicmFuY2g+XV0iCiBtc2dzdHIgIiIKLSJnaXQgcmViYXNlIFstaV0gW2PDoWMgdMO5eSBjaOG7jW5dIFstLWV4ZWMgPGzhu4duaD5dIFstLW9udG8gPG5ld2Jhc2U+XSAiCi0iWzx1cHN0cmVhbT5dIFs8bmjDoW5oPl0iCisiZ2l0IHJlYmFzZSBbLWldIFtjw6FjIHTDuXkgY2jhu41uXSBbLS1leGVjIDxs4buHbmg+XSBbLS1vbnRvIDxuZXdiYXNlPiB8IC0ta2VlcC0iCisiYmFzZV0gWzx1cHN0cmVhbT5dIFs8bmjDoW5oPl1dIgogCiAjOiBidWlsdGluL3JlYmFzZS5jOjM0CiBtc2dpZCAiIgpAQCAtMTcxMjYsMTg5ICsxNzIwNiwxODkgQEAKIG1zZ2lkICJjb3VsZCBub3QgZ2VuZXJhdGUgdG9kbyBsaXN0IgogbXNnc3RyICJraMO0bmcgdGjhu4MgdOG6oW8gZGFuaCBzw6FjaCBj4bqnbiBsw6BtIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjM4MgorIzogYnVpbHRpbi9yZWJhc2UuYzozODMKIG1zZ2lkICJhIGJhc2UgY29tbWl0IG11c3QgYmUgcHJvdmlkZWQgd2l0aCAtLXVwc3RyZWFtIG9yIC0tb250byIKIG1zZ3N0ciAibOG6p24gY2h1eeG7g24gZ2lhbyBjxqEgc+G7jyBwaOG6o2kgxJHGsOG7o2MgY2jhu4kgxJHhu4tuaCB24bubaSAtLXVwc3RyZWFtIGhv4bq3YyAtLW9udG8iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDM3CisjOiBidWlsdGluL3JlYmFzZS5jOjQzOAogbXNnaWQgImdpdCByZWJhc2UtLWludGVyYWN0aXZlIFs8b3B0aW9ucz5dIgogbXNnc3RyICJnaXQgcmViYXNlLS1pbnRlcmFjdGl2ZSBbPGPDoWMgdMO5eSBjaOG7jW4+XSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0NDkKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDUwCiBtc2dpZCAia2VlcCBlbXB0eSBjb21taXRzIgogbXNnc3RyICJnaeG7ryBs4bqhaSBjw6FjIGzhuqduIGNodXnhu4NuIGdpYW8gcuG7l25nIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ1MSBidWlsdGluL3JldmVydC5jOjEyOAorIzogYnVpbHRpbi9yZWJhc2UuYzo0NTIgYnVpbHRpbi9yZXZlcnQuYzoxMjgKIG1zZ2lkICJhbGxvdyBjb21taXRzIHdpdGggZW1wdHkgbWVzc2FnZXMiCiBtc2dzdHIgImNo4bqlcCBuaOG6rW4gY2h1eeG7g24gZ2lhbyBtw6Aga2jDtG5nIGdoaSBjaMO6IGfDrCIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0NTIKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDUzCiBtc2dpZCAicmViYXNlIG1lcmdlIGNvbW1pdHMiCiBtc2dzdHIgImPhuqNpIHThu5UgY8OhYyBs4bqnbiBjaHV54buDbiBnaWFvIGjDsmEgdHLhu5luIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ1NAorIzogYnVpbHRpbi9yZWJhc2UuYzo0NTUKIG1zZ2lkICJrZWVwIG9yaWdpbmFsIGJyYW5jaCBwb2ludHMgb2YgY291c2lucyIKIG1zZ3N0ciAiZ2nhu68gY8OhYyDEkWnhu4NtIG5ow6FuaCBuZ3V5w6puIGLhuqNuIGPhu6dhIGPDoWMgYW5oIGVtIGjhu40iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDU2CisjOiBidWlsdGluL3JlYmFzZS5jOjQ1NwogbXNnaWQgIm1vdmUgY29tbWl0cyB0aGF0IGJlZ2luIHdpdGggc3F1YXNoIS9maXh1cCEiCiBtc2dzdHIgImRpIGNodXnhu4NuIGPDoWMgbOG6p24gY2h1eeG7g24gZ2lhbyBi4bqvdCDEkeG6p3UgYuG6sW5nIHNxdWFzaCEvZml4dXAhIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ1NworIzogYnVpbHRpbi9yZWJhc2UuYzo0NTgKIG1zZ2lkICJzaWduIGNvbW1pdHMiCiBtc2dzdHIgImvDvSBjw6FjIGzhuqduIGNodXnhu4NuIGdpYW8iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDU5IGJ1aWx0aW4vcmViYXNlLmM6MTQwMworIzogYnVpbHRpbi9yZWJhc2UuYzo0NjAgYnVpbHRpbi9yZWJhc2UuYzoxNDI3CiBtc2dpZCAiZGlzcGxheSBhIGRpZmZzdGF0IG9mIHdoYXQgY2hhbmdlZCB1cHN0cmVhbSIKIG1zZ3N0ciAiaGnhu4NuIHRo4buLIG3hu5l0IGRpZmZzdGF0IGPhu6dhIG5o4buvbmcgdGhheSDEkeG7lWkgdGjGsOG7o25nIG5ndeG7k24iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDYxCisjOiBidWlsdGluL3JlYmFzZS5jOjQ2MgogbXNnaWQgImNvbnRpbnVlIHJlYmFzZSIKIG1zZ3N0ciAidGnhur9wIHThu6VjIGPhuqNpIHThu5UiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDYzCisjOiBidWlsdGluL3JlYmFzZS5jOjQ2NAogbXNnaWQgInNraXAgY29tbWl0IgogbXNnc3RyICJi4buPIHF1YSBs4bqnbiBjaHV54buDbiBnaWFvIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ2NAorIzogYnVpbHRpbi9yZWJhc2UuYzo0NjUKIG1zZ2lkICJlZGl0IHRoZSB0b2RvIGxpc3QiCiBtc2dzdHIgInPhu61hIGRhbmggc8OhY2ggY+G6p24gbMOgbSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0NjYKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDY3CiBtc2dpZCAic2hvdyB0aGUgY3VycmVudCBwYXRjaCIKIG1zZ3N0ciAiaGnhu4NuIHRo4buLIG1p4bq/bmcgdsOhIGhp4buHbiBow6BuaCIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0NjkKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDcwCiBtc2dpZCAic2hvcnRlbiBjb21taXQgaWRzIGluIHRoZSB0b2RvIGxpc3QiCiBtc2dzdHIgInLDunQgbmfhuq9uIG3DoyBjaHV54buDbiBnaWFvIHRyb25nIGRhbmggc8OhY2ggY+G6p24gbMOgbSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0NzEKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDcyCiBtc2dpZCAiZXhwYW5kIGNvbW1pdCBpZHMgaW4gdGhlIHRvZG8gbGlzdCIKIG1zZ3N0ciAia2hhaSB0cmnhu4NuIG3DoyBjaHV54buDbiBnaWFvIHRyb25nIGRhbmggc8OhY2ggY+G6p24gbMOgbSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0NzMKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDc0CiBtc2dpZCAiY2hlY2sgdGhlIHRvZG8gbGlzdCIKIG1zZ3N0ciAia2nhu4NtIHRyYSBkYW5oIHPDoWNoIGPhuqduIGzDoG0iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDc1CisjOiBidWlsdGluL3JlYmFzZS5jOjQ3NgogbXNnaWQgInJlYXJyYW5nZSBmaXh1cC9zcXVhc2ggbGluZXMiCiBtc2dzdHIgInPhuq9wIHjhur9wIGzhuqFpIGPDoWMgZMOybmcgZml4dXAvc3F1YXNoIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ3NworIzogYnVpbHRpbi9yZWJhc2UuYzo0NzgKIG1zZ2lkICJpbnNlcnQgZXhlYyBjb21tYW5kcyBpbiB0b2RvIGxpc3QiCiBtc2dzdHIgImNow6huIGPDoWMgbOG7h25oIHRo4buxYyB0aGkgdHJvbmcgZGFuaCBzw6FjaCBj4bqnbiBsw6BtIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ3OAorIzogYnVpbHRpbi9yZWJhc2UuYzo0NzkKIG1zZ2lkICJvbnRvIgogbXNnc3RyICJsw6puIHRyw6puIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ4MQorIzogYnVpbHRpbi9yZWJhc2UuYzo0ODIKIG1zZ2lkICJyZXN0cmljdC1yZXZpc2lvbiIKIG1zZ3N0ciAixJFp4buDbS14w6l0LWR1eeG7h3QtaOG6oW4tY2jhur8iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDgxCisjOiBidWlsdGluL3JlYmFzZS5jOjQ4MgogbXNnaWQgInJlc3RyaWN0IHJldmlzaW9uIgogbXNnc3RyICLEkWnhu4NtIHjDqXQgZHV54buHdCBo4bqhbiBjaOG6vyIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0ODMKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDg0CiBtc2dpZCAic3F1YXNoLW9udG8iCiBtc2dzdHIgInNxdWFzaC1sw6puLXRyw6puIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ4NAorIzogYnVpbHRpbi9yZWJhc2UuYzo0ODUKIG1zZ2lkICJzcXVhc2ggb250byIKIG1zZ3N0ciAic3F1YXNoIGzDqm4gdHLDqm4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDg2CisjOiBidWlsdGluL3JlYmFzZS5jOjQ4NwogbXNnaWQgInRoZSB1cHN0cmVhbSBjb21taXQiCiBtc2dzdHIgImzhuqduIGNodXnhu4NuIGdpYW8gdGjGsOG7o25nIG5ndeG7k24iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDg4CisjOiBidWlsdGluL3JlYmFzZS5jOjQ4OQogbXNnaWQgImhlYWQtbmFtZSIKIG1zZ3N0ciAidMOqbi3EkeG6p3UiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDg4CisjOiBidWlsdGluL3JlYmFzZS5jOjQ4OQogbXNnaWQgImhlYWQgbmFtZSIKIG1zZ3N0ciAidMOqbiDEkeG6p3UiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDkzCisjOiBidWlsdGluL3JlYmFzZS5jOjQ5NAogbXNnaWQgInJlYmFzZSBzdHJhdGVneSIKIG1zZ3N0ciAiY2hp4bq/biBsxrDhu6NjIGPhuqNpIHThu5UiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDk0CisjOiBidWlsdGluL3JlYmFzZS5jOjQ5NQogbXNnaWQgInN0cmF0ZWd5LW9wdHMiCiBtc2dzdHIgInTDuXktY2jhu41uLWNoaeG6v24tbMaw4bujYyIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0OTUKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDk2CiBtc2dpZCAic3RyYXRlZ3kgb3B0aW9ucyIKIG1zZ3N0ciAiY8OhYyB0w7l5IGNo4buNbiBjaGnhur9uIGzGsOG7o2MiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDk2CisjOiBidWlsdGluL3JlYmFzZS5jOjQ5NwogbXNnaWQgInN3aXRjaC10byIKIG1zZ3N0ciAiY2h1eeG7g24txJHhur9uIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ5NworIzogYnVpbHRpbi9yZWJhc2UuYzo0OTgKIG1zZ2lkICJ0aGUgYnJhbmNoIG9yIGNvbW1pdCB0byBjaGVja291dCIKIG1zZ3N0ciAibmjDoW5oIGhheSBs4bqnbiBjaHV54buDbiBnaWFvIGzhuqduIGzhuqV5IHJhIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ5OAorIzogYnVpbHRpbi9yZWJhc2UuYzo0OTkKIG1zZ2lkICJvbnRvLW5hbWUiCiBtc2dzdHIgIm9udG8tbmFtZSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0OTgKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDk5CiBtc2dpZCAib250byBuYW1lIgogbXNnc3RyICJ0w6puIGzDqm4gdHLDqm4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDk5CisjOiBidWlsdGluL3JlYmFzZS5jOjUwMAogbXNnaWQgImNtZCIKIG1zZ3N0ciAibOG7h25oIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ5OQorIzogYnVpbHRpbi9yZWJhc2UuYzo1MDAKIG1zZ2lkICJ0aGUgY29tbWFuZCB0byBydW4iCiBtc2dzdHIgImzhu4duaCBtdeG7kW4gY2jhuqF5IgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjUwMiBidWlsdGluL3JlYmFzZS5jOjE0ODYKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NTAzIGJ1aWx0aW4vcmViYXNlLmM6MTUxMAogbXNnaWQgImF1dG9tYXRpY2FsbHkgcmUtc2NoZWR1bGUgYW55IGBleGVjYCB0aGF0IGZhaWxzIgogbXNnc3RyICJs4bqtcCBs4buLY2ggbOG6oWkgbeG7mXQgY8OhY2ggdOG7sSDEkeG7mW5nIGLhuqV0IGvhu7Mg4oCcZXhlY+KAnCBi4buLIGzhu5dpIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjUxOAorIzogYnVpbHRpbi9yZWJhc2UuYzo1MTkKIG1zZ2lkICItLVtuby1dcmViYXNlLWNvdXNpbnMgaGFzIG5vIGVmZmVjdCB3aXRob3V0IC0tcmViYXNlLW1lcmdlcyIKIG1zZ3N0ciAiLS1bbm8tXXJlYmFzZS1jb3VzaW5zIGtow7RuZyBjw7MgdMOhYyBk4bulbmcga2hpIGtow7RuZyBjw7MgLS1yZWJhc2UtbWVyZ2VzIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjUzNAorIzogYnVpbHRpbi9yZWJhc2UuYzo1MzUKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgcmVxdWlyZXMgYW4gaW50ZXJhY3RpdmUgcmViYXNlIgogbXNnc3RyICIlcyBj4bqnbiBt4buZdCBj4bqjaSB04buVIGtp4buDdSB0xrDGoW5nIHTDoWMiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NTg2CisjOiBidWlsdGluL3JlYmFzZS5jOjU4NwogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgZ2V0ICdvbnRvJzogJyVzJyIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIMSR4bq3dCBs4bqleSDigJxvbnRv4oCdOiDigJwlc+KAnSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo2MDEKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NjAyCiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgb3JpZy1oZWFkOiAnJXMnIgogbXNnc3RyICJvcmlnLWhlYWQga2jDtG5nIGjhu6NwIGzhu4c6IOKAnCVz4oCdIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjYyNgorIzogYnVpbHRpbi9yZWJhc2UuYzo2MjcKICMsIGMtZm9ybWF0CiBtc2dpZCAiaWdub3JpbmcgaW52YWxpZCBhbGxvd19yZXJlcmVfYXV0b3VwZGF0ZTogJyVzJyIKIG1zZ3N0ciAixJFhbmcgYuG7jyBxdWEgYWxsb3dfcmVyZXJlX2F1dG91cGRhdGUga2jDtG5nIGjhu6NwIGzhu4c6IOKAnCVz4oCdIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjcwMgorIzogYnVpbHRpbi9yZWJhc2UuYzo3MDMKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ291bGQgbm90IHJlYWQgJyVzJyIKIG1zZ3N0ciAiS2jDtG5nIHRo4buDIMSR4buNYyDigJwlc+KAnSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo3MjAKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NzIxCiAjLCBjLWZvcm1hdAogbXNnaWQgIkNhbm5vdCBzdG9yZSAlcyIKIG1zZ3N0ciAiS2jDtG5nIHRo4buDIGzGsHUg4oCcJXPigJ0iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6ODI3CisjOiBidWlsdGluL3JlYmFzZS5jOjgyOAogbXNnaWQgImNvdWxkIG5vdCBkZXRlcm1pbmUgSEVBRCByZXZpc2lvbiIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIGTDsiB0w6xtIMSRaeG7g20geMOpdCBkdXnhu4d0IEhFQUQiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6OTUwIGdpdC1yZWJhc2UtLXByZXNlcnZlLW1lcmdlcy5zaDo4MQorIzogYnVpbHRpbi9yZWJhc2UuYzo5NTEgZ2l0LXJlYmFzZS0tcHJlc2VydmUtbWVyZ2VzLnNoOjgxCiBtc2dpZCAiIgogIlJlc29sdmUgYWxsIGNvbmZsaWN0cyBtYW51YWxseSwgbWFyayB0aGVtIGFzIHJlc29sdmVkIHdpdGhcbiIKICJcImdpdCBhZGQvcm0gPGNvbmZsaWN0ZWRfZmlsZXM+XCIsIHRoZW4gcnVuIFwiZ2l0IHJlYmFzZSAtLWNvbnRpbnVlXCIuXG4iCkBAIC0xNzMyMyw3ICsxNzQwMyw3IEBACiAixJDhu4MgYsOjaSBi4buPIHbDoCBxdWF5IHRy4bufIGzhuqFpIHRy4bqhbmcgdGjDoWkgdHLGsOG7m2MgXCJnaXQgcmViYXNlXCIsIGNo4bqheSBcImdpdCByZWJhc2UgIgogIi0tYWJvcnRcIi4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTAzMQorIzogYnVpbHRpbi9yZWJhc2UuYzoxMDMyCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJcbiIKQEAgLTE3MzQyLDcgKzE3NDIyLDcgQEAKICJcbiIKICJL4bq/dCBxdeG6oyBsw6AgZ2l0IGtow7RuZyB0aOG7gyBj4bqjaSB04buVIGzhuqFpIGNow7puZy4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTMxOAorIzogYnVpbHRpbi9yZWJhc2UuYzoxMzM5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICIlc1xuIgpAQCAtMTczNTksNyArMTc0MzksNyBAQAogIiAgICBnaXQgcmViYXNlIOKAnDxuaMOhbmg+4oCdXG4iCiAiXG4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTMzNAorIzogYnVpbHRpbi9yZWJhc2UuYzoxMzU1CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJJZiB5b3Ugd2lzaCB0byBzZXQgdHJhY2tpbmcgaW5mb3JtYXRpb24gZm9yIHRoaXMgYnJhbmNoIHlvdSBjYW4gZG8gc28gd2l0aDpcbiIKQEAgLTE3MzczLDEyOCArMTc0NTMsMTMzIEBACiAiICAgIGdpdCBicmFuY2ggLS1zZXQtdXBzdHJlYW0tdG89JXMvPG5ow6FuaD4gJXNcbiIKICJcbiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxMzY0CisjOiBidWlsdGluL3JlYmFzZS5jOjEzODUKIG1zZ2lkICJleGVjIGNvbW1hbmRzIGNhbm5vdCBjb250YWluIG5ld2xpbmVzIgogbXNnc3RyICJjw6FjIGzhu4duaCB0aOG7sWMgdGhpIGtow7RuZyB0aOG7gyBjaOG7qWEgY8OhYyBrw70gdOG7sSBkw7JuZyBt4bubaSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxMzY4CisjOiBidWlsdGluL3JlYmFzZS5jOjEzODkKIG1zZ2lkICJlbXB0eSBleGVjIGNvbW1hbmQiCiBtc2dzdHIgImzhu4duaCB0aOG7sWMgdGhpIHRy4buRbmcgcuG7l25nIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjEzOTYKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQxOAogbXNnaWQgInJlYmFzZSBvbnRvIGdpdmVuIGJyYW5jaCBpbnN0ZWFkIG9mIHVwc3RyZWFtIgogbXNnc3RyICJj4bqjaSB04buVIHbDoG8gbmjDoW5oIMSRw6MgY2hvIHRoYXkgY2hvIHRoxrDhu6NuZyBuZ3Xhu5NuIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjEzOTgKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQyMAorbXNnaWQgInVzZSB0aGUgbWVyZ2UtYmFzZSBvZiB1cHN0cmVhbSBhbmQgYnJhbmNoIGFzIHRoZSBjdXJyZW50IGJhc2UiCittc2dzdHIgIiIKKyJz4butIGThu6VuZyBjw6FjIGPGoSBz4bufIGjDsmEgdHLhu5luIGPhu6dhIHRoxrDhu6NuZyBuZ3Xhu5NuIHbDoCBuaMOhbmggbmjGsCBsw6AgY8ahIHPhu58gaGnhu4duIHThuqFpIgorCisjOiBidWlsdGluL3JlYmFzZS5jOjE0MjIKIG1zZ2lkICJhbGxvdyBwcmUtcmViYXNlIGhvb2sgdG8gcnVuIgogbXNnc3RyICJjaG8gcGjDqXAgbcOzYyAoaG9vaykgcHJlLXJlYmFzZSDEkcaw4bujYyBjaOG6oXkiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQwMAorIzogYnVpbHRpbi9yZWJhc2UuYzoxNDI0CiBtc2dpZCAiYmUgcXVpZXQuIGltcGxpZXMgLS1uby1zdGF0IgogbXNnc3RyICJow6N5IGltIGzhurduZy4gw70gbMOgIC0tbm8tc3RhdCIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDA2CisjOiBidWlsdGluL3JlYmFzZS5jOjE0MzAKIG1zZ2lkICJkbyBub3Qgc2hvdyBkaWZmc3RhdCBvZiB3aGF0IGNoYW5nZWQgdXBzdHJlYW0iCiBtc2dzdHIgIsSR4burbmcgaGnhu4NuIHRo4buLIGRpZmZzdGF0IGPhu6dhIG5o4buvbmcgdGhheSDEkeG7lWkgdGjGsOG7o25nIG5ndeG7k24iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQwOQorIzogYnVpbHRpbi9yZWJhc2UuYzoxNDMzCiBtc2dpZCAiYWRkIGEgU2lnbmVkLW9mZi1ieTogbGluZSB0byBlYWNoIGNvbW1pdCIKIG1zZ3N0ciAidGjDqm0gZMOybmcgU2lnbmVkLW9mZi1ieTogY2hvIHThu6tuZyBs4bqnbiBjaHV54buDbiBnaWFvIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0MTEgYnVpbHRpbi9yZWJhc2UuYzoxNDE1IGJ1aWx0aW4vcmViYXNlLmM6MTQxNworIzogYnVpbHRpbi9yZWJhc2UuYzoxNDM1IGJ1aWx0aW4vcmViYXNlLmM6MTQzOSBidWlsdGluL3JlYmFzZS5jOjE0NDEKIG1zZ2lkICJwYXNzZWQgdG8gJ2dpdCBhbSciCiBtc2dzdHIgImNodXnhu4NuIGNobyDigJxnaXQgYW3igJ0iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQxOSBidWlsdGluL3JlYmFzZS5jOjE0MjEKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ0MyBidWlsdGluL3JlYmFzZS5jOjE0NDUKIG1zZ2lkICJwYXNzZWQgdG8gJ2dpdCBhcHBseSciCiBtc2dzdHIgImNodXnhu4NuIGNobyDigJxnaXQgYXBwbHnigJ0iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQyMyBidWlsdGluL3JlYmFzZS5jOjE0MjYKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ0NyBidWlsdGluL3JlYmFzZS5jOjE0NTAKIG1zZ2lkICJjaGVycnktcGljayBhbGwgY29tbWl0cywgZXZlbiBpZiB1bmNoYW5nZWQiCiBtc2dzdHIgIiIKICJjaGVycnktcGljayB04bqldCBj4bqjIGPDoWMgbOG6p24gY2h1eeG7g24gZ2lhbywgbmdheSBj4bqjIGtoaSBraMO0bmcgY8OzIHRoYXkgxJHhu5VpIGfDrCIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDI4CisjOiBidWlsdGluL3JlYmFzZS5jOjE0NTIKIG1zZ2lkICJjb250aW51ZSIKIG1zZ3N0ciAidGnhur9wIHThu6VjIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0MzEKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ1NQogbXNnaWQgInNraXAgY3VycmVudCBwYXRjaCBhbmQgY29udGludWUiCiBtc2dzdHIgImLhu48gcXVhIG1p4bq/bmcgdsOhIGhp4buHbiBow6BuaCB2w6AgdGnhur9wIHThu6VjIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0MzMKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ1NwogbXNnaWQgImFib3J0IGFuZCBjaGVjayBvdXQgdGhlIG9yaWdpbmFsIGJyYW5jaCIKIG1zZ3N0ciAiYsOjaSBi4buPIHbDoCBs4bqleSByYSBuaMOhbmggbmd1ecOqbiB0aOG7p3kiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQzNgorIzogYnVpbHRpbi9yZWJhc2UuYzoxNDYwCiBtc2dpZCAiYWJvcnQgYnV0IGtlZXAgSEVBRCB3aGVyZSBpdCBpcyIKIG1zZ3N0ciAiYsOjaSBi4buPIG5oxrBuZyB24bqrbiB24bqrbiBnaeG7ryBIRUFEIGNo4buJIMSR4bq/biBuw7MiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQzNworIzogYnVpbHRpbi9yZWJhc2UuYzoxNDYxCiBtc2dpZCAiZWRpdCB0aGUgdG9kbyBsaXN0IGR1cmluZyBhbiBpbnRlcmFjdGl2ZSByZWJhc2UiCiBtc2dzdHIgInPhu61hIGRhbmggc8OhY2ggY+G6p24gbMOgbSB0cm9uZyBxdcOhIHRyw6xuaCDigJxyZWJhc2XigJ0gKGPhuqNpIHThu5UpIHTGsMahbmcgdMOhYyIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDQwCisjOiBidWlsdGluL3JlYmFzZS5jOjE0NjQKIG1zZ2lkICJzaG93IHRoZSBwYXRjaCBmaWxlIGJlaW5nIGFwcGxpZWQgb3IgbWVyZ2VkIgogbXNnc3RyICJoaeG7g24gdGjhu4sgbWnhur9uZyB2w6EgxJHDoyDEkcaw4bujYyDDoXAgZOG7pW5nIGhheSBow7JhIHRy4buZbiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDQzCisjOiBidWlsdGluL3JlYmFzZS5jOjE0NjcKIG1zZ2lkICJ1c2UgbWVyZ2luZyBzdHJhdGVnaWVzIHRvIHJlYmFzZSIKIG1zZ3N0ciAiZMO5bmcgY2hp4bq/biBsxrDhu6NjIGjDsmEgdHLhu5luIMSR4buDIGPhuqNpIHThu5UiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ0NworIzogYnVpbHRpbi9yZWJhc2UuYzoxNDcxCiBtc2dpZCAibGV0IHRoZSB1c2VyIGVkaXQgdGhlIGxpc3Qgb2YgY29tbWl0cyB0byByZWJhc2UiCiBtc2dzdHIgIsSR4buDIG5nxrDhu51pIGTDuW5nIHPhu61hIGRhbmggc8OhY2ggY8OhYyBs4bqnbiBjaHV54buDbiBnaWFvIG114buRbiBj4bqjaSB04buVIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0NTEKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ3NQogbXNnaWQgIihERVBSRUNBVEVEKSB0cnkgdG8gcmVjcmVhdGUgbWVyZ2VzIGluc3RlYWQgb2YgaWdub3JpbmcgdGhlbSIKIG1zZ3N0ciAiKMSQw4MgTOG6oEMgSOG6rFUpIGhheSB0aOG7rSB04bqhbyBs4bqhaSBjw6FjIGjDsmEgdHLhu5luIHRoYXkgdsOsIGLhu48gcXVhIGNow7puZyIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDU1CisjOiBidWlsdGluL3JlYmFzZS5jOjE0NzkKIG1zZ2lkICJwcmVzZXJ2ZSBlbXB0eSBjb21taXRzIGR1cmluZyByZWJhc2UiCiBtc2dzdHIgIm5nxINuIGPhuqVtIGPDoWMgbOG6p24gY2h1eeG7g24gZ2lhbyB0cuG7kW5nIHLhu5duZyB0cm9uZyBzdeG7kXQgcXXDoSB0csOsbmggY+G6o2kgdOG7lSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDU3CisjOiBidWlsdGluL3JlYmFzZS5jOjE0ODEKIG1zZ2lkICJtb3ZlIGNvbW1pdHMgdGhhdCBiZWdpbiB3aXRoIHNxdWFzaCEvZml4dXAhIHVuZGVyIC1pIgogbXNnc3RyICJkaSBjaHV54buDbiBjw6FjIGzhuqduIGNodXnhu4NuIGdpYW8gbcOgIGLhuq90IMSR4bqndSBi4bqxbmcgc3F1YXNoIS9maXh1cCEgZMaw4bubaSAtaSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDYzCisjOiBidWlsdGluL3JlYmFzZS5jOjE0ODcKIG1zZ2lkICJhdXRvbWF0aWNhbGx5IHN0YXNoL3N0YXNoIHBvcCBiZWZvcmUgYW5kIGFmdGVyIgogbXNnc3RyICJ04buxIMSR4buZbmcgc3Rhc2gvc3Rhc2ggcG9wIHRyxrDhu5tjIHbDoCBzYXUiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ2NQorIzogYnVpbHRpbi9yZWJhc2UuYzoxNDg5CiBtc2dpZCAiYWRkIGV4ZWMgbGluZXMgYWZ0ZXIgZWFjaCBjb21taXQgb2YgdGhlIGVkaXRhYmxlIGxpc3QiCiBtc2dzdHIgInRow6ptIGPDoWMgZMOybmcgdGjhu7FjIHRoaSBzYXUgdOG7q25nIGzhuqduIGNodXnhu4NuIGdpYW8gY+G7p2EgZGFuaCBzw6FjaCBz4butYSDEkcaw4bujYyIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDY5CisjOiBidWlsdGluL3JlYmFzZS5jOjE0OTMKIG1zZ2lkICJhbGxvdyByZWJhc2luZyBjb21taXRzIHdpdGggZW1wdHkgbWVzc2FnZXMiCiBtc2dzdHIgImNo4bqlcCBuaOG6rW4gY+G6o2kgdOG7lSBjw6FjIGNodXnhu4NuIGdpYW8gbcOgIGtow7RuZyBnaGkgY2jDuiBnw6wiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ3MgorIzogYnVpbHRpbi9yZWJhc2UuYzoxNDk2CiBtc2dpZCAidHJ5IHRvIHJlYmFzZSBtZXJnZXMgaW5zdGVhZCBvZiBza2lwcGluZyB0aGVtIgogbXNnc3RyICJj4buRIHRo4butIGPhuqNpIHThu5UgY8OhYyBow7JhIHRy4buZbiB0aGF5IHbDrCBi4buPIHF1YSBjaMO6bmciCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ3NQorIzogYnVpbHRpbi9yZWJhc2UuYzoxNDk5CiBtc2dpZCAidXNlICdtZXJnZS1iYXNlIC0tZm9yay1wb2ludCcgdG8gcmVmaW5lIHVwc3RyZWFtIgogbXNnc3RyICJkw7luZyDigJxtZXJnZS1iYXNlIC0tZm9yay1wb2ludOKAnSDEkeG7gyDEkeG7i25oIG5naMSpYSBs4bqhaSB0aMaw4bujbmcgbmd14buTbiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDc3CisjOiBidWlsdGluL3JlYmFzZS5jOjE1MDEKIG1zZ2lkICJ1c2UgdGhlIGdpdmVuIG1lcmdlIHN0cmF0ZWd5IgogbXNnc3RyICJkw7luZyBjaGnhur9uIGzGsOG7o2MgaMOyYSB0cuG7mW4gxJHDoyBjaG8iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ3OSBidWlsdGluL3JldmVydC5jOjExNQorIzogYnVpbHRpbi9yZWJhc2UuYzoxNTAzIGJ1aWx0aW4vcmV2ZXJ0LmM6MTE1CiBtc2dpZCAib3B0aW9uIgogbXNnc3RyICJ0w7l5IGNo4buNbiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDgwCisjOiBidWlsdGluL3JlYmFzZS5jOjE1MDQKIG1zZ2lkICJwYXNzIHRoZSBhcmd1bWVudCB0aHJvdWdoIHRvIHRoZSBtZXJnZSBzdHJhdGVneSIKIG1zZ3N0ciAiY2h1eeG7g24gdGhhbyBz4buRIMSR4bq/biBjaGnhur9uIGzGsOG7o2MgaMOyYSB0cuG7mW4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ4MworIzogYnVpbHRpbi9yZWJhc2UuYzoxNTA3CiBtc2dpZCAicmViYXNlIGFsbCByZWFjaGFibGUgY29tbWl0cyB1cCB0byB0aGUgcm9vdChzKSIKIG1zZ3N0ciAiY+G6o2kgdOG7lSB04bqldCBjw6FjIGPDoWMgbOG6p24gY2h1eeG7g24gZ2lhbyBjaG8gxJHhur9uIHJvb3QiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTUwMAorIzogYnVpbHRpbi9yZWJhc2UuYzoxNTI0CiBtc2dpZCAiIgogInRoZSByZWJhc2UudXNlQnVpbHRpbiBzdXBwb3J0IGhhcyBiZWVuIHJlbW92ZWQhXG4iCiAiU2VlIGl0cyBlbnRyeSBpbiAnZ2l0IGhlbHAgY29uZmlnJyBmb3IgZGV0YWlscy4iCkBAIC0xNzUwMiwzMyArMTc1ODcsNDEgQEAKICJ2aeG7h2MgaOG7lyB0cuG7oyByZWJhc2UudXNlQnVpbHRpbiDEkcOjIGLhu4sgeMOzYSFcbiIKICJYZW0gbeG7pWMgdGluIGPhu6dhIG7DsyB0cm9uZyDigJwgZ2l0IGhlbHAgY29uZmln4oCdIMSR4buDIGJp4bq/dCBjaGkgdGnhur90LiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNTA2CisjOiBidWlsdGluL3JlYmFzZS5jOjE1MzAKIG1zZ2lkICJJdCBsb29rcyBsaWtlICdnaXQgYW0nIGlzIGluIHByb2dyZXNzLiBDYW5ub3QgcmViYXNlLiIKIG1zZ3N0ciAiIgogIkjDrG5oIG5oxrAgxJFhbmcgdHJvbmcgcXXDoSB0csOsbmggdGjhu7FjIGhp4buHbiBs4buHbmgg4oCcZ2l0LWFt4oCdLiBLaMO0bmcgdGjhu4MgcmViYXNlLiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNTQ3CisjOiBidWlsdGluL3JlYmFzZS5jOjE1NzEKIG1zZ2lkICIiCiAiZ2l0IHJlYmFzZSAtLXByZXNlcnZlLW1lcmdlcyBpcyBkZXByZWNhdGVkLiBVc2UgLS1yZWJhc2UtbWVyZ2VzIGluc3RlYWQuIgogbXNnc3RyICIiCiAiZ2l0IHJlYmFzZSAtLXByZXNlcnZlLW1lcmdlcyDEkcOjIGzhuqFjIGjhuq11LiBIw6N5IGTDuW5nIC0tcmViYXNlLW1lcmdlcyDEkeG7gyB0aGF5ICIKICJ0aOG6vy4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTU1MQorIzogYnVpbHRpbi9yZWJhc2UuYzoxNTc2Cittc2dpZCAiY2Fubm90IGNvbWJpbmUgJy0ta2VlcC1iYXNlJyB3aXRoICctLW9udG8nIgorbXNnc3RyICJraMO0bmcgdGjhu4Mga+G6v3QgaOG7o3Ag4oCcLS1rZWVwLWJhc2XigJ0gduG7m2kg4oCcLS1vbnRv4oCdIgorCisjOiBidWlsdGluL3JlYmFzZS5jOjE1NzgKK21zZ2lkICJjYW5ub3QgY29tYmluZSAnLS1rZWVwLWJhc2UnIHdpdGggJy0tcm9vdCciCittc2dzdHIgImtow7RuZyB0aOG7gyBr4bq/dCBo4bujcCDigJwtLWtlZXAtYmFzZeKAnSB24bubaSDigJwtLXJvb3TigJ0iCisKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTU4MgogbXNnaWQgIk5vIHJlYmFzZSBpbiBwcm9ncmVzcz8iCiBtc2dzdHIgIktow7RuZyBjw7MgdGnhur9uIHRyw6xuaCByZWJhc2UgbsOgbyBwaOG6o2kga2jDtG5nPyIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNTU1CisjOiBidWlsdGluL3JlYmFzZS5jOjE1ODYKIG1zZ2lkICJUaGUgLS1lZGl0LXRvZG8gYWN0aW9uIGNhbiBvbmx5IGJlIHVzZWQgZHVyaW5nIGludGVyYWN0aXZlIHJlYmFzZS4iCiBtc2dzdHIgIiIKICJIw6BuaCDEkeG7mW5nIOKAnC0tZWRpdC10b2Rv4oCdIGNo4buJIGPDsyB0aOG7gyBkw7luZyB0cm9uZyBxdcOhIHRyw6xuaCDigJxyZWJhc2XigJ0gKHPhu61hIGzhu4tjaCAiCiAic+G7rSkgdMawxqFuZyB0w6FjLiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNTc4CisjOiBidWlsdGluL3JlYmFzZS5jOjE2MDkKIG1zZ2lkICJDYW5ub3QgcmVhZCBIRUFEIgogbXNnc3RyICJLaMO0bmcgdGjhu4MgxJHhu41jIEhFQUQiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTU5MAorIzogYnVpbHRpbi9yZWJhc2UuYzoxNjIxCiBtc2dpZCAiIgogIllvdSBtdXN0IGVkaXQgYWxsIG1lcmdlIGNvbmZsaWN0cyBhbmQgdGhlblxuIgogIm1hcmsgdGhlbSBhcyByZXNvbHZlZCB1c2luZyBnaXQgYWRkIgpAQCAtMTc1MzYsMTYgKzE3NjI5LDE2IEBACiAiQuG6oW4gcGjhuqNpIHPhu61hIHThuqV0IGPhuqMgY8OhYyBs4bqnbiBow7JhIHRy4buZbiB4dW5nIMSR4buZdCB2w6Agc2F1XG4iCiAixJHDsyDEkcOhbmggZOG6pXUgY2jDum5nIGzDoCBj4bqnbiB44butIGzDvSBz4butIGThu6VuZyBs4buHbmggZ2l0IGFkZCIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNjA5CisjOiBidWlsdGluL3JlYmFzZS5jOjE2NDAKIG1zZ2lkICJjb3VsZCBub3QgZGlzY2FyZCB3b3JrdHJlZSBjaGFuZ2VzIgogbXNnc3RyICJraMO0bmcgdGjhu4MgbG/huqFpIGLhu48gY8OhYyB0aGF5IMSR4buVaSBjw6J5LWzDoG0tdmnhu4djIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE2MjgKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTY1OQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgbW92ZSBiYWNrIHRvICVzIgogbXNnc3RyICJraMO0bmcgdGjhu4MgcXVheSB0cuG7nyBs4bqhaSAlcyIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNjczCisjOiBidWlsdGluL3JlYmFzZS5jOjE3MDQKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkl0IHNlZW1zIHRoYXQgdGhlcmUgaXMgYWxyZWFkeSBhICVzIGRpcmVjdG9yeSwgYW5kXG4iCkBAIC0xNzU2NiwxNjQgKzE3NjU5LDE1NiBAQAogInbDoCBjaOG6oXkgVMOUSSBs4bqnbiBu4buvYS4gVMOUSSBk4burbmcgbOG6oWkgdHJvbmcgdHLGsOG7nW5nIGjhu6NwIGLhuqFuIHbhuqtuXG4iCiAiY8OzIG3hu5l0IHPhu5EgdGjhu6kgcXXDvSBnacOhIOG7nyDEkcOieS5cbiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNjk0CisjOiBidWlsdGluL3JlYmFzZS5jOjE3MjUKIG1zZ2lkICJzd2l0Y2ggYEMnIGV4cGVjdHMgYSBudW1lcmljYWwgdmFsdWUiCiBtc2dzdHIgInTDuXkgY2jhu41uIOKAnCVj4oCdIGPhuqduIG3hu5l0IGdpw6EgdHLhu4sgYuG6sW5nIHPhu5EiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTczNQorIzogYnVpbHRpbi9yZWJhc2UuYzoxNzY2CiAjLCBjLWZvcm1hdAogbXNnaWQgIlVua25vd24gbW9kZTogJXMiCiBtc2dzdHIgIktow7RuZyBoaeG7g3UgY2jhur8gxJHhu5k6ICVzIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE3NTcKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTc4OAogbXNnaWQgIi0tc3RyYXRlZ3kgcmVxdWlyZXMgLS1tZXJnZSBvciAtLWludGVyYWN0aXZlIgogbXNnc3RyICItLXN0cmF0ZWd5IGPhuqduIC0tbWVyZ2UgaGF5IC0taW50ZXJhY3RpdmUiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTc5NworIzogYnVpbHRpbi9yZWJhc2UuYzoxODI4CiBtc2dpZCAiLS1yZXNjaGVkdWxlLWZhaWxlZC1leGVjIHJlcXVpcmVzIC0tZXhlYyBvciAtLWludGVyYWN0aXZlIgogbXNnc3RyICItLXJlc2NoZWR1bGUtZmFpbGVkLWV4ZWMgY+G6p24gLS1leGVjIGhheSAtLWludGVyYWN0aXZlIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE4MDkKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTg0MAogbXNnaWQgImNhbm5vdCBjb21iaW5lIGFtIG9wdGlvbnMgd2l0aCBlaXRoZXIgaW50ZXJhY3RpdmUgb3IgbWVyZ2Ugb3B0aW9ucyIKIG1zZ3N0ciAiIgogImtow7RuZyB0aOG7gyB04buVIGjhu6NwIGPDoWMgdMO5eSBjaOG7jW4gYW0gduG7m2kgY8OhYyB0w7l5IGNo4buNbiB0xrDGoW5nIHTDoWMgaGF5IGjDsmEgdHLhu5luIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE4MjgKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTg1OQogbXNnaWQgImNhbm5vdCBjb21iaW5lICctLXByZXNlcnZlLW1lcmdlcycgd2l0aCAnLS1yZWJhc2UtbWVyZ2VzJyIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIGvhur90IGjhu6NwIOKAnC0tcHJlc2VydmUtbWVyZ2Vz4oCdIHbhu5tpIOKAnC0tcmViYXNlLW1lcmdlc+KAnSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxODMyCisjOiBidWlsdGluL3JlYmFzZS5jOjE4NjMKIG1zZ2lkICIiCiAiZXJyb3I6IGNhbm5vdCBjb21iaW5lICctLXByZXNlcnZlLW1lcmdlcycgd2l0aCAnLS1yZXNjaGVkdWxlLWZhaWxlZC1leGVjJyIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIGvhur90IGjhu6NwIOKAnC0tcHJlc2VydmUtbWVyZ2Vz4oCdIHbhu5tpIOKAnC0tcmVzY2hlZHVsZS1mYWlsZWQtZXhlY+KAnSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxODM4Ci1tc2dpZCAiY2Fubm90IGNvbWJpbmUgJy0tcmViYXNlLW1lcmdlcycgd2l0aCAnLS1zdHJhdGVneS1vcHRpb24nIgotbXNnc3RyICJraMO0bmcgdGjhu4Mga+G6v3QgaOG7o3Ag4oCcLS1yZWJhc2UtbWVyZ2Vz4oCdIHbhu5tpIOKAnC0tc3RyYXRlZ3ktb3B0aW9u4oCdIgotCi0jOiBidWlsdGluL3JlYmFzZS5jOjE4NDEKLW1zZ2lkICJjYW5ub3QgY29tYmluZSAnLS1yZWJhc2UtbWVyZ2VzJyB3aXRoICctLXN0cmF0ZWd5JyIKLW1zZ3N0ciAia2jDtG5nIHRo4buDIGvhur90IGjhu6NwIOKAnC0tcmViYXNlLW1lcmdlc+KAnSB24bubaSDigJwtLXN0cmF0ZWd54oCdIgotCi0jOiBidWlsdGluL3JlYmFzZS5jOjE4NjUKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTg4NwogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIHVwc3RyZWFtICclcyciCiBtc2dzdHIgInRoxrDhu6NuZyBuZ3Xhu5NuIGtow7RuZyBo4bujcCBs4buHIOKAnCVz4oCdIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE4NzEKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTg5MwogbXNnaWQgIkNvdWxkIG5vdCBjcmVhdGUgbmV3IHJvb3QgY29tbWl0IgogbXNnc3RyICJLaMO0bmcgdGjhu4MgdOG6oW8gbOG6p24gY2h1eeG7g24gZ2lhbyBn4buRYyBt4bubaSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxODg5CisjOiBidWlsdGluL3JlYmFzZS5jOjE5MTkKKyMsIGMtZm9ybWF0Cittc2dpZCAiJyVzJzogbmVlZCBleGFjdGx5IG9uZSBtZXJnZSBiYXNlIHdpdGggYnJhbmNoIgorbXNnc3RyICLigJwlc+KAnTogY+G6p24gY2jDrW5oIHjDoWMgbeG7mXQgY8ahIHPhu58gaMOyYSB0cuG7mW4gduG7m2kgbmjDoW5oIgorCisjOiBidWlsdGluL3JlYmFzZS5jOjE5MjIKICMsIGMtZm9ybWF0CiBtc2dpZCAiJyVzJzogbmVlZCBleGFjdGx5IG9uZSBtZXJnZSBiYXNlIgogbXNnc3RyICLigJwlc+KAnTogY+G6p24gY2jDrW5oIHjDoWMgbeG7mXQgY8ahIHPhu58gaMOyYSB0cuG7mW4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTg5NgorIzogYnVpbHRpbi9yZWJhc2UuYzoxOTMwCiAjLCBjLWZvcm1hdAogbXNnaWQgIkRvZXMgbm90IHBvaW50IHRvIGEgdmFsaWQgY29tbWl0ICclcyciCiBtc2dzdHIgIktow7RuZyBjaOG7iSDEkeG6v24gbeG7mXQgbOG6p24gY2h1eeG7g24gZ2lhbyBraMO0bmcgaOG7o3AgbOG7hyDigJwlc+KAnSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxOTIxCisjOiBidWlsdGluL3JlYmFzZS5jOjE5NTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmF0YWw6IG5vIHN1Y2ggYnJhbmNoL2NvbW1pdCAnJXMnIgogbXNnc3RyICJuZ2hpw6ptIHRy4buNbmc6IGtow7RuZyBjw7MgbmjDoW5oL2zhuqduIGNodXnhu4NuIGdpYW8g4oCcJXPigJ0gbmjGsCB0aOG6vyIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxOTI5IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzozOAorIzogYnVpbHRpbi9yZWJhc2UuYzoxOTYzIGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzozOAogIzogYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjE5MzQKICMsIGMtZm9ybWF0CiBtc2dpZCAiTm8gc3VjaCByZWY6ICVzIgogbXNnc3RyICJLaMO0bmcgY8OzIHRoYW0gY2hp4bq/dSBuw6BvIG5oxrAgdGjhur86ICVzIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE5NDAKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTk3NAogbXNnaWQgIkNvdWxkIG5vdCByZXNvbHZlIEhFQUQgdG8gYSByZXZpc2lvbiIKIG1zZ3N0ciAiS2jDtG5nIHRo4buDIHBow6JuIGdp4bqjaSBs4bqnbiBjaHV54buDbiBnaWFvIEhFQUQgxJHhur9uIG3hu5l0IMSRaeG7g20geMOpdCBkdXnhu4d0IgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE5ODEKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MjAxMgogbXNnaWQgIkNhbm5vdCBhdXRvc3Rhc2giCiBtc2dzdHIgIktow7RuZyB0aOG7gyBhdXRvc3Rhc2giCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTk4NAorIzogYnVpbHRpbi9yZWJhc2UuYzoyMDE1CiAjLCBjLWZvcm1hdAogbXNnaWQgIlVuZXhwZWN0ZWQgc3Rhc2ggcmVzcG9uc2U6ICclcyciCiBtc2dzdHIgIkfhurdwIMSRw6FwIOG7qW5nIHN0YXNoIGtow7RuZyBj4bqnbjog4oCcJXPigJ0iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTk5MAorIzogYnVpbHRpbi9yZWJhc2UuYzoyMDIxCiAjLCBjLWZvcm1hdAogbXNnaWQgIkNvdWxkIG5vdCBjcmVhdGUgZGlyZWN0b3J5IGZvciAnJXMnIgogbXNnc3RyICJLaMO0bmcgdGjhu4MgdOG6oW8gdGjGsCBt4bulYyBjaG8g4oCcJXPigJ0iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTk5MworIzogYnVpbHRpbi9yZWJhc2UuYzoyMDI0CiAjLCBjLWZvcm1hdAogbXNnaWQgIkNyZWF0ZWQgYXV0b3N0YXNoOiAlc1xuIgogbXNnc3RyICLEkMOjIHThuqFvIGF1dG9zdGFzaDogJXNcbiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxOTk2CisjOiBidWlsdGluL3JlYmFzZS5jOjIwMjcKIG1zZ2lkICJjb3VsZCBub3QgcmVzZXQgLS1oYXJkIgogbXNnc3RyICJraMO0bmcgdGjhu4MgcmVzZXQgLS1oYXJkIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE5OTcgYnVpbHRpbi9yZXNldC5jOjExNAotIywgYy1mb3JtYXQKLW1zZ2lkICJIRUFEIGlzIG5vdyBhdCAlcyIKLW1zZ3N0ciAiSEVBRCBoaeG7h24gZ2nhu50gdOG6oWkgJXMiCi0KLSM6IGJ1aWx0aW4vcmViYXNlLmM6MjAxMworIzogYnVpbHRpbi9yZWJhc2UuYzoyMDM2CiBtc2dpZCAiUGxlYXNlIGNvbW1pdCBvciBzdGFzaCB0aGVtLiIKIG1zZ3N0ciAiWGluIGjDo3kgY2h1eeG7g24gZ2lhbyBob+G6t2MgdOG6oW0gY+G6pXQgKHN0YXNoKSBjaMO6bmcuIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjIwNDAKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MjA2MwogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcGFyc2UgJyVzJyIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIHBow6JuIHTDrWNoIGPDuiBwaMOhcCDigJwlc+KAnSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoyMDUzCisjOiBidWlsdGluL3JlYmFzZS5jOjIwNzYKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHN3aXRjaCB0byAlcyIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIGNodXnhu4NuIMSR4bq/biAlcyIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoyMDY0CisjOiBidWlsdGluL3JlYmFzZS5jOjIwODcKIG1zZ2lkICJIRUFEIGlzIHVwIHRvIGRhdGUuIgogbXNnc3RyICJIRUFEIMSRw6MgY+G6rXAgbmjhuq10LiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoyMDY2CisjOiBidWlsdGluL3JlYmFzZS5jOjIwODkKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ3VycmVudCBicmFuY2ggJXMgaXMgdXAgdG8gZGF0ZS5cbiIKIG1zZ3N0ciAiTmjDoW5oIGhp4buHbiB04bqhaSAlcyDEkcOjIMSRxrDhu6NjIGPhuq1wIG5o4bqtdCBy4buTaS5cbiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoyMDc0CisjOiBidWlsdGluL3JlYmFzZS5jOjIwOTcKIG1zZ2lkICJIRUFEIGlzIHVwIHRvIGRhdGUsIHJlYmFzZSBmb3JjZWQuIgogbXNnc3RyICJIRUFEIGhp4buHbiDEkcOjIMSRxrDhu6NjIGPhuq1wIG5o4bqtdCBy4buTaSwgYuG7iyDDqXAgYnXhu5ljIHJlYmFzZS4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MjA3NgorIzogYnVpbHRpbi9yZWJhc2UuYzoyMDk5CiAjLCBjLWZvcm1hdAogbXNnaWQgIkN1cnJlbnQgYnJhbmNoICVzIGlzIHVwIHRvIGRhdGUsIHJlYmFzZSBmb3JjZWQuXG4iCiBtc2dzdHIgIk5ow6FuaCBoaeG7h24gdOG6oWkgJXMgxJHDoyDEkcaw4bujYyBj4bqtcCBuaOG6rXQgcuG7k2ksIGzhu4duaCByZWJhc2Ugw6lwIGJ14buZYy5cbiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoyMDg0CisjOiBidWlsdGluL3JlYmFzZS5jOjIxMDcKIG1zZ2lkICJUaGUgcHJlLXJlYmFzZSBob29rIHJlZnVzZWQgdG8gcmViYXNlLiIKIG1zZ3N0ciAiTcOzYyAoaG9vaykgcHJlLXJlYmFzZSB04burIGNo4buRaSByZWJhc2UuIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjIwOTEKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MjExNAogIywgYy1mb3JtYXQKIG1zZ2lkICJDaGFuZ2VzIHRvICVzOlxuIgogbXNnc3RyICJUaGF5IMSR4buVaSB0aMOgbmggJXM6XG4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MjA5NAorIzogYnVpbHRpbi9yZWJhc2UuYzoyMTE3CiAjLCBjLWZvcm1hdAogbXNnaWQgIkNoYW5nZXMgZnJvbSAlcyB0byAlczpcbiIKIG1zZ3N0ciAiVGhheSDEkeG7lWkgdOG7qyAlcyB0aMOgbmggJXM6XG4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MjExOQorIzogYnVpbHRpbi9yZWJhc2UuYzoyMTQyCiAjLCBjLWZvcm1hdAogbXNnaWQgIkZpcnN0LCByZXdpbmRpbmcgaGVhZCB0byByZXBsYXkgeW91ciB3b3JrIG9uIHRvcCBvZiBpdC4uLlxuIgogbXNnc3RyICIiCiAiVHLGsOG7m2MgdGnDqm4sIGRpIGNodXnhu4NuIGhlYWQgxJHhu4MgeGVtIGzhuqFpIGPDoWMgY8O0bmcgdmnhu4djIHRyw6puIMSR4buJbmggY+G7p2EgbsOz4oCmXG4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MjEyOAorIzogYnVpbHRpbi9yZWJhc2UuYzoyMTUxCiBtc2dpZCAiQ291bGQgbm90IGRldGFjaCBIRUFEIgogbXNnc3RyICJLaMO0bmcgdGjhu4MgdMOhY2ggcuG7nWkgSEVBRCIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoyMTM3CisjOiBidWlsdGluL3JlYmFzZS5jOjIxNjAKICMsIGMtZm9ybWF0CiBtc2dpZCAiRmFzdC1mb3J3YXJkZWQgJXMgdG8gJXMuXG4iCiBtc2dzdHIgIkNodXnhu4NuLXRp4bq/cC1uaGFuaCAlcyDEkeG6v24gJXMuXG4iCkBAIC0xNzczMiw3ICsxNzgxNyw3IEBACiBtc2dpZCAiZ2l0IHJlY2VpdmUtcGFjayA8Z2l0LWRpcj4iCiBtc2dzdHIgImdpdCByZWNlaXZlLXBhY2sgPHRoxrAtbeG7pWMtZ2l0PiIKIAotIzogYnVpbHRpbi9yZWNlaXZlLXBhY2suYzo4MzIKKyM6IGJ1aWx0aW4vcmVjZWl2ZS1wYWNrLmM6ODMwCiBtc2dpZCAiIgogIkJ5IGRlZmF1bHQsIHVwZGF0aW5nIHRoZSBjdXJyZW50IGJyYW5jaCBpbiBhIG5vbi1iYXJlIHJlcG9zaXRvcnlcbiIKICJpcyBkZW5pZWQsIGJlY2F1c2UgaXQgd2lsbCBtYWtlIHRoZSBpbmRleCBhbmQgd29yayB0cmVlIGluY29uc2lzdGVudFxuIgpAQCAtMTc3NjIsNyArMTc4NDcsNyBAQAogIsSQ4buDIGNo4bqlbSBk4bupdCBs4budaSBuaOG6r24gbsOgeSB2w6AgduG6q24gZ2nhu68gY8OhY2gg4bupbmcgeOG7rSBt4bq3YyDEkeG7i25oLCBow6N5IMSR4bq3dFxuIgogImJp4bq/biBj4bqldSBow6xuaCDigJxyZWNlaXZlLmRlbnlDdXJyZW50QnJhbmNo4oCdIHRow6BuaCDigJxyZWZ1c2XigJ0uIgogCi0jOiBidWlsdGluL3JlY2VpdmUtcGFjay5jOjg1MgorIzogYnVpbHRpbi9yZWNlaXZlLXBhY2suYzo4NTAKIG1zZ2lkICIiCiAiQnkgZGVmYXVsdCwgZGVsZXRpbmcgdGhlIGN1cnJlbnQgYnJhbmNoIGlzIGRlbmllZCwgYmVjYXVzZSB0aGUgbmV4dFxuIgogIidnaXQgY2xvbmUnIHdvbid0IHJlc3VsdCBpbiBhbnkgZmlsZSBjaGVja2VkIG91dCwgY2F1c2luZyBjb25mdXNpb24uXG4iCkBAIC0xNzc4MywxMSArMTc4NjgsMTEgQEAKICJcbiIKICLEkOG7gyBjaOG6pW0gZOG7qXQgbOG7nWkgbmjhuq9uIG7DoHksIGLhuqFuIGjDo3kgxJHhurd0IG7DsyB0aMOgbmgg4oCccmVmdXNl4oCdLiIKIAotIzogYnVpbHRpbi9yZWNlaXZlLXBhY2suYzoxOTM4CisjOiBidWlsdGluL3JlY2VpdmUtcGFjay5jOjE5MzYKIG1zZ2lkICJxdWlldCIKIG1zZ3N0ciAiaW0gbOG6t25nIgogCi0jOiBidWlsdGluL3JlY2VpdmUtcGFjay5jOjE5NTIKKyM6IGJ1aWx0aW4vcmVjZWl2ZS1wYWNrLmM6MTk1MAogbXNnaWQgIllvdSBtdXN0IHNwZWNpZnkgYSBkaXJlY3RvcnkuIgogbXNnc3RyICJC4bqhbiBwaOG6o2kgY2jhu4kgxJHhu4tuaCB0aMawIG3hu6VjLiIKIApAQCAtMTgzNTMsMTEgKzE4NDM4LDExIEBACiBtc2dpZCAiVW5rbm93biBzdWJjb21tYW5kOiAlcyIKIG1zZ3N0ciAiS2jDtG5nIGhp4buDdSBjw6J1IGzhu4duaCBjb246ICVzIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjIyCisjOiBidWlsdGluL3JlcGFjay5jOjIzCiBtc2dpZCAiZ2l0IHJlcGFjayBbPG9wdGlvbnM+XSIKIG1zZ3N0ciAiZ2l0IHJlcGFjayBbPGPDoWMgdMO5eSBjaOG7jW4+XSIKIAotIzogYnVpbHRpbi9yZXBhY2suYzoyNworIzogYnVpbHRpbi9yZXBhY2suYzoyOAogbXNnaWQgIiIKICJJbmNyZW1lbnRhbCByZXBhY2tzIGFyZSBpbmNvbXBhdGlibGUgd2l0aCBiaXRtYXAgaW5kZXhlcy4gIFVzZVxuIgogIi0tbm8td3JpdGUtYml0bWFwLWluZGV4IG9yIGRpc2FibGUgdGhlIHBhY2sud3JpdGViaXRtYXBzIGNvbmZpZ3VyYXRpb24uIgpAQCAtMTgzNjUsMTE1ICsxODQ1MCwxMTUgQEAKICJHaWEgdMSDbmcgcmVwYWNrIGzDoCBraMO0bmcgdMawxqFuZyB0aMOtY2ggduG7m2kgY2jhu4kgbeG7pWMgYml0bWFwLiBEw7luZ1xuIgogIi0tbm8td3JpdGUtYml0bWFwLWluZGV4IGhheSB04bqvdCBj4bqldSBow6xuaCBwYWNrLndyaXRlYml0bWFwcy4iCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MTkwCisjOiBidWlsdGluL3JlcGFjay5jOjE5MQogbXNnaWQgImNvdWxkIG5vdCBzdGFydCBwYWNrLW9iamVjdHMgdG8gcmVwYWNrIHByb21pc29yIG9iamVjdHMiCiBtc2dzdHIgIiIKICJraMO0bmcgdGjhu4MgbOG6pXkgdGjDtG5nIHRpbiB0aOG7kW5nIGvDqiBwYWNrLW9iamVjdHMgxJHhu4MgbcOgIMSRw7NuZyBnw7NpIGzhuqFpIGPDoWMgxJHhu5FpICIKICJ0xrDhu6NuZyBo4bupYSBo4bq5biIKIAotIzogYnVpbHRpbi9yZXBhY2suYzoyMjkgYnVpbHRpbi9yZXBhY2suYzo0MDgKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6MjMwIGJ1aWx0aW4vcmVwYWNrLmM6NDA5CiBtc2dpZCAicmVwYWNrOiBFeHBlY3RpbmcgZnVsbCBoZXggb2JqZWN0IElEIGxpbmVzIG9ubHkgZnJvbSBwYWNrLW9iamVjdHMuIgogbXNnc3RyICIiCiAicmVwYWNrOiDEkGFuZyBjaOG7iSBj4bqnbiBjw6FjIGTDsm5nIElEIMSR4buRaSB0xrDhu6NuZyBk4bqhbmcgdGjhuq1wIGzhu6VjIHBow6JuIMSR4bqneSBk4bunIHThu6sgcGFjay0iCiAib2JqZWN0cy4iCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MjQ2CisjOiBidWlsdGluL3JlcGFjay5jOjI0NwogbXNnaWQgImNvdWxkIG5vdCBmaW5pc2ggcGFjay1vYmplY3RzIHRvIHJlcGFjayBwcm9taXNvciBvYmplY3RzIgogbXNnc3RyICJraMO0bmcgdGjhu4MgaG/DoG4gdOG6pXQgcGFjay1vYmplY3RzIMSR4buDIMSRw7NuZyBnw7NpIGPDoWMgxJHhu5FpIHTGsOG7o25nIGjhu6lhIGjhurluIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjI4NAorIzogYnVpbHRpbi9yZXBhY2suYzoyODUKIG1zZ2lkICJwYWNrIGV2ZXJ5dGhpbmcgaW4gYSBzaW5nbGUgcGFjayIKIG1zZ3N0ciAixJHDs25nIGfDs2kgbeG7jWkgdGjhu6kgdHJvbmcgbeG7mXQgZ8OzaSDEkcahbiIKIAotIzogYnVpbHRpbi9yZXBhY2suYzoyODYKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6Mjg3CiBtc2dpZCAic2FtZSBhcyAtYSwgYW5kIHR1cm4gdW5yZWFjaGFibGUgb2JqZWN0cyBsb29zZSIKIG1zZ3N0ciAiZ2nhu5FuZyB24bubaSAtYSwgdsOgIGNo4buJbmggc+G7rWEgY8OhYyDEkeG7kWkgdMaw4bujbmcga2jDtG5nIMSR4buNYyDEkcaw4bujYyB0aGnhur91IHPDs3QiCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6Mjg5CisjOiBidWlsdGluL3JlcGFjay5jOjI5MAogbXNnaWQgInJlbW92ZSByZWR1bmRhbnQgcGFja3MsIGFuZCBydW4gZ2l0LXBydW5lLXBhY2tlZCIKIG1zZ3N0ciAieMOzYSBi4buPIGPDoWMgZ8OzaSBkxrAgdGjhu6thLCB2w6AgY2jhuqF5IGdpdC1wcnVuZS1wYWNrZWQiCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MjkxCisjOiBidWlsdGluL3JlcGFjay5jOjI5MgogbXNnaWQgInBhc3MgLS1uby1yZXVzZS1kZWx0YSB0byBnaXQtcGFjay1vYmplY3RzIgogbXNnc3RyICJjaHV54buDbiAtLW5vLXJldXNlLWRlbHRhIGNobyBnaXQtcGFjay1vYmplY3RzIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjI5MworIzogYnVpbHRpbi9yZXBhY2suYzoyOTQKIG1zZ2lkICJwYXNzIC0tbm8tcmV1c2Utb2JqZWN0IHRvIGdpdC1wYWNrLW9iamVjdHMiCiBtc2dzdHIgImNodXnhu4NuIC0tbm8tcmV1c2Utb2JqZWN0IGNobyBnaXQtcGFjay1vYmplY3RzIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjI5NQorIzogYnVpbHRpbi9yZXBhY2suYzoyOTYKIG1zZ2lkICJkbyBub3QgcnVuIGdpdC11cGRhdGUtc2VydmVyLWluZm8iCiBtc2dzdHIgImtow7RuZyBjaOG6oXkgZ2l0LXVwZGF0ZS1zZXJ2ZXItaW5mbyIKIAotIzogYnVpbHRpbi9yZXBhY2suYzoyOTgKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6Mjk5CiBtc2dpZCAicGFzcyAtLWxvY2FsIHRvIGdpdC1wYWNrLW9iamVjdHMiCiBtc2dzdHIgImNodXnhu4NuIC0tbG9jYWwgY2hvIGdpdC1wYWNrLW9iamVjdHMiCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MzAwCisjOiBidWlsdGluL3JlcGFjay5jOjMwMQogbXNnaWQgIndyaXRlIGJpdG1hcCBpbmRleCIKIG1zZ3N0ciAiZ2hpIG3hu6VjIGzhu6VjIMOhbmggeOG6oSIKIAotIzogYnVpbHRpbi9yZXBhY2suYzozMDIKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6MzAzCiBtc2dpZCAicGFzcyAtLWRlbHRhLWlzbGFuZHMgdG8gZ2l0LXBhY2stb2JqZWN0cyIKIG1zZ3N0ciAiY2h1eeG7g24gLS1kZWx0YS1pc2xhbmRzIGNobyBnaXQtcGFjay1vYmplY3RzIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjMwMworIzogYnVpbHRpbi9yZXBhY2suYzozMDQKIG1zZ2lkICJhcHByb3hpZGF0ZSIKIG1zZ3N0ciAibmfDoHkgxrDhu5tjIHTDrW5oIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjMwNAorIzogYnVpbHRpbi9yZXBhY2suYzozMDUKIG1zZ2lkICJ3aXRoIC1BLCBkbyBub3QgbG9vc2VuIG9iamVjdHMgb2xkZXIgdGhhbiB0aGlzIgogbXNnc3RyICJ24bubaSAtQSwgY8OhYyDEkeG7kWkgdMaw4bujbmcgY8WpIGjGoW4ga2hv4bqjbmcgdGjhu51pIGdpYW4gbsOgeSB0aMOsIGtow7RuZyBi4buLIG3huqV0IgogCi0jOiBidWlsdGluL3JlcGFjay5jOjMwNgorIzogYnVpbHRpbi9yZXBhY2suYzozMDcKIG1zZ2lkICJ3aXRoIC1hLCByZXBhY2sgdW5yZWFjaGFibGUgb2JqZWN0cyIKIG1zZ3N0ciAiduG7m2kgLWEsIMSRw7NuZyBnw7NpIGzhuqFpIGPDoWMgxJHhu5FpIHTGsOG7o25nIGtow7RuZyB0aOG7gyDEkeG7jWMgxJHGsOG7o2MiCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MzA4CisjOiBidWlsdGluL3JlcGFjay5jOjMwOQogbXNnaWQgInNpemUgb2YgdGhlIHdpbmRvdyB1c2VkIGZvciBkZWx0YSBjb21wcmVzc2lvbiIKIG1zZ3N0ciAia8OtY2ggdGjGsOG7m2MgY+G7rWEgc+G7lSDEkcaw4bujYyBkw7luZyBjaG8gbsOpbiDigJxkZWx0YeKAnSIKIAotIzogYnVpbHRpbi9yZXBhY2suYzozMDkgYnVpbHRpbi9yZXBhY2suYzozMTUKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6MzEwIGJ1aWx0aW4vcmVwYWNrLmM6MzE2CiBtc2dpZCAiYnl0ZXMiCiBtc2dzdHIgImJ5dGUiCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MzEwCisjOiBidWlsdGluL3JlcGFjay5jOjMxMQogbXNnaWQgInNhbWUgYXMgdGhlIGFib3ZlLCBidXQgbGltaXQgbWVtb3J5IHNpemUgaW5zdGVhZCBvZiBlbnRyaWVzIGNvdW50IgogbXNnc3RyICJnaeG7kW5nIG5oxrAgdHLDqm4sIG5oxrBuZyBnaeG7m2kgaOG6oW4ga8OtY2ggdGjGsOG7m2MgYuG7mSBuaOG7myBoYXkgdsOsIHPhu5EgbMaw4bujbmciCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MzEyCisjOiBidWlsdGluL3JlcGFjay5jOjMxMwogbXNnaWQgImxpbWl0cyB0aGUgbWF4aW11bSBkZWx0YSBkZXB0aCIKIG1zZ3N0ciAiZ2nhu5tpIGjhuqFuIMSR4buZIHPDonUgdOG7kWkgxJFhIGPhu6dhIOKAnGRlbHRh4oCdIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjMxNAorIzogYnVpbHRpbi9yZXBhY2suYzozMTUKIG1zZ2lkICJsaW1pdHMgdGhlIG1heGltdW0gbnVtYmVyIG9mIHRocmVhZHMiCiBtc2dzdHIgImdp4bubaSBo4bqhbiBz4buRIGzGsOG7o25nIHThu5FpIMSRYSB0dXnhur9uIHRyw6xuaCIKIAotIzogYnVpbHRpbi9yZXBhY2suYzozMTYKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6MzE3CiBtc2dpZCAibWF4aW11bSBzaXplIG9mIGVhY2ggcGFja2ZpbGUiCiBtc2dzdHIgImvDrWNoIHRoxrDhu5tjIHThu5FpIMSRYSBjaG8gdOG7q25nIHThuq1wIHRpbiBnw7NpIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjMxOAorIzogYnVpbHRpbi9yZXBhY2suYzozMTkKIG1zZ2lkICJyZXBhY2sgb2JqZWN0cyBpbiBwYWNrcyBtYXJrZWQgd2l0aCAua2VlcCIKIG1zZ3N0ciAixJHDs25nIGfDs2kgbOG6oWkgY8OhYyDEkeG7kWkgdMaw4bujbmcgdHJvbmcgY8OhYyBnw7NpIMSRw6MgxJHDoW5oIGThuqV1IGLhurFuZyAua2VlcCIKIAotIzogYnVpbHRpbi9yZXBhY2suYzozMjAKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6MzIxCiBtc2dpZCAiZG8gbm90IHJlcGFjayB0aGlzIHBhY2siCiBtc2dzdHIgIsSR4burbmcgxJHDs25nIGfDs2kgbOG6oWkgZ8OzaSBuw6B5IgogCi0jOiBidWlsdGluL3JlcGFjay5jOjMzMAorIzogYnVpbHRpbi9yZXBhY2suYzozMzEKIG1zZ2lkICJjYW5ub3QgZGVsZXRlIHBhY2tzIGluIGEgcHJlY2lvdXMtb2JqZWN0cyByZXBvIgogbXNnc3RyICJraMO0bmcgdGjhu4MgeMOzYSBjw6FjIGfDs2kgdHJvbmcgbeG7mXQga2hvIMSR4buRaV90xrDhu6NuZ192xKlfxJHhuqFpIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjMzNAorIzogYnVpbHRpbi9yZXBhY2suYzozMzUKIG1zZ2lkICItLWtlZXAtdW5yZWFjaGFibGUgYW5kIC1BIGFyZSBpbmNvbXBhdGlibGUiCiBtc2dzdHIgIi0ta2VlcC11bnJlYWNoYWJsZSB2w6AgLUEgeHVuZyBraOG6r2MgbmhhdSIKIAotIzogYnVpbHRpbi9yZXBhY2suYzo0MTcKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6NDE4CiBtc2dpZCAiTm90aGluZyBuZXcgdG8gcGFjay4iCiBtc2dzdHIgIktow7RuZyBjw7MgZ8OsIG3hu5tpIMSR4buDIG3DoCDEkcOzbmcgZ8OzaS4iCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6NDc4CisjOiBidWlsdGluL3JlcGFjay5jOjQ3OQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiV0FSTklORzogU29tZSBwYWNrcyBpbiB1c2UgaGF2ZSBiZWVuIHJlbmFtZWQgYnlcbiIKQEAgLTE4NDkyLDcgKzE4NTc3LDcgQEAKICJD4bqiTkggQsOBTzogbmd1ecOqbiBn4buRYyBj4bunYSBuw7MgY8WpbmcgZ+G6t3AgbOG7l2kuXG4iCiAiQ+G6ok5IIELDgU86IFZ1aSBsw7JuZyDEkeG7lWkgdMOqbiBjaMO6bmcgdHJvbmcgJXMgYuG6sW5nIHRheTpcbiIKIAotIzogYnVpbHRpbi9yZXBhY2suYzo1MjYKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6NTI3CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byByZW1vdmUgJyVzJyIKIG1zZ3N0ciAiZ+G6t3AgbOG7l2kga2hpIGfhu6EgYuG7jyDigJwlc+KAnSIKQEAgLTE4NjAwLDggKzE4Njg1LDggQEAKIG1zZ2lkICJ1bmFibGUgdG8gd3JpdGUgb2JqZWN0IHRvIGRhdGFiYXNlIgogbXNnc3RyICJraMO0bmcgdGjhu4MgZ2hpIMSR4buRaSB0xrDhu6NuZyB2w6BvIGPGoSBz4bufIGThu68gbGnhu4d1IgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzozMjIgYnVpbHRpbi9yZXBsYWNlLmM6Mzc3IGJ1aWx0aW4vcmVwbGFjZS5jOjQyMgotIzogYnVpbHRpbi9yZXBsYWNlLmM6NDUyCisjOiBidWlsdGluL3JlcGxhY2UuYzozMjIgYnVpbHRpbi9yZXBsYWNlLmM6Mzc4IGJ1aWx0aW4vcmVwbGFjZS5jOjQyMworIzogYnVpbHRpbi9yZXBsYWNlLmM6NDUzCiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vdCBhIHZhbGlkIG9iamVjdCBuYW1lOiAnJXMnIgogbXNnc3RyICJraMO0bmcgcGjhuqNpIGzDoCB0w6puIMSR4buRaSB0xrDhu6NuZyBo4bujcCBs4buHOiDigJwlc+KAnSIKQEAgLTE4NjIwLDIyICsxODcwNSwyMiBAQAogbXNnaWQgIm5ldyBvYmplY3QgaXMgdGhlIHNhbWUgYXMgdGhlIG9sZCBvbmU6ICclcyciCiBtc2dzdHIgIsSR4buRaSB0xrDhu6NuZyBt4bubaSBsw6AgZ2nhu5FuZyB24bubaSBjw6FpIGPFqTog4oCcJXPigJ0iCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjM4MworIzogYnVpbHRpbi9yZXBsYWNlLmM6Mzg0CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBwYXJzZSAlcyBhcyBhIGNvbW1pdCIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIHBow6JuIHTDrWNoICVzIG5oxrAgbMOgIG3hu5l0IGzhuqduIGNodXnhu4NuIGdpYW8iCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjQxNAorIzogYnVpbHRpbi9yZXBsYWNlLmM6NDE1CiAjLCBjLWZvcm1hdAogbXNnaWQgImJhZCBtZXJnZXRhZyBpbiBjb21taXQgJyVzJyIKIG1zZ3N0ciAidGjhursgaMOyYSB0cuG7mW4gc2FpIHRyb25nIGzhuqduIGNodXnhu4NuIGdpYW8g4oCcJXPigJ0iCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjQxNgorIzogYnVpbHRpbi9yZXBsYWNlLmM6NDE3CiAjLCBjLWZvcm1hdAogbXNnaWQgIm1hbGZvcm1lZCBtZXJnZXRhZyBpbiBjb21taXQgJyVzJyIKIG1zZ3N0ciAidGjhursgaMOyYSB0cuG7mW4ga2jDtG5nIMSRw7puZyBk4bqhbmcg4bufIGzhuqduIGNodXnhu4NuIGdpYW8g4oCcJXPigJ0iCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjQyOAorIzogYnVpbHRpbi9yZXBsYWNlLmM6NDI5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJvcmlnaW5hbCBjb21taXQgJyVzJyBjb250YWlucyBtZXJnZXRhZyAnJXMnIHRoYXQgaXMgZGlzY2FyZGVkOyB1c2UgLS1lZGl0ICIKQEAgLTE4NjQ0LDMxICsxODcyOSwzMSBAQAogImzhuqduIGNodXnhu4NuIGdpYW8gZ+G7kWMg4oCcJXPigJ0gY8OzIGNo4bupYSB0aOG6uyBow7JhIHRy4buZbiDigJwlc+KAnSBjw6FpIG3DoCBi4buLIGxv4bqhaSBi4buPOyBkw7luZyAiCiAidMO5eSBjaOG7jW4gLS1lZGl0IHRoYXkgY2hvIC0tZ3JhZnQiCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjQ2NworIzogYnVpbHRpbi9yZXBsYWNlLmM6NDY4CiAjLCBjLWZvcm1hdAogbXNnaWQgInRoZSBvcmlnaW5hbCBjb21taXQgJyVzJyBoYXMgYSBncGcgc2lnbmF0dXJlIgogbXNnc3RyICJs4bqnbiBjaHV54buDbiBnaWFvIGfhu5FjIOKAnCVz4oCdIGPDsyBjaOG7ryBrw70gR1BHIgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo0NjgKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjQ2OQogbXNnaWQgInRoZSBzaWduYXR1cmUgd2lsbCBiZSByZW1vdmVkIGluIHRoZSByZXBsYWNlbWVudCBjb21taXQhIgogbXNnc3RyICJjaOG7ryBrw70gc+G6vSDEkcaw4bujYyBi4buPIMSRaSB0cm9uZyBs4bqnbiBjaHV54buDbiBnaWFvIHRoYXkgdGjhur8hIgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo0NzgKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjQ3OQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3Qgd3JpdGUgcmVwbGFjZW1lbnQgY29tbWl0IGZvcjogJyVzJyIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIGdoaSBs4bqnbiBjaHV54buDbiBnaWFvIHRoYXkgdGjhur8gY2hvOiDigJwlc+KAnSIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NDg2CisjOiBidWlsdGluL3JlcGxhY2UuYzo0ODcKICMsIGMtZm9ybWF0CiBtc2dpZCAiZ3JhZnQgZm9yICclcycgdW5uZWNlc3NhcnkiCiBtc2dzdHIgImdyYWZ0IGNobyDigJwlc+KAnSBraMO0bmcgY+G6p24gdGhp4bq/dCIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NDkwCisjOiBidWlsdGluL3JlcGxhY2UuYzo0OTEKICMsIGMtZm9ybWF0CiBtc2dpZCAibmV3IGNvbW1pdCBpcyB0aGUgc2FtZSBhcyB0aGUgb2xkIG9uZTogJyVzJyIKIG1zZ3N0ciAibOG6p24gY2h1eeG7g24gZ2lhbyBt4bubaSBsw6AgZ2nhu5FuZyB24bubaSBjw6FpIGPFqTog4oCcJXPigJ0iCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjUyNQorIzogYnVpbHRpbi9yZXBsYWNlLmM6NTI2CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJjb3VsZCBub3QgY29udmVydCB0aGUgZm9sbG93aW5nIGdyYWZ0KHMpOlxuIgpAQCAtMTg2NzcsNzEgKzE4NzYyLDcxIEBACiAia2jDtG5nIHRo4buDIGNodXnhu4NuIMSR4buVaSBjw6FjIGdyYWZ0IHNhdSDEkcOieTpcbiIKICIlcyIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NTQ2CisjOiBidWlsdGluL3JlcGxhY2UuYzo1NDcKIG1zZ2lkICJsaXN0IHJlcGxhY2UgcmVmcyIKIG1zZ3N0ciAibGnhu4d0IGvDqiBjw6FjIHJlZnMgdGhheSB0aOG6vyIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NTQ3CisjOiBidWlsdGluL3JlcGxhY2UuYzo1NDgKIG1zZ2lkICJkZWxldGUgcmVwbGFjZSByZWZzIgogbXNnc3RyICJ4w7NhIHRoYW0gY2hp4bq/dSB0aGF5IHRo4bq/IgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo1NDgKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU0OQogbXNnaWQgImVkaXQgZXhpc3Rpbmcgb2JqZWN0IgogbXNnc3RyICJz4butYSDEkeG7kWkgdMaw4bujbmcgc+G6tW4gY8OzIgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo1NDkKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU1MAogbXNnaWQgImNoYW5nZSBhIGNvbW1pdCdzIHBhcmVudHMiCiBtc2dzdHIgInRoYXkgxJHhu5VpIGNoYSBt4bq5IGPhu6dhIGzhuqduIGNodXnhu4NuIGdpYW8iCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU1MAorIzogYnVpbHRpbi9yZXBsYWNlLmM6NTUxCiBtc2dpZCAiY29udmVydCBleGlzdGluZyBncmFmdCBmaWxlIgogbXNnc3RyICJjaHV54buDbiDEkeG7lWkgY8OhYyB04bqtcCB0aW4gZ3JhZnQgc+G6tW4gY8OzIgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo1NTEKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU1MgogbXNnaWQgInJlcGxhY2UgdGhlIHJlZiBpZiBpdCBleGlzdHMiCiBtc2dzdHIgInRoYXkgdGjhur8gdGhhbSBjaGnhur91IG7hur91IG7DsyDEkcOjIHPhurVuIGPDsyIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NTUzCisjOiBidWlsdGluL3JlcGxhY2UuYzo1NTQKIG1zZ2lkICJkbyBub3QgcHJldHR5LXByaW50IGNvbnRlbnRzIGZvciAtLWVkaXQiCiBtc2dzdHIgIsSR4burbmcgaW4gxJHhurlwIGPDoWMgbuG7mWkgZHVuZyBjaG8gLS1lZGl0IgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo1NTQKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU1NQogbXNnaWQgInVzZSB0aGlzIGZvcm1hdCIKIG1zZ3N0ciAiZMO5bmcgxJHhu4tuaCBk4bqhbmcgbsOgeSIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NTY3CisjOiBidWlsdGluL3JlcGxhY2UuYzo1NjgKIG1zZ2lkICItLWZvcm1hdCBjYW5ub3QgYmUgdXNlZCB3aGVuIG5vdCBsaXN0aW5nIgogbXNnc3RyICItLWZvcm1hdCBraMO0bmcgdGjhu4MgxJHGsOG7o2MgZMO5bmcga2hpIGtow7RuZyBsaeG7h3Qga8OqIGfDrCIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NTc1CisjOiBidWlsdGluL3JlcGxhY2UuYzo1NzYKIG1zZ2lkICItZiBvbmx5IG1ha2VzIHNlbnNlIHdoZW4gd3JpdGluZyBhIHJlcGxhY2VtZW50IgogbXNnc3RyICItZiBjaOG7iSBo4bujcCBsw70ga2hpIGdoaSBt4buZdCBjw6FpIHRoYXkgdGjhur8iCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU3OQorIzogYnVpbHRpbi9yZXBsYWNlLmM6NTgwCiBtc2dpZCAiLS1yYXcgb25seSBtYWtlcyBzZW5zZSB3aXRoIC0tZWRpdCIKIG1zZ3N0ciAiLS1yYXcgY2jhu4kgaOG7o3AgbMO9IHbhu5tpIC0tZWRpdCIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NTg1CisjOiBidWlsdGluL3JlcGxhY2UuYzo1ODYKIG1zZ2lkICItZCBuZWVkcyBhdCBsZWFzdCBvbmUgYXJndW1lbnQiCiBtc2dzdHIgIi1kIGPhuqduIMOtdCBuaOG6pXQgbeG7mXQgdGhhbSBz4buRIgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo1OTEKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU5MgogbXNnaWQgImJhZCBudW1iZXIgb2YgYXJndW1lbnRzIgogbXNnc3RyICJz4buRIMSR4buRaSBz4buRIGtow7RuZyDEkcO6bmciCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU5NworIzogYnVpbHRpbi9yZXBsYWNlLmM6NTk4CiBtc2dpZCAiLWUgbmVlZHMgZXhhY3RseSBvbmUgYXJndW1lbnQiCiBtc2dzdHIgIi1lIGPhuqduIGNow61uaCBjw6FjIGzDoCBt4buZdCDEkeG7kWkgc+G7kSIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NjAzCisjOiBidWlsdGluL3JlcGxhY2UuYzo2MDQKIG1zZ2lkICItZyBuZWVkcyBhdCBsZWFzdCBvbmUgYXJndW1lbnQiCiBtc2dzdHIgIi1xIGPhuqduIMOtdCBuaOG6pXQgbeG7mXQgdGhhbSBz4buRIgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo2MDkKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjYxMAogbXNnaWQgIi0tY29udmVydC1ncmFmdC1maWxlIHRha2VzIG5vIGFyZ3VtZW50IgogbXNnc3RyICItLWNvbnZlcnQtZ3JhZnQtZmlsZSBraMO0bmcgbmjhuq1uIMSR4buRaSBz4buRIgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo2MTUKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjYxNgogbXNnaWQgIm9ubHkgb25lIHBhdHRlcm4gY2FuIGJlIGdpdmVuIHdpdGggLWwiCiBtc2dzdHIgImNo4buJIG3hu5l0IG3huqt1IMSRxrDhu6NjIGNo4buJIHJhIHbhu5tpIHTDuXkgY2jhu41uIC1sIgogCkBAIC0xODgxMCwxMyArMTg4OTUsMTggQEAKIG1zZ2lkICJGYWlsZWQgdG8gZmluZCB0cmVlIG9mICVzLiIKIG1zZ3N0ciAiR+G6t3AgbOG7l2kga2hpIHTDrG0gY8OieSBj4bunYSAlcy4iCiAKKyM6IGJ1aWx0aW4vcmVzZXQuYzoxMTQKKyMsIGMtZm9ybWF0Cittc2dpZCAiSEVBRCBpcyBub3cgYXQgJXMiCittc2dzdHIgIkhFQUQgaGnhu4duIGdp4budIHThuqFpICVzIgorCiAjOiBidWlsdGluL3Jlc2V0LmM6MTkzCiAjLCBjLWZvcm1hdAogbXNnaWQgIkNhbm5vdCBkbyBhICVzIHJlc2V0IGluIHRoZSBtaWRkbGUgb2YgYSBtZXJnZS4iCiBtc2dzdHIgIktow7RuZyB0aOG7gyB0aOG7sWMgaGnhu4duIG3hu5l0ICVzIHJlc2V0IOG7nyBnaeG7r2EgY+G7p2EgcXXDoSB0csOsbmggaMOyYSB0cuG7mW4uIgogCi0jOiBidWlsdGluL3Jlc2V0LmM6MjkzIGJ1aWx0aW4vc3Rhc2guYzo1MTQgYnVpbHRpbi9zdGFzaC5jOjU4OQotIzogYnVpbHRpbi9zdGFzaC5jOjYxMworIzogYnVpbHRpbi9yZXNldC5jOjI5MyBidWlsdGluL3N0YXNoLmM6NTIwIGJ1aWx0aW4vc3Rhc2guYzo1OTUKKyM6IGJ1aWx0aW4vc3Rhc2guYzo2MTkKIG1zZ2lkICJiZSBxdWlldCwgb25seSByZXBvcnQgZXJyb3JzIgogbXNnc3RyICJsw6BtIHZp4buHYyDhu58gY2jhur8gxJHhu5kgaW0gbOG6t25nLCBjaOG7iSBoaeG7g24gdGjhu4sga2hpIGPDsyBs4buXaSIKIApAQCAtMTg5MDEsMjQgKzE4OTkxLDE5IEBACiBtc2dpZCAiQ291bGQgbm90IHdyaXRlIG5ldyBpbmRleCBmaWxlLiIKIG1zZ3N0ciAiS2jDtG5nIHRo4buDIGdoaSB04bqtcCB0aW4gbMawdSBi4bqjbmcgbeG7pWMgbOG7pWMgbeG7m2kuIgogCi0jOiBidWlsdGluL3Jldi1saXN0LmM6NDEyCisjOiBidWlsdGluL3Jldi1saXN0LmM6NDExCiBtc2dpZCAiY2Fubm90IGNvbWJpbmUgLS1leGNsdWRlLXByb21pc29yLW9iamVjdHMgYW5kIC0tbWlzc2luZyIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIHThu5UgaOG7o3AgLS1leGNsdWRlLXByb21pc29yLW9iamVjdHMgdsOgIC0tbWlzc2luZyIKIAotIzogYnVpbHRpbi9yZXYtbGlzdC5jOjQ3MworIzogYnVpbHRpbi9yZXYtbGlzdC5jOjQ3MgogbXNnaWQgIm9iamVjdCBmaWx0ZXJpbmcgcmVxdWlyZXMgLS1vYmplY3RzIgogbXNnc3RyICJs4buNYyDEkeG7kWkgdMaw4bujbmcgecOqdSBj4bqndSAtLW9iamVjdHMiCiAKLSM6IGJ1aWx0aW4vcmV2LWxpc3QuYzo0NzYKLSMsIGMtZm9ybWF0Ci1tc2dpZCAiaW52YWxpZCBzcGFyc2UgdmFsdWUgJyVzJyIKLW1zZ3N0ciAiZ2nDoSB0cuG7iyBzcGFyc2Uga2jDtG5nIGjhu6NwIGzhu4cg4oCcJXPigJ0iCi0KLSM6IGJ1aWx0aW4vcmV2LWxpc3QuYzo1MjcKKyM6IGJ1aWx0aW4vcmV2LWxpc3QuYzo1MjIKIG1zZ2lkICJyZXYtbGlzdCBkb2VzIG5vdCBzdXBwb3J0IGRpc3BsYXkgb2Ygbm90ZXMiCiBtc2dzdHIgInJldi1saXN0IGtow7RuZyBo4buXIHRy4bujIGhp4buDbiB0aOG7iyBjw6FjIGdoaSBjaMO6IgogCi0jOiBidWlsdGluL3Jldi1saXN0LmM6NTMwCisjOiBidWlsdGluL3Jldi1saXN0LmM6NTI1CiBtc2dpZCAiY2Fubm90IGNvbWJpbmUgLS11c2UtYml0bWFwLWluZGV4IHdpdGggb2JqZWN0IGZpbHRlcmluZyIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIHThu5UgaOG7o3AgLS11c2UtYml0bWFwLWluZGV4IHbhu5tpIGzhu41jIMSR4buRaSB0xrDhu6NuZyIKIApAQCAtMTk0NTQsMTM0ICsxOTUzOSwxMzQgQEAKIG1zZ2lkICJjb3VsZCBub3Qgc2F2ZSBpbmRleCB0cmVlIgogbXNnc3RyICJraMO0bmcgdGjhu4MgZ2hpIGzhuqFpIGPDonkgY2jhu4kgbeG7pWMiCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzo0MzQKKyM6IGJ1aWx0aW4vc3Rhc2guYzo0MzYKIG1zZ2lkICJjb3VsZCBub3QgcmVzdG9yZSB1bnRyYWNrZWQgZmlsZXMgZnJvbSBzdGFzaCIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIHBo4bulYyBo4buTaSBjw6FjIHThuq1wIHRpbiBjaMawYSB0aGVvIGTDtWkgdOG7qyBt4bulYyBj4bqldCDEkWkgKHN0YXNoKSIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjQ0OAorIzogYnVpbHRpbi9zdGFzaC5jOjQ1MAogIywgYy1mb3JtYXQKIG1zZ2lkICJNZXJnaW5nICVzIHdpdGggJXMiCiBtc2dzdHIgIsSQYW5nIGjDsmEgdHLhu5luICVzIHbhu5tpICVzIgogCi0jOiBidWlsdGluL3N0YXNoLmM6NDU4IGdpdC1sZWdhY3ktc3Rhc2guc2g6NjgwCisjOiBidWlsdGluL3N0YXNoLmM6NDYwIGdpdC1sZWdhY3ktc3Rhc2guc2g6NjgwCiBtc2dpZCAiSW5kZXggd2FzIG5vdCB1bnN0YXNoZWQuIgogbXNnc3RyICJC4bqjbmcgbeG7pWMgbOG7pWMgxJHDoyBraMO0bmcgxJHGsOG7o2MgYuG7jyBzdGFzaC4iCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzo1MTYgYnVpbHRpbi9zdGFzaC5jOjYxNQorIzogYnVpbHRpbi9zdGFzaC5jOjUyMiBidWlsdGluL3N0YXNoLmM6NjIxCiBtc2dpZCAiYXR0ZW1wdCB0byByZWNyZWF0ZSB0aGUgaW5kZXgiCiBtc2dzdHIgImfhurdwIGzhu5dpIMSR4buNYyBi4bqjbmcgbeG7pWMgbOG7pWMiCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzo1NDkKKyM6IGJ1aWx0aW4vc3Rhc2guYzo1NTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiRHJvcHBlZCAlcyAoJXMpIgogbXNnc3RyICLEkMOjIHjDs2EgJXMgKCVzKSIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjU1MgorIzogYnVpbHRpbi9zdGFzaC5jOjU1OAogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogQ291bGQgbm90IGRyb3Agc3Rhc2ggZW50cnkiCiBtc2dzdHIgIiVzOiBLaMO0bmcgdGjhu4MgeMOzYSBi4buPIG3hu6VjIHN0YXNoIgogCi0jOiBidWlsdGluL3N0YXNoLmM6NTc3CisjOiBidWlsdGluL3N0YXNoLmM6NTgzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiclcycgaXMgbm90IGEgc3Rhc2ggcmVmZXJlbmNlIgogbXNnc3RyICLigJ0lc+KAnSBraMO0bmcgcGjhuqNpIHRoYW0gY2hp4bq/dSDEkeG6v24gc3Rhc2giCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzo2MjcgZ2l0LWxlZ2FjeS1zdGFzaC5zaDo2OTQKKyM6IGJ1aWx0aW4vc3Rhc2guYzo2MzMgZ2l0LWxlZ2FjeS1zdGFzaC5zaDo2OTQKIG1zZ2lkICJUaGUgc3Rhc2ggZW50cnkgaXMga2VwdCBpbiBjYXNlIHlvdSBuZWVkIGl0IGFnYWluLiIKIG1zZ3N0ciAiQ8OhYyBt4bulYyB04bqhbSBj4bqldCAoc3Rhc2gpIMSRxrDhu6NjIGdp4buvIHRyb25nIHRyxrDhu51uZyBo4bujcCBi4bqhbiBs4bqhaSBj4bqnbiBuw7MuIgogCi0jOiBidWlsdGluL3N0YXNoLmM6NjUwIGdpdC1sZWdhY3ktc3Rhc2guc2g6NzEyCisjOiBidWlsdGluL3N0YXNoLmM6NjU2IGdpdC1sZWdhY3ktc3Rhc2guc2g6NzEyCiBtc2dpZCAiTm8gYnJhbmNoIG5hbWUgc3BlY2lmaWVkIgogbXNnc3RyICJDaMawYSBjaOG7iSByYSB0w6puIGPhu6dhIG5ow6FuaCIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjc5MCBidWlsdGluL3N0YXNoLmM6ODI3CisjOiBidWlsdGluL3N0YXNoLmM6Nzk2IGJ1aWx0aW4vc3Rhc2guYzo4MzMKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ2Fubm90IHVwZGF0ZSAlcyB3aXRoICVzIgogbXNnc3RyICJLaMO0bmcgdGjhu4MgY+G6rXAgbmjhuq10ICVzIHbhu5tpICVzIgogCi0jOiBidWlsdGluL3N0YXNoLmM6ODA4IGJ1aWx0aW4vc3Rhc2guYzoxNDYxIGJ1aWx0aW4vc3Rhc2guYzoxNDk3CisjOiBidWlsdGluL3N0YXNoLmM6ODE0IGJ1aWx0aW4vc3Rhc2guYzoxNDcwIGJ1aWx0aW4vc3Rhc2guYzoxNTA2CiBtc2dpZCAic3Rhc2ggbWVzc2FnZSIKIG1zZ3N0ciAicGjhuqduIGNow7ogdGjDrWNoIGNobyBzdGFzaCIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjgxOAorIzogYnVpbHRpbi9zdGFzaC5jOjgyNAogbXNnaWQgIlwiZ2l0IHN0YXNoIHN0b3JlXCIgcmVxdWlyZXMgb25lIDxjb21taXQ+IGFyZ3VtZW50IgogbXNnc3RyICJcImdpdCBzdGFzaCBzdG9yZVwiIGPhuqduIG3hu5l0IMSR4buRaSBz4buRIDxs4bqnbiBjaHV54buDbiBnaWFvPiIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjEwNDAgZ2l0LWxlZ2FjeS1zdGFzaC5zaDoyMTcKKyM6IGJ1aWx0aW4vc3Rhc2guYzoxMDQ2IGdpdC1sZWdhY3ktc3Rhc2guc2g6MjE3CiBtc2dpZCAiTm8gY2hhbmdlcyBzZWxlY3RlZCIKIG1zZ3N0ciAiQ2jGsGEgY8OzIHRoYXkgxJHhu5VpIG7DoG8gxJHGsOG7o2MgY2jhu41uIgogCi0jOiBidWlsdGluL3N0YXNoLmM6MTEzNiBnaXQtbGVnYWN5LXN0YXNoLnNoOjE1MAorIzogYnVpbHRpbi9zdGFzaC5jOjExNDUgZ2l0LWxlZ2FjeS1zdGFzaC5zaDoxNTAKIG1zZ2lkICJZb3UgZG8gbm90IGhhdmUgdGhlIGluaXRpYWwgY29tbWl0IHlldCIKIG1zZ3N0ciAiQuG6oW4gY2jGsGEgY8OybiBjw7MgbOG6p24gY2h1eeG7g24gZ2lhbyBraOG7n2kgdOG6oW8iCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzoxMTYzIGdpdC1sZWdhY3ktc3Rhc2guc2g6MTY1CisjOiBidWlsdGluL3N0YXNoLmM6MTE3MiBnaXQtbGVnYWN5LXN0YXNoLnNoOjE2NQogbXNnaWQgIkNhbm5vdCBzYXZlIHRoZSBjdXJyZW50IGluZGV4IHN0YXRlIgogbXNnc3RyICJLaMO0bmcgdGjhu4MgZ2hpIGzhuqFpIHRy4bqhbmcgdGjDoWkgYuG6o25nIG3hu6VjIGzhu6VjIGhp4buHbiBow6BuaCIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjExNzIgZ2l0LWxlZ2FjeS1zdGFzaC5zaDoxODAKKyM6IGJ1aWx0aW4vc3Rhc2guYzoxMTgxIGdpdC1sZWdhY3ktc3Rhc2guc2g6MTgwCiBtc2dpZCAiQ2Fubm90IHNhdmUgdGhlIHVudHJhY2tlZCBmaWxlcyIKIG1zZ3N0ciAiS2jDtG5nIHRo4buDIGdoaSBs4bqhaSBjw6FjIHThuq1wIHRpbiBjaMawYSB0aGVvIGTDtWkiCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzoxMTgzIGJ1aWx0aW4vc3Rhc2guYzoxMTkyIGdpdC1sZWdhY3ktc3Rhc2guc2g6MjAwCisjOiBidWlsdGluL3N0YXNoLmM6MTE5MiBidWlsdGluL3N0YXNoLmM6MTIwMSBnaXQtbGVnYWN5LXN0YXNoLnNoOjIwMAogIzogZ2l0LWxlZ2FjeS1zdGFzaC5zaDoyMTMKIG1zZ2lkICJDYW5ub3Qgc2F2ZSB0aGUgY3VycmVudCB3b3JrdHJlZSBzdGF0ZSIKIG1zZ3N0ciAiS2jDtG5nIHRo4buDIGdoaSBs4bqhaSB0cuG6oW5nIHRow6FpIGPDonktbMOgbS12aeG7h2MgaGnhu4duIGjDoG5oIgogCi0jOiBidWlsdGluL3N0YXNoLmM6MTIyMCBnaXQtbGVnYWN5LXN0YXNoLnNoOjIzMworIzogYnVpbHRpbi9zdGFzaC5jOjEyMjkgZ2l0LWxlZ2FjeS1zdGFzaC5zaDoyMzMKIG1zZ2lkICJDYW5ub3QgcmVjb3JkIHdvcmtpbmcgdHJlZSBzdGF0ZSIKIG1zZ3N0ciAiS2jDtG5nIHRo4buDIGdoaSBs4bqhaSB0cuG6oW5nIHRow6FpIGPDonkgbMOgbSB2aeG7h2MgaGnhu4duIGjDoG5oIgogCi0jOiBidWlsdGluL3N0YXNoLmM6MTI2OSBnaXQtbGVnYWN5LXN0YXNoLnNoOjMzNworIzogYnVpbHRpbi9zdGFzaC5jOjEyNzggZ2l0LWxlZ2FjeS1zdGFzaC5zaDozMzcKIG1zZ2lkICJDYW4ndCB1c2UgLS1wYXRjaCBhbmQgLS1pbmNsdWRlLXVudHJhY2tlZCBvciAtLWFsbCBhdCB0aGUgc2FtZSB0aW1lIgogbXNnc3RyICJLaMO0bmcgdGjhu4MgZMO5bmcgLS1wYXRjaCB2w6AgLS1pbmNsdWRlLXVudHJhY2tlZCBoYXkgLS1hbGwgY8O5bmcgbeG7mXQgbMO6YyIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjEyODUKKyM6IGJ1aWx0aW4vc3Rhc2guYzoxMjk0CiBtc2dpZCAiRGlkIHlvdSBmb3JnZXQgdG8gJ2dpdCBhZGQnPyIKIG1zZ3N0ciAiQ8OzIGzhur0gYuG6oW4gxJHDoyBxdcOqbiDigJxnaXQgYWRkIOKAnSBwaOG6o2kga2jDtG5nPyIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjEzMDAgZ2l0LWxlZ2FjeS1zdGFzaC5zaDozNDUKKyM6IGJ1aWx0aW4vc3Rhc2guYzoxMzA5IGdpdC1sZWdhY3ktc3Rhc2guc2g6MzQ1CiBtc2dpZCAiTm8gbG9jYWwgY2hhbmdlcyB0byBzYXZlIgogbXNnc3RyICJLaMO0bmcgY8OzIHRoYXkgxJHhu5VpIG7hu5lpIGLhu5kgbsOgbyDEkcaw4bujYyBnaGkgbOG6oWkiCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzoxMzA3IGdpdC1sZWdhY3ktc3Rhc2guc2g6MzUwCisjOiBidWlsdGluL3N0YXNoLmM6MTMxNiBnaXQtbGVnYWN5LXN0YXNoLnNoOjM1MAogbXNnaWQgIkNhbm5vdCBpbml0aWFsaXplIHN0YXNoIgogbXNnc3RyICJLaMO0bmcgdGjhu4Mga2jhu59pIHThuqFvIHN0YXNoIgogCi0jOiBidWlsdGluL3N0YXNoLmM6MTMyMiBnaXQtbGVnYWN5LXN0YXNoLnNoOjM1NAorIzogYnVpbHRpbi9zdGFzaC5jOjEzMzEgZ2l0LWxlZ2FjeS1zdGFzaC5zaDozNTQKIG1zZ2lkICJDYW5ub3Qgc2F2ZSB0aGUgY3VycmVudCBzdGF0dXMiCiBtc2dzdHIgIktow7RuZyB0aOG7gyBnaGkgbOG6oWkgdHLhuqFuZyB0aMOhaSBoaeG7h24gaMOgbmgiCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzoxMzI3CisjOiBidWlsdGluL3N0YXNoLmM6MTMzNgogIywgYy1mb3JtYXQKIG1zZ2lkICJTYXZlZCB3b3JraW5nIGRpcmVjdG9yeSBhbmQgaW5kZXggc3RhdGUgJXMiCiBtc2dzdHIgIsSQw6MgZ2hpIGzhuqFpIHRoxrAgbeG7pWMgbMOgbSB2aeG7h2MgdsOgIHRy4bqhbmcgdGjDoWkgbeG7pWMgbOG7pWMgJXMiCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzoxNDE3IGdpdC1sZWdhY3ktc3Rhc2guc2g6Mzg0CisjOiBidWlsdGluL3N0YXNoLmM6MTQyNiBnaXQtbGVnYWN5LXN0YXNoLnNoOjM4NAogbXNnaWQgIkNhbm5vdCByZW1vdmUgd29ya3RyZWUgY2hhbmdlcyIKIG1zZ3N0ciAiS2jDtG5nIHRo4buDIGfhu6EgYuG7jyBjw6FjIHRoYXkgxJHhu5VpIGPDonktbMOgbS12aeG7h2MiCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzoxNDUyIGJ1aWx0aW4vc3Rhc2guYzoxNDg4CisjOiBidWlsdGluL3N0YXNoLmM6MTQ2MSBidWlsdGluL3N0YXNoLmM6MTQ5NwogbXNnaWQgImtlZXAgaW5kZXgiCiBtc2dzdHIgImdp4buvIG5ndXnDqm4gYuG6o25nIG3hu6VjIGzhu6VjIgogCi0jOiBidWlsdGluL3N0YXNoLmM6MTQ1NCBidWlsdGluL3N0YXNoLmM6MTQ5MAorIzogYnVpbHRpbi9zdGFzaC5jOjE0NjMgYnVpbHRpbi9zdGFzaC5jOjE0OTkKIG1zZ2lkICJzdGFzaCBpbiBwYXRjaCBtb2RlIgogbXNnc3RyICJj4bqldCDEkWkg4bufIGNo4bq/IMSR4buZIG1p4bq/bmcgdsOhIgogCi0jOiBidWlsdGluL3N0YXNoLmM6MTQ1NSBidWlsdGluL3N0YXNoLmM6MTQ5MQorIzogYnVpbHRpbi9zdGFzaC5jOjE0NjQgYnVpbHRpbi9zdGFzaC5jOjE1MDAKIG1zZ2lkICJxdWlldCBtb2RlIgogbXNnc3RyICJjaOG6vyDEkeG7mSBpbSBs4bq3bmciCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzoxNDU3IGJ1aWx0aW4vc3Rhc2guYzoxNDkzCisjOiBidWlsdGluL3N0YXNoLmM6MTQ2NiBidWlsdGluL3N0YXNoLmM6MTUwMgogbXNnaWQgImluY2x1ZGUgdW50cmFja2VkIGZpbGVzIGluIHN0YXNoIgogbXNnc3RyICJiYW8gZ+G7k20gY8OhYyB04bqtcCB0aW4ga2jDtG5nIMSRxrDhu6NjIHRoZW8gZMO1aSB0cm9uZyBzdGFzaCIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjE0NTkgYnVpbHRpbi9zdGFzaC5jOjE0OTUKKyM6IGJ1aWx0aW4vc3Rhc2guYzoxNDY4IGJ1aWx0aW4vc3Rhc2guYzoxNTA0CiBtc2dpZCAiaW5jbHVkZSBpZ25vcmUgZmlsZXMiCiBtc2dzdHIgImJhbyBn4buTbSBjw6FjIHThuq1wIHRpbiBi4buLIGLhu48gcXVhIgogCi0jOiBidWlsdGluL3N0YXNoLmM6MTU1NQorIzogYnVpbHRpbi9zdGFzaC5jOjE1NjQKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGV4ZWMgJXMiCiBtc2dzdHIgImtow7RuZyB0aOG7gyB0aOG7sWMgdGhpICVzIgpAQCAtMTk5NTMsOSArMjAwMzgsOSBAQAogbXNnc3RyICLEkeG7q25nIGluIHRp4bq/biB0csOsbmggbmjDom4gYuG6o24iCiAKICM6IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxODc3Ci1tc2dpZCAiZ2l0IHN1Ym1vZHVsZS0taGVscGVyIHVwZGF0ZV9jbG9uZSBbLS1wcmVmaXg9PHBhdGg+XSBbPHBhdGg+Li4uXSIKK21zZ2lkICJnaXQgc3VibW9kdWxlLS1oZWxwZXIgdXBkYXRlLWNsb25lIFstLXByZWZpeD08cGF0aD5dIFs8cGF0aD4uLi5dIgogbXNnc3RyICIiCi0iZ2l0IHN1Ym1vZHVsZS0taGVscGVyIHVwZGF0ZV9jbG9uZSBbLS1wcmVmaXg9PC/Ekcaw4budbmcvZOG6q24+XSBbPC/Ekcaw4budbmcvZOG6q24+4oCmXSIKKyJnaXQgc3VibW9kdWxlLS1oZWxwZXIgdXBkYXRlLWNsb25lIFstLXByZWZpeD08L8SRxrDhu51uZy9k4bqrbj5dIFs8L8SRxrDhu51uZy9k4bqrbj7igKZdIgogCiAjOiBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6MTg5MAogbXNnaWQgImJhZCB2YWx1ZSBmb3IgdXBkYXRlIHBhcmFtZXRlciIKQEAgLTIwMDA4LDcgKzIwMDkzLDcgQEAKIG1zZ2lkICJwbGVhc2UgbWFrZSBzdXJlIHRoYXQgdGhlIC5naXRtb2R1bGVzIGZpbGUgaXMgaW4gdGhlIHdvcmtpbmcgdHJlZSIKIG1zZ3N0ciAiaMOjeSDEkeG6o20gYuG6o28gcuG6sW5nIHThuq1wIHRpbiAuZ2l0bW9kdWxlcyBjw7MgdHJvbmcgY8OieSBsw6BtIHZp4buHYyIKIAotIzogYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjIyMzUgZ2l0LmM6NDM0IGdpdC5jOjY4NAorIzogYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjIyMzUgZ2l0LmM6NDMzIGdpdC5jOjY4MwogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyBkb2Vzbid0IHN1cHBvcnQgLS1zdXBlci1wcmVmaXgiCiBtc2dzdHIgIiVzIGtow7RuZyBo4buXIHRy4bujIC0tc3VwZXItcHJlZml4IgpAQCAtMjAzMzEsMTQzICsyMDQxNiwxNDMgQEAKIG1zZ2lkICJnaXQgdXBkYXRlLWluZGV4IFs8b3B0aW9ucz5dIFstLV0gWzxmaWxlPi4uLl0iCiBtc2dzdHIgImdpdCB1cGRhdGUtaW5kZXggWzxjw6FjIHTDuXkgY2jhu41uPl0gWy0tXSBbPHThuq1wLXRpbj7igKZdIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjk3MQorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzo5NzIKIG1zZ2lkICJjb250aW51ZSByZWZyZXNoIGV2ZW4gd2hlbiBpbmRleCBuZWVkcyB1cGRhdGUiCiBtc2dzdHIgInRp4bq/cCB04bulYyBsw6BtIG3hu5tpIG5nYXkgY+G6oyBraGkgYuG6o25nIG3hu6VjIGzhu6VjIGPhuqduIMSRxrDhu6NjIGPhuq1wIG5o4bqtdCIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzo5NzQKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6OTc1CiBtc2dpZCAicmVmcmVzaDogaWdub3JlIHN1Ym1vZHVsZXMiCiBtc2dzdHIgInJlZnJlc2g6IGzhu50gxJFpIG3DtC3EkXVuLWNvbiIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzo5NzcKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6OTc4CiBtc2dpZCAiZG8gbm90IGlnbm9yZSBuZXcgZmlsZXMiCiBtc2dzdHIgImtow7RuZyBi4buPIHF1YSBjw6FjIHThuq1wIHRpbiBt4bubaSB04bqhbyIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzo5NzkKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6OTgwCiBtc2dpZCAibGV0IGZpbGVzIHJlcGxhY2UgZGlyZWN0b3JpZXMgYW5kIHZpY2UtdmVyc2EiCiBtc2dzdHIgIsSR4buDIGPDoWMgdOG6rXAgdGluIHRoYXkgdGjhur8gY8OhYyB0aMawIG3hu6VjIHbDoCDigJx2aWNlLXZlcnNh4oCdIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjk4MQorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzo5ODIKIG1zZ2lkICJub3RpY2UgZmlsZXMgbWlzc2luZyBmcm9tIHdvcmt0cmVlIgogbXNnc3RyICJ0aMO0bmcgYsOhbyBjw6FjIHThuq1wLXRpbiB0aGnhur91IHRyb25nIHRoxrAtbeG7pWMgbMOgbSB2aeG7h2MiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6OTgzCisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjk4NAogbXNnaWQgInJlZnJlc2ggZXZlbiBpZiBpbmRleCBjb250YWlucyB1bm1lcmdlZCBlbnRyaWVzIgogbXNnc3RyICIiCiAibMOgbSB0xrDGoWkgbeG7m2kgdGjhuq1tIGNow60ga2hpIGLhuqNuZyBt4bulYyBs4bulYyBjaOG7qWEgY8OhYyBt4bulYyB0aW4gY2jGsGEgxJHGsOG7o2MgaMOyYSB0cuG7mW4iCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6OTg2CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjk4NwogbXNnaWQgInJlZnJlc2ggc3RhdCBpbmZvcm1hdGlvbiIKIG1zZ3N0ciAibOG6pXkgbOG6oWkgdGjDtG5nIHRpbiB0aOG7kW5nIGvDqiIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzo5OTAKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6OTkxCiBtc2dpZCAibGlrZSAtLXJlZnJlc2gsIGJ1dCBpZ25vcmUgYXNzdW1lLXVuY2hhbmdlZCBzZXR0aW5nIgogbXNnc3RyICJnaeG7kW5nIC0tcmVmcmVzaCwgbmjGsG5nIGLhu48gcXVhIGPDoWMgY8OgaSDEkeG6t3Qg4oCcYXNzdW1lLXVuY2hhbmdlZOKAnSIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzo5OTQKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6OTk1CiBtc2dpZCAiPG1vZGU+LDxvYmplY3Q+LDxwYXRoPiIKIG1zZ3N0ciAiPGNo4bq/X8SR4buZPiw8xJHhu5FpX3TGsOG7o25nPiw8xJHGsOG7nW5nX2ThuqtuPiIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzo5OTUKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6OTk2CiBtc2dpZCAiYWRkIHRoZSBzcGVjaWZpZWQgZW50cnkgdG8gdGhlIGluZGV4IgogbXNnc3RyICJ0aMOqbSBjw6FjIHThuq1wIHRpbiDEkcOjIGNo4buJIHJhIHbDoG8gYuG6o25nIG3hu6VjIGzhu6VjIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMDUKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAwNgogbXNnaWQgIm1hcmsgZmlsZXMgYXMgXCJub3QgY2hhbmdpbmdcIiIKIG1zZ3N0ciAixJHDoW5oIGThuqV1IGPDoWMgdOG6rXAgdGluIGzDoCBcImtow7RuZyB0aGF5IMSR4buVaVwiIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMDgKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAwOQogbXNnaWQgImNsZWFyIGFzc3VtZWQtdW5jaGFuZ2VkIGJpdCIKIG1zZ3N0ciAieMOzYSBiw610IGFzc3VtZWQtdW5jaGFuZ2VkIChnaeG6oyDEkeG7i25oIGzDoCBraMO0bmcgdGhheSDEkeG7lWkpIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMTEKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAxMgogbXNnaWQgIm1hcmsgZmlsZXMgYXMgXCJpbmRleC1vbmx5XCIiCiBtc2dzdHIgIsSRw6FuaCBk4bqldSBjw6FjIHThuq1wIHRpbiBsw6Ag4oCcY2jhu4ktxJHhu41j4oCdIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMTQKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAxNQogbXNnaWQgImNsZWFyIHNraXAtd29ya3RyZWUgYml0IgogbXNnc3RyICJ4w7NhIGLDrXQgc2tpcC13b3JrdHJlZSIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDE3CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMTgKIG1zZ2lkICJhZGQgdG8gaW5kZXggb25seTsgZG8gbm90IGFkZCBjb250ZW50IHRvIG9iamVjdCBkYXRhYmFzZSIKIG1zZ3N0ciAiIgogImNo4buJIHRow6ptIHbDoG8gYuG6o25nIG3hu6VjIGzhu6VjOyBraMO0bmcgdGjDqm0gbuG7mWkgZHVuZyB2w6BvIGPGoSBz4bufIGThu68gbGnhu4d1IMSR4buRaSB0xrDhu6NuZyIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDE5CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMjAKIG1zZ2lkICJyZW1vdmUgbmFtZWQgcGF0aHMgZXZlbiBpZiBwcmVzZW50IGluIHdvcmt0cmVlIgogbXNnc3RyICIiCiAiZ+G7oSBi4buPIGPDoWMgxJHGsOG7nW5nIGThuqtuIMSRxrDhu6NjIMSR4bq3dCB0w6puIHRo4bqtbSBjaMOtIGPhuqMga2hpIG7DsyBoaeG7h24gZGnhu4duIHRyb25nIHRoxrAgbeG7pWMgIgogImzDoG0gdmnhu4djIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMjEKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAyMgogbXNnaWQgIndpdGggLS1zdGRpbjogaW5wdXQgbGluZXMgYXJlIHRlcm1pbmF0ZWQgYnkgbnVsbCBieXRlcyIKIG1zZ3N0ciAiduG7m2kgdMO5eSBjaOG7jW4gLS1zdGRpbjogY8OhYyBkw7JuZyDEkeG6p3UgdsOgbyDEkcaw4bujYyBjaOG6pW0gZOG7qXQgYuG7n2kga8O9IHThu7EgbnVsbCIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDIzCisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMjQKIG1zZ2lkICJyZWFkIGxpc3Qgb2YgcGF0aHMgdG8gYmUgdXBkYXRlZCBmcm9tIHN0YW5kYXJkIGlucHV0IgogbXNnc3RyICLEkeG7jWMgZGFuaCBzw6FjaCDEkcaw4budbmcgZOG6q24gY+G6p24gY+G6rXAgbmjhuq10IHThu6sgxJHhuqd1IHbDoG8gdGnDqnUgY2h14bqpbiIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDI3CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMjgKIG1zZ2lkICJhZGQgZW50cmllcyBmcm9tIHN0YW5kYXJkIGlucHV0IHRvIHRoZSBpbmRleCIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIMSR4buNYyBjw6FjIG3hu6VjIHThu6sgxJHhuqd1IHbDoG8gdGnDqnUgY2h14bqpbiB2w6BvIGLhuqNuZyBt4bulYyBs4bulYyIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDMxCisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMzIKIG1zZ2lkICJyZXBvcHVsYXRlIHN0YWdlcyAjMiBhbmQgIzMgZm9yIHRoZSBsaXN0ZWQgcGF0aHMiCiBtc2dzdHIgInBo4bulYyBo4buTaSBjw6FjIHRy4bqhbmcgdGjDoWkgIzIgdsOgICMzIGNobyBjw6FjIMSRxrDhu51uZyBk4bqrbiDEkcaw4bujYyBsaeG7h3Qga8OqIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMzUKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAzNgogbXNnaWQgIm9ubHkgdXBkYXRlIGVudHJpZXMgdGhhdCBkaWZmZXIgZnJvbSBIRUFEIgogbXNnc3RyICJjaOG7iSBj4bqtcCBuaOG6rXQgY8OhYyBt4bulYyB0aW4gbcOgIG7DsyBraMOhYyBiaeG7h3Qgc28gduG7m2kgSEVBRCIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDM5CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwNDAKIG1zZ2lkICJpZ25vcmUgZmlsZXMgbWlzc2luZyBmcm9tIHdvcmt0cmVlIgogbXNnc3RyICJi4buPIHF1YSBjw6FjIHThuq1wLXRpbiB0aGnhur91IHRyb25nIHRoxrAtbeG7pWMgbMOgbSB2aeG7h2MiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTA0MgorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDQzCiBtc2dpZCAicmVwb3J0IGFjdGlvbnMgdG8gc3RhbmRhcmQgb3V0cHV0IgogbXNnc3RyICJiw6FvIGPDoW8gY8OhYyB0aGFvIHTDoWMgcmEgdGhp4bq/dCBi4buLIHh14bqldCBjaHXhuqluIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwNDQKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTA0NQogbXNnaWQgIihmb3IgcG9yY2VsYWlucykgZm9yZ2V0IHNhdmVkIHVucmVzb2x2ZWQgY29uZmxpY3RzIgogbXNnc3RyICIoY2hvIOKAnHBvcmNlbGFpbnPigJ0pIHF1w6puIGPDoWMgeHVuZyDEkeG7mXQgY2jGsGEgxJHGsOG7o2MgZ2nhuqNpIHF1eeG6v3QgxJHDoyBnaGkiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTA0OAorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDQ5CiBtc2dpZCAid3JpdGUgaW5kZXggaW4gdGhpcyBmb3JtYXQiCiBtc2dzdHIgImdoaSBt4bulYyBs4bulYyDhu58gxJHhu4tuaCBk4bqhbmcgbsOgeSIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDUwCisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwNTEKIG1zZ2lkICJlbmFibGUgb3IgZGlzYWJsZSBzcGxpdCBpbmRleCIKIG1zZ3N0ciAiYuG6rXQvdOG6r3QgY2hpYSBj4bqvdCBi4bqjbmcgbeG7pWMgbOG7pWMiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTA1MgorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDUzCiBtc2dpZCAiZW5hYmxlL2Rpc2FibGUgdW50cmFja2VkIGNhY2hlIgogbXNnc3RyICJi4bqtdC904bqvdCBi4buZIMSR4buHbSBraMO0bmcgdGhlbyB24bq/dCIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDU0CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwNTUKIG1zZ2lkICJ0ZXN0IGlmIHRoZSBmaWxlc3lzdGVtIHN1cHBvcnRzIHVudHJhY2tlZCBjYWNoZSIKIG1zZ3N0ciAia2nhu4NtIHRyYSB4ZW0gaOG7hyB0aOG7kW5nIHThuq1wIHRpbiBjw7MgaOG7lyB0cuG7oyDEkeG7h20ga2jDtG5nIHRoZW8gZMO1aSBoYXkga2jDtG5nIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwNTYKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTA1NwogbXNnaWQgImVuYWJsZSB1bnRyYWNrZWQgY2FjaGUgd2l0aG91dCB0ZXN0aW5nIHRoZSBmaWxlc3lzdGVtIgogbXNnc3RyICJi4bqtdCBi4buZIMSR4buHbSBraMO0bmcgdGhlbyB24bq/dCBtw6Aga2jDtG5nIGtp4buDbSB0cmEgaOG7hyB0aOG7kW5nIHThuq1wIHRpbiIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDU4CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwNTkKIG1zZ2lkICJ3cml0ZSBvdXQgdGhlIGluZGV4IGV2ZW4gaWYgaXMgbm90IGZsYWdnZWQgYXMgY2hhbmdlZCIKIG1zZ3N0ciAiZ2hpIHJhIG3hu6VjIGzhu6VjIG5nYXkgY+G6oyBraGkga2jDtG5nIMSRxrDhu6NjIMSRw6FuaCBj4budIGzDoCBjw7MgdGhheSDEkeG7lWkiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTA2MAorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDYxCiBtc2dpZCAiZW5hYmxlIG9yIGRpc2FibGUgZmlsZSBzeXN0ZW0gbW9uaXRvciIKIG1zZ3N0ciAiYuG6rXQvdOG6r3QgdGhlbyBkw7VpIGjhu4cgdGjhu5FuZyB04bqtcCB0aW4iCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTA2MgorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDYzCiBtc2dpZCAibWFyayBmaWxlcyBhcyBmc21vbml0b3IgdmFsaWQiCiBtc2dzdHIgIsSRw6FuaCBk4bqldSBjw6FjIHThuq1wIHRpbiBsw6AgaOG7o3AgbOG7hyBmc21vbml0b3IiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTA2NQorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDY2CiBtc2dpZCAiY2xlYXIgZnNtb25pdG9yIHZhbGlkIGJpdCIKIG1zZ3N0ciAieMOzYSBiw610IGjhu6NwIGzhu4cgZnNtb25pdG9yIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjExNjgKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTE2OQogbXNnaWQgIiIKICJjb3JlLnNwbGl0SW5kZXggaXMgc2V0IHRvIGZhbHNlOyByZW1vdmUgb3IgY2hhbmdlIGl0LCBpZiB5b3UgcmVhbGx5IHdhbnQgdG8gIgogImVuYWJsZSBzcGxpdCBpbmRleCIKQEAgLTIwNDc1LDcgKzIwNTYwLDcgQEAKICJjb3JlLnNwbGl0SW5kZXggxJHGsOG7o2MgxJHhurd0IGzDoCBzYWk7IHjDs2EgYuG7jyBoYXkgdGhheSDEkeG7lWkgbsOzLCBu4bq/dSBi4bqhbiB0aOG7sWMgc+G7sSAiCiAibXXhu5FuIGLhuq10IGNoaWEgdMOhY2ggbeG7pWMgbOG7pWMiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTE3NworIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMTc4CiBtc2dpZCAiIgogImNvcmUuc3BsaXRJbmRleCBpcyBzZXQgdG8gdHJ1ZTsgcmVtb3ZlIG9yIGNoYW5nZSBpdCwgaWYgeW91IHJlYWxseSB3YW50IHRvICIKICJkaXNhYmxlIHNwbGl0IGluZGV4IgpAQCAtMjA0ODMsNyArMjA1NjgsNyBAQAogImNvcmUuc3BsaXRJbmRleCDEkcaw4bujYyDEkeG6t3QgbMOgIMSRw7puZzsgeMOzYSBi4buPIGhheSB0aGF5IMSR4buVaSBuw7MsIG7hur91IGLhuqFuIHRo4buxYyBz4buxICIKICJtdeG7kW4gdOG6r3QgY2hpYSB0w6FjaCBt4bulYyBs4bulYyIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMTg4CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjExOTAKIG1zZ2lkICIiCiAiY29yZS51bnRyYWNrZWRDYWNoZSBpcyBzZXQgdG8gdHJ1ZTsgcmVtb3ZlIG9yIGNoYW5nZSBpdCwgaWYgeW91IHJlYWxseSB3YW50ICIKICJ0byBkaXNhYmxlIHRoZSB1bnRyYWNrZWQgY2FjaGUiCkBAIC0yMDQ5MSwxMSArMjA1NzYsMTEgQEAKICJjb3JlLnVudHJhY2tlZENhY2hlIMSRxrDhu6NjIMSR4bq3dCBsw6AgxJHDum5nOyB4w7NhIGLhu48gaGF5IHRoYXkgxJHhu5VpIG7DsywgbuG6v3UgYuG6oW4gdGjhu7FjICIKICJz4buxIG114buRbiB04bqvdCBi4buZIMSR4buHbSBjaMawYSB0aGVvIGTDtWkiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTE5MgorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMTk0CiBtc2dpZCAiVW50cmFja2VkIGNhY2hlIGRpc2FibGVkIgogbXNnc3RyICJOaOG7myDEkeG7h20ga2jDtG5nIHRoZW8gduG6v3QgYuG7iyB04bqvdCIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMjAwCisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEyMDIKIG1zZ2lkICIiCiAiY29yZS51bnRyYWNrZWRDYWNoZSBpcyBzZXQgdG8gZmFsc2U7IHJlbW92ZSBvciBjaGFuZ2UgaXQsIGlmIHlvdSByZWFsbHkgd2FudCAiCiAidG8gZW5hYmxlIHRoZSB1bnRyYWNrZWQgY2FjaGUiCkBAIC0yMDUwMywyOSArMjA1ODgsMjkgQEAKICJjb3JlLnVudHJhY2tlZENhY2hlIMSRxrDhu6NjIMSR4bq3dCBsw6Agc2FpOyB4w7NhIGLhu48gaGF5IHRoYXkgxJHhu5VpIG7DsywgbuG6v3UgYuG6oW4gdGjhu7FjIHPhu7EgIgogIm114buRbiBi4bqtdCBi4buZIMSR4buHbSBjaMawYSB0aGVvIGTDtWkiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTIwNAorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMjA2CiAjLCBjLWZvcm1hdAogbXNnaWQgIlVudHJhY2tlZCBjYWNoZSBlbmFibGVkIGZvciAnJXMnIgogbXNnc3RyICJOaOG7myDEkeG7h20ga2jDtG5nIHRoZW8gduG6v3QgxJHGsOG7o2MgYuG6rXQgY2hvIOKAnCVz4oCdIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEyMTIKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTIxNAogbXNnaWQgImNvcmUuZnNtb25pdG9yIGlzIHVuc2V0OyBzZXQgaXQgaWYgeW91IHJlYWxseSB3YW50IHRvIGVuYWJsZSBmc21vbml0b3IiCiBtc2dzdHIgIiIKICJjb3JlLmZzbW9uaXRvciBjaMawYSDEkcaw4bujYyDEkeG6t3Q7IMSR4bq3dCBuw7MgbuG6v3UgYuG6oW4gdGjhu7FjIHPhu7EgbXXhu5FuIGLhuq10IHRoZW8gZMO1aSBo4buHICIKICJ0aOG7kW5nIHThuq1wIHRpbiIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMjE2CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEyMTgKIG1zZ2lkICJmc21vbml0b3IgZW5hYmxlZCIKIG1zZ3N0ciAiZnNtb25pdG9yIMSRxrDhu6NjIGLhuq10IgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEyMTkKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTIyMQogbXNnaWQgIiIKICJjb3JlLmZzbW9uaXRvciBpcyBzZXQ7IHJlbW92ZSBpdCBpZiB5b3UgcmVhbGx5IHdhbnQgdG8gZGlzYWJsZSBmc21vbml0b3IiCiBtc2dzdHIgIiIKICJjb3JlLmZzbW9uaXRvciDEkcOjIMSRxrDhu6NjIMSR4bq3dDsgYuG7jyDEkeG6t3QgbsOzIG7hur91IGLhuqFuIHRo4buxYyBz4buxIG114buRbiBi4bqtdCB0aGVvIGTDtWkgaOG7hyAiCiAidGjhu5FuZyB04bqtcCB0aW4iCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTIyMworIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMjI1CiBtc2dpZCAiZnNtb25pdG9yIGRpc2FibGVkIgogbXNnc3RyICJmc21vbml0b3IgYuG7iyB04bqvdCIKIApAQCAtMjA2MTcsOTAgKzIwNzAyLDkwIEBACiBtc2dpZCAicHJpbnQgdGFnIGNvbnRlbnRzIgogbXNnc3RyICJoaeG7g24gdGjhu4sgbuG7mWkgZHVuZyBj4bunYSB0aOG6uyIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjE4CisjOiBidWlsdGluL3dvcmt0cmVlLmM6MTcKIG1zZ2lkICJnaXQgd29ya3RyZWUgYWRkIFs8b3B0aW9ucz5dIDxwYXRoPiBbPGNvbW1pdC1pc2g+XSIKIG1zZ3N0ciAiZ2l0IHdvcmt0cmVlIGFkZCBbPGPDoWMgdMO5eSBjaOG7jW4+XSA8L8SRxrDhu51uZy9k4bqrbj4gWzxjb21taXQtaXNoPl0iCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzoxOQorIzogYnVpbHRpbi93b3JrdHJlZS5jOjE4CiBtc2dpZCAiZ2l0IHdvcmt0cmVlIGxpc3QgWzxvcHRpb25zPl0iCiBtc2dzdHIgImdpdCB3b3JrdHJlZSBsaXN0IFs8Y8OhYyB0w7l5IGNo4buNbj5dIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6MjAKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzoxOQogbXNnaWQgImdpdCB3b3JrdHJlZSBsb2NrIFs8b3B0aW9ucz5dIDxwYXRoPiIKIG1zZ3N0ciAiZ2l0IHdvcmt0cmVlIGxvY2sgWzxjw6FjIHTDuXkgY2jhu41uPl0gPC/Ekcaw4budbmcvZOG6q24+IgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6MjEKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzoyMAogbXNnaWQgImdpdCB3b3JrdHJlZSBtb3ZlIDx3b3JrdHJlZT4gPG5ldy1wYXRoPiIKIG1zZ3N0ciAiZ2l0IHdvcmt0cmVlIG1vdmUgPHdvcmt0cmVlPiA8L8SRxrDhu51uZy9k4bqrbi9t4bubaT4iCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzoyMgorIzogYnVpbHRpbi93b3JrdHJlZS5jOjIxCiBtc2dpZCAiZ2l0IHdvcmt0cmVlIHBydW5lIFs8b3B0aW9ucz5dIgogbXNnc3RyICJnaXQgd29ya3RyZWUgcHJ1bmUgWzxjw6FjIHTDuXkgY2jhu41uPl0iCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzoyMworIzogYnVpbHRpbi93b3JrdHJlZS5jOjIyCiBtc2dpZCAiZ2l0IHdvcmt0cmVlIHJlbW92ZSBbPG9wdGlvbnM+XSA8d29ya3RyZWU+IgogbXNnc3RyICJnaXQgd29ya3RyZWUgcmVtb3ZlIFs8Y8OhYyB0w7l5IGNo4buNbj5dIDx3b3JrdHJlZT4iCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzoyNAorIzogYnVpbHRpbi93b3JrdHJlZS5jOjIzCiBtc2dpZCAiZ2l0IHdvcmt0cmVlIHVubG9jayA8cGF0aD4iCiBtc2dzdHIgImdpdCB3b3JrdHJlZSB1bmxvY2sgPC/Ekcaw4budbmcvZOG6q24+IgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NjEgYnVpbHRpbi93b3JrdHJlZS5jOjg5OQorIzogYnVpbHRpbi93b3JrdHJlZS5jOjYwIGJ1aWx0aW4vd29ya3RyZWUuYzo4OTgKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIGRlbGV0ZSAnJXMnIgogbXNnc3RyICJn4bq3cCBs4buXaSBraGkgeMOzYSDigJwlc+KAnSIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjgwCisjOiBidWlsdGluL3dvcmt0cmVlLmM6NzkKICMsIGMtZm9ybWF0CiBtc2dpZCAiUmVtb3Zpbmcgd29ya3RyZWVzLyVzOiBub3QgYSB2YWxpZCBkaXJlY3RvcnkiCiBtc2dzdHIgIkfhu6EgYuG7jyBjw6J5IGzDoG0gdmnhu4djLyVzOiBraMO0bmcgcGjhuqNpIGzDoCB0aMawIG3hu6VjIGjhu6NwIGzhu4ciCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4NgorIzogYnVpbHRpbi93b3JrdHJlZS5jOjg1CiAjLCBjLWZvcm1hdAogbXNnaWQgIlJlbW92aW5nIHdvcmt0cmVlcy8lczogZ2l0ZGlyIGZpbGUgZG9lcyBub3QgZXhpc3QiCiBtc2dzdHIgIkfhu6EgYuG7jyBjw6J5IGzDoG0gdmnhu4djLyVzOiBraMO0bmcgY8OzIHThuq1wIHRpbiBnaXRkaXIiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo5MSBidWlsdGluL3dvcmt0cmVlLmM6MTAwCisjOiBidWlsdGluL3dvcmt0cmVlLmM6OTAgYnVpbHRpbi93b3JrdHJlZS5jOjk5CiAjLCBjLWZvcm1hdAogbXNnaWQgIlJlbW92aW5nIHdvcmt0cmVlcy8lczogdW5hYmxlIHRvIHJlYWQgZ2l0ZGlyIGZpbGUgKCVzKSIKIG1zZ3N0ciAiR+G7oSBi4buPIGPDonkgbMOgbSB2aeG7h2MvJXM6IGtow7RuZyB0aOG7gyDEkeG7jWMgdOG6rXAgdGluIGdpdGRpciAoJXMpIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6MTEwCisjOiBidWlsdGluL3dvcmt0cmVlLmM6MTA5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJSZW1vdmluZyB3b3JrdHJlZXMvJXM6IHNob3J0IHJlYWQgKGV4cGVjdGVkICU8UFJJdU1BWD4gYnl0ZXMsIHJlYWQgIgogIiU8UFJJdU1BWD4pIgogbXNnc3RyICJH4buhIGLhu48gY8OieSBsw6BtIHZp4buHYy8lczogxJHhu41jIG5n4bqvbiAoY+G6p24gJTxQUkl1TUFYPiBieXRlLCDEkeG7jWMgJTxQUkl1TUFYPikiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzoxMTgKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzoxMTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiUmVtb3Zpbmcgd29ya3RyZWVzLyVzOiBpbnZhbGlkIGdpdGRpciBmaWxlIgogbXNnc3RyICJH4buhIGLhu48gY8OieSBsw6BtIHZp4buHYy8lczogdOG6rXAgdGluIGdpdGRpciBraMO0bmcgaOG7o3AgbOG7hyIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjEyNworIzogYnVpbHRpbi93b3JrdHJlZS5jOjEyNgogIywgYy1mb3JtYXQKIG1zZ2lkICJSZW1vdmluZyB3b3JrdHJlZXMvJXM6IGdpdGRpciBmaWxlIHBvaW50cyB0byBub24tZXhpc3RlbnQgbG9jYXRpb24iCiBtc2dzdHIgIkfhu6EgYuG7jyBjw6J5IGzDoG0gdmnhu4djLyVzOiB04bqtcCB0aW4gZ2l0ZGlyIGNo4buJIMSR4bq/biB24buLIHRyw60ga2jDtG5nIHThu5NuIHThuqFpIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6MTY2CisjOiBidWlsdGluL3dvcmt0cmVlLmM6MTY1CiBtc2dpZCAicmVwb3J0IHBydW5lZCB3b3JraW5nIHRyZWVzIgogbXNnc3RyICJiw6FvIGPDoW8gY8OhYyBjw6J5IGzDoG0gdmnhu4djIMSRw6MgcHJ1bmUiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzoxNjgKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzoxNjcKIG1zZ2lkICJleHBpcmUgd29ya2luZyB0cmVlcyBvbGRlciB0aGFuIDx0aW1lPiIKIG1zZ3N0ciAiY8OhYyBjw6J5IGzDoG0gdmnhu4djIGjhur90IGjhuqFuIGPFqSBoxqFuIGtob+G6o25nIDx0aOG7nWkgZ2lhbj4iCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzoyMzUKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzoyMzQKICMsIGMtZm9ybWF0CiBtc2dpZCAiJyVzJyBhbHJlYWR5IGV4aXN0cyIKIG1zZ3N0ciAi4oCcJXPigJ0gxJHDoyBjw7MgdOG7qyB0csaw4bubYyBy4buTaSIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjI1MgorIzogYnVpbHRpbi93b3JrdHJlZS5jOjI1MQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gcmUtYWRkIHdvcmt0cmVlICclcyciCiBtc2dzdHIgImtow7RuZyB0aOG7gyB0aMOqbS1s4bqhaSBjw6J5IOKAnCVz4oCdIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6MjU3CisjOiBidWlsdGluL3dvcmt0cmVlLmM6MjU2CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICInJXMnIGlzIGEgbWlzc2luZyBidXQgbG9ja2VkIHdvcmt0cmVlO1xuIgpAQCAtMjA3MDksNyArMjA3OTQsNyBAQAogIuKAnCVz4oCdIGLhu4sgbeG6pXQgbmjGsG5nIGPDonkgbMOgbSB2aeG7h2MgYuG7iyBraMOzYTtcbiIKICJkw7luZyDigJxhZGQgLWYgLWbigJ0gxJHhu4MgZ2hpIMSRw6gsIGhv4bq3YyDigJx1bmxvY2vigJ0gdsOgIOKAnHBydW5l4oCdIGhheSDigJxyZW1vdmXigJ0gxJHhu4MgeMOzYSIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjI1OQorIzogYnVpbHRpbi93b3JrdHJlZS5jOjI1OAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiJyVzJyBpcyBhIG1pc3NpbmcgYnV0IGFscmVhZHkgcmVnaXN0ZXJlZCB3b3JrdHJlZTtcbiIKQEAgLTIwNzE4LDEyMCArMjA4MDMsMTIwIEBACiAi4oCcJXPigJ0gYuG7iyBt4bqldCBuaMawbmcgY8OieSBsw6BtIHZp4buHYyDEkcOjIMSRxrDhu6NjIMSRxINuZyBrw707XG4iCiAiZMO5bmcg4oCcYWRkIC1m4oCdIMSR4buDIGdoaSDEkcOoLCBob+G6t2Mg4oCccHJ1bmXigJ0gaGF5IOKAnHJlbW92ZeKAnSDEkeG7gyB4w7NhIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6MzA5CisjOiBidWlsdGluL3dvcmt0cmVlLmM6MzA4CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBjcmVhdGUgZGlyZWN0b3J5IG9mICclcyciCiBtc2dzdHIgImtow7RuZyB0aOG7gyB04bqhbyB0aMawIG3hu6VjIGPhu6dhIOKAnCVz4oCdIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NDQwIGJ1aWx0aW4vd29ya3RyZWUuYzo0NDYKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo0MzkgYnVpbHRpbi93b3JrdHJlZS5jOjQ0NQogIywgYy1mb3JtYXQKIG1zZ2lkICJQcmVwYXJpbmcgd29ya3RyZWUgKG5ldyBicmFuY2ggJyVzJykiCiBtc2dzdHIgIsSQYW5nIGNodeG6qW4gYuG7iyBjw6J5IGzDoG0gdmnhu4djIChuaMOhbmggbeG7m2kg4oCcJXPigJ0pIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NDQyCisjOiBidWlsdGluL3dvcmt0cmVlLmM6NDQxCiAjLCBjLWZvcm1hdAogbXNnaWQgIlByZXBhcmluZyB3b3JrdHJlZSAocmVzZXR0aW5nIGJyYW5jaCAnJXMnOyB3YXMgYXQgJXMpIgogbXNnc3RyICLEkGFuZyBjaHXhuqluIGLhu4sgY8OieSBsw6BtIHZp4buHYyAoxJFhbmcgY8OgaSDEkeG6t3QgbmjDoW5oIOKAnCVz4oCdLCB0csaw4bubYyDEkcOieSB04bqhaSAlcykiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo0NTEKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo0NTAKICMsIGMtZm9ybWF0CiBtc2dpZCAiUHJlcGFyaW5nIHdvcmt0cmVlIChjaGVja2luZyBvdXQgJyVzJykiCiBtc2dzdHIgIsSQYW5nIGNodeG6qW4gYuG7iyBjw6J5IGzDoG0gdmnhu4djICjEkWFuZyBs4bqleSByYSDigJwlc+KAnSkiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo0NTcKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo0NTYKICMsIGMtZm9ybWF0CiBtc2dpZCAiUHJlcGFyaW5nIHdvcmt0cmVlIChkZXRhY2hlZCBIRUFEICVzKSIKIG1zZ3N0ciAixJBhbmcgY2h14bqpbiBi4buLIGPDonkgbMOgbSB2aeG7h2MgKEhFQUQgxJHDoyB0w6FjaCBy4budaSDigJwlc+KAnSkiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo0OTgKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo0OTcKIG1zZ2lkICJjaGVja291dCA8YnJhbmNoPiBldmVuIGlmIGFscmVhZHkgY2hlY2tlZCBvdXQgaW4gb3RoZXIgd29ya3RyZWUiCiBtc2dzdHIgImzhuqV5IHJhIDxuaMOhbmg+IG5nYXkgY+G6oyBraGkgbsOzIMSRw6MgxJHGsOG7o2MgbOG6pXkgcmEg4bufIGPDonkgbMOgbSB2aeG7h2Mga2jDoWMiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo1MDEKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo1MDAKIG1zZ2lkICJjcmVhdGUgYSBuZXcgYnJhbmNoIgogbXNnc3RyICJ04bqhbyBuaMOhbmggbeG7m2kiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo1MDMKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo1MDIKIG1zZ2lkICJjcmVhdGUgb3IgcmVzZXQgYSBicmFuY2giCiBtc2dzdHIgInThuqFvIGhheSDEkeG6t3QgbOG6oWkgbeG7mXQgbmjDoW5oIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NTA1CisjOiBidWlsdGluL3dvcmt0cmVlLmM6NTA0CiBtc2dpZCAicG9wdWxhdGUgdGhlIG5ldyB3b3JraW5nIHRyZWUiCiBtc2dzdHIgImRpIGNodXnhu4NuIGPDonkgbMOgbSB2aeG7h2MgbeG7m2kiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo1MDYKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo1MDUKIG1zZ2lkICJrZWVwIHRoZSBuZXcgd29ya2luZyB0cmVlIGxvY2tlZCIKIG1zZ3N0ciAiZ2nhu68gY8OieSBsw6BtIHZp4buHYyBt4bubaSBi4buLIGtow7NhIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NTA5CisjOiBidWlsdGluL3dvcmt0cmVlLmM6NTA4CiBtc2dpZCAic2V0IHVwIHRyYWNraW5nIG1vZGUgKHNlZSBnaXQtYnJhbmNoKDEpKSIKIG1zZ3N0ciAiY8OgaSDEkeG6t3QgY2jhur8gxJHhu5kgdGhlbyBkw7VpICh4ZW0gZ2l0LWJyYW5jaCgxKSkiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo1MTIKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo1MTEKIG1zZ2lkICJ0cnkgdG8gbWF0Y2ggdGhlIG5ldyBicmFuY2ggbmFtZSB3aXRoIGEgcmVtb3RlLXRyYWNraW5nIGJyYW5jaCIKIG1zZ3N0ciAiY8OzIGto4bubcCB0w6puIHTDqm4gbmjDoW5oIG3hu5tpIHbhu5tpIG3hu5l0IG5ow6FuaCB0aGVvIGTDtWkgbcOheSBjaOG7pyIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjUyMAorIzogYnVpbHRpbi93b3JrdHJlZS5jOjUxOQogbXNnaWQgIi1iLCAtQiwgYW5kIC0tZGV0YWNoIGFyZSBtdXR1YWxseSBleGNsdXNpdmUiCiBtc2dzdHIgIkPDoWMgdMO5eSBjaOG7jW4gLWIsIC1CLCB2w6AgLS1kZXRhY2ggbG/huqFpIHThu6sgbOG6q24gbmhhdSIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjU4MQorIzogYnVpbHRpbi93b3JrdHJlZS5jOjU4MAogbXNnaWQgIi0tW25vLV10cmFjayBjYW4gb25seSBiZSB1c2VkIGlmIGEgbmV3IGJyYW5jaCBpcyBjcmVhdGVkIgogbXNnc3RyICItLVtuby1ddHJhY2sgY2jhu4kgY8OzIHRo4buDIMSRxrDhu6NjIGTDuW5nIG7hur91IG3hu5l0IG5ow6FuaCBt4bubaSDEkcaw4bujYyB04bqhbyIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjY4MQorIzogYnVpbHRpbi93b3JrdHJlZS5jOjY4MAogbXNnaWQgInJlYXNvbiBmb3IgbG9ja2luZyIKIG1zZ3N0ciAibMO9IGRvIGtow7NhIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NjkzIGJ1aWx0aW4vd29ya3RyZWUuYzo3MjYgYnVpbHRpbi93b3JrdHJlZS5jOjgwMAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjkyNworIzogYnVpbHRpbi93b3JrdHJlZS5jOjY5MiBidWlsdGluL3dvcmt0cmVlLmM6NzI1IGJ1aWx0aW4vd29ya3RyZWUuYzo3OTkKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo5MjYKICMsIGMtZm9ybWF0CiBtc2dpZCAiJyVzJyBpcyBub3QgYSB3b3JraW5nIHRyZWUiCiBtc2dzdHIgIiVzIGtow7RuZyBwaOG6o2kgbMOgIGPDonkgbMOgbSB2aeG7h2MiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo2OTUgYnVpbHRpbi93b3JrdHJlZS5jOjcyOAorIzogYnVpbHRpbi93b3JrdHJlZS5jOjY5NCBidWlsdGluL3dvcmt0cmVlLmM6NzI3CiBtc2dpZCAiVGhlIG1haW4gd29ya2luZyB0cmVlIGNhbm5vdCBiZSBsb2NrZWQgb3IgdW5sb2NrZWQiCiBtc2dzdHIgIkPDonkgdGjGsCBt4bulYyBsw6BtIHZp4buHYyBjaMOtbmgga2jDtG5nIHRo4buDIGtow7NhIGhheSBi4buPIGtow7NhIMSRxrDhu6NjIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NzAwCisjOiBidWlsdGluL3dvcmt0cmVlLmM6Njk5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiclcycgaXMgYWxyZWFkeSBsb2NrZWQsIHJlYXNvbjogJXMiCiBtc2dzdHIgIuKAnCVz4oCdIMSRw6MgxJHGsOG7o2Mga2jDs2EgcuG7k2ksIGzDvSBkbzogJXMiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo3MDIKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo3MDEKICMsIGMtZm9ybWF0CiBtc2dpZCAiJyVzJyBpcyBhbHJlYWR5IGxvY2tlZCIKIG1zZ3N0ciAi4oCcJXPigJ0gxJHDoyDEkcaw4bujYyBraMOzYSBy4buTaSIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjczMAorIzogYnVpbHRpbi93b3JrdHJlZS5jOjcyOQogIywgYy1mb3JtYXQKIG1zZ2lkICInJXMnIGlzIG5vdCBsb2NrZWQiCiBtc2dzdHIgIuKAnCVz4oCdIGNoxrBhIGLhu4sga2jDs2EiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo3NzEKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo3NzAKIG1zZ2lkICJ3b3JraW5nIHRyZWVzIGNvbnRhaW5pbmcgc3VibW9kdWxlcyBjYW5ub3QgYmUgbW92ZWQgb3IgcmVtb3ZlZCIKIG1zZ3N0ciAiY8OieSBsw6BtIHZp4buHYyBjw7MgY2jhu6lhIG3DtC3EkXVuLWNvbiBraMO0bmcgdGjhu4MgZGkgY2h1eeG7g24gaGF5IHjDs2EgYuG7jyIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjc3OQorIzogYnVpbHRpbi93b3JrdHJlZS5jOjc3OAogbXNnaWQgImZvcmNlIG1vdmUgZXZlbiBpZiB3b3JrdHJlZSBpcyBkaXJ0eSBvciBsb2NrZWQiCiBtc2dzdHIgIsOpcCBideG7mWMgbmdheSBj4bqjIGtoaSBjw6J5IGzDoG0gdmnhu4djIMSRYW5nIGLhuqluIGhheSBi4buLIGtow7NhIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6ODAyIGJ1aWx0aW4vd29ya3RyZWUuYzo5MjkKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4MDEgYnVpbHRpbi93b3JrdHJlZS5jOjkyOAogIywgYy1mb3JtYXQKIG1zZ2lkICInJXMnIGlzIGEgbWFpbiB3b3JraW5nIHRyZWUiCiBtc2dzdHIgIuKAnCVz4oCdIGzDoCBjw6J5IGzDoG0gdmnhu4djIGNow61uaCIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjgwNworIzogYnVpbHRpbi93b3JrdHJlZS5jOjgwNgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgZmlndXJlIG91dCBkZXN0aW5hdGlvbiBuYW1lIGZyb20gJyVzJyIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIHBow6FjIGjhu41hIHJhIHTDqm4gxJHDrWNoIMSR4bq/biDigJwlc+KAnSIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjgxMworIzogYnVpbHRpbi93b3JrdHJlZS5jOjgxMgogIywgYy1mb3JtYXQKIG1zZ2lkICJ0YXJnZXQgJyVzJyBhbHJlYWR5IGV4aXN0cyIKIG1zZ3N0ciAixJHDrWNoIOKAnCVz4oCdIMSRw6MgdOG7k24gdOG6oWkgcuG7k2kiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4MjEKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4MjAKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogImNhbm5vdCBtb3ZlIGEgbG9ja2VkIHdvcmtpbmcgdHJlZSwgbG9jayByZWFzb246ICVzXG4iCkBAIC0yMDg0MCw3ICsyMDkyNSw3IEBACiAia2jDtG5nIHRo4buDIGRpIGNodXnhu4NuIG3hu5l0IGPDonktbMOgbS12aeG7h2MgYuG7iyBraMOzYSwga2jDs2EgdsOsOiAlc1xuIgogImTDuW5nIOKAnG1vdmUgLWYgLWbigJ0gxJHhu4MgZ2hpIMSRw6ggaG/hurdjIG3hu58ga2jDs2EgdHLGsOG7m2MgxJHDoyIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjgyMworIzogYnVpbHRpbi93b3JrdHJlZS5jOjgyMgogbXNnaWQgIiIKICJjYW5ub3QgbW92ZSBhIGxvY2tlZCB3b3JraW5nIHRyZWU7XG4iCiAidXNlICdtb3ZlIC1mIC1mJyB0byBvdmVycmlkZSBvciB1bmxvY2sgZmlyc3QiCkBAIC0yMDg0OCwzNiArMjA5MzMsMzggQEAKICJraMO0bmcgdGjhu4MgZGkgY2h1eeG7g24gbeG7mXQgY8OieS1sw6BtLXZp4buHYyBi4buLIGtow7NhO1xuIgogImTDuW5nIOKAnG1vdmUgLWYgLWbigJ0gxJHhu4MgZ2hpIMSRw6ggaG/hurdjIG3hu58ga2jDs2EgdHLGsOG7m2MgxJHDoyIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjgyNgorIzogYnVpbHRpbi93b3JrdHJlZS5jOjgyNQogIywgYy1mb3JtYXQKIG1zZ2lkICJ2YWxpZGF0aW9uIGZhaWxlZCwgY2Fubm90IG1vdmUgd29ya2luZyB0cmVlOiAlcyIKIG1zZ3N0ciAidGjhuqltIHRyYSBn4bq3cCBs4buXaSwga2jDtG5nIHRo4buDIGRpIGNodXnhu4NuIG3hu5l0IGPDonktbMOgbS12aeG7h2M6ICVzIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6ODMxCisjOiBidWlsdGluL3dvcmt0cmVlLmM6ODMwCiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBtb3ZlICclcycgdG8gJyVzJyIKIG1zZ3N0ciAiZ+G6t3AgbOG7l2kga2hpIGNodXnhu4NuIOKAnCVz4oCdIHNhbmcg4oCcJXPigJ0iCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4NzkKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4NzgKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIHJ1biAnZ2l0IHN0YXR1cycgb24gJyVzJyIKIG1zZ3N0ciAiZ+G6t3AgbOG7l2kga2hpIGNo4bqheSDigJxnaXQgc3RhdHVz4oCdIHbDoG8g4oCcJXPigJ0iCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4ODMKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4ODIKICMsIGMtZm9ybWF0Ci1tc2dpZCAiJyVzJyBpcyBkaXJ0eSwgdXNlIC0tZm9yY2UgdG8gZGVsZXRlIGl0IgotbXNnc3RyICLigJwlc+KAnSDEkWFuZyBi4bqpbiwgaMOjeSBkw7luZyAtLWZvcmNlIMSR4buDIHjDs2EgbsOzIgorbXNnaWQgIiclcycgY29udGFpbnMgbW9kaWZpZWQgb3IgdW50cmFja2VkIGZpbGVzLCB1c2UgLS1mb3JjZSB0byBkZWxldGUgaXQiCittc2dzdHIgIiIKKyLigJwlc+KAnSBjw7MgY2jhu6lhIGPDoWMgdOG6rXAgdGluIMSRw6MgYuG7iyBz4butYSBjaOG7r2EgaG/hurdjIGNoxrBhIMSRxrDhu6NjIHRoZW8gZMO1aSwgaMOjeSBkw7luZyAtLSIKKyJmb3JjZSDEkeG7gyB4w7NhIG7DsyIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjg4OAorIzogYnVpbHRpbi93b3JrdHJlZS5jOjg4NwogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gcnVuICdnaXQgc3RhdHVzJyBvbiAnJXMnLCBjb2RlICVkIgogbXNnc3RyICJn4bq3cCBs4buXaSBraGkgY2jhuqF5IOKAnGdpdCBzdGF0dXPigJ0gdHJvbmcg4oCcJXPigJ0sIG3DoyAlZCIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjkxMQorIzogYnVpbHRpbi93b3JrdHJlZS5jOjkxMAogbXNnaWQgImZvcmNlIHJlbW92YWwgZXZlbiBpZiB3b3JrdHJlZSBpcyBkaXJ0eSBvciBsb2NrZWQiCiBtc2dzdHIgIsOpcCBideG7mWMgZGkgY2h1eeG7g24gdGjhuq1tIGNow60gY+G6oyBraGkgY8OieSBsw6BtIHZp4buHYyDEkWFuZyBi4bqpbiBoYXkgYuG7iyBraMOzYSIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjkzNAorIzogYnVpbHRpbi93b3JrdHJlZS5jOjkzMwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiY2Fubm90IHJlbW92ZSBhIGxvY2tlZCB3b3JraW5nIHRyZWUsIGxvY2sgcmVhc29uOiAlc1xuIgpAQCAtMjA4ODYsNyArMjA5NzMsNyBAQAogImtow7RuZyB0aOG7gyB4w7NhIGLhu48gbeG7mXQgY8OieS1sw6BtLXZp4buHYyBi4buLIGtow7NhLCBraMOzYSB2w6w6ICVzXG4iCiAiZMO5bmcg4oCccmVtb3ZlIC1mIC1m4oCdIMSR4buDIGdoaSDEkcOoIGhv4bq3YyBt4bufIGtow7NhIHRyxrDhu5tjIMSRw6MiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo5MzYKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo5MzUKIG1zZ2lkICIiCiAiY2Fubm90IHJlbW92ZSBhIGxvY2tlZCB3b3JraW5nIHRyZWU7XG4iCiAidXNlICdyZW1vdmUgLWYgLWYnIHRvIG92ZXJyaWRlIG9yIHVubG9jayBmaXJzdCIKQEAgLTIwODk0LDcgKzIwOTgxLDcgQEAKICJraMO0bmcgdGjhu4MgeMOzYSBi4buPIG3hu5l0IGPDonktbMOgbS12aeG7h2MgYuG7iyBraMOzYTtcbiIKICJkw7luZyDigJxyZW1vdmUgLWYgLWbigJ0gxJHhu4MgZ2hpIMSRw6ggaG/hurdjIG3hu58ga2jDs2EgdHLGsOG7m2MgxJHDoyIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjkzOQorIzogYnVpbHRpbi93b3JrdHJlZS5jOjkzOAogIywgYy1mb3JtYXQKIG1zZ2lkICJ2YWxpZGF0aW9uIGZhaWxlZCwgY2Fubm90IHJlbW92ZSB3b3JraW5nIHRyZWU6ICVzIgogbXNnc3RyICJ0aOG6qW0gdHJhIGfhurdwIGzhu5dpLCBraMO0bmcgdGjhu4MgZ+G7oSBi4buPIG3hu5l0IGPDonktbMOgbS12aeG7h2M6ICVzIgpAQCAtMjA5MTUsNiArMjEwMDIsMTYgQEAKIG1zZ2lkICJvbmx5IHVzZWZ1bCBmb3IgZGVidWdnaW5nIgogbXNnc3RyICJjaOG7iSBo4buvdSDDrWNoIGtoaSBj4bqnbiBn4buhIGzhu5dpIgogCisjOiBmYXN0LWltcG9ydC5jOjMxMTgKKyMsIGMtZm9ybWF0Cittc2dpZCAiRXhwZWN0ZWQgJ21hcmsnIGNvbW1hbmQsIGdvdCAlcyIKK21zZ3N0ciAiQ+G6p24gbOG7h25oICdtYXJrJywgbmjGsG5nIGzhuqFpIG5o4bqtbiDEkcaw4bujYyAlcyIKKworIzogZmFzdC1pbXBvcnQuYzozMTIzCisjLCBjLWZvcm1hdAorbXNnaWQgIkV4cGVjdGVkICd0bycgY29tbWFuZCwgZ290ICVzIgorbXNnc3RyICJD4bqnbiBs4buHbmggJ3RvJywgbmjGsG5nIGzhuqFpIG5o4bqtbiDEkcaw4bujYyAlcyIKKwogIzogY3JlZGVudGlhbC1jYWNoZS0tZGFlbW9uLmM6MjIzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKQEAgLTIxMDI4LDQwICsyMTEyNSw0MCBAQAogImLDrSBkYW5oIOKAnCVz4oCdIHRoYXkgxJHhu5VpIGJp4bq/biBtw7RpIHRyxrDhu51uZy5cbiIKICJC4bqhbiBjw7MgdGjhu4Mgc+G7rSBk4bulbmcg4oCcIWdpdOKAnSB0cm9uZyDEkeG6t3QgYsOtIGRhbmggxJHhu4MgbMOgbSB2aeG7h2MgbsOgeSIKIAotIzogZ2l0LmM6Mzc3CisjOiBnaXQuYzozNzYKICMsIGMtZm9ybWF0CiBtc2dpZCAiZW1wdHkgYWxpYXMgZm9yICVzIgogbXNnc3RyICJsw6BtIHRy4buRbmcgYsOtIGRhbmggY2hvICVzIgogCi0jOiBnaXQuYzozODAKKyM6IGdpdC5jOjM3OQogIywgYy1mb3JtYXQKIG1zZ2lkICJyZWN1cnNpdmUgYWxpYXM6ICVzIgogbXNnc3RyICLEkeG7hyBxdXkgY8OhYyBiw60gZGFuaDogJXMiCiAKLSM6IGdpdC5jOjQ2MAorIzogZ2l0LmM6NDU5CiBtc2dpZCAid3JpdGUgZmFpbHVyZSBvbiBzdGFuZGFyZCBvdXRwdXQiCiBtc2dzdHIgImzhu5dpIGdoaSBuZ2hpw6ptIHRyb25nIHRyw6puIMSR4bqndSByYSB0acOqdSBjaHXhuqluIgogCi0jOiBnaXQuYzo0NjIKKyM6IGdpdC5jOjQ2MQogbXNnaWQgInVua25vd24gd3JpdGUgZmFpbHVyZSBvbiBzdGFuZGFyZCBvdXRwdXQiCiBtc2dzdHIgImzhu5dpIG5naGnDqm0gdHLhu41uZyBjaMawYSBiaeG6v3Qga2hpIGdoaSByYSDEkeG6p3UgcmEgdGnDqnUgY2h14bqpbiIKIAotIzogZ2l0LmM6NDY0CisjOiBnaXQuYzo0NjMKIG1zZ2lkICJjbG9zZSBmYWlsZWQgb24gc3RhbmRhcmQgb3V0cHV0IgogbXNnc3RyICJn4bq3cCBs4buXaSBraGkgxJHDs25nIMSR4bqndSByYSB0acOqdSBjaHXhuqluIgogCi0jOiBnaXQuYzo3OTMKKyM6IGdpdC5jOjc5MgogIywgYy1mb3JtYXQKIG1zZ2lkICJhbGlhcyBsb29wIGRldGVjdGVkOiBleHBhbnNpb24gb2YgJyVzJyBkb2VzIG5vdCB0ZXJtaW5hdGU6JXMiCiBtc2dzdHIgIiIKICJkw7IgdMOsbSB0aOG6pXkgY8OhYyBiw60gZGFuaCBxdeG6qW4gdHLDsm46IGJp4buDdSB0aOG7qWMgY+G7p2Eg4oCcJXPigJ0ga2jDtG5nIGPDsyDEkWnhu4NtIGvhur90OiVzIgogCi0jOiBnaXQuYzo4NDMKKyM6IGdpdC5jOjg0MgogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgaGFuZGxlICVzIGFzIGEgYnVpbHRpbiIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIHjhu60gbMO9ICVzIG5oxrAgbMOgIG3hu5l0IHBo4bqnbiBi4buVIHN1bmciCiAKLSM6IGdpdC5jOjg1NgorIzogZ2l0LmM6ODU1CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJ1c2FnZTogJXNcbiIKQEAgLTIxMDcwLDEyICsyMTE2NywxMiBAQAogImPDoWNoIGTDuW5nOiAlc1xuIgogIlxuIgogCi0jOiBnaXQuYzo4NzYKKyM6IGdpdC5jOjg3NQogIywgYy1mb3JtYXQKIG1zZ2lkICJleHBhbnNpb24gb2YgYWxpYXMgJyVzJyBmYWlsZWQ7ICclcycgaXMgbm90IGEgZ2l0IGNvbW1hbmRcbiIKIG1zZ3N0ciAiZ+G6t3AgbOG7l2kga2hpIGtoYWkgdHJp4buDbiBiw60gZGFuaCDigJwlc+KAnTsg4oCcJXPigJ0ga2jDtG5nIHBo4bqjaSBsw6AgbOG7h25oIGdpdFxuIgogCi0jOiBnaXQuYzo4ODgKKyM6IGdpdC5jOjg4NwogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gcnVuIGNvbW1hbmQgJyVzJzogJXNcbiIKIG1zZ3N0ciAiZ+G6t3AgbOG7l2kga2hpIGNo4bqheSBs4buHbmgg4oCcJXPigJ06ICVzXG4iCkBAIC0yMTA5MywzNCArMjExOTAsMzQgQEAKIG1zZ2lkICJQdWJsaWMga2V5IHBpbm5pbmcgbm90IHN1cHBvcnRlZCB3aXRoIGNVUkwgPCA3LjQ0LjAiCiBtc2dzdHIgIkNo4buRdCBraMOzYSBjw7RuZyBraMO0bmcgxJHGsOG7o2MgaOG7lyB0cuG7oyB24bubaSBjVVJMIDwgNy40NC4wIgogCi0jOiBodHRwLmM6ODc2CisjOiBodHRwLmM6ODc4CiBtc2dpZCAiQ1VSTFNTTE9QVF9OT19SRVZPS0Ugbm90IHN1cHBvcnRlZCB3aXRoIGNVUkwgPCA3LjQ0LjAiCiBtc2dzdHIgIkNVUkxTU0xPUFRfTk9fUkVWT0tFIGtow7RuZyDEkcaw4bujYyBo4buXIHRy4bujIHbhu5tpIGNVUkwgPCA3LjQ0LjAiCiAKLSM6IGh0dHAuYzo5NDkKKyM6IGh0dHAuYzo5NTEKIG1zZ2lkICJQcm90b2NvbCByZXN0cmljdGlvbnMgbm90IHN1cHBvcnRlZCB3aXRoIGNVUkwgPCA3LjE5LjQiCiBtc2dzdHIgIkPDoWMgaOG6oW4gY2jhur8gZ2lhbyB0aOG7qWMga2jDtG5nIMSRxrDhu6NjIGjhu5cgdHLhu6MgduG7m2kgY1VSTCA8IDcuMTkuNCIKIAotIzogaHR0cC5jOjEwODUKKyM6IGh0dHAuYzoxMDg4CiAjLCBjLWZvcm1hdAogbXNnaWQgIlVuc3VwcG9ydGVkIFNTTCBiYWNrZW5kICclcycuIFN1cHBvcnRlZCBTU0wgYmFja2VuZHM6IgogbXNnc3RyICIiCiAiS2jDtG5nIGjhu5cgdHLhu6Mg4bupbmcgZOG7pW5nIFNTTCBjaOG6oXkgcGjDrWEgc2F1IOKAnCVz4oCdLiBI4buXIHRy4bujIOG7qW5nIGThu6VuZyBTU0wgY2jhuqF5IHBow61hICIKICJzYXU6IgogCi0jOiBodHRwLmM6MTA5MgorIzogaHR0cC5jOjEwOTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ291bGQgbm90IHNldCBTU0wgYmFja2VuZCB0byAnJXMnOiBjVVJMIHdhcyBidWlsdCB3aXRob3V0IFNTTCBiYWNrZW5kcyIKIG1zZ3N0ciAiIgogIktow7RuZyB0aOG7gyDEkeG6t3Qg4bupbmcgZOG7pW5nIGNo4bqheSBTU0wgcGjDrWEgc2F1IOKAnCVz4oCdOiBjVVJMIMSRxrDhu6NjIGJpw6puIGThu4tjaCBraMO0bmcgY8OzICIKICJz4buxIGjhu5cgdHLhu6Mg4bupbmcgZOG7pW5nIGNo4bqheSBwaMOtYSBzYXUgU1NMIgogCi0jOiBodHRwLmM6MTA5NgorIzogaHR0cC5jOjEwOTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ291bGQgbm90IHNldCBTU0wgYmFja2VuZCB0byAnJXMnOiBhbHJlYWR5IHNldCIKIG1zZ3N0ciAiS2jDtG5nIHRo4buDIMSR4bq3dCDhu6luZyBk4bulbmcgY2jhuqF5IHNhdSBTU0wgY2hvIOKAnCVz4oCdOiDEkcOjIMSR4bq3dCBy4buTaSIKIAotIzogaHR0cC5jOjE5NjUKKyM6IGh0dHAuYzoxOTY4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJ1bmFibGUgdG8gdXBkYXRlIHVybCBiYXNlIGZyb20gcmVkaXJlY3Rpb246XG4iCkBAIC0yMTEzMSwxMzAgKzIxMjI4LDEzMCBAQAogIiAgICAgIGjhu49pIGNobzogJXNcbiIKICIgY2h1eeG7g24gaMaw4bubbmc6ICVzIgogCi0jOiByZW1vdGUtY3VybC5jOjE1NworIzogcmVtb3RlLWN1cmwuYzoxNjYKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBxdW90aW5nIGluIHB1c2gtb3B0aW9uIHZhbHVlOiAnJXMnIgogbXNnc3RyICJzYWkgdHLDrWNoIGThuqtuIHRyb25nIGdpw6EgdHLhu4sgcHVzaC1vcHRpb24gOuKAnCVz4oCdIgogCi0jOiByZW1vdGUtY3VybC5jOjI1NAorIzogcmVtb3RlLWN1cmwuYzoyNjMKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXNpbmZvL3JlZnMgbm90IHZhbGlkOiBpcyB0aGlzIGEgZ2l0IHJlcG9zaXRvcnk/IgogbXNnc3RyICIlc2luZm8vcmVmcyBraMO0bmcgaOG7o3AgbOG7hzogxJHDonkgY8OzIHBo4bqjaSBsw6AgbeG7mXQga2hvIGdpdD8iCiAKLSM6IHJlbW90ZS1jdXJsLmM6MzU1CisjOiByZW1vdGUtY3VybC5jOjM2NAogbXNnaWQgImludmFsaWQgc2VydmVyIHJlc3BvbnNlOyBleHBlY3RlZCBzZXJ2aWNlLCBnb3QgZmx1c2ggcGFja2V0IgogbXNnc3RyICIiCiAixJHDoXAg4bupbmcgdOG7qyBtw6F5IHBo4bulYyB24bulIGtow7RuZyBo4bujcCBs4buHOyBj4bqnbiBk4buLY2ggduG7pSwgbmjGsG5nIGzhuqFpIG5o4bqtbiDEkcaw4bujYyBnw7NpICIKICJmbHVzaCIKIAotIzogcmVtb3RlLWN1cmwuYzozODYKKyM6IHJlbW90ZS1jdXJsLmM6Mzk1CiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgc2VydmVyIHJlc3BvbnNlOyBnb3QgJyVzJyIKIG1zZ3N0ciAidHLhuqMgduG7gSBj4bunYSBtw6F5IHBo4bulYyB24bulIGtow7RuZyBo4bujcCBs4buHOyBuaOG6rW4gxJHGsOG7o2MgJXMiCiAKLSM6IHJlbW90ZS1jdXJsLmM6NDQ2CisjOiByZW1vdGUtY3VybC5jOjQ1NQogIywgYy1mb3JtYXQKIG1zZ2lkICJyZXBvc2l0b3J5ICclcycgbm90IGZvdW5kIgogbXNnc3RyICJraMO0bmcgdMOsbSB0aOG6pXkga2hvIOKAnCVz4oCdIgogCi0jOiByZW1vdGUtY3VybC5jOjQ1MAorIzogcmVtb3RlLWN1cmwuYzo0NTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiQXV0aGVudGljYXRpb24gZmFpbGVkIGZvciAnJXMnIgogbXNnc3RyICJYw6FjIHRo4buxYyBn4bq3cCBs4buXaSBjaG8g4oCcJXPigJ0iCiAKLSM6IHJlbW90ZS1jdXJsLmM6NDU0CisjOiByZW1vdGUtY3VybC5jOjQ2MwogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gYWNjZXNzICclcyc6ICVzIgogbXNnc3RyICJraMO0bmcgdGjhu4MgdHJ1eSBj4bqtcCDigJwlc+KAnTogJXMiCiAKLSM6IHJlbW90ZS1jdXJsLmM6NDYwCisjOiByZW1vdGUtY3VybC5jOjQ2OQogIywgYy1mb3JtYXQKIG1zZ2lkICJyZWRpcmVjdGluZyB0byAlcyIKIG1zZ3N0ciAiY2h1eeG7g24gaMaw4bubbmcgxJHhur9uICVzIgogCi0jOiByZW1vdGUtY3VybC5jOjU4NAorIzogcmVtb3RlLWN1cmwuYzo1OTMKIG1zZ2lkICJzaG91bGRuJ3QgaGF2ZSBFT0Ygd2hlbiBub3QgZ2VudGxlIG9uIEVPRiIKIG1zZ3N0ciAia2jDtG5nIG7Dqm4gY8OzIEVPRiBraGkga2jDtG5nIGdlbnRsZSB0csOqbiBFT0YiCiAKLSM6IHJlbW90ZS1jdXJsLmM6NjY0CisjOiByZW1vdGUtY3VybC5jOjY3MwogbXNnaWQgInVuYWJsZSB0byByZXdpbmQgcnBjIHBvc3QgZGF0YSAtIHRyeSBpbmNyZWFzaW5nIGh0dHAucG9zdEJ1ZmZlciIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIHR1YSBs4bqhaSBk4buvIGxp4buHdSBwb3N0IHJwYyAtIHRo4butIHTEg25nIGh0dHAucG9zdEJ1ZmZlciIKIAotIzogcmVtb3RlLWN1cmwuYzo3MjQKKyM6IHJlbW90ZS1jdXJsLmM6NzMzCiAjLCBjLWZvcm1hdAogbXNnaWQgIlJQQyBmYWlsZWQ7ICVzIgogbXNnc3RyICJSUEMgZ+G6t3AgbOG7l2k7ICVzIgogCi0jOiByZW1vdGUtY3VybC5jOjc2NAorIzogcmVtb3RlLWN1cmwuYzo3NzMKIG1zZ2lkICJjYW5ub3QgaGFuZGxlIHB1c2hlcyB0aGlzIGJpZyIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIHjhu60gbMO9IMSR4bqpeSBjw6FpIGzhu5tuIG7DoHkiCiAKLSM6IHJlbW90ZS1jdXJsLmM6ODc5CisjOiByZW1vdGUtY3VybC5jOjg4OAogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgZGVmbGF0ZSByZXF1ZXN0OyB6bGliIGRlZmxhdGUgZXJyb3IgJWQiCiBtc2dzdHIgImtow7RuZyB0aOG7gyBnaeG6o2kgbsOpbiB5w6p1IGPhuqd1OyBjw7MgbOG7l2kga2hpIGdp4bqjaSBuw6luIGPhu6dhIHpsaWIgJWQiCiAKLSM6IHJlbW90ZS1jdXJsLmM6ODgzCisjOiByZW1vdGUtY3VybC5jOjg5MgogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgZGVmbGF0ZSByZXF1ZXN0OyB6bGliIGVuZCBlcnJvciAlZCIKIG1zZ3N0ciAia2jDtG5nIHRo4buDIGdp4bqjaSBuw6luIHnDqnUgY+G6p3U7IGPDsyBs4buXaSDhu58gY3Xhu5FpICVkIgogCi0jOiByZW1vdGUtY3VybC5jOjEwMTQKKyM6IHJlbW90ZS1jdXJsLmM6MTAyMwogbXNnaWQgImR1bWIgaHR0cCB0cmFuc3BvcnQgZG9lcyBub3Qgc3VwcG9ydCBzaGFsbG93IGNhcGFiaWxpdGllcyIKIG1zZ3N0ciAixJHhu5UgduG6rW4gY2h1eeG7g24gaHR0cCBraMO0bmcgaOG7lyB0cuG7oyBraOG6oyBuxINuZyBuw7RuZyIKIAotIzogcmVtb3RlLWN1cmwuYzoxMDI4CisjOiByZW1vdGUtY3VybC5jOjEwMzcKIG1zZ2lkICJmZXRjaCBmYWlsZWQuIgogbXNnc3RyICJs4bqleSB24buBIGfhurdwIGzhu5dpLiIKIAotIzogcmVtb3RlLWN1cmwuYzoxMDc2CisjOiByZW1vdGUtY3VybC5jOjEwODUKIG1zZ2lkICJjYW5ub3QgZmV0Y2ggYnkgc2hhMSBvdmVyIHNtYXJ0IGh0dHAiCiBtc2dzdHIgImtow7RuZyB0aOG7gyBs4bqleSB24buBIGLhurFuZyBzaGExIHRow7RuZyBxdWEgc21hcnQgaHR0cCIKIAotIzogcmVtb3RlLWN1cmwuYzoxMTIwIHJlbW90ZS1jdXJsLmM6MTEyNgorIzogcmVtb3RlLWN1cmwuYzoxMTI5IHJlbW90ZS1jdXJsLmM6MTEzNQogIywgYy1mb3JtYXQKIG1zZ2lkICJwcm90b2NvbCBlcnJvcjogZXhwZWN0ZWQgc2hhL3JlZiwgZ290ICclcyciCiBtc2dzdHIgImzhu5dpIGdpYW8gdGjhu6ljOiBj4bqnbiBzaGEvcmVmLCBuaMawbmcgbOG6oWkgbmjhuq1uIMSRxrDhu6NjIOKAnCVz4oCdIgogCi0jOiByZW1vdGUtY3VybC5jOjExMzggcmVtb3RlLWN1cmwuYzoxMjUyCisjOiByZW1vdGUtY3VybC5jOjExNDcgcmVtb3RlLWN1cmwuYzoxMjYxCiAjLCBjLWZvcm1hdAogbXNnaWQgImh0dHAgdHJhbnNwb3J0IGRvZXMgbm90IHN1cHBvcnQgJXMiCiBtc2dzdHIgInbhuq1uIGNodXnhu4NuIGh0dHAga2jDtG5nIGjhu5cgdHLhu6MgJXMiCiAKLSM6IHJlbW90ZS1jdXJsLmM6MTE3NAorIzogcmVtb3RlLWN1cmwuYzoxMTgzCiBtc2dpZCAiZ2l0LWh0dHAtcHVzaCBmYWlsZWQiCiBtc2dzdHIgImdpdC1odHRwLXB1c2ggZ+G6t3AgbOG7l2kiCiAKLSM6IHJlbW90ZS1jdXJsLmM6MTM2MAorIzogcmVtb3RlLWN1cmwuYzoxMzY3CiBtc2dpZCAicmVtb3RlLWN1cmw6IHVzYWdlOiBnaXQgcmVtb3RlLWN1cmwgPHJlbW90ZT4gWzx1cmw+XSIKIG1zZ3N0ciAicmVtb3RlLWN1cmw6IHVzYWdlOiBnaXQgcmVtb3RlLWN1cmwgPG3DoXkgY2jhu6c+IFs8dXJsPl0iCiAKLSM6IHJlbW90ZS1jdXJsLmM6MTM5MgorIzogcmVtb3RlLWN1cmwuYzoxMzk5CiBtc2dpZCAicmVtb3RlLWN1cmw6IGVycm9yIHJlYWRpbmcgY29tbWFuZCBzdHJlYW0gZnJvbSBnaXQiCiBtc2dzdHIgInJlbW90ZS1jdXJsOiBn4bq3cCBs4buXaSBraGkgxJHhu41jIGx14buTbmcgZOG7ryBsaeG7h3UgbOG7h25oIHThu6sgZ2l0IgogCi0jOiByZW1vdGUtY3VybC5jOjEzOTkKKyM6IHJlbW90ZS1jdXJsLmM6MTQwNgogbXNnaWQgInJlbW90ZS1jdXJsOiBmZXRjaCBhdHRlbXB0ZWQgd2l0aG91dCBhIGxvY2FsIHJlcG8iCiBtc2dzdHIgInJlbW90ZS1jdXJsOiDEkcOjIGPhu5EgZ+G6r25nIGZldGNoIG3DoCBraMO0bmcgY8OzIGtobyBu4buZaSBi4buZIgogCi0jOiByZW1vdGUtY3VybC5jOjE0MzkKKyM6IHJlbW90ZS1jdXJsLmM6MTQ0NgogIywgYy1mb3JtYXQKIG1zZ2lkICJyZW1vdGUtY3VybDogdW5rbm93biBjb21tYW5kICclcycgZnJvbSBnaXQiCiBtc2dzdHIgInJlbW90ZS1jdXJsOiBraMO0bmcgaGnhu4N1IGzhu4duaCDigJwlc+KAnSB04burIGdpdCIKIAotIzogbGlzdC1vYmplY3RzLWZpbHRlci1vcHRpb25zLmg6NjEKKyM6IGxpc3Qtb2JqZWN0cy1maWx0ZXItb3B0aW9ucy5oOjg1CiBtc2dpZCAiYXJncyIKIG1zZ3N0ciAiY8OhY190aGFtX3Phu5EiCiAKLSM6IGxpc3Qtb2JqZWN0cy1maWx0ZXItb3B0aW9ucy5oOjYyCisjOiBsaXN0LW9iamVjdHMtZmlsdGVyLW9wdGlvbnMuaDo4NgogbXNnaWQgIm9iamVjdCBmaWx0ZXJpbmciCiBtc2dzdHIgImzhu41jIMSR4buRaSB0xrDhu6NuZyIKIAotIzogcGFyc2Utb3B0aW9ucy5oOjE3MAorIzogcGFyc2Utb3B0aW9ucy5oOjE3OQogbXNnaWQgImV4cGlyeS1kYXRlIgogbXNnc3RyICJuZ8OgeSBo4bq/dCBo4bqhbiIKIAotIzogcGFyc2Utb3B0aW9ucy5oOjE4NAorIzogcGFyc2Utb3B0aW9ucy5oOjE5MwogbXNnaWQgIm5vLW9wIChiYWNrd2FyZCBjb21wYXRpYmlsaXR5KSIKIG1zZ3N0ciAibm8tb3AgKHTGsMahbmcgdGjDrWNoIG5nxrDhu6NjKSIKIApAQCAtMjM2NjksNiArMjM3NjYsNDcgQEAKIG1zZ2lkICJEbyB5b3UgcmVhbGx5IHdhbnQgdG8gc2VuZCAlcz8gW3l8Tl06ICIKIG1zZ3N0ciAiQuG6oW4gY8OzIHRo4buxYyBz4buxIG114buRbiBn4butaSAlcz8gW3l8Tl0oY8OzL0tIw5RORyk6ICIKIAorIywgYy1mb3JtYXQKKyN+IG1zZ2lkICJ1bmtub3duIGNvcmUudW50cmFja2VkQ2FjaGUgdmFsdWUgJyVzJzsgdXNpbmcgJ2tlZXAnIGRlZmF1bHQgdmFsdWUiCisjfiBtc2dzdHIgIiIKKyN+ICJraMO0bmcgaGnhu4N1IGdpw6EgdHLhu4sgY29yZS51bnRyYWNrZWRDYWNoZSDigJwlc+KAnTsgZMO5bmcgZ2nDoSB0cuG7iyBt4bq3YyDEkeG7i25oIOKAnGtlZXDigJ0iCisKKyN+IG1zZ2lkICJjYW5ub3QgY2hhbmdlIHBhcnRpYWwgY2xvbmUgcHJvbWlzb3IgcmVtb3RlIgorI34gbXNnc3RyICJraMO0bmcgdGjhu4MgdGhheSDEkeG7lWkgbmjDom4gYuG6o24gdOG7q25nIHBo4bqnbiBtw6F5IGNo4bunIHByb21pc29yIgorCisjfiBtc2dpZCAiZXJyb3IgYnVpbGRpbmcgdHJlZXMiCisjfiBtc2dzdHIgImfhurdwIGzhu5dpIGtoaSB4w6J5IGThu7FuZyBjw6J5IgorCisjLCBjLWZvcm1hdAorI34gbXNnaWQgImludmFsaWQgZGF0ZSBmb3JtYXQgJyVzJyBpbiAnJXMnIgorI34gbXNnc3RyICLEkeG7i25oIGThuqFuZyBuZ8OgeSB0aMOhbmcga2jDtG5nIGjhu6NwIGzhu4cg4oCcJXPigJ0gdHJvbmcg4oCcJXPigJ0iCisKKyN+IG1zZ2lkICJ3cml0aW5nIHJvb3QgY29tbWl0IgorI34gbXNnc3RyICJnaGkgY2h1eeG7g24gZ2lhbyBn4buRYyIKKworIywgYy1mb3JtYXQKKyN+IG1zZ2lkICJzdGFnZWQgY2hhbmdlcyBpbiB0aGUgZm9sbG93aW5nIGZpbGVzIG1heSBiZSBsb3N0OiAlcyIKKyN+IG1zZ3N0ciAiIgorI34gImPDoWMgdGhheSDEkeG7lWkgxJHDoyDEkcawYSBsw6puIGLhu4cgcGjDs25nIHRyb25nIGPDoWMgdOG6rXAgdGluIHNhdSDEkcOieSBjw7MgdGjhu4MgYuG7iyBt4bqldDogIgorI34gIiVzIgorCisjfiBtc2dpZCAiIgorI34gIi0tZmlsdGVyIGNhbiBvbmx5IGJlIHVzZWQgd2l0aCB0aGUgcmVtb3RlIGNvbmZpZ3VyZWQgaW4gZXh0ZW5zaW9ucy4iCisjfiAicGFydGlhbENsb25lIgorI34gbXNnc3RyICIiCisjfiAiLS1maWx0ZXIgY2jhu4kgY8OzIHRo4buDIMSRxrDhu6NjIGTDuW5nIHbhu5tpIG3DoXkgY2jhu6cgxJHGsOG7o2MgY+G6pXUgaMOsbmggYuG6sW5nIGV4dGVuc2lvbnMuIgorI34gInBhcnRpYWxDbG9uZSIKKworI34gbXNnaWQgInZlcmlmeSBjb21taXQtbXNnIGhvb2siCisjfiBtc2dzdHIgInRo4bqpbSB0cmEgbcOzYyAoaG9vaykgY29tbWl0LW1zZyIKKworI34gbXNnaWQgImNhbm5vdCBjb21iaW5lICctLXJlYmFzZS1tZXJnZXMnIHdpdGggJy0tc3RyYXRlZ3ktb3B0aW9uJyIKKyN+IG1zZ3N0ciAia2jDtG5nIHRo4buDIGvhur90IGjhu6NwIOKAnC0tcmViYXNlLW1lcmdlc+KAnSB24bubaSDigJwtLXN0cmF0ZWd5LW9wdGlvbuKAnSIKKworIywgYy1mb3JtYXQKKyN+IG1zZ2lkICJpbnZhbGlkIHNwYXJzZSB2YWx1ZSAnJXMnIgorI34gbXNnc3RyICJnacOhIHRy4buLIHNwYXJzZSBraMO0bmcgaOG7o3AgbOG7hyDigJwlc+KAnSIKKwogI34gbXNnaWQgIiIKICN+ICJGZXRjaCBub3JtYWxseSBpbmRpY2F0ZXMgd2hpY2ggYnJhbmNoZXMgaGFkIGEgZm9yY2VkIHVwZGF0ZSwgYnV0IHRoYXQgIgogI34gImNoZWNrIGhhcyBiZWVuIGRpc2FibGVkLiIKQEAgLTI0NTkwLDkgKzI0NzI4LDYgQEAKICN+IG1zZ2lkICJubyBzdWNoIHVzZXIiCiAjfiBtc2dzdHIgImtow7RuZyBjw7MgbmfGsOG7nWkgZMO5bmcgbmjGsCB24bqteSIKIAotI34gbXNnaWQgIk1pc3NpbmcgYXV0aG9yOiAlcyIKLSN+IG1zZ3N0ciAiVGhp4bq/dSB0w6puIHTDoWMgZ2nhuqM6ICVzIgotCiAjfiBtc2dpZCAiVGVzdGluZyAiCiAjfiBtc2dzdHIgIsSQYW5nIHRo4butIgogCkBAIC0yNDY0NSw5ICsyNDc4MCw2IEBACiAjfiBtc2dpZCAib3B0aW9uICVzIGRvZXMgbm90IGFjY2VwdCBuZWdhdGl2ZSBmb3JtIgogI34gbXNnc3RyICJ0w7l5IGNo4buNbiAlcyBraMO0bmcgY2jhuqVwIG5o4bqtbiBk4bqhbmcgdGjhu6ljIMOibSIKIAotI34gbXNnaWQgInVuYWJsZSB0byBwYXJzZSB2YWx1ZSAnJXMnIGZvciBvcHRpb24gJXMiCi0jfiBtc2dzdHIgImtow7RuZyB0aOG7gyBwaMOibiB0w61jaCBnacOhIHRy4buLIOKAnCVz4oCdIGNobyB0w7l5IGNo4buNbiAlcyIKLQogI34gbXNnaWQgIi1iIGFuZCAtQiBhcmUgbXV0dWFsbHkgZXhjbHVzaXZlIgogI34gbXNnc3RyICItYiB2w6AgLUIgbG/huqFpIHThu6sgbOG6q24gbmhhdS4iCiAKZGlmZiAtLWdpdCBhL3BvL3poX0NOLnBvIGIvcG8vemhfQ04ucG8KaW5kZXggYzZiZGIzZS4uYmEwM2IxMCAxMDA2NDQKLS0tIGEvcG8vemhfQ04ucG8KKysrIGIvcG8vemhfQ04ucG8KQEAgLTEzOSw4ICsxMzksOCBAQAogbXNnc3RyICIiCiAiUHJvamVjdC1JZC1WZXJzaW9uOiBHaXRcbiIKICJSZXBvcnQtTXNnaWQtQnVncy1UbzogR2l0IE1haWxpbmcgTGlzdCA8Z2l0QHZnZXIua2VybmVsLm9yZz5cbiIKLSJQT1QtQ3JlYXRpb24tRGF0ZTogMjAxOS0wOC0xMCAyMDoxMiswODAwXG4iCi0iUE8tUmV2aXNpb24tRGF0ZTogMjAxOS0wOC0xMyAyMToxNiswODAwXG4iCisiUE9ULUNyZWF0aW9uLURhdGU6IDIwMTktMTAtMjggMTM6MTkrMDgwMFxuIgorIlBPLVJldmlzaW9uLURhdGU6IDIwMTktMTAtMzAgMTQ6NTgrMDgwMFxuIgogIkxhc3QtVHJhbnNsYXRvcjogSmlhbmcgWGluIDx3b3JsZGhlbGxvLm5ldEBnbWFpbC5jb20+XG4iCiAiTGFuZ3VhZ2UtVGVhbTogR2l0SHViIDxodHRwczovL2dpdGh1Yi5jb20vamlhbmd4aW4vZ2l0Lz5cbiIKICJMYW5ndWFnZTogemhfQ05cbiIKQEAgLTE5MSw3ICsxOTEsNyBAQAogbXNnaWQgIkV4aXRpbmcgYmVjYXVzZSBvZiBhbiB1bnJlc29sdmVkIGNvbmZsaWN0LiIKIG1zZ3N0ciAi5Zug5Li65a2Y5Zyo5pyq6Kej5Yaz55qE5Yay56qB6ICM6YCA5Ye644CCIgogCi0jOiBhZHZpY2UuYzoxOTMgYnVpbHRpbi9tZXJnZS5jOjEzMjcKKyM6IGFkdmljZS5jOjE5MyBidWlsdGluL21lcmdlLmM6MTMzMgogbXNnaWQgIllvdSBoYXZlIG5vdCBjb25jbHVkZWQgeW91ciBtZXJnZSAoTUVSR0VfSEVBRCBleGlzdHMpLiIKIG1zZ3N0ciAi5oKo5bCa5pyq57uT5p2f5oKo55qE5ZCI5bm277yI5a2Y5ZyoIE1FUkdFX0hFQUTvvInjgIIiCiAKQEAgLTMyNSwxNyArMzI1LDcgQEAKIG1zZ2lkICJpbmNvbnNpc3RlbnQgaGVhZGVyIGxpbmVzICVkIGFuZCAlZCIKIG1zZ3N0ciAi5LiN5LiA6Ie055qE5paH5Lu25aS077yMJWQg6KGM5ZKMICVkIOihjCIKIAotIzogYXBwbHkuYzoxNDYwCi0jLCBjLWZvcm1hdAotbXNnaWQgInJlY291bnQ6IHVuZXhwZWN0ZWQgbGluZTogJS4qcyIKLW1zZ3N0ciAicmVjb3VudO+8muaEj+WklueahOihjO+8miUuKnMiCi0KLSM6IGFwcGx5LmM6MTUyOQotIywgYy1mb3JtYXQKLW1zZ2lkICJwYXRjaCBmcmFnbWVudCB3aXRob3V0IGhlYWRlciBhdCBsaW5lICVkOiAlLipzIgotbXNnc3RyICLnrKwgJWQg6KGM55qE6KGl5LiB54mH5q615rKh5pyJ5aS05L+h5oGv77yaJS4qcyIKLQotIzogYXBwbHkuYzoxNTUxCisjOiBhcHBseS5jOjEzNzIKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogImdpdCBkaWZmIGhlYWRlciBsYWNrcyBmaWxlbmFtZSBpbmZvcm1hdGlvbiB3aGVuIHJlbW92aW5nICVkIGxlYWRpbmcgcGF0aG5hbWUgIgpAQCAtMzQ2LDgyICszMzYsOTIgQEAKIG1zZ3N0clswXSAi5b2T56e76ZmkICVkIOS4quWJjeWvvOi3r+W+hOWQjiBnaXQgZGlmZiDlpLTnvLrkuY/mlofku7blkI3kv6Hmga/vvIjnrKwgJWQg6KGM77yJIgogbXNnc3RyWzFdICLlvZPnp7vpmaQgJWQg5Liq5YmN5a+86Lev5b6E5ZCOIGdpdCBkaWZmIOWktOe8uuS5j+aWh+S7tuWQjeS/oeaBr++8iOesrCAlZCDooYzvvIkiCiAKLSM6IGFwcGx5LmM6MTU2NAorIzogYXBwbHkuYzoxMzg1CiAjLCBjLWZvcm1hdAogbXNnaWQgImdpdCBkaWZmIGhlYWRlciBsYWNrcyBmaWxlbmFtZSBpbmZvcm1hdGlvbiAobGluZSAlZCkiCiBtc2dzdHIgImdpdCBkaWZmIOeahOWktOS/oeaBr+S4ree8uuS5j+aWh+S7tuWQjeS/oeaBr++8iOesrCAlZCDooYzvvIkiCiAKLSM6IGFwcGx5LmM6MTc1MgorIzogYXBwbHkuYzoxNDgxCisjLCBjLWZvcm1hdAorbXNnaWQgInJlY291bnQ6IHVuZXhwZWN0ZWQgbGluZTogJS4qcyIKK21zZ3N0ciAicmVjb3VudO+8muaEj+WklueahOihjO+8miUuKnMiCisKKyM6IGFwcGx5LmM6MTU1MAorIywgYy1mb3JtYXQKK21zZ2lkICJwYXRjaCBmcmFnbWVudCB3aXRob3V0IGhlYWRlciBhdCBsaW5lICVkOiAlLipzIgorbXNnc3RyICLnrKwgJWQg6KGM55qE6KGl5LiB54mH5q615rKh5pyJ5aS05L+h5oGv77yaJS4qcyIKKworIzogYXBwbHkuYzoxNzUzCiBtc2dpZCAibmV3IGZpbGUgZGVwZW5kcyBvbiBvbGQgY29udGVudHMiCiBtc2dzdHIgIuaWsOaWh+S7tuS+nei1luaXp+WGheWuuSIKIAotIzogYXBwbHkuYzoxNzU0CisjOiBhcHBseS5jOjE3NTUKIG1zZ2lkICJkZWxldGVkIGZpbGUgc3RpbGwgaGFzIGNvbnRlbnRzIgogbXNnc3RyICLliKDpmaTnmoTmlofku7bku43mnInlhoXlrrkiCiAKLSM6IGFwcGx5LmM6MTc4OAorIzogYXBwbHkuYzoxNzg5CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvcnJ1cHQgcGF0Y2ggYXQgbGluZSAlZCIKIG1zZ3N0ciAi6KGl5LiB5Zyo56ysICVkIOihjOaNn+WdjyIKIAotIzogYXBwbHkuYzoxODI1CisjOiBhcHBseS5jOjE4MjYKICMsIGMtZm9ybWF0CiBtc2dpZCAibmV3IGZpbGUgJXMgZGVwZW5kcyBvbiBvbGQgY29udGVudHMiCiBtc2dzdHIgIuaWsOaWh+S7tiAlcyDkvp3otZbml6flhoXlrrkiCiAKLSM6IGFwcGx5LmM6MTgyNworIzogYXBwbHkuYzoxODI4CiAjLCBjLWZvcm1hdAogbXNnaWQgImRlbGV0ZWQgZmlsZSAlcyBzdGlsbCBoYXMgY29udGVudHMiCiBtc2dzdHIgIuWIoOmZpOeahOaWh+S7tiAlcyDku43mnInlhoXlrrkiCiAKLSM6IGFwcGx5LmM6MTgzMAorIzogYXBwbHkuYzoxODMxCiAjLCBjLWZvcm1hdAogbXNnaWQgIioqIHdhcm5pbmc6IGZpbGUgJXMgYmVjb21lcyBlbXB0eSBidXQgaXMgbm90IGRlbGV0ZWQiCiBtc2dzdHIgIioqIOitpuWRiu+8muaWh+S7tiAlcyDmiJDkuLrnqbrmlofku7bkvYblubbmnKrliKDpmaQiCiAKLSM6IGFwcGx5LmM6MTk3NworIzogYXBwbHkuYzoxOTc4CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvcnJ1cHQgYmluYXJ5IHBhdGNoIGF0IGxpbmUgJWQ6ICUuKnMiCiBtc2dzdHIgIuS6jOi/m+WItuihpeS4geWcqOesrCAlZCDooYzmjZ/lnY/vvJolLipzIgogCi0jOiBhcHBseS5jOjIwMTQKKyM6IGFwcGx5LmM6MjAxNQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bnJlY29nbml6ZWQgYmluYXJ5IHBhdGNoIGF0IGxpbmUgJWQiCiBtc2dzdHIgIuacquiDveivhuWIq+eahOS6jOi/m+WItuihpeS4geS9jeS6juesrCAlZCDooYwiCiAKLSM6IGFwcGx5LmM6MjE3NgorIzogYXBwbHkuYzoyMTc3CiAjLCBjLWZvcm1hdAogbXNnaWQgInBhdGNoIHdpdGggb25seSBnYXJiYWdlIGF0IGxpbmUgJWQiCiBtc2dzdHIgIuihpeS4geaWh+S7tueahOesrCAlZCDooYzlj6rmnInlnoPlnL7mlbDmja4iCiAKLSM6IGFwcGx5LmM6MjI2MgorIzogYXBwbHkuYzoyMjYzCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byByZWFkIHN5bWxpbmsgJXMiCiBtc2dzdHIgIuaXoOazleivu+WPluespuWPt+mTvuaOpSAlcyIKIAotIzogYXBwbHkuYzoyMjY2CisjOiBhcHBseS5jOjIyNjcKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIG9wZW4gb3IgcmVhZCAlcyIKIG1zZ3N0ciAi5LiN6IO95omT5byA5oiW6K+75Y+WICVzIgogCi0jOiBhcHBseS5jOjI5MjUKKyM6IGFwcGx5LmM6MjkyNgogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIHN0YXJ0IG9mIGxpbmU6ICclYyciCiBtc2dzdHIgIuaXoOaViOeahOihjOmmluWtl+espu+8miclYyciCiAKLSM6IGFwcGx5LmM6MzA0NgorIzogYXBwbHkuYzozMDQ3CiAjLCBjLWZvcm1hdAogbXNnaWQgIkh1bmsgIyVkIHN1Y2NlZWRlZCBhdCAlZCAob2Zmc2V0ICVkIGxpbmUpLiIKIG1zZ2lkX3BsdXJhbCAiSHVuayAjJWQgc3VjY2VlZGVkIGF0ICVkIChvZmZzZXQgJWQgbGluZXMpLiIKIG1zZ3N0clswXSAi5Z2XICMlZCDmiJDlip/lupTnlKjkuo4gJWTvvIjlgY/np7sgJWQg6KGM77yJIgogbXNnc3RyWzFdICLlnZcgIyVkIOaIkOWKn+W6lOeUqOS6jiAlZO+8iOWBj+enuyAlZCDooYzvvIkiCiAKLSM6IGFwcGx5LmM6MzA1OAorIzogYXBwbHkuYzozMDU5CiAjLCBjLWZvcm1hdAogbXNnaWQgIkNvbnRleHQgcmVkdWNlZCB0byAoJWxkLyVsZCkgdG8gYXBwbHkgZnJhZ21lbnQgYXQgJWQiCiBtc2dzdHIgIuS4iuS4i+aWh+WHj+WwkeWIsO+8iCVsZC8lbGTvvInku6XlnKjnrKwgJWQg6KGM5bqU55So6KGl5LiB54mH5q61IgogCi0jOiBhcHBseS5jOjMwNjQKKyM6IGFwcGx5LmM6MzA2NQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAid2hpbGUgc2VhcmNoaW5nIGZvcjpcbiIKQEAgLTQzMCw0NDUgKzQzMCw0NDUgQEAKICLlvZPmn6Xor6LvvJpcbiIKICIlLipzIgogCi0jOiBhcHBseS5jOjMwODYKKyM6IGFwcGx5LmM6MzA4NwogIywgYy1mb3JtYXQKIG1zZ2lkICJtaXNzaW5nIGJpbmFyeSBwYXRjaCBkYXRhIGZvciAnJXMnIgogbXNnc3RyICLnvLrlpLEgJyVzJyDnmoTkuozov5vliLbooaXkuIHmlbDmja4iCiAKLSM6IGFwcGx5LmM6MzA5NAorIzogYXBwbHkuYzozMDk1CiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCByZXZlcnNlLWFwcGx5IGEgYmluYXJ5IHBhdGNoIHdpdGhvdXQgdGhlIHJldmVyc2UgaHVuayB0byAnJXMnIgogbXNnc3RyICLkuI3og73lj43lkJHlupTnlKjkuIDkuKrnvLrlsJHliLAgJyVzJyDnmoTlj43lkJHmlbDmja7lnZfnmoTkuozov5vliLbooaXkuIEiCiAKLSM6IGFwcGx5LmM6MzE0MQorIzogYXBwbHkuYzozMTQyCiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCBhcHBseSBiaW5hcnkgcGF0Y2ggdG8gJyVzJyB3aXRob3V0IGZ1bGwgaW5kZXggbGluZSIKIG1zZ3N0ciAi5LiN6IO95ZyoICclcycg5LiK5bqU55So5rKh5pyJ5a6M5pW057Si5byV6KGM55qE5LqM6L+b5Yi26KGl5LiBIgogCi0jOiBhcHBseS5jOjMxNTEKKyM6IGFwcGx5LmM6MzE1MgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAidGhlIHBhdGNoIGFwcGxpZXMgdG8gJyVzJyAoJXMpLCB3aGljaCBkb2VzIG5vdCBtYXRjaCB0aGUgY3VycmVudCBjb250ZW50cy4iCiBtc2dzdHIgIuihpeS4geW6lOeUqOWIsCAnJXMn77yIJXPvvInvvIzkvYbmmK/lkozlvZPliY3lhoXlrrnkuI3ljLnphY3jgIIiCiAKLSM6IGFwcGx5LmM6MzE1OQorIzogYXBwbHkuYzozMTYwCiAjLCBjLWZvcm1hdAogbXNnaWQgInRoZSBwYXRjaCBhcHBsaWVzIHRvIGFuIGVtcHR5ICclcycgYnV0IGl0IGlzIG5vdCBlbXB0eSIKIG1zZ3N0ciAi6KGl5LiB5bqU55So5Yiw56m65paH5Lu2ICclcyfvvIzkvYblhbblubbpnZ7nqbrmlofku7YiCiAKLSM6IGFwcGx5LmM6MzE3NworIzogYXBwbHkuYzozMTc4CiAjLCBjLWZvcm1hdAogbXNnaWQgInRoZSBuZWNlc3NhcnkgcG9zdGltYWdlICVzIGZvciAnJXMnIGNhbm5vdCBiZSByZWFkIgogbXNnc3RyICLml6Dms5Xor7vlj5YgJyUyJHMnIOW/hemcgOeahOebruagh+aWh+S7tiAlMSRzIgogCi0jOiBhcHBseS5jOjMxOTAKKyM6IGFwcGx5LmM6MzE5MQogIywgYy1mb3JtYXQKIG1zZ2lkICJiaW5hcnkgcGF0Y2ggZG9lcyBub3QgYXBwbHkgdG8gJyVzJyIKIG1zZ3N0ciAi5LqM6L+b5Yi26KGl5LiB5pyq5bqU55So5YiwICclcyciCiAKLSM6IGFwcGx5LmM6MzE5NgorIzogYXBwbHkuYzozMTk3CiAjLCBjLWZvcm1hdAogbXNnaWQgImJpbmFyeSBwYXRjaCB0byAnJXMnIGNyZWF0ZXMgaW5jb3JyZWN0IHJlc3VsdCAoZXhwZWN0aW5nICVzLCBnb3QgJXMpIgogbXNnc3RyICLliLAgJyVzJyDnmoTkuozov5vliLbooaXkuIHkuqfnlJ/kuobkuI3mraPnoa7nmoTnu5PmnpzvvIjlupTkuLogJXPvvIzljbTkuLogJXPvvIkiCiAKLSM6IGFwcGx5LmM6MzIxNworIzogYXBwbHkuYzozMjE4CiAjLCBjLWZvcm1hdAogbXNnaWQgInBhdGNoIGZhaWxlZDogJXM6JWxkIgogbXNnc3RyICLmiZPooaXkuIHlpLHotKXvvJolczolbGQiCiAKLSM6IGFwcGx5LmM6MzM0MAorIzogYXBwbHkuYzozMzQxCiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCBjaGVja291dCAlcyIKIG1zZ3N0ciAi5LiN6IO95qOA5Ye6ICVzIgogCi0jOiBhcHBseS5jOjMzOTIgYXBwbHkuYzozNDAzIGFwcGx5LmM6MzQ0OSBtaWR4LmM6NjIgc2V0dXAuYzoyNzkKKyM6IGFwcGx5LmM6MzM5MyBhcHBseS5jOjM0MDQgYXBwbHkuYzozNDUwIG1pZHguYzo2MSBzZXR1cC5jOjI4MAogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gcmVhZCAlcyIKIG1zZ3N0ciAi5peg5rOV6K+75Y+WICVzIgogCi0jOiBhcHBseS5jOjM0MDAKKyM6IGFwcGx5LmM6MzQwMQogIywgYy1mb3JtYXQKIG1zZ2lkICJyZWFkaW5nIGZyb20gJyVzJyBiZXlvbmQgYSBzeW1ib2xpYyBsaW5rIgogbXNnc3RyICLor7vlj5bkvY3kuo7nrKblj7fpk77mjqXkuK3nmoQgJyVzJyIKIAotIzogYXBwbHkuYzozNDI5IGFwcGx5LmM6MzY3MgorIzogYXBwbHkuYzozNDMwIGFwcGx5LmM6MzY3MwogIywgYy1mb3JtYXQKIG1zZ2lkICJwYXRoICVzIGhhcyBiZWVuIHJlbmFtZWQvZGVsZXRlZCIKIG1zZ3N0ciAi6Lev5b6EICVzIOW3sue7j+iiq+mHjeWRveWQjS/liKDpmaQiCiAKLSM6IGFwcGx5LmM6MzUxNSBhcHBseS5jOjM2ODcKKyM6IGFwcGx5LmM6MzUxNiBhcHBseS5jOjM2ODgKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXM6IGRvZXMgbm90IGV4aXN0IGluIGluZGV4IgogbXNnc3RyICIlc++8muS4jeWtmOWcqOS6jue0ouW8leS4rSIKIAotIzogYXBwbHkuYzozNTI0IGFwcGx5LmM6MzY5NQorIzogYXBwbHkuYzozNTI1IGFwcGx5LmM6MzY5NgogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogZG9lcyBub3QgbWF0Y2ggaW5kZXgiCiBtc2dzdHIgIiVz77ya5ZKM57Si5byV5LiN5Yy56YWNIgogCi0jOiBhcHBseS5jOjM1NTkKKyM6IGFwcGx5LmM6MzU2MAogbXNnaWQgInJlcG9zaXRvcnkgbGFja3MgdGhlIG5lY2Vzc2FyeSBibG9iIHRvIGZhbGwgYmFjayBvbiAzLXdheSBtZXJnZS4iCiBtc2dzdHIgIuS7k+W6k+e8uuS5j+W/heimgeeahOaVsOaNruWvueixoeS7pei/m+ihjOS4ieaWueWQiOW5tuOAgiIKIAotIzogYXBwbHkuYzozNTYyCisjOiBhcHBseS5jOjM1NjMKICMsIGMtZm9ybWF0CiBtc2dpZCAiRmFsbGluZyBiYWNrIHRvIHRocmVlLXdheSBtZXJnZS4uLlxuIgogbXNnc3RyICLlm57okL3liLDkuInmlrnlkIjlubYuLi5cbiIKIAotIzogYXBwbHkuYzozNTc4IGFwcGx5LmM6MzU4MgorIzogYXBwbHkuYzozNTc5IGFwcGx5LmM6MzU4MwogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgcmVhZCB0aGUgY3VycmVudCBjb250ZW50cyBvZiAnJXMnIgogbXNnc3RyICLml6Dms5Xor7vlj5YgJyVzJyDnmoTlvZPliY3lhoXlrrkiCiAKLSM6IGFwcGx5LmM6MzU5NAorIzogYXBwbHkuYzozNTk1CiAjLCBjLWZvcm1hdAogbXNnaWQgIkZhaWxlZCB0byBmYWxsIGJhY2sgb24gdGhyZWUtd2F5IG1lcmdlLi4uXG4iCiBtc2dzdHIgIuaXoOazleWbnuiQveWIsOS4ieaWueWQiOW5ti4uLlxuIgogCi0jOiBhcHBseS5jOjM2MDgKKyM6IGFwcGx5LmM6MzYwOQogIywgYy1mb3JtYXQKIG1zZ2lkICJBcHBsaWVkIHBhdGNoIHRvICclcycgd2l0aCBjb25mbGljdHMuXG4iCiBtc2dzdHIgIuW6lOeUqOihpeS4geWIsCAnJXMnIOWtmOWcqOWGsueqgeOAglxuIgogCi0jOiBhcHBseS5jOjM2MTMKKyM6IGFwcGx5LmM6MzYxNAogIywgYy1mb3JtYXQKIG1zZ2lkICJBcHBsaWVkIHBhdGNoIHRvICclcycgY2xlYW5seS5cbiIKIG1zZ3N0ciAi5oiQ5Yqf5bqU55So6KGl5LiB5YiwICclcyfjgIJcbiIKIAotIzogYXBwbHkuYzozNjM5CisjOiBhcHBseS5jOjM2NDAKIG1zZ2lkICJyZW1vdmFsIHBhdGNoIGxlYXZlcyBmaWxlIGNvbnRlbnRzIgogbXNnc3RyICLnp7vpmaTooaXkuIHku43nlZnkuIvkuobmlofku7blhoXlrrkiCiAKLSM6IGFwcGx5LmM6MzcxMgorIzogYXBwbHkuYzozNzEzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiB3cm9uZyB0eXBlIgogbXNnc3RyICIlc++8mumUmeivr+exu+WeiyIKIAotIzogYXBwbHkuYzozNzE0CisjOiBhcHBseS5jOjM3MTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgaGFzIHR5cGUgJW8sIGV4cGVjdGVkICVvIgogbXNnc3RyICIlcyDnmoTnsbvlnovmmK8gJW/vvIzlupTkuLogJW8iCiAKLSM6IGFwcGx5LmM6Mzg2NSBhcHBseS5jOjM4NjcgcmVhZC1jYWNoZS5jOjgzMCByZWFkLWNhY2hlLmM6ODU2CisjOiBhcHBseS5jOjM4NjYgYXBwbHkuYzozODY4IHJlYWQtY2FjaGUuYzo4MzAgcmVhZC1jYWNoZS5jOjg1NgogIzogcmVhZC1jYWNoZS5jOjEzMDkKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBwYXRoICclcyciCiBtc2dzdHIgIuaXoOaViOi3r+W+hCAnJXMnIgogCi0jOiBhcHBseS5jOjM5MjMKKyM6IGFwcGx5LmM6MzkyNAogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogYWxyZWFkeSBleGlzdHMgaW4gaW5kZXgiCiBtc2dzdHIgIiVz77ya5bey57uP5a2Y5Zyo5LqO57Si5byV5LitIgogCi0jOiBhcHBseS5jOjM5MjYKKyM6IGFwcGx5LmM6MzkyNwogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogYWxyZWFkeSBleGlzdHMgaW4gd29ya2luZyBkaXJlY3RvcnkiCiBtc2dzdHIgIiVz77ya5bey57uP5a2Y5Zyo5LqO5bel5L2c5Yy65LitIgogCi0jOiBhcHBseS5jOjM5NDYKKyM6IGFwcGx5LmM6Mzk0NwogIywgYy1mb3JtYXQKIG1zZ2lkICJuZXcgbW9kZSAoJW8pIG9mICVzIGRvZXMgbm90IG1hdGNoIG9sZCBtb2RlICglbykiCiBtc2dzdHIgIiUyJHMg55qE5paw5qih5byP77yIJTEkb++8ieWSjOaXp+aooeW8j++8iCUzJG/vvInkuI3ljLnphY0iCiAKLSM6IGFwcGx5LmM6Mzk1MQorIzogYXBwbHkuYzozOTUyCiAjLCBjLWZvcm1hdAogbXNnaWQgIm5ldyBtb2RlICglbykgb2YgJXMgZG9lcyBub3QgbWF0Y2ggb2xkIG1vZGUgKCVvKSBvZiAlcyIKIG1zZ3N0ciAiJTIkcyDnmoTmlrDmqKHlvI/vvIglMSRv77yJ5ZKMICU0JHMg55qE5pen5qih5byP77yIJTMkb++8ieS4jeWMuemFjSIKIAotIzogYXBwbHkuYzozOTcxCisjOiBhcHBseS5jOjM5NzIKICMsIGMtZm9ybWF0CiBtc2dpZCAiYWZmZWN0ZWQgZmlsZSAnJXMnIGlzIGJleW9uZCBhIHN5bWJvbGljIGxpbmsiCiBtc2dzdHIgIuWPl+W9seWTjeeahOaWh+S7tiAnJXMnIOS9jeS6juespuWPt+mTvuaOpeS4rSIKIAotIzogYXBwbHkuYzozOTc1CisjOiBhcHBseS5jOjM5NzYKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXM6IHBhdGNoIGRvZXMgbm90IGFwcGx5IgogbXNnc3RyICIlc++8muihpeS4geacquW6lOeUqCIKIAotIzogYXBwbHkuYzozOTkwCisjOiBhcHBseS5jOjM5OTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ2hlY2tpbmcgcGF0Y2ggJXMuLi4iCiBtc2dzdHIgIuato+WcqOajgOafpeihpeS4gSAlcy4uLiIKIAotIzogYXBwbHkuYzo0MDgyCisjOiBhcHBseS5jOjQwODMKICMsIGMtZm9ybWF0CiBtc2dpZCAic2hhMSBpbmZvcm1hdGlvbiBpcyBsYWNraW5nIG9yIHVzZWxlc3MgZm9yIHN1Ym1vZHVsZSAlcyIKIG1zZ3N0ciAi5a2Q5qih57uEICVzIOeahCBzaGExIOS/oeaBr+e8uuWkseaIluaXoOaViCIKIAotIzogYXBwbHkuYzo0MDg5CisjOiBhcHBseS5jOjQwOTAKICMsIGMtZm9ybWF0CiBtc2dpZCAibW9kZSBjaGFuZ2UgZm9yICVzLCB3aGljaCBpcyBub3QgaW4gY3VycmVudCBIRUFEIgogbXNnc3RyICIlcyDnmoTmqKHlvI/lj5jmm7TvvIzkvYblroPkuI3lnKjlvZPliY0gSEVBRCDkuK0iCiAKLSM6IGFwcGx5LmM6NDA5MgorIzogYXBwbHkuYzo0MDkzCiAjLCBjLWZvcm1hdAogbXNnaWQgInNoYTEgaW5mb3JtYXRpb24gaXMgbGFja2luZyBvciB1c2VsZXNzICglcykuIgogbXNnc3RyICJzaGExIOS/oeaBr+e8uuWkseaIluaXoOaViO+8iCVz77yJ44CCIgogCi0jOiBhcHBseS5jOjQwOTcgYnVpbHRpbi9jaGVja291dC5jOjI3OCBidWlsdGluL3Jlc2V0LmM6MTQzCisjOiBhcHBseS5jOjQwOTggYnVpbHRpbi9jaGVja291dC5jOjI3OSBidWlsdGluL3Jlc2V0LmM6MTQzCiAjLCBjLWZvcm1hdAogbXNnaWQgIm1ha2VfY2FjaGVfZW50cnkgZmFpbGVkIGZvciBwYXRoICclcyciCiBtc2dzdHIgIuWvuei3r+W+hCAnJXMnIOeahCBtYWtlX2NhY2hlX2VudHJ5IOaTjeS9nOWksei0pSIKIAotIzogYXBwbHkuYzo0MTAxCisjOiBhcHBseS5jOjQxMDIKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGFkZCAlcyB0byB0ZW1wb3JhcnkgaW5kZXgiCiBtc2dzdHIgIuS4jeiDveWcqOS4tOaXtue0ouW8leS4rea3u+WKoCAlcyIKIAotIzogYXBwbHkuYzo0MTExCisjOiBhcHBseS5jOjQxMTIKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHdyaXRlIHRlbXBvcmFyeSBpbmRleCB0byAlcyIKIG1zZ3N0ciAi5LiN6IO95oqK5Li05pe257Si5byV5YaZ5YWl5YiwICVzIgogCi0jOiBhcHBseS5jOjQyNDkKKyM6IGFwcGx5LmM6NDI1MAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gcmVtb3ZlICVzIGZyb20gaW5kZXgiCiBtc2dzdHIgIuS4jeiDveS7jue0ouW8leS4reenu+mZpCAlcyIKIAotIzogYXBwbHkuYzo0MjgzCisjOiBhcHBseS5jOjQyODQKICMsIGMtZm9ybWF0CiBtc2dpZCAiY29ycnVwdCBwYXRjaCBmb3Igc3VibW9kdWxlICVzIgogbXNnc3RyICLlrZDmqKHnu4QgJXMg5o2f5Z2P55qE6KGl5LiBIgogCi0jOiBhcHBseS5jOjQyODkKKyM6IGFwcGx5LmM6NDI5MAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gc3RhdCBuZXdseSBjcmVhdGVkIGZpbGUgJyVzJyIKIG1zZ3N0ciAi5LiN6IO95a+55paw5bu65paH5Lu2ICclcycg6LCD55SoIHN0YXQiCiAKLSM6IGFwcGx5LmM6NDI5NworIzogYXBwbHkuYzo0Mjk4CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBjcmVhdGUgYmFja2luZyBzdG9yZSBmb3IgbmV3bHkgY3JlYXRlZCBmaWxlICVzIgogbXNnc3RyICLkuI3og73kuLrmlrDlu7rmlofku7YgJXMg5Yib5bu65ZCO56uv5a2Y5YKoIgogCi0jOiBhcHBseS5jOjQzMDMgYXBwbHkuYzo0NDQ4CisjOiBhcHBseS5jOjQzMDQgYXBwbHkuYzo0NDQ5CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBhZGQgY2FjaGUgZW50cnkgZm9yICVzIgogbXNnc3RyICLml6Dms5XkuLogJXMg5re75Yqg57yT5a2Y5p2h55uuIgogCi0jOiBhcHBseS5jOjQzNDYKKyM6IGFwcGx5LmM6NDM0NwogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gd3JpdGUgdG8gJyVzJyIKIG1zZ3N0ciAi5YaZ5YWlICclcycg5aSx6LSlIgogCi0jOiBhcHBseS5jOjQzNTAKKyM6IGFwcGx5LmM6NDM1MQogIywgYy1mb3JtYXQKIG1zZ2lkICJjbG9zaW5nIGZpbGUgJyVzJyIKIG1zZ3N0ciAi5YWz6Zet5paH5Lu2ICclcyciCiAKLSM6IGFwcGx5LmM6NDQyMAorIzogYXBwbHkuYzo0NDIxCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byB3cml0ZSBmaWxlICclcycgbW9kZSAlbyIKIG1zZ3N0ciAi5LiN6IO95YaZ5paH5Lu2ICclcycg5p2D6ZmQICVvIgogCi0jOiBhcHBseS5jOjQ1MTgKKyM6IGFwcGx5LmM6NDUxOQogIywgYy1mb3JtYXQKIG1zZ2lkICJBcHBsaWVkIHBhdGNoICVzIGNsZWFubHkuIgogbXNnc3RyICLmiJDlip/lupTnlKjooaXkuIEgJXPjgIIiCiAKLSM6IGFwcGx5LmM6NDUyNgorIzogYXBwbHkuYzo0NTI3CiBtc2dpZCAiaW50ZXJuYWwgZXJyb3IiCiBtc2dzdHIgIuWGhemDqOmUmeivryIKIAotIzogYXBwbHkuYzo0NTI5CisjOiBhcHBseS5jOjQ1MzAKICMsIGMtZm9ybWF0CiBtc2dpZCAiQXBwbHlpbmcgcGF0Y2ggJSVzIHdpdGggJWQgcmVqZWN0Li4uIgogbXNnaWRfcGx1cmFsICJBcHBseWluZyBwYXRjaCAlJXMgd2l0aCAlZCByZWplY3RzLi4uIgogbXNnc3RyWzBdICLlupTnlKggJSVzIOS4quihpeS4ge+8jOWFtuS4rSAlZCDkuKrooqvmi5Lnu50uLi4iCiBtc2dzdHJbMV0gIuW6lOeUqCAlJXMg5Liq6KGl5LiB77yM5YW25LitICVkIOS4quiiq+aLkue7nS4uLiIKIAotIzogYXBwbHkuYzo0NTQwCisjOiBhcHBseS5jOjQ1NDEKICMsIGMtZm9ybWF0CiBtc2dpZCAidHJ1bmNhdGluZyAucmVqIGZpbGVuYW1lIHRvICUuKnMucmVqIgogbXNnc3RyICLmiKrnn60gLnJlaiDmlofku7blkI3kuLogJS4qcy5yZWoiCiAKLSM6IGFwcGx5LmM6NDU0OCBidWlsdGluL2ZldGNoLmM6ODc4IGJ1aWx0aW4vZmV0Y2guYzoxMTY4CisjOiBhcHBseS5jOjQ1NDkgYnVpbHRpbi9mZXRjaC5jOjg5OCBidWlsdGluL2ZldGNoLmM6MTE5NAogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3Qgb3BlbiAlcyIKIG1zZ3N0ciAi5LiN6IO95omT5byAICVzIgogCi0jOiBhcHBseS5jOjQ1NjIKKyM6IGFwcGx5LmM6NDU2MwogIywgYy1mb3JtYXQKIG1zZ2lkICJIdW5rICMlZCBhcHBsaWVkIGNsZWFubHkuIgogbXNnc3RyICLnrKwgIyVkIOS4queJh+auteaIkOWKn+W6lOeUqOOAgiIKIAotIzogYXBwbHkuYzo0NTY2CisjOiBhcHBseS5jOjQ1NjcKICMsIGMtZm9ybWF0CiBtc2dpZCAiUmVqZWN0ZWQgaHVuayAjJWQuIgogbXNnc3RyICLmi5Lnu53nrKwgIyVkIOS4queJh+auteOAgiIKIAotIzogYXBwbHkuYzo0Njc2CisjOiBhcHBseS5jOjQ2ODYKICMsIGMtZm9ybWF0CiBtc2dpZCAiU2tpcHBlZCBwYXRjaCAnJXMnLiIKIG1zZ3N0ciAi55Wl6L+H6KGl5LiBICclcyfjgIIiCiAKLSM6IGFwcGx5LmM6NDY4NAorIzogYXBwbHkuYzo0Njk0CiBtc2dpZCAidW5yZWNvZ25pemVkIGlucHV0IgogbXNnc3RyICLmnKrog73or4bliKvnmoTovpPlhaUiCiAKLSM6IGFwcGx5LmM6NDcwNAorIzogYXBwbHkuYzo0NzE0CiBtc2dpZCAidW5hYmxlIHRvIHJlYWQgaW5kZXggZmlsZSIKIG1zZ3N0ciAi5peg5rOV6K+75Y+W57Si5byV5paH5Lu2IgogCi0jOiBhcHBseS5jOjQ4NTkKKyM6IGFwcGx5LmM6NDg3MQogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW4ndCBvcGVuIHBhdGNoICclcyc6ICVzIgogbXNnc3RyICLkuI3og73miZPlvIDooaXkuIEgJyVzJ++8miVzIgogCi0jOiBhcHBseS5jOjQ4ODYKKyM6IGFwcGx5LmM6NDg5OAogIywgYy1mb3JtYXQKIG1zZ2lkICJzcXVlbGNoZWQgJWQgd2hpdGVzcGFjZSBlcnJvciIKIG1zZ2lkX3BsdXJhbCAic3F1ZWxjaGVkICVkIHdoaXRlc3BhY2UgZXJyb3JzIgogbXNnc3RyWzBdICLmipHliLbkuIvku43mnIkgJWQg5Liq56m655m95a2X56ym6K+v55SoIgogbXNnc3RyWzFdICLmipHliLbkuIvku43mnIkgJWQg5Liq56m655m95a2X56ym6K+v55SoIgogCi0jOiBhcHBseS5jOjQ4OTIgYXBwbHkuYzo0OTA3CisjOiBhcHBseS5jOjQ5MDQgYXBwbHkuYzo0OTE5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVkIGxpbmUgYWRkcyB3aGl0ZXNwYWNlIGVycm9ycy4iCiBtc2dpZF9wbHVyYWwgIiVkIGxpbmVzIGFkZCB3aGl0ZXNwYWNlIGVycm9ycy4iCiBtc2dzdHJbMF0gIiVkIOihjOaWsOWinuS6huepuueZveWtl+espuivr+eUqOOAgiIKIG1zZ3N0clsxXSAiJWQg6KGM5paw5aKe5LqG56m655m95a2X56ym6K+v55So44CCIgogCi0jOiBhcHBseS5jOjQ5MDAKKyM6IGFwcGx5LmM6NDkxMgogIywgYy1mb3JtYXQKIG1zZ2lkICIlZCBsaW5lIGFwcGxpZWQgYWZ0ZXIgZml4aW5nIHdoaXRlc3BhY2UgZXJyb3JzLiIKIG1zZ2lkX3BsdXJhbCAiJWQgbGluZXMgYXBwbGllZCBhZnRlciBmaXhpbmcgd2hpdGVzcGFjZSBlcnJvcnMuIgogbXNnc3RyWzBdICLkv67lpI3nqbrnmb3plJnor6/lkI7vvIzlupTnlKjkuoYgJWQg6KGM44CCIgogbXNnc3RyWzFdICLkv67lpI3nqbrnmb3plJnor6/lkI7vvIzlupTnlKjkuoYgJWQg6KGM44CCIgogCi0jOiBhcHBseS5jOjQ5MTYgYnVpbHRpbi9hZGQuYzo1NDAgYnVpbHRpbi9tdi5jOjMwMSBidWlsdGluL3JtLmM6MzkwCisjOiBhcHBseS5jOjQ5MjggYnVpbHRpbi9hZGQuYzo1NDAgYnVpbHRpbi9tdi5jOjMwMSBidWlsdGluL3JtLmM6MzkwCiBtc2dpZCAiVW5hYmxlIHRvIHdyaXRlIG5ldyBpbmRleCBmaWxlIgogbXNnc3RyICLml6Dms5XlhpnlhaXmlrDntKLlvJXmlofku7YiCiAKLSM6IGFwcGx5LmM6NDk0MyBhcHBseS5jOjQ5NDYgYnVpbHRpbi9hbS5jOjIyMDggYnVpbHRpbi9hbS5jOjIyMTEKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMjMgYnVpbHRpbi9mZXRjaC5jOjEyOCBidWlsdGluL21lcmdlLmM6MjczCi0jOiBidWlsdGluL3B1bGwuYzoyMDggYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjQwNworIzogYXBwbHkuYzo0OTU1IGFwcGx5LmM6NDk1OCBidWlsdGluL2FtLmM6MjE5NyBidWlsdGluL2FtLmM6MjIwMAorIzogYnVpbHRpbi9jbG9uZS5jOjEyMiBidWlsdGluL2ZldGNoLmM6MTQzIGJ1aWx0aW4vbWVyZ2UuYzoyNzMKKyM6IGJ1aWx0aW4vcHVsbC5jOjIwOSBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6NDA3CiAjOiBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6MTM2NyBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6MTM3MAogIzogYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjE4NTAgYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjE4NTMKICM6IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoyMDkyIGdpdC1hZGQtLWludGVyYWN0aXZlLnBlcmw6MjExCiBtc2dpZCAicGF0aCIKIG1zZ3N0ciAi6Lev5b6EIgogCi0jOiBhcHBseS5jOjQ5NDQKKyM6IGFwcGx5LmM6NDk1NgogbXNnaWQgImRvbid0IGFwcGx5IGNoYW5nZXMgbWF0Y2hpbmcgdGhlIGdpdmVuIHBhdGgiCiBtc2dzdHIgIuS4jeimgeW6lOeUqOS4jue7meWHuui3r+W+hOWQkeWMuemFjeeahOWPmOabtCIKIAotIzogYXBwbHkuYzo0OTQ3CisjOiBhcHBseS5jOjQ5NTkKIG1zZ2lkICJhcHBseSBjaGFuZ2VzIG1hdGNoaW5nIHRoZSBnaXZlbiBwYXRoIgogbXNnc3RyICLlupTnlKjkuI7nu5nlh7rot6/lvoTlkJHljLnphY3nmoTlj5jmm7QiCiAKLSM6IGFwcGx5LmM6NDk0OSBidWlsdGluL2FtLmM6MjIxNworIzogYXBwbHkuYzo0OTYxIGJ1aWx0aW4vYW0uYzoyMjA2CiBtc2dpZCAibnVtIgogbXNnc3RyICLmlbDlrZciCiAKLSM6IGFwcGx5LmM6NDk1MAorIzogYXBwbHkuYzo0OTYyCiBtc2dpZCAicmVtb3ZlIDxudW0+IGxlYWRpbmcgc2xhc2hlcyBmcm9tIHRyYWRpdGlvbmFsIGRpZmYgcGF0aHMiCiBtc2dzdHIgIuS7juS8oOe7n+eahCBkaWZmIOi3r+W+hOS4reenu+mZpOaMh+WumuaVsOmHj+eahOWJjeWvvOaWnOe6vyIKIAotIzogYXBwbHkuYzo0OTUzCisjOiBhcHBseS5jOjQ5NjUKIG1zZ2lkICJpZ25vcmUgYWRkaXRpb25zIG1hZGUgYnkgdGhlIHBhdGNoIgogbXNnc3RyICLlv73nlaXooaXkuIHkuK3nmoTmt7vliqDnmoTmlofku7YiCiAKLSM6IGFwcGx5LmM6NDk1NQorIzogYXBwbHkuYzo0OTY3CiBtc2dpZCAiaW5zdGVhZCBvZiBhcHBseWluZyB0aGUgcGF0Y2gsIG91dHB1dCBkaWZmc3RhdCBmb3IgdGhlIGlucHV0IgogbXNnc3RyICLkuI3lupTnlKjooaXkuIHvvIzogIzmmK/mmL7npLrovpPlhaXnmoTlt67lvILnu5/orqHvvIhkaWZmc3RhdO+8iSIKIAotIzogYXBwbHkuYzo0OTU5CisjOiBhcHBseS5jOjQ5NzEKIG1zZ2lkICJzaG93IG51bWJlciBvZiBhZGRlZCBhbmQgZGVsZXRlZCBsaW5lcyBpbiBkZWNpbWFsIG5vdGF0aW9uIgogbXNnc3RyICLku6XljYHov5vliLbmlbDmmL7npLrmt7vliqDlkozliKDpmaTnmoTooYzmlbAiCiAKLSM6IGFwcGx5LmM6NDk2MQorIzogYXBwbHkuYzo0OTczCiBtc2dpZCAiaW5zdGVhZCBvZiBhcHBseWluZyB0aGUgcGF0Y2gsIG91dHB1dCBhIHN1bW1hcnkgZm9yIHRoZSBpbnB1dCIKIG1zZ3N0ciAi5LiN5bqU55So6KGl5LiB77yM6ICM5piv5pi+56S66L6T5YWl55qE5qaC6KaBIgogCi0jOiBhcHBseS5jOjQ5NjMKKyM6IGFwcGx5LmM6NDk3NQogbXNnaWQgImluc3RlYWQgb2YgYXBwbHlpbmcgdGhlIHBhdGNoLCBzZWUgaWYgdGhlIHBhdGNoIGlzIGFwcGxpY2FibGUiCiBtc2dzdHIgIuS4jeW6lOeUqOihpeS4ge+8jOiAjOaYr+afpeeci+ihpeS4geaYr+WQpuWPr+W6lOeUqCIKIAotIzogYXBwbHkuYzo0OTY1CisjOiBhcHBseS5jOjQ5NzcKIG1zZ2lkICJtYWtlIHN1cmUgdGhlIHBhdGNoIGlzIGFwcGxpY2FibGUgdG8gdGhlIGN1cnJlbnQgaW5kZXgiCiBtc2dzdHIgIuehruiupOihpeS4geWPr+S7peW6lOeUqOWIsOW9k+WJjee0ouW8lSIKIAotIzogYXBwbHkuYzo0OTY3CisjOiBhcHBseS5jOjQ5NzkKIG1zZ2lkICJtYXJrIG5ldyBmaWxlcyB3aXRoIGBnaXQgYWRkIC0taW50ZW50LXRvLWFkZGAiCiBtc2dzdHIgIuS9v+eUqOWRveS7pCBgZ2l0IGFkZCAtLWludGVudC10by1hZGRgIOagh+iusOaWsOWinuaWh+S7tiIKIAotIzogYXBwbHkuYzo0OTY5CisjOiBhcHBseS5jOjQ5ODEKIG1zZ2lkICJhcHBseSBhIHBhdGNoIHdpdGhvdXQgdG91Y2hpbmcgdGhlIHdvcmtpbmcgdHJlZSIKIG1zZ3N0ciAi5bqU55So6KGl5LiB6ICM5LiN5L+u5pS55bel5L2c5Yy6IgogCi0jOiBhcHBseS5jOjQ5NzEKKyM6IGFwcGx5LmM6NDk4MwogbXNnaWQgImFjY2VwdCBhIHBhdGNoIHRoYXQgdG91Y2hlcyBvdXRzaWRlIHRoZSB3b3JraW5nIGFyZWEiCiBtc2dzdHIgIuaOpeWPl+S/ruaUueW3peS9nOWMuuS5i+WkluaWh+S7tueahOihpeS4gSIKIAotIzogYXBwbHkuYzo0OTc0CisjOiBhcHBseS5jOjQ5ODYKIG1zZ2lkICJhbHNvIGFwcGx5IHRoZSBwYXRjaCAodXNlIHdpdGggLS1zdGF0Ly0tc3VtbWFyeS8tLWNoZWNrKSIKIG1zZ3N0ciAi6L+Y5bqU55So5q2k6KGl5LiB77yI5LiOIC0tc3RhdC8tLXN1bW1hcnkvLS1jaGVjayDpgInpobnlkIzml7bkvb/nlKjvvIkiCiAKLSM6IGFwcGx5LmM6NDk3NgorIzogYXBwbHkuYzo0OTg4CiBtc2dpZCAiYXR0ZW1wdCB0aHJlZS13YXkgbWVyZ2UgaWYgYSBwYXRjaCBkb2VzIG5vdCBhcHBseSIKIG1zZ3N0ciAi5aaC5p6c5LiA5Liq6KGl5LiB5LiN6IO95bqU55So5YiZ5bCd6K+V5LiJ5pa55ZCI5bm2IgogCi0jOiBhcHBseS5jOjQ5NzgKKyM6IGFwcGx5LmM6NDk5MAogbXNnaWQgImJ1aWxkIGEgdGVtcG9yYXJ5IGluZGV4IGJhc2VkIG9uIGVtYmVkZGVkIGluZGV4IGluZm9ybWF0aW9uIgogbXNnc3RyICLliJvlu7rkuIDkuKrkuLTml7bntKLlvJXln7rkuo7ltYzlhaXnmoTntKLlvJXkv6Hmga8iCiAKLSM6IGFwcGx5LmM6NDk4MSBidWlsdGluL2NoZWNrb3V0LWluZGV4LmM6MTczIGJ1aWx0aW4vbHMtZmlsZXMuYzo1MjQKKyM6IGFwcGx5LmM6NDk5MyBidWlsdGluL2NoZWNrb3V0LWluZGV4LmM6MTczIGJ1aWx0aW4vbHMtZmlsZXMuYzo1MjQKIG1zZ2lkICJwYXRocyBhcmUgc2VwYXJhdGVkIHdpdGggTlVMIGNoYXJhY3RlciIKIG1zZ3N0ciAi6Lev5b6E5LulIE5VTCDlrZfnrKbliIbpmpQiCiAKLSM6IGFwcGx5LmM6NDk4MworIzogYXBwbHkuYzo0OTk1CiBtc2dpZCAiZW5zdXJlIGF0IGxlYXN0IDxuPiBsaW5lcyBvZiBjb250ZXh0IG1hdGNoIgogbXNnc3RyICLnoa7kv53oh7PlsJHljLnphY0gPG4+IOihjOS4iuS4i+aWhyIKIAotIzogYXBwbHkuYzo0OTg0IGJ1aWx0aW4vYW0uYzoyMTk2IGJ1aWx0aW4vaW50ZXJwcmV0LXRyYWlsZXJzLmM6OTgKKyM6IGFwcGx5LmM6NDk5NiBidWlsdGluL2FtLmM6MjE4NSBidWlsdGluL2ludGVycHJldC10cmFpbGVycy5jOjk4CiAjOiBidWlsdGluL2ludGVycHJldC10cmFpbGVycy5jOjEwMCBidWlsdGluL2ludGVycHJldC10cmFpbGVycy5jOjEwMgotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzMwIGJ1aWx0aW4vcmViYXNlLmM6MTQyMQorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzEwIGJ1aWx0aW4vcmViYXNlLmM6MTQ0NQogbXNnaWQgImFjdGlvbiIKIG1zZ3N0ciAi5Yqo5L2cIgogCi0jOiBhcHBseS5jOjQ5ODUKKyM6IGFwcGx5LmM6NDk5NwogbXNnaWQgImRldGVjdCBuZXcgb3IgbW9kaWZpZWQgbGluZXMgdGhhdCBoYXZlIHdoaXRlc3BhY2UgZXJyb3JzIgogbXNnc3RyICLmo4Dmn6XmlrDlop7lkozkv67mlLnnmoTooYzkuK3pl7TnmoTnqbrnmb3lrZfnrKbmu6XnlKgiCiAKLSM6IGFwcGx5LmM6NDk4OCBhcHBseS5jOjQ5OTEKKyM6IGFwcGx5LmM6NTAwMCBhcHBseS5jOjUwMDMKIG1zZ2lkICJpZ25vcmUgY2hhbmdlcyBpbiB3aGl0ZXNwYWNlIHdoZW4gZmluZGluZyBjb250ZXh0IgogbXNnc3RyICLmn6Xmib7kuIrkuIvmlofml7blv73nlaXnqbrnmb3lrZfnrKbnmoTlj5jmm7QiCiAKLSM6IGFwcGx5LmM6NDk5NAorIzogYXBwbHkuYzo1MDA2CiBtc2dpZCAiYXBwbHkgdGhlIHBhdGNoIGluIHJldmVyc2UiCiBtc2dzdHIgIuWPjeWQkeW6lOeUqOihpeS4gSIKIAotIzogYXBwbHkuYzo0OTk2CisjOiBhcHBseS5jOjUwMDgKIG1zZ2lkICJkb24ndCBleHBlY3QgYXQgbGVhc3Qgb25lIGxpbmUgb2YgY29udGV4dCIKIG1zZ3N0ciAi5peg6ZyA6Iez5bCR5LiA6KGM5LiK5LiL5paHIgogCi0jOiBhcHBseS5jOjQ5OTgKKyM6IGFwcGx5LmM6NTAxMAogbXNnaWQgImxlYXZlIHRoZSByZWplY3RlZCBodW5rcyBpbiBjb3JyZXNwb25kaW5nICoucmVqIGZpbGVzIgogbXNnc3RyICLlsIbmi5Lnu53nmoTooaXkuIHniYfmrrXkv53lrZjlnKjlr7nlupTnmoQgKi5yZWog5paH5Lu25LitIgogCi0jOiBhcHBseS5jOjUwMDAKKyM6IGFwcGx5LmM6NTAxMgogbXNnaWQgImFsbG93IG92ZXJsYXBwaW5nIGh1bmtzIgogbXNnc3RyICLlhYHorrjph43lj6DnmoTooaXkuIHniYfmrrUiCiAKLSM6IGFwcGx5LmM6NTAwMSBidWlsdGluL2FkZC5jOjI5MSBidWlsdGluL2NoZWNrLWlnbm9yZS5jOjIyCisjOiBhcHBseS5jOjUwMTMgYnVpbHRpbi9hZGQuYzoyOTEgYnVpbHRpbi9jaGVjay1pZ25vcmUuYzoyMgogIzogYnVpbHRpbi9jb21taXQuYzoxMzM3IGJ1aWx0aW4vY291bnQtb2JqZWN0cy5jOjk4IGJ1aWx0aW4vZnNjay5jOjc4NgotIzogYnVpbHRpbi9sb2cuYzoyMDY4IGJ1aWx0aW4vbXYuYzoxMjMgYnVpbHRpbi9yZWFkLXRyZWUuYzoxMjgKKyM6IGJ1aWx0aW4vbG9nLmM6MjA4NSBidWlsdGluL212LmM6MTIzIGJ1aWx0aW4vcmVhZC10cmVlLmM6MTI4CiBtc2dpZCAiYmUgdmVyYm9zZSIKIG1zZ3N0ciAi5YaX6ZW/6L6T5Ye6IgogCi0jOiBhcHBseS5jOjUwMDMKKyM6IGFwcGx5LmM6NTAxNQogbXNnaWQgInRvbGVyYXRlIGluY29ycmVjdGx5IGRldGVjdGVkIG1pc3NpbmcgbmV3LWxpbmUgYXQgdGhlIGVuZCBvZiBmaWxlIgogbXNnc3RyICLlhYHorrjkuI3mraPnoa7nmoTmlofku7bmnKvlsL7mjaLooYznrKYiCiAKLSM6IGFwcGx5LmM6NTAwNgorIzogYXBwbHkuYzo1MDE4CiBtc2dpZCAiZG8gbm90IHRydXN0IHRoZSBsaW5lIGNvdW50cyBpbiB0aGUgaHVuayBoZWFkZXJzIgogbXNnc3RyICLkuI3kv6Hku7vooaXkuIHniYfmrrXnmoTlpLTkv6Hmga/kuK3nmoTooYzlj7ciCiAKLSM6IGFwcGx5LmM6NTAwOCBidWlsdGluL2FtLmM6MjIwNQorIzogYXBwbHkuYzo1MDIwIGJ1aWx0aW4vYW0uYzoyMTk0CiBtc2dpZCAicm9vdCIKIG1zZ3N0ciAi5qC555uu5b2VIgogCi0jOiBhcHBseS5jOjUwMDkKKyM6IGFwcGx5LmM6NTAyMQogbXNnaWQgInByZXBlbmQgPHJvb3Q+IHRvIGFsbCBmaWxlbmFtZXMiCiBtc2dzdHIgIuS4uuaJgOacieaWh+S7tuWQjeWJjea3u+WKoCA85qC555uu5b2VPiIKIApAQCAtOTIyLDcgKzkyMiw3IEBACiBtc2dpZCAiYXJjaGl2ZSBmb3JtYXQiCiBtc2dzdHIgIuW9kuaho+agvOW8jyIKIAotIzogYXJjaGl2ZS5jOjQ1OCBidWlsdGluL2xvZy5jOjE1ODAKKyM6IGFyY2hpdmUuYzo0NTggYnVpbHRpbi9sb2cuYzoxNTgxCiBtc2dpZCAicHJlZml4IgogbXNnc3RyICLliY3nvIAiCiAKQEAgLTkzMCwxMSArOTMwLDEyIEBACiBtc2dpZCAicHJlcGVuZCBwcmVmaXggdG8gZWFjaCBwYXRobmFtZSBpbiB0aGUgYXJjaGl2ZSIKIG1zZ3N0ciAi5Li65b2S5qGj5Lit5q+P5Liq6Lev5b6E5ZCN5Yqg5LiK5YmN57yAIgogCi0jOiBhcmNoaXZlLmM6NDYwIGJ1aWx0aW4vYmxhbWUuYzo4NjIgYnVpbHRpbi9ibGFtZS5jOjg3NCBidWlsdGluL2JsYW1lLmM6ODc1Ci0jOiBidWlsdGluL2NvbW1pdC10cmVlLmM6MTE3IGJ1aWx0aW4vY29uZmlnLmM6MTI5IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTM0Ci0jOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTEzNiBidWlsdGluL2dyZXAuYzo4OTcgYnVpbHRpbi9oYXNoLW9iamVjdC5jOjEwNQotIzogYnVpbHRpbi9scy1maWxlcy5jOjU2MCBidWlsdGluL2xzLWZpbGVzLmM6NTYzIGJ1aWx0aW4vbm90ZXMuYzo0MTIKLSM6IGJ1aWx0aW4vbm90ZXMuYzo1NzggYnVpbHRpbi9yZWFkLXRyZWUuYzoxMjMgcGFyc2Utb3B0aW9ucy5oOjE3NworIzogYXJjaGl2ZS5jOjQ2MCBidWlsdGluL2JsYW1lLmM6ODYxIGJ1aWx0aW4vYmxhbWUuYzo4NzMgYnVpbHRpbi9ibGFtZS5jOjg3NAorIzogYnVpbHRpbi9jb21taXQtdHJlZS5jOjExNyBidWlsdGluL2NvbmZpZy5jOjEyOSBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE2MgorIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNjQgYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNjggYnVpbHRpbi9ncmVwLmM6ODk5CisjOiBidWlsdGluL2hhc2gtb2JqZWN0LmM6MTA1IGJ1aWx0aW4vbHMtZmlsZXMuYzo1NjAgYnVpbHRpbi9scy1maWxlcy5jOjU2MworIzogYnVpbHRpbi9ub3Rlcy5jOjQxMiBidWlsdGluL25vdGVzLmM6NTc4IGJ1aWx0aW4vcmVhZC10cmVlLmM6MTIzCisjOiBwYXJzZS1vcHRpb25zLmg6MTg2CiBtc2dpZCAiZmlsZSIKIG1zZ3N0ciAi5paH5Lu2IgogCkBAIC05NjYsNyArOTY3LDcgQEAKIG1zZ2lkICJsaXN0IHN1cHBvcnRlZCBhcmNoaXZlIGZvcm1hdHMiCiBtc2dzdHIgIuWIl+WHuuaUr+aMgeeahOW9kuaho+agvOW8jyIKIAotIzogYXJjaGl2ZS5jOjQ3OSBidWlsdGluL2FyY2hpdmUuYzo5MSBidWlsdGluL2Nsb25lLmM6MTEzIGJ1aWx0aW4vY2xvbmUuYzoxMTYKKyM6IGFyY2hpdmUuYzo0NzkgYnVpbHRpbi9hcmNoaXZlLmM6OTEgYnVpbHRpbi9jbG9uZS5jOjExMiBidWlsdGluL2Nsb25lLmM6MTE1CiAjOiBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6MTM3OSBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6MTg1OQogbXNnaWQgInJlcG8iCiBtc2dzdHIgIuS7k+W6kyIKQEAgLTk3NSw3ICs5NzYsNyBAQAogbXNnaWQgInJldHJpZXZlIHRoZSBhcmNoaXZlIGZyb20gcmVtb3RlIHJlcG9zaXRvcnkgPHJlcG8+IgogbXNnc3RyICLku47ov5znqIvku5PlupPvvIg85LuT5bqTPu+8ieaPkOWPluW9kuaho+aWh+S7tiIKIAotIzogYXJjaGl2ZS5jOjQ4MSBidWlsdGluL2FyY2hpdmUuYzo5MyBidWlsdGluL2RpZmZ0b29sLmM6NzA3CisjOiBhcmNoaXZlLmM6NDgxIGJ1aWx0aW4vYXJjaGl2ZS5jOjkzIGJ1aWx0aW4vZGlmZnRvb2wuYzo3MTUKICM6IGJ1aWx0aW4vbm90ZXMuYzo0OTgKIG1zZ2lkICJjb21tYW5kIgogbXNnc3RyICLlkb3ku6QiCkBAIC0xMDExLDI2ICsxMDEyLDI2IEBACiBtc2dpZCAiY2Fubm90IHN0cmVhbSBibG9iICVzIgogbXNnc3RyICLkuI3og73miZPlvIDmlbDmja7lr7nosaEgJXMiCiAKLSM6IGFyY2hpdmUtdGFyLmM6MjYwIGFyY2hpdmUtemlwLmM6MzYzCisjOiBhcmNoaXZlLXRhci5jOjI2NiBhcmNoaXZlLXppcC5jOjM2MwogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bnN1cHBvcnRlZCBmaWxlIG1vZGU6IDAlbyAoU0hBMTogJXMpIgogbXNnc3RyICLkuI3mlK/mjIHnmoTmlofku7bmqKHlvI/vvJowJW8gKFNIQTE6ICVzKSIKIAotIzogYXJjaGl2ZS10YXIuYzoyODcgYXJjaGl2ZS16aXAuYzozNTMKKyM6IGFyY2hpdmUtdGFyLmM6MjkzIGFyY2hpdmUtemlwLmM6MzUzCiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCByZWFkICVzIgogbXNnc3RyICLkuI3og73or7vlj5YgJXMiCiAKLSM6IGFyY2hpdmUtdGFyLmM6NDU5CisjOiBhcmNoaXZlLXRhci5jOjQ2NQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gc3RhcnQgJyVzJyBmaWx0ZXIiCiBtc2dzdHIgIuaXoOazleWQr+WKqCAnJXMnIOi/h+a7pOWZqCIKIAotIzogYXJjaGl2ZS10YXIuYzo0NjIKKyM6IGFyY2hpdmUtdGFyLmM6NDY4CiBtc2dpZCAidW5hYmxlIHRvIHJlZGlyZWN0IGRlc2NyaXB0b3IiCiBtc2dzdHIgIuaXoOazlemHjeWumuWQkeaPj+i/sOespiIKIAotIzogYXJjaGl2ZS10YXIuYzo0NjkKKyM6IGFyY2hpdmUtdGFyLmM6NDc1CiAjLCBjLWZvcm1hdAogbXNnaWQgIiclcycgZmlsdGVyIHJlcG9ydGVkIGVycm9yIgogbXNnc3RyICInJXMnIOi/h+a7pOWZqOaKpeWRiuS6humUmeivryIKQEAgLTEwNTUsMTcgKzEwNTYsMTcgQEAKIG1zZ2lkICJ0aW1lc3RhbXAgdG9vIGxhcmdlIGZvciB0aGlzIHN5c3RlbTogJTxQUkl1TUFYPiIKIG1zZ3N0ciAi5a+55LqO5pys57O757uf5pe26Ze05oiz5aSq5aSn77yaJTxQUkl1TUFYPiIKIAotIzogYXR0ci5jOjIxMQorIzogYXR0ci5jOjIxMwogIywgYy1mb3JtYXQKIG1zZ2lkICIlLipzIGlzIG5vdCBhIHZhbGlkIGF0dHJpYnV0ZSBuYW1lIgogbXNnc3RyICIlLipzIOS4jeaYr+S4gOS4quacieaViOeahOWxnuaAp+WQjSIKIAotIzogYXR0ci5jOjM2OAorIzogYXR0ci5jOjM3MAogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyBub3QgYWxsb3dlZDogJXM6JWQiCiBtc2dzdHIgIuS4jeWFgeiuuCAlc++8miVzOiVkIgogCi0jOiBhdHRyLmM6NDA4CisjOiBhdHRyLmM6NDEwCiBtc2dpZCAiIgogIk5lZ2F0aXZlIHBhdHRlcm5zIGFyZSBpZ25vcmVkIGluIGdpdCBhdHRyaWJ1dGVzXG4iCiAiVXNlICdcXCEnIGZvciBsaXRlcmFsIGxlYWRpbmcgZXhjbGFtYXRpb24uIgpAQCAtMTE5MiwzNyArMTE5MywzNyBAQAogbXNnc3RyWzBdICLkuozliIbmn6Xmib7kuK3vvJrlnKjmraTkuYvlkI7vvIzov5jliakgJWQg5Liq54mI5pys5b6F5rWL6K+VICVzXG4iCiBtc2dzdHJbMV0gIuS6jOWIhuafpeaJvuS4re+8muWcqOatpOS5i+WQju+8jOi/mOWJqSAlZCDkuKrniYjmnKzlvoXmtYvor5UgJXNcbiIKIAotIzogYmxhbWUuYzoyNjk3CisjOiBibGFtZS5jOjI3MDAKIG1zZ2lkICItLWNvbnRlbnRzIGFuZCAtLXJldmVyc2UgZG8gbm90IGJsZW5kIHdlbGwuIgogbXNnc3RyICItLWNvbnRlbnRzIOWSjCAtLXJldmVyc2Ug5LiN6IO95re355So44CCIgogCi0jOiBibGFtZS5jOjI3MTEKKyM6IGJsYW1lLmM6MjcxNAogbXNnaWQgImNhbm5vdCB1c2UgLS1jb250ZW50cyB3aXRoIGZpbmFsIGNvbW1pdCBvYmplY3QgbmFtZSIKIG1zZ3N0ciAi5LiN6IO95bCGIC0tY29udGVudHMg5ZKM5pyA57uI55qE5o+Q5Lqk5a+56LGh5ZCN5YWx55SoIgogCi0jOiBibGFtZS5jOjI3MzIKKyM6IGJsYW1lLmM6MjczNQogbXNnaWQgIi0tcmV2ZXJzZSBhbmQgLS1maXJzdC1wYXJlbnQgdG9nZXRoZXIgcmVxdWlyZSBzcGVjaWZpZWQgbGF0ZXN0IGNvbW1pdCIKIG1zZ3N0ciAiLS1yZXZlcnNlIOWSjCAtLWZpcnN0LXBhcmVudCDlhbHnlKjvvIzpnIDopoHmjIflrprmnIDmlrDnmoTmj5DkuqQiCiAKLSM6IGJsYW1lLmM6Mjc0MSBidW5kbGUuYzoxNjcgcmVmLWZpbHRlci5jOjIxOTYgcmVtb3RlLmM6MTkzOCBzZXF1ZW5jZXIuYzoyMDMzCi0jOiBzZXF1ZW5jZXIuYzo0MzQ4IGJ1aWx0aW4vY29tbWl0LmM6MTAyMCBidWlsdGluL2xvZy5jOjM4NyBidWlsdGluL2xvZy5jOjk2MwotIzogYnVpbHRpbi9sb2cuYzoxNDUxIGJ1aWx0aW4vbG9nLmM6MTgyNyBidWlsdGluL2xvZy5jOjIxMTcgYnVpbHRpbi9tZXJnZS5jOjQxMQotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMTQ4IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzE2MworIzogYmxhbWUuYzoyNzQ0IGJ1bmRsZS5jOjE2NyByZWYtZmlsdGVyLmM6MjIwMyByZW1vdGUuYzoxOTQxIHNlcXVlbmNlci5jOjE5NzEKKyM6IHNlcXVlbmNlci5jOjQzMDUgYnVpbHRpbi9jb21taXQuYzoxMDIwIGJ1aWx0aW4vbG9nLmM6Mzg3IGJ1aWx0aW4vbG9nLmM6OTY0CisjOiBidWlsdGluL2xvZy5jOjE0NTIgYnVpbHRpbi9sb2cuYzoxODQ0IGJ1aWx0aW4vbG9nLmM6MjEzNCBidWlsdGluL21lcmdlLmM6NDExCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMxMjggYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMTQzCiAjOiBidWlsdGluL3Nob3J0bG9nLmM6MTkyCiBtc2dpZCAicmV2aXNpb24gd2FsayBzZXR1cCBmYWlsZWQiCiBtc2dzdHIgIueJiOacrOmBjeWOhuiuvue9ruWksei0pSIKIAotIzogYmxhbWUuYzoyNzU5CisjOiBibGFtZS5jOjI3NjIKIG1zZ2lkICIiCiAiLS1yZXZlcnNlIC0tZmlyc3QtcGFyZW50IHRvZ2V0aGVyIHJlcXVpcmUgcmFuZ2UgYWxvbmcgZmlyc3QtcGFyZW50IGNoYWluIgogbXNnc3RyICItLXJldmVyc2Ug5ZKMIC0tZmlyc3QtcGFyZW50IOWFseeUqO+8jOmcgOimgeesrOS4gOelluWFiOmTvuS4iueahOaPkOS6pOiMg+WbtCIKIAotIzogYmxhbWUuYzoyNzcwCisjOiBibGFtZS5jOjI3NzMKICMsIGMtZm9ybWF0CiBtc2dpZCAibm8gc3VjaCBwYXRoICVzIGluICVzIgogbXNnc3RyICLlnKggJTIkcyDkuK3ml6DmraTot6/lvoQgJTEkcyIKIAotIzogYmxhbWUuYzoyNzgxCisjOiBibGFtZS5jOjI3ODQKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IHJlYWQgYmxvYiAlcyBmb3IgcGF0aCAlcyIKIG1zZ3N0ciAi5LiN6IO95Li66Lev5b6EICUyJHMg6K+75Y+W5pWw5o2u5a+56LGhICUxJHMiCkBAIC0xMzcwLDcgKzEzNzEsNyBAQAogbXNnaWQgInVucmVjb2duaXplZCBoZWFkZXI6ICVzJXMgKCVkKSIKIG1zZ3N0ciAi5pyq6IO96K+G5Yir55qE5YyF5aS077yaJXMlcyAoJWQpIgogCi0jOiBidW5kbGUuYzo5MCByZXJlcmUuYzo0ODAgcmVyZXJlLmM6NjkwIHNlcXVlbmNlci5jOjIyODMgc2VxdWVuY2VyLmM6MzAyNAorIzogYnVuZGxlLmM6OTAgcmVyZXJlLmM6NDgwIHJlcmVyZS5jOjY5MCBzZXF1ZW5jZXIuYzoyMjIxIHNlcXVlbmNlci5jOjI5NjIKICM6IGJ1aWx0aW4vY29tbWl0LmM6NzkxCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBvcGVuICclcyciCkBAIC0xNDIzLDcgKzE0MjQsNyBAQAogbXNnaWQgInJlZiAnJXMnIGlzIGV4Y2x1ZGVkIGJ5IHRoZSByZXYtbGlzdCBvcHRpb25zIgogbXNnc3RyICLlvJXnlKggJyVzJyDooqsgcmV2LWxpc3Qg6YCJ6aG55o6S6ZmkIgogCi0jOiBidW5kbGUuYzo0NjAgYnVpbHRpbi9sb2cuYzoyMDIgYnVpbHRpbi9sb2cuYzoxNzMyIGJ1aWx0aW4vc2hvcnRsb2cuYzozMDYKKyM6IGJ1bmRsZS5jOjQ2MCBidWlsdGluL2xvZy5jOjIwMiBidWlsdGluL2xvZy5jOjE3MzMgYnVpbHRpbi9zaG9ydGxvZy5jOjMwNgogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bnJlY29nbml6ZWQgYXJndW1lbnQ6ICVzIgogbXNnc3RyICLmnKrog73or4bliKvnmoTlj4LmlbDvvJolcyIKQEAgLTE0NDYsOCArMTQ0Nyw4IEBACiBtc2dpZCAiaW52YWxpZCBjb2xvciB2YWx1ZTogJS4qcyIKIG1zZ3N0ciAi5peg5pWI55qE6aKc6Imy5YC877yaJS4qcyIKIAotIzogY29tbWl0LmM6NTAgc2VxdWVuY2VyLmM6MjcyNyBidWlsdGluL2FtLmM6MzU1IGJ1aWx0aW4vYW0uYzozOTkKLSM6IGJ1aWx0aW4vYW0uYzoxMzc4IGJ1aWx0aW4vYW0uYzoyMDIwIGJ1aWx0aW4vcmVwbGFjZS5jOjQ1NQorIzogY29tbWl0LmM6NTAgc2VxdWVuY2VyLmM6MjY2NSBidWlsdGluL2FtLmM6MzU0IGJ1aWx0aW4vYW0uYzozOTgKKyM6IGJ1aWx0aW4vYW0uYzoxMzY2IGJ1aWx0aW4vYW0uYzoyMDA5IGJ1aWx0aW4vcmVwbGFjZS5jOjQ1NgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcGFyc2UgJXMiCiBtc2dzdHIgIuS4jeiDveino+aekCAlcyIKQEAgLTE0NzcsMjcgKzE0NzgsMjcgQEAKICLorr7nva4gXCJnaXQgY29uZmlnIGFkdmljZS5ncmFmdEZpbGVEZXByZWNhdGVkIGZhbHNlXCJcbiIKICLlj6/lhbPpl63mnKzmtojmga8iCiAKLSM6IGNvbW1pdC5jOjExMjcKKyM6IGNvbW1pdC5jOjExMjgKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ29tbWl0ICVzIGhhcyBhbiB1bnRydXN0ZWQgR1BHIHNpZ25hdHVyZSwgYWxsZWdlZGx5IGJ5ICVzLiIKIG1zZ3N0ciAi5o+Q5LqkICVzIOacieS4gOS4qumdnuWPr+S/oeeahOWjsOensOadpeiHqiAlcyDnmoQgR1BHIOetvuWQjeOAgiIKIAotIzogY29tbWl0LmM6MTEzMAorIzogY29tbWl0LmM6MTEzMQogIywgYy1mb3JtYXQKIG1zZ2lkICJDb21taXQgJXMgaGFzIGEgYmFkIEdQRyBzaWduYXR1cmUgYWxsZWdlZGx5IGJ5ICVzLiIKIG1zZ3N0ciAi5o+Q5LqkICVzIOacieS4gOS4qumUmeivr+eahOWjsOensOadpeiHqiAlcyDnmoQgR1BHIOetvuWQjeOAgiIKIAotIzogY29tbWl0LmM6MTEzMworIzogY29tbWl0LmM6MTEzNAogIywgYy1mb3JtYXQKIG1zZ2lkICJDb21taXQgJXMgZG9lcyBub3QgaGF2ZSBhIEdQRyBzaWduYXR1cmUuIgogbXNnc3RyICLmj5DkuqQgJXMg5rKh5pyJIEdQRyDnrb7lkI3jgIIiCiAKLSM6IGNvbW1pdC5jOjExMzYKKyM6IGNvbW1pdC5jOjExMzcKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ29tbWl0ICVzIGhhcyBhIGdvb2QgR1BHIHNpZ25hdHVyZSBieSAlc1xuIgogbXNnc3RyICLmj5DkuqQgJXMg5pyJ5LiA5Liq5p2l6IeqICVzIOeahOWlveeahCBHUEcg562+5ZCN44CCXG4iCiAKLSM6IGNvbW1pdC5jOjEzOTAKKyM6IGNvbW1pdC5jOjEzOTEKIG1zZ2lkICIiCiAiV2FybmluZzogY29tbWl0IG1lc3NhZ2UgZGlkIG5vdCBjb25mb3JtIHRvIFVURi04LlxuIgogIllvdSBtYXkgd2FudCB0byBhbWVuZCBpdCBhZnRlciBmaXhpbmcgdGhlIG1lc3NhZ2UsIG9yIHNldCB0aGUgY29uZmlnXG4iCkBAIC0xNTU3LDE5MyArMTU1OCwyMDggQEAKIG1zZ2lkICJ1bmFibGUgdG8gZmluZCBhbGwgY29tbWl0LWdyYXBoIGZpbGVzIgogbXNnc3RyICLml6Dms5Xmib7liLDmiYDmnInmj5DkuqTlm77lvaLmlofku7YiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjU1NCBjb21taXQtZ3JhcGguYzo2MTQKKyM6IGNvbW1pdC1ncmFwaC5jOjU2MSBjb21taXQtZ3JhcGguYzo2MjEKIG1zZ2lkICJpbnZhbGlkIGNvbW1pdCBwb3NpdGlvbi4gY29tbWl0LWdyYXBoIGlzIGxpa2VseSBjb3JydXB0IgogbXNnc3RyICLml6DmlYjnmoTmj5DkuqTkvY3nva7jgILmj5DkuqTlm77lvaLlj6/og73lt7LmjZ/lnY8iCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjU3NQorIzogY29tbWl0LWdyYXBoLmM6NTgyCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBmaW5kIGNvbW1pdCAlcyIKIG1zZ3N0ciAi5peg5rOV5om+5Yiw5o+Q5LqkICVzIgogCi0jOiBjb21taXQtZ3JhcGguYzoxMDAyIGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjY1NworIzogY29tbWl0LWdyYXBoLmM6ODU1IGJ1aWx0aW4vYW0uYzoxMjg3CisjLCBjLWZvcm1hdAorbXNnaWQgInVuYWJsZSB0byBwYXJzZSBjb21taXQgJXMiCittc2dzdHIgIuS4jeiDveino+aekOaPkOS6pCAlcyIKKworIzogY29tbWl0LWdyYXBoLmM6ODU5CisjLCBjLWZvcm1hdAorbXNnaWQgInVuYWJsZSB0byBnZXQgdHJlZSBmb3IgJXMiCittc2dzdHIgIuaXoOazleW+l+WIsCAlcyDnmoTmoJHlr7nosaEiCisKKyM6IGNvbW1pdC1ncmFwaC5jOjEwMTcgYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNjQxCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBnZXQgdHlwZSBvZiBvYmplY3QgJXMiCiBtc2dzdHIgIuaXoOazleiOt+W+l+WvueixoSAlcyDnsbvlnosiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjEwMzQKKyM6IGNvbW1pdC1ncmFwaC5jOjEwNDkKIG1zZ2lkICJMb2FkaW5nIGtub3duIGNvbW1pdHMgaW4gY29tbWl0IGdyYXBoIgogbXNnc3RyICLmraPlnKjliqDovb3mj5DkuqTlm77kuK3nmoTlt7Lnn6Xmj5DkuqQiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjEwNTEKKyM6IGNvbW1pdC1ncmFwaC5jOjEwNjYKIG1zZ2lkICJFeHBhbmRpbmcgcmVhY2hhYmxlIGNvbW1pdHMgaW4gY29tbWl0IGdyYXBoIgogbXNnc3RyICLmraPlnKjmianlsZXmj5DkuqTlm77kuK3nmoTlj6/ovr7mj5DkuqQiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjEwNzAKKyM6IGNvbW1pdC1ncmFwaC5jOjEwODUKIG1zZ2lkICJDbGVhcmluZyBjb21taXQgbWFya3MgaW4gY29tbWl0IGdyYXBoIgogbXNnc3RyICLmraPlnKjmuIXpmaTmj5DkuqTlm77kuK3nmoTmj5DkuqTmoIforrAiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjEwODkKKyM6IGNvbW1pdC1ncmFwaC5jOjExMDQKIG1zZ2lkICJDb21wdXRpbmcgY29tbWl0IGdyYXBoIGdlbmVyYXRpb24gbnVtYmVycyIKIG1zZ3N0ciAi5q2j5Zyo6K6h566X5o+Q5Lqk5Zu+5LiW5Luj5pWw5a2XIgogCi0jOiBjb21taXQtZ3JhcGguYzoxMTYzCisjOiBjb21taXQtZ3JhcGguYzoxMTc5CiAjLCBjLWZvcm1hdAogbXNnaWQgIkZpbmRpbmcgY29tbWl0cyBmb3IgY29tbWl0IGdyYXBoIGluICVkIHBhY2siCiBtc2dpZF9wbHVyYWwgIkZpbmRpbmcgY29tbWl0cyBmb3IgY29tbWl0IGdyYXBoIGluICVkIHBhY2tzIgogbXNnc3RyWzBdICLmraPlnKggJWQg5Liq5YyF5Lit5p+l5om+5o+Q5Lqk5Zu+55qE5o+Q5LqkIgogbXNnc3RyWzFdICLmraPlnKggJWQg5Liq5YyF5Lit5p+l5om+5o+Q5Lqk5Zu+55qE5o+Q5LqkIgogCi0jOiBjb21taXQtZ3JhcGguYzoxMTc2CisjOiBjb21taXQtZ3JhcGguYzoxMTkyCiAjLCBjLWZvcm1hdAogbXNnaWQgImVycm9yIGFkZGluZyBwYWNrICVzIgogbXNnc3RyICLmt7vliqDljIUgJXMg5Ye66ZSZIgogCi0jOiBjb21taXQtZ3JhcGguYzoxMTgwCisjOiBjb21taXQtZ3JhcGguYzoxMTk2CiAjLCBjLWZvcm1hdAogbXNnaWQgImVycm9yIG9wZW5pbmcgaW5kZXggZm9yICVzIgogbXNnc3RyICLkuLogJXMg5omT5byA57Si5byV5Ye66ZSZIgogCi0jOiBjb21taXQtZ3JhcGguYzoxMjA0CisjOiBjb21taXQtZ3JhcGguYzoxMjIwCiAjLCBjLWZvcm1hdAogbXNnaWQgIkZpbmRpbmcgY29tbWl0cyBmb3IgY29tbWl0IGdyYXBoIGZyb20gJWQgcmVmIgogbXNnaWRfcGx1cmFsICJGaW5kaW5nIGNvbW1pdHMgZm9yIGNvbW1pdCBncmFwaCBmcm9tICVkIHJlZnMiCiBtc2dzdHJbMF0gIuato+WcqOS7jiAlZCDkuKrlvJXnlKjkuK3mn6Xmib7mj5DkuqTlm77nmoTmj5DkuqQiCiBtc2dzdHJbMV0gIuato+WcqOS7jiAlZCDkuKrlvJXnlKjkuK3mn6Xmib7mj5DkuqTlm77nmoTmj5DkuqQiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjEyMzgKKyM6IGNvbW1pdC1ncmFwaC5jOjEyNDAKKyMsIGMtZm9ybWF0Cittc2dpZCAiaW52YWxpZCBjb21taXQgb2JqZWN0IGlkOiAlcyIKK21zZ3N0ciAi5peg5pWI55qE5o+Q5Lqk5a+56LGhIElE77yaJXMiCisKKyM6IGNvbW1pdC1ncmFwaC5jOjEyNTUKIG1zZ2lkICJGaW5kaW5nIGNvbW1pdHMgZm9yIGNvbW1pdCBncmFwaCBhbW9uZyBwYWNrZWQgb2JqZWN0cyIKIG1zZ3N0ciAi5q2j5Zyo5omT5YyF5a+56LGh5Lit5p+l5om+5o+Q5Lqk5Zu+55qE5o+Q5LqkIgogCi0jOiBjb21taXQtZ3JhcGguYzoxMjUzCisjOiBjb21taXQtZ3JhcGguYzoxMjcwCiBtc2dpZCAiQ291bnRpbmcgZGlzdGluY3QgY29tbWl0cyBpbiBjb21taXQgZ3JhcGgiCiBtc2dzdHIgIuato+WcqOiuoeeul+aPkOS6pOWbvuS4reS4jeWQjOeahOaPkOS6pCIKIAotIzogY29tbWl0LWdyYXBoLmM6MTI4NAorIzogY29tbWl0LWdyYXBoLmM6MTMwMAogbXNnaWQgIkZpbmRpbmcgZXh0cmEgZWRnZXMgaW4gY29tbWl0IGdyYXBoIgogbXNnc3RyICLmraPlnKjmn6Xmib7mj5DkuqTlm77kuK3pop3lpJbnmoTovrkiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjEzMzIKKyM6IGNvbW1pdC1ncmFwaC5jOjEzNDYKIG1zZ2lkICJmYWlsZWQgdG8gd3JpdGUgY29ycmVjdCBudW1iZXIgb2YgYmFzZSBncmFwaCBpZHMiCiBtc2dzdHIgIuaXoOazleWGmeWFpeato+ehruaVsOmHj+eahOWfuuehgOWbvuW9oiBJRCIKIAotIzogY29tbWl0LWdyYXBoLmM6MTM2NSBtaWR4LmM6ODExCisjOiBjb21taXQtZ3JhcGguYzoxMzc5IG1pZHguYzo4MTAKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGNyZWF0ZSBsZWFkaW5nIGRpcmVjdG9yaWVzIG9mICVzIgogbXNnc3RyICLkuI3og73kuLogJXMg5Yib5bu65YWI5a+855uu5b2VIgogCi0jOiBjb21taXQtZ3JhcGguYzoxMzc3IGJ1aWx0aW4vaW5kZXgtcGFjay5jOjMwNiBidWlsdGluL3JlcGFjay5jOjI0MAorIzogY29tbWl0LWdyYXBoLmM6MTM5MSBidWlsdGluL2luZGV4LXBhY2suYzozMDYgYnVpbHRpbi9yZXBhY2suYzoyNDEKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGNyZWF0ZSAnJXMnIgogbXNnc3RyICLkuI3og73liJvlu7ogJyVzJyIKIAotIzogY29tbWl0LWdyYXBoLmM6MTQzNworIzogY29tbWl0LWdyYXBoLmM6MTQ1MQogIywgYy1mb3JtYXQKIG1zZ2lkICJXcml0aW5nIG91dCBjb21taXQgZ3JhcGggaW4gJWQgcGFzcyIKIG1zZ2lkX3BsdXJhbCAiV3JpdGluZyBvdXQgY29tbWl0IGdyYXBoIGluICVkIHBhc3NlcyIKIG1zZ3N0clswXSAi5q2j5Zyo55SoICVkIOatpeWGmeWHuuaPkOS6pOWbviIKIG1zZ3N0clsxXSAi5q2j5Zyo55SoICVkIOatpeWGmeWHuuaPkOS6pOWbviIKIAotIzogY29tbWl0LWdyYXBoLmM6MTQ3OAorIzogY29tbWl0LWdyYXBoLmM6MTQ5MgogbXNnaWQgInVuYWJsZSB0byBvcGVuIGNvbW1pdC1ncmFwaCBjaGFpbiBmaWxlIgogbXNnc3RyICLml6Dms5XmiZPlvIDmj5DkuqTlm77lvaLpk77mlofku7YiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjE0OTAKKyM6IGNvbW1pdC1ncmFwaC5jOjE1MDQKIG1zZ2lkICJmYWlsZWQgdG8gcmVuYW1lIGJhc2UgY29tbWl0LWdyYXBoIGZpbGUiCiBtc2dzdHIgIuaXoOazlemHjeWRveWQjeWfuuehgOaPkOS6pOWbvuW9ouaWh+S7tiIKIAotIzogY29tbWl0LWdyYXBoLmM6MTUxMAorIzogY29tbWl0LWdyYXBoLmM6MTUyNAogbXNnaWQgImZhaWxlZCB0byByZW5hbWUgdGVtcG9yYXJ5IGNvbW1pdC1ncmFwaCBmaWxlIgogbXNnc3RyICLml6Dms5Xph43lkb3lkI3kuLTml7bmj5DkuqTlm77lvaLmlofku7YiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjE2MjEKKyM6IGNvbW1pdC1ncmFwaC5jOjE2MzUKIG1zZ2lkICJTY2FubmluZyBtZXJnZWQgY29tbWl0cyIKIG1zZ3N0ciAi5q2j5Zyo5omr5o+P5ZCI5bm25o+Q5LqkIgogCi0jOiBjb21taXQtZ3JhcGguYzoxNjMyCisjOiBjb21taXQtZ3JhcGguYzoxNjQ2CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuZXhwZWN0ZWQgZHVwbGljYXRlIGNvbW1pdCBpZCAlcyIKIG1zZ3N0ciAi5oSP5aSW55qE6YeN5aSN5o+Q5LqkIElEICVzIgogCi0jOiBjb21taXQtZ3JhcGguYzoxNjU3CisjOiBjb21taXQtZ3JhcGguYzoxNjcwCiBtc2dpZCAiTWVyZ2luZyBjb21taXQtZ3JhcGgiCiBtc2dzdHIgIuato+WcqOWQiOW5tuaPkOS6pOWbvuW9oiIKIAotIzogY29tbWl0LWdyYXBoLmM6MTg0NAorIzogY29tbWl0LWdyYXBoLmM6MTg2MAogIywgYy1mb3JtYXQKIG1zZ2lkICJ0aGUgY29tbWl0IGdyYXBoIGZvcm1hdCBjYW5ub3Qgd3JpdGUgJWQgY29tbWl0cyIKIG1zZ3N0ciAi5o+Q5Lqk5Zu+5qC85byP5LiN6IO95YaZ5YWlICVkIOS4quaPkOS6pCIKIAotIzogY29tbWl0LWdyYXBoLmM6MTg1NQorIzogY29tbWl0LWdyYXBoLmM6MTg3MQogbXNnaWQgInRvbyBtYW55IGNvbW1pdHMgdG8gd3JpdGUgZ3JhcGgiCiBtc2dzdHIgIuaPkOS6pOWkquWkmuS4jeiDveeUu+WbviIKIAotIzogY29tbWl0LWdyYXBoLmM6MTk0NQorIzogY29tbWl0LWdyYXBoLmM6MTk2MQogbXNnaWQgInRoZSBjb21taXQtZ3JhcGggZmlsZSBoYXMgaW5jb3JyZWN0IGNoZWNrc3VtIGFuZCBpcyBsaWtlbHkgY29ycnVwdCIKIG1zZ3N0ciAi5o+Q5Lqk5Zu+5paH5Lu255qE5qCh6aqM56CB6ZSZ6K+v77yM5Y+v6IO95bey57uP5o2f5Z2PIgogCi0jOiBjb21taXQtZ3JhcGguYzoxOTU1CisjOiBjb21taXQtZ3JhcGguYzoxOTcxCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvbW1pdC1ncmFwaCBoYXMgaW5jb3JyZWN0IE9JRCBvcmRlcjogJXMgdGhlbiAlcyIKIG1zZ3N0ciAi5o+Q5Lqk5Zu+5b2i55qE5a+56LGhIElEIOmhuuW6j+S4jeato+ehru+8miVzIOeEtuWQjiAlcyIKIAotIzogY29tbWl0LWdyYXBoLmM6MTk2NSBjb21taXQtZ3JhcGguYzoxOTgwCisjOiBjb21taXQtZ3JhcGguYzoxOTgxIGNvbW1pdC1ncmFwaC5jOjE5OTYKICMsIGMtZm9ybWF0CiBtc2dpZCAiY29tbWl0LWdyYXBoIGhhcyBpbmNvcnJlY3QgZmFub3V0IHZhbHVlOiBmYW5vdXRbJWRdID0gJXUgIT0gJXUiCiBtc2dzdHIgIuaPkOS6pOWbvuW9ouacieS4jeato+ehrueahOaJh+WHuuWAvO+8mmZhbm91dFslZF0gPSAldSAhPSAldSIKIAotIzogY29tbWl0LWdyYXBoLmM6MTk3MgorIzogY29tbWl0LWdyYXBoLmM6MTk4OAogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gcGFyc2UgY29tbWl0ICVzIGZyb20gY29tbWl0LWdyYXBoIgogbXNnc3RyICLml6Dms5Xku47mj5DkuqTlm77lvaLkuK3op6PmnpDmj5DkuqQgJXMiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjE5ODkKKyM6IGNvbW1pdC1ncmFwaC5jOjIwMDYKIG1zZ2lkICJWZXJpZnlpbmcgY29tbWl0cyBpbiBjb21taXQgZ3JhcGgiCiBtc2dzdHIgIuato+WcqOagoemqjOaPkOS6pOWbvuS4reeahOaPkOS6pCIKIAotIzogY29tbWl0LWdyYXBoLmM6MjAwMgorIzogY29tbWl0LWdyYXBoLmM6MjAyMAogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gcGFyc2UgY29tbWl0ICVzIGZyb20gb2JqZWN0IGRhdGFiYXNlIGZvciBjb21taXQtZ3JhcGgiCiBtc2dzdHIgIuaXoOazleS7juaPkOS6pOWbvuW9oueahOWvueixoeW6k+S4reino+aekOaPkOS6pCAlcyIKIAotIzogY29tbWl0LWdyYXBoLmM6MjAwOQorIzogY29tbWl0LWdyYXBoLmM6MjAyNwogIywgYy1mb3JtYXQKIG1zZ2lkICJyb290IHRyZWUgT0lEIGZvciBjb21taXQgJXMgaW4gY29tbWl0LWdyYXBoIGlzICVzICE9ICVzIgogbXNnc3RyICLmj5DkuqTlm77lvaLkuK3nmoTmj5DkuqQgJXMg55qE5qC55qCR5a+56LGhIElEIOaYryAlcyAhPSAlcyIKIAotIzogY29tbWl0LWdyYXBoLmM6MjAxOQorIzogY29tbWl0LWdyYXBoLmM6MjAzNwogIywgYy1mb3JtYXQKIG1zZ2lkICJjb21taXQtZ3JhcGggcGFyZW50IGxpc3QgZm9yIGNvbW1pdCAlcyBpcyB0b28gbG9uZyIKIG1zZ3N0ciAi5o+Q5LqkICVzIOeahOaPkOS6pOWbvuW9oueItuaPkOS6pOWIl+ihqOWkqumVv+S6hiIKIAotIzogY29tbWl0LWdyYXBoLmM6MjAyOAorIzogY29tbWl0LWdyYXBoLmM6MjA0NgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb21taXQtZ3JhcGggcGFyZW50IGZvciAlcyBpcyAlcyAhPSAlcyIKIG1zZ3N0ciAiJXMg55qE5o+Q5Lqk5Zu+5b2i54i25o+Q5Lqk5pivICVzICE9ICVzIgogCi0jOiBjb21taXQtZ3JhcGguYzoyMDQxCisjOiBjb21taXQtZ3JhcGguYzoyMDU5CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvbW1pdC1ncmFwaCBwYXJlbnQgbGlzdCBmb3IgY29tbWl0ICVzIHRlcm1pbmF0ZXMgZWFybHkiCiBtc2dzdHIgIuaPkOS6pCAlcyDnmoTmj5DkuqTlm77lvaLniLbmj5DkuqTliJfooajov4fml6nnu4jmraIiCiAKLSM6IGNvbW1pdC1ncmFwaC5jOjIwNDYKKyM6IGNvbW1pdC1ncmFwaC5jOjIwNjQKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogImNvbW1pdC1ncmFwaCBoYXMgZ2VuZXJhdGlvbiBudW1iZXIgemVybyBmb3IgY29tbWl0ICVzLCBidXQgbm9uLXplcm8gZWxzZXdoZXJlIgogbXNnc3RyICLmj5DkuqTlm77lvaLkuK3mj5DkuqQgJXMg55qE5LiW5Luj5Y+35piv6Zu277yM5L2G5YW25a6D5Zyw5pa56Z2e6Zu2IgogCi0jOiBjb21taXQtZ3JhcGguYzoyMDUwCisjOiBjb21taXQtZ3JhcGguYzoyMDY4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJjb21taXQtZ3JhcGggaGFzIG5vbi16ZXJvIGdlbmVyYXRpb24gbnVtYmVyIGZvciBjb21taXQgJXMsIGJ1dCB6ZXJvIGVsc2V3aGVyZSIKIG1zZ3N0ciAi5o+Q5Lqk5Zu+5b2i5Lit5o+Q5LqkICVzIOeahOS4luS7o+WPt+mdnumbtu+8jOS9huWFtuWug+WcsOaWueaYr+mbtiIKIAotIzogY29tbWl0LWdyYXBoLmM6MjA2NQorIzogY29tbWl0LWdyYXBoLmM6MjA4MwogIywgYy1mb3JtYXQKIG1zZ2lkICJjb21taXQtZ3JhcGggZ2VuZXJhdGlvbiBmb3IgY29tbWl0ICVzIGlzICV1ICE9ICV1IgogbXNnc3RyICLmj5DkuqTlm77lvaLkuK3nmoTmj5DkuqQgJXMg55qE5LiW5Luj5Y+35pivICV1ICE9ICV1IgogCi0jOiBjb21taXQtZ3JhcGguYzoyMDcxCisjOiBjb21taXQtZ3JhcGguYzoyMDg5CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvbW1pdCBkYXRlIGZvciBjb21taXQgJXMgaW4gY29tbWl0LWdyYXBoIGlzICU8UFJJdU1BWD4gIT0gJTxQUkl1TUFYPiIKIG1zZ3N0ciAi5o+Q5Lqk5Zu+5b2i5Lit5o+Q5LqkICVzIOeahOaPkOS6pOaXpeacn+aYryAlPFBSSXVNQVg+ICE9ICU8UFJJdU1BWD4iCkBAIC0xNzkwLDcgKzE4MDYsNyBAQAogbXNnaWQgImtleSBkb2VzIG5vdCBjb250YWluIHZhcmlhYmxlIG5hbWU6ICVzIgogbXNnc3RyICLplK7lkI3msqHmnInljIXlkKvlj5jph4/lkI3vvJolcyIKIAotIzogY29uZmlnLmM6NDA2IHNlcXVlbmNlci5jOjI0NjMKKyM6IGNvbmZpZy5jOjQwNiBzZXF1ZW5jZXIuYzoyNDAxCiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQga2V5OiAlcyIKIG1zZ3N0ciAi5peg5pWI6ZSu5ZCN77yaJXMiCkBAIC0xOTEyLDE0OSArMTkyOCwxNDQgQEAKIG1zZ2lkICJpbnZhbGlkIG1vZGUgZm9yIG9iamVjdCBjcmVhdGlvbjogJXMiCiBtc2dzdHIgIuaXoOaViOeahOWvueixoeWIm+W7uuaooeW8j++8miVzIgogCi0jOiBjb25maWcuYzoxNDMwCisjOiBjb25maWcuYzoxNDI1CiAjLCBjLWZvcm1hdAogbXNnaWQgIm1hbGZvcm1lZCB2YWx1ZSBmb3IgJXMiCiBtc2dzdHIgIiVzIOeahOWPluWAvOagvOW8j+mUmeivryIKIAotIzogY29uZmlnLmM6MTQ1NgorIzogY29uZmlnLmM6MTQ1MQogIywgYy1mb3JtYXQKIG1zZ2lkICJtYWxmb3JtZWQgdmFsdWUgZm9yICVzOiAlcyIKIG1zZ3N0ciAiJXMg55qE5Y+W5YC85qC85byP6ZSZ6K+v77yaJXMiCiAKLSM6IGNvbmZpZy5jOjE0NTcKKyM6IGNvbmZpZy5jOjE0NTIKIG1zZ2lkICJtdXN0IGJlIG9uZSBvZiBub3RoaW5nLCBtYXRjaGluZywgc2ltcGxlLCB1cHN0cmVhbSBvciBjdXJyZW50IgogbXNnc3RyICLlv4XpobvmmK/lhbbkuK3kuYvkuIDvvJpub3RoaW5n44CBbWF0Y2hpbmfjgIFzaW1wbGXjgIF1cHN0cmVhbSDmiJYgY3VycmVudCIKIAotIzogY29uZmlnLmM6MTUxOCBidWlsdGluL3BhY2stb2JqZWN0cy5jOjM0MTAKKyM6IGNvbmZpZy5jOjE1MTMgYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzk0CiAjLCBjLWZvcm1hdAogbXNnaWQgImJhZCBwYWNrIGNvbXByZXNzaW9uIGxldmVsICVkIgogbXNnc3RyICLplJnor6/nmoTmiZPljIXljovnvKnnuqfliKsgJWQiCiAKLSM6IGNvbmZpZy5jOjE2MzkKKyM6IGNvbmZpZy5jOjE2MzQKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGxvYWQgY29uZmlnIGJsb2Igb2JqZWN0ICclcyciCiBtc2dzdHIgIuaXoOazleS7juaVsOaNruWvueixoSAnJXMnIOWKoOi9vemFjee9riIKIAotIzogY29uZmlnLmM6MTY0MgorIzogY29uZmlnLmM6MTYzNwogIywgYy1mb3JtYXQKIG1zZ2lkICJyZWZlcmVuY2UgJyVzJyBkb2VzIG5vdCBwb2ludCB0byBhIGJsb2IiCiBtc2dzdHIgIuW8leeUqCAnJXMnIOayoeacieaMh+WQkeS4gOS4quaVsOaNruWvueixoSIKIAotIzogY29uZmlnLmM6MTY1OQorIzogY29uZmlnLmM6MTY1NAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gcmVzb2x2ZSBjb25maWcgYmxvYiAnJXMnIgogbXNnc3RyICLkuI3og73op6PmnpDphY3nva7lr7nosaEgJyVzJyIKIAotIzogY29uZmlnLmM6MTY4OQorIzogY29uZmlnLmM6MTY4NAogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gcGFyc2UgJXMiCiBtc2dzdHIgIuino+aekCAlcyDlpLHotKUiCiAKLSM6IGNvbmZpZy5jOjE3NDUKKyM6IGNvbmZpZy5jOjE3NDAKIG1zZ2lkICJ1bmFibGUgdG8gcGFyc2UgY29tbWFuZC1saW5lIGNvbmZpZyIKIG1zZ3N0ciAi5peg5rOV6Kej5p6Q5ZG95Luk6KGM5Lit55qE6YWN572uIgogCi0jOiBjb25maWcuYzoyMDk0CisjOiBjb25maWcuYzoyMDkxCiBtc2dpZCAidW5rbm93biBlcnJvciBvY2N1cnJlZCB3aGlsZSByZWFkaW5nIHRoZSBjb25maWd1cmF0aW9uIGZpbGVzIgogbXNnc3RyICLlnKjor7vlj5bphY3nva7mlofku7bml7bpgYfliLDmnKrnn6XplJnor68iCiAKLSM6IGNvbmZpZy5jOjIyNjQKKyM6IGNvbmZpZy5jOjIyNjEKICMsIGMtZm9ybWF0CiBtc2dpZCAiSW52YWxpZCAlczogJyVzJyIKIG1zZ3N0ciAi5peg5pWIICVz77yaJyVzJyIKIAotIzogY29uZmlnLmM6MjMwNwotIywgYy1mb3JtYXQKLW1zZ2lkICJ1bmtub3duIGNvcmUudW50cmFja2VkQ2FjaGUgdmFsdWUgJyVzJzsgdXNpbmcgJ2tlZXAnIGRlZmF1bHQgdmFsdWUiCi1tc2dzdHIgIuacquefpeeahCBjb3JlLnVudHJhY2tlZENhY2hlIOWPluWAvCAnJXMn77yM5L2/55So6buY6K6k5YC8ICdrZWVwJyIKLQotIzogY29uZmlnLmM6MjMzMworIzogY29uZmlnLmM6MjMwNgogIywgYy1mb3JtYXQKIG1zZ2lkICJzcGxpdEluZGV4Lm1heFBlcmNlbnRDaGFuZ2UgdmFsdWUgJyVkJyBzaG91bGQgYmUgYmV0d2VlbiAwIGFuZCAxMDAiCiBtc2dzdHIgInNwbGl0SW5kZXgubWF4UGVyY2VudENoYW5nZSDnmoTlj5blgLwgJyVkJyDlupTor6Xku4vkuo4gMCDlkowgMTAwIOS5i+mXtCIKIAotIzogY29uZmlnLmM6MjM3OQorIzogY29uZmlnLmM6MjM1MgogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gcGFyc2UgJyVzJyBmcm9tIGNvbW1hbmQtbGluZSBjb25maWciCiBtc2dzdHIgIuaXoOazleino+aekOWRveS7pOihjOmFjee9ruS4reeahCAnJXMnIgogCi0jOiBjb25maWcuYzoyMzgxCisjOiBjb25maWcuYzoyMzU0CiAjLCBjLWZvcm1hdAogbXNnaWQgImJhZCBjb25maWcgdmFyaWFibGUgJyVzJyBpbiBmaWxlICclcycgYXQgbGluZSAlZCIKIG1zZ3N0ciAi5Zyo5paH5Lu2ICclMiRzJyDnmoTnrKwgJTMkZCDooYzlj5HnjrDplJnor6/nmoTphY3nva7lj5jph48gJyUxJHMnIgogCi0jOiBjb25maWcuYzoyNDYyCisjOiBjb25maWcuYzoyNDM1CiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgc2VjdGlvbiBuYW1lICclcyciCiBtc2dzdHIgIuaXoOaViOeahOWwj+iKguWQjeensCAnJXMnIgogCi0jOiBjb25maWcuYzoyNDk0CisjOiBjb25maWcuYzoyNDY3CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIGhhcyBtdWx0aXBsZSB2YWx1ZXMiCiBtc2dzdHIgIiVzIOacieWkmuS4quWPluWAvCIKIAotIzogY29uZmlnLmM6MjUyMworIzogY29uZmlnLmM6MjQ5NgogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gd3JpdGUgbmV3IGNvbmZpZ3VyYXRpb24gZmlsZSAlcyIKIG1zZ3N0ciAi5YaZ5YWl5paw55qE6YWN572u5paH5Lu2ICVzIOWksei0pSIKIAotIzogY29uZmlnLmM6Mjc3NSBjb25maWcuYzozMDk5CisjOiBjb25maWcuYzoyNzQ4IGNvbmZpZy5jOjMwNzIKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGxvY2sgY29uZmlnIGZpbGUgJXMiCiBtc2dzdHIgIuS4jeiDvemUgeWumumFjee9ruaWh+S7tiAlcyIKIAotIzogY29uZmlnLmM6Mjc4NgorIzogY29uZmlnLmM6Mjc1OQogIywgYy1mb3JtYXQKIG1zZ2lkICJvcGVuaW5nICVzIgogbXNnc3RyICLmiZPlvIAgJXMiCiAKLSM6IGNvbmZpZy5jOjI4MjEgYnVpbHRpbi9jb25maWcuYzozMjgKKyM6IGNvbmZpZy5jOjI3OTQgYnVpbHRpbi9jb25maWcuYzozMjgKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBwYXR0ZXJuOiAlcyIKIG1zZ3N0ciAi5peg5pWI5qih5byP77yaJXMiCiAKLSM6IGNvbmZpZy5jOjI4NDYKKyM6IGNvbmZpZy5jOjI4MTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBjb25maWcgZmlsZSAlcyIKIG1zZ3N0ciAi5peg5pWI55qE6YWN572u5paH5Lu2ICVzIgogCi0jOiBjb25maWcuYzoyODU5IGNvbmZpZy5jOjMxMTIKKyM6IGNvbmZpZy5jOjI4MzIgY29uZmlnLmM6MzA4NQogIywgYy1mb3JtYXQKIG1zZ2lkICJmc3RhdCBvbiAlcyBmYWlsZWQiCiBtc2dzdHIgIuWvuSAlcyDosIPnlKggZnN0YXQg5aSx6LSlIgogCi0jOiBjb25maWcuYzoyODcwCisjOiBjb25maWcuYzoyODQzCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBtbWFwICclcyciCiBtc2dzdHIgIuS4jeiDvSBtbWFwICclcyciCiAKLSM6IGNvbmZpZy5jOjI4NzkgY29uZmlnLmM6MzExNworIzogY29uZmlnLmM6Mjg1MiBjb25maWcuYzozMDkwCiAjLCBjLWZvcm1hdAogbXNnaWQgImNobW9kIG9uICVzIGZhaWxlZCIKIG1zZ3N0ciAi5a+5ICVzIOiwg+eUqCBjaG1vZCDlpLHotKUiCiAKLSM6IGNvbmZpZy5jOjI5NjQgY29uZmlnLmM6MzIxNAorIzogY29uZmlnLmM6MjkzNyBjb25maWcuYzozMTg3CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCB3cml0ZSBjb25maWcgZmlsZSAlcyIKIG1zZ3N0ciAi5LiN6IO95YaZ5YWl6YWN572u5paH5Lu2ICVzIgogCi0jOiBjb25maWcuYzoyOTk4CisjOiBjb25maWcuYzoyOTcxCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBzZXQgJyVzJyB0byAnJXMnIgogbXNnc3RyICLkuI3og73orr7nva4gJyVzJyDkuLogJyVzJyIKIAotIzogY29uZmlnLmM6MzAwMCBidWlsdGluL3JlbW90ZS5jOjc4MgorIzogY29uZmlnLmM6Mjk3MyBidWlsdGluL3JlbW90ZS5jOjc4MgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgdW5zZXQgJyVzJyIKIG1zZ3N0ciAi5LiN6IO95Y+W5raI6K6+572uICclcyciCiAKLSM6IGNvbmZpZy5jOjMwOTAKKyM6IGNvbmZpZy5jOjMwNjMKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBzZWN0aW9uIG5hbWU6ICVzIgogbXNnc3RyICLml6DmlYjnmoTlsI/oioLlkI3np7DvvJolcyIKIAotIzogY29uZmlnLmM6MzI1NworIzogY29uZmlnLmM6MzIzMAogIywgYy1mb3JtYXQKIG1zZ2lkICJtaXNzaW5nIHZhbHVlIGZvciAnJXMnIgogbXNnc3RyICIlcyDnmoTlj5blgLznvLrlpLEiCkBAIC0yMTc3LDcgKzIxODgsNyBAQAogbXNnaWQgInVua25vd24gcG9ydCAlcyIKIG1zZ3N0ciAi5pyq55+l56uv5Y+jICVzIgogCi0jOiBjb25uZWN0LmM6ODQ1IGNvbm5lY3QuYzoxMTcxCisjOiBjb25uZWN0LmM6ODQ1IGNvbm5lY3QuYzoxMTc1CiAjLCBjLWZvcm1hdAogbXNnaWQgInN0cmFuZ2UgaG9zdG5hbWUgJyVzJyBibG9ja2VkIgogbXNnc3RyICLlt7LpmLvmraLlpYfmgKrnmoTkuLvmnLrlkI0gJyVzJyIKQEAgLTIxOTIsNTggKzIyMDMsNTggQEAKIG1zZ2lkICJjYW5ub3Qgc3RhcnQgcHJveHkgJXMiCiBtc2dzdHIgIuS4jeiDveWQr+WKqOS7o+eQhiAlcyIKIAotIzogY29ubmVjdC5jOjkyNAorIzogY29ubmVjdC5jOjkyOAogbXNnaWQgIm5vIHBhdGggc3BlY2lmaWVkOyBzZWUgJ2dpdCBoZWxwIHB1bGwnIGZvciB2YWxpZCB1cmwgc3ludGF4IgogbXNnc3RyICLmnKrmjIflrprot6/lvoTvvIzmiafooYwgJ2dpdCBoZWxwIHB1bGwnIOafpeeci+acieaViOeahCB1cmwg6K+t5rOVIgogCi0jOiBjb25uZWN0LmM6MTExOQorIzogY29ubmVjdC5jOjExMjMKIG1zZ2lkICJzc2ggdmFyaWFudCAnc2ltcGxlJyBkb2VzIG5vdCBzdXBwb3J0IC00IgogbXNnc3RyICJzc2gg5Y+Y5L2TICdzaW1wbGUnIOS4jeaUr+aMgSAtNCIKIAotIzogY29ubmVjdC5jOjExMzEKKyM6IGNvbm5lY3QuYzoxMTM1CiBtc2dpZCAic3NoIHZhcmlhbnQgJ3NpbXBsZScgZG9lcyBub3Qgc3VwcG9ydCAtNiIKIG1zZ3N0ciAic3NoIOWPmOS9kyAnc2ltcGxlJyDkuI3mlK/mjIEgLTYiCiAKLSM6IGNvbm5lY3QuYzoxMTQ4CisjOiBjb25uZWN0LmM6MTE1MgogbXNnaWQgInNzaCB2YXJpYW50ICdzaW1wbGUnIGRvZXMgbm90IHN1cHBvcnQgc2V0dGluZyBwb3J0IgogbXNnc3RyICJzc2gg5Y+Y5L2TICdzaW1wbGUnIOS4jeaUr+aMgeiuvue9ruerr+WPoyIKIAotIzogY29ubmVjdC5jOjEyNjAKKyM6IGNvbm5lY3QuYzoxMjY0CiAjLCBjLWZvcm1hdAogbXNnaWQgInN0cmFuZ2UgcGF0aG5hbWUgJyVzJyBibG9ja2VkIgogbXNnc3RyICLlt7LpmLvmraLlpYfmgKrnmoTot6/lvoTlkI0gJyVzJyIKIAotIzogY29ubmVjdC5jOjEzMDcKKyM6IGNvbm5lY3QuYzoxMzExCiBtc2dpZCAidW5hYmxlIHRvIGZvcmsiCiBtc2dzdHIgIuaXoOazlSBmb3JrIgogCi0jOiBjb25uZWN0ZWQuYzo4NiBidWlsdGluL2ZzY2suYzoyMjEgYnVpbHRpbi9wcnVuZS5jOjQzCisjOiBjb25uZWN0ZWQuYzo4OCBidWlsdGluL2ZzY2suYzoyMjEgYnVpbHRpbi9wcnVuZS5jOjQzCiBtc2dpZCAiQ2hlY2tpbmcgY29ubmVjdGl2aXR5IgogbXNnc3RyICLmraPlnKjmo4Dmn6Xov57pgJrmgKciCiAKLSM6IGNvbm5lY3RlZC5jOjk4CisjOiBjb25uZWN0ZWQuYzoxMDAKIG1zZ2lkICJDb3VsZCBub3QgcnVuICdnaXQgcmV2LWxpc3QnIgogbXNnc3RyICLkuI3og73miafooYwgJ2dpdCByZXYtbGlzdCciCiAKLSM6IGNvbm5lY3RlZC5jOjExOAorIzogY29ubmVjdGVkLmM6MTIwCiBtc2dpZCAiZmFpbGVkIHdyaXRlIHRvIHJldi1saXN0IgogbXNnc3RyICLlhpnlhaUgcmV2LWxpc3Qg5aSx6LSlIgogCi0jOiBjb25uZWN0ZWQuYzoxMjUKKyM6IGNvbm5lY3RlZC5jOjEyNwogbXNnaWQgImZhaWxlZCB0byBjbG9zZSByZXYtbGlzdCdzIHN0ZGluIgogbXNnc3RyICLlhbPpl60gcmV2LWxpc3Qg55qE5qCH5YeG6L6T5YWl5aSx6LSlIgogCi0jOiBjb252ZXJ0LmM6MTkzCisjOiBjb252ZXJ0LmM6MTk0CiAjLCBjLWZvcm1hdAogbXNnaWQgImlsbGVnYWwgY3JsZl9hY3Rpb24gJWQiCiBtc2dzdHIgIumdnuazleeahCBjcmxmIOWKqOS9nCAlZCIKIAotIzogY29udmVydC5jOjIwNgorIzogY29udmVydC5jOjIwNwogIywgYy1mb3JtYXQKIG1zZ2lkICJDUkxGIHdvdWxkIGJlIHJlcGxhY2VkIGJ5IExGIGluICVzIgogbXNnc3RyICIlcyDkuK3nmoQgQ1JMRiDlsIbooqsgTEYg5pu/5o2iIgogCi0jOiBjb252ZXJ0LmM6MjA4CisjOiBjb252ZXJ0LmM6MjA5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJDUkxGIHdpbGwgYmUgcmVwbGFjZWQgYnkgTEYgaW4gJXMuXG4iCkBAIC0yMjUyLDEyICsyMjYzLDEyIEBACiAiJXMg5Lit55qEIENSTEYg5bCG6KKrIExGIOabv+aNouOAgjxcbiIKICLlnKjlt6XkvZzljLrkuK3or6Xmlofku7bku43kv53mjIHljp/mnInnmoTmjaLooYznrKbjgIIiCiAKLSM6IGNvbnZlcnQuYzoyMTYKKyM6IGNvbnZlcnQuYzoyMTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiTEYgd291bGQgYmUgcmVwbGFjZWQgYnkgQ1JMRiBpbiAlcyIKIG1zZ3N0ciAi5paH5Lu2ICVzIOS4reeahCBMRiDlsIbooqsgQ1JMRiDmm7/mjaIiCiAKLSM6IGNvbnZlcnQuYzoyMTgKKyM6IGNvbnZlcnQuYzoyMTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkxGIHdpbGwgYmUgcmVwbGFjZWQgYnkgQ1JMRiBpbiAlcy5cbiIKQEAgLTIyNjYsMjQgKzIyNzcsMjQgQEAKICIlcyDkuK3nmoQgTEYg5bCG6KKrIENSTEYg5pu/5o2i44CCXG4iCiAi5Zyo5bel5L2c5Yy65Lit6K+l5paH5Lu25LuN5L+d5oyB5Y6f5pyJ55qE5o2i6KGM56ymIgogCi0jOiBjb252ZXJ0LmM6Mjc5CisjOiBjb252ZXJ0LmM6MjgwCiAjLCBjLWZvcm1hdAogbXNnaWQgIkJPTSBpcyBwcm9oaWJpdGVkIGluICclcycgaWYgZW5jb2RlZCBhcyAlcyIKIG1zZ3N0ciAi5aaC5p6c5L2/55SoICUyJHMg57yW56CB77yM56aB5q2i5ZyoICclMSRzJyDkuK3kvb/nlKggQk9NIgogCi0jOiBjb252ZXJ0LmM6Mjg2CisjOiBjb252ZXJ0LmM6Mjg3CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgZmlsZSAnJXMnIGNvbnRhaW5zIGEgYnl0ZSBvcmRlciBtYXJrIChCT00pLiBQbGVhc2UgdXNlIFVURi0lcyBhcyB3b3JraW5nLSIKICJ0cmVlLWVuY29kaW5nLiIKIG1zZ3N0ciAi5paH5Lu2ICclcycg5YyF5ZCr5LiA5Liq5a2X6IqC6aG65bqP5qCH6K6w77yIQk9N77yJ44CC6K+35L2/55SoIFVURi0lcyDkvZzkuLrlt6XkvZzljLrnvJbnoIHjgIIiCiAKLSM6IGNvbnZlcnQuYzozMDQKKyM6IGNvbnZlcnQuYzozMDUKICMsIGMtZm9ybWF0CiBtc2dpZCAiQk9NIGlzIHJlcXVpcmVkIGluICclcycgaWYgZW5jb2RlZCBhcyAlcyIKIG1zZ3N0ciAi5aaC5p6c57yW56CB5Li6ICUyJHPvvIzpnIDopoHlnKggJyUxJHMnIOS4reS9v+eUqCBCT00iCiAKLSM6IGNvbnZlcnQuYzozMDYKKyM6IGNvbnZlcnQuYzozMDcKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlRoZSBmaWxlICclcycgaXMgbWlzc2luZyBhIGJ5dGUgb3JkZXIgbWFyayAoQk9NKS4gUGxlYXNlIHVzZSBVVEYtJXNCRSBvciBVVEYtIgpAQCAtMjI5MiwxMTcgKzIzMDMsMTE3IEBACiAi5paH5Lu2ICclcycg57y65aSx5LiA5Liq5a2X6IqC6aG65bqP5qCH6K6w77yIQk9N77yJ44CC6K+35L2/55SoIFVURi0lc0JFIG9yIFVURi0lc0xF77yI5Y+W5Yaz5LqO5a2XIgogIuiKguW6j++8ieS9nOS4uuW3peS9nOWMuue8lueggeOAgiIKIAotIzogY29udmVydC5jOjQyNCBjb252ZXJ0LmM6NDk1CisjOiBjb252ZXJ0LmM6NDI1IGNvbnZlcnQuYzo0OTYKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIGVuY29kZSAnJXMnIGZyb20gJXMgdG8gJXMiCiBtc2dzdHIgIuaXoOazleWvuSAnJXMnIOi/m+ihjOS7jiAlcyDliLAgJXMg55qE57yW56CBIgogCi0jOiBjb252ZXJ0LmM6NDY3CisjOiBjb252ZXJ0LmM6NDY4CiAjLCBjLWZvcm1hdAogbXNnaWQgImVuY29kaW5nICclcycgZnJvbSAlcyB0byAlcyBhbmQgYmFjayBpcyBub3QgdGhlIHNhbWUiCiBtc2dzdHIgIuWwhiclcycg55qE57yW56CB5LuOICVzIOWIsCAlcyDmnaXlm57ovazmjaLkuI3kuIDoh7QiCiAKLSM6IGNvbnZlcnQuYzo2NzMKKyM6IGNvbnZlcnQuYzo2NzQKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IGZvcmsgdG8gcnVuIGV4dGVybmFsIGZpbHRlciAnJXMnIgogbXNnc3RyICLkuI3og70gZm9yayDku6XmiafooYzlpJbpg6jov4fmu6TlmaggJyVzJyIKIAotIzogY29udmVydC5jOjY5MworIzogY29udmVydC5jOjY5NAogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgZmVlZCB0aGUgaW5wdXQgdG8gZXh0ZXJuYWwgZmlsdGVyICclcyciCiBtc2dzdHIgIuS4jeiDveWwhui+k+WFpeS8oOmAkue7meWklumDqOi/h+a7pOWZqCAnJXMnIgogCi0jOiBjb252ZXJ0LmM6NzAwCisjOiBjb252ZXJ0LmM6NzAxCiAjLCBjLWZvcm1hdAogbXNnaWQgImV4dGVybmFsIGZpbHRlciAnJXMnIGZhaWxlZCAlZCIKIG1zZ3N0ciAi5aSW6YOo6L+H5ruk5ZmoICclcycg5aSx6LSl56CBICVkIgogCi0jOiBjb252ZXJ0LmM6NzM1IGNvbnZlcnQuYzo3MzgKKyM6IGNvbnZlcnQuYzo3MzYgY29udmVydC5jOjczOQogIywgYy1mb3JtYXQKIG1zZ2lkICJyZWFkIGZyb20gZXh0ZXJuYWwgZmlsdGVyICclcycgZmFpbGVkIgogbXNnc3RyICLku47lpJbpg6jov4fmu6TlmaggJyVzJyDor7vlj5blpLHotKUiCiAKLSM6IGNvbnZlcnQuYzo3NDEgY29udmVydC5jOjc5NgorIzogY29udmVydC5jOjc0MiBjb252ZXJ0LmM6Nzk3CiAjLCBjLWZvcm1hdAogbXNnaWQgImV4dGVybmFsIGZpbHRlciAnJXMnIGZhaWxlZCIKIG1zZ3N0ciAi5aSW6YOo6L+H5ruk5ZmoICclcycg5aSx6LSlIgogCi0jOiBjb252ZXJ0LmM6ODQ0CisjOiBjb252ZXJ0LmM6ODQ1CiBtc2dpZCAidW5leHBlY3RlZCBmaWx0ZXIgdHlwZSIKIG1zZ3N0ciAi5oSP5aSW55qE6L+H5ruk57G75Z6LIgogCi0jOiBjb252ZXJ0LmM6ODU1CisjOiBjb252ZXJ0LmM6ODU2CiBtc2dpZCAicGF0aCBuYW1lIHRvbyBsb25nIGZvciBleHRlcm5hbCBmaWx0ZXIiCiBtc2dzdHIgIuWklumDqOi/h+a7pOWZqOeahOi3r+W+hOWQjeWkqumVvyIKIAotIzogY29udmVydC5jOjkyOQorIzogY29udmVydC5jOjkzMAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiZXh0ZXJuYWwgZmlsdGVyICclcycgaXMgbm90IGF2YWlsYWJsZSBhbnltb3JlIGFsdGhvdWdoIG5vdCBhbGwgcGF0aHMgaGF2ZSAiCiAiYmVlbiBmaWx0ZXJlZCIKIG1zZ3N0ciAi5aSW6YOo6L+H5ruk5ZmoICclcycg5LiN5YaN5Y+v55So77yM5L2G5bm26Z2e5omA5pyJ6Lev5b6E6YO95bey6L+H5rukIgogCi0jOiBjb252ZXJ0LmM6MTIyOAorIzogY29udmVydC5jOjEyMjkKIG1zZ2lkICJ0cnVlL2ZhbHNlIGFyZSBubyB2YWxpZCB3b3JraW5nLXRyZWUtZW5jb2RpbmdzIgogbXNnc3RyICJ0cnVlL2ZhbHNlIOS4jeaYr+acieaViOeahOW3peS9nOWMuue8lueggSIKIAotIzogY29udmVydC5jOjEzOTggY29udmVydC5jOjE0MzIKKyM6IGNvbnZlcnQuYzoxNDE3IGNvbnZlcnQuYzoxNDUxCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiBjbGVhbiBmaWx0ZXIgJyVzJyBmYWlsZWQiCiBtc2dzdHIgIiVz77yaY2xlYW4g6L+H5ruk5ZmoICclcycg5aSx6LSlIgogCi0jOiBjb252ZXJ0LmM6MTQ3NgorIzogY29udmVydC5jOjE0OTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXM6IHNtdWRnZSBmaWx0ZXIgJXMgZmFpbGVkIgogbXNnc3RyICIlc++8mnNtdWRnZSDov4fmu6TlmaggJXMg5aSx6LSlIgogCi0jOiBkYXRlLmM6MTM3CisjOiBkYXRlLmM6MTM4CiBtc2dpZCAiaW4gdGhlIGZ1dHVyZSIKIG1zZ3N0ciAi5Zyo5bCG5p2lIgogCi0jOiBkYXRlLmM6MTQzCisjOiBkYXRlLmM6MTQ0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiU8UFJJdU1BWD4gc2Vjb25kIGFnbyIKIG1zZ2lkX3BsdXJhbCAiJTxQUkl1TUFYPiBzZWNvbmRzIGFnbyIKIG1zZ3N0clswXSAiJTxQUkl1TUFYPiDnp5Lpkp/liY0iCiBtc2dzdHJbMV0gIiU8UFJJdU1BWD4g56eS6ZKf5YmNIgogCi0jOiBkYXRlLmM6MTUwCisjOiBkYXRlLmM6MTUxCiAjLCBjLWZvcm1hdAogbXNnaWQgIiU8UFJJdU1BWD4gbWludXRlIGFnbyIKIG1zZ2lkX3BsdXJhbCAiJTxQUkl1TUFYPiBtaW51dGVzIGFnbyIKIG1zZ3N0clswXSAiJTxQUkl1TUFYPiDliIbpkp/liY0iCiBtc2dzdHJbMV0gIiU8UFJJdU1BWD4g5YiG6ZKf5YmNIgogCi0jOiBkYXRlLmM6MTU3CisjOiBkYXRlLmM6MTU4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiU8UFJJdU1BWD4gaG91ciBhZ28iCiBtc2dpZF9wbHVyYWwgIiU8UFJJdU1BWD4gaG91cnMgYWdvIgogbXNnc3RyWzBdICIlPFBSSXVNQVg+IOWwj+aXtuWJjSIKIG1zZ3N0clsxXSAiJTxQUkl1TUFYPiDlsI/ml7bliY0iCiAKLSM6IGRhdGUuYzoxNjQKKyM6IGRhdGUuYzoxNjUKICMsIGMtZm9ybWF0CiBtc2dpZCAiJTxQUkl1TUFYPiBkYXkgYWdvIgogbXNnaWRfcGx1cmFsICIlPFBSSXVNQVg+IGRheXMgYWdvIgogbXNnc3RyWzBdICIlPFBSSXVNQVg+IOWkqeWJjSIKIG1zZ3N0clsxXSAiJTxQUkl1TUFYPiDlpKnliY0iCiAKLSM6IGRhdGUuYzoxNzAKKyM6IGRhdGUuYzoxNzEKICMsIGMtZm9ybWF0CiBtc2dpZCAiJTxQUkl1TUFYPiB3ZWVrIGFnbyIKIG1zZ2lkX3BsdXJhbCAiJTxQUkl1TUFYPiB3ZWVrcyBhZ28iCiBtc2dzdHJbMF0gIiU8UFJJdU1BWD4g5ZGo5YmNIgogbXNnc3RyWzFdICIlPFBSSXVNQVg+IOWRqOWJjSIKIAotIzogZGF0ZS5jOjE3NworIzogZGF0ZS5jOjE3OAogIywgYy1mb3JtYXQKIG1zZ2lkICIlPFBSSXVNQVg+IG1vbnRoIGFnbyIKIG1zZ2lkX3BsdXJhbCAiJTxQUkl1TUFYPiBtb250aHMgYWdvIgogbXNnc3RyWzBdICIlPFBSSXVNQVg+IOS4quaciOWJjSIKIG1zZ3N0clsxXSAiJTxQUkl1TUFYPiDkuKrmnIjliY0iCiAKLSM6IGRhdGUuYzoxODgKKyM6IGRhdGUuYzoxODkKICMsIGMtZm9ybWF0CiBtc2dpZCAiJTxQUkl1TUFYPiB5ZWFyIgogbXNnaWRfcGx1cmFsICIlPFBSSXVNQVg+IHllYXJzIgpAQCAtMjQxMCwxNCArMjQyMSwxNCBAQAogbXNnc3RyWzFdICIlPFBSSXVNQVg+IOW5tCIKIAogIy4gVFJBTlNMQVRPUlM6ICIlcyIgaXMgIjxuPiB5ZWFycyIKLSM6IGRhdGUuYzoxOTEKKyM6IGRhdGUuYzoxOTIKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMsICU8UFJJdU1BWD4gbW9udGggYWdvIgogbXNnaWRfcGx1cmFsICIlcywgJTxQUkl1TUFYPiBtb250aHMgYWdvIgogbXNnc3RyWzBdICIlcyAlPFBSSXVNQVg+IOS4quaciOWJjSIKIG1zZ3N0clsxXSAiJXMgJTxQUkl1TUFYPiDkuKrmnIjliY0iCiAKLSM6IGRhdGUuYzoxOTYgZGF0ZS5jOjIwMQorIzogZGF0ZS5jOjE5NyBkYXRlLmM6MjAyCiAjLCBjLWZvcm1hdAogbXNnaWQgIiU8UFJJdU1BWD4geWVhciBhZ28iCiBtc2dpZF9wbHVyYWwgIiU8UFJJdU1BWD4geWVhcnMgYWdvIgpAQCAtMjQ1Myw3ICsyNDY0LDcgQEAKIG1zZ2lkICJmYWlsZWQgdG8gcmVhZCBvcmRlcmZpbGUgJyVzJyIKIG1zZ3N0ciAi6K+75Y+W5o6S5bqP5paH5Lu2ICclcycg5aSx6LSlIgogCi0jOiBkaWZmY29yZS1yZW5hbWUuYzo1NDQKKyM6IGRpZmZjb3JlLXJlbmFtZS5jOjU0MwogbXNnaWQgIlBlcmZvcm1pbmcgaW5leGFjdCByZW5hbWUgZGV0ZWN0aW9uIgogbXNnc3RyICLmraPlnKjov5vooYzpnZ7nsr7noa7nmoTph43lkb3lkI3mjqLmtYsiCiAKQEAgLTI1MTYsMzUgKzI1MjcsMzUgQEAKICLlj5HnjrDphY3nva7lj5jph48gJ2RpZmYuZGlyc3RhdCcg5Lit55qE6ZSZ6K+v77yaXG4iCiAiJXMiCiAKLSM6IGRpZmYuYzo0MjE1CisjOiBkaWZmLmM6NDIxOAogIywgYy1mb3JtYXQKIG1zZ2lkICJleHRlcm5hbCBkaWZmIGRpZWQsIHN0b3BwaW5nIGF0ICVzIgogbXNnc3RyICLlpJbpg6ggZGlmZiDpgIDlh7rvvIzlgZzmraLlnKggJXMiCiAKLSM6IGRpZmYuYzo0NTYwCisjOiBkaWZmLmM6NDU2MwogbXNnaWQgIi0tbmFtZS1vbmx5LCAtLW5hbWUtc3RhdHVzLCAtLWNoZWNrIGFuZCAtcyBhcmUgbXV0dWFsbHkgZXhjbHVzaXZlIgogbXNnc3RyICItLW5hbWUtb25seeOAgS0tbmFtZS1zdGF0dXPjgIEtLWNoZWNrIOWSjCAtcyDmmK/kupLmlqXnmoQiCiAKLSM6IGRpZmYuYzo0NTYzCisjOiBkaWZmLmM6NDU2NgogbXNnaWQgIi1HLCAtUyBhbmQgLS1maW5kLW9iamVjdCBhcmUgbXV0dWFsbHkgZXhjbHVzaXZlIgogbXNnc3RyICItR+OAgS1TIOWSjCAtLWZpbmQtb2JqZWN0IOaYr+S6kuaWpeeahCIKIAotIzogZGlmZi5jOjQ2NDEKKyM6IGRpZmYuYzo0NjQ0CiBtc2dpZCAiLS1mb2xsb3cgcmVxdWlyZXMgZXhhY3RseSBvbmUgcGF0aHNwZWMiCiBtc2dzdHIgIi0tZm9sbG93IOaYjuehruimgeaxguWPqui3n+S4gOS4qui3r+W+hOinhOagvCIKIAotIzogZGlmZi5jOjQ2ODkKKyM6IGRpZmYuYzo0NjkyCiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgLS1zdGF0IHZhbHVlOiAlcyIKIG1zZ3N0ciAi5peg5pWI55qEIC0tc3RhdCDlgLzvvJolcyIKIAotIzogZGlmZi5jOjQ2OTQgZGlmZi5jOjQ2OTkgZGlmZi5jOjQ3MDQgZGlmZi5jOjQ3MDkgZGlmZi5jOjUyMjIKKyM6IGRpZmYuYzo0Njk3IGRpZmYuYzo0NzAyIGRpZmYuYzo0NzA3IGRpZmYuYzo0NzEyIGRpZmYuYzo1MjI1CiAjOiBwYXJzZS1vcHRpb25zLmM6MTk5IHBhcnNlLW9wdGlvbnMuYzoyMDMKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgZXhwZWN0cyBhIG51bWVyaWNhbCB2YWx1ZSIKIG1zZ3N0ciAiJXMg5pyf5pyb5LiA5Liq5pWw5a2X5YC8IgogCi0jOiBkaWZmLmM6NDcyNgorIzogZGlmZi5jOjQ3MjkKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkZhaWxlZCB0byBwYXJzZSAtLWRpcnN0YXQvLVggb3B0aW9uIHBhcmFtZXRlcjpcbiIKQEAgLTI1NTMsMTk1ICsyNTY0LDE5NSBAQAogIuaXoOazleino+aekCAtLWRpcnN0YXQvLVgg6YCJ6aG555qE5Y+C5pWw77yaXG4iCiAiJXMiCiAKLSM6IGRpZmYuYzo0ODExCisjOiBkaWZmLmM6NDgxNAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmtub3duIGNoYW5nZSBjbGFzcyAnJWMnIGluIC0tZGlmZi1maWx0ZXI9JXMiCiBtc2dzdHIgIi0tZGlmZi1maWx0ZXI9JTIkcyDkuK3mnKrnn6XnmoTlj5jmm7TnsbsgJyUxJGMnIgogCi0jOiBkaWZmLmM6NDgzNQorIzogZGlmZi5jOjQ4MzgKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5rbm93biB2YWx1ZSBhZnRlciB3cy1lcnJvci1oaWdobGlnaHQ9JS4qcyIKIG1zZ3N0ciAid3MtZXJyb3ItaGlnaGxpZ2h0PSUuKnMg5LmL5ZCO5pyq55+l55qE5YC8IgogCi0jOiBkaWZmLmM6NDg0OQorIzogZGlmZi5jOjQ4NTIKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHJlc29sdmUgJyVzJyIKIG1zZ3N0ciAi5LiN6IO96Kej5p6QICclcyciCiAKLSM6IGRpZmYuYzo0ODk5IGRpZmYuYzo0OTA1CisjOiBkaWZmLmM6NDkwMiBkaWZmLmM6NDkwOAogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyBleHBlY3RzIDxuPi88bT4gZm9ybSIKIG1zZ3N0ciAiJXMg5pyf5pybIDxuPi88bT4g5qC85byPIgogCi0jOiBkaWZmLmM6NDkxNworIzogZGlmZi5jOjQ5MjAKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgZXhwZWN0cyBhIGNoYXJhY3RlciwgZ290ICclcyciCiBtc2dzdHIgIiVzIOacn+acm+S4gOS4quWtl+espu+8jOW+l+WIsCAnJXMnIgogCi0jOiBkaWZmLmM6NDkzOAorIzogZGlmZi5jOjQ5NDEKICMsIGMtZm9ybWF0CiBtc2dpZCAiYmFkIC0tY29sb3ItbW92ZWQgYXJndW1lbnQ6ICVzIgogbXNnc3RyICLlnY/nmoQgLS1jb2xvci1tb3ZlZCDlj4LmlbDvvJolcyIKIAotIzogZGlmZi5jOjQ5NTcKKyM6IGRpZmYuYzo0OTYwCiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgbW9kZSAnJXMnIGluIC0tY29sb3ItbW92ZWQtd3MiCiBtc2dzdHIgIi0tY29sb3ItbW92ZWQtd3Mg5Lit55qE5peg5pWI5qih5byPICclcycgIgogCi0jOiBkaWZmLmM6NDk5NworIzogZGlmZi5jOjUwMDAKIG1zZ2lkICIiCiAib3B0aW9uIGRpZmYtYWxnb3JpdGhtIGFjY2VwdHMgXCJteWVyc1wiLCBcIm1pbmltYWxcIiwgXCJwYXRpZW5jZVwiIGFuZCAiCiAiXCJoaXN0b2dyYW1cIiIKIG1zZ3N0ciAiIgogImRpZmYtYWxnb3JpdGhtIOmAiemhueaciSBcIm15ZXJzXCLjgIFcIm1pbmltYWxcIuOAgVwicGF0aWVuY2VcIiDlkowgXCJoaXN0b2dyYW1cIiIKIAotIzogZGlmZi5jOjUwMzMgZGlmZi5jOjUwNTMKKyM6IGRpZmYuYzo1MDM2IGRpZmYuYzo1MDU2CiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgYXJndW1lbnQgdG8gJXMiCiBtc2dzdHIgIiVzIOeahOWPguaVsOaXoOaViCIKIAotIzogZGlmZi5jOjUxOTEKKyM6IGRpZmYuYzo1MTk0CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBwYXJzZSAtLXN1Ym1vZHVsZSBvcHRpb24gcGFyYW1ldGVyOiAnJXMnIgogbXNnc3RyICLml6Dms5Xop6PmnpAgLS1zdWJtb2R1bGUg6YCJ6aG555qE5Y+C5pWw77yaJyVzJyIKIAotIzogZGlmZi5jOjUyNDcKKyM6IGRpZmYuYzo1MjUwCiAjLCBjLWZvcm1hdAogbXNnaWQgImJhZCAtLXdvcmQtZGlmZiBhcmd1bWVudDogJXMiCiBtc2dzdHIgIuWdj+eahCAtLXdvcmQtZGlmZiDlj4LmlbDvvJolcyIKIAotIzogZGlmZi5jOjUyNzAKKyM6IGRpZmYuYzo1MjczCiBtc2dpZCAiRGlmZiBvdXRwdXQgZm9ybWF0IG9wdGlvbnMiCiBtc2dzdHIgIuW3ruW8gui+k+WHuuagvOW8j+WMlumAiemhuSIKIAotIzogZGlmZi5jOjUyNzIgZGlmZi5jOjUyNzgKKyM6IGRpZmYuYzo1Mjc1IGRpZmYuYzo1MjgxCiBtc2dpZCAiZ2VuZXJhdGUgcGF0Y2giCiBtc2dzdHIgIueUn+aIkOihpeS4gSIKIAotIzogZGlmZi5jOjUyNzUgYnVpbHRpbi9sb2cuYzoxNzIKKyM6IGRpZmYuYzo1Mjc4IGJ1aWx0aW4vbG9nLmM6MTcyCiBtc2dpZCAic3VwcHJlc3MgZGlmZiBvdXRwdXQiCiBtc2dzdHIgIuS4jeaYvuekuuW3ruW8gui+k+WHuiIKIAotIzogZGlmZi5jOjUyODAgZGlmZi5jOjUzOTQgZGlmZi5jOjU0MDEKKyM6IGRpZmYuYzo1MjgzIGRpZmYuYzo1Mzk3IGRpZmYuYzo1NDA0CiBtc2dpZCAiPG4+IgogbXNnc3RyICI8bj4iCiAKLSM6IGRpZmYuYzo1MjgxIGRpZmYuYzo1Mjg0CisjOiBkaWZmLmM6NTI4NCBkaWZmLmM6NTI4NwogbXNnaWQgImdlbmVyYXRlIGRpZmZzIHdpdGggPG4+IGxpbmVzIGNvbnRleHQiCiBtc2dzdHIgIueUn+aIkOWQqyA8bj4g6KGM5LiK5LiL5paH55qE5beu5byCIgogCi0jOiBkaWZmLmM6NTI4NgorIzogZGlmZi5jOjUyODkKIG1zZ2lkICJnZW5lcmF0ZSB0aGUgZGlmZiBpbiByYXcgZm9ybWF0IgogbXNnc3RyICLnlJ/miJDljp/lp4vmoLzlvI/nmoTlt67lvIIiCiAKLSM6IGRpZmYuYzo1Mjg5CisjOiBkaWZmLmM6NTI5MgogbXNnaWQgInN5bm9ueW0gZm9yICctcCAtLXJhdyciCiBtc2dzdHIgIuWSjCAnLXAgLS1yYXcnIOWQjOS5iSIKIAotIzogZGlmZi5jOjUyOTMKKyM6IGRpZmYuYzo1Mjk2CiBtc2dpZCAic3lub255bSBmb3IgJy1wIC0tc3RhdCciCiBtc2dzdHIgIuWSjCAnLXAgLS1zdGF0JyDlkIzkuYkiCiAKLSM6IGRpZmYuYzo1Mjk3CisjOiBkaWZmLmM6NTMwMAogbXNnaWQgIm1hY2hpbmUgZnJpZW5kbHkgLS1zdGF0IgogbXNnc3RyICLmnLrlmajlj4vlpb3nmoQgLS1zdGF0IgogCi0jOiBkaWZmLmM6NTMwMAorIzogZGlmZi5jOjUzMDMKIG1zZ2lkICJvdXRwdXQgb25seSB0aGUgbGFzdCBsaW5lIG9mIC0tc3RhdCIKIG1zZ3N0ciAi5Y+q6L6T5Ye6IC0tc3RhdCDnmoTmnIDlkI7kuIDooYwiCiAKLSM6IGRpZmYuYzo1MzAyIGRpZmYuYzo1MzEwCisjOiBkaWZmLmM6NTMwNSBkaWZmLmM6NTMxMwogbXNnaWQgIjxwYXJhbTEscGFyYW0yPi4uLiIKIG1zZ3N0ciAiPOWPguaVsDEs5Y+C5pWwMj4uLi4iCiAKLSM6IGRpZmYuYzo1MzAzCisjOiBkaWZmLmM6NTMwNgogbXNnaWQgIiIKICJvdXRwdXQgdGhlIGRpc3RyaWJ1dGlvbiBvZiByZWxhdGl2ZSBhbW91bnQgb2YgY2hhbmdlcyBmb3IgZWFjaCBzdWItZGlyZWN0b3J5IgogbXNnc3RyICLovpPlh7rmr4/kuKrlrZDnm67lvZXnm7jlr7nlj5jmm7TnmoTliIbluIMiCiAKLSM6IGRpZmYuYzo1MzA3CisjOiBkaWZmLmM6NTMxMAogbXNnaWQgInN5bm9ueW0gZm9yIC0tZGlyc3RhdD1jdW11bGF0aXZlIgogbXNnc3RyICLlkowgLS1kaXJzdGF0PWN1bXVsYXRpdmUg5ZCM5LmJIgogCi0jOiBkaWZmLmM6NTMxMQorIzogZGlmZi5jOjUzMTQKIG1zZ2lkICJzeW5vbnltIGZvciAtLWRpcnN0YXQ9ZmlsZXMscGFyYW0xLHBhcmFtMi4uLiIKIG1zZ3N0ciAi5pivIC0tZGlyc3RhdD1maWxlcyxwYXJhbTEscGFyYW0yLi4uIOeahOWQjOS5ieivjSIKIAotIzogZGlmZi5jOjUzMTUKKyM6IGRpZmYuYzo1MzE4CiBtc2dpZCAid2FybiBpZiBjaGFuZ2VzIGludHJvZHVjZSBjb25mbGljdCBtYXJrZXJzIG9yIHdoaXRlc3BhY2UgZXJyb3JzIgogbXNnc3RyICLlpoLmnpzlj5jmm7TkuK3lvJXlhaXlhrLnqoHlrprnlYznrKbmiJbnqbrnmb3plJnor6/vvIznu5nlh7rorablkYoiCiAKLSM6IGRpZmYuYzo1MzE4CisjOiBkaWZmLmM6NTMyMQogbXNnaWQgImNvbmRlbnNlZCBzdW1tYXJ5IHN1Y2ggYXMgY3JlYXRpb25zLCByZW5hbWVzIGFuZCBtb2RlIGNoYW5nZXMiCiBtc2dzdHIgIueyvueugOaRmOimge+8jOS+i+WmguWIm+W7uuOAgemHjeWRveWQjeWSjOaooeW8j+WPmOabtCIKIAotIzogZGlmZi5jOjUzMjEKKyM6IGRpZmYuYzo1MzI0CiBtc2dpZCAic2hvdyBvbmx5IG5hbWVzIG9mIGNoYW5nZWQgZmlsZXMiCiBtc2dzdHIgIuWPquaYvuekuuWPmOabtOaWh+S7tueahOaWh+S7tuWQjSIKIAotIzogZGlmZi5jOjUzMjQKKyM6IGRpZmYuYzo1MzI3CiBtc2dpZCAic2hvdyBvbmx5IG5hbWVzIGFuZCBzdGF0dXMgb2YgY2hhbmdlZCBmaWxlcyIKIG1zZ3N0ciAi5Y+q5pi+56S65Y+Y5pu05paH5Lu255qE5paH5Lu25ZCN5ZKM54q25oCBIgogCi0jOiBkaWZmLmM6NTMyNgorIzogZGlmZi5jOjUzMjkKIG1zZ2lkICI8d2lkdGg+Wyw8bmFtZS13aWR0aD5bLDxjb3VudD5dXSIKIG1zZ3N0ciAiPOWuveW6pj5bLDzmlofku7blkI3lrr3luqY+Wyw85qyh5pWwPl1dIgogCi0jOiBkaWZmLmM6NTMyNworIzogZGlmZi5jOjUzMzAKIG1zZ2lkICJnZW5lcmF0ZSBkaWZmc3RhdCIKIG1zZ3N0ciAi55Sf5oiQ5beu5byC57uf6K6h77yIZGlmZnN0YXTvvIkiCiAKLSM6IGRpZmYuYzo1MzI5IGRpZmYuYzo1MzMyIGRpZmYuYzo1MzM1CisjOiBkaWZmLmM6NTMzMiBkaWZmLmM6NTMzNSBkaWZmLmM6NTMzOAogbXNnaWQgIjx3aWR0aD4iCiBtc2dzdHIgIjzlrr3luqY+IgogCi0jOiBkaWZmLmM6NTMzMAorIzogZGlmZi5jOjUzMzMKIG1zZ2lkICJnZW5lcmF0ZSBkaWZmc3RhdCB3aXRoIGEgZ2l2ZW4gd2lkdGgiCiBtc2dzdHIgIuS9v+eUqOe7meWumueahOmVv+W6pueUn+aIkOW3ruW8gue7n+iuoSIKIAotIzogZGlmZi5jOjUzMzMKKyM6IGRpZmYuYzo1MzM2CiBtc2dpZCAiZ2VuZXJhdGUgZGlmZnN0YXQgd2l0aCBhIGdpdmVuIG5hbWUgd2lkdGgiCiBtc2dzdHIgIuS9v+eUqOe7meWumueahOaWh+S7tuWQjemVv+W6pueUn+aIkOW3ruW8gue7n+iuoSIKIAotIzogZGlmZi5jOjUzMzYKKyM6IGRpZmYuYzo1MzM5CiBtc2dpZCAiZ2VuZXJhdGUgZGlmZnN0YXQgd2l0aCBhIGdpdmVuIGdyYXBoIHdpZHRoIgogbXNnc3RyICLkvb/nlKjnu5nlrprnmoTlm77lvaLplb/luqbnlJ/miJDlt67lvILnu5/orqEiCiAKLSM6IGRpZmYuYzo1MzM4CisjOiBkaWZmLmM6NTM0MQogbXNnaWQgIjxjb3VudD4iCiBtc2dzdHIgIjzmrKHmlbA+IgogCi0jOiBkaWZmLmM6NTMzOQorIzogZGlmZi5jOjUzNDIKIG1zZ2lkICJnZW5lcmF0ZSBkaWZmc3RhdCB3aXRoIGxpbWl0ZWQgbGluZXMiCiBtc2dzdHIgIueUn+aIkOaciemZkOihjOaVsOeahOW3ruW8gue7n+iuoSIKIAotIzogZGlmZi5jOjUzNDIKKyM6IGRpZmYuYzo1MzQ1CiBtc2dpZCAiZ2VuZXJhdGUgY29tcGFjdCBzdW1tYXJ5IGluIGRpZmZzdGF0IgogbXNnc3RyICLnlJ/miJDlt67lvILnu5/orqHnmoTnroDmtIHmkZjopoEiCiAKLSM6IGRpZmYuYzo1MzQ1CisjOiBkaWZmLmM6NTM0OAogbXNnaWQgIm91dHB1dCBhIGJpbmFyeSBkaWZmIHRoYXQgY2FuIGJlIGFwcGxpZWQiCiBtc2dzdHIgIui+k+WHuuS4gOS4quWPr+S7peW6lOeUqOeahOS6jOi/m+WItuW3ruW8giIKIAotIzogZGlmZi5jOjUzNDgKKyM6IGRpZmYuYzo1MzUxCiBtc2dpZCAic2hvdyBmdWxsIHByZS0gYW5kIHBvc3QtaW1hZ2Ugb2JqZWN0IG5hbWVzIG9uIHRoZSBcImluZGV4XCIgbGluZXMiCiBtc2dzdHIgIuWcqCBcImluZGV4XCIg6KGM5pi+56S65a6M5pW055qE5YmN5ZCO5a+56LGh5ZCN56ewIgogCi0jOiBkaWZmLmM6NTM1MAorIzogZGlmZi5jOjUzNTMKIG1zZ2lkICJzaG93IGNvbG9yZWQgZGlmZiIKIG1zZ3N0ciAi5pi+56S65bim6aKc6Imy55qE5beu5byCIgogCi0jOiBkaWZmLmM6NTM1MQorIzogZGlmZi5jOjUzNTQKIG1zZ2lkICI8a2luZD4iCiBtc2dzdHIgIjznsbvlnos+IgogCi0jOiBkaWZmLmM6NTM1MgorIzogZGlmZi5jOjUzNTUKIG1zZ2lkICIiCiAiaGlnaGxpZ2h0IHdoaXRlc3BhY2UgZXJyb3JzIGluIHRoZSAnY29udGV4dCcsICdvbGQnIG9yICduZXcnIGxpbmVzIGluIHRoZSAiCiAiZGlmZiIKIG1zZ3N0ciAi5a+55LqO5beu5byC5Lit55qE5LiK5LiL5paH44CB5pen55qE5ZKM5paw55qE6KGM77yM5Yqg5Lqu5pi+56S66ZSZ6K+v55qE56m655m95a2X56ymIgogCi0jOiBkaWZmLmM6NTM1NQorIzogZGlmZi5jOjUzNTgKIG1zZ2lkICIiCiAiZG8gbm90IG11bmdlIHBhdGhuYW1lcyBhbmQgdXNlIE5VTHMgYXMgb3V0cHV0IGZpZWxkIHRlcm1pbmF0b3JzIGluIC0tcmF3IG9yICIKICItLW51bXN0YXQiCkBAIC0yNzQ5LDMzNCArMjc2MCwzMzQgQEAKICLlnKggLS1yYXcg5oiW6ICFIC0tbnVtc3RhdCDkuK3vvIzkuI3lr7not6/lvoTlrZfnrKbovaznoIHlubbkvb/nlKggTlVMIOWtl+espuWBmuS4uui+k+WHuuWtl+auteeahOWIhumalCIKICLnrKYiCiAKLSM6IGRpZmYuYzo1MzU4IGRpZmYuYzo1MzYxIGRpZmYuYzo1MzY0IGRpZmYuYzo1NDcwCisjOiBkaWZmLmM6NTM2MSBkaWZmLmM6NTM2NCBkaWZmLmM6NTM2NyBkaWZmLmM6NTQ3MwogbXNnaWQgIjxwcmVmaXg+IgogbXNnc3RyICI85YmN57yAPiIKIAotIzogZGlmZi5jOjUzNTkKKyM6IGRpZmYuYzo1MzYyCiBtc2dpZCAic2hvdyB0aGUgZ2l2ZW4gc291cmNlIHByZWZpeCBpbnN0ZWFkIG9mIFwiYS9cIiIKIG1zZ3N0ciAi5pi+56S657uZ5a6a55qE5rqQ5YmN57yA5Y+W5LujIFwiYS9cIiIKIAotIzogZGlmZi5jOjUzNjIKKyM6IGRpZmYuYzo1MzY1CiBtc2dpZCAic2hvdyB0aGUgZ2l2ZW4gZGVzdGluYXRpb24gcHJlZml4IGluc3RlYWQgb2YgXCJiL1wiIgogbXNnc3RyICLmmL7npLrnu5nlrprnmoTnm67moIfliY3nvIDlj5bku6MgXCJiL1wiIgogCi0jOiBkaWZmLmM6NTM2NQorIzogZGlmZi5jOjUzNjgKIG1zZ2lkICJwcmVwZW5kIGFuIGFkZGl0aW9uYWwgcHJlZml4IHRvIGV2ZXJ5IGxpbmUgb2Ygb3V0cHV0IgogbXNnc3RyICLovpPlh7rnmoTmr4/kuIDooYzpmYTliqDliY3nvIAiCiAKLSM6IGRpZmYuYzo1MzY4CisjOiBkaWZmLmM6NTM3MQogbXNnaWQgImRvIG5vdCBzaG93IGFueSBzb3VyY2Ugb3IgZGVzdGluYXRpb24gcHJlZml4IgogbXNnc3RyICLkuI3mmL7npLrku7vkvZXmupDlkoznm67moIfliY3nvIAiCiAKLSM6IGRpZmYuYzo1MzcxCisjOiBkaWZmLmM6NTM3NAogbXNnaWQgInNob3cgY29udGV4dCBiZXR3ZWVuIGRpZmYgaHVua3MgdXAgdG8gdGhlIHNwZWNpZmllZCBudW1iZXIgb2YgbGluZXMiCiBtc2dzdHIgIuaYvuekuuaMh+WumuihjOaVsOeahOW3ruW8guWdl+mXtOeahOS4iuS4i+aWhyIKIAotIzogZGlmZi5jOjUzNzUgZGlmZi5jOjUzODAgZGlmZi5jOjUzODUKKyM6IGRpZmYuYzo1Mzc4IGRpZmYuYzo1MzgzIGRpZmYuYzo1Mzg4CiBtc2dpZCAiPGNoYXI+IgogbXNnc3RyICI85a2X56ymPiIKIAotIzogZGlmZi5jOjUzNzYKKyM6IGRpZmYuYzo1Mzc5CiBtc2dpZCAic3BlY2lmeSB0aGUgY2hhcmFjdGVyIHRvIGluZGljYXRlIGEgbmV3IGxpbmUgaW5zdGVhZCBvZiAnKyciCiBtc2dzdHIgIuaMh+WumuS4gOS4quWtl+espuWPluS7oyAnKycg5p2l6KGo56S65paw55qE5LiA6KGMIgogCi0jOiBkaWZmLmM6NTM4MQorIzogZGlmZi5jOjUzODQKIG1zZ2lkICJzcGVjaWZ5IHRoZSBjaGFyYWN0ZXIgdG8gaW5kaWNhdGUgYW4gb2xkIGxpbmUgaW5zdGVhZCBvZiAnLSciCiBtc2dzdHIgIuaMh+WumuS4gOS4quWtl+espuWPluS7oyAnLScg5p2l6KGo56S65pen55qE5LiA6KGMIgogCi0jOiBkaWZmLmM6NTM4NgorIzogZGlmZi5jOjUzODkKIG1zZ2lkICJzcGVjaWZ5IHRoZSBjaGFyYWN0ZXIgdG8gaW5kaWNhdGUgYSBjb250ZXh0IGluc3RlYWQgb2YgJyAnIgogbXNnc3RyICLmjIflrprkuIDkuKrlrZfnrKblj5bku6MgJyAnIOadpeihqOekuuS4gOihjOS4iuS4i+aWhyIKIAotIzogZGlmZi5jOjUzODkKKyM6IGRpZmYuYzo1MzkyCiBtc2dpZCAiRGlmZiByZW5hbWUgb3B0aW9ucyIKIG1zZ3N0ciAi5beu5byC6YeN5ZG95ZCN6YCJ6aG5IgogCi0jOiBkaWZmLmM6NTM5MAorIzogZGlmZi5jOjUzOTMKIG1zZ2lkICI8bj5bLzxtPl0iCiBtc2dzdHIgIjxuPlsvPG0+XSIKIAotIzogZGlmZi5jOjUzOTEKKyM6IGRpZmYuYzo1Mzk0CiBtc2dpZCAiYnJlYWsgY29tcGxldGUgcmV3cml0ZSBjaGFuZ2VzIGludG8gcGFpcnMgb2YgZGVsZXRlIGFuZCBjcmVhdGUiCiBtc2dzdHIgIuWwhuWujOWFqOmHjeWGmeeahOWPmOabtOaJk+egtOS4uuaIkOWvueeahOWIoOmZpOWSjOWIm+W7uiIKIAotIzogZGlmZi5jOjUzOTUKKyM6IGRpZmYuYzo1Mzk4CiBtc2dpZCAiZGV0ZWN0IHJlbmFtZXMiCiBtc2dzdHIgIuajgOa1i+mHjeWRveWQjSIKIAotIzogZGlmZi5jOjUzOTkKKyM6IGRpZmYuYzo1NDAyCiBtc2dpZCAib21pdCB0aGUgcHJlaW1hZ2UgZm9yIGRlbGV0ZXMiCiBtc2dzdHIgIuecgeeVpeWIoOmZpOaTjeS9nOeahOW3ruW8gui+k+WHuiIKIAotIzogZGlmZi5jOjU0MDIKKyM6IGRpZmYuYzo1NDA1CiBtc2dpZCAiZGV0ZWN0IGNvcGllcyIKIG1zZ3N0ciAi5qOA5rWL5ou36LSdIgogCi0jOiBkaWZmLmM6NTQwNgorIzogZGlmZi5jOjU0MDkKIG1zZ2lkICJ1c2UgdW5tb2RpZmllZCBmaWxlcyBhcyBzb3VyY2UgdG8gZmluZCBjb3BpZXMiCiBtc2dzdHIgIuS9v+eUqOacquS/ruaUueeahOaWh+S7tuWBmuS4uuWPkeeOsOaLt+i0neeahOa6kCIKIAotIzogZGlmZi5jOjU0MDgKKyM6IGRpZmYuYzo1NDExCiBtc2dpZCAiZGlzYWJsZSByZW5hbWUgZGV0ZWN0aW9uIgogbXNnc3RyICLnpoHnlKjph43lkb3lkI3mjqLmtYsiCiAKLSM6IGRpZmYuYzo1NDExCisjOiBkaWZmLmM6NTQxNAogbXNnaWQgInVzZSBlbXB0eSBibG9icyBhcyByZW5hbWUgc291cmNlIgogbXNnc3RyICLkvb/nlKjnqbrnmoTmlbDmja7lr7nosaHlgZrkuLrph43lkb3lkI3nmoTmupAiCiAKLSM6IGRpZmYuYzo1NDEzCisjOiBkaWZmLmM6NTQxNgogbXNnaWQgImNvbnRpbnVlIGxpc3RpbmcgdGhlIGhpc3Rvcnkgb2YgYSBmaWxlIGJleW9uZCByZW5hbWVzIgogbXNnc3RyICLnu6fnu63liJflh7rmlofku7bph43lkb3lkI3ku6XlpJbnmoTljoblj7LorrDlvZUiCiAKLSM6IGRpZmYuYzo1NDE2CisjOiBkaWZmLmM6NTQxOQogbXNnaWQgIiIKICJwcmV2ZW50IHJlbmFtZS9jb3B5IGRldGVjdGlvbiBpZiB0aGUgbnVtYmVyIG9mIHJlbmFtZS9jb3B5IHRhcmdldHMgZXhjZWVkcyAiCiAiZ2l2ZW4gbGltaXQiCiBtc2dzdHIgIuWmguaenOmHjeWRveWQjS/mi7fotJ3nm67moIfotoXov4fnu5nlrprnmoTpmZDliLbvvIznpoHmraLph43lkb3lkI0v5ou36LSd5qOA5rWLIgogCi0jOiBkaWZmLmM6NTQxOAorIzogZGlmZi5jOjU0MjEKIG1zZ2lkICJEaWZmIGFsZ29yaXRobSBvcHRpb25zIgogbXNnc3RyICLlt67lvILnrpfms5XpgInpobkiCiAKLSM6IGRpZmYuYzo1NDIwCisjOiBkaWZmLmM6NTQyMwogbXNnaWQgInByb2R1Y2UgdGhlIHNtYWxsZXN0IHBvc3NpYmxlIGRpZmYiCiBtc2dzdHIgIueUn+aIkOWwveWPr+iDveWwj+eahOW3ruW8giIKIAotIzogZGlmZi5jOjU0MjMKKyM6IGRpZmYuYzo1NDI2CiBtc2dpZCAiaWdub3JlIHdoaXRlc3BhY2Ugd2hlbiBjb21wYXJpbmcgbGluZXMiCiBtc2dzdHIgIuihjOavlOi+g+aXtuW/veeVpeepuueZveWtl+espiIKIAotIzogZGlmZi5jOjU0MjYKKyM6IGRpZmYuYzo1NDI5CiBtc2dpZCAiaWdub3JlIGNoYW5nZXMgaW4gYW1vdW50IG9mIHdoaXRlc3BhY2UiCiBtc2dzdHIgIuW/veeVpeepuueZveWtl+espueahOWPmOabtCIKIAotIzogZGlmZi5jOjU0MjkKKyM6IGRpZmYuYzo1NDMyCiBtc2dpZCAiaWdub3JlIGNoYW5nZXMgaW4gd2hpdGVzcGFjZSBhdCBFT0wiCiBtc2dzdHIgIuW/veeVpeihjOWwvueahOepuueZveWtl+espuWPmOabtCIKIAotIzogZGlmZi5jOjU0MzIKKyM6IGRpZmYuYzo1NDM1CiBtc2dpZCAiaWdub3JlIGNhcnJpZXItcmV0dXJuIGF0IHRoZSBlbmQgb2YgbGluZSIKIG1zZ3N0ciAi5b+955Wl6KGM5bC+55qE5Zue6L2m56ym77yIQ1LvvIkiCiAKLSM6IGRpZmYuYzo1NDM1CisjOiBkaWZmLmM6NTQzOAogbXNnaWQgImlnbm9yZSBjaGFuZ2VzIHdob3NlIGxpbmVzIGFyZSBhbGwgYmxhbmsiCiBtc2dzdHIgIuW/veeVpeaVtOihjOmDveaYr+epuueZveeahOWPmOabtCIKIAotIzogZGlmZi5jOjU0MzgKKyM6IGRpZmYuYzo1NDQxCiBtc2dpZCAiaGV1cmlzdGljIHRvIHNoaWZ0IGRpZmYgaHVuayBib3VuZGFyaWVzIGZvciBlYXN5IHJlYWRpbmciCiBtc2dzdHIgIuWQr+WPkeW8j+i9rOaNouW3ruW8gui+ueeVjOS7peS+v+mYheivuyIKIAotIzogZGlmZi5jOjU0NDEKKyM6IGRpZmYuYzo1NDQ0CiBtc2dpZCAiZ2VuZXJhdGUgZGlmZiB1c2luZyB0aGUgXCJwYXRpZW5jZSBkaWZmXCIgYWxnb3JpdGhtIgogbXNnc3RyICLkvb/nlKggXCJwYXRpZW5jZSBkaWZmXCIg566X5rOV55Sf5oiQ5beu5byCIgogCi0jOiBkaWZmLmM6NTQ0NQorIzogZGlmZi5jOjU0NDgKIG1zZ2lkICJnZW5lcmF0ZSBkaWZmIHVzaW5nIHRoZSBcImhpc3RvZ3JhbSBkaWZmXCIgYWxnb3JpdGhtIgogbXNnc3RyICLkvb/nlKggXCJoaXN0b2dyYW0gZGlmZlwiIOeul+azleeUn+aIkOW3ruW8giIKIAotIzogZGlmZi5jOjU0NDcKKyM6IGRpZmYuYzo1NDUwCiBtc2dpZCAiPGFsZ29yaXRobT4iCiBtc2dzdHIgIjznrpfms5U+IgogCi0jOiBkaWZmLmM6NTQ0OAorIzogZGlmZi5jOjU0NTEKIG1zZ2lkICJjaG9vc2UgYSBkaWZmIGFsZ29yaXRobSIKIG1zZ3N0ciAi6YCJ5oup5LiA5Liq5beu5byC566X5rOVIgogCi0jOiBkaWZmLmM6NTQ1MAorIzogZGlmZi5jOjU0NTMKIG1zZ2lkICI8dGV4dD4iCiBtc2dzdHIgIjzmlofmnKw+IgogCi0jOiBkaWZmLmM6NTQ1MQorIzogZGlmZi5jOjU0NTQKIG1zZ2lkICJnZW5lcmF0ZSBkaWZmIHVzaW5nIHRoZSBcImFuY2hvcmVkIGRpZmZcIiBhbGdvcml0aG0iCiBtc2dzdHIgIuS9v+eUqCBcImFuY2hvcmVkIGRpZmZcIiDnrpfms5XnlJ/miJDlt67lvIIiCiAKLSM6IGRpZmYuYzo1NDUzIGRpZmYuYzo1NDYyIGRpZmYuYzo1NDY1CisjOiBkaWZmLmM6NTQ1NiBkaWZmLmM6NTQ2NSBkaWZmLmM6NTQ2OAogbXNnaWQgIjxtb2RlPiIKIG1zZ3N0ciAiPOaooeW8jz4iCiAKLSM6IGRpZmYuYzo1NDU0CisjOiBkaWZmLmM6NTQ1NwogbXNnaWQgInNob3cgd29yZCBkaWZmLCB1c2luZyA8bW9kZT4gdG8gZGVsaW1pdCBjaGFuZ2VkIHdvcmRzIgogbXNnc3RyICLmmL7npLrljZXor43lt67lvILvvIzkvb/nlKggPOaooeW8jz4g5YiG6ZqU5Y+Y5pu055qE5Y2V6K+NIgogCi0jOiBkaWZmLmM6NTQ1NiBkaWZmLmM6NTQ1OSBkaWZmLmM6NTUwNAorIzogZGlmZi5jOjU0NTkgZGlmZi5jOjU0NjIgZGlmZi5jOjU1MDcKIG1zZ2lkICI8cmVnZXg+IgogbXNnc3RyICI85q2j5YiZPiIKIAotIzogZGlmZi5jOjU0NTcKKyM6IGRpZmYuYzo1NDYwCiBtc2dpZCAidXNlIDxyZWdleD4gdG8gZGVjaWRlIHdoYXQgYSB3b3JkIGlzIgogbXNnc3RyICLkvb/nlKggPOato+WImeihqOi+vuW8jz4g56Gu5a6a5L2V5Li65LiA5Liq6K+NIgogCi0jOiBkaWZmLmM6NTQ2MAorIzogZGlmZi5jOjU0NjMKIG1zZ2lkICJlcXVpdmFsZW50IHRvIC0td29yZC1kaWZmPWNvbG9yIC0td29yZC1kaWZmLXJlZ2V4PTxyZWdleD4iCiBtc2dzdHIgIuebuOW9k+S6jiAtLXdvcmQtZGlmZj1jb2xvciAtLXdvcmQtZGlmZi1yZWdleD085q2j5YiZPiIKIAotIzogZGlmZi5jOjU0NjMKKyM6IGRpZmYuYzo1NDY2CiBtc2dpZCAibW92ZWQgbGluZXMgb2YgY29kZSBhcmUgY29sb3JlZCBkaWZmZXJlbnRseSIKIG1zZ3N0ciAi56e75Yqo55qE5Luj56CB6KGM55So5LiN5ZCM5pa55byP552A6ImyIgogCi0jOiBkaWZmLmM6NTQ2NgorIzogZGlmZi5jOjU0NjkKIG1zZ2lkICJob3cgd2hpdGUgc3BhY2VzIGFyZSBpZ25vcmVkIGluIC0tY29sb3ItbW92ZWQiCiBtc2dzdHIgIuWcqCAtLWNvbG9yLW1vdmVkIOS4i+WmguS9leW/veeVpeepuueZveWtl+espiIKIAotIzogZGlmZi5jOjU0NjkKKyM6IGRpZmYuYzo1NDcyCiBtc2dpZCAiT3RoZXIgZGlmZiBvcHRpb25zIgogbXNnc3RyICLlhbblroPlt67lvILpgInpobkiCiAKLSM6IGRpZmYuYzo1NDcxCisjOiBkaWZmLmM6NTQ3NAogbXNnaWQgIndoZW4gcnVuIGZyb20gc3ViZGlyLCBleGNsdWRlIGNoYW5nZXMgb3V0c2lkZSBhbmQgc2hvdyByZWxhdGl2ZSBwYXRocyIKIG1zZ3N0ciAi5b2T5LuO5a2Q55uu5b2V6L+Q6KGM77yM5o6S6Zmk55uu5b2V5LmL5aSW55qE5Y+Y5pu05bm25pi+56S655u45a+56Lev5b6EIgogCi0jOiBkaWZmLmM6NTQ3NQorIzogZGlmZi5jOjU0NzgKIG1zZ2lkICJ0cmVhdCBhbGwgZmlsZXMgYXMgdGV4dCIKIG1zZ3N0ciAi5oqK5omA5pyJ5paH5Lu25b2T5YGa5paH5pys5aSE55CGIgogCi0jOiBkaWZmLmM6NTQ3NworIzogZGlmZi5jOjU0ODAKIG1zZ2lkICJzd2FwIHR3byBpbnB1dHMsIHJldmVyc2UgdGhlIGRpZmYiCiBtc2dzdHIgIuS6pOaNouS4pOS4qui+k+WFpe+8jOWPjei9rOW3ruW8giIKIAotIzogZGlmZi5jOjU0NzkKKyM6IGRpZmYuYzo1NDgyCiBtc2dpZCAiZXhpdCB3aXRoIDEgaWYgdGhlcmUgd2VyZSBkaWZmZXJlbmNlcywgMCBvdGhlcndpc2UiCiBtc2dzdHIgIuacieW3ruW8guaXtumAgOWHuueggeS4uiAx77yM5ZCm5YiZ5Li6IDAiCiAKLSM6IGRpZmYuYzo1NDgxCisjOiBkaWZmLmM6NTQ4NAogbXNnaWQgImRpc2FibGUgYWxsIG91dHB1dCBvZiB0aGUgcHJvZ3JhbSIKIG1zZ3N0ciAi56aB55So5pys56iL5bqP55qE5omA5pyJ6L6T5Ye6IgogCi0jOiBkaWZmLmM6NTQ4MworIzogZGlmZi5jOjU0ODYKIG1zZ2lkICJhbGxvdyBhbiBleHRlcm5hbCBkaWZmIGhlbHBlciB0byBiZSBleGVjdXRlZCIKIG1zZ3N0ciAi5YWB6K645omn6KGM5LiA5Liq5aSW572u55qE5beu5byC5Yqp5omLIgogCi0jOiBkaWZmLmM6NTQ4NQorIzogZGlmZi5jOjU0ODgKIG1zZ2lkICJydW4gZXh0ZXJuYWwgdGV4dCBjb252ZXJzaW9uIGZpbHRlcnMgd2hlbiBjb21wYXJpbmcgYmluYXJ5IGZpbGVzIgogbXNnc3RyICLlvZPmr5TovoPkuozov5vliLbmlofku7bml7bvvIzov5DooYzlpJbpg6jnmoTmlofmnKzovazmjaLov4fmu6TlmagiCiAKLSM6IGRpZmYuYzo1NDg3CisjOiBkaWZmLmM6NTQ5MAogbXNnaWQgIjx3aGVuPiIKIG1zZ3N0ciAiPOS9leaXtj4iCiAKLSM6IGRpZmYuYzo1NDg4CisjOiBkaWZmLmM6NTQ5MQogbXNnaWQgImlnbm9yZSBjaGFuZ2VzIHRvIHN1Ym1vZHVsZXMgaW4gdGhlIGRpZmYgZ2VuZXJhdGlvbiIKIG1zZ3N0ciAi5Zyo55Sf5oiQ5beu5byC5pe277yM5b+955Wl5a2Q5qih57uE55qE5pu05pS5IgogCi0jOiBkaWZmLmM6NTQ5MQorIzogZGlmZi5jOjU0OTQKIG1zZ2lkICI8Zm9ybWF0PiIKIG1zZ3N0ciAiPOagvOW8jz4iCiAKLSM6IGRpZmYuYzo1NDkyCisjOiBkaWZmLmM6NTQ5NQogbXNnaWQgInNwZWNpZnkgaG93IGRpZmZlcmVuY2VzIGluIHN1Ym1vZHVsZXMgYXJlIHNob3duIgogbXNnc3RyICLmjIflrprlrZDmqKHnu4TnmoTlt67lvILlpoLkvZXmmL7npLoiCiAKLSM6IGRpZmYuYzo1NDk2CisjOiBkaWZmLmM6NTQ5OQogbXNnaWQgImhpZGUgJ2dpdCBhZGQgLU4nIGVudHJpZXMgZnJvbSB0aGUgaW5kZXgiCiBtc2dzdHIgIumakOiXj+e0ouW8leS4rSAnZ2l0IGFkZCAtTicg5p2h55uuIgogCi0jOiBkaWZmLmM6NTQ5OQorIzogZGlmZi5jOjU1MDIKIG1zZ2lkICJ0cmVhdCAnZ2l0IGFkZCAtTicgZW50cmllcyBhcyByZWFsIGluIHRoZSBpbmRleCIKIG1zZ3N0ciAi5bCG57Si5byV5LitICdnaXQgYWRkIC1OJyDmnaHnm67lvZPlgZrnnJ/lrp7nmoQiCiAKLSM6IGRpZmYuYzo1NTAxCisjOiBkaWZmLmM6NTUwNAogbXNnaWQgIjxzdHJpbmc+IgogbXNnc3RyICI85a2X56ym5LiyPiIKIAotIzogZGlmZi5jOjU1MDIKKyM6IGRpZmYuYzo1NTA1CiBtc2dpZCAiIgogImxvb2sgZm9yIGRpZmZlcmVuY2VzIHRoYXQgY2hhbmdlIHRoZSBudW1iZXIgb2Ygb2NjdXJyZW5jZXMgb2YgdGhlIHNwZWNpZmllZCAiCiAic3RyaW5nIgogbXNnc3RyICLmn6Xmib7mlLnlj5jkuobmjIflrprlrZfnrKbkuLLlh7rnjrDmrKHmlbDnmoTlt67lvIIiCiAKLSM6IGRpZmYuYzo1NTA1CisjOiBkaWZmLmM6NTUwOAogbXNnaWQgIiIKICJsb29rIGZvciBkaWZmZXJlbmNlcyB0aGF0IGNoYW5nZSB0aGUgbnVtYmVyIG9mIG9jY3VycmVuY2VzIG9mIHRoZSBzcGVjaWZpZWQgIgogInJlZ2V4IgogbXNnc3RyICLmn6Xmib7mlLnlj5jmjIflrprmraPliJnljLnphY3lh7rnjrDmrKHmlbDnmoTlt67lvIIiCiAKLSM6IGRpZmYuYzo1NTA4CisjOiBkaWZmLmM6NTUxMQogbXNnaWQgInNob3cgYWxsIGNoYW5nZXMgaW4gdGhlIGNoYW5nZXNldCB3aXRoIC1TIG9yIC1HIgogbXNnc3RyICLmmL7npLrkvb/nlKggLVMg5oiWIC1HIOeahOWPmOabtOmbhueahOaJgOacieWPmOabtCIKIAotIzogZGlmZi5jOjU1MTEKKyM6IGRpZmYuYzo1NTE0CiBtc2dpZCAidHJlYXQgPHN0cmluZz4gaW4gLVMgYXMgZXh0ZW5kZWQgUE9TSVggcmVndWxhciBleHByZXNzaW9uIgogbXNnc3RyICLlsIYgLVMg55qEIDxzdHJpbmc+IOW9k+WBmuaJqeWxleeahCBQT1NJWCDmraPliJnooajovr7lvI8iCiAKLSM6IGRpZmYuYzo1NTE0CisjOiBkaWZmLmM6NTUxNwogbXNnaWQgImNvbnRyb2wgdGhlIG9yZGVyIGluIHdoaWNoIGZpbGVzIGFwcGVhciBpbiB0aGUgb3V0cHV0IgogbXNnc3RyICLmjqfliLbovpPlh7rkuK3nmoTmlofku7bmmL7npLrpobrluo8iCiAKLSM6IGRpZmYuYzo1NTE1CisjOiBkaWZmLmM6NTUxOAogbXNnaWQgIjxvYmplY3QtaWQ+IgogbXNnc3RyICI85a+56LGhIElEPiIKIAotIzogZGlmZi5jOjU1MTYKKyM6IGRpZmYuYzo1NTE5CiBtc2dpZCAiIgogImxvb2sgZm9yIGRpZmZlcmVuY2VzIHRoYXQgY2hhbmdlIHRoZSBudW1iZXIgb2Ygb2NjdXJyZW5jZXMgb2YgdGhlIHNwZWNpZmllZCAiCiAib2JqZWN0IgogbXNnc3RyICLmn6Xmib7mlLnlj5jmjIflrprlr7nosaHlh7rnjrDmrKHmlbDnmoTlt67lvIIiCiAKLSM6IGRpZmYuYzo1NTE4CisjOiBkaWZmLmM6NTUyMQogbXNnaWQgIlsoQXxDfER8TXxSfFR8VXxYfEIpLi4uWypdXSIKIG1zZ3N0ciAiWyhBfEN8RHxNfFJ8VHxVfFh8QikuLi5bKl1dIgogCi0jOiBkaWZmLmM6NTUxOQorIzogZGlmZi5jOjU1MjIKIG1zZ2lkICJzZWxlY3QgZmlsZXMgYnkgZGlmZiB0eXBlIgogbXNnc3RyICLpgJrov4flt67lvILnsbvlnovpgInmi6nmlofku7YiCiAKLSM6IGRpZmYuYzo1NTIxCisjOiBkaWZmLmM6NTUyNAogbXNnaWQgIjxmaWxlPiIKIG1zZ3N0ciAiPOaWh+S7tj4iCiAKLSM6IGRpZmYuYzo1NTIyCisjOiBkaWZmLmM6NTUyNQogbXNnaWQgIk91dHB1dCB0byBhIHNwZWNpZmljIGZpbGUiCiBtc2dzdHIgIui+k+WHuuWIsOS4gOS4quaMh+WumueahOaWh+S7tiIKIAotIzogZGlmZi5jOjYxNzcKKyM6IGRpZmYuYzo2MTgwCiBtc2dpZCAiaW5leGFjdCByZW5hbWUgZGV0ZWN0aW9uIHdhcyBza2lwcGVkIGR1ZSB0byB0b28gbWFueSBmaWxlcy4iCiBtc2dzdHIgIuWboOS4uuaWh+S7tuWkquWkmu+8jOeVpei/h+S4jeS4peagvOeahOmHjeWRveWQjeajgOafpeOAgiIKIAotIzogZGlmZi5jOjYxODAKKyM6IGRpZmYuYzo2MTgzCiBtc2dpZCAib25seSBmb3VuZCBjb3BpZXMgZnJvbSBtb2RpZmllZCBwYXRocyBkdWUgdG8gdG9vIG1hbnkgZmlsZXMuIgogbXNnc3RyICLlm6DkuLrmlofku7blpKrlpJrvvIzlj6rlnKjkv67mlLnnmoTot6/lvoTkuK3mn6Xmib7mi7fotJ3jgIIiCiAKLSM6IGRpZmYuYzo2MTgzCisjOiBkaWZmLmM6NjE4NgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAieW91IG1heSB3YW50IHRvIHNldCB5b3VyICVzIHZhcmlhYmxlIHRvIGF0IGxlYXN0ICVkIGFuZCByZXRyeSB0aGUgY29tbWFuZC4iCiBtc2dzdHIgIuaCqOWPr+iDveaDs+imgeWwhuWPmOmHjyAlcyDorr7nva7kuLroh7PlsJEgJWQg5bm25YaN5qyh5omn6KGM5q2k5ZG95Luk44CCIgogCi0jOiBkaXIuYzo1MzcKKyM6IGRpci5jOjU0OQogIywgYy1mb3JtYXQKIG1zZ2lkICJwYXRoc3BlYyAnJXMnIGRpZCBub3QgbWF0Y2ggYW55IGZpbGUocykga25vd24gdG8gZ2l0IgogbXNnc3RyICLot6/lvoTop4TmoLwgJyVzJyDmnKrljLnphY3ku7vkvZUgZ2l0IOW3suefpeaWh+S7tiIKIAotIzogZGlyLmM6OTI2CisjOiBkaXIuYzo5MzgKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IHVzZSAlcyBhcyBhbiBleGNsdWRlIGZpbGUiCiBtc2dzdHIgIuS4jeiDveWwhiAlcyDnlKjkvZzmjpLpmaTmlofku7YiCiAKLSM6IGRpci5jOjE4NDMKKyM6IGRpci5jOjE4NzcKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IG9wZW4gZGlyZWN0b3J5ICclcyciCiBtc2dzdHIgIuS4jeiDveaJk+W8gOebruW9lSAnJXMnIgogCi0jOiBkaXIuYzoyMDg1CisjOiBkaXIuYzoyMTI4CiBtc2dpZCAiZmFpbGVkIHRvIGdldCBrZXJuZWwgbmFtZSBhbmQgaW5mb3JtYXRpb24iCiBtc2dzdHIgIuaXoOazleiOt+W+l+WGheaguOWQjeensOWSjOS/oeaBryIKIAotIzogZGlyLmM6MjIwOQorIzogZGlyLmM6MjI1MgogbXNnaWQgInVudHJhY2tlZCBjYWNoZSBpcyBkaXNhYmxlZCBvbiB0aGlzIHN5c3RlbSBvciBsb2NhdGlvbiIKIG1zZ3N0ciAi57yT5a2Y5pyq6Lef6Liq5paH5Lu25Zyo5pys57O757uf5oiW5L2N572u5Lit6KKr56aB55SoIgogCi0jOiBkaXIuYzozMDEzCisjOiBkaXIuYzozMDU2CiAjLCBjLWZvcm1hdAogbXNnaWQgImluZGV4IGZpbGUgY29ycnVwdCBpbiByZXBvICVzIgogbXNnc3RyICLku5PlupMgJXMg5Lit55qE57Si5byV5paH5Lu25o2f5Z2PIgogCi0jOiBkaXIuYzozMDU4IGRpci5jOjMwNjMKKyM6IGRpci5jOjMxMDEgZGlyLmM6MzEwNgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgY3JlYXRlIGRpcmVjdG9yaWVzIGZvciAlcyIKIG1zZ3N0ciAi5LiN6IO95Li6ICVzIOWIm+W7uuebruW9lSIKIAotIzogZGlyLmM6MzA5MgorIzogZGlyLmM6MzEzNQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgbWlncmF0ZSBnaXQgZGlyZWN0b3J5IGZyb20gJyVzJyB0byAnJXMnIgogbXNnc3RyICLkuI3og73ku44gJyVzJyDov4Hnp7sgZ2l0IOebruW9leWIsCAnJXMnIgpAQCAtMzA5NSwxMiArMzEwNiwxMiBAQAogbXNnaWQgImNvdWxkIG5vdCBzdGF0IGZpbGUgJyVzJyIKIG1zZ3N0ciAi5LiN6IO95a+55paH5Lu2ICclcycg6LCD55SoIHN0YXQiCiAKLSM6IGVudmlyb25tZW50LmM6MTUwCisjOiBlbnZpcm9ubWVudC5jOjE0OAogIywgYy1mb3JtYXQKIG1zZ2lkICJiYWQgZ2l0IG5hbWVzcGFjZSBwYXRoIFwiJXNcIiIKIG1zZ3N0ciAi6ZSZ6K+v55qEIGdpdCDlkI3lrZfnqbrpl7Tot6/lvoQgXCIlc1wiIgogCi0jOiBlbnZpcm9ubWVudC5jOjMzMgorIzogZW52aXJvbm1lbnQuYzozMzAKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHNldCBHSVRfRElSIHRvICclcyciCiBtc2dzdHIgIuS4jeiDveiuvue9riBHSVRfRElSIOS4uiAnJXMnIgpAQCAtMzExMCwxNTggKzMxMjEsMTU0IEBACiBtc2dpZCAidG9vIG1hbnkgYXJncyB0byBydW4gJXMiCiBtc2dzdHIgIuaJp+ihjCAlcyDnmoTlj4LmlbDlpKrlpJoiCiAKLSM6IGZldGNoLW9iamVjdC5jOjE3Ci1tc2dpZCAiUmVtb3RlIHdpdGggbm8gVVJMIgotbXNnc3RyICLov5znqIvmnKrorr7nva4gVVJMIgotCi0jOiBmZXRjaC1wYWNrLmM6MTUxCisjOiBmZXRjaC1wYWNrLmM6MTUwCiBtc2dpZCAiZ2l0IGZldGNoLXBhY2s6IGV4cGVjdGVkIHNoYWxsb3cgbGlzdCIKIG1zZ3N0ciAiZ2l0IGZldGNoLXBhY2vvvJrlupTkuLogc2hhbGxvdyDliJfooagiCiAKLSM6IGZldGNoLXBhY2suYzoxNTQKKyM6IGZldGNoLXBhY2suYzoxNTMKIG1zZ2lkICJnaXQgZmV0Y2gtcGFjazogZXhwZWN0ZWQgYSBmbHVzaCBwYWNrZXQgYWZ0ZXIgc2hhbGxvdyBsaXN0IgogbXNnc3RyICJnaXQgZmV0Y2gtcGFja++8muWcqOa1heWFi+mahuWIl+ihqOS5i+WQjuacn+acm+S4gOS4qiBmbHVzaCDljIUiCiAKLSM6IGZldGNoLXBhY2suYzoxNjUKKyM6IGZldGNoLXBhY2suYzoxNjQKIG1zZ2lkICJnaXQgZmV0Y2gtcGFjazogZXhwZWN0ZWQgQUNLL05BSywgZ290IGEgZmx1c2ggcGFja2V0IgogbXNnc3RyICJnaXQgZmV0Y2gtcGFja++8muacn+acmyBBQ0svTkFL77yM5Y205b6X5YiwIGZsdXNoIOWMhSIKIAotIzogZmV0Y2gtcGFjay5jOjE4NQorIzogZmV0Y2gtcGFjay5jOjE4NAogIywgYy1mb3JtYXQKIG1zZ2lkICJnaXQgZmV0Y2gtcGFjazogZXhwZWN0ZWQgQUNLL05BSywgZ290ICclcyciCiBtc2dzdHIgImdpdCBmZXRjaC1wYWNr77ya5bqU5Li6IEFDSy9OQUvvvIzljbTlvpfliLAgJyVzJyIKIAotIzogZmV0Y2gtcGFjay5jOjE5NgorIzogZmV0Y2gtcGFjay5jOjE5NQogbXNnaWQgInVuYWJsZSB0byB3cml0ZSB0byByZW1vdGUiCiBtc2dzdHIgIuaXoOazleWGmeWIsOi/nOeoiyIKIAotIzogZmV0Y2gtcGFjay5jOjI1OAorIzogZmV0Y2gtcGFjay5jOjI1NwogbXNnaWQgIi0tc3RhdGVsZXNzLXJwYyByZXF1aXJlcyBtdWx0aV9hY2tfZGV0YWlsZWQiCiBtc2dzdHIgIi0tc3RhdGVsZXNzLXJwYyDpnIDopoEgbXVsdGlfYWNrX2RldGFpbGVkIgogCi0jOiBmZXRjaC1wYWNrLmM6MzYwIGZldGNoLXBhY2suYzoxMjg0CisjOiBmZXRjaC1wYWNrLmM6MzU2IGZldGNoLXBhY2suYzoxMjgwCiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgc2hhbGxvdyBsaW5lOiAlcyIKIG1zZ3N0ciAi5peg5pWI55qEIHNoYWxsb3cg5L+h5oGv77yaJXMiCiAKLSM6IGZldGNoLXBhY2suYzozNjYgZmV0Y2gtcGFjay5jOjEyOTAKKyM6IGZldGNoLXBhY2suYzozNjIgZmV0Y2gtcGFjay5jOjEyODYKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCB1bnNoYWxsb3cgbGluZTogJXMiCiBtc2dzdHIgIuaXoOaViOeahCB1bnNoYWxsb3cg5L+h5oGv77yaJXMiCiAKLSM6IGZldGNoLXBhY2suYzozNjggZmV0Y2gtcGFjay5jOjEyOTIKKyM6IGZldGNoLXBhY2suYzozNjQgZmV0Y2gtcGFjay5jOjEyODgKICMsIGMtZm9ybWF0CiBtc2dpZCAib2JqZWN0IG5vdCBmb3VuZDogJXMiCiBtc2dzdHIgIuWvueixoeacquaJvuWIsO+8miVzIgogCi0jOiBmZXRjaC1wYWNrLmM6MzcxIGZldGNoLXBhY2suYzoxMjk1CisjOiBmZXRjaC1wYWNrLmM6MzY3IGZldGNoLXBhY2suYzoxMjkxCiAjLCBjLWZvcm1hdAogbXNnaWQgImVycm9yIGluIG9iamVjdDogJXMiCiBtc2dzdHIgIuWvueixoeS4reWHuumUme+8miVzIgogCi0jOiBmZXRjaC1wYWNrLmM6MzczIGZldGNoLXBhY2suYzoxMjk3CisjOiBmZXRjaC1wYWNrLmM6MzY5IGZldGNoLXBhY2suYzoxMjkzCiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vIHNoYWxsb3cgZm91bmQ6ICVzIgogbXNnc3RyICLmnKrlj5HnjrAgc2hhbGxvd++8miVzIgogCi0jOiBmZXRjaC1wYWNrLmM6Mzc2IGZldGNoLXBhY2suYzoxMzAxCisjOiBmZXRjaC1wYWNrLmM6MzcyIGZldGNoLXBhY2suYzoxMjk3CiAjLCBjLWZvcm1hdAogbXNnaWQgImV4cGVjdGVkIHNoYWxsb3cvdW5zaGFsbG93LCBnb3QgJXMiCiBtc2dzdHIgIuW6lOS4uiBzaGFsbG93L3Vuc2hhbGxvd++8jOWNtOW+l+WIsCAlcyIKIAotIzogZmV0Y2gtcGFjay5jOjQxNworIzogZmV0Y2gtcGFjay5jOjQxNAogIywgYy1mb3JtYXQKIG1zZ2lkICJnb3QgJXMgJWQgJXMiCiBtc2dzdHIgIuW+l+WIsCAlcyAlZCAlcyIKIAotIzogZmV0Y2gtcGFjay5jOjQzNAorIzogZmV0Y2gtcGFjay5jOjQzMQogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIGNvbW1pdCAlcyIKIG1zZ3N0ciAi5peg5pWI5o+Q5LqkICVzIgogCi0jOiBmZXRjaC1wYWNrLmM6NDY1CisjOiBmZXRjaC1wYWNrLmM6NDYyCiBtc2dpZCAiZ2l2aW5nIHVwIgogbXNnc3RyICLmlL7lvIMiCiAKLSM6IGZldGNoLXBhY2suYzo0NzcgcHJvZ3Jlc3MuYzoyNzcKKyM6IGZldGNoLXBhY2suYzo0NzUgcHJvZ3Jlc3MuYzozMTIKIG1zZ2lkICJkb25lIgogbXNnc3RyICLlrozmiJAiCiAKLSM6IGZldGNoLXBhY2suYzo0ODkKKyM6IGZldGNoLXBhY2suYzo0ODcKICMsIGMtZm9ybWF0CiBtc2dpZCAiZ290ICVzICglZCkgJXMiCiBtc2dzdHIgIuW+l+WIsCAlcyAoJWQpICVzIgogCi0jOiBmZXRjaC1wYWNrLmM6NTM1CisjOiBmZXRjaC1wYWNrLmM6NTMzCiAjLCBjLWZvcm1hdAogbXNnaWQgIk1hcmtpbmcgJXMgYXMgY29tcGxldGUiCiBtc2dzdHIgIuagh+iusCAlcyDkuLrlrozmiJAiCiAKLSM6IGZldGNoLXBhY2suYzo3NDQKKyM6IGZldGNoLXBhY2suYzo3NDIKICMsIGMtZm9ybWF0CiBtc2dpZCAiYWxyZWFkeSBoYXZlICVzICglcykiCiBtc2dzdHIgIuW3sue7j+aciSAlc++8iCVz77yJIgogCi0jOiBmZXRjaC1wYWNrLmM6NzgzCisjOiBmZXRjaC1wYWNrLmM6NzgxCiBtc2dpZCAiZmV0Y2gtcGFjazogdW5hYmxlIHRvIGZvcmsgb2ZmIHNpZGViYW5kIGRlbXVsdGlwbGV4ZXIiCiBtc2dzdHIgImZldGNoLXBhY2vvvJrml6Dms5XmtL7nlJ8gc2lkZWJhbmQg5aSa6Lev6L6T5Ye6IgogCi0jOiBmZXRjaC1wYWNrLmM6NzkxCisjOiBmZXRjaC1wYWNrLmM6Nzg5CiBtc2dpZCAicHJvdG9jb2wgZXJyb3I6IGJhZCBwYWNrIGhlYWRlciIKIG1zZ3N0ciAi5Y2P6K6u6ZSZ6K+v77ya5Z2P55qE5YyF5aS0IgogCi0jOiBmZXRjaC1wYWNrLmM6ODU5CisjOiBmZXRjaC1wYWNrLmM6ODU3CiAjLCBjLWZvcm1hdAogbXNnaWQgImZldGNoLXBhY2s6IHVuYWJsZSB0byBmb3JrIG9mZiAlcyIKIG1zZ3N0ciAiZmV0Y2gtcGFja++8muaXoOazlea0vueUn+i/m+eoiyAlcyIKIAotIzogZmV0Y2gtcGFjay5jOjg3NQorIzogZmV0Y2gtcGFjay5jOjg3MwogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyBmYWlsZWQiCiBtc2dzdHIgIiVzIOWksei0pSIKIAotIzogZmV0Y2gtcGFjay5jOjg3NworIzogZmV0Y2gtcGFjay5jOjg3NQogbXNnaWQgImVycm9yIGluIHNpZGViYW5kIGRlbXVsdGlwbGV4ZXIiCiBtc2dzdHIgInNpZGViYW5kIOWkmui3r+i+k+WHuuWHuumUmSIKIAotIzogZmV0Y2gtcGFjay5jOjkwOAorIzogZmV0Y2gtcGFjay5jOjkwNwogIywgYy1mb3JtYXQKIG1zZ2lkICJTZXJ2ZXIgdmVyc2lvbiBpcyAlLipzIgogbXNnc3RyICLmnI3liqHlmajniYjmnKwgJS4qcyIKIAotIzogZmV0Y2gtcGFjay5jOjkxMyBmZXRjaC1wYWNrLmM6OTE5IGZldGNoLXBhY2suYzo5MjIgZmV0Y2gtcGFjay5jOjkyOAotIzogZmV0Y2gtcGFjay5jOjkzMiBmZXRjaC1wYWNrLmM6OTM2IGZldGNoLXBhY2suYzo5NDAgZmV0Y2gtcGFjay5jOjk0NAotIzogZmV0Y2gtcGFjay5jOjk0OCBmZXRjaC1wYWNrLmM6OTUyIGZldGNoLXBhY2suYzo5NTYgZmV0Y2gtcGFjay5jOjk2MAotIzogZmV0Y2gtcGFjay5jOjk2NiBmZXRjaC1wYWNrLmM6OTcyIGZldGNoLXBhY2suYzo5NzcgZmV0Y2gtcGFjay5jOjk4MgorIzogZmV0Y2gtcGFjay5jOjkxMiBmZXRjaC1wYWNrLmM6OTE4IGZldGNoLXBhY2suYzo5MjEgZmV0Y2gtcGFjay5jOjkyNworIzogZmV0Y2gtcGFjay5jOjkzMSBmZXRjaC1wYWNrLmM6OTM1IGZldGNoLXBhY2suYzo5MzkgZmV0Y2gtcGFjay5jOjk0MworIzogZmV0Y2gtcGFjay5jOjk0NyBmZXRjaC1wYWNrLmM6OTUxIGZldGNoLXBhY2suYzo5NTUgZmV0Y2gtcGFjay5jOjk1OQorIzogZmV0Y2gtcGFjay5jOjk2NSBmZXRjaC1wYWNrLmM6OTcxIGZldGNoLXBhY2suYzo5NzYgZmV0Y2gtcGFjay5jOjk4MQogIywgYy1mb3JtYXQKIG1zZ2lkICJTZXJ2ZXIgc3VwcG9ydHMgJXMiCiBtc2dzdHIgIuacjeWKoeWZqOaUr+aMgSAlcyIKIAotIzogZmV0Y2gtcGFjay5jOjkxNQorIzogZmV0Y2gtcGFjay5jOjkxNAogbXNnaWQgIlNlcnZlciBkb2VzIG5vdCBzdXBwb3J0IHNoYWxsb3cgY2xpZW50cyIKIG1zZ3N0ciAi5pyN5Yqh5Zmo5LiN5pSv5oyBIHNoYWxsbG93IOWuouaIt+erryIKIAotIzogZmV0Y2gtcGFjay5jOjk3NQorIzogZmV0Y2gtcGFjay5jOjk3NAogbXNnaWQgIlNlcnZlciBkb2VzIG5vdCBzdXBwb3J0IC0tc2hhbGxvdy1zaW5jZSIKIG1zZ3N0ciAi5pyN5Yqh5Zmo5LiN5pSv5oyBIC0tc2hhbGxvdy1zaW5jZSIKIAotIzogZmV0Y2gtcGFjay5jOjk4MAorIzogZmV0Y2gtcGFjay5jOjk3OQogbXNnaWQgIlNlcnZlciBkb2VzIG5vdCBzdXBwb3J0IC0tc2hhbGxvdy1leGNsdWRlIgogbXNnc3RyICLmnI3liqHlmajkuI3mlK/mjIEgLS1zaGFsbG93LWV4Y2x1ZGUiCiAKLSM6IGZldGNoLXBhY2suYzo5ODQKKyM6IGZldGNoLXBhY2suYzo5ODMKIG1zZ2lkICJTZXJ2ZXIgZG9lcyBub3Qgc3VwcG9ydCAtLWRlZXBlbiIKIG1zZ3N0ciAi5pyN5Yqh5Zmo5LiN5pSv5oyBIC0tZGVlcGVuIgogCi0jOiBmZXRjaC1wYWNrLmM6MTAwMQorIzogZmV0Y2gtcGFjay5jOjEwMDAKIG1zZ2lkICJubyBjb21tb24gY29tbWl0cyIKIG1zZ3N0ciAi5rKh5pyJ5YWx5ZCM55qE5o+Q5LqkIgogCi0jOiBmZXRjaC1wYWNrLmM6MTAxMyBmZXRjaC1wYWNrLmM6MTQ2MgorIzogZmV0Y2gtcGFjay5jOjEwMTIgZmV0Y2gtcGFjay5jOjE0NjgKIG1zZ2lkICJnaXQgZmV0Y2gtcGFjazogZmV0Y2ggZmFpbGVkLiIKIG1zZ3N0ciAiZ2l0IGZldGNoLXBhY2vvvJrojrflj5blpLHotKXjgIIiCiAKLSM6IGZldGNoLXBhY2suYzoxMTUxCisjOiBmZXRjaC1wYWNrLmM6MTE1MAogbXNnaWQgIlNlcnZlciBkb2VzIG5vdCBzdXBwb3J0IHNoYWxsb3cgcmVxdWVzdHMiCiBtc2dzdHIgIuacjeWKoeWZqOS4jeaUr+aMgSBzaGFsbGxvdyDor7fmsYIiCiAKQEAgLTMyNjksNzIgKzMyNzYsNzIgQEAKIG1zZ2lkICJTZXJ2ZXIgc3VwcG9ydHMgZmlsdGVyIgogbXNnc3RyICLmnI3liqHlmajmlK/mjIEgZmlsdGVyIgogCi0jOiBmZXRjaC1wYWNrLmM6MTE4NAorIzogZmV0Y2gtcGFjay5jOjExODAKIG1zZ2lkICJ1bmFibGUgdG8gd3JpdGUgcmVxdWVzdCB0byByZW1vdGUiCiBtc2dzdHIgIuaXoOazleWwhuivt+axguWGmeWIsOi/nOeoiyIKIAotIzogZmV0Y2gtcGFjay5jOjEyMDIKKyM6IGZldGNoLXBhY2suYzoxMTk4CiAjLCBjLWZvcm1hdAogbXNnaWQgImVycm9yIHJlYWRpbmcgc2VjdGlvbiBoZWFkZXIgJyVzJyIKIG1zZ3N0ciAi6K+75Y+W6IqC5qCH6aKYICclcycg5Ye66ZSZIgogCi0jOiBmZXRjaC1wYWNrLmM6MTIwOAorIzogZmV0Y2gtcGFjay5jOjEyMDQKICMsIGMtZm9ybWF0CiBtc2dpZCAiZXhwZWN0ZWQgJyVzJywgcmVjZWl2ZWQgJyVzJyIKIG1zZ3N0ciAi6aKE5pyfICclcyfvvIzlvpfliLAgJyVzJyIKIAotIzogZmV0Y2gtcGFjay5jOjEyNDcKKyM6IGZldGNoLXBhY2suYzoxMjQzCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuZXhwZWN0ZWQgYWNrbm93bGVkZ21lbnQgbGluZTogJyVzJyIKIG1zZ3N0ciAi5oSP5aSW55qE56Gu6K6k6KGM77yaJyVzJyIKIAotIzogZmV0Y2gtcGFjay5jOjEyNTIKKyM6IGZldGNoLXBhY2suYzoxMjQ4CiAjLCBjLWZvcm1hdAogbXNnaWQgImVycm9yIHByb2Nlc3NpbmcgYWNrczogJWQiCiBtc2dzdHIgIuWkhOeQhiBhY2sg5Ye66ZSZ77yaJWQiCiAKLSM6IGZldGNoLXBhY2suYzoxMjYyCisjOiBmZXRjaC1wYWNrLmM6MTI1OAogbXNnaWQgImV4cGVjdGVkIHBhY2tmaWxlIHRvIGJlIHNlbnQgYWZ0ZXIgJ3JlYWR5JyIKIG1zZ3N0ciAi6aKE5pyf5ZyoICdyZWFkeScg5LmL5ZCO5Y+R6YCBIHBhY2tmaWxlIgogCi0jOiBmZXRjaC1wYWNrLmM6MTI2NAorIzogZmV0Y2gtcGFjay5jOjEyNjAKIG1zZ2lkICJleHBlY3RlZCBubyBvdGhlciBzZWN0aW9ucyB0byBiZSBzZW50IGFmdGVyIG5vICdyZWFkeSciCiBtc2dzdHIgIuWcqOayoeaciSAncmVhZHknIOS4jeW6lOivpeWPkemAgeWFtuWug+Wwj+iKgiIKIAotIzogZmV0Y2gtcGFjay5jOjEzMDYKKyM6IGZldGNoLXBhY2suYzoxMzAyCiAjLCBjLWZvcm1hdAogbXNnaWQgImVycm9yIHByb2Nlc3Npbmcgc2hhbGxvdyBpbmZvOiAlZCIKIG1zZ3N0ciAi5aSE55CG5rWF5YWL6ZqG5L+h5oGv5Ye66ZSZ77yaJWQiCiAKLSM6IGZldGNoLXBhY2suYzoxMzUzCisjOiBmZXRjaC1wYWNrLmM6MTM0OQogIywgYy1mb3JtYXQKIG1zZ2lkICJleHBlY3RlZCB3YW50ZWQtcmVmLCBnb3QgJyVzJyIKIG1zZ3N0ciAi6aKE5pyfIHdhbnRlZC1yZWbvvIzlvpfliLAgJyVzJyIKIAotIzogZmV0Y2gtcGFjay5jOjEzNTgKKyM6IGZldGNoLXBhY2suYzoxMzU0CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuZXhwZWN0ZWQgd2FudGVkLXJlZjogJyVzJyIKIG1zZ3N0ciAi5oSP5aSW55qEIHdhbnRlZC1yZWbvvJonJXMnIgogCi0jOiBmZXRjaC1wYWNrLmM6MTM2MworIzogZmV0Y2gtcGFjay5jOjEzNTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiZXJyb3IgcHJvY2Vzc2luZyB3YW50ZWQgcmVmczogJWQiCiBtc2dzdHIgIuWkhOeQhuimgeiOt+WPlueahOW8leeUqOWHuumUme+8miVkIgogCi0jOiBmZXRjaC1wYWNrLmM6MTY4OQorIzogZmV0Y2gtcGFjay5jOjE2OTMKIG1zZ2lkICJubyBtYXRjaGluZyByZW1vdGUgaGVhZCIKIG1zZ3N0ciAi5rKh5pyJ5Yy56YWN55qE6L+c56iL5YiG5pSvIgogCi0jOiBmZXRjaC1wYWNrLmM6MTcxMiBidWlsdGluL2Nsb25lLmM6Njg2CisjOiBmZXRjaC1wYWNrLmM6MTcxNiBidWlsdGluL2Nsb25lLmM6Njg1CiBtc2dpZCAicmVtb3RlIGRpZCBub3Qgc2VuZCBhbGwgbmVjZXNzYXJ5IG9iamVjdHMiCiBtc2dzdHIgIui/nOeoi+ayoeacieWPkemAgeaJgOacieW/hemcgOeahOWvueixoSIKIAotIzogZmV0Y2gtcGFjay5jOjE3MzkKKyM6IGZldGNoLXBhY2suYzoxNzQzCiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vIHN1Y2ggcmVtb3RlIHJlZiAlcyIKIG1zZ3N0ciAi5rKh5pyJ6L+Z5qC355qE6L+c56iL5byV55SoICVzIgogCi0jOiBmZXRjaC1wYWNrLmM6MTc0MgorIzogZmV0Y2gtcGFjay5jOjE3NDYKICMsIGMtZm9ybWF0CiBtc2dpZCAiU2VydmVyIGRvZXMgbm90IGFsbG93IHJlcXVlc3QgZm9yIHVuYWR2ZXJ0aXNlZCBvYmplY3QgJXMiCiBtc2dzdHIgIuacjeWKoeWZqOS4jeWFgeiuuOivt+axguacquWFrOW8gOeahOWvueixoSAlcyIKQEAgLTMzNTcsMTggKzMzNjQsMjUgQEAKIG1zZ2lkICJpZ25vcmUgaW52YWxpZCBjb2xvciAnJS4qcycgaW4gbG9nLmdyYXBoQ29sb3JzIgogbXNnc3RyICLlv73nlaUgbG9nLmdyYXBoQ29sb3JzIOS4reaXoOaViOeahOminOiJsiAnJS4qcyciCiAKLSM6IGdyZXAuYzoyMTE3CisjOiBncmVwLmM6NjY4Cittc2dpZCAiIgorImdpdmVuIHBhdHRlcm4gY29udGFpbnMgTlVMTCBieXRlICh2aWEgLWYgPGZpbGU+KS4gVGhpcyBpcyBvbmx5IHN1cHBvcnRlZCAiCisid2l0aCAtUCB1bmRlciBQQ1JFIHYyIgorbXNnc3RyICIiCisi57uZ5a6a55qE5qih5byP5YyF5ZCrIE5VTEwg5a2X56ym77yI6YCa6L+HIC1mIDzmlofku7Y+IOWPguaVsO+8ieOAguWPquaciSBQQ1JFIHYyIOS4i+eahCAtUCDmlK/mjIHmraTlip/og70iCisKKyM6IGdyZXAuYzoyMTI0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiclcyc6IHVuYWJsZSB0byByZWFkICVzIgogbXNnc3RyICInJXMn77ya5peg5rOV6K+75Y+WICVzIgogCi0jOiBncmVwLmM6MjEzNCBzZXR1cC5jOjE2NCBidWlsdGluL2Nsb25lLmM6NDA5IGJ1aWx0aW4vZGlmZi5jOjgyCisjOiBncmVwLmM6MjE0MSBzZXR1cC5jOjE2NSBidWlsdGluL2Nsb25lLmM6NDA4IGJ1aWx0aW4vZGlmZi5jOjgyCiAjOiBidWlsdGluL3JtLmM6MTM1CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBzdGF0ICclcyciCiBtc2dzdHIgIuWvuSAnJXMnIOiwg+eUqCBzdGF0IOWksei0pSIKIAotIzogZ3JlcC5jOjIxNDUKKyM6IGdyZXAuYzoyMTUyCiAjLCBjLWZvcm1hdAogbXNnaWQgIiclcyc6IHNob3J0IHJlYWQiCiBtc2dzdHIgIiclcyfvvJror7vlj5bkuI3lrozmlbQiCkBAIC0zNTEwLDEyICszNTI0LDEyIEBACiBtc2dpZCAiZ2l0IHZlcnNpb24gWzxvcHRpb25zPl0iCiBtc2dzdHIgImdpdCB2ZXJzaW9uIFs86YCJ6aG5Pl0iCiAKLSM6IGhlbHAuYzo3ODIKKyM6IGhlbHAuYzo3ODMKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXM6ICVzIC0gJXMiCiBtc2dzdHIgIiVz77yaJXMgLSAlcyIKIAotIzogaGVscC5jOjc4NgorIzogaGVscC5jOjc4NwogbXNnaWQgIiIKICJcbiIKICJEaWQgeW91IG1lYW4gdGhpcz8iCkBAIC0zNTg3LDQxICszNjAxLDU2IEBACiBtc2dpZCAiaW52YWxpZCBkYXRlIGZvcm1hdDogJXMiCiBtc2dzdHIgIuaXoOaViOeahOaXpeacn+agvOW8j++8miVzIgogCi0jOiBsaXN0LW9iamVjdHMuYzoxMjkKKyM6IGxpc3Qtb2JqZWN0cy5jOjEyNwogIywgYy1mb3JtYXQKIG1zZ2lkICJlbnRyeSAnJXMnIGluIHRyZWUgJXMgaGFzIHRyZWUgbW9kZSwgYnV0IGlzIG5vdCBhIHRyZWUiCiBtc2dzdHIgIuagkSAlMiRzIOS4reeahOadoeebriAnJTEkcycg5YW35pyJ5qCR55qE5bGe5oCn77yM5L2G5LiN5piv5LiA5Liq5qCR5a+56LGhIgogCi0jOiBsaXN0LW9iamVjdHMuYzoxNDIKKyM6IGxpc3Qtb2JqZWN0cy5jOjE0MAogIywgYy1mb3JtYXQKIG1zZ2lkICJlbnRyeSAnJXMnIGluIHRyZWUgJXMgaGFzIGJsb2IgbW9kZSwgYnV0IGlzIG5vdCBhIGJsb2IiCiBtc2dzdHIgIuagkSAlMiRzIOS4reeahOadoeebriAnJTEkcycg5YW35pyJ5pWw5o2u5a+56LGh55qE5bGe5oCn77yM5L2G5LiN5piv5LiA5Liq5pWw5o2u5a+56LGhIgogCi0jOiBsaXN0LW9iamVjdHMuYzozNzgKKyM6IGxpc3Qtb2JqZWN0cy5jOjM3NQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gbG9hZCByb290IHRyZWUgZm9yIGNvbW1pdCAlcyIKIG1zZ3N0ciAi5peg5rOV5Li65o+Q5LqkICVzIOWKoOi9veagueagkSIKIAotIzogbGlzdC1vYmplY3RzLWZpbHRlci1vcHRpb25zLmM6MzYKLW1zZ2lkICJtdWx0aXBsZSBmaWx0ZXItc3BlY3MgY2Fubm90IGJlIGNvbWJpbmVkIgotbXNnc3RyICLkuI3og73mt7fnlKjlpJrnp43ov4fmu6Top4TmoLwiCisjOiBsaXN0LW9iamVjdHMtZmlsdGVyLmM6NDkyCisjLCBjLWZvcm1hdAorbXNnaWQgInVuYWJsZSB0byBhY2Nlc3Mgc3BhcnNlIGJsb2IgaW4gJyVzJyIKK21zZ3N0ciAi5LiN6IO96K6/6ZeuICclcycg5Lit55qE56iA55aP5pWw5o2u5a+56LGhIgorCisjOiBsaXN0LW9iamVjdHMtZmlsdGVyLmM6NDk1CisjLCBjLWZvcm1hdAorbXNnaWQgInVuYWJsZSB0byBwYXJzZSBzcGFyc2UgZmlsdGVyIGRhdGEgaW4gJXMiCittc2dzdHIgIuaXoOazleino+aekCAlcyDkuK3nmoTnqIDnlo/ov4fmu6TlmajmlbDmja4iCiAKICM6IGxpc3Qtb2JqZWN0cy1maWx0ZXItb3B0aW9ucy5jOjU4CiBtc2dpZCAiZXhwZWN0ZWQgJ3RyZWU6PGRlcHRoPiciCiBtc2dzdHIgIuacn+acmyAndHJlZTo85rex5bqmPiciCiAKLSM6IGxpc3Qtb2JqZWN0cy1maWx0ZXItb3B0aW9ucy5jOjg0CisjOiBsaXN0LW9iamVjdHMtZmlsdGVyLW9wdGlvbnMuYzo3MwogbXNnaWQgInNwYXJzZTpwYXRoIGZpbHRlcnMgc3VwcG9ydCBoYXMgYmVlbiBkcm9wcGVkIgogbXNnc3RyICJzcGFyc2U6cGF0aCDov4fmu6TlmajmlK/mjIHlt7LooqvliKDpmaQiCiAKLSM6IGxpc3Qtb2JqZWN0cy1maWx0ZXItb3B0aW9ucy5jOjk0CisjOiBsaXN0LW9iamVjdHMtZmlsdGVyLW9wdGlvbnMuYzo4NgogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIGZpbHRlci1zcGVjICclcyciCiBtc2dzdHIgIuaXoOaViOeahOi/h+a7pOWZqOihqOi+vuW8jyAnJXMnIgogCi0jOiBsaXN0LW9iamVjdHMtZmlsdGVyLW9wdGlvbnMuYzoxNTgKLW1zZ2lkICJjYW5ub3QgY2hhbmdlIHBhcnRpYWwgY2xvbmUgcHJvbWlzb3IgcmVtb3RlIgotbXNnc3RyICLml6Dms5Xkv67mlLnpg6jliIblhYvpmobnmoQgcHJvbWlzb3Ig6L+c56iL5LuT5bqTIgorIzogbGlzdC1vYmplY3RzLWZpbHRlci1vcHRpb25zLmM6MTAyCisjLCBjLWZvcm1hdAorbXNnaWQgIm11c3QgZXNjYXBlIGNoYXIgaW4gc3ViLWZpbHRlci1zcGVjOiAnJWMnIgorbXNnc3RyICLlv4Xpobvlr7kgc3ViLWZpbHRlci1zcGVjIOS4reeahOWtl+espui/m+ihjOi9rOS5ie+8miclYyciCisKKyM6IGxpc3Qtb2JqZWN0cy1maWx0ZXItb3B0aW9ucy5jOjE0NAorbXNnaWQgImV4cGVjdGVkIHNvbWV0aGluZyBhZnRlciBjb21iaW5lOiIKK21zZ3N0ciAi5pyf5pyb5Zyo57uE5ZCI5ZCO5pyJ5LiA5Lqb5Lic6KW/77yaIgorCisjOiBsaXN0LW9iamVjdHMtZmlsdGVyLW9wdGlvbnMuYzoyMjYKK21zZ2lkICJtdWx0aXBsZSBmaWx0ZXItc3BlY3MgY2Fubm90IGJlIGNvbWJpbmVkIgorbXNnc3RyICLkuI3og73mt7fnlKjlpJrnp43ov4fmu6Top4TmoLwiCiAKICM6IGxvY2tmaWxlLmM6MTUxCiAjLCBjLWZvcm1hdApAQCAtMzY1MCwxMTQgKzM2NzksMTEwIEBACiBtc2dpZCAiZmFpbGVkIHRvIHJlYWQgdGhlIGNhY2hlIgogbXNnc3RyICLor7vlj5bnvJPlrZjlpLHotKUiCiAKLSM6IG1lcmdlLmM6MTA3IHJlcmVyZS5jOjcyMCBidWlsdGluL2FtLmM6MTg4NSBidWlsdGluL2FtLmM6MTkxOQotIzogYnVpbHRpbi9jaGVja291dC5jOjUzNiBidWlsdGluL2NoZWNrb3V0LmM6Nzk2IGJ1aWx0aW4vY2xvbmUuYzo3ODYKKyM6IG1lcmdlLmM6MTA3IHJlcmVyZS5jOjcyMCBidWlsdGluL2FtLmM6MTg3NCBidWlsdGluL2FtLmM6MTkwOAorIzogYnVpbHRpbi9jaGVja291dC5jOjUzNyBidWlsdGluL2NoZWNrb3V0LmM6Nzk2IGJ1aWx0aW4vY2xvbmUuYzo3ODUKICM6IGJ1aWx0aW4vc3Rhc2guYzoyNjQKIG1zZ2lkICJ1bmFibGUgdG8gd3JpdGUgbmV3IGluZGV4IGZpbGUiCiBtc2dzdHIgIuaXoOazleWGmeaWsOeahOe0ouW8leaWh+S7tiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzIyCisjOiBtZXJnZS1yZWN1cnNpdmUuYzozNjcKIG1zZ2lkICIoYmFkIGNvbW1pdClcbiIKIG1zZ3N0ciAi77yI5Z2P5o+Q5Lqk77yJXG4iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjM0NQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzkwCiAjLCBjLWZvcm1hdAogbXNnaWQgImFkZF9jYWNoZWluZm8gZmFpbGVkIGZvciBwYXRoICclcyc7IG1lcmdlIGFib3J0aW5nLiIKIG1zZ3N0ciAiYWRkX2NhY2hlaW5mbyDlr7not6/lvoQgJyVzJyDmiafooYzlpLHotKXvvIzlkIjlubbnu4jmraLjgIIiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjM1NAorIzogbWVyZ2UtcmVjdXJzaXZlLmM6Mzk5CiAjLCBjLWZvcm1hdAogbXNnaWQgImFkZF9jYWNoZWluZm8gZmFpbGVkIHRvIHJlZnJlc2ggZm9yIHBhdGggJyVzJzsgbWVyZ2UgYWJvcnRpbmcuIgogbXNnc3RyICJhZGRfY2FjaGVpbmZvIOaXoOazleWIt+aWsOi3r+W+hCAnJXMn77yM5ZCI5bm257uI5q2i44CCIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzo0MzcKLW1zZ2lkICJlcnJvciBidWlsZGluZyB0cmVlcyIKLW1zZ3N0ciAi5Yib5bu65qCR5Ye66ZSZIgotCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzo4NjMKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjg4NQogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gY3JlYXRlIHBhdGggJyVzJyVzIgogbXNnc3RyICLliJvlu7rot6/lvoQgJyVzJyVzIOWksei0pSIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6ODc0CisjOiBtZXJnZS1yZWN1cnNpdmUuYzo4OTYKICMsIGMtZm9ybWF0CiBtc2dpZCAiUmVtb3ZpbmcgJXMgdG8gbWFrZSByb29tIGZvciBzdWJkaXJlY3RvcnlcbiIKIG1zZ3N0ciAi5Yig6ZmkICVzIOS7peS+v+S4uuWtkOebruW9leeVmeWHuuepuumXtFxuIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzo4ODggbWVyZ2UtcmVjdXJzaXZlLmM6OTA3CisjOiBtZXJnZS1yZWN1cnNpdmUuYzo5MTAgbWVyZ2UtcmVjdXJzaXZlLmM6OTI5CiBtc2dpZCAiOiBwZXJoYXBzIGEgRC9GIGNvbmZsaWN0PyIKIG1zZ3N0ciAi77ya5Y+v6IO95piv5LiA5Liq55uu5b2VL+aWh+S7tuWGsueqge+8nyIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6ODk3CisjOiBtZXJnZS1yZWN1cnNpdmUuYzo5MTkKICMsIGMtZm9ybWF0CiBtc2dpZCAicmVmdXNpbmcgdG8gbG9zZSB1bnRyYWNrZWQgZmlsZSBhdCAnJXMnIgogbXNnc3RyICLmi5Lnu53kuKLlvIMgJyVzJyDkuK3nmoTmnKrot5/ouKrmlofku7YiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjkzOCBidWlsdGluL2NhdC1maWxlLmM6NDAKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjk2MCBidWlsdGluL2NhdC1maWxlLmM6NDEKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IHJlYWQgb2JqZWN0ICVzICclcyciCiBtc2dzdHIgIuS4jeiDveivu+WPluWvueixoSAlcyAnJXMnIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzo5NDEKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjk2NQogIywgYy1mb3JtYXQKIG1zZ2lkICJibG9iIGV4cGVjdGVkIGZvciAlcyAnJXMnIgogbXNnc3RyICIlcyAnJXMnIOW6lOS4uuaVsOaNruWvueixoSIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6OTY1CisjOiBtZXJnZS1yZWN1cnNpdmUuYzo5OTAKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIG9wZW4gJyVzJzogJXMiCiBtc2dzdHIgIuaJk+W8gCAnJXMnIOWksei0pe+8miVzIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzo5NzYKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEwMDEKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIHN5bWxpbmsgJyVzJzogJXMiCiBtc2dzdHIgIuWIm+W7uuespuWPt+mTvuaOpSAnJXMnIOWksei0pe+8miVzIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzo5ODEKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEwMDYKICMsIGMtZm9ybWF0CiBtc2dpZCAiZG8gbm90IGtub3cgd2hhdCB0byBkbyB3aXRoICUwNm8gJXMgJyVzJyIKIG1zZ3N0ciAi5LiN55+l6YGT5aaC5L2V5aSE55CGICUwNm8gJXMgJyVzJyIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTE3NworIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTE5OQogIywgYy1mb3JtYXQKIG1zZ2lkICJGYWlsZWQgdG8gbWVyZ2Ugc3VibW9kdWxlICVzIChub3QgY2hlY2tlZCBvdXQpIgogbXNnc3RyICLml6Dms5XlkIjlubblrZDmqKHnu4QgJXMg77yI5rKh5pyJ5qOA5Ye677yJIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxMTg0CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxMjA2CiAjLCBjLWZvcm1hdAogbXNnaWQgIkZhaWxlZCB0byBtZXJnZSBzdWJtb2R1bGUgJXMgKGNvbW1pdHMgbm90IHByZXNlbnQpIgogbXNnc3RyICLml6Dms5XlkIjlubblrZDmqKHnu4QgJXPvvIjmj5DkuqTkuI3lrZjlnKjvvIkiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjExOTEKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEyMTMKICMsIGMtZm9ybWF0CiBtc2dpZCAiRmFpbGVkIHRvIG1lcmdlIHN1Ym1vZHVsZSAlcyAoY29tbWl0cyBkb24ndCBmb2xsb3cgbWVyZ2UtYmFzZSkiCiBtc2dzdHIgIuaXoOazleWQiOW5tuWtkOaooee7hCAlcyDvvIjmj5DkuqTmnKrot5/pmo/lkIjlubbln7rnur/vvIkiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjExOTkgbWVyZ2UtcmVjdXJzaXZlLmM6MTIxMQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTIyMSBtZXJnZS1yZWN1cnNpdmUuYzoxMjMzCiAjLCBjLWZvcm1hdAogbXNnaWQgIkZhc3QtZm9yd2FyZGluZyBzdWJtb2R1bGUgJXMgdG8gdGhlIGZvbGxvd2luZyBjb21taXQ6IgogbXNnc3RyICLlrZDmqKHnu4QgJXMg5b+r6L+b5Yiw5aaC5LiL5o+Q5Lqk77yaIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxMjAyIG1lcmdlLXJlY3Vyc2l2ZS5jOjEyMTQKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEyMjQgbWVyZ2UtcmVjdXJzaXZlLmM6MTIzNgogIywgYy1mb3JtYXQKIG1zZ2lkICJGYXN0LWZvcndhcmRpbmcgc3VibW9kdWxlICVzIgogbXNnc3RyICLlv6vov5vlrZDmqKHnu4QgJXMiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEyMzcKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEyNTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiRmFpbGVkIHRvIG1lcmdlIHN1Ym1vZHVsZSAlcyAobWVyZ2UgZm9sbG93aW5nIGNvbW1pdHMgbm90IGZvdW5kKSIKIG1zZ3N0ciAi5peg5rOV5ZCI5bm25a2Q5qih57uEICVzIO+8iOayoeWPkeeOsOWQiOW5tui3n+maj+eahOaPkOS6pO+8iSIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTI0MQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTI2MwogIywgYy1mb3JtYXQKIG1zZ2lkICJGYWlsZWQgdG8gbWVyZ2Ugc3VibW9kdWxlICVzIChub3QgZmFzdC1mb3J3YXJkKSIKIG1zZ3N0ciAi5peg5rOV5ZCI5bm25a2Q5qih57uEICVz77yI6Z2e5b+r6L+b77yJIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxMjQyCisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxMjY0CiBtc2dpZCAiRm91bmQgYSBwb3NzaWJsZSBtZXJnZSByZXNvbHV0aW9uIGZvciB0aGUgc3VibW9kdWxlOlxuIgogbXNnc3RyICLmib7liLDlrZDmqKHnu4TnmoTkuIDkuKrlj6/og73nmoTlkIjlubbmlrnmoYjvvJpcbiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTI0NQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTI2NwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiSWYgdGhpcyBpcyBjb3JyZWN0IHNpbXBseSBhZGQgaXQgdG8gdGhlIGluZGV4IGZvciBleGFtcGxlXG4iCkBAIC0zNzczLDMxICszNzk4LDMxIEBACiAiXG4iCiAi5Lul5o6l5Y+X5q2k5bu66K6u44CCXG4iCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEyNTQKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEyNzYKICMsIGMtZm9ybWF0CiBtc2dpZCAiRmFpbGVkIHRvIG1lcmdlIHN1Ym1vZHVsZSAlcyAobXVsdGlwbGUgbWVyZ2VzIGZvdW5kKSIKIG1zZ3N0ciAi5peg5rOV5ZCI5bm25a2Q5qih57uEICVzIO+8iOWPkeeOsOWkmuS4quWQiOW5tu+8iSIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTMyNworIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTM0OQogbXNnaWQgIkZhaWxlZCB0byBleGVjdXRlIGludGVybmFsIG1lcmdlIgogbXNnc3RyICLml6Dms5XmiafooYzlhoXpg6jlkIjlubYiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEzMzIKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjEzNTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiVW5hYmxlIHRvIGFkZCAlcyB0byBkYXRhYmFzZSIKIG1zZ3N0ciAi5LiN6IO95re75YqgICVzIOiHs+WvueixoeW6kyIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTM2NAorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTM4NgogIywgYy1mb3JtYXQKIG1zZ2lkICJBdXRvLW1lcmdpbmcgJXMiCiBtc2dzdHIgIuiHquWKqOWQiOW5tiAlcyIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTM4NworIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTQxMAogIywgYy1mb3JtYXQKIG1zZ2lkICJFcnJvcjogUmVmdXNpbmcgdG8gbG9zZSB1bnRyYWNrZWQgZmlsZSBhdCAlczsgd3JpdGluZyB0byAlcyBpbnN0ZWFkLiIKIG1zZ3N0ciAi6ZSZ6K+v77ya5ouS57ud5Lii5aSx5pyq6Lef6Liq5paH5Lu2ICclcyfvvIzogIzmmK/lhpnlhaUgJXPjgIIiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE0NTkKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE0ODIKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkNPTkZMSUNUICglcy9kZWxldGUpOiAlcyBkZWxldGVkIGluICVzIGFuZCAlcyBpbiAlcy4gVmVyc2lvbiAlcyBvZiAlcyBsZWZ0ICIKQEAgLTM4MDYsNyArMzgzMSw3IEBACiAi5Yay56qB77yIJTEkcy/liKDpmaTvvInvvJolMiRzIOWcqCAlMyRzIOS4reiiq+WIoOmZpO+8jOWcqCAlNSRzIOS4reiiqyAlNCRz44CCJTckcyDnmoQgJTYkcyDniYgiCiAi5pys6KKr5L+d55WZ44CCIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxNDY0CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxNDg3CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJDT05GTElDVCAoJXMvZGVsZXRlKTogJXMgZGVsZXRlZCBpbiAlcyBhbmQgJXMgdG8gJXMgaW4gJXMuIFZlcnNpb24gJXMgb2YgJXMgIgpAQCAtMzgxNSw3ICszODQwLDcgQEAKICLlhrLnqoHvvIglMSRzL+WIoOmZpO+8ie+8miUyJHMg5ZyoICUzJHMg5Lit6KKr5Yig6Zmk77yM5ZyoICU2JHMg5Lit55qEICU1JHMg6KKrICU0JHPjgIIlOCRzIOeahCAiCiAiJTckcyDniYjmnKzooqvkv53nlZnjgIIiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE0NzEKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE0OTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkNPTkZMSUNUICglcy9kZWxldGUpOiAlcyBkZWxldGVkIGluICVzIGFuZCAlcyBpbiAlcy4gVmVyc2lvbiAlcyBvZiAlcyBsZWZ0ICIKQEAgLTM4MjQsNyArMzg0OSw3IEBACiAi5Yay56qB77yIJTEkcy/liKDpmaTvvInvvJolMiRzIOWcqCAlMyRzIOS4reiiq+WIoOmZpO+8jOWcqCAlNSRzIOS4reiiqyAlNCRz44CCJTckcyDnmoQgJTYkcyDniYgiCiAi5pys5L+d55WZ5ZyoICU4JHMg5Lit44CCIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxNDc2CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxNDk5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJDT05GTElDVCAoJXMvZGVsZXRlKTogJXMgZGVsZXRlZCBpbiAlcyBhbmQgJXMgdG8gJXMgaW4gJXMuIFZlcnNpb24gJXMgb2YgJXMgIgpAQCAtMzgzMyw0MCArMzg1OCw0MCBAQAogIuWGsueqge+8iCUxJHMv5Yig6Zmk77yJ77yaJTIkcyDlnKggJTMkcyDkuK3ooqvliKDpmaTvvIzlnKggJTYkcyDkuK3nmoQgJTUkcyDooqsgJTQkc+OAgiU4JHMg55qEICIKICIlNyRzIOeJiOacrOS/neeVmeWcqCAlOSRzIOS4reOAgiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTUxMQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTUzNAogbXNnaWQgInJlbmFtZSIKIG1zZ3N0ciAi6YeN5ZG95ZCNIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxNTExCisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxNTM0CiBtc2dpZCAicmVuYW1lZCIKIG1zZ3N0ciAi6YeN5ZG95ZCNIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxNTkxIG1lcmdlLXJlY3Vyc2l2ZS5jOjI0NTAgbWVyZ2UtcmVjdXJzaXZlLmM6MzA5NAorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTYxNCBtZXJnZS1yZWN1cnNpdmUuYzoyNDcyIG1lcmdlLXJlY3Vyc2l2ZS5jOjMxMTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiUmVmdXNpbmcgdG8gbG9zZSBkaXJ0eSBmaWxlIGF0ICVzIgogbXNnc3RyICLmi5Lnu53kuKLlpLHohI/mlofku7YgJyVzJyIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTYwMQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTYyNAogIywgYy1mb3JtYXQKIG1zZ2lkICJSZWZ1c2luZyB0byBsb3NlIHVudHJhY2tlZCBmaWxlIGF0ICVzLCBldmVuIHRob3VnaCBpdCdzIGluIHRoZSB3YXkuIgogbXNnc3RyICLmi5Lnu53lnKggJyVzJyDlpITlpLHljrvmnKrot5/ouKrmlofku7bvvIzljbPkvb/lroPlrZjlnKjkuo7ph43lkb3lkI3kuK3jgIIiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE2NTkKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE2ODIKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ09ORkxJQ1QgKHJlbmFtZS9hZGQpOiBSZW5hbWUgJXMtPiVzIGluICVzLiAgQWRkZWQgJXMgaW4gJXMiCiBtc2dzdHIgIuWGsueqge+8iOmHjeWRveWQjS/mt7vliqDvvInvvJrlnKggJTMkcyDkuK3ph43lkb3lkI0gJTEkcy0+JTIkc+OAguWcqCAlNSRzIOS4rea3u+WKoCAlNCRzIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxNjkwCisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxNzEzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIGlzIGEgZGlyZWN0b3J5IGluICVzIGFkZGluZyBhcyAlcyBpbnN0ZWFkIgogbXNnc3RyICIlcyDmmK8gJXMg5Lit55qE5LiA5Liq55uu5b2V6ICM5LulICVzIOS4uuWQjeiiq+a3u+WKoCIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTY5NQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTcxOAogIywgYy1mb3JtYXQKIG1zZ2lkICJSZWZ1c2luZyB0byBsb3NlIHVudHJhY2tlZCBmaWxlIGF0ICVzOyBhZGRpbmcgYXMgJXMgaW5zdGVhZCIKIG1zZ3N0ciAi5ouS57ud5Lii5aSx5pyq6Lef6Liq5paH5Lu2ICclcyfvvIzogIzmmK/mt7vliqDkuLogJXMiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE3MTQKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjE3MzcKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkNPTkZMSUNUIChyZW5hbWUvcmVuYW1lKTogUmVuYW1lIFwiJXNcIi0+XCIlc1wiIGluIGJyYW5jaCBcIiVzXCIgcmVuYW1lIFwiJXMiCkBAIC0zODc1LDE4ICszOTAwLDE4IEBACiAi5Yay56qB77yI6YeN5ZG95ZCNL+mHjeWRveWQje+8ie+8muWcqOWIhuaUryBcIiUzJHNcIiDkuK3ph43lkb3lkI0gXCIlMSRzXCItPlwiJTIkc1wi77yM5Zyo5YiG5pSvICIKICJcIiU2JHNcIiDkuK3ph43lkb3lkI0gXCIlNCRzXCItPlwiJTUkc1wiJTckcyIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTcxOQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MTc0MgogbXNnaWQgIiAobGVmdCB1bnJlc29sdmVkKSIKIG1zZ3N0ciAi77yI55WZ5LiL5pyq6Kej5Yaz77yJIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoxODI4CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoxODUxCiAjLCBjLWZvcm1hdAogbXNnaWQgIkNPTkZMSUNUIChyZW5hbWUvcmVuYW1lKTogUmVuYW1lICVzLT4lcyBpbiAlcy4gUmVuYW1lICVzLT4lcyBpbiAlcyIKIG1zZ3N0ciAiIgogIuWGsueqge+8iOmHjeWRveWQjS/ph43lkb3lkI3vvInvvJrlnKggJTMkcyDkuK3ph43lkb3lkI0gJTEkcy0+JTIkc++8jOWcqCAlNiRzIOS4remHjeWRveWQjSAlNCRzLT4iCiAiJTUkcyIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MjAzNQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MjA1NgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiQ09ORkxJQ1QgKGRpcmVjdG9yeSByZW5hbWUgc3BsaXQpOiBVbmNsZWFyIHdoZXJlIHRvIHBsYWNlICVzIGJlY2F1c2UgIgpAQCAtMzg5Niw3ICszOTIxLDcgQEAKICLlhrLnqoHvvIjliIblibLnmoTnm67lvZXph43lkb3lkI3vvInvvJrkuI3muIXmpZogJXMg5bqU6K+l5pS+5Zyo5ZOq6YeM77yM5Zug5Li655uu5b2VICVzIOiiq+mHjeWRveWQjeWIsOWkmuS4qiIKICLlhbblroPnm67lvZXvvIzmsqHmnInnm67lvZXljIXlkKvlpKfpg6jliIbmlofku7bjgIIiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjIwNjcKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjIwODgKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkNPTkZMSUNUIChpbXBsaWNpdCBkaXIgcmVuYW1lKTogRXhpc3RpbmcgZmlsZS9kaXIgYXQgJXMgaW4gdGhlIHdheSBvZiAiCkBAIC0zOTA1LDcgKzM5MzAsNyBAQAogIuWGsueqge+8iOmakOW8j+ebruW9lemHjeWRveWQje+8ie+8muWkhOS6jumakOW8j+ebruW9lemHjeWRveWQjeeahOeOsOWtmOaWh+S7ti/nm67lvZUgJXPvvIzlsIbku6XkuIvot6/lvoTmlL4iCiAi5Zyo77yaJXPjgIIiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjIwNzcKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjIwOTgKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkNPTkZMSUNUIChpbXBsaWNpdCBkaXIgcmVuYW1lKTogQ2Fubm90IG1hcCBtb3JlIHRoYW4gb25lIHBhdGggdG8gJXM7ICIKQEAgLTM5MTQsNyArMzkzOSw3IEBACiAi5Yay56qB77yI6ZqQ5byP55uu5b2V6YeN5ZG95ZCN77yJ77ya5peg5rOV5pig5bCE5LiA5Liq5Lul5LiK6Lev5b6E5YiwICVz77yM6ZqQ5byP55uu5b2V6YeN5ZG95ZCN5bCd6K+V5bCG6L+Z5Lqb6LevIgogIuW+hOaUvue9ruS6juatpO+8miVzIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzoyMTY5CisjOiBtZXJnZS1yZWN1cnNpdmUuYzoyMTkwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJDT05GTElDVCAocmVuYW1lL3JlbmFtZSk6IFJlbmFtZSBkaXJlY3RvcnkgJXMtPiVzIGluICVzLiBSZW5hbWUgZGlyZWN0b3J5ICVzLSIKQEAgLTM5MjMsNTkgKzM5NDgsNTkgQEAKICLlhrLnqoHvvIjph43lkb3lkI0v6YeN5ZG95ZCN77yJ77ya5ZyoICUzJHMg5Lit6YeN5ZG95ZCN55uu5b2VICUxJHMtPiUyJHPvvIzlnKggJTYkcyDkuK3ph43lkb3lkI3nm67lvZUgIgogIiU0JHMtPiU1JHMiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjI0MTMKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjI0MzUKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIldBUk5JTkc6IEF2b2lkaW5nIGFwcGx5aW5nICVzIC0+ICVzIHJlbmFtZSB0byAlcywgYmVjYXVzZSAlcyBpdHNlbGYgd2FzICIKICJyZW5hbWVkLiIKIG1zZ3N0ciAi6K2m5ZGK77ya6YG/5YWN5bqU55SoICVzIC0+ICVzIOeahOmHjeWRveWQjeWIsCAlc++8jOWboOS4uiAlcyDmnKzouqvlt7Looqvph43lkb3lkI3jgIIiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjI5MzgKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjI5NjEKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IHJlYWQgb2JqZWN0ICVzIgogbXNnc3RyICLkuI3og73or7vlj5blr7nosaEgJXMiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjI5NDEKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjI5NjQKICMsIGMtZm9ybWF0CiBtc2dpZCAib2JqZWN0ICVzIGlzIG5vdCBhIGJsb2IiCiBtc2dzdHIgIuWvueixoSAlcyDkuI3mmK/kuIDkuKrmlbDmja7lr7nosaEiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMwMDUKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMwMjgKIG1zZ2lkICJtb2RpZnkiCiBtc2dzdHIgIuS/ruaUuSIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzAwNQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzAyOAogbXNnaWQgIm1vZGlmaWVkIgogbXNnc3RyICLkv67mlLkiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMwMTcKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMwNDAKIG1zZ2lkICJjb250ZW50IgogbXNnc3RyICLlhoXlrrkiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMwMjEKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMwNDQKIG1zZ2lkICJhZGQvYWRkIgogbXNnc3RyICLmt7vliqAv5re75YqgIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozMDQ0CisjOiBtZXJnZS1yZWN1cnNpdmUuYzozMDY3CiAjLCBjLWZvcm1hdAogbXNnaWQgIlNraXBwZWQgJXMgKG1lcmdlZCBzYW1lIGFzIGV4aXN0aW5nKSIKIG1zZ3N0ciAi55Wl6L+HICVz77yI5bey57uP5YGa6L+H55u45ZCM5ZCI5bm277yJIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozMDY2IGdpdC1zdWJtb2R1bGUuc2g6OTM3CisjOiBtZXJnZS1yZWN1cnNpdmUuYzozMDg5IGdpdC1zdWJtb2R1bGUuc2g6OTM3CiBtc2dpZCAic3VibW9kdWxlIgogbXNnc3RyICLlrZDmqKHnu4QiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMwNjcKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMwOTAKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ09ORkxJQ1QgKCVzKTogTWVyZ2UgY29uZmxpY3QgaW4gJXMiCiBtc2dzdHIgIuWGsueqge+8iCVz77yJ77ya5ZCI5bm25Yay56qB5LqOICVzIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozMDk3CisjOiBtZXJnZS1yZWN1cnNpdmUuYzozMTIwCiAjLCBjLWZvcm1hdAogbXNnaWQgIkFkZGluZyBhcyAlcyBpbnN0ZWFkIgogbXNnc3RyICLogIzmmK/ku6UgJXMg5Li65ZCN5re75YqgIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozMTc5CisjOiBtZXJnZS1yZWN1cnNpdmUuYzozMjAzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJQYXRoIHVwZGF0ZWQ6ICVzIGFkZGVkIGluICVzIGluc2lkZSBhIGRpcmVjdG9yeSB0aGF0IHdhcyByZW5hbWVkIGluICVzOyAiCkBAIC0zOTgzLDcgKzQwMDgsNyBAQAogbXNnc3RyICIiCiAi6Lev5b6E5bey5pu05paw77yaJXMg5re75Yqg5YiwICVz77yM5L2N5LqO5LiA5Liq6KKr6YeN5ZG95ZCN5YiwICVzIOeahOebruW9leS4re+8jOWwhuWFtuenu+WKqOWIsCAlc+OAgiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzE4MgorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzIwNgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiQ09ORkxJQ1QgKGZpbGUgbG9jYXRpb24pOiAlcyBhZGRlZCBpbiAlcyBpbnNpZGUgYSBkaXJlY3RvcnkgdGhhdCB3YXMgcmVuYW1lZCAiCkBAIC0zOTkyLDcgKzQwMTcsNyBAQAogIuWGsueqge+8iOaWh+S7tuS9jee9ru+8ie+8miVzIOa3u+WKoOWIsCAlc++8jOS9jeS6juS4gOS4quiiq+mHjeWRveWQjeS4uiAlcyDnmoTnm67lvZXkuK3vvIzlu7rorq7lsIblhbbnp7vliqgiCiAi5YiwICVz44CCIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozMTg2CisjOiBtZXJnZS1yZWN1cnNpdmUuYzozMjEwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJQYXRoIHVwZGF0ZWQ6ICVzIHJlbmFtZWQgdG8gJXMgaW4gJXMsIGluc2lkZSBhIGRpcmVjdG9yeSB0aGF0IHdhcyByZW5hbWVkIGluICIKQEAgLTQwMDEsNyArNDAyNiw3IEBACiAi6Lev5b6E5bey5pu05paw77yaJTEkcyDph43lkb3lkI3kuLogJTMkcyDkuK3nmoQgJTIkc++8jOiAjOivpeebruW9leiiq+mHjeWRveWQjeWIsCAlNCRzIOS4re+8jOWwhuWFtuenuyIKICLliqjliLAgJTUkc+OAgiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzE4OQorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzIxMwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiQ09ORkxJQ1QgKGZpbGUgbG9jYXRpb24pOiAlcyByZW5hbWVkIHRvICVzIGluICVzLCBpbnNpZGUgYSBkaXJlY3RvcnkgdGhhdCAiCkBAIC00MDEwLDM1ICs0MDM1LDU5IEBACiAi5Yay56qB77yI5paH5Lu25L2N572u77yJ77yaJTEkcyDph43lkb3lkI3kuLogJTMkcyDkuK3nmoQgJTIkc++8jOiAjOivpeebruW9leiiq+mHjeWRveWQjeWIsCAlNCRzIOS4re+8jCIKICLlu7rorq7lsIblhbbnp7vliqjliLAgJTUkc+OAgiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzMwMworIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzMyNwogIywgYy1mb3JtYXQKIG1zZ2lkICJSZW1vdmluZyAlcyIKIG1zZ3N0ciAi5Yig6ZmkICVzIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozMzI2CisjOiBtZXJnZS1yZWN1cnNpdmUuYzozMzUwCiBtc2dpZCAiZmlsZS9kaXJlY3RvcnkiCiBtc2dzdHIgIuaWh+S7ti/nm67lvZUiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMzMzEKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMzNTUKIG1zZ2lkICJkaXJlY3RvcnkvZmlsZSIKIG1zZ3N0ciAi55uu5b2VL+aWh+S7tiIKIAotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzMzOAorIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzM2MgogIywgYy1mb3JtYXQKIG1zZ2lkICJDT05GTElDVCAoJXMpOiBUaGVyZSBpcyBhIGRpcmVjdG9yeSB3aXRoIG5hbWUgJXMgaW4gJXMuIEFkZGluZyAlcyBhcyAlcyIKIG1zZ3N0ciAi5Yay56qB77yIJTEkc++8ie+8muWcqCAlMyRzIOS4reacieS4gOS4quWQjeS4uiAlMiRzIOeahOebruW9leOAguS7pSAlNSRzIOS4uuWQjea3u+WKoCAlNCRzIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozMzQ3CisjOiBtZXJnZS1yZWN1cnNpdmUuYzozMzcxCiAjLCBjLWZvcm1hdAogbXNnaWQgIkFkZGluZyAlcyIKIG1zZ3N0ciAi5re75YqgICVzIgogCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozMzU2CisjOiBtZXJnZS1yZWN1cnNpdmUuYzozMzgwCiAjLCBjLWZvcm1hdAogbXNnaWQgIkNPTkZMSUNUIChhZGQvYWRkKTogTWVyZ2UgY29uZmxpY3QgaW4gJXMiCiBtc2dzdHIgIuWGsueqge+8iGFkZC9hZGTvvInvvJrlkIjlubblhrLnqoHkuo4gJXMiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjMzOTQKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjM0MjQKK21zZ2lkICJBbHJlYWR5IHVwIHRvIGRhdGUhIgorbXNnc3RyICLlt7Lnu4/mmK/mnIDmlrDnmoTvvIEiCisKKyM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjM0MzMKKyMsIGMtZm9ybWF0Cittc2dpZCAibWVyZ2luZyBvZiB0cmVlcyAlcyBhbmQgJXMgZmFpbGVkIgorbXNnc3RyICLml6Dms5XlkIjlubbmoJEgJXMg5ZKMICVzIgorCisjOiBtZXJnZS1yZWN1cnNpdmUuYzozNTM3Cittc2dpZCAiTWVyZ2luZzoiCittc2dzdHIgIuWQiOW5tu+8miIKKworIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzU1MAorIywgYy1mb3JtYXQKK21zZ2lkICJmb3VuZCAldSBjb21tb24gYW5jZXN0b3I6IgorbXNnaWRfcGx1cmFsICJmb3VuZCAldSBjb21tb24gYW5jZXN0b3JzOiIKK21zZ3N0clswXSAi5Y+R546wICV1IOS4quWFseWQjOelluWFiO+8miIKK21zZ3N0clsxXSAi5Y+R546wICV1IOS4quWFseWQjOelluWFiO+8miIKKworIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzYwMAorbXNnaWQgIm1lcmdlIHJldHVybmVkIG5vIGNvbW1pdCIKK21zZ3N0ciAi5ZCI5bm25pyq6L+U5Zue5o+Q5LqkIgorCisjOiBtZXJnZS1yZWN1cnNpdmUuYzozNjU5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJZb3VyIGxvY2FsIGNoYW5nZXMgdG8gdGhlIGZvbGxvd2luZyBmaWxlcyB3b3VsZCBiZSBvdmVyd3JpdHRlbiBieSBtZXJnZTpcbiIKQEAgLTQwNDcsMTg3ICs0MDk2LDE2MyBAQAogIuaCqOWvueS4i+WIl+aWh+S7tueahOacrOWcsOS/ruaUueWwhuiiq+WQiOW5tuaTjeS9nOimhueblu+8mlxuIgogIiAgJXMiCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjM0MDUKLW1zZ2lkICJBbHJlYWR5IHVwIHRvIGRhdGUhIgotbXNnc3RyICLlt7Lnu4/mmK/mnIDmlrDnmoTvvIEiCi0KLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjM0MTQKLSMsIGMtZm9ybWF0Ci1tc2dpZCAibWVyZ2luZyBvZiB0cmVlcyAlcyBhbmQgJXMgZmFpbGVkIgotbXNnc3RyICLml6Dms5XlkIjlubbmoJEgJXMg5ZKMICVzIgotCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozNTEzCi1tc2dpZCAiTWVyZ2luZzoiCi1tc2dzdHIgIuWQiOW5tu+8miIKLQotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzUyNgotIywgYy1mb3JtYXQKLW1zZ2lkICJmb3VuZCAldSBjb21tb24gYW5jZXN0b3I6IgotbXNnaWRfcGx1cmFsICJmb3VuZCAldSBjb21tb24gYW5jZXN0b3JzOiIKLW1zZ3N0clswXSAi5Y+R546wICV1IOS4quWFseWQjOelluWFiO+8miIKLW1zZ3N0clsxXSAi5Y+R546wICV1IOS4quWFseWQjOelluWFiO+8miIKLQotIzogbWVyZ2UtcmVjdXJzaXZlLmM6MzU2NQotbXNnaWQgIm1lcmdlIHJldHVybmVkIG5vIGNvbW1pdCIKLW1zZ3N0ciAi5ZCI5bm25pyq6L+U5Zue5o+Q5LqkIgotCi0jOiBtZXJnZS1yZWN1cnNpdmUuYzozNjMxCisjOiBtZXJnZS1yZWN1cnNpdmUuYzozNzU2CiAjLCBjLWZvcm1hdAogbXNnaWQgIkNvdWxkIG5vdCBwYXJzZSBvYmplY3QgJyVzJyIKIG1zZ3N0ciAi5LiN6IO96Kej5p6Q5a+56LGhICclcyciCiAKLSM6IG1lcmdlLXJlY3Vyc2l2ZS5jOjM2NDcgYnVpbHRpbi9tZXJnZS5jOjY5OCBidWlsdGluL21lcmdlLmM6ODY5CisjOiBtZXJnZS1yZWN1cnNpdmUuYzozNzc0IGJ1aWx0aW4vbWVyZ2UuYzo2OTQgYnVpbHRpbi9tZXJnZS5jOjg3NAogbXNnaWQgIlVuYWJsZSB0byB3cml0ZSBpbmRleC4iCiBtc2dzdHIgIuS4jeiDveWGmeWFpee0ouW8leOAgiIKIAotIzogbWlkeC5jOjY5CisjOiBtaWR4LmM6NjgKICMsIGMtZm9ybWF0CiBtc2dpZCAibXVsdGktcGFjay1pbmRleCBmaWxlICVzIGlzIHRvbyBzbWFsbCIKIG1zZ3N0ciAi5aSa5YyF57Si5byV5paH5Lu2ICVzIOWkquWwjyIKIAotIzogbWlkeC5jOjg1CisjOiBtaWR4LmM6ODQKICMsIGMtZm9ybWF0CiBtc2dpZCAibXVsdGktcGFjay1pbmRleCBzaWduYXR1cmUgMHglMDh4IGRvZXMgbm90IG1hdGNoIHNpZ25hdHVyZSAweCUwOHgiCiBtc2dzdHIgIuWkmuWMhee0ouW8leetvuWQjSAweCUwOHgg5ZKM562+5ZCNIDB4JTA4eCDkuI3ljLnphY0iCiAKLSM6IG1pZHguYzo5MAorIzogbWlkeC5jOjg5CiAjLCBjLWZvcm1hdAogbXNnaWQgIm11bHRpLXBhY2staW5kZXggdmVyc2lvbiAlZCBub3QgcmVjb2duaXplZCIKIG1zZ3N0ciAibXVsdGktcGFjay1pbmRleCDniYjmnKwgJWQg5LiN6IO96KKr6K+G5YirIgogCi0jOiBtaWR4LmM6OTUKKyM6IG1pZHguYzo5NAogIywgYy1mb3JtYXQKIG1zZ2lkICJoYXNoIHZlcnNpb24gJXUgZG9lcyBub3QgbWF0Y2giCiBtc2dzdHIgIuaVo+WIl+eJiOacrCAldSDkuI3ljLnphY0iCiAKLSM6IG1pZHguYzoxMDkKKyM6IG1pZHguYzoxMDgKIG1zZ2lkICJpbnZhbGlkIGNodW5rIG9mZnNldCAodG9vIGxhcmdlKSIKIG1zZ3N0ciAi5peg5pWI55qE5Z2X5YGP56e777yI5aSq5aSn77yJIgogCi0jOiBtaWR4LmM6MTMzCisjOiBtaWR4LmM6MTMyCiBtc2dpZCAidGVybWluYXRpbmcgbXVsdGktcGFjay1pbmRleCBjaHVuayBpZCBhcHBlYXJzIGVhcmxpZXIgdGhhbiBleHBlY3RlZCIKIG1zZ3N0ciAi57uI5q2i5aSa5YyF57Si5byV5Z2XIGlkIOWHuueOsOaXtumXtOaXqeS6jumihOacnyIKIAotIzogbWlkeC5jOjE0NgorIzogbWlkeC5jOjE0NQogbXNnaWQgIm11bHRpLXBhY2staW5kZXggbWlzc2luZyByZXF1aXJlZCBwYWNrLW5hbWUgY2h1bmsiCiBtc2dzdHIgIuWkmuWMhee0ouW8lee8uuWwkeW/hemcgOeahOWMheWQjeWdlyIKIAotIzogbWlkeC5jOjE0OAorIzogbWlkeC5jOjE0NwogbXNnaWQgIm11bHRpLXBhY2staW5kZXggbWlzc2luZyByZXF1aXJlZCBPSUQgZmFub3V0IGNodW5rIgogbXNnc3RyICLlpJrljIXntKLlvJXnvLrlsJHlv4XpnIDnmoTlr7nosaEgSUQg5omH5Ye65Z2XIgogCi0jOiBtaWR4LmM6MTUwCisjOiBtaWR4LmM6MTQ5CiBtc2dpZCAibXVsdGktcGFjay1pbmRleCBtaXNzaW5nIHJlcXVpcmVkIE9JRCBsb29rdXAgY2h1bmsiCiBtc2dzdHIgIuWkmuWMhee0ouW8lee8uuWwkeW/hemcgOeahOWvueixoSBJRCDmn6Xor6LlnZciCiAKLSM6IG1pZHguYzoxNTIKKyM6IG1pZHguYzoxNTEKIG1zZ2lkICJtdWx0aS1wYWNrLWluZGV4IG1pc3NpbmcgcmVxdWlyZWQgb2JqZWN0IG9mZnNldHMgY2h1bmsiCiBtc2dzdHIgIuWkmuWMhee0ouW8lee8uuWwkeW/hemcgOeahOWvueixoeWBj+enu+WdlyIKIAotIzogbWlkeC5jOjE2NgorIzogbWlkeC5jOjE2NQogIywgYy1mb3JtYXQKIG1zZ2lkICJtdWx0aS1wYWNrLWluZGV4IHBhY2sgbmFtZXMgb3V0IG9mIG9yZGVyOiAnJXMnIGJlZm9yZSAnJXMnIgogbXNnc3RyICLlpJrljIXntKLlvJXljIXlkI3ml6Dluo/vvJonJXMnIOWcqCAnJXMnIOS5i+WJjSIKIAotIzogbWlkeC5jOjIxMQorIzogbWlkeC5jOjIxMAogIywgYy1mb3JtYXQKIG1zZ2lkICJiYWQgcGFjay1pbnQtaWQ6ICV1ICgldSB0b3RhbCBwYWNrcykiCiBtc2dzdHIgIumUmeeahCBwYWNrLWludC1pZO+8miV177yI5YWx5pyJICV1IOS4quWMhe+8iSIKIAotIzogbWlkeC5jOjI2MQorIzogbWlkeC5jOjI2MAogbXNnaWQgIm11bHRpLXBhY2staW5kZXggc3RvcmVzIGEgNjQtYml0IG9mZnNldCwgYnV0IG9mZl90IGlzIHRvbyBzbWFsbCIKIG1zZ3N0ciAi5aSa5YyF57Si5byV5a2Y5YKo5LiA5LiqNjTkvY3lgY/np7vvvIzkvYbmmK8gb2ZmX3Qg5aSq5bCPIgogCi0jOiBtaWR4LmM6Mjg5CisjOiBtaWR4LmM6Mjg4CiBtc2dpZCAiZXJyb3IgcHJlcGFyaW5nIHBhY2tmaWxlIGZyb20gbXVsdGktcGFjay1pbmRleCIKIG1zZ3N0ciAi5LuO5aSa5YyF57Si5byV5YeG5aSHIHBhY2tmaWxlIOWHuumUmSIKIAotIzogbWlkeC5jOjQ3MAorIzogbWlkeC5jOjQ2OQogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gYWRkIHBhY2tmaWxlICclcyciCiBtc2dzdHIgIua3u+WKoOWMheaWh+S7tiAnJXMnIOWksei0pSIKIAotIzogbWlkeC5jOjQ3NgorIzogbWlkeC5jOjQ3NQogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gb3BlbiBwYWNrLWluZGV4ICclcyciCiBtc2dzdHIgIuaJk+W8gOWMhee0ouW8lSAnJXMnIOWksei0pSIKIAotIzogbWlkeC5jOjUzNgorIzogbWlkeC5jOjUzNQogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gbG9jYXRlIG9iamVjdCAlZCBpbiBwYWNrZmlsZSIKIG1zZ3N0ciAi5Zyo5YyF5paH5Lu25Lit5a6a5L2N5a+56LGhICVkIOWksei0pSIKIAotIzogbWlkeC5jOjg2NQorIzogbWlkeC5jOjg2NAogIywgYy1mb3JtYXQKIG1zZ2lkICJkaWQgbm90IHNlZSBwYWNrLWZpbGUgJXMgdG8gZHJvcCIKIG1zZ3N0ciAi5rKh5pyJ55yL5Yiw6KaB5Lii5byD55qE5YyF5paH5Lu2ICVzIgogCi0jOiBtaWR4LmM6MTAzNgorIzogbWlkeC5jOjEwMzUKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIGNsZWFyIG11bHRpLXBhY2staW5kZXggYXQgJXMiCiBtc2dzdHIgIua4heeQhuS9jeS6jiAlcyDnmoTlpJrljIXntKLlvJXlpLHotKUiCiAKLSM6IG1pZHguYzoxMDkxCisjOiBtaWR4LmM6MTA5MAogbXNnaWQgIkxvb2tpbmcgZm9yIHJlZmVyZW5jZWQgcGFja2ZpbGVzIgogbXNnc3RyICLmraPlnKjmn6Xmib7lvJXnlKjnmoTljIXmlofku7YiCiAKLSM6IG1pZHguYzoxMTA2CisjOiBtaWR4LmM6MTEwNQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAib2lkIGZhbm91dCBvdXQgb2Ygb3JkZXI6IGZhbm91dFslZF0gPSAlPFBSSXgzMj4gPiAlPFBSSXgzMj4gPSBmYW5vdXRbJWRdIgogbXNnc3RyICLlr7nosaEgSUQg5omH5Ye65peg5bqP77yaZmFub3V0WyVkXSA9ICU8UFJJeDMyPiA+ICU8UFJJeDMyPiA9IGZhbm91dFslZF0iCiAKLSM6IG1pZHguYzoxMTEwCisjOiBtaWR4LmM6MTEwOQogbXNnaWQgIlZlcmlmeWluZyBPSUQgb3JkZXIgaW4gTUlEWCIKIG1zZ3N0ciAi5q2j5Zyo5qCh6aqMIE1JRFgg5Lit55qE5a+56LGhIElEIOmhuuW6jyIKIAotIzogbWlkeC5jOjExMTkKKyM6IG1pZHguYzoxMTE4CiAjLCBjLWZvcm1hdAogbXNnaWQgIm9pZCBsb29rdXAgb3V0IG9mIG9yZGVyOiBvaWRbJWRdID0gJXMgPj0gJXMgPSBvaWRbJWRdIgogbXNnc3RyICLlr7nosaEgSUQg5p+l6K+i5peg5bqP77yab2lkWyVkXSA9ICVzID49ICVzID0gb2lkWyVkXSIKIAotIzogbWlkeC5jOjExMzgKKyM6IG1pZHguYzoxMTM3CiBtc2dpZCAiU29ydGluZyBvYmplY3RzIGJ5IHBhY2tmaWxlIgogbXNnc3RyICLpgJrov4fljIXmlofku7bkuLrlr7nosaHmjpLluo8iCiAKLSM6IG1pZHguYzoxMTQ0CisjOiBtaWR4LmM6MTE0MwogbXNnaWQgIlZlcmlmeWluZyBvYmplY3Qgb2Zmc2V0cyIKIG1zZ3N0ciAi5qCh6aqM5a+56LGh5YGP56e7IgogCi0jOiBtaWR4LmM6MTE2MAorIzogbWlkeC5jOjExNTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIGxvYWQgcGFjayBlbnRyeSBmb3Igb2lkWyVkXSA9ICVzIgogbXNnc3RyICLkuLogb2lkWyVkXSA9ICVzIOWKoOi9veWMheadoeebruWksei0pSIKIAotIzogbWlkeC5jOjExNjYKKyM6IG1pZHguYzoxMTY1CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBsb2FkIHBhY2staW5kZXggZm9yIHBhY2tmaWxlICVzIgogbXNnc3RyICLkuLrljIXmlofku7YgJXMg5Yqg6L295YyF57Si5byV5aSx6LSlIgogCi0jOiBtaWR4LmM6MTE3NQorIzogbWlkeC5jOjExNzQKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW5jb3JyZWN0IG9iamVjdCBvZmZzZXQgZm9yIG9pZFslZF0gPSAlczogJTxQUkl4NjQ+ICE9ICU8UFJJeDY0PiIKIG1zZ3N0ciAib2lkWyVkXSA9ICVzIOmUmeivr+eahOWvueixoeWBj+enu++8miU8UFJJeDY0PiAhPSAlPFBSSXg2ND4iCiAKLSM6IG1pZHguYzoxMzUwCisjOiBtaWR4LmM6MTM0OQogbXNnaWQgImNvdWxkIG5vdCBzdGFydCBwYWNrLW9iamVjdHMiCiBtc2dzdHIgIuS4jeiDveW8gOWniyBwYWNrLW9iamVjdHMiCiAKLSM6IG1pZHguYzoxMzY5CisjOiBtaWR4LmM6MTM2OAogbXNnaWQgImNvdWxkIG5vdCBmaW5pc2ggcGFjay1vYmplY3RzIgogbXNnc3RyICLkuI3og73nu5PmnZ8gcGFjay1vYmplY3RzIgogCi0jOiBuYW1lLWhhc2guYzo1MzIKKyM6IG5hbWUtaGFzaC5jOjUzNwogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gY3JlYXRlIGxhenlfZGlyIHRocmVhZDogJXMiCiBtc2dzdHIgIuS4jeiDveWIm+W7uiBsYXp5X2RpciDnur/nqIvvvJolcyIKIAotIzogbmFtZS1oYXNoLmM6NTU0CisjOiBuYW1lLWhhc2guYzo1NTkKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGNyZWF0ZSBsYXp5X25hbWUgdGhyZWFkOiAlcyIKIG1zZ3N0ciAi5LiN6IO95Yib5bu6IGxhenlfbmFtZSDnur/nqIvvvJolcyIKIAotIzogbmFtZS1oYXNoLmM6NTYwCisjOiBuYW1lLWhhc2guYzo1NjUKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGpvaW4gbGF6eV9uYW1lIHRocmVhZDogJXMiCiBtc2dzdHIgIuS4jeiDveWKoOWFpSBsYXN5X25hbWUg57q/56iL77yaJXMiCkBAIC00MjcxLDQxICs0Mjk2LDQxIEBACiBtc2dpZCAiQmFkICVzIHZhbHVlOiAnJXMnIgogbXNnc3RyICLlnY/nmoQgJXMg5YC877yaJyVzJyIKIAotIzogb2JqZWN0LmM6NTQKKyM6IG9iamVjdC5jOjUzCiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgb2JqZWN0IHR5cGUgXCIlc1wiIgogbXNnc3RyICLml6DmlYjnmoTlr7nosaHnsbvlnosgXCIlc1wiIgogCi0jOiBvYmplY3QuYzoxNzQKKyM6IG9iamVjdC5jOjE3MwogIywgYy1mb3JtYXQKIG1zZ2lkICJvYmplY3QgJXMgaXMgYSAlcywgbm90IGEgJXMiCiBtc2dzdHIgIuWvueixoSAlcyDmmK/kuIDkuKogJXPvvIzkuI3mmK/kuIDkuKogJXMiCiAKLSM6IG9iamVjdC5jOjIzNAorIzogb2JqZWN0LmM6MjMzCiAjLCBjLWZvcm1hdAogbXNnaWQgIm9iamVjdCAlcyBoYXMgdW5rbm93biB0eXBlIGlkICVkIgogbXNnc3RyICLlr7nosaEgJXMg5pyJ5pyq55+l55qE57G75Z6LIGlkICVkIgogCi0jOiBvYmplY3QuYzoyNDcKKyM6IG9iamVjdC5jOjI0NgogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gcGFyc2Ugb2JqZWN0OiAlcyIKIG1zZ3N0ciAi5LiN6IO96Kej5p6Q5a+56LGh77yaJXMiCiAKLSM6IG9iamVjdC5jOjI2NyBvYmplY3QuYzoyNzgKKyM6IG9iamVjdC5jOjI2NiBvYmplY3QuYzoyNzcKICMsIGMtZm9ybWF0CiBtc2dpZCAiaGFzaCBtaXNtYXRjaCAlcyIKIG1zZ3N0ciAi5ZOI5biM5YC85LiOICVzIOS4jeWMuemFjSIKIAotIzogcGFja2ZpbGUuYzo2NDgKKyM6IHBhY2tmaWxlLmM6NjQxCiBtc2dpZCAib2Zmc2V0IGJlZm9yZSBlbmQgb2YgcGFja2ZpbGUgKGJyb2tlbiAuaWR4PykiCiBtc2dzdHIgIuWBj+enu+mHj+WcqOWMheaWh+S7tue7k+adn+S5i+WJje+8iOaNn+Wdj+eahCAuaWR477yf77yJIgogCi0jOiBwYWNrZmlsZS5jOjE4OTkKKyM6IHBhY2tmaWxlLmM6MTg4NwogIywgYy1mb3JtYXQKIG1zZ2lkICJvZmZzZXQgYmVmb3JlIHN0YXJ0IG9mIHBhY2sgaW5kZXggZm9yICVzIChjb3JydXB0IGluZGV4PykiCiBtc2dzdHIgIuWBj+enu+mHj+WcqCAlcyDnmoTljIXntKLlvJXlvIDlp4vkuYvliY3vvIjmjZ/lnY/nmoTntKLlvJXvvJ/vvIkiCiAKLSM6IHBhY2tmaWxlLmM6MTkwMworIzogcGFja2ZpbGUuYzoxODkxCiAjLCBjLWZvcm1hdAogbXNnaWQgIm9mZnNldCBiZXlvbmQgZW5kIG9mIHBhY2sgaW5kZXggZm9yICVzICh0cnVuY2F0ZWQgaW5kZXg/KSIKIG1zZ3N0ciAi5YGP56e76YeP6LaK6L+H5LqGICVzIOeahOWMhee0ouW8leeahOe7k+Wwvu+8iOiiq+aIquaWreeahOe0ouW8le+8n++8iSIKQEAgLTQzNTAsMjYgKzQzNzUsMjYgQEAKIG1zZ2lkICJkaWQgeW91IG1lYW4gYC0tJXNgICh3aXRoIHR3byBkYXNoZXMgPykiCiBtc2dzdHIgIuS9oOeahOaEj+aAneaYryBgLS0lc2DvvIjmnInkuKTkuKrnn63nur/vvJ/vvIkiCiAKLSM6IHBhcnNlLW9wdGlvbnMuYzo4NTkKKyM6IHBhcnNlLW9wdGlvbnMuYzo4NjAKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5rbm93biBvcHRpb24gYCVzJyIKIG1zZ3N0ciAi5pyq55+l6YCJ6aG5IGAlcyciCiAKLSM6IHBhcnNlLW9wdGlvbnMuYzo4NjEKKyM6IHBhcnNlLW9wdGlvbnMuYzo4NjIKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5rbm93biBzd2l0Y2ggYCVjJyIKIG1zZ3N0ciAi5pyq55+l5byA5YWzIGAlYyciCiAKLSM6IHBhcnNlLW9wdGlvbnMuYzo4NjMKKyM6IHBhcnNlLW9wdGlvbnMuYzo4NjQKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5rbm93biBub24tYXNjaWkgb3B0aW9uIGluIHN0cmluZzogYCVzJyIKIG1zZ3N0ciAi5a2X56ym5Liy5Lit5pyq55+l55qE6Z2eIGFzY2lpIOWtl+espumAiemhue+8mmAlcyciCiAKLSM6IHBhcnNlLW9wdGlvbnMuYzo4ODcKKyM6IHBhcnNlLW9wdGlvbnMuYzo4ODgKIG1zZ2lkICIuLi4iCiBtc2dzdHIgIi4uLiIKIAotIzogcGFyc2Utb3B0aW9ucy5jOjkwNgorIzogcGFyc2Utb3B0aW9ucy5jOjkwNwogIywgYy1mb3JtYXQKIG1zZ2lkICJ1c2FnZTogJXMiCiBtc2dzdHIgIueUqOazle+8miVzIgpAQCAtNDM3NywyMiArNDQwMiwyMiBAQAogIy4gVFJBTlNMQVRPUlM6IHRoZSBjb2xvbiBoZXJlIHNob3VsZCBhbGlnbiB3aXRoIHRoZQogIy4gb25lIGluICJ1c2FnZTogJXMiIHRyYW5zbGF0aW9uLgogIy4KLSM6IHBhcnNlLW9wdGlvbnMuYzo5MTIKKyM6IHBhcnNlLW9wdGlvbnMuYzo5MTMKICMsIGMtZm9ybWF0CiBtc2dpZCAiICAgb3I6ICVzIgogbXNnc3RyICIgIOaIlu+8miVzIgogCiAjICDor5HogIXvvJrkuLrkv53or4HlnKjovpPlh7rkuK3lr7npvZDvvIzms6jmhI/osIPmlbTlj6XkuK3nqbrmoLzvvIEKLSM6IHBhcnNlLW9wdGlvbnMuYzo5MTUKKyM6IHBhcnNlLW9wdGlvbnMuYzo5MTYKICMsIGMtZm9ybWF0CiBtc2dpZCAiICAgICVzIgogbXNnc3RyICIgICAgJXMiCiAKLSM6IHBhcnNlLW9wdGlvbnMuYzo5NTQKKyM6IHBhcnNlLW9wdGlvbnMuYzo5NTUKIG1zZ2lkICItTlVNIgogbXNnc3RyICIt5pWw5a2XIgogCi0jOiBwYXJzZS1vcHRpb25zLmM6OTY4CisjOiBwYXJzZS1vcHRpb25zLmM6OTY5CiAjLCBjLWZvcm1hdAogbXNnaWQgImFsaWFzIG9mIC0tJXMiCiBtc2dzdHIgIi0tJXMg55qE5Yir5ZCNIgpAQCAtNDU1NywyOSArNDU4MiwzOCBAQAogbXNnaWQgInVuYWJsZSB0byBwYXJzZSAtLXByZXR0eSBmb3JtYXQiCiBtc2dzdHIgIuS4jeiDveino+aekCAtLXByZXR0eSDmoLzlvI8iCiAKLSM6IHJhbmdlLWRpZmYuYzo3MAorIzogcHJvbWlzb3ItcmVtb3RlLmM6MjUKK21zZ2lkICJSZW1vdGUgd2l0aCBubyBVUkwiCittc2dzdHIgIui/nOeoi+acquiuvue9riBVUkwiCisKKyM6IHByb21pc29yLXJlbW90ZS5jOjYxCisjLCBjLWZvcm1hdAorbXNnaWQgInByb21pc29yIHJlbW90ZSBuYW1lIGNhbm5vdCBiZWdpbiB3aXRoICcvJzogJXMiCittc2dzdHIgInByb21pc29yIOi/nOeoi+WQjeensOS4jeiDveS7pSAnLycg5byA5aeL77yaJXMiCisKKyM6IHJhbmdlLWRpZmYuYzo3MQogbXNnaWQgImNvdWxkIG5vdCBzdGFydCBgbG9nYCIKIG1zZ3N0ciAi5LiN6IO95ZCv5YqoIGBsb2dgIgogCi0jOiByYW5nZS1kaWZmLmM6NzIKKyM6IHJhbmdlLWRpZmYuYzo3MwogbXNnaWQgImNvdWxkIG5vdCByZWFkIGBsb2dgIG91dHB1dCIKIG1zZ3N0ciAi5LiN6IO96K+75Y+WIGBsb2dgIOeahOi+k+WHuiIKIAotIzogcmFuZ2UtZGlmZi5jOjkxIHNlcXVlbmNlci5jOjUwMjEKKyM6IHJhbmdlLWRpZmYuYzo5MiBzZXF1ZW5jZXIuYzo0OTg1CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBwYXJzZSBjb21taXQgJyVzJyIKIG1zZ3N0ciAi5LiN6IO96Kej5p6Q5o+Q5LqkICclcyciCiAKLSM6IHJhbmdlLWRpZmYuYzoxMTcKKyM6IHJhbmdlLWRpZmYuYzoxMTgKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHBhcnNlIGdpdCBoZWFkZXIgJyUuKnMnIgogbXNnc3RyICLml6Dms5Xop6PmnpAgZ2l0IOWktCAnJS4qcyciCiAKLSM6IHJhbmdlLWRpZmYuYzoyNzQKKyM6IHJhbmdlLWRpZmYuYzoyNzUKIG1zZ2lkICJmYWlsZWQgdG8gZ2VuZXJhdGUgZGlmZiIKIG1zZ3N0ciAi55Sf5oiQIGRpZmYg5aSx6LSlIgogCi0jOiByYW5nZS1kaWZmLmM6NTA2IHJhbmdlLWRpZmYuYzo1MDgKKyM6IHJhbmdlLWRpZmYuYzo1MDcgcmFuZ2UtZGlmZi5jOjUwOQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcGFyc2UgbG9nIGZvciAnJXMnIgogbXNnc3RyICLkuI3og73op6PmnpAgJyVzJyDnmoTml6Xlv5ciCkBAIC00NjIzLDExICs0NjU3LDExIEBACiBtc2dpZCAiJyVzJyBhcHBlYXJzIGFzIGJvdGggYSBmaWxlIGFuZCBhcyBhIGRpcmVjdG9yeSIKIG1zZ3N0ciAiJyVzJyDnnIvotbfmnaXml6LmmK/mlofku7blj4jmmK/nm67lvZUiCiAKLSM6IHJlYWQtY2FjaGUuYzoxNDk5CisjOiByZWFkLWNhY2hlLmM6MTUyMAogbXNnaWQgIlJlZnJlc2ggaW5kZXgiCiBtc2dzdHIgIuWIt+aWsOe0ouW8lSIKIAotIzogcmVhZC1jYWNoZS5jOjE2MTMKKyM6IHJlYWQtY2FjaGUuYzoxNjM1CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJpbmRleC52ZXJzaW9uIHNldCwgYnV0IHRoZSB2YWx1ZSBpcyBpbnZhbGlkLlxuIgpAQCAtNDYzNiw3ICs0NjcwLDcgQEAKICLorr7nva7kuoYgaW5kZXgudmVyc2lvbu+8jOS9huaYr+WPluWAvOaXoOaViOOAglxuIgogIuS9v+eUqOeJiOacrCAlaSIKIAotIzogcmVhZC1jYWNoZS5jOjE2MjMKKyM6IHJlYWQtY2FjaGUuYzoxNjQ1CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJHSVRfSU5ERVhfVkVSU0lPTiBzZXQsIGJ1dCB0aGUgdmFsdWUgaXMgaW52YWxpZC5cbiIKQEAgLTQ2NDUsMTM5ICs0Njc5LDEzOSBAQAogIuiuvue9ruS6hiBHSVRfSU5ERVhfVkVSU0lPTu+8jOS9huaYr+WPluWAvOaXoOaViOOAglxuIgogIuS9v+eUqOeJiOacrCAlaSIKIAotIzogcmVhZC1jYWNoZS5jOjE2NzkKKyM6IHJlYWQtY2FjaGUuYzoxNzAxCiAjLCBjLWZvcm1hdAogbXNnaWQgImJhZCBzaWduYXR1cmUgMHglMDh4IgogbXNnc3RyICLlnY/nmoTnrb7lkI0gMHglMDh4IgogCi0jOiByZWFkLWNhY2hlLmM6MTY4MgorIzogcmVhZC1jYWNoZS5jOjE3MDQKICMsIGMtZm9ybWF0CiBtc2dpZCAiYmFkIGluZGV4IHZlcnNpb24gJWQiCiBtc2dzdHIgIuWdj+eahOe0ouW8leeJiOacrCAlZCIKIAotIzogcmVhZC1jYWNoZS5jOjE2OTEKKyM6IHJlYWQtY2FjaGUuYzoxNzEzCiBtc2dpZCAiYmFkIGluZGV4IGZpbGUgc2hhMSBzaWduYXR1cmUiCiBtc2dzdHIgIuWdj+eahOe0ouW8leaWh+S7tiBzaGExIOetvuWQjSIKIAotIzogcmVhZC1jYWNoZS5jOjE3MjEKKyM6IHJlYWQtY2FjaGUuYzoxNzQzCiAjLCBjLWZvcm1hdAogbXNnaWQgImluZGV4IHVzZXMgJS40cyBleHRlbnNpb24sIHdoaWNoIHdlIGRvIG5vdCB1bmRlcnN0YW5kIgogbXNnc3RyICLntKLlvJXkvb/nlKjkuI3ooqvmlK/mjIHnmoQgJS40cyDmianlsZUiCiAKICMgCQotIzogcmVhZC1jYWNoZS5jOjE3MjMKKyM6IHJlYWQtY2FjaGUuYzoxNzQ1CiAjLCBjLWZvcm1hdAogbXNnaWQgImlnbm9yaW5nICUuNHMgZXh0ZW5zaW9uIgogbXNnc3RyICLlv73nlaUgJS40cyDmianlsZUiCiAKLSM6IHJlYWQtY2FjaGUuYzoxNzYwCisjOiByZWFkLWNhY2hlLmM6MTc4MgogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmtub3duIGluZGV4IGVudHJ5IGZvcm1hdCAweCUwOHgiCiBtc2dzdHIgIuacquefpeeahOe0ouW8leadoeebruagvOW8jyAweCUwOHgiCiAKLSM6IHJlYWQtY2FjaGUuYzoxNzc2CisjOiByZWFkLWNhY2hlLmM6MTc5OAogIywgYy1mb3JtYXQKIG1zZ2lkICJtYWxmb3JtZWQgbmFtZSBmaWVsZCBpbiB0aGUgaW5kZXgsIG5lYXIgcGF0aCAnJXMnIgogbXNnc3RyICLntKLlvJXkuK3pnaDov5Hot6/lvoQgJyVzJyDmnInplJnor6/nmoTlkI3np7DlrZfmrrUiCiAKLSM6IHJlYWQtY2FjaGUuYzoxODMzCisjOiByZWFkLWNhY2hlLmM6MTg1NQogbXNnaWQgInVub3JkZXJlZCBzdGFnZSBlbnRyaWVzIGluIGluZGV4IgogbXNnc3RyICLntKLlvJXkuK3mnInmnKrmjpLluo/nmoTmmoLlrZjmnaHnm64iCiAKLSM6IHJlYWQtY2FjaGUuYzoxODM2CisjOiByZWFkLWNhY2hlLmM6MTg1OAogIywgYy1mb3JtYXQKIG1zZ2lkICJtdWx0aXBsZSBzdGFnZSBlbnRyaWVzIGZvciBtZXJnZWQgZmlsZSAnJXMnIgogbXNnc3RyICLlkIjlubbmlofku7YgJyVzJyDmnInlpJrkuKrmmoLlrZjmnaHnm64iCiAKLSM6IHJlYWQtY2FjaGUuYzoxODM5CisjOiByZWFkLWNhY2hlLmM6MTg2MQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bm9yZGVyZWQgc3RhZ2UgZW50cmllcyBmb3IgJyVzJyIKIG1zZ3N0ciAiJyVzJyDnmoTmnKrmjpLluo/mmoLlrZjmnaHnm64iCiAKLSM6IHJlYWQtY2FjaGUuYzoxOTQ2IHJlYWQtY2FjaGUuYzoyMjM0IHJlcmVyZS5jOjU2NSByZXJlcmUuYzo1OTkgcmVyZXJlLmM6MTExMQotIzogYnVpbHRpbi9hZGQuYzo0NjAgYnVpbHRpbi9jaGVjay1pZ25vcmUuYzoxNzggYnVpbHRpbi9jaGVja291dC5jOjQ2NwotIzogYnVpbHRpbi9jaGVja291dC5jOjY1MSBidWlsdGluL2NsZWFuLmM6OTU2IGJ1aWx0aW4vY29tbWl0LmM6MzQ3CisjOiByZWFkLWNhY2hlLmM6MTk2NyByZWFkLWNhY2hlLmM6MjI1NSByZXJlcmUuYzo1NjUgcmVyZXJlLmM6NTk5IHJlcmVyZS5jOjExMTEKKyM6IGJ1aWx0aW4vYWRkLmM6NDYwIGJ1aWx0aW4vY2hlY2staWdub3JlLmM6MTc4IGJ1aWx0aW4vY2hlY2tvdXQuYzo0NjgKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo2NTIgYnVpbHRpbi9jbGVhbi5jOjk2NyBidWlsdGluL2NvbW1pdC5jOjM0NwogIzogYnVpbHRpbi9kaWZmLXRyZWUuYzoxMjAgYnVpbHRpbi9ncmVwLmM6NDk5IGJ1aWx0aW4vbXYuYzoxNDUKICM6IGJ1aWx0aW4vcmVzZXQuYzoyNDUgYnVpbHRpbi9ybS5jOjI3MSBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6MzMwCiBtc2dpZCAiaW5kZXggZmlsZSBjb3JydXB0IgogbXNnc3RyICLntKLlvJXmlofku7bmjZ/lnY8iCiAKLSM6IHJlYWQtY2FjaGUuYzoyMDg3CisjOiByZWFkLWNhY2hlLmM6MjEwOAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gY3JlYXRlIGxvYWRfY2FjaGVfZW50cmllcyB0aHJlYWQ6ICVzIgogbXNnc3RyICLml6Dms5XliJvlu7ogbG9hZF9jYWNoZV9lbnRyaWVzIOe6v+eoi++8miVzIgogCi0jOiByZWFkLWNhY2hlLmM6MjEwMAorIzogcmVhZC1jYWNoZS5jOjIxMjEKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGpvaW4gbG9hZF9jYWNoZV9lbnRyaWVzIHRocmVhZDogJXMiCiBtc2dzdHIgIuaXoOazleWKoOWFpSBsb2FkX2NhY2hlX2VudHJpZXMg57q/56iL77yaJXMiCiAKLSM6IHJlYWQtY2FjaGUuYzoyMTMzCisjOiByZWFkLWNhY2hlLmM6MjE1NAogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogaW5kZXggZmlsZSBvcGVuIGZhaWxlZCIKIG1zZ3N0ciAiJXPvvJrmiZPlvIDntKLlvJXmlofku7blpLHotKUiCiAKLSM6IHJlYWQtY2FjaGUuYzoyMTM3CisjOiByZWFkLWNhY2hlLmM6MjE1OAogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogY2Fubm90IHN0YXQgdGhlIG9wZW4gaW5kZXgiCiBtc2dzdHIgIiVz77ya5LiN6IO95a+55omT5byA55qE57Si5byV5omn6KGMIHN0YXQg5pON5L2cIgogCi0jOiByZWFkLWNhY2hlLmM6MjE0MQorIzogcmVhZC1jYWNoZS5jOjIxNjIKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXM6IGluZGV4IGZpbGUgc21hbGxlciB0aGFuIGV4cGVjdGVkIgogbXNnc3RyICIlc++8mue0ouW8leaWh+S7tuavlOmihOacn+eahOWwjyIKIAotIzogcmVhZC1jYWNoZS5jOjIxNDUKKyM6IHJlYWQtY2FjaGUuYzoyMTY2CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiB1bmFibGUgdG8gbWFwIGluZGV4IGZpbGUiCiBtc2dzdHIgIiVz77ya5peg5rOV5a+557Si5byV5paH5Lu25omn6KGMIG1hcCDmk43kvZwiCiAKLSM6IHJlYWQtY2FjaGUuYzoyMTg3CisjOiByZWFkLWNhY2hlLmM6MjIwOAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gY3JlYXRlIGxvYWRfaW5kZXhfZXh0ZW5zaW9ucyB0aHJlYWQ6ICVzIgogbXNnc3RyICLml6Dms5XliJvlu7ogbG9hZF9pbmRleF9leHRlbnNpb25zIOe6v+eoi++8miVzIgogCi0jOiByZWFkLWNhY2hlLmM6MjIxNAorIzogcmVhZC1jYWNoZS5jOjIyMzUKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGpvaW4gbG9hZF9pbmRleF9leHRlbnNpb25zIHRocmVhZDogJXMiCiBtc2dzdHIgIuaXoOazleWKoOWFpSBsb2FkX2luZGV4X2V4dGVuc2lvbnMg57q/56iL77yaJXMiCiAKLSM6IHJlYWQtY2FjaGUuYzoyMjQ2CisjOiByZWFkLWNhY2hlLmM6MjI2NwogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgZnJlc2hlbiBzaGFyZWQgaW5kZXggJyVzJyIKIG1zZ3N0ciAi5peg5rOV5Yi35paw5YWx5Lqr57Si5byVICclcyciCiAKLSM6IHJlYWQtY2FjaGUuYzoyMjkzCisjOiByZWFkLWNhY2hlLmM6MjMxNAogIywgYy1mb3JtYXQKIG1zZ2lkICJicm9rZW4gaW5kZXgsIGV4cGVjdCAlcyBpbiAlcywgZ290ICVzIgogbXNnc3RyICLmjZ/lnY/nmoTntKLlvJXvvIzmnJ/mnJvlnKggJTIkcyDkuK3nmoQgJTEkc++8jOW+l+WIsCAlMyRzIgogCi0jOiByZWFkLWNhY2hlLmM6Mjk4OSB3cmFwcGVyLmM6NjU4IGJ1aWx0aW4vbWVyZ2UuYzoxMTE0CisjOiByZWFkLWNhY2hlLmM6MzAxMCB3cmFwcGVyLmM6NjIyIGJ1aWx0aW4vbWVyZ2UuYzoxMTE5CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBjbG9zZSAnJXMnIgogbXNnc3RyICLkuI3og73lhbPpl60gJyVzJyIKIAotIzogcmVhZC1jYWNoZS5jOjMwOTIgc2VxdWVuY2VyLmM6MjM1OCBzZXF1ZW5jZXIuYzozOTI4CisjOiByZWFkLWNhY2hlLmM6MzExMyBzZXF1ZW5jZXIuYzoyMjk2IHNlcXVlbmNlci5jOjM5MTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHN0YXQgJyVzJyIKIG1zZ3N0ciAi5LiN6IO95a+5ICclcycg6LCD55SoIHN0YXQiCiAKLSM6IHJlYWQtY2FjaGUuYzozMTA1CisjOiByZWFkLWNhY2hlLmM6MzEyNgogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gb3BlbiBnaXQgZGlyOiAlcyIKIG1zZ3N0ciAi5LiN6IO95omT5byAIGdpdCDnm67lvZXvvJolcyIKIAotIzogcmVhZC1jYWNoZS5jOjMxMTcKKyM6IHJlYWQtY2FjaGUuYzozMTM4CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byB1bmxpbms6ICVzIgogbXNnc3RyICLml6Dms5XliKDpmaTvvJolcyIKIAotIzogcmVhZC1jYWNoZS5jOjMxNDIKKyM6IHJlYWQtY2FjaGUuYzozMTYzCiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCBmaXggcGVybWlzc2lvbiBiaXRzIG9uICclcyciCiBtc2dzdHIgIuS4jeiDveS/ruWkjSAnJXMnIOeahOadg+mZkOS9jSIKIAotIzogcmVhZC1jYWNoZS5jOjMyOTEKKyM6IHJlYWQtY2FjaGUuYzozMzEyCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiBjYW5ub3QgZHJvcCB0byBzdGFnZSAjMCIKIG1zZ3N0ciAiJXPvvJrkuI3og73okL3liLDmmoLlrZjljLogIzAiCkBAIC00ODc5LDggKzQ5MTMsOCBAQAogbXNnaWQgIk5vdGUgdGhhdCBlbXB0eSBjb21taXRzIGFyZSBjb21tZW50ZWQgb3V0IgogbXNnc3RyICLms6jmhI/nqbrmj5DkuqTlt7Looqvms6jph4rmjokiCiAKLSM6IHJlYmFzZS1pbnRlcmFjdGl2ZS5jOjEwNSByZXJlcmUuYzo0ODUgcmVyZXJlLmM6NjkyIHNlcXVlbmNlci5jOjM0NDcKLSM6IHNlcXVlbmNlci5jOjM0NzMgc2VxdWVuY2VyLmM6NTEyMCBidWlsdGluL2ZzY2suYzozNTYgYnVpbHRpbi9yZWJhc2UuYzoyMzUKKyM6IHJlYmFzZS1pbnRlcmFjdGl2ZS5jOjEwNSByZXJlcmUuYzo0ODUgcmVyZXJlLmM6NjkyIHNlcXVlbmNlci5jOjMzODgKKyM6IHNlcXVlbmNlci5jOjM0MTQgc2VxdWVuY2VyLmM6NTA4NCBidWlsdGluL2ZzY2suYzozNTYgYnVpbHRpbi9yZWJhc2UuYzoyMzUKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHdyaXRlICclcyciCiBtc2dzdHIgIuS4jeiDveWGmeWFpSAnJXMnIgpAQCAtNDkyNSw3ICs0OTU5LDcgQEAKIG1zZ2lkICJpZ25vcmluZyBkYW5nbGluZyBzeW1yZWYgJXMiCiBtc2dzdHIgIuW/veeVpeaCrOepuuespuWPt+W8leeUqCAlcyIKIAotIzogcmVmcy5jOjY2OSByZWYtZmlsdGVyLmM6MjA5MgorIzogcmVmcy5jOjY2OSByZWYtZmlsdGVyLmM6MjA5OAogIywgYy1mb3JtYXQKIG1zZ2lkICJpZ25vcmluZyBicm9rZW4gcmVmICVzIgogbXNnc3RyICLlv73nlaXmjZ/lnY/nmoTlvJXnlKggJXMiCkBAIC00OTUwLDE0ICs0OTg0LDE0IEBACiBtc2dpZCAidW5leHBlY3RlZCBvYmplY3QgSUQgd2hlbiB3cml0aW5nICclcyciCiBtc2dzdHIgIuWGmeWFpSAnJXMnIOaXtuaEj+WklueahOWvueixoSBJRCIKIAotIzogcmVmcy5jOjgzMyBzZXF1ZW5jZXIuYzo0MDMgc2VxdWVuY2VyLmM6MjcwOSBzZXF1ZW5jZXIuYzoyOTEzCi0jOiBzZXF1ZW5jZXIuYzoyOTI3IHNlcXVlbmNlci5jOjMxODQgc2VxdWVuY2VyLmM6NTAzNyB3cmFwcGVyLmM6NjU2CisjOiByZWZzLmM6ODMzIHNlcXVlbmNlci5jOjQwMyBzZXF1ZW5jZXIuYzoyNjQ3IHNlcXVlbmNlci5jOjI4NTEKKyM6IHNlcXVlbmNlci5jOjI4NjUgc2VxdWVuY2VyLmM6MzEyMiBzZXF1ZW5jZXIuYzo1MDAxIHdyYXBwZXIuYzo2MjAKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHdyaXRlIHRvICclcyciCiBtc2dzdHIgIuS4jeiDveWGmeWFpSAnJXMnIgogCi0jOiByZWZzLmM6ODYwIHdyYXBwZXIuYzoyMjUgd3JhcHBlci5jOjM5NSBidWlsdGluL2FtLmM6NzE1Ci0jOiBidWlsdGluL3JlYmFzZS5jOjEwMDMKKyM6IHJlZnMuYzo4NjAgd3JhcHBlci5jOjE4OCB3cmFwcGVyLmM6MzU4IGJ1aWx0aW4vYW0uYzo3MTQKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTAwNAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3Qgb3BlbiAnJXMnIGZvciB3cml0aW5nIgogbXNnc3RyICLml6Dms5XmiZPlvIAgJyVzJyDov5vooYzlhpnlhaUiCkBAIC00OTkyLDIxICs1MDI2LDIxIEBACiBtc2dpZCAidXBkYXRlX3JlZiBmYWlsZWQgZm9yIHJlZiAnJXMnOiAlcyIKIG1zZ3N0ciAi5a+55byV55SoICclcycg5omn6KGMIHVwZGF0ZV9yZWYg5aSx6LSl77yaJXMiCiAKLSM6IHJlZnMuYzoyMDEyCisjOiByZWZzLmM6MjAyMwogIywgYy1mb3JtYXQKIG1zZ2lkICJtdWx0aXBsZSB1cGRhdGVzIGZvciByZWYgJyVzJyBub3QgYWxsb3dlZCIKIG1zZ3N0ciAi5LiN5YWB6K645a+55byV55SoICclcycg5aSa5qyh5pu05pawIgogCi0jOiByZWZzLmM6MjA0NAorIzogcmVmcy5jOjIwNTUKIG1zZ2lkICJyZWYgdXBkYXRlcyBmb3JiaWRkZW4gaW5zaWRlIHF1YXJhbnRpbmUgZW52aXJvbm1lbnQiCiBtc2dzdHIgIuWcqOmalOemu+eOr+Wig+S4reemgeatouabtOaWsOW8leeUqCIKIAotIzogcmVmcy5jOjIxNDAgcmVmcy5jOjIxNzAKKyM6IHJlZnMuYzoyMTUxIHJlZnMuYzoyMTgxCiAjLCBjLWZvcm1hdAogbXNnaWQgIiclcycgZXhpc3RzOyBjYW5ub3QgY3JlYXRlICclcyciCiBtc2dzdHIgIiclcycg5bey5a2Y5Zyo77yM5peg5rOV5Yib5bu6ICclcyciCiAKLSM6IHJlZnMuYzoyMTQ2IHJlZnMuYzoyMTgxCisjOiByZWZzLmM6MjE1NyByZWZzLmM6MjE5MgogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgcHJvY2VzcyAnJXMnIGFuZCAnJXMnIGF0IHRoZSBzYW1lIHRpbWUiCiBtc2dzdHIgIuaXoOazleWQjOaXtuWkhOeQhiAnJXMnIOWSjCAnJXMnIgpAQCAtNTAxNiwxMyArNTA1MCwxMyBAQAogbXNnaWQgImNvdWxkIG5vdCByZW1vdmUgcmVmZXJlbmNlICVzIgogbXNnc3RyICLml6Dms5XliKDpmaTlvJXnlKggJXMiCiAKLSM6IHJlZnMvZmlsZXMtYmFja2VuZC5jOjEyNDggcmVmcy9wYWNrZWQtYmFja2VuZC5jOjE1MzIKLSM6IHJlZnMvcGFja2VkLWJhY2tlbmQuYzoxNTQyCisjOiByZWZzL2ZpbGVzLWJhY2tlbmQuYzoxMjQ4IHJlZnMvcGFja2VkLWJhY2tlbmQuYzoxNTQxCisjOiByZWZzL3BhY2tlZC1iYWNrZW5kLmM6MTU1MQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgZGVsZXRlIHJlZmVyZW5jZSAlczogJXMiCiBtc2dzdHIgIuaXoOazleWIoOmZpOW8leeUqCAlc++8miVzIgogCi0jOiByZWZzL2ZpbGVzLWJhY2tlbmQuYzoxMjUxIHJlZnMvcGFja2VkLWJhY2tlbmQuYzoxNTQ1CisjOiByZWZzL2ZpbGVzLWJhY2tlbmQuYzoxMjUxIHJlZnMvcGFja2VkLWJhY2tlbmQuYzoxNTU0CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBkZWxldGUgcmVmZXJlbmNlczogJXMiCiBtc2dzdHIgIuaXoOazleWIoOmZpOW8leeUqO+8miVzIgpAQCAtNTAzMiw3ICs1MDY2LDcgQEAKIG1zZ2lkICJpbnZhbGlkIHJlZnNwZWMgJyVzJyIKIG1zZ3N0ciAi5peg5pWI55qE5byV55So6KGo6L6+5byP77yaJyVzJyIKIAotIzogcmVmLWZpbHRlci5jOjQyIHd0LXN0YXR1cy5jOjE5MzQKKyM6IHJlZi1maWx0ZXIuYzo0MiB3dC1zdGF0dXMuYzoxOTM4CiBtc2dpZCAiZ29uZSIKIG1zZ3N0ciAi5Lii5aSxIgogCkBAIC01MDUxLDI4MCArNTA4NSwyODAgQEAKIG1zZ2lkICJhaGVhZCAlZCwgYmVoaW5kICVkIgogbXNnc3RyICLpooblhYggJWTvvIzokL3lkI4gJWQiCiAKLSM6IHJlZi1maWx0ZXIuYzoxNjIKKyM6IHJlZi1maWx0ZXIuYzoxNjUKICMsIGMtZm9ybWF0CiBtc2dpZCAiZXhwZWN0ZWQgZm9ybWF0OiAlJShjb2xvcjo8Y29sb3I+KSIKIG1zZ3N0ciAi5pyf5pyb55qE5qC85byP77yaJSUoY29sb3I6POminOiJsj4pIgogCi0jOiByZWYtZmlsdGVyLmM6MTY0CisjOiByZWYtZmlsdGVyLmM6MTY3CiAjLCBjLWZvcm1hdAogbXNnaWQgInVucmVjb2duaXplZCBjb2xvcjogJSUoY29sb3I6JXMpIgogbXNnc3RyICLmnKrog73or4bliKvnmoTpopzoibLvvJolJShjb2xvcjolcykiCiAKLSM6IHJlZi1maWx0ZXIuYzoxODYKKyM6IHJlZi1maWx0ZXIuYzoxODkKICMsIGMtZm9ybWF0CiBtc2dpZCAiSW50ZWdlciB2YWx1ZSBleHBlY3RlZCByZWZuYW1lOmxzdHJpcD0lcyIKIG1zZ3N0ciAi5pyf5pyb5pW05pWw5YC8IHJlZm5hbWU6bHN0cmlwPSVzIgogCi0jOiByZWYtZmlsdGVyLmM6MTkwCisjOiByZWYtZmlsdGVyLmM6MTkzCiAjLCBjLWZvcm1hdAogbXNnaWQgIkludGVnZXIgdmFsdWUgZXhwZWN0ZWQgcmVmbmFtZTpyc3RyaXA9JXMiCiBtc2dzdHIgIuacn+acm+aVtOaVsOWAvCByZWZuYW1lOnJzdHJpcD0lcyIKIAotIzogcmVmLWZpbHRlci5jOjE5MgorIzogcmVmLWZpbHRlci5jOjE5NQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bnJlY29nbml6ZWQgJSUoJXMpIGFyZ3VtZW50OiAlcyIKIG1zZ3N0ciAi5pyq6IO96K+G5Yir55qEICUlKCVzKSDlj4LmlbDvvJolcyIKIAotIzogcmVmLWZpbHRlci5jOjI0NworIzogcmVmLWZpbHRlci5jOjI1MAogIywgYy1mb3JtYXQKIG1zZ2lkICIlJShvYmplY3R0eXBlKSBkb2VzIG5vdCB0YWtlIGFyZ3VtZW50cyIKIG1zZ3N0ciAiJSUob2JqZWN0dHlwZSkg5LiN5bim5Y+C5pWwIgogCi0jOiByZWYtZmlsdGVyLmM6MjY5CisjOiByZWYtZmlsdGVyLmM6MjcyCiAjLCBjLWZvcm1hdAogbXNnaWQgInVucmVjb2duaXplZCAlJShvYmplY3RzaXplKSBhcmd1bWVudDogJXMiCiBtc2dzdHIgIuacquiDveivhuWIq+eahCAlJShvYmplY3RzaXplKSDlj4LmlbDvvJolcyIKIAotIzogcmVmLWZpbHRlci5jOjI3NworIzogcmVmLWZpbHRlci5jOjI4MAogIywgYy1mb3JtYXQKIG1zZ2lkICIlJShkZWx0YWJhc2UpIGRvZXMgbm90IHRha2UgYXJndW1lbnRzIgogbXNnc3RyICIlJShkZWx0YWJhc2UpIOS4jeW4puWPguaVsCIKIAotIzogcmVmLWZpbHRlci5jOjI4OQorIzogcmVmLWZpbHRlci5jOjI5MgogIywgYy1mb3JtYXQKIG1zZ2lkICIlJShib2R5KSBkb2VzIG5vdCB0YWtlIGFyZ3VtZW50cyIKIG1zZ3N0ciAiJSUoYm9keSkg5LiN5bim5Y+C5pWwIgogCi0jOiByZWYtZmlsdGVyLmM6Mjk4CisjOiByZWYtZmlsdGVyLmM6MzAxCiAjLCBjLWZvcm1hdAogbXNnaWQgIiUlKHN1YmplY3QpIGRvZXMgbm90IHRha2UgYXJndW1lbnRzIgogbXNnc3RyICIlJShzdWJqZWN0KSDkuI3luKblj4LmlbAiCiAKLSM6IHJlZi1maWx0ZXIuYzozMjAKKyM6IHJlZi1maWx0ZXIuYzozMjMKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5rbm93biAlJSh0cmFpbGVycykgYXJndW1lbnQ6ICVzIgogbXNnc3RyICLmnKrnn6XnmoQgJSUodHJhaWxlcnMpIOWPguaVsO+8miVzIgogCi0jOiByZWYtZmlsdGVyLmM6MzQ5CisjOiByZWYtZmlsdGVyLmM6MzUyCiAjLCBjLWZvcm1hdAogbXNnaWQgInBvc2l0aXZlIHZhbHVlIGV4cGVjdGVkIGNvbnRlbnRzOmxpbmVzPSVzIgogbXNnc3RyICLmnJ/mnJvkuIDkuKrmraPmlbAgY29udGVudHM6bGluZXM9JXMiCiAKLSM6IHJlZi1maWx0ZXIuYzozNTEKKyM6IHJlZi1maWx0ZXIuYzozNTQKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5yZWNvZ25pemVkICUlKGNvbnRlbnRzKSBhcmd1bWVudDogJXMiCiBtc2dzdHIgIuacquiDveivhuWIq+eahCAlJShjb250ZW50cykg5Y+C5pWw77yaJXMiCiAKLSM6IHJlZi1maWx0ZXIuYzozNjYKKyM6IHJlZi1maWx0ZXIuYzozNjkKICMsIGMtZm9ybWF0CiBtc2dpZCAicG9zaXRpdmUgdmFsdWUgZXhwZWN0ZWQgb2JqZWN0bmFtZTpzaG9ydD0lcyIKIG1zZ3N0ciAi5pyf5pyb5LiA5Liq5q2j5pWwIG9iamVjdG5hbWU6c2hvcnQ9JXMiCiAKLSM6IHJlZi1maWx0ZXIuYzozNzAKKyM6IHJlZi1maWx0ZXIuYzozNzMKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5yZWNvZ25pemVkICUlKG9iamVjdG5hbWUpIGFyZ3VtZW50OiAlcyIKIG1zZ3N0ciAi5pyq6IO96K+G5Yir55qEICUlKG9iamVjdG5hbWUpIOWPguaVsO+8miVzIgogCi0jOiByZWYtZmlsdGVyLmM6NDAwCisjOiByZWYtZmlsdGVyLmM6NDAzCiAjLCBjLWZvcm1hdAogbXNnaWQgImV4cGVjdGVkIGZvcm1hdDogJSUoYWxpZ246PHdpZHRoPiw8cG9zaXRpb24+KSIKIG1zZ3N0ciAi5pyf5pyb55qE5qC85byP77yaJSUoYWxpZ246POWuveW6pj4sPOS9jee9rj4pIgogCi0jOiByZWYtZmlsdGVyLmM6NDEyCisjOiByZWYtZmlsdGVyLmM6NDE1CiAjLCBjLWZvcm1hdAogbXNnaWQgInVucmVjb2duaXplZCBwb3NpdGlvbjolcyIKIG1zZ3N0ciAi5pyq6IO96K+G5Yir55qE5L2N572u77yaJXMiCiAKLSM6IHJlZi1maWx0ZXIuYzo0MTkKKyM6IHJlZi1maWx0ZXIuYzo0MjIKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5yZWNvZ25pemVkIHdpZHRoOiVzIgogbXNnc3RyICLmnKrog73or4bliKvnmoTlrr3luqbvvJolcyIKIAotIzogcmVmLWZpbHRlci5jOjQyOAorIzogcmVmLWZpbHRlci5jOjQzMQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bnJlY29nbml6ZWQgJSUoYWxpZ24pIGFyZ3VtZW50OiAlcyIKIG1zZ3N0ciAi5pyq6IO96K+G5Yir55qEICUlKGFsaWduKSDlj4LmlbDvvJolcyIKIAotIzogcmVmLWZpbHRlci5jOjQzNgorIzogcmVmLWZpbHRlci5jOjQzOQogIywgYy1mb3JtYXQKIG1zZ2lkICJwb3NpdGl2ZSB3aWR0aCBleHBlY3RlZCB3aXRoIHRoZSAlJShhbGlnbikgYXRvbSIKIG1zZ3N0ciAi5YWD57SgICUlKGFsaWduKSDpnIDopoHkuIDkuKrmraPmlbDnmoTlrr3luqYiCiAKLSM6IHJlZi1maWx0ZXIuYzo0NTQKKyM6IHJlZi1maWx0ZXIuYzo0NTcKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5yZWNvZ25pemVkICUlKGlmKSBhcmd1bWVudDogJXMiCiBtc2dzdHIgIuacquiDveivhuWIq+eahCAlJShpZikg5Y+C5pWw77yaJXMiCiAKLSM6IHJlZi1maWx0ZXIuYzo1NTYKKyM6IHJlZi1maWx0ZXIuYzo1NTkKICMsIGMtZm9ybWF0CiBtc2dpZCAibWFsZm9ybWVkIGZpZWxkIG5hbWU6ICUuKnMiCiBtc2dzdHIgIuagvOW8j+mUmeivr+eahOWtl+auteWQje+8miUuKnMiCiAKLSM6IHJlZi1maWx0ZXIuYzo1ODMKKyM6IHJlZi1maWx0ZXIuYzo1ODYKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5rbm93biBmaWVsZCBuYW1lOiAlLipzIgogbXNnc3RyICLmnKrnn6XnmoTlrZfmrrXlkI3vvJolLipzIgogCi0jOiByZWYtZmlsdGVyLmM6NTg3CisjOiByZWYtZmlsdGVyLmM6NTkwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJub3QgYSBnaXQgcmVwb3NpdG9yeSwgYnV0IHRoZSBmaWVsZCAnJS4qcycgcmVxdWlyZXMgYWNjZXNzIHRvIG9iamVjdCBkYXRhIgogbXNnc3RyICLkuI3mmK/kuIDkuKogZ2l0IOS7k+W6k++8jOS9huaYr+Wtl+autSAnJS4qcycg6ZyA6KaB6K6/6Zeu5a+56LGh5pWw5o2uIgogCi0jOiByZWYtZmlsdGVyLmM6NzExCisjOiByZWYtZmlsdGVyLmM6NzE0CiAjLCBjLWZvcm1hdAogbXNnaWQgImZvcm1hdDogJSUoaWYpIGF0b20gdXNlZCB3aXRob3V0IGEgJSUodGhlbikgYXRvbSIKIG1zZ3N0ciAi5qC85byP77ya5L2/55So5LqGICUlKGlmKSDlhYPntKDogIzmsqHmnIkgJSUodGhlbikg5YWD57SgIgogCi0jOiByZWYtZmlsdGVyLmM6Nzc0CisjOiByZWYtZmlsdGVyLmM6Nzc3CiAjLCBjLWZvcm1hdAogbXNnaWQgImZvcm1hdDogJSUodGhlbikgYXRvbSB1c2VkIHdpdGhvdXQgYW4gJSUoaWYpIGF0b20iCiBtc2dzdHIgIuagvOW8j++8muS9v+eUqOS6hiAlJSh0aGVuKSDlhYPntKDogIzmsqHmnIkgJSUoaWYpIOWFg+e0oCIKIAotIzogcmVmLWZpbHRlci5jOjc3NgorIzogcmVmLWZpbHRlci5jOjc3OQogIywgYy1mb3JtYXQKIG1zZ2lkICJmb3JtYXQ6ICUlKHRoZW4pIGF0b20gdXNlZCBtb3JlIHRoYW4gb25jZSIKIG1zZ3N0ciAi5qC85byP77yaJSUodGhlbikg5YWD57Sg55So5LqG5aSa5qyhIgogCi0jOiByZWYtZmlsdGVyLmM6Nzc4CisjOiByZWYtZmlsdGVyLmM6NzgxCiAjLCBjLWZvcm1hdAogbXNnaWQgImZvcm1hdDogJSUodGhlbikgYXRvbSB1c2VkIGFmdGVyICUlKGVsc2UpIgogbXNnc3RyICLmoLzlvI/vvJolJSh0aGVuKSDlhYPntKDnlKjlnKjkuoYgJSUoZWxzZSkg5LmL5ZCOIgogCi0jOiByZWYtZmlsdGVyLmM6ODA2CisjOiByZWYtZmlsdGVyLmM6ODA5CiAjLCBjLWZvcm1hdAogbXNnaWQgImZvcm1hdDogJSUoZWxzZSkgYXRvbSB1c2VkIHdpdGhvdXQgYW4gJSUoaWYpIGF0b20iCiBtc2dzdHIgIuagvOW8j++8muS9v+eUqOS6hiAlJShlbHNlKSDlhYPntKDogIzmsqHmnIkgJSUoaWYpIOWFg+e0oCIKIAotIzogcmVmLWZpbHRlci5jOjgwOAorIzogcmVmLWZpbHRlci5jOjgxMQogIywgYy1mb3JtYXQKIG1zZ2lkICJmb3JtYXQ6ICUlKGVsc2UpIGF0b20gdXNlZCB3aXRob3V0IGEgJSUodGhlbikgYXRvbSIKIG1zZ3N0ciAi5qC85byP77ya5L2/55So5LqGICUlKGVsc2UpIOWFg+e0oOiAjOayoeaciSAlJSh0aGVuKSDlhYPntKAiCiAKLSM6IHJlZi1maWx0ZXIuYzo4MTAKKyM6IHJlZi1maWx0ZXIuYzo4MTMKICMsIGMtZm9ybWF0CiBtc2dpZCAiZm9ybWF0OiAlJShlbHNlKSBhdG9tIHVzZWQgbW9yZSB0aGFuIG9uY2UiCiBtc2dzdHIgIuagvOW8j++8miUlKGVsc2UpIOWFg+e0oOeUqOS6huWkmuasoSIKIAotIzogcmVmLWZpbHRlci5jOjgyNQorIzogcmVmLWZpbHRlci5jOjgyOAogIywgYy1mb3JtYXQKIG1zZ2lkICJmb3JtYXQ6ICUlKGVuZCkgYXRvbSB1c2VkIHdpdGhvdXQgY29ycmVzcG9uZGluZyBhdG9tIgogbXNnc3RyICLmoLzlvI/vvJrkvb/nlKjkuoYgJSUoZW5kKSDlhYPntKDljbTmsqHmnInlroPnmoTlr7nlupTlhYPntKAiCiAKLSM6IHJlZi1maWx0ZXIuYzo4ODIKKyM6IHJlZi1maWx0ZXIuYzo4ODUKICMsIGMtZm9ybWF0CiBtc2dpZCAibWFsZm9ybWVkIGZvcm1hdCBzdHJpbmcgJXMiCiBtc2dzdHIgIumUmeivr+eahOagvOW8j+WMluWtl+espuS4siAlcyIKIAotIzogcmVmLWZpbHRlci5jOjE0ODUKKyM6IHJlZi1maWx0ZXIuYzoxNDg4CiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vIGJyYW5jaCwgcmViYXNpbmcgJXMiCiBtc2dzdHIgIumdnuWIhuaUr++8jOato+WPmOWfuiAlcyIKIAotIzogcmVmLWZpbHRlci5jOjE0ODgKKyM6IHJlZi1maWx0ZXIuYzoxNDkxCiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vIGJyYW5jaCwgcmViYXNpbmcgZGV0YWNoZWQgSEVBRCAlcyIKIG1zZ3N0ciAi6Z2e5YiG5pSv77yM5q2j5Y+Y5Z+65YiG56a75aS05oyH6ZKIICVzIgogCi0jOiByZWYtZmlsdGVyLmM6MTQ5MQorIzogcmVmLWZpbHRlci5jOjE0OTQKICMsIGMtZm9ybWF0CiBtc2dpZCAibm8gYnJhbmNoLCBiaXNlY3Qgc3RhcnRlZCBvbiAlcyIKIG1zZ3N0ciAi6Z2e5YiG5pSv77yM5LqM5YiG5p+l5om+5byA5aeL5LqOICVzIgogCi0jOiByZWYtZmlsdGVyLmM6MTUwMQorIzogcmVmLWZpbHRlci5jOjE1MDQKIG1zZ2lkICJubyBicmFuY2giCiBtc2dzdHIgIumdnuWIhuaUryIKIAotIzogcmVmLWZpbHRlci5jOjE1MzcgcmVmLWZpbHRlci5jOjE3NDMKKyM6IHJlZi1maWx0ZXIuYzoxNTQwIHJlZi1maWx0ZXIuYzoxNzQ5CiAjLCBjLWZvcm1hdAogbXNnaWQgIm1pc3Npbmcgb2JqZWN0ICVzIGZvciAlcyIKIG1zZ3N0ciAi57y65aSxICUyJHMg55qE5a+56LGhICUxJHMiCiAKLSM6IHJlZi1maWx0ZXIuYzoxNTQ3CisjOiByZWYtZmlsdGVyLmM6MTU1MAogIywgYy1mb3JtYXQKIG1zZ2lkICJwYXJzZV9vYmplY3RfYnVmZmVyIGZhaWxlZCBvbiAlcyBmb3IgJXMiCiBtc2dzdHIgInBhcnNlX29iamVjdF9idWZmZXIg5aSx6LSl5LqOICUyJHMg55qEICUxJHMiCiAKLSM6IHJlZi1maWx0ZXIuYzoxOTk4CisjOiByZWYtZmlsdGVyLmM6MjAwNAogIywgYy1mb3JtYXQKIG1zZ2lkICJtYWxmb3JtZWQgb2JqZWN0IGF0ICclcyciCiBtc2dzdHIgIuagvOW8j+mUmeivr+eahOWvueixoSAnJXMnIgogCi0jOiByZWYtZmlsdGVyLmM6MjA4NworIzogcmVmLWZpbHRlci5jOjIwOTMKICMsIGMtZm9ybWF0CiBtc2dpZCAiaWdub3JpbmcgcmVmIHdpdGggYnJva2VuIG5hbWUgJXMiCiBtc2dzdHIgIuW/veeVpeW4puaciemUmeivr+WQjeensCAlcyDnmoTlvJXnlKgiCiAKLSM6IHJlZi1maWx0ZXIuYzoyMzgyCisjOiByZWYtZmlsdGVyLmM6MjM4OQogIywgYy1mb3JtYXQKIG1zZ2lkICJmb3JtYXQ6ICUlKGVuZCkgYXRvbSBtaXNzaW5nIgogbXNnc3RyICLmoLzlvI/vvJrnvLrlsJEgJSUoZW5kKSDlhYPntKAiCiAKLSM6IHJlZi1maWx0ZXIuYzoyNDgyCisjOiByZWYtZmlsdGVyLmM6MjQ4OQogIywgYy1mb3JtYXQKIG1zZ2lkICJvcHRpb24gYCVzJyBpcyBpbmNvbXBhdGlibGUgd2l0aCAtLW1lcmdlZCIKIG1zZ3N0ciAi6YCJ6aG5IGAlcycg5ZKMIC0tbWVyZ2VkIOS4jeWFvOWuuSIKIAotIzogcmVmLWZpbHRlci5jOjI0ODUKKyM6IHJlZi1maWx0ZXIuYzoyNDkyCiAjLCBjLWZvcm1hdAogbXNnaWQgIm9wdGlvbiBgJXMnIGlzIGluY29tcGF0aWJsZSB3aXRoIC0tbm8tbWVyZ2VkIgogbXNnc3RyICLpgInpobkgYCVzJyDlkowgLS1uby1tZXJnZWQg5LiN5YW85a65IgogCi0jOiByZWYtZmlsdGVyLmM6MjQ5NQorIzogcmVmLWZpbHRlci5jOjI1MDIKICMsIGMtZm9ybWF0CiBtc2dpZCAibWFsZm9ybWVkIG9iamVjdCBuYW1lICVzIgogbXNnc3RyICLmoLzlvI/plJnor6/nmoTlr7nosaHlkI0gJXMiCiAKLSM6IHJlZi1maWx0ZXIuYzoyNTAwCisjOiByZWYtZmlsdGVyLmM6MjUwNwogIywgYy1mb3JtYXQKIG1zZ2lkICJvcHRpb24gYCVzJyBtdXN0IHBvaW50IHRvIGEgY29tbWl0IgogbXNnc3RyICLpgInpobkgYCVzJyDlv4XpobvmjIflkJHkuIDkuKrmj5DkuqQiCiAKLSM6IHJlbW90ZS5jOjM2MworIzogcmVtb3RlLmM6MzY2CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvbmZpZyByZW1vdGUgc2hvcnRoYW5kIGNhbm5vdCBiZWdpbiB3aXRoICcvJzogJXMiCiBtc2dzdHIgIumFjee9rueahOi/nOeoi+efreWQjeensOS4jeiDveS7pSAnLycg5byA5aeL77yaJXMiCiAKLSM6IHJlbW90ZS5jOjQxMAorIzogcmVtb3RlLmM6NDEzCiBtc2dpZCAibW9yZSB0aGFuIG9uZSByZWNlaXZlcGFjayBnaXZlbiwgdXNpbmcgdGhlIGZpcnN0IgogbXNnc3RyICLmj5DkvpvkuobkuIDkuKrku6XkuIrnmoQgcmVjZWl2ZXBhY2vvvIzkvb/nlKjnrKzkuIDkuKoiCiAKLSM6IHJlbW90ZS5jOjQxOAorIzogcmVtb3RlLmM6NDIxCiBtc2dpZCAibW9yZSB0aGFuIG9uZSB1cGxvYWRwYWNrIGdpdmVuLCB1c2luZyB0aGUgZmlyc3QiCiBtc2dzdHIgIuaPkOS+m+S6huS4gOS4quS7peS4iueahCB1cGxvYWRwYWNr77yM5L2/55So56ys5LiA5LiqIgogCi0jOiByZW1vdGUuYzo2MDgKKyM6IHJlbW90ZS5jOjYxMQogIywgYy1mb3JtYXQKIG1zZ2lkICJDYW5ub3QgZmV0Y2ggYm90aCAlcyBhbmQgJXMgdG8gJXMiCiBtc2dzdHIgIuS4jeiDveWQjOaXtuiOt+WPliAlcyDlkowgJXMg6IezICVzIgogCi0jOiByZW1vdGUuYzo2MTIKKyM6IHJlbW90ZS5jOjYxNQogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyB1c3VhbGx5IHRyYWNrcyAlcywgbm90ICVzIgogbXNnc3RyICIlcyDpgJrluLjot5/ouKogJXPvvIzogIzpnZ4gJXMiCiAKLSM6IHJlbW90ZS5jOjYxNgorIzogcmVtb3RlLmM6NjE5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIHRyYWNrcyBib3RoICVzIGFuZCAlcyIKIG1zZ3N0ciAiJXMg5ZCM5pe26Lef6LiqICVzIOWSjCAlcyIKIAotIzogcmVtb3RlLmM6Njg0CisjOiByZW1vdGUuYzo2ODcKICMsIGMtZm9ybWF0CiBtc2dpZCAia2V5ICclcycgb2YgcGF0dGVybiBoYWQgbm8gJyonIgogbXNnc3RyICLmqKHlvI/nmoTplK4gJyVzJyDmsqHmnIkgJyonIgogCi0jOiByZW1vdGUuYzo2OTQKKyM6IHJlbW90ZS5jOjY5NwogIywgYy1mb3JtYXQKIG1zZ2lkICJ2YWx1ZSAnJXMnIG9mIHBhdHRlcm4gaGFzIG5vICcqJyIKIG1zZ3N0ciAi5qih5byP55qE5YC8ICclcycg5rKh5pyJICcqJyIKIAotIzogcmVtb3RlLmM6MTAwMAorIzogcmVtb3RlLmM6MTAwMwogIywgYy1mb3JtYXQKIG1zZ2lkICJzcmMgcmVmc3BlYyAlcyBkb2VzIG5vdCBtYXRjaCBhbnkiCiBtc2dzdHIgIua6kOW8leeUqOihqOi+vuW8jyAlcyDmsqHmnInljLnphY0iCiAKLSM6IHJlbW90ZS5jOjEwMDUKKyM6IHJlbW90ZS5jOjEwMDgKICMsIGMtZm9ybWF0CiBtc2dpZCAic3JjIHJlZnNwZWMgJXMgbWF0Y2hlcyBtb3JlIHRoYW4gb25lIgogbXNnc3RyICLmupDlvJXnlKjooajovr7lvI8gJXMg5Yy56YWN6LaF6L+H5LiA5LiqIgpAQCAtNTMzMyw3ICs1MzY3LDcgQEAKICMuIDxyZW1vdGU+IDxzcmM+Ojxkc3Q+IiBwdXNoLCBhbmQgImJlaW5nIHB1c2hlZCAoJyVzJykiIGlzCiAjLiB0aGUgPHNyYz4uCiAjLgotIzogcmVtb3RlLmM6MTAyMAorIzogcmVtb3RlLmM6MTAyMwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiVGhlIGRlc3RpbmF0aW9uIHlvdSBwcm92aWRlZCBpcyBub3QgYSBmdWxsIHJlZm5hbWUgKGkuZS4sXG4iCkBAIC01MzU1LDcgKzUzODksNyBAQAogIlxuIgogIumDveS4jeihjO+8jOaJgOS7peaIkeS7rOW3suaUvuW8g+OAguaCqOW/hemhu+e7meWHuuWujOaVtOeahOW8leeUqOOAgiIKIAotIzogcmVtb3RlLmM6MTA0MAorIzogcmVtb3RlLmM6MTA0MwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiVGhlIDxzcmM+IHBhcnQgb2YgdGhlIHJlZnNwZWMgaXMgYSBjb21taXQgb2JqZWN0LlxuIgpAQCAtNTM2NSw3ICs1Mzk5LDcgQEAKICLlvJXnlKjooajovr7lvI/nmoQgPHNyYz4g5piv5LiA5Liq5o+Q5Lqk5a+56LGh44CC5oKo5piv5oOz5Yib5bu65LiA5Liq5paw55qE5YiG5pSv6ICM5ZCRXG4iCiAiJyVzOnJlZnMvaGVhZHMvJXMnIOaOqOmAgeS5iO+8nyIKIAotIzogcmVtb3RlLmM6MTA0NQorIzogcmVtb3RlLmM6MTA0OAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiVGhlIDxzcmM+IHBhcnQgb2YgdGhlIHJlZnNwZWMgaXMgYSB0YWcgb2JqZWN0LlxuIgpAQCAtNTM3NSw3ICs1NDA5LDcgQEAKICLlvJXnlKjooajovr7lvI/nmoQgPHNyYz4g5piv5LiA5Liq5qCH562+5a+56LGh44CC5oKo5piv5oOz5Yib5bu65LiA5Liq5paw55qE5qCH562+6ICM5ZCRXG4iCiAiJyVzOnJlZnMvdGFncy8lcycg5o6o6YCB5LmI77yfIgogCi0jOiByZW1vdGUuYzoxMDUwCisjOiByZW1vdGUuYzoxMDUzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgPHNyYz4gcGFydCBvZiB0aGUgcmVmc3BlYyBpcyBhIHRyZWUgb2JqZWN0LlxuIgpAQCAtNTM4NSw3ICs1NDE5LDcgQEAKICLlvJXnlKjooajovr7lvI/nmoQgPHNyYz4g5piv5LiA5Liq5qCR5a+56LGh44CC5oKo5piv5oOz5Li66L+Z5Liq5qCR5a+56LGh5Yib5bu65qCH562+6ICM5ZCRXG4iCiAiJyVzOnJlZnMvdGFncy8lcycg5o6o6YCB5LmI77yfIgogCi0jOiByZW1vdGUuYzoxMDU1CisjOiByZW1vdGUuYzoxMDU4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgPHNyYz4gcGFydCBvZiB0aGUgcmVmc3BlYyBpcyBhIGJsb2Igb2JqZWN0LlxuIgpAQCAtNTM5NSwxMTQgKzU0MjksMTE0IEBACiAi5byV55So6KGo6L6+5byP55qEIDxzcmM+IOaYr+S4gOS4quaVsOaNruWvueixoeOAguaCqOaYr+aDs+S4uui/meS4quaVsOaNruWvueixoeWIm+W7uuagh+etvuiAjOWQkVxuIgogIiclczpyZWZzL3RhZ3MvJXMnIOaOqOmAgeS5iO+8nyIKIAotIzogcmVtb3RlLmM6MTA5MQorIzogcmVtb3RlLmM6MTA5NAogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyBjYW5ub3QgYmUgcmVzb2x2ZWQgdG8gYnJhbmNoIgogbXNnc3RyICIlcyDml6Dms5Xooqvop6PmnpDkuLrliIbmlK8iCiAKLSM6IHJlbW90ZS5jOjExMDIKKyM6IHJlbW90ZS5jOjExMDUKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGRlbGV0ZSAnJXMnOiByZW1vdGUgcmVmIGRvZXMgbm90IGV4aXN0IgogbXNnc3RyICLml6Dms5XliKDpmaQgJyVzJ++8mui/nOeoi+W8leeUqOS4jeWtmOWcqCIKIAotIzogcmVtb3RlLmM6MTExNAorIzogcmVtb3RlLmM6MTExNwogIywgYy1mb3JtYXQKIG1zZ2lkICJkc3QgcmVmc3BlYyAlcyBtYXRjaGVzIG1vcmUgdGhhbiBvbmUiCiBtc2dzdHIgIuebruagh+W8leeUqOihqOi+vuW8jyAlcyDljLnphY3otoXov4fkuIDkuKoiCiAKLSM6IHJlbW90ZS5jOjExMjEKKyM6IHJlbW90ZS5jOjExMjQKICMsIGMtZm9ybWF0CiBtc2dpZCAiZHN0IHJlZiAlcyByZWNlaXZlcyBmcm9tIG1vcmUgdGhhbiBvbmUgc3JjIgogbXNnc3RyICLnm67moIflvJXnlKggJXMg5o6l5pS26LaF6L+H5LiA5Liq5rqQIgogCi0jOiByZW1vdGUuYzoxNjI0IHJlbW90ZS5jOjE3MjUKKyM6IHJlbW90ZS5jOjE2MjcgcmVtb3RlLmM6MTcyOAogbXNnaWQgIkhFQUQgZG9lcyBub3QgcG9pbnQgdG8gYSBicmFuY2giCiBtc2dzdHIgIkhFQUQg5rKh5pyJ5oyH5ZCR5LiA5Liq5YiG5pSvIgogCi0jOiByZW1vdGUuYzoxNjMzCisjOiByZW1vdGUuYzoxNjM2CiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vIHN1Y2ggYnJhbmNoOiAnJXMnIgogbXNnc3RyICLmsqHmnInmraTliIbmlK/vvJonJXMnIgogCi0jOiByZW1vdGUuYzoxNjM2CisjOiByZW1vdGUuYzoxNjM5CiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vIHVwc3RyZWFtIGNvbmZpZ3VyZWQgZm9yIGJyYW5jaCAnJXMnIgogbXNnc3RyICLlsJrmnKrnu5nliIbmlK8gJyVzJyDorr7nva7kuIrmuLgiCiAKLSM6IHJlbW90ZS5jOjE2NDIKKyM6IHJlbW90ZS5jOjE2NDUKICMsIGMtZm9ybWF0CiBtc2dpZCAidXBzdHJlYW0gYnJhbmNoICclcycgbm90IHN0b3JlZCBhcyBhIHJlbW90ZS10cmFja2luZyBicmFuY2giCiBtc2dzdHIgIuS4iua4uOWIhuaUryAnJXMnIOayoeacieWtmOWCqOS4uuS4gOS4qui/nOeoi+i3n+i4quWIhuaUryIKIAotIzogcmVtb3RlLmM6MTY1NworIzogcmVtb3RlLmM6MTY2MAogIywgYy1mb3JtYXQKIG1zZ2lkICJwdXNoIGRlc3RpbmF0aW9uICclcycgb24gcmVtb3RlICclcycgaGFzIG5vIGxvY2FsIHRyYWNraW5nIGJyYW5jaCIKIG1zZ3N0ciAi5o6o6YCB55uu5qCHICclcycg6Iez6L+c56iLICclcycg5rKh5pyJ5pys5Zyw6Lef6Liq5YiG5pSvIgogCi0jOiByZW1vdGUuYzoxNjY5CisjOiByZW1vdGUuYzoxNjcyCiAjLCBjLWZvcm1hdAogbXNnaWQgImJyYW5jaCAnJXMnIGhhcyBubyByZW1vdGUgZm9yIHB1c2hpbmciCiBtc2dzdHIgIuWIhuaUryAnJXMnIOayoeacieiuvue9ruimgeaOqOmAgeeahOi/nOeoi+acjeWKoeWZqCIKIAotIzogcmVtb3RlLmM6MTY3OQorIzogcmVtb3RlLmM6MTY4MgogIywgYy1mb3JtYXQKIG1zZ2lkICJwdXNoIHJlZnNwZWNzIGZvciAnJXMnIGRvIG5vdCBpbmNsdWRlICclcyciCiBtc2dzdHIgIuWQkSAnJXMnIOaOqOmAgeW8leeUqOinhOagvOacquWMheWQqyAnJXMnIgogCi0jOiByZW1vdGUuYzoxNjkyCisjOiByZW1vdGUuYzoxNjk1CiBtc2dpZCAicHVzaCBoYXMgbm8gZGVzdGluYXRpb24gKHB1c2guZGVmYXVsdCBpcyAnbm90aGluZycpIgogbXNnc3RyICLmjqjpgIHml6Dnm67moIfvvIhwdXNoLmRlZmF1bHQg5pivICdub3RoaW5nJ++8iSIKIAotIzogcmVtb3RlLmM6MTcxNAorIzogcmVtb3RlLmM6MTcxNwogbXNnaWQgImNhbm5vdCByZXNvbHZlICdzaW1wbGUnIHB1c2ggdG8gYSBzaW5nbGUgZGVzdGluYXRpb24iCiBtc2dzdHIgIuaXoOazleino+aekCAnc2ltcGxlJyDmjqjpgIHoh7PkuIDkuKrljZXni6znmoTnm67moIciCiAKLSM6IHJlbW90ZS5jOjE4NDAKKyM6IHJlbW90ZS5jOjE4NDMKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGRuJ3QgZmluZCByZW1vdGUgcmVmICVzIgogbXNnc3RyICLml6Dms5Xmib7liLDov5znqIvlvJXnlKggJXMiCiAKLSM6IHJlbW90ZS5jOjE4NTMKKyM6IHJlbW90ZS5jOjE4NTYKICMsIGMtZm9ybWF0CiBtc2dpZCAiKiBJZ25vcmluZyBmdW5ueSByZWYgJyVzJyBsb2NhbGx5IgogbXNnc3RyICIqIOWcqOacrOWcsOW/veeVpeWPr+eskeeahOW8leeUqCAnJXMnIgogCi0jOiByZW1vdGUuYzoyMDE2CisjOiByZW1vdGUuYzoyMDE5CiAjLCBjLWZvcm1hdAogbXNnaWQgIllvdXIgYnJhbmNoIGlzIGJhc2VkIG9uICclcycsIGJ1dCB0aGUgdXBzdHJlYW0gaXMgZ29uZS5cbiIKIG1zZ3N0ciAi5oKo55qE5YiG5pSv5Z+65LqOICclcyfvvIzkvYbmraTkuIrmuLjliIbmlK/lt7Lnu4/kuI3lrZjlnKjjgIJcbiIKIAotIzogcmVtb3RlLmM6MjAyMAorIzogcmVtb3RlLmM6MjAyMwogbXNnaWQgIiAgKHVzZSBcImdpdCBicmFuY2ggLS11bnNldC11cHN0cmVhbVwiIHRvIGZpeHVwKVxuIgogbXNnc3RyICIgIO+8iOS9v+eUqCBcImdpdCBicmFuY2ggLS11bnNldC11cHN0cmVhbVwiIOadpeS/ruWkje+8iVxuIgogCi0jOiByZW1vdGUuYzoyMDIzCisjOiByZW1vdGUuYzoyMDI2CiAjLCBjLWZvcm1hdAogbXNnaWQgIllvdXIgYnJhbmNoIGlzIHVwIHRvIGRhdGUgd2l0aCAnJXMnLlxuIgogbXNnc3RyICLmgqjnmoTliIbmlK/kuI7kuIrmuLjliIbmlK8gJyVzJyDkuIDoh7TjgIJcbiIKIAotIzogcmVtb3RlLmM6MjAyNworIzogcmVtb3RlLmM6MjAzMAogIywgYy1mb3JtYXQKIG1zZ2lkICJZb3VyIGJyYW5jaCBhbmQgJyVzJyByZWZlciB0byBkaWZmZXJlbnQgY29tbWl0cy5cbiIKIG1zZ3N0ciAi5oKo55qE5YiG5pSv5ZKMICclcycg5oyH5ZCR5LiN5ZCM55qE5o+Q5Lqk44CCXG4iCiAKLSM6IHJlbW90ZS5jOjIwMzAKKyM6IHJlbW90ZS5jOjIwMzMKICMsIGMtZm9ybWF0CiBtc2dpZCAiICAodXNlIFwiJXNcIiBmb3IgZGV0YWlscylcbiIKIG1zZ3N0ciAiICDvvIjkvb/nlKggXCIlc1wiIOafpeeci+ivpuaDhe+8iVxuIgogCi0jOiByZW1vdGUuYzoyMDM0CisjOiByZW1vdGUuYzoyMDM3CiAjLCBjLWZvcm1hdAogbXNnaWQgIllvdXIgYnJhbmNoIGlzIGFoZWFkIG9mICclcycgYnkgJWQgY29tbWl0LlxuIgogbXNnaWRfcGx1cmFsICJZb3VyIGJyYW5jaCBpcyBhaGVhZCBvZiAnJXMnIGJ5ICVkIGNvbW1pdHMuXG4iCiBtc2dzdHJbMF0gIuaCqOeahOWIhuaUr+mihuWFiCAnJXMnIOWFsSAlZCDkuKrmj5DkuqTjgIJcbiIKIG1zZ3N0clsxXSAi5oKo55qE5YiG5pSv6aKG5YWIICclcycg5YWxICVkIOS4quaPkOS6pOOAglxuIgogCi0jOiByZW1vdGUuYzoyMDQwCisjOiByZW1vdGUuYzoyMDQzCiBtc2dpZCAiICAodXNlIFwiZ2l0IHB1c2hcIiB0byBwdWJsaXNoIHlvdXIgbG9jYWwgY29tbWl0cylcbiIKIG1zZ3N0ciAiICDvvIjkvb/nlKggXCJnaXQgcHVzaFwiIOadpeWPkeW4g+aCqOeahOacrOWcsOaPkOS6pO+8iVxuIgogCi0jOiByZW1vdGUuYzoyMDQzCisjOiByZW1vdGUuYzoyMDQ2CiAjLCBjLWZvcm1hdAogbXNnaWQgIllvdXIgYnJhbmNoIGlzIGJlaGluZCAnJXMnIGJ5ICVkIGNvbW1pdCwgYW5kIGNhbiBiZSBmYXN0LWZvcndhcmRlZC5cbiIKIG1zZ2lkX3BsdXJhbCAiIgpAQCAtNTUxMSwxMSArNTU0NSwxMSBAQAogbXNnc3RyWzFdICLmgqjnmoTliIbmlK/okL3lkI4gJyVzJyDlhbEgJWQg5Liq5o+Q5Lqk77yM5bm25LiU5Y+v5Lul5b+r6L+b44CCXG4iCiAKICMgIOivkeiAhe+8muazqOaEj+S/neaMgeWJjeWvvOepuuagvAotIzogcmVtb3RlLmM6MjA1MQorIzogcmVtb3RlLmM6MjA1NAogbXNnaWQgIiAgKHVzZSBcImdpdCBwdWxsXCIgdG8gdXBkYXRlIHlvdXIgbG9jYWwgYnJhbmNoKVxuIgogbXNnc3RyICIgIO+8iOS9v+eUqCBcImdpdCBwdWxsXCIg5p2l5pu05paw5oKo55qE5pys5Zyw5YiG5pSv77yJXG4iCiAKLSM6IHJlbW90ZS5jOjIwNTQKKyM6IHJlbW90ZS5jOjIwNTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIllvdXIgYnJhbmNoIGFuZCAnJXMnIGhhdmUgZGl2ZXJnZWQsXG4iCkBAIC01NTMxLDExICs1NTY1LDExIEBACiAi5bm25LiU5YiG5Yir5pyJICVkIOWSjCAlZCDlpITkuI3lkIznmoTmj5DkuqTjgIJcbiIKIAogIyAg6K+R6ICF77ya5rOo5oSP5L+d5oyB5YmN5a+856m65qC8Ci0jOiByZW1vdGUuYzoyMDY0CisjOiByZW1vdGUuYzoyMDY3CiBtc2dpZCAiICAodXNlIFwiZ2l0IHB1bGxcIiB0byBtZXJnZSB0aGUgcmVtb3RlIGJyYW5jaCBpbnRvIHlvdXJzKVxuIgogbXNnc3RyICIgIO+8iOS9v+eUqCBcImdpdCBwdWxsXCIg5p2l5ZCI5bm26L+c56iL5YiG5pSv77yJXG4iCiAKLSM6IHJlbW90ZS5jOjIyNDcKKyM6IHJlbW90ZS5jOjIyNTAKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IHBhcnNlIGV4cGVjdGVkIG9iamVjdCBuYW1lICclcyciCiBtc2dzdHIgIuaXoOazleino+aekOacn+acm+eahOWvueixoeWQjSAnJXMnIgpAQCAtNTYxMyw3ICs1NjQ3LDcgQEAKIG1zZ2lkICJSZWNvcmRlZCBwcmVpbWFnZSBmb3IgJyVzJyIKIG1zZ3N0ciAi5Li6ICclcycg6K6w5b2VIHByZWltYWdlIgogCi0jOiByZXJlcmUuYzo4ODEgc3VibW9kdWxlLmM6MjAyMyBidWlsdGluL2xvZy5jOjE3NzMKKyM6IHJlcmVyZS5jOjg4MSBzdWJtb2R1bGUuYzoyMDIzIGJ1aWx0aW4vbG9nLmM6MTc5MAogIzogYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjE0MTggYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjE0MjgKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGNyZWF0ZSBkaXJlY3RvcnkgJyVzJyIKQEAgLTU2NDgsMjAgKzU2ODIsMjAgQEAKIG1zZ2lkICJ1bmFibGUgdG8gb3BlbiByci1jYWNoZSBkaXJlY3RvcnkiCiBtc2dzdHIgIuS4jeiDveaJk+W8gCByci1jYWNoZSDnm67lvZUiCiAKLSM6IHJldmlzaW9uLmM6MjUwNworIzogcmV2aXNpb24uYzoyNTA5CiBtc2dpZCAieW91ciBjdXJyZW50IGJyYW5jaCBhcHBlYXJzIHRvIGJlIGJyb2tlbiIKIG1zZ3N0ciAi5oKo55qE5b2T5YmN5YiG5pSv5aW95YOP6KKr5o2f5Z2PIgogCi0jOiByZXZpc2lvbi5jOjI1MTAKKyM6IHJldmlzaW9uLmM6MjUxMgogIywgYy1mb3JtYXQKIG1zZ2lkICJ5b3VyIGN1cnJlbnQgYnJhbmNoICclcycgZG9lcyBub3QgaGF2ZSBhbnkgY29tbWl0cyB5ZXQiCiBtc2dzdHIgIuaCqOeahOW9k+WJjeWIhuaUryAnJXMnIOWwmuaXoOS7u+S9leaPkOS6pCIKIAotIzogcmV2aXNpb24uYzoyNzEwCisjOiByZXZpc2lvbi5jOjI3MjAKIG1zZ2lkICItLWZpcnN0LXBhcmVudCBpcyBpbmNvbXBhdGlibGUgd2l0aCAtLWJpc2VjdCIKIG1zZ3N0ciAiLS1maXJzdC1wYXJlbnQg5LiOIC0tYmlzZWN0IOS4jeWFvOWuuSIKIAotIzogcmV2aXNpb24uYzoyNzE0CisjOiByZXZpc2lvbi5jOjI3MjQKIG1zZ2lkICItTCBkb2VzIG5vdCB5ZXQgc3VwcG9ydCBkaWZmIGZvcm1hdHMgYmVzaWRlcyAtcCBhbmQgLXMiCiBtc2dzdHIgIi1MIOWwmuS4jeaUr+aMgSAtcCDlkowgLXMg5LmL5aSW55qE5beu5byC5qC85byPIgogCkBAIC01NjgzLDM5ICs1NzE3LDM5IEBACiAi5Zug5Li65rKh5pyJ5bCG6ZKp5a2QICclcycg6K6+572u5Li65Y+v5omn6KGM77yM6ZKp5a2Q6KKr5b+955Wl44CC5oKo5Y+v5Lul6YCa6L+HXG4iCiAi6YWN572uIGBnaXQgY29uZmlnIGFkdmljZS5pZ25vcmVkSG9vayBmYWxzZWAg5p2l5YWz6Zet6L+Z5p2h6K2m5ZGK44CCIgogCi0jOiBzZW5kLXBhY2suYzoxNDEKKyM6IHNlbmQtcGFjay5jOjE0MgogbXNnaWQgInVuZXhwZWN0ZWQgZmx1c2ggcGFja2V0IHdoaWxlIHJlYWRpbmcgcmVtb3RlIHVucGFjayBzdGF0dXMiCiBtc2dzdHIgIuivu+WPlui/nOeoi+ino+WMheeKtuaAgeaXtuaUtuWIsOaEj+WklueahCBmbHVzaCDljIUiCiAKLSM6IHNlbmQtcGFjay5jOjE0MworIzogc2VuZC1wYWNrLmM6MTQ0CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBwYXJzZSByZW1vdGUgdW5wYWNrIHN0YXR1czogJXMiCiBtc2dzdHIgIuS4jeiDveino+aekOi/nOeoi+ino+WMheeKtuaAge+8miVzIgogCi0jOiBzZW5kLXBhY2suYzoxNDUKKyM6IHNlbmQtcGFjay5jOjE0NgogIywgYy1mb3JtYXQKIG1zZ2lkICJyZW1vdGUgdW5wYWNrIGZhaWxlZDogJXMiCiBtc2dzdHIgIui/nOeoi+ino+WMheWksei0pe+8miVzIgogCi0jOiBzZW5kLXBhY2suYzozMDYKKyM6IHNlbmQtcGFjay5jOjMwNwogbXNnaWQgImZhaWxlZCB0byBzaWduIHRoZSBwdXNoIGNlcnRpZmljYXRlIgogbXNnc3RyICLkuLrmjqjpgIHor4Hkuabnrb7lkI3lpLHotKUiCiAKLSM6IHNlbmQtcGFjay5jOjQyMAorIzogc2VuZC1wYWNrLmM6NDIxCiBtc2dpZCAidGhlIHJlY2VpdmluZyBlbmQgZG9lcyBub3Qgc3VwcG9ydCAtLXNpZ25lZCBwdXNoIgogbXNnc3RyICLmjqXmlLbnq6/kuI3mlK/mjIHnrb7lkI3mjqjpgIEiCiAKLSM6IHNlbmQtcGFjay5jOjQyMgorIzogc2VuZC1wYWNrLmM6NDIzCiBtc2dpZCAiIgogIm5vdCBzZW5kaW5nIGEgcHVzaCBjZXJ0aWZpY2F0ZSBzaW5jZSB0aGUgcmVjZWl2aW5nIGVuZCBkb2VzIG5vdCBzdXBwb3J0IC0tIgogInNpZ25lZCBwdXNoIgogbXNnc3RyICLmnKrlj5HpgIHmjqjpgIHor4HkuabvvIzlm6DkuLrmjqXmlLbnq6/kuI3mlK/mjIHnrb7lkI3mjqjpgIEiCiAKLSM6IHNlbmQtcGFjay5jOjQzNAorIzogc2VuZC1wYWNrLmM6NDM1CiBtc2dpZCAidGhlIHJlY2VpdmluZyBlbmQgZG9lcyBub3Qgc3VwcG9ydCAtLWF0b21pYyBwdXNoIgogbXNnc3RyICLmjqXmlLbnq6/kuI3mlK/mjIHljp/lrZDmjqjpgIEiCiAKLSM6IHNlbmQtcGFjay5jOjQzOQorIzogc2VuZC1wYWNrLmM6NDQwCiBtc2dpZCAidGhlIHJlY2VpdmluZyBlbmQgZG9lcyBub3Qgc3VwcG9ydCBwdXNoIG9wdGlvbnMiCiBtc2dzdHIgIuaOpeaUtuerr+S4jeaUr+aMgeaOqOmAgemAiemhuSIKIApAQCAtNTcyOSw3ICs1NzYzLDcgQEAKIG1zZ2lkICJjb3VsZCBub3QgZGVsZXRlICclcyciCiBtc2dzdHIgIuaXoOazleWIoOmZpCAnJXMnIgogCi0jOiBzZXF1ZW5jZXIuYzozMTEgYnVpbHRpbi9yZWJhc2UuYzo3NTkgYnVpbHRpbi9yZWJhc2UuYzoxNjQ1IGJ1aWx0aW4vcm0uYzozNjkKKyM6IHNlcXVlbmNlci5jOjMxMSBidWlsdGluL3JlYmFzZS5jOjc2MCBidWlsdGluL3JlYmFzZS5jOjE2NzYgYnVpbHRpbi9ybS5jOjM2OQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcmVtb3ZlICclcyciCiBtc2dzdHIgIuaXoOazleWIoOmZpCAnJXMnIgpAQCAtNTc2OCw3ICs1ODAyLDcgQEAKICLlhrLnqoHop6PlhrPlrozmr5XlkI7vvIznlKggJ2dpdCBhZGQgPOi3r+W+hD4nIOaIliAnZ2l0IHJtIDzot6/lvoQ+J1xuIgogIuWvueS/ruato+WQjueahOaWh+S7tuWBmuagh+iusO+8jOeEtuWQjueUqCAnZ2l0IGNvbW1pdCcg5o+Q5LqkIgogCi0jOiBzZXF1ZW5jZXIuYzo0MDEgc2VxdWVuY2VyLmM6MjkwOQorIzogc2VxdWVuY2VyLmM6NDAxIHNlcXVlbmNlci5jOjI4NDcKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGxvY2sgJyVzJyIKIG1zZ3N0ciAi5LiN6IO96ZSB5a6aICclcyciCkBAIC01Nzc4LDE1ICs1ODEyLDE1IEBACiBtc2dpZCAiY291bGQgbm90IHdyaXRlIGVvbCB0byAnJXMnIgogbXNnc3RyICLkuI3og73lsIbmjaLooYznrKblhpnlhaUgJyVzJyIKIAotIzogc2VxdWVuY2VyLmM6NDEzIHNlcXVlbmNlci5jOjI3MTQgc2VxdWVuY2VyLmM6MjkxNSBzZXF1ZW5jZXIuYzoyOTI5Ci0jOiBzZXF1ZW5jZXIuYzozMTkyCisjOiBzZXF1ZW5jZXIuYzo0MTMgc2VxdWVuY2VyLmM6MjY1MiBzZXF1ZW5jZXIuYzoyODUzIHNlcXVlbmNlci5jOjI4NjcKKyM6IHNlcXVlbmNlci5jOjMxMzAKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIGZpbmFsaXplICclcyciCiBtc2dzdHIgIuaXoOazleWujOaIkCAnJXMnIgogCi0jOiBzZXF1ZW5jZXIuYzo0MzYgc2VxdWVuY2VyLmM6OTgxIHNlcXVlbmNlci5jOjE2NTUgc2VxdWVuY2VyLmM6MjczNAotIzogc2VxdWVuY2VyLmM6MzE3NCBzZXF1ZW5jZXIuYzozMjgzIGJ1aWx0aW4vYW0uYzoyNDUgYnVpbHRpbi9jb21taXQuYzo3NjMKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxMTEyIGJ1aWx0aW4vcmViYXNlLmM6NTY3CisjOiBzZXF1ZW5jZXIuYzo0MzYgc2VxdWVuY2VyLmM6MTU4NSBzZXF1ZW5jZXIuYzoyNjcyIHNlcXVlbmNlci5jOjMxMTIKKyM6IHNlcXVlbmNlci5jOjMyMjEgYnVpbHRpbi9hbS5jOjI0NCBidWlsdGluL2NvbW1pdC5jOjc2MyBidWlsdGluL21lcmdlLmM6MTExNworIzogYnVpbHRpbi9yZWJhc2UuYzo1NjgKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHJlYWQgJyVzJyIKIG1zZ3N0ciAi5LiN6IO96K+75Y+WICclcyciCkBAIC01ODEzLDcwICs1ODQ3LDY1IEBACiAjLiBUUkFOU0xBVE9SUzogJXMgd2lsbCBiZSAicmV2ZXJ0IiwgImNoZXJyeS1waWNrIiBvcgogIy4gInJlYmFzZSAtaSIuCiAjLgotIzogc2VxdWVuY2VyLmM6NjMyCisjOiBzZXF1ZW5jZXIuYzo2MzEKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXM6IFVuYWJsZSB0byB3cml0ZSBuZXcgaW5kZXggZmlsZSIKIG1zZ3N0ciAiJXPvvJrml6Dms5XlhpnlhaXmlrDntKLlvJXmlofku7YiCiAKLSM6IHNlcXVlbmNlci5jOjY0OQorIzogc2VxdWVuY2VyLmM6NjQ4CiBtc2dpZCAidW5hYmxlIHRvIHVwZGF0ZSBjYWNoZSB0cmVlIgogbXNnc3RyICLkuI3og73mm7TmlrDnvJPlrZjmoJEiCiAKLSM6IHNlcXVlbmNlci5jOjY2MworIzogc2VxdWVuY2VyLmM6NjYyCiBtc2dpZCAiY291bGQgbm90IHJlc29sdmUgSEVBRCBjb21taXQiCiBtc2dzdHIgIuS4jeiDveino+aekCBIRUFEIOaPkOS6pCIKIAotIzogc2VxdWVuY2VyLmM6NzQzCisjOiBzZXF1ZW5jZXIuYzo3NDIKICMsIGMtZm9ybWF0CiBtc2dpZCAibm8ga2V5IHByZXNlbnQgaW4gJyUuKnMnIgogbXNnc3RyICLlnKggJyUuKnMnIOS4reayoeaciSBrZXkiCiAKLSM6IHNlcXVlbmNlci5jOjc1NAorIzogc2VxdWVuY2VyLmM6NzUzCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBkZXF1b3RlIHZhbHVlIG9mICclcyciCiBtc2dzdHIgIuaXoOazleS4uiAnJXMnIOeahOWAvOWOu+W8leWPtyIKIAotIzogc2VxdWVuY2VyLmM6NzkxIHdyYXBwZXIuYzoyMjcgd3JhcHBlci5jOjM5NyBidWlsdGluL2FtLmM6NzA2Ci0jOiBidWlsdGluL2FtLmM6Nzk4IGJ1aWx0aW4vbWVyZ2UuYzoxMTA5IGJ1aWx0aW4vcmViYXNlLmM6MTA0NQorIzogc2VxdWVuY2VyLmM6NzkwIHdyYXBwZXIuYzoxOTAgd3JhcHBlci5jOjM2MCBidWlsdGluL2FtLmM6NzA1CisjOiBidWlsdGluL2FtLmM6Nzk3IGJ1aWx0aW4vbWVyZ2UuYzoxMTE0IGJ1aWx0aW4vcmViYXNlLmM6MTA0NgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3Qgb3BlbiAnJXMnIGZvciByZWFkaW5nIgogbXNnc3RyICLml6Dms5XmiZPlvIAgJyVzJyDov5vooYzor7vlj5YiCiAKLSM6IHNlcXVlbmNlci5jOjgwMQorIzogc2VxdWVuY2VyLmM6ODAwCiBtc2dpZCAiJ0dJVF9BVVRIT1JfTkFNRScgYWxyZWFkeSBnaXZlbiIKIG1zZ3N0ciAi5bey57uP57uZ5Ye6ICdHSVRfQVVUSE9SX05BTUUnIgogCi0jOiBzZXF1ZW5jZXIuYzo4MDYKKyM6IHNlcXVlbmNlci5jOjgwNQogbXNnaWQgIidHSVRfQVVUSE9SX0VNQUlMJyBhbHJlYWR5IGdpdmVuIgogbXNnc3RyICLlt7Lnu4/nu5nlh7ogJ0dJVF9BVVRIT1JfRU1BSUwnIgogCi0jOiBzZXF1ZW5jZXIuYzo4MTEKKyM6IHNlcXVlbmNlci5jOjgxMAogbXNnaWQgIidHSVRfQVVUSE9SX0RBVEUnIGFscmVhZHkgZ2l2ZW4iCiBtc2dzdHIgIuW3sue7j+e7meWHuiAnR0lUX0FVVEhPUl9EQVRFJyIKIAotIzogc2VxdWVuY2VyLmM6ODE1CisjOiBzZXF1ZW5jZXIuYzo4MTQKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5rbm93biB2YXJpYWJsZSAnJXMnIgogbXNnc3RyICLmnKrnn6Xlj5jph48gJyVzJyIKIAotIzogc2VxdWVuY2VyLmM6ODIwCisjOiBzZXF1ZW5jZXIuYzo4MTkKIG1zZ2lkICJtaXNzaW5nICdHSVRfQVVUSE9SX05BTUUnIgogbXNnc3RyICLnvLrlsJEgJ0dJVF9BVVRIT1JfTkFNRSciCiAKLSM6IHNlcXVlbmNlci5jOjgyMgorIzogc2VxdWVuY2VyLmM6ODIxCiBtc2dpZCAibWlzc2luZyAnR0lUX0FVVEhPUl9FTUFJTCciCiBtc2dzdHIgIue8uuWwkSAnR0lUX0FVVEhPUl9FTUFJTCciCiAKLSM6IHNlcXVlbmNlci5jOjgyNAorIzogc2VxdWVuY2VyLmM6ODIzCiBtc2dpZCAibWlzc2luZyAnR0lUX0FVVEhPUl9EQVRFJyIKIG1zZ3N0ciAi57y65bCRICdHSVRfQVVUSE9SX0RBVEUnIgogCi0jOiBzZXF1ZW5jZXIuYzo4ODQKLSMsIGMtZm9ybWF0Ci1tc2dpZCAiaW52YWxpZCBkYXRlIGZvcm1hdCAnJXMnIGluICclcyciCi1tc2dzdHIgIiclMiRzJyDkuK3ml6DmlYjnmoTml6XmnJ/moLzlvI8gJyUxJHMnIgotCi0jOiBzZXF1ZW5jZXIuYzo5MDEKKyM6IHNlcXVlbmNlci5jOjg3MgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAieW91IGhhdmUgc3RhZ2VkIGNoYW5nZXMgaW4geW91ciB3b3JraW5nIHRyZWVcbiIKQEAgLTU5MDUsMTUgKzU5MzQsMTEgQEAKICJcbiIKICIgIGdpdCByZWJhc2UgLS1jb250aW51ZVxuIgogCi0jOiBzZXF1ZW5jZXIuYzo5OTUKLW1zZ2lkICJ3cml0aW5nIHJvb3QgY29tbWl0IgotbXNnc3RyICLlhpnmoLnmj5DkuqQiCi0KLSM6IHNlcXVlbmNlci5jOjEyMTYKKyM6IHNlcXVlbmNlci5jOjExNDYKIG1zZ2lkICIncHJlcGFyZS1jb21taXQtbXNnJyBob29rIGZhaWxlZCIKIG1zZ3N0ciAiJ3ByZXBhcmUtY29tbWl0LW1zZycg6ZKp5a2Q5aSx6LSlIgogCi0jOiBzZXF1ZW5jZXIuYzoxMjIzCisjOiBzZXF1ZW5jZXIuYzoxMTUzCiBtc2dpZCAiIgogIllvdXIgbmFtZSBhbmQgZW1haWwgYWRkcmVzcyB3ZXJlIGNvbmZpZ3VyZWQgYXV0b21hdGljYWxseSBiYXNlZFxuIgogIm9uIHlvdXIgdXNlcm5hbWUgYW5kIGhvc3RuYW1lLiBQbGVhc2UgY2hlY2sgdGhhdCB0aGV5IGFyZSBhY2N1cmF0ZS5cbiIKQEAgLTU5MzcsNyArNTk2Miw3IEBACiAiXG4iCiAiICAgIGdpdCBjb21taXQgLS1hbWVuZCAtLXJlc2V0LWF1dGhvclxuIgogCi0jOiBzZXF1ZW5jZXIuYzoxMjM2CisjOiBzZXF1ZW5jZXIuYzoxMTY2CiBtc2dpZCAiIgogIllvdXIgbmFtZSBhbmQgZW1haWwgYWRkcmVzcyB3ZXJlIGNvbmZpZ3VyZWQgYXV0b21hdGljYWxseSBiYXNlZFxuIgogIm9uIHlvdXIgdXNlcm5hbWUgYW5kIGhvc3RuYW1lLiBQbGVhc2UgY2hlY2sgdGhhdCB0aGV5IGFyZSBhY2N1cmF0ZS5cbiIKQEAgLTU5NjAsMzI2ICs1OTg1LDMyNiBAQAogIlxuIgogIiAgICBnaXQgY29tbWl0IC0tYW1lbmQgLS1yZXNldC1hdXRob3JcbiIKIAotIzogc2VxdWVuY2VyLmM6MTI3OAorIzogc2VxdWVuY2VyLmM6MTIwOAogbXNnaWQgImNvdWxkbid0IGxvb2sgdXAgbmV3bHkgY3JlYXRlZCBjb21taXQiCiBtc2dzdHIgIuaXoOazleaJvuWIsOaWsOWIm+W7uueahOaPkOS6pCIKIAotIzogc2VxdWVuY2VyLmM6MTI4MAorIzogc2VxdWVuY2VyLmM6MTIxMAogbXNnaWQgImNvdWxkIG5vdCBwYXJzZSBuZXdseSBjcmVhdGVkIGNvbW1pdCIKIG1zZ3N0ciAi5LiN6IO96Kej5p6Q5paw5Yib5bu655qE5o+Q5LqkIgogCi0jOiBzZXF1ZW5jZXIuYzoxMzI2CisjOiBzZXF1ZW5jZXIuYzoxMjU2CiBtc2dpZCAidW5hYmxlIHRvIHJlc29sdmUgSEVBRCBhZnRlciBjcmVhdGluZyBjb21taXQiCiBtc2dzdHIgIuWIm+W7uuaPkOS6pOWQju+8jOS4jeiDveino+aekCBIRUFEIgogCi0jOiBzZXF1ZW5jZXIuYzoxMzI4CisjOiBzZXF1ZW5jZXIuYzoxMjU4CiBtc2dpZCAiZGV0YWNoZWQgSEVBRCIKIG1zZ3N0ciAi5YiG56a75aS05oyH6ZKIIgogCiAjICDor5HogIXvvJrkuK3mloflrZfnrKbkuLLmi7zmjqXvvIzlj6/liKDpmaTliY3lr7znqbrmoLwKLSM6IHNlcXVlbmNlci5jOjEzMzIKKyM6IHNlcXVlbmNlci5jOjEyNjIKIG1zZ2lkICIgKHJvb3QtY29tbWl0KSIKIG1zZ3N0ciAi77yI5qC55o+Q5Lqk77yJIgogCi0jOiBzZXF1ZW5jZXIuYzoxMzUzCisjOiBzZXF1ZW5jZXIuYzoxMjgzCiBtc2dpZCAiY291bGQgbm90IHBhcnNlIEhFQUQiCiBtc2dzdHIgIuS4jeiDveino+aekCBIRUFEIgogCi0jOiBzZXF1ZW5jZXIuYzoxMzU1CisjOiBzZXF1ZW5jZXIuYzoxMjg1CiAjLCBjLWZvcm1hdAogbXNnaWQgIkhFQUQgJXMgaXMgbm90IGEgY29tbWl0ISIKIG1zZ3N0ciAiSEVBRCAlcyDkuI3mmK/kuIDkuKrmj5DkuqTvvIEiCiAKLSM6IHNlcXVlbmNlci5jOjEzNTkgYnVpbHRpbi9jb21taXQuYzoxNTcxCisjOiBzZXF1ZW5jZXIuYzoxMjg5IGJ1aWx0aW4vY29tbWl0LmM6MTU3MQogbXNnaWQgImNvdWxkIG5vdCBwYXJzZSBIRUFEIGNvbW1pdCIKIG1zZ3N0ciAi5LiN6IO96Kej5p6QIEhFQUQg5o+Q5LqkIgogCi0jOiBzZXF1ZW5jZXIuYzoxNDExIHNlcXVlbmNlci5jOjIwMDQKKyM6IHNlcXVlbmNlci5jOjEzNDEgc2VxdWVuY2VyLmM6MTkzMwogbXNnaWQgInVuYWJsZSB0byBwYXJzZSBjb21taXQgYXV0aG9yIgogbXNnc3RyICLkuI3og73op6PmnpDmj5DkuqTkvZzogIUiCiAKLSM6IHNlcXVlbmNlci5jOjE0MjEgYnVpbHRpbi9hbS5jOjE1NzMgYnVpbHRpbi9tZXJnZS5jOjY4NAorIzogc2VxdWVuY2VyLmM6MTM1MiBidWlsdGluL2FtLmM6MTU2MSBidWlsdGluL21lcmdlLmM6Njg0CiBtc2dpZCAiZ2l0IHdyaXRlLXRyZWUgZmFpbGVkIHRvIHdyaXRlIGEgdHJlZSIKIG1zZ3N0ciAiZ2l0IHdyaXRlLXRyZWUg5peg5rOV5YaZ5YWl5qCR5a+56LGhIgogCi0jOiBzZXF1ZW5jZXIuYzoxNDM4IHNlcXVlbmNlci5jOjE0OTkKKyM6IHNlcXVlbmNlci5jOjEzNjkgc2VxdWVuY2VyLmM6MTQyOQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gcmVhZCBjb21taXQgbWVzc2FnZSBmcm9tICclcyciCiBtc2dzdHIgIuS4jeiDveS7jiAnJXMnIOivu+WPluaPkOS6pOivtOaYjiIKIAotIzogc2VxdWVuY2VyLmM6MTQ2NSBidWlsdGluL2FtLmM6MTU5NSBidWlsdGluL2NvbW1pdC5jOjE2NzAgYnVpbHRpbi9tZXJnZS5jOjg3OAotIzogYnVpbHRpbi9tZXJnZS5jOjkwMworIzogc2VxdWVuY2VyLmM6MTM5NiBidWlsdGluL2FtLmM6MTU4MyBidWlsdGluL2NvbW1pdC5jOjE2NzAgYnVpbHRpbi9tZXJnZS5jOjg4MworIzogYnVpbHRpbi9tZXJnZS5jOjkwOAogbXNnaWQgImZhaWxlZCB0byB3cml0ZSBjb21taXQgb2JqZWN0IgogbXNnc3RyICLlhpnmj5DkuqTlr7nosaHlpLHotKUiCiAKLSM6IHNlcXVlbmNlci5jOjE1MjYKKyM6IHNlcXVlbmNlci5jOjE0NTYKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHBhcnNlIGNvbW1pdCAlcyIKIG1zZ3N0ciAi5LiN6IO96Kej5p6Q5o+Q5LqkICVzIgogCi0jOiBzZXF1ZW5jZXIuYzoxNTMxCisjOiBzZXF1ZW5jZXIuYzoxNDYxCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBwYXJzZSBwYXJlbnQgY29tbWl0ICVzIgogbXNnc3RyICLkuI3og73op6PmnpDniLbmj5DkuqQgJXMiCiAKLSM6IHNlcXVlbmNlci5jOjE2MDUgc2VxdWVuY2VyLmM6MTcxNQorIzogc2VxdWVuY2VyLmM6MTUzNSBzZXF1ZW5jZXIuYzoxNjQ1CiAjLCBjLWZvcm1hdAogbXNnaWQgInVua25vd24gY29tbWFuZDogJWQiCiBtc2dzdHIgIuacquefpeWRveS7pO+8miVkIgogCi0jOiBzZXF1ZW5jZXIuYzoxNjYyIHNlcXVlbmNlci5jOjE2ODcKKyM6IHNlcXVlbmNlci5jOjE1OTIgc2VxdWVuY2VyLmM6MTYxNwogIywgYy1mb3JtYXQKIG1zZ2lkICJUaGlzIGlzIGEgY29tYmluYXRpb24gb2YgJWQgY29tbWl0cy4iCiBtc2dzdHIgIui/meaYr+S4gOS4qiAlZCDkuKrmj5DkuqTnmoTnu4TlkIjjgIIiCiAKLSM6IHNlcXVlbmNlci5jOjE2NzIKKyM6IHNlcXVlbmNlci5jOjE2MDIKIG1zZ2lkICJuZWVkIGEgSEVBRCB0byBmaXh1cCIKIG1zZ3N0ciAi6ZyA6KaB5LiA5LiqIEhFQUQg5p2l5L+u5aSNIgogCi0jOiBzZXF1ZW5jZXIuYzoxNjc0IHNlcXVlbmNlci5jOjMyMTkKKyM6IHNlcXVlbmNlci5jOjE2MDQgc2VxdWVuY2VyLmM6MzE1NwogbXNnaWQgImNvdWxkIG5vdCByZWFkIEhFQUQiCiBtc2dzdHIgIuS4jeiDveivu+WPliBIRUFEIgogCi0jOiBzZXF1ZW5jZXIuYzoxNjc2CisjOiBzZXF1ZW5jZXIuYzoxNjA2CiBtc2dpZCAiY291bGQgbm90IHJlYWQgSEVBRCdzIGNvbW1pdCBtZXNzYWdlIgogbXNnc3RyICLkuI3og73or7vlj5YgSEVBRCDnmoTmj5DkuqTor7TmmI4iCiAKLSM6IHNlcXVlbmNlci5jOjE2ODIKKyM6IHNlcXVlbmNlci5jOjE2MTIKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IHdyaXRlICclcyciCiBtc2dzdHIgIuS4jeiDveWGmSAnJXMnIgogCi0jOiBzZXF1ZW5jZXIuYzoxNjg5IGdpdC1yZWJhc2UtLXByZXNlcnZlLW1lcmdlcy5zaDo0OTYKKyM6IHNlcXVlbmNlci5jOjE2MTkgZ2l0LXJlYmFzZS0tcHJlc2VydmUtbWVyZ2VzLnNoOjQ5NgogbXNnaWQgIlRoaXMgaXMgdGhlIDFzdCBjb21taXQgbWVzc2FnZToiCiBtc2dzdHIgIui/meaYr+esrOS4gOS4quaPkOS6pOivtOaYju+8miIKIAotIzogc2VxdWVuY2VyLmM6MTY5NworIzogc2VxdWVuY2VyLmM6MTYyNwogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcmVhZCBjb21taXQgbWVzc2FnZSBvZiAlcyIKIG1zZ3N0ciAi5LiN6IO96K+75Y+WICVzIOeahOaPkOS6pOivtOaYjiIKIAotIzogc2VxdWVuY2VyLmM6MTcwNAorIzogc2VxdWVuY2VyLmM6MTYzNAogIywgYy1mb3JtYXQKIG1zZ2lkICJUaGlzIGlzIHRoZSBjb21taXQgbWVzc2FnZSAjJWQ6IgogbXNnc3RyICLov5nmmK/mj5DkuqTor7TmmI4gIyVk77yaIgogCi0jOiBzZXF1ZW5jZXIuYzoxNzEwCisjOiBzZXF1ZW5jZXIuYzoxNjQwCiAjLCBjLWZvcm1hdAogbXNnaWQgIlRoZSBjb21taXQgbWVzc2FnZSAjJWQgd2lsbCBiZSBza2lwcGVkOiIKIG1zZ3N0ciAi5o+Q5Lqk6K+05piOICMlZCDlsIbooqvot7Pov4fvvJoiCiAKLSM6IHNlcXVlbmNlci5jOjE3OTgKKyM6IHNlcXVlbmNlci5jOjE3MjgKIG1zZ2lkICJ5b3VyIGluZGV4IGZpbGUgaXMgdW5tZXJnZWQuIgogbXNnc3RyICLmgqjnmoTntKLlvJXmlofku7bmnKrlrozmiJDlkIjlubbjgIIiCiAKLSM6IHNlcXVlbmNlci5jOjE4MDUKKyM6IHNlcXVlbmNlci5jOjE3MzUKIG1zZ2lkICJjYW5ub3QgZml4dXAgcm9vdCBjb21taXQiCiBtc2dzdHIgIuS4jeiDveS/ruWkjeagueaPkOS6pCIKIAotIzogc2VxdWVuY2VyLmM6MTgyNAorIzogc2VxdWVuY2VyLmM6MTc1NAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb21taXQgJXMgaXMgYSBtZXJnZSBidXQgbm8gLW0gb3B0aW9uIHdhcyBnaXZlbi4iCiBtc2dzdHIgIuaPkOS6pCAlcyDmmK/kuIDkuKrlkIjlubbmj5DkuqTkvYbmnKrmj5DkvpsgLW0g6YCJ6aG544CCIgogCi0jOiBzZXF1ZW5jZXIuYzoxODMyIHNlcXVlbmNlci5jOjE4NDAKKyM6IHNlcXVlbmNlci5jOjE3NjIgc2VxdWVuY2VyLmM6MTc3MAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb21taXQgJXMgZG9lcyBub3QgaGF2ZSBwYXJlbnQgJWQiCiBtc2dzdHIgIuaPkOS6pCAlcyDmsqHmnInnrKwgJWQg5Liq54i25o+Q5LqkIgogCi0jOiBzZXF1ZW5jZXIuYzoxODQ2CisjOiBzZXF1ZW5jZXIuYzoxNzc2CiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCBnZXQgY29tbWl0IG1lc3NhZ2UgZm9yICVzIgogbXNnc3RyICLkuI3og73lvpfliLAgJXMg55qE5o+Q5Lqk6K+05piOIgogCiAjLiBUUkFOU0xBVE9SUzogVGhlIGZpcnN0ICVzIHdpbGwgYmUgYSAidG9kbyIgY29tbWFuZCBsaWtlCiAjLiAicmV2ZXJ0IiBvciAicGljayIsIHRoZSBzZWNvbmQgJXMgYSBTSEExLgotIzogc2VxdWVuY2VyLmM6MTg2NQorIzogc2VxdWVuY2VyLmM6MTc5NQogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogY2Fubm90IHBhcnNlIHBhcmVudCBjb21taXQgJXMiCiBtc2dzdHIgIiVz77ya5LiN6IO96Kej5p6Q54i25o+Q5LqkICVzIgogCi0jOiBzZXF1ZW5jZXIuYzoxOTMwCisjOiBzZXF1ZW5jZXIuYzoxODYwCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCByZW5hbWUgJyVzJyB0byAnJXMnIgogbXNnc3RyICLkuI3og73lsIYgJyVzJyDph43lkb3lkI3kuLogJyVzJyIKIAotIzogc2VxdWVuY2VyLmM6MTk4NQorIzogc2VxdWVuY2VyLmM6MTkxNQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcmV2ZXJ0ICVzLi4uICVzIgogbXNnc3RyICLkuI3og73ov5jljp8gJXMuLi4gJXMiCiAKLSM6IHNlcXVlbmNlci5jOjE5ODYKKyM6IHNlcXVlbmNlci5jOjE5MTYKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGFwcGx5ICVzLi4uICVzIgogbXNnc3RyICLkuI3og73lupTnlKggJXMuLi4gJXMiCiAKLSM6IHNlcXVlbmNlci5jOjIwNDUKKyM6IHNlcXVlbmNlci5jOjE5ODMKICMsIGMtZm9ybWF0CiBtc2dpZCAiZ2l0ICVzOiBmYWlsZWQgdG8gcmVhZCB0aGUgaW5kZXgiCiBtc2dzdHIgImdpdCAlc++8muaXoOazleivu+WPlue0ouW8lSIKIAotIzogc2VxdWVuY2VyLmM6MjA1MgorIzogc2VxdWVuY2VyLmM6MTk5MAogIywgYy1mb3JtYXQKIG1zZ2lkICJnaXQgJXM6IGZhaWxlZCB0byByZWZyZXNoIHRoZSBpbmRleCIKIG1zZ3N0ciAiZ2l0ICVz77ya5peg5rOV5Yi35paw57Si5byVIgogCi0jOiBzZXF1ZW5jZXIuYzoyMTI4CisjOiBzZXF1ZW5jZXIuYzoyMDY2CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIGRvZXMgbm90IGFjY2VwdCBhcmd1bWVudHM6ICclcyciCiBtc2dzdHIgIiVzIOS4jeaOpeWPl+WPguaVsO+8miclcyciCiAKLSM6IHNlcXVlbmNlci5jOjIxMzcKKyM6IHNlcXVlbmNlci5jOjIwNzUKICMsIGMtZm9ybWF0CiBtc2dpZCAibWlzc2luZyBhcmd1bWVudHMgZm9yICVzIgogbXNnc3RyICLnvLrlsJEgJXMg55qE5Y+C5pWwIgogCi0jOiBzZXF1ZW5jZXIuYzoyMTc0CisjOiBzZXF1ZW5jZXIuYzoyMTEyCiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBwYXJzZSAnJS4qcyciCiBtc2dzdHIgIuaXoOazleino+aekCAnJS4qcyciCiAKLSM6IHNlcXVlbmNlci5jOjIyMjgKKyM6IHNlcXVlbmNlci5jOjIxNjYKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBsaW5lICVkOiAlLipzIgogbXNnc3RyICLml6DmlYjooYwgJWTvvJolLipzIgogCi0jOiBzZXF1ZW5jZXIuYzoyMjM5CisjOiBzZXF1ZW5jZXIuYzoyMTc3CiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCAnJXMnIHdpdGhvdXQgYSBwcmV2aW91cyBjb21taXQiCiBtc2dzdHIgIuayoeacieeItuaPkOS6pOeahOaDheWGteS4i+S4jeiDvSAnJXMnIgogCi0jOiBzZXF1ZW5jZXIuYzoyMjg3IGJ1aWx0aW4vcmViYXNlLmM6MTUzIGJ1aWx0aW4vcmViYXNlLmM6MTc4CisjOiBzZXF1ZW5jZXIuYzoyMjI1IGJ1aWx0aW4vcmViYXNlLmM6MTUzIGJ1aWx0aW4vcmViYXNlLmM6MTc4CiAjOiBidWlsdGluL3JlYmFzZS5jOjIwNCBidWlsdGluL3JlYmFzZS5jOjIyOQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcmVhZCAnJXMnLiIKIG1zZ3N0ciAi5LiN6IO96K+75Y+WICclcyfjgIIiCiAKLSM6IHNlcXVlbmNlci5jOjIzMjMKKyM6IHNlcXVlbmNlci5jOjIyNjEKIG1zZ2lkICJjYW5jZWxsaW5nIGEgY2hlcnJ5IHBpY2tpbmcgaW4gcHJvZ3Jlc3MiCiBtc2dzdHIgIuato+WcqOWPlua2iOS4gOS4qui/m+ihjOS4reeahOaLo+mAiSIKIAotIzogc2VxdWVuY2VyLmM6MjMzMAorIzogc2VxdWVuY2VyLmM6MjI2OAogbXNnaWQgImNhbmNlbGxpbmcgYSByZXZlcnQgaW4gcHJvZ3Jlc3MiCiBtc2dzdHIgIuato+WcqOWPlua2iOS4gOS4qui/m+ihjOS4reeahOi/mOWOnyIKIAotIzogc2VxdWVuY2VyLmM6MjM2NAorIzogc2VxdWVuY2VyLmM6MjMwMgogbXNnaWQgInBsZWFzZSBmaXggdGhpcyB1c2luZyAnZ2l0IHJlYmFzZSAtLWVkaXQtdG9kbycuIgogbXNnc3RyICLor7fnlKggJ2dpdCByZWJhc2UgLS1lZGl0LXRvZG8nIOadpeS/ruaUueOAgiIKIAotIzogc2VxdWVuY2VyLmM6MjM2NgorIzogc2VxdWVuY2VyLmM6MjMwNAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bnVzYWJsZSBpbnN0cnVjdGlvbiBzaGVldDogJyVzJyIKIG1zZ3N0ciAi5LiN5Y+v55So55qE5oyH5Luk5riF5Y2V77yaJyVzJyIKIAotIzogc2VxdWVuY2VyLmM6MjM3MQorIzogc2VxdWVuY2VyLmM6MjMwOQogbXNnaWQgIm5vIGNvbW1pdHMgcGFyc2VkLiIKIG1zZ3N0ciAi5rKh5pyJ6Kej5p6Q5o+Q5Lqk44CCIgogCi0jOiBzZXF1ZW5jZXIuYzoyMzgyCisjOiBzZXF1ZW5jZXIuYzoyMzIwCiBtc2dpZCAiY2Fubm90IGNoZXJyeS1waWNrIGR1cmluZyBhIHJldmVydC4iCiBtc2dzdHIgIuS4jeiDveWcqOWbnumAgOS4reaJp+ihjOaLo+mAieOAgiIKIAotIzogc2VxdWVuY2VyLmM6MjM4NAorIzogc2VxdWVuY2VyLmM6MjMyMgogbXNnaWQgImNhbm5vdCByZXZlcnQgZHVyaW5nIGEgY2hlcnJ5LXBpY2suIgogbXNnc3RyICLkuI3og73lnKjmi6PpgInkuK3miafooYzlm57pgIDjgIIiCiAKLSM6IHNlcXVlbmNlci5jOjI0NjYKKyM6IHNlcXVlbmNlci5jOjI0MDQKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCB2YWx1ZSBmb3IgJXM6ICVzIgogbXNnc3RyICIlcyDnmoTlgLzml6DmlYjvvJolcyIKIAotIzogc2VxdWVuY2VyLmM6MjU1MworIzogc2VxdWVuY2VyLmM6MjQ5MQogbXNnaWQgInVudXNhYmxlIHNxdWFzaC1vbnRvIgogbXNnc3RyICLkuI3lj6/nlKjnmoQgc3F1YXNoLW9udG8iCiAKLSM6IHNlcXVlbmNlci5jOjI1NjkKKyM6IHNlcXVlbmNlci5jOjI1MDcKICMsIGMtZm9ybWF0CiBtc2dpZCAibWFsZm9ybWVkIG9wdGlvbnMgc2hlZXQ6ICclcyciCiBtc2dzdHIgIuagvOW8j+mUmeivr+eahOmAiemhuea4heWNle+8miclcyciCiAKLSM6IHNlcXVlbmNlci5jOjI2NTIgc2VxdWVuY2VyLmM6NDM1MQorIzogc2VxdWVuY2VyLmM6MjU5MCBzZXF1ZW5jZXIuYzo0MzA4CiBtc2dpZCAiZW1wdHkgY29tbWl0IHNldCBwYXNzZWQiCiBtc2dzdHIgIuaPkOS+m+S6huepuueahOaPkOS6pOmbhiIKIAotIzogc2VxdWVuY2VyLmM6MjY2OAorIzogc2VxdWVuY2VyLmM6MjYwNgogbXNnaWQgInJldmVydCBpcyBhbHJlYWR5IGluIHByb2dyZXNzIgogbXNnc3RyICLkuIDkuKrov5jljp/mk43kvZzlt7LlnKjov5vooYwiCiAKLSM6IHNlcXVlbmNlci5jOjI2NzAKKyM6IHNlcXVlbmNlci5jOjI2MDgKICMsIGMtZm9ybWF0CiBtc2dpZCAidHJ5IFwiZ2l0IHJldmVydCAoLS1jb250aW51ZSB8ICVzLS1hYm9ydCB8IC0tcXVpdClcIiIKIG1zZ3N0ciAi5bCd6K+VIFwiZ2l0IHJldmVydCAoLS1jb250aW51ZSB8ICVzLS1hYm9ydCB8IC0tcXVpdClcIiIKIAotIzogc2VxdWVuY2VyLmM6MjY3MworIzogc2VxdWVuY2VyLmM6MjYxMQogbXNnaWQgImNoZXJyeS1waWNrIGlzIGFscmVhZHkgaW4gcHJvZ3Jlc3MiCiBtc2dzdHIgIuaLo+mAieaTjeS9nOW3suWcqOi/m+ihjCIKIAotIzogc2VxdWVuY2VyLmM6MjY3NQorIzogc2VxdWVuY2VyLmM6MjYxMwogIywgYy1mb3JtYXQKIG1zZ2lkICJ0cnkgXCJnaXQgY2hlcnJ5LXBpY2sgKC0tY29udGludWUgfCAlcy0tYWJvcnQgfCAtLXF1aXQpXCIiCiBtc2dzdHIgIuWwneivlSBcImdpdCBjaGVycnktcGljayAoLS1jb250aW51ZSB8ICVzLS1hYm9ydCB8IC0tcXVpdClcIiIKIAotIzogc2VxdWVuY2VyLmM6MjY4OQorIzogc2VxdWVuY2VyLmM6MjYyNwogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgY3JlYXRlIHNlcXVlbmNlciBkaXJlY3RvcnkgJyVzJyIKIG1zZ3N0ciAi5LiN6IO95Yib5bu65bqP5YiX55uu5b2VICclcyciCiAKLSM6IHNlcXVlbmNlci5jOjI3MDQKKyM6IHNlcXVlbmNlci5jOjI2NDIKIG1zZ2lkICJjb3VsZCBub3QgbG9jayBIRUFEIgogbXNnc3RyICLkuI3og73plIHlrpogSEVBRCIKIAotIzogc2VxdWVuY2VyLmM6Mjc2NCBzZXF1ZW5jZXIuYzo0MTAzCisjOiBzZXF1ZW5jZXIuYzoyNzAyIHNlcXVlbmNlci5jOjQwNTcKIG1zZ2lkICJubyBjaGVycnktcGljayBvciByZXZlcnQgaW4gcHJvZ3Jlc3MiCiBtc2dzdHIgIuaLo+mAieaIlui/mOWOn+aTjeS9nOW5tuacqui/m+ihjCIKIAotIzogc2VxdWVuY2VyLmM6Mjc2NiBzZXF1ZW5jZXIuYzoyNzc3CisjOiBzZXF1ZW5jZXIuYzoyNzA0IHNlcXVlbmNlci5jOjI3MTUKIG1zZ2lkICJjYW5ub3QgcmVzb2x2ZSBIRUFEIgogbXNnc3RyICLkuI3og73op6PmnpAgSEVBRCIKIAotIzogc2VxdWVuY2VyLmM6Mjc2OCBzZXF1ZW5jZXIuYzoyODEyCisjOiBzZXF1ZW5jZXIuYzoyNzA2IHNlcXVlbmNlci5jOjI3NTAKIG1zZ2lkICJjYW5ub3QgYWJvcnQgZnJvbSBhIGJyYW5jaCB5ZXQgdG8gYmUgYm9ybiIKIG1zZ3N0ciAi5LiN6IO95LuO5bCa5pyq5bu656uL55qE5YiG5pSv57uI5q2iIgogCi0jOiBzZXF1ZW5jZXIuYzoyNzk4IGJ1aWx0aW4vZ3JlcC5jOjczNAorIzogc2VxdWVuY2VyLmM6MjczNiBidWlsdGluL2dyZXAuYzo3MzYKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IG9wZW4gJyVzJyIKIG1zZ3N0ciAi5LiN6IO95omT5byAICclcyciCiAKLSM6IHNlcXVlbmNlci5jOjI4MDAKKyM6IHNlcXVlbmNlci5jOjI3MzgKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IHJlYWQgJyVzJzogJXMiCiBtc2dzdHIgIuS4jeiDveivu+WPliAnJXMn77yaJXMiCiAKLSM6IHNlcXVlbmNlci5jOjI4MDEKKyM6IHNlcXVlbmNlci5jOjI3MzkKIG1zZ2lkICJ1bmV4cGVjdGVkIGVuZCBvZiBmaWxlIgogbXNnc3RyICLmhI/lpJbnmoTmlofku7bnu5PmnZ8iCiAKLSM6IHNlcXVlbmNlci5jOjI4MDcKKyM6IHNlcXVlbmNlci5jOjI3NDUKICMsIGMtZm9ybWF0CiBtc2dpZCAic3RvcmVkIHByZS1jaGVycnktcGljayBIRUFEIGZpbGUgJyVzJyBpcyBjb3JydXB0IgogbXNnc3RyICLkv53lrZjmi6PpgInmj5DkuqTliY3nmoQgSEVBRCDmlofku7YgJyVzJyDmjZ/lnY8iCiAKLSM6IHNlcXVlbmNlci5jOjI4MTgKKyM6IHNlcXVlbmNlci5jOjI3NTYKIG1zZ2lkICJZb3Ugc2VlbSB0byBoYXZlIG1vdmVkIEhFQUQuIE5vdCByZXdpbmRpbmcsIGNoZWNrIHlvdXIgSEVBRCEiCiBtc2dzdHIgIuaCqOWlveWDj+enu+WKqOS6hiBIRUFE44CC5pyq6IO95Zue6YCA77yM5qOA5p+l5oKo55qEIEhFQUTvvIEiCiAKLSM6IHNlcXVlbmNlci5jOjI4NTkKKyM6IHNlcXVlbmNlci5jOjI3OTcKIG1zZ2lkICJubyByZXZlcnQgaW4gcHJvZ3Jlc3MiCiBtc2dzdHIgIuayoeacieato+WcqOi/m+ihjOeahOi/mOWOnyIKIAotIzogc2VxdWVuY2VyLmM6Mjg2NworIzogc2VxdWVuY2VyLmM6MjgwNQogbXNnaWQgIm5vIGNoZXJyeS1waWNrIGluIHByb2dyZXNzIgogbXNnc3RyICLmsqHmnInmraPlnKjov5vooYznmoTmi6PpgIkiCiAKLSM6IHNlcXVlbmNlci5jOjI4NzcKKyM6IHNlcXVlbmNlci5jOjI4MTUKIG1zZ2lkICJmYWlsZWQgdG8gc2tpcCB0aGUgY29tbWl0IgogbXNnc3RyICLml6Dms5Xot7Pov4fov5nkuKrmj5DkuqQiCiAKLSM6IHNlcXVlbmNlci5jOjI4ODQKKyM6IHNlcXVlbmNlci5jOjI4MjIKIG1zZ2lkICJ0aGVyZSBpcyBub3RoaW5nIHRvIHNraXAiCiBtc2dzdHIgIuayoeacieimgei3s+i/h+eahCIKIAotIzogc2VxdWVuY2VyLmM6Mjg4NworIzogc2VxdWVuY2VyLmM6MjgyNQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiaGF2ZSB5b3UgY29tbWl0dGVkIGFscmVhZHk/XG4iCkBAIC02Mjg4LDIxICs2MzEzLDIxIEBACiAi5oKo5bey57uP5o+Q5Lqk5LqG5LmI77yfXG4iCiAi6K+V6K+VIFwiZ2l0ICVzIC0tY29udGludWVcIiIKIAotIzogc2VxdWVuY2VyLmM6MzAxMSBzZXF1ZW5jZXIuYzo0MDE1CisjOiBzZXF1ZW5jZXIuYzoyOTQ5IHNlcXVlbmNlci5jOjM5NjkKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHVwZGF0ZSAlcyIKIG1zZ3N0ciAi5LiN6IO95pu05pawICVzIgogCi0jOiBzZXF1ZW5jZXIuYzozMDQ5IHNlcXVlbmNlci5jOjM5OTUKKyM6IHNlcXVlbmNlci5jOjI5ODcgc2VxdWVuY2VyLmM6Mzk0OQogbXNnaWQgImNhbm5vdCByZWFkIEhFQUQiCiBtc2dzdHIgIuS4jeiDveivu+WPliBIRUFEIgogCi0jOiBzZXF1ZW5jZXIuYzozMDY2CisjOiBzZXF1ZW5jZXIuYzozMDA0CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBjb3B5ICclcycgdG8gJyVzJyIKIG1zZ3N0ciAi5peg5rOV5ou36LSdICclcycg6IezICclcyciCiAKLSM6IHNlcXVlbmNlci5jOjMwNzQKKyM6IHNlcXVlbmNlci5jOjMwMTIKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIllvdSBjYW4gYW1lbmQgdGhlIGNvbW1pdCBub3csIHdpdGhcbiIKQEAgLTYzMjEsMjggKzYzNDYsMjggQEAKICJcbiIKICIgIGdpdCByZWJhc2UgLS1jb250aW51ZVxuIgogCi0jOiBzZXF1ZW5jZXIuYzozMDg0CisjOiBzZXF1ZW5jZXIuYzozMDIyCiAjLCBjLWZvcm1hdAogbXNnaWQgIkNvdWxkIG5vdCBhcHBseSAlcy4uLiAlLipzIgogbXNnc3RyICLkuI3og73lupTnlKggJXMuLi4gJS4qcyIKIAotIzogc2VxdWVuY2VyLmM6MzA5MQorIzogc2VxdWVuY2VyLmM6MzAyOQogIywgYy1mb3JtYXQKIG1zZ2lkICJDb3VsZCBub3QgbWVyZ2UgJS4qcyIKIG1zZ3N0ciAi5LiN6IO95ZCI5bm2ICUuKnMiCiAKLSM6IHNlcXVlbmNlci5jOjMxMDUgc2VxdWVuY2VyLmM6MzEwOSBidWlsdGluL2RpZmZ0b29sLmM6NjMzCisjOiBzZXF1ZW5jZXIuYzozMDQzIHNlcXVlbmNlci5jOjMwNDcgYnVpbHRpbi9kaWZmdG9vbC5jOjY0MQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgY29weSAnJXMnIHRvICclcyciCiBtc2dzdHIgIuS4jeiDveaLt+i0nSAnJXMnIOiHsyAnJXMnIgogCi0jOiBzZXF1ZW5jZXIuYzozMTMxIHNlcXVlbmNlci5jOjM1NTggYnVpbHRpbi9yZWJhc2UuYzo4NDkgYnVpbHRpbi9yZWJhc2UuYzoxNTgyCi0jOiBidWlsdGluL3JlYmFzZS5jOjE5NTMgYnVpbHRpbi9yZWJhc2UuYzoyMDA4CisjOiBzZXF1ZW5jZXIuYzozMDY5IHNlcXVlbmNlci5jOjM1MDYgYnVpbHRpbi9yZWJhc2UuYzo4NTAgYnVpbHRpbi9yZWJhc2UuYzoxNjEzCisjOiBidWlsdGluL3JlYmFzZS5jOjE5ODcgYnVpbHRpbi9yZWJhc2UuYzoyMDMxCiBtc2dpZCAiY291bGQgbm90IHJlYWQgaW5kZXgiCiBtc2dzdHIgIuS4jeiDveivu+WPlue0ouW8lSIKIAogIyAg6K+R6ICF77ya5rOo5oSP5L+d5oyB5YmN5a+856m65qC8Ci0jOiBzZXF1ZW5jZXIuYzozMTM2CisjOiBzZXF1ZW5jZXIuYzozMDc0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJleGVjdXRpb24gZmFpbGVkOiAlc1xuIgpAQCAtNjM1NywxMSArNjM4MiwxMSBAQAogIiAgZ2l0IHJlYmFzZSAtLWNvbnRpbnVlXG4iCiAiXG4iCiAKLSM6IHNlcXVlbmNlci5jOjMxNDIKKyM6IHNlcXVlbmNlci5jOjMwODAKIG1zZ2lkICJhbmQgbWFkZSBjaGFuZ2VzIHRvIHRoZSBpbmRleCBhbmQvb3IgdGhlIHdvcmtpbmcgdHJlZVxuIgogbXNnc3RyICLlubbkuJTkv67mlLnntKLlvJXlkowv5oiW5bel5L2c5Yy6XG4iCiAKLSM6IHNlcXVlbmNlci5jOjMxNDgKKyM6IHNlcXVlbmNlci5jOjMwODYKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogImV4ZWN1dGlvbiBzdWNjZWVkZWQ6ICVzXG4iCkBAIC02Mzc4LDc2ICs2NDAzLDc2IEBACiAiICBnaXQgcmViYXNlIC0tY29udGludWVcbiIKICJcbiIKIAotIzogc2VxdWVuY2VyLmM6MzIwOQorIzogc2VxdWVuY2VyLmM6MzE0NwogIywgYy1mb3JtYXQKIG1zZ2lkICJpbGxlZ2FsIGxhYmVsIG5hbWU6ICclLipzJyIKIG1zZ3N0ciAi6Z2e5rOV55qE5qCH562+5ZCN56ew77yaJyUuKnMnIgogCi0jOiBzZXF1ZW5jZXIuYzozMjYzCisjOiBzZXF1ZW5jZXIuYzozMjAxCiBtc2dpZCAid3JpdGluZyBmYWtlIHJvb3QgY29tbWl0IgogbXNnc3RyICLlhpnkvKrmoLnmj5DkuqQiCiAKLSM6IHNlcXVlbmNlci5jOjMyNjgKKyM6IHNlcXVlbmNlci5jOjMyMDYKIG1zZ2lkICJ3cml0aW5nIHNxdWFzaC1vbnRvIgogbXNnc3RyICLlhpnlhaUgc3F1YXNoLW9udG8iCiAKLSM6IHNlcXVlbmNlci5jOjMzMDYgYnVpbHRpbi9yZWJhc2UuYzo4NTQgYnVpbHRpbi9yZWJhc2UuYzo4NjAKKyM6IHNlcXVlbmNlci5jOjMyNDQgYnVpbHRpbi9yZWJhc2UuYzo4NTUgYnVpbHRpbi9yZWJhc2UuYzo4NjEKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIGZpbmQgdHJlZSBvZiAlcyIKIG1zZ3N0ciAi5peg5rOV5om+5YiwICVzIOaMh+WQkeeahOagkeOAgiIKIAotIzogc2VxdWVuY2VyLmM6MzMyNCBidWlsdGluL3JlYmFzZS5jOjg3MworIzogc2VxdWVuY2VyLmM6MzI2MiBidWlsdGluL3JlYmFzZS5jOjg3NAogbXNnaWQgImNvdWxkIG5vdCB3cml0ZSBpbmRleCIKIG1zZ3N0ciAi5LiN6IO95YaZ5YWl57Si5byVIgogCi0jOiBzZXF1ZW5jZXIuYzozMzUxCisjOiBzZXF1ZW5jZXIuYzozMjg5CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCByZXNvbHZlICclcyciCiBtc2dzdHIgIuaXoOazleino+aekCAnJXMnIgogCi0jOiBzZXF1ZW5jZXIuYzozMzc5CisjOiBzZXF1ZW5jZXIuYzozMzIwCiBtc2dpZCAiY2Fubm90IG1lcmdlIHdpdGhvdXQgYSBjdXJyZW50IHJldmlzaW9uIgogbXNnc3RyICLmsqHmnInlvZPliY3niYjmnKzkuI3og73lkIjlubYiCiAKLSM6IHNlcXVlbmNlci5jOjM0MDEKKyM6IHNlcXVlbmNlci5jOjMzNDIKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHBhcnNlICclLipzJyIKIG1zZ3N0ciAi5peg5rOV6Kej5p6QICclLipzJyIKIAotIzogc2VxdWVuY2VyLmM6MzQxMAorIzogc2VxdWVuY2VyLmM6MzM1MQogIywgYy1mb3JtYXQKIG1zZ2lkICJub3RoaW5nIHRvIG1lcmdlOiAnJS4qcyciCiBtc2dzdHIgIuaXoOWPr+eUqOWQiOW5tu+8miclLipzJyIKIAotIzogc2VxdWVuY2VyLmM6MzQyMgorIzogc2VxdWVuY2VyLmM6MzM2MwogbXNnaWQgIm9jdG9wdXMgbWVyZ2UgY2Fubm90IGJlIGV4ZWN1dGVkIG9uIHRvcCBvZiBhIFtuZXcgcm9vdF0iCiBtc2dzdHIgIueroOmxvOWQiOW5tuS4jeiDveWcqOS4gOS4quaWsOeahOagueaPkOS6pOS4iuaJp+ihjCIKIAotIzogc2VxdWVuY2VyLmM6MzQzNworIzogc2VxdWVuY2VyLmM6MzM3OAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgZ2V0IGNvbW1pdCBtZXNzYWdlIG9mICclcyciCiBtc2dzdHIgIuS4jeiDveiOt+WPliAnJXMnIOeahOaPkOS6pOivtOaYjiIKIAotIzogc2VxdWVuY2VyLmM6MzU5MAorIzogc2VxdWVuY2VyLmM6MzUzOAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgZXZlbiBhdHRlbXB0IHRvIG1lcmdlICclLipzJyIKIG1zZ3N0ciAi55Sa6Iez5LiN6IO95bCd6K+V5ZCI5bm2ICclLipzJyIKIAotIzogc2VxdWVuY2VyLmM6MzYwNgorIzogc2VxdWVuY2VyLmM6MzU1NAogbXNnaWQgIm1lcmdlOiBVbmFibGUgdG8gd3JpdGUgbmV3IGluZGV4IGZpbGUiCiBtc2dzdHIgIuWQiOW5tu+8muaXoOazleWGmeWFpeaWsOe0ouW8leaWh+S7tiIKIAotIzogc2VxdWVuY2VyLmM6MzY3NSBidWlsdGluL3JlYmFzZS5jOjcxMQorIzogc2VxdWVuY2VyLmM6MzYyMyBidWlsdGluL3JlYmFzZS5jOjcxMgogIywgYy1mb3JtYXQKIG1zZ2lkICJBcHBsaWVkIGF1dG9zdGFzaC5cbiIKIG1zZ3N0ciAi5bey5bqU55SoIGF1dG9zdGFzaOOAglxuIgogCi0jOiBzZXF1ZW5jZXIuYzozNjg3CisjOiBzZXF1ZW5jZXIuYzozNjM1CiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCBzdG9yZSAlcyIKIG1zZ3N0ciAi5LiN6IO95a2Y5YKoICVzIgogCi0jOiBzZXF1ZW5jZXIuYzozNjkwIGJ1aWx0aW4vcmViYXNlLmM6NzI3IGdpdC1yZWJhc2UtLXByZXNlcnZlLW1lcmdlcy5zaDoxMTMKKyM6IHNlcXVlbmNlci5jOjM2MzggYnVpbHRpbi9yZWJhc2UuYzo3MjggZ2l0LXJlYmFzZS0tcHJlc2VydmUtbWVyZ2VzLnNoOjExMwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiQXBwbHlpbmcgYXV0b3N0YXNoIHJlc3VsdGVkIGluIGNvbmZsaWN0cy5cbiIKQEAgLTY0NTgsMzEgKzY0ODMsMzEgQEAKICLmgqjnmoTkv67mlLnlronlhajlnLDkv53lrZjlnKjotK7ol4/ljLrkuK3jgIJcbiIKICLmgqjlj6/ku6XlnKjku7vkvZXml7blgJnov5DooYwgXCJnaXQgc3Rhc2ggcG9wXCIg5oiWIFwiZ2l0IHN0YXNoIGRyb3BcIuOAglxuIgogCi0jOiBzZXF1ZW5jZXIuYzozNzUxCisjOiBzZXF1ZW5jZXIuYzozNjk5CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBjaGVja291dCAlcyIKIG1zZ3N0ciAi5LiN6IO95qOA5Ye6ICVzIgogCi0jOiBzZXF1ZW5jZXIuYzozNzY1CisjOiBzZXF1ZW5jZXIuYzozNzEzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiBub3QgYSB2YWxpZCBPSUQiCiBtc2dzdHIgIiVz77ya5LiN5piv5LiA5Liq5pyJ5pWI55qE5a+56LGhIElEIgogCi0jOiBzZXF1ZW5jZXIuYzozNzcwIGdpdC1yZWJhc2UtLXByZXNlcnZlLW1lcmdlcy5zaDo3NzkKKyM6IHNlcXVlbmNlci5jOjM3MTggZ2l0LXJlYmFzZS0tcHJlc2VydmUtbWVyZ2VzLnNoOjc3OQogbXNnaWQgImNvdWxkIG5vdCBkZXRhY2ggSEVBRCIKIG1zZ3N0ciAi5LiN6IO95YiG56a75aS05oyH6ZKIIgogCi0jOiBzZXF1ZW5jZXIuYzozNzg1CisjOiBzZXF1ZW5jZXIuYzozNzMzCiAjLCBjLWZvcm1hdAogbXNnaWQgIlN0b3BwZWQgYXQgSEVBRFxuIgogbXNnc3RyICLlgZzmraLlnKggSEVBRFxuIgogCi0jOiBzZXF1ZW5jZXIuYzozNzg3CisjOiBzZXF1ZW5jZXIuYzozNzM1CiAjLCBjLWZvcm1hdAogbXNnaWQgIlN0b3BwZWQgYXQgJXNcbiIKIG1zZ3N0ciAi5YGc5q2i5ZyoICVzXG4iCiAKLSM6IHNlcXVlbmNlci5jOjM3OTUKKyM6IHNlcXVlbmNlci5jOjM3NDMKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkNvdWxkIG5vdCBleGVjdXRlIHRoZSB0b2RvIGNvbW1hbmRcbiIKQEAgLTY1MDIsNDggKzY1MjcsNDggQEAKICIgICAgZ2l0IHJlYmFzZSAtLWVkaXQtdG9kb1xuIgogIiAgICBnaXQgcmViYXNlIC0tY29udGludWVcbiIKIAotIzogc2VxdWVuY2VyLmM6Mzg3NworIzogc2VxdWVuY2VyLmM6MzgyNwogIywgYy1mb3JtYXQKIG1zZ2lkICJTdG9wcGVkIGF0ICVzLi4uICAlLipzXG4iCiBtc2dzdHIgIuWBnOatouWcqCAlcy4uLiAlLipzXG4iCiAKLSM6IHNlcXVlbmNlci5jOjM5NTgKKyM6IHNlcXVlbmNlci5jOjM4OTgKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5rbm93biBjb21tYW5kICVkIgogbXNnc3RyICLmnKrnn6Xlkb3ku6QgJWQiCiAKLSM6IHNlcXVlbmNlci5jOjQwMDMKKyM6IHNlcXVlbmNlci5jOjM5NTcKIG1zZ2lkICJjb3VsZCBub3QgcmVhZCBvcmlnLWhlYWQiCiBtc2dzdHIgIuS4jeiDveivu+WPliBvcmlnLWhlYWQiCiAKLSM6IHNlcXVlbmNlci5jOjQwMDgKKyM6IHNlcXVlbmNlci5jOjM5NjIKIG1zZ2lkICJjb3VsZCBub3QgcmVhZCAnb250byciCiBtc2dzdHIgIuS4jeiDveivu+WPliAnb250byciCiAKLSM6IHNlcXVlbmNlci5jOjQwMjIKKyM6IHNlcXVlbmNlci5jOjM5NzYKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHVwZGF0ZSBIRUFEIHRvICVzIgogbXNnc3RyICLkuI3og73mm7TmlrAgSEVBRCDkuLogJXMiCiAKLSM6IHNlcXVlbmNlci5jOjQxMTUKKyM6IHNlcXVlbmNlci5jOjQwNjkKIG1zZ2lkICJjYW5ub3QgcmViYXNlOiBZb3UgaGF2ZSB1bnN0YWdlZCBjaGFuZ2VzLiIKIG1zZ3N0ciAi5LiN6IO95Y+Y5Z+677ya5oKo5pyJ5pyq5pqC5a2Y55qE5Y+Y5pu044CCIgogCi0jOiBzZXF1ZW5jZXIuYzo0MTI0CisjOiBzZXF1ZW5jZXIuYzo0MDc4CiBtc2dpZCAiY2Fubm90IGFtZW5kIG5vbi1leGlzdGluZyBjb21taXQiCiBtc2dzdHIgIuS4jeiDveS/ruihpeS4jeWtmOWcqOeahOaPkOS6pCIKIAotIzogc2VxdWVuY2VyLmM6NDEyNgorIzogc2VxdWVuY2VyLmM6NDA4MAogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIGZpbGU6ICclcyciCiBtc2dzdHIgIuaXoOaViOaWh+S7tu+8miclcyciCiAKLSM6IHNlcXVlbmNlci5jOjQxMjgKKyM6IHNlcXVlbmNlci5jOjQwODIKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBjb250ZW50czogJyVzJyIKIG1zZ3N0ciAi5peg5pWI5YaF5a6577yaJyVzJyIKIAotIzogc2VxdWVuY2VyLmM6NDEzMQorIzogc2VxdWVuY2VyLmM6NDA4NQogbXNnaWQgIiIKICJcbiIKICJZb3UgaGF2ZSB1bmNvbW1pdHRlZCBjaGFuZ2VzIGluIHlvdXIgd29ya2luZyB0cmVlLiBQbGVhc2UsIGNvbW1pdCB0aGVtXG4iCkBAIC02NTUyLDQyICs2NTc3LDQyIEBACiAiXG4iCiAi5oKo55qE5bel5L2c5Yy65Lit5pyJ5pyq5o+Q5Lqk55qE5Y+Y5pu044CC6K+35YWI5o+Q5Lqk54S25ZCO5YaN5qyh6L+Q6KGMICdnaXQgcmViYXNlIC0tY29udGludWUn44CCIgogCi0jOiBzZXF1ZW5jZXIuYzo0MTY3IHNlcXVlbmNlci5jOjQyMDUKKyM6IHNlcXVlbmNlci5jOjQxMjEgc2VxdWVuY2VyLmM6NDE1OQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3Qgd3JpdGUgZmlsZTogJyVzJyIKIG1zZ3N0ciAi5LiN6IO95YaZ5YWl5paH5Lu277yaJyVzJyIKIAotIzogc2VxdWVuY2VyLmM6NDIyMAorIzogc2VxdWVuY2VyLmM6NDE3NAogbXNnaWQgImNvdWxkIG5vdCByZW1vdmUgQ0hFUlJZX1BJQ0tfSEVBRCIKIG1zZ3N0ciAi5LiN6IO95Yig6ZmkIENIRVJSWV9QSUNLX0hFQUQiCiAKLSM6IHNlcXVlbmNlci5jOjQyMjcKKyM6IHNlcXVlbmNlci5jOjQxODEKIG1zZ2lkICJjb3VsZCBub3QgY29tbWl0IHN0YWdlZCBjaGFuZ2VzLiIKIG1zZ3N0ciAi5LiN6IO95o+Q5Lqk5pqC5a2Y55qE5L+u5pS544CCIgogCi0jOiBzZXF1ZW5jZXIuYzo0MzI4CisjOiBzZXF1ZW5jZXIuYzo0Mjg1CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiBjYW4ndCBjaGVycnktcGljayBhICVzIgogbXNnc3RyICIlc++8muS4jeiDveaLo+mAieS4gOS4qiVzIgogCi0jOiBzZXF1ZW5jZXIuYzo0MzMyCisjOiBzZXF1ZW5jZXIuYzo0Mjg5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzOiBiYWQgcmV2aXNpb24iCiBtc2dzdHIgIiVz77ya6ZSZ6K+v55qE54mI5pysIgogCi0jOiBzZXF1ZW5jZXIuYzo0MzY3CisjOiBzZXF1ZW5jZXIuYzo0MzI0CiBtc2dpZCAiY2FuJ3QgcmV2ZXJ0IGFzIGluaXRpYWwgY29tbWl0IgogbXNnc3RyICLkuI3og73kvZzkuLrliJ3lp4vmj5DkuqTlm57pgIAiCiAKLSM6IHNlcXVlbmNlci5jOjQ4MTAKKyM6IHNlcXVlbmNlci5jOjQ3NzQKIG1zZ2lkICJtYWtlX3NjcmlwdDogdW5oYW5kbGVkIG9wdGlvbnMiCiBtc2dzdHIgIm1ha2Vfc2NyaXB077ya5pyJ5pyq6IO95aSE55CG55qE6YCJ6aG5IgogCi0jOiBzZXF1ZW5jZXIuYzo0ODEzCisjOiBzZXF1ZW5jZXIuYzo0Nzc3CiBtc2dpZCAibWFrZV9zY3JpcHQ6IGVycm9yIHByZXBhcmluZyByZXZpc2lvbnMiCiBtc2dzdHIgIm1ha2Vfc2NyaXB077ya5YeG5aSH54mI5pys5pe26ZSZ6K+vIgogCi0jOiBzZXF1ZW5jZXIuYzo0OTcxCisjOiBzZXF1ZW5jZXIuYzo0OTM1CiBtc2dpZCAiIgogIllvdSBjYW4gZml4IHRoaXMgd2l0aCAnZ2l0IHJlYmFzZSAtLWVkaXQtdG9kbycgYW5kIHRoZW4gcnVuICdnaXQgcmViYXNlIC0tIgogImNvbnRpbnVlJy5cbiIKQEAgLTY1OTYsMjQgKzY2MjEsMjQgQEAKICLmgqjlj6/ku6XnlKggJ2dpdCByZWJhc2UgLS1lZGl0LXRvZG8nIOS/ruato++8jOeEtuWQjuaJp+ihjCAnZ2l0IHJlYmFzZSAtLWNvbnRpbnVlJ+OAglxuIgogIuaIluiAheaCqOWPr+S7peeUqCAnZ2l0IHJlYmFzZSAtLWFib3J0JyDnu4jmraLlj5jln7rjgIJcbiIKIAotIzogc2VxdWVuY2VyLmM6NTA4MyBzZXF1ZW5jZXIuYzo1MTAwCisjOiBzZXF1ZW5jZXIuYzo1MDQ3IHNlcXVlbmNlci5jOjUwNjQKIG1zZ2lkICJub3RoaW5nIHRvIGRvIgogbXNnc3RyICLml6Dkuovlj6/lgZoiCiAKLSM6IHNlcXVlbmNlci5jOjUxMTQKKyM6IHNlcXVlbmNlci5jOjUwNzgKIG1zZ2lkICJjb3VsZCBub3Qgc2tpcCB1bm5lY2Vzc2FyeSBwaWNrIGNvbW1hbmRzIgogbXNnc3RyICLml6Dms5Xot7Pov4fkuI3lv4XopoHnmoTmi6PpgIkiCiAKLSM6IHNlcXVlbmNlci5jOjUxOTcKKyM6IHNlcXVlbmNlci5jOjUxNjYKIG1zZ2lkICJ0aGUgc2NyaXB0IHdhcyBhbHJlYWR5IHJlYXJyYW5nZWQuIgogbXNnc3RyICLohJrmnKzlt7Lnu4/ph43mlrDnvJbmjpLjgIIiCiAKLSM6IHNldHVwLmM6MTIzCisjOiBzZXR1cC5jOjEyNAogIywgYy1mb3JtYXQKIG1zZ2lkICInJXMnIGlzIG91dHNpZGUgcmVwb3NpdG9yeSIKIG1zZ3N0ciAiJyVzJyDlnKjku5PlupPkuYvlpJYiCiAKLSM6IHNldHVwLmM6MTczCisjOiBzZXR1cC5jOjE3NAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiJXM6IG5vIHN1Y2ggcGF0aCBpbiB0aGUgd29ya2luZyB0cmVlLlxuIgpAQCAtNjYyMiw3ICs2NjQ3LDcgQEAKICIlc++8muW3peS9nOWMuuS4reaXoOatpOi3r+W+hOOAglxuIgogIuS9v+eUqOWRveS7pCAnZ2l0IDzlkb3ku6Q+IC0tIDzot6/lvoQ+Li4uJyDmnaXmjIflrprmnKzlnLDkuI3lrZjlnKjnmoTot6/lvoTjgIIiCiAKLSM6IHNldHVwLmM6MTg2CisjOiBzZXR1cC5jOjE4NwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiYW1iaWd1b3VzIGFyZ3VtZW50ICclcyc6IHVua25vd24gcmV2aXNpb24gb3IgcGF0aCBub3QgaW4gdGhlIHdvcmtpbmcgdHJlZS5cbiIKQEAgLTY2MzMsMTIgKzY2NTgsMTIgQEAKICLkvb/nlKggJy0tJyDmnaXliIbpmpTniYjmnKzlkozot6/lvoTvvIzkvovlpoLvvJpcbiIKICInZ2l0IDzlkb3ku6Q+IFs854mI5pysPi4uLl0gLS0gWzzmlofku7Y+Li4uXSciCiAKLSM6IHNldHVwLmM6MjM1CisjOiBzZXR1cC5jOjIzNgogIywgYy1mb3JtYXQKIG1zZ2lkICJvcHRpb24gJyVzJyBtdXN0IGNvbWUgYmVmb3JlIG5vbi1vcHRpb24gYXJndW1lbnRzIgogbXNnc3RyICLpgInpobkgJyVzJyDlv4XpobvlnKjlhbbku5bpnZ7pgInpobnlj4LmlbDkuYvliY0iCiAKLSM6IHNldHVwLmM6MjU0CisjOiBzZXR1cC5jOjI1NQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiYW1iaWd1b3VzIGFyZ3VtZW50ICclcyc6IGJvdGggcmV2aXNpb24gYW5kIGZpbGVuYW1lXG4iCkBAIC02NjQ5LDkyICs2Njc0LDkyIEBACiAi5L2/55SoICctLScg5p2l5YiG6ZqU54mI5pys5ZKM6Lev5b6E77yM5L6L5aaC77yaXG4iCiAiJ2dpdCA85ZG95LukPiBbPOeJiOacrD4uLi5dIC0tIFs85paH5Lu2Pi4uLl0nIgogCi0jOiBzZXR1cC5jOjM5MAorIzogc2V0dXAuYzozOTEKIG1zZ2lkICJ1bmFibGUgdG8gc2V0IHVwIHdvcmsgdHJlZSB1c2luZyBpbnZhbGlkIGNvbmZpZyIKIG1zZ3N0ciAi5peg5rOV5L2/55So5peg5pWI6YWN572u5p2l5Yib5bu65bel5L2c5Yy6IgogCi0jOiBzZXR1cC5jOjM5NAorIzogc2V0dXAuYzozOTUKIG1zZ2lkICJ0aGlzIG9wZXJhdGlvbiBtdXN0IGJlIHJ1biBpbiBhIHdvcmsgdHJlZSIKIG1zZ3N0ciAi6K+l5pON5L2c5b+F6aG75Zyo5LiA5Liq5bel5L2c5Yy65Lit6L+Q6KGMIgogCi0jOiBzZXR1cC5jOjU0MAorIzogc2V0dXAuYzo1NDEKICMsIGMtZm9ybWF0CiBtc2dpZCAiRXhwZWN0ZWQgZ2l0IHJlcG8gdmVyc2lvbiA8PSAlZCwgZm91bmQgJWQiCiBtc2dzdHIgIuacn+acmyBnaXQg5LuT5bqT54mI5pysIDw9ICVk77yM5Y205b6X5YiwICVkIgogCi0jOiBzZXR1cC5jOjU0OAorIzogc2V0dXAuYzo1NDkKIG1zZ2lkICJ1bmtub3duIHJlcG9zaXRvcnkgZXh0ZW5zaW9ucyBmb3VuZDoiCiBtc2dzdHIgIuWPkeeOsOacquefpeeahOS7k+W6k+aJqeWxle+8miIKIAotIzogc2V0dXAuYzo1NjcKKyM6IHNldHVwLmM6NTY4CiAjLCBjLWZvcm1hdAogbXNnaWQgImVycm9yIG9wZW5pbmcgJyVzJyIKIG1zZ3N0ciAi5omT5byAICclcycg5Ye66ZSZIgogCi0jOiBzZXR1cC5jOjU2OQorIzogc2V0dXAuYzo1NzAKICMsIGMtZm9ybWF0CiBtc2dpZCAidG9vIGxhcmdlIHRvIGJlIGEgLmdpdCBmaWxlOiAnJXMnIgogbXNnc3RyICLmlofku7blpKrlpKfvvIzml6Dms5XkvZzkuLogLmdpdCDmlofku7bvvJonJXMnIgogCi0jOiBzZXR1cC5jOjU3MQorIzogc2V0dXAuYzo1NzIKICMsIGMtZm9ybWF0CiBtc2dpZCAiZXJyb3IgcmVhZGluZyAlcyIKIG1zZ3N0ciAi6K+75Y+WICVzIOWHuumUmSIKIAotIzogc2V0dXAuYzo1NzMKKyM6IHNldHVwLmM6NTc0CiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgZ2l0ZmlsZSBmb3JtYXQ6ICVzIgogbXNnc3RyICLml6DmlYjnmoQgZ2l0ZmlsZSDmoLzlvI/vvJolcyIKIAotIzogc2V0dXAuYzo1NzUKKyM6IHNldHVwLmM6NTc2CiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vIHBhdGggaW4gZ2l0ZmlsZTogJXMiCiBtc2dzdHIgIuWcqCBnaXRmaWxlIOS4reayoeaciei3r+W+hO+8miVzIgogCi0jOiBzZXR1cC5jOjU3NworIzogc2V0dXAuYzo1NzgKICMsIGMtZm9ybWF0CiBtc2dpZCAibm90IGEgZ2l0IHJlcG9zaXRvcnk6ICVzIgogbXNnc3RyICLkuI3mmK/kuIDkuKogZ2l0IOS7k+W6k++8miVzIgogCi0jOiBzZXR1cC5jOjY3NgorIzogc2V0dXAuYzo2NzcKICMsIGMtZm9ybWF0CiBtc2dpZCAiJyQlcycgdG9vIGJpZyIKIG1zZ3N0ciAiJyQlcycg5aSq5aSnIgogCi0jOiBzZXR1cC5jOjY5MAorIzogc2V0dXAuYzo2OTEKICMsIGMtZm9ybWF0CiBtc2dpZCAibm90IGEgZ2l0IHJlcG9zaXRvcnk6ICclcyciCiBtc2dzdHIgIuS4jeaYr+S4gOS4qiBnaXQg5LuT5bqT77yaJyVzJyIKIAotIzogc2V0dXAuYzo3MTkgc2V0dXAuYzo3MjEgc2V0dXAuYzo3NTIKKyM6IHNldHVwLmM6NzIwIHNldHVwLmM6NzIyIHNldHVwLmM6NzUzCiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCBjaGRpciB0byAnJXMnIgogbXNnc3RyICLkuI3og73liIfmjaLnm67lvZXliLAgJyVzJyIKIAotIzogc2V0dXAuYzo3MjQgc2V0dXAuYzo3ODAgc2V0dXAuYzo3OTAgc2V0dXAuYzo4Mjkgc2V0dXAuYzo4MzcKKyM6IHNldHVwLmM6NzI1IHNldHVwLmM6NzgxIHNldHVwLmM6NzkxIHNldHVwLmM6ODMwIHNldHVwLmM6ODM4CiBtc2dpZCAiY2Fubm90IGNvbWUgYmFjayB0byBjd2QiCiBtc2dzdHIgIuaXoOazlei/lOWbnuW9k+WJjeW3peS9nOebruW9lSIKIAotIzogc2V0dXAuYzo4NTEKKyM6IHNldHVwLmM6ODUyCiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBzdGF0ICclKnMlcyVzJyIKIG1zZ3N0ciAi6I635Y+WICclKnMlcyVzJyDnirbmgIHvvIhzdGF077yJ5aSx6LSlIgogCi0jOiBzZXR1cC5jOjEwODMKKyM6IHNldHVwLmM6MTA5MAogbXNnaWQgIlVuYWJsZSB0byByZWFkIGN1cnJlbnQgd29ya2luZyBkaXJlY3RvcnkiCiBtc2dzdHIgIuS4jeiDveivu+WPluW9k+WJjeW3peS9nOebruW9lSIKIAotIzogc2V0dXAuYzoxMDkyIHNldHVwLmM6MTA5OAorIzogc2V0dXAuYzoxMDk5IHNldHVwLmM6MTEwNQogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgY2hhbmdlIHRvICclcyciCiBtc2dzdHIgIuS4jeiDveWIh+aNouWIsCAnJXMnIgogCi0jOiBzZXR1cC5jOjExMDMKKyM6IHNldHVwLmM6MTExMAogIywgYy1mb3JtYXQKIG1zZ2lkICJub3QgYSBnaXQgcmVwb3NpdG9yeSAob3IgYW55IG9mIHRoZSBwYXJlbnQgZGlyZWN0b3JpZXMpOiAlcyIKIG1zZ3N0ciAi5LiN5piv5LiA5LiqIGdpdCDku5PlupPvvIjmiJbogIXku7vkvZXniLbnm67lvZXvvInvvJolcyIKIAotIzogc2V0dXAuYzoxMTA5CisjOiBzZXR1cC5jOjExMTYKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIm5vdCBhIGdpdCByZXBvc2l0b3J5IChvciBhbnkgcGFyZW50IHVwIHRvIG1vdW50IHBvaW50ICVzKVxuIgpAQCAtNjc0Myw3ICs2NzY4LDcgQEAKICLkuI3mmK/kuIDkuKogZ2l0IOS7k+W6k++8iOaIluiAheebtOiHs+aMgui9veeCuSAlcyDnmoTku7vkvZXniLbnm67lvZXvvIlcbiIKICLlgZzmraLlnKjmlofku7bns7vnu5/ovrnnlYzvvIjmnKrorr7nva4gR0lUX0RJU0NPVkVSWV9BQ1JPU1NfRklMRVNZU1RFTe+8ieOAgiIKIAotIzogc2V0dXAuYzoxMjIwCisjOiBzZXR1cC5jOjEyMjcKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogInByb2JsZW0gd2l0aCBjb3JlLnNoYXJlZFJlcG9zaXRvcnkgZmlsZW1vZGUgdmFsdWUgKDAlLjNvKS5cbiIKQEAgLTY3NTIsMjgyICs2Nzc3LDI4MiBAQAogIuWPguaVsCBjb3JlLnNoYXJlZFJlcG9zaXRvcnkg55qE5paH5Lu25bGe5oCn5YC85pyJ6Zeu6aKY77yIMCUuM2/vvInjgIJcbiIKICLmlofku7blsZ7kuLvlv4Xpobvlp4vnu4jmi6XmnInor7vlhpnmnYPpmZDjgIIiCiAKLSM6IHNldHVwLmM6MTI2NAorIzogc2V0dXAuYzoxMjcxCiBtc2dpZCAib3BlbiAvZGV2L251bGwgb3IgZHVwIGZhaWxlZCIKIG1zZ3N0ciAi5LiN6IO95omT5byA5oiW6ICF5aSN5Yi2IC9kZXYvbnVsbCIKIAotIzogc2V0dXAuYzoxMjc5CisjOiBzZXR1cC5jOjEyODYKIG1zZ2lkICJmb3JrIGZhaWxlZCIKIG1zZ3N0ciAiZm9yayDlpLHotKUiCiAKLSM6IHNldHVwLmM6MTI4NAorIzogc2V0dXAuYzoxMjkxCiBtc2dpZCAic2V0c2lkIGZhaWxlZCIKIG1zZ3N0ciAic2V0c2lkIOWksei0pSIKIAotIzogc2hhMS1maWxlLmM6NDUzCisjOiBzaGExLWZpbGUuYzo0NTIKICMsIGMtZm9ybWF0CiBtc2dpZCAib2JqZWN0IGRpcmVjdG9yeSAlcyBkb2VzIG5vdCBleGlzdDsgY2hlY2sgLmdpdC9vYmplY3RzL2luZm8vYWx0ZXJuYXRlcyIKIG1zZ3N0ciAi5a+56LGh55uu5b2VICVzIOS4jeWtmOWcqO+8jOajgOafpSAuZ2l0L29iamVjdHMvaW5mby9hbHRlcm5hdGVzIgogCi0jOiBzaGExLWZpbGUuYzo1MDQKKyM6IHNoYTEtZmlsZS5jOjUwMwogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gbm9ybWFsaXplIGFsdGVybmF0ZSBvYmplY3QgcGF0aDogJXMiCiBtc2dzdHIgIuaXoOazleinhOiMg+WMluWkh+eUqOWvueixoei3r+W+hO+8miVzIgogCi0jOiBzaGExLWZpbGUuYzo1NzYKKyM6IHNoYTEtZmlsZS5jOjU3NQogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogaWdub3JpbmcgYWx0ZXJuYXRlIG9iamVjdCBzdG9yZXMsIG5lc3RpbmcgdG9vIGRlZXAiCiBtc2dzdHIgIiVz77ya5b+955Wl5aSH55So5a+56LGh5bqT77yM5bWM5aWX5aSq5rexIgogCi0jOiBzaGExLWZpbGUuYzo1ODMKKyM6IHNoYTEtZmlsZS5jOjU4MgogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gbm9ybWFsaXplIG9iamVjdCBkaXJlY3Rvcnk6ICVzIgogbXNnc3RyICLml6Dms5Xop4TojIPljJblr7nosaHnm67lvZU6ICVzIgogCi0jOiBzaGExLWZpbGUuYzo2MjYKKyM6IHNoYTEtZmlsZS5jOjYyNQogbXNnaWQgInVuYWJsZSB0byBmZG9wZW4gYWx0ZXJuYXRlcyBsb2NrZmlsZSIKIG1zZ3N0ciAi5peg5rOVIGZkb3BlbiDmm7/mjaLplIHmlofku7YiCiAKLSM6IHNoYTEtZmlsZS5jOjY0NAorIzogc2hhMS1maWxlLmM6NjQzCiBtc2dpZCAidW5hYmxlIHRvIHJlYWQgYWx0ZXJuYXRlcyBmaWxlIgogbXNnc3RyICLml6Dms5Xor7vlj5bmm7/ku6Pmlofku7YiCiAKLSM6IHNoYTEtZmlsZS5jOjY1MQorIzogc2hhMS1maWxlLmM6NjUwCiBtc2dpZCAidW5hYmxlIHRvIG1vdmUgbmV3IGFsdGVybmF0ZXMgZmlsZSBpbnRvIHBsYWNlIgogbXNnc3RyICLml6Dms5XlsIbmlrDnmoTmm7/ku6Pmlofku7bnp7vliqjliLDkvY0iCiAKLSM6IHNoYTEtZmlsZS5jOjY4NgorIzogc2hhMS1maWxlLmM6Njg1CiAjLCBjLWZvcm1hdAogbXNnaWQgInBhdGggJyVzJyBkb2VzIG5vdCBleGlzdCIKIG1zZ3N0ciAi6Lev5b6EICclcycg5LiN5a2Y5ZyoIgogCi0jOiBzaGExLWZpbGUuYzo3MTIKKyM6IHNoYTEtZmlsZS5jOjcxMQogIywgYy1mb3JtYXQKIG1zZ2lkICJyZWZlcmVuY2UgcmVwb3NpdG9yeSAnJXMnIGFzIGEgbGlua2VkIGNoZWNrb3V0IGlzIG5vdCBzdXBwb3J0ZWQgeWV0LiIKIG1zZ3N0ciAi5bCa5LiN5pSv5oyB5bCG5Y+C6ICD5LuT5bqTICclcycg5L2c5Li65LiA5Liq6ZO+5o6l5qOA5Ye644CCIgogCi0jOiBzaGExLWZpbGUuYzo3MTgKKyM6IHNoYTEtZmlsZS5jOjcxNwogIywgYy1mb3JtYXQKIG1zZ2lkICJyZWZlcmVuY2UgcmVwb3NpdG9yeSAnJXMnIGlzIG5vdCBhIGxvY2FsIHJlcG9zaXRvcnkuIgogbXNnc3RyICLlj4LogIPku5PlupMgJyVzJyDkuI3mmK/kuIDkuKrmnKzlnLDku5PlupPjgIIiCiAKLSM6IHNoYTEtZmlsZS5jOjcyNAorIzogc2hhMS1maWxlLmM6NzIzCiAjLCBjLWZvcm1hdAogbXNnaWQgInJlZmVyZW5jZSByZXBvc2l0b3J5ICclcycgaXMgc2hhbGxvdyIKIG1zZ3N0ciAi5Y+C6ICD5LuT5bqTICclcycg5piv5LiA5Liq5rWF5YWL6ZqGIgogCi0jOiBzaGExLWZpbGUuYzo3MzIKKyM6IHNoYTEtZmlsZS5jOjczMQogIywgYy1mb3JtYXQKIG1zZ2lkICJyZWZlcmVuY2UgcmVwb3NpdG9yeSAnJXMnIGlzIGdyYWZ0ZWQiCiBtc2dzdHIgIuWPguiAg+S7k+W6kyAnJXMnIOW3suiiq+enu+akjSIKIAotIzogc2hhMS1maWxlLmM6NzkyCisjOiBzaGExLWZpbGUuYzo3OTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBsaW5lIHdoaWxlIHBhcnNpbmcgYWx0ZXJuYXRlIHJlZnM6ICVzIgogbXNnc3RyICLop6PmnpDlpIfnlKjlvJXnlKjml7bml6DmlYjnmoTooYzvvJolcyIKIAotIzogc2hhMS1maWxlLmM6OTQ0CisjOiBzaGExLWZpbGUuYzo5NDMKICMsIGMtZm9ybWF0CiBtc2dpZCAiYXR0ZW1wdGluZyB0byBtbWFwICU8UFJJdU1BWD4gb3ZlciBsaW1pdCAlPFBSSXVNQVg+IgogbXNnc3RyICLlsJ3or5UgbW1hcCAlPFBSSXVNQVg+77yM6LaF6L+H5LqG5pyA5aSn5YC8ICU8UFJJdU1BWD4iCiAKLSM6IHNoYTEtZmlsZS5jOjk2OQorIzogc2hhMS1maWxlLmM6OTY0CiBtc2dpZCAibW1hcCBmYWlsZWQiCiBtc2dzdHIgIm1tYXAg5aSx6LSlIgogCi0jOiBzaGExLWZpbGUuYzoxMTMzCisjOiBzaGExLWZpbGUuYzoxMTI4CiAjLCBjLWZvcm1hdAogbXNnaWQgIm9iamVjdCBmaWxlICVzIGlzIGVtcHR5IgogbXNnc3RyICLlr7nosaHmlofku7YgJXMg5Li656m6IgogCi0jOiBzaGExLWZpbGUuYzoxMjU3IHNoYTEtZmlsZS5jOjIzOTYKKyM6IHNoYTEtZmlsZS5jOjEyNTIgc2hhMS1maWxlLmM6MjM5MgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3JydXB0IGxvb3NlIG9iamVjdCAnJXMnIgogbXNnc3RyICLmjZ/lnY/nmoTmnb7mlaPlr7nosaEgJyVzJyIKIAotIzogc2hhMS1maWxlLmM6MTI1OSBzaGExLWZpbGUuYzoyNDAwCisjOiBzaGExLWZpbGUuYzoxMjU0IHNoYTEtZmlsZS5jOjIzOTYKICMsIGMtZm9ybWF0CiBtc2dpZCAiZ2FyYmFnZSBhdCBlbmQgb2YgbG9vc2Ugb2JqZWN0ICclcyciCiBtc2dzdHIgIuadvuaVo+WvueixoSAnJXMnIOWQjumdouacieWeg+WcvuaVsOaNriIKIAotIzogc2hhMS1maWxlLmM6MTMwMQorIzogc2hhMS1maWxlLmM6MTI5NgogbXNnaWQgImludmFsaWQgb2JqZWN0IHR5cGUiCiBtc2dzdHIgIuaXoOaViOeahOWvueixoeexu+WeiyIKIAotIzogc2hhMS1maWxlLmM6MTM4NQorIzogc2hhMS1maWxlLmM6MTM4MAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gdW5wYWNrICVzIGhlYWRlciB3aXRoIC0tYWxsb3ctdW5rbm93bi10eXBlIgogbXNnc3RyICLml6Dms5XnlKggLS1hbGxvdy11bmtub3duLXR5cGUg5Y+C5pWw6Kej5byAICVzIOWktOS/oeaBryIKIAotIzogc2hhMS1maWxlLmM6MTM4OAorIzogc2hhMS1maWxlLmM6MTM4MwogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gdW5wYWNrICVzIGhlYWRlciIKIG1zZ3N0ciAi5peg5rOV6Kej5byAICVzIOWktOmDqCIKIAotIzogc2hhMS1maWxlLmM6MTM5NAorIzogc2hhMS1maWxlLmM6MTM4OQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gcGFyc2UgJXMgaGVhZGVyIHdpdGggLS1hbGxvdy11bmtub3duLXR5cGUiCiBtc2dzdHIgIuaXoOazleeUqCAtLWFsbG93LXVua25vd24tdHlwZSDlj4LmlbDop6PmnpAgJXMg5aS05L+h5oGvIgogCi0jOiBzaGExLWZpbGUuYzoxMzk3CisjOiBzaGExLWZpbGUuYzoxMzkyCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBwYXJzZSAlcyBoZWFkZXIiCiBtc2dzdHIgIuaXoOazleino+aekCAlcyDlpLTpg6giCiAKLSM6IHNoYTEtZmlsZS5jOjE1ODgKKyM6IHNoYTEtZmlsZS5jOjE1ODQKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIHJlYWQgb2JqZWN0ICVzIgogbXNnc3RyICLor7vlj5blr7nosaEgJXMg5aSx6LSlIgogCi0jOiBzaGExLWZpbGUuYzoxNTkyCisjOiBzaGExLWZpbGUuYzoxNTg4CiAjLCBjLWZvcm1hdAogbXNnaWQgInJlcGxhY2VtZW50ICVzIG5vdCBmb3VuZCBmb3IgJXMiCiBtc2dzdHIgIuaJvuS4jeWIsCAlMiRzIOeahOabv+S7oyAlMSRzIgogCi0jOiBzaGExLWZpbGUuYzoxNTk2CisjOiBzaGExLWZpbGUuYzoxNTkyCiAjLCBjLWZvcm1hdAogbXNnaWQgImxvb3NlIG9iamVjdCAlcyAoc3RvcmVkIGluICVzKSBpcyBjb3JydXB0IgogbXNnc3RyICLmnb7mlaPlr7nosaEgJXPvvIjkv53lrZjlnKggJXPvvInlt7LmjZ/lnY8iCiAKLSM6IHNoYTEtZmlsZS5jOjE2MDAKKyM6IHNoYTEtZmlsZS5jOjE1OTYKICMsIGMtZm9ybWF0CiBtc2dpZCAicGFja2VkIG9iamVjdCAlcyAoc3RvcmVkIGluICVzKSBpcyBjb3JydXB0IgogbXNnc3RyICLmiZPljIXlr7nosaEgJXPvvIjkv53lrZjlnKggJXPvvInlt7LmjZ/lnY8iCiAKLSM6IHNoYTEtZmlsZS5jOjE3MDMKKyM6IHNoYTEtZmlsZS5jOjE2OTkKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHdyaXRlIGZpbGUgJXMiCiBtc2dzdHIgIuaXoOazleWGmeaWh+S7tiAlcyIKIAotIzogc2hhMS1maWxlLmM6MTcxMAorIzogc2hhMS1maWxlLmM6MTcwNgogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gc2V0IHBlcm1pc3Npb24gdG8gJyVzJyIKIG1zZ3N0ciAi5peg5rOV5Li6ICclcycg6K6+572u5p2D6ZmQIgogCi0jOiBzaGExLWZpbGUuYzoxNzE3CisjOiBzaGExLWZpbGUuYzoxNzEzCiBtc2dpZCAiZmlsZSB3cml0ZSBlcnJvciIKIG1zZ3N0ciAi5paH5Lu25YaZ6ZSZ6K+vIgogCi0jOiBzaGExLWZpbGUuYzoxNzM2CisjOiBzaGExLWZpbGUuYzoxNzMyCiBtc2dpZCAiZXJyb3Igd2hlbiBjbG9zaW5nIGxvb3NlIG9iamVjdCBmaWxlIgogbXNnc3RyICLlhbPpl63mnb7mlaPlr7nosaHmlofku7bml7blh7rplJkiCiAKLSM6IHNoYTEtZmlsZS5jOjE4MDEKKyM6IHNoYTEtZmlsZS5jOjE3OTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW5zdWZmaWNpZW50IHBlcm1pc3Npb24gZm9yIGFkZGluZyBhbiBvYmplY3QgdG8gcmVwb3NpdG9yeSBkYXRhYmFzZSAlcyIKIG1zZ3N0ciAi5p2D6ZmQ5LiN6Laz77yM5peg5rOV5Zyo5LuT5bqT5a+56LGh5bqTICVzIOS4rea3u+WKoOWvueixoSIKIAotIzogc2hhMS1maWxlLmM6MTgwMworIzogc2hhMS1maWxlLmM6MTc5OQogbXNnaWQgInVuYWJsZSB0byBjcmVhdGUgdGVtcG9yYXJ5IGZpbGUiCiBtc2dzdHIgIuaXoOazleWIm+W7uuS4tOaXtuaWh+S7tiIKIAotIzogc2hhMS1maWxlLmM6MTgyNworIzogc2hhMS1maWxlLmM6MTgyMwogbXNnaWQgInVuYWJsZSB0byB3cml0ZSBsb29zZSBvYmplY3QgZmlsZSIKIG1zZ3N0ciAi5LiN6IO95YaZ5p2+5pWj5a+56LGh5paH5Lu2IgogCi0jOiBzaGExLWZpbGUuYzoxODMzCisjOiBzaGExLWZpbGUuYzoxODI5CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBkZWZsYXRlIG5ldyBvYmplY3QgJXMgKCVkKSIKIG1zZ3N0ciAi5LiN6IO95Y6L57yp5paw5a+56LGhICVz77yIJWTvvIkiCiAKLSM6IHNoYTEtZmlsZS5jOjE4MzcKKyM6IHNoYTEtZmlsZS5jOjE4MzMKICMsIGMtZm9ybWF0CiBtc2dpZCAiZGVmbGF0ZUVuZCBvbiBvYmplY3QgJXMgZmFpbGVkICglZCkiCiBtc2dzdHIgIuWcqOWvueixoSAlcyDkuIrosIPnlKggZGVmbGF0ZUVuZCDlpLHotKXvvIglZO+8iSIKIAotIzogc2hhMS1maWxlLmM6MTg0MQorIzogc2hhMS1maWxlLmM6MTgzNwogIywgYy1mb3JtYXQKIG1zZ2lkICJjb25mdXNlZCBieSB1bnN0YWJsZSBvYmplY3Qgc291cmNlIGRhdGEgZm9yICVzIgogbXNnc3RyICLooqsgJXMg55qE5LiN56iz5a6a5a+56LGh5rqQ5pWw5o2u5pCe57OK5raC5LqGIgogCi0jOiBzaGExLWZpbGUuYzoxODUxIGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6OTI1CisjOiBzaGExLWZpbGUuYzoxODQ3IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6OTI1CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB1dGltZSgpIG9uICVzIgogbXNnc3RyICLlnKggJXMg5LiK6LCD55SoIHV0aW1lKCkg5aSx6LSlIgogCi0jOiBzaGExLWZpbGUuYzoxOTI2CisjOiBzaGExLWZpbGUuYzoxOTIyCiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCByZWFkIG9iamVjdCBmb3IgJXMiCiBtc2dzdHIgIuS4jeiDveivu+WPluWvueixoSAlcyIKIAotIzogc2hhMS1maWxlLmM6MTk2NgorIzogc2hhMS1maWxlLmM6MTk2MgogbXNnaWQgImNvcnJ1cHQgY29tbWl0IgogbXNnc3RyICLmjZ/lnY/nmoTmj5DkuqQiCiAKLSM6IHNoYTEtZmlsZS5jOjE5NzQKKyM6IHNoYTEtZmlsZS5jOjE5NzAKIG1zZ2lkICJjb3JydXB0IHRhZyIKIG1zZ3N0ciAi5o2f5Z2P55qE5qCH562+IgogCi0jOiBzaGExLWZpbGUuYzoyMDczCisjOiBzaGExLWZpbGUuYzoyMDY5CiAjLCBjLWZvcm1hdAogbXNnaWQgInJlYWQgZXJyb3Igd2hpbGUgaW5kZXhpbmcgJXMiCiBtc2dzdHIgIue0ouW8lSAlcyDml7bor7vlj5bplJnor68iCiAKLSM6IHNoYTEtZmlsZS5jOjIwNzYKKyM6IHNoYTEtZmlsZS5jOjIwNzIKICMsIGMtZm9ybWF0CiBtc2dpZCAic2hvcnQgcmVhZCB3aGlsZSBpbmRleGluZyAlcyIKIG1zZ3N0ciAi57Si5byVICVzIOaXtuivu+WFpeS4jeWujOaVtCIKIAotIzogc2hhMS1maWxlLmM6MjE0OSBzaGExLWZpbGUuYzoyMTU4CisjOiBzaGExLWZpbGUuYzoyMTQ1IHNoYTEtZmlsZS5jOjIxNTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXM6IGZhaWxlZCB0byBpbnNlcnQgaW50byBkYXRhYmFzZSIKIG1zZ3N0ciAiJXPvvJrmj5LlhaXmlbDmja7lupPlpLHotKUiCiAKLSM6IHNoYTEtZmlsZS5jOjIxNjQKKyM6IHNoYTEtZmlsZS5jOjIxNjAKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXM6IHVuc3VwcG9ydGVkIGZpbGUgdHlwZSIKIG1zZ3N0ciAiJXPvvJrkuI3mlK/mjIHnmoTmlofku7bnsbvlnosiCiAKLSM6IHNoYTEtZmlsZS5jOjIxODgKKyM6IHNoYTEtZmlsZS5jOjIxODQKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgaXMgbm90IGEgdmFsaWQgb2JqZWN0IgogbXNnc3RyICIlcyDkuI3mmK/kuIDkuKrmnInmlYjnmoTlr7nosaEiCiAKLSM6IHNoYTEtZmlsZS5jOjIxOTAKKyM6IHNoYTEtZmlsZS5jOjIxODYKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgaXMgbm90IGEgdmFsaWQgJyVzJyBvYmplY3QiCiBtc2dzdHIgIiVzIOS4jeaYr+S4gOS4quacieaViOeahCAnJXMnIOWvueixoSIKIAotIzogc2hhMS1maWxlLmM6MjIxNyBidWlsdGluL2luZGV4LXBhY2suYzoxNTUKKyM6IHNoYTEtZmlsZS5jOjIyMTMgYnVpbHRpbi9pbmRleC1wYWNrLmM6MTU1CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBvcGVuICVzIgogbXNnc3RyICLkuI3og73miZPlvIAgJXMiCiAKLSM6IHNoYTEtZmlsZS5jOjI0MDcgc2hhMS1maWxlLmM6MjQ1OQorIzogc2hhMS1maWxlLmM6MjQwMyBzaGExLWZpbGUuYzoyNDU1CiAjLCBjLWZvcm1hdAogbXNnaWQgImhhc2ggbWlzbWF0Y2ggZm9yICVzIChleHBlY3RlZCAlcykiCiBtc2dzdHIgIiVzIOeahOWTiOW4jOWAvOS4jeWMuemFje+8iOmihOacnyAlc++8iSIKIAotIzogc2hhMS1maWxlLmM6MjQzMQorIzogc2hhMS1maWxlLmM6MjQyNwogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gbW1hcCAlcyIKIG1zZ3N0ciAi5LiN6IO9IG1tYXAgJXMiCiAKLSM6IHNoYTEtZmlsZS5jOjI0MzYKKyM6IHNoYTEtZmlsZS5jOjI0MzIKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHVucGFjayBoZWFkZXIgb2YgJXMiCiBtc2dzdHIgIuaXoOazleino+WOi+e8qSAlcyDnmoTlpLTpg6giCiAKLSM6IHNoYTEtZmlsZS5jOjI0NDIKKyM6IHNoYTEtZmlsZS5jOjI0MzgKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHBhcnNlIGhlYWRlciBvZiAlcyIKIG1zZ3N0ciAi5peg5rOV6Kej5p6QICVzIOeahOWktOmDqCIKIAotIzogc2hhMS1maWxlLmM6MjQ1MworIzogc2hhMS1maWxlLmM6MjQ0OQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gdW5wYWNrIGNvbnRlbnRzIG9mICVzIgogbXNnc3RyICLml6Dms5Xop6PljovnvKkgJXMg55qE5YaF5a65IgogCi0jOiBzaGExLW5hbWUuYzo0OTAKKyM6IHNoYTEtbmFtZS5jOjQ4NwogIywgYy1mb3JtYXQKIG1zZ2lkICJzaG9ydCBTSEExICVzIGlzIGFtYmlndW91cyIKIG1zZ3N0ciAi55+tIFNIQTEgJXMg5a2Y5Zyo5q2n5LmJIgogCi0jOiBzaGExLW5hbWUuYzo1MDEKKyM6IHNoYTEtbmFtZS5jOjQ5OAogbXNnaWQgIlRoZSBjYW5kaWRhdGVzIGFyZToiCiBtc2dzdHIgIuWAmemAieiAheacie+8miIKIAotIzogc2hhMS1uYW1lLmM6ODAwCisjOiBzaGExLW5hbWUuYzo3OTcKIG1zZ2lkICIiCiAiR2l0IG5vcm1hbGx5IG5ldmVyIGNyZWF0ZXMgYSByZWYgdGhhdCBlbmRzIHdpdGggNDAgaGV4IGNoYXJhY3RlcnNcbiIKICJiZWNhdXNlIGl0IHdpbGwgYmUgaWdub3JlZCB3aGVuIHlvdSBqdXN0IHNwZWNpZnkgNDAtaGV4LiBUaGVzZSByZWZzXG4iCkBAIC03MDQ5LDQzICs3MDc0LDQzIEBACiAiZmFsc2VcIiDlkb3ku6TlhbPpl63mnKzmtojmga/pgJrnn6XjgIIiCiAKICMuIFRSQU5TTEFUT1JTOiBJRUMgODAwMDAtMTM6MjAwOCBnaWJpYnl0ZQotIzogc3RyYnVmLmM6ODIxCisjOiBzdHJidWYuYzo4MjIKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXUuJTIuMnUgR2lCIgogbXNnc3RyICIldS4lMi4ydSBHaUIiCiAKICMuIFRSQU5TTEFUT1JTOiBJRUMgODAwMDAtMTM6MjAwOCBnaWJpYnl0ZS9zZWNvbmQKLSM6IHN0cmJ1Zi5jOjgyMworIzogc3RyYnVmLmM6ODI0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiV1LiUyLjJ1IEdpQi9zIgogbXNnc3RyICIldS4lMi4ydSBHaUIvcyIKIAogIy4gVFJBTlNMQVRPUlM6IElFQyA4MDAwMC0xMzoyMDA4IG1lYmlieXRlCi0jOiBzdHJidWYuYzo4MzEKKyM6IHN0cmJ1Zi5jOjgzMgogIywgYy1mb3JtYXQKIG1zZ2lkICIldS4lMi4ydSBNaUIiCiBtc2dzdHIgIiV1LiUyLjJ1IE1pQiIKIAogIy4gVFJBTlNMQVRPUlM6IElFQyA4MDAwMC0xMzoyMDA4IG1lYmlieXRlL3NlY29uZAotIzogc3RyYnVmLmM6ODMzCisjOiBzdHJidWYuYzo4MzQKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXUuJTIuMnUgTWlCL3MiCiBtc2dzdHIgIiV1LiUyLjJ1IE1pQi9zIgogCiAjLiBUUkFOU0xBVE9SUzogSUVDIDgwMDAwLTEzOjIwMDgga2liaWJ5dGUKLSM6IHN0cmJ1Zi5jOjg0MAorIzogc3RyYnVmLmM6ODQxCiAjLCBjLWZvcm1hdAogbXNnaWQgIiV1LiUyLjJ1IEtpQiIKIG1zZ3N0ciAiJXUuJTIuMnUgS2lCIgogCiAjLiBUUkFOU0xBVE9SUzogSUVDIDgwMDAwLTEzOjIwMDgga2liaWJ5dGUvc2Vjb25kCi0jOiBzdHJidWYuYzo4NDIKKyM6IHN0cmJ1Zi5jOjg0MwogIywgYy1mb3JtYXQKIG1zZ2lkICIldS4lMi4ydSBLaUIvcyIKIG1zZ3N0ciAiJXUuJTIuMnUgS2lCL3MiCiAKICMuIFRSQU5TTEFUT1JTOiBJRUMgODAwMDAtMTM6MjAwOCBieXRlCi0jOiBzdHJidWYuYzo4NDgKKyM6IHN0cmJ1Zi5jOjg0OQogIywgYy1mb3JtYXQKIG1zZ2lkICIldSBieXRlIgogbXNnaWRfcGx1cmFsICIldSBieXRlcyIKQEAgLTcwOTMsNyArNzExOCw3IEBACiBtc2dzdHJbMV0gIiV1IOWtl+iKgiIKIAogIy4gVFJBTlNMQVRPUlM6IElFQyA4MDAwMC0xMzoyMDA4IGJ5dGUvc2Vjb25kCi0jOiBzdHJidWYuYzo4NTAKKyM6IHN0cmJ1Zi5jOjg1MQogIywgYy1mb3JtYXQKIG1zZ2lkICIldSBieXRlL3MiCiBtc2dpZF9wbHVyYWwgIiV1IGJ5dGVzL3MiCkBAIC03MjA4LDI2ICs3MjMzLDI2IEBACiBtc2dpZCAibHMtdHJlZSByZXR1cm5lZCB1bmV4cGVjdGVkIHJldHVybiBjb2RlICVkIgogbXNnc3RyICJscy10cmVlIOi/lOWbnuacquefpei/lOWbnuWAvCAlZCIKIAotIzogc3VibW9kdWxlLWNvbmZpZy5jOjIzMgorIzogc3VibW9kdWxlLWNvbmZpZy5jOjIzNgogIywgYy1mb3JtYXQKIG1zZ2lkICJpZ25vcmluZyBzdXNwaWNpb3VzIHN1Ym1vZHVsZSBuYW1lOiAlcyIKIG1zZ3N0ciAi5b+955Wl5Y+v55aR55qE5a2Q5qih57uE5ZCN56ew77yaJXMiCiAKLSM6IHN1Ym1vZHVsZS1jb25maWcuYzoyOTkKKyM6IHN1Ym1vZHVsZS1jb25maWcuYzozMDMKIG1zZ2lkICJuZWdhdGl2ZSB2YWx1ZXMgbm90IGFsbG93ZWQgZm9yIHN1Ym1vZHVsZS5mZXRjaGpvYnMiCiBtc2dzdHIgInN1Ym1vZHVsZS5mZXRjaGpvYnMg5LiN5YWB6K645Li66LSf5YC8IgogCi0jOiBzdWJtb2R1bGUtY29uZmlnLmM6Mzk3CisjOiBzdWJtb2R1bGUtY29uZmlnLmM6NDAxCiAjLCBjLWZvcm1hdAogbXNnaWQgImlnbm9yaW5nICclcycgd2hpY2ggbWF5IGJlIGludGVycHJldGVkIGFzIGEgY29tbWFuZC1saW5lIG9wdGlvbjogJXMiCiBtc2dzdHIgIuW/veeVpeWPr+iDveiiq+ino+aekOS4uuWRveS7pOihjOmAiemhueeahCAnJXMn77yaJXMiCiAKLSM6IHN1Ym1vZHVsZS1jb25maWcuYzo0ODYKKyM6IHN1Ym1vZHVsZS1jb25maWcuYzo0OTAKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCB2YWx1ZSBmb3IgJXMiCiBtc2dzdHIgIiVzIOeahOWAvOaXoOaViCIKIAotIzogc3VibW9kdWxlLWNvbmZpZy5jOjc1NQorIzogc3VibW9kdWxlLWNvbmZpZy5jOjc2MQogIywgYy1mb3JtYXQKIG1zZ2lkICJDb3VsZCBub3QgdXBkYXRlIC5naXRtb2R1bGVzIGVudHJ5ICVzIgogbXNnc3RyICLkuI3og73mm7TmlrAgLmdpdG1vZHVsZXMg5p2h55uuICVzIgpAQCAtNzI2Miw3ICs3Mjg3LDcgQEAKIG1zZ2lkICJjb3VsZCBub3QgcmVhZCBmcm9tIHN0ZGluIgogbXNnc3RyICLkuI3og73oh6rmoIflh4bovpPlhaXor7vlj5YiCiAKLSM6IHRyYWlsZXIuYzoxMDExIHdyYXBwZXIuYzo3MDEKKyM6IHRyYWlsZXIuYzoxMDExIHdyYXBwZXIuYzo2NjUKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHN0YXQgJXMiCiBtc2dzdHIgIuS4jeiDveWvuSAlcyDosIPnlKggc3RhdCIKQEAgLTcyOTEsNTQgKzczMTYsNTQgQEAKIG1zZ2lkICJXb3VsZCBzZXQgdXBzdHJlYW0gb2YgJyVzJyB0byAnJXMnIG9mICclcydcbiIKIG1zZ3N0ciAi5bCG6KaB6K6+572uICclMSRzJyDnmoTkuIrmuLjkuLogJyUzJHMnIOeahCAnJTIkcydcbiIKIAotIzogdHJhbnNwb3J0LmM6MTQyCisjOiB0cmFuc3BvcnQuYzoxNDUKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHJlYWQgYnVuZGxlICclcyciCiBtc2dzdHIgIuaXoOazleivu+WPliBidW5kbGUgJyVzJyIKIAotIzogdHJhbnNwb3J0LmM6MjA4CisjOiB0cmFuc3BvcnQuYzoyMTQKICMsIGMtZm9ybWF0CiBtc2dpZCAidHJhbnNwb3J0OiBpbnZhbGlkIGRlcHRoIG9wdGlvbiAnJXMnIgogbXNnc3RyICLkvKDovpPvvJrml6DmlYjnmoTmt7HluqbpgInpobkgJyVzJyIKIAotIzogdHJhbnNwb3J0LmM6MjU5CisjOiB0cmFuc3BvcnQuYzoyNjYKIG1zZ2lkICJzZWUgcHJvdG9jb2wudmVyc2lvbiBpbiAnZ2l0IGhlbHAgY29uZmlnJyBmb3IgbW9yZSBkZXRhaWxzIgogbXNnc3RyICLmn6XnnIsgJ2dpdCBoZWxwIGNvbmZpZycg5Lit55qEIHByb3RvY29sLnZlcnNpb24g6I635Y+W5pu05aSa5L+h5oGvIgogCi0jOiB0cmFuc3BvcnQuYzoyNjAKKyM6IHRyYW5zcG9ydC5jOjI2NwogbXNnaWQgInNlcnZlciBvcHRpb25zIHJlcXVpcmUgcHJvdG9jb2wgdmVyc2lvbiAyIG9yIGxhdGVyIgogbXNnc3RyICLmnI3liqHnq6/pgInpobnpnIDopoHniYjmnKwgMiDljY/orq7miJbmm7Tpq5giCiAKLSM6IHRyYW5zcG9ydC5jOjYyNQorIzogdHJhbnNwb3J0LmM6NjMyCiBtc2dpZCAiY291bGQgbm90IHBhcnNlIHRyYW5zcG9ydC5jb2xvci4qIGNvbmZpZyIKIG1zZ3N0ciAi5LiN6IO96Kej5p6QIHRyYW5zcG9ydC5jb2xvci4qIOmFjee9riIKIAotIzogdHJhbnNwb3J0LmM6Njk4CisjOiB0cmFuc3BvcnQuYzo3MDUKIG1zZ2lkICJzdXBwb3J0IGZvciBwcm90b2NvbCB2MiBub3QgaW1wbGVtZW50ZWQgeWV0IgogbXNnc3RyICLljY/orq4gdjIg55qE5pSv5oyB5bCa5pyq5a6e546wIgogCi0jOiB0cmFuc3BvcnQuYzo4MjUKKyM6IHRyYW5zcG9ydC5jOjgzMQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmtub3duIHZhbHVlIGZvciBjb25maWcgJyVzJzogJXMiCiBtc2dzdHIgIumFjee9riAnJXMnIOeahOWPluWAvOacquefpe+8miVzIgogCi0jOiB0cmFuc3BvcnQuYzo4OTEKKyM6IHRyYW5zcG9ydC5jOjg5NwogIywgYy1mb3JtYXQKIG1zZ2lkICJ0cmFuc3BvcnQgJyVzJyBub3QgYWxsb3dlZCIKIG1zZ3N0ciAi5Lyg6L6TICclcycg5LiN5YWB6K64IgogCi0jOiB0cmFuc3BvcnQuYzo5NDUKKyM6IHRyYW5zcG9ydC5jOjk0OQogbXNnaWQgImdpdC1vdmVyLXJzeW5jIGlzIG5vIGxvbmdlciBzdXBwb3J0ZWQiCiBtc2dzdHIgIuS4jeWGjeaUr+aMgSBnaXQtb3Zlci1yc3luYyIKIAotIzogdHJhbnNwb3J0LmM6MTA0MAorIzogdHJhbnNwb3J0LmM6MTA0NAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiVGhlIGZvbGxvd2luZyBzdWJtb2R1bGUgcGF0aHMgY29udGFpbiBjaGFuZ2VzIHRoYXQgY2FuXG4iCiAibm90IGJlIGZvdW5kIG9uIGFueSByZW1vdGU6XG4iCiBtc2dzdHIgIuS4i+WIl+WtkOaooee7hOi3r+W+hOaJgOWMheWQq+eahOS/ruaUueWcqOS7u+S9lei/nOeoi+a6kOS4remDveaJvuS4jeWIsO+8mlxuIgogCi0jOiB0cmFuc3BvcnQuYzoxMDQ0CisjOiB0cmFuc3BvcnQuYzoxMDQ4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJcbiIKQEAgLTczNjUsMTMxICs3MzkwLDEzNiBAQAogIuS7peaOqOmAgeiHs+i/nOeoi+OAglxuIgogIlxuIgogCi0jOiB0cmFuc3BvcnQuYzoxMDUyCisjOiB0cmFuc3BvcnQuYzoxMDU2CiBtc2dpZCAiQWJvcnRpbmcuIgogbXNnc3RyICLmraPlnKjnu4jmraLjgIIiCiAKLSM6IHRyYW5zcG9ydC5jOjExOTMKKyM6IHRyYW5zcG9ydC5jOjEyMDEKIG1zZ2lkICJmYWlsZWQgdG8gcHVzaCBhbGwgbmVlZGVkIHN1Ym1vZHVsZXMiCiBtc2dzdHIgIuS4jeiDveaOqOmAgeWFqOmDqOmcgOimgeeahOWtkOaooee7hCIKIAotIzogdHJhbnNwb3J0LmM6MTM0MCB0cmFuc3BvcnQtaGVscGVyLmM6NjQ1CisjOiB0cmFuc3BvcnQuYzoxMzQ1IHRyYW5zcG9ydC1oZWxwZXIuYzo2NTUKIG1zZ2lkICJvcGVyYXRpb24gbm90IHN1cHBvcnRlZCBieSBwcm90b2NvbCIKIG1zZ3N0ciAi5Y2P6K6u5LiN5pSv5oyB6K+l5pON5L2cIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6NTEgdHJhbnNwb3J0LWhlbHBlci5jOjgwCisjOiB0cmFuc3BvcnQtaGVscGVyLmM6NjEgdHJhbnNwb3J0LWhlbHBlci5jOjkwCiBtc2dpZCAiZnVsbCB3cml0ZSB0byByZW1vdGUgaGVscGVyIGZhaWxlZCIKIG1zZ3N0ciAi5a6M5pW05YaZ5YWl6L+c56iL5Yqp5omL5aSx6LSlIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6MTM0CisjOiB0cmFuc3BvcnQtaGVscGVyLmM6MTQ0CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBmaW5kIHJlbW90ZSBoZWxwZXIgZm9yICclcyciCiBtc2dzdHIgIuaXoOazleS4uiAnJXMnIOaJvuWIsOi/nOeoi+WKqeaJiyIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjE1MCB0cmFuc3BvcnQtaGVscGVyLmM6NTU5CisjOiB0cmFuc3BvcnQtaGVscGVyLmM6MTYwIHRyYW5zcG9ydC1oZWxwZXIuYzo1NjkKIG1zZ2lkICJjYW4ndCBkdXAgaGVscGVyIG91dHB1dCBmZCIKIG1zZ3N0ciAi5peg5rOV5aSN5Yi25Yqp5omL6L6T5Ye65paH5Lu25Y+l5p+EIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6MjAxCisjOiB0cmFuc3BvcnQtaGVscGVyLmM6MjExCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJ1bmtub3duIG1hbmRhdG9yeSBjYXBhYmlsaXR5ICVzOyB0aGlzIHJlbW90ZSBoZWxwZXIgcHJvYmFibHkgbmVlZHMgbmV3ZXIgIgogInZlcnNpb24gb2YgR2l0IgogbXNnc3RyICLmnKrnn6XnmoTlvLrliLbog73lipsgJXPvvIzor6Xov5znqIvliqnmiYvlj6/og73pnIDopoHmlrDniYjmnKznmoRHaXQiCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzoyMDcKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzoyMTcKIG1zZ2lkICJ0aGlzIHJlbW90ZSBoZWxwZXIgc2hvdWxkIGltcGxlbWVudCByZWZzcGVjIGNhcGFiaWxpdHkiCiBtc2dzdHIgIui/nOeoi+WKqeaJi+mcgOimgeWunueOsCByZWZzcGVjIOiDveWKmyIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjI3NCB0cmFuc3BvcnQtaGVscGVyLmM6NDE0CisjOiB0cmFuc3BvcnQtaGVscGVyLmM6Mjg0IHRyYW5zcG9ydC1oZWxwZXIuYzo0MjQKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgdW5leHBlY3RlZGx5IHNhaWQ6ICclcyciCiBtc2dzdHIgIiVzIOaEj+WkluWcsOivtO+8miclcyciCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzo0MDMKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzo0MTMKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgYWxzbyBsb2NrZWQgJXMiCiBtc2dzdHIgIiVzIOS5n+mUgeWumuS6hiAlcyIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjQ4MQorIzogdHJhbnNwb3J0LWhlbHBlci5jOjQ5MQogbXNnaWQgImNvdWxkbid0IHJ1biBmYXN0LWltcG9ydCIKIG1zZ3N0ciAi5LiN6IO95omn6KGMIGZhc3QtaW1wb3J0IgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6NTA0CisjOiB0cmFuc3BvcnQtaGVscGVyLmM6NTE0CiBtc2dpZCAiZXJyb3Igd2hpbGUgcnVubmluZyBmYXN0LWltcG9ydCIKIG1zZ3N0ciAi5omn6KGMIGZhc3QtaW1wb3J0IOWHuumUmSIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjUzMyB0cmFuc3BvcnQtaGVscGVyLmM6MTEwNQorIzogdHJhbnNwb3J0LWhlbHBlci5jOjU0MyB0cmFuc3BvcnQtaGVscGVyLmM6MTEzMgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcmVhZCByZWYgJXMiCiBtc2dzdHIgIuaXoOazleivu+WPluW8leeUqCAlcyIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjU3OAorIzogdHJhbnNwb3J0LWhlbHBlci5jOjU4OAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmtub3duIHJlc3BvbnNlIHRvIGNvbm5lY3Q6ICVzIgogbXNnc3RyICLov57mjqXml7bmnKrnn6XnmoTlk43lupTvvJolcyIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjYwMAorIzogdHJhbnNwb3J0LWhlbHBlci5jOjYxMAogbXNnaWQgInNldHRpbmcgcmVtb3RlIHNlcnZpY2UgcGF0aCBub3Qgc3VwcG9ydGVkIGJ5IHByb3RvY29sIgogbXNnc3RyICLljY/orq7kuI3mlK/mjIHorr7nva7ov5znqIvmnI3liqHot6/lvoQiCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzo2MDIKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzo2MTIKIG1zZ2lkICJpbnZhbGlkIHJlbW90ZSBzZXJ2aWNlIHBhdGgiCiBtc2dzdHIgIuaXoOaViOeahOi/nOeoi+acjeWKoei3r+W+hCIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjY0OAorIzogdHJhbnNwb3J0LWhlbHBlci5jOjY1OAogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW4ndCBjb25uZWN0IHRvIHN1YnNlcnZpY2UgJXMiCiBtc2dzdHIgIuS4jeiDvei/nuaOpeWIsOWtkOacjeWKoSAlcyIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjcyMAorIzogdHJhbnNwb3J0LWhlbHBlci5jOjczNAogIywgYy1mb3JtYXQKIG1zZ2lkICJleHBlY3RlZCBvay9lcnJvciwgaGVscGVyIHNhaWQgJyVzJyIKIG1zZ3N0ciAi6aKE5pyfIG9rL2Vycm9y77yM5Yqp5omL6K+0ICclcyciCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzo3NzMKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzo3ODcKICMsIGMtZm9ybWF0CiBtc2dpZCAiaGVscGVyIHJlcG9ydGVkIHVuZXhwZWN0ZWQgc3RhdHVzIG9mICVzIgogbXNnc3RyICLliqnmiYvmiqXlkYogJXMg55qE5oSP5aSW54q25oCBIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6ODM0CisjOiB0cmFuc3BvcnQtaGVscGVyLmM6ODQ4CiAjLCBjLWZvcm1hdAogbXNnaWQgImhlbHBlciAlcyBkb2VzIG5vdCBzdXBwb3J0IGRyeS1ydW4iCiBtc2dzdHIgIuWKqeaJiyAlcyDkuI3mlK/mjIEgZHJ5LXJ1biIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjgzNworIzogdHJhbnNwb3J0LWhlbHBlci5jOjg1MQogIywgYy1mb3JtYXQKIG1zZ2lkICJoZWxwZXIgJXMgZG9lcyBub3Qgc3VwcG9ydCAtLXNpZ25lZCIKIG1zZ3N0ciAi5Yqp5omLICVzIOS4jeaUr+aMgSAtLXNpZ25lZCIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjg0MAorIzogdHJhbnNwb3J0LWhlbHBlci5jOjg1NAogIywgYy1mb3JtYXQKIG1zZ2lkICJoZWxwZXIgJXMgZG9lcyBub3Qgc3VwcG9ydCAtLXNpZ25lZD1pZi1hc2tlZCIKIG1zZ3N0ciAi5Yqp5omLICVzIOS4jeaUr+aMgSAtLXNpZ25lZD1pZi1hc2tlZCIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjg0NworIzogdHJhbnNwb3J0LWhlbHBlci5jOjg1OQorIywgYy1mb3JtYXQKK21zZ2lkICJoZWxwZXIgJXMgZG9lcyBub3Qgc3VwcG9ydCAtLWF0b21pYyIKK21zZ3N0ciAi5Yqp5omLICVzIOS4jeaUr+aMgSAtLWF0b21pYyIKKworIzogdHJhbnNwb3J0LWhlbHBlci5jOjg2NQogIywgYy1mb3JtYXQKIG1zZ2lkICJoZWxwZXIgJXMgZG9lcyBub3Qgc3VwcG9ydCAncHVzaC1vcHRpb24nIgogbXNnc3RyICLliqnmiYsgJXMg5LiN5pSv5oyBICdwdXNoLW9wdGlvbiciCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzo5NDUKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzo5NjMKIG1zZ2lkICJyZW1vdGUtaGVscGVyIGRvZXNuJ3Qgc3VwcG9ydCBwdXNoOyByZWZzcGVjIG5lZWRlZCIKIG1zZ3N0ciAicmVtb3RlLWhlcGVyIOS4jeaUr+aMgSBwdXNo77yM6ZyA6KaB5byV55So6KGo6L6+5byPIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6OTUwCisjOiB0cmFuc3BvcnQtaGVscGVyLmM6OTY4CiAjLCBjLWZvcm1hdAogbXNnaWQgImhlbHBlciAlcyBkb2VzIG5vdCBzdXBwb3J0ICdmb3JjZSciCiBtc2dzdHIgIuWKqeaJiyAlcyDkuI3mlK/mjIEgJ2ZvcmNlJyIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjk5NworIzogdHJhbnNwb3J0LWhlbHBlci5jOjEwMTUKIG1zZ2lkICJjb3VsZG4ndCBydW4gZmFzdC1leHBvcnQiCiBtc2dzdHIgIuaXoOazleaJp+ihjCBmYXN0LWV4cG9ydCIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjEwMDIKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxMDIwCiBtc2dpZCAiZXJyb3Igd2hpbGUgcnVubmluZyBmYXN0LWV4cG9ydCIKIG1zZ3N0ciAi5omn6KGMIGZhc3QtZXhwb3J0IOaXtuWHuumUmSIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjEwMjcKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxMDQ1CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJObyByZWZzIGluIGNvbW1vbiBhbmQgbm9uZSBzcGVjaWZpZWQ7IGRvaW5nIG5vdGhpbmcuXG4iCkBAIC03NDk4LDQ3ICs3NTI4LDQ3IEBACiAi5rKh5pyJ5YWx5ZCM55qE5byV55So5bm25LiU5Lmf5rKh5pyJ5oyH5a6a77yM5LuA5LmI5Lmf5LiN5Lya5YGa44CCXG4iCiAi5Y+v6IO95oKo5bqU6K+l5oyH5a6a5LiA5Liq5YiG5pSv5aaCICdtYXN0ZXIn44CCXG4iCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxMDkxCisjOiB0cmFuc3BvcnQtaGVscGVyLmM6MTExOAogIywgYy1mb3JtYXQKIG1zZ2lkICJtYWxmb3JtZWQgcmVzcG9uc2UgaW4gcmVmIGxpc3Q6ICVzIgogbXNnc3RyICLlvJXnlKjliJfooajkuK3moLzlvI/plJnor6/nmoTlk43lupTvvJolcyIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjEyNDQKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxMjcwCiAjLCBjLWZvcm1hdAogbXNnaWQgInJlYWQoJXMpIGZhaWxlZCIKIG1zZ3N0ciAi6K+75Y+W77yIJXPvvInlpLHotKUiCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxMjcxCisjOiB0cmFuc3BvcnQtaGVscGVyLmM6MTI5NwogIywgYy1mb3JtYXQKIG1zZ2lkICJ3cml0ZSglcykgZmFpbGVkIgogbXNnc3RyICLlhpnvvIglc++8ieWksei0pSIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjEzMjAKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxMzQ2CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIHRocmVhZCBmYWlsZWQiCiBtc2dzdHIgIiVzIOe6v+eoi+Wksei0pSIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjEzMjQKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxMzUwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIHRocmVhZCBmYWlsZWQgdG8gam9pbjogJXMiCiBtc2dzdHIgIiVzIOe6v+eoi+etieW+heWksei0pe+8miVzIgogCi0jOiB0cmFuc3BvcnQtaGVscGVyLmM6MTM0MyB0cmFuc3BvcnQtaGVscGVyLmM6MTM0NworIzogdHJhbnNwb3J0LWhlbHBlci5jOjEzNjkgdHJhbnNwb3J0LWhlbHBlci5jOjEzNzMKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2FuJ3Qgc3RhcnQgdGhyZWFkIGZvciBjb3B5aW5nIGRhdGE6ICVzIgogbXNnc3RyICLkuI3og73lkK/liqjnur/nqIvmnaXmi7fotJ3mlbDmja7vvJolcyIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjEzODQKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxNDEwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIHByb2Nlc3MgZmFpbGVkIHRvIHdhaXQiCiBtc2dzdHIgIiVzIOi/m+eoi+etieW+heWksei0pSIKIAotIzogdHJhbnNwb3J0LWhlbHBlci5jOjEzODgKKyM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxNDE0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIHByb2Nlc3MgZmFpbGVkIgogbXNnc3RyICIlcyDov5vnqIvlpLHotKUiCiAKLSM6IHRyYW5zcG9ydC1oZWxwZXIuYzoxNDA2IHRyYW5zcG9ydC1oZWxwZXIuYzoxNDE1CisjOiB0cmFuc3BvcnQtaGVscGVyLmM6MTQzMiB0cmFuc3BvcnQtaGVscGVyLmM6MTQ0MQogbXNnaWQgImNhbid0IHN0YXJ0IHRocmVhZCBmb3IgY29weWluZyBkYXRhIgogbXNnc3RyICLkuI3og73lkK/liqjnur/nqIvmnaXmi7fotJ3mlbDmja4iCiAKQEAgLTc1NTgsNyArNzU4OCw3IEBACiBtc2dpZCAidG9vLXNob3J0IHRyZWUgZmlsZSIKIG1zZ3N0ciAi5aSq55+t55qE5qCR5paH5Lu2IgogCi0jOiB1bnBhY2stdHJlZXMuYzoxMTEKKyM6IHVucGFjay10cmVlcy5jOjExMAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiWW91ciBsb2NhbCBjaGFuZ2VzIHRvIHRoZSBmb2xsb3dpbmcgZmlsZXMgd291bGQgYmUgb3ZlcndyaXR0ZW4gYnkgY2hlY2tvdXQ6XG4iCkBAIC03NTY3LDcgKzc1OTcsNyBAQAogIuaCqOWvueS4i+WIl+aWh+S7tueahOacrOWcsOS/ruaUueWwhuiiq+ajgOWHuuaTjeS9nOimhueblu+8mlxuIgogIiUlc+ivt+WcqOWIh+aNouWIhuaUr+WJjeaPkOS6pOaIlui0ruiXj+aCqOeahOS/ruaUueOAgiIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTEzCisjOiB1bnBhY2stdHJlZXMuYzoxMTIKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIllvdXIgbG9jYWwgY2hhbmdlcyB0byB0aGUgZm9sbG93aW5nIGZpbGVzIHdvdWxkIGJlIG92ZXJ3cml0dGVuIGJ5IGNoZWNrb3V0OlxuIgpAQCAtNzU3Niw3ICs3NjA2LDcgQEAKICLmgqjlr7nkuIvliJfmlofku7bnmoTmnKzlnLDkv67mlLnlsIbooqvmo4Dlh7rmk43kvZzopobnm5bvvJpcbiIKICIlJXMiCiAKLSM6IHVucGFjay10cmVlcy5jOjExNgorIzogdW5wYWNrLXRyZWVzLmM6MTE1CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJZb3VyIGxvY2FsIGNoYW5nZXMgdG8gdGhlIGZvbGxvd2luZyBmaWxlcyB3b3VsZCBiZSBvdmVyd3JpdHRlbiBieSBtZXJnZTpcbiIKQEAgLTc1ODUsNyArNzYxNSw3IEBACiAi5oKo5a+55LiL5YiX5paH5Lu255qE5pys5Zyw5L+u5pS55bCG6KKr5ZCI5bm25pON5L2c6KaG55uW77yaXG4iCiAiJSVz6K+35Zyo5ZCI5bm25YmN5o+Q5Lqk5oiW6LSu6JeP5oKo55qE5L+u5pS544CCIgogCi0jOiB1bnBhY2stdHJlZXMuYzoxMTgKKyM6IHVucGFjay10cmVlcy5jOjExNwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiWW91ciBsb2NhbCBjaGFuZ2VzIHRvIHRoZSBmb2xsb3dpbmcgZmlsZXMgd291bGQgYmUgb3ZlcndyaXR0ZW4gYnkgbWVyZ2U6XG4iCkBAIC03NTk0LDcgKzc2MjQsNyBAQAogIuaCqOWvueS4i+WIl+aWh+S7tueahOacrOWcsOS/ruaUueWwhuiiq+WQiOW5tuaTjeS9nOimhueblu+8mlxuIgogIiUlcyIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTIxCisjOiB1bnBhY2stdHJlZXMuYzoxMjAKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIllvdXIgbG9jYWwgY2hhbmdlcyB0byB0aGUgZm9sbG93aW5nIGZpbGVzIHdvdWxkIGJlIG92ZXJ3cml0dGVuIGJ5ICVzOlxuIgpAQCAtNzYwMyw3ICs3NjMzLDcgQEAKICLmgqjlr7nkuIvliJfmlofku7bnmoTmnKzlnLDkv67mlLnlsIbooqsgJXMg6KaG55uW77yaXG4iCiAiJSVz6K+35ZyoICVzIOS5i+WJjeaPkOS6pOaIlui0ruiXj+aCqOeahOS/ruaUueOAgiIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTIzCisjOiB1bnBhY2stdHJlZXMuYzoxMjIKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIllvdXIgbG9jYWwgY2hhbmdlcyB0byB0aGUgZm9sbG93aW5nIGZpbGVzIHdvdWxkIGJlIG92ZXJ3cml0dGVuIGJ5ICVzOlxuIgpAQCAtNzYxMiw3ICs3NjQyLDcgQEAKICLmgqjlr7nkuIvliJfmlofku7bnmoTmnKzlnLDkv67mlLnlsIbooqsgJXMg6KaG55uW77yaXG4iCiAiJSVzIgogCi0jOiB1bnBhY2stdHJlZXMuYzoxMjgKKyM6IHVucGFjay10cmVlcy5jOjEyNwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiVXBkYXRpbmcgdGhlIGZvbGxvd2luZyBkaXJlY3RvcmllcyB3b3VsZCBsb3NlIHVudHJhY2tlZCBmaWxlcyBpbiB0aGVtOlxuIgpAQCAtNzYyMSw3ICs3NjUxLDcgQEAKICLmm7TmlrDlpoLkuIvnm67lvZXlsIbkvJrkuKLlpLHlhbbkuK3mnKrot5/ouKrnmoTmlofku7bvvJpcbiIKICIlcyIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTMyCisjOiB1bnBhY2stdHJlZXMuYzoxMzEKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlRoZSBmb2xsb3dpbmcgdW50cmFja2VkIHdvcmtpbmcgdHJlZSBmaWxlcyB3b3VsZCBiZSByZW1vdmVkIGJ5IGNoZWNrb3V0OlxuIgpAQCAtNzYzMCw3ICs3NjYwLDcgQEAKICLlt6XkvZzljLrkuK3kuIvliJfmnKrot5/ouKrnmoTmlofku7blsIbkvJrlm6DkuLrmo4Dlh7rmk43kvZzogIzooqvliKDpmaTvvJpcbiIKICIlJXPor7flnKjliIfmjaLliIbmlK/kuYvliY3np7vliqjmiJbliKDpmaTjgIIiCiAKLSM6IHVucGFjay10cmVlcy5jOjEzNAorIzogdW5wYWNrLXRyZWVzLmM6MTMzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgZm9sbG93aW5nIHVudHJhY2tlZCB3b3JraW5nIHRyZWUgZmlsZXMgd291bGQgYmUgcmVtb3ZlZCBieSBjaGVja291dDpcbiIKQEAgLTc2MzksNyArNzY2OSw3IEBACiAi5bel5L2c5Yy65Lit5LiL5YiX5pyq6Lef6Liq55qE5paH5Lu25bCG5Lya5Zug5Li65qOA5Ye65pON5L2c6ICM6KKr5Yig6Zmk77yaXG4iCiAiJSVzIgogCi0jOiB1bnBhY2stdHJlZXMuYzoxMzcKKyM6IHVucGFjay10cmVlcy5jOjEzNgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiVGhlIGZvbGxvd2luZyB1bnRyYWNrZWQgd29ya2luZyB0cmVlIGZpbGVzIHdvdWxkIGJlIHJlbW92ZWQgYnkgbWVyZ2U6XG4iCkBAIC03NjQ4LDcgKzc2NzgsNyBAQAogIuW3peS9nOWMuuS4reS4i+WIl+acqui3n+i4queahOaWh+S7tuWwhuS8muWboOS4uuWQiOW5tuaTjeS9nOiAjOiiq+WIoOmZpO+8mlxuIgogIiUlc+ivt+WcqOWQiOW5tuWJjeenu+WKqOaIluWIoOmZpOOAgiIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTM5CisjOiB1bnBhY2stdHJlZXMuYzoxMzgKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlRoZSBmb2xsb3dpbmcgdW50cmFja2VkIHdvcmtpbmcgdHJlZSBmaWxlcyB3b3VsZCBiZSByZW1vdmVkIGJ5IG1lcmdlOlxuIgpAQCAtNzY1Nyw3ICs3Njg3LDcgQEAKICLlt6XkvZzljLrkuK3kuIvliJfmnKrot5/ouKrnmoTmlofku7blsIbkvJrlm6DkuLrlkIjlubbmk43kvZzogIzooqvliKDpmaTvvJpcbiIKICIlJXMiCiAKLSM6IHVucGFjay10cmVlcy5jOjE0MgorIzogdW5wYWNrLXRyZWVzLmM6MTQxCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgZm9sbG93aW5nIHVudHJhY2tlZCB3b3JraW5nIHRyZWUgZmlsZXMgd291bGQgYmUgcmVtb3ZlZCBieSAlczpcbiIKQEAgLTc2NjYsNyArNzY5Niw3IEBACiAi5bel5L2c5Yy65Lit5LiL5YiX5pyq6Lef6Liq55qE5paH5Lu25bCG5Lya5Zug5Li6ICVzIOaTjeS9nOiAjOiiq+WIoOmZpO+8mlxuIgogIiUlc+ivt+WcqCAlcyDliY3np7vliqjmiJbliKDpmaTjgIIiCiAKLSM6IHVucGFjay10cmVlcy5jOjE0NAorIzogdW5wYWNrLXRyZWVzLmM6MTQzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgZm9sbG93aW5nIHVudHJhY2tlZCB3b3JraW5nIHRyZWUgZmlsZXMgd291bGQgYmUgcmVtb3ZlZCBieSAlczpcbiIKQEAgLTc2NzUsNyArNzcwNSw3IEBACiAi5bel5L2c5Yy65Lit5LiL5YiX5pyq6Lef6Liq55qE5paH5Lu25bCG5Lya5Zug5Li6ICVzIOaTjeS9nOiAjOiiq+WIoOmZpO+8mlxuIgogIiUlcyIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTUwCisjOiB1bnBhY2stdHJlZXMuYzoxNDkKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlRoZSBmb2xsb3dpbmcgdW50cmFja2VkIHdvcmtpbmcgdHJlZSBmaWxlcyB3b3VsZCBiZSBvdmVyd3JpdHRlbiBieSAiCkBAIC03Njg1LDcgKzc3MTUsNyBAQAogIuW3peS9nOWMuuS4reS4i+WIl+acqui3n+i4queahOaWh+S7tuWwhuS8muWboOS4uuajgOWHuuaTjeS9nOiAjOiiq+imhueblu+8mlxuIgogIiUlc+ivt+WcqOWIh+aNouWIhuaUr+WJjeenu+WKqOaIluWIoOmZpOOAgiIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTUyCisjOiB1bnBhY2stdHJlZXMuYzoxNTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlRoZSBmb2xsb3dpbmcgdW50cmFja2VkIHdvcmtpbmcgdHJlZSBmaWxlcyB3b3VsZCBiZSBvdmVyd3JpdHRlbiBieSAiCkBAIC03Njk1LDcgKzc3MjUsNyBAQAogIuW3peS9nOWMuuS4reS4i+WIl+acqui3n+i4queahOaWh+S7tuWwhuS8muWboOS4uuajgOWHuuaTjeS9nOiAjOiiq+imhueblu+8mlxuIgogIiUlcyIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTU1CisjOiB1bnBhY2stdHJlZXMuYzoxNTQKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlRoZSBmb2xsb3dpbmcgdW50cmFja2VkIHdvcmtpbmcgdHJlZSBmaWxlcyB3b3VsZCBiZSBvdmVyd3JpdHRlbiBieSBtZXJnZTpcbiIKQEAgLTc3MDQsNyArNzczNCw3IEBACiAi5bel5L2c5Yy65Lit5LiL5YiX5pyq6Lef6Liq55qE5paH5Lu25bCG5Lya5Zug5Li65ZCI5bm25pON5L2c6ICM6KKr6KaG55uW77yaXG4iCiAiJSVz6K+35Zyo5ZCI5bm25YmN56e75Yqo5oiW5Yig6Zmk44CCIgogCi0jOiB1bnBhY2stdHJlZXMuYzoxNTcKKyM6IHVucGFjay10cmVlcy5jOjE1NgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiVGhlIGZvbGxvd2luZyB1bnRyYWNrZWQgd29ya2luZyB0cmVlIGZpbGVzIHdvdWxkIGJlIG92ZXJ3cml0dGVuIGJ5IG1lcmdlOlxuIgpAQCAtNzcxMyw3ICs3NzQzLDcgQEAKICLlt6XkvZzljLrkuK3kuIvliJfmnKrot5/ouKrnmoTmlofku7blsIbkvJrlm6DkuLrlkIjlubbmk43kvZzogIzooqvopobnm5bvvJpcbiIKICIlJXMiCiAKLSM6IHVucGFjay10cmVlcy5jOjE2MAorIzogdW5wYWNrLXRyZWVzLmM6MTU5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgZm9sbG93aW5nIHVudHJhY2tlZCB3b3JraW5nIHRyZWUgZmlsZXMgd291bGQgYmUgb3ZlcndyaXR0ZW4gYnkgJXM6XG4iCkBAIC03NzIyLDcgKzc3NTIsNyBAQAogIuW3peS9nOWMuuS4reS4i+WIl+acqui3n+i4queahOaWh+S7tuWwhuS8muWboOS4uiAlcyDmk43kvZzogIzooqvopobnm5bvvJpcbiIKICIlJXPor7flnKggJXMg5YmN56e75Yqo5oiW5Yig6Zmk44CCIgogCi0jOiB1bnBhY2stdHJlZXMuYzoxNjIKKyM6IHVucGFjay10cmVlcy5jOjE2MQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiVGhlIGZvbGxvd2luZyB1bnRyYWNrZWQgd29ya2luZyB0cmVlIGZpbGVzIHdvdWxkIGJlIG92ZXJ3cml0dGVuIGJ5ICVzOlxuIgpAQCAtNzczMSwxMiArNzc2MSwxMiBAQAogIuW3peS9nOWMuuS4reS4i+WIl+acqui3n+i4queahOaWh+S7tuWwhuS8muWboOS4uiAlcyDmk43kvZzogIzooqvopobnm5bvvJpcbiIKICIlJXMiCiAKLSM6IHVucGFjay10cmVlcy5jOjE3MAorIzogdW5wYWNrLXRyZWVzLmM6MTY5CiAjLCBjLWZvcm1hdAogbXNnaWQgIkVudHJ5ICclcycgb3ZlcmxhcHMgd2l0aCAnJXMnLiAgQ2Fubm90IGJpbmQuIgogbXNnc3RyICLmnaHnm64gJyVzJyDlkowgJyVzJyDph43lj6DjgILml6Dms5XlkIjlubbjgIIiCiAKLSM6IHVucGFjay10cmVlcy5jOjE3MworIzogdW5wYWNrLXRyZWVzLmM6MTcyCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJDYW5ub3QgdXBkYXRlIHNwYXJzZSBjaGVja291dDogdGhlIGZvbGxvd2luZyBlbnRyaWVzIGFyZSBub3QgdXAgdG8gZGF0ZTpcbiIKQEAgLTc3NDUsNyArNzc3NSw3IEBACiAi5peg5rOV5pu05paw56iA55aP5qOA5Ye677ya5aaC5LiL5p2h55uu5LiN5piv5pyA5paw77yaXG4iCiAiJXMiCiAKLSM6IHVucGFjay10cmVlcy5jOjE3NQorIzogdW5wYWNrLXRyZWVzLmM6MTc0CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgZm9sbG93aW5nIHdvcmtpbmcgdHJlZSBmaWxlcyB3b3VsZCBiZSBvdmVyd3JpdHRlbiBieSBzcGFyc2UgY2hlY2tvdXQgIgpAQCAtNzc1NSw3ICs3Nzg1LDcgQEAKICLlt6XkvZzljLrkuK3kuIvliJfmlofku7blsIbooqvnqIDnlo/mo4Dlh7rmm7TmlrDmiYDopobnm5bvvJpcbiIKICIlcyIKIAotIzogdW5wYWNrLXRyZWVzLmM6MTc3CisjOiB1bnBhY2stdHJlZXMuYzoxNzYKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIlRoZSBmb2xsb3dpbmcgd29ya2luZyB0cmVlIGZpbGVzIHdvdWxkIGJlIHJlbW92ZWQgYnkgc3BhcnNlIGNoZWNrb3V0ICIKQEAgLTc3NjUsNyArNzc5NSw3IEBACiAi5bel5L2c5Yy65Lit5LiL5YiX5paH5Lu25bCG6KKr56iA55aP5qOA5Ye65pu05paw5omA5Yig6Zmk77yaXG4iCiAiJXMiCiAKLSM6IHVucGFjay10cmVlcy5jOjE3OQorIzogdW5wYWNrLXRyZWVzLmM6MTc4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJDYW5ub3QgdXBkYXRlIHN1Ym1vZHVsZTpcbiIKQEAgLTc3NzQsMTYgKzc4MDQsMTYgQEAKICLml6Dms5Xmm7TmlrDlrZDmqKHnu4TvvJpcbiIKICIlcyIKIAotIzogdW5wYWNrLXRyZWVzLmM6MjU2CisjOiB1bnBhY2stdHJlZXMuYzoyNTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiQWJvcnRpbmdcbiIKIG1zZ3N0ciAi5q2j5Zyo57uI5q2iXG4iCiAKLSM6IHVucGFjay10cmVlcy5jOjMxOAorIzogdW5wYWNrLXRyZWVzLmM6MzE3CiBtc2dpZCAiVXBkYXRpbmcgZmlsZXMiCiBtc2dzdHIgIuato+WcqOabtOaWsOaWh+S7tiIKIAotIzogdW5wYWNrLXRyZWVzLmM6MzUwCisjOiB1bnBhY2stdHJlZXMuYzozNDkKIG1zZ2lkICIiCiAidGhlIGZvbGxvd2luZyBwYXRocyBoYXZlIGNvbGxpZGVkIChlLmcuIGNhc2Utc2Vuc2l0aXZlIHBhdGhzXG4iCiAib24gYSBjYXNlLWluc2Vuc2l0aXZlIGZpbGVzeXN0ZW0pIGFuZCBvbmx5IG9uZSBmcm9tIHRoZSBzYW1lXG4iCkBAIC03ODIxLDcgKzc4NTEsNyBAQAogbXNnaWQgImludmFsaWQgJy4uJyBwYXRoIHNlZ21lbnQiCiBtc2dzdHIgIuaXoOaViOeahCAnLi4nIOi3r+W+hOeJh+autSIKIAotIzogd29ya3RyZWUuYzoyNTggYnVpbHRpbi9hbS5jOjIwOTUKKyM6IHdvcmt0cmVlLmM6MjU4IGJ1aWx0aW4vYW0uYzoyMDg0CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byByZWFkICclcyciCiBtc2dzdHIgIuivu+WPliAnJXMnIOWksei0pSIKQEAgLTc4NTEsMTcgKzc4ODEsMTcgQEAKIG1zZ2lkICInJXMnIGRvZXMgbm90IHBvaW50IGJhY2sgdG8gJyVzJyIKIG1zZ3N0ciAiJyVzJyDmsqHmnInmjIflm57liLAgJyVzJyIKIAotIzogd3JhcHBlci5jOjIyMyB3cmFwcGVyLmM6MzkzCisjOiB3cmFwcGVyLmM6MTg2IHdyYXBwZXIuYzozNTYKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IG9wZW4gJyVzJyBmb3IgcmVhZGluZyBhbmQgd3JpdGluZyIKIG1zZ3N0ciAi5peg5rOV5omT5byAICclcycg6L+b6KGM6K+75YaZIgogCi0jOiB3cmFwcGVyLmM6NDI0IHdyYXBwZXIuYzo2MjQKKyM6IHdyYXBwZXIuYzozODcgd3JhcHBlci5jOjU4OAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gYWNjZXNzICclcyciCiBtc2dzdHIgIuS4jeiDveiuv+mXriAnJXMnIgogCi0jOiB3cmFwcGVyLmM6NjMyCisjOiB3cmFwcGVyLmM6NTk2CiBtc2dpZCAidW5hYmxlIHRvIGdldCBjdXJyZW50IHdvcmtpbmcgZGlyZWN0b3J5IgogbXNnc3RyICLkuI3og73ojrflj5blvZPliY3lt6XkvZznm67lvZUiCiAKQEAgLTgyMTYsODUgKzgyNDYsOTUgQEAKIAogIyAg6K+R6ICF77ya5rOo5oSP5L+d5oyB5YmN5a+856m65qC8CiAjOiB3dC1zdGF0dXMuYzoxNDM3Cittc2dpZCAiICAodXNlIFwiZ2l0IGNoZXJyeS1waWNrIC0tc2tpcFwiIHRvIHNraXAgdGhpcyBwYXRjaCkiCittc2dzdHIgIiAg77yI5L2/55SoIFwiZ2l0IGNoZXJyeS1waWNrIC0tc2tpcFwiIOi3s+i/h+atpOihpeS4ge+8iSIKKworIyAg6K+R6ICF77ya5rOo5oSP5L+d5oyB5YmN5a+856m65qC8CisjOiB3dC1zdGF0dXMuYzoxNDM5CiBtc2dpZCAiICAodXNlIFwiZ2l0IGNoZXJyeS1waWNrIC0tYWJvcnRcIiB0byBjYW5jZWwgdGhlIGNoZXJyeS1waWNrIG9wZXJhdGlvbikiCiBtc2dzdHIgIiAg77yI5L2/55SoIFwiZ2l0IGNoZXJyeS1waWNrIC0tYWJvcnRcIiDku6Xlj5bmtojmi6PpgInmk43kvZzvvIkiCiAKLSM6IHd0LXN0YXR1cy5jOjE0NDcKKyM6IHd0LXN0YXR1cy5jOjE0NDkKIG1zZ2lkICJSZXZlcnQgY3VycmVudGx5IGluIHByb2dyZXNzLiIKIG1zZ3N0ciAi6L+Y5Y6f5pON5L2c5q2j5Zyo6KGM5Lit44CCIgogCi0jOiB3dC1zdGF0dXMuYzoxNDUwCisjOiB3dC1zdGF0dXMuYzoxNDUyCiAjLCBjLWZvcm1hdAogbXNnaWQgIllvdSBhcmUgY3VycmVudGx5IHJldmVydGluZyBjb21taXQgJXMuIgogbXNnc3RyICLmgqjlnKjmiafooYzlj43ovazmj5DkuqQgJXMg55qE5pON5L2c44CCIgogCiAjICDor5HogIXvvJrms6jmhI/kv53mjIHliY3lr7znqbrmoLwKLSM6IHd0LXN0YXR1cy5jOjE0NTYKKyM6IHd0LXN0YXR1cy5jOjE0NTgKIG1zZ2lkICIgIChmaXggY29uZmxpY3RzIGFuZCBydW4gXCJnaXQgcmV2ZXJ0IC0tY29udGludWVcIikiCiBtc2dzdHIgIiAg77yI6Kej5Yaz5Yay56qB5bm25omn6KGMIFwiZ2l0IHJldmVydCAtLWNvbnRpbnVlXCLvvIkiCiAKICMgIOivkeiAhe+8muazqOaEj+S/neaMgeWJjeWvvOepuuagvAotIzogd3Qtc3RhdHVzLmM6MTQ1OQorIzogd3Qtc3RhdHVzLmM6MTQ2MQogbXNnaWQgIiAgKHJ1biBcImdpdCByZXZlcnQgLS1jb250aW51ZVwiIHRvIGNvbnRpbnVlKSIKIG1zZ3N0ciAiICDvvIjmiafooYwgXCJnaXQgcmV2ZXJ0IC0tY29udGludWVcIiDku6Xnu6fnu63vvIkiCiAKICMgIOivkeiAhe+8muazqOaEj+S/neaMgeWJjeWvvOepuuagvAotIzogd3Qtc3RhdHVzLmM6MTQ2MgorIzogd3Qtc3RhdHVzLmM6MTQ2NAogbXNnaWQgIiAgKGFsbCBjb25mbGljdHMgZml4ZWQ6IHJ1biBcImdpdCByZXZlcnQgLS1jb250aW51ZVwiKSIKIG1zZ3N0ciAiICDvvIjmiYDmnInlhrLnqoHlt7Lop6PlhrPvvJrmiafooYwgXCJnaXQgcmV2ZXJ0IC0tY29udGludWVcIu+8iSIKIAogIyAg6K+R6ICF77ya5rOo5oSP5L+d5oyB5YmN5a+856m65qC8Ci0jOiB3dC1zdGF0dXMuYzoxNDY0CisjOiB3dC1zdGF0dXMuYzoxNDY2Cittc2dpZCAiICAodXNlIFwiZ2l0IHJldmVydCAtLXNraXBcIiB0byBza2lwIHRoaXMgcGF0Y2gpIgorbXNnc3RyICIgIO+8iOS9v+eUqCBcImdpdCByZXZlcnQgLS1za2lwXCIg6Lez6L+H5q2k6KGl5LiB77yJIgorCisjICDor5HogIXvvJrms6jmhI/kv53mjIHliY3lr7znqbrmoLwKKyM6IHd0LXN0YXR1cy5jOjE0NjgKIG1zZ2lkICIgICh1c2UgXCJnaXQgcmV2ZXJ0IC0tYWJvcnRcIiB0byBjYW5jZWwgdGhlIHJldmVydCBvcGVyYXRpb24pIgogbXNnc3RyICIgIO+8iOS9v+eUqCBcImdpdCByZXZlcnQgLS1hYm9ydFwiIOS7peWPlua2iOWPjei9rOaPkOS6pOaTjeS9nO+8iSIKIAotIzogd3Qtc3RhdHVzLmM6MTQ3NAorIzogd3Qtc3RhdHVzLmM6MTQ3OAogIywgYy1mb3JtYXQKIG1zZ2lkICJZb3UgYXJlIGN1cnJlbnRseSBiaXNlY3RpbmcsIHN0YXJ0ZWQgZnJvbSBicmFuY2ggJyVzJy4iCiBtc2dzdHIgIuaCqOWcqOaJp+ihjOS7juWIhuaUryAnJXMnIOW8gOWni+eahOS6jOWIhuafpeaJvuaTjeS9nOOAgiIKIAotIzogd3Qtc3RhdHVzLmM6MTQ3OAorIzogd3Qtc3RhdHVzLmM6MTQ4MgogbXNnaWQgIllvdSBhcmUgY3VycmVudGx5IGJpc2VjdGluZy4iCiBtc2dzdHIgIuaCqOWcqOaJp+ihjOS6jOWIhuafpeaJvuaTjeS9nOOAgiIKIAogIyAg6K+R6ICF77ya5rOo5oSP5L+d5oyB5YmN5a+856m65qC8Ci0jOiB3dC1zdGF0dXMuYzoxNDgxCisjOiB3dC1zdGF0dXMuYzoxNDg1CiBtc2dpZCAiICAodXNlIFwiZ2l0IGJpc2VjdCByZXNldFwiIHRvIGdldCBiYWNrIHRvIHRoZSBvcmlnaW5hbCBicmFuY2gpIgogbXNnc3RyICIgIO+8iOS9v+eUqCBcImdpdCBiaXNlY3QgcmVzZXRcIiDku6Xlm57liLDljp/mnInliIbmlK/vvIkiCiAKLSM6IHd0LXN0YXR1cy5jOjE2OTAKKyM6IHd0LXN0YXR1cy5jOjE2OTQKIG1zZ2lkICJPbiBicmFuY2ggIgogbXNnc3RyICLkvY3kuo7liIbmlK8gIgogCi0jOiB3dC1zdGF0dXMuYzoxNjk3CisjOiB3dC1zdGF0dXMuYzoxNzAxCiBtc2dpZCAiaW50ZXJhY3RpdmUgcmViYXNlIGluIHByb2dyZXNzOyBvbnRvICIKIG1zZ3N0ciAi5Lqk5LqS5byP5Y+Y5Z+65pON5L2c5q2j5Zyo6L+b6KGM5Lit77yb6IezICIKIAotIzogd3Qtc3RhdHVzLmM6MTY5OQorIzogd3Qtc3RhdHVzLmM6MTcwMwogbXNnaWQgInJlYmFzZSBpbiBwcm9ncmVzczsgb250byAiCiBtc2dzdHIgIuWPmOWfuuaTjeS9nOato+WcqOi/m+ihjOS4re+8m+iHsyAiCiAKLSM6IHd0LXN0YXR1cy5jOjE3MDkKKyM6IHd0LXN0YXR1cy5jOjE3MTMKIG1zZ2lkICJOb3QgY3VycmVudGx5IG9uIGFueSBicmFuY2guIgogbXNnc3RyICLlvZPliY3kuI3lnKjku7vkvZXliIbmlK/kuIrjgIIiCiAKLSM6IHd0LXN0YXR1cy5jOjE3MjYKKyM6IHd0LXN0YXR1cy5jOjE3MzAKIG1zZ2lkICJJbml0aWFsIGNvbW1pdCIKIG1zZ3N0ciAi5Yid5aeL5o+Q5LqkIgogCi0jOiB3dC1zdGF0dXMuYzoxNzI3CisjOiB3dC1zdGF0dXMuYzoxNzMxCiBtc2dpZCAiTm8gY29tbWl0cyB5ZXQiCiBtc2dzdHIgIuWwmuaXoOaPkOS6pCIKIAotIzogd3Qtc3RhdHVzLmM6MTc0MQorIzogd3Qtc3RhdHVzLmM6MTc0NQogbXNnaWQgIlVudHJhY2tlZCBmaWxlcyIKIG1zZ3N0ciAi5pyq6Lef6Liq55qE5paH5Lu2IgogCi0jOiB3dC1zdGF0dXMuYzoxNzQzCisjOiB3dC1zdGF0dXMuYzoxNzQ3CiBtc2dpZCAiSWdub3JlZCBmaWxlcyIKIG1zZ3N0ciAi5b+955Wl55qE5paH5Lu2IgogCi0jOiB3dC1zdGF0dXMuYzoxNzQ3CisjOiB3dC1zdGF0dXMuYzoxNzUxCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJJdCB0b29rICUuMmYgc2Vjb25kcyB0byBlbnVtZXJhdGUgdW50cmFja2VkIGZpbGVzLiAnc3RhdHVzIC11bm8nXG4iCkBAIC04MzA0LDEwMSArODM0NCwxMDYgQEAKICLogJfotLnkuoYgJS4yZiDnp5Lku6XmnprkuL7mnKrot5/ouKrnmoTmlofku7bjgIInc3RhdHVzIC11bm8nIOS5n+iuuOiDveaPkOmrmOmAn+W6pu+8jFxuIgogIuS9huaCqOmcgOimgeWwj+W/g+S4jeimgeW/mOS6hua3u+WKoOaWsOaWh+S7tu+8iOWPguingSAnZ2l0IGhlbHAgc3RhdHVzJ++8ieOAgiIKIAotIzogd3Qtc3RhdHVzLmM6MTc1MworIzogd3Qtc3RhdHVzLmM6MTc1NwogIywgYy1mb3JtYXQKIG1zZ2lkICJVbnRyYWNrZWQgZmlsZXMgbm90IGxpc3RlZCVzIgogbXNnc3RyICLmnKrot5/ouKrnmoTmlofku7bmsqHmnInliJflh7olcyIKIAogIyAg6K+R6ICF77ya5Lit5paH5a2X56ym5Liy5ou85o6l77yM5Y+v5Yig6Zmk5YmN5a+856m65qC8Ci0jOiB3dC1zdGF0dXMuYzoxNzU1CisjOiB3dC1zdGF0dXMuYzoxNzU5CiBtc2dpZCAiICh1c2UgLXUgb3B0aW9uIHRvIHNob3cgdW50cmFja2VkIGZpbGVzKSIKIG1zZ3N0ciAi77yI5L2/55SoIC11IOWPguaVsOaYvuekuuacqui3n+i4queahOaWh+S7tu+8iSIKIAotIzogd3Qtc3RhdHVzLmM6MTc2MQorIzogd3Qtc3RhdHVzLmM6MTc2NQogbXNnaWQgIk5vIGNoYW5nZXMiCiBtc2dzdHIgIuayoeacieS/ruaUuSIKIAotIzogd3Qtc3RhdHVzLmM6MTc2NgorIzogd3Qtc3RhdHVzLmM6MTc3MAogIywgYy1mb3JtYXQKIG1zZ2lkICJubyBjaGFuZ2VzIGFkZGVkIHRvIGNvbW1pdCAodXNlIFwiZ2l0IGFkZFwiIGFuZC9vciBcImdpdCBjb21taXQgLWFcIilcbiIKIG1zZ3N0ciAi5L+u5pS55bCa5pyq5Yqg5YWl5o+Q5Lqk77yI5L2/55SoIFwiZ2l0IGFkZFwiIOWSjC/miJYgXCJnaXQgY29tbWl0IC1hXCLvvIlcbiIKIAotIzogd3Qtc3RhdHVzLmM6MTc2OQorIzogd3Qtc3RhdHVzLmM6MTc3MwogIywgYy1mb3JtYXQKIG1zZ2lkICJubyBjaGFuZ2VzIGFkZGVkIHRvIGNvbW1pdFxuIgogbXNnc3RyICLkv67mlLnlsJrmnKrliqDlhaXmj5DkuqRcbiIKIAotIzogd3Qtc3RhdHVzLmM6MTc3MgorIzogd3Qtc3RhdHVzLmM6MTc3NgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAibm90aGluZyBhZGRlZCB0byBjb21taXQgYnV0IHVudHJhY2tlZCBmaWxlcyBwcmVzZW50ICh1c2UgXCJnaXQgYWRkXCIgdG8gIgogInRyYWNrKVxuIgogbXNnc3RyICLmj5DkuqTkuLrnqbrvvIzkvYbmmK/lrZjlnKjlsJrmnKrot5/ouKrnmoTmlofku7bvvIjkvb/nlKggXCJnaXQgYWRkXCIg5bu656uL6Lef6Liq77yJXG4iCiAKLSM6IHd0LXN0YXR1cy5jOjE3NzUKKyM6IHd0LXN0YXR1cy5jOjE3NzkKICMsIGMtZm9ybWF0CiBtc2dpZCAibm90aGluZyBhZGRlZCB0byBjb21taXQgYnV0IHVudHJhY2tlZCBmaWxlcyBwcmVzZW50XG4iCiBtc2dzdHIgIuaPkOS6pOS4uuepuu+8jOS9huaYr+WtmOWcqOWwmuacqui3n+i4queahOaWh+S7tlxuIgogCiAjICDor5HogIXvvJrkuK3mloflrZfnrKbkuLLmi7zmjqXvvIzlj6/liKDpmaTliY3lr7znqbrmoLwKLSM6IHd0LXN0YXR1cy5jOjE3NzgKKyM6IHd0LXN0YXR1cy5jOjE3ODIKICMsIGMtZm9ybWF0CiBtc2dpZCAibm90aGluZyB0byBjb21taXQgKGNyZWF0ZS9jb3B5IGZpbGVzIGFuZCB1c2UgXCJnaXQgYWRkXCIgdG8gdHJhY2spXG4iCiBtc2dzdHIgIuaXoOaWh+S7tuimgeaPkOS6pO+8iOWIm+W7ui/mi7fotJ3mlofku7blubbkvb/nlKggXCJnaXQgYWRkXCIg5bu656uL6Lef6Liq77yJXG4iCiAKLSM6IHd0LXN0YXR1cy5jOjE3ODEgd3Qtc3RhdHVzLmM6MTc4NgorIzogd3Qtc3RhdHVzLmM6MTc4NSB3dC1zdGF0dXMuYzoxNzkwCiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vdGhpbmcgdG8gY29tbWl0XG4iCiBtc2dzdHIgIuaXoOaWh+S7tuimgeaPkOS6pFxuIgogCiAjICDor5HogIXvvJrkuK3mloflrZfnrKbkuLLmi7zmjqXvvIzlj6/liKDpmaTliY3lr7znqbrmoLwKLSM6IHd0LXN0YXR1cy5jOjE3ODQKKyM6IHd0LXN0YXR1cy5jOjE3ODgKICMsIGMtZm9ybWF0CiBtc2dpZCAibm90aGluZyB0byBjb21taXQgKHVzZSAtdSB0byBzaG93IHVudHJhY2tlZCBmaWxlcylcbiIKIG1zZ3N0ciAi5peg5paH5Lu26KaB5o+Q5Lqk77yI5L2/55SoIC11IOaYvuekuuacqui3n+i4queahOaWh+S7tu+8iVxuIgogCiAjICDor5HogIXvvJrkuK3mloflrZfnrKbkuLLmi7zmjqXvvIzlj6/liKDpmaTliY3lr7znqbrmoLwKLSM6IHd0LXN0YXR1cy5jOjE3ODgKKyM6IHd0LXN0YXR1cy5jOjE3OTIKICMsIGMtZm9ybWF0CiBtc2dpZCAibm90aGluZyB0byBjb21taXQsIHdvcmtpbmcgdHJlZSBjbGVhblxuIgogbXNnc3RyICLml6Dmlofku7bopoHmj5DkuqTvvIzlubLlh4DnmoTlt6XkvZzljLpcbiIKIAotIzogd3Qtc3RhdHVzLmM6MTkwMQorIzogd3Qtc3RhdHVzLmM6MTkwNQogbXNnaWQgIk5vIGNvbW1pdHMgeWV0IG9uICIKIG1zZ3N0ciAi5bCa5peg5o+Q5Lqk5ZyoICIKIAotIzogd3Qtc3RhdHVzLmM6MTkwNQorIzogd3Qtc3RhdHVzLmM6MTkwOQogbXNnaWQgIkhFQUQgKG5vIGJyYW5jaCkiCiBtc2dzdHIgIkhFQUTvvIjpnZ7liIbmlK/vvIkiCiAKLSM6IHd0LXN0YXR1cy5jOjE5MzYKKyM6IHd0LXN0YXR1cy5jOjE5NDAKIG1zZ2lkICJkaWZmZXJlbnQiCiBtc2dzdHIgIuS4jeWQjCIKIAogIyAg6K+R6ICF77ya5rOo5oSP5L+d5oyB5Y+l5bC+56m65qC8Ci0jOiB3dC1zdGF0dXMuYzoxOTM4IHd0LXN0YXR1cy5jOjE5NDYKKyM6IHd0LXN0YXR1cy5jOjE5NDIgd3Qtc3RhdHVzLmM6MTk1MAogbXNnaWQgImJlaGluZCAiCiBtc2dzdHIgIuiQveWQjiAiCiAKLSM6IHd0LXN0YXR1cy5jOjE5NDEgd3Qtc3RhdHVzLmM6MTk0NAorIzogd3Qtc3RhdHVzLmM6MTk0NSB3dC1zdGF0dXMuYzoxOTQ4CiBtc2dpZCAiYWhlYWQgIgogbXNnc3RyICLpooblhYggIgogCiAjLiBUUkFOU0xBVE9SUzogdGhlIGFjdGlvbiBpcyBlLmcuICJwdWxsIHdpdGggcmViYXNlIgotIzogd3Qtc3RhdHVzLmM6MjQ2NgorIzogd3Qtc3RhdHVzLmM6MjQ3MAogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgJXM6IFlvdSBoYXZlIHVuc3RhZ2VkIGNoYW5nZXMuIgogbXNnc3RyICLkuI3og70lc++8muaCqOacieacquaaguWtmOeahOWPmOabtOOAgiIKIAotIzogd3Qtc3RhdHVzLmM6MjQ3MgorIzogd3Qtc3RhdHVzLmM6MjQ3NgogbXNnaWQgImFkZGl0aW9uYWxseSwgeW91ciBpbmRleCBjb250YWlucyB1bmNvbW1pdHRlZCBjaGFuZ2VzLiIKIG1zZ3N0ciAi5Y+m5aSW77yM5oKo55qE57Si5byV5Lit5YyF5ZCr5pyq5o+Q5Lqk55qE5Y+Y5pu044CCIgogCi0jOiB3dC1zdGF0dXMuYzoyNDc0CisjOiB3dC1zdGF0dXMuYzoyNDc4CiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCAlczogWW91ciBpbmRleCBjb250YWlucyB1bmNvbW1pdHRlZCBjaGFuZ2VzLiIKIG1zZ3N0ciAi5LiN6IO9JXPvvJrmgqjnmoTntKLlvJXkuK3ljIXlkKvmnKrmj5DkuqTnmoTlj5jmm7TjgIIiCiAKKyM6IGNvbXBhdC9wcmVjb21wb3NlX3V0ZjguYzo1OCBidWlsdGluL2Nsb25lLmM6NDUyCisjLCBjLWZvcm1hdAorbXNnaWQgImZhaWxlZCB0byB1bmxpbmsgJyVzJyIKK21zZ3N0ciAi5Yig6ZmkICclcycg5aSx6LSlIgorCiAjOiBidWlsdGluL2FkZC5jOjI1CiBtc2dpZCAiZ2l0IGFkZCBbPG9wdGlvbnM+XSBbLS1dIDxwYXRoc3BlYz4uLi4iCiBtc2dzdHIgImdpdCBhZGQgWzzpgInpobk+XSBbLS1dIDzot6/lvoTop4TmoLw+Li4uIgpAQCAtODQyMSw3ICs4NDY2LDcgQEAKIG1zZ2lkICJVbnN0YWdlZCBjaGFuZ2VzIGFmdGVyIHJlZnJlc2hpbmcgdGhlIGluZGV4OiIKIG1zZ3N0ciAi5Yi35paw57Si5byV5LmL5ZCO5bCa5pyq6KKr5pqC5a2Y55qE5Y+Y5pu077yaIgogCi0jOiBidWlsdGluL2FkZC5jOjIzNCBidWlsdGluL3Jldi1wYXJzZS5jOjg5NgorIzogYnVpbHRpbi9hZGQuYzoyMzQgYnVpbHRpbi9yZXYtcGFyc2UuYzo4OTcKIG1zZ2lkICJDb3VsZCBub3QgcmVhZCB0aGUgaW5kZXgiCiBtc2dzdHIgIuS4jeiDveivu+WPlue0ouW8lSIKIApAQCAtODQ1Niw4ICs4NTAxLDggQEAKIG1zZ2lkICJUaGUgZm9sbG93aW5nIHBhdGhzIGFyZSBpZ25vcmVkIGJ5IG9uZSBvZiB5b3VyIC5naXRpZ25vcmUgZmlsZXM6XG4iCiBtc2dzdHIgIuS4i+WIl+i3r+W+hOagueaNruaCqOeahOS4gOS4qiAuZ2l0aWdub3JlIOaWh+S7tuiAjOiiq+W/veeVpe+8mlxuIgogCi0jOiBidWlsdGluL2FkZC5jOjI5MCBidWlsdGluL2NsZWFuLmM6OTA5IGJ1aWx0aW4vZmV0Y2guYzoxNDcgYnVpbHRpbi9tdi5jOjEyNAotIzogYnVpbHRpbi9wcnVuZS1wYWNrZWQuYzo1NiBidWlsdGluL3B1bGwuYzoyMjIgYnVpbHRpbi9wdXNoLmM6NTYwCisjOiBidWlsdGluL2FkZC5jOjI5MCBidWlsdGluL2NsZWFuLmM6OTEwIGJ1aWx0aW4vZmV0Y2guYzoxNjIgYnVpbHRpbi9tdi5jOjEyNAorIzogYnVpbHRpbi9wcnVuZS1wYWNrZWQuYzo1NiBidWlsdGluL3B1bGwuYzoyMjMgYnVpbHRpbi9wdXNoLmM6NTQ3CiAjOiBidWlsdGluL3JlbW90ZS5jOjEzNDUgYnVpbHRpbi9ybS5jOjI0MSBidWlsdGluL3NlbmQtcGFjay5jOjE2NQogbXNnaWQgImRyeSBydW4iCiBtc2dzdHIgIua8lOS5oCIKQEAgLTg1MTAsNyArODU1NSw3IEBACiBtc2dpZCAiY2hlY2sgaWYgLSBldmVuIG1pc3NpbmcgLSBmaWxlcyBhcmUgaWdub3JlZCBpbiBkcnkgcnVuIgogbXNnc3RyICLmo4Dmn6XlnKjmvJTkuaDmqKHlvI/kuIvmlofku7bvvIjljbPkvb/kuI3lrZjlnKjvvInmmK/lkKbooqvlv73nlaUiCiAKLSM6IGJ1aWx0aW4vYWRkLmM6MzA5IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAwMQorIzogYnVpbHRpbi9hZGQuYzozMDkgYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDAyCiBtc2dpZCAib3ZlcnJpZGUgdGhlIGV4ZWN1dGFibGUgYml0IG9mIHRoZSBsaXN0ZWQgZmlsZXMiCiBtc2dzdHIgIuimhuebluWIl+ihqOmHjOaWh+S7tueahOWPr+aJp+ihjOS9jSIKIApAQCAtODU4NCwxMDkgKzg2MjksMTA1IEBACiBtc2dpZCAiTWF5YmUgeW91IHdhbnRlZCB0byBzYXkgJ2dpdCBhZGQgLic/XG4iCiBtc2dzdHIgIuS5n+iuuOaCqOaDs+imgeaJp+ihjCAnZ2l0IGFkZCAuJ++8n1xuIgogCi0jOiBidWlsdGluL2FtLmM6MzQ4CisjOiBidWlsdGluL2FtLmM6MzQ3CiBtc2dpZCAiY291bGQgbm90IHBhcnNlIGF1dGhvciBzY3JpcHQiCiBtc2dzdHIgIuS4jeiDveino+aekOS9nOiAheiEmuacrCIKIAotIzogYnVpbHRpbi9hbS5jOjQzMgorIzogYnVpbHRpbi9hbS5jOjQzMQogIywgYy1mb3JtYXQKIG1zZ2lkICInJXMnIHdhcyBkZWxldGVkIGJ5IHRoZSBhcHBseXBhdGNoLW1zZyBob29rIgogbXNnc3RyICInJXMnIOiiqyBhcHBseXBhdGNoLW1zZyDpkqnlrZDliKDpmaQiCiAKLSM6IGJ1aWx0aW4vYW0uYzo0NzQKKyM6IGJ1aWx0aW4vYW0uYzo0NzMKICMsIGMtZm9ybWF0CiBtc2dpZCAiTWFsZm9ybWVkIGlucHV0IGxpbmU6ICclcycuIgogbXNnc3RyICLpnZ7ms5XnmoTovpPlhaXooYzvvJonJXMn44CCIgogCi0jOiBidWlsdGluL2FtLmM6NTEyCisjOiBidWlsdGluL2FtLmM6NTExCiAjLCBjLWZvcm1hdAogbXNnaWQgIkZhaWxlZCB0byBjb3B5IG5vdGVzIGZyb20gJyVzJyB0byAnJXMnIgogbXNnc3RyICLku44gJyVzJyDmi7fotJ3ms6jop6PliLAgJyVzJyDml7blpLHotKUiCiAKLSM6IGJ1aWx0aW4vYW0uYzo1MzgKKyM6IGJ1aWx0aW4vYW0uYzo1MzcKIG1zZ2lkICJmc2VlayBmYWlsZWQiCiBtc2dzdHIgImZzZWVrIOWksei0pSIKIAotIzogYnVpbHRpbi9hbS5jOjcyNgorIzogYnVpbHRpbi9hbS5jOjcyNQogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcGFyc2UgcGF0Y2ggJyVzJyIKIG1zZ3N0ciAi5peg5rOV6Kej5p6Q6KGl5LiBICclcyciCiAKLSM6IGJ1aWx0aW4vYW0uYzo3OTEKKyM6IGJ1aWx0aW4vYW0uYzo3OTAKIG1zZ2lkICJPbmx5IG9uZSBTdEdJVCBwYXRjaCBzZXJpZXMgY2FuIGJlIGFwcGxpZWQgYXQgb25jZSIKIG1zZ3N0ciAi5LiA5qyh5Y+q6IO95pyJ5LiA5LiqIFN0R0lUIOihpeS4gemYn+WIl+iiq+W6lOeUqCIKIAotIzogYnVpbHRpbi9hbS5jOjgzOQorIzogYnVpbHRpbi9hbS5jOjgzOAogbXNnaWQgImludmFsaWQgdGltZXN0YW1wIgogbXNnc3RyICLml6DmlYjnmoTml7bpl7TmiLMiCiAKLSM6IGJ1aWx0aW4vYW0uYzo4NDQgYnVpbHRpbi9hbS5jOjg1NgorIzogYnVpbHRpbi9hbS5jOjg0MyBidWlsdGluL2FtLmM6ODU1CiBtc2dpZCAiaW52YWxpZCBEYXRlIGxpbmUiCiBtc2dzdHIgIuaXoOaViOeahOaXpeacn+ihjCIKIAotIzogYnVpbHRpbi9hbS5jOjg1MQorIzogYnVpbHRpbi9hbS5jOjg1MAogbXNnaWQgImludmFsaWQgdGltZXpvbmUgb2Zmc2V0IgogbXNnc3RyICLml6DmlYjnmoTml7bljLrlgY/np7vlgLwiCiAKLSM6IGJ1aWx0aW4vYW0uYzo5NDQKKyM6IGJ1aWx0aW4vYW0uYzo5NDMKIG1zZ2lkICJQYXRjaCBmb3JtYXQgZGV0ZWN0aW9uIGZhaWxlZC4iCiBtc2dzdHIgIuihpeS4geagvOW8j+aOoua1i+Wksei0peOAgiIKIAotIzogYnVpbHRpbi9hbS5jOjk0OSBidWlsdGluL2Nsb25lLmM6NDA3CisjOiBidWlsdGluL2FtLmM6OTQ4IGJ1aWx0aW4vY2xvbmUuYzo0MDYKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIGNyZWF0ZSBkaXJlY3RvcnkgJyVzJyIKIG1zZ3N0ciAi5Yib5bu655uu5b2VICclcycg5aSx6LSlIgogCi0jOiBidWlsdGluL2FtLmM6OTU0CisjOiBidWlsdGluL2FtLmM6OTUzCiBtc2dpZCAiRmFpbGVkIHRvIHNwbGl0IHBhdGNoZXMuIgogbXNnc3RyICLmi4bliIbooaXkuIHlpLHotKXjgIIiCiAKLSM6IGJ1aWx0aW4vYW0uYzoxMDg0IGJ1aWx0aW4vY29tbWl0LmM6Mzc0Ci1tc2dpZCAidW5hYmxlIHRvIHdyaXRlIGluZGV4IGZpbGUiCi1tc2dzdHIgIuaXoOazleWGmeWFpee0ouW8leaWh+S7tiIKLQotIzogYnVpbHRpbi9hbS5jOjEwOTgKKyM6IGJ1aWx0aW4vYW0uYzoxMDg0CiAjLCBjLWZvcm1hdAogbXNnaWQgIldoZW4geW91IGhhdmUgcmVzb2x2ZWQgdGhpcyBwcm9ibGVtLCBydW4gXCIlcyAtLWNvbnRpbnVlXCIuIgogbXNnc3RyICLlvZPmgqjop6PlhrPov5nkuIDpl67popjvvIzmiafooYwgXCIlcyAtLWNvbnRpbnVlXCLjgIIiCiAKLSM6IGJ1aWx0aW4vYW0uYzoxMDk5CisjOiBidWlsdGluL2FtLmM6MTA4NQogIywgYy1mb3JtYXQKIG1zZ2lkICJJZiB5b3UgcHJlZmVyIHRvIHNraXAgdGhpcyBwYXRjaCwgcnVuIFwiJXMgLS1za2lwXCIgaW5zdGVhZC4iCiBtc2dzdHIgIuWmguaenOaCqOaDs+imgei3s+i/h+i/meS4gOihpeS4ge+8jOWImeaJp+ihjCBcIiVzIC0tc2tpcFwi44CCIgogCi0jOiBidWlsdGluL2FtLmM6MTEwMAorIzogYnVpbHRpbi9hbS5jOjEwODYKICMsIGMtZm9ybWF0CiBtc2dpZCAiVG8gcmVzdG9yZSB0aGUgb3JpZ2luYWwgYnJhbmNoIGFuZCBzdG9wIHBhdGNoaW5nLCBydW4gXCIlcyAtLWFib3J0XCIuIgogbXNnc3RyICLoi6XopoHlpI3ljp/oh7Pljp/lp4vliIbmlK/lubblgZzmraLooaXkuIHmk43kvZzvvIzmiafooYwgXCIlcyAtLWFib3J0XCLjgIIiCiAKLSM6IGJ1aWx0aW4vYW0uYzoxMTgzCisjOiBidWlsdGluL2FtLmM6MTE2OQogbXNnaWQgIlBhdGNoIHNlbnQgd2l0aCBmb3JtYXQ9Zmxvd2VkOyBzcGFjZSBhdCB0aGUgZW5kIG9mIGxpbmVzIG1pZ2h0IGJlIGxvc3QuIgogbXNnc3RyICLooaXkuIHkvb/nlKggZm9ybWF0PWZsb3dlZCDmoLzlvI/lj5HpgIHvvIzooYzlsL7nmoTnqbrmoLzlj6/og73kvJrkuKLlpLHjgIIiCiAKLSM6IGJ1aWx0aW4vYW0uYzoxMjExCisjOiBidWlsdGluL2FtLmM6MTE5NwogbXNnaWQgIlBhdGNoIGlzIGVtcHR5LiIKIG1zZ3N0ciAi6KGl5LiB5Li656m644CCIgogCi0jOiBidWlsdGluL2FtLmM6MTI3NworIzogYnVpbHRpbi9hbS5jOjEyNjIKKyMsIGMtZm9ybWF0Cittc2dpZCAibWlzc2luZyBhdXRob3IgbGluZSBpbiBjb21taXQgJXMiCittc2dzdHIgIuWcqOaPkOS6pCAlcyDkuK3nvLrlpLHkvZzogIXooYwiCisKKyM6IGJ1aWx0aW4vYW0uYzoxMjY1CiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgaWRlbnQgbGluZTogJS4qcyIKIG1zZ3N0ciAi5peg5pWI55qE6Lqr5Lu95qCH6K+G77yaJS4qcyIKIAotIzogYnVpbHRpbi9hbS5jOjEyOTkKLSMsIGMtZm9ybWF0Ci1tc2dpZCAidW5hYmxlIHRvIHBhcnNlIGNvbW1pdCAlcyIKLW1zZ3N0ciAi5LiN6IO96Kej5p6Q5o+Q5LqkICVzIgotCi0jOiBidWlsdGluL2FtLmM6MTQ5NgorIzogYnVpbHRpbi9hbS5jOjE0ODQKIG1zZ2lkICJSZXBvc2l0b3J5IGxhY2tzIG5lY2Vzc2FyeSBibG9icyB0byBmYWxsIGJhY2sgb24gMy13YXkgbWVyZ2UuIgogbXNnc3RyICLku5PlupPnvLrkuY/lv4XopoHnmoTmlbDmja7lr7nosaHku6Xov5vooYzkuInmlrnlkIjlubbjgIIiCiAKLSM6IGJ1aWx0aW4vYW0uYzoxNDk4CisjOiBidWlsdGluL2FtLmM6MTQ4NgogbXNnaWQgIlVzaW5nIGluZGV4IGluZm8gdG8gcmVjb25zdHJ1Y3QgYSBiYXNlIHRyZWUuLi4iCiBtc2dzdHIgIuS9v+eUqOe0ouW8leadpemHjeW7uuS4gOS4qu+8iOS4ieaWueWQiOW5tueahO+8ieWfuuehgOebruW9leagkS4uLiIKIAotIzogYnVpbHRpbi9hbS5jOjE1MTcKKyM6IGJ1aWx0aW4vYW0uYzoxNTA1CiBtc2dpZCAiIgogIkRpZCB5b3UgaGFuZCBlZGl0IHlvdXIgcGF0Y2g/XG4iCiAiSXQgZG9lcyBub3QgYXBwbHkgdG8gYmxvYnMgcmVjb3JkZWQgaW4gaXRzIGluZGV4LiIKQEAgLTg2OTQsMjQgKzg3MzUsMjQgQEAKICLmgqjmmK/lkKbmm77miYvliqjnvJbovpHov4fmgqjnmoTooaXkuIHvvJ9cbiIKICLml6Dms5XlupTnlKjooaXkuIHliLDntKLlvJXkuK3nmoTmlbDmja7lr7nosaHkuIrjgIIiCiAKLSM6IGJ1aWx0aW4vYW0uYzoxNTIzCisjOiBidWlsdGluL2FtLmM6MTUxMQogbXNnaWQgIkZhbGxpbmcgYmFjayB0byBwYXRjaGluZyBiYXNlIGFuZCAzLXdheSBtZXJnZS4uLiIKIG1zZ3N0ciAi5Zue6JC95Yiw5Z+656GA54mI5pys5LiK5omT6KGl5LiB5Y+K6L+b6KGM5LiJ5pa55ZCI5bm2Li4uIgogCi0jOiBidWlsdGluL2FtLmM6MTU0OQorIzogYnVpbHRpbi9hbS5jOjE1MzcKIG1zZ2lkICJGYWlsZWQgdG8gbWVyZ2UgaW4gdGhlIGNoYW5nZXMuIgogbXNnc3RyICLml6Dms5XlkIjlubblj5jmm7TjgIIiCiAKLSM6IGJ1aWx0aW4vYW0uYzoxNTgxCisjOiBidWlsdGluL2FtLmM6MTU2OQogbXNnaWQgImFwcGx5aW5nIHRvIGFuIGVtcHR5IGhpc3RvcnkiCiBtc2dzdHIgIuato+W6lOeUqOWIsOS4gOS4quepuuWOhuWPsuS4iiIKIAotIzogYnVpbHRpbi9hbS5jOjE2MjggYnVpbHRpbi9hbS5jOjE2MzIKKyM6IGJ1aWx0aW4vYW0uYzoxNjE2IGJ1aWx0aW4vYW0uYzoxNjIwCiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCByZXN1bWU6ICVzIGRvZXMgbm90IGV4aXN0LiIKIG1zZ3N0ciAi5peg5rOV57un57ut77yaJXMg5LiN5a2Y5Zyo44CCIgogCi0jOiBidWlsdGluL2FtLmM6MTY1MAorIzogYnVpbHRpbi9hbS5jOjE2MzgKIG1zZ2lkICJDb21taXQgQm9keSBpczoiCiBtc2dzdHIgIuaPkOS6pOWGheWuueS4uu+8miIKIApAQCAtODcyMCwzNSArODc2MSwzOSBAQAogIy4gaW4geW91ciB0cmFuc2xhdGlvbi4gVGhlIHByb2dyYW0gd2lsbCBvbmx5IGFjY2VwdCBFbmdsaXNoCiAjLiBpbnB1dCBhdCB0aGlzIHBvaW50LgogIy4KLSM6IGJ1aWx0aW4vYW0uYzoxNjYwCisjOiBidWlsdGluL2FtLmM6MTY0OAogIywgYy1mb3JtYXQKIG1zZ2lkICJBcHBseT8gW3ldZXMvW25dby9bZV1kaXQvW3ZdaWV3IHBhdGNoL1thXWNjZXB0IGFsbDogIgogbXNnc3RyICLlupTnlKjvvJ/mmK9beV0v5ZCmW25dL+e8lui+kVtlXS/mn6XnnIvooaXkuIFbdl0v5bqU55So5omA5pyJW2Fd77yaIgogCi0jOiBidWlsdGluL2FtLmM6MTcxMAorIzogYnVpbHRpbi9hbS5jOjE2OTUgYnVpbHRpbi9jb21taXQuYzozNzQKK21zZ2lkICJ1bmFibGUgdG8gd3JpdGUgaW5kZXggZmlsZSIKK21zZ3N0ciAi5peg5rOV5YaZ5YWl57Si5byV5paH5Lu2IgorCisjOiBidWlsdGluL2FtLmM6MTY5OQogIywgYy1mb3JtYXQKIG1zZ2lkICJEaXJ0eSBpbmRleDogY2Fubm90IGFwcGx5IHBhdGNoZXMgKGRpcnR5OiAlcykiCiBtc2dzdHIgIuiEj+e0ouW8le+8muS4jeiDveW6lOeUqOihpeS4ge+8iOiEj+aWh+S7tu+8miVz77yJIgogCi0jOiBidWlsdGluL2FtLmM6MTc1MCBidWlsdGluL2FtLmM6MTgxOAorIzogYnVpbHRpbi9hbS5jOjE3MzkgYnVpbHRpbi9hbS5jOjE4MDcKICMsIGMtZm9ybWF0CiBtc2dpZCAiQXBwbHlpbmc6ICUuKnMiCiBtc2dzdHIgIuW6lOeUqO+8miUuKnMiCiAKLSM6IGJ1aWx0aW4vYW0uYzoxNzY3CisjOiBidWlsdGluL2FtLmM6MTc1NgogbXNnaWQgIk5vIGNoYW5nZXMgLS0gUGF0Y2ggYWxyZWFkeSBhcHBsaWVkLiIKIG1zZ3N0ciAi5rKh5pyJ5Y+Y5pu0IOKAlOKAlCDooaXkuIHlt7Lnu4/lupTnlKjov4fjgIIiCiAKLSM6IGJ1aWx0aW4vYW0uYzoxNzczCisjOiBidWlsdGluL2FtLmM6MTc2MgogIywgYy1mb3JtYXQKIG1zZ2lkICJQYXRjaCBmYWlsZWQgYXQgJXMgJS4qcyIKIG1zZ3N0ciAi5omT6KGl5LiB5aSx6LSl5LqOICVzICUuKnMiCiAKLSM6IGJ1aWx0aW4vYW0uYzoxNzc3CisjOiBidWlsdGluL2FtLmM6MTc2NgogbXNnaWQgIlVzZSAnZ2l0IGFtIC0tc2hvdy1jdXJyZW50LXBhdGNoJyB0byBzZWUgdGhlIGZhaWxlZCBwYXRjaCIKIG1zZ3N0ciAi55SoICdnaXQgYW0gLS1zaG93LWN1cnJlbnQtcGF0Y2gnIOWRveS7pOafpeeci+Wksei0peeahOihpeS4gSIKIAotIzogYnVpbHRpbi9hbS5jOjE4MjEKKyM6IGJ1aWx0aW4vYW0uYzoxODEwCiBtc2dpZCAiIgogIk5vIGNoYW5nZXMgLSBkaWQgeW91IGZvcmdldCB0byB1c2UgJ2dpdCBhZGQnP1xuIgogIklmIHRoZXJlIGlzIG5vdGhpbmcgbGVmdCB0byBzdGFnZSwgY2hhbmNlcyBhcmUgdGhhdCBzb21ldGhpbmcgZWxzZVxuIgpAQCAtODc1OCw3ICs4ODAzLDcgQEAKICLlpoLmnpzmsqHmnInku4DkuYjopoHmt7vliqDliLDmmoLlrZjljLrnmoTvvIzliJnlvojlj6/og73mmK/lhbblroPmj5DkuqTlt7Lnu4/lvJXlhaXkuobnm7jlkIznmoTlj5jmm7TjgIJcbiIKICLmgqjkuZ/orrjmg7PopoHot7Pov4fov5nkuKrooaXkuIHjgIIiCiAKLSM6IGJ1aWx0aW4vYW0uYzoxODI4CisjOiBidWlsdGluL2FtLmM6MTgxNwogbXNnaWQgIiIKICJZb3Ugc3RpbGwgaGF2ZSB1bm1lcmdlZCBwYXRocyBpbiB5b3VyIGluZGV4LlxuIgogIllvdSBzaG91bGQgJ2dpdCBhZGQnIGVhY2ggZmlsZSB3aXRoIHJlc29sdmVkIGNvbmZsaWN0cyB0byBtYXJrIHRoZW0gYXMgIgpAQCAtODc2OSwxNTkgKzg4MTQsMTU5IEBACiAi5oKo5bqU6K+l5a+55bey57uP5Yay56qB6Kej5Yaz55qE5q+P5LiA5Liq5paH5Lu25omn6KGMICdnaXQgYWRkJyDmnaXmoIforrDlt7Lnu4/lrozmiJDjgIIgXG4iCiAi5L2g5Y+v5Lul5a+5IFwi55Sx5LuW5Lus5Yig6ZmkXCIg55qE5paH5Lu25omn6KGMIGBnaXQgcm1gIOWRveS7pOOAgiIKIAotIzogYnVpbHRpbi9hbS5jOjE5MzUgYnVpbHRpbi9hbS5jOjE5MzkgYnVpbHRpbi9hbS5jOjE5NTEgYnVpbHRpbi9yZXNldC5jOjMyOQorIzogYnVpbHRpbi9hbS5jOjE5MjQgYnVpbHRpbi9hbS5jOjE5MjggYnVpbHRpbi9hbS5jOjE5NDAgYnVpbHRpbi9yZXNldC5jOjMyOQogIzogYnVpbHRpbi9yZXNldC5jOjMzNwogIywgYy1mb3JtYXQKIG1zZ2lkICJDb3VsZCBub3QgcGFyc2Ugb2JqZWN0ICclcycuIgogbXNnc3RyICLkuI3og73op6PmnpDlr7nosaEgJyVzJ+OAgiIKIAotIzogYnVpbHRpbi9hbS5jOjE5ODcKKyM6IGJ1aWx0aW4vYW0uYzoxOTc2CiBtc2dpZCAiZmFpbGVkIHRvIGNsZWFuIGluZGV4IgogbXNnc3RyICLmuIXnqbrntKLlvJXlpLHotKUiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMDMxCisjOiBidWlsdGluL2FtLmM6MjAyMAogbXNnaWQgIiIKICJZb3Ugc2VlbSB0byBoYXZlIG1vdmVkIEhFQUQgc2luY2UgdGhlIGxhc3QgJ2FtJyBmYWlsdXJlLlxuIgogIk5vdCByZXdpbmRpbmcgdG8gT1JJR19IRUFEIgogbXNnc3RyICLmgqjlpb3lg4/lnKjkuIrkuIDmrKEgJ2FtJyDlpLHotKXlkI7np7vliqjkuoYgSEVBROOAguacquWbnumAgOiHsyBPUklHX0hFQUQiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMTI4CisjOiBidWlsdGluL2FtLmM6MjExNwogIywgYy1mb3JtYXQKIG1zZ2lkICJJbnZhbGlkIHZhbHVlIGZvciAtLXBhdGNoLWZvcm1hdDogJXMiCiBtc2dzdHIgIuaXoOaViOeahCAtLXBhdGNoLWZvcm1hdCDlgLzvvJolcyIKIAotIzogYnVpbHRpbi9hbS5jOjIxNjQKKyM6IGJ1aWx0aW4vYW0uYzoyMTUzCiBtc2dpZCAiZ2l0IGFtIFs8b3B0aW9ucz5dIFsoPG1ib3g+IHwgPE1haWxkaXI+KS4uLl0iCiBtc2dzdHIgImdpdCBhbSBbPOmAiemhuT5dIFsoPG1ib3g+IHwgPE1haWxkaXI+KS4uLl0iCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMTY1CisjOiBidWlsdGluL2FtLmM6MjE1NAogbXNnaWQgImdpdCBhbSBbPG9wdGlvbnM+XSAoLS1jb250aW51ZSB8IC0tc2tpcCB8IC0tYWJvcnQpIgogbXNnc3RyICJnaXQgYW0gWzzpgInpobk+XSAoLS1jb250aW51ZSB8IC0tc2tpcCB8IC0tYWJvcnQpIgogCi0jOiBidWlsdGluL2FtLmM6MjE3MQorIzogYnVpbHRpbi9hbS5jOjIxNjAKIG1zZ2lkICJydW4gaW50ZXJhY3RpdmVseSIKIG1zZ3N0ciAi5Lul5Lqk5LqS5byP5pa55byP6L+Q6KGMIgogCi0jOiBidWlsdGluL2FtLmM6MjE3MworIzogYnVpbHRpbi9hbS5jOjIxNjIKIG1zZ2lkICJoaXN0b3JpY2FsIG9wdGlvbiAtLSBuby1vcCIKIG1zZ3N0ciAi6ICB55qE5Y+C5pWwIOKAlOKAlCDml6DkvZznlKgiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMTc1CisjOiBidWlsdGluL2FtLmM6MjE2NAogbXNnaWQgImFsbG93IGZhbGwgYmFjayBvbiAzd2F5IG1lcmdpbmcgaWYgbmVlZGVkIgogbXNnc3RyICLlpoLmnpzlv4XopoHvvIzlhYHorrjkvb/nlKjkuInmlrnlkIjlubbjgIIiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMTc2IGJ1aWx0aW4vaW5pdC1kYi5jOjQ5NCBidWlsdGluL3BydW5lLXBhY2tlZC5jOjU4Ci0jOiBidWlsdGluL3JlcGFjay5jOjI5NiBidWlsdGluL3N0YXNoLmM6ODA2CisjOiBidWlsdGluL2FtLmM6MjE2NSBidWlsdGluL2luaXQtZGIuYzo0OTQgYnVpbHRpbi9wcnVuZS1wYWNrZWQuYzo1OAorIzogYnVpbHRpbi9yZXBhY2suYzoyOTcgYnVpbHRpbi9zdGFzaC5jOjgxMgogbXNnaWQgImJlIHF1aWV0IgogbXNnc3RyICLpnZnpu5jmqKHlvI8iCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMTc4CisjOiBidWlsdGluL2FtLmM6MjE2NwogbXNnaWQgImFkZCBhIFNpZ25lZC1vZmYtYnkgbGluZSB0byB0aGUgY29tbWl0IG1lc3NhZ2UiCiBtc2dzdHIgIuWcqOaPkOS6pOivtOaYjuS4rea3u+WKoOS4gOS4qiBTaWduZWQtb2ZmLWJ5IOetvuWQjSIKIAotIzogYnVpbHRpbi9hbS5jOjIxODEKKyM6IGJ1aWx0aW4vYW0uYzoyMTcwCiBtc2dpZCAicmVjb2RlIGludG8gdXRmOCAoZGVmYXVsdCkiCiBtc2dzdHIgIuS9v+eUqCB1dGY4IOWtl+espumbhu+8iOm7mOiupO+8iSIKIAotIzogYnVpbHRpbi9hbS5jOjIxODMKKyM6IGJ1aWx0aW4vYW0uYzoyMTcyCiBtc2dpZCAicGFzcyAtayBmbGFnIHRvIGdpdC1tYWlsaW5mbyIKIG1zZ3N0ciAi5ZCRIGdpdC1tYWlsaW5mbyDkvKDpgJIgLWsg5Y+C5pWwIgogCi0jOiBidWlsdGluL2FtLmM6MjE4NQorIzogYnVpbHRpbi9hbS5jOjIxNzQKIG1zZ2lkICJwYXNzIC1iIGZsYWcgdG8gZ2l0LW1haWxpbmZvIgogbXNnc3RyICLlkJEgZ2l0LW1haWxpbmZvIOS8oOmAkiAtYiDlj4LmlbAiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMTg3CisjOiBidWlsdGluL2FtLmM6MjE3NgogbXNnaWQgInBhc3MgLW0gZmxhZyB0byBnaXQtbWFpbGluZm8iCiBtc2dzdHIgIuWQkSBnaXQtbWFpbGluZm8g5Lyg6YCSIC1tIOWPguaVsCIKIAotIzogYnVpbHRpbi9hbS5jOjIxODkKKyM6IGJ1aWx0aW4vYW0uYzoyMTc4CiBtc2dpZCAicGFzcyAtLWtlZXAtY3IgZmxhZyB0byBnaXQtbWFpbHNwbGl0IGZvciBtYm94IGZvcm1hdCIKIG1zZ3N0ciAi6ZKI5a+5IG1ib3gg5qC85byP77yM5ZCRIGdpdC1tYWlsc3BsaXQg5Lyg6YCSIC0ta2VlcC1jciDlj4LmlbAiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMTkyCisjOiBidWlsdGluL2FtLmM6MjE4MQogbXNnaWQgImRvIG5vdCBwYXNzIC0ta2VlcC1jciBmbGFnIHRvIGdpdC1tYWlsc3BsaXQgaW5kZXBlbmRlbnQgb2YgYW0ua2VlcGNyIgogbXNnc3RyICLkuI3lkJEgZ2l0LW1haWxzcGxpdCDkvKDpgJIgLS1rZWVwLWNyIOWPguaVsO+8jOimhuebliBhbS5rZWVwY3Ig55qE6K6+572uIgogCi0jOiBidWlsdGluL2FtLmM6MjE5NQorIzogYnVpbHRpbi9hbS5jOjIxODQKIG1zZ2lkICJzdHJpcCBldmVyeXRoaW5nIGJlZm9yZSBhIHNjaXNzb3JzIGxpbmUiCiBtc2dzdHIgIuS4ouW8g+ijgeWIh+e6v+WJjeeahOaJgOacieWGheWuuSIKIAotIzogYnVpbHRpbi9hbS5jOjIxOTcgYnVpbHRpbi9hbS5jOjIyMDAgYnVpbHRpbi9hbS5jOjIyMDMgYnVpbHRpbi9hbS5jOjIyMDYKLSM6IGJ1aWx0aW4vYW0uYzoyMjA5IGJ1aWx0aW4vYW0uYzoyMjEyIGJ1aWx0aW4vYW0uYzoyMjE1IGJ1aWx0aW4vYW0uYzoyMjE4Ci0jOiBidWlsdGluL2FtLmM6MjIyNAorIzogYnVpbHRpbi9hbS5jOjIxODYgYnVpbHRpbi9hbS5jOjIxODkgYnVpbHRpbi9hbS5jOjIxOTIgYnVpbHRpbi9hbS5jOjIxOTUKKyM6IGJ1aWx0aW4vYW0uYzoyMTk4IGJ1aWx0aW4vYW0uYzoyMjAxIGJ1aWx0aW4vYW0uYzoyMjA0IGJ1aWx0aW4vYW0uYzoyMjA3CisjOiBidWlsdGluL2FtLmM6MjIxMwogbXNnaWQgInBhc3MgaXQgdGhyb3VnaCBnaXQtYXBwbHkiCiBtc2dzdHIgIuS8oOmAkue7mSBnaXQtYXBwbHkiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMjE0IGJ1aWx0aW4vY29tbWl0LmM6MTM2OCBidWlsdGluL2ZtdC1tZXJnZS1tc2cuYzo2NzEKLSM6IGJ1aWx0aW4vZm10LW1lcmdlLW1zZy5jOjY3NCBidWlsdGluL2dyZXAuYzo4ODEgYnVpbHRpbi9tZXJnZS5jOjI0OQotIzogYnVpbHRpbi9wdWxsLmM6MTU5IGJ1aWx0aW4vcHVsbC5jOjIxOCBidWlsdGluL3JlYmFzZS5jOjE0MTgKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MzA3IGJ1aWx0aW4vcmVwYWNrLmM6MzExIGJ1aWx0aW4vcmVwYWNrLmM6MzEzCisjOiBidWlsdGluL2FtLmM6MjIwMyBidWlsdGluL2NvbW1pdC5jOjEzNjggYnVpbHRpbi9mbXQtbWVyZ2UtbXNnLmM6NjcxCisjOiBidWlsdGluL2ZtdC1tZXJnZS1tc2cuYzo2NzQgYnVpbHRpbi9ncmVwLmM6ODgzIGJ1aWx0aW4vbWVyZ2UuYzoyNDkKKyM6IGJ1aWx0aW4vcHVsbC5jOjE2MCBidWlsdGluL3B1bGwuYzoyMTkgYnVpbHRpbi9yZWJhc2UuYzoxNDQyCisjOiBidWlsdGluL3JlcGFjay5jOjMwOCBidWlsdGluL3JlcGFjay5jOjMxMiBidWlsdGluL3JlcGFjay5jOjMxNAogIzogYnVpbHRpbi9zaG93LWJyYW5jaC5jOjY1MCBidWlsdGluL3Nob3ctcmVmLmM6MTcyIGJ1aWx0aW4vdGFnLmM6NDAzCi0jOiBwYXJzZS1vcHRpb25zLmg6MTQxIHBhcnNlLW9wdGlvbnMuaDoxNjIgcGFyc2Utb3B0aW9ucy5oOjMxMgorIzogcGFyc2Utb3B0aW9ucy5oOjE1MCBwYXJzZS1vcHRpb25zLmg6MTcxIHBhcnNlLW9wdGlvbnMuaDozMTIKIG1zZ2lkICJuIgogbXNnc3RyICJuIgogCi0jOiBidWlsdGluL2FtLmM6MjIyMCBidWlsdGluL2JyYW5jaC5jOjY2MSBidWlsdGluL2Zvci1lYWNoLXJlZi5jOjM4Ci0jOiBidWlsdGluL3JlcGxhY2UuYzo1NTQgYnVpbHRpbi90YWcuYzo0MzcgYnVpbHRpbi92ZXJpZnktdGFnLmM6MzgKKyM6IGJ1aWx0aW4vYW0uYzoyMjA5IGJ1aWx0aW4vYnJhbmNoLmM6NjYxIGJ1aWx0aW4vZm9yLWVhY2gtcmVmLmM6MzgKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU1NSBidWlsdGluL3RhZy5jOjQzNyBidWlsdGluL3ZlcmlmeS10YWcuYzozOAogbXNnaWQgImZvcm1hdCIKIG1zZ3N0ciAi5qC85byPIgogCi0jOiBidWlsdGluL2FtLmM6MjIyMQorIzogYnVpbHRpbi9hbS5jOjIyMTAKIG1zZ2lkICJmb3JtYXQgdGhlIHBhdGNoKGVzKSBhcmUgaW4iCiBtc2dzdHIgIuihpeS4geeahOagvOW8jyIKIAotIzogYnVpbHRpbi9hbS5jOjIyMjcKKyM6IGJ1aWx0aW4vYW0uYzoyMjE2CiBtc2dpZCAib3ZlcnJpZGUgZXJyb3IgbWVzc2FnZSB3aGVuIHBhdGNoIGZhaWx1cmUgb2NjdXJzIgogbXNnc3RyICLmiZPooaXkuIHlpLHotKXml7bmmL7npLrnmoTplJnor6/kv6Hmga8iCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMjI5CisjOiBidWlsdGluL2FtLmM6MjIxOAogbXNnaWQgImNvbnRpbnVlIGFwcGx5aW5nIHBhdGNoZXMgYWZ0ZXIgcmVzb2x2aW5nIGEgY29uZmxpY3QiCiBtc2dzdHIgIuWGsueqgeino+WGs+WQjue7p+e7reW6lOeUqOihpeS4gSIKIAotIzogYnVpbHRpbi9hbS5jOjIyMzIKKyM6IGJ1aWx0aW4vYW0uYzoyMjIxCiBtc2dpZCAic3lub255bXMgZm9yIC0tY29udGludWUiCiBtc2dzdHIgIuWSjCAtLWNvbnRpbnVlIOWQjOS5iSIKIAotIzogYnVpbHRpbi9hbS5jOjIyMzUKKyM6IGJ1aWx0aW4vYW0uYzoyMjI0CiBtc2dpZCAic2tpcCB0aGUgY3VycmVudCBwYXRjaCIKIG1zZ3N0ciAi6Lez6L+H5b2T5YmN6KGl5LiBIgogCi0jOiBidWlsdGluL2FtLmM6MjIzOAorIzogYnVpbHRpbi9hbS5jOjIyMjcKIG1zZ2lkICJyZXN0b3JlIHRoZSBvcmlnaW5hbCBicmFuY2ggYW5kIGFib3J0IHRoZSBwYXRjaGluZyBvcGVyYXRpb24uIgogbXNnc3RyICLmgaLlpI3ljp/lp4vliIbmlK/lubbnu4jmraLmiZPooaXkuIHmk43kvZzjgIIiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMjQxCisjOiBidWlsdGluL2FtLmM6MjIzMAogbXNnaWQgImFib3J0IHRoZSBwYXRjaGluZyBvcGVyYXRpb24gYnV0IGtlZXAgSEVBRCB3aGVyZSBpdCBpcy4iCiBtc2dzdHIgIue7iOatouihpeS4geaTjeS9nOS9huS/neaMgSBIRUFEIOS4jeWPmOOAgiIKIAotIzogYnVpbHRpbi9hbS5jOjIyNDQKKyM6IGJ1aWx0aW4vYW0uYzoyMjMzCiBtc2dpZCAic2hvdyB0aGUgcGF0Y2ggYmVpbmcgYXBwbGllZC4iCiBtc2dzdHIgIuaYvuekuuato+WcqOW6lOeUqOeahOihpeS4geOAgiIKIAotIzogYnVpbHRpbi9hbS5jOjIyNDgKKyM6IGJ1aWx0aW4vYW0uYzoyMjM3CiBtc2dpZCAibGllIGFib3V0IGNvbW1pdHRlciBkYXRlIgogbXNnc3RyICLlsIbkvZzogIXml6XmnJ/kvZzkuLrmj5DkuqTml6XmnJ8iCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMjUwCisjOiBidWlsdGluL2FtLmM6MjIzOQogbXNnaWQgInVzZSBjdXJyZW50IHRpbWVzdGFtcCBmb3IgYXV0aG9yIGRhdGUiCiBtc2dzdHIgIueUqOW9k+WJjeaXtumXtOS9nOS4uuS9nOiAheaXpeacnyIKIAotIzogYnVpbHRpbi9hbS5jOjIyNTIgYnVpbHRpbi9jb21taXQtdHJlZS5jOjEyMCBidWlsdGluL2NvbW1pdC5jOjE1MTEKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoyODYgYnVpbHRpbi9wdWxsLmM6MTkzIGJ1aWx0aW4vcmViYXNlLmM6NDg5Ci0jOiBidWlsdGluL3JlYmFzZS5jOjE0NTkgYnVpbHRpbi9yZXZlcnQuYzoxMTcgYnVpbHRpbi90YWcuYzo0MTgKKyM6IGJ1aWx0aW4vYW0uYzoyMjQxIGJ1aWx0aW4vY29tbWl0LXRyZWUuYzoxMjAgYnVpbHRpbi9jb21taXQuYzoxNTExCisjOiBidWlsdGluL21lcmdlLmM6Mjg2IGJ1aWx0aW4vcHVsbC5jOjE5NCBidWlsdGluL3JlYmFzZS5jOjQ5MAorIzogYnVpbHRpbi9yZWJhc2UuYzoxNDgzIGJ1aWx0aW4vcmV2ZXJ0LmM6MTE3IGJ1aWx0aW4vdGFnLmM6NDE4CiBtc2dpZCAia2V5LWlkIgogbXNnc3RyICJrZXktaWQiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMjUzIGJ1aWx0aW4vcmViYXNlLmM6NDkwIGJ1aWx0aW4vcmViYXNlLmM6MTQ2MAorIzogYnVpbHRpbi9hbS5jOjIyNDIgYnVpbHRpbi9yZWJhc2UuYzo0OTEgYnVpbHRpbi9yZWJhc2UuYzoxNDg0CiBtc2dpZCAiR1BHLXNpZ24gY29tbWl0cyIKIG1zZ3N0ciAi5L2/55SoIEdQRyDnrb7lkI3mj5DkuqQiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMjU2CisjOiBidWlsdGluL2FtLmM6MjI0NQogbXNnaWQgIihpbnRlcm5hbCB1c2UgZm9yIGdpdC1yZWJhc2UpIgogbXNnc3RyICLvvIjlhoXpg6jkvb/nlKjvvIznlKjkuo4gZ2l0LXJlYmFzZe+8iSIKIAotIzogYnVpbHRpbi9hbS5jOjIyNzQKKyM6IGJ1aWx0aW4vYW0uYzoyMjYzCiBtc2dpZCAiIgogIlRoZSAtYi8tLWJpbmFyeSBvcHRpb24gaGFzIGJlZW4gYSBuby1vcCBmb3IgbG9uZyB0aW1lLCBhbmRcbiIKICJpdCB3aWxsIGJlIHJlbW92ZWQuIFBsZWFzZSBkbyBub3QgdXNlIGl0IGFueW1vcmUuIgpAQCAtODkyOSwxNiArODk3NCwxNiBAQAogIuWPguaVsCAtYi8tLWJpbmFyeSDlt7Lnu4/lvojplb/ml7bpl7TkuI3lgZrku7vkvZXlrp7otKjmk43kvZzkuobvvIzlubbkuJTlsIbooqvnp7vpmaTjgIJcbiIKICLor7fkuI3opoHlho3kvb/nlKjlroPkuobjgIIiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMjgxCisjOiBidWlsdGluL2FtLmM6MjI3MAogbXNnaWQgImZhaWxlZCB0byByZWFkIHRoZSBpbmRleCIKIG1zZ3N0ciAi6K+75Y+W57Si5byV5aSx6LSlIgogCi0jOiBidWlsdGluL2FtLmM6MjI5NgorIzogYnVpbHRpbi9hbS5jOjIyODUKICMsIGMtZm9ybWF0CiBtc2dpZCAicHJldmlvdXMgcmViYXNlIGRpcmVjdG9yeSAlcyBzdGlsbCBleGlzdHMgYnV0IG1ib3ggZ2l2ZW4uIgogbXNnc3RyICLkuYvliY3nmoTlj5jln7rnm67lvZUgJXMg5LuN54S25a2Y5Zyo77yM5L2G5Y205o+Q5L6b5LqGIG1ib3jjgIIiCiAKLSM6IGJ1aWx0aW4vYW0uYzoyMzIwCisjOiBidWlsdGluL2FtLmM6MjMwOQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiU3RyYXkgJXMgZGlyZWN0b3J5IGZvdW5kLlxuIgpAQCAtODk0NywxMSArODk5MiwxMSBAQAogIuWPkeeOsOS6humUmeivr+eahCAlcyDnm67lvZXjgIJcbiIKICLkvb/nlKggXCJnaXQgYW0gLS1hYm9ydFwiIOWIoOmZpOWug+OAgiIKIAotIzogYnVpbHRpbi9hbS5jOjIzMjYKKyM6IGJ1aWx0aW4vYW0uYzoyMzE1CiBtc2dpZCAiUmVzb2x2ZSBvcGVyYXRpb24gbm90IGluIHByb2dyZXNzLCB3ZSBhcmUgbm90IHJlc3VtaW5nLiIKIG1zZ3N0ciAi6Kej5Yaz5pON5L2c5pyq6L+b6KGM77yM5oiR5Lus5LiN5Lya57un57ut44CCIgogCi0jOiBidWlsdGluL2FtLmM6MjMzNgorIzogYnVpbHRpbi9hbS5jOjIzMjUKIG1zZ2lkICJpbnRlcmFjdGl2ZSBtb2RlIHJlcXVpcmVzIHBhdGNoZXMgb24gdGhlIGNvbW1hbmQgbGluZSIKIG1zZ3N0ciAi5Lqk5LqS5byP5qih5byP6ZyA6KaB5ZG95Luk6KGM5LiK5o+Q5L6b6KGl5LiBIgogCkBAIC05MjYxLDE1NCArOTMwNiwxNTQgQEAKIG1zZ2lkICItLWJpc2VjdC10ZXJtcyByZXF1aXJlcyAwIG9yIDEgYXJndW1lbnQiCiBtc2dzdHIgIi0tYmlzZWN0LXRlcm1zIOmcgOimgSAwIOaIliAxIOS4quWPguaVsCIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjMyCisjOiBidWlsdGluL2JsYW1lLmM6MzEKIG1zZ2lkICJnaXQgYmxhbWUgWzxvcHRpb25zPl0gWzxyZXYtb3B0cz5dIFs8cmV2Pl0gWy0tXSA8ZmlsZT4iCiBtc2dzdHIgImdpdCBibGFtZSBbPOmAiemhuT5dIFs854mI5pys6YCJ6aG5Pl0gWzzniYjmnKw+XSBbLS1dIDzmlofku7Y+IgogCi0jOiBidWlsdGluL2JsYW1lLmM6MzcKKyM6IGJ1aWx0aW4vYmxhbWUuYzozNgogbXNnaWQgIjxyZXYtb3B0cz4gYXJlIGRvY3VtZW50ZWQgaW4gZ2l0LXJldi1saXN0KDEpIgogbXNnc3RyICI854mI5pys6YCJ6aG5PiDnmoTmlofmoaPorrDlvZXlnKggZ2l0LXJldi1saXN0KDEpIOS4rSIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjQxMAorIzogYnVpbHRpbi9ibGFtZS5jOjQwOQogIywgYy1mb3JtYXQKIG1zZ2lkICJleHBlY3RpbmcgYSBjb2xvcjogJXMiCiBtc2dzdHIgIuacn+acm+S4gOS4quminOiJsu+8miVzIgogCi0jOiBidWlsdGluL2JsYW1lLmM6NDE3CisjOiBidWlsdGluL2JsYW1lLmM6NDE2CiBtc2dpZCAibXVzdCBlbmQgd2l0aCBhIGNvbG9yIgogbXNnc3RyICLlv4Xpobvku6XkuIDkuKrpopzoibLnu5PlsL4iCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo3MzAKKyM6IGJ1aWx0aW4vYmxhbWUuYzo3MjkKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCBjb2xvciAnJXMnIGluIGNvbG9yLmJsYW1lLnJlcGVhdGVkTGluZXMiCiBtc2dzdHIgIuiuvue9riBjb2xvci5ibGFtZS5yZXBlYXRlZExpbmVzIOS4reeahOaXoOaViOminOiJsiAnJXMnIgogCi0jOiBidWlsdGluL2JsYW1lLmM6NzQ4CisjOiBidWlsdGluL2JsYW1lLmM6NzQ3CiBtc2dpZCAiaW52YWxpZCB2YWx1ZSBmb3IgYmxhbWUuY29sb3JpbmciCiBtc2dzdHIgIuiuvue9riBibGFtZS5jb2xvcmluZyDkuK3nmoTml6DmlYjlj5blgLwiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4MjMKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4MjIKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IGZpbmQgcmV2aXNpb24gJXMgdG8gaWdub3JlIgogbXNnc3RyICLkuI3og73mib7liLDopoHlv73nlaXnmoTniYjmnKwgJXMiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NDUKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NDQKIG1zZ2lkICJTaG93IGJsYW1lIGVudHJpZXMgYXMgd2UgZmluZCB0aGVtLCBpbmNyZW1lbnRhbGx5IgogbXNnc3RyICLlop7ph4/lvI/lnLDmmL7npLrlj5HnjrDnmoQgYmxhbWUg5p2h55uuIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODQ2CisjOiBidWlsdGluL2JsYW1lLmM6ODQ1CiBtc2dpZCAiU2hvdyBibGFuayBTSEEtMSBmb3IgYm91bmRhcnkgY29tbWl0cyAoRGVmYXVsdDogb2ZmKSIKIG1zZ3N0ciAi6L6555WM5o+Q5Lqk5pi+56S656m655qEIFNIQS0x77yI6buY6K6k77ya5YWz6Zet77yJIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODQ3CisjOiBidWlsdGluL2JsYW1lLmM6ODQ2CiBtc2dpZCAiRG8gbm90IHRyZWF0IHJvb3QgY29tbWl0cyBhcyBib3VuZGFyaWVzIChEZWZhdWx0OiBvZmYpIgogbXNnc3RyICLkuI3miormoLnmj5DkuqTkvZzkuLrovrnnlYzvvIjpu5jorqTvvJrlhbPpl63vvIkiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NDgKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NDcKIG1zZ2lkICJTaG93IHdvcmsgY29zdCBzdGF0aXN0aWNzIgogbXNnc3RyICLmmL7npLrlkb3ku6TmtojogJfnu5/orqEiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NDkKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NDgKIG1zZ2lkICJGb3JjZSBwcm9ncmVzcyByZXBvcnRpbmciCiBtc2dzdHIgIuW8uuWItui/m+W6puaYvuekuiIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg1MAorIzogYnVpbHRpbi9ibGFtZS5jOjg0OQogbXNnaWQgIlNob3cgb3V0cHV0IHNjb3JlIGZvciBibGFtZSBlbnRyaWVzIgogbXNnc3RyICLmmL7npLrliKTmlq0gYmxhbWUg5p2h55uu5L2N56e755qE5b6X5YiG6K+K5pat5L+h5oGvIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODUxCisjOiBidWlsdGluL2JsYW1lLmM6ODUwCiBtc2dpZCAiU2hvdyBvcmlnaW5hbCBmaWxlbmFtZSAoRGVmYXVsdDogYXV0bykiCiBtc2dzdHIgIuaYvuekuuWOn+Wni+aWh+S7tuWQje+8iOm7mOiupO+8muiHquWKqO+8iSIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg1MgorIzogYnVpbHRpbi9ibGFtZS5jOjg1MQogbXNnaWQgIlNob3cgb3JpZ2luYWwgbGluZW51bWJlciAoRGVmYXVsdDogb2ZmKSIKIG1zZ3N0ciAi5pi+56S65Y6f5aeL55qE6KGM5Y+377yI6buY6K6k77ya5YWz6Zet77yJIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODUzCisjOiBidWlsdGluL2JsYW1lLmM6ODUyCiBtc2dpZCAiU2hvdyBpbiBhIGZvcm1hdCBkZXNpZ25lZCBmb3IgbWFjaGluZSBjb25zdW1wdGlvbiIKIG1zZ3N0ciAi5pi+56S65Li65LiA5Liq6YCC5ZCI5py65Zmo6K+75Y+W55qE5qC85byPIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODU0CisjOiBidWlsdGluL2JsYW1lLmM6ODUzCiBtc2dpZCAiU2hvdyBwb3JjZWxhaW4gZm9ybWF0IHdpdGggcGVyLWxpbmUgY29tbWl0IGluZm9ybWF0aW9uIgogbXNnc3RyICLkuLrmr4/kuIDooYzmmL7npLrmnLrlmajpgILnlKjnmoTmj5DkuqTkv6Hmga8iCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NTUKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NTQKIG1zZ2lkICJVc2UgdGhlIHNhbWUgb3V0cHV0IG1vZGUgYXMgZ2l0LWFubm90YXRlIChEZWZhdWx0OiBvZmYpIgogbXNnc3RyICLkvb/nlKjlkowgZ2l0LWFubm90YXRlIOebuOWQjOeahOi+k+WHuuaooeW8j++8iOm7mOiupO+8muWFs+mXre+8iSIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg1NgorIzogYnVpbHRpbi9ibGFtZS5jOjg1NQogbXNnaWQgIlNob3cgcmF3IHRpbWVzdGFtcCAoRGVmYXVsdDogb2ZmKSIKIG1zZ3N0ciAi5pi+56S65Y6f5aeL5pe26Ze05oiz77yI6buY6K6k77ya5YWz6Zet77yJIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODU3CisjOiBidWlsdGluL2JsYW1lLmM6ODU2CiBtc2dpZCAiU2hvdyBsb25nIGNvbW1pdCBTSEExIChEZWZhdWx0OiBvZmYpIgogbXNnc3RyICLmmL7npLrplb/nmoQgU0hBMSDmj5DkuqTlj7fvvIjpu5jorqTvvJrlhbPpl63vvIkiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NTgKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NTcKIG1zZ2lkICJTdXBwcmVzcyBhdXRob3IgbmFtZSBhbmQgdGltZXN0YW1wIChEZWZhdWx0OiBvZmYpIgogbXNnc3RyICLpmpDol4/kvZzogIXlkI3lrZflkozml7bpl7TmiLPvvIjpu5jorqTvvJrlhbPpl63vvIkiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NTkKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NTgKIG1zZ2lkICJTaG93IGF1dGhvciBlbWFpbCBpbnN0ZWFkIG9mIG5hbWUgKERlZmF1bHQ6IG9mZikiCiBtc2dzdHIgIuaYvuekuuS9nOiAheeahOmCrueuseiAjOS4jeaYr+WQjeWtl++8iOm7mOiupO+8muWFs+mXre+8iSIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg2MAorIzogYnVpbHRpbi9ibGFtZS5jOjg1OQogbXNnaWQgIklnbm9yZSB3aGl0ZXNwYWNlIGRpZmZlcmVuY2VzIgogbXNnc3RyICLlv73nlaXnqbrnmb3lt67lvIIiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NjEgYnVpbHRpbi9sb2cuYzoxNjI5CisjOiBidWlsdGluL2JsYW1lLmM6ODYwIGJ1aWx0aW4vbG9nLmM6MTYzMAogbXNnaWQgInJldiIKIG1zZ3N0ciAi54mI5pysIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODYxCisjOiBidWlsdGluL2JsYW1lLmM6ODYwCiBtc2dpZCAiSWdub3JlIDxyZXY+IHdoZW4gYmxhbWluZyIKIG1zZ3N0ciAi5Zyo5omn6KGMIGJsYW1lIOaTjeS9nOaXtuW/veeVpSA854mI5pysPiIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg2MgorIzogYnVpbHRpbi9ibGFtZS5jOjg2MQogbXNnaWQgIklnbm9yZSByZXZpc2lvbnMgZnJvbSA8ZmlsZT4iCiBtc2dzdHIgIuW/veeVpeadpeiHqiA85paH5Lu2PiDkuK3nmoTniYjmnKwiCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NjMKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NjIKIG1zZ2lkICJjb2xvciByZWR1bmRhbnQgbWV0YWRhdGEgZnJvbSBwcmV2aW91cyBsaW5lIGRpZmZlcmVudGx5IgogbXNnc3RyICLkvb/nlKjpopzoibLpl7TpmpTovpPlh7rkuI7liY3kuIDooYzkuI3lkIznmoTph43lpI3lhYPkv6Hmga8iCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NjQKKyM6IGJ1aWx0aW4vYmxhbWUuYzo4NjMKIG1zZ2lkICJjb2xvciBsaW5lcyBieSBhZ2UiCiBtc2dzdHIgIuS+neaNruaXtumXtOedgOiJsiIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg3MQorIzogYnVpbHRpbi9ibGFtZS5jOjg3MAogbXNnaWQgIlVzZSBhbiBleHBlcmltZW50YWwgaGV1cmlzdGljIHRvIGltcHJvdmUgZGlmZnMiCiBtc2dzdHIgIuS9v+eUqOS4gOS4quivlemqjOaAp+eahOWQr+WPkeW8j+eul+azleaUuei/m+W3ruW8guaYvuekuiIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg3MworIzogYnVpbHRpbi9ibGFtZS5jOjg3MgogbXNnaWQgIlNwZW5kIGV4dHJhIGN5Y2xlcyB0byBmaW5kIGJldHRlciBtYXRjaCIKIG1zZ3N0ciAi6Iqx6LS56aKd5aSW55qE5b6q546v5p2l5om+5Yiw5pu05aW955qE5Yy56YWNIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODc0CisjOiBidWlsdGluL2JsYW1lLmM6ODczCiBtc2dpZCAiVXNlIHJldmlzaW9ucyBmcm9tIDxmaWxlPiBpbnN0ZWFkIG9mIGNhbGxpbmcgZ2l0LXJldi1saXN0IgogbXNnc3RyICLkvb/nlKjmnaXoh6ogPOaWh+S7tj4g55qE5L+u6K6i6ZuG6ICM5LiN5piv6LCD55SoIGdpdC1yZXYtbGlzdCIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg3NQorIzogYnVpbHRpbi9ibGFtZS5jOjg3NAogbXNnaWQgIlVzZSA8ZmlsZT4ncyBjb250ZW50cyBhcyB0aGUgZmluYWwgaW1hZ2UiCiBtc2dzdHIgIuS9v+eUqCA85paH5Lu2PiDnmoTlhoXlrrnkvZzkuLrmnIDnu4jnmoTlm77niYciCiAKLSM6IGJ1aWx0aW4vYmxhbWUuYzo4NzYgYnVpbHRpbi9ibGFtZS5jOjg3NworIzogYnVpbHRpbi9ibGFtZS5jOjg3NSBidWlsdGluL2JsYW1lLmM6ODc2CiBtc2dpZCAic2NvcmUiCiBtc2dzdHIgIuW+l+WIhiIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg3NgorIzogYnVpbHRpbi9ibGFtZS5jOjg3NQogbXNnaWQgIkZpbmQgbGluZSBjb3BpZXMgd2l0aGluIGFuZCBhY3Jvc3MgZmlsZXMiCiBtc2dzdHIgIuaJvuWIsOaWh+S7tuWGheWPiui3qOaWh+S7tueahOihjOaLt+i0nSIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg3NworIzogYnVpbHRpbi9ibGFtZS5jOjg3NgogbXNnaWQgIkZpbmQgbGluZSBtb3ZlbWVudHMgd2l0aGluIGFuZCBhY3Jvc3MgZmlsZXMiCiBtc2dzdHIgIuaJvuWIsOaWh+S7tuWGheWPiui3qOaWh+S7tueahOihjOenu+WKqCIKIAotIzogYnVpbHRpbi9ibGFtZS5jOjg3OAorIzogYnVpbHRpbi9ibGFtZS5jOjg3NwogbXNnaWQgIm4sbSIKIG1zZ3N0ciAibixtIgogCi0jOiBidWlsdGluL2JsYW1lLmM6ODc4CisjOiBidWlsdGluL2JsYW1lLmM6ODc3CiBtc2dpZCAiUHJvY2VzcyBvbmx5IGxpbmUgcmFuZ2UgbixtLCBjb3VudGluZyBmcm9tIDEiCiBtc2dzdHIgIuWPquWkhOeQhuihjOiMg+WbtOWcqCBuIOWSjCBtIOS5i+mXtOeahO+8jOS7jiAxIOW8gOWniyIKIApAQCAtOTY0Niw3ICs5NjkxLDcgQEAKIG1zZ2lkICJkbyBub3QgdXNlIgogbXNnc3RyICLkuI3opoHkvb/nlKgiCiAKLSM6IGJ1aWx0aW4vYnJhbmNoLmM6NjI2IGJ1aWx0aW4vcmViYXNlLmM6NDg1CisjOiBidWlsdGluL2JyYW5jaC5jOjYyNiBidWlsdGluL3JlYmFzZS5jOjQ4NgogbXNnaWQgInVwc3RyZWFtIgogbXNnc3RyICLkuIrmuLgiCiAKQEAgLTk3NTcsNyArOTgwMiw3IEBACiBtc2dpZCAiZm9ybWF0IHRvIHVzZSBmb3IgdGhlIG91dHB1dCIKIG1zZ3N0ciAi6L6T5Ye65qC85byPIgogCi0jOiBidWlsdGluL2JyYW5jaC5jOjY4NCBidWlsdGluL2Nsb25lLmM6NzYxCisjOiBidWlsdGluL2JyYW5jaC5jOjY4NCBidWlsdGluL2Nsb25lLmM6NzYwCiBtc2dpZCAiSEVBRCBub3QgZm91bmQgYmVsb3cgcmVmcy9oZWFkcyEiCiBtc2dzdHIgIkhFQUQg5rKh5pyJ5L2N5LqOIC9yZWZzL2hlYWRzIOS5i+S4i++8gSIKIApAQCAtOTg1Niw3ICs5OTAxLDcgQEAKIG1zZ2lkICJOZWVkIGEgcmVwb3NpdG9yeSB0byB1bmJ1bmRsZS4iCiBtc2dzdHIgIumcgOimgeS4gOS4quS7k+W6k+adpeino+WMheOAgiIKIAotIzogYnVpbHRpbi9jYXQtZmlsZS5jOjU5NAorIzogYnVpbHRpbi9jYXQtZmlsZS5jOjU5NQogbXNnaWQgIiIKICJnaXQgY2F0LWZpbGUgKC10IFstLWFsbG93LXVua25vd24tdHlwZV0gfCAtcyBbLS1hbGxvdy11bmtub3duLXR5cGVdIHwgLWUgfCAtIgogInAgfCA8dHlwZT4gfCAtLXRleHRjb252IHwgLS1maWx0ZXJzKSBbLS1wYXRoPTxwYXRoPl0gPG9iamVjdD4iCkBAIC05ODY0LDcgKzk5MDksNyBAQAogImdpdCBjYXQtZmlsZSAoLXQgWy0tYWxsb3ctdW5rbm93bi10eXBlXSB8IC1zIFstLWFsbG93LXVua25vd24tdHlwZV0gfCAtZSB8IC0iCiAicCB8IDznsbvlnos+IHwgLS10ZXh0Y29udiB8IC0tZmlsdGVycykgWy0tcGF0aD086Lev5b6EPl0gPOWvueixoT4iCiAKLSM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo1OTUKKyM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo1OTYKIG1zZ2lkICIiCiAiZ2l0IGNhdC1maWxlICgtLWJhdGNoIHwgLS1iYXRjaC1jaGVjaykgWy0tZm9sbG93LXN5bWxpbmtzXSBbLS10ZXh0Y29udiB8IC0tIgogImZpbHRlcnNdIgpAQCAtOTg3Miw3MSArOTkxNyw3MSBAQAogImdpdCBjYXQtZmlsZSAoLS1iYXRjaCB8IC0tYmF0Y2gtY2hlY2spIFstLWZvbGxvdy1zeW1saW5rc10gWy0tdGV4dGNvbnYgfCAtLSIKICJmaWx0ZXJzXSIKIAotIzogYnVpbHRpbi9jYXQtZmlsZS5jOjYxNgorIzogYnVpbHRpbi9jYXQtZmlsZS5jOjYxNwogbXNnaWQgIm9ubHkgb25lIGJhdGNoIG9wdGlvbiBtYXkgYmUgc3BlY2lmaWVkIgogbXNnc3RyICLlj6rog73mjIflrprkuIDkuKrmibnlpITnkIbpgInpobkiCiAKLSM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2MzQKKyM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2MzUKIG1zZ2lkICI8dHlwZT4gY2FuIGJlIG9uZSBvZjogYmxvYiwgdHJlZSwgY29tbWl0LCB0YWciCiBtc2dzdHIgIjznsbvlnos+IOWPr+S7peaYr+WFtuS4reS5i+S4gO+8mmJsb2LjgIF0cmVl44CBY29tbWl044CBdGFnIgogCi0jOiBidWlsdGluL2NhdC1maWxlLmM6NjM1CisjOiBidWlsdGluL2NhdC1maWxlLmM6NjM2CiBtc2dpZCAic2hvdyBvYmplY3QgdHlwZSIKIG1zZ3N0ciAi5pi+56S65a+56LGh57G75Z6LIgogCi0jOiBidWlsdGluL2NhdC1maWxlLmM6NjM2CisjOiBidWlsdGluL2NhdC1maWxlLmM6NjM3CiBtc2dpZCAic2hvdyBvYmplY3Qgc2l6ZSIKIG1zZ3N0ciAi5pi+56S65a+56LGh5aSn5bCPIgogCi0jOiBidWlsdGluL2NhdC1maWxlLmM6NjM4CisjOiBidWlsdGluL2NhdC1maWxlLmM6NjM5CiBtc2dpZCAiZXhpdCB3aXRoIHplcm8gd2hlbiB0aGVyZSdzIG5vIGVycm9yIgogbXNnc3RyICLlvZPmsqHmnInplJnor6/ml7bpgIDlh7rlubbov5Tlm57pm7YiCiAKLSM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2MzkKKyM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NDAKIG1zZ2lkICJwcmV0dHktcHJpbnQgb2JqZWN0J3MgY29udGVudCIKIG1zZ3N0ciAi576O6KeC5Zyw5omT5Y2w5a+56LGh55qE5YaF5a65IgogCi0jOiBidWlsdGluL2NhdC1maWxlLmM6NjQxCisjOiBidWlsdGluL2NhdC1maWxlLmM6NjQyCiBtc2dpZCAiZm9yIGJsb2Igb2JqZWN0cywgcnVuIHRleHRjb252IG9uIG9iamVjdCdzIGNvbnRlbnQiCiBtc2dzdHIgIuWvueS6juaVsOaNruWvueixoe+8jOWvueWFtuWGheWuueWBmuaWh+acrOi9rOaNoiIKIAotIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY0MworIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY0NAogbXNnaWQgImZvciBibG9iIG9iamVjdHMsIHJ1biBmaWx0ZXJzIG9uIG9iamVjdCdzIGNvbnRlbnQiCiBtc2dzdHIgIuWvueS6juaVsOaNruWvueixoe+8jOWvueWFtuWGheWuueWBmui/h+a7pCIKIAotIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY0NCBnaXQtc3VibW9kdWxlLnNoOjkzNgorIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY0NSBnaXQtc3VibW9kdWxlLnNoOjkzNgogbXNnaWQgImJsb2IiCiBtc2dzdHIgIuaVsOaNruWvueixoSIKIAotIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY0NQorIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY0NgogbXNnaWQgInVzZSBhIHNwZWNpZmljIHBhdGggZm9yIC0tdGV4dGNvbnYvLS1maWx0ZXJzIgogbXNnc3RyICLlr7nkuo4gLS10ZXh0Y29udi8tLWZpbHRlcnMg5L2/55So5LiA5Liq54m55a6a55qE6Lev5b6EIgogCi0jOiBidWlsdGluL2NhdC1maWxlLmM6NjQ3CisjOiBidWlsdGluL2NhdC1maWxlLmM6NjQ4CiBtc2dpZCAiYWxsb3cgLXMgYW5kIC10IHRvIHdvcmsgd2l0aCBicm9rZW4vY29ycnVwdCBvYmplY3RzIgogbXNnc3RyICLlhYHorrggLXMg5ZKMIC10IOWvueaNn+Wdj+eahOWvueixoeeUn+aViCIKIAotIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY0OAorIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY0OQogbXNnaWQgImJ1ZmZlciAtLWJhdGNoIG91dHB1dCIKIG1zZ3N0ciAi57yT5YayIC0tYmF0Y2gg55qE6L6T5Ye6IgogCi0jOiBidWlsdGluL2NhdC1maWxlLmM6NjUwCisjOiBidWlsdGluL2NhdC1maWxlLmM6NjUxCiBtc2dpZCAic2hvdyBpbmZvIGFuZCBjb250ZW50IG9mIG9iamVjdHMgZmVkIGZyb20gdGhlIHN0YW5kYXJkIGlucHV0IgogbXNnc3RyICLmmL7npLrku47moIflh4bovpPlhaXmj5DkvpvnmoTlr7nosaHnmoTkv6Hmga/lkozlhoXlrrkiCiAKLSM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NTQKKyM6IGJ1aWx0aW4vY2F0LWZpbGUuYzo2NTUKIG1zZ2lkICJzaG93IGluZm8gYWJvdXQgb2JqZWN0cyBmZWQgZnJvbSB0aGUgc3RhbmRhcmQgaW5wdXQiCiBtc2dzdHIgIuaYvuekuuS7juagh+WHhui+k+WFpeaPkOS+m+eahOWvueixoeeahOS/oeaBryIKIAotIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY1OAorIzogYnVpbHRpbi9jYXQtZmlsZS5jOjY1OQogbXNnaWQgImZvbGxvdyBpbi10cmVlIHN5bWxpbmtzICh1c2VkIHdpdGggLS1iYXRjaCBvciAtLWJhdGNoLWNoZWNrKSIKIG1zZ3N0ciAi6Lef6ZqP5qCR5YaF56ym5Y+36ZO+5o6l77yI5ZKMIC0tYmF0Y2gg5oiWIC0tYmF0Y2gtY2hlY2sg5YWx55So77yJIgogCi0jOiBidWlsdGluL2NhdC1maWxlLmM6NjYwCisjOiBidWlsdGluL2NhdC1maWxlLmM6NjYxCiBtc2dpZCAic2hvdyBhbGwgb2JqZWN0cyB3aXRoIC0tYmF0Y2ggb3IgLS1iYXRjaC1jaGVjayIKIG1zZ3N0ciAi5L2/55SoIC0tYmF0Y2gg5oiWIC0tYmF0Y2gtY2hlY2sg5Y+C5pWw5pi+56S65omA5pyJ5a+56LGhIgogCi0jOiBidWlsdGluL2NhdC1maWxlLmM6NjYyCisjOiBidWlsdGluL2NhdC1maWxlLmM6NjYzCiBtc2dpZCAiZG8gbm90IG9yZGVyIC0tYmF0Y2gtYWxsLW9iamVjdHMgb3V0cHV0IgogbXNnc3RyICLkuI3opoHlr7kgLS1iYXRjaC1hbGwtb2JqZWN0cyDnmoTovpPlh7rmjpLluo8iCiAKQEAgLTk5NjQsOCArMTAwMDksOCBAQAogbXNnaWQgInRlcm1pbmF0ZSBpbnB1dCBhbmQgb3V0cHV0IHJlY29yZHMgYnkgYSBOVUwgY2hhcmFjdGVyIgogbXNnc3RyICLovpPlhaXlkozovpPlh7rnmoTorrDlvZXkvb/nlKggTlVMIOWtl+espue7iOe7kyIKIAotIzogYnVpbHRpbi9jaGVjay1pZ25vcmUuYzoyMSBidWlsdGluL2NoZWNrb3V0LmM6MTQzMyBidWlsdGluL2djLmM6NTM4Ci0jOiBidWlsdGluL3dvcmt0cmVlLmM6NTA3CisjOiBidWlsdGluL2NoZWNrLWlnbm9yZS5jOjIxIGJ1aWx0aW4vY2hlY2tvdXQuYzoxNDMzIGJ1aWx0aW4vZ2MuYzo1MzcKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo1MDYKIG1zZ2lkICJzdXBwcmVzcyBwcm9ncmVzcyByZXBvcnRpbmciCiBtc2dzdHIgIuS4jeaYvuekuui/m+W6puaKpeWRiiIKIApAQCAtMTAwNTcsNyArMTAxMDIsNyBAQAogIzogYnVpbHRpbi9jaGVja291dC1pbmRleC5jOjE3OCBidWlsdGluL2NvbHVtbi5jOjMxCiAjOiBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6MTM3MyBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6MTM3NgogIzogYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjEzODQgYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjE4NTcKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo2ODAKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo2NzkKIG1zZ2lkICJzdHJpbmciCiBtc2dzdHIgIuWtl+espuS4siIKIApAQCAtMTAwODUsOTggKzEwMTMwLDk4IEBACiBtc2dpZCAiZ2l0IHJlc3RvcmUgWzxvcHRpb25zPl0gWy0tc291cmNlPTxicmFuY2g+XSA8ZmlsZT4uLi4iCiBtc2dzdHIgImdpdCByZXN0b3JlIFs86YCJ6aG5Pl0gWy0tc291cmNlPTzliIbmlK8+XSA85paH5Lu2Pi4uLiIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjE3MiBidWlsdGluL2NoZWNrb3V0LmM6MjExCisjOiBidWlsdGluL2NoZWNrb3V0LmM6MTczIGJ1aWx0aW4vY2hlY2tvdXQuYzoyMTIKICMsIGMtZm9ybWF0CiBtc2dpZCAicGF0aCAnJXMnIGRvZXMgbm90IGhhdmUgb3VyIHZlcnNpb24iCiBtc2dzdHIgIui3r+W+hCAnJXMnIOayoeacieaIkeS7rOeahOeJiOacrCIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjE3NCBidWlsdGluL2NoZWNrb3V0LmM6MjEzCisjOiBidWlsdGluL2NoZWNrb3V0LmM6MTc1IGJ1aWx0aW4vY2hlY2tvdXQuYzoyMTQKICMsIGMtZm9ybWF0CiBtc2dpZCAicGF0aCAnJXMnIGRvZXMgbm90IGhhdmUgdGhlaXIgdmVyc2lvbiIKIG1zZ3N0ciAi6Lev5b6EICclcycg5rKh5pyJ5LuW5Lus55qE54mI5pysIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6MTkwCisjOiBidWlsdGluL2NoZWNrb3V0LmM6MTkxCiAjLCBjLWZvcm1hdAogbXNnaWQgInBhdGggJyVzJyBkb2VzIG5vdCBoYXZlIGFsbCBuZWNlc3NhcnkgdmVyc2lvbnMiCiBtc2dzdHIgIui3r+W+hCAnJXMnIOayoeacieWFqOmDqOW/hemcgOeahOeJiOacrCIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjI0MAorIzogYnVpbHRpbi9jaGVja291dC5jOjI0MQogIywgYy1mb3JtYXQKIG1zZ2lkICJwYXRoICclcycgZG9lcyBub3QgaGF2ZSBuZWNlc3NhcnkgdmVyc2lvbnMiCiBtc2dzdHIgIui3r+W+hCAnJXMnIOayoeacieW/hemcgOeahOeJiOacrCIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjI1OAorIzogYnVpbHRpbi9jaGVja291dC5jOjI1OQogIywgYy1mb3JtYXQKIG1zZ2lkICJwYXRoICclcyc6IGNhbm5vdCBtZXJnZSIKIG1zZ3N0ciAicGF0aCAnJXMn77ya5peg5rOV5ZCI5bm2IgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6Mjc0CisjOiBidWlsdGluL2NoZWNrb3V0LmM6Mjc1CiAjLCBjLWZvcm1hdAogbXNnaWQgIlVuYWJsZSB0byBhZGQgbWVyZ2UgcmVzdWx0IGZvciAnJXMnIgogbXNnc3RyICLml6Dms5XkuLogJyVzJyDmt7vliqDlkIjlubbnu5PmnpwiCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzozNzQKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzozNzUKICMsIGMtZm9ybWF0CiBtc2dpZCAiUmVjcmVhdGVkICVkIG1lcmdlIGNvbmZsaWN0IgogbXNnaWRfcGx1cmFsICJSZWNyZWF0ZWQgJWQgbWVyZ2UgY29uZmxpY3RzIgogbXNnc3RyWzBdICLph43mlrDliJvlu7rkuoYgJWQg5Liq5ZCI5bm25Yay56qBIgogbXNnc3RyWzFdICLph43mlrDliJvlu7rkuoYgJWQg5Liq5ZCI5bm25Yay56qBIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6Mzc5CisjOiBidWlsdGluL2NoZWNrb3V0LmM6MzgwCiAjLCBjLWZvcm1hdAogbXNnaWQgIlVwZGF0ZWQgJWQgcGF0aCBmcm9tICVzIgogbXNnaWRfcGx1cmFsICJVcGRhdGVkICVkIHBhdGhzIGZyb20gJXMiCiBtc2dzdHJbMF0gIuS7jiAlMiRzIOabtOaWsOS6hiAlMSRkIOS4qui3r+W+hCIKIG1zZ3N0clsxXSAi5LuOICUyJHMg5pu05paw5LqGICUxJGQg5Liq6Lev5b6EIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6Mzg2CisjOiBidWlsdGluL2NoZWNrb3V0LmM6Mzg3CiAjLCBjLWZvcm1hdAogbXNnaWQgIlVwZGF0ZWQgJWQgcGF0aCBmcm9tIHRoZSBpbmRleCIKIG1zZ2lkX3BsdXJhbCAiVXBkYXRlZCAlZCBwYXRocyBmcm9tIHRoZSBpbmRleCIKIG1zZ3N0clswXSAi5LuO57Si5byV5Yy65pu05paw5LqGICVkIOS4qui3r+W+hCIKIG1zZ3N0clsxXSAi5LuO57Si5byV5Yy65pu05paw5LqGICVkIOS4qui3r+W+hCIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjQwOSBidWlsdGluL2NoZWNrb3V0LmM6NDEyIGJ1aWx0aW4vY2hlY2tvdXQuYzo0MTUKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo0MTkKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo0MTAgYnVpbHRpbi9jaGVja291dC5jOjQxMyBidWlsdGluL2NoZWNrb3V0LmM6NDE2CisjOiBidWlsdGluL2NoZWNrb3V0LmM6NDIwCiAjLCBjLWZvcm1hdAogbXNnaWQgIiclcycgY2Fubm90IGJlIHVzZWQgd2l0aCB1cGRhdGluZyBwYXRocyIKIG1zZ3N0ciAiJyVzJyDkuI3og73lnKjmm7TmlrDot6/lvoTml7bkvb/nlKgiCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo0MjIgYnVpbHRpbi9jaGVja291dC5jOjQyNQorIzogYnVpbHRpbi9jaGVja291dC5jOjQyMyBidWlsdGluL2NoZWNrb3V0LmM6NDI2CiAjLCBjLWZvcm1hdAogbXNnaWQgIiclcycgY2Fubm90IGJlIHVzZWQgd2l0aCAlcyIKIG1zZ3N0ciAiJyVzJyDkuI3og73lkowgJXMg5ZCM5pe25L2/55SoIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6NDI5CisjOiBidWlsdGluL2NoZWNrb3V0LmM6NDMwCiAjLCBjLWZvcm1hdAogbXNnaWQgIkNhbm5vdCB1cGRhdGUgcGF0aHMgYW5kIHN3aXRjaCB0byBicmFuY2ggJyVzJyBhdCB0aGUgc2FtZSB0aW1lLiIKIG1zZ3N0ciAi5LiN6IO95ZCM5pe25pu05paw6Lev5b6E5bm25YiH5o2i5Yiw5YiG5pSvJyVzJ+OAgiIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjQzMworIzogYnVpbHRpbi9jaGVja291dC5jOjQzNAogIywgYy1mb3JtYXQKIG1zZ2lkICJuZWl0aGVyICclcycgb3IgJyVzJyBpcyBzcGVjaWZpZWQiCiBtc2dzdHIgIiclcycg5oiWICclcycg6YO95rKh5pyJ5oyH5a6aIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6NDM3CisjOiBidWlsdGluL2NoZWNrb3V0LmM6NDM4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiclcycgbXVzdCBiZSB1c2VkIHdoZW4gJyVzJyBpcyBub3Qgc3BlY2lmaWVkIgogbXNnc3RyICLmnKrmjIflrpogJyUyJHMnIOaXtu+8jOW/hemhu+S9v+eUqCAnJTEkcyciCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo0NDIgYnVpbHRpbi9jaGVja291dC5jOjQ0NworIzogYnVpbHRpbi9jaGVja291dC5jOjQ0MyBidWlsdGluL2NoZWNrb3V0LmM6NDQ4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiclcycgb3IgJyVzJyBjYW5ub3QgYmUgdXNlZCB3aXRoICVzIgogbXNnc3RyICInJXMnIOaIliAnJXMnIOS4jeiDveWSjCAlcyDkuIDotbfkvb/nlKgiCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo1MDYgYnVpbHRpbi9jaGVja291dC5jOjUxMworIzogYnVpbHRpbi9jaGVja291dC5jOjUwNyBidWlsdGluL2NoZWNrb3V0LmM6NTE0CiAjLCBjLWZvcm1hdAogbXNnaWQgInBhdGggJyVzJyBpcyB1bm1lcmdlZCIKIG1zZ3N0ciAi6Lev5b6EICclcycg5pyq5ZCI5bm2IgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6Njc5CisjOiBidWlsdGluL2NoZWNrb3V0LmM6NjgwCiBtc2dpZCAieW91IG5lZWQgdG8gcmVzb2x2ZSB5b3VyIGN1cnJlbnQgaW5kZXggZmlyc3QiCiBtc2dzdHIgIuaCqOmcgOimgeWFiOino+WGs+W9k+WJjee0ouW8leeahOWGsueqgSIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjcyOQorIzogYnVpbHRpbi9jaGVja291dC5jOjczMAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiY2Fubm90IGNvbnRpbnVlIHdpdGggc3RhZ2VkIGNoYW5nZXMgaW4gdGhlIGZvbGxvd2luZyBmaWxlczpcbiIKQEAgLTEwMTg1LDExICsxMDIzMCw2IEBACiAi5LiN6IO957un57ut77yM5LiL5YiX5paH5Lu25pyJ5pqC5a2Y55qE5L+u5pS577yaXG4iCiAiJXMiCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzo3MzYKLSMsIGMtZm9ybWF0Ci1tc2dpZCAic3RhZ2VkIGNoYW5nZXMgaW4gdGhlIGZvbGxvd2luZyBmaWxlcyBtYXkgYmUgbG9zdDogJXMiCi1tc2dzdHIgIuS4i+WIl+aWh+S7tuaaguWtmOeahOS/ruaUueWPr+iDveS8muS4ouWkse+8miVzIgotCiAjOiBidWlsdGluL2NoZWNrb3V0LmM6ODMzCiAjLCBjLWZvcm1hdAogbXNnaWQgIkNhbiBub3QgZG8gcmVmbG9nIGZvciAnJXMnOiAlc1xuIgpAQCAtMTAxOTksNyArMTAyMzksNyBAQAogbXNnaWQgIkhFQUQgaXMgbm93IGF0IgogbXNnc3RyICJIRUFEIOebruWJjeS9jeS6jiIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjg3OSBidWlsdGluL2Nsb25lLmM6NzE0CisjOiBidWlsdGluL2NoZWNrb3V0LmM6ODc5IGJ1aWx0aW4vY2xvbmUuYzo3MTMKIG1zZ2lkICJ1bmFibGUgdG8gdXBkYXRlIEhFQUQiCiBtc2dzdHIgIuS4jeiDveabtOaWsCBIRUFEIgogCkBAIC0xMDMxMiw3ICsxMDM1Miw3IEBACiAiJyVzJyDml6Llj6/ku6XmmK/kuIDkuKrmnKzlnLDmlofku7bvvIzkuZ/lj6/ku6XmmK/kuIDkuKrot5/ouKrliIbmlK/jgIJcbiIKICLor7fkvb/nlKggLS3vvIjlkozlj6/pgInnmoQgLS1uby1ndWVzc++8ieadpea2iOmZpOatp+S5iSIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjEyNDMgYnVpbHRpbi93b3JrdHJlZS5jOjI5MSBidWlsdGluL3dvcmt0cmVlLmM6NDU2CisjOiBidWlsdGluL2NoZWNrb3V0LmM6MTI0MyBidWlsdGluL3dvcmt0cmVlLmM6MjkwIGJ1aWx0aW4vd29ya3RyZWUuYzo0NTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW52YWxpZCByZWZlcmVuY2U6ICVzIgogbXNnc3RyICLml6DmlYjlvJXnlKjvvJolcyIKQEAgLTEwNDE1LDkgKzEwNDU1LDkgQEAKIG1zZ2lkICJtaXNzaW5nIGJyYW5jaCBvciBjb21taXQgYXJndW1lbnQiCiBtc2dzdHIgIue8uuWwkeWIhuaUr+aIluaPkOS6pOWPguaVsCIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjE0MzcgYnVpbHRpbi9jbG9uZS5jOjkxIGJ1aWx0aW4vZmV0Y2guYzoxNTEKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoyODUgYnVpbHRpbi9wdWxsLmM6MTM3IGJ1aWx0aW4vcHVzaC5jOjU3NQotIzogYnVpbHRpbi9zZW5kLXBhY2suYzoxNzQKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNDM3IGJ1aWx0aW4vY2xvbmUuYzo5MCBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjU5CisjOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE4MCBidWlsdGluL2ZldGNoLmM6MTY2IGJ1aWx0aW4vbWVyZ2UuYzoyODUKKyM6IGJ1aWx0aW4vcHVsbC5jOjEzOCBidWlsdGluL3B1c2guYzo1NjIgYnVpbHRpbi9zZW5kLXBhY2suYzoxNzQKIG1zZ2lkICJmb3JjZSBwcm9ncmVzcyByZXBvcnRpbmciCiBtc2dzdHIgIuW8uuWItuaYvuekuui/m+W6puaKpeWRiiIKIApAQCAtMTA0MjUsNyArMTA0NjUsNyBAQAogbXNnaWQgInBlcmZvcm0gYSAzLXdheSBtZXJnZSB3aXRoIHRoZSBuZXcgYnJhbmNoIgogbXNnc3RyICLlkozmlrDnmoTliIbmlK/miafooYzkuInmlrnlkIjlubYiCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNDM5IGJ1aWx0aW4vbG9nLmM6MTYxNyBwYXJzZS1vcHRpb25zLmg6MzE4CisjOiBidWlsdGluL2NoZWNrb3V0LmM6MTQzOSBidWlsdGluL2xvZy5jOjE2MTggcGFyc2Utb3B0aW9ucy5oOjMxOAogbXNnaWQgInN0eWxlIgogbXNnc3RyICLpo47moLwiCiAKQEAgLTEwNDMzLDcgKzEwNDczLDcgQEAKIG1zZ2lkICJjb25mbGljdCBzdHlsZSAobWVyZ2Ugb3IgZGlmZjMpIgogbXNnc3RyICLlhrLnqoHovpPlh7rpo47moLzvvIhtZXJnZSDmiJYgZGlmZjPvvIkiCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNDUyIGJ1aWx0aW4vd29ya3RyZWUuYzo1MDQKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNDUyIGJ1aWx0aW4vd29ya3RyZWUuYzo1MDMKIG1zZ2lkICJkZXRhY2ggSEVBRCBhdCBuYW1lZCBjb21taXQiCiBtc2dzdHIgIkhFQUQg5LuO5oyH5a6a55qE5o+Q5Lqk5YiG56a7IgogCkBAIC0xMDU0Nyw5ICsxMDU4Nyw5IEBACiAi5aaC5p6c5oKo5oC75piv5Zac5qyi5L2/55So5qih57OK55qE566A55+t5YiG5pSv5ZCNIDxuYW1lPu+8jOiAjOS4jeWWnOasouWmgiAnb3JpZ2luJyDnmoTov5znqItcbiIKICLku5PlupPlkI3vvIzlj6/ku6XlnKjphY3nva7kuK3orr7nva4gY2hlY2tvdXQuZGVmYXVsdFJlbW90ZT1vcmlnaW7jgIIiCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNjkxIGJ1aWx0aW4vY2hlY2tvdXQuYzoxNjkzIGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzMzCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6MTczNSBidWlsdGluL2Nsb25lLmM6MTIxIGJ1aWx0aW4vcmVtb3RlLmM6MTY5Ci0jOiBidWlsdGluL3JlbW90ZS5jOjE3MSBidWlsdGluL3dvcmt0cmVlLmM6NTAwIGJ1aWx0aW4vd29ya3RyZWUuYzo1MDIKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNjkxIGJ1aWx0aW4vY2hlY2tvdXQuYzoxNjkzIGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzQyCisjOiBidWlsdGluL2NoZWNrb3V0LmM6MTc0NCBidWlsdGluL2Nsb25lLmM6MTIwIGJ1aWx0aW4vcmVtb3RlLmM6MTY5CisjOiBidWlsdGluL3JlbW90ZS5jOjE3MSBidWlsdGluL3dvcmt0cmVlLmM6NDk5IGJ1aWx0aW4vd29ya3RyZWUuYzo1MDEKIG1zZ2lkICJicmFuY2giCiBtc2dzdHIgIuWIhuaUryIKIApAQCAtMTA1NzMsMzkgKzEwNjEzLDM5IEBACiBtc2dpZCAidXNlIG92ZXJsYXkgbW9kZSAoZGVmYXVsdCkiCiBtc2dzdHIgIuS9v+eUqOWPoOWKoOaooeW8j++8iOm7mOiupO+8iSIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjE3MzQKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzQzCiBtc2dpZCAiY3JlYXRlIGFuZCBzd2l0Y2ggdG8gYSBuZXcgYnJhbmNoIgogbXNnc3RyICLliJvlu7rlubbliIfmjaLkuIDkuKrmlrDliIbmlK8iCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzM2CisjOiBidWlsdGluL2NoZWNrb3V0LmM6MTc0NQogbXNnaWQgImNyZWF0ZS9yZXNldCBhbmQgc3dpdGNoIHRvIGEgYnJhbmNoIgogbXNnc3RyICLliJvlu7ov6YeN572u5bm25YiH5o2i5LiA5Liq5YiG5pSvIgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6MTczOAorIzogYnVpbHRpbi9jaGVja291dC5jOjE3NDcKIG1zZ2lkICJzZWNvbmQgZ3Vlc3MgJ2dpdCBzd2l0Y2ggPG5vLXN1Y2gtYnJhbmNoPiciCiBtc2dzdHIgIuS6jOasoeeMnOa1iyAnZ2l0IHN3aXRjaCA85peg5q2k5YiG5pSvPiciCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzQwCisjOiBidWlsdGluL2NoZWNrb3V0LmM6MTc0OQogbXNnaWQgInRocm93IGF3YXkgbG9jYWwgbW9kaWZpY2F0aW9ucyIKIG1zZ3N0ciAi5Lii5byD5pys5Zyw5L+u5pS5IgogCi0jOiBidWlsdGluL2NoZWNrb3V0LmM6MTc3MgorIzogYnVpbHRpbi9jaGVja291dC5jOjE3ODEKIG1zZ2lkICJ3aGljaCB0cmVlLWlzaCB0byBjaGVja291dCBmcm9tIgogbXNnc3RyICLopoHmo4Dlh7rlk6rkuIDkuKrmoJEiCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzc0CisjOiBidWlsdGluL2NoZWNrb3V0LmM6MTc4MwogbXNnaWQgInJlc3RvcmUgdGhlIGluZGV4IgogbXNnc3RyICLmgaLlpI3ntKLlvJUiCiAKLSM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzc2CisjOiBidWlsdGluL2NoZWNrb3V0LmM6MTc4NQogbXNnaWQgInJlc3RvcmUgdGhlIHdvcmtpbmcgdHJlZSAoZGVmYXVsdCkiCiBtc2dzdHIgIuaBouWkjeW3peS9nOWMuu+8iOm7mOiupO+8iSIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjE3NzgKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzg3CiBtc2dpZCAiaWdub3JlIHVubWVyZ2VkIGVudHJpZXMiCiBtc2dzdHIgIuW/veeVpeacquWQiOW5tuadoeebriIKIAotIzogYnVpbHRpbi9jaGVja291dC5jOjE3NzkKKyM6IGJ1aWx0aW4vY2hlY2tvdXQuYzoxNzg4CiBtc2dpZCAidXNlIG92ZXJsYXkgbW9kZSIKIG1zZ3N0ciAi5L2/55So5Y+g5Yqg5qih5byPIgogCkBAIC0xMDY0NSw3ICsxMDY4NSw3IEBACiBtc2dpZCAiY291bGQgbm90IGxzdGF0ICVzXG4iCiBtc2dzdHIgIuS4jeiDveWvuSAlcyDosIPnlKggbHN0YXRcbiIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjMwMCBnaXQtYWRkLS1pbnRlcmFjdGl2ZS5wZXJsOjU5MworIzogYnVpbHRpbi9jbGVhbi5jOjMwMSBnaXQtYWRkLS1pbnRlcmFjdGl2ZS5wZXJsOjU5MwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiUHJvbXB0IGhlbHA6XG4iCkBAIC0xMDY1OCw3ICsxMDY5OCw3IEBACiAiZm9vICAgICAgICAtIOmAmui/h+WUr+S4gOWJjee8gOmAieaLqeS4gOS4qumAiemhuVxuIgogIiAgICAgICAgICAgLSDvvIjnqbrvvInku4DkuYjkuZ/kuI3pgInmi6lcbiIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjMwNCBnaXQtYWRkLS1pbnRlcmFjdGl2ZS5wZXJsOjYwMgorIzogYnVpbHRpbi9jbGVhbi5jOjMwNSBnaXQtYWRkLS1pbnRlcmFjdGl2ZS5wZXJsOjYwMgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiUHJvbXB0IGhlbHA6XG4iCkBAIC0xMDY3OSwzOCArMTA3MTksMzggQEAKICIqICAgICAgICAgIC0g6YCJ5oup5omA5pyJ6YCJ6aG5XG4iCiAiICAgICAgICAgICAtIO+8iOepuu+8iee7k+adn+mAieaLqVxuIgogCi0jOiBidWlsdGluL2NsZWFuLmM6NTIwIGdpdC1hZGQtLWludGVyYWN0aXZlLnBlcmw6NTY4CisjOiBidWlsdGluL2NsZWFuLmM6NTIxIGdpdC1hZGQtLWludGVyYWN0aXZlLnBlcmw6NTY4CiAjOiBnaXQtYWRkLS1pbnRlcmFjdGl2ZS5wZXJsOjU3MwogIywgYy1mb3JtYXQsIHBlcmwtZm9ybWF0CiBtc2dpZCAiSHVoICglcyk/XG4iCiBtc2dzdHIgIuWXr++8iCVz77yJ77yfXG4iCiAKLSM6IGJ1aWx0aW4vY2xlYW4uYzo2NjIKKyM6IGJ1aWx0aW4vY2xlYW4uYzo2NjMKICMsIGMtZm9ybWF0CiBtc2dpZCAiSW5wdXQgaWdub3JlIHBhdHRlcm5zPj4gIgogbXNnc3RyICLovpPlhaXmqKHniYjku6XmjpLpmaTmnaHnm64+PiAiCiAKLSM6IGJ1aWx0aW4vY2xlYW4uYzo2OTkKKyM6IGJ1aWx0aW4vY2xlYW4uYzo3MDAKICMsIGMtZm9ybWF0CiBtc2dpZCAiV0FSTklORzogQ2Fubm90IGZpbmQgaXRlbXMgbWF0Y2hlZCBieTogJXMiCiBtc2dzdHIgIuitpuWRiu+8muaXoOazleaJvuWIsOWSjCAlcyDljLnphY3nmoTmnaHnm64iCiAKLSM6IGJ1aWx0aW4vY2xlYW4uYzo3MjAKKyM6IGJ1aWx0aW4vY2xlYW4uYzo3MjEKIG1zZ2lkICJTZWxlY3QgaXRlbXMgdG8gZGVsZXRlIgogbXNnc3RyICLpgInmi6nopoHliKDpmaTnmoTmnaHnm64iCiAKICMuIFRSQU5TTEFUT1JTOiBNYWtlIHN1cmUgdG8ga2VlcCBbeS9OXSBhcyBpcwotIzogYnVpbHRpbi9jbGVhbi5jOjc2MQorIzogYnVpbHRpbi9jbGVhbi5jOjc2MgogIywgYy1mb3JtYXQKIG1zZ2lkICJSZW1vdmUgJXMgW3kvTl0/ICIKIG1zZ3N0ciAi5Yig6ZmkICVzIFt5L05d77yfIgogCi0jOiBidWlsdGluL2NsZWFuLmM6Nzg2IGdpdC1hZGQtLWludGVyYWN0aXZlLnBlcmw6MTc2MworIzogYnVpbHRpbi9jbGVhbi5jOjc4NyBnaXQtYWRkLS1pbnRlcmFjdGl2ZS5wZXJsOjE3NjMKICMsIGMtZm9ybWF0CiBtc2dpZCAiQnllLlxuIgogbXNnc3RyICLlho3op4HjgIJcbiIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjc5NAorIzogYnVpbHRpbi9jbGVhbi5jOjc5NQogbXNnaWQgIiIKICJjbGVhbiAgICAgICAgICAgICAgIC0gc3RhcnQgY2xlYW5pbmdcbiIKICJmaWx0ZXIgYnkgcGF0dGVybiAgIC0gZXhjbHVkZSBpdGVtcyBmcm9tIGRlbGV0aW9uXG4iCkBAIC0xMDcyOCwyMzEgKzEwNzY4LDIzMSBAQAogImhlbHAgICAgICAgICAgICAgICAgLSDmmL7npLrmnKzluK7liqlcbiIKICI/ICAgICAgICAgICAgICAgICAgIC0g5pi+56S65aaC5L2V5Zyo5o+Q56S656ym5LiL6YCJ5oup55qE5biu5YqpIgogCi0jOiBidWlsdGluL2NsZWFuLmM6ODIxIGdpdC1hZGQtLWludGVyYWN0aXZlLnBlcmw6MTg0OQorIzogYnVpbHRpbi9jbGVhbi5jOjgyMiBnaXQtYWRkLS1pbnRlcmFjdGl2ZS5wZXJsOjE4NDkKIG1zZ2lkICIqKiogQ29tbWFuZHMgKioqIgogbXNnc3RyICIqKiog5ZG95LukICoqKiIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjgyMiBnaXQtYWRkLS1pbnRlcmFjdGl2ZS5wZXJsOjE4NDYKKyM6IGJ1aWx0aW4vY2xlYW4uYzo4MjMgZ2l0LWFkZC0taW50ZXJhY3RpdmUucGVybDoxODQ2CiBtc2dpZCAiV2hhdCBub3ciCiBtc2dzdHIgIuivt+mAieaLqSIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjgzMAorIzogYnVpbHRpbi9jbGVhbi5jOjgzMQogbXNnaWQgIldvdWxkIHJlbW92ZSB0aGUgZm9sbG93aW5nIGl0ZW06IgogbXNnaWRfcGx1cmFsICJXb3VsZCByZW1vdmUgdGhlIGZvbGxvd2luZyBpdGVtczoiCiBtc2dzdHJbMF0gIuWwhuWIoOmZpOWmguS4i+adoeebru+8miIKIG1zZ3N0clsxXSAi5bCG5Yig6Zmk5aaC5LiL5p2h55uu77yaIgogCi0jOiBidWlsdGluL2NsZWFuLmM6ODQ2CisjOiBidWlsdGluL2NsZWFuLmM6ODQ3CiBtc2dpZCAiTm8gbW9yZSBmaWxlcyB0byBjbGVhbiwgZXhpdGluZy4iCiBtc2dzdHIgIuayoeacieimgea4heeQhueahOaWh+S7tu+8jOmAgOWHuuOAgiIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjkwOAorIzogYnVpbHRpbi9jbGVhbi5jOjkwOQogbXNnaWQgImRvIG5vdCBwcmludCBuYW1lcyBvZiBmaWxlcyByZW1vdmVkIgogbXNnc3RyICLkuI3miZPljbDliKDpmaTmlofku7bnmoTlkI3np7AiCiAKLSM6IGJ1aWx0aW4vY2xlYW4uYzo5MTAKKyM6IGJ1aWx0aW4vY2xlYW4uYzo5MTEKIG1zZ2lkICJmb3JjZSIKIG1zZ3N0ciAi5by65Yi2IgogCi0jOiBidWlsdGluL2NsZWFuLmM6OTExCisjOiBidWlsdGluL2NsZWFuLmM6OTEyCiBtc2dpZCAiaW50ZXJhY3RpdmUgY2xlYW5pbmciCiBtc2dzdHIgIuS6pOS6kuW8j+a4hemZpCIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjkxMworIzogYnVpbHRpbi9jbGVhbi5jOjkxNAogbXNnaWQgInJlbW92ZSB3aG9sZSBkaXJlY3RvcmllcyIKIG1zZ3N0ciAi5Yig6Zmk5pW05Liq55uu5b2VIgogCi0jOiBidWlsdGluL2NsZWFuLmM6OTE0IGJ1aWx0aW4vZGVzY3JpYmUuYzo1NDYgYnVpbHRpbi9kZXNjcmliZS5jOjU0OAotIzogYnVpbHRpbi9ncmVwLmM6ODk5IGJ1aWx0aW4vbG9nLmM6MTc2IGJ1aWx0aW4vbG9nLmM6MTc4Ci0jOiBidWlsdGluL2xzLWZpbGVzLmM6NTU3IGJ1aWx0aW4vbmFtZS1yZXYuYzo0MTMgYnVpbHRpbi9uYW1lLXJldi5jOjQxNQorIzogYnVpbHRpbi9jbGVhbi5jOjkxNSBidWlsdGluL2Rlc2NyaWJlLmM6NTQ4IGJ1aWx0aW4vZGVzY3JpYmUuYzo1NTAKKyM6IGJ1aWx0aW4vZ3JlcC5jOjkwMSBidWlsdGluL2xvZy5jOjE3NiBidWlsdGluL2xvZy5jOjE3OAorIzogYnVpbHRpbi9scy1maWxlcy5jOjU1NyBidWlsdGluL25hbWUtcmV2LmM6NDE3IGJ1aWx0aW4vbmFtZS1yZXYuYzo0MTkKICM6IGJ1aWx0aW4vc2hvdy1yZWYuYzoxNzkKIG1zZ2lkICJwYXR0ZXJuIgogbXNnc3RyICLmqKHlvI8iCiAKLSM6IGJ1aWx0aW4vY2xlYW4uYzo5MTUKKyM6IGJ1aWx0aW4vY2xlYW4uYzo5MTYKIG1zZ2lkICJhZGQgPHBhdHRlcm4+IHRvIGlnbm9yZSBydWxlcyIKIG1zZ3N0ciAi5re75YqgIDzmqKHlvI8+IOWIsOW/veeVpeinhOWImSIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjkxNgorIzogYnVpbHRpbi9jbGVhbi5jOjkxNwogbXNnaWQgInJlbW92ZSBpZ25vcmVkIGZpbGVzLCB0b28iCiBtc2dzdHIgIuS5n+WIoOmZpOW/veeVpeeahOaWh+S7tiIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjkxOAorIzogYnVpbHRpbi9jbGVhbi5jOjkxOQogbXNnaWQgInJlbW92ZSBvbmx5IGlnbm9yZWQgZmlsZXMiCiBtc2dzdHIgIuWPquWIoOmZpOW/veeVpeeahOaWh+S7tiIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjkzNgorIzogYnVpbHRpbi9jbGVhbi5jOjkzNwogbXNnaWQgIi14IGFuZCAtWCBjYW5ub3QgYmUgdXNlZCB0b2dldGhlciIKIG1zZ3N0ciAiLXgg5ZKMIC1YIOS4jeiDveWQjOaXtuS9v+eUqCIKIAotIzogYnVpbHRpbi9jbGVhbi5jOjk0MAorIzogYnVpbHRpbi9jbGVhbi5jOjk0MQogbXNnaWQgIiIKICJjbGVhbi5yZXF1aXJlRm9yY2Ugc2V0IHRvIHRydWUgYW5kIG5laXRoZXIgLWksIC1uLCBub3IgLWYgZ2l2ZW47IHJlZnVzaW5nIHRvICIKICJjbGVhbiIKIG1zZ3N0ciAiIgogImNsZWFuLnJlcXVpcmVGb3JjZSDorr7nva7kuLogdHJ1ZSDkuJTmnKrmj5DkvpsgLWnjgIEtbiDmiJYgLWYg6YCJ6aG577yM5ouS57ud5omn6KGM5riF55CG5Yqo5L2cIgogCi0jOiBidWlsdGluL2NsZWFuLmM6OTQzCisjOiBidWlsdGluL2NsZWFuLmM6OTQ0CiBtc2dpZCAiIgogImNsZWFuLnJlcXVpcmVGb3JjZSBkZWZhdWx0cyB0byB0cnVlIGFuZCBuZWl0aGVyIC1pLCAtbiwgbm9yIC1mIGdpdmVuOyAiCiAicmVmdXNpbmcgdG8gY2xlYW4iCiBtc2dzdHIgIiIKICJjbGVhbi5yZXF1aXJlRm9yY2Ug6buY6K6k5Li6IHRydWUg5LiU5pyq5o+Q5L6bIC1p44CBLW4g5oiWIC1mIOmAiemhue+8jOaLkue7neaJp+ihjOa4heeQhuWKqOS9nCIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjQ2CisjOiBidWlsdGluL2Nsb25lLmM6NDUKIG1zZ2lkICJnaXQgY2xvbmUgWzxvcHRpb25zPl0gWy0tXSA8cmVwbz4gWzxkaXI+XSIKIG1zZ3N0ciAiZ2l0IGNsb25lIFs86YCJ6aG5Pl0gWy0tXSA85LuT5bqTPiBbPOi3r+W+hD5dIgogCi0jOiBidWlsdGluL2Nsb25lLmM6OTMKKyM6IGJ1aWx0aW4vY2xvbmUuYzo5MgogbXNnaWQgImRvbid0IGNyZWF0ZSBhIGNoZWNrb3V0IgogbXNnc3RyICLkuI3liJvlu7rkuIDkuKrmo4Dlh7oiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo5NCBidWlsdGluL2Nsb25lLmM6OTYgYnVpbHRpbi9pbml0LWRiLmM6NDg5CisjOiBidWlsdGluL2Nsb25lLmM6OTMgYnVpbHRpbi9jbG9uZS5jOjk1IGJ1aWx0aW4vaW5pdC1kYi5jOjQ4OQogbXNnaWQgImNyZWF0ZSBhIGJhcmUgcmVwb3NpdG9yeSIKIG1zZ3N0ciAi5Yib5bu65LiA5Liq57qv5LuT5bqTIgogCi0jOiBidWlsdGluL2Nsb25lLmM6OTgKKyM6IGJ1aWx0aW4vY2xvbmUuYzo5NwogbXNnaWQgImNyZWF0ZSBhIG1pcnJvciByZXBvc2l0b3J5IChpbXBsaWVzIGJhcmUpIgogbXNnc3RyICLliJvlu7rkuIDkuKrplZzlg4/ku5PlupPvvIjkuZ/mmK/nuq/ku5PlupPvvIkiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMDAKKyM6IGJ1aWx0aW4vY2xvbmUuYzo5OQogbXNnaWQgInRvIGNsb25lIGZyb20gYSBsb2NhbCByZXBvc2l0b3J5IgogbXNnc3RyICLku47mnKzlnLDku5PlupPlhYvpmoYiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMDIKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMDEKIG1zZ2lkICJkb24ndCB1c2UgbG9jYWwgaGFyZGxpbmtzLCBhbHdheXMgY29weSIKIG1zZ3N0ciAi5LiN5L2/55So5pys5Zyw56Gs6ZO+5o6l77yM5aeL57uI5aSN5Yi2IgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTA0CisjOiBidWlsdGluL2Nsb25lLmM6MTAzCiBtc2dpZCAic2V0dXAgYXMgc2hhcmVkIHJlcG9zaXRvcnkiCiBtc2dzdHIgIuiuvue9ruS4uuWFseS6q+S7k+W6kyIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEwNworIzogYnVpbHRpbi9jbG9uZS5jOjEwNgogbXNnaWQgInBhdGhzcGVjIgogbXNnc3RyICLot6/lvoTop4TmoLwiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMDcKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMDYKIG1zZ2lkICJpbml0aWFsaXplIHN1Ym1vZHVsZXMgaW4gdGhlIGNsb25lIgogbXNnc3RyICLlnKjlhYvpmobml7bliJ3lp4vljJblrZDmqKHnu4QiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMTAKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMDkKIG1zZ2lkICJudW1iZXIgb2Ygc3VibW9kdWxlcyBjbG9uZWQgaW4gcGFyYWxsZWwiCiBtc2dzdHIgIuW5tuWPkeWFi+mahueahOWtkOaooee7hOeahOaVsOmHjyIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjExMSBidWlsdGluL2luaXQtZGIuYzo0ODYKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMTAgYnVpbHRpbi9pbml0LWRiLmM6NDg2CiBtc2dpZCAidGVtcGxhdGUtZGlyZWN0b3J5IgogbXNnc3RyICLmqKHmnb/nm67lvZUiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMTIgYnVpbHRpbi9pbml0LWRiLmM6NDg3CisjOiBidWlsdGluL2Nsb25lLmM6MTExIGJ1aWx0aW4vaW5pdC1kYi5jOjQ4NwogbXNnaWQgImRpcmVjdG9yeSBmcm9tIHdoaWNoIHRlbXBsYXRlcyB3aWxsIGJlIHVzZWQiCiBtc2dzdHIgIuaooeadv+ebruW9leWwhuiiq+S9v+eUqCIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjExNCBidWlsdGluL2Nsb25lLmM6MTE2IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxMzgwCisjOiBidWlsdGluL2Nsb25lLmM6MTEzIGJ1aWx0aW4vY2xvbmUuYzoxMTUgYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjEzODAKICM6IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxODYwCiBtc2dpZCAicmVmZXJlbmNlIHJlcG9zaXRvcnkiCiBtc2dzdHIgIuWPguiAg+S7k+W6kyIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjExOCBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6MTM4MgorIzogYnVpbHRpbi9jbG9uZS5jOjExNyBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6MTM4MgogIzogYnVpbHRpbi9zdWJtb2R1bGUtLWhlbHBlci5jOjE4NjIKIG1zZ2lkICJ1c2UgLS1yZWZlcmVuY2Ugb25seSB3aGlsZSBjbG9uaW5nIgogbXNnc3RyICLku4XlnKjlhYvpmobml7blj4LogIMgLS1yZWZlcmVuY2Ug5oyH5ZCR55qE5pys5Zyw5LuT5bqTIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTE5IGJ1aWx0aW4vY29sdW1uLmM6MjcgYnVpbHRpbi9tZXJnZS1maWxlLmM6NDYKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMxNCBidWlsdGluL3JlcGFjay5jOjMxOQorIzogYnVpbHRpbi9jbG9uZS5jOjExOCBidWlsdGluL2NvbHVtbi5jOjI3IGJ1aWx0aW4vbWVyZ2UtZmlsZS5jOjQ2CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyOTQgYnVpbHRpbi9yZXBhY2suYzozMjAKIG1zZ2lkICJuYW1lIgogbXNnc3RyICLlkI3np7AiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMjAKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMTkKIG1zZ2lkICJ1c2UgPG5hbWU+IGluc3RlYWQgb2YgJ29yaWdpbicgdG8gdHJhY2sgdXBzdHJlYW0iCiBtc2dzdHIgIuS9v+eUqCA85ZCN56ewPiDogIzkuI3mmK8gJ29yaWdpbicg5Y676Lef6Liq5LiK5ri4IgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTIyCisjOiBidWlsdGluL2Nsb25lLmM6MTIxCiBtc2dpZCAiY2hlY2tvdXQgPGJyYW5jaD4gaW5zdGVhZCBvZiB0aGUgcmVtb3RlJ3MgSEVBRCIKIG1zZ3N0ciAi5qOA5Ye6IDzliIbmlK8+IOiAjOS4jeaYr+i/nOeoiyBIRUFEIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTI0CisjOiBidWlsdGluL2Nsb25lLmM6MTIzCiBtc2dpZCAicGF0aCB0byBnaXQtdXBsb2FkLXBhY2sgb24gdGhlIHJlbW90ZSIKIG1zZ3N0ciAi6L+c56iLIGdpdC11cGxvYWQtcGFjayDot6/lvoQiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMjUgYnVpbHRpbi9mZXRjaC5jOjE1MiBidWlsdGluL2dyZXAuYzo4MzgKLSM6IGJ1aWx0aW4vcHVsbC5jOjIyNgorIzogYnVpbHRpbi9jbG9uZS5jOjEyNCBidWlsdGluL2ZldGNoLmM6MTY3IGJ1aWx0aW4vZ3JlcC5jOjg0MAorIzogYnVpbHRpbi9wdWxsLmM6MjI3CiBtc2dpZCAiZGVwdGgiCiBtc2dzdHIgIua3seW6piIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEyNgorIzogYnVpbHRpbi9jbG9uZS5jOjEyNQogbXNnaWQgImNyZWF0ZSBhIHNoYWxsb3cgY2xvbmUgb2YgdGhhdCBkZXB0aCIKIG1zZ3N0ciAi5Yib5bu65LiA5Liq5oyH5a6a5rex5bqm55qE5rWF5YWL6ZqGIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTI3IGJ1aWx0aW4vZmV0Y2guYzoxNTQgYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzAzCisjOiBidWlsdGluL2Nsb25lLmM6MTI2IGJ1aWx0aW4vZmV0Y2guYzoxNjkgYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjgzCiBtc2dpZCAidGltZSIKIG1zZ3N0ciAi5pe26Ze0IgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTI4CisjOiBidWlsdGluL2Nsb25lLmM6MTI3CiBtc2dpZCAiY3JlYXRlIGEgc2hhbGxvdyBjbG9uZSBzaW5jZSBhIHNwZWNpZmljIHRpbWUiCiBtc2dzdHIgIuS7juS4gOS4queJueWumuaXtumXtOWIm+W7uuS4gOS4qua1heWFi+mahiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEyOSBidWlsdGluL2ZldGNoLmM6MTU2IGJ1aWx0aW4vZmV0Y2guYzoxNzkKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTM5NQorIzogYnVpbHRpbi9jbG9uZS5jOjEyOCBidWlsdGluL2ZldGNoLmM6MTcxIGJ1aWx0aW4vZmV0Y2guYzoxOTQKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQxNwogbXNnaWQgInJldmlzaW9uIgogbXNnc3RyICLniYjmnKwiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMzAgYnVpbHRpbi9mZXRjaC5jOjE1NworIzogYnVpbHRpbi9jbG9uZS5jOjEyOSBidWlsdGluL2ZldGNoLmM6MTcyCiBtc2dpZCAiZGVlcGVuIGhpc3Rvcnkgb2Ygc2hhbGxvdyBjbG9uZSwgZXhjbHVkaW5nIHJldiIKIG1zZ3N0ciAi5rex5YyW5rWF5YWL6ZqG55qE5Y6G5Y+y77yM6Zmk5LqG54m55a6a54mI5pysIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTMyCisjOiBidWlsdGluL2Nsb25lLmM6MTMxCiBtc2dpZCAiY2xvbmUgb25seSBvbmUgYnJhbmNoLCBIRUFEIG9yIC0tYnJhbmNoIgogbXNnc3RyICLlj6rlhYvpmobkuIDkuKrliIbmlK/jgIFIRUFEIOaIliAtLWJyYW5jaCIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEzNAorIzogYnVpbHRpbi9jbG9uZS5jOjEzMwogbXNnaWQgImRvbid0IGNsb25lIGFueSB0YWdzLCBhbmQgbWFrZSBsYXRlciBmZXRjaGVzIG5vdCB0byBmb2xsb3cgdGhlbSIKIG1zZ3N0ciAi5LiN6KaB5YWL6ZqG5Lu75L2V5qCH562+77yM5bm25LiU5ZCO57ut6I635Y+W5pON5L2c5Lmf5LiN5LiL6L295a6D5LusIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTM2CisjOiBidWlsdGluL2Nsb25lLmM6MTM1CiBtc2dpZCAiYW55IGNsb25lZCBzdWJtb2R1bGVzIHdpbGwgYmUgc2hhbGxvdyIKIG1zZ3N0ciAi5a2Q5qih57uE5bCG5Lul5rWF5LiL6L295qih5byP5YWL6ZqGIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTM3IGJ1aWx0aW4vaW5pdC1kYi5jOjQ5NQorIzogYnVpbHRpbi9jbG9uZS5jOjEzNiBidWlsdGluL2luaXQtZGIuYzo0OTUKIG1zZ2lkICJnaXRkaXIiCiBtc2dzdHIgImdpdOebruW9lSIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEzOCBidWlsdGluL2luaXQtZGIuYzo0OTYKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMzcgYnVpbHRpbi9pbml0LWRiLmM6NDk2CiBtc2dpZCAic2VwYXJhdGUgZ2l0IGRpciBmcm9tIHdvcmtpbmcgdHJlZSIKIG1zZ3N0ciAiZ2l055uu5b2V5ZKM5bel5L2c5Yy65YiG56a7IgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTM5CisjOiBidWlsdGluL2Nsb25lLmM6MTM4CiBtc2dpZCAia2V5PXZhbHVlIgogbXNnc3RyICJrZXk9dmFsdWUiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxNDAKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMzkKIG1zZ2lkICJzZXQgY29uZmlnIGluc2lkZSB0aGUgbmV3IHJlcG9zaXRvcnkiCiBtc2dzdHIgIuWcqOaWsOS7k+W6k+S4reiuvue9rumFjee9ruS/oeaBryIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjE0MiBidWlsdGluL2ZldGNoLmM6MTc0IGJ1aWx0aW4vbHMtcmVtb3RlLmM6NzYKLSM6IGJ1aWx0aW4vcHVzaC5jOjU4NSBidWlsdGluL3NlbmQtcGFjay5jOjE3MgorIzogYnVpbHRpbi9jbG9uZS5jOjE0MSBidWlsdGluL2ZldGNoLmM6MTg5IGJ1aWx0aW4vbHMtcmVtb3RlLmM6NzYKKyM6IGJ1aWx0aW4vcHVzaC5jOjU3MiBidWlsdGluL3NlbmQtcGFjay5jOjE3MgogbXNnaWQgInNlcnZlci1zcGVjaWZpYyIKIG1zZ3N0ciAic2VydmVyLXNwZWNpZmljIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTQyIGJ1aWx0aW4vZmV0Y2guYzoxNzQgYnVpbHRpbi9scy1yZW1vdGUuYzo3NgotIzogYnVpbHRpbi9wdXNoLmM6NTg1IGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTczCisjOiBidWlsdGluL2Nsb25lLmM6MTQxIGJ1aWx0aW4vZmV0Y2guYzoxODkgYnVpbHRpbi9scy1yZW1vdGUuYzo3NgorIzogYnVpbHRpbi9wdXNoLmM6NTcyIGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTczCiBtc2dpZCAib3B0aW9uIHRvIHRyYW5zbWl0IgogbXNnc3RyICLkvKDovpPpgInpobkiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxNDMgYnVpbHRpbi9mZXRjaC5jOjE3NSBidWlsdGluL3B1bGwuYzoyMzkKLSM6IGJ1aWx0aW4vcHVzaC5jOjU4NgorIzogYnVpbHRpbi9jbG9uZS5jOjE0MiBidWlsdGluL2ZldGNoLmM6MTkwIGJ1aWx0aW4vcHVsbC5jOjI0MAorIzogYnVpbHRpbi9wdXNoLmM6NTczCiBtc2dpZCAidXNlIElQdjQgYWRkcmVzc2VzIG9ubHkiCiBtc2dzdHIgIuWPquS9v+eUqCBJUHY0IOWcsOWdgCIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjE0NSBidWlsdGluL2ZldGNoLmM6MTc3IGJ1aWx0aW4vcHVsbC5jOjI0MgotIzogYnVpbHRpbi9wdXNoLmM6NTg4CisjOiBidWlsdGluL2Nsb25lLmM6MTQ0IGJ1aWx0aW4vZmV0Y2guYzoxOTIgYnVpbHRpbi9wdWxsLmM6MjQzCisjOiBidWlsdGluL3B1c2guYzo1NzUKIG1zZ2lkICJ1c2UgSVB2NiBhZGRyZXNzZXMgb25seSIKIG1zZ3N0ciAi5Y+q5L2/55SoIElQdjYg5Zyw5Z2AIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTQ5CisjOiBidWlsdGluL2Nsb25lLmM6MTQ4CiBtc2dpZCAiYW55IGNsb25lZCBzdWJtb2R1bGVzIHdpbGwgdXNlIHRoZWlyIHJlbW90ZS10cmFja2luZyBicmFuY2giCiBtc2dzdHIgIuS7u+S9leWFi+mahueahOWtkOaooee7hOWwhuS9v+eUqOWug+S7rOeahOi/nOeoi+i3n+i4quWIhuaUryIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjI4NQorIzogYnVpbHRpbi9jbG9uZS5jOjI4NAogbXNnaWQgIiIKICJObyBkaXJlY3RvcnkgbmFtZSBjb3VsZCBiZSBndWVzc2VkLlxuIgogIlBsZWFzZSBzcGVjaWZ5IGEgZGlyZWN0b3J5IG9uIHRoZSBjb21tYW5kIGxpbmUiCkBAIC0xMDk2MCw0NyArMTEwMDAsNDIgQEAKICLml6Dms5XnjJzliLDnm67lvZXlkI3jgIJcbiIKICLor7flnKjlkb3ku6TooYzmjIflrprkuIDkuKrnm67lvZUiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzozMzgKKyM6IGJ1aWx0aW4vY2xvbmUuYzozMzcKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW5mbzogQ291bGQgbm90IGFkZCBhbHRlcm5hdGUgZm9yICclcyc6ICVzXG4iCiBtc2dzdHIgImluZm86IOS4jeiDveS4uiAnJXMnIOa3u+WKoOS4gOS4quWkh+eUqO+8miVzXG4iCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo0MTEKKyM6IGJ1aWx0aW4vY2xvbmUuYzo0MTAKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgZXhpc3RzIGFuZCBpcyBub3QgYSBkaXJlY3RvcnkiCiBtc2dzdHIgIiVzIOWtmOWcqOS4lOS4jeaYr+S4gOS4quebruW9lSIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjQyOAorIzogYnVpbHRpbi9jbG9uZS5jOjQyNwogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gc3RhcnQgaXRlcmF0b3Igb3ZlciAnJXMnIgogbXNnc3RyICLml6Dms5XlnKggJyVzJyDkuIrlkK/liqjov63ku6PlmagiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo0NTMKLSMsIGMtZm9ybWF0Ci1tc2dpZCAiZmFpbGVkIHRvIHVubGluayAnJXMnIgotbXNnc3RyICLliKDpmaQgJyVzJyDlpLHotKUiCi0KLSM6IGJ1aWx0aW4vY2xvbmUuYzo0NTgKKyM6IGJ1aWx0aW4vY2xvbmUuYzo0NTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIGNyZWF0ZSBsaW5rICclcyciCiBtc2dzdHIgIuWIm+W7uumTvuaOpSAnJXMnIOWksei0pSIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjQ2MgorIzogYnVpbHRpbi9jbG9uZS5jOjQ2MQogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gY29weSBmaWxlIHRvICclcyciCiBtc2dzdHIgIuaLt+i0neaWh+S7tuiHsyAnJXMnIOWksei0pSIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjQ2NworIzogYnVpbHRpbi9jbG9uZS5jOjQ2NgogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gaXRlcmF0ZSBvdmVyICclcyciCiBtc2dzdHIgIuaXoOazleWcqCAnJXMnIOS4iui/reS7oyIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjQ5MgorIzogYnVpbHRpbi9jbG9uZS5jOjQ5MQogIywgYy1mb3JtYXQKIG1zZ2lkICJkb25lLlxuIgogbXNnc3RyICLlrozmiJDjgIJcbiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjUwNgorIzogYnVpbHRpbi9jbG9uZS5jOjUwNQogbXNnaWQgIiIKICJDbG9uZSBzdWNjZWVkZWQsIGJ1dCBjaGVja291dCBmYWlsZWQuXG4iCiAiWW91IGNhbiBpbnNwZWN0IHdoYXQgd2FzIGNoZWNrZWQgb3V0IHdpdGggJ2dpdCBzdGF0dXMnXG4iCkBAIC0xMTAxMCwxMzAgKzExMDQ1LDEzMCBAQAogIuaCqOWPr+S7pemAmui/hyAnZ2l0IHN0YXR1cycg5qOA5p+l5ZOq5Lqb5bey6KKr5qOA5Ye677yM54S25ZCO5L2/55So5ZG95LukXG4iCiAiJ2dpdCByZXN0b3JlIC0tc291cmNlPUhFQUQgOi8nIOmHjeivlVxuIgogCi0jOiBidWlsdGluL2Nsb25lLmM6NTgzCisjOiBidWlsdGluL2Nsb25lLmM6NTgyCiAjLCBjLWZvcm1hdAogbXNnaWQgIkNvdWxkIG5vdCBmaW5kIHJlbW90ZSBicmFuY2ggJXMgdG8gY2xvbmUuIgogbXNnc3RyICLkuI3og73lj5HnjrDopoHlhYvpmobnmoTov5znqIvliIbmlK8gJXPjgIIiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo3MDIKKyM6IGJ1aWx0aW4vY2xvbmUuYzo3MDEKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHVwZGF0ZSAlcyIKIG1zZ3N0ciAi5LiN6IO95pu05pawICVzIgogCi0jOiBidWlsdGluL2Nsb25lLmM6NzUyCisjOiBidWlsdGluL2Nsb25lLmM6NzUxCiBtc2dpZCAicmVtb3RlIEhFQUQgcmVmZXJzIHRvIG5vbmV4aXN0ZW50IHJlZiwgdW5hYmxlIHRvIGNoZWNrb3V0LlxuIgogbXNnc3RyICLov5znqIsgSEVBRCDmjIflkJHkuIDkuKrkuI3lrZjlnKjnmoTlvJXnlKjvvIzml6Dms5Xmo4Dlh7rjgIJcbiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjc4MworIzogYnVpbHRpbi9jbG9uZS5jOjc4MgogbXNnaWQgInVuYWJsZSB0byBjaGVja291dCB3b3JraW5nIHRyZWUiCiBtc2dzdHIgIuS4jeiDveajgOWHuuW3peS9nOWMuiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjgzMworIzogYnVpbHRpbi9jbG9uZS5jOjgzMgogbXNnaWQgInVuYWJsZSB0byB3cml0ZSBwYXJhbWV0ZXJzIHRvIGNvbmZpZyBmaWxlIgogbXNnc3RyICLml6Dms5XlsIblj4LmlbDlhpnlhaXphY3nva7mlofku7YiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo4OTYKKyM6IGJ1aWx0aW4vY2xvbmUuYzo4OTUKIG1zZ2lkICJjYW5ub3QgcmVwYWNrIHRvIGNsZWFuIHVwIgogbXNnc3RyICLml6Dms5XmiafooYwgcmVwYWNrIOadpea4heeQhiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjg5OAorIzogYnVpbHRpbi9jbG9uZS5jOjg5NwogbXNnaWQgImNhbm5vdCB1bmxpbmsgdGVtcG9yYXJ5IGFsdGVybmF0ZXMgZmlsZSIKIG1zZ3N0ciAi5peg5rOV5Yig6Zmk5Li05pe255qEIGFsdGVybmF0ZXMg5paH5Lu2IgogCi0jOiBidWlsdGluL2Nsb25lLmM6OTM4IGJ1aWx0aW4vcmVjZWl2ZS1wYWNrLmM6MTk1MAorIzogYnVpbHRpbi9jbG9uZS5jOjkzNyBidWlsdGluL3JlY2VpdmUtcGFjay5jOjE5NDgKIG1zZ2lkICJUb28gbWFueSBhcmd1bWVudHMuIgogbXNnc3RyICLlpKrlpJrlj4LmlbDjgIIiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo5NDIKKyM6IGJ1aWx0aW4vY2xvbmUuYzo5NDEKIG1zZ2lkICJZb3UgbXVzdCBzcGVjaWZ5IGEgcmVwb3NpdG9yeSB0byBjbG9uZS4iCiBtc2dzdHIgIuaCqOW/hemhu+aMh+WumuS4gOS4quS7k+W6k+adpeWFi+mahuOAgiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjk1NQorIzogYnVpbHRpbi9jbG9uZS5jOjk1NAogIywgYy1mb3JtYXQKIG1zZ2lkICItLWJhcmUgYW5kIC0tb3JpZ2luICVzIG9wdGlvbnMgYXJlIGluY29tcGF0aWJsZS4iCiBtc2dzdHIgIi0tYmFyZSDlkowgLS1vcmlnaW4gJXMg6YCJ6aG55LiN5YW85a6544CCIgogCi0jOiBidWlsdGluL2Nsb25lLmM6OTU4CisjOiBidWlsdGluL2Nsb25lLmM6OTU3CiBtc2dpZCAiLS1iYXJlIGFuZCAtLXNlcGFyYXRlLWdpdC1kaXIgYXJlIGluY29tcGF0aWJsZS4iCiBtc2dzdHIgIi0tYmFyZSDlkowgLS1zZXBhcmF0ZS1naXQtZGlyIOmAiemhueS4jeWFvOWuueOAgiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjk3MQorIzogYnVpbHRpbi9jbG9uZS5jOjk3MAogIywgYy1mb3JtYXQKIG1zZ2lkICJyZXBvc2l0b3J5ICclcycgZG9lcyBub3QgZXhpc3QiCiBtc2dzdHIgIuS7k+W6kyAnJXMnIOS4jeWtmOWcqCIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjk3NyBidWlsdGluL2ZldGNoLmM6MTY2MAorIzogYnVpbHRpbi9jbG9uZS5jOjk3NiBidWlsdGluL2ZldGNoLmM6MTc5MAogIywgYy1mb3JtYXQKIG1zZ2lkICJkZXB0aCAlcyBpcyBub3QgYSBwb3NpdGl2ZSBudW1iZXIiCiBtc2dzdHIgIua3seW6piAlcyDkuI3mmK/kuIDkuKrmraPmlbAiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzo5ODcKKyM6IGJ1aWx0aW4vY2xvbmUuYzo5ODYKICMsIGMtZm9ybWF0CiBtc2dpZCAiZGVzdGluYXRpb24gcGF0aCAnJXMnIGFscmVhZHkgZXhpc3RzIGFuZCBpcyBub3QgYW4gZW1wdHkgZGlyZWN0b3J5LiIKIG1zZ3N0ciAi55uu5qCH6Lev5b6EICclcycg5bey57uP5a2Y5Zyo77yM5bm25LiU5LiN5piv5LiA5Liq56m655uu5b2V44CCIgogCi0jOiBidWlsdGluL2Nsb25lLmM6OTk3CisjOiBidWlsdGluL2Nsb25lLmM6OTk2CiAjLCBjLWZvcm1hdAogbXNnaWQgIndvcmtpbmcgdHJlZSAnJXMnIGFscmVhZHkgZXhpc3RzLiIKIG1zZ3N0ciAi5bel5L2c5Yy6ICclcycg5bey57uP5a2Y5Zyo44CCIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTAxMiBidWlsdGluL2Nsb25lLmM6MTAzMyBidWlsdGluL2RpZmZ0b29sLmM6MjY0Ci0jOiBidWlsdGluL3dvcmt0cmVlLmM6MzAzIGJ1aWx0aW4vd29ya3RyZWUuYzozMzUKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMDExIGJ1aWx0aW4vY2xvbmUuYzoxMDMyIGJ1aWx0aW4vZGlmZnRvb2wuYzoyNzEKKyM6IGJ1aWx0aW4vbG9nLmM6MTc4NSBidWlsdGluL3dvcmt0cmVlLmM6MzAyIGJ1aWx0aW4vd29ya3RyZWUuYzozMzQKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IGNyZWF0ZSBsZWFkaW5nIGRpcmVjdG9yaWVzIG9mICclcyciCiBtc2dzdHIgIuS4jeiDveS4uiAnJXMnIOWIm+W7uuWFiOWvvOebruW9lSIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEwMTcKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMDE2CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBjcmVhdGUgd29yayB0cmVlIGRpciAnJXMnIgogbXNnc3RyICLkuI3og73liJvlu7rlt6XkvZzljLrnm67lvZUgJyVzJyIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEwMzcKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMDM2CiAjLCBjLWZvcm1hdAogbXNnaWQgIkNsb25pbmcgaW50byBiYXJlIHJlcG9zaXRvcnkgJyVzJy4uLlxuIgogbXNnc3RyICLlhYvpmobliLDnuq/ku5PlupMgJyVzJy4uLlxuIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTAzOQorIzogYnVpbHRpbi9jbG9uZS5jOjEwMzgKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ2xvbmluZyBpbnRvICclcycuLi5cbiIKIG1zZ3N0ciAi5q2j5YWL6ZqG5YiwICclcycuLi5cbiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEwNjMKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMDYyCiBtc2dpZCAiIgogImNsb25lIC0tcmVjdXJzaXZlIGlzIG5vdCBjb21wYXRpYmxlIHdpdGggYm90aCAtLXJlZmVyZW5jZSBhbmQgLS1yZWZlcmVuY2UtaWYtIgogImFibGUiCiBtc2dzdHIgImNsb25lIC0tcmVjdXJzaXZlIOWSjCAtLXJlZmVyZW5jZSDku6Xlj4ogLS1yZWZlcmVuY2UtaWYtYWJsZSDkuI3lhbzlrrkiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMTI0CisjOiBidWlsdGluL2Nsb25lLmM6MTEyMwogbXNnaWQgIi0tZGVwdGggaXMgaWdub3JlZCBpbiBsb2NhbCBjbG9uZXM7IHVzZSBmaWxlOi8vIGluc3RlYWQuIgogbXNnc3RyICItLWRlcHRoIOWcqOacrOWcsOWFi+mahuaXtuiiq+W/veeVpe+8jOivt+aUueeUqCBmaWxlOi8vIOWNj+iuruOAgiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjExMjYKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMTI1CiBtc2dpZCAiLS1zaGFsbG93LXNpbmNlIGlzIGlnbm9yZWQgaW4gbG9jYWwgY2xvbmVzOyB1c2UgZmlsZTovLyBpbnN0ZWFkLiIKIG1zZ3N0ciAiLS1zaGFsbG93LXNpbmNlIOWcqOacrOWcsOWFi+mahuaXtuiiq+W/veeVpe+8jOivt+aUueeUqCBmaWxlOi8vIOWNj+iuruOAgiIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjExMjgKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMTI3CiBtc2dpZCAiLS1zaGFsbG93LWV4Y2x1ZGUgaXMgaWdub3JlZCBpbiBsb2NhbCBjbG9uZXM7IHVzZSBmaWxlOi8vIGluc3RlYWQuIgogbXNnc3RyICItLXNoYWxsb3ctZXhjbHVkZSDlnKjmnKzlnLDlhYvpmobml7booqvlv73nlaXvvIzor7fmlLnnlKggZmlsZTovLyDljY/orq7jgIIiCiAKLSM6IGJ1aWx0aW4vY2xvbmUuYzoxMTMwCisjOiBidWlsdGluL2Nsb25lLmM6MTEyOQogbXNnaWQgIi0tZmlsdGVyIGlzIGlnbm9yZWQgaW4gbG9jYWwgY2xvbmVzOyB1c2UgZmlsZTovLyBpbnN0ZWFkLiIKIG1zZ3N0ciAiLS1maWx0ZXIg5Zyo5pys5Zyw5YWL6ZqG5pe26KKr5b+955Wl77yM6K+35pS555SoIGZpbGU6Ly8g5Y2P6K6u44CCIgogCi0jOiBidWlsdGluL2Nsb25lLmM6MTEzMworIzogYnVpbHRpbi9jbG9uZS5jOjExMzIKIG1zZ2lkICJzb3VyY2UgcmVwb3NpdG9yeSBpcyBzaGFsbG93LCBpZ25vcmluZyAtLWxvY2FsIgogbXNnc3RyICLmupDku5PlupPmmK/mtYXlhYvpmobvvIzlv73nlaUgLS1sb2NhbCIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjExMzgKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMTM3CiBtc2dpZCAiLS1sb2NhbCBpcyBpZ25vcmVkIgogbXNnc3RyICItLWxvY2FsIOiiq+W/veeVpSIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEyMTUgYnVpbHRpbi9jbG9uZS5jOjEyMjMKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMjEyIGJ1aWx0aW4vY2xvbmUuYzoxMjIwCiAjLCBjLWZvcm1hdAogbXNnaWQgIlJlbW90ZSBicmFuY2ggJXMgbm90IGZvdW5kIGluIHVwc3RyZWFtICVzIgogbXNnc3RyICLov5znqIvliIbmlK8gJXMg5Zyo5LiK5ri4ICVzIOacquWPkeeOsCIKIAotIzogYnVpbHRpbi9jbG9uZS5jOjEyMjYKKyM6IGJ1aWx0aW4vY2xvbmUuYzoxMjIzCiBtc2dpZCAiWW91IGFwcGVhciB0byBoYXZlIGNsb25lZCBhbiBlbXB0eSByZXBvc2l0b3J5LiIKIG1zZ3N0ciAi5oKo5Ly85LmO5YWL6ZqG5LqG5LiA5Liq56m65LuT5bqT44CCIgogCkBAIC0xMTIxMSw3ICsxMTI0Niw3IEBACiBtc2dzdHIgIueItuaPkOS6pOWvueixoSBJRCIKIAogIzogYnVpbHRpbi9jb21taXQtdHJlZS5jOjExNCBidWlsdGluL2NvbW1pdC5jOjE1MDAgYnVpbHRpbi9tZXJnZS5jOjI3MAotIzogYnVpbHRpbi9ub3Rlcy5jOjQwOSBidWlsdGluL25vdGVzLmM6NTc1IGJ1aWx0aW4vc3Rhc2guYzoxNDYwCisjOiBidWlsdGluL25vdGVzLmM6NDA5IGJ1aWx0aW4vbm90ZXMuYzo1NzUgYnVpbHRpbi9zdGFzaC5jOjE0NjkKICM6IGJ1aWx0aW4vdGFnLmM6NDEyCiBtc2dpZCAibWVzc2FnZSIKIG1zZ3N0ciAi6K+05piOIgpAQCAtMTEyMjUsNyArMTEyNjAsNyBAQAogbXNnc3RyICLku47mlofku7bkuK3or7vlj5bmj5DkuqTor7TmmI4iCiAKICM6IGJ1aWx0aW4vY29tbWl0LXRyZWUuYzoxMjEgYnVpbHRpbi9jb21taXQuYzoxNTEyIGJ1aWx0aW4vbWVyZ2UuYzoyODcKLSM6IGJ1aWx0aW4vcHVsbC5jOjE5NCBidWlsdGluL3JldmVydC5jOjExOAorIzogYnVpbHRpbi9wdWxsLmM6MTk1IGJ1aWx0aW4vcmV2ZXJ0LmM6MTE4CiBtc2dpZCAiR1BHIHNpZ24gY29tbWl0IgogbXNnc3RyICJHUEcg5o+Q5Lqk562+5ZCNIgogCkBAIC0xMTU0Niw4ICsxMTU4MSw4IEBACiBtc2dpZCAidmVyc2lvbiIKIG1zZ3N0ciAi54mI5pysIgogCi0jOiBidWlsdGluL2NvbW1pdC5jOjEzNDcgYnVpbHRpbi9jb21taXQuYzoxNTI5IGJ1aWx0aW4vcHVzaC5jOjU2MQotIzogYnVpbHRpbi93b3JrdHJlZS5jOjY1MQorIzogYnVpbHRpbi9jb21taXQuYzoxMzQ3IGJ1aWx0aW4vY29tbWl0LmM6MTUyOSBidWlsdGluL3B1c2guYzo1NDgKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo2NTAKIG1zZ2lkICJtYWNoaW5lLXJlYWRhYmxlIG91dHB1dCIKIG1zZ3N0ciAi5py65Zmo5Y+v6K+755qE6L6T5Ye6IgogCkBAIC0xMTU2MCw4ICsxMTU5NSw4IEBACiBtc2dzdHIgIuadoeebruS7pSBOVUwg5a2X56ym57uT5bC+IgogCiAjOiBidWlsdGluL2NvbW1pdC5jOjEzNTUgYnVpbHRpbi9jb21taXQuYzoxMzU5IGJ1aWx0aW4vY29tbWl0LmM6MTUzNwotIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExMjUgYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExMjgKLSM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTMxIGJ1aWx0aW4vcmViYXNlLmM6MTQ3MSBwYXJzZS1vcHRpb25zLmg6MzMyCisjOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE1MyBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE1NgorIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNTkgYnVpbHRpbi9yZWJhc2UuYzoxNDk1IHBhcnNlLW9wdGlvbnMuaDozMzIKIG1zZ2lkICJtb2RlIgogbXNnc3RyICLmqKHlvI8iCiAKQEAgLTExNTc2LDcgKzExNjExLDcgQEAKIG1zZ3N0ciAiIgogIuaYvuekuuW3suW/veeVpeeahOaWh+S7tu+8jOWPr+mAieaooeW8j++8mnRyYWRpdGlvbmFs44CBbWF0Y2hpbmfjgIFub+OAgu+8iOm7mOiupO+8mnRyYWRpdGlvbmFs77yJIgogCi0jOiBidWlsdGluL2NvbW1pdC5jOjEzNjIgcGFyc2Utb3B0aW9ucy5oOjE3OQorIzogYnVpbHRpbi9jb21taXQuYzoxMzYyIHBhcnNlLW9wdGlvbnMuaDoxODgKIG1zZ2lkICJ3aGVuIgogbXNnc3RyICLkvZXml7YiCiAKQEAgLTExNjI3LDcgKzExNjYyLDcgQEAKIG1zZ2lkICJvdmVycmlkZSBhdXRob3IgZm9yIGNvbW1pdCIKIG1zZ3N0ciAi5o+Q5Lqk5pe26KaG55uW5L2c6ICFIgogCi0jOiBidWlsdGluL2NvbW1pdC5jOjE0OTkgYnVpbHRpbi9nYy5jOjUzOQorIzogYnVpbHRpbi9jb21taXQuYzoxNDk5IGJ1aWx0aW4vZ2MuYzo1MzgKIG1zZ2lkICJkYXRlIgogbXNnc3RyICLml6XmnJ8iCiAKQEAgLTExNjYwLDggKzExNjk1LDggQEAKIG1zZ2lkICJ0aGUgY29tbWl0IGlzIGF1dGhvcmVkIGJ5IG1lIG5vdyAodXNlZCB3aXRoIC1DLy1jLy0tYW1lbmQpIgogbXNnc3RyICLnjrDlnKjlsIbor6Xmj5DkuqTnmoTkvZzogIXmlLnkuLrmiJHvvIjlkowgLUMvLWMvLS1hbWVuZCDlj4LmlbDlhbHnlKjvvIkiCiAKLSM6IGJ1aWx0aW4vY29tbWl0LmM6MTUwNiBidWlsdGluL2xvZy5jOjE1NjQgYnVpbHRpbi9tZXJnZS5jOjI4OQotIzogYnVpbHRpbi9wdWxsLmM6MTYzIGJ1aWx0aW4vcmV2ZXJ0LmM6MTEwCisjOiBidWlsdGluL2NvbW1pdC5jOjE1MDYgYnVpbHRpbi9sb2cuYzoxNTY1IGJ1aWx0aW4vbWVyZ2UuYzoyODkKKyM6IGJ1aWx0aW4vcHVsbC5jOjE2NCBidWlsdGluL3JldmVydC5jOjExMAogbXNnaWQgImFkZCBTaWduZWQtb2ZmLWJ5OiIKIG1zZ3N0ciAi5re75YqgIFNpZ25lZC1vZmYtYnk6IOetvuWQjSIKIApAQCAtMTE3NjcsNjQgKzExODAyLDY5IEBACiBtc2dzdHIgImdpdCBjb21taXQtZ3JhcGggcmVhZCBbLS1vYmplY3QtZGlyIDzlr7nosaHnm67lvZU+XSIKIAogIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxMyBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE5Ci1tc2dpZCAiZ2l0IGNvbW1pdC1ncmFwaCB2ZXJpZnkgWy0tb2JqZWN0LWRpciA8b2JqZGlyPl0gWy0tc2hhbGxvd10iCi1tc2dzdHIgImdpdCBjb21taXQtZ3JhcGggdmVyaWZ5IFstLW9iamVjdC1kaXIgPOWvueixoeebruW9lT5dIFstLXNoYWxsb3ddIgorbXNnaWQgIiIKKyJnaXQgY29tbWl0LWdyYXBoIHZlcmlmeSBbLS1vYmplY3QtZGlyIDxvYmpkaXI+XSBbLS1zaGFsbG93XSBbLS1bbm8tXXByb2dyZXNzXSIKK21zZ3N0ciAiIgorImdpdCBjb21taXQtZ3JhcGggdmVyaWZ5IFstLW9iamVjdC1kaXIgPOWvueixoeebruW9lT5dIFstLXNoYWxsb3ddIFstLSIKKyJbbm8tXXByb2dyZXNzXSIKIAogIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxNCBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjI5CiBtc2dpZCAiIgogImdpdCBjb21taXQtZ3JhcGggd3JpdGUgWy0tb2JqZWN0LWRpciA8b2JqZGlyPl0gWy0tYXBwZW5kfC0tc3BsaXRdIFstLSIKLSJyZWFjaGFibGV8LS1zdGRpbi1wYWNrc3wtLXN0ZGluLWNvbW1pdHNdIDxzcGxpdCBvcHRpb25zPiIKLW1zZ3N0ciAiZ2l0IGNvbW1pdC1ncmFwaCB3cml0ZSBbLS1vYmplY3QtZGlyIDzlr7nosaHnm67lvZU+XSBbLS1hcHBlbmR8LS1zcGxpdF0gWy0tcmVhY2hhYmxlfC0tc3RkaW4tcGFja3N8LS1zdGRpbi1jb21taXRzXSA8c3BsaXQgb3B0aW9ucz4iCisicmVhY2hhYmxlfC0tc3RkaW4tcGFja3N8LS1zdGRpbi1jb21taXRzXSBbLS1bbm8tXXByb2dyZXNzXSA8c3BsaXQgb3B0aW9ucz4iCittc2dzdHIgIiIKKyJnaXQgY29tbWl0LWdyYXBoIHdyaXRlIFstLW9iamVjdC1kaXIgPOWvueixoeebruW9lT5dIFstLWFwcGVuZHwtLXNwbGl0XSBbLS0iCisicmVhY2hhYmxlfC0tc3RkaW4tcGFja3N8LS1zdGRpbi1jb21taXRzXSBbLS1bbm8tXXByb2dyZXNzXSA8c3BsaXQgb3B0aW9ucz4iCiAKLSM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6NTQgYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxMDAKLSM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTYxIGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MjM3IGJ1aWx0aW4vZmV0Y2guYzoxNjMKLSM6IGJ1aWx0aW4vbG9nLmM6MTU4NAorIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzo1NSBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjEwNworIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxNzAgYnVpbHRpbi9jb21taXQtZ3JhcGguYzoyNTQgYnVpbHRpbi9mZXRjaC5jOjE3OAorIzogYnVpbHRpbi9sb2cuYzoxNTg1CiBtc2dpZCAiZGlyIgogbXNnc3RyICLnm67lvZUiCiAKLSM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6NTUgYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxMDEKLSM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTYyIGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MjM4CisjOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjU2IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTA4CisjOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE3MSBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjI1NQogbXNnaWQgIlRoZSBvYmplY3QgZGlyZWN0b3J5IHRvIHN0b3JlIHRoZSBncmFwaCIKIG1zZ3N0ciAi5L+d5a2Y5Zu+5b2i55qE5a+56LGh55uu5b2VIgogCi0jOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjU3CisjOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjU4CiBtc2dpZCAiaWYgdGhlIGNvbW1pdC1ncmFwaCBpcyBzcGxpdCwgb25seSB2ZXJpZnkgdGhlIHRpcCBmaWxlIgogbXNnc3RyICLlpoLmnpzmj5DkuqTlm77lvaLooqvmi4bliIbvvIzlj6rpqozor4HlpLTkuIDkuKrmlofku7YiCiAKLSM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6NzMgYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxMTYKKyM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6ODAgYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxMjUKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ291bGQgbm90IG9wZW4gY29tbWl0LWdyYXBoICclcyciCiBtc2dzdHIgIuaXoOazleaJk+W8gOaPkOS6pOWbvuW9oiAnJXMnIgogCi0jOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE2NAorIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxNzMKIG1zZ2lkICJzdGFydCB3YWxrIGF0IGFsbCByZWZzIgogbXNnc3RyICLlvIDlp4vpgY3ljobmiYDmnInlvJXnlKgiCiAKLSM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTY2CisjOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE3NQogbXNnaWQgInNjYW4gcGFjay1pbmRleGVzIGxpc3RlZCBieSBzdGRpbiBmb3IgY29tbWl0cyIKIG1zZ3N0ciAi5LuO5qCH5YeG6L6T5YWl5Lit55qE5YyF57Si5byV5paH5Lu25YiX6KGo5Lit5omr5o+P5o+Q5LqkIgogCi0jOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE2OAorIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxNzcKIG1zZ2lkICJzdGFydCB3YWxrIGF0IGNvbW1pdHMgbGlzdGVkIGJ5IHN0ZGluIgogbXNnc3RyICLku47moIflh4bovpPlhaXkuK3nmoTmj5DkuqTlvIDlp4vmiavmj48iCiAKLSM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTcwCisjOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE3OQogbXNnaWQgImluY2x1ZGUgYWxsIGNvbW1pdHMgYWxyZWFkeSBpbiB0aGUgY29tbWl0LWdyYXBoIGZpbGUiCiBtc2dzdHIgIuWMheWQqyBjb21taXQtZ3JhcGgg5paH5Lu25Lit5bey5pyJ5omA5pyJ5o+Q5LqkIgogCi0jOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE3MgorIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxODIKIG1zZ2lkICJhbGxvdyB3cml0aW5nIGFuIGluY3JlbWVudGFsIGNvbW1pdC1ncmFwaCBmaWxlIgogbXNnc3RyICLlhYHorrjlhpnkuIDkuKrlop7ph4/mj5DkuqTlm77lvaLmlofku7YiCiAKLSM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTc0IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTc4CisjOiBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE4NCBidWlsdGluL2NvbW1pdC1ncmFwaC5jOjE4OAogbXNnaWQgIm1heGltdW0gbnVtYmVyIG9mIGNvbW1pdHMgaW4gYSBub24tYmFzZSBzcGxpdCBjb21taXQtZ3JhcGgiCiBtc2dzdHIgIuWcqOmdnuWfuuacrOaLhuWIhuaPkOS6pOWbvuW9ouS4reeahOacgOWkp+aPkOS6pOaVsCIKIAotIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxNzYKKyM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MTg2CiBtc2dpZCAibWF4aW11bSByYXRpbyBiZXR3ZWVuIHR3byBsZXZlbHMgb2YgYSBzcGxpdCBjb21taXQtZ3JhcGgiCiBtc2dzdHIgIuS4gOS4quaLhuWIhuaPkOS6pOWbvuW9oueahOS4pOS4que6p+WIq+S5i+mXtOeahOacgOWkp+avlOeOhyIKIAotIzogYnVpbHRpbi9jb21taXQtZ3JhcGguYzoxOTEKKyM6IGJ1aWx0aW4vY29tbWl0LWdyYXBoLmM6MjA0CiBtc2dpZCAidXNlIGF0IG1vc3Qgb25lIG9mIC0tcmVhY2hhYmxlLCAtLXN0ZGluLWNvbW1pdHMsIG9yIC0tc3RkaW4tcGFja3MiCiBtc2dzdHIgIuS4jeiDveWQjOaXtuS9v+eUqCAtLXJlYWNoYWJsZeOAgS0tc3RkaW4tY29tbWl0cyDmiJYgLS1zdGRpbi1wYWNrcyIKIApAQCAtMTIxMzYsNTcgKzEyMTc2LDU3IEBACiBtc2dpZCAicHJpbnQgc2l6ZXMgaW4gaHVtYW4gcmVhZGFibGUgZm9ybWF0IgogbXNnc3RyICLku6XnlKjmiLflj6/or7vnmoTmoLzlvI/mmL7npLrlpKflsI8iCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzoyNworIzogYnVpbHRpbi9kZXNjcmliZS5jOjI2CiBtc2dpZCAiZ2l0IGRlc2NyaWJlIFs8b3B0aW9ucz5dIFs8Y29tbWl0LWlzaD4uLi5dIgogbXNnc3RyICJnaXQgZGVzY3JpYmUgWzzpgInpobk+XSBbPOaPkOS6pOWPtz4uLi5dIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6MjgKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzoyNwogbXNnaWQgImdpdCBkZXNjcmliZSBbPG9wdGlvbnM+XSAtLWRpcnR5IgogbXNnc3RyICJnaXQgZGVzY3JpYmUgWzzpgInpobk+XSAtLWRpcnR5IgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NjMKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo2MgogbXNnaWQgImhlYWQiCiBtc2dzdHIgIuWktCIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjYzCisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NjIKIG1zZ2lkICJsaWdodHdlaWdodCIKIG1zZ3N0ciAi6L276YeP57qn55qEIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NjMKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo2MgogbXNnaWQgImFubm90YXRlZCIKIG1zZ3N0ciAi6ZmE5rOo55qEIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6MjczCisjOiBidWlsdGluL2Rlc2NyaWJlLmM6Mjc1CiAjLCBjLWZvcm1hdAogbXNnaWQgImFubm90YXRlZCB0YWcgJXMgbm90IGF2YWlsYWJsZSIKIG1zZ3N0ciAi6ZmE5rOo5qCH562+ICVzIOaXoOaViCIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjI3NworIzogYnVpbHRpbi9kZXNjcmliZS5jOjI3OQogIywgYy1mb3JtYXQKIG1zZ2lkICJhbm5vdGF0ZWQgdGFnICVzIGhhcyBubyBlbWJlZGRlZCBuYW1lIgogbXNnc3RyICLpmYTms6jmoIfnrb4gJXMg5rKh5pyJ5bWM5YWl5ZCN56ewIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6Mjc5CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6MjgxCiAjLCBjLWZvcm1hdAogbXNnaWQgInRhZyAnJXMnIGlzIHJlYWxseSAnJXMnIGhlcmUiCiBtc2dzdHIgIuagh+etviAnJXMnIOeahOehruaYr+WcqCAnJXMnIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6MzIzCisjOiBidWlsdGluL2Rlc2NyaWJlLmM6MzI1CiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vIHRhZyBleGFjdGx5IG1hdGNoZXMgJyVzJyIKIG1zZ3N0ciAi5rKh5pyJ5qCH562+5YeG56Gu5Yy56YWNICclcyciCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzozMjUKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzozMjcKICMsIGMtZm9ybWF0CiBtc2dpZCAiTm8gZXhhY3QgbWF0Y2ggb24gcmVmcyBvciB0YWdzLCBzZWFyY2hpbmcgdG8gZGVzY3JpYmVcbiIKIG1zZ3N0ciAi5rKh5pyJ57K+56Gu5Yy56YWN5Yiw5byV55So5oiW5qCH562+77yM57un57ut5pCc57Si6L+b6KGM5o+P6L+wXG4iCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzozNzkKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzozODEKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmluaXNoZWQgc2VhcmNoIGF0ICVzXG4iCiBtc2dzdHIgIuWujOaIkOaQnOe0oiAlc1xuIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NDA1CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NDA3CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJObyBhbm5vdGF0ZWQgdGFncyBjYW4gZGVzY3JpYmUgJyVzJy5cbiIKQEAgLTEyMTk1LDcgKzEyMjM1LDcgQEAKICLmsqHmnInpmYTms6jmoIfnrb7og73mj4/ov7AgJyVzJ+OAglxuIgogIueEtuiAjO+8jOWtmOWcqOacqumZhOazqOagh+etvu+8muWwneivlSAtLXRhZ3PjgIIiCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo0MDkKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo0MTEKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIk5vIHRhZ3MgY2FuIGRlc2NyaWJlICclcycuXG4iCkBAIC0xMjIwNCwxMiArMTIyNDQsMTIgQEAKICLmsqHmnInmoIfnrb7og73mj4/ov7AgJyVzJ+OAglxuIgogIuWwneivlSAtLWFsd2F5c++8jOaIluiAheWIm+W7uuS4gOS6m+agh+etvuOAgiIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjQzOQorIzogYnVpbHRpbi9kZXNjcmliZS5jOjQ0MQogIywgYy1mb3JtYXQKIG1zZ2lkICJ0cmF2ZXJzZWQgJWx1IGNvbW1pdHNcbiIKIG1zZ3N0ciAi5bey6YGN5Y6GICVsdSDkuKrmj5DkuqRcbiIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjQ0MgorIzogYnVpbHRpbi9kZXNjcmliZS5jOjQ0NAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAibW9yZSB0aGFuICVpIHRhZ3MgZm91bmQ7IGxpc3RlZCAlaSBtb3N0IHJlY2VudFxuIgpAQCAtMTIyMTgsOTAgKzEyMjU4LDkwIEBACiAi5Y+R546w5aSa5LqOICVpIOS4quagh+etvu+8jOWIl+WHuuacgOi/keeahCAlaSDkuKpcbiIKICLlnKggJXMg5pS+5byD5pCc57SiXG4iCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1MTAKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1MTIKICMsIGMtZm9ybWF0CiBtc2dpZCAiZGVzY3JpYmUgJXNcbiIKIG1zZ3N0ciAi5o+P6L+wICVzXG4iCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1MTMKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1MTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiTm90IGEgdmFsaWQgb2JqZWN0IG5hbWUgJXMiCiBtc2dzdHIgIuS4jeaYr+S4gOS4quacieaViOeahOWvueixoeWQjSAlcyIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjUyMQorIzogYnVpbHRpbi9kZXNjcmliZS5jOjUyMwogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyBpcyBuZWl0aGVyIGEgY29tbWl0IG5vciBibG9iIgogbXNnc3RyICIlcyDml6LkuI3mmK/mj5DkuqTkuZ/kuI3mmK/mlbDmja7lr7nosaEiCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1MzUKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1MzcKIG1zZ2lkICJmaW5kIHRoZSB0YWcgdGhhdCBjb21lcyBhZnRlciB0aGUgY29tbWl0IgogbXNnc3RyICLlr7vmib7or6Xmj5DkuqTkuYvlkI7nmoTmoIfnrb4iCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1MzYKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1MzgKIG1zZ2lkICJkZWJ1ZyBzZWFyY2ggc3RyYXRlZ3kgb24gc3RkZXJyIgogbXNnc3RyICLlnKjmoIflh4bplJnor6/kuIrosIPor5XmkJzntKLnrZbnlaUiCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1MzcKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1MzkKIG1zZ2lkICJ1c2UgYW55IHJlZiIKIG1zZ3N0ciAi5L2/55So5Lu75oSP5byV55SoIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NTM4CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NTQwCiBtc2dpZCAidXNlIGFueSB0YWcsIGV2ZW4gdW5hbm5vdGF0ZWQiCiBtc2dzdHIgIuS9v+eUqOS7u+aEj+agh+etvu+8jOWNs+S9v+acqumZhOW4puazqOmHiiIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjUzOQorIzogYnVpbHRpbi9kZXNjcmliZS5jOjU0MQogbXNnaWQgImFsd2F5cyB1c2UgbG9uZyBmb3JtYXQiCiBtc2dzdHIgIuWni+e7iOS9v+eUqOmVv+aPkOS6pOWPt+agvOW8jyIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjU0MAorIzogYnVpbHRpbi9kZXNjcmliZS5jOjU0MgogbXNnaWQgIm9ubHkgZm9sbG93IGZpcnN0IHBhcmVudCIKIG1zZ3N0ciAi5Y+q6Lef6ZqP56ys5LiA5Liq54i25o+Q5LqkIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NTQzCisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NTQ1CiBtc2dpZCAib25seSBvdXRwdXQgZXhhY3QgbWF0Y2hlcyIKIG1zZ3N0ciAi5Y+q6L6T5Ye657K+56Gu5Yy56YWNIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NTQ1CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NTQ3CiBtc2dpZCAiY29uc2lkZXIgPG4+IG1vc3QgcmVjZW50IHRhZ3MgKGRlZmF1bHQ6IDEwKSIKIG1zZ3N0ciAi6ICD6JmR5pyA6L+RIDxuPiDkuKrmoIfnrb7vvIjpu5jorqTvvJoxMO+8iSIKIAotIzogYnVpbHRpbi9kZXNjcmliZS5jOjU0NworIzogYnVpbHRpbi9kZXNjcmliZS5jOjU0OQogbXNnaWQgIm9ubHkgY29uc2lkZXIgdGFncyBtYXRjaGluZyA8cGF0dGVybj4iCiBtc2dzdHIgIuWPquiAg+iZkeWMuemFjSA85qih5byPPiDnmoTmoIfnrb4iCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1NDkKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1NTEKIG1zZ2lkICJkbyBub3QgY29uc2lkZXIgdGFncyBtYXRjaGluZyA8cGF0dGVybj4iCiBtc2dzdHIgIuS4jeiAg+iZkeWMuemFjSA85qih5byPPiDnmoTmoIfnrb4iCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1NTEgYnVpbHRpbi9uYW1lLXJldi5jOjQyMgorIzogYnVpbHRpbi9kZXNjcmliZS5jOjU1MyBidWlsdGluL25hbWUtcmV2LmM6NDI2CiBtc2dpZCAic2hvdyBhYmJyZXZpYXRlZCBjb21taXQgb2JqZWN0IGFzIGZhbGxiYWNrIgogbXNnc3RyICLmmL7npLrnroDlhpnnmoTmj5DkuqTlj7fkvZzkuLrlkI7lpIciCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo1NTIgYnVpbHRpbi9kZXNjcmliZS5jOjU1NQorIzogYnVpbHRpbi9kZXNjcmliZS5jOjU1NCBidWlsdGluL2Rlc2NyaWJlLmM6NTU3CiBtc2dpZCAibWFyayIKIG1zZ3N0ciAi5qCH6K6wIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NTUzCisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NTU1CiBtc2dpZCAiYXBwZW5kIDxtYXJrPiBvbiBkaXJ0eSB3b3JraW5nIHRyZWUgKGRlZmF1bHQ6IFwiLWRpcnR5XCIpIgogbXNnc3RyICLlr7nkuo7ohI/lt6XkvZzljLrvvIzov73liqAgPOagh+iusD7vvIjpu5jorqTvvJpcIi1kaXJ0eVwi77yJIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NTU2CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NTU4CiBtc2dpZCAiYXBwZW5kIDxtYXJrPiBvbiBicm9rZW4gd29ya2luZyB0cmVlIChkZWZhdWx0OiBcIi1icm9rZW5cIikiCiBtc2dzdHIgIuWvueS6juaNn+Wdj+eahOW3peS9nOWMuu+8jOi/veWKoCA85qCH6K6wPu+8iOm7mOiupO+8mlwiLWJyb2tlblwi77yJIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NTc0CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NTc2CiBtc2dpZCAiLS1sb25nIGlzIGluY29tcGF0aWJsZSB3aXRoIC0tYWJicmV2PTAiCiBtc2dzdHIgIi0tbG9uZyDkuI4gLS1hYmJyZXY9MCDkuI3lhbzlrrkiCiAKLSM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo2MDMKKyM6IGJ1aWx0aW4vZGVzY3JpYmUuYzo2MDUKIG1zZ2lkICJObyBuYW1lcyBmb3VuZCwgY2Fubm90IGRlc2NyaWJlIGFueXRoaW5nLiIKIG1zZ3N0ciAi5rKh5pyJ5Y+R546w5ZCN56ew77yM5peg5rOV5o+P6L+w5Lu75L2V5Lic6KW/44CCIgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NjU0CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NjU2CiBtc2dpZCAiLS1kaXJ0eSBpcyBpbmNvbXBhdGlibGUgd2l0aCBjb21taXQtaXNoZXMiCiBtc2dzdHIgIi0tZGlydHkg5LiO5o+Q5Lqk5Y+35LiN5YW85a65IgogCi0jOiBidWlsdGluL2Rlc2NyaWJlLmM6NjU2CisjOiBidWlsdGluL2Rlc2NyaWJlLmM6NjU4CiBtc2dpZCAiLS1icm9rZW4gaXMgaW5jb21wYXRpYmxlIHdpdGggY29tbWl0LWlzaGVzIgogbXNnc3RyICItLWJyb2tlbiDkuI7mj5DkuqTlj7fkuI3lhbzlrrkiCiAKQEAgLTEyMzM4LDI3ICsxMjM3OCwyNyBAQAogbXNnaWQgImdpdCBkaWZmdG9vbCBbPG9wdGlvbnM+XSBbPGNvbW1pdD4gWzxjb21taXQ+XV0gWy0tXSBbPHBhdGg+Li4uXSIKIG1zZ3N0ciAiZ2l0IGRpZmZ0b29sIFs86YCJ6aG5Pl0gWzzmj5DkuqQ+IFs85o+Q5LqkPl1dIFstLV0gWzzot6/lvoQ+Li4uXSIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjI1MworIzogYnVpbHRpbi9kaWZmdG9vbC5jOjI2MAogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQ6ICVkIgogbXNnc3RyICLlpLHotKXvvJolZCIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjI5NQorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjMwMgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcmVhZCBzeW1saW5rICVzIgogbXNnc3RyICLml6Dms5Xor7vlj5bnrKblj7fpk77mjqUgJXMiCiAKLSM6IGJ1aWx0aW4vZGlmZnRvb2wuYzoyOTcKKyM6IGJ1aWx0aW4vZGlmZnRvb2wuYzozMDQKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHJlYWQgc3ltbGluayBmaWxlICVzIgogbXNnc3RyICLml6Dms5Xor7vlj5bnrKblj7fpk77mjqXmlofku7YgJXMiCiAKLSM6IGJ1aWx0aW4vZGlmZnRvb2wuYzozMDUKKyM6IGJ1aWx0aW4vZGlmZnRvb2wuYzozMTIKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHJlYWQgb2JqZWN0ICVzIGZvciBzeW1saW5rICVzIgogbXNnc3RyICLml6Dms5Xor7vlj5bnrKblj7fpk77mjqUgJTIkcyDmjIflkJHnmoTlr7nosaEgJTEkcyIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjQwNgorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjQxMwogbXNnaWQgIiIKICJjb21iaW5lZCBkaWZmIGZvcm1hdHMoJy1jJyBhbmQgJy0tY2MnKSBhcmUgbm90IHN1cHBvcnRlZCBpblxuIgogImRpcmVjdG9yeSBkaWZmIG1vZGUoJy1kJyBhbmQgJy0tZGlyLWRpZmYnKS4iCkBAIC0xMjM2Niw4MyArMTI0MDYsODMgQEAKICLkuI3mlK/mjIHlnKjnm67lvZXmr5TovoPmqKHlvI/vvIgnLWQnIOWSjCAnLS1kaXItZGlmZifvvInkuK3ph4fnlKjnu4TlkIjlt67lvILmoLzlvI/vvIgnLWMnIOWSjCAnLS0iCiAiY2Mn77yJ44CCIgogCi0jOiBidWlsdGluL2RpZmZ0b29sLmM6NjI2CisjOiBidWlsdGluL2RpZmZ0b29sLmM6NjM0CiAjLCBjLWZvcm1hdAogbXNnaWQgImJvdGggZmlsZXMgbW9kaWZpZWQ6ICclcycgYW5kICclcycuIgogbXNnc3RyICLkuKTkuKrmlofku7bpg73ooqvkv67mlLnvvJonJXMnIOWSjCAnJXMn44CCIgogCi0jOiBidWlsdGluL2RpZmZ0b29sLmM6NjI4CisjOiBidWlsdGluL2RpZmZ0b29sLmM6NjM2CiBtc2dpZCAid29ya2luZyB0cmVlIGZpbGUgaGFzIGJlZW4gbGVmdC4iCiBtc2dzdHIgIuW3peS9nOWMuuaWh+S7tuiiq+eVmeS6huS4i+adpeOAgiIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjYzOQorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjY0NwogIywgYy1mb3JtYXQKIG1zZ2lkICJ0ZW1wb3JhcnkgZmlsZXMgZXhpc3QgaW4gJyVzJy4iCiBtc2dzdHIgIuS4tOaXtuaWh+S7tuWtmOWcqOS6jiAnJXMn44CCIgogCi0jOiBidWlsdGluL2RpZmZ0b29sLmM6NjQwCisjOiBidWlsdGluL2RpZmZ0b29sLmM6NjQ4CiBtc2dpZCAieW91IG1heSB3YW50IHRvIGNsZWFudXAgb3IgcmVjb3ZlciB0aGVzZS4iCiBtc2dzdHIgIuaCqOWPr+iDveaDs+imgea4heeQhuaIluiAheaBouWkjeWug+S7rOOAgiIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjY4OQorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjY5NwogbXNnaWQgInVzZSBgZGlmZi5ndWl0b29sYCBpbnN0ZWFkIG9mIGBkaWZmLnRvb2xgIgogbXNnc3RyICLkvb/nlKggYGRpZmYuZ3VpdG9vbGAg5Luj5pu/IGBkaWZmLnRvb2xgIgogCi0jOiBidWlsdGluL2RpZmZ0b29sLmM6NjkxCisjOiBidWlsdGluL2RpZmZ0b29sLmM6Njk5CiBtc2dpZCAicGVyZm9ybSBhIGZ1bGwtZGlyZWN0b3J5IGRpZmYiCiBtc2dzdHIgIuaJp+ihjOS4gOS4quWFqOebruW9leW3ruW8guavlOi+gyIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjY5MworIzogYnVpbHRpbi9kaWZmdG9vbC5jOjcwMQogbXNnaWQgImRvIG5vdCBwcm9tcHQgYmVmb3JlIGxhdW5jaGluZyBhIGRpZmYgdG9vbCIKIG1zZ3N0ciAi5ZCv5Yqo5beu5byC5q+U6L6D5bel5YW35LmL5YmN5LiN5o+Q56S6IgogCi0jOiBidWlsdGluL2RpZmZ0b29sLmM6Njk4CisjOiBidWlsdGluL2RpZmZ0b29sLmM6NzA2CiBtc2dpZCAidXNlIHN5bWxpbmtzIGluIGRpci1kaWZmIG1vZGUiCiBtc2dzdHIgIuWcqCBkaXItZGlmZiDmqKHlvI/kuK3kvb/nlKjnrKblj7fpk77mjqUiCiAKLSM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo2OTkKKyM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo3MDcKIG1zZ2lkICJ0b29sIgogbXNnc3RyICLlt6XlhbciCiAKLSM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo3MDAKKyM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo3MDgKIG1zZ2lkICJ1c2UgdGhlIHNwZWNpZmllZCBkaWZmIHRvb2wiCiBtc2dzdHIgIuS9v+eUqOaMh+WumueahOW3ruW8guavlOi+g+W3peWFtyIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjcwMgorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjcxMAogbXNnaWQgInByaW50IGEgbGlzdCBvZiBkaWZmIHRvb2xzIHRoYXQgbWF5IGJlIHVzZWQgd2l0aCBgLS10b29sYCIKIG1zZ3N0ciAi5pi+56S65Y+v5Lul55So5ZyoIGAtLXRvb2xgIOWPguaVsOWQjueahOW3ruW8guW3peWFt+WIl+ihqCIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjcwNQorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjcxMwogbXNnaWQgIiIKICJtYWtlICdnaXQtZGlmZnRvb2wnIGV4aXQgd2hlbiBhbiBpbnZva2VkIGRpZmYgdG9vbCByZXR1cm5zIGEgbm9uIC0gemVybyBleGl0ICIKICJjb2RlIgogbXNnc3RyICLlvZPmiafooYwgZGlmZiDlt6Xlhbfov5Tlm57pnZ7pm7bpgIDlh7rnoIHml7bvvIzkvb8gJ2dpdC1kaWZmdG9vbCcg6YCA5Ye6IgogCi0jOiBidWlsdGluL2RpZmZ0b29sLmM6NzA4CisjOiBidWlsdGluL2RpZmZ0b29sLmM6NzE2CiBtc2dpZCAic3BlY2lmeSBhIGN1c3RvbSBjb21tYW5kIGZvciB2aWV3aW5nIGRpZmZzIgogbXNnc3RyICLmjIflrprkuIDkuKrnlKjkuo7mn6XnnIvlt67lvILnmoToh6rlrprkuYnlkb3ku6QiCiAKLSM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo3MDkKKyM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo3MTcKIG1zZ2lkICJwYXNzZWQgdG8gYGRpZmZgIgogbXNnc3RyICLkvKDpgJLnu5kgYGRpZmZgIgogCi0jOiBidWlsdGluL2RpZmZ0b29sLmM6NzI0CisjOiBidWlsdGluL2RpZmZ0b29sLmM6NzMyCiBtc2dpZCAiZGlmZnRvb2wgcmVxdWlyZXMgd29ya3RyZWUgb3IgLS1uby1pbmRleCIKIG1zZ3N0ciAiZGlmZnRvb2wg6KaB5rGC5bel5L2c5Yy65oiW6ICFIC0tbm8taW5kZXgiCiAKLSM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo3MzEKKyM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo3MzkKIG1zZ2lkICItLWRpci1kaWZmIGlzIGluY29tcGF0aWJsZSB3aXRoIC0tbm8taW5kZXgiCiBtc2dzdHIgIi0tZGlyLWRpZmYg5ZKMIC0tbm8taW5kZXgg5LiN5YW85a65IgogCi0jOiBidWlsdGluL2RpZmZ0b29sLmM6NzM0CisjOiBidWlsdGluL2RpZmZ0b29sLmM6NzQyCiBtc2dpZCAiLS1ndWksIC0tdG9vbCBhbmQgLS1leHRjbWQgYXJlIG11dHVhbGx5IGV4Y2x1c2l2ZSIKIG1zZ3N0ciAiLS1ndWnjgIEtLXRvb2wg5ZKMIC0tZXh0Y21kIOS6kuaWpSIKIAotIzogYnVpbHRpbi9kaWZmdG9vbC5jOjc0MgorIzogYnVpbHRpbi9kaWZmdG9vbC5jOjc1MAogbXNnaWQgIm5vIDx0b29sPiBnaXZlbiBmb3IgLS10b29sPTx0b29sPiIKIG1zZ3N0ciAi5rKh5pyJ5Li6IC0tdG9vbD085bel5YW3PiDlj4LmlbDmj5DkvpsgPOW3peWFtz4iCiAKLSM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo3NDkKKyM6IGJ1aWx0aW4vZGlmZnRvb2wuYzo3NTcKIG1zZ2lkICJubyA8Y21kPiBnaXZlbiBmb3IgLS1leHRjbWQ9PGNtZD4iCiBtc2dzdHIgIuayoeacieS4uiAtLWV4dGNtZD085ZG95LukPiDlj4LmlbDmj5DkvpsgPOWRveS7pD4iCiAKQEAgLTEyNDc4LDI0NSArMTI1MTgsMjY5IEBACiBtc2dpZCAiZ2l0IGZhc3QtZXhwb3J0IFtyZXYtbGlzdC1vcHRzXSIKIG1zZ3N0ciAiZ2l0IGZhc3QtZXhwb3J0IFtyZXYtbGlzdC1vcHRzXSIKIAotIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExMjQKKyM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzo4NTIKK21zZ2lkICJFcnJvcjogQ2Fubm90IGV4cG9ydCBuZXN0ZWQgdGFncyB1bmxlc3MgLS1tYXJrLXRhZ3MgaXMgc3BlY2lmaWVkLiIKK21zZ3N0ciAi6ZSZ6K+v77ya6Zmk6Z2e5oyH5a6aIC0tbWFyay10YWdz77yM5ZCm5YiZ5peg5rOV5a+85Ye65bWM5aWX5qCH562+44CCIgorCisjOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE1MgogbXNnaWQgInNob3cgcHJvZ3Jlc3MgYWZ0ZXIgPG4+IG9iamVjdHMiCiBtc2dzdHIgIuWcqCA8bj4g5Liq5a+56LGh5LmL5ZCO5pi+56S66L+b5bqmIgogCi0jOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTEyNgorIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNTQKIG1zZ2lkICJzZWxlY3QgaGFuZGxpbmcgb2Ygc2lnbmVkIHRhZ3MiCiBtc2dzdHIgIumAieaLqeWmguS9leWkhOeQhuetvuWQjeagh+etviIKIAotIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExMjkKKyM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTU3CiBtc2dpZCAic2VsZWN0IGhhbmRsaW5nIG9mIHRhZ3MgdGhhdCB0YWcgZmlsdGVyZWQgb2JqZWN0cyIKIG1zZ3N0ciAi6YCJ5oup5b2T5qCH562+5oyH5ZCR6KKr6L+H5ruk5a+56LGh5pe26K+l5qCH562+55qE5aSE55CG5pa55byPIgogCi0jOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTEzMgorIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNjAKIG1zZ2lkICJzZWxlY3QgaGFuZGxpbmcgb2YgY29tbWl0IG1lc3NhZ2VzIGluIGFuIGFsdGVybmF0ZSBlbmNvZGluZyIKIG1zZ3N0ciAi6YCJ5oup5L2/55So5aSH55So57yW56CB5aSE55CG5o+Q5Lqk6K+05piOIgogCi0jOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTEzNQorIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNjMKIG1zZ2lkICJEdW1wIG1hcmtzIHRvIHRoaXMgZmlsZSIKIG1zZ3N0ciAi5oqK5qCH6K6w5a2Y5YKo5Yiw6L+Z5Liq5paH5Lu2IgogCi0jOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTEzNworIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNjUKIG1zZ2lkICJJbXBvcnQgbWFya3MgZnJvbSB0aGlzIGZpbGUiCiBtc2dzdHIgIuS7jui/meS4quaWh+S7tuWvvOWFpeagh+iusCIKIAotIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExMzkKKyM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTY5Cittc2dpZCAiSW1wb3J0IG1hcmtzIGZyb20gdGhpcyBmaWxlIGlmIGl0IGV4aXN0cyIKK21zZ3N0ciAi5LuO6K+l5paH5Lu25a+85YWl5qCH6K6w77yI5aaC5p6c5a2Y5Zyo55qE6K+d77yJIgorCisjOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE3MQogbXNnaWQgIkZha2UgYSB0YWdnZXIgd2hlbiB0YWdzIGxhY2sgb25lIgogbXNnc3RyICLlvZPmoIfnrb7nvLrlsJHmoIforrDogIXlrZfmrrXml7bvvIzlgYfoo4Xmj5DkvpvkuIDkuKoiCiAKLSM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTQxCisjOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE3MwogbXNnaWQgIk91dHB1dCBmdWxsIHRyZWUgZm9yIGVhY2ggY29tbWl0IgogbXNnc3RyICLmr4/mrKHmj5DkuqTpg73ovpPlh7rmlbTkuKrmoJEiCiAKLSM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTQzCisjOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE3NQogbXNnaWQgIlVzZSB0aGUgZG9uZSBmZWF0dXJlIHRvIHRlcm1pbmF0ZSB0aGUgc3RyZWFtIgogbXNnc3RyICLkvb/nlKggZG9uZSDlip/og73mnaXnu4jmraLmtYEiCiAKLSM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTQ0CisjOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE3NgogbXNnaWQgIlNraXAgb3V0cHV0IG9mIGJsb2IgZGF0YSIKIG1zZ3N0ciAi6Lez6L+H5pWw5o2u5a+56LGh55qE6L6T5Ye6IgogCi0jOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE0NSBidWlsdGluL2xvZy5jOjE2MzIKKyM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTc3IGJ1aWx0aW4vbG9nLmM6MTYzMwogbXNnaWQgInJlZnNwZWMiCiBtc2dzdHIgIuW8leeUqOinhOagvCIKIAotIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNDYKKyM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTc4CiBtc2dpZCAiQXBwbHkgcmVmc3BlYyB0byBleHBvcnRlZCByZWZzIgogbXNnc3RyICLlr7nlr7zlh7rnmoTlvJXnlKjlupTnlKjlvJXnlKjop4TmoLwiCiAKLSM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTQ3CisjOiBidWlsdGluL2Zhc3QtZXhwb3J0LmM6MTE3OQogbXNnaWQgImFub255bWl6ZSBvdXRwdXQiCiBtc2dzdHIgIuWMv+WQjei+k+WHuiIKIAotIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNDkKKyM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTgxCiBtc2dpZCAiUmVmZXJlbmNlIHBhcmVudHMgd2hpY2ggYXJlIG5vdCBpbiBmYXN0LWV4cG9ydCBzdHJlYW0gYnkgb2JqZWN0IGlkIgogbXNnc3RyICLlvJXnlKjniLblr7nosaEgSUQg5LiN5ZyoIGZhc3QtZXhwb3J0IOa1geS4rSIKIAotIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExNTEKKyM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMTgzCiBtc2dpZCAiU2hvdyBvcmlnaW5hbCBvYmplY3QgaWRzIG9mIGJsb2JzL2NvbW1pdHMiCiBtc2dzdHIgIuaYvuekuuaVsOaNruWvueixoS/mj5DkuqTnmoTljp/lp4vlr7nosaEgSUQiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzozMAorIzogYnVpbHRpbi9mYXN0LWV4cG9ydC5jOjExODUKK21zZ2lkICJMYWJlbCB0YWdzIHdpdGggbWFyayBpZHMiCittc2dzdHIgIuWvueW4puacieagh+iusCBJRCDnmoTmoIfnrb7lgZrmoIforrAiCisKKyM6IGJ1aWx0aW4vZmFzdC1leHBvcnQuYzoxMjIwCittc2dpZCAiQ2Fubm90IHBhc3MgYm90aCAtLWltcG9ydC1tYXJrcyBhbmQgLS1pbXBvcnQtbWFya3MtaWYtZXhpc3RzIgorbXNnc3RyICLkuI3og73lkIzml7bkvKDpgJLlj4LmlbAgLS1pbXBvcnQtbWFya3Mg5ZKMIC0taW1wb3J0LW1hcmtzLWlmLWV4aXN0cyIKKworIzogYnVpbHRpbi9mZXRjaC5jOjM0CiBtc2dpZCAiZ2l0IGZldGNoIFs8b3B0aW9ucz5dIFs8cmVwb3NpdG9yeT4gWzxyZWZzcGVjPi4uLl1dIgogbXNnc3RyICJnaXQgZmV0Y2ggWzzpgInpobk+XSBbPOS7k+W6kz4gWzzlvJXnlKjop4TmoLw+Li4uXV0iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzozMQorIzogYnVpbHRpbi9mZXRjaC5jOjM1CiBtc2dpZCAiZ2l0IGZldGNoIFs8b3B0aW9ucz5dIDxncm91cD4iCiBtc2dzdHIgImdpdCBmZXRjaCBbPOmAiemhuT5dIDznu4Q+IgogCi0jOiBidWlsdGluL2ZldGNoLmM6MzIKKyM6IGJ1aWx0aW4vZmV0Y2guYzozNgogbXNnaWQgImdpdCBmZXRjaCAtLW11bHRpcGxlIFs8b3B0aW9ucz5dIFsoPHJlcG9zaXRvcnk+IHwgPGdyb3VwPikuLi5dIgogbXNnc3RyICJnaXQgZmV0Y2ggLS1tdWx0aXBsZSBbPOmAiemhuT5dIFsoPOS7k+W6kz4gfCA857uEPikuLi5dIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MzMKKyM6IGJ1aWx0aW4vZmV0Y2guYzozNwogbXNnaWQgImdpdCBmZXRjaCAtLWFsbCBbPG9wdGlvbnM+XSIKIG1zZ3N0ciAiZ2l0IGZldGNoIC0tYWxsIFs86YCJ6aG5Pl0iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxMjUgYnVpbHRpbi9wdWxsLmM6MjAzCisjOiBidWlsdGluL2ZldGNoLmM6MTE1Cittc2dpZCAiZmV0Y2gucGFyYWxsZWwgY2Fubm90IGJlIG5lZ2F0aXZlIgorbXNnc3RyICJmZXRjaC5wYXJhbGxlbCDkuI3og73kuLrotJ/mlbAiCisKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxMzggYnVpbHRpbi9wdWxsLmM6MjA0CiBtc2dpZCAiZmV0Y2ggZnJvbSBhbGwgcmVtb3RlcyIKIG1zZ3N0ciAi5LuO5omA5pyJ55qE6L+c56iL5oqT5Y+WIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTI3IGJ1aWx0aW4vcHVsbC5jOjIwNgorIzogYnVpbHRpbi9mZXRjaC5jOjE0MCBidWlsdGluL3B1bGwuYzoyNDgKK21zZ2lkICJzZXQgdXBzdHJlYW0gZm9yIGdpdCBwdWxsL2ZldGNoIgorbXNnc3RyICLkuLogZ2l0IHB1bGwvZmV0Y2gg6K6+572u5LiK5ri4IgorCisjOiBidWlsdGluL2ZldGNoLmM6MTQyIGJ1aWx0aW4vcHVsbC5jOjIwNwogbXNnaWQgImFwcGVuZCB0byAuZ2l0L0ZFVENIX0hFQUQgaW5zdGVhZCBvZiBvdmVyd3JpdGluZyIKIG1zZ3N0ciAi6L+95Yqg5YiwIC5naXQvRkVUQ0hfSEVBRCDogIzkuI3mmK/opobnm5blroMiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxMjkgYnVpbHRpbi9wdWxsLmM6MjA5CisjOiBidWlsdGluL2ZldGNoLmM6MTQ0IGJ1aWx0aW4vcHVsbC5jOjIxMAogbXNnaWQgInBhdGggdG8gdXBsb2FkIHBhY2sgb24gcmVtb3RlIGVuZCIKIG1zZ3N0ciAi5LiK5Lyg5YyF5Yiw6L+c56iL55qE6Lev5b6EIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTMwCisjOiBidWlsdGluL2ZldGNoLmM6MTQ1CiBtc2dpZCAiZm9yY2Ugb3ZlcndyaXRlIG9mIGxvY2FsIHJlZmVyZW5jZSIKIG1zZ3N0ciAi5by65Yi26KaG55uW5pys5Zyw5byV55SoIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTMyCisjOiBidWlsdGluL2ZldGNoLmM6MTQ3CiBtc2dpZCAiZmV0Y2ggZnJvbSBtdWx0aXBsZSByZW1vdGVzIgogbXNnc3RyICLku47lpJrkuKrov5znqIvmipPlj5YiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxMzQgYnVpbHRpbi9wdWxsLmM6MjEzCisjOiBidWlsdGluL2ZldGNoLmM6MTQ5IGJ1aWx0aW4vcHVsbC5jOjIxNAogbXNnaWQgImZldGNoIGFsbCB0YWdzIGFuZCBhc3NvY2lhdGVkIG9iamVjdHMiCiBtc2dzdHIgIuaKk+WPluaJgOacieeahOagh+etvuWSjOWFs+iBlOWvueixoSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjEzNgorIzogYnVpbHRpbi9mZXRjaC5jOjE1MQogbXNnaWQgImRvIG5vdCBmZXRjaCBhbGwgdGFncyAoLS1uby10YWdzKSIKIG1zZ3N0ciAi5LiN5oqT5Y+W5Lu75L2V5qCH562+KC0tbm8tdGFncykiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxMzgKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNTMKIG1zZ2lkICJudW1iZXIgb2Ygc3VibW9kdWxlcyBmZXRjaGVkIGluIHBhcmFsbGVsIgogbXNnc3RyICLlrZDmqKHnu4Tojrflj5bnmoTlubblj5HmlbAiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNDAgYnVpbHRpbi9wdWxsLmM6MjE2CisjOiBidWlsdGluL2ZldGNoLmM6MTU1IGJ1aWx0aW4vcHVsbC5jOjIxNwogbXNnaWQgInBydW5lIHJlbW90ZS10cmFja2luZyBicmFuY2hlcyBubyBsb25nZXIgb24gcmVtb3RlIgogbXNnc3RyICLmuIXpmaTov5znqIvlt7Lnu4/kuI3lrZjlnKjnmoTliIbmlK/nmoTot5/ouKrliIbmlK8iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNDIKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNTcKIG1zZ2lkICJwcnVuZSBsb2NhbCB0YWdzIG5vIGxvbmdlciBvbiByZW1vdGUgYW5kIGNsb2JiZXIgY2hhbmdlZCB0YWdzIgogbXNnc3RyICLmuIXpmaTov5znqIvkuI3lrZjlnKjnmoTmnKzlnLDmoIfnrb7vvIzlubbkuJTmm7/mjaLlj5jmm7TmoIfnrb4iCiAKICMgIOivkeiAhe+8muWPr+mAieWAvO+8jOS4jeiDvee/u+ivkQotIzogYnVpbHRpbi9mZXRjaC5jOjE0MyBidWlsdGluL2ZldGNoLmM6MTY2IGJ1aWx0aW4vcHVsbC5jOjE0MAorIzogYnVpbHRpbi9mZXRjaC5jOjE1OCBidWlsdGluL2ZldGNoLmM6MTgxIGJ1aWx0aW4vcHVsbC5jOjE0MQogbXNnaWQgIm9uLWRlbWFuZCIKIG1zZ3N0ciAib24tZGVtYW5kIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTQ0CisjOiBidWlsdGluL2ZldGNoLmM6MTU5CiBtc2dpZCAiY29udHJvbCByZWN1cnNpdmUgZmV0Y2hpbmcgb2Ygc3VibW9kdWxlcyIKIG1zZ3N0ciAi5o6n5Yi25a2Q5qih57uE55qE6YCS5b2S5oqT5Y+WIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTQ4IGJ1aWx0aW4vcHVsbC5jOjIyNAorIzogYnVpbHRpbi9mZXRjaC5jOjE2MyBidWlsdGluL3B1bGwuYzoyMjUKIG1zZ2lkICJrZWVwIGRvd25sb2FkZWQgcGFjayIKIG1zZ3N0ciAi5L+d5oyB5LiL6L295YyFIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTUwCisjOiBidWlsdGluL2ZldGNoLmM6MTY1CiBtc2dpZCAiYWxsb3cgdXBkYXRpbmcgb2YgSEVBRCByZWYiCiBtc2dzdHIgIuWFgeiuuOabtOaWsCBIRUFEIOW8leeUqCIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE1MyBidWlsdGluL2ZldGNoLmM6MTU5IGJ1aWx0aW4vcHVsbC5jOjIyNworIzogYnVpbHRpbi9mZXRjaC5jOjE2OCBidWlsdGluL2ZldGNoLmM6MTc0IGJ1aWx0aW4vcHVsbC5jOjIyOAogbXNnaWQgImRlZXBlbiBoaXN0b3J5IG9mIHNoYWxsb3cgY2xvbmUiCiBtc2dzdHIgIua3seWMlua1heWFi+mahueahOWOhuWPsiIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE1NQorIzogYnVpbHRpbi9mZXRjaC5jOjE3MAogbXNnaWQgImRlZXBlbiBoaXN0b3J5IG9mIHNoYWxsb3cgcmVwb3NpdG9yeSBiYXNlZCBvbiB0aW1lIgogbXNnc3RyICLln7rkuo7ml7bpl7TmnaXmt7HljJbmtYXlhYvpmobnmoTljoblj7IiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNjEgYnVpbHRpbi9wdWxsLmM6MjMwCisjOiBidWlsdGluL2ZldGNoLmM6MTc2IGJ1aWx0aW4vcHVsbC5jOjIzMQogbXNnaWQgImNvbnZlcnQgdG8gYSBjb21wbGV0ZSByZXBvc2l0b3J5IgogbXNnc3RyICLovazmjaLkuLrkuIDkuKrlrozmlbTnmoTku5PlupMiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNjQKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNzkKIG1zZ2lkICJwcmVwZW5kIHRoaXMgdG8gc3VibW9kdWxlIHBhdGggb3V0cHV0IgogbXNnc3RyICLlnKjlrZDmqKHnu4Tot6/lvoTovpPlh7rnmoTliY3pnaLliqDkuIrmraTnm67lvZUiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNjcKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxODIKIG1zZ2lkICIiCiAiZGVmYXVsdCBmb3IgcmVjdXJzaXZlIGZldGNoaW5nIG9mIHN1Ym1vZHVsZXMgKGxvd2VyIHByaW9yaXR5IHRoYW4gY29uZmlnICIKICJmaWxlcykiCiBtc2dzdHIgIumAkuW9kuiOt+WPluWtkOaooee7hOeahOe8uuecgeWAvO+8iOavlOmFjee9ruaWh+S7tuS8mOWFiOe6p+S9ju+8iSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE3MSBidWlsdGluL3B1bGwuYzoyMzMKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxODYgYnVpbHRpbi9wdWxsLmM6MjM0CiBtc2dpZCAiYWNjZXB0IHJlZnMgdGhhdCB1cGRhdGUgLmdpdC9zaGFsbG93IgogbXNnc3RyICLmjqXlj5fmm7TmlrAgLmdpdC9zaGFsbG93IOeahOW8leeUqCIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE3MiBidWlsdGluL3B1bGwuYzoyMzUKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxODcgYnVpbHRpbi9wdWxsLmM6MjM2CiBtc2dpZCAicmVmbWFwIgogbXNnc3RyICLlvJXnlKjmmKDlsIQiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNzMgYnVpbHRpbi9wdWxsLmM6MjM2CisjOiBidWlsdGluL2ZldGNoLmM6MTg4IGJ1aWx0aW4vcHVsbC5jOjIzNwogbXNnaWQgInNwZWNpZnkgZmV0Y2ggcmVmbWFwIgogbXNnc3RyICLmjIflrprojrflj5bmk43kvZznmoTlvJXnlKjmmKDlsIQiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxODAKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxOTUKIG1zZ2lkICJyZXBvcnQgdGhhdCB3ZSBoYXZlIG9ubHkgb2JqZWN0cyByZWFjaGFibGUgZnJvbSB0aGlzIG9iamVjdCIKIG1zZ3N0ciAi5oql5ZGK5oiR5Lus5Y+q5oul5pyJ5LuO6K+l5a+56LGh5byA5aeL5Y+v6L6+55qE5a+56LGhIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTgzCisjOiBidWlsdGluL2ZldGNoLmM6MTk4CiBtc2dpZCAicnVuICdnYyAtLWF1dG8nIGFmdGVyIGZldGNoaW5nIgogbXNnc3RyICLojrflj5blkI7miafooYwgJ2djIC0tYXV0byciCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxODUgYnVpbHRpbi9wdWxsLmM6MjQ1CisjOiBidWlsdGluL2ZldGNoLmM6MjAwIGJ1aWx0aW4vcHVsbC5jOjI0NgogbXNnaWQgImNoZWNrIGZvciBmb3JjZWQtdXBkYXRlcyBvbiBhbGwgdXBkYXRlZCBicmFuY2hlcyIKIG1zZ3N0ciAi5Zyo5omA5pyJ5pu05paw5YiG5pSv5LiK5qOA5p+l5by65Yi25pu05pawIgogCi0jOiBidWlsdGluL2ZldGNoLmM6NDkxCisjOiBidWlsdGluL2ZldGNoLmM6NTEwCiBtc2dpZCAiQ291bGRuJ3QgZmluZCByZW1vdGUgcmVmIEhFQUQiCiBtc2dzdHIgIuaXoOazleWPkeeOsOi/nOeoiyBIRUFEIOW8leeUqCIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjYzMAorIzogYnVpbHRpbi9mZXRjaC5jOjY1MAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb25maWd1cmF0aW9uIGZldGNoLm91dHB1dCBjb250YWlucyBpbnZhbGlkIHZhbHVlICVzIgogbXNnc3RyICLphY3nva7lj5jph48gZmV0Y2gub3V0cHV0IOWMheWQq+aXoOaViOWAvCAlcyIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjcyOAorIzogYnVpbHRpbi9mZXRjaC5jOjc0OAogIywgYy1mb3JtYXQKIG1zZ2lkICJvYmplY3QgJXMgbm90IGZvdW5kIgogbXNnc3RyICLlr7nosaEgJXMg5pyq5Y+R546wIgogCi0jOiBidWlsdGluL2ZldGNoLmM6NzMyCisjOiBidWlsdGluL2ZldGNoLmM6NzUyCiBtc2dpZCAiW3VwIHRvIGRhdGVdIgogbXNnc3RyICJb5pyA5pawXSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjc0NSBidWlsdGluL2ZldGNoLmM6NzYxIGJ1aWx0aW4vZmV0Y2guYzo4MzMKKyM6IGJ1aWx0aW4vZmV0Y2guYzo3NjUgYnVpbHRpbi9mZXRjaC5jOjc4MSBidWlsdGluL2ZldGNoLmM6ODUzCiBtc2dpZCAiW3JlamVjdGVkXSIKIG1zZ3N0ciAiW+W3suaLkue7nV0iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzo3NDYKKyM6IGJ1aWx0aW4vZmV0Y2guYzo3NjYKIG1zZ2lkICJjYW4ndCBmZXRjaCBpbiBjdXJyZW50IGJyYW5jaCIKIG1zZ3N0ciAi5b2T5YmN5YiG5pSv5LiL5LiN6IO95omn6KGM6I635Y+W5pON5L2cIgogCi0jOiBidWlsdGluL2ZldGNoLmM6NzU2CisjOiBidWlsdGluL2ZldGNoLmM6Nzc2CiBtc2dpZCAiW3RhZyB1cGRhdGVdIgogbXNnc3RyICJb5qCH562+5pu05pawXSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjc1NyBidWlsdGluL2ZldGNoLmM6Nzk0IGJ1aWx0aW4vZmV0Y2guYzo4MTYKLSM6IGJ1aWx0aW4vZmV0Y2guYzo4MjgKKyM6IGJ1aWx0aW4vZmV0Y2guYzo3NzcgYnVpbHRpbi9mZXRjaC5jOjgxNCBidWlsdGluL2ZldGNoLmM6ODM2CisjOiBidWlsdGluL2ZldGNoLmM6ODQ4CiBtc2dpZCAidW5hYmxlIHRvIHVwZGF0ZSBsb2NhbCByZWYiCiBtc2dzdHIgIuS4jeiDveabtOaWsOacrOWcsOW8leeUqCIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjc2MQorIzogYnVpbHRpbi9mZXRjaC5jOjc4MQogbXNnaWQgIndvdWxkIGNsb2JiZXIgZXhpc3RpbmcgdGFnIgogbXNnc3RyICLkvJrnoLTlnY/njrDmnInnmoTmoIfnrb4iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzo3ODMKKyM6IGJ1aWx0aW4vZmV0Y2guYzo4MDMKIG1zZ2lkICJbbmV3IHRhZ10iCiBtc2dzdHIgIlvmlrDmoIfnrb5dIgogCi0jOiBidWlsdGluL2ZldGNoLmM6Nzg2CisjOiBidWlsdGluL2ZldGNoLmM6ODA2CiBtc2dpZCAiW25ldyBicmFuY2hdIgogbXNnc3RyICJb5paw5YiG5pSvXSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjc4OQorIzogYnVpbHRpbi9mZXRjaC5jOjgwOQogbXNnaWQgIltuZXcgcmVmXSIKIG1zZ3N0ciAiW+aWsOW8leeUqF0iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzo4MjgKKyM6IGJ1aWx0aW4vZmV0Y2guYzo4NDgKIG1zZ2lkICJmb3JjZWQgdXBkYXRlIgogbXNnc3RyICLlvLrliLbmm7TmlrAiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzo4MzMKKyM6IGJ1aWx0aW4vZmV0Y2guYzo4NTMKIG1zZ2lkICJub24tZmFzdC1mb3J3YXJkIgogbXNnc3RyICLpnZ7lv6vov5siCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzo4NTQKKyM6IGJ1aWx0aW4vZmV0Y2guYzo4NzQKIG1zZ2lkICIiCiAiRmV0Y2ggbm9ybWFsbHkgaW5kaWNhdGVzIHdoaWNoIGJyYW5jaGVzIGhhZCBhIGZvcmNlZCB1cGRhdGUsXG4iCiAiYnV0IHRoYXQgY2hlY2sgaGFzIGJlZW4gZGlzYWJsZWQuIFRvIHJlLWVuYWJsZSwgdXNlICctLXNob3ctZm9yY2VkLXVwZGF0ZXMnXG4iCkBAIC0xMjcyNiw3ICsxMjc5MCw3IEBACiAi6KaB6YeN5paw5ZCv55So77yM6K+35L2/55SoICctLXNob3ctZm9yY2VkLXVwZGF0ZXMnIOmAiemhueaIlui/kOihjFxuIgogIidnaXQgY29uZmlnIGZldGNoLnNob3dGb3JjZWRVcGRhdGVzIHRydWUn44CCIgogCi0jOiBidWlsdGluL2ZldGNoLmM6ODU4CisjOiBidWlsdGluL2ZldGNoLmM6ODc4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJJdCB0b29rICUuMmYgc2Vjb25kcyB0byBjaGVjayBmb3JjZWQgdXBkYXRlcy4gWW91IGNhbiB1c2VcbiIKQEAgLTEyNzM3LDIyICsxMjgwMSwyMiBAQAogIuiKseS6hiAlLjJmIOenkuadpeajgOafpeW8uuWItuabtOaWsOOAguaCqOWPr+S7peS9v+eUqCAnLS1uby1zaG93LWZvcmNlZC11cGRhdGVzJ1xuIgogIuaIlui/kOihjCAnZ2l0IGNvbmZpZyBmZXRjaC5zaG93Rm9yY2VkVXBkYXRlcyBmYWxzZScg5Lul6YG/5YWN5q2k6aG55qOA5p+l44CCXG4iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzo4ODgKKyM6IGJ1aWx0aW4vZmV0Y2guYzo5MDgKICMsIGMtZm9ybWF0CiBtc2dpZCAiJXMgZGlkIG5vdCBzZW5kIGFsbCBuZWNlc3Nhcnkgb2JqZWN0c1xuIgogbXNnc3RyICIlcyDmnKrlj5HpgIHmiYDmnInlv4XpnIDnmoTlr7nosaFcbiIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjkwOQorIzogYnVpbHRpbi9mZXRjaC5jOjkyOQogIywgYy1mb3JtYXQKIG1zZ2lkICJyZWplY3QgJXMgYmVjYXVzZSBzaGFsbG93IHJvb3RzIGFyZSBub3QgYWxsb3dlZCB0byBiZSB1cGRhdGVkIgogbXNnc3RyICLmi5Lnu50gJXMg5Zug5Li65rWF5YWL6ZqG5LiN5YWB6K646KKr5pu05pawIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTAwMCBidWlsdGluL2ZldGNoLmM6MTEzMQorIzogYnVpbHRpbi9mZXRjaC5jOjEwMjAgYnVpbHRpbi9mZXRjaC5jOjExNTcKICMsIGMtZm9ybWF0CiBtc2dpZCAiRnJvbSAlLipzXG4iCiBtc2dzdHIgIuadpeiHqiAlLipzXG4iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxMDExCisjOiBidWlsdGluL2ZldGNoLmM6MTAzMQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAic29tZSBsb2NhbCByZWZzIGNvdWxkIG5vdCBiZSB1cGRhdGVkOyB0cnkgcnVubmluZ1xuIgpAQCAtMTI3NjIsMTAwICsxMjgyNiwxMjMgQEAKICIgJ2dpdCByZW1vdGUgcHJ1bmUgJXMnIOadpeWIoOmZpOaXp+eahOOAgeacieWGsueqgeeahOWIhuaUryIKIAogIyAg6K+R6ICF77ya5rOo5oSP5L+d5oyB5YmN5a+856m65qC8Ci0jOiBidWlsdGluL2ZldGNoLmM6MTEwMQorIzogYnVpbHRpbi9mZXRjaC5jOjExMjcKICMsIGMtZm9ybWF0CiBtc2dpZCAiICAgKCVzIHdpbGwgYmVjb21lIGRhbmdsaW5nKSIKIG1zZ3N0ciAiICAg77yIJXMg5bCG5oiQ5Li65oKs56m654q25oCB77yJIgogCiAjICDor5HogIXvvJrms6jmhI/kv53mjIHliY3lr7znqbrmoLwKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxMTAyCisjOiBidWlsdGluL2ZldGNoLmM6MTEyOAogIywgYy1mb3JtYXQKIG1zZ2lkICIgICAoJXMgaGFzIGJlY29tZSBkYW5nbGluZykiCiBtc2dzdHIgIiAgIO+8iCVzIOW3suaIkOS4uuaCrOepuueKtuaAge+8iSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjExMzQKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxMTYwCiBtc2dpZCAiW2RlbGV0ZWRdIgogbXNnc3RyICJb5bey5Yig6ZmkXSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjExMzUgYnVpbHRpbi9yZW1vdGUuYzoxMDM2CisjOiBidWlsdGluL2ZldGNoLmM6MTE2MSBidWlsdGluL3JlbW90ZS5jOjEwMzYKIG1zZ2lkICIobm9uZSkiCiBtc2dzdHIgIu+8iOaXoO+8iSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjExNTgKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxMTg0CiAjLCBjLWZvcm1hdAogbXNnaWQgIlJlZnVzaW5nIHRvIGZldGNoIGludG8gY3VycmVudCBicmFuY2ggJXMgb2Ygbm9uLWJhcmUgcmVwb3NpdG9yeSIKIG1zZ3N0ciAi5ouS57ud6I635Y+W5Yiw6Z2e57qv5LuT5bqT55qE5b2T5YmN5YiG5pSvICVzIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTE3NworIzogYnVpbHRpbi9mZXRjaC5jOjEyMDMKICMsIGMtZm9ybWF0CiBtc2dpZCAiT3B0aW9uIFwiJXNcIiB2YWx1ZSBcIiVzXCIgaXMgbm90IHZhbGlkIGZvciAlcyIKIG1zZ3N0ciAi6YCJ6aG5IFwiJXNcIiDnmoTlgLwgXCIlc1wiIOWvueS6jiAlcyDmmK/ml6DmlYjnmoQiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxMTgwCisjOiBidWlsdGluL2ZldGNoLmM6MTIwNgogIywgYy1mb3JtYXQKIG1zZ2lkICJPcHRpb24gXCIlc1wiIGlzIGlnbm9yZWQgZm9yICVzXG4iCiBtc2dzdHIgIumAiemhuSBcIiVzXCIg5Li6ICVzIOaJgOW/veeVpVxuIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTQ4NAorIzogYnVpbHRpbi9mZXRjaC5jOjE0MTQKK21zZ2lkICJtdWx0aXBsZSBicmFuY2ggZGV0ZWN0ZWQsIGluY29tcGF0aWJsZSB3aXRoIC0tc2V0LXVwc3RyZWFtIgorbXNnc3RyICLmo4DmtYvliLDlpJrliIbmlK/vvIzlkowgLS1zZXQtdXBzdHJlYW0g5LiN5YW85a65IgorCisjOiBidWlsdGluL2ZldGNoLmM6MTQyOQorbXNnaWQgIm5vdCBzZXR0aW5nIHVwc3RyZWFtIGZvciBhIHJlbW90ZSByZW1vdGUtdHJhY2tpbmcgYnJhbmNoIgorbXNnc3RyICLmsqHmnInkuLrkuIDkuKrov5znqIvot5/ouKrliIbmlK/orr7nva7kuIrmuLgiCisKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNDMxCittc2dpZCAibm90IHNldHRpbmcgdXBzdHJlYW0gZm9yIGEgcmVtb3RlIHRhZyIKK21zZ3N0ciAi5rKh5pyJ5Li65LiA5Liq6L+c56iL5qCH562+6K6+572u5LiK5ri4IgorCisjOiBidWlsdGluL2ZldGNoLmM6MTQzMworbXNnaWQgInVua25vd24gYnJhbmNoIHR5cGUiCittc2dzdHIgIuacquefpeeahOWIhuaUr+exu+WeiyIKKworIzogYnVpbHRpbi9mZXRjaC5jOjE0MzUKK21zZ2lkICIiCisibm8gc291cmNlIGJyYW5jaCBmb3VuZC5cbiIKKyJ5b3UgbmVlZCB0byBzcGVjaWZ5IGV4YWN0bHkgb25lIGJyYW5jaCB3aXRoIHRoZSAtLXNldC11cHN0cmVhbSBvcHRpb24uIgorbXNnc3RyICIiCisi5pyq5Y+R546w5rqQ5YiG5pSv44CCXG4iCisi5oKo6ZyA6KaB5L2/55SoIC0tc2V0LXVwc3RyZWFtIOmAiemhueaMh+WumuS4gOS4quWIhuaUr+OAgiIKKworIzogYnVpbHRpbi9mZXRjaC5jOjE1NjEgYnVpbHRpbi9mZXRjaC5jOjE2MjMKICMsIGMtZm9ybWF0CiBtc2dpZCAiRmV0Y2hpbmcgJXNcbiIKIG1zZ3N0ciAi5q2j5Zyo6I635Y+WICVzXG4iCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNDg2IGJ1aWx0aW4vcmVtb3RlLmM6MTAwCisjOiBidWlsdGluL2ZldGNoLmM6MTU3MSBidWlsdGluL2ZldGNoLmM6MTYyNSBidWlsdGluL3JlbW90ZS5jOjEwMAogIywgYy1mb3JtYXQKIG1zZ2lkICJDb3VsZCBub3QgZmV0Y2ggJXMiCiBtc2dzdHIgIuS4jeiDveiOt+WPliAlcyIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE1MzIKLW1zZ2lkICIiCi0iLS1maWx0ZXIgY2FuIG9ubHkgYmUgdXNlZCB3aXRoIHRoZSByZW1vdGUgY29uZmlndXJlZCBpbiBleHRlbnNpb25zLiIKLSJwYXJ0aWFsQ2xvbmUiCi1tc2dzdHIgIuWPquWPr+S7peWwhiAtLWZpbHRlciDnlKjkuo7lnKggZXh0ZW5zaW9ucy5wYXJ0aWFsQ2xvbmUg5Lit6YWN572u55qE6L+c56iL5LuT5bqTIgorIzogYnVpbHRpbi9mZXRjaC5jOjE1ODMKKyMsIGMtZm9ybWF0Cittc2dpZCAiY291bGQgbm90IGZldGNoICclcycgKGV4aXQgY29kZTogJWQpXG4iCittc2dzdHIgIuaXoOazleiOt+WPliAnJXMn77yI6YCA5Ye656CB77yaJWTvvIlcbiIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE1NTYKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNjg1CiBtc2dpZCAiIgogIk5vIHJlbW90ZSByZXBvc2l0b3J5IHNwZWNpZmllZC4gIFBsZWFzZSwgc3BlY2lmeSBlaXRoZXIgYSBVUkwgb3IgYVxuIgogInJlbW90ZSBuYW1lIGZyb20gd2hpY2ggbmV3IHJldmlzaW9ucyBzaG91bGQgYmUgZmV0Y2hlZC4iCiBtc2dzdHIgIuacquaMh+Wumui/nOeoi+S7k+W6k+OAguivt+mAmui/h+S4gOS4qiBVUkwg5oiW6L+c56iL5LuT5bqT5ZCN5oyH5a6a77yM55So5Lul6I635Y+W5paw5o+Q5Lqk44CCIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTU5MworIzogYnVpbHRpbi9mZXRjaC5jOjE3MjIKIG1zZ2lkICJZb3UgbmVlZCB0byBzcGVjaWZ5IGEgdGFnIG5hbWUuIgogbXNnc3RyICLmgqjpnIDopoHmjIflrprkuIDkuKrmoIfnrb7lkI3np7DjgIIiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNjQ0CisjOiBidWlsdGluL2ZldGNoLmM6MTc3NAogbXNnaWQgIk5lZ2F0aXZlIGRlcHRoIGluIC0tZGVlcGVuIGlzIG5vdCBzdXBwb3J0ZWQiCiBtc2dzdHIgIi0tZGVlcGVuIOS4jeaUr+aMgei0n+aVsOa3seW6piIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE2NDYKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNzc2CiBtc2dpZCAiLS1kZWVwZW4gYW5kIC0tZGVwdGggYXJlIG11dHVhbGx5IGV4Y2x1c2l2ZSIKIG1zZ3N0ciAiLS1kZWVwZW4g5ZKMIC0tZGVwdGgg5piv5LqS5pal55qEIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTY1MQorIzogYnVpbHRpbi9mZXRjaC5jOjE3ODEKIG1zZ2lkICItLWRlcHRoIGFuZCAtLXVuc2hhbGxvdyBjYW5ub3QgYmUgdXNlZCB0b2dldGhlciIKIG1zZ3N0ciAiLS1kZXB0aCDlkowgLS11bnNoYWxsb3cg5LiN6IO95ZCM5pe25L2/55SoIgogCi0jOiBidWlsdGluL2ZldGNoLmM6MTY1MworIzogYnVpbHRpbi9mZXRjaC5jOjE3ODMKIG1zZ2lkICItLXVuc2hhbGxvdyBvbiBhIGNvbXBsZXRlIHJlcG9zaXRvcnkgZG9lcyBub3QgbWFrZSBzZW5zZSIKIG1zZ3N0ciAi5a+55LqO5LiA5Liq5a6M5pW055qE5LuT5bqT77yM5Y+C5pWwIC0tdW5zaGFsbG93IOayoeacieaEj+S5iSIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE2NjkKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxNzk5CiBtc2dpZCAiZmV0Y2ggLS1hbGwgZG9lcyBub3QgdGFrZSBhIHJlcG9zaXRvcnkgYXJndW1lbnQiCiBtc2dzdHIgImZldGNoIC0tYWxsIOS4jeiDveW4puS4gOS4quS7k+W6k+WPguaVsCIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE2NzEKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxODAxCiBtc2dpZCAiZmV0Y2ggLS1hbGwgZG9lcyBub3QgbWFrZSBzZW5zZSB3aXRoIHJlZnNwZWNzIgogbXNnc3RyICJmZXRjaCAtLWFsbCDluKblvJXnlKjop4TmoLzmsqHmnInku7vkvZXmhI/kuYkiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNjgwCisjOiBidWlsdGluL2ZldGNoLmM6MTgxMAogIywgYy1mb3JtYXQKIG1zZ2lkICJObyBzdWNoIHJlbW90ZSBvciByZW1vdGUgZ3JvdXA6ICVzIgogbXNnc3RyICLmsqHmnInov5nmoLfnmoTov5znqIvmiJbov5znqIvnu4TvvJolcyIKIAotIzogYnVpbHRpbi9mZXRjaC5jOjE2ODcKKyM6IGJ1aWx0aW4vZmV0Y2guYzoxODE3CiBtc2dpZCAiRmV0Y2hpbmcgYSBncm91cCBhbmQgc3BlY2lmeWluZyByZWZzcGVjcyBkb2VzIG5vdCBtYWtlIHNlbnNlIgogbXNnc3RyICLojrflj5bnu4TlubbmjIflrprlvJXnlKjop4TmoLzmsqHmnInmhI/kuYkiCiAKLSM6IGJ1aWx0aW4vZmV0Y2guYzoxNzAzCisjOiBidWlsdGluL2ZldGNoLmM6MTgzNQogbXNnaWQgIiIKICItLWZpbHRlciBjYW4gb25seSBiZSB1c2VkIHdpdGggdGhlIHJlbW90ZSBjb25maWd1cmVkIGluIGV4dGVuc2lvbnMuIgogInBhcnRpYWxjbG9uZSIKQEAgLTEzMTg5LDcgKzEzMjc2LDcgQEAKIG1zZ2lkICJpbnZhbGlkIHBhcmFtZXRlcjogZXhwZWN0ZWQgc2hhMSwgZ290ICclcyciCiBtc2dzdHIgIuaXoOaViOeahOWPguaVsO+8muacn+acmyBzaGEx77yM5b6X5YiwICclcyciCiAKLSM6IGJ1aWx0aW4vZ2MuYzozNAorIzogYnVpbHRpbi9nYy5jOjM1CiBtc2dpZCAiZ2l0IGdjIFs8b3B0aW9ucz5dIgogbXNnc3RyICJnaXQgZ2MgWzzpgInpobk+XSIKIApAQCAtMTMyMDMsMTcgKzEzMjkwLDE3IEBACiBtc2dpZCAiZmFpbGVkIHRvIHBhcnNlICclcycgdmFsdWUgJyVzJyIKIG1zZ3N0ciAi5peg5rOV6Kej5p6QICclcycg5YC8ICclcyciCiAKLSM6IGJ1aWx0aW4vZ2MuYzo0NzYgYnVpbHRpbi9pbml0LWRiLmM6NTUKKyM6IGJ1aWx0aW4vZ2MuYzo0NzUgYnVpbHRpbi9pbml0LWRiLmM6NTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IHN0YXQgJyVzJyIKIG1zZ3N0ciAi5LiN6IO95a+5ICclcycg6LCD55SoIHN0YXQiCiAKLSM6IGJ1aWx0aW4vZ2MuYzo0ODUgYnVpbHRpbi9ub3Rlcy5jOjI0MCBidWlsdGluL3RhZy5jOjUyOQorIzogYnVpbHRpbi9nYy5jOjQ4NCBidWlsdGluL25vdGVzLmM6MjQwIGJ1aWx0aW4vdGFnLmM6NTI5CiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCByZWFkICclcyciCiBtc2dzdHIgIuS4jeiDveivu+WPliAnJXMnIgogCi0jOiBidWlsdGluL2djLmM6NDkyCisjOiBidWlsdGluL2djLmM6NDkxCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJUaGUgbGFzdCBnYyBydW4gcmVwb3J0ZWQgdGhlIGZvbGxvd2luZy4gUGxlYXNlIGNvcnJlY3QgdGhlIHJvb3QgY2F1c2VcbiIKQEAgLTEzMjI3LDU5ICsxMzMxNCw1OSBAQAogIlxuIgogIiVzIgogCi0jOiBidWlsdGluL2djLmM6NTQwCisjOiBidWlsdGluL2djLmM6NTM5CiBtc2dpZCAicHJ1bmUgdW5yZWZlcmVuY2VkIG9iamVjdHMiCiBtc2dzdHIgIua4hemZpOacquW8leeUqOeahOWvueixoSIKIAotIzogYnVpbHRpbi9nYy5jOjU0MgorIzogYnVpbHRpbi9nYy5jOjU0MQogbXNnaWQgImJlIG1vcmUgdGhvcm91Z2ggKGluY3JlYXNlZCBydW50aW1lKSIKIG1zZ3N0ciAi5pu05b275bqV77yI5aKe5Yqg6L+Q6KGM5pe26Ze077yJIgogCi0jOiBidWlsdGluL2djLmM6NTQzCisjOiBidWlsdGluL2djLmM6NTQyCiBtc2dpZCAiZW5hYmxlIGF1dG8tZ2MgbW9kZSIKIG1zZ3N0ciAi5ZCv55So6Ieq5Yqo5Z6D5Zy+5Zue5pS25qih5byPIgogCi0jOiBidWlsdGluL2djLmM6NTQ2CisjOiBidWlsdGluL2djLmM6NTQ1CiBtc2dpZCAiZm9yY2UgcnVubmluZyBnYyBldmVuIGlmIHRoZXJlIG1heSBiZSBhbm90aGVyIGdjIHJ1bm5pbmciCiBtc2dzdHIgIuW8uuWItuaJp+ihjCBnYyDljbPkvb/lj6blpJbkuIDkuKogZ2Mg5q2j5Zyo5omn6KGMIgogCi0jOiBidWlsdGluL2djLmM6NTQ5CisjOiBidWlsdGluL2djLmM6NTQ4CiBtc2dpZCAicmVwYWNrIGFsbCBvdGhlciBwYWNrcyBleGNlcHQgdGhlIGxhcmdlc3QgcGFjayIKIG1zZ3N0ciAi6Zmk5LqG5pyA5aSn55qE5YyF5LmL5aSW77yM5a+55omA5pyJ5YW25a6D5YyF5paH5Lu26YeN5paw5omT5YyFIgogCi0jOiBidWlsdGluL2djLmM6NTY2CisjOiBidWlsdGluL2djLmM6NTY1CiAjLCBjLWZvcm1hdAogbXNnaWQgImZhaWxlZCB0byBwYXJzZSBnYy5sb2dleHBpcnkgdmFsdWUgJXMiCiBtc2dzdHIgIuino+aekCBnYy5sb2dleHBpcnkg55qE5YC8ICVzIOWksei0pSIKIAotIzogYnVpbHRpbi9nYy5jOjU3NworIzogYnVpbHRpbi9nYy5jOjU3NgogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gcGFyc2UgcHJ1bmUgZXhwaXJ5IHZhbHVlICVzIgogbXNnc3RyICLop6PmnpDmuIXpmaTmnJ/pmZDlgLwgJXMg5aSx6LSlIgogCi0jOiBidWlsdGluL2djLmM6NTk3CisjOiBidWlsdGluL2djLmM6NTk2CiAjLCBjLWZvcm1hdAogbXNnaWQgIkF1dG8gcGFja2luZyB0aGUgcmVwb3NpdG9yeSBpbiBiYWNrZ3JvdW5kIGZvciBvcHRpbXVtIHBlcmZvcm1hbmNlLlxuIgogbXNnc3RyICLoh6rliqjlnKjlkI7lj7DmiafooYzku5PlupPmiZPljIXku6XmsYLmnIDkvbPmgKfog73jgIJcbiIKIAotIzogYnVpbHRpbi9nYy5jOjU5OQorIzogYnVpbHRpbi9nYy5jOjU5OAogIywgYy1mb3JtYXQKIG1zZ2lkICJBdXRvIHBhY2tpbmcgdGhlIHJlcG9zaXRvcnkgZm9yIG9wdGltdW0gcGVyZm9ybWFuY2UuXG4iCiBtc2dzdHIgIuiHquWKqOaJk+WMheS7k+W6k+S7peaxguacgOS9s+aAp+iDveOAglxuIgogCi0jOiBidWlsdGluL2djLmM6NjAwCisjOiBidWlsdGluL2djLmM6NTk5CiAjLCBjLWZvcm1hdAogbXNnaWQgIlNlZSBcImdpdCBoZWxwIGdjXCIgZm9yIG1hbnVhbCBob3VzZWtlZXBpbmcuXG4iCiBtc2dzdHIgIuaJi+W3pee7tOaKpOWPguingSBcImdpdCBoZWxwIGdjXCLjgIJcbiIKIAotIzogYnVpbHRpbi9nYy5jOjY0MAorIzogYnVpbHRpbi9nYy5jOjYzOQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiZ2MgaXMgYWxyZWFkeSBydW5uaW5nIG9uIG1hY2hpbmUgJyVzJyBwaWQgJTxQUkl1TUFYPiAodXNlIC0tZm9yY2UgaWYgbm90KSIKIG1zZ3N0ciAiIgogIuW3sue7j+acieS4gOS4qiBnYyDmraPov5DooYzlnKjmnLrlmaggJyVzJyBwaWQgJTxQUkl1TUFYPu+8iOWmguaenOS4jeaYr++8jOS9v+eUqCAtLWZvcmNl77yJIgogCi0jOiBidWlsdGluL2djLmM6Njk1CisjOiBidWlsdGluL2djLmM6Njk0CiBtc2dpZCAiIgogIlRoZXJlIGFyZSB0b28gbWFueSB1bnJlYWNoYWJsZSBsb29zZSBvYmplY3RzOyBydW4gJ2dpdCBwcnVuZScgdG8gcmVtb3ZlIHRoZW0uIgogbXNnc3RyICLmnInlpKrlpJrkuI3lj6/ovr7nmoTmnb7mlaPlr7nosaHvvIzov5DooYwgJ2dpdCBwcnVuZScg5Yig6Zmk5a6D5Lus44CCIgpAQCAtMTMzMDMsMjU4ICsxMzM5MCwyNTggQEAKICMuIGdyZXAudGhyZWFkcwogIy4KICM6IGJ1aWx0aW4vZ3JlcC5jOjI4NyBidWlsdGluL2luZGV4LXBhY2suYzoxNTM0IGJ1aWx0aW4vaW5kZXgtcGFjay5jOjE3MjcKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjcyOAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNzA4CiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vIHRocmVhZHMgc3VwcG9ydCwgaWdub3JpbmcgJXMiCiBtc2dzdHIgIuayoeaciee6v+eoi+aUr+aMge+8jOW/veeVpSAlcyIKIAotIzogYnVpbHRpbi9ncmVwLmM6NDY3IGJ1aWx0aW4vZ3JlcC5jOjU5MSBidWlsdGluL2dyZXAuYzo2MzMKKyM6IGJ1aWx0aW4vZ3JlcC5jOjQ2NyBidWlsdGluL2dyZXAuYzo1OTIgYnVpbHRpbi9ncmVwLmM6NjM1CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byByZWFkIHRyZWUgKCVzKSIKIG1zZ3N0ciAi5peg5rOV6K+75Y+W5qCR77yIJXPvvIkiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjY0OAorIzogYnVpbHRpbi9ncmVwLmM6NjUwCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBncmVwIGZyb20gb2JqZWN0IG9mIHR5cGUgJXMiCiBtc2dzdHIgIuaXoOazleaKk+WPluadpeiHquS6jiAlcyDnsbvlnovnmoTlr7nosaEiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjcxNAorIzogYnVpbHRpbi9ncmVwLmM6NzE2CiAjLCBjLWZvcm1hdAogbXNnaWQgInN3aXRjaCBgJWMnIGV4cGVjdHMgYSBudW1lcmljYWwgdmFsdWUiCiBtc2dzdHIgIuW8gOWFsyBgJWMnIOacn+acm+S4gOS4quaVsOWtl+WAvCIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODEzCisjOiBidWlsdGluL2dyZXAuYzo4MTUKIG1zZ2lkICJzZWFyY2ggaW4gaW5kZXggaW5zdGVhZCBvZiBpbiB0aGUgd29yayB0cmVlIgogbXNnc3RyICLlnKjntKLlvJXljLrmkJzntKLogIzkuI3mmK/lnKjlt6XkvZzljLoiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjgxNQorIzogYnVpbHRpbi9ncmVwLmM6ODE3CiBtc2dpZCAiZmluZCBpbiBjb250ZW50cyBub3QgbWFuYWdlZCBieSBnaXQiCiBtc2dzdHIgIuWcqOacquiiqyBnaXQg566h55CG55qE5YaF5a655Lit5p+l5om+IgogCiAjICDor5HogIXvvJrkuK3mloflrZfnrKbkuLLmi7zmjqXvvIzlj6/liKDpmaTliY3lr7znqbrmoLwKLSM6IGJ1aWx0aW4vZ3JlcC5jOjgxNworIzogYnVpbHRpbi9ncmVwLmM6ODE5CiBtc2dpZCAic2VhcmNoIGluIGJvdGggdHJhY2tlZCBhbmQgdW50cmFja2VkIGZpbGVzIgogbXNnc3RyICLlnKjot5/ouKrlkozmnKrot5/ouKrnmoTmlofku7bkuK3mkJzntKIiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjgxOQorIzogYnVpbHRpbi9ncmVwLmM6ODIxCiBtc2dpZCAiaWdub3JlIGZpbGVzIHNwZWNpZmllZCB2aWEgJy5naXRpZ25vcmUnIgogbXNnc3RyICLlv73nlaUgJy5naXRpZ25vcmUnIOWMheWQq+eahOaWh+S7tiIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODIxCisjOiBidWlsdGluL2dyZXAuYzo4MjMKIG1zZ2lkICJyZWN1cnNpdmVseSBzZWFyY2ggaW4gZWFjaCBzdWJtb2R1bGUiCiBtc2dzdHIgIuWcqOavj+S4gOS4quWtkOaooee7hOS4remAkuW9kuaQnOe0oiIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODI0CisjOiBidWlsdGluL2dyZXAuYzo4MjYKIG1zZ2lkICJzaG93IG5vbi1tYXRjaGluZyBsaW5lcyIKIG1zZ3N0ciAi5pi+56S65pyq5Yy56YWN55qE6KGMIgogCi0jOiBidWlsdGluL2dyZXAuYzo4MjYKKyM6IGJ1aWx0aW4vZ3JlcC5jOjgyOAogbXNnaWQgImNhc2UgaW5zZW5zaXRpdmUgbWF0Y2hpbmciCiBtc2dzdHIgIuS4jeWMuuWIhuWkp+Wwj+WGmeWMuemFjSIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODI4CisjOiBidWlsdGluL2dyZXAuYzo4MzAKIG1zZ2lkICJtYXRjaCBwYXR0ZXJucyBvbmx5IGF0IHdvcmQgYm91bmRhcmllcyIKIG1zZ3N0ciAi5Y+q5Zyo5Y2V6K+N6L6555WM5Yy56YWN5qih5byPIgogCi0jOiBidWlsdGluL2dyZXAuYzo4MzAKKyM6IGJ1aWx0aW4vZ3JlcC5jOjgzMgogbXNnaWQgInByb2Nlc3MgYmluYXJ5IGZpbGVzIGFzIHRleHQiCiBtc2dzdHIgIuaKiuS6jOi/m+WItuaWh+S7tuW9k+WBmuaWh+acrOWkhOeQhiIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODMyCisjOiBidWlsdGluL2dyZXAuYzo4MzQKIG1zZ2lkICJkb24ndCBtYXRjaCBwYXR0ZXJucyBpbiBiaW5hcnkgZmlsZXMiCiBtc2dzdHIgIuS4jeWcqOS6jOi/m+WItuaWh+S7tuS4reWMuemFjeaooeW8jyIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODM1CisjOiBidWlsdGluL2dyZXAuYzo4MzcKIG1zZ2lkICJwcm9jZXNzIGJpbmFyeSBmaWxlcyB3aXRoIHRleHRjb252IGZpbHRlcnMiCiBtc2dzdHIgIueUqCB0ZXh0Y29udiDov4fmu6TlmajlpITnkIbkuozov5vliLbmlofku7YiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjgzNworIzogYnVpbHRpbi9ncmVwLmM6ODM5CiBtc2dpZCAic2VhcmNoIGluIHN1YmRpcmVjdG9yaWVzIChkZWZhdWx0KSIKIG1zZ3N0ciAi5Zyo5a2Q55uu5b2V5Lit5a+75om+77yI6buY6K6k77yJIgogCi0jOiBidWlsdGluL2dyZXAuYzo4MzkKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg0MQogbXNnaWQgImRlc2NlbmQgYXQgbW9zdCA8ZGVwdGg+IGxldmVscyIKIG1zZ3N0ciAi5pyA5aSa5Lul5oyH5a6a55qE5rex5bqm5ZCR5LiL5a+75om+IgogCi0jOiBidWlsdGluL2dyZXAuYzo4NDMKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg0NQogbXNnaWQgInVzZSBleHRlbmRlZCBQT1NJWCByZWd1bGFyIGV4cHJlc3Npb25zIgogbXNnc3RyICLkvb/nlKjmianlsZXnmoQgUE9TSVgg5q2j5YiZ6KGo6L6+5byPIgogCi0jOiBidWlsdGluL2dyZXAuYzo4NDYKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg0OAogbXNnaWQgInVzZSBiYXNpYyBQT1NJWCByZWd1bGFyIGV4cHJlc3Npb25zIChkZWZhdWx0KSIKIG1zZ3N0ciAi5L2/55So5Z+65pys55qEIFBPU0lYIOato+WImeihqOi+vuW8j++8iOm7mOiupO+8iSIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODQ5CisjOiBidWlsdGluL2dyZXAuYzo4NTEKIG1zZ2lkICJpbnRlcnByZXQgcGF0dGVybnMgYXMgZml4ZWQgc3RyaW5ncyIKIG1zZ3N0ciAi5oqK5qih5byP6Kej5p6Q5Li65Zu65a6a55qE5a2X56ym5LiyIgogCi0jOiBidWlsdGluL2dyZXAuYzo4NTIKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg1NAogbXNnaWQgInVzZSBQZXJsLWNvbXBhdGlibGUgcmVndWxhciBleHByZXNzaW9ucyIKIG1zZ3N0ciAi5L2/55SoIFBlcmwg5YW85a6555qE5q2j5YiZ6KGo6L6+5byPIgogCi0jOiBidWlsdGluL2dyZXAuYzo4NTUKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg1NwogbXNnaWQgInNob3cgbGluZSBudW1iZXJzIgogbXNnc3RyICLmmL7npLrooYzlj7ciCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg1NgorIzogYnVpbHRpbi9ncmVwLmM6ODU4CiBtc2dpZCAic2hvdyBjb2x1bW4gbnVtYmVyIG9mIGZpcnN0IG1hdGNoIgogbXNnc3RyICLmmL7npLrnrKzkuIDkuKrljLnphY3nmoTliJflj7ciCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg1NworIzogYnVpbHRpbi9ncmVwLmM6ODU5CiBtc2dpZCAiZG9uJ3Qgc2hvdyBmaWxlbmFtZXMiCiBtc2dzdHIgIuS4jeaYvuekuuaWh+S7tuWQjSIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODU4CisjOiBidWlsdGluL2dyZXAuYzo4NjAKIG1zZ2lkICJzaG93IGZpbGVuYW1lcyIKIG1zZ3N0ciAi5pi+56S65paH5Lu25ZCNIgogCi0jOiBidWlsdGluL2dyZXAuYzo4NjAKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg2MgogbXNnaWQgInNob3cgZmlsZW5hbWVzIHJlbGF0aXZlIHRvIHRvcCBkaXJlY3RvcnkiCiBtc2dzdHIgIuaYvuekuuebuOWvueS6jumhtue6p+ebruW9leeahOaWh+S7tuWQjSIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODYyCisjOiBidWlsdGluL2dyZXAuYzo4NjQKIG1zZ2lkICJzaG93IG9ubHkgZmlsZW5hbWVzIGluc3RlYWQgb2YgbWF0Y2hpbmcgbGluZXMiCiBtc2dzdHIgIuWPquaYvuekuuaWh+S7tuWQjeiAjOS4jeaYvuekuuWMuemFjeeahOihjCIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODY0CisjOiBidWlsdGluL2dyZXAuYzo4NjYKIG1zZ2lkICJzeW5vbnltIGZvciAtLWZpbGVzLXdpdGgtbWF0Y2hlcyIKIG1zZ3N0ciAi5ZKMIC0tZmlsZXMtd2l0aC1tYXRjaGVzIOWQjOS5iSIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODY3CisjOiBidWlsdGluL2dyZXAuYzo4NjkKIG1zZ2lkICJzaG93IG9ubHkgdGhlIG5hbWVzIG9mIGZpbGVzIHdpdGhvdXQgbWF0Y2giCiBtc2dzdHIgIuWPquaYvuekuuacquWMuemFjeeahOaWh+S7tuWQjSIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODY5CisjOiBidWlsdGluL2dyZXAuYzo4NzEKIG1zZ2lkICJwcmludCBOVUwgYWZ0ZXIgZmlsZW5hbWVzIgogbXNnc3RyICLlnKjmlofku7blkI3lkI7ovpPlh7ogTlVMIOWtl+espiIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODcyCisjOiBidWlsdGluL2dyZXAuYzo4NzQKIG1zZ2lkICJzaG93IG9ubHkgbWF0Y2hpbmcgcGFydHMgb2YgYSBsaW5lIgogbXNnc3RyICLlj6rmmL7npLrooYzkuK3nmoTljLnphY3nmoTpg6jliIYiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg3NAorIzogYnVpbHRpbi9ncmVwLmM6ODc2CiBtc2dpZCAic2hvdyB0aGUgbnVtYmVyIG9mIG1hdGNoZXMgaW5zdGVhZCBvZiBtYXRjaGluZyBsaW5lcyIKIG1zZ3N0ciAi5pi+56S65oC75Yy56YWN6KGM5pWw77yM6ICM5LiN5pi+56S65Yy56YWN55qE6KGMIgogCi0jOiBidWlsdGluL2dyZXAuYzo4NzUKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg3NwogbXNnaWQgImhpZ2hsaWdodCBtYXRjaGVzIgogbXNnc3RyICLpq5jkuq7mmL7npLrljLnphY3pobkiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg3NworIzogYnVpbHRpbi9ncmVwLmM6ODc5CiBtc2dpZCAicHJpbnQgZW1wdHkgbGluZSBiZXR3ZWVuIG1hdGNoZXMgZnJvbSBkaWZmZXJlbnQgZmlsZXMiCiBtc2dzdHIgIuWcqOS4jeWQjOaWh+S7tueahOWMuemFjemhueS5i+mXtOaJk+WNsOepuuihjCIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODc5CisjOiBidWlsdGluL2dyZXAuYzo4ODEKIG1zZ2lkICJzaG93IGZpbGVuYW1lIG9ubHkgb25jZSBhYm92ZSBtYXRjaGVzIGZyb20gc2FtZSBmaWxlIgogbXNnc3RyICLlj6rlnKjlkIzkuIDmlofku7bnmoTljLnphY3pobnnmoTkuIrpnaLmmL7npLrkuIDmrKHmlofku7blkI0iCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg4MgorIzogYnVpbHRpbi9ncmVwLmM6ODg0CiBtc2dpZCAic2hvdyA8bj4gY29udGV4dCBsaW5lcyBiZWZvcmUgYW5kIGFmdGVyIG1hdGNoZXMiCiBtc2dzdHIgIuaYvuekuuWMuemFjemhueWJjeWQjueahCA8bj4g6KGM5LiK5LiL5paHIgogCi0jOiBidWlsdGluL2dyZXAuYzo4ODUKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg4NwogbXNnaWQgInNob3cgPG4+IGNvbnRleHQgbGluZXMgYmVmb3JlIG1hdGNoZXMiCiBtc2dzdHIgIuaYvuekuuWMuemFjemhueWJjSA8bj4g6KGM5LiK5LiL5paHIgogCi0jOiBidWlsdGluL2dyZXAuYzo4ODcKKyM6IGJ1aWx0aW4vZ3JlcC5jOjg4OQogbXNnaWQgInNob3cgPG4+IGNvbnRleHQgbGluZXMgYWZ0ZXIgbWF0Y2hlcyIKIG1zZ3N0ciAi5pi+56S65Yy56YWN6aG55ZCOIDxuPiDooYzkuIrkuIvmlociCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg4OQorIzogYnVpbHRpbi9ncmVwLmM6ODkxCiBtc2dpZCAidXNlIDxuPiB3b3JrZXIgdGhyZWFkcyIKIG1zZ3N0ciAi5L2/55SoIDxuPiDkuKrlt6XkvZznur/nqIsiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg5MAorIzogYnVpbHRpbi9ncmVwLmM6ODkyCiBtc2dpZCAic2hvcnRjdXQgZm9yIC1DIE5VTSIKIG1zZ3N0ciAi5b+r5o236ZSuIC1DIOaVsOWtlyIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODkzCisjOiBidWlsdGluL2dyZXAuYzo4OTUKIG1zZ2lkICJzaG93IGEgbGluZSB3aXRoIHRoZSBmdW5jdGlvbiBuYW1lIGJlZm9yZSBtYXRjaGVzIgogbXNnc3RyICLlnKjljLnphY3nmoTliY3pnaLmmL7npLrkuIDooYzlh73mlbDlkI0iCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjg5NQorIzogYnVpbHRpbi9ncmVwLmM6ODk3CiBtc2dpZCAic2hvdyB0aGUgc3Vycm91bmRpbmcgZnVuY3Rpb24iCiBtc2dzdHIgIuaYvuekuuaJgOWcqOWHveaVsOeahOWJjeWQjuWGheWuuSIKIAotIzogYnVpbHRpbi9ncmVwLmM6ODk4CisjOiBidWlsdGluL2dyZXAuYzo5MDAKIG1zZ2lkICJyZWFkIHBhdHRlcm5zIGZyb20gZmlsZSIKIG1zZ3N0ciAi5LuO5paH5Lu26K+75Y+W5qih5byPIgogCi0jOiBidWlsdGluL2dyZXAuYzo5MDAKKyM6IGJ1aWx0aW4vZ3JlcC5jOjkwMgogbXNnaWQgIm1hdGNoIDxwYXR0ZXJuPiIKIG1zZ3N0ciAi5Yy56YWNIDzmqKHlvI8+IgogCi0jOiBidWlsdGluL2dyZXAuYzo5MDIKKyM6IGJ1aWx0aW4vZ3JlcC5jOjkwNAogbXNnaWQgImNvbWJpbmUgcGF0dGVybnMgc3BlY2lmaWVkIHdpdGggLWUiCiBtc2dzdHIgIue7hOWQiOeUqCAtZSDlj4LmlbDorr7lrprnmoTmqKHlvI8iCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjkxNAorIzogYnVpbHRpbi9ncmVwLmM6OTE2CiBtc2dpZCAiaW5kaWNhdGUgaGl0IHdpdGggZXhpdCBzdGF0dXMgd2l0aG91dCBvdXRwdXQiCiBtc2dzdHIgIuS4jei+k+WHuu+8jOiAjOeUqOmAgOWHuueggeagh+ivhuWRveS4reeKtuaAgSIKIAotIzogYnVpbHRpbi9ncmVwLmM6OTE2CisjOiBidWlsdGluL2dyZXAuYzo5MTgKIG1zZ2lkICJzaG93IG9ubHkgbWF0Y2hlcyBmcm9tIGZpbGVzIHRoYXQgbWF0Y2ggYWxsIHBhdHRlcm5zIgogbXNnc3RyICLlj6rmmL7npLrljLnphY3miYDmnInmqKHlvI/nmoTmlofku7bkuK3nmoTljLnphY0iCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjkxOAorIzogYnVpbHRpbi9ncmVwLmM6OTIwCiBtc2dpZCAic2hvdyBwYXJzZSB0cmVlIGZvciBncmVwIGV4cHJlc3Npb24iCiBtc2dzdHIgIuaYvuekuiBncmVwIOihqOi+vuW8j+eahOino+aekOagkSIKIAotIzogYnVpbHRpbi9ncmVwLmM6OTIyCisjOiBidWlsdGluL2dyZXAuYzo5MjQKIG1zZ2lkICJwYWdlciIKIG1zZ3N0ciAi5YiG6aG1IgogCi0jOiBidWlsdGluL2dyZXAuYzo5MjIKKyM6IGJ1aWx0aW4vZ3JlcC5jOjkyNAogbXNnaWQgInNob3cgbWF0Y2hpbmcgZmlsZXMgaW4gdGhlIHBhZ2VyIgogbXNnc3RyICLliIbpobXmmL7npLrljLnphY3nmoTmlofku7YiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjkyNgorIzogYnVpbHRpbi9ncmVwLmM6OTI4CiBtc2dpZCAiYWxsb3cgY2FsbGluZyBvZiBncmVwKDEpIChpZ25vcmVkIGJ5IHRoaXMgYnVpbGQpIgogbXNnc3RyICLlhYHorrjosIPnlKggZ3JlcCgxKe+8iOacrOasoeaehOW7uuW/veeVpe+8iSIKIAotIzogYnVpbHRpbi9ncmVwLmM6OTkwCisjOiBidWlsdGluL2dyZXAuYzo5OTIKIG1zZ2lkICJubyBwYXR0ZXJuIGdpdmVuIgogbXNnc3RyICLmnKrmj5DkvpvljLnphY3mqKHlvI8iCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjEwMjYKKyM6IGJ1aWx0aW4vZ3JlcC5jOjEwMjgKIG1zZ2lkICItLW5vLWluZGV4IG9yIC0tdW50cmFja2VkIGNhbm5vdCBiZSB1c2VkIHdpdGggcmV2cyIKIG1zZ3N0ciAiLS1uby1pbmRleCDmiJYgLS11bnRyYWNrZWQg5LiN6IO95ZKM54mI5pys5ZCM5pe25L2/55SoIgogCi0jOiBidWlsdGluL2dyZXAuYzoxMDM0CisjOiBidWlsdGluL2dyZXAuYzoxMDM2CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byByZXNvbHZlIHJldmlzaW9uOiAlcyIKIG1zZ3N0ciAi5LiN6IO96Kej5p6Q54mI5pys77yaJXMiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjEwNjUKKyM6IGJ1aWx0aW4vZ3JlcC5jOjEwNjcKIG1zZ2lkICJpbnZhbGlkIG9wdGlvbiBjb21iaW5hdGlvbiwgaWdub3JpbmcgLS10aHJlYWRzIgogbXNnc3RyICLml6DmlYjnmoTpgInpobnnu4TlkIjvvIzlv73nlaUgLS10aHJlYWRzIgogCi0jOiBidWlsdGluL2dyZXAuYzoxMDY4IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzQxNgorIzogYnVpbHRpbi9ncmVwLmM6MTA3MCBidWlsdGluL3BhY2stb2JqZWN0cy5jOjM0MDAKIG1zZ2lkICJubyB0aHJlYWRzIHN1cHBvcnQsIGlnbm9yaW5nIC0tdGhyZWFkcyIKIG1zZ3N0ciAi5rKh5pyJ57q/56iL5pSv5oyB77yM5b+955WlIC0tdGhyZWFkcyIKIAotIzogYnVpbHRpbi9ncmVwLmM6MTA3MSBidWlsdGluL2luZGV4LXBhY2suYzoxNTMxIGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjcyNQorIzogYnVpbHRpbi9ncmVwLmM6MTA3MyBidWlsdGluL2luZGV4LXBhY2suYzoxNTMxIGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjcwNQogIywgYy1mb3JtYXQKIG1zZ2lkICJpbnZhbGlkIG51bWJlciBvZiB0aHJlYWRzIHNwZWNpZmllZCAoJWQpIgogbXNnc3RyICLmjIflrprnmoTnur/nqIvmlbDml6DmlYjvvIglZO+8iSIKIAotIzogYnVpbHRpbi9ncmVwLmM6MTA5NAorIzogYnVpbHRpbi9ncmVwLmM6MTA5NgogbXNnaWQgIi0tb3Blbi1maWxlcy1pbi1wYWdlciBvbmx5IHdvcmtzIG9uIHRoZSB3b3JrdHJlZSIKIG1zZ3N0ciAiLS1vcGVuLWZpbGVzLWluLXBhZ2VyIOS7heeUqOS6juW3peS9nOWMuiIKIAotIzogYnVpbHRpbi9ncmVwLmM6MTExNworIzogYnVpbHRpbi9ncmVwLmM6MTExOQogbXNnaWQgIm9wdGlvbiBub3Qgc3VwcG9ydGVkIHdpdGggLS1yZWN1cnNlLXN1Ym1vZHVsZXMiCiBtc2dzdHIgIumAiemhueS4jeaUr+aMgeWSjCAtLXJlY3Vyc2Utc3VibW9kdWxlcyDlhbHnlKgiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjExMjMKKyM6IGJ1aWx0aW4vZ3JlcC5jOjExMjUKIG1zZ2lkICItLWNhY2hlZCBvciAtLXVudHJhY2tlZCBjYW5ub3QgYmUgdXNlZCB3aXRoIC0tbm8taW5kZXgiCiBtc2dzdHIgIi0tY2FjaGVkIOaIliAtLXVudHJhY2tlZCDkuI3og73kuI4gLS1uby1pbmRleCDlkIzml7bkvb/nlKgiCiAKLSM6IGJ1aWx0aW4vZ3JlcC5jOjExMjkKKyM6IGJ1aWx0aW4vZ3JlcC5jOjExMzEKIG1zZ2lkICItLVtuby1dZXhjbHVkZS1zdGFuZGFyZCBjYW5ub3QgYmUgdXNlZCBmb3IgdHJhY2tlZCBjb250ZW50cyIKIG1zZ3N0ciAiLS1bbm8tXWV4Y2x1ZGUtc3RhbmRhcmQg5LiN6IO955So5LqO5bey6Lef6Liq5YaF5a65IgogCi0jOiBidWlsdGluL2dyZXAuYzoxMTM3CisjOiBidWlsdGluL2dyZXAuYzoxMTM5CiBtc2dpZCAiYm90aCAtLWNhY2hlZCBhbmQgdHJlZXMgYXJlIGdpdmVuIgogbXNnc3RyICLlkIzml7bnu5nlh7rkuoYgLS1jYWNoZWQg5ZKM5qCR5a+56LGhIgogCkBAIC0xMzg2Niw3ICsxMzk1Myw3IEBACiBtc2dpZCAiUmVzb2x2aW5nIGRlbHRhcyIKIG1zZ3N0ciAi5aSE55CGIGRlbHRhIOS4rSIKIAotIzogYnVpbHRpbi9pbmRleC1wYWNrLmM6MTIwNSBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI0OTcKKyM6IGJ1aWx0aW4vaW5kZXgtcGFjay5jOjEyMDUgYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNDgxCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBjcmVhdGUgdGhyZWFkOiAlcyIKIG1zZ3N0ciAi5LiN6IO95Yib5bu657q/56iL77yaJXMiCkBAIC0xMzkzMSw3ICsxNDAxOCw3IEBACiBtc2dpZCAiY2Fubm90IHN0b3JlIGluZGV4IGZpbGUiCiBtc2dzdHIgIuaXoOazleWtmOWCqOe0ouW8leaWh+S7tiIKIAotIzogYnVpbHRpbi9pbmRleC1wYWNrLmM6MTUyNSBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI3MzYKKyM6IGJ1aWx0aW4vaW5kZXgtcGFjay5jOjE1MjUgYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNzE2CiAjLCBjLWZvcm1hdAogbXNnaWQgImJhZCBwYWNrLmluZGV4dmVyc2lvbj0lPFBSSXUzMj4iCiBtc2dzdHIgIuWdj+eahCBwYWNrLmluZGV4dmVyc2lvbj0lPFBSSXUzMj4iCkBAIC0xNDIxMCw3NCArMTQyOTcsNzQgQEAKIG1zZ2lkICJnaXQgc2hvdyAlczogYmFkIGZpbGUiCiBtc2dzdHIgImdpdCBzaG93ICVzOiDmjZ/lnY/nmoTmlofku7YiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6NTQ5IGJ1aWx0aW4vbG9nLmM6NjQzCisjOiBidWlsdGluL2xvZy5jOjU0OSBidWlsdGluL2xvZy5jOjY0NAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcmVhZCBvYmplY3QgJXMiCiBtc2dzdHIgIuS4jeiDveivu+WPluWvueixoSAlcyIKIAotIzogYnVpbHRpbi9sb2cuYzo2NjgKKyM6IGJ1aWx0aW4vbG9nLmM6NjY5CiAjLCBjLWZvcm1hdAogbXNnaWQgInVua25vd24gdHlwZTogJWQiCiBtc2dzdHIgIuacquefpeexu+Wei++8miVkIgogCi0jOiBidWlsdGluL2xvZy5jOjc5MQorIzogYnVpbHRpbi9sb2cuYzo3OTIKIG1zZ2lkICJmb3JtYXQuaGVhZGVycyB3aXRob3V0IHZhbHVlIgogbXNnc3RyICJmb3JtYXQuaGVhZGVycyDmsqHmnInlgLwiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6OTA4CisjOiBidWlsdGluL2xvZy5jOjkwOQogbXNnaWQgIm5hbWUgb2Ygb3V0cHV0IGRpcmVjdG9yeSBpcyB0b28gbG9uZyIKIG1zZ3N0ciAi6L6T5Ye655uu5b2V5ZCN5aSq6ZW/IgogCi0jOiBidWlsdGluL2xvZy5jOjkyNAorIzogYnVpbHRpbi9sb2cuYzo5MjUKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IG9wZW4gcGF0Y2ggZmlsZSAlcyIKIG1zZ3N0ciAi5peg5rOV5omT5byA6KGl5LiB5paH5Lu2ICVzIgogCi0jOiBidWlsdGluL2xvZy5jOjk0MQorIzogYnVpbHRpbi9sb2cuYzo5NDIKIG1zZ2lkICJuZWVkIGV4YWN0bHkgb25lIHJhbmdlIgogbXNnc3RyICLlj6rpnIDopoHkuIDkuKrojIPlm7QiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6OTUxCisjOiBidWlsdGluL2xvZy5jOjk1MgogbXNnaWQgIm5vdCBhIHJhbmdlIgogbXNnc3RyICLkuI3mmK/kuIDkuKrojIPlm7QiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTA3NAorIzogYnVpbHRpbi9sb2cuYzoxMDc1CiBtc2dpZCAiY292ZXIgbGV0dGVyIG5lZWRzIGVtYWlsIGZvcm1hdCIKIG1zZ3N0ciAi6ZmE5Ye96ZyA6KaB6YKu5Lu25Zyw5Z2A5qC85byPIgogCi0jOiBidWlsdGluL2xvZy5jOjEwODAKKyM6IGJ1aWx0aW4vbG9nLmM6MTA4MQogbXNnaWQgImZhaWxlZCB0byBjcmVhdGUgY292ZXItbGV0dGVyIGZpbGUiCiBtc2dzdHIgIuaXoOazleWIm+W7uumZhOWHveaWh+S7tiIKIAotIzogYnVpbHRpbi9sb2cuYzoxMTU5CisjOiBidWlsdGluL2xvZy5jOjExNjAKICMsIGMtZm9ybWF0CiBtc2dpZCAiaW5zYW5lIGluLXJlcGx5LXRvOiAlcyIKIG1zZ3N0ciAi5LiN5q2j5bi455qEIGluLXJlcGx5LXRv77yaJXMiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTE4NgorIzogYnVpbHRpbi9sb2cuYzoxMTg3CiBtc2dpZCAiZ2l0IGZvcm1hdC1wYXRjaCBbPG9wdGlvbnM+XSBbPHNpbmNlPiB8IDxyZXZpc2lvbi1yYW5nZT5dIgogbXNnc3RyICJnaXQgZm9ybWF0LXBhdGNoIFs86YCJ6aG5Pl0gWzzku44+IHwgPOeJiOacrOiMg+WbtD5dIgogCi0jOiBidWlsdGluL2xvZy5jOjEyNDQKKyM6IGJ1aWx0aW4vbG9nLmM6MTI0NQogbXNnaWQgInR3byBvdXRwdXQgZGlyZWN0b3JpZXM/IgogbXNnc3RyICLkuKTkuKrovpPlh7rnm67lvZXvvJ8iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTM1NSBidWlsdGluL2xvZy5jOjIwOTkgYnVpbHRpbi9sb2cuYzoyMTAxIGJ1aWx0aW4vbG9nLmM6MjExMworIzogYnVpbHRpbi9sb2cuYzoxMzU2IGJ1aWx0aW4vbG9nLmM6MjExNiBidWlsdGluL2xvZy5jOjIxMTggYnVpbHRpbi9sb2cuYzoyMTMwCiAjLCBjLWZvcm1hdAogbXNnaWQgInVua25vd24gY29tbWl0ICVzIgogbXNnc3RyICLmnKrnn6Xmj5DkuqQgJXMiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTM2NSBidWlsdGluL3JlcGxhY2UuYzo1OCBidWlsdGluL3JlcGxhY2UuYzoyMDcKKyM6IGJ1aWx0aW4vbG9nLmM6MTM2NiBidWlsdGluL3JlcGxhY2UuYzo1OCBidWlsdGluL3JlcGxhY2UuYzoyMDcKICM6IGJ1aWx0aW4vcmVwbGFjZS5jOjIxMAogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gcmVzb2x2ZSAnJXMnIGFzIGEgdmFsaWQgcmVmIgogbXNnc3RyICLml6Dms5XlsIYgJyVzJyDop6PmnpDkuLrkuIDkuKrmnInmlYjlvJXnlKgiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTM3MAorIzogYnVpbHRpbi9sb2cuYzoxMzcxCiBtc2dpZCAiY291bGQgbm90IGZpbmQgZXhhY3QgbWVyZ2UgYmFzZSIKIG1zZ3N0ciAi5LiN6IO95om+5Yiw5YeG56Gu55qE5ZCI5bm25Z+657q/IgogCi0jOiBidWlsdGluL2xvZy5jOjEzNzQKKyM6IGJ1aWx0aW4vbG9nLmM6MTM3NQogbXNnaWQgIiIKICJmYWlsZWQgdG8gZ2V0IHVwc3RyZWFtLCBpZiB5b3Ugd2FudCB0byByZWNvcmQgYmFzZSBjb21taXQgYXV0b21hdGljYWxseSxcbiIKICJwbGVhc2UgdXNlIGdpdCBicmFuY2ggLS1zZXQtdXBzdHJlYW0tdG8gdG8gdHJhY2sgYSByZW1vdGUgYnJhbmNoLlxuIgpAQCAtMTQyODcsMjY3ICsxNDM3NCwyNjcgQEAKICJnaXQgYnJhbmNoIC0tc2V0LXVwc3RyZWFtLXRvIOadpei3n+i4quS4gOS4qui/nOeoi+WIhuaUr+OAguaIluiAheS9oOWPr+S7pemAmui/h1xuIgogIuWPguaVsCAtLWJhc2U9POWfuue6v+aPkOS6pD4g5omL5Yqo5oyH5a6a5LiA5Liq5Z+657q/5o+Q5LqkIgogCi0jOiBidWlsdGluL2xvZy5jOjEzOTQKKyM6IGJ1aWx0aW4vbG9nLmM6MTM5NQogbXNnaWQgImZhaWxlZCB0byBmaW5kIGV4YWN0IG1lcmdlIGJhc2UiCiBtc2dzdHIgIuaXoOazleaJvuWIsOWHhuehrueahOWQiOW5tuWfuue6vyIKIAotIzogYnVpbHRpbi9sb2cuYzoxNDA1CisjOiBidWlsdGluL2xvZy5jOjE0MDYKIG1zZ2lkICJiYXNlIGNvbW1pdCBzaG91bGQgYmUgdGhlIGFuY2VzdG9yIG9mIHJldmlzaW9uIGxpc3QiCiBtc2dzdHIgIuWfuue6v+aPkOS6pOW6lOivpeaYr+eJiOacrOWIl+ihqOeahOelluWFiCIKIAotIzogYnVpbHRpbi9sb2cuYzoxNDA5CisjOiBidWlsdGluL2xvZy5jOjE0MTAKIG1zZ2lkICJiYXNlIGNvbW1pdCBzaG91bGRuJ3QgYmUgaW4gcmV2aXNpb24gbGlzdCIKIG1zZ3N0ciAi5Z+657q/5o+Q5Lqk5LiN5bqU6K+l5Ye6546w5Zyo54mI5pys5YiX6KGo5LitIgogCi0jOiBidWlsdGluL2xvZy5jOjE0NjIKKyM6IGJ1aWx0aW4vbG9nLmM6MTQ2MwogbXNnaWQgImNhbm5vdCBnZXQgcGF0Y2ggaWQiCiBtc2dzdHIgIuaXoOazleW+l+WIsOihpeS4gSBpZCIKIAotIzogYnVpbHRpbi9sb2cuYzoxNTE0CisjOiBidWlsdGluL2xvZy5jOjE1MTUKIG1zZ2lkICJmYWlsZWQgdG8gaW5mZXIgcmFuZ2UtZGlmZiByYW5nZXMiCiBtc2dzdHIgIuaXoOazleaOqOaWrSByYW5nZS1kaWZmIOiMg+WbtCIKIAotIzogYnVpbHRpbi9sb2cuYzoxNTU5CisjOiBidWlsdGluL2xvZy5jOjE1NjAKIG1zZ2lkICJ1c2UgW1BBVENIIG4vbV0gZXZlbiB3aXRoIGEgc2luZ2xlIHBhdGNoIgogbXNnc3RyICLkvb/nlKggW1BBVENIIG4vbV3vvIzljbPkvb/lj6rmnInkuIDkuKrooaXkuIEiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTU2MgorIzogYnVpbHRpbi9sb2cuYzoxNTYzCiBtc2dpZCAidXNlIFtQQVRDSF0gZXZlbiB3aXRoIG11bHRpcGxlIHBhdGNoZXMiCiBtc2dzdHIgIuS9v+eUqCBbUEFUQ0hd77yM5Y2z5L2/5pyJ5aSa5Liq6KGl5LiBIgogCi0jOiBidWlsdGluL2xvZy5jOjE1NjYKKyM6IGJ1aWx0aW4vbG9nLmM6MTU2NwogbXNnaWQgInByaW50IHBhdGNoZXMgdG8gc3RhbmRhcmQgb3V0IgogbXNnc3RyICLmiZPljbDooaXkuIHliLDmoIflh4bovpPlh7oiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTU2OAorIzogYnVpbHRpbi9sb2cuYzoxNTY5CiBtc2dpZCAiZ2VuZXJhdGUgYSBjb3ZlciBsZXR0ZXIiCiBtc2dzdHIgIueUn+aIkOS4gOWwgemZhOWHvSIKIAotIzogYnVpbHRpbi9sb2cuYzoxNTcwCisjOiBidWlsdGluL2xvZy5jOjE1NzEKIG1zZ2lkICJ1c2Ugc2ltcGxlIG51bWJlciBzZXF1ZW5jZSBmb3Igb3V0cHV0IGZpbGUgbmFtZXMiCiBtc2dzdHIgIuS9v+eUqOeugOWNleeahOaVsOWtl+W6j+WIl+S9nOS4uui+k+WHuuaWh+S7tuWQjSIKIAotIzogYnVpbHRpbi9sb2cuYzoxNTcxCisjOiBidWlsdGluL2xvZy5jOjE1NzIKIG1zZ2lkICJzZngiCiBtc2dzdHIgIuWQjue8gCIKIAotIzogYnVpbHRpbi9sb2cuYzoxNTcyCisjOiBidWlsdGluL2xvZy5jOjE1NzMKIG1zZ2lkICJ1c2UgPHNmeD4gaW5zdGVhZCBvZiAnLnBhdGNoJyIKIG1zZ3N0ciAi5L2/55SoIDzlkI7nvIA+IOS7o+abvyAnLnBhdGNoJyIKIAotIzogYnVpbHRpbi9sb2cuYzoxNTc0CisjOiBidWlsdGluL2xvZy5jOjE1NzUKIG1zZ2lkICJzdGFydCBudW1iZXJpbmcgcGF0Y2hlcyBhdCA8bj4gaW5zdGVhZCBvZiAxIgogbXNnc3RyICLooaXkuIHku6UgPG4+IOW8gOWni+e8luWPt++8jOiAjOS4jeaYrzEiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTU3NgorIzogYnVpbHRpbi9sb2cuYzoxNTc3CiBtc2dpZCAibWFyayB0aGUgc2VyaWVzIGFzIE50aCByZS1yb2xsIgogbXNnc3RyICLmoIforrDooaXkuIHns7vliJfmmK/nrKzlh6DmrKHph43liLYiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTU3OAorIzogYnVpbHRpbi9sb2cuYzoxNTc5CiBtc2dpZCAiVXNlIFtSRkMgUEFUQ0hdIGluc3RlYWQgb2YgW1BBVENIXSIKIG1zZ3N0ciAi5L2/55SoIFtSRkMgUEFUQ0hdIOS7o+abvyBbUEFUQ0hdIgogCi0jOiBidWlsdGluL2xvZy5jOjE1ODEKKyM6IGJ1aWx0aW4vbG9nLmM6MTU4MgogbXNnaWQgIlVzZSBbPHByZWZpeD5dIGluc3RlYWQgb2YgW1BBVENIXSIKIG1zZ3N0ciAi5L2/55SoIFs85YmN57yAPl0g5Luj5pu/IFtQQVRDSF0iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTU4NAorIzogYnVpbHRpbi9sb2cuYzoxNTg1CiBtc2dpZCAic3RvcmUgcmVzdWx0aW5nIGZpbGVzIGluIDxkaXI+IgogbXNnc3RyICLmiornu5Pmnpzmlofku7blrZjlgqjlnKggPOebruW9lT4iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTU4NworIzogYnVpbHRpbi9sb2cuYzoxNTg4CiBtc2dpZCAiZG9uJ3Qgc3RyaXAvYWRkIFtQQVRDSF0iCiBtc2dzdHIgIuS4jeWIoOmZpC/mt7vliqAgW1BBVENIXSIKIAotIzogYnVpbHRpbi9sb2cuYzoxNTkwCisjOiBidWlsdGluL2xvZy5jOjE1OTEKIG1zZ2lkICJkb24ndCBvdXRwdXQgYmluYXJ5IGRpZmZzIgogbXNnc3RyICLkuI3ovpPlh7rkuozov5vliLblt67lvIIiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTU5MgorIzogYnVpbHRpbi9sb2cuYzoxNTkzCiBtc2dpZCAib3V0cHV0IGFsbC16ZXJvIGhhc2ggaW4gRnJvbSBoZWFkZXIiCiBtc2dzdHIgIuWcqCBGcm9tIOWktOS/oeaBr+S4rei+k+WHuuWFqOS4uumbtueahOWTiOW4jOWAvCIKIAotIzogYnVpbHRpbi9sb2cuYzoxNTk0CisjOiBidWlsdGluL2xvZy5jOjE1OTUKIG1zZ2lkICJkb24ndCBpbmNsdWRlIGEgcGF0Y2ggbWF0Y2hpbmcgYSBjb21taXQgdXBzdHJlYW0iCiBtc2dzdHIgIuS4jeWMheWQq+W3suWcqOS4iua4uOaPkOS6pOS4reeahOihpeS4gSIKIAotIzogYnVpbHRpbi9sb2cuYzoxNTk2CisjOiBidWlsdGluL2xvZy5jOjE1OTcKIG1zZ2lkICJzaG93IHBhdGNoIGZvcm1hdCBpbnN0ZWFkIG9mIGRlZmF1bHQgKHBhdGNoICsgc3RhdCkiCiBtc2dzdHIgIuaYvuekuue6r+ihpeS4geagvOW8j+iAjOmdnum7mOiupOeahO+8iOihpeS4gSvnirbmgIHvvIkiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTU5OAorIzogYnVpbHRpbi9sb2cuYzoxNTk5CiBtc2dpZCAiTWVzc2FnaW5nIgogbXNnc3RyICLpgq7ku7blj5HpgIEiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTU5OQorIzogYnVpbHRpbi9sb2cuYzoxNjAwCiBtc2dpZCAiaGVhZGVyIgogbXNnc3RyICJoZWFkZXIiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTYwMAorIzogYnVpbHRpbi9sb2cuYzoxNjAxCiBtc2dpZCAiYWRkIGVtYWlsIGhlYWRlciIKIG1zZ3N0ciAi5re75Yqg6YKu5Lu25aS0IgogCi0jOiBidWlsdGluL2xvZy5jOjE2MDEgYnVpbHRpbi9sb2cuYzoxNjAzCisjOiBidWlsdGluL2xvZy5jOjE2MDIgYnVpbHRpbi9sb2cuYzoxNjA0CiBtc2dpZCAiZW1haWwiCiBtc2dzdHIgIumCruS7tuWcsOWdgCIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjAxCisjOiBidWlsdGluL2xvZy5jOjE2MDIKIG1zZ2lkICJhZGQgVG86IGhlYWRlciIKIG1zZ3N0ciAi5re75Yqg5pS25Lu25Lq6IgogCi0jOiBidWlsdGluL2xvZy5jOjE2MDMKKyM6IGJ1aWx0aW4vbG9nLmM6MTYwNAogbXNnaWQgImFkZCBDYzogaGVhZGVyIgogbXNnc3RyICLmt7vliqDmioTpgIEiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTYwNQorIzogYnVpbHRpbi9sb2cuYzoxNjA2CiBtc2dpZCAiaWRlbnQiCiBtc2dzdHIgIuagh+ivhiIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjA2CisjOiBidWlsdGluL2xvZy5jOjE2MDcKIG1zZ2lkICJzZXQgRnJvbSBhZGRyZXNzIHRvIDxpZGVudD4gKG9yIGNvbW1pdHRlciBpZGVudCBpZiBhYnNlbnQpIgogbXNnc3RyICLlsIYgRnJvbSDlnLDlnYDorr7nva7kuLogPOagh+ivhj7vvIjlpoLoi6XkuI3mj5DkvpvvvIzliJnnlKjmj5DkuqTogIUgSUQg5YGa5Li65Zyw5Z2A77yJIgogCi0jOiBidWlsdGluL2xvZy5jOjE2MDgKKyM6IGJ1aWx0aW4vbG9nLmM6MTYwOQogbXNnaWQgIm1lc3NhZ2UtaWQiCiBtc2dzdHIgIumCruS7tuagh+ivhiIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjA5CisjOiBidWlsdGluL2xvZy5jOjE2MTAKIG1zZ2lkICJtYWtlIGZpcnN0IG1haWwgYSByZXBseSB0byA8bWVzc2FnZS1pZD4iCiBtc2dzdHIgIuS9v+esrOS4gOWwgemCruS7tuS9nOS4uuWvuSA86YKu5Lu25qCH6K+GPiDnmoTlm57lpI0iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTYxMCBidWlsdGluL2xvZy5jOjE2MTMKKyM6IGJ1aWx0aW4vbG9nLmM6MTYxMSBidWlsdGluL2xvZy5jOjE2MTQKIG1zZ2lkICJib3VuZGFyeSIKIG1zZ3N0ciAi6L6555WMIgogCi0jOiBidWlsdGluL2xvZy5jOjE2MTEKKyM6IGJ1aWx0aW4vbG9nLmM6MTYxMgogbXNnaWQgImF0dGFjaCB0aGUgcGF0Y2giCiBtc2dzdHIgIumZhOS7tuaWueW8j+a3u+WKoOihpeS4gSIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjE0CisjOiBidWlsdGluL2xvZy5jOjE2MTUKIG1zZ2lkICJpbmxpbmUgdGhlIHBhdGNoIgogbXNnc3RyICLlhoXogZTmmL7npLrooaXkuIEiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTYxOAorIzogYnVpbHRpbi9sb2cuYzoxNjE5CiBtc2dpZCAiZW5hYmxlIG1lc3NhZ2UgdGhyZWFkaW5nLCBzdHlsZXM6IHNoYWxsb3csIGRlZXAiCiBtc2dzdHIgIuWQr+eUqOmCruS7tue6v+e0ou+8jOmjjuagvO+8mua1he+8jOa3sSIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjIwCisjOiBidWlsdGluL2xvZy5jOjE2MjEKIG1zZ2lkICJzaWduYXR1cmUiCiBtc2dzdHIgIuetvuWQjSIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjIxCisjOiBidWlsdGluL2xvZy5jOjE2MjIKIG1zZ2lkICJhZGQgYSBzaWduYXR1cmUiCiBtc2dzdHIgIua3u+WKoOS4gOS4quetvuWQjSIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjIyCisjOiBidWlsdGluL2xvZy5jOjE2MjMKIG1zZ2lkICJiYXNlLWNvbW1pdCIKIG1zZ3N0ciAi5Z+657q/5o+Q5LqkIgogCi0jOiBidWlsdGluL2xvZy5jOjE2MjMKKyM6IGJ1aWx0aW4vbG9nLmM6MTYyNAogbXNnaWQgImFkZCBwcmVyZXF1aXNpdGUgdHJlZSBpbmZvIHRvIHRoZSBwYXRjaCBzZXJpZXMiCiBtc2dzdHIgIuS4uuihpeS4geWIl+ihqOa3u+WKoOWJjee9ruagkeS/oeaBryIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjI1CisjOiBidWlsdGluL2xvZy5jOjE2MjYKIG1zZ2lkICJhZGQgYSBzaWduYXR1cmUgZnJvbSBhIGZpbGUiCiBtc2dzdHIgIuS7juaWh+S7tua3u+WKoOS4gOS4quetvuWQjSIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjI2CisjOiBidWlsdGluL2xvZy5jOjE2MjcKIG1zZ2lkICJkb24ndCBwcmludCB0aGUgcGF0Y2ggZmlsZW5hbWVzIgogbXNnc3RyICLkuI3opoHmiZPljbDooaXkuIHmlofku7blkI0iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTYyOAorIzogYnVpbHRpbi9sb2cuYzoxNjI5CiBtc2dpZCAic2hvdyBwcm9ncmVzcyB3aGlsZSBnZW5lcmF0aW5nIHBhdGNoZXMiCiBtc2dzdHIgIuWcqOeUn+aIkOihpeS4geaXtuaYvuekuui/m+W6piIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjMwCisjOiBidWlsdGluL2xvZy5jOjE2MzEKIG1zZ2lkICJzaG93IGNoYW5nZXMgYWdhaW5zdCA8cmV2PiBpbiBjb3ZlciBsZXR0ZXIgb3Igc2luZ2xlIHBhdGNoIgogbXNnc3RyICLlnKjpmYTlh73miJbljZXkuKrooaXkuIHkuK3mmL7npLrlkowgPHJldj4g55qE5beu5byCIgogCi0jOiBidWlsdGluL2xvZy5jOjE2MzMKKyM6IGJ1aWx0aW4vbG9nLmM6MTYzNAogbXNnaWQgInNob3cgY2hhbmdlcyBhZ2FpbnN0IDxyZWZzcGVjPiBpbiBjb3ZlciBsZXR0ZXIgb3Igc2luZ2xlIHBhdGNoIgogbXNnc3RyICLlnKjpmYTlh73miJbljZXkuKrooaXkuIHkuK3mmL7npLrlkowgPHJlZnNwZWM+IOeahOW3ruW8giIKIAotIzogYnVpbHRpbi9sb2cuYzoxNjM1CisjOiBidWlsdGluL2xvZy5jOjE2MzYKIG1zZ2lkICJwZXJjZW50YWdlIGJ5IHdoaWNoIGNyZWF0aW9uIGlzIHdlaWdodGVkIgogbXNnc3RyICLliJvlu7rmnYPph43nmoTnmb7liIbmr5QiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTcxMAorIzogYnVpbHRpbi9sb2cuYzoxNzExCiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgaWRlbnQgbGluZTogJXMiCiBtc2dzdHIgIuWMheWQq+aXoOaViOeahOi6q+S7veagh+ivhu+8miVzIgogCi0jOiBidWlsdGluL2xvZy5jOjE3MjUKKyM6IGJ1aWx0aW4vbG9nLmM6MTcyNgogbXNnaWQgIi1uIGFuZCAtayBhcmUgbXV0dWFsbHkgZXhjbHVzaXZlIgogbXNnc3RyICItbiDlkowgLWsg5LqS5palIgogCi0jOiBidWlsdGluL2xvZy5jOjE3MjcKKyM6IGJ1aWx0aW4vbG9nLmM6MTcyOAogbXNnaWQgIi0tc3ViamVjdC1wcmVmaXgvLS1yZmMgYW5kIC1rIGFyZSBtdXR1YWxseSBleGNsdXNpdmUiCiBtc2dzdHIgIi0tc3ViamVjdC1wcmVmaXgvLS1yZmMg5ZKMIC1rIOS6kuaWpSIKIAotIzogYnVpbHRpbi9sb2cuYzoxNzM1CisjOiBidWlsdGluL2xvZy5jOjE3MzYKIG1zZ2lkICItLW5hbWUtb25seSBkb2VzIG5vdCBtYWtlIHNlbnNlIgogbXNnc3RyICItLW5hbWUtb25seSDml6DmhI/kuYkiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTczNworIzogYnVpbHRpbi9sb2cuYzoxNzM4CiBtc2dpZCAiLS1uYW1lLXN0YXR1cyBkb2VzIG5vdCBtYWtlIHNlbnNlIgogbXNnc3RyICItLW5hbWUtc3RhdHVzIOaXoOaEj+S5iSIKIAotIzogYnVpbHRpbi9sb2cuYzoxNzM5CisjOiBidWlsdGluL2xvZy5jOjE3NDAKIG1zZ2lkICItLWNoZWNrIGRvZXMgbm90IG1ha2Ugc2Vuc2UiCiBtc2dzdHIgIi0tY2hlY2sg5peg5oSP5LmJIgogCi0jOiBidWlsdGluL2xvZy5jOjE3NzEKKyM6IGJ1aWx0aW4vbG9nLmM6MTc3MwogbXNnaWQgInN0YW5kYXJkIG91dHB1dCwgb3IgZGlyZWN0b3J5LCB3aGljaCBvbmU/IgogbXNnc3RyICLmoIflh4bovpPlh7rmiJbnm67lvZXvvIzlk6rkuIDkuKrvvJ8iCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTg2MAorIzogYnVpbHRpbi9sb2cuYzoxODc3CiBtc2dpZCAiLS1pbnRlcmRpZmYgcmVxdWlyZXMgLS1jb3Zlci1sZXR0ZXIgb3Igc2luZ2xlIHBhdGNoIgogbXNnc3RyICItLWludGVyZGlmZiDpnIDopoEgLS1jb3Zlci1sZXR0ZXIg5oiW5Y2V5LiA6KGl5LiBIgogCi0jOiBidWlsdGluL2xvZy5jOjE4NjQKKyM6IGJ1aWx0aW4vbG9nLmM6MTg4MQogbXNnaWQgIkludGVyZGlmZjoiCiBtc2dzdHIgIueJiOacrOmXtOW3ruW8gu+8miIKIAotIzogYnVpbHRpbi9sb2cuYzoxODY1CisjOiBidWlsdGluL2xvZy5jOjE4ODIKICMsIGMtZm9ybWF0CiBtc2dpZCAiSW50ZXJkaWZmIGFnYWluc3QgdiVkOiIKIG1zZ3N0ciAi5a+5IHYlZCDnmoTniYjmnKzlt67lvILvvJoiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTg3MQorIzogYnVpbHRpbi9sb2cuYzoxODg4CiBtc2dpZCAiLS1jcmVhdGlvbi1mYWN0b3IgcmVxdWlyZXMgLS1yYW5nZS1kaWZmIgogbXNnc3RyICItLWNyZWF0aW9uLWZhY3RvciDpnIDopoEgLS1yYW5nZS1kaWZmIgogCi0jOiBidWlsdGluL2xvZy5jOjE4NzUKKyM6IGJ1aWx0aW4vbG9nLmM6MTg5MgogbXNnaWQgIi0tcmFuZ2UtZGlmZiByZXF1aXJlcyAtLWNvdmVyLWxldHRlciBvciBzaW5nbGUgcGF0Y2giCiBtc2dzdHIgIi0tcmFuZ2UtZGlmZiDpnIDopoEgLS1jb3Zlci1sZXR0ZXIg5oiW5Y2V5LiA6KGl5LiBIgogCi0jOiBidWlsdGluL2xvZy5jOjE4ODMKKyM6IGJ1aWx0aW4vbG9nLmM6MTkwMAogbXNnaWQgIlJhbmdlLWRpZmY6IgogbXNnc3RyICLojIPlm7Tlt67lvILvvJoiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTg4NAorIzogYnVpbHRpbi9sb2cuYzoxOTAxCiAjLCBjLWZvcm1hdAogbXNnaWQgIlJhbmdlLWRpZmYgYWdhaW5zdCB2JWQ6IgogbXNnc3RyICLlr7kgdiVkIOeahOiMg+WbtOW3ruW8gu+8miIKIAotIzogYnVpbHRpbi9sb2cuYzoxODk1CisjOiBidWlsdGluL2xvZy5jOjE5MTIKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHJlYWQgc2lnbmF0dXJlIGZpbGUgJyVzJyIKIG1zZ3N0ciAi5peg5rOV6K+75Y+W562+5ZCN5paH5Lu2ICclcyciCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTkzMQorIzogYnVpbHRpbi9sb2cuYzoxOTQ4CiBtc2dpZCAiR2VuZXJhdGluZyBwYXRjaGVzIgogbXNnc3RyICLnlJ/miJDooaXkuIEiCiAKLSM6IGJ1aWx0aW4vbG9nLmM6MTk3NQorIzogYnVpbHRpbi9sb2cuYzoxOTkyCiBtc2dpZCAiZmFpbGVkIHRvIGNyZWF0ZSBvdXRwdXQgZmlsZXMiCiBtc2dzdHIgIuaXoOazleWIm+W7uui+k+WHuuaWh+S7tiIKIAotIzogYnVpbHRpbi9sb2cuYzoyMDM0CisjOiBidWlsdGluL2xvZy5jOjIwNTEKIG1zZ2lkICJnaXQgY2hlcnJ5IFstdl0gWzx1cHN0cmVhbT4gWzxoZWFkPiBbPGxpbWl0Pl1dXSIKIG1zZ3N0ciAiZ2l0IGNoZXJyeSBbLXZdIFs85LiK5ri4PiBbPOWktD4gWzzpmZDliLY+XV1dIgogCi0jOiBidWlsdGluL2xvZy5jOjIwODgKKyM6IGJ1aWx0aW4vbG9nLmM6MjEwNQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiQ291bGQgbm90IGZpbmQgYSB0cmFja2VkIHJlbW90ZSBicmFuY2gsIHBsZWFzZSBzcGVjaWZ5IDx1cHN0cmVhbT4gbWFudWFsbHkuXG4iCkBAIC0xNDY3MSw3ICsxNDc1OCw3IEBACiBtc2dpZCAiZG8gbm90IHByaW50IHJlbW90ZSBVUkwiCiBtc2dzdHIgIuS4jeaJk+WNsOi/nOeoiyBVUkwiCiAKLSM6IGJ1aWx0aW4vbHMtcmVtb3RlLmM6NjAgYnVpbHRpbi9scy1yZW1vdGUuYzo2MiBidWlsdGluL3JlYmFzZS5jOjE0NjQKKyM6IGJ1aWx0aW4vbHMtcmVtb3RlLmM6NjAgYnVpbHRpbi9scy1yZW1vdGUuYzo2MiBidWlsdGluL3JlYmFzZS5jOjE0ODgKIG1zZ2lkICJleGVjIgogbXNnc3RyICJleGVjIgogCkBAIC0xNDc4MCwzMSArMTQ4NjcsMzEgQEAKIG1zZ2lkICJBdmFpbGFibGUgY3VzdG9tIHN0cmF0ZWdpZXMgYXJlOiIKIG1zZ3N0ciAi5Y+v55So55qE6Ieq5a6a5LmJ562W55Wl5pyJ77yaIgogCi0jOiBidWlsdGluL21lcmdlLmM6MjQ0IGJ1aWx0aW4vcHVsbC5jOjE1MQorIzogYnVpbHRpbi9tZXJnZS5jOjI0NCBidWlsdGluL3B1bGwuYzoxNTIKIG1zZ2lkICJkbyBub3Qgc2hvdyBhIGRpZmZzdGF0IGF0IHRoZSBlbmQgb2YgdGhlIG1lcmdlIgogbXNnc3RyICLlnKjlkIjlubbnmoTmnIDlkI7kuI3mmL7npLrlt67lvILnu5/orqEiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoyNDcgYnVpbHRpbi9wdWxsLmM6MTU0CisjOiBidWlsdGluL21lcmdlLmM6MjQ3IGJ1aWx0aW4vcHVsbC5jOjE1NQogbXNnaWQgInNob3cgYSBkaWZmc3RhdCBhdCB0aGUgZW5kIG9mIHRoZSBtZXJnZSIKIG1zZ3N0ciAi5Zyo5ZCI5bm255qE5pyA5ZCO5pi+56S65beu5byC57uf6K6hIgogCi0jOiBidWlsdGluL21lcmdlLmM6MjQ4IGJ1aWx0aW4vcHVsbC5jOjE1NworIzogYnVpbHRpbi9tZXJnZS5jOjI0OCBidWlsdGluL3B1bGwuYzoxNTgKIG1zZ2lkICIoc3lub255bSB0byAtLXN0YXQpIgogbXNnc3RyICLvvIjlkowgLS1zdGF0IOWQjOS5ie+8iSIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjI1MCBidWlsdGluL3B1bGwuYzoxNjAKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoyNTAgYnVpbHRpbi9wdWxsLmM6MTYxCiBtc2dpZCAiYWRkIChhdCBtb3N0IDxuPikgZW50cmllcyBmcm9tIHNob3J0bG9nIHRvIG1lcmdlIGNvbW1pdCBtZXNzYWdlIgogbXNnc3RyICLlnKjlkIjlubbmj5DkuqTkv6Hmga/kuK3mt7vliqDvvIjmnIDlpJogPG4+IOadoe+8ieeyvueugOaPkOS6pOiusOW9lSIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjI1MyBidWlsdGluL3B1bGwuYzoxNjYKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoyNTMgYnVpbHRpbi9wdWxsLmM6MTY3CiBtc2dpZCAiY3JlYXRlIGEgc2luZ2xlIGNvbW1pdCBpbnN0ZWFkIG9mIGRvaW5nIGEgbWVyZ2UiCiBtc2dzdHIgIuWIm+W7uuS4gOS4quWNleeLrOeahOaPkOS6pOiAjOS4jeaYr+WBmuS4gOasoeWQiOW5tiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjI1NSBidWlsdGluL3B1bGwuYzoxNjkKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoyNTUgYnVpbHRpbi9wdWxsLmM6MTcwCiBtc2dpZCAicGVyZm9ybSBhIGNvbW1pdCBpZiB0aGUgbWVyZ2Ugc3VjY2VlZHMgKGRlZmF1bHQpIgogbXNnc3RyICLlpoLmnpzlkIjlubbmiJDlip/vvIzmiafooYzkuIDmrKHmj5DkuqTvvIjpu5jorqTvvIkiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoyNTcgYnVpbHRpbi9wdWxsLmM6MTcyCisjOiBidWlsdGluL21lcmdlLmM6MjU3IGJ1aWx0aW4vcHVsbC5jOjE3MwogbXNnaWQgImVkaXQgbWVzc2FnZSBiZWZvcmUgY29tbWl0dGluZyIKIG1zZ3N0ciAi5Zyo5o+Q5Lqk5YmN57yW6L6R5o+Q5Lqk6K+05piOIgogCkBAIC0xNDgxMiwyOCArMTQ4OTksMjggQEAKIG1zZ2lkICJhbGxvdyBmYXN0LWZvcndhcmQgKGRlZmF1bHQpIgogbXNnc3RyICLlhYHorrjlv6vov5vvvIjpu5jorqTvvIkiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoyNjEgYnVpbHRpbi9wdWxsLmM6MTc5CisjOiBidWlsdGluL21lcmdlLmM6MjYxIGJ1aWx0aW4vcHVsbC5jOjE4MAogbXNnaWQgImFib3J0IGlmIGZhc3QtZm9yd2FyZCBpcyBub3QgcG9zc2libGUiCiBtc2dzdHIgIuWmguaenOS4jeiDveW/q+i/m+WwseaUvuW8g+WQiOW5tiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjI2NSBidWlsdGluL3B1bGwuYzoxODIKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoyNjUgYnVpbHRpbi9wdWxsLmM6MTgzCiBtc2dpZCAidmVyaWZ5IHRoYXQgdGhlIG5hbWVkIGNvbW1pdCBoYXMgYSB2YWxpZCBHUEcgc2lnbmF0dXJlIgogbXNnc3RyICLpqozor4HmjIflrprnmoTmj5DkuqTmmK/lkKbljIXlkKvkuIDkuKrmnInmlYjnmoQgR1BHIOetvuWQjSIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjI2NiBidWlsdGluL25vdGVzLmM6Nzg3IGJ1aWx0aW4vcHVsbC5jOjE4NgotIzogYnVpbHRpbi9yZWJhc2UuYzo0OTIgYnVpbHRpbi9yZWJhc2UuYzoxNDc3IGJ1aWx0aW4vcmV2ZXJ0LmM6MTE0CisjOiBidWlsdGluL21lcmdlLmM6MjY2IGJ1aWx0aW4vbm90ZXMuYzo3ODcgYnVpbHRpbi9wdWxsLmM6MTg3CisjOiBidWlsdGluL3JlYmFzZS5jOjQ5MyBidWlsdGluL3JlYmFzZS5jOjE1MDEgYnVpbHRpbi9yZXZlcnQuYzoxMTQKIG1zZ2lkICJzdHJhdGVneSIKIG1zZ3N0ciAi562W55WlIgogCi0jOiBidWlsdGluL21lcmdlLmM6MjY3IGJ1aWx0aW4vcHVsbC5jOjE4NworIzogYnVpbHRpbi9tZXJnZS5jOjI2NyBidWlsdGluL3B1bGwuYzoxODgKIG1zZ2lkICJtZXJnZSBzdHJhdGVneSB0byB1c2UiCiBtc2dzdHIgIuimgeS9v+eUqOeahOWQiOW5tuetlueVpSIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjI2OCBidWlsdGluL3B1bGwuYzoxOTAKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoyNjggYnVpbHRpbi9wdWxsLmM6MTkxCiBtc2dpZCAib3B0aW9uPXZhbHVlIgogbXNnc3RyICJvcHRpb249dmFsdWUiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoyNjkgYnVpbHRpbi9wdWxsLmM6MTkxCisjOiBidWlsdGluL21lcmdlLmM6MjY5IGJ1aWx0aW4vcHVsbC5jOjE5MgogbXNnaWQgIm9wdGlvbiBmb3Igc2VsZWN0ZWQgbWVyZ2Ugc3RyYXRlZ3kiCiBtc2dzdHIgIuaJgOmAieeahOWQiOW5tuetlueVpeeahOmAiemhuSIKIApAQCAtMTQ4NTQsMTMgKzE0OTQxLDEzIEBACiBtc2dpZCAiY29udGludWUgdGhlIGN1cnJlbnQgaW4tcHJvZ3Jlc3MgbWVyZ2UiCiBtc2dzdHIgIue7p+e7reW9k+WJjeato+WcqOi/m+ihjOeahOWQiOW5tiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjI4NCBidWlsdGluL3B1bGwuYzoxOTgKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoyODQgYnVpbHRpbi9wdWxsLmM6MTk5CiBtc2dpZCAiYWxsb3cgbWVyZ2luZyB1bnJlbGF0ZWQgaGlzdG9yaWVzIgogbXNnc3RyICLlhYHorrjlkIjlubbkuI3nm7jlhbPnmoTljoblj7IiCiAKICM6IGJ1aWx0aW4vbWVyZ2UuYzoyOTAKLW1zZ2lkICJ2ZXJpZnkgY29tbWl0LW1zZyBob29rIgotbXNnc3RyICLmoKHpqowgY29tbWl0LW1zZyDpkqnlrZAiCittc2dpZCAiYnlwYXNzIHByZS1tZXJnZS1jb21taXQgYW5kIGNvbW1pdC1tc2cgaG9va3MiCittc2dzdHIgIue7lei/hyBwcmUtbWVyZ2UtY29tbWl0IOWSjCBjb21taXQtbXNnIOmSqeWtkCIKIAogIzogYnVpbHRpbi9tZXJnZS5jOjMwNwogbXNnaWQgImNvdWxkIG5vdCBydW4gc3Rhc2guIgpAQCAtMTQ5MDQsMzEgKzE0OTkxLDMxIEBACiBtc2dpZCAiQmFkIGJyYW5jaC4lcy5tZXJnZW9wdGlvbnMgc3RyaW5nOiAlcyIKIG1zZ3N0ciAi5Z2P55qEIGJyYW5jaC4lcy5tZXJnZW9wdGlvbnMg5a2X56ym5Liy77yaJXMiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzo3MDgKKyM6IGJ1aWx0aW4vbWVyZ2UuYzo3MDUKIG1zZ2lkICJOb3QgaGFuZGxpbmcgYW55dGhpbmcgb3RoZXIgdGhhbiB0d28gaGVhZHMgbWVyZ2UuIgogbXNnc3RyICLmnKrlpITnkIbkuKTkuKrlpLTlkIjlubbkuYvlpJbnmoTku7vkvZXmk43kvZzjgIIiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzo3MjIKKyM6IGJ1aWx0aW4vbWVyZ2UuYzo3MTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiVW5rbm93biBvcHRpb24gZm9yIG1lcmdlLXJlY3Vyc2l2ZTogLVglcyIKIG1zZ3N0ciAibWVyZ2UtcmVjdXJzaXZlIOeahOacquefpemAiemhue+8mi1YJXMiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzo3MzcKKyM6IGJ1aWx0aW4vbWVyZ2UuYzo3MzQKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIHdyaXRlICVzIgogbXNnc3RyICLkuI3og73lhpkgJXMiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzo3ODkKKyM6IGJ1aWx0aW4vbWVyZ2UuYzo3ODYKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ291bGQgbm90IHJlYWQgZnJvbSAnJXMnIgogbXNnc3RyICLkuI3og73ku44gJyVzJyDor7vlj5YiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzo3OTgKKyM6IGJ1aWx0aW4vbWVyZ2UuYzo3OTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiTm90IGNvbW1pdHRpbmcgbWVyZ2U7IHVzZSAnZ2l0IGNvbW1pdCcgdG8gY29tcGxldGUgdGhlIG1lcmdlLlxuIgogbXNnc3RyICLmnKrmj5DkuqTlkIjlubbvvIzkvb/nlKggJ2dpdCBjb21taXQnIOWujOaIkOatpOasoeWQiOW5tuOAglxuIgogCi0jOiBidWlsdGluL21lcmdlLmM6ODA0CisjOiBidWlsdGluL21lcmdlLmM6ODAxCiBtc2dpZCAiIgogIlBsZWFzZSBlbnRlciBhIGNvbW1pdCBtZXNzYWdlIHRvIGV4cGxhaW4gd2h5IHRoaXMgbWVyZ2UgaXMgbmVjZXNzYXJ5LFxuIgogImVzcGVjaWFsbHkgaWYgaXQgbWVyZ2VzIGFuIHVwZGF0ZWQgdXBzdHJlYW0gaW50byBhIHRvcGljIGJyYW5jaC5cbiIKQEAgLTE0OTM4LDgzICsxNTAyNSw4MyBAQAogIuWQiOW5tuWIsOS4u+mimOWIhuaUr+OAglxuIgogIlxuIgogCi0jOiBidWlsdGluL21lcmdlLmM6ODA5CisjOiBidWlsdGluL21lcmdlLmM6ODA2CiBtc2dpZCAiQW4gZW1wdHkgbWVzc2FnZSBhYm9ydHMgdGhlIGNvbW1pdC5cbiIKIG1zZ3N0ciAi56m655qE5o+Q5Lqk6K+05piO5Lya57uI5q2i5o+Q5Lqk44CCXG4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzo4MTIKKyM6IGJ1aWx0aW4vbWVyZ2UuYzo4MDkKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIkxpbmVzIHN0YXJ0aW5nIHdpdGggJyVjJyB3aWxsIGJlIGlnbm9yZWQsIGFuZCBhbiBlbXB0eSBtZXNzYWdlIGFib3J0c1xuIgogInRoZSBjb21taXQuXG4iCiBtc2dzdHIgIuS7pSAnJWMnIOW8gOWni+eahOihjOWwhuiiq+W/veeVpe+8jOiAjOepuueahOaPkOS6pOivtOaYjuWwhue7iOatouaPkOS6pOOAglxuIgogCi0jOiBidWlsdGluL21lcmdlLmM6ODUzCisjOiBidWlsdGluL21lcmdlLmM6ODYyCiBtc2dpZCAiRW1wdHkgY29tbWl0IG1lc3NhZ2UuIgogbXNnc3RyICLnqbrmj5DkuqTkv6Hmga/jgIIiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzo4NzIKKyM6IGJ1aWx0aW4vbWVyZ2UuYzo4NzcKICMsIGMtZm9ybWF0CiBtc2dpZCAiV29uZGVyZnVsLlxuIgogbXNnc3RyICLlpKrmo5LkuobjgIJcbiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjkzMworIzogYnVpbHRpbi9tZXJnZS5jOjkzOAogIywgYy1mb3JtYXQKIG1zZ2lkICJBdXRvbWF0aWMgbWVyZ2UgZmFpbGVkOyBmaXggY29uZmxpY3RzIGFuZCB0aGVuIGNvbW1pdCB0aGUgcmVzdWx0LlxuIgogbXNnc3RyICLoh6rliqjlkIjlubblpLHotKXvvIzkv67mraPlhrLnqoHnhLblkI7mj5DkuqTkv67mraPnmoTnu5PmnpzjgIJcbiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjk3MgorIzogYnVpbHRpbi9tZXJnZS5jOjk3NwogbXNnaWQgIk5vIGN1cnJlbnQgYnJhbmNoLiIKIG1zZ3N0ciAi5rKh5pyJ5b2T5YmN5YiG5pSv44CCIgogCi0jOiBidWlsdGluL21lcmdlLmM6OTc0CisjOiBidWlsdGluL21lcmdlLmM6OTc5CiBtc2dpZCAiTm8gcmVtb3RlIGZvciB0aGUgY3VycmVudCBicmFuY2guIgogbXNnc3RyICLlvZPliY3liIbmlK/msqHmnInlr7nlupTnmoTov5znqIvku5PlupPjgIIiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzo5NzYKKyM6IGJ1aWx0aW4vbWVyZ2UuYzo5ODEKIG1zZ2lkICJObyBkZWZhdWx0IHVwc3RyZWFtIGRlZmluZWQgZm9yIHRoZSBjdXJyZW50IGJyYW5jaC4iCiBtc2dzdHIgIuW9k+WJjeWIhuaUr+ayoeacieWumuS5iem7mOiupOeahOS4iua4uOWIhuaUr+OAgiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjk4MQorIzogYnVpbHRpbi9tZXJnZS5jOjk4NgogIywgYy1mb3JtYXQKIG1zZ2lkICJObyByZW1vdGUtdHJhY2tpbmcgYnJhbmNoIGZvciAlcyBmcm9tICVzIgogbXNnc3RyICLlr7nkuo4gJXMg5rKh5pyJ5p2l6IeqICVzIOeahOi/nOeoi+i3n+i4quWIhuaUryIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjEwMzgKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxMDQzCiAjLCBjLWZvcm1hdAogbXNnaWQgIkJhZCB2YWx1ZSAnJXMnIGluIGVudmlyb25tZW50ICclcyciCiBtc2dzdHIgIueOr+WigyAnJTIkcycg5Lit5a2Y5Zyo5Z2P55qE5Y+W5YC8ICclMSRzJyIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjExNDEKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxMTQ2CiAjLCBjLWZvcm1hdAogbXNnaWQgIm5vdCBzb21ldGhpbmcgd2UgY2FuIG1lcmdlIGluICVzOiAlcyIKIG1zZ3N0ciAi5LiN6IO95ZyoICVzIOS4reWQiOW5tu+8miVzIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTE3NQorIzogYnVpbHRpbi9tZXJnZS5jOjExODAKIG1zZ2lkICJub3Qgc29tZXRoaW5nIHdlIGNhbiBtZXJnZSIKIG1zZ3N0ciAi5LiN6IO95ZCI5bm2IgogCi0jOiBidWlsdGluL21lcmdlLmM6MTI3OAorIzogYnVpbHRpbi9tZXJnZS5jOjEyODMKIG1zZ2lkICItLWFib3J0IGV4cGVjdHMgbm8gYXJndW1lbnRzIgogbXNnc3RyICItLWFib3J0IOS4jeW4puWPguaVsCIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjEyODIKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxMjg3CiBtc2dpZCAiVGhlcmUgaXMgbm8gbWVyZ2UgdG8gYWJvcnQgKE1FUkdFX0hFQUQgbWlzc2luZykuIgogbXNnc3RyICLmsqHmnInopoHnu4jmraLnmoTlkIjlubbvvIhNRVJHRV9IRUFEIOS4ouWkse+8ieOAgiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjEyOTEKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxMjk2CiBtc2dpZCAiLS1xdWl0IGV4cGVjdHMgbm8gYXJndW1lbnRzIgogbXNnc3RyICItLXF1aXQg5LiN5bim5Y+C5pWwIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTMwNAorIzogYnVpbHRpbi9tZXJnZS5jOjEzMDkKIG1zZ2lkICItLWNvbnRpbnVlIGV4cGVjdHMgbm8gYXJndW1lbnRzIgogbXNnc3RyICItLWNvbnRpbnVlIOS4jeW4puWPguaVsCIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjEzMDgKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzEzCiBtc2dpZCAiVGhlcmUgaXMgbm8gbWVyZ2UgaW4gcHJvZ3Jlc3MgKE1FUkdFX0hFQUQgbWlzc2luZykuIgogbXNnc3RyICLmsqHmnInov5vooYzkuK3nmoTlkIjlubbvvIhNRVJHRV9IRUFEIOS4ouWkse+8ieOAgiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjEzMjQKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzI5CiBtc2dpZCAiIgogIllvdSBoYXZlIG5vdCBjb25jbHVkZWQgeW91ciBtZXJnZSAoTUVSR0VfSEVBRCBleGlzdHMpLlxuIgogIlBsZWFzZSwgY29tbWl0IHlvdXIgY2hhbmdlcyBiZWZvcmUgeW91IG1lcmdlLiIKQEAgLTE1MDIyLDcgKzE1MTA5LDcgQEAKICLmgqjlsJrmnKrnu5PmnZ/mgqjnmoTlkIjlubbvvIjlrZjlnKggTUVSR0VfSEVBRO+8ieOAglxuIgogIuivt+WcqOWQiOW5tuWJjeWFiOaPkOS6pOaCqOeahOS/ruaUueOAgiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjEzMzEKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzM2CiBtc2dpZCAiIgogIllvdSBoYXZlIG5vdCBjb25jbHVkZWQgeW91ciBjaGVycnktcGljayAoQ0hFUlJZX1BJQ0tfSEVBRCBleGlzdHMpLlxuIgogIlBsZWFzZSwgY29tbWl0IHlvdXIgY2hhbmdlcyBiZWZvcmUgeW91IG1lcmdlLiIKQEAgLTE1MDMwLDk2ICsxNTExNyw5NiBAQAogIuaCqOWwmuacque7k+adn+aCqOeahOaLo+mAie+8iOWtmOWcqCBDSEVSUllfUElDS19IRUFE77yJ44CCXG4iCiAi6K+35Zyo5ZCI5bm25YmN5YWI5o+Q5Lqk5oKo55qE5L+u5pS544CCIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTMzNAorIzogYnVpbHRpbi9tZXJnZS5jOjEzMzkKIG1zZ2lkICJZb3UgaGF2ZSBub3QgY29uY2x1ZGVkIHlvdXIgY2hlcnJ5LXBpY2sgKENIRVJSWV9QSUNLX0hFQUQgZXhpc3RzKS4iCiBtc2dzdHIgIuaCqOWwmuacque7k+adn+aCqOeahOaLo+mAie+8iOWtmOWcqCBDSEVSUllfUElDS19IRUFE77yJ44CCIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTM0OAorIzogYnVpbHRpbi9tZXJnZS5jOjEzNTMKIG1zZ2lkICJZb3UgY2Fubm90IGNvbWJpbmUgLS1zcXVhc2ggd2l0aCAtLW5vLWZmLiIKIG1zZ3N0ciAi5oKo5LiN6IO95bCGIC0tc3F1YXNoIOWSjCAtLW5vLWZmIOe7hOWQiOS9v+eUqOOAgiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjEzNTAKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzU1CiBtc2dpZCAiWW91IGNhbm5vdCBjb21iaW5lIC0tc3F1YXNoIHdpdGggLS1jb21taXQuIgogbXNnc3RyICLmgqjkuI3og73lsIYgLS1zcXVhc2gg5ZKMIC0tY29tbWl0IOe7hOWQiOS9v+eUqOOAgiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjEzNjYKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzcxCiBtc2dpZCAiTm8gY29tbWl0IHNwZWNpZmllZCBhbmQgbWVyZ2UuZGVmYXVsdFRvVXBzdHJlYW0gbm90IHNldC4iCiBtc2dzdHIgIuacquaMh+WumuaPkOS6pOW5tuS4lCBtZXJnZS5kZWZhdWx0VG9VcHN0cmVhbSDmnKrorr7nva7jgIIiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzgzCisjOiBidWlsdGluL21lcmdlLmM6MTM4OAogbXNnaWQgIlNxdWFzaCBjb21taXQgaW50byBlbXB0eSBoZWFkIG5vdCBzdXBwb3J0ZWQgeWV0IgogbXNnc3RyICLlsJrkuI3mlK/mjIHliLDnqbrliIbmlK/nmoTljovnvKnmj5DkuqQiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzg1CisjOiBidWlsdGluL21lcmdlLmM6MTM5MAogbXNnaWQgIk5vbi1mYXN0LWZvcndhcmQgY29tbWl0IGRvZXMgbm90IG1ha2Ugc2Vuc2UgaW50byBhbiBlbXB0eSBoZWFkIgogbXNnc3RyICLliLDnqbrliIbmlK/nmoTpnZ7lv6vov5vlvI/mj5DkuqTmsqHmnInmhI/kuYkiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzkwCisjOiBidWlsdGluL21lcmdlLmM6MTM5NQogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyAtIG5vdCBzb21ldGhpbmcgd2UgY2FuIG1lcmdlIgogbXNnc3RyICIlcyAtIOS4jeiDveiiq+WQiOW5tiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjEzOTIKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxMzk3CiBtc2dpZCAiQ2FuIG1lcmdlIG9ubHkgZXhhY3RseSBvbmUgY29tbWl0IGludG8gZW1wdHkgaGVhZCIKIG1zZ3N0ciAi5Y+q6IO95bCG5LiA5Liq5o+Q5Lqk5ZCI5bm25Yiw56m65YiG5pSv5LiKIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTQ3MQorIzogYnVpbHRpbi9tZXJnZS5jOjE0NzYKIG1zZ2lkICJyZWZ1c2luZyB0byBtZXJnZSB1bnJlbGF0ZWQgaGlzdG9yaWVzIgogbXNnc3RyICLmi5Lnu53lkIjlubbml6DlhbPnmoTljoblj7IiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxNDgwCisjOiBidWlsdGluL21lcmdlLmM6MTQ4NQogbXNnaWQgIkFscmVhZHkgdXAgdG8gZGF0ZS4iCiBtc2dzdHIgIuW3sue7j+aYr+acgOaWsOeahOOAgiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjE0OTAKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxNDk1CiAjLCBjLWZvcm1hdAogbXNnaWQgIlVwZGF0aW5nICVzLi4lc1xuIgogbXNnc3RyICLmm7TmlrAgJXMuLiVzXG4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxNTMyCisjOiBidWlsdGluL21lcmdlLmM6MTUzNwogIywgYy1mb3JtYXQKIG1zZ2lkICJUcnlpbmcgcmVhbGx5IHRyaXZpYWwgaW4taW5kZXggbWVyZ2UuLi5cbiIKIG1zZ3N0ciAi5bCd6K+V6Z2e5bi45bCP55qE57Si5byV5YaF5ZCI5bm2Li4uXG4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxNTM5CisjOiBidWlsdGluL21lcmdlLmM6MTU0NAogIywgYy1mb3JtYXQKIG1zZ2lkICJOb3BlLlxuIgogbXNnc3RyICLml6DjgIJcbiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjE1NjQKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxNTY5CiBtc2dpZCAiQWxyZWFkeSB1cCB0byBkYXRlLiBZZWVhaCEiCiBtc2dzdHIgIuW3sue7j+aYr+acgOaWsOeahOOAguiAtu+8gSIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjE1NzAKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxNTc1CiBtc2dpZCAiTm90IHBvc3NpYmxlIHRvIGZhc3QtZm9yd2FyZCwgYWJvcnRpbmcuIgogbXNnc3RyICLml6Dms5Xlv6vov5vvvIznu4jmraLjgIIiCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxNTkzIGJ1aWx0aW4vbWVyZ2UuYzoxNjU4CisjOiBidWlsdGluL21lcmdlLmM6MTU5OCBidWlsdGluL21lcmdlLmM6MTY2MwogIywgYy1mb3JtYXQKIG1zZ2lkICJSZXdpbmRpbmcgdGhlIHRyZWUgdG8gcHJpc3RpbmUuLi5cbiIKIG1zZ3N0ciAi5bCG5qCR5Zue5rua6Iez5Y6f5aeL54q25oCBLi4uXG4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxNTk3CisjOiBidWlsdGluL21lcmdlLmM6MTYwMgogIywgYy1mb3JtYXQKIG1zZ2lkICJUcnlpbmcgbWVyZ2Ugc3RyYXRlZ3kgJXMuLi5cbiIKIG1zZ3N0ciAi5bCd6K+V5ZCI5bm2562W55WlICVzLi4uXG4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxNjQ5CisjOiBidWlsdGluL21lcmdlLmM6MTY1NAogIywgYy1mb3JtYXQKIG1zZ2lkICJObyBtZXJnZSBzdHJhdGVneSBoYW5kbGVkIHRoZSBtZXJnZS5cbiIKIG1zZ3N0ciAi5rKh5pyJ5ZCI5bm2562W55Wl5aSE55CG5q2k5ZCI5bm244CCXG4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UuYzoxNjUxCisjOiBidWlsdGluL21lcmdlLmM6MTY1NgogIywgYy1mb3JtYXQKIG1zZ2lkICJNZXJnZSB3aXRoIHN0cmF0ZWd5ICVzIGZhaWxlZC5cbiIKIG1zZ3N0ciAi5L2/55So562W55WlICVzIOWQiOW5tuWksei0peOAglxuIgogCi0jOiBidWlsdGluL21lcmdlLmM6MTY2MAorIzogYnVpbHRpbi9tZXJnZS5jOjE2NjUKICMsIGMtZm9ybWF0CiBtc2dpZCAiVXNpbmcgdGhlICVzIHRvIHByZXBhcmUgcmVzb2x2aW5nIGJ5IGhhbmQuXG4iCiBtc2dzdHIgIuS9v+eUqCAlcyDku6Xlh4blpIfmiYvlt6Xop6PlhrPjgIJcbiIKIAotIzogYnVpbHRpbi9tZXJnZS5jOjE2NzIKKyM6IGJ1aWx0aW4vbWVyZ2UuYzoxNjc3CiAjLCBjLWZvcm1hdAogbXNnaWQgIkF1dG9tYXRpYyBtZXJnZSB3ZW50IHdlbGw7IHN0b3BwZWQgYmVmb3JlIGNvbW1pdHRpbmcgYXMgcmVxdWVzdGVkXG4iCiBtc2dzdHIgIuiHquWKqOWQiOW5tui/m+WxlemhuuWIqe+8jOaMieimgeaxguWcqOaPkOS6pOWJjeWBnOatolxuIgpAQCAtMTUyMDQsMzMgKzE1MjkxLDMzIEBACiBtc2dpZCAic2V0IGxhYmVscyBmb3IgZmlsZTEvb3JpZy1maWxlL2ZpbGUyIgogbXNnc3RyICLkuLog5paH5Lu2MS/liJ3lp4vmlofku7Yv5paH5Lu2MiDorr7nva7moIfnrb4iCiAKLSM6IGJ1aWx0aW4vbWVyZ2UtcmVjdXJzaXZlLmM6NDYKKyM6IGJ1aWx0aW4vbWVyZ2UtcmVjdXJzaXZlLmM6NDcKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5rbm93biBvcHRpb24gJXMiCiBtc2dzdHIgIuacquefpemAiemhuSAlcyIKIAotIzogYnVpbHRpbi9tZXJnZS1yZWN1cnNpdmUuYzo1MgorIzogYnVpbHRpbi9tZXJnZS1yZWN1cnNpdmUuYzo1MwogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcGFyc2Ugb2JqZWN0ICclcyciCiBtc2dzdHIgIuS4jeiDveino+aekOWvueixoSAnJXMnIgogCi0jOiBidWlsdGluL21lcmdlLXJlY3Vyc2l2ZS5jOjU2CisjOiBidWlsdGluL21lcmdlLXJlY3Vyc2l2ZS5jOjU3CiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCBoYW5kbGUgbW9yZSB0aGFuICVkIGJhc2UuIElnbm9yaW5nICVzLiIKIG1zZ2lkX3BsdXJhbCAiY2Fubm90IGhhbmRsZSBtb3JlIHRoYW4gJWQgYmFzZXMuIElnbm9yaW5nICVzLiIKIG1zZ3N0clswXSAi5peg5rOV5aSE55CGICVkIOadoeS7peS4iueahOWfuue6v+OAguW/veeVpSAlc+OAgiIKIG1zZ3N0clsxXSAi5peg5rOV5aSE55CGICVkIOadoeS7peS4iueahOWfuue6v+OAguW/veeVpSAlc+OAgiIKIAotIzogYnVpbHRpbi9tZXJnZS1yZWN1cnNpdmUuYzo2NAorIzogYnVpbHRpbi9tZXJnZS1yZWN1cnNpdmUuYzo2NQogbXNnaWQgIm5vdCBoYW5kbGluZyBhbnl0aGluZyBvdGhlciB0aGFuIHR3byBoZWFkcyBtZXJnZS4iCiBtc2dzdHIgIuS4jeiDveWkhOeQhuS4pOS4quWktOWQiOW5tuS5i+WklueahOS7u+S9leaTjeS9nOOAgiIKIAotIzogYnVpbHRpbi9tZXJnZS1yZWN1cnNpdmUuYzo3MCBidWlsdGluL21lcmdlLXJlY3Vyc2l2ZS5jOjcyCisjOiBidWlsdGluL21lcmdlLXJlY3Vyc2l2ZS5jOjc0IGJ1aWx0aW4vbWVyZ2UtcmVjdXJzaXZlLmM6NzYKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHJlc29sdmUgcmVmICclcyciCiBtc2dzdHIgIuaXoOazleino+aekOW8leeUqCAnJXMnIgogCi0jOiBidWlsdGluL21lcmdlLXJlY3Vyc2l2ZS5jOjc4CisjOiBidWlsdGluL21lcmdlLXJlY3Vyc2l2ZS5jOjgyCiAjLCBjLWZvcm1hdAogbXNnaWQgIk1lcmdpbmcgJXMgd2l0aCAlc1xuIgogbXNnc3RyICLlkIjlubYgJXMg5ZKMICVzXG4iCkBAIC0xNTM2OSw1MiArMTU0NTYsNTIgQEAKIG1zZ2lkICJSZW5hbWluZyAlcyB0byAlc1xuIgogbXNnc3RyICLph43lkb3lkI0gJXMg6IezICVzXG4iCiAKLSM6IGJ1aWx0aW4vbXYuYzoyNzcgYnVpbHRpbi9yZW1vdGUuYzo3MTcgYnVpbHRpbi9yZXBhY2suYzo1MTAKKyM6IGJ1aWx0aW4vbXYuYzoyNzcgYnVpbHRpbi9yZW1vdGUuYzo3MTcgYnVpbHRpbi9yZXBhY2suYzo1MTEKICMsIGMtZm9ybWF0CiBtc2dpZCAicmVuYW1pbmcgJyVzJyBmYWlsZWQiCiBtc2dzdHIgIumHjeWRveWQjSAnJXMnIOWksei0pSIKIAotIzogYnVpbHRpbi9uYW1lLXJldi5jOjM1MgorIzogYnVpbHRpbi9uYW1lLXJldi5jOjM1NgogbXNnaWQgImdpdCBuYW1lLXJldiBbPG9wdGlvbnM+XSA8Y29tbWl0Pi4uLiIKIG1zZ3N0ciAiZ2l0IG5hbWUtcmV2IFs86YCJ6aG5Pl0gPOaPkOS6pD4uLi4iCiAKLSM6IGJ1aWx0aW4vbmFtZS1yZXYuYzozNTMKKyM6IGJ1aWx0aW4vbmFtZS1yZXYuYzozNTcKIG1zZ2lkICJnaXQgbmFtZS1yZXYgWzxvcHRpb25zPl0gLS1hbGwiCiBtc2dzdHIgImdpdCBuYW1lLXJldiBbPOmAiemhuT5dIC0tYWxsIgogCi0jOiBidWlsdGluL25hbWUtcmV2LmM6MzU0CisjOiBidWlsdGluL25hbWUtcmV2LmM6MzU4CiBtc2dpZCAiZ2l0IG5hbWUtcmV2IFs8b3B0aW9ucz5dIC0tc3RkaW4iCiBtc2dzdHIgImdpdCBuYW1lLXJldiBbPOmAiemhuT5dIC0tc3RkaW4iCiAKLSM6IGJ1aWx0aW4vbmFtZS1yZXYuYzo0MTEKKyM6IGJ1aWx0aW4vbmFtZS1yZXYuYzo0MTUKIG1zZ2lkICJwcmludCBvbmx5IG5hbWVzIChubyBTSEEtMSkiCiBtc2dzdHIgIuWPquaJk+WNsOWQjeensO+8iOaXoCBTSEEtMe+8iSIKIAotIzogYnVpbHRpbi9uYW1lLXJldi5jOjQxMgorIzogYnVpbHRpbi9uYW1lLXJldi5jOjQxNgogbXNnaWQgIm9ubHkgdXNlIHRhZ3MgdG8gbmFtZSB0aGUgY29tbWl0cyIKIG1zZ3N0ciAi5Y+q5L2/55So5qCH562+5p2l5ZG95ZCN5o+Q5LqkIgogCi0jOiBidWlsdGluL25hbWUtcmV2LmM6NDE0CisjOiBidWlsdGluL25hbWUtcmV2LmM6NDE4CiBtc2dpZCAib25seSB1c2UgcmVmcyBtYXRjaGluZyA8cGF0dGVybj4iCiBtc2dzdHIgIuWPquS9v+eUqOWSjCA85qih5byPPiDnm7jljLnphY3nmoTlvJXnlKgiCiAKLSM6IGJ1aWx0aW4vbmFtZS1yZXYuYzo0MTYKKyM6IGJ1aWx0aW4vbmFtZS1yZXYuYzo0MjAKIG1zZ2lkICJpZ25vcmUgcmVmcyBtYXRjaGluZyA8cGF0dGVybj4iCiBtc2dzdHIgIuW/veeVpeWSjCA85qih5byPPiDnm7jljLnphY3nmoTlvJXnlKgiCiAKLSM6IGJ1aWx0aW4vbmFtZS1yZXYuYzo0MTgKKyM6IGJ1aWx0aW4vbmFtZS1yZXYuYzo0MjIKIG1zZ2lkICJsaXN0IGFsbCBjb21taXRzIHJlYWNoYWJsZSBmcm9tIGFsbCByZWZzIgogbXNnc3RyICLliJflh7rlj6/ku6Xku47miYDmnInlvJXnlKjorr/pl67nmoTmj5DkuqQiCiAKLSM6IGJ1aWx0aW4vbmFtZS1yZXYuYzo0MTkKKyM6IGJ1aWx0aW4vbmFtZS1yZXYuYzo0MjMKIG1zZ2lkICJyZWFkIGZyb20gc3RkaW4iCiBtc2dzdHIgIuS7juagh+WHhui+k+WFpeivu+WPliIKIAotIzogYnVpbHRpbi9uYW1lLXJldi5jOjQyMAorIzogYnVpbHRpbi9uYW1lLXJldi5jOjQyNAogbXNnaWQgImFsbG93IHRvIHByaW50IGB1bmRlZmluZWRgIG5hbWVzIChkZWZhdWx0KSIKIG1zZ3N0ciAi5YWB6K645omT5Y2wIGDmnKrlrprkuYlgIOeahOWQjeensO+8iOm7mOiupO+8iSIKIAotIzogYnVpbHRpbi9uYW1lLXJldi5jOjQyNgorIzogYnVpbHRpbi9uYW1lLXJldi5jOjQzMAogbXNnaWQgImRlcmVmZXJlbmNlIHRhZ3MgaW4gdGhlIGlucHV0IChpbnRlcm5hbCB1c2UpIgogbXNnc3RyICLlj43lkJHop6PmnpDovpPlhaXkuK3nmoTmoIfnrb7vvIjlhoXpg6jkvb/nlKjvvIkiCiAKQEAgLTE1ODAxLDcgKzE1ODg4LDcgQEAKIG1zZ2lkICJyZWFkIG9iamVjdCBuYW1lcyBmcm9tIHRoZSBzdGFuZGFyZCBpbnB1dCIKIG1zZ3N0ciAi5LuO5qCH5YeG6L6T5YWl6K+75Y+W5a+56LGh5ZCN56ewIgogCi0jOiBidWlsdGluL25vdGVzLmM6OTU0IGJ1aWx0aW4vcHJ1bmUuYzoxMzAgYnVpbHRpbi93b3JrdHJlZS5jOjE2NQorIzogYnVpbHRpbi9ub3Rlcy5jOjk1NCBidWlsdGluL3BydW5lLmM6MTMwIGJ1aWx0aW4vd29ya3RyZWUuYzoxNjQKIG1zZ2lkICJkbyBub3QgcmVtb3ZlLCBzaG93IG9ubHkiCiBtc2dzdHIgIuS4jeWIoOmZpO+8jOWPquaYvuekuiIKIApAQCAtMTU4MTcsNyArMTU5MDQsNyBAQAogbXNnaWQgInVzZSBub3RlcyBmcm9tIDxub3Rlcy1yZWY+IgogbXNnc3RyICLku44gPOazqOino+W8leeUqD4g5L2/55So5rOo6KejIgogCi0jOiBidWlsdGluL25vdGVzLmM6MTAzNCBidWlsdGluL3N0YXNoLmM6MTU5OAorIzogYnVpbHRpbi9ub3Rlcy5jOjEwMzQgYnVpbHRpbi9zdGFzaC5jOjE2MDcKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5rbm93biBzdWJjb21tYW5kOiAlcyIKIG1zZ3N0ciAi5pyq55+l5a2Q5ZG95Luk77yaJXMiCkBAIC0xNTg4OCw2OCArMTU5NzUsNjggQEAKIG1zZ2lkICJ3cm90ZSAlPFBSSXUzMj4gb2JqZWN0cyB3aGlsZSBleHBlY3RpbmcgJTxQUkl1MzI+IgogbXNnc3RyICLlhpnlhaUgJTxQUkl1MzI+IOS4quWvueixoeiAjOmihOacnyAlPFBSSXUzMj4g5LiqIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjExNjYKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MTE2NAogbXNnaWQgImRpc2FibGluZyBiaXRtYXAgd3JpdGluZywgYXMgc29tZSBvYmplY3RzIGFyZSBub3QgYmVpbmcgcGFja2VkIgogbXNnc3RyICLnpoHnlKggYml0bWFwIOWGmeWFpe+8jOWboOS4uuS4gOS6m+WvueixoeWwhuS4jeS8muiiq+aJk+WMhSIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoxNTk3CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjE1OTIKICMsIGMtZm9ybWF0CiBtc2dpZCAiZGVsdGEgYmFzZSBvZmZzZXQgb3ZlcmZsb3cgaW4gcGFjayBmb3IgJXMiCiBtc2dzdHIgIiVzIOWOi+e8qeS4rSBkZWx0YSDln7rlh4blgY/np7votornlYwiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MTYwNgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoxNjAxCiAjLCBjLWZvcm1hdAogbXNnaWQgImRlbHRhIGJhc2Ugb2Zmc2V0IG91dCBvZiBib3VuZCBmb3IgJXMiCiBtc2dzdHIgIiVzIOeahCBkZWx0YSDln7rlh4blgY/np7votornlYwiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MTg3NQorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoxODcwCiBtc2dpZCAiQ291bnRpbmcgb2JqZWN0cyIKIG1zZ3N0ciAi5a+56LGh6K6h5pWw5LitIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjIwMDUKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjAwMAogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gZ2V0IHNpemUgb2YgJXMiCiBtc2dzdHIgIuS4jeiDveW+l+WIsCAlcyDnmoTlpKflsI8iCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjAyMAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyMDE1CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBwYXJzZSBvYmplY3QgaGVhZGVyIG9mICVzIgogbXNnc3RyICLml6Dms5Xop6PmnpDlr7nosaEgJXMg5aS05L+h5oGvIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjIwOTAgYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyMTA2Ci0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjIxMTYKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjA4NSBidWlsdGluL3BhY2stb2JqZWN0cy5jOjIxMDEKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjExMQogIywgYy1mb3JtYXQKIG1zZ2lkICJvYmplY3QgJXMgY2Fubm90IGJlIHJlYWQiCiBtc2dzdHIgIuWvueixoSAlcyDml6Dms5Xor7vlj5YiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjA5MyBidWlsdGluL3BhY2stb2JqZWN0cy5jOjIxMjAKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjA4OCBidWlsdGluL3BhY2stb2JqZWN0cy5jOjIxMTUKICMsIGMtZm9ybWF0CiBtc2dpZCAib2JqZWN0ICVzIGluY29uc2lzdGVudCBvYmplY3QgbGVuZ3RoICglPFBSSXVNQVg+IHZzICU8UFJJdU1BWD4pIgogbXNnc3RyICLlr7nosaEgJXMg5LiN5LiA6Ie055qE5a+56LGh6ZW/5bqm77yIJTxQUkl1TUFYPiB2cyAlPFBSSXVNQVg+77yJIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjIxMzAKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjEyNQogbXNnaWQgInN1Ym9wdGltYWwgcGFjayAtIG91dCBvZiBtZW1vcnkiCiBtc2dzdHIgIuasoeS8mO+8iHN1Ym9wdGltYWzvvInmiZPljIUgLSDlhoXlrZjkuI3otrMiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjQ1NgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNDQwCiAjLCBjLWZvcm1hdAogbXNnaWQgIkRlbHRhIGNvbXByZXNzaW9uIHVzaW5nIHVwIHRvICVkIHRocmVhZHMiCiBtc2dzdHIgIuS9v+eUqCAlZCDkuKrnur/nqIvov5vooYzljovnvKkiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjU4OAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNTcyCiAjLCBjLWZvcm1hdAogbXNnaWQgInVuYWJsZSB0byBwYWNrIG9iamVjdHMgcmVhY2hhYmxlIGZyb20gdGFnICVzIgogbXNnc3RyICLml6Dms5XkuLrmoIfnrb4gJXMg5Y6L57yp5a+56LGhIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI2NzUKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjY1OQogbXNnaWQgIkNvbXByZXNzaW5nIG9iamVjdHMiCiBtc2dzdHIgIuWOi+e8qeWvueixoeS4rSIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNjgxCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI2NjUKIG1zZ2lkICJpbmNvbnNpc3RlbmN5IHdpdGggZGVsdGEgY291bnQiCiBtc2dzdHIgIuS4jeS4gOiHtOeahOW3ruW8guiuoeaVsCIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyNzYyCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI3NDIKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogImV4cGVjdGVkIGVkZ2Ugb2JqZWN0IElELCBnb3QgZ2FyYmFnZTpcbiIKQEAgLTE1OTU4LDcgKzE2MDQ1LDcgQEAKICLpooTmnJ/ovrnnlYzlr7nosaHvvIhlZGdlIG9iamVjdO+8iUlE77yM5Y205b6X5Yiw5Z6D5Zy+5pWw5o2u77yaXG4iCiAiICVzIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI3NjgKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6Mjc0OAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiZXhwZWN0ZWQgb2JqZWN0IElELCBnb3QgZ2FyYmFnZTpcbiIKQEAgLTE1OTY3LDI0MiArMTYwNTQsMjQyIEBACiAi6aKE5pyf5a+56LGhIElE77yM5Y205b6X5Yiw5Z6D5Zy+5pWw5o2u77yaXG4iCiAiICVzIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjI4NjYKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6Mjg0NgogbXNnaWQgImludmFsaWQgdmFsdWUgZm9yIC0tbWlzc2luZyIKIG1zZ3N0ciAi6YCJ6aG5IC0tbWlzc2luZyDnmoTlgLzml6DmlYgiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjkyNSBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMwMzMKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MjkwNSBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMwMTMKIG1zZ2lkICJjYW5ub3Qgb3BlbiBwYWNrIGluZGV4IgogbXNnc3RyICLml6Dms5XmiZPlvIDljIXmlofku7bntKLlvJUiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6Mjk1NgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzoyOTM2CiAjLCBjLWZvcm1hdAogbXNnaWQgImxvb3NlIG9iamVjdCBhdCAlcyBjb3VsZCBub3QgYmUgZXhhbWluZWQiCiBtc2dzdHIgIuaXoOazleajgOafpSAlcyDlpITnmoTmnb7mlaPlr7nosaEiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzA0MQorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMDIxCiBtc2dpZCAidW5hYmxlIHRvIGZvcmNlIGxvb3NlIG9iamVjdCIKIG1zZ3N0ciAi5peg5rOV5by65Yi25p2+5pWj5a+56LGhIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMxMzMKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzExMwogIywgYy1mb3JtYXQKIG1zZ2lkICJub3QgYSByZXYgJyVzJyIKIG1zZ3N0ciAi5LiN5piv5LiA5Liq54mI5pysICclcyciCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzEzNgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMTE2CiAjLCBjLWZvcm1hdAogbXNnaWQgImJhZCByZXZpc2lvbiAnJXMnIgogbXNnc3RyICLlnY/nmoTniYjmnKwgJyVzJyIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMTYxCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMxNDEKIG1zZ2lkICJ1bmFibGUgdG8gYWRkIHJlY2VudCBvYmplY3RzIgogbXNnc3RyICLml6Dms5Xmt7vliqDmnIDov5HnmoTlr7nosaEiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzIxNAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMTk0CiAjLCBjLWZvcm1hdAogbXNnaWQgInVuc3VwcG9ydGVkIGluZGV4IHZlcnNpb24gJXMiCiBtc2dzdHIgIuS4jeaUr+aMgeeahOe0ouW8leeJiOacrCAlcyIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjE4CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMxOTgKICMsIGMtZm9ybWF0CiBtc2dpZCAiYmFkIGluZGV4IHZlcnNpb24gJyVzJyIKIG1zZ3N0ciAi5Z2P55qE57Si5byV54mI5pysICclcyciCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI0OAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjI4CiBtc2dpZCAiZG8gbm90IHNob3cgcHJvZ3Jlc3MgbWV0ZXIiCiBtc2dzdHIgIuS4jeaYvuekuui/m+W6puihqCIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjUwCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyMzAKIG1zZ2lkICJzaG93IHByb2dyZXNzIG1ldGVyIgogbXNnc3RyICLmmL7npLrov5vluqbooagiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI1MgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjMyCiBtc2dpZCAic2hvdyBwcm9ncmVzcyBtZXRlciBkdXJpbmcgb2JqZWN0IHdyaXRpbmcgcGhhc2UiCiBtc2dzdHIgIuWcqOWvueixoeWGmeWFpemYtuauteaYvuekuui/m+W6puihqCIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjU1CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyMzUKIG1zZ2lkICJzaW1pbGFyIHRvIC0tYWxsLXByb2dyZXNzIHdoZW4gcHJvZ3Jlc3MgbWV0ZXIgaXMgc2hvd24iCiBtc2dzdHIgIuW9k+i/m+W6puihqOaYvuekuuaXtuexu+S8vOS6jiAtLWFsbC1wcm9ncmVzcyIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjU2CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyMzYKIG1zZ2lkICI8dmVyc2lvbj5bLDxvZmZzZXQ+XSIKIG1zZ3N0ciAiPOeJiOacrD5bLDzlgY/np7s+XSIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjU3CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyMzcKIG1zZ2lkICJ3cml0ZSB0aGUgcGFjayBpbmRleCBmaWxlIGluIHRoZSBzcGVjaWZpZWQgaWR4IGZvcm1hdCB2ZXJzaW9uIgogbXNnc3RyICLnlKjmjIflrprnmoQgaWR4IOagvOW8j+eJiOacrOadpeWGmeWMhee0ouW8leaWh+S7tiIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjYwCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNDAKIG1zZ2lkICJtYXhpbXVtIHNpemUgb2YgZWFjaCBvdXRwdXQgcGFjayBmaWxlIgogbXNnc3RyICLmr4/kuKrovpPlh7rljIXnmoTmnIDlpKflsLrlr7giCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI2MgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjQyCiBtc2dpZCAiaWdub3JlIGJvcnJvd2VkIG9iamVjdHMgZnJvbSBhbHRlcm5hdGUgb2JqZWN0IHN0b3JlIgogbXNnc3RyICLlv73nlaXku47lpIfnlKjlr7nosaHlrZjlgqjph4zlgJ/nlKjlr7nosaEiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI2NAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjQ0CiBtc2dpZCAiaWdub3JlIHBhY2tlZCBvYmplY3RzIgogbXNnc3RyICLlv73nlaXljIXlr7nosaEiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI2NgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjQ2CiBtc2dpZCAibGltaXQgcGFjayB3aW5kb3cgYnkgb2JqZWN0cyIKIG1zZ3N0ciAi6ZmQ5Yi25omT5YyF56qX5Y+j55qE5a+56LGh5pWwIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNjgKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI0OAogbXNnaWQgImxpbWl0IHBhY2sgd2luZG93IGJ5IG1lbW9yeSBpbiBhZGRpdGlvbiB0byBvYmplY3QgbGltaXQiCiBtc2dzdHIgIumZpOWvueixoeaVsOmHj+mZkOWItuWkluiuvue9ruaJk+WMheeql+WPo+eahOWGheWtmOmZkOWItiIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjcwCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNTAKIG1zZ2lkICJtYXhpbXVtIGxlbmd0aCBvZiBkZWx0YSBjaGFpbiBhbGxvd2VkIGluIHRoZSByZXN1bHRpbmcgcGFjayIKIG1zZ3N0ciAi5omT5YyF5YWB6K6455qEIGRlbHRhIOmTvueahOacgOWkp+mVv+W6piIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjcyCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNTIKIG1zZ2lkICJyZXVzZSBleGlzdGluZyBkZWx0YXMiCiBtc2dzdHIgIumHjeeUqOW3suWtmOWcqOeahCBkZWx0YXMiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI3NAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjU0CiBtc2dpZCAicmV1c2UgZXhpc3Rpbmcgb2JqZWN0cyIKIG1zZ3N0ciAi6YeN55So5bey5a2Y5Zyo55qE5a+56LGhIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNzYKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI1NgogbXNnaWQgInVzZSBPRlNfREVMVEEgb2JqZWN0cyIKIG1zZ3N0ciAi5L2/55SoIE9GU19ERUxUQSDlr7nosaEiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI3OAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjU4CiBtc2dpZCAidXNlIHRocmVhZHMgd2hlbiBzZWFyY2hpbmcgZm9yIGJlc3QgZGVsdGEgbWF0Y2hlcyIKIG1zZ3N0ciAi5L2/55So57q/56iL5p+l6K+i5pyA5L2zIGRlbHRhIOWMuemFjSIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjgwCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNjAKIG1zZ2lkICJkbyBub3QgY3JlYXRlIGFuIGVtcHR5IHBhY2sgb3V0cHV0IgogbXNnc3RyICLkuI3liJvlu7rnqbrnmoTljIXovpPlh7oiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI4MgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjYyCiBtc2dpZCAicmVhZCByZXZpc2lvbiBhcmd1bWVudHMgZnJvbSBzdGFuZGFyZCBpbnB1dCIKIG1zZ3N0ciAi5LuO5qCH5YeG6L6T5YWl6K+75Y+W54mI5pys5Y+35Y+C5pWwIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyODQKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI2NAogbXNnaWQgImxpbWl0IHRoZSBvYmplY3RzIHRvIHRob3NlIHRoYXQgYXJlIG5vdCB5ZXQgcGFja2VkIgogbXNnc3RyICLpmZDliLbpgqPkupvlsJrmnKrmiZPljIXnmoTlr7nosaEiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI4NworIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjY3CiBtc2dpZCAiaW5jbHVkZSBvYmplY3RzIHJlYWNoYWJsZSBmcm9tIGFueSByZWZlcmVuY2UiCiBtc2dzdHIgIuWMheaLrOWPr+S7peS7juS7u+S9leW8leeUqOiuv+mXruWIsOeahOWvueixoSIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjkwCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNzAKIG1zZ2lkICJpbmNsdWRlIG9iamVjdHMgcmVmZXJyZWQgYnkgcmVmbG9nIGVudHJpZXMiCiBtc2dzdHIgIuWMheaLrOiiq+W8leeUqOaXpeW/l+W8leeUqOWIsOeahOWvueixoSIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjkzCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyNzMKIG1zZ2lkICJpbmNsdWRlIG9iamVjdHMgcmVmZXJyZWQgdG8gYnkgdGhlIGluZGV4IgogbXNnc3RyICLljIXmi6zooqvntKLlvJXlvJXnlKjliLDnmoTlr7nosaEiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI5NgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjc2CiBtc2dpZCAib3V0cHV0IHBhY2sgdG8gc3Rkb3V0IgogbXNnc3RyICLovpPlh7rljIXliLDmoIflh4bovpPlh7oiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI5OAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjc4CiBtc2dpZCAiaW5jbHVkZSB0YWcgb2JqZWN0cyB0aGF0IHJlZmVyIHRvIG9iamVjdHMgdG8gYmUgcGFja2VkIgogbXNnc3RyICLljIXmi6zpgqPkupvlvJXnlKjkuoblvoXmiZPljIXlr7nosaHnmoTmoIfnrb7lr7nosaEiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMwMAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjgwCiBtc2dpZCAia2VlcCB1bnJlYWNoYWJsZSBvYmplY3RzIgogbXNnc3RyICLnu7TmjIHkuI3lj6/ovr7nmoTlr7nosaEiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMwMgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjgyCiBtc2dpZCAicGFjayBsb29zZSB1bnJlYWNoYWJsZSBvYmplY3RzIgogbXNnc3RyICLmiZPljIXmnb7mlaPnmoTkuI3lj6/ovr7lr7nosaEiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMwNAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjg0CiBtc2dpZCAidW5wYWNrIHVucmVhY2hhYmxlIG9iamVjdHMgbmV3ZXIgdGhhbiA8dGltZT4iCiBtc2dzdHIgIuWwhuavlOe7meWumiA85pe26Ze0PiDmlrDnmoTml6Dms5Xorr/pl67nmoTlr7nosaHop6PljIUiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMwNworIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjg3CiBtc2dpZCAidXNlIHRoZSBzcGFyc2UgcmVhY2hhYmlsaXR5IGFsZ29yaXRobSIKIG1zZ3N0ciAi5L2/55So56iA55aP5Y+v6L6+5oCn566X5rOVIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMDkKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI4OQogbXNnaWQgImNyZWF0ZSB0aGluIHBhY2tzIgogbXNnc3RyICLliJvlu7rnsr7nroDljIUiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMxMQorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMjkxCiBtc2dpZCAiY3JlYXRlIHBhY2tzIHN1aXRhYmxlIGZvciBzaGFsbG93IGZldGNoZXMiCiBtc2dzdHIgIuWIm+W7uumAguWQiOa1heWFi+mahuS7k+W6k+iOt+WPlueahOWMhSIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzEzCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyOTMKIG1zZ2lkICJpZ25vcmUgcGFja3MgdGhhdCBoYXZlIGNvbXBhbmlvbiAua2VlcCBmaWxlIgogbXNnc3RyICLlv73nlaXphY3mnIkgLmtlZXAg5paH5Lu255qE5YyFIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMTUKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI5NQogbXNnaWQgImlnbm9yZSB0aGlzIHBhY2siCiBtc2dzdHIgIuW/veeVpeivpSBwYWNrIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMTcKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzI5NwogbXNnaWQgInBhY2sgY29tcHJlc3Npb24gbGV2ZWwiCiBtc2dzdHIgIuaJk+WMheWOi+e8qee6p+WIqyIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzE5CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMyOTkKIG1zZ2lkICJkbyBub3QgaGlkZSBjb21taXRzIGJ5IGdyYWZ0cyIKIG1zZ3N0ciAi5pi+56S66KKr56e75qSN6ZqQ6JeP55qE5o+Q5LqkIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMjEKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMwMQogbXNnaWQgInVzZSBhIGJpdG1hcCBpbmRleCBpZiBhdmFpbGFibGUgdG8gc3BlZWQgdXAgY291bnRpbmcgb2JqZWN0cyIKIG1zZ3N0ciAi5L2/55SoIGJpdG1hcCDntKLlvJXvvIjlpoLmnpzmnInnmoTor53vvInku6Xmj5Dpq5jlr7nosaHorqHmlbDml7bnmoTpgJ/luqYiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMyMworIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzAzCiBtc2dpZCAid3JpdGUgYSBiaXRtYXAgaW5kZXggdG9nZXRoZXIgd2l0aCB0aGUgcGFjayBpbmRleCIKIG1zZ3N0ciAi5Zyo5bu656uL5YyF57Si5byV55qE5ZCM5pe25Yib5bu6IGJpdG1hcCDntKLlvJUiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMyNworIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzA3CiBtc2dpZCAid3JpdGUgYSBiaXRtYXAgaW5kZXggaWYgcG9zc2libGUiCiBtc2dzdHIgIuWmguaenOWPr+iDve+8jOWGmSBiaXRtYXAg57Si5byVIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMzEKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzMxMQogbXNnaWQgImhhbmRsaW5nIGZvciBtaXNzaW5nIG9iamVjdHMiCiBtc2dzdHIgIuWkhOeQhuS4ouWkseeahOWvueixoSIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzM0CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMTQKIG1zZ2lkICJkbyBub3QgcGFjayBvYmplY3RzIGluIHByb21pc29yIHBhY2tmaWxlcyIKIG1zZ3N0ciAi5LiN6KaB5omT5YyFIHByb21pc29yIOWMheaWh+S7tuS4reeahOWvueixoSIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzM2CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzMTYKIG1zZ2lkICJyZXNwZWN0IGlzbGFuZHMgZHVyaW5nIGRlbHRhIGNvbXByZXNzaW9uIgogbXNnc3RyICLlnKjlop7ph4/ljovnvKnml7blj4LogIPmlbDmja7lspsiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzM2MQorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozMzQ1CiAjLCBjLWZvcm1hdAogbXNnaWQgImRlbHRhIGNoYWluIGRlcHRoICVkIGlzIHRvbyBkZWVwLCBmb3JjaW5nICVkIgogbXNnc3RyICLlop7ph4/pk77mt7HluqYgJWQg5aSq5rex5LqG77yM5by65Yi25Li6ICVkIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjMzNjYKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzM1MAogIywgYy1mb3JtYXQKIG1zZ2lkICJwYWNrLmRlbHRhQ2FjaGVMaW1pdCBpcyB0b28gaGlnaCwgZm9yY2luZyAlZCIKIG1zZ3N0ciAi6YWN572uIHBhY2suZGVsdGFDYWNoZUxpbWl0IOWkqumrmOS6hu+8jOW8uuWItuS4uiAlZCIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozNDIwCisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjM0MDQKIG1zZ2lkICItLW1heC1wYWNrLXNpemUgY2Fubm90IGJlIHVzZWQgdG8gYnVpbGQgYSBwYWNrIGZvciB0cmFuc2ZlciIKIG1zZ3N0ciAi5LiN6IO95L2/55SoIC0tbWF4LXBhY2stc2l6ZSDmnaXmnoTlu7rkvKDovpPnlKjnmoTljIXmlofku7YiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzQyMgorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozNDA2CiBtc2dpZCAibWluaW11bSBwYWNrIHNpemUgbGltaXQgaXMgMSBNaUIiCiBtc2dzdHIgIuacgOWwj+eahOWMheaWh+S7tuWkp+Wwj+aYryAxIE1pQiIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozNDI3CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjM0MTEKIG1zZ2lkICItLXRoaW4gY2Fubm90IGJlIHVzZWQgdG8gYnVpbGQgYW4gaW5kZXhhYmxlIHBhY2siCiBtc2dzdHIgIi0tdGhpbiDkuI3og73nlKjkuo7liJvlu7rkuIDkuKrlj6/ntKLlvJXljIUiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzQzMAorIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozNDE0CiBtc2dpZCAiLS1rZWVwLXVucmVhY2hhYmxlIGFuZCAtLXVucGFjay11bnJlYWNoYWJsZSBhcmUgaW5jb21wYXRpYmxlIgogbXNnc3RyICItLWtlZXAtdW5yZWFjaGFibGUg5ZKMIC0tdW5wYWNrLXVucmVhY2hhYmxlIOS4jeWFvOWuuSIKIAotIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozNDM2CisjOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjM0MjAKIG1zZ2lkICJjYW5ub3QgdXNlIC0tZmlsdGVyIHdpdGhvdXQgLS1zdGRvdXQiCiBtc2dzdHIgIuS4jeiDveWcqOayoeaciSAtLXN0ZG91dCDnmoTmg4XlhrXkuIvkvb/nlKggLS1maWx0ZXIiCiAKLSM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzQ5NworIzogYnVpbHRpbi9wYWNrLW9iamVjdHMuYzozNDgxCiBtc2dpZCAiRW51bWVyYXRpbmcgb2JqZWN0cyIKIG1zZ3N0ciAi5p6a5Li+5a+56LGhIgogCi0jOiBidWlsdGluL3BhY2stb2JqZWN0cy5jOjM1MjcKKyM6IGJ1aWx0aW4vcGFjay1vYmplY3RzLmM6MzUxMQogIywgYy1mb3JtYXQKIG1zZ2lkICJUb3RhbCAlPFBSSXUzMj4gKGRlbHRhICU8UFJJdTMyPiksIHJldXNlZCAlPFBSSXUzMj4gKGRlbHRhICU8UFJJdTMyPikiCiBtc2dzdHIgIuaAu+WFsSAlPFBSSXUzMj4g77yI5beu5byCICU8UFJJdTMyPu+8ie+8jOWkjeeUqCAlPFBSSXUzMj4g77yI5beu5byCICU8UFJJdTMyPu+8iSIKQEAgLTE2MjU2LDYxICsxNjM0Myw2MSBAQAogbXNnaWQgImdpdCBwdWxsIFs8b3B0aW9ucz5dIFs8cmVwb3NpdG9yeT4gWzxyZWZzcGVjPi4uLl1dIgogbXNnc3RyICJnaXQgcHVsbCBbPOmAiemhuT5dIFs85LuT5bqTPiBbPOW8leeUqOinhOagvD4uLi5dXSIKIAotIzogYnVpbHRpbi9wdWxsLmM6MTQxCisjOiBidWlsdGluL3B1bGwuYzoxNDIKIG1zZ2lkICJjb250cm9sIGZvciByZWN1cnNpdmUgZmV0Y2hpbmcgb2Ygc3VibW9kdWxlcyIKIG1zZ3N0ciAi5o6n5Yi25a2Q5qih57uE55qE6YCS5b2S6I635Y+WIgogCi0jOiBidWlsdGluL3B1bGwuYzoxNDUKKyM6IGJ1aWx0aW4vcHVsbC5jOjE0NgogbXNnaWQgIk9wdGlvbnMgcmVsYXRlZCB0byBtZXJnaW5nIgogbXNnc3RyICLlkozlkIjlubbnm7jlhbPnmoTpgInpobkiCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjE0OAorIzogYnVpbHRpbi9wdWxsLmM6MTQ5CiBtc2dpZCAiaW5jb3Jwb3JhdGUgY2hhbmdlcyBieSByZWJhc2luZyByYXRoZXIgdGhhbiBtZXJnaW5nIgogbXNnc3RyICLkvb/nlKjlj5jln7rmk43kvZzlj5bku6PlkIjlubbmk43kvZzku6XlkIjlhaXkv67mlLkiCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjE3NiBidWlsdGluL3JlYmFzZS5jOjQ0NyBidWlsdGluL3JldmVydC5jOjEyNgorIzogYnVpbHRpbi9wdWxsLmM6MTc3IGJ1aWx0aW4vcmViYXNlLmM6NDQ4IGJ1aWx0aW4vcmV2ZXJ0LmM6MTI2CiBtc2dpZCAiYWxsb3cgZmFzdC1mb3J3YXJkIgogbXNnc3RyICLlhYHorrjlv6vov5vlvI8iCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjE4NQorIzogYnVpbHRpbi9wdWxsLmM6MTg2CiBtc2dpZCAiYXV0b21hdGljYWxseSBzdGFzaC9zdGFzaCBwb3AgYmVmb3JlIGFuZCBhZnRlciByZWJhc2UiCiBtc2dzdHIgIuWPmOWfuuaTjeS9nOWJjeWQjuaJp+ihjOiHquWKqOi0ruiXj+WSjOW8ueWHuui0ruiXjyIKIAotIzogYnVpbHRpbi9wdWxsLmM6MjAxCisjOiBidWlsdGluL3B1bGwuYzoyMDIKIG1zZ2lkICJPcHRpb25zIHJlbGF0ZWQgdG8gZmV0Y2hpbmciCiBtc2dzdHIgIuWSjOiOt+WPluebuOWFs+eahOWPguaVsCIKIAotIzogYnVpbHRpbi9wdWxsLmM6MjExCisjOiBidWlsdGluL3B1bGwuYzoyMTIKIG1zZ2lkICJmb3JjZSBvdmVyd3JpdGUgb2YgbG9jYWwgYnJhbmNoIgogbXNnc3RyICLlvLrliLbopobnm5bmnKzlnLDliIbmlK8iCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjIxOQorIzogYnVpbHRpbi9wdWxsLmM6MjIwCiBtc2dpZCAibnVtYmVyIG9mIHN1Ym1vZHVsZXMgcHVsbGVkIGluIHBhcmFsbGVsIgogbXNnc3RyICLlubblj5Hmi4nlj5bnmoTlrZDmqKHnu4TnmoTmlbDph48iCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjMxNgorIzogYnVpbHRpbi9wdWxsLmM6MzIwCiAjLCBjLWZvcm1hdAogbXNnaWQgIkludmFsaWQgdmFsdWUgZm9yIHB1bGwuZmY6ICVzIgogbXNnc3RyICJwdWxsLmZmIOeahOWPluWAvOaXoOaViO+8miVzIgogCi0jOiBidWlsdGluL3B1bGwuYzo0MzMKKyM6IGJ1aWx0aW4vcHVsbC5jOjQzNwogbXNnaWQgIiIKICJUaGVyZSBpcyBubyBjYW5kaWRhdGUgZm9yIHJlYmFzaW5nIGFnYWluc3QgYW1vbmcgdGhlIHJlZnMgdGhhdCB5b3UganVzdCAiCiAiZmV0Y2hlZC4iCiBtc2dzdHIgIuWcqOaCqOWImuWImuiOt+WPluWIsOeahOW8leeUqOS4reayoeacieWPmOWfuuaTjeS9nOeahOWAmemAieOAgiIKIAotIzogYnVpbHRpbi9wdWxsLmM6NDM1CisjOiBidWlsdGluL3B1bGwuYzo0MzkKIG1zZ2lkICIiCiAiVGhlcmUgYXJlIG5vIGNhbmRpZGF0ZXMgZm9yIG1lcmdpbmcgYW1vbmcgdGhlIHJlZnMgdGhhdCB5b3UganVzdCBmZXRjaGVkLiIKIG1zZ3N0ciAi5Zyo5oKo5Yia5Yia6I635Y+W5Yiw55qE5byV55So5Lit5rKh5pyJ5ZCI5bm25pON5L2c55qE5YCZ6YCJ44CCIgogCi0jOiBidWlsdGluL3B1bGwuYzo0MzYKKyM6IGJ1aWx0aW4vcHVsbC5jOjQ0MAogbXNnaWQgIiIKICJHZW5lcmFsbHkgdGhpcyBtZWFucyB0aGF0IHlvdSBwcm92aWRlZCBhIHdpbGRjYXJkIHJlZnNwZWMgd2hpY2ggaGFkIG5vXG4iCiAibWF0Y2hlcyBvbiB0aGUgcmVtb3RlIGVuZC4iCiBtc2dzdHIgIumAmuW4uOi/meaEj+WRs+edgOaCqOaPkOS+m+S6huS4gOS4qumAmumFjeespuW8leeUqOinhOagvOS9huacquiDveWSjOi/nOerr+WMuemFjeOAgiIKIAotIzogYnVpbHRpbi9wdWxsLmM6NDM5CisjOiBidWlsdGluL3B1bGwuYzo0NDMKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIllvdSBhc2tlZCB0byBwdWxsIGZyb20gdGhlIHJlbW90ZSAnJXMnLCBidXQgZGlkIG5vdCBzcGVjaWZ5XG4iCkBAIC0xNjMyMCw0MiArMTY0MDcsNDIgQEAKICLmgqjopoHmsYLku47ov5znqIsgJyVzJyDmi4nlj5bvvIzkvYbmmK/mnKrmjIflrprkuIDkuKrliIbmlK/jgILlm6DkuLrov5nkuI3mmK/lvZPliY1cbiIKICLliIbmlK/pu5jorqTnmoTov5znqIvku5PlupPvvIzmgqjlv4XpobvlnKjlkb3ku6TooYzkuK3mjIflrprkuIDkuKrliIbmlK/lkI3jgIIiCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjQ0NCBidWlsdGluL3JlYmFzZS5jOjEzMjYgZ2l0LXBhcnNlLXJlbW90ZS5zaDo3MworIzogYnVpbHRpbi9wdWxsLmM6NDQ4IGJ1aWx0aW4vcmViYXNlLmM6MTM0NyBnaXQtcGFyc2UtcmVtb3RlLnNoOjczCiBtc2dpZCAiWW91IGFyZSBub3QgY3VycmVudGx5IG9uIGEgYnJhbmNoLiIKIG1zZ3N0ciAi5oKo5b2T5YmN5LiN5Zyo5LiA5Liq5YiG5pSv5LiK44CCIgogCi0jOiBidWlsdGluL3B1bGwuYzo0NDYgYnVpbHRpbi9wdWxsLmM6NDYxIGdpdC1wYXJzZS1yZW1vdGUuc2g6NzkKKyM6IGJ1aWx0aW4vcHVsbC5jOjQ1MCBidWlsdGluL3B1bGwuYzo0NjUgZ2l0LXBhcnNlLXJlbW90ZS5zaDo3OQogbXNnaWQgIlBsZWFzZSBzcGVjaWZ5IHdoaWNoIGJyYW5jaCB5b3Ugd2FudCB0byByZWJhc2UgYWdhaW5zdC4iCiBtc2dzdHIgIuivt+aMh+WumuaCqOimgeWPmOWfuuWIsOWTquS4gOS4quWIhuaUr+OAgiIKIAotIzogYnVpbHRpbi9wdWxsLmM6NDQ4IGJ1aWx0aW4vcHVsbC5jOjQ2MyBnaXQtcGFyc2UtcmVtb3RlLnNoOjgyCisjOiBidWlsdGluL3B1bGwuYzo0NTIgYnVpbHRpbi9wdWxsLmM6NDY3IGdpdC1wYXJzZS1yZW1vdGUuc2g6ODIKIG1zZ2lkICJQbGVhc2Ugc3BlY2lmeSB3aGljaCBicmFuY2ggeW91IHdhbnQgdG8gbWVyZ2Ugd2l0aC4iCiBtc2dzdHIgIuivt+aMh+WumuaCqOimgeWQiOW5tuWTquS4gOS4quWIhuaUr+OAgiIKIAotIzogYnVpbHRpbi9wdWxsLmM6NDQ5IGJ1aWx0aW4vcHVsbC5jOjQ2NAorIzogYnVpbHRpbi9wdWxsLmM6NDUzIGJ1aWx0aW4vcHVsbC5jOjQ2OAogbXNnaWQgIlNlZSBnaXQtcHVsbCgxKSBmb3IgZGV0YWlscy4iCiBtc2dzdHIgIuivpuingSBnaXQtcHVsbCgxKeOAgiIKIAotIzogYnVpbHRpbi9wdWxsLmM6NDUxIGJ1aWx0aW4vcHVsbC5jOjQ1NyBidWlsdGluL3B1bGwuYzo0NjYKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTMzMiBnaXQtcGFyc2UtcmVtb3RlLnNoOjY0CisjOiBidWlsdGluL3B1bGwuYzo0NTUgYnVpbHRpbi9wdWxsLmM6NDYxIGJ1aWx0aW4vcHVsbC5jOjQ3MAorIzogYnVpbHRpbi9yZWJhc2UuYzoxMzUzIGdpdC1wYXJzZS1yZW1vdGUuc2g6NjQKIG1zZ2lkICI8cmVtb3RlPiIKIG1zZ3N0ciAiPOi/nOeoiz4iCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjQ1MSBidWlsdGluL3B1bGwuYzo0NjYgYnVpbHRpbi9wdWxsLmM6NDcxCisjOiBidWlsdGluL3B1bGwuYzo0NTUgYnVpbHRpbi9wdWxsLmM6NDcwIGJ1aWx0aW4vcHVsbC5jOjQ3NQogIzogZ2l0LXBhcnNlLXJlbW90ZS5zaDo2NQogbXNnaWQgIjxicmFuY2g+IgogbXNnc3RyICI85YiG5pSvPiIKIAotIzogYnVpbHRpbi9wdWxsLmM6NDU5IGJ1aWx0aW4vcmViYXNlLmM6MTMyNCBnaXQtcGFyc2UtcmVtb3RlLnNoOjc1CisjOiBidWlsdGluL3B1bGwuYzo0NjMgYnVpbHRpbi9yZWJhc2UuYzoxMzQ1IGdpdC1wYXJzZS1yZW1vdGUuc2g6NzUKIG1zZ2lkICJUaGVyZSBpcyBubyB0cmFja2luZyBpbmZvcm1hdGlvbiBmb3IgdGhlIGN1cnJlbnQgYnJhbmNoLiIKIG1zZ3N0ciAi5b2T5YmN5YiG5pSv5rKh5pyJ6Lef6Liq5L+h5oGv44CCIgogCi0jOiBidWlsdGluL3B1bGwuYzo0NjggZ2l0LXBhcnNlLXJlbW90ZS5zaDo5NQorIzogYnVpbHRpbi9wdWxsLmM6NDcyIGdpdC1wYXJzZS1yZW1vdGUuc2g6OTUKIG1zZ2lkICIiCiAiSWYgeW91IHdpc2ggdG8gc2V0IHRyYWNraW5nIGluZm9ybWF0aW9uIGZvciB0aGlzIGJyYW5jaCB5b3UgY2FuIGRvIHNvIHdpdGg6IgogbXNnc3RyICLlpoLmnpzmgqjmg7PopoHkuLrmraTliIbmlK/liJvlu7rot5/ouKrkv6Hmga/vvIzmgqjlj6/ku6XmiafooYzvvJoiCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjQ3MworIzogYnVpbHRpbi9wdWxsLmM6NDc3CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJZb3VyIGNvbmZpZ3VyYXRpb24gc3BlY2lmaWVzIHRvIG1lcmdlIHdpdGggdGhlIHJlZiAnJXMnXG4iCkBAIC0xNjM2NCwzMiArMTY0NTEsMzIgQEAKICLmgqjnmoTphY3nva7kuK3mjIflrpropoHlkIjlubbov5znqIvnmoTlvJXnlKggJyVzJ++8jFxuIgogIuS9huaYr+ayoeacieiOt+WPluWIsOi/meS4quW8leeUqOOAgiIKIAotIzogYnVpbHRpbi9wdWxsLmM6NTgxCisjOiBidWlsdGluL3B1bGwuYzo1ODcKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGFjY2VzcyBjb21taXQgJXMiCiBtc2dzdHIgIuaXoOazleiuv+mXruaPkOS6pCAlcyIKIAotIzogYnVpbHRpbi9wdWxsLmM6ODYxCisjOiBidWlsdGluL3B1bGwuYzo4NjcKIG1zZ2lkICJpZ25vcmluZyAtLXZlcmlmeS1zaWduYXR1cmVzIGZvciByZWJhc2UiCiBtc2dzdHIgIuS4uuWPmOWfuuaTjeS9nOW/veeVpSAtLXZlcmlmeS1zaWduYXR1cmVzIgogCi0jOiBidWlsdGluL3B1bGwuYzo5MTYKKyM6IGJ1aWx0aW4vcHVsbC5jOjkyMgogbXNnaWQgIi0tW25vLV1hdXRvc3Rhc2ggb3B0aW9uIGlzIG9ubHkgdmFsaWQgd2l0aCAtLXJlYmFzZS4iCiBtc2dzdHIgIi0tW25vLV1hdXRvc3Rhc2gg6YCJ6aG55Y+q5Zyo5L2/55SoIC0tcmViYXNlIOaXtuacieaViOOAgiIKIAotIzogYnVpbHRpbi9wdWxsLmM6OTI0CisjOiBidWlsdGluL3B1bGwuYzo5MzAKIG1zZ2lkICJVcGRhdGluZyBhbiB1bmJvcm4gYnJhbmNoIHdpdGggY2hhbmdlcyBhZGRlZCB0byB0aGUgaW5kZXguIgogbXNnc3RyICLmm7TmlrDlsJrmnKror57nlJ/nmoTliIbmlK/vvIzlj5jmm7Tmt7vliqDoh7PntKLlvJXjgIIiCiAKLSM6IGJ1aWx0aW4vcHVsbC5jOjkyOAorIzogYnVpbHRpbi9wdWxsLmM6OTM0CiBtc2dpZCAicHVsbCB3aXRoIHJlYmFzZSIKIG1zZ3N0ciAi5Y+Y5Z+65byP5ouJ5Y+WIgogCi0jOiBidWlsdGluL3B1bGwuYzo5MjkKKyM6IGJ1aWx0aW4vcHVsbC5jOjkzNQogbXNnaWQgInBsZWFzZSBjb21taXQgb3Igc3Rhc2ggdGhlbS4iCiBtc2dzdHIgIuivt+aPkOS6pOaIlui0ruiXj+Wug+S7rOOAgiIKIAotIzogYnVpbHRpbi9wdWxsLmM6OTU0CisjOiBidWlsdGluL3B1bGwuYzo5NjAKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogImZldGNoIHVwZGF0ZWQgdGhlIGN1cnJlbnQgYnJhbmNoIGhlYWQuXG4iCkBAIC0xNjM5OSw3ICsxNjQ4Niw3IEBACiAiZmV0Y2gg5pu05paw5LqG5b2T5YmN55qE5YiG5pSv44CC5b+r6L+b5oKo55qE5bel5L2c5Yy6XG4iCiAi6Iez5o+Q5LqkICVz44CCIgogCi0jOiBidWlsdGluL3B1bGwuYzo5NjAKKyM6IGJ1aWx0aW4vcHVsbC5jOjk2NgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiQ2Fubm90IGZhc3QtZm9yd2FyZCB5b3VyIHdvcmtpbmcgdHJlZS5cbiIKQEAgLTE2NDE2LDE1ICsxNjUwMywxNSBAQAogIiQgZ2l0IHJlc2V0IC0taGFyZFxuIgogIuaBouWkjeS5i+WJjeeahOeKtuaAgeOAgiIKIAotIzogYnVpbHRpbi9wdWxsLmM6OTc1CisjOiBidWlsdGluL3B1bGwuYzo5ODEKIG1zZ2lkICJDYW5ub3QgbWVyZ2UgbXVsdGlwbGUgYnJhbmNoZXMgaW50byBlbXB0eSBoZWFkLiIKIG1zZ3N0ciAi5peg5rOV5bCG5aSa5Liq5YiG5pSv5ZCI5bm25Yiw56m65YiG5pSv44CCIgogCi0jOiBidWlsdGluL3B1bGwuYzo5NzkKKyM6IGJ1aWx0aW4vcHVsbC5jOjk4NQogbXNnaWQgIkNhbm5vdCByZWJhc2Ugb250byBtdWx0aXBsZSBicmFuY2hlcy4iCiBtc2dzdHIgIuaXoOazleWPmOWfuuWIsOWkmuS4quWIhuaUr+OAgiIKIAotIzogYnVpbHRpbi9wdWxsLmM6OTg2CisjOiBidWlsdGluL3B1bGwuYzo5OTIKIG1zZ2lkICJjYW5ub3QgcmViYXNlIHdpdGggbG9jYWxseSByZWNvcmRlZCBzdWJtb2R1bGUgbW9kaWZpY2F0aW9ucyIKIG1zZ3N0ciAi5pys5Zyw5a2Q5qih57uE5Lit5pyJ5L+u5pS577yM5peg5rOV5Y+Y5Z+6IgogCkBAIC0xNjU3MiwxNyArMTY2NTksOTQgQEAKIG1zZ2lkICJQdXNoaW5nIHRvICVzXG4iCiBtc2dzdHIgIuaOqOmAgeWIsCAlc1xuIgogCi0jOiBidWlsdGluL3B1c2guYzozNjQKKyM6IGJ1aWx0aW4vcHVzaC5jOjM2NgogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gcHVzaCBzb21lIHJlZnMgdG8gJyVzJyIKIG1zZ3N0ciAi5o6o6YCB5LiA5Lqb5byV55So5YiwICclcycg5aSx6LSlIgogCi0jOiBidWlsdGluL3B1c2guYzozOTgKKyM6IGJ1aWx0aW4vcHVzaC5jOjU0MQorbXNnaWQgInJlcG9zaXRvcnkiCittc2dzdHIgIuS7k+W6kyIKKworIzogYnVpbHRpbi9wdXNoLmM6NTQyIGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTY0Cittc2dpZCAicHVzaCBhbGwgcmVmcyIKK21zZ3N0ciAi5o6o6YCB5omA5pyJ5byV55SoIgorCisjOiBidWlsdGluL3B1c2guYzo1NDMgYnVpbHRpbi9zZW5kLXBhY2suYzoxNjYKK21zZ2lkICJtaXJyb3IgYWxsIHJlZnMiCittc2dzdHIgIumVnOWDj+aJgOacieW8leeUqCIKKworIzogYnVpbHRpbi9wdXNoLmM6NTQ1Cittc2dpZCAiZGVsZXRlIHJlZnMiCittc2dzdHIgIuWIoOmZpOW8leeUqCIKKworIzogYnVpbHRpbi9wdXNoLmM6NTQ2Cittc2dpZCAicHVzaCB0YWdzIChjYW4ndCBiZSB1c2VkIHdpdGggLS1hbGwgb3IgLS1taXJyb3IpIgorbXNnc3RyICLmjqjpgIHmoIfnrb7vvIjkuI3og73kvb/nlKggLS1hbGwgb3IgLS1taXJyb3LvvIkiCisKKyM6IGJ1aWx0aW4vcHVzaC5jOjU0OSBidWlsdGluL3NlbmQtcGFjay5jOjE2NworbXNnaWQgImZvcmNlIHVwZGF0ZXMiCittc2dzdHIgIuW8uuWItuabtOaWsCIKKworIzogYnVpbHRpbi9wdXNoLmM6NTUxIGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTgxCittc2dpZCAiPHJlZm5hbWU+OjxleHBlY3Q+IgorbXNnc3RyICI85byV55So5ZCNPjo85pyf5pyb5YC8PiIKKworIzogYnVpbHRpbi9wdXNoLmM6NTUyIGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTgyCittc2dpZCAicmVxdWlyZSBvbGQgdmFsdWUgb2YgcmVmIHRvIGJlIGF0IHRoaXMgdmFsdWUiCittc2dzdHIgIuimgeaxguW8leeUqOaXp+eahOWPluWAvOS4uuiuvuWumuWAvCIKKworIzogYnVpbHRpbi9wdXNoLmM6NTU1Cittc2dpZCAiY29udHJvbCByZWN1cnNpdmUgcHVzaGluZyBvZiBzdWJtb2R1bGVzIgorbXNnc3RyICLmjqfliLblrZDmqKHnu4TnmoTpgJLlvZLmjqjpgIEiCisKKyM6IGJ1aWx0aW4vcHVzaC5jOjU1NyBidWlsdGluL3NlbmQtcGFjay5jOjE3NQorbXNnaWQgInVzZSB0aGluIHBhY2siCittc2dzdHIgIuS9v+eUqOeyvueugOaJk+WMhSIKKworIzogYnVpbHRpbi9wdXNoLmM6NTU4IGJ1aWx0aW4vcHVzaC5jOjU1OSBidWlsdGluL3NlbmQtcGFjay5jOjE2MQorIzogYnVpbHRpbi9zZW5kLXBhY2suYzoxNjIKK21zZ2lkICJyZWNlaXZlIHBhY2sgcHJvZ3JhbSIKK21zZ3N0ciAi5o6l5pS25YyF56iL5bqPIgorCisjOiBidWlsdGluL3B1c2guYzo1NjAKK21zZ2lkICJzZXQgdXBzdHJlYW0gZm9yIGdpdCBwdWxsL3N0YXR1cyIKK21zZ3N0ciAi6K6+572uIGdpdCBwdWxsL3N0YXR1cyDnmoTkuIrmuLgiCisKKyM6IGJ1aWx0aW4vcHVzaC5jOjU2MworbXNnaWQgInBydW5lIGxvY2FsbHkgcmVtb3ZlZCByZWZzIgorbXNnc3RyICLmuIXpmaTmnKzlnLDliKDpmaTnmoTlvJXnlKgiCisKKyM6IGJ1aWx0aW4vcHVzaC5jOjU2NQorbXNnaWQgImJ5cGFzcyBwcmUtcHVzaCBob29rIgorbXNnc3RyICLnu5Xov4cgcHJlLXB1c2gg6ZKp5a2QIgorCisjOiBidWlsdGluL3B1c2guYzo1NjYKK21zZ2lkICJwdXNoIG1pc3NpbmcgYnV0IHJlbGV2YW50IHRhZ3MiCittc2dzdHIgIuaOqOmAgee8uuWkseS9huacieWFs+eahOagh+etviIKKworIzogYnVpbHRpbi9wdXNoLmM6NTY5IGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTY5Cittc2dpZCAiR1BHIHNpZ24gdGhlIHB1c2giCittc2dzdHIgIueUqCBHUEcg5Li65o6o6YCB562+5ZCNIgorCisjOiBidWlsdGluL3B1c2guYzo1NzEgYnVpbHRpbi9zZW5kLXBhY2suYzoxNzYKK21zZ2lkICJyZXF1ZXN0IGF0b21pYyB0cmFuc2FjdGlvbiBvbiByZW1vdGUgc2lkZSIKK21zZ3N0ciAi6ZyA6KaB6L+c56uv5pSv5oyB5Y6f5a2Q5LqL5YqhIgorCisjOiBidWlsdGluL3B1c2guYzo1ODkKK21zZ2lkICItLWRlbGV0ZSBpcyBpbmNvbXBhdGlibGUgd2l0aCAtLWFsbCwgLS1taXJyb3IgYW5kIC0tdGFncyIKK21zZ3N0ciAiLS1kZWxldGUg5LiOIC0tYWxs44CBLS1taXJyb3Ig5Y+KIC0tdGFncyDkuI3lhbzlrrkiCisKKyM6IGJ1aWx0aW4vcHVzaC5jOjU5MQorbXNnaWQgIi0tZGVsZXRlIGRvZXNuJ3QgbWFrZSBzZW5zZSB3aXRob3V0IGFueSByZWZzIgorbXNnc3RyICItLWRlbGV0ZSDmnKrmjqXku7vkvZXlvJXnlKjmsqHmnInmhI/kuYkiCisKKyM6IGJ1aWx0aW4vcHVzaC5jOjYxMQogIywgYy1mb3JtYXQKIG1zZ2lkICJiYWQgcmVwb3NpdG9yeSAnJXMnIgogbXNnc3RyICLlnY/nmoTku5PlupMgJyVzJyIKIAotIzogYnVpbHRpbi9wdXNoLmM6Mzk5CisjOiBidWlsdGluL3B1c2guYzo2MTIKIG1zZ2lkICIiCiAiTm8gY29uZmlndXJlZCBwdXNoIGRlc3RpbmF0aW9uLlxuIgogIkVpdGhlciBzcGVjaWZ5IHRoZSBVUkwgZnJvbSB0aGUgY29tbWFuZC1saW5lIG9yIGNvbmZpZ3VyZSBhIHJlbW90ZSAiCkBAIC0xNjYwMywxMDQgKzE2NzY3LDI3IEBACiAiXG4iCiAiICAgIGdpdCBwdXNoIDzlkI3np7A+XG4iCiAKLSM6IGJ1aWx0aW4vcHVzaC5jOjU1NAotbXNnaWQgInJlcG9zaXRvcnkiCi1tc2dzdHIgIuS7k+W6kyIKLQotIzogYnVpbHRpbi9wdXNoLmM6NTU1IGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTY0Ci1tc2dpZCAicHVzaCBhbGwgcmVmcyIKLW1zZ3N0ciAi5o6o6YCB5omA5pyJ5byV55SoIgotCi0jOiBidWlsdGluL3B1c2guYzo1NTYgYnVpbHRpbi9zZW5kLXBhY2suYzoxNjYKLW1zZ2lkICJtaXJyb3IgYWxsIHJlZnMiCi1tc2dzdHIgIumVnOWDj+aJgOacieW8leeUqCIKLQotIzogYnVpbHRpbi9wdXNoLmM6NTU4Ci1tc2dpZCAiZGVsZXRlIHJlZnMiCi1tc2dzdHIgIuWIoOmZpOW8leeUqCIKLQotIzogYnVpbHRpbi9wdXNoLmM6NTU5Ci1tc2dpZCAicHVzaCB0YWdzIChjYW4ndCBiZSB1c2VkIHdpdGggLS1hbGwgb3IgLS1taXJyb3IpIgotbXNnc3RyICLmjqjpgIHmoIfnrb7vvIjkuI3og73kvb/nlKggLS1hbGwgb3IgLS1taXJyb3LvvIkiCi0KLSM6IGJ1aWx0aW4vcHVzaC5jOjU2MiBidWlsdGluL3NlbmQtcGFjay5jOjE2NwotbXNnaWQgImZvcmNlIHVwZGF0ZXMiCi1tc2dzdHIgIuW8uuWItuabtOaWsCIKLQotIzogYnVpbHRpbi9wdXNoLmM6NTY0IGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTgxCi1tc2dpZCAiPHJlZm5hbWU+OjxleHBlY3Q+IgotbXNnc3RyICI85byV55So5ZCNPjo85pyf5pyb5YC8PiIKLQotIzogYnVpbHRpbi9wdXNoLmM6NTY1IGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTgyCi1tc2dpZCAicmVxdWlyZSBvbGQgdmFsdWUgb2YgcmVmIHRvIGJlIGF0IHRoaXMgdmFsdWUiCi1tc2dzdHIgIuimgeaxguW8leeUqOaXp+eahOWPluWAvOS4uuiuvuWumuWAvCIKLQotIzogYnVpbHRpbi9wdXNoLmM6NTY4Ci1tc2dpZCAiY29udHJvbCByZWN1cnNpdmUgcHVzaGluZyBvZiBzdWJtb2R1bGVzIgotbXNnc3RyICLmjqfliLblrZDmqKHnu4TnmoTpgJLlvZLmjqjpgIEiCi0KLSM6IGJ1aWx0aW4vcHVzaC5jOjU3MCBidWlsdGluL3NlbmQtcGFjay5jOjE3NQotbXNnaWQgInVzZSB0aGluIHBhY2siCi1tc2dzdHIgIuS9v+eUqOeyvueugOaJk+WMhSIKLQotIzogYnVpbHRpbi9wdXNoLmM6NTcxIGJ1aWx0aW4vcHVzaC5jOjU3MiBidWlsdGluL3NlbmQtcGFjay5jOjE2MQotIzogYnVpbHRpbi9zZW5kLXBhY2suYzoxNjIKLW1zZ2lkICJyZWNlaXZlIHBhY2sgcHJvZ3JhbSIKLW1zZ3N0ciAi5o6l5pS25YyF56iL5bqPIgotCi0jOiBidWlsdGluL3B1c2guYzo1NzMKLW1zZ2lkICJzZXQgdXBzdHJlYW0gZm9yIGdpdCBwdWxsL3N0YXR1cyIKLW1zZ3N0ciAi6K6+572uIGdpdCBwdWxsL3N0YXR1cyDnmoTkuIrmuLgiCi0KLSM6IGJ1aWx0aW4vcHVzaC5jOjU3NgotbXNnaWQgInBydW5lIGxvY2FsbHkgcmVtb3ZlZCByZWZzIgotbXNnc3RyICLmuIXpmaTmnKzlnLDliKDpmaTnmoTlvJXnlKgiCi0KLSM6IGJ1aWx0aW4vcHVzaC5jOjU3OAotbXNnaWQgImJ5cGFzcyBwcmUtcHVzaCBob29rIgotbXNnc3RyICLnu5Xov4cgcHJlLXB1c2gg6ZKp5a2QIgotCi0jOiBidWlsdGluL3B1c2guYzo1NzkKLW1zZ2lkICJwdXNoIG1pc3NpbmcgYnV0IHJlbGV2YW50IHRhZ3MiCi1tc2dzdHIgIuaOqOmAgee8uuWkseS9huacieWFs+eahOagh+etviIKLQotIzogYnVpbHRpbi9wdXNoLmM6NTgyIGJ1aWx0aW4vc2VuZC1wYWNrLmM6MTY5Ci1tc2dpZCAiR1BHIHNpZ24gdGhlIHB1c2giCi1tc2dzdHIgIueUqCBHUEcg5Li65o6o6YCB562+5ZCNIgotCi0jOiBidWlsdGluL3B1c2guYzo1ODQgYnVpbHRpbi9zZW5kLXBhY2suYzoxNzYKLW1zZ2lkICJyZXF1ZXN0IGF0b21pYyB0cmFuc2FjdGlvbiBvbiByZW1vdGUgc2lkZSIKLW1zZ3N0ciAi6ZyA6KaB6L+c56uv5pSv5oyB5Y6f5a2Q5LqL5YqhIgotCi0jOiBidWlsdGluL3B1c2guYzo2MDIKLW1zZ2lkICItLWRlbGV0ZSBpcyBpbmNvbXBhdGlibGUgd2l0aCAtLWFsbCwgLS1taXJyb3IgYW5kIC0tdGFncyIKLW1zZ3N0ciAiLS1kZWxldGUg5LiOIC0tYWxs44CBLS1taXJyb3Ig5Y+KIC0tdGFncyDkuI3lhbzlrrkiCi0KLSM6IGJ1aWx0aW4vcHVzaC5jOjYwNAotbXNnaWQgIi0tZGVsZXRlIGRvZXNuJ3QgbWFrZSBzZW5zZSB3aXRob3V0IGFueSByZWZzIgotbXNnc3RyICItLWRlbGV0ZSDmnKrmjqXku7vkvZXlvJXnlKjmsqHmnInmhI/kuYkiCi0KLSM6IGJ1aWx0aW4vcHVzaC5jOjYwNworIzogYnVpbHRpbi9wdXNoLmM6NjI3CiBtc2dpZCAiLS1hbGwgYW5kIC0tdGFncyBhcmUgaW5jb21wYXRpYmxlIgogbXNnc3RyICItLWFsbCDlkowgLS10YWdzIOS4jeWFvOWuuSIKIAotIzogYnVpbHRpbi9wdXNoLmM6NjA5CisjOiBidWlsdGluL3B1c2guYzo2MjkKIG1zZ2lkICItLWFsbCBjYW4ndCBiZSBjb21iaW5lZCB3aXRoIHJlZnNwZWNzIgogbXNnc3RyICItLWFsbCDkuI3og73lkozlvJXnlKjop4TmoLzlkIzml7bkvb/nlKgiCiAKLSM6IGJ1aWx0aW4vcHVzaC5jOjYxMworIzogYnVpbHRpbi9wdXNoLmM6NjMzCiBtc2dpZCAiLS1taXJyb3IgYW5kIC0tdGFncyBhcmUgaW5jb21wYXRpYmxlIgogbXNnc3RyICItLW1pcnJvciDlkowgLS10YWdzIOS4jeWFvOWuuSIKIAotIzogYnVpbHRpbi9wdXNoLmM6NjE1CisjOiBidWlsdGluL3B1c2guYzo2MzUKIG1zZ2lkICItLW1pcnJvciBjYW4ndCBiZSBjb21iaW5lZCB3aXRoIHJlZnNwZWNzIgogbXNnc3RyICItLW1pcnJvciDkuI3og73lkozlvJXnlKjop4TmoLzlkIzml7bkvb/nlKgiCiAKLSM6IGJ1aWx0aW4vcHVzaC5jOjYxOAorIzogYnVpbHRpbi9wdXNoLmM6NjM4CiBtc2dpZCAiLS1hbGwgYW5kIC0tbWlycm9yIGFyZSBpbmNvbXBhdGlibGUiCiBtc2dzdHIgIi0tYWxsIOWSjCAtLW1pcnJvciDkuI3lhbzlrrkiCiAKLSM6IGJ1aWx0aW4vcHVzaC5jOjYzNworIzogYnVpbHRpbi9wdXNoLmM6NjQyCiBtc2dpZCAicHVzaCBvcHRpb25zIG11c3Qgbm90IGhhdmUgbmV3IGxpbmUgY2hhcmFjdGVycyIKIG1zZ3N0ciAi5o6o6YCB6YCJ6aG55LiN6IO95pyJ5o2i6KGM56ymIgogCkBAIC0xNjgxNywxMCArMTY5MDQsOSBAQAogCiAjOiBidWlsdGluL3JlYmFzZS5jOjMyCiBtc2dpZCAiIgotImdpdCByZWJhc2UgWy1pXSBbb3B0aW9uc10gWy0tZXhlYyA8Y21kPl0gWy0tb250byA8bmV3YmFzZT5dIFs8dXBzdHJlYW0+XSAiCi0iWzxicmFuY2g+XSIKLW1zZ3N0ciAiIgotImdpdCByZWJhc2UgWy1pXSBb6YCJ6aG5XSBbLS1leGVjIDzlkb3ku6Q+XSBbLS1vbnRvIDzmlrDln7rnur8+XSBbPOS4iua4uD5dIFs85YiG5pSvPl0iCisiZ2l0IHJlYmFzZSBbLWldIFtvcHRpb25zXSBbLS1leGVjIDxjbWQ+XSBbLS1vbnRvIDxuZXdiYXNlPiB8IC0ta2VlcC1iYXNlXSAiCisiWzx1cHN0cmVhbT4gWzxicmFuY2g+XV0iCittc2dzdHIgImdpdCByZWJhc2UgWy1pXSBbb3B0aW9uc10gWy0tZXhlYyA85ZG95LukPl0gWy0tb250byA85paw5Z+657q/PiB8IC0ta2VlcC1iYXNlXSBbPOS4iua4uD4gWzzliIbmlK8+XV0iCiAKICM6IGJ1aWx0aW4vcmViYXNlLmM6MzQKIG1zZ2lkICIiCkBAIC0xNjg1OSwxODkgKzE2OTQ1LDE4OSBAQAogbXNnaWQgImNvdWxkIG5vdCBnZW5lcmF0ZSB0b2RvIGxpc3QiCiBtc2dzdHIgIuaXoOazleeUn+aIkOW+heWKnuWIl+ihqCIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzozODIKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MzgzCiBtc2dpZCAiYSBiYXNlIGNvbW1pdCBtdXN0IGJlIHByb3ZpZGVkIHdpdGggLS11cHN0cmVhbSBvciAtLW9udG8iCiBtc2dzdHIgIuS9v+eUqCAtLXVwc3RyZWFtIOaIliAtLW9udG8g5b+F6aG75o+Q5L6b5LiA5Liq5Z+657q/5o+Q5LqkIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQzNworIzogYnVpbHRpbi9yZWJhc2UuYzo0MzgKIG1zZ2lkICJnaXQgcmViYXNlLS1pbnRlcmFjdGl2ZSBbPG9wdGlvbnM+XSIKIG1zZ3N0ciAiZ2l0IHJlYmFzZS0taW50ZXJhY3RpdmUgWzzpgInpobk+XSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0NDkKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDUwCiBtc2dpZCAia2VlcCBlbXB0eSBjb21taXRzIgogbXNnc3RyICLkv53mjIHnqbrmj5DkuqQiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDUxIGJ1aWx0aW4vcmV2ZXJ0LmM6MTI4CisjOiBidWlsdGluL3JlYmFzZS5jOjQ1MiBidWlsdGluL3JldmVydC5jOjEyOAogbXNnaWQgImFsbG93IGNvbW1pdHMgd2l0aCBlbXB0eSBtZXNzYWdlcyIKIG1zZ3N0ciAi5YWB6K645o+Q5Lqk6K+05piO5Li656m6IgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ1MgorIzogYnVpbHRpbi9yZWJhc2UuYzo0NTMKIG1zZ2lkICJyZWJhc2UgbWVyZ2UgY29tbWl0cyIKIG1zZ3N0ciAi5a+55ZCI5bm25o+Q5Lqk5Y+Y5Z+6IgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ1NAorIzogYnVpbHRpbi9yZWJhc2UuYzo0NTUKIG1zZ2lkICJrZWVwIG9yaWdpbmFsIGJyYW5jaCBwb2ludHMgb2YgY291c2lucyIKIG1zZ3N0ciAi5L+d5oyB5YWE5byf5o+Q5Lqk55qE5Y6f5aeL5YiG5pSv54K5IgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ1NgorIzogYnVpbHRpbi9yZWJhc2UuYzo0NTcKIG1zZ2lkICJtb3ZlIGNvbW1pdHMgdGhhdCBiZWdpbiB3aXRoIHNxdWFzaCEvZml4dXAhIgogbXNnc3RyICLnp7vliqjku6Ugc3F1YXNoIS9maXh1cCEg5byA5aS055qE5o+Q5LqkIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ1NworIzogYnVpbHRpbi9yZWJhc2UuYzo0NTgKIG1zZ2lkICJzaWduIGNvbW1pdHMiCiBtc2dzdHIgIuetvuWQjeaPkOS6pCIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0NTkgYnVpbHRpbi9yZWJhc2UuYzoxNDAzCisjOiBidWlsdGluL3JlYmFzZS5jOjQ2MCBidWlsdGluL3JlYmFzZS5jOjE0MjcKIG1zZ2lkICJkaXNwbGF5IGEgZGlmZnN0YXQgb2Ygd2hhdCBjaGFuZ2VkIHVwc3RyZWFtIgogbXNnc3RyICLmmL7npLrkuIrmuLjlj5jljJbnmoTlt67lvILnu5/orqEiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDYxCisjOiBidWlsdGluL3JlYmFzZS5jOjQ2MgogbXNnaWQgImNvbnRpbnVlIHJlYmFzZSIKIG1zZ3N0ciAi57un57ut5Y+Y5Z+6IgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ2MworIzogYnVpbHRpbi9yZWJhc2UuYzo0NjQKIG1zZ2lkICJza2lwIGNvbW1pdCIKIG1zZ3N0ciAi6Lez6L+H5o+Q5LqkIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ2NAorIzogYnVpbHRpbi9yZWJhc2UuYzo0NjUKIG1zZ2lkICJlZGl0IHRoZSB0b2RvIGxpc3QiCiBtc2dzdHIgIuWPmOWfuuW+heWKnuWIl+ihqCIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0NjYKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDY3CiBtc2dpZCAic2hvdyB0aGUgY3VycmVudCBwYXRjaCIKIG1zZ3N0ciAi5pi+56S65b2T5YmN6KGl5LiBIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ2OQorIzogYnVpbHRpbi9yZWJhc2UuYzo0NzAKIG1zZ2lkICJzaG9ydGVuIGNvbW1pdCBpZHMgaW4gdGhlIHRvZG8gbGlzdCIKIG1zZ3N0ciAi57yp55+t5b6F5Yqe5YiX6KGo5Lit55qE5o+Q5Lqk5Y+3IgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ3MQorIzogYnVpbHRpbi9yZWJhc2UuYzo0NzIKIG1zZ2lkICJleHBhbmQgY29tbWl0IGlkcyBpbiB0aGUgdG9kbyBsaXN0IgogbXNnc3RyICLmianlsZXlvoXlip7liJfooajkuK3nmoTmj5DkuqTlj7ciCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDczCisjOiBidWlsdGluL3JlYmFzZS5jOjQ3NAogbXNnaWQgImNoZWNrIHRoZSB0b2RvIGxpc3QiCiBtc2dzdHIgIuajgOafpeW+heWKnuWIl+ihqCIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0NzUKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDc2CiBtc2dpZCAicmVhcnJhbmdlIGZpeHVwL3NxdWFzaCBsaW5lcyIKIG1zZ3N0ciAi6YeN5paw5o6S5YiXIGZpeHVwL3NxdWFzaCDooYwiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDc3CisjOiBidWlsdGluL3JlYmFzZS5jOjQ3OAogbXNnaWQgImluc2VydCBleGVjIGNvbW1hbmRzIGluIHRvZG8gbGlzdCIKIG1zZ3N0ciAi5Zyo5b6F5Yqe5YiX6KGo5Lit5o+S5YWlIGV4ZWMg5omn6KGM5ZG95LukIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ3OAorIzogYnVpbHRpbi9yZWJhc2UuYzo0NzkKIG1zZ2lkICJvbnRvIgogbXNnc3RyICJvbnRvIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ4MQorIzogYnVpbHRpbi9yZWJhc2UuYzo0ODIKIG1zZ2lkICJyZXN0cmljdC1yZXZpc2lvbiIKIG1zZ3N0ciAicmVzdHJpY3QtcmV2aXNpb24iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDgxCisjOiBidWlsdGluL3JlYmFzZS5jOjQ4MgogbXNnaWQgInJlc3RyaWN0IHJldmlzaW9uIgogbXNnc3RyICLpmZDliLbniYjmnKwiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDgzCisjOiBidWlsdGluL3JlYmFzZS5jOjQ4NAogbXNnaWQgInNxdWFzaC1vbnRvIgogbXNnc3RyICJzcXVhc2gtb250byIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0ODQKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDg1CiBtc2dpZCAic3F1YXNoIG9udG8iCiBtc2dzdHIgInNxdWFzaCBvbnRvIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ4NgorIzogYnVpbHRpbi9yZWJhc2UuYzo0ODcKIG1zZ2lkICJ0aGUgdXBzdHJlYW0gY29tbWl0IgogbXNnc3RyICLkuIrmuLjmj5DkuqQiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDg4CisjOiBidWlsdGluL3JlYmFzZS5jOjQ4OQogbXNnaWQgImhlYWQtbmFtZSIKIG1zZ3N0ciAiaGVhZC1uYW1lIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ4OAorIzogYnVpbHRpbi9yZWJhc2UuYzo0ODkKIG1zZ2lkICJoZWFkIG5hbWUiCiBtc2dzdHIgImhlYWQg5ZCN56ewIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ5MworIzogYnVpbHRpbi9yZWJhc2UuYzo0OTQKIG1zZ2lkICJyZWJhc2Ugc3RyYXRlZ3kiCiBtc2dzdHIgIuWPmOWfuuetlueVpSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0OTQKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDk1CiBtc2dpZCAic3RyYXRlZ3ktb3B0cyIKIG1zZ3N0ciAic3RyYXRlZ3ktb3B0cyIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0OTUKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDk2CiBtc2dpZCAic3RyYXRlZ3kgb3B0aW9ucyIKIG1zZ3N0ciAi562W55Wl6YCJ6aG5IgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ5NgorIzogYnVpbHRpbi9yZWJhc2UuYzo0OTcKIG1zZ2lkICJzd2l0Y2gtdG8iCiBtc2dzdHIgIuWIh+aNouWIsCIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0OTcKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDk4CiBtc2dpZCAidGhlIGJyYW5jaCBvciBjb21taXQgdG8gY2hlY2tvdXQiCiBtc2dzdHIgIuimgeajgOWHuueahOWIhuaUr+aIluaPkOS6pCIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0OTgKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NDk5CiBtc2dpZCAib250by1uYW1lIgogbXNnc3RyICJvbnRvLW5hbWUiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NDk4CisjOiBidWlsdGluL3JlYmFzZS5jOjQ5OQogbXNnaWQgIm9udG8gbmFtZSIKIG1zZ3N0ciAib250byBuYW1lIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjQ5OQorIzogYnVpbHRpbi9yZWJhc2UuYzo1MDAKIG1zZ2lkICJjbWQiCiBtc2dzdHIgImNtZCIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo0OTkKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NTAwCiBtc2dpZCAidGhlIGNvbW1hbmQgdG8gcnVuIgogbXNnc3RyICLopoHmiafooYznmoTlkb3ku6QiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NTAyIGJ1aWx0aW4vcmViYXNlLmM6MTQ4NgorIzogYnVpbHRpbi9yZWJhc2UuYzo1MDMgYnVpbHRpbi9yZWJhc2UuYzoxNTEwCiBtc2dpZCAiYXV0b21hdGljYWxseSByZS1zY2hlZHVsZSBhbnkgYGV4ZWNgIHRoYXQgZmFpbHMiCiBtc2dzdHIgIuiHquWKqOmHjeaWsOWuieaOkuS7u+S9leWksei0peeahCBgZXhlY2AiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NTE4CisjOiBidWlsdGluL3JlYmFzZS5jOjUxOQogbXNnaWQgIi0tW25vLV1yZWJhc2UtY291c2lucyBoYXMgbm8gZWZmZWN0IHdpdGhvdXQgLS1yZWJhc2UtbWVyZ2VzIgogbXNnc3RyICLkuI3kvb/nlKggLS1yZWJhc2UtbWVyZ2Vz77yM5YiZIC0tW25vLV1yZWJhc2UtY291c2lucyDmsqHmnInmlYjmnpwiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NTM0CisjOiBidWlsdGluL3JlYmFzZS5jOjUzNQogIywgYy1mb3JtYXQKIG1zZ2lkICIlcyByZXF1aXJlcyBhbiBpbnRlcmFjdGl2ZSByZWJhc2UiCiBtc2dzdHIgIiVzIOmcgOimgeS6pOS6kuW8j+WPmOWfuiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo1ODYKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NTg3CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBnZXQgJ29udG8nOiAnJXMnIgogbXNnc3RyICLml6Dms5Xojrflj5YgJ29udG8n77yaJyVzJyIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo2MDEKKyM6IGJ1aWx0aW4vcmViYXNlLmM6NjAyCiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgb3JpZy1oZWFkOiAnJXMnIgogbXNnc3RyICLml6DmlYjnmoTljp/lp4sgaGVhZO+8miclcyciCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NjI2CisjOiBidWlsdGluL3JlYmFzZS5jOjYyNwogIywgYy1mb3JtYXQKIG1zZ2lkICJpZ25vcmluZyBpbnZhbGlkIGFsbG93X3JlcmVyZV9hdXRvdXBkYXRlOiAnJXMnIgogbXNnc3RyICLlv73nlaXml6DmlYjnmoQgYWxsb3dfcmVyZXJlX2F1dG91cGRhdGXvvJonJXMnIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjcwMgorIzogYnVpbHRpbi9yZWJhc2UuYzo3MDMKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ291bGQgbm90IHJlYWQgJyVzJyIKIG1zZ3N0ciAi5LiN6IO96K+75Y+WICclcyciCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6NzIwCisjOiBidWlsdGluL3JlYmFzZS5jOjcyMQogIywgYy1mb3JtYXQKIG1zZ2lkICJDYW5ub3Qgc3RvcmUgJXMiCiBtc2dzdHIgIuS4jeiDveWtmOWCqCAlcyIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzo4MjcKKyM6IGJ1aWx0aW4vcmViYXNlLmM6ODI4CiBtc2dpZCAiY291bGQgbm90IGRldGVybWluZSBIRUFEIHJldmlzaW9uIgogbXNnc3RyICLkuI3og73noa7lrpogSEVBRCDniYjmnKwiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6OTUwIGdpdC1yZWJhc2UtLXByZXNlcnZlLW1lcmdlcy5zaDo4MQorIzogYnVpbHRpbi9yZWJhc2UuYzo5NTEgZ2l0LXJlYmFzZS0tcHJlc2VydmUtbWVyZ2VzLnNoOjgxCiBtc2dpZCAiIgogIlJlc29sdmUgYWxsIGNvbmZsaWN0cyBtYW51YWxseSwgbWFyayB0aGVtIGFzIHJlc29sdmVkIHdpdGhcbiIKICJcImdpdCBhZGQvcm0gPGNvbmZsaWN0ZWRfZmlsZXM+XCIsIHRoZW4gcnVuIFwiZ2l0IHJlYmFzZSAtLWNvbnRpbnVlXCIuXG4iCkBAIC0xNzA1NCw3ICsxNzE0MCw3IEBACiAiXCJnaXQgcmViYXNlIC0tc2tpcFwiIOWRveS7pOi3s+i/h+i/meS4quaPkOS6pOOAguWmguaenOaDs+imgee7iOatouaJp+ihjOW5tuWbnuWIsFxuIgogIlwiZ2l0IHJlYmFzZVwiIOaJp+ihjOS5i+WJjeeahOeKtuaAge+8jOaJp+ihjCBcImdpdCByZWJhc2UgLS1hYm9ydFwi44CCIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjEwMzEKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTAzMgogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiXG4iCkBAIC0xNzA3Miw3ICsxNzE1OCw3IEBACiAiXG4iCiAi5Zug5q2kIGdpdCDml6Dms5Xlr7nlhbblj5jln7rjgIIiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTMxOAorIzogYnVpbHRpbi9yZWJhc2UuYzoxMzM5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICIlc1xuIgpAQCAtMTcwODksNyArMTcxNzUsNyBAQAogIiAgICBnaXQgcmViYXNlICc8YnJhbmNoPidcbiIKICJcbiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxMzM0CisjOiBidWlsdGluL3JlYmFzZS5jOjEzNTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIklmIHlvdSB3aXNoIHRvIHNldCB0cmFja2luZyBpbmZvcm1hdGlvbiBmb3IgdGhpcyBicmFuY2ggeW91IGNhbiBkbyBzbyB3aXRoOlxuIgpAQCAtMTcxMDIsMTI4ICsxNzE4OCwxMzIgQEAKICIgICAgZ2l0IGJyYW5jaCAtLXNldC11cHN0cmVhbS10bz0lcy88YnJhbmNoPiAlc1xuIgogIlxuIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjEzNjQKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTM4NQogbXNnaWQgImV4ZWMgY29tbWFuZHMgY2Fubm90IGNvbnRhaW4gbmV3bGluZXMiCiBtc2dzdHIgImV4ZWMg5ZG95Luk5LiN6IO95YyF5ZCr5o2i6KGM56ymIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjEzNjgKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTM4OQogbXNnaWQgImVtcHR5IGV4ZWMgY29tbWFuZCIKIG1zZ3N0ciAi56m655qEIGV4ZWMg5ZG95LukIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjEzOTYKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQxOAogbXNnaWQgInJlYmFzZSBvbnRvIGdpdmVuIGJyYW5jaCBpbnN0ZWFkIG9mIHVwc3RyZWFtIgogbXNnc3RyICLlj5jln7rliLDnu5nlrprnmoTliIbmlK/ogIzpnZ7kuIrmuLgiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTM5OAorIzogYnVpbHRpbi9yZWJhc2UuYzoxNDIwCittc2dpZCAidXNlIHRoZSBtZXJnZS1iYXNlIG9mIHVwc3RyZWFtIGFuZCBicmFuY2ggYXMgdGhlIGN1cnJlbnQgYmFzZSIKK21zZ3N0ciAi5L2/55So5LiK5ri45ZKM5YiG5pSv55qE5ZCI5bm25Z+657q/5YGa5Li65b2T5YmN5Z+657q/IgorCisjOiBidWlsdGluL3JlYmFzZS5jOjE0MjIKIG1zZ2lkICJhbGxvdyBwcmUtcmViYXNlIGhvb2sgdG8gcnVuIgogbXNnc3RyICLlhYHorrjmiafooYwgcHJlLXJlYmFzZSDpkqnlrZAiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQwMAorIzogYnVpbHRpbi9yZWJhc2UuYzoxNDI0CiBtc2dpZCAiYmUgcXVpZXQuIGltcGxpZXMgLS1uby1zdGF0IgogbXNnc3RyICLlronpnZnjgILmmpfnpLogLS1uby1zdGF0IgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0MDYKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQzMAogbXNnaWQgImRvIG5vdCBzaG93IGRpZmZzdGF0IG9mIHdoYXQgY2hhbmdlZCB1cHN0cmVhbSIKIG1zZ3N0ciAi5LiN5pi+56S65LiK5ri45Y+Y5YyW55qE5beu5byC57uf6K6hIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0MDkKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQzMwogbXNnaWQgImFkZCBhIFNpZ25lZC1vZmYtYnk6IGxpbmUgdG8gZWFjaCBjb21taXQiCiBtc2dzdHIgIuS4uuavj+S4gOS4quaPkOS6pOa3u+WKoOS4gOS4qiBTaWduZWQtb2ZmLWJ5OiDnrb7lkI0iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQxMSBidWlsdGluL3JlYmFzZS5jOjE0MTUgYnVpbHRpbi9yZWJhc2UuYzoxNDE3CisjOiBidWlsdGluL3JlYmFzZS5jOjE0MzUgYnVpbHRpbi9yZWJhc2UuYzoxNDM5IGJ1aWx0aW4vcmViYXNlLmM6MTQ0MQogbXNnaWQgInBhc3NlZCB0byAnZ2l0IGFtJyIKIG1zZ3N0ciAi5Lyg6YCS57uZICdnaXQgYW0nIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0MTkgYnVpbHRpbi9yZWJhc2UuYzoxNDIxCisjOiBidWlsdGluL3JlYmFzZS5jOjE0NDMgYnVpbHRpbi9yZWJhc2UuYzoxNDQ1CiBtc2dpZCAicGFzc2VkIHRvICdnaXQgYXBwbHknIgogbXNnc3RyICLkvKDpgJLnu5kgJ2dpdCBhcHBseSciCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQyMyBidWlsdGluL3JlYmFzZS5jOjE0MjYKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ0NyBidWlsdGluL3JlYmFzZS5jOjE0NTAKIG1zZ2lkICJjaGVycnktcGljayBhbGwgY29tbWl0cywgZXZlbiBpZiB1bmNoYW5nZWQiCiBtc2dzdHIgIuaLo+mAieaJgOacieaPkOS6pO+8jOWNs+S9v+acquS/ruaUuSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDI4CisjOiBidWlsdGluL3JlYmFzZS5jOjE0NTIKIG1zZ2lkICJjb250aW51ZSIKIG1zZ3N0ciAi57un57utIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0MzEKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ1NQogbXNnaWQgInNraXAgY3VycmVudCBwYXRjaCBhbmQgY29udGludWUiCiBtc2dzdHIgIui3s+i/h+W9k+WJjeihpeS4geW5tue7p+e7rSIKIAogIyAg6K+R6ICF77ya5rOo5oSP5L+d5oyB5YmN5a+856m65qC8Ci0jOiBidWlsdGluL3JlYmFzZS5jOjE0MzMKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ1NwogbXNnaWQgImFib3J0IGFuZCBjaGVjayBvdXQgdGhlIG9yaWdpbmFsIGJyYW5jaCIKIG1zZ3N0ciAi57uI5q2i5bm25qOA5Ye65Y6f5pyJ5YiG5pSvIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0MzYKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ2MAogbXNnaWQgImFib3J0IGJ1dCBrZWVwIEhFQUQgd2hlcmUgaXQgaXMiCiBtc2dzdHIgIue7iOatouS9huS/neaMgSBIRUFEIOS4jeWPmCIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDM3CisjOiBidWlsdGluL3JlYmFzZS5jOjE0NjEKIG1zZ2lkICJlZGl0IHRoZSB0b2RvIGxpc3QgZHVyaW5nIGFuIGludGVyYWN0aXZlIHJlYmFzZSIKIG1zZ3N0ciAi5Zyo5Lqk5LqS5byP5Y+Y5Z+65Lit57yW6L6R5b6F5Yqe5YiX6KGoIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0NDAKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ2NAogbXNnaWQgInNob3cgdGhlIHBhdGNoIGZpbGUgYmVpbmcgYXBwbGllZCBvciBtZXJnZWQiCiBtc2dzdHIgIuaYvuekuuato+WcqOW6lOeUqOaIluWQiOW5tueahOihpeS4geaWh+S7tiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDQzCisjOiBidWlsdGluL3JlYmFzZS5jOjE0NjcKIG1zZ2lkICJ1c2UgbWVyZ2luZyBzdHJhdGVnaWVzIHRvIHJlYmFzZSIKIG1zZ3N0ciAi5L2/55So5ZCI5bm2562W55Wl6L+b6KGM5Y+Y5Z+6IgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0NDcKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ3MQogbXNnaWQgImxldCB0aGUgdXNlciBlZGl0IHRoZSBsaXN0IG9mIGNvbW1pdHMgdG8gcmViYXNlIgogbXNnc3RyICLorqnnlKjmiLfnvJbovpHopoHlj5jln7rnmoTmj5DkuqTliJfooagiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ1MQorIzogYnVpbHRpbi9yZWJhc2UuYzoxNDc1CiBtc2dpZCAiKERFUFJFQ0FURUQpIHRyeSB0byByZWNyZWF0ZSBtZXJnZXMgaW5zdGVhZCBvZiBpZ25vcmluZyB0aGVtIgogbXNnc3RyICLvvIjlt7LlvIPnlKjvvInlsJ3or5Xph43lu7rlkIjlubbmj5DkuqTogIzpnZ7lv73nlaXlroPku6wiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ1NQorIzogYnVpbHRpbi9yZWJhc2UuYzoxNDc5CiBtc2dpZCAicHJlc2VydmUgZW1wdHkgY29tbWl0cyBkdXJpbmcgcmViYXNlIgogbXNnc3RyICLlj5jln7rml7bkv53nlZnnqbrmj5DkuqQiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ1NworIzogYnVpbHRpbi9yZWJhc2UuYzoxNDgxCiBtc2dpZCAibW92ZSBjb21taXRzIHRoYXQgYmVnaW4gd2l0aCBzcXVhc2ghL2ZpeHVwISB1bmRlciAtaSIKIG1zZ3N0ciAi5ZyoIC1pIOS6pOS6kuaooeW8j+S4i++8jOenu+WKqOS7pSBzcXVhc2ghL2ZpeHVwISDlvIDlpLTnmoTmj5DkuqQiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ2MworIzogYnVpbHRpbi9yZWJhc2UuYzoxNDg3CiBtc2dpZCAiYXV0b21hdGljYWxseSBzdGFzaC9zdGFzaCBwb3AgYmVmb3JlIGFuZCBhZnRlciIKIG1zZ3N0ciAi5Zyo5pON5L2c5YmN5ZCO5omn6KGM6Ieq5Yqo6LSu6JeP5ZKM5by55Ye66LSu6JePIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE0NjUKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ4OQogbXNnaWQgImFkZCBleGVjIGxpbmVzIGFmdGVyIGVhY2ggY29tbWl0IG9mIHRoZSBlZGl0YWJsZSBsaXN0IgogbXNnc3RyICLlj6/nvJbovpHliJfooajnmoTmr4/kuIDkuKrmj5DkuqTkuIvpnaLlop7liqDkuIDooYwgZXhlYyIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDY5CisjOiBidWlsdGluL3JlYmFzZS5jOjE0OTMKIG1zZ2lkICJhbGxvdyByZWJhc2luZyBjb21taXRzIHdpdGggZW1wdHkgbWVzc2FnZXMiCiBtc2dzdHIgIuWFgeiuuOmSiOWvueepuuaPkOS6pOivtOaYjueahOaPkOS6pOWPmOWfuiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDcyCisjOiBidWlsdGluL3JlYmFzZS5jOjE0OTYKIG1zZ2lkICJ0cnkgdG8gcmViYXNlIG1lcmdlcyBpbnN0ZWFkIG9mIHNraXBwaW5nIHRoZW0iCiBtc2dzdHIgIuWwneivleWvueWQiOW5tuaPkOS6pOWPmOWfuuiAjOS4jeaYr+W/veeVpeWug+S7rCIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDc1CisjOiBidWlsdGluL3JlYmFzZS5jOjE0OTkKIG1zZ2lkICJ1c2UgJ21lcmdlLWJhc2UgLS1mb3JrLXBvaW50JyB0byByZWZpbmUgdXBzdHJlYW0iCiBtc2dzdHIgIuS9v+eUqCAnbWVyZ2UtYmFzZSAtLWZvcmstcG9pbnQnIOadpeS8mOWMluS4iua4uCIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDc3CisjOiBidWlsdGluL3JlYmFzZS5jOjE1MDEKIG1zZ2lkICJ1c2UgdGhlIGdpdmVuIG1lcmdlIHN0cmF0ZWd5IgogbXNnc3RyICLkvb/nlKjnu5nlrprnmoTlkIjlubbnrZbnlaUiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ3OSBidWlsdGluL3JldmVydC5jOjExNQorIzogYnVpbHRpbi9yZWJhc2UuYzoxNTAzIGJ1aWx0aW4vcmV2ZXJ0LmM6MTE1CiBtc2dpZCAib3B0aW9uIgogbXNnc3RyICLpgInpobkiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTQ4MAorIzogYnVpbHRpbi9yZWJhc2UuYzoxNTA0CiBtc2dpZCAicGFzcyB0aGUgYXJndW1lbnQgdGhyb3VnaCB0byB0aGUgbWVyZ2Ugc3RyYXRlZ3kiCiBtc2dzdHIgIuWwhuWPguaVsOS8oOmAkue7meWQiOW5tuetlueVpSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNDgzCisjOiBidWlsdGluL3JlYmFzZS5jOjE1MDcKIG1zZ2lkICJyZWJhc2UgYWxsIHJlYWNoYWJsZSBjb21taXRzIHVwIHRvIHRoZSByb290KHMpIgogbXNnc3RyICLlsIbmiYDmnInlj6/ovr7nmoTmj5DkuqTlj5jln7rliLDmoLnmj5DkuqQiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTUwMAorIzogYnVpbHRpbi9yZWJhc2UuYzoxNTI0CiBtc2dpZCAiIgogInRoZSByZWJhc2UudXNlQnVpbHRpbiBzdXBwb3J0IGhhcyBiZWVuIHJlbW92ZWQhXG4iCiAiU2VlIGl0cyBlbnRyeSBpbiAnZ2l0IGhlbHAgY29uZmlnJyBmb3IgZGV0YWlscy4iCkBAIC0xNzIzMSwyOCArMTczMjEsMzYgQEAKICLlr7kgcmViYXNlLnVzZUJ1aWx0aW4g55qE5pSv5oyB5bey6KKr5Yig6Zmk77yBXG4iCiAi6K+m6KeBICdnaXQgaGVscCBjb25maWcnIOS4reeahOadoeebruOAgiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNTA2CisjOiBidWlsdGluL3JlYmFzZS5jOjE1MzAKIG1zZ2lkICJJdCBsb29rcyBsaWtlICdnaXQgYW0nIGlzIGluIHByb2dyZXNzLiBDYW5ub3QgcmViYXNlLiIKIG1zZ3N0ciAi55yL6LW35p2lICdnaXQtYW0nIOato+WcqOaJp+ihjOS4reOAguaXoOazleWPmOWfuuOAgiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNTQ3CisjOiBidWlsdGluL3JlYmFzZS5jOjE1NzEKIG1zZ2lkICIiCiAiZ2l0IHJlYmFzZSAtLXByZXNlcnZlLW1lcmdlcyBpcyBkZXByZWNhdGVkLiBVc2UgLS1yZWJhc2UtbWVyZ2VzIGluc3RlYWQuIgogbXNnc3RyICJnaXQgcmViYXNlIC0tcHJlc2VydmUtbWVyZ2VzIOiiq+W8g+eUqOOAgueUqCAtLXJlYmFzZS1tZXJnZXMg5Luj5pu/44CCIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE1NTEKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTU3NgorbXNnaWQgImNhbm5vdCBjb21iaW5lICctLWtlZXAtYmFzZScgd2l0aCAnLS1vbnRvJyIKK21zZ3N0ciAi5LiN6IO95bCGICctLWtlZXAtYmFzZScg5ZKMICctLW9udG8nIOe7hOWQiOS9v+eUqCIKKworIzogYnVpbHRpbi9yZWJhc2UuYzoxNTc4Cittc2dpZCAiY2Fubm90IGNvbWJpbmUgJy0ta2VlcC1iYXNlJyB3aXRoICctLXJvb3QnIgorbXNnc3RyICLkuI3og73lsIYgJy0ta2VlcC1iYXNlJyDlkowgJy0tcm9vdCcg57uE5ZCI5L2/55SoIgorCisjOiBidWlsdGluL3JlYmFzZS5jOjE1ODIKIG1zZ2lkICJObyByZWJhc2UgaW4gcHJvZ3Jlc3M/IgogbXNnc3RyICLmsqHmnInmraPlnKjov5vooYznmoTlj5jln7rvvJ8iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTU1NQorIzogYnVpbHRpbi9yZWJhc2UuYzoxNTg2CiBtc2dpZCAiVGhlIC0tZWRpdC10b2RvIGFjdGlvbiBjYW4gb25seSBiZSB1c2VkIGR1cmluZyBpbnRlcmFjdGl2ZSByZWJhc2UuIgogbXNnc3RyICLliqjkvZwgLS1lZGl0LXRvZG8g5Y+q6IO955So5Zyo5Lqk5LqS5byP5Y+Y5Z+66L+H56iL5Lit44CCIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE1NzgKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTYwOQogbXNnaWQgIkNhbm5vdCByZWFkIEhFQUQiCiBtc2dzdHIgIuS4jeiDveivu+WPliBIRUFEIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE1OTAKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTYyMQogbXNnaWQgIiIKICJZb3UgbXVzdCBlZGl0IGFsbCBtZXJnZSBjb25mbGljdHMgYW5kIHRoZW5cbiIKICJtYXJrIHRoZW0gYXMgcmVzb2x2ZWQgdXNpbmcgZ2l0IGFkZCIKQEAgLTE3MjYwLDE2ICsxNzM1OCwxNiBAQAogIuaCqOW/hemhu+e8lui+keaJgOacieeahOWQiOW5tuWGsueqge+8jOeEtuWQjumAmui/hyBnaXQgYWRkXG4iCiAi5ZG95Luk5bCG5a6D5Lus5qCH6K6w5Li65bey6Kej5YazIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE2MDkKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTY0MAogbXNnaWQgImNvdWxkIG5vdCBkaXNjYXJkIHdvcmt0cmVlIGNoYW5nZXMiCiBtc2dzdHIgIuaXoOazleS4ouW8g+W3peS9nOWMuuWPmOabtCIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNjI4CisjOiBidWlsdGluL3JlYmFzZS5jOjE2NTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IG1vdmUgYmFjayB0byAlcyIKIG1zZ3N0ciAi5peg5rOV56e75ZueICVzIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE2NzMKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTcwNAogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiSXQgc2VlbXMgdGhhdCB0aGVyZSBpcyBhbHJlYWR5IGEgJXMgZGlyZWN0b3J5LCBhbmRcbiIKQEAgLTE3Mjg4LDE2MyArMTczODYsMTU1IEBACiAiXHQlc1xuIgogIueEtuWQjuWGjemHjeaWsOaJp+ihjOOAgiDkuLrpgb/lhY3kuKLlpLHph43opoHmlbDmja7vvIzmiJHlt7Lnu4/lgZzmraLlvZPliY3mk43kvZzjgIJcbiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNjk0CisjOiBidWlsdGluL3JlYmFzZS5jOjE3MjUKIG1zZ2lkICJzd2l0Y2ggYEMnIGV4cGVjdHMgYSBudW1lcmljYWwgdmFsdWUiCiBtc2dzdHIgIuW8gOWFsyBgQycg5pyf5pyb5LiA5Liq5pWw5a2X5YC8IgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE3MzUKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTc2NgogIywgYy1mb3JtYXQKIG1zZ2lkICJVbmtub3duIG1vZGU6ICVzIgogbXNnc3RyICLmnKrnn6XmqKHlvI/vvJolcyIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNzU3CisjOiBidWlsdGluL3JlYmFzZS5jOjE3ODgKIG1zZ2lkICItLXN0cmF0ZWd5IHJlcXVpcmVzIC0tbWVyZ2Ugb3IgLS1pbnRlcmFjdGl2ZSIKIG1zZ3N0ciAiLS1zdHJhdGVneSDpnIDopoEgLS1tZXJnZSDmiJYgLS1pbnRlcmFjdGl2ZSIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxNzk3CisjOiBidWlsdGluL3JlYmFzZS5jOjE4MjgKIG1zZ2lkICItLXJlc2NoZWR1bGUtZmFpbGVkLWV4ZWMgcmVxdWlyZXMgLS1leGVjIG9yIC0taW50ZXJhY3RpdmUiCiBtc2dzdHIgIi0tcmVzY2hlZHVsZS1mYWlsZWQtZXhlYyDpnIDopoEgLS1leGVjIOaIliAtLWludGVyYWN0aXZlIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE4MDkKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTg0MAogbXNnaWQgImNhbm5vdCBjb21iaW5lIGFtIG9wdGlvbnMgd2l0aCBlaXRoZXIgaW50ZXJhY3RpdmUgb3IgbWVyZ2Ugb3B0aW9ucyIKIG1zZ3N0ciAi5LiN6IO95bCGIGFtIOmAiemhueS4juS6pOS6kuaIluWQiOW5tumAiemhueWQjOaXtuS9v+eUqCIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxODI4CisjOiBidWlsdGluL3JlYmFzZS5jOjE4NTkKIG1zZ2lkICJjYW5ub3QgY29tYmluZSAnLS1wcmVzZXJ2ZS1tZXJnZXMnIHdpdGggJy0tcmViYXNlLW1lcmdlcyciCiBtc2dzdHIgIuS4jeiDveWwhiAnLS1wcmVzZXJ2ZS1tZXJnZXMnIOWSjCAnLS1yZWJhc2UtbWVyZ2VzJyDlkIzml7bkvb/nlKgiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTgzMgorIzogYnVpbHRpbi9yZWJhc2UuYzoxODYzCiBtc2dpZCAiIgogImVycm9yOiBjYW5ub3QgY29tYmluZSAnLS1wcmVzZXJ2ZS1tZXJnZXMnIHdpdGggJy0tcmVzY2hlZHVsZS1mYWlsZWQtZXhlYyciCiBtc2dzdHIgIiIKICLplJnor6/vvJrkuI3og73lsIYgJy0tcHJlc2VydmUtbWVyZ2VzJyDlkowgJy0tcmVzY2hlZHVsZS1mYWlsZWQtZXhlYycg5ZCM5pe25L2/55SoIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE4MzgKLW1zZ2lkICJjYW5ub3QgY29tYmluZSAnLS1yZWJhc2UtbWVyZ2VzJyB3aXRoICctLXN0cmF0ZWd5LW9wdGlvbiciCi1tc2dzdHIgIuS4jeiDveWwhiAnLS1yZWJhc2UtbWVyZ2VzJyDlkowgJy0tc3RyYXRlZ3ktb3B0aW9uJyDlkIzml7bkvb/nlKgiCi0KLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTg0MQotbXNnaWQgImNhbm5vdCBjb21iaW5lICctLXJlYmFzZS1tZXJnZXMnIHdpdGggJy0tc3RyYXRlZ3knIgotbXNnc3RyICLkuI3og73lsIYgJy0tcmViYXNlLW1lcmdlcycg5ZKMICctLXN0cmF0ZWd5JyDlkIzml7bkvb/nlKgiCi0KLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTg2NQorIzogYnVpbHRpbi9yZWJhc2UuYzoxODg3CiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgdXBzdHJlYW0gJyVzJyIKIG1zZ3N0ciAi5peg5pWI55qE5LiK5ri4ICclcyciCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTg3MQorIzogYnVpbHRpbi9yZWJhc2UuYzoxODkzCiBtc2dpZCAiQ291bGQgbm90IGNyZWF0ZSBuZXcgcm9vdCBjb21taXQiCiBtc2dzdHIgIuS4jeiDveWIm+W7uuaWsOeahOagueaPkOS6pCIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxODg5CisjOiBidWlsdGluL3JlYmFzZS5jOjE5MTkKKyMsIGMtZm9ybWF0Cittc2dpZCAiJyVzJzogbmVlZCBleGFjdGx5IG9uZSBtZXJnZSBiYXNlIHdpdGggYnJhbmNoIgorbXNnc3RyICInJXMn77ya5Y+q6ZyA6KaB5LiO5YiG5pSv55qE5LiA5Liq5ZCI5bm25Z+657q/IgorCisjOiBidWlsdGluL3JlYmFzZS5jOjE5MjIKICMsIGMtZm9ybWF0CiBtc2dpZCAiJyVzJzogbmVlZCBleGFjdGx5IG9uZSBtZXJnZSBiYXNlIgogbXNnc3RyICInJXMn77ya5Y+q6ZyA6KaB5LiA5Liq5ZCI5bm25Z+657q/IgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE4OTYKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTkzMAogIywgYy1mb3JtYXQKIG1zZ2lkICJEb2VzIG5vdCBwb2ludCB0byBhIHZhbGlkIGNvbW1pdCAnJXMnIgogbXNnc3RyICLmsqHmnInmjIflkJHkuIDkuKrmnInmlYjnmoTmj5DkuqQgJyVzJyIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxOTIxCisjOiBidWlsdGluL3JlYmFzZS5jOjE5NTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmF0YWw6IG5vIHN1Y2ggYnJhbmNoL2NvbW1pdCAnJXMnIgogbXNnc3RyICLoh7Tlkb3plJnor6/vvJrml6DmraTliIbmlK8v5o+Q5LqkICclcyciCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTkyOSBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6MzgKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MTk2MyBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6MzgKICM6IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxOTM0CiAjLCBjLWZvcm1hdAogbXNnaWQgIk5vIHN1Y2ggcmVmOiAlcyIKIG1zZ3N0ciAi5rKh5pyJ6L+Z5qC355qE5byV55So77yaJXMiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTk0MAorIzogYnVpbHRpbi9yZWJhc2UuYzoxOTc0CiBtc2dpZCAiQ291bGQgbm90IHJlc29sdmUgSEVBRCB0byBhIHJldmlzaW9uIgogbXNnc3RyICLml6Dms5XlsIYgSEVBRCDop6PmnpDkuLrkuIDkuKrniYjmnKwiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTk4MQorIzogYnVpbHRpbi9yZWJhc2UuYzoyMDEyCiBtc2dpZCAiQ2Fubm90IGF1dG9zdGFzaCIKIG1zZ3N0ciAi5peg5rOVIGF1dG9zdGFzaCIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxOTg0CisjOiBidWlsdGluL3JlYmFzZS5jOjIwMTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiVW5leHBlY3RlZCBzdGFzaCByZXNwb25zZTogJyVzJyIKIG1zZ3N0ciAi5oSP5aSW55qEIHN0YXNoIOWTjeW6lO+8miclcyciCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTk5MAorIzogYnVpbHRpbi9yZWJhc2UuYzoyMDIxCiAjLCBjLWZvcm1hdAogbXNnaWQgIkNvdWxkIG5vdCBjcmVhdGUgZGlyZWN0b3J5IGZvciAnJXMnIgogbXNnc3RyICLkuI3og73kuLogJyVzJyDliJvlu7rnm67lvZUiCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MTk5MworIzogYnVpbHRpbi9yZWJhc2UuYzoyMDI0CiAjLCBjLWZvcm1hdAogbXNnaWQgIkNyZWF0ZWQgYXV0b3N0YXNoOiAlc1xuIgogbXNnc3RyICLliJvlu7rkuoYgYXV0b3N0YXNo77yaJXNcbiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoxOTk2CisjOiBidWlsdGluL3JlYmFzZS5jOjIwMjcKIG1zZ2lkICJjb3VsZCBub3QgcmVzZXQgLS1oYXJkIgogbXNnc3RyICLml6Dms5UgcmVzZXQgLS1oYXJkIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjE5OTcgYnVpbHRpbi9yZXNldC5jOjExNAotIywgYy1mb3JtYXQKLW1zZ2lkICJIRUFEIGlzIG5vdyBhdCAlcyIKLW1zZ3N0ciAiSEVBRCDnjrDlnKjkvY3kuo4gJXMiCi0KLSM6IGJ1aWx0aW4vcmViYXNlLmM6MjAxMworIzogYnVpbHRpbi9yZWJhc2UuYzoyMDM2CiBtc2dpZCAiUGxlYXNlIGNvbW1pdCBvciBzdGFzaCB0aGVtLiIKIG1zZ3N0ciAi6K+35o+Q5Lqk5oiW6LSu6JeP5L+u5pS544CCIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjIwNDAKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MjA2MwogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcGFyc2UgJyVzJyIKIG1zZ3N0ciAi5peg5rOV6Kej5p6QICclcyciCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MjA1MworIzogYnVpbHRpbi9yZWJhc2UuYzoyMDc2CiAjLCBjLWZvcm1hdAogbXNnaWQgImNvdWxkIG5vdCBzd2l0Y2ggdG8gJXMiCiBtc2dzdHIgIuaXoOazleWIh+aNouWIsCAlcyIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoyMDY0CisjOiBidWlsdGluL3JlYmFzZS5jOjIwODcKIG1zZ2lkICJIRUFEIGlzIHVwIHRvIGRhdGUuIgogbXNnc3RyICJIRUFEIOaYr+acgOaWsOeahOOAgiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoyMDY2CisjOiBidWlsdGluL3JlYmFzZS5jOjIwODkKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ3VycmVudCBicmFuY2ggJXMgaXMgdXAgdG8gZGF0ZS5cbiIKIG1zZ3N0ciAi5b2T5YmN5YiG5pSvICVzIOaYr+acgOaWsOeahOOAglxuIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjIwNzQKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MjA5NwogbXNnaWQgIkhFQUQgaXMgdXAgdG8gZGF0ZSwgcmViYXNlIGZvcmNlZC4iCiBtc2dzdHIgIkhFQUQg5piv5pyA5paw55qE77yM5by65Yi25Y+Y5Z+644CCIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjIwNzYKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MjA5OQogIywgYy1mb3JtYXQKIG1zZ2lkICJDdXJyZW50IGJyYW5jaCAlcyBpcyB1cCB0byBkYXRlLCByZWJhc2UgZm9yY2VkLlxuIgogbXNnc3RyICLlvZPliY3liIbmlK8gJXMg5piv5pyA5paw55qE77yM5by65Yi25Y+Y5Z+644CCXG4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MjA4NAorIzogYnVpbHRpbi9yZWJhc2UuYzoyMTA3CiBtc2dpZCAiVGhlIHByZS1yZWJhc2UgaG9vayByZWZ1c2VkIHRvIHJlYmFzZS4iCiBtc2dzdHIgInByZS1yZWJhc2Ug6ZKp5a2Q5ouS57ud5LqG5Y+Y5Z+65pON5L2c44CCIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjIwOTEKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MjExNAogIywgYy1mb3JtYXQKIG1zZ2lkICJDaGFuZ2VzIHRvICVzOlxuIgogbXNnc3RyICLliLAgJXMg55qE5Y+Y5pu077yaXG4iCiAKLSM6IGJ1aWx0aW4vcmViYXNlLmM6MjA5NAorIzogYnVpbHRpbi9yZWJhc2UuYzoyMTE3CiAjLCBjLWZvcm1hdAogbXNnaWQgIkNoYW5nZXMgZnJvbSAlcyB0byAlczpcbiIKIG1zZ3N0ciAi5LuOICVzIOWIsCAlcyDnmoTlj5jmm7TvvJpcbiIKIAotIzogYnVpbHRpbi9yZWJhc2UuYzoyMTE5CisjOiBidWlsdGluL3JlYmFzZS5jOjIxNDIKICMsIGMtZm9ybWF0CiBtc2dpZCAiRmlyc3QsIHJld2luZGluZyBoZWFkIHRvIHJlcGxheSB5b3VyIHdvcmsgb24gdG9wIG9mIGl0Li4uXG4iCiBtc2dzdHIgIummluWFiO+8jOWbnumAgOWktOaMh+mSiOS7peS+v+WcqOWFtuS4iumHjeaUvuaCqOeahOW3peS9nC4uLlxuIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjIxMjgKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MjE1MQogbXNnaWQgIkNvdWxkIG5vdCBkZXRhY2ggSEVBRCIKIG1zZ3N0ciAi5peg5rOV5YiG56a75aS05oyH6ZKIIgogCi0jOiBidWlsdGluL3JlYmFzZS5jOjIxMzcKKyM6IGJ1aWx0aW4vcmViYXNlLmM6MjE2MAogIywgYy1mb3JtYXQKIG1zZ2lkICJGYXN0LWZvcndhcmRlZCAlcyB0byAlcy5cbiIKIG1zZ3N0ciAi5b+r6L+bICVzIOWIsCAlc+OAglxuIgpAQCAtMTc0NTMsNyArMTc1NDMsNyBAQAogbXNnaWQgImdpdCByZWNlaXZlLXBhY2sgPGdpdC1kaXI+IgogbXNnc3RyICJnaXQgcmVjZWl2ZS1wYWNrIDzku5PlupPnm67lvZU+IgogCi0jOiBidWlsdGluL3JlY2VpdmUtcGFjay5jOjgzMgorIzogYnVpbHRpbi9yZWNlaXZlLXBhY2suYzo4MzAKIG1zZ2lkICIiCiAiQnkgZGVmYXVsdCwgdXBkYXRpbmcgdGhlIGN1cnJlbnQgYnJhbmNoIGluIGEgbm9uLWJhcmUgcmVwb3NpdG9yeVxuIgogImlzIGRlbmllZCwgYmVjYXVzZSBpdCB3aWxsIG1ha2UgdGhlIGluZGV4IGFuZCB3b3JrIHRyZWUgaW5jb25zaXN0ZW50XG4iCkBAIC0xNzQ3OSw3ICsxNzU2OSw3IEBACiAi6Iul6KaB5bGP6JS95q2k5L+h5oGv5LiU5L+d5oyB6buY6K6k6KGM5Li677yM6K6+572uICdyZWNlaXZlLmRlbnlDdXJyZW50QnJhbmNoJ1xuIgogIumFjee9ruWPmOmHj+S4uiAncmVmdXNlJ+OAgiIKIAotIzogYnVpbHRpbi9yZWNlaXZlLXBhY2suYzo4NTIKKyM6IGJ1aWx0aW4vcmVjZWl2ZS1wYWNrLmM6ODUwCiBtc2dpZCAiIgogIkJ5IGRlZmF1bHQsIGRlbGV0aW5nIHRoZSBjdXJyZW50IGJyYW5jaCBpcyBkZW5pZWQsIGJlY2F1c2UgdGhlIG5leHRcbiIKICInZ2l0IGNsb25lJyB3b24ndCByZXN1bHQgaW4gYW55IGZpbGUgY2hlY2tlZCBvdXQsIGNhdXNpbmcgY29uZnVzaW9uLlxuIgpAQCAtMTc0OTgsMTEgKzE3NTg4LDExIEBACiAiXG4iCiAi6Iul6KaB5bGP6JS95q2k5L+h5oGv77yM5oKo5Y+v5Lul6K6+572u5a6D5Li6ICdyZWZ1c2Un44CCIgogCi0jOiBidWlsdGluL3JlY2VpdmUtcGFjay5jOjE5MzgKKyM6IGJ1aWx0aW4vcmVjZWl2ZS1wYWNrLmM6MTkzNgogbXNnaWQgInF1aWV0IgogbXNnc3RyICLpnZnpu5jmqKHlvI8iCiAKLSM6IGJ1aWx0aW4vcmVjZWl2ZS1wYWNrLmM6MTk1MgorIzogYnVpbHRpbi9yZWNlaXZlLXBhY2suYzoxOTUwCiBtc2dpZCAiWW91IG11c3Qgc3BlY2lmeSBhIGRpcmVjdG9yeS4iCiBtc2dzdHIgIuaCqOW/hemhu+aMh+WumuS4gOS4quebruW9leOAgiIKIApAQCAtMTgwNzEsMTEgKzE4MTYxLDExIEBACiBtc2dpZCAiVW5rbm93biBzdWJjb21tYW5kOiAlcyIKIG1zZ3N0ciAi5pyq55+l5a2Q5ZG95Luk77yaJXMiCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MjIKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6MjMKIG1zZ2lkICJnaXQgcmVwYWNrIFs8b3B0aW9ucz5dIgogbXNnc3RyICJnaXQgcmVwYWNrIFs86YCJ6aG5Pl0iCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MjcKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6MjgKIG1zZ2lkICIiCiAiSW5jcmVtZW50YWwgcmVwYWNrcyBhcmUgaW5jb21wYXRpYmxlIHdpdGggYml0bWFwIGluZGV4ZXMuICBVc2VcbiIKICItLW5vLXdyaXRlLWJpdG1hcC1pbmRleCBvciBkaXNhYmxlIHRoZSBwYWNrLndyaXRlYml0bWFwcyBjb25maWd1cmF0aW9uLiIKQEAgLTE4MDgzLDExMSArMTgxNzMsMTExIEBACiAi5aKe6YePIHJlcGFjayDlkowgYml0bWFwIOe0ouW8leS4jeWFvOWuueOAgiAg5L2/55SoIC0tbm8td3JpdGUtYml0bWFwLWluZGV4XG4iCiAi5oiW56aB55SoIHBhY2sud3JpdGViaXRtYXBzIOmFjee9ruOAgiIKIAotIzogYnVpbHRpbi9yZXBhY2suYzoxOTAKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6MTkxCiBtc2dpZCAiY291bGQgbm90IHN0YXJ0IHBhY2stb2JqZWN0cyB0byByZXBhY2sgcHJvbWlzb3Igb2JqZWN0cyIKIG1zZ3N0ciAi5peg5rOV5byA5aeLIHBhY2stb2JqZWN0cyDmnaXph43mlrDmiZPljIUgcHJvbWlzb3Ig5a+56LGhIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjIyOSBidWlsdGluL3JlcGFjay5jOjQwOAorIzogYnVpbHRpbi9yZXBhY2suYzoyMzAgYnVpbHRpbi9yZXBhY2suYzo0MDkKIG1zZ2lkICJyZXBhY2s6IEV4cGVjdGluZyBmdWxsIGhleCBvYmplY3QgSUQgbGluZXMgb25seSBmcm9tIHBhY2stb2JqZWN0cy4iCiBtc2dzdHIgInJlcGFja++8muacn+acm+adpeiHqiBwYWNrLW9iamVjdHMg55qE5a6M5pW05Y2B5YWt6L+b5Yi25a+56LGhIElE44CCIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjI0NgorIzogYnVpbHRpbi9yZXBhY2suYzoyNDcKIG1zZ2lkICJjb3VsZCBub3QgZmluaXNoIHBhY2stb2JqZWN0cyB0byByZXBhY2sgcHJvbWlzb3Igb2JqZWN0cyIKIG1zZ3N0ciAi5peg5rOV5a6M5oiQIHBhY2stb2JqZWN0cyDmnaXph43mlrDmiZPljIUgcHJvbWlzb3Ig5a+56LGhIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjI4NAorIzogYnVpbHRpbi9yZXBhY2suYzoyODUKIG1zZ2lkICJwYWNrIGV2ZXJ5dGhpbmcgaW4gYSBzaW5nbGUgcGFjayIKIG1zZ3N0ciAi5omA5pyJ5YaF5a655omT5YyF5Yiw5LiA5Liq5YyF5paH5Lu25LitIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjI4NgorIzogYnVpbHRpbi9yZXBhY2suYzoyODcKIG1zZ2lkICJzYW1lIGFzIC1hLCBhbmQgdHVybiB1bnJlYWNoYWJsZSBvYmplY3RzIGxvb3NlIgogbXNnc3RyICLlkowgLWEg55u45ZCM77yM5bm25bCG5LiN5Y+v6L6+55qE5a+56LGh6K6+5Li65p2+5pWj5a+56LGhIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjI4OQorIzogYnVpbHRpbi9yZXBhY2suYzoyOTAKIG1zZ2lkICJyZW1vdmUgcmVkdW5kYW50IHBhY2tzLCBhbmQgcnVuIGdpdC1wcnVuZS1wYWNrZWQiCiBtc2dzdHIgIuWIoOmZpOWkmuS9meeahOWMhe+8jOi/kOihjCBnaXQtcHJ1bmUtcGFja2VkIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjI5MQorIzogYnVpbHRpbi9yZXBhY2suYzoyOTIKIG1zZ2lkICJwYXNzIC0tbm8tcmV1c2UtZGVsdGEgdG8gZ2l0LXBhY2stb2JqZWN0cyIKIG1zZ3N0ciAi5ZCRIGdpdC1wYWNrLW9iamVjdHMg5Lyg6YCS5Y+C5pWwIC0tbm8tcmV1c2UtZGVsdGEiCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MjkzCisjOiBidWlsdGluL3JlcGFjay5jOjI5NAogbXNnaWQgInBhc3MgLS1uby1yZXVzZS1vYmplY3QgdG8gZ2l0LXBhY2stb2JqZWN0cyIKIG1zZ3N0ciAi5ZCRIGdpdC1wYWNrLW9iamVjdHMg5Lyg6YCS5Y+C5pWwIC0tbm8tcmV1c2Utb2JqZWN0IgogCi0jOiBidWlsdGluL3JlcGFjay5jOjI5NQorIzogYnVpbHRpbi9yZXBhY2suYzoyOTYKIG1zZ2lkICJkbyBub3QgcnVuIGdpdC11cGRhdGUtc2VydmVyLWluZm8iCiBtc2dzdHIgIuS4jei/kOihjCBnaXQtdXBkYXRlLXNlcnZlci1pbmZvIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjI5OAorIzogYnVpbHRpbi9yZXBhY2suYzoyOTkKIG1zZ2lkICJwYXNzIC0tbG9jYWwgdG8gZ2l0LXBhY2stb2JqZWN0cyIKIG1zZ3N0ciAi5ZCRIGdpdC1wYWNrLW9iamVjdHMg5Lyg6YCS5Y+C5pWwIC0tbG9jYWwiCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MzAwCisjOiBidWlsdGluL3JlcGFjay5jOjMwMQogbXNnaWQgIndyaXRlIGJpdG1hcCBpbmRleCIKIG1zZ3N0ciAi5YaZIGJpdG1hcCDntKLlvJUiCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MzAyCisjOiBidWlsdGluL3JlcGFjay5jOjMwMwogbXNnaWQgInBhc3MgLS1kZWx0YS1pc2xhbmRzIHRvIGdpdC1wYWNrLW9iamVjdHMiCiBtc2dzdHIgIuWQkSBnaXQtcGFjay1vYmplY3RzIOS8oOmAkuWPguaVsCAtLWRlbHRhLWlzbGFuZHMiCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MzAzCisjOiBidWlsdGluL3JlcGFjay5jOjMwNAogbXNnaWQgImFwcHJveGlkYXRlIgogbXNnc3RyICLov5HkvLzml6XmnJ8iCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MzA0CisjOiBidWlsdGluL3JlcGFjay5jOjMwNQogbXNnaWQgIndpdGggLUEsIGRvIG5vdCBsb29zZW4gb2JqZWN0cyBvbGRlciB0aGFuIHRoaXMiCiBtc2dzdHIgIuS9v+eUqCAtQe+8jOS4jeimgeWwhuaXqeS6jue7meWumuaXtumXtOeahOWvueixoei/h+acnyIKIAotIzogYnVpbHRpbi9yZXBhY2suYzozMDYKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6MzA3CiBtc2dpZCAid2l0aCAtYSwgcmVwYWNrIHVucmVhY2hhYmxlIG9iamVjdHMiCiBtc2dzdHIgIuS9v+eUqCAtYSDvvIzph43mlrDlr7nkuI3lj6/ovr7lr7nosaHmiZPljIUiCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MzA4CisjOiBidWlsdGluL3JlcGFjay5jOjMwOQogbXNnaWQgInNpemUgb2YgdGhlIHdpbmRvdyB1c2VkIGZvciBkZWx0YSBjb21wcmVzc2lvbiIKIG1zZ3N0ciAi55So5LqO5aKe6YeP5Y6L57yp55qE56qX5Y+j5YC8IgogCi0jOiBidWlsdGluL3JlcGFjay5jOjMwOSBidWlsdGluL3JlcGFjay5jOjMxNQorIzogYnVpbHRpbi9yZXBhY2suYzozMTAgYnVpbHRpbi9yZXBhY2suYzozMTYKIG1zZ2lkICJieXRlcyIKIG1zZ3N0ciAi5a2X6IqCIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjMxMAorIzogYnVpbHRpbi9yZXBhY2suYzozMTEKIG1zZ2lkICJzYW1lIGFzIHRoZSBhYm92ZSwgYnV0IGxpbWl0IG1lbW9yeSBzaXplIGluc3RlYWQgb2YgZW50cmllcyBjb3VudCIKIG1zZ3N0ciAi5ZKM5LiK6Z2i55qE55u45Ly877yM5L2G6ZmQ5Yi25YaF5a2Y5aSn5bCP6ICM6Z2e5p2h55uu5pWwIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjMxMgorIzogYnVpbHRpbi9yZXBhY2suYzozMTMKIG1zZ2lkICJsaW1pdHMgdGhlIG1heGltdW0gZGVsdGEgZGVwdGgiCiBtc2dzdHIgIumZkOWItuacgOWkp+WinumHj+a3seW6piIKIAotIzogYnVpbHRpbi9yZXBhY2suYzozMTQKKyM6IGJ1aWx0aW4vcmVwYWNrLmM6MzE1CiBtc2dpZCAibGltaXRzIHRoZSBtYXhpbXVtIG51bWJlciBvZiB0aHJlYWRzIgogbXNnc3RyICLpmZDliLbmnIDlpKfnur/nqIvmlbAiCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MzE2CisjOiBidWlsdGluL3JlcGFjay5jOjMxNwogbXNnaWQgIm1heGltdW0gc2l6ZSBvZiBlYWNoIHBhY2tmaWxlIgogbXNnc3RyICLmr4/kuKrljIXmlofku7bnmoTmnIDlpKflsLrlr7giCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MzE4CisjOiBidWlsdGluL3JlcGFjay5jOjMxOQogbXNnaWQgInJlcGFjayBvYmplY3RzIGluIHBhY2tzIG1hcmtlZCB3aXRoIC5rZWVwIgogbXNnc3RyICLlr7nmoIforrDkuLogLmtlZXAg55qE5YyF5Lit55qE5a+56LGh6YeN5paw5omT5YyFIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjMyMAorIzogYnVpbHRpbi9yZXBhY2suYzozMjEKIG1zZ2lkICJkbyBub3QgcmVwYWNrIHRoaXMgcGFjayIKIG1zZ3N0ciAi5LiN6KaB5a+56K+l5YyF5paH5Lu26YeN5paw5omT5YyFIgogCi0jOiBidWlsdGluL3JlcGFjay5jOjMzMAorIzogYnVpbHRpbi9yZXBhY2suYzozMzEKIG1zZ2lkICJjYW5ub3QgZGVsZXRlIHBhY2tzIGluIGEgcHJlY2lvdXMtb2JqZWN0cyByZXBvIgogbXNnc3RyICLkuI3og73liKDpmaTnj43lk4Hku5PlupPkuK3nmoTmiZPljIXmlofku7YiCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6MzM0CisjOiBidWlsdGluL3JlcGFjay5jOjMzNQogbXNnaWQgIi0ta2VlcC11bnJlYWNoYWJsZSBhbmQgLUEgYXJlIGluY29tcGF0aWJsZSIKIG1zZ3N0ciAiLS1rZWVwLXVucmVhY2hhYmxlIOWSjCAtQSDkuI3lhbzlrrkiCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6NDE3CisjOiBidWlsdGluL3JlcGFjay5jOjQxOAogbXNnaWQgIk5vdGhpbmcgbmV3IHRvIHBhY2suIgogbXNnc3RyICLmsqHmnInmlrDnmoTopoHmiZPljIXjgIIiCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6NDc4CisjOiBidWlsdGluL3JlcGFjay5jOjQ3OQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiV0FSTklORzogU29tZSBwYWNrcyBpbiB1c2UgaGF2ZSBiZWVuIHJlbmFtZWQgYnlcbiIKQEAgLTE4MjAzLDcgKzE4MjkzLDcgQEAKICLorablkYrvvJrlubbkuJTlsJ3or5Xph43lkb3lkI3mlLnlm57ljp/mnInmlofku7blkI3nmoTmk43kvZzkuZ/lpLHotKXjgIJcbiIKICLorablkYrvvJror7fmiYvliqjlsIYgJXMg5LiL55qE6L+Z5Lqb5paH5Lu26YeN5ZG95ZCN77yaXG4iCiAKLSM6IGJ1aWx0aW4vcmVwYWNrLmM6NTI2CisjOiBidWlsdGluL3JlcGFjay5jOjUyNwogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gcmVtb3ZlICclcyciCiBtc2dzdHIgIuWIoOmZpCAnJXMnIOWksei0pSIKQEAgLTE4MzExLDggKzE4NDAxLDggQEAKIG1zZ2lkICJ1bmFibGUgdG8gd3JpdGUgb2JqZWN0IHRvIGRhdGFiYXNlIgogbXNnc3RyICLml6Dms5XlkJHmlbDmja7lupPlhpnlhaXlr7nosaEiCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjMyMiBidWlsdGluL3JlcGxhY2UuYzozNzcgYnVpbHRpbi9yZXBsYWNlLmM6NDIyCi0jOiBidWlsdGluL3JlcGxhY2UuYzo0NTIKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjMyMiBidWlsdGluL3JlcGxhY2UuYzozNzggYnVpbHRpbi9yZXBsYWNlLmM6NDIzCisjOiBidWlsdGluL3JlcGxhY2UuYzo0NTMKICMsIGMtZm9ybWF0CiBtc2dpZCAibm90IGEgdmFsaWQgb2JqZWN0IG5hbWU6ICclcyciCiBtc2dzdHIgIuS4jeaYr+S4gOS4quacieaViOeahOWvueixoeWQje+8miclcyciCkBAIC0xODMzMSw1MyArMTg0MjEsNTMgQEAKIG1zZ2lkICJuZXcgb2JqZWN0IGlzIHRoZSBzYW1lIGFzIHRoZSBvbGQgb25lOiAnJXMnIgogbXNnc3RyICLmlrDlr7nosaHlkozml6flr7nosaHnm7jlkIzvvJonJXMnIgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzozODMKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjM4NAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgcGFyc2UgJXMgYXMgYSBjb21taXQiCiBtc2dzdHIgIuaXoOazleWwhiAlcyDop6PmnpDkuLrkuIDkuKrmj5DkuqQiCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjQxNAorIzogYnVpbHRpbi9yZXBsYWNlLmM6NDE1CiAjLCBjLWZvcm1hdAogbXNnaWQgImJhZCBtZXJnZXRhZyBpbiBjb21taXQgJyVzJyIKIG1zZ3N0ciAi5o+Q5LqkICclcycg5Lit5ZCr5pyJ5o2f5Z2P55qE5ZCI5bm25qCH562+IgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo0MTYKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjQxNwogIywgYy1mb3JtYXQKIG1zZ2lkICJtYWxmb3JtZWQgbWVyZ2V0YWcgaW4gY29tbWl0ICclcyciCiBtc2dzdHIgIuaPkOS6pCAnJXMnIOS4reWQq+acieagvOW8j+mUmeivr+eahOWQiOW5tuagh+etviIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NDI4CisjOiBidWlsdGluL3JlcGxhY2UuYzo0MjkKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIm9yaWdpbmFsIGNvbW1pdCAnJXMnIGNvbnRhaW5zIG1lcmdldGFnICclcycgdGhhdCBpcyBkaXNjYXJkZWQ7IHVzZSAtLWVkaXQgIgogImluc3RlYWQgb2YgLS1ncmFmdCIKIG1zZ3N0ciAi5Y6f5aeL5o+Q5LqkICclcycg5YyF5ZCr5bey57uP5Lii5byD55qE5ZCI5bm25qCH562+ICclcyfvvIzkvb/nlKggLS1lZGl0IOS7o+abvyAtLWdyYWZ0IgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo0NjcKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjQ2OAogIywgYy1mb3JtYXQKIG1zZ2lkICJ0aGUgb3JpZ2luYWwgY29tbWl0ICclcycgaGFzIGEgZ3BnIHNpZ25hdHVyZSIKIG1zZ3N0ciAi5Y6f5aeL5o+Q5LqkICclcycg5Lit5pyJ5LiA5LiqIGdwZyDnrb7lkI0iCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjQ2OAorIzogYnVpbHRpbi9yZXBsYWNlLmM6NDY5CiBtc2dpZCAidGhlIHNpZ25hdHVyZSB3aWxsIGJlIHJlbW92ZWQgaW4gdGhlIHJlcGxhY2VtZW50IGNvbW1pdCEiCiBtc2dzdHIgIuWcqOabv+aNoueahOaPkOS6pOS4reetvuWQjeWwhuiiq+enu+mZpO+8gSIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NDc4CisjOiBidWlsdGluL3JlcGxhY2UuYzo0NzkKICMsIGMtZm9ybWF0CiBtc2dpZCAiY291bGQgbm90IHdyaXRlIHJlcGxhY2VtZW50IGNvbW1pdCBmb3I6ICclcyciCiBtc2dzdHIgIuS4jeiDveS4uiAnJXMnIOWGmeabv+aNouaPkOS6pCIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NDg2CisjOiBidWlsdGluL3JlcGxhY2UuYzo0ODcKICMsIGMtZm9ybWF0CiBtc2dpZCAiZ3JhZnQgZm9yICclcycgdW5uZWNlc3NhcnkiCiBtc2dzdHIgIuWvuSAnJXMnIOenu+akjeayoeacieW/heimgSIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NDkwCisjOiBidWlsdGluL3JlcGxhY2UuYzo0OTEKICMsIGMtZm9ybWF0CiBtc2dpZCAibmV3IGNvbW1pdCBpcyB0aGUgc2FtZSBhcyB0aGUgb2xkIG9uZTogJyVzJyIKIG1zZ3N0ciAi5paw5o+Q5Lqk5ZKM5pen55qE5LiA5qC377yaJyVzJyIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NTI1CisjOiBidWlsdGluL3JlcGxhY2UuYzo1MjYKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogImNvdWxkIG5vdCBjb252ZXJ0IHRoZSBmb2xsb3dpbmcgZ3JhZnQocyk6XG4iCkBAIC0xODM4Niw3MSArMTg0NzYsNzEgQEAKICLkuI3og73ovazmjaLkuIvliJfnp7vmpI3vvJpcbiIKICIlcyIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NTQ2CisjOiBidWlsdGluL3JlcGxhY2UuYzo1NDcKIG1zZ2lkICJsaXN0IHJlcGxhY2UgcmVmcyIKIG1zZ3N0ciAi5YiX5Ye65pu/5o2i55qE5byV55SoIgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo1NDcKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU0OAogbXNnaWQgImRlbGV0ZSByZXBsYWNlIHJlZnMiCiBtc2dzdHIgIuWIoOmZpOabv+aNoueahOW8leeUqCIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NTQ4CisjOiBidWlsdGluL3JlcGxhY2UuYzo1NDkKIG1zZ2lkICJlZGl0IGV4aXN0aW5nIG9iamVjdCIKIG1zZ3N0ciAi57yW6L6R546w5a2Y55qE5a+56LGhIgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo1NDkKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU1MAogbXNnaWQgImNoYW5nZSBhIGNvbW1pdCdzIHBhcmVudHMiCiBtc2dzdHIgIuS/ruaUueS4gOS4quaPkOS6pOeahOeItuaPkOS6pCIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NTUwCisjOiBidWlsdGluL3JlcGxhY2UuYzo1NTEKIG1zZ2lkICJjb252ZXJ0IGV4aXN0aW5nIGdyYWZ0IGZpbGUiCiBtc2dzdHIgIui9rOaNoueOsOWtmOeahOenu+akjeaWh+S7tiIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NTUxCisjOiBidWlsdGluL3JlcGxhY2UuYzo1NTIKIG1zZ2lkICJyZXBsYWNlIHRoZSByZWYgaWYgaXQgZXhpc3RzIgogbXNnc3RyICLlpoLmnpzlrZjlnKjliJnmm7/mjaLlvJXnlKgiCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU1MworIzogYnVpbHRpbi9yZXBsYWNlLmM6NTU0CiBtc2dpZCAiZG8gbm90IHByZXR0eS1wcmludCBjb250ZW50cyBmb3IgLS1lZGl0IgogbXNnc3RyICLkuI3opoHkuLogLS1lZGl0IOaTjeS9nOe+juinguaYvuekuuWGheWuuSIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NTU0CisjOiBidWlsdGluL3JlcGxhY2UuYzo1NTUKIG1zZ2lkICJ1c2UgdGhpcyBmb3JtYXQiCiBtc2dzdHIgIuS9v+eUqOatpOagvOW8jyIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NTY3CisjOiBidWlsdGluL3JlcGxhY2UuYzo1NjgKIG1zZ2lkICItLWZvcm1hdCBjYW5ub3QgYmUgdXNlZCB3aGVuIG5vdCBsaXN0aW5nIgogbXNnc3RyICLkuI3liJflh7rml7bkuI3og73kvb/nlKggLS1mb3JtYXQiCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU3NQorIzogYnVpbHRpbi9yZXBsYWNlLmM6NTc2CiBtc2dpZCAiLWYgb25seSBtYWtlcyBzZW5zZSB3aGVuIHdyaXRpbmcgYSByZXBsYWNlbWVudCIKIG1zZ3N0ciAi5Y+q5pyJ5YaZ5LiA5Liq5pu/5o2i5pe2IC1mIOaJjeacieaEj+S5iSIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NTc5CisjOiBidWlsdGluL3JlcGxhY2UuYzo1ODAKIG1zZ2lkICItLXJhdyBvbmx5IG1ha2VzIHNlbnNlIHdpdGggLS1lZGl0IgogbXNnc3RyICItLXJhdyDlj6rmnInlkowgLS1lZGl0IOWFseeUqOaJjeacieaEj+S5iSIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NTg1CisjOiBidWlsdGluL3JlcGxhY2UuYzo1ODYKIG1zZ2lkICItZCBuZWVkcyBhdCBsZWFzdCBvbmUgYXJndW1lbnQiCiBtc2dzdHIgIi1kIOmcgOimgeiHs+WwkeS4gOS4quWPguaVsCIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NTkxCisjOiBidWlsdGluL3JlcGxhY2UuYzo1OTIKIG1zZ2lkICJiYWQgbnVtYmVyIG9mIGFyZ3VtZW50cyIKIG1zZ3N0ciAi6ZSZ6K+v55qE5Y+C5pWw5Liq5pWwIgogCi0jOiBidWlsdGluL3JlcGxhY2UuYzo1OTcKKyM6IGJ1aWx0aW4vcmVwbGFjZS5jOjU5OAogbXNnaWQgIi1lIG5lZWRzIGV4YWN0bHkgb25lIGFyZ3VtZW50IgogbXNnc3RyICItZSDpnIDopoHkuJTku4XpnIDopoHkuIDkuKrlj4LmlbAiCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjYwMworIzogYnVpbHRpbi9yZXBsYWNlLmM6NjA0CiBtc2dpZCAiLWcgbmVlZHMgYXQgbGVhc3Qgb25lIGFyZ3VtZW50IgogbXNnc3RyICItZyDpnIDopoHoh7PlsJHkuIDkuKrlj4LmlbAiCiAKLSM6IGJ1aWx0aW4vcmVwbGFjZS5jOjYwOQorIzogYnVpbHRpbi9yZXBsYWNlLmM6NjEwCiBtc2dpZCAiLS1jb252ZXJ0LWdyYWZ0LWZpbGUgdGFrZXMgbm8gYXJndW1lbnQiCiBtc2dzdHIgIi0tY29udmVydC1ncmFmdC1maWxlIOS4jeW4puWPguaVsCIKIAotIzogYnVpbHRpbi9yZXBsYWNlLmM6NjE1CisjOiBidWlsdGluL3JlcGxhY2UuYzo2MTYKIG1zZ2lkICJvbmx5IG9uZSBwYXR0ZXJuIGNhbiBiZSBnaXZlbiB3aXRoIC1sIgogbXNnc3RyICLlj6rog73kuLogLWwg5o+Q5L6b5LiA5Liq5qih5byPIgogCkBAIC0xODUxNywxNCArMTg2MDcsMTkgQEAKIG1zZ2lkICJGYWlsZWQgdG8gZmluZCB0cmVlIG9mICVzLiIKIG1zZ3N0ciAi5peg5rOV5om+5YiwICVzIOaMh+WQkeeahOagkeOAgiIKIAorIzogYnVpbHRpbi9yZXNldC5jOjExNAorIywgYy1mb3JtYXQKK21zZ2lkICJIRUFEIGlzIG5vdyBhdCAlcyIKK21zZ3N0ciAiSEVBRCDnjrDlnKjkvY3kuo4gJXMiCisKICMgIOivkeiAhe+8muaxieWtl+S5i+mXtOaXoOepuuagvO+8jOaVheWIoOmZpCVz5YmN5ZCO56m65qC8CiAjOiBidWlsdGluL3Jlc2V0LmM6MTkzCiAjLCBjLWZvcm1hdAogbXNnaWQgIkNhbm5vdCBkbyBhICVzIHJlc2V0IGluIHRoZSBtaWRkbGUgb2YgYSBtZXJnZS4iCiBtc2dzdHIgIuWcqOWQiOW5tui/h+eoi+S4reS4jeiDveWBmiVz6YeN572u5pON5L2c44CCIgogCi0jOiBidWlsdGluL3Jlc2V0LmM6MjkzIGJ1aWx0aW4vc3Rhc2guYzo1MTQgYnVpbHRpbi9zdGFzaC5jOjU4OQotIzogYnVpbHRpbi9zdGFzaC5jOjYxMworIzogYnVpbHRpbi9yZXNldC5jOjI5MyBidWlsdGluL3N0YXNoLmM6NTIwIGJ1aWx0aW4vc3Rhc2guYzo1OTUKKyM6IGJ1aWx0aW4vc3Rhc2guYzo2MTkKIG1zZ2lkICJiZSBxdWlldCwgb25seSByZXBvcnQgZXJyb3JzIgogbXNnc3RyICLlronpnZnmqKHlvI/vvIzlj6rmiqXlkYrplJnor68iCiAKQEAgLTE4NjA3LDI0ICsxODcwMiwxOSBAQAogbXNnaWQgIkNvdWxkIG5vdCB3cml0ZSBuZXcgaW5kZXggZmlsZS4iCiBtc2dzdHIgIuS4jeiDveWGmeWFpeaWsOeahOe0ouW8leaWh+S7tuOAgiIKIAotIzogYnVpbHRpbi9yZXYtbGlzdC5jOjQxMgorIzogYnVpbHRpbi9yZXYtbGlzdC5jOjQxMQogbXNnaWQgImNhbm5vdCBjb21iaW5lIC0tZXhjbHVkZS1wcm9taXNvci1vYmplY3RzIGFuZCAtLW1pc3NpbmciCiBtc2dzdHIgIuS4jeiDveWQjOaXtuS9v+eUqCAtLWV4Y2x1ZGUtcHJvbWlzb3Itb2JqZWN0cyDlkowgLS1taXNzaW5nIOmAiemhuSIKIAotIzogYnVpbHRpbi9yZXYtbGlzdC5jOjQ3MworIzogYnVpbHRpbi9yZXYtbGlzdC5jOjQ3MgogbXNnaWQgIm9iamVjdCBmaWx0ZXJpbmcgcmVxdWlyZXMgLS1vYmplY3RzIgogbXNnc3RyICLlr7nosaHov4fmu6TpnIDopoEgLS1vYmplY3RzIgogCi0jOiBidWlsdGluL3Jldi1saXN0LmM6NDc2Ci0jLCBjLWZvcm1hdAotbXNnaWQgImludmFsaWQgc3BhcnNlIHZhbHVlICclcyciCi1tc2dzdHIgIuaXoOaViOeahOeogOeWj+WAvCAnJXMnIgotCi0jOiBidWlsdGluL3Jldi1saXN0LmM6NTI3CisjOiBidWlsdGluL3Jldi1saXN0LmM6NTIyCiBtc2dpZCAicmV2LWxpc3QgZG9lcyBub3Qgc3VwcG9ydCBkaXNwbGF5IG9mIG5vdGVzIgogbXNnc3RyICJyZXYtbGlzdCDkuI3mlK/mjIHmmL7npLrms6jop6MiCiAKLSM6IGJ1aWx0aW4vcmV2LWxpc3QuYzo1MzAKKyM6IGJ1aWx0aW4vcmV2LWxpc3QuYzo1MjUKIG1zZ2lkICJjYW5ub3QgY29tYmluZSAtLXVzZS1iaXRtYXAtaW5kZXggd2l0aCBvYmplY3QgZmlsdGVyaW5nIgogbXNnc3RyICLkuI3og73lsIYgLS11c2UtYml0bWFwLWluZGV4IOWSjOWvueixoei/h+a7pOe7hOWQiOS9v+eUqCIKIApAQCAtMTkxNTUsMTM0ICsxOTI0NSwxMzQgQEAKIG1zZ2lkICJjb3VsZCBub3Qgc2F2ZSBpbmRleCB0cmVlIgogbXNnc3RyICLkuI3og73kv53lrZjntKLlvJXmoJEiCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzo0MzQKKyM6IGJ1aWx0aW4vc3Rhc2guYzo0MzYKIG1zZ2lkICJjb3VsZCBub3QgcmVzdG9yZSB1bnRyYWNrZWQgZmlsZXMgZnJvbSBzdGFzaCIKIG1zZ3N0ciAi5peg5rOV5LuO6LSu6JeP5p2h55uu5Lit5oGi5aSN5pyq6Lef6Liq5paH5Lu2IgogCi0jOiBidWlsdGluL3N0YXNoLmM6NDQ4CisjOiBidWlsdGluL3N0YXNoLmM6NDUwCiAjLCBjLWZvcm1hdAogbXNnaWQgIk1lcmdpbmcgJXMgd2l0aCAlcyIKIG1zZ3N0ciAi5q2j5Zyo5ZCI5bm2ICVzIOWSjCAlcyIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjQ1OCBnaXQtbGVnYWN5LXN0YXNoLnNoOjY4MAorIzogYnVpbHRpbi9zdGFzaC5jOjQ2MCBnaXQtbGVnYWN5LXN0YXNoLnNoOjY4MAogbXNnaWQgIkluZGV4IHdhcyBub3QgdW5zdGFzaGVkLiIKIG1zZ3N0ciAi57Si5byV5pyq5LuO6LSu6JeP5Lit5oGi5aSN44CCIgogCi0jOiBidWlsdGluL3N0YXNoLmM6NTE2IGJ1aWx0aW4vc3Rhc2guYzo2MTUKKyM6IGJ1aWx0aW4vc3Rhc2guYzo1MjIgYnVpbHRpbi9zdGFzaC5jOjYyMQogbXNnaWQgImF0dGVtcHQgdG8gcmVjcmVhdGUgdGhlIGluZGV4IgogbXNnc3RyICLlsJ3or5Xph43lu7rntKLlvJUiCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzo1NDkKKyM6IGJ1aWx0aW4vc3Rhc2guYzo1NTUKICMsIGMtZm9ybWF0CiBtc2dpZCAiRHJvcHBlZCAlcyAoJXMpIgogbXNnc3RyICLkuKLlvIPkuoYgJXPvvIglc++8iSIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjU1MgorIzogYnVpbHRpbi9zdGFzaC5jOjU1OAogIywgYy1mb3JtYXQKIG1zZ2lkICIlczogQ291bGQgbm90IGRyb3Agc3Rhc2ggZW50cnkiCiBtc2dzdHIgIiVz77ya5peg5rOV5Lii5byD6LSu6JeP5p2h55uuIgogCi0jOiBidWlsdGluL3N0YXNoLmM6NTc3CisjOiBidWlsdGluL3N0YXNoLmM6NTgzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiclcycgaXMgbm90IGEgc3Rhc2ggcmVmZXJlbmNlIgogbXNnc3RyICInJXMnIOS4jeaYr+S4gOS4qui0ruiXj+W8leeUqCIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjYyNyBnaXQtbGVnYWN5LXN0YXNoLnNoOjY5NAorIzogYnVpbHRpbi9zdGFzaC5jOjYzMyBnaXQtbGVnYWN5LXN0YXNoLnNoOjY5NAogbXNnaWQgIlRoZSBzdGFzaCBlbnRyeSBpcyBrZXB0IGluIGNhc2UgeW91IG5lZWQgaXQgYWdhaW4uIgogbXNnc3RyICLotK7ol4/mnaHnm67ooqvkv53nlZnku6XlpIfmgqjlho3mrKHpnIDopoHjgIIiCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzo2NTAgZ2l0LWxlZ2FjeS1zdGFzaC5zaDo3MTIKKyM6IGJ1aWx0aW4vc3Rhc2guYzo2NTYgZ2l0LWxlZ2FjeS1zdGFzaC5zaDo3MTIKIG1zZ2lkICJObyBicmFuY2ggbmFtZSBzcGVjaWZpZWQiCiBtc2dzdHIgIuacquaMh+WumuWIhuaUr+WQjSIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjc5MCBidWlsdGluL3N0YXNoLmM6ODI3CisjOiBidWlsdGluL3N0YXNoLmM6Nzk2IGJ1aWx0aW4vc3Rhc2guYzo4MzMKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ2Fubm90IHVwZGF0ZSAlcyB3aXRoICVzIgogbXNnc3RyICLml6Dms5XnlKggJTIkcyDmm7TmlrAgJTEkcyIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjgwOCBidWlsdGluL3N0YXNoLmM6MTQ2MSBidWlsdGluL3N0YXNoLmM6MTQ5NworIzogYnVpbHRpbi9zdGFzaC5jOjgxNCBidWlsdGluL3N0YXNoLmM6MTQ3MCBidWlsdGluL3N0YXNoLmM6MTUwNgogbXNnaWQgInN0YXNoIG1lc3NhZ2UiCiBtc2dzdHIgIui0ruiXj+ivtOaYjiIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjgxOAorIzogYnVpbHRpbi9zdGFzaC5jOjgyNAogbXNnaWQgIlwiZ2l0IHN0YXNoIHN0b3JlXCIgcmVxdWlyZXMgb25lIDxjb21taXQ+IGFyZ3VtZW50IgogbXNnc3RyICJcImdpdCBzdGFzaCBzdG9yZVwiIOmcgOimgeS4gOS4qiA85o+Q5LqkPiDlj4LmlbAiCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzoxMDQwIGdpdC1sZWdhY3ktc3Rhc2guc2g6MjE3CisjOiBidWlsdGluL3N0YXNoLmM6MTA0NiBnaXQtbGVnYWN5LXN0YXNoLnNoOjIxNwogbXNnaWQgIk5vIGNoYW5nZXMgc2VsZWN0ZWQiCiBtc2dzdHIgIuayoeaciemAieaLqeWPmOabtCIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjExMzYgZ2l0LWxlZ2FjeS1zdGFzaC5zaDoxNTAKKyM6IGJ1aWx0aW4vc3Rhc2guYzoxMTQ1IGdpdC1sZWdhY3ktc3Rhc2guc2g6MTUwCiBtc2dpZCAiWW91IGRvIG5vdCBoYXZlIHRoZSBpbml0aWFsIGNvbW1pdCB5ZXQiCiBtc2dzdHIgIuaCqOWwmuacquW7uueri+WIneWni+aPkOS6pCIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjExNjMgZ2l0LWxlZ2FjeS1zdGFzaC5zaDoxNjUKKyM6IGJ1aWx0aW4vc3Rhc2guYzoxMTcyIGdpdC1sZWdhY3ktc3Rhc2guc2g6MTY1CiBtc2dpZCAiQ2Fubm90IHNhdmUgdGhlIGN1cnJlbnQgaW5kZXggc3RhdGUiCiBtc2dzdHIgIuaXoOazleS/neWtmOW9k+WJjee0ouW8leeKtuaAgSIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjExNzIgZ2l0LWxlZ2FjeS1zdGFzaC5zaDoxODAKKyM6IGJ1aWx0aW4vc3Rhc2guYzoxMTgxIGdpdC1sZWdhY3ktc3Rhc2guc2g6MTgwCiBtc2dpZCAiQ2Fubm90IHNhdmUgdGhlIHVudHJhY2tlZCBmaWxlcyIKIG1zZ3N0ciAi5peg5rOV5L+d5a2Y5pyq6Lef6Liq5paH5Lu2IgogCi0jOiBidWlsdGluL3N0YXNoLmM6MTE4MyBidWlsdGluL3N0YXNoLmM6MTE5MiBnaXQtbGVnYWN5LXN0YXNoLnNoOjIwMAorIzogYnVpbHRpbi9zdGFzaC5jOjExOTIgYnVpbHRpbi9zdGFzaC5jOjEyMDEgZ2l0LWxlZ2FjeS1zdGFzaC5zaDoyMDAKICM6IGdpdC1sZWdhY3ktc3Rhc2guc2g6MjEzCiBtc2dpZCAiQ2Fubm90IHNhdmUgdGhlIGN1cnJlbnQgd29ya3RyZWUgc3RhdGUiCiBtc2dzdHIgIuaXoOazleS/neWtmOW9k+WJjeW3peS9nOWMuueKtuaAgSIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjEyMjAgZ2l0LWxlZ2FjeS1zdGFzaC5zaDoyMzMKKyM6IGJ1aWx0aW4vc3Rhc2guYzoxMjI5IGdpdC1sZWdhY3ktc3Rhc2guc2g6MjMzCiBtc2dpZCAiQ2Fubm90IHJlY29yZCB3b3JraW5nIHRyZWUgc3RhdGUiCiBtc2dzdHIgIuS4jeiDveiusOW9leW3peS9nOWMuueKtuaAgSIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjEyNjkgZ2l0LWxlZ2FjeS1zdGFzaC5zaDozMzcKKyM6IGJ1aWx0aW4vc3Rhc2guYzoxMjc4IGdpdC1sZWdhY3ktc3Rhc2guc2g6MzM3CiBtc2dpZCAiQ2FuJ3QgdXNlIC0tcGF0Y2ggYW5kIC0taW5jbHVkZS11bnRyYWNrZWQgb3IgLS1hbGwgYXQgdGhlIHNhbWUgdGltZSIKIG1zZ3N0ciAi5LiN6IO95ZCM5pe25L2/55So5Y+C5pWwIC0tcGF0Y2gg5ZKMIC0taW5jbHVkZS11bnRyYWNrZWQg5oiWIC0tYWxsIgogCi0jOiBidWlsdGluL3N0YXNoLmM6MTI4NQorIzogYnVpbHRpbi9zdGFzaC5jOjEyOTQKIG1zZ2lkICJEaWQgeW91IGZvcmdldCB0byAnZ2l0IGFkZCc/IgogbXNnc3RyICLmgqjmmK/lkKblv5jkuobmiafooYwgJ2dpdCBhZGQn77yfIgogCi0jOiBidWlsdGluL3N0YXNoLmM6MTMwMCBnaXQtbGVnYWN5LXN0YXNoLnNoOjM0NQorIzogYnVpbHRpbi9zdGFzaC5jOjEzMDkgZ2l0LWxlZ2FjeS1zdGFzaC5zaDozNDUKIG1zZ2lkICJObyBsb2NhbCBjaGFuZ2VzIHRvIHNhdmUiCiBtc2dzdHIgIuayoeacieimgeS/neWtmOeahOacrOWcsOS/ruaUuSIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjEzMDcgZ2l0LWxlZ2FjeS1zdGFzaC5zaDozNTAKKyM6IGJ1aWx0aW4vc3Rhc2guYzoxMzE2IGdpdC1sZWdhY3ktc3Rhc2guc2g6MzUwCiBtc2dpZCAiQ2Fubm90IGluaXRpYWxpemUgc3Rhc2giCiBtc2dzdHIgIuaXoOazleWIneWni+WMlui0ruiXjyIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjEzMjIgZ2l0LWxlZ2FjeS1zdGFzaC5zaDozNTQKKyM6IGJ1aWx0aW4vc3Rhc2guYzoxMzMxIGdpdC1sZWdhY3ktc3Rhc2guc2g6MzU0CiBtc2dpZCAiQ2Fubm90IHNhdmUgdGhlIGN1cnJlbnQgc3RhdHVzIgogbXNnc3RyICLml6Dms5Xkv53lrZjlvZPliY3nirbmgIEiCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzoxMzI3CisjOiBidWlsdGluL3N0YXNoLmM6MTMzNgogIywgYy1mb3JtYXQKIG1zZ2lkICJTYXZlZCB3b3JraW5nIGRpcmVjdG9yeSBhbmQgaW5kZXggc3RhdGUgJXMiCiBtc2dzdHIgIuS/neWtmOW3peS9nOebruW9leWSjOe0ouW8leeKtuaAgSAlcyIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjE0MTcgZ2l0LWxlZ2FjeS1zdGFzaC5zaDozODQKKyM6IGJ1aWx0aW4vc3Rhc2guYzoxNDI2IGdpdC1sZWdhY3ktc3Rhc2guc2g6Mzg0CiBtc2dpZCAiQ2Fubm90IHJlbW92ZSB3b3JrdHJlZSBjaGFuZ2VzIgogbXNnc3RyICLml6Dms5XliKDpmaTlt6XkvZzljLrlj5jmm7QiCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzoxNDUyIGJ1aWx0aW4vc3Rhc2guYzoxNDg4CisjOiBidWlsdGluL3N0YXNoLmM6MTQ2MSBidWlsdGluL3N0YXNoLmM6MTQ5NwogbXNnaWQgImtlZXAgaW5kZXgiCiBtc2dzdHIgIuS/neaMgee0ouW8lSIKIAotIzogYnVpbHRpbi9zdGFzaC5jOjE0NTQgYnVpbHRpbi9zdGFzaC5jOjE0OTAKKyM6IGJ1aWx0aW4vc3Rhc2guYzoxNDYzIGJ1aWx0aW4vc3Rhc2guYzoxNDk5CiBtc2dpZCAic3Rhc2ggaW4gcGF0Y2ggbW9kZSIKIG1zZ3N0ciAi5Lul6KGl5LiB5qih5byP6LSu6JePIgogCi0jOiBidWlsdGluL3N0YXNoLmM6MTQ1NSBidWlsdGluL3N0YXNoLmM6MTQ5MQorIzogYnVpbHRpbi9zdGFzaC5jOjE0NjQgYnVpbHRpbi9zdGFzaC5jOjE1MDAKIG1zZ2lkICJxdWlldCBtb2RlIgogbXNnc3RyICLpnZnpu5jmqKHlvI8iCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzoxNDU3IGJ1aWx0aW4vc3Rhc2guYzoxNDkzCisjOiBidWlsdGluL3N0YXNoLmM6MTQ2NiBidWlsdGluL3N0YXNoLmM6MTUwMgogbXNnaWQgImluY2x1ZGUgdW50cmFja2VkIGZpbGVzIGluIHN0YXNoIgogbXNnc3RyICLotK7ol4/kuK3ljIXlkKvmnKrot5/ouKrmlofku7YiCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzoxNDU5IGJ1aWx0aW4vc3Rhc2guYzoxNDk1CisjOiBidWlsdGluL3N0YXNoLmM6MTQ2OCBidWlsdGluL3N0YXNoLmM6MTUwNAogbXNnaWQgImluY2x1ZGUgaWdub3JlIGZpbGVzIgogbXNnc3RyICLljIXlkKvlv73nlaXnmoTmlofku7YiCiAKLSM6IGJ1aWx0aW4vc3Rhc2guYzoxNTU1CisjOiBidWlsdGluL3N0YXNoLmM6MTU2NAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgZXhlYyAlcyIKIG1zZ3N0ciAi5LiN6IO95omn6KGMICVzIgpAQCAtMTk2NDIsOCArMTk3MzIsOCBAQAogbXNnc3RyICLkuI3opoHovpPlh7rlhYvpmobov5vluqYiCiAKICM6IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxODc3Ci1tc2dpZCAiZ2l0IHN1Ym1vZHVsZS0taGVscGVyIHVwZGF0ZV9jbG9uZSBbLS1wcmVmaXg9PHBhdGg+XSBbPHBhdGg+Li4uXSIKLW1zZ3N0ciAiZ2l0IHN1Ym1vZHVsZS0taGVscGVyIHVwZGF0ZV9jbG9uZSBbLS1wcmVmaXg9POi3r+W+hD5dIFs86Lev5b6EPi4uLl0iCittc2dpZCAiZ2l0IHN1Ym1vZHVsZS0taGVscGVyIHVwZGF0ZS1jbG9uZSBbLS1wcmVmaXg9PHBhdGg+XSBbPHBhdGg+Li4uXSIKK21zZ3N0ciAiZ2l0IHN1Ym1vZHVsZS0taGVscGVyIHVwZGF0ZS1jbG9uZSBbLS1wcmVmaXg9POi3r+W+hD5dIFs86Lev5b6EPi4uLl0iCiAKICM6IGJ1aWx0aW4vc3VibW9kdWxlLS1oZWxwZXIuYzoxODkwCiBtc2dpZCAiYmFkIHZhbHVlIGZvciB1cGRhdGUgcGFyYW1ldGVyIgpAQCAtMTk2OTQsNyArMTk3ODQsNyBAQAogbXNnaWQgInBsZWFzZSBtYWtlIHN1cmUgdGhhdCB0aGUgLmdpdG1vZHVsZXMgZmlsZSBpcyBpbiB0aGUgd29ya2luZyB0cmVlIgogbXNnc3RyICLor7fnoa7orqQgLmdpdG1vZHVsZXMg5paH5Lu25Zyo5bel5L2c5Yy66YeMIgogCi0jOiBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6MjIzNSBnaXQuYzo0MzQgZ2l0LmM6Njg0CisjOiBidWlsdGluL3N1Ym1vZHVsZS0taGVscGVyLmM6MjIzNSBnaXQuYzo0MzMgZ2l0LmM6NjgzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiVzIGRvZXNuJ3Qgc3VwcG9ydCAtLXN1cGVyLXByZWZpeCIKIG1zZ3N0ciAiJXMg5LiN5pSv5oyBIC0tc3VwZXItcHJlZml4IgpAQCAtMjAwMTMsMTUzICsyMDEwMywxNTMgQEAKIG1zZ2lkICJnaXQgdXBkYXRlLWluZGV4IFs8b3B0aW9ucz5dIFstLV0gWzxmaWxlPi4uLl0iCiBtc2dzdHIgImdpdCB1cGRhdGUtaW5kZXggWzzpgInpobk+XSBbLS1dIFs85paH5Lu2Pi4uLl0iCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6OTcxCisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjk3MgogbXNnaWQgImNvbnRpbnVlIHJlZnJlc2ggZXZlbiB3aGVuIGluZGV4IG5lZWRzIHVwZGF0ZSIKIG1zZ3N0ciAi5b2T57Si5byV6ZyA6KaB5pu05paw5pe257un57ut5Yi35pawIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjk3NAorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzo5NzUKIG1zZ2lkICJyZWZyZXNoOiBpZ25vcmUgc3VibW9kdWxlcyIKIG1zZ3N0ciAi5Yi35paw77ya5b+955Wl5a2Q5qih57uEIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjk3NworIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzo5NzgKIG1zZ2lkICJkbyBub3QgaWdub3JlIG5ldyBmaWxlcyIKIG1zZ3N0ciAi5LiN5b+955Wl5paw55qE5paH5Lu2IgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjk3OQorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzo5ODAKIG1zZ2lkICJsZXQgZmlsZXMgcmVwbGFjZSBkaXJlY3RvcmllcyBhbmQgdmljZS12ZXJzYSIKIG1zZ3N0ciAi6K6p5paH5Lu25pu/5o2i55uu5b2V77yI5Y+N5LmL5Lqm54S277yJIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjk4MQorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzo5ODIKIG1zZ2lkICJub3RpY2UgZmlsZXMgbWlzc2luZyBmcm9tIHdvcmt0cmVlIgogbXNnc3RyICLpgJrnn6Xmlofku7bku47lt6XkvZzljLrkuKLlpLEiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6OTgzCisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjk4NAogbXNnaWQgInJlZnJlc2ggZXZlbiBpZiBpbmRleCBjb250YWlucyB1bm1lcmdlZCBlbnRyaWVzIgogbXNnc3RyICLljbPkvb/ntKLlvJXljLrljIXlkKvmnKrlkIjlubbnmoTmnaHnm67kuZ/miafooYzliLfmlrAiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6OTg2CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjk4NwogbXNnaWQgInJlZnJlc2ggc3RhdCBpbmZvcm1hdGlvbiIKIG1zZ3N0ciAi5Yi35paw57uf6K6h5L+h5oGvIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjk5MAorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzo5OTEKIG1zZ2lkICJsaWtlIC0tcmVmcmVzaCwgYnV0IGlnbm9yZSBhc3N1bWUtdW5jaGFuZ2VkIHNldHRpbmciCiBtc2dzdHIgIuexu+S8vOS6jiAtLXJlZnJlc2jvvIzkvYbmmK/lv73nlaUgYXNzdW1lLXVuY2hhbmdlZCDorr7nva4iCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6OTk0CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjk5NQogbXNnaWQgIjxtb2RlPiw8b2JqZWN0Piw8cGF0aD4iCiBtc2dzdHIgIjzlrZjlj5bmqKHlvI8+LDzlr7nosaE+LDzot6/lvoQ+IgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjk5NQorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzo5OTYKIG1zZ2lkICJhZGQgdGhlIHNwZWNpZmllZCBlbnRyeSB0byB0aGUgaW5kZXgiCiBtc2dzdHIgIua3u+WKoOaMh+WumueahOadoeebruWIsOe0ouW8leWMuiIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDA1CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMDYKIG1zZ2lkICJtYXJrIGZpbGVzIGFzIFwibm90IGNoYW5naW5nXCIiCiBtc2dzdHIgIuaKiuaWh+S7tuagh+iusOS4uiBcIuayoeacieWPmOabtFwiIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMDgKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAwOQogbXNnaWQgImNsZWFyIGFzc3VtZWQtdW5jaGFuZ2VkIGJpdCIKIG1zZ3N0ciAi5riF6ZmkIGFzc3VtZWQtdW5jaGFuZ2VkIOS9jSIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDExCisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMTIKIG1zZ2lkICJtYXJrIGZpbGVzIGFzIFwiaW5kZXgtb25seVwiIgogbXNnc3RyICLmiormlofku7bmoIforrDkuLogXCLku4XntKLlvJVcIiIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDE0CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMTUKIG1zZ2lkICJjbGVhciBza2lwLXdvcmt0cmVlIGJpdCIKIG1zZ3N0ciAi5riF6ZmkIHNraXAtd29ya3RyZWUg5L2NIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMTcKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAxOAogbXNnaWQgImFkZCB0byBpbmRleCBvbmx5OyBkbyBub3QgYWRkIGNvbnRlbnQgdG8gb2JqZWN0IGRhdGFiYXNlIgogbXNnc3RyICLlj6rmt7vliqDliLDntKLlvJXljLrvvJvkuI3mt7vliqDlr7nosaHliLDlr7nosaHlupMiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAxOQorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDIwCiBtc2dpZCAicmVtb3ZlIG5hbWVkIHBhdGhzIGV2ZW4gaWYgcHJlc2VudCBpbiB3b3JrdHJlZSIKIG1zZ3N0ciAi5Y2z5L2/5a2Y5Zyo5bel5L2c5Yy66YeM77yM5Lmf5Yig6Zmk6Lev5b6EIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMjEKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAyMgogbXNnaWQgIndpdGggLS1zdGRpbjogaW5wdXQgbGluZXMgYXJlIHRlcm1pbmF0ZWQgYnkgbnVsbCBieXRlcyIKIG1zZ3N0ciAi5pC65bimIC0tc3RkaW7vvJrovpPlhaXnmoTooYzku6UgbnVsbCDlrZfnrKbnu4jmraIiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAyMworIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDI0CiBtc2dpZCAicmVhZCBsaXN0IG9mIHBhdGhzIHRvIGJlIHVwZGF0ZWQgZnJvbSBzdGFuZGFyZCBpbnB1dCIKIG1zZ3N0ciAi5LuO5qCH5YeG6L6T5YWl5Lit6K+75Y+W6ZyA6KaB5pu05paw55qE6Lev5b6E5YiX6KGoIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMjcKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAyOAogbXNnaWQgImFkZCBlbnRyaWVzIGZyb20gc3RhbmRhcmQgaW5wdXQgdG8gdGhlIGluZGV4IgogbXNnc3RyICLku47moIflh4bovpPlhaXmt7vliqDmnaHnm67liLDntKLlvJXljLoiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTAzMQorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDMyCiBtc2dpZCAicmVwb3B1bGF0ZSBzdGFnZXMgIzIgYW5kICMzIGZvciB0aGUgbGlzdGVkIHBhdGhzIgogbXNnc3RyICLkuLrmjIflrprmlofku7bph43mlrDnlJ/miJDnrKwy5ZKM56ysM+aaguWtmOWMuiIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDM1CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMzYKIG1zZ2lkICJvbmx5IHVwZGF0ZSBlbnRyaWVzIHRoYXQgZGlmZmVyIGZyb20gSEVBRCIKIG1zZ3N0ciAi5Y+q5pu05paw5LiOIEhFQUQg5LiN5ZCM55qE5p2h55uuIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwMzkKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTA0MAogbXNnaWQgImlnbm9yZSBmaWxlcyBtaXNzaW5nIGZyb20gd29ya3RyZWUiCiBtc2dzdHIgIuW/veeVpeW3peS9nOWMuuS4ouWkseeahOaWh+S7tiIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDQyCisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwNDMKIG1zZ2lkICJyZXBvcnQgYWN0aW9ucyB0byBzdGFuZGFyZCBvdXRwdXQiCiBtc2dzdHIgIuWcqOagh+WHhui+k+WHuuaYvuekuuaTjeS9nCIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDQ0CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwNDUKIG1zZ2lkICIoZm9yIHBvcmNlbGFpbnMpIGZvcmdldCBzYXZlZCB1bnJlc29sdmVkIGNvbmZsaWN0cyIKIG1zZ3N0ciAiKGZvciBwb3JjZWxhaW5zKSDlv5jorrDkv53lrZjnmoTmnKrop6PlhrPnmoTlhrLnqoEiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTA0OAorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDQ5CiBtc2dpZCAid3JpdGUgaW5kZXggaW4gdGhpcyBmb3JtYXQiCiBtc2dzdHIgIuS7pei/meenjeagvOW8j+WGmeWFpee0ouW8leWMuiIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDUwCisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwNTEKIG1zZ2lkICJlbmFibGUgb3IgZGlzYWJsZSBzcGxpdCBpbmRleCIKIG1zZ3N0ciAi5ZCv55So5oiW56aB55So57Si5byV5ouG5YiGIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwNTIKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTA1MwogbXNnaWQgImVuYWJsZS9kaXNhYmxlIHVudHJhY2tlZCBjYWNoZSIKIG1zZ3N0ciAi5ZCv55SoL+emgeeUqOWvueacqui3n+i4quaWh+S7tueahOe8k+WtmCIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDU0CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwNTUKIG1zZ2lkICJ0ZXN0IGlmIHRoZSBmaWxlc3lzdGVtIHN1cHBvcnRzIHVudHJhY2tlZCBjYWNoZSIKIG1zZ3N0ciAi5rWL6K+V5paH5Lu257O757uf5piv5ZCm5pSv5oyB5pyq6Lef6Liq5paH5Lu257yT5a2YIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwNTYKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTA1NwogbXNnaWQgImVuYWJsZSB1bnRyYWNrZWQgY2FjaGUgd2l0aG91dCB0ZXN0aW5nIHRoZSBmaWxlc3lzdGVtIgogbXNnc3RyICLml6DpnIDmo4DmtYvmlofku7bns7vnu5/vvIzlkK/nlKjlr7nmnKrot5/ouKrmlofku7bnmoTnvJPlrZgiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTA1OAorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDU5CiBtc2dpZCAid3JpdGUgb3V0IHRoZSBpbmRleCBldmVuIGlmIGlzIG5vdCBmbGFnZ2VkIGFzIGNoYW5nZWQiCiBtc2dzdHIgIuWNs+S9v+ayoeacieiiq+agh+iusOS4uuW3suabtOaUue+8jOS5n+imgeWGmeWHuue0ouW8lSIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDYwCisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwNjEKIG1zZ2lkICJlbmFibGUgb3IgZGlzYWJsZSBmaWxlIHN5c3RlbSBtb25pdG9yIgogbXNnc3RyICLlkK/nlKjmiJbnpoHnlKjmlofku7bns7vnu5/nm5HmjqciCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTA2MgorIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMDYzCiBtc2dpZCAibWFyayBmaWxlcyBhcyBmc21vbml0b3IgdmFsaWQiCiBtc2dzdHIgIuagh+iusOaWh+S7tuS4uiBmc21vbml0b3Ig5pyJ5pWIIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEwNjUKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTA2NgogbXNnaWQgImNsZWFyIGZzbW9uaXRvciB2YWxpZCBiaXQiCiBtc2dzdHIgIua4hemZpCBmc21vbml0b3Ig5pyJ5pWI5L2NIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjExNjgKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTE2OQogbXNnaWQgIiIKICJjb3JlLnNwbGl0SW5kZXggaXMgc2V0IHRvIGZhbHNlOyByZW1vdmUgb3IgY2hhbmdlIGl0LCBpZiB5b3UgcmVhbGx5IHdhbnQgdG8gIgogImVuYWJsZSBzcGxpdCBpbmRleCIKIG1zZ3N0ciAiIgogImNvcmUuc3BsaXRJbmRleCDooqvorr7nva7kuLogZmFsc2XjgILlpoLmnpzmgqjnoa7lrp7opoHlkK/nlKjntKLlvJXmi4bliIbvvIzor7fliKDpmaTmiJbkv67mlLnlroPjgIIiCiAKLSM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTE3NworIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMTc4CiBtc2dpZCAiIgogImNvcmUuc3BsaXRJbmRleCBpcyBzZXQgdG8gdHJ1ZTsgcmVtb3ZlIG9yIGNoYW5nZSBpdCwgaWYgeW91IHJlYWxseSB3YW50IHRvICIKICJkaXNhYmxlIHNwbGl0IGluZGV4IgogbXNnc3RyICIiCiAiY29yZS5zcGxpdEluZGV4IOiiq+iuvue9ruS4uiB0cnVl44CC5aaC5p6c5oKo56Gu5a6e6KaB56aB55So57Si5byV5ouG5YiG77yM6K+35Yig6Zmk5oiW5L+u5pS55a6D44CCIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjExODgKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTE5MAogbXNnaWQgIiIKICJjb3JlLnVudHJhY2tlZENhY2hlIGlzIHNldCB0byB0cnVlOyByZW1vdmUgb3IgY2hhbmdlIGl0LCBpZiB5b3UgcmVhbGx5IHdhbnQgIgogInRvIGRpc2FibGUgdGhlIHVudHJhY2tlZCBjYWNoZSIKQEAgLTIwMTY3LDExICsyMDI1NywxMSBAQAogImNvcmUudW50cmFja2VkQ2FjaGUg6KKr6K6+572u5Li6IHRydWXjgILlpoLmnpzmgqjnoa7lrp7opoHnpoHnlKjmnKrot5/ouKrmlofku7bnvJPlrZjvvIzor7fliKDpmaTmiJbkv64iCiAi5pS55a6D44CCIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjExOTIKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTE5NAogbXNnaWQgIlVudHJhY2tlZCBjYWNoZSBkaXNhYmxlZCIKIG1zZ3N0ciAi57yT5a2Y5pyq6Lef6Liq5paH5Lu26KKr56aB55SoIgogCi0jOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEyMDAKKyM6IGJ1aWx0aW4vdXBkYXRlLWluZGV4LmM6MTIwMgogbXNnaWQgIiIKICJjb3JlLnVudHJhY2tlZENhY2hlIGlzIHNldCB0byBmYWxzZTsgcmVtb3ZlIG9yIGNoYW5nZSBpdCwgaWYgeW91IHJlYWxseSB3YW50ICIKICJ0byBlbmFibGUgdGhlIHVudHJhY2tlZCBjYWNoZSIKQEAgLTIwMTc5LDI1ICsyMDI2OSwyNSBAQAogImNvcmUudW50cmFja2VkQ2FjaGUg6KKr6K6+572u5Li6IGZhbHNl44CC5aaC5p6c5oKo56Gu5a6e6KaB5ZCv55So5pyq6Lef6Liq5paH5Lu257yT5a2Y77yM6K+35Yig6Zmk5oiWIgogIuS/ruaUueWug+OAgiIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMjA0CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEyMDYKICMsIGMtZm9ybWF0CiBtc2dpZCAiVW50cmFja2VkIGNhY2hlIGVuYWJsZWQgZm9yICclcyciCiBtc2dzdHIgIue8k+WtmOacqui3n+i4quaWh+S7tuWcqCAnJXMnIOWQr+eUqCIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMjEyCisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEyMTQKIG1zZ2lkICJjb3JlLmZzbW9uaXRvciBpcyB1bnNldDsgc2V0IGl0IGlmIHlvdSByZWFsbHkgd2FudCB0byBlbmFibGUgZnNtb25pdG9yIgogbXNnc3RyICJjb3JlLmZzbW9uaXRvciDmnKrorr7nva7vvJvlpoLmnpzmg7PopoHlkK/nlKggZnNtb25pdG9yIOivt+iuvue9ruivpemAiemhuSIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMjE2CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEyMTgKIG1zZ2lkICJmc21vbml0b3IgZW5hYmxlZCIKIG1zZ3N0ciAiZnNtb25pdG9yIOiiq+WQr+eUqCIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMjE5CisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEyMjEKIG1zZ2lkICIiCiAiY29yZS5mc21vbml0b3IgaXMgc2V0OyByZW1vdmUgaXQgaWYgeW91IHJlYWxseSB3YW50IHRvIGRpc2FibGUgZnNtb25pdG9yIgogbXNnc3RyICJjb3JlLmZzbW9uaXRvciDlt7Lorr7nva7vvJvlpoLmnpzmg7PopoHnpoHnlKggZnNtb25pdG9yIOivt+enu+mZpOivpemAiemhuSIKIAotIzogYnVpbHRpbi91cGRhdGUtaW5kZXguYzoxMjIzCisjOiBidWlsdGluL3VwZGF0ZS1pbmRleC5jOjEyMjUKIG1zZ2lkICJmc21vbml0b3IgZGlzYWJsZWQiCiBtc2dzdHIgImZzbW9uaXRvciDooqvnpoHnlKgiCiAKQEAgLTIwMjg5LDkwICsyMDM3OSw5MCBAQAogbXNnaWQgInByaW50IHRhZyBjb250ZW50cyIKIG1zZ3N0ciAi5omT5Y2w5qCH562+5YaF5a65IgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6MTgKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzoxNwogbXNnaWQgImdpdCB3b3JrdHJlZSBhZGQgWzxvcHRpb25zPl0gPHBhdGg+IFs8Y29tbWl0LWlzaD5dIgogbXNnc3RyICJnaXQgd29ya3RyZWUgYWRkIFs86YCJ6aG5Pl0gPOi3r+W+hD4gWzzmj5DkuqQ+XSIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjE5CisjOiBidWlsdGluL3dvcmt0cmVlLmM6MTgKIG1zZ2lkICJnaXQgd29ya3RyZWUgbGlzdCBbPG9wdGlvbnM+XSIKIG1zZ3N0ciAiZ2l0IHdvcmt0cmVlIGxpc3QgWzzpgInpobk+XSIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjIwCisjOiBidWlsdGluL3dvcmt0cmVlLmM6MTkKIG1zZ2lkICJnaXQgd29ya3RyZWUgbG9jayBbPG9wdGlvbnM+XSA8cGF0aD4iCiBtc2dzdHIgImdpdCB3b3JrdHJlZSBsb2NrIFs86YCJ6aG5Pl0gPOi3r+W+hD4iCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzoyMQorIzogYnVpbHRpbi93b3JrdHJlZS5jOjIwCiBtc2dpZCAiZ2l0IHdvcmt0cmVlIG1vdmUgPHdvcmt0cmVlPiA8bmV3LXBhdGg+IgogbXNnc3RyICJnaXQgd29ya3RyZWUgbW92ZSA85bel5L2c5Yy6PiA85paw6Lev5b6EPiIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjIyCisjOiBidWlsdGluL3dvcmt0cmVlLmM6MjEKIG1zZ2lkICJnaXQgd29ya3RyZWUgcHJ1bmUgWzxvcHRpb25zPl0iCiBtc2dzdHIgImdpdCB3b3JrdHJlZSBwcnVuZSBbPOmAiemhuT5dIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6MjMKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzoyMgogbXNnaWQgImdpdCB3b3JrdHJlZSByZW1vdmUgWzxvcHRpb25zPl0gPHdvcmt0cmVlPiIKIG1zZ3N0ciAiZ2l0IHdvcmt0cmVlIHJlbW92ZSBbPOmAiemhuT5dIDzlt6XkvZzljLo+IgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6MjQKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzoyMwogbXNnaWQgImdpdCB3b3JrdHJlZSB1bmxvY2sgPHBhdGg+IgogbXNnc3RyICJnaXQgd29ya3RyZWUgdW5sb2NrIDzot6/lvoQ+IgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NjEgYnVpbHRpbi93b3JrdHJlZS5jOjg5OQorIzogYnVpbHRpbi93b3JrdHJlZS5jOjYwIGJ1aWx0aW4vd29ya3RyZWUuYzo4OTgKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIGRlbGV0ZSAnJXMnIgogbXNnc3RyICLliKDpmaQgJyVzJyDlpLHotKUiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4MAorIzogYnVpbHRpbi93b3JrdHJlZS5jOjc5CiAjLCBjLWZvcm1hdAogbXNnaWQgIlJlbW92aW5nIHdvcmt0cmVlcy8lczogbm90IGEgdmFsaWQgZGlyZWN0b3J5IgogbXNnc3RyICLliKDpmaTlt6XkvZzljLovJXPvvJrkuI3mmK/kuIDkuKrmnInmlYjnmoTnm67lvZUiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4NgorIzogYnVpbHRpbi93b3JrdHJlZS5jOjg1CiAjLCBjLWZvcm1hdAogbXNnaWQgIlJlbW92aW5nIHdvcmt0cmVlcy8lczogZ2l0ZGlyIGZpbGUgZG9lcyBub3QgZXhpc3QiCiBtc2dzdHIgIuWIoOmZpCB3b3JrdHJlZXMvJXPvvJpnaXRkaXIg5paH5Lu25LiN5a2Y5ZyoIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6OTEgYnVpbHRpbi93b3JrdHJlZS5jOjEwMAorIzogYnVpbHRpbi93b3JrdHJlZS5jOjkwIGJ1aWx0aW4vd29ya3RyZWUuYzo5OQogIywgYy1mb3JtYXQKIG1zZ2lkICJSZW1vdmluZyB3b3JrdHJlZXMvJXM6IHVuYWJsZSB0byByZWFkIGdpdGRpciBmaWxlICglcykiCiBtc2dzdHIgIuWIoOmZpCB3b3JrdHJlZXMvJXPvvJrml6Dms5Xor7vlj5YgZ2l0ZGlyIOaWh+S7tiAoJXMpIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6MTEwCisjOiBidWlsdGluL3dvcmt0cmVlLmM6MTA5CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJSZW1vdmluZyB3b3JrdHJlZXMvJXM6IHNob3J0IHJlYWQgKGV4cGVjdGVkICU8UFJJdU1BWD4gYnl0ZXMsIHJlYWQgIgogIiU8UFJJdU1BWD4pIgogbXNnc3RyICLliKDpmaTlt6XkvZzmoJEvJXPvvJror7vlj5bov4fnn63vvIjmnJ/mnJsgJTxQUkl1TUFYPiDlrZfoioLvvIzor7vlj5YgJTxQUkl1TUFYPu+8iSIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjExOAorIzogYnVpbHRpbi93b3JrdHJlZS5jOjExNwogIywgYy1mb3JtYXQKIG1zZ2lkICJSZW1vdmluZyB3b3JrdHJlZXMvJXM6IGludmFsaWQgZ2l0ZGlyIGZpbGUiCiBtc2dzdHIgIuWIoOmZpCB3b3JrdHJlZXMvJXPvvJrml6DmlYjnmoQgZ2l0ZGlyIOaWh+S7tiIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjEyNworIzogYnVpbHRpbi93b3JrdHJlZS5jOjEyNgogIywgYy1mb3JtYXQKIG1zZ2lkICJSZW1vdmluZyB3b3JrdHJlZXMvJXM6IGdpdGRpciBmaWxlIHBvaW50cyB0byBub24tZXhpc3RlbnQgbG9jYXRpb24iCiBtc2dzdHIgIuWIoOmZpCB3b3JrdHJlZXMvJXPvvJpnaXRkaXIg5paH5Lu255qE5oyH5ZCR5LiN5a2Y5ZyoIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6MTY2CisjOiBidWlsdGluL3dvcmt0cmVlLmM6MTY1CiBtc2dpZCAicmVwb3J0IHBydW5lZCB3b3JraW5nIHRyZWVzIgogbXNnc3RyICLmiqXlkYrmuIXpmaTnmoTlt6XkvZzljLoiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzoxNjgKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzoxNjcKIG1zZ2lkICJleHBpcmUgd29ya2luZyB0cmVlcyBvbGRlciB0aGFuIDx0aW1lPiIKIG1zZ3N0ciAi5bCG5pep5LqOIDzml7bpl7Q+IOeahOW3peS9nOWMuui/h+acnyIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjIzNQorIzogYnVpbHRpbi93b3JrdHJlZS5jOjIzNAogIywgYy1mb3JtYXQKIG1zZ2lkICInJXMnIGFscmVhZHkgZXhpc3RzIgogbXNnc3RyICInJXMnIOW3sue7j+WtmOWcqCIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjI1MgorIzogYnVpbHRpbi93b3JrdHJlZS5jOjI1MQogIywgYy1mb3JtYXQKIG1zZ2lkICJ1bmFibGUgdG8gcmUtYWRkIHdvcmt0cmVlICclcyciCiBtc2dzdHIgIuaXoOazleWGjeasoea3u+WKoOW3peS9nOWMuiAnJXMnIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6MjU3CisjOiBidWlsdGluL3dvcmt0cmVlLmM6MjU2CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICInJXMnIGlzIGEgbWlzc2luZyBidXQgbG9ja2VkIHdvcmt0cmVlO1xuIgpAQCAtMjAzODEsNyArMjA0NzEsNyBAQAogIiclcycg5piv5LiA5Liq5Lii5aSx5L2G6ZSB5a6a55qE5bel5L2c5Yy677yM5L2/55SoXG4iCiAiJ2FkZCAtZiAtZicg6KaG55uW77yM5oiWICd1bmxvY2snIOWSjCAncHJ1bmUnIOaIliAncmVtb3ZlJyDmuIXpmaQiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzoyNTkKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzoyNTgKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogIiclcycgaXMgYSBtaXNzaW5nIGJ1dCBhbHJlYWR5IHJlZ2lzdGVyZWQgd29ya3RyZWU7XG4iCkBAIC0yMDM5MCwxMjAgKzIwNDgwLDEyMCBAQAogIiclcycg5piv5LiA5Liq5Lii5aSx5L2G5bey57uP5rOo5YaM55qE5bel5L2c5Yy677yM5L2/55SoXG4iCiAiJ2FkZCAtZicg6KaG55uW77yM5oiWICdwcnVuZScg5oiWICdyZW1vdmUnIOa4hemZpCIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjMwOQorIzogYnVpbHRpbi93b3JrdHJlZS5jOjMwOAogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgY3JlYXRlIGRpcmVjdG9yeSBvZiAnJXMnIgogbXNnc3RyICLkuI3og73liJvlu7rnm67lvZUgJyVzJyIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjQ0MCBidWlsdGluL3dvcmt0cmVlLmM6NDQ2CisjOiBidWlsdGluL3dvcmt0cmVlLmM6NDM5IGJ1aWx0aW4vd29ya3RyZWUuYzo0NDUKICMsIGMtZm9ybWF0CiBtc2dpZCAiUHJlcGFyaW5nIHdvcmt0cmVlIChuZXcgYnJhbmNoICclcycpIgogbXNnc3RyICLlh4blpIflt6XkvZzljLrvvIjmlrDliIbmlK8gJyVzJ++8iSIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjQ0MgorIzogYnVpbHRpbi93b3JrdHJlZS5jOjQ0MQogIywgYy1mb3JtYXQKIG1zZ2lkICJQcmVwYXJpbmcgd29ya3RyZWUgKHJlc2V0dGluZyBicmFuY2ggJyVzJzsgd2FzIGF0ICVzKSIKIG1zZ3N0ciAi5YeG5aSH5bel5L2c5Yy677yI6YeN572u5YiG5pSvICclcyfvvIzkuYvliY3kuLogJXPvvIkiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo0NTEKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo0NTAKICMsIGMtZm9ybWF0CiBtc2dpZCAiUHJlcGFyaW5nIHdvcmt0cmVlIChjaGVja2luZyBvdXQgJyVzJykiCiBtc2dzdHIgIuWHhuWkh+W3peS9nOWMuu+8iOajgOWHuiAnJXMn77yJIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NDU3CisjOiBidWlsdGluL3dvcmt0cmVlLmM6NDU2CiAjLCBjLWZvcm1hdAogbXNnaWQgIlByZXBhcmluZyB3b3JrdHJlZSAoZGV0YWNoZWQgSEVBRCAlcykiCiBtc2dzdHIgIuWHhuWkh+W3peS9nOWMuu+8iOWIhuemu+WktOaMh+mSiCAlc++8iSIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjQ5OAorIzogYnVpbHRpbi93b3JrdHJlZS5jOjQ5NwogbXNnaWQgImNoZWNrb3V0IDxicmFuY2g+IGV2ZW4gaWYgYWxyZWFkeSBjaGVja2VkIG91dCBpbiBvdGhlciB3b3JrdHJlZSIKIG1zZ3N0ciAi5qOA5Ye6IDzliIbmlK8+77yM5Y2z5L2/5bey57uP6KKr5qOA5Ye65Yiw5YW25a6D5bel5L2c5Yy6IgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NTAxCisjOiBidWlsdGluL3dvcmt0cmVlLmM6NTAwCiBtc2dpZCAiY3JlYXRlIGEgbmV3IGJyYW5jaCIKIG1zZ3N0ciAi5Yib5bu65LiA5Liq5paw5YiG5pSvIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NTAzCisjOiBidWlsdGluL3dvcmt0cmVlLmM6NTAyCiBtc2dpZCAiY3JlYXRlIG9yIHJlc2V0IGEgYnJhbmNoIgogbXNnc3RyICLliJvlu7rmiJbph43nva7kuIDkuKrliIbmlK8iCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo1MDUKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo1MDQKIG1zZ2lkICJwb3B1bGF0ZSB0aGUgbmV3IHdvcmtpbmcgdHJlZSIKIG1zZ3N0ciAi55Sf5oiQ5paw55qE5bel5L2c5Yy6IgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NTA2CisjOiBidWlsdGluL3dvcmt0cmVlLmM6NTA1CiBtc2dpZCAia2VlcCB0aGUgbmV3IHdvcmtpbmcgdHJlZSBsb2NrZWQiCiBtc2dzdHIgIumUgeWumuaWsOW3peS9nOWMuiIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjUwOQorIzogYnVpbHRpbi93b3JrdHJlZS5jOjUwOAogbXNnaWQgInNldCB1cCB0cmFja2luZyBtb2RlIChzZWUgZ2l0LWJyYW5jaCgxKSkiCiBtc2dzdHIgIuiuvue9rui3n+i4quaooeW8j++8iOWPguingSBnaXQtYnJhbmNoKDEp77yJIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NTEyCisjOiBidWlsdGluL3dvcmt0cmVlLmM6NTExCiBtc2dpZCAidHJ5IHRvIG1hdGNoIHRoZSBuZXcgYnJhbmNoIG5hbWUgd2l0aCBhIHJlbW90ZS10cmFja2luZyBicmFuY2giCiBtc2dzdHIgIuWwneivleS4uuaWsOWIhuaUr+WQjeWMuemFjeS4gOS4qui/nOeoi+i3n+i4quWIhuaUryIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjUyMAorIzogYnVpbHRpbi93b3JrdHJlZS5jOjUxOQogbXNnaWQgIi1iLCAtQiwgYW5kIC0tZGV0YWNoIGFyZSBtdXR1YWxseSBleGNsdXNpdmUiCiBtc2dzdHIgIi1i44CBLUIg5ZKMIC0tZGV0YWNoIOaYr+S6kuaWpeeahCIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjU4MQorIzogYnVpbHRpbi93b3JrdHJlZS5jOjU4MAogbXNnaWQgIi0tW25vLV10cmFjayBjYW4gb25seSBiZSB1c2VkIGlmIGEgbmV3IGJyYW5jaCBpcyBjcmVhdGVkIgogbXNnc3RyICLlj6rog73lnKjliJvlu7rmlrDliIbmlK/ml7bkvb/nlKjpgInpobkgLS1bbm8tXXRyYWNrICIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjY4MQorIzogYnVpbHRpbi93b3JrdHJlZS5jOjY4MAogbXNnaWQgInJlYXNvbiBmb3IgbG9ja2luZyIKIG1zZ3N0ciAi6ZSB5a6a5Y6f5ZugIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NjkzIGJ1aWx0aW4vd29ya3RyZWUuYzo3MjYgYnVpbHRpbi93b3JrdHJlZS5jOjgwMAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjkyNworIzogYnVpbHRpbi93b3JrdHJlZS5jOjY5MiBidWlsdGluL3dvcmt0cmVlLmM6NzI1IGJ1aWx0aW4vd29ya3RyZWUuYzo3OTkKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo5MjYKICMsIGMtZm9ybWF0CiBtc2dpZCAiJyVzJyBpcyBub3QgYSB3b3JraW5nIHRyZWUiCiBtc2dzdHIgIiclcycg5LiN5piv5LiA5Liq5bel5L2c5Yy6IgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6Njk1IGJ1aWx0aW4vd29ya3RyZWUuYzo3MjgKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo2OTQgYnVpbHRpbi93b3JrdHJlZS5jOjcyNwogbXNnaWQgIlRoZSBtYWluIHdvcmtpbmcgdHJlZSBjYW5ub3QgYmUgbG9ja2VkIG9yIHVubG9ja2VkIgogbXNnc3RyICLkuLvlt6XkvZzljLrml6Dms5XooqvliqDplIHmiJbop6PplIEiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo3MDAKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo2OTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiJyVzJyBpcyBhbHJlYWR5IGxvY2tlZCwgcmVhc29uOiAlcyIKIG1zZ3N0ciAiJyVzJyDlt7LooqvplIHlrprvvIzljp/lm6DvvJolcyIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjcwMgorIzogYnVpbHRpbi93b3JrdHJlZS5jOjcwMQogIywgYy1mb3JtYXQKIG1zZ2lkICInJXMnIGlzIGFscmVhZHkgbG9ja2VkIgogbXNnc3RyICInJXMnIOW3suiiq+mUgeWumiIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjczMAorIzogYnVpbHRpbi93b3JrdHJlZS5jOjcyOQogIywgYy1mb3JtYXQKIG1zZ2lkICInJXMnIGlzIG5vdCBsb2NrZWQiCiBtc2dzdHIgIiclcycg5pyq6KKr6ZSB5a6aIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6NzcxCisjOiBidWlsdGluL3dvcmt0cmVlLmM6NzcwCiBtc2dpZCAid29ya2luZyB0cmVlcyBjb250YWluaW5nIHN1Ym1vZHVsZXMgY2Fubm90IGJlIG1vdmVkIG9yIHJlbW92ZWQiCiBtc2dzdHIgIuS4jeiDveenu+WKqOaIluWIoOmZpOWMheWQq+WtkOaooee7hOeahOW3peS9nOWMuiIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjc3OQorIzogYnVpbHRpbi93b3JrdHJlZS5jOjc3OAogbXNnaWQgImZvcmNlIG1vdmUgZXZlbiBpZiB3b3JrdHJlZSBpcyBkaXJ0eSBvciBsb2NrZWQiCiBtc2dzdHIgIuW8uuWItuenu+WKqO+8jOWNs+S9v+W3peS9nOWMuuaYr+iEj+eahOaIluW3sumUgeWumiIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjgwMiBidWlsdGluL3dvcmt0cmVlLmM6OTI5CisjOiBidWlsdGluL3dvcmt0cmVlLmM6ODAxIGJ1aWx0aW4vd29ya3RyZWUuYzo5MjgKICMsIGMtZm9ybWF0CiBtc2dpZCAiJyVzJyBpcyBhIG1haW4gd29ya2luZyB0cmVlIgogbXNnc3RyICInJXMnIOaYr+S4gOS4quS4u+W3peS9nOWMuiIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjgwNworIzogYnVpbHRpbi93b3JrdHJlZS5jOjgwNgogIywgYy1mb3JtYXQKIG1zZ2lkICJjb3VsZCBub3QgZmlndXJlIG91dCBkZXN0aW5hdGlvbiBuYW1lIGZyb20gJyVzJyIKIG1zZ3N0ciAi5peg5rOV5LuOICclcycg566X5Ye655uu5qCH5ZCN56ewIgogCi0jOiBidWlsdGluL3dvcmt0cmVlLmM6ODEzCisjOiBidWlsdGluL3dvcmt0cmVlLmM6ODEyCiAjLCBjLWZvcm1hdAogbXNnaWQgInRhcmdldCAnJXMnIGFscmVhZHkgZXhpc3RzIgogbXNnc3RyICLnm67moIcgJyVzJyDlt7LlrZjlnKgiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4MjEKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4MjAKICMsIGMtZm9ybWF0CiBtc2dpZCAiIgogImNhbm5vdCBtb3ZlIGEgbG9ja2VkIHdvcmtpbmcgdHJlZSwgbG9jayByZWFzb246ICVzXG4iCkBAIC0yMDUxMiw3ICsyMDYwMiw3IEBACiAi5peg5rOV56e75Yqo5LiA5Liq6ZSB5a6a55qE5bel5L2c5Yy677yM6ZSB5a6a5Y6f5Zug77yaJXNcbiIKICLkvb/nlKggJ21vdmUgLWYgLWYnIOimhuebluaIluWFiOino+mUgSIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjgyMworIzogYnVpbHRpbi93b3JrdHJlZS5jOjgyMgogbXNnaWQgIiIKICJjYW5ub3QgbW92ZSBhIGxvY2tlZCB3b3JraW5nIHRyZWU7XG4iCiAidXNlICdtb3ZlIC1mIC1mJyB0byBvdmVycmlkZSBvciB1bmxvY2sgZmlyc3QiCkBAIC0yMDUyMCwzNiArMjA2MTAsMzYgQEAKICLml6Dms5Xnp7vliqjkuIDkuKrplIHlrprnmoTlt6XkvZzljLrvvIxcbiIKICLkvb/nlKggJ21vdmUgLWYgLWYnIOimhuebluaIluWFiOino+mUgSIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjgyNgorIzogYnVpbHRpbi93b3JrdHJlZS5jOjgyNQogIywgYy1mb3JtYXQKIG1zZ2lkICJ2YWxpZGF0aW9uIGZhaWxlZCwgY2Fubm90IG1vdmUgd29ya2luZyB0cmVlOiAlcyIKIG1zZ3N0ciAi6aqM6K+B5aSx6LSl77yM5peg5rOV56e75Yqo5bel5L2c5Yy677yaJXMiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4MzEKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4MzAKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIG1vdmUgJyVzJyB0byAnJXMnIgogbXNnc3RyICLnp7vliqggJyVzJyDliLAgJyVzJyDlpLHotKUiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4NzkKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4NzgKICMsIGMtZm9ybWF0CiBtc2dpZCAiZmFpbGVkIHRvIHJ1biAnZ2l0IHN0YXR1cycgb24gJyVzJyIKIG1zZ3N0ciAi5ZyoICclcycg5Lit5omn6KGMICdnaXQgc3RhdHVzJyDlpLHotKUiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4ODMKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo4ODIKICMsIGMtZm9ybWF0Ci1tc2dpZCAiJyVzJyBpcyBkaXJ0eSwgdXNlIC0tZm9yY2UgdG8gZGVsZXRlIGl0IgotbXNnc3RyICInJXMnIOaYr+iEj+eahO+8jOS9v+eUqCAtLWZvcmNlIOWIoOmZpCIKK21zZ2lkICInJXMnIGNvbnRhaW5zIG1vZGlmaWVkIG9yIHVudHJhY2tlZCBmaWxlcywgdXNlIC0tZm9yY2UgdG8gZGVsZXRlIGl0IgorbXNnc3RyICInJXMnIOWMheWQq+S/ruaUueaIluacqui3n+i4queahOaWh+S7tu+8jOS9v+eUqCAtLWZvcmNlIOWIoOmZpCIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjg4OAorIzogYnVpbHRpbi93b3JrdHJlZS5jOjg4NwogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gcnVuICdnaXQgc3RhdHVzJyBvbiAnJXMnLCBjb2RlICVkIgogbXNnc3RyICLlnKggJyVzJyDkuK3miafooYwgJ2dpdCBzdGF0dXMnIOWksei0pe+8jOmAgOWHuueggSAlZCIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjkxMQorIzogYnVpbHRpbi93b3JrdHJlZS5jOjkxMAogbXNnaWQgImZvcmNlIHJlbW92YWwgZXZlbiBpZiB3b3JrdHJlZSBpcyBkaXJ0eSBvciBsb2NrZWQiCiBtc2dzdHIgIuW8uuWItuWIoOmZpO+8jOWNs+S9v+W3peS9nOWMuuaYr+iEj+eahOaIluW3sumUgeWumiIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjkzNAorIzogYnVpbHRpbi93b3JrdHJlZS5jOjkzMwogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAiY2Fubm90IHJlbW92ZSBhIGxvY2tlZCB3b3JraW5nIHRyZWUsIGxvY2sgcmVhc29uOiAlc1xuIgpAQCAtMjA1NTgsNyArMjA2NDgsNyBAQAogIuaXoOazleWIoOmZpOS4gOS4qumUgeWumueahOW3peS9nOWMuu+8jOmUgeWumuWOn+WboO+8miVzXG4iCiAi5L2/55SoICdyZW1vdmUgLWYgLWYnIOimhuebluaIluWFiOino+mUgSIKIAotIzogYnVpbHRpbi93b3JrdHJlZS5jOjkzNgorIzogYnVpbHRpbi93b3JrdHJlZS5jOjkzNQogbXNnaWQgIiIKICJjYW5ub3QgcmVtb3ZlIGEgbG9ja2VkIHdvcmtpbmcgdHJlZTtcbiIKICJ1c2UgJ3JlbW92ZSAtZiAtZicgdG8gb3ZlcnJpZGUgb3IgdW5sb2NrIGZpcnN0IgpAQCAtMjA1NjYsNyArMjA2NTYsNyBAQAogIuaXoOazleWIoOmZpOS4gOS4qumUgeWumueahOW3peS9nOWMuu+8jFxuIgogIuS9v+eUqCAncmVtb3ZlIC1mIC1mJyDopobnm5bmiJblhYjop6PplIEiCiAKLSM6IGJ1aWx0aW4vd29ya3RyZWUuYzo5MzkKKyM6IGJ1aWx0aW4vd29ya3RyZWUuYzo5MzgKICMsIGMtZm9ybWF0CiBtc2dpZCAidmFsaWRhdGlvbiBmYWlsZWQsIGNhbm5vdCByZW1vdmUgd29ya2luZyB0cmVlOiAlcyIKIG1zZ3N0ciAi6aqM6K+B5aSx6LSl77yM5peg5rOV5Yig6Zmk5bel5L2c5Yy677yaJXMiCkBAIC0yMDU4Nyw2ICsyMDY3NywxNiBAQAogbXNnaWQgIm9ubHkgdXNlZnVsIGZvciBkZWJ1Z2dpbmciCiBtc2dzdHIgIuWPquWvueiwg+ivleacieeUqCIKIAorIzogZmFzdC1pbXBvcnQuYzozMTE4CisjLCBjLWZvcm1hdAorbXNnaWQgIkV4cGVjdGVkICdtYXJrJyBjb21tYW5kLCBnb3QgJXMiCittc2dzdHIgIumihOacnyAnbWFyaycg5ZG95Luk77yM5b6X5YiwICVzIgorCisjOiBmYXN0LWltcG9ydC5jOjMxMjMKKyMsIGMtZm9ybWF0Cittc2dpZCAiRXhwZWN0ZWQgJ3RvJyBjb21tYW5kLCBnb3QgJXMiCittc2dzdHIgIumihOacnyAndG8nIOWRveS7pO+8jOW+l+WIsCAlcyIKKwogIzogY3JlZGVudGlhbC1jYWNoZS0tZGFlbW9uLmM6MjIzCiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKQEAgLTIwNjk4LDM5ICsyMDc5OCwzOSBAQAogIuWIq+WQjSAnJXMnIOS/ruaUueeOr+Wig+WPmOmHj+OAguaCqOWPr+S7peS9v+eUqOWcqOWIq+WQjeS4rVxuIgogIuS9v+eUqCAnIWdpdCciCiAKLSM6IGdpdC5jOjM3NworIzogZ2l0LmM6Mzc2CiAjLCBjLWZvcm1hdAogbXNnaWQgImVtcHR5IGFsaWFzIGZvciAlcyIKIG1zZ3N0ciAiJXMg55qE56m65Yir5ZCNIgogCi0jOiBnaXQuYzozODAKKyM6IGdpdC5jOjM3OQogIywgYy1mb3JtYXQKIG1zZ2lkICJyZWN1cnNpdmUgYWxpYXM6ICVzIgogbXNnc3RyICLpgJLlvZLnmoTliKvlkI3vvJolcyIKIAotIzogZ2l0LmM6NDYwCisjOiBnaXQuYzo0NTkKIG1zZ2lkICJ3cml0ZSBmYWlsdXJlIG9uIHN0YW5kYXJkIG91dHB1dCIKIG1zZ3N0ciAi5Zyo5qCH5YeG6L6T5Ye65YaZ5YWl5aSx6LSlIgogCi0jOiBnaXQuYzo0NjIKKyM6IGdpdC5jOjQ2MQogbXNnaWQgInVua25vd24gd3JpdGUgZmFpbHVyZSBvbiBzdGFuZGFyZCBvdXRwdXQiCiBtc2dzdHIgIuWIsOagh+WHhui+k+WHuueahOacquefpeWGmeWFpemUmeivryIKIAotIzogZ2l0LmM6NDY0CisjOiBnaXQuYzo0NjMKIG1zZ2lkICJjbG9zZSBmYWlsZWQgb24gc3RhbmRhcmQgb3V0cHV0IgogbXNnc3RyICLmoIflh4bovpPlh7rlhbPpl63lpLHotKUiCiAKLSM6IGdpdC5jOjc5MworIzogZ2l0LmM6NzkyCiAjLCBjLWZvcm1hdAogbXNnaWQgImFsaWFzIGxvb3AgZGV0ZWN0ZWQ6IGV4cGFuc2lvbiBvZiAnJXMnIGRvZXMgbm90IHRlcm1pbmF0ZTolcyIKIG1zZ3N0ciAi5qOA5rWL5Yiw5Yir5ZCN5b6q546v77yaJyVzJ+eahOaJqeWxleacque7iOatou+8miVzIgogCi0jOiBnaXQuYzo4NDMKKyM6IGdpdC5jOjg0MgogIywgYy1mb3JtYXQKIG1zZ2lkICJjYW5ub3QgaGFuZGxlICVzIGFzIGEgYnVpbHRpbiIKIG1zZ3N0ciAi5LiN6IO95L2c5Li65YaF572u5ZG95Luk5aSE55CGICVzIgogCi0jOiBnaXQuYzo4NTYKKyM6IGdpdC5jOjg1NQogIywgYy1mb3JtYXQKIG1zZ2lkICIiCiAidXNhZ2U6ICVzXG4iCkBAIC0yMDczOSwxMiArMjA4MzksMTIgQEAKICLnlKjms5XvvJolc1xuIgogIlxuIgogCi0jOiBnaXQuYzo4NzYKKyM6IGdpdC5jOjg3NQogIywgYy1mb3JtYXQKIG1zZ2lkICJleHBhbnNpb24gb2YgYWxpYXMgJyVzJyBmYWlsZWQ7ICclcycgaXMgbm90IGEgZ2l0IGNvbW1hbmRcbiIKIG1zZ3N0ciAi5bGV5byA5Yir5ZCN5ZG95LukICclcycg5aSx6LSl77yMJyVzJyDkuI3mmK/kuIDkuKogZ2l0IOWRveS7pFxuIgogCi0jOiBnaXQuYzo4ODgKKyM6IGdpdC5jOjg4NwogIywgYy1mb3JtYXQKIG1zZ2lkICJmYWlsZWQgdG8gcnVuIGNvbW1hbmQgJyVzJzogJXNcbiIKIG1zZ3N0ciAi6L+Q6KGM5ZG95LukICclcycg5aSx6LSl77yaJXNcbiIKQEAgLTIwNzYyLDMwICsyMDg2MiwzMCBAQAogbXNnaWQgIlB1YmxpYyBrZXkgcGlubmluZyBub3Qgc3VwcG9ydGVkIHdpdGggY1VSTCA8IDcuNDQuMCIKIG1zZ3N0ciAi5LiN5pSv5oyB5YWs6ZKl5paH5Lu26ZSB5a6a77yM5Zug5Li6IGNVUkwgPCA3LjQ0LjAiCiAKLSM6IGh0dHAuYzo4NzYKKyM6IGh0dHAuYzo4NzgKIG1zZ2lkICJDVVJMU1NMT1BUX05PX1JFVk9LRSBub3Qgc3VwcG9ydGVkIHdpdGggY1VSTCA8IDcuNDQuMCIKIG1zZ3N0ciAi5LiN5pSv5oyBIENVUkxTU0xPUFRfTk9fUkVWT0tF77yM5Zug5Li6IGNVUkwgPCA3LjQ0LjAiCiAKLSM6IGh0dHAuYzo5NDkKKyM6IGh0dHAuYzo5NTEKIG1zZ2lkICJQcm90b2NvbCByZXN0cmljdGlvbnMgbm90IHN1cHBvcnRlZCB3aXRoIGNVUkwgPCA3LjE5LjQiCiBtc2dzdHIgIuS4jeaUr+aMgeWNj+iurumZkOWItu+8jOWboOS4uiBjVVJMIDwgNy4xOS40IgogCi0jOiBodHRwLmM6MTA4NQorIzogaHR0cC5jOjEwODgKICMsIGMtZm9ybWF0CiBtc2dpZCAiVW5zdXBwb3J0ZWQgU1NMIGJhY2tlbmQgJyVzJy4gU3VwcG9ydGVkIFNTTCBiYWNrZW5kczoiCiBtc2dzdHIgIuS4jeaUr+aMgeeahCBTU0wg5ZCO56uvICclcyfjgILmlK/mjIHnmoQgU1NMIOWQjuerr++8miIKIAotIzogaHR0cC5jOjEwOTIKKyM6IGh0dHAuYzoxMDk1CiAjLCBjLWZvcm1hdAogbXNnaWQgIkNvdWxkIG5vdCBzZXQgU1NMIGJhY2tlbmQgdG8gJyVzJzogY1VSTCB3YXMgYnVpbHQgd2l0aG91dCBTU0wgYmFja2VuZHMiCiBtc2dzdHIgIuaXoOazleiuvue9riBTU0wg5ZCO56uv5Li6ICclcyfvvJpjVVJMOiBjVVJMIOayoeacieS9v+eUqCBTU0wg5ZCO56uv5p6E5bu6IgogCi0jOiBodHRwLmM6MTA5NgorIzogaHR0cC5jOjEwOTkKICMsIGMtZm9ybWF0CiBtc2dpZCAiQ291bGQgbm90IHNldCBTU0wgYmFja2VuZCB0byAnJXMnOiBhbHJlYWR5IHNldCIKIG1zZ3N0ciAi5peg5rOV5bCGIFNTTCDlkI7nq6/orr7nva7kuLogJyVzJ++8muW3sue7j+iuvue9riIKIAotIzogaHR0cC5jOjE5NjUKKyM6IGh0dHAuYzoxOTY4CiAjLCBjLWZvcm1hdAogbXNnaWQgIiIKICJ1bmFibGUgdG8gdXBkYXRlIHVybCBiYXNlIGZyb20gcmVkaXJlY3Rpb246XG4iCkBAIC0yMDc5NiwxMjggKzIwODk2LDEyOCBAQAogIiAgICAg6K+35rGC77yaJXNcbiIKICIgICDph43lrprlkJHvvJolcyIKIAotIzogcmVtb3RlLWN1cmwuYzoxNTcKKyM6IHJlbW90ZS1jdXJsLmM6MTY2CiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgcXVvdGluZyBpbiBwdXNoLW9wdGlvbiB2YWx1ZTogJyVzJyIKIG1zZ3N0ciAi5ZyoIHB1c2gtb3B0aW9uIOWPluWAvOS4reaXoOaViOeahOW8leWPt++8miclcyciCiAKLSM6IHJlbW90ZS1jdXJsLmM6MjU0CisjOiByZW1vdGUtY3VybC5jOjI2MwogIywgYy1mb3JtYXQKIG1zZ2lkICIlc2luZm8vcmVmcyBub3QgdmFsaWQ6IGlzIHRoaXMgYSBnaXQgcmVwb3NpdG9yeT8iCiBtc2dzdHIgIiVzaW5mby9yZWZzIOaXoOaViO+8mui/meaYr+S4gOS4qiBnaXQg5LuT5bqT5LmI77yfIgogCi0jOiByZW1vdGUtY3VybC5jOjM1NQorIzogcmVtb3RlLWN1cmwuYzozNjQKIG1zZ2lkICJpbnZhbGlkIHNlcnZlciByZXNwb25zZTsgZXhwZWN0ZWQgc2VydmljZSwgZ290IGZsdXNoIHBhY2tldCIKIG1zZ3N0ciAi5peg5pWI55qE5pyN5Yqh56uv5ZON5bqU44CC6aKE5pyf5pyN5Yqh77yM5b6X5YiwIGZsdXNoIOWMhSIKIAotIzogcmVtb3RlLWN1cmwuYzozODYKKyM6IHJlbW90ZS1jdXJsLmM6Mzk1CiAjLCBjLWZvcm1hdAogbXNnaWQgImludmFsaWQgc2VydmVyIHJlc3BvbnNlOyBnb3QgJyVzJyIKIG1zZ3N0ciAi5peg5pWI55qE5pyN5Yqh56uv5ZON5bqU77yM5b6X5YiwICclcyciCiAKLSM6IHJlbW90ZS1jdXJsLmM6NDQ2CisjOiByZW1vdGUtY3VybC5jOjQ1NQogIywgYy1mb3JtYXQKIG1zZ2lkICJyZXBvc2l0b3J5ICclcycgbm90IGZvdW5kIgogbXNnc3RyICLku5PlupMgJyVzJyDmnKrmib7liLAiCiAKLSM6IHJlbW90ZS1jdXJsLmM6NDUwCisjOiByZW1vdGUtY3VybC5jOjQ1OQogIywgYy1mb3JtYXQKIG1zZ2lkICJBdXRoZW50aWNhdGlvbiBmYWlsZWQgZm9yICclcyciCiBtc2dzdHIgIiclcycg6Ym05p2D5aSx6LSlIgogCi0jOiByZW1vdGUtY3VybC5jOjQ1NAorIzogcmVtb3RlLWN1cmwuYzo0NjMKICMsIGMtZm9ybWF0CiBtc2dpZCAidW5hYmxlIHRvIGFjY2VzcyAnJXMnOiAlcyIKIG1zZ3N0ciAi5peg5rOV6K6/6ZeuICclcyfvvJolcyIKIAotIzogcmVtb3RlLWN1cmwuYzo0NjAKKyM6IHJlbW90ZS1jdXJsLmM6NDY5CiAjLCBjLWZvcm1hdAogbXNnaWQgInJlZGlyZWN0aW5nIHRvICVzIgogbXNnc3RyICLph43lrprlkJHliLAgJXMiCiAKLSM6IHJlbW90ZS1jdXJsLmM6NTg0CisjOiByZW1vdGUtY3VybC5jOjU5MwogbXNnaWQgInNob3VsZG4ndCBoYXZlIEVPRiB3aGVuIG5vdCBnZW50bGUgb24gRU9GIgogbXNnc3RyICLlvZPmsqHmnInorr7nva7muKnlkozlpITnkIbmlofku7bnu5PmnZ/nrKbvvIhFT0bvvInml7bvvIzkuI3lupTor6XmnInmlofku7bnu5PmnZ/nrKYiCiAKLSM6IHJlbW90ZS1jdXJsLmM6NjY0CisjOiByZW1vdGUtY3VybC5jOjY3MwogbXNnaWQgInVuYWJsZSB0byByZXdpbmQgcnBjIHBvc3QgZGF0YSAtIHRyeSBpbmNyZWFzaW5nIGh0dHAucG9zdEJ1ZmZlciIKIG1zZ3N0ciAi5peg5rOV5YCS5ZueIHJwYyBwb3N0IOaVsOaNriAtIOWwneivleWinuWKoCBodHRwLnBvc3RCdWZmZXIiCiAKLSM6IHJlbW90ZS1jdXJsLmM6NzI0CisjOiByZW1vdGUtY3VybC5jOjczMwogIywgYy1mb3JtYXQKIG1zZ2lkICJSUEMgZmFpbGVkOyAlcyIKIG1zZ3N0ciAiUlBDIOWksei0peOAgiVzIgogCi0jOiByZW1vdGUtY3VybC5jOjc2NAorIzogcmVtb3RlLWN1cmwuYzo3NzMKIG1zZ2lkICJjYW5ub3QgaGFuZGxlIHB1c2hlcyB0aGlzIGJpZyIKIG1zZ3N0ciAi5LiN6IO95aSE55CG6L+Z5LmI5aSn55qE5o6o6YCBIgogCi0jOiByZW1vdGUtY3VybC5jOjg3OQorIzogcmVtb3RlLWN1cmwuYzo4ODgKICMsIGMtZm9ybWF0CiBtc2dpZCAiY2Fubm90IGRlZmxhdGUgcmVxdWVzdDsgemxpYiBkZWZsYXRlIGVycm9yICVkIgogbXNnc3RyICLkuI3og73ljovnvKnor7fmsYLvvIx6bGliIOWOi+e8qemUmeivryAlZCIKIAotIzogcmVtb3RlLWN1cmwuYzo4ODMKKyM6IHJlbW90ZS1jdXJsLmM6ODkyCiAjLCBjLWZvcm1hdAogbXNnaWQgImNhbm5vdCBkZWZsYXRlIHJlcXVlc3Q7IHpsaWIgZW5kIGVycm9yICVkIgogbXNnc3RyICLkuI3og73ljovnvKnor7fmsYLvvIx6bGliIOe7k+adn+mUmeivryAlZCIKIAotIzogcmVtb3RlLWN1cmwuYzoxMDE0CisjOiByZW1vdGUtY3VybC5jOjEwMjMKIG1zZ2lkICJkdW1iIGh0dHAgdHJhbnNwb3J0IGRvZXMgbm90IHN1cHBvcnQgc2hhbGxvdyBjYXBhYmlsaXRpZXMiCiBtc2dzdHIgIuWTkSBodHRwIOS8oOi+k+S4jeaUr+aMgSBzaGFsbGxvdyDog73lipsiCiAKLSM6IHJlbW90ZS1jdXJsLmM6MTAyOAorIzogcmVtb3RlLWN1cmwuYzoxMDM3CiBtc2dpZCAiZmV0Y2ggZmFpbGVkLiIKIG1zZ3N0ciAi6I635Y+W5aSx6LSl44CCIgogCi0jOiByZW1vdGUtY3VybC5jOjEwNzYKKyM6IHJlbW90ZS1jdXJsLmM6MTA4NQogbXNnaWQgImNhbm5vdCBmZXRjaCBieSBzaGExIG92ZXIgc21hcnQgaHR0cCIKIG1zZ3N0ciAi5peg5rOV6YCa6L+H5pm66IO9IEhUVFAg6I635Y+WIHNoYTEiCiAKLSM6IHJlbW90ZS1jdXJsLmM6MTEyMCByZW1vdGUtY3VybC5jOjExMjYKKyM6IHJlbW90ZS1jdXJsLmM6MTEyOSByZW1vdGUtY3VybC5jOjExMzUKICMsIGMtZm9ybWF0CiBtc2dpZCAicHJvdG9jb2wgZXJyb3I6IGV4cGVjdGVkIHNoYS9yZWYsIGdvdCAnJXMnIgogbXNnc3RyICLljY/orq7plJnor6/vvJrmnJ/mnJsgc2hhL3JlZu+8jOWNtOW+l+WIsCAnJXMnIgogCi0jOiByZW1vdGUtY3VybC5jOjExMzggcmVtb3RlLWN1cmwuYzoxMjUyCisjOiByZW1vdGUtY3VybC5jOjExNDcgcmVtb3RlLWN1cmwuYzoxMjYxCiAjLCBjLWZvcm1hdAogbXNnaWQgImh0dHAgdHJhbnNwb3J0IGRvZXMgbm90IHN1cHBvcnQgJXMiCiBtc2dzdHIgImh0dHAg5Lyg6L6T5Y2P6K6u5LiN5pSv5oyBICVzIgogCi0jOiByZW1vdGUtY3VybC5jOjExNzQKKyM6IHJlbW90ZS1jdXJsLmM6MTE4MwogbXNnaWQgImdpdC1odHRwLXB1c2ggZmFpbGVkIgogbXNnc3RyICJnaXQtaHR0cC1wdXNoIOWksei0pSIKIAotIzogcmVtb3RlLWN1cmwuYzoxMzYwCisjOiByZW1vdGUtY3VybC5jOjEzNjcKIG1zZ2lkICJyZW1vdGUtY3VybDogdXNhZ2U6IGdpdCByZW1vdGUtY3VybCA8cmVtb3RlPiBbPHVybD5dIgogbXNnc3RyICJyZW1vdGUtY3VybO+8mueUqOazle+8mmdpdCByZW1vdGUtY3VybCA86L+c56iLPiBbPHVybD5dIgogCi0jOiByZW1vdGUtY3VybC5jOjEzOTIKKyM6IHJlbW90ZS1jdXJsLmM6MTM5OQogbXNnaWQgInJlbW90ZS1jdXJsOiBlcnJvciByZWFkaW5nIGNvbW1hbmQgc3RyZWFtIGZyb20gZ2l0IgogbXNnc3RyICJyZW1vdGUtY3VybO+8mumUmeivr+ivu+WPluadpeiHqiBnaXQg55qE5ZG95Luk5rWBIgogCi0jOiByZW1vdGUtY3VybC5jOjEzOTkKKyM6IHJlbW90ZS1jdXJsLmM6MTQwNgogbXNnaWQgInJlbW90ZS1jdXJsOiBmZXRjaCBhdHRlbXB0ZWQgd2l0aG91dCBhIGxvY2FsIHJlcG8iCiBtc2dzdHIgInJlbW90ZS1jdXJs77ya5bCd6K+V5rKh5pyJ5pys5Zyw5LuT5bqT5LiL6I635Y+WIgogCi0jOiByZW1vdGUtY3VybC5jOjE0MzkKKyM6IHJlbW90ZS1jdXJsLmM6MTQ0NgogIywgYy1mb3JtYXQKIG1zZ2lkICJyZW1vdGUtY3VybDogdW5rbm93biBjb21tYW5kICclcycgZnJvbSBnaXQiCiBtc2dzdHIgInJlbW90ZS1jdXJs77ya5pyq55+l55qE5p2l6IeqIGdpdCDnmoTlkb3ku6QgJyVzJyIKIAotIzogbGlzdC1vYmplY3RzLWZpbHRlci1vcHRpb25zLmg6NjEKKyM6IGxpc3Qtb2JqZWN0cy1maWx0ZXItb3B0aW9ucy5oOjg1CiBtc2dpZCAiYXJncyIKIG1zZ3N0ciAi5Y+C5pWwIgogCi0jOiBsaXN0LW9iamVjdHMtZmlsdGVyLW9wdGlvbnMuaDo2MgorIzogbGlzdC1vYmplY3RzLWZpbHRlci1vcHRpb25zLmg6ODYKIG1zZ2lkICJvYmplY3QgZmlsdGVyaW5nIgogbXNnc3RyICLlr7nosaHov4fmu6QiCiAKLSM6IHBhcnNlLW9wdGlvbnMuaDoxNzAKKyM6IHBhcnNlLW9wdGlvbnMuaDoxNzkKIG1zZ2lkICJleHBpcnktZGF0ZSIKIG1zZ3N0ciAi5Yiw5pyf5pe26Ze0IgogCi0jOiBwYXJzZS1vcHRpb25zLmg6MTg0CisjOiBwYXJzZS1vcHRpb25zLmg6MTkzCiBtc2dpZCAibm8tb3AgKGJhY2t3YXJkIGNvbXBhdGliaWxpdHkpIgogbXNnc3RyICLnqbrmk43kvZzvvIjlkJHlkI7lhbzlrrnvvIkiCiAKZGlmZiAtLWdpdCBhL3ByZXR0eS5jIGIvcHJldHR5LmMKaW5kZXggZTRlZDE0ZS4uOTNlYjZlOCAxMDA2NDQKLS0tIGEvcHJldHR5LmMKKysrIGIvcHJldHR5LmMKQEAgLTY5Niw3ICs2OTYsNyBAQAogCW1haWwgPSBzLm1haWxfYmVnaW47CiAJbWFpbGxlbiA9IHMubWFpbF9lbmQgLSBzLm1haWxfYmVnaW47CiAKLQlpZiAocGFydCA9PSAnTicgfHwgcGFydCA9PSAnRScpIC8qIG1haWxtYXAgbG9va3VwICovCisJaWYgKHBhcnQgPT0gJ04nIHx8IHBhcnQgPT0gJ0UnIHx8IHBhcnQgPT0gJ0wnKSAvKiBtYWlsbWFwIGxvb2t1cCAqLwogCQltYWlsbWFwX25hbWUoJm1haWwsICZtYWlsbGVuLCAmbmFtZSwgJm5hbWVsZW4pOwogCWlmIChwYXJ0ID09ICduJyB8fCBwYXJ0ID09ICdOJykgewkvKiBuYW1lICovCiAJCXN0cmJ1Zl9hZGQoc2IsIG5hbWUsIG5hbWVsZW4pOwpAQCAtNzA2LDYgKzcwNiwxMyBAQAogCQlzdHJidWZfYWRkKHNiLCBtYWlsLCBtYWlsbGVuKTsKIAkJcmV0dXJuIHBsYWNlaG9sZGVyX2xlbjsKIAl9CisJaWYgKHBhcnQgPT0gJ2wnIHx8IHBhcnQgPT0gJ0wnKSB7CS8qIGxvY2FsLXBhcnQgKi8KKwkJY29uc3QgY2hhciAqYXQgPSBtZW1jaHIobWFpbCwgJ0AnLCBtYWlsbGVuKTsKKwkJaWYgKGF0KQorCQkJbWFpbGxlbiA9IGF0IC0gbWFpbDsKKwkJc3RyYnVmX2FkZChzYiwgbWFpbCwgbWFpbGxlbik7CisJCXJldHVybiBwbGFjZWhvbGRlcl9sZW47CisJfQogCiAJaWYgKCFzLmRhdGVfYmVnaW4pCiAJCWdvdG8gc2tpcDsKQEAgLTEyMzksMTEgKzEyNDYsOSBAQAogCQlzdHJidWZfYWRkc3RyKHNiLCBnZXRfcmV2aXNpb25fbWFyayhOVUxMLCBjb21taXQpKTsKIAkJcmV0dXJuIDE7CiAJY2FzZSAnZCc6Ci0JCWxvYWRfcmVmX2RlY29yYXRpb25zKE5VTEwsIERFQ09SQVRFX1NIT1JUX1JFRlMpOwogCQlmb3JtYXRfZGVjb3JhdGlvbnMoc2IsIGNvbW1pdCwgYy0+YXV0b19jb2xvcik7CiAJCXJldHVybiAxOwogCWNhc2UgJ0QnOgotCQlsb2FkX3JlZl9kZWNvcmF0aW9ucyhOVUxMLCBERUNPUkFURV9TSE9SVF9SRUZTKTsKIAkJZm9ybWF0X2RlY29yYXRpb25zX2V4dGVuZGVkKHNiLCBjb21taXQsIGMtPmF1dG9fY29sb3IsICIiLCAiLCAiLCAiIik7CiAJCXJldHVybiAxOwogCWNhc2UgJ1MnOgkJLyogdGFnL2JyYW5jaCBsaWtlIC0tc291cmNlICovCmRpZmYgLS1naXQgYS9wcm9ncmVzcy5jIGIvcHJvZ3Jlc3MuYwppbmRleCAyNzdkYjhhLi4wMDYzNTU5IDEwMDY0NAotLS0gYS9wcm9ncmVzcy5jCisrKyBiL3Byb2dyZXNzLmMKQEAgLTQ1LDYgKzQ1LDE5IEBACiAKIHN0YXRpYyB2b2xhdGlsZSBzaWdfYXRvbWljX3QgcHJvZ3Jlc3NfdXBkYXRlOwogCisvKgorICogVGhlc2UgYXJlIG9ubHkgaW50ZW5kZWQgZm9yIHRlc3RpbmcgdGhlIHByb2dyZXNzIG91dHB1dCwgaS5lLiBleGNsdXNpdmVseQorICogZm9yICd0ZXN0LXRvb2wgcHJvZ3Jlc3MnLgorICovCitpbnQgcHJvZ3Jlc3NfdGVzdGluZzsKK3VpbnQ2NF90IHByb2dyZXNzX3Rlc3RfbnMgPSAwOwordm9pZCBwcm9ncmVzc190ZXN0X2ZvcmNlX3VwZGF0ZSh2b2lkKTsgLyogVG8gc2lsZW5jZSAtV21pc3NpbmctcHJvdG90eXBlcyAqLwordm9pZCBwcm9ncmVzc190ZXN0X2ZvcmNlX3VwZGF0ZSh2b2lkKQoreworCXByb2dyZXNzX3VwZGF0ZSA9IDE7Cit9CisKKwogc3RhdGljIHZvaWQgcHJvZ3Jlc3NfaW50ZXJ2YWwoaW50IHNpZ251bSkKIHsKIAlwcm9ncmVzc191cGRhdGUgPSAxOwpAQCAtNTUsNiArNjgsOSBAQAogCXN0cnVjdCBzaWdhY3Rpb24gc2E7CiAJc3RydWN0IGl0aW1lcnZhbCB2OwogCisJaWYgKHByb2dyZXNzX3Rlc3RpbmcpCisJCXJldHVybjsKKwogCXByb2dyZXNzX3VwZGF0ZSA9IDA7CiAKIAltZW1zZXQoJnNhLCAwLCBzaXplb2Yoc2EpKTsKQEAgLTcyLDYgKzg4LDEwIEBACiBzdGF0aWMgdm9pZCBjbGVhcl9wcm9ncmVzc19zaWduYWwodm9pZCkKIHsKIAlzdHJ1Y3QgaXRpbWVydmFsIHYgPSB7ezAsfSx9OworCisJaWYgKHByb2dyZXNzX3Rlc3RpbmcpCisJCXJldHVybjsKKwogCXNldGl0aW1lcihJVElNRVJfUkVBTCwgJnYsIE5VTEwpOwogCXNpZ25hbChTSUdBTFJNLCBTSUdfSUdOKTsKIAlwcm9ncmVzc191cGRhdGUgPSAwOwpAQCAtODgsNiArMTA4LDcgQEAKIAljb25zdCBjaGFyICp0cDsKIAlzdHJ1Y3Qgc3RyYnVmICpjb3VudGVyc19zYiA9ICZwcm9ncmVzcy0+Y291bnRlcnNfc2I7CiAJaW50IHNob3dfdXBkYXRlID0gMDsKKwlpbnQgbGFzdF9jb3VudF9sZW4gPSBjb3VudGVyc19zYi0+bGVuOwogCiAJaWYgKHByb2dyZXNzLT5kZWxheSAmJiAoIXByb2dyZXNzX3VwZGF0ZSB8fCAtLXByb2dyZXNzLT5kZWxheSkpCiAJCXJldHVybjsKQEAgLTExNSwyMSArMTM2LDI3IEBACiAJaWYgKHNob3dfdXBkYXRlKSB7CiAJCWlmIChpc19mb3JlZ3JvdW5kX2ZkKGZpbGVubyhzdGRlcnIpKSB8fCBkb25lKSB7CiAJCQljb25zdCBjaGFyICplb2wgPSBkb25lID8gZG9uZSA6ICJcciI7CisJCQlzaXplX3QgY2xlYXJfbGVuID0gY291bnRlcnNfc2ItPmxlbiA8IGxhc3RfY291bnRfbGVuID8KKwkJCQkJbGFzdF9jb3VudF9sZW4gLSBjb3VudGVyc19zYi0+bGVuICsgMSA6CisJCQkJCTA7CisJCQkvKiBUaGUgIisgMiIgYWNjb3VudHMgZm9yIHRoZSAiOiAiLiAqLworCQkJc2l6ZV90IHByb2dyZXNzX2xpbmVfbGVuID0gcHJvZ3Jlc3MtPnRpdGxlX2xlbiArCisJCQkJCQljb3VudGVyc19zYi0+bGVuICsgMjsKKwkJCWludCBjb2xzID0gdGVybV9jb2x1bW5zKCk7CiAKLQkJCXRlcm1fY2xlYXJfbGluZSgpOwogCQkJaWYgKHByb2dyZXNzLT5zcGxpdCkgewotCQkJCWZwcmludGYoc3RkZXJyLCAiICAlcyVzIiwgY291bnRlcnNfc2ItPmJ1ZiwKLQkJCQkJZW9sKTsKLQkJCX0gZWxzZSBpZiAoIWRvbmUgJiYKLQkJCQkgICAvKiBUaGUgIisgMiIgYWNjb3VudHMgZm9yIHRoZSAiOiAiLiAqLwotCQkJCSAgIHRlcm1fY29sdW1ucygpIDwgcHJvZ3Jlc3MtPnRpdGxlX2xlbiArCi0JCQkJCQkgICAgY291bnRlcnNfc2ItPmxlbiArIDIpIHsKLQkJCQlmcHJpbnRmKHN0ZGVyciwgIiVzOlxuICAlcyVzIiwKLQkJCQkJcHJvZ3Jlc3MtPnRpdGxlLCBjb3VudGVyc19zYi0+YnVmLCBlb2wpOworCQkJCWZwcmludGYoc3RkZXJyLCAiICAlcyUqcyIsIGNvdW50ZXJzX3NiLT5idWYsCisJCQkJCShpbnQpIGNsZWFyX2xlbiwgZW9sKTsKKwkJCX0gZWxzZSBpZiAoIWRvbmUgJiYgY29scyA8IHByb2dyZXNzX2xpbmVfbGVuKSB7CisJCQkJY2xlYXJfbGVuID0gcHJvZ3Jlc3MtPnRpdGxlX2xlbiArIDEgPCBjb2xzID8KKwkJCQkJICAgIGNvbHMgLSBwcm9ncmVzcy0+dGl0bGVfbGVuIC0gMSA6IDA7CisJCQkJZnByaW50ZihzdGRlcnIsICIlczolKnNcbiAgJXMlcyIsCisJCQkJCXByb2dyZXNzLT50aXRsZSwgKGludCkgY2xlYXJfbGVuLCAiIiwKKwkJCQkJY291bnRlcnNfc2ItPmJ1ZiwgZW9sKTsKIAkJCQlwcm9ncmVzcy0+c3BsaXQgPSAxOwogCQkJfSBlbHNlIHsKLQkJCQlmcHJpbnRmKHN0ZGVyciwgIiVzOiAlcyVzIiwgcHJvZ3Jlc3MtPnRpdGxlLAotCQkJCQljb3VudGVyc19zYi0+YnVmLCBlb2wpOworCQkJCWZwcmludGYoc3RkZXJyLCAiJXM6ICVzJSpzIiwgcHJvZ3Jlc3MtPnRpdGxlLAorCQkJCQljb3VudGVyc19zYi0+YnVmLCAoaW50KSBjbGVhcl9sZW4sIGVvbCk7CiAJCQl9CiAJCQlmZmx1c2goc3RkZXJyKTsKIAkJfQpAQCAtMTQ3LDYgKzE3NCwxNCBAQAogCXN0cmJ1Zl9odW1hbmlzZV9yYXRlKGJ1ZiwgcmF0ZSAqIDEwMjQpOwogfQogCitzdGF0aWMgdWludDY0X3QgcHJvZ3Jlc3NfZ2V0bmFub3RpbWUoc3RydWN0IHByb2dyZXNzICpwcm9ncmVzcykKK3sKKwlpZiAocHJvZ3Jlc3NfdGVzdGluZykKKwkJcmV0dXJuIHByb2dyZXNzLT5zdGFydF9ucyArIHByb2dyZXNzX3Rlc3RfbnM7CisJZWxzZQorCQlyZXR1cm4gZ2V0bmFub3RpbWUoKTsKK30KKwogdm9pZCBkaXNwbGF5X3Rocm91Z2hwdXQoc3RydWN0IHByb2dyZXNzICpwcm9ncmVzcywgdWludDY0X3QgdG90YWwpCiB7CiAJc3RydWN0IHRocm91Z2hwdXQgKnRwOwpAQCAtMTU3LDcgKzE5Miw3IEBACiAJCXJldHVybjsKIAl0cCA9IHByb2dyZXNzLT50aHJvdWdocHV0OwogCi0Jbm93X25zID0gZ2V0bmFub3RpbWUoKTsKKwlub3dfbnMgPSBwcm9ncmVzc19nZXRuYW5vdGltZShwcm9ncmVzcyk7CiAKIAlpZiAoIXRwKSB7CiAJCXByb2dyZXNzLT50aHJvdWdocHV0ID0gdHAgPSB4Y2FsbG9jKDEsIHNpemVvZigqdHApKTsKQEAgLTI4OSw3ICszMjQsNyBAQAogCQlzdHJ1Y3QgdGhyb3VnaHB1dCAqdHAgPSBwcm9ncmVzcy0+dGhyb3VnaHB1dDsKIAogCQlpZiAodHApIHsKLQkJCXVpbnQ2NF90IG5vd19ucyA9IGdldG5hbm90aW1lKCk7CisJCQl1aW50NjRfdCBub3dfbnMgPSBwcm9ncmVzc19nZXRuYW5vdGltZShwcm9ncmVzcyk7CiAJCQl1bnNpZ25lZCBpbnQgbWlzZWNzLCByYXRlOwogCQkJbWlzZWNzID0gKChub3dfbnMgLSBwcm9ncmVzcy0+c3RhcnRfbnMpICogNDM5OCkgPj4gMzI7CiAJCQlyYXRlID0gdHAtPmN1cnJfdG90YWwgLyAobWlzZWNzID8gbWlzZWNzIDogMSk7CmRpZmYgLS1naXQgYS9wcm9taXNvci1yZW1vdGUuYyBiL3Byb21pc29yLXJlbW90ZS5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjlmMzM4YzkKLS0tIC9kZXYvbnVsbAorKysgYi9wcm9taXNvci1yZW1vdGUuYwpAQCAtMCwwICsxLDI2NSBAQAorI2luY2x1ZGUgImNhY2hlLmgiCisjaW5jbHVkZSAib2JqZWN0LXN0b3JlLmgiCisjaW5jbHVkZSAicHJvbWlzb3ItcmVtb3RlLmgiCisjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAidHJhbnNwb3J0LmgiCisKK3N0YXRpYyBjaGFyICpyZXBvc2l0b3J5X2Zvcm1hdF9wYXJ0aWFsX2Nsb25lOworc3RhdGljIGNvbnN0IGNoYXIgKmNvcmVfcGFydGlhbF9jbG9uZV9maWx0ZXJfZGVmYXVsdDsKKwordm9pZCBzZXRfcmVwb3NpdG9yeV9mb3JtYXRfcGFydGlhbF9jbG9uZShjaGFyICpwYXJ0aWFsX2Nsb25lKQoreworCXJlcG9zaXRvcnlfZm9ybWF0X3BhcnRpYWxfY2xvbmUgPSB4c3RyZHVwX29yX251bGwocGFydGlhbF9jbG9uZSk7Cit9CisKK3N0YXRpYyBpbnQgZmV0Y2hfcmVmcyhjb25zdCBjaGFyICpyZW1vdGVfbmFtZSwgc3RydWN0IHJlZiAqcmVmKQoreworCXN0cnVjdCByZW1vdGUgKnJlbW90ZTsKKwlzdHJ1Y3QgdHJhbnNwb3J0ICp0cmFuc3BvcnQ7CisJaW50IHJlczsKKworCXJlbW90ZSA9IHJlbW90ZV9nZXQocmVtb3RlX25hbWUpOworCWlmICghcmVtb3RlLT51cmxbMF0pCisJCWRpZShfKCJSZW1vdGUgd2l0aCBubyBVUkwiKSk7CisJdHJhbnNwb3J0ID0gdHJhbnNwb3J0X2dldChyZW1vdGUsIHJlbW90ZS0+dXJsWzBdKTsKKworCXRyYW5zcG9ydF9zZXRfb3B0aW9uKHRyYW5zcG9ydCwgVFJBTlNfT1BUX0ZST01fUFJPTUlTT1IsICIxIik7CisJdHJhbnNwb3J0X3NldF9vcHRpb24odHJhbnNwb3J0LCBUUkFOU19PUFRfTk9fREVQRU5ERU5UUywgIjEiKTsKKwlyZXMgPSB0cmFuc3BvcnRfZmV0Y2hfcmVmcyh0cmFuc3BvcnQsIHJlZik7CisKKwlyZXR1cm4gcmVzOworfQorCitzdGF0aWMgaW50IGZldGNoX29iamVjdHMoY29uc3QgY2hhciAqcmVtb3RlX25hbWUsCisJCQkgY29uc3Qgc3RydWN0IG9iamVjdF9pZCAqb2lkcywKKwkJCSBpbnQgb2lkX25yKQoreworCXN0cnVjdCByZWYgKnJlZiA9IE5VTEw7CisJaW50IGk7CisKKwlmb3IgKGkgPSAwOyBpIDwgb2lkX25yOyBpKyspIHsKKwkJc3RydWN0IHJlZiAqbmV3X3JlZiA9IGFsbG9jX3JlZihvaWRfdG9faGV4KCZvaWRzW2ldKSk7CisJCW9pZGNweSgmbmV3X3JlZi0+b2xkX29pZCwgJm9pZHNbaV0pOworCQluZXdfcmVmLT5leGFjdF9vaWQgPSAxOworCQluZXdfcmVmLT5uZXh0ID0gcmVmOworCQlyZWYgPSBuZXdfcmVmOworCX0KKwlyZXR1cm4gZmV0Y2hfcmVmcyhyZW1vdGVfbmFtZSwgcmVmKTsKK30KKworc3RhdGljIHN0cnVjdCBwcm9taXNvcl9yZW1vdGUgKnByb21pc29yczsKK3N0YXRpYyBzdHJ1Y3QgcHJvbWlzb3JfcmVtb3RlICoqcHJvbWlzb3JzX3RhaWwgPSAmcHJvbWlzb3JzOworCitzdGF0aWMgc3RydWN0IHByb21pc29yX3JlbW90ZSAqcHJvbWlzb3JfcmVtb3RlX25ldyhjb25zdCBjaGFyICpyZW1vdGVfbmFtZSkKK3sKKwlzdHJ1Y3QgcHJvbWlzb3JfcmVtb3RlICpyOworCisJaWYgKCpyZW1vdGVfbmFtZSA9PSAnLycpIHsKKwkJd2FybmluZyhfKCJwcm9taXNvciByZW1vdGUgbmFtZSBjYW5ub3QgYmVnaW4gd2l0aCAnLyc6ICVzIiksCisJCQlyZW1vdGVfbmFtZSk7CisJCXJldHVybiBOVUxMOworCX0KKworCUZMRVhfQUxMT0NfU1RSKHIsIG5hbWUsIHJlbW90ZV9uYW1lKTsKKworCSpwcm9taXNvcnNfdGFpbCA9IHI7CisJcHJvbWlzb3JzX3RhaWwgPSAmci0+bmV4dDsKKworCXJldHVybiByOworfQorCitzdGF0aWMgc3RydWN0IHByb21pc29yX3JlbW90ZSAqcHJvbWlzb3JfcmVtb3RlX2xvb2t1cChjb25zdCBjaGFyICpyZW1vdGVfbmFtZSwKKwkJCQkJCSAgICAgIHN0cnVjdCBwcm9taXNvcl9yZW1vdGUgKipwcmV2aW91cykKK3sKKwlzdHJ1Y3QgcHJvbWlzb3JfcmVtb3RlICpyLCAqcDsKKworCWZvciAocCA9IE5VTEwsIHIgPSBwcm9taXNvcnM7IHI7IHAgPSByLCByID0gci0+bmV4dCkKKwkJaWYgKCFzdHJjbXAoci0+bmFtZSwgcmVtb3RlX25hbWUpKSB7CisJCQlpZiAocHJldmlvdXMpCisJCQkJKnByZXZpb3VzID0gcDsKKwkJCXJldHVybiByOworCQl9CisKKwlyZXR1cm4gTlVMTDsKK30KKworc3RhdGljIHZvaWQgcHJvbWlzb3JfcmVtb3RlX21vdmVfdG9fdGFpbChzdHJ1Y3QgcHJvbWlzb3JfcmVtb3RlICpyLAorCQkJCQkgc3RydWN0IHByb21pc29yX3JlbW90ZSAqcHJldmlvdXMpCit7CisJaWYgKHItPm5leHQgPT0gTlVMTCkKKwkJcmV0dXJuOworCisJaWYgKHByZXZpb3VzKQorCQlwcmV2aW91cy0+bmV4dCA9IHItPm5leHQ7CisJZWxzZQorCQlwcm9taXNvcnMgPSByLT5uZXh0ID8gci0+bmV4dCA6IHI7CisJci0+bmV4dCA9IE5VTEw7CisJKnByb21pc29yc190YWlsID0gcjsKKwlwcm9taXNvcnNfdGFpbCA9ICZyLT5uZXh0OworfQorCitzdGF0aWMgaW50IHByb21pc29yX3JlbW90ZV9jb25maWcoY29uc3QgY2hhciAqdmFyLCBjb25zdCBjaGFyICp2YWx1ZSwgdm9pZCAqZGF0YSkKK3sKKwljb25zdCBjaGFyICpuYW1lOworCWludCBuYW1lbGVuOworCWNvbnN0IGNoYXIgKnN1YmtleTsKKworCWlmICghc3RyY21wKHZhciwgImNvcmUucGFydGlhbGNsb25lZmlsdGVyIikpCisJCXJldHVybiBnaXRfY29uZmlnX3N0cmluZygmY29yZV9wYXJ0aWFsX2Nsb25lX2ZpbHRlcl9kZWZhdWx0LAorCQkJCQkgdmFyLCB2YWx1ZSk7CisKKwlpZiAocGFyc2VfY29uZmlnX2tleSh2YXIsICJyZW1vdGUiLCAmbmFtZSwgJm5hbWVsZW4sICZzdWJrZXkpIDwgMCkKKwkJcmV0dXJuIDA7CisKKwlpZiAoIXN0cmNtcChzdWJrZXksICJwcm9taXNvciIpKSB7CisJCWNoYXIgKnJlbW90ZV9uYW1lOworCisJCWlmICghZ2l0X2NvbmZpZ19ib29sKHZhciwgdmFsdWUpKQorCQkJcmV0dXJuIDA7CisKKwkJcmVtb3RlX25hbWUgPSB4bWVtZHVweihuYW1lLCBuYW1lbGVuKTsKKworCQlpZiAoIXByb21pc29yX3JlbW90ZV9sb29rdXAocmVtb3RlX25hbWUsIE5VTEwpKQorCQkJcHJvbWlzb3JfcmVtb3RlX25ldyhyZW1vdGVfbmFtZSk7CisKKwkJZnJlZShyZW1vdGVfbmFtZSk7CisJCXJldHVybiAwOworCX0KKwlpZiAoIXN0cmNtcChzdWJrZXksICJwYXJ0aWFsY2xvbmVmaWx0ZXIiKSkgeworCQlzdHJ1Y3QgcHJvbWlzb3JfcmVtb3RlICpyOworCQljaGFyICpyZW1vdGVfbmFtZSA9IHhtZW1kdXB6KG5hbWUsIG5hbWVsZW4pOworCisJCXIgPSBwcm9taXNvcl9yZW1vdGVfbG9va3VwKHJlbW90ZV9uYW1lLCBOVUxMKTsKKwkJaWYgKCFyKQorCQkJciA9IHByb21pc29yX3JlbW90ZV9uZXcocmVtb3RlX25hbWUpOworCisJCWZyZWUocmVtb3RlX25hbWUpOworCisJCWlmICghcikKKwkJCXJldHVybiAwOworCisJCXJldHVybiBnaXRfY29uZmlnX3N0cmluZygmci0+cGFydGlhbF9jbG9uZV9maWx0ZXIsIHZhciwgdmFsdWUpOworCX0KKworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50IGluaXRpYWxpemVkOworCitzdGF0aWMgdm9pZCBwcm9taXNvcl9yZW1vdGVfaW5pdCh2b2lkKQoreworCWlmIChpbml0aWFsaXplZCkKKwkJcmV0dXJuOworCWluaXRpYWxpemVkID0gMTsKKworCWdpdF9jb25maWcocHJvbWlzb3JfcmVtb3RlX2NvbmZpZywgTlVMTCk7CisKKwlpZiAocmVwb3NpdG9yeV9mb3JtYXRfcGFydGlhbF9jbG9uZSkgeworCQlzdHJ1Y3QgcHJvbWlzb3JfcmVtb3RlICpvLCAqcHJldmlvdXM7CisKKwkJbyA9IHByb21pc29yX3JlbW90ZV9sb29rdXAocmVwb3NpdG9yeV9mb3JtYXRfcGFydGlhbF9jbG9uZSwKKwkJCQkJICAgJnByZXZpb3VzKTsKKwkJaWYgKG8pCisJCQlwcm9taXNvcl9yZW1vdGVfbW92ZV90b190YWlsKG8sIHByZXZpb3VzKTsKKwkJZWxzZQorCQkJcHJvbWlzb3JfcmVtb3RlX25ldyhyZXBvc2l0b3J5X2Zvcm1hdF9wYXJ0aWFsX2Nsb25lKTsKKwl9Cit9CisKK3N0YXRpYyB2b2lkIHByb21pc29yX3JlbW90ZV9jbGVhcih2b2lkKQoreworCXdoaWxlIChwcm9taXNvcnMpIHsKKwkJc3RydWN0IHByb21pc29yX3JlbW90ZSAqciA9IHByb21pc29yczsKKwkJcHJvbWlzb3JzID0gcHJvbWlzb3JzLT5uZXh0OworCQlmcmVlKHIpOworCX0KKworCXByb21pc29yc190YWlsID0gJnByb21pc29yczsKK30KKwordm9pZCBwcm9taXNvcl9yZW1vdGVfcmVpbml0KHZvaWQpCit7CisJaW5pdGlhbGl6ZWQgPSAwOworCXByb21pc29yX3JlbW90ZV9jbGVhcigpOworCXByb21pc29yX3JlbW90ZV9pbml0KCk7Cit9CisKK3N0cnVjdCBwcm9taXNvcl9yZW1vdGUgKnByb21pc29yX3JlbW90ZV9maW5kKGNvbnN0IGNoYXIgKnJlbW90ZV9uYW1lKQoreworCXByb21pc29yX3JlbW90ZV9pbml0KCk7CisKKwlpZiAoIXJlbW90ZV9uYW1lKQorCQlyZXR1cm4gcHJvbWlzb3JzOworCisJcmV0dXJuIHByb21pc29yX3JlbW90ZV9sb29rdXAocmVtb3RlX25hbWUsIE5VTEwpOworfQorCitpbnQgaGFzX3Byb21pc29yX3JlbW90ZSh2b2lkKQoreworCXJldHVybiAhIXByb21pc29yX3JlbW90ZV9maW5kKE5VTEwpOworfQorCitzdGF0aWMgaW50IHJlbW92ZV9mZXRjaGVkX29pZHMoc3RydWN0IHJlcG9zaXRvcnkgKnJlcG8sCisJCQkgICAgICAgc3RydWN0IG9iamVjdF9pZCAqKm9pZHMsCisJCQkgICAgICAgaW50IG9pZF9uciwgaW50IHRvX2ZyZWUpCit7CisJaW50IGksIHJlbWFpbmluZ19uciA9IDA7CisJaW50ICpyZW1haW5pbmcgPSB4Y2FsbG9jKG9pZF9uciwgc2l6ZW9mKCpyZW1haW5pbmcpKTsKKwlzdHJ1Y3Qgb2JqZWN0X2lkICpvbGRfb2lkcyA9ICpvaWRzOworCXN0cnVjdCBvYmplY3RfaWQgKm5ld19vaWRzOworCisJZm9yIChpID0gMDsgaSA8IG9pZF9ucjsgaSsrKQorCQlpZiAob2lkX29iamVjdF9pbmZvX2V4dGVuZGVkKHJlcG8sICZvbGRfb2lkc1tpXSwgTlVMTCwKKwkJCQkJICAgICBPQkpFQ1RfSU5GT19TS0lQX0ZFVENIX09CSkVDVCkpIHsKKwkJCXJlbWFpbmluZ1tpXSA9IDE7CisJCQlyZW1haW5pbmdfbnIrKzsKKwkJfQorCisJaWYgKHJlbWFpbmluZ19ucikgeworCQlpbnQgaiA9IDA7CisJCW5ld19vaWRzID0geGNhbGxvYyhyZW1haW5pbmdfbnIsIHNpemVvZigqbmV3X29pZHMpKTsKKwkJZm9yIChpID0gMDsgaSA8IG9pZF9ucjsgaSsrKQorCQkJaWYgKHJlbWFpbmluZ1tpXSkKKwkJCQlvaWRjcHkoJm5ld19vaWRzW2orK10sICZvbGRfb2lkc1tpXSk7CisJCSpvaWRzID0gbmV3X29pZHM7CisJCWlmICh0b19mcmVlKQorCQkJZnJlZShvbGRfb2lkcyk7CisJfQorCisJZnJlZShyZW1haW5pbmcpOworCisJcmV0dXJuIHJlbWFpbmluZ19ucjsKK30KKworaW50IHByb21pc29yX3JlbW90ZV9nZXRfZGlyZWN0KHN0cnVjdCByZXBvc2l0b3J5ICpyZXBvLAorCQkJICAgICAgIGNvbnN0IHN0cnVjdCBvYmplY3RfaWQgKm9pZHMsCisJCQkgICAgICAgaW50IG9pZF9ucikKK3sKKwlzdHJ1Y3QgcHJvbWlzb3JfcmVtb3RlICpyOworCXN0cnVjdCBvYmplY3RfaWQgKnJlbWFpbmluZ19vaWRzID0gKHN0cnVjdCBvYmplY3RfaWQgKilvaWRzOworCWludCByZW1haW5pbmdfbnIgPSBvaWRfbnI7CisJaW50IHRvX2ZyZWUgPSAwOworCWludCByZXMgPSAtMTsKKworCXByb21pc29yX3JlbW90ZV9pbml0KCk7CisKKwlmb3IgKHIgPSBwcm9taXNvcnM7IHI7IHIgPSByLT5uZXh0KSB7CisJCWlmIChmZXRjaF9vYmplY3RzKHItPm5hbWUsIHJlbWFpbmluZ19vaWRzLCByZW1haW5pbmdfbnIpIDwgMCkgeworCQkJaWYgKHJlbWFpbmluZ19uciA9PSAxKQorCQkJCWNvbnRpbnVlOworCQkJcmVtYWluaW5nX25yID0gcmVtb3ZlX2ZldGNoZWRfb2lkcyhyZXBvLCAmcmVtYWluaW5nX29pZHMsCisJCQkJCQkJIHJlbWFpbmluZ19uciwgdG9fZnJlZSk7CisJCQlpZiAocmVtYWluaW5nX25yKSB7CisJCQkJdG9fZnJlZSA9IDE7CisJCQkJY29udGludWU7CisJCQl9CisJCX0KKwkJcmVzID0gMDsKKwkJYnJlYWs7CisJfQorCisJaWYgKHRvX2ZyZWUpCisJCWZyZWUocmVtYWluaW5nX29pZHMpOworCisJcmV0dXJuIHJlczsKK30KZGlmZiAtLWdpdCBhL3Byb21pc29yLXJlbW90ZS5oIGIvcHJvbWlzb3ItcmVtb3RlLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNzM3YmFjMwotLS0gL2Rldi9udWxsCisrKyBiL3Byb21pc29yLXJlbW90ZS5oCkBAIC0wLDAgKzEsMzMgQEAKKyNpZm5kZWYgUFJPTUlTT1JfUkVNT1RFX0gKKyNkZWZpbmUgUFJPTUlTT1JfUkVNT1RFX0gKKworI2luY2x1ZGUgInJlcG9zaXRvcnkuaCIKKworc3RydWN0IG9iamVjdF9pZDsKKworLyoKKyAqIFByb21pc29yIHJlbW90ZSBsaW5rZWQgbGlzdAorICoKKyAqIEluZm9ybWF0aW9uIGluIGl0cyBmaWVsZHMgY29tZSBmcm9tIHJlbW90ZS5YWFggY29uZmlnIGVudHJpZXMgb3IKKyAqIGZyb20gZXh0ZW5zaW9ucy5wYXJ0aWFsY2xvbmUgb3IgY29yZS5wYXJ0aWFsY2xvbmVmaWx0ZXIuCisgKi8KK3N0cnVjdCBwcm9taXNvcl9yZW1vdGUgeworCXN0cnVjdCBwcm9taXNvcl9yZW1vdGUgKm5leHQ7CisJY29uc3QgY2hhciAqcGFydGlhbF9jbG9uZV9maWx0ZXI7CisJY29uc3QgY2hhciBuYW1lW0ZMRVhfQVJSQVldOworfTsKKwordm9pZCBwcm9taXNvcl9yZW1vdGVfcmVpbml0KHZvaWQpOworc3RydWN0IHByb21pc29yX3JlbW90ZSAqcHJvbWlzb3JfcmVtb3RlX2ZpbmQoY29uc3QgY2hhciAqcmVtb3RlX25hbWUpOworaW50IGhhc19wcm9taXNvcl9yZW1vdGUodm9pZCk7CitpbnQgcHJvbWlzb3JfcmVtb3RlX2dldF9kaXJlY3Qoc3RydWN0IHJlcG9zaXRvcnkgKnJlcG8sCisJCQkgICAgICAgY29uc3Qgc3RydWN0IG9iamVjdF9pZCAqb2lkcywKKwkJCSAgICAgICBpbnQgb2lkX25yKTsKKworLyoKKyAqIFRoaXMgc2hvdWxkIGJlIHVzZWQgb25seSBvbmNlIGZyb20gc2V0dXAuYyB0byBzZXQgdGhlIHZhbHVlIHdlIGdvdAorICogZnJvbSB0aGUgZXh0ZW5zaW9ucy5wYXJ0aWFsY2xvbmUgY29uZmlnIG9wdGlvbi4KKyAqLwordm9pZCBzZXRfcmVwb3NpdG9yeV9mb3JtYXRfcGFydGlhbF9jbG9uZShjaGFyICpwYXJ0aWFsX2Nsb25lKTsKKworI2VuZGlmIC8qIFBST01JU09SX1JFTU9URV9IICovCmRpZmYgLS1naXQgYS9xdW90ZS5jIGIvcXVvdGUuYwppbmRleCA3ZjJhYTZmLi4yNGE1OGJhIDEwMDY0NAotLS0gYS9xdW90ZS5jCisrKyBiL3F1b3RlLmMKQEAgLTQ4LDYgKzQ4LDEyIEBACiAJc3RhdGljIGNvbnN0IGNoYXIgb2tfcHVuY3RbXSA9ICIrLC0uLzo9QF9eIjsKIAljb25zdCBjaGFyICpwOwogCisJLyogQXZvaWQgbG9zaW5nIGEgemVyby1sZW5ndGggc3RyaW5nIGJ5IGFkZGluZyAnJyAqLworCWlmICghKnNyYykgeworCQlzdHJidWZfYWRkc3RyKGRzdCwgIicnIik7CisJCXJldHVybjsKKwl9CisKIAlmb3IgKHAgPSBzcmM7ICpwOyBwKyspIHsKIAkJaWYgKCFpc2FscGhhKCpwKSAmJiAhaXNkaWdpdCgqcCkgJiYgIXN0cmNocihva19wdW5jdCwgKnApKSB7CiAJCQlzcV9xdW90ZV9idWYoZHN0LCBzcmMpOwpAQCAtODQsMTIgKzkwLDI4IEBACiAJfQogfQogCisvKgorICogTGVnYWN5IGZ1bmN0aW9uIHRvIGFwcGVuZCBlYWNoIGFyZ3YgdmFsdWUsIHF1b3RlZCBhcyBuZWNlc3Nhc3J5LAorICogd2l0aCB3aGl0ZXNwYWNlIGJlZm9yZSBlYWNoIHZhbHVlLiAgVGhpcyByZXN1bHRzIGluIGEgbGVhZGluZworICogc3BhY2UgaW4gdGhlIHJlc3VsdC4KKyAqLwogdm9pZCBzcV9xdW90ZV9hcmd2X3ByZXR0eShzdHJ1Y3Qgc3RyYnVmICpkc3QsIGNvbnN0IGNoYXIgKiphcmd2KQogeworCWlmIChhcmd2WzBdKQorCQlzdHJidWZfYWRkY2goZHN0LCAnICcpOworCXNxX2FwcGVuZF9xdW90ZV9hcmd2X3ByZXR0eShkc3QsIGFyZ3YpOworfQorCisvKgorICogQXBwZW5kIGVhY2ggYXJndiB2YWx1ZSwgcXVvdGVkIGFzIG5lY2Vzc2FyeSwgd2l0aCB3aGl0ZXNwYWNlIGJldHdlZW4gdGhlbS4KKyAqLwordm9pZCBzcV9hcHBlbmRfcXVvdGVfYXJndl9wcmV0dHkoc3RydWN0IHN0cmJ1ZiAqZHN0LCBjb25zdCBjaGFyICoqYXJndikKK3sKIAlpbnQgaTsKIAogCWZvciAoaSA9IDA7IGFyZ3ZbaV07IGkrKykgewotCQlzdHJidWZfYWRkY2goZHN0LCAnICcpOworCQlpZiAoaSA+IDApCisJCQlzdHJidWZfYWRkY2goZHN0LCAnICcpOwogCQlzcV9xdW90ZV9idWZfcHJldHR5KGRzdCwgYXJndltpXSk7CiAJfQogfQpkaWZmIC0tZ2l0IGEvcXVvdGUuaCBiL3F1b3RlLmgKaW5kZXggZmIwOGRjMC4uY2E4ZWUzMSAxMDA2NDQKLS0tIGEvcXVvdGUuaAorKysgYi9xdW90ZS5oCkBAIC00MCw2ICs0MCw3IEBACiAgKi8KIHZvaWQgc3FfcXVvdGVfYnVmX3ByZXR0eShzdHJ1Y3Qgc3RyYnVmICosIGNvbnN0IGNoYXIgKnNyYyk7CiB2b2lkIHNxX3F1b3RlX2FyZ3ZfcHJldHR5KHN0cnVjdCBzdHJidWYgKiwgY29uc3QgY2hhciAqKmFyZ3YpOwordm9pZCBzcV9hcHBlbmRfcXVvdGVfYXJndl9wcmV0dHkoc3RydWN0IHN0cmJ1ZiAqZHN0LCBjb25zdCBjaGFyICoqYXJndik7CiAKIC8qIFRoaXMgdW53cmFwcyB3aGF0IHNxX3F1b3RlKCkgcHJvZHVjZXMgaW4gcGxhY2UsIGJ1dCByZXR1cm5zCiAgKiBOVUxMIGlmIHRoZSBpbnB1dCBkb2VzIG5vdCBsb29rIGxpa2Ugd2hhdCBzcV9xdW90ZSB3b3VsZCBoYXZlCmRpZmYgLS1naXQgYS9yYW5nZS1kaWZmLmMgYi9yYW5nZS1kaWZmLmMKaW5kZXggYmExZTlhNC4uZjU2YjQwMSAxMDA2NDQKLS0tIGEvcmFuZ2UtZGlmZi5jCisrKyBiL3JhbmdlLWRpZmYuYwpAQCAtNDAsNyArNDAsOCBAQAogICogUmVhZHMgdGhlIHBhdGNoZXMgaW50byBhIHN0cmluZyBsaXN0LCB3aXRoIHRoZSBgdXRpbGAgZmllbGQgYmVpbmcgcG9wdWxhdGVkCiAgKiBhcyBzdHJ1Y3Qgb2JqZWN0X2lkICh3aWxsIG5lZWQgdG8gYmUgZnJlZSgpZCkuCiAgKi8KLXN0YXRpYyBpbnQgcmVhZF9wYXRjaGVzKGNvbnN0IGNoYXIgKnJhbmdlLCBzdHJ1Y3Qgc3RyaW5nX2xpc3QgKmxpc3QpCitzdGF0aWMgaW50IHJlYWRfcGF0Y2hlcyhjb25zdCBjaGFyICpyYW5nZSwgc3RydWN0IHN0cmluZ19saXN0ICpsaXN0LAorCQkJc3RydWN0IGFyZ3ZfYXJyYXkgKm90aGVyX2FyZykKIHsKIAlzdHJ1Y3QgY2hpbGRfcHJvY2VzcyBjcCA9IENISUxEX1BST0NFU1NfSU5JVDsKIAlzdHJ1Y3Qgc3RyYnVmIGJ1ZiA9IFNUUkJVRl9JTklULCBjb250ZW50cyA9IFNUUkJVRl9JTklUOwpAQCAtNTIsNiArNTMsNyBAQAogCiAJYXJndl9hcnJheV9wdXNobCgmY3AuYXJncywgImxvZyIsICItLW5vLWNvbG9yIiwgIi1wIiwgIi0tbm8tbWVyZ2VzIiwKIAkJCSItLXJldmVyc2UiLCAiLS1kYXRlLW9yZGVyIiwgIi0tZGVjb3JhdGU9bm8iLAorCQkJIi0tbm8tcHJlZml4IiwKIAkJCS8qCiAJCQkgKiBDaG9vc2UgaW5kaWNhdG9ycyB0aGF0IGFyZSBub3QgdXNlZCBhbnl3aGVyZQogCQkJICogZWxzZSBpbiBkaWZmcywgYnV0IHN0aWxsIGxvb2sgcmVhc29uYWJsZQpAQCAtNjAsOCArNjIsMTEgQEAKIAkJCSItLW91dHB1dC1pbmRpY2F0b3ItbmV3PT4iLAogCQkJIi0tb3V0cHV0LWluZGljYXRvci1vbGQ9PCIsCiAJCQkiLS1vdXRwdXQtaW5kaWNhdG9yLWNvbnRleHQ9IyIsCi0JCQkiLS1uby1hYmJyZXYtY29tbWl0IiwgcmFuZ2UsCisJCQkiLS1uby1hYmJyZXYtY29tbWl0IiwKIAkJCU5VTEwpOworCWlmIChvdGhlcl9hcmcpCisJCWFyZ3ZfYXJyYXlfcHVzaHYoJmNwLmFyZ3MsIG90aGVyX2FyZy0+YXJndik7CisJYXJndl9hcnJheV9wdXNoKCZjcC5hcmdzLCByYW5nZSk7CiAJY3Aub3V0ID0gLTE7CiAJY3Aubm9fc3RkaW4gPSAxOwogCWNwLmdpdF9jbWQgPSAxOwpAQCAtMTExLDcgKzExNiw3IEBACiAJCQlpZiAoIXV0aWwtPmRpZmZfb2Zmc2V0KQogCQkJCXV0aWwtPmRpZmZfb2Zmc2V0ID0gYnVmLmxlbjsKIAkJCWxpbmVbbGVuIC0gMV0gPSAnXG4nOwotCQkJbGVuID0gcGFyc2VfZ2l0X2RpZmZfaGVhZGVyKCZyb290LCAmbGluZW5yLCAxLCBsaW5lLAorCQkJbGVuID0gcGFyc2VfZ2l0X2RpZmZfaGVhZGVyKCZyb290LCAmbGluZW5yLCAwLCBsaW5lLAogCQkJCQkJICAgIGxlbiwgc2l6ZSwgJnBhdGNoKTsKIAkJCWlmIChsZW4gPCAwKQogCQkJCWRpZShfKCJjb3VsZCBub3QgcGFyc2UgZ2l0IGhlYWRlciAnJS4qcyciKSwgKGludClsZW4sIGxpbmUpOwpAQCAtMTQzLDYgKzE0OCwxMiBAQAogCQkJCXN0cmJ1Zl9hZGRzdHIoJmJ1ZiwgbGluZSk7CiAJCQkJc3RyYnVmX2FkZHN0cigmYnVmLCAiXG5cbiIpOwogCQkJCXN0cmJ1Zl9hZGRzdHIoJmJ1ZiwgIiAjIyBDb21taXQgbWVzc2FnZSAjI1xuIik7CisJCQl9IGVsc2UgaWYgKHN0YXJ0c193aXRoKGxpbmUsICJOb3RlcyIpICYmCisJCQkJICAgbGluZVtzdHJsZW4obGluZSkgLSAxXSA9PSAnOicpIHsKKwkJCQlzdHJidWZfYWRkc3RyKCZidWYsICJcblxuIik7CisJCQkJLyogc3RyaXAgdGhlIHRyYWlsaW5nIGNvbG9uICovCisJCQkJc3RyYnVmX2FkZGYoJmJ1ZiwgIiAjIyAlLipzICMjXG4iLAorCQkJCQkgICAgKGludCkoc3RybGVuKGxpbmUpIC0gMSksIGxpbmUpOwogCQkJfSBlbHNlIGlmIChzdGFydHNfd2l0aChsaW5lLCAiICAgICIpKSB7CiAJCQkJcCA9IGxpbmUgKyBsZW4gLSAyOwogCQkJCXdoaWxlIChpc3NwYWNlKCpwKSAmJiBwID49IGxpbmUpCkBAIC0yMTcsOCArMjI4LDggQEAKIAkJdXRpbC0+aSA9IGk7CiAJCXV0aWwtPnBhdGNoID0gYS0+aXRlbXNbaV0uc3RyaW5nOwogCQl1dGlsLT5kaWZmID0gdXRpbC0+cGF0Y2ggKyB1dGlsLT5kaWZmX29mZnNldDsKLQkJaGFzaG1hcF9lbnRyeV9pbml0KHV0aWwsIHN0cmhhc2godXRpbC0+ZGlmZikpOwotCQloYXNobWFwX2FkZCgmbWFwLCB1dGlsKTsKKwkJaGFzaG1hcF9lbnRyeV9pbml0KCZ1dGlsLT5lLCBzdHJoYXNoKHV0aWwtPmRpZmYpKTsKKwkJaGFzaG1hcF9hZGQoJm1hcCwgJnV0aWwtPmUpOwogCX0KIAogCS8qIE5vdyB0cnkgdG8gZmluZCBleGFjdCBtYXRjaGVzIGluIGIgKi8KQEAgLTIyOCw4ICsyMzksOCBAQAogCQl1dGlsLT5pID0gaTsKIAkJdXRpbC0+cGF0Y2ggPSBiLT5pdGVtc1tpXS5zdHJpbmc7CiAJCXV0aWwtPmRpZmYgPSB1dGlsLT5wYXRjaCArIHV0aWwtPmRpZmZfb2Zmc2V0OwotCQloYXNobWFwX2VudHJ5X2luaXQodXRpbCwgc3RyaGFzaCh1dGlsLT5kaWZmKSk7Ci0JCW90aGVyID0gaGFzaG1hcF9yZW1vdmUoJm1hcCwgdXRpbCwgTlVMTCk7CisJCWhhc2htYXBfZW50cnlfaW5pdCgmdXRpbC0+ZSwgc3RyaGFzaCh1dGlsLT5kaWZmKSk7CisJCW90aGVyID0gaGFzaG1hcF9yZW1vdmVfZW50cnkoJm1hcCwgdXRpbCwgZSwgTlVMTCk7CiAJCWlmIChvdGhlcikgewogCQkJaWYgKG90aGVyLT5tYXRjaGluZyA+PSAwKQogCQkJCUJVRygiYWxyZWFkeSBhc3NpZ25lZCEiKTsKQEAgLTIzOSw3ICsyNTAsNyBAQAogCQl9CiAJfQogCi0JaGFzaG1hcF9mcmVlKCZtYXAsIDApOworCWhhc2htYXBfZnJlZSgmbWFwKTsKIH0KIAogc3RhdGljIHZvaWQgZGlmZnNpemVfY29uc3VtZSh2b2lkICpkYXRhLCBjaGFyICpsaW5lLCB1bnNpZ25lZCBsb25nIGxlbikKQEAgLTQ5NSwxNiArNTA2LDE3IEBACiAKIGludCBzaG93X3JhbmdlX2RpZmYoY29uc3QgY2hhciAqcmFuZ2UxLCBjb25zdCBjaGFyICpyYW5nZTIsCiAJCSAgICBpbnQgY3JlYXRpb25fZmFjdG9yLCBpbnQgZHVhbF9jb2xvciwKLQkJICAgIHN0cnVjdCBkaWZmX29wdGlvbnMgKmRpZmZvcHQpCisJCSAgICBzdHJ1Y3QgZGlmZl9vcHRpb25zICpkaWZmb3B0LAorCQkgICAgc3RydWN0IGFyZ3ZfYXJyYXkgKm90aGVyX2FyZykKIHsKIAlpbnQgcmVzID0gMDsKIAogCXN0cnVjdCBzdHJpbmdfbGlzdCBicmFuY2gxID0gU1RSSU5HX0xJU1RfSU5JVF9EVVA7CiAJc3RydWN0IHN0cmluZ19saXN0IGJyYW5jaDIgPSBTVFJJTkdfTElTVF9JTklUX0RVUDsKIAotCWlmIChyZWFkX3BhdGNoZXMocmFuZ2UxLCAmYnJhbmNoMSkpCisJaWYgKHJlYWRfcGF0Y2hlcyhyYW5nZTEsICZicmFuY2gxLCBvdGhlcl9hcmcpKQogCQlyZXMgPSBlcnJvcihfKCJjb3VsZCBub3QgcGFyc2UgbG9nIGZvciAnJXMnIiksIHJhbmdlMSk7Ci0JaWYgKCFyZXMgJiYgcmVhZF9wYXRjaGVzKHJhbmdlMiwgJmJyYW5jaDIpKQorCWlmICghcmVzICYmIHJlYWRfcGF0Y2hlcyhyYW5nZTIsICZicmFuY2gyLCBvdGhlcl9hcmcpKQogCQlyZXMgPSBlcnJvcihfKCJjb3VsZCBub3QgcGFyc2UgbG9nIGZvciAnJXMnIiksIHJhbmdlMik7CiAKIAlpZiAoIXJlcykgewpkaWZmIC0tZ2l0IGEvcmFuZ2UtZGlmZi5oIGIvcmFuZ2UtZGlmZi5oCmluZGV4IDA4YTUwYjYuLmM1N2VjN2QgMTAwNjQ0Ci0tLSBhL3JhbmdlLWRpZmYuaAorKysgYi9yYW5nZS1kaWZmLmgKQEAgLTIsMTYgKzIsMTggQEAKICNkZWZpbmUgUkFOR0VfRElGRl9ICiAKICNpbmNsdWRlICJkaWZmLmgiCisjaW5jbHVkZSAiYXJndi1hcnJheS5oIgogCiAjZGVmaW5lIFJBTkdFX0RJRkZfQ1JFQVRJT05fRkFDVE9SX0RFRkFVTFQgNjAKIAogLyoKLSAqIENvbXBhcmUgc2VyaWVzIG9mIGNvbW1taXRzIGluIFJBTkdFMSBhbmQgUkFOR0UyLCBhbmQgZW1pdCB0byB0aGUKKyAqIENvbXBhcmUgc2VyaWVzIG9mIGNvbW1pdHMgaW4gUkFOR0UxIGFuZCBSQU5HRTIsIGFuZCBlbWl0IHRvIHRoZQogICogc3RhbmRhcmQgb3V0cHV0LiAgTlVMTCBjYW4gYmUgcGFzc2VkIHRvIERJRkZPUFQgdG8gdXNlIHRoZSBidWlsdC1pbgogICogZGVmYXVsdC4KICAqLwogaW50IHNob3dfcmFuZ2VfZGlmZihjb25zdCBjaGFyICpyYW5nZTEsIGNvbnN0IGNoYXIgKnJhbmdlMiwKIAkJICAgIGludCBjcmVhdGlvbl9mYWN0b3IsIGludCBkdWFsX2NvbG9yLAotCQkgICAgc3RydWN0IGRpZmZfb3B0aW9ucyAqZGlmZm9wdCk7CisJCSAgICBzdHJ1Y3QgZGlmZl9vcHRpb25zICpkaWZmb3B0LAorCQkgICAgc3RydWN0IGFyZ3ZfYXJyYXkgKm90aGVyX2FyZyk7CiAKICNlbmRpZgpkaWZmIC0tZ2l0IGEvcmVhZC1jYWNoZS5jIGIvcmVhZC1jYWNoZS5jCmluZGV4IDUyZmZhOGEuLjA2NzQ0MjggMTAwNjQ0Ci0tLSBhL3JlYWQtY2FjaGUuYworKysgYi9yZWFkLWNhY2hlLmMKQEAgLTEyNzYsNyArMTI3Niw3IEBACiAJICovCiAJaWYgKGlzdGF0ZS0+Y2FjaGVfbnIgPiAwICYmCiAJCXN0cmNtcChjZS0+bmFtZSwgaXN0YXRlLT5jYWNoZVtpc3RhdGUtPmNhY2hlX25yIC0gMV0tPm5hbWUpID4gMCkKLQkJcG9zID0gLWlzdGF0ZS0+Y2FjaGVfbnIgLSAxOworCQlwb3MgPSBpbmRleF9wb3NfdG9faW5zZXJ0X3Bvcyhpc3RhdGUtPmNhY2hlX25yKTsKIAllbHNlCiAJCXBvcyA9IGluZGV4X25hbWVfc3RhZ2VfcG9zKGlzdGF0ZSwgY2UtPm5hbWUsIGNlX25hbWVsZW4oY2UpLCBjZV9zdGFnZShjZSkpOwogCkBAIC0xNDcyLDYgKzE0NzIsMjcgQEAKIAlwcmludGYoZm10LCBuYW1lKTsKIH0KIAoraW50IHJlcG9fcmVmcmVzaF9hbmRfd3JpdGVfaW5kZXgoc3RydWN0IHJlcG9zaXRvcnkgKnJlcG8sCisJCQkJIHVuc2lnbmVkIGludCByZWZyZXNoX2ZsYWdzLAorCQkJCSB1bnNpZ25lZCBpbnQgd3JpdGVfZmxhZ3MsCisJCQkJIGludCBnZW50bGUsCisJCQkJIGNvbnN0IHN0cnVjdCBwYXRoc3BlYyAqcGF0aHNwZWMsCisJCQkJIGNoYXIgKnNlZW4sIGNvbnN0IGNoYXIgKmhlYWRlcl9tc2cpCit7CisJc3RydWN0IGxvY2tfZmlsZSBsb2NrX2ZpbGUgPSBMT0NLX0lOSVQ7CisJaW50IGZkLCByZXQgPSAwOworCisJZmQgPSByZXBvX2hvbGRfbG9ja2VkX2luZGV4KHJlcG8sICZsb2NrX2ZpbGUsIDApOworCWlmICghZ2VudGxlICYmIGZkIDwgMCkKKwkJcmV0dXJuIC0xOworCWlmIChyZWZyZXNoX2luZGV4KHJlcG8tPmluZGV4LCByZWZyZXNoX2ZsYWdzLCBwYXRoc3BlYywgc2VlbiwgaGVhZGVyX21zZykpCisJCXJldCA9IDE7CisJaWYgKDAgPD0gZmQgJiYgd3JpdGVfbG9ja2VkX2luZGV4KHJlcG8tPmluZGV4LCAmbG9ja19maWxlLCBDT01NSVRfTE9DSyB8IHdyaXRlX2ZsYWdzKSkKKwkJcmV0ID0gLTE7CisJcmV0dXJuIHJldDsKK30KKworCiBpbnQgcmVmcmVzaF9pbmRleChzdHJ1Y3QgaW5kZXhfc3RhdGUgKmlzdGF0ZSwgdW5zaWduZWQgaW50IGZsYWdzLAogCQkgIGNvbnN0IHN0cnVjdCBwYXRoc3BlYyAqcGF0aHNwZWMsCiAJCSAgY2hhciAqc2VlbiwgY29uc3QgY2hhciAqaGVhZGVyX21zZykKQEAgLTE1OTksMTYgKzE2MjAsMTcgQEAKIAogI2RlZmluZSBJTkRFWF9GT1JNQVRfREVGQVVMVCAzCiAKLXN0YXRpYyB1bnNpZ25lZCBpbnQgZ2V0X2luZGV4X2Zvcm1hdF9kZWZhdWx0KHZvaWQpCitzdGF0aWMgdW5zaWduZWQgaW50IGdldF9pbmRleF9mb3JtYXRfZGVmYXVsdChzdHJ1Y3QgcmVwb3NpdG9yeSAqcikKIHsKIAljaGFyICplbnZ2ZXJzaW9uID0gZ2V0ZW52KCJHSVRfSU5ERVhfVkVSU0lPTiIpOwogCWNoYXIgKmVuZHA7Ci0JaW50IHZhbHVlOwogCXVuc2lnbmVkIGludCB2ZXJzaW9uID0gSU5ERVhfRk9STUFUX0RFRkFVTFQ7CiAKIAlpZiAoIWVudnZlcnNpb24pIHsKLQkJaWYgKCFnaXRfY29uZmlnX2dldF9pbnQoImluZGV4LnZlcnNpb24iLCAmdmFsdWUpKQotCQkJdmVyc2lvbiA9IHZhbHVlOworCQlwcmVwYXJlX3JlcG9fc2V0dGluZ3Mocik7CisKKwkJaWYgKHItPnNldHRpbmdzLmluZGV4X3ZlcnNpb24gPj0gMCkKKwkJCXZlcnNpb24gPSByLT5zZXR0aW5ncy5pbmRleF92ZXJzaW9uOwogCQlpZiAodmVyc2lvbiA8IElOREVYX0ZPUk1BVF9MQiB8fCBJTkRFWF9GT1JNQVRfVUIgPCB2ZXJzaW9uKSB7CiAJCQl3YXJuaW5nKF8oImluZGV4LnZlcnNpb24gc2V0LCBidXQgdGhlIHZhbHVlIGlzIGludmFsaWQuXG4iCiAJCQkJICAiVXNpbmcgdmVyc2lvbiAlaSIpLCBJTkRFWF9GT1JNQVRfREVGQVVMVCk7CkBAIC0xNzY4LDcgKzE3OTAsNyBAQAogCQljb25zdCB1bnNpZ25lZCBjaGFyICpjcCA9IChjb25zdCB1bnNpZ25lZCBjaGFyICopbmFtZTsKIAkJc2l6ZV90IHN0cmlwX2xlbiwgcHJldmlvdXNfbGVuOwogCi0JCS8qIElmIHdlJ3JlIGF0IHRoZSBiZWdpbmluZyBvZiBhIGJsb2NrLCBpZ25vcmUgdGhlIHByZXZpb3VzIG5hbWUgKi8KKwkJLyogSWYgd2UncmUgYXQgdGhlIGJlZ2lubmluZyBvZiBhIGJsb2NrLCBpZ25vcmUgdGhlIHByZXZpb3VzIG5hbWUgKi8KIAkJc3RyaXBfbGVuID0gZGVjb2RlX3ZhcmludCgmY3ApOwogCQlpZiAocHJldmlvdXNfY2UpIHsKIAkJCXByZXZpb3VzX2xlbiA9IHByZXZpb3VzX2NlLT5jZV9uYW1lbGVuOwpAQCAtMTg0NCwxOCArMTg2NiwxNyBAQAogCiBzdGF0aWMgdm9pZCB0d2Vha191bnRyYWNrZWRfY2FjaGUoc3RydWN0IGluZGV4X3N0YXRlICppc3RhdGUpCiB7Ci0Jc3dpdGNoIChnaXRfY29uZmlnX2dldF91bnRyYWNrZWRfY2FjaGUoKSkgewotCWNhc2UgLTE6IC8qIGtlZXA6IGRvIG5vdGhpbmcgKi8KLQkJYnJlYWs7Ci0JY2FzZSAwOiAvKiBmYWxzZSAqLworCXN0cnVjdCByZXBvc2l0b3J5ICpyID0gdGhlX3JlcG9zaXRvcnk7CisKKwlwcmVwYXJlX3JlcG9fc2V0dGluZ3Mocik7CisKKwlpZiAoci0+c2V0dGluZ3MuY29yZV91bnRyYWNrZWRfY2FjaGUgID09IFVOVFJBQ0tFRF9DQUNIRV9SRU1PVkUpIHsKIAkJcmVtb3ZlX3VudHJhY2tlZF9jYWNoZShpc3RhdGUpOwotCQlicmVhazsKLQljYXNlIDE6IC8qIHRydWUgKi8KLQkJYWRkX3VudHJhY2tlZF9jYWNoZShpc3RhdGUpOwotCQlicmVhazsKLQlkZWZhdWx0OiAvKiB1bmtub3duIHZhbHVlOiBkbyBub3RoaW5nICovCi0JCWJyZWFrOworCQlyZXR1cm47CiAJfQorCisJaWYgKHItPnNldHRpbmdzLmNvcmVfdW50cmFja2VkX2NhY2hlID09IFVOVFJBQ0tFRF9DQUNIRV9XUklURSkKKwkJYWRkX3VudHJhY2tlZF9jYWNoZShpc3RhdGUpOwogfQogCiBzdGF0aWMgdm9pZCB0d2Vha19zcGxpdF9pbmRleChzdHJ1Y3QgaW5kZXhfc3RhdGUgKmlzdGF0ZSkKQEAgLTE4OTQsNyArMTkxNSw3IEBACiAJLyoKIAkgKiBBY2NvdW50IGZvciBwb3RlbnRpYWwgYWxpZ25tZW50IGRpZmZlcmVuY2VzLgogCSAqLwotCXBlcl9lbnRyeSArPSBhbGlnbl9wYWRkaW5nX3NpemUoc2l6ZW9mKHN0cnVjdCBjYWNoZV9lbnRyeSksIC1zaXplb2Yoc3RydWN0IG9uZGlza19jYWNoZV9lbnRyeSkpOworCXBlcl9lbnRyeSArPSBhbGlnbl9wYWRkaW5nX3NpemUocGVyX2VudHJ5LCAwKTsKIAlyZXR1cm4gb25kaXNrX3NpemUgKyBlbnRyaWVzICogcGVyX2VudHJ5OwogfQogCkBAIC0yNzY1LDcgKzI3ODYsNyBAQAogCX0KIAogCWlmICghaXN0YXRlLT52ZXJzaW9uKSB7Ci0JCWlzdGF0ZS0+dmVyc2lvbiA9IGdldF9pbmRleF9mb3JtYXRfZGVmYXVsdCgpOworCQlpc3RhdGUtPnZlcnNpb24gPSBnZXRfaW5kZXhfZm9ybWF0X2RlZmF1bHQodGhlX3JlcG9zaXRvcnkpOwogCQlpZiAoZ2l0X2Vudl9ib29sKCJHSVRfVEVTVF9TUExJVF9JTkRFWCIsIDApKQogCQkJaW5pdF9zcGxpdF9pbmRleChpc3RhdGUpOwogCX0KZGlmZiAtLWdpdCBhL3JlZi1maWx0ZXIuYyBiL3JlZi1maWx0ZXIuYwppbmRleCBmMjdjZmM4Li42ODY3ZTMzIDEwMDY0NAotLS0gYS9yZWYtZmlsdGVyLmMKKysrIGIvcmVmLWZpbHRlci5jCkBAIC03OSwxNyArNzksMjAgQEAKIH0gb2ksIG9pX2RlcmVmOwogCiBzdHJ1Y3QgcmVmX3RvX3dvcmt0cmVlX2VudHJ5IHsKLQlzdHJ1Y3QgaGFzaG1hcF9lbnRyeSBlbnQ7IC8qIG11c3QgYmUgdGhlIGZpcnN0IG1lbWJlciEgKi8KKwlzdHJ1Y3QgaGFzaG1hcF9lbnRyeSBlbnQ7CiAJc3RydWN0IHdvcmt0cmVlICp3dDsgLyoga2V5IGlzIHd0LT5oZWFkX3JlZiAqLwogfTsKIAogc3RhdGljIGludCByZWZfdG9fd29ya3RyZWVfbWFwX2NtcGZuYyhjb25zdCB2b2lkICp1bnVzZWRfbG9va3VwZGF0YSwKLQkJCQkgICAgICBjb25zdCB2b2lkICpleGlzdGluZ19oYXNobWFwX2VudHJ5X3RvX3Rlc3QsCi0JCQkJICAgICAgY29uc3Qgdm9pZCAqa2V5LAorCQkJCSAgICAgIGNvbnN0IHN0cnVjdCBoYXNobWFwX2VudHJ5ICplcHRyLAorCQkJCSAgICAgIGNvbnN0IHN0cnVjdCBoYXNobWFwX2VudHJ5ICprcHRyLAogCQkJCSAgICAgIGNvbnN0IHZvaWQgKmtleWRhdGFfYWthX3JlZm5hbWUpCiB7Ci0JY29uc3Qgc3RydWN0IHJlZl90b193b3JrdHJlZV9lbnRyeSAqZSA9IGV4aXN0aW5nX2hhc2htYXBfZW50cnlfdG9fdGVzdDsKLQljb25zdCBzdHJ1Y3QgcmVmX3RvX3dvcmt0cmVlX2VudHJ5ICprID0ga2V5OworCWNvbnN0IHN0cnVjdCByZWZfdG9fd29ya3RyZWVfZW50cnkgKmUsICprOworCisJZSA9IGNvbnRhaW5lcl9vZihlcHRyLCBjb25zdCBzdHJ1Y3QgcmVmX3RvX3dvcmt0cmVlX2VudHJ5LCBlbnQpOworCWsgPSBjb250YWluZXJfb2Yoa3B0ciwgY29uc3Qgc3RydWN0IHJlZl90b193b3JrdHJlZV9lbnRyeSwgZW50KTsKKwogCXJldHVybiBzdHJjbXAoZS0+d3QtPmhlYWRfcmVmLAogCQlrZXlkYXRhX2FrYV9yZWZuYW1lID8ga2V5ZGF0YV9ha2FfcmVmbmFtZSA6IGstPnd0LT5oZWFkX3JlZik7CiB9CkBAIC0xMDI4LDcgKzEwMzEsNyBAQAogCQlpZiAoIXN0cm5jbXAoY3AsICIgPCIsIDIpKQogCQkJcmV0dXJuIHhtZW1kdXB6KGJ1ZiwgY3AgLSBidWYpOwogCX0KLQlyZXR1cm4gIiI7CisJcmV0dXJuIHhzdHJkdXAoIiIpOwogfQogCiBzdGF0aWMgY29uc3QgY2hhciAqY29weV9lbWFpbChjb25zdCBjaGFyICpidWYpCkBAIC0xMDM2LDEwICsxMDM5LDEwIEBACiAJY29uc3QgY2hhciAqZW1haWwgPSBzdHJjaHIoYnVmLCAnPCcpOwogCWNvbnN0IGNoYXIgKmVvZW1haWw7CiAJaWYgKCFlbWFpbCkKLQkJcmV0dXJuICIiOworCQlyZXR1cm4geHN0cmR1cCgiIik7CiAJZW9lbWFpbCA9IHN0cmNocihlbWFpbCwgJz4nKTsKIAlpZiAoIWVvZW1haWwpCi0JCXJldHVybiAiIjsKKwkJcmV0dXJuIHhzdHJkdXAoIiIpOwogCXJldHVybiB4bWVtZHVweihlbWFpbCwgZW9lbWFpbCArIDEgLSBlbWFpbCk7CiB9CiAKQEAgLTE1NjUsOSArMTU2OCwxMCBAQAogCQkJc3RydWN0IHJlZl90b193b3JrdHJlZV9lbnRyeSAqZW50cnk7CiAJCQllbnRyeSA9IHhtYWxsb2Moc2l6ZW9mKCplbnRyeSkpOwogCQkJZW50cnktPnd0ID0gd29ya3RyZWVzW2ldOwotCQkJaGFzaG1hcF9lbnRyeV9pbml0KGVudHJ5LCBzdHJoYXNoKHdvcmt0cmVlc1tpXS0+aGVhZF9yZWYpKTsKKwkJCWhhc2htYXBfZW50cnlfaW5pdCgmZW50cnktPmVudCwKKwkJCQkJc3RyaGFzaCh3b3JrdHJlZXNbaV0tPmhlYWRfcmVmKSk7CiAKLQkJCWhhc2htYXBfYWRkKG1hcCwgZW50cnkpOworCQkJaGFzaG1hcF9hZGQobWFwLCAmZW50cnktPmVudCk7CiAJCX0KIAl9CiB9CkBAIC0xNTg0LDE4ICsxNTg4LDIwIEBACiAKIHN0YXRpYyBjaGFyICpnZXRfd29ya3RyZWVfcGF0aChjb25zdCBzdHJ1Y3QgdXNlZF9hdG9tICphdG9tLCBjb25zdCBzdHJ1Y3QgcmVmX2FycmF5X2l0ZW0gKnJlZikKIHsKLQlzdHJ1Y3QgaGFzaG1hcF9lbnRyeSBlbnRyeTsKKwlzdHJ1Y3QgaGFzaG1hcF9lbnRyeSBlbnRyeSwgKmU7CiAJc3RydWN0IHJlZl90b193b3JrdHJlZV9lbnRyeSAqbG9va3VwX3Jlc3VsdDsKIAogCWxhenlfaW5pdF93b3JrdHJlZV9tYXAoKTsKIAogCWhhc2htYXBfZW50cnlfaW5pdCgmZW50cnksIHN0cmhhc2gocmVmLT5yZWZuYW1lKSk7Ci0JbG9va3VwX3Jlc3VsdCA9IGhhc2htYXBfZ2V0KCYocmVmX3RvX3dvcmt0cmVlX21hcC5tYXApLCAmZW50cnksIHJlZi0+cmVmbmFtZSk7CisJZSA9IGhhc2htYXBfZ2V0KCYocmVmX3RvX3dvcmt0cmVlX21hcC5tYXApLCAmZW50cnksIHJlZi0+cmVmbmFtZSk7CiAKLQlpZiAobG9va3VwX3Jlc3VsdCkKLQkJcmV0dXJuIHhzdHJkdXAobG9va3VwX3Jlc3VsdC0+d3QtPnBhdGgpOwotCWVsc2UKKwlpZiAoIWUpCiAJCXJldHVybiB4c3RyZHVwKCIiKTsKKworCWxvb2t1cF9yZXN1bHQgPSBjb250YWluZXJfb2YoZSwgc3RydWN0IHJlZl90b193b3JrdHJlZV9lbnRyeSwgZW50KTsKKworCXJldHVybiB4c3RyZHVwKGxvb2t1cF9yZXN1bHQtPnd0LT5wYXRoKTsKIH0KIAogLyoKQEAgLTE3NjYsNyArMTc3Miw3IEBACiAJICogSWYgaXQgaXMgYSB0YWcgb2JqZWN0LCBzZWUgaWYgd2UgdXNlIGEgdmFsdWUgdGhhdCBkZXJlZnMKIAkgKiB0aGUgb2JqZWN0LCBhbmQgaWYgd2UgZG8gZ3JhYiB0aGUgb2JqZWN0IGl0IHJlZmVycyB0by4KIAkgKi8KLQlvaV9kZXJlZi5vaWQgPSAoKHN0cnVjdCB0YWcgKilvYmopLT50YWdnZWQtPm9pZDsKKwlvaV9kZXJlZi5vaWQgPSAqZ2V0X3RhZ2dlZF9vaWQoKHN0cnVjdCB0YWcgKilvYmopOwogCiAJLyoKIAkgKiBORUVEU1dPUks6IFRoaXMgZGVyZWZzIHRhZyBvbmx5IG9uY2UsIHdoaWNoCkBAIC0xOTk3LDcgKzIwMDMsNyBAQAogCWlmICghb2JqKQogCQlkaWUoXygibWFsZm9ybWVkIG9iamVjdCBhdCAnJXMnIiksIHJlZm5hbWUpOwogCWlmIChvYmotPnR5cGUgPT0gT0JKX1RBRykKLQkJdGFnZ2VkX29pZCA9ICYoKHN0cnVjdCB0YWcgKilvYmopLT50YWdnZWQtPm9pZDsKKwkJdGFnZ2VkX29pZCA9IGdldF90YWdnZWRfb2lkKChzdHJ1Y3QgdGFnICopb2JqKTsKIAlpZiAodGFnZ2VkX29pZCAmJiBvaWRfYXJyYXlfbG9va3VwKHBvaW50c19hdCwgdGFnZ2VkX29pZCkgPj0gMCkKIAkJcmV0dXJuIHRhZ2dlZF9vaWQ7CiAJcmV0dXJuIE5VTEw7CkBAIC0yMTY2LDcgKzIxNzIsOCBAQAogCXVzZWRfYXRvbV9jbnQgPSAwOwogCiAJaWYgKHJlZl90b193b3JrdHJlZV9tYXAud29ya3RyZWVzKSB7Ci0JCWhhc2htYXBfZnJlZSgmKHJlZl90b193b3JrdHJlZV9tYXAubWFwKSwgMSk7CisJCWhhc2htYXBfZnJlZV9lbnRyaWVzKCYocmVmX3RvX3dvcmt0cmVlX21hcC5tYXApLAorCQkJCQlzdHJ1Y3QgcmVmX3RvX3dvcmt0cmVlX2VudHJ5LCBlbnQpOwogCQlmcmVlX3dvcmt0cmVlcyhyZWZfdG9fd29ya3RyZWVfbWFwLndvcmt0cmVlcyk7CiAJCXJlZl90b193b3JrdHJlZV9tYXAud29ya3RyZWVzID0gTlVMTDsKIAl9CmRpZmYgLS1naXQgYS9yZWZzLmMgYi9yZWZzLmMKaW5kZXggY2QyOTdlZS4uMWFiMGJiNSAxMDA2NDQKLS0tIGEvcmVmcy5jCisrKyBiL3JlZnMuYwpAQCAtMTc3Miw3ICsxNzcyLDcgQEAKIAogc3RydWN0IHJlZl9zdG9yZV9oYXNoX2VudHJ5CiB7Ci0Jc3RydWN0IGhhc2htYXBfZW50cnkgZW50OyAvKiBtdXN0IGJlIHRoZSBmaXJzdCBtZW1iZXIhICovCisJc3RydWN0IGhhc2htYXBfZW50cnkgZW50OwogCiAJc3RydWN0IHJlZl9zdG9yZSAqcmVmczsKIApAQCAtMTc4MSwxMSArMTc4MSwxNiBAQAogfTsKIAogc3RhdGljIGludCByZWZfc3RvcmVfaGFzaF9jbXAoY29uc3Qgdm9pZCAqdW51c2VkX2NtcF9kYXRhLAotCQkJICAgICAgY29uc3Qgdm9pZCAqZW50cnksIGNvbnN0IHZvaWQgKmVudHJ5X29yX2tleSwKKwkJCSAgICAgIGNvbnN0IHN0cnVjdCBoYXNobWFwX2VudHJ5ICplcHRyLAorCQkJICAgICAgY29uc3Qgc3RydWN0IGhhc2htYXBfZW50cnkgKmVudHJ5X29yX2tleSwKIAkJCSAgICAgIGNvbnN0IHZvaWQgKmtleWRhdGEpCiB7Ci0JY29uc3Qgc3RydWN0IHJlZl9zdG9yZV9oYXNoX2VudHJ5ICplMSA9IGVudHJ5LCAqZTIgPSBlbnRyeV9vcl9rZXk7Ci0JY29uc3QgY2hhciAqbmFtZSA9IGtleWRhdGEgPyBrZXlkYXRhIDogZTItPm5hbWU7CisJY29uc3Qgc3RydWN0IHJlZl9zdG9yZV9oYXNoX2VudHJ5ICplMSwgKmUyOworCWNvbnN0IGNoYXIgKm5hbWU7CisKKwllMSA9IGNvbnRhaW5lcl9vZihlcHRyLCBjb25zdCBzdHJ1Y3QgcmVmX3N0b3JlX2hhc2hfZW50cnksIGVudCk7CisJZTIgPSBjb250YWluZXJfb2YoZW50cnlfb3Jfa2V5LCBjb25zdCBzdHJ1Y3QgcmVmX3N0b3JlX2hhc2hfZW50cnksIGVudCk7CisJbmFtZSA9IGtleWRhdGEgPyBrZXlkYXRhIDogZTItPm5hbWU7CiAKIAlyZXR1cm4gc3RyY21wKGUxLT5uYW1lLCBuYW1lKTsKIH0KQEAgLTE3OTYsNyArMTgwMSw3IEBACiAJc3RydWN0IHJlZl9zdG9yZV9oYXNoX2VudHJ5ICplbnRyeTsKIAogCUZMRVhfQUxMT0NfU1RSKGVudHJ5LCBuYW1lLCBuYW1lKTsKLQloYXNobWFwX2VudHJ5X2luaXQoZW50cnksIHN0cmhhc2gobmFtZSkpOworCWhhc2htYXBfZW50cnlfaW5pdCgmZW50cnktPmVudCwgc3RyaGFzaChuYW1lKSk7CiAJZW50cnktPnJlZnMgPSByZWZzOwogCXJldHVybiBlbnRyeTsKIH0KQEAgLTE4MTUsMTIgKzE4MjAsMTUgQEAKIAkJCQkJICAgICAgY29uc3QgY2hhciAqbmFtZSkKIHsKIAlzdHJ1Y3QgcmVmX3N0b3JlX2hhc2hfZW50cnkgKmVudHJ5OworCXVuc2lnbmVkIGludCBoYXNoOwogCiAJaWYgKCFtYXAtPnRhYmxlc2l6ZSkKIAkJLyogSXQncyBpbml0aWFsaXplZCBvbiBkZW1hbmQgaW4gcmVnaXN0ZXJfcmVmX3N0b3JlKCkuICovCiAJCXJldHVybiBOVUxMOwogCi0JZW50cnkgPSBoYXNobWFwX2dldF9mcm9tX2hhc2gobWFwLCBzdHJoYXNoKG5hbWUpLCBuYW1lKTsKKwloYXNoID0gc3RyaGFzaChuYW1lKTsKKwllbnRyeSA9IGhhc2htYXBfZ2V0X2VudHJ5X2Zyb21faGFzaChtYXAsIGhhc2gsIG5hbWUsCisJCQkJCXN0cnVjdCByZWZfc3RvcmVfaGFzaF9lbnRyeSwgZW50KTsKIAlyZXR1cm4gZW50cnkgPyBlbnRyeS0+cmVmcyA6IE5VTEw7CiB9CiAKQEAgLTE4NjMsMTAgKzE4NzEsMTMgQEAKIAkJCQkgICBzdHJ1Y3QgcmVmX3N0b3JlICpyZWZzLAogCQkJCSAgIGNvbnN0IGNoYXIgKm5hbWUpCiB7CisJc3RydWN0IHJlZl9zdG9yZV9oYXNoX2VudHJ5ICplbnRyeTsKKwogCWlmICghbWFwLT50YWJsZXNpemUpCiAJCWhhc2htYXBfaW5pdChtYXAsIHJlZl9zdG9yZV9oYXNoX2NtcCwgTlVMTCwgMCk7CiAKLQlpZiAoaGFzaG1hcF9wdXQobWFwLCBhbGxvY19yZWZfc3RvcmVfaGFzaF9lbnRyeShuYW1lLCByZWZzKSkpCisJZW50cnkgPSBhbGxvY19yZWZfc3RvcmVfaGFzaF9lbnRyeShuYW1lLCByZWZzKTsKKwlpZiAoaGFzaG1hcF9wdXQobWFwLCAmZW50cnktPmVudCkpCiAJCUJVRygiJXMgcmVmX3N0b3JlICclcycgaW5pdGlhbGl6ZWQgdHdpY2UiLCB0eXBlLCBuYW1lKTsKIH0KIApkaWZmIC0tZ2l0IGEvcmVmcy9wYWNrZWQtYmFja2VuZC5jIGIvcmVmcy9wYWNrZWQtYmFja2VuZC5jCmluZGV4IGMwMWM3ZjUuLjQ0NThhMGYgMTAwNjQ0Ci0tLSBhL3JlZnMvcGFja2VkLWJhY2tlbmQuYworKysgYi9yZWZzL3BhY2tlZC1iYWNrZW5kLmMKQEAgLTEwMTIsMTQgKzEwMTIsMjMgQEAKIAl9CiAKIAkvKgotCSAqIE5vdyB0aGF0IHdlIGhvbGQgdGhlIGBwYWNrZWQtcmVmc2AgbG9jaywgbWFrZSBzdXJlIHRoYXQgb3VyCi0JICogc25hcHNob3QgbWF0Y2hlcyB0aGUgY3VycmVudCB2ZXJzaW9uIG9mIHRoZSBmaWxlLiBOb3JtYWxseQotCSAqIGBnZXRfc25hcHNob3QoKWAgZG9lcyB0aGF0IGZvciB1cywgYnV0IHRoYXQgZnVuY3Rpb24KLQkgKiBhc3N1bWVzIHRoYXQgd2hlbiB0aGUgZmlsZSBpcyBsb2NrZWQsIGFueSBleGlzdGluZyBzbmFwc2hvdAotCSAqIGlzIHN0aWxsIHZhbGlkLiBXZSd2ZSBqdXN0IGxvY2tlZCB0aGUgZmlsZSwgYnV0IGl0IG1pZ2h0Ci0JICogaGF2ZSBjaGFuZ2VkIHRoZSBtb21lbnQgKmJlZm9yZSogd2UgbG9ja2VkIGl0LgorCSAqIFRoZXJlIGlzIGEgc3RhdC12YWxpZGl0eSBwcm9ibGVtIG1pZ2h0IGNhdXNlIGB1cGRhdGUtcmVmIC1kYAorCSAqIGxvc3QgdGhlIG5ld2x5IGNvbW1pdCBvZiBhIHJlZiwgYmVjYXVzZSBhIG5ldyBgcGFja2VkLXJlZnNgCisJICogZmlsZSBtaWdodCBoYXMgdGhlIHNhbWUgb24tZGlzayBmaWxlIGF0dHJpYnV0ZXMgc3VjaCBhcworCSAqIHRpbWVzdGFtcCwgZmlsZSBzaXplIGFuZCBpbm9kZSB2YWx1ZSwgYnV0IGhhcyBhIGNoYW5nZWQKKwkgKiByZWYgdmFsdWUuCisJICoKKwkgKiBUaGlzIGNvdWxkIGhhcHBlbiB3aXRoIGEgdmVyeSBzbWFsbCBjaGFuY2Ugd2hlbgorCSAqIGB1cGRhdGUtcmVmIC1kYCBpcyBjYWxsZWQgYW5kIGF0IHRoZSBzYW1lIHRpbWUgYW5vdGhlcgorCSAqIGBwYWNrLXJlZnMgLS1hbGxgIHByb2Nlc3MgaXMgcnVubmluZy4KKwkgKgorCSAqIE5vdyB0aGF0IHdlIGhvbGQgdGhlIGBwYWNrZWQtcmVmc2AgbG9jaywgaXQgaXMgaW1wb3J0YW50CisJICogdG8gbWFrZSBzdXJlIHdlIGNvdWxkIHJlYWQgdGhlIGxhdGVzdCB2ZXJzaW9uIG9mCisJICogYHBhY2tlZC1yZWZzYCBmaWxlIG5vIG1hdHRlciB3ZSBoYXZlIGp1c3QgbW1hcCBpdCBvciBub3QuCisJICogU28gd2hhdCBuZWVkIHRvIGRvIGlzIGNsZWFyIHRoZSBzbmFwc2hvdCBpZiB3ZSBob2xkIGl0CisJICogYWxyZWFkeS4KIAkgKi8KLQl2YWxpZGF0ZV9zbmFwc2hvdChyZWZzKTsKKwljbGVhcl9zbmFwc2hvdChyZWZzKTsKIAogCS8qCiAJICogTm93IG1ha2Ugc3VyZSB0aGF0IHRoZSBwYWNrZWQtcmVmcyBmaWxlIGFzIGl0IGV4aXN0cyBpbiB0aGUKZGlmZiAtLWdpdCBhL3JlZnMvcmVmcy1pbnRlcm5hbC5oIGIvcmVmcy9yZWZzLWludGVybmFsLmgKaW5kZXggZjJkOGMwMS4uZmYyNDM2YyAxMDA2NDQKLS0tIGEvcmVmcy9yZWZzLWludGVybmFsLmgKKysrIGIvcmVmcy9yZWZzLWludGVybmFsLmgKQEAgLTI2Miw3ICsyNjIsNyBAQAogICogYWZ0ZXIgY2FsbGluZyByZWZfaXRlcmF0b3JfYWR2YW5jZSgpIGFnYWluIG9yIGNhbGxpbmcKICAqIHJlZl9pdGVyYXRvcl9hYm9ydCgpLCB5b3UgbXVzdCBtYWtlIGEgY29weS4gV2hlbiB0aGUgaXRlcmF0aW9uIGhhcwogICogYmVlbiBleGhhdXN0ZWQsIHJlZl9pdGVyYXRvcl9hZHZhbmNlKCkgcmVsZWFzZXMgYW55IHJlc291cmNlcwotICogYXNzb2NhdGVkIHdpdGggdGhlIGl0ZXJhdGlvbiwgZnJlZXMgdGhlIHJlZl9pdGVyYXRvciBvYmplY3QsIGFuZAorICogYXNzb2NpYXRlZCB3aXRoIHRoZSBpdGVyYXRpb24sIGZyZWVzIHRoZSByZWZfaXRlcmF0b3Igb2JqZWN0LCBhbmQKICAqIHJldHVybnMgSVRFUl9ET05FLiBJZiB5b3Ugd2FudCB0byBhYm9ydCB0aGUgaXRlcmF0aW9uIGVhcmx5LCBjYWxsCiAgKiByZWZfaXRlcmF0b3JfYWJvcnQoKSwgd2hpY2ggYWxzbyBmcmVlcyB0aGUgcmVmX2l0ZXJhdG9yIG9iamVjdCBhbmQKICAqIGFueSBhc3NvY2lhdGVkIHJlc291cmNlcy4gSWYgdGhlcmUgd2FzIGFuIGludGVybmFsIGVycm9yIGFkdmFuY2luZwpkaWZmIC0tZ2l0IGEvcmVtb3RlLWN1cmwuYyBiL3JlbW90ZS1jdXJsLmMKaW5kZXggMDUxZjI2Ni4uMzUwZDkyYSAxMDA2NDQKLS0tIGEvcmVtb3RlLWN1cmwuYworKysgYi9yZW1vdGUtY3VybC5jCkBAIC00MCw3ICs0MCw4IEBACiAJCXB1c2hfY2VydCA6IDIsCiAJCWRlZXBlbl9yZWxhdGl2ZSA6IDEsCiAJCWZyb21fcHJvbWlzb3IgOiAxLAotCQlub19kZXBlbmRlbnRzIDogMTsKKwkJbm9fZGVwZW5kZW50cyA6IDEsCisJCWF0b21pYyA6IDE7CiB9Owogc3RhdGljIHN0cnVjdCBvcHRpb25zIG9wdGlvbnM7CiBzdGF0aWMgc3RydWN0IHN0cmluZ19saXN0IGNhc19vcHRpb25zID0gU1RSSU5HX0xJU1RfSU5JVF9EVVA7CkBAIC0xNDgsNiArMTQ5LDE0IEBACiAJCWVsc2UKIAkJCXJldHVybiAtMTsKIAkJcmV0dXJuIDA7CisJfSBlbHNlIGlmICghc3RyY21wKG5hbWUsICJhdG9taWMiKSkgeworCQlpZiAoIXN0cmNtcCh2YWx1ZSwgInRydWUiKSkKKwkJCW9wdGlvbnMuYXRvbWljID0gMTsKKwkJZWxzZSBpZiAoIXN0cmNtcCh2YWx1ZSwgImZhbHNlIikpCisJCQlvcHRpb25zLmF0b21pYyA9IDA7CisJCWVsc2UKKwkJCXJldHVybiAtMTsKKwkJcmV0dXJuIDA7CiAJfSBlbHNlIGlmICghc3RyY21wKG5hbWUsICJwdXNoLW9wdGlvbiIpKSB7CiAJCWlmICgqdmFsdWUgIT0gJyInKQogCQkJc3RyaW5nX2xpc3RfYXBwZW5kKCZvcHRpb25zLnB1c2hfb3B0aW9ucywgdmFsdWUpOwpAQCAtMTE1NCw3ICsxMTYzLDcgQEAKIAlzdHJidWZfcmVzZXQoYnVmKTsKIH0KIAotc3RhdGljIGludCBwdXNoX2RhdihpbnQgbnJfc3BlYywgY2hhciAqKnNwZWNzKQorc3RhdGljIGludCBwdXNoX2RhdihpbnQgbnJfc3BlYywgY29uc3QgY2hhciAqKnNwZWNzKQogewogCXN0cnVjdCBjaGlsZF9wcm9jZXNzIGNoaWxkID0gQ0hJTERfUFJPQ0VTU19JTklUOwogCXNpemVfdCBpOwpAQCAtMTE3NSw3ICsxMTg0LDcgQEAKIAlyZXR1cm4gMDsKIH0KIAotc3RhdGljIGludCBwdXNoX2dpdChzdHJ1Y3QgZGlzY292ZXJ5ICpoZWFkcywgaW50IG5yX3NwZWMsIGNoYXIgKipzcGVjcykKK3N0YXRpYyBpbnQgcHVzaF9naXQoc3RydWN0IGRpc2NvdmVyeSAqaGVhZHMsIGludCBucl9zcGVjLCBjb25zdCBjaGFyICoqc3BlY3MpCiB7CiAJc3RydWN0IHJwY19zdGF0ZSBycGM7CiAJaW50IGksIGVycjsKQEAgLTExOTYsNiArMTIwNSw4IEBACiAJCWFyZ3ZfYXJyYXlfcHVzaCgmYXJncywgIi0tc2lnbmVkPXllcyIpOwogCWVsc2UgaWYgKG9wdGlvbnMucHVzaF9jZXJ0ID09IFNFTkRfUEFDS19QVVNIX0NFUlRfSUZfQVNLRUQpCiAJCWFyZ3ZfYXJyYXlfcHVzaCgmYXJncywgIi0tc2lnbmVkPWlmLWFza2VkIik7CisJaWYgKG9wdGlvbnMuYXRvbWljKQorCQlhcmd2X2FycmF5X3B1c2goJmFyZ3MsICItLWF0b21pYyIpOwogCWlmIChvcHRpb25zLnZlcmJvc2l0eSA9PSAwKQogCQlhcmd2X2FycmF5X3B1c2goJmFyZ3MsICItLXF1aWV0Iik7CiAJZWxzZSBpZiAob3B0aW9ucy52ZXJib3NpdHkgPiAxKQpAQCAtMTIyNSw3ICsxMjM2LDcgQEAKIAlyZXR1cm4gZXJyOwogfQogCi1zdGF0aWMgaW50IHB1c2goaW50IG5yX3NwZWMsIGNoYXIgKipzcGVjcykKK3N0YXRpYyBpbnQgcHVzaChpbnQgbnJfc3BlYywgY29uc3QgY2hhciAqKnNwZWNzKQogewogCXN0cnVjdCBkaXNjb3ZlcnkgKmhlYWRzID0gZGlzY292ZXJfcmVmcygiZ2l0LXJlY2VpdmUtcGFjayIsIDEpOwogCWludCByZXQ7CkBAIC0xMjQwLDE0ICsxMjUxLDEyIEBACiAKIHN0YXRpYyB2b2lkIHBhcnNlX3B1c2goc3RydWN0IHN0cmJ1ZiAqYnVmKQogewotCWNoYXIgKipzcGVjcyA9IE5VTEw7Ci0JaW50IGFsbG9jX3NwZWMgPSAwLCBucl9zcGVjID0gMCwgaSwgcmV0OworCXN0cnVjdCBhcmd2X2FycmF5IHNwZWNzID0gQVJHVl9BUlJBWV9JTklUOworCWludCByZXQ7CiAKIAlkbyB7Ci0JCWlmIChzdGFydHNfd2l0aChidWYtPmJ1ZiwgInB1c2ggIikpIHsKLQkJCUFMTE9DX0dST1coc3BlY3MsIG5yX3NwZWMgKyAxLCBhbGxvY19zcGVjKTsKLQkJCXNwZWNzW25yX3NwZWMrK10gPSB4c3RyZHVwKGJ1Zi0+YnVmICsgNSk7Ci0JCX0KKwkJaWYgKHN0YXJ0c193aXRoKGJ1Zi0+YnVmLCAicHVzaCAiKSkKKwkJCWFyZ3ZfYXJyYXlfcHVzaCgmc3BlY3MsIGJ1Zi0+YnVmICsgNSk7CiAJCWVsc2UKIAkJCWRpZShfKCJodHRwIHRyYW5zcG9ydCBkb2VzIG5vdCBzdXBwb3J0ICVzIiksIGJ1Zi0+YnVmKTsKIApAQCAtMTI1OCw3ICsxMjY3LDcgQEAKIAkJCWJyZWFrOwogCX0gd2hpbGUgKDEpOwogCi0JcmV0ID0gcHVzaChucl9zcGVjLCBzcGVjcyk7CisJcmV0ID0gcHVzaChzcGVjcy5hcmdjLCBzcGVjcy5hcmd2KTsKIAlwcmludGYoIlxuIik7CiAJZmZsdXNoKHN0ZG91dCk7CiAKQEAgLTEyNjYsOSArMTI3NSw3IEBACiAJCWV4aXQoMTI4KTsgLyogZXJyb3IgYWxyZWFkeSByZXBvcnRlZCAqLwogCiAgZnJlZV9zcGVjczoKLQlmb3IgKGkgPSAwOyBpIDwgbnJfc3BlYzsgaSsrKQotCQlmcmVlKHNwZWNzW2ldKTsKLQlmcmVlKHNwZWNzKTsKKwlhcmd2X2FycmF5X2NsZWFyKCZzcGVjcyk7CiB9CiAKIHN0YXRpYyBpbnQgc3RhdGVsZXNzX2Nvbm5lY3QoY29uc3QgY2hhciAqc2VydmljZV9uYW1lKQpkaWZmIC0tZ2l0IGEvcmVtb3RlLmMgYi9yZW1vdGUuYwppbmRleCBlNTBmNzYwLi41YzQ2NjZiIDEwMDY0NAotLS0gYS9yZW1vdGUuYworKysgYi9yZW1vdGUuYwpAQCAtMTExLDE0ICsxMTEsMTYgQEAKIH07CiAKIHN0YXRpYyBpbnQgcmVtb3Rlc19oYXNoX2NtcChjb25zdCB2b2lkICp1bnVzZWRfY21wX2RhdGEsCi0JCQkgICAgY29uc3Qgdm9pZCAqZW50cnksCi0JCQkgICAgY29uc3Qgdm9pZCAqZW50cnlfb3Jfa2V5LAorCQkJICAgIGNvbnN0IHN0cnVjdCBoYXNobWFwX2VudHJ5ICplcHRyLAorCQkJICAgIGNvbnN0IHN0cnVjdCBoYXNobWFwX2VudHJ5ICplbnRyeV9vcl9rZXksCiAJCQkgICAgY29uc3Qgdm9pZCAqa2V5ZGF0YSkKIHsKLQljb25zdCBzdHJ1Y3QgcmVtb3RlICphID0gZW50cnk7Ci0JY29uc3Qgc3RydWN0IHJlbW90ZSAqYiA9IGVudHJ5X29yX2tleTsKKwljb25zdCBzdHJ1Y3QgcmVtb3RlICphLCAqYjsKIAljb25zdCBzdHJ1Y3QgcmVtb3Rlc19oYXNoX2tleSAqa2V5ID0ga2V5ZGF0YTsKIAorCWEgPSBjb250YWluZXJfb2YoZXB0ciwgY29uc3Qgc3RydWN0IHJlbW90ZSwgZW50KTsKKwliID0gY29udGFpbmVyX29mKGVudHJ5X29yX2tleSwgY29uc3Qgc3RydWN0IHJlbW90ZSwgZW50KTsKKwogCWlmIChrZXkpCiAJCXJldHVybiBzdHJuY21wKGEtPm5hbWUsIGtleS0+c3RyLCBrZXktPmxlbikgfHwgYS0+bmFtZVtrZXktPmxlbl07CiAJZWxzZQpAQCAtMTM1LDcgKzEzNyw3IEBACiB7CiAJc3RydWN0IHJlbW90ZSAqcmV0LCAqcmVwbGFjZWQ7CiAJc3RydWN0IHJlbW90ZXNfaGFzaF9rZXkgbG9va3VwOwotCXN0cnVjdCBoYXNobWFwX2VudHJ5IGxvb2t1cF9lbnRyeTsKKwlzdHJ1Y3QgaGFzaG1hcF9lbnRyeSBsb29rdXBfZW50cnksICplOwogCiAJaWYgKCFsZW4pCiAJCWxlbiA9IHN0cmxlbihuYW1lKTsKQEAgLTE0NSw4ICsxNDcsOSBAQAogCWxvb2t1cC5sZW4gPSBsZW47CiAJaGFzaG1hcF9lbnRyeV9pbml0KCZsb29rdXBfZW50cnksIG1lbWhhc2gobmFtZSwgbGVuKSk7CiAKLQlpZiAoKHJldCA9IGhhc2htYXBfZ2V0KCZyZW1vdGVzX2hhc2gsICZsb29rdXBfZW50cnksICZsb29rdXApKSAhPSBOVUxMKQotCQlyZXR1cm4gcmV0OworCWUgPSBoYXNobWFwX2dldCgmcmVtb3Rlc19oYXNoLCAmbG9va3VwX2VudHJ5LCAmbG9va3VwKTsKKwlpZiAoZSkKKwkJcmV0dXJuIGNvbnRhaW5lcl9vZihlLCBzdHJ1Y3QgcmVtb3RlLCBlbnQpOwogCiAJcmV0ID0geGNhbGxvYygxLCBzaXplb2Yoc3RydWN0IHJlbW90ZSkpOwogCXJldC0+cHJ1bmUgPSAtMTsgIC8qIHVuc3BlY2lmaWVkICovCkBAIC0xNTgsOCArMTYxLDggQEAKIAlBTExPQ19HUk9XKHJlbW90ZXMsIHJlbW90ZXNfbnIgKyAxLCByZW1vdGVzX2FsbG9jKTsKIAlyZW1vdGVzW3JlbW90ZXNfbnIrK10gPSByZXQ7CiAKLQloYXNobWFwX2VudHJ5X2luaXQocmV0LCBsb29rdXBfZW50cnkuaGFzaCk7Ci0JcmVwbGFjZWQgPSBoYXNobWFwX3B1dCgmcmVtb3Rlc19oYXNoLCByZXQpOworCWhhc2htYXBfZW50cnlfaW5pdCgmcmV0LT5lbnQsIGxvb2t1cF9lbnRyeS5oYXNoKTsKKwlyZXBsYWNlZCA9IGhhc2htYXBfcHV0X2VudHJ5KCZyZW1vdGVzX2hhc2gsIHJldCwgZW50KTsKIAlhc3NlcnQocmVwbGFjZWQgPT0gTlVMTCk7ICAvKiBubyBwcmV2aW91cyBlbnRyeSBvdmVyd3JpdHRlbiAqLwogCXJldHVybiByZXQ7CiB9CmRpZmYgLS1naXQgYS9yZW1vdGUuaCBiL3JlbW90ZS5oCmluZGV4IDgzZTg4NTYuLjBlMWQyYjIgMTAwNjQ0Ci0tLSBhL3JlbW90ZS5oCisrKyBiL3JlbW90ZS5oCkBAIC0xNCw3ICsxNCw3IEBACiB9OwogCiBzdHJ1Y3QgcmVtb3RlIHsKLQlzdHJ1Y3QgaGFzaG1hcF9lbnRyeSBlbnQ7ICAvKiBtdXN0IGJlIGZpcnN0ICovCisJc3RydWN0IGhhc2htYXBfZW50cnkgZW50OwogCiAJY29uc3QgY2hhciAqbmFtZTsKIAlpbnQgb3JpZ2luLCBjb25maWd1cmVkX2luX3JlcG87CmRpZmYgLS1naXQgYS9yZXBvLXNldHRpbmdzLmMgYi9yZXBvLXNldHRpbmdzLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYTcwM2U0MAotLS0gL2Rldi9udWxsCisrKyBiL3JlcG8tc2V0dGluZ3MuYwpAQCAtMCwwICsxLDY4IEBACisjaW5jbHVkZSAiY2FjaGUuaCIKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJyZXBvc2l0b3J5LmgiCisKKyNkZWZpbmUgVVBEQVRFX0RFRkFVTFRfQk9PTChzLHYpIGRvIHsgaWYgKHMgPT0gLTEpIHsgcyA9IHY7IH0gfSB3aGlsZSgwKQorCit2b2lkIHByZXBhcmVfcmVwb19zZXR0aW5ncyhzdHJ1Y3QgcmVwb3NpdG9yeSAqcikKK3sKKwlpbnQgdmFsdWU7CisJY2hhciAqc3RydmFsOworCisJaWYgKHItPnNldHRpbmdzLmluaXRpYWxpemVkKQorCQlyZXR1cm47CisKKwkvKiBEZWZhdWx0cyAqLworCW1lbXNldCgmci0+c2V0dGluZ3MsIC0xLCBzaXplb2Yoci0+c2V0dGluZ3MpKTsKKworCWlmICghcmVwb19jb25maWdfZ2V0X2Jvb2wociwgImNvcmUuY29tbWl0Z3JhcGgiLCAmdmFsdWUpKQorCQlyLT5zZXR0aW5ncy5jb3JlX2NvbW1pdF9ncmFwaCA9IHZhbHVlOworCWlmICghcmVwb19jb25maWdfZ2V0X2Jvb2wociwgImdjLndyaXRlY29tbWl0Z3JhcGgiLCAmdmFsdWUpKQorCQlyLT5zZXR0aW5ncy5nY193cml0ZV9jb21taXRfZ3JhcGggPSB2YWx1ZTsKKwlVUERBVEVfREVGQVVMVF9CT09MKHItPnNldHRpbmdzLmNvcmVfY29tbWl0X2dyYXBoLCAxKTsKKwlVUERBVEVfREVGQVVMVF9CT09MKHItPnNldHRpbmdzLmdjX3dyaXRlX2NvbW1pdF9ncmFwaCwgMSk7CisKKwlpZiAoIXJlcG9fY29uZmlnX2dldF9pbnQociwgImluZGV4LnZlcnNpb24iLCAmdmFsdWUpKQorCQlyLT5zZXR0aW5ncy5pbmRleF92ZXJzaW9uID0gdmFsdWU7CisJaWYgKCFyZXBvX2NvbmZpZ19nZXRfbWF5YmVfYm9vbChyLCAiY29yZS51bnRyYWNrZWRjYWNoZSIsICZ2YWx1ZSkpIHsKKwkJaWYgKHZhbHVlID09IDApCisJCQlyLT5zZXR0aW5ncy5jb3JlX3VudHJhY2tlZF9jYWNoZSA9IFVOVFJBQ0tFRF9DQUNIRV9SRU1PVkU7CisJCWVsc2UKKwkJCXItPnNldHRpbmdzLmNvcmVfdW50cmFja2VkX2NhY2hlID0gVU5UUkFDS0VEX0NBQ0hFX1dSSVRFOworCX0gZWxzZSBpZiAoIXJlcG9fY29uZmlnX2dldF9zdHJpbmcociwgImNvcmUudW50cmFja2VkY2FjaGUiLCAmc3RydmFsKSkgeworCQlpZiAoIXN0cmNhc2VjbXAoc3RydmFsLCAia2VlcCIpKQorCQkJci0+c2V0dGluZ3MuY29yZV91bnRyYWNrZWRfY2FjaGUgPSBVTlRSQUNLRURfQ0FDSEVfS0VFUDsKKworCQlmcmVlKHN0cnZhbCk7CisJfQorCisJaWYgKCFyZXBvX2NvbmZpZ19nZXRfc3RyaW5nKHIsICJmZXRjaC5uZWdvdGlhdGlvbmFsZ29yaXRobSIsICZzdHJ2YWwpKSB7CisJCWlmICghc3RyY2FzZWNtcChzdHJ2YWwsICJza2lwcGluZyIpKQorCQkJci0+c2V0dGluZ3MuZmV0Y2hfbmVnb3RpYXRpb25fYWxnb3JpdGhtID0gRkVUQ0hfTkVHT1RJQVRJT05fU0tJUFBJTkc7CisJCWVsc2UKKwkJCXItPnNldHRpbmdzLmZldGNoX25lZ290aWF0aW9uX2FsZ29yaXRobSA9IEZFVENIX05FR09USUFUSU9OX0RFRkFVTFQ7CisJfQorCisJaWYgKCFyZXBvX2NvbmZpZ19nZXRfYm9vbChyLCAicGFjay51c2VzcGFyc2UiLCAmdmFsdWUpKQorCQlyLT5zZXR0aW5ncy5wYWNrX3VzZV9zcGFyc2UgPSB2YWx1ZTsKKwlpZiAoIXJlcG9fY29uZmlnX2dldF9ib29sKHIsICJmZWF0dXJlLm1hbnlmaWxlcyIsICZ2YWx1ZSkgJiYgdmFsdWUpIHsKKwkJVVBEQVRFX0RFRkFVTFRfQk9PTChyLT5zZXR0aW5ncy5pbmRleF92ZXJzaW9uLCA0KTsKKwkJVVBEQVRFX0RFRkFVTFRfQk9PTChyLT5zZXR0aW5ncy5jb3JlX3VudHJhY2tlZF9jYWNoZSwgVU5UUkFDS0VEX0NBQ0hFX1dSSVRFKTsKKwl9CisJaWYgKCFyZXBvX2NvbmZpZ19nZXRfYm9vbChyLCAiZmV0Y2gud3JpdGVjb21taXRncmFwaCIsICZ2YWx1ZSkpCisJCXItPnNldHRpbmdzLmZldGNoX3dyaXRlX2NvbW1pdF9ncmFwaCA9IHZhbHVlOworCWlmICghcmVwb19jb25maWdfZ2V0X2Jvb2wociwgImZlYXR1cmUuZXhwZXJpbWVudGFsIiwgJnZhbHVlKSAmJiB2YWx1ZSkgeworCQlVUERBVEVfREVGQVVMVF9CT09MKHItPnNldHRpbmdzLnBhY2tfdXNlX3NwYXJzZSwgMSk7CisJCVVQREFURV9ERUZBVUxUX0JPT0woci0+c2V0dGluZ3MuZmV0Y2hfbmVnb3RpYXRpb25fYWxnb3JpdGhtLCBGRVRDSF9ORUdPVElBVElPTl9TS0lQUElORyk7CisJCVVQREFURV9ERUZBVUxUX0JPT0woci0+c2V0dGluZ3MuZmV0Y2hfd3JpdGVfY29tbWl0X2dyYXBoLCAxKTsKKwl9CisJVVBEQVRFX0RFRkFVTFRfQk9PTChyLT5zZXR0aW5ncy5mZXRjaF93cml0ZV9jb21taXRfZ3JhcGgsIDApOworCisJLyogSGFjayBmb3IgdGVzdCBwcm9ncmFtcyBsaWtlIHRlc3QtZHVtcC11bnRyYWNrZWQtY2FjaGUgKi8KKwlpZiAoaWdub3JlX3VudHJhY2tlZF9jYWNoZV9jb25maWcpCisJCXItPnNldHRpbmdzLmNvcmVfdW50cmFja2VkX2NhY2hlID0gVU5UUkFDS0VEX0NBQ0hFX0tFRVA7CisJZWxzZQorCQlVUERBVEVfREVGQVVMVF9CT09MKHItPnNldHRpbmdzLmNvcmVfdW50cmFja2VkX2NhY2hlLCBVTlRSQUNLRURfQ0FDSEVfS0VFUCk7CisKKwlVUERBVEVfREVGQVVMVF9CT09MKHItPnNldHRpbmdzLmZldGNoX25lZ290aWF0aW9uX2FsZ29yaXRobSwgRkVUQ0hfTkVHT1RJQVRJT05fREVGQVVMVCk7Cit9CmRpZmYgLS1naXQgYS9yZXBvc2l0b3J5LmMgYi9yZXBvc2l0b3J5LmMKaW5kZXggNjgyYzIzOS4uYTQxNzRkZCAxMDA2NDQKLS0tIGEvcmVwb3NpdG9yeS5jCisrKyBiL3JlcG9zaXRvcnkuYwpAQCAtMjAwLDkgKzIwMCw5IEBACiAKIAlpZiAocmVwb19pbml0KHN1YnJlcG8sIGdpdGRpci5idWYsIHdvcmt0cmVlLmJ1ZikpIHsKIAkJLyoKLQkJICogSWYgaW5pdGlsaXphdGlvbiBmYWlscyB0aGVuIGl0IG1heSBiZSBkdWUgdG8gdGhlIHN1Ym1vZHVsZQorCQkgKiBJZiBpbml0aWFsaXphdGlvbiBmYWlscyB0aGVuIGl0IG1heSBiZSBkdWUgdG8gdGhlIHN1Ym1vZHVsZQogCQkgKiBub3QgYmVpbmcgcG9wdWxhdGVkIGluIHRoZSBzdXBlcnByb2plY3QncyB3b3JrdHJlZS4gIEluc3RlYWQKLQkJICogd2UgY2FuIHRyeSB0byBpbml0aWxpemUgdGhlIHN1Ym1vZHVsZSBieSBmaW5kaW5nIGl0J3MgZ2l0ZGlyCisJCSAqIHdlIGNhbiB0cnkgdG8gaW5pdGlhbGl6ZSB0aGUgc3VibW9kdWxlIGJ5IGZpbmRpbmcgaXQncyBnaXRkaXIKIAkJICogaW4gdGhlIHN1cGVycHJvamVjdCdzICdtb2R1bGVzJyBkaXJlY3RvcnkuICBJbiB0aGlzIGNhc2UgdGhlCiAJCSAqIHN1Ym1vZHVsZSB3b3VsZCBub3QgaGF2ZSBhIHdvcmt0cmVlLgogCQkgKi8KZGlmZiAtLWdpdCBhL3JlcG9zaXRvcnkuaCBiL3JlcG9zaXRvcnkuaAppbmRleCA0ZmI2YTU4Li4wNDAwNTdkIDEwMDY0NAotLS0gYS9yZXBvc2l0b3J5LmgKKysrIGIvcmVwb3NpdG9yeS5oCkBAIC0xMSw2ICsxMSwzNCBAQAogc3RydWN0IHJhd19vYmplY3Rfc3RvcmU7CiBzdHJ1Y3Qgc3VibW9kdWxlX2NhY2hlOwogCitlbnVtIHVudHJhY2tlZF9jYWNoZV9zZXR0aW5nIHsKKwlVTlRSQUNLRURfQ0FDSEVfVU5TRVQgPSAtMSwKKwlVTlRSQUNLRURfQ0FDSEVfUkVNT1ZFID0gMCwKKwlVTlRSQUNLRURfQ0FDSEVfS0VFUCA9IDEsCisJVU5UUkFDS0VEX0NBQ0hFX1dSSVRFID0gMgorfTsKKworZW51bSBmZXRjaF9uZWdvdGlhdGlvbl9zZXR0aW5nIHsKKwlGRVRDSF9ORUdPVElBVElPTl9VTlNFVCA9IC0xLAorCUZFVENIX05FR09USUFUSU9OX05PTkUgPSAwLAorCUZFVENIX05FR09USUFUSU9OX0RFRkFVTFQgPSAxLAorCUZFVENIX05FR09USUFUSU9OX1NLSVBQSU5HID0gMiwKK307CisKK3N0cnVjdCByZXBvX3NldHRpbmdzIHsKKwlpbnQgaW5pdGlhbGl6ZWQ7CisKKwlpbnQgY29yZV9jb21taXRfZ3JhcGg7CisJaW50IGdjX3dyaXRlX2NvbW1pdF9ncmFwaDsKKwlpbnQgZmV0Y2hfd3JpdGVfY29tbWl0X2dyYXBoOworCisJaW50IGluZGV4X3ZlcnNpb247CisJZW51bSB1bnRyYWNrZWRfY2FjaGVfc2V0dGluZyBjb3JlX3VudHJhY2tlZF9jYWNoZTsKKworCWludCBwYWNrX3VzZV9zcGFyc2U7CisJZW51bSBmZXRjaF9uZWdvdGlhdGlvbl9zZXR0aW5nIGZldGNoX25lZ290aWF0aW9uX2FsZ29yaXRobTsKK307CisKIHN0cnVjdCByZXBvc2l0b3J5IHsKIAkvKiBFbnZpcm9ubWVudCAqLwogCS8qCkBAIC03Miw2ICsxMDAsOCBAQAogCSAqLwogCWNoYXIgKnN1Ym1vZHVsZV9wcmVmaXg7CiAKKwlzdHJ1Y3QgcmVwb19zZXR0aW5ncyBzZXR0aW5nczsKKwogCS8qIFN1YnN5c3RlbXMgKi8KIAkvKgogCSAqIFJlcG9zaXRvcnkncyBjb25maWcgd2hpY2ggY29udGFpbnMga2V5LXZhbHVlIHBhaXJzIGZyb20gdGhlIHVzdWFsCkBAIC05NSw2ICsxMjUsOSBAQAogCS8qIEEgdW5pcXVlLWlkIGZvciB0cmFjaW5nIHB1cnBvc2VzLiAqLwogCWludCB0cmFjZTJfcmVwb19pZDsKIAorCS8qIFRydWUgaWYgY29tbWl0LWdyYXBoIGhhcyBiZWVuIGRpc2FibGVkIHdpdGhpbiB0aGlzIHByb2Nlc3MuICovCisJaW50IGNvbW1pdF9ncmFwaF9kaXNhYmxlZDsKKwogCS8qIENvbmZpZ3VyYXRpb25zICovCiAKIAkvKiBJbmRpY2F0ZSBpZiBhIHJlcG9zaXRvcnkgaGFzIGEgZGlmZmVyZW50ICdjb21tb25kaXInIGZyb20gJ2dpdGRpcicgKi8KQEAgLTEzOSw3ICsxNzIsNyBAQAogICogYmUgYWxsb2NhdGVkIGlmIG5lZWRlZC4KICAqCiAgKiBSZXR1cm4gdGhlIG51bWJlciBvZiBpbmRleCBlbnRyaWVzIGluIHRoZSBwb3B1bGF0ZWQgaW5kZXggb3IgYSB2YWx1ZSBsZXNzCi0gKiB0aGFuIHplcm8gaWYgYW4gZXJyb3Igb2NjdXJlZC4gIElmIHRoZSByZXBvc2l0b3J5J3MgaW5kZXggaGFzIGFscmVhZHkgYmVlbgorICogdGhhbiB6ZXJvIGlmIGFuIGVycm9yIG9jY3VycmVkLiAgSWYgdGhlIHJlcG9zaXRvcnkncyBpbmRleCBoYXMgYWxyZWFkeSBiZWVuCiAgKiBwb3B1bGF0ZWQgdGhlbiB0aGUgbnVtYmVyIG9mIGVudHJpZXMgd2lsbCBzaW1wbHkgYmUgcmV0dXJuZWQuCiAgKi8KIGludCByZXBvX3JlYWRfaW5kZXgoc3RydWN0IHJlcG9zaXRvcnkgKnJlcG8pOwpAQCAtMTU3LDUgKzE5MCw2IEBACiAgKi8KIHZvaWQgcmVwb191cGRhdGVfaW5kZXhfaWZfYWJsZShzdHJ1Y3QgcmVwb3NpdG9yeSAqLCBzdHJ1Y3QgbG9ja19maWxlICopOwogCit2b2lkIHByZXBhcmVfcmVwb19zZXR0aW5ncyhzdHJ1Y3QgcmVwb3NpdG9yeSAqcik7CiAKICNlbmRpZiAvKiBSRVBPU0lUT1JZX0ggKi8KZGlmZiAtLWdpdCBhL3JlcmVyZS5jIGIvcmVyZXJlLmMKaW5kZXggMTdhYmI0Ny4uOTI4MTEzMSAxMDA2NDQKLS0tIGEvcmVyZXJlLmMKKysrIGIvcmVyZXJlLmMKQEAgLTUyLDcgKzUyLDcgQEAKIAogc3RhdGljIGNvbnN0IGNoYXIgKnJlcmVyZV9pZF9oZXgoY29uc3Qgc3RydWN0IHJlcmVyZV9pZCAqaWQpCiB7Ci0JcmV0dXJuIHNoYTFfdG9faGV4KGlkLT5jb2xsZWN0aW9uLT5oYXNoKTsKKwlyZXR1cm4gaGFzaF90b19oZXgoaWQtPmNvbGxlY3Rpb24tPmhhc2gpOwogfQogCiBzdGF0aWMgdm9pZCBmaXRfdmFyaWFudChzdHJ1Y3QgcmVyZXJlX2RpciAqcnJfZGlyLCBpbnQgdmFyaWFudCkKQEAgLTExNSw3ICsxMTUsNyBAQAogc3RhdGljIHZvaWQgc2Nhbl9yZXJlcmVfZGlyKHN0cnVjdCByZXJlcmVfZGlyICpycl9kaXIpCiB7CiAJc3RydWN0IGRpcmVudCAqZGU7Ci0JRElSICpkaXIgPSBvcGVuZGlyKGdpdF9wYXRoKCJyci1jYWNoZS8lcyIsIHNoYTFfdG9faGV4KHJyX2Rpci0+aGFzaCkpKTsKKwlESVIgKmRpciA9IG9wZW5kaXIoZ2l0X3BhdGgoInJyLWNhY2hlLyVzIiwgaGFzaF90b19oZXgocnJfZGlyLT5oYXNoKSkpOwogCiAJaWYgKCFkaXIpCiAJCXJldHVybjsKQEAgLTE4Niw5ICsxODYsOSBAQAogCXJldHVybiBpZDsKIH0KIAotc3RhdGljIHN0cnVjdCByZXJlcmVfaWQgKm5ld19yZXJlcmVfaWQodW5zaWduZWQgY2hhciAqc2hhMSkKK3N0YXRpYyBzdHJ1Y3QgcmVyZXJlX2lkICpuZXdfcmVyZXJlX2lkKHVuc2lnbmVkIGNoYXIgKmhhc2gpCiB7Ci0JcmV0dXJuIG5ld19yZXJlcmVfaWRfaGV4KHNoYTFfdG9faGV4KHNoYTEpKTsKKwlyZXR1cm4gbmV3X3JlcmVyZV9pZF9oZXgoaGFzaF90b19oZXgoaGFzaCkpOwogfQogCiAvKgpAQCAtNDMxLDcgKzQzMSw3IEBACiAgKiBhbmQgTlVMIGNvbmNhdGVuYXRlZCB0b2dldGhlci4KICAqCiAgKiBSZXR1cm4gMSBpZiBjb25mbGljdCBodW5rcyBhcmUgZm91bmQsIDAgaWYgdGhlcmUgYXJlIG5vIGNvbmZsaWN0Ci0gKiBodW5rcyBhbmQgLTEgaWYgYW4gZXJyb3Igb2NjdXJlZC4KKyAqIGh1bmtzIGFuZCAtMSBpZiBhbiBlcnJvciBvY2N1cnJlZC4KICAqLwogc3RhdGljIGludCBoYW5kbGVfcGF0aCh1bnNpZ25lZCBjaGFyICpoYXNoLCBzdHJ1Y3QgcmVyZXJlX2lvICppbywgaW50IG1hcmtlcl9zaXplKQogewpkaWZmIC0tZ2l0IGEvcmV2aXNpb24uYyBiL3JldmlzaW9uLmMKaW5kZXggMDc0MTIyOS4uN2UyM2M1ZSAxMDA2NDQKLS0tIGEvcmV2aXNpb24uYworKysgYi9yZXZpc2lvbi5jCkBAIC0yOCw2ICsyOCw3IEBACiAjaW5jbHVkZSAiY29tbWl0LWdyYXBoLmgiCiAjaW5jbHVkZSAicHJpby1xdWV1ZS5oIgogI2luY2x1ZGUgImhhc2htYXAuaCIKKyNpbmNsdWRlICJ1dGY4LmgiCiAKIHZvbGF0aWxlIHNob3dfZWFybHlfb3V0cHV0X2ZuX3Qgc2hvd19lYXJseV9vdXRwdXQ7CiAKQEAgLTEwNywzMCArMTA4LDM0IEBACiB9OwogCiBzdGF0aWMgaW50IHBhdGhfYW5kX29pZHNfY21wKGNvbnN0IHZvaWQgKmhhc2htYXBfY21wX2ZuX2RhdGEsCi0JCQkgICAgIGNvbnN0IHN0cnVjdCBwYXRoX2FuZF9vaWRzX2VudHJ5ICplMSwKLQkJCSAgICAgY29uc3Qgc3RydWN0IHBhdGhfYW5kX29pZHNfZW50cnkgKmUyLAorCQkJICAgICBjb25zdCBzdHJ1Y3QgaGFzaG1hcF9lbnRyeSAqZXB0ciwKKwkJCSAgICAgY29uc3Qgc3RydWN0IGhhc2htYXBfZW50cnkgKmVudHJ5X29yX2tleSwKIAkJCSAgICAgY29uc3Qgdm9pZCAqa2V5ZGF0YSkKIHsKKwljb25zdCBzdHJ1Y3QgcGF0aF9hbmRfb2lkc19lbnRyeSAqZTEsICplMjsKKworCWUxID0gY29udGFpbmVyX29mKGVwdHIsIGNvbnN0IHN0cnVjdCBwYXRoX2FuZF9vaWRzX2VudHJ5LCBlbnQpOworCWUyID0gY29udGFpbmVyX29mKGVudHJ5X29yX2tleSwgY29uc3Qgc3RydWN0IHBhdGhfYW5kX29pZHNfZW50cnksIGVudCk7CisKIAlyZXR1cm4gc3RyY21wKGUxLT5wYXRoLCBlMi0+cGF0aCk7CiB9CiAKIHN0YXRpYyB2b2lkIHBhdGhzX2FuZF9vaWRzX2luaXQoc3RydWN0IGhhc2htYXAgKm1hcCkKIHsKLQloYXNobWFwX2luaXQobWFwLCAoaGFzaG1hcF9jbXBfZm4pIHBhdGhfYW5kX29pZHNfY21wLCBOVUxMLCAwKTsKKwloYXNobWFwX2luaXQobWFwLCBwYXRoX2FuZF9vaWRzX2NtcCwgTlVMTCwgMCk7CiB9CiAKIHN0YXRpYyB2b2lkIHBhdGhzX2FuZF9vaWRzX2NsZWFyKHN0cnVjdCBoYXNobWFwICptYXApCiB7CiAJc3RydWN0IGhhc2htYXBfaXRlciBpdGVyOwogCXN0cnVjdCBwYXRoX2FuZF9vaWRzX2VudHJ5ICplbnRyeTsKLQloYXNobWFwX2l0ZXJfaW5pdChtYXAsICZpdGVyKTsKIAotCXdoaWxlICgoZW50cnkgPSAoc3RydWN0IHBhdGhfYW5kX29pZHNfZW50cnkgKiloYXNobWFwX2l0ZXJfbmV4dCgmaXRlcikpKSB7CisJaGFzaG1hcF9mb3JfZWFjaF9lbnRyeShtYXAsICZpdGVyLCBlbnRyeSwgZW50IC8qIG1lbWJlciBuYW1lICovKSB7CiAJCW9pZHNldF9jbGVhcigmZW50cnktPnRyZWVzKTsKIAkJZnJlZShlbnRyeS0+cGF0aCk7CiAJfQogCi0JaGFzaG1hcF9mcmVlKG1hcCwgMSk7CisJaGFzaG1hcF9mcmVlX2VudHJpZXMobWFwLCBzdHJ1Y3QgcGF0aF9hbmRfb2lkc19lbnRyeSwgZW50KTsKIH0KIAogc3RhdGljIHZvaWQgcGF0aHNfYW5kX29pZHNfaW5zZXJ0KHN0cnVjdCBoYXNobWFwICptYXAsCkBAIC0xNDEsMTggKzE0NiwxOSBAQAogCXN0cnVjdCBwYXRoX2FuZF9vaWRzX2VudHJ5IGtleTsKIAlzdHJ1Y3QgcGF0aF9hbmRfb2lkc19lbnRyeSAqZW50cnk7CiAKLQloYXNobWFwX2VudHJ5X2luaXQoJmtleSwgaGFzaCk7CisJaGFzaG1hcF9lbnRyeV9pbml0KCZrZXkuZW50LCBoYXNoKTsKIAogCS8qIHVzZSBhIHNoYWxsb3cgY29weSBmb3IgdGhlIGxvb2t1cCAqLwogCWtleS5wYXRoID0gKGNoYXIgKilwYXRoOwogCW9pZHNldF9pbml0KCZrZXkudHJlZXMsIDApOwogCi0JaWYgKCEoZW50cnkgPSAoc3RydWN0IHBhdGhfYW5kX29pZHNfZW50cnkgKiloYXNobWFwX2dldChtYXAsICZrZXksIE5VTEwpKSkgeworCWVudHJ5ID0gaGFzaG1hcF9nZXRfZW50cnkobWFwLCAma2V5LCBlbnQsIE5VTEwpOworCWlmICghZW50cnkpIHsKIAkJZW50cnkgPSB4Y2FsbG9jKDEsIHNpemVvZihzdHJ1Y3QgcGF0aF9hbmRfb2lkc19lbnRyeSkpOwotCQloYXNobWFwX2VudHJ5X2luaXQoZW50cnksIGhhc2gpOworCQloYXNobWFwX2VudHJ5X2luaXQoJmVudHJ5LT5lbnQsIGhhc2gpOwogCQllbnRyeS0+cGF0aCA9IHhzdHJkdXAoa2V5LnBhdGgpOwogCQlvaWRzZXRfaW5pdCgmZW50cnktPnRyZWVzLCAxNik7Ci0JCWhhc2htYXBfcHV0KG1hcCwgZW50cnkpOworCQloYXNobWFwX3B1dChtYXAsICZlbnRyeS0+ZW50KTsKIAl9CiAKIAlvaWRzZXRfaW5zZXJ0KCZlbnRyeS0+dHJlZXMsIG9pZCk7CkBAIC0yMzUsOCArMjQxLDcgQEAKIAkJYWRkX2NoaWxkcmVuX2J5X3BhdGgociwgdHJlZSwgJm1hcCk7CiAJfQogCi0JaGFzaG1hcF9pdGVyX2luaXQoJm1hcCwgJm1hcF9pdGVyKTsKLQl3aGlsZSAoKGVudHJ5ID0gaGFzaG1hcF9pdGVyX25leHQoJm1hcF9pdGVyKSkpCisJaGFzaG1hcF9mb3JfZWFjaF9lbnRyeSgmbWFwLCAmbWFwX2l0ZXIsIGVudHJ5LCBlbnQgLyogbWVtYmVyIG5hbWUgKi8pCiAJCW1hcmtfdHJlZXNfdW5pbnRlcmVzdGluZ19zcGFyc2UociwgJmVudHJ5LT50cmVlcyk7CiAKIAlwYXRoc19hbmRfb2lkc19jbGVhcigmbWFwKTsKQEAgLTQwNCw5ICs0MDksNyBAQAogCQlzdHJ1Y3QgdGFnICp0YWcgPSAoc3RydWN0IHRhZyAqKSBvYmplY3Q7CiAJCWlmIChyZXZzLT50YWdfb2JqZWN0cyAmJiAhKGZsYWdzICYgVU5JTlRFUkVTVElORykpCiAJCQlhZGRfcGVuZGluZ19vYmplY3QocmV2cywgb2JqZWN0LCB0YWctPnRhZyk7Ci0JCWlmICghdGFnLT50YWdnZWQpCi0JCQlkaWUoImJhZCB0YWciKTsKLQkJb2JqZWN0ID0gcGFyc2Vfb2JqZWN0KHJldnMtPnJlcG8sICZ0YWctPnRhZ2dlZC0+b2lkKTsKKwkJb2JqZWN0ID0gcGFyc2Vfb2JqZWN0KHJldnMtPnJlcG8sIGdldF90YWdnZWRfb2lkKHRhZykpOwogCQlpZiAoIW9iamVjdCkgewogCQkJaWYgKHJldnMtPmlnbm9yZV9taXNzaW5nX2xpbmtzIHx8IChmbGFncyAmIFVOSU5URVJFU1RJTkcpKQogCQkJCXJldHVybiBOVUxMOwpAQCAtMjA2Myw3ICsyMDY2LDYgQEAKIAkJcmV2cy0+c2ltcGxpZnlfYnlfZGVjb3JhdGlvbiA9IDE7CiAJCXJldnMtPmxpbWl0ZWQgPSAxOwogCQlyZXZzLT5wcnVuZSA9IDE7Ci0JCWxvYWRfcmVmX2RlY29yYXRpb25zKE5VTEwsIERFQ09SQVRFX1NIT1JUX1JFRlMpOwogCX0gZWxzZSBpZiAoIXN0cmNtcChhcmcsICItLWRhdGUtb3JkZXIiKSkgewogCQlyZXZzLT5zb3J0X29yZGVyID0gUkVWX1NPUlRfQllfQ09NTUlUX0RBVEU7CiAJCXJldnMtPnRvcG9fb3JkZXIgPSAxOwpAQCAtMjUyMyw2ICsyNTI1LDcgQEAKIAlpbnQgaSwgZmxhZ3MsIGxlZnQsIHNlZW5fZGFzaGRhc2gsIGdvdF9yZXZfYXJnID0gMCwgcmV2YXJnX29wdDsKIAlzdHJ1Y3QgYXJndl9hcnJheSBwcnVuZV9kYXRhID0gQVJHVl9BUlJBWV9JTklUOwogCWNvbnN0IGNoYXIgKnN1Ym1vZHVsZSA9IE5VTEw7CisJaW50IHNlZW5fZW5kX29mX29wdGlvbnMgPSAwOwogCiAJaWYgKG9wdCkKIAkJc3VibW9kdWxlID0gb3B0LT5zdWJtb2R1bGU7CkBAIC0yNTUyLDcgKzI1NTUsNyBAQAogCQlyZXZhcmdfb3B0IHw9IFJFVkFSR19DQU5OT1RfQkVfRklMRU5BTUU7CiAJZm9yIChsZWZ0ID0gaSA9IDE7IGkgPCBhcmdjOyBpKyspIHsKIAkJY29uc3QgY2hhciAqYXJnID0gYXJndltpXTsKLQkJaWYgKCphcmcgPT0gJy0nKSB7CisJCWlmICghc2Vlbl9lbmRfb2Zfb3B0aW9ucyAmJiAqYXJnID09ICctJykgewogCQkJaW50IG9wdHM7CiAKIAkJCW9wdHMgPSBoYW5kbGVfcmV2aXNpb25fcHNldWRvX29wdChzdWJtb2R1bGUsCkBAIC0yNTc0LDYgKzI1NzcsMTEgQEAKIAkJCQljb250aW51ZTsKIAkJCX0KIAorCQkJaWYgKCFzdHJjbXAoYXJnLCAiLS1lbmQtb2Ytb3B0aW9ucyIpKSB7CisJCQkJc2Vlbl9lbmRfb2Zfb3B0aW9ucyA9IDE7CisJCQkJY29udGludWU7CisJCQl9CisKIAkJCW9wdHMgPSBoYW5kbGVfcmV2aXNpb25fb3B0KHJldnMsIGFyZ2MgLSBpLCBhcmd2ICsgaSwKIAkJCQkJCSAgICZsZWZ0LCBhcmd2LCBvcHQpOwogCQkJaWYgKG9wdHMgPiAwKSB7CkBAIC0yNjg0LDYgKzI2OTIsOCBAQAogCiAJZ3JlcF9jb21taXRfcGF0dGVybl90eXBlKEdSRVBfUEFUVEVSTl9UWVBFX1VOU1BFQ0lGSUVELAogCQkJCSAmcmV2cy0+Z3JlcF9maWx0ZXIpOworCWlmICghaXNfZW5jb2RpbmdfdXRmOChnZXRfbG9nX291dHB1dF9lbmNvZGluZygpKSkKKwkJcmV2cy0+Z3JlcF9maWx0ZXIuaWdub3JlX2xvY2FsZSA9IDE7CiAJY29tcGlsZV9ncmVwX3BhdHRlcm5zKCZyZXZzLT5ncmVwX2ZpbHRlcik7CiAKIAlpZiAocmV2cy0+cmV2ZXJzZSAmJiByZXZzLT5yZWZsb2dfaW5mbykKQEAgLTMwODgsNyArMzA5OCw3IEBACiAKIHZvaWQgcmVzZXRfcmV2aXNpb25fd2Fsayh2b2lkKQogewotCWNsZWFyX29iamVjdF9mbGFncyhTRUVOIHwgQURERUQgfCBTSE9XTik7CisJY2xlYXJfb2JqZWN0X2ZsYWdzKFNFRU4gfCBBRERFRCB8IFNIT1dOIHwgVE9QT19XQUxLX0VYUExPUkVEIHwgVE9QT19XQUxLX0lOREVHUkVFKTsKIH0KIAogc3RhdGljIGludCBtYXJrX3VuaW50ZXJlc3RpbmcoY29uc3Qgc3RydWN0IG9iamVjdF9pZCAqb2lkLApAQCAtMzIwMSwxMCArMzIxMSwyNiBAQAogCQlpbmRlZ3JlZV93YWxrX3N0ZXAocmV2cyk7CiB9CiAKK3N0YXRpYyB2b2lkIHJlc2V0X3RvcG9fd2FsayhzdHJ1Y3QgcmV2X2luZm8gKnJldnMpCit7CisJc3RydWN0IHRvcG9fd2Fsa19pbmZvICppbmZvID0gcmV2cy0+dG9wb193YWxrX2luZm87CisKKwljbGVhcl9wcmlvX3F1ZXVlKCZpbmZvLT5leHBsb3JlX3F1ZXVlKTsKKwljbGVhcl9wcmlvX3F1ZXVlKCZpbmZvLT5pbmRlZ3JlZV9xdWV1ZSk7CisJY2xlYXJfcHJpb19xdWV1ZSgmaW5mby0+dG9wb19xdWV1ZSk7CisJY2xlYXJfaW5kZWdyZWVfc2xhYigmaW5mby0+aW5kZWdyZWUpOworCWNsZWFyX2F1dGhvcl9kYXRlX3NsYWIoJmluZm8tPmF1dGhvcl9kYXRlKTsKKworCUZSRUVfQU5EX05VTEwocmV2cy0+dG9wb193YWxrX2luZm8pOworfQorCiBzdGF0aWMgdm9pZCBpbml0X3RvcG9fd2FsayhzdHJ1Y3QgcmV2X2luZm8gKnJldnMpCiB7CiAJc3RydWN0IHRvcG9fd2Fsa19pbmZvICppbmZvOwogCXN0cnVjdCBjb21taXRfbGlzdCAqbGlzdDsKKwlpZiAocmV2cy0+dG9wb193YWxrX2luZm8pCisJCXJlc2V0X3RvcG9fd2FsayhyZXZzKTsKKwogCXJldnMtPnRvcG9fd2Fsa19pbmZvID0geG1hbGxvYyhzaXplb2Yoc3RydWN0IHRvcG9fd2Fsa19pbmZvKSk7CiAJaW5mbyA9IHJldnMtPnRvcG9fd2Fsa19pbmZvOwogCW1lbXNldChpbmZvLCAwLCBzaXplb2Yoc3RydWN0IHRvcG9fd2Fsa19pbmZvKSk7CmRpZmYgLS1naXQgYS9zZW5kLXBhY2suYyBiL3NlbmQtcGFjay5jCmluZGV4IDZkYzE2YzMuLmE3MzIyZDMgMTAwNjQ0Ci0tLSBhL3NlbmQtcGFjay5jCisrKyBiL3NlbmQtcGFjay5jCkBAIC00MCw3ICs0MCw4IEBACiAKIHN0YXRpYyB2b2lkIGZlZWRfb2JqZWN0KGNvbnN0IHN0cnVjdCBvYmplY3RfaWQgKm9pZCwgRklMRSAqZmgsIGludCBuZWdhdGl2ZSkKIHsKLQlpZiAobmVnYXRpdmUgJiYgIWhhc19vYmplY3RfZmlsZShvaWQpKQorCWlmIChuZWdhdGl2ZSAmJgorCSAgICAhaGFzX29iamVjdF9maWxlX3dpdGhfZmxhZ3Mob2lkLCBPQkpFQ1RfSU5GT19TS0lQX0ZFVENIX09CSkVDVCkpCiAJCXJldHVybjsKIAogCWlmIChuZWdhdGl2ZSkKQEAgLTU2NCw4ICs1NjUsNiBAQAogCiAJaWYgKG5lZWRfcGFja19kYXRhICYmIGNtZHNfc2VudCkgewogCQlpZiAocGFja19vYmplY3RzKG91dCwgcmVtb3RlX3JlZnMsIGV4dHJhX2hhdmUsIGFyZ3MpIDwgMCkgewotCQkJZm9yIChyZWYgPSByZW1vdGVfcmVmczsgcmVmOyByZWYgPSByZWYtPm5leHQpCi0JCQkJcmVmLT5zdGF0dXMgPSBSRUZfU1RBVFVTX05PTkU7CiAJCQlpZiAoYXJncy0+c3RhdGVsZXNzX3JwYykKIAkJCQljbG9zZShvdXQpOwogCQkJaWYgKGdpdF9jb25uZWN0aW9uX2lzX3NvY2tldChjb25uKSkKQEAgLTU3MywxMCArNTcyLDEyIEBACiAKIAkJCS8qCiAJCQkgKiBEbyBub3QgZXZlbiBib3RoZXIgd2l0aCB0aGUgcmV0dXJuIHZhbHVlOyB3ZSBrbm93IHdlCi0JCQkgKiBhcmUgZmFpbGluZywgYW5kIGp1c3Qgd2FudCB0aGUgZXJyb3IoKSBzaWRlIGVmZmVjdHMuCisJCQkgKiBhcmUgZmFpbGluZywgYW5kIGp1c3Qgd2FudCB0aGUgZXJyb3IoKSBzaWRlIGVmZmVjdHMsCisJCQkgKiBhcyB3ZWxsIGFzIG1hcmtpbmcgcmVmcyB3aXRoIHRoZWlyIHJlbW90ZSBzdGF0dXMgKGlmCisJCQkgKiB3ZSBnZXQgb25lKS4KIAkJCSAqLwogCQkJaWYgKHN0YXR1c19yZXBvcnQpCi0JCQkJcmVjZWl2ZV91bnBhY2tfc3RhdHVzKCZyZWFkZXIpOworCQkJCXJlY2VpdmVfc3RhdHVzKCZyZWFkZXIsIHJlbW90ZV9yZWZzKTsKIAogCQkJaWYgKHVzZV9zaWRlYmFuZCkgewogCQkJCWNsb3NlKGRlbXV4Lm91dCk7CmRpZmYgLS1naXQgYS9zZXF1ZW5jZXIuYyBiL3NlcXVlbmNlci5jCmluZGV4IDM0ZWJmOGUuLmQxOGFiYTYgMTAwNjQ0Ci0tLSBhL3NlcXVlbmNlci5jCisrKyBiL3NlcXVlbmNlci5jCkBAIC0xMzEsNyArMTMxLDcgQEAKIAkicmViYXNlLW1lcmdlL3Jld3JpdHRlbi1wZW5kaW5nIikKIAogLyoKLSAqIFRoZSBwYXRoIG9mIHRoZSBmaWxlIGNvbnRhaW5pZyB0aGUgT0lEIG9mIHRoZSAic3F1YXNoIG9udG8iIGNvbW1pdCwgaS5lLgorICogVGhlIHBhdGggb2YgdGhlIGZpbGUgY29udGFpbmluZyB0aGUgT0lEIG9mIHRoZSAic3F1YXNoIG9udG8iIGNvbW1pdCwgaS5lLgogICogdGhlIGR1bW15IGNvbW1pdCB1c2VkIGZvciBgcmVzZXQgW25ldyByb290XWAuCiAgKi8KIHN0YXRpYyBHSVRfUEFUSF9GVU5DKHJlYmFzZV9wYXRoX3NxdWFzaF9vbnRvLCAicmViYXNlLW1lcmdlL3NxdWFzaC1vbnRvIikKQEAgLTU4Niw3ICs1ODYsNyBAQAogCQkJICAgICAgc3RydWN0IHJlcGxheV9vcHRzICpvcHRzKQogewogCXN0cnVjdCBtZXJnZV9vcHRpb25zIG87Ci0Jc3RydWN0IHRyZWUgKnJlc3VsdCwgKm5leHRfdHJlZSwgKmJhc2VfdHJlZSwgKmhlYWRfdHJlZTsKKwlzdHJ1Y3QgdHJlZSAqbmV4dF90cmVlLCAqYmFzZV90cmVlLCAqaGVhZF90cmVlOwogCWludCBjbGVhbjsKIAljaGFyICoqeG9wdDsKIAlzdHJ1Y3QgbG9ja19maWxlIGluZGV4X2xvY2sgPSBMT0NLX0lOSVQ7CkBAIC02MTMsMTEgKzYxMywxMCBAQAogCiAJY2xlYW4gPSBtZXJnZV90cmVlcygmbywKIAkJCSAgICBoZWFkX3RyZWUsCi0JCQkgICAgbmV4dF90cmVlLCBiYXNlX3RyZWUsICZyZXN1bHQpOworCQkJICAgIG5leHRfdHJlZSwgYmFzZV90cmVlKTsKIAlpZiAoaXNfcmViYXNlX2kob3B0cykgJiYgY2xlYW4gPD0gMCkKIAkJZnB1dHMoby5vYnVmLmJ1Ziwgc3Rkb3V0KTsKIAlzdHJidWZfcmVsZWFzZSgmby5vYnVmKTsKLQlkaWZmX3dhcm5fcmVuYW1lX2xpbWl0KCJtZXJnZS5yZW5hbWVsaW1pdCIsIG8ubmVlZGVkX3JlbmFtZV9saW1pdCwgMCk7CiAJaWYgKGNsZWFuIDwgMCkgewogCQlyb2xsYmFja19sb2NrX2ZpbGUoJmluZGV4X2xvY2spOwogCQlyZXR1cm4gY2xlYW47CkBAIC04NjksMzQgKzg2OCw2IEBACiAJcmV0dXJuIE5VTEw7CiB9CiAKLS8qIFJlYWQgYXV0aG9yLXNjcmlwdCBhbmQgcmV0dXJuIGFuIGlkZW50IGxpbmUgKGF1dGhvciA8ZW1haWw+IHRpbWVzdGFtcCkgKi8KLXN0YXRpYyBjb25zdCBjaGFyICpyZWFkX2F1dGhvcl9pZGVudChzdHJ1Y3Qgc3RyYnVmICpidWYpCi17Ci0Jc3RydWN0IHN0cmJ1ZiBvdXQgPSBTVFJCVUZfSU5JVDsKLQljaGFyICpuYW1lLCAqZW1haWwsICpkYXRlOwotCi0JaWYgKHJlYWRfYXV0aG9yX3NjcmlwdChyZWJhc2VfcGF0aF9hdXRob3Jfc2NyaXB0KCksCi0JCQkgICAgICAgJm5hbWUsICZlbWFpbCwgJmRhdGUsIDApKQotCQlyZXR1cm4gTlVMTDsKLQotCS8qIHZhbGlkYXRlIGRhdGUgc2luY2UgZm10X2lkZW50KCkgd2lsbCBkaWUoKSBvbiBiYWQgdmFsdWUgKi8KLQlpZiAocGFyc2VfZGF0ZShkYXRlLCAmb3V0KSl7Ci0JCXdhcm5pbmcoXygiaW52YWxpZCBkYXRlIGZvcm1hdCAnJXMnIGluICclcyciKSwKLQkJCWRhdGUsIHJlYmFzZV9wYXRoX2F1dGhvcl9zY3JpcHQoKSk7Ci0JCXN0cmJ1Zl9yZWxlYXNlKCZvdXQpOwotCQlyZXR1cm4gTlVMTDsKLQl9Ci0KLQlzdHJidWZfcmVzZXQoJm91dCk7Ci0Jc3RyYnVmX2FkZHN0cigmb3V0LCBmbXRfaWRlbnQobmFtZSwgZW1haWwsIFdBTlRfQVVUSE9SX0lERU5ULCBkYXRlLCAwKSk7Ci0Jc3RyYnVmX3N3YXAoYnVmLCAmb3V0KTsKLQlzdHJidWZfcmVsZWFzZSgmb3V0KTsKLQlmcmVlKG5hbWUpOwotCWZyZWUoZW1haWwpOwotCWZyZWUoZGF0ZSk7Ci0JcmV0dXJuIGJ1Zi0+YnVmOwotfQotCiBzdGF0aWMgY29uc3QgY2hhciBzdGFnZWRfY2hhbmdlc19hZHZpY2VbXSA9CiBOXygieW91IGhhdmUgc3RhZ2VkIGNoYW5nZXMgaW4geW91ciB3b3JraW5nIHRyZWVcbiIKICJJZiB0aGVzZSBjaGFuZ2VzIGFyZSBtZWFudCB0byBiZSBzcXVhc2hlZCBpbnRvIHRoZSBwcmV2aW91cyBjb21taXQsIHJ1bjpcbiIKQEAgLTk1NCw0NyArOTI1LDYgQEAKIHsKIAlzdHJ1Y3QgY2hpbGRfcHJvY2VzcyBjbWQgPSBDSElMRF9QUk9DRVNTX0lOSVQ7CiAKLQlpZiAoKGZsYWdzICYgQ1JFQVRFX1JPT1RfQ09NTUlUKSAmJiAhKGZsYWdzICYgQU1FTkRfTVNHKSkgewotCQlzdHJ1Y3Qgc3RyYnVmIG1zZyA9IFNUUkJVRl9JTklULCBzY3JpcHQgPSBTVFJCVUZfSU5JVDsKLQkJY29uc3QgY2hhciAqYXV0aG9yID0gTlVMTDsKLQkJc3RydWN0IG9iamVjdF9pZCByb290X2NvbW1pdCwgKmNhY2hlX3RyZWVfb2lkOwotCQlpbnQgcmVzID0gMDsKLQotCQlpZiAoaXNfcmViYXNlX2kob3B0cykpIHsKLQkJCWF1dGhvciA9IHJlYWRfYXV0aG9yX2lkZW50KCZzY3JpcHQpOwotCQkJaWYgKCFhdXRob3IpIHsKLQkJCQlzdHJidWZfcmVsZWFzZSgmc2NyaXB0KTsKLQkJCQlyZXR1cm4gLTE7Ci0JCQl9Ci0JCX0KLQotCQlpZiAoIWRlZm1zZykKLQkJCUJVRygicm9vdCBjb21taXQgd2l0aG91dCBtZXNzYWdlIik7Ci0KLQkJaWYgKCEoY2FjaGVfdHJlZV9vaWQgPSBnZXRfY2FjaGVfdHJlZV9vaWQoci0+aW5kZXgpKSkKLQkJCXJlcyA9IC0xOwotCi0JCWlmICghcmVzKQotCQkJcmVzID0gc3RyYnVmX3JlYWRfZmlsZSgmbXNnLCBkZWZtc2csIDApOwotCi0JCWlmIChyZXMgPD0gMCkKLQkJCXJlcyA9IGVycm9yX2Vycm5vKF8oImNvdWxkIG5vdCByZWFkICclcyciKSwgZGVmbXNnKTsKLQkJZWxzZQotCQkJcmVzID0gY29tbWl0X3RyZWUobXNnLmJ1ZiwgbXNnLmxlbiwgY2FjaGVfdHJlZV9vaWQsCi0JCQkJCSAgTlVMTCwgJnJvb3RfY29tbWl0LCBhdXRob3IsCi0JCQkJCSAgb3B0cy0+Z3BnX3NpZ24pOwotCi0JCXN0cmJ1Zl9yZWxlYXNlKCZtc2cpOwotCQlzdHJidWZfcmVsZWFzZSgmc2NyaXB0KTsKLQkJaWYgKCFyZXMpIHsKLQkJCXVwZGF0ZV9yZWYoTlVMTCwgIkNIRVJSWV9QSUNLX0hFQUQiLCAmcm9vdF9jb21taXQsIE5VTEwsCi0JCQkJICAgUkVGX05PX0RFUkVGLCBVUERBVEVfUkVGU19NU0dfT05fRVJSKTsKLQkJCXJlcyA9IHVwZGF0ZV9yZWYoTlVMTCwgIkhFQUQiLCAmcm9vdF9jb21taXQsIE5VTEwsIDAsCi0JCQkJCSBVUERBVEVfUkVGU19NU0dfT05fRVJSKTsKLQkJfQotCQlyZXR1cm4gcmVzIDwgMCA/IGVycm9yKF8oIndyaXRpbmcgcm9vdCBjb21taXQiKSkgOiAwOwotCX0KLQogCWNtZC5naXRfY21kID0gMTsKIAogCWlmIChpc19yZWJhc2VfaShvcHRzKSAmJiByZWFkX2Vudl9zY3JpcHQoJmNtZC5lbnZfYXJyYXkpKSB7CkBAIC0xMTk2LDI1ICsxMTI2LDIyIEBACiAJCQkJICAgICAgIHN0cnVjdCBzdHJidWYgKm1zZywKIAkJCQkgICAgICAgY29uc3QgY2hhciAqY29tbWl0KQogewotCXN0cnVjdCBhcmd2X2FycmF5IGhvb2tfZW52ID0gQVJHVl9BUlJBWV9JTklUOwotCWludCByZXQ7Ci0JY29uc3QgY2hhciAqbmFtZTsKKwlpbnQgcmV0ID0gMDsKKwljb25zdCBjaGFyICpuYW1lLCAqYXJnMSA9IE5VTEwsICphcmcyID0gTlVMTDsKIAogCW5hbWUgPSBnaXRfcGF0aF9jb21taXRfZWRpdG1zZygpOwogCWlmICh3cml0ZV9tZXNzYWdlKG1zZy0+YnVmLCBtc2ctPmxlbiwgbmFtZSwgMCkpCiAJCXJldHVybiAtMTsKIAotCWFyZ3ZfYXJyYXlfcHVzaGYoJmhvb2tfZW52LCAiR0lUX0lOREVYX0ZJTEU9JXMiLCByLT5pbmRleF9maWxlKTsKLQlhcmd2X2FycmF5X3B1c2goJmhvb2tfZW52LCAiR0lUX0VESVRPUj06Iik7Ci0JaWYgKGNvbW1pdCkKLQkJcmV0ID0gcnVuX2hvb2tfbGUoaG9va19lbnYuYXJndiwgInByZXBhcmUtY29tbWl0LW1zZyIsIG5hbWUsCi0JCQkJICAiY29tbWl0IiwgY29tbWl0LCBOVUxMKTsKLQllbHNlCi0JCXJldCA9IHJ1bl9ob29rX2xlKGhvb2tfZW52LmFyZ3YsICJwcmVwYXJlLWNvbW1pdC1tc2ciLCBuYW1lLAotCQkJCSAgIm1lc3NhZ2UiLCBOVUxMKTsKLQlpZiAocmV0KQorCWlmIChjb21taXQpIHsKKwkJYXJnMSA9ICJjb21taXQiOworCQlhcmcyID0gY29tbWl0OworCX0gZWxzZSB7CisJCWFyZzEgPSAibWVzc2FnZSI7CisJfQorCWlmIChydW5fY29tbWl0X2hvb2soMCwgci0+aW5kZXhfZmlsZSwgInByZXBhcmUtY29tbWl0LW1zZyIsIG5hbWUsCisJCQkgICAgYXJnMSwgYXJnMiwgTlVMTCkpCiAJCXJldCA9IGVycm9yKF8oIidwcmVwYXJlLWNvbW1pdC1tc2cnIGhvb2sgZmFpbGVkIikpOwotCWFyZ3ZfYXJyYXlfY2xlYXIoJmhvb2tfZW52KTsKIAogCXJldHVybiByZXQ7CiB9CkBAIC0xMzc4LDcgKzEzMDUsNyBAQAogCQkJIHN0cnVjdCBvYmplY3RfaWQgKm9pZCkKIHsKIAlzdHJ1Y3Qgb2JqZWN0X2lkIHRyZWU7Ci0Jc3RydWN0IGNvbW1pdCAqY3VycmVudF9oZWFkOworCXN0cnVjdCBjb21taXQgKmN1cnJlbnRfaGVhZCA9IE5VTEw7CiAJc3RydWN0IGNvbW1pdF9saXN0ICpwYXJlbnRzID0gTlVMTDsKIAlzdHJ1Y3QgY29tbWl0X2V4dHJhX2hlYWRlciAqZXh0cmEgPSBOVUxMOwogCXN0cnVjdCBzdHJidWYgZXJyID0gU1RSQlVGX0lOSVQ7CkBAIC0xNDEzLDcgKzEzNDAsOCBAQAogCQl9CiAJCXBhcmVudHMgPSBjb3B5X2NvbW1pdF9saXN0KGN1cnJlbnRfaGVhZC0+cGFyZW50cyk7CiAJCWV4dHJhID0gcmVhZF9jb21taXRfZXh0cmFfaGVhZGVycyhjdXJyZW50X2hlYWQsIGV4Y2x1ZGVfZ3Bnc2lnKTsKLQl9IGVsc2UgaWYgKGN1cnJlbnRfaGVhZCkgeworCX0gZWxzZSBpZiAoY3VycmVudF9oZWFkICYmCisJCSAgICghKGZsYWdzICYgQ1JFQVRFX1JPT1RfQ09NTUlUKSB8fCAoZmxhZ3MgJiBBTUVORF9NU0cpKSkgewogCQljb21taXRfbGlzdF9pbnNlcnQoY3VycmVudF9oZWFkLCAmcGFyZW50cyk7CiAJfQogCkBAIC0xNDIyLDExICsxMzUwLDI3IEBACiAJCWdvdG8gb3V0OwogCX0KIAotCWlmICghKGZsYWdzICYgQUxMT1dfRU1QVFkpICYmIG9pZGVxKGN1cnJlbnRfaGVhZCA/Ci0JCQkJCSAgICBnZXRfY29tbWl0X3RyZWVfb2lkKGN1cnJlbnRfaGVhZCkgOgotCQkJCQkgICAgdGhlX2hhc2hfYWxnby0+ZW1wdHlfdHJlZSwgJnRyZWUpKSB7Ci0JCXJlcyA9IDE7IC8qIHJ1biAnZ2l0IGNvbW1pdCcgdG8gZGlzcGxheSBlcnJvciBtZXNzYWdlICovCi0JCWdvdG8gb3V0OworCWlmICghKGZsYWdzICYgQUxMT1dfRU1QVFkpKSB7CisJCXN0cnVjdCBjb21taXQgKmZpcnN0X3BhcmVudCA9IGN1cnJlbnRfaGVhZDsKKworCQlpZiAoZmxhZ3MgJiBBTUVORF9NU0cpIHsKKwkJCWlmIChjdXJyZW50X2hlYWQtPnBhcmVudHMpIHsKKwkJCQlmaXJzdF9wYXJlbnQgPSBjdXJyZW50X2hlYWQtPnBhcmVudHMtPml0ZW07CisJCQkJaWYgKHJlcG9fcGFyc2VfY29tbWl0KHIsIGZpcnN0X3BhcmVudCkpIHsKKwkJCQkJcmVzID0gZXJyb3IoXygiY291bGQgbm90IHBhcnNlIEhFQUQgY29tbWl0IikpOworCQkJCQlnb3RvIG91dDsKKwkJCQl9CisJCQl9IGVsc2UgeworCQkJCWZpcnN0X3BhcmVudCA9IE5VTEw7CisJCQl9CisJCX0KKwkJaWYgKG9pZGVxKGZpcnN0X3BhcmVudAorCQkJICA/IGdldF9jb21taXRfdHJlZV9vaWQoZmlyc3RfcGFyZW50KQorCQkJICA6IHRoZV9oYXNoX2FsZ28tPmVtcHR5X3RyZWUsCisJCQkgICZ0cmVlKSkgeworCQkJcmVzID0gMTsgLyogcnVuICdnaXQgY29tbWl0JyB0byBkaXNwbGF5IGVycm9yIG1lc3NhZ2UgKi8KKwkJCWdvdG8gb3V0OworCQl9CiAJfQogCiAJaWYgKGZpbmRfaG9vaygicHJlcGFyZS1jb21taXQtbXNnIikpIHsKQEAgLTE0NzIsNiArMTQxNiw3IEBACiAJCWdvdG8gb3V0OwogCX0KIAorCXJ1bl9jb21taXRfaG9vaygwLCByLT5pbmRleF9maWxlLCAicG9zdC1jb21taXQiLCBOVUxMKTsKIAlpZiAoZmxhZ3MgJiBBTUVORF9NU0cpCiAJCWNvbW1pdF9wb3N0X3Jld3JpdGUociwgY3VycmVudF9oZWFkLCBvaWQpOwogCkBAIC0xNDkwLDggKzE0MzUsNyBAQAogewogCWludCByZXMgPSAxOwogCi0JaWYgKCEoZmxhZ3MgJiBFRElUX01TRykgJiYgIShmbGFncyAmIFZFUklGWV9NU0cpICYmCi0JICAgICEoZmxhZ3MgJiBDUkVBVEVfUk9PVF9DT01NSVQpKSB7CisJaWYgKCEoZmxhZ3MgJiBFRElUX01TRykgJiYgIShmbGFncyAmIFZFUklGWV9NU0cpKSB7CiAJCXN0cnVjdCBvYmplY3RfaWQgb2lkOwogCQlzdHJ1Y3Qgc3RyYnVmIHNiID0gU1RSQlVGX0lOSVQ7CiAKQEAgLTE2NDYsNiArMTU5MCw3IEBACiAJc3RydWN0IHN0cmJ1ZiBidWYgPSBTVFJCVUZfSU5JVDsKIAlpbnQgcmVzOwogCWNvbnN0IGNoYXIgKm1lc3NhZ2UsICpib2R5OworCWNvbnN0IGNoYXIgKmVuY29kaW5nID0gZ2V0X2NvbW1pdF9vdXRwdXRfZW5jb2RpbmcoKTsKIAogCWlmIChvcHRzLT5jdXJyZW50X2ZpeHVwX2NvdW50ID4gMCkgewogCQlzdHJ1Y3Qgc3RyYnVmIGhlYWRlciA9IFNUUkJVRl9JTklUOwpAQCAtMTY3Miw3ICsxNjE3LDcgQEAKIAkJCXJldHVybiBlcnJvcihfKCJuZWVkIGEgSEVBRCB0byBmaXh1cCIpKTsKIAkJaWYgKCEoaGVhZF9jb21taXQgPSBsb29rdXBfY29tbWl0X3JlZmVyZW5jZShyLCAmaGVhZCkpKQogCQkJcmV0dXJuIGVycm9yKF8oImNvdWxkIG5vdCByZWFkIEhFQUQiKSk7Ci0JCWlmICghKGhlYWRfbWVzc2FnZSA9IGdldF9jb21taXRfYnVmZmVyKGhlYWRfY29tbWl0LCBOVUxMKSkpCisJCWlmICghKGhlYWRfbWVzc2FnZSA9IGxvZ21zZ19yZWVuY29kZShoZWFkX2NvbW1pdCwgTlVMTCwgZW5jb2RpbmcpKSkKIAkJCXJldHVybiBlcnJvcihfKCJjb3VsZCBub3QgcmVhZCBIRUFEJ3MgY29tbWl0IG1lc3NhZ2UiKSk7CiAKIAkJZmluZF9jb21taXRfc3ViamVjdChoZWFkX21lc3NhZ2UsICZib2R5KTsKQEAgLTE2OTMsNyArMTYzOCw3IEBACiAJCXVudXNlX2NvbW1pdF9idWZmZXIoaGVhZF9jb21taXQsIGhlYWRfbWVzc2FnZSk7CiAJfQogCi0JaWYgKCEobWVzc2FnZSA9IGdldF9jb21taXRfYnVmZmVyKGNvbW1pdCwgTlVMTCkpKQorCWlmICghKG1lc3NhZ2UgPSBsb2dtc2dfcmVlbmNvZGUoY29tbWl0LCBOVUxMLCBlbmNvZGluZykpKQogCQlyZXR1cm4gZXJyb3IoXygiY291bGQgbm90IHJlYWQgY29tbWl0IG1lc3NhZ2Ugb2YgJXMiKSwKIAkJCSAgICAgb2lkX3RvX2hleCgmY29tbWl0LT5vYmplY3Qub2lkKSk7CiAJZmluZF9jb21taXRfc3ViamVjdChtZXNzYWdlLCAmYm9keSk7CkBAIC0xNzc1LDcgKzE3MjAsNyBAQAogCQkJICBlbnVtIHRvZG9fY29tbWFuZCBjb21tYW5kLAogCQkJICBzdHJ1Y3QgY29tbWl0ICpjb21taXQsCiAJCQkgIHN0cnVjdCByZXBsYXlfb3B0cyAqb3B0cywKLQkJCSAgaW50IGZpbmFsX2ZpeHVwKQorCQkJICBpbnQgZmluYWxfZml4dXAsIGludCAqY2hlY2tfdG9kbykKIHsKIAl1bnNpZ25lZCBpbnQgZmxhZ3MgPSBvcHRzLT5lZGl0ID8gRURJVF9NU0cgOiAwOwogCWNvbnN0IGNoYXIgKm1zZ19maWxlID0gb3B0cy0+ZWRpdCA/IE5VTEwgOiBnaXRfcGF0aF9tZXJnZV9tc2cocik7CkBAIC0xNzg1LDcgKzE3MzAsNyBAQAogCWNoYXIgKmF1dGhvciA9IE5VTEw7CiAJc3RydWN0IGNvbW1pdF9tZXNzYWdlIG1zZyA9IHsgTlVMTCwgTlVMTCwgTlVMTCwgTlVMTCB9OwogCXN0cnVjdCBzdHJidWYgbXNnYnVmID0gU1RSQlVGX0lOSVQ7Ci0JaW50IHJlcywgdW5ib3JuID0gMCwgYWxsb3c7CisJaW50IHJlcywgdW5ib3JuID0gMCwgcmV3b3JkID0gMCwgYWxsb3c7CiAKIAlpZiAob3B0cy0+bm9fY29tbWl0KSB7CiAJCS8qCkBAIC0xODU1LDcgKzE4MDAsNyBAQAogCQkJb3B0cyk7CiAJCWlmIChyZXMgfHwgY29tbWFuZCAhPSBUT0RPX1JFV09SRCkKIAkJCWdvdG8gbGVhdmU7Ci0JCWZsYWdzIHw9IEVESVRfTVNHIHwgQU1FTkRfTVNHIHwgVkVSSUZZX01TRzsKKwkJcmV3b3JkID0gMTsKIAkJbXNnX2ZpbGUgPSBOVUxMOwogCQlnb3RvIGZhc3RfZm9yd2FyZF9lZGl0OwogCX0KQEAgLTE5MTMsNyArMTg1OCw3IEBACiAJfQogCiAJaWYgKGNvbW1hbmQgPT0gVE9ET19SRVdPUkQpCi0JCWZsYWdzIHw9IEVESVRfTVNHIHwgVkVSSUZZX01TRzsKKwkJcmV3b3JkID0gMTsKIAllbHNlIGlmIChpc19maXh1cChjb21tYW5kKSkgewogCQlpZiAodXBkYXRlX3NxdWFzaF9tZXNzYWdlcyhyLCBjb21tYW5kLCBjb21taXQsIG9wdHMpKQogCQkJcmV0dXJuIC0xOwpAQCAtMTk5NywxMyArMTk0MiwyMSBAQAogCX0gZWxzZSBpZiAoYWxsb3cpCiAJCWZsYWdzIHw9IEFMTE9XX0VNUFRZOwogCWlmICghb3B0cy0+bm9fY29tbWl0KSB7Ci1mYXN0X2ZvcndhcmRfZWRpdDoKIAkJaWYgKGF1dGhvciB8fCBjb21tYW5kID09IFRPRE9fUkVWRVJUIHx8IChmbGFncyAmIEFNRU5EX01TRykpCiAJCQlyZXMgPSBkb19jb21taXQociwgbXNnX2ZpbGUsIGF1dGhvciwgb3B0cywgZmxhZ3MpOwogCQllbHNlCiAJCQlyZXMgPSBlcnJvcihfKCJ1bmFibGUgdG8gcGFyc2UgY29tbWl0IGF1dGhvciIpKTsKKwkJKmNoZWNrX3RvZG8gPSAhIShmbGFncyAmIEVESVRfTVNHKTsKKwkJaWYgKCFyZXMgJiYgcmV3b3JkKSB7CitmYXN0X2ZvcndhcmRfZWRpdDoKKwkJCXJlcyA9IHJ1bl9naXRfY29tbWl0KHIsIE5VTEwsIG9wdHMsIEVESVRfTVNHIHwKKwkJCQkJICAgICBWRVJJRllfTVNHIHwgQU1FTkRfTVNHIHwKKwkJCQkJICAgICAoZmxhZ3MgJiBBTExPV19FTVBUWSkpOworCQkJKmNoZWNrX3RvZG8gPSAxOworCQl9CiAJfQogCisKIAlpZiAoIXJlcyAmJiBmaW5hbF9maXh1cCkgewogCQl1bmxpbmsocmViYXNlX3BhdGhfZml4dXBfbXNnKCkpOwogCQl1bmxpbmsocmViYXNlX3BhdGhfc3F1YXNoX21zZygpKTsKQEAgLTI2MjYsMTQgKzI1NzksMTcgQEAKIAllbnVtIHRvZG9fY29tbWFuZCBjb21tYW5kID0gb3B0cy0+YWN0aW9uID09IFJFUExBWV9QSUNLID8KIAkJVE9ET19QSUNLIDogVE9ET19SRVZFUlQ7CiAJY29uc3QgY2hhciAqY29tbWFuZF9zdHJpbmcgPSB0b2RvX2NvbW1hbmRfaW5mb1tjb21tYW5kXS5zdHI7CisJY29uc3QgY2hhciAqZW5jb2Rpbmc7CiAJc3RydWN0IGNvbW1pdCAqY29tbWl0OwogCiAJaWYgKHByZXBhcmVfcmV2cyhvcHRzKSkKIAkJcmV0dXJuIC0xOwogCisJZW5jb2RpbmcgPSBnZXRfbG9nX291dHB1dF9lbmNvZGluZygpOworCiAJd2hpbGUgKChjb21taXQgPSBnZXRfcmV2aXNpb24ob3B0cy0+cmV2cykpKSB7CiAJCXN0cnVjdCB0b2RvX2l0ZW0gKml0ZW0gPSBhcHBlbmRfbmV3X3RvZG8odG9kb19saXN0KTsKLQkJY29uc3QgY2hhciAqY29tbWl0X2J1ZmZlciA9IGdldF9jb21taXRfYnVmZmVyKGNvbW1pdCwgTlVMTCk7CisJCWNvbnN0IGNoYXIgKmNvbW1pdF9idWZmZXIgPSBsb2dtc2dfcmVlbmNvZGUoY29tbWl0LCBOVUxMLCBlbmNvZGluZyk7CiAJCWNvbnN0IGNoYXIgKnN1YmplY3Q7CiAJCWludCBzdWJqZWN0X2xlbjsKIApAQCAtMzAzMCw3ICsyOTg2LDggQEAKIAogCXN0cmJ1Zl9hZGRmKCZidWYsICIlcy9tZXNzYWdlIiwgZ2V0X2RpcihvcHRzKSk7CiAJaWYgKCFmaWxlX2V4aXN0cyhidWYuYnVmKSkgewotCQljb25zdCBjaGFyICpjb21taXRfYnVmZmVyID0gZ2V0X2NvbW1pdF9idWZmZXIoY29tbWl0LCBOVUxMKTsKKwkJY29uc3QgY2hhciAqZW5jb2RpbmcgPSBnZXRfY29tbWl0X291dHB1dF9lbmNvZGluZygpOworCQljb25zdCBjaGFyICpjb21taXRfYnVmZmVyID0gbG9nbXNnX3JlZW5jb2RlKGNvbW1pdCwgTlVMTCwgZW5jb2RpbmcpOwogCQlmaW5kX2NvbW1pdF9zdWJqZWN0KGNvbW1pdF9idWZmZXIsICZzdWJqZWN0KTsKIAkJcmVzIHw9IHdyaXRlX21lc3NhZ2Uoc3ViamVjdCwgc3RybGVuKHN1YmplY3QpLCBidWYuYnVmLCAxKTsKIAkJdW51c2VfY29tbWl0X2J1ZmZlcihjb21taXQsIGNvbW1pdF9idWZmZXIpOwpAQCAtMzM2NCw2ICszMzIxLDkgQEAKIAlzdHJ1Y3QgY29tbWl0ICpoZWFkX2NvbW1pdCwgKm1lcmdlX2NvbW1pdCwgKmk7CiAJc3RydWN0IGNvbW1pdF9saXN0ICpiYXNlcywgKmosICpyZXZlcnNlZCA9IE5VTEw7CiAJc3RydWN0IGNvbW1pdF9saXN0ICp0b19tZXJnZSA9IE5VTEwsICoqdGFpbCA9ICZ0b19tZXJnZTsKKwljb25zdCBjaGFyICpzdHJhdGVneSA9ICFvcHRzLT54b3B0c19uciAmJgorCQkoIW9wdHMtPnN0cmF0ZWd5IHx8ICFzdHJjbXAob3B0cy0+c3RyYXRlZ3ksICJyZWN1cnNpdmUiKSkgPworCQlOVUxMIDogb3B0cy0+c3RyYXRlZ3k7CiAJc3RydWN0IG1lcmdlX29wdGlvbnMgbzsKIAlpbnQgbWVyZ2VfYXJnX2xlbiwgb25lbGluZV9vZmZzZXQsIGNhbl9mYXN0X2ZvcndhcmQsIHJldCwgazsKIAlzdGF0aWMgc3RydWN0IGxvY2tfZmlsZSBsb2NrOwpAQCAtMzQyOSw3ICszMzg5LDggQEAKIAl9CiAKIAlpZiAoY29tbWl0KSB7Ci0JCWNvbnN0IGNoYXIgKm1lc3NhZ2UgPSBnZXRfY29tbWl0X2J1ZmZlcihjb21taXQsIE5VTEwpOworCQljb25zdCBjaGFyICplbmNvZGluZyA9IGdldF9jb21taXRfb3V0cHV0X2VuY29kaW5nKCk7CisJCWNvbnN0IGNoYXIgKm1lc3NhZ2UgPSBsb2dtc2dfcmVlbmNvZGUoY29tbWl0LCBOVUxMLCBlbmNvZGluZyk7CiAJCWNvbnN0IGNoYXIgKmJvZHk7CiAJCWludCBsZW47CiAKQEAgLTM1MTYsNyArMzQ3Nyw3IEBACiAJCWdvdG8gbGVhdmVfbWVyZ2U7CiAJfQogCi0JaWYgKHRvX21lcmdlLT5uZXh0KSB7CisJaWYgKHN0cmF0ZWd5IHx8IHRvX21lcmdlLT5uZXh0KSB7CiAJCS8qIE9jdG9wdXMgbWVyZ2UgKi8KIAkJc3RydWN0IGNoaWxkX3Byb2Nlc3MgY21kID0gQ0hJTERfUFJPQ0VTU19JTklUOwogCkBAIC0zNTMwLDcgKzM0OTEsMTQgQEAKIAkJY21kLmdpdF9jbWQgPSAxOwogCQlhcmd2X2FycmF5X3B1c2goJmNtZC5hcmdzLCAibWVyZ2UiKTsKIAkJYXJndl9hcnJheV9wdXNoKCZjbWQuYXJncywgIi1zIik7Ci0JCWFyZ3ZfYXJyYXlfcHVzaCgmY21kLmFyZ3MsICJvY3RvcHVzIik7CisJCWlmICghc3RyYXRlZ3kpCisJCQlhcmd2X2FycmF5X3B1c2goJmNtZC5hcmdzLCAib2N0b3B1cyIpOworCQllbHNlIHsKKwkJCWFyZ3ZfYXJyYXlfcHVzaCgmY21kLmFyZ3MsIHN0cmF0ZWd5KTsKKwkJCWZvciAoayA9IDA7IGsgPCBvcHRzLT54b3B0c19ucjsgaysrKQorCQkJCWFyZ3ZfYXJyYXlfcHVzaGYoJmNtZC5hcmdzLAorCQkJCQkJICItWCVzIiwgb3B0cy0+eG9wdHNba10pOworCQl9CiAJCWFyZ3ZfYXJyYXlfcHVzaCgmY21kLmFyZ3MsICItLW5vLWVkaXQiKTsKIAkJYXJndl9hcnJheV9wdXNoKCZjbWQuYXJncywgIi0tbm8tZmYiKTsKIAkJYXJndl9hcnJheV9wdXNoKCZjbWQuYXJncywgIi0tbm8tbG9nIik7CkBAIC0zNTY4LDcgKzM1MzYsNyBAQAogCQlnb3RvIGxlYXZlX21lcmdlOwogCX0KIAotCXdyaXRlX21lc3NhZ2Uob2lkX3RvX2hleCgmbWVyZ2VfY29tbWl0LT5vYmplY3Qub2lkKSwgR0lUX1NIQTFfSEVYU1osCisJd3JpdGVfbWVzc2FnZShvaWRfdG9faGV4KCZtZXJnZV9jb21taXQtPm9iamVjdC5vaWQpLCB0aGVfaGFzaF9hbGdvLT5oZXhzeiwKIAkJICAgICAgZ2l0X3BhdGhfbWVyZ2VfaGVhZChyKSwgMCk7CiAJd3JpdGVfbWVzc2FnZSgibm8tZmYiLCA1LCBnaXRfcGF0aF9tZXJnZV9tb2RlKHIpLCAwKTsKIApAQCAtMzgxOCw2ICszNzg2LDcgQEAKIAl3aGlsZSAodG9kb19saXN0LT5jdXJyZW50IDwgdG9kb19saXN0LT5ucikgewogCQlzdHJ1Y3QgdG9kb19pdGVtICppdGVtID0gdG9kb19saXN0LT5pdGVtcyArIHRvZG9fbGlzdC0+Y3VycmVudDsKIAkJY29uc3QgY2hhciAqYXJnID0gdG9kb19pdGVtX2dldF9hcmcodG9kb19saXN0LCBpdGVtKTsKKwkJaW50IGNoZWNrX3RvZG8gPSAwOwogCiAJCWlmIChzYXZlX3RvZG8odG9kb19saXN0LCBvcHRzKSkKIAkJCXJldHVybiAtMTsKQEAgLTM4NTYsNyArMzgyNSw4IEBACiAJCQkJCWNvbW1hbmRfdG9fc3RyaW5nKGl0ZW0tPmNvbW1hbmQpLCBOVUxMKSwKIAkJCQkJMSk7CiAJCQlyZXMgPSBkb19waWNrX2NvbW1pdChyLCBpdGVtLT5jb21tYW5kLCBpdGVtLT5jb21taXQsCi0JCQkJCW9wdHMsIGlzX2ZpbmFsX2ZpeHVwKHRvZG9fbGlzdCkpOworCQkJCQkgICAgIG9wdHMsIGlzX2ZpbmFsX2ZpeHVwKHRvZG9fbGlzdCksCisJCQkJCSAgICAgJmNoZWNrX3RvZG8pOwogCQkJaWYgKGlzX3JlYmFzZV9pKG9wdHMpICYmIHJlcyA8IDApIHsKIAkJCQkvKiBSZXNjaGVkdWxlICovCiAJCQkJYWR2aXNlKF8ocmVzY2hlZHVsZWRfYWR2aWNlKSwKQEAgLTM5MTMsNyArMzg4Myw2IEBACiAJCX0gZWxzZSBpZiAoaXRlbS0+Y29tbWFuZCA9PSBUT0RPX0VYRUMpIHsKIAkJCWNoYXIgKmVuZF9vZl9hcmcgPSAoY2hhciAqKShhcmcgKyBpdGVtLT5hcmdfbGVuKTsKIAkJCWludCBzYXZlZCA9ICplbmRfb2ZfYXJnOwotCQkJc3RydWN0IHN0YXQgc3Q7CiAKIAkJCWlmICghb3B0cy0+dmVyYm9zZSkKIAkJCQl0ZXJtX2NsZWFyX2xpbmUoKTsKQEAgLTM5MjQsMTcgKzM4OTMsOCBAQAogCQkJaWYgKHJlcykgewogCQkJCWlmIChvcHRzLT5yZXNjaGVkdWxlX2ZhaWxlZF9leGVjKQogCQkJCQlyZXNjaGVkdWxlID0gMTsKLQkJCX0gZWxzZSBpZiAoc3RhdChnZXRfdG9kb19wYXRoKG9wdHMpLCAmc3QpKQotCQkJCXJlcyA9IGVycm9yX2Vycm5vKF8oImNvdWxkIG5vdCBzdGF0ICclcyciKSwKLQkJCQkJCSAgZ2V0X3RvZG9fcGF0aChvcHRzKSk7Ci0JCQllbHNlIGlmIChtYXRjaF9zdGF0X2RhdGEoJnRvZG9fbGlzdC0+c3RhdCwgJnN0KSkgewotCQkJCS8qIFJlcmVhZCB0aGUgdG9kbyBmaWxlIGlmIGl0IGhhcyBjaGFuZ2VkLiAqLwotCQkJCXRvZG9fbGlzdF9yZWxlYXNlKHRvZG9fbGlzdCk7Ci0JCQkJaWYgKHJlYWRfcG9wdWxhdGVfdG9kbyhyLCB0b2RvX2xpc3QsIG9wdHMpKQotCQkJCQlyZXMgPSAtMTsgLyogbWVzc2FnZSB3YXMgcHJpbnRlZCAqLwotCQkJCS8qIGBjdXJyZW50YCB3aWxsIGJlIGluY3JlbWVudGVkIGJlbG93ICovCi0JCQkJdG9kb19saXN0LT5jdXJyZW50ID0gLTE7CiAJCQl9CisJCQljaGVja190b2RvID0gMTsKIAkJfSBlbHNlIGlmIChpdGVtLT5jb21tYW5kID09IFRPRE9fTEFCRUwpIHsKIAkJCWlmICgocmVzID0gZG9fbGFiZWwociwgYXJnLCBpdGVtLT5hcmdfbGVuKSkpCiAJCQkJcmVzY2hlZHVsZSA9IDE7CkBAIC0zOTcwLDYgKzM5MzAsMjAgQEAKIAkJCQkJCQlpdGVtLT5jb21taXQsCiAJCQkJCQkJYXJnLCBpdGVtLT5hcmdfbGVuLAogCQkJCQkJCW9wdHMsIHJlcywgMCk7CisJCX0gZWxzZSBpZiAoY2hlY2tfdG9kbyAmJiAhcmVzKSB7CisJCQlzdHJ1Y3Qgc3RhdCBzdDsKKworCQkJaWYgKHN0YXQoZ2V0X3RvZG9fcGF0aChvcHRzKSwgJnN0KSkgeworCQkJCXJlcyA9IGVycm9yX2Vycm5vKF8oImNvdWxkIG5vdCBzdGF0ICclcyciKSwKKwkJCQkJCSAgZ2V0X3RvZG9fcGF0aChvcHRzKSk7CisJCQl9IGVsc2UgaWYgKG1hdGNoX3N0YXRfZGF0YSgmdG9kb19saXN0LT5zdGF0LCAmc3QpKSB7CisJCQkJLyogUmVyZWFkIHRoZSB0b2RvIGZpbGUgaWYgaXQgaGFzIGNoYW5nZWQuICovCisJCQkJdG9kb19saXN0X3JlbGVhc2UodG9kb19saXN0KTsKKwkJCQlpZiAocmVhZF9wb3B1bGF0ZV90b2RvKHIsIHRvZG9fbGlzdCwgb3B0cykpCisJCQkJCXJlcyA9IC0xOyAvKiBtZXNzYWdlIHdhcyBwcmludGVkICovCisJCQkJLyogYGN1cnJlbnRgIHdpbGwgYmUgaW5jcmVtZW50ZWQgYmVsb3cgKi8KKwkJCQl0b2RvX2xpc3QtPmN1cnJlbnQgPSAtMTsKKwkJCX0KIAkJfQogCiAJCXRvZG9fbGlzdC0+Y3VycmVudCsrOwpAQCAtNDE5Nyw5ICs0MTcxLDEwIEBACiAJCQkJICovCiAJCQkJc3RydWN0IGNvbW1pdCAqY29tbWl0OwogCQkJCWNvbnN0IGNoYXIgKnBhdGggPSByZWJhc2VfcGF0aF9zcXVhc2hfbXNnKCk7CisJCQkJY29uc3QgY2hhciAqZW5jb2RpbmcgPSBnZXRfY29tbWl0X291dHB1dF9lbmNvZGluZygpOwogCiAJCQkJaWYgKHBhcnNlX2hlYWQociwgJmNvbW1pdCkgfHwKLQkJCQkgICAgIShwID0gZ2V0X2NvbW1pdF9idWZmZXIoY29tbWl0LCBOVUxMKSkgfHwKKwkJCQkgICAgIShwID0gbG9nbXNnX3JlZW5jb2RlKGNvbW1pdCwgTlVMTCwgZW5jb2RpbmcpKSB8fAogCQkJCSAgICB3cml0ZV9tZXNzYWdlKHAsIHN0cmxlbihwKSwgcGF0aCwgMCkpIHsKIAkJCQkJdW51c2VfY29tbWl0X2J1ZmZlcihjb21taXQsIHApOwogCQkJCQlyZXR1cm4gZXJyb3IoXygiY291bGQgbm90IHdyaXRlIGZpbGU6ICIKQEAgLTQyOTYsOSArNDI3MSwxMiBAQAogCQkgICAgICAgc3RydWN0IGNvbW1pdCAqY21pdCwKIAkJICAgICAgIHN0cnVjdCByZXBsYXlfb3B0cyAqb3B0cykKIHsKKwlpbnQgY2hlY2tfdG9kbzsKKwogCXNldGVudihHSVRfUkVGTE9HX0FDVElPTiwgYWN0aW9uX25hbWUob3B0cyksIDApOwogCXJldHVybiBkb19waWNrX2NvbW1pdChyLCBvcHRzLT5hY3Rpb24gPT0gUkVQTEFZX1BJQ0sgPwotCQlUT0RPX1BJQ0sgOiBUT0RPX1JFVkVSVCwgY21pdCwgb3B0cywgMCk7CisJCQkgICAgICBUT0RPX1BJQ0sgOiBUT0RPX1JFVkVSVCwgY21pdCwgb3B0cywgMCwKKwkJCSAgICAgICZjaGVja190b2RvKTsKIH0KIAogaW50IHNlcXVlbmNlcl9waWNrX3JldmlzaW9ucyhzdHJ1Y3QgcmVwb3NpdG9yeSAqciwKQEAgLTQ0NDAsOSArNDQxOCwxNCBAQAogCWNoYXIgbGFiZWxbRkxFWF9BUlJBWV07CiB9OwogCi1zdGF0aWMgaW50IGxhYmVsc19jbXAoY29uc3Qgdm9pZCAqZm5kYXRhLCBjb25zdCBzdHJ1Y3QgbGFiZWxzX2VudHJ5ICphLAotCQkgICAgICBjb25zdCBzdHJ1Y3QgbGFiZWxzX2VudHJ5ICpiLCBjb25zdCB2b2lkICprZXkpCitzdGF0aWMgaW50IGxhYmVsc19jbXAoY29uc3Qgdm9pZCAqZm5kYXRhLCBjb25zdCBzdHJ1Y3QgaGFzaG1hcF9lbnRyeSAqZXB0ciwKKwkJICAgICAgY29uc3Qgc3RydWN0IGhhc2htYXBfZW50cnkgKmVudHJ5X29yX2tleSwgY29uc3Qgdm9pZCAqa2V5KQogeworCWNvbnN0IHN0cnVjdCBsYWJlbHNfZW50cnkgKmEsICpiOworCisJYSA9IGNvbnRhaW5lcl9vZihlcHRyLCBjb25zdCBzdHJ1Y3QgbGFiZWxzX2VudHJ5LCBlbnRyeSk7CisJYiA9IGNvbnRhaW5lcl9vZihlbnRyeV9vcl9rZXksIGNvbnN0IHN0cnVjdCBsYWJlbHNfZW50cnksIGVudHJ5KTsKKwogCXJldHVybiBrZXkgPyBzdHJjbXAoYS0+bGFiZWwsIGtleSkgOiBzdHJjbXAoYS0+bGFiZWwsIGItPmxhYmVsKTsKIH0KIApAQCAtNDQ2Myw3ICs0NDQ2LDYgQEAKIAlzdHJ1Y3QgbGFiZWxzX2VudHJ5ICpsYWJlbHNfZW50cnk7CiAJc3RydWN0IHN0cmluZ19lbnRyeSAqc3RyaW5nX2VudHJ5OwogCXN0cnVjdCBvYmplY3RfaWQgZHVtbXk7Ci0Jc2l6ZV90IGxlbjsKIAlpbnQgaTsKIAogCXN0cmluZ19lbnRyeSA9IG9pZG1hcF9nZXQoJnN0YXRlLT5jb21taXQybGFiZWwsIG9pZCk7CkBAIC00NDgzLDExICs0NDY1LDExIEBACiAJICogYWJicmV2aWF0aW9uIGZvciBhbnkgdW5pbnRlcmVzdGluZyBjb21taXQncyBuYW1lcyB0aGF0IGRvZXMgbm90CiAJICogY2xhc2ggd2l0aCBhbnkgb3RoZXIgbGFiZWwuCiAJICovCisJc3RyYnVmX3Jlc2V0KCZzdGF0ZS0+YnVmKTsKIAlpZiAoIWxhYmVsKSB7CiAJCWNoYXIgKnA7CiAKLQkJc3RyYnVmX3Jlc2V0KCZzdGF0ZS0+YnVmKTsKLQkJc3RyYnVmX2dyb3coJnN0YXRlLT5idWYsIEdJVF9TSEExX0hFWFNaKTsKKwkJc3RyYnVmX2dyb3coJnN0YXRlLT5idWYsIEdJVF9NQVhfSEVYU1opOwogCQlsYWJlbCA9IHAgPSBzdGF0ZS0+YnVmLmJ1ZjsKIAogCQlmaW5kX3VuaXF1ZV9hYmJyZXZfcihwLCBvaWQsIGRlZmF1bHRfYWJicmV2KTsKQEAgLTQ1MDAsNyArNDQ4Miw3IEBACiAJCQlzaXplX3QgaSA9IHN0cmxlbihwKSArIDE7CiAKIAkJCW9pZF90b19oZXhfcihwLCBvaWQpOwotCQkJZm9yICg7IGkgPCBHSVRfU0hBMV9IRVhTWjsgaSsrKSB7CisJCQlmb3IgKDsgaSA8IHRoZV9oYXNoX2FsZ28tPmhleHN6OyBpKyspIHsKIAkJCQljaGFyIHNhdmUgPSBwW2ldOwogCQkJCXBbaV0gPSAnXDAnOwogCQkJCWlmICghaGFzaG1hcF9nZXRfZnJvbV9oYXNoKCZzdGF0ZS0+bGFiZWxzLApAQCAtNDUwOSwzNyArNDQ5MSw2MCBAQAogCQkJCXBbaV0gPSBzYXZlOwogCQkJfQogCQl9Ci0JfSBlbHNlIGlmICgoKGxlbiA9IHN0cmxlbihsYWJlbCkpID09IHRoZV9oYXNoX2FsZ28tPmhleHN6ICYmCi0JCSAgICAhZ2V0X29pZF9oZXgobGFiZWwsICZkdW1teSkpIHx8Ci0JCSAgIChsZW4gPT0gMSAmJiAqbGFiZWwgPT0gJyMnKSB8fAotCQkgICBoYXNobWFwX2dldF9mcm9tX2hhc2goJnN0YXRlLT5sYWJlbHMsCi0JCQkJCSBzdHJpaGFzaChsYWJlbCksIGxhYmVsKSkgewotCQkvKgotCQkgKiBJZiB0aGUgbGFiZWwgYWxyZWFkeSBleGlzdHMsIG9yIGlmIHRoZSBsYWJlbCBpcyBhIHZhbGlkIGZ1bGwKLQkJICogT0lELCBvciB0aGUgbGFiZWwgaXMgYSAnIycgKHdoaWNoIHdlIHVzZSBhcyBhIHNlcGFyYXRvcgotCQkgKiBiZXR3ZWVuIG1lcmdlIGhlYWRzIGFuZCBvbmVsaW5lKSwgd2UgYXBwZW5kIGEgZGFzaCBhbmQgYQotCQkgKiBudW1iZXIgdG8gbWFrZSBpdCB1bmlxdWUuCi0JCSAqLworCX0gZWxzZSB7CiAJCXN0cnVjdCBzdHJidWYgKmJ1ZiA9ICZzdGF0ZS0+YnVmOwogCi0JCXN0cmJ1Zl9yZXNldChidWYpOwotCQlzdHJidWZfYWRkKGJ1ZiwgbGFiZWwsIGxlbik7Ci0KLQkJZm9yIChpID0gMjsgOyBpKyspIHsKLQkJCXN0cmJ1Zl9zZXRsZW4oYnVmLCBsZW4pOwotCQkJc3RyYnVmX2FkZGYoYnVmLCAiLSVkIiwgaSk7Ci0JCQlpZiAoIWhhc2htYXBfZ2V0X2Zyb21faGFzaCgmc3RhdGUtPmxhYmVscywKLQkJCQkJCSAgIHN0cmloYXNoKGJ1Zi0+YnVmKSwKLQkJCQkJCSAgIGJ1Zi0+YnVmKSkKLQkJCQlicmVhazsKKwkJLyoKKwkJICogU2FuaXRpemUgbGFiZWxzIGJ5IHJlcGxhY2luZyBub24tYWxwaGEtbnVtZXJpYyBjaGFyYWN0ZXJzCisJCSAqIChpbmNsdWRpbmcgd2hpdGUtc3BhY2Ugb25lcykgYnkgZGFzaGVzLCBhcyB0aGV5IG1pZ2h0IGJlCisJCSAqIGlsbGVnYWwgaW4gZmlsZSBuYW1lcyAoYW5kIGhlbmNlIGluIHJlZiBuYW1lcykuCisJCSAqCisJCSAqIE5vdGUgdGhhdCB3ZSByZXRhaW4gbm9uLUFTQ0lJIFVURi04IGNoYXJhY3RlcnMgKGlkZW50aWZpZWQKKwkJICogdmlhIHRoZSBtb3N0IHNpZ25pZmljYW50IGJpdCkuIFRoZXkgc2hvdWxkIGJlIGFsbCBhY2NlcHRhYmxlCisJCSAqIGluIGZpbGUgbmFtZXMuIFdlIGRvIG5vdCB2YWxpZGF0ZSB0aGUgVVRGLTggaGVyZSwgdGhhdCdzIG5vdAorCQkgKiB0aGUgam9iIG9mIHRoaXMgZnVuY3Rpb24uCisJCSAqLworCQlmb3IgKDsgKmxhYmVsOyBsYWJlbCsrKQorCQkJaWYgKCgqbGFiZWwgJiAweDgwKSB8fCBpc2FsbnVtKCpsYWJlbCkpCisJCQkJc3RyYnVmX2FkZGNoKGJ1ZiwgKmxhYmVsKTsKKwkJCS8qIGF2b2lkIGxlYWRpbmcgZGFzaCBhbmQgZG91YmxlLWRhc2hlcyAqLworCQkJZWxzZSBpZiAoYnVmLT5sZW4gJiYgYnVmLT5idWZbYnVmLT5sZW4gLSAxXSAhPSAnLScpCisJCQkJc3RyYnVmX2FkZGNoKGJ1ZiwgJy0nKTsKKwkJaWYgKCFidWYtPmxlbikgeworCQkJc3RyYnVmX2FkZHN0cihidWYsICJyZXYtIik7CisJCQlzdHJidWZfYWRkX3VuaXF1ZV9hYmJyZXYoYnVmLCBvaWQsIGRlZmF1bHRfYWJicmV2KTsKIAkJfQotCiAJCWxhYmVsID0gYnVmLT5idWY7CisKKwkJaWYgKChidWYtPmxlbiA9PSB0aGVfaGFzaF9hbGdvLT5oZXhzeiAmJgorCQkgICAgICFnZXRfb2lkX2hleChsYWJlbCwgJmR1bW15KSkgfHwKKwkJICAgIChidWYtPmxlbiA9PSAxICYmICpsYWJlbCA9PSAnIycpIHx8CisJCSAgICBoYXNobWFwX2dldF9mcm9tX2hhc2goJnN0YXRlLT5sYWJlbHMsCisJCQkJCSAgc3RyaWhhc2gobGFiZWwpLCBsYWJlbCkpIHsKKwkJCS8qCisJCQkgKiBJZiB0aGUgbGFiZWwgYWxyZWFkeSBleGlzdHMsIG9yIGlmIHRoZSBsYWJlbCBpcyBhCisJCQkgKiB2YWxpZCBmdWxsIE9JRCwgb3IgdGhlIGxhYmVsIGlzIGEgJyMnICh3aGljaCB3ZSB1c2UKKwkJCSAqIGFzIGEgc2VwYXJhdG9yIGJldHdlZW4gbWVyZ2UgaGVhZHMgYW5kIG9uZWxpbmUpLCB3ZQorCQkJICogYXBwZW5kIGEgZGFzaCBhbmQgYSBudW1iZXIgdG8gbWFrZSBpdCB1bmlxdWUuCisJCQkgKi8KKwkJCXNpemVfdCBsZW4gPSBidWYtPmxlbjsKKworCQkJZm9yIChpID0gMjsgOyBpKyspIHsKKwkJCQlzdHJidWZfc2V0bGVuKGJ1ZiwgbGVuKTsKKwkJCQlzdHJidWZfYWRkZihidWYsICItJWQiLCBpKTsKKwkJCQlpZiAoIWhhc2htYXBfZ2V0X2Zyb21faGFzaCgmc3RhdGUtPmxhYmVscywKKwkJCQkJCQkgICBzdHJpaGFzaChidWYtPmJ1ZiksCisJCQkJCQkJICAgYnVmLT5idWYpKQorCQkJCQlicmVhazsKKwkJCX0KKworCQkJbGFiZWwgPSBidWYtPmJ1ZjsKKwkJfQogCX0KIAogCUZMRVhfQUxMT0NfU1RSKGxhYmVsc19lbnRyeSwgbGFiZWwsIGxhYmVsKTsKLQloYXNobWFwX2VudHJ5X2luaXQobGFiZWxzX2VudHJ5LCBzdHJpaGFzaChsYWJlbCkpOwotCWhhc2htYXBfYWRkKCZzdGF0ZS0+bGFiZWxzLCBsYWJlbHNfZW50cnkpOworCWhhc2htYXBfZW50cnlfaW5pdCgmbGFiZWxzX2VudHJ5LT5lbnRyeSwgc3RyaWhhc2gobGFiZWwpKTsKKwloYXNobWFwX2FkZCgmc3RhdGUtPmxhYmVscywgJmxhYmVsc19lbnRyeS0+ZW50cnkpOwogCiAJRkxFWF9BTExPQ19TVFIoc3RyaW5nX2VudHJ5LCBzdHJpbmcsIGxhYmVsKTsKIAlvaWRjcHkoJnN0cmluZ19lbnRyeS0+ZW50cnkub2lkLCBvaWQpOwpAQCAtNDU1NCw2ICs0NTU5LDcgQEAKIHsKIAlpbnQga2VlcF9lbXB0eSA9IGZsYWdzICYgVE9ET19MSVNUX0tFRVBfRU1QVFk7CiAJaW50IHJlYmFzZV9jb3VzaW5zID0gZmxhZ3MgJiBUT0RPX0xJU1RfUkVCQVNFX0NPVVNJTlM7CisJaW50IHJvb3Rfd2l0aF9vbnRvID0gZmxhZ3MgJiBUT0RPX0xJU1RfUk9PVF9XSVRIX09OVE87CiAJc3RydWN0IHN0cmJ1ZiBidWYgPSBTVFJCVUZfSU5JVCwgb25lbGluZSA9IFNUUkJVRl9JTklUOwogCXN0cnVjdCBzdHJidWYgbGFiZWwgPSBTVFJCVUZfSU5JVDsKIAlzdHJ1Y3QgY29tbWl0X2xpc3QgKmNvbW1pdHMgPSBOVUxMLCAqKnRhaWwgPSAmY29tbWl0cywgKml0ZXI7CkBAIC00NTczLDE0ICs0NTc5LDE5IEBACiAKIAlvaWRtYXBfaW5pdCgmY29tbWl0MnRvZG8sIDApOwogCW9pZG1hcF9pbml0KCZzdGF0ZS5jb21taXQybGFiZWwsIDApOwotCWhhc2htYXBfaW5pdCgmc3RhdGUubGFiZWxzLCAoaGFzaG1hcF9jbXBfZm4pIGxhYmVsc19jbXAsIE5VTEwsIDApOworCWhhc2htYXBfaW5pdCgmc3RhdGUubGFiZWxzLCBsYWJlbHNfY21wLCBOVUxMLCAwKTsKIAlzdHJidWZfaW5pdCgmc3RhdGUuYnVmLCAzMik7CiAKIAlpZiAocmV2cy0+Y21kbGluZS5uciAmJiAocmV2cy0+Y21kbGluZS5yZXZbMF0uZmxhZ3MgJiBCT1RUT00pKSB7CisJCXN0cnVjdCBsYWJlbHNfZW50cnkgKm9udG9fbGFiZWxfZW50cnk7CiAJCXN0cnVjdCBvYmplY3RfaWQgKm9pZCA9ICZyZXZzLT5jbWRsaW5lLnJldlswXS5pdGVtLT5vaWQ7CiAJCUZMRVhfQUxMT0NfU1RSKGVudHJ5LCBzdHJpbmcsICJvbnRvIik7CiAJCW9pZGNweSgmZW50cnktPmVudHJ5Lm9pZCwgb2lkKTsKIAkJb2lkbWFwX3B1dCgmc3RhdGUuY29tbWl0MmxhYmVsLCBlbnRyeSk7CisKKwkJRkxFWF9BTExPQ19TVFIob250b19sYWJlbF9lbnRyeSwgbGFiZWwsICJvbnRvIik7CisJCWhhc2htYXBfZW50cnlfaW5pdCgmb250b19sYWJlbF9lbnRyeS0+ZW50cnksIHN0cmloYXNoKCJvbnRvIikpOworCQloYXNobWFwX2FkZCgmc3RhdGUubGFiZWxzLCAmb250b19sYWJlbF9lbnRyeS0+ZW50cnkpOwogCX0KIAogCS8qCkBAIC00NjM1LDEwICs0NjQ2LDYgQEAKIAkJZWxzZQogCQkJc3RyYnVmX2FkZGJ1ZigmbGFiZWwsICZvbmVsaW5lKTsKIAotCQlmb3IgKHAxID0gbGFiZWwuYnVmOyAqcDE7IHAxKyspCi0JCQlpZiAoaXNzcGFjZSgqcDEpKQotCQkJCSooY2hhciAqKXAxID0gJy0nOwotCiAJCXN0cmJ1Zl9yZXNldCgmYnVmKTsKIAkJc3RyYnVmX2FkZGYoJmJ1ZiwgIiVzIC1DICVzIiwKIAkJCSAgICBjbWRfbWVyZ2UsIG9pZF90b19oZXgoJmNvbW1pdC0+b2JqZWN0Lm9pZCkpOwpAQCAtNDY4MSw3ICs0Njg4LDcgQEAKIAkJCQlsYWJlbF9vaWQob2lkLCAiYnJhbmNoLXBvaW50IiwgJnN0YXRlKTsKIAkJfQogCi0JCS8qIEFkZCBIRUFEIGFzIGltcGxpY3QgInRpcCBvZiBicmFuY2giICovCisJCS8qIEFkZCBIRUFEIGFzIGltcGxpY2l0ICJ0aXAgb2YgYnJhbmNoIiAqLwogCQlpZiAoIWl0ZXItPm5leHQpCiAJCQl0aXBzX3RhaWwgPSAmY29tbWl0X2xpc3RfaW5zZXJ0KGl0ZXItPml0ZW0sCiAJCQkJCQkJdGlwc190YWlsKS0+bmV4dDsKQEAgLTQ3MjAsNyArNDcyNyw4IEBACiAKIAkJaWYgKCFjb21taXQpCiAJCQlzdHJidWZfYWRkZihvdXQsICIlcyAlc1xuIiwgY21kX3Jlc2V0LAotCQkJCSAgICByZWJhc2VfY291c2lucyA/ICJvbnRvIiA6ICJbbmV3IHJvb3RdIik7CisJCQkJICAgIHJlYmFzZV9jb3VzaW5zIHx8IHJvb3Rfd2l0aF9vbnRvID8KKwkJCQkgICAgIm9udG8iIDogIltuZXcgcm9vdF0iKTsKIAkJZWxzZSB7CiAJCQljb25zdCBjaGFyICp0byA9IE5VTEw7CiAKQEAgLTQ3NjcsNyArNDc3NSw3IEBACiAKIAlvaWRtYXBfZnJlZSgmY29tbWl0MnRvZG8sIDEpOwogCW9pZG1hcF9mcmVlKCZzdGF0ZS5jb21taXQybGFiZWwsIDEpOwotCWhhc2htYXBfZnJlZSgmc3RhdGUubGFiZWxzLCAxKTsKKwloYXNobWFwX2ZyZWVfZW50cmllcygmc3RhdGUubGFiZWxzLCBzdHJ1Y3QgbGFiZWxzX2VudHJ5LCBlbnRyeSk7CiAJc3RyYnVmX3JlbGVhc2UoJnN0YXRlLmJ1Zik7CiAKIAlyZXR1cm4gMDsKQEAgLTQ4NjIsNyArNDg3MCw3IEBACiAJICogYXJlIGNvbnNpZGVyZWQgcGFydCBvZiB0aGUgcGljaywgc28gd2UgaW5zZXJ0IHRoZSBjb21tYW5kcyAqYWZ0ZXIqCiAJICogdGhvc2UgY2hhaW5zIGlmIHRoZXJlIGFyZSBhbnkuCiAJICoKLQkgKiBBcyB3ZSBpbnNlcnQgdGhlIGV4ZWMgY29tbWFuZHMgaW1tZWRpYXRseSBhZnRlciByZWFycmFuZ2luZworCSAqIEFzIHdlIGluc2VydCB0aGUgZXhlYyBjb21tYW5kcyBpbW1lZGlhdGVseSBhZnRlciByZWFycmFuZ2luZwogCSAqIGFueSBmaXh1cHMgYW5kIGJlZm9yZSB0aGUgdXNlciBlZGl0cyB0aGUgbGlzdCwgYSBmaXh1cCBjaGFpbgogCSAqIGNhbiBuZXZlciBjb250YWluIGNvbW1lbnRzIChhbnkgY29tbWVudHMgYXJlIGVtcHR5IHBpY2tzIHRoYXQKIAkgKiBoYXZlIGJlZW4gY29tbWVudGVkIG91dCBiZWNhdXNlIHRoZSB1c2VyIGRpZCBub3Qgc3BlY2lmeQpAQCAtNTEzOCw5ICs1MTQ2LDE1IEBACiB9OwogCiBzdGF0aWMgaW50IHN1YmplY3QyaXRlbV9jbXAoY29uc3Qgdm9pZCAqZm5kYXRhLAotCQkJICAgIGNvbnN0IHN0cnVjdCBzdWJqZWN0Mml0ZW1fZW50cnkgKmEsCi0JCQkgICAgY29uc3Qgc3RydWN0IHN1YmplY3QyaXRlbV9lbnRyeSAqYiwgY29uc3Qgdm9pZCAqa2V5KQorCQkJICAgIGNvbnN0IHN0cnVjdCBoYXNobWFwX2VudHJ5ICplcHRyLAorCQkJICAgIGNvbnN0IHN0cnVjdCBoYXNobWFwX2VudHJ5ICplbnRyeV9vcl9rZXksCisJCQkgICAgY29uc3Qgdm9pZCAqa2V5KQogeworCWNvbnN0IHN0cnVjdCBzdWJqZWN0Mml0ZW1fZW50cnkgKmEsICpiOworCisJYSA9IGNvbnRhaW5lcl9vZihlcHRyLCBjb25zdCBzdHJ1Y3Qgc3ViamVjdDJpdGVtX2VudHJ5LCBlbnRyeSk7CisJYiA9IGNvbnRhaW5lcl9vZihlbnRyeV9vcl9rZXksIGNvbnN0IHN0cnVjdCBzdWJqZWN0Mml0ZW1fZW50cnksIGVudHJ5KTsKKwogCXJldHVybiBrZXkgPyBzdHJjbXAoYS0+c3ViamVjdCwga2V5KSA6IHN0cmNtcChhLT5zdWJqZWN0LCBiLT5zdWJqZWN0KTsKIH0KIApAQCAtNTE3Myw4ICs1MTg3LDcgQEAKIAkgKiBJbiB0aGF0IGNhc2UsIGxhc3RbaV0gd2lsbCBpbmRpY2F0ZSB0aGUgaW5kZXggb2YgdGhlIGxhdGVzdCBpdGVtIHRvCiAJICogYmUgbW92ZWQgdG8gYXBwZWFyIGFmdGVyIHRoZSBpJ3RoLgogCSAqLwotCWhhc2htYXBfaW5pdCgmc3ViamVjdDJpdGVtLCAoaGFzaG1hcF9jbXBfZm4pIHN1YmplY3QyaXRlbV9jbXAsCi0JCSAgICAgTlVMTCwgdG9kb19saXN0LT5ucik7CisJaGFzaG1hcF9pbml0KCZzdWJqZWN0Mml0ZW0sIHN1YmplY3QyaXRlbV9jbXAsIE5VTEwsIHRvZG9fbGlzdC0+bnIpOwogCUFMTE9DX0FSUkFZKG5leHQsIHRvZG9fbGlzdC0+bnIpOwogCUFMTE9DX0FSUkFZKHRhaWwsIHRvZG9fbGlzdC0+bnIpOwogCUFMTE9DX0FSUkFZKHN1YmplY3RzLCB0b2RvX2xpc3QtPm5yKTsKQEAgLTUyMDAsNyArNTIxMyw3IEBACiAJCSpjb21taXRfdG9kb19pdGVtX2F0KCZjb21taXRfdG9kbywgaXRlbS0+Y29tbWl0KSA9IGl0ZW07CiAKIAkJcGFyc2VfY29tbWl0KGl0ZW0tPmNvbW1pdCk7Ci0JCWNvbW1pdF9idWZmZXIgPSBnZXRfY29tbWl0X2J1ZmZlcihpdGVtLT5jb21taXQsIE5VTEwpOworCQljb21taXRfYnVmZmVyID0gbG9nbXNnX3JlZW5jb2RlKGl0ZW0tPmNvbW1pdCwgTlVMTCwgIlVURi04Iik7CiAJCWZpbmRfY29tbWl0X3N1YmplY3QoY29tbWl0X2J1ZmZlciwgJnN1YmplY3QpOwogCQlmb3JtYXRfc3ViamVjdCgmYnVmLCBzdWJqZWN0LCAiICIpOwogCQlzdWJqZWN0ID0gc3ViamVjdHNbaV0gPSBzdHJidWZfZGV0YWNoKCZidWYsICZzdWJqZWN0X2xlbik7CkBAIC01MjE3LDggKzUyMzAsMTEgQEAKIAkJCQkJYnJlYWs7CiAJCQl9CiAKLQkJCWlmICgoZW50cnkgPSBoYXNobWFwX2dldF9mcm9tX2hhc2goJnN1YmplY3QyaXRlbSwKLQkJCQkJCQkgICBzdHJoYXNoKHApLCBwKSkpCisJCQllbnRyeSA9IGhhc2htYXBfZ2V0X2VudHJ5X2Zyb21faGFzaCgmc3ViamVjdDJpdGVtLAorCQkJCQkJc3RyaGFzaChwKSwgcCwKKwkJCQkJCXN0cnVjdCBzdWJqZWN0Mml0ZW1fZW50cnksCisJCQkJCQllbnRyeSk7CisJCQlpZiAoZW50cnkpCiAJCQkJLyogZm91bmQgYnkgdGl0bGUgKi8KIAkJCQlpMiA9IGVudHJ5LT5pOwogCQkJZWxzZSBpZiAoIXN0cmNocihwLCAnICcpICYmCkBAIC01MjUyLDggKzUyNjgsOSBAQAogCQkJCQkJc3RyaGFzaChzdWJqZWN0KSwgc3ViamVjdCkpIHsKIAkJCUZMRVhfQUxMT0NfTUVNKGVudHJ5LCBzdWJqZWN0LCBzdWJqZWN0LCBzdWJqZWN0X2xlbik7CiAJCQllbnRyeS0+aSA9IGk7Ci0JCQloYXNobWFwX2VudHJ5X2luaXQoZW50cnksIHN0cmhhc2goZW50cnktPnN1YmplY3QpKTsKLQkJCWhhc2htYXBfcHV0KCZzdWJqZWN0Mml0ZW0sIGVudHJ5KTsKKwkJCWhhc2htYXBfZW50cnlfaW5pdCgmZW50cnktPmVudHJ5LAorCQkJCQlzdHJoYXNoKGVudHJ5LT5zdWJqZWN0KSk7CisJCQloYXNobWFwX3B1dCgmc3ViamVjdDJpdGVtLCAmZW50cnktPmVudHJ5KTsKIAkJfQogCX0KIApAQCAtNTI4Nyw3ICs1MzA0LDcgQEAKIAlmb3IgKGkgPSAwOyBpIDwgdG9kb19saXN0LT5ucjsgaSsrKQogCQlmcmVlKHN1YmplY3RzW2ldKTsKIAlmcmVlKHN1YmplY3RzKTsKLQloYXNobWFwX2ZyZWUoJnN1YmplY3QyaXRlbSwgMSk7CisJaGFzaG1hcF9mcmVlX2VudHJpZXMoJnN1YmplY3QyaXRlbSwgc3RydWN0IHN1YmplY3QyaXRlbV9lbnRyeSwgZW50cnkpOwogCiAJY2xlYXJfY29tbWl0X3RvZG9faXRlbSgmY29tbWl0X3RvZG8pOwogCmRpZmYgLS1naXQgYS9zZXF1ZW5jZXIuaCBiL3NlcXVlbmNlci5oCmluZGV4IDY3MDRhY2IuLjlmOWFlMjkgMTAwNjQ0Ci0tLSBhL3NlcXVlbmNlci5oCisrKyBiL3NlcXVlbmNlci5oCkBAIC0xNDMsNiArMTQzLDEyIEBACiAgKi8KICNkZWZpbmUgVE9ET19MSVNUX1JFQkFTRV9DT1VTSU5TICgxVSA8PCA0KQogI2RlZmluZSBUT0RPX0xJU1RfQVBQRU5EX1RPRE9fSEVMUCAoMVUgPDwgNSkKKy8qCisgKiBXaGVuIGdlbmVyYXRpbmcgYSBzY3JpcHQgdGhhdCByZWJhc2VzIG1lcmdlcyB3aXRoIGAtLXJvb3RgICphbmQqIHdpdGgKKyAqIGAtLW9udG9gLCB3ZSBkbyBub3Qgd2FudCB0byByZS1nZW5lcmF0ZSB0aGUgcm9vdCBjb21taXRzLgorICovCisjZGVmaW5lIFRPRE9fTElTVF9ST09UX1dJVEhfT05UTyAoMVUgPDwgNikKKwogCiBpbnQgc2VxdWVuY2VyX21ha2Vfc2NyaXB0KHN0cnVjdCByZXBvc2l0b3J5ICpyLCBzdHJ1Y3Qgc3RyYnVmICpvdXQsIGludCBhcmdjLAogCQkJICBjb25zdCBjaGFyICoqYXJndiwgdW5zaWduZWQgZmxhZ3MpOwpAQCAtMTk2LDExICsyMDIsMTAgQEAKIAogaW50IHJlYWRfYXV0aG9yX3NjcmlwdChjb25zdCBjaGFyICpwYXRoLCBjaGFyICoqbmFtZSwgY2hhciAqKmVtYWlsLCBjaGFyICoqZGF0ZSwKIAkJICAgICAgIGludCBhbGxvd19taXNzaW5nKTsKLSNlbmRpZgotCiB2b2lkIHBhcnNlX3N0cmF0ZWd5X29wdHMoc3RydWN0IHJlcGxheV9vcHRzICpvcHRzLCBjaGFyICpyYXdfb3B0cyk7CiBpbnQgd3JpdGVfYmFzaWNfc3RhdGUoc3RydWN0IHJlcGxheV9vcHRzICpvcHRzLCBjb25zdCBjaGFyICpoZWFkX25hbWUsCiAJCSAgICAgIHN0cnVjdCBjb21taXQgKm9udG8sIGNvbnN0IGNoYXIgKm9yaWdfaGVhZCk7CiB2b2lkIHNlcXVlbmNlcl9wb3N0X2NvbW1pdF9jbGVhbnVwKHN0cnVjdCByZXBvc2l0b3J5ICpyLCBpbnQgdmVyYm9zZSk7CiBpbnQgc2VxdWVuY2VyX2dldF9sYXN0X2NvbW1hbmQoc3RydWN0IHJlcG9zaXRvcnkqIHIsCiAJCQkgICAgICAgZW51bSByZXBsYXlfYWN0aW9uICphY3Rpb24pOworI2VuZGlmIC8qIFNFUVVFTkNFUl9IICovCmRpZmYgLS1naXQgYS9zZXJ2ZXItaW5mby5jIGIvc2VydmVyLWluZm8uYwppbmRleCA0ZDgxOTliLi5iYWUyY2RmIDEwMDY0NAotLS0gYS9zZXJ2ZXItaW5mby5jCisrKyBiL3NlcnZlci1pbmZvLmMKQEAgLTkzLDcgKzkzLDcgQEAKIAkJdWljLm9sZF9mcCA9IGZvcGVuX29yX3dhcm4ocGF0aCwgInIiKTsKIAogCS8qCi0JICogdWljX3ByaW50ZiB3aWxsIGNvbXBhcmUgaW5jcmVtZW50YWwgY29tcGFyaXNvbiBhZ2luc3Qgb2xkX2ZwCisJICogdWljX3ByaW50ZiB3aWxsIGNvbXBhcmUgaW5jcmVtZW50YWwgY29tcGFyaXNvbiBhZ2FpbnN0IG9sZF9mcAogCSAqIGFuZCBtYXJrIHVpYyBhcyBzdGFsZSBpZiBuZWVkZWQKIAkgKi8KIAlyZXQgPSBnZW5lcmF0ZSgmdWljKTsKZGlmZiAtLWdpdCBhL3NldHVwLmMgYi9zZXR1cC5jCmluZGV4IDhkY2I0NjMuLmUyYTQ3OWEgMTAwNjQ0Ci0tLSBhL3NldHVwLmMKKysrIGIvc2V0dXAuYwpAQCAtNCw2ICs0LDcgQEAKICNpbmNsdWRlICJkaXIuaCIKICNpbmNsdWRlICJzdHJpbmctbGlzdC5oIgogI2luY2x1ZGUgImNoZGlyLW5vdGlmeS5oIgorI2luY2x1ZGUgInByb21pc29yLXJlbW90ZS5oIgogCiBzdGF0aWMgaW50IGluc2lkZV9naXRfZGlyID0gLTE7CiBzdGF0aWMgaW50IGluc2lkZV93b3JrX3RyZWUgPSAtMTsKQEAgLTQ3OCw3ICs0NzksNyBAQAogCX0KIAogCXJlcG9zaXRvcnlfZm9ybWF0X3ByZWNpb3VzX29iamVjdHMgPSBjYW5kaWRhdGUtPnByZWNpb3VzX29iamVjdHM7Ci0JcmVwb3NpdG9yeV9mb3JtYXRfcGFydGlhbF9jbG9uZSA9IHhzdHJkdXBfb3JfbnVsbChjYW5kaWRhdGUtPnBhcnRpYWxfY2xvbmUpOworCXNldF9yZXBvc2l0b3J5X2Zvcm1hdF9wYXJ0aWFsX2Nsb25lKGNhbmRpZGF0ZS0+cGFydGlhbF9jbG9uZSk7CiAJcmVwb3NpdG9yeV9mb3JtYXRfd29ya3RyZWVfY29uZmlnID0gY2FuZGlkYXRlLT53b3JrdHJlZV9jb25maWc7CiAJc3RyaW5nX2xpc3RfY2xlYXIoJmNhbmRpZGF0ZS0+dW5rbm93bl9leHRlbnNpb25zLCAwKTsKIApAQCAtNzk3LDcgKzc5OCw3IEBACiAJCXNldF9naXRfZGlyKGdpdGRpcik7CiAJaW5zaWRlX2dpdF9kaXIgPSAwOwogCWluc2lkZV93b3JrX3RyZWUgPSAxOwotCWlmIChvZmZzZXQgPT0gY3dkLT5sZW4pCisJaWYgKG9mZnNldCA+PSBjd2QtPmxlbikKIAkJcmV0dXJuIE5VTEw7CiAKIAkvKiBNYWtlICJvZmZzZXQiIHBvaW50IHBhc3QgdGhlICcvJyAoYWxyZWFkeSB0aGUgY2FzZSBmb3Igcm9vdCBkaXJzKSAqLwpAQCAtOTE5LDcgKzkyMCw3IEBACiAJY29uc3QgY2hhciAqZW52X2NlaWxpbmdfZGlycyA9IGdldGVudihDRUlMSU5HX0RJUkVDVE9SSUVTX0VOVklST05NRU5UKTsKIAlzdHJ1Y3Qgc3RyaW5nX2xpc3QgY2VpbGluZ19kaXJzID0gU1RSSU5HX0xJU1RfSU5JVF9EVVA7CiAJY29uc3QgY2hhciAqZ2l0ZGlyZW52OwotCWludCBjZWlsX29mZnNldCA9IC0xLCBtaW5fb2Zmc2V0ID0gaGFzX2Rvc19kcml2ZV9wcmVmaXgoZGlyLT5idWYpID8gMyA6IDE7CisJaW50IGNlaWxfb2Zmc2V0ID0gLTEsIG1pbl9vZmZzZXQgPSBvZmZzZXRfMXN0X2NvbXBvbmVudChkaXItPmJ1Zik7CiAJZGV2X3QgY3VycmVudF9kZXZpY2UgPSAwOwogCWludCBvbmVfZmlsZXN5c3RlbSA9IDE7CiAKQEAgLTk0Nyw2ICs5NDgsMTIgQEAKIAlpZiAoY2VpbF9vZmZzZXQgPCAwKQogCQljZWlsX29mZnNldCA9IG1pbl9vZmZzZXQgLSAyOwogCisJaWYgKG1pbl9vZmZzZXQgJiYgbWluX29mZnNldCA9PSBkaXItPmxlbiAmJgorCSAgICAhaXNfZGlyX3NlcChkaXItPmJ1ZlttaW5fb2Zmc2V0IC0gMV0pKSB7CisJCXN0cmJ1Zl9hZGRjaChkaXIsICcvJyk7CisJCW1pbl9vZmZzZXQrKzsKKwl9CisKIAkvKgogCSAqIFRlc3QgaW4gdGhlIGZvbGxvd2luZyBvcmRlciAocmVsYXRpdmUgdG8gdGhlIGRpcik6CiAJICogLSAuZ2l0IChmaWxlIGNvbnRhaW5pbmcgImdpdGRpcjogPHBhdGg+IikKZGlmZiAtLWdpdCBhL3NoYTEtZmlsZS5jIGIvc2hhMS1maWxlLmMKaW5kZXggNDg3ZWEzNS4uMTg4ZGU1NyAxMDA2NDQKLS0tIGEvc2hhMS1maWxlLmMKKysrIGIvc2hhMS1maWxlLmMKQEAgLTMwLDggKzMwLDggQEAKICNpbmNsdWRlICJtZXJnZXNvcnQuaCIKICNpbmNsdWRlICJxdW90ZS5oIgogI2luY2x1ZGUgInBhY2tmaWxlLmgiCi0jaW5jbHVkZSAiZmV0Y2gtb2JqZWN0LmgiCiAjaW5jbHVkZSAib2JqZWN0LXN0b3JlLmgiCisjaW5jbHVkZSAicHJvbWlzb3ItcmVtb3RlLmgiCiAKIC8qIFRoZSBtYXhpbXVtIHNpemUgZm9yIGFuIG9iamVjdCBoZWFkZXIuICovCiAjZGVmaW5lIE1BWF9IRUFERVJfTEVOIDMyCkBAIC01NSw3ICs1NSw2IEBACiAJIlx4NmZceGUxXHg0MVx4ZjdceDc0XHg5MVx4MjBceGEzXHgwM1x4NzIiIFwKIAkiXHgxOFx4MTMiCiAKLWNvbnN0IHVuc2lnbmVkIGNoYXIgbnVsbF9zaGExW0dJVF9NQVhfUkFXU1pdOwogY29uc3Qgc3RydWN0IG9iamVjdF9pZCBudWxsX29pZDsKIHN0YXRpYyBjb25zdCBzdHJ1Y3Qgb2JqZWN0X2lkIGVtcHR5X3RyZWVfb2lkID0gewogCUVNUFRZX1RSRUVfU0hBMV9CSU5fTElURVJBTApAQCAtOTUyLDEyICs5NTEsOCBAQAogCiAJbW1hcF9saW1pdF9jaGVjayhsZW5ndGgpOwogCXJldCA9IG1tYXAoc3RhcnQsIGxlbmd0aCwgcHJvdCwgZmxhZ3MsIGZkLCBvZmZzZXQpOwotCWlmIChyZXQgPT0gTUFQX0ZBSUxFRCkgewotCQlpZiAoIWxlbmd0aCkKLQkJCXJldHVybiBOVUxMOwotCQlyZWxlYXNlX3BhY2tfbWVtb3J5KGxlbmd0aCk7Ci0JCXJldCA9IG1tYXAoc3RhcnQsIGxlbmd0aCwgcHJvdCwgZmxhZ3MsIGZkLCBvZmZzZXQpOwotCX0KKwlpZiAocmV0ID09IE1BUF9GQUlMRUQgJiYgIWxlbmd0aCkKKwkJcmV0ID0gTlVMTDsKIAlyZXR1cm4gcmV0OwogfQogCkBAIC0xNDc1LDE2ICsxNDcwLDE3IEBACiAJCX0KIAogCQkvKiBDaGVjayBpZiBpdCBpcyBhIG1pc3Npbmcgb2JqZWN0ICovCi0JCWlmIChmZXRjaF9pZl9taXNzaW5nICYmIHJlcG9zaXRvcnlfZm9ybWF0X3BhcnRpYWxfY2xvbmUgJiYKKwkJaWYgKGZldGNoX2lmX21pc3NpbmcgJiYgaGFzX3Byb21pc29yX3JlbW90ZSgpICYmCiAJCSAgICAhYWxyZWFkeV9yZXRyaWVkICYmIHIgPT0gdGhlX3JlcG9zaXRvcnkgJiYKIAkJICAgICEoZmxhZ3MgJiBPQkpFQ1RfSU5GT19TS0lQX0ZFVENIX09CSkVDVCkpIHsKIAkJCS8qCi0JCQkgKiBUT0RPIEludmVzdGlnYXRlIGhhdmluZyBmZXRjaF9vYmplY3QoKSByZXR1cm4KLQkJCSAqIFRPRE8gZXJyb3Ivc3VjY2VzcyBhbmQgc3RvcHBpbmcgdGhlIG11c2ljIGhlcmUuCi0JCQkgKiBUT0RPIFBhc3MgYSByZXBvc2l0b3J5IHN0cnVjdCB0aHJvdWdoIGZldGNoX29iamVjdCwKLQkJCSAqIHN1Y2ggdGhhdCBhcmJpdHJhcnkgcmVwb3NpdG9yaWVzIHdvcmsuCisJCQkgKiBUT0RPIEludmVzdGlnYXRlIGNoZWNraW5nIHByb21pc29yX3JlbW90ZV9nZXRfZGlyZWN0KCkKKwkJCSAqIFRPRE8gcmV0dXJuIHZhbHVlIGFuZCBzdG9wcGluZyBvbiBlcnJvciBoZXJlLgorCQkJICogVE9ETyBQYXNzIGEgcmVwb3NpdG9yeSBzdHJ1Y3QgdGhyb3VnaAorCQkJICogcHJvbWlzb3JfcmVtb3RlX2dldF9kaXJlY3QoKSwgc3VjaCB0aGF0IGFyYml0cmFyeQorCQkJICogcmVwb3NpdG9yaWVzIHdvcmsuCiAJCQkgKi8KLQkJCWZldGNoX29iamVjdHMocmVwb3NpdG9yeV9mb3JtYXRfcGFydGlhbF9jbG9uZSwgcmVhbCwgMSk7CisJCQlwcm9taXNvcl9yZW1vdGVfZ2V0X2RpcmVjdChyLCByZWFsLCAxKTsKIAkJCWFscmVhZHlfcmV0cmllZCA9IDE7CiAJCQljb250aW51ZTsKIAkJfQpkaWZmIC0tZ2l0IGEvc2hhMS1sb29rdXAuYyBiL3NoYTEtbG9va3VwLmMKaW5kZXggNzk2YWI2OC4uMjkxODU4NCAxMDA2NDQKLS0tIGEvc2hhMS1sb29rdXAuYworKysgYi9zaGExLWxvb2t1cC5jCkBAIC01MCw3ICs1MCw3IEBACiAgKiBUaGUgc2hhMSBvZiBlbGVtZW50IGkgKGJldHdlZW4gMCBhbmQgbnIgLSAxKSBzaG91bGQgYmUgcmV0dXJuZWQKICAqIGJ5ICJmbihpLCB0YWJsZSkiLgogICovCi1pbnQgc2hhMV9wb3MoY29uc3QgdW5zaWduZWQgY2hhciAqc2hhMSwgdm9pZCAqdGFibGUsIHNpemVfdCBuciwKK2ludCBzaGExX3Bvcyhjb25zdCB1bnNpZ25lZCBjaGFyICpoYXNoLCB2b2lkICp0YWJsZSwgc2l6ZV90IG5yLAogCSAgICAgc2hhMV9hY2Nlc3NfZm4gZm4pCiB7CiAJc2l6ZV90IGhpID0gbnI7CkBAIC02MywxNCArNjMsMTQgQEAKIAlpZiAobnIgIT0gMSkgewogCQlzaXplX3QgbG92LCBoaXYsIG1pdiwgb2ZzOwogCi0JCWZvciAob2ZzID0gMDsgb2ZzIDwgMTg7IG9mcyArPSAyKSB7CisJCWZvciAob2ZzID0gMDsgb2ZzIDwgdGhlX2hhc2hfYWxnby0+cmF3c3ogLSAyOyBvZnMgKz0gMikgewogCQkJbG92ID0gdGFrZTIoZm4oMCwgdGFibGUpICsgb2ZzKTsKIAkJCWhpdiA9IHRha2UyKGZuKG5yIC0gMSwgdGFibGUpICsgb2ZzKTsKLQkJCW1pdiA9IHRha2UyKHNoYTEgKyBvZnMpOworCQkJbWl2ID0gdGFrZTIoaGFzaCArIG9mcyk7CiAJCQlpZiAobWl2IDwgbG92KQogCQkJCXJldHVybiAtMTsKIAkJCWlmIChoaXYgPCBtaXYpCi0JCQkJcmV0dXJuIC0xIC0gbnI7CisJCQkJcmV0dXJuIGluZGV4X3Bvc190b19pbnNlcnRfcG9zKG5yKTsKIAkJCWlmIChsb3YgIT0gaGl2KSB7CiAJCQkJLyoKIAkJCQkgKiBBdCB0aGlzIHBvaW50IG1pdiBjb3VsZCBiZSBlcXVhbApAQCAtODgsNyArODgsNyBAQAogCiAJZG8gewogCQlpbnQgY21wOwotCQljbXAgPSBoYXNoY21wKGZuKG1pLCB0YWJsZSksIHNoYTEpOworCQljbXAgPSBoYXNoY21wKGZuKG1pLCB0YWJsZSksIGhhc2gpOwogCQlpZiAoIWNtcCkKIAkJCXJldHVybiBtaTsKIAkJaWYgKGNtcCA+IDApCkBAIC05Nyw3ICs5Nyw3IEBACiAJCQlsbyA9IG1pICsgMTsKIAkJbWkgPSBsbyArIChoaSAtIGxvKSAvIDI7CiAJfSB3aGlsZSAobG8gPCBoaSk7Ci0JcmV0dXJuIC1sby0xOworCXJldHVybiBpbmRleF9wb3NfdG9faW5zZXJ0X3Bvcyhsbyk7CiB9CiAKIGludCBic2VhcmNoX2hhc2goY29uc3QgdW5zaWduZWQgY2hhciAqc2hhMSwgY29uc3QgdWludDMyX3QgKmZhbm91dF9uYm8sCmRpZmYgLS1naXQgYS9zaGExLW5hbWUuYyBiL3NoYTEtbmFtZS5jCmluZGV4IDI5ODllMjcuLjIwMGViMzcgMTAwNjQ0Ci0tLSBhL3NoYTEtbmFtZS5jCisrKyBiL3NoYTEtbmFtZS5jCkBAIC00MDMsOSArNDAzLDkgQEAKIAlyZXR1cm4gY29sbGVjdF9hbWJpZ3VvdXMob2lkLCBkYXRhKTsKIH0KIAotc3RhdGljIHN0cnVjdCByZXBvc2l0b3J5ICpzb3J0X2FtYmlndW91c19yZXBvOwotc3RhdGljIGludCBzb3J0X2FtYmlndW91cyhjb25zdCB2b2lkICphLCBjb25zdCB2b2lkICpiKQorc3RhdGljIGludCBzb3J0X2FtYmlndW91cyhjb25zdCB2b2lkICphLCBjb25zdCB2b2lkICpiLCB2b2lkICpjdHgpCiB7CisJc3RydWN0IHJlcG9zaXRvcnkgKnNvcnRfYW1iaWd1b3VzX3JlcG8gPSBjdHg7CiAJaW50IGFfdHlwZSA9IG9pZF9vYmplY3RfaW5mbyhzb3J0X2FtYmlndW91c19yZXBvLCBhLCBOVUxMKTsKIAlpbnQgYl90eXBlID0gb2lkX29iamVjdF9pbmZvKHNvcnRfYW1iaWd1b3VzX3JlcG8sIGIsIE5VTEwpOwogCWludCBhX3R5cGVfc29ydDsKQEAgLTQzNCwxMCArNDM0LDcgQEAKIAogc3RhdGljIHZvaWQgc29ydF9hbWJpZ3VvdXNfb2lkX2FycmF5KHN0cnVjdCByZXBvc2l0b3J5ICpyLCBzdHJ1Y3Qgb2lkX2FycmF5ICphKQogewotCS8qIG11dGV4IHdpbGwgYmUgbmVlZGVkIGlmIHRoaXMgY29kZSBpcyB0byBiZSBtYWRlIHRocmVhZCBzYWZlICovCi0Jc29ydF9hbWJpZ3VvdXNfcmVwbyA9IHI7Ci0JUVNPUlQoYS0+b2lkLCBhLT5uciwgc29ydF9hbWJpZ3VvdXMpOwotCXNvcnRfYW1iaWd1b3VzX3JlcG8gPSBOVUxMOworCVFTT1JUX1MoYS0+b2lkLCBhLT5uciwgc29ydF9hbWJpZ3VvdXMsIHIpOwogfQogCiBzdGF0aWMgZW51bSBnZXRfb2lkX3Jlc3VsdCBnZXRfc2hvcnRfb2lkKHN0cnVjdCByZXBvc2l0b3J5ICpyLApAQCAtMTE2MywxMyArMTE2MCwyMiBAQAogCX0KIAogCWlmIChoYXNfc3VmZml4KSB7Ci0JCWludCBudW0gPSAwOworCQl1bnNpZ25lZCBpbnQgbnVtID0gMDsKIAkJaW50IGxlbjEgPSBjcCAtIG5hbWU7CiAJCWNwKys7Ci0JCXdoaWxlIChjcCA8IG5hbWUgKyBsZW4pCi0JCQludW0gPSBudW0gKiAxMCArICpjcCsrIC0gJzAnOworCQl3aGlsZSAoY3AgPCBuYW1lICsgbGVuKSB7CisJCQl1bnNpZ25lZCBpbnQgZGlnaXQgPSAqY3ArKyAtICcwJzsKKwkJCWlmICh1bnNpZ25lZF9tdWx0X292ZXJmbG93cyhudW0sIDEwKSkKKwkJCQlyZXR1cm4gTUlTU0lOR19PQkpFQ1Q7CisJCQludW0gKj0gMTA7CisJCQlpZiAodW5zaWduZWRfYWRkX292ZXJmbG93cyhudW0sIGRpZ2l0KSkKKwkJCQlyZXR1cm4gTUlTU0lOR19PQkpFQ1Q7CisJCQludW0gKz0gZGlnaXQ7CisJCX0KIAkJaWYgKCFudW0gJiYgbGVuMSA9PSBsZW4gLSAxKQogCQkJbnVtID0gMTsKKwkJZWxzZSBpZiAobnVtID4gSU5UX01BWCkKKwkJCXJldHVybiBNSVNTSU5HX09CSkVDVDsKIAkJaWYgKGhhc19zdWZmaXggPT0gJ14nKQogCQkJcmV0dXJuIGdldF9wYXJlbnQociwgbmFtZSwgbGVuMSwgb2lkLCBudW0pOwogCQkvKiBlbHNlIGlmIChoYXNfc3VmZml4ID09ICd+JykgLS0gZ29lcyB3aXRob3V0IHNheWluZyAqLwpAQCAtMTI4OSw3ICsxMjk1LDcgQEAKIAogc3RydWN0IGdyYWJfbnRoX2JyYW5jaF9zd2l0Y2hfY2JkYXRhIHsKIAlpbnQgcmVtYWluaW5nOwotCXN0cnVjdCBzdHJidWYgYnVmOworCXN0cnVjdCBzdHJidWYgKnNiOwogfTsKIAogc3RhdGljIGludCBncmFiX250aF9icmFuY2hfc3dpdGNoKHN0cnVjdCBvYmplY3RfaWQgKm9vaWQsIHN0cnVjdCBvYmplY3RfaWQgKm5vaWQsCkBAIC0xMzA3LDggKzEzMTMsOCBAQAogCQlyZXR1cm4gMDsKIAlpZiAoLS0oY2ItPnJlbWFpbmluZykgPT0gMCkgewogCQlsZW4gPSB0YXJnZXQgLSBtYXRjaDsKLQkJc3RyYnVmX3Jlc2V0KCZjYi0+YnVmKTsKLQkJc3RyYnVmX2FkZCgmY2ItPmJ1ZiwgbWF0Y2gsIGxlbik7CisJCXN0cmJ1Zl9yZXNldChjYi0+c2IpOworCQlzdHJidWZfYWRkKGNiLT5zYiwgbWF0Y2gsIGxlbik7CiAJCXJldHVybiAxOyAvKiB3ZSBhcmUgZG9uZSAqLwogCX0KIAlyZXR1cm4gMDsKQEAgLTEzNDEsMTggKzEzNDcsMTUgQEAKIAlpZiAobnRoIDw9IDApCiAJCXJldHVybiAtMTsKIAljYi5yZW1haW5pbmcgPSBudGg7Ci0Jc3RyYnVmX2luaXQoJmNiLmJ1ZiwgMjApOworCWNiLnNiID0gYnVmOwogCiAJcmV0dmFsID0gcmVmc19mb3JfZWFjaF9yZWZsb2dfZW50X3JldmVyc2UoZ2V0X21haW5fcmVmX3N0b3JlKHIpLAogCQkJIkhFQUQiLCBncmFiX250aF9icmFuY2hfc3dpdGNoLCAmY2IpOwogCWlmICgwIDwgcmV0dmFsKSB7Ci0JCXN0cmJ1Zl9yZXNldChidWYpOwotCQlzdHJidWZfYWRkYnVmKGJ1ZiwgJmNiLmJ1Zik7CiAJCXJldHZhbCA9IGJyYWNlIC0gbmFtZSArIDE7CiAJfSBlbHNlCiAJCXJldHZhbCA9IDA7CiAKLQlzdHJidWZfcmVsZWFzZSgmY2IuYnVmKTsKIAlyZXR1cm4gcmV0dmFsOwogfQogCmRpZmYgLS1naXQgYS9zaGExZGMvc2hhMS5jIGIvc2hhMWRjL3NoYTEuYwppbmRleCA5ZDNjZjgxLi42M2NkNWM5IDEwMDY0NAotLS0gYS9zaGExZGMvc2hhMS5jCisrKyBiL3NoYTFkYy9zaGExLmMKQEAgLTcyLDcgKzcyLDcgQEAKIC8qIE5vdCB1bmRlciBHQ0MtYWxpa2Ugb3IgZ2xpYmMgKi8KICNlbGlmIGRlZmluZWQoX0JZVEVfT1JERVIpICYmIGRlZmluZWQoX0JJR19FTkRJQU4pICYmIGRlZmluZWQoX0xJVFRMRV9FTkRJQU4pCiAvKgotICogKkJTRCBhbmQgbmV3bGliIChlbWJlZGVkIGxpbnV4LCBjeWd3aW4sIGV0YykuCisgKiAqQlNEIGFuZCBuZXdsaWIgKGVtYmVkZGVkIGxpbnV4LCBjeWd3aW4sIGV0YykuCiAgKiB0aGUgZGVmaW5lZChfQklHX0VORElBTikgJiYgZGVmaW5lZChfTElUVExFX0VORElBTikgcGFydCBwcmV2ZW50cwogICogdGhpcyBjb25kaXRpb24gZnJvbSBtYXRjaGluZyB3aXRoIFNvbGFyaXMvc3BhcmMuCiAgKiAoU29sYXJpcyBkZWZpbmVzIG9ubHkgb25lIGVuZGlhbiBtYWNybykKZGlmZiAtLWdpdCBhL3NoYTFkY19naXQuYyBiL3NoYTFkY19naXQuYwppbmRleCBlMGNjOWQ5Li41YzMwMGU4IDEwMDY0NAotLS0gYS9zaGExZGNfZ2l0LmMKKysrIGIvc2hhMWRjX2dpdC5jCkBAIC0xOSw3ICsxOSw3IEBACiAJaWYgKCFTSEExRENGaW5hbChoYXNoLCBjdHgpKQogCQlyZXR1cm47CiAJZGllKCJTSEEtMSBhcHBlYXJzIHRvIGJlIHBhcnQgb2YgYSBjb2xsaXNpb24gYXR0YWNrOiAlcyIsCi0JICAgIHNoYTFfdG9faGV4KGhhc2gpKTsKKwkgICAgaGFzaF90b19oZXhfYWxnb3AoaGFzaCwgJmhhc2hfYWxnb3NbR0lUX0hBU0hfU0hBMV0pKTsKIH0KIAogLyoKZGlmZiAtLWdpdCBhL3NoYWxsb3cuYyBiL3NoYWxsb3cuYwppbmRleCA1ZmEyYjE1Li43ZmQwNGFmIDEwMDY0NAotLS0gYS9zaGFsbG93LmMKKysrIGIvc2hhbGxvdy5jCkBAIC0xMiwxMCArMTIsNyBAQAogI2luY2x1ZGUgImRpZmYuaCIKICNpbmNsdWRlICJyZXZpc2lvbi5oIgogI2luY2x1ZGUgImNvbW1pdC1zbGFiLmgiCi0jaW5jbHVkZSAicmV2aXNpb24uaCIKICNpbmNsdWRlICJsaXN0LW9iamVjdHMuaCIKLSNpbmNsdWRlICJjb21taXQtc2xhYi5oIgotI2luY2x1ZGUgInJlcG9zaXRvcnkuaCIKICNpbmNsdWRlICJjb21taXQtcmVhY2guaCIKIAogdm9pZCBzZXRfYWx0ZXJuYXRlX3NoYWxsb3dfZmlsZShzdHJ1Y3QgcmVwb3NpdG9yeSAqciwgY29uc3QgY2hhciAqcGF0aCwgaW50IG92ZXJyaWRlKQpAQCAtMTU2LDYgKzE1Myw4IEBACiAJZm9yIChpID0gMDsgaSA8IGRlcHRocy5zbGFiX2NvdW50OyBpKyspIHsKIAkJaW50IGo7CiAKKwkJaWYgKCFkZXB0aHMuc2xhYltpXSkKKwkJCWNvbnRpbnVlOwogCQlmb3IgKGogPSAwOyBqIDwgZGVwdGhzLnNsYWJfc2l6ZTsgaisrKQogCQkJZnJlZShkZXB0aHMuc2xhYltpXVtqXSk7CiAJfQpkaWZmIC0tZ2l0IGEvY29tcGF0L3Fzb3J0LmMgYi9zdGFibGUtcXNvcnQuYwpzaW1pbGFyaXR5IGluZGV4IDg4JQpyZW5hbWUgZnJvbSBjb21wYXQvcXNvcnQuYwpyZW5hbWUgdG8gc3RhYmxlLXFzb3J0LmMKaW5kZXggN2QwNzFhZi4uNmNiYWYzOSAxMDA2NDQKLS0tIGEvY29tcGF0L3Fzb3J0LmMKKysrIGIvc3RhYmxlLXFzb3J0LmMKQEAgLTEsNCArMSw0IEBACi0jaW5jbHVkZSAiLi4vZ2l0LWNvbXBhdC11dGlsLmgiCisjaW5jbHVkZSAiZ2l0LWNvbXBhdC11dGlsLmgiCiAKIC8qCiAgKiBBIG1lcmdlIHNvcnQgaW1wbGVtZW50YXRpb24sIHNpbXBsaWZpZWQgZnJvbSB0aGUgcXNvcnQgaW1wbGVtZW50YXRpb24KQEAgLTQ0LDggKzQ0LDggQEAKIAltZW1jcHkoYiwgdCwgKG4gLSBuMikgKiBzKTsKIH0KIAotdm9pZCBnaXRfcXNvcnQodm9pZCAqYiwgc2l6ZV90IG4sIHNpemVfdCBzLAotCSAgICAgICBpbnQgKCpjbXApKGNvbnN0IHZvaWQgKiwgY29uc3Qgdm9pZCAqKSkKK3ZvaWQgZ2l0X3N0YWJsZV9xc29ydCh2b2lkICpiLCBzaXplX3Qgbiwgc2l6ZV90IHMsCisJCSAgICAgIGludCAoKmNtcCkoY29uc3Qgdm9pZCAqLCBjb25zdCB2b2lkICopKQogewogCWNvbnN0IHNpemVfdCBzaXplID0gc3RfbXVsdChuLCBzKTsKIAljaGFyIGJ1ZlsxMDI0XTsKZGlmZiAtLWdpdCBhL3N0cmJ1Zi5jIGIvc3RyYnVmLmMKaW5kZXggZDMwZjkxNi4uYWE0OGQxNyAxMDA2NDQKLS0tIGEvc3RyYnVmLmMKKysrIGIvc3RyYnVmLmMKQEAgLTc3NCw4ICs3NzQsMTAgQEAKIAl9CiB9CiAKLXN0YXRpYyBpbnQgaXNfcmZjMzk4Nl9yZXNlcnZlZChjaGFyIGNoKQoraW50IGlzX3JmYzM5ODZfcmVzZXJ2ZWRfb3JfdW5yZXNlcnZlZChjaGFyIGNoKQogeworCWlmIChpc19yZmMzOTg2X3VucmVzZXJ2ZWQoY2gpKQorCQlyZXR1cm4gMTsKIAlzd2l0Y2ggKGNoKSB7CiAJCWNhc2UgJyEnOiBjYXNlICcqJzogY2FzZSAnXCcnOiBjYXNlICcoJzogY2FzZSAnKSc6IGNhc2UgJzsnOgogCQljYXNlICc6JzogY2FzZSAnQCc6IGNhc2UgJyYnOiBjYXNlICc9JzogY2FzZSAnKyc6IGNhc2UgJyQnOgpAQCAtNzg1LDIwICs3ODcsMTkgQEAKIAlyZXR1cm4gMDsKIH0KIAotc3RhdGljIGludCBpc19yZmMzOTg2X3VucmVzZXJ2ZWQoY2hhciBjaCkKK2ludCBpc19yZmMzOTg2X3VucmVzZXJ2ZWQoY2hhciBjaCkKIHsKIAlyZXR1cm4gaXNhbG51bShjaCkgfHwKIAkJY2ggPT0gJy0nIHx8IGNoID09ICdfJyB8fCBjaCA9PSAnLicgfHwgY2ggPT0gJ34nOwogfQogCiBzdGF0aWMgdm9pZCBzdHJidWZfYWRkX3VybGVuY29kZShzdHJ1Y3Qgc3RyYnVmICpzYiwgY29uc3QgY2hhciAqcywgc2l6ZV90IGxlbiwKLQkJCQkgaW50IHJlc2VydmVkKQorCQkJCSBjaGFyX3ByZWRpY2F0ZSBhbGxvd191bmVuY29kZWRfZm4pCiB7CiAJc3RyYnVmX2dyb3coc2IsIGxlbik7CiAJd2hpbGUgKGxlbi0tKSB7CiAJCWNoYXIgY2ggPSAqcysrOwotCQlpZiAoaXNfcmZjMzk4Nl91bnJlc2VydmVkKGNoKSB8fAotCQkgICAgKCFyZXNlcnZlZCAmJiBpc19yZmMzOTg2X3Jlc2VydmVkKGNoKSkpCisJCWlmIChhbGxvd191bmVuY29kZWRfZm4oY2gpKQogCQkJc3RyYnVmX2FkZGNoKHNiLCBjaCk7CiAJCWVsc2UKIAkJCXN0cmJ1Zl9hZGRmKHNiLCAiJSUlMDJ4IiwgKHVuc2lnbmVkIGNoYXIpY2gpOwpAQCAtODA2LDkgKzgwNyw5IEBACiB9CiAKIHZvaWQgc3RyYnVmX2FkZHN0cl91cmxlbmNvZGUoc3RydWN0IHN0cmJ1ZiAqc2IsIGNvbnN0IGNoYXIgKnMsCi0JCQkgICAgIGludCByZXNlcnZlZCkKKwkJCSAgICAgY2hhcl9wcmVkaWNhdGUgYWxsb3dfdW5lbmNvZGVkX2ZuKQogewotCXN0cmJ1Zl9hZGRfdXJsZW5jb2RlKHNiLCBzLCBzdHJsZW4ocyksIHJlc2VydmVkKTsKKwlzdHJidWZfYWRkX3VybGVuY29kZShzYiwgcywgc3RybGVuKHMpLCBhbGxvd191bmVuY29kZWRfZm4pOwogfQogCiBzdGF0aWMgdm9pZCBzdHJidWZfaHVtYW5pc2Uoc3RydWN0IHN0cmJ1ZiAqYnVmLCBvZmZfdCBieXRlcywKZGlmZiAtLWdpdCBhL3N0cmJ1Zi5oIGIvc3RyYnVmLmgKaW5kZXggZjYyMjc4YS4uODRjZjk2OSAxMDA2NDQKLS0tIGEvc3RyYnVmLmgKKysrIGIvc3RyYnVmLmgKQEAgLTY3Miw4ICs2NzIsMTMgQEAKICAqLwogaW50IHN0cmJ1Zl9jaGVja19icmFuY2hfcmVmKHN0cnVjdCBzdHJidWYgKnNiLCBjb25zdCBjaGFyICpuYW1lKTsKIAordHlwZWRlZiBpbnQgKCpjaGFyX3ByZWRpY2F0ZSkoY2hhciBjaCk7CisKK2ludCBpc19yZmMzOTg2X3VucmVzZXJ2ZWQoY2hhciBjaCk7CitpbnQgaXNfcmZjMzk4Nl9yZXNlcnZlZF9vcl91bnJlc2VydmVkKGNoYXIgY2gpOworCiB2b2lkIHN0cmJ1Zl9hZGRzdHJfdXJsZW5jb2RlKHN0cnVjdCBzdHJidWYgKnNiLCBjb25zdCBjaGFyICpuYW1lLAotCQkJICAgICBpbnQgcmVzZXJ2ZWQpOworCQkJICAgICBjaGFyX3ByZWRpY2F0ZSBhbGxvd191bmVuY29kZWRfZm4pOwogCiBfX2F0dHJpYnV0ZV9fKChmb3JtYXQgKHByaW50ZiwxLDIpKSkKIGludCBwcmludGZfbG4oY29uc3QgY2hhciAqZm10LCAuLi4pOwpkaWZmIC0tZ2l0IGEvc3RyaW5nLWxpc3QuaCBiL3N0cmluZy1saXN0LmgKaW5kZXggZjk2NDM5OS4uN2JiMGFkMCAxMDA2NDQKLS0tIGEvc3RyaW5nLWxpc3QuaAorKysgYi9zdHJpbmctbGlzdC5oCkBAIC0xNzksNyArMTc5LDcgQEAKIAogLyoqCiAgKiBDaGVjayBpZiB0aGUgZ2l2ZW4gc3RyaW5nIGlzIHBhcnQgb2YgYSBzb3J0ZWQgbGlzdC4gSWYgaXQgaXMgcGFydCBvZiB0aGUgbGlzdCwKLSAqIHJldHVybiB0aGUgY29yZXNwb25kaW5nIHN0cmluZ19saXN0X2l0ZW0sIE5VTEwgb3RoZXJ3aXNlLgorICogcmV0dXJuIHRoZSBjb3JyZXNwb25kaW5nIHN0cmluZ19saXN0X2l0ZW0sIE5VTEwgb3RoZXJ3aXNlLgogICovCiBzdHJ1Y3Qgc3RyaW5nX2xpc3RfaXRlbSAqc3RyaW5nX2xpc3RfbG9va3VwKHN0cnVjdCBzdHJpbmdfbGlzdCAqbGlzdCwgY29uc3QgY2hhciAqc3RyaW5nKTsKIApkaWZmIC0tZ2l0IGEvc3ViLXByb2Nlc3MuYyBiL3N1Yi1wcm9jZXNzLmMKaW5kZXggM2Y0YWY5My4uMWIxYWY5ZCAxMDA2NDQKLS0tIGEvc3ViLXByb2Nlc3MuYworKysgYi9zdWItcHJvY2Vzcy5jCkBAIC02LDEyICs2LDE0IEBACiAjaW5jbHVkZSAicGt0LWxpbmUuaCIKIAogaW50IGNtZDJwcm9jZXNzX2NtcChjb25zdCB2b2lkICp1bnVzZWRfY21wX2RhdGEsCi0JCSAgICBjb25zdCB2b2lkICplbnRyeSwKLQkJICAgIGNvbnN0IHZvaWQgKmVudHJ5X29yX2tleSwKKwkJICAgIGNvbnN0IHN0cnVjdCBoYXNobWFwX2VudHJ5ICplcHRyLAorCQkgICAgY29uc3Qgc3RydWN0IGhhc2htYXBfZW50cnkgKmVudHJ5X29yX2tleSwKIAkJICAgIGNvbnN0IHZvaWQgKnVudXNlZF9rZXlkYXRhKQogewotCWNvbnN0IHN0cnVjdCBzdWJwcm9jZXNzX2VudHJ5ICplMSA9IGVudHJ5OwotCWNvbnN0IHN0cnVjdCBzdWJwcm9jZXNzX2VudHJ5ICplMiA9IGVudHJ5X29yX2tleTsKKwljb25zdCBzdHJ1Y3Qgc3VicHJvY2Vzc19lbnRyeSAqZTEsICplMjsKKworCWUxID0gY29udGFpbmVyX29mKGVwdHIsIGNvbnN0IHN0cnVjdCBzdWJwcm9jZXNzX2VudHJ5LCBlbnQpOworCWUyID0gY29udGFpbmVyX29mKGVudHJ5X29yX2tleSwgY29uc3Qgc3RydWN0IHN1YnByb2Nlc3NfZW50cnksIGVudCk7CiAKIAlyZXR1cm4gc3RyY21wKGUxLT5jbWQsIGUyLT5jbWQpOwogfQpAQCAtMjAsOSArMjIsOSBAQAogewogCXN0cnVjdCBzdWJwcm9jZXNzX2VudHJ5IGtleTsKIAotCWhhc2htYXBfZW50cnlfaW5pdCgma2V5LCBzdHJoYXNoKGNtZCkpOworCWhhc2htYXBfZW50cnlfaW5pdCgma2V5LmVudCwgc3RyaGFzaChjbWQpKTsKIAlrZXkuY21kID0gY21kOwotCXJldHVybiBoYXNobWFwX2dldChoYXNobWFwLCAma2V5LCBOVUxMKTsKKwlyZXR1cm4gaGFzaG1hcF9nZXRfZW50cnkoaGFzaG1hcCwgJmtleSwgZW50LCBOVUxMKTsKIH0KIAogaW50IHN1YnByb2Nlc3NfcmVhZF9zdGF0dXMoaW50IGZkLCBzdHJ1Y3Qgc3RyYnVmICpzdGF0dXMpCkBAIC01OCw3ICs2MCw3IEBACiAJa2lsbChlbnRyeS0+cHJvY2Vzcy5waWQsIFNJR1RFUk0pOwogCWZpbmlzaF9jb21tYW5kKCZlbnRyeS0+cHJvY2Vzcyk7CiAKLQloYXNobWFwX3JlbW92ZShoYXNobWFwLCBlbnRyeSwgTlVMTCk7CisJaGFzaG1hcF9yZW1vdmUoaGFzaG1hcCwgJmVudHJ5LT5lbnQsIE5VTEwpOwogfQogCiBzdGF0aWMgdm9pZCBzdWJwcm9jZXNzX2V4aXRfaGFuZGxlcihzdHJ1Y3QgY2hpbGRfcHJvY2VzcyAqcHJvY2VzcykKQEAgLTk2LDcgKzk4LDcgQEAKIAkJcmV0dXJuIGVycjsKIAl9CiAKLQloYXNobWFwX2VudHJ5X2luaXQoZW50cnksIHN0cmhhc2goY21kKSk7CisJaGFzaG1hcF9lbnRyeV9pbml0KCZlbnRyeS0+ZW50LCBzdHJoYXNoKGNtZCkpOwogCiAJZXJyID0gc3RhcnRmbihlbnRyeSk7CiAJaWYgKGVycikgewpAQCAtMTA1LDcgKzEwNyw3IEBACiAJCXJldHVybiBlcnI7CiAJfQogCi0JaGFzaG1hcF9hZGQoaGFzaG1hcCwgZW50cnkpOworCWhhc2htYXBfYWRkKGhhc2htYXAsICZlbnRyeS0+ZW50KTsKIAlyZXR1cm4gMDsKIH0KIApkaWZmIC0tZ2l0IGEvc3ViLXByb2Nlc3MuaCBiL3N1Yi1wcm9jZXNzLmgKaW5kZXggNWMxODJmYS4uZTg1ZjIxZiAxMDA2NDQKLS0tIGEvc3ViLXByb2Nlc3MuaAorKysgYi9zdWItcHJvY2Vzcy5oCkBAIC0yNCw3ICsyNCw3IEBACiAKIC8qIE1lbWJlcnMgc2hvdWxkIG5vdCBiZSBhY2Nlc3NlZCBkaXJlY3RseS4gKi8KIHN0cnVjdCBzdWJwcm9jZXNzX2VudHJ5IHsKLQlzdHJ1Y3QgaGFzaG1hcF9lbnRyeSBlbnQ7IC8qIG11c3QgYmUgdGhlIGZpcnN0IG1lbWJlciEgKi8KKwlzdHJ1Y3QgaGFzaG1hcF9lbnRyeSBlbnQ7CiAJY29uc3QgY2hhciAqY21kOwogCXN0cnVjdCBjaGlsZF9wcm9jZXNzIHByb2Nlc3M7CiB9OwpAQCAtNDMsOCArNDMsOCBAQAogCiAvKiBGdW5jdGlvbiB0byB0ZXN0IHR3byBzdWJwcm9jZXNzIGhhc2htYXAgZW50cmllcyBmb3IgZXF1YWxpdHkuICovCiBpbnQgY21kMnByb2Nlc3NfY21wKGNvbnN0IHZvaWQgKnVudXNlZF9jbXBfZGF0YSwKLQkJICAgIGNvbnN0IHZvaWQgKmUxLAotCQkgICAgY29uc3Qgdm9pZCAqZTIsCisJCSAgICBjb25zdCBzdHJ1Y3QgaGFzaG1hcF9lbnRyeSAqZSwKKwkJICAgIGNvbnN0IHN0cnVjdCBoYXNobWFwX2VudHJ5ICplbnRyeV9vcl9rZXksCiAJCSAgICBjb25zdCB2b2lkICp1bnVzZWRfa2V5ZGF0YSk7CiAKIC8qCmRpZmYgLS1naXQgYS9zdWJtb2R1bGUtY29uZmlnLmMgYi9zdWJtb2R1bGUtY29uZmlnLmMKaW5kZXggNDI2NGVlMi4uNDAxYTliMiAxMDA2NDQKLS0tIGEvc3VibW9kdWxlLWNvbmZpZy5jCisrKyBiL3N1Ym1vZHVsZS1jb25maWcuYwpAQCAtMzgsMjQgKzM4LDI4IEBACiB9OwogCiBzdGF0aWMgaW50IGNvbmZpZ19wYXRoX2NtcChjb25zdCB2b2lkICp1bnVzZWRfY21wX2RhdGEsCi0JCQkgICBjb25zdCB2b2lkICplbnRyeSwKLQkJCSAgIGNvbnN0IHZvaWQgKmVudHJ5X29yX2tleSwKKwkJCSAgIGNvbnN0IHN0cnVjdCBoYXNobWFwX2VudHJ5ICplcHRyLAorCQkJICAgY29uc3Qgc3RydWN0IGhhc2htYXBfZW50cnkgKmVudHJ5X29yX2tleSwKIAkJCSAgIGNvbnN0IHZvaWQgKnVudXNlZF9rZXlkYXRhKQogewotCWNvbnN0IHN0cnVjdCBzdWJtb2R1bGVfZW50cnkgKmEgPSBlbnRyeTsKLQljb25zdCBzdHJ1Y3Qgc3VibW9kdWxlX2VudHJ5ICpiID0gZW50cnlfb3Jfa2V5OworCWNvbnN0IHN0cnVjdCBzdWJtb2R1bGVfZW50cnkgKmEsICpiOworCisJYSA9IGNvbnRhaW5lcl9vZihlcHRyLCBjb25zdCBzdHJ1Y3Qgc3VibW9kdWxlX2VudHJ5LCBlbnQpOworCWIgPSBjb250YWluZXJfb2YoZW50cnlfb3Jfa2V5LCBjb25zdCBzdHJ1Y3Qgc3VibW9kdWxlX2VudHJ5LCBlbnQpOwogCiAJcmV0dXJuIHN0cmNtcChhLT5jb25maWctPnBhdGgsIGItPmNvbmZpZy0+cGF0aCkgfHwKIAkgICAgICAgIW9pZGVxKCZhLT5jb25maWctPmdpdG1vZHVsZXNfb2lkLCAmYi0+Y29uZmlnLT5naXRtb2R1bGVzX29pZCk7CiB9CiAKIHN0YXRpYyBpbnQgY29uZmlnX25hbWVfY21wKGNvbnN0IHZvaWQgKnVudXNlZF9jbXBfZGF0YSwKLQkJCSAgIGNvbnN0IHZvaWQgKmVudHJ5LAotCQkJICAgY29uc3Qgdm9pZCAqZW50cnlfb3Jfa2V5LAorCQkJICAgY29uc3Qgc3RydWN0IGhhc2htYXBfZW50cnkgKmVwdHIsCisJCQkgICBjb25zdCBzdHJ1Y3QgaGFzaG1hcF9lbnRyeSAqZW50cnlfb3Jfa2V5LAogCQkJICAgY29uc3Qgdm9pZCAqdW51c2VkX2tleWRhdGEpCiB7Ci0JY29uc3Qgc3RydWN0IHN1Ym1vZHVsZV9lbnRyeSAqYSA9IGVudHJ5OwotCWNvbnN0IHN0cnVjdCBzdWJtb2R1bGVfZW50cnkgKmIgPSBlbnRyeV9vcl9rZXk7CisJY29uc3Qgc3RydWN0IHN1Ym1vZHVsZV9lbnRyeSAqYSwgKmI7CisKKwlhID0gY29udGFpbmVyX29mKGVwdHIsIGNvbnN0IHN0cnVjdCBzdWJtb2R1bGVfZW50cnksIGVudCk7CisJYiA9IGNvbnRhaW5lcl9vZihlbnRyeV9vcl9rZXksIGNvbnN0IHN0cnVjdCBzdWJtb2R1bGVfZW50cnksIGVudCk7CiAKIAlyZXR1cm4gc3RyY21wKGEtPmNvbmZpZy0+bmFtZSwgYi0+Y29uZmlnLT5uYW1lKSB8fAogCSAgICAgICAhb2lkZXEoJmEtPmNvbmZpZy0+Z2l0bW9kdWxlc19vaWQsICZiLT5jb25maWctPmdpdG1vZHVsZXNfb2lkKTsKQEAgLTk1LDEyICs5OSwxMiBAQAogCSAqIGFsbG9jYXRpb24gb2Ygc3RydWN0IHN1Ym1vZHVsZSBlbnRyaWVzLiBFYWNoIGlzIGFsbG9jYXRlZCBieQogCSAqIHRoZWlyIC5naXRtb2R1bGVzIGJsb2Igc2hhMSBhbmQgc3VibW9kdWxlIG5hbWUuCiAJICovCi0JaGFzaG1hcF9pdGVyX2luaXQoJmNhY2hlLT5mb3JfbmFtZSwgJml0ZXIpOwotCXdoaWxlICgoZW50cnkgPSBoYXNobWFwX2l0ZXJfbmV4dCgmaXRlcikpKQorCWhhc2htYXBfZm9yX2VhY2hfZW50cnkoJmNhY2hlLT5mb3JfbmFtZSwgJml0ZXIsIGVudHJ5LAorCQkJCWVudCAvKiBtZW1iZXIgbmFtZSAqLykKIAkJZnJlZV9vbmVfY29uZmlnKGVudHJ5KTsKIAotCWhhc2htYXBfZnJlZSgmY2FjaGUtPmZvcl9wYXRoLCAxKTsKLQloYXNobWFwX2ZyZWUoJmNhY2hlLT5mb3JfbmFtZSwgMSk7CisJaGFzaG1hcF9mcmVlX2VudHJpZXMoJmNhY2hlLT5mb3JfcGF0aCwgc3RydWN0IHN1Ym1vZHVsZV9lbnRyeSwgZW50KTsKKwloYXNobWFwX2ZyZWVfZW50cmllcygmY2FjaGUtPmZvcl9uYW1lLCBzdHJ1Y3Qgc3VibW9kdWxlX2VudHJ5LCBlbnQpOwogCWNhY2hlLT5pbml0aWFsaXplZCA9IDA7CiAJY2FjaGUtPmdpdG1vZHVsZXNfcmVhZCA9IDA7CiB9CkBAIC0xMjMsOSArMTI3LDkgQEAKIAl1bnNpZ25lZCBpbnQgaGFzaCA9IGhhc2hfb2lkX3N0cmluZygmc3VibW9kdWxlLT5naXRtb2R1bGVzX29pZCwKIAkJCQkJICAgIHN1Ym1vZHVsZS0+cGF0aCk7CiAJc3RydWN0IHN1Ym1vZHVsZV9lbnRyeSAqZSA9IHhtYWxsb2Moc2l6ZW9mKCplKSk7Ci0JaGFzaG1hcF9lbnRyeV9pbml0KGUsIGhhc2gpOworCWhhc2htYXBfZW50cnlfaW5pdCgmZS0+ZW50LCBoYXNoKTsKIAllLT5jb25maWcgPSBzdWJtb2R1bGU7Ci0JaGFzaG1hcF9wdXQoJmNhY2hlLT5mb3JfcGF0aCwgZSk7CisJaGFzaG1hcF9wdXQoJmNhY2hlLT5mb3JfcGF0aCwgJmUtPmVudCk7CiB9CiAKIHN0YXRpYyB2b2lkIGNhY2hlX3JlbW92ZV9wYXRoKHN0cnVjdCBzdWJtb2R1bGVfY2FjaGUgKmNhY2hlLApAQCAtMTM1LDkgKzEzOSw5IEBACiAJCQkJCSAgICBzdWJtb2R1bGUtPnBhdGgpOwogCXN0cnVjdCBzdWJtb2R1bGVfZW50cnkgZTsKIAlzdHJ1Y3Qgc3VibW9kdWxlX2VudHJ5ICpyZW1vdmVkOwotCWhhc2htYXBfZW50cnlfaW5pdCgmZSwgaGFzaCk7CisJaGFzaG1hcF9lbnRyeV9pbml0KCZlLmVudCwgaGFzaCk7CiAJZS5jb25maWcgPSBzdWJtb2R1bGU7Ci0JcmVtb3ZlZCA9IGhhc2htYXBfcmVtb3ZlKCZjYWNoZS0+Zm9yX3BhdGgsICZlLCBOVUxMKTsKKwlyZW1vdmVkID0gaGFzaG1hcF9yZW1vdmVfZW50cnkoJmNhY2hlLT5mb3JfcGF0aCwgJmUsIGVudCwgTlVMTCk7CiAJZnJlZShyZW1vdmVkKTsKIH0KIApAQCAtMTQ3LDkgKzE1MSw5IEBACiAJdW5zaWduZWQgaW50IGhhc2ggPSBoYXNoX29pZF9zdHJpbmcoJnN1Ym1vZHVsZS0+Z2l0bW9kdWxlc19vaWQsCiAJCQkJCSAgICBzdWJtb2R1bGUtPm5hbWUpOwogCXN0cnVjdCBzdWJtb2R1bGVfZW50cnkgKmUgPSB4bWFsbG9jKHNpemVvZigqZSkpOwotCWhhc2htYXBfZW50cnlfaW5pdChlLCBoYXNoKTsKKwloYXNobWFwX2VudHJ5X2luaXQoJmUtPmVudCwgaGFzaCk7CiAJZS0+Y29uZmlnID0gc3VibW9kdWxlOwotCWhhc2htYXBfYWRkKCZjYWNoZS0+Zm9yX25hbWUsIGUpOworCWhhc2htYXBfYWRkKCZjYWNoZS0+Zm9yX25hbWUsICZlLT5lbnQpOwogfQogCiBzdGF0aWMgY29uc3Qgc3RydWN0IHN1Ym1vZHVsZSAqY2FjaGVfbG9va3VwX3BhdGgoc3RydWN0IHN1Ym1vZHVsZV9jYWNoZSAqY2FjaGUsCkBAIC0xNjMsMTAgKzE2NywxMCBAQAogCW9pZGNweSgma2V5X2NvbmZpZy5naXRtb2R1bGVzX29pZCwgZ2l0bW9kdWxlc19vaWQpOwogCWtleV9jb25maWcucGF0aCA9IHBhdGg7CiAKLQloYXNobWFwX2VudHJ5X2luaXQoJmtleSwgaGFzaCk7CisJaGFzaG1hcF9lbnRyeV9pbml0KCZrZXkuZW50LCBoYXNoKTsKIAlrZXkuY29uZmlnID0gJmtleV9jb25maWc7CiAKLQllbnRyeSA9IGhhc2htYXBfZ2V0KCZjYWNoZS0+Zm9yX3BhdGgsICZrZXksIE5VTEwpOworCWVudHJ5ID0gaGFzaG1hcF9nZXRfZW50cnkoJmNhY2hlLT5mb3JfcGF0aCwgJmtleSwgZW50LCBOVUxMKTsKIAlpZiAoZW50cnkpCiAJCXJldHVybiBlbnRyeS0+Y29uZmlnOwogCXJldHVybiBOVUxMOwpAQCAtMTgzLDEwICsxODcsMTAgQEAKIAlvaWRjcHkoJmtleV9jb25maWcuZ2l0bW9kdWxlc19vaWQsIGdpdG1vZHVsZXNfb2lkKTsKIAlrZXlfY29uZmlnLm5hbWUgPSBuYW1lOwogCi0JaGFzaG1hcF9lbnRyeV9pbml0KCZrZXksIGhhc2gpOworCWhhc2htYXBfZW50cnlfaW5pdCgma2V5LmVudCwgaGFzaCk7CiAJa2V5LmNvbmZpZyA9ICZrZXlfY29uZmlnOwogCi0JZW50cnkgPSBoYXNobWFwX2dldCgmY2FjaGUtPmZvcl9uYW1lLCAma2V5LCBOVUxMKTsKKwllbnRyeSA9IGhhc2htYXBfZ2V0X2VudHJ5KCZjYWNoZS0+Zm9yX25hbWUsICZrZXksIGVudCwgTlVMTCk7CiAJaWYgKGVudHJ5KQogCQlyZXR1cm4gZW50cnktPmNvbmZpZzsKIAlyZXR1cm4gTlVMTDsKQEAgLTU1MCw3ICs1NTQsOSBAQAogCQlzdHJ1Y3QgaGFzaG1hcF9pdGVyIGl0ZXI7CiAJCXN0cnVjdCBzdWJtb2R1bGVfZW50cnkgKmVudHJ5OwogCi0JCWVudHJ5ID0gaGFzaG1hcF9pdGVyX2ZpcnN0KCZjYWNoZS0+Zm9yX25hbWUsICZpdGVyKTsKKwkJZW50cnkgPSBoYXNobWFwX2l0ZXJfZmlyc3RfZW50cnkoJmNhY2hlLT5mb3JfbmFtZSwgJml0ZXIsCisJCQkJCQlzdHJ1Y3Qgc3VibW9kdWxlX2VudHJ5LAorCQkJCQkJZW50IC8qIG1lbWJlciBuYW1lICovKTsKIAkJaWYgKCFlbnRyeSkKIAkJCXJldHVybiBOVUxMOwogCQlyZXR1cm4gZW50cnktPmNvbmZpZzsKZGlmZiAtLWdpdCBhL3QvUkVBRE1FIGIvdC9SRUFETUUKaW5kZXggNjBkNWI3Ny4uY2FhMTI1YiAxMDA2NDQKLS0tIGEvdC9SRUFETUUKKysrIGIvdC9SRUFETUUKQEAgLTM5Nyw2ICszOTcsMTAgQEAKIGJ1aWx0LWluIHZlcnNpb24gb2YgZ2l0LXN0YXNoLiBTZWUgJ3N0YXNoLnVzZUJ1aWx0aW4nIGluCiBnaXQtY29uZmlnKDEpLgogCitHSVRfVEVTVF9BRERfSV9VU0VfQlVJTFRJTj08Ym9vbGVhbj4sIHdoZW4gdHJ1ZSwgZW5hYmxlcyB0aGUKK2J1aWx0LWluIHZlcnNpb24gb2YgZ2l0IGFkZCAtaS4gU2VlICdhZGQuaW50ZXJhY3RpdmUudXNlQnVpbHRpbicgaW4KK2dpdC1jb25maWcoMSkuCisKIEdJVF9URVNUX0lOREVYX1RIUkVBRFM9PG4+IGVuYWJsZXMgZXhlcmNpc2luZyB0aGUgbXVsdGktdGhyZWFkZWQgbG9hZGluZwogb2YgdGhlIGluZGV4IGZvciB0aGUgd2hvbGUgdGVzdCBzdWl0ZSBieSBieXBhc3NpbmcgdGhlIGRlZmF1bHQgbnVtYmVyIG9mCiBjYWNoZSBlbnRyaWVzIGFuZCB0aHJlYWQgbWluaW11bXMuIFNldHRpbmcgdGhpcyB0byAxIHdpbGwgbWFrZSB0aGUKQEAgLTk3OCw2ICs5ODIsMTUgQEAKICAgIG91dHB1dCB0byB0aGUgZG93bnN0cmVhbS0tLXVubGlrZSB0aGUgcmVhbCB2ZXJzaW9uLCBpdCBnZW5lcmF0ZXMKICAgIG9ubHkgdXAgdG8gOTkgbGluZXMuCiAKKyAtIHRlc3RfYm9vbF9lbnYgPGVudi12YXJpYWJsZS1uYW1lPiA8ZGVmYXVsdC12YWx1ZT4KKworICAgR2l2ZW4gdGhlIG5hbWUgb2YgYW4gZW52aXJvbm1lbnQgdmFyaWFibGUgd2l0aCBhIGJvb2wgdmFsdWUsCisgICBub3JtYWxpemUgaXRzIHZhbHVlIHRvIGEgMCAodHJ1ZSkgb3IgMSAoZmFsc2Ugb3IgZW1wdHkgc3RyaW5nKQorICAgcmV0dXJuIGNvZGUuICBSZXR1cm4gd2l0aCBjb2RlIGNvcnJlc3BvbmRpbmcgdG8gdGhlIGdpdmVuIGRlZmF1bHQKKyAgIHZhbHVlIGlmIHRoZSB2YXJpYWJsZSBpcyB1bnNldC4KKyAgIEFib3J0IHRoZSB0ZXN0IHNjcmlwdCBpZiBlaXRoZXIgdGhlIHZhbHVlIG9mIHRoZSB2YXJpYWJsZSBvciB0aGUKKyAgIGRlZmF1bHQgYXJlIG5vdCB2YWxpZCBib29sIHZhbHVlcy4KKwogCiBQcmVyZXF1aXNpdGVzCiAtLS0tLS0tLS0tLS0tCmRpZmYgLS1naXQgYS90L2dpdHdlYi1saWIuc2ggYi90L2dpdHdlYi1saWIuc2gKaW5kZXggMDA2ZDJhOC4uMWYzMmNhNiAxMDA2NDQKLS0tIGEvdC9naXR3ZWItbGliLnNoCisrKyBiL3QvZ2l0d2ViLWxpYi5zaApAQCAtNTgsMTAgKzU4LDExIEBACiAJR0FURVdBWV9JTlRFUkZBQ0U9J0NHSS8xLjEnCiAJSFRUUF9BQ0NFUFQ9JyovKicKIAlSRVFVRVNUX01FVEhPRD0nR0VUJwotCVFVRVJZX1NUUklORz0iIiQxIiIKLQlQQVRIX0lORk89IiIkMiIiCisJUVVFUllfU1RSSU5HPSQxCisJUEFUSF9JTkZPPSQyCisJUkVRVUVTVF9VUkk9L2dpdHdlYi5jZ2kkUEFUSF9JTkZPCiAJZXhwb3J0IEdBVEVXQVlfSU5URVJGQUNFIEhUVFBfQUNDRVBUIFJFUVVFU1RfTUVUSE9EIFwKLQkJUVVFUllfU1RSSU5HIFBBVEhfSU5GTworCQlRVUVSWV9TVFJJTkcgUEFUSF9JTkZPIFJFUVVFU1RfVVJJCiAKIAlHSVRXRUJfQ09ORklHPSQocHdkKS9naXR3ZWJfY29uZmlnLnBlcmwKIAlleHBvcnQgR0lUV0VCX0NPTkZJRwpkaWZmIC0tZ2l0IGEvdC9oZWxwZXIvLmdpdGlnbm9yZSBiL3QvaGVscGVyLy5naXRpZ25vcmUKaW5kZXggMmJhZDI4YS4uNDhjN2JiMCAxMDA2NDQKLS0tIGEvdC9oZWxwZXIvLmdpdGlnbm9yZQorKysgYi90L2hlbHBlci8uZ2l0aWdub3JlCkBAIC0xLDUgKzEsNCBAQAotKgotISouc2gKLSEqLltjaF0KLSEqLmdpdGlnbm9yZQotCisvdGVzdC10b29sCisvdGVzdC1mYWtlLXNzaAorL3Rlc3QtbGluZS1idWZmZXIKKy90ZXN0LXN2bi1mZQpkaWZmIC0tZ2l0IGEvdC9oZWxwZXIvdGVzdC1kYXRlLmMgYi90L2hlbHBlci90ZXN0LWRhdGUuYwppbmRleCA1ODUzNDdlLi4wOTllZmY0IDEwMDY0NAotLS0gYS90L2hlbHBlci90ZXN0LWRhdGUuYworKysgYi90L2hlbHBlci90ZXN0LWRhdGUuYwpAQCAtMTIsMTMgKzEyLDEzIEBACiAiICB0ZXN0LXRvb2wgZGF0ZSBpczY0Yml0XG4iCiAiICB0ZXN0LXRvb2wgZGF0ZSB0aW1lX3QtaXM2NGJpdFxuIjsKIAotc3RhdGljIHZvaWQgc2hvd19yZWxhdGl2ZV9kYXRlcyhjb25zdCBjaGFyICoqYXJndiwgc3RydWN0IHRpbWV2YWwgKm5vdykKK3N0YXRpYyB2b2lkIHNob3dfcmVsYXRpdmVfZGF0ZXMoY29uc3QgY2hhciAqKmFyZ3YpCiB7CiAJc3RydWN0IHN0cmJ1ZiBidWYgPSBTVFJCVUZfSU5JVDsKIAogCWZvciAoOyAqYXJndjsgYXJndisrKSB7CiAJCXRpbWVfdCB0ID0gYXRvaSgqYXJndik7Ci0JCXNob3dfZGF0ZV9yZWxhdGl2ZSh0LCBub3csICZidWYpOworCQlzaG93X2RhdGVfcmVsYXRpdmUodCwgJmJ1Zik7CiAJCXByaW50ZigiJXMgLT4gJXNcbiIsICphcmd2LCBidWYuYnVmKTsKIAl9CiAJc3RyYnVmX3JlbGVhc2UoJmJ1Zik7CkBAIC03NCwyMCArNzQsMjAgQEAKIAlzdHJidWZfcmVsZWFzZSgmcmVzdWx0KTsKIH0KIAotc3RhdGljIHZvaWQgcGFyc2VfYXBwcm94aWRhdGUoY29uc3QgY2hhciAqKmFyZ3YsIHN0cnVjdCB0aW1ldmFsICpub3cpCitzdGF0aWMgdm9pZCBwYXJzZV9hcHByb3hpZGF0ZShjb25zdCBjaGFyICoqYXJndikKIHsKIAlmb3IgKDsgKmFyZ3Y7IGFyZ3YrKykgewogCQl0aW1lc3RhbXBfdCB0OwotCQl0ID0gYXBwcm94aWRhdGVfcmVsYXRpdmUoKmFyZ3YsIG5vdyk7CisJCXQgPSBhcHByb3hpZGF0ZV9yZWxhdGl2ZSgqYXJndik7CiAJCXByaW50ZigiJXMgLT4gJXNcbiIsICphcmd2LCBzaG93X2RhdGUodCwgMCwgREFURV9NT0RFKElTTzg2MDEpKSk7CiAJfQogfQogCi1zdGF0aWMgdm9pZCBwYXJzZV9hcHByb3hfdGltZXN0YW1wKGNvbnN0IGNoYXIgKiphcmd2LCBzdHJ1Y3QgdGltZXZhbCAqbm93KQorc3RhdGljIHZvaWQgcGFyc2VfYXBwcm94X3RpbWVzdGFtcChjb25zdCBjaGFyICoqYXJndikKIHsKIAlmb3IgKDsgKmFyZ3Y7IGFyZ3YrKykgewogCQl0aW1lc3RhbXBfdCB0OwotCQl0ID0gYXBwcm94aWRhdGVfcmVsYXRpdmUoKmFyZ3YsIG5vdyk7CisJCXQgPSBhcHByb3hpZGF0ZV9yZWxhdGl2ZSgqYXJndik7CiAJCXByaW50ZigiJXMgLT4gJSJQUkl0aW1lIlxuIiwgKmFyZ3YsIHQpOwogCX0KIH0KQEAgLTEwMywyMiArMTAzLDEzIEBACiAKIGludCBjbWRfX2RhdGUoaW50IGFyZ2MsIGNvbnN0IGNoYXIgKiphcmd2KQogewotCXN0cnVjdCB0aW1ldmFsIG5vdzsKIAljb25zdCBjaGFyICp4OwogCi0JeCA9IGdldGVudigiR0lUX1RFU1RfREFURV9OT1ciKTsKLQlpZiAoeCkgewotCQlub3cudHZfc2VjID0gYXRvaSh4KTsKLQkJbm93LnR2X3VzZWMgPSAwOwotCX0KLQllbHNlCi0JCWdldHRpbWVvZmRheSgmbm93LCBOVUxMKTsKLQogCWFyZ3YrKzsKIAlpZiAoISphcmd2KQogCQl1c2FnZSh1c2FnZV9tc2cpOwogCWlmICghc3RyY21wKCphcmd2LCAicmVsYXRpdmUiKSkKLQkJc2hvd19yZWxhdGl2ZV9kYXRlcyhhcmd2KzEsICZub3cpOworCQlzaG93X3JlbGF0aXZlX2RhdGVzKGFyZ3YrMSk7CiAJZWxzZSBpZiAoIXN0cmNtcCgqYXJndiwgImh1bWFuIikpCiAJCXNob3dfaHVtYW5fZGF0ZXMoYXJndisxKTsKIAllbHNlIGlmIChza2lwX3ByZWZpeCgqYXJndiwgInNob3c6IiwgJngpKQpAQCAtMTI2LDkgKzExNyw5IEBACiAJZWxzZSBpZiAoIXN0cmNtcCgqYXJndiwgInBhcnNlIikpCiAJCXBhcnNlX2RhdGVzKGFyZ3YrMSk7CiAJZWxzZSBpZiAoIXN0cmNtcCgqYXJndiwgImFwcHJveGlkYXRlIikpCi0JCXBhcnNlX2FwcHJveGlkYXRlKGFyZ3YrMSwgJm5vdyk7CisJCXBhcnNlX2FwcHJveGlkYXRlKGFyZ3YrMSk7CiAJZWxzZSBpZiAoIXN0cmNtcCgqYXJndiwgInRpbWVzdGFtcCIpKQotCQlwYXJzZV9hcHByb3hfdGltZXN0YW1wKGFyZ3YrMSwgJm5vdyk7CisJCXBhcnNlX2FwcHJveF90aW1lc3RhbXAoYXJndisxKTsKIAllbHNlIGlmICghc3RyY21wKCphcmd2LCAiZ2V0bmFub3MiKSkKIAkJZ2V0bmFub3MoYXJndisxKTsKIAllbHNlIGlmICghc3RyY21wKCphcmd2LCAiaXM2NGJpdCIpKQpkaWZmIC0tZ2l0IGEvdC9oZWxwZXIvdGVzdC1oYXNobWFwLmMgYi90L2hlbHBlci90ZXN0LWhhc2htYXAuYwppbmRleCBhYWYxN2IwLi5mMzg3MDYyIDEwMDY0NAotLS0gYS90L2hlbHBlci90ZXN0LWhhc2htYXAuYworKysgYi90L2hlbHBlci90ZXN0LWhhc2htYXAuYwpAQCAtNSw2ICs1LDcgQEAKIAogc3RydWN0IHRlc3RfZW50cnkKIHsKKwlpbnQgcGFkZGluZzsgLyogaGFzaG1hcCBlbnRyeSBubyBsb25nZXIgbmVlZHMgdG8gYmUgdGhlIGZpcnN0IG1lbWJlciAqLwogCXN0cnVjdCBoYXNobWFwX2VudHJ5IGVudDsKIAkvKiBrZXkgYW5kIHZhbHVlIGFzIHR3byBcMC10ZXJtaW5hdGVkIHN0cmluZ3MgKi8KIAljaGFyIGtleVtGTEVYX0FSUkFZXTsKQEAgLTE2LDE1ICsxNywxNyBAQAogfQogCiBzdGF0aWMgaW50IHRlc3RfZW50cnlfY21wKGNvbnN0IHZvaWQgKmNtcF9kYXRhLAotCQkJICBjb25zdCB2b2lkICplbnRyeSwKLQkJCSAgY29uc3Qgdm9pZCAqZW50cnlfb3Jfa2V5LAorCQkJICBjb25zdCBzdHJ1Y3QgaGFzaG1hcF9lbnRyeSAqZXB0ciwKKwkJCSAgY29uc3Qgc3RydWN0IGhhc2htYXBfZW50cnkgKmVudHJ5X29yX2tleSwKIAkJCSAgY29uc3Qgdm9pZCAqa2V5ZGF0YSkKIHsKIAljb25zdCBpbnQgaWdub3JlX2Nhc2UgPSBjbXBfZGF0YSA/ICooKGludCAqKWNtcF9kYXRhKSA6IDA7Ci0JY29uc3Qgc3RydWN0IHRlc3RfZW50cnkgKmUxID0gZW50cnk7Ci0JY29uc3Qgc3RydWN0IHRlc3RfZW50cnkgKmUyID0gZW50cnlfb3Jfa2V5OworCWNvbnN0IHN0cnVjdCB0ZXN0X2VudHJ5ICplMSwgKmUyOwogCWNvbnN0IGNoYXIgKmtleSA9IGtleWRhdGE7CiAKKwllMSA9IGNvbnRhaW5lcl9vZihlcHRyLCBjb25zdCBzdHJ1Y3QgdGVzdF9lbnRyeSwgZW50KTsKKwllMiA9IGNvbnRhaW5lcl9vZihlbnRyeV9vcl9rZXksIGNvbnN0IHN0cnVjdCB0ZXN0X2VudHJ5LCBlbnQpOworCiAJaWYgKGlnbm9yZV9jYXNlKQogCQlyZXR1cm4gc3RyY2FzZWNtcChlMS0+a2V5LCBrZXkgPyBrZXkgOiBlMi0+a2V5KTsKIAllbHNlCkBAIC0zNyw3ICs0MCw3IEBACiAJc2l6ZV90IGtsZW4gPSBzdHJsZW4oa2V5KTsKIAlzaXplX3QgdmxlbiA9IHN0cmxlbih2YWx1ZSk7CiAJc3RydWN0IHRlc3RfZW50cnkgKmVudHJ5ID0geG1hbGxvYyhzdF9hZGQ0KHNpemVvZigqZW50cnkpLCBrbGVuLCB2bGVuLCAyKSk7Ci0JaGFzaG1hcF9lbnRyeV9pbml0KGVudHJ5LCBoYXNoKTsKKwloYXNobWFwX2VudHJ5X2luaXQoJmVudHJ5LT5lbnQsIGhhc2gpOwogCW1lbWNweShlbnRyeS0+a2V5LCBrZXksIGtsZW4gKyAxKTsKIAltZW1jcHkoZW50cnktPmtleSArIGtsZW4gKyAxLCB2YWx1ZSwgdmxlbiArIDEpOwogCXJldHVybiBlbnRyeTsKQEAgLTEwMywxMSArMTA2LDExIEBACiAKIAkJCS8qIGFkZCBlbnRyaWVzICovCiAJCQlmb3IgKGkgPSAwOyBpIDwgVEVTVF9TSVpFOyBpKyspIHsKLQkJCQloYXNobWFwX2VudHJ5X2luaXQoZW50cmllc1tpXSwgaGFzaGVzW2ldKTsKLQkJCQloYXNobWFwX2FkZCgmbWFwLCBlbnRyaWVzW2ldKTsKKwkJCQloYXNobWFwX2VudHJ5X2luaXQoJmVudHJpZXNbaV0tPmVudCwgaGFzaGVzW2ldKTsKKwkJCQloYXNobWFwX2FkZCgmbWFwLCAmZW50cmllc1tpXS0+ZW50KTsKIAkJCX0KIAotCQkJaGFzaG1hcF9mcmVlKCZtYXAsIDApOworCQkJaGFzaG1hcF9mcmVlKCZtYXApOwogCQl9CiAJfSBlbHNlIHsKIAkJLyogdGVzdCBtYXAgbG9va3VwcyAqLwpAQCAtMTE2LDggKzExOSw4IEBACiAJCS8qIGZpbGwgdGhlIG1hcCAoc3BhcnNlbHkgaWYgc3BlY2lmaWVkKSAqLwogCQlqID0gKG1ldGhvZCAmIFRFU1RfU1BBUlNFKSA/IFRFU1RfU0laRSAvIDEwIDogVEVTVF9TSVpFOwogCQlmb3IgKGkgPSAwOyBpIDwgajsgaSsrKSB7Ci0JCQloYXNobWFwX2VudHJ5X2luaXQoZW50cmllc1tpXSwgaGFzaGVzW2ldKTsKLQkJCWhhc2htYXBfYWRkKCZtYXAsIGVudHJpZXNbaV0pOworCQkJaGFzaG1hcF9lbnRyeV9pbml0KCZlbnRyaWVzW2ldLT5lbnQsIGhhc2hlc1tpXSk7CisJCQloYXNobWFwX2FkZCgmbWFwLCAmZW50cmllc1tpXS0+ZW50KTsKIAkJfQogCiAJCWZvciAoaiA9IDA7IGogPCByb3VuZHM7IGorKykgewpAQCAtMTI3LDcgKzEzMCw3IEBACiAJCQl9CiAJCX0KIAotCQloYXNobWFwX2ZyZWUoJm1hcCwgMCk7CisJCWhhc2htYXBfZnJlZSgmbWFwKTsKIAl9CiB9CiAKQEAgLTE3OSw3ICsxODIsNyBAQAogCQkJZW50cnkgPSBhbGxvY190ZXN0X2VudHJ5KGhhc2gsIHAxLCBwMik7CiAKIAkJCS8qIGFkZCB0byBoYXNobWFwICovCi0JCQloYXNobWFwX2FkZCgmbWFwLCBlbnRyeSk7CisJCQloYXNobWFwX2FkZCgmbWFwLCAmZW50cnktPmVudCk7CiAKIAkJfSBlbHNlIGlmICghc3RyY21wKCJwdXQiLCBjbWQpICYmIHAxICYmIHAyKSB7CiAKQEAgLTE4Nyw0MyArMTkwLDQ0IEBACiAJCQllbnRyeSA9IGFsbG9jX3Rlc3RfZW50cnkoaGFzaCwgcDEsIHAyKTsKIAogCQkJLyogYWRkIC8gcmVwbGFjZSBlbnRyeSAqLwotCQkJZW50cnkgPSBoYXNobWFwX3B1dCgmbWFwLCBlbnRyeSk7CisJCQllbnRyeSA9IGhhc2htYXBfcHV0X2VudHJ5KCZtYXAsIGVudHJ5LCBlbnQpOwogCiAJCQkvKiBwcmludCBhbmQgZnJlZSByZXBsYWNlZCBlbnRyeSwgaWYgYW55ICovCiAJCQlwdXRzKGVudHJ5ID8gZ2V0X3ZhbHVlKGVudHJ5KSA6ICJOVUxMIik7CiAJCQlmcmVlKGVudHJ5KTsKIAogCQl9IGVsc2UgaWYgKCFzdHJjbXAoImdldCIsIGNtZCkgJiYgcDEpIHsKLQogCQkJLyogbG9va3VwIGVudHJ5IGluIGhhc2htYXAgKi8KLQkJCWVudHJ5ID0gaGFzaG1hcF9nZXRfZnJvbV9oYXNoKCZtYXAsIGhhc2gsIHAxKTsKKwkJCWVudHJ5ID0gaGFzaG1hcF9nZXRfZW50cnlfZnJvbV9oYXNoKCZtYXAsIGhhc2gsIHAxLAorCQkJCQkJCXN0cnVjdCB0ZXN0X2VudHJ5LCBlbnQpOwogCiAJCQkvKiBwcmludCByZXN1bHQgKi8KIAkJCWlmICghZW50cnkpCiAJCQkJcHV0cygiTlVMTCIpOwotCQkJd2hpbGUgKGVudHJ5KSB7CisJCQloYXNobWFwX2Zvcl9lYWNoX2VudHJ5X2Zyb20oJm1hcCwgZW50cnksIGVudCkKIAkJCQlwdXRzKGdldF92YWx1ZShlbnRyeSkpOwotCQkJCWVudHJ5ID0gaGFzaG1hcF9nZXRfbmV4dCgmbWFwLCBlbnRyeSk7Ci0JCQl9CiAKIAkJfSBlbHNlIGlmICghc3RyY21wKCJyZW1vdmUiLCBjbWQpICYmIHAxKSB7CiAKIAkJCS8qIHNldHVwIHN0YXRpYyBrZXkgKi8KIAkJCXN0cnVjdCBoYXNobWFwX2VudHJ5IGtleTsKKwkJCXN0cnVjdCBoYXNobWFwX2VudHJ5ICpybTsKIAkJCWhhc2htYXBfZW50cnlfaW5pdCgma2V5LCBoYXNoKTsKIAogCQkJLyogcmVtb3ZlIGVudHJ5IGZyb20gaGFzaG1hcCAqLwotCQkJZW50cnkgPSBoYXNobWFwX3JlbW92ZSgmbWFwLCAma2V5LCBwMSk7CisJCQlybSA9IGhhc2htYXBfcmVtb3ZlKCZtYXAsICZrZXksIHAxKTsKKwkJCWVudHJ5ID0gcm0gPyBjb250YWluZXJfb2Yocm0sIHN0cnVjdCB0ZXN0X2VudHJ5LCBlbnQpCisJCQkJCTogTlVMTDsKIAogCQkJLyogcHJpbnQgcmVzdWx0IGFuZCBmcmVlIGVudHJ5Ki8KIAkJCXB1dHMoZW50cnkgPyBnZXRfdmFsdWUoZW50cnkpIDogIk5VTEwiKTsKIAkJCWZyZWUoZW50cnkpOwogCiAJCX0gZWxzZSBpZiAoIXN0cmNtcCgiaXRlcmF0ZSIsIGNtZCkpIHsKLQogCQkJc3RydWN0IGhhc2htYXBfaXRlciBpdGVyOwotCQkJaGFzaG1hcF9pdGVyX2luaXQoJm1hcCwgJml0ZXIpOwotCQkJd2hpbGUgKChlbnRyeSA9IGhhc2htYXBfaXRlcl9uZXh0KCZpdGVyKSkpCisKKwkJCWhhc2htYXBfZm9yX2VhY2hfZW50cnkoJm1hcCwgJml0ZXIsIGVudHJ5LAorCQkJCQkJZW50IC8qIG1lbWJlciBuYW1lICovKQogCQkJCXByaW50ZigiJXMgJXNcbiIsIGVudHJ5LT5rZXksIGdldF92YWx1ZShlbnRyeSkpOwogCiAJCX0gZWxzZSBpZiAoIXN0cmNtcCgic2l6ZSIsIGNtZCkpIHsKQEAgLTI1OCw2ICsyNjIsNiBAQAogCX0KIAogCXN0cmJ1Zl9yZWxlYXNlKCZsaW5lKTsKLQloYXNobWFwX2ZyZWUoJm1hcCwgMSk7CisJaGFzaG1hcF9mcmVlX2VudHJpZXMoJm1hcCwgc3RydWN0IHRlc3RfZW50cnksIGVudCk7CiAJcmV0dXJuIDA7CiB9CmRpZmYgLS1naXQgYS90L2hlbHBlci90ZXN0LWxhenktaW5pdC1uYW1lLWhhc2guYyBiL3QvaGVscGVyL3Rlc3QtbGF6eS1pbml0LW5hbWUtaGFzaC5jCmluZGV4IGI5OWEzNzAuLmNkMWI0YzkgMTAwNjQ0Ci0tLSBhL3QvaGVscGVyL3Rlc3QtbGF6eS1pbml0LW5hbWUtaGFzaC5jCisrKyBiL3QvaGVscGVyL3Rlc3QtbGF6eS1pbml0LW5hbWUtaGFzaC5jCkBAIC00MSwxNyArNDEsMTMgQEAKIAkJCWRpZSgibm9uLXRocmVhZGVkIGNvZGUgcGF0aCB1c2VkIik7CiAJfQogCi0JZGlyID0gaGFzaG1hcF9pdGVyX2ZpcnN0KCZ0aGVfaW5kZXguZGlyX2hhc2gsICZpdGVyX2Rpcik7Ci0Jd2hpbGUgKGRpcikgeworCWhhc2htYXBfZm9yX2VhY2hfZW50cnkoJnRoZV9pbmRleC5kaXJfaGFzaCwgJml0ZXJfZGlyLCBkaXIsCisJCQkJZW50IC8qIG1lbWJlciBuYW1lICovKQogCQlwcmludGYoImRpciAlMDh4ICU3ZCAlc1xuIiwgZGlyLT5lbnQuaGFzaCwgZGlyLT5uciwgZGlyLT5uYW1lKTsKLQkJZGlyID0gaGFzaG1hcF9pdGVyX25leHQoJml0ZXJfZGlyKTsKLQl9CiAKLQljZSA9IGhhc2htYXBfaXRlcl9maXJzdCgmdGhlX2luZGV4Lm5hbWVfaGFzaCwgJml0ZXJfY2FjaGUpOwotCXdoaWxlIChjZSkgeworCWhhc2htYXBfZm9yX2VhY2hfZW50cnkoJnRoZV9pbmRleC5uYW1lX2hhc2gsICZpdGVyX2NhY2hlLCBjZSwKKwkJCQllbnQgLyogbWVtYmVyIG5hbWUgKi8pCiAJCXByaW50ZigibmFtZSAlMDh4ICVzXG4iLCBjZS0+ZW50Lmhhc2gsIGNlLT5uYW1lKTsKLQkJY2UgPSBoYXNobWFwX2l0ZXJfbmV4dCgmaXRlcl9jYWNoZSk7Ci0JfQogCiAJZGlzY2FyZF9jYWNoZSgpOwogfQpkaWZmIC0tZ2l0IGEvdC9oZWxwZXIvdGVzdC1wcm9ncmVzcy5jIGIvdC9oZWxwZXIvdGVzdC1wcm9ncmVzcy5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjQyYjk2Y2IKLS0tIC9kZXYvbnVsbAorKysgYi90L2hlbHBlci90ZXN0LXByb2dyZXNzLmMKQEAgLTAsMCArMSw4MSBAQAorLyoKKyAqIEEgdGVzdCBoZWxwZXIgdG8gZXhlcmNpc2UgdGhlIHByb2dyZXNzIGRpc3BsYXkuCisgKgorICogUmVhZHMgaW5zdHJ1Y3Rpb25zIGZyb20gc3RhbmRhcmQgaW5wdXQsIG9uZSBpbnN0cnVjdGlvbiBwZXIgbGluZToKKyAqCisgKiAgICJwcm9ncmVzcyA8aXRlbXM+IiAtIENhbGwgZGlzcGxheV9wcm9ncmVzcygpIHdpdGggdGhlIGdpdmVuIGl0ZW0gY291bnQKKyAqICAgICAgICAgICAgICAgICAgICAgICAgYXMgcGFyYW1ldGVyLgorICogICAidGhyb3VnaHB1dCA8Ynl0ZXM+IDxtaWxsaXM+IC0gQ2FsbCBkaXNwbGF5X3Rocm91Z2hwdXQoKSB3aXRoIHRoZSBnaXZlbgorICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgYnl0ZSBjb3VudCBhcyBwYXJhbWV0ZXIuICBUaGUgJ21pbGxpcycKKyAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHNwZWNpZnkgdGhlIHRpbWUgZWxhcHNlZCBzaW5jZSB0aGUKKyAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHN0YXJ0X3Byb2dyZXNzKCkgY2FsbC4KKyAqICAgInVwZGF0ZSIgLSBTZXQgdGhlICdwcm9ncmVzc191cGRhdGUnIGZsYWcuCisgKgorICogU2VlICd0MDUwMC1wcm9ncmVzcy1kaXNwbGF5LnNoJyBmb3IgZXhhbXBsZXMuCisgKi8KKyNpbmNsdWRlICJ0ZXN0LXRvb2wuaCIKKyNpbmNsdWRlICJnZXR0ZXh0LmgiCisjaW5jbHVkZSAicGFyc2Utb3B0aW9ucy5oIgorI2luY2x1ZGUgInByb2dyZXNzLmgiCisjaW5jbHVkZSAic3RyYnVmLmgiCisKKy8qCisgKiBUaGVzZSBhcmUgZGVmaW5lZCBpbiAncHJvZ3Jlc3MuYycsIGJ1dCBhcmUgbm90IGV4cG9zZWQgaW4gJ3Byb2dyZXNzLmgnLAorICogYmVjYXVzZSB0aGV5IGFyZSBleGNsdXNpdmVseSBmb3IgdGVzdGluZy4KKyAqLworZXh0ZXJuIGludCBwcm9ncmVzc190ZXN0aW5nOworZXh0ZXJuIHVpbnQ2NF90IHByb2dyZXNzX3Rlc3RfbnM7Cit2b2lkIHByb2dyZXNzX3Rlc3RfZm9yY2VfdXBkYXRlKHZvaWQpOworCitpbnQgY21kX19wcm9ncmVzcyhpbnQgYXJnYywgY29uc3QgY2hhciAqKmFyZ3YpCit7CisJaW50IHRvdGFsID0gMDsKKwljb25zdCBjaGFyICp0aXRsZTsKKwlzdHJ1Y3Qgc3RyYnVmIGxpbmUgPSBTVFJCVUZfSU5JVDsKKwlzdHJ1Y3QgcHJvZ3Jlc3MgKnByb2dyZXNzOworCisJY29uc3QgY2hhciAqdXNhZ2VbXSA9IHsKKwkJInRlc3QtdG9vbCBwcm9ncmVzcyBbLS10b3RhbD08bj5dIDxwcm9ncmVzcy10aXRsZT4iLAorCQlOVUxMCisJfTsKKwlzdHJ1Y3Qgb3B0aW9uIG9wdGlvbnNbXSA9IHsKKwkJT1BUX0lOVEVHRVIoMCwgInRvdGFsIiwgJnRvdGFsLCAidG90YWwgbnVtYmVyIG9mIGl0ZW1zIiksCisJCU9QVF9FTkQoKSwKKwl9OworCisJYXJnYyA9IHBhcnNlX29wdGlvbnMoYXJnYywgYXJndiwgTlVMTCwgb3B0aW9ucywgdXNhZ2UsIDApOworCWlmIChhcmdjICE9IDEpCisJCWRpZSgibmVlZCBhIHRpdGxlIGZvciB0aGUgcHJvZ3Jlc3Mgb3V0cHV0Iik7CisJdGl0bGUgPSBhcmd2WzBdOworCisJcHJvZ3Jlc3NfdGVzdGluZyA9IDE7CisJcHJvZ3Jlc3MgPSBzdGFydF9wcm9ncmVzcyh0aXRsZSwgdG90YWwpOworCXdoaWxlIChzdHJidWZfZ2V0bGluZSgmbGluZSwgc3RkaW4pICE9IEVPRikgeworCQljaGFyICplbmQ7CisKKwkJaWYgKHNraXBfcHJlZml4KGxpbmUuYnVmLCAicHJvZ3Jlc3MgIiwgKGNvbnN0IGNoYXIgKiopICZlbmQpKSB7CisJCQl1aW50NjRfdCBpdGVtX2NvdW50ID0gc3RydG91bGwoZW5kLCAmZW5kLCAxMCk7CisJCQlpZiAoKmVuZCAhPSAnXDAnKQorCQkJCWRpZSgiaW52YWxpZCBpbnB1dDogJyVzJ1xuIiwgbGluZS5idWYpOworCQkJZGlzcGxheV9wcm9ncmVzcyhwcm9ncmVzcywgaXRlbV9jb3VudCk7CisJCX0gZWxzZSBpZiAoc2tpcF9wcmVmaXgobGluZS5idWYsICJ0aHJvdWdocHV0ICIsCisJCQkJICAgICAgIChjb25zdCBjaGFyICoqKSAmZW5kKSkgeworCQkJdWludDY0X3QgYnl0ZV9jb3VudCwgdGVzdF9tczsKKworCQkJYnl0ZV9jb3VudCA9IHN0cnRvdWxsKGVuZCwgJmVuZCwgMTApOworCQkJaWYgKCplbmQgIT0gJyAnKQorCQkJCWRpZSgiaW52YWxpZCBpbnB1dDogJyVzJ1xuIiwgbGluZS5idWYpOworCQkJdGVzdF9tcyA9IHN0cnRvdWxsKGVuZCArIDEsICZlbmQsIDEwKTsKKwkJCWlmICgqZW5kICE9ICdcMCcpCisJCQkJZGllKCJpbnZhbGlkIGlucHV0OiAnJXMnXG4iLCBsaW5lLmJ1Zik7CisJCQlwcm9ncmVzc190ZXN0X25zID0gdGVzdF9tcyAqIDEwMDAgKiAxMDAwOworCQkJZGlzcGxheV90aHJvdWdocHV0KHByb2dyZXNzLCBieXRlX2NvdW50KTsKKwkJfSBlbHNlIGlmICghc3RyY21wKGxpbmUuYnVmLCAidXBkYXRlIikpCisJCQlwcm9ncmVzc190ZXN0X2ZvcmNlX3VwZGF0ZSgpOworCQllbHNlCisJCQlkaWUoImludmFsaWQgaW5wdXQ6ICclcydcbiIsIGxpbmUuYnVmKTsKKwl9CisJc3RvcF9wcm9ncmVzcygmcHJvZ3Jlc3MpOworCisJcmV0dXJuIDA7Cit9CmRpZmYgLS1naXQgYS90L2hlbHBlci90ZXN0LXJlYWQtY2FjaGUuYyBiL3QvaGVscGVyL3Rlc3QtcmVhZC1jYWNoZS5jCmluZGV4IDdlNzliNTUuLjI0NDk3N2EgMTAwNjQ0Ci0tLSBhL3QvaGVscGVyL3Rlc3QtcmVhZC1jYWNoZS5jCisrKyBiL3QvaGVscGVyL3Rlc3QtcmVhZC1jYWNoZS5jCkBAIC00LDExICs0LDEwIEBACiAKIGludCBjbWRfX3JlYWRfY2FjaGUoaW50IGFyZ2MsIGNvbnN0IGNoYXIgKiphcmd2KQogewotCWludCBpLCBjbnQgPSAxLCBuYW1lbGVuOworCWludCBpLCBjbnQgPSAxOwogCWNvbnN0IGNoYXIgKm5hbWUgPSBOVUxMOwogCiAJaWYgKGFyZ2MgPiAxICYmIHNraXBfcHJlZml4KGFyZ3ZbMV0sICItLXByaW50LWFuZC1yZWZyZXNoPSIsICZuYW1lKSkgewotCQluYW1lbGVuID0gc3RybGVuKG5hbWUpOwogCQlhcmdjLS07CiAJCWFyZ3YrKzsKIAl9CkBAIC0yNCw3ICsyMyw3IEBACiAKIAkJCXJlZnJlc2hfaW5kZXgoJnRoZV9pbmRleCwgUkVGUkVTSF9RVUlFVCwKIAkJCQkgICAgICBOVUxMLCBOVUxMLCBOVUxMKTsKLQkJCXBvcyA9IGluZGV4X25hbWVfcG9zKCZ0aGVfaW5kZXgsIG5hbWUsIG5hbWVsZW4pOworCQkJcG9zID0gaW5kZXhfbmFtZV9wb3MoJnRoZV9pbmRleCwgbmFtZSwgc3RybGVuKG5hbWUpKTsKIAkJCWlmIChwb3MgPCAwKQogCQkJCWRpZSgiJXMgbm90IGluIGluZGV4IiwgbmFtZSk7CiAJCQlwcmludGYoIiVzIGlzJXMgdXAgdG8gZGF0ZVxuIiwgbmFtZSwKZGlmZiAtLWdpdCBhL3QvaGVscGVyL3Rlc3QtcmVhZC1ncmFwaC5jIGIvdC9oZWxwZXIvdGVzdC1yZWFkLWdyYXBoLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZDI4ODRlZgotLS0gL2Rldi9udWxsCisrKyBiL3QvaGVscGVyL3Rlc3QtcmVhZC1ncmFwaC5jCkBAIC0wLDAgKzEsNTMgQEAKKyNpbmNsdWRlICJ0ZXN0LXRvb2wuaCIKKyNpbmNsdWRlICJjYWNoZS5oIgorI2luY2x1ZGUgImNvbW1pdC1ncmFwaC5oIgorI2luY2x1ZGUgInJlcG9zaXRvcnkuaCIKKyNpbmNsdWRlICJvYmplY3Qtc3RvcmUuaCIKKworaW50IGNtZF9fcmVhZF9ncmFwaChpbnQgYXJnYywgY29uc3QgY2hhciAqKmFyZ3YpCit7CisJc3RydWN0IGNvbW1pdF9ncmFwaCAqZ3JhcGggPSBOVUxMOworCWNoYXIgKmdyYXBoX25hbWU7CisJaW50IG9wZW5fb2s7CisJaW50IGZkOworCXN0cnVjdCBzdGF0IHN0OworCWNvbnN0IGNoYXIgKm9iamVjdF9kaXI7CisKKwlzZXR1cF9naXRfZGlyZWN0b3J5KCk7CisJb2JqZWN0X2RpciA9IGdldF9vYmplY3RfZGlyZWN0b3J5KCk7CisKKwlncmFwaF9uYW1lID0gZ2V0X2NvbW1pdF9ncmFwaF9maWxlbmFtZShvYmplY3RfZGlyKTsKKworCW9wZW5fb2sgPSBvcGVuX2NvbW1pdF9ncmFwaChncmFwaF9uYW1lLCAmZmQsICZzdCk7CisJaWYgKCFvcGVuX29rKQorCQlkaWVfZXJybm8oXygiQ291bGQgbm90IG9wZW4gY29tbWl0LWdyYXBoICclcyciKSwgZ3JhcGhfbmFtZSk7CisKKwlncmFwaCA9IGxvYWRfY29tbWl0X2dyYXBoX29uZV9mZF9zdChmZCwgJnN0KTsKKwlpZiAoIWdyYXBoKQorCQlyZXR1cm4gMTsKKworCUZSRUVfQU5EX05VTEwoZ3JhcGhfbmFtZSk7CisKKwlwcmludGYoImhlYWRlcjogJTA4eCAlZCAlZCAlZCAlZFxuIiwKKwkJbnRvaGwoKih1aW50MzJfdCopZ3JhcGgtPmRhdGEpLAorCQkqKHVuc2lnbmVkIGNoYXIqKShncmFwaC0+ZGF0YSArIDQpLAorCQkqKHVuc2lnbmVkIGNoYXIqKShncmFwaC0+ZGF0YSArIDUpLAorCQkqKHVuc2lnbmVkIGNoYXIqKShncmFwaC0+ZGF0YSArIDYpLAorCQkqKHVuc2lnbmVkIGNoYXIqKShncmFwaC0+ZGF0YSArIDcpKTsKKwlwcmludGYoIm51bV9jb21taXRzOiAldVxuIiwgZ3JhcGgtPm51bV9jb21taXRzKTsKKwlwcmludGYoImNodW5rczoiKTsKKworCWlmIChncmFwaC0+Y2h1bmtfb2lkX2Zhbm91dCkKKwkJcHJpbnRmKCIgb2lkX2Zhbm91dCIpOworCWlmIChncmFwaC0+Y2h1bmtfb2lkX2xvb2t1cCkKKwkJcHJpbnRmKCIgb2lkX2xvb2t1cCIpOworCWlmIChncmFwaC0+Y2h1bmtfY29tbWl0X2RhdGEpCisJCXByaW50ZigiIGNvbW1pdF9tZXRhZGF0YSIpOworCWlmIChncmFwaC0+Y2h1bmtfZXh0cmFfZWRnZXMpCisJCXByaW50ZigiIGV4dHJhX2VkZ2VzIik7CisJcHJpbnRmKCJcbiIpOworCisJVU5MRUFLKGdyYXBoKTsKKworCXJldHVybiAwOworfQpkaWZmIC0tZ2l0IGEvdC9oZWxwZXIvdGVzdC1ydW4tY29tbWFuZC5jIGIvdC9oZWxwZXIvdGVzdC1ydW4tY29tbWFuZC5jCmluZGV4IDJjYzkzYmIuLmVhZDZkYzYgMTAwNjQ0Ci0tLSBhL3QvaGVscGVyL3Rlc3QtcnVuLWNvbW1hbmQuYworKysgYi90L2hlbHBlci90ZXN0LXJ1bi1jb21tYW5kLmMKQEAgLTEwLDkgKzEwLDE0IEBACiAKICNpbmNsdWRlICJ0ZXN0LXRvb2wuaCIKICNpbmNsdWRlICJnaXQtY29tcGF0LXV0aWwuaCIKKyNpbmNsdWRlICJjYWNoZS5oIgogI2luY2x1ZGUgInJ1bi1jb21tYW5kLmgiCiAjaW5jbHVkZSAiYXJndi1hcnJheS5oIgogI2luY2x1ZGUgInN0cmJ1Zi5oIgorI2luY2x1ZGUgInBhcnNlLW9wdGlvbnMuaCIKKyNpbmNsdWRlICJzdHJpbmctbGlzdC5oIgorI2luY2x1ZGUgInRocmVhZC11dGlscy5oIgorI2luY2x1ZGUgIndpbGRtYXRjaC5oIgogI2luY2x1ZGUgPHN0cmluZy5oPgogI2luY2x1ZGUgPGVycm5vLmg+CiAKQEAgLTUwLDExICs1NSwxNTkgQEAKIAlyZXR1cm4gMTsKIH0KIAorc3RydWN0IHRlc3RzdWl0ZSB7CisJc3RydWN0IHN0cmluZ19saXN0IHRlc3RzLCBmYWlsZWQ7CisJaW50IG5leHQ7CisJaW50IHF1aWV0LCBpbW1lZGlhdGUsIHZlcmJvc2UsIHZlcmJvc2VfbG9nLCB0cmFjZSwgd3JpdGVfanVuaXRfeG1sOworfTsKKyNkZWZpbmUgVEVTVFNVSVRFX0lOSVQgXAorCXsgU1RSSU5HX0xJU1RfSU5JVF9EVVAsIFNUUklOR19MSVNUX0lOSVRfRFVQLCAtMSwgMCwgMCwgMCwgMCwgMCwgMCB9CisKK3N0YXRpYyBpbnQgbmV4dF90ZXN0KHN0cnVjdCBjaGlsZF9wcm9jZXNzICpjcCwgc3RydWN0IHN0cmJ1ZiAqZXJyLCB2b2lkICpjYiwKKwkJICAgICB2b2lkICoqdGFza19jYikKK3sKKwlzdHJ1Y3QgdGVzdHN1aXRlICpzdWl0ZSA9IGNiOworCWNvbnN0IGNoYXIgKnRlc3Q7CisJaWYgKHN1aXRlLT5uZXh0ID49IHN1aXRlLT50ZXN0cy5ucikKKwkJcmV0dXJuIDA7CisKKwl0ZXN0ID0gc3VpdGUtPnRlc3RzLml0ZW1zW3N1aXRlLT5uZXh0KytdLnN0cmluZzsKKwlhcmd2X2FycmF5X3B1c2hsKCZjcC0+YXJncywgInNoIiwgdGVzdCwgTlVMTCk7CisJaWYgKHN1aXRlLT5xdWlldCkKKwkJYXJndl9hcnJheV9wdXNoKCZjcC0+YXJncywgIi0tcXVpZXQiKTsKKwlpZiAoc3VpdGUtPmltbWVkaWF0ZSkKKwkJYXJndl9hcnJheV9wdXNoKCZjcC0+YXJncywgIi1pIik7CisJaWYgKHN1aXRlLT52ZXJib3NlKQorCQlhcmd2X2FycmF5X3B1c2goJmNwLT5hcmdzLCAiLXYiKTsKKwlpZiAoc3VpdGUtPnZlcmJvc2VfbG9nKQorCQlhcmd2X2FycmF5X3B1c2goJmNwLT5hcmdzLCAiLVYiKTsKKwlpZiAoc3VpdGUtPnRyYWNlKQorCQlhcmd2X2FycmF5X3B1c2goJmNwLT5hcmdzLCAiLXgiKTsKKwlpZiAoc3VpdGUtPndyaXRlX2p1bml0X3htbCkKKwkJYXJndl9hcnJheV9wdXNoKCZjcC0+YXJncywgIi0td3JpdGUtanVuaXQteG1sIik7CisKKwlzdHJidWZfYWRkZihlcnIsICJPdXRwdXQgb2YgJyVzJzpcbiIsIHRlc3QpOworCSp0YXNrX2NiID0gKHZvaWQgKil0ZXN0OworCisJcmV0dXJuIDE7Cit9CisKK3N0YXRpYyBpbnQgdGVzdF9maW5pc2hlZChpbnQgcmVzdWx0LCBzdHJ1Y3Qgc3RyYnVmICplcnIsIHZvaWQgKmNiLAorCQkJIHZvaWQgKnRhc2tfY2IpCit7CisJc3RydWN0IHRlc3RzdWl0ZSAqc3VpdGUgPSBjYjsKKwljb25zdCBjaGFyICpuYW1lID0gKGNvbnN0IGNoYXIgKil0YXNrX2NiOworCisJaWYgKHJlc3VsdCkKKwkJc3RyaW5nX2xpc3RfYXBwZW5kKCZzdWl0ZS0+ZmFpbGVkLCBuYW1lKTsKKworCXN0cmJ1Zl9hZGRmKGVyciwgIiVzOiAnJXMnXG4iLCByZXN1bHQgPyAiRkFJTCIgOiAiU1VDQ0VTUyIsIG5hbWUpOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgdGVzdF9mYWlsZWQoc3RydWN0IHN0cmJ1ZiAqb3V0LCB2b2lkICpjYiwgdm9pZCAqdGFza19jYikKK3sKKwlzdHJ1Y3QgdGVzdHN1aXRlICpzdWl0ZSA9IGNiOworCWNvbnN0IGNoYXIgKm5hbWUgPSAoY29uc3QgY2hhciAqKXRhc2tfY2I7CisKKwlzdHJpbmdfbGlzdF9hcHBlbmQoJnN1aXRlLT5mYWlsZWQsIG5hbWUpOworCXN0cmJ1Zl9hZGRmKG91dCwgIkZBSUxFRCBUTyBTVEFSVDogJyVzJ1xuIiwgbmFtZSk7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCB0ZXN0c3VpdGVfdXNhZ2VbXSA9IHsKKwkidGVzdC1ydW4tY29tbWFuZCB0ZXN0c3VpdGUgWzxvcHRpb25zPl0gWzxwYXR0ZXJuPi4uLl0iLAorCU5VTEwKK307CisKK3N0YXRpYyBpbnQgdGVzdHN1aXRlKGludCBhcmdjLCBjb25zdCBjaGFyICoqYXJndikKK3sKKwlzdHJ1Y3QgdGVzdHN1aXRlIHN1aXRlID0gVEVTVFNVSVRFX0lOSVQ7CisJaW50IG1heF9qb2JzID0gMSwgaSwgcmV0OworCURJUiAqZGlyOworCXN0cnVjdCBkaXJlbnQgKmQ7CisJc3RydWN0IG9wdGlvbiBvcHRpb25zW10gPSB7CisJCU9QVF9CT09MKCdpJywgImltbWVkaWF0ZSIsICZzdWl0ZS5pbW1lZGlhdGUsCisJCQkgInN0b3AgYXQgZmlyc3QgZmFpbGVkIHRlc3QgY2FzZShzKSIpLAorCQlPUFRfSU5URUdFUignaicsICJqb2JzIiwgJm1heF9qb2JzLCAicnVuIDxOPiBqb2JzIGluIHBhcmFsbGVsIiksCisJCU9QVF9CT09MKCdxJywgInF1aWV0IiwgJnN1aXRlLnF1aWV0LCAiYmUgdGVyc2UiKSwKKwkJT1BUX0JPT0woJ3YnLCAidmVyYm9zZSIsICZzdWl0ZS52ZXJib3NlLCAiYmUgdmVyYm9zZSIpLAorCQlPUFRfQk9PTCgnVicsICJ2ZXJib3NlLWxvZyIsICZzdWl0ZS52ZXJib3NlX2xvZywKKwkJCSAiYmUgdmVyYm9zZSwgcmVkaXJlY3RlZCB0byBhIGZpbGUiKSwKKwkJT1BUX0JPT0woJ3gnLCAidHJhY2UiLCAmc3VpdGUudHJhY2UsICJ0cmFjZSBzaGVsbCBjb21tYW5kcyIpLAorCQlPUFRfQk9PTCgwLCAid3JpdGUtanVuaXQteG1sIiwgJnN1aXRlLndyaXRlX2p1bml0X3htbCwKKwkJCSAid3JpdGUgSlVuaXQtc3R5bGUgWE1MIGZpbGVzIiksCisJCU9QVF9FTkQoKQorCX07CisKKwltZW1zZXQoJnN1aXRlLCAwLCBzaXplb2Yoc3VpdGUpKTsKKwlzdWl0ZS50ZXN0cy5zdHJkdXBfc3RyaW5ncyA9IHN1aXRlLmZhaWxlZC5zdHJkdXBfc3RyaW5ncyA9IDE7CisKKwlhcmdjID0gcGFyc2Vfb3B0aW9ucyhhcmdjLCBhcmd2LCBOVUxMLCBvcHRpb25zLAorCQkJdGVzdHN1aXRlX3VzYWdlLCBQQVJTRV9PUFRfU1RPUF9BVF9OT05fT1BUSU9OKTsKKworCWlmIChtYXhfam9icyA8PSAwKQorCQltYXhfam9icyA9IG9ubGluZV9jcHVzKCk7CisKKwlkaXIgPSBvcGVuZGlyKCIuIik7CisJaWYgKCFkaXIpCisJCWRpZSgiQ291bGQgbm90IG9wZW4gdGhlIGN1cnJlbnQgZGlyZWN0b3J5Iik7CisJd2hpbGUgKChkID0gcmVhZGRpcihkaXIpKSkgeworCQljb25zdCBjaGFyICpwID0gZC0+ZF9uYW1lOworCisJCWlmICgqcCAhPSAndCcgfHwgIWlzZGlnaXQocFsxXSkgfHwgIWlzZGlnaXQocFsyXSkgfHwKKwkJICAgICFpc2RpZ2l0KHBbM10pIHx8ICFpc2RpZ2l0KHBbNF0pIHx8IHBbNV0gIT0gJy0nIHx8CisJCSAgICAhZW5kc193aXRoKHAsICIuc2giKSkKKwkJCWNvbnRpbnVlOworCisJCS8qIE5vIHBhdHRlcm46IG1hdGNoIGFsbCAqLworCQlpZiAoIWFyZ2MpIHsKKwkJCXN0cmluZ19saXN0X2FwcGVuZCgmc3VpdGUudGVzdHMsIHApOworCQkJY29udGludWU7CisJCX0KKworCQlmb3IgKGkgPSAwOyBpIDwgYXJnYzsgaSsrKQorCQkJaWYgKCF3aWxkbWF0Y2goYXJndltpXSwgcCwgMCkpIHsKKwkJCQlzdHJpbmdfbGlzdF9hcHBlbmQoJnN1aXRlLnRlc3RzLCBwKTsKKwkJCQlicmVhazsKKwkJCX0KKwl9CisJY2xvc2VkaXIoZGlyKTsKKworCWlmICghc3VpdGUudGVzdHMubnIpCisJCWRpZSgiTm8gdGVzdHMgbWF0Y2ghIik7CisJaWYgKG1heF9qb2JzID4gc3VpdGUudGVzdHMubnIpCisJCW1heF9qb2JzID0gc3VpdGUudGVzdHMubnI7CisKKwlmcHJpbnRmKHN0ZGVyciwgIlJ1bm5pbmcgJWQgdGVzdHMgKCVkIGF0IGEgdGltZSlcbiIsCisJCXN1aXRlLnRlc3RzLm5yLCBtYXhfam9icyk7CisKKwlyZXQgPSBydW5fcHJvY2Vzc2VzX3BhcmFsbGVsKG1heF9qb2JzLCBuZXh0X3Rlc3QsIHRlc3RfZmFpbGVkLAorCQkJCSAgICAgdGVzdF9maW5pc2hlZCwgJnN1aXRlKTsKKworCWlmIChzdWl0ZS5mYWlsZWQubnIgPiAwKSB7CisJCXJldCA9IDE7CisJCWZwcmludGYoc3RkZXJyLCAiJWQgdGVzdHMgZmFpbGVkOlxuXG4iLCBzdWl0ZS5mYWlsZWQubnIpOworCQlmb3IgKGkgPSAwOyBpIDwgc3VpdGUuZmFpbGVkLm5yOyBpKyspCisJCQlmcHJpbnRmKHN0ZGVyciwgIlx0JXNcbiIsIHN1aXRlLmZhaWxlZC5pdGVtc1tpXS5zdHJpbmcpOworCX0KKworCXN0cmluZ19saXN0X2NsZWFyKCZzdWl0ZS50ZXN0cywgMCk7CisJc3RyaW5nX2xpc3RfY2xlYXIoJnN1aXRlLmZhaWxlZCwgMCk7CisKKwlyZXR1cm4gISFyZXQ7Cit9CisKIGludCBjbWRfX3J1bl9jb21tYW5kKGludCBhcmdjLCBjb25zdCBjaGFyICoqYXJndikKIHsKIAlzdHJ1Y3QgY2hpbGRfcHJvY2VzcyBwcm9jID0gQ0hJTERfUFJPQ0VTU19JTklUOwogCWludCBqb2JzOwogCisJaWYgKGFyZ2MgPiAxICYmICFzdHJjbXAoYXJndlsxXSwgInRlc3RzdWl0ZSIpKQorCQlleGl0KHRlc3RzdWl0ZShhcmdjIC0gMSwgYXJndiArIDEpKTsKKwogCWlmIChhcmdjIDwgMykKIAkJcmV0dXJuIDE7CiAJd2hpbGUgKCFzdHJjbXAoYXJndlsxXSwgImVudiIpKSB7CmRpZmYgLS1naXQgYS90L2hlbHBlci90ZXN0LXRvb2wuYyBiL3QvaGVscGVyL3Rlc3QtdG9vbC5jCmluZGV4IGNlN2U4OTAuLmYyMDk4OWQgMTAwNjQ0Ci0tLSBhL3QvaGVscGVyL3Rlc3QtdG9vbC5jCisrKyBiL3QvaGVscGVyL3Rlc3QtdG9vbC5jCkBAIC00Miw4ICs0MiwxMCBAQAogCXsgInBhdGgtdXRpbHMiLCBjbWRfX3BhdGhfdXRpbHMgfSwKIAl7ICJwa3QtbGluZSIsIGNtZF9fcGt0X2xpbmUgfSwKIAl7ICJwcmlvLXF1ZXVlIiwgY21kX19wcmlvX3F1ZXVlIH0sCisJeyAicHJvZ3Jlc3MiLCBjbWRfX3Byb2dyZXNzIH0sCiAJeyAicmVhY2giLCBjbWRfX3JlYWNoIH0sCiAJeyAicmVhZC1jYWNoZSIsIGNtZF9fcmVhZF9jYWNoZSB9LAorCXsgInJlYWQtZ3JhcGgiLCBjbWRfX3JlYWRfZ3JhcGggfSwKIAl7ICJyZWFkLW1pZHgiLCBjbWRfX3JlYWRfbWlkeCB9LAogCXsgInJlZi1zdG9yZSIsIGNtZF9fcmVmX3N0b3JlIH0sCiAJeyAicmVnZXgiLCBjbWRfX3JlZ2V4IH0sCmRpZmYgLS1naXQgYS90L2hlbHBlci90ZXN0LXRvb2wuaCBiL3QvaGVscGVyL3Rlc3QtdG9vbC5oCmluZGV4IGY4MDViYjMuLjhlZDJhZjcgMTAwNjQ0Ci0tLSBhL3QvaGVscGVyL3Rlc3QtdG9vbC5oCisrKyBiL3QvaGVscGVyL3Rlc3QtdG9vbC5oCkBAIC0zMiw4ICszMiwxMCBAQAogaW50IGNtZF9fcGF0aF91dGlscyhpbnQgYXJnYywgY29uc3QgY2hhciAqKmFyZ3YpOwogaW50IGNtZF9fcGt0X2xpbmUoaW50IGFyZ2MsIGNvbnN0IGNoYXIgKiphcmd2KTsKIGludCBjbWRfX3ByaW9fcXVldWUoaW50IGFyZ2MsIGNvbnN0IGNoYXIgKiphcmd2KTsKK2ludCBjbWRfX3Byb2dyZXNzKGludCBhcmdjLCBjb25zdCBjaGFyICoqYXJndik7CiBpbnQgY21kX19yZWFjaChpbnQgYXJnYywgY29uc3QgY2hhciAqKmFyZ3YpOwogaW50IGNtZF9fcmVhZF9jYWNoZShpbnQgYXJnYywgY29uc3QgY2hhciAqKmFyZ3YpOworaW50IGNtZF9fcmVhZF9ncmFwaChpbnQgYXJnYywgY29uc3QgY2hhciAqKmFyZ3YpOwogaW50IGNtZF9fcmVhZF9taWR4KGludCBhcmdjLCBjb25zdCBjaGFyICoqYXJndik7CiBpbnQgY21kX19yZWZfc3RvcmUoaW50IGFyZ2MsIGNvbnN0IGNoYXIgKiphcmd2KTsKIGludCBjbWRfX3JlZ2V4KGludCBhcmdjLCBjb25zdCBjaGFyICoqYXJndik7CmRpZmYgLS1naXQgYS90L2xpYi1naXQtZGFlbW9uLnNoIGIvdC9saWItZ2l0LWRhZW1vbi5zaAppbmRleCBmYjhmODg3Li5lNjI1NjkyIDEwMDY0NAotLS0gYS90L2xpYi1naXQtZGFlbW9uLnNoCisrKyBiL3QvbGliLWdpdC1kYWVtb24uc2gKQEAgLTE1LDcgKzE1LDcgQEAKICMKICMJdGVzdF9kb25lCiAKLWlmICEgZ2l0IGVudi0taGVscGVyIC0tdHlwZT1ib29sIC0tZGVmYXVsdD10cnVlIC0tZXhpdC1jb2RlIEdJVF9URVNUX0dJVF9EQUVNT04KK2lmICEgdGVzdF9ib29sX2VudiBHSVRfVEVTVF9HSVRfREFFTU9OIHRydWUKIHRoZW4KIAlza2lwX2FsbD0iZ2l0LWRhZW1vbiB0ZXN0aW5nIGRpc2FibGVkICh1bnNldCBHSVRfVEVTVF9HSVRfREFFTU9OIHRvIGVuYWJsZSkiCiAJdGVzdF9kb25lCmRpZmYgLS1naXQgYS90L2xpYi1naXQtc3ZuLnNoIGIvdC9saWItZ2l0LXN2bi5zaAppbmRleCA1ZDRhZTYyLi43ZDI0OGU2IDEwMDY0NAotLS0gYS90L2xpYi1naXQtc3ZuLnNoCisrKyBiL3QvbGliLWdpdC1zdm4uc2gKQEAgLTY5LDcgKzY5LDcgQEAKIG1heWJlX3N0YXJ0X2h0dHBkICgpIHsKIAlsb2M9JHsxLXN2bn0KIAotCWlmIGdpdCBlbnYtLWhlbHBlciAtLXR5cGU9Ym9vbCAtLWRlZmF1bHQ9ZmFsc2UgLS1leGl0LWNvZGUgR0lUX1RFU1RfSFRUUEQKKwlpZiB0ZXN0X2Jvb2xfZW52IEdJVF9URVNUX1NWTl9IVFRQRCBmYWxzZQogCXRoZW4KIAkJLiAiJFRFU1RfRElSRUNUT1JZIi9saWItaHR0cGQuc2gKIAkJTElCX0hUVFBEX1NWTj0iJGxvYyIKQEAgLTEwNCw3ICsxMDQsNyBAQAogfQogCiByZXF1aXJlX3N2bnNlcnZlICgpIHsKLQlpZiAhIGdpdCBlbnYtLWhlbHBlciAtLXR5cGU9Ym9vbCAtLWRlZmF1bHQ9ZmFsc2UgLS1leGl0LWNvZGUgR0lUX1RFU1RfU1ZOU0VSVkUKKwlpZiAhIHRlc3RfYm9vbF9lbnYgR0lUX1RFU1RfU1ZOU0VSVkUgZmFsc2UKIAl0aGVuCiAJCXNraXBfYWxsPSdza2lwcGluZyBzdm5zZXJ2ZSB0ZXN0LiAoc2V0ICRHSVRfVEVTVF9TVk5TRVJWRSB0byBlbmFibGUpJwogCQl0ZXN0X2RvbmUKZGlmZiAtLWdpdCBhL3QvbGliLWh0dHBkLnNoIGIvdC9saWItaHR0cGQuc2gKaW5kZXggMGQ5ODU3NS4uNjU2OTk3YiAxMDA2NDQKLS0tIGEvdC9saWItaHR0cGQuc2gKKysrIGIvdC9saWItaHR0cGQuc2gKQEAgLTQxLDcgKzQxLDcgQEAKIAl0ZXN0X2RvbmUKIGZpCiAKLWlmICEgZ2l0IGVudi0taGVscGVyIC0tdHlwZT1ib29sIC0tZGVmYXVsdD10cnVlIC0tZXhpdC1jb2RlIEdJVF9URVNUX0hUVFBECitpZiAhIHRlc3RfYm9vbF9lbnYgR0lUX1RFU1RfSFRUUEQgdHJ1ZQogdGhlbgogCXNraXBfYWxsPSJOZXR3b3JrIHRlc3RpbmcgZGlzYWJsZWQgKHVuc2V0IEdJVF9URVNUX0hUVFBEIHRvIGVuYWJsZSkiCiAJdGVzdF9kb25lCmRpZmYgLS1naXQgYS90L2xpYi1yZWJhc2Uuc2ggYi90L2xpYi1yZWJhc2Uuc2gKaW5kZXggN2VhMzBlNS4uYjcyYzA1MSAxMDA2NDQKLS0tIGEvdC9saWItcmViYXNlLnNoCisrKyBiL3QvbGliLXJlYmFzZS5zaApAQCAtNDQsMTAgKzQ0LDEwIEBACiAJcm0gLWYgIiQxIgogCWVjaG8gJ3JlYmFzZSAtaSBzY3JpcHQgYmVmb3JlIGVkaXRpbmc6JwogCWNhdCAiJDEiLnRtcAotCWFjdGlvbj1waWNrCisJYWN0aW9uPVwmCiAJZm9yIGxpbmUgaW4gJEZBS0VfTElORVM7IGRvCiAJCWNhc2UgJGxpbmUgaW4KLQkJcGlja3xwfHNxdWFzaHxzfGZpeHVwfGZ8ZWRpdHxlfHJld29yZHxyfGRyb3B8ZCkKKwkJcGlja3xwfHNxdWFzaHxzfGZpeHVwfGZ8ZWRpdHxlfHJld29yZHxyfGRyb3B8ZHxsYWJlbHxsfHJlc2V0fHJ8bWVyZ2V8bSkKIAkJCWFjdGlvbj0iJGxpbmUiOzsKIAkJZXhlY18qfHhfKnxicmVha3xiKQogCQkJZWNobyAiJGxpbmUiIHwgc2VkICdzL18vIC9nJyA+PiAiJDEiOzsKQEAgLTU4LDExICs1OCwxMiBAQAogCQliYWQpCiAJCQlhY3Rpb249ImJhZGNtZCI7OwogCQlmYWtlc2hhKQorCQkJdGVzdCBcJiAhPSAiJGFjdGlvbiIgfHwgYWN0aW9uPXBpY2sKIAkJCWVjaG8gIiRhY3Rpb24gWFhYWFhYWCBGYWxzZSBjb21taXQiID4+ICIkMSIKIAkJCWFjdGlvbj1waWNrOzsKIAkJKikKLQkJCXNlZCAtbiAiJHtsaW5lfXMvXnBpY2svJGFjdGlvbi9wIiA8ICIkMSIudG1wID4+ICIkMSIKLQkJCWFjdGlvbj1waWNrOzsKKwkJCXNlZCAtbiAiJHtsaW5lfXMvXlthLXpdW2Etel0qLyRhY3Rpb24vcCIgPCAiJDEiLnRtcCA+PiAiJDEiCisJCQlhY3Rpb249XCY7OwogCQllc2FjCiAJZG9uZQogCWVjaG8gJ3JlYmFzZSAtaSBzY3JpcHQgYWZ0ZXIgZWRpdGluZzonCkBAIC0xMTgsMyArMTE5LDMxIEBACiAJZ2l0IGNvbW1pdCAtLWFsbG93LWVtcHR5IC1tICIkMSIgJiYKIAlnaXQgdGFnICIkMSIKIH0KKworIyBDYWxsIHRoaXMgKGluc2lkZSB0ZXN0X2V4cGVjdF9zdWNjZXNzKSBhdCB0aGUgZW5kIG9mIGEgdGVzdCBmaWxlIHRvCisjIGNoZWNrIHRoYXQgbm8gdGVzdHMgaGF2ZSBjaGFuZ2VkIGVkaXRvciByZWxhdGVkIGVudmlyb25tZW50CisjIHZhcmlhYmxlcyBvciBjb25maWcgc2V0dGluZ3MKK3Rlc3RfZWRpdG9yX3VuY2hhbmdlZCAoKSB7CisJIyBXZSdyZSBvbmx5IGludGVyZXN0ZWQgaW4gZXhwb3J0ZWQgdmFyaWFibGVzIGhlbmNlICdzaCAtYycKKwlzaCAtYyAnY2F0ID5hY3R1YWwgPDwtRU9GCisJRURJVE9SPSRFRElUT1IKKwlGQUtFX0NPTU1JVF9BTUVORD0kRkFLRV9DT01NSVRfQU1FTkQKKwlGQUtFX0NPTU1JVF9NRVNTQUdFPSRGQUtFX0NPTU1JVF9NRVNTQUdFCisJRkFLRV9MSU5FUz0kRkFLRV9MSU5FUworCUdJVF9FRElUT1I9JEdJVF9FRElUT1IKKwlHSVRfU0VRVUVOQ0VfRURJVE9SPSRHSVRfU0VRVUVOQ0VfRURJVE9SCisJY29yZS5lZGl0b3I9JChnaXQgY29uZmlnIGNvcmUuZWRpdG9yKQorCXNlcXVlbmNlLmVkaXRvcj0kKGdpdCBjb25maWcgc2VxdWVuY2UuZWRpdG9yKQorCUVPRicKKwljYXQgPmV4cGVjdCA8PC1cRU9GCisJRURJVE9SPToKKwlGQUtFX0NPTU1JVF9BTUVORD0KKwlGQUtFX0NPTU1JVF9NRVNTQUdFPQorCUZBS0VfTElORVM9CisJR0lUX0VESVRPUj0KKwlHSVRfU0VRVUVOQ0VfRURJVE9SPQorCWNvcmUuZWRpdG9yPQorCXNlcXVlbmNlLmVkaXRvcj0KKwlFT0YKKwl0ZXN0X2NtcCBleHBlY3QgYWN0dWFsCit9CmRpZmYgLS1naXQgYS90L29pZC1pbmZvL2hhc2gtaW5mbyBiL3Qvb2lkLWluZm8vaGFzaC1pbmZvCmluZGV4IGNjZGJmZGYuLmQwNzM2ZGQgMTAwNjQ0Ci0tLSBhL3Qvb2lkLWluZm8vaGFzaC1pbmZvCisrKyBiL3Qvb2lkLWluZm8vaGFzaC1pbmZvCkBAIC02LDMgKzYsMTIgQEAKIAogemVybyBzaGExOjAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAKIHplcm8gc2hhMjU2OjAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAKKworYWxnbyBzaGExOnNoYTEKK2FsZ28gc2hhMjU2OnNoYTI1NgorCitlbXB0eV9ibG9iIHNoYTE6ZTY5ZGUyOWJiMmQxZDY0MzRiOGIyOWFlNzc1YWQ4YzJlNDhjNTM5MQorZW1wdHlfYmxvYiBzaGEyNTY6NDczYTBmNGMzYmU4YTkzNjgxYTI2N2UzYjFlOWE3ZGNkYTExODU0MzZmZTE0MWY3NzQ5MTIwYTMwMzcyMTgxMworCitlbXB0eV90cmVlIHNoYTE6NGI4MjVkYzY0MmNiNmViOWEwNjBlNTRiZjhkNjkyODhmYmVlNDkwNAorZW1wdHlfdHJlZSBzaGEyNTY6NmVmMTliNDEyMjVjNTM2OWYxYzEwNGQ0NWQ4ZDg1ZWZhOWIwNTdiNTNiMTRiNGI5YjkzOWRkNzRkZWNjNTMyMQpkaWZmIC0tZ2l0IGEvdC9wZXJmL2Jpc2VjdF9yZWdyZXNzaW9uIGIvdC9wZXJmL2Jpc2VjdF9yZWdyZXNzaW9uCmluZGV4IGE5NGQ5OTUuLmNlNDdlMTYgMTAwNzU1Ci0tLSBhL3QvcGVyZi9iaXNlY3RfcmVncmVzc2lvbgorKysgYi90L3BlcmYvYmlzZWN0X3JlZ3Jlc3Npb24KQEAgLTUxLDcgKzUxLDcgQEAKIG5ld3RpbWU9JChlY2hvICIkbmV3dGltZSIgfCBzZWQgLWUgJ3MvXlwoWzAtOV1cK1wuWzAtOV1cK1wpLiokL1wxLycpCiAKIHRlc3QgJChlY2hvICIkbmV3dGltZSIgIiRvbGR0aW1lIiB8IGF3ayAneyBwcmludCAoJDEgPiAkMikgfScpID0gMSB8fAotCWRpZSAiTmV3IHRpbWUgJyRuZXd0aW1lJyBzaG91ZCBiZSBncmVhdGVyIHRoYW4gb2xkIHRpbWUgJyRvbGR0aW1lJyIKKwlkaWUgIk5ldyB0aW1lICckbmV3dGltZScgc2hvdWxkIGJlIGdyZWF0ZXIgdGhhbiBvbGQgdGltZSAnJG9sZHRpbWUnIgogCiB0bXBkaXI9JChta3RlbXAgLWQgLXQgYmlzZWN0X3JlZ3Jlc3Npb25fWFhYWFhYKSB8fCBkaWUgIkZhaWxlZCB0byBjcmVhdGUgdGVtcCBkaXJlY3RvcnkiCiBlY2hvICIkb2xkdGltZSIgPiIkdG1wZGlyL29sZHRpbWUiIHx8IGRpZSAiRmFpbGVkIHRvIHdyaXRlIHRvICckdG1wZGlyL29sZHRpbWUnIgpkaWZmIC0tZ2l0IGEvdC9wZXJmL3A1MzAzLW1hbnktcGFja3Muc2ggYi90L3BlcmYvcDUzMDMtbWFueS1wYWNrcy5zaAppbmRleCAzNzc5ODUxLi5hMzY5MTUyIDEwMDc1NQotLS0gYS90L3BlcmYvcDUzMDMtbWFueS1wYWNrcy5zaAorKysgYi90L3BlcmYvcDUzMDMtbWFueS1wYWNrcy5zaApAQCAtNzcsNiArNzcsNyBAQAogCSMgYWN0dWFsIHBhY2sgZ2VuZXJhdGlvbiwgd2l0aG91dCBzbXVkZ2luZyB0aGUgb24tZGlzayBzZXR1cAogCSMgYmV0d2VlbiB0cmlhbHMuCiAJdGVzdF9wZXJmICJyZXBhY2sgKCRucl9wYWNrcykiICcKKwkJR0lUX1RFU1RfRlVMTF9JTl9QQUNLX0FSUkFZPTEgXAogCQlnaXQgcGFjay1vYmplY3RzIC0ta2VlcC10cnVlLXBhcmVudHMgXAogCQkgIC0taG9ub3ItcGFjay1rZWVwIC0tbm9uLWVtcHR5IC0tYWxsIFwKIAkJICAtLXJlZmxvZyAtLWluZGV4ZWQtb2JqZWN0cyAtLWRlbHRhLWJhc2Utb2Zmc2V0IFwKZGlmZiAtLWdpdCBhL3QvcGVyZi9wNTYwMC1jbG9uZS1yZWZlcmVuY2Uuc2ggYi90L3BlcmYvcDU2MDEtY2xvbmUtcmVmZXJlbmNlLnNoCnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSB0L3BlcmYvcDU2MDAtY2xvbmUtcmVmZXJlbmNlLnNoCnJlbmFtZSB0byB0L3BlcmYvcDU2MDEtY2xvbmUtcmVmZXJlbmNlLnNoCmRpZmYgLS1naXQgYS90L3QwMDAwLWJhc2ljLnNoIGIvdC90MDAwMC1iYXNpYy5zaAppbmRleCA5Y2EwODE4Li44YTgxYTI0IDEwMDc1NQotLS0gYS90L3QwMDAwLWJhc2ljLnNoCisrKyBiL3QvdDAwMDAtYmFzaWMuc2gKQEAgLTIwLDkgKzIwLDkgQEAKIAogLiAuL3Rlc3QtbGliLnNoCiAKLXRyeV9sb2NhbF94ICgpIHsKLQlsb2NhbCB4PSJsb2NhbCIgJiYKLQllY2hvICIkeCIKK3RyeV9sb2NhbF94eSAoKSB7CisJbG9jYWwgeD0ibG9jYWwiIHk9ImFsc29sb2NhbCIgJiYKKwllY2hvICIkeCAkeSIKIH0KIAogIyBDaGVjayB3aGV0aGVyIHRoZSBzaGVsbCBzdXBwb3J0cyB0aGUgImxvY2FsIiBrZXl3b3JkLiAibG9jYWwiIGlzIG5vdApAQCAtMzUsMTEgKzM1LDEyIEBACiAjIHJlbHlpbmcgb24gImxvY2FsIi4KIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3ZlcmlmeSB0aGF0IHRoZSBydW5uaW5nIHNoZWxsIHN1cHBvcnRzICJsb2NhbCInICcKIAl4PSJub3Rsb2NhbCIgJiYKLQllY2hvICJsb2NhbCIgPmV4cGVjdGVkMSAmJgotCXRyeV9sb2NhbF94ID5hY3R1YWwxICYmCisJeT0iYWxzb25vdGxvY2FsIiAmJgorCWVjaG8gImxvY2FsIGFsc29sb2NhbCIgPmV4cGVjdGVkMSAmJgorCXRyeV9sb2NhbF94eSA+YWN0dWFsMSAmJgogCXRlc3RfY21wIGV4cGVjdGVkMSBhY3R1YWwxICYmCi0JZWNobyAibm90bG9jYWwiID5leHBlY3RlZDIgJiYKLQllY2hvICIkeCIgPmFjdHVhbDIgJiYKKwllY2hvICJub3Rsb2NhbCBhbHNvbm90bG9jYWwiID5leHBlY3RlZDIgJiYKKwllY2hvICIkeCAkeSIgPmFjdHVhbDIgJiYKIAl0ZXN0X2NtcCBleHBlY3RlZDIgYWN0dWFsMgogJwogCkBAIC0xMjYsNyArMTI3LDcgQEAKIAogY2hlY2tfc3ViX3Rlc3RfbGliX3Rlc3RfZXJyICgpIHsKIAluYW1lPSIkMSIgIyBzdGRpbiBpcyB0aGUgZXhwZWN0ZWQgb3V0cHV0IGZyb20gdGhlIHRlc3QKLQkjIGV4cGVjdGVkIGVycm9yIG91dHB1dCBpcyBpbiBkZXNjcmlwdGlvciAzCisJIyBleHBlY3RlZCBlcnJvciBvdXRwdXQgaXMgaW4gZGVzY3JpcHRvciAzCiAJKAogCQljZCAiJG5hbWUiICYmCiAJCXNlZCAtZSAncy9ePiAvLycgLWUgJ3MvWiQvLycgPmV4cGVjdC5vdXQgJiYKQEAgLTI3NCwyMyArMjc1LDIzIEBACiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgQ19MT0NBTEVfT1VUUFVUICd0ZXN0IC0tdmVyYm9zZScgJwogCXRlc3RfbXVzdF9mYWlsIHJ1bl9zdWJfdGVzdF9saWJfdGVzdCBcCi0JCXRlc3QtdmVyYm9zZSAidGVzdCB2ZXJib3NlIiAtLXZlcmJvc2UgPDwtXEVPRiAmJgorCQl0MTIzNC12ZXJib3NlICJ0ZXN0IHZlcmJvc2UiIC0tdmVyYm9zZSA8PC1cRU9GICYmCiAJdGVzdF9leHBlY3Rfc3VjY2VzcyAicGFzc2luZyB0ZXN0IiB0cnVlCiAJdGVzdF9leHBlY3Rfc3VjY2VzcyAidGVzdCB3aXRoIG91dHB1dCIgImVjaG8gZm9vIgogCXRlc3RfZXhwZWN0X3N1Y2Nlc3MgImZhaWxpbmcgdGVzdCIgZmFsc2UKIAl0ZXN0X2RvbmUKIAlFT0YKLQltdiB0ZXN0LXZlcmJvc2Uvb3V0IHRlc3QtdmVyYm9zZS9vdXQrICYmCi0JZ3JlcCAtdiAiXkluaXRpYWxpemVkIGVtcHR5IiB0ZXN0LXZlcmJvc2Uvb3V0KyA+dGVzdC12ZXJib3NlL291dCAmJgotCWNoZWNrX3N1Yl90ZXN0X2xpYl90ZXN0IHRlc3QtdmVyYm9zZSA8PC1cRU9GCi0JPiBleHBlY3Rpbmcgc3VjY2VzczogdHJ1ZQorCW12IHQxMjM0LXZlcmJvc2Uvb3V0IHQxMjM0LXZlcmJvc2Uvb3V0KyAmJgorCWdyZXAgLXYgIl5Jbml0aWFsaXplZCBlbXB0eSIgdDEyMzQtdmVyYm9zZS9vdXQrID50MTIzNC12ZXJib3NlL291dCAmJgorCWNoZWNrX3N1Yl90ZXN0X2xpYl90ZXN0IHQxMjM0LXZlcmJvc2UgPDwtXEVPRgorCT4gZXhwZWN0aW5nIHN1Y2Nlc3Mgb2YgMTIzNC4xICdcJydwYXNzaW5nIHRlc3QnXCcnOiB0cnVlCiAJPiBvayAxIC0gcGFzc2luZyB0ZXN0CiAJPiBaCi0JPiBleHBlY3Rpbmcgc3VjY2VzczogZWNobyBmb28KKwk+IGV4cGVjdGluZyBzdWNjZXNzIG9mIDEyMzQuMiAnXCcndGVzdCB3aXRoIG91dHB1dCdcJyc6IGVjaG8gZm9vCiAJPiBmb28KIAk+IG9rIDIgLSB0ZXN0IHdpdGggb3V0cHV0CiAJPiBaCi0JPiBleHBlY3Rpbmcgc3VjY2VzczogZmFsc2UKKwk+IGV4cGVjdGluZyBzdWNjZXNzIG9mIDEyMzQuMyAnXCcnZmFpbGluZyB0ZXN0J1wnJzogZmFsc2UKIAk+IG5vdCBvayAzIC0gZmFpbGluZyB0ZXN0CiAJPiAjCWZhbHNlCiAJPiBaCkBAIC0zMDEsMTcgKzMwMiwxNyBAQAogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICd0ZXN0IC0tdmVyYm9zZS1vbmx5JyAnCiAJdGVzdF9tdXN0X2ZhaWwgcnVuX3N1Yl90ZXN0X2xpYl90ZXN0IFwKLQkJdGVzdC12ZXJib3NlLW9ubHktMiAidGVzdCB2ZXJib3NlLW9ubHk9MiIgXAorCQl0MjM0NS12ZXJib3NlLW9ubHktMiAidGVzdCB2ZXJib3NlLW9ubHk9MiIgXAogCQktLXZlcmJvc2Utb25seT0yIDw8LVxFT0YgJiYKIAl0ZXN0X2V4cGVjdF9zdWNjZXNzICJwYXNzaW5nIHRlc3QiIHRydWUKIAl0ZXN0X2V4cGVjdF9zdWNjZXNzICJ0ZXN0IHdpdGggb3V0cHV0IiAiZWNobyBmb28iCiAJdGVzdF9leHBlY3Rfc3VjY2VzcyAiZmFpbGluZyB0ZXN0IiBmYWxzZQogCXRlc3RfZG9uZQogCUVPRgotCWNoZWNrX3N1Yl90ZXN0X2xpYl90ZXN0IHRlc3QtdmVyYm9zZS1vbmx5LTIgPDwtXEVPRgorCWNoZWNrX3N1Yl90ZXN0X2xpYl90ZXN0IHQyMzQ1LXZlcmJvc2Utb25seS0yIDw8LVxFT0YKIAk+IG9rIDEgLSBwYXNzaW5nIHRlc3QKIAk+IFoKLQk+IGV4cGVjdGluZyBzdWNjZXNzOiBlY2hvIGZvbworCT4gZXhwZWN0aW5nIHN1Y2Nlc3Mgb2YgMjM0NS4yICdcJyd0ZXN0IHdpdGggb3V0cHV0J1wnJzogZWNobyBmb28KIAk+IGZvbwogCT4gb2sgMiAtIHRlc3Qgd2l0aCBvdXRwdXQKIAk+IFoKQEAgLTM5MSw2ICszOTIsNDQgQEAKIAkpCiAiCiAKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ0dJVF9TS0lQX1RFU1RTIGVudGlyZSBzdWl0ZScgIgorCSgKKwkJR0lUX1NLSVBfVEVTVFM9J2dpdCcgJiYgZXhwb3J0IEdJVF9TS0lQX1RFU1RTICYmCisJCXJ1bl9zdWJfdGVzdF9saWJfdGVzdCBnaXQtc2tpcC10ZXN0cy1lbnRpcmUtc3VpdGUgXAorCQkJJ0dJVF9TS0lQX1RFU1RTIGVudGlyZSBzdWl0ZScgPDwtXFxFT0YgJiYKKwkJZm9yIGkgaW4gMSAyIDMKKwkJZG8KKwkJCXRlc3RfZXhwZWN0X3N1Y2Nlc3MgXCJwYXNzaW5nIHRlc3QgI1wkaVwiICd0cnVlJworCQlkb25lCisJCXRlc3RfZG9uZQorCQlFT0YKKwkJY2hlY2tfc3ViX3Rlc3RfbGliX3Rlc3QgZ2l0LXNraXAtdGVzdHMtZW50aXJlLXN1aXRlIDw8LVxcRU9GCisJCT4gMS4uMCAjIFNLSVAgc2tpcCBhbGwgdGVzdHMgaW4gZ2l0CisJCUVPRgorCSkKKyIKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAnR0lUX1NLSVBfVEVTVFMgZG9lcyBub3Qgc2tpcCB1bm1hdGNoZWQgc3VpdGUnICIKKwkoCisJCUdJVF9TS0lQX1RFU1RTPSdub3RnaXQnICYmIGV4cG9ydCBHSVRfU0tJUF9URVNUUyAmJgorCQlydW5fc3ViX3Rlc3RfbGliX3Rlc3QgZ2l0LXNraXAtdGVzdHMtdW5tYXRjaGVkLXN1aXRlIFwKKwkJCSdHSVRfU0tJUF9URVNUUyBkb2VzIG5vdCBza2lwIHVubWF0Y2hlZCBzdWl0ZScgPDwtXFxFT0YgJiYKKwkJZm9yIGkgaW4gMSAyIDMKKwkJZG8KKwkJCXRlc3RfZXhwZWN0X3N1Y2Nlc3MgXCJwYXNzaW5nIHRlc3QgI1wkaVwiICd0cnVlJworCQlkb25lCisJCXRlc3RfZG9uZQorCQlFT0YKKwkJY2hlY2tfc3ViX3Rlc3RfbGliX3Rlc3QgZ2l0LXNraXAtdGVzdHMtdW5tYXRjaGVkLXN1aXRlIDw8LVxcRU9GCisJCT4gb2sgMSAtIHBhc3NpbmcgdGVzdCAjMQorCQk+IG9rIDIgLSBwYXNzaW5nIHRlc3QgIzIKKwkJPiBvayAzIC0gcGFzc2luZyB0ZXN0ICMzCisJCT4gIyBwYXNzZWQgYWxsIDMgdGVzdChzKQorCQk+IDEuLjMKKwkJRU9GCisJKQorIgorCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICctLXJ1biBiYXNpYycgIgogCXJ1bl9zdWJfdGVzdF9saWJfdGVzdCBydW4tYmFzaWMgXAogCQknLS1ydW4gYmFzaWMnIC0tcnVuPScxIDMgNScgPDwtXFxFT0YgJiYKQEAgLTg3OCw2ICs5MTcsNDAgQEAKIAl0ZXN0ICIkaGV4c3oiIC1lcSA2NAogJwogCit0ZXN0X2V4cGVjdF9zdWNjZXNzICd0ZXN0X2Jvb2xfZW52JyAnCisJKAorCQlzYW5lX3Vuc2V0IGVudnZhciAmJgorCisJCXRlc3RfYm9vbF9lbnYgZW52dmFyIHRydWUgJiYKKwkJISB0ZXN0X2Jvb2xfZW52IGVudnZhciBmYWxzZSAmJgorCisJCWVudnZhcj0gJiYKKwkJZXhwb3J0IGVudnZhciAmJgorCQkhIHRlc3RfYm9vbF9lbnYgZW52dmFyIHRydWUgJiYKKwkJISB0ZXN0X2Jvb2xfZW52IGVudnZhciBmYWxzZSAmJgorCisJCWVudnZhcj10cnVlICYmCisJCXRlc3RfYm9vbF9lbnYgZW52dmFyIHRydWUgJiYKKwkJdGVzdF9ib29sX2VudiBlbnZ2YXIgZmFsc2UgJiYKKworCQllbnZ2YXI9ZmFsc2UgJiYKKwkJISB0ZXN0X2Jvb2xfZW52IGVudnZhciB0cnVlICYmCisJCSEgdGVzdF9ib29sX2VudiBlbnZ2YXIgZmFsc2UgJiYKKworCQllbnZ2YXI9aW52YWxpZCAmJgorCQkjIFdoZW4gZW5jb3VudGVyaW5nIGFuIGludmFsaWQgYm9vbCB2YWx1ZSwgdGVzdF9ib29sX2VudgorCQkjIHByaW50cyBpdHMgZXJyb3IgbWVzc2FnZSB0byB0aGUgb3JpZ2luYWwgc3RkZXJyIG9mIHRoZQorCQkjIHRlc3Qgc2NyaXB0LCBoZW5jZSB0aGUgcmVkaXJlY3Rpb24gb2YgZmQgNywgYW5kIGFib3J0cworCQkjIHdpdGggImV4aXQgMSIsIGhlbmNlIHRoZSBzdWJzaGVsbC4KKwkJISAoIHRlc3RfYm9vbF9lbnYgZW52dmFyIHRydWUgKSA3PmVyciAmJgorCQlncmVwICJlcnJvcjogdGVzdF9ib29sX2VudiByZXF1aXJlcyBib29sIHZhbHVlcyIgZXJyICYmCisKKwkJZW52dmFyPXRydWUgJiYKKwkJISAoIHRlc3RfYm9vbF9lbnYgZW52dmFyIGludmFsaWQgKSA3PmVyciAmJgorCQlncmVwICJlcnJvcjogdGVzdF9ib29sX2VudiByZXF1aXJlcyBib29sIHZhbHVlcyIgZXJyCisJKQorJworCiAjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCiAjIEJhc2ljcyBvZiB0aGUgYmFzaWNzCiAKZGlmZiAtLWdpdCBhL3QvdDAwMTQtYWxpYXMuc2ggYi90L3QwMDE0LWFsaWFzLnNoCmluZGV4IGEwNzBlNjQuLjI2OTRjODEgMTAwNzU1Ci0tLSBhL3QvdDAwMTQtYWxpYXMuc2gKKysrIGIvdC90MDAxNC1hbGlhcy5zaApAQCAtMzcsNCArMzcsMTEgQEAKICMJdGVzdF9pMThuZ3JlcCAiXmZhdGFsOiBhbGlhcyBsb29wIGRldGVjdGVkOiBleHBhbnNpb24gb2YiIG91dHB1dAogIycKIAordGVzdF9leHBlY3Rfc3VjY2VzcyAncnVuLWNvbW1hbmQgZm9ybWF0cyBlbXB0eSBhcmdzIHByb3Blcmx5JyAnCisgICAgR0lUX1RSQUNFPTEgZ2l0IGZyb3R6IGEgIiIgYiAiICIgYyAyPiYxIHwKKyAgICBzZWQgLW5lICIvcnVuX2NvbW1hbmQ6L3MvLip0cmFjZTogcnVuX2NvbW1hbmQ6IC8vcCIgPmFjdHVhbCAmJgorICAgIGVjaG8gImdpdC1mcm90eiBhICdcJycnXCcnIGIgJ1wnJyAnXCcnIGMiID5leHBlY3QgJiYKKyAgICB0ZXN0X2NtcCBleHBlY3QgYWN0dWFsCisnCisKIHRlc3RfZG9uZQpkaWZmIC0tZ2l0IGEvdC90MDAyMS1jb252ZXJzaW9uLnNoIGIvdC90MDAyMS1jb252ZXJzaW9uLnNoCmluZGV4IGUxMGY1ZjcuLmM5NTRjNzAgMTAwNzU1Ci0tLSBhL3QvdDAwMjEtY29udmVyc2lvbi5zaAorKysgYi90L3QwMDIxLWNvbnZlcnNpb24uc2gKQEAgLTM5MCw2ICszOTAsOSBAQAogCQlFT0YKIAkJdGVzdF9jbXBfZXhjbHVkZV9jbGVhbiBleHBlY3RlZC5sb2cgZGVidWcubG9nICYmCiAKKwkJIyBNYWtlIHN1cmUgdGhhdCB0aGUgZmlsZSBhcHBlYXJzIGRpcnR5LCBzbyBjaGVja291dCBiZWxvdyBoYXMgdG8KKwkJIyBydW4gdGhlIGNvbmZpZ3VyZWQgZmlsdGVyLgorCQl0b3VjaCB0ZXN0LnIgJiYKIAkJZmlsdGVyX2dpdCBjaGVja291dCAtLXF1aWV0IC0tbm8tcHJvZ3Jlc3MgZW1wdHktYnJhbmNoICYmCiAJCWNhdCA+ZXhwZWN0ZWQubG9nIDw8LUVPRiAmJgogCQkJU1RBUlQKZGlmZiAtLWdpdCBhL3QvdDAwMjctYXV0by1jcmxmLnNoIGIvdC90MDAyNy1hdXRvLWNybGYuc2gKaW5kZXggOTU5YjZkYS4uOWZjZDU2ZiAxMDA3NTUKLS0tIGEvdC90MDAyNy1hdXRvLWNybGYuc2gKKysrIGIvdC90MDAyNy1hdXRvLWNybGYuc2gKQEAgLTIxNSw3ICsyMTUsNyBAQAogfQogCiAKLSMgY29udHJ1Y3QgdGhlIGF0dHIvIHJldHVybmVkIGJ5IGdpdCBscy1maWxlcyAtLWVvbAorIyBjb25zdHJ1Y3QgdGhlIGF0dHIvIHJldHVybmVkIGJ5IGdpdCBscy1maWxlcyAtLWVvbAogIyBUYWtlIG5vbmUgKD1lbXB0eSksIG9uZSBvciB0d28gYXJncwogIyBjb252ZXJ0LmM6IGVvbD1YWCBvdmVycmlkZXMgdGV4dD1hdXRvCiBhdHRyX2FzY2lpICgpIHsKZGlmZiAtLWdpdCBhL3QvdDAwMjgtd29ya2luZy10cmVlLWVuY29kaW5nLnNoIGIvdC90MDAyOC13b3JraW5nLXRyZWUtZW5jb2Rpbmcuc2gKaW5kZXggMTA5MGU2NS4uYmZjNGZiOSAxMDA3NTUKLS0tIGEvdC90MDAyOC13b3JraW5nLXRyZWUtZW5jb2Rpbmcuc2gKKysrIGIvdC90MDAyOC13b3JraW5nLXRyZWUtZW5jb2Rpbmcuc2gKQEAgLTE3LDcgKzE3LDcgQEAKIHdyaXRlX3V0ZjE2ICgpIHsKIAlpZiB0ZXN0X2hhdmVfcHJlcmVxIE5PX1VURjE2X0JPTQogCXRoZW4KLQkJcHJpbnRmICdceGZlXHhmZicKKwkJcHJpbnRmICdcMzc2XDM3NycKIAlmaSAmJgogCWljb252IC1mIFVURi04IC10IFVURi0xNgogfQpAQCAtMjUsNyArMjUsNyBAQAogd3JpdGVfdXRmMzIgKCkgewogCWlmIHRlc3RfaGF2ZV9wcmVyZXEgTk9fVVRGMzJfQk9NCiAJdGhlbgotCQlwcmludGYgJ1x4MDBceDAwXHhmZVx4ZmYnCisJCXByaW50ZiAnXDBcMFwzNzZcMzc3JwogCWZpICYmCiAJaWNvbnYgLWYgVVRGLTggLXQgVVRGLTMyCiB9CkBAIC00MCw3ICs0MCw3IEBACiAJcHJpbnRmICIkdGV4dCIgfCB3cml0ZV91dGYxNiA+dGVzdC51dGYxNi5yYXcgJiYKIAlwcmludGYgIiR0ZXh0IiB8IHdyaXRlX3V0ZjMyID50ZXN0LnV0ZjMyLnJhdyAmJgogCXByaW50ZiAiXDM3N1wzNzYiICAgICAgICAgICAgICAgICAgICAgICAgID50ZXN0LnV0ZjE2bGVib20ucmF3ICYmCi0JcHJpbnRmICIkdGV4dCIgfCBpY29udiAtZiBVVEYtOCAtdCBVVEYtMzJMRSA+PnRlc3QudXRmMTZsZWJvbS5yYXcgJiYKKwlwcmludGYgIiR0ZXh0IiB8IGljb252IC1mIFVURi04IC10IFVURi0xNkxFID4+dGVzdC51dGYxNmxlYm9tLnJhdyAmJgogCiAJIyBMaW5lIGVuZGluZyB0ZXN0cwogCXByaW50ZiAib25lXG50d29cbnRocmVlXG4iID5sZi51dGY4LnJhdyAmJgpAQCAtMjgwLDQgKzI4MCw0MyBAQAogCWdpdCByZXNldAogJwogCisjICQxOiBjaGVja291dCBlbmNvZGluZworIyAkMjogdGVzdCBzdHJpbmcKKyMgJDM6IGJpbmFyeSB0ZXN0IHN0cmluZyBpbiBjaGVja291dCBlbmNvZGluZwordGVzdF9jb21taXRfdXRmOF9jaGVja291dF9vdGhlciAoKSB7CisJZW5jb2Rpbmc9IiQxIgorCW9yaWdfc3RyaW5nPSIkMiIKKwlleHBlY3RfYnl0ZXM9IiQzIgorCisJdGVzdF9leHBlY3Rfc3VjY2VzcyAiQ29tbWl0IFVURi04LCBjaGVja291dCAkZW5jb2RpbmciICcKKwkJdGVzdF93aGVuX2ZpbmlzaGVkICJnaXQgY2hlY2tvdXQgSEVBRCAtLSAuZ2l0YXR0cmlidXRlcyIgJiYKKworCQl0ZXN0X2V4dD0iY29tbWl0X3V0ZjhfY2hlY2tvdXRfJGVuY29kaW5nIiAmJgorCQl0ZXN0X2ZpbGU9InRlc3QuJHRlc3RfZXh0IiAmJgorCisJCSMgQ29tbWl0IGFzIFVURi04CisJCWVjaG8gIiouJHRlc3RfZXh0IHRleHQgd29ya2luZy10cmVlLWVuY29kaW5nPVVURi04IiA+LmdpdGF0dHJpYnV0ZXMgJiYKKwkJcHJpbnRmICIkb3JpZ19zdHJpbmciID4kdGVzdF9maWxlICYmCisJCWdpdCBhZGQgJHRlc3RfZmlsZSAmJgorCQlnaXQgY29tbWl0IC1tICJUZXN0IGRhdGEiICYmCisKKwkJIyBDaGVja291dCBpbiB0ZXN0ZWQgZW5jb2RpbmcKKwkJcm0gJHRlc3RfZmlsZSAmJgorCQllY2hvICIqLiR0ZXN0X2V4dCB0ZXh0IHdvcmtpbmctdHJlZS1lbmNvZGluZz0kZW5jb2RpbmciID4uZ2l0YXR0cmlidXRlcyAmJgorCQlnaXQgY2hlY2tvdXQgSEVBRCAtLSAkdGVzdF9maWxlICYmCisKKwkJIyBUZXN0CisJCXByaW50ZiAkZXhwZWN0X2J5dGVzID4kdGVzdF9maWxlLnJhdyAmJgorCQl0ZXN0X2NtcF9iaW4gJHRlc3RfZmlsZS5yYXcgJHRlc3RfZmlsZQorCScKK30KKwordGVzdF9jb21taXRfdXRmOF9jaGVja291dF9vdGhlciAiVVRGLTgiICAgICAgICAiVGVzdCDQotC10YHRgiIgIlwxMjRcMTQ1XDE2M1wxNjRcMDQwXDMyMFwyNDJcMzIwXDI2NVwzMjFcMjAxXDMyMVwyMDIiCit0ZXN0X2NvbW1pdF91dGY4X2NoZWNrb3V0X290aGVyICJVVEYtMTZMRSIgICAgICJUZXN0INCi0LXRgdGCIiAiXDEyNFwwMDBcMTQ1XDAwMFwxNjNcMDAwXDE2NFwwMDBcMDQwXDAwMFwwNDJcMDA0XDA2NVwwMDRcMTAxXDAwNFwxMDJcMDA0IgordGVzdF9jb21taXRfdXRmOF9jaGVja291dF9vdGhlciAiVVRGLTE2QkUiICAgICAiVGVzdCDQotC10YHRgiIgIlwwMDBcMTI0XDAwMFwxNDVcMDAwXDE2M1wwMDBcMTY0XDAwMFwwNDBcMDA0XDA0MlwwMDRcMDY1XDAwNFwxMDFcMDA0XDEwMiIKK3Rlc3RfY29tbWl0X3V0ZjhfY2hlY2tvdXRfb3RoZXIgIlVURi0xNkxFLUJPTSIgIlRlc3Qg0KLQtdGB0YIiICJcMzc3XDM3NlwxMjRcMDAwXDE0NVwwMDBcMTYzXDAwMFwxNjRcMDAwXDA0MFwwMDBcMDQyXDAwNFwwNjVcMDA0XDEwMVwwMDRcMTAyXDAwNCIKK3Rlc3RfY29tbWl0X3V0ZjhfY2hlY2tvdXRfb3RoZXIgIlVURi0xNkJFLUJPTSIgIlRlc3Qg0KLQtdGB0YIiICJcMzc2XDM3N1wwMDBcMTI0XDAwMFwxNDVcMDAwXDE2M1wwMDBcMTY0XDAwMFwwNDBcMDA0XDA0MlwwMDRcMDY1XDAwNFwxMDFcMDA0XDEwMiIKK3Rlc3RfY29tbWl0X3V0ZjhfY2hlY2tvdXRfb3RoZXIgIlVURi0zMkxFIiAgICAgIlRlc3Qg0KLQtdGB0YIiICJcMTI0XDAwMFwwMDBcMDAwXDE0NVwwMDBcMDAwXDAwMFwxNjNcMDAwXDAwMFwwMDBcMTY0XDAwMFwwMDBcMDAwXDA0MFwwMDBcMDAwXDAwMFwwNDJcMDA0XDAwMFwwMDBcMDY1XDAwNFwwMDBcMDAwXDEwMVwwMDRcMDAwXDAwMFwxMDJcMDA0XDAwMFwwMDAiCit0ZXN0X2NvbW1pdF91dGY4X2NoZWNrb3V0X290aGVyICJVVEYtMzJCRSIgICAgICJUZXN0INCi0LXRgdGCIiAiXDAwMFwwMDBcMDAwXDEyNFwwMDBcMDAwXDAwMFwxNDVcMDAwXDAwMFwwMDBcMTYzXDAwMFwwMDBcMDAwXDE2NFwwMDBcMDAwXDAwMFwwNDBcMDAwXDAwMFwwMDRcMDQyXDAwMFwwMDBcMDA0XDA2NVwwMDBcMDAwXDAwNFwxMDFcMDAwXDAwMFwwMDRcMTAyIgorCiB0ZXN0X2RvbmUKZGlmZiAtLWdpdCBhL3QvdDAwNDAtcGFyc2Utb3B0aW9ucy5zaCBiL3QvdDAwNDAtcGFyc2Utb3B0aW9ucy5zaAppbmRleCBjZWJjNzdmLi43MDVhMTM2IDEwMDc1NQotLS0gYS90L3QwMDQwLXBhcnNlLW9wdGlvbnMuc2gKKysrIGIvdC90MDA0MC1wYXJzZS1vcHRpb25zLnNoCkBAIC0zOTksNCArMzk5LDExIEBACiAJCXRlc3QtdG9vbCBwYXJzZS1vcHRpb25zIC0teWUKICcKIAordGVzdF9leHBlY3Rfc3VjY2VzcyAnLS1lbmQtb2Ytb3B0aW9ucyB0cmVhdHMgcmVtYWluZGVyIGFzIGFyZ3MnICcKKwl0ZXN0LXRvb2wgcGFyc2Utb3B0aW9ucyBcCisJICAgIC0tZXhwZWN0PSJ2ZXJib3NlOiAtMSIgXAorCSAgICAtLWV4cGVjdD0iYXJnIDAwOiAtLXZlcmJvc2UiIFwKKwkgICAgLS1lbmQtb2Ytb3B0aW9ucyAtLXZlcmJvc2UKKycKKwogdGVzdF9kb25lCmRpZmYgLS1naXQgYS90L3QwMDUwLWZpbGVzeXN0ZW0uc2ggYi90L3QwMDUwLWZpbGVzeXN0ZW0uc2gKaW5kZXggMTkyYzk0ZS4uNjA4NjczZiAxMDA3NTUKLS0tIGEvdC90MDA1MC1maWxlc3lzdGVtLnNoCisrKyBiL3QvdDAwNTAtZmlsZXN5c3RlbS5zaApAQCAtMTMxLDQgKzEzMSwyNCBAQAogCWdpdCBtZXJnZSB0b3BpYwogJwogCit0ZXN0X2V4cGVjdF9zdWNjZXNzIENBU0VfSU5TRU5TSVRJVkVfRlMgJ2NoZWNrb3V0IHdpdGggbm8gcGF0aHNwZWMgYW5kIGEgY2FzZSBpbnNlbnNpdGl2ZSBmcycgJworCWdpdCBpbml0IHJlcG8gJiYKKwkoCisJCWNkIHJlcG8gJiYKKworCQk+R2l0d2ViICYmCisJCWdpdCBhZGQgR2l0d2ViICYmCisJCWdpdCBjb21taXQgLW0gImFkZCBHaXR3ZWIiICYmCisKKwkJZ2l0IGNoZWNrb3V0IC0tb3JwaGFuIHRvZG8gJiYKKwkJZ2l0IHJlc2V0IC0taGFyZCAmJgorCQlta2RpciAtcCBnaXR3ZWIvc3ViZGlyICYmCisJCT5naXR3ZWIvc3ViZGlyL2ZpbGUgJiYKKwkJZ2l0IGFkZCBnaXR3ZWIgJiYKKwkJZ2l0IGNvbW1pdCAtbSAiYWRkIGdpdHdlYi9zdWJkaXIvZmlsZSIgJiYKKworCQlnaXQgY2hlY2tvdXQgbWFzdGVyCisJKQorJworCiB0ZXN0X2RvbmUKZGlmZiAtLWdpdCBhL3QvdDAwNjAtcGF0aC11dGlscy5zaCBiL3QvdDAwNjAtcGF0aC11dGlscy5zaAppbmRleCBjN2I1M2U0Li41NTNlOTRiIDEwMDc1NQotLS0gYS90L3QwMDYwLXBhdGgtdXRpbHMuc2gKKysrIGIvdC90MDA2MC1wYXRoLXV0aWxzLnNoCkBAIC0yODUsOSArMjg1LDEzIEBACiB0ZXN0X2dpdF9wYXRoIEdJVF9PQkpFQ1RfRElSRUNUT1JZPWZvbyBvYmplY3RzMiAuZ2l0L29iamVjdHMyCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdzZXR1cCBjb21tb24gcmVwb3NpdG9yeScgJ2dpdCAtLWdpdC1kaXI9YmFyIGluaXQnCiB0ZXN0X2dpdF9wYXRoIEdJVF9DT01NT05fRElSPWJhciBpbmRleCAgICAgICAgICAgICAgICAgICAgLmdpdC9pbmRleAordGVzdF9naXRfcGF0aCBHSVRfQ09NTU9OX0RJUj1iYXIgaW5kZXgubG9jayAgICAgICAgICAgICAgIC5naXQvaW5kZXgubG9jawogdGVzdF9naXRfcGF0aCBHSVRfQ09NTU9OX0RJUj1iYXIgSEVBRCAgICAgICAgICAgICAgICAgICAgIC5naXQvSEVBRAogdGVzdF9naXRfcGF0aCBHSVRfQ09NTU9OX0RJUj1iYXIgbG9ncy9IRUFEICAgICAgICAgICAgICAgIC5naXQvbG9ncy9IRUFECit0ZXN0X2dpdF9wYXRoIEdJVF9DT01NT05fRElSPWJhciBsb2dzL0hFQUQubG9jayAgICAgICAgICAgLmdpdC9sb2dzL0hFQUQubG9jawogdGVzdF9naXRfcGF0aCBHSVRfQ09NTU9OX0RJUj1iYXIgbG9ncy9yZWZzL2Jpc2VjdC9mb28gICAgIC5naXQvbG9ncy9yZWZzL2Jpc2VjdC9mb28KK3Rlc3RfZ2l0X3BhdGggR0lUX0NPTU1PTl9ESVI9YmFyIGxvZ3MvcmVmcyAgICAgICAgICAgICAgICBiYXIvbG9ncy9yZWZzCit0ZXN0X2dpdF9wYXRoIEdJVF9DT01NT05fRElSPWJhciBsb2dzL3JlZnMvICAgICAgICAgICAgICAgYmFyL2xvZ3MvcmVmcy8KIHRlc3RfZ2l0X3BhdGggR0lUX0NPTU1PTl9ESVI9YmFyIGxvZ3MvcmVmcy9iaXNlYy9mb28gICAgICBiYXIvbG9ncy9yZWZzL2Jpc2VjL2ZvbwogdGVzdF9naXRfcGF0aCBHSVRfQ09NTU9OX0RJUj1iYXIgbG9ncy9yZWZzL2Jpc2VjICAgICAgICAgIGJhci9sb2dzL3JlZnMvYmlzZWMKIHRlc3RfZ2l0X3BhdGggR0lUX0NPTU1PTl9ESVI9YmFyIGxvZ3MvcmVmcy9iaXNlY3Rmb28gICAgICBiYXIvbG9ncy9yZWZzL2Jpc2VjdGZvbwpkaWZmIC0tZ2l0IGEvdC90MDA2MS1ydW4tY29tbWFuZC5zaCBiL3QvdDAwNjEtcnVuLWNvbW1hbmQuc2gKaW5kZXggMDE1ZmFjOC4uMTdjOWMwZiAxMDA3NTUKLS0tIGEvdC90MDA2MS1ydW4tY29tbWFuZC5zaAorKysgYi90L3QwMDYxLXJ1bi1jb21tYW5kLnNoCkBAIC0yMTAsMTAgKzIxMCwyMyBAQAogCXRlc3RfY21wIGV4cGVjdCBhY3R1YWwKICcKIAotdGVzdF9leHBlY3Rfc3VjY2VzcyBNSU5HVyAnY2FuIHNwYXduIHdpdGggYXJndlswXSBjb250YWluaW5nIHNwYWNlcycgJwotCWNwICIkR0lUX0JVSUxEX0RJUi90L2hlbHBlci90ZXN0LWZha2Utc3NoJFgiIC4vICYmCi0JdGVzdF9tdXN0X2ZhaWwgIiRQV0QvdGVzdC1mYWtlLXNzaCRYIiAyPmVyciAmJgotCWdyZXAgVFJBU0hfRElSRUNUT1JZIGVycgordGVzdF9leHBlY3Rfc3VjY2VzcyBNSU5HVyAnY2FuIHNwYXduIC5iYXQgd2l0aCBhcmd2WzBdIGNvbnRhaW5pbmcgc3BhY2VzJyAnCisJYmF0PSIkVFJBU0hfRElSRUNUT1JZL2JhdCB3aXRoIHNwYWNlcyBpbiBuYW1lLmJhdCIgJiYKKworCSMgRXZlcnkgLmJhdCBpbnZvY2F0aW9uIHdpbGwgbG9nIGl0cyBhcmd1bWVudHMgdG8gZmlsZSAib3V0IgorCXJtIC1mIG91dCAmJgorCWVjaG8gImVjaG8gJSogPj5vdXQiID4iJGJhdCIgJiYKKworCSMgQXNrIGdpdCB0byBpbnZva2UgLmJhdDsgY2xvbmUgd2lsbCBmYWlsIGR1ZSB0byBmYWtlIFNTSCBoZWxwZXIKKwl0ZXN0X211c3RfZmFpbCBlbnYgR0lUX1NTSD0iJGJhdCIgZ2l0IGNsb25lIG15aG9zdDpzcmMgc3NoLWNsb25lICYmCisKKwkjIFNwYXduaW5nIC5iYXQgY2FuIGZhaWwgaWYgdGhlcmUgYXJlIHR3byBxdW90ZWQgY21kLmV4ZSBhcmd1bWVudHMuCisJIyAuYmF0IGl0c2VsZiBpcyBmaXJzdCAoZHVlIHRvIHNwYWNlcyBpbiBuYW1lKSwgc28ganVzdCBvbmUgbW9yZSBpcworCSMgbmVlZGVkIHRvIHZlcmlmeS4gR0lUX1NTSCB3aWxsIGludm9rZSAuYmF0IG11bHRpcGxlIHRpbWVzOgorCSMgMSkgLUcgbXlob3N0CisJIyAyKSBteWhvc3QgImdpdC11cGxvYWQtcGFjayBzcmMiCisJIyBGaXJzdCBpbnZvY2F0aW9uIHdpbGwgYWx3YXlzIHN1Y2NlZWQuIFRlc3QgdGhlIHNlY29uZCBvbmUuCisJZ3JlcCAiZ2l0LXVwbG9hZC1wYWNrIiBvdXQKICcKIAogdGVzdF9kb25lCmRpZmYgLS1naXQgYS90L3QwMjExLXRyYWNlMi1wZXJmLnNoIGIvdC90MDIxMS10cmFjZTItcGVyZi5zaAppbmRleCAyYzNhZDZlLi42ZWU4ZWUzIDEwMDc1NQotLS0gYS90L3QwMjExLXRyYWNlMi1wZXJmLnNoCisrKyBiL3QvdDAyMTEtdHJhY2UyLXBlcmYuc2gKQEAgLTEzMCwxMSArMTMwLDExIEBACiAJCWQwfG1haW58dmVyc2lvbnx8fHx8JFYKIAkJZDB8bWFpbnxzdGFydHx8X1RfQUJTX3x8fF9FWEVfIHRyYWNlMiAwMDRjaGlsZCB0ZXN0LXRvb2wgdHJhY2UyIDAwNGNoaWxkIHRlc3QtdG9vbCB0cmFjZTIgMDAxcmV0dXJuIDAKIAkJZDB8bWFpbnxjbWRfbmFtZXx8fHx8dHJhY2UyICh0cmFjZTIpCi0JCWQwfG1haW58Y2hpbGRfc3RhcnR8fF9UX0FCU198fHxbY2gwXSBjbGFzczo/IGFyZ3Y6IHRlc3QtdG9vbCB0cmFjZTIgMDA0Y2hpbGQgdGVzdC10b29sIHRyYWNlMiAwMDFyZXR1cm4gMAorCQlkMHxtYWlufGNoaWxkX3N0YXJ0fHxfVF9BQlNffHx8W2NoMF0gY2xhc3M6PyBhcmd2Olt0ZXN0LXRvb2wgdHJhY2UyIDAwNGNoaWxkIHRlc3QtdG9vbCB0cmFjZTIgMDAxcmV0dXJuIDBdCiAJCWQxfG1haW58dmVyc2lvbnx8fHx8JFYKIAkJZDF8bWFpbnxzdGFydHx8X1RfQUJTX3x8fF9FWEVfIHRyYWNlMiAwMDRjaGlsZCB0ZXN0LXRvb2wgdHJhY2UyIDAwMXJldHVybiAwCiAJCWQxfG1haW58Y21kX25hbWV8fHx8fHRyYWNlMiAodHJhY2UyL3RyYWNlMikKLQkJZDF8bWFpbnxjaGlsZF9zdGFydHx8X1RfQUJTX3x8fFtjaDBdIGNsYXNzOj8gYXJndjogdGVzdC10b29sIHRyYWNlMiAwMDFyZXR1cm4gMAorCQlkMXxtYWlufGNoaWxkX3N0YXJ0fHxfVF9BQlNffHx8W2NoMF0gY2xhc3M6PyBhcmd2Olt0ZXN0LXRvb2wgdHJhY2UyIDAwMXJldHVybiAwXQogCQlkMnxtYWlufHZlcnNpb258fHx8fCRWCiAJCWQyfG1haW58c3RhcnR8fF9UX0FCU198fHxfRVhFXyB0cmFjZTIgMDAxcmV0dXJuIDAKIAkJZDJ8bWFpbnxjbWRfbmFtZXx8fHx8dHJhY2UyICh0cmFjZTIvdHJhY2UyL3RyYWNlMikKZGlmZiAtLWdpdCBhL3QvdDAyMTItdHJhY2UyLWV2ZW50LnNoIGIvdC90MDIxMi10cmFjZTItZXZlbnQuc2gKaW5kZXggZmY1YjljYy4uNzA2NWExYiAxMDA3NTUKLS0tIGEvdC90MDIxMi10cmFjZTItZXZlbnQuc2gKKysrIGIvdC90MDIxMi10cmFjZTItZXZlbnQuc2gKQEAgLTI2NSw0ICsyNjUsMjMgQEAKIAl0ZXN0X2NtcCBleHBlY3QgYWN0dWFsCiAnCiAKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2Rpc2NhcmQgdHJhY2VzIHdoZW4gdGhlcmUgYXJlIHRvbyBtYW55IGZpbGVzJyAnCisJbWtkaXIgdHJhY2VfdGFyZ2V0X2RpciAmJgorCXRlc3Rfd2hlbl9maW5pc2hlZCAicm0gLXIgdHJhY2VfdGFyZ2V0X2RpciIgJiYKKwkoCisJCUdJVF9UUkFDRTJfTUFYX0ZJTEVTPTUgJiYKKwkJZXhwb3J0IEdJVF9UUkFDRTJfTUFYX0ZJTEVTICYmCisJCWNkIHRyYWNlX3RhcmdldF9kaXIgJiYKKwkJdGVzdF9zZXEgJEdJVF9UUkFDRTJfTUFYX0ZJTEVTID4uLi9leHBlY3RlZF9maWxlbmFtZXMudHh0ICYmCisJCXhhcmdzIHRvdWNoIDwuLi9leHBlY3RlZF9maWxlbmFtZXMudHh0ICYmCisJCWNkIC4uICYmCisJCUdJVF9UUkFDRTJfRVZFTlQ9IiQocHdkKS90cmFjZV90YXJnZXRfZGlyIiB0ZXN0LXRvb2wgdHJhY2UyIDAwMXJldHVybiAwCisJKSAmJgorCWVjaG8gZ2l0LXRyYWNlMi1kaXNjYXJkID4+ZXhwZWN0ZWRfZmlsZW5hbWVzLnR4dCAmJgorCWxzIHRyYWNlX3RhcmdldF9kaXIgPmxzX291dHB1dC50eHQgJiYKKwl0ZXN0X2NtcCBleHBlY3RlZF9maWxlbmFtZXMudHh0IGxzX291dHB1dC50eHQgJiYKKwloZWFkIC1uMSB0cmFjZV90YXJnZXRfZGlyL2dpdC10cmFjZTItZGlzY2FyZCB8IGdyZXAgXCJldmVudFwiOlwidmVyc2lvblwiICYmCisJaGVhZCAtbjIgdHJhY2VfdGFyZ2V0X2Rpci9naXQtdHJhY2UyLWRpc2NhcmQgfCB0YWlsIC1uMSB8IGdyZXAgXCJldmVudFwiOlwidG9vX21hbnlfZmlsZXNcIgorJworCiB0ZXN0X2RvbmUKZGlmZiAtLWdpdCBhL3QvdDA0MTAtcGFydGlhbC1jbG9uZS5zaCBiL3QvdDA0MTAtcGFydGlhbC1jbG9uZS5zaAppbmRleCA1YmQ4OTJmLi5hMzk4OGJkIDEwMDc1NQotLS0gYS90L3QwNDEwLXBhcnRpYWwtY2xvbmUuc2gKKysrIGIvdC90MDQxMC1wYXJ0aWFsLWNsb25lLnNoCkBAIC0yNiw3ICsyNiw3IEBACiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdleHRlbnNpb25zLnBhcnRpYWxjbG9uZSB3aXRob3V0IGZpbHRlcicgJwogCXRlc3RfY3JlYXRlX3JlcG8gc2VydmVyICYmCiAJZ2l0IGNsb25lIC0tZmlsdGVyPSJibG9iOm5vbmUiICJmaWxlOi8vJChwd2QpL3NlcnZlciIgY2xpZW50ICYmCi0JZ2l0IC1DIGNsaWVudCBjb25maWcgLS11bnNldCBjb3JlLnBhcnRpYWxjbG9uZWZpbHRlciAmJgorCWdpdCAtQyBjbGllbnQgY29uZmlnIC0tdW5zZXQgcmVtb3RlLm9yaWdpbi5wYXJ0aWFsY2xvbmVmaWx0ZXIgJiYKIAlnaXQgLUMgY2xpZW50IGZldGNoIG9yaWdpbgogJwogCkBAIC0xNjYsOCArMTY2LDkgQEAKIAkjIGFzc29jaWF0ZWQgcGFja2ZpbGUgY29udGFpbnMgdGhlIG9iamVjdAogCWxzIHJlcG8vLmdpdC9vYmplY3RzL3BhY2svcGFjay0qLnByb21pc29yID5wcm9taXNvcmxpc3QgJiYKIAl0ZXN0X2xpbmVfY291bnQgPSAxIHByb21pc29ybGlzdCAmJgotCUlEWD0kKGNhdCBwcm9taXNvcmxpc3QgfCBzZWQgInMvcHJvbWlzb3IkL2lkeC8iKSAmJgotCWdpdCB2ZXJpZnktcGFjayAtLXZlcmJvc2UgIiRJRFgiIHwgZ3JlcCAiJEhBU0giCisJSURYPSQoc2VkICJzL3Byb21pc29yJC9pZHgvIiBwcm9taXNvcmxpc3QpICYmCisJZ2l0IHZlcmlmeS1wYWNrIC0tdmVyYm9zZSAiJElEWCIgPm91dCAmJgorCWdyZXAgIiRIQVNIIiBvdXQKICcKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnZmV0Y2hpbmcgb2YgbWlzc2luZyBvYmplY3RzIHdvcmtzIHdpdGggcmVmLWluLXdhbnQgZW5hYmxlZCcgJwpAQCAtMTgyLDggKzE4Myw1NSBAQAogCWdyZXAgImdpdDwgZmV0Y2g9LipyZWYtaW4td2FudCIgdHJhY2UKICcKIAordGVzdF9leHBlY3Rfc3VjY2VzcyAnZmV0Y2hpbmcgb2YgbWlzc2luZyBvYmplY3RzIGZyb20gYW5vdGhlciBwcm9taXNvciByZW1vdGUnICcKKwlnaXQgY2xvbmUgImZpbGU6Ly8kKHB3ZCkvc2VydmVyIiBzZXJ2ZXIyICYmCisJdGVzdF9jb21taXQgLUMgc2VydmVyMiBiYXIgJiYKKwlnaXQgLUMgc2VydmVyMiByZXBhY2sgLWEgLWQgLS13cml0ZS1iaXRtYXAtaW5kZXggJiYKKwlIQVNIMj0kKGdpdCAtQyBzZXJ2ZXIyIHJldi1wYXJzZSBiYXIpICYmCisKKwlnaXQgLUMgcmVwbyByZW1vdGUgYWRkIHNlcnZlcjIgImZpbGU6Ly8kKHB3ZCkvc2VydmVyMiIgJiYKKwlnaXQgLUMgcmVwbyBjb25maWcgcmVtb3RlLnNlcnZlcjIucHJvbWlzb3IgdHJ1ZSAmJgorCWdpdCAtQyByZXBvIGNhdC1maWxlIC1wICIkSEFTSDIiICYmCisKKwlnaXQgLUMgcmVwbyBmZXRjaCBzZXJ2ZXIyICYmCisJcm0gLXJmIHJlcG8vLmdpdC9vYmplY3RzLyogJiYKKwlnaXQgLUMgcmVwbyBjYXQtZmlsZSAtcCAiJEhBU0gyIiAmJgorCisJIyBFbnN1cmUgdGhhdCB0aGUgLnByb21pc29yIGZpbGUgaXMgd3JpdHRlbiwgYW5kIGNoZWNrIHRoYXQgaXRzCisJIyBhc3NvY2lhdGVkIHBhY2tmaWxlIGNvbnRhaW5zIHRoZSBvYmplY3QKKwlscyByZXBvLy5naXQvb2JqZWN0cy9wYWNrL3BhY2stKi5wcm9taXNvciA+cHJvbWlzb3JsaXN0ICYmCisJdGVzdF9saW5lX2NvdW50ID0gMSBwcm9taXNvcmxpc3QgJiYKKwlJRFg9JChzZWQgInMvcHJvbWlzb3IkL2lkeC8iIHByb21pc29ybGlzdCkgJiYKKwlnaXQgdmVyaWZ5LXBhY2sgLS12ZXJib3NlICIkSURYIiA+b3V0ICYmCisJZ3JlcCAiJEhBU0gyIiBvdXQKKycKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAnZmV0Y2hpbmcgb2YgbWlzc2luZyBvYmplY3RzIGNvbmZpZ3VyZXMgYSBwcm9taXNvciByZW1vdGUnICcKKwlnaXQgY2xvbmUgImZpbGU6Ly8kKHB3ZCkvc2VydmVyIiBzZXJ2ZXIzICYmCisJdGVzdF9jb21taXQgLUMgc2VydmVyMyBiYXogJiYKKwlnaXQgLUMgc2VydmVyMyByZXBhY2sgLWEgLWQgLS13cml0ZS1iaXRtYXAtaW5kZXggJiYKKwlIQVNIMz0kKGdpdCAtQyBzZXJ2ZXIzIHJldi1wYXJzZSBiYXopICYmCisJZ2l0IC1DIHNlcnZlcjMgY29uZmlnIHVwbG9hZHBhY2suYWxsb3dmaWx0ZXIgMSAmJgorCisJcm0gcmVwby8uZ2l0L29iamVjdHMvcGFjay9wYWNrLSoucHJvbWlzb3IgJiYKKworCWdpdCAtQyByZXBvIHJlbW90ZSBhZGQgc2VydmVyMyAiZmlsZTovLyQocHdkKS9zZXJ2ZXIzIiAmJgorCWdpdCAtQyByZXBvIGZldGNoIC0tZmlsdGVyPSJibG9iOm5vbmUiIHNlcnZlcjMgJEhBU0gzICYmCisKKwl0ZXN0X2NtcF9jb25maWcgLUMgcmVwbyB0cnVlIHJlbW90ZS5zZXJ2ZXIzLnByb21pc29yICYmCisKKwkjIEVuc3VyZSB0aGF0IHRoZSAucHJvbWlzb3IgZmlsZSBpcyB3cml0dGVuLCBhbmQgY2hlY2sgdGhhdCBpdHMKKwkjIGFzc29jaWF0ZWQgcGFja2ZpbGUgY29udGFpbnMgdGhlIG9iamVjdAorCWxzIHJlcG8vLmdpdC9vYmplY3RzL3BhY2svcGFjay0qLnByb21pc29yID5wcm9taXNvcmxpc3QgJiYKKwl0ZXN0X2xpbmVfY291bnQgPSAxIHByb21pc29ybGlzdCAmJgorCUlEWD0kKHNlZCAicy9wcm9taXNvciQvaWR4LyIgcHJvbWlzb3JsaXN0KSAmJgorCWdpdCB2ZXJpZnktcGFjayAtLXZlcmJvc2UgIiRJRFgiID5vdXQgJiYKKwlncmVwICIkSEFTSDMiIG91dAorJworCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdmZXRjaGluZyBvZiBtaXNzaW5nIGJsb2JzIHdvcmtzJyAnCi0Jcm0gLXJmIHNlcnZlciByZXBvICYmCisJcm0gLXJmIHNlcnZlciBzZXJ2ZXIyIHJlcG8gJiYKKwlybSAtcmYgc2VydmVyIHNlcnZlcjMgcmVwbyAmJgogCXRlc3RfY3JlYXRlX3JlcG8gc2VydmVyICYmCiAJdGVzdF9jb21taXQgLUMgc2VydmVyIGZvbyAmJgogCWdpdCAtQyBzZXJ2ZXIgcmVwYWNrIC1hIC1kIC0td3JpdGUtYml0bWFwLWluZGV4ICYmCkBAIC0yMzQsNyArMjgyLDcgQEAKIAogCWdpdCAtQyByZXBvIGNvbmZpZyBjb3JlLnJlcG9zaXRvcnlmb3JtYXR2ZXJzaW9uIDEgJiYKIAlnaXQgLUMgcmVwbyBjb25maWcgZXh0ZW5zaW9ucy5wYXJ0aWFsY2xvbmUgImFyYml0cmFyeSBzdHJpbmciICYmCi0JR0lUX1RFU1RfQ09NTUlUX0dSQVBIPTAgZ2l0IC1DIHJlcG8gcmV2LWxpc3QgLS1leGNsdWRlLXByb21pc29yLW9iamVjdHMgLS1vYmplY3RzIGJhciA+b3V0ICYmCisJR0lUX1RFU1RfQ09NTUlUX0dSQVBIPTAgZ2l0IC1DIHJlcG8gLWMgY29yZS5jb21taXRHcmFwaD1mYWxzZSByZXYtbGlzdCAtLWV4Y2x1ZGUtcHJvbWlzb3Itb2JqZWN0cyAtLW9iamVjdHMgYmFyID5vdXQgJiYKIAlncmVwICQoZ2l0IC1DIHJlcG8gcmV2LXBhcnNlIGJhcikgb3V0ICYmCiAJISBncmVwICRGT08gb3V0CiAnCkBAIC0zODEsNiArNDI5LDE5IEBACiAJZG9uZQogJwogCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdzaW5nbGUgcHJvbWlzb3IgcmVtb3RlIGNhbiBiZSByZS1pbml0aWFsaXplZCBncmFjZWZ1bGx5JyAnCisJIyBlbnN1cmUgb25lIHByb21pc29yIGlzIGluIHRoZSBwcm9taXNvcnMgbGlzdAorCXJtIC1yZiByZXBvICYmCisJdGVzdF9jcmVhdGVfcmVwbyByZXBvICYmCisJdGVzdF9jcmVhdGVfcmVwbyBvdGhlciAmJgorCWdpdCAtQyByZXBvIHJlbW90ZSBhZGQgZm9vICJmaWxlOi8vJChwd2QpL290aGVyIiAmJgorCWdpdCAtQyByZXBvIGNvbmZpZyByZW1vdGUuZm9vLnByb21pc29yIHRydWUgJiYKKwlnaXQgLUMgcmVwbyBjb25maWcgZXh0ZW5zaW9ucy5wYXJ0aWFsY2xvbmUgZm9vICYmCisKKwkjIHJlaW5pdGlhbGl6ZSB0aGUgcHJvbWlzb3JzIGxpc3QKKwlnaXQgLUMgcmVwbyBmZXRjaCAtLWZpbHRlcj1ibG9iOm5vbmUgZm9vCisnCisKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2djIHJlcGFja3MgcHJvbWlzb3Igb2JqZWN0cyBzZXBhcmF0ZWx5IGZyb20gbm9uLXByb21pc29yIG9iamVjdHMnICcKIAlybSAtcmYgcmVwbyAmJgogCXRlc3RfY3JlYXRlX3JlcG8gcmVwbyAmJgpAQCAtNDkyLDYgKzU1MywyMCBAQAogCSEgZ3JlcCAiJFRSRUVfSEFTSCIgb3V0CiAnCiAKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2RvIG5vdCBmZXRjaCB3aGVuIGNoZWNraW5nIGV4aXN0ZW5jZSBvZiB0cmVlIHdlIGNvbnN0cnVjdCBvdXJzZWx2ZXMnICcKKwlybSAtcmYgcmVwbyAmJgorCXRlc3RfY3JlYXRlX3JlcG8gcmVwbyAmJgorCXRlc3RfY29tbWl0IC1DIHJlcG8gYmFzZSAmJgorCXRlc3RfY29tbWl0IC1DIHJlcG8gc2lkZTEgJiYKKwlnaXQgLUMgcmVwbyBjaGVja291dCBiYXNlICYmCisJdGVzdF9jb21taXQgLUMgcmVwbyBzaWRlMiAmJgorCisJZ2l0IC1DIHJlcG8gY29uZmlnIGNvcmUucmVwb3NpdG9yeWZvcm1hdHZlcnNpb24gMSAmJgorCWdpdCAtQyByZXBvIGNvbmZpZyBleHRlbnNpb25zLnBhcnRpYWxjbG9uZSAiYXJiaXRyYXJ5IHN0cmluZyIgJiYKKworCWdpdCAtQyByZXBvIGNoZXJyeS1waWNrIHNpZGUxCisnCisKIC4gIiRURVNUX0RJUkVDVE9SWSIvbGliLWh0dHBkLnNoCiBzdGFydF9odHRwZAogCkBAIC01MTQsOCArNTg5LDEyIEBACiAJIyBhc3NvY2lhdGVkIHBhY2tmaWxlIGNvbnRhaW5zIHRoZSBvYmplY3QKIAlscyByZXBvLy5naXQvb2JqZWN0cy9wYWNrL3BhY2stKi5wcm9taXNvciA+cHJvbWlzb3JsaXN0ICYmCiAJdGVzdF9saW5lX2NvdW50ID0gMSBwcm9taXNvcmxpc3QgJiYKLQlJRFg9JChjYXQgcHJvbWlzb3JsaXN0IHwgc2VkICJzL3Byb21pc29yJC9pZHgvIikgJiYKLQlnaXQgdmVyaWZ5LXBhY2sgLS12ZXJib3NlICIkSURYIiB8IGdyZXAgIiRIQVNIIgorCUlEWD0kKHNlZCAicy9wcm9taXNvciQvaWR4LyIgcHJvbWlzb3JsaXN0KSAmJgorCWdpdCB2ZXJpZnktcGFjayAtLXZlcmJvc2UgIiRJRFgiID5vdXQgJiYKKwlncmVwICIkSEFTSCIgb3V0CiAnCiAKKyMgRE8gTk9UIGFkZCBub24taHR0cGQtc3BlY2lmaWMgdGVzdHMgaGVyZSwgYmVjYXVzZSB0aGUgbGFzdCBwYXJ0IG9mIHRoaXMKKyMgdGVzdCBzY3JpcHQgaXMgb25seSBleGVjdXRlZCB3aGVuIGh0dHBkIGlzIGF2YWlsYWJsZSBhbmQgZW5hYmxlZC4KKwogdGVzdF9kb25lCmRpZmYgLS1naXQgYS90L3QwNTAwLXByb2dyZXNzLWRpc3BsYXkuc2ggYi90L3QwNTAwLXByb2dyZXNzLWRpc3BsYXkuc2gKbmV3IGZpbGUgbW9kZSAxMDA3NTUKaW5kZXggMDAwMDAwMC4uZDJkMDg4ZAotLS0gL2Rldi9udWxsCisrKyBiL3QvdDA1MDAtcHJvZ3Jlc3MtZGlzcGxheS5zaApAQCAtMCwwICsxLDI4NiBAQAorIyEvYmluL3NoCisKK3Rlc3RfZGVzY3JpcHRpb249J3Byb2dyZXNzIGRpc3BsYXknCisKKy4gLi90ZXN0LWxpYi5zaAorCitzaG93X2NyICgpIHsKKwl0ciAnXDAxNScgUSB8IHNlZCAtZSAicy9RLzxDUj5cXCRMRi9nIgorfQorCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdzaW1wbGUgcHJvZ3Jlc3MgZGlzcGxheScgJworCWNhdCA+ZXhwZWN0IDw8LVxFT0YgJiYKKwlXb3JraW5nIGhhcmQ6IDE8Q1I+CisJV29ya2luZyBoYXJkOiAyPENSPgorCVdvcmtpbmcgaGFyZDogNTxDUj4KKwlXb3JraW5nIGhhcmQ6IDUsIGRvbmUuCisJRU9GCisKKwljYXQgPmluIDw8LVxFT0YgJiYKKwl1cGRhdGUKKwlwcm9ncmVzcyAxCisJdXBkYXRlCisJcHJvZ3Jlc3MgMgorCXByb2dyZXNzIDMKKwlwcm9ncmVzcyA0CisJdXBkYXRlCisJcHJvZ3Jlc3MgNQorCUVPRgorCXRlc3QtdG9vbCBwcm9ncmVzcyAiV29ya2luZyBoYXJkIiA8aW4gMj5zdGRlcnIgJiYKKworCXNob3dfY3IgPHN0ZGVyciA+b3V0ICYmCisJdGVzdF9pMThuY21wIGV4cGVjdCBvdXQKKycKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAncHJvZ3Jlc3MgZGlzcGxheSB3aXRoIHRvdGFsJyAnCisJY2F0ID5leHBlY3QgPDwtXEVPRiAmJgorCVdvcmtpbmcgaGFyZDogIDMzJSAoMS8zKTxDUj4KKwlXb3JraW5nIGhhcmQ6ICA2NiUgKDIvMyk8Q1I+CisJV29ya2luZyBoYXJkOiAxMDAlICgzLzMpPENSPgorCVdvcmtpbmcgaGFyZDogMTAwJSAoMy8zKSwgZG9uZS4KKwlFT0YKKworCWNhdCA+aW4gPDwtXEVPRiAmJgorCXByb2dyZXNzIDEKKwlwcm9ncmVzcyAyCisJcHJvZ3Jlc3MgMworCUVPRgorCXRlc3QtdG9vbCBwcm9ncmVzcyAtLXRvdGFsPTMgIldvcmtpbmcgaGFyZCIgPGluIDI+c3RkZXJyICYmCisKKwlzaG93X2NyIDxzdGRlcnIgPm91dCAmJgorCXRlc3RfaTE4bmNtcCBleHBlY3Qgb3V0CisnCisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3Byb2dyZXNzIGRpc3BsYXkgYnJlYWtzIGxvbmcgbGluZXMgIzEnICcKKwlzZWQgLWUgInMvWiQvLyIgPmV4cGVjdCA8PFxFT0YgJiYKK1dvcmtpbmcgaGFyZC4uLi4uLi4yLi4uLi4uLi4uMy4uLi4uLi4uLjQuLi4uLi4uLi41Li4uLi4uLi4uNjogICAwJSAoMTAwLzEwMDAwMCk8Q1I+CitXb3JraW5nIGhhcmQuLi4uLi4uMi4uLi4uLi4uLjMuLi4uLi4uLi40Li4uLi4uLi4uNS4uLi4uLi4uLjY6ICAgMSUgKDEwMDAvMTAwMDAwKTxDUj4KK1dvcmtpbmcgaGFyZC4uLi4uLi4yLi4uLi4uLi4uMy4uLi4uLi4uLjQuLi4uLi4uLi41Li4uLi4uLi4uNjogICAgICAgICAgICAgICAgICAgWgorICAgMTAlICgxMDAwMC8xMDAwMDApPENSPgorICAxMDAlICgxMDAwMDAvMTAwMDAwKTxDUj4KKyAgMTAwJSAoMTAwMDAwLzEwMDAwMCksIGRvbmUuCitFT0YKKworCWNhdCA+aW4gPDwtXEVPRiAmJgorCXByb2dyZXNzIDEwMAorCXByb2dyZXNzIDEwMDAKKwlwcm9ncmVzcyAxMDAwMAorCXByb2dyZXNzIDEwMDAwMAorCUVPRgorCXRlc3QtdG9vbCBwcm9ncmVzcyAtLXRvdGFsPTEwMDAwMCBcCisJCSJXb3JraW5nIGhhcmQuLi4uLi4uMi4uLi4uLi4uLjMuLi4uLi4uLi40Li4uLi4uLi4uNS4uLi4uLi4uLjYiIFwKKwkJPGluIDI+c3RkZXJyICYmCisKKwlzaG93X2NyIDxzdGRlcnIgPm91dCAmJgorCXRlc3RfaTE4bmNtcCBleHBlY3Qgb3V0CisnCisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3Byb2dyZXNzIGRpc3BsYXkgYnJlYWtzIGxvbmcgbGluZXMgIzInICcKKwkjIE5vdGU6IHdlIGRvIG5vdCBuZWVkIHRoYXQgbWFueSBzcGFjZXMgYWZ0ZXIgdGhlIHRpdGxlIHRvIGNvdmVyIHVwCisJIyB0aGUgbGFzdCBsaW5lIGJlZm9yZSBicmVha2luZyB0aGUgcHJvZ3Jlc3MgbGluZS4KKwlzZWQgLWUgInMvWiQvLyIgPmV4cGVjdCA8PFxFT0YgJiYKK1dvcmtpbmcgaGFyZC4uLi4uLi4yLi4uLi4uLi4uMy4uLi4uLi4uLjQuLi4uLi4uLi41Li4uLi4uLi4uNjogICAwJSAoMS8xMDAwMDApPENSPgorV29ya2luZyBoYXJkLi4uLi4uLjIuLi4uLi4uLi4zLi4uLi4uLi4uNC4uLi4uLi4uLjUuLi4uLi4uLi42OiAgIDAlICgyLzEwMDAwMCk8Q1I+CitXb3JraW5nIGhhcmQuLi4uLi4uMi4uLi4uLi4uLjMuLi4uLi4uLi40Li4uLi4uLi4uNS4uLi4uLi4uLjY6ICAgICAgICAgICAgICAgICAgIFoKKyAgIDEwJSAoMTAwMDAvMTAwMDAwKTxDUj4KKyAgMTAwJSAoMTAwMDAwLzEwMDAwMCk8Q1I+CisgIDEwMCUgKDEwMDAwMC8xMDAwMDApLCBkb25lLgorRU9GCisKKwljYXQgPmluIDw8LVxFT0YgJiYKKwl1cGRhdGUKKwlwcm9ncmVzcyAxCisJdXBkYXRlCisJcHJvZ3Jlc3MgMgorCXByb2dyZXNzIDEwMDAwCisJcHJvZ3Jlc3MgMTAwMDAwCisJRU9GCisJdGVzdC10b29sIHByb2dyZXNzIC0tdG90YWw9MTAwMDAwIFwKKwkJIldvcmtpbmcgaGFyZC4uLi4uLi4yLi4uLi4uLi4uMy4uLi4uLi4uLjQuLi4uLi4uLi41Li4uLi4uLi4uNiIgXAorCQk8aW4gMj5zdGRlcnIgJiYKKworCXNob3dfY3IgPHN0ZGVyciA+b3V0ICYmCisJdGVzdF9pMThuY21wIGV4cGVjdCBvdXQKKycKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAncHJvZ3Jlc3MgZGlzcGxheSBicmVha3MgbG9uZyBsaW5lcyAjMyAtIGV2ZW4gdGhlIGZpcnN0IGlzIHRvbyBsb25nJyAnCisJIyBOb3RlOiB3ZSBkbyBub3QgYWN0dWFsbHkgbmVlZCBhbnkgc3BhY2VzIGF0IHRoZSBlbmQgb2YgdGhlIHRpdGxlCisJIyBsaW5lLCBiZWNhdXNlIHRoZXJlIGlzIG5vIHByZXZpb3VzIHByb2dyZXNzIGxpbmUgdG8gY292ZXIgdXAuCisJc2VkIC1lICJzL1okLy8iID5leHBlY3QgPDxcRU9GICYmCitXb3JraW5nIGhhcmQuLi4uLi4uMi4uLi4uLi4uLjMuLi4uLi4uLi40Li4uLi4uLi4uNS4uLi4uLi4uLjY6ICAgICAgICAgICAgICAgICAgIFoKKyAgIDI1JSAoMjUwMDAvMTAwMDAwKTxDUj4KKyAgIDUwJSAoNTAwMDAvMTAwMDAwKTxDUj4KKyAgIDc1JSAoNzUwMDAvMTAwMDAwKTxDUj4KKyAgMTAwJSAoMTAwMDAwLzEwMDAwMCk8Q1I+CisgIDEwMCUgKDEwMDAwMC8xMDAwMDApLCBkb25lLgorRU9GCisKKwljYXQgPmluIDw8LVxFT0YgJiYKKwlwcm9ncmVzcyAyNTAwMAorCXByb2dyZXNzIDUwMDAwCisJcHJvZ3Jlc3MgNzUwMDAKKwlwcm9ncmVzcyAxMDAwMDAKKwlFT0YKKwl0ZXN0LXRvb2wgcHJvZ3Jlc3MgLS10b3RhbD0xMDAwMDAgXAorCQkiV29ya2luZyBoYXJkLi4uLi4uLjIuLi4uLi4uLi4zLi4uLi4uLi4uNC4uLi4uLi4uLjUuLi4uLi4uLi42IiBcCisJCTxpbiAyPnN0ZGVyciAmJgorCisJc2hvd19jciA8c3RkZXJyID5vdXQgJiYKKwl0ZXN0X2kxOG5jbXAgZXhwZWN0IG91dAorJworCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdwcm9ncmVzcyBkaXNwbGF5IGJyZWFrcyBsb25nIGxpbmVzICM0IC0gdGl0bGUgbGluZSBtYXRjaGVzIHRlcm1pbmFsIHdpZHRoJyAnCisJY2F0ID5leHBlY3QgPDxcRU9GICYmCitXb3JraW5nIGhhcmQuLi4uLi4uMi4uLi4uLi4uLjMuLi4uLi4uLi40Li4uLi4uLi4uNS4uLi4uLi4uLjYuLi4uLi4uLi43Li4uLi4uLi4uOgorICAgMjUlICgyNTAwMC8xMDAwMDApPENSPgorICAgNTAlICg1MDAwMC8xMDAwMDApPENSPgorICAgNzUlICg3NTAwMC8xMDAwMDApPENSPgorICAxMDAlICgxMDAwMDAvMTAwMDAwKTxDUj4KKyAgMTAwJSAoMTAwMDAwLzEwMDAwMCksIGRvbmUuCitFT0YKKworCWNhdCA+aW4gPDwtXEVPRiAmJgorCXByb2dyZXNzIDI1MDAwCisJcHJvZ3Jlc3MgNTAwMDAKKwlwcm9ncmVzcyA3NTAwMAorCXByb2dyZXNzIDEwMDAwMAorCUVPRgorCXRlc3QtdG9vbCBwcm9ncmVzcyAtLXRvdGFsPTEwMDAwMCBcCisJCSJXb3JraW5nIGhhcmQuLi4uLi4uMi4uLi4uLi4uLjMuLi4uLi4uLi40Li4uLi4uLi4uNS4uLi4uLi4uLjYuLi4uLi4uLi43Li4uLi4uLi4uIiBcCisJCTxpbiAyPnN0ZGVyciAmJgorCisJc2hvd19jciA8c3RkZXJyID5vdXQgJiYKKwl0ZXN0X2kxOG5jbXAgZXhwZWN0IG91dAorJworCisjIFByb2dyZXNzIGNvdW50ZXIgZ29lcyBiYWNrd2FyZHMsIHRoaXMgc2hvdWxkIG5vdCBoYXBwZW4gaW4gcHJhY3RpY2UuCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdwcm9ncmVzcyBzaG9ydGVucyAtIGNyYXp5IGNhbGxlcicgJworCWNhdCA+ZXhwZWN0IDw8LVxFT0YgJiYKKwlXb3JraW5nIGhhcmQ6ICAxMCUgKDEwMC8xMDAwKTxDUj4KKwlXb3JraW5nIGhhcmQ6ICAyMCUgKDIwMC8xMDAwKTxDUj4KKwlXb3JraW5nIGhhcmQ6ICAgMCUgKDEvMTAwMCkgIDxDUj4KKwlXb3JraW5nIGhhcmQ6IDEwMCUgKDEwMDAvMTAwMCk8Q1I+CisJV29ya2luZyBoYXJkOiAxMDAlICgxMDAwLzEwMDApLCBkb25lLgorCUVPRgorCisJY2F0ID5pbiA8PC1cRU9GICYmCisJcHJvZ3Jlc3MgMTAwCisJcHJvZ3Jlc3MgMjAwCisJcHJvZ3Jlc3MgMQorCXByb2dyZXNzIDEwMDAKKwlFT0YKKwl0ZXN0LXRvb2wgcHJvZ3Jlc3MgLS10b3RhbD0xMDAwICJXb3JraW5nIGhhcmQiIDxpbiAyPnN0ZGVyciAmJgorCisJc2hvd19jciA8c3RkZXJyID5vdXQgJiYKKwl0ZXN0X2kxOG5jbXAgZXhwZWN0IG91dAorJworCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdwcm9ncmVzcyBkaXNwbGF5IHdpdGggdGhyb3VnaHB1dCcgJworCWNhdCA+ZXhwZWN0IDw8LVxFT0YgJiYKKwlXb3JraW5nIGhhcmQ6IDEwPENSPgorCVdvcmtpbmcgaGFyZDogMjAsIDIwMC4wMCBLaUIgfCAxMDAuMDAgS2lCL3M8Q1I+CisJV29ya2luZyBoYXJkOiAzMCwgMzAwLjAwIEtpQiB8IDEwMC4wMCBLaUIvczxDUj4KKwlXb3JraW5nIGhhcmQ6IDQwLCA0MDAuMDAgS2lCIHwgMTAwLjAwIEtpQi9zPENSPgorCVdvcmtpbmcgaGFyZDogNDAsIDQwMC4wMCBLaUIgfCAxMDAuMDAgS2lCL3MsIGRvbmUuCisJRU9GCisKKwljYXQgPmluIDw8LVxFT0YgJiYKKwl0aHJvdWdocHV0IDEwMjQwMCAxMDAwCisJdXBkYXRlCisJcHJvZ3Jlc3MgMTAKKwl0aHJvdWdocHV0IDIwNDgwMCAyMDAwCisJdXBkYXRlCisJcHJvZ3Jlc3MgMjAKKwl0aHJvdWdocHV0IDMwNzIwMCAzMDAwCisJdXBkYXRlCisJcHJvZ3Jlc3MgMzAKKwl0aHJvdWdocHV0IDQwOTYwMCA0MDAwCisJdXBkYXRlCisJcHJvZ3Jlc3MgNDAKKwlFT0YKKwl0ZXN0LXRvb2wgcHJvZ3Jlc3MgIldvcmtpbmcgaGFyZCIgPGluIDI+c3RkZXJyICYmCisKKwlzaG93X2NyIDxzdGRlcnIgPm91dCAmJgorCXRlc3RfaTE4bmNtcCBleHBlY3Qgb3V0CisnCisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3Byb2dyZXNzIGRpc3BsYXkgd2l0aCB0aHJvdWdocHV0IGFuZCB0b3RhbCcgJworCWNhdCA+ZXhwZWN0IDw8LVxFT0YgJiYKKwlXb3JraW5nIGhhcmQ6ICAyNSUgKDEwLzQwKTxDUj4KKwlXb3JraW5nIGhhcmQ6ICA1MCUgKDIwLzQwKSwgMjAwLjAwIEtpQiB8IDEwMC4wMCBLaUIvczxDUj4KKwlXb3JraW5nIGhhcmQ6ICA3NSUgKDMwLzQwKSwgMzAwLjAwIEtpQiB8IDEwMC4wMCBLaUIvczxDUj4KKwlXb3JraW5nIGhhcmQ6IDEwMCUgKDQwLzQwKSwgNDAwLjAwIEtpQiB8IDEwMC4wMCBLaUIvczxDUj4KKwlXb3JraW5nIGhhcmQ6IDEwMCUgKDQwLzQwKSwgNDAwLjAwIEtpQiB8IDEwMC4wMCBLaUIvcywgZG9uZS4KKwlFT0YKKworCWNhdCA+aW4gPDwtXEVPRiAmJgorCXRocm91Z2hwdXQgMTAyNDAwIDEwMDAKKwlwcm9ncmVzcyAxMAorCXRocm91Z2hwdXQgMjA0ODAwIDIwMDAKKwlwcm9ncmVzcyAyMAorCXRocm91Z2hwdXQgMzA3MjAwIDMwMDAKKwlwcm9ncmVzcyAzMAorCXRocm91Z2hwdXQgNDA5NjAwIDQwMDAKKwlwcm9ncmVzcyA0MAorCUVPRgorCXRlc3QtdG9vbCBwcm9ncmVzcyAtLXRvdGFsPTQwICJXb3JraW5nIGhhcmQiIDxpbiAyPnN0ZGVyciAmJgorCisJc2hvd19jciA8c3RkZXJyID5vdXQgJiYKKwl0ZXN0X2kxOG5jbXAgZXhwZWN0IG91dAorJworCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdjb3ZlciB1cCBhZnRlciB0aHJvdWdocHV0IHNob3J0ZW5zJyAnCisJY2F0ID5leHBlY3QgPDwtXEVPRiAmJgorCVdvcmtpbmcgaGFyZDogMTxDUj4KKwlXb3JraW5nIGhhcmQ6IDIsIDgwMC4wMCBLaUIgfCA0MDAuMDAgS2lCL3M8Q1I+CisJV29ya2luZyBoYXJkOiAzLCAxLjE3IE1pQiB8IDQwMC4wMCBLaUIvcyAgPENSPgorCVdvcmtpbmcgaGFyZDogNCwgMS41NiBNaUIgfCA0MDAuMDAgS2lCL3M8Q1I+CisJV29ya2luZyBoYXJkOiA0LCAxLjU2IE1pQiB8IDQwMC4wMCBLaUIvcywgZG9uZS4KKwlFT0YKKworCWNhdCA+aW4gPDwtXEVPRiAmJgorCXRocm91Z2hwdXQgNDA5NjAwIDEwMDAKKwl1cGRhdGUKKwlwcm9ncmVzcyAxCisJdGhyb3VnaHB1dCA4MTkyMDAgMjAwMAorCXVwZGF0ZQorCXByb2dyZXNzIDIKKwl0aHJvdWdocHV0IDEyMjg4MDAgMzAwMAorCXVwZGF0ZQorCXByb2dyZXNzIDMKKwl0aHJvdWdocHV0IDE2Mzg0MDAgNDAwMAorCXVwZGF0ZQorCXByb2dyZXNzIDQKKwlFT0YKKwl0ZXN0LXRvb2wgcHJvZ3Jlc3MgIldvcmtpbmcgaGFyZCIgPGluIDI+c3RkZXJyICYmCisKKwlzaG93X2NyIDxzdGRlcnIgPm91dCAmJgorCXRlc3RfaTE4bmNtcCBleHBlY3Qgb3V0CisnCisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2NvdmVyIHVwIGFmdGVyIHRocm91Z2hwdXQgc2hvcnRlbnMgYSBsb3QnICcKKwljYXQgPmV4cGVjdCA8PC1cRU9GICYmCisJV29ya2luZyBoYXJkOiAxPENSPgorCVdvcmtpbmcgaGFyZDogMiwgMTAwMC4wMCBLaUIgfCAxMDAwLjAwIEtpQi9zPENSPgorCVdvcmtpbmcgaGFyZDogMywgMy4wMCBNaUIgfCAxLjUwIE1pQi9zICAgICAgPENSPgorCVdvcmtpbmcgaGFyZDogMywgMy4wMCBNaUIgfCAxMDI0LjAwIEtpQi9zLCBkb25lLgorCUVPRgorCisJY2F0ID5pbiA8PC1cRU9GICYmCisJdGhyb3VnaHB1dCAxIDEwMDAKKwl1cGRhdGUKKwlwcm9ncmVzcyAxCisJdGhyb3VnaHB1dCAxMDI0MDAwIDIwMDAKKwl1cGRhdGUKKwlwcm9ncmVzcyAyCisJdGhyb3VnaHB1dCAzMTQ1NzI4IDMwMDAKKwl1cGRhdGUKKwlwcm9ncmVzcyAzCisJRU9GCisJdGVzdC10b29sIHByb2dyZXNzICJXb3JraW5nIGhhcmQiIDxpbiAyPnN0ZGVyciAmJgorCisJc2hvd19jciA8c3RkZXJyID5vdXQgJiYKKwl0ZXN0X2kxOG5jbXAgZXhwZWN0IG91dAorJworCit0ZXN0X2RvbmUKZGlmZiAtLWdpdCBhL3QvdDEwNTAtbGFyZ2Uuc2ggYi90L3QxMDUwLWxhcmdlLnNoCmluZGV4IGRjYjRkYmIuLmQzYjJhZGIgMTAwNzU1Ci0tLSBhL3QvdDEwNTAtbGFyZ2Uuc2gKKysrIGIvdC90MTA1MC1sYXJnZS5zaApAQCAtMTk0LDE1ICsxOTQsMTUgQEAKIAl0ZXN0X2NtcCBodWdlIGFjdHVhbAogJwogCi10ZXN0X2V4cGVjdF9zdWNjZXNzICd0YXIgYWNoaXZpbmcnICcKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3RhciBhcmNoaXZpbmcnICcKIAlnaXQgYXJjaGl2ZSAtLWZvcm1hdD10YXIgSEVBRCA+L2Rldi9udWxsCiAnCiAKLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3ppcCBhY2hpdmluZywgc3RvcmUgb25seScgJwordGVzdF9leHBlY3Rfc3VjY2VzcyAnemlwIGFyY2hpdmluZywgc3RvcmUgb25seScgJwogCWdpdCBhcmNoaXZlIC0tZm9ybWF0PXppcCAtMCBIRUFEID4vZGV2L251bGwKICcKIAotdGVzdF9leHBlY3Rfc3VjY2VzcyAnemlwIGFjaGl2aW5nLCBkZWZsYXRlJyAnCit0ZXN0X2V4cGVjdF9zdWNjZXNzICd6aXAgYXJjaGl2aW5nLCBkZWZsYXRlJyAnCiAJZ2l0IGFyY2hpdmUgLS1mb3JtYXQ9emlwIEhFQUQgPi9kZXYvbnVsbAogJwogCmRpZmYgLS1naXQgYS90L3QxMzAwLWNvbmZpZy5zaCBiL3QvdDEzMDAtY29uZmlnLnNoCmluZGV4IDQyODE3N2MuLjk4M2EwYTEgMTAwNzU1Ci0tLSBhL3QvdDEzMDAtY29uZmlnLnNoCisrKyBiL3QvdDEzMDAtY29uZmlnLnNoCkBAIC0xMjk0LDI2ICsxMjk0LDI1IEBACiAJR0lUX0NPTkZJR19QQVJBTUVURVJTPSIiIGdpdCAtYyB4Lm9uZT0xIGNvbmZpZyAtLWxpc3QKICcKIAotc3E9IiciCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdkZXRlY3QgYm9ndXMgR0lUX0NPTkZJR19QQVJBTUVURVJTJyAnCiAJY2F0ID5leHBlY3QgPDwtXEVPRiAmJgogCWVudi5vbmUgb25lCiAJZW52LnR3byB0d28KIAlFT0YKLQlHSVRfQ09ORklHX1BBUkFNRVRFUlM9IiR7c3F9ZW52Lm9uZT1vbmUke3NxfSAke3NxfWVudi50d289dHdvJHtzcX0iIFwKKwlHSVRfQ09ORklHX1BBUkFNRVRFUlM9IiR7U1F9ZW52Lm9uZT1vbmUke1NRfSAke1NRfWVudi50d289dHdvJHtTUX0iIFwKIAkJZ2l0IGNvbmZpZyAtLWdldC1yZWdleHAgImVudi4qIiA+YWN0dWFsICYmCiAJdGVzdF9jbXAgZXhwZWN0IGFjdHVhbCAmJgogCiAJY2F0ID5leHBlY3QgPDwtRU9GICYmCi0JZW52Lm9uZSBvbmUke3NxfQorCWVudi5vbmUgb25lJHtTUX0KIAllbnYudHdvIHR3bwogCUVPRgotCUdJVF9DT05GSUdfUEFSQU1FVEVSUz0iJHtzcX1lbnYub25lPW9uZSR7c3F9XFwkc3Ekc3Ekc3EgJHtzcX1lbnYudHdvPXR3byR7c3F9IiBcCisJR0lUX0NPTkZJR19QQVJBTUVURVJTPSIke1NRfWVudi5vbmU9b25lJHtTUX1cXCRTUSRTUSRTUSAke1NRfWVudi50d289dHdvJHtTUX0iIFwKIAkJZ2l0IGNvbmZpZyAtLWdldC1yZWdleHAgImVudi4qIiA+YWN0dWFsICYmCiAJdGVzdF9jbXAgZXhwZWN0IGFjdHVhbCAmJgogCiAJdGVzdF9tdXN0X2ZhaWwgZW52IFwKLQkJR0lUX0NPTkZJR19QQVJBTUVURVJTPSIke3NxfWVudi5vbmU9b25lJHtzcX1cXCRzcSAke3NxfWVudi50d289dHdvJHtzcX0iIFwKKwkJR0lUX0NPTkZJR19QQVJBTUVURVJTPSIke1NRfWVudi5vbmU9b25lJHtTUX1cXCRTUSAke1NRfWVudi50d289dHdvJHtTUX0iIFwKIAkJZ2l0IGNvbmZpZyAtLWdldC1yZWdleHAgImVudi4qIgogJwogCmRpZmYgLS1naXQgYS90L3QxMzA1LWNvbmZpZy1pbmNsdWRlLnNoIGIvdC90MTMwNS1jb25maWctaW5jbHVkZS5zaAppbmRleCBkMjBiNGQxLi5mMWUxYjI4IDEwMDc1NQotLS0gYS90L3QxMzA1LWNvbmZpZy1pbmNsdWRlLnNoCisrKyBiL3QvdDEzMDUtY29uZmlnLWluY2x1ZGUuc2gKQEAgLTYzLDcgKzYzLDcgQEAKIAl0ZXN0Lm9uZT0xCiAJRU9GCiAJZ2l0IGNvbmZpZyAtLWxpc3QgPmFjdHVhbC5mdWxsICYmCi0JZ3JlcCAtdiBeY29yZSBhY3R1YWwuZnVsbCA+YWN0dWFsICYmCisJZ3JlcCAtdiAtZSBeY29yZSAtZSBeZXh0ZW5zaW9ucyBhY3R1YWwuZnVsbCA+YWN0dWFsICYmCiAJdGVzdF9jbXAgZXhwZWN0IGFjdHVhbAogJwogCmRpZmYgLS1naXQgYS90L3QxMzA4LWNvbmZpZy1zZXQuc2ggYi90L3QxMzA4LWNvbmZpZy1zZXQuc2gKaW5kZXggZDBhMjcyNy4uN2I0ZTFhNiAxMDA3NTUKLS0tIGEvdC90MTMwOC1jb25maWctc2V0LnNoCisrKyBiL3QvdDEzMDgtY29uZmlnLXNldC5zaApAQCAtMTY2LDE0ICsxNjYsMTQgQEAKICcKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnZmluZCB2YWx1ZV9saXN0IGZvciBhIGtleSBmcm9tIGEgY29uZmlnc2V0JyAnCi0JY2F0ID5leGNlcHQgPDwtXEVPRiAmJgorCWNhdCA+ZXhwZWN0IDw8LVxFT0YgJiYKKwlsYW1hCisJYmFsbAogCXNhbQogCWJhdAogCWhhc2sKLQlsYW1hCi0JYmFsbAogCUVPRgotCXRlc3QtdG9vbCBjb25maWcgY29uZmlnc2V0X2dldF92YWx1ZSBjYXNlLmJheiBjb25maWcyIC5naXQvY29uZmlnID5hY3R1YWwgJiYKKwl0ZXN0LXRvb2wgY29uZmlnIGNvbmZpZ3NldF9nZXRfdmFsdWVfbXVsdGkgY2FzZS5iYXogY29uZmlnMiAuZ2l0L2NvbmZpZyA+YWN0dWFsICYmCiAJdGVzdF9jbXAgZXhwZWN0IGFjdHVhbAogJwogCmRpZmYgLS1naXQgYS90L3QxMzA5LWVhcmx5LWNvbmZpZy5zaCBiL3QvdDEzMDktZWFybHktY29uZmlnLnNoCmluZGV4IDBjMzdlNzEuLjNhMGRlMGQgMTAwNzU1Ci0tLSBhL3QvdDEzMDktZWFybHktY29uZmlnLnNoCisrKyBiL3QvdDEzMDktZWFybHktY29uZmlnLnNoCkBAIC05MSw3ICs5MSwxMiBAQAogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdlYXJseSBjb25maWcgYW5kIG9uYnJhbmNoJyAnCiAJZWNobyAiW2Jyb2tlbiIgPmJyb2tlbiAmJgotCXRlc3Rfd2l0aF9jb25maWcgIltpbmNsdWRlaWYgXCJvbmJyYW5jaDpyZWZzL2hlYWRzL21hc3RlclwiXXBhdGg9Li4vYnJva2VuIgorCXRlc3Rfd2l0aF9jb25maWcgIltpbmNsdWRlaWYgXCJvbmJyYW5jaDptYXN0ZXJcIl1wYXRoPS4uL2Jyb2tlbiIKKycKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAnb25icmFuY2ggY29uZmlnIG91dHNpZGUgb2YgZ2l0IHJlcG8nICcKKwl0ZXN0X2NvbmZpZ19nbG9iYWwgaW5jbHVkZUlmLm9uYnJhbmNoOm1hc3Rlci5wYXRoIG5vbi1leGlzdGVudCAmJgorCW5vbmdpdCBnaXQgaGVscAogJwogCiB0ZXN0X2RvbmUKZGlmZiAtLWdpdCBhL3QvdDE0MDAtdXBkYXRlLXJlZi5zaCBiL3QvdDE0MDAtdXBkYXRlLXJlZi5zaAppbmRleCAxZmJkOTQwLi42OWE3ZjI3IDEwMDc1NQotLS0gYS90L3QxNDAwLXVwZGF0ZS1yZWYuc2gKKysrIGIvdC90MTQwMC11cGRhdGUtcmVmLnNoCkBAIC0zNDQsMTQgKzM0NCwxNiBAQAogCXRlc3RfY21wIGV4cGVjdCAuZ2l0L2xvZ3MvJG0KICcKIAotZ2l0IHVwZGF0ZS1yZWYgJG0gJEQKLWNhdCA+LmdpdC9sb2dzLyRtIDw8RU9GCi0kWiAkQyAkR0lUX0NPTU1JVFRFUl9OQU1FIDwkR0lUX0NPTU1JVFRFUl9FTUFJTD4gMTExNzE1MDMyMCAtMDUwMAotJEMgJEEgJEdJVF9DT01NSVRURVJfTkFNRSA8JEdJVF9DT01NSVRURVJfRU1BSUw+IDExMTcxNTAzNTAgLTA1MDAKLSRBICRCICRHSVRfQ09NTUlUVEVSX05BTUUgPCRHSVRfQ09NTUlUVEVSX0VNQUlMPiAxMTE3MTUwMzgwIC0wNTAwCi0kRiAkWiAkR0lUX0NPTU1JVFRFUl9OQU1FIDwkR0lUX0NPTU1JVFRFUl9FTUFJTD4gMTExNzE1MDY4MCAtMDUwMAotJFogJEUgJEdJVF9DT01NSVRURVJfTkFNRSA8JEdJVF9DT01NSVRURVJfRU1BSUw+IDExMTcxNTA5ODAgLTA1MDAKLUVPRgordGVzdF9leHBlY3Rfc3VjY2VzcyAnc2V0IHVwIGZvciBxdWVyeWluZyB0aGUgcmVmbG9nJyAnCisJZ2l0IHVwZGF0ZS1yZWYgJG0gJEQgJiYKKwljYXQgPi5naXQvbG9ncy8kbSA8PC1FT0YKKwkkWiAkQyAkR0lUX0NPTU1JVFRFUl9OQU1FIDwkR0lUX0NPTU1JVFRFUl9FTUFJTD4gMTExNzE1MDMyMCAtMDUwMAorCSRDICRBICRHSVRfQ09NTUlUVEVSX05BTUUgPCRHSVRfQ09NTUlUVEVSX0VNQUlMPiAxMTE3MTUwMzUwIC0wNTAwCisJJEEgJEIgJEdJVF9DT01NSVRURVJfTkFNRSA8JEdJVF9DT01NSVRURVJfRU1BSUw+IDExMTcxNTAzODAgLTA1MDAKKwkkRiAkWiAkR0lUX0NPTU1JVFRFUl9OQU1FIDwkR0lUX0NPTU1JVFRFUl9FTUFJTD4gMTExNzE1MDY4MCAtMDUwMAorCSRaICRFICRHSVRfQ09NTUlUVEVSX05BTUUgPCRHSVRfQ09NTUlUVEVSX0VNQUlMPiAxMTE3MTUwOTgwIC0wNTAwCisJRU9GCisnCiAKIGVkPSJUaHUsIDI2IE1heSAyMDA1IDE4OjMyOjAwIC0wNTAwIgogZ2Q9IlRodSwgMjYgTWF5IDIwMDUgMTg6MzM6MDAgLTA1MDAiCmRpZmYgLS1naXQgYS90L3QxNDA0LXVwZGF0ZS1yZWYtZXJyb3JzLnNoIGIvdC90MTQwNC11cGRhdGUtcmVmLWVycm9ycy5zaAppbmRleCA5NzBjNWMzLi4yZDE0MmU1IDEwMDc1NQotLS0gYS90L3QxNDA0LXVwZGF0ZS1yZWYtZXJyb3JzLnNoCisrKyBiL3QvdDE0MDQtdXBkYXRlLXJlZi1lcnJvcnMuc2gKQEAgLTMyLDggKzMyLDYgQEAKIAl0ZXN0X2NtcCB1bmNoYW5nZWQgYWN0dWFsCiB9CiAKLVE9IiciCi0KICMgVGVzdCBhZGRpbmcgYW5kIGRlbGV0aW5nIEQvRi1jb25mbGljdGluZyByZWZlcmVuY2VzIGluIGEgc2luZ2xlCiAjIHRyYW5zYWN0aW9uLgogZGZfdGVzdCgpIHsKQEAgLTkzLDcgKzkxLDcgQEAKIAkJZGVsbmFtZT0iJGRlbHJlZiIKIAlmaSAmJgogCWNhdCA+ZXhwZWN0ZWQtZXJyIDw8LUVPRiAmJgotCWZhdGFsOiBjYW5ub3QgbG9jayByZWYgJFEkYWRkbmFtZSRROiAkUSRkZWxyZWYkUSBleGlzdHM7IGNhbm5vdCBjcmVhdGUgJFEkYWRkcmVmJFEKKwlmYXRhbDogY2Fubm90IGxvY2sgcmVmICRTUSRhZGRuYW1lJFNROiAkU1EkZGVscmVmJFNRIGV4aXN0czsgY2Fubm90IGNyZWF0ZSAkU1EkYWRkcmVmJFNRCiAJRU9GCiAJJHBhY2sgJiYKIAlpZiAkYWRkX2RlbApAQCAtMTIzLDcgKzEyMSw3IEBACiAKIAlwcmVmaXg9cmVmcy8xbCAmJgogCXRlc3RfdXBkYXRlX3JlamVjdGVkICJhIGMgZSIgZmFsc2UgImIgYy94IGQiIFwKLQkJIiRRJHByZWZpeC9jJFEgZXhpc3RzOyBjYW5ub3QgY3JlYXRlICRRJHByZWZpeC9jL3gkUSIKKwkJIiRTUSRwcmVmaXgvYyRTUSBleGlzdHM7IGNhbm5vdCBjcmVhdGUgJFNRJHByZWZpeC9jL3gkU1EiCiAKICcKIApAQCAtMTMxLDcgKzEyOSw3IEBACiAKIAlwcmVmaXg9cmVmcy8xcCAmJgogCXRlc3RfdXBkYXRlX3JlamVjdGVkICJhIGMgZSIgdHJ1ZSAiYiBjL3ggZCIgXAotCQkiJFEkcHJlZml4L2MkUSBleGlzdHM7IGNhbm5vdCBjcmVhdGUgJFEkcHJlZml4L2MveCRRIgorCQkiJFNRJHByZWZpeC9jJFNRIGV4aXN0czsgY2Fubm90IGNyZWF0ZSAkU1EkcHJlZml4L2MveCRTUSIKIAogJwogCkBAIC0xMzksNyArMTM3LDcgQEAKIAogCXByZWZpeD1yZWZzLzJsICYmCiAJdGVzdF91cGRhdGVfcmVqZWN0ZWQgImEgYyBlIiBmYWxzZSAiYiBjL3gveSBkIiBcCi0JCSIkUSRwcmVmaXgvYyRRIGV4aXN0czsgY2Fubm90IGNyZWF0ZSAkUSRwcmVmaXgvYy94L3kkUSIKKwkJIiRTUSRwcmVmaXgvYyRTUSBleGlzdHM7IGNhbm5vdCBjcmVhdGUgJFNRJHByZWZpeC9jL3gveSRTUSIKIAogJwogCkBAIC0xNDcsNyArMTQ1LDcgQEAKIAogCXByZWZpeD1yZWZzLzJwICYmCiAJdGVzdF91cGRhdGVfcmVqZWN0ZWQgImEgYyBlIiB0cnVlICJiIGMveC95IGQiIFwKLQkJIiRRJHByZWZpeC9jJFEgZXhpc3RzOyBjYW5ub3QgY3JlYXRlICRRJHByZWZpeC9jL3gveSRRIgorCQkiJFNRJHByZWZpeC9jJFNRIGV4aXN0czsgY2Fubm90IGNyZWF0ZSAkU1EkcHJlZml4L2MveC95JFNRIgogCiAnCiAKQEAgLTE1NSw3ICsxNTMsNyBAQAogCiAJcHJlZml4PXJlZnMvM2wgJiYKIAl0ZXN0X3VwZGF0ZV9yZWplY3RlZCAiYSBjL3ggZSIgZmFsc2UgImIgYyBkIiBcCi0JCSIkUSRwcmVmaXgvYy94JFEgZXhpc3RzOyBjYW5ub3QgY3JlYXRlICRRJHByZWZpeC9jJFEiCisJCSIkU1EkcHJlZml4L2MveCRTUSBleGlzdHM7IGNhbm5vdCBjcmVhdGUgJFNRJHByZWZpeC9jJFNRIgogCiAnCiAKQEAgLTE2Myw3ICsxNjEsNyBAQAogCiAJcHJlZml4PXJlZnMvM3AgJiYKIAl0ZXN0X3VwZGF0ZV9yZWplY3RlZCAiYSBjL3ggZSIgdHJ1ZSAiYiBjIGQiIFwKLQkJIiRRJHByZWZpeC9jL3gkUSBleGlzdHM7IGNhbm5vdCBjcmVhdGUgJFEkcHJlZml4L2MkUSIKKwkJIiRTUSRwcmVmaXgvYy94JFNRIGV4aXN0czsgY2Fubm90IGNyZWF0ZSAkU1EkcHJlZml4L2MkU1EiCiAKICcKIApAQCAtMTcxLDcgKzE2OSw3IEBACiAKIAlwcmVmaXg9cmVmcy80bCAmJgogCXRlc3RfdXBkYXRlX3JlamVjdGVkICJhIGMveC95IGUiIGZhbHNlICJiIGMgZCIgXAotCQkiJFEkcHJlZml4L2MveC95JFEgZXhpc3RzOyBjYW5ub3QgY3JlYXRlICRRJHByZWZpeC9jJFEiCisJCSIkU1EkcHJlZml4L2MveC95JFNRIGV4aXN0czsgY2Fubm90IGNyZWF0ZSAkU1EkcHJlZml4L2MkU1EiCiAKICcKIApAQCAtMTc5LDcgKzE3Nyw3IEBACiAKIAlwcmVmaXg9cmVmcy80cCAmJgogCXRlc3RfdXBkYXRlX3JlamVjdGVkICJhIGMveC95IGUiIHRydWUgImIgYyBkIiBcCi0JCSIkUSRwcmVmaXgvYy94L3kkUSBleGlzdHM7IGNhbm5vdCBjcmVhdGUgJFEkcHJlZml4L2MkUSIKKwkJIiRTUSRwcmVmaXgvYy94L3kkU1EgZXhpc3RzOyBjYW5ub3QgY3JlYXRlICRTUSRwcmVmaXgvYyRTUSIKIAogJwogCkBAIC0xODcsNyArMTg1LDcgQEAKIAogCXByZWZpeD1yZWZzLzUgJiYKIAl0ZXN0X3VwZGF0ZV9yZWplY3RlZCAiYSBlIiBmYWxzZSAiYiBjIGMveCBkIiBcCi0JCSJjYW5ub3QgcHJvY2VzcyAkUSRwcmVmaXgvYyRRIGFuZCAkUSRwcmVmaXgvYy94JFEgYXQgdGhlIHNhbWUgdGltZSIKKwkJImNhbm5vdCBwcm9jZXNzICRTUSRwcmVmaXgvYyRTUSBhbmQgJFNRJHByZWZpeC9jL3gkU1EgYXQgdGhlIHNhbWUgdGltZSIKIAogJwogCkBAIC0zMzQsNyArMzMyLDcgQEAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ21pc3Npbmcgb2xkIHZhbHVlIGJsb2NrcyB1cGRhdGUnICcKIAlwcmVmaXg9cmVmcy9taXNzaW5nLXVwZGF0ZSAmJgogCWNhdCA+ZXhwZWN0ZWQgPDwtRU9GICYmCi0JZmF0YWw6IGNhbm5vdCBsb2NrIHJlZiAkUSRwcmVmaXgvZm9vJFE6IHVuYWJsZSB0byByZXNvbHZlIHJlZmVyZW5jZSAkUSRwcmVmaXgvZm9vJFEKKwlmYXRhbDogY2Fubm90IGxvY2sgcmVmICRTUSRwcmVmaXgvZm9vJFNROiB1bmFibGUgdG8gcmVzb2x2ZSByZWZlcmVuY2UgJFNRJHByZWZpeC9mb28kU1EKIAlFT0YKIAlwcmludGYgIiVzXG4iICJ1cGRhdGUgJHByZWZpeC9mb28gJEUgJEQiIHwKIAl0ZXN0X211c3RfZmFpbCBnaXQgdXBkYXRlLXJlZiAtLXN0ZGluIDI+b3V0cHV0LmVyciAmJgpAQCAtMzQ1LDcgKzM0Myw3IEBACiAJcHJlZml4PXJlZnMvaW5jb3JyZWN0LXVwZGF0ZSAmJgogCWdpdCB1cGRhdGUtcmVmICRwcmVmaXgvZm9vICRDICYmCiAJY2F0ID5leHBlY3RlZCA8PC1FT0YgJiYKLQlmYXRhbDogY2Fubm90IGxvY2sgcmVmICRRJHByZWZpeC9mb28kUTogaXMgYXQgJEMgYnV0IGV4cGVjdGVkICRECisJZmF0YWw6IGNhbm5vdCBsb2NrIHJlZiAkU1EkcHJlZml4L2ZvbyRTUTogaXMgYXQgJEMgYnV0IGV4cGVjdGVkICRECiAJRU9GCiAJcHJpbnRmICIlc1xuIiAidXBkYXRlICRwcmVmaXgvZm9vICRFICREIiB8CiAJdGVzdF9tdXN0X2ZhaWwgZ2l0IHVwZGF0ZS1yZWYgLS1zdGRpbiAyPm91dHB1dC5lcnIgJiYKQEAgLTM1Niw3ICszNTQsNyBAQAogCXByZWZpeD1yZWZzL2V4aXN0aW5nLWNyZWF0ZSAmJgogCWdpdCB1cGRhdGUtcmVmICRwcmVmaXgvZm9vICRDICYmCiAJY2F0ID5leHBlY3RlZCA8PC1FT0YgJiYKLQlmYXRhbDogY2Fubm90IGxvY2sgcmVmICRRJHByZWZpeC9mb28kUTogcmVmZXJlbmNlIGFscmVhZHkgZXhpc3RzCisJZmF0YWw6IGNhbm5vdCBsb2NrIHJlZiAkU1EkcHJlZml4L2ZvbyRTUTogcmVmZXJlbmNlIGFscmVhZHkgZXhpc3RzCiAJRU9GCiAJcHJpbnRmICIlc1xuIiAiY3JlYXRlICRwcmVmaXgvZm9vICRFIiB8CiAJdGVzdF9tdXN0X2ZhaWwgZ2l0IHVwZGF0ZS1yZWYgLS1zdGRpbiAyPm91dHB1dC5lcnIgJiYKQEAgLTM2Nyw3ICszNjUsNyBAQAogCXByZWZpeD1yZWZzL2luY29ycmVjdC1kZWxldGUgJiYKIAlnaXQgdXBkYXRlLXJlZiAkcHJlZml4L2ZvbyAkQyAmJgogCWNhdCA+ZXhwZWN0ZWQgPDwtRU9GICYmCi0JZmF0YWw6IGNhbm5vdCBsb2NrIHJlZiAkUSRwcmVmaXgvZm9vJFE6IGlzIGF0ICRDIGJ1dCBleHBlY3RlZCAkRAorCWZhdGFsOiBjYW5ub3QgbG9jayByZWYgJFNRJHByZWZpeC9mb28kU1E6IGlzIGF0ICRDIGJ1dCBleHBlY3RlZCAkRAogCUVPRgogCXByaW50ZiAiJXNcbiIgImRlbGV0ZSAkcHJlZml4L2ZvbyAkRCIgfAogCXRlc3RfbXVzdF9mYWlsIGdpdCB1cGRhdGUtcmVmIC0tc3RkaW4gMj5vdXRwdXQuZXJyICYmCkBAIC0zNzgsNyArMzc2LDcgQEAKIAlwcmVmaXg9cmVmcy9taXNzaW5nLWluZGlyZWN0LXVwZGF0ZSAmJgogCWdpdCBzeW1ib2xpYy1yZWYgJHByZWZpeC9zeW1yZWYgJHByZWZpeC9mb28gJiYKIAljYXQgPmV4cGVjdGVkIDw8LUVPRiAmJgotCWZhdGFsOiBjYW5ub3QgbG9jayByZWYgJFEkcHJlZml4L3N5bXJlZiRROiB1bmFibGUgdG8gcmVzb2x2ZSByZWZlcmVuY2UgJFEkcHJlZml4L2ZvbyRRCisJZmF0YWw6IGNhbm5vdCBsb2NrIHJlZiAkU1EkcHJlZml4L3N5bXJlZiRTUTogdW5hYmxlIHRvIHJlc29sdmUgcmVmZXJlbmNlICRTUSRwcmVmaXgvZm9vJFNRCiAJRU9GCiAJcHJpbnRmICIlc1xuIiAidXBkYXRlICRwcmVmaXgvc3ltcmVmICRFICREIiB8CiAJdGVzdF9tdXN0X2ZhaWwgZ2l0IHVwZGF0ZS1yZWYgLS1zdGRpbiAyPm91dHB1dC5lcnIgJiYKQEAgLTM5MCw3ICszODgsNyBAQAogCWdpdCBzeW1ib2xpYy1yZWYgJHByZWZpeC9zeW1yZWYgJHByZWZpeC9mb28gJiYKIAlnaXQgdXBkYXRlLXJlZiAkcHJlZml4L2ZvbyAkQyAmJgogCWNhdCA+ZXhwZWN0ZWQgPDwtRU9GICYmCi0JZmF0YWw6IGNhbm5vdCBsb2NrIHJlZiAkUSRwcmVmaXgvc3ltcmVmJFE6IGlzIGF0ICRDIGJ1dCBleHBlY3RlZCAkRAorCWZhdGFsOiBjYW5ub3QgbG9jayByZWYgJFNRJHByZWZpeC9zeW1yZWYkU1E6IGlzIGF0ICRDIGJ1dCBleHBlY3RlZCAkRAogCUVPRgogCXByaW50ZiAiJXNcbiIgInVwZGF0ZSAkcHJlZml4L3N5bXJlZiAkRSAkRCIgfAogCXRlc3RfbXVzdF9mYWlsIGdpdCB1cGRhdGUtcmVmIC0tc3RkaW4gMj5vdXRwdXQuZXJyICYmCkBAIC00MDIsNyArNDAwLDcgQEAKIAlnaXQgc3ltYm9saWMtcmVmICRwcmVmaXgvc3ltcmVmICRwcmVmaXgvZm9vICYmCiAJZ2l0IHVwZGF0ZS1yZWYgJHByZWZpeC9mb28gJEMgJiYKIAljYXQgPmV4cGVjdGVkIDw8LUVPRiAmJgotCWZhdGFsOiBjYW5ub3QgbG9jayByZWYgJFEkcHJlZml4L3N5bXJlZiRROiByZWZlcmVuY2UgYWxyZWFkeSBleGlzdHMKKwlmYXRhbDogY2Fubm90IGxvY2sgcmVmICRTUSRwcmVmaXgvc3ltcmVmJFNROiByZWZlcmVuY2UgYWxyZWFkeSBleGlzdHMKIAlFT0YKIAlwcmludGYgIiVzXG4iICJjcmVhdGUgJHByZWZpeC9zeW1yZWYgJEUiIHwKIAl0ZXN0X211c3RfZmFpbCBnaXQgdXBkYXRlLXJlZiAtLXN0ZGluIDI+b3V0cHV0LmVyciAmJgpAQCAtNDE0LDcgKzQxMiw3IEBACiAJZ2l0IHN5bWJvbGljLXJlZiAkcHJlZml4L3N5bXJlZiAkcHJlZml4L2ZvbyAmJgogCWdpdCB1cGRhdGUtcmVmICRwcmVmaXgvZm9vICRDICYmCiAJY2F0ID5leHBlY3RlZCA8PC1FT0YgJiYKLQlmYXRhbDogY2Fubm90IGxvY2sgcmVmICRRJHByZWZpeC9zeW1yZWYkUTogaXMgYXQgJEMgYnV0IGV4cGVjdGVkICRECisJZmF0YWw6IGNhbm5vdCBsb2NrIHJlZiAkU1EkcHJlZml4L3N5bXJlZiRTUTogaXMgYXQgJEMgYnV0IGV4cGVjdGVkICRECiAJRU9GCiAJcHJpbnRmICIlc1xuIiAiZGVsZXRlICRwcmVmaXgvc3ltcmVmICREIiB8CiAJdGVzdF9tdXN0X2ZhaWwgZ2l0IHVwZGF0ZS1yZWYgLS1zdGRpbiAyPm91dHB1dC5lcnIgJiYKQEAgLTQyNSw3ICs0MjMsNyBAQAogCXByZWZpeD1yZWZzL21pc3Npbmctbm9kZXJlZi11cGRhdGUgJiYKIAlnaXQgc3ltYm9saWMtcmVmICRwcmVmaXgvc3ltcmVmICRwcmVmaXgvZm9vICYmCiAJY2F0ID5leHBlY3RlZCA8PC1FT0YgJiYKLQlmYXRhbDogY2Fubm90IGxvY2sgcmVmICRRJHByZWZpeC9zeW1yZWYkUTogcmVmZXJlbmNlIGlzIG1pc3NpbmcgYnV0IGV4cGVjdGVkICRECisJZmF0YWw6IGNhbm5vdCBsb2NrIHJlZiAkU1EkcHJlZml4L3N5bXJlZiRTUTogcmVmZXJlbmNlIGlzIG1pc3NpbmcgYnV0IGV4cGVjdGVkICRECiAJRU9GCiAJcHJpbnRmICIlc1xuIiAib3B0aW9uIG5vLWRlcmVmIiAidXBkYXRlICRwcmVmaXgvc3ltcmVmICRFICREIiB8CiAJdGVzdF9tdXN0X2ZhaWwgZ2l0IHVwZGF0ZS1yZWYgLS1zdGRpbiAyPm91dHB1dC5lcnIgJiYKQEAgLTQzNyw3ICs0MzUsNyBAQAogCWdpdCBzeW1ib2xpYy1yZWYgJHByZWZpeC9zeW1yZWYgJHByZWZpeC9mb28gJiYKIAlnaXQgdXBkYXRlLXJlZiAkcHJlZml4L2ZvbyAkQyAmJgogCWNhdCA+ZXhwZWN0ZWQgPDwtRU9GICYmCi0JZmF0YWw6IGNhbm5vdCBsb2NrIHJlZiAkUSRwcmVmaXgvc3ltcmVmJFE6IGlzIGF0ICRDIGJ1dCBleHBlY3RlZCAkRAorCWZhdGFsOiBjYW5ub3QgbG9jayByZWYgJFNRJHByZWZpeC9zeW1yZWYkU1E6IGlzIGF0ICRDIGJ1dCBleHBlY3RlZCAkRAogCUVPRgogCXByaW50ZiAiJXNcbiIgIm9wdGlvbiBuby1kZXJlZiIgInVwZGF0ZSAkcHJlZml4L3N5bXJlZiAkRSAkRCIgfAogCXRlc3RfbXVzdF9mYWlsIGdpdCB1cGRhdGUtcmVmIC0tc3RkaW4gMj5vdXRwdXQuZXJyICYmCkBAIC00NDksNyArNDQ3LDcgQEAKIAlnaXQgc3ltYm9saWMtcmVmICRwcmVmaXgvc3ltcmVmICRwcmVmaXgvZm9vICYmCiAJZ2l0IHVwZGF0ZS1yZWYgJHByZWZpeC9mb28gJEMgJiYKIAljYXQgPmV4cGVjdGVkIDw8LUVPRiAmJgotCWZhdGFsOiBjYW5ub3QgbG9jayByZWYgJFEkcHJlZml4L3N5bXJlZiRROiByZWZlcmVuY2UgYWxyZWFkeSBleGlzdHMKKwlmYXRhbDogY2Fubm90IGxvY2sgcmVmICRTUSRwcmVmaXgvc3ltcmVmJFNROiByZWZlcmVuY2UgYWxyZWFkeSBleGlzdHMKIAlFT0YKIAlwcmludGYgIiVzXG4iICJvcHRpb24gbm8tZGVyZWYiICJjcmVhdGUgJHByZWZpeC9zeW1yZWYgJEUiIHwKIAl0ZXN0X211c3RfZmFpbCBnaXQgdXBkYXRlLXJlZiAtLXN0ZGluIDI+b3V0cHV0LmVyciAmJgpAQCAtNDYxLDcgKzQ1OSw3IEBACiAJZ2l0IHN5bWJvbGljLXJlZiAkcHJlZml4L3N5bXJlZiAkcHJlZml4L2ZvbyAmJgogCWdpdCB1cGRhdGUtcmVmICRwcmVmaXgvZm9vICRDICYmCiAJY2F0ID5leHBlY3RlZCA8PC1FT0YgJiYKLQlmYXRhbDogY2Fubm90IGxvY2sgcmVmICRRJHByZWZpeC9zeW1yZWYkUTogaXMgYXQgJEMgYnV0IGV4cGVjdGVkICRECisJZmF0YWw6IGNhbm5vdCBsb2NrIHJlZiAkU1EkcHJlZml4L3N5bXJlZiRTUTogaXMgYXQgJEMgYnV0IGV4cGVjdGVkICRECiAJRU9GCiAJcHJpbnRmICIlc1xuIiAib3B0aW9uIG5vLWRlcmVmIiAiZGVsZXRlICRwcmVmaXgvc3ltcmVmICREIiB8CiAJdGVzdF9tdXN0X2ZhaWwgZ2l0IHVwZGF0ZS1yZWYgLS1zdGRpbiAyPm91dHB1dC5lcnIgJiYKQEAgLTQ3NCwxMyArNDcyLDEzIEBACiAJOiA+LmdpdC8kcHJlZml4L2Zvby9iYXIvYmF6LmxvY2sgJiYKIAl0ZXN0X3doZW5fZmluaXNoZWQgInJtIC1mIC5naXQvJHByZWZpeC9mb28vYmFyL2Jhei5sb2NrIiAmJgogCWNhdCA+ZXhwZWN0ZWQgPDwtRU9GICYmCi0JZmF0YWw6IGNhbm5vdCBsb2NrIHJlZiAkUSRwcmVmaXgvZm9vJFE6IHRoZXJlIGlzIGEgbm9uLWVtcHR5IGRpcmVjdG9yeSAkUS5naXQvJHByZWZpeC9mb28kUSBibG9ja2luZyByZWZlcmVuY2UgJFEkcHJlZml4L2ZvbyRRCisJZmF0YWw6IGNhbm5vdCBsb2NrIHJlZiAkU1EkcHJlZml4L2ZvbyRTUTogdGhlcmUgaXMgYSBub24tZW1wdHkgZGlyZWN0b3J5ICRTUS5naXQvJHByZWZpeC9mb28kU1EgYmxvY2tpbmcgcmVmZXJlbmNlICRTUSRwcmVmaXgvZm9vJFNRCiAJRU9GCiAJcHJpbnRmICIlc1xuIiAidXBkYXRlICRwcmVmaXgvZm9vICRDIiB8CiAJdGVzdF9tdXN0X2ZhaWwgZ2l0IHVwZGF0ZS1yZWYgLS1zdGRpbiAyPm91dHB1dC5lcnIgJiYKIAl0ZXN0X2NtcCBleHBlY3RlZCBvdXRwdXQuZXJyICYmCiAJY2F0ID5leHBlY3RlZCA8PC1FT0YgJiYKLQlmYXRhbDogY2Fubm90IGxvY2sgcmVmICRRJHByZWZpeC9mb28kUTogdW5hYmxlIHRvIHJlc29sdmUgcmVmZXJlbmNlICRRJHByZWZpeC9mb28kUQorCWZhdGFsOiBjYW5ub3QgbG9jayByZWYgJFNRJHByZWZpeC9mb28kU1E6IHVuYWJsZSB0byByZXNvbHZlIHJlZmVyZW5jZSAkU1EkcHJlZml4L2ZvbyRTUQogCUVPRgogCXByaW50ZiAiJXNcbiIgInVwZGF0ZSAkcHJlZml4L2ZvbyAkRCAkQyIgfAogCXRlc3RfbXVzdF9mYWlsIGdpdCB1cGRhdGUtcmVmIC0tc3RkaW4gMj5vdXRwdXQuZXJyICYmCkBAIC00OTMsMTMgKzQ5MSwxMyBAQAogCWVjaG8gImdvYmJsZWRpZ29vayIgPi5naXQvJHByZWZpeC9mb28gJiYKIAl0ZXN0X3doZW5fZmluaXNoZWQgInJtIC1mIC5naXQvJHByZWZpeC9mb28iICYmCiAJY2F0ID5leHBlY3RlZCA8PC1FT0YgJiYKLQlmYXRhbDogY2Fubm90IGxvY2sgcmVmICRRJHByZWZpeC9mb28kUTogdW5hYmxlIHRvIHJlc29sdmUgcmVmZXJlbmNlICRRJHByZWZpeC9mb28kUTogcmVmZXJlbmNlIGJyb2tlbgorCWZhdGFsOiBjYW5ub3QgbG9jayByZWYgJFNRJHByZWZpeC9mb28kU1E6IHVuYWJsZSB0byByZXNvbHZlIHJlZmVyZW5jZSAkU1EkcHJlZml4L2ZvbyRTUTogcmVmZXJlbmNlIGJyb2tlbgogCUVPRgogCXByaW50ZiAiJXNcbiIgInVwZGF0ZSAkcHJlZml4L2ZvbyAkQyIgfAogCXRlc3RfbXVzdF9mYWlsIGdpdCB1cGRhdGUtcmVmIC0tc3RkaW4gMj5vdXRwdXQuZXJyICYmCiAJdGVzdF9jbXAgZXhwZWN0ZWQgb3V0cHV0LmVyciAmJgogCWNhdCA+ZXhwZWN0ZWQgPDwtRU9GICYmCi0JZmF0YWw6IGNhbm5vdCBsb2NrIHJlZiAkUSRwcmVmaXgvZm9vJFE6IHVuYWJsZSB0byByZXNvbHZlIHJlZmVyZW5jZSAkUSRwcmVmaXgvZm9vJFE6IHJlZmVyZW5jZSBicm9rZW4KKwlmYXRhbDogY2Fubm90IGxvY2sgcmVmICRTUSRwcmVmaXgvZm9vJFNROiB1bmFibGUgdG8gcmVzb2x2ZSByZWZlcmVuY2UgJFNRJHByZWZpeC9mb28kU1E6IHJlZmVyZW5jZSBicm9rZW4KIAlFT0YKIAlwcmludGYgIiVzXG4iICJ1cGRhdGUgJHByZWZpeC9mb28gJEQgJEMiIHwKIAl0ZXN0X211c3RfZmFpbCBnaXQgdXBkYXRlLXJlZiAtLXN0ZGluIDI+b3V0cHV0LmVyciAmJgpAQCAtNTEzLDEzICs1MTEsMTMgQEAKIAk6ID4uZ2l0LyRwcmVmaXgvZm9vL2Jhci9iYXoubG9jayAmJgogCXRlc3Rfd2hlbl9maW5pc2hlZCAicm0gLWYgLmdpdC8kcHJlZml4L2Zvby9iYXIvYmF6LmxvY2siICYmCiAJY2F0ID5leHBlY3RlZCA8PC1FT0YgJiYKLQlmYXRhbDogY2Fubm90IGxvY2sgcmVmICRRJHByZWZpeC9zeW1yZWYkUTogdGhlcmUgaXMgYSBub24tZW1wdHkgZGlyZWN0b3J5ICRRLmdpdC8kcHJlZml4L2ZvbyRRIGJsb2NraW5nIHJlZmVyZW5jZSAkUSRwcmVmaXgvZm9vJFEKKwlmYXRhbDogY2Fubm90IGxvY2sgcmVmICRTUSRwcmVmaXgvc3ltcmVmJFNROiB0aGVyZSBpcyBhIG5vbi1lbXB0eSBkaXJlY3RvcnkgJFNRLmdpdC8kcHJlZml4L2ZvbyRTUSBibG9ja2luZyByZWZlcmVuY2UgJFNRJHByZWZpeC9mb28kU1EKIAlFT0YKIAlwcmludGYgIiVzXG4iICJ1cGRhdGUgJHByZWZpeC9zeW1yZWYgJEMiIHwKIAl0ZXN0X211c3RfZmFpbCBnaXQgdXBkYXRlLXJlZiAtLXN0ZGluIDI+b3V0cHV0LmVyciAmJgogCXRlc3RfY21wIGV4cGVjdGVkIG91dHB1dC5lcnIgJiYKIAljYXQgPmV4cGVjdGVkIDw8LUVPRiAmJgotCWZhdGFsOiBjYW5ub3QgbG9jayByZWYgJFEkcHJlZml4L3N5bXJlZiRROiB1bmFibGUgdG8gcmVzb2x2ZSByZWZlcmVuY2UgJFEkcHJlZml4L2ZvbyRRCisJZmF0YWw6IGNhbm5vdCBsb2NrIHJlZiAkU1EkcHJlZml4L3N5bXJlZiRTUTogdW5hYmxlIHRvIHJlc29sdmUgcmVmZXJlbmNlICRTUSRwcmVmaXgvZm9vJFNRCiAJRU9GCiAJcHJpbnRmICIlc1xuIiAidXBkYXRlICRwcmVmaXgvc3ltcmVmICREICRDIiB8CiAJdGVzdF9tdXN0X2ZhaWwgZ2l0IHVwZGF0ZS1yZWYgLS1zdGRpbiAyPm91dHB1dC5lcnIgJiYKQEAgLTUzMiwxMyArNTMwLDEzIEBACiAJZWNobyAiZ29iYmxlZGlnb29rIiA+LmdpdC8kcHJlZml4L2ZvbyAmJgogCXRlc3Rfd2hlbl9maW5pc2hlZCAicm0gLWYgLmdpdC8kcHJlZml4L2ZvbyIgJiYKIAljYXQgPmV4cGVjdGVkIDw8LUVPRiAmJgotCWZhdGFsOiBjYW5ub3QgbG9jayByZWYgJFEkcHJlZml4L3N5bXJlZiRROiB1bmFibGUgdG8gcmVzb2x2ZSByZWZlcmVuY2UgJFEkcHJlZml4L2ZvbyRROiByZWZlcmVuY2UgYnJva2VuCisJZmF0YWw6IGNhbm5vdCBsb2NrIHJlZiAkU1EkcHJlZml4L3N5bXJlZiRTUTogdW5hYmxlIHRvIHJlc29sdmUgcmVmZXJlbmNlICRTUSRwcmVmaXgvZm9vJFNROiByZWZlcmVuY2UgYnJva2VuCiAJRU9GCiAJcHJpbnRmICIlc1xuIiAidXBkYXRlICRwcmVmaXgvc3ltcmVmICRDIiB8CiAJdGVzdF9tdXN0X2ZhaWwgZ2l0IHVwZGF0ZS1yZWYgLS1zdGRpbiAyPm91dHB1dC5lcnIgJiYKIAl0ZXN0X2NtcCBleHBlY3RlZCBvdXRwdXQuZXJyICYmCiAJY2F0ID5leHBlY3RlZCA8PC1FT0YgJiYKLQlmYXRhbDogY2Fubm90IGxvY2sgcmVmICRRJHByZWZpeC9zeW1yZWYkUTogdW5hYmxlIHRvIHJlc29sdmUgcmVmZXJlbmNlICRRJHByZWZpeC9mb28kUTogcmVmZXJlbmNlIGJyb2tlbgorCWZhdGFsOiBjYW5ub3QgbG9jayByZWYgJFNRJHByZWZpeC9zeW1yZWYkU1E6IHVuYWJsZSB0byByZXNvbHZlIHJlZmVyZW5jZSAkU1EkcHJlZml4L2ZvbyRTUTogcmVmZXJlbmNlIGJyb2tlbgogCUVPRgogCXByaW50ZiAiJXNcbiIgInVwZGF0ZSAkcHJlZml4L3N5bXJlZiAkRCAkQyIgfAogCXRlc3RfbXVzdF9mYWlsIGdpdCB1cGRhdGUtcmVmIC0tc3RkaW4gMj5vdXRwdXQuZXJyICYmCkBAIC02MTQsNyArNjEyLDcgQEAKIAl0ZXN0X3doZW5fZmluaXNoZWQgInJtIC1mIC5naXQvcGFja2VkLXJlZnMubG9jayIgJiYKIAl0ZXN0X211c3RfZmFpbCBnaXQgdXBkYXRlLXJlZiAtZCAkcHJlZml4L2ZvbyA+b3V0IDI+ZXJyICYmCiAJZ2l0IGZvci1lYWNoLXJlZiAkcHJlZml4ID5hY3R1YWwgJiYKLQl0ZXN0X2kxOG5ncmVwICJVbmFibGUgdG8gY3JlYXRlICRRLipwYWNrZWQtcmVmcy5sb2NrJFE6ICIgZXJyICYmCisJdGVzdF9pMThuZ3JlcCAiVW5hYmxlIHRvIGNyZWF0ZSAkU1EuKnBhY2tlZC1yZWZzLmxvY2skU1E6ICIgZXJyICYmCiAJdGVzdF9jbXAgdW5jaGFuZ2VkIGFjdHVhbAogJwogCmRpZmYgLS1naXQgYS90L3QxNDE0LXJlZmxvZy13YWxrLnNoIGIvdC90MTQxNC1yZWZsb2ctd2Fsay5zaAppbmRleCBmZWIxZWZkLi4xMTgxYTlmIDEwMDc1NQotLS0gYS90L3QxNDE0LXJlZmxvZy13YWxrLnNoCisrKyBiL3QvdDE0MTQtcmVmbG9nLXdhbGsuc2gKQEAgLTE4LDEwICsxOCw5IEBACiAJZ2l0IGxvZyAtZyAtLWZvcm1hdD0iJWdkICVncyIgIiRAIgogfQogCi1zcT0iJyIKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3NldCB1cCBleHBlY3RlZCByZWZsb2cnICcKIAljYXQgPmV4cGVjdC5hbGwgPDwtRU9GCi0JSEVBREB7MH0gY29tbWl0IChtZXJnZSk6IE1lcmdlIGJyYW5jaCAke3NxfW1hc3RlciR7c3F9IGludG8gc2lkZQorCUhFQURAezB9IGNvbW1pdCAobWVyZ2UpOiBNZXJnZSBicmFuY2ggJHtTUX1tYXN0ZXIke1NRfSBpbnRvIHNpZGUKIAlIRUFEQHsxfSBjb21taXQ6IHRocmVlCiAJSEVBREB7Mn0gY2hlY2tvdXQ6IG1vdmluZyBmcm9tIG1hc3RlciB0byBzaWRlCiAJSEVBREB7M30gY29tbWl0OiB0d28KZGlmZiAtLWdpdCBhL3QvdDE0NTAtZnNjay5zaCBiL3QvdDE0NTAtZnNjay5zaAppbmRleCBiMzZlMDUyLi43YzdmZjdlIDEwMDc1NQotLS0gYS90L3QxNDUwLWZzY2suc2gKKysrIGIvdC90MTQ1MC1mc2NrLnNoCkBAIC03MCw3ICs3MCw2IEBACiAJdGVzdF93aGVuX2ZpbmlzaGVkICJnaXQgdXBkYXRlLXJlZiAtZCByZWZzL2hlYWRzL2JvZ3VzIiAmJgogCiAJdGVzdF9tdXN0X2ZhaWwgZ2l0IGZzY2sgMj5vdXQgJiYKLQljYXQgb3V0ICYmCiAJdGVzdF9pMThuZ3JlcCAiJHNoYS4qY29ycnVwdCIgb3V0CiAnCiAKQEAgLTc4LDcgKzc3LDYgQEAKIAlnaXQgcmV2LXBhcnNlIEhFQURee3RyZWV9ID4uZ2l0L3JlZnMvaGVhZHMvaW52YWxpZCAmJgogCXRlc3Rfd2hlbl9maW5pc2hlZCAiZ2l0IHVwZGF0ZS1yZWYgLWQgcmVmcy9oZWFkcy9pbnZhbGlkIiAmJgogCXRlc3RfbXVzdF9mYWlsIGdpdCBmc2NrIDI+b3V0ICYmCi0JY2F0IG91dCAmJgogCXRlc3RfaTE4bmdyZXAgIm5vdCBhIGNvbW1pdCIgb3V0CiAnCiAKQEAgLTg4LDcgKzg2LDYgQEAKIAllY2hvICRaRVJPX09JRCA+LmdpdC9IRUFEICYmCiAJIyBhdm9pZCBjb3JydXB0L2Jyb2tlbiBIRUFEIGZyb20gaW50ZXJmZXJpbmcgd2l0aCByZXBvIGRpc2NvdmVyeQogCXRlc3RfbXVzdF9mYWlsIGVudiBHSVRfRElSPS5naXQgZ2l0IGZzY2sgMj5vdXQgJiYKLQljYXQgb3V0ICYmCiAJdGVzdF9pMThuZ3JlcCAiZGV0YWNoZWQgSEVBRCBwb2ludHMiIG91dAogJwogCkBAIC05OCw3ICs5NSw2IEBACiAJZWNobyAicmVmOiByZWZzL2Z1bm55L3BsYWNlIiA+LmdpdC9IRUFEICYmCiAJIyBhdm9pZCBjb3JydXB0L2Jyb2tlbiBIRUFEIGZyb20gaW50ZXJmZXJpbmcgd2l0aCByZXBvIGRpc2NvdmVyeQogCXRlc3RfbXVzdF9mYWlsIGVudiBHSVRfRElSPS5naXQgZ2l0IGZzY2sgMj5vdXQgJiYKLQljYXQgb3V0ICYmCiAJdGVzdF9pMThuZ3JlcCAiSEVBRCBwb2ludHMgdG8gc29tZXRoaW5nIHN0cmFuZ2UiIG91dAogJwogCkBAIC0xNTcsNyArMTUzLDYgQEAKIAlnaXQgdXBkYXRlLXJlZiByZWZzL2hlYWRzL2JvZ3VzICIkbmV3IiAmJgogCXRlc3Rfd2hlbl9maW5pc2hlZCAiZ2l0IHVwZGF0ZS1yZWYgLWQgcmVmcy9oZWFkcy9ib2d1cyIgJiYKIAl0ZXN0X211c3RfZmFpbCBnaXQgZnNjayAyPm91dCAmJgotCWNhdCBvdXQgJiYKIAl0ZXN0X2kxOG5ncmVwICJlcnJvciBpbiBjb21taXQgJG5ldyIgb3V0CiAnCiAKQEAgLTE2OSw3ICsxNjQsNiBAQAogCWdpdCB1cGRhdGUtcmVmIHJlZnMvaGVhZHMvYm9ndXMgIiRuZXciICYmCiAJdGVzdF93aGVuX2ZpbmlzaGVkICJnaXQgdXBkYXRlLXJlZiAtZCByZWZzL2hlYWRzL2JvZ3VzIiAmJgogCXRlc3RfbXVzdF9mYWlsIGdpdCBmc2NrIDI+b3V0ICYmCi0JY2F0IG91dCAmJgogCXRlc3RfaTE4bmdyZXAgImVycm9yIGluIGNvbW1pdCAkbmV3LiogLSBiYWQgbmFtZSIgb3V0CiAnCiAKQEAgLTE4MSw3ICsxNzUsNiBAQAogCWdpdCB1cGRhdGUtcmVmIHJlZnMvaGVhZHMvYm9ndXMgIiRuZXciICYmCiAJdGVzdF93aGVuX2ZpbmlzaGVkICJnaXQgdXBkYXRlLXJlZiAtZCByZWZzL2hlYWRzL2JvZ3VzIiAmJgogCXRlc3RfbXVzdF9mYWlsIGdpdCBmc2NrIDI+b3V0ICYmCi0JY2F0IG91dCAmJgogCXRlc3RfaTE4bmdyZXAgImVycm9yIGluIGNvbW1pdCAkbmV3LiogLSBtaXNzaW5nIGVtYWlsIiBvdXQKICcKIApAQCAtMTkzLDcgKzE4Niw2IEBACiAJZ2l0IHVwZGF0ZS1yZWYgcmVmcy9oZWFkcy9ib2d1cyAiJG5ldyIgJiYKIAl0ZXN0X3doZW5fZmluaXNoZWQgImdpdCB1cGRhdGUtcmVmIC1kIHJlZnMvaGVhZHMvYm9ndXMiICYmCiAJdGVzdF9tdXN0X2ZhaWwgZ2l0IGZzY2sgMj5vdXQgJiYKLQljYXQgb3V0ICYmCiAJdGVzdF9pMThuZ3JlcCAiZXJyb3IgaW4gY29tbWl0ICRuZXciIG91dAogJwogCkBAIC0yMDcsNyArMTk5LDYgQEAKIAlnaXQgdXBkYXRlLXJlZiByZWZzL2hlYWRzL2JvZ3VzICIkbmV3IiAmJgogCXRlc3Rfd2hlbl9maW5pc2hlZCAiZ2l0IHVwZGF0ZS1yZWYgLWQgcmVmcy9oZWFkcy9ib2d1cyIgJiYKIAl0ZXN0X211c3RfZmFpbCBnaXQgZnNjayAyPm91dCAmJgotCWNhdCBvdXQgJiYKIAl0ZXN0X2kxOG5ncmVwICJlcnJvciBpbiBjb21taXQgJG5ldy4qaW50ZWdlciBvdmVyZmxvdyIgb3V0CiAnCiAKQEAgLTIxOSw3ICsyMTAsNiBAQAogCWdpdCB1cGRhdGUtcmVmIHJlZnMvaGVhZHMvYm9ndXMgIiRuZXciICYmCiAJdGVzdF93aGVuX2ZpbmlzaGVkICJnaXQgdXBkYXRlLXJlZiAtZCByZWZzL2hlYWRzL2JvZ3VzIiAmJgogCXRlc3RfbXVzdF9mYWlsIGdpdCBmc2NrIDI+b3V0ICYmCi0JY2F0IG91dCAmJgogCXRlc3RfaTE4bmdyZXAgImVycm9yIGluIGNvbW1pdCAkbmV3Lip1bnRlcm1pbmF0ZWQgaGVhZGVyOiBOVUwgYXQgb2Zmc2V0IiBvdXQKICcKIApAQCAtMjk3LDcgKzI4Nyw2IEBACiAJZWNobyAkdGFnID4uZ2l0L3JlZnMvdGFncy9pbnZhbGlkICYmCiAJdGVzdF93aGVuX2ZpbmlzaGVkICJnaXQgdXBkYXRlLXJlZiAtZCByZWZzL3RhZ3MvaW52YWxpZCIgJiYKIAl0ZXN0X211c3RfZmFpbCBnaXQgZnNjayAtLXRhZ3MgPm91dCAmJgotCWNhdCBvdXQgJiYKIAl0ZXN0X2kxOG5ncmVwICJicm9rZW4gbGluayIgb3V0CiAnCiAKQEAgLTM3OCw3ICszNjcsNiBAQAogCWVjaG8gJHRhZyA+LmdpdC9yZWZzL3RhZ3Mvd3JvbmcgJiYKIAl0ZXN0X3doZW5fZmluaXNoZWQgImdpdCB1cGRhdGUtcmVmIC1kIHJlZnMvdGFncy93cm9uZyIgJiYKIAl0ZXN0X211c3RfZmFpbCBnaXQgZnNjayAtLXRhZ3MgMj5vdXQgJiYKLQljYXQgb3V0ICYmCiAJdGVzdF9pMThuZ3JlcCAiZXJyb3IgaW4gdGFnICR0YWcuKnVudGVybWluYXRlZCBoZWFkZXI6IE5VTCBhdCBvZmZzZXQiIG91dAogJwogCkBAIC00MDksNyArMzk3LDYgQEAKIAl0ZXN0X3doZW5fZmluaXNoZWQgImdpdCB1cGRhdGUtcmVmIC1kIHJlZnMvaGVhZHMvYm9ndXMiICYmCiAKIAl0ZXN0X21pZ2h0X2ZhaWwgZ2l0IHJldi1saXN0IC0tdmVyaWZ5LW9iamVjdHMgcmVmcy9oZWFkcy9ib2d1cyA+L2Rldi9udWxsIDI+b3V0ICYmCi0JY2F0IG91dCAmJgogCXRlc3RfaTE4bmdyZXAgLXEgImVycm9yOiBoYXNoIG1pc21hdGNoICQoZGlybmFtZSAkbmV3KSQodGVzdF9vaWQgZmZfMikiIG91dAogJwogCkBAIC00MzMsNyArNDIwLDYgQEAKIAkgc2hhPSQocHJpbnRmICIxMDA2NDQgZmlsZSRfYnokX2J6b2lkIiB8CiAJICAgICAgIGdpdCBoYXNoLW9iamVjdCAtdyAtLXN0ZGluIC10IHRyZWUpICYmCiAJICBnaXQgZnNjayAyPm91dCAmJgotCSAgY2F0IG91dCAmJgogCSAgdGVzdF9pMThuZ3JlcCAid2FybmluZy4qbnVsbCBzaGExIiBvdXQKIAkpCiAnCkBAIC00NDQsNyArNDMwLDYgQEAKIAkgc2hhPSQocHJpbnRmICIxNjAwMDAgc3VibW9kdWxlJF9ieiRfYnpvaWQiIHwKIAkgICAgICAgZ2l0IGhhc2gtb2JqZWN0IC13IC0tc3RkaW4gLXQgdHJlZSkgJiYKIAkgIGdpdCBmc2NrIDI+b3V0ICYmCi0JICBjYXQgb3V0ICYmCiAJICB0ZXN0X2kxOG5ncmVwICJ3YXJuaW5nLipudWxsIHNoYTEiIG91dAogCSkKICcKQEAgLTQ2NSw3ICs0NTAsNiBAQAogCQkJcHJpbnRmICIkbW9kZSAkdHlwZSAlc1x0JXMiICIkdmFsdWUiICIkcGF0aCIgPmJhZCAmJgogCQkJYmFkX3RyZWU9JChnaXQgbWt0cmVlIDxiYWQpICYmCiAJCQlnaXQgZnNjayAyPm91dCAmJgotCQkJY2F0IG91dCAmJgogCQkJdGVzdF9pMThuZ3JlcCAid2FybmluZy4qdHJlZSAkYmFkX3RyZWUiIG91dAogCQkpJwogCWRvbmUgPDwtXEVPRgpAQCAtNjMyLDcgKzYxNiw3IEBACiAJCXJlbW92ZV9vYmplY3QgJChnaXQgcmV2LXBhcnNlIGp1bGl1czpjYWVzYXIudCkgJiYKIAkJdGVzdF9tdXN0X2ZhaWwgZ2l0IGZzY2sgLS1uYW1lLW9iamVjdHMgPm91dCAmJgogCQl0cmVlPSQoZ2l0IHJldi1wYXJzZSAtLXZlcmlmeSBqdWxpdXM6KSAmJgotCQl0ZXN0X2kxOG5ncmVwIC1FICIkdHJlZSBcKChyZWZzL2hlYWRzL21hc3RlcnxIRUFEKUBce1swLTldKlx9OiIgb3V0CisJCXRlc3RfaTE4bmdyZXAgIiR0cmVlIChyZWZzL3RhZ3MvanVsaXVzOiIgb3V0CiAJKQogJwogCmRpZmYgLS1naXQgYS90L3QxNTAwLXJldi1wYXJzZS5zaCBiL3QvdDE1MDAtcmV2LXBhcnNlLnNoCmluZGV4IDAxYWJlZTUuLjYwMzAxOWIgMTAwNzU1Ci0tLSBhL3QvdDE1MDAtcmV2LXBhcnNlLnNoCisrKyBiL3QvdDE1MDAtcmV2LXBhcnNlLnNoCkBAIC01OSw2ICs1OSw3IEBACiBST09UPSQocHdkKQogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdzZXR1cCcgJworCXRlc3Rfb2lkX2luaXQgJiYKIAlta2RpciAtcCBzdWIvZGlyIHdvcmsgJiYKIAljcCAtUiAuZ2l0IHJlcG8uZ2l0CiAnCkBAIC0xMzEsNiArMTMyLDMwIEBACiAJdGVzdF9jbXAgZXhwZWN0IGFjdHVhbAogJwogCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdyZXYtcGFyc2UgLS1zaG93LW9iamVjdC1mb3JtYXQgaW4gcmVwbycgJworCWVjaG8gIiQodGVzdF9vaWQgYWxnbykiID5leHBlY3QgJiYKKwlnaXQgcmV2LXBhcnNlIC0tc2hvdy1vYmplY3QtZm9ybWF0ID5hY3R1YWwgJiYKKwl0ZXN0X2NtcCBleHBlY3QgYWN0dWFsICYmCisJZ2l0IHJldi1wYXJzZSAtLXNob3ctb2JqZWN0LWZvcm1hdD1zdG9yYWdlID5hY3R1YWwgJiYKKwl0ZXN0X2NtcCBleHBlY3QgYWN0dWFsICYmCisJZ2l0IHJldi1wYXJzZSAtLXNob3ctb2JqZWN0LWZvcm1hdD1pbnB1dCA+YWN0dWFsICYmCisJdGVzdF9jbXAgZXhwZWN0IGFjdHVhbCAmJgorCWdpdCByZXYtcGFyc2UgLS1zaG93LW9iamVjdC1mb3JtYXQ9b3V0cHV0ID5hY3R1YWwgJiYKKwl0ZXN0X2NtcCBleHBlY3QgYWN0dWFsICYmCisJdGVzdF9tdXN0X2ZhaWwgZ2l0IHJldi1wYXJzZSAtLXNob3ctb2JqZWN0LWZvcm1hdD1zcXVlYW1pc2gtb3NzaWZyYWdlIDI+ZXJyICYmCisJZ3JlcCAidW5rbm93biBtb2RlIGZvciAtLXNob3ctb2JqZWN0LWZvcm1hdDogc3F1ZWFtaXNoLW9zc2lmcmFnZSIgZXJyCisnCisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJy0tc2hvdy10b3BsZXZlbCBmcm9tIHN1YmRpciBvZiB3b3JraW5nIHRyZWUnICcKKwlwd2QgPmV4cGVjdCAmJgorCWdpdCAtQyBzdWIvZGlyIHJldi1wYXJzZSAtLXNob3ctdG9wbGV2ZWwgPmFjdHVhbCAmJgorCXRlc3RfY21wIGV4cGVjdCBhY3R1YWwKKycKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAnLS1zaG93LXRvcGxldmVsIGZyb20gaW5zaWRlIC5naXQnICcKKwl0ZXN0X211c3RfZmFpbCBnaXQgLUMgLmdpdCByZXYtcGFyc2UgLS1zaG93LXRvcGxldmVsCisnCisKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3Nob3dpbmcgdGhlIHN1cGVycHJvamVjdCBjb3JyZWN0bHknICcKIAlnaXQgcmV2LXBhcnNlIC0tc2hvdy1zdXBlcnByb2plY3Qtd29ya2luZy10cmVlID5vdXQgJiYKIAl0ZXN0X211c3RfYmVfZW1wdHkgb3V0ICYmCmRpZmYgLS1naXQgYS90L3QxNTA2LXJldi1wYXJzZS1kaWFnbm9zaXMuc2ggYi90L3QxNTA2LXJldi1wYXJzZS1kaWFnbm9zaXMuc2gKaW5kZXggNGVlMDA5ZC4uNjI0ZDBhNSAxMDA3NTUKLS0tIGEvdC90MTUwNi1yZXYtcGFyc2UtZGlhZ25vc2lzLnNoCisrKyBiL3QvdDE1MDYtcmV2LXBhcnNlLWRpYWdub3Npcy5zaApAQCAtOCwxMCArOCw5IEBACiAKIHRlc3RfZGlkX3lvdV9tZWFuICgpCiB7Ci0Jc3E9IiciICYmCiAJY2F0ID5leHBlY3RlZCA8PC1FT0YgJiYKLQlmYXRhbDogUGF0aCAnJDIkMycgJDQsIGJ1dCBub3QgJHs1Oi0kc3EkMyRzcX0uCi0JRGlkIHlvdSBtZWFuICckMTokMiQzJyR7MjorIGFrYSAkc3EkMTouLyQzJHNxfT8KKwlmYXRhbDogUGF0aCAnJDIkMycgJDQsIGJ1dCBub3QgJHs1Oi0kU1EkMyRTUX0uCisJRGlkIHlvdSBtZWFuICckMTokMiQzJyR7MjorIGFrYSAkU1EkMTouLyQzJFNRfT8KIAlFT0YKIAl0ZXN0X2NtcCBleHBlY3RlZCBlcnJvcgogfQpAQCAtMjE1LDQgKzIxNCwxMiBAQAogCXRlc3RfY21wIGV4cGVjdCBhY3R1YWwKICcKIAordGVzdF9leHBlY3Rfc3VjY2VzcyAncmVqZWN0IE50aCBwYXJlbnQgaWYgTiBpcyB0b28gaGlnaCcgJworCXRlc3RfbXVzdF9mYWlsIGdpdCByZXYtcGFyc2UgSEVBRF4xMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAKKycKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAncmVqZWN0IE50aCBhbmNlc3RvciBpZiBOIGlzIHRvbyBoaWdoJyAnCisJdGVzdF9tdXN0X2ZhaWwgZ2l0IHJldi1wYXJzZSBIRUFEfjEwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMAorJworCiB0ZXN0X2RvbmUKZGlmZiAtLWdpdCBhL3QvdDE1MDctcmV2LXBhcnNlLXVwc3RyZWFtLnNoIGIvdC90MTUwNy1yZXYtcGFyc2UtdXBzdHJlYW0uc2gKaW5kZXggZmEzZTQ5OS4uOGI0Y2Y4YSAxMDA3NTUKLS0tIGEvdC90MTUwNy1yZXYtcGFyc2UtdXBzdHJlYW0uc2gKKysrIGIvdC90MTUwNy1yZXYtcGFyc2UtdXBzdHJlYW0uc2gKQEAgLTI4LDggKzI4LDYgQEAKIAkpCiAnCiAKLXNxPSInIgotCiBmdWxsX25hbWUgKCkgewogCShjZCBjbG9uZSAmJgogCSBnaXQgcmV2LXBhcnNlIC0tc3ltYm9saWMtZnVsbC1uYW1lICIkQCIpCkBAIC0xMjksNyArMTI3LDcgQEAKIAlnaXQgYnJhbmNoIC10IG5ldyBteS1zaWRlQHt1fSAmJgogCWdpdCBtZXJnZSAtcyBvdXJzIG5ld0B7dX0gJiYKIAlnaXQgc2hvdyAtcyAtLXByZXR0eT10Zm9ybWF0OiVzID5hY3R1YWwgJiYKLQllY2hvICJNZXJnZSByZW1vdGUtdHJhY2tpbmcgYnJhbmNoICR7c3F9b3JpZ2luL3NpZGUke3NxfSIgPmV4cGVjdCAmJgorCWVjaG8gIk1lcmdlIHJlbW90ZS10cmFja2luZyBicmFuY2ggJHtTUX1vcmlnaW4vc2lkZSR7U1F9IiA+ZXhwZWN0ICYmCiAJdGVzdF9jbXAgZXhwZWN0IGFjdHVhbAogKQogJwpAQCAtMTU2LDcgKzE1NCw3IEBACiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2JyYW5jaEB7dX0gZXJyb3IgbWVzc2FnZSB3aGVuIG5vIHVwc3RyZWFtJyAnCiAJY2F0ID5leHBlY3QgPDwtRU9GICYmCi0JZmF0YWw6IG5vIHVwc3RyZWFtIGNvbmZpZ3VyZWQgZm9yIGJyYW5jaCAke3NxfW5vbi10cmFja2luZyR7c3F9CisJZmF0YWw6IG5vIHVwc3RyZWFtIGNvbmZpZ3VyZWQgZm9yIGJyYW5jaCAke1NRfW5vbi10cmFja2luZyR7U1F9CiAJRU9GCiAJZXJyb3JfbWVzc2FnZSBub24tdHJhY2tpbmdAe3V9ICYmCiAJdGVzdF9pMThuY21wIGV4cGVjdCBlcnJvcgpAQCAtMTY0LDcgKzE2Miw3IEBACiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ0B7dX0gZXJyb3IgbWVzc2FnZSB3aGVuIG5vIHVwc3RyZWFtJyAnCiAJY2F0ID5leHBlY3QgPDwtRU9GICYmCi0JZmF0YWw6IG5vIHVwc3RyZWFtIGNvbmZpZ3VyZWQgZm9yIGJyYW5jaCAke3NxfW1hc3RlciR7c3F9CisJZmF0YWw6IG5vIHVwc3RyZWFtIGNvbmZpZ3VyZWQgZm9yIGJyYW5jaCAke1NRfW1hc3RlciR7U1F9CiAJRU9GCiAJdGVzdF9tdXN0X2ZhaWwgZ2l0IHJldi1wYXJzZSAtLXZlcmlmeSBAe3V9IDI+YWN0dWFsICYmCiAJdGVzdF9pMThuY21wIGV4cGVjdCBhY3R1YWwKQEAgLTE3Miw3ICsxNzAsNyBAQAogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdicmFuY2hAe3V9IGVycm9yIG1lc3NhZ2Ugd2l0aCBtaXNzcGVsdCBicmFuY2gnICcKIAljYXQgPmV4cGVjdCA8PC1FT0YgJiYKLQlmYXRhbDogbm8gc3VjaCBicmFuY2g6ICR7c3F9bm8tc3VjaC1icmFuY2gke3NxfQorCWZhdGFsOiBubyBzdWNoIGJyYW5jaDogJHtTUX1uby1zdWNoLWJyYW5jaCR7U1F9CiAJRU9GCiAJZXJyb3JfbWVzc2FnZSBuby1zdWNoLWJyYW5jaEB7dX0gJiYKIAl0ZXN0X2kxOG5jbXAgZXhwZWN0IGVycm9yCkBAIC0xODksNyArMTg3LDcgQEAKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnYnJhbmNoQHt1fSBlcnJvciBtZXNzYWdlIGlmIHVwc3RyZWFtIGJyYW5jaCBub3QgZmV0Y2hlZCcgJwogCWNhdCA+ZXhwZWN0IDw8LUVPRiAmJgotCWZhdGFsOiB1cHN0cmVhbSBicmFuY2ggJHtzcX1yZWZzL2hlYWRzL3NpZGUke3NxfSBub3Qgc3RvcmVkIGFzIGEgcmVtb3RlLXRyYWNraW5nIGJyYW5jaAorCWZhdGFsOiB1cHN0cmVhbSBicmFuY2ggJHtTUX1yZWZzL2hlYWRzL3NpZGUke1NRfSBub3Qgc3RvcmVkIGFzIGEgcmVtb3RlLXRyYWNraW5nIGJyYW5jaAogCUVPRgogCWVycm9yX21lc3NhZ2UgYmFkLXVwc3RyZWFtQHt1fSAmJgogCXRlc3RfaTE4bmNtcCBleHBlY3QgZXJyb3IKZGlmZiAtLWdpdCBhL3QvdDE1MTItcmV2LXBhcnNlLWRpc2FtYmlndWF0aW9uLnNoIGIvdC90MTUxMi1yZXYtcGFyc2UtZGlzYW1iaWd1YXRpb24uc2gKaW5kZXggYzE5ZmI1MC4uMjU3NDRlMiAxMDA3NTUKLS0tIGEvdC90MTUxMi1yZXYtcGFyc2UtZGlzYW1iaWd1YXRpb24uc2gKKysrIGIvdC90MTUxMi1yZXYtcGFyc2UtZGlzYW1iaWd1YXRpb24uc2gKQEAgLTMzOSw3ICszMzksNyBAQAogdGVzdF9leHBlY3Rfc3VjY2VzcyBDX0xPQ0FMRV9PVVRQVVQgJ2FtYmlndWl0eSBoaW50cyByZXNwZWN0IHR5cGUnICcKIAl0ZXN0X211c3RfZmFpbCBnaXQgcmV2LXBhcnNlIDAwMDAwMDAwMF57Y29tbWl0fSAyPnN0ZGVyciAmJgogCWdyZXAgXmhpbnQ6IHN0ZGVyciA+aGludHMgJiYKLQkjIDUgY29tbWl0cywgMSB0YWcgKHdoaWNoIGlzIGEgY29tbWl0aXNoKSwgcGx1cyBpbnRybyBsaW5lCisJIyA1IGNvbW1pdHMsIDEgdGFnICh3aGljaCBpcyBhIGNvbW1pdHRpc2gpLCBwbHVzIGludHJvIGxpbmUKIAl0ZXN0X2xpbmVfY291bnQgPSA3IGhpbnRzCiAnCiAKZGlmZiAtLWdpdCBhL3QvdDE2MDAtaW5kZXguc2ggYi90L3QxNjAwLWluZGV4LnNoCmluZGV4IDQyOTYyZWQuLmI3YzMxYWEgMTAwNzU1Ci0tLSBhL3QvdDE2MDAtaW5kZXguc2gKKysrIGIvdC90MTYwMC1pbmRleC5zaApAQCAtNTksMTcgKzU5LDQyIEBACiAJKQogJwogCi10ZXN0X2V4cGVjdF9zdWNjZXNzICdHSVRfSU5ERVhfVkVSU0lPTiB0YWtlcyBwcmVjZWRlbmNlIG92ZXIgY29uZmlnJyAnCit0ZXN0X2luZGV4X3ZlcnNpb24gKCkgeworCUlOREVYX1ZFUlNJT05fQ09ORklHPSQxICYmCisJRkVBVFVSRV9NQU5ZX0ZJTEVTPSQyICYmCisJRU5WX1ZBUl9WRVJTSU9OPSQzCisJRVhQRUNURURfT1VUUFVUX1ZFUlNJT049JDQgJiYKIAkoCiAJCXJtIC1mIC5naXQvaW5kZXggJiYKLQkJR0lUX0lOREVYX1ZFUlNJT049NCAmJgotCQlleHBvcnQgR0lUX0lOREVYX1ZFUlNJT04gJiYKLQkJZ2l0IGNvbmZpZyAtLWFkZCBpbmRleC52ZXJzaW9uIDIgJiYKKwkJcm0gLWYgLmdpdC9jb25maWcgJiYKKwkJaWYgdGVzdCAiJElOREVYX1ZFUlNJT05fQ09ORklHIiAtbmUgMAorCQl0aGVuCisJCQlnaXQgY29uZmlnIC0tYWRkIGluZGV4LnZlcnNpb24gJElOREVYX1ZFUlNJT05fQ09ORklHCisJCWZpICYmCisJCWdpdCBjb25maWcgLS1hZGQgZmVhdHVyZS5tYW55RmlsZXMgJEZFQVRVUkVfTUFOWV9GSUxFUworCQlpZiB0ZXN0ICIkRU5WX1ZBUl9WRVJTSU9OIiAtbmUgMAorCQl0aGVuCisJCQlHSVRfSU5ERVhfVkVSU0lPTj0kRU5WX1ZBUl9WRVJTSU9OICYmCisJCQlleHBvcnQgR0lUX0lOREVYX1ZFUlNJT04KKwkJZWxzZQorCQkJdW5zZXQgR0lUX0lOREVYX1ZFUlNJT04KKwkJZmkgJiYKIAkJZ2l0IGFkZCBhIDI+JjEgJiYKLQkJZWNobyA0ID5leHBlY3QgJiYKKwkJZWNobyAkRVhQRUNURURfT1VUUFVUX1ZFUlNJT04gPmV4cGVjdCAmJgogCQl0ZXN0LXRvb2wgaW5kZXgtdmVyc2lvbiA8LmdpdC9pbmRleCA+YWN0dWFsICYmCiAJCXRlc3RfY21wIGV4cGVjdCBhY3R1YWwKIAkpCit9CisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2luZGV4IHZlcnNpb24gY29uZmlnIHByZWNlZGVuY2UnICcKKwl0ZXN0X2luZGV4X3ZlcnNpb24gMCBmYWxzZSAwIDIgJiYKKwl0ZXN0X2luZGV4X3ZlcnNpb24gMiBmYWxzZSAwIDIgJiYKKwl0ZXN0X2luZGV4X3ZlcnNpb24gMyBmYWxzZSAwIDIgJiYKKwl0ZXN0X2luZGV4X3ZlcnNpb24gNCBmYWxzZSAwIDQgJiYKKwl0ZXN0X2luZGV4X3ZlcnNpb24gMiBmYWxzZSA0IDQgJiYKKwl0ZXN0X2luZGV4X3ZlcnNpb24gMiB0cnVlIDAgMiAmJgorCXRlc3RfaW5kZXhfdmVyc2lvbiAwIHRydWUgMCA0ICYmCisJdGVzdF9pbmRleF92ZXJzaW9uIDAgdHJ1ZSAyIDIKICcKIAogdGVzdF9kb25lCmRpZmYgLS1naXQgYS90L3QyMDIyLWNoZWNrb3V0LXBhdGhzLnNoIGIvdC90MjAyMi1jaGVja291dC1wYXRocy5zaAppbmRleCBmYzNlYjQzLi42ODQ0YWZhIDEwMDc1NQotLS0gYS90L3QyMDIyLWNoZWNrb3V0LXBhdGhzLnNoCisrKyBiL3QvdDIwMjItY2hlY2tvdXQtcGF0aHMuc2gKQEAgLTc4LDQgKzc4LDE1IEBACiAJdGVzdF9jbXAgZXhwZWN0IGFjdHVhbAogJwogCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdjaGVja291dCBIRUFEIGFkZHMgZGVsZXRlZCBpbnRlbnQtdG8tYWRkIGZpbGUgYmFjayB0byBpbmRleCcgJworCWVjaG8gIm5vbmVtcHR5IiA+bm9uZW1wdHkgJiYKKwk+ZW1wdHkgJiYKKwlnaXQgYWRkIG5vbmVtcHR5IGVtcHR5ICYmCisJZ2l0IGNvbW1pdCAtbSAiY3JlYXRlIGZpbGVzIHRvIGJlIGRlbGV0ZWQiICYmCisJZ2l0IHJtIC0tY2FjaGVkIG5vbmVtcHR5IGVtcHR5ICYmCisJZ2l0IGFkZCAtTiBub25lbXB0eSBlbXB0eSAmJgorCWdpdCBjaGVja291dCBIRUFEIG5vbmVtcHR5IGVtcHR5ICYmCisJZ2l0IGRpZmYgLS1jYWNoZWQgLS1leGl0LWNvZGUKKycKKwogdGVzdF9kb25lCmRpZmYgLS1naXQgYS90L3QyMDcwLXJlc3RvcmUuc2ggYi90L3QyMDcwLXJlc3RvcmUuc2gKaW5kZXggMjY1MGRmMS4uMjFjM2Y4NCAxMDA3NTUKLS0tIGEvdC90MjA3MC1yZXN0b3JlLnNoCisrKyBiL3QvdDIwNzAtcmVzdG9yZS5zaApAQCAtOTUsNCArOTUsMTUgQEAKIAkpCiAnCiAKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3Jlc3RvcmUgLS1zdGFnZWQgYWRkcyBkZWxldGVkIGludGVudC10by1hZGQgZmlsZSBiYWNrIHRvIGluZGV4JyAnCisJZWNobyAibm9uZW1wdHkiID5ub25lbXB0eSAmJgorCT5lbXB0eSAmJgorCWdpdCBhZGQgbm9uZW1wdHkgZW1wdHkgJiYKKwlnaXQgY29tbWl0IC1tICJjcmVhdGUgZmlsZXMgdG8gYmUgZGVsZXRlZCIgJiYKKwlnaXQgcm0gLS1jYWNoZWQgbm9uZW1wdHkgZW1wdHkgJiYKKwlnaXQgYWRkIC1OIG5vbmVtcHR5IGVtcHR5ICYmCisJZ2l0IHJlc3RvcmUgLS1zdGFnZWQgbm9uZW1wdHkgZW1wdHkgJiYKKwlnaXQgZGlmZiAtLWNhY2hlZCAtLWV4aXQtY29kZQorJworCiB0ZXN0X2RvbmUKZGlmZiAtLWdpdCBhL3QvdDI0MDAtd29ya3RyZWUtYWRkLnNoIGIvdC90MjQwMC13b3JrdHJlZS1hZGQuc2gKaW5kZXggZTgxOWJhNy4uYjVlY2UxOSAxMDA3NTUKLS0tIGEvdC90MjQwMC13b3JrdHJlZS1hZGQuc2gKKysrIGIvdC90MjQwMC13b3JrdHJlZS1hZGQuc2gKQEAgLTQzOCw3ICs0MzgsNyBAQAogCQljZCBmb28gJiYKIAkJdGVzdF9tdXN0X2ZhaWwgZ2l0IGNvbmZpZyAiYnJhbmNoLmZvby5yZW1vdGUiICYmCiAJCXRlc3RfbXVzdF9mYWlsIGdpdCBjb25maWcgImJyYW5jaC5mb28ubWVyZ2UiICYmCi0JCSEgdGVzdF9jbXBfcmV2IHJlZnMvcmVtb3Rlcy9yZXBvX2EvZm9vIHJlZnMvaGVhZHMvZm9vCisJCXRlc3RfY21wX3JldiAhIHJlZnMvcmVtb3Rlcy9yZXBvX2EvZm9vIHJlZnMvaGVhZHMvZm9vCiAJKQogJwogCkBAIC00ODMsNyArNDgzLDcgQEAKIAkJY2QgZm9vICYmCiAJCXRlc3RfbXVzdF9mYWlsIGdpdCBjb25maWcgImJyYW5jaC5mb28ucmVtb3RlIiAmJgogCQl0ZXN0X211c3RfZmFpbCBnaXQgY29uZmlnICJicmFuY2guZm9vLm1lcmdlIiAmJgotCQkhIHRlc3RfY21wX3JldiByZWZzL3JlbW90ZXMvcmVwb19hL2ZvbyByZWZzL2hlYWRzL2ZvbworCQl0ZXN0X2NtcF9yZXYgISByZWZzL3JlbW90ZXMvcmVwb19hL2ZvbyByZWZzL2hlYWRzL2ZvbwogCSkKICcKIApAQCAtNTg3LDQgKzU4NywyOCBAQAogCSkKICcKIAordGVzdF9leHBlY3Rfc3VjY2VzcyAnImFkZCIgd2l0aCB1bmluaXRpYWxpemVkIHN1Ym1vZHVsZSwgd2l0aCBzdWJtb2R1bGUucmVjdXJzZSB1bnNldCcgJworCXRlc3RfY3JlYXRlX3JlcG8gc3VibW9kdWxlICYmCisJdGVzdF9jb21taXQgLUMgc3VibW9kdWxlIGZpcnN0ICYmCisJdGVzdF9jcmVhdGVfcmVwbyBwcm9qZWN0ICYmCisJZ2l0IC1DIHByb2plY3Qgc3VibW9kdWxlIGFkZCAuLi9zdWJtb2R1bGUgJiYKKwlnaXQgLUMgcHJvamVjdCBhZGQgc3VibW9kdWxlICYmCisJdGVzdF90aWNrICYmCisJZ2l0IC1DIHByb2plY3QgY29tbWl0IC1tIGFkZF9zdWIgJiYKKwlnaXQgY2xvbmUgcHJvamVjdCBwcm9qZWN0LWNsb25lICYmCisJZ2l0IC1DIHByb2plY3QtY2xvbmUgd29ya3RyZWUgYWRkIC4uL3Byb2plY3QtMgorJwordGVzdF9leHBlY3Rfc3VjY2VzcyAnImFkZCIgd2l0aCB1bmluaXRpYWxpemVkIHN1Ym1vZHVsZSwgd2l0aCBzdWJtb2R1bGUucmVjdXJzZSBzZXQnICcKKwlnaXQgLUMgcHJvamVjdC1jbG9uZSAtYyBzdWJtb2R1bGUucmVjdXJzZSB3b3JrdHJlZSBhZGQgLi4vcHJvamVjdC0zCisnCisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJyJhZGQiIHdpdGggaW5pdGlhbGl6ZWQgc3VibW9kdWxlLCB3aXRoIHN1Ym1vZHVsZS5yZWN1cnNlIHVuc2V0JyAnCisJZ2l0IC1DIHByb2plY3QtY2xvbmUgc3VibW9kdWxlIHVwZGF0ZSAtLWluaXQgJiYKKwlnaXQgLUMgcHJvamVjdC1jbG9uZSB3b3JrdHJlZSBhZGQgLi4vcHJvamVjdC00CisnCisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJyJhZGQiIHdpdGggaW5pdGlhbGl6ZWQgc3VibW9kdWxlLCB3aXRoIHN1Ym1vZHVsZS5yZWN1cnNlIHNldCcgJworCWdpdCAtQyBwcm9qZWN0LWNsb25lIC1jIHN1Ym1vZHVsZS5yZWN1cnNlIHdvcmt0cmVlIGFkZCAuLi9wcm9qZWN0LTUKKycKKwogdGVzdF9kb25lCmRpZmYgLS1naXQgYS90L3QzMDA1LWxzLWZpbGVzLXJlbGF0aXZlLnNoIGIvdC90MzAwNS1scy1maWxlcy1yZWxhdGl2ZS5zaAppbmRleCAyMDliNGM3Li4yZWM2OWE4IDEwMDc1NQotLS0gYS90L3QzMDA1LWxzLWZpbGVzLXJlbGF0aXZlLnNoCisrKyBiL3QvdDMwMDUtbHMtZmlsZXMtcmVsYXRpdmUuc2gKQEAgLTcsMTAgKzcsNiBAQAogCiAuIC4vdGVzdC1saWIuc2gKIAotbmV3X2xpbmU9JwotJwotc3E9XCcKLQogdGVzdF9leHBlY3Rfc3VjY2VzcyAncHJlcGFyZScgJwogCTogPm5ldmVyLW1pbmQtbWUgJiYKIAlnaXQgYWRkIG5ldmVyLW1pbmQtbWUgJiYKQEAgLTQ0LDkgKzQwLDkgQEAKIAkJY2QgdG9wL3N1YiAmJgogCQlmb3IgZiBpbiAuLi95KgogCQlkbwotCQkJZWNobyAiZXJyb3I6IHBhdGhzcGVjICRzcSRmJHNxIGRpZCBub3QgbWF0Y2ggYW55IGZpbGUocykga25vd24gdG8gZ2l0IgorCQkJZWNobyAiZXJyb3I6IHBhdGhzcGVjICRTUSRmJFNRIGRpZCBub3QgbWF0Y2ggYW55IGZpbGUocykga25vd24gdG8gZ2l0IgogCQlkb25lID5leHBlY3QuZXJyICYmCi0JCWVjaG8gIkRpZCB5b3UgZm9yZ2V0IHRvICR7c3F9Z2l0IGFkZCR7c3F9PyIgPj5leHBlY3QuZXJyICYmCisJCWVjaG8gIkRpZCB5b3UgZm9yZ2V0IHRvICR7U1F9Z2l0IGFkZCR7U1F9PyIgPj5leHBlY3QuZXJyICYmCiAJCWxzIC4uL3gqID5leHBlY3Qub3V0ICYmCiAJCXRlc3RfbXVzdF9mYWlsIGdpdCBscy1maWxlcyAtYyAtLWVycm9yLXVubWF0Y2ggLi4vW3h5XSogPmFjdHVhbC5vdXQgMj5hY3R1YWwuZXJyICYmCiAJCXRlc3RfY21wIGV4cGVjdC5vdXQgYWN0dWFsLm91dCAmJgpAQCAtNTksOSArNTUsOSBAQAogCQljZCB0b3Avc3ViICYmCiAJCWZvciBmIGluIC4uL3gqCiAJCWRvCi0JCQllY2hvICJlcnJvcjogcGF0aHNwZWMgJHNxJGYkc3EgZGlkIG5vdCBtYXRjaCBhbnkgZmlsZShzKSBrbm93biB0byBnaXQiCisJCQllY2hvICJlcnJvcjogcGF0aHNwZWMgJFNRJGYkU1EgZGlkIG5vdCBtYXRjaCBhbnkgZmlsZShzKSBrbm93biB0byBnaXQiCiAJCWRvbmUgPmV4cGVjdC5lcnIgJiYKLQkJZWNobyAiRGlkIHlvdSBmb3JnZXQgdG8gJHtzcX1naXQgYWRkJHtzcX0/IiA+PmV4cGVjdC5lcnIgJiYKKwkJZWNobyAiRGlkIHlvdSBmb3JnZXQgdG8gJHtTUX1naXQgYWRkJHtTUX0/IiA+PmV4cGVjdC5lcnIgJiYKIAkJbHMgLi4veSogPmV4cGVjdC5vdXQgJiYKIAkJdGVzdF9tdXN0X2ZhaWwgZ2l0IGxzLWZpbGVzIC1vIC0tZXJyb3ItdW5tYXRjaCAuLi9beHldKiA+YWN0dWFsLm91dCAyPmFjdHVhbC5lcnIgJiYKIAkJdGVzdF9jbXAgZXhwZWN0Lm91dCBhY3R1YWwub3V0ICYmCmRpZmYgLS1naXQgYS90L3QzMDMwLW1lcmdlLXJlY3Vyc2l2ZS5zaCBiL3QvdDMwMzAtbWVyZ2UtcmVjdXJzaXZlLnNoCmluZGV4IGZmNjQxYjMuLjIxNzA3NTggMTAwNzU1Ci0tLSBhL3QvdDMwMzAtbWVyZ2UtcmVjdXJzaXZlLnNoCisrKyBiL3QvdDMwMzAtbWVyZ2UtcmVjdXJzaXZlLnNoCkBAIC00NTIsNiArNDUyLDM0IEBACiAKICcKIAordGVzdF9leHBlY3Rfc3VjY2VzcyBTWU1MSU5LUyAnZGlyIGluIHdvcmtpbmcgdHJlZSB3aXRoIHN5bWxpbmsgYW5jZXN0b3IgZG9lcyBub3QgcHJvZHVjZSBkL2YgY29uZmxpY3QnICcKKwlnaXQgaW5pdCBzeW0gJiYKKwkoCisJCWNkIHN5bSAmJgorCQlsbiAtcyAuIGZvbyAmJgorCQlta2RpciBiYXIgJiYKKwkJPmJhci9maWxlICYmCisJCWdpdCBhZGQgZm9vIGJhci9maWxlICYmCisJCWdpdCBjb21taXQgLW0gImZvbyBzeW1saW5rIiAmJgorCisJCWdpdCBjaGVja291dCAtYiBicmFuY2gxICYmCisJCWdpdCBjb21taXQgLS1hbGxvdy1lbXB0eSAtbSAiZW1wdHkgY29tbWl0IiAmJgorCisJCWdpdCBjaGVja291dCBtYXN0ZXIgJiYKKwkJZ2l0IHJtIGZvbyAmJgorCQlta2RpciBmb28gJiYKKwkJPmZvby9iYXIgJiYKKwkJZ2l0IGFkZCBmb28vYmFyICYmCisJCWdpdCBjb21taXQgLW0gInJlcGxhY2UgZm9vIHN5bWxpbmsgd2l0aCByZWFsIGZvbyBkaXIgYW5kIGZvby9iYXIgZmlsZSIgJiYKKworCQlnaXQgY2hlY2tvdXQgYnJhbmNoMSAmJgorCisJCWdpdCBjaGVycnktcGljayBtYXN0ZXIgJiYKKwkJdGVzdF9wYXRoX2lzX2RpciBmb28gJiYKKwkJdGVzdF9wYXRoX2lzX2ZpbGUgZm9vL2JhcgorCSkKKycKKwogdGVzdF9leHBlY3Rfc3VjY2VzcyAncmVzZXQgYW5kIDMtd2F5IG1lcmdlJyAnCiAKIAlnaXQgcmVzZXQgLS1oYXJkICIkYzIiICYmCkBAIC02NjcsMTUgKzY5NSwyMiBAQAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnbWVyZ2UtcmVjdXJzaXZlIHJlbWVtYmVycyB0aGUgbmFtZXMgb2YgYWxsIGJhc2UgdHJlZXMnICcKIAlnaXQgcmVzZXQgLS1oYXJkIEhFQUQgJiYKIAorCSMgbWFrZSB0aGUgaW5kZXggbWF0Y2ggJGMxIHNvIHRoYXQgbWVyZ2UtcmVjdXJzaXZlIGJlbG93IGRvZXMgbm90CisJIyBmYWlsIGVhcmx5CisJZ2l0IGRpZmYgLS1iaW5hcnkgSEVBRCAkYzEgLS0gfCBnaXQgYXBwbHkgLS1jYWNoZWQgJiYKKwogCSMgbW9yZSB0cmVlcyB0aGFuIHN0YXRpYyBzbG90cyB1c2VkIGJ5IG9pZF90b19oZXgoKQogCWZvciBjb21taXQgaW4gJGMwICRjMiAkYzQgJGM1ICRjNiAkYzcKIAlkbwogCQlnaXQgcmV2LXBhcnNlICIkY29tbWl0Xnt0cmVlfSIKIAlkb25lID50cmVlcyAmJgogCi0JIyBpZ25vcmUgdGhlIHJldHVybiBjb2RlIC0tIGl0IG9ubHkgZmFpbHMgYmVjYXVzZSB0aGUgaW5wdXQgaXMgd2VpcmQKKwkjIGlnbm9yZSB0aGUgcmV0dXJuIGNvZGU7IGl0IG9ubHkgZmFpbHMgYmVjYXVzZSB0aGUgaW5wdXQgaXMgd2VpcmQuLi4KIAl0ZXN0X211c3RfZmFpbCBnaXQgLWMgbWVyZ2UudmVyYm9zaXR5PTUgbWVyZ2UtcmVjdXJzaXZlICQoY2F0IHRyZWVzKSAtLSAkYzEgJGMzID5vdXQgJiYKIAorCSMgLi4uYnV0IG1ha2Ugc3VyZSBpdCBmYWlscyBpbiB0aGUgZXhwZWN0ZWQgd2F5CisJdGVzdF9pMThuZ3JlcCBDT05GTElDVC4qcmVuYW1lL3JlbmFtZSBvdXQgJiYKKwogCSMgbWVyZ2UtcmVjdXJzaXZlIHByaW50cyBpbiByZXZlcnNlIG9yZGVyLCBidXQgd2UgZG8gbm90IGNhcmUKIAlzb3J0IDx0cmVlcyA+ZXhwZWN0ICYmCiAJc2VkIC1uICJzL152aXJ0dWFsIC8vcCIgb3V0IHwgc29ydCA+YWN0dWFsICYmCmRpZmYgLS1naXQgYS90L3QzMDYwLWxzLWZpbGVzLXdpdGgtdHJlZS5zaCBiL3QvdDMwNjAtbHMtZmlsZXMtd2l0aC10cmVlLnNoCmluZGV4IDQ0ZjM3OGMuLjUyZWQ2NjUgMTAwNzU1Ci0tLSBhL3QvdDMwNjAtbHMtZmlsZXMtd2l0aC10cmVlLnNoCisrKyBiL3QvdDMwNjAtbHMtZmlsZXMtd2l0aC10cmVlLnNoCkBAIC00Nyw3ICs0Nyw3IEBACiAJZ2l0IGFkZCAuCiAnCiAKLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2dpdCAtbHMtZmlsZXMgLS13aXRoLXRyZWUgc2hvdWxkIHN1Y2NlZWQgZnJvbSBzdWJkaXInICcKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2dpdCBscy1maWxlcyAtLXdpdGgtdHJlZSBzaG91bGQgc3VjY2VlZCBmcm9tIHN1YmRpcicgJwogCSMgV2UgaGF2ZSB0byBydW4gZnJvbSBhIHN1Yi1kaXJlY3RvcnkgdG8gdHJpZ2dlciBwcnVuZV9wYXRoCiAJIyBUaGVuIHdlIGZpbmFsbHkgZ2V0IHRvIHJ1biBvdXIgLS13aXRoLXRyZWUgdGVzdAogCSgKQEAgLTU3LDcgKzU3LDcgQEAKICcKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyBcCi0gICAgJ2dpdCAtbHMtZmlsZXMgLS13aXRoLXRyZWUgc2hvdWxkIGFkZCBlbnRyaWVzIGZyb20gbmFtZWQgdHJlZS4nIFwKKyAgICAnZ2l0IGxzLWZpbGVzIC0td2l0aC10cmVlIHNob3VsZCBhZGQgZW50cmllcyBmcm9tIG5hbWVkIHRyZWUuJyBcCiAgICAgJ3Rlc3RfY21wIGV4cGVjdGVkIG91dHB1dCcKIAogdGVzdF9kb25lCmRpZmYgLS1naXQgYS90L3QzMjAxLWJyYW5jaC1jb250YWlucy5zaCBiL3QvdDMyMDEtYnJhbmNoLWNvbnRhaW5zLnNoCmluZGV4IDBlYTRmYzQuLjQwMjUxYzkgMTAwNzU1Ci0tLSBhL3QvdDMyMDEtYnJhbmNoLWNvbnRhaW5zLnNoCisrKyBiL3QvdDMyMDEtYnJhbmNoLWNvbnRhaW5zLnNoCkBAIC0xOTIsMTAgKzE5MiwxMCBAQAogCUVPRgogCXRlc3RfY21wIGV4cGVjdCBhY3R1YWwgJiYKIAlnaXQgYnJhbmNoIC0tdmVyYm9zZSAtLW1lcmdlZCB0b3BpYyA+YWN0dWFsICYmCi0JY2F0ID5leHBlY3QgPDwtXEVPRiAmJgotCSAgbWFzdGVyIGM3N2EwYTkgc2Vjb25kIG9uIG1hc3RlcgotCSogdG9waWMgIDJjOTM5ZjQgW2FoZWFkIDFdIGZvbwotCSAgenp6ICAgIGM3N2EwYTkgc2Vjb25kIG9uIG1hc3RlcgorCWNhdCA+ZXhwZWN0IDw8LUVPRiAmJgorCSAgbWFzdGVyICQoZ2l0IHJldi1wYXJzZSAtLXNob3J0IG1hc3Rlcikgc2Vjb25kIG9uIG1hc3RlcgorCSogdG9waWMgICQoZ2l0IHJldi1wYXJzZSAtLXNob3J0IHRvcGljICkgW2FoZWFkIDFdIGZvbworCSAgenp6ICAgICQoZ2l0IHJldi1wYXJzZSAtLXNob3J0IHp6eiAgICkgc2Vjb25kIG9uIG1hc3RlcgogCUVPRgogCXRlc3RfaTE4bmNtcCBleHBlY3QgYWN0dWFsCiAnCmRpZmYgLS1naXQgYS90L3QzMjA2LXJhbmdlLWRpZmYuc2ggYi90L3QzMjA2LXJhbmdlLWRpZmYuc2gKaW5kZXggZWM1NDg2NS4uZWMyYjQ1NiAxMDA3NTUKLS0tIGEvdC90MzIwNi1yYW5nZS1kaWZmLnNoCisrKyBiL3QvdDMyMDYtcmFuZ2UtZGlmZi5zaApAQCAtOCw5NyArOCwyMDQgQEAKICMgaGFybSB0aGFuIGdvb2QuICBXZSBuZWVkIHNvbWUgcmVhbCBoaXN0b3J5LgogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdzZXR1cCcgJwotCWdpdCBmYXN0LWltcG9ydCA8ICIkVEVTVF9ESVJFQ1RPUlkiL3QzMjA2L2hpc3RvcnkuZXhwb3J0CisJZ2l0IGZhc3QtaW1wb3J0IDwiJFRFU1RfRElSRUNUT1JZIi90MzIwNi9oaXN0b3J5LmV4cG9ydCAmJgorCXRlc3Rfb2lkX2NhY2hlIDw8LVxFT0YKKwkjIHRvcGljCisJdDEgc2hhMTo0ZGU0NTdkCisJdDIgc2hhMTpmY2NjZTIyCisJdDMgc2hhMToxNDdlNjRlCisJdDQgc2hhMTphNjNlOTkyCisJdDEgc2hhMjU2OmI4OWY4YjkKKwl0MiBzaGEyNTY6NWYxMmFhZAorCXQzIHNoYTI1NjplYThiMjczCisJdDQgc2hhMjU2OjE0YjczMzYKKworCSMgdW5tb2RpZmllZAorCXUxIHNoYTE6MzViOWIyNQorCXUyIHNoYTE6ZGUzNDVhYgorCXUzIHNoYTE6OWFmNjY1NAorCXU0IHNoYTE6MjkwMWY3NworCXUxIHNoYTI1NjplMzczMWJlCisJdTIgc2hhMjU2OjE0ZmFkZjgKKwl1MyBzaGEyNTY6NzM2YzRiYworCXU0IHNoYTI1Njo2NzNlNzdkCisKKwkjIHJlb3JkZXJlZAorCXIxIHNoYTE6YWNhMTc3YQorCXIyIHNoYTE6MTRhZDYyOQorCXIzIHNoYTE6ZWU1ODIwOAorCXI0IHNoYTE6MzA3YjI3YQorCXIxIHNoYTI1NjpmNTlkM2FhCisJcjIgc2hhMjU2OmZiMjYxYTgKKwlyMyBzaGEyNTY6Y2IyNjQ5YgorCXI0IHNoYTI1Njo5NTg1NzdlCisKKwkjIHJlbW92ZWQgKGRlbGV0ZWQpCisJZDEgc2hhMTo3NjU3MTU5CisJZDIgc2hhMTo0M2Q4NGQzCisJZDMgc2hhMTphNzQwMzk2CisJZDEgc2hhMjU2OmUzMTI1MTMKKwlkMiBzaGEyNTY6ZWIxOTI1OAorCWQzIHNoYTI1NjoxY2NiM2MxCisKKwkjIGFkZGVkCisJYTEgc2hhMToyNzE2MDIyCisJYTIgc2hhMTpiNjJhY2NkCisJYTMgc2hhMTpkZjQ2Y2ZhCisJYTQgc2hhMTozZTY0NTQ4CisJYTUgc2hhMToxMmI0MDYzCisJYTEgc2hhMjU2OmQ3MjRmNGQKKwlhMiBzaGEyNTY6MWRlNzc2MgorCWEzIHNoYTI1NjplMTU5NDMxCisJYTQgc2hhMjU2OmIzZTQ4M2MKKwlhNSBzaGEyNTY6OTA4NjZhNworCisJIyByZWJhc2VkCisJYjEgc2hhMTpjYzljNDQzCisJYjIgc2hhMTpjNWQ5NjQxCisJYjMgc2hhMToyOGNjMmI2CisJYjQgc2hhMTo1NjI4YWI3CisJYjUgc2hhMTphMzFiMTJlCisJYjEgc2hhMjU2OmExYTg3MTcKKwliMiBzaGEyNTY6MjBhNTg2MgorCWIzIHNoYTI1Njo1ODcxNzJhCisJYjQgc2hhMjU2OjI3MjFjNWQKKwliNSBzaGEyNTY6N2I1Nzg2NAorCisJIyBjaGFuZ2VkCisJYzEgc2hhMTphNGIzMzMzCisJYzIgc2hhMTpmNTFkMzcwCisJYzMgc2hhMTowNTU5NTU2CisJYzQgc2hhMTpkOTY2YzVjCisJYzEgc2hhMjU2OmY4YzJiOWQKKwljMiBzaGEyNTY6M2ZiNjMxOAorCWMzIHNoYTI1NjoxNjhhYjY4CisJYzQgc2hhMjU2OjM1MjY1MzkKKworCSMgY2hhbmdlZC1tZXNzYWdlCisJbTEgc2hhMTpmNjg2MDI0CisJbTIgc2hhMTo0YWIwNjdkCisJbTMgc2hhMTpiOWNiOTU2CisJbTQgc2hhMTo4YWRkNWYxCisJbTEgc2hhMjU2OjMxZTYyODEKKwltMiBzaGEyNTY6YTA2YmYxYgorCW0zIHNoYTI1Njo4MmRjNjU0CisJbTQgc2hhMjU2OjQ4NDcwYzUKKworCSMgcmVuYW1lZAorCW4xIHNoYTE6ZjI1OGQ3NQorCW4yIHNoYTE6MDE3YjYyZAorCW4zIHNoYTE6M2NlN2FmNgorCW40IHNoYTE6MWU2MjI2YgorCW4xIHNoYTI1NjphZDUyMTE0CisJbjIgc2hhMjU2OjNiNTRjOGYKKwluMyBzaGEyNTY6M2IwYTY0NAorCW40IHNoYTI1NjplNDYxNjUzCisKKwkjIGFkZGVkIGFuZCByZW1vdmVkCisJczEgc2hhMTowOTZiMWJhCisJczIgc2hhMTpkOTJlNjk4CisJczMgc2hhMTo5YTFkYjRkCisJczQgc2hhMTpmZWEzYjVjCisJczEgc2hhMjU2OmE3ZjkxMzQKKwlzMiBzaGEyNTY6YjRjMjU4MAorCXMzIHNoYTI1NjoxZDYyYWEyCisJczQgc2hhMjU2OjQ4MTYwZTgKKworCSMgRW1wdHkgZGVsaW1pdGVyIChpbmNsdWRlZCBzbyBsaW5lcyBtYXRjaCBuZWF0bHkpCisJX18gc2hhMTotLS0tLS0tCisJX18gc2hhMjU2Oi0tLS0tLS0KKwlFT0YKICcKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnc2ltcGxlIEEuLkIgQS4uQyAodW5tb2RpZmllZCknICcKIAlnaXQgcmFuZ2UtZGlmZiAtLW5vLWNvbG9yIG1hc3Rlci4udG9waWMgbWFzdGVyLi51bm1vZGlmaWVkIFwKIAkJPmFjdHVhbCAmJgotCWNhdCA+ZXhwZWN0ZWQgPDwtRU9GICYmCi0JMTogIDRkZTQ1N2QgPSAxOiAgMzViOWIyNSBzLzUvQS8KLQkyOiAgZmNjY2UyMiA9IDI6ICBkZTM0NWFiIHMvNC9BLwotCTM6ICAxNDdlNjRlID0gMzogIDlhZjY2NTQgcy8xMS9CLwotCTQ6ICBhNjNlOTkyID0gNDogIDI5MDFmNzcgcy8xMi9CLworCWNhdCA+ZXhwZWN0IDw8LUVPRiAmJgorCTE6ICAkKHRlc3Rfb2lkIHQxKSA9IDE6ICAkKHRlc3Rfb2lkIHUxKSBzLzUvQS8KKwkyOiAgJCh0ZXN0X29pZCB0MikgPSAyOiAgJCh0ZXN0X29pZCB1Mikgcy80L0EvCisJMzogICQodGVzdF9vaWQgdDMpID0gMzogICQodGVzdF9vaWQgdTMpIHMvMTEvQi8KKwk0OiAgJCh0ZXN0X29pZCB0NCkgPSA0OiAgJCh0ZXN0X29pZCB1NCkgcy8xMi9CLwogCUVPRgotCXRlc3RfY21wIGV4cGVjdGVkIGFjdHVhbAorCXRlc3RfY21wIGV4cGVjdCBhY3R1YWwKICcKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnc2ltcGxlIEIuLi5DICh1bm1vZGlmaWVkKScgJwogCWdpdCByYW5nZS1kaWZmIC0tbm8tY29sb3IgdG9waWMuLi51bm1vZGlmaWVkID5hY3R1YWwgJiYKLQkjIHNhbWUgImV4cGVjdGVkIiBhcyBhYm92ZQotCXRlc3RfY21wIGV4cGVjdGVkIGFjdHVhbAorCSMgc2FtZSAiZXhwZWN0IiBhcyBhYm92ZQorCXRlc3RfY21wIGV4cGVjdCBhY3R1YWwKICcKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnc2ltcGxlIEEgQiBDICh1bm1vZGlmaWVkKScgJwogCWdpdCByYW5nZS1kaWZmIC0tbm8tY29sb3IgbWFzdGVyIHRvcGljIHVubW9kaWZpZWQgPmFjdHVhbCAmJgotCSMgc2FtZSAiZXhwZWN0ZWQiIGFzIGFib3ZlCi0JdGVzdF9jbXAgZXhwZWN0ZWQgYWN0dWFsCisJIyBzYW1lICJleHBlY3QiIGFzIGFib3ZlCisJdGVzdF9jbXAgZXhwZWN0IGFjdHVhbAogJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICd0cml2aWFsIHJlb3JkZXJpbmcnICcKIAlnaXQgcmFuZ2UtZGlmZiAtLW5vLWNvbG9yIG1hc3RlciB0b3BpYyByZW9yZGVyZWQgPmFjdHVhbCAmJgotCWNhdCA+ZXhwZWN0ZWQgPDwtRU9GICYmCi0JMTogIDRkZTQ1N2QgPSAxOiAgYWNhMTc3YSBzLzUvQS8KLQkzOiAgMTQ3ZTY0ZSA9IDI6ICAxNGFkNjI5IHMvMTEvQi8KLQk0OiAgYTYzZTk5MiA9IDM6ICBlZTU4MjA4IHMvMTIvQi8KLQkyOiAgZmNjY2UyMiA9IDQ6ICAzMDdiMjdhIHMvNC9BLworCWNhdCA+ZXhwZWN0IDw8LUVPRiAmJgorCTE6ICAkKHRlc3Rfb2lkIHQxKSA9IDE6ICAkKHRlc3Rfb2lkIHIxKSBzLzUvQS8KKwkzOiAgJCh0ZXN0X29pZCB0MykgPSAyOiAgJCh0ZXN0X29pZCByMikgcy8xMS9CLworCTQ6ICAkKHRlc3Rfb2lkIHQ0KSA9IDM6ICAkKHRlc3Rfb2lkIHIzKSBzLzEyL0IvCisJMjogICQodGVzdF9vaWQgdDIpID0gNDogICQodGVzdF9vaWQgcjQpIHMvNC9BLwogCUVPRgotCXRlc3RfY21wIGV4cGVjdGVkIGFjdHVhbAorCXRlc3RfY21wIGV4cGVjdCBhY3R1YWwKICcKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAncmVtb3ZlZCBhIGNvbW1pdCcgJwogCWdpdCByYW5nZS1kaWZmIC0tbm8tY29sb3IgbWFzdGVyIHRvcGljIHJlbW92ZWQgPmFjdHVhbCAmJgotCWNhdCA+ZXhwZWN0ZWQgPDwtRU9GICYmCi0JMTogIDRkZTQ1N2QgPSAxOiAgNzY1NzE1OSBzLzUvQS8KLQkyOiAgZmNjY2UyMiA8IC06ICAtLS0tLS0tIHMvNC9BLwotCTM6ICAxNDdlNjRlID0gMjogIDQzZDg0ZDMgcy8xMS9CLwotCTQ6ICBhNjNlOTkyID0gMzogIGE3NDAzOTYgcy8xMi9CLworCWNhdCA+ZXhwZWN0IDw8LUVPRiAmJgorCTE6ICAkKHRlc3Rfb2lkIHQxKSA9IDE6ICAkKHRlc3Rfb2lkIGQxKSBzLzUvQS8KKwkyOiAgJCh0ZXN0X29pZCB0MikgPCAtOiAgJCh0ZXN0X29pZCBfXykgcy80L0EvCisJMzogICQodGVzdF9vaWQgdDMpID0gMjogICQodGVzdF9vaWQgZDIpIHMvMTEvQi8KKwk0OiAgJCh0ZXN0X29pZCB0NCkgPSAzOiAgJCh0ZXN0X29pZCBkMykgcy8xMi9CLwogCUVPRgotCXRlc3RfY21wIGV4cGVjdGVkIGFjdHVhbAorCXRlc3RfY21wIGV4cGVjdCBhY3R1YWwKICcKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnYWRkZWQgYSBjb21taXQnICcKIAlnaXQgcmFuZ2UtZGlmZiAtLW5vLWNvbG9yIG1hc3RlciB0b3BpYyBhZGRlZCA+YWN0dWFsICYmCi0JY2F0ID5leHBlY3RlZCA8PC1FT0YgJiYKLQkxOiAgNGRlNDU3ZCA9IDE6ICAyNzE2MDIyIHMvNS9BLwotCTI6ICBmY2NjZTIyID0gMjogIGI2MmFjY2Qgcy80L0EvCi0JLTogIC0tLS0tLS0gPiAzOiAgZGY0NmNmYSBzLzYvQS8KLQkzOiAgMTQ3ZTY0ZSA9IDQ6ICAzZTY0NTQ4IHMvMTEvQi8KLQk0OiAgYTYzZTk5MiA9IDU6ICAxMmI0MDYzIHMvMTIvQi8KKwljYXQgPmV4cGVjdCA8PC1FT0YgJiYKKwkxOiAgJCh0ZXN0X29pZCB0MSkgPSAxOiAgJCh0ZXN0X29pZCBhMSkgcy81L0EvCisJMjogICQodGVzdF9vaWQgdDIpID0gMjogICQodGVzdF9vaWQgYTIpIHMvNC9BLworCS06ICAkKHRlc3Rfb2lkIF9fKSA+IDM6ICAkKHRlc3Rfb2lkIGEzKSBzLzYvQS8KKwkzOiAgJCh0ZXN0X29pZCB0MykgPSA0OiAgJCh0ZXN0X29pZCBhNCkgcy8xMS9CLworCTQ6ICAkKHRlc3Rfb2lkIHQ0KSA9IDU6ICAkKHRlc3Rfb2lkIGE1KSBzLzEyL0IvCiAJRU9GCi0JdGVzdF9jbXAgZXhwZWN0ZWQgYWN0dWFsCisJdGVzdF9jbXAgZXhwZWN0IGFjdHVhbAogJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICduZXcgYmFzZSwgQSBCIEMnICcKIAlnaXQgcmFuZ2UtZGlmZiAtLW5vLWNvbG9yIG1hc3RlciB0b3BpYyByZWJhc2VkID5hY3R1YWwgJiYKLQljYXQgPmV4cGVjdGVkIDw8LUVPRiAmJgotCTE6ICA0ZGU0NTdkID0gMTogIGNjOWM0NDMgcy81L0EvCi0JMjogIGZjY2NlMjIgPSAyOiAgYzVkOTY0MSBzLzQvQS8KLQkzOiAgMTQ3ZTY0ZSA9IDM6ICAyOGNjMmI2IHMvMTEvQi8KLQk0OiAgYTYzZTk5MiA9IDQ6ICA1NjI4YWI3IHMvMTIvQi8KKwljYXQgPmV4cGVjdCA8PC1FT0YgJiYKKwkxOiAgJCh0ZXN0X29pZCB0MSkgPSAxOiAgJCh0ZXN0X29pZCBiMSkgcy81L0EvCisJMjogICQodGVzdF9vaWQgdDIpID0gMjogICQodGVzdF9vaWQgYjIpIHMvNC9BLworCTM6ICAkKHRlc3Rfb2lkIHQzKSA9IDM6ICAkKHRlc3Rfb2lkIGIzKSBzLzExL0IvCisJNDogICQodGVzdF9vaWQgdDQpID0gNDogICQodGVzdF9vaWQgYjQpIHMvMTIvQi8KIAlFT0YKLQl0ZXN0X2NtcCBleHBlY3RlZCBhY3R1YWwKKwl0ZXN0X2NtcCBleHBlY3QgYWN0dWFsCiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ25ldyBiYXNlLCBCLi4uQycgJwogCSMgdGhpcyBzeW50YXggaW5jbHVkZXMgdGhlIGNvbW1pdHMgZnJvbSBtYXN0ZXIhCiAJZ2l0IHJhbmdlLWRpZmYgLS1uby1jb2xvciB0b3BpYy4uLnJlYmFzZWQgPmFjdHVhbCAmJgotCWNhdCA+ZXhwZWN0ZWQgPDwtRU9GICYmCi0JLTogIC0tLS0tLS0gPiAxOiAgYTMxYjEyZSB1bnJlbGF0ZWQKLQkxOiAgNGRlNDU3ZCA9IDI6ICBjYzljNDQzIHMvNS9BLwotCTI6ICBmY2NjZTIyID0gMzogIGM1ZDk2NDEgcy80L0EvCi0JMzogIDE0N2U2NGUgPSA0OiAgMjhjYzJiNiBzLzExL0IvCi0JNDogIGE2M2U5OTIgPSA1OiAgNTYyOGFiNyBzLzEyL0IvCisJY2F0ID5leHBlY3QgPDwtRU9GICYmCisJLTogICQodGVzdF9vaWQgX18pID4gMTogICQodGVzdF9vaWQgYjUpIHVucmVsYXRlZAorCTE6ICAkKHRlc3Rfb2lkIHQxKSA9IDI6ICAkKHRlc3Rfb2lkIGIxKSBzLzUvQS8KKwkyOiAgJCh0ZXN0X29pZCB0MikgPSAzOiAgJCh0ZXN0X29pZCBiMikgcy80L0EvCisJMzogICQodGVzdF9vaWQgdDMpID0gNDogICQodGVzdF9vaWQgYjMpIHMvMTEvQi8KKwk0OiAgJCh0ZXN0X29pZCB0NCkgPSA1OiAgJCh0ZXN0X29pZCBiNCkgcy8xMi9CLwogCUVPRgotCXRlc3RfY21wIGV4cGVjdGVkIGFjdHVhbAorCXRlc3RfY21wIGV4cGVjdCBhY3R1YWwKICcKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnY2hhbmdlZCBjb21taXQnICcKIAlnaXQgcmFuZ2UtZGlmZiAtLW5vLWNvbG9yIHRvcGljLi4uY2hhbmdlZCA+YWN0dWFsICYmCi0JY2F0ID5leHBlY3RlZCA8PC1FT0YgJiYKLQkxOiAgNGRlNDU3ZCA9IDE6ICBhNGIzMzMzIHMvNS9BLwotCTI6ICBmY2NjZTIyID0gMjogIGY1MWQzNzAgcy80L0EvCi0JMzogIDE0N2U2NGUgISAzOiAgMDU1OTU1NiBzLzExL0IvCisJY2F0ID5leHBlY3QgPDwtRU9GICYmCisJMTogICQodGVzdF9vaWQgdDEpID0gMTogICQodGVzdF9vaWQgYzEpIHMvNS9BLworCTI6ICAkKHRlc3Rfb2lkIHQyKSA9IDI6ICAkKHRlc3Rfb2lkIGMyKSBzLzQvQS8KKwkzOiAgJCh0ZXN0X29pZCB0MykgISAzOiAgJCh0ZXN0X29pZCBjMykgcy8xMS9CLwogCSAgICBAQCBmaWxlOiBBCiAJICAgICAgOQogCSAgICAgIDEwCkBAIC0xMDgsNyArMjE1LDcgQEAKIAkgICAgICAxMgogCSAgICAgIDEzCiAJICAgICAgMTQKLQk0OiAgYTYzZTk5MiAhIDQ6ICBkOTY2YzVjIHMvMTIvQi8KKwk0OiAgJCh0ZXN0X29pZCB0NCkgISA0OiAgJCh0ZXN0X29pZCBjNCkgcy8xMi9CLwogCSAgICBAQCBmaWxlCiAJICAgICBAQCBmaWxlOiBBCiAJICAgICAgOQpAQCAtMTE5LDQ1ICsyMjYsNDUgQEAKIAkgICAgICtCCiAJICAgICAgMTMKIAlFT0YKLQl0ZXN0X2NtcCBleHBlY3RlZCBhY3R1YWwKKwl0ZXN0X2NtcCBleHBlY3QgYWN0dWFsCiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2NoYW5nZWQgY29tbWl0IHdpdGggLS1uby1wYXRjaCBkaWZmIG9wdGlvbicgJwogCWdpdCByYW5nZS1kaWZmIC0tbm8tY29sb3IgLS1uby1wYXRjaCB0b3BpYy4uLmNoYW5nZWQgPmFjdHVhbCAmJgotCWNhdCA+ZXhwZWN0ZWQgPDwtRU9GICYmCi0JMTogIDRkZTQ1N2QgPSAxOiAgYTRiMzMzMyBzLzUvQS8KLQkyOiAgZmNjY2UyMiA9IDI6ICBmNTFkMzcwIHMvNC9BLwotCTM6ICAxNDdlNjRlICEgMzogIDA1NTk1NTYgcy8xMS9CLwotCTQ6ICBhNjNlOTkyICEgNDogIGQ5NjZjNWMgcy8xMi9CLworCWNhdCA+ZXhwZWN0IDw8LUVPRiAmJgorCTE6ICAkKHRlc3Rfb2lkIHQxKSA9IDE6ICAkKHRlc3Rfb2lkIGMxKSBzLzUvQS8KKwkyOiAgJCh0ZXN0X29pZCB0MikgPSAyOiAgJCh0ZXN0X29pZCBjMikgcy80L0EvCisJMzogICQodGVzdF9vaWQgdDMpICEgMzogICQodGVzdF9vaWQgYzMpIHMvMTEvQi8KKwk0OiAgJCh0ZXN0X29pZCB0NCkgISA0OiAgJCh0ZXN0X29pZCBjNCkgcy8xMi9CLwogCUVPRgotCXRlc3RfY21wIGV4cGVjdGVkIGFjdHVhbAorCXRlc3RfY21wIGV4cGVjdCBhY3R1YWwKICcKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnY2hhbmdlZCBjb21taXQgd2l0aCAtLXN0YXQgZGlmZiBvcHRpb24nICcKIAlnaXQgcmFuZ2UtZGlmZiAtLW5vLWNvbG9yIC0tc3RhdCB0b3BpYy4uLmNoYW5nZWQgPmFjdHVhbCAmJgotCWNhdCA+ZXhwZWN0ZWQgPDwtRU9GICYmCi0JMTogIDRkZTQ1N2QgPSAxOiAgYTRiMzMzMyBzLzUvQS8KKwljYXQgPmV4cGVjdCA8PC1FT0YgJiYKKwkxOiAgJCh0ZXN0X29pZCB0MSkgPSAxOiAgJCh0ZXN0X29pZCBjMSkgcy81L0EvCiAJICAgICBhID0+IGIgfCAwCiAJICAgICAxIGZpbGUgY2hhbmdlZCwgMCBpbnNlcnRpb25zKCspLCAwIGRlbGV0aW9ucygtKQotCTI6ICBmY2NjZTIyID0gMjogIGY1MWQzNzAgcy80L0EvCisJMjogICQodGVzdF9vaWQgdDIpID0gMjogICQodGVzdF9vaWQgYzIpIHMvNC9BLwogCSAgICAgYSA9PiBiIHwgMAogCSAgICAgMSBmaWxlIGNoYW5nZWQsIDAgaW5zZXJ0aW9ucygrKSwgMCBkZWxldGlvbnMoLSkKLQkzOiAgMTQ3ZTY0ZSAhIDM6ICAwNTU5NTU2IHMvMTEvQi8KKwkzOiAgJCh0ZXN0X29pZCB0MykgISAzOiAgJCh0ZXN0X29pZCBjMykgcy8xMS9CLwogCSAgICAgYSA9PiBiIHwgMAogCSAgICAgMSBmaWxlIGNoYW5nZWQsIDAgaW5zZXJ0aW9ucygrKSwgMCBkZWxldGlvbnMoLSkKLQk0OiAgYTYzZTk5MiAhIDQ6ICBkOTY2YzVjIHMvMTIvQi8KKwk0OiAgJCh0ZXN0X29pZCB0NCkgISA0OiAgJCh0ZXN0X29pZCBjNCkgcy8xMi9CLwogCSAgICAgYSA9PiBiIHwgMAogCSAgICAgMSBmaWxlIGNoYW5nZWQsIDAgaW5zZXJ0aW9ucygrKSwgMCBkZWxldGlvbnMoLSkKIAlFT0YKLQl0ZXN0X2NtcCBleHBlY3RlZCBhY3R1YWwKKwl0ZXN0X2NtcCBleHBlY3QgYWN0dWFsCiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2NoYW5nZWQgY29tbWl0IHdpdGggc20gY29uZmlnJyAnCiAJZ2l0IHJhbmdlLWRpZmYgLS1uby1jb2xvciAtLXN1Ym1vZHVsZT1sb2cgdG9waWMuLi5jaGFuZ2VkID5hY3R1YWwgJiYKLQljYXQgPmV4cGVjdGVkIDw8LUVPRiAmJgotCTE6ICA0ZGU0NTdkID0gMTogIGE0YjMzMzMgcy81L0EvCi0JMjogIGZjY2NlMjIgPSAyOiAgZjUxZDM3MCBzLzQvQS8KLQkzOiAgMTQ3ZTY0ZSAhIDM6ICAwNTU5NTU2IHMvMTEvQi8KKwljYXQgPmV4cGVjdCA8PC1FT0YgJiYKKwkxOiAgJCh0ZXN0X29pZCB0MSkgPSAxOiAgJCh0ZXN0X29pZCBjMSkgcy81L0EvCisJMjogICQodGVzdF9vaWQgdDIpID0gMjogICQodGVzdF9vaWQgYzIpIHMvNC9BLworCTM6ICAkKHRlc3Rfb2lkIHQzKSAhIDM6ICAkKHRlc3Rfb2lkIGMzKSBzLzExL0IvCiAJICAgIEBAIGZpbGU6IEEKIAkgICAgICA5CiAJICAgICAgMTAKQEAgLTE2Nyw3ICsyNzQsNyBAQAogCSAgICAgIDEyCiAJICAgICAgMTMKIAkgICAgICAxNAotCTQ6ICBhNjNlOTkyICEgNDogIGQ5NjZjNWMgcy8xMi9CLworCTQ6ICAkKHRlc3Rfb2lkIHQ0KSAhIDQ6ICAkKHRlc3Rfb2lkIGM0KSBzLzEyL0IvCiAJICAgIEBAIGZpbGUKIAkgICAgIEBAIGZpbGU6IEEKIAkgICAgICA5CkBAIC0xNzgsMTQgKzI4NSwxNCBAQAogCSAgICAgK0IKIAkgICAgICAxMwogCUVPRgotCXRlc3RfY21wIGV4cGVjdGVkIGFjdHVhbAorCXRlc3RfY21wIGV4cGVjdCBhY3R1YWwKICcKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAncmVuYW1lZCBmaWxlJyAnCiAJZ2l0IHJhbmdlLWRpZmYgLS1uby1jb2xvciAtLXN1Ym1vZHVsZT1sb2cgdG9waWMuLi5yZW5hbWVkLWZpbGUgPmFjdHVhbCAmJgotCXNlZCBzL1ovXCAvZyA+ZXhwZWN0ZWQgPDwtRU9GICYmCi0JMTogIDRkZTQ1N2QgPSAxOiAgZjI1OGQ3NSBzLzUvQS8KLQkyOiAgZmNjY2UyMiAhIDI6ICAwMTdiNjJkIHMvNC9BLworCXNlZCBzL1ovXCAvZyA+ZXhwZWN0IDw8LUVPRiAmJgorCTE6ICAkKHRlc3Rfb2lkIHQxKSA9IDE6ICAkKHRlc3Rfb2lkIG4xKSBzLzUvQS8KKwkyOiAgJCh0ZXN0X29pZCB0MikgISAyOiAgJCh0ZXN0X29pZCBuMikgcy80L0EvCiAJICAgIEBAIE1ldGFkYXRhCiAJICAgIFpBdXRob3I6IFRob21hcyBSYXN0IDx0cmFzdEBpbmYuZXRoei5jaD4KIAkgICAgWgpAQCAtMTk4LDcgKzMwNSw3IEBACiAJICAgIFpAQAogCSAgICBaIDEKIAkgICAgWiAyCi0JMzogIDE0N2U2NGUgISAzOiAgM2NlN2FmNiBzLzExL0IvCisJMzogICQodGVzdF9vaWQgdDMpICEgMzogICQodGVzdF9vaWQgbjMpIHMvMTEvQi8KIAkgICAgQEAgTWV0YWRhdGEKIAkgICAgWiAjIyBDb21taXQgbWVzc2FnZSAjIwogCSAgICBaICAgIHMvMTEvQi8KQEAgLTIxMCw3ICszMTcsNyBAQAogCSAgICBaIDgKIAkgICAgWiA5CiAJICAgIFogMTAKLQk0OiAgYTYzZTk5MiAhIDQ6ICAxZTYyMjZiIHMvMTIvQi8KKwk0OiAgJCh0ZXN0X29pZCB0NCkgISA0OiAgJCh0ZXN0X29pZCBuNCkgcy8xMi9CLwogCSAgICBAQCBNZXRhZGF0YQogCSAgICBaICMjIENvbW1pdCBtZXNzYWdlICMjCiAJICAgIFogICAgcy8xMi9CLwpAQCAtMjIzLDE0ICszMzAsNTQgQEAKIAkgICAgWiAxMAogCSAgICBaIEIKIAlFT0YKLQl0ZXN0X2NtcCBleHBlY3RlZCBhY3R1YWwKKwl0ZXN0X2NtcCBleHBlY3QgYWN0dWFsCisnCisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2ZpbGUgd2l0aCBtb2RlIG9ubHkgY2hhbmdlJyAnCisJZ2l0IHJhbmdlLWRpZmYgLS1uby1jb2xvciAtLXN1Ym1vZHVsZT1sb2cgdG9waWMuLi5tb2RlLW9ubHktY2hhbmdlID5hY3R1YWwgJiYKKwlzZWQgcy9aL1wgL2cgPmV4cGVjdCA8PC1FT0YgJiYKKwkxOiAgZmNjY2UyMiAhIDE6ICA0ZDM5Y2IzIHMvNC9BLworCSAgICBAQCBNZXRhZGF0YQorCSAgICBaQXV0aG9yOiBUaG9tYXMgUmFzdCA8dHJhc3RAaW5mLmV0aHouY2g+CisJICAgIFoKKwkgICAgWiAjIyBDb21taXQgbWVzc2FnZSAjIworCSAgICAtICAgIHMvNC9BLworCSAgICArICAgIHMvNC9BLyArIGFkZCBvdGhlci1maWxlCisJICAgIFoKKwkgICAgWiAjIyBmaWxlICMjCisJICAgIFpAQAorCSAgICBAQCBmaWxlCisJICAgIFogQQorCSAgICBaIDYKKwkgICAgWiA3CisJICAgICsKKwkgICAgKyAjIyBvdGhlci1maWxlIChuZXcpICMjCisJMjogIDE0N2U2NGUgISAyOiAgMjZjMTA3ZiBzLzExL0IvCisJICAgIEBAIE1ldGFkYXRhCisJICAgIFpBdXRob3I6IFRob21hcyBSYXN0IDx0cmFzdEBpbmYuZXRoei5jaD4KKwkgICAgWgorCSAgICBaICMjIENvbW1pdCBtZXNzYWdlICMjCisJICAgIC0gICAgcy8xMS9CLworCSAgICArICAgIHMvMTEvQi8gKyBtb2RlIGNoYW5nZSBvdGhlci1maWxlCisJICAgIFoKKwkgICAgWiAjIyBmaWxlICMjCisJICAgIFpAQCBmaWxlOiBBCisJICAgIEBAIGZpbGU6IEEKKwkgICAgWiAxMgorCSAgICBaIDEzCisJICAgIFogMTQKKwkgICAgKworCSAgICArICMjIG90aGVyLWZpbGUgKG1vZGUgY2hhbmdlIDEwMDY0NCA9PiAxMDA3NTUpICMjCisJMzogIGE2M2U5OTIgPSAzOiAgNGMxZTBmNSBzLzEyL0IvCisJRU9GCisJdGVzdF9jbXAgZXhwZWN0IGFjdHVhbAogJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdmaWxlIGFkZGVkIGFuZCBsYXRlciByZW1vdmVkJyAnCiAJZ2l0IHJhbmdlLWRpZmYgLS1uby1jb2xvciAtLXN1Ym1vZHVsZT1sb2cgdG9waWMuLi5hZGRlZC1yZW1vdmVkID5hY3R1YWwgJiYKLQlzZWQgcy9aL1wgL2cgPmV4cGVjdGVkIDw8LUVPRiAmJgotCTE6ICA0ZGU0NTdkID0gMTogIDA5NmIxYmEgcy81L0EvCi0JMjogIGZjY2NlMjIgISAyOiAgZDkyZTY5OCBzLzQvQS8KKwlzZWQgcy9aL1wgL2cgPmV4cGVjdCA8PC1FT0YgJiYKKwkxOiAgJCh0ZXN0X29pZCB0MSkgPSAxOiAgJCh0ZXN0X29pZCBzMSkgcy81L0EvCisJMjogICQodGVzdF9vaWQgdDIpICEgMjogICQodGVzdF9vaWQgczIpIHMvNC9BLwogCSAgICBAQCBNZXRhZGF0YQogCSAgICBaQXV0aG9yOiBUaG9tYXMgUmFzdCA8dHJhc3RAaW5mLmV0aHouY2g+CiAJICAgIFoKQEAgLTI0Niw3ICszOTMsNyBAQAogCSAgICBaIDcKIAkgICAgKwogCSAgICArICMjIG5ldy1maWxlIChuZXcpICMjCi0JMzogIDE0N2U2NGUgISAzOiAgOWExZGI0ZCBzLzExL0IvCisJMzogICQodGVzdF9vaWQgdDMpICEgMzogICQodGVzdF9vaWQgczMpIHMvMTEvQi8KIAkgICAgQEAgTWV0YWRhdGEKIAkgICAgWkF1dGhvcjogVGhvbWFzIFJhc3QgPHRyYXN0QGluZi5ldGh6LmNoPgogCSAgICBaCkBAIC0yNjIsOSArNDA5LDkgQEAKIAkgICAgWiAxNAogCSAgICArCiAJICAgICsgIyMgbmV3LWZpbGUgKGRlbGV0ZWQpICMjCi0JNDogIGE2M2U5OTIgPSA0OiAgZmVhM2I1YyBzLzEyL0IvCisJNDogICQodGVzdF9vaWQgdDQpID0gNDogICQodGVzdF9vaWQgczQpIHMvMTIvQi8KIAlFT0YKLQl0ZXN0X2NtcCBleHBlY3RlZCBhY3R1YWwKKwl0ZXN0X2NtcCBleHBlY3QgYWN0dWFsCiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ25vIGNvbW1pdHMgb24gb25lIHNpZGUnICcKQEAgLTI3NCw5ICs0MjEsOSBAQAogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdjaGFuZ2VkIG1lc3NhZ2UnICcKIAlnaXQgcmFuZ2UtZGlmZiAtLW5vLWNvbG9yIHRvcGljLi4uY2hhbmdlZC1tZXNzYWdlID5hY3R1YWwgJiYKLQlzZWQgcy9aL1wgL2cgPmV4cGVjdGVkIDw8LUVPRiAmJgotCTE6ICA0ZGU0NTdkID0gMTogIGY2ODYwMjQgcy81L0EvCi0JMjogIGZjY2NlMjIgISAyOiAgNGFiMDY3ZCBzLzQvQS8KKwlzZWQgcy9aL1wgL2cgPmV4cGVjdCA8PC1FT0YgJiYKKwkxOiAgJCh0ZXN0X29pZCB0MSkgPSAxOiAgJCh0ZXN0X29pZCBtMSkgcy81L0EvCisJMjogICQodGVzdF9vaWQgdDIpICEgMjogICQodGVzdF9vaWQgbTIpIHMvNC9BLwogCSAgICBAQCBNZXRhZGF0YQogCSAgICBaICMjIENvbW1pdCBtZXNzYWdlICMjCiAJICAgIFogICAgcy80L0EvCkBAIC0yODYsMTYgKzQzMywxNiBAQAogCSAgICBaICMjIGZpbGUgIyMKIAkgICAgWkBACiAJICAgIFogMQotCTM6ICAxNDdlNjRlID0gMzogIGI5Y2I5NTYgcy8xMS9CLwotCTQ6ICBhNjNlOTkyID0gNDogIDhhZGQ1ZjEgcy8xMi9CLworCTM6ICAkKHRlc3Rfb2lkIHQzKSA9IDM6ICAkKHRlc3Rfb2lkIG0zKSBzLzExL0IvCisJNDogICQodGVzdF9vaWQgdDQpID0gNDogICQodGVzdF9vaWQgbTQpIHMvMTIvQi8KIAlFT0YKLQl0ZXN0X2NtcCBleHBlY3RlZCBhY3R1YWwKKwl0ZXN0X2NtcCBleHBlY3QgYWN0dWFsCiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2R1YWwtY29sb3JpbmcnICcKLQlzZWQgLWUgInN8Xjp8fCIgPmV4cGVjdCA8PC1cRU9GICYmCi0JOjxZRUxMT1c+MTogIGE0YjMzMzMgPSAxOiAgZjY4NjAyNCBzLzUvQS88UkVTRVQ+Ci0JOjxSRUQ+MjogIGY1MWQzNzAgPFJFU0VUPjxZRUxMT1c+ITxSRVNFVD48R1JFRU4+IDI6ICA0YWIwNjdkPFJFU0VUPjxZRUxMT1c+IHMvNC9BLzxSRVNFVD4KKwlzZWQgLWUgInN8Xjp8fCIgPmV4cGVjdCA8PC1FT0YgJiYKKwk6PFlFTExPVz4xOiAgJCh0ZXN0X29pZCBjMSkgPSAxOiAgJCh0ZXN0X29pZCBtMSkgcy81L0EvPFJFU0VUPgorCTo8UkVEPjI6ICAkKHRlc3Rfb2lkIGMyKSA8UkVTRVQ+PFlFTExPVz4hPFJFU0VUPjxHUkVFTj4gMjogICQodGVzdF9vaWQgbTIpPFJFU0VUPjxZRUxMT1c+IHMvNC9BLzxSRVNFVD4KIAk6ICAgIDxSRVZFUlNFPjxDWUFOPkBAPFJFU0VUPiA8UkVTRVQ+TWV0YWRhdGE8UkVTRVQ+CiAJOiAgICAgICMjIENvbW1pdCBtZXNzYWdlICMjPFJFU0VUPgogCTogICAgICAgICBzLzQvQS88UkVTRVQ+CkBAIC0zMDUsNyArNDUyLDcgQEAKIAk6ICAgICAgIyMgZmlsZSAjIzxSRVNFVD4KIAk6ICAgIDxDWUFOPiBAQDxSRVNFVD4KIAk6ICAgICAgMTxSRVNFVD4KLQk6PFJFRD4zOiAgMDU1OTU1NiA8UkVTRVQ+PFlFTExPVz4hPFJFU0VUPjxHUkVFTj4gMzogIGI5Y2I5NTY8UkVTRVQ+PFlFTExPVz4gcy8xMS9CLzxSRVNFVD4KKwk6PFJFRD4zOiAgJCh0ZXN0X29pZCBjMykgPFJFU0VUPjxZRUxMT1c+ITxSRVNFVD48R1JFRU4+IDM6ICAkKHRlc3Rfb2lkIG0zKTxSRVNFVD48WUVMTE9XPiBzLzExL0IvPFJFU0VUPgogCTogICAgPFJFVkVSU0U+PENZQU4+QEA8UkVTRVQ+IDxSRVNFVD5maWxlOiBBPFJFU0VUPgogCTogICAgICA5PFJFU0VUPgogCTogICAgICAxMDxSRVNFVD4KQEAgLTMxNSw3ICs0NjIsNyBAQAogCTogICAgICAxMjxSRVNFVD4KIAk6ICAgICAgMTM8UkVTRVQ+CiAJOiAgICAgIDE0PFJFU0VUPgotCTo8UkVEPjQ6ICBkOTY2YzVjIDxSRVNFVD48WUVMTE9XPiE8UkVTRVQ+PEdSRUVOPiA0OiAgOGFkZDVmMTxSRVNFVD48WUVMTE9XPiBzLzEyL0IvPFJFU0VUPgorCTo8UkVEPjQ6ICAkKHRlc3Rfb2lkIGM0KSA8UkVTRVQ+PFlFTExPVz4hPFJFU0VUPjxHUkVFTj4gNDogICQodGVzdF9vaWQgbTQpPFJFU0VUPjxZRUxMT1c+IHMvMTIvQi88UkVTRVQ+CiAJOiAgICA8UkVWRVJTRT48Q1lBTj5AQDxSRVNFVD4gPFJFU0VUPmZpbGU8UkVTRVQ+CiAJOiAgICA8Q1lBTj4gQEAgZmlsZTogQTxSRVNFVD4KIAk6ICAgICAgOTxSRVNFVD4KQEAgLTM1NCw0ICs1MDEsMjA2IEBACiAJZ3JlcCAiPiAxOiAuKiBuZXcgbWVzc2FnZSIgMDAwMS0qCiAnCiAKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3JhbmdlLWRpZmYgb3ZlcnJpZGVzIGRpZmYubm9wcmVmaXggaW50ZXJuYWxseScgJworCWdpdCAtYyBkaWZmLm5vcHJlZml4PXRydWUgcmFuZ2UtZGlmZiBIRUFEXi4uLgorJworCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdyYW5nZS1kaWZmIGNvbXBhcmVzIG5vdGVzIGJ5IGRlZmF1bHQnICcKKwlnaXQgbm90ZXMgYWRkIC1tICJ0b3BpYyBub3RlIiB0b3BpYyAmJgorCWdpdCBub3RlcyBhZGQgLW0gInVubW9kaWZpZWQgbm90ZSIgdW5tb2RpZmllZCAmJgorCXRlc3Rfd2hlbl9maW5pc2hlZCBnaXQgbm90ZXMgcmVtb3ZlIHRvcGljIHVubW9kaWZpZWQgJiYKKwlnaXQgcmFuZ2UtZGlmZiAtLW5vLWNvbG9yIG1hc3Rlci4udG9waWMgbWFzdGVyLi51bm1vZGlmaWVkIFwKKwkJPmFjdHVhbCAmJgorCXNlZCBzL1ovXCAvZyA+ZXhwZWN0IDw8LUVPRiAmJgorCTE6ICAkKHRlc3Rfb2lkIHQxKSA9IDE6ICAkKHRlc3Rfb2lkIHUxKSBzLzUvQS8KKwkyOiAgJCh0ZXN0X29pZCB0MikgPSAyOiAgJCh0ZXN0X29pZCB1Mikgcy80L0EvCisJMzogICQodGVzdF9vaWQgdDMpID0gMzogICQodGVzdF9vaWQgdTMpIHMvMTEvQi8KKwk0OiAgJCh0ZXN0X29pZCB0NCkgISA0OiAgJCh0ZXN0X29pZCB1NCkgcy8xMi9CLworCSAgICBAQCBDb21taXQgbWVzc2FnZQorCSAgICBaCisJICAgIFoKKwkgICAgWiAjIyBOb3RlcyAjIworCSAgICAtICAgIHRvcGljIG5vdGUKKwkgICAgKyAgICB1bm1vZGlmaWVkIG5vdGUKKwkgICAgWgorCSAgICBaICMjIGZpbGUgIyMKKwkgICAgWkBAIGZpbGU6IEEKKwlFT0YKKwl0ZXN0X2NtcCBleHBlY3QgYWN0dWFsCisnCisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3JhbmdlLWRpZmYgd2l0aCAtLW5vLW5vdGVzJyAnCisJZ2l0IG5vdGVzIGFkZCAtbSAidG9waWMgbm90ZSIgdG9waWMgJiYKKwlnaXQgbm90ZXMgYWRkIC1tICJ1bm1vZGlmaWVkIG5vdGUiIHVubW9kaWZpZWQgJiYKKwl0ZXN0X3doZW5fZmluaXNoZWQgZ2l0IG5vdGVzIHJlbW92ZSB0b3BpYyB1bm1vZGlmaWVkICYmCisJZ2l0IHJhbmdlLWRpZmYgLS1uby1jb2xvciAtLW5vLW5vdGVzIG1hc3Rlci4udG9waWMgbWFzdGVyLi51bm1vZGlmaWVkIFwKKwkJPmFjdHVhbCAmJgorCWNhdCA+ZXhwZWN0IDw8LUVPRiAmJgorCTE6ICAkKHRlc3Rfb2lkIHQxKSA9IDE6ICAkKHRlc3Rfb2lkIHUxKSBzLzUvQS8KKwkyOiAgJCh0ZXN0X29pZCB0MikgPSAyOiAgJCh0ZXN0X29pZCB1Mikgcy80L0EvCisJMzogICQodGVzdF9vaWQgdDMpID0gMzogICQodGVzdF9vaWQgdTMpIHMvMTEvQi8KKwk0OiAgJCh0ZXN0X29pZCB0NCkgPSA0OiAgJCh0ZXN0X29pZCB1NCkgcy8xMi9CLworCUVPRgorCXRlc3RfY21wIGV4cGVjdCBhY3R1YWwKKycKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAncmFuZ2UtZGlmZiB3aXRoIG11bHRpcGxlIC0tbm90ZXMnICcKKwlnaXQgbm90ZXMgLS1yZWY9bm90ZTEgYWRkIC1tICJ0b3BpYyBub3RlMSIgdG9waWMgJiYKKwlnaXQgbm90ZXMgLS1yZWY9bm90ZTEgYWRkIC1tICJ1bm1vZGlmaWVkIG5vdGUxIiB1bm1vZGlmaWVkICYmCisJdGVzdF93aGVuX2ZpbmlzaGVkIGdpdCBub3RlcyAtLXJlZj1ub3RlMSByZW1vdmUgdG9waWMgdW5tb2RpZmllZCAmJgorCWdpdCBub3RlcyAtLXJlZj1ub3RlMiBhZGQgLW0gInRvcGljIG5vdGUyIiB0b3BpYyAmJgorCWdpdCBub3RlcyAtLXJlZj1ub3RlMiBhZGQgLW0gInVubW9kaWZpZWQgbm90ZTIiIHVubW9kaWZpZWQgJiYKKwl0ZXN0X3doZW5fZmluaXNoZWQgZ2l0IG5vdGVzIC0tcmVmPW5vdGUyIHJlbW92ZSB0b3BpYyB1bm1vZGlmaWVkICYmCisJZ2l0IHJhbmdlLWRpZmYgLS1uby1jb2xvciAtLW5vdGVzPW5vdGUxIC0tbm90ZXM9bm90ZTIgbWFzdGVyLi50b3BpYyBtYXN0ZXIuLnVubW9kaWZpZWQgXAorCQk+YWN0dWFsICYmCisJc2VkIHMvWi9cIC9nID5leHBlY3QgPDwtRU9GICYmCisJMTogICQodGVzdF9vaWQgdDEpID0gMTogICQodGVzdF9vaWQgdTEpIHMvNS9BLworCTI6ICAkKHRlc3Rfb2lkIHQyKSA9IDI6ICAkKHRlc3Rfb2lkIHUyKSBzLzQvQS8KKwkzOiAgJCh0ZXN0X29pZCB0MykgPSAzOiAgJCh0ZXN0X29pZCB1Mykgcy8xMS9CLworCTQ6ICAkKHRlc3Rfb2lkIHQ0KSAhIDQ6ICAkKHRlc3Rfb2lkIHU0KSBzLzEyL0IvCisJICAgIEBAIENvbW1pdCBtZXNzYWdlCisJICAgIFoKKwkgICAgWgorCSAgICBaICMjIE5vdGVzIChub3RlMSkgIyMKKwkgICAgLSAgICB0b3BpYyBub3RlMQorCSAgICArICAgIHVubW9kaWZpZWQgbm90ZTEKKwkgICAgWgorCSAgICBaCisJICAgIFogIyMgTm90ZXMgKG5vdGUyKSAjIworCSAgICAtICAgIHRvcGljIG5vdGUyCisJICAgICsgICAgdW5tb2RpZmllZCBub3RlMgorCSAgICBaCisJICAgIFogIyMgZmlsZSAjIworCSAgICBaQEAgZmlsZTogQQorCUVPRgorCXRlc3RfY21wIGV4cGVjdCBhY3R1YWwKKycKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAnZm9ybWF0LXBhdGNoIC0tcmFuZ2UtZGlmZiBkb2VzIG5vdCBjb21wYXJlIG5vdGVzIGJ5IGRlZmF1bHQnICcKKwlnaXQgbm90ZXMgYWRkIC1tICJ0b3BpYyBub3RlIiB0b3BpYyAmJgorCWdpdCBub3RlcyBhZGQgLW0gInVubW9kaWZpZWQgbm90ZSIgdW5tb2RpZmllZCAmJgorCXRlc3Rfd2hlbl9maW5pc2hlZCBnaXQgbm90ZXMgcmVtb3ZlIHRvcGljIHVubW9kaWZpZWQgJiYKKwlnaXQgZm9ybWF0LXBhdGNoIC0tY292ZXItbGV0dGVyIC0tcmFuZ2UtZGlmZj0kcHJldiBcCisJCW1hc3Rlci4udW5tb2RpZmllZCA+YWN0dWFsICYmCisJdGVzdF93aGVuX2ZpbmlzaGVkICJybSAwMDA/LSoiICYmCisJdGVzdF9saW5lX2NvdW50ID0gNSBhY3R1YWwgJiYKKwl0ZXN0X2kxOG5ncmVwICJeUmFuZ2UtZGlmZjokIiAwMDAwLSogJiYKKwlncmVwICI9IDE6IC4qIHMvNS9BIiAwMDAwLSogJiYKKwlncmVwICI9IDI6IC4qIHMvNC9BIiAwMDAwLSogJiYKKwlncmVwICI9IDM6IC4qIHMvMTEvQiIgMDAwMC0qICYmCisJZ3JlcCAiPSA0OiAuKiBzLzEyL0IiIDAwMDAtKiAmJgorCSEgZ3JlcCAiTm90ZXMiIDAwMDAtKiAmJgorCSEgZ3JlcCAibm90ZSIgMDAwMC0qCisnCisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2Zvcm1hdC1wYXRjaCAtLXJhbmdlLWRpZmYgd2l0aCAtLW5vLW5vdGVzJyAnCisJZ2l0IG5vdGVzIGFkZCAtbSAidG9waWMgbm90ZSIgdG9waWMgJiYKKwlnaXQgbm90ZXMgYWRkIC1tICJ1bm1vZGlmaWVkIG5vdGUiIHVubW9kaWZpZWQgJiYKKwl0ZXN0X3doZW5fZmluaXNoZWQgZ2l0IG5vdGVzIHJlbW92ZSB0b3BpYyB1bm1vZGlmaWVkICYmCisJZ2l0IGZvcm1hdC1wYXRjaCAtLW5vLW5vdGVzIC0tY292ZXItbGV0dGVyIC0tcmFuZ2UtZGlmZj0kcHJldiBcCisJCW1hc3Rlci4udW5tb2RpZmllZCA+YWN0dWFsICYmCisJdGVzdF93aGVuX2ZpbmlzaGVkICJybSAwMDA/LSoiICYmCisJdGVzdF9saW5lX2NvdW50ID0gNSBhY3R1YWwgJiYKKwl0ZXN0X2kxOG5ncmVwICJeUmFuZ2UtZGlmZjokIiAwMDAwLSogJiYKKwlncmVwICI9IDE6IC4qIHMvNS9BIiAwMDAwLSogJiYKKwlncmVwICI9IDI6IC4qIHMvNC9BIiAwMDAwLSogJiYKKwlncmVwICI9IDM6IC4qIHMvMTEvQiIgMDAwMC0qICYmCisJZ3JlcCAiPSA0OiAuKiBzLzEyL0IiIDAwMDAtKiAmJgorCSEgZ3JlcCAiTm90ZXMiIDAwMDAtKiAmJgorCSEgZ3JlcCAibm90ZSIgMDAwMC0qCisnCisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2Zvcm1hdC1wYXRjaCAtLXJhbmdlLWRpZmYgd2l0aCAtLW5vdGVzJyAnCisJZ2l0IG5vdGVzIGFkZCAtbSAidG9waWMgbm90ZSIgdG9waWMgJiYKKwlnaXQgbm90ZXMgYWRkIC1tICJ1bm1vZGlmaWVkIG5vdGUiIHVubW9kaWZpZWQgJiYKKwl0ZXN0X3doZW5fZmluaXNoZWQgZ2l0IG5vdGVzIHJlbW92ZSB0b3BpYyB1bm1vZGlmaWVkICYmCisJZ2l0IGZvcm1hdC1wYXRjaCAtLW5vdGVzIC0tY292ZXItbGV0dGVyIC0tcmFuZ2UtZGlmZj0kcHJldiBcCisJCW1hc3Rlci4udW5tb2RpZmllZCA+YWN0dWFsICYmCisJdGVzdF93aGVuX2ZpbmlzaGVkICJybSAwMDA/LSoiICYmCisJdGVzdF9saW5lX2NvdW50ID0gNSBhY3R1YWwgJiYKKwl0ZXN0X2kxOG5ncmVwICJeUmFuZ2UtZGlmZjokIiAwMDAwLSogJiYKKwlncmVwICI9IDE6IC4qIHMvNS9BIiAwMDAwLSogJiYKKwlncmVwICI9IDI6IC4qIHMvNC9BIiAwMDAwLSogJiYKKwlncmVwICI9IDM6IC4qIHMvMTEvQiIgMDAwMC0qICYmCisJZ3JlcCAiISA0OiAuKiBzLzEyL0IiIDAwMDAtKiAmJgorCXNlZCBzL1ovXCAvZyA+ZXhwZWN0IDw8LUVPRiAmJgorCSAgICBAQCBDb21taXQgbWVzc2FnZQorCSAgICBaCisJICAgIFoKKwkgICAgWiAjIyBOb3RlcyAjIworCSAgICAtICAgIHRvcGljIG5vdGUKKwkgICAgKyAgICB1bm1vZGlmaWVkIG5vdGUKKwkgICAgWgorCSAgICBaICMjIGZpbGUgIyMKKwkgICAgWkBAIGZpbGU6IEEKKwlFT0YKKwlzZWQgIi9AQCBDb21taXQgbWVzc2FnZS8sL0BAIGZpbGU6IEEvIWQiIDAwMDAtKiA+YWN0dWFsICYmCisJdGVzdF9jbXAgZXhwZWN0IGFjdHVhbAorJworCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdmb3JtYXQtcGF0Y2ggLS1yYW5nZS1kaWZmIHdpdGggLS1ub3RlcycgJworCWdpdCBub3RlcyBhZGQgLW0gInRvcGljIG5vdGUiIHRvcGljICYmCisJZ2l0IG5vdGVzIGFkZCAtbSAidW5tb2RpZmllZCBub3RlIiB1bm1vZGlmaWVkICYmCisJdGVzdF93aGVuX2ZpbmlzaGVkIGdpdCBub3RlcyByZW1vdmUgdG9waWMgdW5tb2RpZmllZCAmJgorCXRlc3RfY29uZmlnIGZvcm1hdC5ub3RlcyB0cnVlICYmCisJZ2l0IGZvcm1hdC1wYXRjaCAtLWNvdmVyLWxldHRlciAtLXJhbmdlLWRpZmY9JHByZXYgXAorCQltYXN0ZXIuLnVubW9kaWZpZWQgPmFjdHVhbCAmJgorCXRlc3Rfd2hlbl9maW5pc2hlZCAicm0gMDAwPy0qIiAmJgorCXRlc3RfbGluZV9jb3VudCA9IDUgYWN0dWFsICYmCisJdGVzdF9pMThuZ3JlcCAiXlJhbmdlLWRpZmY6JCIgMDAwMC0qICYmCisJZ3JlcCAiPSAxOiAuKiBzLzUvQSIgMDAwMC0qICYmCisJZ3JlcCAiPSAyOiAuKiBzLzQvQSIgMDAwMC0qICYmCisJZ3JlcCAiPSAzOiAuKiBzLzExL0IiIDAwMDAtKiAmJgorCWdyZXAgIiEgNDogLiogcy8xMi9CIiAwMDAwLSogJiYKKwlzZWQgcy9aL1wgL2cgPmV4cGVjdCA8PC1FT0YgJiYKKwkgICAgQEAgQ29tbWl0IG1lc3NhZ2UKKwkgICAgWgorCSAgICBaCisJICAgIFogIyMgTm90ZXMgIyMKKwkgICAgLSAgICB0b3BpYyBub3RlCisJICAgICsgICAgdW5tb2RpZmllZCBub3RlCisJICAgIFoKKwkgICAgWiAjIyBmaWxlICMjCisJICAgIFpAQCBmaWxlOiBBCisJRU9GCisJc2VkICIvQEAgQ29tbWl0IG1lc3NhZ2UvLC9AQCBmaWxlOiBBLyFkIiAwMDAwLSogPmFjdHVhbCAmJgorCXRlc3RfY21wIGV4cGVjdCBhY3R1YWwKKycKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAnZm9ybWF0LXBhdGNoIC0tcmFuZ2UtZGlmZiB3aXRoIG11bHRpcGxlIG5vdGVzJyAnCisJZ2l0IG5vdGVzIC0tcmVmPW5vdGUxIGFkZCAtbSAidG9waWMgbm90ZTEiIHRvcGljICYmCisJZ2l0IG5vdGVzIC0tcmVmPW5vdGUxIGFkZCAtbSAidW5tb2RpZmllZCBub3RlMSIgdW5tb2RpZmllZCAmJgorCXRlc3Rfd2hlbl9maW5pc2hlZCBnaXQgbm90ZXMgLS1yZWY9bm90ZTEgcmVtb3ZlIHRvcGljIHVubW9kaWZpZWQgJiYKKwlnaXQgbm90ZXMgLS1yZWY9bm90ZTIgYWRkIC1tICJ0b3BpYyBub3RlMiIgdG9waWMgJiYKKwlnaXQgbm90ZXMgLS1yZWY9bm90ZTIgYWRkIC1tICJ1bm1vZGlmaWVkIG5vdGUyIiB1bm1vZGlmaWVkICYmCisJdGVzdF93aGVuX2ZpbmlzaGVkIGdpdCBub3RlcyAtLXJlZj1ub3RlMiByZW1vdmUgdG9waWMgdW5tb2RpZmllZCAmJgorCWdpdCBmb3JtYXQtcGF0Y2ggLS1ub3Rlcz1ub3RlMSAtLW5vdGVzPW5vdGUyIC0tY292ZXItbGV0dGVyIC0tcmFuZ2UtZGlmZj0kcHJldiBcCisJCW1hc3Rlci4udW5tb2RpZmllZCA+YWN0dWFsICYmCisJdGVzdF93aGVuX2ZpbmlzaGVkICJybSAwMDA/LSoiICYmCisJdGVzdF9saW5lX2NvdW50ID0gNSBhY3R1YWwgJiYKKwl0ZXN0X2kxOG5ncmVwICJeUmFuZ2UtZGlmZjokIiAwMDAwLSogJiYKKwlncmVwICI9IDE6IC4qIHMvNS9BIiAwMDAwLSogJiYKKwlncmVwICI9IDI6IC4qIHMvNC9BIiAwMDAwLSogJiYKKwlncmVwICI9IDM6IC4qIHMvMTEvQiIgMDAwMC0qICYmCisJZ3JlcCAiISA0OiAuKiBzLzEyL0IiIDAwMDAtKiAmJgorCXNlZCBzL1ovXCAvZyA+ZXhwZWN0IDw8LUVPRiAmJgorCSAgICBAQCBDb21taXQgbWVzc2FnZQorCSAgICBaCisJICAgIFoKKwkgICAgWiAjIyBOb3RlcyAobm90ZTEpICMjCisJICAgIC0gICAgdG9waWMgbm90ZTEKKwkgICAgKyAgICB1bm1vZGlmaWVkIG5vdGUxCisJICAgIFoKKwkgICAgWgorCSAgICBaICMjIE5vdGVzIChub3RlMikgIyMKKwkgICAgLSAgICB0b3BpYyBub3RlMgorCSAgICArICAgIHVubW9kaWZpZWQgbm90ZTIKKwkgICAgWgorCSAgICBaICMjIGZpbGUgIyMKKwkgICAgWkBAIGZpbGU6IEEKKwlFT0YKKwlzZWQgIi9AQCBDb21taXQgbWVzc2FnZS8sL0BAIGZpbGU6IEEvIWQiIDAwMDAtKiA+YWN0dWFsICYmCisJdGVzdF9jbXAgZXhwZWN0IGFjdHVhbAorJworCiB0ZXN0X2RvbmUKZGlmZiAtLWdpdCBhL3QvdDMyMDYvaGlzdG9yeS5leHBvcnQgYi90L3QzMjA2L2hpc3RvcnkuZXhwb3J0CmluZGV4IDdiYjM4MTQuLjRjODA4ZTUgMTAwNjQ0Ci0tLSBhL3QvdDMyMDYvaGlzdG9yeS5leHBvcnQKKysrIGIvdC90MzIwNi9oaXN0b3J5LmV4cG9ydApAQCAtNTUsNyArNTUsNyBAQAogMTkKIDIwCiAKLWNvbW1pdCByZWZzL2hlYWRzL3RvcGljCitjb21taXQgcmVmcy9oZWFkcy9tb2RlLW9ubHktY2hhbmdlCiBtYXJrIDo0CiBhdXRob3IgVGhvbWFzIFJhc3QgPHRyYXN0QGluZi5ldGh6LmNoPiAxMzc0NDg1MDE0ICswMjAwCiBjb21taXR0ZXIgVGhvbWFzIFJhc3QgPHRyYXN0QGluZi5ldGh6LmNoPiAxMzc0NDg1MDE0ICswMjAwCkBAIC02NzgsMyArNjc4LDMyIEBACiBmcm9tIDo1NQogTSAxMDA2NDQgOjkgcmVuYW1lZC1maWxlCiAKK2NvbW1pdCByZWZzL2hlYWRzL21vZGUtb25seS1jaGFuZ2UKK21hcmsgOjU3CithdXRob3IgVGhvbWFzIFJhc3QgPHRyYXN0QGluZi5ldGh6LmNoPiAxMzc0NDg1MDI0ICswMjAwCitjb21taXR0ZXIgVGhvbWFzIEd1bW1lcmVyIDx0Lmd1bW1lcmVyQGdtYWlsLmNvbT4gMTU3MDQ3Mzc2NyArMDEwMAorZGF0YSAyNAorcy80L0EvICsgYWRkIG90aGVyLWZpbGUKK2Zyb20gOjQKK00gMTAwNjQ0IDo1IGZpbGUKK00gMTAwNjQ0IDo0OSBvdGhlci1maWxlCisKK2NvbW1pdCByZWZzL2hlYWRzL21vZGUtb25seS1jaGFuZ2UKK21hcmsgOjU4CithdXRob3IgVGhvbWFzIFJhc3QgPHRyYXN0QGluZi5ldGh6LmNoPiAxMzc0NDg1MDM2ICswMjAwCitjb21taXR0ZXIgVGhvbWFzIEd1bW1lcmVyIDx0Lmd1bW1lcmVyQGdtYWlsLmNvbT4gMTU3MDQ3Mzc2OCArMDEwMAorZGF0YSAzMworcy8xMS9CLyArIG1vZGUgY2hhbmdlIG90aGVyLWZpbGUKK2Zyb20gOjU3CitNIDEwMDY0NCA6NyBmaWxlCitNIDEwMDc1NSA6NDkgb3RoZXItZmlsZQorCitjb21taXQgcmVmcy9oZWFkcy9tb2RlLW9ubHktY2hhbmdlCittYXJrIDo1OQorYXV0aG9yIFRob21hcyBSYXN0IDx0cmFzdEBpbmYuZXRoei5jaD4gMTM3NDQ4NTA0NCArMDIwMAorY29tbWl0dGVyIFRob21hcyBHdW1tZXJlciA8dC5ndW1tZXJlckBnbWFpbC5jb20+IDE1NzA0NzM3NjggKzAxMDAKK2RhdGEgOAorcy8xMi9CLworZnJvbSA6NTgKK00gMTAwNjQ0IDo5IGZpbGUKKwpkaWZmIC0tZ2l0IGEvdC90MzIxMC1wYWNrLXJlZnMuc2ggYi90L3QzMjEwLXBhY2stcmVmcy5zaAppbmRleCA5ZWE1ZmE0Li5mNDFiMmFmIDEwMDc1NQotLS0gYS90L3QzMjEwLXBhY2stcmVmcy5zaAorKysgYi90L3QzMjEwLXBhY2stcmVmcy5zaApAQCAtMjQwLDcgKzI0MCw3IEBACiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgU1lNTElOS1MgJ3BhY2sgc3ltbGlua2VkIHBhY2tlZC1yZWZzJyAnCiAJIyBGaXJzdCBtYWtlIHN1cmUgdGhhdCBzeW1saW5raW5nIHdvcmtzIHdoZW4gcmVhZGluZzoKLQlnaXQgdXBkYXRlLXJlZiByZWZzL2hlYWRzL2xvb3N5IHJlZnMvaGVhZHMvbWFzdGVyICYmCisJZ2l0IHVwZGF0ZS1yZWYgcmVmcy9oZWFkcy9sb3NzeSByZWZzL2hlYWRzL21hc3RlciAmJgogCWdpdCBmb3ItZWFjaC1yZWYgPmFsbC1yZWZzLWJlZm9yZSAmJgogCW12IC5naXQvcGFja2VkLXJlZnMgLmdpdC9teS1kZXZpYW50LXBhY2tlZC1yZWZzICYmCiAJbG4gLXMgbXktZGV2aWFudC1wYWNrZWQtcmVmcyAuZ2l0L3BhY2tlZC1yZWZzICYmCmRpZmYgLS1naXQgYS90L3QzMzAxLW5vdGVzLnNoIGIvdC90MzMwMS1ub3Rlcy5zaAppbmRleCA3MDRiYmM2Li5kNjZhNWY2IDEwMDc1NQotLS0gYS90L3QzMzAxLW5vdGVzLnNoCisrKyBiL3QvdDMzMDEtbm90ZXMuc2gKQEAgLTY2LDggKzY2LDkgQEAKICcKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnY3JlYXRlIHJlZmxvZyBlbnRyeScgJworCXJlZj0kKGdpdCByZXYtcGFyc2UgLS1zaG9ydCByZWZzL25vdGVzL2NvbW1pdHMpICYmCiAJY2F0IDw8LUVPRiA+ZXhwZWN0ICYmCi0JCWExZDhmYTYgcmVmcy9ub3Rlcy9jb21taXRzQHswfTogbm90ZXM6IE5vdGVzIGFkZGVkIGJ5ICdcJydnaXQgbm90ZXMgYWRkJ1wnJworCQkkcmVmIHJlZnMvbm90ZXMvY29tbWl0c0B7MH06IG5vdGVzOiBOb3RlcyBhZGRlZCBieSAnXCcnZ2l0IG5vdGVzIGFkZCdcJycKIAlFT0YKIAlnaXQgcmVmbG9nIHNob3cgcmVmcy9ub3Rlcy9jb21taXRzID5hY3R1YWwgJiYKIAl0ZXN0X2NtcCBleHBlY3QgYWN0dWFsCkBAIC0xMzQsOCArMTM1LDkgQEAKICcKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnc2hvdyBub3RlcycgJworCWNvbW1pdD0kKGdpdCByZXYtcGFyc2UgSEVBRCkgJiYKIAljYXQgPmV4cGVjdCA8PC1FT0YgJiYKLQkJY29tbWl0IDdhNGNhNmVlNTJhOTc0YTY2Y2JhYTc4ZTMzMjE0NTM1ZGZmMWQ2OTEKKwkJY29tbWl0ICRjb21taXQKIAkJQXV0aG9yOiBBIFUgVGhvciA8YXV0aG9yQGV4YW1wbGUuY29tPgogCQlEYXRlOiAgIFRodSBBcHIgNyAxNToxNDoxMyAyMDA1IC0wNzAwCiAKQEAgLTE1Miw4ICsxNTQsOSBAQAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnc2hvdyBtdWx0aS1saW5lIG5vdGVzJyAnCiAJdGVzdF9jb21taXQgM3JkICYmCiAJTVNHPSJiMyR7TEZ9YzNjM2MzYzMke0xGfWQzZDNkMyIgZ2l0IG5vdGVzIGFkZCAmJgorCWNvbW1pdD0kKGdpdCByZXYtcGFyc2UgSEVBRCkgJiYKIAljYXQgPmV4cGVjdC1tdWx0aWxpbmUgPDwtRU9GICYmCi0JCWNvbW1pdCBkMDdkNjJlNTIwOGYyMmViNTY5NWU3ZWI0NzY2N2RjOGI5ODYwMjkwCisJCWNvbW1pdCAkY29tbWl0CiAJCUF1dGhvcjogQSBVIFRob3IgPGF1dGhvckBleGFtcGxlLmNvbT4KIAkJRGF0ZTogICBUaHUgQXByIDcgMTU6MTU6MTMgMjAwNSAtMDcwMAogCkBAIC0xNzQsOCArMTc3LDkgQEAKIAl0ZXN0X2NvbW1pdCA0dGggJiYKIAllY2hvICJ4eXp6eSIgPm5vdGU1ICYmCiAJZ2l0IG5vdGVzIGFkZCAtRiBub3RlNSAmJgorCWNvbW1pdD0kKGdpdCByZXYtcGFyc2UgSEVBRCkgJiYKIAljYXQgPmV4cGVjdC1GIDw8LUVPRiAmJgotCQljb21taXQgMGY3YWEzZWM2MzI1YWViODhiOTEwNDUzYmIzZWIzN2M0OWQ3NWMxMQorCQljb21taXQgJGNvbW1pdAogCQlBdXRob3I6IEEgVSBUaG9yIDxhdXRob3JAZXhhbXBsZS5jb20+CiAJCURhdGU6ICAgVGh1IEFwciA3IDE1OjE2OjEzIDIwMDUgLTA3MDAKIApAQCAtMTk4LDEwICsyMDIsMTMgQEAKICcKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnZ2l0IGxvZyAtLXByZXR0eT1yYXcgZG9lcyBub3Qgc2hvdyBub3RlcycgJworCWNvbW1pdD0kKGdpdCByZXYtcGFyc2UgSEVBRCkgJiYKKwl0cmVlPSQoZ2l0IHJldi1wYXJzZSBIRUFEXnt0cmVlfSkgJiYKKwlwYXJlbnQ9JChnaXQgcmV2LXBhcnNlIEhFQUReKSAmJgogCWNhdCA+ZXhwZWN0IDw8LUVPRiAmJgotCQljb21taXQgMGY3YWEzZWM2MzI1YWViODhiOTEwNDUzYmIzZWIzN2M0OWQ3NWMxMQotCQl0cmVlIDA1YWM2NTI4OGM0YzRiM2I3MDlhMDIwYWU5NGIyZWNlMmYyMjAxYWUKLQkJcGFyZW50IGQwN2Q2MmU1MjA4ZjIyZWI1Njk1ZTdlYjQ3NjY3ZGM4Yjk4NjAyOTAKKwkJY29tbWl0ICRjb21taXQKKwkJdHJlZSAkdHJlZQorCQlwYXJlbnQgJHBhcmVudAogCQlhdXRob3IgQSBVIFRob3IgPGF1dGhvckBleGFtcGxlLmNvbT4gMTExMjkxMjE3MyAtMDcwMAogCQljb21taXR0ZXIgQyBPIE1pdHRlciA8Y29tbWl0dGVyQGV4YW1wbGUuY29tPiAxMTEyOTEyMTczIC0wNzAwCiAKQEAgLTI5MSw4ICsyOTgsOSBAQAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnc2hvdyAtbSBub3RlcycgJwogCXRlc3RfY29tbWl0IDV0aCAmJgogCWdpdCBub3RlcyBhZGQgLW0gc3BhbSAtbSAiZm9vJHtMRn1iYXIke0xGfWJheiIgJiYKKwljb21taXQ9JChnaXQgcmV2LXBhcnNlIEhFQUQpICYmCiAJY2F0ID5leHBlY3QtbSA8PC1FT0YgJiYKLQkJY29tbWl0IDdmOWFkODgzNmM3NzVhY2IxMzRjMGEwNTVmYzU1ZmI0Y2QxYmEzNjEKKwkJY29tbWl0ICRjb21taXQKIAkJQXV0aG9yOiBBIFUgVGhvciA8YXV0aG9yQGV4YW1wbGUuY29tPgogCQlEYXRlOiAgIFRodSBBcHIgNyAxNToxNzoxMyAyMDA1IC0wNzAwCiAKQEAgLTMxMyw4ICszMjEsOSBAQAogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdyZW1vdmUgbm90ZSB3aXRoIGFkZCAtZiAtRiAvZGV2L251bGwnICcKIAlnaXQgbm90ZXMgYWRkIC1mIC1GIC9kZXYvbnVsbCAmJgorCWNvbW1pdD0kKGdpdCByZXYtcGFyc2UgSEVBRCkgJiYKIAljYXQgPmV4cGVjdC1ybS1GIDw8LUVPRiAmJgotCQljb21taXQgN2Y5YWQ4ODM2Yzc3NWFjYjEzNGMwYTA1NWZjNTVmYjRjZDFiYTM2MQorCQljb21taXQgJGNvbW1pdAogCQlBdXRob3I6IEEgVSBUaG9yIDxhdXRob3JAZXhhbXBsZS5jb20+CiAJCURhdGU6ICAgVGh1IEFwciA3IDE1OjE3OjEzIDIwMDUgLTA3MDAKIApAQCAtMzU2LDE0ICszNjUsMTYgQEAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3JlbW92ZSBub3RlIHdpdGggImdpdCBub3RlcyByZW1vdmUiJyAnCiAJZ2l0IG5vdGVzIHJlbW92ZSBIRUFEXiAmJgogCWdpdCBub3RlcyByZW1vdmUgJiYKKwljb21taXQ9JChnaXQgcmV2LXBhcnNlIEhFQUQpICYmCisJcGFyZW50PSQoZ2l0IHJldi1wYXJzZSBIRUFEXikgJiYKIAljYXQgPmV4cGVjdC1ybS1yZW1vdmUgPDwtRU9GICYmCi0JCWNvbW1pdCA3ZjlhZDg4MzZjNzc1YWNiMTM0YzBhMDU1ZmM1NWZiNGNkMWJhMzYxCisJCWNvbW1pdCAkY29tbWl0CiAJCUF1dGhvcjogQSBVIFRob3IgPGF1dGhvckBleGFtcGxlLmNvbT4KIAkJRGF0ZTogICBUaHUgQXByIDcgMTU6MTc6MTMgMjAwNSAtMDcwMAogCiAJCSR7aW5kZW50fTV0aAogCi0JCWNvbW1pdCAwZjdhYTNlYzYzMjVhZWI4OGI5MTA0NTNiYjNlYjM3YzQ5ZDc1YzExCisJCWNvbW1pdCAkcGFyZW50CiAJCUF1dGhvcjogQSBVIFRob3IgPGF1dGhvckBleGFtcGxlLmNvbT4KIAkJRGF0ZTogICBUaHUgQXByIDcgMTU6MTY6MTMgMjAwNSAtMDcwMAogCkBAIC00NTksOSArNDcwLDExIEBACiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2xpc3Qgbm90ZXMgd2l0aCAiZ2l0IG5vdGVzIGxpc3QiJyAnCi0JY2F0ID5leHBlY3QgPDwtRU9GICYmCi0JCWM5YzZhZjdmNzhiYzQ3NDkwZGJmM2U4MjJjZjJmM2MyNGQ0YjkwNjEgN2E0Y2E2ZWU1MmE5NzRhNjZjYmFhNzhlMzMyMTQ1MzVkZmYxZDY5MQotCQljMThkYzAyNGUxNGYwOGQxOGQxNGVlYTBkNzQ3ZmY2OTJkNjZkNmEzIGQwN2Q2MmU1MjA4ZjIyZWI1Njk1ZTdlYjQ3NjY3ZGM4Yjk4NjAyOTAKKwljb21taXRfMj0kKGdpdCByZXYtcGFyc2UgMm5kKSAmJgorCWNvbW1pdF8zPSQoZ2l0IHJldi1wYXJzZSAzcmQpICYmCisJc29ydCAtdCIgIiAtazIgPmV4cGVjdCA8PC1FT0YgJiYKKwkJJChnaXQgcmV2LXBhcnNlIHJlZnMvbm90ZXMvY29tbWl0czokY29tbWl0XzIpICRjb21taXRfMgorCQkkKGdpdCByZXYtcGFyc2UgcmVmcy9ub3Rlcy9jb21taXRzOiRjb21taXRfMykgJGNvbW1pdF8zCiAJRU9GCiAJZ2l0IG5vdGVzIGxpc3QgPmFjdHVhbCAmJgogCXRlc3RfY21wIGV4cGVjdCBhY3R1YWwKQEAgLTQ3NCw3ICs0ODcsNyBAQAogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdsaXN0IHNwZWNpZmljIG5vdGUgd2l0aCAiZ2l0IG5vdGVzIGxpc3QgPG9iamVjdD4iJyAnCiAJY2F0ID5leHBlY3QgPDwtRU9GICYmCi0JCWMxOGRjMDI0ZTE0ZjA4ZDE4ZDE0ZWVhMGQ3NDdmZjY5MmQ2NmQ2YTMKKwkJJChnaXQgcmV2LXBhcnNlIHJlZnMvbm90ZXMvY29tbWl0czokY29tbWl0XzMpCiAJRU9GCiAJZ2l0IG5vdGVzIGxpc3QgSEVBRF5eID5hY3R1YWwgJiYKIAl0ZXN0X2NtcCBleHBlY3QgYWN0dWFsCkBAIC00OTgsMTAgKzUxMSwxMSBAQAogJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICciZ2l0IG5vdGVzIGxpc3QiIGRvZXMgbm90IGV4cGFuZCB0byAiZ2l0IG5vdGVzIGxpc3QgSEVBRCInICcKLQljYXQgPmV4cGVjdF9saXN0IDw8LUVPRiAmJgotCQljOWM2YWY3Zjc4YmM0NzQ5MGRiZjNlODIyY2YyZjNjMjRkNGI5MDYxIDdhNGNhNmVlNTJhOTc0YTY2Y2JhYTc4ZTMzMjE0NTM1ZGZmMWQ2OTEKLQkJNGI2YWQyMjM1N2NjOGExMjk2NzIwNTc0YjhkMmZiYzIyZmFiMDY3MSA3ZjlhZDg4MzZjNzc1YWNiMTM0YzBhMDU1ZmM1NWZiNGNkMWJhMzYxCi0JCWMxOGRjMDI0ZTE0ZjA4ZDE4ZDE0ZWVhMGQ3NDdmZjY5MmQ2NmQ2YTMgZDA3ZDYyZTUyMDhmMjJlYjU2OTVlN2ViNDc2NjdkYzhiOTg2MDI5MAorCWNvbW1pdF81PSQoZ2l0IHJldi1wYXJzZSA1dGgpICYmCisJc29ydCAtdCIgIiAtazIgPmV4cGVjdF9saXN0IDw8LUVPRiAmJgorCQkkKGdpdCByZXYtcGFyc2UgcmVmcy9ub3Rlcy9jb21taXRzOiRjb21taXRfMikgJGNvbW1pdF8yCisJCSQoZ2l0IHJldi1wYXJzZSByZWZzL25vdGVzL2NvbW1pdHM6JGNvbW1pdF8zKSAkY29tbWl0XzMKKwkJJChnaXQgcmV2LXBhcnNlIHJlZnMvbm90ZXMvY29tbWl0czokY29tbWl0XzUpICRjb21taXRfNQogCUVPRgogCWdpdCBub3RlcyBsaXN0ID5hY3R1YWwgJiYKIAl0ZXN0X2NtcCBleHBlY3RfbGlzdCBhY3R1YWwKQEAgLTUzMSw4ICs1NDUsOSBAQAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnY3JlYXRlIG90aGVyIG5vdGUgb24gYSBkaWZmZXJlbnQgbm90ZXMgcmVmIChzZXR1cCknICcKIAl0ZXN0X2NvbW1pdCA2dGggJiYKIAlHSVRfTk9URVNfUkVGPSJyZWZzL25vdGVzL290aGVyIiBnaXQgbm90ZXMgYWRkIC1tICJvdGhlciBub3RlIiAmJgorCWNvbW1pdD0kKGdpdCByZXYtcGFyc2UgSEVBRCkgJiYKIAljYXQgPmV4cGVjdC1ub3Qtb3RoZXIgPDwtRU9GICYmCi0JCWNvbW1pdCAyYzEyNTMzMTExOGNhYmEwZmY4MjM4YjdmNDk1OGFjNmU5M2ZlMzljCisJCWNvbW1pdCAkY29tbWl0CiAJCUF1dGhvcjogQSBVIFRob3IgPGF1dGhvckBleGFtcGxlLmNvbT4KIAkJRGF0ZTogICBUaHUgQXByIDcgMTU6MTg6MTMgMjAwNSAtMDcwMAogCkBAIC01NjksOCArNTg0LDEwIEBACiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ1Nob3cgYWxsIG5vdGVzIHdoZW4gbm90ZXMuZGlzcGxheVJlZj1yZWZzL25vdGVzLyonICcKKwljb21taXQ9JChnaXQgcmV2LXBhcnNlIEhFQUQpICYmCisJcGFyZW50PSQoZ2l0IHJldi1wYXJzZSBIRUFEXikgJiYKIAljYXQgPmV4cGVjdC1ib3RoIDw8LUVPRiAmJgotCQljb21taXQgMmMxMjUzMzExMThjYWJhMGZmODIzOGI3ZjQ5NThhYzZlOTNmZTM5YworCQljb21taXQgJGNvbW1pdAogCQlBdXRob3I6IEEgVSBUaG9yIDxhdXRob3JAZXhhbXBsZS5jb20+CiAJCURhdGU6ICAgVGh1IEFwciA3IDE1OjE4OjEzIDIwMDUgLTA3MDAKIApAQCAtNTgyLDcgKzU5OSw3IEBACiAJCU5vdGVzIChvdGhlcik6CiAJCSR7aW5kZW50fW90aGVyIG5vdGUKIAotCQljb21taXQgN2Y5YWQ4ODM2Yzc3NWFjYjEzNGMwYTA1NWZjNTVmYjRjZDFiYTM2MQorCQljb21taXQgJHBhcmVudAogCQlBdXRob3I6IEEgVSBUaG9yIDxhdXRob3JAZXhhbXBsZS5jb20+CiAJCURhdGU6ICAgVGh1IEFwciA3IDE1OjE3OjEzIDIwMDUgLTA3MDAKIApAQCAtNjE2LDggKzYzMyw5IEBACiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ25vdGVzLmRpc3BsYXlSZWYgcmVzcGVjdHMgb3JkZXInICcKKwljb21taXQ9JChnaXQgcmV2LXBhcnNlIEhFQUQpICYmCiAJY2F0ID5leHBlY3QtYm90aC1yZXZlcnNlZCA8PC1FT0YgJiYKLQkJY29tbWl0IDJjMTI1MzMxMTE4Y2FiYTBmZjgyMzhiN2Y0OTU4YWM2ZTkzZmUzOWMKKwkJY29tbWl0ICRjb21taXQKIAkJQXV0aG9yOiBBIFUgVGhvciA8YXV0aG9yQGV4YW1wbGUuY29tPgogCQlEYXRlOiAgIFRodSBBcHIgNyAxNToxODoxMyAyMDA1IC0wNzAwCiAKQEAgLTY0MiwxNCArNjYwLDE2IEBACiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ0dJVF9OT1RFU19ESVNQTEFZX1JFRiBvdmVycmlkZXMgY29uZmlnJyAnCisJY29tbWl0PSQoZ2l0IHJldi1wYXJzZSBIRUFEKSAmJgorCXBhcmVudD0kKGdpdCByZXYtcGFyc2UgSEVBRF4pICYmCiAJY2F0ID5leHBlY3Qtbm9uZSA8PC1FT0YgJiYKLQkJY29tbWl0IDJjMTI1MzMxMTE4Y2FiYTBmZjgyMzhiN2Y0OTU4YWM2ZTkzZmUzOWMKKwkJY29tbWl0ICRjb21taXQKIAkJQXV0aG9yOiBBIFUgVGhvciA8YXV0aG9yQGV4YW1wbGUuY29tPgogCQlEYXRlOiAgIFRodSBBcHIgNyAxNToxODoxMyAyMDA1IC0wNzAwCiAKIAkJJHtpbmRlbnR9NnRoCiAKLQkJY29tbWl0IDdmOWFkODgzNmM3NzVhY2IxMzRjMGEwNTVmYzU1ZmI0Y2QxYmEzNjEKKwkJY29tbWl0ICRwYXJlbnQKIAkJQXV0aG9yOiBBIFUgVGhvciA8YXV0aG9yQGV4YW1wbGUuY29tPgogCQlEYXRlOiAgIFRodSBBcHIgNyAxNToxNzoxMyAyMDA1IC0wNzAwCiAKQEAgLTY2Niw4ICs2ODYsOSBAQAogJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICctLW5vLXN0YW5kYXJkLW5vdGVzJyAnCisJY29tbWl0PSQoZ2l0IHJldi1wYXJzZSBIRUFEKSAmJgogCWNhdCA+ZXhwZWN0LWNvbW1pdHMgPDwtRU9GICYmCi0JCWNvbW1pdCAyYzEyNTMzMTExOGNhYmEwZmY4MjM4YjdmNDk1OGFjNmU5M2ZlMzljCisJCWNvbW1pdCAkY29tbWl0CiAJCUF1dGhvcjogQSBVIFRob3IgPGF1dGhvckBleGFtcGxlLmNvbT4KIAkJRGF0ZTogICBUaHUgQXByIDcgMTU6MTg6MTMgMjAwNSAtMDcwMAogCkBAIC03MTIsOCArNzMzLDEwIEBACiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2NyZWF0ZSBub3RlIGZyb20gb3RoZXIgbm90ZSB3aXRoICJnaXQgbm90ZXMgYWRkIC1DIicgJworCXRlc3RfY29tbWl0IDd0aCAmJgorCWNvbW1pdD0kKGdpdCByZXYtcGFyc2UgSEVBRCkgJiYKIAljYXQgPmV4cGVjdCA8PC1FT0YgJiYKLQkJY29tbWl0IGZiMDFlMGNhOGMzM2I2Y2MwYzY0NTFkZGU3NDdmOTdkZjU2N2NiNWMKKwkJY29tbWl0ICRjb21taXQKIAkJQXV0aG9yOiBBIFUgVGhvciA8YXV0aG9yQGV4YW1wbGUuY29tPgogCQlEYXRlOiAgIFRodSBBcHIgNyAxNToxOToxMyAyMDA1IC0wNzAwCiAKQEAgLTcyMiw3ICs3NDUsNiBAQAogCQlOb3RlczoKIAkJJHtpbmRlbnR9b3JkZXIgdGVzdAogCUVPRgotCXRlc3RfY29tbWl0IDd0aCAmJgogCWdpdCBub3RlcyBhZGQgLUMgJChnaXQgbm90ZXMgbGlzdCBIRUFEXikgJiYKIAlnaXQgbG9nIC0xID5hY3R1YWwgJiYKIAl0ZXN0X2NtcCBleHBlY3QgYWN0dWFsICYmCkBAIC03NDQsOCArNzY2LDkgQEAKICcKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnY3JlYXRlIG5vdGUgZnJvbSBibG9iIHdpdGggImdpdCBub3RlcyBhZGQgLUMiIHJldXNlcyBibG9iIGlkJyAnCisJY29tbWl0PSQoZ2l0IHJldi1wYXJzZSBIRUFEKSAmJgogCWNhdCA+ZXhwZWN0IDw8LUVPRiAmJgotCQljb21taXQgOWE0YzMxYzdmNzIyYjVkNTE3ZTkyYzY0ZTkzMmRkNzUxZTE0MTNiZgorCQljb21taXQgJGNvbW1pdAogCQlBdXRob3I6IEEgVSBUaG9yIDxhdXRob3JAZXhhbXBsZS5jb20+CiAJCURhdGU6ICAgVGh1IEFwciA3IDE1OjIwOjEzIDIwMDUgLTA3MDAKIApAQCAtNzYyLDggKzc4NSwxMCBAQAogJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdjcmVhdGUgbm90ZSBmcm9tIG90aGVyIG5vdGUgd2l0aCAiZ2l0IG5vdGVzIGFkZCAtYyInICcKKwl0ZXN0X2NvbW1pdCA5dGggJiYKKwljb21taXQ9JChnaXQgcmV2LXBhcnNlIEhFQUQpICYmCiAJY2F0ID5leHBlY3QgPDwtRU9GICYmCi0JCWNvbW1pdCAyZTBkYjRiYzY0OWUxNzRkNjY3YTFjZGUxOWU3MjVjZjg5N2E1YmQyCisJCWNvbW1pdCAkY29tbWl0CiAJCUF1dGhvcjogQSBVIFRob3IgPGF1dGhvckBleGFtcGxlLmNvbT4KIAkJRGF0ZTogICBUaHUgQXByIDcgMTU6MjE6MTMgMjAwNSAtMDcwMAogCkBAIC03NzIsNyArNzk3LDYgQEAKIAkJTm90ZXM6CiAJCSR7aW5kZW50fXlldCBhbm90aGVyIG5vdGUKIAlFT0YKLQl0ZXN0X2NvbW1pdCA5dGggJiYKIAlNU0c9InlldCBhbm90aGVyIG5vdGUiIGdpdCBub3RlcyBhZGQgLWMgJChnaXQgbm90ZXMgbGlzdCBIRUFEXl4pICYmCiAJZ2l0IGxvZyAtMSA+YWN0dWFsICYmCiAJdGVzdF9jbXAgZXhwZWN0IGFjdHVhbApAQCAtNzg1LDggKzgwOSw5IEBACiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2FwcGVuZCB0byBub3RlIGZyb20gb3RoZXIgbm90ZSB3aXRoICJnaXQgbm90ZXMgYXBwZW5kIC1DIicgJworCWNvbW1pdD0kKGdpdCByZXYtcGFyc2UgSEVBRF4pICYmCiAJY2F0ID5leHBlY3QgPDwtRU9GICYmCi0JCWNvbW1pdCAyZTBkYjRiYzY0OWUxNzRkNjY3YTFjZGUxOWU3MjVjZjg5N2E1YmQyCisJCWNvbW1pdCAkY29tbWl0CiAJCUF1dGhvcjogQSBVIFRob3IgPGF1dGhvckBleGFtcGxlLmNvbT4KIAkJRGF0ZTogICBUaHUgQXByIDcgMTU6MjE6MTMgMjAwNSAtMDcwMAogCkBAIC04MDMsOCArODI4LDkgQEAKICcKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnY3JlYXRlIG5vdGUgZnJvbSBvdGhlciBub3RlIHdpdGggImdpdCBub3RlcyBhcHBlbmQgLWMiJyAnCisJY29tbWl0PSQoZ2l0IHJldi1wYXJzZSBIRUFEKSAmJgogCWNhdCA+ZXhwZWN0IDw8LUVPRiAmJgotCQljb21taXQgN2MzYjg3YWIzNjhmODFlMTFiMWVhODdiMmFiOTlhNzFjY2QyNTQwNgorCQljb21taXQgJGNvbW1pdAogCQlBdXRob3I6IEEgVSBUaG9yIDxhdXRob3JAZXhhbXBsZS5jb20+CiAJCURhdGU6ICAgVGh1IEFwciA3IDE1OjIyOjEzIDIwMDUgLTA3MDAKIApAQCAtODE5LDggKzg0NSw5IEBACiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2FwcGVuZCB0byBub3RlIGZyb20gb3RoZXIgbm90ZSB3aXRoICJnaXQgbm90ZXMgYXBwZW5kIC1jIicgJworCWNvbW1pdD0kKGdpdCByZXYtcGFyc2UgSEVBRCkgJiYKIAljYXQgPmV4cGVjdCA8PC1FT0YgJiYKLQkJY29tbWl0IDdjM2I4N2FiMzY4ZjgxZTExYjFlYTg3YjJhYjk5YTcxY2NkMjU0MDYKKwkJY29tbWl0ICRjb21taXQKIAkJQXV0aG9yOiBBIFUgVGhvciA8YXV0aG9yQGV4YW1wbGUuY29tPgogCQlEYXRlOiAgIFRodSBBcHIgNyAxNToyMjoxMyAyMDA1IC0wNzAwCiAKQEAgLTgzNyw4ICs4NjQsMjggQEAKICcKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnY29weSBub3RlIHdpdGggImdpdCBub3RlcyBjb3B5IicgJworCWNvbW1pdD0kKGdpdCByZXYtcGFyc2UgNHRoKSAmJgogCWNhdCA+ZXhwZWN0IDw8LUVPRiAmJgotCQljb21taXQgYTQ0NmZmZjg3NzdlZmRjNmViOGY0YjdjOGE1ZmY2OTk0ODRkZjBkNQorCQljb21taXQgJGNvbW1pdAorCQlBdXRob3I6IEEgVSBUaG9yIDxhdXRob3JAZXhhbXBsZS5jb20+CisJCURhdGU6ICAgVGh1IEFwciA3IDE1OjE2OjEzIDIwMDUgLTA3MDAKKworCQkke2luZGVudH00dGgKKworCQlOb3RlczoKKwkJJHtpbmRlbnR9VGhpcyBpcyBhIGJsb2Igb2JqZWN0CisJRU9GCisJZ2l0IG5vdGVzIGNvcHkgOHRoIDR0aCAmJgorCWdpdCBsb2cgM3JkLi40dGggPmFjdHVhbCAmJgorCXRlc3RfY21wIGV4cGVjdCBhY3R1YWwgJiYKKwl0ZXN0ICIkKGdpdCBub3RlIGxpc3QgNHRoKSIgPSAiJChnaXQgbm90ZSBsaXN0IDh0aCkiCisnCisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2NvcHkgbm90ZSB3aXRoICJnaXQgbm90ZXMgY29weSIgd2l0aCBkZWZhdWx0JyAnCisJdGVzdF9jb21taXQgMTF0aCAmJgorCWNvbW1pdD0kKGdpdCByZXYtcGFyc2UgSEVBRCkgJiYKKwljYXQgPmV4cGVjdCA8PC1FT0YgJiYKKwkJY29tbWl0ICRjb21taXQKIAkJQXV0aG9yOiBBIFUgVGhvciA8YXV0aG9yQGV4YW1wbGUuY29tPgogCQlEYXRlOiAgIFRodSBBcHIgNyAxNToyMzoxMyAyMDA1IC0wNzAwCiAKQEAgLTg0OSw4ICs4OTYsNyBAQAogCQkke2luZGVudH0KIAkJJHtpbmRlbnR9eWV0IGFub3RoZXIgbm90ZQogCUVPRgotCXRlc3RfY29tbWl0IDExdGggJiYKLQlnaXQgbm90ZXMgY29weSBIRUFEXiBIRUFEICYmCisJZ2l0IG5vdGVzIGNvcHkgSEVBRF4gJiYKIAlnaXQgbG9nIC0xID5hY3R1YWwgJiYKIAl0ZXN0X2NtcCBleHBlY3QgYWN0dWFsICYmCiAJdGVzdCAiJChnaXQgbm90ZXMgbGlzdCBIRUFEKSIgPSAiJChnaXQgbm90ZXMgbGlzdCBIRUFEXikiCkBAIC04NjQsOCArOTEwLDI3IEBACiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2FsbG93IG92ZXJ3cml0ZSB3aXRoICJnaXQgbm90ZXMgY29weSAtZiInICcKKwljb21taXQ9JChnaXQgcmV2LXBhcnNlIEhFQUQpICYmCiAJY2F0ID5leHBlY3QgPDwtRU9GICYmCi0JCWNvbW1pdCBhNDQ2ZmZmODc3N2VmZGM2ZWI4ZjRiN2M4YTVmZjY5OTQ4NGRmMGQ1CisJCWNvbW1pdCAkY29tbWl0CisJCUF1dGhvcjogQSBVIFRob3IgPGF1dGhvckBleGFtcGxlLmNvbT4KKwkJRGF0ZTogICBUaHUgQXByIDcgMTU6MjM6MTMgMjAwNSAtMDcwMAorCisJCSR7aW5kZW50fTExdGgKKworCQlOb3RlczoKKwkJJHtpbmRlbnR9VGhpcyBpcyBhIGJsb2Igb2JqZWN0CisJRU9GCisJZ2l0IG5vdGVzIGNvcHkgLWYgSEVBRH4zIEhFQUQgJiYKKwlnaXQgbG9nIC0xID5hY3R1YWwgJiYKKwl0ZXN0X2NtcCBleHBlY3QgYWN0dWFsICYmCisJdGVzdCAiJChnaXQgbm90ZXMgbGlzdCBIRUFEKSIgPSAiJChnaXQgbm90ZXMgbGlzdCBIRUFEfjMpIgorJworCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdhbGxvdyBvdmVyd3JpdGUgd2l0aCAiZ2l0IG5vdGVzIGNvcHkgLWYiIHdpdGggZGVmYXVsdCcgJworCWNvbW1pdD0kKGdpdCByZXYtcGFyc2UgSEVBRCkgJiYKKwljYXQgPmV4cGVjdCA8PC1FT0YgJiYKKwkJY29tbWl0ICRjb21taXQKIAkJQXV0aG9yOiBBIFUgVGhvciA8YXV0aG9yQGV4YW1wbGUuY29tPgogCQlEYXRlOiAgIFRodSBBcHIgNyAxNToyMzoxMyAyMDA1IC0wNzAwCiAKQEAgLTg3Niw3ICs5NDEsNyBAQAogCQkke2luZGVudH0KIAkJJHtpbmRlbnR9eWV0IGFub3RoZXIgbm90ZQogCUVPRgotCWdpdCBub3RlcyBjb3B5IC1mIEhFQUR+MiBIRUFEICYmCisJZ2l0IG5vdGVzIGNvcHkgLWYgSEVBRH4yICYmCiAJZ2l0IGxvZyAtMSA+YWN0dWFsICYmCiAJdGVzdF9jbXAgZXhwZWN0IGFjdHVhbCAmJgogCXRlc3QgIiQoZ2l0IG5vdGVzIGxpc3QgSEVBRCkiID0gIiQoZ2l0IG5vdGVzIGxpc3QgSEVBRH4yKSIKQEAgLTg4OSw4ICs5NTQsMTAgQEAKICcKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnZ2l0IG5vdGVzIGNvcHkgLS1zdGRpbicgJworCWNvbW1pdD0kKGdpdCByZXYtcGFyc2UgSEVBRCkgJiYKKwlwYXJlbnQ9JChnaXQgcmV2LXBhcnNlIEhFQUReKSAmJgogCWNhdCA+ZXhwZWN0IDw8LUVPRiAmJgotCQljb21taXQgZTg3MWFhNjExODJiMWQ5NWQwYTZmYjc1NDQ1ZDg5MTcyMjg2M2I2YgorCQljb21taXQgJGNvbW1pdAogCQlBdXRob3I6IEEgVSBUaG9yIDxhdXRob3JAZXhhbXBsZS5jb20+CiAJCURhdGU6ICAgVGh1IEFwciA3IDE1OjI1OjEzIDIwMDUgLTA3MDAKIApAQCAtOTAxLDcgKzk2OCw3IEBACiAJCSR7aW5kZW50fQogCQkke2luZGVudH15ZXQgYW5vdGhlciBub3RlCiAKLQkJY29tbWl0IDY1ZTI2M2RlZDAyYWU0ZTg4MzliYzE1MTA5NTExMzczNzU3OWRjMTIKKwkJY29tbWl0ICRwYXJlbnQKIAkJQXV0aG9yOiBBIFUgVGhvciA8YXV0aG9yQGV4YW1wbGUuY29tPgogCQlEYXRlOiAgIFRodSBBcHIgNyAxNToyNDoxMyAyMDA1IC0wNzAwCiAKQEAgLTkyMiwyMSArOTg5LDIzIEBACiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2dpdCBub3RlcyBjb3B5IC0tZm9yLXJld3JpdGUgKHVuY29uZmlndXJlZCknICcKKwl0ZXN0X2NvbW1pdCAxNHRoICYmCisJdGVzdF9jb21taXQgMTV0aCAmJgorCWNvbW1pdD0kKGdpdCByZXYtcGFyc2UgSEVBRCkgJiYKKwlwYXJlbnQ9JChnaXQgcmV2LXBhcnNlIEhFQUReKSAmJgogCWNhdCA+ZXhwZWN0IDw8LUVPRiAmJgotCQljb21taXQgNGFjZjQyZTg0N2U3ZmZmYmJmODllZTM2NWMyMGFjN2NhZjQwZGU4OQorCQljb21taXQgJGNvbW1pdAogCQlBdXRob3I6IEEgVSBUaG9yIDxhdXRob3JAZXhhbXBsZS5jb20+CiAJCURhdGU6ICAgVGh1IEFwciA3IDE1OjI3OjEzIDIwMDUgLTA3MDAKIAogCQkke2luZGVudH0xNXRoCiAKLQkJY29tbWl0IDA3Yzg1ZDc3MDU5MzkzZWQwMTU0YjhjOTY5MDY1NDdhNTlkZmNkZGQKKwkJY29tbWl0ICRwYXJlbnQKIAkJQXV0aG9yOiBBIFUgVGhvciA8YXV0aG9yQGV4YW1wbGUuY29tPgogCQlEYXRlOiAgIFRodSBBcHIgNyAxNToyNjoxMyAyMDA1IC0wNzAwCiAKIAkJJHtpbmRlbnR9MTR0aAogCUVPRgotCXRlc3RfY29tbWl0IDE0dGggJiYKLQl0ZXN0X2NvbW1pdCAxNXRoICYmCiAJKGVjaG8gJChnaXQgcmV2LXBhcnNlIEhFQUR+MykgJChnaXQgcmV2LXBhcnNlIEhFQUReKSAmJgogCWVjaG8gJChnaXQgcmV2LXBhcnNlIEhFQUR+MikgJChnaXQgcmV2LXBhcnNlIEhFQUQpKSB8CiAJZ2l0IG5vdGVzIGNvcHkgLS1mb3ItcmV3cml0ZT1mb28gJiYKQEAgLTk0NSw4ICsxMDE0LDEwIEBACiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2dpdCBub3RlcyBjb3B5IC0tZm9yLXJld3JpdGUgKGVuYWJsZWQpJyAnCisJY29tbWl0PSQoZ2l0IHJldi1wYXJzZSBIRUFEKSAmJgorCXBhcmVudD0kKGdpdCByZXYtcGFyc2UgSEVBRF4pICYmCiAJY2F0ID5leHBlY3QgPDwtRU9GICYmCi0JCWNvbW1pdCA0YWNmNDJlODQ3ZTdmZmZiYmY4OWVlMzY1YzIwYWM3Y2FmNDBkZTg5CisJCWNvbW1pdCAkY29tbWl0CiAJCUF1dGhvcjogQSBVIFRob3IgPGF1dGhvckBleGFtcGxlLmNvbT4KIAkJRGF0ZTogICBUaHUgQXByIDcgMTU6Mjc6MTMgMjAwNSAtMDcwMAogCkBAIC05NTcsNyArMTAyOCw3IEBACiAJCSR7aW5kZW50fQogCQkke2luZGVudH15ZXQgYW5vdGhlciBub3RlCiAKLQkJY29tbWl0IDA3Yzg1ZDc3MDU5MzkzZWQwMTU0YjhjOTY5MDY1NDdhNTlkZmNkZGQKKwkJY29tbWl0ICRwYXJlbnQKIAkJQXV0aG9yOiBBIFUgVGhvciA8YXV0aG9yQGV4YW1wbGUuY29tPgogCQlEYXRlOiAgIFRodSBBcHIgNyAxNToyNjoxMyAyMDA1IC0wNzAwCiAKQEAgLTk4Niw4ICsxMDU3LDkgQEAKICcKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnZ2l0IG5vdGVzIGNvcHkgLS1mb3ItcmV3cml0ZSAob3ZlcndyaXRlKScgJworCWNvbW1pdD0kKGdpdCByZXYtcGFyc2UgSEVBRCkgJiYKIAljYXQgPmV4cGVjdCA8PC1FT0YgJiYKLQkJY29tbWl0IDRhY2Y0MmU4NDdlN2ZmZmJiZjg5ZWUzNjVjMjBhYzdjYWY0MGRlODkKKwkJY29tbWl0ICRjb21taXQKIAkJQXV0aG9yOiBBIFUgVGhvciA8YXV0aG9yQGV4YW1wbGUuY29tPgogCQlEYXRlOiAgIFRodSBBcHIgNyAxNToyNzoxMyAyMDA1IC0wNzAwCiAKQEAgLTEwMTUsOCArMTA4Nyw5IEBACiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2dpdCBub3RlcyBjb3B5IC0tZm9yLXJld3JpdGUgKGFwcGVuZCknICcKKwljb21taXQ9JChnaXQgcmV2LXBhcnNlIEhFQUQpICYmCiAJY2F0ID5leHBlY3QgPDwtRU9GICYmCi0JCWNvbW1pdCA0YWNmNDJlODQ3ZTdmZmZiYmY4OWVlMzY1YzIwYWM3Y2FmNDBkZTg5CisJCWNvbW1pdCAkY29tbWl0CiAJCUF1dGhvcjogQSBVIFRob3IgPGF1dGhvckBleGFtcGxlLmNvbT4KIAkJRGF0ZTogICBUaHUgQXByIDcgMTU6Mjc6MTMgMjAwNSAtMDcwMAogCkBAIC0xMDM3LDggKzExMTAsOSBAQAogJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdnaXQgbm90ZXMgY29weSAtLWZvci1yZXdyaXRlIChhcHBlbmQgdHdvIHRvIG9uZSknICcKKwljb21taXQ9JChnaXQgcmV2LXBhcnNlIEhFQUQpICYmCiAJY2F0ID5leHBlY3QgPDwtRU9GICYmCi0JCWNvbW1pdCA0YWNmNDJlODQ3ZTdmZmZiYmY4OWVlMzY1YzIwYWM3Y2FmNDBkZTg5CisJCWNvbW1pdCAkY29tbWl0CiAJCUF1dGhvcjogQSBVIFRob3IgPGF1dGhvckBleGFtcGxlLmNvbT4KIAkJRGF0ZTogICBUaHUgQXByIDcgMTU6Mjc6MTMgMjAwNSAtMDcwMAogCkBAIC0xMDc1LDggKzExNDksOSBAQAogJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdHSVRfTk9URVNfUkVXUklURV9NT0RFIHdvcmtzJyAnCisJY29tbWl0PSQoZ2l0IHJldi1wYXJzZSBIRUFEKSAmJgogCWNhdCA+ZXhwZWN0IDw8LUVPRiAmJgotCQljb21taXQgNGFjZjQyZTg0N2U3ZmZmYmJmODllZTM2NWMyMGFjN2NhZjQwZGU4OQorCQljb21taXQgJGNvbW1pdAogCQlBdXRob3I6IEEgVSBUaG9yIDxhdXRob3JAZXhhbXBsZS5jb20+CiAJCURhdGU6ICAgVGh1IEFwciA3IDE1OjI3OjEzIDIwMDUgLTA3MDAKIApAQCAtMTA5NSw4ICsxMTcwLDkgQEAKICcKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnR0lUX05PVEVTX1JFV1JJVEVfUkVGIHdvcmtzJyAnCisJY29tbWl0PSQoZ2l0IHJldi1wYXJzZSBIRUFEKSAmJgogCWNhdCA+ZXhwZWN0IDw8LUVPRiAmJgotCQljb21taXQgNGFjZjQyZTg0N2U3ZmZmYmJmODllZTM2NWMyMGFjN2NhZjQwZGU4OQorCQljb21taXQgJGNvbW1pdAogCQlBdXRob3I6IEEgVSBUaG9yIDxhdXRob3JAZXhhbXBsZS5jb20+CiAJCURhdGU6ICAgVGh1IEFwciA3IDE1OjI3OjEzIDIwMDUgLTA3MDAKIApAQCAtMTEyNyw4ICsxMjAzLDEwIEBACiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2dpdCBub3RlcyBjb3B5IGRpYWdub3NlcyB0b28gbWFueSBvciB0b28gZmV3IHBhcmFtZXRlcnMnICcKLQl0ZXN0X211c3RfZmFpbCBnaXQgbm90ZXMgY29weSAmJgotCXRlc3RfbXVzdF9mYWlsIGdpdCBub3RlcyBjb3B5IG9uZSB0d28gdGhyZWUKKwl0ZXN0X211c3RfZmFpbCBnaXQgbm90ZXMgY29weSAyPmVycm9yICYmCisJdGVzdF9pMThuZ3JlcCAidG9vIGZldyBwYXJhbWV0ZXJzIiBlcnJvciAmJgorCXRlc3RfbXVzdF9mYWlsIGdpdCBub3RlcyBjb3B5IG9uZSB0d28gdGhyZWUgMj5lcnJvciAmJgorCXRlc3RfaTE4bmdyZXAgInRvbyBtYW55IHBhcmFtZXRlcnMiIGVycm9yCiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2dpdCBub3RlcyBnZXQtcmVmIGV4cGFuZHMgcmVmcy9oZWFkcy9tYXN0ZXIgdG8gcmVmcy9ub3Rlcy9yZWZzL2hlYWRzL21hc3RlcicgJwpkaWZmIC0tZ2l0IGEvdC90MzMwNS1ub3Rlcy1mYW5vdXQuc2ggYi90L3QzMzA1LW5vdGVzLWZhbm91dC5zaAppbmRleCA1NDQ2MGJlLi44MzFmODNkIDEwMDc1NQotLS0gYS90L3QzMzA1LW5vdGVzLWZhbm91dC5zaAorKysgYi90L3QzMzA1LW5vdGVzLWZhbm91dC5zaApAQCAtMzUsMTUgKzM1LDEwIEBACiAJZ2l0IGxzLXRyZWUgLXIgLS1uYW1lLW9ubHkgcmVmcy9ub3Rlcy9jb21taXRzIHwKIAl3aGlsZSByZWFkIHBhdGgKIAlkbwotCQljYXNlICIkcGF0aCIgaW4KLQkJPz8vPz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8pCi0JCQk6IHRydWUKLQkJCTs7Ci0JCSopCisJCWVjaG8gJHBhdGggfCBncmVwICJeLi4vWzAtOWEtZl0qJCIgfHwgewogCQkJZWNobyAiSW52YWxpZCBwYXRoIFwiJHBhdGhcIiIgJiYKLQkJCXJldHVybiAxCi0JCQk7OwotCQllc2FjCisJCQlyZXR1cm4gMTsKKwkJfQogCWRvbmUKICcKIApAQCAtNzcsMTUgKzcyLDEwIEBACiAJZ2l0IGxzLXRyZWUgLXIgLS1uYW1lLW9ubHkgcmVmcy9ub3Rlcy9jb21taXRzIHwKIAl3aGlsZSByZWFkIHBhdGgKIAlkbwotCQljYXNlICIkcGF0aCIgaW4KLQkJPz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/Pz8/PykKLQkJCTogdHJ1ZQotCQkJOzsKLQkJKikKKwkJZWNobyAkcGF0aCB8IGdyZXAgLXYgIl4uLi8uKiIgfHwgewogCQkJZWNobyAiSW52YWxpZCBwYXRoIFwiJHBhdGhcIiIgJiYKLQkJCXJldHVybiAxCi0JCQk7OwotCQllc2FjCisJCQlyZXR1cm4gMTsKKwkJfQogCWRvbmUKICcKIApkaWZmIC0tZ2l0IGEvdC90MzMwNi1ub3Rlcy1wcnVuZS5zaCBiL3QvdDMzMDYtbm90ZXMtcHJ1bmUuc2gKaW5kZXggNjE3NDgwOC4uOGY0MTAyZiAxMDA3NTUKLS0tIGEvdC90MzMwNi1ub3Rlcy1wcnVuZS5zaAorKysgYi90L3QzMzA2LW5vdGVzLXBydW5lLnNoCkBAIC0xMSwyMyArMTEsMjYgQEAKIAl0ZXN0X3RpY2sgJiYKIAlnaXQgY29tbWl0IC1tIDFzdCAmJgogCWdpdCBub3RlcyBhZGQgLW0gIk5vdGUgIzEiICYmCisJZmlyc3Q9JChnaXQgcmV2LXBhcnNlIEhFQUQpICYmCiAJOiA+IGZpbGUyICYmCiAJZ2l0IGFkZCBmaWxlMiAmJgogCXRlc3RfdGljayAmJgogCWdpdCBjb21taXQgLW0gMm5kICYmCiAJZ2l0IG5vdGVzIGFkZCAtbSAiTm90ZSAjMiIgJiYKKwlzZWNvbmQ9JChnaXQgcmV2LXBhcnNlIEhFQUQpICYmCiAJOiA+IGZpbGUzICYmCiAJZ2l0IGFkZCBmaWxlMyAmJgogCXRlc3RfdGljayAmJgogCWdpdCBjb21taXQgLW0gM3JkICYmCi0JQ09NTUlUX0ZJTEU9LmdpdC9vYmplY3RzLzVlL2UxYzM1ZTgzZWE0N2NkM2NjNGY4Y2JlZTA1Njg5MTVmYmJiZDI5ICYmCisJdGhpcmQ9JChnaXQgcmV2LXBhcnNlIEhFQUQpICYmCisJQ09NTUlUX0ZJTEU9JChlY2hvICR0aGlyZCB8IHNlZCAicyFeLi4hLmdpdC9vYmplY3RzLyYvISIpICYmCiAJdGVzdCAtZiAkQ09NTUlUX0ZJTEUgJiYKIAl0ZXN0LXRvb2wgY2htdGltZSA9KzAgJENPTU1JVF9GSUxFICYmCiAJZ2l0IG5vdGVzIGFkZCAtbSAiTm90ZSAjMyIKICcKIAogY2F0ID4gZXhwZWN0IDw8RU5EX09GX0xPRwotY29tbWl0IDVlZTFjMzVlODNlYTQ3Y2QzY2M0ZjhjYmVlMDU2ODkxNWZiYmJkMjkKK2NvbW1pdCAkdGhpcmQKIEF1dGhvcjogQSBVIFRob3IgPGF1dGhvckBleGFtcGxlLmNvbT4KIERhdGU6ICAgVGh1IEFwciA3IDE1OjE1OjEzIDIwMDUgLTA3MDAKIApAQCAtMzYsNyArMzksNyBAQAogTm90ZXM6CiAgICAgTm90ZSAjMwogCi1jb21taXQgMDgzNDFhZDllOTRmYWEwODlkNjBmZDNmNTIzYWZmYjI1YzZkYTE4OQorY29tbWl0ICRzZWNvbmQKIEF1dGhvcjogQSBVIFRob3IgPGF1dGhvckBleGFtcGxlLmNvbT4KIERhdGU6ICAgVGh1IEFwciA3IDE1OjE0OjEzIDIwMDUgLTA3MDAKIApAQCAtNDUsNyArNDgsNyBAQAogTm90ZXM6CiAgICAgTm90ZSAjMgogCi1jb21taXQgYWI1ZjMwMjAzNWYyZTdhYWYwNDI2NWYwOGI0MjAzNGMyMzI1NmUxZgorY29tbWl0ICRmaXJzdAogQXV0aG9yOiBBIFUgVGhvciA8YXV0aG9yQGV4YW1wbGUuY29tPgogRGF0ZTogICBUaHUgQXByIDcgMTU6MTM6MTMgMjAwNSAtMDcwMAogCkBAIC03MCwxNiArNzMsMTYgQEAKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAndmVyaWZ5IHRoYXQgY29tbWl0cyBhcmUgZ29uZScgJwogCi0JdGVzdF9tdXN0X2ZhaWwgZ2l0IGNhdC1maWxlIC1wIDVlZTFjMzVlODNlYTQ3Y2QzY2M0ZjhjYmVlMDU2ODkxNWZiYmJkMjkgJiYKLQlnaXQgY2F0LWZpbGUgLXAgMDgzNDFhZDllOTRmYWEwODlkNjBmZDNmNTIzYWZmYjI1YzZkYTE4OSAmJgotCWdpdCBjYXQtZmlsZSAtcCBhYjVmMzAyMDM1ZjJlN2FhZjA0MjY1ZjA4YjQyMDM0YzIzMjU2ZTFmCisJdGVzdF9tdXN0X2ZhaWwgZ2l0IGNhdC1maWxlIC1wICR0aGlyZCAmJgorCWdpdCBjYXQtZmlsZSAtcCAkc2Vjb25kICYmCisJZ2l0IGNhdC1maWxlIC1wICRmaXJzdAogJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICd2ZXJpZnkgdGhhdCBub3RlcyBhcmUgc3RpbGwgcHJlc2VudCcgJwogCi0JZ2l0IG5vdGVzIHNob3cgNWVlMWMzNWU4M2VhNDdjZDNjYzRmOGNiZWUwNTY4OTE1ZmJiYmQyOSAmJgotCWdpdCBub3RlcyBzaG93IDA4MzQxYWQ5ZTk0ZmFhMDg5ZDYwZmQzZjUyM2FmZmIyNWM2ZGExODkgJiYKLQlnaXQgbm90ZXMgc2hvdyBhYjVmMzAyMDM1ZjJlN2FhZjA0MjY1ZjA4YjQyMDM0YzIzMjU2ZTFmCisJZ2l0IG5vdGVzIHNob3cgJHRoaXJkICYmCisJZ2l0IG5vdGVzIHNob3cgJHNlY29uZCAmJgorCWdpdCBub3RlcyBzaG93ICRmaXJzdAogJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdwcnVuZSAtbiBkb2VzIG5vdCByZW1vdmUgbm90ZXMnICcKQEAgLTkwLDEzICs5MywxMCBAQAogCXRlc3RfY21wIGV4cGVjdCBhY3R1YWwKICcKIAotY2F0ID4gZXhwZWN0IDw8RU9GCi01ZWUxYzM1ZTgzZWE0N2NkM2NjNGY4Y2JlZTA1Njg5MTVmYmJiZDI5Ci1FT0YKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAncHJ1bmUgLW4gbGlzdHMgcHJ1bmFibGUgbm90ZXMnICcKIAotCisJZWNobyAkdGhpcmQgPmV4cGVjdCAmJgogCWdpdCBub3RlcyBwcnVuZSAtbiA+IGFjdHVhbCAmJgogCXRlc3RfY21wIGV4cGVjdCBhY3R1YWwKICcKQEAgLTEwOSw5ICsxMDksOSBAQAogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICd2ZXJpZnkgdGhhdCBub3RlcyBhcmUgZ29uZScgJwogCi0JdGVzdF9tdXN0X2ZhaWwgZ2l0IG5vdGVzIHNob3cgNWVlMWMzNWU4M2VhNDdjZDNjYzRmOGNiZWUwNTY4OTE1ZmJiYmQyOSAmJgotCWdpdCBub3RlcyBzaG93IDA4MzQxYWQ5ZTk0ZmFhMDg5ZDYwZmQzZjUyM2FmZmIyNWM2ZGExODkgJiYKLQlnaXQgbm90ZXMgc2hvdyBhYjVmMzAyMDM1ZjJlN2FhZjA0MjY1ZjA4YjQyMDM0YzIzMjU2ZTFmCisJdGVzdF9tdXN0X2ZhaWwgZ2l0IG5vdGVzIHNob3cgJHRoaXJkICYmCisJZ2l0IG5vdGVzIHNob3cgJHNlY29uZCAmJgorCWdpdCBub3RlcyBzaG93ICRmaXJzdAogJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdyZW1vdmUgc29tZSBjb21taXRzJyAnCkBAIC0xMjEsMjEgKzEyMSwxOCBAQAogCWdpdCBnYyAtLXBydW5lPW5vdwogJwogCi1jYXQgPiBleHBlY3QgPDxFT0YKLTA4MzQxYWQ5ZTk0ZmFhMDg5ZDYwZmQzZjUyM2FmZmIyNWM2ZGExODkKLUVPRgotCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdwcnVuZSAtdiBub3RlcycgJwogCisJZWNobyAkc2Vjb25kID5leHBlY3QgJiYKIAlnaXQgbm90ZXMgcHJ1bmUgLXYgPiBhY3R1YWwgJiYKIAl0ZXN0X2NtcCBleHBlY3QgYWN0dWFsCiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3ZlcmlmeSB0aGF0IG5vdGVzIGFyZSBnb25lJyAnCiAKLQl0ZXN0X211c3RfZmFpbCBnaXQgbm90ZXMgc2hvdyA1ZWUxYzM1ZTgzZWE0N2NkM2NjNGY4Y2JlZTA1Njg5MTVmYmJiZDI5ICYmCi0JdGVzdF9tdXN0X2ZhaWwgZ2l0IG5vdGVzIHNob3cgMDgzNDFhZDllOTRmYWEwODlkNjBmZDNmNTIzYWZmYjI1YzZkYTE4OSAmJgotCWdpdCBub3RlcyBzaG93IGFiNWYzMDIwMzVmMmU3YWFmMDQyNjVmMDhiNDIwMzRjMjMyNTZlMWYKKwl0ZXN0X211c3RfZmFpbCBnaXQgbm90ZXMgc2hvdyAkdGhpcmQgJiYKKwl0ZXN0X211c3RfZmFpbCBnaXQgbm90ZXMgc2hvdyAkc2Vjb25kICYmCisJZ2l0IG5vdGVzIHNob3cgJGZpcnN0CiAnCiAKIHRlc3RfZG9uZQpkaWZmIC0tZ2l0IGEvdC90MzQwMC1yZWJhc2Uuc2ggYi90L3QzNDAwLXJlYmFzZS5zaAppbmRleCA4MGIyM2ZkLi5mMjY3ZjZjIDEwMDc1NQotLS0gYS90L3QzNDAwLXJlYmFzZS5zaAorKysgYi90L3QzNDAwLXJlYmFzZS5zaApAQCAtNjQsNyArNjQsNyBAQAogCXByZT0iJChnaXQgcmV2LXBhcnNlIC0tdmVyaWZ5IEhFQUQpIiAmJgogCWdpdCByZWJhc2UgbWFzdGVyICYmCiAJdGVzdF9jbXBfcmV2ICIkcHJlIiBPUklHX0hFQUQgJiYKLQkhIHRlc3RfY21wX3JldiAiJHByZSIgSEVBRAorCXRlc3RfY21wX3JldiAhICIkcHJlIiBIRUFECiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3JlYmFzZSwgd2l0aCA8b250bz4gYW5kIDx1cHN0cmVhbT4gc3BlY2lmaWVkIGFzIDovcXV1eGVyeScgJwpAQCAtMjk1LDEyICsyOTUsNDggQEAKIAkJZWNobyB0d28gPj5pbml0LnQgJiYKIAkJZ2l0IGNvbW1pdCAtYSAtbSB0d28gJiYKIAkJZ2l0IHRhZyB0d28gJiYKLQkJdGVzdF9tdXN0X2ZhaWwgZ2l0IHJlYmFzZSAtLW9udG8gaW5pdCBIRUFEXiAmJgorCQl0ZXN0X211c3RfZmFpbCBnaXQgcmViYXNlIC1mIC0tb250byBpbml0IEhFQUReICYmCiAJCUdJVF9UUkFDRT0xIGdpdCByZWJhc2UgLS1zaG93LWN1cnJlbnQtcGF0Y2ggPi9kZXYvbnVsbCAyPnN0ZGVyciAmJgogCQlncmVwICJzaG93LiokKGdpdCByZXYtcGFyc2UgdHdvKSIgc3RkZXJyCiAJKQogJwogCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdyZWJhc2UgLS1hbSBhbmQgLmdpdGF0dHJpYnV0ZXMnICcKKwl0ZXN0X2NyZWF0ZV9yZXBvIGF0dHJpYnV0ZXMgJiYKKwkoCisJCWNkIGF0dHJpYnV0ZXMgJiYKKwkJdGVzdF9jb21taXQgaW5pdCAmJgorCQlnaXQgY29uZmlnIGZpbHRlci50ZXN0LmNsZWFuICJzZWQgLWUgJ1wnJ3Mvc211ZGdlZC9jbGVhbi9nJ1wnJyIgJiYKKwkJZ2l0IGNvbmZpZyBmaWx0ZXIudGVzdC5zbXVkZ2UgInNlZCAtZSAnXCcncy9jbGVhbi9zbXVkZ2VkL2cnXCcnIiAmJgorCisJCXRlc3RfY29tbWl0IHNlY29uZCAmJgorCQlnaXQgY2hlY2tvdXQgLWIgdGVzdCBIRUFEXiAmJgorCisJCWVjaG8gIioudHh0IGZpbHRlcj10ZXN0IiA+LmdpdGF0dHJpYnV0ZXMgJiYKKwkJZ2l0IGFkZCAuZ2l0YXR0cmlidXRlcyAmJgorCQl0ZXN0X2NvbW1pdCB0aGlyZCAmJgorCisJCWVjaG8gIlRoaXMgdGV4dCBpcyBzbXVkZ2VkLiIgPmEudHh0ICYmCisJCWdpdCBhZGQgYS50eHQgJiYKKwkJdGVzdF9jb21taXQgZm91cnRoICYmCisKKwkJZ2l0IGNoZWNrb3V0IC1iIHJlbW92YWwgSEVBRF4gJiYKKwkJZ2l0IHJtIC5naXRhdHRyaWJ1dGVzICYmCisJCWdpdCBhZGQgLXUgJiYKKwkJdGVzdF9jb21taXQgZmlmdGggJiYKKwkJZ2l0IGNoZXJyeS1waWNrIHRlc3QgJiYKKworCQlnaXQgY2hlY2tvdXQgdGVzdCAmJgorCQlnaXQgcmViYXNlIG1hc3RlciAmJgorCQlncmVwICJzbXVkZ2VkIiBhLnR4dCAmJgorCisJCWdpdCBjaGVja291dCByZW1vdmFsICYmCisJCWdpdCByZXNldCAtLWhhcmQgJiYKKwkJZ2l0IHJlYmFzZSBtYXN0ZXIgJiYKKwkJZ3JlcCAiY2xlYW4iIGEudHh0CisJKQorJworCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdyZWJhc2UtLW1lcmdlLnNoIGFuZCAtLXNob3ctY3VycmVudC1wYXRjaCcgJwogCXRlc3RfY3JlYXRlX3JlcG8gY29uZmxpY3QtbWVyZ2UgJiYKIAkoCmRpZmYgLS1naXQgYS90L3QzNDAzLXJlYmFzZS1za2lwLnNoIGIvdC90MzQwMy1yZWJhc2Utc2tpcC5zaAppbmRleCAxZjUxMjJiLi5lZThhOGRiIDEwMDc1NQotLS0gYS90L3QzNDAzLXJlYmFzZS1za2lwLnNoCisrKyBiL3QvdDM0MDMtcmViYXNlLXNraXAuc2gKQEAgLTcsNiArNyw4IEBACiAKIC4gLi90ZXN0LWxpYi5zaAogCisuICIkVEVTVF9ESVJFQ1RPUlkiL2xpYi1yZWJhc2Uuc2gKKwogIyB3ZSBhc3N1bWUgdGhlIGRlZmF1bHQgZ2l0IGFtIC0zIC0tc2tpcCBzdHJhdGVneSBpcyB0ZXN0ZWQgaW5kZXBlbmRlbnRseQogIyBhbmQgYWx3YXlzIHdvcmtzIDopCiAKQEAgLTIwLDYgKzIyLDEzIEBACiAJZ2l0IGNvbW1pdCAtYSAtbSAiaGVsbG8gd29ybGQiICYmCiAJZWNobyBnb29kYnllID4+IGhlbGxvICYmCiAJZ2l0IGNvbW1pdCAtYSAtbSAiZ29vZGJ5ZSIgJiYKKwlnaXQgdGFnIGdvb2RieWUgJiYKKworCWdpdCBjaGVja291dCAtLWRldGFjaCAmJgorCWdpdCBjaGVja291dCBIRUFEXiAuICYmCisJdGVzdF90aWNrICYmCisJZ2l0IGNvbW1pdCAtbSByZXZlcnRlZC1nb29kYnllICYmCisJZ2l0IHRhZyByZXZlcnRlZC1nb29kYnllICYmCiAKIAlnaXQgY2hlY2tvdXQgLWYgc2tpcC1yZWZlcmVuY2UgJiYKIAllY2hvIG1vbyA+IGhlbGxvICYmCkBAIC03Niw0ICs4NSwyNyBAQAogCiB0ZXN0X2RlYnVnICdnaXRrIC0tYWxsICYgc2xlZXAgMScKIAordGVzdF9leHBlY3Rfc3VjY2VzcyAnZml4dXAgdGhhdCBlbXB0aWVzIGNvbW1pdCBmYWlscycgJworCXRlc3Rfd2hlbl9maW5pc2hlZCAiZ2l0IHJlYmFzZSAtLWFib3J0IiAmJgorCSgKKwkJc2V0X2Zha2VfZWRpdG9yICYmCisJCXRlc3RfbXVzdF9mYWlsIGVudiBGQUtFX0xJTkVTPSIxIGZpeHVwIDIiIGdpdCByZWJhc2UgLWkgXAorCQkJZ29vZGJ5ZV4gcmV2ZXJ0ZWQtZ29vZGJ5ZQorCSkKKycKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAnc3F1YXNoIHRoYXQgZW1wdGllcyBjb21taXQgZmFpbHMnICcKKwl0ZXN0X3doZW5fZmluaXNoZWQgImdpdCByZWJhc2UgLS1hYm9ydCIgJiYKKwkoCisJCXNldF9mYWtlX2VkaXRvciAmJgorCQl0ZXN0X211c3RfZmFpbCBlbnYgRkFLRV9MSU5FUz0iMSBzcXVhc2ggMiIgZ2l0IHJlYmFzZSAtaSBcCisJCQlnb29kYnllXiByZXZlcnRlZC1nb29kYnllCisJKQorJworCisjIE11c3QgYmUgdGhlIGxhc3QgdGVzdCBpbiB0aGlzIGZpbGUKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJyRFRElUT1IgYW5kIGZyaWVuZHMgYXJlIHVuY2hhbmdlZCcgJworCXRlc3RfZWRpdG9yX3VuY2hhbmdlZAorJworCiB0ZXN0X2RvbmUKZGlmZiAtLWdpdCBhL3QvdDM0MDQtcmViYXNlLWludGVyYWN0aXZlLnNoIGIvdC90MzQwNC1yZWJhc2UtaW50ZXJhY3RpdmUuc2gKaW5kZXggNDYxZGQ1My4uYmYwZGM3NSAxMDA3NTUKLS0tIGEvdC90MzQwNC1yZWJhc2UtaW50ZXJhY3RpdmUuc2gKKysrIGIvdC90MzQwNC1yZWJhc2UtaW50ZXJhY3RpdmUuc2gKQEAgLTI5LDkgKzI5LDYgQEAKIAogLiAiJFRFU1RfRElSRUNUT1JZIi9saWItcmViYXNlLnNoCiAKLSMgV0FSTklORzogTW9kaWZpY2F0aW9ucyB0byB0aGUgaW5pdGlhbCByZXBvc2l0b3J5IGNhbiBjaGFuZ2UgdGhlIFNIQSBJRCB1c2VkCi0jIGluIHRoZSBleHBlY3QyIGZpbGUgZm9yIHRoZSAnc3RvcCBvbiBjb25mbGljdGluZyBwaWNrJyB0ZXN0LgotCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdzZXR1cCcgJwogCXRlc3RfY29tbWl0IEEgZmlsZTEgJiYKIAl0ZXN0X2NvbW1pdCBCIGZpbGUxICYmCkBAIC03OSw4ICs3NiwxMSBAQAogCWNhdCA+ZXhwZWN0IDw8LVxFT0YgJiYKIAllcnJvcjogbm90aGluZyB0byBkbwogCUVPRgotCXNldF9mYWtlX2VkaXRvciAmJgotCXRlc3RfbXVzdF9mYWlsIGVudiBGQUtFX0xJTkVTPSIxIGV4ZWNfdHJ1ZSIgZ2l0IHJlYmFzZSAtaSBIRUFEXiA+YWN0dWFsIDI+JjEgJiYKKwkoCisJCXNldF9mYWtlX2VkaXRvciAmJgorCQl0ZXN0X211c3RfZmFpbCBlbnYgRkFLRV9MSU5FUz0iMSBleGVjX3RydWUiIFwKKwkJCWdpdCByZWJhc2UgLWkgSEVBRF4gPmFjdHVhbCAyPiYxCisJKSAmJgogCXRlc3RfaTE4bmNtcCBleHBlY3QgYWN0dWFsCiAnCiAKQEAgLTEzOSw4ICsxMzksMTEgQEAKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAncmViYXNlIC1pIHdpdGggdGhlIGV4ZWMgY29tbWFuZCBjaGVja3MgdHJlZSBjbGVhbm5lc3MnICcKIAlnaXQgY2hlY2tvdXQgbWFzdGVyICYmCi0Jc2V0X2Zha2VfZWRpdG9yICYmCi0JdGVzdF9tdXN0X2ZhaWwgZW52IEZBS0VfTElORVM9ImV4ZWNfZWNob19mb29fPmZpbGUxIDEiIGdpdCByZWJhc2UgLWkgSEVBRF4gJiYKKwkoCisJCXNldF9mYWtlX2VkaXRvciAmJgorCQl0ZXN0X211c3RfZmFpbCBlbnYgRkFLRV9MSU5FUz0iZXhlY19lY2hvX2Zvb18+ZmlsZTEgMSIgXAorCQkJZ2l0IHJlYmFzZSAtaSBIRUFEXgorCSkgJiYKIAl0ZXN0X2NtcF9yZXYgbWFzdGVyXiBIRUFEICYmCiAJZ2l0IHJlc2V0IC0taGFyZCAmJgogCWdpdCByZWJhc2UgLS1jb250aW51ZQpAQCAtMTU1LDggKzE1OCw2IEBACiAJdGVzdF9pMThuY21wIGV4cGVjdGVkIGFjdHVhbAogJwogCi1MRj0nCi0nCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdyZWJhc2UgLXggd2l0aCBuZXdsaW5lIGluIGNvbW1hbmQgZmFpbHMnICcKIAl0ZXN0X3doZW5fZmluaXNoZWQgImdpdCByZWJhc2UgLS1hYm9ydCB8fDoiICYmCiAJdGVzdF9tdXN0X2ZhaWwgZW52IGdpdCByZWJhc2UgLXggImEke0xGfWIiIEAgMj5hY3R1YWwgJiYKQEAgLTE2OCw5ICsxNjksMTEgQEAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3JlYmFzZSAtaSB3aXRoIGV4ZWMgb2YgaW5leGlzdGVudCBjb21tYW5kJyAnCiAJZ2l0IGNoZWNrb3V0IG1hc3RlciAmJgogCXRlc3Rfd2hlbl9maW5pc2hlZCAiZ2l0IHJlYmFzZSAtLWFib3J0IiAmJgotCXNldF9mYWtlX2VkaXRvciAmJgotCXRlc3RfbXVzdF9mYWlsIGVudiBGQUtFX0xJTkVTPSJleGVjX3RoaXMtY29tbWFuZC1kb2VzLW5vdC1leGlzdCAxIiBcCi0JZ2l0IHJlYmFzZSAtaSBIRUFEXiA+YWN0dWFsIDI+JjEgJiYKKwkoCisJCXNldF9mYWtlX2VkaXRvciAmJgorCQl0ZXN0X211c3RfZmFpbCBlbnYgRkFLRV9MSU5FUz0iZXhlY190aGlzLWNvbW1hbmQtZG9lcy1ub3QtZXhpc3QgMSIgXAorCQkJZ2l0IHJlYmFzZSAtaSBIRUFEXiA+YWN0dWFsIDI+JjEKKwkpICYmCiAJISBncmVwICJNYXliZSBnaXQtcmViYXNlIGlzIGJyb2tlbiIgYWN0dWFsCiAnCiAKQEAgLTE4MSw3ICsxODQsNiBAQAogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdubyBjaGFuZ2VzIGFyZSBhIG5vcCcgJwogCWdpdCBjaGVja291dCBicmFuY2gyICYmCi0Jc2V0X2Zha2VfZWRpdG9yICYmCiAJZ2l0IHJlYmFzZSAtaSBGICYmCiAJdGVzdCAiJChnaXQgc3ltYm9saWMtcmVmIC1xIEhFQUQpIiA9ICJyZWZzL2hlYWRzL2JyYW5jaDIiICYmCiAJdGVzdCAkKGdpdCByZXYtcGFyc2UgSSkgPSAkKGdpdCByZXYtcGFyc2UgSEVBRCkKQEAgLTE5MSw3ICsxOTMsNiBAQAogCWdpdCBjaGVja291dCAtYiBkZWFkLWVuZCAmJgogCWdpdCBybSBmaWxlNiAmJgogCWdpdCBjb21taXQgLW0gInN0b3AgaGVyZSIgJiYKLQlzZXRfZmFrZV9lZGl0b3IgJiYKIAlnaXQgcmViYXNlIC1pIEYgYnJhbmNoMiAmJgogCXRlc3QgIiQoZ2l0IHN5bWJvbGljLXJlZiAtcSBIRUFEKSIgPSAicmVmcy9oZWFkcy9icmFuY2gyIiAmJgogCXRlc3QgJChnaXQgcmV2LXBhcnNlIEkpID0gJChnaXQgcmV2LXBhcnNlIGJyYW5jaDIpICYmCkBAIC0yMDAsNyArMjAxLDYgQEAKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAndGVzdCAtLW9udG8gPGJyYW5jaD4nICcKIAlnaXQgY2hlY2tvdXQgLWIgdGVzdC1vbnRvIGJyYW5jaDIgJiYKLQlzZXRfZmFrZV9lZGl0b3IgJiYKIAlnaXQgcmViYXNlIC1pIC0tb250byBicmFuY2gxIEYgJiYKIAl0ZXN0ICIkKGdpdCBzeW1ib2xpYy1yZWYgLXEgSEVBRCkiID0gInJlZnMvaGVhZHMvdGVzdC1vbnRvIiAmJgogCXRlc3QgJChnaXQgcmV2LXBhcnNlIEhFQUReKSA9ICQoZ2l0IHJldi1wYXJzZSBicmFuY2gxKSAmJgpAQCAtMjEwLDcgKzIxMCw2IEBACiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdyZWJhc2Ugb24gdG9wIG9mIGEgbm9uLWNvbmZsaWN0aW5nIGNvbW1pdCcgJwogCWdpdCBjaGVja291dCBicmFuY2gxICYmCiAJZ2l0IHRhZyBvcmlnaW5hbC1icmFuY2gxICYmCi0Jc2V0X2Zha2VfZWRpdG9yICYmCiAJZ2l0IHJlYmFzZSAtaSBicmFuY2gyICYmCiAJdGVzdCBmaWxlNiA9ICQoZ2l0IGRpZmYgLS1uYW1lLW9ubHkgb3JpZ2luYWwtYnJhbmNoMSkgJiYKIAl0ZXN0ICIkKGdpdCBzeW1ib2xpYy1yZWYgLXEgSEVBRCkiID0gInJlZnMvaGVhZHMvYnJhbmNoMSIgJiYKQEAgLTIzMCwzMSArMjI5LDM1IEBACiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2V4Y2hhbmdlIHR3byBjb21taXRzJyAnCi0Jc2V0X2Zha2VfZWRpdG9yICYmCi0JRkFLRV9MSU5FUz0iMiAxIiBnaXQgcmViYXNlIC1pIEhFQUR+MiAmJgorCSgKKwkJc2V0X2Zha2VfZWRpdG9yICYmCisJCUZBS0VfTElORVM9IjIgMSIgZ2l0IHJlYmFzZSAtaSBIRUFEfjIKKwkpICYmCiAJdGVzdCBIID0gJChnaXQgY2F0LWZpbGUgY29tbWl0IEhFQUReIHwgc2VkIC1uZSBcJHApICYmCi0JdGVzdCBHID0gJChnaXQgY2F0LWZpbGUgY29tbWl0IEhFQUQgfCBzZWQgLW5lIFwkcCkKKwl0ZXN0IEcgPSAkKGdpdCBjYXQtZmlsZSBjb21taXQgSEVBRCB8IHNlZCAtbmUgXCRwKSAmJgorCWJsb2IxPSQoZ2l0IHJldi1wYXJzZSAtLXNob3J0IEhFQUReOmZpbGUxKSAmJgorCWJsb2IyPSQoZ2l0IHJldi1wYXJzZSAtLXNob3J0IEhFQUQ6ZmlsZTEpICYmCisJY29tbWl0PSQoZ2l0IHJldi1wYXJzZSAtLXNob3J0IEhFQUQpCiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3N0b3Agb24gY29uZmxpY3RpbmcgcGljaycgJwotCWNhdCA+ZXhwZWN0IDw8LVxFT0YgJiYKKwljYXQgPmV4cGVjdCA8PC1FT0YgJiYKIAlkaWZmIC0tZ2l0IGEvZmlsZTEgYi9maWxlMQotCWluZGV4IGY3MGYxMGUuLmZkNzkyMzUgMTAwNjQ0CisJaW5kZXggJGJsb2IxLi4kYmxvYjIgMTAwNjQ0CiAJLS0tIGEvZmlsZTEKIAkrKysgYi9maWxlMQogCUBAIC0xICsxIEBACiAJLUEKIAkrRwogCUVPRgotCWNhdCA+ZXhwZWN0MiA8PC1cRU9GICYmCisJY2F0ID5leHBlY3QyIDw8LUVPRiAmJgogCTw8PDw8PDwgSEVBRAogCUQKIAk9PT09PT09CiAJRwotCT4+Pj4+Pj4gNWQxOGU1NC4uLiBHCisJPj4+Pj4+PiAkY29tbWl0Li4uIEcKIAlFT0YKIAlnaXQgdGFnIG5ldy1icmFuY2gxICYmCi0Jc2V0X2Zha2VfZWRpdG9yICYmCiAJdGVzdF9tdXN0X2ZhaWwgZ2l0IHJlYmFzZSAtaSBtYXN0ZXIgJiYKIAl0ZXN0ICIkKGdpdCByZXYtcGFyc2UgSEVBRH4zKSIgPSAiJChnaXQgcmV2LXBhcnNlIG1hc3RlcikiICYmCiAJdGVzdF9jbXAgZXhwZWN0IC5naXQvcmViYXNlLW1lcmdlL3BhdGNoICYmCkBAIC0yODMsNyArMjg2LDYgQEAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2Fib3J0IHdpdGggZXJyb3Igd2hlbiBuZXcgYmFzZSBjYW5ub3QgYmUgY2hlY2tlZCBvdXQnICcKIAlnaXQgcm0gLS1jYWNoZWQgZmlsZTEgJiYKIAlnaXQgY29tbWl0IC1tICJyZW1vdmUgZmlsZSBpbiBiYXNlIiAmJgotCXNldF9mYWtlX2VkaXRvciAmJgogCXRlc3RfbXVzdF9mYWlsIGdpdCByZWJhc2UgLWkgbWFzdGVyID4gb3V0cHV0IDI+JjEgJiYKIAl0ZXN0X2kxOG5ncmVwICJUaGUgZm9sbG93aW5nIHVudHJhY2tlZCB3b3JraW5nIHRyZWUgZmlsZXMgd291bGQgYmUgb3ZlcndyaXR0ZW4gYnkgY2hlY2tvdXQ6IiBcCiAJCW91dHB1dCAmJgpAQCAtMjk4LDcgKzMwMCw2IEBACiAJdGVzdF90aWNrICYmCiAJR0lUX0FVVEhPUl9OQU1FPSJUd2VycCBTbm9nIiBnaXQgY29tbWl0IC1tICJkaWZmZXJlbnQgYXV0aG9yIiAmJgogCWdpdCB0YWcgdHdlcnAgJiYKLQlzZXRfZmFrZV9lZGl0b3IgJiYKIAlnaXQgcmViYXNlIC1pIC0tb250byBtYXN0ZXIgSEVBRF4gJiYKIAlnaXQgc2hvdyBIRUFEIHwgZ3JlcCAiXkF1dGhvcjogVHdlcnAgU25vZyIKICcKQEAgLTMxNiw3ICszMTcsNiBAQAogCXRlc3RfY29tbWl0IGIgY29uZmxpY3QgYiBjb25mbGljdC1iICYmCiAJR0lUX0FVVEhPUl9OQU1FPSRvR0lUX0FVVEhPUl9OQU1FICYmCiAKLQlzZXRfZmFrZV9lZGl0b3IgJiYKIAl0ZXN0X211c3RfZmFpbCBnaXQgcmViYXNlIC1pIGNvbmZsaWN0LWEgJiYKIAllY2hvIHJlc29sdmVkID5jb25mbGljdCAmJgogCWdpdCBhZGQgY29uZmxpY3QgJiYKQEAgLTMzMiw5ICszMzIsMTEgQEAKIAl0ZXN0X3RpY2sgJiYKIAlHSVRfQVVUSE9SX05BTUU9Ik5pdGZvbCIgZ2l0IGNvbW1pdCAtbSAibml0Zm9sIiBmaWxlNyAmJgogCWVjaG8gIioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiIgJiYKLQlzZXRfZmFrZV9lZGl0b3IgJiYKLQlGQUtFX0xJTkVTPSIxIHNxdWFzaCAyIiBFWFBFQ1RfSEVBREVSX0NPVU5UPTIgXAotCQlnaXQgcmViYXNlIC1pIC0tb250byBtYXN0ZXIgSEVBRH4yICYmCisJKAorCQlzZXRfZmFrZV9lZGl0b3IgJiYKKwkJRkFLRV9MSU5FUz0iMSBzcXVhc2ggMiIgRVhQRUNUX0hFQURFUl9DT1VOVD0yIFwKKwkJCWdpdCByZWJhc2UgLWkgLS1vbnRvIG1hc3RlciBIRUFEfjIKKwkpICYmCiAJdGVzdCBCID0gJChjYXQgZmlsZTcpICYmCiAJdGVzdCAkKGdpdCByZXYtcGFyc2UgSEVBRF4pID0gJChnaXQgcmV2LXBhcnNlIG1hc3RlcikKICcKQEAgLTM0NSw3ICszNDcsNiBAQAogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzIFJFQkFTRV9QICctcCBoYW5kbGVzICJubyBjaGFuZ2VzIiBncmFjZWZ1bGx5JyAnCiAJSEVBRD0kKGdpdCByZXYtcGFyc2UgSEVBRCkgJiYKLQlzZXRfZmFrZV9lZGl0b3IgJiYKIAlnaXQgcmViYXNlIC1pIC1wIEhFQUReICYmCiAJZ2l0IHVwZGF0ZS1pbmRleCAtLXJlZnJlc2ggJiYKIAlnaXQgZGlmZi1maWxlcyAtLXF1aWV0ICYmCkBAIC0zNTUsOCArMzU2LDEwIEBACiAKIHRlc3RfZXhwZWN0X2ZhaWx1cmUgUkVCQVNFX1AgJ2V4Y2hhbmdlIHR3byBjb21taXRzIHdpdGggLXAnICcKIAlnaXQgY2hlY2tvdXQgSCAmJgotCXNldF9mYWtlX2VkaXRvciAmJgotCUZBS0VfTElORVM9IjIgMSIgZ2l0IHJlYmFzZSAtaSAtcCBIRUFEfjIgJiYKKwkoCisJCXNldF9mYWtlX2VkaXRvciAmJgorCQlGQUtFX0xJTkVTPSIyIDEiIGdpdCByZWJhc2UgLWkgLXAgSEVBRH4yCisJKSAmJgogCXRlc3QgSCA9ICQoZ2l0IGNhdC1maWxlIGNvbW1pdCBIRUFEXiB8IHNlZCAtbmUgXCRwKSAmJgogCXRlc3QgRyA9ICQoZ2l0IGNhdC1maWxlIGNvbW1pdCBIRUFEIHwgc2VkIC1uZSBcJHApCiAnCkBAIC0zOTAsNyArMzkzLDYgQEAKIAlnaXQgY29tbWl0IC1tIE0gZmlsZTEgJiYKIAlnaXQgY2hlY2tvdXQgLWIgdG8tYmUtcmViYXNlZCAmJgogCXRlc3RfdGljayAmJgotCXNldF9mYWtlX2VkaXRvciAmJgogCWdpdCByZWJhc2UgLWkgLXAgLS1vbnRvIGJyYW5jaDEgbWFzdGVyICYmCiAJZ2l0IHVwZGF0ZS1pbmRleCAtLXJlZnJlc2ggJiYKIAlnaXQgZGlmZi1maWxlcyAtLXF1aWV0ICYmCkBAIC00MDUsOCArNDA3LDEwIEBACiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgUkVCQVNFX1AgJ2VkaXQgYW5jZXN0b3Igd2l0aCAtcCcgJwotCXNldF9mYWtlX2VkaXRvciAmJgotCUZBS0VfTElORVM9IjEgMiBlZGl0IDMgNCIgZ2l0IHJlYmFzZSAtaSAtcCBIRUFEfjMgJiYKKwkoCisJCXNldF9mYWtlX2VkaXRvciAmJgorCQlGQUtFX0xJTkVTPSIxIDIgZWRpdCAzIDQiIGdpdCByZWJhc2UgLWkgLXAgSEVBRH4zCisJKSAmJgogCWVjaG8gMiA+IHVucmVsYXRlZC1maWxlICYmCiAJdGVzdF90aWNrICYmCiAJZ2l0IGNvbW1pdCAtbSBMMi1tb2RpZmllZCAtLWFtZW5kIHVucmVsYXRlZC1maWxlICYmCkBAIC00MjAsMTEgKzQyNCwxMyBAQAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnLS1jb250aW51ZSB0cmllcyB0byBjb21taXQnICcKIAlnaXQgcmVzZXQgLS1oYXJkIEQgJiYKIAl0ZXN0X3RpY2sgJiYKLQlzZXRfZmFrZV9lZGl0b3IgJiYKLQl0ZXN0X211c3RfZmFpbCBnaXQgcmViYXNlIC1pIC0tb250byBuZXctYnJhbmNoMSBIRUFEXiAmJgotCWVjaG8gcmVzb2x2ZWQgPiBmaWxlMSAmJgotCWdpdCBhZGQgZmlsZTEgJiYKLQlGQUtFX0NPTU1JVF9NRVNTQUdFPSJjaG91ZXR0ZSEiIGdpdCByZWJhc2UgLS1jb250aW51ZSAmJgorCSgKKwkJc2V0X2Zha2VfZWRpdG9yICYmCisJCXRlc3RfbXVzdF9mYWlsIGdpdCByZWJhc2UgLWkgLS1vbnRvIG5ldy1icmFuY2gxIEhFQUReICYmCisJCWVjaG8gcmVzb2x2ZWQgPiBmaWxlMSAmJgorCQlnaXQgYWRkIGZpbGUxICYmCisJCUZBS0VfQ09NTUlUX01FU1NBR0U9ImNob3VldHRlISIgZ2l0IHJlYmFzZSAtLWNvbnRpbnVlCisJKSAmJgogCXRlc3QgJChnaXQgcmV2LXBhcnNlIEhFQUReKSA9ICQoZ2l0IHJldi1wYXJzZSBuZXctYnJhbmNoMSkgJiYKIAlnaXQgc2hvdyBIRUFEIHwgZ3JlcCBjaG91ZXR0ZQogJwpAQCAtNDMyLDcgKzQzOCw2IEBACiB0ZXN0X2V4cGVjdF9zdWNjZXNzICd2ZXJib3NlIGZsYWcgaXMgaGVlZGVkLCBldmVuIGFmdGVyIC0tY29udGludWUnICcKIAlnaXQgcmVzZXQgLS1oYXJkIG1hc3RlckB7MX0gJiYKIAl0ZXN0X3RpY2sgJiYKLQlzZXRfZmFrZV9lZGl0b3IgJiYKIAl0ZXN0X211c3RfZmFpbCBnaXQgcmViYXNlIC12IC1pIC0tb250byBuZXctYnJhbmNoMSBIRUFEXiAmJgogCWVjaG8gcmVzb2x2ZWQgPiBmaWxlMSAmJgogCWdpdCBhZGQgZmlsZTEgJiYKQEAgLTQ0MiwxMCArNDQ3LDEzIEBACiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgQ19MT0NBTEVfT1VUUFVUICdtdWx0aS1zcXVhc2ggb25seSBmaXJlcyB1cCBlZGl0b3Igb25jZScgJwogCWJhc2U9JChnaXQgcmV2LXBhcnNlIEhFQUR+NCkgJiYKLQlzZXRfZmFrZV9lZGl0b3IgJiYKLQlGQUtFX0NPTU1JVF9BTUVORD0iT05DRSIgRkFLRV9MSU5FUz0iMSBzcXVhc2ggMiBzcXVhc2ggMyBzcXVhc2ggNCIgXAotCQlFWFBFQ1RfSEVBREVSX0NPVU5UPTQgXAotCQlnaXQgcmViYXNlIC1pICRiYXNlICYmCisJKAorCQlzZXRfZmFrZV9lZGl0b3IgJiYKKwkJRkFLRV9DT01NSVRfQU1FTkQ9Ik9OQ0UiIFwKKwkJCUZBS0VfTElORVM9IjEgc3F1YXNoIDIgc3F1YXNoIDMgc3F1YXNoIDQiIFwKKwkJCUVYUEVDVF9IRUFERVJfQ09VTlQ9NCBcCisJCQlnaXQgcmViYXNlIC1pICRiYXNlCisJKSAmJgogCXRlc3QgJGJhc2UgPSAkKGdpdCByZXYtcGFyc2UgSEVBRF4pICYmCiAJdGVzdCAxID0gJChnaXQgc2hvdyB8IGdyZXAgT05DRSB8IHdjIC1sKQogJwpAQCAtNDUzLDkgKzQ2MSwxMiBAQAogdGVzdF9leHBlY3Rfc3VjY2VzcyBDX0xPQ0FMRV9PVVRQVVQgJ211bHRpLWZpeHVwIGRvZXMgbm90IGZpcmUgdXAgZWRpdG9yJyAnCiAJZ2l0IGNoZWNrb3V0IC1iIG11bHRpLWZpeHVwIEUgJiYKIAliYXNlPSQoZ2l0IHJldi1wYXJzZSBIRUFEfjQpICYmCi0Jc2V0X2Zha2VfZWRpdG9yICYmCi0JRkFLRV9DT01NSVRfQU1FTkQ9Ik5FVkVSIiBGQUtFX0xJTkVTPSIxIGZpeHVwIDIgZml4dXAgMyBmaXh1cCA0IiBcCi0JCWdpdCByZWJhc2UgLWkgJGJhc2UgJiYKKwkoCisJCXNldF9mYWtlX2VkaXRvciAmJgorCQlGQUtFX0NPTU1JVF9BTUVORD0iTkVWRVIiIFwKKwkJCUZBS0VfTElORVM9IjEgZml4dXAgMiBmaXh1cCAzIGZpeHVwIDQiIFwKKwkJCWdpdCByZWJhc2UgLWkgJGJhc2UKKwkpICYmCiAJdGVzdCAkYmFzZSA9ICQoZ2l0IHJldi1wYXJzZSBIRUFEXikgJiYKIAl0ZXN0IDAgPSAkKGdpdCBzaG93IHwgZ3JlcCBORVZFUiB8IHdjIC1sKSAmJgogCWdpdCBjaGVja291dCBAey0xfSAmJgpAQCAtNDY1LDEyICs0NzYsMTUgQEAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2NvbW1pdCBtZXNzYWdlIHVzZWQgYWZ0ZXIgY29uZmxpY3QnICcKIAlnaXQgY2hlY2tvdXQgLWIgY29uZmxpY3QtZml4dXAgY29uZmxpY3QtYnJhbmNoICYmCiAJYmFzZT0kKGdpdCByZXYtcGFyc2UgSEVBRH40KSAmJgotCXNldF9mYWtlX2VkaXRvciAmJgotCXRlc3RfbXVzdF9mYWlsIGVudiBGQUtFX0xJTkVTPSIxIGZpeHVwIDMgZml4dXAgNCIgZ2l0IHJlYmFzZSAtaSAkYmFzZSAmJgotCWVjaG8gdGhyZWUgPiBjb25mbGljdCAmJgotCWdpdCBhZGQgY29uZmxpY3QgJiYKLQlGQUtFX0NPTU1JVF9BTUVORD0iT05DRSIgRVhQRUNUX0hFQURFUl9DT1VOVD0yIFwKLQkJZ2l0IHJlYmFzZSAtLWNvbnRpbnVlICYmCisJKAorCQlzZXRfZmFrZV9lZGl0b3IgJiYKKwkJdGVzdF9tdXN0X2ZhaWwgZW52IEZBS0VfTElORVM9IjEgZml4dXAgMyBmaXh1cCA0IiBcCisJCQlnaXQgcmViYXNlIC1pICRiYXNlICYmCisJCWVjaG8gdGhyZWUgPiBjb25mbGljdCAmJgorCQlnaXQgYWRkIGNvbmZsaWN0ICYmCisJCUZBS0VfQ09NTUlUX0FNRU5EPSJPTkNFIiBFWFBFQ1RfSEVBREVSX0NPVU5UPTIgXAorCQkJZ2l0IHJlYmFzZSAtLWNvbnRpbnVlCisJKSAmJgogCXRlc3QgJGJhc2UgPSAkKGdpdCByZXYtcGFyc2UgSEVBRF4pICYmCiAJdGVzdCAxID0gJChnaXQgc2hvdyB8IGdyZXAgT05DRSB8IHdjIC1sKSAmJgogCWdpdCBjaGVja291dCBAey0xfSAmJgpAQCAtNDgwLDEyICs0OTQsMTUgQEAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2NvbW1pdCBtZXNzYWdlIHJldGFpbmVkIGFmdGVyIGNvbmZsaWN0JyAnCiAJZ2l0IGNoZWNrb3V0IC1iIGNvbmZsaWN0LXNxdWFzaCBjb25mbGljdC1icmFuY2ggJiYKIAliYXNlPSQoZ2l0IHJldi1wYXJzZSBIRUFEfjQpICYmCi0Jc2V0X2Zha2VfZWRpdG9yICYmCi0JdGVzdF9tdXN0X2ZhaWwgZW52IEZBS0VfTElORVM9IjEgZml4dXAgMyBzcXVhc2ggNCIgZ2l0IHJlYmFzZSAtaSAkYmFzZSAmJgotCWVjaG8gdGhyZWUgPiBjb25mbGljdCAmJgotCWdpdCBhZGQgY29uZmxpY3QgJiYKLQlGQUtFX0NPTU1JVF9BTUVORD0iVFdJQ0UiIEVYUEVDVF9IRUFERVJfQ09VTlQ9MiBcCi0JCWdpdCByZWJhc2UgLS1jb250aW51ZSAmJgorCSgKKwkJc2V0X2Zha2VfZWRpdG9yICYmCisJCXRlc3RfbXVzdF9mYWlsIGVudiBGQUtFX0xJTkVTPSIxIGZpeHVwIDMgc3F1YXNoIDQiIFwKKwkJCWdpdCByZWJhc2UgLWkgJGJhc2UgJiYKKwkJZWNobyB0aHJlZSA+IGNvbmZsaWN0ICYmCisJCWdpdCBhZGQgY29uZmxpY3QgJiYKKwkJRkFLRV9DT01NSVRfQU1FTkQ9IlRXSUNFIiBFWFBFQ1RfSEVBREVSX0NPVU5UPTIgXAorCQkJZ2l0IHJlYmFzZSAtLWNvbnRpbnVlCisJKSAmJgogCXRlc3QgJGJhc2UgPSAkKGdpdCByZXYtcGFyc2UgSEVBRF4pICYmCiAJdGVzdCAyID0gJChnaXQgc2hvdyB8IGdyZXAgVFdJQ0UgfCB3YyAtbCkgJiYKIAlnaXQgY2hlY2tvdXQgQHstMX0gJiYKQEAgLTUwMiwxMCArNTE5LDEzIEBACiAJRU9GCiAJZ2l0IGNoZWNrb3V0IC1iIHNxdWFzaC1maXh1cCBFICYmCiAJYmFzZT0kKGdpdCByZXYtcGFyc2UgSEVBRH40KSAmJgotCXNldF9mYWtlX2VkaXRvciAmJgotCUZBS0VfQ09NTUlUX0FNRU5EPSJPTkNFIiBGQUtFX0xJTkVTPSIxIGZpeHVwIDIgc3F1YXNoIDMgZml4dXAgNCIgXAotCQlFWFBFQ1RfSEVBREVSX0NPVU5UPTQgXAotCQlnaXQgcmViYXNlIC1pICRiYXNlICYmCisJKAorCQlzZXRfZmFrZV9lZGl0b3IgJiYKKwkJRkFLRV9DT01NSVRfQU1FTkQ9Ik9OQ0UiIFwKKwkJCUZBS0VfTElORVM9IjEgZml4dXAgMiBzcXVhc2ggMyBmaXh1cCA0IiBcCisJCQlFWFBFQ1RfSEVBREVSX0NPVU5UPTQgXAorCQkJZ2l0IHJlYmFzZSAtaSAkYmFzZQorCSkgJiYKIAlnaXQgY2F0LWZpbGUgY29tbWl0IEhFQUQgfCBzZWQgLWUgMSwvXlwkL2QgPiBhY3R1YWwtc3F1YXNoLWZpeHVwICYmCiAJdGVzdF9jbXAgZXhwZWN0LXNxdWFzaC1maXh1cCBhY3R1YWwtc3F1YXNoLWZpeHVwICYmCiAJZ2l0IGNhdC1maWxlIGNvbW1pdCBIRUFEQHsyfSB8CkBAIC01MTksMTAgKzUzOSwxMyBAQAogdGVzdF9leHBlY3Rfc3VjY2VzcyBDX0xPQ0FMRV9PVVRQVVQgJ3NxdWFzaCBpZ25vcmVzIGNvbW1lbnRzJyAnCiAJZ2l0IGNoZWNrb3V0IC1iIHNraXAtY29tbWVudHMgRSAmJgogCWJhc2U9JChnaXQgcmV2LXBhcnNlIEhFQUR+NCkgJiYKLQlzZXRfZmFrZV9lZGl0b3IgJiYKLQlGQUtFX0NPTU1JVF9BTUVORD0iT05DRSIgRkFLRV9MSU5FUz0iIyAxICMgc3F1YXNoIDIgIyBzcXVhc2ggMyAjIHNxdWFzaCA0ICMiIFwKLQkJRVhQRUNUX0hFQURFUl9DT1VOVD00IFwKLQkJZ2l0IHJlYmFzZSAtaSAkYmFzZSAmJgorCSgKKwkJc2V0X2Zha2VfZWRpdG9yICYmCisJCUZBS0VfQ09NTUlUX0FNRU5EPSJPTkNFIiBcCisJCQlGQUtFX0xJTkVTPSIjIDEgIyBzcXVhc2ggMiAjIHNxdWFzaCAzICMgc3F1YXNoIDQgIyIgXAorCQkJRVhQRUNUX0hFQURFUl9DT1VOVD00IFwKKwkJCWdpdCByZWJhc2UgLWkgJGJhc2UKKwkpICYmCiAJdGVzdCAkYmFzZSA9ICQoZ2l0IHJldi1wYXJzZSBIRUFEXikgJiYKIAl0ZXN0IDEgPSAkKGdpdCBzaG93IHwgZ3JlcCBPTkNFIHwgd2MgLWwpICYmCiAJZ2l0IGNoZWNrb3V0IEB7LTF9ICYmCkBAIC01MzIsMTAgKzU1NSwxMyBAQAogdGVzdF9leHBlY3Rfc3VjY2VzcyBDX0xPQ0FMRV9PVVRQVVQgJ3NxdWFzaCBpZ25vcmVzIGJsYW5rIGxpbmVzJyAnCiAJZ2l0IGNoZWNrb3V0IC1iIHNraXAtYmxhbmstbGluZXMgRSAmJgogCWJhc2U9JChnaXQgcmV2LXBhcnNlIEhFQUR+NCkgJiYKLQlzZXRfZmFrZV9lZGl0b3IgJiYKLQlGQUtFX0NPTU1JVF9BTUVORD0iT05DRSIgRkFLRV9MSU5FUz0iPiAxID4gc3F1YXNoIDIgPiBzcXVhc2ggMyA+IHNxdWFzaCA0ID4iIFwKLQkJRVhQRUNUX0hFQURFUl9DT1VOVD00IFwKLQkJZ2l0IHJlYmFzZSAtaSAkYmFzZSAmJgorCSgKKwkJc2V0X2Zha2VfZWRpdG9yICYmCisJCUZBS0VfQ09NTUlUX0FNRU5EPSJPTkNFIiBcCisJCQlGQUtFX0xJTkVTPSI+IDEgPiBzcXVhc2ggMiA+IHNxdWFzaCAzID4gc3F1YXNoIDQgPiIgXAorCQkJRVhQRUNUX0hFQURFUl9DT1VOVD00IFwKKwkJCWdpdCByZWJhc2UgLWkgJGJhc2UKKwkpICYmCiAJdGVzdCAkYmFzZSA9ICQoZ2l0IHJldi1wYXJzZSBIRUFEXikgJiYKIAl0ZXN0IDEgPSAkKGdpdCBzaG93IHwgZ3JlcCBPTkNFIHwgd2MgLWwpICYmCiAJZ2l0IGNoZWNrb3V0IEB7LTF9ICYmCkBAIC01NDUsMTcgKzU3MSwyMSBAQAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnc3F1YXNoIHdvcmtzIGFzIGV4cGVjdGVkJyAnCiAJZ2l0IGNoZWNrb3V0IC1iIHNxdWFzaC13b3JrcyBuby1jb25mbGljdC1icmFuY2ggJiYKIAlvbmU9JChnaXQgcmV2LXBhcnNlIEhFQUR+MykgJiYKLQlzZXRfZmFrZV9lZGl0b3IgJiYKLQlGQUtFX0xJTkVTPSIxIHMgMyAyIiBFWFBFQ1RfSEVBREVSX0NPVU5UPTIgXAotCQlnaXQgcmViYXNlIC1pIEhFQUR+MyAmJgorCSgKKwkJc2V0X2Zha2VfZWRpdG9yICYmCisJCUZBS0VfTElORVM9IjEgcyAzIDIiIEVYUEVDVF9IRUFERVJfQ09VTlQ9MiBnaXQgcmViYXNlIC1pIEhFQUR+MworCSkgJiYKIAl0ZXN0ICRvbmUgPSAkKGdpdCByZXYtcGFyc2UgSEVBRH4yKQogJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdpbnRlcnJ1cHRlZCBzcXVhc2ggd29ya3MgYXMgZXhwZWN0ZWQnICcKIAlnaXQgY2hlY2tvdXQgLWIgaW50ZXJydXB0ZWQtc3F1YXNoIGNvbmZsaWN0LWJyYW5jaCAmJgogCW9uZT0kKGdpdCByZXYtcGFyc2UgSEVBRH4zKSAmJgotCXNldF9mYWtlX2VkaXRvciAmJgotCXRlc3RfbXVzdF9mYWlsIGVudiBGQUtFX0xJTkVTPSIxIHNxdWFzaCAzIDIiIGdpdCByZWJhc2UgLWkgSEVBRH4zICYmCisJKAorCQlzZXRfZmFrZV9lZGl0b3IgJiYKKwkJdGVzdF9tdXN0X2ZhaWwgZW52IEZBS0VfTElORVM9IjEgc3F1YXNoIDMgMiIgXAorCQkJZ2l0IHJlYmFzZSAtaSBIRUFEfjMKKwkpICYmCiAJdGVzdF93cml0ZV9saW5lcyBvbmUgdHdvIGZvdXIgPiBjb25mbGljdCAmJgogCWdpdCBhZGQgY29uZmxpY3QgJiYKIAl0ZXN0X211c3RfZmFpbCBnaXQgcmViYXNlIC0tY29udGludWUgJiYKQEAgLTU2OCw4ICs1OTgsMTEgQEAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2ludGVycnVwdGVkIHNxdWFzaCB3b3JrcyBhcyBleHBlY3RlZCAoY2FzZSAyKScgJwogCWdpdCBjaGVja291dCAtYiBpbnRlcnJ1cHRlZC1zcXVhc2gyIGNvbmZsaWN0LWJyYW5jaCAmJgogCW9uZT0kKGdpdCByZXYtcGFyc2UgSEVBRH4zKSAmJgotCXNldF9mYWtlX2VkaXRvciAmJgotCXRlc3RfbXVzdF9mYWlsIGVudiBGQUtFX0xJTkVTPSIzIHNxdWFzaCAxIDIiIGdpdCByZWJhc2UgLWkgSEVBRH4zICYmCisJKAorCQlzZXRfZmFrZV9lZGl0b3IgJiYKKwkJdGVzdF9tdXN0X2ZhaWwgZW52IEZBS0VfTElORVM9IjMgc3F1YXNoIDEgMiIgXAorCQkJZ2l0IHJlYmFzZSAtaSBIRUFEfjMKKwkpICYmCiAJdGVzdF93cml0ZV9saW5lcyBvbmUgZm91ciA+IGNvbmZsaWN0ICYmCiAJZ2l0IGFkZCBjb25mbGljdCAmJgogCXRlc3RfbXVzdF9mYWlsIGdpdCByZWJhc2UgLS1jb250aW51ZSAmJgpAQCAtNTg5LDExICs2MjIsMTMgQEAKIAlnaXQgY29tbWl0IC1tICJ1bnJlbGF0ZWQgY2hhbmdlIiAmJgogCXBhcmVudD0kKGdpdCByZXYtcGFyc2UgSEVBRF4pICYmCiAJdGVzdF90aWNrICYmCi0Jc2V0X2Zha2VfZWRpdG9yICYmCi0JRkFLRV9MSU5FUz0iZWRpdCAxIiBnaXQgcmViYXNlIC1pIEhFQUReICYmCi0JZWNobyBlZGl0ZWQgPiBmaWxlNyAmJgotCWdpdCBhZGQgZmlsZTcgJiYKLQlGQUtFX0NPTU1JVF9NRVNTQUdFPSJjaG91ZXR0ZSEiIGdpdCByZWJhc2UgLS1jb250aW51ZSAmJgorCSgKKwkJc2V0X2Zha2VfZWRpdG9yICYmCisJCUZBS0VfTElORVM9ImVkaXQgMSIgZ2l0IHJlYmFzZSAtaSBIRUFEXiAmJgorCQllY2hvIGVkaXRlZCA+IGZpbGU3ICYmCisJCWdpdCBhZGQgZmlsZTcgJiYKKwkJRkFLRV9DT01NSVRfTUVTU0FHRT0iY2hvdWV0dGUhIiBnaXQgcmViYXNlIC0tY29udGludWUKKwkpICYmCiAJdGVzdCBlZGl0ZWQgPSAkKGdpdCBzaG93IEhFQUQ6ZmlsZTcpICYmCiAJZ2l0IHNob3cgSEVBRCB8IGdyZXAgY2hvdWV0dGUgJiYKIAl0ZXN0ICRwYXJlbnQgPSAkKGdpdCByZXYtcGFyc2UgSEVBRF4pCkBAIC02MDIsMzQgKzYzNyw0MSBAQAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnYWJvcnRlZCAtLWNvbnRpbnVlIGRvZXMgbm90IHNxdWFzaCBjb21taXRzIGFmdGVyICJlZGl0IicgJwogCW9sZD0kKGdpdCByZXYtcGFyc2UgSEVBRCkgJiYKIAl0ZXN0X3RpY2sgJiYKLQlzZXRfZmFrZV9lZGl0b3IgJiYKLQlGQUtFX0xJTkVTPSJlZGl0IDEiIGdpdCByZWJhc2UgLWkgSEVBRF4gJiYKLQllY2hvICJlZGl0ZWQgYWdhaW4iID4gZmlsZTcgJiYKLQlnaXQgYWRkIGZpbGU3ICYmCi0JdGVzdF9tdXN0X2ZhaWwgZW52IEZBS0VfQ09NTUlUX01FU1NBR0U9IiAiIGdpdCByZWJhc2UgLS1jb250aW51ZSAmJgorCSgKKwkJc2V0X2Zha2VfZWRpdG9yICYmCisJCUZBS0VfTElORVM9ImVkaXQgMSIgZ2l0IHJlYmFzZSAtaSBIRUFEXiAmJgorCQllY2hvICJlZGl0ZWQgYWdhaW4iID4gZmlsZTcgJiYKKwkJZ2l0IGFkZCBmaWxlNyAmJgorCQl0ZXN0X211c3RfZmFpbCBlbnYgRkFLRV9DT01NSVRfTUVTU0FHRT0iICIgZ2l0IHJlYmFzZSAtLWNvbnRpbnVlCisJKSAmJgogCXRlc3QgJG9sZCA9ICQoZ2l0IHJldi1wYXJzZSBIRUFEKSAmJgogCWdpdCByZWJhc2UgLS1hYm9ydAogJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdhdXRvLWFtZW5kIG9ubHkgZWRpdGVkIGNvbW1pdHMgYWZ0ZXIgImVkaXQiJyAnCiAJdGVzdF90aWNrICYmCi0Jc2V0X2Zha2VfZWRpdG9yICYmCi0JRkFLRV9MSU5FUz0iZWRpdCAxIiBnaXQgcmViYXNlIC1pIEhFQUReICYmCi0JZWNobyAiZWRpdGVkIGFnYWluIiA+IGZpbGU3ICYmCi0JZ2l0IGFkZCBmaWxlNyAmJgotCUZBS0VfQ09NTUlUX01FU1NBR0U9ImVkaXRlZCBmaWxlNyBhZ2FpbiIgZ2l0IGNvbW1pdCAmJgotCWVjaG8gImFuZCBhZ2FpbiIgPiBmaWxlNyAmJgotCWdpdCBhZGQgZmlsZTcgJiYKLQl0ZXN0X3RpY2sgJiYKLQl0ZXN0X211c3RfZmFpbCBlbnYgRkFLRV9DT01NSVRfTUVTU0FHRT0iYW5kIGFnYWluIiBnaXQgcmViYXNlIC0tY29udGludWUgJiYKKwkoCisJCXNldF9mYWtlX2VkaXRvciAmJgorCQlGQUtFX0xJTkVTPSJlZGl0IDEiIGdpdCByZWJhc2UgLWkgSEVBRF4gJiYKKwkJZWNobyAiZWRpdGVkIGFnYWluIiA+IGZpbGU3ICYmCisJCWdpdCBhZGQgZmlsZTcgJiYKKwkJRkFLRV9DT01NSVRfTUVTU0FHRT0iZWRpdGVkIGZpbGU3IGFnYWluIiBnaXQgY29tbWl0ICYmCisJCWVjaG8gImFuZCBhZ2FpbiIgPiBmaWxlNyAmJgorCQlnaXQgYWRkIGZpbGU3ICYmCisJCXRlc3RfdGljayAmJgorCQl0ZXN0X211c3RfZmFpbCBlbnYgRkFLRV9DT01NSVRfTUVTU0FHRT0iYW5kIGFnYWluIiBcCisJCQlnaXQgcmViYXNlIC0tY29udGludWUKKwkpICYmCiAJZ2l0IHJlYmFzZSAtLWFib3J0CiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2NsZWFuIGVycm9yIGFmdGVyIGZhaWxlZCAiZXhlYyInICcKIAl0ZXN0X3RpY2sgJiYKIAl0ZXN0X3doZW5fZmluaXNoZWQgImdpdCByZWJhc2UgLS1hYm9ydCB8fCA6IiAmJgotCXNldF9mYWtlX2VkaXRvciAmJgotCXRlc3RfbXVzdF9mYWlsIGVudiBGQUtFX0xJTkVTPSIxIGV4ZWNfZmFsc2UiIGdpdCByZWJhc2UgLWkgSEVBRF4gJiYKKwkoCisJCXNldF9mYWtlX2VkaXRvciAmJgorCQl0ZXN0X211c3RfZmFpbCBlbnYgRkFLRV9MSU5FUz0iMSBleGVjX2ZhbHNlIiBnaXQgcmViYXNlIC1pIEhFQUReCisJKSAmJgogCWVjaG8gImVkaXRlZCBhZ2FpbiIgPiBmaWxlNyAmJgogCWdpdCBhZGQgZmlsZTcgJiYKIAl0ZXN0X211c3RfZmFpbCBnaXQgcmViYXNlIC0tY29udGludWUgMj5lcnJvciAmJgpAQCAtNjQwLDggKzY4MiwxMCBAQAogCWdyYW5kcGFyZW50PSQoZ2l0IHJldi1wYXJzZSBIRUFEfjIpICYmCiAJZ2l0IGNoZWNrb3V0ICQoZ2l0IHJldi1wYXJzZSBIRUFEKSAmJgogCXRlc3RfdGljayAmJgotCXNldF9mYWtlX2VkaXRvciAmJgotCUZBS0VfTElORVM9IjIgMSIgZ2l0IHJlYmFzZSAtaSBIRUFEfjIgJiYKKwkoCisJCXNldF9mYWtlX2VkaXRvciAmJgorCQlGQUtFX0xJTkVTPSIyIDEiIGdpdCByZWJhc2UgLWkgSEVBRH4yCisJKSAmJgogCXRlc3QgJGdyYW5kcGFyZW50ID0gJChnaXQgcmV2LXBhcnNlIEhFQUR+MikKICcKIApAQCAtNjU2LDkgKzcwMCwxMCBAQAogCXRlc3RfbXVzdF9mYWlsIGdpdCBjb21taXQgLW0gZG9lc250LXZlcmlmeSBmaWxlMSAmJgogCWdpdCBjb21taXQgLW0gZG9lc250LXZlcmlmeSAtLW5vLXZlcmlmeSBmaWxlMSAmJgogCXRlc3RfdGljayAmJgotCXNldF9mYWtlX2VkaXRvciAmJgotCUZBS0VfTElORVM9MiBnaXQgcmViYXNlIC1pIEhFQUR+MgotCisJKAorCQlzZXRfZmFrZV9lZGl0b3IgJiYKKwkJRkFLRV9MSU5FUz0yIGdpdCByZWJhc2UgLWkgSEVBRH4yCisJKQogJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdyZWJhc2Ugd2l0aCBhIGZpbGUgbmFtZWQgSEVBRCBpbiB3b3JrdHJlZScgJwpAQCAtNjc4LDggKzcyMywxMCBAQAogCQlnaXQgY29tbWl0IC1tICJBZGQgYm9keSIKIAkpICYmCiAKLQlzZXRfZmFrZV9lZGl0b3IgJiYKLQlGQUtFX0xJTkVTPSIxIHNxdWFzaCAyIiBnaXQgcmViYXNlIC1pIEB7LTF9ICYmCisJKAorCQlzZXRfZmFrZV9lZGl0b3IgJiYKKwkJRkFLRV9MSU5FUz0iMSBzcXVhc2ggMiIgZ2l0IHJlYmFzZSAtaSBAey0xfQorCSkgJiYKIAl0ZXN0ICIkKGdpdCBzaG93IC1zIC0tcHJldHR5PWZvcm1hdDolYW4pIiA9ICJTcXVhc2hlZCBBd2F5IgogCiAnCkBAIC02OTAsNyArNzM3LDYgQEAKIAlHSVRfRURJVE9SPTogZ2l0IGNvbW1pdCAtLWFtZW5kIFwKIAkJLS1hdXRob3I9IlNvbWVib2R5IGVsc2UgPHNvbWVib2R5QGVsc2UuY29tPiIgJiYKIAl0ZXN0ICQoZ2l0IHJldi1wYXJzZSBicmFuY2gzKSAhPSAkKGdpdCByZXYtcGFyc2UgYnJhbmNoNCkgJiYKLQlzZXRfZmFrZV9lZGl0b3IgJiYKIAlnaXQgcmViYXNlIC1pIGJyYW5jaDMgJiYKIAl0ZXN0ICQoZ2l0IHJldi1wYXJzZSBicmFuY2gzKSA9ICQoZ2l0IHJldi1wYXJzZSBicmFuY2g0KQogCkBAIC03MTUsMTMgKzc2MSwxNCBAQAogCQlnaXQgY29tbWl0IC1hIC1tICJzdWJtb2R1bGUgc2Vjb25kIgogCSkgJiYKIAl0ZXN0X3RpY2sgJiYKLQlzZXRfZmFrZV9lZGl0b3IgJiYKIAlnaXQgY29tbWl0IC1hIC1tICJUaHJlZSBjaGFuZ2VzIHN1Ym1vZHVsZSIKICcKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnc3VibW9kdWxlIHJlYmFzZSAtaScgJwotCXNldF9mYWtlX2VkaXRvciAmJgotCUZBS0VfTElORVM9IjEgc3F1YXNoIDIgMyIgZ2l0IHJlYmFzZSAtaSBBCisJKAorCQlzZXRfZmFrZV9lZGl0b3IgJiYKKwkJRkFLRV9MSU5FUz0iMSBzcXVhc2ggMiAzIiBnaXQgcmViYXNlIC1pIEEKKwkpCiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3N1Ym1vZHVsZSBjb25mbGljdCBzZXR1cCcgJwpAQCAtNzM4LDcgKzc4NSw2IEBACiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3JlYmFzZSAtaSBjb250aW51ZSB3aXRoIG9ubHkgc3VibW9kdWxlIHN0YWdlZCcgJwotCXNldF9mYWtlX2VkaXRvciAmJgogCXRlc3RfbXVzdF9mYWlsIGdpdCByZWJhc2UgLWkgc3VibW9kdWxlLWJhc2UgJiYKIAlnaXQgYWRkIHN1YiAmJgogCWdpdCByZWJhc2UgLS1jb250aW51ZSAmJgpAQCAtNzQ4LDcgKzc5NCw2IEBACiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdyZWJhc2UgLWkgY29udGludWUgd2l0aCB1bnN0YWdlZCBzdWJtb2R1bGUnICcKIAlnaXQgY2hlY2tvdXQgc3VibW9kdWxlLXRvcGljICYmCiAJZ2l0IHJlc2V0IC0taGFyZCAmJgotCXNldF9mYWtlX2VkaXRvciAmJgogCXRlc3RfbXVzdF9mYWlsIGdpdCByZWJhc2UgLWkgc3VibW9kdWxlLWJhc2UgJiYKIAlnaXQgcmVzZXQgJiYKIAlnaXQgcmViYXNlIC0tY29udGludWUgJiYKQEAgLTc2MSw3ICs4MDYsNiBAQAogCXRlc3QtdG9vbCBjaG10aW1lID0xMjM0NTY3ODkgZmlsZTMgJiYKIAlnaXQgdXBkYXRlLWluZGV4IC0tcmVmcmVzaCAmJgogCUhFQUQ9JChnaXQgcmV2LXBhcnNlIEhFQUQpICYmCi0Jc2V0X2Zha2VfZWRpdG9yICYmCiAJZ2l0IHJlYmFzZSAtaSBIRUFEfjQgJiYKIAl0ZXN0ICRIRUFEID0gJChnaXQgcmV2LXBhcnNlIEhFQUQpICYmCiAJTVRJTUU9JCh0ZXN0LXRvb2wgY2htdGltZSAtLWdldCBmaWxlMykgJiYKQEAgLTc3MCwxNiArODE0LDIyIEBACiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3Jld29yZCcgJwogCWdpdCBjaGVja291dCAtYiByZXdvcmQtYnJhbmNoIG1hc3RlciAmJgotCXNldF9mYWtlX2VkaXRvciAmJgotCUZBS0VfTElORVM9IjEgMiAzIHJld29yZCA0IiBGQUtFX0NPTU1JVF9NRVNTQUdFPSJFIGNoYW5nZWQiIGdpdCByZWJhc2UgLWkgQSAmJgotCWdpdCBzaG93IEhFQUQgfCBncmVwICJFIGNoYW5nZWQiICYmCi0JdGVzdCAkKGdpdCByZXYtcGFyc2UgbWFzdGVyKSAhPSAkKGdpdCByZXYtcGFyc2UgSEVBRCkgJiYKLQl0ZXN0ICQoZ2l0IHJldi1wYXJzZSBtYXN0ZXJeKSA9ICQoZ2l0IHJldi1wYXJzZSBIRUFEXikgJiYKLQlGQUtFX0xJTkVTPSIxIDIgcmV3b3JkIDMgNCIgRkFLRV9DT01NSVRfTUVTU0FHRT0iRCBjaGFuZ2VkIiBnaXQgcmViYXNlIC1pIEEgJiYKLQlnaXQgc2hvdyBIRUFEXiB8IGdyZXAgIkQgY2hhbmdlZCIgJiYKLQlGQUtFX0xJTkVTPSJyZXdvcmQgMSAyIDMgNCIgRkFLRV9DT01NSVRfTUVTU0FHRT0iQiBjaGFuZ2VkIiBnaXQgcmViYXNlIC1pIEEgJiYKLQlnaXQgc2hvdyBIRUFEfjMgfCBncmVwICJCIGNoYW5nZWQiICYmCi0JRkFLRV9MSU5FUz0iMSByIDIgcGljayAzIHAgNCIgRkFLRV9DT01NSVRfTUVTU0FHRT0iQyBjaGFuZ2VkIiBnaXQgcmViYXNlIC1pIEEgJiYKKwkoCisJCXNldF9mYWtlX2VkaXRvciAmJgorCQlGQUtFX0xJTkVTPSIxIDIgMyByZXdvcmQgNCIgRkFLRV9DT01NSVRfTUVTU0FHRT0iRSBjaGFuZ2VkIiBcCisJCQlnaXQgcmViYXNlIC1pIEEgJiYKKwkJZ2l0IHNob3cgSEVBRCB8IGdyZXAgIkUgY2hhbmdlZCIgJiYKKwkJdGVzdCAkKGdpdCByZXYtcGFyc2UgbWFzdGVyKSAhPSAkKGdpdCByZXYtcGFyc2UgSEVBRCkgJiYKKwkJdGVzdCAkKGdpdCByZXYtcGFyc2UgbWFzdGVyXikgPSAkKGdpdCByZXYtcGFyc2UgSEVBRF4pICYmCisJCUZBS0VfTElORVM9IjEgMiByZXdvcmQgMyA0IiBGQUtFX0NPTU1JVF9NRVNTQUdFPSJEIGNoYW5nZWQiIFwKKwkJCWdpdCByZWJhc2UgLWkgQSAmJgorCQlnaXQgc2hvdyBIRUFEXiB8IGdyZXAgIkQgY2hhbmdlZCIgJiYKKwkJRkFLRV9MSU5FUz0icmV3b3JkIDEgMiAzIDQiIEZBS0VfQ09NTUlUX01FU1NBR0U9IkIgY2hhbmdlZCIgXAorCQkJZ2l0IHJlYmFzZSAtaSBBICYmCisJCWdpdCBzaG93IEhFQUR+MyB8IGdyZXAgIkIgY2hhbmdlZCIgJiYKKwkJRkFLRV9MSU5FUz0iMSByIDIgcGljayAzIHAgNCIgRkFLRV9DT01NSVRfTUVTU0FHRT0iQyBjaGFuZ2VkIiBcCisJCQlnaXQgcmViYXNlIC1pIEEKKwkpICYmCiAJZ2l0IHNob3cgSEVBRH4yIHwgZ3JlcCAiQyBjaGFuZ2VkIgogJwogCkBAIC03OTAsNyArODQwLDYgQEAKIAl0ZXN0X2NvbW1pdCBuMiAmJgogCXRlc3RfY29tbWl0IG4zICYmCiAJZ2l0IG5vdGVzIGFkZCAtbSJhIG5vdGUiIG4zICYmCi0Jc2V0X2Zha2VfZWRpdG9yICYmCiAJZ2l0IHJlYmFzZSAtaSAtLW9udG8gbjEgbjIgJiYKIAl0ZXN0ICJhIG5vdGUiID0gIiQoZ2l0IG5vdGVzIHNob3cgSEVBRCkiCiAnCkBAIC04MDMsOCArODUyLDExIEBACiAJRU9GCiAJZ2l0IHJlc2V0IC0taGFyZCBuMyAmJgogCWdpdCBub3RlcyBhZGQgLW0iYW4gZWFybGllciBub3RlIiBuMiAmJgotCXNldF9mYWtlX2VkaXRvciAmJgotCUdJVF9OT1RFU19SRVdSSVRFX01PREU9Y29uY2F0ZW5hdGUgRkFLRV9MSU5FUz0iMSBmIDIiIGdpdCByZWJhc2UgLWkgbjEgJiYKKwkoCisJCXNldF9mYWtlX2VkaXRvciAmJgorCQlHSVRfTk9URVNfUkVXUklURV9NT0RFPWNvbmNhdGVuYXRlIEZBS0VfTElORVM9IjEgZiAyIiBcCisJCQlnaXQgcmViYXNlIC1pIG4xCisJKSAmJgogCWdpdCBub3RlcyBzaG93ID4gb3V0cHV0ICYmCiAJdGVzdF9jbXAgZXhwZWN0IG91dHB1dAogJwpAQCAtODEzLDggKzg2NSwxMCBAQAogCWdpdCBzeW1ib2xpYy1yZWYgSEVBRCAmJgogCWdyYW5kcGFyZW50PSQoZ2l0IHJldi1wYXJzZSBIRUFEfjIpICYmCiAJdGVzdF90aWNrICYmCi0Jc2V0X2Zha2VfZWRpdG9yICYmCi0JRkFLRV9MSU5FUz0iMiAxIiBnaXQgcmViYXNlIC1pIEhFQUR+MiBIRUFEXjAgJiYKKwkoCisJCXNldF9mYWtlX2VkaXRvciAmJgorCQlGQUtFX0xJTkVTPSIyIDEiIGdpdCByZWJhc2UgLWkgSEVBRH4yIEhFQUReMAorCSkgJiYKIAl0ZXN0ICRncmFuZHBhcmVudCA9ICQoZ2l0IHJldi1wYXJzZSBIRUFEfjIpICYmCiAJdGVzdF9tdXN0X2ZhaWwgZ2l0IHN5bWJvbGljLXJlZiBIRUFECiAnCkBAIC04MjMsNyArODc3LDYgQEAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2Fsd2F5cyBjaGVycnktcGljayB3aXRoIC0tbm8tZmYnICcKIAlnaXQgY2hlY2tvdXQgbm8tZmYtYnJhbmNoICYmCiAJZ2l0IHRhZyBvcmlnaW5hbC1uby1mZi1icmFuY2ggJiYKLQlzZXRfZmFrZV9lZGl0b3IgJiYKIAlnaXQgcmViYXNlIC1pIC0tbm8tZmYgQSAmJgogCWZvciBwIGluIDAgMSAyCiAJZG8KQEAgLTg1NSw4ICs5MDgsMTAgQEAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3JlYmFzZS1pIGhpc3Rvcnkgd2l0aCBmdW5ueSBtZXNzYWdlcycgJwogCWdpdCByZXYtbGlzdCBBLi5mdW5ueSA+ZXhwZWN0ICYmCiAJdGVzdF90aWNrICYmCi0Jc2V0X2Zha2VfZWRpdG9yICYmCi0JRkFLRV9MSU5FUz0iMSAyIDMgNCIgZ2l0IHJlYmFzZSAtaSBBICYmCisJKAorCQlzZXRfZmFrZV9lZGl0b3IgJiYKKwkJRkFLRV9MSU5FUz0iMSAyIDMgNCIgZ2l0IHJlYmFzZSAtaSBBCisJKSAmJgogCWdpdCByZXYtbGlzdCBBLi4gPmFjdHVhbCAmJgogCXRlc3RfY21wIGV4cGVjdCBhY3R1YWwKICcKQEAgLTg3MCw5ICs5MjUsOSBAQAogJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdydW5uaW5nICJnaXQgcmViYXNlIC1pIC0tZXhlYyBnaXQgc2hvdyBIRUFEIicgJwotCXNldF9mYWtlX2VkaXRvciAmJgotCWdpdCByZWJhc2UgLWkgLS1leGVjICJnaXQgc2hvdyBIRUFEIiBIRUFEfjIgPmFjdHVhbCAmJgogCSgKKwkJc2V0X2Zha2VfZWRpdG9yICYmCisJCWdpdCByZWJhc2UgLWkgLS1leGVjICJnaXQgc2hvdyBIRUFEIiBIRUFEfjIgPmFjdHVhbCAmJgogCQlGQUtFX0xJTkVTPSIxIGV4ZWNfZ2l0X3Nob3dfSEVBRCAyIGV4ZWNfZ2l0X3Nob3dfSEVBRCIgJiYKIAkJZXhwb3J0IEZBS0VfTElORVMgJiYKIAkJZ2l0IHJlYmFzZSAtaSBIRUFEfjIgPmV4cGVjdApAQCAtODgzLDkgKzkzOCw5IEBACiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3J1bm5pbmcgImdpdCByZWJhc2UgLS1leGVjIGdpdCBzaG93IEhFQUQgLWkiJyAnCiAJZ2l0IHJlc2V0IC0taGFyZCBleGVjdXRlICYmCi0Jc2V0X2Zha2VfZWRpdG9yICYmCi0JZ2l0IHJlYmFzZSAtLWV4ZWMgImdpdCBzaG93IEhFQUQiIC1pIEhFQUR+MiA+YWN0dWFsICYmCiAJKAorCQlzZXRfZmFrZV9lZGl0b3IgJiYKKwkJZ2l0IHJlYmFzZSAtLWV4ZWMgImdpdCBzaG93IEhFQUQiIC1pIEhFQUR+MiA+YWN0dWFsICYmCiAJCUZBS0VfTElORVM9IjEgZXhlY19naXRfc2hvd19IRUFEIDIgZXhlY19naXRfc2hvd19IRUFEIiAmJgogCQlleHBvcnQgRkFLRV9MSU5FUyAmJgogCQlnaXQgcmViYXNlIC1pIEhFQUR+MiA+ZXhwZWN0CkBAIC04OTYsOSArOTUxLDkgQEAKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAncnVubmluZyAiZ2l0IHJlYmFzZSAtaXggZ2l0IHNob3cgSEVBRCInICcKIAlnaXQgcmVzZXQgLS1oYXJkIGV4ZWN1dGUgJiYKLQlzZXRfZmFrZV9lZGl0b3IgJiYKLQlnaXQgcmViYXNlIC1peCAiZ2l0IHNob3cgSEVBRCIgSEVBRH4yID5hY3R1YWwgJiYKIAkoCisJCXNldF9mYWtlX2VkaXRvciAmJgorCQlnaXQgcmViYXNlIC1peCAiZ2l0IHNob3cgSEVBRCIgSEVBRH4yID5hY3R1YWwgJiYKIAkJRkFLRV9MSU5FUz0iMSBleGVjX2dpdF9zaG93X0hFQUQgMiBleGVjX2dpdF9zaG93X0hFQUQiICYmCiAJCWV4cG9ydCBGQUtFX0xJTkVTICYmCiAJCWdpdCByZWJhc2UgLWkgSEVBRH4yID5leHBlY3QKQEAgLTkxMCw5ICs5NjUsOSBAQAogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdyZWJhc2UgLWl4IHdpdGggc2V2ZXJhbCA8Q01EPicgJwogCWdpdCByZXNldCAtLWhhcmQgZXhlY3V0ZSAmJgotCXNldF9mYWtlX2VkaXRvciAmJgotCWdpdCByZWJhc2UgLWl4ICJnaXQgc2hvdyBIRUFEOyBwd2QiIEhFQUR+MiA+YWN0dWFsICYmCiAJKAorCQlzZXRfZmFrZV9lZGl0b3IgJiYKKwkJZ2l0IHJlYmFzZSAtaXggImdpdCBzaG93IEhFQUQ7IHB3ZCIgSEVBRH4yID5hY3R1YWwgJiYKIAkJRkFLRV9MSU5FUz0iMSBleGVjX2dpdF9zaG93X0hFQUQ7X3B3ZCAyIGV4ZWNfZ2l0X3Nob3dfSEVBRDtfcHdkIiAmJgogCQlleHBvcnQgRkFLRV9MSU5FUyAmJgogCQlnaXQgcmViYXNlIC1pIEhFQUR+MiA+ZXhwZWN0CkBAIC05MjMsOSArOTc4LDkgQEAKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAncmViYXNlIC1peCB3aXRoIHNldmVyYWwgaW5zdGFuY2VzIG9mIC0tZXhlYycgJwogCWdpdCByZXNldCAtLWhhcmQgZXhlY3V0ZSAmJgotCXNldF9mYWtlX2VkaXRvciAmJgotCWdpdCByZWJhc2UgLWkgLS1leGVjICJnaXQgc2hvdyBIRUFEIiAtLWV4ZWMgInB3ZCIgSEVBRH4yID5hY3R1YWwgJiYKIAkoCisJCXNldF9mYWtlX2VkaXRvciAmJgorCQlnaXQgcmViYXNlIC1pIC0tZXhlYyAiZ2l0IHNob3cgSEVBRCIgLS1leGVjICJwd2QiIEhFQUR+MiA+YWN0dWFsICYmCiAJCUZBS0VfTElORVM9IjEgZXhlY19naXRfc2hvd19IRUFEIGV4ZWNfcHdkIDIKIAkJCQlleGVjX2dpdF9zaG93X0hFQUQgZXhlY19wd2QiICYmCiAJCWV4cG9ydCBGQUtFX0xJTkVTICYmCkBAIC05NDQsMTMgKzk5OSwxMSBAQAogCWVjaG8gYmlzID5iaXMudHh0ICYmCiAJZ2l0IGFkZCBiaXMudHh0ICYmCiAJZ2l0IGNvbW1pdCAtbSAiZml4dXAhIHR3b19leGVjIiAmJgotCXNldF9mYWtlX2VkaXRvciAmJgotCSgKLQkJZ2l0IGNoZWNrb3V0IC1iIGF1dG9zcXVhc2hfYWN0dWFsICYmCi0JCWdpdCByZWJhc2UgLWkgLS1leGVjICJnaXQgc2hvdyBIRUFEIiAtLWF1dG9zcXVhc2ggSEVBRH40ID5hY3R1YWwKLQkpICYmCisJZ2l0IGNoZWNrb3V0IC1iIGF1dG9zcXVhc2hfYWN0dWFsICYmCisJZ2l0IHJlYmFzZSAtaSAtLWV4ZWMgImdpdCBzaG93IEhFQUQiIC0tYXV0b3NxdWFzaCBIRUFEfjQgPmFjdHVhbCAmJgogCWdpdCBjaGVja291dCBhdXRvc3F1YXNoICYmCiAJKAorCQlzZXRfZmFrZV9lZGl0b3IgJiYKIAkJZ2l0IGNoZWNrb3V0IC1iIGF1dG9zcXVhc2hfZXhwZWN0ZWQgJiYKIAkJRkFLRV9MSU5FUz0iMSBmaXh1cCAzIGZpeHVwIDQgZXhlY19naXRfc2hvd19IRUFEIDIgZXhlY19naXRfc2hvd19IRUFEIiAmJgogCQlleHBvcnQgRkFLRV9MSU5FUyAmJgpAQCAtOTcxLDcgKzEwMjQsNiBAQAogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdyZWJhc2UgLWkgLS1leGVjIHdpdGhvdXQgPENNRD4nICcKIAlnaXQgcmVzZXQgLS1oYXJkIGV4ZWN1dGUgJiYKLQlzZXRfZmFrZV9lZGl0b3IgJiYKIAl0ZXN0X211c3RfZmFpbCBnaXQgcmViYXNlIC1pIC0tZXhlYyAyPmFjdHVhbCAmJgogCXRlc3RfaTE4bmdyZXAgInJlcXVpcmVzIGEgdmFsdWUiIGFjdHVhbCAmJgogCWdpdCBjaGVja291dCBtYXN0ZXIKQEAgLTk3OSw4ICsxMDMxLDEwIEBACiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3JlYmFzZSAtaSAtLXJvb3QgcmUtb3JkZXIgYW5kIGRyb3AgY29tbWl0cycgJwogCWdpdCBjaGVja291dCBFICYmCi0Jc2V0X2Zha2VfZWRpdG9yICYmCi0JRkFLRV9MSU5FUz0iMyAxIDIgNSIgZ2l0IHJlYmFzZSAtaSAtLXJvb3QgJiYKKwkoCisJCXNldF9mYWtlX2VkaXRvciAmJgorCQlGQUtFX0xJTkVTPSIzIDEgMiA1IiBnaXQgcmViYXNlIC1pIC0tcm9vdAorCSkgJiYKIAl0ZXN0IEUgPSAkKGdpdCBjYXQtZmlsZSBjb21taXQgSEVBRCB8IHNlZCAtbmUgXCRwKSAmJgogCXRlc3QgQiA9ICQoZ2l0IGNhdC1maWxlIGNvbW1pdCBIRUFEXiB8IHNlZCAtbmUgXCRwKSAmJgogCXRlc3QgQSA9ICQoZ2l0IGNhdC1maWxlIGNvbW1pdCBIRUFEXl4gfCBzZWQgLW5lIFwkcCkgJiYKQEAgLTk5MywzOSArMTA0Nyw1OSBAQAogCWVjaG8gQiA+ZmlsZTcgJiYKIAlnaXQgYWRkIGZpbGU3ICYmCiAJR0lUX0FVVEhPUl9OQU1FPSJUd2VycCBTbm9nIiBnaXQgY29tbWl0IC1tICJkaWZmZXJlbnQgYXV0aG9yIiAmJgotCXNldF9mYWtlX2VkaXRvciAmJgotCUZBS0VfTElORVM9IjIiIGdpdCByZWJhc2UgLWkgLS1yb290ICYmCisJKAorCQlzZXRfZmFrZV9lZGl0b3IgJiYKKwkJRkFLRV9MSU5FUz0iMiIgZ2l0IHJlYmFzZSAtaSAtLXJvb3QKKwkpICYmCiAJZ2l0IGNhdC1maWxlIGNvbW1pdCBIRUFEIHwgZ3JlcCAtcSAiXmF1dGhvciBUd2VycCBTbm9nIiAmJgogCWdpdCBjYXQtZmlsZSBjb21taXQgSEVBRCB8IGdyZXAgLXEgIl5kaWZmZXJlbnQgYXV0aG9yJCIKICcKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAncmViYXNlIC1pIC0tcm9vdCB0ZW1wb3Jhcnkgc2VudGluZWwgY29tbWl0JyAnCiAJZ2l0IGNoZWNrb3V0IEIgJiYKLQlzZXRfZmFrZV9lZGl0b3IgJiYKLQl0ZXN0X211c3RfZmFpbCBlbnYgRkFLRV9MSU5FUz0iMiIgZ2l0IHJlYmFzZSAtaSAtLXJvb3QgJiYKLQlnaXQgY2F0LWZpbGUgY29tbWl0IEhFQUQgfCBncmVwICJedHJlZSA0YjgyNWRjNjQyY2IiICYmCisJKAorCQlzZXRfZmFrZV9lZGl0b3IgJiYKKwkJdGVzdF9tdXN0X2ZhaWwgZW52IEZBS0VfTElORVM9IjIiIGdpdCByZWJhc2UgLWkgLS1yb290CisJKSAmJgorCWdpdCBjYXQtZmlsZSBjb21taXQgSEVBRCB8IGdyZXAgIl50cmVlICRFTVBUWV9UUkVFIiAmJgogCWdpdCByZWJhc2UgLS1hYm9ydAogJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdyZWJhc2UgLWkgLS1yb290IGZpeHVwIHJvb3QgY29tbWl0JyAnCiAJZ2l0IGNoZWNrb3V0IEIgJiYKLQlzZXRfZmFrZV9lZGl0b3IgJiYKLQlGQUtFX0xJTkVTPSIxIGZpeHVwIDIiIGdpdCByZWJhc2UgLWkgLS1yb290ICYmCisJKAorCQlzZXRfZmFrZV9lZGl0b3IgJiYKKwkJRkFLRV9MSU5FUz0iMSBmaXh1cCAyIiBnaXQgcmViYXNlIC1pIC0tcm9vdAorCSkgJiYKIAl0ZXN0IEEgPSAkKGdpdCBjYXQtZmlsZSBjb21taXQgSEVBRCB8IHNlZCAtbmUgXCRwKSAmJgogCXRlc3QgQiA9ICQoZ2l0IHNob3cgSEVBRDpmaWxlMSkgJiYKIAl0ZXN0IDAgPSAkKGdpdCBjYXQtZmlsZSBjb21taXQgSEVBRCB8IGdyZXAgLWMgXnBhcmVudFwgKQogJwogCi10ZXN0X2V4cGVjdF9zdWNjZXNzICdyZWJhc2UgLWkgLS1yb290IHJld29yZCByb290IGNvbW1pdCcgJwordGVzdF9leHBlY3Rfc3VjY2VzcyAncmViYXNlIC1pIC0tcm9vdCByZXdvcmQgb3JpZ2luYWwgcm9vdCBjb21taXQnICcKIAl0ZXN0X3doZW5fZmluaXNoZWQgInRlc3RfbWlnaHRfZmFpbCBnaXQgcmViYXNlIC0tYWJvcnQiICYmCi0JZ2l0IGNoZWNrb3V0IC1iIHJld29yZC1yb290LWJyYW5jaCBtYXN0ZXIgJiYKLQlzZXRfZmFrZV9lZGl0b3IgJiYKLQlGQUtFX0xJTkVTPSJyZXdvcmQgMSAyIiBGQUtFX0NPTU1JVF9NRVNTQUdFPSJBIGNoYW5nZWQiIFwKLQlnaXQgcmViYXNlIC1pIC0tcm9vdCAmJgorCWdpdCBjaGVja291dCAtYiByZXdvcmQtb3JpZ2luYWwtcm9vdC1icmFuY2ggbWFzdGVyICYmCisJKAorCQlzZXRfZmFrZV9lZGl0b3IgJiYKKwkJRkFLRV9MSU5FUz0icmV3b3JkIDEgMiIgRkFLRV9DT01NSVRfTUVTU0FHRT0iQSBjaGFuZ2VkIiBcCisJCQlnaXQgcmViYXNlIC1pIC0tcm9vdAorCSkgJiYKIAlnaXQgc2hvdyBIRUFEXiB8IGdyZXAgIkEgY2hhbmdlZCIgJiYKIAl0ZXN0IC16ICIkKGdpdCBzaG93IC1zIC0tZm9ybWF0PSVwIEhFQUReKSIKICcKIAordGVzdF9leHBlY3Rfc3VjY2VzcyAncmViYXNlIC1pIC0tcm9vdCByZXdvcmQgbmV3IHJvb3QgY29tbWl0JyAnCisJdGVzdF93aGVuX2ZpbmlzaGVkICJ0ZXN0X21pZ2h0X2ZhaWwgZ2l0IHJlYmFzZSAtLWFib3J0IiAmJgorCWdpdCBjaGVja291dCAtYiByZXdvcmQtbm93LXJvb3QtYnJhbmNoIG1hc3RlciAmJgorCSgKKwkJc2V0X2Zha2VfZWRpdG9yICYmCisJCUZBS0VfTElORVM9InJld29yZCAzIDEiIEZBS0VfQ09NTUlUX01FU1NBR0U9IkMgY2hhbmdlZCIgXAorCQlnaXQgcmViYXNlIC1pIC0tcm9vdAorCSkgJiYKKwlnaXQgc2hvdyBIRUFEXiB8IGdyZXAgIkMgY2hhbmdlZCIgJiYKKwl0ZXN0IC16ICIkKGdpdCBzaG93IC1zIC0tZm9ybWF0PSVwIEhFQUReKSIKKycKKwogdGVzdF9leHBlY3Rfc3VjY2VzcyAncmViYXNlIC1pIC0tcm9vdCB3aGVuIHJvb3QgaGFzIHVudHJhY2tlZCBmaWxlIGNvbmZsaWN0JyAnCiAJdGVzdF93aGVuX2ZpbmlzaGVkICJyZXNldF9yZWJhc2UiICYmCiAJZ2l0IGNoZWNrb3V0IC1iIGZhaWxpbmctcm9vdC1waWNrIEEgJiYKQEAgLTEwMzMsOCArMTEwNywxMCBAQAogCWdpdCBybSBmaWxlMSAmJgogCWdpdCBjb21taXQgLW0gInJlbW92ZSBmaWxlIDEgYWRkIGZpbGUgMiIgJiYKIAllY2hvIHogPmZpbGUxICYmCi0Jc2V0X2Zha2VfZWRpdG9yICYmCi0JdGVzdF9tdXN0X2ZhaWwgZW52IEZBS0VfTElORVM9IjEgMiIgZ2l0IHJlYmFzZSAtaSAtLXJvb3QgJiYKKwkoCisJCXNldF9mYWtlX2VkaXRvciAmJgorCQl0ZXN0X211c3RfZmFpbCBlbnYgRkFLRV9MSU5FUz0iMSAyIiBnaXQgcmViYXNlIC1pIC0tcm9vdAorCSkgJiYKIAlybSBmaWxlMSAmJgogCWdpdCByZWJhc2UgLS1jb250aW51ZSAmJgogCXRlc3QgIiQoZ2l0IGxvZyAtMSAtLWZvcm1hdD0lQikiID0gInJlbW92ZSBmaWxlIDEgYWRkIGZpbGUgMiIgJiYKQEAgLTEwNDQsMzIgKzExMjAsMzggQEAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3JlYmFzZSAtaSAtLXJvb3QgcmV3b3JkIHJvb3Qgd2hlbiByb290IGhhcyB1bnRyYWNrZWQgZmlsZSBjb25mbGljdCcgJwogCXRlc3Rfd2hlbl9maW5pc2hlZCAicmVzZXRfcmViYXNlIiAmJgogCWVjaG8gej5maWxlMSAmJgotCXNldF9mYWtlX2VkaXRvciAmJgotCXRlc3RfbXVzdF9mYWlsIGVudiBGQUtFX0xJTkVTPSJyZXdvcmQgMSAyIiBcCi0JCUZBS0VfQ09NTUlUX01FU1NBR0U9Ik1vZGlmaWVkIEEiIGdpdCByZWJhc2UgLWkgLS1yb290ICYmCi0Jcm0gZmlsZTEgJiYKLQlGQUtFX0NPTU1JVF9NRVNTQUdFPSJSZXdvcmRlZCBBIiBnaXQgcmViYXNlIC0tY29udGludWUgJiYKKwkoCisJCXNldF9mYWtlX2VkaXRvciAmJgorCQl0ZXN0X211c3RfZmFpbCBlbnYgRkFLRV9MSU5FUz0icmV3b3JkIDEgMiIgXAorCQkJRkFLRV9DT01NSVRfTUVTU0FHRT0iTW9kaWZpZWQgQSIgZ2l0IHJlYmFzZSAtaSAtLXJvb3QgJiYKKwkJcm0gZmlsZTEgJiYKKwkJRkFLRV9DT01NSVRfTUVTU0FHRT0iUmV3b3JkZWQgQSIgZ2l0IHJlYmFzZSAtLWNvbnRpbnVlCisJKSAmJgogCXRlc3QgIiQoZ2l0IGxvZyAtMSAtLWZvcm1hdD0lQiBIRUFEXikiID0gIlJld29yZGVkIEEiICYmCiAJdGVzdCAiJChnaXQgcmV2LWxpc3QgLS1jb3VudCBIRUFEKSIgPSAyCiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgQ19MT0NBTEVfT1VUUFVUICdyZWJhc2UgLS1lZGl0LXRvZG8gZG9lcyBub3Qgd29yayBvbiBub24taW50ZXJhY3RpdmUgcmViYXNlJyAnCi0JZ2l0IGNoZWNrb3V0IHJld29yZC1yb290LWJyYW5jaCAmJgorCWdpdCBjaGVja291dCByZXdvcmQtb3JpZ2luYWwtcm9vdC1icmFuY2ggJiYKIAlnaXQgcmVzZXQgLS1oYXJkICYmCiAJZ2l0IGNoZWNrb3V0IGNvbmZsaWN0LWJyYW5jaCAmJgotCXNldF9mYWtlX2VkaXRvciAmJgotCXRlc3RfbXVzdF9mYWlsIGdpdCByZWJhc2UgLS1vbnRvIEhFQUR+MiBIRUFEfiAmJgotCXRlc3RfbXVzdF9mYWlsIGdpdCByZWJhc2UgLS1lZGl0LXRvZG8gJiYKKwkoCisJCXNldF9mYWtlX2VkaXRvciAmJgorCQl0ZXN0X211c3RfZmFpbCBnaXQgcmViYXNlIC1mIC0tb250byBIRUFEfjIgSEVBRH4gJiYKKwkJdGVzdF9tdXN0X2ZhaWwgZ2l0IHJlYmFzZSAtLWVkaXQtdG9kbworCSkgJiYKIAlnaXQgcmViYXNlIC0tYWJvcnQKICcKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAncmViYXNlIC0tZWRpdC10b2RvIGNhbiBiZSB1c2VkIHRvIG1vZGlmeSB0b2RvJyAnCiAJZ2l0IHJlc2V0IC0taGFyZCAmJgogCWdpdCBjaGVja291dCBuby1jb25mbGljdC1icmFuY2heMCAmJgotCXNldF9mYWtlX2VkaXRvciAmJgotCUZBS0VfTElORVM9ImVkaXQgMSAyIDMiIGdpdCByZWJhc2UgLWkgSEVBRH4zICYmCi0JRkFLRV9MSU5FUz0iMiAxIiBnaXQgcmViYXNlIC0tZWRpdC10b2RvICYmCi0JZ2l0IHJlYmFzZSAtLWNvbnRpbnVlICYmCisJKAorCQlzZXRfZmFrZV9lZGl0b3IgJiYKKwkJRkFLRV9MSU5FUz0iZWRpdCAxIDIgMyIgZ2l0IHJlYmFzZSAtaSBIRUFEfjMgJiYKKwkJRkFLRV9MSU5FUz0iMiAxIiBnaXQgcmViYXNlIC0tZWRpdC10b2RvICYmCisJCWdpdCByZWJhc2UgLS1jb250aW51ZQorCSkgJiYKIAl0ZXN0IE0gPSAkKGdpdCBjYXQtZmlsZSBjb21taXQgSEVBRF4gfCBzZWQgLW5lIFwkcCkgJiYKIAl0ZXN0IEwgPSAkKGdpdCBjYXQtZmlsZSBjb21taXQgSEVBRCB8IHNlZCAtbmUgXCRwKQogJwpAQCAtMTA3Nyw3ICsxMTU5LDYgQEAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3JlYmFzZSAtaSBwcm9kdWNlcyByZWFkYWJsZSByZWZsb2cnICcKIAlnaXQgcmVzZXQgLS1oYXJkICYmCiAJZ2l0IGJyYW5jaCAtZiBicmFuY2gtcmVmbG9nLXRlc3QgSCAmJgotCXNldF9mYWtlX2VkaXRvciAmJgogCWdpdCByZWJhc2UgLWkgLS1vbnRvIEkgRiBicmFuY2gtcmVmbG9nLXRlc3QgJiYKIAljYXQgPmV4cGVjdCA8PC1cRU9GICYmCiAJcmViYXNlIC1pIChmaW5pc2gpOiByZXR1cm5pbmcgdG8gcmVmcy9oZWFkcy9icmFuY2gtcmVmbG9nLXRlc3QKQEAgLTEwOTgsOCArMTE3OSwxMCBAQAogCXNlZCAtZSAiMixcJHMvXi9cXFxcLyIgIiQxIiA+IiQxLnRtcCIgJiYKIAltdiAiJDEudG1wIiAiJDEiCiAJRU9GCi0JdGVzdF9zZXRfZWRpdG9yICIkKHB3ZCkvcmVtb3ZlLWFsbC1idXQtZmlyc3Quc2giICYmCi0JZ2l0IHJlYmFzZSAtaSBCICYmCisJKAorCQl0ZXN0X3NldF9lZGl0b3IgIiQocHdkKS9yZW1vdmUtYWxsLWJ1dC1maXJzdC5zaCIgJiYKKwkJZ2l0IHJlYmFzZSAtaSBCCisJKSAmJgogCXRlc3QgQiA9ICQoZ2l0IGNhdC1maWxlIGNvbW1pdCBIRUFEXiB8IHNlZCAtbmUgXCRwKQogJwogCkBAIC0xMTA4LDkgKzExOTEsMTEgQEAKIAl3cml0ZV9zY3JpcHQgY29weS1lZGl0LXNjcmlwdC5zaCA8PC1cRU9GICYmCiAJY3AgIiQxIiBlZGl0LXNjcmlwdAogCUVPRgotCXRlc3Rfc2V0X2VkaXRvciAiJChwd2QpL2NvcHktZWRpdC1zY3JpcHQuc2giICYmCiAJdGVzdF93aGVuX2ZpbmlzaGVkICJnaXQgcmViYXNlIC0tYWJvcnQgfHwgOiIgJiYKLQlnaXQgcmViYXNlIC1pIEhFQUReICYmCisJKAorCQl0ZXN0X3NldF9lZGl0b3IgIiQocHdkKS9jb3B5LWVkaXQtc2NyaXB0LnNoIiAmJgorCQlnaXQgcmViYXNlIC1pIEhFQUReCisJKSAmJgogCXRlc3QgLXogIiQoZ3JlcCAtdmUgIl4jIiAtZSAiXlwkIiAtZSAiXnBpY2siIGVkaXQtc2NyaXB0KSIKICcKIApAQCAtMTE0NSw4ICsxMjMwLDExIEBACiAJZWNobyBmaXZlID5jb25mbGljdCAmJgogCWVjaG8gWiA+ZmlsZTEgJiYKIAlnaXQgY29tbWl0IC1hIC1tICJvbmUgZmlsZSBjb25mbGljdCIgJiYKLQlzZXRfZmFrZV9lZGl0b3IgJiYKLQlGQUtFX0xJTkVTPSJlZGl0IDEgMiIgZ2l0IHJlYmFzZSAtaSAtLXN0cmF0ZWd5PXJlY3Vyc2l2ZSAtWG91cnMgY29uZmxpY3QtYnJhbmNoICYmCisJKAorCQlzZXRfZmFrZV9lZGl0b3IgJiYKKwkJRkFLRV9MSU5FUz0iZWRpdCAxIDIiIGdpdCByZWJhc2UgLWkgLS1zdHJhdGVneT1yZWN1cnNpdmUgXAorCQkJLVhvdXJzIGNvbmZsaWN0LWJyYW5jaAorCSkgJiYKIAlnaXQgcmViYXNlIC0tY29udGludWUgJiYKIAl0ZXN0ICQoZ2l0IHNob3cgY29uZmxpY3QtYnJhbmNoOmNvbmZsaWN0KSA9ICQoY2F0IGNvbmZsaWN0KSAmJgogCXRlc3QgJChjYXQgZmlsZTEpID0gWgpAQCAtMTE2MSw3ICsxMjQ5LDcgQEAKIAl0ZXN0X2V4cGVjdF9jb2RlIDEgZ3JlcCAgIgllbXAiIGVycm9yCiAnCiAKLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3Nob3J0IFNIQS0xIHNldHVwJyAnCit0ZXN0X2V4cGVjdF9zdWNjZXNzIFNIQTEgJ3Nob3J0IFNIQS0xIHNldHVwJyAnCiAJdGVzdF93aGVuX2ZpbmlzaGVkICJnaXQgY2hlY2tvdXQgbWFzdGVyIiAmJgogCWdpdCBjaGVja291dCAtLW9ycGhhbiBjb2xsaWRlICYmCiAJZ2l0IHJtIC1yZiAuICYmCkBAIC0xMTczLDcgKzEyNjEsNyBAQAogCSkKICcKIAotdGVzdF9leHBlY3Rfc3VjY2VzcyAnc2hvcnQgU0hBLTEgY29sbGlkZScgJwordGVzdF9leHBlY3Rfc3VjY2VzcyBTSEExICdzaG9ydCBTSEEtMSBjb2xsaWRlJyAnCiAJdGVzdF93aGVuX2ZpbmlzaGVkICJyZXNldF9yZWJhc2UgJiYgZ2l0IGNoZWNrb3V0IG1hc3RlciIgJiYKIAlnaXQgY2hlY2tvdXQgY29sbGlkZSAmJgogCSgKQEAgLTExODcsOCArMTI3NSwxMCBAQAogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdyZXNwZWN0IGNvcmUuYWJicmV2JyAnCiAJZ2l0IGNvbmZpZyBjb3JlLmFiYnJldiAxMiAmJgotCXNldF9jYXRfdG9kb19lZGl0b3IgJiYKLQl0ZXN0X211c3RfZmFpbCBnaXQgcmViYXNlIC1pIEhFQUR+NCA+dG9kby1saXN0ICYmCisJKAorCQlzZXRfY2F0X3RvZG9fZWRpdG9yICYmCisJCXRlc3RfbXVzdF9mYWlsIGdpdCByZWJhc2UgLWkgSEVBRH40ID50b2RvLWxpc3QKKwkpICYmCiAJdGVzdCA0ID0gJChncmVwIC1jICJwaWNrIFswLTlhLWZdXHsxMixcfSIgdG9kby1saXN0KQogJwogCkBAIC0xMTk2LDE2ICsxMjg2LDIwIEBACiAJd3JpdGVfc2NyaXB0IGR1bXAtcmF3LnNoIDw8LVxFT0YgJiYKIAkJY2F0ICIkMSIKIAlFT0YKLQl0ZXN0X3NldF9lZGl0b3IgIiQocHdkKS9kdW1wLXJhdy5zaCIgJiYKLQlnaXQgcmViYXNlIC1pIEhFQUR+NCA+YWN0dWFsICYmCisJKAorCQl0ZXN0X3NldF9lZGl0b3IgIiQocHdkKS9kdW1wLXJhdy5zaCIgJiYKKwkJZ2l0IHJlYmFzZSAtaSBIRUFEfjQgPmFjdHVhbAorCSkgJiYKIAl0ZXN0X2kxOG5ncmVwICJeIyBSZWJhc2UgLi4qIG9udG8gLi4qIChbMC05XSIgYWN0dWFsCiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3JlYmFzZSAtaSBjb21taXRzIHRoYXQgb3ZlcndyaXRlIHVudHJhY2tlZCBmaWxlcyAocGljayknICcKIAlnaXQgY2hlY2tvdXQgLS1mb3JjZSBicmFuY2gyICYmCiAJZ2l0IGNsZWFuIC1mICYmCi0Jc2V0X2Zha2VfZWRpdG9yICYmCi0JRkFLRV9MSU5FUz0iZWRpdCAxIDIiIGdpdCByZWJhc2UgLWkgQSAmJgorCSgKKwkJc2V0X2Zha2VfZWRpdG9yICYmCisJCUZBS0VfTElORVM9ImVkaXQgMSAyIiBnaXQgcmViYXNlIC1pIEEKKwkpICYmCiAJdGVzdF9jbXBfcmV2IEhFQUQgRiAmJgogCXRlc3RfcGF0aF9pc19taXNzaW5nIGZpbGU2ICYmCiAJPmZpbGU2ICYmCkBAIC0xMjIwLDggKzEzMTQsMTAgQEAKIAlnaXQgY2hlY2tvdXQgLS1mb3JjZSBicmFuY2gyICYmCiAJZ2l0IGNsZWFuIC1mICYmCiAJZ2l0IHRhZyBvcmlnaW5hbC1icmFuY2gyICYmCi0Jc2V0X2Zha2VfZWRpdG9yICYmCi0JRkFLRV9MSU5FUz0iZWRpdCAxIHNxdWFzaCAyIiBnaXQgcmViYXNlIC1pIEEgJiYKKwkoCisJCXNldF9mYWtlX2VkaXRvciAmJgorCQlGQUtFX0xJTkVTPSJlZGl0IDEgc3F1YXNoIDIiIGdpdCByZWJhc2UgLWkgQQorCSkgJiYKIAl0ZXN0X2NtcF9yZXYgSEVBRCBGICYmCiAJdGVzdF9wYXRoX2lzX21pc3NpbmcgZmlsZTYgJiYKIAk+ZmlsZTYgJiYKQEAgLTEyMzYsOCArMTMzMiwxMCBAQAogdGVzdF9leHBlY3Rfc3VjY2VzcyAncmViYXNlIC1pIGNvbW1pdHMgdGhhdCBvdmVyd3JpdGUgdW50cmFja2VkIGZpbGVzIChubyBmZiknICcKIAlnaXQgY2hlY2tvdXQgLS1mb3JjZSBicmFuY2gyICYmCiAJZ2l0IGNsZWFuIC1mICYmCi0Jc2V0X2Zha2VfZWRpdG9yICYmCi0JRkFLRV9MSU5FUz0iZWRpdCAxIDIiIGdpdCByZWJhc2UgLWkgLS1uby1mZiBBICYmCisJKAorCQlzZXRfZmFrZV9lZGl0b3IgJiYKKwkJRkFLRV9MSU5FUz0iZWRpdCAxIDIiIGdpdCByZWJhc2UgLWkgLS1uby1mZiBBCisJKSAmJgogCXRlc3QgJChnaXQgY2F0LWZpbGUgY29tbWl0IEhFQUQgfCBzZWQgLW5lIFwkcCkgPSBGICYmCiAJdGVzdF9wYXRoX2lzX21pc3NpbmcgZmlsZTYgJiYKIAk+ZmlsZTYgJiYKQEAgLTEyNjAsOCArMTM1OCwxMCBAQAogCWdpdCB0YWcgc2VxLW9udG8gJiYKIAlnaXQgcmVzZXQgLS1oYXJkIEhFQUR+MiAmJgogCWdpdCBjaGVycnktcGljayBzZXEtb250byAmJgotCXNldF9mYWtlX2VkaXRvciAmJgotCXRlc3RfbXVzdF9mYWlsIGVudiBGQUtFX0xJTkVTPSBnaXQgcmViYXNlIC1pIHNlcS1vbnRvICYmCisJKAorCQlzZXRfZmFrZV9lZGl0b3IgJiYKKwkJdGVzdF9tdXN0X2ZhaWwgZW52IEZBS0VfTElORVM9IGdpdCByZWJhc2UgLWkgc2VxLW9udG8KKwkpICYmCiAJdGVzdCAtZCAuZ2l0L3JlYmFzZS1tZXJnZSAmJgogCWdpdCByZWJhc2UgLS1jb250aW51ZSAmJgogCWdpdCBkaWZmIC0tZXhpdC1jb2RlIHNlcS1vbnRvICYmCkBAIC0xMjgwLDggKzEzODAsMTAgQEAKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnZHJvcCcgJwogCXJlYmFzZV9zZXR1cF9hbmRfY2xlYW4gZHJvcC10ZXN0ICYmCi0Jc2V0X2Zha2VfZWRpdG9yICYmCi0JRkFLRV9MSU5FUz0iMSBkcm9wIDIgMyBkIDQgNSIgZ2l0IHJlYmFzZSAtaSAtLXJvb3QgJiYKKwkoCisJCXNldF9mYWtlX2VkaXRvciAmJgorCQlGQUtFX0xJTkVTPSIxIGRyb3AgMiAzIGQgNCA1IiBnaXQgcmViYXNlIC1pIC0tcm9vdAorCSkgJiYKIAl0ZXN0IEUgPSAkKGdpdCBjYXQtZmlsZSBjb21taXQgSEVBRCB8IHNlZCAtbmUgXCRwKSAmJgogCXRlc3QgQyA9ICQoZ2l0IGNhdC1maWxlIGNvbW1pdCBIRUFEXiB8IHNlZCAtbmUgXCRwKSAmJgogCXRlc3QgQSA9ICQoZ2l0IGNhdC1maWxlIGNvbW1pdCBIRUFEXl4gfCBzZWQgLW5lIFwkcCkKQEAgLTEyOTAsOSArMTM5MiwxMCBAQAogdGVzdF9leHBlY3Rfc3VjY2VzcyAncmViYXNlIC1pIHJlc3BlY3RzIHJlYmFzZS5taXNzaW5nQ29tbWl0c0NoZWNrID0gaWdub3JlJyAnCiAJdGVzdF9jb25maWcgcmViYXNlLm1pc3NpbmdDb21taXRzQ2hlY2sgaWdub3JlICYmCiAJcmViYXNlX3NldHVwX2FuZF9jbGVhbiBtaXNzaW5nLWNvbW1pdCAmJgotCXNldF9mYWtlX2VkaXRvciAmJgotCUZBS0VfTElORVM9IjEgMiAzIDQiIFwKLQkJZ2l0IHJlYmFzZSAtaSAtLXJvb3QgMj5hY3R1YWwgJiYKKwkoCisJCXNldF9mYWtlX2VkaXRvciAmJgorCQlGQUtFX0xJTkVTPSIxIDIgMyA0IiBnaXQgcmViYXNlIC1pIC0tcm9vdCAyPmFjdHVhbAorCSkgJiYKIAl0ZXN0IEQgPSAkKGdpdCBjYXQtZmlsZSBjb21taXQgSEVBRCB8IHNlZCAtbmUgXCRwKSAmJgogCXRlc3RfaTE4bmdyZXAgXAogCQkiU3VjY2Vzc2Z1bGx5IHJlYmFzZWQgYW5kIHVwZGF0ZWQgcmVmcy9oZWFkcy9taXNzaW5nLWNvbW1pdCIgXApAQCAtMTMwOCw5ICsxNDExLDEwIEBACiAJRU9GCiAJdGVzdF9jb25maWcgcmViYXNlLm1pc3NpbmdDb21taXRzQ2hlY2sgd2FybiAmJgogCXJlYmFzZV9zZXR1cF9hbmRfY2xlYW4gbWlzc2luZy1jb21taXQgJiYKLQlzZXRfZmFrZV9lZGl0b3IgJiYKLQlGQUtFX0xJTkVTPSIxIDIgMyA0IiBcCi0JCWdpdCByZWJhc2UgLWkgLS1yb290IDI+YWN0dWFsLjIgJiYKKwkoCisJCXNldF9mYWtlX2VkaXRvciAmJgorCQlGQUtFX0xJTkVTPSIxIDIgMyA0IiBnaXQgcmViYXNlIC1pIC0tcm9vdCAyPmFjdHVhbC4yCisJKSAmJgogCWhlYWQgLW40IGFjdHVhbC4yID5hY3R1YWwgJiYKIAl0ZXN0X2kxOG5jbXAgZXhwZWN0IGFjdHVhbCAmJgogCXRlc3QgRCA9ICQoZ2l0IGNhdC1maWxlIGNvbW1pdCBIRUFEIHwgc2VkIC1uZSBcJHApCkBAIC0xMzMyLDE0ICsxNDM2LDE1IEBACiAJRU9GCiAJdGVzdF9jb25maWcgcmViYXNlLm1pc3NpbmdDb21taXRzQ2hlY2sgZXJyb3IgJiYKIAlyZWJhc2Vfc2V0dXBfYW5kX2NsZWFuIG1pc3NpbmctY29tbWl0ICYmCi0Jc2V0X2Zha2VfZWRpdG9yICYmCi0JdGVzdF9tdXN0X2ZhaWwgZW52IEZBS0VfTElORVM9IjEgMiA0IiBcCi0JCWdpdCByZWJhc2UgLWkgLS1yb290IDI+YWN0dWFsICYmCi0JdGVzdF9pMThuY21wIGV4cGVjdCBhY3R1YWwgJiYKLQljcCAuZ2l0L3JlYmFzZS1tZXJnZS9naXQtcmViYXNlLXRvZG8uYmFja3VwIFwKLQkJLmdpdC9yZWJhc2UtbWVyZ2UvZ2l0LXJlYmFzZS10b2RvICYmCi0JRkFLRV9MSU5FUz0iMSAyIGRyb3AgMyA0IGRyb3AgNSIgXAotCQlnaXQgcmViYXNlIC0tZWRpdC10b2RvICYmCisJKAorCQlzZXRfZmFrZV9lZGl0b3IgJiYKKwkJdGVzdF9tdXN0X2ZhaWwgZW52IEZBS0VfTElORVM9IjEgMiA0IiBcCisJCQlnaXQgcmViYXNlIC1pIC0tcm9vdCAyPmFjdHVhbCAmJgorCQl0ZXN0X2kxOG5jbXAgZXhwZWN0IGFjdHVhbCAmJgorCQljcCAuZ2l0L3JlYmFzZS1tZXJnZS9naXQtcmViYXNlLXRvZG8uYmFja3VwIFwKKwkJCS5naXQvcmViYXNlLW1lcmdlL2dpdC1yZWJhc2UtdG9kbyAmJgorCQlGQUtFX0xJTkVTPSIxIDIgZHJvcCAzIDQgZHJvcCA1IiBnaXQgcmViYXNlIC0tZWRpdC10b2RvCisJKSAmJgogCWdpdCByZWJhc2UgLS1jb250aW51ZSAmJgogCXRlc3QgRCA9ICQoZ2l0IGNhdC1maWxlIGNvbW1pdCBIRUFEIHwgc2VkIC1uZSBcJHApICYmCiAJdGVzdCBCID0gJChnaXQgY2F0LWZpbGUgY29tbWl0IEhFQUReIHwgc2VkIC1uZSBcJHApCkBAIC0xMzYwLDIxICsxNDY1LDI3IEBACiAJeCBnaXQgc2hvdyBIRUFECiAJRU9GCiAJZ2l0IGNoZWNrb3V0IGFiYnJldmNtZCAmJgotCXNldF9jYXRfdG9kb19lZGl0b3IgJiYKIAl0ZXN0X2NvbmZpZyByZWJhc2UuYWJicmV2aWF0ZUNvbW1hbmRzIHRydWUgJiYKLQl0ZXN0X211c3RfZmFpbCBnaXQgcmViYXNlIC1pIC0tZXhlYyAiZ2l0IHNob3cgSEVBRCIgXAotCQktLWF1dG9zcXVhc2ggbWFzdGVyID5hY3R1YWwgJiYKKwkoCisJCXNldF9jYXRfdG9kb19lZGl0b3IgJiYKKwkJdGVzdF9tdXN0X2ZhaWwgZ2l0IHJlYmFzZSAtaSAtLWV4ZWMgImdpdCBzaG93IEhFQUQiIFwKKwkJCS0tYXV0b3NxdWFzaCBtYXN0ZXIgPmFjdHVhbAorCSkgJiYKIAl0ZXN0X2NtcCBleHBlY3RlZCBhY3R1YWwKICcKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnc3RhdGljIGNoZWNrIG9mIGJhZCBjb21tYW5kJyAnCiAJcmViYXNlX3NldHVwX2FuZF9jbGVhbiBiYWQtY21kICYmCi0Jc2V0X2Zha2VfZWRpdG9yICYmCi0JdGVzdF9tdXN0X2ZhaWwgZW52IEZBS0VfTElORVM9IjEgMiAzIGJhZCA0IDUiIFwKKwkoCisJCXNldF9mYWtlX2VkaXRvciAmJgorCQl0ZXN0X211c3RfZmFpbCBlbnYgRkFLRV9MSU5FUz0iMSAyIDMgYmFkIDQgNSIgXAogCQlnaXQgcmViYXNlIC1pIC0tcm9vdCAyPmFjdHVhbCAmJgotCXRlc3RfaTE4bmdyZXAgImJhZGNtZCAkKGdpdCByZXYtbGlzdCAtLW9uZWxpbmUgLTEgbWFzdGVyfjEpIiBhY3R1YWwgJiYKLQl0ZXN0X2kxOG5ncmVwICJZb3UgY2FuIGZpeCB0aGlzIHdpdGggLmdpdCByZWJhc2UgLS1lZGl0LXRvZG8uLiIgYWN0dWFsICYmCi0JRkFLRV9MSU5FUz0iMSAyIDMgZHJvcCA0IDUiIGdpdCByZWJhc2UgLS1lZGl0LXRvZG8gJiYKKwkJdGVzdF9pMThuZ3JlcCAiYmFkY21kICQoZ2l0IHJldi1saXN0IC0tb25lbGluZSAtMSBtYXN0ZXJ+MSkiIFwKKwkJCQlhY3R1YWwgJiYKKwkJdGVzdF9pMThuZ3JlcCAiWW91IGNhbiBmaXggdGhpcyB3aXRoIC5naXQgcmViYXNlIC0tZWRpdC10b2RvLi4iIFwKKwkJCQlhY3R1YWwgJiYKKwkJRkFLRV9MSU5FUz0iMSAyIDMgZHJvcCA0IDUiIGdpdCByZWJhc2UgLS1lZGl0LXRvZG8KKwkpICYmCiAJZ2l0IHJlYmFzZSAtLWNvbnRpbnVlICYmCiAJdGVzdCBFID0gJChnaXQgY2F0LWZpbGUgY29tbWl0IEhFQUQgfCBzZWQgLW5lIFwkcCkgJiYKIAl0ZXN0IEMgPSAkKGdpdCBjYXQtZmlsZSBjb21taXQgSEVBRF4gfCBzZWQgLW5lIFwkcCkKQEAgLTEzOTAsMTkgKzE1MDEsMjQgQEAKIAkpID4iJDEubmV3IgogCW12ICIkMS5uZXciICIkMSIKIAlFT0YKLQl0ZXN0X3NldF9lZGl0b3IgIiQocHdkKS9hZGQtaW5kZW50LnNoIiAmJgotCWdpdCByZWJhc2UgLWkgSEVBRF5eXiAmJgorCSgKKwkJdGVzdF9zZXRfZWRpdG9yICIkKHB3ZCkvYWRkLWluZGVudC5zaCIgJiYKKwkJZ2l0IHJlYmFzZSAtaSBIRUFEXl5eCisJKSAmJgogCXRlc3QgRSA9ICQoZ2l0IGNhdC1maWxlIGNvbW1pdCBIRUFEIHwgc2VkIC1uZSBcJHApCiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3N0YXRpYyBjaGVjayBvZiBiYWQgU0hBLTEnICcKIAlyZWJhc2Vfc2V0dXBfYW5kX2NsZWFuIGJhZC1zaGEgJiYKLQlzZXRfZmFrZV9lZGl0b3IgJiYKLQl0ZXN0X211c3RfZmFpbCBlbnYgRkFLRV9MSU5FUz0iMSAyIGVkaXQgZmFrZXNoYSAzIDQgNSAjIiBcCi0JCWdpdCByZWJhc2UgLWkgLS1yb290IDI+YWN0dWFsICYmCi0JdGVzdF9pMThuZ3JlcCAiZWRpdCBYWFhYWFhYIEZhbHNlIGNvbW1pdCIgYWN0dWFsICYmCi0JdGVzdF9pMThuZ3JlcCAiWW91IGNhbiBmaXggdGhpcyB3aXRoIC5naXQgcmViYXNlIC0tZWRpdC10b2RvLi4iIGFjdHVhbCAmJgotCUZBS0VfTElORVM9IjEgMiA0IDUgNiIgZ2l0IHJlYmFzZSAtLWVkaXQtdG9kbyAmJgorCSgKKwkJc2V0X2Zha2VfZWRpdG9yICYmCisJCXRlc3RfbXVzdF9mYWlsIGVudiBGQUtFX0xJTkVTPSIxIDIgZWRpdCBmYWtlc2hhIDMgNCA1ICMiIFwKKwkJCWdpdCByZWJhc2UgLWkgLS1yb290IDI+YWN0dWFsICYmCisJCQl0ZXN0X2kxOG5ncmVwICJlZGl0IFhYWFhYWFggRmFsc2UgY29tbWl0IiBhY3R1YWwgJiYKKwkJCXRlc3RfaTE4bmdyZXAgIllvdSBjYW4gZml4IHRoaXMgd2l0aCAuZ2l0IHJlYmFzZSAtLWVkaXQtdG9kby4uIiBcCisJCQkJCWFjdHVhbCAmJgorCQlGQUtFX0xJTkVTPSIxIDIgNCA1IDYiIGdpdCByZWJhc2UgLS1lZGl0LXRvZG8KKwkpICYmCiAJZ2l0IHJlYmFzZSAtLWNvbnRpbnVlICYmCiAJdGVzdCBFID0gJChnaXQgY2F0LWZpbGUgY29tbWl0IEhFQUQgfCBzZWQgLW5lIFwkcCkKICcKQEAgLTE0MTksNDIgKzE1MzUsNzMgQEAKIAkpCiAnCiAKLVNRPSInIgogdGVzdF9leHBlY3Rfc3VjY2VzcyAncmViYXNlIC1pIC0tZ3BnLXNpZ249PGtleS1pZD4nICcKIAl0ZXN0X3doZW5fZmluaXNoZWQgInRlc3RfbWlnaHRfZmFpbCBnaXQgcmViYXNlIC0tYWJvcnQiICYmCi0Jc2V0X2Zha2VfZWRpdG9yICYmCi0JRkFLRV9MSU5FUz0iZWRpdCAxIiBnaXQgcmViYXNlIC1pIC0tZ3BnLXNpZ249IlwiUyBJIEduZXJcIiIgSEVBRF4gXAotCQk+b3V0IDI+ZXJyICYmCisJKAorCQlzZXRfZmFrZV9lZGl0b3IgJiYKKwkJRkFLRV9MSU5FUz0iZWRpdCAxIiBnaXQgcmViYXNlIC1pIC0tZ3BnLXNpZ249IlwiUyBJIEduZXJcIiIgXAorCQkJSEVBRF4gPm91dCAyPmVycgorCSkgJiYKIAl0ZXN0X2kxOG5ncmVwICIkU1EtU1wiUyBJIEduZXJcIiRTUSIgZXJyCiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3JlYmFzZSAtaSAtLWdwZy1zaWduPTxrZXktaWQ+IG92ZXJyaWRlcyBjb21taXQuZ3BnU2lnbicgJwogCXRlc3Rfd2hlbl9maW5pc2hlZCAidGVzdF9taWdodF9mYWlsIGdpdCByZWJhc2UgLS1hYm9ydCIgJiYKIAl0ZXN0X2NvbmZpZyBjb21taXQuZ3Bnc2lnbiB0cnVlICYmCi0Jc2V0X2Zha2VfZWRpdG9yICYmCi0JRkFLRV9MSU5FUz0iZWRpdCAxIiBnaXQgcmViYXNlIC1pIC0tZ3BnLXNpZ249IlwiUyBJIEduZXJcIiIgSEVBRF4gXAotCQk+b3V0IDI+ZXJyICYmCisJKAorCQlzZXRfZmFrZV9lZGl0b3IgJiYKKwkJRkFLRV9MSU5FUz0iZWRpdCAxIiBnaXQgcmViYXNlIC1pIC0tZ3BnLXNpZ249IlwiUyBJIEduZXJcIiIgXAorCQkJSEVBRF4gPm91dCAyPmVycgorCSkgJiYKIAl0ZXN0X2kxOG5ncmVwICIkU1EtU1wiUyBJIEduZXJcIiRTUSIgZXJyCiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3ZhbGlkIGF1dGhvciBoZWFkZXIgYWZ0ZXIgLS1yb290IHN3YXAnICcKIAlyZWJhc2Vfc2V0dXBfYW5kX2NsZWFuIGF1dGhvci1oZWFkZXIgbm8tY29uZmxpY3QtYnJhbmNoICYmCi0Jc2V0X2Zha2VfZWRpdG9yICYmCiAJZ2l0IGNvbW1pdCAtLWFtZW5kIC0tYXV0aG9yPSJBdSAke1NRfXRob3IgPGF1dGhvckBleGFtcGxlLmNvbT4iIC0tbm8tZWRpdCAmJgogCWdpdCBjYXQtZmlsZSBjb21taXQgSEVBRCB8IGdyZXAgXmF1dGhvciA+ZXhwZWN0ZWQgJiYKLQlGQUtFX0xJTkVTPSI1IDEiIGdpdCByZWJhc2UgLWkgLS1yb290ICYmCisJKAorCQlzZXRfZmFrZV9lZGl0b3IgJiYKKwkJRkFLRV9MSU5FUz0iNSAxIiBnaXQgcmViYXNlIC1pIC0tcm9vdAorCSkgJiYKIAlnaXQgY2F0LWZpbGUgY29tbWl0IEhFQUReIHwgZ3JlcCBeYXV0aG9yID5hY3R1YWwgJiYKIAl0ZXN0X2NtcCBleHBlY3RlZCBhY3R1YWwKICcKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAndmFsaWQgYXV0aG9yIGhlYWRlciB3aGVuIGF1dGhvciBjb250YWlucyBzaW5nbGUgcXVvdGUnICcKIAlyZWJhc2Vfc2V0dXBfYW5kX2NsZWFuIGF1dGhvci1oZWFkZXIgbm8tY29uZmxpY3QtYnJhbmNoICYmCi0Jc2V0X2Zha2VfZWRpdG9yICYmCiAJZ2l0IGNvbW1pdCAtLWFtZW5kIC0tYXV0aG9yPSJBdSAke1NRfXRob3IgPGF1dGhvckBleGFtcGxlLmNvbT4iIC0tbm8tZWRpdCAmJgogCWdpdCBjYXQtZmlsZSBjb21taXQgSEVBRCB8IGdyZXAgXmF1dGhvciA+ZXhwZWN0ZWQgJiYKLQlGQUtFX0xJTkVTPSIyIiBnaXQgcmViYXNlIC1pIEhFQUR+MiAmJgorCSgKKwkJc2V0X2Zha2VfZWRpdG9yICYmCisJCUZBS0VfTElORVM9IjIiIGdpdCByZWJhc2UgLWkgSEVBRH4yCisJKSAmJgogCWdpdCBjYXQtZmlsZSBjb21taXQgSEVBRCB8IGdyZXAgXmF1dGhvciA+YWN0dWFsICYmCiAJdGVzdF9jbXAgZXhwZWN0ZWQgYWN0dWFsCiAnCiAKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3Bvc3QtY29tbWl0IGhvb2sgaXMgY2FsbGVkJyAnCisJdGVzdF93aGVuX2ZpbmlzaGVkICJybSAtZiAuZ2l0L2hvb2tzL3Bvc3QtY29tbWl0IiAmJgorCT5hY3R1YWwgJiYKKwlta2RpciAtcCAuZ2l0L2hvb2tzICYmCisJd3JpdGVfc2NyaXB0IC5naXQvaG9va3MvcG9zdC1jb21taXQgPDwtXEVPUyAmJgorCWdpdCByZXYtcGFyc2UgSEVBRCA+PmFjdHVhbAorCUVPUworCSgKKwkJc2V0X2Zha2VfZWRpdG9yICYmCisJCUZBS0VfTElORVM9ImVkaXQgNCAxIHJld29yZCAyIGZpeHVwIDMiIGdpdCByZWJhc2UgLWkgQSBFICYmCisJCWVjaG8geD5maWxlMyAmJgorCQlnaXQgYWRkIGZpbGUzICYmCisJCUZBS0VfQ09NTUlUX01FU1NBR0U9ZWRpdGVkIGdpdCByZWJhc2UgLS1jb250aW51ZQorCSkgJiYKKwlnaXQgcmV2LXBhcnNlIEhFQURAezV9IEhFQURAezR9IEhFQURAezN9IEhFQURAezJ9IEhFQURAezF9IEhFQUQgXAorCQk+ZXhwZWN0ICYmCisJdGVzdF9jbXAgZXhwZWN0IGFjdHVhbAorJworCisjIFRoaXMgbXVzdCBiZSB0aGUgbGFzdCB0ZXN0IGluIHRoaXMgZmlsZQordGVzdF9leHBlY3Rfc3VjY2VzcyAnJEVESVRPUiBhbmQgZnJpZW5kcyBhcmUgdW5jaGFuZ2VkJyAnCisJdGVzdF9lZGl0b3JfdW5jaGFuZ2VkCisnCisKIHRlc3RfZG9uZQpkaWZmIC0tZ2l0IGEvdC90MzQxNi1yZWJhc2Utb250by10aHJlZWRvdHMuc2ggYi90L3QzNDE2LXJlYmFzZS1vbnRvLXRocmVlZG90cy5zaAppbmRleCBkZGYyZjY0Li45YzI1NDg0IDEwMDc1NQotLS0gYS90L3QzNDE2LXJlYmFzZS1vbnRvLXRocmVlZG90cy5zaAorKysgYi90L3QzNDE2LXJlYmFzZS1vbnRvLXRocmVlZG90cy5zaApAQCAtOTksNyArOTksNjQgQEAKIAlnaXQgY2hlY2tvdXQgc2lkZSAmJgogCWdpdCByZXNldCAtLWhhcmQgSyAmJgogCisJc2V0X2Zha2VfZWRpdG9yICYmCiAJdGVzdF9tdXN0X2ZhaWwgZ2l0IHJlYmFzZSAtaSAtLW9udG8gbWFzdGVyLi4uc2lkZSBKCiAnCiAKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3JlYmFzZSAtLWtlZXAtYmFzZSAtLW9udG8gaW5jb21wYXRpYmxlJyAnCisJdGVzdF9tdXN0X2ZhaWwgZ2l0IHJlYmFzZSAtLWtlZXAtYmFzZSAtLW9udG8gbWFzdGVyLi4uCisnCisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3JlYmFzZSAtLWtlZXAtYmFzZSAtLXJvb3QgaW5jb21wYXRpYmxlJyAnCisJdGVzdF9tdXN0X2ZhaWwgZ2l0IHJlYmFzZSAtLWtlZXAtYmFzZSAtLXJvb3QKKycKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAncmViYXNlIC0ta2VlcC1iYXNlIG1hc3RlciBmcm9tIHRvcGljJyAnCisJZ2l0IHJlc2V0IC0taGFyZCAmJgorCWdpdCBjaGVja291dCB0b3BpYyAmJgorCWdpdCByZXNldCAtLWhhcmQgRyAmJgorCisJZ2l0IHJlYmFzZSAtLWtlZXAtYmFzZSBtYXN0ZXIgJiYKKwlnaXQgcmV2LXBhcnNlIEMgPmJhc2UuZXhwZWN0ICYmCisJZ2l0IG1lcmdlLWJhc2UgbWFzdGVyIEhFQUQgPmJhc2UuYWN0dWFsICYmCisJdGVzdF9jbXAgYmFzZS5leHBlY3QgYmFzZS5hY3R1YWwgJiYKKworCWdpdCByZXYtcGFyc2UgSEVBRH4yID5hY3R1YWwgJiYKKwlnaXQgcmV2LXBhcnNlIENeMCA+ZXhwZWN0ICYmCisJdGVzdF9jbXAgZXhwZWN0IGFjdHVhbAorJworCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdyZWJhc2UgLS1rZWVwLWJhc2UgbWFzdGVyIGZyb20gc2lkZScgJworCWdpdCByZXNldCAtLWhhcmQgJiYKKwlnaXQgY2hlY2tvdXQgc2lkZSAmJgorCWdpdCByZXNldCAtLWhhcmQgSyAmJgorCisJdGVzdF9tdXN0X2ZhaWwgZ2l0IHJlYmFzZSAtLWtlZXAtYmFzZSBtYXN0ZXIKKycKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAncmViYXNlIC1pIC0ta2VlcC1iYXNlIG1hc3RlciBmcm9tIHRvcGljJyAnCisJZ2l0IHJlc2V0IC0taGFyZCAmJgorCWdpdCBjaGVja291dCB0b3BpYyAmJgorCWdpdCByZXNldCAtLWhhcmQgRyAmJgorCisJc2V0X2Zha2VfZWRpdG9yICYmCisJRVhQRUNUX0NPVU5UPTIgZ2l0IHJlYmFzZSAtaSAtLWtlZXAtYmFzZSBtYXN0ZXIgJiYKKwlnaXQgcmV2LXBhcnNlIEMgPmJhc2UuZXhwZWN0ICYmCisJZ2l0IG1lcmdlLWJhc2UgbWFzdGVyIEhFQUQgPmJhc2UuYWN0dWFsICYmCisJdGVzdF9jbXAgYmFzZS5leHBlY3QgYmFzZS5hY3R1YWwgJiYKKworCWdpdCByZXYtcGFyc2UgSEVBRH4yID5hY3R1YWwgJiYKKwlnaXQgcmV2LXBhcnNlIENeMCA+ZXhwZWN0ICYmCisJdGVzdF9jbXAgZXhwZWN0IGFjdHVhbAorJworCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdyZWJhc2UgLWkgLS1rZWVwLWJhc2UgbWFzdGVyIGZyb20gc2lkZScgJworCWdpdCByZXNldCAtLWhhcmQgJiYKKwlnaXQgY2hlY2tvdXQgc2lkZSAmJgorCWdpdCByZXNldCAtLWhhcmQgSyAmJgorCisJc2V0X2Zha2VfZWRpdG9yICYmCisJdGVzdF9tdXN0X2ZhaWwgZ2l0IHJlYmFzZSAtaSAtLWtlZXAtYmFzZSBtYXN0ZXIKKycKKwogdGVzdF9kb25lCmRpZmYgLS1naXQgYS90L3QzNDE4LXJlYmFzZS1jb250aW51ZS5zaCBiL3QvdDM0MTgtcmViYXNlLWNvbnRpbnVlLnNoCmluZGV4IDRlZmYxNGQuLjdhMmRhOTcgMTAwNzU1Ci0tLSBhL3QvdDM0MTgtcmViYXNlLWNvbnRpbnVlLnNoCisrKyBiL3QvdDM0MTgtcmViYXNlLWNvbnRpbnVlLnNoCkBAIC0xMjAsNiArMTIwLDIwIEBACiAJZ2l0IHJlYmFzZSAtLWNvbnRpbnVlCiAnCiAKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3JlYmFzZSAtciBwYXNzZXMgbWVyZ2Ugc3RyYXRlZ3kgb3B0aW9ucyBjb3JyZWN0bHknICcKKwlybSAtZnIgLmdpdC9yZWJhc2UtKiAmJgorCWdpdCByZXNldCAtLWhhcmQgY29tbWl0LW5ldy1maWxlLUYzLW9uLXRvcGljLWJyYW5jaCAmJgorCXRlc3RfY29tbWl0IG1lcmdlLXRoZWlycyAmJgorCWdpdCByZXNldCAtLWhhcmQgSEVBRF4gJiYKKwl0ZXN0X2NvbW1pdCBzb21lLW90aGVyLWNvbW1pdCAmJgorCXRlc3RfdGljayAmJgorCWdpdCBtZXJnZSAtLW5vLWZmIG1lcmdlLXRoZWlycyAmJgorCUZBS0VfTElORVM9IjEgMyBlZGl0IDQgNSA3IDggOSIgZ2l0IHJlYmFzZSAtaSAtZiAtciAtbSBcCisJCS1zIHJlY3Vyc2l2ZSAtLXN0cmF0ZWd5LW9wdGlvbj10aGVpcnMgSEVBRH4yICYmCisJdGVzdF9jb21taXQgZm9yY2UtY2hhbmdlLW91cnMgJiYKKwlnaXQgcmViYXNlIC0tY29udGludWUKKycKKwogdGVzdF9leHBlY3Rfc3VjY2VzcyAnLS1za2lwIGFmdGVyIGZhaWxlZCBmaXh1cCBjbGVhbnMgY29tbWl0IG1lc3NhZ2UnICcKIAl0ZXN0X3doZW5fZmluaXNoZWQgInRlc3RfbWlnaHRfZmFpbCBnaXQgcmViYXNlIC0tYWJvcnQiICYmCiAJZ2l0IGNoZWNrb3V0IC1iIHdpdGgtY29uZmxpY3RpbmctZml4dXAgJiYKZGlmZiAtLWdpdCBhL3QvdDM0MjAtcmViYXNlLWF1dG9zdGFzaC5zaCBiL3QvdDM0MjAtcmViYXNlLWF1dG9zdGFzaC5zaAppbmRleCBiOGY0ZDAzLi41ZjdlNzNjIDEwMDc1NQotLS0gYS90L3QzNDIwLXJlYmFzZS1hdXRvc3Rhc2guc2gKKysrIGIvdC90MzQyMC1yZWJhc2UtYXV0b3N0YXNoLnNoCkBAIC0zNyw3ICszNyw2IEBACiBjcmVhdGVfZXhwZWN0ZWRfc3VjY2Vzc19hbSAoKSB7CiAJY2F0ID5leHBlY3RlZCA8PC1FT0YKIAkkKGdyZXAgIl5DcmVhdGVkIGF1dG9zdGFzaDogWzAtOWEtZl1bMC05YS1mXSpcJCIgYWN0dWFsKQotCUhFQUQgaXMgbm93IGF0ICQoZ2l0IHJldi1wYXJzZSAtLXNob3J0IGZlYXR1cmUtYnJhbmNoKSB0aGlyZCBjb21taXQKIAlGaXJzdCwgcmV3aW5kaW5nIGhlYWQgdG8gcmVwbGF5IHlvdXIgd29yayBvbiB0b3Agb2YgaXQuLi4KIAlBcHBseWluZzogc2Vjb25kIGNvbW1pdAogCUFwcGx5aW5nOiB0aGlyZCBjb21taXQKQEAgLTQ4LDcgKzQ3LDYgQEAKIGNyZWF0ZV9leHBlY3RlZF9zdWNjZXNzX2ludGVyYWN0aXZlICgpIHsKIAlxX3RvX2NyID5leHBlY3RlZCA8PC1FT0YKIAkkKGdyZXAgIl5DcmVhdGVkIGF1dG9zdGFzaDogWzAtOWEtZl1bMC05YS1mXSpcJCIgYWN0dWFsKQotCUhFQUQgaXMgbm93IGF0ICQoZ2l0IHJldi1wYXJzZSAtLXNob3J0IGZlYXR1cmUtYnJhbmNoKSB0aGlyZCBjb21taXQKIAlBcHBsaWVkIGF1dG9zdGFzaC4KIAlTdWNjZXNzZnVsbHkgcmViYXNlZCBhbmQgdXBkYXRlZCByZWZzL2hlYWRzL3JlYmFzZWQtZmVhdHVyZS1icmFuY2guCiAJRU9GCkBAIC01Nyw3ICs1NSw2IEBACiBjcmVhdGVfZXhwZWN0ZWRfZmFpbHVyZV9hbSAoKSB7CiAJY2F0ID5leHBlY3RlZCA8PC1FT0YKIAkkKGdyZXAgIl5DcmVhdGVkIGF1dG9zdGFzaDogWzAtOWEtZl1bMC05YS1mXSpcJCIgYWN0dWFsKQotCUhFQUQgaXMgbm93IGF0ICQoZ2l0IHJldi1wYXJzZSAtLXNob3J0IGZlYXR1cmUtYnJhbmNoKSB0aGlyZCBjb21taXQKIAlGaXJzdCwgcmV3aW5kaW5nIGhlYWQgdG8gcmVwbGF5IHlvdXIgd29yayBvbiB0b3Agb2YgaXQuLi4KIAlBcHBseWluZzogc2Vjb25kIGNvbW1pdAogCUFwcGx5aW5nOiB0aGlyZCBjb21taXQKQEAgLTcwLDcgKzY3LDYgQEAKIGNyZWF0ZV9leHBlY3RlZF9mYWlsdXJlX2ludGVyYWN0aXZlICgpIHsKIAljYXQgPmV4cGVjdGVkIDw8LUVPRgogCSQoZ3JlcCAiXkNyZWF0ZWQgYXV0b3N0YXNoOiBbMC05YS1mXVswLTlhLWZdKlwkIiBhY3R1YWwpCi0JSEVBRCBpcyBub3cgYXQgJChnaXQgcmV2LXBhcnNlIC0tc2hvcnQgZmVhdHVyZS1icmFuY2gpIHRoaXJkIGNvbW1pdAogCUFwcGx5aW5nIGF1dG9zdGFzaCByZXN1bHRlZCBpbiBjb25mbGljdHMuCiAJWW91ciBjaGFuZ2VzIGFyZSBzYWZlIGluIHRoZSBzdGFzaC4KIAlZb3UgY2FuIHJ1biAiZ2l0IHN0YXNoIHBvcCIgb3IgImdpdCBzdGFzaCBkcm9wIiBhdCBhbnkgdGltZS4KQEAgLTMwNiw0ICszMDIsMTIgQEAKIAl0ZXN0IHVuY2hhbmdlZC1icmFuY2ggPSAiJChnaXQgcmV2LXBhcnNlIC0tYWJicmV2LXJlZiBIRUFEKSIKICcKIAordGVzdF9leHBlY3Rfc3VjY2VzcyAnbmV2ZXIgY2hhbmdlIGFjdGl2ZSBicmFuY2gnICcKKwlnaXQgY2hlY2tvdXQgLWIgbm90LXRoZS1mZWF0dXJlLWJyYW5jaCB1bnJlbGF0ZWQtb250by1icmFuY2ggJiYKKwl0ZXN0X3doZW5fZmluaXNoZWQgImdpdCByZXNldCAtLWhhcmQgJiYgZ2l0IGNoZWNrb3V0IG1hc3RlciIgJiYKKwllY2hvIGNoYW5nZWQgPmZpbGUwICYmCisJZ2l0IHJlYmFzZSAtLWF1dG9zdGFzaCBub3QtdGhlLWZlYXR1cmUtYnJhbmNoIGZlYXR1cmUtYnJhbmNoICYmCisJdGVzdF9jbXBfcmV2IG5vdC10aGUtZmVhdHVyZS1icmFuY2ggdW5yZWxhdGVkLW9udG8tYnJhbmNoCisnCisKIHRlc3RfZG9uZQpkaWZmIC0tZ2l0IGEvdC90MzQyMS1yZWJhc2UtdG9wb2xvZ3ktbGluZWFyLnNoIGIvdC90MzQyMS1yZWJhc2UtdG9wb2xvZ3ktbGluZWFyLnNoCmluZGV4IDcyNzRkY2EuLjMyNTA3MmIgMTAwNzU1Ci0tLSBhL3QvdDM0MjEtcmViYXNlLXRvcG9sb2d5LWxpbmVhci5zaAorKysgYi90L3QzNDIxLXJlYmFzZS10b3BvbG9neS1saW5lYXIuc2gKQEAgLTMxLDYgKzMxLDE2IEBACiB0ZXN0X3J1bl9yZWJhc2Ugc3VjY2VzcyAtaQogdGVzdF9oYXZlX3ByZXJlcSAhUkVCQVNFX1AgfHwgdGVzdF9ydW5fcmViYXNlIHN1Y2Nlc3MgLXAKIAordGVzdF9leHBlY3Rfc3VjY2VzcyAnc2V0dXAgYnJhbmNoZXMgYW5kIHJlbW90ZSB0cmFja2luZycgJworCWdpdCB0YWcgLWwgPnRhZ3MgJiYKKwlmb3IgdGFnIGluICQoY2F0IHRhZ3MpCisJZG8KKwkJZ2l0IGJyYW5jaCBicmFuY2gtJHRhZyAkdGFnIHx8IHJldHVybiAxCisJZG9uZSAmJgorCWdpdCByZW1vdGUgYWRkIG9yaWdpbiAiZmlsZTovLyRQV0QiICYmCisJZ2l0IGZldGNoIG9yaWdpbgorJworCiB0ZXN0X3J1bl9yZWJhc2UgKCkgewogCXJlc3VsdD0kMQogCXNoaWZ0CkBAIC01MSwxMiArNjEsMTMgQEAKIAl0ZXN0X2V4cGVjdF8kcmVzdWx0ICJyZWJhc2UgJCogLWYgcmV3cml0ZXMgZXZlbiBpZiB1cHN0cmVhbSBpcyBhbiBhbmNlc3RvciIgIgogCQlyZXNldF9yZWJhc2UgJiYKIAkJZ2l0IHJlYmFzZSAkKiAtZiBiIGUgJiYKLQkJISB0ZXN0X2NtcF9yZXYgZSBIRUFEICYmCisJCXRlc3RfY21wX3JldiAhIGUgSEVBRCAmJgogCQl0ZXN0X2NtcF9yZXYgYiBIRUFEfjIgJiYKIAkJdGVzdF9saW5lYXJfcmFuZ2UgJ2QgZScgYi4uCiAJIgogfQogdGVzdF9ydW5fcmViYXNlIHN1Y2Nlc3MgJycKK3Rlc3RfcnVuX3JlYmFzZSBzdWNjZXNzIC0tZm9yay1wb2ludAogdGVzdF9ydW5fcmViYXNlIHN1Y2Nlc3MgLW0KIHRlc3RfcnVuX3JlYmFzZSBzdWNjZXNzIC1pCiB0ZXN0X2hhdmVfcHJlcmVxICFSRUJBU0VfUCB8fCB0ZXN0X3J1bl9yZWJhc2UgZmFpbHVyZSAtcApAQCAtNjQsNiArNzUsMjMgQEAKIHRlc3RfcnVuX3JlYmFzZSAoKSB7CiAJcmVzdWx0PSQxCiAJc2hpZnQKKwl0ZXN0X2V4cGVjdF8kcmVzdWx0ICJyZWJhc2UgJCogLWYgcmV3cml0ZXMgZXZlbiBpZiByZW1vdGUgdXBzdHJlYW0gaXMgYW4gYW5jZXN0b3IiICIKKwkJcmVzZXRfcmViYXNlICYmCisJCWdpdCByZWJhc2UgJCogLWYgYnJhbmNoLWIgYnJhbmNoLWUgJiYKKwkJdGVzdF9jbXBfcmV2ICEgYnJhbmNoLWUgb3JpZ2luL2JyYW5jaC1lICYmCisJCXRlc3RfY21wX3JldiBicmFuY2gtYiBIRUFEfjIgJiYKKwkJdGVzdF9saW5lYXJfcmFuZ2UgJ2QgZScgYnJhbmNoLWIuLgorCSIKK30KK3Rlc3RfcnVuX3JlYmFzZSBzdWNjZXNzICcnCit0ZXN0X3J1bl9yZWJhc2Ugc3VjY2VzcyAtLWZvcmstcG9pbnQKK3Rlc3RfcnVuX3JlYmFzZSBzdWNjZXNzIC1tCit0ZXN0X3J1bl9yZWJhc2Ugc3VjY2VzcyAtaQordGVzdF9oYXZlX3ByZXJlcSAhUkVCQVNFX1AgfHwgdGVzdF9ydW5fcmViYXNlIHN1Y2Nlc3MgLXAKKwordGVzdF9ydW5fcmViYXNlICgpIHsKKwlyZXN1bHQ9JDEKKwlzaGlmdAogCXRlc3RfZXhwZWN0XyRyZXN1bHQgInJlYmFzZSAkKiBmYXN0LWZvcndhcmRzIGZyb20gYW5jZXN0b3Igb2YgdXBzdHJlYW0iICIKIAkJcmVzZXRfcmViYXNlICYmCiAJCWdpdCByZWJhc2UgJCogZSBiICYmCkBAIC03MSw2ICs5OSw3IEBACiAJIgogfQogdGVzdF9ydW5fcmViYXNlIHN1Y2Nlc3MgJycKK3Rlc3RfcnVuX3JlYmFzZSBzdWNjZXNzIC0tZm9yay1wb2ludAogdGVzdF9ydW5fcmViYXNlIHN1Y2Nlc3MgLW0KIHRlc3RfcnVuX3JlYmFzZSBzdWNjZXNzIC1pCiB0ZXN0X2hhdmVfcHJlcmVxICFSRUJBU0VfUCB8fCB0ZXN0X3J1bl9yZWJhc2Ugc3VjY2VzcyAtcApAQCAtMzM5LDcgKzM2OCw3IEBACiAJdGVzdF9leHBlY3RfJHJlc3VsdCAicmViYXNlICQqIC1mIC0tcm9vdCBvbiBsaW5lYXIgaGlzdG9yeSBjYXVzZXMgcmUtd3JpdGUiICIKIAkJcmVzZXRfcmViYXNlICYmCiAJCWdpdCByZWJhc2UgJCogLWYgLS1yb290IGMgJiYKLQkJISB0ZXN0X2NtcF9yZXYgYSBIRUFEfjIgJiYKKwkJdGVzdF9jbXBfcmV2ICEgYSBIRUFEfjIgJiYKIAkJdGVzdF9saW5lYXJfcmFuZ2UgJ2EgYiBjJyBIRUFECiAJIgogfQpkaWZmIC0tZ2l0IGEvdC90MzQyMi1yZWJhc2UtaW5jb21wYXRpYmxlLW9wdGlvbnMuc2ggYi90L3QzNDIyLXJlYmFzZS1pbmNvbXBhdGlibGUtb3B0aW9ucy5zaAppbmRleCBhNTg2OGVhLi41MGU3OTYwIDEwMDc1NQotLS0gYS90L3QzNDIyLXJlYmFzZS1pbmNvbXBhdGlibGUtb3B0aW9ucy5zaAorKysgYi90L3QzNDIyLXJlYmFzZS1pbmNvbXBhdGlibGUtb3B0aW9ucy5zaApAQCAtNzYsMTQgKzc2LDQgQEAKIAl0ZXN0X211c3RfZmFpbCBnaXQgcmViYXNlIC0tcHJlc2VydmUtbWVyZ2VzIC0tcmViYXNlLW1lcmdlcyBBCiAnCiAKLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJy0tcmViYXNlLW1lcmdlcyBpbmNvbXBhdGlibGUgd2l0aCAtLXN0cmF0ZWd5JyAnCi0JZ2l0IGNoZWNrb3V0IEJeMCAmJgotCXRlc3RfbXVzdF9mYWlsIGdpdCByZWJhc2UgLS1yZWJhc2UtbWVyZ2VzIC1zIHJlc29sdmUgQQotJwotCi10ZXN0X2V4cGVjdF9zdWNjZXNzICctLXJlYmFzZS1tZXJnZXMgaW5jb21wYXRpYmxlIHdpdGggLS1zdHJhdGVneS1vcHRpb24nICcKLQlnaXQgY2hlY2tvdXQgQl4wICYmCi0JdGVzdF9tdXN0X2ZhaWwgZ2l0IHJlYmFzZSAtLXJlYmFzZS1tZXJnZXMgLVhpZ25vcmUtc3BhY2UtY2hhbmdlIEEKLScKLQogdGVzdF9kb25lCmRpZmYgLS1naXQgYS90L3QzNDI3LXJlYmFzZS1zdWJ0cmVlLnNoIGIvdC90MzQyNy1yZWJhc2Utc3VidHJlZS5zaAppbmRleCBkODY0MDUyLi5iZWM0OGU2IDEwMDc1NQotLS0gYS90L3QzNDI3LXJlYmFzZS1zdWJ0cmVlLnNoCisrKyBiL3QvdDM0MjctcmViYXNlLXN1YnRyZWUuc2gKQEAgLTExLDExMyArMTEsOTkgQEAKIAlnaXQgbG9nIC0tcHJldHR5PWZvcm1hdDolcyAtMSAiJDEiCiB9CiAKKyMgVGhlcmUgYXJlIGEgZmV3IGJ1Z3MgaW4gdGhlIHJlYmFzZSB3aXRoIHJlZ2FyZHMgdG8gdGhlIHN1YnRyZWUgc3RyYXRlZ3ksIGFuZAorIyB0aGlzIHRlc3Qgc2NyaXB0IHRyaWVzIHRvIGRvY3VtZW50IHRoZW0uICBGaXJzdCwgdGhlIGZvbGxvd2luZyBjb21taXQgaGlzdG9yeQorIyBpcyBnZW5lcmF0ZWQgKHRoZSBvbmVsaW5lcyBhcmUgc2hvd24sIHRpbWUgZmxvd3MgZnJvbSBsZWZ0IHRvIHJpZ2h0KToKKyMKKyMgbWFzdGVyMSAtIG1hc3RlcjIgLSBtYXN0ZXIzCisjICAgICAgICAgICAgICAgICAgICAgICAgICAgICBcCisjIFJFQURNRSAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tIEFkZCBzdWJwcm9qZWN0IG1hc3RlciAtIG1hc3RlcjQgLSBmaWxlc19zdWJ0cmVlL21hc3RlcjUKKyMKKyMgV2hlcmUgdGhlIG1lcmdlIG1vdmVzIHRoZSBmaWxlcyBtYXN0ZXJbMTIzXS50IGludG8gdGhlIHN1YmRpcmVjdG9yeQorIyBmaWxlc19zdWJ0cmVlLyBhbmQgbWFzdGVyNCBhcyB3ZWxsIGFzIGZpbGVzX3N1YnRyZWUvbWFzdGVyNSBhZGQgZmlsZXMgdG8gdGhhdAorIyBkaXJlY3RvcnkgZGlyZWN0bHkuCisjCisjIFRoZW4sIGluIHN1YnNlcXVlbnQgdGVzdCBjYXNlcywgYGdpdCBmaWx0ZXItYnJhbmNoYCBpcyB1c2VkIHRvIGRpc3RpbGwganVzdAorIyB0aGUgY29tbWl0cyB0aGF0IHRvdWNoIGZpbGVzX3N1YnRyZWUvLiBUbyBnaXZlIGl0IGEgZmluYWwgcHJlLXJlYmFzZSB0b3VjaCwKKyMgYW4gZW1wdHkgY29tbWl0IGlzIGFkZGVkIG9uIHRvcC4gVGhlIHByZS1yZWJhc2UgY29tbWl0IGhpc3RvcnkgbG9va3MgbGlrZQorIyB0aGlzOgorIworIyBBZGQgc3VicHJvamVjdCBtYXN0ZXIgLSBtYXN0ZXI0IC0gZmlsZXNfc3VidHJlZS9tYXN0ZXI1IC0gRW1wdHkgY29tbWl0CisjCisjIHdoZXJlIHRoZSByb290IGNvbW1pdCBhZGRzIHRocmVlIGZpbGVzOiBtYXN0ZXIxLnQsIG1hc3RlcjIudCBhbmQgbWFzdGVyMy50LgorIworIyBUaGlzIGNvbW1pdCBoaXN0b3J5IGlzIHRoZW4gcmViYXNlZCBvbnRvIGBtYXN0ZXIzYCB3aXRoIHRoZQorIyBgLVhzdWJ0cmVlPWZpbGVzX3N1YnRyZWVgIG9wdGlvbiBpbiB0aHJlZSBkaWZmZXJlbnQgd2F5czoKKyMKKyMgMS4gdXNpbmcgYC0tcHJlc2VydmUtbWVyZ2VzYAorIyAyLiB1c2luZyBgLS1wcmVzZXJ2ZS1tZXJnZXNgIGFuZCAtLWtlZXAtZW1wdHkKKyMgMy4gd2l0aG91dCBzcGVjaWZ5aW5nIGEgcmViYXNlIGJhY2tlbmQKKwogdGVzdF9leHBlY3Rfc3VjY2VzcyAnc2V0dXAnICcKIAl0ZXN0X2NvbW1pdCBSRUFETUUgJiYKLQlta2RpciBmaWxlcyAmJgotCSgKLQkJY2QgZmlsZXMgJiYKLQkJZ2l0IGluaXQgJiYKLQkJdGVzdF9jb21taXQgbWFzdGVyMSAmJgotCQl0ZXN0X2NvbW1pdCBtYXN0ZXIyICYmCi0JCXRlc3RfY29tbWl0IG1hc3RlcjMKLQkpICYmCi0JZ2l0IGZldGNoIGZpbGVzIG1hc3RlciAmJgotCWdpdCBicmFuY2ggZmlsZXMtbWFzdGVyIEZFVENIX0hFQUQgJiYKLQlnaXQgcmVhZC10cmVlIC0tcHJlZml4PWZpbGVzX3N1YnRyZWUgZmlsZXMtbWFzdGVyICYmCi0JZ2l0IGNoZWNrb3V0IC0tIGZpbGVzX3N1YnRyZWUgJiYKLQl0cmVlPSQoZ2l0IHdyaXRlLXRyZWUpICYmCi0JaGVhZD0kKGdpdCByZXYtcGFyc2UgSEVBRCkgJiYKLQlyZXY9JChnaXQgcmV2LXBhcnNlIC0tdmVyaWZ5IGZpbGVzLW1hc3Rlcl4wKSAmJgotCWNvbW1pdD0kKGdpdCBjb21taXQtdHJlZSAtcCAkaGVhZCAtcCAkcmV2IC1tICJBZGQgc3VicHJvamVjdCBtYXN0ZXIiICR0cmVlKSAmJgotCWdpdCB1cGRhdGUtcmVmIEhFQUQgJGNvbW1pdCAmJgotCSgKLQkJY2QgZmlsZXNfc3VidHJlZSAmJgotCQl0ZXN0X2NvbW1pdCBtYXN0ZXI0Ci0JKSAmJgotCXRlc3RfY29tbWl0IGZpbGVzX3N1YnRyZWUvbWFzdGVyNQorCisJZ2l0IGluaXQgZmlsZXMgJiYKKwl0ZXN0X2NvbW1pdCAtQyBmaWxlcyBtYXN0ZXIxICYmCisJdGVzdF9jb21taXQgLUMgZmlsZXMgbWFzdGVyMiAmJgorCXRlc3RfY29tbWl0IC1DIGZpbGVzIG1hc3RlcjMgJiYKKworCTogcGVyZm9ybSBzdWJ0cmVlIG1lcmdlIGludG8gZmlsZXNfc3VidHJlZS8gJiYKKwlnaXQgZmV0Y2ggZmlsZXMgcmVmcy9oZWFkcy9tYXN0ZXI6cmVmcy9oZWFkcy9maWxlcy1tYXN0ZXIgJiYKKwlnaXQgbWVyZ2UgLXMgb3VycyAtLW5vLWNvbW1pdCAtLWFsbG93LXVucmVsYXRlZC1oaXN0b3JpZXMgXAorCQlmaWxlcy1tYXN0ZXIgJiYKKwlnaXQgcmVhZC10cmVlIC0tcHJlZml4PWZpbGVzX3N1YnRyZWUgLXUgZmlsZXMtbWFzdGVyICYmCisJZ2l0IGNvbW1pdCAtbSAiQWRkIHN1YnByb2plY3QgbWFzdGVyIiAmJgorCisJOiBhZGQgdHdvIGV4dHJhIGNvbW1pdHMgdG8gcmViYXNlICYmCisJdGVzdF9jb21taXQgLUMgZmlsZXNfc3VidHJlZSBtYXN0ZXI0ICYmCisJdGVzdF9jb21taXQgZmlsZXNfc3VidHJlZS9tYXN0ZXI1ICYmCisKKwlnaXQgY2hlY2tvdXQgLWIgdG8tcmViYXNlICYmCisJZ2l0IGZhc3QtZXhwb3J0IC0tbm8tZGF0YSBIRUFEIC0tIGZpbGVzX3N1YnRyZWUvIHwKKwkJc2VkIC1lICJzJVwoWzAtOWEtZl1cezQwXH0gXClmaWxlc19zdWJ0cmVlLyVcMSUiIHwKKwkJZ2l0IGZhc3QtaW1wb3J0IC0tZm9yY2UgLS1xdWlldCAmJgorCWdpdCByZXNldCAtLWhhcmQgJiYKKwlnaXQgY29tbWl0IC1tICJFbXB0eSBjb21taXQiIC0tYWxsb3ctZW1wdHkKICcKIAogIyBGQUlMVVJFOiBEb2VzIG5vdCBwcmVzZXJ2ZSBtYXN0ZXI0LgotdGVzdF9leHBlY3RfZmFpbHVyZSBSRUJBU0VfUCBcCi0JJ1JlYmFzZSAtWHN1YnRyZWUgLS1wcmVzZXJ2ZS1tZXJnZXMgLS1vbnRvIGNvbW1pdCA0JyAnCit0ZXN0X2V4cGVjdF9mYWlsdXJlIFJFQkFTRV9QICdSZWJhc2UgLVhzdWJ0cmVlIC0tcHJlc2VydmUtbWVyZ2VzIC0tb250byBjb21taXQnICcKIAlyZXNldF9yZWJhc2UgJiYKLQlnaXQgY2hlY2tvdXQgLWIgcmViYXNlLXByZXNlcnZlLW1lcmdlcy00IG1hc3RlciAmJgotCWdpdCBmaWx0ZXItYnJhbmNoIC0tcHJ1bmUtZW1wdHkgLWYgLS1zdWJkaXJlY3RvcnktZmlsdGVyIGZpbGVzX3N1YnRyZWUgJiYKLQlnaXQgY29tbWl0IC1tICJFbXB0eSBjb21taXQiIC0tYWxsb3ctZW1wdHkgJiYKKwlnaXQgY2hlY2tvdXQgLWIgcmViYXNlLXByZXNlcnZlLW1lcmdlcyB0by1yZWJhc2UgJiYKIAlnaXQgcmViYXNlIC1Yc3VidHJlZT1maWxlc19zdWJ0cmVlIC0tcHJlc2VydmUtbWVyZ2VzIC0tb250byBmaWxlcy1tYXN0ZXIgbWFzdGVyICYmCi0JdmVyYm9zZSB0ZXN0ICIkKGNvbW1pdF9tZXNzYWdlIEhFQUR+KSIgPSAiZmlsZXNfc3VidHJlZS9tYXN0ZXI0IgotJwotCi0jIEZBSUxVUkU6IERvZXMgbm90IHByZXNlcnZlIG1hc3RlcjUuCi10ZXN0X2V4cGVjdF9mYWlsdXJlIFJFQkFTRV9QIFwKLQknUmViYXNlIC1Yc3VidHJlZSAtLXByZXNlcnZlLW1lcmdlcyAtLW9udG8gY29tbWl0IDUnICcKLQlyZXNldF9yZWJhc2UgJiYKLQlnaXQgY2hlY2tvdXQgLWIgcmViYXNlLXByZXNlcnZlLW1lcmdlcy01IG1hc3RlciAmJgotCWdpdCBmaWx0ZXItYnJhbmNoIC0tcHJ1bmUtZW1wdHkgLWYgLS1zdWJkaXJlY3RvcnktZmlsdGVyIGZpbGVzX3N1YnRyZWUgJiYKLQlnaXQgY29tbWl0IC1tICJFbXB0eSBjb21taXQiIC0tYWxsb3ctZW1wdHkgJiYKLQlnaXQgcmViYXNlIC1Yc3VidHJlZT1maWxlc19zdWJ0cmVlIC0tcHJlc2VydmUtbWVyZ2VzIC0tb250byBmaWxlcy1tYXN0ZXIgbWFzdGVyICYmCisJdmVyYm9zZSB0ZXN0ICIkKGNvbW1pdF9tZXNzYWdlIEhFQUR+KSIgPSAibWFzdGVyNCIgJiYKIAl2ZXJib3NlIHRlc3QgIiQoY29tbWl0X21lc3NhZ2UgSEVBRCkiID0gImZpbGVzX3N1YnRyZWUvbWFzdGVyNSIKICcKIAogIyBGQUlMVVJFOiBEb2VzIG5vdCBwcmVzZXJ2ZSBtYXN0ZXI0LgotdGVzdF9leHBlY3RfZmFpbHVyZSBSRUJBU0VfUCBcCi0JJ1JlYmFzZSAtWHN1YnRyZWUgLS1rZWVwLWVtcHR5IC0tcHJlc2VydmUtbWVyZ2VzIC0tb250byBjb21taXQgNCcgJwordGVzdF9leHBlY3RfZmFpbHVyZSBSRUJBU0VfUCAnUmViYXNlIC1Yc3VidHJlZSAtLWtlZXAtZW1wdHkgLS1wcmVzZXJ2ZS1tZXJnZXMgLS1vbnRvIGNvbW1pdCcgJwogCXJlc2V0X3JlYmFzZSAmJgotCWdpdCBjaGVja291dCAtYiByZWJhc2Uta2VlcC1lbXB0eS00IG1hc3RlciAmJgotCWdpdCBmaWx0ZXItYnJhbmNoIC0tcHJ1bmUtZW1wdHkgLWYgLS1zdWJkaXJlY3RvcnktZmlsdGVyIGZpbGVzX3N1YnRyZWUgJiYKLQlnaXQgY29tbWl0IC1tICJFbXB0eSBjb21taXQiIC0tYWxsb3ctZW1wdHkgJiYKKwlnaXQgY2hlY2tvdXQgLWIgcmViYXNlLWtlZXAtZW1wdHkgdG8tcmViYXNlICYmCiAJZ2l0IHJlYmFzZSAtWHN1YnRyZWU9ZmlsZXNfc3VidHJlZSAtLWtlZXAtZW1wdHkgLS1wcmVzZXJ2ZS1tZXJnZXMgLS1vbnRvIGZpbGVzLW1hc3RlciBtYXN0ZXIgJiYKLQl2ZXJib3NlIHRlc3QgIiQoY29tbWl0X21lc3NhZ2UgSEVBRH4yKSIgPSAiZmlsZXNfc3VidHJlZS9tYXN0ZXI0IgotJwotCi0jIEZBSUxVUkU6IERvZXMgbm90IHByZXNlcnZlIG1hc3RlcjUuCi10ZXN0X2V4cGVjdF9mYWlsdXJlIFJFQkFTRV9QIFwKLQknUmViYXNlIC1Yc3VidHJlZSAtLWtlZXAtZW1wdHkgLS1wcmVzZXJ2ZS1tZXJnZXMgLS1vbnRvIGNvbW1pdCA1JyAnCi0JcmVzZXRfcmViYXNlICYmCi0JZ2l0IGNoZWNrb3V0IC1iIHJlYmFzZS1rZWVwLWVtcHR5LTUgbWFzdGVyICYmCi0JZ2l0IGZpbHRlci1icmFuY2ggLS1wcnVuZS1lbXB0eSAtZiAtLXN1YmRpcmVjdG9yeS1maWx0ZXIgZmlsZXNfc3VidHJlZSAmJgotCWdpdCBjb21taXQgLW0gIkVtcHR5IGNvbW1pdCIgLS1hbGxvdy1lbXB0eSAmJgotCWdpdCByZWJhc2UgLVhzdWJ0cmVlPWZpbGVzX3N1YnRyZWUgLS1rZWVwLWVtcHR5IC0tcHJlc2VydmUtbWVyZ2VzIC0tb250byBmaWxlcy1tYXN0ZXIgbWFzdGVyICYmCi0JdmVyYm9zZSB0ZXN0ICIkKGNvbW1pdF9tZXNzYWdlIEhFQUR+KSIgPSAiZmlsZXNfc3VidHJlZS9tYXN0ZXI1IgotJwotCi0jIEZBSUxVUkU6IERvZXMgbm90IHByZXNlcnZlIEVtcHR5LgotdGVzdF9leHBlY3RfZmFpbHVyZSBSRUJBU0VfUCBcCi0JJ1JlYmFzZSAtWHN1YnRyZWUgLS1rZWVwLWVtcHR5IC0tcHJlc2VydmUtbWVyZ2VzIC0tb250byBlbXB0eSBjb21taXQnICcKLQlyZXNldF9yZWJhc2UgJiYKLQlnaXQgY2hlY2tvdXQgLWIgcmViYXNlLWtlZXAtZW1wdHktZW1wdHkgbWFzdGVyICYmCi0JZ2l0IGZpbHRlci1icmFuY2ggLS1wcnVuZS1lbXB0eSAtZiAtLXN1YmRpcmVjdG9yeS1maWx0ZXIgZmlsZXNfc3VidHJlZSAmJgotCWdpdCBjb21taXQgLW0gIkVtcHR5IGNvbW1pdCIgLS1hbGxvdy1lbXB0eSAmJgotCWdpdCByZWJhc2UgLVhzdWJ0cmVlPWZpbGVzX3N1YnRyZWUgLS1rZWVwLWVtcHR5IC0tcHJlc2VydmUtbWVyZ2VzIC0tb250byBmaWxlcy1tYXN0ZXIgbWFzdGVyICYmCisJdmVyYm9zZSB0ZXN0ICIkKGNvbW1pdF9tZXNzYWdlIEhFQUR+MikiID0gIm1hc3RlcjQiICYmCisJdmVyYm9zZSB0ZXN0ICIkKGNvbW1pdF9tZXNzYWdlIEhFQUR+KSIgPSAiZmlsZXNfc3VidHJlZS9tYXN0ZXI1IiAmJgogCXZlcmJvc2UgdGVzdCAiJChjb21taXRfbWVzc2FnZSBIRUFEKSIgPSAiRW1wdHkgY29tbWl0IgogJwogCi0jIEZBSUxVUkU6IGZhdGFsOiBDb3VsZCBub3QgcGFyc2Ugb2JqZWN0Ci10ZXN0X2V4cGVjdF9mYWlsdXJlICdSZWJhc2UgLVhzdWJ0cmVlIC0tb250byBjb21taXQgNCcgJwordGVzdF9leHBlY3Rfc3VjY2VzcyAnUmViYXNlIC1Yc3VidHJlZSAtLWtlZXAtZW1wdHkgLS1vbnRvIGNvbW1pdCcgJwogCXJlc2V0X3JlYmFzZSAmJgotCWdpdCBjaGVja291dCAtYiByZWJhc2Utb250by00IG1hc3RlciAmJgotCWdpdCBmaWx0ZXItYnJhbmNoIC0tcHJ1bmUtZW1wdHkgLWYgLS1zdWJkaXJlY3RvcnktZmlsdGVyIGZpbGVzX3N1YnRyZWUgJiYKLQlnaXQgY29tbWl0IC1tICJFbXB0eSBjb21taXQiIC0tYWxsb3ctZW1wdHkgJiYKLQlnaXQgcmViYXNlIC1Yc3VidHJlZT1maWxlc19zdWJ0cmVlIC0tb250byBmaWxlcy1tYXN0ZXIgbWFzdGVyICYmCi0JdmVyYm9zZSB0ZXN0ICIkKGNvbW1pdF9tZXNzYWdlIEhFQUR+MikiID0gImZpbGVzX3N1YnRyZWUvbWFzdGVyNCIKKwlnaXQgY2hlY2tvdXQgLWIgcmViYXNlLW9udG8gdG8tcmViYXNlICYmCisJdGVzdF9tdXN0X2ZhaWwgZ2l0IHJlYmFzZSAtWHN1YnRyZWU9ZmlsZXNfc3VidHJlZSAtLWtlZXAtZW1wdHkgLS1vbnRvIGZpbGVzLW1hc3RlciBtYXN0ZXIgJiYKKwk6IGZpcnN0IHBpY2sgcmVzdWx0cyBpbiBubyBjaGFuZ2VzICYmCisJZ2l0IHJlYmFzZSAtLWNvbnRpbnVlICYmCisJdmVyYm9zZSB0ZXN0ICIkKGNvbW1pdF9tZXNzYWdlIEhFQUR+MikiID0gIm1hc3RlcjQiICYmCisJdmVyYm9zZSB0ZXN0ICIkKGNvbW1pdF9tZXNzYWdlIEhFQUR+KSIgPSAiZmlsZXNfc3VidHJlZS9tYXN0ZXI1IiAmJgorCXZlcmJvc2UgdGVzdCAiJChjb21taXRfbWVzc2FnZSBIRUFEKSIgPSAiRW1wdHkgY29tbWl0IgogJwogCi0jIEZBSUxVUkU6IGZhdGFsOiBDb3VsZCBub3QgcGFyc2Ugb2JqZWN0Ci10ZXN0X2V4cGVjdF9mYWlsdXJlICdSZWJhc2UgLVhzdWJ0cmVlIC0tb250byBjb21taXQgNScgJwordGVzdF9leHBlY3Rfc3VjY2VzcyAnUmViYXNlIC1Yc3VidHJlZSAtLWtlZXAtZW1wdHkgLS1yZWJhc2UtbWVyZ2VzIC0tb250byBjb21taXQnICcKIAlyZXNldF9yZWJhc2UgJiYKLQlnaXQgY2hlY2tvdXQgLWIgcmViYXNlLW9udG8tNSBtYXN0ZXIgJiYKLQlnaXQgZmlsdGVyLWJyYW5jaCAtLXBydW5lLWVtcHR5IC1mIC0tc3ViZGlyZWN0b3J5LWZpbHRlciBmaWxlc19zdWJ0cmVlICYmCi0JZ2l0IGNvbW1pdCAtbSAiRW1wdHkgY29tbWl0IiAtLWFsbG93LWVtcHR5ICYmCi0JZ2l0IHJlYmFzZSAtWHN1YnRyZWU9ZmlsZXNfc3VidHJlZSAtLW9udG8gZmlsZXMtbWFzdGVyIG1hc3RlciAmJgotCXZlcmJvc2UgdGVzdCAiJChjb21taXRfbWVzc2FnZSBIRUFEfikiID0gImZpbGVzX3N1YnRyZWUvbWFzdGVyNSIKLScKLSMgRkFJTFVSRTogZmF0YWw6IENvdWxkIG5vdCBwYXJzZSBvYmplY3QKLXRlc3RfZXhwZWN0X2ZhaWx1cmUgJ1JlYmFzZSAtWHN1YnRyZWUgLS1vbnRvIGVtcHR5IGNvbW1pdCcgJwotCXJlc2V0X3JlYmFzZSAmJgotCWdpdCBjaGVja291dCAtYiByZWJhc2Utb250by1lbXB0eSBtYXN0ZXIgJiYKLQlnaXQgZmlsdGVyLWJyYW5jaCAtLXBydW5lLWVtcHR5IC1mIC0tc3ViZGlyZWN0b3J5LWZpbHRlciBmaWxlc19zdWJ0cmVlICYmCi0JZ2l0IGNvbW1pdCAtbSAiRW1wdHkgY29tbWl0IiAtLWFsbG93LWVtcHR5ICYmCi0JZ2l0IHJlYmFzZSAtWHN1YnRyZWU9ZmlsZXNfc3VidHJlZSAtLW9udG8gZmlsZXMtbWFzdGVyIG1hc3RlciAmJgorCWdpdCBjaGVja291dCAtYiByZWJhc2UtbWVyZ2VzLW9udG8gdG8tcmViYXNlICYmCisJdGVzdF9tdXN0X2ZhaWwgZ2l0IHJlYmFzZSAtWHN1YnRyZWU9ZmlsZXNfc3VidHJlZSAtLWtlZXAtZW1wdHkgLS1yZWJhc2UtbWVyZ2VzIC0tb250byBmaWxlcy1tYXN0ZXIgLS1yb290ICYmCisJOiBmaXJzdCBwaWNrIHJlc3VsdHMgaW4gbm8gY2hhbmdlcyAmJgorCWdpdCByZWJhc2UgLS1jb250aW51ZSAmJgorCXZlcmJvc2UgdGVzdCAiJChjb21taXRfbWVzc2FnZSBIRUFEfjIpIiA9ICJtYXN0ZXI0IiAmJgorCXZlcmJvc2UgdGVzdCAiJChjb21taXRfbWVzc2FnZSBIRUFEfikiID0gImZpbGVzX3N1YnRyZWUvbWFzdGVyNSIgJiYKIAl2ZXJib3NlIHRlc3QgIiQoY29tbWl0X21lc3NhZ2UgSEVBRCkiID0gIkVtcHR5IGNvbW1pdCIKICcKIApkaWZmIC0tZ2l0IGEvdC90MzQyOS1yZWJhc2UtZWRpdC10b2RvLnNoIGIvdC90MzQyOS1yZWJhc2UtZWRpdC10b2RvLnNoCmluZGV4IDc2ZjZkMzAuLmFhZWFjNmUgMTAwNzU1Ci0tLSBhL3QvdDM0MjktcmViYXNlLWVkaXQtdG9kby5zaAorKysgYi90L3QzNDI5LXJlYmFzZS1lZGl0LXRvZG8uc2gKQEAgLTMsMTUgKzMsMjEgQEAKIHRlc3RfZGVzY3JpcHRpb249J3JlYmFzZSBzaG91bGQgcmVyZWFkIHRoZSB0b2RvIGZpbGUgaWYgYW4gZXhlYyBtb2RpZmllcyBpdCcKIAogLiAuL3Rlc3QtbGliLnNoCisuICIkVEVTVF9ESVJFQ1RPUlkiL2xpYi1yZWJhc2Uuc2gKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAnc2V0dXAnICcKKwl0ZXN0X2NvbW1pdCBmaXJzdCBmaWxlICYmCisJdGVzdF9jb21taXQgc2Vjb25kIGZpbGUgJiYKKwl0ZXN0X2NvbW1pdCB0aGlyZCBmaWxlCisnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3JlYmFzZSBleGVjIG1vZGlmaWVzIHJlYmFzZS10b2RvJyAnCi0JdGVzdF9jb21taXQgaW5pdGlhbCAmJgogCXRvZG89LmdpdC9yZWJhc2UtbWVyZ2UvZ2l0LXJlYmFzZS10b2RvICYmCiAJZ2l0IHJlYmFzZSBIRUFEIC14ICJlY2hvIGV4ZWMgdG91Y2ggRiA+PiR0b2RvIiAmJgogCXRlc3QgLWUgRgogJwogCi10ZXN0X2V4cGVjdF9zdWNjZXNzIFNIQTEgJ2xvb3NlIG9iamVjdCBjYWNoZSB2cyByZS1yZWFkaW5nIHRvZG8gbGlzdCcgJwordGVzdF9leHBlY3Rfc3VjY2VzcyAnbG9vc2Ugb2JqZWN0IGNhY2hlIHZzIHJlLXJlYWRpbmcgdG9kbyBsaXN0JyAnCiAJR0lUX1JFQkFTRV9UT0RPPS5naXQvcmViYXNlLW1lcmdlL2dpdC1yZWJhc2UtdG9kbyAmJgogCWV4cG9ydCBHSVRfUkVCQVNFX1RPRE8gJiYKIAl3cml0ZV9zY3JpcHQgYXBwZW5kLXRvZG8uc2ggPDwtXEVPUyAmJgpAQCAtMzMsNCArMzksMTcgQEAKIAlnaXQgcmViYXNlIEhFQUQgLXggIi4vYXBwZW5kLXRvZG8uc2ggNSA2IgogJwogCit0ZXN0X2V4cGVjdF9zdWNjZXNzICd0b2RvIGlzIHJlLXJlYWQgYWZ0ZXIgcmV3b3JkIGFuZCBzcXVhc2gnICcKKwl3cml0ZV9zY3JpcHQgcmV3b3JkLWVkaXRvci5zaCA8PC1cRU9TICYmCisJR0lUX1NFUVVFTkNFX0VESVRPUj0iZWNobyBcImV4ZWMgZWNobyAkKGNhdCBmaWxlKSA+PmFjdHVhbFwiID4+IiBcCisJCWdpdCByZWJhc2UgLS1lZGl0LXRvZG8KKwlFT1MKKworCXRlc3Rfd3JpdGVfbGluZXMgZmlyc3QgdGhpcmQgPmV4cGVjdGVkICYmCisJc2V0X2Zha2VfZWRpdG9yICYmCisJR0lUX1NFUVVFTkNFX0VESVRPUj0iJEVESVRPUiIgRkFLRV9MSU5FUz0icmV3b3JkIDEgc3F1YXNoIDIgZml4dXAgMyIgXAorCQlHSVRfRURJVE9SPS4vcmV3b3JkLWVkaXRvci5zaCBnaXQgcmViYXNlIC1pIC0tcm9vdCB0aGlyZCAmJgorCXRlc3RfY21wIGV4cGVjdGVkIGFjdHVhbAorJworCiB0ZXN0X2RvbmUKZGlmZiAtLWdpdCBhL3QvdDM0MzAtcmViYXNlLW1lcmdlcy5zaCBiL3QvdDM0MzAtcmViYXNlLW1lcmdlcy5zaAppbmRleCA3YjZjNDg0Li5lNzJjYTM0IDEwMDc1NQotLS0gYS90L3QzNDMwLXJlYmFzZS1tZXJnZXMuc2gKKysrIGIvdC90MzQzMC1yZWJhc2UtbWVyZ2VzLnNoCkBAIC0zNywyMCArMzcsMjcgQEAKIAl0ZXN0X2NvbW1pdCBBICYmCiAJZ2l0IGNoZWNrb3V0IC1iIGZpcnN0ICYmCiAJdGVzdF9jb21taXQgQiAmJgorCWI9JChnaXQgcmV2LXBhcnNlIC0tc2hvcnQgSEVBRCkgJiYKIAlnaXQgY2hlY2tvdXQgbWFzdGVyICYmCiAJdGVzdF9jb21taXQgQyAmJgorCWM9JChnaXQgcmV2LXBhcnNlIC0tc2hvcnQgSEVBRCkgJiYKIAl0ZXN0X2NvbW1pdCBEICYmCisJZD0kKGdpdCByZXYtcGFyc2UgLS1zaG9ydCBIRUFEKSAmJgogCWdpdCBtZXJnZSAtLW5vLWNvbW1pdCBCICYmCiAJdGVzdF90aWNrICYmCiAJZ2l0IGNvbW1pdCAtbSBFICYmCiAJZ2l0IHRhZyAtbSBFIEUgJiYKKwllPSQoZ2l0IHJldi1wYXJzZSAtLXNob3J0IEhFQUQpICYmCiAJZ2l0IGNoZWNrb3V0IC1iIHNlY29uZCBDICYmCiAJdGVzdF9jb21taXQgRiAmJgorCWY9JChnaXQgcmV2LXBhcnNlIC0tc2hvcnQgSEVBRCkgJiYKIAl0ZXN0X2NvbW1pdCBHICYmCisJZz0kKGdpdCByZXYtcGFyc2UgLS1zaG9ydCBIRUFEKSAmJgogCWdpdCBjaGVja291dCBtYXN0ZXIgJiYKIAlnaXQgbWVyZ2UgLS1uby1jb21taXQgRyAmJgogCXRlc3RfdGljayAmJgogCWdpdCBjb21taXQgLW0gSCAmJgorCWg9JChnaXQgcmV2LXBhcnNlIC0tc2hvcnQgSEVBRCkgJiYKIAlnaXQgdGFnIC1tIEggSCAmJgogCWdpdCBjaGVja291dCBBICYmCiAJdGVzdF9jb21taXQgY29uZmxpY3RpbmctRyBHLnQKQEAgLTkzLDI0ICsxMDAsMjQgQEAKICcKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnZ2VuZXJhdGUgY29ycmVjdCB0b2RvIGxpc3QnICcKLQljYXQgPmV4cGVjdCA8PC1cRU9GICYmCisJY2F0ID5leHBlY3QgPDwtRU9GICYmCiAJbGFiZWwgb250bwogCiAJcmVzZXQgb250bwotCXBpY2sgZDlkZjQ1MCBCCisJcGljayAkYiBCCiAJbGFiZWwgRQogCiAJcmVzZXQgb250bwotCXBpY2sgNWRlZTc4NCBDCisJcGljayAkYyBDCiAJbGFiZWwgYnJhbmNoLXBvaW50Ci0JcGljayBjYTJjODYxIEYKLQlwaWNrIDA4OGIwMGEgRworCXBpY2sgJGYgRgorCXBpY2sgJGcgRwogCWxhYmVsIEgKIAogCXJlc2V0IGJyYW5jaC1wb2ludCAjIEMKLQlwaWNrIDEyYmQwN2IgRAotCW1lcmdlIC1DIDIwNTFiNTYgRSAjIEUKLQltZXJnZSAtQyAyMzNkNDhhIEggIyBICisJcGljayAkZCBECisJbWVyZ2UgLUMgJGUgRSAjIEUKKwltZXJnZSAtQyAkaCBIICMgSAogCiAJRU9GCiAKQEAgLTE1MSw3ICsxNTgsNiBAQAogCXRlc3RfcGF0aF9pc19maWxlIC5naXQvcmViYXNlLW1lcmdlL3BhdGNoCiAnCiAKLVNRPSInIgogdGVzdF9leHBlY3Rfc3VjY2VzcyAnZmFpbGVkIGBtZXJnZSA8YnJhbmNoPmAgZG9lcyBub3QgY3Jhc2gnICcKIAl0ZXN0X3doZW5fZmluaXNoZWQgInRlc3RfbWlnaHRfZmFpbCBnaXQgcmViYXNlIC0tYWJvcnQiICYmCiAJZ2l0IGNoZWNrb3V0IGNvbmZsaWN0aW5nLUcgJiYKQEAgLTM0MCw3ICszNDYsNyBAQAogCWdpdCBtZXJnZSAtLWFsbG93LXVucmVsYXRlZC1oaXN0b3JpZXMga2hudW0gJiYKIAl0ZXN0X3RpY2sgJiYKIAlnaXQgcmViYXNlIC1mIC1yIEhFQUReICYmCi0JISB0ZXN0X2NtcF9yZXYgSEVBRF4yIGtobnVtICYmCisJdGVzdF9jbXBfcmV2ICEgSEVBRF4yIGtobnVtICYmCiAJdGVzdF9jbXBfZ3JhcGggSEVBRF4uLiA8PC1cRU9GICYmCiAJKiAgIE1lcmdlIGJyYW5jaCAnXCcna2hudW0nXCcnIGludG8gYXNoZXJhaAogCXxcCkBAIC00MDIsNyArNDA4LDcgQEAKIAl8IHwgKiB0aHJlZQogCXwgKiB8IHR3bwogCXwgfC8KLQkqIHwgb25lCisJKiAvIG9uZQogCXwvCiAJbyBiZWZvcmUtb2N0b3B1cwogCUVPRgpAQCAtNDQxLDQgKzQ0Nyw1MiBAQAogCXRlc3RfcGF0aF9pc19taXNzaW5nIC5naXQvTUVSR0VfSEVBRAogJwogCit0ZXN0X2V4cGVjdF9zdWNjZXNzICctLXJlYmFzZS1tZXJnZXMgd2l0aCBzdHJhdGVnaWVzJyAnCisJZ2l0IGNoZWNrb3V0IC1iIHdpdGgtYS1zdHJhdGVneSBGICYmCisJdGVzdF90aWNrICYmCisJZ2l0IG1lcmdlIC1tICJNZXJnZSBjb25mbGljdGluZy1HIiBjb25mbGljdGluZy1HICYmCisKKwk6IGZpcnN0LCB0ZXN0IHdpdGggYSBtZXJnZSBzdHJhdGVneSBvcHRpb24gJiYKKwlnaXQgcmViYXNlIC1pciAtWHRoZWlycyBHICYmCisJZWNobyBjb25mbGljdGluZy1HID5leHBlY3QgJiYKKwl0ZXN0X2NtcCBleHBlY3QgRy50ICYmCisKKwk6IG5vdywgdHJ5IHdpdGggYSBtZXJnZSBzdHJhdGVneSBvdGhlciB0aGFuIHJlY3Vyc2l2ZSAmJgorCWdpdCByZXNldCAtLWhhcmQgQHsxfSAmJgorCXdyaXRlX3NjcmlwdCBnaXQtbWVyZ2Utb3ZlcnJpZGUgPDwtXEVPRiAmJgorCWVjaG8gb3ZlcnJpZGRlbiQxID4+Ry50CisJZ2l0IGFkZCBHLnQKKwlFT0YKKwlQQVRIPSIkUFdEOiRQQVRIIiBnaXQgcmViYXNlIC1pciAtcyBvdmVycmlkZSAtWHhvcHQgRyAmJgorCXRlc3Rfd3JpdGVfbGluZXMgRyBvdmVycmlkZGVuLS14b3B0ID5leHBlY3QgJiYKKwl0ZXN0X2NtcCBleHBlY3QgRy50CisnCisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJy0tcmViYXNlLW1lcmdlcyB3aXRoIGNvbW1pdCB0aGF0IGNhbiBnZW5lcmF0ZSBiYWQgY2hhcmFjdGVycyBmb3IgZmlsZW5hbWUnICcKKwlnaXQgY2hlY2tvdXQgLWIgY29sb24taW4tbGFiZWwgRSAmJgorCWdpdCBtZXJnZSAtbSAiY29sb246IHRoaXMgc2hvdWxkIHdvcmsiIEcgJiYKKwlnaXQgcmViYXNlIC0tcmViYXNlLW1lcmdlcyAtLWZvcmNlLXJlYmFzZSBFCisnCisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJy0tcmViYXNlLW1lcmdlcyB3aXRoIG1lc3NhZ2UgbWF0Y2hlZCB3aXRoIG9udG8gbGFiZWwnICcKKwlnaXQgY2hlY2tvdXQgLWIgb250by1sYWJlbCBFICYmCisJZ2l0IG1lcmdlIC1tIG9udG8gRyAmJgorCWdpdCByZWJhc2UgLS1yZWJhc2UtbWVyZ2VzIC0tZm9yY2UtcmViYXNlIEUgJiYKKwl0ZXN0X2NtcF9ncmFwaCA8PC1cRU9GCisJKiAgIG9udG8KKwl8XAorCXwgKiBHCisJfCAqIEYKKwkqIHwgICBFCisJfFwgXAorCXwgKiB8IEIKKwkqIHwgfCBECisJfCB8LworCXwvfAorCSogfCBDCisJfC8KKwkqIEEKKwlFT0YKKycKKwogdGVzdF9kb25lCmRpZmYgLS1naXQgYS90L3QzNDMxLXJlYmFzZS1mb3JrLXBvaW50LnNoIGIvdC90MzQzMS1yZWJhc2UtZm9yay1wb2ludC5zaApuZXcgZmlsZSBtb2RlIDEwMDc1NQppbmRleCAwMDAwMDAwLi43ODg1MWI5Ci0tLSAvZGV2L251bGwKKysrIGIvdC90MzQzMS1yZWJhc2UtZm9yay1wb2ludC5zaApAQCAtMCwwICsxLDU3IEBACisjIS9iaW4vc2gKKyMKKyMgQ29weXJpZ2h0IChjKSAyMDE5IERlbnRvbiBMaXUKKyMKKwordGVzdF9kZXNjcmlwdGlvbj0nZ2l0IHJlYmFzZSAtLWZvcmstcG9pbnQgdGVzdCcKKworLiAuL3Rlc3QtbGliLnNoCisKKyMgQS0tLUItLS1ELS0tRSAgICAobWFzdGVyKQorIyAgICAgIFwKKyMgICAgICAgQyotLS1GLS0tRyAoc2lkZSkKKyMKKyMgQyB3YXMgZm9ybWVybHkgcGFydCBvZiBtYXN0ZXIgYnV0IG1hc3RlciB3YXMgcmV3b3VuZCB0byByZW1vdmUgQworIwordGVzdF9leHBlY3Rfc3VjY2VzcyBzZXR1cCAnCisJdGVzdF9jb21taXQgQSAmJgorCXRlc3RfY29tbWl0IEIgJiYKKwl0ZXN0X2NvbW1pdCBDICYmCisJZ2l0IGJyYW5jaCAtdCBzaWRlICYmCisJZ2l0IHJlc2V0IC0taGFyZCBIRUFEXiAmJgorCXRlc3RfY29tbWl0IEQgJiYKKwl0ZXN0X2NvbW1pdCBFICYmCisJZ2l0IGNoZWNrb3V0IHNpZGUgJiYKKwl0ZXN0X2NvbW1pdCBGICYmCisJdGVzdF9jb21taXQgRworJworCit0ZXN0X3JlYmFzZSAoKSB7CisJZXhwZWN0ZWQ9IiQxIiAmJgorCXNoaWZ0ICYmCisJdGVzdF9leHBlY3Rfc3VjY2VzcyAiZ2l0IHJlYmFzZSAkKiIgIgorCQlnaXQgY2hlY2tvdXQgbWFzdGVyICYmCisJCWdpdCByZXNldCAtLWhhcmQgRSAmJgorCQlnaXQgY2hlY2tvdXQgc2lkZSAmJgorCQlnaXQgcmVzZXQgLS1oYXJkIEcgJiYKKwkJZ2l0IHJlYmFzZSAkKiAmJgorCQl0ZXN0X3dyaXRlX2xpbmVzICRleHBlY3RlZCA+ZXhwZWN0ICYmCisJCWdpdCBsb2cgLS1wcmV0dHk9JXMgPmFjdHVhbCAmJgorCQl0ZXN0X2NtcCBleHBlY3QgYWN0dWFsCisJIgorfQorCit0ZXN0X3JlYmFzZSAnRyBGIEUgRCBCIEEnCit0ZXN0X3JlYmFzZSAnRyBGIEQgQiBBJyAtLW9udG8gRAordGVzdF9yZWJhc2UgJ0cgRiBCIEEnIC0ta2VlcC1iYXNlCit0ZXN0X3JlYmFzZSAnRyBGIEMgRSBEIEIgQScgLS1uby1mb3JrLXBvaW50Cit0ZXN0X3JlYmFzZSAnRyBGIEMgRCBCIEEnIC0tbm8tZm9yay1wb2ludCAtLW9udG8gRAordGVzdF9yZWJhc2UgJ0cgRiBDIEIgQScgLS1uby1mb3JrLXBvaW50IC0ta2VlcC1iYXNlCit0ZXN0X3JlYmFzZSAnRyBGIEUgRCBCIEEnIC0tZm9yay1wb2ludCByZWZzL2hlYWRzL21hc3RlcgordGVzdF9yZWJhc2UgJ0cgRiBEIEIgQScgLS1mb3JrLXBvaW50IC0tb250byBEIHJlZnMvaGVhZHMvbWFzdGVyCit0ZXN0X3JlYmFzZSAnRyBGIEIgQScgLS1mb3JrLXBvaW50IC0ta2VlcC1iYXNlIHJlZnMvaGVhZHMvbWFzdGVyCit0ZXN0X3JlYmFzZSAnRyBGIEMgRSBEIEIgQScgcmVmcy9oZWFkcy9tYXN0ZXIKK3Rlc3RfcmViYXNlICdHIEYgQyBEIEIgQScgLS1vbnRvIEQgcmVmcy9oZWFkcy9tYXN0ZXIKK3Rlc3RfcmViYXNlICdHIEYgQyBCIEEnIC0ta2VlcC1iYXNlIHJlZnMvaGVhZHMvbWFzdGVyCisKK3Rlc3RfZG9uZQpkaWZmIC0tZ2l0IGEvdC90MzQzMi1yZWJhc2UtZmFzdC1mb3J3YXJkLnNoIGIvdC90MzQzMi1yZWJhc2UtZmFzdC1mb3J3YXJkLnNoCm5ldyBmaWxlIG1vZGUgMTAwNzU1CmluZGV4IDAwMDAwMDAuLjkyZjk1YjUKLS0tIC9kZXYvbnVsbAorKysgYi90L3QzNDMyLXJlYmFzZS1mYXN0LWZvcndhcmQuc2gKQEAgLTAsMCArMSwxMjUgQEAKKyMhL2Jpbi9zaAorIworIyBDb3B5cmlnaHQgKGMpIDIwMTkgRGVudG9uIExpdQorIworCit0ZXN0X2Rlc2NyaXB0aW9uPSdlbnN1cmUgcmViYXNlIGZhc3QtZm9yd2FyZHMgY29tbWl0cyB3aGVuIHBvc3NpYmxlJworCisuIC4vdGVzdC1saWIuc2gKKwordGVzdF9leHBlY3Rfc3VjY2VzcyBzZXR1cCAnCisJdGVzdF9jb21taXQgQSAmJgorCXRlc3RfY29tbWl0IEIgJiYKKwl0ZXN0X2NvbW1pdCBDICYmCisJdGVzdF9jb21taXQgRCAmJgorCWdpdCBjaGVja291dCAtdCAtYiBzaWRlCisnCisKK3Rlc3RfcmViYXNlX3NhbWVfaGVhZCAoKSB7CisJc3RhdHVzX249IiQxIiAmJgorCXNoaWZ0ICYmCisJd2hhdF9uPSIkMSIgJiYKKwlzaGlmdCAmJgorCWNtcF9uPSIkMSIgJiYKKwlzaGlmdCAmJgorCXN0YXR1c19mPSIkMSIgJiYKKwlzaGlmdCAmJgorCXdoYXRfZj0iJDEiICYmCisJc2hpZnQgJiYKKwljbXBfZj0iJDEiICYmCisJc2hpZnQgJiYKKwl0ZXN0X3JlYmFzZV9zYW1lX2hlYWRfICRzdGF0dXNfbiAkd2hhdF9uICRjbXBfbiAiIiAiJCoiICYmCisJdGVzdF9yZWJhc2Vfc2FtZV9oZWFkXyAkc3RhdHVzX2YgJHdoYXRfZiAkY21wX2YgIiAtLW5vLWZmIiAiJCoiCit9CisKK3Rlc3RfcmViYXNlX3NhbWVfaGVhZF8gKCkgeworCXN0YXR1cz0iJDEiICYmCisJc2hpZnQgJiYKKwl3aGF0PSIkMSIgJiYKKwlzaGlmdCAmJgorCWNtcD0iJDEiICYmCisJc2hpZnQgJiYKKwlmbGFnPSIkMSIKKwlzaGlmdCAmJgorCXRlc3RfZXhwZWN0XyRzdGF0dXMgImdpdCByZWJhc2UkZmxhZyAkKiB3aXRoICRjaGFuZ2VzIGlzICR3aGF0IHdpdGggJGNtcCBIRUFEIiAiCisJCW9sZGhlYWQ9XCQoZ2l0IHJldi1wYXJzZSBIRUFEKSAmJgorCQl0ZXN0X3doZW5fZmluaXNoZWQgJ2dpdCByZXNldCAtLWhhcmQgXCRvbGRoZWFkJyAmJgorCQlnaXQgcmViYXNlJGZsYWcgJCogPnN0ZG91dCAmJgorCQlpZiB0ZXN0ICR3aGF0ID0gd29yaworCQl0aGVuCisJCQkjIE11c3QgY2hlY2sgdGhpcyBjYXNlIGZpcnN0LCBmb3IgJ2lzIHVwIHRvCisJCQkjIGRhdGUsIHJlYmFzZSBmb3JjZWRbLi4uXXJld2luZGluZyBoZWFkJyBjYXNlcworCQkJdGVzdF9pMThuZ3JlcCAncmV3aW5kaW5nIGhlYWQnIHN0ZG91dAorCQllbGlmIHRlc3QgJHdoYXQgPSBub29wCisJCXRoZW4KKwkJCXRlc3RfaTE4bmdyZXAgJ2lzIHVwIHRvIGRhdGUnIHN0ZG91dCAmJgorCQkJdGVzdF9pMThuZ3JlcCAhICdyZWJhc2UgZm9yY2VkJyBzdGRvdXQKKwkJZWxpZiB0ZXN0ICR3aGF0ID0gbm9vcC1mb3JjZQorCQl0aGVuCisJCQl0ZXN0X2kxOG5ncmVwICdpcyB1cCB0byBkYXRlLCByZWJhc2UgZm9yY2VkJyBzdGRvdXQKKwkJZmkgJiYKKwkJbmV3aGVhZD1cJChnaXQgcmV2LXBhcnNlIEhFQUQpICYmCisJCWlmIHRlc3QgJGNtcCA9IHNhbWUKKwkJdGhlbgorCQkJdGVzdF9jbXBfcmV2IFwkb2xkaGVhZCBcJG5ld2hlYWQKKwkJZWxpZiB0ZXN0ICRjbXAgPSBkaWZmCisJCXRoZW4KKwkJCXRlc3RfY21wX3JldiAhIFwkb2xkaGVhZCBcJG5ld2hlYWQKKwkJZmkKKwkiCit9CisKK2NoYW5nZXM9J25vIGNoYW5nZXMnCit0ZXN0X3JlYmFzZV9zYW1lX2hlYWQgc3VjY2VzcyBub29wIHNhbWUgc3VjY2VzcyB3b3JrIHNhbWUKK3Rlc3RfcmViYXNlX3NhbWVfaGVhZCBzdWNjZXNzIG5vb3Agc2FtZSBzdWNjZXNzIG5vb3AtZm9yY2Ugc2FtZSBtYXN0ZXIKK3Rlc3RfcmViYXNlX3NhbWVfaGVhZCBzdWNjZXNzIG5vb3Agc2FtZSBzdWNjZXNzIG5vb3AtZm9yY2UgZGlmZiAtLW9udG8gQiBCCit0ZXN0X3JlYmFzZV9zYW1lX2hlYWQgc3VjY2VzcyBub29wIHNhbWUgc3VjY2VzcyBub29wLWZvcmNlIGRpZmYgLS1vbnRvIEIuLi4gQgordGVzdF9yZWJhc2Vfc2FtZV9oZWFkIHN1Y2Nlc3Mgbm9vcCBzYW1lIHN1Y2Nlc3Mgbm9vcC1mb3JjZSBzYW1lIC0tb250byBtYXN0ZXIuLi4gbWFzdGVyCit0ZXN0X3JlYmFzZV9zYW1lX2hlYWQgc3VjY2VzcyBub29wIHNhbWUgc3VjY2VzcyBub29wLWZvcmNlIHNhbWUgLS1rZWVwLWJhc2UgbWFzdGVyCit0ZXN0X3JlYmFzZV9zYW1lX2hlYWQgc3VjY2VzcyBub29wIHNhbWUgc3VjY2VzcyBub29wLWZvcmNlIHNhbWUgLS1rZWVwLWJhc2UKK3Rlc3RfcmViYXNlX3NhbWVfaGVhZCBzdWNjZXNzIG5vb3Agc2FtZSBzdWNjZXNzIG5vb3AtZm9yY2Ugc2FtZSAtLW5vLWZvcmstcG9pbnQKK3Rlc3RfcmViYXNlX3NhbWVfaGVhZCBzdWNjZXNzIG5vb3Agc2FtZSBzdWNjZXNzIG5vb3AtZm9yY2Ugc2FtZSAtLWtlZXAtYmFzZSAtLW5vLWZvcmstcG9pbnQKK3Rlc3RfcmViYXNlX3NhbWVfaGVhZCBzdWNjZXNzIG5vb3Agc2FtZSBzdWNjZXNzIHdvcmsgc2FtZSAtLWZvcmstcG9pbnQgbWFzdGVyCit0ZXN0X3JlYmFzZV9zYW1lX2hlYWQgc3VjY2VzcyBub29wIHNhbWUgc3VjY2VzcyB3b3JrIGRpZmYgLS1mb3JrLXBvaW50IC0tb250byBCIEIKK3Rlc3RfcmViYXNlX3NhbWVfaGVhZCBzdWNjZXNzIG5vb3Agc2FtZSBzdWNjZXNzIHdvcmsgZGlmZiAtLWZvcmstcG9pbnQgLS1vbnRvIEIuLi4gQgordGVzdF9yZWJhc2Vfc2FtZV9oZWFkIHN1Y2Nlc3Mgbm9vcCBzYW1lIHN1Y2Nlc3Mgd29yayBzYW1lIC0tZm9yay1wb2ludCAtLW9udG8gbWFzdGVyLi4uIG1hc3RlcgordGVzdF9yZWJhc2Vfc2FtZV9oZWFkIHN1Y2Nlc3Mgbm9vcCBzYW1lIHN1Y2Nlc3Mgd29yayBzYW1lIC0ta2VlcC1iYXNlIC0ta2VlcC1iYXNlIG1hc3RlcgorCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdhZGQgd29yayBzYW1lIHRvIHNpZGUnICcKKwl0ZXN0X2NvbW1pdCBFCisnCisKK2NoYW5nZXM9J291ciBjaGFuZ2VzJwordGVzdF9yZWJhc2Vfc2FtZV9oZWFkIHN1Y2Nlc3Mgbm9vcCBzYW1lIHN1Y2Nlc3Mgd29yayBzYW1lCit0ZXN0X3JlYmFzZV9zYW1lX2hlYWQgc3VjY2VzcyBub29wIHNhbWUgc3VjY2VzcyBub29wLWZvcmNlIHNhbWUgbWFzdGVyCit0ZXN0X3JlYmFzZV9zYW1lX2hlYWQgc3VjY2VzcyBub29wIHNhbWUgc3VjY2VzcyBub29wLWZvcmNlIGRpZmYgLS1vbnRvIEIgQgordGVzdF9yZWJhc2Vfc2FtZV9oZWFkIHN1Y2Nlc3Mgbm9vcCBzYW1lIHN1Y2Nlc3Mgbm9vcC1mb3JjZSBkaWZmIC0tb250byBCLi4uIEIKK3Rlc3RfcmViYXNlX3NhbWVfaGVhZCBzdWNjZXNzIG5vb3Agc2FtZSBzdWNjZXNzIG5vb3AtZm9yY2Ugc2FtZSAtLW9udG8gbWFzdGVyLi4uIG1hc3RlcgordGVzdF9yZWJhc2Vfc2FtZV9oZWFkIHN1Y2Nlc3Mgbm9vcCBzYW1lIHN1Y2Nlc3Mgbm9vcC1mb3JjZSBzYW1lIC0ta2VlcC1iYXNlIG1hc3RlcgordGVzdF9yZWJhc2Vfc2FtZV9oZWFkIHN1Y2Nlc3Mgbm9vcCBzYW1lIHN1Y2Nlc3Mgbm9vcC1mb3JjZSBzYW1lIC0ta2VlcC1iYXNlCit0ZXN0X3JlYmFzZV9zYW1lX2hlYWQgc3VjY2VzcyBub29wIHNhbWUgc3VjY2VzcyBub29wLWZvcmNlIHNhbWUgLS1uby1mb3JrLXBvaW50Cit0ZXN0X3JlYmFzZV9zYW1lX2hlYWQgc3VjY2VzcyBub29wIHNhbWUgc3VjY2VzcyBub29wLWZvcmNlIHNhbWUgLS1rZWVwLWJhc2UgLS1uby1mb3JrLXBvaW50Cit0ZXN0X3JlYmFzZV9zYW1lX2hlYWQgc3VjY2VzcyBub29wIHNhbWUgc3VjY2VzcyB3b3JrIHNhbWUgLS1mb3JrLXBvaW50IG1hc3RlcgordGVzdF9yZWJhc2Vfc2FtZV9oZWFkIHN1Y2Nlc3Mgbm9vcCBzYW1lIHN1Y2Nlc3Mgd29yayBkaWZmIC0tZm9yay1wb2ludCAtLW9udG8gQiBCCit0ZXN0X3JlYmFzZV9zYW1lX2hlYWQgc3VjY2VzcyBub29wIHNhbWUgc3VjY2VzcyB3b3JrIGRpZmYgLS1mb3JrLXBvaW50IC0tb250byBCLi4uIEIKK3Rlc3RfcmViYXNlX3NhbWVfaGVhZCBzdWNjZXNzIG5vb3Agc2FtZSBzdWNjZXNzIHdvcmsgc2FtZSAtLWZvcmstcG9pbnQgLS1vbnRvIG1hc3Rlci4uLiBtYXN0ZXIKK3Rlc3RfcmViYXNlX3NhbWVfaGVhZCBzdWNjZXNzIG5vb3Agc2FtZSBzdWNjZXNzIHdvcmsgc2FtZSAtLWZvcmstcG9pbnQgLS1rZWVwLWJhc2UgbWFzdGVyCisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2FkZCB3b3JrIHNhbWUgdG8gdXBzdHJlYW0nICcKKwlnaXQgY2hlY2tvdXQgbWFzdGVyICYmCisJdGVzdF9jb21taXQgRiAmJgorCWdpdCBjaGVja291dCBzaWRlCisnCisKK2NoYW5nZXM9J291ciBhbmQgdGhlaXIgY2hhbmdlcycKK3Rlc3RfcmViYXNlX3NhbWVfaGVhZCBzdWNjZXNzIG5vb3Agc2FtZSBzdWNjZXNzIG5vb3AtZm9yY2UgZGlmZiAtLW9udG8gQiBCCit0ZXN0X3JlYmFzZV9zYW1lX2hlYWQgc3VjY2VzcyBub29wIHNhbWUgc3VjY2VzcyBub29wLWZvcmNlIGRpZmYgLS1vbnRvIEIuLi4gQgordGVzdF9yZWJhc2Vfc2FtZV9oZWFkIHN1Y2Nlc3Mgbm9vcCBzYW1lIHN1Y2Nlc3Mgd29yayBkaWZmIC0tb250byBtYXN0ZXIuLi4gbWFzdGVyCit0ZXN0X3JlYmFzZV9zYW1lX2hlYWQgc3VjY2VzcyBub29wIHNhbWUgc3VjY2VzcyB3b3JrIGRpZmYgLS1rZWVwLWJhc2UgbWFzdGVyCit0ZXN0X3JlYmFzZV9zYW1lX2hlYWQgc3VjY2VzcyBub29wIHNhbWUgc3VjY2VzcyB3b3JrIGRpZmYgLS1rZWVwLWJhc2UKK3Rlc3RfcmViYXNlX3NhbWVfaGVhZCBmYWlsdXJlIHdvcmsgc2FtZSBzdWNjZXNzIHdvcmsgZGlmZiAtLWZvcmstcG9pbnQgLS1vbnRvIEIgQgordGVzdF9yZWJhc2Vfc2FtZV9oZWFkIGZhaWx1cmUgd29yayBzYW1lIHN1Y2Nlc3Mgd29yayBkaWZmIC0tZm9yay1wb2ludCAtLW9udG8gQi4uLiBCCit0ZXN0X3JlYmFzZV9zYW1lX2hlYWQgc3VjY2VzcyBub29wIHNhbWUgc3VjY2VzcyB3b3JrIGRpZmYgLS1mb3JrLXBvaW50IC0tb250byBtYXN0ZXIuLi4gbWFzdGVyCit0ZXN0X3JlYmFzZV9zYW1lX2hlYWQgc3VjY2VzcyBub29wIHNhbWUgc3VjY2VzcyB3b3JrIGRpZmYgLS1mb3JrLXBvaW50IC0ta2VlcC1iYXNlIG1hc3RlcgorCit0ZXN0X2RvbmUKZGlmZiAtLWdpdCBhL3QvdDM0MzQtcmViYXNlLWkxOG4uc2ggYi90L3QzNDM0LXJlYmFzZS1pMThuLnNoCm5ldyBmaWxlIG1vZGUgMTAwNzU1CmluZGV4IDAwMDAwMDAuLjRiNWIxMjgKLS0tIC9kZXYvbnVsbAorKysgYi90L3QzNDM0LXJlYmFzZS1pMThuLnNoCkBAIC0wLDAgKzEsODQgQEAKKyMhL2Jpbi9zaAorIworIyBDb3B5cmlnaHQgKGMpIDIwMTkgRG9hbiBUcmFuIENvbmcgRGFuaAorIworCit0ZXN0X2Rlc2NyaXB0aW9uPSdyZWJhc2Ugd2l0aCBjaGFuZ2luZyBlbmNvZGluZworCitJbml0aWFsIHNldHVwOgorCisxIC0gMiAgICAgICAgICAgICAgbWFzdGVyCisgXAorICAzIC0gNCAgICAgICAgICAgIGZpcnN0CisgICBcCisgICAgNSAtIDYgICAgICAgICAgc2Vjb25kCisnCisKKy4gLi90ZXN0LWxpYi5zaAorCitjb21wYXJlX21zZyAoKSB7CisJaWNvbnYgLWYgIiQyIiAtdCAiJDMiICIkVEVTVF9ESVJFQ1RPUlkvdDM0MzQvJDEiID5leHBlY3QgJiYKKwlnaXQgY2F0LWZpbGUgY29tbWl0IEhFQUQgPnJhdyAmJgorCXNlZCAiMSwvXiQvZCIgcmF3ID5hY3R1YWwgJiYKKwl0ZXN0X2NtcCBleHBlY3QgYWN0dWFsCit9CisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3Mgc2V0dXAgJworCXRlc3RfY29tbWl0IG9uZSAmJgorCWdpdCBicmFuY2ggZmlyc3QgJiYKKwl0ZXN0X2NvbW1pdCB0d28gJiYKKwlnaXQgc3dpdGNoIGZpcnN0ICYmCisJdGVzdF9jb21taXQgdGhyZWUgJiYKKwlnaXQgYnJhbmNoIHNlY29uZCAmJgorCXRlc3RfY29tbWl0IGZvdXIgJiYKKwlnaXQgc3dpdGNoIHNlY29uZCAmJgorCXRlc3RfY29tbWl0IGZpdmUgJiYKKwl0ZXN0X2NvbW1pdCBzaXgKKycKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAncmViYXNlIC0tcmViYXNlLW1lcmdlcyB1cGRhdGUgZW5jb2RpbmcgZXVjSlAgdG8gVVRGLTgnICcKKwlnaXQgc3dpdGNoIC1jIG1lcmdlLWV1Y0pQLVVURi04IGZpcnN0ICYmCisJZ2l0IGNvbmZpZyBpMThuLmNvbW1pdGVuY29kaW5nIGV1Y0pQICYmCisJZ2l0IG1lcmdlIC1GICIkVEVTVF9ESVJFQ1RPUlkvdDM0MzQvZXVjSlAudHh0IiBzZWNvbmQgJiYKKwlnaXQgY29uZmlnIGkxOG4uY29tbWl0ZW5jb2RpbmcgVVRGLTggJiYKKwlnaXQgcmViYXNlIC0tcmViYXNlLW1lcmdlcyBtYXN0ZXIgJiYKKwljb21wYXJlX21zZyBldWNKUC50eHQgZXVjSlAgVVRGLTgKKycKKwordGVzdF9leHBlY3RfZmFpbHVyZSAncmViYXNlIC0tcmViYXNlLW1lcmdlcyB1cGRhdGUgZW5jb2RpbmcgZXVjSlAgdG8gSVNPLTIwMjItSlAnICcKKwlnaXQgc3dpdGNoIC1jIG1lcmdlLWV1Y0pQLUlTTy0yMDIyLUpQIGZpcnN0ICYmCisJZ2l0IGNvbmZpZyBpMThuLmNvbW1pdGVuY29kaW5nIGV1Y0pQICYmCisJZ2l0IG1lcmdlIC1GICIkVEVTVF9ESVJFQ1RPUlkvdDM0MzQvZXVjSlAudHh0IiBzZWNvbmQgJiYKKwlnaXQgY29uZmlnIGkxOG4uY29tbWl0ZW5jb2RpbmcgSVNPLTIwMjItSlAgJiYKKwlnaXQgcmViYXNlIC0tcmViYXNlLW1lcmdlcyBtYXN0ZXIgJiYKKwljb21wYXJlX21zZyBldWNKUC50eHQgZXVjSlAgSVNPLTIwMjItSlAKKycKKwordGVzdF9yZWJhc2VfY29udGludWVfdXBkYXRlX2VuY29kZSAoKSB7CisJb2xkPSQxCisJbmV3PSQyCisJbXNnZmlsZT0kMworCXRlc3RfZXhwZWN0X3N1Y2Nlc3MgInJlYmFzZSAtLWNvbnRpbnVlIHVwZGF0ZSBmcm9tICRvbGQgdG8gJG5ldyIgJworCQkoZ2l0IHJlYmFzZSAtLWFib3J0IHx8IDogYWJvcnQgY3VycmVudCBnaXQtcmViYXNlIGZhaWx1cmUpICYmCisJCWdpdCBzd2l0Y2ggLWMgY29uZmxpY3QtJG9sZC0kbmV3IG9uZSAmJgorCQllY2hvIGZvci1jb25mbGljdCA+dHdvLnQgJiYKKwkJZ2l0IGFkZCB0d28udCAmJgorCQlnaXQgY29uZmlnIGkxOG4uY29tbWl0ZW5jb2RpbmcgJG9sZCAmJgorCQlnaXQgY29tbWl0IC1GICIkVEVTVF9ESVJFQ1RPUlkvdDM0MzQvJG1zZ2ZpbGUiICYmCisJCWdpdCBjb25maWcgaTE4bi5jb21taXRlbmNvZGluZyAkbmV3ICYmCisJCXRlc3RfbXVzdF9mYWlsIGdpdCByZWJhc2UgLW0gbWFzdGVyICYmCisJCXRlc3QgLWYgLmdpdC9yZWJhc2UtbWVyZ2UvbWVzc2FnZSAmJgorCQlnaXQgc3RyaXBzcGFjZSA8LmdpdC9yZWJhc2UtbWVyZ2UvbWVzc2FnZSA+dHdvLnQgJiYKKwkJZ2l0IGFkZCB0d28udCAmJgorCQlnaXQgcmViYXNlIC0tY29udGludWUgJiYKKwkJY29tcGFyZV9tc2cgJG1zZ2ZpbGUgJG9sZCAkbmV3ICYmCisJCTogZ2l0LWNvbW1pdCBhc3N1bWUgaW52YWxpZCB1dGYtOCBpcyBsYXRpbjEgJiYKKwkJdGVzdF9jbXAgZXhwZWN0IHR3by50CisJJworfQorCit0ZXN0X3JlYmFzZV9jb250aW51ZV91cGRhdGVfZW5jb2RlIElTTy04ODU5LTEgVVRGLTggSVNPODg1OS0xLnR4dAordGVzdF9yZWJhc2VfY29udGludWVfdXBkYXRlX2VuY29kZSBldWNKUCBVVEYtOCBldWNKUC50eHQKK3Rlc3RfcmViYXNlX2NvbnRpbnVlX3VwZGF0ZV9lbmNvZGUgZXVjSlAgSVNPLTIwMjItSlAgZXVjSlAudHh0CisKK3Rlc3RfZG9uZQpkaWZmIC0tZ2l0IGEvdC90MzQzNC9JU084ODU5LTEudHh0IGIvdC90MzQzNC9JU084ODU5LTEudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjdjYmVmMGUKLS0tIC9kZXYvbnVsbAorKysgYi90L3QzNDM0L0lTTzg4NTktMS50eHQKQEAgLTAsMCArMSwzIEBACivEy9HP1gorCivBYudk6GZnCmRpZmYgLS1naXQgYS90L3QzNDM0L2V1Y0pQLnR4dCBiL3QvdDM0MzQvZXVjSlAudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjU0NmYyYWEKLS0tIC9kZXYvbnVsbAorKysgYi90L3QzNDM0L2V1Y0pQLnR4dApAQCAtMCwwICsxLDQgQEAKK6TPpOyk0qTbpNUKKworpLekxqSkpOukzqSsoaKkpKTrpM6kx6GjCivfwMnNpNuk7KTXpOqk3aTspN6k06SwpOqk7aTYoaMKZGlmZiAtLWdpdCBhL3QvdDM1MDEtcmV2ZXJ0LWNoZXJyeS1waWNrLnNoIGIvdC90MzUwMS1yZXZlcnQtY2hlcnJ5LXBpY2suc2gKaW5kZXggZDFjNjhhZi4uMWM1MWE5MSAxMDA3NTUKLS0tIGEvdC90MzUwMS1yZXZlcnQtY2hlcnJ5LXBpY2suc2gKKysrIGIvdC90MzUwMS1yZXZlcnQtY2hlcnJ5LXBpY2suc2gKQEAgLTEwNiw3ICsxMDYsNyBAQAogCXJtIC1yZiAqICYmCiAJZ2l0IGNoZXJyeS1waWNrIGluaXRpYWwgJiYKIAlnaXQgZGlmZiAtLXF1aWV0IGluaXRpYWwgJiYKLQkhIHRlc3RfY21wX3JldiBpbml0aWFsIEhFQUQKKwl0ZXN0X2NtcF9yZXYgISBpbml0aWFsIEhFQUQKICcKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnY2hlcnJ5LXBpY2sgIi0iIHRvIHBpY2sgZnJvbSBwcmV2aW91cyBicmFuY2gnICcKZGlmZiAtLWdpdCBhL3QvdDM1MDYtY2hlcnJ5LXBpY2stZmYuc2ggYi90L3QzNTA2LWNoZXJyeS1waWNrLWZmLnNoCmluZGV4IDEyN2RkMDAuLjlkNWFkYmMgMTAwNzU1Ci0tLSBhL3QvdDM1MDYtY2hlcnJ5LXBpY2stZmYuc2gKKysrIGIvdC90MzUwNi1jaGVycnktcGljay1mZi5zaApAQCAtMTYsNyArMTYsMTEgQEAKIAlnaXQgYWRkIGZpbGUxICYmCiAJdGVzdF90aWNrICYmCiAJZ2l0IGNvbW1pdCAtbSAic2Vjb25kIiAmJgotCWdpdCB0YWcgc2Vjb25kCisJZ2l0IHRhZyBzZWNvbmQgJiYKKwl0ZXN0X29pZF9jYWNoZSA8PC1FT0YKKwljcF9mZiBzaGExOjFkZjE5MmNkOGJjNThhMmIyNzVkODQyY2VkZTRkMjIxYWQ5MDAwZDEKKwljcF9mZiBzaGEyNTY6ZTcwZDZiN2ZjMDY0YmRkYjUxNmI4ZDUxMmM5MDU3MDk0Yjk2Y2U2ZmYwOGUxMjA4MGFjYzRmZTdmMWQ2MGExZAorCUVPRgogJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdjaGVycnktcGljayB1c2luZyAtLWZmIGZhc3QgZm9yd2FyZHMnICcKQEAgLTEwMiw3ICsxMDYsNyBAQAogCWdpdCBhZGQgZmlsZTIgJiYKIAlnaXQgY29tbWl0IC0tYW1lbmQgLW0gImZpbGUyIiAmJgogCWdpdCBjaGVycnktcGljayAtLWZmIGZpcnN0ICYmCi0JdGVzdCAiJChnaXQgcmV2LXBhcnNlIC0tdmVyaWZ5IEhFQUQpIiA9ICIxZGYxOTJjZDhiYzU4YTJiMjc1ZDg0MmNlZGU0ZDIyMWFkOTAwMGQxIgorCXRlc3QgIiQoZ2l0IHJldi1wYXJzZSAtLXZlcmlmeSBIRUFEKSIgPSAiJCh0ZXN0X29pZCBjcF9mZikiCiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2NoZXJyeS1waWNrIC0tZmYgb24gdW5ib3JuIGJyYW5jaCcgJwpkaWZmIC0tZ2l0IGEvdC90MzUwOC1jaGVycnktcGljay1tYW55LWNvbW1pdHMuc2ggYi90L3QzNTA4LWNoZXJyeS1waWNrLW1hbnktY29tbWl0cy5zaAppbmRleCBiNDU3MzMzLi4yMzA3MGE3IDEwMDc1NQotLS0gYS90L3QzNTA4LWNoZXJyeS1waWNrLW1hbnktY29tbWl0cy5zaAorKysgYi90L3QzNTA4LWNoZXJyeS1waWNrLW1hbnktY29tbWl0cy5zaApAQCAtNSw3ICs1LDcgQEAKIC4gLi90ZXN0LWxpYi5zaAogCiBjaGVja19oZWFkX2RpZmZlcnNfZnJvbSgpIHsKLQkhIHRlc3RfY21wX3JldiBIRUFEICIkMSIKKwl0ZXN0X2NtcF9yZXYgISBIRUFEICIkMSIKIH0KIAogY2hlY2tfaGVhZF9lcXVhbHMoKSB7CmRpZmYgLS1naXQgYS90L3QzNjAwLXJtLnNoIGIvdC90MzYwMC1ybS5zaAppbmRleCA2NjI4MmE3Li44YzhjY2E1IDEwMDc1NQotLS0gYS90L3QzNjAwLXJtLnNoCisrKyBiL3QvdDM2MDAtcm0uc2gKQEAgLTI0MCwxMiArMjQwLDE0IEBACiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2Nob2tpbmcgImdpdCBybSIgc2hvdWxkIG5vdCBsZXQgaXQgZGllIHdpdGggY3J1ZnQnICcKKwl0ZXN0X29pZF9pbml0ICYmCiAJZ2l0IHJlc2V0IC1xIC0taGFyZCAmJgogCXRlc3Rfd2hlbl9maW5pc2hlZCAicm0gLWYgLmdpdC9pbmRleC5sb2NrICYmIGdpdCByZXNldCAtcSAtLWhhcmQiICYmCiAJaT0wICYmCisJaGFzaD0kKHRlc3Rfb2lkIGRlYWRiZWVmKSAmJgogCXdoaWxlIHRlc3QgJGkgLWx0IDEyMDAwCiAJZG8KLQkJZWNobyAiMTAwNjQ0IDEyMzQ1Njc4OTAxMjM0NTY3ODkwMTIzNDU2Nzg5MDEyMzQ1Njc4OTAgMAlzb21lLWZpbGUtJGkiCisJCWVjaG8gIjEwMDY0NCAkaGFzaCAwCXNvbWUtZmlsZS0kaSIKIAkJaT0kKCggJGkgKyAxICkpCiAJZG9uZSB8IGdpdCB1cGRhdGUtaW5kZXggLS1pbmRleC1pbmZvICYmCiAJZ2l0IHJtIC1uICJzb21lLWZpbGUtKiIgfCA6ICYmCmRpZmYgLS1naXQgYS90L3QzNzAxLWFkZC1pbnRlcmFjdGl2ZS5zaCBiL3QvdDM3MDEtYWRkLWludGVyYWN0aXZlLnNoCmluZGV4IDY5OTkxYTMuLmQ0ZjkzODYgMTAwNzU1Ci0tLSBhL3QvdDM3MDEtYWRkLWludGVyYWN0aXZlLnNoCisrKyBiL3QvdDM3MDEtYWRkLWludGVyYWN0aXZlLnNoCkBAIC0zMTQsNyArMzE0LDcgQEAKIAlnaXQgY29tbWl0IC1hbSAiY2xlYXIgbG9jYWwgY2hhbmdlcyIgJiYKIAlnaXQgYXBwbHkgcGF0Y2ggJiYKIAlwcmludGYgIiVzXG4iIHMgeSB5IHwgZ2l0IGFkZCAtcCBmaWxlIDI+ZXJyb3IgfAotCQlzZWQgLW4gLWUgInMvXlN0YWdlIHRoaXMgaHVua1teQF0qXChAQCAuKlwpL1wxLyIgXAorCQlzZWQgLW4gLWUgInMvXihbMS0yXVwvWzEtMl0pIFN0YWdlIHRoaXMgaHVua1teQF0qXChAQCAuKlwpL1wxLyIgXAogCQkgICAgICAgLWUgIi9eWy0rQCBcXFxcXSIvcCAgPm91dHB1dCAmJgogCXRlc3RfbXVzdF9iZV9lbXB0eSBlcnJvciAmJgogCWdpdCBkaWZmIC0tY2FjaGVkID5kaWZmICYmCkBAIC02NDcsNCArNjQ3LDI5IEBACiAJdGVzdF93cml0ZV9saW5lcyBhIGIgYSBiIGEgYSBiIGEgYiBhID5leHBlY3QgJiYKIAl0ZXN0X2NtcCBleHBlY3QgYQogJworCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdzaG93IGhlbHAgZnJvbSBhZGQtLWhlbHBlcicgJworCWdpdCByZXNldCAtLWhhcmQgJiYKKwljYXQgPmV4cGVjdCA8PC1FT0YgJiYKKworCTxCT0xEPioqKiBDb21tYW5kcyAqKio8UkVTRVQ+CisJICAxOiA8Qk9MRDtCTFVFPnM8UkVTRVQ+dGF0dXMJICAyOiA8Qk9MRDtCTFVFPnU8UkVTRVQ+cGRhdGUJICAzOiA8Qk9MRDtCTFVFPnI8UkVTRVQ+ZXZlcnQJICA0OiA8Qk9MRDtCTFVFPmE8UkVTRVQ+ZGQgdW50cmFja2VkCisJICA1OiA8Qk9MRDtCTFVFPnA8UkVTRVQ+YXRjaAkgIDY6IDxCT0xEO0JMVUU+ZDxSRVNFVD5pZmYJICA3OiA8Qk9MRDtCTFVFPnE8UkVTRVQ+dWl0CSAgODogPEJPTEQ7QkxVRT5oPFJFU0VUPmVscAorCTxCT0xEO0JMVUU+V2hhdCBub3c8UkVTRVQ+PiA8Qk9MRDtSRUQ+c3RhdHVzICAgICAgICAtIHNob3cgcGF0aHMgd2l0aCBjaGFuZ2VzPFJFU0VUPgorCTxCT0xEO1JFRD51cGRhdGUgICAgICAgIC0gYWRkIHdvcmtpbmcgdHJlZSBzdGF0ZSB0byB0aGUgc3RhZ2VkIHNldCBvZiBjaGFuZ2VzPFJFU0VUPgorCTxCT0xEO1JFRD5yZXZlcnQgICAgICAgIC0gcmV2ZXJ0IHN0YWdlZCBzZXQgb2YgY2hhbmdlcyBiYWNrIHRvIHRoZSBIRUFEIHZlcnNpb248UkVTRVQ+CisJPEJPTEQ7UkVEPnBhdGNoICAgICAgICAgLSBwaWNrIGh1bmtzIGFuZCB1cGRhdGUgc2VsZWN0aXZlbHk8UkVTRVQ+CisJPEJPTEQ7UkVEPmRpZmYgICAgICAgICAgLSB2aWV3IGRpZmYgYmV0d2VlbiBIRUFEIGFuZCBpbmRleDxSRVNFVD4KKwk8Qk9MRDtSRUQ+YWRkIHVudHJhY2tlZCAtIGFkZCBjb250ZW50cyBvZiB1bnRyYWNrZWQgZmlsZXMgdG8gdGhlIHN0YWdlZCBzZXQgb2YgY2hhbmdlczxSRVNFVD4KKwk8Qk9MRD4qKiogQ29tbWFuZHMgKioqPFJFU0VUPgorCSAgMTogPEJPTEQ7QkxVRT5zPFJFU0VUPnRhdHVzCSAgMjogPEJPTEQ7QkxVRT51PFJFU0VUPnBkYXRlCSAgMzogPEJPTEQ7QkxVRT5yPFJFU0VUPmV2ZXJ0CSAgNDogPEJPTEQ7QkxVRT5hPFJFU0VUPmRkIHVudHJhY2tlZAorCSAgNTogPEJPTEQ7QkxVRT5wPFJFU0VUPmF0Y2gJICA2OiA8Qk9MRDtCTFVFPmQ8UkVTRVQ+aWZmCSAgNzogPEJPTEQ7QkxVRT5xPFJFU0VUPnVpdAkgIDg6IDxCT0xEO0JMVUU+aDxSRVNFVD5lbHAKKwk8Qk9MRDtCTFVFPldoYXQgbm93PFJFU0VUPj4kU1AKKwlCeWUuCisJRU9GCisJdGVzdF93cml0ZV9saW5lcyBoIHwgR0lUX1BBR0VSX0lOX1VTRT10cnVlIFRFUk09dnQxMDAgZ2l0IGFkZCAtaSA+YWN0dWFsLmNvbG9yZWQgJiYKKwl0ZXN0X2RlY29kZV9jb2xvciA8YWN0dWFsLmNvbG9yZWQgPmFjdHVhbCAmJgorCXRlc3RfaTE4bmNtcCBleHBlY3QgYWN0dWFsCisnCisKIHRlc3RfZG9uZQpkaWZmIC0tZ2l0IGEvdC90MzgwMC1ta3RhZy5zaCBiL3QvdDM4MDAtbWt0YWcuc2gKaW5kZXggOGViNDc5NC4uNjRkY2M1ZSAxMDA3NTUKLS0tIGEvdC90MzgwMC1ta3RhZy5zaAorKysgYi90L3QzODAwLW1rdGFnLnNoCkBAIC0yMyw2ICsyMyw3IEBACiAjIGZpcnN0IGNyZWF0ZSBhIGNvbW1pdCwgc28gd2UgaGF2ZSBhIHZhbGlkIG9iamVjdC90eXBlCiAjIGZvciB0aGUgdGFnLgogdGVzdF9leHBlY3Rfc3VjY2VzcyAnc2V0dXAnICcKKwl0ZXN0X29pZF9pbml0ICYmCiAJZWNobyBIZWxsbyA+QSAmJgogCWdpdCB1cGRhdGUtaW5kZXggLS1hZGQgQSAmJgogCWdpdCBjb21taXQgLW0gIkluaXRpYWwgY29tbWl0IiAmJgpAQCAtNjksMjggKzcwLDI4IEBACiAjICA0LiB0eXBlIGxpbmUgbGFiZWwgY2hlY2sKIAogY2F0ID50YWcuc2lnIDw8RU9GCi1vYmplY3QgNzc5ZTliMzM5ODZiMWMyNjcwZmZmNTJjNTA2NzYwMzExN2IzZTg5NQorb2JqZWN0ICRoZWFkCiB4eHh4IHRhZwogdGFnIG15dGFnCiB0YWdnZXIgLiA8PiAwICswMDAwCiAKIEVPRgogCi1jaGVja192ZXJpZnlfZmFpbHVyZSAnInR5cGUiIGxpbmUgbGFiZWwgY2hlY2snICdeZXJyb3I6IGNoYXI0NzogLioiXFxudHlwZSAiJCcKK2NoZWNrX3ZlcmlmeV9mYWlsdXJlICcidHlwZSIgbGluZSBsYWJlbCBjaGVjaycgJ15lcnJvcjogY2hhci4qOiAuKiJcXG50eXBlICIkJwogCiAjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKICMgIDUuIHR5cGUgbGluZSBlb2wgY2hlY2sKIAotZWNobyAib2JqZWN0IDc3OWU5YjMzOTg2YjFjMjY3MGZmZjUyYzUwNjc2MDMxMTdiM2U4OTUiID50YWcuc2lnCitlY2hvICJvYmplY3QgJGhlYWQiID50YWcuc2lnCiBwcmludGYgInR5cGUgdGFnc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3Nzc3NzcyIgPj50YWcuc2lnCiAKLWNoZWNrX3ZlcmlmeV9mYWlsdXJlICcidHlwZSIgbGluZSBlb2wgY2hlY2snICdeZXJyb3I6IGNoYXI0ODogLioiXFxuIiQnCitjaGVja192ZXJpZnlfZmFpbHVyZSAnInR5cGUiIGxpbmUgZW9sIGNoZWNrJyAnXmVycm9yOiBjaGFyLio6IC4qIlxcbiIkJwogCiAjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKICMgIDYuIHRhZyBsaW5lIGxhYmVsIGNoZWNrICMxCiAKIGNhdCA+dGFnLnNpZyA8PEVPRgotb2JqZWN0IDc3OWU5YjMzOTg2YjFjMjY3MGZmZjUyYzUwNjc2MDMxMTdiM2U4OTUKK29iamVjdCAkaGVhZAogdHlwZSB0YWcKIHh4eCBteXRhZwogdGFnZ2VyIC4gPD4gMCArMDAwMApAQCAtOTgsMzcgKzk5LDM3IEBACiBFT0YKIAogY2hlY2tfdmVyaWZ5X2ZhaWx1cmUgJyJ0YWciIGxpbmUgbGFiZWwgY2hlY2sgIzEnIFwKLQknXmVycm9yOiBjaGFyNTc6IG5vICJ0YWcgIiBmb3VuZCQnCisJJ15lcnJvcjogY2hhci4qOiBubyAidGFnICIgZm91bmQkJwogCiAjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKICMgIDcuIHRhZyBsaW5lIGxhYmVsIGNoZWNrICMyCiAKIGNhdCA+dGFnLnNpZyA8PEVPRgotb2JqZWN0IDc3OWU5YjMzOTg2YjFjMjY3MGZmZjUyYzUwNjc2MDMxMTdiM2U4OTUKK29iamVjdCAkaGVhZAogdHlwZSB0YWdnZ2dnZ2dnZ2dnZ2dnZ2dnZ2dnZ2dnZ2dnZ2dnZ2cKIHRhZwogRU9GCiAKIGNoZWNrX3ZlcmlmeV9mYWlsdXJlICcidGFnIiBsaW5lIGxhYmVsIGNoZWNrICMyJyBcCi0JJ15lcnJvcjogY2hhcjg3OiBubyAidGFnICIgZm91bmQkJworCSdeZXJyb3I6IGNoYXIuKjogbm8gInRhZyAiIGZvdW5kJCcKIAogIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCiAjICA4LiB0eXBlIGxpbmUgdHlwZS1uYW1lIGxlbmd0aCBjaGVjawogCiBjYXQgPnRhZy5zaWcgPDxFT0YKLW9iamVjdCA3NzllOWIzMzk4NmIxYzI2NzBmZmY1MmM1MDY3NjAzMTE3YjNlODk1CitvYmplY3QgJGhlYWQKIHR5cGUgdGFnZ2dnZ2dnZ2dnZ2dnZ2dnZ2dnZ2dnZ2dnZ2dnZ2dnCiB0YWcgbXl0YWcKIEVPRgogCiBjaGVja192ZXJpZnlfZmFpbHVyZSAnInR5cGUiIGxpbmUgdHlwZS1uYW1lIGxlbmd0aCBjaGVjaycgXAotCSdeZXJyb3I6IGNoYXI1MzogdHlwZSB0b28gbG9uZyQnCisJJ15lcnJvcjogY2hhci4qOiB0eXBlIHRvbyBsb25nJCcKIAogIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCiAjICA5LiB2ZXJpZnkgb2JqZWN0IChTSEExL3R5cGUpIGNoZWNrCiAKIGNhdCA+dGFnLnNpZyA8PEVPRgotb2JqZWN0IDc3OWU5YjMzOTg2YjFjMjY3MGZmZjUyYzUwNjc2MDMxMTdiM2U4OTUKK29iamVjdCAkKHRlc3Rfb2lkIGRlYWRiZWVmKQogdHlwZSB0YWdnZ2cKIHRhZyBteXRhZwogdGFnZ2VyIC4gPD4gMCArMDAwMApAQCAtMTUwLDcgKzE1MSw3IEBACiBFT0YKIAogY2hlY2tfdmVyaWZ5X2ZhaWx1cmUgJ3ZlcmlmeSB0YWctbmFtZSBjaGVjaycgXAotCSdeZXJyb3I6IGNoYXI2NzogY291bGQgbm90IHZlcmlmeSB0YWcgbmFtZSQnCisJJ15lcnJvcjogY2hhci4qOiBjb3VsZCBub3QgdmVyaWZ5IHRhZyBuYW1lJCcKIAogIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCiAjIDExLiB0YWdnZXIgbGluZSBsYWJlbCBjaGVjayAjMQpAQCAtMTY0LDcgKzE2NSw3IEBACiBFT0YKIAogY2hlY2tfdmVyaWZ5X2ZhaWx1cmUgJyJ0YWdnZXIiIGxpbmUgbGFiZWwgY2hlY2sgIzEnIFwKLQknXmVycm9yOiBjaGFyNzA6IGNvdWxkIG5vdCBmaW5kICJ0YWdnZXIgIiQnCisJJ15lcnJvcjogY2hhci4qOiBjb3VsZCBub3QgZmluZCAidGFnZ2VyICIkJwogCiAjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKICMgMTIuIHRhZ2dlciBsaW5lIGxhYmVsIGNoZWNrICMyCkBAIC0xNzksNyArMTgwLDcgQEAKIEVPRgogCiBjaGVja192ZXJpZnlfZmFpbHVyZSAnInRhZ2dlciIgbGluZSBsYWJlbCBjaGVjayAjMicgXAotCSdeZXJyb3I6IGNoYXI3MDogY291bGQgbm90IGZpbmQgInRhZ2dlciAiJCcKKwknXmVycm9yOiBjaGFyLio6IGNvdWxkIG5vdCBmaW5kICJ0YWdnZXIgIiQnCiAKICMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIwogIyAxMy4gZGlzYWxsb3cgbWlzc2luZyB0YWcgYXV0aG9yIG5hbWUKQEAgLTE5NCw3ICsxOTUsNyBAQAogRU9GCiAKIGNoZWNrX3ZlcmlmeV9mYWlsdXJlICdkaXNhbGxvdyBtaXNzaW5nIHRhZyBhdXRob3IgbmFtZScgXAotCSdeZXJyb3I6IGNoYXI3NzogbWlzc2luZyB0YWdnZXIgbmFtZSQnCisJJ15lcnJvcjogY2hhci4qOiBtaXNzaW5nIHRhZ2dlciBuYW1lJCcKIAogIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCiAjIDE0LiBkaXNhbGxvdyBtaXNzaW5nIHRhZyBhdXRob3IgbmFtZQpAQCAtMjA5LDcgKzIxMCw3IEBACiBFT0YKIAogY2hlY2tfdmVyaWZ5X2ZhaWx1cmUgJ2Rpc2FsbG93IG1hbGZvcm1lZCB0YWdnZXInIFwKLQknXmVycm9yOiBjaGFyNzc6IG1hbGZvcm1lZCB0YWdnZXIgZmllbGQkJworCSdeZXJyb3I6IGNoYXIuKjogbWFsZm9ybWVkIHRhZ2dlciBmaWVsZCQnCiAKICMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIwogIyAxNS4gYWxsb3cgZW1wdHkgdGFnIGVtYWlsCkBAIC0yMzgsNyArMjM5LDcgQEAKIEVPRgogCiBjaGVja192ZXJpZnlfZmFpbHVyZSAnZGlzYWxsb3cgc3BhY2VzIGluIHRhZyBlbWFpbCcgXAotCSdeZXJyb3I6IGNoYXI3NzogbWFsZm9ybWVkIHRhZ2dlciBmaWVsZCQnCisJJ15lcnJvcjogY2hhci4qOiBtYWxmb3JtZWQgdGFnZ2VyIGZpZWxkJCcKIAogIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCiAjIDE3LiBkaXNhbGxvdyBtaXNzaW5nIHRhZyB0aW1lc3RhbXAKQEAgLTI1Miw3ICsyNTMsNyBAQAogRU9GCiAKIGNoZWNrX3ZlcmlmeV9mYWlsdXJlICdkaXNhbGxvdyBtaXNzaW5nIHRhZyB0aW1lc3RhbXAnIFwKLQknXmVycm9yOiBjaGFyMTA3OiBtaXNzaW5nIHRhZyB0aW1lc3RhbXAkJworCSdeZXJyb3I6IGNoYXIuKjogbWlzc2luZyB0YWcgdGltZXN0YW1wJCcKIAogIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCiAjIDE4LiBkZXRlY3QgaW52YWxpZCB0YWcgdGltZXN0YW1wMQpAQCAtMjY2LDcgKzI2Nyw3IEBACiBFT0YKIAogY2hlY2tfdmVyaWZ5X2ZhaWx1cmUgJ2RldGVjdCBpbnZhbGlkIHRhZyB0aW1lc3RhbXAxJyBcCi0JJ15lcnJvcjogY2hhcjEwNzogbWlzc2luZyB0YWcgdGltZXN0YW1wJCcKKwknXmVycm9yOiBjaGFyLio6IG1pc3NpbmcgdGFnIHRpbWVzdGFtcCQnCiAKICMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIwogIyAxOS4gZGV0ZWN0IGludmFsaWQgdGFnIHRpbWVzdGFtcDIKQEAgLTI4MCw3ICsyODEsNyBAQAogRU9GCiAKIGNoZWNrX3ZlcmlmeV9mYWlsdXJlICdkZXRlY3QgaW52YWxpZCB0YWcgdGltZXN0YW1wMicgXAotCSdeZXJyb3I6IGNoYXIxMTE6IG1hbGZvcm1lZCB0YWcgdGltZXN0YW1wJCcKKwknXmVycm9yOiBjaGFyLio6IG1hbGZvcm1lZCB0YWcgdGltZXN0YW1wJCcKIAogIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCiAjIDIwLiBkZXRlY3QgaW52YWxpZCB0YWcgdGltZXpvbmUxCkBAIC0yOTQsNyArMjk1LDcgQEAKIEVPRgogCiBjaGVja192ZXJpZnlfZmFpbHVyZSAnZGV0ZWN0IGludmFsaWQgdGFnIHRpbWV6b25lMScgXAotCSdeZXJyb3I6IGNoYXIxMTg6IG1hbGZvcm1lZCB0YWcgdGltZXpvbmUkJworCSdeZXJyb3I6IGNoYXIuKjogbWFsZm9ybWVkIHRhZyB0aW1lem9uZSQnCiAKICMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIwogIyAyMS4gZGV0ZWN0IGludmFsaWQgdGFnIHRpbWV6b25lMgpAQCAtMzA4LDcgKzMwOSw3IEBACiBFT0YKIAogY2hlY2tfdmVyaWZ5X2ZhaWx1cmUgJ2RldGVjdCBpbnZhbGlkIHRhZyB0aW1lem9uZTInIFwKLQknXmVycm9yOiBjaGFyMTE4OiBtYWxmb3JtZWQgdGFnIHRpbWV6b25lJCcKKwknXmVycm9yOiBjaGFyLio6IG1hbGZvcm1lZCB0YWcgdGltZXpvbmUkJwogCiAjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKICMgMjIuIGRldGVjdCBpbnZhbGlkIHRhZyB0aW1lem9uZTMKQEAgLTMyMiw3ICszMjMsNyBAQAogRU9GCiAKIGNoZWNrX3ZlcmlmeV9mYWlsdXJlICdkZXRlY3QgaW52YWxpZCB0YWcgdGltZXpvbmUzJyBcCi0JJ15lcnJvcjogY2hhcjExODogbWFsZm9ybWVkIHRhZyB0aW1lem9uZSQnCisJJ15lcnJvcjogY2hhci4qOiBtYWxmb3JtZWQgdGFnIHRpbWV6b25lJCcKIAogIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCiAjIDIzLiBkZXRlY3QgaW52YWxpZCBoZWFkZXIgZW50cnkKQEAgLTMzNyw3ICszMzgsNyBAQAogRU9GCiAKIGNoZWNrX3ZlcmlmeV9mYWlsdXJlICdkZXRlY3QgaW52YWxpZCBoZWFkZXIgZW50cnknIFwKLQknXmVycm9yOiBjaGFyMTI0OiB0cmFpbGluZyBnYXJiYWdlIGluIHRhZyBoZWFkZXIkJworCSdeZXJyb3I6IGNoYXIuKjogdHJhaWxpbmcgZ2FyYmFnZSBpbiB0YWcgaGVhZGVyJCcKIAogIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCiAjIDI0LiBjcmVhdGUgdmFsaWQgdGFnCmRpZmYgLS1naXQgYS90L3QzOTAwLWkxOG4tY29tbWl0LnNoIGIvdC90MzkwMC1pMThuLWNvbW1pdC5zaAppbmRleCBiOTJmZjk1Li5kMjc3YTlmIDEwMDc1NQotLS0gYS90L3QzOTAwLWkxOG4tY29tbWl0LnNoCisrKyBiL3QvdDM5MDAtaTE4bi1jb21taXQuc2gKQEAgLTIwNCw0ICsyMDQsNDEgQEAKIAogdGVzdF9jb21taXRfYXV0b3NxdWFzaF9mbGFncyBJU08tMjAyMi1KUCBzcXVhc2gKIAordGVzdF9jb21taXRfYXV0b3NxdWFzaF9tdWx0aV9lbmNvZGluZyAoKSB7CisJZmxhZz0kMQorCW9sZD0kMgorCW5ldz0kMworCW1zZz0kNAorCXRlc3RfZXhwZWN0X3N1Y2Nlc3MgImNvbW1pdCAtLSRmbGFnIGludG8gJG9sZCBmcm9tICRuZXciICcKKwkJZ2l0IGNoZWNrb3V0IC1iICRmbGFnLSRvbGQtJG5ldyBDMCAmJgorCQlnaXQgY29uZmlnIGkxOG4uY29tbWl0ZW5jb2RpbmcgJG9sZCAmJgorCQllY2hvICRvbGQgPj5GICYmCisJCWdpdCBjb21taXQgLWEgLUYgIiRURVNUX0RJUkVDVE9SWSIvdDM5MDAvJG1zZyAmJgorCQl0ZXN0X3RpY2sgJiYKKwkJZWNobyBpbnRlcm1lZGlhdGUgc3R1ZmYgPj5HICYmCisJCWdpdCBhZGQgRyAmJgorCQlnaXQgY29tbWl0IC1hIC1tICJpbnRlcm1lZGlhdGUgY29tbWl0IiAmJgorCQl0ZXN0X3RpY2sgJiYKKwkJZ2l0IGNvbmZpZyBpMThuLmNvbW1pdGVuY29kaW5nICRuZXcgJiYKKwkJZWNobyAkbmV3LSRmbGFnID4+RiAmJgorCQlnaXQgY29tbWl0IC1hIC0tJGZsYWcgSEVBRF4gJiYKKwkJZ2l0IHJlYmFzZSAtLWF1dG9zcXVhc2ggLWkgSEVBRF5eXiAmJgorCQlnaXQgcmV2LWxpc3QgSEVBRCA+YWN0dWFsICYmCisJCXRlc3RfbGluZV9jb3VudCA9IDMgYWN0dWFsICYmCisJCWljb252IC1mICRvbGQgLXQgVVRGLTggIiRURVNUX0RJUkVDVE9SWSIvdDM5MDAvJG1zZyA+ZXhwZWN0ICYmCisJCWlmIHRlc3QgJGZsYWcgPSBzcXVhc2g7IHRoZW4KKwkJCXN1YmplY3Q9IiQoaGVhZCAtMSBleHBlY3QpIiAmJgorCQkJcHJpbnRmICJcbnNxdWFzaCEgJXNcbiIgIiRzdWJqZWN0IiA+PmV4cGVjdAorCQlmaSAmJgorCQlnaXQgY2F0LWZpbGUgY29tbWl0IEhFQUReID5yYXcgJiYKKwkJKHNlZCAiMSwvXiQvZCIgcmF3IHwgaWNvbnYgLWYgJG5ldyAtdCB1dGYtOCkgPmFjdHVhbCAmJgorCQl0ZXN0X2NtcCBleHBlY3QgYWN0dWFsCisJJworfQorCit0ZXN0X2NvbW1pdF9hdXRvc3F1YXNoX211bHRpX2VuY29kaW5nIGZpeHVwIFVURi04IElTTy04ODU5LTEgMS1VVEYtOC50eHQKK3Rlc3RfY29tbWl0X2F1dG9zcXVhc2hfbXVsdGlfZW5jb2Rpbmcgc3F1YXNoIElTTy04ODU5LTEgVVRGLTggSVNPODg1OS0xLnR4dAordGVzdF9jb21taXRfYXV0b3NxdWFzaF9tdWx0aV9lbmNvZGluZyBzcXVhc2ggZXVjSlAgSVNPLTIwMjItSlAgZXVjSlAudHh0Cit0ZXN0X2NvbW1pdF9hdXRvc3F1YXNoX211bHRpX2VuY29kaW5nIGZpeHVwIElTTy0yMDIyLUpQIFVURi04IElTTy0yMDIyLUpQLnR4dAorCiB0ZXN0X2RvbmUKZGlmZiAtLWdpdCBhL3QvdDM5MDMtc3Rhc2guc2ggYi90L3QzOTAzLXN0YXNoLnNoCmluZGV4IGI4ZTMzNzguLmVhNTZlODUgMTAwNzU1Ci0tLSBhL3QvdDM5MDMtc3Rhc2guc2gKKysrIGIvdC90MzkwMy1zdGFzaC5zaApAQCAtNyw2ICs3LDE4IEBACiAKIC4gLi90ZXN0LWxpYi5zaAogCitkaWZmX2NtcCAoKSB7CisJZm9yIGkgaW4gIiQxIiAiJDIiCisJZG8KKwkJc2VkIC1lICdzL15pbmRleCAwMDAwMDAwXC5cLlswLTlhLWZdKi9pbmRleCAwMDAwMDAwLi4xMjM0NTY3LycgXAorCQktZSAncy9eaW5kZXggWzAtOWEtZl0qXC5cLlswLTlhLWZdKi9pbmRleCAxMjM0NTY3Li44OWFiY2RlLycgXAorCQktZSAncy9eaW5kZXggWzAtOWEtZl0qLFswLTlhLWZdKlwuXC5bMC05YS1mXSovaW5kZXggMTIzNDU2Nyw3NjU0MzIxLi44OWFiY2RlLycgXAorCQkiJGkiID4iJGkuY29tcGFyZSIgfHwgcmV0dXJuIDEKKwlkb25lICYmCisJdGVzdF9jbXAgIiQxLmNvbXBhcmUiICIkMi5jb21wYXJlIiAmJgorCXJtIC1mICIkMS5jb21wYXJlIiAiJDIuY29tcGFyZSIKK30KKwogdGVzdF9leHBlY3Rfc3VjY2VzcyAnc3Rhc2ggc29tZSBkaXJ0eSB3b3JraW5nIGRpcmVjdG9yeScgJwogCWVjaG8gMSA+ZmlsZSAmJgogCWdpdCBhZGQgZmlsZSAmJgpAQCAtMzYsNyArNDgsNyBAQAogdGVzdF9leHBlY3Rfc3VjY2VzcyAncGFyZW50cyBvZiBzdGFzaCcgJwogCXRlc3QgJChnaXQgcmV2LXBhcnNlIHN0YXNoXikgPSAkKGdpdCByZXYtcGFyc2UgSEVBRCkgJiYKIAlnaXQgZGlmZiBzdGFzaF4yLi5zdGFzaCA+b3V0cHV0ICYmCi0JdGVzdF9jbXAgZXhwZWN0IG91dHB1dAorCWRpZmZfY21wIGV4cGVjdCBvdXRwdXQKICcKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnYXBwbHlpbmcgYm9ndXMgc3Rhc2ggZG9lcyBub3RoaW5nJyAnCkBAIC0yMTAsMTMgKzIyMiwxMyBAQAogCXRlc3QgcmVmcy9oZWFkcy9zdGFzaGJyYW5jaCA9ICQoZ2l0IHN5bWJvbGljLXJlZiBIRUFEKSAmJgogCXRlc3QgJChnaXQgcmV2LXBhcnNlIEhFQUQpID0gJChnaXQgcmV2LXBhcnNlIG1hc3Rlcl4pICYmCiAJZ2l0IGRpZmYgLS1jYWNoZWQgPm91dHB1dCAmJgotCXRlc3RfY21wIGV4cGVjdCBvdXRwdXQgJiYKKwlkaWZmX2NtcCBleHBlY3Qgb3V0cHV0ICYmCiAJZ2l0IGRpZmYgPm91dHB1dCAmJgotCXRlc3RfY21wIGV4cGVjdDEgb3V0cHV0ICYmCisJZGlmZl9jbXAgZXhwZWN0MSBvdXRwdXQgJiYKIAlnaXQgYWRkIGZpbGUgJiYKIAlnaXQgY29tbWl0IC1tIGFsdGVybmF0ZVwgc2Vjb25kICYmCiAJZ2l0IGRpZmYgbWFzdGVyLi5zdGFzaGJyYW5jaCA+b3V0cHV0ICYmCi0JdGVzdF9jbXAgb3V0cHV0IGV4cGVjdDIgJiYKKwlkaWZmX2NtcCBvdXRwdXQgZXhwZWN0MiAmJgogCXRlc3QgMCA9ICQoZ2l0IHN0YXNoIGxpc3QgfCB3YyAtbCkKICcKIApAQCAtMjMyLDggKzI0NCwxMSBAQAogCXRlc3RfbXVzdF9iZV9lbXB0eSBvdXRwdXQub3V0CiAnCiAKLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3BvcCAtcSBpcyBxdWlldCcgJwordGVzdF9leHBlY3Rfc3VjY2VzcyAncG9wIC1xIHdvcmtzIGFuZCBpcyBxdWlldCcgJwogCWdpdCBzdGFzaCBwb3AgLXEgPm91dHB1dC5vdXQgMj4mMSAmJgorCWVjaG8gYmFyID5leHBlY3QgJiYKKwlnaXQgc2hvdyA6ZmlsZSA+YWN0dWFsICYmCisJdGVzdF9jbXAgZXhwZWN0IGFjdHVhbCAmJgogCXRlc3RfbXVzdF9iZV9lbXB0eSBvdXRwdXQub3V0CiAnCiAKQEAgLTI0Miw2ICsyNTcsOCBAQAogCWdpdCBhZGQgZmlsZSAmJgogCWdpdCBzdGFzaCBzYXZlIC0tcXVpZXQgJiYKIAlnaXQgc3Rhc2ggcG9wIC1xIC0taW5kZXggPm91dHB1dC5vdXQgMj4mMSAmJgorCWdpdCBkaWZmLWZpbGVzIGZpbGUyID5maWxlMi5kaWZmICYmCisJdGVzdF9tdXN0X2JlX2VtcHR5IGZpbGUyLmRpZmYgJiYKIAl0ZXN0IGZvbyA9ICIkKGdpdCBzaG93IDpmaWxlKSIgJiYKIAl0ZXN0X211c3RfYmVfZW1wdHkgb3V0cHV0Lm91dAogJwpAQCAtNTc3LDcgKzU5NCw3IEBACiAJK2JhcgogCUVPRgogCWdpdCBzdGFzaCBzaG93IC1wICR7U1RBU0hfSUR9ID5hY3R1YWwgJiYKLQl0ZXN0X2NtcCBleHBlY3RlZCBhY3R1YWwKKwlkaWZmX2NtcCBleHBlY3RlZCBhY3R1YWwKICcKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnc3Rhc2ggc2hvdyAtIG5vIHN0YXNoZXMgb24gc3RhY2ssIHN0YXNoLWxpa2UgYXJndW1lbnQnICcKQEAgLTYwOSw3ICs2MjYsNyBAQAogCStmb28KIAlFT0YKIAlnaXQgc3Rhc2ggc2hvdyAtcCAke1NUQVNIX0lEfSA+YWN0dWFsICYmCi0JdGVzdF9jbXAgZXhwZWN0ZWQgYWN0dWFsCisJZGlmZl9jbXAgZXhwZWN0ZWQgYWN0dWFsCiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3N0YXNoIHNob3cgLS1wYXRpZW5jZSBzaG93cyBkaWZmJyAnCkBAIC02MjcsNyArNjQ0LDcgQEAKIAkrZm9vCiAJRU9GCiAJZ2l0IHN0YXNoIHNob3cgLS1wYXRpZW5jZSAke1NUQVNIX0lEfSA+YWN0dWFsICYmCi0JdGVzdF9jbXAgZXhwZWN0ZWQgYWN0dWFsCisJZGlmZl9jbXAgZXhwZWN0ZWQgYWN0dWFsCiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2Ryb3A6IGZhaWwgZWFybHkgaWYgc3BlY2lmaWVkIHN0YXNoIGlzIG5vdCBhIHN0YXNoIHJlZicgJwpAQCAtNzkxLDcgKzgwOCw3IEBACiAJZ2l0IGRpZmYtaW5kZXggLS1jYWNoZWQgLS1xdWlldCBIRUFEICYmCiAJdGVzdCAiJChnaXQgcmV2LXBhcnNlIHN0YXNoXikiID0gIiQoZ2l0IHJldi1wYXJzZSBIRUFEKSIgJiYKIAlnaXQgZGlmZiBzdGFzaF4uLnN0YXNoID5vdXRwdXQgJiYKLQl0ZXN0X2NtcCBleHBlY3Qgb3V0cHV0CisJZGlmZl9jbXAgZXhwZWN0IG91dHB1dAogJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdzdG9yZSBjYWxsZWQgd2l0aCBpbnZhbGlkIGNvbW1pdCcgJwpAQCAtODQ3LDcgKzg2NCw3IEBACiAJK3dvcmtpbmcKIAlFT0YKIAlnaXQgc3Rhc2ggbGlzdCAtLWZvcm1hdD0lZ2QgLXAgPmFjdHVhbCAmJgotCXRlc3RfY21wIGV4cGVjdCBhY3R1YWwKKwlkaWZmX2NtcCBleHBlY3QgYWN0dWFsCiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3N0YXNoIGxpc3QgLS1jYyBzaG93cyBjb21iaW5lZCBkaWZmJyAnCkBAIC04NjQsNyArODgxLDcgQEAKIAkrK3dvcmtpbmcKIAlFT0YKIAlnaXQgc3Rhc2ggbGlzdCAtLWZvcm1hdD0lZ2QgLXAgLS1jYyA+YWN0dWFsICYmCi0JdGVzdF9jbXAgZXhwZWN0IGFjdHVhbAorCWRpZmZfY21wIGV4cGVjdCBhY3R1YWwKICcKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnc3Rhc2ggaXMgbm90IGNvbmZ1c2VkIGJ5IHBhcnRpYWwgcmVuYW1lcycgJwpAQCAtMTI0MSw0ICsxMjU4LDMxIEBACiAJdGVzdF9wYXRoX2lzX21pc3NpbmcgdG8tcmVtb3ZlCiAnCiAKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3N0YXNoIGFwcGx5IHNob3VsZCBzdWNjZWVkIHdpdGggdW5tb2RpZmllZCBmaWxlJyAnCisJZWNobyBiYXNlID5maWxlICYmCisJZ2l0IGFkZCBmaWxlICYmCisJZ2l0IGNvbW1pdCAtbSBiYXNlICYmCisKKwkjIG5vdyBzdGFzaCBhIG1vZGlmaWNhdGlvbgorCWVjaG8gbW9kaWZpZWQgPmZpbGUgJiYKKwlnaXQgc3Rhc2ggJiYKKworCSMgbWFrZSB0aGUgZmlsZSBzdGF0IGRpcnR5CisJY3AgZmlsZSBvdGhlciAmJgorCW12IG90aGVyIGZpbGUgJiYKKworCWdpdCBzdGFzaCBhcHBseQorJworCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdzdGFzaCBoYW5kbGVzIHNraXAtd29ya3RyZWUgZW50cmllcyBuaWNlbHknICcKKwl0ZXN0X2NvbW1pdCBBICYmCisJZWNobyBjaGFuZ2VkID5BLnQgJiYKKwlnaXQgYWRkIEEudCAmJgorCWdpdCB1cGRhdGUtaW5kZXggLS1za2lwLXdvcmt0cmVlIEEudCAmJgorCXJtIEEudCAmJgorCWdpdCBzdGFzaCAmJgorCisJZ2l0IHJldi1wYXJzZSAtLXZlcmlmeSByZWZzL3N0YXNoOkEudAorJworCiB0ZXN0X2RvbmUKZGlmZiAtLWdpdCBhL3QvdDM5MDUtc3Rhc2gtaW5jbHVkZS11bnRyYWNrZWQuc2ggYi90L3QzOTA1LXN0YXNoLWluY2x1ZGUtdW50cmFja2VkLnNoCmluZGV4IDI5Y2E3NmYuLmYwNzVjN2YgMTAwNzU1Ci0tLSBhL3QvdDM5MDUtc3Rhc2gtaW5jbHVkZS11bnRyYWNrZWQuc2gKKysrIGIvdC90MzkwNS1zdGFzaC1pbmNsdWRlLXVudHJhY2tlZC5zaApAQCAtMjc3LDggKzI3Nyw4IEBACiAJdGVzdF9wYXRoX2lzX2ZpbGUgaWdub3JlZC5kL2JhcgogJwogCi10ZXN0X2V4cGVjdF9zdWNjZXNzICdzdGFzaCAtdSAtLSA8bm9uLWV4aXN0YW50PiBzaG93cyBubyBjaGFuZ2VzIHdoZW4gdGhlcmUgYXJlIG5vbmUnICcKLQlnaXQgc3Rhc2ggcHVzaCAtdSAtLSBub24tZXhpc3RhbnQgPmFjdHVhbCAmJgordGVzdF9leHBlY3Rfc3VjY2VzcyAnc3Rhc2ggLXUgLS0gPG5vbi1leGlzdGVudD4gc2hvd3Mgbm8gY2hhbmdlcyB3aGVuIHRoZXJlIGFyZSBub25lJyAnCisJZ2l0IHN0YXNoIHB1c2ggLXUgLS0gbm9uLWV4aXN0ZW50ID5hY3R1YWwgJiYKIAllY2hvICJObyBsb2NhbCBjaGFuZ2VzIHRvIHNhdmUiID5leHBlY3QgJiYKIAl0ZXN0X2kxOG5jbXAgZXhwZWN0IGFjdHVhbAogJwpkaWZmIC0tZ2l0IGEvdC90MzkwNi1zdGFzaC1zdWJtb2R1bGUuc2ggYi90L3QzOTA2LXN0YXNoLXN1Ym1vZHVsZS5zaAppbmRleCBkNzIxOWQ2Li5iOTNkMWQ3IDEwMDc1NQotLS0gYS90L3QzOTA2LXN0YXNoLXN1Ym1vZHVsZS5zaAorKysgYi90L3QzOTA2LXN0YXNoLXN1Ym1vZHVsZS5zaApAQCAtMSw2ICsxLDYgQEAKICMhL2Jpbi9zaAogCi10ZXN0X2Rlc2NyaXB0aW9uPSdzdGFzaCBhcHBseSBjYW4gaGFuZGxlIHN1Ym1vZHVsZXMnCit0ZXN0X2Rlc2NyaXB0aW9uPSdzdGFzaCBjYW4gaGFuZGxlIHN1Ym1vZHVsZXMnCiAKIC4gLi90ZXN0LWxpYi5zaAogLiAiJFRFU1RfRElSRUNUT1JZIi9saWItc3VibW9kdWxlLXVwZGF0ZS5zaApAQCAtMjEsNCArMjEsNDQgQEAKIEtOT1dOX0ZBSUxVUkVfTk9GRl9NRVJHRV9ET0VTTlRfQ1JFQVRFX0VNUFRZX1NVQk1PRFVMRV9ESVI9MQogdGVzdF9zdWJtb2R1bGVfc3dpdGNoICJnaXRfc3Rhc2giCiAKK3NldHVwX2Jhc2ljICgpIHsKKwl0ZXN0X3doZW5fZmluaXNoZWQgInJtIC1yZiBtYWluIHN1YiIgJiYKKwlnaXQgaW5pdCBzdWIgJiYKKwkoCisJCWNkIHN1YiAmJgorCQl0ZXN0X2NvbW1pdCBzdWJfZmlsZQorCSkgJiYKKwlnaXQgaW5pdCBtYWluICYmCisJKAorCQljZCBtYWluICYmCisJCWdpdCBzdWJtb2R1bGUgYWRkIC4uL3N1YiAmJgorCQl0ZXN0X2NvbW1pdCBtYWluX2ZpbGUKKwkpCit9CisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3N0YXNoIHB1c2ggd2l0aCBzdWJtb2R1bGUucmVjdXJzZT10cnVlIHByZXNlcnZlcyBkaXJ0eSBzdWJtb2R1bGUgd29ya3RyZWUnICcKKwlzZXR1cF9iYXNpYyAmJgorCSgKKwkJY2QgbWFpbiAmJgorCQlnaXQgY29uZmlnIHN1Ym1vZHVsZS5yZWN1cnNlIHRydWUgJiYKKwkJZWNobyAieCIgPm1haW5fZmlsZS50ICYmCisJCWVjaG8gInkiID5zdWIvc3ViX2ZpbGUudCAmJgorCQlnaXQgc3Rhc2ggcHVzaCAmJgorCQl0ZXN0X211c3RfZmFpbCBnaXQgLUMgc3ViIGRpZmYgLS1xdWlldAorCSkKKycKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAnc3Rhc2ggcHVzaCBhbmQgcG9wIHdpdGggc3VibW9kdWxlLnJlY3Vyc2U9dHJ1ZSBwcmVzZXJ2ZXMgZGlydHkgc3VibW9kdWxlIHdvcmt0cmVlJyAnCisJc2V0dXBfYmFzaWMgJiYKKwkoCisJCWNkIG1haW4gJiYKKwkJZ2l0IGNvbmZpZyBzdWJtb2R1bGUucmVjdXJzZSB0cnVlICYmCisJCWVjaG8gIngiID5tYWluX2ZpbGUudCAmJgorCQllY2hvICJ5IiA+c3ViL3N1Yl9maWxlLnQgJiYKKwkJZ2l0IHN0YXNoIHB1c2ggJiYKKwkJZ2l0IHN0YXNoIHBvcCAmJgorCQl0ZXN0X211c3RfZmFpbCBnaXQgLUMgc3ViIGRpZmYgLS1xdWlldAorCSkKKycKKwogdGVzdF9kb25lCmRpZmYgLS1naXQgYS90L3QzOTA4LXN0YXNoLWluLXdvcmt0cmVlLnNoIGIvdC90MzkwOC1zdGFzaC1pbi13b3JrdHJlZS5zaApuZXcgZmlsZSBtb2RlIDEwMDc1NQppbmRleCAwMDAwMDAwLi4yYjJiMzY2Ci0tLSAvZGV2L251bGwKKysrIGIvdC90MzkwOC1zdGFzaC1pbi13b3JrdHJlZS5zaApAQCAtMCwwICsxLDI3IEBACisjIS9iaW4vc2gKKyMKKyMgQ29weXJpZ2h0IChjKSAyMDE5IEpvaGFubmVzIEUgU2NoaW5kZWxpbgorIworCit0ZXN0X2Rlc2NyaXB0aW9uPSdUZXN0IGdpdCBzdGFzaCBpbiBhIHdvcmt0cmVlJworCisuIC4vdGVzdC1saWIuc2gKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAnc2V0dXAnICcKKwl0ZXN0X2NvbW1pdCBpbml0aWFsICYmCisJZ2l0IHdvcmt0cmVlIGFkZCB3dCAmJgorCXRlc3RfY29tbWl0IC1DIHd0IGluLXdvcmt0cmVlCisnCisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2FwcGx5IGluIHN1YmRpcmVjdG9yeScgJworCW1rZGlyIHd0L3N1YmRpciAmJgorCSgKKwkJY2Qgd3Qvc3ViZGlyICYmCisJCWVjaG8gbW9kaWZpZWQgPi4uL2luaXRpYWwudCAmJgorCQlnaXQgc3Rhc2ggJiYKKwkJZ2l0IHN0YXNoIGFwcGx5ID5vdXQKKwkpICYmCisJZ3JlcCAiXC5cLlwvaW5pdGlhbFwudCIgd3Qvc3ViZGlyL291dAorJworCit0ZXN0X2RvbmUKZGlmZiAtLWdpdCBhL3QvdDQwMDAtZGlmZi1mb3JtYXQuc2ggYi90L3Q0MDAwLWRpZmYtZm9ybWF0LnNoCmluZGV4IDhkZTM2YjcuLmU1MTE2YTcgMTAwNzU1Ci0tLSBhL3QvdDQwMDAtZGlmZi1mb3JtYXQuc2gKKysrIGIvdC90NDAwMC1kaWZmLWZvcm1hdC5zaApAQCAtNzgsNyArNzgsNyBAQAogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdnaXQgZGlmZi1maWxlcyAtLW5vLXBhdGNoIC0tcGF0Y2gtd2l0aC1yYXcgc2hvd3MgdGhlIHBhdGNoIGFuZCByYXcgZGF0YScgJwogCWdpdCBkaWZmLWZpbGVzIC0tbm8tcGF0Y2ggLS1wYXRjaC13aXRoLXJhdyA+YWN0dWFsICYmCi0JZ3JlcCAtcSAiXjoxMDA2NDQgMTAwNzU1IC4qIDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAgTQlwYXRoMFwkIiBhY3R1YWwgJiYKKwlncmVwIC1xICJeOjEwMDY0NCAxMDA3NTUgLiogJFpFUk9fT0lEIE0JcGF0aDBcJCIgYWN0dWFsICYmCiAJdGFpbCAtbiArNCBhY3R1YWwgPmFjdHVhbC1wYXRjaCAmJgogCWNvbXBhcmVfZGlmZl9wYXRjaCBleHBlY3RlZCBhY3R1YWwtcGF0Y2gKICcKZGlmZiAtLWdpdCBhL3QvdDQwMDItZGlmZi1iYXNpYy5zaCBiL3QvdDQwMDItZGlmZi1iYXNpYy5zaAppbmRleCAzYTZjMjFlLi5jYmNkZDEwIDEwMDc1NQotLS0gYS90L3Q0MDAyLWRpZmYtYmFzaWMuc2gKKysrIGIvdC90NDAwMi1kaWZmLWJhc2ljLnNoCkBAIC03LDEyMyArNywyNzIgQEAKIAogJwogLiAuL3Rlc3QtbGliLnNoCisKIC4gIiRURVNUX0RJUkVDVE9SWSIvbGliLXJlYWQtdHJlZS1tLTN3YXkuc2gKIAotY2F0ID4udGVzdC1wbGFpbi1PQSA8PFxFT0YKLTowMDAwMDAgMTAwNjQ0IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAgY2NiYTcyYWQzODg4YTM1MjBiMzllZmNmNzgwYjllZTY0MTY3NTM1ZCBBCUFBCi06MDAwMDAwIDEwMDY0NCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwIDdlNDI2ZmIwNzk0NzlmZDY3ZjZkODFmOTg0ZTRlYzY0OWE0NGJjMjUgQQlBTgotOjEwMDY0NCAwMDAwMDAgYmNjNjhlZjk5NzAxNzQ2NmQ1YzkwOTRiY2Y3NjkyMjk1ZjU4OGM5YSAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwIEQJREQKLTowMDAwMDAgMDQwMDAwIDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAgNmQ1MGY2NWQzYmRhYjkxYzYzNDQ0Mjk0ZDM4ZjA4YWVmZjMyOGU0MiBBCURGCi06MTAwNjQ0IDAwMDAwMCAxNDFjMWYxNjQyMzI4ZTRiYzQ2YTdkODAxYTcxZGEzOTJlNjY3OTFlIDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAgRAlETQotOjEwMDY0NCAwMDAwMDAgMzVhYmRlMTUwNmRkZjgwNjU3MmZmNGQ0MDdiZDA2ODg1ZDBmOGVlOSAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwIEQJRE4KLTowMDAwMDAgMTAwNjQ0IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAgMWQ0MTEyMmViZGQ3YTY0MGYyOWQzYzljYzRmOWQ3MDA5NDM3NDc2MiBBCUxMCi06MTAwNjQ0IDEwMDY0NCAwM2YyNGM4YzQ3MDBiYWJjY2ZkMjhiNjU0ZTdlOGVhYzQwMmFkNmNkIDEwM2Q5Zjg5YjUwYjlhYWQwMzA1NGI1NzliZTVlN2FhNjY1ZjJkNTcgTQlNRAotOjEwMDY0NCAxMDA2NDQgYjI1ODUwOGFmYjdjZWI0NDk5ODFiZDlkNjNkMmQzZTk3MWJmOGQzNCBiNDMxYjI3MmQ4MjlmZjNhYTRkMWE1MDg1ZjQzOTRhYjRkMzMwNWI2IE0JTU0KLToxMDA2NDQgMTAwNjQ0IGJkMDg0YjBjMjdjN2I2Y2MzNGYxMWQ2ZDA1MDlhMjliZTNjYWY5NzAgYTcxNmQ1OGRlNGE1NzBlMDAzOGY1YzMwN2JkOGRiMzRkYWVhMDIxZiBNCU1OCi06MTAwNjQ0IDEwMDY0NCA0MGM5NTlmOTg0YzhiODlhMmIwMjUyMGQxN2YwMGQ3MTdmMDI0Mzk3IDJhYzU0N2FlOTYxNGEwMGQxYjI4Mjc1ZGU2MDgxMzFmN2EwZTI1OWYgTQlTUwotOjEwMDY0NCAxMDA2NDQgNGFjMTM0NTg4OTlhYjkwOGVmM2IxMTI4ZmEzNzhkYWVmYzg4ZDM1NiA0Yzg2ZjlhODVmYmM1ZTY4MDRlZTJlMTdhNzk3NTM4ZmJlNzg1YmNhIE0JVFQKLTowNDAwMDAgMDQwMDAwIDdkNjcwZmRjZGI5OTI5ZjZjN2RhYzE5NmZmNzg2ODljZDFjNTY2YTEgNWU1ZjIyMDcyYmIzOWY2ZTEyY2Y2NjNhNTdjYjYzNGM3NmVlZmI0OSBNCVoKK3Rlc3Rfb2lkX2luaXQKKwordGVzdF9vaWRfY2FjaGUgPDxcRU9GCithYV8xIHNoYTE6Y2NiYTcyYWQzODg4YTM1MjBiMzllZmNmNzgwYjllZTY0MTY3NTM1ZAorYWFfMSBzaGEyNTY6OWZlYmZiZjE4MTk3ODE5YjI3MzVjNDUyOTFmMTM4NTI1ZDI0NzZkNTk0NzBmOTgyMzk2NDc1NDQ1ODZiYTQwMworCithYV8yIHNoYTE6NmFhMmI1MzM1YjE2NDMxYTBlZjcxZTVjMGEyOGJlNjkxODNjZjZhMgorYWFfMiBzaGEyNTY6NmVhYTM0MzdkZTgzZjE0NWE0YWFhNmJhMzU1MzAzMDc1YWRlNTQ3YjEyOGVjNmEyY2QwMGE4MWZmN2NlN2E1NgorCithbl8xIHNoYTE6N2U0MjZmYjA3OTQ3OWZkNjdmNmQ4MWY5ODRlNGVjNjQ5YTQ0YmMyNQorYW5fMSBzaGEyNTY6OGY5MmEwYmVjOTllMzk5YTM4ZTNiZDBlMWJmMTlmYmYxMjFlMDE2MGVmYjI5Yjg1N2RmNzlkNDM5ZjFjNDUzNgorCitkZF8xIHNoYTE6YmNjNjhlZjk5NzAxNzQ2NmQ1YzkwOTRiY2Y3NjkyMjk1ZjU4OGM5YQorZGRfMSBzaGEyNTY6MDdlMTc0MjhiMDA2MzliODU0ODVkMmIwMTA4M2QyMTllMmYzZTNiYTg1NzllOWNhNDRlOWNjOGRkNTU0ZDk1MgorCitkZl8xIHNoYTE6NmQ1MGY2NWQzYmRhYjkxYzYzNDQ0Mjk0ZDM4ZjA4YWVmZjMyOGU0MgorZGZfMSBzaGEyNTY6ZTM2N2NlY2MyN2U5YmY1NDUxYjFjNjU4MjhjYjIxOTM4ZDM2YTVmOGUzOWMxYjAzYWQ2NTA5Y2MzNmJiOGU5ZAorCitkZl8yIHNoYTE6NzE0MjBhYjgxZTI1NDE0NWQyNmQ2ZmMwY2RkZWU2NGMxYWNkNDc4NworZGZfMiBzaGEyNTY6MGYwYTg2ZDEwMzQ3ZmY2OTIxZDAzYTNjOTU0Njc5ZjNmMWQxNGZhM2Q1Y2Q4MmY1N2IzMmMwOTc1NWYzYTQ3ZAorCitkZmQxIHNoYTE6NjhhNmQ4YjkxZGExMTA0NWNmNGFhM2E1YWI5ZjJhNzgxYzcwMTI0OQorZGZkMSBzaGEyNTY6ZjNiZDMyNjViMDJiNjk3OGNlODY0OTBkOGFkMDI2YzU3MzYzOWM5NzRiM2RlMWQ5ZmFmMzBkOGQ1YTc3ZDNkNQorCitkbV8xIHNoYTE6MTQxYzFmMTY0MjMyOGU0YmM0NmE3ZDgwMWE3MWRhMzkyZTY2NzkxZQorZG1fMSBzaGEyNTY6Yzg5Zjg2NTZlN2I5NGUyMWVlNWZiYWYwZTIxNDliYmY3ODNjNTFlZGJlMmNlMTEwMzQ5Y2FjMTMwNTllZTdlZAorCitkbV8yIHNoYTE6M2M0ZDhkZTVmYmFkMDg1NzJiYWI4ZTEwZWVmOGRiYjI2NGNmMDIzMQorZG1fMiBzaGEyNTY6ODNhNTcyZTM3ZTBjOTQwODYyOTRkYWUyY2VjYzQzZDkxMzFhZmQ2ZjZjOTA2ZTQ5NWM3ODk3MjIzMGI1NDk4OAorCitkbl8xIHNoYTE6MzVhYmRlMTUwNmRkZjgwNjU3MmZmNGQ0MDdiZDA2ODg1ZDBmOGVlOQorZG5fMSBzaGEyNTY6Nzc1ZDU4NTI1ODIwNzBlNjIwYmU2MzMyN2JmYTUxNWZhYjhmNzFjN2FjM2U0ZjBjM2NkNjI2N2I0Mzc3YmEyOAorCitsbF8yIHNoYTE6MWQ0MTEyMmViZGQ3YTY0MGYyOWQzYzljYzRmOWQ3MDA5NDM3NDc2MgorbGxfMiBzaGEyNTY6NzkxN2I0OTQ4YTg4M2NmZWQwYTc3ZDNkNWE2MjVkYzg1NzdkNmRkY2MzYzZjM2JiYzU2YzRkNDIyNmEyMjQ2ZAorCittZF8xIHNoYTE6MDNmMjRjOGM0NzAwYmFiY2NmZDI4YjY1NGU3ZThlYWM0MDJhZDZjZAorbWRfMSBzaGEyNTY6ZmM5ZjMwMzY5Yjk3ODU5NWFkNjg1YmExMWNhOWExN2RlMGFmMTZkNzljZDRiNjI5OTc1ZjRmMTU5MDAzMzkwMgorCittZF8yIHNoYTE6MTAzZDlmODliNTBiOWFhZDAzMDU0YjU3OWJlNWU3YWE2NjVmMmQ1NworbWRfMiBzaGEyNTY6ZmM3OGVjNzUyNzU2Mjg3NjJmZTUyMDQ3OWE2YjIzOThkZWMyOTVjZTdhYWJjYjFkMTVlNTk2M2M3YjRlOTMxNworCittbV8xIHNoYTE6YjI1ODUwOGFmYjdjZWI0NDk5ODFiZDlkNjNkMmQzZTk3MWJmOGQzNAorbW1fMSBzaGEyNTY6YTRiNzg0N2QyMjhlOTAwZTMwMDAyODVlMjQwYzIwZmQ5NmY5ZGQ0MWNlMTQ0NTMwNWY2ZWFkYTEyNmQ0YTA0YQorCittbV8yIHNoYTE6YjQzMWIyNzJkODI5ZmYzYWE0ZDFhNTA4NWY0Mzk0YWI0ZDMzMDViNgorbW1fMiBzaGEyNTY6M2Y4YjgzZWEzNmFhY2Y2ODliY2YxYTEyOTBhOWE4ZWQzNDE1NjRkMzI2ODJlYTZmNzZmZWE5YTk3OTE4Njc4MgorCittbV8zIHNoYTE6MTk5ODlkNDU1OWFhZTQxN2ZlZGVlMjQwY2NmMmJhMzE1ZWE0ZGMyYgorbW1fMyBzaGEyNTY6NzFiM2JmYzU3NDdhYzAzM2ZmZjllYTBhYjM5ZWU0NTNhM2FmMjk2OTg5MGU3NWQ2ZWY1NDdiODc1NDRlMjY4MQorCittbl8xIHNoYTE6YmQwODRiMGMyN2M3YjZjYzM0ZjExZDZkMDUwOWEyOWJlM2NhZjk3MAorbW5fMSBzaGEyNTY6NDdhNjc0NTA1ODNkN2EzMjllYjAxYTdjNGJhNjQ0OTQ1YWY3MmMwZWQyYzdjOTVlYjVhMDBkNmU0NmQ0ZDQ4MworCittbl8yIHNoYTE6YTcxNmQ1OGRlNGE1NzBlMDAzOGY1YzMwN2JkOGRiMzRkYWVhMDIxZgorbW5fMiBzaGEyNTY6Zjk1MTA0YzFlYmUyN2FjYjg0YmFjMjVhN2JlOThjNzFmNmI4ZDMwNTRiMjFmMzU3YTViZTBjNTI0YWQ5N2UwOAorCitubV8xIHNoYTE6YzhmMjU3ODFlOGYxNzkyZTNlNDBiNzQyMjVlMjA1NTMwNDFiNTIyNgorbm1fMSBzaGEyNTY6MDliYWRkYzdhZmFhNjJlNjJlMTUyYzIzYzljM2FiOTRiZjE1YTM4OTQwMzFlMjI3ZTliZTdmZTY4ZTFmNGU0OQorCitubV8yIHNoYTE6Y2RiOWE4YzNkYTU3MTUwMmFjMzAyMjVlOWMxN2JlY2NiODM4Nzk4Mworbm1fMiBzaGEyNTY6NThiNTIyNzk1NmFjMmQyYTA4ZDBlZmE1MTNjMGFlMzc0MzA5NDhiMTY3OTFlYTM4NjlhMTMwOGRiZjA1NTM2ZAorCituYV8xIHNoYTE6MTU4ODU4ODFlYTY5MTE1MzUxYzA5YjM4MzcxZjAzNDhhM2ZiOGM2NworbmFfMSBzaGEyNTY6MThlNGZkZDE2NzBjZDc5NjhlZTIzZDM1YmZkMjllNTQxOGQ1NmZiMTkwYzg0MDA5NGMxYzU3Y2VlZTBhYWQ4ZgorCituZF8xIHNoYTE6YTRlMTc5ZTQyOTFlNTUzNmE1ZTFjODJlMDkxMDUyNzcyZDJjNWE5MworbmRfMSBzaGEyNTY6MDdkYWM5YjAxZDAwOTU2ZWEwYzY1YmQ5OTNkN2RlNDg2NGFlZWYyZWQzY2JiMTI1NWQ5ZjFkOTQ5ZmNkNmRmNgorCitzc18xIHNoYTE6NDBjOTU5Zjk4NGM4Yjg5YTJiMDI1MjBkMTdmMDBkNzE3ZjAyNDM5Nworc3NfMSBzaGEyNTY6NTBmYzFiNWRmNzRkOTkxMGRiMmY5MjcwOTkzNDg0MjM1ZjE1YjY5Yjc1YjAxYmNmYjUzZTA1OTI4OWQxNGFmOQorCitzc18yIHNoYTE6MmFjNTQ3YWU5NjE0YTAwZDFiMjgyNzVkZTYwODEzMWY3YTBlMjU5Zgorc3NfMiBzaGEyNTY6YTkwZjAyZTYwNDRmMTQ5N2QxM2RiNTg3ZDIyYWIxMmY5MDE1MGE3ZDFlMDg0YWZjZjk2MDY1ZmFiMzVhZTJiYworCit0dF8xIHNoYTE6NGFjMTM0NTg4OTlhYjkwOGVmM2IxMTI4ZmEzNzhkYWVmYzg4ZDM1NgordHRfMSBzaGEyNTY6YzUzMTEzYzdkZDUwNjBlODZiNWIyNTE0MjhiZDA1OGY2NzI2ZjY2MjczYzZhMjRiZmYxYzYxYTA0ZjQ5OGRkMworCit0dF8yIHNoYTE6NGM4NmY5YTg1ZmJjNWU2ODA0ZWUyZTE3YTc5NzUzOGZiZTc4NWJjYQordHRfMiBzaGEyNTY6MDc3NWYyYTI5NjEyOWE3Y2YyODYyYjQ2YmMwZTg4YzE0ZDU5M2YyNzczYTNlM2ZiMWM1MTkzZGI2ZjVhN2U3NworCit0dF8zIHNoYTE6YzRlNGExMjIzMWI5ZmE3OWEwMDUzY2I2MDc3ZmNiMjFiYjViMTM1YQordHRfMyBzaGEyNTY6NDc4NjBmOTNjZGQyMTFmOTY0NDNlMDU2MGYyMWM1N2FiNmMyZjRiMGFjMjdmZjAzNjUxYTM1MmU1M2ZlODQ4NAorCit6X18xIHNoYTE6N2Q2NzBmZGNkYjk5MjlmNmM3ZGFjMTk2ZmY3ODY4OWNkMWM1NjZhMQorel9fMSBzaGEyNTY6NDRkMGYzN2FmZjVlNTFjZmNmZGQxMTM0YzkzYTY0MTliY2NhN2I5OTY0Zjc5MmZmY2Q1ZjliNGZjYmExZWU2MworCit6X18yIHNoYTE6NWU1ZjIyMDcyYmIzOWY2ZTEyY2Y2NjNhNTdjYjYzNGM3NmVlZmI0OQorel9fMiBzaGEyNTY6ZDI5ZGUxNjIxMTMxOTBmZWQxMDRlYjVmMDEwODIwY2VmNGUzMTVmODliOTMyNmU4NDk3ZjcyMTlmYjczNzg5NAorCit6X18zIHNoYTE6MWJhNTIzOTU1ZDUxNjA2ODFhZjY1Y2I3NzY0MTFmNTc0YzFlODE1NQorel9fMyBzaGEyNTY6MDc0MjJkNzcyYjA3Nzk0YWI0MzY5YTU2NDhlNjE3NzE5Zjg5YzJkMjIxMmNiZWFiMDVkOTcyMTRiNjQ3MTYzNgorCit6YWExIHNoYTE6OGFjYjhlOTc1MGUzZjY0NGJmMzIzZmNmM2QzMzg4NDlkYjEwNmM3NworemFhMSBzaGEyNTY6ZTc5YjAyOTI4MmM4YWJlYzJkOWYzZjdmYWNlYWYyYTE0MDVlMDJkMWYzNjhlNjY0NTBhZTY2Y2Y1YjY4ZDFmNAorCit6YWEyIHNoYTE6NmMwYjk5Mjg2ZDBiY2U1NTFhYzRhN2IzZGZmOGI3MDZlZGZmMzcxNQoremFhMiBzaGEyNTY6YzgyYmQ3OGMzZTY5ZWExNzk2ZTZiMWE3YTNiYTQ1YmIxMDZjNTBlODE5Mjk2NDc1Yjg2MjEyM2QzZjVjYzVhMAorCit6YW4xIHNoYTE6MDg3NDk0MjYyMDg0Y2VmZWU3ZWQ0ODRkMjBjOGRjMDU4MDc5MTI3MgoremFuMSBzaGEyNTY6NGIxNTllYjM4MDRkMDU1OTkwMjNkZDA3NGY3NzFkMDZkMDI4NzBmNGFiMjRhNzE2NWFkZDhhYzNkNzAzYjhkMworCit6ZGQxIHNoYTE6ODc5MDA3ZWZhZTYyNGQyYjEzMDcyMTRiMjRhOTU2ZjBhOGQ2ODZhOAoremRkMSBzaGEyNTY6ZWVjZmRkNGQ4MDkyZGQwMzYzZmI2ZDQ1NDhiNTRjNmFmYzg5ODJjM2VkOWIzNGUzOTNmMWQ2YTkyMWQ4ZWFhMworCit6ZG0xIHNoYTE6OWI1NDFiMjI3NWMwNmUzYTdiMTNmMjhiYWRmNTI5NGUyYWU2M2RmNAoremRtMSBzaGEyNTY6YWIxMzZlODhlMTlhODQzYzRiZjc3MTNkMjA5MGQ1YTIxODZiYTE2YTZhODBkYWNjMTJlZWRkZDI1NmE4ZTU1NgorCit6ZG0yIHNoYTE6ZDc3MzcxZDE1ODE3ZmNhYTU3ZWVlYzI3Zjc3MGM1MDViYTk3NGVjMQoremRtMiBzaGEyNTY6MWMxYTVmNTczNjNmNDZhMTVkOTVjZTg1MjdiM2MyYzE1OGQ4OGQxNjg1M2I0YWNiZjgxYmQyMGZkMmM4OWE0NgorCit6ZG4xIHNoYTE6YmViNWQzOGM1NTI4M2QyODA2ODVlYTIxYTBlNTBjZmNjMGNhMDY0YQoremRuMSBzaGEyNTY6MGYwZWNhNjYxODM2MTdiMGFhNWFkNzRiMjU2NTQwMzI5Zjg0MTQ3MDkyMmNhNjc2MDI2M2M5OTZkODI1ZWIxOAorCit6bWQxIHNoYTE6ZDQxZmRhNDFiN2VjNGRlNDZiNDNjYjdlYTQyYTQ1MDAxYWUzOTNkNQorem1kMSBzaGEyNTY6MWVkMzJkNDgxODUyZWRkZjMxYTBjZTEyNjUyYTBhZDE0YmY1YjdhODQyNjY3YjVkYmIwYjUwZjM1YmYxYzgwYQorCit6bWQyIHNoYTE6YTc5YWMzYmU5Mzc3NjM5ZTFjN2QxZWRmMWFlMWIzYTVmMGNjZDhhOQorem1kMiBzaGEyNTY6YjIzOGRhMjExYjQwNGY4OTE3ZGYyZDljNmY3MDMwNTM1ZTkwNGIyMTg2MTMxMDA3YTNjMjkyZWM2OTAyZjkzMworCit6bW0xIHNoYTE6NGNhMjJiYWUyNTI3ZDNkOWUxNjc2NDk4YTBmYmEzYjM1NWJkMTI3OAorem1tMSBzaGEyNTY6MDcyYjFkODViNWYzNGZhYmM5OWRmYTQ2MDA4YzU0MThkZjY4MzAyZDNlMzE3NDMwMDA2ZjQ5YjMyZDI0NDIyNgorCit6bW0yIHNoYTE6NjE0MjJiYTljMmM4NzM0MTYwNjFhODhjZDQwYTU5YTM1YjU3NjQ3NAorem1tMiBzaGEyNTY6ODFkZDVkMmIzYzVjZGExNmZlZjU1MjI1NmFlZDRlMmVhMDgwMmE4NDUwYTA4ZjMwOGE5MjE0MjExMmZmNmRkYQorCit6bW0zIHNoYTE6Njk3YWFkNzcxNWExZTczMDZjYTc2MjkwYTNkZDQyMDhmYmFlZGRmYQorem1tMyBzaGEyNTY6OGIxMGZhYjQ5ZTliZTM0MTRhYTVlOWE5M2QwZTQ2Zjk1NjkwNTM0NDAxMzhhN2MxOWE1ZWI1NTM2ZDhlOTViZgorCit6bW4xIHNoYTE6YjE2ZDdiMjViODY5ZjJiZWIxMjRlZmE1MzQ2N2Q4YTE1NTBhZDY5NAorem1uMSBzaGEyNTY6NjA5ZTRmNzVkMTI5NWU4NDRjODI2ZmVlYmEyMTNhY2IwYjZjZmM2MDlhZGZlOGZmNzA1YjE5ZTM4MjlhZTNlOQorCit6bW4yIHNoYTE6YTVjNTQ0YzIxY2ZjYjA3ZWI4MGE0ZDg5YTViN2QxNTcwMDAyZWRmZAorem1uMiBzaGEyNTY6ZDZkMDNlZGYyZGMxYTNiMjY3YTgyMDVkZTVmNDFhMmZmNGIwM2RlZjhjN2FlMDIwNTJiNTQzZmIwOWQ1ODlmYworCit6bmExIHNoYTE6ZDEyOTc5YzIyZmZmNjljNTljYTk0MDllN2E4ZmUzZWUyNWVhZWU4MAorem5hMSBzaGEyNTY6YjM3YjgwZTc4OWU4ZWEzMmFhMzIzZjAwNDYyOGYwMjAxM2Y2MzIxMjRiMDI4MmM3ZmUwMGExMjdkM2M2NGMzYworCit6bmQxIHNoYTE6YTE4MzkzYzYzNmI5OGU5YmQ3Mjk2YjhiNDM3ZWE0OTkyYjcyNDQwYworem5kMSBzaGEyNTY6YWY5MmEyMmVlZThjMzg0MTBhMGM5ZDJiNTEzNWExMGFlYjA1MmNiYzdjZjY3NTU0MWVkOWE2N2JmY2FmN2NmOQorCit6bm0xIHNoYTE6M2ZkYmUxN2ZkMDEzMzAzYTJlOTgxZTFjYTFjNmNkNmU3Mjc4OTA4Nworem5tMSBzaGEyNTY6Zjc1YWVhYTBjMTFlNzY5MThlMzgxYzEwNWYwNzUyOTMyYzYxNTBlOTQxZmVjNTY1ZDI0ZmEzMTA5OGExM2RjMQorCit6bm0yIHNoYTE6N2UwOWQ2YTNhMTRiZDYzMDkxM2U4Yzc1NjkzY2VhMzIxNTdiNjA2ZAorem5tMiBzaGEyNTY6OTM4ZDczY2ZiYWExYzkwMmE4NGZiNWIzYWZkOTczNmFhMDU5MDM2N2ZiOWJkNTljNmM0ZDA3MmNlNzBmY2Q2ZAogRU9GCiAKLWNhdCA+LnRlc3QtcmVjdXJzaXZlLU9BIDw8XEVPRgotOjAwMDAwMCAxMDA2NDQgMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMCBjY2JhNzJhZDM4ODhhMzUyMGIzOWVmY2Y3ODBiOWVlNjQxNjc1MzVkIEEJQUEKLTowMDAwMDAgMTAwNjQ0IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAgN2U0MjZmYjA3OTQ3OWZkNjdmNmQ4MWY5ODRlNGVjNjQ5YTQ0YmMyNSBBCUFOCi06MTAwNjQ0IDAwMDAwMCBiY2M2OGVmOTk3MDE3NDY2ZDVjOTA5NGJjZjc2OTIyOTVmNTg4YzlhIDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAgRAlERAotOjAwMDAwMCAxMDA2NDQgMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMCA2OGE2ZDhiOTFkYTExMDQ1Y2Y0YWEzYTVhYjlmMmE3ODFjNzAxMjQ5IEEJREYvREYKLToxMDA2NDQgMDAwMDAwIDE0MWMxZjE2NDIzMjhlNGJjNDZhN2Q4MDFhNzFkYTM5MmU2Njc5MWUgMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMCBECURNCi06MTAwNjQ0IDAwMDAwMCAzNWFiZGUxNTA2ZGRmODA2NTcyZmY0ZDQwN2JkMDY4ODVkMGY4ZWU5IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAgRAlETgotOjAwMDAwMCAxMDA2NDQgMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMCAxZDQxMTIyZWJkZDdhNjQwZjI5ZDNjOWNjNGY5ZDcwMDk0Mzc0NzYyIEEJTEwKLToxMDA2NDQgMTAwNjQ0IDAzZjI0YzhjNDcwMGJhYmNjZmQyOGI2NTRlN2U4ZWFjNDAyYWQ2Y2QgMTAzZDlmODliNTBiOWFhZDAzMDU0YjU3OWJlNWU3YWE2NjVmMmQ1NyBNCU1ECi06MTAwNjQ0IDEwMDY0NCBiMjU4NTA4YWZiN2NlYjQ0OTk4MWJkOWQ2M2QyZDNlOTcxYmY4ZDM0IGI0MzFiMjcyZDgyOWZmM2FhNGQxYTUwODVmNDM5NGFiNGQzMzA1YjYgTQlNTQotOjEwMDY0NCAxMDA2NDQgYmQwODRiMGMyN2M3YjZjYzM0ZjExZDZkMDUwOWEyOWJlM2NhZjk3MCBhNzE2ZDU4ZGU0YTU3MGUwMDM4ZjVjMzA3YmQ4ZGIzNGRhZWEwMjFmIE0JTU4KLToxMDA2NDQgMTAwNjQ0IDQwYzk1OWY5ODRjOGI4OWEyYjAyNTIwZDE3ZjAwZDcxN2YwMjQzOTcgMmFjNTQ3YWU5NjE0YTAwZDFiMjgyNzVkZTYwODEzMWY3YTBlMjU5ZiBNCVNTCi06MTAwNjQ0IDEwMDY0NCA0YWMxMzQ1ODg5OWFiOTA4ZWYzYjExMjhmYTM3OGRhZWZjODhkMzU2IDRjODZmOWE4NWZiYzVlNjgwNGVlMmUxN2E3OTc1MzhmYmU3ODViY2EgTQlUVAotOjAwMDAwMCAxMDA2NDQgMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMCA4YWNiOGU5NzUwZTNmNjQ0YmYzMjNmY2YzZDMzODg0OWRiMTA2Yzc3IEEJWi9BQQotOjAwMDAwMCAxMDA2NDQgMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMCAwODc0OTQyNjIwODRjZWZlZTdlZDQ4NGQyMGM4ZGMwNTgwNzkxMjcyIEEJWi9BTgotOjEwMDY0NCAwMDAwMDAgODc5MDA3ZWZhZTYyNGQyYjEzMDcyMTRiMjRhOTU2ZjBhOGQ2ODZhOCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwIEQJWi9ERAotOjEwMDY0NCAwMDAwMDAgOWI1NDFiMjI3NWMwNmUzYTdiMTNmMjhiYWRmNTI5NGUyYWU2M2RmNCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwIEQJWi9ETQotOjEwMDY0NCAwMDAwMDAgYmViNWQzOGM1NTI4M2QyODA2ODVlYTIxYTBlNTBjZmNjMGNhMDY0YSAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwIEQJWi9ETgotOjEwMDY0NCAxMDA2NDQgZDQxZmRhNDFiN2VjNGRlNDZiNDNjYjdlYTQyYTQ1MDAxYWUzOTNkNSBhNzlhYzNiZTkzNzc2MzllMWM3ZDFlZGYxYWUxYjNhNWYwY2NkOGE5IE0JWi9NRAotOjEwMDY0NCAxMDA2NDQgNGNhMjJiYWUyNTI3ZDNkOWUxNjc2NDk4YTBmYmEzYjM1NWJkMTI3OCA2MTQyMmJhOWMyYzg3MzQxNjA2MWE4OGNkNDBhNTlhMzViNTc2NDc0IE0JWi9NTQotOjEwMDY0NCAxMDA2NDQgYjE2ZDdiMjViODY5ZjJiZWIxMjRlZmE1MzQ2N2Q4YTE1NTBhZDY5NCBhNWM1NDRjMjFjZmNiMDdlYjgwYTRkODlhNWI3ZDE1NzAwMDJlZGZkIE0JWi9NTgorY2F0ID4udGVzdC1wbGFpbi1PQSA8PEVPRgorOjAwMDAwMCAxMDA2NDQgJCh0ZXN0X29pZCB6ZXJvKSAkKHRlc3Rfb2lkIGFhXzEpIEEJQUEKKzowMDAwMDAgMTAwNjQ0ICQodGVzdF9vaWQgemVybykgJCh0ZXN0X29pZCBhbl8xKSBBCUFOCis6MTAwNjQ0IDAwMDAwMCAkKHRlc3Rfb2lkIGRkXzEpICQodGVzdF9vaWQgemVybykgRAlERAorOjAwMDAwMCAwNDAwMDAgJCh0ZXN0X29pZCB6ZXJvKSAkKHRlc3Rfb2lkIGRmXzEpIEEJREYKKzoxMDA2NDQgMDAwMDAwICQodGVzdF9vaWQgZG1fMSkgJCh0ZXN0X29pZCB6ZXJvKSBECURNCis6MTAwNjQ0IDAwMDAwMCAkKHRlc3Rfb2lkIGRuXzEpICQodGVzdF9vaWQgemVybykgRAlETgorOjAwMDAwMCAxMDA2NDQgJCh0ZXN0X29pZCB6ZXJvKSAkKHRlc3Rfb2lkIGxsXzIpIEEJTEwKKzoxMDA2NDQgMTAwNjQ0ICQodGVzdF9vaWQgbWRfMSkgJCh0ZXN0X29pZCBtZF8yKSBNCU1ECis6MTAwNjQ0IDEwMDY0NCAkKHRlc3Rfb2lkIG1tXzEpICQodGVzdF9vaWQgbW1fMikgTQlNTQorOjEwMDY0NCAxMDA2NDQgJCh0ZXN0X29pZCBtbl8xKSAkKHRlc3Rfb2lkIG1uXzIpIE0JTU4KKzoxMDA2NDQgMTAwNjQ0ICQodGVzdF9vaWQgc3NfMSkgJCh0ZXN0X29pZCBzc18yKSBNCVNTCis6MTAwNjQ0IDEwMDY0NCAkKHRlc3Rfb2lkIHR0XzEpICQodGVzdF9vaWQgdHRfMikgTQlUVAorOjA0MDAwMCAwNDAwMDAgJCh0ZXN0X29pZCB6X18xKSAkKHRlc3Rfb2lkIHpfXzIpIE0JWgogRU9GCi1jYXQgPi50ZXN0LXBsYWluLU9CIDw8XEVPRgotOjAwMDAwMCAxMDA2NDQgMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMCA2YWEyYjUzMzViMTY0MzFhMGVmNzFlNWMwYTI4YmU2OTE4M2NmNmEyIEEJQUEKLToxMDA2NDQgMDAwMDAwIGJjYzY4ZWY5OTcwMTc0NjZkNWM5MDk0YmNmNzY5MjI5NWY1ODhjOWEgMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMCBECURECi06MDAwMDAwIDEwMDY0NCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwIDcxNDIwYWI4MWUyNTQxNDVkMjZkNmZjMGNkZGVlNjRjMWFjZDQ3ODcgQQlERgotOjEwMDY0NCAxMDA2NDQgMTQxYzFmMTY0MjMyOGU0YmM0NmE3ZDgwMWE3MWRhMzkyZTY2NzkxZSAzYzRkOGRlNWZiYWQwODU3MmJhYjhlMTBlZWY4ZGJiMjY0Y2YwMjMxIE0JRE0KLTowMDAwMDAgMTAwNjQ0IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAgMWQ0MTEyMmViZGQ3YTY0MGYyOWQzYzljYzRmOWQ3MDA5NDM3NDc2MiBBCUxMCi06MTAwNjQ0IDAwMDAwMCAwM2YyNGM4YzQ3MDBiYWJjY2ZkMjhiNjU0ZTdlOGVhYzQwMmFkNmNkIDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAgRAlNRAotOjEwMDY0NCAxMDA2NDQgYjI1ODUwOGFmYjdjZWI0NDk5ODFiZDlkNjNkMmQzZTk3MWJmOGQzNCAxOTk4OWQ0NTU5YWFlNDE3ZmVkZWUyNDBjY2YyYmEzMTVlYTRkYzJiIE0JTU0KLTowMDAwMDAgMTAwNjQ0IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAgMTU4ODU4ODFlYTY5MTE1MzUxYzA5YjM4MzcxZjAzNDhhM2ZiOGM2NyBBCU5BCi06MTAwNjQ0IDAwMDAwMCBhNGUxNzllNDI5MWU1NTM2YTVlMWM4MmUwOTEwNTI3NzJkMmM1YTkzIDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAgRAlORAotOjEwMDY0NCAxMDA2NDQgYzhmMjU3ODFlOGYxNzkyZTNlNDBiNzQyMjVlMjA1NTMwNDFiNTIyNiBjZGI5YThjM2RhNTcxNTAyYWMzMDIyNWU5YzE3YmVjY2I4Mzg3OTgzIE0JTk0KLToxMDA2NDQgMTAwNjQ0IDQwYzk1OWY5ODRjOGI4OWEyYjAyNTIwZDE3ZjAwZDcxN2YwMjQzOTcgMmFjNTQ3YWU5NjE0YTAwZDFiMjgyNzVkZTYwODEzMWY3YTBlMjU5ZiBNCVNTCi06MTAwNjQ0IDEwMDY0NCA0YWMxMzQ1ODg5OWFiOTA4ZWYzYjExMjhmYTM3OGRhZWZjODhkMzU2IGM0ZTRhMTIyMzFiOWZhNzlhMDA1M2NiNjA3N2ZjYjIxYmI1YjEzNWEgTQlUVAotOjA0MDAwMCAwNDAwMDAgN2Q2NzBmZGNkYjk5MjlmNmM3ZGFjMTk2ZmY3ODY4OWNkMWM1NjZhMSAxYmE1MjM5NTVkNTE2MDY4MWFmNjVjYjc3NjQxMWY1NzRjMWU4MTU1IE0JWgorCitjYXQgPi50ZXN0LXJlY3Vyc2l2ZS1PQSA8PEVPRgorOjAwMDAwMCAxMDA2NDQgJCh0ZXN0X29pZCB6ZXJvKSAkKHRlc3Rfb2lkIGFhXzEpIEEJQUEKKzowMDAwMDAgMTAwNjQ0ICQodGVzdF9vaWQgemVybykgJCh0ZXN0X29pZCBhbl8xKSBBCUFOCis6MTAwNjQ0IDAwMDAwMCAkKHRlc3Rfb2lkIGRkXzEpICQodGVzdF9vaWQgemVybykgRAlERAorOjAwMDAwMCAxMDA2NDQgJCh0ZXN0X29pZCB6ZXJvKSAkKHRlc3Rfb2lkIGRmZDEpIEEJREYvREYKKzoxMDA2NDQgMDAwMDAwICQodGVzdF9vaWQgZG1fMSkgJCh0ZXN0X29pZCB6ZXJvKSBECURNCis6MTAwNjQ0IDAwMDAwMCAkKHRlc3Rfb2lkIGRuXzEpICQodGVzdF9vaWQgemVybykgRAlETgorOjAwMDAwMCAxMDA2NDQgJCh0ZXN0X29pZCB6ZXJvKSAkKHRlc3Rfb2lkIGxsXzIpIEEJTEwKKzoxMDA2NDQgMTAwNjQ0ICQodGVzdF9vaWQgbWRfMSkgJCh0ZXN0X29pZCBtZF8yKSBNCU1ECis6MTAwNjQ0IDEwMDY0NCAkKHRlc3Rfb2lkIG1tXzEpICQodGVzdF9vaWQgbW1fMikgTQlNTQorOjEwMDY0NCAxMDA2NDQgJCh0ZXN0X29pZCBtbl8xKSAkKHRlc3Rfb2lkIG1uXzIpIE0JTU4KKzoxMDA2NDQgMTAwNjQ0ICQodGVzdF9vaWQgc3NfMSkgJCh0ZXN0X29pZCBzc18yKSBNCVNTCis6MTAwNjQ0IDEwMDY0NCAkKHRlc3Rfb2lkIHR0XzEpICQodGVzdF9vaWQgdHRfMikgTQlUVAorOjAwMDAwMCAxMDA2NDQgJCh0ZXN0X29pZCB6ZXJvKSAkKHRlc3Rfb2lkIHphYTEpIEEJWi9BQQorOjAwMDAwMCAxMDA2NDQgJCh0ZXN0X29pZCB6ZXJvKSAkKHRlc3Rfb2lkIHphbjEpIEEJWi9BTgorOjEwMDY0NCAwMDAwMDAgJCh0ZXN0X29pZCB6ZGQxKSAkKHRlc3Rfb2lkIHplcm8pIEQJWi9ERAorOjEwMDY0NCAwMDAwMDAgJCh0ZXN0X29pZCB6ZG0xKSAkKHRlc3Rfb2lkIHplcm8pIEQJWi9ETQorOjEwMDY0NCAwMDAwMDAgJCh0ZXN0X29pZCB6ZG4xKSAkKHRlc3Rfb2lkIHplcm8pIEQJWi9ETgorOjEwMDY0NCAxMDA2NDQgJCh0ZXN0X29pZCB6bWQxKSAkKHRlc3Rfb2lkIHptZDIpIE0JWi9NRAorOjEwMDY0NCAxMDA2NDQgJCh0ZXN0X29pZCB6bW0xKSAkKHRlc3Rfb2lkIHptbTIpIE0JWi9NTQorOjEwMDY0NCAxMDA2NDQgJCh0ZXN0X29pZCB6bW4xKSAkKHRlc3Rfb2lkIHptbjIpIE0JWi9NTgogRU9GCi1jYXQgPi50ZXN0LXJlY3Vyc2l2ZS1PQiA8PFxFT0YKLTowMDAwMDAgMTAwNjQ0IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAgNmFhMmI1MzM1YjE2NDMxYTBlZjcxZTVjMGEyOGJlNjkxODNjZjZhMiBBCUFBCi06MTAwNjQ0IDAwMDAwMCBiY2M2OGVmOTk3MDE3NDY2ZDVjOTA5NGJjZjc2OTIyOTVmNTg4YzlhIDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAgRAlERAotOjAwMDAwMCAxMDA2NDQgMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMCA3MTQyMGFiODFlMjU0MTQ1ZDI2ZDZmYzBjZGRlZTY0YzFhY2Q0Nzg3IEEJREYKLToxMDA2NDQgMTAwNjQ0IDE0MWMxZjE2NDIzMjhlNGJjNDZhN2Q4MDFhNzFkYTM5MmU2Njc5MWUgM2M0ZDhkZTVmYmFkMDg1NzJiYWI4ZTEwZWVmOGRiYjI2NGNmMDIzMSBNCURNCi06MDAwMDAwIDEwMDY0NCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwIDFkNDExMjJlYmRkN2E2NDBmMjlkM2M5Y2M0ZjlkNzAwOTQzNzQ3NjIgQQlMTAotOjEwMDY0NCAwMDAwMDAgMDNmMjRjOGM0NzAwYmFiY2NmZDI4YjY1NGU3ZThlYWM0MDJhZDZjZCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwIEQJTUQKLToxMDA2NDQgMTAwNjQ0IGIyNTg1MDhhZmI3Y2ViNDQ5OTgxYmQ5ZDYzZDJkM2U5NzFiZjhkMzQgMTk5ODlkNDU1OWFhZTQxN2ZlZGVlMjQwY2NmMmJhMzE1ZWE0ZGMyYiBNCU1NCi06MDAwMDAwIDEwMDY0NCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwIDE1ODg1ODgxZWE2OTExNTM1MWMwOWIzODM3MWYwMzQ4YTNmYjhjNjcgQQlOQQotOjEwMDY0NCAwMDAwMDAgYTRlMTc5ZTQyOTFlNTUzNmE1ZTFjODJlMDkxMDUyNzcyZDJjNWE5MyAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwIEQJTkQKLToxMDA2NDQgMTAwNjQ0IGM4ZjI1NzgxZThmMTc5MmUzZTQwYjc0MjI1ZTIwNTUzMDQxYjUyMjYgY2RiOWE4YzNkYTU3MTUwMmFjMzAyMjVlOWMxN2JlY2NiODM4Nzk4MyBNCU5NCi06MTAwNjQ0IDEwMDY0NCA0MGM5NTlmOTg0YzhiODlhMmIwMjUyMGQxN2YwMGQ3MTdmMDI0Mzk3IDJhYzU0N2FlOTYxNGEwMGQxYjI4Mjc1ZGU2MDgxMzFmN2EwZTI1OWYgTQlTUwotOjEwMDY0NCAxMDA2NDQgNGFjMTM0NTg4OTlhYjkwOGVmM2IxMTI4ZmEzNzhkYWVmYzg4ZDM1NiBjNGU0YTEyMjMxYjlmYTc5YTAwNTNjYjYwNzdmY2IyMWJiNWIxMzVhIE0JVFQKLTowMDAwMDAgMTAwNjQ0IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAgNmMwYjk5Mjg2ZDBiY2U1NTFhYzRhN2IzZGZmOGI3MDZlZGZmMzcxNSBBCVovQUEKLToxMDA2NDQgMDAwMDAwIDg3OTAwN2VmYWU2MjRkMmIxMzA3MjE0YjI0YTk1NmYwYThkNjg2YTggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMCBECVovREQKLToxMDA2NDQgMTAwNjQ0IDliNTQxYjIyNzVjMDZlM2E3YjEzZjI4YmFkZjUyOTRlMmFlNjNkZjQgZDc3MzcxZDE1ODE3ZmNhYTU3ZWVlYzI3Zjc3MGM1MDViYTk3NGVjMSBNCVovRE0KLToxMDA2NDQgMDAwMDAwIGQ0MWZkYTQxYjdlYzRkZTQ2YjQzY2I3ZWE0MmE0NTAwMWFlMzkzZDUgMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMCBECVovTUQKLToxMDA2NDQgMTAwNjQ0IDRjYTIyYmFlMjUyN2QzZDllMTY3NjQ5OGEwZmJhM2IzNTViZDEyNzggNjk3YWFkNzcxNWExZTczMDZjYTc2MjkwYTNkZDQyMDhmYmFlZGRmYSBNCVovTU0KLTowMDAwMDAgMTAwNjQ0IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAgZDEyOTc5YzIyZmZmNjljNTljYTk0MDllN2E4ZmUzZWUyNWVhZWU4MCBBCVovTkEKLToxMDA2NDQgMDAwMDAwIGExODM5M2M2MzZiOThlOWJkNzI5NmI4YjQzN2VhNDk5MmI3MjQ0MGMgMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMCBECVovTkQKLToxMDA2NDQgMTAwNjQ0IDNmZGJlMTdmZDAxMzMwM2EyZTk4MWUxY2ExYzZjZDZlNzI3ODkwODcgN2UwOWQ2YTNhMTRiZDYzMDkxM2U4Yzc1NjkzY2VhMzIxNTdiNjA2ZCBNCVovTk0KK2NhdCA+LnRlc3QtcGxhaW4tT0IgPDxFT0YKKzowMDAwMDAgMTAwNjQ0ICQodGVzdF9vaWQgemVybykgJCh0ZXN0X29pZCBhYV8yKSBBCUFBCis6MTAwNjQ0IDAwMDAwMCAkKHRlc3Rfb2lkIGRkXzEpICQodGVzdF9vaWQgemVybykgRAlERAorOjAwMDAwMCAxMDA2NDQgJCh0ZXN0X29pZCB6ZXJvKSAkKHRlc3Rfb2lkIGRmXzIpIEEJREYKKzoxMDA2NDQgMTAwNjQ0ICQodGVzdF9vaWQgZG1fMSkgJCh0ZXN0X29pZCBkbV8yKSBNCURNCis6MDAwMDAwIDEwMDY0NCAkKHRlc3Rfb2lkIHplcm8pICQodGVzdF9vaWQgbGxfMikgQQlMTAorOjEwMDY0NCAwMDAwMDAgJCh0ZXN0X29pZCBtZF8xKSAkKHRlc3Rfb2lkIHplcm8pIEQJTUQKKzoxMDA2NDQgMTAwNjQ0ICQodGVzdF9vaWQgbW1fMSkgJCh0ZXN0X29pZCBtbV8zKSBNCU1NCis6MDAwMDAwIDEwMDY0NCAkKHRlc3Rfb2lkIHplcm8pICQodGVzdF9vaWQgbmFfMSkgQQlOQQorOjEwMDY0NCAwMDAwMDAgJCh0ZXN0X29pZCBuZF8xKSAkKHRlc3Rfb2lkIHplcm8pIEQJTkQKKzoxMDA2NDQgMTAwNjQ0ICQodGVzdF9vaWQgbm1fMSkgJCh0ZXN0X29pZCBubV8yKSBNCU5NCis6MTAwNjQ0IDEwMDY0NCAkKHRlc3Rfb2lkIHNzXzEpICQodGVzdF9vaWQgc3NfMikgTQlTUworOjEwMDY0NCAxMDA2NDQgJCh0ZXN0X29pZCB0dF8xKSAkKHRlc3Rfb2lkIHR0XzMpIE0JVFQKKzowNDAwMDAgMDQwMDAwICQodGVzdF9vaWQgel9fMSkgJCh0ZXN0X29pZCB6X18zKSBNCVoKIEVPRgotY2F0ID4udGVzdC1wbGFpbi1BQiA8PFxFT0YKLToxMDA2NDQgMTAwNjQ0IGNjYmE3MmFkMzg4OGEzNTIwYjM5ZWZjZjc4MGI5ZWU2NDE2NzUzNWQgNmFhMmI1MzM1YjE2NDMxYTBlZjcxZTVjMGEyOGJlNjkxODNjZjZhMiBNCUFBCi06MTAwNjQ0IDAwMDAwMCA3ZTQyNmZiMDc5NDc5ZmQ2N2Y2ZDgxZjk4NGU0ZWM2NDlhNDRiYzI1IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAgRAlBTgotOjAwMDAwMCAxMDA2NDQgMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMCA3MTQyMGFiODFlMjU0MTQ1ZDI2ZDZmYzBjZGRlZTY0YzFhY2Q0Nzg3IEEJREYKLTowNDAwMDAgMDAwMDAwIDZkNTBmNjVkM2JkYWI5MWM2MzQ0NDI5NGQzOGYwOGFlZmYzMjhlNDIgMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMCBECURGCi06MDAwMDAwIDEwMDY0NCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwIDNjNGQ4ZGU1ZmJhZDA4NTcyYmFiOGUxMGVlZjhkYmIyNjRjZjAyMzEgQQlETQotOjAwMDAwMCAxMDA2NDQgMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMCAzNWFiZGUxNTA2ZGRmODA2NTcyZmY0ZDQwN2JkMDY4ODVkMGY4ZWU5IEEJRE4KLToxMDA2NDQgMDAwMDAwIDEwM2Q5Zjg5YjUwYjlhYWQwMzA1NGI1NzliZTVlN2FhNjY1ZjJkNTcgMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMCBECU1ECi06MTAwNjQ0IDEwMDY0NCBiNDMxYjI3MmQ4MjlmZjNhYTRkMWE1MDg1ZjQzOTRhYjRkMzMwNWI2IDE5OTg5ZDQ1NTlhYWU0MTdmZWRlZTI0MGNjZjJiYTMxNWVhNGRjMmIgTQlNTQotOjEwMDY0NCAxMDA2NDQgYTcxNmQ1OGRlNGE1NzBlMDAzOGY1YzMwN2JkOGRiMzRkYWVhMDIxZiBiZDA4NGIwYzI3YzdiNmNjMzRmMTFkNmQwNTA5YTI5YmUzY2FmOTcwIE0JTU4KLTowMDAwMDAgMTAwNjQ0IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAgMTU4ODU4ODFlYTY5MTE1MzUxYzA5YjM4MzcxZjAzNDhhM2ZiOGM2NyBBCU5BCi06MTAwNjQ0IDAwMDAwMCBhNGUxNzllNDI5MWU1NTM2YTVlMWM4MmUwOTEwNTI3NzJkMmM1YTkzIDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAgRAlORAotOjEwMDY0NCAxMDA2NDQgYzhmMjU3ODFlOGYxNzkyZTNlNDBiNzQyMjVlMjA1NTMwNDFiNTIyNiBjZGI5YThjM2RhNTcxNTAyYWMzMDIyNWU5YzE3YmVjY2I4Mzg3OTgzIE0JTk0KLToxMDA2NDQgMTAwNjQ0IDRjODZmOWE4NWZiYzVlNjgwNGVlMmUxN2E3OTc1MzhmYmU3ODViY2EgYzRlNGExMjIzMWI5ZmE3OWEwMDUzY2I2MDc3ZmNiMjFiYjViMTM1YSBNCVRUCi06MDQwMDAwIDA0MDAwMCA1ZTVmMjIwNzJiYjM5ZjZlMTJjZjY2M2E1N2NiNjM0Yzc2ZWVmYjQ5IDFiYTUyMzk1NWQ1MTYwNjgxYWY2NWNiNzc2NDExZjU3NGMxZTgxNTUgTQlaCitjYXQgPi50ZXN0LXJlY3Vyc2l2ZS1PQiA8PEVPRgorOjAwMDAwMCAxMDA2NDQgJCh0ZXN0X29pZCB6ZXJvKSAkKHRlc3Rfb2lkIGFhXzIpIEEJQUEKKzoxMDA2NDQgMDAwMDAwICQodGVzdF9vaWQgZGRfMSkgJCh0ZXN0X29pZCB6ZXJvKSBECURECis6MDAwMDAwIDEwMDY0NCAkKHRlc3Rfb2lkIHplcm8pICQodGVzdF9vaWQgZGZfMikgQQlERgorOjEwMDY0NCAxMDA2NDQgJCh0ZXN0X29pZCBkbV8xKSAkKHRlc3Rfb2lkIGRtXzIpIE0JRE0KKzowMDAwMDAgMTAwNjQ0ICQodGVzdF9vaWQgemVybykgJCh0ZXN0X29pZCBsbF8yKSBBCUxMCis6MTAwNjQ0IDAwMDAwMCAkKHRlc3Rfb2lkIG1kXzEpICQodGVzdF9vaWQgemVybykgRAlNRAorOjEwMDY0NCAxMDA2NDQgJCh0ZXN0X29pZCBtbV8xKSAkKHRlc3Rfb2lkIG1tXzMpIE0JTU0KKzowMDAwMDAgMTAwNjQ0ICQodGVzdF9vaWQgemVybykgJCh0ZXN0X29pZCBuYV8xKSBBCU5BCis6MTAwNjQ0IDAwMDAwMCAkKHRlc3Rfb2lkIG5kXzEpICQodGVzdF9vaWQgemVybykgRAlORAorOjEwMDY0NCAxMDA2NDQgJCh0ZXN0X29pZCBubV8xKSAkKHRlc3Rfb2lkIG5tXzIpIE0JTk0KKzoxMDA2NDQgMTAwNjQ0ICQodGVzdF9vaWQgc3NfMSkgJCh0ZXN0X29pZCBzc18yKSBNCVNTCis6MTAwNjQ0IDEwMDY0NCAkKHRlc3Rfb2lkIHR0XzEpICQodGVzdF9vaWQgdHRfMykgTQlUVAorOjAwMDAwMCAxMDA2NDQgJCh0ZXN0X29pZCB6ZXJvKSAkKHRlc3Rfb2lkIHphYTIpIEEJWi9BQQorOjEwMDY0NCAwMDAwMDAgJCh0ZXN0X29pZCB6ZGQxKSAkKHRlc3Rfb2lkIHplcm8pIEQJWi9ERAorOjEwMDY0NCAxMDA2NDQgJCh0ZXN0X29pZCB6ZG0xKSAkKHRlc3Rfb2lkIHpkbTIpIE0JWi9ETQorOjEwMDY0NCAwMDAwMDAgJCh0ZXN0X29pZCB6bWQxKSAkKHRlc3Rfb2lkIHplcm8pIEQJWi9NRAorOjEwMDY0NCAxMDA2NDQgJCh0ZXN0X29pZCB6bW0xKSAkKHRlc3Rfb2lkIHptbTMpIE0JWi9NTQorOjAwMDAwMCAxMDA2NDQgJCh0ZXN0X29pZCB6ZXJvKSAkKHRlc3Rfb2lkIHpuYTEpIEEJWi9OQQorOjEwMDY0NCAwMDAwMDAgJCh0ZXN0X29pZCB6bmQxKSAkKHRlc3Rfb2lkIHplcm8pIEQJWi9ORAorOjEwMDY0NCAxMDA2NDQgJCh0ZXN0X29pZCB6bm0xKSAkKHRlc3Rfb2lkIHpubTIpIE0JWi9OTQogRU9GCi1jYXQgPi50ZXN0LXJlY3Vyc2l2ZS1BQiA8PFxFT0YKLToxMDA2NDQgMTAwNjQ0IGNjYmE3MmFkMzg4OGEzNTIwYjM5ZWZjZjc4MGI5ZWU2NDE2NzUzNWQgNmFhMmI1MzM1YjE2NDMxYTBlZjcxZTVjMGEyOGJlNjkxODNjZjZhMiBNCUFBCi06MTAwNjQ0IDAwMDAwMCA3ZTQyNmZiMDc5NDc5ZmQ2N2Y2ZDgxZjk4NGU0ZWM2NDlhNDRiYzI1IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAgRAlBTgotOjAwMDAwMCAxMDA2NDQgMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMCA3MTQyMGFiODFlMjU0MTQ1ZDI2ZDZmYzBjZGRlZTY0YzFhY2Q0Nzg3IEEJREYKLToxMDA2NDQgMDAwMDAwIDY4YTZkOGI5MWRhMTEwNDVjZjRhYTNhNWFiOWYyYTc4MWM3MDEyNDkgMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMCBECURGL0RGCi06MDAwMDAwIDEwMDY0NCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwIDNjNGQ4ZGU1ZmJhZDA4NTcyYmFiOGUxMGVlZjhkYmIyNjRjZjAyMzEgQQlETQotOjAwMDAwMCAxMDA2NDQgMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMCAzNWFiZGUxNTA2ZGRmODA2NTcyZmY0ZDQwN2JkMDY4ODVkMGY4ZWU5IEEJRE4KLToxMDA2NDQgMDAwMDAwIDEwM2Q5Zjg5YjUwYjlhYWQwMzA1NGI1NzliZTVlN2FhNjY1ZjJkNTcgMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMCBECU1ECi06MTAwNjQ0IDEwMDY0NCBiNDMxYjI3MmQ4MjlmZjNhYTRkMWE1MDg1ZjQzOTRhYjRkMzMwNWI2IDE5OTg5ZDQ1NTlhYWU0MTdmZWRlZTI0MGNjZjJiYTMxNWVhNGRjMmIgTQlNTQotOjEwMDY0NCAxMDA2NDQgYTcxNmQ1OGRlNGE1NzBlMDAzOGY1YzMwN2JkOGRiMzRkYWVhMDIxZiBiZDA4NGIwYzI3YzdiNmNjMzRmMTFkNmQwNTA5YTI5YmUzY2FmOTcwIE0JTU4KLTowMDAwMDAgMTAwNjQ0IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAgMTU4ODU4ODFlYTY5MTE1MzUxYzA5YjM4MzcxZjAzNDhhM2ZiOGM2NyBBCU5BCi06MTAwNjQ0IDAwMDAwMCBhNGUxNzllNDI5MWU1NTM2YTVlMWM4MmUwOTEwNTI3NzJkMmM1YTkzIDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAgRAlORAotOjEwMDY0NCAxMDA2NDQgYzhmMjU3ODFlOGYxNzkyZTNlNDBiNzQyMjVlMjA1NTMwNDFiNTIyNiBjZGI5YThjM2RhNTcxNTAyYWMzMDIyNWU5YzE3YmVjY2I4Mzg3OTgzIE0JTk0KLToxMDA2NDQgMTAwNjQ0IDRjODZmOWE4NWZiYzVlNjgwNGVlMmUxN2E3OTc1MzhmYmU3ODViY2EgYzRlNGExMjIzMWI5ZmE3OWEwMDUzY2I2MDc3ZmNiMjFiYjViMTM1YSBNCVRUCi06MTAwNjQ0IDEwMDY0NCA4YWNiOGU5NzUwZTNmNjQ0YmYzMjNmY2YzZDMzODg0OWRiMTA2Yzc3IDZjMGI5OTI4NmQwYmNlNTUxYWM0YTdiM2RmZjhiNzA2ZWRmZjM3MTUgTQlaL0FBCi06MTAwNjQ0IDAwMDAwMCAwODc0OTQyNjIwODRjZWZlZTdlZDQ4NGQyMGM4ZGMwNTgwNzkxMjcyIDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAgRAlaL0FOCi06MDAwMDAwIDEwMDY0NCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwIGQ3NzM3MWQxNTgxN2ZjYWE1N2VlZWMyN2Y3NzBjNTA1YmE5NzRlYzEgQQlaL0RNCi06MDAwMDAwIDEwMDY0NCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwIGJlYjVkMzhjNTUyODNkMjgwNjg1ZWEyMWEwZTUwY2ZjYzBjYTA2NGEgQQlaL0ROCi06MTAwNjQ0IDAwMDAwMCBhNzlhYzNiZTkzNzc2MzllMWM3ZDFlZGYxYWUxYjNhNWYwY2NkOGE5IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAgRAlaL01ECi06MTAwNjQ0IDEwMDY0NCA2MTQyMmJhOWMyYzg3MzQxNjA2MWE4OGNkNDBhNTlhMzViNTc2NDc0IDY5N2FhZDc3MTVhMWU3MzA2Y2E3NjI5MGEzZGQ0MjA4ZmJhZWRkZmEgTQlaL01NCi06MTAwNjQ0IDEwMDY0NCBhNWM1NDRjMjFjZmNiMDdlYjgwYTRkODlhNWI3ZDE1NzAwMDJlZGZkIGIxNmQ3YjI1Yjg2OWYyYmViMTI0ZWZhNTM0NjdkOGExNTUwYWQ2OTQgTQlaL01OCi06MDAwMDAwIDEwMDY0NCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwIGQxMjk3OWMyMmZmZjY5YzU5Y2E5NDA5ZTdhOGZlM2VlMjVlYWVlODAgQQlaL05BCi06MTAwNjQ0IDAwMDAwMCBhMTgzOTNjNjM2Yjk4ZTliZDcyOTZiOGI0MzdlYTQ5OTJiNzI0NDBjIDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAgRAlaL05ECi06MTAwNjQ0IDEwMDY0NCAzZmRiZTE3ZmQwMTMzMDNhMmU5ODFlMWNhMWM2Y2Q2ZTcyNzg5MDg3IDdlMDlkNmEzYTE0YmQ2MzA5MTNlOGM3NTY5M2NlYTMyMTU3YjYwNmQgTQlaL05NCitjYXQgPi50ZXN0LXBsYWluLUFCIDw8RU9GCis6MTAwNjQ0IDEwMDY0NCAkKHRlc3Rfb2lkIGFhXzEpICQodGVzdF9vaWQgYWFfMikgTQlBQQorOjEwMDY0NCAwMDAwMDAgJCh0ZXN0X29pZCBhbl8xKSAkKHRlc3Rfb2lkIHplcm8pIEQJQU4KKzowMDAwMDAgMTAwNjQ0ICQodGVzdF9vaWQgemVybykgJCh0ZXN0X29pZCBkZl8yKSBBCURGCis6MDQwMDAwIDAwMDAwMCAkKHRlc3Rfb2lkIGRmXzEpICQodGVzdF9vaWQgemVybykgRAlERgorOjAwMDAwMCAxMDA2NDQgJCh0ZXN0X29pZCB6ZXJvKSAkKHRlc3Rfb2lkIGRtXzIpIEEJRE0KKzowMDAwMDAgMTAwNjQ0ICQodGVzdF9vaWQgemVybykgJCh0ZXN0X29pZCBkbl8xKSBBCUROCis6MTAwNjQ0IDAwMDAwMCAkKHRlc3Rfb2lkIG1kXzIpICQodGVzdF9vaWQgemVybykgRAlNRAorOjEwMDY0NCAxMDA2NDQgJCh0ZXN0X29pZCBtbV8yKSAkKHRlc3Rfb2lkIG1tXzMpIE0JTU0KKzoxMDA2NDQgMTAwNjQ0ICQodGVzdF9vaWQgbW5fMikgJCh0ZXN0X29pZCBtbl8xKSBNCU1OCis6MDAwMDAwIDEwMDY0NCAkKHRlc3Rfb2lkIHplcm8pICQodGVzdF9vaWQgbmFfMSkgQQlOQQorOjEwMDY0NCAwMDAwMDAgJCh0ZXN0X29pZCBuZF8xKSAkKHRlc3Rfb2lkIHplcm8pIEQJTkQKKzoxMDA2NDQgMTAwNjQ0ICQodGVzdF9vaWQgbm1fMSkgJCh0ZXN0X29pZCBubV8yKSBNCU5NCis6MTAwNjQ0IDEwMDY0NCAkKHRlc3Rfb2lkIHR0XzIpICQodGVzdF9vaWQgdHRfMykgTQlUVAorOjA0MDAwMCAwNDAwMDAgJCh0ZXN0X29pZCB6X18yKSAkKHRlc3Rfb2lkIHpfXzMpIE0JWgorRU9GCitjYXQgPi50ZXN0LXJlY3Vyc2l2ZS1BQiA8PEVPRgorOjEwMDY0NCAxMDA2NDQgJCh0ZXN0X29pZCBhYV8xKSAkKHRlc3Rfb2lkIGFhXzIpIE0JQUEKKzoxMDA2NDQgMDAwMDAwICQodGVzdF9vaWQgYW5fMSkgJCh0ZXN0X29pZCB6ZXJvKSBECUFOCis6MDAwMDAwIDEwMDY0NCAkKHRlc3Rfb2lkIHplcm8pICQodGVzdF9vaWQgZGZfMikgQQlERgorOjEwMDY0NCAwMDAwMDAgJCh0ZXN0X29pZCBkZmQxKSAkKHRlc3Rfb2lkIHplcm8pIEQJREYvREYKKzowMDAwMDAgMTAwNjQ0ICQodGVzdF9vaWQgemVybykgJCh0ZXN0X29pZCBkbV8yKSBBCURNCis6MDAwMDAwIDEwMDY0NCAkKHRlc3Rfb2lkIHplcm8pICQodGVzdF9vaWQgZG5fMSkgQQlETgorOjEwMDY0NCAwMDAwMDAgJCh0ZXN0X29pZCBtZF8yKSAkKHRlc3Rfb2lkIHplcm8pIEQJTUQKKzoxMDA2NDQgMTAwNjQ0ICQodGVzdF9vaWQgbW1fMikgJCh0ZXN0X29pZCBtbV8zKSBNCU1NCis6MTAwNjQ0IDEwMDY0NCAkKHRlc3Rfb2lkIG1uXzIpICQodGVzdF9vaWQgbW5fMSkgTQlNTgorOjAwMDAwMCAxMDA2NDQgJCh0ZXN0X29pZCB6ZXJvKSAkKHRlc3Rfb2lkIG5hXzEpIEEJTkEKKzoxMDA2NDQgMDAwMDAwICQodGVzdF9vaWQgbmRfMSkgJCh0ZXN0X29pZCB6ZXJvKSBECU5ECis6MTAwNjQ0IDEwMDY0NCAkKHRlc3Rfb2lkIG5tXzEpICQodGVzdF9vaWQgbm1fMikgTQlOTQorOjEwMDY0NCAxMDA2NDQgJCh0ZXN0X29pZCB0dF8yKSAkKHRlc3Rfb2lkIHR0XzMpIE0JVFQKKzoxMDA2NDQgMTAwNjQ0ICQodGVzdF9vaWQgemFhMSkgJCh0ZXN0X29pZCB6YWEyKSBNCVovQUEKKzoxMDA2NDQgMDAwMDAwICQodGVzdF9vaWQgemFuMSkgJCh0ZXN0X29pZCB6ZXJvKSBECVovQU4KKzowMDAwMDAgMTAwNjQ0ICQodGVzdF9vaWQgemVybykgJCh0ZXN0X29pZCB6ZG0yKSBBCVovRE0KKzowMDAwMDAgMTAwNjQ0ICQodGVzdF9vaWQgemVybykgJCh0ZXN0X29pZCB6ZG4xKSBBCVovRE4KKzoxMDA2NDQgMDAwMDAwICQodGVzdF9vaWQgem1kMikgJCh0ZXN0X29pZCB6ZXJvKSBECVovTUQKKzoxMDA2NDQgMTAwNjQ0ICQodGVzdF9vaWQgem1tMikgJCh0ZXN0X29pZCB6bW0zKSBNCVovTU0KKzoxMDA2NDQgMTAwNjQ0ICQodGVzdF9vaWQgem1uMikgJCh0ZXN0X29pZCB6bW4xKSBNCVovTU4KKzowMDAwMDAgMTAwNjQ0ICQodGVzdF9vaWQgemVybykgJCh0ZXN0X29pZCB6bmExKSBBCVovTkEKKzoxMDA2NDQgMDAwMDAwICQodGVzdF9vaWQgem5kMSkgJCh0ZXN0X29pZCB6ZXJvKSBECVovTkQKKzoxMDA2NDQgMTAwNjQ0ICQodGVzdF9vaWQgem5tMSkgJCh0ZXN0X29pZCB6bm0yKSBNCVovTk0KIEVPRgogCiBjbXBfZGlmZl9maWxlc19vdXRwdXQgKCkgewpkaWZmIC0tZ2l0IGEvdC90NDAwOS1kaWZmLXJlbmFtZS00LnNoIGIvdC90NDAwOS1kaWZmLXJlbmFtZS00LnNoCmluZGV4IDM2NDFmZDguLmI2M2JkZjAgMTAwNzU1Ci0tLSBhL3QvdDQwMDktZGlmZi1yZW5hbWUtNC5zaAorKysgYi90L3Q0MDA5LWRpZmYtcmVuYW1lLTQuc2gKQEAgLTE0LDYgKzE0LDcgQEAKICAgICAnY2F0ICIkVEVTVF9ESVJFQ1RPUlkiL2RpZmYtbGliL0NPUFlJTkcgPkNPUFlJTkcgJiYKICAgICAgZWNobyBmcm90eiA+cmV6cm92ICYmCiAgICAgZ2l0IHVwZGF0ZS1pbmRleCAtLWFkZCBDT1BZSU5HIHJlenJvdiAmJgorICAgIG9yaWc9JChnaXQgaGFzaC1vYmplY3QgQ09QWUlORykgJiYKICAgICB0cmVlPSQoZ2l0IHdyaXRlLXRyZWUpICYmCiAgICAgZWNobyAkdHJlZScKIApAQCAtMjIsNiArMjMsOCBAQAogICAgICdzZWQgLWUgJ3MvSE9XRVZFUi9Ib3dldmVyLycgPENPUFlJTkcgPkNPUFlJTkcuMSAmJgogICAgIHNlZCAtZSAncy9HUEwvRy5QLkwvZycgPENPUFlJTkcgPkNPUFlJTkcuMiAmJgogICAgIHJtIC1mIENPUFlJTkcgJiYKKyAgICBjMT0kKGdpdCBoYXNoLW9iamVjdCBDT1BZSU5HLjEpICYmCisgICAgYzI9JChnaXQgaGFzaC1vYmplY3QgQ09QWUlORy4yKSAmJgogICAgIGdpdCB1cGRhdGUtaW5kZXggLS1hZGQgLS1yZW1vdmUgQ09QWUlORyBDT1BZSU5HLj8nCiAKICMgdHJlZSBoYXMgQ09QWUlORyBhbmQgcmV6cm92LiAgd29yayB0cmVlIGhhcyBDT1BZSU5HLjEgYW5kIENPUFlJTkcuMiwKQEAgLTMxLDExICszNCwxMSBAQAogCiBnaXQgZGlmZi1pbmRleCAteiAtQyAkdHJlZSA+Y3VycmVudAogCi1jYXQgPmV4cGVjdGVkIDw8XEVPRgotOjEwMDY0NCAxMDA2NDQgNmZmODdjNDY2NDk4MWU0Mzk3NjI1NzkxYzhlYTNiYmI1ZjIyNzlhMyAwNjAzYjMyMzhhMDc2ZGM2YzgwMjJhZWRjNjY0OGZhNTIzYTE3MTc4IEMxMjM0CitjYXQgPmV4cGVjdGVkIDw8RU9GCis6MTAwNjQ0IDEwMDY0NCAkb3JpZyAkYzEgQzEyMzQKIENPUFlJTkcKIENPUFlJTkcuMQotOjEwMDY0NCAxMDA2NDQgNmZmODdjNDY2NDk4MWU0Mzk3NjI1NzkxYzhlYTNiYmI1ZjIyNzlhMyAwNmM2Nzk2MWJiYWVkMzRhMTI3Zjc2ZDI2MWY0YzBiZjczZWRhNDcxIFIxMjM0Cis6MTAwNjQ0IDEwMDY0NCAkb3JpZyAkYzIgUjEyMzQKIENPUFlJTkcKIENPUFlJTkcuMgogRU9GCkBAIC01NywxMCArNjAsMTAgQEAKICMgYWJvdXQgcmV6cm92LgogCiBnaXQgZGlmZi1pbmRleCAteiAtQyAkdHJlZSA+Y3VycmVudAotY2F0ID5leHBlY3RlZCA8PFxFT0YKLToxMDA2NDQgMTAwNjQ0IDZmZjg3YzQ2NjQ5ODFlNDM5NzYyNTc5MWM4ZWEzYmJiNWYyMjc5YTMgMDZjNjc5NjFiYmFlZDM0YTEyN2Y3NmQyNjFmNGMwYmY3M2VkYTQ3MSBNCitjYXQgPmV4cGVjdGVkIDw8RU9GCis6MTAwNjQ0IDEwMDY0NCAkb3JpZyAkYzIgTQogQ09QWUlORwotOjEwMDY0NCAxMDA2NDQgNmZmODdjNDY2NDk4MWU0Mzk3NjI1NzkxYzhlYTNiYmI1ZjIyNzlhMyAwNjAzYjMyMzhhMDc2ZGM2YzgwMjJhZWRjNjY0OGZhNTIzYTE3MTc4IEMxMjM0Cis6MTAwNjQ0IDEwMDY0NCAkb3JpZyAkYzEgQzEyMzQKIENPUFlJTkcKIENPUFlJTkcuMQogRU9GCkBAIC04Miw4ICs4NSw4IEBACiAgICAgIGdpdCB1cGRhdGUtaW5kZXggLS1hZGQgLS1yZW1vdmUgQ09QWUlORyBDT1BZSU5HLjEnCiAKIGdpdCBkaWZmLWluZGV4IC16IC1DIC0tZmluZC1jb3BpZXMtaGFyZGVyICR0cmVlID5jdXJyZW50Ci1jYXQgPmV4cGVjdGVkIDw8XEVPRgotOjEwMDY0NCAxMDA2NDQgNmZmODdjNDY2NDk4MWU0Mzk3NjI1NzkxYzhlYTNiYmI1ZjIyNzlhMyAwNjAzYjMyMzhhMDc2ZGM2YzgwMjJhZWRjNjY0OGZhNTIzYTE3MTc4IEMxMjM0CitjYXQgPmV4cGVjdGVkIDw8RU9GCis6MTAwNjQ0IDEwMDY0NCAkb3JpZyAkYzEgQzEyMzQKIENPUFlJTkcKIENPUFlJTkcuMQogRU9GCmRpZmYgLS1naXQgYS90L3Q0MDEwLWRpZmYtcGF0aHNwZWMuc2ggYi90L3Q0MDEwLWRpZmYtcGF0aHNwZWMuc2gKaW5kZXggMjgxZjhmYS4uZTVjYTM1OSAxMDA3NTUKLS0tIGEvdC90NDAxMC1kaWZmLXBhdGhzcGVjLnNoCisrKyBiL3QvdDQwMTAtZGlmZi1wYXRoc3BlYy5zaApAQCAtMTcsMTEgKzE3LDE1IEBACiAgICAgJ2VjaG8gZnJvdHogPmZpbGUwICYmCiAgICAgIG1rZGlyIHBhdGgxICYmCiAgICAgIGVjaG8gcmV6cm92ID5wYXRoMS9maWxlMSAmJgorICAgICBiZWZvcmUwPSQoZ2l0IGhhc2gtb2JqZWN0IGZpbGUwKSAmJgorICAgICBiZWZvcmUxPSQoZ2l0IGhhc2gtb2JqZWN0IHBhdGgxL2ZpbGUxKSAmJgogICAgICBnaXQgdXBkYXRlLWluZGV4IC0tYWRkIGZpbGUwIHBhdGgxL2ZpbGUxICYmCiAgICAgIHRyZWU9JChnaXQgd3JpdGUtdHJlZSkgJiYKICAgICAgZWNobyAiJHRyZWUiICYmCiAgICAgIGVjaG8gbml0Zm9sID5maWxlMCAmJgogICAgICBlY2hvIHlvbWluID5wYXRoMS9maWxlMSAmJgorICAgICBhZnRlcjA9JChnaXQgaGFzaC1vYmplY3QgZmlsZTApICYmCisgICAgIGFmdGVyMT0kKGdpdCBoYXNoLW9iamVjdCBwYXRoMS9maWxlMSkgJiYKICAgICAgZ2l0IHVwZGF0ZS1pbmRleCBmaWxlMCBwYXRoMS9maWxlMScKIAogY2F0ID5leHBlY3RlZCA8PFxFT0YKQEAgLTMxLDMyICszNSwzMiBAQAogICAgICdnaXQgZGlmZi1pbmRleCAtLWNhY2hlZCAkdHJlZSAtLSBwYXRoID5jdXJyZW50ICYmCiAgICAgIGNvbXBhcmVfZGlmZl9yYXcgY3VycmVudCBleHBlY3RlZCcKIAotY2F0ID5leHBlY3RlZCA8PFxFT0YKLToxMDA2NDQgMTAwNjQ0IDc2NjQ5OGQ5M2E0YjA2MDU3YThlNDlkMjNmNDA2OGYxMTcwZmYzOGYgMGE0MWUxMTVhYjYxYmUwMzI4YTE5YjI5ZjE4Y2RjYjQ5MzM4ZDUxNiBNCXBhdGgxL2ZpbGUxCitjYXQgPmV4cGVjdGVkIDw8RU9GCis6MTAwNjQ0IDEwMDY0NCAkYmVmb3JlMSAkYWZ0ZXIxIE0JcGF0aDEvZmlsZTEKIEVPRgogdGVzdF9leHBlY3Rfc3VjY2VzcyBcCiAgICAgJ2xpbWl0IHRvIHBhdGgxIHNob3VsZCBzaG93IHBhdGgxL2ZpbGUxJyBcCiAgICAgJ2dpdCBkaWZmLWluZGV4IC0tY2FjaGVkICR0cmVlIC0tIHBhdGgxID5jdXJyZW50ICYmCiAgICAgIGNvbXBhcmVfZGlmZl9yYXcgY3VycmVudCBleHBlY3RlZCcKIAotY2F0ID5leHBlY3RlZCA8PFxFT0YKLToxMDA2NDQgMTAwNjQ0IDc2NjQ5OGQ5M2E0YjA2MDU3YThlNDlkMjNmNDA2OGYxMTcwZmYzOGYgMGE0MWUxMTVhYjYxYmUwMzI4YTE5YjI5ZjE4Y2RjYjQ5MzM4ZDUxNiBNCXBhdGgxL2ZpbGUxCitjYXQgPmV4cGVjdGVkIDw8RU9GCis6MTAwNjQ0IDEwMDY0NCAkYmVmb3JlMSAkYWZ0ZXIxIE0JcGF0aDEvZmlsZTEKIEVPRgogdGVzdF9leHBlY3Rfc3VjY2VzcyBcCiAgICAgJ2xpbWl0IHRvIHBhdGgxLyBzaG91bGQgc2hvdyBwYXRoMS9maWxlMScgXAogICAgICdnaXQgZGlmZi1pbmRleCAtLWNhY2hlZCAkdHJlZSAtLSBwYXRoMS8gPmN1cnJlbnQgJiYKICAgICAgY29tcGFyZV9kaWZmX3JhdyBjdXJyZW50IGV4cGVjdGVkJwogCi1jYXQgPmV4cGVjdGVkIDw8XEVPRgotOjEwMDY0NCAxMDA2NDQgNzY2NDk4ZDkzYTRiMDYwNTdhOGU0OWQyM2Y0MDY4ZjExNzBmZjM4ZiAwYTQxZTExNWFiNjFiZTAzMjhhMTliMjlmMThjZGNiNDkzMzhkNTE2IE0JcGF0aDEvZmlsZTEKK2NhdCA+ZXhwZWN0ZWQgPDxFT0YKKzoxMDA2NDQgMTAwNjQ0ICRiZWZvcmUxICRhZnRlcjEgTQlwYXRoMS9maWxlMQogRU9GCiB0ZXN0X2V4cGVjdF9zdWNjZXNzIFwKICAgICAnIipmaWxlMSIgc2hvdWxkIHNob3cgcGF0aDEvZmlsZTEnIFwKICAgICAnZ2l0IGRpZmYtaW5kZXggLS1jYWNoZWQgJHRyZWUgLS0gIipmaWxlMSIgPmN1cnJlbnQgJiYKICAgICAgY29tcGFyZV9kaWZmX3JhdyBjdXJyZW50IGV4cGVjdGVkJwogCi1jYXQgPmV4cGVjdGVkIDw8XEVPRgotOjEwMDY0NCAxMDA2NDQgOGU0MDIwYmI1YThkOGM4NzNiMjVkZTE1OTMzZTc1Y2MwZmMyNzVkZiBkY2E2YjkyMzAzYmVmYzkzMDg2YWEwMjVkOTBhNWZhY2Q3ZWIyODEyIE0JZmlsZTAKK2NhdCA+ZXhwZWN0ZWQgPDxFT0YKKzoxMDA2NDQgMTAwNjQ0ICRiZWZvcmUwICRhZnRlcjAgTQlmaWxlMAogRU9GCiB0ZXN0X2V4cGVjdF9zdWNjZXNzIFwKICAgICAnbGltaXQgdG8gZmlsZTAgc2hvdWxkIHNob3cgZmlsZTAnIFwKZGlmZiAtLWdpdCBhL3QvdDQwMTEtZGlmZi1zeW1saW5rLnNoIGIvdC90NDAxMS1kaWZmLXN5bWxpbmsuc2gKaW5kZXggNWFlMTliOS4uNzE3MDM0YiAxMDA3NTUKLS0tIGEvdC90NDAxMS1kaWZmLXN5bWxpbmsuc2gKKysrIGIvdC90NDAxMS1kaWZmLXN5bWxpbmsuc2gKQEAgLTksMTEgKzksMjQgQEAKIC4gLi90ZXN0LWxpYi5zaAogLiAiJFRFU1RfRElSRUNUT1JZIi9kaWZmLWxpYi5zaAogCisjIFByaW50IHRoZSBzaG9ydCBPSUQgb2YgYSBzeW1saW5rIHdpdGggdGhlIGdpdmVuIG5hbWUuCitzeW1saW5rX29pZCAoKSB7CisJbG9jYWwgb2lkPSQocHJpbnRmICIlcyIgIiQxIiB8IGdpdCBoYXNoLW9iamVjdCAtLXN0ZGluKSAmJgorCWdpdCByZXYtcGFyc2UgLS1zaG9ydCAiJG9pZCIKK30KKworIyBQcmludCB0aGUgc2hvcnQgT0lEIG9mIHRoZSBnaXZlbiBmaWxlLgorc2hvcnRfb2lkICgpIHsKKwlsb2NhbCBvaWQ9JChnaXQgaGFzaC1vYmplY3QgIiQxIikgJiYKKwlnaXQgcmV2LXBhcnNlIC0tc2hvcnQgIiRvaWQiCit9CisKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2RpZmYgbmV3IHN5bWxpbmsgYW5kIGZpbGUnICcKLQljYXQgPmV4cGVjdGVkIDw8LVxFT0YgJiYKKwlzeW1saW5rPSQoc3ltbGlua19vaWQgeHl6enkpICYmCisJY2F0ID5leHBlY3RlZCA8PC1FT0YgJiYKIAlkaWZmIC0tZ2l0IGEvZnJvdHogYi9mcm90egogCW5ldyBmaWxlIG1vZGUgMTIwMDAwCi0JaW5kZXggMDAwMDAwMC4uN2M0NjVhZgorCWluZGV4IDAwMDAwMDAuLiRzeW1saW5rCiAJLS0tIC9kZXYvbnVsbAogCSsrKyBiL2Zyb3R6CiAJQEAgLTAsMCArMSBAQApAQCAtMjEsNyArMzQsNyBAQAogCVwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQogCWRpZmYgLS1naXQgYS9uaXRmb2wgYi9uaXRmb2wKIAluZXcgZmlsZSBtb2RlIDEwMDY0NAotCWluZGV4IDAwMDAwMDAuLjdjNDY1YWYKKwlpbmRleCAwMDAwMDAwLi4kc3ltbGluawogCS0tLSAvZGV2L251bGwKIAkrKysgYi9uaXRmb2wKIAlAQCAtMCwwICsxIEBACkBAIC00NiwxMCArNTksMTAgQEAKICcKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnZGlmZiByZW1vdmVkIHN5bWxpbmsgYW5kIGZpbGUnICcKLQljYXQgPmV4cGVjdGVkIDw8LVxFT0YgJiYKKwljYXQgPmV4cGVjdGVkIDw8LUVPRiAmJgogCWRpZmYgLS1naXQgYS9mcm90eiBiL2Zyb3R6CiAJZGVsZXRlZCBmaWxlIG1vZGUgMTIwMDAwCi0JaW5kZXggN2M0NjVhZi4uMDAwMDAwMAorCWluZGV4ICRzeW1saW5rLi4wMDAwMDAwCiAJLS0tIGEvZnJvdHoKIAkrKysgL2Rldi9udWxsCiAJQEAgLTEgKzAsMCBAQApAQCAtNTcsNyArNzAsNyBAQAogCVwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQogCWRpZmYgLS1naXQgYS9uaXRmb2wgYi9uaXRmb2wKIAlkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKLQlpbmRleCA3YzQ2NWFmLi4wMDAwMDAwCisJaW5kZXggJHN5bWxpbmsuLjAwMDAwMDAKIAktLS0gYS9uaXRmb2wKIAkrKysgL2Rldi9udWxsCiAJQEAgLTEgKzAsMCBAQApAQCAtOTAsOSArMTAzLDEwIEBACiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2RpZmYgZGlmZmVyZW50IHN5bWxpbmsgYW5kIGZpbGUnICcKLQljYXQgPmV4cGVjdGVkIDw8LVxFT0YgJiYKKwluZXc9JChzeW1saW5rX29pZCB5eHl5eikgJiYKKwljYXQgPmV4cGVjdGVkIDw8LUVPRiAmJgogCWRpZmYgLS1naXQgYS9mcm90eiBiL2Zyb3R6Ci0JaW5kZXggN2M0NjVhZi4uZGYxZGI1NCAxMjAwMDAKKwlpbmRleCAkc3ltbGluay4uJG5ldyAxMjAwMDAKIAktLS0gYS9mcm90egogCSsrKyBiL2Zyb3R6CiAJQEAgLTEgKzEgQEAKQEAgLTEwMSw3ICsxMTUsNyBAQAogCSt5eHl5egogCVwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQogCWRpZmYgLS1naXQgYS9uaXRmb2wgYi9uaXRmb2wKLQlpbmRleCA3YzQ2NWFmLi5kZjFkYjU0IDEwMDY0NAorCWluZGV4ICRzeW1saW5rLi4kbmV3IDEwMDY0NAogCS0tLSBhL25pdGZvbAogCSsrKyBiL25pdGZvbAogCUBAIC0xICsxIEBACkBAIC0xMzcsMTQgKzE1MSwxNiBAQAogJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzIFNZTUxJTktTICdzeW1saW5rcyBkbyBub3QgcmVzcGVjdCB1c2VyZGlmZiBjb25maWcgYnkgcGF0aCcgJwotCWNhdCA+ZXhwZWN0IDw8LVxFT0YgJiYKKwlmaWxlPSQoc2hvcnRfb2lkIGZpbGUuYmluKSAmJgorCWxpbms9JChzeW1saW5rX29pZCBmaWxlLmJpbikgJiYKKwljYXQgPmV4cGVjdCA8PC1FT0YgJiYKIAlkaWZmIC0tZ2l0IGEvZmlsZS5iaW4gYi9maWxlLmJpbgogCW5ldyBmaWxlIG1vZGUgMTAwNjQ0Ci0JaW5kZXggMDAwMDAwMC4uZDk1ZjNhZAorCWluZGV4IDAwMDAwMDAuLiRmaWxlCiAJQmluYXJ5IGZpbGVzIC9kZXYvbnVsbCBhbmQgYi9maWxlLmJpbiBkaWZmZXIKIAlkaWZmIC0tZ2l0IGEvbGluay5iaW4gYi9saW5rLmJpbgogCW5ldyBmaWxlIG1vZGUgMTIwMDAwCi0JaW5kZXggMDAwMDAwMC4uZGNlNDFlYworCWluZGV4IDAwMDAwMDAuLiRsaW5rCiAJLS0tIC9kZXYvbnVsbAogCSsrKyBiL2xpbmsuYmluCiAJQEAgLTAsMCArMSBAQApkaWZmIC0tZ2l0IGEvdC90NDAxMy1kaWZmLXZhcmlvdXMuc2ggYi90L3Q0MDEzLWRpZmYtdmFyaW91cy5zaAppbmRleCBhOTA1NGQyLi41YWM5NGIzIDEwMDc1NQotLS0gYS90L3Q0MDEzLWRpZmYtdmFyaW91cy5zaAorKysgYi90L3Q0MDEzLWRpZmYtdmFyaW91cy5zaApAQCAtNyw5ICs3LDYgQEAKIAogLiAuL3Rlc3QtbGliLnNoCiAKLUxGPScKLScKLQogdGVzdF9leHBlY3Rfc3VjY2VzcyBzZXR1cCAnCiAKIAlHSVRfQVVUSE9SX0RBVEU9IjIwMDYtMDYtMjYgMDA6MDA6MDAgKzAwMDAiICYmCmRpZmYgLS1naXQgYS90L3Q0MDE0LWZvcm1hdC1wYXRjaC5zaCBiL3QvdDQwMTQtZm9ybWF0LXBhdGNoLnNoCmluZGV4IGNhN2RlYmYuLjY5MjY3YjEgMTAwNzU1Ci0tLSBhL3QvdDQwMTQtZm9ybWF0LXBhdGNoLnNoCisrKyBiL3QvdDQwMTQtZm9ybWF0LXBhdGNoLnNoCkBAIC05LDcgKzksNiBAQAogLiAiJFRFU1RfRElSRUNUT1JZIi9saWItdGVybWluYWwuc2gKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyBzZXR1cCAnCi0KIAlmb3IgaSBpbiAxIDIgMyA0IDUgNiA3IDggOSAxMDsgZG8gZWNobyAiJGkiOyBkb25lID5maWxlICYmCiAJY2F0IGZpbGUgPmVsaWYgJiYKIAlnaXQgYWRkIGZpbGUgZWxpZiAmJgpAQCAtMzQsNyArMzMsOCBAQAogCWdpdCBjb21taXQgLW0gIlNpZGUgY2hhbmdlcyAjMyB3aXRoIFxcbiBiYWNrc2xhc2gtbiBpbiBpdC4iICYmCiAKIAlnaXQgY2hlY2tvdXQgbWFzdGVyICYmCi0JZ2l0IGRpZmYtdHJlZSAtcCBDMiB8IGdpdCBhcHBseSAtLWluZGV4ICYmCisJZ2l0IGRpZmYtdHJlZSAtcCBDMiA+cGF0Y2ggJiYKKwlnaXQgYXBwbHkgLS1pbmRleCA8cGF0Y2ggJiYKIAl0ZXN0X3RpY2sgJiYKIAlnaXQgY29tbWl0IC1tICJNYXN0ZXIgYWNjZXB0cyBtb3JhbCBlcXVpdmFsZW50IG9mICMyIiAmJgogCkBAIC01OSwzMyArNTksMjggQEAKIAlnaXQgY2hlY2tvdXQgbWFzdGVyCiAnCiAKLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgImZvcm1hdC1wYXRjaCAtLWlnbm9yZS1pZi1pbi11cHN0cmVhbSIgJwotCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdmb3JtYXQtcGF0Y2ggLS1pZ25vcmUtaWYtaW4tdXBzdHJlYW0nICcKIAlnaXQgZm9ybWF0LXBhdGNoIC0tc3Rkb3V0IG1hc3Rlci4uc2lkZSA+cGF0Y2gwICYmCi0JY250PSQoZ3JlcCAiXkZyb20gIiBwYXRjaDAgfCB3YyAtbCkgJiYKLQl0ZXN0ICRjbnQgPSAzCi0KKwlncmVwICJeRnJvbSAiIHBhdGNoMCA+ZnJvbTAgJiYKKwl0ZXN0X2xpbmVfY291bnQgPSAzIGZyb20wCiAnCiAKLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgImZvcm1hdC1wYXRjaCAtLWlnbm9yZS1pZi1pbi11cHN0cmVhbSIgJwotCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdmb3JtYXQtcGF0Y2ggLS1pZ25vcmUtaWYtaW4tdXBzdHJlYW0nICcKIAlnaXQgZm9ybWF0LXBhdGNoIC0tc3Rkb3V0IFwKIAkJLS1pZ25vcmUtaWYtaW4tdXBzdHJlYW0gbWFzdGVyLi5zaWRlID5wYXRjaDEgJiYKLQljbnQ9JChncmVwICJeRnJvbSAiIHBhdGNoMSB8IHdjIC1sKSAmJgotCXRlc3QgJGNudCA9IDIKLQorCWdyZXAgIl5Gcm9tICIgcGF0Y2gxID5mcm9tMSAmJgorCXRlc3RfbGluZV9jb3VudCA9IDIgZnJvbTEKICcKIAotdGVzdF9leHBlY3Rfc3VjY2VzcyAiZm9ybWF0LXBhdGNoIC0taWdub3JlLWlmLWluLXVwc3RyZWFtIGhhbmRsZXMgdGFncyIgJwordGVzdF9leHBlY3Rfc3VjY2VzcyAnZm9ybWF0LXBhdGNoIC0taWdub3JlLWlmLWluLXVwc3RyZWFtIGhhbmRsZXMgdGFncycgJwogCWdpdCB0YWcgLWEgdjEgLW0gdGFnIHNpZGUgJiYKIAlnaXQgdGFnIC1hIHYyIC1tIHRhZyBtYXN0ZXIgJiYKIAlnaXQgZm9ybWF0LXBhdGNoIC0tc3Rkb3V0IC0taWdub3JlLWlmLWluLXVwc3RyZWFtIHYyLi52MSA+cGF0Y2gxICYmCi0JY250PSQoZ3JlcCAiXkZyb20gIiBwYXRjaDEgfCB3YyAtbCkgJiYKLQl0ZXN0ICRjbnQgPSAyCisJZ3JlcCAiXkZyb20gIiBwYXRjaDEgPmZyb20xICYmCisJdGVzdF9saW5lX2NvdW50ID0gMiBmcm9tMQogJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICJmb3JtYXQtcGF0Y2ggZG9lc24ndCBjb25zaWRlciBtZXJnZSBjb21taXRzIiAnCi0KIAlnaXQgY2hlY2tvdXQgLWIgc2xhdmUgbWFzdGVyICYmCiAJZWNobyAiQW5vdGhlciBsaW5lIiA+PmZpbGUgJiYKIAl0ZXN0X3RpY2sgJiYKQEAgLTk2LDE0OCArOTEsMTM4IEBACiAJZ2l0IGNoZWNrb3V0IC1iIG1lcmdlciBtYXN0ZXIgJiYKIAl0ZXN0X3RpY2sgJiYKIAlnaXQgbWVyZ2UgLS1uby1mZiBzbGF2ZSAmJgotCWNudD0kKGdpdCBmb3JtYXQtcGF0Y2ggLTMgLS1zdGRvdXQgfCBncmVwICJeRnJvbSAiIHwgd2MgLWwpICYmCi0JdGVzdCAkY250ID0gMworCWdpdCBmb3JtYXQtcGF0Y2ggLTMgLS1zdGRvdXQgPnBhdGNoICYmCisJZ3JlcCAiXkZyb20gIiBwYXRjaCA+ZnJvbSAmJgorCXRlc3RfbGluZV9jb3VudCA9IDMgZnJvbQogJwogCi10ZXN0X2V4cGVjdF9zdWNjZXNzICJmb3JtYXQtcGF0Y2ggcmVzdWx0IGFwcGxpZXMiICcKLQordGVzdF9leHBlY3Rfc3VjY2VzcyAnZm9ybWF0LXBhdGNoIHJlc3VsdCBhcHBsaWVzJyAnCiAJZ2l0IGNoZWNrb3V0IC1iIHJlYnVpbGQtMCBtYXN0ZXIgJiYKIAlnaXQgYW0gLTMgcGF0Y2gwICYmCi0JY250PSQoZ2l0IHJldi1saXN0IG1hc3Rlci4uIHwgd2MgLWwpICYmCi0JdGVzdCAkY250ID0gMgorCWdpdCByZXYtbGlzdCBtYXN0ZXIuLiA+bGlzdCAmJgorCXRlc3RfbGluZV9jb3VudCA9IDIgbGlzdAogJwogCi10ZXN0X2V4cGVjdF9zdWNjZXNzICJmb3JtYXQtcGF0Y2ggLS1pZ25vcmUtaWYtaW4tdXBzdHJlYW0gcmVzdWx0IGFwcGxpZXMiICcKLQordGVzdF9leHBlY3Rfc3VjY2VzcyAnZm9ybWF0LXBhdGNoIC0taWdub3JlLWlmLWluLXVwc3RyZWFtIHJlc3VsdCBhcHBsaWVzJyAnCiAJZ2l0IGNoZWNrb3V0IC1iIHJlYnVpbGQtMSBtYXN0ZXIgJiYKIAlnaXQgYW0gLTMgcGF0Y2gxICYmCi0JY250PSQoZ2l0IHJldi1saXN0IG1hc3Rlci4uIHwgd2MgLWwpICYmCi0JdGVzdCAkY250ID0gMgorCWdpdCByZXYtbGlzdCBtYXN0ZXIuLiA+bGlzdCAmJgorCXRlc3RfbGluZV9jb3VudCA9IDIgbGlzdAogJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdjb21taXQgZGlkIG5vdCBzY3JldyB1cCB0aGUgbG9nIG1lc3NhZ2UnICcKLQotCWdpdCBjYXQtZmlsZSBjb21taXQgc2lkZSB8IGdyZXAgIl5TaWRlIC4qIHdpdGggLiogYmFja3NsYXNoLW4iCi0KKwlnaXQgY2F0LWZpbGUgY29tbWl0IHNpZGUgPmFjdHVhbCAmJgorCWdyZXAgIl5TaWRlIC4qIHdpdGggLiogYmFja3NsYXNoLW4iIGFjdHVhbAogJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdmb3JtYXQtcGF0Y2ggZGlkIG5vdCBzY3JldyB1cCB0aGUgbG9nIG1lc3NhZ2UnICcKLQogCWdyZXAgIl5TdWJqZWN0OiAuKlNpZGUgY2hhbmdlcyAjMyB3aXRoIC4qIGJhY2tzbGFzaC1uIiBwYXRjaDAgJiYKIAlncmVwICJeU3ViamVjdDogLipTaWRlIGNoYW5nZXMgIzMgd2l0aCAuKiBiYWNrc2xhc2gtbiIgcGF0Y2gxCi0KICcKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAncmVwbGF5IGRpZCBub3Qgc2NyZXcgdXAgdGhlIGxvZyBtZXNzYWdlJyAnCi0KLQlnaXQgY2F0LWZpbGUgY29tbWl0IHJlYnVpbGQtMSB8IGdyZXAgIl5TaWRlIC4qIHdpdGggLiogYmFja3NsYXNoLW4iCi0KKwlnaXQgY2F0LWZpbGUgY29tbWl0IHJlYnVpbGQtMSA+YWN0dWFsICYmCisJZ3JlcCAiXlNpZGUgLiogd2l0aCAuKiBiYWNrc2xhc2gtbiIgYWN0dWFsCiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2V4dHJhIGhlYWRlcnMnICcKLQogCWdpdCBjb25maWcgZm9ybWF0LmhlYWRlcnMgIlRvOiBSIEUgQ2lwaWVudCA8cmNpcGllbnRAZXhhbXBsZS5jb20+CiAiICYmCiAJZ2l0IGNvbmZpZyAtLWFkZCBmb3JtYXQuaGVhZGVycyAiQ2M6IFMgRSBDaXBpZW50IDxzY2lwaWVudEBleGFtcGxlLmNvbT4KICIgJiYKLQlnaXQgZm9ybWF0LXBhdGNoIC0tc3Rkb3V0IG1hc3Rlci4uc2lkZSA+IHBhdGNoMiAmJgotCXNlZCAtZSAiL15cJC9xIiBwYXRjaDIgPiBoZHJzMiAmJgorCWdpdCBmb3JtYXQtcGF0Y2ggLS1zdGRvdXQgbWFzdGVyLi5zaWRlID5wYXRjaDIgJiYKKwlzZWQgLWUgIi9eXCQvcSIgcGF0Y2gyID5oZHJzMiAmJgogCWdyZXAgIl5UbzogUiBFIENpcGllbnQgPHJjaXBpZW50QGV4YW1wbGUuY29tPlwkIiBoZHJzMiAmJgogCWdyZXAgIl5DYzogUyBFIENpcGllbnQgPHNjaXBpZW50QGV4YW1wbGUuY29tPlwkIiBoZHJzMgotCiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2V4dHJhIGhlYWRlcnMgd2l0aG91dCBuZXdsaW5lcycgJwotCiAJZ2l0IGNvbmZpZyAtLXJlcGxhY2UtYWxsIGZvcm1hdC5oZWFkZXJzICJUbzogUiBFIENpcGllbnQgPHJjaXBpZW50QGV4YW1wbGUuY29tPiIgJiYKIAlnaXQgY29uZmlnIC0tYWRkIGZvcm1hdC5oZWFkZXJzICJDYzogUyBFIENpcGllbnQgPHNjaXBpZW50QGV4YW1wbGUuY29tPiIgJiYKIAlnaXQgZm9ybWF0LXBhdGNoIC0tc3Rkb3V0IG1hc3Rlci4uc2lkZSA+cGF0Y2gzICYmCi0Jc2VkIC1lICIvXlwkL3EiIHBhdGNoMyA+IGhkcnMzICYmCisJc2VkIC1lICIvXlwkL3EiIHBhdGNoMyA+aGRyczMgJiYKIAlncmVwICJeVG86IFIgRSBDaXBpZW50IDxyY2lwaWVudEBleGFtcGxlLmNvbT5cJCIgaGRyczMgJiYKIAlncmVwICJeQ2M6IFMgRSBDaXBpZW50IDxzY2lwaWVudEBleGFtcGxlLmNvbT5cJCIgaGRyczMKLQogJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdleHRyYSBoZWFkZXJzIHdpdGggbXVsdGlwbGUgVG86cycgJwotCiAJZ2l0IGNvbmZpZyAtLXJlcGxhY2UtYWxsIGZvcm1hdC5oZWFkZXJzICJUbzogUiBFIENpcGllbnQgPHJjaXBpZW50QGV4YW1wbGUuY29tPiIgJiYKIAlnaXQgY29uZmlnIC0tYWRkIGZvcm1hdC5oZWFkZXJzICJUbzogUyBFIENpcGllbnQgPHNjaXBpZW50QGV4YW1wbGUuY29tPiIgJiYKLQlnaXQgZm9ybWF0LXBhdGNoIC0tc3Rkb3V0IG1hc3Rlci4uc2lkZSA+IHBhdGNoNCAmJgotCXNlZCAtZSAiL15cJC9xIiBwYXRjaDQgPiBoZHJzNCAmJgorCWdpdCBmb3JtYXQtcGF0Y2ggLS1zdGRvdXQgbWFzdGVyLi5zaWRlID5wYXRjaDQgJiYKKwlzZWQgLWUgIi9eXCQvcSIgcGF0Y2g0ID5oZHJzNCAmJgogCWdyZXAgIl5UbzogUiBFIENpcGllbnQgPHJjaXBpZW50QGV4YW1wbGUuY29tPixcJCIgaGRyczQgJiYKIAlncmVwICJeICpTIEUgQ2lwaWVudCA8c2NpcGllbnRAZXhhbXBsZS5jb20+XCQiIGhkcnM0CiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2FkZGl0aW9uYWwgY29tbWFuZCBsaW5lIGNjIChhc2NpaSknICcKLQogCWdpdCBjb25maWcgLS1yZXBsYWNlLWFsbCBmb3JtYXQuaGVhZGVycyAiQ2M6IFIgRSBDaXBpZW50IDxyY2lwaWVudEBleGFtcGxlLmNvbT4iICYmCi0JZ2l0IGZvcm1hdC1wYXRjaCAtLWNjPSJTIEUgQ2lwaWVudCA8c2NpcGllbnRAZXhhbXBsZS5jb20+IiAtLXN0ZG91dCBtYXN0ZXIuLnNpZGUgfCBzZWQgLWUgIi9eXCQvcSIgPnBhdGNoNSAmJgotCWdyZXAgIl5DYzogUiBFIENpcGllbnQgPHJjaXBpZW50QGV4YW1wbGUuY29tPixcJCIgcGF0Y2g1ICYmCi0JZ3JlcCAiXiAqUyBFIENpcGllbnQgPHNjaXBpZW50QGV4YW1wbGUuY29tPlwkIiBwYXRjaDUKKwlnaXQgZm9ybWF0LXBhdGNoIC0tY2M9IlMgRSBDaXBpZW50IDxzY2lwaWVudEBleGFtcGxlLmNvbT4iIC0tc3Rkb3V0IG1hc3Rlci4uc2lkZSA+cGF0Y2g1ICYmCisJc2VkIC1lICIvXlwkL3EiIHBhdGNoNSA+aGRyczUgJiYKKwlncmVwICJeQ2M6IFIgRSBDaXBpZW50IDxyY2lwaWVudEBleGFtcGxlLmNvbT4sXCQiIGhkcnM1ICYmCisJZ3JlcCAiXiAqUyBFIENpcGllbnQgPHNjaXBpZW50QGV4YW1wbGUuY29tPlwkIiBoZHJzNQogJwogCiB0ZXN0X2V4cGVjdF9mYWlsdXJlICdhZGRpdGlvbmFsIGNvbW1hbmQgbGluZSBjYyAocmZjODIyKScgJwotCiAJZ2l0IGNvbmZpZyAtLXJlcGxhY2UtYWxsIGZvcm1hdC5oZWFkZXJzICJDYzogUiBFIENpcGllbnQgPHJjaXBpZW50QGV4YW1wbGUuY29tPiIgJiYKLQlnaXQgZm9ybWF0LXBhdGNoIC0tY2M9IlMuIEUuIENpcGllbnQgPHNjaXBpZW50QGV4YW1wbGUuY29tPiIgLS1zdGRvdXQgbWFzdGVyLi5zaWRlIHwgc2VkIC1lICIvXlwkL3EiID5wYXRjaDUgJiYKLQlncmVwICJeQ2M6IFIgRSBDaXBpZW50IDxyY2lwaWVudEBleGFtcGxlLmNvbT4sXCQiIHBhdGNoNSAmJgotCWdyZXAgIl4gKlwiUy4gRS4gQ2lwaWVudFwiIDxzY2lwaWVudEBleGFtcGxlLmNvbT5cJCIgcGF0Y2g1CisJZ2l0IGZvcm1hdC1wYXRjaCAtLWNjPSJTLiBFLiBDaXBpZW50IDxzY2lwaWVudEBleGFtcGxlLmNvbT4iIC0tc3Rkb3V0IG1hc3Rlci4uc2lkZSA+cGF0Y2g1ICYmCisJc2VkIC1lICIvXlwkL3EiIHBhdGNoNSA+aGRyczUgJiYKKwlncmVwICJeQ2M6IFIgRSBDaXBpZW50IDxyY2lwaWVudEBleGFtcGxlLmNvbT4sXCQiIGhkcnM1ICYmCisJZ3JlcCAiXiAqXCJTLiBFLiBDaXBpZW50XCIgPHNjaXBpZW50QGV4YW1wbGUuY29tPlwkIiBoZHJzNQogJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdjb21tYW5kIGxpbmUgaGVhZGVycycgJwotCiAJZ2l0IGNvbmZpZyAtLXVuc2V0LWFsbCBmb3JtYXQuaGVhZGVycyAmJgotCWdpdCBmb3JtYXQtcGF0Y2ggLS1hZGQtaGVhZGVyPSJDYzogUiBFIENpcGllbnQgPHJjaXBpZW50QGV4YW1wbGUuY29tPiIgLS1zdGRvdXQgbWFzdGVyLi5zaWRlIHwgc2VkIC1lICIvXlwkL3EiID5wYXRjaDYgJiYKLQlncmVwICJeQ2M6IFIgRSBDaXBpZW50IDxyY2lwaWVudEBleGFtcGxlLmNvbT5cJCIgcGF0Y2g2CisJZ2l0IGZvcm1hdC1wYXRjaCAtLWFkZC1oZWFkZXI9IkNjOiBSIEUgQ2lwaWVudCA8cmNpcGllbnRAZXhhbXBsZS5jb20+IiAtLXN0ZG91dCBtYXN0ZXIuLnNpZGUgPnBhdGNoNiAmJgorCXNlZCAtZSAiL15cJC9xIiBwYXRjaDYgPmhkcnM2ICYmCisJZ3JlcCAiXkNjOiBSIEUgQ2lwaWVudCA8cmNpcGllbnRAZXhhbXBsZS5jb20+XCQiIGhkcnM2CiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2NvbmZpZ3VyYXRpb24gaGVhZGVycyBhbmQgY29tbWFuZCBsaW5lIGhlYWRlcnMnICcKLQogCWdpdCBjb25maWcgLS1yZXBsYWNlLWFsbCBmb3JtYXQuaGVhZGVycyAiQ2M6IFIgRSBDaXBpZW50IDxyY2lwaWVudEBleGFtcGxlLmNvbT4iICYmCi0JZ2l0IGZvcm1hdC1wYXRjaCAtLWFkZC1oZWFkZXI9IkNjOiBTIEUgQ2lwaWVudCA8c2NpcGllbnRAZXhhbXBsZS5jb20+IiAtLXN0ZG91dCBtYXN0ZXIuLnNpZGUgfCBzZWQgLWUgIi9eXCQvcSIgPnBhdGNoNyAmJgotCWdyZXAgIl5DYzogUiBFIENpcGllbnQgPHJjaXBpZW50QGV4YW1wbGUuY29tPixcJCIgcGF0Y2g3ICYmCi0JZ3JlcCAiXiAqUyBFIENpcGllbnQgPHNjaXBpZW50QGV4YW1wbGUuY29tPlwkIiBwYXRjaDcKKwlnaXQgZm9ybWF0LXBhdGNoIC0tYWRkLWhlYWRlcj0iQ2M6IFMgRSBDaXBpZW50IDxzY2lwaWVudEBleGFtcGxlLmNvbT4iIC0tc3Rkb3V0IG1hc3Rlci4uc2lkZSA+cGF0Y2g3ICYmCisJc2VkIC1lICIvXlwkL3EiIHBhdGNoNyA+aGRyczcgJiYKKwlncmVwICJeQ2M6IFIgRSBDaXBpZW50IDxyY2lwaWVudEBleGFtcGxlLmNvbT4sXCQiIGhkcnM3ICYmCisJZ3JlcCAiXiAqUyBFIENpcGllbnQgPHNjaXBpZW50QGV4YW1wbGUuY29tPlwkIiBoZHJzNwogJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdjb21tYW5kIGxpbmUgVG86IGhlYWRlciAoYXNjaWkpJyAnCi0KIAlnaXQgY29uZmlnIC0tdW5zZXQtYWxsIGZvcm1hdC5oZWFkZXJzICYmCi0JZ2l0IGZvcm1hdC1wYXRjaCAtLXRvPSJSIEUgQ2lwaWVudCA8cmNpcGllbnRAZXhhbXBsZS5jb20+IiAtLXN0ZG91dCBtYXN0ZXIuLnNpZGUgfCBzZWQgLWUgIi9eXCQvcSIgPnBhdGNoOCAmJgotCWdyZXAgIl5UbzogUiBFIENpcGllbnQgPHJjaXBpZW50QGV4YW1wbGUuY29tPlwkIiBwYXRjaDgKKwlnaXQgZm9ybWF0LXBhdGNoIC0tdG89IlIgRSBDaXBpZW50IDxyY2lwaWVudEBleGFtcGxlLmNvbT4iIC0tc3Rkb3V0IG1hc3Rlci4uc2lkZSA+cGF0Y2g4ICYmCisJc2VkIC1lICIvXlwkL3EiIHBhdGNoOCA+aGRyczggJiYKKwlncmVwICJeVG86IFIgRSBDaXBpZW50IDxyY2lwaWVudEBleGFtcGxlLmNvbT5cJCIgaGRyczgKICcKIAogdGVzdF9leHBlY3RfZmFpbHVyZSAnY29tbWFuZCBsaW5lIFRvOiBoZWFkZXIgKHJmYzgyMiknICcKLQotCWdpdCBmb3JtYXQtcGF0Y2ggLS10bz0iUi4gRS4gQ2lwaWVudCA8cmNpcGllbnRAZXhhbXBsZS5jb20+IiAtLXN0ZG91dCBtYXN0ZXIuLnNpZGUgfCBzZWQgLWUgIi9eXCQvcSIgPnBhdGNoOCAmJgotCWdyZXAgIl5UbzogXCJSLiBFLiBDaXBpZW50XCIgPHJjaXBpZW50QGV4YW1wbGUuY29tPlwkIiBwYXRjaDgKKwlnaXQgZm9ybWF0LXBhdGNoIC0tdG89IlIuIEUuIENpcGllbnQgPHJjaXBpZW50QGV4YW1wbGUuY29tPiIgLS1zdGRvdXQgbWFzdGVyLi5zaWRlID5wYXRjaDggJiYKKwlzZWQgLWUgIi9eXCQvcSIgcGF0Y2g4ID5oZHJzOCAmJgorCWdyZXAgIl5UbzogXCJSLiBFLiBDaXBpZW50XCIgPHJjaXBpZW50QGV4YW1wbGUuY29tPlwkIiBoZHJzOAogJwogCiB0ZXN0X2V4cGVjdF9mYWlsdXJlICdjb21tYW5kIGxpbmUgVG86IGhlYWRlciAocmZjMjA0NyknICcKLQotCWdpdCBmb3JtYXQtcGF0Y2ggLS10bz0iUiDDhCBDaXBpZW50IDxyY2lwaWVudEBleGFtcGxlLmNvbT4iIC0tc3Rkb3V0IG1hc3Rlci4uc2lkZSB8IHNlZCAtZSAiL15cJC9xIiA+cGF0Y2g4ICYmCi0JZ3JlcCAiXlRvOiA9P1VURi04P3E/Uj0yMD1DMz04ND0yMENpcGllbnQ/PSA8cmNpcGllbnRAZXhhbXBsZS5jb20+XCQiIHBhdGNoOAorCWdpdCBmb3JtYXQtcGF0Y2ggLS10bz0iUiDDhCBDaXBpZW50IDxyY2lwaWVudEBleGFtcGxlLmNvbT4iIC0tc3Rkb3V0IG1hc3Rlci4uc2lkZSA+cGF0Y2g4ICYmCisJc2VkIC1lICIvXlwkL3EiIHBhdGNoOCA+aGRyczggJiYKKwlncmVwICJeVG86ID0/VVRGLTg/cT9SPTIwPUMzPTg0PTIwQ2lwaWVudD89IDxyY2lwaWVudEBleGFtcGxlLmNvbT5cJCIgaGRyczgKICcKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnY29uZmlndXJhdGlvbiBUbzogaGVhZGVyIChhc2NpaSknICcKLQogCWdpdCBjb25maWcgZm9ybWF0LnRvICJSIEUgQ2lwaWVudCA8cmNpcGllbnRAZXhhbXBsZS5jb20+IiAmJgotCWdpdCBmb3JtYXQtcGF0Y2ggLS1zdGRvdXQgbWFzdGVyLi5zaWRlIHwgc2VkIC1lICIvXlwkL3EiID5wYXRjaDkgJiYKLQlncmVwICJeVG86IFIgRSBDaXBpZW50IDxyY2lwaWVudEBleGFtcGxlLmNvbT5cJCIgcGF0Y2g5CisJZ2l0IGZvcm1hdC1wYXRjaCAtLXN0ZG91dCBtYXN0ZXIuLnNpZGUgPnBhdGNoOSAmJgorCXNlZCAtZSAiL15cJC9xIiBwYXRjaDkgPmhkcnM5ICYmCisJZ3JlcCAiXlRvOiBSIEUgQ2lwaWVudCA8cmNpcGllbnRAZXhhbXBsZS5jb20+XCQiIGhkcnM5CiAnCiAKIHRlc3RfZXhwZWN0X2ZhaWx1cmUgJ2NvbmZpZ3VyYXRpb24gVG86IGhlYWRlciAocmZjODIyKScgJwotCiAJZ2l0IGNvbmZpZyBmb3JtYXQudG8gIlIuIEUuIENpcGllbnQgPHJjaXBpZW50QGV4YW1wbGUuY29tPiIgJiYKLQlnaXQgZm9ybWF0LXBhdGNoIC0tc3Rkb3V0IG1hc3Rlci4uc2lkZSB8IHNlZCAtZSAiL15cJC9xIiA+cGF0Y2g5ICYmCi0JZ3JlcCAiXlRvOiBcIlIuIEUuIENpcGllbnRcIiA8cmNpcGllbnRAZXhhbXBsZS5jb20+XCQiIHBhdGNoOQorCWdpdCBmb3JtYXQtcGF0Y2ggLS1zdGRvdXQgbWFzdGVyLi5zaWRlID5wYXRjaDkgJiYKKwlzZWQgLWUgIi9eXCQvcSIgcGF0Y2g5ID5oZHJzOSAmJgorCWdyZXAgIl5UbzogXCJSLiBFLiBDaXBpZW50XCIgPHJjaXBpZW50QGV4YW1wbGUuY29tPlwkIiBoZHJzOQogJwogCiB0ZXN0X2V4cGVjdF9mYWlsdXJlICdjb25maWd1cmF0aW9uIFRvOiBoZWFkZXIgKHJmYzIwNDcpJyAnCi0KIAlnaXQgY29uZmlnIGZvcm1hdC50byAiUiDDhCBDaXBpZW50IDxyY2lwaWVudEBleGFtcGxlLmNvbT4iICYmCi0JZ2l0IGZvcm1hdC1wYXRjaCAtLXN0ZG91dCBtYXN0ZXIuLnNpZGUgfCBzZWQgLWUgIi9eXCQvcSIgPnBhdGNoOSAmJgotCWdyZXAgIl5UbzogPT9VVEYtOD9xP1I9MjA9QzM9ODQ9MjBDaXBpZW50Pz0gPHJjaXBpZW50QGV4YW1wbGUuY29tPlwkIiBwYXRjaDkKKwlnaXQgZm9ybWF0LXBhdGNoIC0tc3Rkb3V0IG1hc3Rlci4uc2lkZSA+cGF0Y2g5ICYmCisJc2VkIC1lICIvXlwkL3EiIHBhdGNoOSA+aGRyczkgJiYKKwlncmVwICJeVG86ID0/VVRGLTg/cT9SPTIwPUMzPTg0PTIwQ2lwaWVudD89IDxyY2lwaWVudEBleGFtcGxlLmNvbT5cJCIgaGRyczkKICcKIAogIyBjaGVja19wYXRjaCA8cGF0Y2g+OiBWZXJpZnkgdGhhdCA8cGF0Y2g+IGxvb2tzIGxpa2UgYSBoYWxmLXNhbmUKQEAgLTI0OSw4OSArMjM0LDc5IEBACiB9CiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2Zvcm1hdC5mcm9tPWZhbHNlJyAnCi0KLQlnaXQgLWMgZm9ybWF0LmZyb209ZmFsc2UgZm9ybWF0LXBhdGNoIC0tc3Rkb3V0IG1hc3Rlci4uc2lkZSB8Ci0Jc2VkIC1lICIvXlwkL3EiID5wYXRjaCAmJgorCWdpdCAtYyBmb3JtYXQuZnJvbT1mYWxzZSBmb3JtYXQtcGF0Y2ggLS1zdGRvdXQgbWFzdGVyLi5zaWRlID5wYXRjaCAmJgorCXNlZCAtZSAiL15cJC9xIiBwYXRjaCA+aGRycyAmJgogCWNoZWNrX3BhdGNoIHBhdGNoICYmCi0JISBncmVwICJeRnJvbTogQyBPIE1pdHRlciA8Y29tbWl0dGVyQGV4YW1wbGUuY29tPlwkIiBwYXRjaAorCSEgZ3JlcCAiXkZyb206IEMgTyBNaXR0ZXIgPGNvbW1pdHRlckBleGFtcGxlLmNvbT5cJCIgaGRycwogJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdmb3JtYXQuZnJvbT10cnVlJyAnCi0KLQlnaXQgLWMgZm9ybWF0LmZyb209dHJ1ZSBmb3JtYXQtcGF0Y2ggLS1zdGRvdXQgbWFzdGVyLi5zaWRlIHwKLQlzZWQgLWUgIi9eXCQvcSIgPnBhdGNoICYmCi0JY2hlY2tfcGF0Y2ggcGF0Y2ggJiYKLQlncmVwICJeRnJvbTogQyBPIE1pdHRlciA8Y29tbWl0dGVyQGV4YW1wbGUuY29tPlwkIiBwYXRjaAorCWdpdCAtYyBmb3JtYXQuZnJvbT10cnVlIGZvcm1hdC1wYXRjaCAtLXN0ZG91dCBtYXN0ZXIuLnNpZGUgPnBhdGNoICYmCisJc2VkIC1lICIvXlwkL3EiIHBhdGNoID5oZHJzICYmCisJY2hlY2tfcGF0Y2ggaGRycyAmJgorCWdyZXAgIl5Gcm9tOiBDIE8gTWl0dGVyIDxjb21taXR0ZXJAZXhhbXBsZS5jb20+XCQiIGhkcnMKICcKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnZm9ybWF0LmZyb20gd2l0aCBhZGRyZXNzJyAnCi0KLQlnaXQgLWMgZm9ybWF0LmZyb209IkYgUiBPbSA8ZnJvbUBleGFtcGxlLmNvbT4iIGZvcm1hdC1wYXRjaCAtLXN0ZG91dCBtYXN0ZXIuLnNpZGUgfAotCXNlZCAtZSAiL15cJC9xIiA+cGF0Y2ggJiYKLQljaGVja19wYXRjaCBwYXRjaCAmJgotCWdyZXAgIl5Gcm9tOiBGIFIgT20gPGZyb21AZXhhbXBsZS5jb20+XCQiIHBhdGNoCisJZ2l0IC1jIGZvcm1hdC5mcm9tPSJGIFIgT20gPGZyb21AZXhhbXBsZS5jb20+IiBmb3JtYXQtcGF0Y2ggLS1zdGRvdXQgbWFzdGVyLi5zaWRlID5wYXRjaCAmJgorCXNlZCAtZSAiL15cJC9xIiBwYXRjaCA+aGRycyAmJgorCWNoZWNrX3BhdGNoIGhkcnMgJiYKKwlncmVwICJeRnJvbTogRiBSIE9tIDxmcm9tQGV4YW1wbGUuY29tPlwkIiBoZHJzCiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJy0tbm8tZnJvbSBvdmVycmlkZXMgZm9ybWF0LmZyb20nICcKLQotCWdpdCAtYyBmb3JtYXQuZnJvbT0iRiBSIE9tIDxmcm9tQGV4YW1wbGUuY29tPiIgZm9ybWF0LXBhdGNoIC0tbm8tZnJvbSAtLXN0ZG91dCBtYXN0ZXIuLnNpZGUgfAotCXNlZCAtZSAiL15cJC9xIiA+cGF0Y2ggJiYKLQljaGVja19wYXRjaCBwYXRjaCAmJgotCSEgZ3JlcCAiXkZyb206IEYgUiBPbSA8ZnJvbUBleGFtcGxlLmNvbT5cJCIgcGF0Y2gKKwlnaXQgLWMgZm9ybWF0LmZyb209IkYgUiBPbSA8ZnJvbUBleGFtcGxlLmNvbT4iIGZvcm1hdC1wYXRjaCAtLW5vLWZyb20gLS1zdGRvdXQgbWFzdGVyLi5zaWRlID5wYXRjaCAmJgorCXNlZCAtZSAiL15cJC9xIiBwYXRjaCA+aGRycyAmJgorCWNoZWNrX3BhdGNoIGhkcnMgJiYKKwkhIGdyZXAgIl5Gcm9tOiBGIFIgT20gPGZyb21AZXhhbXBsZS5jb20+XCQiIGhkcnMKICcKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnLS1mcm9tIG92ZXJyaWRlcyBmb3JtYXQuZnJvbScgJwotCi0JZ2l0IC1jIGZvcm1hdC5mcm9tPSJGIFIgT20gPGZyb21AZXhhbXBsZS5jb20+IiBmb3JtYXQtcGF0Y2ggLS1mcm9tIC0tc3Rkb3V0IG1hc3Rlci4uc2lkZSB8Ci0Jc2VkIC1lICIvXlwkL3EiID5wYXRjaCAmJgotCWNoZWNrX3BhdGNoIHBhdGNoICYmCi0JISBncmVwICJeRnJvbTogRiBSIE9tIDxmcm9tQGV4YW1wbGUuY29tPlwkIiBwYXRjaAorCWdpdCAtYyBmb3JtYXQuZnJvbT0iRiBSIE9tIDxmcm9tQGV4YW1wbGUuY29tPiIgZm9ybWF0LXBhdGNoIC0tZnJvbSAtLXN0ZG91dCBtYXN0ZXIuLnNpZGUgPnBhdGNoICYmCisJc2VkIC1lICIvXlwkL3EiIHBhdGNoID5oZHJzICYmCisJY2hlY2tfcGF0Y2ggaGRycyAmJgorCSEgZ3JlcCAiXkZyb206IEYgUiBPbSA8ZnJvbUBleGFtcGxlLmNvbT5cJCIgaGRycwogJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICctLW5vLXRvIG92ZXJyaWRlcyBjb25maWcudG8nICcKLQogCWdpdCBjb25maWcgLS1yZXBsYWNlLWFsbCBmb3JtYXQudG8gXAogCQkiUiBFIENpcGllbnQgPHJjaXBpZW50QGV4YW1wbGUuY29tPiIgJiYKLQlnaXQgZm9ybWF0LXBhdGNoIC0tbm8tdG8gLS1zdGRvdXQgbWFzdGVyLi5zaWRlIHwKLQlzZWQgLWUgIi9eXCQvcSIgPnBhdGNoMTAgJiYKLQljaGVja19wYXRjaCBwYXRjaDEwICYmCi0JISBncmVwICJeVG86IFIgRSBDaXBpZW50IDxyY2lwaWVudEBleGFtcGxlLmNvbT5cJCIgcGF0Y2gxMAorCWdpdCBmb3JtYXQtcGF0Y2ggLS1uby10byAtLXN0ZG91dCBtYXN0ZXIuLnNpZGUgPnBhdGNoMTAgJiYKKwlzZWQgLWUgIi9eXCQvcSIgcGF0Y2gxMCA+aGRyczEwICYmCisJY2hlY2tfcGF0Y2ggaGRyczEwICYmCisJISBncmVwICJeVG86IFIgRSBDaXBpZW50IDxyY2lwaWVudEBleGFtcGxlLmNvbT5cJCIgaGRyczEwCiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJy0tbm8tdG8gYW5kIC0tdG8gcmVwbGFjZXMgY29uZmlnLnRvJyAnCi0KIAlnaXQgY29uZmlnIC0tcmVwbGFjZS1hbGwgZm9ybWF0LnRvIFwKIAkJIlNvbWVvbmUgPHNvbWVvbmVAb3V0LnRoZXJlPiIgJiYKIAlnaXQgZm9ybWF0LXBhdGNoIC0tbm8tdG8gLS10bz0iU29tZW9uZSBFbHNlIDxlbHNlQG91dC50aGVyZT4iIFwKLQkJLS1zdGRvdXQgbWFzdGVyLi5zaWRlIHwKLQlzZWQgLWUgIi9eXCQvcSIgPnBhdGNoMTEgJiYKLQljaGVja19wYXRjaCBwYXRjaDExICYmCi0JISBncmVwICJeVG86IFNvbWVvbmUgPHNvbWVvbmVAb3V0LnRoZXJlPlwkIiBwYXRjaDExICYmCi0JZ3JlcCAiXlRvOiBTb21lb25lIEVsc2UgPGVsc2VAb3V0LnRoZXJlPlwkIiBwYXRjaDExCisJCS0tc3Rkb3V0IG1hc3Rlci4uc2lkZSA+cGF0Y2gxMSAmJgorCXNlZCAtZSAiL15cJC9xIiBwYXRjaDExID5oZHJzMTEgJiYKKwljaGVja19wYXRjaCBoZHJzMTEgJiYKKwkhIGdyZXAgIl5UbzogU29tZW9uZSA8c29tZW9uZUBvdXQudGhlcmU+XCQiIGhkcnMxMSAmJgorCWdyZXAgIl5UbzogU29tZW9uZSBFbHNlIDxlbHNlQG91dC50aGVyZT5cJCIgaGRyczExCiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJy0tbm8tY2Mgb3ZlcnJpZGVzIGNvbmZpZy5jYycgJwotCiAJZ2l0IGNvbmZpZyAtLXJlcGxhY2UtYWxsIGZvcm1hdC5jYyBcCiAJCSJDIEUgQ2lwaWVudCA8cmNpcGllbnRAZXhhbXBsZS5jb20+IiAmJgotCWdpdCBmb3JtYXQtcGF0Y2ggLS1uby1jYyAtLXN0ZG91dCBtYXN0ZXIuLnNpZGUgfAotCXNlZCAtZSAiL15cJC9xIiA+cGF0Y2gxMiAmJgotCWNoZWNrX3BhdGNoIHBhdGNoMTIgJiYKLQkhIGdyZXAgIl5DYzogQyBFIENpcGllbnQgPHJjaXBpZW50QGV4YW1wbGUuY29tPlwkIiBwYXRjaDEyCisJZ2l0IGZvcm1hdC1wYXRjaCAtLW5vLWNjIC0tc3Rkb3V0IG1hc3Rlci4uc2lkZSA+cGF0Y2gxMiAmJgorCXNlZCAtZSAiL15cJC9xIiBwYXRjaDEyID5oZHJzMTIgJiYKKwljaGVja19wYXRjaCBoZHJzMTIgJiYKKwkhIGdyZXAgIl5DYzogQyBFIENpcGllbnQgPHJjaXBpZW50QGV4YW1wbGUuY29tPlwkIiBoZHJzMTIKICcKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnLS1uby1hZGQtaGVhZGVyIG92ZXJyaWRlcyBjb25maWcuaGVhZGVycycgJwotCiAJZ2l0IGNvbmZpZyAtLXJlcGxhY2UtYWxsIGZvcm1hdC5oZWFkZXJzIFwKIAkJIkhlYWRlcjE6IEIgRSBDaXBpZW50IDxyY2lwaWVudEBleGFtcGxlLmNvbT4iICYmCi0JZ2l0IGZvcm1hdC1wYXRjaCAtLW5vLWFkZC1oZWFkZXIgLS1zdGRvdXQgbWFzdGVyLi5zaWRlIHwKLQlzZWQgLWUgIi9eXCQvcSIgPnBhdGNoMTMgJiYKLQljaGVja19wYXRjaCBwYXRjaDEzICYmCi0JISBncmVwICJeSGVhZGVyMTogQiBFIENpcGllbnQgPHJjaXBpZW50QGV4YW1wbGUuY29tPlwkIiBwYXRjaDEzCisJZ2l0IGZvcm1hdC1wYXRjaCAtLW5vLWFkZC1oZWFkZXIgLS1zdGRvdXQgbWFzdGVyLi5zaWRlID5wYXRjaDEzICYmCisJc2VkIC1lICIvXlwkL3EiIHBhdGNoMTMgPmhkcnMxMyAmJgorCWNoZWNrX3BhdGNoIGhkcnMxMyAmJgorCSEgZ3JlcCAiXkhlYWRlcjE6IEIgRSBDaXBpZW50IDxyY2lwaWVudEBleGFtcGxlLmNvbT5cJCIgaGRyczEzCiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ211bHRpcGxlIGZpbGVzJyAnCi0KIAlybSAtcmYgcGF0Y2hlcy8gJiYKIAlnaXQgY2hlY2tvdXQgc2lkZSAmJgogCWdpdCBmb3JtYXQtcGF0Y2ggLW8gcGF0Y2hlcy8gbWFzdGVyICYmCkBAIC0zNTcsNyArMzMyLDcgQEAKIGNoZWNrX3RocmVhZGluZyAoKSB7CiAJZXhwZWN0PSIkMSIgJiYKIAlzaGlmdCAmJgotCShnaXQgZm9ybWF0LXBhdGNoIC0tc3Rkb3V0ICIkQCI7IGVjaG8gJD8gPiBzdGF0dXMub3V0KSB8CisJZ2l0IGZvcm1hdC1wYXRjaCAtLXN0ZG91dCAiJEAiID5wYXRjaCAmJgogCSMgUHJpbnRzIGV2ZXJ5dGhpbmcgYmV0d2VlbiB0aGUgTWVzc2FnZS1JRCBhbmQgSW4tUmVwbHktVG8sCiAJIyBhbmQgcmVwbGFjZXMgYWxsIE1lc3NhZ2UtSUQtbG9va2FsaWtlcyBieSBhIHNlcXVlbmNlIG51bWJlcgogCXBlcmwgLW5lICcKQEAgLTM3MiwxMiArMzQ3LDExIEBACiAJCQlwcmludDsKIAkJfQogCQlwcmludCAiLS0tXG4iIGlmIC9eRnJvbSAvaTsKLQknID4gYWN0dWFsICYmCi0JdGVzdCAwID0gIiQoY2F0IHN0YXR1cy5vdXQpIiAmJgorCScgPHBhdGNoID5hY3R1YWwgJiYKIAl0ZXN0X2NtcCAiJGV4cGVjdCIgYWN0dWFsCiB9CiAKLWNhdCA+PiBleHBlY3Qubm8tdGhyZWFkaW5nIDw8RU9GCitjYXQgPj5leHBlY3Qubm8tdGhyZWFkaW5nIDw8RU9GCiAtLS0KIC0tLQogLS0tCkBAIC0zODgsNyArMzYyLDcgQEAKIAljaGVja190aHJlYWRpbmcgZXhwZWN0Lm5vLXRocmVhZGluZyBtYXN0ZXIKICcKIAotY2F0ID4gZXhwZWN0LnRocmVhZCA8PEVPRgorY2F0ID5leHBlY3QudGhyZWFkIDw8RU9GCiAtLS0KIE1lc3NhZ2UtSWQ6IDwwPgogLS0tCkBAIC00MDUsNyArMzc5LDcgQEAKIAljaGVja190aHJlYWRpbmcgZXhwZWN0LnRocmVhZCAtLXRocmVhZCBtYXN0ZXIKICcKIAotY2F0ID4gZXhwZWN0LmluLXJlcGx5LXRvIDw8RU9GCitjYXQgPmV4cGVjdC5pbi1yZXBseS10byA8PEVPRgogLS0tCiBNZXNzYWdlLUlkOiA8MD4KIEluLVJlcGx5LVRvOiA8MT4KQEAgLTQyNSw3ICszOTksNyBAQAogCQktLXRocmVhZCBtYXN0ZXIKICcKIAotY2F0ID4gZXhwZWN0LmNvdmVyLWxldHRlciA8PEVPRgorY2F0ID5leHBlY3QuY292ZXItbGV0dGVyIDw8RU9GCiAtLS0KIE1lc3NhZ2UtSWQ6IDwwPgogLS0tCkBAIC00NDYsNyArNDIwLDcgQEAKIAljaGVja190aHJlYWRpbmcgZXhwZWN0LmNvdmVyLWxldHRlciAtLWNvdmVyLWxldHRlciAtLXRocmVhZCBtYXN0ZXIKICcKIAotY2F0ID4gZXhwZWN0LmNsLWlydCA8PEVPRgorY2F0ID5leHBlY3QuY2wtaXJ0IDw8RU9GCiAtLS0KIE1lc3NhZ2UtSWQ6IDwwPgogSW4tUmVwbHktVG86IDwxPgpAQCAtNDc4LDcgKzQ1Miw3IEBACiAJCS0taW4tcmVwbHktdG89Ijx0ZXN0Lm1lc3NhZ2U+IiAtLXRocmVhZD1zaGFsbG93IG1hc3RlcgogJwogCi1jYXQgPiBleHBlY3QuZGVlcCA8PEVPRgorY2F0ID5leHBlY3QuZGVlcCA8PEVPRgogLS0tCiBNZXNzYWdlLUlkOiA8MD4KIC0tLQpAQCAtNDk2LDcgKzQ3MCw3IEBACiAJY2hlY2tfdGhyZWFkaW5nIGV4cGVjdC5kZWVwIC0tdGhyZWFkPWRlZXAgbWFzdGVyCiAnCiAKLWNhdCA+IGV4cGVjdC5kZWVwLWlydCA8PEVPRgorY2F0ID5leHBlY3QuZGVlcC1pcnQgPDxFT0YKIC0tLQogTWVzc2FnZS1JZDogPDA+CiBJbi1SZXBseS1UbzogPDE+CkBAIC01MTksNyArNDkzLDcgQEAKIAkJLS1pbi1yZXBseS10bz0iPHRlc3QubWVzc2FnZT4iIG1hc3RlcgogJwogCi1jYXQgPiBleHBlY3QuZGVlcC1jbCA8PEVPRgorY2F0ID5leHBlY3QuZGVlcC1jbCA8PEVPRgogLS0tCiBNZXNzYWdlLUlkOiA8MD4KIC0tLQpAQCAtNTQzLDcgKzUxNyw3IEBACiAJY2hlY2tfdGhyZWFkaW5nIGV4cGVjdC5kZWVwLWNsIC0tY292ZXItbGV0dGVyIC0tdGhyZWFkPWRlZXAgbWFzdGVyCiAnCiAKLWNhdCA+IGV4cGVjdC5kZWVwLWNsLWlydCA8PEVPRgorY2F0ID5leHBlY3QuZGVlcC1jbC1pcnQgPDxFT0YKIC0tLQogTWVzc2FnZS1JZDogPDA+CiBJbi1SZXBseS1UbzogPDE+CkBAIC01OTQsNyArNTY4LDYgQEAKICcKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnZXhjZXNzaXZlIHN1YmplY3QnICcKLQogCXJtIC1yZiBwYXRjaGVzLyAmJgogCWdpdCBjaGVja291dCBzaWRlICYmCiAJYmVmb3JlPSQoZ2l0IGhhc2gtb2JqZWN0IGZpbGUpICYmCkBAIC02MjIsMTAgKzU5NSw5IEBACiAJISBncmVwICJmaWxlID0+IGZvbyAuKiAwICpcJCIgMDAwMC1jb3Zlci1sZXR0ZXIucGF0Y2ggJiYKIAlnaXQgZm9ybWF0LXBhdGNoIC0tY292ZXItbGV0dGVyIC0xIC1NICYmCiAJZ3JlcCAiZmlsZSA9PiBmb28gLiogMCAqXCQiIDAwMDAtY292ZXItbGV0dGVyLnBhdGNoCi0KICcKIAotY2F0ID4gZXhwZWN0IDw8IEVPRgorY2F0ID5leHBlY3QgPDxFT0YKICAgVGhpcyBpcyBhbiBleGNlc3NpdmVseSBsb25nIHN1YmplY3QgbGluZSBmb3IgYSBtZXNzYWdlIGR1ZSB0byB0aGUKICAgICBoYWJpdCBzb21lIHByb2plY3RzIGhhdmUgb2Ygbm90IGhhdmluZyBhIHNob3J0LCBvbmUtbGluZSBzdWJqZWN0IGF0CiAgICAgdGhlIHN0YXJ0IG9mIHRoZSBjb21taXQgbWVzc2FnZSwgYnV0IHJhdGhlciBzdGlja2luZyBhIHdob2xlCkBAIC02MzYsMTQgKzYwOCwxMiBAQAogRU9GCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3Nob3J0bG9nIG9mIGNvdmVyLWxldHRlciB3cmFwcyBvdmVybHktbG9uZyBvbmVsaW5lcycgJwotCiAJZ2l0IGZvcm1hdC1wYXRjaCAtLWNvdmVyLWxldHRlciAtMiAmJgotCXNlZCAtZSAiMSwvQSBVIFRob3IvZCIgLWUgIi9eXCQvcSIgPCAwMDAwLWNvdmVyLWxldHRlci5wYXRjaCA+IG91dHB1dCAmJgorCXNlZCAtZSAiMSwvQSBVIFRob3IvZCIgLWUgIi9eXCQvcSIgMDAwMC1jb3Zlci1sZXR0ZXIucGF0Y2ggPm91dHB1dCAmJgogCXRlc3RfY21wIGV4cGVjdCBvdXRwdXQKLQogJwogCi1jYXQgPiBleHBlY3QgPDwgRU9GCitjYXQgPmV4cGVjdCA8PEVPRgogaW5kZXggJGJlZm9yZS4uJGFmdGVyIDEwMDY0NAogLS0tIGEvZmlsZQogKysrIGIvZmlsZQpAQCAtNjU2LDE2ICs2MjYsMTQgQEAKIEVPRgogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdmb3JtYXQtcGF0Y2ggcmVzcGVjdHMgLVUnICcKLQogCWdpdCBmb3JtYXQtcGF0Y2ggLVU0IC0yICYmCiAJc2VkIC1lICIxLC9eZGlmZi9kIiAtZSAiL14rNS9xIiBcCiAJCTwwMDAxLVRoaXMtaXMtYW4tZXhjZXNzaXZlbHktbG9uZy1zdWJqZWN0LWxpbmUtZm9yLWEtbWVzc2EucGF0Y2ggXAogCQk+b3V0cHV0ICYmCiAJdGVzdF9jbXAgZXhwZWN0IG91dHB1dAotCiAnCiAKLWNhdCA+IGV4cGVjdCA8PCBFT0YKK2NhdCA+ZXhwZWN0IDw8RU9GCiAKIGRpZmYgLS1naXQgYS9maWxlIGIvZmlsZQogaW5kZXggJGJlZm9yZS4uJGFmdGVyIDEwMDY0NApAQCAtNjc5LDExICs2NDcsOSBAQAogRU9GCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2Zvcm1hdC1wYXRjaCAtcCBzdXBwcmVzc2VzIHN0YXQnICcKLQogCWdpdCBmb3JtYXQtcGF0Y2ggLXAgLTIgJiYKLQlzZWQgLWUgIjEsL15cJC9kIiAtZSAiL14rNS9xIiA8IDAwMDEtVGhpcy1pcy1hbi1leGNlc3NpdmVseS1sb25nLXN1YmplY3QtbGluZS1mb3ItYS1tZXNzYS5wYXRjaCA+IG91dHB1dCAmJgorCXNlZCAtZSAiMSwvXlwkL2QiIC1lICIvXis1L3EiIDAwMDEtVGhpcy1pcy1hbi1leGNlc3NpdmVseS1sb25nLXN1YmplY3QtbGluZS1mb3ItYS1tZXNzYS5wYXRjaCA+b3V0cHV0ICYmCiAJdGVzdF9jbXAgZXhwZWN0IG91dHB1dAotCiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2Zvcm1hdC1wYXRjaCBmcm9tIGEgc3ViZGlyZWN0b3J5ICgxKScgJwpAQCAtNzM2LDcgKzcwMiw3IEBACiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2Zvcm1hdC1wYXRjaCAtLWluLXJlcGx5LXRvJyAnCi0JZ2l0IGZvcm1hdC1wYXRjaCAtMSAtLXN0ZG91dCAtLWluLXJlcGx5LXRvICJiYXpAZm9vLmJhciIgPiBwYXRjaDggJiYKKwlnaXQgZm9ybWF0LXBhdGNoIC0xIC0tc3Rkb3V0IC0taW4tcmVwbHktdG8gImJhekBmb28uYmFyIiA+cGF0Y2g4ICYmCiAJZ3JlcCAiXkluLVJlcGx5LVRvOiA8YmF6QGZvby5iYXI+IiBwYXRjaDggJiYKIAlncmVwICJeUmVmZXJlbmNlczogPGJhekBmb28uYmFyPiIgcGF0Y2g4CiAnCkBAIC04MjcsMjEgKzc5MywyNCBAQAogCSEgZ3JlcCAidGhpcyBpcyBub3RlIDIiIG91dAogJwogCi1lY2hvICJmYXRhbDogLS1uYW1lLW9ubHkgZG9lcyBub3QgbWFrZSBzZW5zZSIgPiBleHBlY3QubmFtZS1vbmx5Ci1lY2hvICJmYXRhbDogLS1uYW1lLXN0YXR1cyBkb2VzIG5vdCBtYWtlIHNlbnNlIiA+IGV4cGVjdC5uYW1lLXN0YXR1cwotZWNobyAiZmF0YWw6IC0tY2hlY2sgZG9lcyBub3QgbWFrZSBzZW5zZSIgPiBleHBlY3QuY2hlY2sKK2VjaG8gImZhdGFsOiAtLW5hbWUtb25seSBkb2VzIG5vdCBtYWtlIHNlbnNlIiA+ZXhwZWN0Lm5hbWUtb25seQorZWNobyAiZmF0YWw6IC0tbmFtZS1zdGF0dXMgZG9lcyBub3QgbWFrZSBzZW5zZSIgPmV4cGVjdC5uYW1lLXN0YXR1cworZWNobyAiZmF0YWw6IC0tY2hlY2sgZG9lcyBub3QgbWFrZSBzZW5zZSIgPmV4cGVjdC5jaGVjawogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdvcHRpb25zIG5vIGxvbmdlciBhbGxvd2VkIGZvciBmb3JtYXQtcGF0Y2gnICcKLQl0ZXN0X211c3RfZmFpbCBnaXQgZm9ybWF0LXBhdGNoIC0tbmFtZS1vbmx5IDI+IG91dHB1dCAmJgorCXRlc3RfbXVzdF9mYWlsIGdpdCBmb3JtYXQtcGF0Y2ggLS1uYW1lLW9ubHkgMj5vdXRwdXQgJiYKIAl0ZXN0X2kxOG5jbXAgZXhwZWN0Lm5hbWUtb25seSBvdXRwdXQgJiYKLQl0ZXN0X211c3RfZmFpbCBnaXQgZm9ybWF0LXBhdGNoIC0tbmFtZS1zdGF0dXMgMj4gb3V0cHV0ICYmCisJdGVzdF9tdXN0X2ZhaWwgZ2l0IGZvcm1hdC1wYXRjaCAtLW5hbWUtc3RhdHVzIDI+b3V0cHV0ICYmCiAJdGVzdF9pMThuY21wIGV4cGVjdC5uYW1lLXN0YXR1cyBvdXRwdXQgJiYKLQl0ZXN0X211c3RfZmFpbCBnaXQgZm9ybWF0LXBhdGNoIC0tY2hlY2sgMj4gb3V0cHV0ICYmCi0JdGVzdF9pMThuY21wIGV4cGVjdC5jaGVjayBvdXRwdXQnCisJdGVzdF9tdXN0X2ZhaWwgZ2l0IGZvcm1hdC1wYXRjaCAtLWNoZWNrIDI+b3V0cHV0ICYmCisJdGVzdF9pMThuY21wIGV4cGVjdC5jaGVjayBvdXRwdXQKKycKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnZm9ybWF0LXBhdGNoIC0tbnVtc3RhdCBzaG91bGQgcHJvZHVjZSBhIHBhdGNoJyAnCi0JZ2l0IGZvcm1hdC1wYXRjaCAtLW51bXN0YXQgLS1zdGRvdXQgbWFzdGVyLi5zaWRlID4gb3V0cHV0ICYmCi0JdGVzdCA1ID0gJChncmVwICJeZGlmZiAtLWdpdCBhLyIgb3V0cHV0IHwgd2MgLWwpJworCWdpdCBmb3JtYXQtcGF0Y2ggLS1udW1zdGF0IC0tc3Rkb3V0IG1hc3Rlci4uc2lkZSA+b3V0cHV0ICYmCisJZ3JlcCAiXmRpZmYgLS1naXQgYS8iIG91dHB1dCA+ZGlmZiAmJgorCXRlc3RfbGluZV9jb3VudCA9IDUgZGlmZgorJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdmb3JtYXQtcGF0Y2ggLS0gPHBhdGg+JyAnCiAJZ2l0IGZvcm1hdC1wYXRjaCBtYXN0ZXIuLnNpZGUgLS0gZmlsZSAyPmVycm9yICYmCkBAIC04NTIsMjAgKzgyMSwyNSBAQAogCWdpdCBmb3JtYXQtcGF0Y2ggLS1pZ25vcmUtaWYtaW4tdXBzdHJlYW0gSEVBRAogJwogCi1naXRfdmVyc2lvbj0iJChnaXQgLS12ZXJzaW9uIHwgc2VkICJzLy4qIC8vIikiCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdnZXQgZ2l0IHZlcnNpb24nICcKKwlnaXRfdmVyc2lvbj0kKGdpdCAtLXZlcnNpb24pICYmCisJZ2l0X3ZlcnNpb249JHtnaXRfdmVyc2lvbiMjKiB9CisnCiAKIHNpZ25hdHVyZSgpIHsKIAlwcmludGYgIiVzXG4lc1xuXG4iICItLSAiICIkezE6LSRnaXRfdmVyc2lvbn0iCiB9CiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2Zvcm1hdC1wYXRjaCBkZWZhdWx0IHNpZ25hdHVyZScgJwotCWdpdCBmb3JtYXQtcGF0Y2ggLS1zdGRvdXQgLTEgfCB0YWlsIC1uIDMgPm91dHB1dCAmJgorCWdpdCBmb3JtYXQtcGF0Y2ggLS1zdGRvdXQgLTEgPnBhdGNoICYmCisJdGFpbCAtbiAzIHBhdGNoID5vdXRwdXQgJiYKIAlzaWduYXR1cmUgPmV4cGVjdCAmJgogCXRlc3RfY21wIGV4cGVjdCBvdXRwdXQKICcKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnZm9ybWF0LXBhdGNoIC0tc2lnbmF0dXJlJyAnCi0JZ2l0IGZvcm1hdC1wYXRjaCAtLXN0ZG91dCAtLXNpZ25hdHVyZT0ibXkgc2lnIiAtMSB8IHRhaWwgLW4gMyA+b3V0cHV0ICYmCisJZ2l0IGZvcm1hdC1wYXRjaCAtLXN0ZG91dCAtLXNpZ25hdHVyZT0ibXkgc2lnIiAtMSA+cGF0Y2ggJiYKKwl0YWlsIC1uIDMgcGF0Y2ggPm91dHB1dCAmJgogCXNpZ25hdHVyZSAibXkgc2lnIiA+ZXhwZWN0ICYmCiAJdGVzdF9jbXAgZXhwZWN0IG91dHB1dAogJwpAQCAtODk3LDggKzg3MSw4IEBACiAJZ2l0IGNvbmZpZyAtLXVuc2V0LWFsbCBmb3JtYXQuc2lnbmF0dXJlICYmCiAJZ2l0IGZvcm1hdC1wYXRjaCAtLXN0ZG91dCAtLXNpZ25hdHVyZT0ibXkgc2lnIiAtLWNvdmVyLWxldHRlciBcCiAJCS0xID5vdXRwdXQgJiYKLQlncmVwICJteSBzaWciIG91dHB1dCAmJgotCXRlc3QgMiA9ICQoZ3JlcCAibXkgc2lnIiBvdXRwdXQgfCB3YyAtbCkKKwlncmVwICJteSBzaWciIG91dHB1dCA+c2lnICYmCisJdGVzdF9saW5lX2NvdW50ID0gMiBzaWcKICcKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnZm9ybWF0LnNpZ25hdHVyZT0iIiBzdXBwcmVzc2VzIHNpZ25hdHVyZXMnICcKQEAgLTkzNSw3ICs5MDksNyBAQAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnLS1zaWduYXR1cmUtZmlsZT1maWxlIHdvcmtzJyAnCiAJZ2l0IGZvcm1hdC1wYXRjaCAtLXN0ZG91dCAtLXNpZ25hdHVyZS1maWxlPW1haWwtc2lnbmF0dXJlIC0xID5vdXRwdXQgJiYKIAljaGVja19wYXRjaCBvdXRwdXQgJiYKLQlzZWQgLWUgIjEsL14tLSBcJC9kIiA8b3V0cHV0ID5hY3R1YWwgJiYKKwlzZWQgLWUgIjEsL14tLSBcJC9kIiBvdXRwdXQgPmFjdHVhbCAmJgogCXsKIAkJY2F0IG1haWwtc2lnbmF0dXJlICYmIGVjaG8KIAl9ID5leHBlY3QgJiYKQEAgLTk0Niw3ICs5MjAsNyBAQAogCXRlc3RfY29uZmlnIGZvcm1hdC5zaWduYXR1cmVmaWxlIG1haWwtc2lnbmF0dXJlICYmCiAJZ2l0IGZvcm1hdC1wYXRjaCAtLXN0ZG91dCAtMSA+b3V0cHV0ICYmCiAJY2hlY2tfcGF0Y2ggb3V0cHV0ICYmCi0Jc2VkIC1lICIxLC9eLS0gXCQvZCIgPG91dHB1dCA+YWN0dWFsICYmCisJc2VkIC1lICIxLC9eLS0gXCQvZCIgb3V0cHV0ID5hY3R1YWwgJiYKIAl7CiAJCWNhdCBtYWlsLXNpZ25hdHVyZSAmJiBlY2hvCiAJfSA+ZXhwZWN0ICYmCkBAIC05NjgsNyArOTQyLDcgQEAKIAlnaXQgZm9ybWF0LXBhdGNoIC0tc3Rkb3V0IFwKIAkJCS0tc2lnbmF0dXJlLWZpbGU9b3RoZXItbWFpbC1zaWduYXR1cmUgLTEgPm91dHB1dCAmJgogCWNoZWNrX3BhdGNoIG91dHB1dCAmJgotCXNlZCAtZSAiMSwvXi0tIFwkL2QiIDxvdXRwdXQgPmFjdHVhbCAmJgorCXNlZCAtZSAiMSwvXi0tIFwkL2QiIG91dHB1dCA+YWN0dWFsICYmCiAJewogCQljYXQgb3RoZXItbWFpbC1zaWduYXR1cmUgJiYgZWNobwogCX0gPmV4cGVjdCAmJgpAQCAtMTAzNyw3ICsxMDExLDcgQEAKIAlnaXQgYWRkIGZpbGUgJiYKIAlnaXQgY29tbWl0IC1tICIkTTUxMiIgJiYKIAlnaXQgZm9ybWF0LXBhdGNoIC0tc3Rkb3V0IC0xID5wYXRjaCAmJgotCXNlZCAtbiAiL15TdWJqZWN0L3A7IC9eIC9wOyAvXiQvcSIgPHBhdGNoID5zdWJqZWN0ICYmCisJc2VkIC1uICIvXlN1YmplY3QvcDsgL14gL3A7IC9eJC9xIiBwYXRjaCA+c3ViamVjdCAmJgogCXRlc3RfY21wIGV4cGVjdCBzdWJqZWN0CiAnCiAKQEAgLTEwNzYsNyArMTA1MCw3IEBACiAJZ2l0IGFkZCBmaWxlICYmCiAJZ2l0IGNvbW1pdCAtbSAiJE01MTIiICYmCiAJZ2l0IGZvcm1hdC1wYXRjaCAtLXN0ZG91dCAtMSA+cGF0Y2ggJiYKLQlzZWQgLW4gIi9eU3ViamVjdC9wOyAvXiAvcDsgL14kL3EiIDxwYXRjaCA+c3ViamVjdCAmJgorCXNlZCAtbiAiL15TdWJqZWN0L3A7IC9eIC9wOyAvXiQvcSIgcGF0Y2ggPnN1YmplY3QgJiYKIAl0ZXN0X2NtcCBleHBlY3Qgc3ViamVjdAogJwogCkBAIC0xMDg1LDcgKzEwNTksNyBAQAogCWdpdCBhZGQgZmlsZSAmJgogCUdJVF9BVVRIT1JfTkFNRT0kMSBnaXQgY29tbWl0IC1tIGF1dGhvci1jaGVjayAmJgogCWdpdCBmb3JtYXQtcGF0Y2ggLS1zdGRvdXQgLTEgPnBhdGNoICYmCi0Jc2VkIC1uICIvXkZyb206IC9wOyAvXiAvcDsgL14kL3EiIDxwYXRjaCA+YWN0dWFsICYmCisJc2VkIC1uICIvXkZyb206IC9wOyAvXiAvcDsgL14kL3EiIHBhdGNoID5hY3R1YWwgJiYKIAl0ZXN0X2NtcCBleHBlY3QgYWN0dWFsCiB9CiAKQEAgLTEyMDUsNyArMTE3OSw3IEBACiAJRnJvbTogQSBVIFRob3IgPGF1dGhvckBleGFtcGxlLmNvbT4KIAogCUVPRgotCXNlZCAtbmUgIi9eRnJvbTovcDsgL14kL3A7IC9eLS0tJC9xIiA8cGF0Y2ggPnBhdGNoLmhlYWQgJiYKKwlzZWQgLW5lICIvXkZyb206L3A7IC9eJC9wOyAvXi0tLSQvcSIgcGF0Y2ggPnBhdGNoLmhlYWQgJiYKIAl0ZXN0X2NtcCBleHBlY3QgcGF0Y2guaGVhZAogJwogCkBAIC0xMjE3LDcgKzExOTEsNyBAQAogCUZyb206IEEgVSBUaG9yIDxhdXRob3JAZXhhbXBsZS5jb20+CiAKIAlFT0YKLQlzZWQgLW5lICIvXkZyb206L3A7IC9eJC9wOyAvXi0tLSQvcSIgPHBhdGNoID5wYXRjaC5oZWFkICYmCisJc2VkIC1uZSAiL15Gcm9tOi9wOyAvXiQvcDsgL14tLS0kL3EiIHBhdGNoID5wYXRjaC5oZWFkICYmCiAJdGVzdF9jbXAgZXhwZWN0IHBhdGNoLmhlYWQKICcKIApAQCAtMTIyNyw3ICsxMjAxLDcgQEAKIAlGcm9tOiBBIFUgVGhvciA8YXV0aG9yQGV4YW1wbGUuY29tPgogCiAJRU9GCi0Jc2VkIC1uZSAiL15Gcm9tOi9wOyAvXiQvcDsgL14tLS0kL3EiIDxwYXRjaCA+cGF0Y2guaGVhZCAmJgorCXNlZCAtbmUgIi9eRnJvbTovcDsgL14kL3A7IC9eLS0tJC9xIiBwYXRjaCA+cGF0Y2guaGVhZCAmJgogCXRlc3RfY21wIGV4cGVjdCBwYXRjaC5oZWFkCiAnCiAKQEAgLTEyNDIsNyArMTIxNiw3IEBACiAJRnJvbTogw6l4w7Z0w6xjIDxhdXRob3JAZXhhbXBsZS5jb20+CiAKIAlFT0YKLQlzZWQgLW5lICIvXkZyb206L3A7IC9eJC9wOyAvXkNvbnRlbnQtVHlwZS9wOyAvXi0tLSQvcSIgPHBhdGNoID5wYXRjaC5oZWFkICYmCisJc2VkIC1uZSAiL15Gcm9tOi9wOyAvXiQvcDsgL15Db250ZW50LVR5cGUvcDsgL14tLS0kL3EiIHBhdGNoID5wYXRjaC5oZWFkICYmCiAJdGVzdF9jbXAgZXhwZWN0IHBhdGNoLmhlYWQKICcKIApAQCAtMTI1NiwyODMgKzEyMzAsMjgzIEBACiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3NpZ25vZmY6IGNvbW1pdCB3aXRoIG5vIGJvZHknICcKIAlhcHBlbmRfc2lnbm9mZiA8L2Rldi9udWxsID5hY3R1YWwgJiYKLQljYXQgPDxcRU9GIHwgc2VkICJzL0VPTCQvLyIgPmV4cGVjdGVkICYmCi00OlN1YmplY3Q6IFtQQVRDSF0gRU9MCi04OgotOTpTaWduZWQtb2ZmLWJ5OiBDIE8gTWl0dGVyIDxjb21taXR0ZXJAZXhhbXBsZS5jb20+Ci1FT0YKLQl0ZXN0X2NtcCBleHBlY3RlZCBhY3R1YWwKKwljYXQgPDwtXEVPRiB8IHNlZCAicy9FT0wkLy8iID5leHBlY3QgJiYKKwk0OlN1YmplY3Q6IFtQQVRDSF0gRU9MCisJODoKKwk5OlNpZ25lZC1vZmYtYnk6IEMgTyBNaXR0ZXIgPGNvbW1pdHRlckBleGFtcGxlLmNvbT4KKwlFT0YKKwl0ZXN0X2NtcCBleHBlY3QgYWN0dWFsCiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3NpZ25vZmY6IGNvbW1pdCB3aXRoIG9ubHkgc3ViamVjdCcgJwogCWVjaG8gc3ViamVjdCB8IGFwcGVuZF9zaWdub2ZmID5hY3R1YWwgJiYKLQljYXQgPmV4cGVjdGVkIDw8XEVPRiAmJgotNDpTdWJqZWN0OiBbUEFUQ0hdIHN1YmplY3QKLTg6Ci05OlNpZ25lZC1vZmYtYnk6IEMgTyBNaXR0ZXIgPGNvbW1pdHRlckBleGFtcGxlLmNvbT4KLUVPRgotCXRlc3RfY21wIGV4cGVjdGVkIGFjdHVhbAorCWNhdCA+ZXhwZWN0IDw8LVxFT0YgJiYKKwk0OlN1YmplY3Q6IFtQQVRDSF0gc3ViamVjdAorCTg6CisJOTpTaWduZWQtb2ZmLWJ5OiBDIE8gTWl0dGVyIDxjb21taXR0ZXJAZXhhbXBsZS5jb20+CisJRU9GCisJdGVzdF9jbXAgZXhwZWN0IGFjdHVhbAogJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdzaWdub2ZmOiBjb21taXQgd2l0aCBvbmx5IHN1YmplY3QgdGhhdCBkb2VzIG5vdCBlbmQgd2l0aCBOTCcgJwogCXByaW50ZiBzdWJqZWN0IHwgYXBwZW5kX3NpZ25vZmYgPmFjdHVhbCAmJgotCWNhdCA+ZXhwZWN0ZWQgPDxcRU9GICYmCi00OlN1YmplY3Q6IFtQQVRDSF0gc3ViamVjdAotODoKLTk6U2lnbmVkLW9mZi1ieTogQyBPIE1pdHRlciA8Y29tbWl0dGVyQGV4YW1wbGUuY29tPgotRU9GCi0JdGVzdF9jbXAgZXhwZWN0ZWQgYWN0dWFsCisJY2F0ID5leHBlY3QgPDwtXEVPRiAmJgorCTQ6U3ViamVjdDogW1BBVENIXSBzdWJqZWN0CisJODoKKwk5OlNpZ25lZC1vZmYtYnk6IEMgTyBNaXR0ZXIgPGNvbW1pdHRlckBleGFtcGxlLmNvbT4KKwlFT0YKKwl0ZXN0X2NtcCBleHBlY3QgYWN0dWFsCiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3NpZ25vZmY6IG5vIGV4aXN0aW5nIHNpZ25vZmZzJyAnCi0JYXBwZW5kX3NpZ25vZmYgPDxcRU9GID5hY3R1YWwgJiYKLXN1YmplY3QKKwlhcHBlbmRfc2lnbm9mZiA8PC1cRU9GID5hY3R1YWwgJiYKKwlzdWJqZWN0CiAKLWJvZHkKLUVPRgotCWNhdCA+ZXhwZWN0ZWQgPDxcRU9GICYmCi00OlN1YmplY3Q6IFtQQVRDSF0gc3ViamVjdAotODoKLTEwOgotMTE6U2lnbmVkLW9mZi1ieTogQyBPIE1pdHRlciA8Y29tbWl0dGVyQGV4YW1wbGUuY29tPgotRU9GCi0JdGVzdF9jbXAgZXhwZWN0ZWQgYWN0dWFsCisJYm9keQorCUVPRgorCWNhdCA+ZXhwZWN0IDw8LVxFT0YgJiYKKwk0OlN1YmplY3Q6IFtQQVRDSF0gc3ViamVjdAorCTg6CisJMTA6CisJMTE6U2lnbmVkLW9mZi1ieTogQyBPIE1pdHRlciA8Y29tbWl0dGVyQGV4YW1wbGUuY29tPgorCUVPRgorCXRlc3RfY21wIGV4cGVjdCBhY3R1YWwKICcKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnc2lnbm9mZjogbm8gZXhpc3Rpbmcgc2lnbm9mZnMgYW5kIG5vIHRyYWlsaW5nIE5MJyAnCiAJcHJpbnRmICJzdWJqZWN0XG5cbmJvZHkiIHwgYXBwZW5kX3NpZ25vZmYgPmFjdHVhbCAmJgotCWNhdCA+ZXhwZWN0ZWQgPDxcRU9GICYmCi00OlN1YmplY3Q6IFtQQVRDSF0gc3ViamVjdAotODoKLTEwOgotMTE6U2lnbmVkLW9mZi1ieTogQyBPIE1pdHRlciA8Y29tbWl0dGVyQGV4YW1wbGUuY29tPgotRU9GCi0JdGVzdF9jbXAgZXhwZWN0ZWQgYWN0dWFsCisJY2F0ID5leHBlY3QgPDwtXEVPRiAmJgorCTQ6U3ViamVjdDogW1BBVENIXSBzdWJqZWN0CisJODoKKwkxMDoKKwkxMTpTaWduZWQtb2ZmLWJ5OiBDIE8gTWl0dGVyIDxjb21taXR0ZXJAZXhhbXBsZS5jb20+CisJRU9GCisJdGVzdF9jbXAgZXhwZWN0IGFjdHVhbAogJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdzaWdub2ZmOiBzb21lIHJhbmRvbSBzaWdub2ZmJyAnCi0JYXBwZW5kX3NpZ25vZmYgPDxcRU9GID5hY3R1YWwgJiYKLXN1YmplY3QKKwlhcHBlbmRfc2lnbm9mZiA8PC1cRU9GID5hY3R1YWwgJiYKKwlzdWJqZWN0CiAKLWJvZHkKKwlib2R5CiAKLVNpZ25lZC1vZmYtYnk6IG15QGhvdXNlCi1FT0YKLQljYXQgPmV4cGVjdGVkIDw8XEVPRiAmJgotNDpTdWJqZWN0OiBbUEFUQ0hdIHN1YmplY3QKLTg6Ci0xMDoKLTExOlNpZ25lZC1vZmYtYnk6IG15QGhvdXNlCi0xMjpTaWduZWQtb2ZmLWJ5OiBDIE8gTWl0dGVyIDxjb21taXR0ZXJAZXhhbXBsZS5jb20+Ci1FT0YKLQl0ZXN0X2NtcCBleHBlY3RlZCBhY3R1YWwKKwlTaWduZWQtb2ZmLWJ5OiBteUBob3VzZQorCUVPRgorCWNhdCA+ZXhwZWN0IDw8LVxFT0YgJiYKKwk0OlN1YmplY3Q6IFtQQVRDSF0gc3ViamVjdAorCTg6CisJMTA6CisJMTE6U2lnbmVkLW9mZi1ieTogbXlAaG91c2UKKwkxMjpTaWduZWQtb2ZmLWJ5OiBDIE8gTWl0dGVyIDxjb21taXR0ZXJAZXhhbXBsZS5jb20+CisJRU9GCisJdGVzdF9jbXAgZXhwZWN0IGFjdHVhbAogJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdzaWdub2ZmOiBtaXNjIGNvbmZvcm1pbmcgZm9vdGVyIGVsZW1lbnRzJyAnCi0JYXBwZW5kX3NpZ25vZmYgPDxcRU9GID5hY3R1YWwgJiYKLXN1YmplY3QKKwlhcHBlbmRfc2lnbm9mZiA8PC1cRU9GID5hY3R1YWwgJiYKKwlzdWJqZWN0CiAKLWJvZHkKKwlib2R5CiAKLVNpZ25lZC1vZmYtYnk6IG15QGhvdXNlCi0oY2hlcnJ5IHBpY2tlZCBmcm9tIGNvbW1pdCBkYTM5YTNlZTVlNmI0YjBkMzI1NWJmZWY5NTYwMTg5MGFmZDgwNzA5KQotVGVzdGVkLWJ5OiBTb21lIE9uZSA8c29tZW9uZUBleGFtcGxlLmNvbT4KLUJ1ZzogMTIzNAotRU9GCi0JY2F0ID5leHBlY3RlZCA8PFxFT0YgJiYKLTQ6U3ViamVjdDogW1BBVENIXSBzdWJqZWN0Ci04OgotMTA6Ci0xMTpTaWduZWQtb2ZmLWJ5OiBteUBob3VzZQotMTU6U2lnbmVkLW9mZi1ieTogQyBPIE1pdHRlciA8Y29tbWl0dGVyQGV4YW1wbGUuY29tPgotRU9GCi0JdGVzdF9jbXAgZXhwZWN0ZWQgYWN0dWFsCisJU2lnbmVkLW9mZi1ieTogbXlAaG91c2UKKwkoY2hlcnJ5IHBpY2tlZCBmcm9tIGNvbW1pdCBkYTM5YTNlZTVlNmI0YjBkMzI1NWJmZWY5NTYwMTg5MGFmZDgwNzA5KQorCVRlc3RlZC1ieTogU29tZSBPbmUgPHNvbWVvbmVAZXhhbXBsZS5jb20+CisJQnVnOiAxMjM0CisJRU9GCisJY2F0ID5leHBlY3QgPDwtXEVPRiAmJgorCTQ6U3ViamVjdDogW1BBVENIXSBzdWJqZWN0CisJODoKKwkxMDoKKwkxMTpTaWduZWQtb2ZmLWJ5OiBteUBob3VzZQorCTE1OlNpZ25lZC1vZmYtYnk6IEMgTyBNaXR0ZXIgPGNvbW1pdHRlckBleGFtcGxlLmNvbT4KKwlFT0YKKwl0ZXN0X2NtcCBleHBlY3QgYWN0dWFsCiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3NpZ25vZmY6IHNvbWUgcmFuZG9tIHNpZ25vZmYtYWxpa2UnICcKLQlhcHBlbmRfc2lnbm9mZiA8PFxFT0YgPmFjdHVhbCAmJgotc3ViamVjdAorCWFwcGVuZF9zaWdub2ZmIDw8LVxFT0YgPmFjdHVhbCAmJgorCXN1YmplY3QKIAotYm9keQotRm9vbGVkLWJ5LW1lOiBteUBob3VzZQotRU9GCi0JY2F0ID5leHBlY3RlZCA8PFxFT0YgJiYKLTQ6U3ViamVjdDogW1BBVENIXSBzdWJqZWN0Ci04OgotMTE6Ci0xMjpTaWduZWQtb2ZmLWJ5OiBDIE8gTWl0dGVyIDxjb21taXR0ZXJAZXhhbXBsZS5jb20+Ci1FT0YKLQl0ZXN0X2NtcCBleHBlY3RlZCBhY3R1YWwKKwlib2R5CisJRm9vbGVkLWJ5LW1lOiBteUBob3VzZQorCUVPRgorCWNhdCA+ZXhwZWN0IDw8LVxFT0YgJiYKKwk0OlN1YmplY3Q6IFtQQVRDSF0gc3ViamVjdAorCTg6CisJMTE6CisJMTI6U2lnbmVkLW9mZi1ieTogQyBPIE1pdHRlciA8Y29tbWl0dGVyQGV4YW1wbGUuY29tPgorCUVPRgorCXRlc3RfY21wIGV4cGVjdCBhY3R1YWwKICcKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnc2lnbm9mZjogbm90IHJlYWxseSBhIHNpZ25vZmYnICcKLQlhcHBlbmRfc2lnbm9mZiA8PFxFT0YgPmFjdHVhbCAmJgotc3ViamVjdAorCWFwcGVuZF9zaWdub2ZmIDw8LVxFT0YgPmFjdHVhbCAmJgorCXN1YmplY3QKIAotSSB3YW50IHRvIG1lbnRpb24gYWJvdXQgU2lnbmVkLW9mZi1ieTogaGVyZS4KLUVPRgotCWNhdCA+ZXhwZWN0ZWQgPDxcRU9GICYmCi00OlN1YmplY3Q6IFtQQVRDSF0gc3ViamVjdAotODoKLTk6SSB3YW50IHRvIG1lbnRpb24gYWJvdXQgU2lnbmVkLW9mZi1ieTogaGVyZS4KLTEwOgotMTE6U2lnbmVkLW9mZi1ieTogQyBPIE1pdHRlciA8Y29tbWl0dGVyQGV4YW1wbGUuY29tPgotRU9GCi0JdGVzdF9jbXAgZXhwZWN0ZWQgYWN0dWFsCisJSSB3YW50IHRvIG1lbnRpb24gYWJvdXQgU2lnbmVkLW9mZi1ieTogaGVyZS4KKwlFT0YKKwljYXQgPmV4cGVjdCA8PC1cRU9GICYmCisJNDpTdWJqZWN0OiBbUEFUQ0hdIHN1YmplY3QKKwk4OgorCTk6SSB3YW50IHRvIG1lbnRpb24gYWJvdXQgU2lnbmVkLW9mZi1ieTogaGVyZS4KKwkxMDoKKwkxMTpTaWduZWQtb2ZmLWJ5OiBDIE8gTWl0dGVyIDxjb21taXR0ZXJAZXhhbXBsZS5jb20+CisJRU9GCisJdGVzdF9jbXAgZXhwZWN0IGFjdHVhbAogJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdzaWdub2ZmOiBub3QgcmVhbGx5IGEgc2lnbm9mZiAoMiknICcKLQlhcHBlbmRfc2lnbm9mZiA8PFxFT0YgPmFjdHVhbCAmJgotc3ViamVjdAorCWFwcGVuZF9zaWdub2ZmIDw8LVxFT0YgPmFjdHVhbCAmJgorCXN1YmplY3QKIAotTXkgdW5mb3J0dW5hdGUKLVNpZ25lZC1vZmYtYnk6IGV4YW1wbGUgaGFwcGVucyB0byBiZSB3cmFwcGVkIGhlcmUuCi1FT0YKLQljYXQgPmV4cGVjdGVkIDw8XEVPRiAmJgotNDpTdWJqZWN0OiBbUEFUQ0hdIHN1YmplY3QKLTg6Ci0xMDpTaWduZWQtb2ZmLWJ5OiBleGFtcGxlIGhhcHBlbnMgdG8gYmUgd3JhcHBlZCBoZXJlLgotMTE6U2lnbmVkLW9mZi1ieTogQyBPIE1pdHRlciA8Y29tbWl0dGVyQGV4YW1wbGUuY29tPgotRU9GCi0JdGVzdF9jbXAgZXhwZWN0ZWQgYWN0dWFsCisJTXkgdW5mb3J0dW5hdGUKKwlTaWduZWQtb2ZmLWJ5OiBleGFtcGxlIGhhcHBlbnMgdG8gYmUgd3JhcHBlZCBoZXJlLgorCUVPRgorCWNhdCA+ZXhwZWN0IDw8LVxFT0YgJiYKKwk0OlN1YmplY3Q6IFtQQVRDSF0gc3ViamVjdAorCTg6CisJMTA6U2lnbmVkLW9mZi1ieTogZXhhbXBsZSBoYXBwZW5zIHRvIGJlIHdyYXBwZWQgaGVyZS4KKwkxMTpTaWduZWQtb2ZmLWJ5OiBDIE8gTWl0dGVyIDxjb21taXR0ZXJAZXhhbXBsZS5jb20+CisJRU9GCisJdGVzdF9jbXAgZXhwZWN0IGFjdHVhbAogJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdzaWdub2ZmOiB2YWxpZCBTLW8tYiBwYXJhZ3JhcGggaW4gdGhlIG1pZGRsZScgJwotCWFwcGVuZF9zaWdub2ZmIDw8XEVPRiA+YWN0dWFsICYmCi1zdWJqZWN0CisJYXBwZW5kX3NpZ25vZmYgPDwtXEVPRiA+YWN0dWFsICYmCisJc3ViamVjdAogCi1TaWduZWQtb2ZmLWJ5OiBteUBob3VzZQotU2lnbmVkLW9mZi1ieTogeW91ckBob3VzZQorCVNpZ25lZC1vZmYtYnk6IG15QGhvdXNlCisJU2lnbmVkLW9mZi1ieTogeW91ckBob3VzZQogCi1BIGxvdCBvZiBob3VzZXMuCi1FT0YKLQljYXQgPmV4cGVjdGVkIDw8XEVPRiAmJgotNDpTdWJqZWN0OiBbUEFUQ0hdIHN1YmplY3QKLTg6Ci05OlNpZ25lZC1vZmYtYnk6IG15QGhvdXNlCi0xMDpTaWduZWQtb2ZmLWJ5OiB5b3VyQGhvdXNlCi0xMToKLTEzOgotMTQ6U2lnbmVkLW9mZi1ieTogQyBPIE1pdHRlciA8Y29tbWl0dGVyQGV4YW1wbGUuY29tPgotRU9GCi0JdGVzdF9jbXAgZXhwZWN0ZWQgYWN0dWFsCisJQSBsb3Qgb2YgaG91c2VzLgorCUVPRgorCWNhdCA+ZXhwZWN0IDw8LVxFT0YgJiYKKwk0OlN1YmplY3Q6IFtQQVRDSF0gc3ViamVjdAorCTg6CisJOTpTaWduZWQtb2ZmLWJ5OiBteUBob3VzZQorCTEwOlNpZ25lZC1vZmYtYnk6IHlvdXJAaG91c2UKKwkxMToKKwkxMzoKKwkxNDpTaWduZWQtb2ZmLWJ5OiBDIE8gTWl0dGVyIDxjb21taXR0ZXJAZXhhbXBsZS5jb20+CisJRU9GCisJdGVzdF9jbXAgZXhwZWN0IGFjdHVhbAogJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdzaWdub2ZmOiB0aGUgc2FtZSBzaWdub2ZmIGF0IHRoZSBlbmQnICcKLQlhcHBlbmRfc2lnbm9mZiA8PFxFT0YgPmFjdHVhbCAmJgotc3ViamVjdAorCWFwcGVuZF9zaWdub2ZmIDw8LVxFT0YgPmFjdHVhbCAmJgorCXN1YmplY3QKIAotYm9keQorCWJvZHkKIAotU2lnbmVkLW9mZi1ieTogQyBPIE1pdHRlciA8Y29tbWl0dGVyQGV4YW1wbGUuY29tPgotRU9GCi0JY2F0ID5leHBlY3RlZCA8PFxFT0YgJiYKLTQ6U3ViamVjdDogW1BBVENIXSBzdWJqZWN0Ci04OgotMTA6Ci0xMTpTaWduZWQtb2ZmLWJ5OiBDIE8gTWl0dGVyIDxjb21taXR0ZXJAZXhhbXBsZS5jb20+Ci1FT0YKLQl0ZXN0X2NtcCBleHBlY3RlZCBhY3R1YWwKKwlTaWduZWQtb2ZmLWJ5OiBDIE8gTWl0dGVyIDxjb21taXR0ZXJAZXhhbXBsZS5jb20+CisJRU9GCisJY2F0ID5leHBlY3QgPDwtXEVPRiAmJgorCTQ6U3ViamVjdDogW1BBVENIXSBzdWJqZWN0CisJODoKKwkxMDoKKwkxMTpTaWduZWQtb2ZmLWJ5OiBDIE8gTWl0dGVyIDxjb21taXR0ZXJAZXhhbXBsZS5jb20+CisJRU9GCisJdGVzdF9jbXAgZXhwZWN0IGFjdHVhbAogJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdzaWdub2ZmOiB0aGUgc2FtZSBzaWdub2ZmIGF0IHRoZSBlbmQsIG5vIHRyYWlsaW5nIE5MJyAnCiAJcHJpbnRmICJzdWJqZWN0XG5cblNpZ25lZC1vZmYtYnk6IEMgTyBNaXR0ZXIgPGNvbW1pdHRlckBleGFtcGxlLmNvbT4iIHwKIAkJYXBwZW5kX3NpZ25vZmYgPmFjdHVhbCAmJgotCWNhdCA+ZXhwZWN0ZWQgPDxcRU9GICYmCi00OlN1YmplY3Q6IFtQQVRDSF0gc3ViamVjdAotODoKLTk6U2lnbmVkLW9mZi1ieTogQyBPIE1pdHRlciA8Y29tbWl0dGVyQGV4YW1wbGUuY29tPgotRU9GCi0JdGVzdF9jbXAgZXhwZWN0ZWQgYWN0dWFsCisJY2F0ID5leHBlY3QgPDwtXEVPRiAmJgorCTQ6U3ViamVjdDogW1BBVENIXSBzdWJqZWN0CisJODoKKwk5OlNpZ25lZC1vZmYtYnk6IEMgTyBNaXR0ZXIgPGNvbW1pdHRlckBleGFtcGxlLmNvbT4KKwlFT0YKKwl0ZXN0X2NtcCBleHBlY3QgYWN0dWFsCiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3NpZ25vZmY6IHRoZSBzYW1lIHNpZ25vZmYgTk9UIGF0IHRoZSBlbmQnICcKLQlhcHBlbmRfc2lnbm9mZiA8PFxFT0YgPmFjdHVhbCAmJgotc3ViamVjdAorCWFwcGVuZF9zaWdub2ZmIDw8LVxFT0YgPmFjdHVhbCAmJgorCXN1YmplY3QKIAotYm9keQorCWJvZHkKIAotU2lnbmVkLW9mZi1ieTogQyBPIE1pdHRlciA8Y29tbWl0dGVyQGV4YW1wbGUuY29tPgotU2lnbmVkLW9mZi1ieTogbXlAaG91c2UKLUVPRgotCWNhdCA+ZXhwZWN0ZWQgPDxcRU9GICYmCi00OlN1YmplY3Q6IFtQQVRDSF0gc3ViamVjdAotODoKLTEwOgotMTE6U2lnbmVkLW9mZi1ieTogQyBPIE1pdHRlciA8Y29tbWl0dGVyQGV4YW1wbGUuY29tPgotMTI6U2lnbmVkLW9mZi1ieTogbXlAaG91c2UKLUVPRgotCXRlc3RfY21wIGV4cGVjdGVkIGFjdHVhbAorCVNpZ25lZC1vZmYtYnk6IEMgTyBNaXR0ZXIgPGNvbW1pdHRlckBleGFtcGxlLmNvbT4KKwlTaWduZWQtb2ZmLWJ5OiBteUBob3VzZQorCUVPRgorCWNhdCA+ZXhwZWN0IDw8LVxFT0YgJiYKKwk0OlN1YmplY3Q6IFtQQVRDSF0gc3ViamVjdAorCTg6CisJMTA6CisJMTE6U2lnbmVkLW9mZi1ieTogQyBPIE1pdHRlciA8Y29tbWl0dGVyQGV4YW1wbGUuY29tPgorCTEyOlNpZ25lZC1vZmYtYnk6IG15QGhvdXNlCisJRU9GCisJdGVzdF9jbXAgZXhwZWN0IGFjdHVhbAogJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdzaWdub2ZmOiB0b2xlcmF0ZSBnYXJiYWdlIGluIGNvbmZvcm1pbmcgZm9vdGVyJyAnCi0JYXBwZW5kX3NpZ25vZmYgPDxcRU9GID5hY3R1YWwgJiYKLXN1YmplY3QKKwlhcHBlbmRfc2lnbm9mZiA8PC1cRU9GID5hY3R1YWwgJiYKKwlzdWJqZWN0CiAKLWJvZHkKKwlib2R5CiAKLVRlc3RlZC1ieTogbXlAaG91c2UKLVNvbWUgVHJhc2gKLVNpZ25lZC1vZmYtYnk6IEMgTyBNaXR0ZXIgPGNvbW1pdHRlckBleGFtcGxlLmNvbT4KLUVPRgotCWNhdCA+ZXhwZWN0ZWQgPDxcRU9GICYmCi00OlN1YmplY3Q6IFtQQVRDSF0gc3ViamVjdAotODoKLTEwOgotMTM6U2lnbmVkLW9mZi1ieTogQyBPIE1pdHRlciA8Y29tbWl0dGVyQGV4YW1wbGUuY29tPgotRU9GCi0JdGVzdF9jbXAgZXhwZWN0ZWQgYWN0dWFsCisJVGVzdGVkLWJ5OiBteUBob3VzZQorCVNvbWUgVHJhc2gKKwlTaWduZWQtb2ZmLWJ5OiBDIE8gTWl0dGVyIDxjb21taXR0ZXJAZXhhbXBsZS5jb20+CisJRU9GCisJY2F0ID5leHBlY3QgPDwtXEVPRiAmJgorCTQ6U3ViamVjdDogW1BBVENIXSBzdWJqZWN0CisJODoKKwkxMDoKKwkxMzpTaWduZWQtb2ZmLWJ5OiBDIE8gTWl0dGVyIDxjb21taXR0ZXJAZXhhbXBsZS5jb20+CisJRU9GCisJdGVzdF9jbXAgZXhwZWN0IGFjdHVhbAogJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdzaWdub2ZmOiByZXNwZWN0IHRyYWlsZXIgY29uZmlnJyAnCi0JYXBwZW5kX3NpZ25vZmYgPDxcRU9GID5hY3R1YWwgJiYKLXN1YmplY3QKKwlhcHBlbmRfc2lnbm9mZiA8PC1cRU9GID5hY3R1YWwgJiYKKwlzdWJqZWN0CiAKLU15Zm9vdGVyOiB4Ci1Tb21lIFRyYXNoCi1FT0YKLQljYXQgPmV4cGVjdGVkIDw8XEVPRiAmJgotNDpTdWJqZWN0OiBbUEFUQ0hdIHN1YmplY3QKLTg6Ci0xMToKLTEyOlNpZ25lZC1vZmYtYnk6IEMgTyBNaXR0ZXIgPGNvbW1pdHRlckBleGFtcGxlLmNvbT4KLUVPRgotCXRlc3RfY21wIGV4cGVjdGVkIGFjdHVhbCAmJgorCU15Zm9vdGVyOiB4CisJU29tZSBUcmFzaAorCUVPRgorCWNhdCA+ZXhwZWN0IDw8LVxFT0YgJiYKKwk0OlN1YmplY3Q6IFtQQVRDSF0gc3ViamVjdAorCTg6CisJMTE6CisJMTI6U2lnbmVkLW9mZi1ieTogQyBPIE1pdHRlciA8Y29tbWl0dGVyQGV4YW1wbGUuY29tPgorCUVPRgorCXRlc3RfY21wIGV4cGVjdCBhY3R1YWwgJiYKIAogCXRlc3RfY29uZmlnIHRyYWlsZXIuTXlmb290ZXIuaWZleGlzdHMgYWRkICYmCi0JYXBwZW5kX3NpZ25vZmYgPDxcRU9GID5hY3R1YWwgJiYKLXN1YmplY3QKKwlhcHBlbmRfc2lnbm9mZiA8PC1cRU9GID5hY3R1YWwgJiYKKwlzdWJqZWN0CiAKLU15Zm9vdGVyOiB4Ci1Tb21lIFRyYXNoCi1FT0YKLQljYXQgPmV4cGVjdGVkIDw8XEVPRiAmJgotNDpTdWJqZWN0OiBbUEFUQ0hdIHN1YmplY3QKLTg6Ci0xMTpTaWduZWQtb2ZmLWJ5OiBDIE8gTWl0dGVyIDxjb21taXR0ZXJAZXhhbXBsZS5jb20+Ci1FT0YKLQl0ZXN0X2NtcCBleHBlY3RlZCBhY3R1YWwKKwlNeWZvb3RlcjogeAorCVNvbWUgVHJhc2gKKwlFT0YKKwljYXQgPmV4cGVjdCA8PC1cRU9GICYmCisJNDpTdWJqZWN0OiBbUEFUQ0hdIHN1YmplY3QKKwk4OgorCTExOlNpZ25lZC1vZmYtYnk6IEMgTyBNaXR0ZXIgPGNvbW1pdHRlckBleGFtcGxlLmNvbT4KKwlFT0YKKwl0ZXN0X2NtcCBleHBlY3QgYWN0dWFsCiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3NpZ25vZmY6IGZvb3RlciBiZWdpbnMgd2l0aCBub24tc2lnbm9mZiB3aXRob3V0IEAgc2lnbicgJwotCWFwcGVuZF9zaWdub2ZmIDw8XEVPRiA+YWN0dWFsICYmCi1zdWJqZWN0CisJYXBwZW5kX3NpZ25vZmYgPDwtXEVPRiA+YWN0dWFsICYmCisJc3ViamVjdAogCi1ib2R5CisJYm9keQogCi1SZXZpZXdlZC1pZDogTm9vbmUKLVRlc3RlZC1ieTogbXlAaG91c2UKLUNoYW5nZS1pZDogSWRlYWRiZWVmCi1TaWduZWQtb2ZmLWJ5OiBDIE8gTWl0dGVyIDxjb21taXR0ZXJAZXhhbXBsZS5jb20+Ci1CdWc6IDEyMzQKLUVPRgotCWNhdCA+ZXhwZWN0ZWQgPDxcRU9GICYmCi00OlN1YmplY3Q6IFtQQVRDSF0gc3ViamVjdAotODoKLTEwOgotMTQ6U2lnbmVkLW9mZi1ieTogQyBPIE1pdHRlciA8Y29tbWl0dGVyQGV4YW1wbGUuY29tPgotRU9GCi0JdGVzdF9jbXAgZXhwZWN0ZWQgYWN0dWFsCisJUmV2aWV3ZWQtaWQ6IE5vb25lCisJVGVzdGVkLWJ5OiBteUBob3VzZQorCUNoYW5nZS1pZDogSWRlYWRiZWVmCisJU2lnbmVkLW9mZi1ieTogQyBPIE1pdHRlciA8Y29tbWl0dGVyQGV4YW1wbGUuY29tPgorCUJ1ZzogMTIzNAorCUVPRgorCWNhdCA+ZXhwZWN0IDw8LVxFT0YgJiYKKwk0OlN1YmplY3Q6IFtQQVRDSF0gc3ViamVjdAorCTg6CisJMTA6CisJMTQ6U2lnbmVkLW9mZi1ieTogQyBPIE1pdHRlciA8Y29tbWl0dGVyQGV4YW1wbGUuY29tPgorCUVPRgorCXRlc3RfY21wIGV4cGVjdCBhY3R1YWwKICcKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnZm9ybWF0IHBhdGNoIGlnbm9yZXMgY29sb3IudWknICcKQEAgLTE1NDMsNDYgKzE1MTcsMjE4IEBACiAJdGVzdF9jbXAgZXhwZWN0IGFjdHVhbAogJwogCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdjb3ZlciBsZXR0ZXIgd2l0aCBpbnZhbGlkIC0tY292ZXItZnJvbS1kZXNjcmlwdGlvbiBhbmQgY29uZmlnJyAnCisJdGVzdF9jb25maWcgYnJhbmNoLnJlYnVpbGQtMS5kZXNjcmlwdGlvbiAiY29uZmlnIHN1YmplY3QKKworYm9keSIgJiYKKwl0ZXN0X211c3RfZmFpbCBnaXQgZm9ybWF0LXBhdGNoIC0tY292ZXItbGV0dGVyIC0tY292ZXItZnJvbS1kZXNjcmlwdGlvbiBnYXJiYWdlIG1hc3RlciAmJgorCXRlc3RfY29uZmlnIGZvcm1hdC5jb3ZlckZyb21EZXNjcmlwdGlvbiBnYXJiYWdlICYmCisJdGVzdF9tdXN0X2ZhaWwgZ2l0IGZvcm1hdC1wYXRjaCAtLWNvdmVyLWxldHRlciBtYXN0ZXIKKycKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAnY292ZXIgbGV0dGVyIHdpdGggZm9ybWF0LmNvdmVyRnJvbURlc2NyaXB0aW9uID0gZGVmYXVsdCcgJworCXRlc3RfY29uZmlnIGJyYW5jaC5yZWJ1aWxkLTEuZGVzY3JpcHRpb24gImNvbmZpZyBzdWJqZWN0CisKK2JvZHkiICYmCisJdGVzdF9jb25maWcgZm9ybWF0LmNvdmVyRnJvbURlc2NyaXB0aW9uIGRlZmF1bHQgJiYKKwlnaXQgY2hlY2tvdXQgcmVidWlsZC0xICYmCisJZ2l0IGZvcm1hdC1wYXRjaCAtLXN0ZG91dCAtLWNvdmVyLWxldHRlciBtYXN0ZXIgPmFjdHVhbCAmJgorCWdyZXAgIl5TdWJqZWN0OiBcW1BBVENIIDAvMlxdIFwqXCpcKiBTVUJKRUNUIEhFUkUgXCpcKlwqJCIgYWN0dWFsICYmCisJISBncmVwICJeXCpcKlwqIEJMVVJCIEhFUkUgXCpcKlwqJCIgYWN0dWFsICYmCisJZ3JlcCAiXmNvbmZpZyBzdWJqZWN0JCIgYWN0dWFsICYmCisJZ3JlcCAiXmJvZHkkIiBhY3R1YWwKKycKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAnY292ZXIgbGV0dGVyIHdpdGggLS1jb3Zlci1mcm9tLWRlc2NyaXB0aW9uIGRlZmF1bHQnICcKKwl0ZXN0X2NvbmZpZyBicmFuY2gucmVidWlsZC0xLmRlc2NyaXB0aW9uICJjb25maWcgc3ViamVjdAorCitib2R5IiAmJgorCWdpdCBjaGVja291dCByZWJ1aWxkLTEgJiYKKwlnaXQgZm9ybWF0LXBhdGNoIC0tc3Rkb3V0IC0tY292ZXItbGV0dGVyIC0tY292ZXItZnJvbS1kZXNjcmlwdGlvbiBkZWZhdWx0IG1hc3RlciA+YWN0dWFsICYmCisJZ3JlcCAiXlN1YmplY3Q6IFxbUEFUQ0ggMC8yXF0gXCpcKlwqIFNVQkpFQ1QgSEVSRSBcKlwqXCokIiBhY3R1YWwgJiYKKwkhIGdyZXAgIl5cKlwqXCogQkxVUkIgSEVSRSBcKlwqXCokIiBhY3R1YWwgJiYKKwlncmVwICJeY29uZmlnIHN1YmplY3QkIiBhY3R1YWwgJiYKKwlncmVwICJeYm9keSQiIGFjdHVhbAorJworCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdjb3ZlciBsZXR0ZXIgd2l0aCBmb3JtYXQuY292ZXJGcm9tRGVzY3JpcHRpb24gPSBub25lJyAnCisJdGVzdF9jb25maWcgYnJhbmNoLnJlYnVpbGQtMS5kZXNjcmlwdGlvbiAiY29uZmlnIHN1YmplY3QKKworYm9keSIgJiYKKwl0ZXN0X2NvbmZpZyBmb3JtYXQuY292ZXJGcm9tRGVzY3JpcHRpb24gbm9uZSAmJgorCWdpdCBjaGVja291dCByZWJ1aWxkLTEgJiYKKwlnaXQgZm9ybWF0LXBhdGNoIC0tc3Rkb3V0IC0tY292ZXItbGV0dGVyIG1hc3RlciA+YWN0dWFsICYmCisJZ3JlcCAiXlN1YmplY3Q6IFxbUEFUQ0ggMC8yXF0gXCpcKlwqIFNVQkpFQ1QgSEVSRSBcKlwqXCokIiBhY3R1YWwgJiYKKwlncmVwICJeXCpcKlwqIEJMVVJCIEhFUkUgXCpcKlwqJCIgYWN0dWFsICYmCisJISBncmVwICJeY29uZmlnIHN1YmplY3QkIiBhY3R1YWwgJiYKKwkhIGdyZXAgIl5ib2R5JCIgYWN0dWFsCisnCisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2NvdmVyIGxldHRlciB3aXRoIC0tY292ZXItZnJvbS1kZXNjcmlwdGlvbiBub25lJyAnCisJdGVzdF9jb25maWcgYnJhbmNoLnJlYnVpbGQtMS5kZXNjcmlwdGlvbiAiY29uZmlnIHN1YmplY3QKKworYm9keSIgJiYKKwlnaXQgY2hlY2tvdXQgcmVidWlsZC0xICYmCisJZ2l0IGZvcm1hdC1wYXRjaCAtLXN0ZG91dCAtLWNvdmVyLWxldHRlciAtLWNvdmVyLWZyb20tZGVzY3JpcHRpb24gbm9uZSBtYXN0ZXIgPmFjdHVhbCAmJgorCWdyZXAgIl5TdWJqZWN0OiBcW1BBVENIIDAvMlxdIFwqXCpcKiBTVUJKRUNUIEhFUkUgXCpcKlwqJCIgYWN0dWFsICYmCisJZ3JlcCAiXlwqXCpcKiBCTFVSQiBIRVJFIFwqXCpcKiQiIGFjdHVhbCAmJgorCSEgZ3JlcCAiXmNvbmZpZyBzdWJqZWN0JCIgYWN0dWFsICYmCisJISBncmVwICJeYm9keSQiIGFjdHVhbAorJworCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdjb3ZlciBsZXR0ZXIgd2l0aCBmb3JtYXQuY292ZXJGcm9tRGVzY3JpcHRpb24gPSBtZXNzYWdlJyAnCisJdGVzdF9jb25maWcgYnJhbmNoLnJlYnVpbGQtMS5kZXNjcmlwdGlvbiAiY29uZmlnIHN1YmplY3QKKworYm9keSIgJiYKKwl0ZXN0X2NvbmZpZyBmb3JtYXQuY292ZXJGcm9tRGVzY3JpcHRpb24gbWVzc2FnZSAmJgorCWdpdCBjaGVja291dCByZWJ1aWxkLTEgJiYKKwlnaXQgZm9ybWF0LXBhdGNoIC0tc3Rkb3V0IC0tY292ZXItbGV0dGVyIG1hc3RlciA+YWN0dWFsICYmCisJZ3JlcCAiXlN1YmplY3Q6IFxbUEFUQ0ggMC8yXF0gXCpcKlwqIFNVQkpFQ1QgSEVSRSBcKlwqXCokIiBhY3R1YWwgJiYKKwkhIGdyZXAgIl5cKlwqXCogQkxVUkIgSEVSRSBcKlwqXCokIiBhY3R1YWwgJiYKKwlncmVwICJeY29uZmlnIHN1YmplY3QkIiBhY3R1YWwgJiYKKwlncmVwICJeYm9keSQiIGFjdHVhbAorJworCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdjb3ZlciBsZXR0ZXIgd2l0aCAtLWNvdmVyLWZyb20tZGVzY3JpcHRpb24gbWVzc2FnZScgJworCXRlc3RfY29uZmlnIGJyYW5jaC5yZWJ1aWxkLTEuZGVzY3JpcHRpb24gImNvbmZpZyBzdWJqZWN0CisKK2JvZHkiICYmCisJZ2l0IGNoZWNrb3V0IHJlYnVpbGQtMSAmJgorCWdpdCBmb3JtYXQtcGF0Y2ggLS1zdGRvdXQgLS1jb3Zlci1sZXR0ZXIgLS1jb3Zlci1mcm9tLWRlc2NyaXB0aW9uIG1lc3NhZ2UgbWFzdGVyID5hY3R1YWwgJiYKKwlncmVwICJeU3ViamVjdDogXFtQQVRDSCAwLzJcXSBcKlwqXCogU1VCSkVDVCBIRVJFIFwqXCpcKiQiIGFjdHVhbCAmJgorCSEgZ3JlcCAiXlwqXCpcKiBCTFVSQiBIRVJFIFwqXCpcKiQiIGFjdHVhbCAmJgorCWdyZXAgIl5jb25maWcgc3ViamVjdCQiIGFjdHVhbCAmJgorCWdyZXAgIl5ib2R5JCIgYWN0dWFsCisnCisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2NvdmVyIGxldHRlciB3aXRoIGZvcm1hdC5jb3ZlckZyb21EZXNjcmlwdGlvbiA9IHN1YmplY3QnICcKKwl0ZXN0X2NvbmZpZyBicmFuY2gucmVidWlsZC0xLmRlc2NyaXB0aW9uICJjb25maWcgc3ViamVjdAorCitib2R5IiAmJgorCXRlc3RfY29uZmlnIGZvcm1hdC5jb3ZlckZyb21EZXNjcmlwdGlvbiBzdWJqZWN0ICYmCisJZ2l0IGNoZWNrb3V0IHJlYnVpbGQtMSAmJgorCWdpdCBmb3JtYXQtcGF0Y2ggLS1zdGRvdXQgLS1jb3Zlci1sZXR0ZXIgbWFzdGVyID5hY3R1YWwgJiYKKwlncmVwICJeU3ViamVjdDogXFtQQVRDSCAwLzJcXSBjb25maWcgc3ViamVjdCQiIGFjdHVhbCAmJgorCSEgZ3JlcCAiXlwqXCpcKiBCTFVSQiBIRVJFIFwqXCpcKiQiIGFjdHVhbCAmJgorCSEgZ3JlcCAiXmNvbmZpZyBzdWJqZWN0JCIgYWN0dWFsICYmCisJZ3JlcCAiXmJvZHkkIiBhY3R1YWwKKycKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAnY292ZXIgbGV0dGVyIHdpdGggLS1jb3Zlci1mcm9tLWRlc2NyaXB0aW9uIHN1YmplY3QnICcKKwl0ZXN0X2NvbmZpZyBicmFuY2gucmVidWlsZC0xLmRlc2NyaXB0aW9uICJjb25maWcgc3ViamVjdAorCitib2R5IiAmJgorCWdpdCBjaGVja291dCByZWJ1aWxkLTEgJiYKKwlnaXQgZm9ybWF0LXBhdGNoIC0tc3Rkb3V0IC0tY292ZXItbGV0dGVyIC0tY292ZXItZnJvbS1kZXNjcmlwdGlvbiBzdWJqZWN0IG1hc3RlciA+YWN0dWFsICYmCisJZ3JlcCAiXlN1YmplY3Q6IFxbUEFUQ0ggMC8yXF0gY29uZmlnIHN1YmplY3QkIiBhY3R1YWwgJiYKKwkhIGdyZXAgIl5cKlwqXCogQkxVUkIgSEVSRSBcKlwqXCokIiBhY3R1YWwgJiYKKwkhIGdyZXAgIl5jb25maWcgc3ViamVjdCQiIGFjdHVhbCAmJgorCWdyZXAgIl5ib2R5JCIgYWN0dWFsCisnCisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2NvdmVyIGxldHRlciB3aXRoIGZvcm1hdC5jb3ZlckZyb21EZXNjcmlwdGlvbiA9IGF1dG8gKHNob3J0IHN1YmplY3QgbGluZSknICcKKwl0ZXN0X2NvbmZpZyBicmFuY2gucmVidWlsZC0xLmRlc2NyaXB0aW9uICJjb25maWcgc3ViamVjdAorCitib2R5IiAmJgorCXRlc3RfY29uZmlnIGZvcm1hdC5jb3ZlckZyb21EZXNjcmlwdGlvbiBhdXRvICYmCisJZ2l0IGNoZWNrb3V0IHJlYnVpbGQtMSAmJgorCWdpdCBmb3JtYXQtcGF0Y2ggLS1zdGRvdXQgLS1jb3Zlci1sZXR0ZXIgbWFzdGVyID5hY3R1YWwgJiYKKwlncmVwICJeU3ViamVjdDogXFtQQVRDSCAwLzJcXSBjb25maWcgc3ViamVjdCQiIGFjdHVhbCAmJgorCSEgZ3JlcCAiXlwqXCpcKiBCTFVSQiBIRVJFIFwqXCpcKiQiIGFjdHVhbCAmJgorCSEgZ3JlcCAiXmNvbmZpZyBzdWJqZWN0JCIgYWN0dWFsICYmCisJZ3JlcCAiXmJvZHkkIiBhY3R1YWwKKycKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAnY292ZXIgbGV0dGVyIHdpdGggLS1jb3Zlci1mcm9tLWRlc2NyaXB0aW9uIGF1dG8gKHNob3J0IHN1YmplY3QgbGluZSknICcKKwl0ZXN0X2NvbmZpZyBicmFuY2gucmVidWlsZC0xLmRlc2NyaXB0aW9uICJjb25maWcgc3ViamVjdAorCitib2R5IiAmJgorCWdpdCBjaGVja291dCByZWJ1aWxkLTEgJiYKKwlnaXQgZm9ybWF0LXBhdGNoIC0tc3Rkb3V0IC0tY292ZXItbGV0dGVyIC0tY292ZXItZnJvbS1kZXNjcmlwdGlvbiBhdXRvIG1hc3RlciA+YWN0dWFsICYmCisJZ3JlcCAiXlN1YmplY3Q6IFxbUEFUQ0ggMC8yXF0gY29uZmlnIHN1YmplY3QkIiBhY3R1YWwgJiYKKwkhIGdyZXAgIl5cKlwqXCogQkxVUkIgSEVSRSBcKlwqXCokIiBhY3R1YWwgJiYKKwkhIGdyZXAgIl5jb25maWcgc3ViamVjdCQiIGFjdHVhbCAmJgorCWdyZXAgIl5ib2R5JCIgYWN0dWFsCisnCisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2NvdmVyIGxldHRlciB3aXRoIGZvcm1hdC5jb3ZlckZyb21EZXNjcmlwdGlvbiA9IGF1dG8gKGxvbmcgc3ViamVjdCBsaW5lKScgJworCXRlc3RfY29uZmlnIGJyYW5jaC5yZWJ1aWxkLTEuZGVzY3JpcHRpb24gInRoaXMgaXMgYSByZWFsbHkgbG9uZyBmaXJzdCBsaW5lIGFuZCBpdCBpcyBvdmVyIDEwMCBjaGFyYWN0ZXJzIGxvbmcgd2hpY2ggaXMgdGhlIHRocmVzaG9sZCBmb3IgbG9uZyBzdWJqZWN0cworCitib2R5IiAmJgorCXRlc3RfY29uZmlnIGZvcm1hdC5jb3ZlckZyb21EZXNjcmlwdGlvbiBhdXRvICYmCisJZ2l0IGNoZWNrb3V0IHJlYnVpbGQtMSAmJgorCWdpdCBmb3JtYXQtcGF0Y2ggLS1zdGRvdXQgLS1jb3Zlci1sZXR0ZXIgbWFzdGVyID5hY3R1YWwgJiYKKwlncmVwICJeU3ViamVjdDogXFtQQVRDSCAwLzJcXSBcKlwqXCogU1VCSkVDVCBIRVJFIFwqXCpcKiQiIGFjdHVhbCAmJgorCSEgZ3JlcCAiXlwqXCpcKiBCTFVSQiBIRVJFIFwqXCpcKiQiIGFjdHVhbCAmJgorCWdyZXAgIl50aGlzIGlzIGEgcmVhbGx5IGxvbmcgZmlyc3QgbGluZSBhbmQgaXQgaXMgb3ZlciAxMDAgY2hhcmFjdGVycyBsb25nIHdoaWNoIGlzIHRoZSB0aHJlc2hvbGQgZm9yIGxvbmcgc3ViamVjdHMkIiBhY3R1YWwgJiYKKwlncmVwICJeYm9keSQiIGFjdHVhbAorJworCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdjb3ZlciBsZXR0ZXIgd2l0aCAtLWNvdmVyLWZyb20tZGVzY3JpcHRpb24gYXV0byAobG9uZyBzdWJqZWN0IGxpbmUpJyAnCisJdGVzdF9jb25maWcgYnJhbmNoLnJlYnVpbGQtMS5kZXNjcmlwdGlvbiAidGhpcyBpcyBhIHJlYWxseSBsb25nIGZpcnN0IGxpbmUgYW5kIGl0IGlzIG92ZXIgMTAwIGNoYXJhY3RlcnMgbG9uZyB3aGljaCBpcyB0aGUgdGhyZXNob2xkIGZvciBsb25nIHN1YmplY3RzCisKK2JvZHkiICYmCisJZ2l0IGNoZWNrb3V0IHJlYnVpbGQtMSAmJgorCWdpdCBmb3JtYXQtcGF0Y2ggLS1zdGRvdXQgLS1jb3Zlci1sZXR0ZXIgLS1jb3Zlci1mcm9tLWRlc2NyaXB0aW9uIGF1dG8gbWFzdGVyID5hY3R1YWwgJiYKKwlncmVwICJeU3ViamVjdDogXFtQQVRDSCAwLzJcXSBcKlwqXCogU1VCSkVDVCBIRVJFIFwqXCpcKiQiIGFjdHVhbCAmJgorCSEgZ3JlcCAiXlwqXCpcKiBCTFVSQiBIRVJFIFwqXCpcKiQiIGFjdHVhbCAmJgorCWdyZXAgIl50aGlzIGlzIGEgcmVhbGx5IGxvbmcgZmlyc3QgbGluZSBhbmQgaXQgaXMgb3ZlciAxMDAgY2hhcmFjdGVycyBsb25nIHdoaWNoIGlzIHRoZSB0aHJlc2hvbGQgZm9yIGxvbmcgc3ViamVjdHMkIiBhY3R1YWwgJiYKKwlncmVwICJeYm9keSQiIGFjdHVhbAorJworCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdjb3ZlciBsZXR0ZXIgd2l0aCBjb21tYW5kLWxpbmUgLS1jb3Zlci1mcm9tLWRlc2NyaXB0aW9uIG92ZXJyaWRlcyBjb25maWcnICcKKwl0ZXN0X2NvbmZpZyBicmFuY2gucmVidWlsZC0xLmRlc2NyaXB0aW9uICJjb25maWcgc3ViamVjdAorCitib2R5IiAmJgorCXRlc3RfY29uZmlnIGZvcm1hdC5jb3ZlckZyb21EZXNjcmlwdGlvbiBub25lICYmCisJZ2l0IGNoZWNrb3V0IHJlYnVpbGQtMSAmJgorCWdpdCBmb3JtYXQtcGF0Y2ggLS1zdGRvdXQgLS1jb3Zlci1sZXR0ZXIgLS1jb3Zlci1mcm9tLWRlc2NyaXB0aW9uIHN1YmplY3QgbWFzdGVyID5hY3R1YWwgJiYKKwlncmVwICJeU3ViamVjdDogXFtQQVRDSCAwLzJcXSBjb25maWcgc3ViamVjdCQiIGFjdHVhbCAmJgorCSEgZ3JlcCAiXlwqXCpcKiBCTFVSQiBIRVJFIFwqXCpcKiQiIGFjdHVhbCAmJgorCSEgZ3JlcCAiXmNvbmZpZyBzdWJqZWN0JCIgYWN0dWFsICYmCisJZ3JlcCAiXmJvZHkkIiBhY3R1YWwKKycKKwogdGVzdF9leHBlY3Rfc3VjY2VzcyAnY292ZXIgbGV0dGVyIHVzaW5nIGJyYW5jaCBkZXNjcmlwdGlvbiAoMSknICcKIAlnaXQgY2hlY2tvdXQgcmVidWlsZC0xICYmCiAJdGVzdF9jb25maWcgYnJhbmNoLnJlYnVpbGQtMS5kZXNjcmlwdGlvbiBoZWxsbyAmJgogCWdpdCBmb3JtYXQtcGF0Y2ggLS1zdGRvdXQgLS1jb3Zlci1sZXR0ZXIgbWFzdGVyID5hY3R1YWwgJiYKLQlncmVwIGhlbGxvIGFjdHVhbCA+L2Rldi9udWxsCisJZ3JlcCBoZWxsbyBhY3R1YWwKICcKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnY292ZXIgbGV0dGVyIHVzaW5nIGJyYW5jaCBkZXNjcmlwdGlvbiAoMiknICcKIAlnaXQgY2hlY2tvdXQgcmVidWlsZC0xICYmCiAJdGVzdF9jb25maWcgYnJhbmNoLnJlYnVpbGQtMS5kZXNjcmlwdGlvbiBoZWxsbyAmJgogCWdpdCBmb3JtYXQtcGF0Y2ggLS1zdGRvdXQgLS1jb3Zlci1sZXR0ZXIgcmVidWlsZC0xfjIuLnJlYnVpbGQtMSA+YWN0dWFsICYmCi0JZ3JlcCBoZWxsbyBhY3R1YWwgPi9kZXYvbnVsbAorCWdyZXAgaGVsbG8gYWN0dWFsCiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2NvdmVyIGxldHRlciB1c2luZyBicmFuY2ggZGVzY3JpcHRpb24gKDMpJyAnCiAJZ2l0IGNoZWNrb3V0IHJlYnVpbGQtMSAmJgogCXRlc3RfY29uZmlnIGJyYW5jaC5yZWJ1aWxkLTEuZGVzY3JpcHRpb24gaGVsbG8gJiYKIAlnaXQgZm9ybWF0LXBhdGNoIC0tc3Rkb3V0IC0tY292ZXItbGV0dGVyIF5tYXN0ZXIgcmVidWlsZC0xID5hY3R1YWwgJiYKLQlncmVwIGhlbGxvIGFjdHVhbCA+L2Rldi9udWxsCisJZ3JlcCBoZWxsbyBhY3R1YWwKICcKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnY292ZXIgbGV0dGVyIHVzaW5nIGJyYW5jaCBkZXNjcmlwdGlvbiAoNCknICcKIAlnaXQgY2hlY2tvdXQgcmVidWlsZC0xICYmCiAJdGVzdF9jb25maWcgYnJhbmNoLnJlYnVpbGQtMS5kZXNjcmlwdGlvbiBoZWxsbyAmJgogCWdpdCBmb3JtYXQtcGF0Y2ggLS1zdGRvdXQgLS1jb3Zlci1sZXR0ZXIgbWFzdGVyLi4gPmFjdHVhbCAmJgotCWdyZXAgaGVsbG8gYWN0dWFsID4vZGV2L251bGwKKwlncmVwIGhlbGxvIGFjdHVhbAogJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdjb3ZlciBsZXR0ZXIgdXNpbmcgYnJhbmNoIGRlc2NyaXB0aW9uICg1KScgJwogCWdpdCBjaGVja291dCByZWJ1aWxkLTEgJiYKIAl0ZXN0X2NvbmZpZyBicmFuY2gucmVidWlsZC0xLmRlc2NyaXB0aW9uIGhlbGxvICYmCiAJZ2l0IGZvcm1hdC1wYXRjaCAtLXN0ZG91dCAtLWNvdmVyLWxldHRlciAtMiBIRUFEID5hY3R1YWwgJiYKLQlncmVwIGhlbGxvIGFjdHVhbCA+L2Rldi9udWxsCisJZ3JlcCBoZWxsbyBhY3R1YWwKICcKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnY292ZXIgbGV0dGVyIHVzaW5nIGJyYW5jaCBkZXNjcmlwdGlvbiAoNiknICcKIAlnaXQgY2hlY2tvdXQgcmVidWlsZC0xICYmCiAJdGVzdF9jb25maWcgYnJhbmNoLnJlYnVpbGQtMS5kZXNjcmlwdGlvbiBoZWxsbyAmJgogCWdpdCBmb3JtYXQtcGF0Y2ggLS1zdGRvdXQgLS1jb3Zlci1sZXR0ZXIgLTIgPmFjdHVhbCAmJgotCWdyZXAgaGVsbG8gYWN0dWFsID4vZGV2L251bGwKKwlncmVwIGhlbGxvIGFjdHVhbAogJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdjb3ZlciBsZXR0ZXIgd2l0aCBub3RoaW5nJyAnCkBAIC0xNjMyLDExICsxNzc4LDM5IEBACiAJdGVzdF9jbXAgZnJvbSBmaWx0ZXJlZAogJwogCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdmb3JtYXQtcGF0Y2ggLW8gd2l0aCBubyBsZWFkaW5nIGRpcmVjdG9yaWVzJyAnCisJcm0gLWZyIHBhdGNoZXMgJiYKKwlnaXQgZm9ybWF0LXBhdGNoIC1vIHBhdGNoZXMgbWFzdGVyLi5zaWRlICYmCisJY291bnQ9JChnaXQgcmV2LWxpc3QgLS1jb3VudCBtYXN0ZXIuLnNpZGUpICYmCisJbHMgcGF0Y2hlcyA+bGlzdCAmJgorCXRlc3RfbGluZV9jb3VudCA9ICRjb3VudCBsaXN0CisnCisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2Zvcm1hdC1wYXRjaCAtbyB3aXRoIGxlYWRpbmcgZXhpc3RpbmcgZGlyZWN0b3JpZXMnICcKKwlybSAtcmYgZXhpc3RpbmctZGlyICYmCisJbWtkaXIgZXhpc3RpbmctZGlyICYmCisJZ2l0IGZvcm1hdC1wYXRjaCAtbyBleGlzdGluZy1kaXIvcGF0Y2hlcyBtYXN0ZXIuLnNpZGUgJiYKKwljb3VudD0kKGdpdCByZXYtbGlzdCAtLWNvdW50IG1hc3Rlci4uc2lkZSkgJiYKKwlscyBleGlzdGluZy1kaXIvcGF0Y2hlcyA+bGlzdCAmJgorCXRlc3RfbGluZV9jb3VudCA9ICRjb3VudCBsaXN0CisnCisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2Zvcm1hdC1wYXRjaCAtbyB3aXRoIGxlYWRpbmcgbm9uLWV4aXN0aW5nIGRpcmVjdG9yaWVzJyAnCisJcm0gLXJmIG5vbi1leGlzdGluZy1kaXIgJiYKKwlnaXQgZm9ybWF0LXBhdGNoIC1vIG5vbi1leGlzdGluZy1kaXIvcGF0Y2hlcyBtYXN0ZXIuLnNpZGUgJiYKKwljb3VudD0kKGdpdCByZXYtbGlzdCAtLWNvdW50IG1hc3Rlci4uc2lkZSkgJiYKKwl0ZXN0X3BhdGhfaXNfZGlyIG5vbi1leGlzdGluZy1kaXIgJiYKKwlscyBub24tZXhpc3RpbmctZGlyL3BhdGNoZXMgPmxpc3QgJiYKKwl0ZXN0X2xpbmVfY291bnQgPSAkY291bnQgbGlzdAorJworCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdmb3JtYXQtcGF0Y2ggZm9ybWF0Lm91dHB1dERpcmVjdG9yeSBvcHRpb24nICcKIAl0ZXN0X2NvbmZpZyBmb3JtYXQub3V0cHV0RGlyZWN0b3J5IHBhdGNoZXMgJiYKIAlybSAtZnIgcGF0Y2hlcyAmJgogCWdpdCBmb3JtYXQtcGF0Y2ggbWFzdGVyLi5zaWRlICYmCi0JdGVzdCAkKGdpdCByZXYtbGlzdCBtYXN0ZXIuLnNpZGUgfCB3YyAtbCkgLWVxICQobHMgcGF0Y2hlcyB8IHdjIC1sKQorCWNvdW50PSQoZ2l0IHJldi1saXN0IC0tY291bnQgbWFzdGVyLi5zaWRlKSAmJgorCWxzIHBhdGNoZXMgPmxpc3QgJiYKKwl0ZXN0X2xpbmVfY291bnQgPSAkY291bnQgbGlzdAogJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdmb3JtYXQtcGF0Y2ggLW8gb3ZlcnJpZGVzIGZvcm1hdC5vdXRwdXREaXJlY3RvcnknICcKQEAgLTE2NDksMjAgKzE4MjMsNDEgQEAKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnZm9ybWF0LXBhdGNoIC0tYmFzZScgJwogCWdpdCBjaGVja291dCBwYXRjaGlkICYmCi0JZ2l0IGZvcm1hdC1wYXRjaCAtLXN0ZG91dCAtLWJhc2U9SEVBRH4zIC0xIHwgdGFpbCAtbiA3ID5hY3R1YWwxICYmCi0JZ2l0IGZvcm1hdC1wYXRjaCAtLXN0ZG91dCAtLWJhc2U9SEVBRH4zIEhFQUR+Li4gfCB0YWlsIC1uIDcgPmFjdHVhbDIgJiYKLQllY2hvID5leHBlY3RlZCAmJgotCWVjaG8gImJhc2UtY29tbWl0OiAkKGdpdCByZXYtcGFyc2UgSEVBRH4zKSIgPj5leHBlY3RlZCAmJgotCWVjaG8gInByZXJlcXVpc2l0ZS1wYXRjaC1pZDogJChnaXQgc2hvdyAtLXBhdGNoIEhFQUR+MiB8IGdpdCBwYXRjaC1pZCAtLXN0YWJsZSB8IGF3ayAie3ByaW50IFwkMX0iKSIgPj5leHBlY3RlZCAmJgotCWVjaG8gInByZXJlcXVpc2l0ZS1wYXRjaC1pZDogJChnaXQgc2hvdyAtLXBhdGNoIEhFQUR+MSB8IGdpdCBwYXRjaC1pZCAtLXN0YWJsZSB8IGF3ayAie3ByaW50IFwkMX0iKSIgPj5leHBlY3RlZCAmJgotCXNpZ25hdHVyZSA+PiBleHBlY3RlZCAmJgotCXRlc3RfY21wIGV4cGVjdGVkIGFjdHVhbDEgJiYKLQl0ZXN0X2NtcCBleHBlY3RlZCBhY3R1YWwyICYmCisKKwlnaXQgZm9ybWF0LXBhdGNoIC0tc3Rkb3V0IC0tYmFzZT1IRUFEfjMgLTEgPnBhdGNoICYmCisJdGFpbCAtbiA3IHBhdGNoID5hY3R1YWwxICYmCisKKwlnaXQgZm9ybWF0LXBhdGNoIC0tc3Rkb3V0IC0tYmFzZT1IRUFEfjMgSEVBRH4uLiA+cGF0Y2ggJiYKKwl0YWlsIC1uIDcgcGF0Y2ggPmFjdHVhbDIgJiYKKworCWVjaG8gPmV4cGVjdCAmJgorCWdpdCByZXYtcGFyc2UgSEVBRH4zID5jb21taXQtaWQtYmFzZSAmJgorCWVjaG8gImJhc2UtY29tbWl0OiAkKGNhdCBjb21taXQtaWQtYmFzZSkiID4+ZXhwZWN0ICYmCisKKwlnaXQgc2hvdyAtLXBhdGNoIEhFQUR+MiA+cGF0Y2ggJiYKKwlnaXQgcGF0Y2gtaWQgLS1zdGFibGUgPHBhdGNoID5wYXRjaC5pZC5yYXcgJiYKKwlhd2sgIntwcmludCBcInByZXJlcXVpc2l0ZS1wYXRjaC1pZDpcIiwgXCQxfSIgPHBhdGNoLmlkLnJhdyA+PmV4cGVjdCAmJgorCisJZ2l0IHNob3cgLS1wYXRjaCBIRUFEfjEgPnBhdGNoICYmCisJZ2l0IHBhdGNoLWlkIC0tc3RhYmxlIDxwYXRjaCA+cGF0Y2guaWQucmF3ICYmCisJYXdrICJ7cHJpbnQgXCJwcmVyZXF1aXNpdGUtcGF0Y2gtaWQ6XCIsIFwkMX0iIDxwYXRjaC5pZC5yYXcgPj5leHBlY3QgJiYKKworCXNpZ25hdHVyZSA+PmV4cGVjdCAmJgorCXRlc3RfY21wIGV4cGVjdCBhY3R1YWwxICYmCisJdGVzdF9jbXAgZXhwZWN0IGFjdHVhbDIgJiYKKwogCWVjaG8gPmZhaWwgJiYKLQllY2hvICJiYXNlLWNvbW1pdDogJChnaXQgcmV2LXBhcnNlIEhFQUR+MykiID4+ZmFpbCAmJgotCWVjaG8gInByZXJlcXVpc2l0ZS1wYXRjaC1pZDogJChnaXQgc2hvdyAtLXBhdGNoIEhFQUR+MiB8IGdpdCBwYXRjaC1pZCAtLXVuc3RhYmxlIHwgYXdrICJ7cHJpbnQgXCQxfSIpIiA+PmZhaWwgJiYKLQllY2hvICJwcmVyZXF1aXNpdGUtcGF0Y2gtaWQ6ICQoZ2l0IHNob3cgLS1wYXRjaCBIRUFEfjEgfCBnaXQgcGF0Y2gtaWQgLS11bnN0YWJsZSB8IGF3ayAie3ByaW50IFwkMX0iKSIgPj5mYWlsICYmCi0Jc2lnbmF0dXJlID4+IGZhaWwgJiYKKwllY2hvICJiYXNlLWNvbW1pdDogJChjYXQgY29tbWl0LWlkLWJhc2UpIiA+PmZhaWwgJiYKKworCWdpdCBzaG93IC0tcGF0Y2ggSEVBRH4yID5wYXRjaCAmJgorCWdpdCBwYXRjaC1pZCAtLXVuc3RhYmxlIDxwYXRjaCA+cGF0Y2guaWQucmF3ICYmCisJYXdrICJ7cHJpbnQgXCJwcmVyZXF1aXNpdGUtcGF0Y2gtaWQ6XCIsIFwkMX0iIDxwYXRjaC5pZC5yYXcgPj5mYWlsICYmCisKKwlnaXQgc2hvdyAtLXBhdGNoIEhFQUR+MSA+cGF0Y2ggJiYKKwlnaXQgcGF0Y2gtaWQgLS11bnN0YWJsZSA8cGF0Y2ggPnBhdGNoLmlkLnJhdyAmJgorCWF3ayAie3ByaW50IFwicHJlcmVxdWlzaXRlLXBhdGNoLWlkOlwiLCBcJDF9IiA8cGF0Y2guaWQucmF3ID4+ZmFpbCAmJgorCisJc2lnbmF0dXJlID4+ZmFpbCAmJgogCSEgdGVzdF9jbXAgZmFpbCBhY3R1YWwxICYmCiAJISB0ZXN0X2NtcCBmYWlsIGFjdHVhbDIKICcKQEAgLTE2NzIsOCArMTg2Nyw5IEBACiAJdGVzdF9tdXN0X2ZhaWwgZ2l0IGZvcm1hdC1wYXRjaCAtLWJhc2U9SEVBRH4xIC0yICYmCiAJZ2l0IGZvcm1hdC1wYXRjaCAtLXN0ZG91dCAtLWJhc2U9SEVBRH4yIC0yID5wYXRjaCAmJgogCWdyZXAgIl5iYXNlLWNvbW1pdDoiIHBhdGNoID5hY3R1YWwgJiYKLQllY2hvICJiYXNlLWNvbW1pdDogJChnaXQgcmV2LXBhcnNlIEhFQUR+MikiID5leHBlY3RlZCAmJgotCXRlc3RfY21wIGV4cGVjdGVkIGFjdHVhbAorCWdpdCByZXYtcGFyc2UgSEVBRH4yID5jb21taXQtaWQtYmFzZSAmJgorCWVjaG8gImJhc2UtY29tbWl0OiAkKGNhdCBjb21taXQtaWQtYmFzZSkiID5leHBlY3QgJiYKKwl0ZXN0X2NtcCBleHBlY3QgYWN0dWFsCiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2Zvcm1hdC1wYXRjaCAtLWJhc2UgZXJyb3JzIG91dCB3aGVuIGJhc2UgY29tbWl0IGlzIG5vdCBhbmNlc3RvciBvZiByZXZpc2lvbiBsaXN0JyAnCkBAIC0xNjk5LDggKzE4OTUsOCBAQAogCXRlc3RfbXVzdF9mYWlsIGdpdCBmb3JtYXQtcGF0Y2ggLS1iYXNlPSQoY2F0IGNvbW1pdC1pZC1aKSAtMyAmJgogCWdpdCBmb3JtYXQtcGF0Y2ggLS1zdGRvdXQgLS1iYXNlPSQoY2F0IGNvbW1pdC1pZC1iYXNlKSAtMyA+cGF0Y2ggJiYKIAlncmVwICJeYmFzZS1jb21taXQ6IiBwYXRjaCA+YWN0dWFsICYmCi0JZWNobyAiYmFzZS1jb21taXQ6ICQoY2F0IGNvbW1pdC1pZC1iYXNlKSIgPmV4cGVjdGVkICYmCi0JdGVzdF9jbXAgZXhwZWN0ZWQgYWN0dWFsCisJZWNobyAiYmFzZS1jb21taXQ6ICQoY2F0IGNvbW1pdC1pZC1iYXNlKSIgPmV4cGVjdCAmJgorCXRlc3RfY21wIGV4cGVjdCBhY3R1YWwKICcKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnZm9ybWF0LXBhdGNoIC0tYmFzZT1hdXRvJyAnCkBAIC0xNzExLDggKzE5MDcsOSBAQAogCXRlc3RfY29tbWl0IE4yICYmCiAJZ2l0IGZvcm1hdC1wYXRjaCAtLXN0ZG91dCAtLWJhc2U9YXV0byAtMiA+cGF0Y2ggJiYKIAlncmVwICJeYmFzZS1jb21taXQ6IiBwYXRjaCA+YWN0dWFsICYmCi0JZWNobyAiYmFzZS1jb21taXQ6ICQoZ2l0IHJldi1wYXJzZSB1cHN0cmVhbSkiID5leHBlY3RlZCAmJgotCXRlc3RfY21wIGV4cGVjdGVkIGFjdHVhbAorCWdpdCByZXYtcGFyc2UgdXBzdHJlYW0gPmNvbW1pdC1pZC1iYXNlICYmCisJZWNobyAiYmFzZS1jb21taXQ6ICQoY2F0IGNvbW1pdC1pZC1iYXNlKSIgPmV4cGVjdCAmJgorCXRlc3RfY21wIGV4cGVjdCBhY3R1YWwKICcKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnZm9ybWF0LXBhdGNoIGVycm9ycyBvdXQgd2hlbiBoaXN0b3J5IGludm9sdmVzIGNyaXNzLWNyb3NzJyAnCkBAIC0xNzQ4LDggKzE5NDUsOSBAQAogCWdpdCBjb25maWcgZm9ybWF0LnVzZUF1dG9CYXNlIHRydWUgJiYKIAlnaXQgZm9ybWF0LXBhdGNoIC0tc3Rkb3V0IC0xID5wYXRjaCAmJgogCWdyZXAgIl5iYXNlLWNvbW1pdDoiIHBhdGNoID5hY3R1YWwgJiYKLQllY2hvICJiYXNlLWNvbW1pdDogJChnaXQgcmV2LXBhcnNlIHVwc3RyZWFtKSIgPmV4cGVjdGVkICYmCi0JdGVzdF9jbXAgZXhwZWN0ZWQgYWN0dWFsCisJZ2l0IHJldi1wYXJzZSB1cHN0cmVhbSA+Y29tbWl0LWlkLWJhc2UgJiYKKwllY2hvICJiYXNlLWNvbW1pdDogJChjYXQgY29tbWl0LWlkLWJhc2UpIiA+ZXhwZWN0ICYmCisJdGVzdF9jbXAgZXhwZWN0IGFjdHVhbAogJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdmb3JtYXQtcGF0Y2ggLS1iYXNlIG92ZXJyaWRlcyBmb3JtYXQudXNlQXV0b0Jhc2UnICcKQEAgLTE3NTcsOCArMTk1NSw5IEBACiAJZ2l0IGNvbmZpZyBmb3JtYXQudXNlQXV0b0Jhc2UgdHJ1ZSAmJgogCWdpdCBmb3JtYXQtcGF0Y2ggLS1zdGRvdXQgLS1iYXNlPUhFQUR+MSAtMSA+cGF0Y2ggJiYKIAlncmVwICJeYmFzZS1jb21taXQ6IiBwYXRjaCA+YWN0dWFsICYmCi0JZWNobyAiYmFzZS1jb21taXQ6ICQoZ2l0IHJldi1wYXJzZSBIRUFEfjEpIiA+ZXhwZWN0ZWQgJiYKLQl0ZXN0X2NtcCBleHBlY3RlZCBhY3R1YWwKKwlnaXQgcmV2LXBhcnNlIEhFQUR+MSA+Y29tbWl0LWlkLWJhc2UgJiYKKwllY2hvICJiYXNlLWNvbW1pdDogJChjYXQgY29tbWl0LWlkLWJhc2UpIiA+ZXhwZWN0ICYmCisJdGVzdF9jbXAgZXhwZWN0IGFjdHVhbAogJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdmb3JtYXQtcGF0Y2ggLS1iYXNlIHdpdGggLS1hdHRhY2gnICcKQEAgLTE4MzMsNyArMjAzMiw3IEBACiAJZ2l0IGZvcm1hdC1wYXRjaCAtLWNvdmVyLWxldHRlciAtLWludGVyZGlmZj1ib29wfjIgLTEgYm9vcCAmJgogCXRlc3RfaTE4bmdyZXAgIl5JbnRlcmRpZmY6JCIgMDAwMC1jb3Zlci1sZXR0ZXIucGF0Y2ggJiYKIAl0ZXN0X2kxOG5ncmVwICEgIl5JbnRlcmRpZmY6JCIgMDAwMS1mbGVlcC5wYXRjaCAmJgotCXNlZCAiMSwvXkBAIC9kOyAvXi0tICQvcSIgPDAwMDAtY292ZXItbGV0dGVyLnBhdGNoID5hY3R1YWwgJiYKKwlzZWQgIjEsL15AQCAvZDsgL14tLSAkL3EiIDAwMDAtY292ZXItbGV0dGVyLnBhdGNoID5hY3R1YWwgJiYKIAl0ZXN0X2NtcCBleHBlY3QgYWN0dWFsCiAnCiAKQEAgLTE4NDksNyArMjA0OCw3IEBACiAJRU9GCiAJZ2l0IGZvcm1hdC1wYXRjaCAtLWludGVyZGlmZj1ib29wfjIgLTEgYm9vcCAmJgogCXRlc3RfaTE4bmdyZXAgIl5JbnRlcmRpZmY6JCIgMDAwMS1mbGVlcC5wYXRjaCAmJgotCXNlZCAiMSwvXiAgQEAgL2Q7IC9eJC9xIiA8MDAwMS1mbGVlcC5wYXRjaCA+YWN0dWFsICYmCisJc2VkICIxLC9eICBAQCAvZDsgL14kL3EiIDAwMDEtZmxlZXAucGF0Y2ggPmFjdHVhbCAmJgogCXRlc3RfY21wIGV4cGVjdCBhY3R1YWwKICcKIApkaWZmIC0tZ2l0IGEvdC90NDAxNS1kaWZmLXdoaXRlc3BhY2Uuc2ggYi90L3Q0MDE1LWRpZmYtd2hpdGVzcGFjZS5zaAppbmRleCA2YjA4N2RmLi5lYWRhZjU3IDEwMDc1NQotLS0gYS90L3Q0MDE1LWRpZmYtd2hpdGVzcGFjZS5zaAorKysgYi90L3Q0MDE1LWRpZmYtd2hpdGVzcGFjZS5zaApAQCAtMTYsNiArMTYsNyBAQAogCX0gd2hpbGUgKDApOwogCUVPRgogCWdpdCB1cGRhdGUtaW5kZXggLS1hZGQgeCAmJgorCWJlZm9yZT0kKGdpdCByZXYtcGFyc2UgLS1zaG9ydCAkKGdpdCBoYXNoLW9iamVjdCB4KSkgJiYKIAogCWNhdCA8PC1cRU9GID54ICYmCiAJZG8KQEAgLTI0LDEwICsyNSwxMSBAQAogCX0KIAl3aGlsZSAoMCk7CiAJRU9GCisJYWZ0ZXI9JChnaXQgcmV2LXBhcnNlIC0tc2hvcnQgJChnaXQgaGFzaC1vYmplY3QgeCkpICYmCiAKLQljYXQgPDwtXEVPRiA+ZXhwZWN0ICYmCisJY2F0IDw8LUVPRiA+ZXhwZWN0ICYmCiAJZGlmZiAtLWdpdCBhL3ggYi94Ci0JaW5kZXggYWRmMzkzNy4uNmVkYzE3MiAxMDA2NDQKKwlpbmRleCAkYmVmb3JlLi4kYWZ0ZXIgMTAwNjQ0CiAJLS0tIGEveAogCSsrKyBiL3gKIAlAQCAtMSwzICsxLDUgQEAKQEAgLTYxLDYgKzYzLDcgQEAKIAlFT0YKIAogCWdpdCB1cGRhdGUtaW5kZXggeCAmJgorCWJlZm9yZT0kKGdpdCByZXYtcGFyc2UgLS1zaG9ydCAkKGdpdCBoYXNoLW9iamVjdCB4KSkgJiYKIAogCXRyICJfIiAiICIgPDwtXEVPRiA+eCAmJgogCV8Jd2hpdGVzcGFjZSBhdCBiZWdpbm5pbmcKQEAgLTcwLDEwICs3MywxMSBAQAogCXVuY2hhbmdlZCBsaW5lCiAJQ1IgYXQgZW5kCiAJRU9GCisJYWZ0ZXI9JChnaXQgcmV2LXBhcnNlIC0tc2hvcnQgJChnaXQgaGFzaC1vYmplY3QgeCkpICYmCiAKLQl0ciAiUV8iICJcMDE1ICIgPDwtXEVPRiA+ZXhwZWN0ICYmCisJdHIgIlFfIiAiXDAxNSAiIDw8LUVPRiA+ZXhwZWN0ICYmCiAJZGlmZiAtLWdpdCBhL3ggYi94Ci0JaW5kZXggZDk5YWYyMy4uMjJkOWY3MyAxMDA2NDQKKwlpbmRleCAkYmVmb3JlLi4kYWZ0ZXIgMTAwNjQ0CiAJLS0tIGEveAogCSsrKyBiL3gKIAlAQCAtMSw2ICsxLDYgQEAKQEAgLTEwOCw5ICsxMTIsOSBAQAogCWdpdCBkaWZmIC13IC0taWdub3JlLWNyLWF0LWVvbCA+b3V0ICYmCiAJdGVzdF9tdXN0X2JlX2VtcHR5IG91dCAmJgogCi0JdHIgIlFfIiAiXDAxNSAiIDw8LVxFT0YgPmV4cGVjdCAmJgorCXRyICJRXyIgIlwwMTUgIiA8PC1FT0YgPmV4cGVjdCAmJgogCWRpZmYgLS1naXQgYS94IGIveAotCWluZGV4IGQ5OWFmMjMuLjIyZDlmNzMgMTAwNjQ0CisJaW5kZXggJGJlZm9yZS4uJGFmdGVyIDEwMDY0NAogCS0tLSBhL3gKIAkrKysgYi94CiAJQEAgLTEsNiArMSw2IEBACkBAIC0xMzIsOSArMTM2LDkgQEAKIAlnaXQgZGlmZiAtYiAtLWlnbm9yZS1jci1hdC1lb2wgPm91dCAmJgogCXRlc3RfY21wIGV4cGVjdCBvdXQgJiYKIAotCXRyICJRXyIgIlwwMTUgIiA8PC1cRU9GID5leHBlY3QgJiYKKwl0ciAiUV8iICJcMDE1ICIgPDwtRU9GID5leHBlY3QgJiYKIAlkaWZmIC0tZ2l0IGEveCBiL3gKLQlpbmRleCBkOTlhZjIzLi4yMmQ5ZjczIDEwMDY0NAorCWluZGV4ICRiZWZvcmUuLiRhZnRlciAxMDA2NDQKIAktLS0gYS94CiAJKysrIGIveAogCUBAIC0xLDYgKzEsNiBAQApAQCAtMTU0LDkgKzE1OCw5IEBACiAJZ2l0IGRpZmYgLS1pZ25vcmUtc3BhY2UtYXQtZW9sIC0taWdub3JlLWNyLWF0LWVvbCA+b3V0ICYmCiAJdGVzdF9jbXAgZXhwZWN0IG91dCAmJgogCi0JdHIgIlFfIiAiXDAxNSAiIDw8LVxFT0YgPmV4cGVjdCAmJgorCXRyICJRXyIgIlwwMTUgIiA8PC1FT0YgPmV4cGVjdCAmJgogCWRpZmYgLS1naXQgYS94IGIveAotCWluZGV4X2Q5OWFmMjMuLjIyZDlmNzMgMTAwNjQ0CisJaW5kZXhfJGJlZm9yZS4uJGFmdGVyIDEwMDY0NAogCS0tLSBhL3gKIAkrKysgYi94CiAJQEAgLTEsNiArMSw2IEBACkBAIC03ODYsMjMgKzc5MCwyNSBAQAogCXRlc3RfbXVzdF9iZV9lbXB0eSBhY3R1YWwKICcKIAotY2F0IDw8RU9GID5leHBlY3QKLWRpZmYgLS1naXQgYS94IGIvegotc2ltaWxhcml0eSBpbmRleCBOVU0lCi1yZW5hbWUgZnJvbSB4Ci1yZW5hbWUgdG8gegotaW5kZXggMzgwYzMyYS4uYTk3Yjc4NSAxMDA2NDQKLUVPRgogdGVzdF9leHBlY3Rfc3VjY2VzcyAnd2hpdGVzcGFjZS1vbmx5IGNoYW5nZXMgcmVwb3J0ZWQgYWNyb3NzIHJlbmFtZXMnICcKIAlnaXQgcmVzZXQgLS1oYXJkICYmCiAJZm9yIGkgaW4gMSAyIDMgNCA1IDYgNyA4IDk7IGRvIGVjaG8gIiRpJGkkaSRpJGkkaSI7IGRvbmUgPnggJiYKIAlnaXQgYWRkIHggJiYKKwliZWZvcmU9JChnaXQgcmV2LXBhcnNlIC0tc2hvcnQgJChnaXQgaGFzaC1vYmplY3QgeCkpICYmCiAJZ2l0IGNvbW1pdCAtbSAiYmFzZSIgJiYKIAlzZWQgLWUgIjVzL14vIC8iIHggPnogJiYKIAlnaXQgcm0geCAmJgogCWdpdCBhZGQgeiAmJgorCWFmdGVyPSQoZ2l0IHJldi1wYXJzZSAtLXNob3J0ICQoZ2l0IGhhc2gtb2JqZWN0IHopKSAmJgogCWdpdCBkaWZmIC13IC1NIC0tY2FjaGVkIHwKIAlzZWQgLWUgIi9ec2ltaWxhcml0eSBpbmRleCAvcy9bMC05XVswLTldKi9OVU0vIiA+YWN0dWFsICYmCisJY2F0IDw8LUVPRiA+ZXhwZWN0ICYmCisJZGlmZiAtLWdpdCBhL3ggYi96CisJc2ltaWxhcml0eSBpbmRleCBOVU0lCisJcmVuYW1lIGZyb20geAorCXJlbmFtZSB0byB6CisJaW5kZXggJGJlZm9yZS4uJGFmdGVyIDEwMDY0NAorCUVPRgogCXRlc3RfY21wIGV4cGVjdCBhY3R1YWwKICcKIApAQCAtODU4LDEzICs4NjQsMTUgQEAKIAlnaXQgY29uZmlnIGNvcmUud2hpdGVzcGFjZSBibGFuay1hdC1lb2wgJiYKIAlnaXQgcmVzZXQgLS1oYXJkICYmCiAJZWNobyAidGVzdCIgPnggJiYKKwliZWZvcmU9JChnaXQgcmV2LXBhcnNlIC0tc2hvcnQgJChnaXQgaGFzaC1vYmplY3QgeCkpICYmCiAJZ2l0IGNvbW1pdCAtbSAiaW5pdGlhbCIgeCAmJgogCWVjaG8gIntOVE59IiB8IHRyICJOVCIgIlxuXHQiID4+eCAmJgorCWFmdGVyPSQoZ2l0IHJldi1wYXJzZSAtLXNob3J0ICQoZ2l0IGhhc2gtb2JqZWN0IHgpKSAmJgogCWdpdCBkaWZmIC0tY29sb3IgfCB0ZXN0X2RlY29kZV9jb2xvciA+Y3VycmVudCAmJgogCi0JY2F0ID5leHBlY3RlZCA8PC1cRU9GICYmCisJY2F0ID5leHBlY3RlZCA8PC1FT0YgJiYKIAk8Qk9MRD5kaWZmIC0tZ2l0IGEveCBiL3g8UkVTRVQ+Ci0JPEJPTEQ+aW5kZXggOWRhZWFmYi4uMjg3NGI5MSAxMDA2NDQ8UkVTRVQ+CisJPEJPTEQ+aW5kZXggJGJlZm9yZS4uJGFmdGVyIDEwMDY0NDxSRVNFVD4KIAk8Qk9MRD4tLS0gYS94PFJFU0VUPgogCTxCT0xEPisrKyBiL3g8UkVTRVQ+CiAJPENZQU4+QEAgLTEgKzEsNCBAQDxSRVNFVD4KQEAgLTg4MywxOSArODkxLDIxIEBACiAJCWVjaG8gIjAuIGJsYW5rLWF0LWVvbCAiICYmCiAJCWVjaG8gIjEuIGJsYW5rLWF0LWVvbCAiCiAJfSA+eCAmJgorCWJlZm9yZT0kKGdpdCByZXYtcGFyc2UgLS1zaG9ydCAkKGdpdCBoYXNoLW9iamVjdCB4KSkgJiYKIAlnaXQgY29tbWl0IC1hIC0tYWxsb3ctZW1wdHkgLW0gcHJlaW1hZ2UgJiYKIAl7CiAJCWVjaG8gIjAuIGJsYW5rLWF0LWVvbCAiICYmCiAJCWVjaG8gIjEuIHN0aWxsLWJsYW5rLWF0LWVvbCAiICYmCiAJCWVjaG8gIjIuIGFuZCBhIG5ldyBsaW5lICIKIAl9ID54ICYmCisJYWZ0ZXI9JChnaXQgcmV2LXBhcnNlIC0tc2hvcnQgJChnaXQgaGFzaC1vYmplY3QgeCkpICYmCiAKIAlnaXQgZGlmZiAtLWNvbG9yIHwKIAl0ZXN0X2RlY29kZV9jb2xvciA+Y3VycmVudCAmJgogCi0JY2F0ID5leHBlY3RlZCA8PC1cRU9GICYmCisJY2F0ID5leHBlY3RlZCA8PC1FT0YgJiYKIAk8Qk9MRD5kaWZmIC0tZ2l0IGEveCBiL3g8UkVTRVQ+Ci0JPEJPTEQ+aW5kZXggZDAyMzNhMi4uNzAwODg2ZSAxMDA2NDQ8UkVTRVQ+CisJPEJPTEQ+aW5kZXggJGJlZm9yZS4uJGFmdGVyIDEwMDY0NDxSRVNFVD4KIAk8Qk9MRD4tLS0gYS94PFJFU0VUPgogCTxCT0xEPisrKyBiL3g8UkVTRVQ+CiAJPENZQU4+QEAgLTEsMiArMSwzIEBAPFJFU0VUPgpAQCAtOTE1LDE2ICs5MjUsMTggQEAKIAkJZWNobyAiMC4gYmxhbmstYXQtZW9sICIgJiYKIAkJZWNobyAiMS4gYmxhbmstYXQtZW9sICIKIAl9ID54ICYmCisJYmVmb3JlPSQoZ2l0IHJldi1wYXJzZSAtLXNob3J0ICQoZ2l0IGhhc2gtb2JqZWN0IHgpKSAmJgogCWdpdCBjb21taXQgLWEgLS1hbGxvdy1lbXB0eSAtbSBwcmVpbWFnZSAmJgogCXsKIAkJZWNobyAiMC4gYmxhbmstYXQtZW9sICIgJiYKIAkJZWNobyAiMS4gc3RpbGwtYmxhbmstYXQtZW9sICIgJiYKIAkJZWNobyAiMi4gYW5kIGEgbmV3IGxpbmUgIgogCX0gPnggJiYKKwlhZnRlcj0kKGdpdCByZXYtcGFyc2UgLS1zaG9ydCAkKGdpdCBoYXNoLW9iamVjdCB4KSkgJiYKIAotCWNhdCA+ZXhwZWN0LmRlZmF1bHQtb2xkIDw8LVxFT0YgJiYKKwljYXQgPmV4cGVjdC5kZWZhdWx0LW9sZCA8PC1FT0YgJiYKIAk8Qk9MRD5kaWZmIC0tZ2l0IGEveCBiL3g8UkVTRVQ+Ci0JPEJPTEQ+aW5kZXggZDAyMzNhMi4uNzAwODg2ZSAxMDA2NDQ8UkVTRVQ+CisJPEJPTEQ+aW5kZXggJGJlZm9yZS4uJGFmdGVyIDEwMDY0NDxSRVNFVD4KIAk8Qk9MRD4tLS0gYS94PFJFU0VUPgogCTxCT0xEPisrKyBiL3g8UkVTRVQ+CiAJPENZQU4+QEAgLTEsMiArMSwzIEBAPFJFU0VUPgpAQCAtOTM0LDkgKzk0Niw5IEBACiAJPEdSRUVOPis8UkVTRVQ+PEdSRUVOPjIuIGFuZCBhIG5ldyBsaW5lPFJFU0VUPjxCTFVFPiA8UkVTRVQ+CiAJRU9GCiAKLQljYXQgPmV4cGVjdC5hbGwgPDwtXEVPRiAmJgorCWNhdCA+ZXhwZWN0LmFsbCA8PC1FT0YgJiYKIAk8Qk9MRD5kaWZmIC0tZ2l0IGEveCBiL3g8UkVTRVQ+Ci0JPEJPTEQ+aW5kZXggZDAyMzNhMi4uNzAwODg2ZSAxMDA2NDQ8UkVTRVQ+CisJPEJPTEQ+aW5kZXggJGJlZm9yZS4uJGFmdGVyIDEwMDY0NDxSRVNFVD4KIAk8Qk9MRD4tLS0gYS94PFJFU0VUPgogCTxCT0xEPisrKyBiL3g8UkVTRVQ+CiAJPENZQU4+QEAgLTEsMiArMSwzIEBAPFJFU0VUPgpAQCAtOTQ2LDkgKzk1OCw5IEBACiAJPEdSRUVOPis8UkVTRVQ+PEdSRUVOPjIuIGFuZCBhIG5ldyBsaW5lPFJFU0VUPjxCTFVFPiA8UkVTRVQ+CiAJRU9GCiAKLQljYXQgPmV4cGVjdC5ub25lIDw8LVxFT0YKKwljYXQgPmV4cGVjdC5ub25lIDw8LUVPRgogCTxCT0xEPmRpZmYgLS1naXQgYS94IGIveDxSRVNFVD4KLQk8Qk9MRD5pbmRleCBkMDIzM2EyLi43MDA4ODZlIDEwMDY0NDxSRVNFVD4KKwk8Qk9MRD5pbmRleCAkYmVmb3JlLi4kYWZ0ZXIgMTAwNjQ0PFJFU0VUPgogCTxCT0xEPi0tLSBhL3g8UkVTRVQ+CiAJPEJPTEQ+KysrIGIveDxSRVNFVD4KIAk8Q1lBTj5AQCAtMSwyICsxLDMgQEA8UkVTRVQ+CkBAIC0xMDIyLDE0ICsxMDM0LDE1IEBACiAJRU9GCiAJZ2l0IGFkZCB0ZXN0LmMgJiYKIAlnaXQgY29tbWl0IC1tICJhZGQgbWFpbiBmdW5jdGlvbiIgJiYKKwlmaWxlPSQoZ2l0IHJldi1wYXJzZSAtLXNob3J0IEhFQUQ6dGVzdC5jKSAmJgogCWdpdCBtdiB0ZXN0LmMgbWFpbi5jICYmCiAJdGVzdF9jb25maWcgY29sb3IuZGlmZi5vbGRNb3ZlZCAibm9ybWFsIHJlZCIgJiYKIAl0ZXN0X2NvbmZpZyBjb2xvci5kaWZmLm5ld01vdmVkICJub3JtYWwgZ3JlZW4iICYmCiAJZ2l0IGRpZmYgSEVBRCAtLWNvbG9yLW1vdmVkPXplYnJhIC0tY29sb3IgLS1uby1yZW5hbWVzIHwgdGVzdF9kZWNvZGVfY29sb3IgPmFjdHVhbCAmJgotCWNhdCA+ZXhwZWN0ZWQgPDwtXEVPRiAmJgorCWNhdCA+ZXhwZWN0ZWQgPDwtRU9GICYmCiAJPEJPTEQ+ZGlmZiAtLWdpdCBhL21haW4uYyBiL21haW4uYzxSRVNFVD4KIAk8Qk9MRD5uZXcgZmlsZSBtb2RlIDEwMDY0NDxSRVNFVD4KLQk8Qk9MRD5pbmRleCAwMDAwMDAwLi5hOTg2YzU3PFJFU0VUPgorCTxCT0xEPmluZGV4IDAwMDAwMDAuLiRmaWxlPFJFU0VUPgogCTxCT0xEPi0tLSAvZGV2L251bGw8UkVTRVQ+CiAJPEJPTEQ+KysrIGIvbWFpbi5jPFJFU0VUPgogCTxDWUFOPkBAIC0wLDAgKzEsNSBAQDxSRVNFVD4KQEAgLTEwNDAsNyArMTA1Myw3IEBACiAJPEJHUkVFTj4rPFJFU0VUPjxCR1JFRU4+fTxSRVNFVD4KIAk8Qk9MRD5kaWZmIC0tZ2l0IGEvdGVzdC5jIGIvdGVzdC5jPFJFU0VUPgogCTxCT0xEPmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NDxSRVNFVD4KLQk8Qk9MRD5pbmRleCBhOTg2YzU3Li4wMDAwMDAwPFJFU0VUPgorCTxCT0xEPmluZGV4ICRmaWxlLi4wMDAwMDAwPFJFU0VUPgogCTxCT0xEPi0tLSBhL3Rlc3QuYzxSRVNFVD4KIAk8Qk9MRD4rKysgL2Rldi9udWxsPFJFU0VUPgogCTxDWUFOPkBAIC0xLDUgKzAsMCBAQDxSRVNFVD4KQEAgLTEwOTQsNiArMTEwNyw4IEBACiAJRU9GCiAJZ2l0IGFkZCBtYWluLmMgdGVzdC5jICYmCiAJZ2l0IGNvbW1pdCAtbSAiYWRkIG1haW4gYW5kIHRlc3QgZmlsZSIgJiYKKwliZWZvcmVfbWFpbj0kKGdpdCByZXYtcGFyc2UgLS1zaG9ydCBIRUFEOm1haW4uYykgJiYKKwliZWZvcmVfdGVzdD0kKGdpdCByZXYtcGFyc2UgLS1zaG9ydCBIRUFEOnRlc3QuYykgJiYKIAljYXQgPDwtXEVPRiA+bWFpbi5jICYmCiAJCSNpbmNsdWRlPHN0ZGlvLmg+CiAJCWludCBzdHVmZigpCkBAIC0xMTI2LDEwICsxMTQxLDEyIEBACiAJCQliYXIoKTsKIAkJfQogCUVPRgorCWFmdGVyX21haW49JChnaXQgcmV2LXBhcnNlIC0tc2hvcnQgJChnaXQgaGFzaC1vYmplY3QgbWFpbi5jKSkgJiYKKwlhZnRlcl90ZXN0PSQoZ2l0IHJldi1wYXJzZSAtLXNob3J0ICQoZ2l0IGhhc2gtb2JqZWN0IHRlc3QuYykpICYmCiAJZ2l0IGRpZmYgSEVBRCAtLW5vLXJlbmFtZXMgLS1jb2xvci1tb3ZlZD16ZWJyYSAtLWNvbG9yIHwgdGVzdF9kZWNvZGVfY29sb3IgPmFjdHVhbCAmJgotCWNhdCA8PC1cRU9GID5leHBlY3RlZCAmJgorCWNhdCA8PC1FT0YgPmV4cGVjdGVkICYmCiAJPEJPTEQ+ZGlmZiAtLWdpdCBhL21haW4uYyBiL21haW4uYzxSRVNFVD4KLQk8Qk9MRD5pbmRleCAyN2E2MTljLi43Y2Y5MzM2IDEwMDY0NDxSRVNFVD4KKwk8Qk9MRD5pbmRleCAkYmVmb3JlX21haW4uLiRhZnRlcl9tYWluIDEwMDY0NDxSRVNFVD4KIAk8Qk9MRD4tLS0gYS9tYWluLmM8UkVTRVQ+CiAJPEJPTEQ+KysrIGIvbWFpbi5jPFJFU0VUPgogCTxDWUFOPkBAIC01LDEzICs1LDYgQEA8UkVTRVQ+IDxSRVNFVD5wcmludGYoIkhlbGxvICIpOzxSRVNFVD4KQEAgLTExNDcsNyArMTE2NCw3IEBACiAJIHs8UkVTRVQ+CiAJIGZvbygpOzxSRVNFVD4KIAk8Qk9MRD5kaWZmIC0tZ2l0IGEvdGVzdC5jIGIvdGVzdC5jPFJFU0VUPgotCTxCT0xEPmluZGV4IDFkYzFkODUuLjJiZWRlYzkgMTAwNjQ0PFJFU0VUPgorCTxCT0xEPmluZGV4ICRiZWZvcmVfdGVzdC4uJGFmdGVyX3Rlc3QgMTAwNjQ0PFJFU0VUPgogCTxCT0xEPi0tLSBhL3Rlc3QuYzxSRVNFVD4KIAk8Qk9MRD4rKysgYi90ZXN0LmM8UkVTRVQ+CiAJPENZQU4+QEAgLTQsNiArNCwxMyBAQDxSRVNFVD4gPFJFU0VUPmludCBiYXIoKTxSRVNFVD4KQEAgLTExNzYsOSArMTE5Myw5IEBACiAJdGVzdF9jb25maWcgY29sb3IuZGlmZi5uZXdNb3ZlZEFsdGVybmF0aXZlICJ5ZWxsb3ciICYmCiAJIyBuZWVkcyBwcmV2aW91cyB0ZXN0IGFzIHNldHVwCiAJZ2l0IGRpZmYgSEVBRCAtLW5vLXJlbmFtZXMgLS1jb2xvci1tb3ZlZD1wbGFpbiAtLWNvbG9yIHwgdGVzdF9kZWNvZGVfY29sb3IgPmFjdHVhbCAmJgotCWNhdCA8PC1cRU9GID5leHBlY3RlZCAmJgorCWNhdCA8PC1FT0YgPmV4cGVjdGVkICYmCiAJPEJPTEQ+ZGlmZiAtLWdpdCBhL21haW4uYyBiL21haW4uYzxSRVNFVD4KLQk8Qk9MRD5pbmRleCAyN2E2MTljLi43Y2Y5MzM2IDEwMDY0NDxSRVNFVD4KKwk8Qk9MRD5pbmRleCAkYmVmb3JlX21haW4uLiRhZnRlcl9tYWluIDEwMDY0NDxSRVNFVD4KIAk8Qk9MRD4tLS0gYS9tYWluLmM8UkVTRVQ+CiAJPEJPTEQ+KysrIGIvbWFpbi5jPFJFU0VUPgogCTxDWUFOPkBAIC01LDEzICs1LDYgQEA8UkVTRVQ+IDxSRVNFVD5wcmludGYoIkhlbGxvICIpOzxSRVNFVD4KQEAgLTExOTYsNyArMTIxMyw3IEBACiAJIHs8UkVTRVQ+CiAJIGZvbygpOzxSRVNFVD4KIAk8Qk9MRD5kaWZmIC0tZ2l0IGEvdGVzdC5jIGIvdGVzdC5jPFJFU0VUPgotCTxCT0xEPmluZGV4IDFkYzFkODUuLjJiZWRlYzkgMTAwNjQ0PFJFU0VUPgorCTxCT0xEPmluZGV4ICRiZWZvcmVfdGVzdC4uJGFmdGVyX3Rlc3QgMTAwNjQ0PFJFU0VUPgogCTxCT0xEPi0tLSBhL3Rlc3QuYzxSRVNFVD4KIAk8Qk9MRD4rKysgYi90ZXN0LmM8UkVTRVQ+CiAJPENZQU4+QEAgLTQsNiArNCwxMyBAQDxSRVNFVD4gPFJFU0VUPmludCBiYXIoKTxSRVNFVD4KZGlmZiAtLWdpdCBhL3QvdDQwMTgtZGlmZi1mdW5jbmFtZS5zaCBiL3QvdDQwMTgtZGlmZi1mdW5jbmFtZS5zaAppbmRleCA5MjYxZDZkLi5jMGY0ODM5IDEwMDc1NQotLS0gYS90L3Q0MDE4LWRpZmYtZnVuY25hbWUuc2gKKysrIGIvdC90NDAxOC1kaWZmLWZ1bmNuYW1lLnNoCkBAIC0zMSw2ICszMSw4IEBACiAJY3BwCiAJY3NoYXJwCiAJY3NzCisJZHRzCisJZWxpeGlyCiAJZm9ydHJhbgogCWZvdW50YWluCiAJZ29sYW5nCmRpZmYgLS1naXQgYS90L3Q0MDE4L2R0cy1sYWJlbHMgYi90L3Q0MDE4L2R0cy1sYWJlbHMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYjIxZWY4NwotLS0gL2Rldi9udWxsCisrKyBiL3QvdDQwMTgvZHRzLWxhYmVscwpAQCAtMCwwICsxLDkgQEAKKy8geworCWxhYmVsXzE6IG5vZGUxQGZmMDAgeworCQlsYWJlbDI6IFJJR0hUIHsKKwkJCXZlbmRvcixzb21lLXByb3BlcnR5OworCisJCQlDaGFuZ2VNZSA9IDwweDQ1LTMwPjsKKwkJfTsKKwl9OworfTsKZGlmZiAtLWdpdCBhL3QvdDQwMTgvZHRzLW5vZGUtdW5pdGxlc3MgYi90L3Q0MDE4L2R0cy1ub2RlLXVuaXRsZXNzCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmM1Mjg3ZDkKLS0tIC9kZXYvbnVsbAorKysgYi90L3Q0MDE4L2R0cy1ub2RlLXVuaXRsZXNzCkBAIC0wLDAgKzEsOCBAQAorLyB7CisJbGFiZWxfMTogbm9kZTEgeworCQlSSUdIVCB7CisJCQlwcm9wLWFycmF5ID0gPDE+LCA8ND47CisJCQlDaGFuZ2VNZSA9IDwweGZmZWVkZDAwPjsKKwkJfTsKKwl9OworfTsKZGlmZiAtLWdpdCBhL3QvdDQwMTgvZHRzLW5vZGVzIGIvdC90NDAxOC9kdHMtbm9kZXMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNWE0MzM0YgotLS0gL2Rldi9udWxsCisrKyBiL3QvdDQwMTgvZHRzLW5vZGVzCkBAIC0wLDAgKzEsOCBAQAorLyB7CisJbGFiZWxfMTogbm9kZTFAZmYwMCB7CisJCVJJR0hUQGRlYWRmMDAsNDAwMCB7CisJCQkjc2l6ZS1jZWxscyA9IDwxPjsKKwkJCUNoYW5nZU1lID0gPDB4ZmZlZWRkMDA+OworCQl9OworCX07Cit9OwpkaWZmIC0tZ2l0IGEvdC90NDAxOC9kdHMtbm9kZXMtYm9vbGVhbi1wcm9wIGIvdC90NDAxOC9kdHMtbm9kZXMtYm9vbGVhbi1wcm9wCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmFmYzZiNWIKLS0tIC9kZXYvbnVsbAorKysgYi90L3Q0MDE4L2R0cy1ub2Rlcy1ib29sZWFuLXByb3AKQEAgLTAsMCArMSw5IEBACisvIHsKKwlsYWJlbF8xOiBub2RlMUBmZjAwIHsKKwkJUklHSFRAZGVhZGYwMCw0MDAwIHsKKwkJCWJvb2xlYW4tcHJvcDE7CisKKwkJCUNoYW5nZU1lOworCQl9OworCX07Cit9OwpkaWZmIC0tZ2l0IGEvdC90NDAxOC9kdHMtbm9kZXMtY29tbWVudDEgYi90L3Q0MDE4L2R0cy1ub2Rlcy1jb21tZW50MQpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi41NTlkZmNlCi0tLSAvZGV2L251bGwKKysrIGIvdC90NDAxOC9kdHMtbm9kZXMtY29tbWVudDEKQEAgLTAsMCArMSw4IEBACisvIHsKKwlsYWJlbF8xOiBub2RlMUBmZjAwIHsKKwkJUklHSFRAZGVhZGYwMCw0MDAwIC8qICZhIGNvbW1lbnQgKi8geworCQkJI3NpemUtY2VsbHMgPSA8MT47CisJCQlDaGFuZ2VNZSA9IDwweGZmZWVkZDAwPjsKKwkJfTsKKwl9OworfTsKZGlmZiAtLWdpdCBhL3QvdDQwMTgvZHRzLW5vZGVzLWNvbW1lbnQyIGIvdC90NDAxOC9kdHMtbm9kZXMtY29tbWVudDIKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMjdlOTcxOAotLS0gL2Rldi9udWxsCisrKyBiL3QvdDQwMTgvZHRzLW5vZGVzLWNvbW1lbnQyCkBAIC0wLDAgKzEsOCBAQAorLyB7CisJbGFiZWxfMTogbm9kZTFAZmYwMCB7CisJCVJJR0hUQGRlYWRmMDAsNDAwMCB7IC8qIGEgdHJhaWxpbmcgY29tbWVudCAqLyAKKwkJCSNzaXplLWNlbGxzID0gPDE+OworCQkJQ2hhbmdlTWUgPSA8MHhmZmVlZGQwMD47CisJCX07CisJfTsKK307CmRpZmYgLS1naXQgYS90L3Q0MDE4L2R0cy1ub2Rlcy1tdWx0aWxpbmUtcHJvcCBiL3QvdDQwMTgvZHRzLW5vZGVzLW11bHRpbGluZS1wcm9wCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjA3MmQ1OGIKLS0tIC9kZXYvbnVsbAorKysgYi90L3Q0MDE4L2R0cy1ub2Rlcy1tdWx0aWxpbmUtcHJvcApAQCAtMCwwICsxLDEzIEBACisvIHsKKwlsYWJlbF8xOiBub2RlMUBmZjAwIHsKKwkJUklHSFRAZGVhZGYwMCw0MDAwIHsKKwkJCW11bHRpbGluZXByb3AgPSA8Mz4sCisJCQkJCTw0PiwKKwkJCQkJPDU+LAorCQkJCQk8Nj4sCisJCQkJCTw3PjsKKworCQkJQ2hhbmdlTWUgPSA8MHhmZmVlZGQwMD47CisJCX07CisJfTsKK307CmRpZmYgLS1naXQgYS90L3Q0MDE4L2R0cy1yZWZlcmVuY2UgYi90L3Q0MDE4L2R0cy1yZWZlcmVuY2UKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uOGYwYzg3ZAotLS0gL2Rldi9udWxsCisrKyBiL3QvdDQwMTgvZHRzLXJlZmVyZW5jZQpAQCAtMCwwICsxLDkgQEAKKyZsYWJlbF8xIHsKKwlURVNUID0gPDQ1NT47Cit9OworCismUklHSFQgeworCXZlbmRvcixzb21lLXByb3BlcnR5OworCisJQ2hhbmdlTWUgPSA8MHg0NS0zMD47Cit9OwpkaWZmIC0tZ2l0IGEvdC90NDAxOC9kdHMtcm9vdCBiL3QvdDQwMTgvZHRzLXJvb3QKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNDM1M2I4MgotLS0gL2Rldi9udWxsCisrKyBiL3QvdDQwMTgvZHRzLXJvb3QKQEAgLTAsMCArMSw1IEBACisvIHsgUklHSFQgLyogVGVjaG5pY2FsbHkganVzdCBzdXBwb3NlZCB0byBiZSBhIHNsYXNoIGFuZCBicmFjZSAqLworCSNzaXplLWNlbGxzID0gPDE+OworCisJQ2hhbmdlTWUgPSA8MHhmZmVlZGQwMD47Cit9OwpkaWZmIC0tZ2l0IGEvdC90NDAxOC9kdHMtcm9vdC1jb21tZW50IGIvdC90NDAxOC9kdHMtcm9vdC1jb21tZW50Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjMzM2E2MjUKLS0tIC9kZXYvbnVsbAorKysgYi90L3Q0MDE4L2R0cy1yb290LWNvbW1lbnQKQEAgLTAsMCArMSw4IEBACisvIHsgUklHSFQgLyogVGVjaG5pY2FsbHkganVzdCBzdXBwb3NlZCB0byBiZSBhIHNsYXNoIGFuZCBicmFjZSAqLworCSNzaXplLWNlbGxzID0gPDE+OworCisJLyogVGhpcyBjb21tZW50IHNob3VsZCBiZSBpZ25vcmVkICovCisKKwlzb21lLXByb3BlcnR5ID0gPDQwKzI+OworCUNoYW5nZU1lID0gPDB4ZmZlZWRkMDA+OworfTsKZGlmZiAtLWdpdCBhL3QvdDQwMTgvZWxpeGlyLWRvLW5vdC1waWNrLWVuZCBiL3QvdDQwMTgvZWxpeGlyLWRvLW5vdC1waWNrLWVuZApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5mYWUwOGJhCi0tLSAvZGV2L251bGwKKysrIGIvdC90NDAxOC9lbGl4aXItZG8tbm90LXBpY2stZW5kCkBAIC0wLDAgKzEsNSBAQAorZGVmbW9kdWxlIFJJR0hUIGRvCitlbmQKKyMKKyMKKyMgQ2hhbmdlTWU7IGRvIG5vdCBwaWNrIHVwICdlbmQnIGxpbmUKZGlmZiAtLWdpdCBhL3QvdDQwMTgvZWxpeGlyLWV4LXVuaXQtdGVzdCBiL3QvdDQwMTgvZWxpeGlyLWV4LXVuaXQtdGVzdApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4wNTYwYTJiCi0tLSAvZGV2L251bGwKKysrIGIvdC90NDAxOC9lbGl4aXItZXgtdW5pdC10ZXN0CkBAIC0wLDAgKzEsNiBAQAorZGVmbW9kdWxlIFRlc3QgZG8KKyAgdGVzdCAiUklHSFQiIGRvCisgICAgYXNzZXJ0IHRydWUgPT0gdHJ1ZQorICAgIGFzc2VydCBDaGFuZ2VNZQorICBlbmQKK2VuZApkaWZmIC0tZ2l0IGEvdC90NDAxOC9lbGl4aXItZnVuY3Rpb24gYi90L3Q0MDE4L2VsaXhpci1mdW5jdGlvbgpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5kNDUyZjQ5Ci0tLSAvZGV2L251bGwKKysrIGIvdC90NDAxOC9lbGl4aXItZnVuY3Rpb24KQEAgLTAsMCArMSw1IEBACitkZWYgZnVuY3Rpb24oUklHSFQsIGFyZykgZG8KKyAgIyBjb21tZW50CisgICMgY29tbWVudAorICBDaGFuZ2VNZQorZW5kCmRpZmYgLS1naXQgYS90L3Q0MDE4L2VsaXhpci1tYWNybyBiL3QvdDQwMTgvZWxpeGlyLW1hY3JvCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjRmOTI1ZTkKLS0tIC9kZXYvbnVsbAorKysgYi90L3Q0MDE4L2VsaXhpci1tYWNybwpAQCAtMCwwICsxLDUgQEAKK2RlZm1hY3JvIGZvbyhSSUdIVCkgZG8KKyAgIyBDb2RlCisgICMgQ29kZQorICBDaGFuZ2VNZQorZW5kCmRpZmYgLS1naXQgYS90L3Q0MDE4L2VsaXhpci1tb2R1bGUgYi90L3Q0MDE4L2VsaXhpci1tb2R1bGUKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uOTFhNGU3YQotLS0gL2Rldi9udWxsCisrKyBiL3QvdDQwMTgvZWxpeGlyLW1vZHVsZQpAQCAtMCwwICsxLDkgQEAKK2RlZm1vZHVsZSBSSUdIVCBkbworICBAbW9kdWxlZG9jICIiIgorICBGb28gYmFyCisgICIiIgorCisgIGRlZiBDaGFuZ2VNZShhKSB3aGVyZSBpc19tYXAoYSkgZG8KKyAgICBhCisgIGVuZAorZW5kCmRpZmYgLS1naXQgYS90L3Q0MDE4L2VsaXhpci1tb2R1bGUtZnVuYyBiL3QvdDQwMTgvZWxpeGlyLW1vZHVsZS1mdW5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmM5OTEwZDAKLS0tIC9kZXYvbnVsbAorKysgYi90L3Q0MDE4L2VsaXhpci1tb2R1bGUtZnVuYwpAQCAtMCwwICsxLDggQEAKK2RlZm1vZHVsZSBGb28gZG8KKyAgZGVmIGZ1bihSSUdIVCkgZG8KKyAgICAgIyBDb2RlCisgICAgICMgQ29kZQorICAgICAjIENvZGUKKyAgICAgQ2hhbmdlTWUKKyAgZW5kCitlbmQKZGlmZiAtLWdpdCBhL3QvdDQwMTgvZWxpeGlyLW5lc3RlZC1tb2R1bGUgYi90L3Q0MDE4L2VsaXhpci1uZXN0ZWQtbW9kdWxlCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjc3MWViYzUKLS0tIC9kZXYvbnVsbAorKysgYi90L3Q0MDE4L2VsaXhpci1uZXN0ZWQtbW9kdWxlCkBAIC0wLDAgKzEsOSBAQAorZGVmbW9kdWxlIE15QXBwLlJJR0hUIGRvCisgIEBtb2R1bGVkb2MgIiIiCisgIEZvbyBiYXIKKyAgIiIiCisKKyAgZGVmIENoYW5nZU1lKGEpIHdoZXJlIGlzX21hcChhKSBkbworICAgIGEKKyAgZW5kCitlbmQKZGlmZiAtLWdpdCBhL3QvdDQwMTgvZWxpeGlyLXByaXZhdGUtZnVuY3Rpb24gYi90L3Q0MDE4L2VsaXhpci1wcml2YXRlLWZ1bmN0aW9uCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjFhYWJlMzMKLS0tIC9kZXYvbnVsbAorKysgYi90L3Q0MDE4L2VsaXhpci1wcml2YXRlLWZ1bmN0aW9uCkBAIC0wLDAgKzEsNSBAQAorZGVmcCBmdW5jdGlvbihSSUdIVCwgYXJnKSBkbworICAjIGNvbW1lbnQKKyAgIyBjb21tZW50CisgIENoYW5nZU1lCitlbmQKZGlmZiAtLWdpdCBhL3QvdDQwMTgvZWxpeGlyLXByb3RvY29sIGIvdC90NDAxOC9lbGl4aXItcHJvdG9jb2wKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uN2Q5MTczNgotLS0gL2Rldi9udWxsCisrKyBiL3QvdDQwMTgvZWxpeGlyLXByb3RvY29sCkBAIC0wLDAgKzEsNiBAQAorZGVmcHJvdG9jb2wgUklHSFQgZG8KKyAgQGRvYyAiIiIKKyAgQ2FsY3VsYXRlcyB0aGUgc2l6ZSAoYW5kIG5vdCB0aGUgbGVuZ3RoISkgb2YgYSBkYXRhIHN0cnVjdHVyZQorICAiIiIKKyAgZGVmIHNpemUoZGF0YSwgQ2hhbmdlTWUpCitlbmQKZGlmZiAtLWdpdCBhL3QvdDQwMTgvZWxpeGlyLXByb3RvY29sLWltcGxlbWVudGF0aW9uIGIvdC90NDAxOC9lbGl4aXItcHJvdG9jb2wtaW1wbGVtZW50YXRpb24KbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZjkyMzRiYgotLS0gL2Rldi9udWxsCisrKyBiL3QvdDQwMTgvZWxpeGlyLXByb3RvY29sLWltcGxlbWVudGF0aW9uCkBAIC0wLDAgKzEsNSBAQAorZGVmaW1wbCBSSUdIVCBkbworICAjIERvY3MKKyAgIyBEb2NzCisgIGRlZiBmb28oQ2hhbmdlTWUpLCBkbzogOm9rCitlbmQKZGlmZiAtLWdpdCBhL3QvdDQwMTgvcHl0aG9uLWFzeW5jLWRlZiBiL3QvdDQwMTgvcHl0aG9uLWFzeW5jLWRlZgpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi44NzY0MGUwCi0tLSAvZGV2L251bGwKKysrIGIvdC90NDAxOC9weXRob24tYXN5bmMtZGVmCkBAIC0wLDAgKzEsNCBAQAorYXN5bmMgZGVmIFJJR0hUKHBpOiBpbnQgPSAzLjE0KToKKyAgICB3aGlsZSBUcnVlOgorICAgICAgICBicmVhaworICAgIHJldHVybiBDaGFuZ2VNZSgpCmRpZmYgLS1naXQgYS90L3Q0MDE4L3B5dGhvbi1jbGFzcyBiL3QvdDQwMTgvcHl0aG9uLWNsYXNzCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmJhOWU3NDEKLS0tIC9kZXYvbnVsbAorKysgYi90L3Q0MDE4L3B5dGhvbi1jbGFzcwpAQCAtMCwwICsxLDQgQEAKK2NsYXNzIFJJR0hUKGludCwgc3RyKToKKyAgICAjIGNvbW1lbnQKKyAgICAjIGFub3RoZXIgY29tbWVudAorICAgICMgQ2hhbmdlTWUKZGlmZiAtLWdpdCBhL3QvdDQwMTgvcHl0aG9uLWRlZiBiL3QvdDQwMTgvcHl0aG9uLWRlZgpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5lNTBiMzFiCi0tLSAvZGV2L251bGwKKysrIGIvdC90NDAxOC9weXRob24tZGVmCkBAIC0wLDAgKzEsNCBAQAorZGVmIFJJR0hUKHBpOiBpbnQgPSAzLjE0KToKKyAgICB3aGlsZSBUcnVlOgorICAgICAgICBicmVhaworICAgIHJldHVybiBDaGFuZ2VNZSgpCmRpZmYgLS1naXQgYS90L3Q0MDE4L3B5dGhvbi1pbmRlbnRlZC1hc3luYy1kZWYgYi90L3Q0MDE4L3B5dGhvbi1pbmRlbnRlZC1hc3luYy1kZWYKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZjVkMDMyNQotLS0gL2Rldi9udWxsCisrKyBiL3QvdDQwMTgvcHl0aG9uLWluZGVudGVkLWFzeW5jLWRlZgpAQCAtMCwwICsxLDcgQEAKK2NsYXNzIEZvbzoKKyAgICBhc3luYyBkZWYgUklHSFQoc2VsZiwgeDogaW50KToKKyAgICAgICAgcmV0dXJuIFsKKyAgICAgICAgICAgIDEsCisgICAgICAgICAgICAyLAorICAgICAgICAgICAgQ2hhbmdlTWUsCisgICAgICAgIF0KZGlmZiAtLWdpdCBhL3QvdDQwMTgvcHl0aG9uLWluZGVudGVkLWNsYXNzIGIvdC90NDAxOC9weXRob24taW5kZW50ZWQtY2xhc3MKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMTliNGYzNQotLS0gL2Rldi9udWxsCisrKyBiL3QvdDQwMTgvcHl0aG9uLWluZGVudGVkLWNsYXNzCkBAIC0wLDAgKzEsNSBAQAoraWYgVFlQRV9DSEVDS0lORzoKKyAgICBjbGFzcyBSSUdIVDoKKyAgICAgICAgIyBjb21tZW50CisgICAgICAgICMgYW5vdGhlciBjb21tZW50CisgICAgICAgICMgQ2hhbmdlTWUKZGlmZiAtLWdpdCBhL3QvdDQwMTgvcHl0aG9uLWluZGVudGVkLWRlZiBiL3QvdDQwMTgvcHl0aG9uLWluZGVudGVkLWRlZgpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4yMDhmYmFkCi0tLSAvZGV2L251bGwKKysrIGIvdC90NDAxOC9weXRob24taW5kZW50ZWQtZGVmCkBAIC0wLDAgKzEsNyBAQAorY2xhc3MgRm9vOgorICAgIGRlZiBSSUdIVChzZWxmLCB4OiBpbnQpOgorICAgICAgICByZXR1cm4gWworICAgICAgICAgICAgMSwKKyAgICAgICAgICAgIDIsCisgICAgICAgICAgICBDaGFuZ2VNZSwKKyAgICAgICAgXQpkaWZmIC0tZ2l0IGEvdC90NDAyNy1kaWZmLXN1Ym1vZHVsZS5zaCBiL3QvdDQwMjctZGlmZi1zdWJtb2R1bGUuc2gKaW5kZXggOWFhOGUyYi4uZTI5ZGVhZiAxMDA3NTUKLS0tIGEvdC90NDAyNy1kaWZmLXN1Ym1vZHVsZS5zaAorKysgYi90L3Q0MDI3LWRpZmYtc3VibW9kdWxlLnNoCkBAIC02LDYgKzYsNyBAQAogLiAiJFRFU1RfRElSRUNUT1JZIi9kaWZmLWxpYi5zaAogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzIHNldHVwICcKKwl0ZXN0X29pZF9pbml0ICYmCiAJdGVzdF90aWNrICYmCiAJdGVzdF9jcmVhdGVfcmVwbyBzdWIgJiYKIAkoCkBAIC0zNiw3ICszNyw4IEBACiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2dpdCBkaWZmIC0tcmF3IEhFQUQnICcKLQlnaXQgZGlmZiAtLXJhdyAtLWFiYnJldj00MCBIRUFEID5hY3R1YWwgJiYKKwloZXhzej0kKHRlc3Rfb2lkIGhleHN6KSAmJgorCWdpdCBkaWZmIC0tcmF3IC0tYWJicmV2PSRoZXhzeiBIRUFEID5hY3R1YWwgJiYKIAl0ZXN0X2NtcCBleHBlY3QgYWN0dWFsCiAnCiAKQEAgLTI0NSwyMyArMjQ3LDIxIEBACiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2NvbmZsaWN0ZWQgc3VibW9kdWxlIHNldHVwJyAnCi0KLQkjIDM5IGVmcwotCWM9ZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmICYmCisJYz0kKHRlc3Rfb2lkIGZmXzEpICYmCiAJKAogCQllY2hvICIwMDAwMDAgJFpFUk9fT0lEIDAJc3ViIiAmJgogCQllY2hvICIxNjAwMDAgMSRjIDEJc3ViIiAmJgogCQllY2hvICIxNjAwMDAgMiRjIDIJc3ViIiAmJgogCQllY2hvICIxNjAwMDAgMyRjIDMJc3ViIgogCSkgfCBnaXQgdXBkYXRlLWluZGV4IC0taW5kZXgtaW5mbyAmJgotCWVjaG8gPmV4cGVjdC5ub3N1YiAnXCcnZGlmZiAtLWNjIHN1YgorCWVjaG8gPmV4cGVjdC5ub3N1YiAiZGlmZiAtLWNjIHN1YgogaW5kZXggMmZmZmZmZiwzZmZmZmZmLi4wMDAwMDAwCiAtLS0gYS9zdWIKICsrKyBiL3N1YgogQEBAIC0xLDEgLTEsMSArMSwxIEBAQAotLSBTdWJwcm9qZWN0IGNvbW1pdCAyZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmCi0gLVN1YnByb2plY3QgY29tbWl0IDNmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmYKLSsrU3VicHJvamVjdCBjb21taXQgMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMCdcJycgJiYKKy0gU3VicHJvamVjdCBjb21taXQgMiRjCisgLVN1YnByb2plY3QgY29tbWl0IDMkYworKytTdWJwcm9qZWN0IGNvbW1pdCAkWkVST19PSUQiICYmCiAKIAloaD0kKGdpdCByZXYtcGFyc2UgSEVBRCkgJiYKIAlzZWQgLWUgInMvJFpFUk9fT0lELyRoaC8iIGV4cGVjdC5ub3N1YiA+ZXhwZWN0LndpdGhzdWIKZGlmZiAtLWdpdCBhL3QvdDQwMzQtZGlmZi13b3Jkcy5zaCBiL3QvdDQwMzQtZGlmZi13b3Jkcy5zaAppbmRleCA5MTJkZjkxLi5mYjE0NWFhIDEwMDc1NQotLS0gYS90L3Q0MDM0LWRpZmYtd29yZHMuc2gKKysrIGIvdC90NDAzNC1kaWZmLXdvcmRzLnNoCkBAIC0xOSw5ICsxOSwxMSBAQAogCiAJYWVmZiA9IGFlZmYgKiAoIGFhYSApCiBFT0YKLWNhdCA+ZXhwZWN0LmxldHRlci1ydW5zLWFyZS13b3JkcyA8PC1cRU9GCitwcmU9JChnaXQgcmV2LXBhcnNlIC0tc2hvcnQgJChnaXQgaGFzaC1vYmplY3QgcHJlLnNpbXBsZSkpCitwb3N0PSQoZ2l0IHJldi1wYXJzZSAtLXNob3J0ICQoZ2l0IGhhc2gtb2JqZWN0IHBvc3Quc2ltcGxlKSkKK2NhdCA+ZXhwZWN0LmxldHRlci1ydW5zLWFyZS13b3JkcyA8PC1FT0YKIAk8Qk9MRD5kaWZmIC0tZ2l0IGEvcHJlIGIvcG9zdDxSRVNFVD4KLQk8Qk9MRD5pbmRleCAzMzBiMDRmLi41ZWQ4ZWZmIDEwMDY0NDxSRVNFVD4KKwk8Qk9MRD5pbmRleCAkcHJlLi4kcG9zdCAxMDA2NDQ8UkVTRVQ+CiAJPEJPTEQ+LS0tIGEvcHJlPFJFU0VUPgogCTxCT0xEPisrKyBiL3Bvc3Q8UkVTRVQ+CiAJPENZQU4+QEAgLTEsMyArMSw3IEBAPFJFU0VUPgpAQCAtMzMsOSArMzUsOSBAQAogCiAJPEdSRUVOPmFlZmYgPSBhZWZmICogKCBhYWE8UkVTRVQ+ICkKIEVPRgotY2F0ID5leHBlY3Qubm9uLXdoaXRlc3BhY2UtaXMtd29yZCA8PC1cRU9GCitjYXQgPmV4cGVjdC5ub24td2hpdGVzcGFjZS1pcy13b3JkIDw8LUVPRgogCTxCT0xEPmRpZmYgLS1naXQgYS9wcmUgYi9wb3N0PFJFU0VUPgotCTxCT0xEPmluZGV4IDMzMGIwNGYuLjVlZDhlZmYgMTAwNjQ0PFJFU0VUPgorCTxCT0xEPmluZGV4ICRwcmUuLiRwb3N0IDEwMDY0NDxSRVNFVD4KIAk8Qk9MRD4tLS0gYS9wcmU8UkVTRVQ+CiAJPEJPTEQ+KysrIGIvcG9zdDxSRVNFVD4KIAk8Q1lBTj5AQCAtMSwzICsxLDcgQEA8UkVTRVQ+CkBAIC00OSw5ICs1MSwxMiBAQAogRU9GCiAKIHdvcmRfZGlmZiAoKSB7CisJcHJlPSQoZ2l0IHJldi1wYXJzZSAtLXNob3J0ICQoZ2l0IGhhc2gtb2JqZWN0IHByZSkpICYmCisJcG9zdD0kKGdpdCByZXYtcGFyc2UgLS1zaG9ydCAkKGdpdCBoYXNoLW9iamVjdCBwb3N0KSkgJiYKIAl0ZXN0X211c3RfZmFpbCBnaXQgZGlmZiAtLW5vLWluZGV4ICIkQCIgcHJlIHBvc3QgPm91dHB1dCAmJgogCXRlc3RfZGVjb2RlX2NvbG9yIDxvdXRwdXQgPm91dHB1dC5kZWNyeXB0ZWQgJiYKLQl0ZXN0X2NtcCBleHBlY3Qgb3V0cHV0LmRlY3J5cHRlZAorCXNlZCAtZSAiMnMvaW5kZXggW14gXSovaW5kZXggJHByZS4uJHBvc3QvIiBleHBlY3QgPmV4cGVjdGVkCisJdGVzdF9jbXAgZXhwZWN0ZWQgb3V0cHV0LmRlY3J5cHRlZAogfQogCiB0ZXN0X2xhbmd1YWdlX2RyaXZlciAoKSB7CkBAIC03Nyw5ICs4Miw5IEBACiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3dvcmQgZGlmZiB3aXRoIHJ1bnMgb2Ygd2hpdGVzcGFjZScgJwotCWNhdCA+ZXhwZWN0IDw8LVxFT0YgJiYKKwljYXQgPmV4cGVjdCA8PC1FT0YgJiYKIAkJPEJPTEQ+ZGlmZiAtLWdpdCBhL3ByZSBiL3Bvc3Q8UkVTRVQ+Ci0JCTxCT0xEPmluZGV4IDMzMGIwNGYuLjVlZDhlZmYgMTAwNjQ0PFJFU0VUPgorCQk8Qk9MRD5pbmRleCAkcHJlLi4kcG9zdCAxMDA2NDQ8UkVTRVQ+CiAJCTxCT0xEPi0tLSBhL3ByZTxSRVNFVD4KIAkJPEJPTEQ+KysrIGIvcG9zdDxSRVNFVD4KIAkJPENZQU4+QEAgLTEsMyArMSw3IEBAPFJFU0VUPgpAQCAtOTcsOSArMTAyLDkgQEAKICcKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnLS13b3JkLWRpZmY9cG9yY2VsYWluJyAnCi0Jc2VkICdzLyMuKiQvLycgPmV4cGVjdCA8PC1cRU9GICYmCisJc2VkICdzLyMuKiQvLycgPmV4cGVjdCA8PC1FT0YgJiYKIAkJZGlmZiAtLWdpdCBhL3ByZSBiL3Bvc3QKLQkJaW5kZXggMzMwYjA0Zi4uNWVkOGVmZiAxMDA2NDQKKwkJaW5kZXggJHByZS4uJHBvc3QgMTAwNjQ0CiAJCS0tLSBhL3ByZQogCQkrKysgYi9wb3N0CiAJCUBAIC0xLDMgKzEsNyBAQApAQCAtMTIxLDkgKzEyNiw5IEBACiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJy0td29yZC1kaWZmPXBsYWluJyAnCi0JY2F0ID5leHBlY3QgPDwtXEVPRiAmJgorCWNhdCA+ZXhwZWN0IDw8LUVPRiAmJgogCQlkaWZmIC0tZ2l0IGEvcHJlIGIvcG9zdAotCQlpbmRleCAzMzBiMDRmLi41ZWQ4ZWZmIDEwMDY0NAorCQlpbmRleCAkcHJlLi4kcG9zdCAxMDA2NDQKIAkJLS0tIGEvcHJlCiAJCSsrKyBiL3Bvc3QKIAkJQEAgLTEsMyArMSw3IEBACkBAIC0xNDAsOSArMTQ1LDkgQEAKICcKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnLS13b3JkLWRpZmY9cGxhaW4gLS1jb2xvcicgJwotCWNhdCA+ZXhwZWN0IDw8LVxFT0YgJiYKKwljYXQgPmV4cGVjdCA8PC1FT0YgJiYKIAkJPEJPTEQ+ZGlmZiAtLWdpdCBhL3ByZSBiL3Bvc3Q8UkVTRVQ+Ci0JCTxCT0xEPmluZGV4IDMzMGIwNGYuLjVlZDhlZmYgMTAwNjQ0PFJFU0VUPgorCQk8Qk9MRD5pbmRleCAkcHJlLi4kcG9zdCAxMDA2NDQ8UkVTRVQ+CiAJCTxCT0xEPi0tLSBhL3ByZTxSRVNFVD4KIAkJPEJPTEQ+KysrIGIvcG9zdDxSRVNFVD4KIAkJPENZQU4+QEAgLTEsMyArMSw3IEBAPFJFU0VUPgpAQCAtMTU4LDkgKzE2Myw5IEBACiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3dvcmQgZGlmZiB3aXRob3V0IGNvbnRleHQnICcKLQljYXQgPmV4cGVjdCA8PC1cRU9GICYmCisJY2F0ID5leHBlY3QgPDwtRU9GICYmCiAJCTxCT0xEPmRpZmYgLS1naXQgYS9wcmUgYi9wb3N0PFJFU0VUPgotCQk8Qk9MRD5pbmRleCAzMzBiMDRmLi41ZWQ4ZWZmIDEwMDY0NDxSRVNFVD4KKwkJPEJPTEQ+aW5kZXggJHByZS4uJHBvc3QgMTAwNjQ0PFJFU0VUPgogCQk8Qk9MRD4tLS0gYS9wcmU8UkVTRVQ+CiAJCTxCT0xEPisrKyBiL3Bvc3Q8UkVTRVQ+CiAJCTxDWUFOPkBAIC0xICsxIEBAPFJFU0VUPgpAQCAtMjA3LDkgKzIxMiw5IEBACiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2NvbW1hbmQtbGluZSBvdmVycmlkZXMgY29uZmlnOiAtLXdvcmQtZGlmZi1yZWdleCcgJwotCWNhdCA+ZXhwZWN0IDw8LVxFT0YgJiYKKwljYXQgPmV4cGVjdCA8PC1FT0YgJiYKIAkJPEJPTEQ+ZGlmZiAtLWdpdCBhL3ByZSBiL3Bvc3Q8UkVTRVQ+Ci0JCTxCT0xEPmluZGV4IDMzMGIwNGYuLjVlZDhlZmYgMTAwNjQ0PFJFU0VUPgorCQk8Qk9MRD5pbmRleCAkcHJlLi4kcG9zdCAxMDA2NDQ8UkVTRVQ+CiAJCTxCT0xEPi0tLSBhL3ByZTxSRVNFVD4KIAkJPEJPTEQ+KysrIGIvcG9zdDxSRVNFVD4KIAkJPENZQU4+QEAgLTEsMyArMSw3IEBAPFJFU0VUPgpAQCAtMjM0LDkgKzIzOSw5IEBACiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3VzZSBjb25maWd1cmVkIHJlZ2V4JyAnCi0JY2F0ID5leHBlY3QgPDwtXEVPRiAmJgorCWNhdCA+ZXhwZWN0IDw8LUVPRiAmJgogCQk8Qk9MRD5kaWZmIC0tZ2l0IGEvcHJlIGIvcG9zdDxSRVNFVD4KLQkJPEJPTEQ+aW5kZXggMzMwYjA0Zi4uNWVkOGVmZiAxMDA2NDQ8UkVTRVQ+CisJCTxCT0xEPmluZGV4ICRwcmUuLiRwb3N0IDEwMDY0NDxSRVNFVD4KIAkJPEJPTEQ+LS0tIGEvcHJlPFJFU0VUPgogCQk8Qk9MRD4rKysgYi9wb3N0PFJFU0VUPgogCQk8Q1lBTj5AQCAtMSwzICsxLDcgQEA8UkVTRVQ+CkBAIC0yNTQsOSArMjU5LDExIEBACiB0ZXN0X2V4cGVjdF9zdWNjZXNzICd0ZXN0IHBhcnNpbmcgd29yZHMgZm9yIG5ld2xpbmUnICcKIAllY2hvICJhYWEgKGFhYSkiID5wcmUgJiYKIAllY2hvICJhYWEgKGFhYSkgYWFhIiA+cG9zdCAmJgotCWNhdCA+ZXhwZWN0IDw8LVxFT0YgJiYKKwlwcmU9JChnaXQgcmV2LXBhcnNlIC0tc2hvcnQgJChnaXQgaGFzaC1vYmplY3QgcHJlKSkgJiYKKwlwb3N0PSQoZ2l0IHJldi1wYXJzZSAtLXNob3J0ICQoZ2l0IGhhc2gtb2JqZWN0IHBvc3QpKSAmJgorCWNhdCA+ZXhwZWN0IDw8LUVPRiAmJgogCQk8Qk9MRD5kaWZmIC0tZ2l0IGEvcHJlIGIvcG9zdDxSRVNFVD4KLQkJPEJPTEQ+aW5kZXggYzI5NDUzYi4uYmUyMmYzNyAxMDA2NDQ8UkVTRVQ+CisJCTxCT0xEPmluZGV4ICRwcmUuLiRwb3N0IDEwMDY0NDxSRVNFVD4KIAkJPEJPTEQ+LS0tIGEvcHJlPFJFU0VUPgogCQk8Qk9MRD4rKysgYi9wb3N0PFJFU0VUPgogCQk8Q1lBTj5AQCAtMSArMSBAQDxSRVNFVD4KQEAgLTI2OCw5ICsyNzUsMTEgQEAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3Rlc3Qgd2hlbiB3b3JkcyBhcmUgb25seSByZW1vdmVkIGF0IHRoZSBlbmQnICcKIAllY2hvICIoOiIgPnByZSAmJgogCWVjaG8gIigiID5wb3N0ICYmCi0JY2F0ID5leHBlY3QgPDwtXEVPRiAmJgorCXByZT0kKGdpdCByZXYtcGFyc2UgLS1zaG9ydCAkKGdpdCBoYXNoLW9iamVjdCBwcmUpKSAmJgorCXBvc3Q9JChnaXQgcmV2LXBhcnNlIC0tc2hvcnQgJChnaXQgaGFzaC1vYmplY3QgcG9zdCkpICYmCisJY2F0ID5leHBlY3QgPDwtRU9GICYmCiAJCTxCT0xEPmRpZmYgLS1naXQgYS9wcmUgYi9wb3N0PFJFU0VUPgotCQk8Qk9MRD5pbmRleCAyODljYjlkLi4yZDA2ZjM3IDEwMDY0NDxSRVNFVD4KKwkJPEJPTEQ+aW5kZXggJHByZS4uJHBvc3QgMTAwNjQ0PFJFU0VUPgogCQk8Qk9MRD4tLS0gYS9wcmU8UkVTRVQ+CiAJCTxCT0xEPisrKyBiL3Bvc3Q8UkVTRVQ+CiAJCTxDWUFOPkBAIC0xICsxIEBAPFJFU0VUPgpAQCAtMjgyLDkgKzI5MSwxMSBAQAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnLS13b3JkLWRpZmY9bm9uZScgJwogCWVjaG8gIig6IiA+cHJlICYmCiAJZWNobyAiKCIgPnBvc3QgJiYKLQljYXQgPmV4cGVjdCA8PC1cRU9GICYmCisJcHJlPSQoZ2l0IHJldi1wYXJzZSAtLXNob3J0ICQoZ2l0IGhhc2gtb2JqZWN0IHByZSkpICYmCisJcG9zdD0kKGdpdCByZXYtcGFyc2UgLS1zaG9ydCAkKGdpdCBoYXNoLW9iamVjdCBwb3N0KSkgJiYKKwljYXQgPmV4cGVjdCA8PC1FT0YgJiYKIAkJZGlmZiAtLWdpdCBhL3ByZSBiL3Bvc3QKLQkJaW5kZXggMjg5Y2I5ZC4uMmQwNmYzNyAxMDA2NDQKKwkJaW5kZXggJHByZS4uJHBvc3QgMTAwNjQ0CiAJCS0tLSBhL3ByZQogCQkrKysgYi9wb3N0CiAJCUBAIC0xICsxIEBACkBAIC0zMDMsNiArMzE0LDcgQEAKIHRlc3RfbGFuZ3VhZ2VfZHJpdmVyIGNwcAogdGVzdF9sYW5ndWFnZV9kcml2ZXIgY3NoYXJwCiB0ZXN0X2xhbmd1YWdlX2RyaXZlciBjc3MKK3Rlc3RfbGFuZ3VhZ2VfZHJpdmVyIGR0cwogdGVzdF9sYW5ndWFnZV9kcml2ZXIgZm9ydHJhbgogdGVzdF9sYW5ndWFnZV9kcml2ZXIgaHRtbAogdGVzdF9sYW5ndWFnZV9kcml2ZXIgamF2YQpAQCAtMzE2LDE2ICszMjgsNiBAQAogdGVzdF9sYW5ndWFnZV9kcml2ZXIgdGV4CiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3dvcmQtZGlmZiB3aXRoIGRpZmYuc2JlJyAnCi0JY2F0ID5leHBlY3QgPDwtXEVPRiAmJgotCWRpZmYgLS1naXQgYS9wcmUgYi9wb3N0Ci0JaW5kZXggYTFhNTNiNS4uYmM4ZmU2ZCAxMDA2NDQKLQktLS0gYS9wcmUKLQkrKysgYi9wb3N0Ci0JQEAgLTEsMyArMSwzIEBACi0JYQotCi0JWy1iLV17K2MrfQotCUVPRgogCWNhdCA+cHJlIDw8LVxFT0YgJiYKIAlhCiAKQEAgLTMzNiwyMSArMzM4LDM1IEBACiAKIAljCiAJRU9GCisJcHJlPSQoZ2l0IHJldi1wYXJzZSAtLXNob3J0ICQoZ2l0IGhhc2gtb2JqZWN0IHByZSkpICYmCisJcG9zdD0kKGdpdCByZXYtcGFyc2UgLS1zaG9ydCAkKGdpdCBoYXNoLW9iamVjdCBwb3N0KSkgJiYKKwljYXQgPmV4cGVjdCA8PC1FT0YgJiYKKwlkaWZmIC0tZ2l0IGEvcHJlIGIvcG9zdAorCWluZGV4ICRwcmUuLiRwb3N0IDEwMDY0NAorCS0tLSBhL3ByZQorCSsrKyBiL3Bvc3QKKwlAQCAtMSwzICsxLDMgQEAKKwlhCisKKwlbLWItXXsrYyt9CisJRU9GCiAJdGVzdF9jb25maWcgZGlmZi5zdXBwcmVzcy1ibGFuay1lbXB0eSB0cnVlICYmCiAJd29yZF9kaWZmIC0td29yZC1kaWZmPXBsYWluCiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3dvcmQtZGlmZiB3aXRoIG5vIG5ld2xpbmUgYXQgRU9GJyAnCi0JY2F0ID5leHBlY3QgPDwtXEVPRiAmJgorCXByaW50ZiAiJXMiICJhIGEgYSBhIGEiID5wcmUgJiYKKwlwcmludGYgIiVzIiAiYSBhIGFiIGEgYSIgPnBvc3QgJiYKKwlwcmU9JChnaXQgcmV2LXBhcnNlIC0tc2hvcnQgJChnaXQgaGFzaC1vYmplY3QgcHJlKSkgJiYKKwlwb3N0PSQoZ2l0IHJldi1wYXJzZSAtLXNob3J0ICQoZ2l0IGhhc2gtb2JqZWN0IHBvc3QpKSAmJgorCWNhdCA+ZXhwZWN0IDw8LUVPRiAmJgogCWRpZmYgLS1naXQgYS9wcmUgYi9wb3N0Ci0JaW5kZXggN2JmMzE2ZS4uM2RkMDMwMyAxMDA2NDQKKwlpbmRleCAkcHJlLi4kcG9zdCAxMDA2NDQKIAktLS0gYS9wcmUKIAkrKysgYi9wb3N0CiAJQEAgLTEgKzEgQEAKIAlhIGEgWy1hLV17K2FiK30gYSBhCiAJRU9GCi0JcHJpbnRmICIlcyIgImEgYSBhIGEgYSIgPnByZSAmJgotCXByaW50ZiAiJXMiICJhIGEgYWIgYSBhIiA+cG9zdCAmJgogCXdvcmRfZGlmZiAtLXdvcmQtZGlmZj1wbGFpbgogJwogCmRpZmYgLS1naXQgYS90L3Q0MDM0L2R0cy9leHBlY3QgYi90L3Q0MDM0L2R0cy9leHBlY3QKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNTYwZmM5OQotLS0gL2Rldi9udWxsCisrKyBiL3QvdDQwMzQvZHRzL2V4cGVjdApAQCAtMCwwICsxLDM3IEBACis8Qk9MRD5kaWZmIC0tZ2l0IGEvcHJlIGIvcG9zdDxSRVNFVD4KKzxCT0xEPmluZGV4IGI2YTkwNTEuLjc4MDNhZWUgMTAwNjQ0PFJFU0VUPgorPEJPTEQ+LS0tIGEvcHJlPFJFU0VUPgorPEJPTEQ+KysrIGIvcG9zdDxSRVNFVD4KKzxDWUFOPkBAIC0xLDMyICsxLDMyIEBAPFJFU0VUPgorLyB7PFJFU0VUPgorCTxSRUQ+dGhpc19oYW5kbGU8UkVTRVQ+PEdSRUVOPkhBTkRMRV8yPFJFU0VUPjogPFJFRD5ub2RlPFJFU0VUPjxHUkVFTj5uZXctbm9kZTxSRVNFVD5APFJFRD5mMDA8UkVTRVQ+PEdSRUVOPmVlZGE8UkVTRVQ+IHsKKwkJY29tcGF0aWJsZSA9ICI8UkVEPm15ZGV2PFJFU0VUPjxHUkVFTj52ZW5kb3IsY29tcGF0PFJFU0VUPiI7CisJCXN0cmluZy1wcm9wID0gPFJFRD5zdGFydDxSRVNFVD48R1JFRU4+ZW5kPFJFU0VUPjogImhlbGxvIDxSRUQ+d29ybGQhPFJFU0VUPjxHUkVFTj53b3JsZD88UkVTRVQ+IiA8UkVEPmVuZDxSRVNFVD48R1JFRU4+c3RhcnQ8UkVTRVQ+OiA7CisJCTxSRUQ+I3NpemUtY2VsbHM8UkVTRVQ+PEdSRUVOPiNhZGRyZXNzLWNlbGxzPFJFU0VUPiA9IDw8UkVEPjArMDxSRVNFVD48R1JFRU4+MCs0MDxSRVNFVD4+OworCQlyZWcgPSA8PFJFRD4weGYwMDxSRVNFVD48R1JFRU4+MHhlZWRhPFJFU0VUPj47CisJCXByb3AgPSA8PEdSRUVOPig8UkVTRVQ+MTxHUkVFTj4pPFJFU0VUPj47CisJCXByb3AgPSA8PEdSRUVOPig8UkVTRVQ+LTFlMTA8R1JFRU4+KTxSRVNFVD4+OworCQlwcm9wID0gPCghPFJFRD4zPFJFU0VUPjxHUkVFTj4xPFJFU0VUPik+OworCQlwcm9wID0gPCh+PFJFRD4zPFJFU0VUPjxHUkVFTj4xPFJFU0VUPik+OworCQlwcm9wID0gPCg8UkVEPjM8UkVTRVQ+PEdSRUVOPjE8UkVTRVQ+KjxSRUQ+NDxSRVNFVD48R1JFRU4+MjxSRVNFVD4pPjsKKwkJcHJvcCA9IDwoPFJFRD4zPFJFU0VUPjxHUkVFTj4xPFJFU0VUPiY8UkVEPjQ8UkVTRVQ+PEdSRUVOPjI8UkVTRVQ+KT47CisJCXByb3AgPSA8KDxSRUQ+MzxSRVNFVD48R1JFRU4+MTxSRVNFVD4qPFJFRD40PFJFU0VUPjxHUkVFTj4yPFJFU0VUPik+OworCQlwcm9wID0gPCg8UkVEPjM8UkVTRVQ+PEdSRUVOPjE8UkVTRVQ+LzxSRUQ+NDxSRVNFVD48R1JFRU4+MjxSRVNFVD4pPjsKKwkJcHJvcCA9IDwoPFJFRD4zPFJFU0VUPjxHUkVFTj4xPFJFU0VUPiU8UkVEPjQ8UkVTRVQ+PEdSRUVOPjI8UkVTRVQ+KT47CisJCXByb3AgPSA8KDxSRUQ+Mys0PFJFU0VUPjxHUkVFTj4xKzI8UkVTRVQ+KT47CisJCXByb3AgPSA8KDxSRUQ+My00PFJFU0VUPjxHUkVFTj4xLTI8UkVTRVQ+KT47CisJCXByb3AgPSAvYml0cy8gPFJFRD42NDxSRVNFVD48R1JFRU4+MzI8UkVTRVQ+IDwoPFJFRD4zPFJFU0VUPjxHUkVFTj4xPFJFU0VUPjw8PFJFRD40PFJFU0VUPjxHUkVFTj4yPFJFU0VUPik+OworCQlwcm9wID0gPCg8UkVEPjM8UkVTRVQ+PEdSRUVOPjE8UkVTRVQ+Pj48UkVEPjQ8UkVTRVQ+PEdSRUVOPjI8UkVTRVQ+KT47CisJCXByb3AgPSA8KDxSRUQ+MzxSRVNFVD48R1JFRU4+MTxSRVNFVD4mPFJFRD40PFJFU0VUPjxHUkVFTj4yPFJFU0VUPik+OworCQlwcm9wID0gPCg8UkVEPjM8UkVTRVQ+PEdSRUVOPjE8UkVTRVQ+XjxSRUQ+NDxSRVNFVD48R1JFRU4+MjxSRVNFVD4pPjsKKwkJcHJvcCA9IDwoPFJFRD4zPFJFU0VUPjxHUkVFTj4xPFJFU0VUPnw8UkVEPjQ8UkVTRVQ+PEdSRUVOPjI8UkVTRVQ+KT47CisJCXByb3AgPSA8KDxSRUQ+MzxSRVNFVD48R1JFRU4+MTxSRVNFVD4mJjxSRUQ+NDxSRVNFVD48R1JFRU4+MjxSRVNFVD4pPjsKKwkJcHJvcCA9IDwoPFJFRD4zPFJFU0VUPjxHUkVFTj4xPFJFU0VUPnx8PFJFRD40PFJFU0VUPjxHUkVFTj4yPFJFU0VUPik+OworCQlwcm9wID0gPCg8UkVEPjQ/NTxSRVNFVD48R1JFRU4+MT8yPFJFU0VUPjozKT47CisJCWxpc3QgPSA8JjxSRUQ+dGhpc19oYW5kbGU8UkVTRVQ+PEdSRUVOPkhBTkRMRV8yPFJFU0VUPj4sIDwwIDAgMCA8UkVEPjA8UkVTRVQ+PEdSRUVOPjE8UkVTRVQ+PjsKKwl9OzxSRVNFVD4KKworCSY8UkVEPnBoYW5kbGU8UkVTRVQ+PEdSRUVOPnBoYW5kbGUyPFJFU0VUPiB7CisJCTxSRUQ+cHJlLXBoYW5kbGU8UkVTRVQ+PEdSRUVOPnByb3BfaGFuZGxlPFJFU0VUPiA9IDwmPFJFRD50aGlzX2hhbmRsZTxSRVNFVD48R1JFRU4+SEFORExFXzI8UkVTRVQ+PjsKKwl9OzxSRVNFVD4KK307PFJFU0VUPgpkaWZmIC0tZ2l0IGEvdC90NDAzNC9kdHMvcG9zdCBiL3QvdDQwMzQvZHRzL3Bvc3QKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNzgwM2FlZQotLS0gL2Rldi9udWxsCisrKyBiL3QvdDQwMzQvZHRzL3Bvc3QKQEAgLTAsMCArMSwzMiBAQAorLyB7CisJSEFORExFXzI6IG5ldy1ub2RlQGVlZGEgeworCQljb21wYXRpYmxlID0gInZlbmRvcixjb21wYXQiOworCQlzdHJpbmctcHJvcCA9IGVuZDogImhlbGxvIHdvcmxkPyIgc3RhcnQ6IDsKKwkJI2FkZHJlc3MtY2VsbHMgPSA8MCs0MD47CisJCXJlZyA9IDwweGVlZGE+OworCQlwcm9wID0gPCgxKT47CisJCXByb3AgPSA8KC0xZTEwKT47CisJCXByb3AgPSA8KCExKT47CisJCXByb3AgPSA8KH4xKT47CisJCXByb3AgPSA8KDEqMik+OworCQlwcm9wID0gPCgxJjIpPjsKKwkJcHJvcCA9IDwoMSoyKT47CisJCXByb3AgPSA8KDEvMik+OworCQlwcm9wID0gPCgxJTIpPjsKKwkJcHJvcCA9IDwoMSsyKT47CisJCXByb3AgPSA8KDEtMik+OworCQlwcm9wID0gL2JpdHMvIDMyIDwoMTw8Mik+OworCQlwcm9wID0gPCgxPj4yKT47CisJCXByb3AgPSA8KDEmMik+OworCQlwcm9wID0gPCgxXjIpPjsKKwkJcHJvcCA9IDwoMXwyKT47CisJCXByb3AgPSA8KDEmJjIpPjsKKwkJcHJvcCA9IDwoMXx8Mik+OworCQlwcm9wID0gPCgxPzI6Myk+OworCQlsaXN0ID0gPCZIQU5ETEVfMj4sIDwwIDAgMCAxPjsKKwl9OworCisJJnBoYW5kbGUyIHsKKwkJcHJvcF9oYW5kbGUgPSA8JkhBTkRMRV8yPjsKKwl9OworfTsKZGlmZiAtLWdpdCBhL3QvdDQwMzQvZHRzL3ByZSBiL3QvdDQwMzQvZHRzL3ByZQpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5iNmE5MDUxCi0tLSAvZGV2L251bGwKKysrIGIvdC90NDAzNC9kdHMvcHJlCkBAIC0wLDAgKzEsMzIgQEAKKy8geworCXRoaXNfaGFuZGxlOiBub2RlQGYwMCB7CisJCWNvbXBhdGlibGUgPSAibXlkZXYiOworCQlzdHJpbmctcHJvcCA9IHN0YXJ0OiAiaGVsbG8gd29ybGQhIiBlbmQ6IDsKKwkJI3NpemUtY2VsbHMgPSA8MCswPjsKKwkJcmVnID0gPDB4ZjAwPjsKKwkJcHJvcCA9IDwxPjsKKwkJcHJvcCA9IDwtMWUxMD47CisJCXByb3AgPSA8KCEzKT47CisJCXByb3AgPSA8KH4zKT47CisJCXByb3AgPSA8KDMqNCk+OworCQlwcm9wID0gPCgzJjQpPjsKKwkJcHJvcCA9IDwoMyo0KT47CisJCXByb3AgPSA8KDMvNCk+OworCQlwcm9wID0gPCgzJTQpPjsKKwkJcHJvcCA9IDwoMys0KT47CisJCXByb3AgPSA8KDMtNCk+OworCQlwcm9wID0gL2JpdHMvIDY0IDwoMzw8NCk+OworCQlwcm9wID0gPCgzPj40KT47CisJCXByb3AgPSA8KDMmNCk+OworCQlwcm9wID0gPCgzXjQpPjsKKwkJcHJvcCA9IDwoM3w0KT47CisJCXByb3AgPSA8KDMmJjQpPjsKKwkJcHJvcCA9IDwoM3x8NCk+OworCQlwcm9wID0gPCg0PzU6Myk+OworCQlsaXN0ID0gPCZ0aGlzX2hhbmRsZT4sIDwwIDAgMCAwPjsKKwl9OworCisJJnBoYW5kbGUgeworCQlwcmUtcGhhbmRsZSA9IDwmdGhpc19oYW5kbGU+OworCX07Cit9OwpkaWZmIC0tZ2l0IGEvdC90NDAzOC1kaWZmLWNvbWJpbmVkLnNoIGIvdC90NDAzOC1kaWZmLWNvbWJpbmVkLnNoCmluZGV4IGQ0YWZlMTIuLmI1YTU2ODkgMTAwNzU1Ci0tLSBhL3QvdDQwMzgtZGlmZi1jb21iaW5lZC5zaAorKysgYi90L3Q0MDM4LWRpZmYtY29tYmluZWQuc2gKQEAgLTQ0MCwxMSArNDQwLDEzIEBACiAJZ2l0IGJyYW5jaCBzaWRlMmMgJiYKIAlnaXQgY2hlY2tvdXQgc2lkZTFjICYmCiAJdGVzdF9zZXEgMSAxMCA+ZmlsZW5hbWUtc2lkZTFjICYmCisJc2lkZTFjZj0kKGdpdCBoYXNoLW9iamVjdCBmaWxlbmFtZS1zaWRlMWMpICYmCiAJZ2l0IGFkZCBmaWxlbmFtZS1zaWRlMWMgJiYKIAlnaXQgY29tbWl0IC1tIHdpdGggJiYKIAlnaXQgY2hlY2tvdXQgc2lkZTJjICYmCiAJdGVzdF9zZXEgMSA5ID5maWxlbmFtZS1zaWRlMmMgJiYKIAllY2hvIHRlbiA+PmZpbGVuYW1lLXNpZGUyYyAmJgorCXNpZGUyY2Y9JChnaXQgaGFzaC1vYmplY3QgZmlsZW5hbWUtc2lkZTJjKSAmJgogCWdpdCBhZGQgZmlsZW5hbWUtc2lkZTJjICYmCiAJZ2l0IGNvbW1pdCAtbSBpYW0gJiYKIAlnaXQgY2hlY2tvdXQgLWIgbWVyZ2VyeSBzaWRlMWMgJiYKQEAgLTQ1MiwxMyArNDU0LDE0IEBACiAJZ2l0IHJtIGZpbGVuYW1lLXNpZGUxYyAmJgogCWVjaG8gZWxldmVuID4+ZmlsZW5hbWUtc2lkZTJjICYmCiAJZ2l0IG12IGZpbGVuYW1lLXNpZGUyYyBmaWxlbmFtZS1tZXJnZWQgJiYKKwltZXJnZWRmPSQoZ2l0IGhhc2gtb2JqZWN0IGZpbGVuYW1lLW1lcmdlZCkgJiYKIAlnaXQgYWRkIGZpbGVuYW1lLW1lcmdlZCAmJgogCWdpdCBjb21taXQKICcKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnLS1jb21iaW5lZC1hbGwtcGF0aHMgYW5kIC0tcmF3JyAnCi0JY2F0IDw8LVxFT0YgPmV4cGVjdCAmJgotCTo6MTAwNjQ0IDEwMDY0NCAxMDA2NDQgZjAwYzk2NWQ4MzA3MzA4NDY5ZTUzNzMwMmJhYTczMDQ4NDg4ZjE2MiAwODhiZDVkOTJjMmE4ZTAyMDNjYThlN2U0YzJhNWM2OTJmNmFlM2Y3IDMzM2I5YzYyNTE5ZjI4NWUxODU0ODMwYWRlMGZlMWVmMWQ0MGVlMWIgUlIJZmlsZW5hbWUtc2lkZTFjCWZpbGVuYW1lLXNpZGUyYwlmaWxlbmFtZS1tZXJnZWQKKwljYXQgPDwtRU9GID5leHBlY3QgJiYKKwk6OjEwMDY0NCAxMDA2NDQgMTAwNjQ0ICRzaWRlMWNmICRzaWRlMmNmICRtZXJnZWRmIFJSCWZpbGVuYW1lLXNpZGUxYwlmaWxlbmFtZS1zaWRlMmMJZmlsZW5hbWUtbWVyZ2VkCiAJRU9GCiAJZ2l0IGRpZmYtdHJlZSAtYyAtTSAtLXJhdyAtLWNvbWJpbmVkLWFsbC1wYXRocyBIRUFEID5hY3R1YWwudG1wICYmCiAJc2VkIDFkIDxhY3R1YWwudG1wID5hY3R1YWwgJiYKQEAgLTQ4MiwxMSArNDg1LDEzIEBACiAJZ2l0IGNoZWNrb3V0IHNpZGUxZCAmJgogCXRlc3Rfc2VxIDEgMTAgPiIkKHByaW50ZiAiZmlsZVx0d2l0aFx0dGFicyIpIiAmJgogCWdpdCBhZGQgZmlsZSogJiYKKwlzaWRlMWRmPSQoZ2l0IGhhc2gtb2JqZWN0ICp0YWJzKSAmJgogCWdpdCBjb21taXQgLW0gd2l0aCAmJgogCWdpdCBjaGVja291dCBzaWRlMmQgJiYKIAl0ZXN0X3NlcSAxIDkgPiIkKHByaW50ZiAiaVx0YW1cdHRhYmJlZCIpIiAmJgogCWVjaG8gdGVuID4+IiQocHJpbnRmICJpXHRhbVx0dGFiYmVkIikiICYmCiAJZ2l0IGFkZCAqdGFiYmVkICYmCisJc2lkZTJkZj0kKGdpdCBoYXNoLW9iamVjdCAqdGFiYmVkKSAmJgogCWdpdCBjb21taXQgLW0gaWFtICYmCiAJZ2l0IGNoZWNrb3V0IC1iIGZ1bm55LW5hbWVzLW1lcmdlcnkgc2lkZTFkICYmCiAJZ2l0IG1lcmdlIC0tbm8tY29tbWl0IHNpZGUyZCAmJgpAQCAtNDk0LDEyICs0OTksMTQgQEAKIAllY2hvIGVsZXZlbiA+PiIkKHByaW50ZiAiaVx0YW1cdHRhYmJlZCIpIiAmJgogCWdpdCBtdiAiJChwcmludGYgImlcdGFtXHR0YWJiZWQiKSIgIiQocHJpbnRmICJmaWNrbGVcdG5hbWluZyIpIiAmJgogCWdpdCBhZGQgZmlja2xlKiAmJgotCWdpdCBjb21taXQKKwloZWFkZj0kKGdpdCBoYXNoLW9iamVjdCBmaWNrbGUqKSAmJgorCWdpdCBjb21taXQgJiYKKwloZWFkPSQoZ2l0IHJldi1wYXJzZSBIRUFEKQogJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzIEZVTk5ZTkFNRVMgJy0tY29tYmluZWQtYWxsLXBhdGhzIGFuZCAtLXJhdyBhbmQgZnVubnkgbmFtZXMnICcKLQljYXQgPDwtXEVPRiA+ZXhwZWN0ICYmCi0JOjoxMDA2NDQgMTAwNjQ0IDEwMDY0NCBmMDBjOTY1ZDgzMDczMDg0NjllNTM3MzAyYmFhNzMwNDg0ODhmMTYyIDA4OGJkNWQ5MmMyYThlMDIwM2NhOGU3ZTRjMmE1YzY5MmY2YWUzZjcgMzMzYjljNjI1MTlmMjg1ZTE4NTQ4MzBhZGUwZmUxZWYxZDQwZWUxYiBSUgkiZmlsZVx0d2l0aFx0dGFicyIJImlcdGFtXHR0YWJiZWQiCSJmaWNrbGVcdG5hbWluZyIKKwljYXQgPDwtRU9GID5leHBlY3QgJiYKKwk6OjEwMDY0NCAxMDA2NDQgMTAwNjQ0ICRzaWRlMWRmICRzaWRlMmRmICRoZWFkZiBSUgkiZmlsZVx0d2l0aFx0dGFicyIJImlcdGFtXHR0YWJiZWQiCSJmaWNrbGVcdG5hbWluZyIKIAlFT0YKIAlnaXQgZGlmZi10cmVlIC1jIC1NIC0tcmF3IC0tY29tYmluZWQtYWxsLXBhdGhzIEhFQUQgPmFjdHVhbC50bXAgJiYKIAlzZWQgMWQgPGFjdHVhbC50bXAgPmFjdHVhbCAmJgpAQCAtNTA3LDkgKzUxNCw5IEBACiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgRlVOTllOQU1FUyAnLS1jb21iaW5lZC1hbGwtcGF0aHMgYW5kIC0tcmF3IC1hbmQgLXogYW5kIGZ1bm55IG5hbWVzJyAnCi0JcHJpbnRmICJhYWY4MDg3YzNjYmQ0ZGI4ZTE4NWEyZDA3NGNmMjdjNTNjZmI3NWQ3XDA6OjEwMDY0NCAxMDA2NDQgMTAwNjQ0IGYwMGM5NjVkODMwNzMwODQ2OWU1MzczMDJiYWE3MzA0ODQ4OGYxNjIgMDg4YmQ1ZDkyYzJhOGUwMjAzY2E4ZTdlNGMyYTVjNjkyZjZhZTNmNyAzMzNiOWM2MjUxOWYyODVlMTg1NDgzMGFkZTBmZTFlZjFkNDBlZTFiIFJSXDBmaWxlXHR3aXRoXHR0YWJzXDBpXHRhbVx0dGFiYmVkXDBmaWNrbGVcdG5hbWluZ1wwIiA+ZXhwZWN0ICYmCisJcHJpbnRmICIkaGVhZFwwOjoxMDA2NDQgMTAwNjQ0IDEwMDY0NCAkc2lkZTFkZiAkc2lkZTJkZiAkaGVhZGYgUlJcMGZpbGVcdHdpdGhcdHRhYnNcMGlcdGFtXHR0YWJiZWRcMGZpY2tsZVx0bmFtaW5nXDAiID5leHBlY3QgJiYKIAlnaXQgZGlmZi10cmVlIC1jIC1NIC0tcmF3IC0tY29tYmluZWQtYWxsLXBhdGhzIC16IEhFQUQgPmFjdHVhbCAmJgotCXRlc3RfY21wIC1hIGV4cGVjdCBhY3R1YWwKKwl0ZXN0X2NtcCBleHBlY3QgYWN0dWFsCiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgRlVOTllOQU1FUyAnLS1jb21iaW5lZC1hbGwtcGF0aHMgYW5kIC0tY2MgYW5kIGZ1bm55IG5hbWVzJyAnCmRpZmYgLS1naXQgYS90L3Q0MDM5LWRpZmYtYXNzdW1lLXVuY2hhbmdlZC5zaCBiL3QvdDQwMzktZGlmZi1hc3N1bWUtdW5jaGFuZ2VkLnNoCmluZGV4IDUzYWM0NGIuLjBlYjAzMTQgMTAwNzU1Ci0tLSBhL3QvdDQwMzktZGlmZi1hc3N1bWUtdW5jaGFuZ2VkLnNoCisrKyBiL3QvdDQwMzktZGlmZi1hc3N1bWUtdW5jaGFuZ2VkLnNoCkBAIC0xMiw2ICsxMiw3IEBACiAJZ2l0IGNvbW1pdCAtbSB6ZXJvICYmCiAJZWNobyBvbmUgPiBvbmUgJiYKIAllY2hvIHR3byA+IHR3byAmJgorCWJsb2I9JChnaXQgaGFzaC1vYmplY3Qgb25lKSAmJgogCWdpdCBhZGQgb25lIHR3byAmJgogCWdpdCBjb21taXQgLW0gb25ldHdvICYmCiAJZ2l0IHVwZGF0ZS1pbmRleCAtLWFzc3VtZS11bmNoYW5nZWQgb25lICYmCkBAIC0yMCw3ICsyMSw3IEBACiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2RpZmYtaW5kZXggZG9lcyBub3QgZXhhbWluZSBhc3N1bWUtdW5jaGFuZ2VkIGVudHJpZXMnICcKLQlnaXQgZGlmZi1pbmRleCBIRUFEXiAtLSBvbmUgfCBncmVwIC1xIDU2MjZhYmYwZjcyZTU4ZDdhMTUzMzY4YmE1N2RiNGM2NzNjMGUxNzEKKwlnaXQgZGlmZi1pbmRleCBIRUFEXiAtLSBvbmUgfCBncmVwIC1xICRibG9iCiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2RpZmYtZmlsZXMgZG9lcyBub3QgZXhhbWluZSBhc3N1bWUtdW5jaGFuZ2VkIGVudHJpZXMnICcKZGlmZiAtLWdpdCBhL3QvdDQwNDEtZGlmZi1zdWJtb2R1bGUtb3B0aW9uLnNoIGIvdC90NDA0MS1kaWZmLXN1Ym1vZHVsZS1vcHRpb24uc2gKaW5kZXggNjE5YmY5Ny4uZjg1MjEzNiAxMDA3NTUKLS0tIGEvdC90NDA0MS1kaWZmLXN1Ym1vZHVsZS1vcHRpb24uc2gKKysrIGIvdC90NDA0MS1kaWZmLXN1Ym1vZHVsZS1vcHRpb24uc2gKQEAgLTI4NCw3ICsyODQsNyBAQAogCXRlc3RfbXVzdF9iZV9lbXB0eSBhY3R1YWwKICcKIAotdGVzdF9leHBlY3Rfc3VjY2VzcyAnc3VibW9kdWxlIGNvbnRhaW5zIHVudHJhY2tlZCBhbmQgbW9kaWZlZCBjb250ZW50JyAnCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdzdWJtb2R1bGUgY29udGFpbnMgdW50cmFja2VkIGFuZCBtb2RpZmllZCBjb250ZW50JyAnCiAJZWNobyBuZXcgPiBzbTEvZm9vNiAmJgogCWdpdCBkaWZmLWluZGV4IC1wIC0tc3VibW9kdWxlPWxvZyBIRUFEID5hY3R1YWwgJiYKIAljYXQgPmV4cGVjdGVkIDw8LUVPRiAmJgpAQCAtMjk0LDcgKzI5NCw3IEBACiAJdGVzdF9jbXAgZXhwZWN0ZWQgYWN0dWFsCiAnCiAKLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3N1Ym1vZHVsZSBjb250YWlucyB1bnRyYWNrZWQgYW5kIG1vZGlmZWQgY29udGVudCAodW50cmFja2VkIGlnbm9yZWQpJyAnCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdzdWJtb2R1bGUgY29udGFpbnMgdW50cmFja2VkIGFuZCBtb2RpZmllZCBjb250ZW50ICh1bnRyYWNrZWQgaWdub3JlZCknICcKIAllY2hvIG5ldyA+IHNtMS9mb282ICYmCiAJZ2l0IGRpZmYtaW5kZXggLXAgLS1pZ25vcmUtc3VibW9kdWxlcz11bnRyYWNrZWQgLS1zdWJtb2R1bGU9bG9nIEhFQUQgPmFjdHVhbCAmJgogCWNhdCA+ZXhwZWN0ZWQgPDwtRU9GICYmCkBAIC0zMDMsMTkgKzMwMywxOSBAQAogCXRlc3RfY21wIGV4cGVjdGVkIGFjdHVhbAogJwogCi10ZXN0X2V4cGVjdF9zdWNjZXNzICdzdWJtb2R1bGUgY29udGFpbnMgdW50cmFja2VkIGFuZCBtb2RpZmVkIGNvbnRlbnQgKGRpcnR5IGlnbm9yZWQpJyAnCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdzdWJtb2R1bGUgY29udGFpbnMgdW50cmFja2VkIGFuZCBtb2RpZmllZCBjb250ZW50IChkaXJ0eSBpZ25vcmVkKScgJwogCWVjaG8gbmV3ID4gc20xL2ZvbzYgJiYKIAlnaXQgZGlmZi1pbmRleCAtcCAtLWlnbm9yZS1zdWJtb2R1bGVzPWRpcnR5IC0tc3VibW9kdWxlPWxvZyBIRUFEID5hY3R1YWwgJiYKIAl0ZXN0X211c3RfYmVfZW1wdHkgYWN0dWFsCiAnCiAKLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3N1Ym1vZHVsZSBjb250YWlucyB1bnRyYWNrZWQgYW5kIG1vZGlmZWQgY29udGVudCAoYWxsIGlnbm9yZWQpJyAnCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdzdWJtb2R1bGUgY29udGFpbnMgdW50cmFja2VkIGFuZCBtb2RpZmllZCBjb250ZW50IChhbGwgaWdub3JlZCknICcKIAllY2hvIG5ldyA+IHNtMS9mb282ICYmCiAJZ2l0IGRpZmYtaW5kZXggLXAgLS1pZ25vcmUtc3VibW9kdWxlcyAtLXN1Ym1vZHVsZT1sb2cgSEVBRCA+YWN0dWFsICYmCiAJdGVzdF9tdXN0X2JlX2VtcHR5IGFjdHVhbAogJwogCi10ZXN0X2V4cGVjdF9zdWNjZXNzICdzdWJtb2R1bGUgY29udGFpbnMgbW9kaWZlZCBjb250ZW50JyAnCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdzdWJtb2R1bGUgY29udGFpbnMgbW9kaWZpZWQgY29udGVudCcgJwogCXJtIC1mIHNtMS9uZXctZmlsZSAmJgogCWdpdCBkaWZmLWluZGV4IC1wIC0tc3VibW9kdWxlPWxvZyBIRUFEID5hY3R1YWwgJiYKIAljYXQgPmV4cGVjdGVkIDw8LUVPRiAmJgpAQCAtMzY5LDcgKzM2OSw3IEBACiAJdGVzdF9tdXN0X2JlX2VtcHR5IGFjdHVhbAogJwogCi10ZXN0X2V4cGVjdF9zdWNjZXNzICdtb2RpZmllZCBzdWJtb2R1bGUgY29udGFpbnMgdW50cmFja2VkIGFuZCBtb2RpZmVkIGNvbnRlbnQnICcKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ21vZGlmaWVkIHN1Ym1vZHVsZSBjb250YWlucyB1bnRyYWNrZWQgYW5kIG1vZGlmaWVkIGNvbnRlbnQnICcKIAllY2hvIG1vZGlmaWNhdGlvbiA+PiBzbTEvZm9vNiAmJgogCWdpdCBkaWZmLWluZGV4IC1wIC0tc3VibW9kdWxlPWxvZyBIRUFEID5hY3R1YWwgJiYKIAljYXQgPmV4cGVjdGVkIDw8LUVPRiAmJgpAQCAtMzgxLDcgKzM4MSw3IEBACiAJdGVzdF9jbXAgZXhwZWN0ZWQgYWN0dWFsCiAnCiAKLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ21vZGlmaWVkIHN1Ym1vZHVsZSBjb250YWlucyB1bnRyYWNrZWQgYW5kIG1vZGlmZWQgY29udGVudCAodW50cmFja2VkIGlnbm9yZWQpJyAnCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdtb2RpZmllZCBzdWJtb2R1bGUgY29udGFpbnMgdW50cmFja2VkIGFuZCBtb2RpZmllZCBjb250ZW50ICh1bnRyYWNrZWQgaWdub3JlZCknICcKIAllY2hvIG1vZGlmaWNhdGlvbiA+PiBzbTEvZm9vNiAmJgogCWdpdCBkaWZmLWluZGV4IC1wIC0taWdub3JlLXN1Ym1vZHVsZXM9dW50cmFja2VkIC0tc3VibW9kdWxlPWxvZyBIRUFEID5hY3R1YWwgJiYKIAljYXQgPmV4cGVjdGVkIDw8LUVPRiAmJgpAQCAtMzkyLDcgKzM5Miw3IEBACiAJdGVzdF9jbXAgZXhwZWN0ZWQgYWN0dWFsCiAnCiAKLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ21vZGlmaWVkIHN1Ym1vZHVsZSBjb250YWlucyB1bnRyYWNrZWQgYW5kIG1vZGlmZWQgY29udGVudCAoZGlydHkgaWdub3JlZCknICcKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ21vZGlmaWVkIHN1Ym1vZHVsZSBjb250YWlucyB1bnRyYWNrZWQgYW5kIG1vZGlmaWVkIGNvbnRlbnQgKGRpcnR5IGlnbm9yZWQpJyAnCiAJZWNobyBtb2RpZmljYXRpb24gPj4gc20xL2ZvbzYgJiYKIAlnaXQgZGlmZi1pbmRleCAtcCAtLWlnbm9yZS1zdWJtb2R1bGVzPWRpcnR5IC0tc3VibW9kdWxlPWxvZyBIRUFEID5hY3R1YWwgJiYKIAljYXQgPmV4cGVjdGVkIDw8LUVPRiAmJgpAQCAtNDAyLDEzICs0MDIsMTMgQEAKIAl0ZXN0X2NtcCBleHBlY3RlZCBhY3R1YWwKICcKIAotdGVzdF9leHBlY3Rfc3VjY2VzcyAnbW9kaWZpZWQgc3VibW9kdWxlIGNvbnRhaW5zIHVudHJhY2tlZCBhbmQgbW9kaWZlZCBjb250ZW50IChhbGwgaWdub3JlZCknICcKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ21vZGlmaWVkIHN1Ym1vZHVsZSBjb250YWlucyB1bnRyYWNrZWQgYW5kIG1vZGlmaWVkIGNvbnRlbnQgKGFsbCBpZ25vcmVkKScgJwogCWVjaG8gbW9kaWZpY2F0aW9uID4+IHNtMS9mb282ICYmCiAJZ2l0IGRpZmYtaW5kZXggLXAgLS1pZ25vcmUtc3VibW9kdWxlcyAtLXN1Ym1vZHVsZT1sb2cgSEVBRCA+YWN0dWFsICYmCiAJdGVzdF9tdXN0X2JlX2VtcHR5IGFjdHVhbAogJwogCi10ZXN0X2V4cGVjdF9zdWNjZXNzICdtb2RpZmllZCBzdWJtb2R1bGUgY29udGFpbnMgbW9kaWZlZCBjb250ZW50JyAnCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdtb2RpZmllZCBzdWJtb2R1bGUgY29udGFpbnMgbW9kaWZpZWQgY29udGVudCcgJwogCXJtIC1mIHNtMS9uZXctZmlsZSAmJgogCWdpdCBkaWZmLWluZGV4IC1wIC0tc3VibW9kdWxlPWxvZyBIRUFEID5hY3R1YWwgJiYKIAljYXQgPmV4cGVjdGVkIDw8LUVPRiAmJgpkaWZmIC0tZ2l0IGEvdC90NDA0NC1kaWZmLWluZGV4LXVuaXF1ZS1hYmJyZXYuc2ggYi90L3Q0MDQ0LWRpZmYtaW5kZXgtdW5pcXVlLWFiYnJldi5zaAppbmRleCA2NDc5MDVlLi40NzAxNzk2IDEwMDc1NQotLS0gYS90L3Q0MDQ0LWRpZmYtaW5kZXgtdW5pcXVlLWFiYnJldi5zaAorKysgYi90L3Q0MDQ0LWRpZmYtaW5kZXgtdW5pcXVlLWFiYnJldi5zaApAQCAtMywzNCArMyw0OCBAQAogdGVzdF9kZXNjcmlwdGlvbj0ndGVzdCB1bmlxdWUgc2hhMSBhYmJyZXZpYXRpb24gb24gImluZGV4IGZyb20uLnRvIiBsaW5lJwogLiAuL3Rlc3QtbGliLnNoCiAKLWlmICEgdGVzdF9oYXZlX3ByZXJlcSBTSEExCi10aGVuCi0gICAgICAgc2tpcF9hbGw9J25vdCB1c2luZyBTSEEtMSBmb3Igb2JqZWN0cycKLSAgICAgICB0ZXN0X2RvbmUKLWZpCi0KLWNhdCA+ZXhwZWN0X2luaXRpYWwgPDxFT0YKLTEwMDY0NCBibG9iIDUxZDI3Mzg0NjNlYTRjYTY2Zjg2OTFjOTFlMzNjZTY0YjdkNDFiYjEJZm9vCi1FT0YKLQotY2F0ID5leHBlY3RfdXBkYXRlIDw8RU9GCi0xMDA2NDQgYmxvYiA1MWQyNzM4ZWZiNGFkOGExZTQwYmVkODM5YWI4ZTExNmYwYTE1ZTQ3CWZvbwotRU9GCi0KIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3NldHVwJyAnCi0JZWNobyA0ODI3ID4gZm9vICYmCisJdGVzdF9vaWRfY2FjaGUgPDwtRU9GICYmCisJdmFsMSBzaGExOjQ4MjcKKwl2YWwxIHNoYTI1Njo1NjY0CisKKwl2YWwyIHNoYTE6MTE3NDIKKwl2YWwyIHNoYTI1NjoxMDYyNQorCisJaGFzaDEgc2hhMTo1MWQyNzM4NDYzZWE0Y2E2NmY4NjkxYzkxZTMzY2U2NGI3ZDQxYmIxCisJaGFzaDEgc2hhMjU2OmFlMzFkZmZmMGFmOTNiMmM2MmIwMDk4YTAzOWIzODU2OWM0M2IwYTdlOTdiODczMDAwY2E0MmQxMjhmMjczNTAKKworCWhhc2h0MSBzaGExOjUxZDI3Mzg0CisJaGFzaHQxIHNoYTI1NjphZTMxZGZmZgorCisJaGFzaDIgc2hhMTo1MWQyNzM4ZWZiNGFkOGExZTQwYmVkODM5YWI4ZTExNmYwYTE1ZTQ3CisJaGFzaDIgc2hhMjU2OmFlMzFkZmZhZGE4OGE0NmZkNWY1M2M3ZWQ1YWEyNWE3YTg5NTFmMWQ1ZTg4NDU2YzMxN2M4ZDU0ODRkMjYzZTUKKworCWhhc2h0MiBzaGExOjUxZDI3MzhlCisJaGFzaHQyIHNoYTI1NjphZTMxZGZmYQorCUVPRgorCisJY2F0ID5leHBlY3RfaW5pdGlhbCA8PC1FT0YgJiYKKwkxMDA2NDQgYmxvYiAkKHRlc3Rfb2lkIGhhc2gxKQlmb28KKwlFT0YKKworCWNhdCA+ZXhwZWN0X3VwZGF0ZSA8PC1FT0YgJiYKKwkxMDA2NDQgYmxvYiAkKHRlc3Rfb2lkIGhhc2gyKQlmb28KKwlFT0YKKworCWVjaG8gIiQodGVzdF9vaWQgdmFsMSkiID4gZm9vICYmCiAJZ2l0IGFkZCBmb28gJiYKIAlnaXQgY29tbWl0IC1tICJpbml0aWFsIiAmJgogCWdpdCBjYXQtZmlsZSAtcCBIRUFEOiA+IGFjdHVhbCAmJgogCXRlc3RfY21wIGV4cGVjdF9pbml0aWFsIGFjdHVhbCAmJgotCWVjaG8gMTE3NDIgPiBmb28gJiYKKwllY2hvICIkKHRlc3Rfb2lkIHZhbDIpIiA+IGZvbyAmJgogCWdpdCBjb21taXQgLWEgLW0gInVwZGF0ZSIgJiYKIAlnaXQgY2F0LWZpbGUgLXAgSEVBRDogPiBhY3R1YWwgJiYKIAl0ZXN0X2NtcCBleHBlY3RfdXBkYXRlIGFjdHVhbAogJwogCiBjYXQgPmV4cGVjdCA8PEVPRgotaW5kZXggNTFkMjczODQuLjUxZDI3MzhlIDEwMDY0NAoraW5kZXggJCh0ZXN0X29pZCBoYXNodDEpLi4kKHRlc3Rfb2lkIGhhc2h0MikgMTAwNjQ0CiBFT0YKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnZGlmZiBkb2VzIG5vdCBwcm9kdWNlIGFtYmlndW91cyBpbmRleCBsaW5lJyAnCmRpZmYgLS1naXQgYS90L3Q0MDQ1LWRpZmYtcmVsYXRpdmUuc2ggYi90L3Q0MDQ1LWRpZmYtcmVsYXRpdmUuc2gKaW5kZXggMzZmOGVkOC4uMjU4ODA4NyAxMDA3NTUKLS0tIGEvdC90NDA0NS1kaWZmLXJlbGF0aXZlLnNoCisrKyBiL3QvdDQwNDUtZGlmZi1yZWxhdGl2ZS5zaApAQCAtNzAsNyArNzAsNyBAQAogCWV4cGVjdD0kMQogCXNoaWZ0CiAJY2F0ID5leHBlY3RlZCA8PC1FT0YKLQk6MDAwMDAwIDEwMDY0NCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwICRibG9iIEEJJGV4cGVjdAorCTowMDAwMDAgMTAwNjQ0ICRaRVJPX09JRCAkYmxvYiBBCSRleHBlY3QKIAlFT0YKIAl0ZXN0X2V4cGVjdF9zdWNjZXNzICItLXJhdyAkKiIgIgogCQlnaXQgLUMgJyRkaXInIGRpZmYgLS1uby1hYmJyZXYgLS1yYXcgJCogSEVBRF4gPmFjdHVhbCAmJgpkaWZmIC0tZ2l0IGEvdC90NDA0OC1kaWZmLWNvbWJpbmVkLWJpbmFyeS5zaCBiL3QvdDQwNDgtZGlmZi1jb21iaW5lZC1iaW5hcnkuc2gKaW5kZXggODdhODk0OS4uN2Y5YWQ5ZiAxMDA3NTUKLS0tIGEvdC90NDA0OC1kaWZmLWNvbWJpbmVkLWJpbmFyeS5zaAorKysgYi90L3Q0MDQ4LWRpZmYtY29tYmluZWQtYmluYXJ5LnNoCkBAIC05LDI0ICs5LDI3IEBACiAJZ2l0IGNvbW1pdCAtbSBvbmUgJiYKIAllY2hvIHR3b1EyIHwgcV90b19udWwgPmJpbmFyeSAmJgogCWdpdCBjb21taXQgLWEgLW0gdHdvICYmCisJdHdvPSQoZ2l0IHJldi1wYXJzZSAtLXNob3J0IEhFQUQ6YmluYXJ5KSAmJgogCWdpdCBjaGVja291dCAtYiBicmFuY2gtYmluYXJ5IEhFQUReICYmCiAJZWNobyB0aHJlZVEzIHwgcV90b19udWwgPmJpbmFyeSAmJgogCWdpdCBjb21taXQgLWEgLW0gdGhyZWUgJiYKKwl0aHJlZT0kKGdpdCByZXYtcGFyc2UgLS1zaG9ydCBIRUFEOmJpbmFyeSkgJiYKIAl0ZXN0X211c3RfZmFpbCBnaXQgbWVyZ2UgbWFzdGVyICYmCiAJZWNobyByZXNvbHZlZFFob29yYXkgfCBxX3RvX251bCA+YmluYXJ5ICYmCi0JZ2l0IGNvbW1pdCAtYSAtbSByZXNvbHZlZAorCWdpdCBjb21taXQgLWEgLW0gcmVzb2x2ZWQgJiYKKwlyZXM9JChnaXQgcmV2LXBhcnNlIC0tc2hvcnQgSEVBRDpiaW5hcnkpCiAnCiAKLWNhdCA+ZXhwZWN0IDw8J0VPRicKK2NhdCA+ZXhwZWN0IDw8RU9GCiByZXNvbHZlZAogCiBkaWZmIC0tZ2l0IGEvYmluYXJ5IGIvYmluYXJ5Ci1pbmRleCA3ZWE2ZGVkLi45NTYzNjkxIDEwMDY0NAoraW5kZXggJHRocmVlLi4kcmVzIDEwMDY0NAogQmluYXJ5IGZpbGVzIGEvYmluYXJ5IGFuZCBiL2JpbmFyeSBkaWZmZXIKIHJlc29sdmVkCiAKIGRpZmYgLS1naXQgYS9iaW5hcnkgYi9iaW5hcnkKLWluZGV4IDYxOTc1NzAuLjk1NjM2OTEgMTAwNjQ0CitpbmRleCAkdHdvLi4kcmVzIDEwMDY0NAogQmluYXJ5IGZpbGVzIGEvYmluYXJ5IGFuZCBiL2JpbmFyeSBkaWZmZXIKIEVPRgogdGVzdF9leHBlY3Rfc3VjY2VzcyAnZGlmZiAtbSBpbmRpY2F0ZXMgYmluYXJ5LW5lc3MnICcKQEAgLTM0LDExICszNywxMSBAQAogCXRlc3RfY21wIGV4cGVjdCBhY3R1YWwKICcKIAotY2F0ID5leHBlY3QgPDwnRU9GJworY2F0ID5leHBlY3QgPDxFT0YKIHJlc29sdmVkCiAKIGRpZmYgLS1jb21iaW5lZCBiaW5hcnkKLWluZGV4IDdlYTZkZWQsNjE5NzU3MC4uOTU2MzY5MQoraW5kZXggJHRocmVlLCR0d28uLiRyZXMKIEJpbmFyeSBmaWxlcyBkaWZmZXIKIEVPRgogdGVzdF9leHBlY3Rfc3VjY2VzcyAnZGlmZiAtYyBpbmRpY2F0ZXMgYmluYXJ5LW5lc3MnICcKQEAgLTQ2LDExICs0OSwxMSBAQAogCXRlc3RfY21wIGV4cGVjdCBhY3R1YWwKICcKIAotY2F0ID5leHBlY3QgPDwnRU9GJworY2F0ID5leHBlY3QgPDxFT0YKIHJlc29sdmVkCiAKIGRpZmYgLS1jYyBiaW5hcnkKLWluZGV4IDdlYTZkZWQsNjE5NzU3MC4uOTU2MzY5MQoraW5kZXggJHRocmVlLCR0d28uLiRyZXMKIEJpbmFyeSBmaWxlcyBkaWZmZXIKIEVPRgogdGVzdF9leHBlY3Rfc3VjY2VzcyAnZGlmZiAtLWNjIGluZGljYXRlcyBiaW5hcnktbmVzcycgJwpAQCAtNjIsMjMgKzY1LDI2IEBACiAJZ2l0IGNoZWNrb3V0IG1hc3RlciAmJgogCXRlc3RfY29tbWl0IG9uZSB0ZXh0ICYmCiAJdGVzdF9jb21taXQgdHdvIHRleHQgJiYKKwl0d289JChnaXQgcmV2LXBhcnNlIC0tc2hvcnQgSEVBRDp0ZXh0KSAmJgogCWdpdCBjaGVja291dCAtYiBicmFuY2gtdGV4dCBIRUFEXiAmJgogCXRlc3RfY29tbWl0IHRocmVlIHRleHQgJiYKKwl0aHJlZT0kKGdpdCByZXYtcGFyc2UgLS1zaG9ydCBIRUFEOnRleHQpICYmCiAJdGVzdF9tdXN0X2ZhaWwgZ2l0IG1lcmdlIG1hc3RlciAmJgogCXRlc3RfY29tbWl0IHJlc29sdmVkIHRleHQgJiYKKwlyZXM9JChnaXQgcmV2LXBhcnNlIC0tc2hvcnQgSEVBRDp0ZXh0KSAmJgogCWVjaG8gdGV4dCAtZGlmZiA+LmdpdGF0dHJpYnV0ZXMKICcKIAotY2F0ID5leHBlY3QgPDwnRU9GJworY2F0ID5leHBlY3QgPDxFT0YKIHJlc29sdmVkCiAKIGRpZmYgLS1naXQgYS90ZXh0IGIvdGV4dAotaW5kZXggMmJkZjY3YS4uMmFiMTlhZSAxMDA2NDQKK2luZGV4ICR0aHJlZS4uJHJlcyAxMDA2NDQKIEJpbmFyeSBmaWxlcyBhL3RleHQgYW5kIGIvdGV4dCBkaWZmZXIKIHJlc29sdmVkCiAKIGRpZmYgLS1naXQgYS90ZXh0IGIvdGV4dAotaW5kZXggZjcxOWVmZC4uMmFiMTlhZSAxMDA2NDQKK2luZGV4ICR0d28uLiRyZXMgMTAwNjQ0CiBCaW5hcnkgZmlsZXMgYS90ZXh0IGFuZCBiL3RleHQgZGlmZmVyCiBFT0YKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2RpZmYgLW0gcmVzcGVjdHMgYmluYXJ5IGF0dHJpYnV0ZScgJwpAQCAtODYsMTEgKzkyLDExIEBACiAJdGVzdF9jbXAgZXhwZWN0IGFjdHVhbAogJwogCi1jYXQgPmV4cGVjdCA8PCdFT0YnCitjYXQgPmV4cGVjdCA8PEVPRgogcmVzb2x2ZWQKIAogZGlmZiAtLWNvbWJpbmVkIHRleHQKLWluZGV4IDJiZGY2N2EsZjcxOWVmZC4uMmFiMTlhZQoraW5kZXggJHRocmVlLCR0d28uLiRyZXMKIEJpbmFyeSBmaWxlcyBkaWZmZXIKIEVPRgogdGVzdF9leHBlY3Rfc3VjY2VzcyAnZGlmZiAtYyByZXNwZWN0cyBiaW5hcnkgYXR0cmlidXRlJyAnCkBAIC05OCwxMSArMTA0LDExIEBACiAJdGVzdF9jbXAgZXhwZWN0IGFjdHVhbAogJwogCi1jYXQgPmV4cGVjdCA8PCdFT0YnCitjYXQgPmV4cGVjdCA8PEVPRgogcmVzb2x2ZWQKIAogZGlmZiAtLWNjIHRleHQKLWluZGV4IDJiZGY2N2EsZjcxOWVmZC4uMmFiMTlhZQoraW5kZXggJHRocmVlLCR0d28uLiRyZXMKIEJpbmFyeSBmaWxlcyBkaWZmZXIKIEVPRgogdGVzdF9leHBlY3Rfc3VjY2VzcyAnZGlmZiAtLWNjIHJlc3BlY3RzIGJpbmFyeSBhdHRyaWJ1dGUnICcKQEAgLTExNSwxMSArMTIxLDExIEBACiAJZ2l0IGNvbmZpZyBkaWZmLnVwY2FzZS50ZXh0Y29udiAidHIgYS16IEEtWiA8IgogJwogCi1jYXQgPmV4cGVjdCA8PCdFT0YnCitjYXQgPmV4cGVjdCA8PEVPRgogcmVzb2x2ZWQKIAogZGlmZiAtLWdpdCBhL3RleHQgYi90ZXh0Ci1pbmRleCAyYmRmNjdhLi4yYWIxOWFlIDEwMDY0NAoraW5kZXggJHRocmVlLi4kcmVzIDEwMDY0NAogLS0tIGEvdGV4dAogKysrIGIvdGV4dAogQEAgLTEgKzEgQEAKQEAgLTEyOCw3ICsxMzQsNyBAQAogcmVzb2x2ZWQKIAogZGlmZiAtLWdpdCBhL3RleHQgYi90ZXh0Ci1pbmRleCBmNzE5ZWZkLi4yYWIxOWFlIDEwMDY0NAoraW5kZXggJHR3by4uJHJlcyAxMDA2NDQKIC0tLSBhL3RleHQKICsrKyBiL3RleHQKIEBAIC0xICsxIEBACkBAIC0xNDAsMTEgKzE0NiwxMSBAQAogCXRlc3RfY21wIGV4cGVjdCBhY3R1YWwKICcKIAotY2F0ID5leHBlY3QgPDwnRU9GJworY2F0ID5leHBlY3QgPDxFT0YKIHJlc29sdmVkCiAKIGRpZmYgLS1jb21iaW5lZCB0ZXh0Ci1pbmRleCAyYmRmNjdhLGY3MTllZmQuLjJhYjE5YWUKK2luZGV4ICR0aHJlZSwkdHdvLi4kcmVzCiAtLS0gYS90ZXh0CiArKysgYi90ZXh0CiBAQEAgLTEsMSAtMSwxICsxLDEgQEBACkBAIC0xNTcsMTEgKzE2MywxMSBAQAogCXRlc3RfY21wIGV4cGVjdCBhY3R1YWwKICcKIAotY2F0ID5leHBlY3QgPDwnRU9GJworY2F0ID5leHBlY3QgPDxFT0YKIHJlc29sdmVkCiAKIGRpZmYgLS1jYyB0ZXh0Ci1pbmRleCAyYmRmNjdhLGY3MTllZmQuLjJhYjE5YWUKK2luZGV4ICR0aHJlZSwkdHdvLi4kcmVzCiAtLS0gYS90ZXh0CiArKysgYi90ZXh0CiBAQEAgLTEsMSAtMSwxICsxLDEgQEBACkBAIC0xNzQsOSArMTgwLDkgQEAKIAl0ZXN0X2NtcCBleHBlY3QgYWN0dWFsCiAnCiAKLWNhdCA+ZXhwZWN0IDw8J0VPRicKK2NhdCA+ZXhwZWN0IDw8RU9GCiBkaWZmIC0tY29tYmluZWQgdGV4dAotaW5kZXggMmJkZjY3YSxmNzE5ZWZkLi4yYWIxOWFlCitpbmRleCAkdGhyZWUsJHR3by4uJHJlcwogLS0tIGEvdGV4dAogKysrIGIvdGV4dAogQEBAIC0xLDEgLTEsMSArMSwxIEBAQApAQCAtMTkwLDkgKzE5Niw5IEBACiAJdGVzdF9jbXAgZXhwZWN0IGFjdHVhbAogJwogCi1jYXQgPmV4cGVjdCA8PCdFT0YnCitjYXQgPmV4cGVjdCA8PEVPRgogZGlmZiAtLWNjIHRleHQKLWluZGV4IDJiZGY2N2EsZjcxOWVmZC4uMDAwMDAwMAoraW5kZXggJHRocmVlLCR0d28uLjAwMDAwMDAKIC0tLSBhL3RleHQKICsrKyBiL3RleHQKIEBAQCAtMSwxIC0xLDEgKzEsNSBAQEAKZGlmZiAtLWdpdCBhL3QvdDQwNTctZGlmZi1jb21iaW5lZC1wYXRocy5zaCBiL3QvdDQwNTctZGlmZi1jb21iaW5lZC1wYXRocy5zaAppbmRleCBkZmYzNmI3Li40ZjRiNTQxIDEwMDc1NQotLS0gYS90L3Q0MDU3LWRpZmYtY29tYmluZWQtcGF0aHMuc2gKKysrIGIvdC90NDA1Ny1kaWZmLWNvbWJpbmVkLXBhdGhzLnNoCkBAIC0zMyw3ICszMyw3IEBACiAnCiAKIAotdGVzdF9leHBlY3Rfc3VjY2VzcyAnb25seSBvbmUgdHJ1bGx5IGNvbmZsaWN0aW5nIHBhdGgnICcKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ29ubHkgb25lIHRydWx5IGNvbmZsaWN0aW5nIHBhdGgnICcKIAlnaXQgY2hlY2tvdXQgc2lkZSAmJgogCWZvciBpIGluICQodGVzdF9zZXEgMiA5KQogCWRvCmRpZmYgLS1naXQgYS90L3Q0MDY3LWRpZmYtcGFydGlhbC1jbG9uZS5zaCBiL3QvdDQwNjctZGlmZi1wYXJ0aWFsLWNsb25lLnNoCmluZGV4IDkwYzhmYjIuLjQ4MzFhZDMgMTAwNzU1Ci0tLSBhL3QvdDQwNjctZGlmZi1wYXJ0aWFsLWNsb25lLnNoCisrKyBiL3QvdDQwNjctZGlmZi1wYXJ0aWFsLWNsb25lLnNoCkBAIC03NSw2ICs3NSwzNyBAQAogCSEgZ3JlcCAid2FudCAkKGNhdCBoYXNoLWIpIiB0cmFjZQogJwogCit0ZXN0X2V4cGVjdF9zdWNjZXNzICd3aGVuIGZldGNoaW5nIG1pc3Npbmcgb2JqZWN0cywgZGlmZiBza2lwcyBHSVRMSU5LcycgJworCXRlc3Rfd2hlbl9maW5pc2hlZCAicm0gLXJmIHN1YiBzZXJ2ZXIgY2xpZW50IHRyYWNlIiAmJgorCisJdGVzdF9jcmVhdGVfcmVwbyBzdWIgJiYKKwl0ZXN0X2NvbW1pdCAtQyBzdWIgZmlyc3QgJiYKKworCXRlc3RfY3JlYXRlX3JlcG8gc2VydmVyICYmCisJZWNobyBhID5zZXJ2ZXIvYSAmJgorCWdpdCAtQyBzZXJ2ZXIgYWRkIGEgJiYKKwlnaXQgLUMgc2VydmVyIHN1Ym1vZHVsZSBhZGQgImZpbGU6Ly8kKHB3ZCkvc3ViIiAmJgorCWdpdCAtQyBzZXJ2ZXIgY29tbWl0IC1tIHggJiYKKworCXRlc3RfY29tbWl0IC1DIHNlcnZlci9zdWIgc2Vjb25kICYmCisJZWNobyBhbm90aGVyLWEgPnNlcnZlci9hICYmCisJZ2l0IC1DIHNlcnZlciBhZGQgYSBzdWIgJiYKKwlnaXQgLUMgc2VydmVyIGNvbW1pdCAtbSB4ICYmCisKKwl0ZXN0X2NvbmZpZyAtQyBzZXJ2ZXIgdXBsb2FkcGFjay5hbGxvd2ZpbHRlciAxICYmCisJdGVzdF9jb25maWcgLUMgc2VydmVyIHVwbG9hZHBhY2suYWxsb3dhbnlzaGExaW53YW50IDEgJiYKKwlnaXQgY2xvbmUgLS1iYXJlIC0tZmlsdGVyPWJsb2I6bGltaXQ9MCAiZmlsZTovLyQocHdkKS9zZXJ2ZXIiIGNsaWVudCAmJgorCisJZWNobyBhIHwgZ2l0IGhhc2gtb2JqZWN0IC0tc3RkaW4gPmhhc2gtb2xkLWEgJiYKKwllY2hvIGFub3RoZXItYSB8IGdpdCBoYXNoLW9iamVjdCAtLXN0ZGluID5oYXNoLW5ldy1hICYmCisKKwkjIEVuc3VyZSB0aGF0IGEgYW5kIGFub3RoZXItYSBhcmUgZmV0Y2hlZCwgYW5kIGNoZWNrIChieSBzdWNjZXNzZnVsCisJIyBleGVjdXRpb24gb2YgdGhlIGRpZmYpIHRoYXQgbm8gaW52YWxpZCBPSURzIGFyZSBzZW50LgorCUdJVF9UUkFDRV9QQUNLRVQ9IiQocHdkKS90cmFjZSIgZ2l0IC1DIGNsaWVudCBkaWZmIEhFQUReIEhFQUQgJiYKKwlncmVwICJ3YW50ICQoY2F0IGhhc2gtb2xkLWEpIiB0cmFjZSAmJgorCWdyZXAgIndhbnQgJChjYXQgaGFzaC1uZXctYSkiIHRyYWNlCisnCisKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2RpZmYgd2l0aCByZW5hbWUgZGV0ZWN0aW9uIGJhdGNoZXMgYmxvYnMnICcKIAl0ZXN0X3doZW5fZmluaXNoZWQgInJtIC1yZiBzZXJ2ZXIgY2xpZW50IHRyYWNlIiAmJgogCmRpZmYgLS1naXQgYS90L3Q0MTAwL3QtYXBwbHktMS5wYXRjaCBiL3QvdDQxMDAvdC1hcHBseS0xLnBhdGNoCmluZGV4IDkwYWI1NGYuLjQzMzk0ZjggMTAwNjQ0Ci0tLSBhL3QvdDQxMDAvdC1hcHBseS0xLnBhdGNoCisrKyBiL3QvdDQxMDAvdC1hcHBseS0xLnBhdGNoCkBAIC03NSw4ICs3NSw4IEBACiArbGluazpnaXQtc3NoLXB1bGwuaHRtbFtnaXQtc3NoLXB1bGxdOjoKICAJUHVsbHMgZnJvbSBhIHJlbW90ZSByZXBvc2l0b3J5IG92ZXIgc3NoIGNvbm5lY3Rpb24KICAKLSBJbnRlcm9nYXRvcnM6Ci1AQCAtMTU2LDggKzE1Niw4IEBAIEludGVyb2dhdG9yczoKKyBJbnRlcnJvZ2F0b3JzOgorQEAgLTE1Niw4ICsxNTYsOCBAQCBJbnRlcnJvZ2F0b3JzOgogIGxpbms6Z2l0LWRpZmYtaGVscGVyLmh0bWxbZ2l0LWRpZmYtaGVscGVyXTo6CiAgCUdlbmVyYXRlcyBwYXRjaCBmb3JtYXQgb3V0cHV0IGZvciBnaXQtZGlmZi0qCiAgCmRpZmYgLS1naXQgYS90L3Q0MTAwL3QtYXBwbHktMy5wYXRjaCBiL3QvdDQxMDAvdC1hcHBseS0zLnBhdGNoCmluZGV4IDkwY2RiYWEuLmNhYzE3MmUgMTAwNjQ0Ci0tLSBhL3QvdDQxMDAvdC1hcHBseS0zLnBhdGNoCisrKyBiL3QvdDQxMDAvdC1hcHBseS0zLnBhdGNoCkBAIC0yMTEsNyArMjExLDcgQEAKIC0KIC0JCS8qIElmIHRoaXMgaXMgYW4gZXhhY3QgZGlyZWN0b3J5IG1hdGNoLCB3ZSBtYXkgaGF2ZQogLQkJICogZGlyZWN0b3J5IGZpbGVzIGZvbGxvd2luZyB0aGlzIHBhdGguIE1hdGNoIG9uIHRoZW0uCi0tCQkgKiBPdGhlcndpc2UsIHdlJ3JlIGF0IGEgcGFjaCBzdWJjb21wb25lbnQsIGFuZCB3ZSBuZWVkCistCQkgKiBPdGhlcndpc2UsIHdlJ3JlIGF0IGEgcGF0Y2ggc3ViY29tcG9uZW50LCBhbmQgd2UgbmVlZAogLQkJICogdG8gdHJ5IHRvIG1hdGNoIGFnYWluLgogLQkJICovCiAtCQlpZiAobXR5cGUgPT0gMCkKZGlmZiAtLWdpdCBhL3QvdDQxMDAvdC1hcHBseS01LnBhdGNoIGIvdC90NDEwMC90LWFwcGx5LTUucGF0Y2gKaW5kZXggNWY2ZGRjMS4uNTdlYzc5ZCAxMDA2NDQKLS0tIGEvdC90NDEwMC90LWFwcGx5LTUucGF0Y2gKKysrIGIvdC90NDEwMC90LWFwcGx5LTUucGF0Y2gKQEAgLTE4NSw4ICsxODUsOCBAQAogK2xpbms6Z2l0LXNzaC1wdWxsLmh0bWxbZ2l0LXNzaC1wdWxsXTo6CiAgCVB1bGxzIGZyb20gYSByZW1vdGUgcmVwb3NpdG9yeSBvdmVyIHNzaCBjb25uZWN0aW9uCiAgCi0gSW50ZXJvZ2F0b3JzOgotQEAgLTE1Niw4ICsxNTYsOCBAQCBJbnRlcm9nYXRvcnM6CisgSW50ZXJyb2dhdG9yczoKK0BAIC0xNTYsOCArMTU2LDggQEAgSW50ZXJyb2dhdG9yczoKICBsaW5rOmdpdC1kaWZmLWhlbHBlci5odG1sW2dpdC1kaWZmLWhlbHBlcl06OgogIAlHZW5lcmF0ZXMgcGF0Y2ggZm9ybWF0IG91dHB1dCBmb3IgZ2l0LWRpZmYtKgogIApkaWZmIC0tZ2l0IGEvdC90NDEwMC90LWFwcGx5LTcucGF0Y2ggYi90L3Q0MTAwL3QtYXBwbHktNy5wYXRjaAppbmRleCAwN2M2NTg5Li5mYTI0MzA1IDEwMDY0NAotLS0gYS90L3Q0MTAwL3QtYXBwbHktNy5wYXRjaAorKysgYi90L3Q0MTAwL3QtYXBwbHktNy5wYXRjaApAQCAtMzM1LDcgKzMzNSw3IEBACiAgCiAtCQkvKiBJZiB0aGlzIGlzIGFuIGV4YWN0IGRpcmVjdG9yeSBtYXRjaCwgd2UgbWF5IGhhdmUKIC0JCSAqIGRpcmVjdG9yeSBmaWxlcyBmb2xsb3dpbmcgdGhpcyBwYXRoLiBNYXRjaCBvbiB0aGVtLgotLQkJICogT3RoZXJ3aXNlLCB3ZSdyZSBhdCBhIHBhY2ggc3ViY29tcG9uZW50LCBhbmQgd2UgbmVlZAorLQkJICogT3RoZXJ3aXNlLCB3ZSdyZSBhdCBhIHBhdGNoIHN1YmNvbXBvbmVudCwgYW5kIHdlIG5lZWQKIC0JCSAqIHRvIHRyeSB0byBtYXRjaCBhZ2Fpbi4KICsJaWYgKGUtPmRpcmVjdG9yeSkgewogKwkJLyogSWYgdGhpcyBpcyBhIGRpcmVjdG9yeSwgd2UgaGF2ZSB0aGUgZm9sbG93aW5nIGNhc2VzOgpkaWZmIC0tZ2l0IGEvdC90NDEwOC1hcHBseS10aHJlZXdheS5zaCBiL3QvdDQxMDgtYXBwbHktdGhyZWV3YXkuc2gKaW5kZXggZmE1ZDRlZi4uZDczNDljZSAxMDA3NTUKLS0tIGEvdC90NDEwOC1hcHBseS10aHJlZXdheS5zaAorKysgYi90L3Q0MTA4LWFwcGx5LXRocmVld2F5LnNoCkBAIC00LDIzICs0LDE3IEBACiAKIC4gLi90ZXN0LWxpYi5zaAogCi1jcmVhdGVfZmlsZSAoKSB7Ci0JZm9yIGkKLQlkbwotCQllY2hvICIkaSIKLQlkb25lCi19Ci0KLXNhbml0aXplX2NvbmZsaWN0ZWRfZGlmZiAoKSB7CitwcmludF9zYW5pdGl6ZWRfY29uZmxpY3RlZF9kaWZmICgpIHsKKwlnaXQgZGlmZiBIRUFEID5kaWZmLnJhdyAmJgogCXNlZCAtZSAnCiAJCS9eaW5kZXggL2QKLQkJcy9eXCgrWzw+XVs8Pl1bPD5dWzw+XSpcKSAuKi9cMS8KLQknCisJCXMvXlwoK1s8PnxdWzw+fF1bPD58XVs8PnxdKlwpIC4qL1wxLworCScgZGlmZi5yYXcKIH0KIAogdGVzdF9leHBlY3Rfc3VjY2VzcyBzZXR1cCAnCiAJdGVzdF90aWNrICYmCi0JY3JlYXRlX2ZpbGUgPm9uZSAxIDIgMyA0IDUgNiA3ICYmCisJdGVzdF93cml0ZV9saW5lcyAxIDIgMyA0IDUgNiA3ID5vbmUgJiYKIAljYXQgb25lID50d28gJiYKIAlnaXQgYWRkIG9uZSB0d28gJiYKIAlnaXQgY29tbWl0IC1tIGluaXRpYWwgJiYKQEAgLTI4LDEzICsyMiwxMyBAQAogCWdpdCBicmFuY2ggc2lkZSAmJgogCiAJdGVzdF90aWNrICYmCi0JY3JlYXRlX2ZpbGUgPm9uZSAxIHR3byAzIDQgNSBzaXggNyAmJgotCWNyZWF0ZV9maWxlID50d28gMSB0d28gMyA0IDUgNiA3ICYmCisJdGVzdF93cml0ZV9saW5lcyAxIHR3byAzIDQgNSBzaXggNyA+b25lICYmCisJdGVzdF93cml0ZV9saW5lcyAxIHR3byAzIDQgNSA2IDcgPnR3byAmJgogCWdpdCBjb21taXQgLWEgLW0gbWFzdGVyICYmCiAKIAlnaXQgY2hlY2tvdXQgc2lkZSAmJgotCWNyZWF0ZV9maWxlID5vbmUgMSAyIDMgNCBmaXZlIDYgNyAmJgotCWNyZWF0ZV9maWxlID50d28gMSAyIDMgNCBmaXZlIDYgNyAmJgorCXRlc3Rfd3JpdGVfbGluZXMgMSAyIDMgNCBmaXZlIDYgNyA+b25lICYmCisJdGVzdF93cml0ZV9saW5lcyAxIDIgMyA0IGZpdmUgNiA3ID50d28gJiYKIAlnaXQgY29tbWl0IC1hIC1tIHNpZGUgJiYKIAogCWdpdCBjaGVja291dCBtYXN0ZXIKQEAgLTUyLDcgKzQ2LDcgQEAKIAlnaXQgZGlmZi1pbmRleCAtLWV4aXQtY29kZSAtLWNhY2hlZCBIRUFECiAnCiAKLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2FwcGx5IHdpdGggLS0zd2F5JyAnCit0ZXN0X2FwcGx5X3dpdGhfM3dheSAoKSB7CiAJIyBNZXJnaW5nIHNpZGUgc2hvdWxkIGJlIHNpbWlsYXIgdG8gYXBwbHlpbmcgdGhpcyBwYXRjaAogCWdpdCBkaWZmIC4uLnNpZGUgPlAuZGlmZiAmJgogCkBAIC02MSwyMiArNTUsMzEgQEAKIAlnaXQgY2hlY2tvdXQgbWFzdGVyXjAgJiYKIAl0ZXN0X211c3RfZmFpbCBnaXQgbWVyZ2UgLS1uby1jb21taXQgc2lkZSAmJgogCWdpdCBscy1maWxlcyAtcyA+ZXhwZWN0LmxzICYmCi0JZ2l0IGRpZmYgSEVBRCB8IHNhbml0aXplX2NvbmZsaWN0ZWRfZGlmZiA+ZXhwZWN0LmRpZmYgJiYKKwlwcmludF9zYW5pdGl6ZWRfY29uZmxpY3RlZF9kaWZmID5leHBlY3QuZGlmZiAmJgogCiAJIyBzaG91bGQgZmFpbCB0byBhcHBseQogCWdpdCByZXNldCAtLWhhcmQgJiYKIAlnaXQgY2hlY2tvdXQgbWFzdGVyXjAgJiYKIAl0ZXN0X211c3RfZmFpbCBnaXQgYXBwbHkgLS1pbmRleCAtLTN3YXkgUC5kaWZmICYmCiAJZ2l0IGxzLWZpbGVzIC1zID5hY3R1YWwubHMgJiYKLQlnaXQgZGlmZiBIRUFEIHwgc2FuaXRpemVfY29uZmxpY3RlZF9kaWZmID5hY3R1YWwuZGlmZiAmJgorCXByaW50X3Nhbml0aXplZF9jb25mbGljdGVkX2RpZmYgPmFjdHVhbC5kaWZmICYmCiAKIAkjIFRoZSByZXN1bHQgc2hvdWxkIHJlc2VtYmxlIHRoZSBjb3JyZXNwb25kaW5nIG1lcmdlCiAJdGVzdF9jbXAgZXhwZWN0LmxzIGFjdHVhbC5scyAmJgogCXRlc3RfY21wIGV4cGVjdC5kaWZmIGFjdHVhbC5kaWZmCit9CisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2FwcGx5IHdpdGggLS0zd2F5JyAnCisJdGVzdF9hcHBseV93aXRoXzN3YXkKKycKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAnYXBwbHkgd2l0aCAtLTN3YXkgd2l0aCBtZXJnZS5jb25mbGljdFN0eWxlID0gZGlmZjMnICcKKwl0ZXN0X2NvbmZpZyBtZXJnZS5jb25mbGljdFN0eWxlIGRpZmYzICYmCisJdGVzdF9hcHBseV93aXRoXzN3YXkKICcKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnYXBwbHkgd2l0aCAtLTN3YXkgd2l0aCByZXJlcmUgZW5hYmxlZCcgJwotCWdpdCBjb25maWcgcmVyZXJlLmVuYWJsZWQgdHJ1ZSAmJgorCXRlc3RfY29uZmlnIHJlcmVyZS5lbmFibGVkIHRydWUgJiYKIAogCSMgTWVyZ2luZyBzaWRlIHNob3VsZCBiZSBzaW1pbGFyIHRvIGFwcGx5aW5nIHRoaXMgcGF0Y2gKIAlnaXQgZGlmZiAuLi5zaWRlID5QLmRpZmYgJiYKQEAgLTg3LDcgKzkwLDcgQEAKIAl0ZXN0X211c3RfZmFpbCBnaXQgbWVyZ2UgLS1uby1jb21taXQgc2lkZSAmJgogCiAJIyBNYW51YWxseSByZXNvbHZlIGFuZCByZWNvcmQgdGhlIHJlc29sdXRpb24KLQljcmVhdGVfZmlsZSAxIHR3byAzIDQgZml2ZSBzaXggNyA+b25lICYmCisJdGVzdF93cml0ZV9saW5lcyAxIHR3byAzIDQgZml2ZSBzaXggNyA+b25lICYmCiAJZ2l0IHJlcmVyZSAmJgogCWNhdCBvbmUgPmV4cGVjdCAmJgogCkBAIC0xMDQsMTQgKzEwNywxNCBAQAogCWdpdCByZXNldCAtLWhhcmQgJiYKIAogCWdpdCBjaGVja291dCAtYiBhZGRlciAmJgotCWNyZWF0ZV9maWxlIDEgMiAzIDQgNSA2IDcgPnRocmVlICYmCi0JY3JlYXRlX2ZpbGUgMSAyIDMgNCA1IDYgNyA+Zm91ciAmJgorCXRlc3Rfd3JpdGVfbGluZXMgMSAyIDMgNCA1IDYgNyA+dGhyZWUgJiYKKwl0ZXN0X3dyaXRlX2xpbmVzIDEgMiAzIDQgNSA2IDcgPmZvdXIgJiYKIAlnaXQgYWRkIHRocmVlIGZvdXIgJiYKIAlnaXQgY29tbWl0IC1tICJhZGQgdGhyZWUgYW5kIGZvdXIiICYmCiAKIAlnaXQgY2hlY2tvdXQgLWIgYW5vdGhlciBhZGRlcl4gJiYKLQljcmVhdGVfZmlsZSAxIDIgMyA0IDUgNiA3ID50aHJlZSAmJgotCWNyZWF0ZV9maWxlIDEgMiAzIGZvdXIgNSA2IDcgPmZvdXIgJiYKKwl0ZXN0X3dyaXRlX2xpbmVzIDEgMiAzIDQgNSA2IDcgPnRocmVlICYmCisJdGVzdF93cml0ZV9saW5lcyAxIDIgMyBmb3VyIDUgNiA3ID5mb3VyICYmCiAJZ2l0IGFkZCB0aHJlZSBmb3VyICYmCiAJZ2l0IGNvbW1pdCAtbSAiYWRkIHRocmVlIGFuZCBmb3VyIiAmJgogCkBAIC0xMjEsNyArMTI0LDcgQEAKIAlnaXQgY2hlY2tvdXQgYWRkZXJeMCAmJgogCXRlc3RfbXVzdF9mYWlsIGdpdCBtZXJnZSAtLW5vLWNvbW1pdCBhbm90aGVyICYmCiAJZ2l0IGxzLWZpbGVzIC1zID5leHBlY3QubHMgJiYKLQlnaXQgZGlmZiBIRUFEIHwgc2FuaXRpemVfY29uZmxpY3RlZF9kaWZmID5leHBlY3QuZGlmZgorCXByaW50X3Nhbml0aXplZF9jb25mbGljdGVkX2RpZmYgPmV4cGVjdC5kaWZmCiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2FwcGx5IC0zIHdpdGggYWRkL2FkZCBjb25mbGljdCcgJwpAQCAtMTMxLDcgKzEzNCw3IEBACiAJdGVzdF9tdXN0X2ZhaWwgZ2l0IGFwcGx5IC0taW5kZXggLS0zd2F5IFAuZGlmZiAmJgogCSMgLi4uIGFuZCBsZWF2ZSBjb25mbGljdHMgaW4gdGhlIGluZGV4IGFuZCBpbiB0aGUgd29ya2luZyB0cmVlCiAJZ2l0IGxzLWZpbGVzIC1zID5hY3R1YWwubHMgJiYKLQlnaXQgZGlmZiBIRUFEIHwgc2FuaXRpemVfY29uZmxpY3RlZF9kaWZmID5hY3R1YWwuZGlmZiAmJgorCXByaW50X3Nhbml0aXplZF9jb25mbGljdGVkX2RpZmYgPmFjdHVhbC5kaWZmICYmCiAKIAkjIFRoZSByZXN1bHQgc2hvdWxkIHJlc2VtYmxlIHRoZSBjb3JyZXNwb25kaW5nIG1lcmdlCiAJdGVzdF9jbXAgZXhwZWN0LmxzIGFjdHVhbC5scyAmJgpkaWZmIC0tZ2l0IGEvdC90NDE1MC1hbS5zaCBiL3QvdDQxNTAtYW0uc2gKaW5kZXggM2Y3Zjc1MC4uNGYxZTI0ZSAxMDA3NTUKLS0tIGEvdC90NDE1MC1hbS5zaAorKysgYi90L3Q0MTUwLWFtLnNoCkBAIC0xMDYxLDQgKzEwNjEsNTYgQEAKIAl0ZXN0X2NtcCBleHBlY3RlZCBhY3R1YWwKICcKIAordGVzdF9leHBlY3Rfc3VjY2VzcyAnYW0gYW5kIC5naXRhdHRpYnV0ZXMnICcKKwl0ZXN0X2NyZWF0ZV9yZXBvIGF0dHJpYnV0ZXMgJiYKKwkoCisJCWNkIGF0dHJpYnV0ZXMgJiYKKwkJdGVzdF9jb21taXQgaW5pdCAmJgorCQlnaXQgY29uZmlnIGZpbHRlci50ZXN0LmNsZWFuICJzZWQgLWUgJ1wnJ3Mvc211ZGdlZC9jbGVhbi9nJ1wnJyIgJiYKKwkJZ2l0IGNvbmZpZyBmaWx0ZXIudGVzdC5zbXVkZ2UgInNlZCAtZSAnXCcncy9jbGVhbi9zbXVkZ2VkL2cnXCcnIiAmJgorCisJCXRlc3RfY29tbWl0IHNlY29uZCAmJgorCQlnaXQgY2hlY2tvdXQgLWIgdGVzdCBIRUFEXiAmJgorCisJCWVjaG8gIioudHh0IGZpbHRlcj10ZXN0IGNvbmZsaWN0LW1hcmtlci1zaXplPTEwIiA+LmdpdGF0dHJpYnV0ZXMgJiYKKwkJZ2l0IGFkZCAuZ2l0YXR0cmlidXRlcyAmJgorCQl0ZXN0X2NvbW1pdCB0aGlyZCAmJgorCisJCWVjaG8gIlRoaXMgdGV4dCBpcyBzbXVkZ2VkLiIgPmEudHh0ICYmCisJCWdpdCBhZGQgYS50eHQgJiYKKwkJdGVzdF9jb21taXQgZm91cnRoICYmCisKKwkJZ2l0IGNoZWNrb3V0IC1iIHJlbW92YWwgSEVBRF4gJiYKKwkJZ2l0IHJtIC5naXRhdHRyaWJ1dGVzICYmCisJCWdpdCBhZGQgLXUgJiYKKwkJdGVzdF9jb21taXQgZmlmdGggJiYKKwkJZ2l0IGNoZXJyeS1waWNrIHRlc3QgJiYKKworCQlnaXQgY2hlY2tvdXQgLWIgY29uZmxpY3QgdGhpcmQgJiYKKwkJZWNobyAiVGhpcyB0ZXh0IGlzIGRpZmZlcmVudC4iID5hLnR4dCAmJgorCQlnaXQgYWRkIGEudHh0ICYmCisJCXRlc3RfY29tbWl0IHNpeHRoICYmCisKKwkJZ2l0IGNoZWNrb3V0IHRlc3QgJiYKKwkJZ2l0IGZvcm1hdC1wYXRjaCAtLXN0ZG91dCBtYXN0ZXIuLkhFQUQgPnBhdGNoZXMgJiYKKwkJZ2l0IHJlc2V0IC0taGFyZCBtYXN0ZXIgJiYKKwkJZ2l0IGFtIHBhdGNoZXMgJiYKKwkJZ3JlcCAic211ZGdlZCIgYS50eHQgJiYKKworCQlnaXQgY2hlY2tvdXQgcmVtb3ZhbCAmJgorCQlnaXQgcmVzZXQgLS1oYXJkICYmCisJCWdpdCBmb3JtYXQtcGF0Y2ggLS1zdGRvdXQgbWFzdGVyLi5IRUFEID5wYXRjaGVzICYmCisJCWdpdCByZXNldCAtLWhhcmQgbWFzdGVyICYmCisJCWdpdCBhbSBwYXRjaGVzICYmCisJCWdyZXAgImNsZWFuIiBhLnR4dCAmJgorCisJCWdpdCBjaGVja291dCBjb25mbGljdCAmJgorCQlnaXQgcmVzZXQgLS1oYXJkICYmCisJCWdpdCBmb3JtYXQtcGF0Y2ggLS1zdGRvdXQgbWFzdGVyLi5IRUFEID5wYXRjaGVzICYmCisJCWdpdCByZXNldCAtLWhhcmQgZm91cnRoICYmCisJCXRlc3RfbXVzdF9mYWlsIGdpdCBhbSAtMyBwYXRjaGVzICYmCisJCWdyZXAgIjw8PDw8PDw8PDwiIGEudHh0CisJKQorJworCiB0ZXN0X2RvbmUKZGlmZiAtLWdpdCBhL3QvdDQyMDItbG9nLnNoIGIvdC90NDIwMi1sb2cuc2gKaW5kZXggYzIwMjA5My4uMmM5NDg5NCAxMDA3NTUKLS0tIGEvdC90NDIwMi1sb2cuc2gKKysrIGIvdC90NDIwMi1sb2cuc2gKQEAgLTY2Nyw3ICs2NjcsNyBAQAogKiB8IHwgZmlmdGgKICogfCB8IGZvdXJ0aAogfC8gLwotKiB8IHRoaXJkCisqIC8gdGhpcmQKIHwvCiAqIHNlY29uZAogKiBpbml0aWFsCkBAIC04MzcsNiArODM3LDIxIEBACiAJdGVzdF9jbXAgZXhwZWN0LmRlY29yYXRlIGFjdHVhbAogJwogCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdkZWNvcmF0ZS1yZWZzLWV4Y2x1ZGUgYW5kIHNpbXBsaWZ5LWJ5LWRlY29yYXRpb24nICcKKwljYXQgPmV4cGVjdC5kZWNvcmF0ZSA8PC1cRU9GICYmCisJTWVyZ2UtdGFnLXJlYWNoIChIRUFEIC0+IG1hc3RlcikKKwlyZWFjaCAodGFnOiByZWFjaCwgcmVhY2gpCisJc2V2ZW50aCAodGFnOiBzZXZlbnRoKQorCU1lcmdlLWJyYW5jaC10YW5nbGUKKwlNZXJnZS1icmFuY2gtc2lkZS1lYXJseS1wYXJ0LWludG8tdGFuZ2xlICh0YW5nbGUpCisJdGFuZ2xlLWEgKHRhZzogdGFuZ2xlLWEpCisJRU9GCisJZ2l0IGxvZyAtbjYgLS1kZWNvcmF0ZT1zaG9ydCAtLXByZXR0eT0idGZvcm1hdDolZiVkIiBcCisJCS0tZGVjb3JhdGUtcmVmcy1leGNsdWRlPSIqb2N0b3B1cyoiIFwKKwkJLS1zaW1wbGlmeS1ieS1kZWNvcmF0aW9uID5hY3R1YWwgJiYKKwl0ZXN0X2NtcCBleHBlY3QuZGVjb3JhdGUgYWN0dWFsCisnCisKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2xvZy5kZWNvcmF0ZSBjb25maWcgcGFyc2luZycgJwogCWdpdCBsb2cgLS1vbmVsaW5lIC0tZGVjb3JhdGU9ZnVsbCA+ZXhwZWN0LmZ1bGwgJiYKIAlnaXQgbG9nIC0tb25lbGluZSAtLWRlY29yYXRlPXNob3J0ID5leHBlY3Quc2hvcnQgJiYKQEAgLTE1NTUsNiArMTU3MCwxNCBAQAogCWdpdCBjb21taXQgLVMgLW0gc2lnbmVkX2NvbW1pdAogJwogCit0ZXN0X2V4cGVjdF9zdWNjZXNzIEdQRyAnc2V0dXAgc2lnbmVkIGJyYW5jaCB3aXRoIHN1YmtleScgJworCXRlc3Rfd2hlbl9maW5pc2hlZCAiZ2l0IHJlc2V0IC0taGFyZCAmJiBnaXQgY2hlY2tvdXQgbWFzdGVyIiAmJgorCWdpdCBjaGVja291dCAtYiBzaWduZWQtc3Via2V5IG1hc3RlciAmJgorCWVjaG8gZm9vID5mb28gJiYKKwlnaXQgYWRkIGZvbyAmJgorCWdpdCBjb21taXQgLVNCNzIyNzE4OSAtbSBzaWduZWRfY29tbWl0CisnCisKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgR1BHU00gJ3NldHVwIHNpZ25lZCBicmFuY2ggeDUwOScgJwogCXRlc3Rfd2hlbl9maW5pc2hlZCAiZ2l0IHJlc2V0IC0taGFyZCAmJiBnaXQgY2hlY2tvdXQgbWFzdGVyIiAmJgogCWdpdCBjaGVja291dCAtYiBzaWduZWQteDUwOSBtYXN0ZXIgJiYKQEAgLTE1NjUsNiArMTU4OCwxOCBAQAogCWdpdCBjb21taXQgLVMgLW0gc2lnbmVkX2NvbW1pdAogJwogCit0ZXN0X2V4cGVjdF9zdWNjZXNzIEdQR1NNICdsb2cgeDUwOSBmaW5nZXJwcmludCcgJworCWVjaG8gIkY4QkY2MkUwNjkzRDA2OTQ4MTYzNzcwOTk5MDlDNzc5RkEyM0ZENjUgfCAiID5leHBlY3QgJiYKKwlnaXQgbG9nIC1uMSAtLWZvcm1hdD0iJUdGIHwgJUdQIiBzaWduZWQteDUwOSA+YWN0dWFsICYmCisJdGVzdF9jbXAgZXhwZWN0IGFjdHVhbAorJworCit0ZXN0X2V4cGVjdF9zdWNjZXNzIEdQR1NNICdsb2cgT3BlblBHUCBmaW5nZXJwcmludCcgJworCWVjaG8gIkQ0QkUyMjMxMUFEMzEzMUU1RURBMjlBNDYxMDkyRTg1QjcyMjcxODkiID4gZXhwZWN0ICYmCisJZ2l0IGxvZyAtbjEgLS1mb3JtYXQ9IiVHUCIgc2lnbmVkLXN1YmtleSA+YWN0dWFsICYmCisJdGVzdF9jbXAgZXhwZWN0IGFjdHVhbAorJworCiB0ZXN0X2V4cGVjdF9zdWNjZXNzIEdQRyAnbG9nIC0tZ3JhcGggLS1zaG93LXNpZ25hdHVyZScgJwogCWdpdCBsb2cgLS1ncmFwaCAtLXNob3ctc2lnbmF0dXJlIC1uMSBzaWduZWQgPmFjdHVhbCAmJgogCWdyZXAgIl58IGdwZzogU2lnbmF0dXJlIG1hZGUiIGFjdHVhbCAmJgpAQCAtMTcwNyw0ICsxNzQyLDExIEBACiAJdGVzdF9tdXN0X2ZhaWwgZ2l0IGxvZyAtLWV4Y2x1ZGUtcHJvbWlzb3Itb2JqZWN0cyBzb3VyY2UtYQogJwogCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdsb2cgLS1lbmQtb2Ytb3B0aW9ucycgJworICAgICAgIGdpdCB1cGRhdGUtcmVmIHJlZnMvaGVhZHMvLS1zb3VyY2UgSEVBRCAmJgorICAgICAgIGdpdCBsb2cgLS1lbmQtb2Ytb3B0aW9ucyAtLXNvdXJjZSA+YWN0dWFsICYmCisgICAgICAgZ2l0IGxvZyA+ZXhwZWN0ICYmCisgICAgICAgdGVzdF9jbXAgZXhwZWN0IGFjdHVhbAorJworCiB0ZXN0X2RvbmUKZGlmZiAtLWdpdCBhL3QvdDQyMDMtbWFpbG1hcC5zaCBiL3QvdDQyMDMtbWFpbG1hcC5zaAppbmRleCA5MThhZGE2Li41ODZjM2E4IDEwMDc1NQotLS0gYS90L3Q0MjAzLW1haWxtYXAuc2gKKysrIGIvdC90NDIwMy1tYWlsbWFwLnNoCkBAIC0xMyw4ICsxMyw4IEBACiB9CiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3Mgc2V0dXAgJwotCWNhdCA+Y29udGFjdHMgPDwtXEVPRiAmJgotCUEgVSBUaG9yIDxhdXRob3JAZXhhbXBsZS5jb20+CisJY2F0ID5jb250YWN0cyA8PC0gRU9GICYmCisJJEdJVF9BVVRIT1JfTkFNRSA8JEdJVF9BVVRIT1JfRU1BSUw+CiAJbmljazEgPGJ1Z3NAY29tcGFueS54eD4KIAlFT0YKIApAQCAtMzMsMTkgKzMzLDE5IEBACiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2NoZWNrLW1haWxtYXAgYXJndW1lbnRzJyAnCi0JY2F0ID5leHBlY3QgPDwtXEVPRiAmJgotCUEgVSBUaG9yIDxhdXRob3JAZXhhbXBsZS5jb20+CisJY2F0ID5leHBlY3QgPDwtIEVPRiAmJgorCSRHSVRfQVVUSE9SX05BTUUgPCRHSVRfQVVUSE9SX0VNQUlMPgogCW5pY2sxIDxidWdzQGNvbXBhbnkueHg+CiAJRU9GCiAJZ2l0IGNoZWNrLW1haWxtYXAgXAotCQkiQSBVIFRob3IgPGF1dGhvckBleGFtcGxlLmNvbT4iIFwKKwkJIiRHSVRfQVVUSE9SX05BTUUgPCRHSVRfQVVUSE9SX0VNQUlMPiIgXAogCQkibmljazEgPGJ1Z3NAY29tcGFueS54eD4iID5hY3R1YWwgJiYKIAl0ZXN0X2NtcCBleHBlY3QgYWN0dWFsCiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2NoZWNrLW1haWxtYXAgLS1zdGRpbicgJwotCWNhdCA+ZXhwZWN0IDw8LVxFT0YgJiYKLQlBIFUgVGhvciA8YXV0aG9yQGV4YW1wbGUuY29tPgorCWNhdCA+ZXhwZWN0IDw8LSBFT0YgJiYKKwkkR0lUX0FVVEhPUl9OQU1FIDwkR0lUX0FVVEhPUl9FTUFJTD4KIAluaWNrMSA8YnVnc0Bjb21wYW55Lnh4PgogCUVPRgogCWdpdCBjaGVjay1tYWlsbWFwIC0tc3RkaW4gPGNvbnRhY3RzID5hY3R1YWwgJiYKQEAgLTY2LDggKzY2LDggQEAKIAl0ZXN0X211c3RfZmFpbCBnaXQgY2hlY2stbWFpbG1hcCBib2d1cwogJwogCi1jYXQgPmV4cGVjdCA8PFxFT0YKLUEgVSBUaG9yICgxKToKK2NhdCA+ZXhwZWN0IDw8IEVPRgorJEdJVF9BVVRIT1JfTkFNRSAoMSk6CiAgICAgICBpbml0aWFsCiAKIG5pY2sxICgxKToKQEAgLTkwLDcgKzkwLDcgQEAKIEVPRgogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdkZWZhdWx0IC5tYWlsbWFwJyAnCi0JZWNobyAiUmVwbyBHdXkgPGF1dGhvckBleGFtcGxlLmNvbT4iID4gLm1haWxtYXAgJiYKKwllY2hvICJSZXBvIEd1eSA8JEdJVF9BVVRIT1JfRU1BSUw+IiA+IC5tYWlsbWFwICYmCiAJZ2l0IHNob3J0bG9nIEhFQUQgPmFjdHVhbCAmJgogCXRlc3RfY21wIGV4cGVjdCBhY3R1YWwKICcKQEAgLTEyMiw3ICsxMjIsNyBAQAogCiBFT0YKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ21haWxtYXAuZmlsZSBvdmVycmlkZScgJwotCWVjaG8gIkV4dGVybmFsIEd1eSA8YXV0aG9yQGV4YW1wbGUuY29tPiIgPj4gaW50ZXJuYWxfbWFpbG1hcC8ubWFpbG1hcCAmJgorCWVjaG8gIkV4dGVybmFsIEd1eSA8JEdJVF9BVVRIT1JfRU1BSUw+IiA+PiBpbnRlcm5hbF9tYWlsbWFwLy5tYWlsbWFwICYmCiAJZ2l0IGNvbmZpZyBtYWlsbWFwLmZpbGUgaW50ZXJuYWxfbWFpbG1hcC8ubWFpbG1hcCAmJgogCWdpdCBzaG9ydGxvZyBIRUFEID5hY3R1YWwgJiYKIAl0ZXN0X2NtcCBleHBlY3QgYWN0dWFsCkBAIC0xNzgsOCArMTc4LDggQEAKIAl0ZXN0X2NtcCBleHBlY3QgYWN0dWFsCiAnCiAKLWNhdCA+ZXhwZWN0IDw8XEVPRgotQSBVIFRob3IgKDEpOgorY2F0ID5leHBlY3QgPDwgRU9GCiskR0lUX0FVVEhPUl9OQU1FICgxKToKICAgICAgIGluaXRpYWwKIAogbmljazEgKDEpOgpAQCAtMTk1LDE4ICsxOTUsMTggQEAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3NldHVwIG1haWxtYXAgYmxvYiB0ZXN0cycgJwogCWdpdCBjaGVja291dCAtYiBtYXAgJiYKIAl0ZXN0X3doZW5fZmluaXNoZWQgImdpdCBjaGVja291dCBtYXN0ZXIiICYmCi0JY2F0ID5qdXN0LWJ1Z3MgPDwtXEVPRiAmJgorCWNhdCA+anVzdC1idWdzIDw8LSBFT0YgJiYKIAlCbG9iIEd1eSA8YnVnc0Bjb21wYW55Lnh4PgogCUVPRgotCWNhdCA+Ym90aCA8PC1cRU9GICYmCi0JQmxvYiBHdXkgPGF1dGhvckBleGFtcGxlLmNvbT4KKwljYXQgPmJvdGggPDwtIEVPRiAmJgorCUJsb2IgR3V5IDwkR0lUX0FVVEhPUl9FTUFJTD4KIAlCbG9iIEd1eSA8YnVnc0Bjb21wYW55Lnh4PgogCUVPRgotCXByaW50ZiAiVHJpY2t5IEd1eSA8YXV0aG9yQGV4YW1wbGUuY29tPiIgPm5vLW5ld2xpbmUgJiYKKwlwcmludGYgIlRyaWNreSBHdXkgPCRHSVRfQVVUSE9SX0VNQUlMPiIgPm5vLW5ld2xpbmUgJiYKIAlnaXQgYWRkIGp1c3QtYnVncyBib3RoIG5vLW5ld2xpbmUgJiYKIAlnaXQgY29tbWl0IC1tICJteSBtYWlsbWFwcyIgJiYKLQllY2hvICJSZXBvIEd1eSA8YXV0aG9yQGV4YW1wbGUuY29tPiIgPi5tYWlsbWFwICYmCi0JZWNobyAiSW50ZXJuYWwgR3V5IDxhdXRob3JAZXhhbXBsZS5jb20+IiA+aW50ZXJuYWwubWFwCisJZWNobyAiUmVwbyBHdXkgPCRHSVRfQVVUSE9SX0VNQUlMPiIgPi5tYWlsbWFwICYmCisJZWNobyAiSW50ZXJuYWwgR3V5IDwkR0lUX0FVVEhPUl9FTUFJTD4iID5pbnRlcm5hbC5tYXAKICcKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnbWFpbG1hcC5ibG9iIHNldCcgJwpAQCAtMjY2LDEyICsyNjYsMTIgQEAKIAlnaXQgaW5pdCBub24tYmFyZSAmJgogCSgKIAkJY2Qgbm9uLWJhcmUgJiYKLQkJdGVzdF9jb21taXQgb25lIC5tYWlsbWFwICJGYWtlIE5hbWUgPGF1dGhvckBleGFtcGxlLmNvbT4iICYmCisJCXRlc3RfY29tbWl0IG9uZSAubWFpbG1hcCAiRmFrZSBOYW1lIDwkR0lUX0FVVEhPUl9FTUFJTD4iICYmCiAJCWVjaG8gIiAgICAgMQlGYWtlIE5hbWUiID5leHBlY3QgJiYKIAkJZ2l0IHNob3J0bG9nIC1ucyBIRUFEID5hY3R1YWwgJiYKIAkJdGVzdF9jbXAgZXhwZWN0IGFjdHVhbCAmJgogCQlybSAubWFpbG1hcCAmJgotCQllY2hvICIgICAgIDEJQSBVIFRob3IiID5leHBlY3QgJiYKKwkJZWNobyAiICAgICAxCSRHSVRfQVVUSE9SX05BTUUiID5leHBlY3QgJiYKIAkJZ2l0IHNob3J0bG9nIC1ucyBIRUFEID5hY3R1YWwgJiYKIAkJdGVzdF9jbXAgZXhwZWN0IGFjdHVhbAogCSkKQEAgLTMwNSwyNiArMzA1LDI2IEBACiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3NpbmdsZS1jaGFyYWN0ZXIgbmFtZScgJwotCWVjaG8gIiAgICAgMQlBIDxhdXRob3JAZXhhbXBsZS5jb20+IiA+ZXhwZWN0ICYmCisJZWNobyAiICAgICAxCUEgPCRHSVRfQVVUSE9SX0VNQUlMPiIgPmV4cGVjdCAmJgogCWVjaG8gIiAgICAgMQluaWNrMSA8YnVnc0Bjb21wYW55Lnh4PiIgPj5leHBlY3QgJiYKLQllY2hvICJBIDxhdXRob3JAZXhhbXBsZS5jb20+IiA+Lm1haWxtYXAgJiYKKwllY2hvICJBIDwkR0lUX0FVVEhPUl9FTUFJTD4iID4ubWFpbG1hcCAmJgogCXRlc3Rfd2hlbl9maW5pc2hlZCAicm0gLm1haWxtYXAiICYmCiAJZ2l0IHNob3J0bG9nIC1lcyBIRUFEID5hY3R1YWwgJiYKIAl0ZXN0X2NtcCBleHBlY3QgYWN0dWFsCiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3ByZXNlcnZlIGNhbm9uaWNhbCBlbWFpbCBjYXNlJyAnCi0JZWNobyAiICAgICAxCUEgVSBUaG9yIDxBVVRIT1JAZXhhbXBsZS5jb20+IiA+ZXhwZWN0ICYmCisJZWNobyAiICAgICAxCSRHSVRfQVVUSE9SX05BTUUgPEFVVEhPUkBleGFtcGxlLmNvbT4iID5leHBlY3QgJiYKIAllY2hvICIgICAgIDEJbmljazEgPGJ1Z3NAY29tcGFueS54eD4iID4+ZXhwZWN0ICYmCi0JZWNobyAiPEFVVEhPUkBleGFtcGxlLmNvbT4gPGF1dGhvckBleGFtcGxlLmNvbT4iID4ubWFpbG1hcCAmJgorCWVjaG8gIjxBVVRIT1JAZXhhbXBsZS5jb20+IDwkR0lUX0FVVEhPUl9FTUFJTD4iID4ubWFpbG1hcCAmJgogCXRlc3Rfd2hlbl9maW5pc2hlZCAicm0gLm1haWxtYXAiICYmCiAJZ2l0IHNob3J0bG9nIC1lcyBIRUFEID5hY3R1YWwgJiYKIAl0ZXN0X2NtcCBleHBlY3QgYWN0dWFsCiAnCiAKICMgRXh0ZW5kZWQgbWFpbG1hcCBjb25maWd1cmF0aW9ucyBzaG91bGQgZ2l2ZSB1cyB0aGUgZm9sbG93aW5nIG91dHB1dCBmb3Igc2hvcnRsb2cKLWNhdCA+ZXhwZWN0IDw8XEVPRgotQSBVIFRob3IgPGF1dGhvckBleGFtcGxlLmNvbT4gKDEpOgorY2F0ID5leHBlY3QgPDwgRU9GCiskR0lUX0FVVEhPUl9OQU1FIDwkR0lUX0FVVEhPUl9FTUFJTD4gKDEpOgogICAgICAgaW5pdGlhbAogCiBDVE8gPGN0b0Bjb21wYW55Lnh4PiAoMSk6CkBAIC0zNzAsNyArMzcwLDcgQEAKIAlnaXQgY29tbWl0IC0tYXV0aG9yICJDVE8gPGN0b0Bjb29tcGFueS54eD4iIC1tIHNldmVudGggJiYKIAogCW1rZGlyIC1wIGludGVybmFsX21haWxtYXAgJiYKLQllY2hvICJDb21taXR0ZWQgPGNvbW1pdHRlckBleGFtcGxlLmNvbT4iID4gaW50ZXJuYWxfbWFpbG1hcC8ubWFpbG1hcCAmJgorCWVjaG8gIkNvbW1pdHRlZCA8JEdJVF9DT01NSVRURVJfRU1BSUw+IiA+IGludGVybmFsX21haWxtYXAvLm1haWxtYXAgJiYKIAllY2hvICI8Y3RvQGNvbXBhbnkueHg+ICAgICAgICAgICAgICAgICAgICAgICA8Y3RvQGNvb21wYW55Lnh4PiIgPj4gaW50ZXJuYWxfbWFpbG1hcC8ubWFpbG1hcCAmJgogCWVjaG8gIlNvbWUgRHVkZSA8c29tZUBkdWRlLnh4PiAgICAgICAgIG5pY2sxIDxidWdzQGNvbXBhbnkueHg+IiA+PiBpbnRlcm5hbF9tYWlsbWFwLy5tYWlsbWFwICYmCiAJZWNobyAiT3RoZXIgQXV0aG9yIDxvdGhlckBhdXRob3IueHg+ICAgbmljazIgPGJ1Z3NAY29tcGFueS54eD4iID4+IGludGVybmFsX21haWxtYXAvLm1haWxtYXAgJiYKQEAgLTM4NCwyNyArMzg0LDI3IEBACiAnCiAKICMgZ2l0IGxvZyB3aXRoIC0tcHJldHR5IGZvcm1hdCB3aGljaCB1c2VzIHRoZSBuYW1lIGFuZCBlbWFpbCBtYWlsbWFwIHBsYWNlbWFya2VycwotY2F0ID5leHBlY3QgPDxcRU9GCitjYXQgPmV4cGVjdCA8PCBFT0YKIEF1dGhvciBDVE8gPGN0b0Bjb29tcGFueS54eD4gbWFwcyB0byBDVE8gPGN0b0Bjb21wYW55Lnh4PgotQ29tbWl0dGVyIEMgTyBNaXR0ZXIgPGNvbW1pdHRlckBleGFtcGxlLmNvbT4gbWFwcyB0byBDb21taXR0ZWQgPGNvbW1pdHRlckBleGFtcGxlLmNvbT4KK0NvbW1pdHRlciAkR0lUX0NPTU1JVFRFUl9OQU1FIDwkR0lUX0NPTU1JVFRFUl9FTUFJTD4gbWFwcyB0byBDb21taXR0ZWQgPCRHSVRfQ09NTUlUVEVSX0VNQUlMPgogCiBBdXRob3IgY2xhdXMgPG1lQGNvbXBhbnkueHg+IG1hcHMgdG8gU2FudGEgQ2xhdXMgPHNhbnRhLmNsYXVzQG5vcnRocG9sZS54eD4KLUNvbW1pdHRlciBDIE8gTWl0dGVyIDxjb21taXR0ZXJAZXhhbXBsZS5jb20+IG1hcHMgdG8gQ29tbWl0dGVkIDxjb21taXR0ZXJAZXhhbXBsZS5jb20+CitDb21taXR0ZXIgJEdJVF9DT01NSVRURVJfTkFNRSA8JEdJVF9DT01NSVRURVJfRU1BSUw+IG1hcHMgdG8gQ29tbWl0dGVkIDwkR0lUX0NPTU1JVFRFUl9FTUFJTD4KIAogQXV0aG9yIHNhbnRhIDxtZUBjb21wYW55Lnh4PiBtYXBzIHRvIFNhbnRhIENsYXVzIDxzYW50YS5jbGF1c0Bub3J0aHBvbGUueHg+Ci1Db21taXR0ZXIgQyBPIE1pdHRlciA8Y29tbWl0dGVyQGV4YW1wbGUuY29tPiBtYXBzIHRvIENvbW1pdHRlZCA8Y29tbWl0dGVyQGV4YW1wbGUuY29tPgorQ29tbWl0dGVyICRHSVRfQ09NTUlUVEVSX05BTUUgPCRHSVRfQ09NTUlUVEVSX0VNQUlMPiBtYXBzIHRvIENvbW1pdHRlZCA8JEdJVF9DT01NSVRURVJfRU1BSUw+CiAKIEF1dGhvciBuaWNrMiA8bmljazJAY29tcGFueS54eD4gbWFwcyB0byBPdGhlciBBdXRob3IgPG90aGVyQGF1dGhvci54eD4KLUNvbW1pdHRlciBDIE8gTWl0dGVyIDxjb21taXR0ZXJAZXhhbXBsZS5jb20+IG1hcHMgdG8gQ29tbWl0dGVkIDxjb21taXR0ZXJAZXhhbXBsZS5jb20+CitDb21taXR0ZXIgJEdJVF9DT01NSVRURVJfTkFNRSA8JEdJVF9DT01NSVRURVJfRU1BSUw+IG1hcHMgdG8gQ29tbWl0dGVkIDwkR0lUX0NPTU1JVFRFUl9FTUFJTD4KIAogQXV0aG9yIG5pY2syIDxidWdzQGNvbXBhbnkueHg+IG1hcHMgdG8gT3RoZXIgQXV0aG9yIDxvdGhlckBhdXRob3IueHg+Ci1Db21taXR0ZXIgQyBPIE1pdHRlciA8Y29tbWl0dGVyQGV4YW1wbGUuY29tPiBtYXBzIHRvIENvbW1pdHRlZCA8Y29tbWl0dGVyQGV4YW1wbGUuY29tPgorQ29tbWl0dGVyICRHSVRfQ09NTUlUVEVSX05BTUUgPCRHSVRfQ09NTUlUVEVSX0VNQUlMPiBtYXBzIHRvIENvbW1pdHRlZCA8JEdJVF9DT01NSVRURVJfRU1BSUw+CiAKIEF1dGhvciBuaWNrMSA8YnVnc0Bjb21wYW55Lnh4PiBtYXBzIHRvIFNvbWUgRHVkZSA8c29tZUBkdWRlLnh4PgotQ29tbWl0dGVyIEMgTyBNaXR0ZXIgPGNvbW1pdHRlckBleGFtcGxlLmNvbT4gbWFwcyB0byBDb21taXR0ZWQgPGNvbW1pdHRlckBleGFtcGxlLmNvbT4KK0NvbW1pdHRlciAkR0lUX0NPTU1JVFRFUl9OQU1FIDwkR0lUX0NPTU1JVFRFUl9FTUFJTD4gbWFwcyB0byBDb21taXR0ZWQgPCRHSVRfQ09NTUlUVEVSX0VNQUlMPgogCi1BdXRob3IgQSBVIFRob3IgPGF1dGhvckBleGFtcGxlLmNvbT4gbWFwcyB0byBBIFUgVGhvciA8YXV0aG9yQGV4YW1wbGUuY29tPgotQ29tbWl0dGVyIEMgTyBNaXR0ZXIgPGNvbW1pdHRlckBleGFtcGxlLmNvbT4gbWFwcyB0byBDb21taXR0ZWQgPGNvbW1pdHRlckBleGFtcGxlLmNvbT4KK0F1dGhvciAkR0lUX0FVVEhPUl9OQU1FIDwkR0lUX0FVVEhPUl9FTUFJTD4gbWFwcyB0byAkR0lUX0FVVEhPUl9OQU1FIDwkR0lUX0FVVEhPUl9FTUFJTD4KK0NvbW1pdHRlciAkR0lUX0NPTU1JVFRFUl9OQU1FIDwkR0lUX0NPTU1JVFRFUl9FTUFJTD4gbWFwcyB0byBDb21taXR0ZWQgPCRHSVRfQ09NTUlUVEVSX0VNQUlMPgogRU9GCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ0xvZyBvdXRwdXQgKGNvbXBsZXggbWFwcGluZyknICcKQEAgLTQxMiwxNCArNDEyLDQyIEBACiAJdGVzdF9jbXAgZXhwZWN0IGFjdHVhbAogJwogCi1jYXQgPmV4cGVjdCA8PFxFT0YKK2NhdCA+ZXhwZWN0IDw8IEVPRgorQXV0aG9yIGVtYWlsIGN0b0Bjb29tcGFueS54eCBoYXMgbG9jYWwtcGFydCBjdG8KK0NvbW1pdHRlciBlbWFpbCAkR0lUX0NPTU1JVFRFUl9FTUFJTCBoYXMgbG9jYWwtcGFydCAkVEVTVF9DT01NSVRURVJfTE9DQUxOQU1FCisKK0F1dGhvciBlbWFpbCBtZUBjb21wYW55Lnh4IGhhcyBsb2NhbC1wYXJ0IG1lCitDb21taXR0ZXIgZW1haWwgJEdJVF9DT01NSVRURVJfRU1BSUwgaGFzIGxvY2FsLXBhcnQgJFRFU1RfQ09NTUlUVEVSX0xPQ0FMTkFNRQorCitBdXRob3IgZW1haWwgbWVAY29tcGFueS54eCBoYXMgbG9jYWwtcGFydCBtZQorQ29tbWl0dGVyIGVtYWlsICRHSVRfQ09NTUlUVEVSX0VNQUlMIGhhcyBsb2NhbC1wYXJ0ICRURVNUX0NPTU1JVFRFUl9MT0NBTE5BTUUKKworQXV0aG9yIGVtYWlsIG5pY2syQGNvbXBhbnkueHggaGFzIGxvY2FsLXBhcnQgbmljazIKK0NvbW1pdHRlciBlbWFpbCAkR0lUX0NPTU1JVFRFUl9FTUFJTCBoYXMgbG9jYWwtcGFydCAkVEVTVF9DT01NSVRURVJfTE9DQUxOQU1FCisKK0F1dGhvciBlbWFpbCBidWdzQGNvbXBhbnkueHggaGFzIGxvY2FsLXBhcnQgYnVncworQ29tbWl0dGVyIGVtYWlsICRHSVRfQ09NTUlUVEVSX0VNQUlMIGhhcyBsb2NhbC1wYXJ0ICRURVNUX0NPTU1JVFRFUl9MT0NBTE5BTUUKKworQXV0aG9yIGVtYWlsIGJ1Z3NAY29tcGFueS54eCBoYXMgbG9jYWwtcGFydCBidWdzCitDb21taXR0ZXIgZW1haWwgJEdJVF9DT01NSVRURVJfRU1BSUwgaGFzIGxvY2FsLXBhcnQgJFRFU1RfQ09NTUlUVEVSX0xPQ0FMTkFNRQorCitBdXRob3IgZW1haWwgYXV0aG9yQGV4YW1wbGUuY29tIGhhcyBsb2NhbC1wYXJ0IGF1dGhvcgorQ29tbWl0dGVyIGVtYWlsICRHSVRfQ09NTUlUVEVSX0VNQUlMIGhhcyBsb2NhbC1wYXJ0ICRURVNUX0NPTU1JVFRFUl9MT0NBTE5BTUUKK0VPRgorCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdMb2cgb3V0cHV0IChsb2NhbC1wYXJ0IGVtYWlsIGFkZHJlc3MpJyAnCisJZ2l0IGxvZyAtLXByZXR0eT1mb3JtYXQ6IkF1dGhvciBlbWFpbCAlYWUgaGFzIGxvY2FsLXBhcnQgJWFsJW5Db21taXR0ZXIgZW1haWwgJWNlIGhhcyBsb2NhbC1wYXJ0ICVjbCVuIiA+YWN0dWFsICYmCisJdGVzdF9jbXAgZXhwZWN0IGFjdHVhbAorJworCitjYXQgPmV4cGVjdCA8PCBFT0YKIEF1dGhvcjogQ1RPIDxjdG9AY29tcGFueS54eD4KIEF1dGhvcjogU2FudGEgQ2xhdXMgPHNhbnRhLmNsYXVzQG5vcnRocG9sZS54eD4KIEF1dGhvcjogU2FudGEgQ2xhdXMgPHNhbnRhLmNsYXVzQG5vcnRocG9sZS54eD4KIEF1dGhvcjogT3RoZXIgQXV0aG9yIDxvdGhlckBhdXRob3IueHg+CiBBdXRob3I6IE90aGVyIEF1dGhvciA8b3RoZXJAYXV0aG9yLnh4PgogQXV0aG9yOiBTb21lIER1ZGUgPHNvbWVAZHVkZS54eD4KLUF1dGhvcjogQSBVIFRob3IgPGF1dGhvckBleGFtcGxlLmNvbT4KK0F1dGhvcjogJEdJVF9BVVRIT1JfTkFNRSA8JEdJVF9BVVRIT1JfRU1BSUw+CiBFT0YKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnTG9nIG91dHB1dCB3aXRoIC0tdXNlLW1haWxtYXAnICcKQEAgLTQyNywxNCArNDU1LDE0IEBACiAJdGVzdF9jbXAgZXhwZWN0IGFjdHVhbAogJwogCi1jYXQgPmV4cGVjdCA8PFxFT0YKK2NhdCA+ZXhwZWN0IDw8IEVPRgogQXV0aG9yOiBDVE8gPGN0b0Bjb21wYW55Lnh4PgogQXV0aG9yOiBTYW50YSBDbGF1cyA8c2FudGEuY2xhdXNAbm9ydGhwb2xlLnh4PgogQXV0aG9yOiBTYW50YSBDbGF1cyA8c2FudGEuY2xhdXNAbm9ydGhwb2xlLnh4PgogQXV0aG9yOiBPdGhlciBBdXRob3IgPG90aGVyQGF1dGhvci54eD4KIEF1dGhvcjogT3RoZXIgQXV0aG9yIDxvdGhlckBhdXRob3IueHg+CiBBdXRob3I6IFNvbWUgRHVkZSA8c29tZUBkdWRlLnh4PgotQXV0aG9yOiBBIFUgVGhvciA8YXV0aG9yQGV4YW1wbGUuY29tPgorQXV0aG9yOiAkR0lUX0FVVEhPUl9OQU1FIDwkR0lUX0FVVEhPUl9FTUFJTD4KIEVPRgogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdMb2cgb3V0cHV0IHdpdGggbG9nLm1haWxtYXAnICcKQEAgLTQ0MywyOCArNDcxLDI4IEBACiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2xvZy5tYWlsbWFwPWZhbHNlIGRpc2FibGVzIG1haWxtYXAnICcKLQljYXQgPmV4cGVjdCA8PC1cRU9GICYmCisJY2F0ID5leHBlY3QgPDwtIEVPRiAmJgogCUF1dGhvcjogQ1RPIDxjdG9AY29vbXBhbnkueHg+CiAJQXV0aG9yOiBjbGF1cyA8bWVAY29tcGFueS54eD4KIAlBdXRob3I6IHNhbnRhIDxtZUBjb21wYW55Lnh4PgogCUF1dGhvcjogbmljazIgPG5pY2syQGNvbXBhbnkueHg+CiAJQXV0aG9yOiBuaWNrMiA8YnVnc0Bjb21wYW55Lnh4PgogCUF1dGhvcjogbmljazEgPGJ1Z3NAY29tcGFueS54eD4KLQlBdXRob3I6IEEgVSBUaG9yIDxhdXRob3JAZXhhbXBsZS5jb20+CisJQXV0aG9yOiAkR0lUX0FVVEhPUl9OQU1FIDwkR0lUX0FVVEhPUl9FTUFJTD4KIAlFT0YKIAlnaXQgLWMgbG9nLm1haWxtYXA9RmFsc2UgbG9nIHwgZ3JlcCBBdXRob3IgPiBhY3R1YWwgJiYKIAl0ZXN0X2NtcCBleHBlY3QgYWN0dWFsCiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJy0tbm8tdXNlLW1haWxtYXAgZGlzYWJsZXMgbWFpbG1hcCcgJwotCWNhdCA+ZXhwZWN0IDw8LVxFT0YgJiYKKwljYXQgPmV4cGVjdCA8PC0gRU9GICYmCiAJQXV0aG9yOiBDVE8gPGN0b0Bjb29tcGFueS54eD4KIAlBdXRob3I6IGNsYXVzIDxtZUBjb21wYW55Lnh4PgogCUF1dGhvcjogc2FudGEgPG1lQGNvbXBhbnkueHg+CiAJQXV0aG9yOiBuaWNrMiA8bmljazJAY29tcGFueS54eD4KIAlBdXRob3I6IG5pY2syIDxidWdzQGNvbXBhbnkueHg+CiAJQXV0aG9yOiBuaWNrMSA8YnVnc0Bjb21wYW55Lnh4PgotCUF1dGhvcjogQSBVIFRob3IgPGF1dGhvckBleGFtcGxlLmNvbT4KKwlBdXRob3I6ICRHSVRfQVVUSE9SX05BTUUgPCRHSVRfQVVUSE9SX0VNQUlMPgogCUVPRgogCWdpdCBsb2cgLS1uby11c2UtbWFpbG1hcCB8IGdyZXAgQXV0aG9yID4gYWN0dWFsICYmCiAJdGVzdF9jbXAgZXhwZWN0IGFjdHVhbApAQCAtNTAwLDggKzUyOCw4IEBACiAnCiAKICMgZ2l0IGJsYW1lCi1jYXQgPmV4cGVjdCA8PFxFT0YKLV5PQkpJIChBIFUgVGhvciAgICAgREFURSAxKSBvbmUKK2NhdCA+ZXhwZWN0IDw8RU9GCiteT0JKSSAoJEdJVF9BVVRIT1JfTkFNRSAgICAgREFURSAxKSBvbmUKIE9CSklEIChTb21lIER1ZGUgICAgREFURSAyKSB0d28KIE9CSklEIChPdGhlciBBdXRob3IgREFURSAzKSB0aHJlZQogT0JKSUQgKE90aGVyIEF1dGhvciBEQVRFIDQpIGZvdXIKZGlmZiAtLWdpdCBhL3QvdDQyMDUtbG9nLXByZXR0eS1mb3JtYXRzLnNoIGIvdC90NDIwNS1sb2ctcHJldHR5LWZvcm1hdHMuc2gKaW5kZXggZjQyYTY5Zi4uMmYyNTFiMiAxMDA3NTUKLS0tIGEvdC90NDIwNS1sb2ctcHJldHR5LWZvcm1hdHMuc2gKKysrIGIvdC90NDIwNS1sb2ctcHJldHR5LWZvcm1hdHMuc2gKQEAgLTY0MCw3ICs2NDAsNyBAQAogCXRlc3RfY21wIGV4cGVjdCBhY3R1YWwKICcKIAotdGVzdF9leHBlY3Rfc3VjY2VzcyAnJSh0cmFpbGVyczprZXk9bm9uZXhpc3RhbnQpIGJlY29tZXMgZW1wdHknICcKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJyUodHJhaWxlcnM6a2V5PW5vbmV4aXN0ZW50KSBiZWNvbWVzIGVtcHR5JyAnCiAJZ2l0IGxvZyAtLW5vLXdhbGsgLS1wcmV0dHk9InglKHRyYWlsZXJzOmtleT1OYWNrZWQtYnkpeCIgPmFjdHVhbCAmJgogCWVjaG8gInh4IiA+ZXhwZWN0ICYmCiAJdGVzdF9jbXAgZXhwZWN0IGFjdHVhbApkaWZmIC0tZ2l0IGEvdC90NDIxMC1sb2ctaTE4bi5zaCBiL3QvdDQyMTAtbG9nLWkxOG4uc2gKaW5kZXggN2M1MTk0My4uNmU2MWY1NyAxMDA3NTUKLS0tIGEvdC90NDIxMC1sb2ctaTE4bi5zaAorKysgYi90L3Q0MjEwLWxvZy1pMThuLnNoCkBAIC0xLDEyICsxLDE1IEBACiAjIS9iaW4vc2gKIAogdGVzdF9kZXNjcmlwdGlvbj0ndGVzdCBsb2cgd2l0aCBpMThuIGZlYXR1cmVzJwotLiAuL3Rlc3QtbGliLnNoCisuIC4vbGliLWdldHRleHQuc2gKIAogIyB0d28gZm9ybXMgb2Ygw6kKIHV0ZjhfZT0kKHByaW50ZiAnXDMwM1wyNTEnKQogbGF0aW4xX2U9JChwcmludGYgJ1wzNTEnKQogCisjIGludmFsaWQgVVRGLTgKK2ludmFsaWRfZT0kKHByaW50ZiAnXDMwM1w1MCknKSAjICIpIiBhdCBlbmQgdG8gY2xvc2Ugb3BlbmluZyAiKCIKKwogdGVzdF9leHBlY3Rfc3VjY2VzcyAnY3JlYXRlIGNvbW1pdHMgaW4gZGlmZmVyZW50IGVuY29kaW5ncycgJwogCXRlc3RfdGljayAmJgogCWNhdCA+bXNnIDw8LUVPRiAmJgpAQCAtNDgsOSArNTEsNDMgQEAKIAl0ZXN0X211c3RfYmVfZW1wdHkgYWN0dWFsCiAnCiAKLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2xvZyAtLWdyZXAgZG9lcyBub3QgZmluZCBub24tcmVlbmNvZGVkIHZhbHVlcyAobGF0aW4xKScgJwordGVzdF9leHBlY3Rfc3VjY2VzcyAhTUlOR1cgJ2xvZyAtLWdyZXAgZG9lcyBub3QgZmluZCBub24tcmVlbmNvZGVkIHZhbHVlcyAobGF0aW4xKScgJwogCWdpdCBsb2cgLS1lbmNvZGluZz1JU08tODg1OS0xIC0tZm9ybWF0PSVzIC0tZ3JlcD0kdXRmOF9lID5hY3R1YWwgJiYKIAl0ZXN0X211c3RfYmVfZW1wdHkgYWN0dWFsCiAnCiAKK2ZvciBlbmdpbmUgaW4gZml4ZWQgYmFzaWMgZXh0ZW5kZWQgcGVybAorZG8KKwlwcmVyZXE9CisJaWYgdGVzdCAkZW5naW5lID0gInBlcmwiCisJdGhlbgorCQlwcmVyZXE9IlBDUkUiCisJZWxzZQorCQlwcmVyZXE9IiIKKwlmaQorCWZvcmNlX3JlZ2V4PQorCWlmIHRlc3QgJGVuZ2luZSAhPSAiZml4ZWQiCisJdGhlbgorCSAgICBmb3JjZV9yZWdleD0uKgorCWZpCisJdGVzdF9leHBlY3Rfc3VjY2VzcyAhTUlOR1csR0VUVEVYVF9MT0NBTEUsJHByZXJlcSAiLWMgZ3JlcC5wYXR0ZXJuVHlwZT0kZW5naW5lIGxvZyAtLWdyZXAgZG9lcyBub3QgZmluZCBub24tcmVlbmNvZGVkIHZhbHVlcyAobGF0aW4xICsgbG9jYWxlKSIgIgorCQljYXQgPmV4cGVjdCA8PC1cRU9GICYmCisJCWxhdGluMQorCQl1dGY4CisJCUVPRgorCQlMQ19BTEw9XCIkaXNfSVNfbG9jYWxlXCIgZ2l0IC1jIGdyZXAucGF0dGVyblR5cGU9JGVuZ2luZSBsb2cgLS1lbmNvZGluZz1JU08tODg1OS0xIC0tZm9ybWF0PSVzIC0tZ3JlcD1cIiRmb3JjZV9yZWdleCRsYXRpbjFfZVwiID5hY3R1YWwgJiYKKwkJdGVzdF9jbXAgZXhwZWN0IGFjdHVhbAorCSIKKworCXRlc3RfZXhwZWN0X3N1Y2Nlc3MgIU1JTkdXLEdFVFRFWFRfTE9DQUxFLCRwcmVyZXEgIi1jIGdyZXAucGF0dGVyblR5cGU9JGVuZ2luZSBsb2cgLS1ncmVwIGRvZXMgbm90IGZpbmQgbm9uLXJlZW5jb2RlZCB2YWx1ZXMgKGxhdGluMSArIGxvY2FsZSkiICIKKwkJTENfQUxMPVwiJGlzX0lTX2xvY2FsZVwiIGdpdCAtYyBncmVwLnBhdHRlcm5UeXBlPSRlbmdpbmUgbG9nIC0tZW5jb2Rpbmc9SVNPLTg4NTktMSAtLWZvcm1hdD0lcyAtLWdyZXA9XCIkZm9yY2VfcmVnZXgkdXRmOF9lXCIgPmFjdHVhbCAmJgorCQl0ZXN0X211c3RfYmVfZW1wdHkgYWN0dWFsCisJIgorCisJdGVzdF9leHBlY3Rfc3VjY2VzcyAhTUlOR1csR0VUVEVYVF9MT0NBTEUsJHByZXJlcSAiLWMgZ3JlcC5wYXR0ZXJuVHlwZT0kZW5naW5lIGxvZyAtLWdyZXAgZG9lcyBub3QgZGllIG9uIGludmFsaWQgVVRGLTggdmFsdWUgKGxhdGluMSArIGxvY2FsZSArIGludmFsaWQgbmVlZGxlKSIgIgorCQlMQ19BTEw9XCIkaXNfSVNfbG9jYWxlXCIgZ2l0IC1jIGdyZXAucGF0dGVyblR5cGU9JGVuZ2luZSBsb2cgLS1lbmNvZGluZz1JU08tODg1OS0xIC0tZm9ybWF0PSVzIC0tZ3JlcD1cIiRmb3JjZV9yZWdleCRpbnZhbGlkX2VcIiA+YWN0dWFsICYmCisJCXRlc3RfbXVzdF9iZV9lbXB0eSBhY3R1YWwKKwkiCitkb25lCisKIHRlc3RfZG9uZQpkaWZmIC0tZ2l0IGEvdC90NDIxMS1saW5lLWxvZy5zaCBiL3QvdDQyMTEtbGluZS1sb2cuc2gKaW5kZXggMWRiN2JkMC4uODMxOTE2MyAxMDA3NTUKLS0tIGEvdC90NDIxMS1saW5lLWxvZy5zaAorKysgYi90L3Q0MjExLWxpbmUtbG9nLnNoCkBAIC0xMzIsNCArMTMyLDg2IEBACiAJdGVzdF9tdXN0X2ZhaWwgZ2l0IGxvZyAtTDEsMjQ6Yi5jIC0tcmF3CiAnCiAKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3NldHVwIGZvciBjaGVja2luZyBmYW5jeSByZW5hbWUgZm9sbG93aW5nJyAnCisJZ2l0IGNoZWNrb3V0IC0tb3JwaGFuIG1vdmVzLXN0YXJ0ICYmCisJZ2l0IHJlc2V0IC0taGFyZCAmJgorCisJcHJpbnRmICIlc1xuIiAgICAxMiAxMyAxNCAxNSAgICAgIGIgYyBkIGUgICA+ZmlsZS0xICYmCisJcHJpbnRmICIlc1xuIiAgICAyMiAyMyAyNCAyNSAgICAgIEIgQyBEIEUgICA+ZmlsZS0yICYmCisJZ2l0IGFkZCBmaWxlLTEgZmlsZS0yICYmCisJdGVzdF90aWNrICYmCisJZ2l0IGNvbW1pdCAtbSAiQWRkIGZpbGUtMSBhbmQgZmlsZS0yIiAmJgorCW9pZF9hZGRfZjFfZjI9JChnaXQgcmV2LXBhcnNlIC0tc2hvcnQgSEVBRCkgJiYKKworCWdpdCBjaGVja291dCAtYiBtb3Zlcy1tYWluICYmCisJcHJpbnRmICIlc1xuIiAxMSAxMiAxMyAxNCAxNSAgICAgIGIgYyBkIGUgICA+ZmlsZS0xICYmCisJZ2l0IGNvbW1pdCAtYSAtbSAiTW9kaWZ5IGZpbGUtMSBvbiBtYWluIiAmJgorCW9pZF9tb2RfZjFfbWFpbj0kKGdpdCByZXYtcGFyc2UgLS1zaG9ydCBIRUFEKSAmJgorCisJcHJpbnRmICIlc1xuIiAyMSAyMiAyMyAyNCAyNSAgICAgIEIgQyBEIEUgICA+ZmlsZS0yICYmCisJZ2l0IGNvbW1pdCAtYSAtbSAiTW9kaWZ5IGZpbGUtMiBvbiBtYWluICMxIiAmJgorCW9pZF9tb2RfZjJfbWFpbl8xPSQoZ2l0IHJldi1wYXJzZSAtLXNob3J0IEhFQUQpICYmCisKKwlnaXQgbXYgZmlsZS0xIHJlbmFtZWQtMSAmJgorCWdpdCBjb21taXQgLW0gIlJlbmFtZSBmaWxlLTEgdG8gcmVuYW1lZC0xIG9uIG1haW4iICYmCisKKwlwcmludGYgIiVzXG4iIDExIDEyIDEzIDE0IDE1ICAgICAgYiBjIGQgZSBmID5yZW5hbWVkLTEgJiYKKwlnaXQgY29tbWl0IC1hIC1tICJNb2RpZnkgcmVuYW1lZC0xIG9uIG1haW4iICYmCisJb2lkX21vZF9yMV9tYWluPSQoZ2l0IHJldi1wYXJzZSAtLXNob3J0IEhFQUQpICYmCisKKwlwcmludGYgIiVzXG4iIDIxIDIyIDIzIDI0IDI1ICAgICAgQiBDIEQgRSBGID5maWxlLTIgJiYKKwlnaXQgY29tbWl0IC1hIC1tICJNb2RpZnkgZmlsZS0yIG9uIG1haW4gIzIiICYmCisJb2lkX21vZF9mMl9tYWluXzI9JChnaXQgcmV2LXBhcnNlIC0tc2hvcnQgSEVBRCkgJiYKKworCWdpdCBjaGVja291dCAtYiBtb3Zlcy1zaWRlIG1vdmVzLXN0YXJ0ICYmCisJcHJpbnRmICIlc1xuIiAgICAxMiAxMyAxNCAxNSAxNiAgIGIgYyBkIGUgICA+ZmlsZS0xICYmCisJZ2l0IGNvbW1pdCAtYSAtbSAiTW9kaWZ5IGZpbGUtMSBvbiBzaWRlICMxIiAmJgorCW9pZF9tb2RfZjFfc2lkZV8xPSQoZ2l0IHJldi1wYXJzZSAtLXNob3J0IEhFQUQpICYmCisKKwlwcmludGYgIiVzXG4iICAgIDIyIDIzIDI0IDI1IDI2ICAgQiBDIEQgRSAgID5maWxlLTIgJiYKKwlnaXQgY29tbWl0IC1hIC1tICJNb2RpZnkgZmlsZS0yIG9uIHNpZGUiICYmCisJb2lkX21vZF9mMl9zaWRlPSQoZ2l0IHJldi1wYXJzZSAtLXNob3J0IEhFQUQpICYmCisKKwlnaXQgbXYgZmlsZS0yIHJlbmFtZWQtMiAmJgorCWdpdCBjb21taXQgLW0gIlJlbmFtZSBmaWxlLTIgdG8gcmVuYW1lZC0yIG9uIHNpZGUiICYmCisKKwlwcmludGYgIiVzXG4iICAgIDEyIDEzIDE0IDE1IDE2IGEgYiBjIGQgZSAgID5maWxlLTEgJiYKKwlnaXQgY29tbWl0IC1hIC1tICJNb2RpZnkgZmlsZS0xIG9uIHNpZGUgIzIiICYmCisJb2lkX21vZF9mMV9zaWRlXzI9JChnaXQgcmV2LXBhcnNlIC0tc2hvcnQgSEVBRCkgJiYKKworCXByaW50ZiAiJXNcbiIgICAgMjIgMjMgMjQgMjUgMjYgQSBCIEMgRCBFICAgPnJlbmFtZWQtMiAmJgorCWdpdCBjb21taXQgLWEgLW0gIk1vZGlmeSByZW5hbWVkLTIgb24gc2lkZSIgJiYKKwlvaWRfbW9kX3IyX3NpZGU9JChnaXQgcmV2LXBhcnNlIC0tc2hvcnQgSEVBRCkgJiYKKworCWdpdCBjaGVja291dCBtb3Zlcy1tYWluICYmCisJZ2l0IG1lcmdlIG1vdmVzLXNpZGUgJiYKKwlvaWRfbWVyZ2U9JChnaXQgcmV2LXBhcnNlIC0tc2hvcnQgSEVBRCkKKycKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAnZmFuY3kgcmVuYW1lIGZvbGxvd2luZyAjMScgJworCWNhdCA+ZXhwZWN0IDw8LUVPRiAmJgorCSRvaWRfbWVyZ2UgTWVyZ2UgYnJhbmNoICdcJydtb3Zlcy1zaWRlJ1wnJyBpbnRvIG1vdmVzLW1haW4KKwkkb2lkX21vZF9mMV9zaWRlXzIgTW9kaWZ5IGZpbGUtMSBvbiBzaWRlICMyCisJJG9pZF9tb2RfZjFfc2lkZV8xIE1vZGlmeSBmaWxlLTEgb24gc2lkZSAjMQorCSRvaWRfbW9kX3IxX21haW4gTW9kaWZ5IHJlbmFtZWQtMSBvbiBtYWluCisJJG9pZF9tb2RfZjFfbWFpbiBNb2RpZnkgZmlsZS0xIG9uIG1haW4KKwkkb2lkX2FkZF9mMV9mMiBBZGQgZmlsZS0xIGFuZCBmaWxlLTIKKwlFT0YKKwlnaXQgbG9nIC1MMTpyZW5hbWVkLTEgLS1vbmVsaW5lIC0tbm8tcGF0Y2ggPmFjdHVhbCAmJgorCXRlc3RfY21wIGV4cGVjdCBhY3R1YWwKKycKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAnZmFuY3kgcmVuYW1lIGZvbGxvd2luZyAjMicgJworCWNhdCA+ZXhwZWN0IDw8LUVPRiAmJgorCSRvaWRfbWVyZ2UgTWVyZ2UgYnJhbmNoICdcJydtb3Zlcy1zaWRlJ1wnJyBpbnRvIG1vdmVzLW1haW4KKwkkb2lkX21vZF9yMl9zaWRlIE1vZGlmeSByZW5hbWVkLTIgb24gc2lkZQorCSRvaWRfbW9kX2YyX3NpZGUgTW9kaWZ5IGZpbGUtMiBvbiBzaWRlCisJJG9pZF9tb2RfZjJfbWFpbl8yIE1vZGlmeSBmaWxlLTIgb24gbWFpbiAjMgorCSRvaWRfbW9kX2YyX21haW5fMSBNb2RpZnkgZmlsZS0yIG9uIG1haW4gIzEKKwkkb2lkX2FkZF9mMV9mMiBBZGQgZmlsZS0xIGFuZCBmaWxlLTIKKwlFT0YKKwlnaXQgbG9nIC1MMTpyZW5hbWVkLTIgLS1vbmVsaW5lIC0tbm8tcGF0Y2ggPmFjdHVhbCAmJgorCXRlc3RfY21wIGV4cGVjdCBhY3R1YWwKKycKKwogdGVzdF9kb25lCmRpZmYgLS1naXQgYS90L3Q0MjEzLWxvZy10YWJleHBhbmQuc2ggYi90L3Q0MjEzLWxvZy10YWJleHBhbmQuc2gKaW5kZXggN2Y5MGY1OC4uNTNhNGFmMyAxMDA3NTUKLS0tIGEvdC90NDIxMy1sb2ctdGFiZXhwYW5kLnNoCisrKyBiL3QvdDQyMTMtbG9nLXRhYmV4cGFuZC5zaApAQCAtMzYsNyArMzYsNyBAQAogCWVzYWMKIAogCSMgUHJlZml4IHRoZSBvdXRwdXQgd2l0aCB0aGUgY29tbWFuZCBsaW5lIGFyZ3VtZW50cywgYW5kCi0JIyByZXBsYWNlIFNQIHdpdGggYSBkb3QgYm90aCBpbiB0aGUgZXhwZWN0ZSBhbmQgYWN0dWFsIG91dHB1dAorCSMgcmVwbGFjZSBTUCB3aXRoIGEgZG90IGJvdGggaW4gdGhlIGV4cGVjdGVkIGFuZCBhY3R1YWwgb3V0cHV0CiAJIyBzbyB0aGF0IHRlc3RfY21wIHdvdWxkIHNob3cgdGhlIGRpZmZlcmVuY2UgdG9nZXRoZXIgd2l0aCB0aGUKIAkjIGJyZWFrYWdlIGluIGEgd2F5IGVhc2llciB0byBjb25zdW1lIGJ5IHRoZSBkZWJ1Z2dpbmcgdXNlci4KIAl7CmRpZmYgLS1naXQgYS90L3Q0MjE0LWxvZy1ncmFwaC1vY3RvcHVzLnNoIGIvdC90NDIxNC1sb2ctZ3JhcGgtb2N0b3B1cy5zaAppbmRleCBkYWI5NmM4Li40MGQyN2RiIDEwMDc1NQotLS0gYS90L3Q0MjE0LWxvZy1ncmFwaC1vY3RvcHVzLnNoCisrKyBiL3QvdDQyMTQtbG9nLWdyYXBoLW9jdG9wdXMuc2gKQEAgLTUsMzQgKzUsNiBAQAogLiAuL3Rlc3QtbGliLnNoCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3NldCB1cCBtZXJnZSBoaXN0b3J5JyAnCi0JY2F0ID5leHBlY3QudW5jb2xvcmVkIDw8LVxFT0YgJiYKLQkqIGxlZnQKLQl8ICotLS0uICAgb2N0b3B1cy1tZXJnZQotCXwgfFwgXCBcCi0JfC8gLyAvIC8KLQl8IHwgfCAqIDQKLQl8IHwgKiB8IDMKLQl8IHwgfC8KLQl8ICogfCAyCi0JfCB8LwotCSogfCAxCi0JfC8KLQkqIGluaXRpYWwKLQlFT0YKLQljYXQgPmV4cGVjdC5jb2xvcnMgPDwtXEVPRiAmJgotCSogbGVmdAotCTxSRUQ+fDxSRVNFVD4gKjxCTFVFPi08UkVTRVQ+PEJMVUU+LTxSRVNFVD48TUFHRU5UQT4tPFJFU0VUPjxNQUdFTlRBPi48UkVTRVQ+ICAgb2N0b3B1cy1tZXJnZQotCTxSRUQ+fDxSRVNFVD4gPFJFRD58PFJFU0VUPjxZRUxMT1c+XDxSRVNFVD4gPEJMVUU+XDxSRVNFVD4gPE1BR0VOVEE+XDxSRVNFVD4KLQk8UkVEPnw8UkVTRVQ+PFJFRD4vPFJFU0VUPiA8WUVMTE9XPi88UkVTRVQ+IDxCTFVFPi88UkVTRVQ+IDxNQUdFTlRBPi88UkVTRVQ+Ci0JPFJFRD58PFJFU0VUPiA8WUVMTE9XPnw8UkVTRVQ+IDxCTFVFPnw8UkVTRVQ+ICogNAotCTxSRUQ+fDxSRVNFVD4gPFlFTExPVz58PFJFU0VUPiAqIDxNQUdFTlRBPnw8UkVTRVQ+IDMKLQk8UkVEPnw8UkVTRVQ+IDxZRUxMT1c+fDxSRVNFVD4gPE1BR0VOVEE+fDxSRVNFVD48TUFHRU5UQT4vPFJFU0VUPgotCTxSRUQ+fDxSRVNFVD4gKiA8TUFHRU5UQT58PFJFU0VUPiAyCi0JPFJFRD58PFJFU0VUPiA8TUFHRU5UQT58PFJFU0VUPjxNQUdFTlRBPi88UkVTRVQ+Ci0JKiA8TUFHRU5UQT58PFJFU0VUPiAxCi0JPE1BR0VOVEE+fDxSRVNFVD48TUFHRU5UQT4vPFJFU0VUPgotCSogaW5pdGlhbAotCUVPRgogCXRlc3RfY29tbWl0IGluaXRpYWwgJiYKIAlmb3IgaSBpbiAxIDIgMyA0IDsgZG8KIAkJZ2l0IGNoZWNrb3V0IG1hc3RlciAtYiAkaSB8fCByZXR1cm4gJD8KQEAgLTQxLDI1ICsxMyw1NSBAQAogCQl0ZXN0X2NvbW1pdCAkaSAkaSAkaSB0YWckaSB8fCByZXR1cm4gJD8KIAlkb25lICYmCiAJZ2l0IGNoZWNrb3V0IDEgLWIgbWVyZ2UgJiYKLQl0ZXN0X3RpY2sgJiYKLQlnaXQgbWVyZ2UgLW0gb2N0b3B1cy1tZXJnZSAxIDIgMyA0ICYmCisJdGVzdF9tZXJnZSBvY3RvcHVzLW1lcmdlIDEgMiAzIDQgJiYKKwl0ZXN0X2NvbW1pdCBhZnRlci1tZXJnZSAmJgogCWdpdCBjaGVja291dCAxIC1iIEwgJiYKLQl0ZXN0X2NvbW1pdCBsZWZ0CisJdGVzdF9jb21taXQgbGVmdCAmJgorCWdpdCBjaGVja291dCA0IC1iIGNyb3Nzb3ZlciAmJgorCXRlc3RfY29tbWl0IGFmdGVyLTQgJiYKKwlnaXQgY2hlY2tvdXQgaW5pdGlhbCAtYiBtb3JlLUwgJiYKKwl0ZXN0X2NvbW1pdCBhZnRlci1pbml0aWFsCisnCisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2xvZyAtLWdyYXBoIHdpdGggdHJpY2t5IG9jdG9wdXMgbWVyZ2UsIG5vIGNvbG9yJyAnCisJY2F0ID5leHBlY3QudW5jb2xvcmVkIDw8LVxFT0YgJiYKKwkqIGxlZnQKKwl8ICotLiAgIG9jdG9wdXMtbWVyZ2UKKwl8L3xcIFwKKwl8IHwgfCAqIDQKKwl8IHwgKiB8IDMKKwl8IHwgfC8KKwl8ICogLyAyCisJfCB8LworCSogLyAxCisJfC8KKwkqIGluaXRpYWwKKwlFT0YKKwlnaXQgbG9nIC0tY29sb3I9bmV2ZXIgLS1ncmFwaCAtLWRhdGUtb3JkZXIgLS1wcmV0dHk9dGZvcm1hdDolcyBsZWZ0IG9jdG9wdXMtbWVyZ2UgPmFjdHVhbC5yYXcgJiYKKwlzZWQgInMvICpcJC8vIiBhY3R1YWwucmF3ID5hY3R1YWwgJiYKKwl0ZXN0X2NtcCBleHBlY3QudW5jb2xvcmVkIGFjdHVhbAogJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdsb2cgLS1ncmFwaCB3aXRoIHRyaWNreSBvY3RvcHVzIG1lcmdlIHdpdGggY29sb3JzJyAnCiAJdGVzdF9jb25maWcgbG9nLmdyYXBoQ29sb3JzIHJlZCxncmVlbix5ZWxsb3csYmx1ZSxtYWdlbnRhLGN5YW4gJiYKLQlnaXQgbG9nIC0tY29sb3I9YWx3YXlzIC0tZ3JhcGggLS1kYXRlLW9yZGVyIC0tcHJldHR5PXRmb3JtYXQ6JXMgLS1hbGwgPmFjdHVhbC5jb2xvcnMucmF3ICYmCisJY2F0ID5leHBlY3QuY29sb3JzIDw8LVxFT0YgJiYKKwkqIGxlZnQKKwk8UkVEPnw8UkVTRVQ+ICo8TUFHRU5UQT4tPFJFU0VUPjxNQUdFTlRBPi48UkVTRVQ+ICAgb2N0b3B1cy1tZXJnZQorCTxSRUQ+fDxSRVNFVD48UkVEPi88UkVTRVQ+PFlFTExPVz58PFJFU0VUPjxCTFVFPlw8UkVTRVQ+IDxNQUdFTlRBPlw8UkVTRVQ+CisJPFJFRD58PFJFU0VUPiA8WUVMTE9XPnw8UkVTRVQ+IDxCTFVFPnw8UkVTRVQ+ICogNAorCTxSRUQ+fDxSRVNFVD4gPFlFTExPVz58PFJFU0VUPiAqIDxNQUdFTlRBPnw8UkVTRVQ+IDMKKwk8UkVEPnw8UkVTRVQ+IDxZRUxMT1c+fDxSRVNFVD4gPE1BR0VOVEE+fDxSRVNFVD48TUFHRU5UQT4vPFJFU0VUPgorCTxSRUQ+fDxSRVNFVD4gKiA8TUFHRU5UQT4vPFJFU0VUPiAyCisJPFJFRD58PFJFU0VUPiA8TUFHRU5UQT58PFJFU0VUPjxNQUdFTlRBPi88UkVTRVQ+CisJKiA8TUFHRU5UQT4vPFJFU0VUPiAxCisJPE1BR0VOVEE+fDxSRVNFVD48TUFHRU5UQT4vPFJFU0VUPgorCSogaW5pdGlhbAorCUVPRgorCWdpdCBsb2cgLS1jb2xvcj1hbHdheXMgLS1ncmFwaCAtLWRhdGUtb3JkZXIgLS1wcmV0dHk9dGZvcm1hdDolcyBsZWZ0IG9jdG9wdXMtbWVyZ2UgPmFjdHVhbC5jb2xvcnMucmF3ICYmCiAJdGVzdF9kZWNvZGVfY29sb3IgPGFjdHVhbC5jb2xvcnMucmF3IHwgc2VkICJzLyAqXCQvLyIgPmFjdHVhbC5jb2xvcnMgJiYKIAl0ZXN0X2NtcCBleHBlY3QuY29sb3JzIGFjdHVhbC5jb2xvcnMKICcKIAotdGVzdF9leHBlY3Rfc3VjY2VzcyAnbG9nIC0tZ3JhcGggd2l0aCB0cmlja3kgb2N0b3B1cyBtZXJnZSwgbm8gY29sb3InICcKLQlnaXQgbG9nIC0tY29sb3I9bmV2ZXIgLS1ncmFwaCAtLWRhdGUtb3JkZXIgLS1wcmV0dHk9dGZvcm1hdDolcyAtLWFsbCA+YWN0dWFsLnJhdyAmJgotCXNlZCAicy8gKlwkLy8iIGFjdHVhbC5yYXcgPmFjdHVhbCAmJgotCXRlc3RfY21wIGV4cGVjdC51bmNvbG9yZWQgYWN0dWFsCi0nCi0KICMgUmVwZWF0IHRoZSBwcmV2aW91cyB0d28gdGVzdHMgd2l0aCAibm9ybWFsIiBvY3RvcHVzIG1lcmdlIChpLmUuLAogIyB3aXRob3V0IHRoZSBmaXJzdCBwYXJlbnQgc2tld2luZyB0byB0aGUgImxlZnQiIGJyYW5jaCBjb2x1bW4pLgogCkBAIC03MCwxMyArNzIsMTMgQEAKIAl8IHwgfCAqIDQKIAl8IHwgKiB8IDMKIAl8IHwgfC8KLQl8ICogfCAyCisJfCAqIC8gMgogCXwgfC8KLQkqIHwgMQorCSogLyAxCiAJfC8KIAkqIGluaXRpYWwKIAlFT0YKLQlnaXQgbG9nIC0tY29sb3I9bmV2ZXIgLS1ncmFwaCAtLWRhdGUtb3JkZXIgLS1wcmV0dHk9dGZvcm1hdDolcyBtZXJnZSA+YWN0dWFsLnJhdyAmJgorCWdpdCBsb2cgLS1jb2xvcj1uZXZlciAtLWdyYXBoIC0tZGF0ZS1vcmRlciAtLXByZXR0eT10Zm9ybWF0OiVzIG9jdG9wdXMtbWVyZ2UgPmFjdHVhbC5yYXcgJiYKIAlzZWQgInMvICpcJC8vIiBhY3R1YWwucmF3ID5hY3R1YWwgJiYKIAl0ZXN0X2NtcCBleHBlY3QudW5jb2xvcmVkIGFjdHVhbAogJwpAQCAtODgsMTUgKzkwLDI4OCBAQAogCTxSRUQ+fDxSRVNFVD4gPEdSRUVOPnw8UkVTRVQ+IDxZRUxMT1c+fDxSRVNFVD4gKiA0CiAJPFJFRD58PFJFU0VUPiA8R1JFRU4+fDxSRVNFVD4gKiA8QkxVRT58PFJFU0VUPiAzCiAJPFJFRD58PFJFU0VUPiA8R1JFRU4+fDxSRVNFVD4gPEJMVUU+fDxSRVNFVD48QkxVRT4vPFJFU0VUPgotCTxSRUQ+fDxSRVNFVD4gKiA8QkxVRT58PFJFU0VUPiAyCisJPFJFRD58PFJFU0VUPiAqIDxCTFVFPi88UkVTRVQ+IDIKIAk8UkVEPnw8UkVTRVQ+IDxCTFVFPnw8UkVTRVQ+PEJMVUU+LzxSRVNFVD4KLQkqIDxCTFVFPnw8UkVTRVQ+IDEKKwkqIDxCTFVFPi88UkVTRVQ+IDEKIAk8QkxVRT58PFJFU0VUPjxCTFVFPi88UkVTRVQ+CiAJKiBpbml0aWFsCiAJRU9GCiAJdGVzdF9jb25maWcgbG9nLmdyYXBoQ29sb3JzIHJlZCxncmVlbix5ZWxsb3csYmx1ZSxtYWdlbnRhLGN5YW4gJiYKLQlnaXQgbG9nIC0tY29sb3I9YWx3YXlzIC0tZ3JhcGggLS1kYXRlLW9yZGVyIC0tcHJldHR5PXRmb3JtYXQ6JXMgbWVyZ2UgPmFjdHVhbC5jb2xvcnMucmF3ICYmCisJZ2l0IGxvZyAtLWNvbG9yPWFsd2F5cyAtLWdyYXBoIC0tZGF0ZS1vcmRlciAtLXByZXR0eT10Zm9ybWF0OiVzIG9jdG9wdXMtbWVyZ2UgPmFjdHVhbC5jb2xvcnMucmF3ICYmCiAJdGVzdF9kZWNvZGVfY29sb3IgPGFjdHVhbC5jb2xvcnMucmF3IHwgc2VkICJzLyAqXCQvLyIgPmFjdHVhbC5jb2xvcnMgJiYKIAl0ZXN0X2NtcCBleHBlY3QuY29sb3JzIGFjdHVhbC5jb2xvcnMKICcKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAnbG9nIC0tZ3JhcGggd2l0aCBub3JtYWwgb2N0b3B1cyBtZXJnZSBhbmQgY2hpbGQsIG5vIGNvbG9yJyAnCisJY2F0ID5leHBlY3QudW5jb2xvcmVkIDw8LVxFT0YgJiYKKwkqIGFmdGVyLW1lcmdlCisJKi0tLS4gICBvY3RvcHVzLW1lcmdlCisJfFwgXCBcCisJfCB8IHwgKiA0CisJfCB8ICogfCAzCisJfCB8IHwvCisJfCAqIC8gMgorCXwgfC8KKwkqIC8gMQorCXwvCisJKiBpbml0aWFsCisJRU9GCisJZ2l0IGxvZyAtLWNvbG9yPW5ldmVyIC0tZ3JhcGggLS1kYXRlLW9yZGVyIC0tcHJldHR5PXRmb3JtYXQ6JXMgYWZ0ZXItbWVyZ2UgPmFjdHVhbC5yYXcgJiYKKwlzZWQgInMvICpcJC8vIiBhY3R1YWwucmF3ID5hY3R1YWwgJiYKKwl0ZXN0X2NtcCBleHBlY3QudW5jb2xvcmVkIGFjdHVhbAorJworCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdsb2cgLS1ncmFwaCB3aXRoIG5vcm1hbCBvY3RvcHVzIGFuZCBjaGlsZCBtZXJnZSB3aXRoIGNvbG9ycycgJworCWNhdCA+ZXhwZWN0LmNvbG9ycyA8PC1cRU9GICYmCisJKiBhZnRlci1tZXJnZQorCSo8QkxVRT4tPFJFU0VUPjxCTFVFPi08UkVTRVQ+PE1BR0VOVEE+LTxSRVNFVD48TUFHRU5UQT4uPFJFU0VUPiAgIG9jdG9wdXMtbWVyZ2UKKwk8R1JFRU4+fDxSRVNFVD48WUVMTE9XPlw8UkVTRVQ+IDxCTFVFPlw8UkVTRVQ+IDxNQUdFTlRBPlw8UkVTRVQ+CisJPEdSRUVOPnw8UkVTRVQ+IDxZRUxMT1c+fDxSRVNFVD4gPEJMVUU+fDxSRVNFVD4gKiA0CisJPEdSRUVOPnw8UkVTRVQ+IDxZRUxMT1c+fDxSRVNFVD4gKiA8TUFHRU5UQT58PFJFU0VUPiAzCisJPEdSRUVOPnw8UkVTRVQ+IDxZRUxMT1c+fDxSRVNFVD4gPE1BR0VOVEE+fDxSRVNFVD48TUFHRU5UQT4vPFJFU0VUPgorCTxHUkVFTj58PFJFU0VUPiAqIDxNQUdFTlRBPi88UkVTRVQ+IDIKKwk8R1JFRU4+fDxSRVNFVD4gPE1BR0VOVEE+fDxSRVNFVD48TUFHRU5UQT4vPFJFU0VUPgorCSogPE1BR0VOVEE+LzxSRVNFVD4gMQorCTxNQUdFTlRBPnw8UkVTRVQ+PE1BR0VOVEE+LzxSRVNFVD4KKwkqIGluaXRpYWwKKwlFT0YKKwl0ZXN0X2NvbmZpZyBsb2cuZ3JhcGhDb2xvcnMgcmVkLGdyZWVuLHllbGxvdyxibHVlLG1hZ2VudGEsY3lhbiAmJgorCWdpdCBsb2cgLS1jb2xvcj1hbHdheXMgLS1ncmFwaCAtLWRhdGUtb3JkZXIgLS1wcmV0dHk9dGZvcm1hdDolcyBhZnRlci1tZXJnZSA+YWN0dWFsLmNvbG9ycy5yYXcgJiYKKwl0ZXN0X2RlY29kZV9jb2xvciA8YWN0dWFsLmNvbG9ycy5yYXcgfCBzZWQgInMvICpcJC8vIiA+YWN0dWFsLmNvbG9ycyAmJgorCXRlc3RfY21wIGV4cGVjdC5jb2xvcnMgYWN0dWFsLmNvbG9ycworJworCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdsb2cgLS1ncmFwaCB3aXRoIHRyaWNreSBvY3RvcHVzIG1lcmdlIGFuZCBpdHMgY2hpbGQsIG5vIGNvbG9yJyAnCisJY2F0ID5leHBlY3QudW5jb2xvcmVkIDw8LVxFT0YgJiYKKwkqIGxlZnQKKwl8ICogYWZ0ZXItbWVyZ2UKKwl8ICotLiAgIG9jdG9wdXMtbWVyZ2UKKwl8L3xcIFwKKwl8IHwgfCAqIDQKKwl8IHwgKiB8IDMKKwl8IHwgfC8KKwl8ICogLyAyCisJfCB8LworCSogLyAxCisJfC8KKwkqIGluaXRpYWwKKwlFT0YKKwlnaXQgbG9nIC0tY29sb3I9bmV2ZXIgLS1ncmFwaCAtLWRhdGUtb3JkZXIgLS1wcmV0dHk9dGZvcm1hdDolcyBsZWZ0IGFmdGVyLW1lcmdlID5hY3R1YWwucmF3ICYmCisJc2VkICJzLyAqXCQvLyIgYWN0dWFsLnJhdyA+YWN0dWFsICYmCisJdGVzdF9jbXAgZXhwZWN0LnVuY29sb3JlZCBhY3R1YWwKKycKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAnbG9nIC0tZ3JhcGggd2l0aCB0cmlja3kgb2N0b3B1cyBtZXJnZSBhbmQgaXRzIGNoaWxkIHdpdGggY29sb3JzJyAnCisJdGVzdF9jb25maWcgbG9nLmdyYXBoQ29sb3JzIHJlZCxncmVlbix5ZWxsb3csYmx1ZSxtYWdlbnRhLGN5YW4gJiYKKwljYXQgPmV4cGVjdC5jb2xvcnMgPDwtXEVPRiAmJgorCSogbGVmdAorCTxSRUQ+fDxSRVNFVD4gKiBhZnRlci1tZXJnZQorCTxSRUQ+fDxSRVNFVD4gKjxDWUFOPi08UkVTRVQ+PENZQU4+LjxSRVNFVD4gICBvY3RvcHVzLW1lcmdlCisJPFJFRD58PFJFU0VUPjxSRUQ+LzxSRVNFVD48QkxVRT58PFJFU0VUPjxNQUdFTlRBPlw8UkVTRVQ+IDxDWUFOPlw8UkVTRVQ+CisJPFJFRD58PFJFU0VUPiA8QkxVRT58PFJFU0VUPiA8TUFHRU5UQT58PFJFU0VUPiAqIDQKKwk8UkVEPnw8UkVTRVQ+IDxCTFVFPnw8UkVTRVQ+ICogPENZQU4+fDxSRVNFVD4gMworCTxSRUQ+fDxSRVNFVD4gPEJMVUU+fDxSRVNFVD4gPENZQU4+fDxSRVNFVD48Q1lBTj4vPFJFU0VUPgorCTxSRUQ+fDxSRVNFVD4gKiA8Q1lBTj4vPFJFU0VUPiAyCisJPFJFRD58PFJFU0VUPiA8Q1lBTj58PFJFU0VUPjxDWUFOPi88UkVTRVQ+CisJKiA8Q1lBTj4vPFJFU0VUPiAxCisJPENZQU4+fDxSRVNFVD48Q1lBTj4vPFJFU0VUPgorCSogaW5pdGlhbAorCUVPRgorCWdpdCBsb2cgLS1jb2xvcj1hbHdheXMgLS1ncmFwaCAtLWRhdGUtb3JkZXIgLS1wcmV0dHk9dGZvcm1hdDolcyBsZWZ0IGFmdGVyLW1lcmdlID5hY3R1YWwuY29sb3JzLnJhdyAmJgorCXRlc3RfZGVjb2RlX2NvbG9yIDxhY3R1YWwuY29sb3JzLnJhdyB8IHNlZCAicy8gKlwkLy8iID5hY3R1YWwuY29sb3JzICYmCisJdGVzdF9jbXAgZXhwZWN0LmNvbG9ycyBhY3R1YWwuY29sb3JzCisnCisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2xvZyAtLWdyYXBoIHdpdGggY3Jvc3NvdmVyIGluIG9jdG9wdXMgbWVyZ2UsIG5vIGNvbG9yJyAnCisJY2F0ID5leHBlY3QudW5jb2xvcmVkIDw8LVxFT0YgJiYKKwkqIGFmdGVyLTQKKwl8ICotLS0uICAgb2N0b3B1cy1tZXJnZQorCXwgfFwgXCBcCisJfCB8X3xffC8KKwl8L3wgfCB8CisJKiB8IHwgfCA0CisJfCB8IHwgKiAzCisJfCB8X3wvCisJfC98IHwKKwl8IHwgKiAyCisJfCB8LworCXwvfAorCXwgKiAxCisJfC8KKwkqIGluaXRpYWwKKwlFT0YKKwlnaXQgbG9nIC0tY29sb3I9bmV2ZXIgLS1ncmFwaCAtLWRhdGUtb3JkZXIgLS1wcmV0dHk9dGZvcm1hdDolcyBhZnRlci00IG9jdG9wdXMtbWVyZ2UgPmFjdHVhbC5yYXcgJiYKKwlzZWQgInMvICpcJC8vIiBhY3R1YWwucmF3ID5hY3R1YWwgJiYKKwl0ZXN0X2NtcCBleHBlY3QudW5jb2xvcmVkIGFjdHVhbAorJworCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdsb2cgLS1ncmFwaCB3aXRoIGNyb3Nzb3ZlciBpbiBvY3RvcHVzIG1lcmdlIHdpdGggY29sb3JzJyAnCisJdGVzdF9jb25maWcgbG9nLmdyYXBoQ29sb3JzIHJlZCxncmVlbix5ZWxsb3csYmx1ZSxtYWdlbnRhLGN5YW4gJiYKKwljYXQgPmV4cGVjdC5jb2xvcnMgPDwtXEVPRiAmJgorCSogYWZ0ZXItNAorCTxSRUQ+fDxSRVNFVD4gKjxCTFVFPi08UkVTRVQ+PEJMVUU+LTxSRVNFVD48UkVEPi08UkVTRVQ+PFJFRD4uPFJFU0VUPiAgIG9jdG9wdXMtbWVyZ2UKKwk8UkVEPnw8UkVTRVQ+IDxHUkVFTj58PFJFU0VUPjxZRUxMT1c+XDxSRVNFVD4gPEJMVUU+XDxSRVNFVD4gPFJFRD5cPFJFU0VUPgorCTxSRUQ+fDxSRVNFVD4gPEdSRUVOPnw8UkVTRVQ+PFJFRD5fPFJFU0VUPjxZRUxMT1c+fDxSRVNFVD48UkVEPl88UkVTRVQ+PEJMVUU+fDxSRVNFVD48UkVEPi88UkVTRVQ+CisJPFJFRD58PFJFU0VUPjxSRUQ+LzxSRVNFVD48R1JFRU4+fDxSRVNFVD4gPFlFTExPVz58PFJFU0VUPiA8QkxVRT58PFJFU0VUPgorCSogPEdSRUVOPnw8UkVTRVQ+IDxZRUxMT1c+fDxSRVNFVD4gPEJMVUU+fDxSRVNFVD4gNAorCTxNQUdFTlRBPnw8UkVTRVQ+IDxHUkVFTj58PFJFU0VUPiA8WUVMTE9XPnw8UkVTRVQ+ICogMworCTxNQUdFTlRBPnw8UkVTRVQ+IDxHUkVFTj58PFJFU0VUPjxNQUdFTlRBPl88UkVTRVQ+PFlFTExPVz58PFJFU0VUPjxNQUdFTlRBPi88UkVTRVQ+CisJPE1BR0VOVEE+fDxSRVNFVD48TUFHRU5UQT4vPFJFU0VUPjxHUkVFTj58PFJFU0VUPiA8WUVMTE9XPnw8UkVTRVQ+CisJPE1BR0VOVEE+fDxSRVNFVD4gPEdSRUVOPnw8UkVTRVQ+ICogMgorCTxNQUdFTlRBPnw8UkVTRVQ+IDxHUkVFTj58PFJFU0VUPjxNQUdFTlRBPi88UkVTRVQ+CisJPE1BR0VOVEE+fDxSRVNFVD48TUFHRU5UQT4vPFJFU0VUPjxHUkVFTj58PFJFU0VUPgorCTxNQUdFTlRBPnw8UkVTRVQ+ICogMQorCTxNQUdFTlRBPnw8UkVTRVQ+PE1BR0VOVEE+LzxSRVNFVD4KKwkqIGluaXRpYWwKKwlFT0YKKwlnaXQgbG9nIC0tY29sb3I9YWx3YXlzIC0tZ3JhcGggLS1kYXRlLW9yZGVyIC0tcHJldHR5PXRmb3JtYXQ6JXMgYWZ0ZXItNCBvY3RvcHVzLW1lcmdlID5hY3R1YWwuY29sb3JzLnJhdyAmJgorCXRlc3RfZGVjb2RlX2NvbG9yIDxhY3R1YWwuY29sb3JzLnJhdyB8IHNlZCAicy8gKlwkLy8iID5hY3R1YWwuY29sb3JzICYmCisJdGVzdF9jbXAgZXhwZWN0LmNvbG9ycyBhY3R1YWwuY29sb3JzCisnCisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2xvZyAtLWdyYXBoIHdpdGggY3Jvc3NvdmVyIGluIG9jdG9wdXMgbWVyZ2UgYW5kIGl0cyBjaGlsZCwgbm8gY29sb3InICcKKwljYXQgPmV4cGVjdC51bmNvbG9yZWQgPDwtXEVPRiAmJgorCSogYWZ0ZXItNAorCXwgKiBhZnRlci1tZXJnZQorCXwgKi0tLS4gICBvY3RvcHVzLW1lcmdlCisJfCB8XCBcIFwKKwl8IHxffF98LworCXwvfCB8IHwKKwkqIHwgfCB8IDQKKwl8IHwgfCAqIDMKKwl8IHxffC8KKwl8L3wgfAorCXwgfCAqIDIKKwl8IHwvCisJfC98CisJfCAqIDEKKwl8LworCSogaW5pdGlhbAorCUVPRgorCWdpdCBsb2cgLS1jb2xvcj1uZXZlciAtLWdyYXBoIC0tZGF0ZS1vcmRlciAtLXByZXR0eT10Zm9ybWF0OiVzIGFmdGVyLTQgYWZ0ZXItbWVyZ2UgPmFjdHVhbC5yYXcgJiYKKwlzZWQgInMvICpcJC8vIiBhY3R1YWwucmF3ID5hY3R1YWwgJiYKKwl0ZXN0X2NtcCBleHBlY3QudW5jb2xvcmVkIGFjdHVhbAorJworCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdsb2cgLS1ncmFwaCB3aXRoIGNyb3Nzb3ZlciBpbiBvY3RvcHVzIG1lcmdlIGFuZCBpdHMgY2hpbGQgd2l0aCBjb2xvcnMnICcKKwl0ZXN0X2NvbmZpZyBsb2cuZ3JhcGhDb2xvcnMgcmVkLGdyZWVuLHllbGxvdyxibHVlLG1hZ2VudGEsY3lhbiAmJgorCWNhdCA+ZXhwZWN0LmNvbG9ycyA8PC1cRU9GICYmCisJKiBhZnRlci00CisJPFJFRD58PFJFU0VUPiAqIGFmdGVyLW1lcmdlCisJPFJFRD58PFJFU0VUPiAqPE1BR0VOVEE+LTxSRVNFVD48TUFHRU5UQT4tPFJFU0VUPjxSRUQ+LTxSRVNFVD48UkVEPi48UkVTRVQ+ICAgb2N0b3B1cy1tZXJnZQorCTxSRUQ+fDxSRVNFVD4gPFlFTExPVz58PFJFU0VUPjxCTFVFPlw8UkVTRVQ+IDxNQUdFTlRBPlw8UkVTRVQ+IDxSRUQ+XDxSRVNFVD4KKwk8UkVEPnw8UkVTRVQ+IDxZRUxMT1c+fDxSRVNFVD48UkVEPl88UkVTRVQ+PEJMVUU+fDxSRVNFVD48UkVEPl88UkVTRVQ+PE1BR0VOVEE+fDxSRVNFVD48UkVEPi88UkVTRVQ+CisJPFJFRD58PFJFU0VUPjxSRUQ+LzxSRVNFVD48WUVMTE9XPnw8UkVTRVQ+IDxCTFVFPnw8UkVTRVQ+IDxNQUdFTlRBPnw8UkVTRVQ+CisJKiA8WUVMTE9XPnw8UkVTRVQ+IDxCTFVFPnw8UkVTRVQ+IDxNQUdFTlRBPnw8UkVTRVQ+IDQKKwk8Q1lBTj58PFJFU0VUPiA8WUVMTE9XPnw8UkVTRVQ+IDxCTFVFPnw8UkVTRVQ+ICogMworCTxDWUFOPnw8UkVTRVQ+IDxZRUxMT1c+fDxSRVNFVD48Q1lBTj5fPFJFU0VUPjxCTFVFPnw8UkVTRVQ+PENZQU4+LzxSRVNFVD4KKwk8Q1lBTj58PFJFU0VUPjxDWUFOPi88UkVTRVQ+PFlFTExPVz58PFJFU0VUPiA8QkxVRT58PFJFU0VUPgorCTxDWUFOPnw8UkVTRVQ+IDxZRUxMT1c+fDxSRVNFVD4gKiAyCisJPENZQU4+fDxSRVNFVD4gPFlFTExPVz58PFJFU0VUPjxDWUFOPi88UkVTRVQ+CisJPENZQU4+fDxSRVNFVD48Q1lBTj4vPFJFU0VUPjxZRUxMT1c+fDxSRVNFVD4KKwk8Q1lBTj58PFJFU0VUPiAqIDEKKwk8Q1lBTj58PFJFU0VUPjxDWUFOPi88UkVTRVQ+CisJKiBpbml0aWFsCisJRU9GCisJZ2l0IGxvZyAtLWNvbG9yPWFsd2F5cyAtLWdyYXBoIC0tZGF0ZS1vcmRlciAtLXByZXR0eT10Zm9ybWF0OiVzIGFmdGVyLTQgYWZ0ZXItbWVyZ2UgPmFjdHVhbC5jb2xvcnMucmF3ICYmCisJdGVzdF9kZWNvZGVfY29sb3IgPGFjdHVhbC5jb2xvcnMucmF3IHwgc2VkICJzLyAqXCQvLyIgPmFjdHVhbC5jb2xvcnMgJiYKKwl0ZXN0X2NtcCBleHBlY3QuY29sb3JzIGFjdHVhbC5jb2xvcnMKKycKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAnbG9nIC0tZ3JhcGggd2l0aCB1bnJlbGF0ZWQgY29tbWl0IGFuZCBvY3RvcHVzIHRpcCwgbm8gY29sb3InICcKKwljYXQgPmV4cGVjdC51bmNvbG9yZWQgPDwtXEVPRiAmJgorCSogYWZ0ZXItaW5pdGlhbAorCXwgKi0tLS4gICBvY3RvcHVzLW1lcmdlCisJfCB8XCBcIFwKKwl8IHwgfCB8ICogNAorCXwgfF98X3wvCisJfC98IHwgfAorCXwgfCB8ICogMworCXwgfF98LworCXwvfCB8CisJfCB8ICogMgorCXwgfC8KKwl8L3wKKwl8ICogMQorCXwvCisJKiBpbml0aWFsCisJRU9GCisJZ2l0IGxvZyAtLWNvbG9yPW5ldmVyIC0tZ3JhcGggLS1kYXRlLW9yZGVyIC0tcHJldHR5PXRmb3JtYXQ6JXMgYWZ0ZXItaW5pdGlhbCBvY3RvcHVzLW1lcmdlID5hY3R1YWwucmF3ICYmCisJc2VkICJzLyAqXCQvLyIgYWN0dWFsLnJhdyA+YWN0dWFsICYmCisJdGVzdF9jbXAgZXhwZWN0LnVuY29sb3JlZCBhY3R1YWwKKycKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAnbG9nIC0tZ3JhcGggd2l0aCB1bnJlbGF0ZWQgY29tbWl0IGFuZCBvY3RvcHVzIHRpcCB3aXRoIGNvbG9ycycgJworCXRlc3RfY29uZmlnIGxvZy5ncmFwaENvbG9ycyByZWQsZ3JlZW4seWVsbG93LGJsdWUsbWFnZW50YSxjeWFuICYmCisJY2F0ID5leHBlY3QuY29sb3JzIDw8LVxFT0YgJiYKKwkqIGFmdGVyLWluaXRpYWwKKwk8UkVEPnw8UkVTRVQ+ICo8QkxVRT4tPFJFU0VUPjxCTFVFPi08UkVTRVQ+PE1BR0VOVEE+LTxSRVNFVD48TUFHRU5UQT4uPFJFU0VUPiAgIG9jdG9wdXMtbWVyZ2UKKwk8UkVEPnw8UkVTRVQ+IDxHUkVFTj58PFJFU0VUPjxZRUxMT1c+XDxSRVNFVD4gPEJMVUU+XDxSRVNFVD4gPE1BR0VOVEE+XDxSRVNFVD4KKwk8UkVEPnw8UkVTRVQ+IDxHUkVFTj58PFJFU0VUPiA8WUVMTE9XPnw8UkVTRVQ+IDxCTFVFPnw8UkVTRVQ+ICogNAorCTxSRUQ+fDxSRVNFVD4gPEdSRUVOPnw8UkVTRVQ+PFJFRD5fPFJFU0VUPjxZRUxMT1c+fDxSRVNFVD48UkVEPl88UkVTRVQ+PEJMVUU+fDxSRVNFVD48UkVEPi88UkVTRVQ+CisJPFJFRD58PFJFU0VUPjxSRUQ+LzxSRVNFVD48R1JFRU4+fDxSRVNFVD4gPFlFTExPVz58PFJFU0VUPiA8QkxVRT58PFJFU0VUPgorCTxSRUQ+fDxSRVNFVD4gPEdSRUVOPnw8UkVTRVQ+IDxZRUxMT1c+fDxSRVNFVD4gKiAzCisJPFJFRD58PFJFU0VUPiA8R1JFRU4+fDxSRVNFVD48UkVEPl88UkVTRVQ+PFlFTExPVz58PFJFU0VUPjxSRUQ+LzxSRVNFVD4KKwk8UkVEPnw8UkVTRVQ+PFJFRD4vPFJFU0VUPjxHUkVFTj58PFJFU0VUPiA8WUVMTE9XPnw8UkVTRVQ+CisJPFJFRD58PFJFU0VUPiA8R1JFRU4+fDxSRVNFVD4gKiAyCisJPFJFRD58PFJFU0VUPiA8R1JFRU4+fDxSRVNFVD48UkVEPi88UkVTRVQ+CisJPFJFRD58PFJFU0VUPjxSRUQ+LzxSRVNFVD48R1JFRU4+fDxSRVNFVD4KKwk8UkVEPnw8UkVTRVQ+ICogMQorCTxSRUQ+fDxSRVNFVD48UkVEPi88UkVTRVQ+CisJKiBpbml0aWFsCisJRU9GCisJZ2l0IGxvZyAtLWNvbG9yPWFsd2F5cyAtLWdyYXBoIC0tZGF0ZS1vcmRlciAtLXByZXR0eT10Zm9ybWF0OiVzIGFmdGVyLWluaXRpYWwgb2N0b3B1cy1tZXJnZSA+YWN0dWFsLmNvbG9ycy5yYXcgJiYKKwl0ZXN0X2RlY29kZV9jb2xvciA8YWN0dWFsLmNvbG9ycy5yYXcgfCBzZWQgInMvICpcJC8vIiA+YWN0dWFsLmNvbG9ycyAmJgorCXRlc3RfY21wIGV4cGVjdC5jb2xvcnMgYWN0dWFsLmNvbG9ycworJworCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdsb2cgLS1ncmFwaCB3aXRoIHVucmVsYXRlZCBjb21taXQgYW5kIG9jdG9wdXMgY2hpbGQsIG5vIGNvbG9yJyAnCisJY2F0ID5leHBlY3QudW5jb2xvcmVkIDw8LVxFT0YgJiYKKwkqIGFmdGVyLWluaXRpYWwKKwl8ICogYWZ0ZXItbWVyZ2UKKwl8ICotLS0uICAgb2N0b3B1cy1tZXJnZQorCXwgfFwgXCBcCisJfCB8IHwgfCAqIDQKKwl8IHxffF98LworCXwvfCB8IHwKKwl8IHwgfCAqIDMKKwl8IHxffC8KKwl8L3wgfAorCXwgfCAqIDIKKwl8IHwvCisJfC98CisJfCAqIDEKKwl8LworCSogaW5pdGlhbAorCUVPRgorCWdpdCBsb2cgLS1jb2xvcj1uZXZlciAtLWdyYXBoIC0tZGF0ZS1vcmRlciAtLXByZXR0eT10Zm9ybWF0OiVzIGFmdGVyLWluaXRpYWwgYWZ0ZXItbWVyZ2UgPmFjdHVhbC5yYXcgJiYKKwlzZWQgInMvICpcJC8vIiBhY3R1YWwucmF3ID5hY3R1YWwgJiYKKwl0ZXN0X2NtcCBleHBlY3QudW5jb2xvcmVkIGFjdHVhbAorJworCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdsb2cgLS1ncmFwaCB3aXRoIHVucmVsYXRlZCBjb21taXQgYW5kIG9jdG9wdXMgY2hpbGQgd2l0aCBjb2xvcnMnICcKKwl0ZXN0X2NvbmZpZyBsb2cuZ3JhcGhDb2xvcnMgcmVkLGdyZWVuLHllbGxvdyxibHVlLG1hZ2VudGEsY3lhbiAmJgorCWNhdCA+ZXhwZWN0LmNvbG9ycyA8PC1cRU9GICYmCisJKiBhZnRlci1pbml0aWFsCisJPFJFRD58PFJFU0VUPiAqIGFmdGVyLW1lcmdlCisJPFJFRD58PFJFU0VUPiAqPE1BR0VOVEE+LTxSRVNFVD48TUFHRU5UQT4tPFJFU0VUPjxDWUFOPi08UkVTRVQ+PENZQU4+LjxSRVNFVD4gICBvY3RvcHVzLW1lcmdlCisJPFJFRD58PFJFU0VUPiA8WUVMTE9XPnw8UkVTRVQ+PEJMVUU+XDxSRVNFVD4gPE1BR0VOVEE+XDxSRVNFVD4gPENZQU4+XDxSRVNFVD4KKwk8UkVEPnw8UkVTRVQ+IDxZRUxMT1c+fDxSRVNFVD4gPEJMVUU+fDxSRVNFVD4gPE1BR0VOVEE+fDxSRVNFVD4gKiA0CisJPFJFRD58PFJFU0VUPiA8WUVMTE9XPnw8UkVTRVQ+PFJFRD5fPFJFU0VUPjxCTFVFPnw8UkVTRVQ+PFJFRD5fPFJFU0VUPjxNQUdFTlRBPnw8UkVTRVQ+PFJFRD4vPFJFU0VUPgorCTxSRUQ+fDxSRVNFVD48UkVEPi88UkVTRVQ+PFlFTExPVz58PFJFU0VUPiA8QkxVRT58PFJFU0VUPiA8TUFHRU5UQT58PFJFU0VUPgorCTxSRUQ+fDxSRVNFVD4gPFlFTExPVz58PFJFU0VUPiA8QkxVRT58PFJFU0VUPiAqIDMKKwk8UkVEPnw8UkVTRVQ+IDxZRUxMT1c+fDxSRVNFVD48UkVEPl88UkVTRVQ+PEJMVUU+fDxSRVNFVD48UkVEPi88UkVTRVQ+CisJPFJFRD58PFJFU0VUPjxSRUQ+LzxSRVNFVD48WUVMTE9XPnw8UkVTRVQ+IDxCTFVFPnw8UkVTRVQ+CisJPFJFRD58PFJFU0VUPiA8WUVMTE9XPnw8UkVTRVQ+ICogMgorCTxSRUQ+fDxSRVNFVD4gPFlFTExPVz58PFJFU0VUPjxSRUQ+LzxSRVNFVD4KKwk8UkVEPnw8UkVTRVQ+PFJFRD4vPFJFU0VUPjxZRUxMT1c+fDxSRVNFVD4KKwk8UkVEPnw8UkVTRVQ+ICogMQorCTxSRUQ+fDxSRVNFVD48UkVEPi88UkVTRVQ+CisJKiBpbml0aWFsCisJRU9GCisJZ2l0IGxvZyAtLWNvbG9yPWFsd2F5cyAtLWdyYXBoIC0tZGF0ZS1vcmRlciAtLXByZXR0eT10Zm9ybWF0OiVzIGFmdGVyLWluaXRpYWwgYWZ0ZXItbWVyZ2UgPmFjdHVhbC5jb2xvcnMucmF3ICYmCisJdGVzdF9kZWNvZGVfY29sb3IgPGFjdHVhbC5jb2xvcnMucmF3IHwgc2VkICJzLyAqXCQvLyIgPmFjdHVhbC5jb2xvcnMgJiYKKwl0ZXN0X2NtcCBleHBlY3QuY29sb3JzIGFjdHVhbC5jb2xvcnMKKycKKwogdGVzdF9kb25lCmRpZmYgLS1naXQgYS90L3Q0MjE1LWxvZy1za2V3ZWQtbWVyZ2VzLnNoIGIvdC90NDIxNS1sb2ctc2tld2VkLW1lcmdlcy5zaApuZXcgZmlsZSBtb2RlIDEwMDc1NQppbmRleCAwMDAwMDAwLi4xODcwOWE3Ci0tLSAvZGV2L251bGwKKysrIGIvdC90NDIxNS1sb2ctc2tld2VkLW1lcmdlcy5zaApAQCAtMCwwICsxLDI0MyBAQAorIyEvYmluL3NoCisKK3Rlc3RfZGVzY3JpcHRpb249J2dpdCBsb2cgLS1ncmFwaCBvZiBza2V3ZWQgbWVyZ2VzJworCisuIC4vdGVzdC1saWIuc2gKKworY2hlY2tfZ3JhcGggKCkgeworCWNhdCA+ZXhwZWN0ICYmCisJZ2l0IGxvZyAtLWdyYXBoIC0tcHJldHR5PXRmb3JtYXQ6JXMgIiRAIiA+YWN0dWFsLnJhdyAmJgorCXNlZCAicy8gKiQvLyIgYWN0dWFsLnJhdyA+YWN0dWFsICYmCisJdGVzdF9jbXAgZXhwZWN0IGFjdHVhbAorfQorCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdsb2cgLS1ncmFwaCB3aXRoIG1lcmdlIGZ1c2luZyB3aXRoIGl0cyBsZWZ0IGFuZCByaWdodCBuZWlnaGJvcnMnICcKKwlnaXQgY2hlY2tvdXQgLS1vcnBoYW4gX3AgJiYKKwl0ZXN0X2NvbW1pdCBBICYmCisJdGVzdF9jb21taXQgQiAmJgorCWdpdCBjaGVja291dCAtYiBfcSBAXiAmJiB0ZXN0X2NvbW1pdCBDICYmCisJZ2l0IGNoZWNrb3V0IC1iIF9yIEBeICYmIHRlc3RfY29tbWl0IEQgJiYKKwlnaXQgY2hlY2tvdXQgX3AgJiYgZ2l0IG1lcmdlIC0tbm8tZmYgX3EgX3IgLW0gRSAmJgorCWdpdCBjaGVja291dCBfciAmJiB0ZXN0X2NvbW1pdCBGICYmCisJZ2l0IGNoZWNrb3V0IF9wICYmIGdpdCBtZXJnZSAtLW5vLWZmIF9yIC1tIEcgJiYKKwlnaXQgY2hlY2tvdXQgQF5eICYmIGdpdCBtZXJnZSAtLW5vLWZmIF9wIC1tIEggJiYKKworCWNoZWNrX2dyYXBoIDw8LVxFT0YKKwkqICAgSAorCXxcCisJfCAqICAgRworCXwgfFwKKwl8IHwgKiBGCisJfCAqIHwgRQorCXwvfFx8CisJfCB8ICogRAorCXwgKiB8IEMKKwl8IHwvCisJKiAvIEIKKwl8LworCSogQQorCUVPRgorJworCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdsb2cgLS1ncmFwaCB3aXRoIGxlZnQtc2tld2VkIG1lcmdlJyAnCisJZ2l0IGNoZWNrb3V0IC0tb3JwaGFuIDBfcCAmJiB0ZXN0X2NvbW1pdCAwX0EgJiYKKwlnaXQgY2hlY2tvdXQgLWIgMF9xIDBfcCAmJiB0ZXN0X2NvbW1pdCAwX0IgJiYKKwlnaXQgY2hlY2tvdXQgLWIgMF9yIDBfcCAmJgorCXRlc3RfY29tbWl0IDBfQyAmJgorCXRlc3RfY29tbWl0IDBfRCAmJgorCWdpdCBjaGVja291dCAtYiAwX3MgMF9wICYmIHRlc3RfY29tbWl0IDBfRSAmJgorCWdpdCBjaGVja291dCAtYiAwX3QgMF9wICYmIGdpdCBtZXJnZSAtLW5vLWZmIDBfcl4gMF9zIC1tIDBfRiAmJgorCWdpdCBjaGVja291dCAwX3AgJiYgZ2l0IG1lcmdlIC0tbm8tZmYgMF9zIC1tIDBfRyAmJgorCWdpdCBjaGVja291dCBAXiAmJiBnaXQgbWVyZ2UgLS1uby1mZiAwX3EgMF9yIDBfdCAwX3AgLW0gMF9IICYmCisKKwljaGVja19ncmFwaCA8PC1cRU9GCisJKi0tLS0tLiAgIDBfSAorCXxcIFwgXCBcCisJfCB8IHwgfCAqIDBfRworCXwgfF98X3wvfAorCXwvfCB8IHwgfAorCXwgfCB8ICogfCAwX0YKKwl8IHxffC98XHwKKwl8L3wgfCB8IHwKKwl8IHwgfCB8ICogMF9FCisJfCB8X3xffC8KKwl8L3wgfCB8CisJfCB8ICogfCAwX0QKKwl8IHwgfC8KKwl8IHwgKiAwX0MKKwl8IHwvCisJfC98CisJfCAqIDBfQgorCXwvCisJKiAwX0EKKwlFT0YKKycKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAnbG9nIC0tZ3JhcGggd2l0aCBuZXN0ZWQgbGVmdC1za2V3ZWQgbWVyZ2UnICcKKwlnaXQgY2hlY2tvdXQgLS1vcnBoYW4gMV9wICYmCisJdGVzdF9jb21taXQgMV9BICYmCisJdGVzdF9jb21taXQgMV9CICYmCisJdGVzdF9jb21taXQgMV9DICYmCisJZ2l0IGNoZWNrb3V0IC1iIDFfcSBAXiAmJiB0ZXN0X2NvbW1pdCAxX0QgJiYKKwlnaXQgY2hlY2tvdXQgMV9wICYmIGdpdCBtZXJnZSAtLW5vLWZmIDFfcSAtbSAxX0UgJiYKKwlnaXQgY2hlY2tvdXQgLWIgMV9yIEB+MyAmJiB0ZXN0X2NvbW1pdCAxX0YgJiYKKwlnaXQgY2hlY2tvdXQgMV9wICYmIGdpdCBtZXJnZSAtLW5vLWZmIDFfciAtbSAxX0cgJiYKKwlnaXQgY2hlY2tvdXQgQF5eICYmIGdpdCBtZXJnZSAtLW5vLWZmIDFfcCAtbSAxX0ggJiYKKworCWNoZWNrX2dyYXBoIDw8LVxFT0YKKwkqICAgMV9ICisJfFwKKwl8ICogICAxX0cKKwl8IHxcCisJfCB8ICogMV9GCisJfCAqIHwgMV9FCisJfC98IHwKKwl8ICogfCAxX0QKKwkqIHwgfCAxX0MKKwl8LyAvCisJKiAvIDFfQgorCXwvCisJKiAxX0EKKwlFT0YKKycKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAnbG9nIC0tZ3JhcGggd2l0aCBuZXN0ZWQgbGVmdC1za2V3ZWQgbWVyZ2UgZm9sbG93aW5nIG5vcm1hbCBtZXJnZScgJworCWdpdCBjaGVja291dCAtLW9ycGhhbiAyX3AgJiYKKwl0ZXN0X2NvbW1pdCAyX0EgJiYKKwl0ZXN0X2NvbW1pdCAyX0IgJiYKKwl0ZXN0X2NvbW1pdCAyX0MgJiYKKwlnaXQgY2hlY2tvdXQgLWIgMl9xIEBeXiAmJgorCXRlc3RfY29tbWl0IDJfRCAmJgorCXRlc3RfY29tbWl0IDJfRSAmJgorCWdpdCBjaGVja291dCAtYiAyX3IgQF4gJiYgdGVzdF9jb21taXQgMl9GICYmCisJZ2l0IGNoZWNrb3V0IDJfcSAmJgorCWdpdCBtZXJnZSAtLW5vLWZmIDJfciAtbSAyX0cgJiYKKwlnaXQgbWVyZ2UgLS1uby1mZiAyX3BeIC1tIDJfSCAmJgorCWdpdCBjaGVja291dCAtYiAyX3MgQF5eICYmIGdpdCBtZXJnZSAtLW5vLWZmIDJfcSAtbSAyX0ogJiYKKwlnaXQgY2hlY2tvdXQgMl9wICYmIGdpdCBtZXJnZSAtLW5vLWZmIDJfcyAtbSAyX0sgJiYKKworCWNoZWNrX2dyYXBoIDw8LVxFT0YKKwkqICAgMl9LCisJfFwKKwl8ICogICAyX0oKKwl8IHxcCisJfCB8ICogICAyX0gKKwl8IHwgfFwKKwl8IHwgKiB8IDJfRworCXwgfC98IHwKKwl8IHwgKiB8IDJfRgorCXwgKiB8IHwgMl9FCisJfCB8LyAvCisJfCAqIHwgMl9ECisJKiB8IHwgMl9DCisJfCB8LworCXwvfAorCSogfCAyX0IKKwl8LworCSogMl9BCisJRU9GCisnCisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2xvZyAtLWdyYXBoIHdpdGggbmVzdGVkIHJpZ2h0LXNrZXdlZCBtZXJnZSBmb2xsb3dpbmcgbGVmdC1za2V3ZWQgbWVyZ2UnICcKKwlnaXQgY2hlY2tvdXQgLS1vcnBoYW4gM19wICYmCisJdGVzdF9jb21taXQgM19BICYmCisJZ2l0IGNoZWNrb3V0IC1iIDNfcSAmJgorCXRlc3RfY29tbWl0IDNfQiAmJgorCXRlc3RfY29tbWl0IDNfQyAmJgorCWdpdCBjaGVja291dCAtYiAzX3IgQF4gJiYKKwl0ZXN0X2NvbW1pdCAzX0QgJiYKKwlnaXQgY2hlY2tvdXQgM19xICYmIGdpdCBtZXJnZSAtLW5vLWZmIDNfciAtbSAzX0UgJiYKKwlnaXQgY2hlY2tvdXQgM19wICYmIGdpdCBtZXJnZSAtLW5vLWZmIDNfcSAtbSAzX0YgJiYKKwlnaXQgY2hlY2tvdXQgM19yICYmIHRlc3RfY29tbWl0IDNfRyAmJgorCWdpdCBjaGVja291dCAzX3AgJiYgZ2l0IG1lcmdlIC0tbm8tZmYgM19yIC1tIDNfSCAmJgorCWdpdCBjaGVja291dCBAXl4gJiYgZ2l0IG1lcmdlIC0tbm8tZmYgM19wIC1tIDNfSiAmJgorCisJY2hlY2tfZ3JhcGggPDwtXEVPRgorCSogICAzX0oKKwl8XAorCXwgKiAgIDNfSAorCXwgfFwKKwl8IHwgKiAzX0cKKwl8ICogfCAzX0YKKwl8L3wgfAorCXwgKiB8IDNfRQorCXwgfFx8CisJfCB8ICogM19ECisJfCAqIHwgM19DCisJfCB8LworCXwgKiAzX0IKKwl8LworCSogM19BCisJRU9GCisnCisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2xvZyAtLWdyYXBoIHdpdGggcmlnaHQtc2tld2VkIG1lcmdlIGZvbGxvd2luZyBhIGxlZnQtc2tld2VkIG9uZScgJworCWdpdCBjaGVja291dCAtLW9ycGhhbiA0X3AgJiYKKwl0ZXN0X2NvbW1pdCA0X0EgJiYKKwl0ZXN0X2NvbW1pdCA0X0IgJiYKKwl0ZXN0X2NvbW1pdCA0X0MgJiYKKwlnaXQgY2hlY2tvdXQgLWIgNF9xIEBeXiAmJiB0ZXN0X2NvbW1pdCA0X0QgJiYKKwlnaXQgY2hlY2tvdXQgLWIgNF9yIDRfcF4gJiYgZ2l0IG1lcmdlIC0tbm8tZmYgNF9xIC1tIDRfRSAmJgorCWdpdCBjaGVja291dCAtYiA0X3MgNF9wXl4gJiYKKwlnaXQgbWVyZ2UgLS1uby1mZiA0X3IgLW0gNF9GICYmCisJZ2l0IG1lcmdlIC0tbm8tZmYgNF9wIC1tIDRfRyAmJgorCWdpdCBjaGVja291dCBAXl4gJiYgZ2l0IG1lcmdlIC0tbm8tZmYgNF9zIC1tIDRfSCAmJgorCisJY2hlY2tfZ3JhcGggLS1kYXRlLW9yZGVyIDw8LVxFT0YKKwkqICAgNF9ICisJfFwKKwl8ICogICA0X0cKKwl8IHxcCisJfCAqIHwgNF9GCisJfC98IHwKKwl8ICogfCAgIDRfRQorCXwgfFwgXAorCXwgfCAqIHwgNF9ECisJfCB8LyAvCisJfC98IHwKKwl8IHwgKiA0X0MKKwl8IHwvCisJfCAqIDRfQgorCXwvCisJKiA0X0EKKwlFT0YKKycKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAnbG9nIC0tZ3JhcGggd2l0aCBvY3RvcHVzIG1lcmdlIHdpdGggY29sdW1uIGpvaW5pbmcgaXRzIHBlbnVsdGltYXRlIHBhcmVudCcgJworCWdpdCBjaGVja291dCAtLW9ycGhhbiA1X3AgJiYKKwl0ZXN0X2NvbW1pdCA1X0EgJiYKKwlnaXQgYnJhbmNoIDVfcSAmJgorCWdpdCBicmFuY2ggNV9yICYmCisJdGVzdF9jb21taXQgNV9CICYmCisJZ2l0IGNoZWNrb3V0IDVfcSAmJiB0ZXN0X2NvbW1pdCA1X0MgJiYKKwlnaXQgY2hlY2tvdXQgNV9yICYmIHRlc3RfY29tbWl0IDVfRCAmJgorCWdpdCBjaGVja291dCA1X3AgJiYKKwlnaXQgbWVyZ2UgLS1uby1mZiA1X3EgNV9yIC1tIDVfRSAmJgorCWdpdCBjaGVja291dCA1X3EgJiYgdGVzdF9jb21taXQgNV9GICYmCisJZ2l0IGNoZWNrb3V0IC1iIDVfcyA1X3BeICYmCisJZ2l0IG1lcmdlIC0tbm8tZmYgNV9wIDVfcSAtbSA1X0cgJiYKKwlnaXQgY2hlY2tvdXQgNV9yICYmCisJZ2l0IG1lcmdlIC0tbm8tZmYgNV9zIC1tIDVfSCAmJgorCisJY2hlY2tfZ3JhcGggPDwtXEVPRgorCSogICA1X0gKKwl8XAorCXwgKi0uICAgNV9HCisJfCB8XCBcCisJfCB8IHwgKiA1X0YKKwl8IHwgKiB8ICAgNV9FCisJfCB8L3xcIFwKKwl8IHxffC8gLworCXwvfCB8IC8KKwl8IHwgfC8KKwkqIHwgfCA1X0QKKwl8IHwgKiA1X0MKKwl8IHwvCisJfC98CisJfCAqIDVfQgorCXwvCisJKiA1X0EKKwlFT0YKKycKKwordGVzdF9kb25lCmRpZmYgLS1naXQgYS90L3Q1MDA0LWFyY2hpdmUtY29ybmVyLWNhc2VzLnNoIGIvdC90NTAwNC1hcmNoaXZlLWNvcm5lci1jYXNlcy5zaAppbmRleCAyNzFlYjVhLi4zZTdiMjNjIDEwMDc1NQotLS0gYS90L3Q1MDA0LWFyY2hpdmUtY29ybmVyLWNhc2VzLnNoCisrKyBiL3QvdDUwMDQtYXJjaGl2ZS1jb3JuZXItY2FzZXMuc2gKQEAgLTIwNCw0ICsyMDQsMjMgQEAKIAlncmVwICRzaXplIGJpZy5sc3QKICcKIAorYnVpbGRfdHJlZSgpIHsKKwlwZXJsIC1lICcKKwkJbXkgJGhhc2ggPSAkQVJHVlswXTsKKwkJZm9yZWFjaCBteSAkb3JkZXIgKDIuLjYpIHsKKwkJCSRmaXJzdCA9IDEwICoqICRvcmRlcjsKKwkJCWZvcmVhY2ggbXkgJGkgKC0xMy4uLTkpIHsKKwkJCQlteSAkbmFtZSA9ICJhIiB4ICgkZmlyc3QgKyAkaSk7CisJCQkJcHJpbnQgIjEwMDY0NCBibG9iICRoYXNoXHQkbmFtZVxuIgorCQkJfQorCQl9CisJJyAiJDEiCit9CisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3RhciBhcmNoaXZlIHdpdGggbG9uZyBwYXRocycgJworCWJsb2I9JChlY2hvIGZvbyB8IGdpdCBoYXNoLW9iamVjdCAtdyAtLXN0ZGluKSAmJgorCXRyZWU9JChidWlsZF90cmVlICRibG9iIHwgZ2l0IG1rdHJlZSkgJiYKKwlnaXQgYXJjaGl2ZSAtbyBsb25nX3BhdGhzLnRhciAkdHJlZQorJworCiB0ZXN0X2RvbmUKZGlmZiAtLWdpdCBhL3QvdDUzMDctcGFjay1taXNzaW5nLWNvbW1pdC5zaCBiL3QvdDUzMDctcGFjay1taXNzaW5nLWNvbW1pdC5zaAppbmRleCBkYWNiNDQwLi5mNDMzOGFiIDEwMDc1NQotLS0gYS90L3Q1MzA3LXBhY2stbWlzc2luZy1jb21taXQuc2gKKysrIGIvdC90NTMwNy1wYWNrLW1pc3NpbmctY29tbWl0LnNoCkBAIC0yNCwxMSArMjQsMTEgQEAKICcKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAncmV2LWxpc3Qgbm90aWNlcyBjb3JydXB0aW9uICgxKScgJwotCXRlc3RfbXVzdF9mYWlsIGVudiBHSVRfVEVTVF9DT01NSVRfR1JBUEg9MCBnaXQgcmV2LWxpc3QgSEVBRAorCXRlc3RfbXVzdF9mYWlsIGVudiBHSVRfVEVTVF9DT01NSVRfR1JBUEg9MCBnaXQgLWMgY29yZS5jb21taXRHcmFwaD1mYWxzZSByZXYtbGlzdCBIRUFECiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3Jldi1saXN0IG5vdGljZXMgY29ycnVwdGlvbiAoMiknICcKLQl0ZXN0X211c3RfZmFpbCBlbnYgR0lUX1RFU1RfQ09NTUlUX0dSQVBIPTAgZ2l0IHJldi1saXN0IC0tb2JqZWN0cyBIRUFECisJdGVzdF9tdXN0X2ZhaWwgZW52IEdJVF9URVNUX0NPTU1JVF9HUkFQSD0wIGdpdCAtYyBjb3JlLmNvbW1pdEdyYXBoPWZhbHNlIHJldi1saXN0IC0tb2JqZWN0cyBIRUFECiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3BhY2stb2JqZWN0cyBub3RpY2VzIGNvcnJ1cHRpb24nICcKZGlmZiAtLWdpdCBhL3QvdDUzMTgtY29tbWl0LWdyYXBoLnNoIGIvdC90NTMxOC1jb21taXQtZ3JhcGguc2gKaW5kZXggMjJjYjlkNi4uNWEzZTRlMyAxMDA3NTUKLS0tIGEvdC90NTMxOC1jb21taXQtZ3JhcGguc2gKKysrIGIvdC90NTMxOC1jb21taXQtZ3JhcGguc2gKQEAgLTIzLDExICsyMywxMCBAQAogCXRlc3RfcGF0aF9pc19taXNzaW5nIGluZm8vY29tbWl0LWdyYXBoCiAnCiAKLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2Nsb3NlIHdpdGggY29ycmVjdCBlcnJvciBvbiBiYWQgaW5wdXQnICcKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2V4aXQgd2l0aCBjb3JyZWN0IGVycm9yIG9uIGJhZCBpbnB1dCB0byAtLXN0ZGluLXBhY2tzJyAnCiAJY2QgIiRUUkFTSF9ESVJFQ1RPUlkvZnVsbCIgJiYKIAllY2hvIGRvZXNub3RleGlzdCA+aW4gJiYKLQl7IGdpdCBjb21taXQtZ3JhcGggd3JpdGUgLS1zdGRpbi1wYWNrcyA8aW4gMj5zdGRlcnI7IHJldD0kPzsgfSAmJgotCXRlc3QgIiRyZXQiID0gMSAmJgorCXRlc3RfZXhwZWN0X2NvZGUgMSBnaXQgY29tbWl0LWdyYXBoIHdyaXRlIC0tc3RkaW4tcGFja3MgPGluIDI+c3RkZXJyICYmCiAJdGVzdF9pMThuZ3JlcCAiZXJyb3IgYWRkaW5nIHBhY2siIHN0ZGVycgogJwogCkBAIC00MSw2ICs0MCwxNSBAQAogCWdpdCByZXBhY2sKICcKIAordGVzdF9leHBlY3Rfc3VjY2VzcyAnZXhpdCB3aXRoIGNvcnJlY3QgZXJyb3Igb24gYmFkIGlucHV0IHRvIC0tc3RkaW4tY29tbWl0cycgJworCWNkICIkVFJBU0hfRElSRUNUT1JZL2Z1bGwiICYmCisJZWNobyBIRUFEIHwgdGVzdF9leHBlY3RfY29kZSAxIGdpdCBjb21taXQtZ3JhcGggd3JpdGUgLS1zdGRpbi1jb21taXRzIDI+c3RkZXJyICYmCisJdGVzdF9pMThuZ3JlcCAiaW52YWxpZCBjb21taXQgb2JqZWN0IGlkIiBzdGRlcnIgJiYKKwkjIHZhbGlkIHRyZWUgT0lELCBidXQgbm90IGEgY29tbWl0IE9JRAorCWdpdCByZXYtcGFyc2UgSEVBRF57dHJlZX0gfCB0ZXN0X2V4cGVjdF9jb2RlIDEgZ2l0IGNvbW1pdC1ncmFwaCB3cml0ZSAtLXN0ZGluLWNvbW1pdHMgMj5zdGRlcnIgJiYKKwl0ZXN0X2kxOG5ncmVwICJpbnZhbGlkIGNvbW1pdCBvYmplY3QgaWQiIHN0ZGVycgorJworCiBncmFwaF9naXRfdHdvX21vZGVzKCkgewogCWdpdCAtYyBjb3JlLmNvbW1pdEdyYXBoPXRydWUgJDEgPm91dHB1dAogCWdpdCAtYyBjb3JlLmNvbW1pdEdyYXBoPWZhbHNlICQxID5leHBlY3QKQEAgLTc3LDcgKzg1LDcgQEAKIAludW1fY29tbWl0czogJDEKIAljaHVua3M6IG9pZF9mYW5vdXQgb2lkX2xvb2t1cCBjb21taXRfbWV0YWRhdGEkT1BUSU9OQUwKIAlFT0YKLQlnaXQgY29tbWl0LWdyYXBoIHJlYWQgPm91dHB1dCAmJgorCXRlc3QtdG9vbCByZWFkLWdyYXBoID5vdXRwdXQgJiYKIAl0ZXN0X2NtcCBleHBlY3Qgb3V0cHV0CiB9CiAKQEAgLTExNiw2ICsxMjQsNDIgQEAKIAlnaXQgcmVwYWNrCiAnCiAKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2NvbW1pdC1ncmFwaCB3cml0ZSBwcm9ncmVzcyBvZmYgZm9yIHJlZGlyZWN0ZWQgc3RkZXJyJyAnCisJY2QgIiRUUkFTSF9ESVJFQ1RPUlkvZnVsbCIgJiYKKwlnaXQgY29tbWl0LWdyYXBoIHdyaXRlIDI+ZXJyICYmCisJdGVzdF9saW5lX2NvdW50ID0gMCBlcnIKKycKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAnY29tbWl0LWdyYXBoIHdyaXRlIGZvcmNlIHByb2dyZXNzIG9uIGZvciBzdGRlcnInICcKKwljZCAiJFRSQVNIX0RJUkVDVE9SWS9mdWxsIiAmJgorCWdpdCBjb21taXQtZ3JhcGggd3JpdGUgLS1wcm9ncmVzcyAyPmVyciAmJgorCXRlc3RfZmlsZV9ub3RfZW1wdHkgZXJyCisnCisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2NvbW1pdC1ncmFwaCB3cml0ZSB3aXRoIHRoZSAtLW5vLXByb2dyZXNzIG9wdGlvbicgJworCWNkICIkVFJBU0hfRElSRUNUT1JZL2Z1bGwiICYmCisJZ2l0IGNvbW1pdC1ncmFwaCB3cml0ZSAtLW5vLXByb2dyZXNzIDI+ZXJyICYmCisJdGVzdF9saW5lX2NvdW50ID0gMCBlcnIKKycKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAnY29tbWl0LWdyYXBoIHZlcmlmeSBwcm9ncmVzcyBvZmYgZm9yIHJlZGlyZWN0ZWQgc3RkZXJyJyAnCisJY2QgIiRUUkFTSF9ESVJFQ1RPUlkvZnVsbCIgJiYKKwlnaXQgY29tbWl0LWdyYXBoIHZlcmlmeSAyPmVyciAmJgorCXRlc3RfbGluZV9jb3VudCA9IDAgZXJyCisnCisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2NvbW1pdC1ncmFwaCB2ZXJpZnkgZm9yY2UgcHJvZ3Jlc3Mgb24gZm9yIHN0ZGVycicgJworCWNkICIkVFJBU0hfRElSRUNUT1JZL2Z1bGwiICYmCisJZ2l0IGNvbW1pdC1ncmFwaCB2ZXJpZnkgLS1wcm9ncmVzcyAyPmVyciAmJgorCXRlc3RfZmlsZV9ub3RfZW1wdHkgZXJyCisnCisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2NvbW1pdC1ncmFwaCB2ZXJpZnkgd2l0aCB0aGUgLS1uby1wcm9ncmVzcyBvcHRpb24nICcKKwljZCAiJFRSQVNIX0RJUkVDVE9SWS9mdWxsIiAmJgorCWdpdCBjb21taXQtZ3JhcGggdmVyaWZ5IC0tbm8tcHJvZ3Jlc3MgMj5lcnIgJiYKKwl0ZXN0X2xpbmVfY291bnQgPSAwIGVycgorJworCiAjIEN1cnJlbnQgZ3JhcGggc3RydWN0dXJlOgogIwogIyAgIF9fTTNfX18KQEAgLTU3Nyw0ICs2MjEsNDcgQEAKIAl0ZXN0X2NtcCBleHBlY3QgYWN0dWFsCiAnCiAKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2NvcnJ1cHQgY29tbWl0LWdyYXBoIHdyaXRlIChicm9rZW4gcGFyZW50KScgJworCXJtIC1yZiByZXBvICYmCisJZ2l0IGluaXQgcmVwbyAmJgorCSgKKwkJY2QgcmVwbyAmJgorCQllbXB0eT0iJChnaXQgbWt0cmVlIDwvZGV2L251bGwpIiAmJgorCQljYXQgPmJyb2tlbiA8PC1FT0YgJiYKKwkJdHJlZSAkZW1wdHkKKwkJcGFyZW50IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAKKwkJYXV0aG9yIHdoYXRldmVyIDx3aGF0ZXZlckBleGFtcGxlLmNvbT4gMTIzNCAtMDAwMAorCQljb21taXR0ZXIgd2hhdGV2ZXIgPHdoYXRldmVyQGV4YW1wbGUuY29tPiAxMjM0IC0wMDAwCisKKwkJYnJva2VuIGNvbW1pdAorCQlFT0YKKwkJYnJva2VuPSIkKGdpdCBoYXNoLW9iamVjdCAtdyAtdCBjb21taXQgLS1saXRlcmFsbHkgYnJva2VuKSIgJiYKKwkJZ2l0IGNvbW1pdC10cmVlIC1wICIkYnJva2VuIiAtbSAiZ29vZCBjb21taXQiICIkZW1wdHkiID5nb29kICYmCisJCXRlc3RfbXVzdF9mYWlsIGdpdCBjb21taXQtZ3JhcGggd3JpdGUgLS1zdGRpbi1jb21taXRzIFwKKwkJCTxnb29kIDI+dGVzdF9lcnIgJiYKKwkJdGVzdF9pMThuZ3JlcCAidW5hYmxlIHRvIHBhcnNlIGNvbW1pdCIgdGVzdF9lcnIKKwkpCisnCisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2NvcnJ1cHQgY29tbWl0LWdyYXBoIHdyaXRlIChtaXNzaW5nIHRyZWUpJyAnCisJcm0gLXJmIHJlcG8gJiYKKwlnaXQgaW5pdCByZXBvICYmCisJKAorCQljZCByZXBvICYmCisJCXRyZWU9IiQoZ2l0IG1rdHJlZSA8L2Rldi9udWxsKSIgJiYKKwkJY2F0ID5icm9rZW4gPDwtRU9GICYmCisJCXBhcmVudCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwCisJCWF1dGhvciB3aGF0ZXZlciA8d2hhdGV2ZXJAZXhhbXBsZS5jb20+IDEyMzQgLTAwMDAKKwkJY29tbWl0dGVyIHdoYXRldmVyIDx3aGF0ZXZlckBleGFtcGxlLmNvbT4gMTIzNCAtMDAwMAorCisJCWJyb2tlbiBjb21taXQKKwkJRU9GCisJCWJyb2tlbj0iJChnaXQgaGFzaC1vYmplY3QgLXcgLXQgY29tbWl0IC0tbGl0ZXJhbGx5IGJyb2tlbikiICYmCisJCWdpdCBjb21taXQtdHJlZSAtcCAiJGJyb2tlbiIgLW0gImdvb2QiICIkdHJlZSIgPmdvb2QgJiYKKwkJdGVzdF9tdXN0X2ZhaWwgZ2l0IGNvbW1pdC1ncmFwaCB3cml0ZSAtLXN0ZGluLWNvbW1pdHMgXAorCQkJPGdvb2QgMj50ZXN0X2VyciAmJgorCQl0ZXN0X2kxOG5ncmVwICJ1bmFibGUgdG8gcGFyc2UgY29tbWl0IiB0ZXN0X2VycgorCSkKKycKKwogdGVzdF9kb25lCmRpZmYgLS1naXQgYS90L3Q1MzE5LW11bHRpLXBhY2staW5kZXguc2ggYi90L3Q1MzE5LW11bHRpLXBhY2staW5kZXguc2gKaW5kZXggYzcyY2EwNC4uY2QyZjg3YiAxMDA3NTUKLS0tIGEvdC90NTMxOS1tdWx0aS1wYWNrLWluZGV4LnNoCisrKyBiL3QvdDUzMTktbXVsdGktcGFjay1pbmRleC5zaApAQCAtMTQ3LDYgKzE0NywyMSBAQAogCiBjb21wYXJlX3Jlc3VsdHNfd2l0aF9taWR4ICJ0d28gcGFja3MiCiAKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3dyaXRlIHByb2dyZXNzIG9mZiBmb3IgcmVkaXJlY3RlZCBzdGRlcnInICcKKwlnaXQgbXVsdGktcGFjay1pbmRleCAtLW9iamVjdC1kaXI9JG9iamRpciB3cml0ZSAyPmVyciAmJgorCXRlc3RfbGluZV9jb3VudCA9IDAgZXJyCisnCisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3dyaXRlIGZvcmNlIHByb2dyZXNzIG9uIGZvciBzdGRlcnInICcKKwlnaXQgbXVsdGktcGFjay1pbmRleCAtLW9iamVjdC1kaXI9JG9iamRpciAtLXByb2dyZXNzIHdyaXRlIDI+ZXJyICYmCisJdGVzdF9maWxlX25vdF9lbXB0eSBlcnIKKycKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAnd3JpdGUgd2l0aCB0aGUgLS1uby1wcm9ncmVzcyBvcHRpb24nICcKKwlnaXQgbXVsdGktcGFjay1pbmRleCAtLW9iamVjdC1kaXI9JG9iamRpciAtLW5vLXByb2dyZXNzIHdyaXRlIDI+ZXJyICYmCisJdGVzdF9saW5lX2NvdW50ID0gMCBlcnIKKycKKwogdGVzdF9leHBlY3Rfc3VjY2VzcyAnYWRkIG1vcmUgcGFja3MnICcKIAlmb3IgaiBpbiAkKHRlc3Rfc2VxIDExIDIwKQogCWRvCkBAIC0xNjksNiArMTg0LDIxIEBACiAJZ2l0IG11bHRpLXBhY2staW5kZXggdmVyaWZ5IC0tb2JqZWN0LWRpcj0kb2JqZGlyCiAnCiAKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3ZlcmlmeSBwcm9ncmVzcyBvZmYgZm9yIHJlZGlyZWN0ZWQgc3RkZXJyJyAnCisJZ2l0IG11bHRpLXBhY2staW5kZXggdmVyaWZ5IC0tb2JqZWN0LWRpcj0kb2JqZGlyIDI+ZXJyICYmCisJdGVzdF9saW5lX2NvdW50ID0gMCBlcnIKKycKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAndmVyaWZ5IGZvcmNlIHByb2dyZXNzIG9uIGZvciBzdGRlcnInICcKKwlnaXQgbXVsdGktcGFjay1pbmRleCB2ZXJpZnkgLS1vYmplY3QtZGlyPSRvYmpkaXIgLS1wcm9ncmVzcyAyPmVyciAmJgorCXRlc3RfZmlsZV9ub3RfZW1wdHkgZXJyCisnCisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3ZlcmlmeSB3aXRoIHRoZSAtLW5vLXByb2dyZXNzIG9wdGlvbicgJworCWdpdCBtdWx0aS1wYWNrLWluZGV4IHZlcmlmeSAtLW9iamVjdC1kaXI9JG9iamRpciAtLW5vLXByb2dyZXNzIDI+ZXJyICYmCisJdGVzdF9saW5lX2NvdW50ID0gMCBlcnIKKycKKwogIyB1c2FnZTogY29ycnVwdF9taWR4X2FuZF92ZXJpZnkgPHBvcz4gPGRhdGE+IDxvYmpkaXI+IDxzdHJpbmc+CiBjb3JydXB0X21pZHhfYW5kX3ZlcmlmeSgpIHsKIAlQT1M9JDEgJiYKQEAgLTI4NCw2ICszMTQsMjEgQEAKIAkJImdpdCAtYyBjb3JlLm11bHRpcGFja2luZGV4PXRydWUgZnNjayIKICcKIAordGVzdF9leHBlY3Rfc3VjY2VzcyAncmVwYWNrIHByb2dyZXNzIG9mZiBmb3IgcmVkaXJlY3RlZCBzdGRlcnInICcKKwlnaXQgbXVsdGktcGFjay1pbmRleCAtLW9iamVjdC1kaXI9JG9iamRpciByZXBhY2sgMj5lcnIgJiYKKwl0ZXN0X2xpbmVfY291bnQgPSAwIGVycgorJworCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdyZXBhY2sgZm9yY2UgcHJvZ3Jlc3Mgb24gZm9yIHN0ZGVycicgJworCWdpdCBtdWx0aS1wYWNrLWluZGV4IC0tb2JqZWN0LWRpcj0kb2JqZGlyIC0tcHJvZ3Jlc3MgcmVwYWNrIDI+ZXJyICYmCisJdGVzdF9maWxlX25vdF9lbXB0eSBlcnIKKycKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAncmVwYWNrIHdpdGggdGhlIC0tbm8tcHJvZ3Jlc3Mgb3B0aW9uJyAnCisJZ2l0IG11bHRpLXBhY2staW5kZXggLS1vYmplY3QtZGlyPSRvYmpkaXIgLS1uby1wcm9ncmVzcyByZXBhY2sgMj5lcnIgJiYKKwl0ZXN0X2xpbmVfY291bnQgPSAwIGVycgorJworCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdyZXBhY2sgcmVtb3ZlcyBtdWx0aS1wYWNrLWluZGV4JyAnCiAJdGVzdF9wYXRoX2lzX2ZpbGUgJG9iamRpci9wYWNrL211bHRpLXBhY2staW5kZXggJiYKIAlHSVRfVEVTVF9NVUxUSV9QQUNLX0lOREVYPTAgZ2l0IHJlcGFjayAtYWRmICYmCkBAIC00MTMsNiArNDU4LDMwIEBACiAJKQogJwogCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdleHBpcmUgcHJvZ3Jlc3Mgb2ZmIGZvciByZWRpcmVjdGVkIHN0ZGVycicgJworCSgKKwkJY2QgZHVwICYmCisJCWdpdCBtdWx0aS1wYWNrLWluZGV4IGV4cGlyZSAyPmVyciAmJgorCQl0ZXN0X2xpbmVfY291bnQgPSAwIGVycgorCSkKKycKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAnZXhwaXJlIGZvcmNlIHByb2dyZXNzIG9uIGZvciBzdGRlcnInICcKKwkoCisJCWNkIGR1cCAmJgorCQlnaXQgbXVsdGktcGFjay1pbmRleCAtLXByb2dyZXNzIGV4cGlyZSAyPmVyciAmJgorCQl0ZXN0X2ZpbGVfbm90X2VtcHR5IGVycgorCSkKKycKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAnZXhwaXJlIHdpdGggdGhlIC0tbm8tcHJvZ3Jlc3Mgb3B0aW9uJyAnCisJKAorCQljZCBkdXAgJiYKKwkJZ2l0IG11bHRpLXBhY2staW5kZXggLS1uby1wcm9ncmVzcyBleHBpcmUgMj5lcnIgJiYKKwkJdGVzdF9saW5lX2NvdW50ID0gMCBlcnIKKwkpCisnCisKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2V4cGlyZSByZW1vdmVzIHVucmVmZXJlbmNlZCBwYWNrcycgJwogCSgKIAkJY2QgZHVwICYmCmRpZmYgLS1naXQgYS90L3Q1MzI0LXNwbGl0LWNvbW1pdC1ncmFwaC5zaCBiL3QvdDUzMjQtc3BsaXQtY29tbWl0LWdyYXBoLnNoCmluZGV4IDk5ZjRlZjQuLmMyNDgyMzQgMTAwNzU1Ci0tLSBhL3QvdDUzMjQtc3BsaXQtY29tbWl0LWdyYXBoLnNoCisrKyBiL3QvdDUzMjQtc3BsaXQtY29tbWl0LWdyYXBoLnNoCkBAIC04LDYgKzgsNyBAQAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnc2V0dXAgcmVwbycgJwogCWdpdCBpbml0ICYmCiAJZ2l0IGNvbmZpZyBjb3JlLmNvbW1pdEdyYXBoIHRydWUgJiYKKwlnaXQgY29uZmlnIGdjLndyaXRlQ29tbWl0R3JhcGggZmFsc2UgJiYKIAlpbmZvZGlyPSIuZ2l0L29iamVjdHMvaW5mbyIgJiYKIAlncmFwaGRpcj0iJGluZm9kaXIvY29tbWl0LWdyYXBocyIgJiYKIAl0ZXN0X29pZF9pbml0CkBAIC0yNCw3ICsyNSw3IEBACiAJbnVtX2NvbW1pdHM6ICQxCiAJY2h1bmtzOiBvaWRfZmFub3V0IG9pZF9sb29rdXAgY29tbWl0X21ldGFkYXRhCiAJRU9GCi0JZ2l0IGNvbW1pdC1ncmFwaCByZWFkID5vdXRwdXQgJiYKKwl0ZXN0LXRvb2wgcmVhZC1ncmFwaCA+b3V0cHV0ICYmCiAJdGVzdF9jbXAgZXhwZWN0IG91dHB1dAogfQogCkBAIC0zMTksNyArMzIwLDcgQEAKIAlnaXQgbWVyZ2UgY29tbWl0cy8zIGNvbW1pdHMvNCAmJgogCWdpdCBicmFuY2ggbWVyZ2Uvb2N0b3B1cyAmJgogCWdpdCBjb21taXQtZ3JhcGggd3JpdGUgLS1yZWFjaGFibGUgLS1zcGxpdCAmJgotCWdpdCBjb21taXQtZ3JhcGggdmVyaWZ5IDI+ZXJyICYmCisJZ2l0IGNvbW1pdC1ncmFwaCB2ZXJpZnkgLS1wcm9ncmVzcyAyPmVyciAmJgogCXRlc3RfbGluZV9jb3VudCA9IDMgZXJyICYmCiAJdGVzdF9pMThuZ3JlcCAhIHdhcm5pbmcgZXJyICYmCiAJdGVzdF9saW5lX2NvdW50ID0gMyAkZ3JhcGhkaXIvY29tbWl0LWdyYXBoLWNoYWluCkBAIC0zMzQsNiArMzM1LDcgQEAKIAlnaXQgY2xvbmUgLS1uby1oYXJkbGlua3MgLiBhbHQtc3BsaXQgJiYKIAkoCiAJCWNkIGFsdC1zcGxpdCAmJgorCQlybSAtZiAuZ2l0L29iamVjdHMvaW5mby9jb21taXQtZ3JhcGggJiYKIAkJZWNobyAiJChwd2QpIi8uLi8uZ2l0L29iamVjdHMgPi5naXQvb2JqZWN0cy9pbmZvL2FsdGVybmF0ZXMgJiYKIAkJdGVzdF9jb21taXQgMTggJiYKIAkJZ2l0IGNvbW1pdC1ncmFwaCB3cml0ZSAtLXJlYWNoYWJsZSAtLXNwbGl0ICYmCmRpZmYgLS1naXQgYS90L3Q1NTAwLWZldGNoLXBhY2suc2ggYi90L3Q1NTAwLWZldGNoLXBhY2suc2gKaW5kZXggMWM3MWMwZS4uNmI5NzkyMyAxMDA3NTUKLS0tIGEvdC90NTUwMC1mZXRjaC1wYWNrLnNoCisrKyBiL3QvdDU1MDAtZmV0Y2gtcGFjay5zaApAQCAtNzA4LDEzICs3MDgsMjIgQEAKIAkjIGZpbGUgd2l0aCBzY2hlbWUKIAlmb3IgcCBpbiBmaWxlCiAJZG8KLQkJdGVzdF9leHBlY3Rfc3VjY2VzcyAiZmV0Y2gtcGFjayAtLWRpYWctdXJsICRwOi8vJGgvJHIiICcKKwkJdGVzdF9leHBlY3Rfc3VjY2VzcyAhTUlOR1cgImZldGNoLXBhY2sgLS1kaWFnLXVybCAkcDovLyRoLyRyIiAnCiAJCQljaGVja19wcm90X3BhdGggJHA6Ly8kaC8kciAkcCAiLyRyIgogCQknCisJCXRlc3RfZXhwZWN0X3N1Y2Nlc3MgTUlOR1cgImZldGNoLXBhY2sgLS1kaWFnLXVybCAkcDovLyRoLyRyIiAnCisJCQljaGVja19wcm90X3BhdGggJHA6Ly8kaC8kciAkcCAiLy8kaC8kciIKKwkJJworCQl0ZXN0X2V4cGVjdF9zdWNjZXNzIE1JTkdXICJmZXRjaC1wYWNrIC0tZGlhZy11cmwgJHA6Ly8vJHIiICcKKwkJCWNoZWNrX3Byb3RfcGF0aCAkcDovLy8kciAkcCAiLyRyIgorCQknCiAJCSMgTm8gIi9+IiAtPiAifiIgY29udmVyc2lvbiBmb3IgZmlsZQotCQl0ZXN0X2V4cGVjdF9zdWNjZXNzICJmZXRjaC1wYWNrIC0tZGlhZy11cmwgJHA6Ly8kaC9+JHIiICcKKwkJdGVzdF9leHBlY3Rfc3VjY2VzcyAhTUlOR1cgImZldGNoLXBhY2sgLS1kaWFnLXVybCAkcDovLyRoL34kciIgJwogCQkJY2hlY2tfcHJvdF9wYXRoICRwOi8vJGgvfiRyICRwICIvfiRyIgogCQknCisJCXRlc3RfZXhwZWN0X3N1Y2Nlc3MgTUlOR1cgImZldGNoLXBhY2sgLS1kaWFnLXVybCAkcDovLyRoL34kciIgJworCQkJY2hlY2tfcHJvdF9wYXRoICRwOi8vJGgvfiRyICRwICIvLyRoL34kciIKKwkJJwogCWRvbmUKIAkjIGZpbGUgd2l0aG91dCBzY2hlbWUKIAlmb3IgaCBpbiBub2hvc3Qgbm9ob3N0OjEyIFs6OjFdIFs6OjFdOjIzIFsgWzphYQpAQCAtNzgzLDYgKzc5Miw0NCBAQAogCSkKICcKIAorIyBBIGZldyBzdWJ0bGUgdGhpbmdzIGFib3V0IHRoZSByZXF1ZXN0IGluIHRoaXMgdGVzdDoKKyMKKyMgIC0gdGhlIHNlcnZlciBtdXN0IGhhdmUgY29tbWl0LWdyYXBocyBwcmVzZW50IGFuZCBlbmFibGVkCisjCisjICAtIHRoZSBoaXN0b3J5IGlzIHN1Y2ggdGhhdCBvdXIgd2FudC9oYXZlIHNoYXJlIGEgY29tbW9uIGFuY2VzdG9yICgiYmFzZSIKKyMgICAgaGVyZSkKKyMKKyMgIC0gd2Ugc2VuZCBvbmx5IGEgc2luZ2xlIGhhdmUsIHdoaWNoIGlzIGZld2VyIHRoYW4gYSBub3JtYWwgY2xpZW50IHdvdWxkCisjICAgIHNlbmQuIFRoaXMgZW5zdXJlcyB0aGF0IHdlIGRvbid0IHBhcnNlICJiYXNlIiB1cCBmcm9udCB3aXRoCisjICAgIHBhcnNlX29iamVjdCgpLCBidXQgcmF0aGVyIHRyYXZlcnNlIHRvIGl0IGFzIGEgcGFyZW50IHdoaWxlIGRlY2lkaW5nIGlmIHdlCisjICAgIGNhbiBzdG9wIHRoZSAiaGF2ZSIgbmVnb3RpYXRpb24sIGFuZCBjYWxsIHBhcnNlX2NvbW1pdCgpLiBUaGUgZm9ybWVyCisjICAgIHNlZXMgdGhlIGFjdHVhbCBvYmplY3QgZGF0YSBhbmQgc28gYWx3YXlzIGxvYWRzIHRoZSB0aHJlZSBvaWQsIHdoZXJlYXMgdGhlCisjICAgIGxhdHRlciB3aWxsIHRyeSB0byBsb2FkIGl0IGxhemlseS4KKyMKKyMgIC0gd2UgbXVzdCB1c2UgcHJvdG9jb2wgdjIsIGJlY2F1c2UgaXQgaGFuZGxlcyB0aGUgImhhdmUiIG5lZ290aWF0aW9uIGJlZm9yZQorIyAgICBwcm9jZXNzaW5nIHRoZSBzaGFsbG93IGRpcmVjdGl2ZXMKKyMKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3NoYWxsb3cgc2luY2Ugd2l0aCBjb21taXQgZ3JhcGggYW5kIGFscmVhZHktc2VlbiBjb21taXQnICcKKwl0ZXN0X2NyZWF0ZV9yZXBvIHNoYWxsb3ctc2luY2UtZ3JhcGggJiYKKwkoCisJY2Qgc2hhbGxvdy1zaW5jZS1ncmFwaCAmJgorCXRlc3RfY29tbWl0IGJhc2UgJiYKKwl0ZXN0X2NvbW1pdCBtYXN0ZXIgJiYKKwlnaXQgY2hlY2tvdXQgLWIgb3RoZXIgSEVBRF4gJiYKKwl0ZXN0X2NvbW1pdCBvdGhlciAmJgorCWdpdCBjb21taXQtZ3JhcGggd3JpdGUgLS1yZWFjaGFibGUgJiYKKwlnaXQgY29uZmlnIGNvcmUuY29tbWl0R3JhcGggdHJ1ZSAmJgorCisJR0lUX1BST1RPQ09MPXZlcnNpb249MiBnaXQgdXBsb2FkLXBhY2sgLiA8PC1FT0YgPi9kZXYvbnVsbAorCTAwMTJjb21tYW5kPWZldGNoCisJMDAwMTAwMTNkZWVwZW4tc2luY2UgMQorCTAwMzJ3YW50ICQoZ2l0IHJldi1wYXJzZSBvdGhlcikKKwkwMDMyaGF2ZSAkKGdpdCByZXYtcGFyc2UgbWFzdGVyKQorCTAwMDAKKwlFT0YKKwkpCisnCisKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3NoYWxsb3cgY2xvbmUgZXhjbHVkZSB0YWcgdHdvJyAnCiAJdGVzdF9jcmVhdGVfcmVwbyBzaGFsbG93LWV4Y2x1ZGUgJiYKIAkoCkBAIC05MjAsNCArOTY3LDcgQEAKIAlmZXRjaF9maWx0ZXJfYmxvYl9saW1pdF96ZXJvICIkSFRUUERfRE9DVU1FTlRfUk9PVF9QQVRIL3NlcnZlciIgIiRIVFRQRF9VUkwvc21hcnQvc2VydmVyIgogJwogCisjIERPIE5PVCBhZGQgbm9uLWh0dHBkLXNwZWNpZmljIHRlc3RzIGhlcmUsIGJlY2F1c2UgdGhlIGxhc3QgcGFydCBvZiB0aGlzCisjIHRlc3Qgc2NyaXB0IGlzIG9ubHkgZXhlY3V0ZWQgd2hlbiBodHRwZCBpcyBhdmFpbGFibGUgYW5kIGVuYWJsZWQuCisKIHRlc3RfZG9uZQpkaWZmIC0tZ2l0IGEvdC90NTUxMC1mZXRjaC5zaCBiL3QvdDU1MTAtZmV0Y2guc2gKaW5kZXggMTM5ZjcxMC4uNGI2MDI4MiAxMDA3NTUKLS0tIGEvdC90NTUxMC1mZXRjaC5zaAorKysgYi90L3Q1NTEwLWZldGNoLnNoCkBAIC01NzAsNiArNTcwLDM1IEBACiAJKQogJwogCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdmZXRjaC53cml0ZUNvbW1pdEdyYXBoJyAnCisJZ2l0IGNsb25lIHRocmVlIHdyaXRlICYmCisJKAorCQljZCB0aHJlZSAmJgorCQl0ZXN0X2NvbW1pdCBuZXcKKwkpICYmCisJKAorCQljZCB3cml0ZSAmJgorCQlnaXQgLWMgZmV0Y2gud3JpdGVDb21taXRHcmFwaCBmZXRjaCBvcmlnaW4gJiYKKwkJdGVzdF9wYXRoX2lzX2ZpbGUgLmdpdC9vYmplY3RzL2luZm8vY29tbWl0LWdyYXBocy9jb21taXQtZ3JhcGgtY2hhaW4KKwkpCisnCisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2ZldGNoLndyaXRlQ29tbWl0R3JhcGggd2l0aCBzdWJtb2R1bGVzJyAnCisJZ2l0IGNsb25lIGR1cHMgc3VwZXIgJiYKKwkoCisJCWNkIHN1cGVyICYmCisJCWdpdCBzdWJtb2R1bGUgYWRkICJmaWxlOi8vJFRSQVNIX0RJUkVDVE9SWS90aHJlZSIgJiYKKwkJZ2l0IGNvbW1pdCAtbSAiYWRkIHN1Ym1vZHVsZSIKKwkpICYmCisJZ2l0IGNsb25lICJzdXBlciIgc3VwZXItY2xvbmUgJiYKKwkoCisJCWNkIHN1cGVyLWNsb25lICYmCisJCXJtIC1yZiAuZ2l0L29iamVjdHMvaW5mbyAmJgorCQlnaXQgLWMgZmV0Y2gud3JpdGVDb21taXRHcmFwaD10cnVlIGZldGNoIG9yaWdpbiAmJgorCQl0ZXN0X3BhdGhfaXNfZmlsZSAuZ2l0L29iamVjdHMvaW5mby9jb21taXQtZ3JhcGhzL2NvbW1pdC1ncmFwaC1jaGFpbgorCSkKKycKKwogIyBjb25maWd1cmVkIHBydW5lIHRlc3RzCiAKIHNldF9jb25maWdfdHJpc3RhdGUgKCkgewpAQCAtOTAyLDYgKzkzMSwyOSBAQAogCXRlc3RfY21wIGV4cGVjdCBhY3R1YWwKICcKIAordGVzdF9leHBlY3Rfc3VjY2VzcyAnLS1uby1zaG93LWZvcmNlZC11cGRhdGVzJyAnCisJbWtkaXIgZm9yY2VkLXVwZGF0ZXMgJiYKKwkoCisJCWNkIGZvcmNlZC11cGRhdGVzICYmCisJCWdpdCBpbml0ICYmCisJCXRlc3RfY29tbWl0IDEgJiYKKwkJdGVzdF9jb21taXQgMgorCSkgJiYKKwlnaXQgY2xvbmUgZm9yY2VkLXVwZGF0ZXMgZm9yY2VkLXVwZGF0ZS1jbG9uZSAmJgorCWdpdCBjbG9uZSBmb3JjZWQtdXBkYXRlcyBuby1mb3JjZWQtdXBkYXRlLWNsb25lICYmCisJZ2l0IC1DIGZvcmNlZC11cGRhdGVzIHJlc2V0IC0taGFyZCBIRUFEfjEgJiYKKwkoCisJCWNkIGZvcmNlZC11cGRhdGUtY2xvbmUgJiYKKwkJZ2l0IGZldGNoIC0tc2hvdy1mb3JjZWQtdXBkYXRlcyBvcmlnaW4gMj5vdXRwdXQgJiYKKwkJdGVzdF9pMThuZ3JlcCAiKGZvcmNlZCB1cGRhdGUpIiBvdXRwdXQKKwkpICYmCisJKAorCQljZCBuby1mb3JjZWQtdXBkYXRlLWNsb25lICYmCisJCWdpdCBmZXRjaCAtLW5vLXNob3ctZm9yY2VkLXVwZGF0ZXMgb3JpZ2luIDI+b3V0cHV0ICYmCisJCXRlc3RfaTE4bmdyZXAgISAiKGZvcmNlZCB1cGRhdGUpIiBvdXRwdXQKKwkpCisnCisKIHNldHVwX25lZ290aWF0aW9uX3RpcCAoKSB7CiAJU0VSVkVSPSIkMSIKIAlVUkw9IiQyIgpAQCAtOTc4LDI3ICsxMDMwLDcgQEAKIAljaGVja19uZWdvdGlhdGlvbl90aXAKICcKIAotdGVzdF9leHBlY3Rfc3VjY2VzcyAnLS1uby1zaG93LWZvcmNlZC11cGRhdGVzJyAnCi0JbWtkaXIgZm9yY2VkLXVwZGF0ZXMgJiYKLQkoCi0JCWNkIGZvcmNlZC11cGRhdGVzICYmCi0JCWdpdCBpbml0ICYmCi0JCXRlc3RfY29tbWl0IDEgJiYKLQkJdGVzdF9jb21taXQgMgotCSkgJiYKLQlnaXQgY2xvbmUgZm9yY2VkLXVwZGF0ZXMgZm9yY2VkLXVwZGF0ZS1jbG9uZSAmJgotCWdpdCBjbG9uZSBmb3JjZWQtdXBkYXRlcyBuby1mb3JjZWQtdXBkYXRlLWNsb25lICYmCi0JZ2l0IC1DIGZvcmNlZC11cGRhdGVzIHJlc2V0IC0taGFyZCBIRUFEfjEgJiYKLQkoCi0JCWNkIGZvcmNlZC11cGRhdGUtY2xvbmUgJiYKLQkJZ2l0IGZldGNoIC0tc2hvdy1mb3JjZWQtdXBkYXRlcyBvcmlnaW4gMj5vdXRwdXQgJiYKLQkJdGVzdF9pMThuZ3JlcCAiKGZvcmNlZCB1cGRhdGUpIiBvdXRwdXQKLQkpICYmCi0JKAotCQljZCBuby1mb3JjZWQtdXBkYXRlLWNsb25lICYmCi0JCWdpdCBmZXRjaCAtLW5vLXNob3ctZm9yY2VkLXVwZGF0ZXMgb3JpZ2luIDI+b3V0cHV0ICYmCi0JCSEgdGVzdF9pMThuZ3JlcCAiKGZvcmNlZCB1cGRhdGUpIiBvdXRwdXQKLQkpCi0nCisjIERPIE5PVCBhZGQgbm9uLWh0dHBkLXNwZWNpZmljIHRlc3RzIGhlcmUsIGJlY2F1c2UgdGhlIGxhc3QgcGFydCBvZiB0aGlzCisjIHRlc3Qgc2NyaXB0IGlzIG9ubHkgZXhlY3V0ZWQgd2hlbiBodHRwZCBpcyBhdmFpbGFibGUgYW5kIGVuYWJsZWQuCiAKIHRlc3RfZG9uZQpkaWZmIC0tZ2l0IGEvdC90NTUxMi1scy1yZW1vdGUuc2ggYi90L3Q1NTEyLWxzLXJlbW90ZS5zaAppbmRleCA0M2UxZDhkLi5kN2I5ZjkwIDEwMDc1NQotLS0gYS90L3Q1NTEyLWxzLXJlbW90ZS5zaAorKysgYi90L3Q1NTEyLWxzLXJlbW90ZS5zaApAQCAtMjY3LDcgKzI2Nyw3IEBACiAnCiAKIHRlc3RfbGF6eV9wcmVyZXEgR0lUX0RBRU1PTiAnCi0JZ2l0IGVudi0taGVscGVyIC0tdHlwZT1ib29sIC0tZGVmYXVsdD10cnVlIC0tZXhpdC1jb2RlIEdJVF9URVNUX0dJVF9EQUVNT04KKwl0ZXN0X2Jvb2xfZW52IEdJVF9URVNUX0dJVF9EQUVNT04gdHJ1ZQogJwogCiAjIFRoaXMgdGVzdCBzcGF3bnMgYSBkYWVtb24sIHNvIHJ1biBpdCBvbmx5IGlmIHRoZSB1c2VyIHdvdWxkIGJlIE9LIHdpdGgKZGlmZiAtLWdpdCBhL3QvdDU1MTQtZmV0Y2gtbXVsdGlwbGUuc2ggYi90L3Q1NTE0LWZldGNoLW11bHRpcGxlLnNoCmluZGV4IDU0MjZkNGIuLmRlOGUyZjEgMTAwNzU1Ci0tLSBhL3QvdDU1MTQtZmV0Y2gtbXVsdGlwbGUuc2gKKysrIGIvdC90NTUxNC1mZXRjaC1tdWx0aXBsZS5zaApAQCAtMTgzLDQgKzE4MywxNSBAQAogCXRlc3RfY21wIGV4cGVjdCB0ZXN0OC9vdXRwdXQKICcKIAordGVzdF9leHBlY3Rfc3VjY2VzcyAncGFyYWxsZWwnICcKKwlnaXQgcmVtb3RlIGFkZCBvbmUgLi9ib2d1czEgJiYKKwlnaXQgcmVtb3RlIGFkZCB0d28gLi9ib2d1czIgJiYKKworCXRlc3RfbXVzdF9mYWlsIGVudiBHSVRfVFJBQ0U9IiRQV0QvdHJhY2UiIFwKKwkJZ2l0IGZldGNoIC0tam9icz0yIC0tbXVsdGlwbGUgb25lIHR3byAyPmVyciAmJgorCWdyZXAgInByZXBhcmluZyB0byBydW4gdXAgdG8gMiB0YXNrcyIgdHJhY2UgJiYKKwl0ZXN0X2kxOG5ncmVwICJjb3VsZCBub3QgZmV0Y2ggLm9uZS4qMTI4IiBlcnIgJiYKKwl0ZXN0X2kxOG5ncmVwICJjb3VsZCBub3QgZmV0Y2ggLnR3by4qMTI4IiBlcnIKKycKKwogdGVzdF9kb25lCmRpZmYgLS1naXQgYS90L3Q1NTE1LWZldGNoLW1lcmdlLWxvZ2ljLnNoIGIvdC90NTUxNS1mZXRjaC1tZXJnZS1sb2dpYy5zaAppbmRleCBlNTVkODQ3Li45NjFlYjM1IDEwMDc1NQotLS0gYS90L3Q1NTE1LWZldGNoLW1lcmdlLWxvZ2ljLnNoCisrKyBiL3QvdDU1MTUtZmV0Y2gtbWVyZ2UtbG9naWMuc2gKQEAgLTEyLDkgKzEyLDYgQEAKIAogLiAuL3Rlc3QtbGliLnNoCiAKLUxGPScKLScKLQogdGVzdF9leHBlY3Rfc3VjY2VzcyBzZXR1cCAnCiAJR0lUX0FVVEhPUl9EQVRFPSIyMDA2LTA2LTI2IDAwOjAwOjAwICswMDAwIiAmJgogCUdJVF9DT01NSVRURVJfREFURT0iMjAwNi0wNi0yNiAwMDowMDowMCArMDAwMCIgJiYKZGlmZiAtLWdpdCBhL3QvdDU1MTctcHVzaC1taXJyb3Iuc2ggYi90L3Q1NTE3LXB1c2gtbWlycm9yLnNoCmluZGV4IGMwNWE2NjEuLmU0ZWRkNTYgMTAwNzU1Ci0tLSBhL3QvdDU1MTctcHVzaC1taXJyb3Iuc2gKKysrIGIvdC90NTUxNy1wdXNoLW1pcnJvci5zaApAQCAtMjY1LDQgKzI2NSwxNCBAQAogCiAnCiAKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3B1c2ggdG8gbWlycm9yZWQgcmVwb3NpdG9yeSB3aXRoIHJlZnNwZWMgZmFpbHMnICcKKwlta19yZXBvX3BhaXIgJiYKKwkoCisJCWNkIG1hc3RlciAmJgorCQllY2hvIG9uZSA+Zm9vICYmIGdpdCBhZGQgZm9vICYmIGdpdCBjb21taXQgLW0gb25lICYmCisJCWdpdCBjb25maWcgLS1hZGQgcmVtb3RlLnVwLm1pcnJvciB0cnVlICYmCisJCXRlc3RfbXVzdF9mYWlsIGdpdCBwdXNoIHVwIG1hc3RlcgorCSkKKycKKwogdGVzdF9kb25lCmRpZmYgLS1naXQgYS90L3Q1NTIwLXB1bGwuc2ggYi90L3Q1NTIwLXB1bGwuc2gKaW5kZXggY2Y0Y2MzMi4uNjAyZDk5NiAxMDA3NTUKLS0tIGEvdC90NTUyMC1wdWxsLnNoCisrKyBiL3QvdDU1MjAtcHVsbC5zaApAQCAtNSw3ICs1LDcgQEAKIC4gLi90ZXN0LWxpYi5zaAogCiBtb2RpZnkgKCkgewotCXNlZCAtZSAiJDEiIDwiJDIiID4iJDIueCIgJiYKKwlzZWQgLWUgIiQxIiAiJDIiID4iJDIueCIgJiYKIAltdiAiJDIueCIgIiQyIgogfQogCkBAIC0xNSw4ICsxNSwxMCBAQAogCWdpdCBhZGQgbmV3X2ZpbGUgJiYKIAlnaXQgcHVsbCAiJEAiIC4gY29weSAmJgogCXRlc3RfY21wX3JldiBIRUFEXiBjb3B5ICYmCi0JdGVzdCAiJChjYXQgbmV3X2ZpbGUpIiA9IGRpcnR5ICYmCi0JdGVzdCAiJChjYXQgZmlsZSkiID0gIm1vZGlmaWVkIGFnYWluIgorCWVjaG8gZGlydHkgPmV4cGVjdCAmJgorCXRlc3RfY21wIGV4cGVjdCBuZXdfZmlsZSAmJgorCWVjaG8gIm1vZGlmaWVkIGFnYWluIiA+ZXhwZWN0ICYmCisJdGVzdF9jbXAgZXhwZWN0IGZpbGUKIH0KIAogdGVzdF9wdWxsX2F1dG9zdGFzaF9mYWlsICgpIHsKQEAgLTM5LDggKzQxLDggQEAKIAkJY2QgY2xvbmVkICYmCiAJCWdpdCBwdWxsIC4uCiAJKSAmJgotCXRlc3QgLWYgZmlsZSAmJgotCXRlc3QgLWYgY2xvbmVkL2ZpbGUgJiYKKwl0ZXN0X3BhdGhfaXNfZmlsZSBmaWxlICYmCisJdGVzdF9wYXRoX2lzX2ZpbGUgY2xvbmVkL2ZpbGUgJiYKIAl0ZXN0X2NtcCBmaWxlIGNsb25lZC9maWxlCiAnCiAKQEAgLTUwLDggKzUyLDggQEAKIAkJY2QgY2xvbmVkLXVobyAmJgogCQlnaXQgcHVsbCAuLiBtYXN0ZXI6bWFzdGVyCiAJKSAmJgotCXRlc3QgLWYgZmlsZSAmJgotCXRlc3QgLWYgY2xvbmVkLXVoby9maWxlICYmCisJdGVzdF9wYXRoX2lzX2ZpbGUgZmlsZSAmJgorCXRlc3RfcGF0aF9pc19maWxlIGNsb25lZC11aG8vZmlsZSAmJgogCXRlc3RfY21wIGZpbGUgY2xvbmVkLXVoby9maWxlCiAnCiAKQEAgLTk5LDcgKzEwMSw3IEBACiAJKAogCQljZCBjbG9uZWQtb2N0b3B1cyAmJgogCQl0ZXN0X211c3RfZmFpbCBnaXQgcHVsbCAuLiBtYXN0ZXIgbWFzdGVyICYmCi0JCSEgdGVzdCAtZiBmaWxlCisJCXRlc3RfcGF0aF9pc19taXNzaW5nIGZpbGUKIAkpCiAnCiAKQEAgLTExMCw5ICsxMTIsMTEgQEAKIAllY2hvIHVwZGF0ZWQgPmZpbGUgJiYKIAlnaXQgY29tbWl0IC1hIC1tIHVwZGF0ZWQgJiYKIAlnaXQgY2hlY2tvdXQgY29weSAmJgotCXRlc3QgIiQoY2F0IGZpbGUpIiA9IGZpbGUgJiYKKwllY2hvIGZpbGUgPmV4cGVjdCAmJgorCXRlc3RfY21wIGV4cGVjdCBmaWxlICYmCiAJZ2l0IHB1bGwgJiYKLQl0ZXN0ICIkKGNhdCBmaWxlKSIgPSB1cGRhdGVkICYmCisJZWNobyB1cGRhdGVkID5leHBlY3QgJiYKKwl0ZXN0X2NtcCBleHBlY3QgZmlsZSAmJgogCWdpdCByZWZsb2cgLTEgPnJlZmxvZy5hY3R1YWwgJiYKIAlzZWQgInMvXlswLTlhLWZdWzAtOWEtZl0qL09CSklELyIgcmVmbG9nLmFjdHVhbCA+cmVmbG9nLmZ1enp5ICYmCiAJZWNobyAiT0JKSUQgSEVBREB7MH06IHB1bGw6IEZhc3QtZm9yd2FyZCIgPnJlZmxvZy5leHBlY3RlZCAmJgpAQCAtMTI1LDkgKzEyOSwxMSBAQAogCWdpdCBjb21taXQgLWEgLW0gbW9kaWZpZWQgJiYKIAlnaXQgY2hlY2tvdXQgY29weSAmJgogCWdpdCByZXNldCAtLWhhcmQgSEVBRF4gJiYKLQl0ZXN0ICIkKGNhdCBmaWxlKSIgPSBmaWxlICYmCisJZWNobyBmaWxlID5leHBlY3QgJiYKKwl0ZXN0X2NtcCBleHBlY3QgZmlsZSAmJgogCWdpdCBwdWxsIC4gc2Vjb25kICYmCi0JdGVzdCAiJChjYXQgZmlsZSkiID0gbW9kaWZpZWQgJiYKKwllY2hvIG1vZGlmaWVkID5leHBlY3QgJiYKKwl0ZXN0X2NtcCBleHBlY3QgZmlsZSAmJgogCWdpdCByZWZsb2cgLTEgPnJlZmxvZy5hY3R1YWwgJiYKIAlzZWQgInMvXlswLTlhLWZdWzAtOWEtZl0qL09CSklELyIgcmVmbG9nLmFjdHVhbCA+cmVmbG9nLmZ1enp5ICYmCiAJZWNobyAiT0JKSUQgSEVBREB7MH06IHB1bGwgLiBzZWNvbmQ6IEZhc3QtZm9yd2FyZCIgPnJlZmxvZy5leHBlY3RlZCAmJgpAQCAtMTM3LDEwICsxNDMsMTEgQEAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2ZhaWwgaWYgd2lsZGNhcmQgc3BlYyBkb2VzIG5vdCBtYXRjaCBhbnkgcmVmcycgJwogCWdpdCBjaGVja291dCAtYiB0ZXN0IGNvcHleICYmCiAJdGVzdF93aGVuX2ZpbmlzaGVkICJnaXQgY2hlY2tvdXQgLWYgY29weSAmJiBnaXQgYnJhbmNoIC1EIHRlc3QiICYmCi0JdGVzdCAiJChjYXQgZmlsZSkiID0gZmlsZSAmJgorCWVjaG8gZmlsZSA+ZXhwZWN0ICYmCisJdGVzdF9jbXAgZXhwZWN0IGZpbGUgJiYKIAl0ZXN0X211c3RfZmFpbCBnaXQgcHVsbCAuICJyZWZzL25vbmV4aXN0aW5nMS8qOnJlZnMvbm9uZXhpc3RpbmcyLyoiIDI+ZXJyICYmCiAJdGVzdF9pMThuZ3JlcCAibm8gY2FuZGlkYXRlcyBmb3IgbWVyZ2luZyIgZXJyICYmCi0JdGVzdCAiJChjYXQgZmlsZSkiID0gZmlsZQorCXRlc3RfY21wIGV4cGVjdCBmaWxlCiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2ZhaWwgaWYgbm8gYnJhbmNoZXMgc3BlY2lmaWVkIHdpdGggbm9uLWRlZmF1bHQgcmVtb3RlJyAnCkBAIC0xNDgsMTEgKzE1NSwxMiBAQAogCXRlc3Rfd2hlbl9maW5pc2hlZCAiZ2l0IHJlbW90ZSByZW1vdmUgdGVzdF9yZW1vdGUiICYmCiAJZ2l0IGNoZWNrb3V0IC1iIHRlc3QgY29weV4gJiYKIAl0ZXN0X3doZW5fZmluaXNoZWQgImdpdCBjaGVja291dCAtZiBjb3B5ICYmIGdpdCBicmFuY2ggLUQgdGVzdCIgJiYKLQl0ZXN0ICIkKGNhdCBmaWxlKSIgPSBmaWxlICYmCisJZWNobyBmaWxlID5leHBlY3QgJiYKKwl0ZXN0X2NtcCBleHBlY3QgZmlsZSAmJgogCXRlc3RfY29uZmlnIGJyYW5jaC50ZXN0LnJlbW90ZSBvcmlnaW4gJiYKIAl0ZXN0X211c3RfZmFpbCBnaXQgcHVsbCB0ZXN0X3JlbW90ZSAyPmVyciAmJgogCXRlc3RfaTE4bmdyZXAgInNwZWNpZnkgYSBicmFuY2ggb24gdGhlIGNvbW1hbmQgbGluZSIgZXJyICYmCi0JdGVzdCAiJChjYXQgZmlsZSkiID0gZmlsZQorCXRlc3RfY21wIGV4cGVjdCBmaWxlCiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2ZhaWwgaWYgbm90IG9uIGEgYnJhbmNoJyAnCkBAIC0xNjAsMTAgKzE2OCwxMSBAQAogCXRlc3Rfd2hlbl9maW5pc2hlZCAiZ2l0IHJlbW90ZSByZW1vdmUgb3JpZ2luIiAmJgogCWdpdCBjaGVja291dCBIRUFEXiAmJgogCXRlc3Rfd2hlbl9maW5pc2hlZCAiZ2l0IGNoZWNrb3V0IC1mIGNvcHkiICYmCi0JdGVzdCAiJChjYXQgZmlsZSkiID0gZmlsZSAmJgorCWVjaG8gZmlsZSA+ZXhwZWN0ICYmCisJdGVzdF9jbXAgZXhwZWN0IGZpbGUgJiYKIAl0ZXN0X211c3RfZmFpbCBnaXQgcHVsbCAyPmVyciAmJgogCXRlc3RfaTE4bmdyZXAgIm5vdCBjdXJyZW50bHkgb24gYSBicmFuY2giIGVyciAmJgotCXRlc3QgIiQoY2F0IGZpbGUpIiA9IGZpbGUKKwl0ZXN0X2NtcCBleHBlY3QgZmlsZQogJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdmYWlsIGlmIG5vIGNvbmZpZ3VyYXRpb24gZm9yIGN1cnJlbnQgYnJhbmNoJyAnCkBAIC0xNzIsMTAgKzE4MSwxMSBAQAogCWdpdCBjaGVja291dCAtYiB0ZXN0IGNvcHleICYmCiAJdGVzdF93aGVuX2ZpbmlzaGVkICJnaXQgY2hlY2tvdXQgLWYgY29weSAmJiBnaXQgYnJhbmNoIC1EIHRlc3QiICYmCiAJdGVzdF9jb25maWcgYnJhbmNoLnRlc3QucmVtb3RlIHRlc3RfcmVtb3RlICYmCi0JdGVzdCAiJChjYXQgZmlsZSkiID0gZmlsZSAmJgorCWVjaG8gZmlsZSA+ZXhwZWN0ICYmCisJdGVzdF9jbXAgZXhwZWN0IGZpbGUgJiYKIAl0ZXN0X211c3RfZmFpbCBnaXQgcHVsbCAyPmVyciAmJgogCXRlc3RfaTE4bmdyZXAgIm5vIHRyYWNraW5nIGluZm9ybWF0aW9uIiBlcnIgJiYKLQl0ZXN0ICIkKGNhdCBmaWxlKSIgPSBmaWxlCisJdGVzdF9jbXAgZXhwZWN0IGZpbGUKICcKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAncHVsbCAtLWFsbDogZmFpbCBpZiBubyBjb25maWd1cmF0aW9uIGZvciBjdXJyZW50IGJyYW5jaCcgJwpAQCAtMTg0LDEwICsxOTQsMTEgQEAKIAlnaXQgY2hlY2tvdXQgLWIgdGVzdCBjb3B5XiAmJgogCXRlc3Rfd2hlbl9maW5pc2hlZCAiZ2l0IGNoZWNrb3V0IC1mIGNvcHkgJiYgZ2l0IGJyYW5jaCAtRCB0ZXN0IiAmJgogCXRlc3RfY29uZmlnIGJyYW5jaC50ZXN0LnJlbW90ZSB0ZXN0X3JlbW90ZSAmJgotCXRlc3QgIiQoY2F0IGZpbGUpIiA9IGZpbGUgJiYKKwllY2hvIGZpbGUgPmV4cGVjdCAmJgorCXRlc3RfY21wIGV4cGVjdCBmaWxlICYmCiAJdGVzdF9tdXN0X2ZhaWwgZ2l0IHB1bGwgLS1hbGwgMj5lcnIgJiYKIAl0ZXN0X2kxOG5ncmVwICJUaGVyZSBpcyBubyB0cmFja2luZyBpbmZvcm1hdGlvbiIgZXJyICYmCi0JdGVzdCAiJChjYXQgZmlsZSkiID0gZmlsZQorCXRlc3RfY21wIGV4cGVjdCBmaWxlCiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2ZhaWwgaWYgdXBzdHJlYW0gYnJhbmNoIGRvZXMgbm90IGV4aXN0JyAnCkBAIC0xOTUsMjYgKzIwNiwzMSBAQAogCXRlc3Rfd2hlbl9maW5pc2hlZCAiZ2l0IGNoZWNrb3V0IC1mIGNvcHkgJiYgZ2l0IGJyYW5jaCAtRCB0ZXN0IiAmJgogCXRlc3RfY29uZmlnIGJyYW5jaC50ZXN0LnJlbW90ZSAuICYmCiAJdGVzdF9jb25maWcgYnJhbmNoLnRlc3QubWVyZ2UgcmVmcy9oZWFkcy9ub25leGlzdGluZyAmJgotCXRlc3QgIiQoY2F0IGZpbGUpIiA9IGZpbGUgJiYKKwllY2hvIGZpbGUgPmV4cGVjdCAmJgorCXRlc3RfY21wIGV4cGVjdCBmaWxlICYmCiAJdGVzdF9tdXN0X2ZhaWwgZ2l0IHB1bGwgMj5lcnIgJiYKIAl0ZXN0X2kxOG5ncmVwICJubyBzdWNoIHJlZiB3YXMgZmV0Y2hlZCIgZXJyICYmCi0JdGVzdCAiJChjYXQgZmlsZSkiID0gZmlsZQorCXRlc3RfY21wIGV4cGVjdCBmaWxlCiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2ZhaWwgaWYgdGhlIGluZGV4IGhhcyB1bnJlc29sdmVkIGVudHJpZXMnICcKIAlnaXQgY2hlY2tvdXQgLWIgdGhpcmQgc2Vjb25kXiAmJgogCXRlc3Rfd2hlbl9maW5pc2hlZCAiZ2l0IGNoZWNrb3V0IC1mIGNvcHkgJiYgZ2l0IGJyYW5jaCAtRCB0aGlyZCIgJiYKLQl0ZXN0ICIkKGNhdCBmaWxlKSIgPSBmaWxlICYmCisJZWNobyBmaWxlID5leHBlY3QgJiYKKwl0ZXN0X2NtcCBleHBlY3QgZmlsZSAmJgogCXRlc3RfY29tbWl0IG1vZGlmaWVkMiBmaWxlICYmCi0JdGVzdCAteiAiJChnaXQgbHMtZmlsZXMgLXUpIiAmJgorCWdpdCBscy1maWxlcyAtdSA+dW5tZXJnZWQgJiYKKwl0ZXN0X211c3RfYmVfZW1wdHkgdW5tZXJnZWQgJiYKIAl0ZXN0X211c3RfZmFpbCBnaXQgcHVsbCAuIHNlY29uZCAmJgotCXRlc3QgLW4gIiQoZ2l0IGxzLWZpbGVzIC11KSIgJiYKKwlnaXQgbHMtZmlsZXMgLXUgPnVubWVyZ2VkICYmCisJdGVzdF9maWxlX25vdF9lbXB0eSB1bm1lcmdlZCAmJgogCWNwIGZpbGUgZXhwZWN0ZWQgJiYKIAl0ZXN0X211c3RfZmFpbCBnaXQgcHVsbCAuIHNlY29uZCAyPmVyciAmJgogCXRlc3RfaTE4bmdyZXAgIlB1bGxpbmcgaXMgbm90IHBvc3NpYmxlIGJlY2F1c2UgeW91IGhhdmUgdW5tZXJnZWQgZmlsZXMuIiBlcnIgJiYKIAl0ZXN0X2NtcCBleHBlY3RlZCBmaWxlICYmCiAJZ2l0IGFkZCBmaWxlICYmCi0JdGVzdCAteiAiJChnaXQgbHMtZmlsZXMgLXUpIiAmJgorCWdpdCBscy1maWxlcyAtdSA+dW5tZXJnZWQgJiYKKwl0ZXN0X211c3RfYmVfZW1wdHkgdW5tZXJnZWQgJiYKIAl0ZXN0X211c3RfZmFpbCBnaXQgcHVsbCAuIHNlY29uZCAyPmVyciAmJgogCXRlc3RfaTE4bmdyZXAgIllvdSBoYXZlIG5vdCBjb25jbHVkZWQgeW91ciBtZXJnZSIgZXJyICYmCiAJdGVzdF9jbXAgZXhwZWN0ZWQgZmlsZQpAQCAtMjIzLDM2ICsyMzksNDIgQEAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2Zhc3QtZm9yd2FyZHMgd29ya2luZyB0cmVlIGlmIGJyYW5jaCBoZWFkIGlzIHVwZGF0ZWQnICcKIAlnaXQgY2hlY2tvdXQgLWIgdGhpcmQgc2Vjb25kXiAmJgogCXRlc3Rfd2hlbl9maW5pc2hlZCAiZ2l0IGNoZWNrb3V0IC1mIGNvcHkgJiYgZ2l0IGJyYW5jaCAtRCB0aGlyZCIgJiYKLQl0ZXN0ICIkKGNhdCBmaWxlKSIgPSBmaWxlICYmCisJZWNobyBmaWxlID5leHBlY3QgJiYKKwl0ZXN0X2NtcCBleHBlY3QgZmlsZSAmJgogCWdpdCBwdWxsIC4gc2Vjb25kOnRoaXJkIDI+ZXJyICYmCiAJdGVzdF9pMThuZ3JlcCAiZmV0Y2ggdXBkYXRlZCB0aGUgY3VycmVudCBicmFuY2ggaGVhZCIgZXJyICYmCi0JdGVzdCAiJChjYXQgZmlsZSkiID0gbW9kaWZpZWQgJiYKLQl0ZXN0ICIkKGdpdCByZXYtcGFyc2UgdGhpcmQpIiA9ICIkKGdpdCByZXYtcGFyc2Ugc2Vjb25kKSIKKwllY2hvIG1vZGlmaWVkID5leHBlY3QgJiYKKwl0ZXN0X2NtcCBleHBlY3QgZmlsZSAmJgorCXRlc3RfY21wX3JldiB0aGlyZCBzZWNvbmQKICcKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnZmFzdC1mb3J3YXJkIGZhaWxzIHdpdGggY29uZmxpY3Rpbmcgd29yayB0cmVlJyAnCiAJZ2l0IGNoZWNrb3V0IC1iIHRoaXJkIHNlY29uZF4gJiYKIAl0ZXN0X3doZW5fZmluaXNoZWQgImdpdCBjaGVja291dCAtZiBjb3B5ICYmIGdpdCBicmFuY2ggLUQgdGhpcmQiICYmCi0JdGVzdCAiJChjYXQgZmlsZSkiID0gZmlsZSAmJgorCWVjaG8gZmlsZSA+ZXhwZWN0ICYmCisJdGVzdF9jbXAgZXhwZWN0IGZpbGUgJiYKIAllY2hvIGNvbmZsaWN0ID5maWxlICYmCiAJdGVzdF9tdXN0X2ZhaWwgZ2l0IHB1bGwgLiBzZWNvbmQ6dGhpcmQgMj5lcnIgJiYKIAl0ZXN0X2kxOG5ncmVwICJDYW5ub3QgZmFzdC1mb3J3YXJkIHlvdXIgd29ya2luZyB0cmVlIiBlcnIgJiYKLQl0ZXN0ICIkKGNhdCBmaWxlKSIgPSBjb25mbGljdCAmJgotCXRlc3QgIiQoZ2l0IHJldi1wYXJzZSB0aGlyZCkiID0gIiQoZ2l0IHJldi1wYXJzZSBzZWNvbmQpIgorCWVjaG8gY29uZmxpY3QgPmV4cGVjdCAmJgorCXRlc3RfY21wIGV4cGVjdCBmaWxlICYmCisJdGVzdF9jbXBfcmV2IHRoaXJkIHNlY29uZAogJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICctLXJlYmFzZScgJwogCWdpdCBicmFuY2ggdG8tcmViYXNlICYmCi0JZWNobyBtb2RpZmllZCBhZ2FpbiA+IGZpbGUgJiYKKwllY2hvIG1vZGlmaWVkIGFnYWluID5maWxlICYmCiAJZ2l0IGNvbW1pdCAtbSBmaWxlIGZpbGUgJiYKIAlnaXQgY2hlY2tvdXQgdG8tcmViYXNlICYmCi0JZWNobyBuZXcgPiBmaWxlMiAmJgorCWVjaG8gbmV3ID5maWxlMiAmJgogCWdpdCBhZGQgZmlsZTIgJiYKIAlnaXQgY29tbWl0IC1tICJuZXcgZmlsZSIgJiYKIAlnaXQgdGFnIGJlZm9yZS1yZWJhc2UgJiYKIAlnaXQgcHVsbCAtLXJlYmFzZSAuIGNvcHkgJiYKLQl0ZXN0ICIkKGdpdCByZXYtcGFyc2UgSEVBRF4pIiA9ICIkKGdpdCByZXYtcGFyc2UgY29weSkiICYmCi0JdGVzdCBuZXcgPSAiJChnaXQgc2hvdyBIRUFEOmZpbGUyKSIKKwl0ZXN0X2NtcF9yZXYgSEVBRF4gY29weSAmJgorCWVjaG8gbmV3ID5leHBlY3QgJiYKKwlnaXQgc2hvdyBIRUFEOmZpbGUyID5hY3R1YWwgJiYKKwl0ZXN0X2NtcCBleHBlY3QgYWN0dWFsCiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJy0tcmViYXNlIGZhc3QgZm9yd2FyZCcgJwpAQCAtMjYzLDcgKzI4NSw3IEBACiAKIAlnaXQgY2hlY2tvdXQgdG8tcmViYXNlICYmCiAJZ2l0IHB1bGwgLS1yZWJhc2UgLiBmZiAmJgotCXRlc3QgIiQoZ2l0IHJldi1wYXJzZSBIRUFEKSIgPSAiJChnaXQgcmV2LXBhcnNlIGZmKSIgJiYKKwl0ZXN0X2NtcF9yZXYgSEVBRCBmZiAmJgogCiAJIyBUaGUgYWJvdmUgb25seSB2YWxpZGF0ZXMgdGhlIHJlc3VsdC4gIERpZCB3ZSBhY3R1YWxseSBieXBhc3MgcmViYXNlPwogCWdpdCByZWZsb2cgLTEgPnJlZmxvZy5hY3R1YWwgJiYKQEAgLTI4Nyw3ICszMDksNyBAQAogCWdpdCBjaGVja291dCBiZWhpbmQgJiYKIAllY2hvIGRpcnR5ID5maWxlICYmCiAJZ2l0IHB1bGwgLS1yZWJhc2UgLS1hdXRvc3Rhc2ggLiB0by1yZWJhc2UtZmYgJiYKLQl0ZXN0ICIkKGdpdCByZXYtcGFyc2UgSEVBRCkiID0gIiQoZ2l0IHJldi1wYXJzZSB0by1yZWJhc2UtZmYpIgorCXRlc3RfY21wX3JldiBIRUFEIHRvLXJlYmFzZS1mZgogJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICctLXJlYmFzZSB3aXRoIGNvbmZsaWN0cyBzaG93cyBhZHZpY2UnICcKQEAgLTMyNSw5ICszNDcsMTEgQEAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJy0tcmViYXNlIGZhaWxzIHdpdGggbXVsdGlwbGUgYnJhbmNoZXMnICcKIAlnaXQgcmVzZXQgLS1oYXJkIGJlZm9yZS1yZWJhc2UgJiYKIAl0ZXN0X211c3RfZmFpbCBnaXQgcHVsbCAtLXJlYmFzZSAuIGNvcHkgbWFzdGVyIDI+ZXJyICYmCi0JdGVzdCAiJChnaXQgcmV2LXBhcnNlIEhFQUQpIiA9ICIkKGdpdCByZXYtcGFyc2UgYmVmb3JlLXJlYmFzZSkiICYmCisJdGVzdF9jbXBfcmV2IEhFQUQgYmVmb3JlLXJlYmFzZSAmJgogCXRlc3RfaTE4bmdyZXAgIkNhbm5vdCByZWJhc2Ugb250byBtdWx0aXBsZSBicmFuY2hlcyIgZXJyICYmCi0JdGVzdCBtb2RpZmllZCA9ICIkKGdpdCBzaG93IEhFQUQ6ZmlsZSkiCisJZWNobyBtb2RpZmllZCA+ZXhwZWN0ICYmCisJZ2l0IHNob3cgSEVBRDpmaWxlID5hY3R1YWwgJiYKKwl0ZXN0X2NtcCBleHBlY3QgYWN0dWFsCiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3B1bGwgLS1yZWJhc2Ugc3VjY2VlZHMgd2l0aCBkaXJ0eSB3b3JraW5nIGRpcmVjdG9yeSBhbmQgcmViYXNlLmF1dG9zdGFzaCBzZXQnICcKQEAgLTM3Nyw4ICs0MDEsMTAgQEAKIAlnaXQgcmVzZXQgLS1oYXJkIGJlZm9yZS1yZWJhc2UgJiYKIAl0ZXN0X2NvbmZpZyBwdWxsLnJlYmFzZSB0cnVlICYmCiAJZ2l0IHB1bGwgLiBjb3B5ICYmCi0JdGVzdCAiJChnaXQgcmV2LXBhcnNlIEhFQUReKSIgPSAiJChnaXQgcmV2LXBhcnNlIGNvcHkpIiAmJgotCXRlc3QgbmV3ID0gIiQoZ2l0IHNob3cgSEVBRDpmaWxlMikiCisJdGVzdF9jbXBfcmV2IEhFQUReIGNvcHkgJiYKKwllY2hvIG5ldyA+ZXhwZWN0ICYmCisJZ2l0IHNob3cgSEVBRDpmaWxlMiA+YWN0dWFsICYmCisJdGVzdF9jbXAgZXhwZWN0IGFjdHVhbAogJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdwdWxsIC0tYXV0b3N0YXNoICYgcHVsbC5yZWJhc2U9dHJ1ZScgJwpAQCAtMzk1LDggKzQyMSwxMCBAQAogCWdpdCByZXNldCAtLWhhcmQgYmVmb3JlLXJlYmFzZSAmJgogCXRlc3RfY29uZmlnIGJyYW5jaC50by1yZWJhc2UucmViYXNlIHRydWUgJiYKIAlnaXQgcHVsbCAuIGNvcHkgJiYKLQl0ZXN0ICIkKGdpdCByZXYtcGFyc2UgSEVBRF4pIiA9ICIkKGdpdCByZXYtcGFyc2UgY29weSkiICYmCi0JdGVzdCBuZXcgPSAiJChnaXQgc2hvdyBIRUFEOmZpbGUyKSIKKwl0ZXN0X2NtcF9yZXYgSEVBRF4gY29weSAmJgorCWVjaG8gbmV3ID5leHBlY3QgJiYKKwlnaXQgc2hvdyBIRUFEOmZpbGUyID5hY3R1YWwgJiYKKwl0ZXN0X2NtcCBleHBlY3QgYWN0dWFsCiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2JyYW5jaC50by1yZWJhc2UucmViYXNlIHNob3VsZCBvdmVycmlkZSBwdWxsLnJlYmFzZScgJwpAQCAtNDA0LDIzICs0MzIsMjkgQEAKIAl0ZXN0X2NvbmZpZyBwdWxsLnJlYmFzZSB0cnVlICYmCiAJdGVzdF9jb25maWcgYnJhbmNoLnRvLXJlYmFzZS5yZWJhc2UgZmFsc2UgJiYKIAlnaXQgcHVsbCAuIGNvcHkgJiYKLQl0ZXN0ICIkKGdpdCByZXYtcGFyc2UgSEVBRF4pIiAhPSAiJChnaXQgcmV2LXBhcnNlIGNvcHkpIiAmJgotCXRlc3QgbmV3ID0gIiQoZ2l0IHNob3cgSEVBRDpmaWxlMikiCisJdGVzdF9jbXBfcmV2ICEgSEVBRF4gY29weSAmJgorCWVjaG8gbmV3ID5leHBlY3QgJiYKKwlnaXQgc2hvdyBIRUFEOmZpbGUyID5hY3R1YWwgJiYKKwl0ZXN0X2NtcCBleHBlY3QgYWN0dWFsCiAnCiAKLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgInB1bGwgLS1yZWJhc2Ugd2FybnMgb24gLS12ZXJpZnktc2lnbmF0dXJlcyIgJwordGVzdF9leHBlY3Rfc3VjY2VzcyAncHVsbCAtLXJlYmFzZSB3YXJucyBvbiAtLXZlcmlmeS1zaWduYXR1cmVzJyAnCiAJZ2l0IHJlc2V0IC0taGFyZCBiZWZvcmUtcmViYXNlICYmCiAJZ2l0IHB1bGwgLS1yZWJhc2UgLS12ZXJpZnktc2lnbmF0dXJlcyAuIGNvcHkgMj5lcnIgJiYKLQl0ZXN0ICIkKGdpdCByZXYtcGFyc2UgSEVBRF4pIiA9ICIkKGdpdCByZXYtcGFyc2UgY29weSkiICYmCi0JdGVzdCBuZXcgPSAiJChnaXQgc2hvdyBIRUFEOmZpbGUyKSIgJiYKKwl0ZXN0X2NtcF9yZXYgSEVBRF4gY29weSAmJgorCWVjaG8gbmV3ID5leHBlY3QgJiYKKwlnaXQgc2hvdyBIRUFEOmZpbGUyID5hY3R1YWwgJiYKKwl0ZXN0X2NtcCBleHBlY3QgYWN0dWFsICYmCiAJdGVzdF9pMThuZ3JlcCAiaWdub3JpbmcgLS12ZXJpZnktc2lnbmF0dXJlcyBmb3IgcmViYXNlIiBlcnIKICcKIAotdGVzdF9leHBlY3Rfc3VjY2VzcyAicHVsbCAtLXJlYmFzZSBkb2VzIG5vdCB3YXJuIG9uIC0tbm8tdmVyaWZ5LXNpZ25hdHVyZXMiICcKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3B1bGwgLS1yZWJhc2UgZG9lcyBub3Qgd2FybiBvbiAtLW5vLXZlcmlmeS1zaWduYXR1cmVzJyAnCiAJZ2l0IHJlc2V0IC0taGFyZCBiZWZvcmUtcmViYXNlICYmCiAJZ2l0IHB1bGwgLS1yZWJhc2UgLS1uby12ZXJpZnktc2lnbmF0dXJlcyAuIGNvcHkgMj5lcnIgJiYKLQl0ZXN0ICIkKGdpdCByZXYtcGFyc2UgSEVBRF4pIiA9ICIkKGdpdCByZXYtcGFyc2UgY29weSkiICYmCi0JdGVzdCBuZXcgPSAiJChnaXQgc2hvdyBIRUFEOmZpbGUyKSIgJiYKKwl0ZXN0X2NtcF9yZXYgSEVBRF4gY29weSAmJgorCWVjaG8gbmV3ID5leHBlY3QgJiYKKwlnaXQgc2hvdyBIRUFEOmZpbGUyID5hY3R1YWwgJiYKKwl0ZXN0X2NtcCBleHBlY3QgYWN0dWFsICYmCiAJdGVzdF9pMThuZ3JlcCAhICJ2ZXJpZnktc2lnbmF0dXJlcyIgZXJyCiAnCiAKQEAgLTQ0MCwyNSArNDc0LDMxIEBACiAJZ2l0IHJlc2V0IC0taGFyZCBiZWZvcmUtcHJlc2VydmUtcmViYXNlICYmCiAJdGVzdF9jb25maWcgcHVsbC5yZWJhc2UgZmFsc2UgJiYKIAlnaXQgcHVsbCAuIGNvcHkgJiYKLQl0ZXN0ICIkKGdpdCByZXYtcGFyc2UgSEVBRF4xKSIgPSAiJChnaXQgcmV2LXBhcnNlIGJlZm9yZS1wcmVzZXJ2ZS1yZWJhc2UpIiAmJgotCXRlc3QgIiQoZ2l0IHJldi1wYXJzZSBIRUFEXjIpIiA9ICIkKGdpdCByZXYtcGFyc2UgY29weSkiICYmCi0JdGVzdCBmaWxlMyA9ICIkKGdpdCBzaG93IEhFQUQ6ZmlsZTMudCkiCisJdGVzdF9jbXBfcmV2IEhFQUReMSBiZWZvcmUtcHJlc2VydmUtcmViYXNlICYmCisJdGVzdF9jbXBfcmV2IEhFQUReMiBjb3B5ICYmCisJZWNobyBmaWxlMyA+ZXhwZWN0ICYmCisJZ2l0IHNob3cgSEVBRDpmaWxlMy50ID5hY3R1YWwgJiYKKwl0ZXN0X2NtcCBleHBlY3QgYWN0dWFsCiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3B1bGwucmViYXNlPXRydWUgZmxhdHRlbnMga2VlcC1tZXJnZScgJwogCWdpdCByZXNldCAtLWhhcmQgYmVmb3JlLXByZXNlcnZlLXJlYmFzZSAmJgogCXRlc3RfY29uZmlnIHB1bGwucmViYXNlIHRydWUgJiYKIAlnaXQgcHVsbCAuIGNvcHkgJiYKLQl0ZXN0ICIkKGdpdCByZXYtcGFyc2UgSEVBRF5eKSIgPSAiJChnaXQgcmV2LXBhcnNlIGNvcHkpIiAmJgotCXRlc3QgZmlsZTMgPSAiJChnaXQgc2hvdyBIRUFEOmZpbGUzLnQpIgorCXRlc3RfY21wX3JldiBIRUFEXl4gY29weSAmJgorCWVjaG8gZmlsZTMgPmV4cGVjdCAmJgorCWdpdCBzaG93IEhFQUQ6ZmlsZTMudCA+YWN0dWFsICYmCisJdGVzdF9jbXAgZXhwZWN0IGFjdHVhbAogJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdwdWxsLnJlYmFzZT0xIGlzIHRyZWF0ZWQgYXMgdHJ1ZSBhbmQgZmxhdHRlbnMga2VlcC1tZXJnZScgJwogCWdpdCByZXNldCAtLWhhcmQgYmVmb3JlLXByZXNlcnZlLXJlYmFzZSAmJgogCXRlc3RfY29uZmlnIHB1bGwucmViYXNlIDEgJiYKIAlnaXQgcHVsbCAuIGNvcHkgJiYKLQl0ZXN0ICIkKGdpdCByZXYtcGFyc2UgSEVBRF5eKSIgPSAiJChnaXQgcmV2LXBhcnNlIGNvcHkpIiAmJgotCXRlc3QgZmlsZTMgPSAiJChnaXQgc2hvdyBIRUFEOmZpbGUzLnQpIgorCXRlc3RfY21wX3JldiBIRUFEXl4gY29weSAmJgorCWVjaG8gZmlsZTMgPmV4cGVjdCAmJgorCWdpdCBzaG93IEhFQUQ6ZmlsZTMudCA+YWN0dWFsICYmCisJdGVzdF9jbXAgZXhwZWN0IGFjdHVhbAogJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzIFJFQkFTRV9QIFwKQEAgLTQ2Niw4ICs1MDYsOCBAQAogCWdpdCByZXNldCAtLWhhcmQgYmVmb3JlLXByZXNlcnZlLXJlYmFzZSAmJgogCXRlc3RfY29uZmlnIHB1bGwucmViYXNlIHByZXNlcnZlICYmCiAJZ2l0IHB1bGwgLiBjb3B5ICYmCi0JdGVzdCAiJChnaXQgcmV2LXBhcnNlIEhFQUReXikiID0gIiQoZ2l0IHJldi1wYXJzZSBjb3B5KSIgJiYKLQl0ZXN0ICIkKGdpdCByZXYtcGFyc2UgSEVBRF4yKSIgPSAiJChnaXQgcmV2LXBhcnNlIGtlZXAtbWVyZ2UpIgorCXRlc3RfY21wX3JldiBIRUFEXl4gY29weSAmJgorCXRlc3RfY21wX3JldiBIRUFEXjIga2VlcC1tZXJnZQogJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdwdWxsLnJlYmFzZT1pbnRlcmFjdGl2ZScgJwpAQCAtNDc4LDcgKzUxOCw4IEBACiAJdGVzdF9zZXRfZWRpdG9yICIkVFJBU0hfRElSRUNUT1JZL2Zha2UtZWRpdG9yIiAmJgogCXRlc3Rfd2hlbl9maW5pc2hlZCAidGVzdF9taWdodF9mYWlsIGdpdCByZWJhc2UgLS1hYm9ydCIgJiYKIAl0ZXN0X211c3RfZmFpbCBnaXQgcHVsbCAtLXJlYmFzZT1pbnRlcmFjdGl2ZSAuIGNvcHkgJiYKLQl0ZXN0ICJJIHdhcyBoZXJlIiA9ICIkKGNhdCBmYWtlLm91dCkiCisJZWNobyAiSSB3YXMgaGVyZSIgPmV4cGVjdCAmJgorCXRlc3RfY21wIGV4cGVjdCBmYWtlLm91dAogJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdwdWxsIC0tcmViYXNlPWknICcKQEAgLTQ4OSwzMCArNTMwLDM1IEBACiAJdGVzdF9zZXRfZWRpdG9yICIkVFJBU0hfRElSRUNUT1JZL2Zha2UtZWRpdG9yIiAmJgogCXRlc3Rfd2hlbl9maW5pc2hlZCAidGVzdF9taWdodF9mYWlsIGdpdCByZWJhc2UgLS1hYm9ydCIgJiYKIAl0ZXN0X211c3RfZmFpbCBnaXQgcHVsbCAtLXJlYmFzZT1pIC4gY29weSAmJgotCXRlc3QgIkkgd2FzIGhlcmUsIHRvbyIgPSAiJChjYXQgZmFrZS5vdXQpIgorCWVjaG8gIkkgd2FzIGhlcmUsIHRvbyIgPmV4cGVjdCAmJgorCXRlc3RfY21wIGV4cGVjdCBmYWtlLm91dAogJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdwdWxsLnJlYmFzZT1pbnZhbGlkIGZhaWxzJyAnCiAJZ2l0IHJlc2V0IC0taGFyZCBiZWZvcmUtcHJlc2VydmUtcmViYXNlICYmCiAJdGVzdF9jb25maWcgcHVsbC5yZWJhc2UgaW52YWxpZCAmJgotCSEgZ2l0IHB1bGwgLiBjb3B5CisJdGVzdF9tdXN0X2ZhaWwgZ2l0IHB1bGwgLiBjb3B5CiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJy0tcmViYXNlPWZhbHNlIGNyZWF0ZSBhIG5ldyBtZXJnZSBjb21taXQnICcKIAlnaXQgcmVzZXQgLS1oYXJkIGJlZm9yZS1wcmVzZXJ2ZS1yZWJhc2UgJiYKIAl0ZXN0X2NvbmZpZyBwdWxsLnJlYmFzZSB0cnVlICYmCiAJZ2l0IHB1bGwgLS1yZWJhc2U9ZmFsc2UgLiBjb3B5ICYmCi0JdGVzdCAiJChnaXQgcmV2LXBhcnNlIEhFQUReMSkiID0gIiQoZ2l0IHJldi1wYXJzZSBiZWZvcmUtcHJlc2VydmUtcmViYXNlKSIgJiYKLQl0ZXN0ICIkKGdpdCByZXYtcGFyc2UgSEVBRF4yKSIgPSAiJChnaXQgcmV2LXBhcnNlIGNvcHkpIiAmJgotCXRlc3QgZmlsZTMgPSAiJChnaXQgc2hvdyBIRUFEOmZpbGUzLnQpIgorCXRlc3RfY21wX3JldiBIRUFEXjEgYmVmb3JlLXByZXNlcnZlLXJlYmFzZSAmJgorCXRlc3RfY21wX3JldiBIRUFEXjIgY29weSAmJgorCWVjaG8gZmlsZTMgPmV4cGVjdCAmJgorCWdpdCBzaG93IEhFQUQ6ZmlsZTMudCA+YWN0dWFsICYmCisJdGVzdF9jbXAgZXhwZWN0IGFjdHVhbAogJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICctLXJlYmFzZT10cnVlIHJlYmFzZXMgYW5kIGZsYXR0ZW5zIGtlZXAtbWVyZ2UnICcKIAlnaXQgcmVzZXQgLS1oYXJkIGJlZm9yZS1wcmVzZXJ2ZS1yZWJhc2UgJiYKIAl0ZXN0X2NvbmZpZyBwdWxsLnJlYmFzZSBwcmVzZXJ2ZSAmJgogCWdpdCBwdWxsIC0tcmViYXNlPXRydWUgLiBjb3B5ICYmCi0JdGVzdCAiJChnaXQgcmV2LXBhcnNlIEhFQUReXikiID0gIiQoZ2l0IHJldi1wYXJzZSBjb3B5KSIgJiYKLQl0ZXN0IGZpbGUzID0gIiQoZ2l0IHNob3cgSEVBRDpmaWxlMy50KSIKKwl0ZXN0X2NtcF9yZXYgSEVBRF5eIGNvcHkgJiYKKwllY2hvIGZpbGUzID5leHBlY3QgJiYKKwlnaXQgc2hvdyBIRUFEOmZpbGUzLnQgPmFjdHVhbCAmJgorCXRlc3RfY21wIGV4cGVjdCBhY3R1YWwKICcKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyBSRUJBU0VfUCBcCkBAIC01MjAsNTggKzU2Niw2MiBAQAogCWdpdCByZXNldCAtLWhhcmQgYmVmb3JlLXByZXNlcnZlLXJlYmFzZSAmJgogCXRlc3RfY29uZmlnIHB1bGwucmViYXNlIHRydWUgJiYKIAlnaXQgcHVsbCAtLXJlYmFzZT1wcmVzZXJ2ZSAuIGNvcHkgJiYKLQl0ZXN0ICIkKGdpdCByZXYtcGFyc2UgSEVBRF5eKSIgPSAiJChnaXQgcmV2LXBhcnNlIGNvcHkpIiAmJgotCXRlc3QgIiQoZ2l0IHJldi1wYXJzZSBIRUFEXjIpIiA9ICIkKGdpdCByZXYtcGFyc2Uga2VlcC1tZXJnZSkiCisJdGVzdF9jbXBfcmV2IEhFQUReXiBjb3B5ICYmCisJdGVzdF9jbXBfcmV2IEhFQUReMiBrZWVwLW1lcmdlCiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJy0tcmViYXNlPWludmFsaWQgZmFpbHMnICcKIAlnaXQgcmVzZXQgLS1oYXJkIGJlZm9yZS1wcmVzZXJ2ZS1yZWJhc2UgJiYKLQkhIGdpdCBwdWxsIC0tcmViYXNlPWludmFsaWQgLiBjb3B5CisJdGVzdF9tdXN0X2ZhaWwgZ2l0IHB1bGwgLS1yZWJhc2U9aW52YWxpZCAuIGNvcHkKICcKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnLS1yZWJhc2Ugb3ZlcnJpZGVzIHB1bGwucmViYXNlPXByZXNlcnZlIGFuZCBmbGF0dGVucyBrZWVwLW1lcmdlJyAnCiAJZ2l0IHJlc2V0IC0taGFyZCBiZWZvcmUtcHJlc2VydmUtcmViYXNlICYmCiAJdGVzdF9jb25maWcgcHVsbC5yZWJhc2UgcHJlc2VydmUgJiYKIAlnaXQgcHVsbCAtLXJlYmFzZSAuIGNvcHkgJiYKLQl0ZXN0ICIkKGdpdCByZXYtcGFyc2UgSEVBRF5eKSIgPSAiJChnaXQgcmV2LXBhcnNlIGNvcHkpIiAmJgotCXRlc3QgZmlsZTMgPSAiJChnaXQgc2hvdyBIRUFEOmZpbGUzLnQpIgorCXRlc3RfY21wX3JldiBIRUFEXl4gY29weSAmJgorCWVjaG8gZmlsZTMgPmV4cGVjdCAmJgorCWdpdCBzaG93IEhFQUQ6ZmlsZTMudCA+YWN0dWFsICYmCisJdGVzdF9jbXAgZXhwZWN0IGFjdHVhbAogJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICctLXJlYmFzZSB3aXRoIHJlYmFzZWQgdXBzdHJlYW0nICcKLQogCWdpdCByZW1vdGUgYWRkIC1mIG1lIC4gJiYKIAlnaXQgY2hlY2tvdXQgY29weSAmJgogCWdpdCB0YWcgY29weS1vcmlnICYmCiAJZ2l0IHJlc2V0IC0taGFyZCBIRUFEXiAmJgotCWVjaG8gY29uZmxpY3RpbmcgbW9kaWZpY2F0aW9uID4gZmlsZSAmJgorCWVjaG8gY29uZmxpY3RpbmcgbW9kaWZpY2F0aW9uID5maWxlICYmCiAJZ2l0IGNvbW1pdCAtbSBjb25mbGljdCBmaWxlICYmCiAJZ2l0IGNoZWNrb3V0IHRvLXJlYmFzZSAmJgotCWVjaG8gZmlsZSA+IGZpbGUyICYmCisJZWNobyBmaWxlID5maWxlMiAmJgogCWdpdCBjb21taXQgLW0gdG8tcmViYXNlIGZpbGUyICYmCiAJZ2l0IHRhZyB0by1yZWJhc2Utb3JpZyAmJgogCWdpdCBwdWxsIC0tcmViYXNlIG1lIGNvcHkgJiYKLQl0ZXN0ICJjb25mbGljdGluZyBtb2RpZmljYXRpb24iID0gIiQoY2F0IGZpbGUpIiAmJgotCXRlc3QgZmlsZSA9ICIkKGNhdCBmaWxlMikiCi0KKwllY2hvICJjb25mbGljdGluZyBtb2RpZmljYXRpb24iID5leHBlY3QgJiYKKwl0ZXN0X2NtcCBleHBlY3QgZmlsZSAmJgorCWVjaG8gZmlsZSA+ZXhwZWN0ICYmCisJdGVzdF9jbXAgZXhwZWN0IGZpbGUyCiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJy0tcmViYXNlIC1mIHdpdGggcmViYXNlZCB1cHN0cmVhbScgJwogCXRlc3Rfd2hlbl9maW5pc2hlZCAidGVzdF9taWdodF9mYWlsIGdpdCByZWJhc2UgLS1hYm9ydCIgJiYKIAlnaXQgcmVzZXQgLS1oYXJkIHRvLXJlYmFzZS1vcmlnICYmCiAJZ2l0IHB1bGwgLS1yZWJhc2UgLWYgbWUgY29weSAmJgotCXRlc3QgImNvbmZsaWN0aW5nIG1vZGlmaWNhdGlvbiIgPSAiJChjYXQgZmlsZSkiICYmCi0JdGVzdCBmaWxlID0gIiQoY2F0IGZpbGUyKSIKKwllY2hvICJjb25mbGljdGluZyBtb2RpZmljYXRpb24iID5leHBlY3QgJiYKKwl0ZXN0X2NtcCBleHBlY3QgZmlsZSAmJgorCWVjaG8gZmlsZSA+ZXhwZWN0ICYmCisJdGVzdF9jbXAgZXhwZWN0IGZpbGUyCiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJy0tcmViYXNlIHdpdGggcmViYXNlZCBkZWZhdWx0IHVwc3RyZWFtJyAnCi0KIAlnaXQgdXBkYXRlLXJlZiByZWZzL3JlbW90ZXMvbWUvY29weSBjb3B5LW9yaWcgJiYKIAlnaXQgY2hlY2tvdXQgLS10cmFjayAtYiB0by1yZWJhc2UyIG1lL2NvcHkgJiYKIAlnaXQgcmVzZXQgLS1oYXJkIHRvLXJlYmFzZS1vcmlnICYmCiAJZ2l0IHB1bGwgLS1yZWJhc2UgJiYKLQl0ZXN0ICJjb25mbGljdGluZyBtb2RpZmljYXRpb24iID0gIiQoY2F0IGZpbGUpIiAmJgotCXRlc3QgZmlsZSA9ICIkKGNhdCBmaWxlMikiCi0KKwllY2hvICJjb25mbGljdGluZyBtb2RpZmljYXRpb24iID5leHBlY3QgJiYKKwl0ZXN0X2NtcCBleHBlY3QgZmlsZSAmJgorCWVjaG8gZmlsZSA+ZXhwZWN0ICYmCisJdGVzdF9jbXAgZXhwZWN0IGZpbGUyCiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3JlYmFzZWQgdXBzdHJlYW0gKyBmZXRjaCArIHB1bGwgLS1yZWJhc2UnICcKQEAgLTU4MiwxMyArNjMyLDE0IEBACiAJZ2l0IHJlc2V0IC0taGFyZCB0by1yZWJhc2Utb3JpZyAmJgogCWdpdCBmZXRjaCAmJgogCWdpdCBwdWxsIC0tcmViYXNlICYmCi0JdGVzdCAiY29uZmxpY3RpbmcgbW9kaWZpY2F0aW9uIiA9ICIkKGNhdCBmaWxlKSIgJiYKLQl0ZXN0IGZpbGUgPSAiJChjYXQgZmlsZTIpIgorCWVjaG8gImNvbmZsaWN0aW5nIG1vZGlmaWNhdGlvbiIgPmV4cGVjdCAmJgorCXRlc3RfY21wIGV4cGVjdCBmaWxlICYmCisJZWNobyBmaWxlID5leHBlY3QgJiYKKwl0ZXN0X2NtcCBleHBlY3QgZmlsZTIKIAogJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdwdWxsIC0tcmViYXNlIGRpZXMgZWFybHkgd2l0aCBkaXJ0eSB3b3JraW5nIGRpcmVjdG9yeScgJwotCiAJZ2l0IGNoZWNrb3V0IHRvLXJlYmFzZSAmJgogCWdpdCB1cGRhdGUtcmVmIHJlZnMvcmVtb3Rlcy9tZS9jb3B5IGNvcHleICYmCiAJQ09QWT0iJChnaXQgcmV2LXBhcnNlIC0tdmVyaWZ5IG1lL2NvcHkpIiAmJgpAQCAtNTk2LDIzICs2NDcsMjMgQEAKIAl0ZXN0X2NvbmZpZyBicmFuY2gudG8tcmViYXNlLnJlbW90ZSBtZSAmJgogCXRlc3RfY29uZmlnIGJyYW5jaC50by1yZWJhc2UubWVyZ2UgcmVmcy9oZWFkcy9jb3B5ICYmCiAJdGVzdF9jb25maWcgYnJhbmNoLnRvLXJlYmFzZS5yZWJhc2UgdHJ1ZSAmJgotCWVjaG8gZGlydHkgPj4gZmlsZSAmJgorCWVjaG8gZGlydHkgPj5maWxlICYmCiAJZ2l0IGFkZCBmaWxlICYmCiAJdGVzdF9tdXN0X2ZhaWwgZ2l0IHB1bGwgJiYKLQl0ZXN0ICIkQ09QWSIgPSAiJChnaXQgcmV2LXBhcnNlIC0tdmVyaWZ5IG1lL2NvcHkpIiAmJgorCXRlc3RfY21wX3JldiAiJENPUFkiIG1lL2NvcHkgJiYKIAlnaXQgY2hlY2tvdXQgSEVBRCAtLSBmaWxlICYmCiAJZ2l0IHB1bGwgJiYKLQl0ZXN0ICIkQ09QWSIgIT0gIiQoZ2l0IHJldi1wYXJzZSAtLXZlcmlmeSBtZS9jb3B5KSIKLQorCXRlc3RfY21wX3JldiAhICIkQ09QWSIgbWUvY29weQogJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdwdWxsIC0tcmViYXNlIHdvcmtzIG9uIGJyYW5jaCB5ZXQgdG8gYmUgYm9ybicgJwogCWdpdCByZXYtcGFyc2UgbWFzdGVyID5leHBlY3QgJiYKIAlta2RpciBlbXB0eV9yZXBvICYmCi0JKGNkIGVtcHR5X3JlcG8gJiYKLQkgZ2l0IGluaXQgJiYKLQkgZ2l0IHB1bGwgLS1yZWJhc2UgLi4gbWFzdGVyICYmCi0JIGdpdCByZXYtcGFyc2UgSEVBRCA+Li4vYWN0dWFsCisJKAorCQljZCBlbXB0eV9yZXBvICYmCisJCWdpdCBpbml0ICYmCisJCWdpdCBwdWxsIC0tcmViYXNlIC4uIG1hc3RlciAmJgorCQlnaXQgcmV2LXBhcnNlIEhFQUQgPi4uL2FjdHVhbAogCSkgJiYKIAl0ZXN0X2NtcCBleHBlY3QgYWN0dWFsCiAnCkBAIC02MjQsMTAgKzY3NSwxNCBAQAogCQljZCBlbXB0eV9yZXBvMiAmJgogCQllY2hvIHN0YWdlZC1maWxlID5zdGFnZWQtZmlsZSAmJgogCQlnaXQgYWRkIHN0YWdlZC1maWxlICYmCi0JCXRlc3QgIiQoZ2l0IGxzLWZpbGVzKSIgPSBzdGFnZWQtZmlsZSAmJgorCQllY2hvIHN0YWdlZC1maWxlID5leHBlY3QgJiYKKwkJZ2l0IGxzLWZpbGVzID5hY3R1YWwgJiYKKwkJdGVzdF9jbXAgZXhwZWN0IGFjdHVhbCAmJgogCQl0ZXN0X211c3RfZmFpbCBnaXQgcHVsbCAtLXJlYmFzZSAuLiBtYXN0ZXIgMj5lcnIgJiYKLQkJdGVzdCAiJChnaXQgbHMtZmlsZXMpIiA9IHN0YWdlZC1maWxlICYmCi0JCXRlc3QgIiQoZ2l0IHNob3cgOnN0YWdlZC1maWxlKSIgPSBzdGFnZWQtZmlsZSAmJgorCQlnaXQgbHMtZmlsZXMgPmFjdHVhbCAmJgorCQl0ZXN0X2NtcCBleHBlY3QgYWN0dWFsICYmCisJCWdpdCBzaG93IDpzdGFnZWQtZmlsZSA+YWN0dWFsICYmCisJCXRlc3RfY21wIGV4cGVjdCBhY3R1YWwgJiYKIAkJdGVzdF9pMThuZ3JlcCAidW5ib3JuIGJyYW5jaCB3aXRoIGNoYW5nZXMgYWRkZWQgdG8gdGhlIGluZGV4IiBlcnIKIAkpCiAnCkBAIC02MzgsNyArNjkzLDggQEAKIAkoCiAJCWNkIGNvcnJ1cHQgJiYKIAkJdGVzdF9jb21taXQgb25lICYmCi0JCW9iaj0kKGdpdCByZXYtcGFyc2UgLS12ZXJpZnkgSEVBRCB8IHNlZCAicyNeLi4jJi8jIikgJiYKKwkJZ2l0IHJldi1wYXJzZSAtLXZlcmlmeSBIRUFEID5oZWFkICYmCisJCW9iaj0kKHNlZCAicyNeLi4jJi8jIiBoZWFkKSAmJgogCQlybSAtZiAuZ2l0L29iamVjdHMvJG9iaiAmJgogCQl0ZXN0X211c3RfZmFpbCBnaXQgcHVsbCAtLXJlYmFzZQogCSkKQEAgLTY0Niw2NiArNzAyLDc3IEBACiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3NldHVwIGZvciBkZXRlY3RpbmcgdXBzdHJlYW1lZCBjaGFuZ2VzJyAnCiAJbWtkaXIgc3JjICYmCi0JKGNkIHNyYyAmJgotCSBnaXQgaW5pdCAmJgotCSBwcmludGYgIjFcbjJcbjNcbjRcbjVcbjZcbjdcbjhcbjlcbjEwXG4iID4gc3R1ZmYgJiYKLQkgZ2l0IGFkZCBzdHVmZiAmJgotCSBnaXQgY29tbWl0IC1tICJJbml0aWFsIHJldmlzaW9uIgorCSgKKwkJY2Qgc3JjICYmCisJCWdpdCBpbml0ICYmCisJCXByaW50ZiAiMVxuMlxuM1xuNFxuNVxuNlxuN1xuOFxuOVxuMTBcbiIgPiBzdHVmZiAmJgorCQlnaXQgYWRkIHN0dWZmICYmCisJCWdpdCBjb21taXQgLW0gIkluaXRpYWwgcmV2aXNpb24iCiAJKSAmJgogCWdpdCBjbG9uZSBzcmMgZHN0ICYmCi0JKGNkIHNyYyAmJgotCSBtb2RpZnkgcy81LzQzLyBzdHVmZiAmJgotCSBnaXQgY29tbWl0IC1hIC1tICI1LT40MyIgJiYKLQkgbW9kaWZ5IHMvNi80Mi8gc3R1ZmYgJiYKLQkgZ2l0IGNvbW1pdCAtYSAtbSAiTWFrZSBpdCBiaWdnZXIiCisJKAorCQljZCBzcmMgJiYKKwkJbW9kaWZ5IHMvNS80My8gc3R1ZmYgJiYKKwkJZ2l0IGNvbW1pdCAtYSAtbSAiNS0+NDMiICYmCisJCW1vZGlmeSBzLzYvNDIvIHN0dWZmICYmCisJCWdpdCBjb21taXQgLWEgLW0gIk1ha2UgaXQgYmlnZ2VyIgogCSkgJiYKLQkoY2QgZHN0ICYmCi0JIG1vZGlmeSBzLzUvNDMvIHN0dWZmICYmCi0JIGdpdCBjb21taXQgLWEgLW0gIkluZGVwZW5kZW50IGRpc2NvdmVyeSBvZiA1LT40MyIKKwkoCisJCWNkIGRzdCAmJgorCQltb2RpZnkgcy81LzQzLyBzdHVmZiAmJgorCQlnaXQgY29tbWl0IC1hIC1tICJJbmRlcGVuZGVudCBkaXNjb3Zlcnkgb2YgNS0+NDMiCiAJKQogJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdnaXQgcHVsbCAtLXJlYmFzZSBkZXRlY3RzIHVwc3RyZWFtZWQgY2hhbmdlcycgJwotCShjZCBkc3QgJiYKLQkgZ2l0IHB1bGwgLS1yZWJhc2UgJiYKLQkgdGVzdCAteiAiJChnaXQgbHMtZmlsZXMgLXUpIgorCSgKKwkJY2QgZHN0ICYmCisJCWdpdCBwdWxsIC0tcmViYXNlICYmCisJCWdpdCBscy1maWxlcyAtdSA+dW50cmFja2VkICYmCisJCXRlc3RfbXVzdF9iZV9lbXB0eSB1bnRyYWNrZWQKIAkpCiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3NldHVwIGZvciBhdm9pZGluZyByZWFwcGx5aW5nIG9sZCBwYXRjaGVzJyAnCi0JKGNkIGRzdCAmJgotCSB0ZXN0X21pZ2h0X2ZhaWwgZ2l0IHJlYmFzZSAtLWFib3J0ICYmCi0JIGdpdCByZXNldCAtLWhhcmQgb3JpZ2luL21hc3RlcgorCSgKKwkJY2QgZHN0ICYmCisJCXRlc3RfbWlnaHRfZmFpbCBnaXQgcmViYXNlIC0tYWJvcnQgJiYKKwkJZ2l0IHJlc2V0IC0taGFyZCBvcmlnaW4vbWFzdGVyCiAJKSAmJgogCWdpdCBjbG9uZSAtLWJhcmUgc3JjIHNyYy1yZXBsYWNlLmdpdCAmJgogCXJtIC1yZiBzcmMgJiYKIAltdiBzcmMtcmVwbGFjZS5naXQgc3JjICYmCi0JKGNkIGRzdCAmJgotCSBtb2RpZnkgcy8yLzIyLyBzdHVmZiAmJgotCSBnaXQgY29tbWl0IC1hIC1tICJDaGFuZ2UgMiIgJiYKLQkgbW9kaWZ5IHMvMy8zMy8gc3R1ZmYgJiYKLQkgZ2l0IGNvbW1pdCAtYSAtbSAiQ2hhbmdlIDMiICYmCi0JIG1vZGlmeSBzLzQvNDQvIHN0dWZmICYmCi0JIGdpdCBjb21taXQgLWEgLW0gIkNoYW5nZSA0IiAmJgotCSBnaXQgcHVzaCAmJgorCSgKKwkJY2QgZHN0ICYmCisJCW1vZGlmeSBzLzIvMjIvIHN0dWZmICYmCisJCWdpdCBjb21taXQgLWEgLW0gIkNoYW5nZSAyIiAmJgorCQltb2RpZnkgcy8zLzMzLyBzdHVmZiAmJgorCQlnaXQgY29tbWl0IC1hIC1tICJDaGFuZ2UgMyIgJiYKKwkJbW9kaWZ5IHMvNC80NC8gc3R1ZmYgJiYKKwkJZ2l0IGNvbW1pdCAtYSAtbSAiQ2hhbmdlIDQiICYmCisJCWdpdCBwdXNoICYmCiAKLQkgbW9kaWZ5IHMvNDQvNTUvIHN0dWZmICYmCi0JIGdpdCBjb21taXQgLS1hbWVuZCAtYSAtbSAiTW9kaWZpZWQgQ2hhbmdlIDQiCisJCW1vZGlmeSBzLzQ0LzU1LyBzdHVmZiAmJgorCQlnaXQgY29tbWl0IC0tYW1lbmQgLWEgLW0gIk1vZGlmaWVkIENoYW5nZSA0IgogCSkKICcKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnZ2l0IHB1bGwgLS1yZWJhc2UgZG9lcyBub3QgcmVhcHBseSBvbGQgcGF0Y2hlcycgJwotCShjZCBkc3QgJiYKLQkgdGVzdF9tdXN0X2ZhaWwgZ2l0IHB1bGwgLS1yZWJhc2UgJiYKLQkgdGVzdCAxID0gJChmaW5kIC5naXQvcmViYXNlLWFwcGx5IC1uYW1lICIwMDAqIiB8IHdjIC1sKQorCSgKKwkJY2QgZHN0ICYmCisJCXRlc3RfbXVzdF9mYWlsIGdpdCBwdWxsIC0tcmViYXNlICYmCisJCWZpbmQgLmdpdC9yZWJhc2UtYXBwbHkgLW5hbWUgIjAwMCoiID5wYXRjaGVzICYmCisJCXRlc3RfbGluZV9jb3VudCA9IDEgcGF0Y2hlcwogCSkKICcKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnZ2l0IHB1bGwgLS1yZWJhc2UgYWdhaW5zdCBsb2NhbCBicmFuY2gnICcKIAlnaXQgY2hlY2tvdXQgLWIgY29weTIgdG8tcmViYXNlLW9yaWcgJiYKIAlnaXQgcHVsbCAtLXJlYmFzZSAuIHRvLXJlYmFzZSAmJgotCXRlc3QgImNvbmZsaWN0aW5nIG1vZGlmaWNhdGlvbiIgPSAiJChjYXQgZmlsZSkiICYmCi0JdGVzdCBmaWxlID0gIiQoY2F0IGZpbGUyKSIKKwllY2hvICJjb25mbGljdGluZyBtb2RpZmljYXRpb24iID5leHBlY3QgJiYKKwl0ZXN0X2NtcCBleHBlY3QgZmlsZSAmJgorCWVjaG8gZmlsZSA+ZXhwZWN0ICYmCisJdGVzdF9jbXAgZXhwZWN0IGZpbGUyCiAnCiAKIHRlc3RfZG9uZQpkaWZmIC0tZ2l0IGEvdC90NTUyOC1wdXNoLWRlZmF1bHQuc2ggYi90L3Q1NTI4LXB1c2gtZGVmYXVsdC5zaAppbmRleCA0NDMwOTU2Li40ZDFlMGMzIDEwMDc1NQotLS0gYS90L3Q1NTI4LXB1c2gtZGVmYXVsdC5zaAorKysgYi90L3Q1NTI4LXB1c2gtZGVmYXVsdC5zaApAQCAtMTYzLDcgKzE2Myw3IEBACiAjIHVwZGF0ZSBwYXJlbnQxJ3MgZm9vICh3aGljaCBpcyBvdXIgdXBzdHJlYW0pCiB0ZXN0X3B1c2hkZWZhdWx0X3dvcmtmbG93IHN1Y2Nlc3MgdXBzdHJlYW0gZm9vCiAKLSMgdXBzcmVhbSBpcyBmb28gd2hpY2ggaXMgbm90IHRoZSBuYW1lIG9mIHRoZSBjdXJyZW50IGJyYW5jaAorIyB1cHN0cmVhbSBpcyBmb28gd2hpY2ggaXMgbm90IHRoZSBuYW1lIG9mIHRoZSBjdXJyZW50IGJyYW5jaAogdGVzdF9wdXNoZGVmYXVsdF93b3JrZmxvdyBmYWlsdXJlIHNpbXBsZSBtYXN0ZXIKIAogIyBtYXN0ZXIgYW5kIGZvbyBhcmUgdXBkYXRlZApkaWZmIC0tZ2l0IGEvdC90NTUzNS1mZXRjaC1wdXNoLXN5bXJlZi5zaCBiL3QvdDU1MzUtZmV0Y2gtcHVzaC1zeW1yZWYuc2gKaW5kZXggOGVkNThkMi4uZThmNmQyMyAxMDA3NTUKLS0tIGEvdC90NTUzNS1mZXRjaC1wdXNoLXN5bXJlZi5zaAorKysgYi90L3Q1NTM1LWZldGNoLXB1c2gtc3ltcmVmLnNoCkBAIC0xLDYgKzEsNiBAQAogIyEvYmluL3NoCiAKLXRlc3RfZGVzY3JpcHRpb249J2F2b2lkaW5nIGNvbmZsaWN0aW5nIHVwZGF0ZSB0aHJ1IHN5bXJlZiBhbGlhc2luZycKK3Rlc3RfZGVzY3JpcHRpb249J2F2b2lkaW5nIGNvbmZsaWN0aW5nIHVwZGF0ZSB0aHJvdWdoIHN5bXJlZiBhbGlhc2luZycKIAogLiAuL3Rlc3QtbGliLnNoCiAKZGlmZiAtLWdpdCBhL3QvdDU1MzctZmV0Y2gtc2hhbGxvdy5zaCBiL3QvdDU1MzctZmV0Y2gtc2hhbGxvdy5zaAppbmRleCA2NmYwYjY0Li45N2E2NzcyIDEwMDc1NQotLS0gYS90L3Q1NTM3LWZldGNoLXNoYWxsb3cuc2gKKysrIGIvdC90NTUzNy1mZXRjaC1zaGFsbG93LnNoCkBAIC0yNTUsNCArMjU1LDcgQEAKIAlnaXQgLUMgY2xpZW50IGZzY2sKICcKIAorIyBETyBOT1QgYWRkIG5vbi1odHRwZC1zcGVjaWZpYyB0ZXN0cyBoZXJlLCBiZWNhdXNlIHRoZSBsYXN0IHBhcnQgb2YgdGhpcworIyB0ZXN0IHNjcmlwdCBpcyBvbmx5IGV4ZWN1dGVkIHdoZW4gaHR0cGQgaXMgYXZhaWxhYmxlIGFuZCBlbmFibGVkLgorCiB0ZXN0X2RvbmUKZGlmZiAtLWdpdCBhL3QvdDU1NDEtaHR0cC1wdXNoLXNtYXJ0LnNoIGIvdC90NTU0MS1odHRwLXB1c2gtc21hcnQuc2gKaW5kZXggYjg2ZGRiNi4uNGM5NzA3OCAxMDA3NTUKLS0tIGEvdC90NTU0MS1odHRwLXB1c2gtc21hcnQuc2gKKysrIGIvdC90NTU0MS1odHRwLXB1c2gtc21hcnQuc2gKQEAgLTE4NCwxMSArMTg0LDEyIEBACiAJdGVzdF9jb25maWcgLUMgIiRkIiBodHRwLnJlY2VpdmVwYWNrIHRydWUgJiYKIAl1cD0iJEhUVFBEX1VSTCIvc21hcnQvYXRvbWljLWJyYW5jaGVzLmdpdCAmJgogCi0JIyBUZWxsICIkdXAiIGFib3V0IHR3byBicmFuY2hlcyBmb3Igbm93CisJIyBUZWxsICIkdXAiIGFib3V0IHRocmVlIGJyYW5jaGVzIGZvciBub3cKIAl0ZXN0X2NvbW1pdCBhdG9taWMxICYmCiAJdGVzdF9jb21taXQgYXRvbWljMiAmJgogCWdpdCBicmFuY2ggY29sbGF0ZXJhbCAmJgotCWdpdCBwdXNoICIkdXAiIG1hc3RlciBjb2xsYXRlcmFsICYmCisJZ2l0IGJyYW5jaCBvdGhlciAmJgorCWdpdCBwdXNoICIkdXAiIG1hc3RlciBjb2xsYXRlcmFsIG90aGVyICYmCiAKIAkjIGNvbGxhdGVyYWwgaXMgYSB2YWxpZCBwdXNoLCBidXQgc2hvdWxkIGJlIGZhaWxlZCBieSBhdG9taWMgcHVzaAogCWdpdCBjaGVja291dCBjb2xsYXRlcmFsICYmCkBAIC0yMjYsNiArMjI3LDQxIEBACiAJZ3JlcCAiXiAhIC4qcmVqZWN0ZWQuKiBjb2xsYXRlcmFsIC0+IGNvbGxhdGVyYWwgLiphdG9taWMgcHVzaCBmYWlsZWQiIG91dHB1dAogJwogCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdwdXNoIC0tYXRvbWljIGZhaWxzIG9uIHNlcnZlci1zaWRlIGVycm9ycycgJworCSMgVXNlIHByZXZpb3VzbHkgc2V0IHVwIHJlcG9zaXRvcnkKKwlkPSRIVFRQRF9ET0NVTUVOVF9ST09UX1BBVEgvYXRvbWljLWJyYW5jaGVzLmdpdCAmJgorCXRlc3RfY29uZmlnIC1DICIkZCIgaHR0cC5yZWNlaXZlcGFjayB0cnVlICYmCisJdXA9IiRIVFRQRF9VUkwiL3NtYXJ0L2F0b21pYy1icmFuY2hlcy5naXQgJiYKKworCSMgYnJlYWsgcmVmIHVwZGF0ZXMgZm9yIG90aGVyIG9uIHRoZSByZW1vdGUgc2l0ZQorCW1rZGlyICIkZC9yZWZzL2hlYWRzL290aGVyLmxvY2siICYmCisKKwkjIGFkZCB0aGUgbmV3IGNvbW1pdCB0byBvdGhlcgorCWdpdCBicmFuY2ggLWYgb3RoZXIgY29sbGF0ZXJhbCAmJgorCisJIyAtLWF0b21pYyBzaG91bGQgY2F1c2UgZW50aXJlIHB1c2ggdG8gYmUgcmVqZWN0ZWQKKwl0ZXN0X211c3RfZmFpbCBnaXQgcHVzaCAtLWF0b21pYyAiJHVwIiBhdG9taWMgb3RoZXIgMj5vdXRwdXQgICYmCisKKwkjIHRoZSBuZXcgYnJhbmNoIHNob3VsZCBub3QgaGF2ZSBiZWVuIGNyZWF0ZWQgdXBzdHJlYW0KKwl0ZXN0X211c3RfZmFpbCBnaXQgLUMgIiRkIiBzaG93LXJlZiAtLXZlcmlmeSByZWZzL2hlYWRzL2F0b21pYyAmJgorCisJIyB1cHN0cmVhbSBzaG91bGQgc3RpbGwgcmVmbGVjdCBhdG9taWMyLCB0aGUgbGFzdCB0aGluZyB3ZSBwdXNoZWQKKwkjIHN1Y2Nlc3NmdWxseQorCWdpdCByZXYtcGFyc2UgYXRvbWljMiA+ZXhwZWN0ZWQgJiYKKwkjIC4uLnRvIG90aGVyLgorCWdpdCAtQyAiJGQiIHJldi1wYXJzZSByZWZzL2hlYWRzL290aGVyID5hY3R1YWwgJiYKKwl0ZXN0X2NtcCBleHBlY3RlZCBhY3R1YWwgJiYKKworCSMgdGhlIG5ldyBicmFuY2ggc2hvdWxkIG5vdCBoYXZlIGJlZW4gY3JlYXRlZCB1cHN0cmVhbQorCXRlc3RfbXVzdF9mYWlsIGdpdCAtQyAiJGQiIHNob3ctcmVmIC0tdmVyaWZ5IHJlZnMvaGVhZHMvYXRvbWljICYmCisKKwkjIHRoZSBmYWlsZWQgcmVmcyBzaG91bGQgYmUgaW5kaWNhdGVkIHRvIHRoZSB1c2VyCisJZ3JlcCAiXiAhIC4qcmVqZWN0ZWQuKiBvdGhlciAtPiBvdGhlciAuKmF0b21pYyB0cmFuc2FjdGlvbiBmYWlsZWQiIG91dHB1dCAmJgorCisJIyB0aGUgY29sbGF0ZXJhbCBmYWlsdXJlIHJlZnMgc2hvdWxkIGJlIGluZGljYXRlZCB0byB0aGUgdXNlcgorCWdyZXAgIl4gISAuKnJlamVjdGVkLiogYXRvbWljIC0+IGF0b21pYyAuKmF0b21pYyB0cmFuc2FjdGlvbiBmYWlsZWQiIG91dHB1dAorJworCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdwdXNoIC0tYWxsIGNhbiBwdXNoIHRvIGVtcHR5IHJlcG8nICcKIAlkPSRIVFRQRF9ET0NVTUVOVF9ST09UX1BBVEgvZW1wdHktYWxsLmdpdCAmJgogCWdpdCBpbml0IC0tYmFyZSAiJGQiICYmCkBAIC0yNjIsNyArMjk4LDcgQEAKIAljZCAiJFJPT1RfUEFUSCIvdGVzdF9yZXBvX2Nsb25lICYmCiAJdGVzdF9jb21taXQgbm9pc3kgJiYKIAl0ZXN0X3Rlcm1pbmFsIGdpdCBwdXNoID5vdXRwdXQgMj4mMSAmJgotCXRlc3RfaTE4bmdyZXAgIldyaXRpbmcgb2JqZWN0cyIgb3V0cHV0CisJdGVzdF9pMThuZ3JlcCAiXldyaXRpbmcgb2JqZWN0cyIgb3V0cHV0CiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgVFRZICdwdXNoIC0tcXVpZXQgc2lsZW5jZXMgc3RhdHVzIGFuZCBwcm9ncmVzcycgJwpAQCAtMjc3LDcgKzMxMyw3IEBACiAJdGVzdF9jb21taXQgbm8tcHJvZ3Jlc3MgJiYKIAl0ZXN0X3Rlcm1pbmFsIGdpdCBwdXNoIC0tbm8tcHJvZ3Jlc3MgPm91dHB1dCAyPiYxICYmCiAJdGVzdF9pMThuZ3JlcCAiXlRvIGh0dHAiIG91dHB1dCAmJgotCXRlc3RfaTE4bmdyZXAgISAiV3JpdGluZyBvYmplY3RzIiBvdXRwdXQKKwl0ZXN0X2kxOG5ncmVwICEgIl5Xcml0aW5nIG9iamVjdHMiIG91dHB1dAogJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdwdXNoIC0tcHJvZ3Jlc3Mgc2hvd3MgcHJvZ3Jlc3MgdG8gbm9uLXR0eScgJwpAQCAtMjg1LDcgKzMyMSw3IEBACiAJdGVzdF9jb21taXQgcHJvZ3Jlc3MgJiYKIAlnaXQgcHVzaCAtLXByb2dyZXNzID5vdXRwdXQgMj4mMSAmJgogCXRlc3RfaTE4bmdyZXAgIl5UbyBodHRwIiBvdXRwdXQgJiYKLQl0ZXN0X2kxOG5ncmVwICJXcml0aW5nIG9iamVjdHMiIG91dHB1dAorCXRlc3RfaTE4bmdyZXAgIl5Xcml0aW5nIG9iamVjdHMiIG91dHB1dAogJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdodHRwIHB1c2ggZ2l2ZXMgc2FuZSBkZWZhdWx0cyB0byByZWZsb2cnICcKZGlmZiAtLWdpdCBhL3QvdDU1NDUtcHVzaC1vcHRpb25zLnNoIGIvdC90NTU0NS1wdXNoLW9wdGlvbnMuc2gKaW5kZXggNmQxZDU5Yy4uMzhlNmY3MyAxMDA3NTUKLS0tIGEvdC90NTU0NS1wdXNoLW9wdGlvbnMuc2gKKysrIGIvdC90NTU0NS1wdXNoLW9wdGlvbnMuc2gKQEAgLTExNSw3ICsxMTUsNyBAQAogCiAJZ2l0IC1DIHBhcmVudCBzdWJtb2R1bGUgYWRkIC4uL3Vwc3RyZWFtIHdvcmtiZW5jaCAmJgogCWdpdCAtQyBwYXJlbnQvd29ya2JlbmNoIHJlbW90ZSBhZGQgdXAgLi4vLi4vdXBzdHJlYW0gJiYKLQlnaXQgLUMgcGFyZW50IGNvbW1pdCAtbSAiYWRkIHN1Ym1vdWxlIiAmJgorCWdpdCAtQyBwYXJlbnQgY29tbWl0IC1tICJhZGQgc3VibW9kdWxlIiAmJgogCiAJdGVzdF9jb21taXQgLUMgcGFyZW50L3dvcmtiZW5jaCB0d28gJiYKIAlnaXQgLUMgcGFyZW50IGFkZCB3b3JrYmVuY2ggJiYKQEAgLTI3OCw0ICsyNzgsNyBAQAogCXRlc3RfY21wIGV4cGVjdCAiJEhUVFBEX0RPQ1VNRU5UX1JPT1RfUEFUSCIvdXBzdHJlYW0uZ2l0L2hvb2tzL3ByZS1yZWNlaXZlLnB1c2hfb3B0aW9ucwogJwogCisjIERPIE5PVCBhZGQgbm9uLWh0dHBkLXNwZWNpZmljIHRlc3RzIGhlcmUsIGJlY2F1c2UgdGhlIGxhc3QgcGFydCBvZiB0aGlzCisjIHRlc3Qgc2NyaXB0IGlzIG9ubHkgZXhlY3V0ZWQgd2hlbiBodHRwZCBpcyBhdmFpbGFibGUgYW5kIGVuYWJsZWQuCisKIHRlc3RfZG9uZQpkaWZmIC0tZ2l0IGEvdC90NTU1Mi1za2lwcGluZy1mZXRjaC1uZWdvdGlhdG9yLnNoIGIvdC90NTU1Mi1za2lwcGluZy1mZXRjaC1uZWdvdGlhdG9yLnNoCmluZGV4IDhhMTRiZTUuLmY3MGNiY2MgMTAwNzU1Ci0tLSBhL3QvdDU1NTItc2tpcHBpbmctZmV0Y2gtbmVnb3RpYXRvci5zaAorKysgYi90L3Q1NTUyLXNraXBwaW5nLWZldGNoLW5lZ290aWF0b3Iuc2gKQEAgLTYwLDI5ICs2MCw2IEBACiAJaGF2ZV9ub3Rfc2VudCBjNiBjNCBjMwogJwogCi10ZXN0X2V4cGVjdF9zdWNjZXNzICd1bmtub3duIGZldGNoLm5lZ290aWF0aW9uQWxnb3JpdGhtIHZhbHVlcyBlcnJvciBvdXQnICcKLQlybSAtcmYgc2VydmVyIGNsaWVudCB0cmFjZSAmJgotCWdpdCBpbml0IHNlcnZlciAmJgotCXRlc3RfY29tbWl0IC1DIHNlcnZlciB0b19mZXRjaCAmJgotCi0JZ2l0IGluaXQgY2xpZW50ICYmCi0JdGVzdF9jb21taXQgLUMgY2xpZW50IG9uX2NsaWVudCAmJgotCWdpdCAtQyBjbGllbnQgY2hlY2tvdXQgb25fY2xpZW50ICYmCi0KLQl0ZXN0X2NvbmZpZyAtQyBjbGllbnQgZmV0Y2gubmVnb3RpYXRpb25BbGdvcml0aG0gaW52YWxpZCAmJgotCXRlc3RfbXVzdF9mYWlsIGdpdCAtQyBjbGllbnQgZmV0Y2ggIiQocHdkKS9zZXJ2ZXIiIDI+ZXJyICYmCi0JdGVzdF9pMThuZ3JlcCAidW5rbm93biBmZXRjaCBuZWdvdGlhdGlvbiBhbGdvcml0aG0iIGVyciAmJgotCi0JIyBFeHBsaWNpdCAiZGVmYXVsdCIgdmFsdWUKLQl0ZXN0X2NvbmZpZyAtQyBjbGllbnQgZmV0Y2gubmVnb3RpYXRpb25BbGdvcml0aG0gZGVmYXVsdCAmJgotCWdpdCAtQyBjbGllbnQgLWMgZmV0Y2gubmVnb3RpYXRpb25BbGdvcml0aG09ZGVmYXVsdCBmZXRjaCAiJChwd2QpL3NlcnZlciIgJiYKLQotCSMgSW1wbGVtZW50YXRpb24gZGV0YWlsOiBJZiB0aGVyZSBpcyBub3RoaW5nIHRvIGZldGNoLCB3ZSB3aWxsIG5vdCBlcnJvciBvdXQKLQl0ZXN0X2NvbmZpZyAtQyBjbGllbnQgZmV0Y2gubmVnb3RpYXRpb25BbGdvcml0aG0gaW52YWxpZCAmJgotCWdpdCAtQyBjbGllbnQgZmV0Y2ggIiQocHdkKS9zZXJ2ZXIiIDI+ZXJyICYmCi0JdGVzdF9pMThuZ3JlcCAhICJ1bmtub3duIGZldGNoIG5lZ290aWF0aW9uIGFsZ29yaXRobSIgZXJyCi0nCi0KIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3doZW4gdHdvIHNraXBzIGNvbGxpZGUsIGZhdm9yIHRoZSBsYXJnZXIgb25lJyAnCiAJcm0gLXJmIHNlcnZlciBjbGllbnQgdHJhY2UgJiYKIAlnaXQgaW5pdCBzZXJ2ZXIgJiYKZGlmZiAtLWdpdCBhL3QvdDU1NTMtc2V0LXVwc3RyZWFtLnNoIGIvdC90NTU1My1zZXQtdXBzdHJlYW0uc2gKbmV3IGZpbGUgbW9kZSAxMDA3NTUKaW5kZXggMDAwMDAwMC4uODE5NzVhZAotLS0gL2Rldi9udWxsCisrKyBiL3QvdDU1NTMtc2V0LXVwc3RyZWFtLnNoCkBAIC0wLDAgKzEsMTc4IEBACisjIS9iaW4vc2gKKwordGVzdF9kZXNjcmlwdGlvbj0nImdpdCBmZXRjaC9wdWxsIC0tc2V0LXVwc3RyZWFtIiBiYXNpYyB0ZXN0cy4nCisuIC4vdGVzdC1saWIuc2gKKworY2hlY2tfY29uZmlnICgpIHsKKwlwcmludGYgIiVzXG4iICIkMiIgIiQzIiA+ImV4cGVjdC4kMSIgJiYKKwl7CisJCWdpdCBjb25maWcgImJyYW5jaC4kMS5yZW1vdGUiICYmIGdpdCBjb25maWcgImJyYW5jaC4kMS5tZXJnZSIKKwl9ID4iYWN0dWFsLiQxIiAmJgorCXRlc3RfY21wICJleHBlY3QuJDEiICJhY3R1YWwuJDEiCit9CisKK2NoZWNrX2NvbmZpZ19taXNzaW5nICgpIHsKKwl0ZXN0X2V4cGVjdF9jb2RlIDEgZ2l0IGNvbmZpZyAiYnJhbmNoLiQxLnJlbW90ZSIgJiYKKwl0ZXN0X2V4cGVjdF9jb2RlIDEgZ2l0IGNvbmZpZyAiYnJhbmNoLiQxLm1lcmdlIgorfQorCitjbGVhcl9jb25maWcgKCkgeworCWZvciBicmFuY2ggaW4gIiRAIjsgZG8KKwkJdGVzdF9taWdodF9mYWlsIGdpdCBjb25maWcgLS11bnNldC1hbGwgImJyYW5jaC4kYnJhbmNoLnJlbW90ZSIKKwkJdGVzdF9taWdodF9mYWlsIGdpdCBjb25maWcgLS11bnNldC1hbGwgImJyYW5jaC4kYnJhbmNoLm1lcmdlIgorCWRvbmUKK30KKworZW5zdXJlX2ZyZXNoX3Vwc3RyZWFtICgpIHsKKwlybSAtcmYgcGFyZW50ICYmIGdpdCBpbml0IC0tYmFyZSBwYXJlbnQKK30KKwordGVzdF9leHBlY3Rfc3VjY2VzcyAnc2V0dXAgYmFyZSBwYXJlbnQgZmV0Y2gnICcKKwllbnN1cmVfZnJlc2hfdXBzdHJlYW0gJiYKKwlnaXQgcmVtb3RlIGFkZCB1cHN0cmVhbSBwYXJlbnQKKycKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAnc2V0dXAgY29tbWl0IG9uIG1hc3RlciBhbmQgb3RoZXIgZmV0Y2gnICcKKwl0ZXN0X2NvbW1pdCBvbmUgJiYKKwlnaXQgcHVzaCB1cHN0cmVhbSBtYXN0ZXIgJiYKKwlnaXQgY2hlY2tvdXQgLWIgb3RoZXIgJiYKKwl0ZXN0X2NvbW1pdCB0d28gJiYKKwlnaXQgcHVzaCB1cHN0cmVhbSBvdGhlcgorJworCisjIHRlc3RzIGZvciBmZXRjaCAtLXNldC11cHN0cmVhbQorCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdmZXRjaCAtLXNldC11cHN0cmVhbSBkb2VzIG5vdCBzZXQgdXBzdHJlYW0gdy9vIGJyYW5jaCcgJworCWNsZWFyX2NvbmZpZyBtYXN0ZXIgb3RoZXIgJiYKKwlnaXQgY2hlY2tvdXQgbWFzdGVyICYmCisJZ2l0IGZldGNoIC0tc2V0LXVwc3RyZWFtIHVwc3RyZWFtICYmCisJY2hlY2tfY29uZmlnX21pc3NpbmcgbWFzdGVyICYmCisJY2hlY2tfY29uZmlnX21pc3Npbmcgb3RoZXIKKycKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAnZmV0Y2ggLS1zZXQtdXBzdHJlYW0gdXBzdHJlYW0gbWFzdGVyIHNldHMgYnJhbmNoIG1hc3RlciBidXQgbm90IG90aGVyJyAnCisJY2xlYXJfY29uZmlnIG1hc3RlciBvdGhlciAmJgorCWdpdCBmZXRjaCAtLXNldC11cHN0cmVhbSB1cHN0cmVhbSBtYXN0ZXIgJiYKKwljaGVja19jb25maWcgbWFzdGVyIHVwc3RyZWFtIHJlZnMvaGVhZHMvbWFzdGVyICYmCisJY2hlY2tfY29uZmlnX21pc3Npbmcgb3RoZXIKKycKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAnZmV0Y2ggLS1zZXQtdXBzdHJlYW0gdXBzdHJlYW0gb3RoZXIgc2V0cyBicmFuY2ggb3RoZXInICcKKwljbGVhcl9jb25maWcgbWFzdGVyIG90aGVyICYmCisJZ2l0IGZldGNoIC0tc2V0LXVwc3RyZWFtIHVwc3RyZWFtIG90aGVyICYmCisJY2hlY2tfY29uZmlnIG1hc3RlciB1cHN0cmVhbSByZWZzL2hlYWRzL290aGVyICYmCisJY2hlY2tfY29uZmlnX21pc3Npbmcgb3RoZXIKKycKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAnZmV0Y2ggLS1zZXQtdXBzdHJlYW0gbWFzdGVyOm90aGVyIGRvZXMgbm90IHNldCB0aGUgYnJhbmNoIG90aGVyMicgJworCWNsZWFyX2NvbmZpZyBvdGhlcjIgJiYKKwlnaXQgZmV0Y2ggLS1zZXQtdXBzdHJlYW0gdXBzdHJlYW0gbWFzdGVyOm90aGVyMiAmJgorCWNoZWNrX2NvbmZpZ19taXNzaW5nIG90aGVyMgorJworCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdmZXRjaCAtLXNldC11cHN0cmVhbSBodHRwOi8vbm9zdWNoZG9tYWluLmV4YW1wbGUuY29tIGZhaWxzIHdpdGggaW52YWxpZCB1cmwnICcKKwkjIG1hc3RlciBleHBsaWNpdGx5IG5vdCBjbGVhcmVkLCB3ZSBjaGVjayB0aGF0IGl0IGlzIG5vdCB0b3VjaGVkIGZyb20gcHJldmlvdXMgdmFsdWUKKwljbGVhcl9jb25maWcgb3RoZXIgb3RoZXIyICYmCisJdGVzdF9tdXN0X2ZhaWwgZ2l0IGZldGNoIC0tc2V0LXVwc3RyZWFtIGh0dHA6Ly9ub3N1Y2hkb21haW4uZXhhbXBsZS5jb20gJiYKKwljaGVja19jb25maWcgbWFzdGVyIHVwc3RyZWFtIHJlZnMvaGVhZHMvb3RoZXIgJiYKKwljaGVja19jb25maWdfbWlzc2luZyBvdGhlciAmJgorCWNoZWNrX2NvbmZpZ19taXNzaW5nIG90aGVyMgorJworCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdmZXRjaCAtLXNldC11cHN0cmVhbSB3aXRoIHZhbGlkIFVSTCBzZXRzIHVwc3RyZWFtIHRvIFVSTCcgJworCWNsZWFyX2NvbmZpZyBvdGhlciBvdGhlcjIgJiYKKwl1cmw9ImZpbGU6Ly8nIiRQV0QiJyIgJiYKKwlnaXQgZmV0Y2ggLS1zZXQtdXBzdHJlYW0gIiR1cmwiICYmCisJY2hlY2tfY29uZmlnIG1hc3RlciAiJHVybCIgSEVBRCAmJgorCWNoZWNrX2NvbmZpZ19taXNzaW5nIG90aGVyICYmCisJY2hlY2tfY29uZmlnX21pc3Npbmcgb3RoZXIyCisnCisKKyMgdGVzdHMgZm9yIHB1bGwgLS1zZXQtdXBzdHJlYW0KKwordGVzdF9leHBlY3Rfc3VjY2VzcyAnc2V0dXAgYmFyZSBwYXJlbnQgcHVsbCcgJworCWdpdCByZW1vdGUgcm0gdXBzdHJlYW0gJiYKKwllbnN1cmVfZnJlc2hfdXBzdHJlYW0gJiYKKwlnaXQgcmVtb3RlIGFkZCB1cHN0cmVhbSBwYXJlbnQKKycKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAnc2V0dXAgY29tbWl0IG9uIG1hc3RlciBhbmQgb3RoZXIgcHVsbCcgJworCXRlc3RfY29tbWl0IHRocmVlICYmCisJZ2l0IHB1c2ggLS10YWdzIHVwc3RyZWFtIG1hc3RlciAmJgorCXRlc3RfY29tbWl0IGZvdXIgJiYKKwlnaXQgcHVzaCB1cHN0cmVhbSBvdGhlcgorJworCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdwdWxsIC0tc2V0LXVwc3RyZWFtIHVwc3RyZWFtIG1hc3RlciBzZXRzIGJyYW5jaCBtYXN0ZXIgYnV0IG5vdCBvdGhlcicgJworCWNsZWFyX2NvbmZpZyBtYXN0ZXIgb3RoZXIgJiYKKwlnaXQgcHVsbCAtLXNldC11cHN0cmVhbSB1cHN0cmVhbSBtYXN0ZXIgJiYKKwljaGVja19jb25maWcgbWFzdGVyIHVwc3RyZWFtIHJlZnMvaGVhZHMvbWFzdGVyICYmCisJY2hlY2tfY29uZmlnX21pc3Npbmcgb3RoZXIKKycKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAncHVsbCAtLXNldC11cHN0cmVhbSBtYXN0ZXI6b3RoZXIyIGRvZXMgbm90IHNldCB0aGUgYnJhbmNoIG90aGVyMicgJworCWNsZWFyX2NvbmZpZyBvdGhlcjIgJiYKKwlnaXQgcHVsbCAtLXNldC11cHN0cmVhbSB1cHN0cmVhbSBtYXN0ZXI6b3RoZXIyICYmCisJY2hlY2tfY29uZmlnX21pc3Npbmcgb3RoZXIyCisnCisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3B1bGwgLS1zZXQtdXBzdHJlYW0gdXBzdHJlYW0gb3RoZXIgc2V0cyBicmFuY2ggbWFzdGVyJyAnCisJY2xlYXJfY29uZmlnIG1hc3RlciBvdGhlciAmJgorCWdpdCBwdWxsIC0tc2V0LXVwc3RyZWFtIHVwc3RyZWFtIG90aGVyICYmCisJY2hlY2tfY29uZmlnIG1hc3RlciB1cHN0cmVhbSByZWZzL2hlYWRzL290aGVyICYmCisJY2hlY2tfY29uZmlnX21pc3Npbmcgb3RoZXIKKycKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAncHVsbCAtLXNldC11cHN0cmVhbSB1cHN0cmVhbSB0YWcgZG9lcyBub3Qgc2V0IHRoZSB0YWcnICcKKwljbGVhcl9jb25maWcgdGhyZWUgJiYKKwlnaXQgcHVsbCAtLXRhZ3MgLS1zZXQtdXBzdHJlYW0gdXBzdHJlYW0gdGhyZWUgJiYKKwljaGVja19jb25maWdfbWlzc2luZyB0aHJlZQorJworCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdwdWxsIC0tc2V0LXVwc3RyZWFtIGh0dHA6Ly9ub3N1Y2hkb21haW4uZXhhbXBsZS5jb20gZmFpbHMgd2l0aCBpbnZhbGlkIHVybCcgJworCSMgbWFzdGVyIGV4cGxpY2l0bHkgbm90IGNsZWFyZWQsIHdlIGNoZWNrIHRoYXQgaXQgaXMgbm90IHRvdWNoZWQgZnJvbSBwcmV2aW91cyB2YWx1ZQorCWNsZWFyX2NvbmZpZyBvdGhlciBvdGhlcjIgdGhyZWUgJiYKKwl0ZXN0X211c3RfZmFpbCBnaXQgcHVsbCAtLXNldC11cHN0cmVhbSBodHRwOi8vbm9zdWNoZG9tYWluLmV4YW1wbGUuY29tICYmCisJY2hlY2tfY29uZmlnIG1hc3RlciB1cHN0cmVhbSByZWZzL2hlYWRzL290aGVyICYmCisJY2hlY2tfY29uZmlnX21pc3Npbmcgb3RoZXIgJiYKKwljaGVja19jb25maWdfbWlzc2luZyBvdGhlcjIgJiYKKwljaGVja19jb25maWdfbWlzc2luZyB0aHJlZQorJworCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdwdWxsIC0tc2V0LXVwc3RyZWFtIHVwc3RyZWFtIEhFQUQgc2V0cyBicmFuY2ggSEVBRCcgJworCWNsZWFyX2NvbmZpZyBtYXN0ZXIgb3RoZXIgJiYKKwlnaXQgcHVsbCAtLXNldC11cHN0cmVhbSB1cHN0cmVhbSBIRUFEICYmCisJY2hlY2tfY29uZmlnIG1hc3RlciB1cHN0cmVhbSBIRUFEICYmCisJZ2l0IGNoZWNrb3V0IG90aGVyICYmCisJZ2l0IHB1bGwgLS1zZXQtdXBzdHJlYW0gdXBzdHJlYW0gSEVBRCAmJgorCWNoZWNrX2NvbmZpZyBvdGhlciB1cHN0cmVhbSBIRUFECisnCisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3B1bGwgLS1zZXQtdXBzdHJlYW0gdXBzdHJlYW0gd2l0aCBtb3JlIHRoYW4gb25lIGJyYW5jaCBkb2VzIG5vdGhpbmcnICcKKwljbGVhcl9jb25maWcgbWFzdGVyIHRocmVlICYmCisJZ2l0IHB1bGwgLS1zZXQtdXBzdHJlYW0gdXBzdHJlYW0gbWFzdGVyIHRocmVlICYmCisJY2hlY2tfY29uZmlnX21pc3NpbmcgbWFzdGVyICYmCisJY2hlY2tfY29uZmlnX21pc3NpbmcgdGhyZWUKKycKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAncHVsbCAtLXNldC11cHN0cmVhbSB3aXRoIHZhbGlkIFVSTCBzZXRzIHVwc3RyZWFtIHRvIFVSTCcgJworCWNsZWFyX2NvbmZpZyBtYXN0ZXIgb3RoZXIgb3RoZXIyICYmCisJZ2l0IGNoZWNrb3V0IG1hc3RlciAmJgorCXVybD0iZmlsZTovLyciJFBXRCInIiAmJgorCWdpdCBwdWxsIC0tc2V0LXVwc3RyZWFtICIkdXJsIiAmJgorCWNoZWNrX2NvbmZpZyBtYXN0ZXIgIiR1cmwiIEhFQUQgJiYKKwljaGVja19jb25maWdfbWlzc2luZyBvdGhlciAmJgorCWNoZWNrX2NvbmZpZ19taXNzaW5nIG90aGVyMgorJworCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdwdWxsIC0tc2V0LXVwc3RyZWFtIHdpdGggdmFsaWQgVVJMIGFuZCBicmFuY2ggc2V0cyBicmFuY2gnICcKKwljbGVhcl9jb25maWcgbWFzdGVyIG90aGVyIG90aGVyMiAmJgorCWdpdCBjaGVja291dCBtYXN0ZXIgJiYKKwl1cmw9ImZpbGU6Ly8nIiRQV0QiJyIgJiYKKwlnaXQgcHVsbCAtLXNldC11cHN0cmVhbSAiJHVybCIgbWFzdGVyICYmCisJY2hlY2tfY29uZmlnIG1hc3RlciAiJHVybCIgcmVmcy9oZWFkcy9tYXN0ZXIgJiYKKwljaGVja19jb25maWdfbWlzc2luZyBvdGhlciAmJgorCWNoZWNrX2NvbmZpZ19taXNzaW5nIG90aGVyMgorJworCit0ZXN0X2RvbmUKZGlmZiAtLWdpdCBhL3QvdDU2MDEtY2xvbmUuc2ggYi90L3Q1NjAxLWNsb25lLnNoCmluZGV4IDM3ZDc2ODAuLmFkOGM0MTEgMTAwNzU1Ci0tLSBhL3QvdDU2MDEtY2xvbmUuc2gKKysrIGIvdC90NTYwMS1jbG9uZS5zaApAQCAtNDM0LDcgKzQzNCw2IEBACiAJZXhwZWN0X3NzaCAiLXYgLVAgMTIzIiBteWhvc3Qgc3JjCiAnCiAKLVNRPSInIgogdGVzdF9leHBlY3Rfc3VjY2VzcyAnc2luZ2xlIHF1b3RlZCBwbGluay5leGUgaW4gR0lUX1NTSF9DT01NQU5EJyAnCiAJY29weV9zc2hfd3JhcHBlcl9hcyAiJFRSQVNIX0RJUkVDVE9SWS9wbGluay5leGUiICYmCiAJR0lUX1NTSF9DT01NQU5EPSIkU1EkVFJBU0hfRElSRUNUT1JZL3BsaW5rLmV4ZSRTUSAtdiIgXApAQCAtNjU0LDcgKzY1Myw4IEBACiAJZ2l0IC1DIGNsaWVudCBmc2NrICYmCiAKIAkjIEVuc3VyZSB0aGF0IHVubmVlZGVkIGJsb2JzIGFyZSBub3QgaW5hZHZlcnRlbnRseSBmZXRjaGVkLgotCXRlc3RfY29uZmlnIC1DIGNsaWVudCBleHRlbnNpb25zLnBhcnRpYWxjbG9uZSAibm90IGEgcmVtb3RlIiAmJgorCXRlc3RfY29uZmlnIC1DIGNsaWVudCByZW1vdGUub3JpZ2luLnByb21pc29yICJmYWxzZSIgJiYKKwlnaXQgLUMgY2xpZW50IGNvbmZpZyAtLXVuc2V0IHJlbW90ZS5vcmlnaW4ucGFydGlhbGNsb25lZmlsdGVyICYmCiAJdGVzdF9tdXN0X2ZhaWwgZ2l0IC1DIGNsaWVudCBjYXQtZmlsZSAtZSAiJEhBU0gxIiAmJgogCiAJIyBCdXQgdGhpcyBibG9iIHdhcyBmZXRjaGVkLCBiZWNhdXNlIGNsb25lIHBlcmZvcm1zIGFuIGluaXRpYWwgY2hlY2tvdXQKQEAgLTczOSw0ICs3MzksNyBAQAogCXBhcnRpYWxfY2xvbmUgIiRIVFRQRF9ET0NVTUVOVF9ST09UX1BBVEgvc2VydmVyIiAiJEhUVFBEX1VSTC9zbWFydC9zZXJ2ZXIiCiAnCiAKKyMgRE8gTk9UIGFkZCBub24taHR0cGQtc3BlY2lmaWMgdGVzdHMgaGVyZSwgYmVjYXVzZSB0aGUgbGFzdCBwYXJ0IG9mIHRoaXMKKyMgdGVzdCBzY3JpcHQgaXMgb25seSBleGVjdXRlZCB3aGVuIGh0dHBkIGlzIGF2YWlsYWJsZSBhbmQgZW5hYmxlZC4KKwogdGVzdF9kb25lCmRpZmYgLS1naXQgYS90L3Q1NjA3LWNsb25lLWJ1bmRsZS5zaCBiL3QvdDU2MDctY2xvbmUtYnVuZGxlLnNoCmluZGV4IDJhMGZiMTUuLmI3YTNmZGYgMTAwNzU1Ci0tLSBhL3QvdDU2MDctY2xvbmUtYnVuZGxlLnNoCisrKyBiL3QvdDU2MDctY2xvbmUtYnVuZGxlLnNoCkBAIC04Myw0ICs4MywxNSBAQAogCXRlc3RfcGF0aF9pc19taXNzaW5nIGZhaWwuYnVuZGxlLmxvY2sKICcKIAordGVzdF9leHBlY3Rfc3VjY2VzcyAnZmV0Y2ggU0hBLTEgZnJvbSBidW5kbGUnICcKKwl0ZXN0X2NyZWF0ZV9yZXBvIGZvbyAmJgorCXRlc3RfY29tbWl0IC1DIGZvbyB4ICYmCisJZ2l0IC1DIGZvbyBidW5kbGUgY3JlYXRlIHRpcC5idW5kbGUgLTEgbWFzdGVyICYmCisJZ2l0IC1DIGZvbyByZXYtcGFyc2UgSEVBRCA+aGFzaCAmJgorCisJIyBFeGVyY2lzZSB0byBlbnN1cmUgdGhhdCBmZXRjaGluZyBhIFNIQS0xIGZyb20gYSBidW5kbGUgd29ya3Mgd2l0aCBubworCSMgZXJyb3JzCisJZ2l0IGZldGNoIC0tbm8tdGFncyBmb28vdGlwLmJ1bmRsZSAiJChjYXQgaGFzaCkiCisnCisKIHRlc3RfZG9uZQpkaWZmIC0tZ2l0IGEvdC90NTYwOC1jbG9uZS0yZ2Iuc2ggYi90L3Q1NjA4LWNsb25lLTJnYi5zaAppbmRleCAyYzZiYzA3Li5lZWUwODQyIDEwMDc1NQotLS0gYS90L3Q1NjA4LWNsb25lLTJnYi5zaAorKysgYi90L3Q1NjA4LWNsb25lLTJnYi5zaApAQCAtMyw3ICszLDcgQEAKIHRlc3RfZGVzY3JpcHRpb249J1Rlc3QgY2xvbmluZyBhIHJlcG9zaXRvcnkgbGFyZ2VyIHRoYW4gMiBnaWdhYnl0ZScKIC4gLi90ZXN0LWxpYi5zaAogCi1pZiB0ZXN0IC16ICIkR0lUX1RFU1RfQ0xPTkVfMkdCIgoraWYgISB0ZXN0X2Jvb2xfZW52IEdJVF9URVNUX0NMT05FXzJHQiBmYWxzZQogdGhlbgogCXNheSAnU2tpcHBpbmcgZXhwZW5zaXZlIDJHQiBjbG9uZSB0ZXN0OyBlbmFibGUgaXQgd2l0aCBHSVRfVEVTVF9DTE9ORV8yR0I9dCcKIGVsc2UKZGlmZiAtLWdpdCBhL3QvdDU2MTYtcGFydGlhbC1jbG9uZS5zaCBiL3QvdDU2MTYtcGFydGlhbC1jbG9uZS5zaAppbmRleCBiOTFlZjU0Li5mZWE1NmNkIDEwMDc1NQotLS0gYS90L3Q1NjE2LXBhcnRpYWwtY2xvbmUuc2gKKysrIGIvdC90NTYxNi1wYXJ0aWFsLWNsb25lLnNoCkBAIC00Miw4ICs0MiwxNiBAQAogCiAJdGVzdF9jbXAgZXhwZWN0XzEub2lkcyBvYnNlcnZlZC5vaWRzICYmCiAJdGVzdCAiJChnaXQgLUMgcGMxIGNvbmZpZyAtLWxvY2FsIGNvcmUucmVwb3NpdG9yeWZvcm1hdHZlcnNpb24pIiA9ICIxIiAmJgotCXRlc3QgIiQoZ2l0IC1DIHBjMSBjb25maWcgLS1sb2NhbCBleHRlbnNpb25zLnBhcnRpYWxjbG9uZSkiID0gIm9yaWdpbiIgJiYKLQl0ZXN0ICIkKGdpdCAtQyBwYzEgY29uZmlnIC0tbG9jYWwgY29yZS5wYXJ0aWFsY2xvbmVmaWx0ZXIpIiA9ICJibG9iOm5vbmUiCisJdGVzdCAiJChnaXQgLUMgcGMxIGNvbmZpZyAtLWxvY2FsIHJlbW90ZS5vcmlnaW4ucHJvbWlzb3IpIiA9ICJ0cnVlIiAmJgorCXRlc3QgIiQoZ2l0IC1DIHBjMSBjb25maWcgLS1sb2NhbCByZW1vdGUub3JpZ2luLnBhcnRpYWxjbG9uZWZpbHRlcikiID0gImJsb2I6bm9uZSIKKycKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAndmVyaWZ5IHRoYXQgLnByb21pc29yIGZpbGUgY29udGFpbnMgcmVmcyBmZXRjaGVkJyAnCisJbHMgcGMxLy5naXQvb2JqZWN0cy9wYWNrL3BhY2stKi5wcm9taXNvciA+cHJvbWlzb3JsaXN0ICYmCisJdGVzdF9saW5lX2NvdW50ID0gMSBwcm9taXNvcmxpc3QgJiYKKwlnaXQgLUMgc3J2LmJhcmUgcmV2LWxpc3QgSEVBRCA+aGVhZGhhc2ggJiYKKwlncmVwICIkKGNhdCBoZWFkaGFzaCkgSEVBRCIgJChjYXQgcHJvbWlzb3JsaXN0KSAmJgorCWdyZXAgIiQoY2F0IGhlYWRoYXNoKSByZWZzL2hlYWRzL21hc3RlciIgJChjYXQgcHJvbWlzb3JsaXN0KQogJwogCiAjIGNoZWNrb3V0IG1hc3RlciB0byBmb3JjZSBkeW5hbWljIG9iamVjdCBmZXRjaCBvZiBibG9icyBhdCBIRUFELgpAQCAtMjA4LDYgKzIxNiwyNSBAQAogCXRlc3RfY21wIHVuaXF1ZV90eXBlcy5leHBlY3RlZCB1bmlxdWVfdHlwZXMub2JzZXJ2ZWQKICcKIAordGVzdF9leHBlY3Rfc3VjY2VzcyAnaW1wbGljaXRseSBjb25zdHJ1Y3QgY29tYmluZTogZmlsdGVyIHdpdGggcmVwZWF0ZWQgZmxhZ3MnICcKKwlHSVRfVFJBQ0U9JChwd2QpL3RyYWNlIGdpdCBjbG9uZSAtLWJhcmUgXAorCQktLWZpbHRlcj1ibG9iOm5vbmUgLS1maWx0ZXI9dHJlZToxIFwKKwkJImZpbGU6Ly8kKHB3ZCkvc3J2LmJhcmUiIHBjMiAmJgorCWdyZXAgInRyYWNlOi4qIGdpdCBwYWNrLW9iamVjdHMgLiotLWZpbHRlcj1jb21iaW5lOmJsb2I6bm9uZSt0cmVlOjEiIFwKKwkJdHJhY2UgJiYKKwlnaXQgLUMgcGMyIHJldi1saXN0IC0tb2JqZWN0cyAtLW1pc3Npbmc9YWxsb3ctYW55IEhFQUQgPm9iamVjdHMgJiYKKworCSMgV2Ugc2hvdWxkIGhhdmUgZ290dGVuIHNvbWUgcm9vdCB0cmVlcy4KKwlncmVwICIgJCIgb2JqZWN0cyAmJgorCSMgU2hvdWxkIG5vdCBoYXZlIGdvdHRlbiBhbnkgbm9uLXJvb3QgdHJlZXMgb3IgYmxvYnMuCisJISBncmVwICIgLiIgb2JqZWN0cyAmJgorCisJeGFyZ3MgLW4gMSBnaXQgLUMgcGMyIGNhdC1maWxlIC10IDxvYmplY3RzID50eXBlcyAmJgorCXNvcnQgLXUgdHlwZXMgPnVuaXF1ZV90eXBlcy5hY3R1YWwgJiYKKwl0ZXN0X3dyaXRlX2xpbmVzIGNvbW1pdCB0cmVlID51bmlxdWVfdHlwZXMuZXhwZWN0ZWQgJiYKKwl0ZXN0X2NtcCB1bmlxdWVfdHlwZXMuZXhwZWN0ZWQgdW5pcXVlX3R5cGVzLmFjdHVhbAorJworCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdwYXJ0aWFsIGNsb25lIGZldGNoZXMgYmxvYnMgcG9pbnRlZCB0byBieSByZWZzIGV2ZW4gaWYgbm9ybWFsbHkgZmlsdGVyZWQgb3V0JyAnCiAJcm0gLXJmIHNyYyBkc3QgJiYKIAlnaXQgaW5pdCBzcmMgJiYKQEAgLTI0MSw2ICsyNjgsMTEyIEBACiAJISBncmVwICI/JChjYXQgYmxvYikiIG1pc3NpbmdfYWZ0ZXIKICcKIAordGVzdF9leHBlY3Rfc3VjY2VzcyAnc2V0dXAgc3JjIHJlcG8gZm9yIHNwYXJzZSBmaWx0ZXInICcKKwlnaXQgaW5pdCBzcGFyc2Utc3JjICYmCisJZ2l0IC1DIHNwYXJzZS1zcmMgY29uZmlnIC0tbG9jYWwgdXBsb2FkcGFjay5hbGxvd2ZpbHRlciAxICYmCisJZ2l0IC1DIHNwYXJzZS1zcmMgY29uZmlnIC0tbG9jYWwgdXBsb2FkcGFjay5hbGxvd2FueXNoYTFpbndhbnQgMSAmJgorCXRlc3RfY29tbWl0IC1DIHNwYXJzZS1zcmMgb25lICYmCisJdGVzdF9jb21taXQgLUMgc3BhcnNlLXNyYyB0d28gJiYKKwllY2hvIC9vbmUudCA+c3BhcnNlLXNyYy9vbmx5LW9uZSAmJgorCWdpdCAtQyBzcGFyc2Utc3JjIGFkZCAuICYmCisJZ2l0IC1DIHNwYXJzZS1zcmMgY29tbWl0IC1tICJhZGQgc3BhcnNlIGNoZWNrb3V0IGZpbGVzIgorJworCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdwYXJ0aWFsIGNsb25lIHdpdGggc3BhcnNlIGZpbHRlciBzdWNjZWVkcycgJworCXJtIC1yZiBkc3QuZ2l0ICYmCisJZ2l0IGNsb25lIC0tbm8tbG9jYWwgLS1iYXJlIFwKKwkJICAtLWZpbHRlcj1zcGFyc2U6b2lkPW1hc3Rlcjpvbmx5LW9uZSBcCisJCSAgc3BhcnNlLXNyYyBkc3QuZ2l0ICYmCisJKAorCQljZCBkc3QuZ2l0ICYmCisJCWdpdCByZXYtbGlzdCAtLW9iamVjdHMgLS1taXNzaW5nPXByaW50IEhFQUQgPm91dCAmJgorCQlncmVwICJeJChnaXQgcmV2LXBhcnNlIEhFQUQ6b25lLnQpIiBvdXQgJiYKKwkJZ3JlcCAiXj8kKGdpdCByZXYtcGFyc2UgSEVBRDp0d28udCkiIG91dAorCSkKKycKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAncGFydGlhbCBjbG9uZSB3aXRoIHVucmVzb2x2YWJsZSBzcGFyc2UgZmlsdGVyIGZhaWxzIGNsZWFubHknICcKKwlybSAtcmYgZHN0LmdpdCAmJgorCXRlc3RfbXVzdF9mYWlsIGdpdCBjbG9uZSAtLW5vLWxvY2FsIC0tYmFyZSBcCisJCQkJIC0tZmlsdGVyPXNwYXJzZTpvaWQ9bWFzdGVyOm5vLXN1Y2gtbmFtZSBcCisJCQkJIHNwYXJzZS1zcmMgZHN0LmdpdCAyPmVyciAmJgorCXRlc3RfaTE4bmdyZXAgInVuYWJsZSB0byBhY2Nlc3Mgc3BhcnNlIGJsb2IgaW4gLm1hc3Rlcjpuby1zdWNoLW5hbWUiIGVyciAmJgorCXRlc3RfbXVzdF9mYWlsIGdpdCBjbG9uZSAtLW5vLWxvY2FsIC0tYmFyZSBcCisJCQkJIC0tZmlsdGVyPXNwYXJzZTpvaWQ9bWFzdGVyIFwKKwkJCQkgc3BhcnNlLXNyYyBkc3QuZ2l0IDI+ZXJyICYmCisJdGVzdF9pMThuZ3JlcCAidW5hYmxlIHRvIHBhcnNlIHNwYXJzZSBmaWx0ZXIgZGF0YSBpbiIgZXJyCisnCisKK3NldHVwX3RyaWFuZ2xlICgpIHsKKwlybSAtcmYgYmlnLWJsb2IudHh0IHNlcnZlciBjbGllbnQgcHJvbWlzb3ItcmVtb3RlICYmCisKKwlwcmludGYgImxpbmUgJWRcbiIgJCh0ZXN0X3NlcSAxIDEwMCkgPmJpZy1ibG9iLnR4dCAmJgorCisJIyBDcmVhdGUgYSBzZXJ2ZXIgd2l0aCAyIGNvbW1pdHM6IGEgY29tbWl0IHdpdGggYSBiaWcgYmxvYiBhbmQgYSBjaGlsZAorCSMgY29tbWl0IHdpdGggYW4gaW5jcmVtZW50YWwgY2hhbmdlLiBBbHNvLCBjcmVhdGUgYSBwYXJ0aWFsIGNsb25lCisJIyBjbGllbnQgdGhhdCBvbmx5IGNvbnRhaW5zIHRoZSBmaXJzdCBjb21taXQuCisJZ2l0IGluaXQgc2VydmVyICYmCisJZ2l0IC1DIHNlcnZlciBjb25maWcgLS1sb2NhbCB1cGxvYWRwYWNrLmFsbG93ZmlsdGVyIDEgJiYKKwljcCBiaWctYmxvYi50eHQgc2VydmVyICYmCisJZ2l0IC1DIHNlcnZlciBhZGQgYmlnLWJsb2IudHh0ICYmCisJZ2l0IC1DIHNlcnZlciBjb21taXQgLW0gImluaXRpYWwiICYmCisJZ2l0IGNsb25lIC0tYmFyZSAtLWZpbHRlcj10cmVlOjAgImZpbGU6Ly8kKHB3ZCkvc2VydmVyIiBjbGllbnQgJiYKKwllY2hvIGFub3RoZXIgbGluZSA+PnNlcnZlci9iaWctYmxvYi50eHQgJiYKKwlnaXQgLUMgc2VydmVyIGNvbW1pdCAtYW0gImFwcGVuZCBsaW5lIHRvIGJpZyBibG9iIiAmJgorCisJIyBDcmVhdGUgYSBwcm9taXNvciByZW1vdGUgdGhhdCBvbmx5IGNvbnRhaW5zIHRoZSBibG9iIGZyb20gdGhlIGZpcnN0CisJIyBjb21taXQsIGFuZCBzZXQgaXQgYXMgdGhlIHByb21pc29yIHJlbW90ZSBvZiBjbGllbnQuIFRodXMsIHdoZW5ldmVyCisJIyB0aGUgY2xpZW50IGxhenkgZmV0Y2hlcywgdGhlIGxhenkgZmV0Y2ggd2lsbCBzdWNjZWVkIG9ubHkgaWYgaXQgaXMKKwkjIGZvciB0aGlzIGJsb2IuCisJZ2l0IGluaXQgcHJvbWlzb3ItcmVtb3RlICYmCisJdGVzdF9jb21taXQgLUMgcHJvbWlzb3ItcmVtb3RlIG9uZSAmJiAjIHNvIHRoYXQgcmVmIGFkdmVydGlzZW1lbnQgaXMgbm90IGVtcHR5CisJZ2l0IC1DIHByb21pc29yLXJlbW90ZSBjb25maWcgLS1sb2NhbCB1cGxvYWRwYWNrLmFsbG93YW55c2hhMWlud2FudCAxICYmCisJZ2l0IC1DIHByb21pc29yLXJlbW90ZSBoYXNoLW9iamVjdCAtdyAtLXN0ZGluIDxiaWctYmxvYi50eHQgJiYKKwlnaXQgLUMgY2xpZW50IHJlbW90ZSBzZXQtdXJsIG9yaWdpbiAiZmlsZTovLyQocHdkKS9wcm9taXNvci1yZW1vdGUiCit9CisKKyMgTkVFRFNXT1JLOiBUaGUgdGVzdHMgYmVnaW5uaW5nIHdpdGggImZldGNoIGxhenktZmV0Y2hlcyIgYmVsb3cgb25seQorIyB0ZXN0IHRoYXQgImZldGNoIiBhdm9pZCBmZXRjaGluZyB0cmVlcyBhbmQgYmxvYnMsIGJ1dCBub3QgY29tbWl0cyBvcgorIyB0YWdzLiBSZXZpc2l0IHRoaXMgaWYgR2l0IGlzIGV2ZXIgdGF1Z2h0IHRvIHN1cHBvcnQgcGFydGlhbCBjbG9uZXMKKyMgd2l0aCBjb21taXRzIGFuZC9vciB0YWdzIGZpbHRlcmVkIG91dC4KKwordGVzdF9leHBlY3Rfc3VjY2VzcyAnZmV0Y2ggbGF6eS1mZXRjaGVzIG9ubHkgdG8gcmVzb2x2ZSBkZWx0YXMnICcKKwlzZXR1cF90cmlhbmdsZSAmJgorCisJIyBFeGVyY2lzZSB0byBtYWtlIHN1cmUgaXQgd29ya3MuIEdpdCB3aWxsIG5vdCBmZXRjaCBhbnl0aGluZyBmcm9tIHRoZQorCSMgcHJvbWlzb3IgcmVtb3RlIG90aGVyIHRoYW4gZm9yIHRoZSBiaWcgYmxvYiAoYmVjYXVzZSBpdCBuZWVkcyB0bworCSMgcmVzb2x2ZSB0aGUgZGVsdGEpLgorCUdJVF9UUkFDRV9QQUNLRVQ9IiQocHdkKS90cmFjZSIgZ2l0IC1DIGNsaWVudCBcCisJCWZldGNoICJmaWxlOi8vJChwd2QpL3NlcnZlciIgbWFzdGVyICYmCisKKwkjIFZlcmlmeSB0aGUgYXNzdW1wdGlvbiB0aGF0IHRoZSBjbGllbnQgbmVlZGVkIHRvIGZldGNoIHRoZSBkZWx0YSBiYXNlCisJIyB0byByZXNvbHZlIHRoZSBkZWx0YS4KKwlnaXQgaGFzaC1vYmplY3QgYmlnLWJsb2IudHh0ID5oYXNoICYmCisJZ3JlcCAid2FudCAkKGNhdCBoYXNoKSIgdHJhY2UKKycKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAnZmV0Y2ggbGF6eS1mZXRjaGVzIG9ubHkgdG8gcmVzb2x2ZSBkZWx0YXMsIHByb3RvY29sIHYyJyAnCisJc2V0dXBfdHJpYW5nbGUgJiYKKworCWdpdCAtQyBzZXJ2ZXIgY29uZmlnIC0tbG9jYWwgcHJvdG9jb2wudmVyc2lvbiAyICYmCisJZ2l0IC1DIGNsaWVudCBjb25maWcgLS1sb2NhbCBwcm90b2NvbC52ZXJzaW9uIDIgJiYKKwlnaXQgLUMgcHJvbWlzb3ItcmVtb3RlIGNvbmZpZyAtLWxvY2FsIHByb3RvY29sLnZlcnNpb24gMiAmJgorCisJIyBFeGVyY2lzZSB0byBtYWtlIHN1cmUgaXQgd29ya3MuIEdpdCB3aWxsIG5vdCBmZXRjaCBhbnl0aGluZyBmcm9tIHRoZQorCSMgcHJvbWlzb3IgcmVtb3RlIG90aGVyIHRoYW4gZm9yIHRoZSBiaWcgYmxvYiAoYmVjYXVzZSBpdCBuZWVkcyB0bworCSMgcmVzb2x2ZSB0aGUgZGVsdGEpLgorCUdJVF9UUkFDRV9QQUNLRVQ9IiQocHdkKS90cmFjZSIgZ2l0IC1DIGNsaWVudCBcCisJCWZldGNoICJmaWxlOi8vJChwd2QpL3NlcnZlciIgbWFzdGVyICYmCisKKwkjIFZlcmlmeSB0aGF0IHByb3RvY29sIHZlcnNpb24gMiB3YXMgdXNlZC4KKwlncmVwICJmZXRjaDwgdmVyc2lvbiAyIiB0cmFjZSAmJgorCisJIyBWZXJpZnkgdGhlIGFzc3VtcHRpb24gdGhhdCB0aGUgY2xpZW50IG5lZWRlZCB0byBmZXRjaCB0aGUgZGVsdGEgYmFzZQorCSMgdG8gcmVzb2x2ZSB0aGUgZGVsdGEuCisJZ2l0IGhhc2gtb2JqZWN0IGJpZy1ibG9iLnR4dCA+aGFzaCAmJgorCWdyZXAgIndhbnQgJChjYXQgaGFzaCkiIHRyYWNlCisnCisKIC4gIiRURVNUX0RJUkVDVE9SWSIvbGliLWh0dHBkLnNoCiBzdGFydF9odHRwZAogCkBAIC00MTcsNCArNTUwLDcgQEAKIAkhIHRlc3QgLWUgIiRIVFRQRF9ST09UX1BBVEgvb25lLXRpbWUtc2VkIgogJwogCisjIERPIE5PVCBhZGQgbm9uLWh0dHBkLXNwZWNpZmljIHRlc3RzIGhlcmUsIGJlY2F1c2UgdGhlIGxhc3QgcGFydCBvZiB0aGlzCisjIHRlc3Qgc2NyaXB0IGlzIG9ubHkgZXhlY3V0ZWQgd2hlbiBodHRwZCBpcyBhdmFpbGFibGUgYW5kIGVuYWJsZWQuCisKIHRlc3RfZG9uZQpkaWZmIC0tZ2l0IGEvdC90NTcwMC1wcm90b2NvbC12MS5zaCBiL3QvdDU3MDAtcHJvdG9jb2wtdjEuc2gKaW5kZXggN2M5NTExYy4uMjU3MWViOSAxMDA3NTUKLS0tIGEvdC90NTcwMC1wcm90b2NvbC12MS5zaAorKysgYi90L3Q1NzAwLXByb3RvY29sLXYxLnNoCkBAIC0yOTIsNCArMjkyLDcgQEAKIAlncmVwICJnaXQ8IHZlcnNpb24gMSIgbG9nCiAnCiAKKyMgRE8gTk9UIGFkZCBub24taHR0cGQtc3BlY2lmaWMgdGVzdHMgaGVyZSwgYmVjYXVzZSB0aGUgbGFzdCBwYXJ0IG9mIHRoaXMKKyMgdGVzdCBzY3JpcHQgaXMgb25seSBleGVjdXRlZCB3aGVuIGh0dHBkIGlzIGF2YWlsYWJsZSBhbmQgZW5hYmxlZC4KKwogdGVzdF9kb25lCmRpZmYgLS1naXQgYS90L3Q1NzAyLXByb3RvY29sLXYyLnNoIGIvdC90NTcwMi1wcm90b2NvbC12Mi5zaAppbmRleCAwMTFiODFkLi5lNzMwNjdkIDEwMDc1NQotLS0gYS90L3Q1NzAyLXByb3RvY29sLXYyLnNoCisrKyBiL3QvdDU3MDItcHJvdG9jb2wtdjIuc2gKQEAgLTMyLDcgKzMyLDcgQEAKIAl0ZXN0X2NtcCBleHBlY3QgYWN0dWFsCiAnCiAKLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3JlZiBhZHZlcnRpc21lbnQgaXMgZmlsdGVyZWQgd2l0aCBscy1yZW1vdGUgdXNpbmcgcHJvdG9jb2wgdjInICcKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3JlZiBhZHZlcnRpc2VtZW50IGlzIGZpbHRlcmVkIHdpdGggbHMtcmVtb3RlIHVzaW5nIHByb3RvY29sIHYyJyAnCiAJdGVzdF93aGVuX2ZpbmlzaGVkICJybSAtZiBsb2ciICYmCiAKIAlHSVRfVFJBQ0VfUEFDS0VUPSIkKHB3ZCkvbG9nIiBnaXQgLWMgcHJvdG9jb2wudmVyc2lvbj0yIFwKQEAgLTE1NCw3ICsxNTQsNyBAQAogCXRlc3RfY21wIGV4cGVjdCBhY3R1YWwKICcKIAotdGVzdF9leHBlY3Rfc3VjY2VzcyAncmVmIGFkdmVydGlzbWVudCBpcyBmaWx0ZXJlZCB3aXRoIGxzLXJlbW90ZSB1c2luZyBwcm90b2NvbCB2MicgJwordGVzdF9leHBlY3Rfc3VjY2VzcyAncmVmIGFkdmVydGlzZW1lbnQgaXMgZmlsdGVyZWQgd2l0aCBscy1yZW1vdGUgdXNpbmcgcHJvdG9jb2wgdjInICcKIAl0ZXN0X3doZW5fZmluaXNoZWQgInJtIC1mIGxvZyIgJiYKIAogCUdJVF9UUkFDRV9QQUNLRVQ9IiQocHdkKS9sb2ciIGdpdCAtYyBwcm90b2NvbC52ZXJzaW9uPTIgXApAQCAtMjI1LDcgKzIyNSw3IEBACiAJZ3JlcCAiZmV0Y2g8IHZlcnNpb24gMiIgbG9nCiAnCiAKLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3JlZiBhZHZlcnRpc21lbnQgaXMgZmlsdGVyZWQgZHVyaW5nIGZldGNoIHVzaW5nIHByb3RvY29sIHYyJyAnCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdyZWYgYWR2ZXJ0aXNlbWVudCBpcyBmaWx0ZXJlZCBkdXJpbmcgZmV0Y2ggdXNpbmcgcHJvdG9jb2wgdjInICcKIAl0ZXN0X3doZW5fZmluaXNoZWQgInJtIC1mIGxvZyIgJiYKIAogCXRlc3RfY29tbWl0IC1DIGZpbGVfcGFyZW50IHRocmVlICYmCkBAIC02MzEsNiArNjMxLDE5IEBACiAJZ3JlcCAiZ2l0PCB2ZXJzaW9uIDIiIGxvZwogJwogCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdmZXRjaCB3aXRoIGh0dHA6Ly8gYnkgaGFzaCB3aXRob3V0IHRhZyBmb2xsb3dpbmcgd2l0aCBwcm90b2NvbCB2MiBkb2VzIG5vdCBsaXN0IHJlZnMnICcKKwl0ZXN0X3doZW5fZmluaXNoZWQgInJtIC1mIGxvZyIgJiYKKworCXRlc3RfY29tbWl0IC1DICIkSFRUUERfRE9DVU1FTlRfUk9PVF9QQVRIL2h0dHBfcGFyZW50IiB0d29fYSAmJgorCWdpdCAtQyAiJEhUVFBEX0RPQ1VNRU5UX1JPT1RfUEFUSC9odHRwX3BhcmVudCIgcmV2LXBhcnNlIHR3b19hID50d29fYV9oYXNoICYmCisKKwlHSVRfVFJBQ0VfUEFDS0VUPSIkKHB3ZCkvbG9nIiBnaXQgLUMgaHR0cF9jaGlsZCAtYyBwcm90b2NvbC52ZXJzaW9uPTIgXAorCQlmZXRjaCAtLW5vLXRhZ3Mgb3JpZ2luICQoY2F0IHR3b19hX2hhc2gpICYmCisKKwlncmVwICJmZXRjaDwgdmVyc2lvbiAyIiBsb2cgJiYKKwkhIGdyZXAgImZldGNoPiBjb21tYW5kPWxzLXJlZnMiIGxvZworJworCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdmZXRjaCBmcm9tIG5hbWVzcGFjZWQgcmVwbyByZXNwZWN0cyBuYW1lc3BhY2VzJyAnCiAJdGVzdF93aGVuX2ZpbmlzaGVkICJybSAtZiBsb2ciICYmCiAKQEAgLTY2OSw5ICs2ODIsOSBAQAogCWdpdCAtQyAiJEhUVFBEX0RPQ1VNRU5UX1JPT1RfUEFUSC9odHRwX3BhcmVudCIgbG9nIC0xIC0tZm9ybWF0PSVzIGNsaWVudF9icmFuY2ggPmV4cGVjdCAmJgogCXRlc3RfY21wIGV4cGVjdCBhY3R1YWwgJiYKIAotCSMgQ2xpZW50IGRpZG50IHJlcXVlc3QgdG8gdXNlIHByb3RvY29sIHYyCisJIyBDbGllbnQgZGlkIG5vdCByZXF1ZXN0IHRvIHVzZSBwcm90b2NvbCB2MgogCSEgZ3JlcCAiR2l0LVByb3RvY29sOiB2ZXJzaW9uPTIiIGxvZyAmJgotCSMgU2VydmVyIGRpZG50IHJlc3BvbmQgdXNpbmcgcHJvdG9jb2wgdjIKKwkjIFNlcnZlciBkaWQgbm90IHJlc3BvbmQgdXNpbmcgcHJvdG9jb2wgdjIKIAkhIGdyZXAgImdpdDwgdmVyc2lvbiAyIiBsb2cKICcKIApAQCAtNzIzLDQgKzczNiw3IEBACiAJdGVzdF9pMThuZ3JlcCAiZXhwZWN0ZWQgbm8gb3RoZXIgc2VjdGlvbnMgdG8gYmUgc2VudCBhZnRlciBubyAucmVhZHkuIiBlcnIKICcKIAorIyBETyBOT1QgYWRkIG5vbi1odHRwZC1zcGVjaWZpYyB0ZXN0cyBoZXJlLCBiZWNhdXNlIHRoZSBsYXN0IHBhcnQgb2YgdGhpcworIyB0ZXN0IHNjcmlwdCBpcyBvbmx5IGV4ZWN1dGVkIHdoZW4gaHR0cGQgaXMgYXZhaWxhYmxlIGFuZCBlbmFibGVkLgorCiB0ZXN0X2RvbmUKZGlmZiAtLWdpdCBhL3QvdDU3MDMtdXBsb2FkLXBhY2stcmVmLWluLXdhbnQuc2ggYi90L3Q1NzAzLXVwbG9hZC1wYWNrLXJlZi1pbi13YW50LnNoCmluZGV4IGRlNGI2MTAuLjNhMmMxNDMgMTAwNzU1Ci0tLSBhL3QvdDU3MDMtdXBsb2FkLXBhY2stcmVmLWluLXdhbnQuc2gKKysrIGIvdC90NTcwMy11cGxvYWQtcGFjay1yZWYtaW4td2FudC5zaApAQCAtMTU3LDEwNiArMTU3LDYgQEAKIAljaGVja19vdXRwdXQKICcKIAotLiAiJFRFU1RfRElSRUNUT1JZIi9saWItaHR0cGQuc2gKLXN0YXJ0X2h0dHBkCi0KLVJFUE89IiRIVFRQRF9ET0NVTUVOVF9ST09UX1BBVEgvcmVwbyIKLUxPQ0FMX1BSSVNUSU5FPSIkKHB3ZCkvbG9jYWxfcHJpc3RpbmUiCi0KLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3NldHVwIHJlcG9zIGZvciBjaGFuZ2Utd2hpbGUtbmVnb3RpYXRpbmcgdGVzdCcgJwotCSgKLQkJZ2l0IGluaXQgIiRSRVBPIiAmJgotCQljZCAiJFJFUE8iICYmCi0JCT4uZ2l0L2dpdC1kYWVtb24tZXhwb3J0LW9rICYmCi0JCXRlc3RfY29tbWl0IG0xICYmCi0JCWdpdCB0YWcgLWQgbTEgJiYKLQotCQkjIExvY2FsIHJlcG8gd2l0aCBtYW55IGNvbW1pdHMgKHNvIHRoYXQgbmVnb3RpYXRpb24gd2lsbCB0YWtlCi0JCSMgbW9yZSB0aGFuIDEgcmVxdWVzdC9yZXNwb25zZSBwYWlyKQotCQlnaXQgY2xvbmUgImh0dHA6Ly8xMjcuMC4wLjE6JExJQl9IVFRQRF9QT1JUL3NtYXJ0L3JlcG8iICIkTE9DQUxfUFJJU1RJTkUiICYmCi0JCWNkICIkTE9DQUxfUFJJU1RJTkUiICYmCi0JCWdpdCBjaGVja291dCAtYiBzaWRlICYmCi0JCXRlc3RfY29tbWl0X2J1bGsgLS1pZD1zIDMzICYmCi0KLQkJIyBBZGQgbm92ZWwgY29tbWl0cyB0byB1cHN0cmVhbQotCQlnaXQgY2hlY2tvdXQgbWFzdGVyICYmCi0JCWNkICIkUkVQTyIgJiYKLQkJdGVzdF9jb21taXQgbTIgJiYKLQkJdGVzdF9jb21taXQgbTMgJiYKLQkJZ2l0IHRhZyAtZCBtMiBtMwotCSkgJiYKLQlnaXQgLUMgIiRMT0NBTF9QUklTVElORSIgcmVtb3RlIHNldC11cmwgb3JpZ2luICJodHRwOi8vMTI3LjAuMC4xOiRMSUJfSFRUUERfUE9SVC9vbmVfdGltZV9zZWQvcmVwbyIgJiYKLQlnaXQgLUMgIiRMT0NBTF9QUklTVElORSIgY29uZmlnIHByb3RvY29sLnZlcnNpb24gMgotJwotCi1pbmNvbnNpc3RlbmN5ICgpIHsKLQkjIFNpbXVsYXRlIHRoYXQgdGhlIHNlcnZlciBpbml0aWFsbHkgcmVwb3J0cyAkMiBhcyB0aGUgcmVmCi0JIyBjb3JyZXNwb25kaW5nIHRvICQxLCBhbmQgYWZ0ZXIgdGhhdCwgJDEgYXMgdGhlIHJlZiBjb3JyZXNwb25kaW5nIHRvCi0JIyAkMS4gVGhpcyBjb3JyZXNwb25kcyB0byB0aGUgcmVhbC1saWZlIHNpdHVhdGlvbiB3aGVyZSB0aGUgc2VydmVyJ3MKLQkjIHJlcG9zaXRvcnkgYXBwZWFycyB0byBjaGFuZ2UgZHVyaW5nIG5lZ290aWF0aW9uLCBmb3IgZXhhbXBsZSwgd2hlbgotCSMgZGlmZmVyZW50IHNlcnZlcnMgaW4gYSBsb2FkLWJhbGFuY2luZyBhcnJhbmdlbWVudCBzZXJ2ZSAoc3RhdGVsZXNzKQotCSMgUlBDcyBkdXJpbmcgYSBzaW5nbGUgbmVnb3RpYXRpb24uCi0JcHJpbnRmICJzLyVzLyVzLyIgXAotCSAgICAgICAkKGdpdCAtQyAiJFJFUE8iIHJldi1wYXJzZSAkMSB8IHRyIC1kICJcbiIpIFwKLQkgICAgICAgJChnaXQgLUMgIiRSRVBPIiByZXYtcGFyc2UgJDIgfCB0ciAtZCAiXG4iKSBcCi0JICAgICAgID4iJEhUVFBEX1JPT1RfUEFUSC9vbmUtdGltZS1zZWQiCi19Ci0KLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3NlcnZlciBpcyBpbml0aWFsbHkgYWhlYWQgLSBubyByZWYgaW4gd2FudCcgJwotCWdpdCAtQyAiJFJFUE8iIGNvbmZpZyB1cGxvYWRwYWNrLmFsbG93UmVmSW5XYW50IGZhbHNlICYmCi0Jcm0gLXJmIGxvY2FsICYmCi0JY3AgLXIgIiRMT0NBTF9QUklTVElORSIgbG9jYWwgJiYKLQlpbmNvbnNpc3RlbmN5IG1hc3RlciAxMjM0NTY3ODkwMTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0NTY3ODkwICYmCi0JdGVzdF9tdXN0X2ZhaWwgZ2l0IC1DIGxvY2FsIGZldGNoIDI+ZXJyICYmCi0JdGVzdF9pMThuZ3JlcCAiZmF0YWw6IHJlbW90ZSBlcnJvcjogdXBsb2FkLXBhY2s6IG5vdCBvdXIgcmVmIiBlcnIKLScKLQotdGVzdF9leHBlY3Rfc3VjY2VzcyAnc2VydmVyIGlzIGluaXRpYWxseSBhaGVhZCAtIHJlZiBpbiB3YW50JyAnCi0JZ2l0IC1DICIkUkVQTyIgY29uZmlnIHVwbG9hZHBhY2suYWxsb3dSZWZJbldhbnQgdHJ1ZSAmJgotCXJtIC1yZiBsb2NhbCAmJgotCWNwIC1yICIkTE9DQUxfUFJJU1RJTkUiIGxvY2FsICYmCi0JaW5jb25zaXN0ZW5jeSBtYXN0ZXIgMTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0NTY3ODkwMTIzNDU2Nzg5MCAmJgotCWdpdCAtQyBsb2NhbCBmZXRjaCAmJgotCi0JZ2l0IC1DICIkUkVQTyIgcmV2LXBhcnNlIC0tdmVyaWZ5IG1hc3RlciA+ZXhwZWN0ZWQgJiYKLQlnaXQgLUMgbG9jYWwgcmV2LXBhcnNlIC0tdmVyaWZ5IHJlZnMvcmVtb3Rlcy9vcmlnaW4vbWFzdGVyID5hY3R1YWwgJiYKLQl0ZXN0X2NtcCBleHBlY3RlZCBhY3R1YWwKLScKLQotdGVzdF9leHBlY3Rfc3VjY2VzcyAnc2VydmVyIGlzIGluaXRpYWxseSBiZWhpbmQgLSBubyByZWYgaW4gd2FudCcgJwotCWdpdCAtQyAiJFJFUE8iIGNvbmZpZyB1cGxvYWRwYWNrLmFsbG93UmVmSW5XYW50IGZhbHNlICYmCi0Jcm0gLXJmIGxvY2FsICYmCi0JY3AgLXIgIiRMT0NBTF9QUklTVElORSIgbG9jYWwgJiYKLQlpbmNvbnNpc3RlbmN5IG1hc3RlciAibWFzdGVyXiIgJiYKLQlnaXQgLUMgbG9jYWwgZmV0Y2ggJiYKLQotCWdpdCAtQyAiJFJFUE8iIHJldi1wYXJzZSAtLXZlcmlmeSAibWFzdGVyXiIgPmV4cGVjdGVkICYmCi0JZ2l0IC1DIGxvY2FsIHJldi1wYXJzZSAtLXZlcmlmeSByZWZzL3JlbW90ZXMvb3JpZ2luL21hc3RlciA+YWN0dWFsICYmCi0JdGVzdF9jbXAgZXhwZWN0ZWQgYWN0dWFsCi0nCi0KLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3NlcnZlciBpcyBpbml0aWFsbHkgYmVoaW5kIC0gcmVmIGluIHdhbnQnICcKLQlnaXQgLUMgIiRSRVBPIiBjb25maWcgdXBsb2FkcGFjay5hbGxvd1JlZkluV2FudCB0cnVlICYmCi0Jcm0gLXJmIGxvY2FsICYmCi0JY3AgLXIgIiRMT0NBTF9QUklTVElORSIgbG9jYWwgJiYKLQlpbmNvbnNpc3RlbmN5IG1hc3RlciAibWFzdGVyXiIgJiYKLQlnaXQgLUMgbG9jYWwgZmV0Y2ggJiYKLQotCWdpdCAtQyAiJFJFUE8iIHJldi1wYXJzZSAtLXZlcmlmeSAibWFzdGVyIiA+ZXhwZWN0ZWQgJiYKLQlnaXQgLUMgbG9jYWwgcmV2LXBhcnNlIC0tdmVyaWZ5IHJlZnMvcmVtb3Rlcy9vcmlnaW4vbWFzdGVyID5hY3R1YWwgJiYKLQl0ZXN0X2NtcCBleHBlY3RlZCBhY3R1YWwKLScKLQotdGVzdF9leHBlY3Rfc3VjY2VzcyAnc2VydmVyIGxvc2VzIGEgcmVmIC0gcmVmIGluIHdhbnQnICcKLQlnaXQgLUMgIiRSRVBPIiBjb25maWcgdXBsb2FkcGFjay5hbGxvd1JlZkluV2FudCB0cnVlICYmCi0Jcm0gLXJmIGxvY2FsICYmCi0JY3AgLXIgIiRMT0NBTF9QUklTVElORSIgbG9jYWwgJiYKLQllY2hvICJzL21hc3Rlci9yYXN0ZXIvIiA+IiRIVFRQRF9ST09UX1BBVEgvb25lLXRpbWUtc2VkIiAmJgotCXRlc3RfbXVzdF9mYWlsIGdpdCAtQyBsb2NhbCBmZXRjaCAyPmVyciAmJgotCi0JdGVzdF9pMThuZ3JlcCAiZmF0YWw6IHJlbW90ZSBlcnJvcjogdW5rbm93biByZWYgcmVmcy9oZWFkcy9yYXN0ZXIiIGVycgotJwotCiBSRVBPPSIkKHB3ZCkvcmVwbyIKIExPQ0FMX1BSSVNUSU5FPSIkKHB3ZCkvbG9jYWxfcHJpc3RpbmUiCiAKQEAgLTM3Miw0ICsyNzIsMTA4IEBACiAJZ3JlcCAid2FudC1yZWYgcmVmcy9oZWFkcy9vL2JhciIgbG9nCiAnCiAKKy4gIiRURVNUX0RJUkVDVE9SWSIvbGliLWh0dHBkLnNoCitzdGFydF9odHRwZAorCitSRVBPPSIkSFRUUERfRE9DVU1FTlRfUk9PVF9QQVRIL3JlcG8iCitMT0NBTF9QUklTVElORT0iJChwd2QpL2xvY2FsX3ByaXN0aW5lIgorCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdzZXR1cCByZXBvcyBmb3IgY2hhbmdlLXdoaWxlLW5lZ290aWF0aW5nIHRlc3QnICcKKwkoCisJCWdpdCBpbml0ICIkUkVQTyIgJiYKKwkJY2QgIiRSRVBPIiAmJgorCQk+LmdpdC9naXQtZGFlbW9uLWV4cG9ydC1vayAmJgorCQl0ZXN0X2NvbW1pdCBtMSAmJgorCQlnaXQgdGFnIC1kIG0xICYmCisKKwkJIyBMb2NhbCByZXBvIHdpdGggbWFueSBjb21taXRzIChzbyB0aGF0IG5lZ290aWF0aW9uIHdpbGwgdGFrZQorCQkjIG1vcmUgdGhhbiAxIHJlcXVlc3QvcmVzcG9uc2UgcGFpcikKKwkJcm0gLXJmICIkTE9DQUxfUFJJU1RJTkUiICYmCisJCWdpdCBjbG9uZSAiaHR0cDovLzEyNy4wLjAuMTokTElCX0hUVFBEX1BPUlQvc21hcnQvcmVwbyIgIiRMT0NBTF9QUklTVElORSIgJiYKKwkJY2QgIiRMT0NBTF9QUklTVElORSIgJiYKKwkJZ2l0IGNoZWNrb3V0IC1iIHNpZGUgJiYKKwkJdGVzdF9jb21taXRfYnVsayAtLWlkPXMgMzMgJiYKKworCQkjIEFkZCBub3ZlbCBjb21taXRzIHRvIHVwc3RyZWFtCisJCWdpdCBjaGVja291dCBtYXN0ZXIgJiYKKwkJY2QgIiRSRVBPIiAmJgorCQl0ZXN0X2NvbW1pdCBtMiAmJgorCQl0ZXN0X2NvbW1pdCBtMyAmJgorCQlnaXQgdGFnIC1kIG0yIG0zCisJKSAmJgorCWdpdCAtQyAiJExPQ0FMX1BSSVNUSU5FIiByZW1vdGUgc2V0LXVybCBvcmlnaW4gImh0dHA6Ly8xMjcuMC4wLjE6JExJQl9IVFRQRF9QT1JUL29uZV90aW1lX3NlZC9yZXBvIiAmJgorCWdpdCAtQyAiJExPQ0FMX1BSSVNUSU5FIiBjb25maWcgcHJvdG9jb2wudmVyc2lvbiAyCisnCisKK2luY29uc2lzdGVuY3kgKCkgeworCSMgU2ltdWxhdGUgdGhhdCB0aGUgc2VydmVyIGluaXRpYWxseSByZXBvcnRzICQyIGFzIHRoZSByZWYKKwkjIGNvcnJlc3BvbmRpbmcgdG8gJDEsIGFuZCBhZnRlciB0aGF0LCAkMSBhcyB0aGUgcmVmIGNvcnJlc3BvbmRpbmcgdG8KKwkjICQxLiBUaGlzIGNvcnJlc3BvbmRzIHRvIHRoZSByZWFsLWxpZmUgc2l0dWF0aW9uIHdoZXJlIHRoZSBzZXJ2ZXIncworCSMgcmVwb3NpdG9yeSBhcHBlYXJzIHRvIGNoYW5nZSBkdXJpbmcgbmVnb3RpYXRpb24sIGZvciBleGFtcGxlLCB3aGVuCisJIyBkaWZmZXJlbnQgc2VydmVycyBpbiBhIGxvYWQtYmFsYW5jaW5nIGFycmFuZ2VtZW50IHNlcnZlIChzdGF0ZWxlc3MpCisJIyBSUENzIGR1cmluZyBhIHNpbmdsZSBuZWdvdGlhdGlvbi4KKwlwcmludGYgInMvJXMvJXMvIiBcCisJICAgICAgICQoZ2l0IC1DICIkUkVQTyIgcmV2LXBhcnNlICQxIHwgdHIgLWQgIlxuIikgXAorCSAgICAgICAkKGdpdCAtQyAiJFJFUE8iIHJldi1wYXJzZSAkMiB8IHRyIC1kICJcbiIpIFwKKwkgICAgICAgPiIkSFRUUERfUk9PVF9QQVRIL29uZS10aW1lLXNlZCIKK30KKwordGVzdF9leHBlY3Rfc3VjY2VzcyAnc2VydmVyIGlzIGluaXRpYWxseSBhaGVhZCAtIG5vIHJlZiBpbiB3YW50JyAnCisJZ2l0IC1DICIkUkVQTyIgY29uZmlnIHVwbG9hZHBhY2suYWxsb3dSZWZJbldhbnQgZmFsc2UgJiYKKwlybSAtcmYgbG9jYWwgJiYKKwljcCAtciAiJExPQ0FMX1BSSVNUSU5FIiBsb2NhbCAmJgorCWluY29uc2lzdGVuY3kgbWFzdGVyIDEyMzQ1Njc4OTAxMjM0NTY3ODkwMTIzNDU2Nzg5MDEyMzQ1Njc4OTAgJiYKKwl0ZXN0X211c3RfZmFpbCBnaXQgLUMgbG9jYWwgZmV0Y2ggMj5lcnIgJiYKKwl0ZXN0X2kxOG5ncmVwICJmYXRhbDogcmVtb3RlIGVycm9yOiB1cGxvYWQtcGFjazogbm90IG91ciByZWYiIGVycgorJworCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdzZXJ2ZXIgaXMgaW5pdGlhbGx5IGFoZWFkIC0gcmVmIGluIHdhbnQnICcKKwlnaXQgLUMgIiRSRVBPIiBjb25maWcgdXBsb2FkcGFjay5hbGxvd1JlZkluV2FudCB0cnVlICYmCisJcm0gLXJmIGxvY2FsICYmCisJY3AgLXIgIiRMT0NBTF9QUklTVElORSIgbG9jYWwgJiYKKwlpbmNvbnNpc3RlbmN5IG1hc3RlciAxMjM0NTY3ODkwMTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0NTY3ODkwICYmCisJZ2l0IC1DIGxvY2FsIGZldGNoICYmCisKKwlnaXQgLUMgIiRSRVBPIiByZXYtcGFyc2UgLS12ZXJpZnkgbWFzdGVyID5leHBlY3RlZCAmJgorCWdpdCAtQyBsb2NhbCByZXYtcGFyc2UgLS12ZXJpZnkgcmVmcy9yZW1vdGVzL29yaWdpbi9tYXN0ZXIgPmFjdHVhbCAmJgorCXRlc3RfY21wIGV4cGVjdGVkIGFjdHVhbAorJworCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdzZXJ2ZXIgaXMgaW5pdGlhbGx5IGJlaGluZCAtIG5vIHJlZiBpbiB3YW50JyAnCisJZ2l0IC1DICIkUkVQTyIgY29uZmlnIHVwbG9hZHBhY2suYWxsb3dSZWZJbldhbnQgZmFsc2UgJiYKKwlybSAtcmYgbG9jYWwgJiYKKwljcCAtciAiJExPQ0FMX1BSSVNUSU5FIiBsb2NhbCAmJgorCWluY29uc2lzdGVuY3kgbWFzdGVyICJtYXN0ZXJeIiAmJgorCWdpdCAtQyBsb2NhbCBmZXRjaCAmJgorCisJZ2l0IC1DICIkUkVQTyIgcmV2LXBhcnNlIC0tdmVyaWZ5ICJtYXN0ZXJeIiA+ZXhwZWN0ZWQgJiYKKwlnaXQgLUMgbG9jYWwgcmV2LXBhcnNlIC0tdmVyaWZ5IHJlZnMvcmVtb3Rlcy9vcmlnaW4vbWFzdGVyID5hY3R1YWwgJiYKKwl0ZXN0X2NtcCBleHBlY3RlZCBhY3R1YWwKKycKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAnc2VydmVyIGlzIGluaXRpYWxseSBiZWhpbmQgLSByZWYgaW4gd2FudCcgJworCWdpdCAtQyAiJFJFUE8iIGNvbmZpZyB1cGxvYWRwYWNrLmFsbG93UmVmSW5XYW50IHRydWUgJiYKKwlybSAtcmYgbG9jYWwgJiYKKwljcCAtciAiJExPQ0FMX1BSSVNUSU5FIiBsb2NhbCAmJgorCWluY29uc2lzdGVuY3kgbWFzdGVyICJtYXN0ZXJeIiAmJgorCWdpdCAtQyBsb2NhbCBmZXRjaCAmJgorCisJZ2l0IC1DICIkUkVQTyIgcmV2LXBhcnNlIC0tdmVyaWZ5ICJtYXN0ZXIiID5leHBlY3RlZCAmJgorCWdpdCAtQyBsb2NhbCByZXYtcGFyc2UgLS12ZXJpZnkgcmVmcy9yZW1vdGVzL29yaWdpbi9tYXN0ZXIgPmFjdHVhbCAmJgorCXRlc3RfY21wIGV4cGVjdGVkIGFjdHVhbAorJworCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdzZXJ2ZXIgbG9zZXMgYSByZWYgLSByZWYgaW4gd2FudCcgJworCWdpdCAtQyAiJFJFUE8iIGNvbmZpZyB1cGxvYWRwYWNrLmFsbG93UmVmSW5XYW50IHRydWUgJiYKKwlybSAtcmYgbG9jYWwgJiYKKwljcCAtciAiJExPQ0FMX1BSSVNUSU5FIiBsb2NhbCAmJgorCWVjaG8gInMvbWFzdGVyL3Jhc3Rlci8iID4iJEhUVFBEX1JPT1RfUEFUSC9vbmUtdGltZS1zZWQiICYmCisJdGVzdF9tdXN0X2ZhaWwgZ2l0IC1DIGxvY2FsIGZldGNoIDI+ZXJyICYmCisKKwl0ZXN0X2kxOG5ncmVwICJmYXRhbDogcmVtb3RlIGVycm9yOiB1bmtub3duIHJlZiByZWZzL2hlYWRzL3Jhc3RlciIgZXJyCisnCisKKyMgRE8gTk9UIGFkZCBub24taHR0cGQtc3BlY2lmaWMgdGVzdHMgaGVyZSwgYmVjYXVzZSB0aGUgbGFzdCBwYXJ0IG9mIHRoaXMKKyMgdGVzdCBzY3JpcHQgaXMgb25seSBleGVjdXRlZCB3aGVuIGh0dHBkIGlzIGF2YWlsYWJsZSBhbmQgZW5hYmxlZC4KKwogdGVzdF9kb25lCmRpZmYgLS1naXQgYS90L3Q1ODAxLXJlbW90ZS1oZWxwZXJzLnNoIGIvdC90NTgwMS1yZW1vdGUtaGVscGVycy5zaAppbmRleCAyZDZjNGEyLi4xMjFlNWM2IDEwMDc1NQotLS0gYS90L3Q1ODAxLXJlbW90ZS1oZWxwZXJzLnNoCisrKyBiL3QvdDU4MDEtcmVtb3RlLWhlbHBlcnMuc2gKQEAgLTI0Nyw3ICsyNDcsNiBAQAogdGVzdF9leHBlY3Rfc3VjY2VzcyAncHJvcGVyIGZhaWx1cmUgY2hlY2tzIGZvciBmZXRjaGluZycgJwogCShjZCBsb2NhbCAmJgogCXRlc3RfbXVzdF9mYWlsIGVudiBHSVRfUkVNT1RFX1RFU1RHSVRfRkFJTFVSRT0xIGdpdCBmZXRjaCAyPmVycm9yICYmCi0JY2F0IGVycm9yICYmCiAJdGVzdF9pMThuZ3JlcCAtcSAiZXJyb3Igd2hpbGUgcnVubmluZyBmYXN0LWltcG9ydCIgZXJyb3IKIAkpCiAnCmRpZmYgLS1naXQgYS90L3Q2MDAwLXJldi1saXN0LW1pc2Muc2ggYi90L3Q2MDAwLXJldi1saXN0LW1pc2Muc2gKaW5kZXggNTJhOWUzOC4uYjhjZjgyMyAxMDA3NTUKLS0tIGEvdC90NjAwMC1yZXYtbGlzdC1taXNjLnNoCisrKyBiL3QvdDYwMDAtcmV2LWxpc3QtbWlzYy5zaApAQCAtMTQwLDQgKzE0MCwxMiBAQAogCXRlc3RfY21wIGV4cGVjdCBhY3R1YWwKICcKIAordGVzdF9leHBlY3Rfc3VjY2VzcyAncmV2LWxpc3QgLS1lbmQtb2Ytb3B0aW9ucycgJworCWdpdCB1cGRhdGUtcmVmIHJlZnMvaGVhZHMvLS1vdXRwdXQ9eWlrZXMgSEVBRCAmJgorCWdpdCByZXYtbGlzdCAtLWVuZC1vZi1vcHRpb25zIC0tb3V0cHV0PXlpa2VzID5hY3R1YWwgJiYKKwl0ZXN0X3BhdGhfaXNfbWlzc2luZyB5aWtlcyAmJgorCWdpdCByZXYtbGlzdCBIRUFEID5leHBlY3QgJiYKKwl0ZXN0X2NtcCBleHBlY3QgYWN0dWFsCisnCisKIHRlc3RfZG9uZQpkaWZmIC0tZ2l0IGEvdC90NjAwNi1yZXYtbGlzdC1mb3JtYXQuc2ggYi90L3Q2MDA2LXJldi1saXN0LWZvcm1hdC5zaAppbmRleCBkYTExM2Q5Li5lYmRjNDljIDEwMDc1NQotLS0gYS90L3Q2MDA2LXJldi1saXN0LWZvcm1hdC5zaAorKysgYi90L3Q2MDA2LXJldi1saXN0LWZvcm1hdC5zaApAQCAtMTA5LDMxICsxMDksMzUgQEAKIEVPRgogCiAjIHdlIGRvbid0IHRlc3QgcmVsYXRpdmUgaGVyZQotdGVzdF9mb3JtYXQgYXV0aG9yICVhbiVuJWFlJW4lYWQlbiVhRCVuJWF0IDw8RU9GCit0ZXN0X2Zvcm1hdCBhdXRob3IgJWFuJW4lYWUlbiVhbCVuJWFkJW4lYUQlbiVhdCA8PEVPRgogY29tbWl0ICRoZWFkMgotQSBVIFRob3IKLWF1dGhvckBleGFtcGxlLmNvbQorJEdJVF9BVVRIT1JfTkFNRQorJEdJVF9BVVRIT1JfRU1BSUwKKyRURVNUX0FVVEhPUl9MT0NBTE5BTUUKIFRodSBBcHIgNyAxNToxMzoxMyAyMDA1IC0wNzAwCiBUaHUsIDcgQXByIDIwMDUgMTU6MTM6MTMgLTA3MDAKIDExMTI5MTE5OTMKIGNvbW1pdCAkaGVhZDEKLUEgVSBUaG9yCi1hdXRob3JAZXhhbXBsZS5jb20KKyRHSVRfQVVUSE9SX05BTUUKKyRHSVRfQVVUSE9SX0VNQUlMCiskVEVTVF9BVVRIT1JfTE9DQUxOQU1FCiBUaHUgQXByIDcgMTU6MTM6MTMgMjAwNSAtMDcwMAogVGh1LCA3IEFwciAyMDA1IDE1OjEzOjEzIC0wNzAwCiAxMTEyOTExOTkzCiBFT0YKIAotdGVzdF9mb3JtYXQgY29tbWl0dGVyICVjbiVuJWNlJW4lY2QlbiVjRCVuJWN0IDw8RU9GCit0ZXN0X2Zvcm1hdCBjb21taXR0ZXIgJWNuJW4lY2UlbiVjbCVuJWNkJW4lY0QlbiVjdCA8PEVPRgogY29tbWl0ICRoZWFkMgotQyBPIE1pdHRlcgotY29tbWl0dGVyQGV4YW1wbGUuY29tCiskR0lUX0NPTU1JVFRFUl9OQU1FCiskR0lUX0NPTU1JVFRFUl9FTUFJTAorJFRFU1RfQ09NTUlUVEVSX0xPQ0FMTkFNRQogVGh1IEFwciA3IDE1OjEzOjEzIDIwMDUgLTA3MDAKIFRodSwgNyBBcHIgMjAwNSAxNToxMzoxMyAtMDcwMAogMTExMjkxMTk5MwogY29tbWl0ICRoZWFkMQotQyBPIE1pdHRlcgotY29tbWl0dGVyQGV4YW1wbGUuY29tCiskR0lUX0NPTU1JVFRFUl9OQU1FCiskR0lUX0NPTU1JVFRFUl9FTUFJTAorJFRFU1RfQ09NTUlUVEVSX0xPQ0FMTkFNRQogVGh1IEFwciA3IDE1OjEzOjEzIDIwMDUgLTA3MDAKIFRodSwgNyBBcHIgMjAwNSAxNToxMzoxMyAtMDcwMAogMTExMjkxMTk5MwpAQCAtNDEwLDcgKzQxNCw3IEBACiAJdGVzdF90aWNrICYmCiAJQz0kKEdJVF9BVVRIT1JfRU1BSUw9IGdpdCBjb21taXQtdHJlZSBIRUFEXnt0cmVlfSA8L2Rldi9udWxsKSAmJgogCUE9JChnaXQgc2hvdyAtLXByZXR0eT1mb3JtYXQ6JWFuLCVhZSwlYWQlbiAtcyAkQykgJiYKLQl2ZXJib3NlIHRlc3QgIiRBIiA9ICJBIFUgVGhvciwsVGh1IEFwciA3IDE1OjE0OjEzIDIwMDUgLTA3MDAiCisJdmVyYm9zZSB0ZXN0ICIkQSIgPSAiJEdJVF9BVVRIT1JfTkFNRSwsVGh1IEFwciA3IDE1OjE0OjEzIDIwMDUgLTA3MDAiCiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2RlbCBMRiBiZWZvcmUgZW1wdHkgKDEpJyAnCkBAIC00OTUsMTUgKzQ5OSwxNCBAQAogJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdyZWZsb2cgaWRlbnRpdHknICcKLQllY2hvICJDIE8gTWl0dGVyOmNvbW1pdHRlckBleGFtcGxlLmNvbSIgPmV4cGVjdCAmJgorCWVjaG8gIiRHSVRfQ09NTUlUVEVSX05BTUU6JEdJVF9DT01NSVRURVJfRU1BSUwiID5leHBlY3QgJiYKIAlnaXQgbG9nIC1nIC0xIC0tZm9ybWF0PSIlZ246JWdlIiA+YWN0dWFsICYmCiAJdGVzdF9jbXAgZXhwZWN0IGFjdHVhbAogJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdvbmVsaW5lIHdpdGggZW1wdHkgbWVzc2FnZScgJwotCWdpdCBjb21taXQgLW0gImR1bW15IiAtLWFsbG93LWVtcHR5ICYmCi0JZ2l0IGNvbW1pdCAtbSAiZHVtbXkiIC0tYWxsb3ctZW1wdHkgJiYKLQlnaXQgZmlsdGVyLWJyYW5jaCAtLW1zZy1maWx0ZXIgInNlZCAtZSBzL2R1bW15Ly8iIEhFQUReXi4uICYmCisJZ2l0IGNvbW1pdCAtLWFsbG93LWVtcHR5IC0tY2xlYW51cD12ZXJiYXRpbSAtbSAiJExGIiAmJgorCWdpdCBjb21taXQgLS1hbGxvdy1lbXB0eSAtLWFsbG93LWVtcHR5LW1lc3NhZ2UgJiYKIAlnaXQgcmV2LWxpc3QgLS1vbmVsaW5lIEhFQUQgPnRlc3QudHh0ICYmCiAJdGVzdF9saW5lX2NvdW50ID0gNSB0ZXN0LnR4dCAmJgogCWdpdCByZXYtbGlzdCAtLW9uZWxpbmUgLS1ncmFwaCBIRUFEID50ZXN0Zy50eHQgJiYKZGlmZiAtLWdpdCBhL3QvdDYwMTEtcmV2LWxpc3Qtd2l0aC1iYWQtY29tbWl0LnNoIGIvdC90NjAxMS1yZXYtbGlzdC13aXRoLWJhZC1jb21taXQuc2gKaW5kZXggNTQ1YjQ2MS4uYmFkMDJjZiAxMDA3NTUKLS0tIGEvdC90NjAxMS1yZXYtbGlzdC13aXRoLWJhZC1jb21taXQuc2gKKysrIGIvdC90NjAxMS1yZXYtbGlzdC13aXRoLWJhZC1jb21taXQuc2gKQEAgLTQyLDcgKzQyLDcgQEAKICAgICcKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAncmV2LWxpc3Qgc2hvdWxkIGZhaWwnICcKLQl0ZXN0X211c3RfZmFpbCBlbnYgR0lUX1RFU1RfQ09NTUlUX0dSQVBIPTAgZ2l0IHJldi1saXN0IC0tYWxsID4gL2Rldi9udWxsCisJdGVzdF9tdXN0X2ZhaWwgZW52IEdJVF9URVNUX0NPTU1JVF9HUkFQSD0wIGdpdCAtYyBjb3JlLmNvbW1pdEdyYXBoPWZhbHNlIHJldi1saXN0IC0tYWxsID4gL2Rldi9udWxsCiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2dpdCByZXBhY2sgX01VU1RfIGZhaWwnIFwKZGlmZiAtLWdpdCBhL3QvdDYwMTYtcmV2LWxpc3QtZ3JhcGgtc2ltcGxpZnktaGlzdG9yeS5zaCBiL3QvdDYwMTYtcmV2LWxpc3QtZ3JhcGgtc2ltcGxpZnktaGlzdG9yeS5zaAppbmRleCBmNzE4MWQxLi5mNWU2ZTkyIDEwMDc1NQotLS0gYS90L3Q2MDE2LXJldi1saXN0LWdyYXBoLXNpbXBsaWZ5LWhpc3Rvcnkuc2gKKysrIGIvdC90NjAxNi1yZXYtbGlzdC1ncmFwaC1zaW1wbGlmeS1oaXN0b3J5LnNoCkBAIC02NywxMSArNjcsMTAgQEAKIAllY2hvICJ8ICogJEM0IiA+PiBleHBlY3RlZCAmJgogCWVjaG8gInwgKiAkQzMiID4+IGV4cGVjdGVkICYmCiAJZWNobyAiKiB8ICRBNSIgPj4gZXhwZWN0ZWQgJiYKLQllY2hvICJ8IHwgICAgICIgPj4gZXhwZWN0ZWQgJiYKLQllY2hvICJ8ICBcXCAgICAiID4+IGV4cGVjdGVkICYmCi0JZWNobyAiKi0uIFxcICAgJEE0IiA+PiBleHBlY3RlZCAmJgotCWVjaG8gInxcXCBcXCBcXCAgIiA+PiBleHBlY3RlZCAmJgotCWVjaG8gInwgfCB8LyAgIiA+PiBleHBlY3RlZCAmJgorCWVjaG8gInwgfCAgICIgPj4gZXhwZWN0ZWQgJiYKKwllY2hvICJ8ICBcXCAgIiA+PiBleHBlY3RlZCAmJgorCWVjaG8gIiotLiB8ICRBNCIgPj4gZXhwZWN0ZWQgJiYKKwllY2hvICJ8XFwgXFx8ICIgPj4gZXhwZWN0ZWQgJiYKIAllY2hvICJ8IHwgKiAkQzIiID4+IGV4cGVjdGVkICYmCiAJZWNobyAifCB8ICogJEMxIiA+PiBleHBlY3RlZCAmJgogCWVjaG8gInwgKiB8ICRCMiIgPj4gZXhwZWN0ZWQgJiYKQEAgLTk3LDExICs5NiwxMCBAQAogCWVjaG8gInwgKiAkQzQiID4+IGV4cGVjdGVkICYmCiAJZWNobyAifCAqICRDMyIgPj4gZXhwZWN0ZWQgJiYKIAllY2hvICIqIHwgJEE1IiA+PiBleHBlY3RlZCAmJgotCWVjaG8gInwgfCAgICAgIiA+PiBleHBlY3RlZCAmJgotCWVjaG8gInwgIFxcICAgICIgPj4gZXhwZWN0ZWQgJiYKLQllY2hvICIqLS4gXFwgICAkQTQiID4+IGV4cGVjdGVkICYmCi0JZWNobyAifFxcIFxcIFxcICAiID4+IGV4cGVjdGVkICYmCi0JZWNobyAifCB8IHwvICAiID4+IGV4cGVjdGVkICYmCisJZWNobyAifCB8ICAgIiA+PiBleHBlY3RlZCAmJgorCWVjaG8gInwgIFxcICAiID4+IGV4cGVjdGVkICYmCisJZWNobyAiKi0uIHwgJEE0IiA+PiBleHBlY3RlZCAmJgorCWVjaG8gInxcXCBcXHwgIiA+PiBleHBlY3RlZCAmJgogCWVjaG8gInwgfCAqICRDMiIgPj4gZXhwZWN0ZWQgJiYKIAllY2hvICJ8IHwgKiAkQzEiID4+IGV4cGVjdGVkICYmCiAJZWNobyAifCAqIHwgJEIyIiA+PiBleHBlY3RlZCAmJgpAQCAtMTMxLDkgKzEyOSw4IEBACiAJZWNobyAifCAqICRDNCIgPj4gZXhwZWN0ZWQgJiYKIAllY2hvICJ8ICogJEMzIiA+PiBleHBlY3RlZCAmJgogCWVjaG8gIiogfCAkQTUiID4+IGV4cGVjdGVkICYmCi0JZWNobyAiKiB8ICAgJEE0IiA+PiBleHBlY3RlZCAmJgotCWVjaG8gInxcXCBcXCAgIiA+PiBleHBlY3RlZCAmJgotCWVjaG8gInwgfC8gICIgPj4gZXhwZWN0ZWQgJiYKKwllY2hvICIqIHwgJEE0IiA+PiBleHBlY3RlZCAmJgorCWVjaG8gInxcXHwgIiA+PiBleHBlY3RlZCAmJgogCWVjaG8gInwgKiAkQzIiID4+IGV4cGVjdGVkICYmCiAJZWNobyAifCAqICRDMSIgPj4gZXhwZWN0ZWQgJiYKIAllY2hvICIqIHwgJEEzIiA+PiBleHBlY3RlZCAmJgpAQCAtMTUxLDkgKzE0OCw4IEBACiAJZWNobyAifFxcICAiID4+IGV4cGVjdGVkICYmCiAJZWNobyAifCAqICRDNCIgPj4gZXhwZWN0ZWQgJiYKIAllY2hvICIqIHwgJEE1IiA+PiBleHBlY3RlZCAmJgotCWVjaG8gIiogfCAgICRBNCIgPj4gZXhwZWN0ZWQgJiYKLQllY2hvICJ8XFwgXFwgICIgPj4gZXhwZWN0ZWQgJiYKLQllY2hvICJ8IHwvICAiID4+IGV4cGVjdGVkICYmCisJZWNobyAiKiB8ICRBNCIgPj4gZXhwZWN0ZWQgJiYKKwllY2hvICJ8XFx8ICIgPj4gZXhwZWN0ZWQgJiYKIAllY2hvICIqIHwgJEEzIiA+PiBleHBlY3RlZCAmJgogCWVjaG8gInwvICAiID4+IGV4cGVjdGVkICYmCiAJZWNobyAiKiAkQTIiID4+IGV4cGVjdGVkICYmCkBAIC0yNTUsNyArMjUxLDcgQEAKIAllY2hvICIqIHwgfCB8ICRBMyIgPj4gZXhwZWN0ZWQgJiYKIAllY2hvICJvIHwgfCB8ICRBMiIgPj4gZXhwZWN0ZWQgJiYKIAllY2hvICJ8LyAvIC8gICIgPj4gZXhwZWN0ZWQgJiYKLQllY2hvICJvIHwgfCAkQTEiID4+IGV4cGVjdGVkICYmCisJZWNobyAibyAvIC8gJEExIiA+PiBleHBlY3RlZCAmJgogCWVjaG8gIiAvIC8gICIgPj4gZXhwZWN0ZWQgJiYKIAllY2hvICJ8IG8gJEMzIiA+PiBleHBlY3RlZCAmJgogCWVjaG8gInwvICAiID4+IGV4cGVjdGVkICYmCmRpZmYgLS1naXQgYS90L3Q2MDI0LXJlY3Vyc2l2ZS1tZXJnZS5zaCBiL3QvdDYwMjQtcmVjdXJzaXZlLW1lcmdlLnNoCmluZGV4IDI3YzdkZTkuLjBjOWUzYzIgMTAwNzU1Ci0tLSBhL3QvdDYwMjQtcmVjdXJzaXZlLW1lcmdlLnNoCisrKyBiL3QvdDYwMjQtcmVjdXJzaXZlLW1lcmdlLnNoCkBAIC0xNCw4NSArMTQsOTAgQEAKIEdJVF9DT01NSVRURVJfREFURT0iMjAwNi0xMi0xMiAyMzoyODowMCArMDEwMCIKIGV4cG9ydCBHSVRfQ09NTUlUVEVSX0RBVEUKIAotdGVzdF9leHBlY3Rfc3VjY2VzcyAic2V0dXAgdGVzdHMiICcKLWVjaG8gMSA+IGExICYmCi1naXQgYWRkIGExICYmCi1HSVRfQVVUSE9SX0RBVEU9IjIwMDYtMTItMTIgMjM6MDA6MDAiIGdpdCBjb21taXQgLW0gMSBhMSAmJgordGVzdF9leHBlY3Rfc3VjY2VzcyAnc2V0dXAgdGVzdHMnICcKKwllY2hvIDEgPmExICYmCisJZ2l0IGFkZCBhMSAmJgorCUdJVF9BVVRIT1JfREFURT0iMjAwNi0xMi0xMiAyMzowMDowMCIgZ2l0IGNvbW1pdCAtbSAxIGExICYmCiAKLWdpdCBjaGVja291dCAtYiBBIG1hc3RlciAmJgotZWNobyBBID4gYTEgJiYKLUdJVF9BVVRIT1JfREFURT0iMjAwNi0xMi0xMiAyMzowMDowMSIgZ2l0IGNvbW1pdCAtbSBBIGExICYmCisJZ2l0IGNoZWNrb3V0IC1iIEEgbWFzdGVyICYmCisJZWNobyBBID5hMSAmJgorCUdJVF9BVVRIT1JfREFURT0iMjAwNi0xMi0xMiAyMzowMDowMSIgZ2l0IGNvbW1pdCAtbSBBIGExICYmCiAKLWdpdCBjaGVja291dCAtYiBCIG1hc3RlciAmJgotZWNobyBCID4gYTEgJiYKLUdJVF9BVVRIT1JfREFURT0iMjAwNi0xMi0xMiAyMzowMDowMiIgZ2l0IGNvbW1pdCAtbSBCIGExICYmCisJZ2l0IGNoZWNrb3V0IC1iIEIgbWFzdGVyICYmCisJZWNobyBCID5hMSAmJgorCUdJVF9BVVRIT1JfREFURT0iMjAwNi0xMi0xMiAyMzowMDowMiIgZ2l0IGNvbW1pdCAtbSBCIGExICYmCiAKLWdpdCBjaGVja291dCAtYiBEIEEgJiYKLWdpdCByZXYtcGFyc2UgQiA+IC5naXQvTUVSR0VfSEVBRCAmJgotZWNobyBEID4gYTEgJiYKLWdpdCB1cGRhdGUtaW5kZXggYTEgJiYKLUdJVF9BVVRIT1JfREFURT0iMjAwNi0xMi0xMiAyMzowMDowMyIgZ2l0IGNvbW1pdCAtbSBEICYmCisJZ2l0IGNoZWNrb3V0IC1iIEQgQSAmJgorCWdpdCByZXYtcGFyc2UgQiA+LmdpdC9NRVJHRV9IRUFEICYmCisJZWNobyBEID5hMSAmJgorCWdpdCB1cGRhdGUtaW5kZXggYTEgJiYKKwlHSVRfQVVUSE9SX0RBVEU9IjIwMDYtMTItMTIgMjM6MDA6MDMiIGdpdCBjb21taXQgLW0gRCAmJgogCi1naXQgc3ltYm9saWMtcmVmIEhFQUQgcmVmcy9oZWFkcy9vdGhlciAmJgotZWNobyAyID4gYTEgJiYKLUdJVF9BVVRIT1JfREFURT0iMjAwNi0xMi0xMiAyMzowMDowNCIgZ2l0IGNvbW1pdCAtbSAyIGExICYmCisJZ2l0IHN5bWJvbGljLXJlZiBIRUFEIHJlZnMvaGVhZHMvb3RoZXIgJiYKKwllY2hvIDIgPmExICYmCisJR0lUX0FVVEhPUl9EQVRFPSIyMDA2LTEyLTEyIDIzOjAwOjA0IiBnaXQgY29tbWl0IC1tIDIgYTEgJiYKIAotZ2l0IGNoZWNrb3V0IC1iIEMgJiYKLWVjaG8gQyA+IGExICYmCi1HSVRfQVVUSE9SX0RBVEU9IjIwMDYtMTItMTIgMjM6MDA6MDUiIGdpdCBjb21taXQgLW0gQyBhMSAmJgorCWdpdCBjaGVja291dCAtYiBDICYmCisJZWNobyBDID5hMSAmJgorCUdJVF9BVVRIT1JfREFURT0iMjAwNi0xMi0xMiAyMzowMDowNSIgZ2l0IGNvbW1pdCAtbSBDIGExICYmCiAKLWdpdCBjaGVja291dCAtYiBFIEMgJiYKLWdpdCByZXYtcGFyc2UgQiA+IC5naXQvTUVSR0VfSEVBRCAmJgotZWNobyBFID4gYTEgJiYKLWdpdCB1cGRhdGUtaW5kZXggYTEgJiYKLUdJVF9BVVRIT1JfREFURT0iMjAwNi0xMi0xMiAyMzowMDowNiIgZ2l0IGNvbW1pdCAtbSBFICYmCisJZ2l0IGNoZWNrb3V0IC1iIEUgQyAmJgorCWdpdCByZXYtcGFyc2UgQiA+LmdpdC9NRVJHRV9IRUFEICYmCisJZWNobyBFID5hMSAmJgorCWdpdCB1cGRhdGUtaW5kZXggYTEgJiYKKwlHSVRfQVVUSE9SX0RBVEU9IjIwMDYtMTItMTIgMjM6MDA6MDYiIGdpdCBjb21taXQgLW0gRSAmJgogCi1naXQgY2hlY2tvdXQgLWIgRyBFICYmCi1naXQgcmV2LXBhcnNlIEEgPiAuZ2l0L01FUkdFX0hFQUQgJiYKLWVjaG8gRyA+IGExICYmCi1naXQgdXBkYXRlLWluZGV4IGExICYmCi1HSVRfQVVUSE9SX0RBVEU9IjIwMDYtMTItMTIgMjM6MDA6MDciIGdpdCBjb21taXQgLW0gRyAmJgorCWdpdCBjaGVja291dCAtYiBHIEUgJiYKKwlnaXQgcmV2LXBhcnNlIEEgPi5naXQvTUVSR0VfSEVBRCAmJgorCWVjaG8gRyA+YTEgJiYKKwlnaXQgdXBkYXRlLWluZGV4IGExICYmCisJR0lUX0FVVEhPUl9EQVRFPSIyMDA2LTEyLTEyIDIzOjAwOjA3IiBnaXQgY29tbWl0IC1tIEcgJiYKIAotZ2l0IGNoZWNrb3V0IC1iIEYgRCAmJgotZ2l0IHJldi1wYXJzZSBDID4gLmdpdC9NRVJHRV9IRUFEICYmCi1lY2hvIEYgPiBhMSAmJgotZ2l0IHVwZGF0ZS1pbmRleCBhMSAmJgotR0lUX0FVVEhPUl9EQVRFPSIyMDA2LTEyLTEyIDIzOjAwOjA4IiBnaXQgY29tbWl0IC1tIEYKKwlnaXQgY2hlY2tvdXQgLWIgRiBEICYmCisJZ2l0IHJldi1wYXJzZSBDID4uZ2l0L01FUkdFX0hFQUQgJiYKKwllY2hvIEYgPmExICYmCisJZ2l0IHVwZGF0ZS1pbmRleCBhMSAmJgorCUdJVF9BVVRIT1JfREFURT0iMjAwNi0xMi0xMiAyMzowMDowOCIgZ2l0IGNvbW1pdCAtbSBGCiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2NvbWJpbmVkIG1lcmdlIGNvbmZsaWN0cycgJwogCXRlc3RfbXVzdF9mYWlsIGVudiBHSVRfVEVTVF9DT01NSVRfR1JBUEg9MCBnaXQgbWVyZ2UgLW0gZmluYWwgRwogJwogCi1jYXQgPiBleHBlY3QgPDwgRU9GCi08PDw8PDw8IEhFQUQKLUYKLT09PT09PT0KLUcKLT4+Pj4+Pj4gRwotRU9GCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdyZXN1bHQgY29udGFpbnMgYSBjb25mbGljdCcgJworCWNhdCA+ZXhwZWN0IDw8LVxFT0YgJiYKKwk8PDw8PDw8IEhFQUQKKwlGCisJPT09PT09PQorCUcKKwk+Pj4+Pj4+IEcKKwlFT0YKIAotdGVzdF9leHBlY3Rfc3VjY2VzcyAicmVzdWx0IGNvbnRhaW5zIGEgY29uZmxpY3QiICJ0ZXN0X2NtcCBleHBlY3QgYTEiCisJdGVzdF9jbXAgZXhwZWN0IGExCisnCiAKLWdpdCBscy1maWxlcyAtLXN0YWdlID4gb3V0Ci1jYXQgPiBleHBlY3QgPDwgRU9GCi0xMDA2NDQgZWMzZmUyYTc5MTcwNjczM2YyZDhmYTdhZDQ1ZDlhOTY3MjAzMWY1ZSAxCWExCi0xMDA2NDQgY2Y4NDQ0M2U0OWUxYjM2NmZhYzkzODcxMWRkZjRiZTJkNGQxZDllOSAyCWExCi0xMDA2NDQgZmQ3OTIzNTI5ODU1ZDBiMjc0Nzk1YWUzMzQ5YzVlMDQzODMzMzk3OSAzCWExCi1FT0YKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3ZpcnR1YWwgdHJlZXMgd2VyZSBwcm9jZXNzZWQnICcKKwlnaXQgbHMtZmlsZXMgLS1zdGFnZSA+b3V0ICYmCiAKLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgInZpcnR1YWwgdHJlZXMgd2VyZSBwcm9jZXNzZWQiICJ0ZXN0X2NtcCBleHBlY3Qgb3V0IgorCWNhdCA+ZXhwZWN0IDw8LVxFT0YgJiYKKwkxMDA2NDQgZWMzZmUyYTc5MTcwNjczM2YyZDhmYTdhZDQ1ZDlhOTY3MjAzMWY1ZSAxCWExCisJMTAwNjQ0IGNmODQ0NDNlNDllMWIzNjZmYWM5Mzg3MTFkZGY0YmUyZDRkMWQ5ZTkgMglhMQorCTEwMDY0NCBmZDc5MjM1Mjk4NTVkMGIyNzQ3OTVhZTMzNDljNWUwNDM4MzMzOTc5IDMJYTEKKwlFT0YKKworCXRlc3RfY21wIGV4cGVjdCBvdXQKKycKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAncmVmdXNlIHRvIG1lcmdlIGJpbmFyeSBmaWxlcycgJwogCWdpdCByZXNldCAtLWhhcmQgJiYKLQlwcmludGYgIlwwIiA+IGJpbmFyeS1maWxlICYmCisJcHJpbnRmICJcMCIgPmJpbmFyeS1maWxlICYmCiAJZ2l0IGFkZCBiaW5hcnktZmlsZSAmJgogCWdpdCBjb21taXQgLW0gYmluYXJ5ICYmCiAJZ2l0IGNoZWNrb3V0IEcgJiYKLQlwcmludGYgIlwwXDAiID4gYmluYXJ5LWZpbGUgJiYKKwlwcmludGYgIlwwXDAiID5iaW5hcnktZmlsZSAmJgogCWdpdCBhZGQgYmluYXJ5LWZpbGUgJiYKIAlnaXQgY29tbWl0IC1tIGJpbmFyeTIgJiYKLQl0ZXN0X211c3RfZmFpbCBnaXQgbWVyZ2UgRiA+IG1lcmdlLm91dCAyPiBtZXJnZS5lcnIgJiYKKwl0ZXN0X211c3RfZmFpbCBnaXQgbWVyZ2UgRiA+bWVyZ2Uub3V0IDI+bWVyZ2UuZXJyICYmCiAJZ3JlcCAiQ2Fubm90IG1lcmdlIGJpbmFyeSBmaWxlczogYmluYXJ5LWZpbGUgKEhFQUQgdnMuIEYpIiBtZXJnZS5lcnIKICcKIApAQCAtMTE2LDcgKzEyMSw2IEBACiAJdGVzdCAxID0gJChnaXQgbHMtZmlsZXMgLS11bm1lcmdlZCB8IHdjIC1sKSAmJgogCXRlc3RfbXVzdF9mYWlsIGdpdCByZXYtcGFyc2UgLS12ZXJpZnkgOjI6YTIgJiYKIAlnaXQgcmV2LXBhcnNlIC0tdmVyaWZ5IDozOmEyCi0KICcKIAogdGVzdF9kb25lCmRpZmYgLS1naXQgYS90L3Q2MDM2LXJlY3Vyc2l2ZS1jb3JuZXItY2FzZXMuc2ggYi90L3Q2MDM2LXJlY3Vyc2l2ZS1jb3JuZXItY2FzZXMuc2gKaW5kZXggZDIzYjk0OC4uN2Q3M2FmZCAxMDA3NTUKLS0tIGEvdC90NjAzNi1yZWN1cnNpdmUtY29ybmVyLWNhc2VzLnNoCisrKyBiL3QvdDYwMzYtcmVjdXJzaXZlLWNvcm5lci1jYXNlcy5zaApAQCAtMTUzMiw3ICsxNTMyLDcgQEAKIAkJbXYgLWYgYl9SMSBiICYmCiAJCW12IC1mIGFfUjEgYSAmJgogCQlnaXQgYWRkIGIgYSAmJgotCQl0ZXN0X3RpY2sgJiYgZ2l0IGNvbW1pdCAtbSAidmVyc29uIFIxIG9mIGZpbGVzIiAmJgorCQl0ZXN0X3RpY2sgJiYgZ2l0IGNvbW1pdCAtbSAidmVyc2lvbiBSMSBvZiBmaWxlcyIgJiYKIAkJZ2l0IHRhZyBSMSAmJgogCiAJCSMgQ3JlYXRlIGZpcnN0IG1lcmdlIG9uIGxlZnQgc2lkZQpAQCAtMTU2Miw2ICsxNTYyLDcgQEAKIAkJY2QgbmVzdGVkX2NvbmZsaWN0cyAmJgogCiAJCWdpdCBjbGVhbiAtZiAmJgorCQlNQVNURVI9JChnaXQgcmV2LXBhcnNlIC0tc2hvcnQgbWFzdGVyKSAmJgogCQlnaXQgY2hlY2tvdXQgTDJeMCAmJgogCiAJCSMgTWVyZ2UgbXVzdCBmYWlsOyB0aGVyZSBpcyBhIGNvbmZsaWN0CkBAIC0xNTgyLDcgKzE1ODMsNyBAQAogCQlnaXQgY2F0LWZpbGUgLXAgUjE6YSA+dGhlaXJzICYmCiAJCXRlc3RfbXVzdF9mYWlsIGdpdCBtZXJnZS1maWxlIC0tZGlmZjMgXAogCQkJLUwgIlRlbXBvcmFyeSBtZXJnZSBicmFuY2ggMSIgXAotCQkJLUwgIm1lcmdlZCBjb21tb24gYW5jZXN0b3JzIiAgXAorCQkJLUwgIiRNQVNURVIiICBcCiAJCQktTCAiVGVtcG9yYXJ5IG1lcmdlIGJyYW5jaCAyIiBcCiAJCQlvdXJzICBcCiAJCQliYXNlICBcCkBAIC0xNTk0LDcgKzE1OTUsNyBAQAogCQlnaXQgY2F0LWZpbGUgLXAgUjE6YiA+dGhlaXJzICYmCiAJCXRlc3RfbXVzdF9mYWlsIGdpdCBtZXJnZS1maWxlIC0tZGlmZjMgXAogCQkJLUwgIlRlbXBvcmFyeSBtZXJnZSBicmFuY2ggMSIgXAotCQkJLUwgIm1lcmdlZCBjb21tb24gYW5jZXN0b3JzIiAgXAorCQkJLUwgIiRNQVNURVIiICBcCiAJCQktTCAiVGVtcG9yYXJ5IG1lcmdlIGJyYW5jaCAyIiBcCiAJCQlvdXJzICBcCiAJCQliYXNlICBcCkBAIC0xNjk1LDcgKzE2OTYsNyBAQAogCQlnaXQgY2hlY2tvdXQgUiAmJgogCQllY2hvIHJpZ2h0ID4+Y29udGVudCAmJgogCQlnaXQgYWRkIGNvbnRlbnQgJiYKLQkJdGVzdF90aWNrICYmIGdpdCBjb21taXQgLW0gInZlcnNvbiBSMSBvZiBjb250ZW50IiAmJgorCQl0ZXN0X3RpY2sgJiYgZ2l0IGNvbW1pdCAtbSAidmVyc2lvbiBSMSBvZiBjb250ZW50IiAmJgogCQlnaXQgdGFnIFIxICYmCiAKIAkJIyBDcmVhdGUgTDIKQEAgLTE3MzIsNiArMTczMyw3IEBACiAJKAogCQljZCB2aXJ0dWFsX21lcmdlX2Jhc2VfaGFzX25lc3RlZF9jb25mbGljdHMgJiYKIAorCQlNQVNURVI9JChnaXQgcmV2LXBhcnNlIC0tc2hvcnQgbWFzdGVyKSAmJgogCQlnaXQgY2hlY2tvdXQgTDNeMCAmJgogCiAJCSMgTWVyZ2UgbXVzdCBmYWlsOyB0aGVyZSBpcyBhIGNvbmZsaWN0CkBAIC0xNzYwLDcgKzE3NjIsNyBAQAogCQljcCBsZWZ0IG1lcmdlZC1vbmNlICYmCiAJCXRlc3RfbXVzdF9mYWlsIGdpdCBtZXJnZS1maWxlIC0tZGlmZjMgXAogCQkJLUwgIlRlbXBvcmFyeSBtZXJnZSBicmFuY2ggMSIgXAotCQkJLUwgIm1lcmdlZCBjb21tb24gYW5jZXN0b3JzIiAgXAorCQkJLUwgIiRNQVNURVIiICBcCiAJCQktTCAiVGVtcG9yYXJ5IG1lcmdlIGJyYW5jaCAyIiBcCiAJCQltZXJnZWQtb25jZSBcCiAJCQliYXNlICAgICAgICBcCmRpZmYgLS1naXQgYS90L3Q2MDQyLW1lcmdlLXJlbmFtZS1jb3JuZXItY2FzZXMuc2ggYi90L3Q2MDQyLW1lcmdlLXJlbmFtZS1jb3JuZXItY2FzZXMuc2gKaW5kZXggYzViNTdmNC4uYjA0N2NmMSAxMDA3NTUKLS0tIGEvdC90NjA0Mi1tZXJnZS1yZW5hbWUtY29ybmVyLWNhc2VzLnNoCisrKyBiL3QvdDYwNDItbWVyZ2UtcmVuYW1lLWNvcm5lci1jYXNlcy5zaApAQCAtNSw3ICs1LDcgQEAKIAogLiAuL3Rlc3QtbGliLnNoCiAKLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3NldHVwIHJlbmFtZS9kZWxldGUgKyB1bnRyYWNrZWQgZmlsZScgJwordGVzdF9zZXR1cF9yZW5hbWVfZGVsZXRlX3VudHJhY2tlZCAoKSB7CiAJdGVzdF9jcmVhdGVfcmVwbyByZW5hbWUtZGVsZXRlLXVudHJhY2tlZCAmJgogCSgKIAkJY2QgcmVuYW1lLWRlbGV0ZS11bnRyYWNrZWQgJiYKQEAgLTI5LDkgKzI5LDEwIEBACiAJCWdpdCBjb21taXQgLW0gdHJhY2stcGVvcGxlLWluc3RlYWQtb2Ytb2JqZWN0cyAmJgogCQllY2hvICJNeXl5IFBSRUNJT1VTU1MiID5yaW5nCiAJKQotJworfQogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICJEb2VzIGdpdCBwcmVzZXJ2ZSBHb2xsdW0ncyBwcmVjaW91cyBhcnRpZmFjdD8iICcKKwl0ZXN0X3NldHVwX3JlbmFtZV9kZWxldGVfdW50cmFja2VkICYmCiAJKAogCQljZCByZW5hbWUtZGVsZXRlLXVudHJhY2tlZCAmJgogCkBAIC00OSw3ICs1MCw3IEBACiAjCiAjIFdlIHNob3VsZCBiZSBhYmxlIHRvIG1lcmdlIEIgJiBDIGNsZWFubHkKIAotdGVzdF9leHBlY3Rfc3VjY2VzcyAnc2V0dXAgcmVuYW1lL21vZGlmeS9hZGQtc291cmNlIGNvbmZsaWN0JyAnCit0ZXN0X3NldHVwX3JlbmFtZV9tb2RpZnlfYWRkX3NvdXJjZSAoKSB7CiAJdGVzdF9jcmVhdGVfcmVwbyByZW5hbWUtbW9kaWZ5LWFkZC1zb3VyY2UgJiYKIAkoCiAJCWNkIHJlbmFtZS1tb2RpZnktYWRkLXNvdXJjZSAmJgpAQCAtNzAsOSArNzEsMTAgQEAKIAkJZ2l0IGFkZCBhICYmCiAJCWdpdCBjb21taXQgLW0gQwogCSkKLScKK30KIAogdGVzdF9leHBlY3RfZmFpbHVyZSAncmVuYW1lL21vZGlmeS9hZGQtc291cmNlIGNvbmZsaWN0IHJlc29sdmFibGUnICcKKwl0ZXN0X3NldHVwX3JlbmFtZV9tb2RpZnlfYWRkX3NvdXJjZSAmJgogCSgKIAkJY2QgcmVuYW1lLW1vZGlmeS1hZGQtc291cmNlICYmCiAKQEAgLTg4LDcgKzkwLDcgQEAKIAkpCiAnCiAKLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3NldHVwIHJlc29sdmFibGUgY29uZmxpY3QgbWlzc2VkIGlmIHJlbmFtZSBtaXNzZWQnICcKK3Rlc3Rfc2V0dXBfYnJlYWtfZGV0ZWN0aW9uXzEgKCkgewogCXRlc3RfY3JlYXRlX3JlcG8gYnJlYWstZGV0ZWN0aW9uLTEgJiYKIAkoCiAJCWNkIGJyZWFrLWRldGVjdGlvbi0xICYmCkBAIC0xMTAsOSArMTEyLDEwIEBACiAJCWdpdCBhZGQgYSAmJgogCQlnaXQgY29tbWl0IC1tIEMKIAkpCi0nCit9CiAKIHRlc3RfZXhwZWN0X2ZhaWx1cmUgJ2NvbmZsaWN0IGNhdXNlZCBpZiByZW5hbWUgbm90IGRldGVjdGVkJyAnCisJdGVzdF9zZXR1cF9icmVha19kZXRlY3Rpb25fMSAmJgogCSgKIAkJY2QgYnJlYWstZGV0ZWN0aW9uLTEgJiYKIApAQCAtMTM1LDcgKzEzOCw3IEBACiAJKQogJwogCi10ZXN0X2V4cGVjdF9zdWNjZXNzICdzZXR1cCBjb25mbGljdCByZXNvbHZlZCB3cm9uZyBpZiByZW5hbWUgbWlzc2VkJyAnCit0ZXN0X3NldHVwX2JyZWFrX2RldGVjdGlvbl8yICgpIHsKIAl0ZXN0X2NyZWF0ZV9yZXBvIGJyZWFrLWRldGVjdGlvbi0yICYmCiAJKAogCQljZCBicmVhay1kZXRlY3Rpb24tMiAmJgpAQCAtMTYwLDkgKzE2MywxMCBAQAogCQlnaXQgYWRkIGEgJiYKIAkJZ2l0IGNvbW1pdCAtbSBFCiAJKQotJworfQogCiB0ZXN0X2V4cGVjdF9mYWlsdXJlICdtaXNzZWQgY29uZmxpY3QgaWYgcmVuYW1lIG5vdCBkZXRlY3RlZCcgJworCXRlc3Rfc2V0dXBfYnJlYWtfZGV0ZWN0aW9uXzIgJiYKIAkoCiAJCWNkIGJyZWFrLWRldGVjdGlvbi0yICYmCiAKQEAgLTE4Miw3ICsxODYsNyBAQAogIyAgIENvbW1pdCBCOiByZW5hbWUgYS0+YgogIyAgIENvbW1pdCBDOiByZW5hbWUgYS0+YiwgYWRkIHVucmVsYXRlZCBhCiAKLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3NldHVwIHVuZGV0ZWN0ZWQgcmVuYW1lL2FkZC1zb3VyY2UgY2F1c2VzIGRhdGEgbG9zcycgJwordGVzdF9zZXR1cF9icmVha19kZXRlY3Rpb25fMyAoKSB7CiAJdGVzdF9jcmVhdGVfcmVwbyBicmVhay1kZXRlY3Rpb24tMyAmJgogCSgKIAkJY2QgYnJlYWstZGV0ZWN0aW9uLTMgJiYKQEAgLTIwMiw5ICsyMDYsMTAgQEAKIAkJZ2l0IGFkZCBhICYmCiAJCWdpdCBjb21taXQgLW0gQwogCSkKLScKK30KIAogdGVzdF9leHBlY3RfZmFpbHVyZSAnZGV0ZWN0IHJlbmFtZS9hZGQtc291cmNlIGFuZCBwcmVzZXJ2ZSBhbGwgZGF0YScgJworCXRlc3Rfc2V0dXBfYnJlYWtfZGV0ZWN0aW9uXzMgJiYKIAkoCiAJCWNkIGJyZWFrLWRldGVjdGlvbi0zICYmCiAKQEAgLTIzMSw2ICsyMzYsNyBAQAogJwogCiB0ZXN0X2V4cGVjdF9mYWlsdXJlICdkZXRlY3QgcmVuYW1lL2FkZC1zb3VyY2UgYW5kIHByZXNlcnZlIGFsbCBkYXRhLCBtZXJnZSBvdGhlciB3YXknICcKKwl0ZXN0X3NldHVwX2JyZWFrX2RldGVjdGlvbl8zICYmCiAJKAogCQljZCBicmVhay1kZXRlY3Rpb24tMyAmJgogCkBAIC0yNTYsMTAgKzI2MiwxMCBAQAogCSkKICcKIAotdGVzdF9leHBlY3Rfc3VjY2VzcyAnc2V0dXAgY29udGVudCBtZXJnZSArIHJlbmFtZS9kaXJlY3RvcnkgY29uZmxpY3QnICcKLQl0ZXN0X2NyZWF0ZV9yZXBvIHJlbmFtZS1kaXJlY3RvcnktMSAmJgordGVzdF9zZXR1cF9yZW5hbWVfZGlyZWN0b3J5ICgpIHsKKwl0ZXN0X2NyZWF0ZV9yZXBvIHJlbmFtZS1kaXJlY3RvcnktJDEgJiYKIAkoCi0JCWNkIHJlbmFtZS1kaXJlY3RvcnktMSAmJgorCQljZCByZW5hbWUtZGlyZWN0b3J5LSQxICYmCiAKIAkJcHJpbnRmICIxXG4yXG4zXG40XG41XG42XG4iID5maWxlICYmCiAJCWdpdCBhZGQgZmlsZSAmJgpAQCAtMjkwLDExICsyOTYsMTIgQEAKIAkJdGVzdF90aWNrICYmCiAJCWdpdCBjb21taXQgLW0gbGVmdAogCSkKLScKK30KIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAncmVuYW1lL2RpcmVjdG9yeSBjb25mbGljdCArIGNsZWFuIGNvbnRlbnQgbWVyZ2UnICcKKwl0ZXN0X3NldHVwX3JlbmFtZV9kaXJlY3RvcnkgMWEgJiYKIAkoCi0JCWNkIHJlbmFtZS1kaXJlY3RvcnktMSAmJgorCQljZCByZW5hbWUtZGlyZWN0b3J5LTFhICYmCiAKIAkJZ2l0IGNoZWNrb3V0IGxlZnQtY2xlYW5eMCAmJgogCkBAIC0zMjAsOCArMzI3LDkgQEAKICcKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAncmVuYW1lL2RpcmVjdG9yeSBjb25mbGljdCArIGNvbnRlbnQgbWVyZ2UgY29uZmxpY3QnICcKKwl0ZXN0X3NldHVwX3JlbmFtZV9kaXJlY3RvcnkgMWIgJiYKIAkoCi0JCWNkIHJlbmFtZS1kaXJlY3RvcnktMSAmJgorCQljZCByZW5hbWUtZGlyZWN0b3J5LTFiICYmCiAKIAkJZ2l0IHJlc2V0IC0taGFyZCAmJgogCQlnaXQgY2xlYW4gLWZkcXggJiYKQEAgLTM1OCw3ICszNjYsNyBAQAogCSkKICcKIAotdGVzdF9leHBlY3Rfc3VjY2VzcyAnc2V0dXAgY29udGVudCBtZXJnZSArIHJlbmFtZS9kaXJlY3RvcnkgY29uZmxpY3Qgdy8gZGlzYXBwZWFyaW5nIGRpcicgJwordGVzdF9zZXR1cF9yZW5hbWVfZGlyZWN0b3J5XzIgKCkgewogCXRlc3RfY3JlYXRlX3JlcG8gcmVuYW1lLWRpcmVjdG9yeS0yICYmCiAJKAogCQljZCByZW5hbWUtZGlyZWN0b3J5LTIgJiYKQEAgLTM4NSw5ICszOTMsMTAgQEAKIAkJdGVzdF90aWNrICYmCiAJCWdpdCBjb21taXQgLW0gbGVmdAogCSkKLScKK30KIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnZGlzYXBwZWFyaW5nIGRpciBpbiByZW5hbWUvZGlyZWN0b3J5IGNvbmZsaWN0IGhhbmRsZWQnICcKKwl0ZXN0X3NldHVwX3JlbmFtZV9kaXJlY3RvcnlfMiAmJgogCSgKIAkJY2QgcmVuYW1lLWRpcmVjdG9yeS0yICYmCiAKQEAgLTQxNiwxMCArNDI1LDEwIEBACiAjICAgQ29tbWl0IEE6IHJlbmFtZSBhLT5iLCBtb2RpZnlpbmcgYiB0b28KICMgICBDb21taXQgQjogbW9kaWZ5IGEsIGFkZCBkaWZmZXJlbnQgYgogCi10ZXN0X2V4cGVjdF9zdWNjZXNzICdzZXR1cCByZW5hbWUtd2l0aC1jb250ZW50LW1lcmdlIHZzLiBhZGQnICcKLQl0ZXN0X2NyZWF0ZV9yZXBvIHJlbmFtZS13aXRoLWNvbnRlbnQtbWVyZ2UtYW5kLWFkZCAmJgordGVzdF9zZXR1cF9yZW5hbWVfd2l0aF9jb250ZW50X21lcmdlX2FuZF9hZGQgKCkgeworCXRlc3RfY3JlYXRlX3JlcG8gcmVuYW1lLXdpdGgtY29udGVudC1tZXJnZS1hbmQtYWRkLSQxICYmCiAJKAotCQljZCByZW5hbWUtd2l0aC1jb250ZW50LW1lcmdlLWFuZC1hZGQgJiYKKwkJY2QgcmVuYW1lLXdpdGgtY29udGVudC1tZXJnZS1hbmQtYWRkLSQxICYmCiAKIAkJdGVzdF9zZXEgMSA1ID5hICYmCiAJCWdpdCBhZGQgYSAmJgpAQCAtNDM4LDExICs0NDcsMTIgQEAKIAkJZ2l0IGFkZCBhIGIgJiYKIAkJZ2l0IGNvbW1pdCAtbSBCCiAJKQotJworfQogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdoYW5kbGUgcmVuYW1lLXdpdGgtY29udGVudC1tZXJnZSB2cy4gYWRkJyAnCisJdGVzdF9zZXR1cF9yZW5hbWVfd2l0aF9jb250ZW50X21lcmdlX2FuZF9hZGQgQUIgJiYKIAkoCi0JCWNkIHJlbmFtZS13aXRoLWNvbnRlbnQtbWVyZ2UtYW5kLWFkZCAmJgorCQljZCByZW5hbWUtd2l0aC1jb250ZW50LW1lcmdlLWFuZC1hZGQtQUIgJiYKIAogCQlnaXQgY2hlY2tvdXQgQV4wICYmCiAKQEAgLTQ4Myw4ICs0OTMsOSBAQAogJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdoYW5kbGUgcmVuYW1lLXdpdGgtY29udGVudC1tZXJnZSB2cy4gYWRkLCBtZXJnZSBvdGhlciB3YXknICcKKwl0ZXN0X3NldHVwX3JlbmFtZV93aXRoX2NvbnRlbnRfbWVyZ2VfYW5kX2FkZCBCQSAmJgogCSgKLQkJY2QgcmVuYW1lLXdpdGgtY29udGVudC1tZXJnZS1hbmQtYWRkICYmCisJCWNkIHJlbmFtZS13aXRoLWNvbnRlbnQtbWVyZ2UtYW5kLWFkZC1CQSAmJgogCiAJCWdpdCByZXNldCAtLWhhcmQgJiYKIAkJZ2l0IGNsZWFuIC1mZHggJiYKQEAgLTUzOSw3ICs1NTAsNyBAQAogIyAgICogVGhlIHdvcmtpbmcgY29weSBzaG91bGQgaGF2ZSB0d28gZmlsZXMsIGJvdGggb2YgZm9ybSBjfjx1bmlxdWU+OyBkb2VzIGl0PwogIyAgICogTm90aGluZyBlbHNlIHNob3VsZCBiZSBwcmVzZW50LiAgSXMgYW55dGhpbmc/CiAKLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3NldHVwIHJlbmFtZS9yZW5hbWUgKDJ0bzEpICsgbW9kaWZ5L21vZGlmeScgJwordGVzdF9zZXR1cF9yZW5hbWVfcmVuYW1lXzJ0bzEgKCkgewogCXRlc3RfY3JlYXRlX3JlcG8gcmVuYW1lLXJlbmFtZS0ydG8xICYmCiAJKAogCQljZCByZW5hbWUtcmVuYW1lLTJ0bzEgJiYKQEAgLTU2Miw5ICs1NzMsMTAgQEAKIAkJZ2l0IGFkZCBhICYmCiAJCWdpdCBjb21taXQgLW0gQwogCSkKLScKK30KIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnaGFuZGxlIHJlbmFtZS9yZW5hbWUgKDJ0bzEpIGNvbmZsaWN0IGNvcnJlY3RseScgJworCXRlc3Rfc2V0dXBfcmVuYW1lX3JlbmFtZV8ydG8xICYmCiAJKAogCQljZCByZW5hbWUtcmVuYW1lLTJ0bzEgJiYKIApAQCAtNjEwLDcgKzYyMiw3IEBACiAjICAgQ29tbWl0IEE6IG5ldyBmaWxlOiBhCiAjICAgQ29tbWl0IEI6IHJlbmFtZSBhLT5iCiAjICAgQ29tbWl0IEM6IHJlbmFtZSBhLT5jCi10ZXN0X2V4cGVjdF9zdWNjZXNzICdzZXR1cCBzaW1wbGUgcmVuYW1lL3JlbmFtZSAoMXRvMikgY29uZmxpY3QnICcKK3Rlc3Rfc2V0dXBfcmVuYW1lX3JlbmFtZV8xdG8yICgpIHsKIAl0ZXN0X2NyZWF0ZV9yZXBvIHJlbmFtZS1yZW5hbWUtMXRvMiAmJgogCSgKIAkJY2QgcmVuYW1lLXJlbmFtZS0xdG8yICYmCkBAIC02MzEsOSArNjQzLDEwIEBACiAJCXRlc3RfdGljayAmJgogCQlnaXQgY29tbWl0IC1tIEMKIAkpCi0nCit9CiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ21lcmdlIGhhcyBjb3JyZWN0IHdvcmtpbmcgdHJlZSBjb250ZW50cycgJworCXRlc3Rfc2V0dXBfcmVuYW1lX3JlbmFtZV8xdG8yICYmCiAJKAogCQljZCByZW5hbWUtcmVuYW1lLTF0bzIgJiYKIApAQCAtNjY3LDcgKzY4MCw3IEBACiAjCiAjIE1lcmdpbmcgb2YgQiAmIEMgc2hvdWxkIE5PVCBiZSBjbGVhbjsgdGhlcmUncyBhIHJlbmFtZS9yZW5hbWUgY29uZmxpY3QKIAotdGVzdF9leHBlY3Rfc3VjY2VzcyAnc2V0dXAgcmVuYW1lL3JlbmFtZSgxdG8yKS9hZGQtc291cmNlIGNvbmZsaWN0JyAnCit0ZXN0X3NldHVwX3JlbmFtZV9yZW5hbWVfMXRvMl9hZGRfc291cmNlXzEgKCkgewogCXRlc3RfY3JlYXRlX3JlcG8gcmVuYW1lLXJlbmFtZS0xdG8yLWFkZC1zb3VyY2UtMSAmJgogCSgKIAkJY2QgcmVuYW1lLXJlbmFtZS0xdG8yLWFkZC1zb3VyY2UtMSAmJgpAQCAtNjg3LDkgKzcwMCwxMCBAQAogCQlnaXQgYWRkIGEgJiYKIAkJZ2l0IGNvbW1pdCAtbSBDCiAJKQotJworfQogCiB0ZXN0X2V4cGVjdF9mYWlsdXJlICdkZXRlY3QgY29uZmxpY3Qgd2l0aCByZW5hbWUvcmVuYW1lKDF0bzIpL2FkZC1zb3VyY2UgbWVyZ2UnICcKKwl0ZXN0X3NldHVwX3JlbmFtZV9yZW5hbWVfMXRvMl9hZGRfc291cmNlXzEgJiYKIAkoCiAJCWNkIHJlbmFtZS1yZW5hbWUtMXRvMi1hZGQtc291cmNlLTEgJiYKIApAQCAtNzE0LDcgKzcyOCw3IEBACiAJKQogJwogCi10ZXN0X2V4cGVjdF9zdWNjZXNzICdzZXR1cCByZW5hbWUvcmVuYW1lKDF0bzIpL2FkZC1zb3VyY2UgcmVzb2x2YWJsZSBjb25mbGljdCcgJwordGVzdF9zZXR1cF9yZW5hbWVfcmVuYW1lXzF0bzJfYWRkX3NvdXJjZV8yICgpIHsKIAl0ZXN0X2NyZWF0ZV9yZXBvIHJlbmFtZS1yZW5hbWUtMXRvMi1hZGQtc291cmNlLTIgJiYKIAkoCiAJCWNkIHJlbmFtZS1yZW5hbWUtMXRvMi1hZGQtc291cmNlLTIgJiYKQEAgLTczNyw5ICs3NTEsMTAgQEAKIAkJdGVzdF90aWNrICYmCiAJCWdpdCBjb21taXQgLW0gdHdvCiAJKQotJworfQogCiB0ZXN0X2V4cGVjdF9mYWlsdXJlICdyZW5hbWUvcmVuYW1lL2FkZC1zb3VyY2Ugc3RpbGwgdHJhY2tzIG5ldyBhIGZpbGUnICcKKwl0ZXN0X3NldHVwX3JlbmFtZV9yZW5hbWVfMXRvMl9hZGRfc291cmNlXzIgJiYKIAkoCiAJCWNkIHJlbmFtZS1yZW5hbWUtMXRvMi1hZGQtc291cmNlLTIgJiYKIApAQCAtNzU5LDcgKzc3NCw3IEBACiAJKQogJwogCi10ZXN0X2V4cGVjdF9zdWNjZXNzICdzZXR1cCByZW5hbWUvcmVuYW1lKDF0bzIpL2FkZC1kZXN0IGNvbmZsaWN0JyAnCit0ZXN0X3NldHVwX3JlbmFtZV9yZW5hbWVfMXRvMl9hZGRfZGVzdCAoKSB7CiAJdGVzdF9jcmVhdGVfcmVwbyByZW5hbWUtcmVuYW1lLTF0bzItYWRkLWRlc3QgJiYKIAkoCiAJCWNkIHJlbmFtZS1yZW5hbWUtMXRvMi1hZGQtZGVzdCAmJgpAQCAtNzg0LDkgKzc5OSwxMCBAQAogCQl0ZXN0X3RpY2sgJiYKIAkJZ2l0IGNvbW1pdCAtbSB0d28KIAkpCi0nCit9CiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3JlbmFtZS9yZW5hbWUvYWRkLWRlc3QgbWVyZ2Ugc3RpbGwga25vd3MgYWJvdXQgY29uZmxpY3RpbmcgZmlsZSB2ZXJzaW9ucycgJworCXRlc3Rfc2V0dXBfcmVuYW1lX3JlbmFtZV8xdG8yX2FkZF9kZXN0ICYmCiAJKAogCQljZCByZW5hbWUtcmVuYW1lLTF0bzItYWRkLWRlc3QgJiYKIApAQCAtODM4LDcgKzg1NCw3IEBACiAjICAgQ29tbWl0IEI6IHJlbmFtZSBmb28tPmJhcgogIyAgIEV4cGVjdGVkOiBDT05GTElDVCAocmVuYW1lL2FkZC9kZWxldGUpLCB0d28td2F5IG1lcmdlZCBiYXIKIAotdGVzdF9leHBlY3Rfc3VjY2VzcyAncmFkLXNldHVwOiByZW5hbWUvYWRkL2RlbGV0ZSBjb25mbGljdCcgJwordGVzdF9zZXR1cF9yYWQgKCkgewogCXRlc3RfY3JlYXRlX3JlcG8gcmFkICYmCiAJKAogCQljZCByYWQgJiYKQEAgLTg2MCw5ICs4NzYsMTAgQEAKIAkJZ2l0IG12IGZvbyBiYXIgJiYKIAkJZ2l0IGNvbW1pdCAtbSAicmVuYW1lIGZvbyB0byBiYXIiCiAJKQotJworfQogCiB0ZXN0X2V4cGVjdF9mYWlsdXJlICdyYWQtY2hlY2s6IHJlbmFtZS9hZGQvZGVsZXRlIGNvbmZsaWN0JyAnCisJdGVzdF9zZXR1cF9yYWQgJiYKIAkoCiAJCWNkIHJhZCAmJgogCkBAIC05MDQsNyArOTIxLDcgQEAKICMgICBDb21taXQgQjogcmVuYW1lIGJhci0+YmF6LCBybSBmb28KICMgICBFeHBlY3RlZDogQ09ORkxJQ1QgKHJlbmFtZS9yZW5hbWUvZGVsZXRlL2RlbGV0ZSksIHR3by13YXkgbWVyZ2VkIGJhegogCi10ZXN0X2V4cGVjdF9zdWNjZXNzICdycmRkLXNldHVwOiByZW5hbWUvcmVuYW1lKDJ0bzEpL2RlbGV0ZS9kZWxldGUgY29uZmxpY3QnICcKK3Rlc3Rfc2V0dXBfcnJkZCAoKSB7CiAJdGVzdF9jcmVhdGVfcmVwbyBycmRkICYmCiAJKAogCQljZCBycmRkICYmCkBAIC05MjcsOSArOTQ0LDEwIEBACiAJCWdpdCBybSBmb28gJiYKIAkJZ2l0IGNvbW1pdCAtbSAiUmVuYW1lIGJhciwgcmVtb3ZlIGZvbyIKIAkpCi0nCit9CiAKIHRlc3RfZXhwZWN0X2ZhaWx1cmUgJ3JyZGQtY2hlY2s6IHJlbmFtZS9yZW5hbWUoMnRvMSkvZGVsZXRlL2RlbGV0ZSBjb25mbGljdCcgJworCXRlc3Rfc2V0dXBfcnJkZCAmJgogCSgKIAkJY2QgcnJkZCAmJgogCkBAIC05NzMsNyArOTkxLDcgQEAKICMgICBFeHBlY3RlZDogc2l4IENPTkZMSUNUKHJlbmFtZS9yZW5hbWUpIG1lc3NhZ2VzLCBlYWNoIHBhdGggaW4gdHdvIG9mIHRoZQogIyAgICAgICAgICAgICBtdWx0aS13YXkgbWVyZ2VkIGNvbnRlbnRzIGZvdW5kIGluIHR3bywgZm91ciwgc2l4CiAKLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ21vZDYtc2V0dXA6IGNoYWlucyBvZiByZW5hbWUvcmVuYW1lKDF0bzIpIGFuZCByZW5hbWUvcmVuYW1lKDJ0bzEpJyAnCit0ZXN0X3NldHVwX21vZDYgKCkgewogCXRlc3RfY3JlYXRlX3JlcG8gbW9kNiAmJgogCSgKIAkJY2QgbW9kNiAmJgpAQCAtMTAwOSw5ICsxMDI3LDEwIEBACiAJCXRlc3RfdGljayAmJgogCQlnaXQgY29tbWl0IC1tICJCIgogCSkKLScKK30KIAogdGVzdF9leHBlY3RfZmFpbHVyZSAnbW9kNi1jaGVjazogY2hhaW5zIG9mIHJlbmFtZS9yZW5hbWUoMXRvMikgYW5kIHJlbmFtZS9yZW5hbWUoMnRvMSknICcKKwl0ZXN0X3NldHVwX21vZDYgJiYKIAkoCiAJCWNkIG1vZDYgJiYKIApAQCAtMTEwOCw3ICsxMTI3LDggQEAKIAkjICAgICAgZmlsZXMuICBJcyBpdCBwcmVzZW50PwogCSMgICA0KSBUaGVyZSBzaG91bGQgbm90IGJlIGFueSB0aHJlZX4qIGZpbGVzIGluIHRoZSB3b3JraW5nCiAJIyAgICAgIHRyZWUKLQl0ZXN0X2V4cGVjdF9zdWNjZXNzICJzZXR1cCBzaW1wbGUgJHNpZGVMLyRzaWRlUiBjb25mbGljdCIgJworCXRlc3Rfc2V0dXBfY29sbGlzaW9uX2NvbmZsaWN0ICgpIHsKKwkjdGVzdF9leHBlY3Rfc3VjY2VzcyAic2V0dXAgc2ltcGxlICRzaWRlTC8kc2lkZVIgY29uZmxpY3QiICcKIAkJdGVzdF9jcmVhdGVfcmVwbyBzaW1wbGVfJHtzaWRlTH1fJHtzaWRlUn0gJiYKIAkJKAogCQkJY2Qgc2ltcGxlXyR7c2lkZUx9XyR7c2lkZVJ9ICYmCkBAIC0xMTg1LDkgKzEyMDUsMTEgQEAKIAkJCWZpICYmCiAJCQl0ZXN0X3RpY2sgJiYgZ2l0IGNvbW1pdCAtbSBSCiAJCSkKLQknCisJIycKKwl9CiAKIAl0ZXN0X2V4cGVjdF9zdWNjZXNzICJjaGVjayBzaW1wbGUgJHNpZGVMLyRzaWRlUiBjb25mbGljdCIgJworCQl0ZXN0X3NldHVwX2NvbGxpc2lvbl9jb25mbGljdCAmJgogCQkoCiAJCQljZCBzaW1wbGVfJHtzaWRlTH1fJHtzaWRlUn0gJiYKIApAQCAtMTI1NCw3ICsxMjc2LDcgQEAKICMKICMgICBTbywgd2UgaGF2ZSBmb3VyIGRpZmZlcmVudCBjb25mbGljdGluZyBmaWxlcyB0aGF0IGFsbCBlbmQgdXAgYXQgcGF0aAogIyAgICd0aHJlZScuCi10ZXN0X2V4cGVjdF9zdWNjZXNzICdzZXR1cCBuZXN0ZWQgY29uZmxpY3RzIGZyb20gcmVuYW1lL3JlbmFtZSgydG8xKScgJwordGVzdF9zZXR1cF9uZXN0ZWRfY29uZmxpY3RzX2Zyb21fcmVuYW1lX3JlbmFtZSAoKSB7CiAJdGVzdF9jcmVhdGVfcmVwbyBuZXN0ZWRfY29uZmxpY3RzX2Zyb21fcmVuYW1lX3JlbmFtZSAmJgogCSgKIAkJY2QgbmVzdGVkX2NvbmZsaWN0c19mcm9tX3JlbmFtZV9yZW5hbWUgJiYKQEAgLTEzMDUsOSArMTMyNywxMCBAQAogCQlnaXQgYWRkIG9uZSB0aHJlZSAmJgogCQl0ZXN0X3RpY2sgJiYgZ2l0IGNvbW1pdCAtbSBnZXJtYW4KIAkpCi0nCit9CiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2NoZWNrIG5lc3RlZCBjb25mbGljdHMgZnJvbSByZW5hbWUvcmVuYW1lKDJ0bzEpJyAnCisJdGVzdF9zZXR1cF9uZXN0ZWRfY29uZmxpY3RzX2Zyb21fcmVuYW1lX3JlbmFtZSAmJgogCSgKIAkJY2QgbmVzdGVkX2NvbmZsaWN0c19mcm9tX3JlbmFtZV9yZW5hbWUgJiYKIApkaWZmIC0tZ2l0IGEvdC90NjA0My1tZXJnZS1yZW5hbWUtZGlyZWN0b3JpZXMuc2ggYi90L3Q2MDQzLW1lcmdlLXJlbmFtZS1kaXJlY3Rvcmllcy5zaAppbmRleCBjOTY2MTQ3Li44Mzc5MmM1IDEwMDc1NQotLS0gYS90L3Q2MDQzLW1lcmdlLXJlbmFtZS1kaXJlY3Rvcmllcy5zaAorKysgYi90L3Q2MDQzLW1lcmdlLXJlbmFtZS1kaXJlY3Rvcmllcy5zaApAQCAtMzgsNyArMzgsNyBAQAogIyAgIENvbW1pdCBCOiB6L3tiLGMsZCxlL2Z9CiAjICAgRXhwZWN0ZWQ6IHkve2IsYyxkLGUvZn0KIAotdGVzdF9leHBlY3Rfc3VjY2VzcyAnMWEtc2V0dXA6IFNpbXBsZSBkaXJlY3RvcnkgcmVuYW1lIGRldGVjdGlvbicgJwordGVzdF9zZXR1cF8xYSAoKSB7CiAJdGVzdF9jcmVhdGVfcmVwbyAxYSAmJgogCSgKIAkJY2QgMWEgJiYKQEAgLTY3LDkgKzY3LDEwIEBACiAJCXRlc3RfdGljayAmJgogCQlnaXQgY29tbWl0IC1tICJCIgogCSkKLScKK30KIAotdGVzdF9leHBlY3Rfc3VjY2VzcyAnMWEtY2hlY2s6IFNpbXBsZSBkaXJlY3RvcnkgcmVuYW1lIGRldGVjdGlvbicgJwordGVzdF9leHBlY3Rfc3VjY2VzcyAnMWE6IFNpbXBsZSBkaXJlY3RvcnkgcmVuYW1lIGRldGVjdGlvbicgJworCXRlc3Rfc2V0dXBfMWEgJiYKIAkoCiAJCWNkIDFhICYmCiAKQEAgLTEwMyw3ICsxMDQsNyBAQAogIyAgIENvbW1pdCBCOiB5L3tiLGMsZH0KICMgICBFeHBlY3RlZDogeS97YixjLGQsZX0KIAotdGVzdF9leHBlY3Rfc3VjY2VzcyAnMWItc2V0dXA6IE1lcmdlIGEgZGlyZWN0b3J5IHdpdGggYW5vdGhlcicgJwordGVzdF9zZXR1cF8xYiAoKSB7CiAJdGVzdF9jcmVhdGVfcmVwbyAxYiAmJgogCSgKIAkJY2QgMWIgJiYKQEAgLTEzNCw5ICsxMzUsMTAgQEAKIAkJdGVzdF90aWNrICYmCiAJCWdpdCBjb21taXQgLW0gIkIiCiAJKQotJworfQogCi10ZXN0X2V4cGVjdF9zdWNjZXNzICcxYi1jaGVjazogTWVyZ2UgYSBkaXJlY3Rvcnkgd2l0aCBhbm90aGVyJyAnCit0ZXN0X2V4cGVjdF9zdWNjZXNzICcxYjogTWVyZ2UgYSBkaXJlY3Rvcnkgd2l0aCBhbm90aGVyJyAnCisJdGVzdF9zZXR1cF8xYiAmJgogCSgKIAkJY2QgMWIgJiYKIApAQCAtMTY1LDcgKzE2Nyw3IEBACiAjICAgQ29tbWl0IEI6IHove2IsYyxkfQogIyAgIEV4cGVjdGVkOiB5L3tiLGMsZH0gIChiZWNhdXNlIHgvZCAtPiB6L2QgLT4geS9kKQogCi10ZXN0X2V4cGVjdF9zdWNjZXNzICcxYy1zZXR1cDogVHJhbnNpdGl2ZSByZW5hbWluZycgJwordGVzdF9zZXR1cF8xYyAoKSB7CiAJdGVzdF9jcmVhdGVfcmVwbyAxYyAmJgogCSgKIAkJY2QgMWMgJiYKQEAgLTE5Myw5ICsxOTUsMTAgQEAKIAkJdGVzdF90aWNrICYmCiAJCWdpdCBjb21taXQgLW0gIkIiCiAJKQotJworfQogCi10ZXN0X2V4cGVjdF9zdWNjZXNzICcxYy1jaGVjazogVHJhbnNpdGl2ZSByZW5hbWluZycgJwordGVzdF9leHBlY3Rfc3VjY2VzcyAnMWM6IFRyYW5zaXRpdmUgcmVuYW1pbmcnICcKKwl0ZXN0X3NldHVwXzFjICYmCiAJKAogCQljZCAxYyAmJgogCkBAIC0yMjcsNyArMjMwLDcgQEAKICMgICBOb3RlOiB5L20gJiB6L24gc2hvdWxkIGRlZmluaXRlbHkgbW92ZSBpbnRvIHguICBCeSB0aGUgc2FtZSB0b2tlbiwgYm90aAogIyAgICAgICAgIHkvd2hhbV8xICYgei93aGFtXzIgc2hvdWxkIHRvby4uLmdpdmluZyB1cyBhIGNvbmZsaWN0LgogCi10ZXN0X2V4cGVjdF9zdWNjZXNzICcxZC1zZXR1cDogRGlyZWN0b3J5IHJlbmFtZXMgY2F1c2UgYSByZW5hbWUvcmVuYW1lKDJ0bzEpIGNvbmZsaWN0JyAnCit0ZXN0X3NldHVwXzFkICgpIHsKIAl0ZXN0X2NyZWF0ZV9yZXBvIDFkICYmCiAJKAogCQljZCAxZCAmJgpAQCAtMjYyLDkgKzI2NSwxMCBAQAogCQl0ZXN0X3RpY2sgJiYKIAkJZ2l0IGNvbW1pdCAtbSAiQiIKIAkpCi0nCit9CiAKLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJzFkLWNoZWNrOiBEaXJlY3RvcnkgcmVuYW1lcyBjYXVzZSBhIHJlbmFtZS9yZW5hbWUoMnRvMSkgY29uZmxpY3QnICcKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJzFkOiBEaXJlY3RvcnkgcmVuYW1lcyBjYXVzZSBhIHJlbmFtZS9yZW5hbWUoMnRvMSkgY29uZmxpY3QnICcKKwl0ZXN0X3NldHVwXzFkICYmCiAJKAogCQljZCAxZCAmJgogCkBAIC0zMTMsNyArMzE3LDcgQEAKICMgICBDb21taXQgQjogei97b2xkYixvbGRjLGR9CiAjICAgRXhwZWN0ZWQ6IHkve25ld2IsbmV3YyxkfQogCi10ZXN0X2V4cGVjdF9zdWNjZXNzICcxZS1zZXR1cDogUmVuYW1lZCBkaXJlY3RvcnksIHdpdGggYWxsIGZpbGVzIGJlaW5nIHJlbmFtZWQgdG9vJyAnCit0ZXN0X3NldHVwXzFlICgpIHsKIAl0ZXN0X2NyZWF0ZV9yZXBvIDFlICYmCiAJKAogCQljZCAxZSAmJgpAQCAtMzQyLDkgKzM0NiwxMCBAQAogCQl0ZXN0X3RpY2sgJiYKIAkJZ2l0IGNvbW1pdCAtbSAiQiIKIAkpCi0nCit9CiAKLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJzFlLWNoZWNrOiBSZW5hbWVkIGRpcmVjdG9yeSwgd2l0aCBhbGwgZmlsZXMgYmVpbmcgcmVuYW1lZCB0b28nICcKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJzFlOiBSZW5hbWVkIGRpcmVjdG9yeSwgd2l0aCBhbGwgZmlsZXMgYmVpbmcgcmVuYW1lZCB0b28nICcKKwl0ZXN0X3NldHVwXzFlICYmCiAJKAogCQljZCAxZSAmJgogCkBAIC0zNzEsNyArMzc2LDcgQEAKICMgICBDb21taXQgQjogeS97YixjfSwgeC97ZCxlLGZ9CiAjICAgRXhwZWN0ZWQ6IHkve2IsY30sIHgve2QsZSxmLGd9CiAKLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJzFmLXNldHVwOiBTcGxpdCBhIGRpcmVjdG9yeSBpbnRvIHR3byBvdGhlciBkaXJlY3RvcmllcycgJwordGVzdF9zZXR1cF8xZiAoKSB7CiAJdGVzdF9jcmVhdGVfcmVwbyAxZiAmJgogCSgKIAkJY2QgMWYgJiYKQEAgLTQwOCw5ICs0MTMsMTAgQEAKIAkJdGVzdF90aWNrICYmCiAJCWdpdCBjb21taXQgLW0gIkIiCiAJKQotJworfQogCi10ZXN0X2V4cGVjdF9zdWNjZXNzICcxZi1jaGVjazogU3BsaXQgYSBkaXJlY3RvcnkgaW50byB0d28gb3RoZXIgZGlyZWN0b3JpZXMnICcKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJzFmOiBTcGxpdCBhIGRpcmVjdG9yeSBpbnRvIHR3byBvdGhlciBkaXJlY3RvcmllcycgJworCXRlc3Rfc2V0dXBfMWYgJiYKIAkoCiAJCWNkIDFmICYmCiAKQEAgLTQ1OSw3ICs0NjUsNyBAQAogIyAgIENvbW1pdCBBOiB5L2IsIHcvYwogIyAgIENvbW1pdCBCOiB6L3tiLGMsZH0KICMgICBFeHBlY3RlZDogeS9iLCB3L2MsIHovZCwgd2l0aCB3YXJuaW5nIGFib3V0IHovIC0+ICh5LyB2cy4gdy8pIGNvbmZsaWN0Ci10ZXN0X2V4cGVjdF9zdWNjZXNzICcyYS1zZXR1cDogRGlyZWN0b3J5IHNwbGl0IGludG8gdHdvIG9uIG9uZSBzaWRlLCB3aXRoIGVxdWFsIG51bWJlcnMgb2YgcGF0aHMnICcKK3Rlc3Rfc2V0dXBfMmEgKCkgewogCXRlc3RfY3JlYXRlX3JlcG8gMmEgJiYKIAkoCiAJCWNkIDJhICYmCkBAIC00ODksOSArNDk1LDEwIEBACiAJCXRlc3RfdGljayAmJgogCQlnaXQgY29tbWl0IC1tICJCIgogCSkKLScKK30KIAotdGVzdF9leHBlY3Rfc3VjY2VzcyAnMmEtY2hlY2s6IERpcmVjdG9yeSBzcGxpdCBpbnRvIHR3byBvbiBvbmUgc2lkZSwgd2l0aCBlcXVhbCBudW1iZXJzIG9mIHBhdGhzJyAnCit0ZXN0X2V4cGVjdF9zdWNjZXNzICcyYTogRGlyZWN0b3J5IHNwbGl0IGludG8gdHdvIG9uIG9uZSBzaWRlLCB3aXRoIGVxdWFsIG51bWJlcnMgb2YgcGF0aHMnICcKKwl0ZXN0X3NldHVwXzJhICYmCiAJKAogCQljZCAyYSAmJgogCkBAIC01MjAsNyArNTI3LDcgQEAKICMgICBDb21taXQgQTogeS9iLCB3L2MKICMgICBDb21taXQgQjogei97YixjfSwgeC9kCiAjICAgRXhwZWN0ZWQ6IHkvYiwgdy9jLCB4L2Q7IE5vIHdhcm5pbmcgYWJvdXQgei8gLT4gKHkvIHZzLiB3LykgY29uZmxpY3QKLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJzJiLXNldHVwOiBEaXJlY3Rvcnkgc3BsaXQgaW50byB0d28gb24gb25lIHNpZGUsIHdpdGggZXF1YWwgbnVtYmVycyBvZiBwYXRocycgJwordGVzdF9zZXR1cF8yYiAoKSB7CiAJdGVzdF9jcmVhdGVfcmVwbyAyYiAmJgogCSgKIAkJY2QgMmIgJiYKQEAgLTU1MSw5ICs1NTgsMTAgQEAKIAkJdGVzdF90aWNrICYmCiAJCWdpdCBjb21taXQgLW0gIkIiCiAJKQotJworfQogCi10ZXN0X2V4cGVjdF9zdWNjZXNzICcyYi1jaGVjazogRGlyZWN0b3J5IHNwbGl0IGludG8gdHdvIG9uIG9uZSBzaWRlLCB3aXRoIGVxdWFsIG51bWJlcnMgb2YgcGF0aHMnICcKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJzJiOiBEaXJlY3Rvcnkgc3BsaXQgaW50byB0d28gb24gb25lIHNpZGUsIHdpdGggZXF1YWwgbnVtYmVycyBvZiBwYXRocycgJworCXRlc3Rfc2V0dXBfMmIgJiYKIAkoCiAJCWNkIDJiICYmCiAKQEAgLTYwMSw3ICs2MDksNyBAQAogIyAgIENvbW1pdCBBOiB6L3tiLGMsZH0gKG5vIGNoYW5nZSkKICMgICBDb21taXQgQjogeS97YixjfSwgeC9kCiAjICAgRXhwZWN0ZWQ6IHkve2IsY30sIHgvZAotdGVzdF9leHBlY3Rfc3VjY2VzcyAnM2Etc2V0dXA6IEF2b2lkIGltcGxpY2l0IHJlbmFtZSBpZiBpbnZvbHZlZCBhcyBzb3VyY2Ugb24gb3RoZXIgc2lkZScgJwordGVzdF9zZXR1cF8zYSAoKSB7CiAJdGVzdF9jcmVhdGVfcmVwbyAzYSAmJgogCSgKIAkJY2QgM2EgJiYKQEAgLTYzMiw5ICs2NDAsMTAgQEAKIAkJdGVzdF90aWNrICYmCiAJCWdpdCBjb21taXQgLW0gIkIiCiAJKQotJworfQogCi10ZXN0X2V4cGVjdF9zdWNjZXNzICczYS1jaGVjazogQXZvaWQgaW1wbGljaXQgcmVuYW1lIGlmIGludm9sdmVkIGFzIHNvdXJjZSBvbiBvdGhlciBzaWRlJyAnCit0ZXN0X2V4cGVjdF9zdWNjZXNzICczYTogQXZvaWQgaW1wbGljaXQgcmVuYW1lIGlmIGludm9sdmVkIGFzIHNvdXJjZSBvbiBvdGhlciBzaWRlJyAnCisJdGVzdF9zZXR1cF8zYSAmJgogCSgKIAkJY2QgM2EgJiYKIApAQCAtNjY0LDcgKzY3Myw3IEBACiAjICAgICAgICAgZ2V0IGl0IGludm9sdmVkIGluIGRpcmVjdG9yeSByZW5hbWUgZGV0ZWN0aW9uLiAgSWYgaXQgd2VyZSwgd2UgbWlnaHQKICMgICAgICAgICBlbmQgdXAgd2l0aCBDT05GTElDVDooei9kIC0+IHkvZCB2cy4geC9kIHZzLiB3L2QpLCBpLmUuIGEKICMgICAgICAgICByZW5hbWUvcmVuYW1lL3JlbmFtZSgxdG8zKSBjb25mbGljdCwgd2hpY2ggaXMganVzdCB3ZWlyZC4KLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJzNiLXNldHVwOiBBdm9pZCBpbXBsaWNpdCByZW5hbWUgaWYgaW52b2x2ZWQgYXMgc291cmNlIG9uIGN1cnJlbnQgc2lkZScgJwordGVzdF9zZXR1cF8zYiAoKSB7CiAJdGVzdF9jcmVhdGVfcmVwbyAzYiAmJgogCSgKIAkJY2QgM2IgJiYKQEAgLTY5Nyw5ICs3MDYsMTAgQEAKIAkJdGVzdF90aWNrICYmCiAJCWdpdCBjb21taXQgLW0gIkIiCiAJKQotJworfQogCi10ZXN0X2V4cGVjdF9zdWNjZXNzICczYi1jaGVjazogQXZvaWQgaW1wbGljaXQgcmVuYW1lIGlmIGludm9sdmVkIGFzIHNvdXJjZSBvbiBjdXJyZW50IHNpZGUnICcKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJzNiOiBBdm9pZCBpbXBsaWNpdCByZW5hbWUgaWYgaW52b2x2ZWQgYXMgc291cmNlIG9uIGN1cnJlbnQgc2lkZScgJworCXRlc3Rfc2V0dXBfM2IgJiYKIAkoCiAJCWNkIDNiICYmCiAKQEAgLTc0NCw3ICs3NTQsNyBAQAogIwogIyBXaGF0IGlmIHdlIHdlcmUgdG8gYXR0ZW1wdCB0byBkbyBkaXJlY3RvcnkgcmVuYW1lIGRldGVjdGlvbiB3aGVuIHNvbWVvbmUKICMgIm1vc3RseSIgbW92ZWQgYSBkaXJlY3RvcnkgYnV0IHN0aWxsIGxlZnQgc29tZSBmaWxlcyBhcm91bmQsIG9yLAotIyBlcXVpdmFsZW50bHksIGZ1bGx5IHJlbmFtZWQgYSBkaXJlY3RvcnkgaW4gb25lIGNvbW1taXQgYW5kIHRoZW4gcmVjcmVhdGVkCisjIGVxdWl2YWxlbnRseSwgZnVsbHkgcmVuYW1lZCBhIGRpcmVjdG9yeSBpbiBvbmUgY29tbWl0IGFuZCB0aGVuIHJlY3JlYXRlZAogIyB0aGF0IGRpcmVjdG9yeSBpbiBhIGxhdGVyIGNvbW1pdCBhZGRpbmcgc29tZSBuZXcgZmlsZXMgYW5kIHRoZW4gdHJpZWQgdG8KICMgbWVyZ2U/CiAjCkBAIC03ODYsNyArNzk2LDcgQEAKICMgICBFeHBlY3RlZDogeS97YixjLGR9LCB6L3tlLGZ9CiAjICAgTk9URTogRXZlbiB0aG91Z2ggbW9zdCBmaWxlcyBmcm9tIHogbW92ZWQgdG8geSwgd2UgZG9uJ3Qgd2FudCBmIHRvIGZvbGxvdy4KIAotdGVzdF9leHBlY3Rfc3VjY2VzcyAnNGEtc2V0dXA6IERpcmVjdG9yeSBzcGxpdCwgd2l0aCBvcmlnaW5hbCBkaXJlY3Rvcnkgc3RpbGwgcHJlc2VudCcgJwordGVzdF9zZXR1cF80YSAoKSB7CiAJdGVzdF9jcmVhdGVfcmVwbyA0YSAmJgogCSgKIAkJY2QgNGEgJiYKQEAgLTgxOCw5ICs4MjgsMTAgQEAKIAkJdGVzdF90aWNrICYmCiAJCWdpdCBjb21taXQgLW0gIkIiCiAJKQotJworfQogCi10ZXN0X2V4cGVjdF9zdWNjZXNzICc0YS1jaGVjazogRGlyZWN0b3J5IHNwbGl0LCB3aXRoIG9yaWdpbmFsIGRpcmVjdG9yeSBzdGlsbCBwcmVzZW50JyAnCit0ZXN0X2V4cGVjdF9zdWNjZXNzICc0YTogRGlyZWN0b3J5IHNwbGl0LCB3aXRoIG9yaWdpbmFsIGRpcmVjdG9yeSBzdGlsbCBwcmVzZW50JyAnCisJdGVzdF9zZXR1cF80YSAmJgogCSgKIAkJY2QgNGEgJiYKIApAQCAtODc0LDcgKzg4NSw3IEBACiAjICAgICAgICAgb2YgaGlzdG9yeSwgZ2l2aW5nIHVzIG5vIHdheSB0byByZXByZXNlbnQgdGhpcyBjb25mbGljdCBpbiB0aGUKICMgICAgICAgICBpbmRleC4KIAotdGVzdF9leHBlY3Rfc3VjY2VzcyAnNWEtc2V0dXA6IE1lcmdlIGRpcmVjdG9yaWVzLCBvdGhlciBzaWRlIGFkZHMgZmlsZXMgdG8gb3JpZ2luYWwgYW5kIHRhcmdldCcgJwordGVzdF9zZXR1cF81YSAoKSB7CiAJdGVzdF9jcmVhdGVfcmVwbyA1YSAmJgogCSgKIAkJY2QgNWEgJiYKQEAgLTkwNyw5ICs5MTgsMTAgQEAKIAkJdGVzdF90aWNrICYmCiAJCWdpdCBjb21taXQgLW0gIkIiCiAJKQotJworfQogCi10ZXN0X2V4cGVjdF9zdWNjZXNzICc1YS1jaGVjazogTWVyZ2UgZGlyZWN0b3JpZXMsIG90aGVyIHNpZGUgYWRkcyBmaWxlcyB0byBvcmlnaW5hbCBhbmQgdGFyZ2V0JyAnCit0ZXN0X2V4cGVjdF9zdWNjZXNzICc1YTogTWVyZ2UgZGlyZWN0b3JpZXMsIG90aGVyIHNpZGUgYWRkcyBmaWxlcyB0byBvcmlnaW5hbCBhbmQgdGFyZ2V0JyAnCisJdGVzdF9zZXR1cF81YSAmJgogCSgKIAkJY2QgNWEgJiYKIApAQCAtOTQxLDE0ICs5NTMsMTQgQEAKICMgICBDb21taXQgQjogei97YixjLGRfMSxlfSwgeS9kXzMKICMgICBFeHBlY3RlZDogeS97YixjLGV9LCBDT05GTElDVChhZGQvYWRkOiB5L2RfMiB2cy4geS9kXzMpCiAjICAgTk9URTogSWYgei9kXzEgaW4gY29tbWl0IEIgd2VyZSB0byBiZSBpbnZvbHZlZCBpbiBkaXIgcmVuYW1lIGRldGVjdGlvbiwgYXMKLSMgICAgICAgICB3ZSBub3JtYWx5IHdvdWxkIHNpbmNlIHovIGlzIGJlaW5nIHJlbmFtZWQgdG8geS8sIHRoZW4gdGhpcyB3b3VsZCBiZQorIyAgICAgICAgIHdlIG5vcm1hbGx5IHdvdWxkIHNpbmNlIHovIGlzIGJlaW5nIHJlbmFtZWQgdG8geS8sIHRoZW4gdGhpcyB3b3VsZCBiZQogIyAgICAgICAgIGEgcmVuYW1lL2RlbGV0ZSAoei9kXzEgLT4geS9kXzEgdnMuIGRlbGV0ZWQpIEFORCBhbiBhZGQvYWRkL2FkZAogIyAgICAgICAgIGNvbmZsaWN0IG9mIHkvZF8xIHZzLiB5L2RfMiB2cy4geS9kXzMuICBBZGQvYWRkL2FkZCBpcyBub3QKICMgICAgICAgICByZXByZXNlbnRhYmxlIGluIHRoZSBpbmRleCwgc28gdGhlIGV4aXN0ZW5jZSBvZiB5L2RfMyBuZWVkcyB0bwogIyAgICAgICAgIGNhdXNlIHVzIHRvIGJhaWwgb24gZGlyZWN0b3J5IHJlbmFtZSBkZXRlY3Rpb24gZm9yIHRoYXQgcGF0aCwgZmFsbGluZwogIyAgICAgICAgIGJhY2sgdG8gZ2l0IGJlaGF2aW9yIHdpdGhvdXQgdGhlIGRpcmVjdG9yeSByZW5hbWUgZGV0ZWN0aW9uLgogCi10ZXN0X2V4cGVjdF9zdWNjZXNzICc1Yi1zZXR1cDogUmVuYW1lL2RlbGV0ZSBpbiBvcmRlciB0byBnZXQgYWRkL2FkZC9hZGQgY29uZmxpY3QnICcKK3Rlc3Rfc2V0dXBfNWIgKCkgewogCXRlc3RfY3JlYXRlX3JlcG8gNWIgJiYKIAkoCiAJCWNkIDViICYmCkBAIC05ODEsOSArOTkzLDEwIEBACiAJCXRlc3RfdGljayAmJgogCQlnaXQgY29tbWl0IC1tICJCIgogCSkKLScKK30KIAotdGVzdF9leHBlY3Rfc3VjY2VzcyAnNWItY2hlY2s6IFJlbmFtZS9kZWxldGUgaW4gb3JkZXIgdG8gZ2V0IGFkZC9hZGQvYWRkIGNvbmZsaWN0JyAnCit0ZXN0X2V4cGVjdF9zdWNjZXNzICc1YjogUmVuYW1lL2RlbGV0ZSBpbiBvcmRlciB0byBnZXQgYWRkL2FkZC9hZGQgY29uZmxpY3QnICcKKwl0ZXN0X3NldHVwXzViICYmCiAJKAogCQljZCA1YiAmJgogCkBAIC0xMDI0LDcgKzEwMzcsNyBAQAogIyAgICAgICAgICAgICB5L2QgYXJlIHkvZF8yIGFuZCB5L2RfNC4gIFdlIHN0aWxsIGRvIHRoZSBtb3ZlIGZyb20gei9lIHRvIHkvZSwKICMgICAgICAgICAgICAgdGhvdWdoLCBiZWNhdXNlIGl0IGRvZXNuJ3QgaGF2ZSBhbnl0aGluZyBpbiB0aGUgd2F5LgogCi10ZXN0X2V4cGVjdF9zdWNjZXNzICc1Yy1zZXR1cDogVHJhbnNpdGl2ZSByZW5hbWUgd291bGQgY2F1c2UgcmVuYW1lL3JlbmFtZS9yZW5hbWUvYWRkL2FkZC9hZGQnICcKK3Rlc3Rfc2V0dXBfNWMgKCkgewogCXRlc3RfY3JlYXRlX3JlcG8gNWMgJiYKIAkoCiAJCWNkIDVjICYmCkBAIC0xMDYxLDkgKzEwNzQsMTAgQEAKIAkJdGVzdF90aWNrICYmCiAJCWdpdCBjb21taXQgLW0gIkIiCiAJKQotJworfQogCi10ZXN0X2V4cGVjdF9zdWNjZXNzICc1Yy1jaGVjazogVHJhbnNpdGl2ZSByZW5hbWUgd291bGQgY2F1c2UgcmVuYW1lL3JlbmFtZS9yZW5hbWUvYWRkL2FkZC9hZGQnICcKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJzVjOiBUcmFuc2l0aXZlIHJlbmFtZSB3b3VsZCBjYXVzZSByZW5hbWUvcmVuYW1lL3JlbmFtZS9hZGQvYWRkL2FkZCcgJworCXRlc3Rfc2V0dXBfNWMgJiYKIAkoCiAJCWNkIDVjICYmCiAKQEAgLTExMTMsNyArMTEyNyw3IEBACiAjICAgICAgICAgZGV0ZWN0aW9uIGZvciB6L2RfMiwgYnV0IHRoYXQgZG9lc24ndCBwcmV2ZW50IHVzIGZyb20gYXBwbHlpbmcgdGhlCiAjICAgICAgICAgZGlyZWN0b3J5IHJlbmFtZSBkZXRlY3Rpb24gZm9yIHovZiAtPiB5L2YuCiAKLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJzVkLXNldHVwOiBEaXJlY3RvcnkvZmlsZS9maWxlIGNvbmZsaWN0IGR1ZSB0byBkaXJlY3RvcnkgcmVuYW1lJyAnCit0ZXN0X3NldHVwXzVkICgpIHsKIAl0ZXN0X2NyZWF0ZV9yZXBvIDVkICYmCiAJKAogCQljZCA1ZCAmJgpAQCAtMTE0NSw5ICsxMTU5LDEwIEBACiAJCXRlc3RfdGljayAmJgogCQlnaXQgY29tbWl0IC1tICJCIgogCSkKLScKK30KIAotdGVzdF9leHBlY3Rfc3VjY2VzcyAnNWQtY2hlY2s6IERpcmVjdG9yeS9maWxlL2ZpbGUgY29uZmxpY3QgZHVlIHRvIGRpcmVjdG9yeSByZW5hbWUnICcKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJzVkOiBEaXJlY3RvcnkvZmlsZS9maWxlIGNvbmZsaWN0IGR1ZSB0byBkaXJlY3RvcnkgcmVuYW1lJyAnCisJdGVzdF9zZXR1cF81ZCAmJgogCSgKIAkJY2QgNWQgJiYKIApAQCAtMTIwNSw3ICsxMjIwLDcgQEAKICMgICAgICAgICB0aGVtIHVuZGVyIHkvIGRvZXNuJ3QgYWNjaWRlbnRhbGx5IGNhdGNoIHovZCBhbmQgbWFrZSBpdCBsb29rIGxpa2UKICMgICAgICAgICBpdCBpcyBhbHNvIGludm9sdmVkIGluIGEgcmVuYW1lL2RlbGV0ZSBjb25mbGljdC4KIAotdGVzdF9leHBlY3Rfc3VjY2VzcyAnNmEtc2V0dXA6IFRyaWNreSByZW5hbWUvZGVsZXRlJyAnCit0ZXN0X3NldHVwXzZhICgpIHsKIAl0ZXN0X2NyZWF0ZV9yZXBvIDZhICYmCiAJKAogCQljZCA2YSAmJgpAQCAtMTIzNSw5ICsxMjUwLDEwIEBACiAJCXRlc3RfdGljayAmJgogCQlnaXQgY29tbWl0IC1tICJCIgogCSkKLScKK30KIAotdGVzdF9leHBlY3Rfc3VjY2VzcyAnNmEtY2hlY2s6IFRyaWNreSByZW5hbWUvZGVsZXRlJyAnCit0ZXN0X2V4cGVjdF9zdWNjZXNzICc2YTogVHJpY2t5IHJlbmFtZS9kZWxldGUnICcKKwl0ZXN0X3NldHVwXzZhICYmCiAJKAogCQljZCA2YSAmJgogCkBAIC0xMjcxLDcgKzEyODcsNyBAQAogIyAgICAgICAgIGJ1dCBCIGRpZCB0aGF0IHJlbmFtZSBhbmQgc3RpbGwgZGVjaWRlZCB0byBwdXQgdGhlIGZpbGUgaW50byB6LywKICMgICAgICAgICBzbyB3ZSBwcm9iYWJseSBzaG91bGRuJ3QgYXBwbHkgZGlyZWN0b3J5IHJlbmFtZSBkZXRlY3Rpb24gZm9yIGl0LgogCi10ZXN0X2V4cGVjdF9zdWNjZXNzICc2Yi1zZXR1cDogU2FtZSByZW5hbWUgZG9uZSBvbiBib3RoIHNpZGVzJyAnCit0ZXN0X3NldHVwXzZiICgpIHsKIAl0ZXN0X2NyZWF0ZV9yZXBvIDZiICYmCiAJKAogCQljZCA2YiAmJgpAQCAtMTMwMCw5ICsxMzE2LDEwIEBACiAJCXRlc3RfdGljayAmJgogCQlnaXQgY29tbWl0IC1tICJCIgogCSkKLScKK30KIAotdGVzdF9leHBlY3Rfc3VjY2VzcyAnNmItY2hlY2s6IFNhbWUgcmVuYW1lIGRvbmUgb24gYm90aCBzaWRlcycgJwordGVzdF9leHBlY3Rfc3VjY2VzcyAnNmI6IFNhbWUgcmVuYW1lIGRvbmUgb24gYm90aCBzaWRlcycgJworCXRlc3Rfc2V0dXBfNmIgJiYKIAkoCiAJCWNkIDZiICYmCiAKQEAgLTEzMzQsNyArMTM1MSw3IEBACiAjICAgTk9URTogU2VlbXMgb2J2aW91cywgYnV0IGp1c3QgY2hlY2tpbmcgdGhhdCB0aGUgaW1wbGVtZW50YXRpb24gZG9lc24ndAogIyAgICAgICAgICJhY2NpZGVudGFsbHkgZGV0ZWN0IGEgcmVuYW1lIiBhbmQgZ2l2ZSB1cyB5L3tiLGMsZH0uCiAKLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJzZjLXNldHVwOiBSZW5hbWUgb25seSBkb25lIG9uIHNhbWUgc2lkZScgJwordGVzdF9zZXR1cF82YyAoKSB7CiAJdGVzdF9jcmVhdGVfcmVwbyA2YyAmJgogCSgKIAkJY2QgNmMgJiYKQEAgLTEzNjIsOSArMTM3OSwxMCBAQAogCQl0ZXN0X3RpY2sgJiYKIAkJZ2l0IGNvbW1pdCAtbSAiQiIKIAkpCi0nCit9CiAKLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJzZjLWNoZWNrOiBSZW5hbWUgb25seSBkb25lIG9uIHNhbWUgc2lkZScgJwordGVzdF9leHBlY3Rfc3VjY2VzcyAnNmM6IFJlbmFtZSBvbmx5IGRvbmUgb24gc2FtZSBzaWRlJyAnCisJdGVzdF9zZXR1cF82YyAmJgogCSgKIAkJY2QgNmMgJiYKIApAQCAtMTM5Niw3ICsxNDE0LDcgQEAKICMgICBOT1RFOiBBZ2FpbiwgdGhpcyBzZWVtcyBvYnZpb3VzIGJ1dCBqdXN0IGNoZWNraW5nIHRoYXQgdGhlIGltcGxlbWVudGF0aW9uCiAjICAgICAgICAgZG9lc24ndCAiYWNjaWRlbnRhbGx5IGRldGVjdCBhIHJlbmFtZSIgYW5kIGdpdmUgdXMgeS97YixjLGR9LgogCi10ZXN0X2V4cGVjdF9zdWNjZXNzICc2ZC1zZXR1cDogV2UgZG8gbm90IGFsd2F5cyB3YW50IHRyYW5zaXRpdmUgcmVuYW1pbmcnICcKK3Rlc3Rfc2V0dXBfNmQgKCkgewogCXRlc3RfY3JlYXRlX3JlcG8gNmQgJiYKIAkoCiAJCWNkIDZkICYmCkBAIC0xNDI0LDkgKzE0NDIsMTAgQEAKIAkJdGVzdF90aWNrICYmCiAJCWdpdCBjb21taXQgLW0gIkIiCiAJKQotJworfQogCi10ZXN0X2V4cGVjdF9zdWNjZXNzICc2ZC1jaGVjazogV2UgZG8gbm90IGFsd2F5cyB3YW50IHRyYW5zaXRpdmUgcmVuYW1pbmcnICcKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJzZkOiBXZSBkbyBub3QgYWx3YXlzIHdhbnQgdHJhbnNpdGl2ZSByZW5hbWluZycgJworCXRlc3Rfc2V0dXBfNmQgJiYKIAkoCiAJCWNkIDZkICYmCiAKQEAgLTE0NTgsNyArMTQ3Nyw3IEBACiAjICAgICAgICAgZG9lc24ndCAiYWNjaWRlbnRhbGx5IGRldGVjdCBhIHJlbmFtZSIgYW5kIGdpdmUgdXMgeS97YixjfSArCiAjICAgICAgICAgYWRkL2FkZCBjb25mbGljdCBvbiB5L2RfMSB2cyB5L2RfMi4KIAotdGVzdF9leHBlY3Rfc3VjY2VzcyAnNmUtc2V0dXA6IEFkZC9hZGQgZnJvbSBvbmUgc2lkZScgJwordGVzdF9zZXR1cF82ZSAoKSB7CiAJdGVzdF9jcmVhdGVfcmVwbyA2ZSAmJgogCSgKIAkJY2QgNmUgJiYKQEAgLTE0ODcsOSArMTUwNiwxMCBAQAogCQl0ZXN0X3RpY2sgJiYKIAkJZ2l0IGNvbW1pdCAtbSAiQiIKIAkpCi0nCit9CiAKLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJzZlLWNoZWNrOiBBZGQvYWRkIGZyb20gb25lIHNpZGUnICcKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJzZlOiBBZGQvYWRkIGZyb20gb25lIHNpZGUnICcKKwl0ZXN0X3NldHVwXzZlICYmCiAJKAogCQljZCA2ZSAmJgogCkBAIC0xNTUyLDcgKzE1NzIsNyBAQAogIyAgIEV4cGVjdGVkOiB5L2QsIENPTkZMSUNUKHJlbmFtZS9yZW5hbWUgZm9yIGJvdGggei9iIGFuZCB6L2MpCiAjICAgTk9URTogVGhlcmUncyBhIHJlbmFtZSBvZiB6LyBoZXJlLCB5LyBoYXMgbW9yZSByZW5hbWVzLCBzbyB6L2QgLT4geS9kLgogCi10ZXN0X2V4cGVjdF9zdWNjZXNzICc3YS1zZXR1cDogcmVuYW1lLWRpciB2cy4gcmVuYW1lLWRpciAoTk9UIHNwbGl0IGV2ZW5seSkgUExVUyBhZGQtb3RoZXItZmlsZScgJwordGVzdF9zZXR1cF83YSAoKSB7CiAJdGVzdF9jcmVhdGVfcmVwbyA3YSAmJgogCSgKIAkJY2QgN2EgJiYKQEAgLTE1ODMsOSArMTYwMywxMCBAQAogCQl0ZXN0X3RpY2sgJiYKIAkJZ2l0IGNvbW1pdCAtbSAiQiIKIAkpCi0nCit9CiAKLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJzdhLWNoZWNrOiByZW5hbWUtZGlyIHZzLiByZW5hbWUtZGlyIChOT1Qgc3BsaXQgZXZlbmx5KSBQTFVTIGFkZC1vdGhlci1maWxlJyAnCit0ZXN0X2V4cGVjdF9zdWNjZXNzICc3YTogcmVuYW1lLWRpciB2cy4gcmVuYW1lLWRpciAoTk9UIHNwbGl0IGV2ZW5seSkgUExVUyBhZGQtb3RoZXItZmlsZScgJworCXRlc3Rfc2V0dXBfN2EgJiYKIAkoCiAJCWNkIDdhICYmCiAKQEAgLTE2MjMsNyArMTY0NCw3IEBACiAjICAgQ29tbWl0IEI6IHove2IsYyxkXzF9LCAgICAgICAgdy9kXzIKICMgICBFeHBlY3RlZDogeS97YixjfSwgQ09ORkxJQ1QocmVuYW1lL3JlbmFtZSgydG8xKTogeC9kXzEsIHcvZF8yIC0+IHlfZCkKIAotdGVzdF9leHBlY3Rfc3VjY2VzcyAnN2Itc2V0dXA6IHJlbmFtZS9yZW5hbWUoMnRvMSksIGJ1dCBvbmx5IGR1ZSB0byB0cmFuc2l0aXZlIHJlbmFtZScgJwordGVzdF9zZXR1cF83YiAoKSB7CiAJdGVzdF9jcmVhdGVfcmVwbyA3YiAmJgogCSgKIAkJY2QgN2IgJiYKQEAgLTE2NTUsOSArMTY3NiwxMCBAQAogCQl0ZXN0X3RpY2sgJiYKIAkJZ2l0IGNvbW1pdCAtbSAiQiIKIAkpCi0nCit9CiAKLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJzdiLWNoZWNrOiByZW5hbWUvcmVuYW1lKDJ0bzEpLCBidXQgb25seSBkdWUgdG8gdHJhbnNpdGl2ZSByZW5hbWUnICcKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJzdiOiByZW5hbWUvcmVuYW1lKDJ0bzEpLCBidXQgb25seSBkdWUgdG8gdHJhbnNpdGl2ZSByZW5hbWUnICcKKwl0ZXN0X3NldHVwXzdiICYmCiAJKAogCQljZCA3YiAmJgogCkBAIC0xNzAyLDcgKzE3MjQsNyBAQAogIyAgICAgICAgIG5laXRoZXIgQ09ORkxJQ1QoeC9kIC0+IHcvZCB2cy4gei9kKQogIyAgICAgICAgIG5vciBDT05GTGlDVCB4L2QgLT4gdy9kIHZzLiB5L2QgdnMuIHovZCkKIAotdGVzdF9leHBlY3Rfc3VjY2VzcyAnN2Mtc2V0dXA6IHJlbmFtZS9yZW5hbWUoMXRvLi4uMm9yMyk7IHRyYW5zaXRpdmUgcmVuYW1lIG1heSBhZGQgY29tcGxleGl0eScgJwordGVzdF9zZXR1cF83YyAoKSB7CiAJdGVzdF9jcmVhdGVfcmVwbyA3YyAmJgogCSgKIAkJY2QgN2MgJiYKQEAgLTE3MzIsOSArMTc1NCwxMCBAQAogCQl0ZXN0X3RpY2sgJiYKIAkJZ2l0IGNvbW1pdCAtbSAiQiIKIAkpCi0nCit9CiAKLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJzdjLWNoZWNrOiByZW5hbWUvcmVuYW1lKDF0by4uLjJvcjMpOyB0cmFuc2l0aXZlIHJlbmFtZSBtYXkgYWRkIGNvbXBsZXhpdHknICcKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJzdjOiByZW5hbWUvcmVuYW1lKDF0by4uLjJvcjMpOyB0cmFuc2l0aXZlIHJlbmFtZSBtYXkgYWRkIGNvbXBsZXhpdHknICcKKwl0ZXN0X3NldHVwXzdjICYmCiAJKAogCQljZCA3YyAmJgogCkBAIC0xNzY2LDcgKzE3ODksNyBAQAogIyAgIEV4cGVjdGVkOiB5L3tiLGN9LCBDT05GTElDVChkZWxldGUgeC9kIHZzIHJlbmFtZSB0byB5L2QpCiAjICAgTk9URTogei0+eSBzbyBOT1QgQ09ORkxJQ1QoZGVsZXRlIHgvZCB2cyByZW5hbWUgdG8gei9kKQogCi10ZXN0X2V4cGVjdF9zdWNjZXNzICc3ZC1zZXR1cDogdHJhbnNpdGl2ZSByZW5hbWUgaW52b2x2ZWQgaW4gcmVuYW1lL2RlbGV0ZTsgaG93IGlzIGl0IHJlcG9ydGVkPycgJwordGVzdF9zZXR1cF83ZCAoKSB7CiAJdGVzdF9jcmVhdGVfcmVwbyA3ZCAmJgogCSgKIAkJY2QgN2QgJiYKQEAgLTE3OTYsOSArMTgxOSwxMCBAQAogCQl0ZXN0X3RpY2sgJiYKIAkJZ2l0IGNvbW1pdCAtbSAiQiIKIAkpCi0nCit9CiAKLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJzdkLWNoZWNrOiB0cmFuc2l0aXZlIHJlbmFtZSBpbnZvbHZlZCBpbiByZW5hbWUvZGVsZXRlOyBob3cgaXMgaXQgcmVwb3J0ZWQ/JyAnCit0ZXN0X2V4cGVjdF9zdWNjZXNzICc3ZDogdHJhbnNpdGl2ZSByZW5hbWUgaW52b2x2ZWQgaW4gcmVuYW1lL2RlbGV0ZTsgaG93IGlzIGl0IHJlcG9ydGVkPycgJworCXRlc3Rfc2V0dXBfN2QgJiYKIAkoCiAJCWNkIDdkICYmCiAKQEAgLTE4NTEsNyArMTg3NSw3IEBACiAjICAgICAgICAgc2VlIHRlc3RjYXNlcyA5YyBhbmQgOWQgZm9yIGZ1cnRoZXIgZGlzY3Vzc2lvbiBvZiB0aGlzIGlzc3VlIGFuZAogIyAgICAgICAgIGhvdyBpdCdzIHJlc29sdmVkLgogCi10ZXN0X2V4cGVjdF9zdWNjZXNzICc3ZS1zZXR1cDogdHJhbnNpdGl2ZSByZW5hbWUgaW4gcmVuYW1lL2RlbGV0ZSBBTkQgZGlycyBpbiB0aGUgd2F5JyAnCit0ZXN0X3NldHVwXzdlICgpIHsKIAl0ZXN0X2NyZWF0ZV9yZXBvIDdlICYmCiAJKAogCQljZCA3ZSAmJgpAQCAtMTg4Niw5ICsxOTEwLDEwIEBACiAJCXRlc3RfdGljayAmJgogCQlnaXQgY29tbWl0IC1tICJCIgogCSkKLScKK30KIAotdGVzdF9leHBlY3Rfc3VjY2VzcyAnN2UtY2hlY2s6IHRyYW5zaXRpdmUgcmVuYW1lIGluIHJlbmFtZS9kZWxldGUgQU5EIGRpcnMgaW4gdGhlIHdheScgJwordGVzdF9leHBlY3Rfc3VjY2VzcyAnN2U6IHRyYW5zaXRpdmUgcmVuYW1lIGluIHJlbmFtZS9kZWxldGUgQU5EIGRpcnMgaW4gdGhlIHdheScgJworCXRlc3Rfc2V0dXBfN2UgJiYKIAkoCiAJCWNkIDdlICYmCiAKQEAgLTE5NDUsNyArMTk3MCw3IEBACiAjIHNpbXBsZSBydWxlIGZyb20gc2VjdGlvbiA1IHByZXZlbnRzIG1lIGZyb20gaGFuZGxpbmcgdGhpcyBhcyBvcHRpbWFsbHkgYXMKICMgd2UgcG90ZW50aWFsbHkgY291bGQuCiAKLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJzhhLXNldHVwOiBEdWFsLWRpcmVjdG9yeSByZW5hbWUsIG9uZSBpbnRvIHRoZSBvdGhlcnMgd2F5JyAnCit0ZXN0X3NldHVwXzhhICgpIHsKIAl0ZXN0X2NyZWF0ZV9yZXBvIDhhICYmCiAJKAogCQljZCA4YSAmJgpAQCAtMTk3Nyw5ICsyMDAyLDEwIEBACiAJCXRlc3RfdGljayAmJgogCQlnaXQgY29tbWl0IC1tICJCIgogCSkKLScKK30KIAotdGVzdF9leHBlY3Rfc3VjY2VzcyAnOGEtY2hlY2s6IER1YWwtZGlyZWN0b3J5IHJlbmFtZSwgb25lIGludG8gdGhlIG90aGVycyB3YXknICcKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJzhhOiBEdWFsLWRpcmVjdG9yeSByZW5hbWUsIG9uZSBpbnRvIHRoZSBvdGhlcnMgd2F5JyAnCisJdGVzdF9zZXR1cF84YSAmJgogCSgKIAkJY2QgOGEgJiYKIApAQCAtMjAyMyw3ICsyMDQ5LDcgQEAKICMgbWFraW5nIHVzIGZhbGwgYmFjayB0byBwcmUtZGlyZWN0b3J5LXJlbmFtZS1kZXRlY3Rpb24gYmVoYXZpb3IgZm9yIGJvdGgKICMgZV8xIGFuZCBlXzIuCiAKLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJzhiLXNldHVwOiBEdWFsLWRpcmVjdG9yeSByZW5hbWUsIG9uZSBpbnRvIHRoZSBvdGhlcnMgd2F5LCB3aXRoIGNvbmZsaWN0aW5nIGZpbGVuYW1lcycgJwordGVzdF9zZXR1cF84YiAoKSB7CiAJdGVzdF9jcmVhdGVfcmVwbyA4YiAmJgogCSgKIAkJY2QgOGIgJiYKQEAgLTIwNTUsOSArMjA4MSwxMCBAQAogCQl0ZXN0X3RpY2sgJiYKIAkJZ2l0IGNvbW1pdCAtbSAiQiIKIAkpCi0nCit9CiAKLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJzhiLWNoZWNrOiBEdWFsLWRpcmVjdG9yeSByZW5hbWUsIG9uZSBpbnRvIHRoZSBvdGhlcnMgd2F5LCB3aXRoIGNvbmZsaWN0aW5nIGZpbGVuYW1lcycgJwordGVzdF9leHBlY3Rfc3VjY2VzcyAnOGI6IER1YWwtZGlyZWN0b3J5IHJlbmFtZSwgb25lIGludG8gdGhlIG90aGVycyB3YXksIHdpdGggY29uZmxpY3RpbmcgZmlsZW5hbWVzJyAnCisJdGVzdF9zZXR1cF84YiAmJgogCSgKIAkJY2QgOGIgJiYKIApAQCAtMjA4OSwxNCArMjExNiwxNCBAQAogIwogIyAgIE5vdGU6IEl0IGNvdWxkIGVhc2lseSBiZSBhcmd1ZWQgdGhhdCB0aGUgY29ycmVjdCByZXNvbHV0aW9uIGhlcmUgaXMKICMgICAgICAgICB5L3tiLGMsZX0sIENPTkZMSUNUKHJlbmFtZS9kZWxldGU6IHovZCAtPiB5L2QgdnMgZGVsZXRlZCkKLSMgICAgICAgICBhbmQgdGhhdCB0aGUgbW9kaWZlZCB2ZXJzaW9uIG9mIGQgc2hvdWxkIGJlIHByZXNlbnQgaW4geS8gYWZ0ZXIKKyMgICAgICAgICBhbmQgdGhhdCB0aGUgbW9kaWZpZWQgdmVyc2lvbiBvZiBkIHNob3VsZCBiZSBwcmVzZW50IGluIHkvIGFmdGVyCiAjICAgICAgICAgdGhlIG1lcmdlLCBqdXN0IG1hcmtlZCBhcyBjb25mbGljdGVkLiAgSW5kZWVkLCBJIHByZXZpb3VzbHkgZGlkCiAjICAgICAgICAgYXJndWUgdGhhdC4gIEJ1dCBhcHBseWluZyBkaXJlY3RvcnkgcmVuYW1lcyB0byB0aGUgc2lkZSBvZgogIyAgICAgICAgIGhpc3Rvcnkgd2hlcmUgYSBmaWxlIGlzIG1lcmVseSBtb2RpZmllZCByZXN1bHRzIGluIHNwdXJpb3VzCiAjICAgICAgICAgcmVuYW1lL3JlbmFtZSgxdG8yKSBjb25mbGljdHMgLS0gc2VlIHRlc3RjYXNlIDloLiAgU2VlIGFsc28KICMgICAgICAgICBub3RlcyBpbiA4ZC4KIAotdGVzdF9leHBlY3Rfc3VjY2VzcyAnOGMtc2V0dXA6IG1vZGlmeS9kZWxldGUgb3IgcmVuYW1lK21vZGlmeS9kZWxldGU/JyAnCit0ZXN0X3NldHVwXzhjICgpIHsKIAl0ZXN0X2NyZWF0ZV9yZXBvIDhjICYmCiAJKAogCQljZCA4YyAmJgpAQCAtMjEyNyw5ICsyMTU0LDEwIEBACiAJCXRlc3RfdGljayAmJgogCQlnaXQgY29tbWl0IC1tICJCIgogCSkKLScKK30KIAotdGVzdF9leHBlY3Rfc3VjY2VzcyAnOGMtY2hlY2s6IG1vZGlmeS9kZWxldGUgb3IgcmVuYW1lK21vZGlmeS9kZWxldGUnICcKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJzhjOiBtb2RpZnkvZGVsZXRlIG9yIHJlbmFtZSttb2RpZnkvZGVsZXRlJyAnCisJdGVzdF9zZXR1cF84YyAmJgogCSgKIAkJY2QgOGMgJiYKIApAQCAtMjE3NSw3ICsyMjAzLDcgQEAKICMgICBkdXJpbmcgbWVyZ2luZyBhcmUgc3VwcG9zZWQgdG8gYmUgYWJvdXQgb3Bwb3NpdGUgc2lkZXMgZG9pbmcgdGhpbmdzCiAjICAgZGlmZmVyZW50bHkuCiAKLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJzhkLXNldHVwOiByZW5hbWUvZGVsZXRlLi4ub3Igbm90PycgJwordGVzdF9zZXR1cF84ZCAoKSB7CiAJdGVzdF9jcmVhdGVfcmVwbyA4ZCAmJgogCSgKIAkJY2QgOGQgJiYKQEAgLTIyMDQsOSArMjIzMiwxMCBAQAogCQl0ZXN0X3RpY2sgJiYKIAkJZ2l0IGNvbW1pdCAtbSAiQiIKIAkpCi0nCit9CiAKLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJzhkLWNoZWNrOiByZW5hbWUvZGVsZXRlLi4ub3Igbm90PycgJwordGVzdF9leHBlY3Rfc3VjY2VzcyAnOGQ6IHJlbmFtZS9kZWxldGUuLi5vciBub3Q/JyAnCisJdGVzdF9zZXR1cF84ZCAmJgogCSgKIAkJY2QgOGQgJiYKIApAQCAtMjI1MCw3ICsyMjc5LDcgQEAKICMgICAgICAgIGFib3V0IHRoZSByYW1pZmljYXRpb25zIG9mIGRvaW5nIHRoYXQsIEkgZGlkbid0IGtub3cgaG93IHRvIHJ1bGUgb3V0CiAjICAgICAgICB0aGF0IG9wZW5pbmcgb3RoZXIgd2VpcmQgZWRnZSBhbmQgY29ybmVyIGNhc2VzIHNvIEkganVzdCBwdW50ZWQuCiAKLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJzhlLXNldHVwOiBCb3RoIHNpZGVzIHJlbmFtZSwgb25lIHNpZGUgYWRkcyB0byBvcmlnaW5hbCBkaXJlY3RvcnknICcKK3Rlc3Rfc2V0dXBfOGUgKCkgewogCXRlc3RfY3JlYXRlX3JlcG8gOGUgJiYKIAkoCiAJCWNkIDhlICYmCkBAIC0yMjc5LDkgKzIzMDgsMTAgQEAKIAkJdGVzdF90aWNrICYmCiAJCWdpdCBjb21taXQgLW0gIkIiCiAJKQotJworfQogCi10ZXN0X2V4cGVjdF9zdWNjZXNzICc4ZS1jaGVjazogQm90aCBzaWRlcyByZW5hbWUsIG9uZSBzaWRlIGFkZHMgdG8gb3JpZ2luYWwgZGlyZWN0b3J5JyAnCit0ZXN0X2V4cGVjdF9zdWNjZXNzICc4ZTogQm90aCBzaWRlcyByZW5hbWUsIG9uZSBzaWRlIGFkZHMgdG8gb3JpZ2luYWwgZGlyZWN0b3J5JyAnCisJdGVzdF9zZXR1cF84ZSAmJgogCSgKIAkJY2QgOGUgJiYKIApAQCAtMjMzMyw3ICsyMzYzLDcgQEAKICMgICAgICAgICBvZiB3aGljaCBvbmUgaGFkIHRoZSBtb3N0IHBhdGhzIGdvaW5nIHRvIGl0LiAgQSBuYWl2ZSBpbXBsZW1lbnRhdGlvbgogIyAgICAgICAgIG9mIHRoYXQgY291bGQgdGFrZSB0aGUgbmV3IGZpbGUgaW4gY29tbWl0IEIgYXQgei9pIHRvIHgvdy9pIG9yIHgvaS4KIAotdGVzdF9leHBlY3Rfc3VjY2VzcyAnOWEtc2V0dXA6IElubmVyIHJlbmFtZWQgZGlyZWN0b3J5IHdpdGhpbiBvdXRlciByZW5hbWVkIGRpcmVjdG9yeScgJwordGVzdF9zZXR1cF85YSAoKSB7CiAJdGVzdF9jcmVhdGVfcmVwbyA5YSAmJgogCSgKIAkJY2QgOWEgJiYKQEAgLTIzNjYsOSArMjM5NiwxMCBAQAogCQl0ZXN0X3RpY2sgJiYKIAkJZ2l0IGNvbW1pdCAtbSAiQiIKIAkpCi0nCit9CiAKLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJzlhLWNoZWNrOiBJbm5lciByZW5hbWVkIGRpcmVjdG9yeSB3aXRoaW4gb3V0ZXIgcmVuYW1lZCBkaXJlY3RvcnknICcKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJzlhOiBJbm5lciByZW5hbWVkIGRpcmVjdG9yeSB3aXRoaW4gb3V0ZXIgcmVuYW1lZCBkaXJlY3RvcnknICcKKwl0ZXN0X3NldHVwXzlhICYmCiAJKAogCQljZCA5YSAmJgogCkBAIC0yNDA0LDcgKzI0MzUsNyBAQAogIyAgIENvbW1pdCBCOiB6L3tiLGMsZF8zfQogIyAgIEV4cGVjdGVkOiB5L3tiLGMsZF9tZXJnZWR9CiAKLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJzliLXNldHVwOiBUcmFuc2l0aXZlIHJlbmFtZSB3aXRoIGNvbnRlbnQgbWVyZ2UnICcKK3Rlc3Rfc2V0dXBfOWIgKCkgewogCXRlc3RfY3JlYXRlX3JlcG8gOWIgJiYKIAkoCiAJCWNkIDliICYmCkBAIC0yNDM2LDkgKzI0NjcsMTAgQEAKIAkJdGVzdF90aWNrICYmCiAJCWdpdCBjb21taXQgLW0gIkIiCiAJKQotJworfQogCi10ZXN0X2V4cGVjdF9zdWNjZXNzICc5Yi1jaGVjazogVHJhbnNpdGl2ZSByZW5hbWUgd2l0aCBjb250ZW50IG1lcmdlJyAnCit0ZXN0X2V4cGVjdF9zdWNjZXNzICc5YjogVHJhbnNpdGl2ZSByZW5hbWUgd2l0aCBjb250ZW50IG1lcmdlJyAnCisJdGVzdF9zZXR1cF85YiAmJgogCSgKIAkJY2QgOWIgJiYKIApAQCAtMjQ5MSw3ICsyNTIzLDcgQEAKICMgICAgICAgICBhd2F5LCB0aGVuIGlnbm9yZSB0aGF0IHBhcnRpY3VsYXIgcmVuYW1lIGZyb20gdGhlIG90aGVyIHNpZGUgb2YKICMgICAgICAgICBoaXN0b3J5IGZvciBhbnkgaW1wbGljaXQgZGlyZWN0b3J5IHJlbmFtZXMuCiAKLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJzljLXNldHVwOiBEb3VibHkgdHJhbnNpdGl2ZSByZW5hbWU/JyAnCit0ZXN0X3NldHVwXzljICgpIHsKIAl0ZXN0X2NyZWF0ZV9yZXBvIDljICYmCiAJKAogCQljZCA5YyAmJgpAQCAtMjUyNiw5ICsyNTU4LDEwIEBACiAJCXRlc3RfdGljayAmJgogCQlnaXQgY29tbWl0IC1tICJCIgogCSkKLScKK30KIAotdGVzdF9leHBlY3Rfc3VjY2VzcyAnOWMtY2hlY2s6IERvdWJseSB0cmFuc2l0aXZlIHJlbmFtZT8nICcKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJzljOiBEb3VibHkgdHJhbnNpdGl2ZSByZW5hbWU/JyAnCisJdGVzdF9zZXR1cF85YyAmJgogCSgKIAkJY2QgOWMgJiYKIApAQCAtMjU3OSw3ICsyNjEyLDcgQEAKICMgICBzaW1wbGUgcnVsZXMgdGhhdCBhcmUgY29uc2lzdGVudCB3aXRoIHdoYXQgd2UgbmVlZCBmb3IgYWxsIHRoZSBvdGhlcgogIyAgIHRlc3RjYXNlcyBhbmQgc2ltcGxpZmllcyB0aGluZ3MgZm9yIHRoZSB1c2VyLgogCi10ZXN0X2V4cGVjdF9zdWNjZXNzICc5ZC1zZXR1cDogTi13YXkgdHJhbnNpdGl2ZSByZW5hbWU/JyAnCit0ZXN0X3NldHVwXzlkICgpIHsKIAl0ZXN0X2NyZWF0ZV9yZXBvIDlkICYmCiAJKAogCQljZCA5ZCAmJgpAQCAtMjYxNCw5ICsyNjQ3LDEwIEBACiAJCXRlc3RfdGljayAmJgogCQlnaXQgY29tbWl0IC1tICJCIgogCSkKLScKK30KIAotdGVzdF9leHBlY3Rfc3VjY2VzcyAnOWQtY2hlY2s6IE4td2F5IHRyYW5zaXRpdmUgcmVuYW1lPycgJwordGVzdF9leHBlY3Rfc3VjY2VzcyAnOWQ6IE4td2F5IHRyYW5zaXRpdmUgcmVuYW1lPycgJworCXRlc3Rfc2V0dXBfOWQgJiYKIAkoCiAJCWNkIDlkICYmCiAKQEAgLTI2NTMsNyArMjY4Nyw3IEBACiAjICAgRXhwZWN0ZWQ6IGNvbWJpbmVkL3thLGIsYyxkLGUsZixnLGgsaSxqLGssbH0sIENPTkZMSUNUKE50bzEpIHdhcm5pbmdzLAogIyAgICAgICAgICAgICBkaXIxL3lvLCBkaXIyL3lvLCBkaXIzL3lvLCBkaXJOL3lvCiAKLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJzllLXNldHVwOiBOLXRvLTEgd2hhbW1vJyAnCit0ZXN0X3NldHVwXzllICgpIHsKIAl0ZXN0X2NyZWF0ZV9yZXBvIDllICYmCiAJKAogCQljZCA5ZSAmJgpAQCAtMjY5Niw5ICsyNzMwLDEwIEBACiAJCXRlc3RfdGljayAmJgogCQlnaXQgY29tbWl0IC1tICJCIgogCSkKLScKK30KIAotdGVzdF9leHBlY3Rfc3VjY2VzcyBDX0xPQ0FMRV9PVVRQVVQgJzllLWNoZWNrOiBOLXRvLTEgd2hhbW1vJyAnCit0ZXN0X2V4cGVjdF9zdWNjZXNzIENfTE9DQUxFX09VVFBVVCAnOWU6IE4tdG8tMSB3aGFtbW8nICcKKwl0ZXN0X3NldHVwXzllICYmCiAJKAogCQljZCA5ZSAmJgogCkBAIC0yNzQ1LDcgKzI3ODAsNyBAQAogIyAgIENvbW1pdCBCOiBnb2FsL3thLGJ9LyRtb3JlX2ZpbGVzLCBnb2FsL2MKICMgICBFeHBlY3RlZDogcHJpb3JpdHkve2EsYn0vJG1vcmVfZmlsZXMsIHByaW9yaXR5L2MKIAotdGVzdF9leHBlY3Rfc3VjY2VzcyAnOWYtc2V0dXA6IFJlbmFtZWQgZGlyZWN0b3J5IHRoYXQgb25seSBjb250YWluZWQgaW1tZWRpYXRlIHN1YmRpcnMnICcKK3Rlc3Rfc2V0dXBfOWYgKCkgewogCXRlc3RfY3JlYXRlX3JlcG8gOWYgJiYKIAkoCiAJCWNkIDlmICYmCkBAIC0yNzc0LDkgKzI4MDksMTAgQEAKIAkJdGVzdF90aWNrICYmCiAJCWdpdCBjb21taXQgLW0gIkIiCiAJKQotJworfQogCi10ZXN0X2V4cGVjdF9zdWNjZXNzICc5Zi1jaGVjazogUmVuYW1lZCBkaXJlY3RvcnkgdGhhdCBvbmx5IGNvbnRhaW5lZCBpbW1lZGlhdGUgc3ViZGlycycgJwordGVzdF9leHBlY3Rfc3VjY2VzcyAnOWY6IFJlbmFtZWQgZGlyZWN0b3J5IHRoYXQgb25seSBjb250YWluZWQgaW1tZWRpYXRlIHN1YmRpcnMnICcKKwl0ZXN0X3NldHVwXzlmICYmCiAJKAogCQljZCA5ZiAmJgogCkBAIC0yODA5LDcgKzI4NDUsNyBAQAogIyAgIENvbW1pdCBCOiBnb2FsL3thLGJ9LyRtb3JlX2ZpbGVzLCBnb2FsL2MKICMgICBFeHBlY3RlZDogcHJpb3JpdHkve2FscGhhLGJyYXZvfS8kbW9yZV9maWxlcywgcHJpb3JpdHkvYwogCi10ZXN0X2V4cGVjdF9zdWNjZXNzICc5Zy1zZXR1cDogUmVuYW1lZCBkaXJlY3RvcnkgdGhhdCBvbmx5IGNvbnRhaW5lZCBpbW1lZGlhdGUgc3ViZGlycywgaW1tZWRpYXRlIHN1YmRpcnMgcmVuYW1lZCcgJwordGVzdF9zZXR1cF85ZyAoKSB7CiAJdGVzdF9jcmVhdGVfcmVwbyA5ZyAmJgogCSgKIAkJY2QgOWcgJiYKQEAgLTI4NDEsOSArMjg3Nyw5IEBACiAJCXRlc3RfdGljayAmJgogCQlnaXQgY29tbWl0IC1tICJCIgogCSkKLScKK30KIAotdGVzdF9leHBlY3RfZmFpbHVyZSAnOWctY2hlY2s6IFJlbmFtZWQgZGlyZWN0b3J5IHRoYXQgb25seSBjb250YWluZWQgaW1tZWRpYXRlIHN1YmRpcnMsIGltbWVkaWF0ZSBzdWJkaXJzIHJlbmFtZWQnICcKK3Rlc3RfZXhwZWN0X2ZhaWx1cmUgJzlnOiBSZW5hbWVkIGRpcmVjdG9yeSB0aGF0IG9ubHkgY29udGFpbmVkIGltbWVkaWF0ZSBzdWJkaXJzLCBpbW1lZGlhdGUgc3ViZGlycyByZW5hbWVkJyAnCiAJKAogCQljZCA5ZyAmJgogCkBAIC0yODc3LDcgKzI5MTMsNyBAQAogIyAgIEV4cGVjdGVkOiB5L3tiLGN9LCB4L2RfMgogIyAgIE5PVEU6IElmIHdlIGFwcGxpZWQgdGhlIHovIC0+IHkvIHJlbmFtZSB0byB6L2QsIHRoZW4gd2UnZCBlbmQgdXAgd2l0aAogIyAgICAgICAgIGEgcmVuYW1lL3JlbmFtZSgxdG8yKSBjb25mbGljdCAoei9kIC0+IHkvZCB2cy4geC9kKQotdGVzdF9leHBlY3Rfc3VjY2VzcyAnOWgtc2V0dXA6IEF2b2lkIGRpciByZW5hbWUgb24gbWVyZWx5IG1vZGlmaWVkIHBhdGgnICcKK3Rlc3Rfc2V0dXBfOWggKCkgewogCXRlc3RfY3JlYXRlX3JlcG8gOWggJiYKIAkoCiAJCWNkIDloICYmCkBAIC0yOTEwLDkgKzI5NDYsMTAgQEAKIAkJdGVzdF90aWNrICYmCiAJCWdpdCBjb21taXQgLW0gIkIiCiAJKQotJworfQogCi10ZXN0X2V4cGVjdF9zdWNjZXNzICc5aC1jaGVjazogQXZvaWQgZGlyIHJlbmFtZSBvbiBtZXJlbHkgbW9kaWZpZWQgcGF0aCcgJwordGVzdF9leHBlY3Rfc3VjY2VzcyAnOWg6IEF2b2lkIGRpciByZW5hbWUgb24gbWVyZWx5IG1vZGlmaWVkIHBhdGgnICcKKwl0ZXN0X3NldHVwXzloICYmCiAJKAogCQljZCA5aCAmJgogCkBAIC0yOTU3LDcgKzI5OTQsNyBAQAogIyAgIEV4cGVjdGVkOiBBYm9ydGVkIE1lcmdlICsKICMgICAgICAgRVJST1JfTVNHKHVudHJhY2tlZCB3b3JraW5nIHRyZWUgZmlsZXMgd291bGQgYmUgb3ZlcndyaXR0ZW4gYnkgbWVyZ2UpCiAKLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJzEwYS1zZXR1cDogT3ZlcndyaXRlIHVudHJhY2tlZCB3aXRoIG5vcm1hbCByZW5hbWUvZGVsZXRlJyAnCit0ZXN0X3NldHVwXzEwYSAoKSB7CiAJdGVzdF9jcmVhdGVfcmVwbyAxMGEgJiYKIAkoCiAJCWNkIDEwYSAmJgpAQCAtMjk4Myw5ICszMDIwLDEwIEBACiAJCXRlc3RfdGljayAmJgogCQlnaXQgY29tbWl0IC1tICJCIgogCSkKLScKK30KIAotdGVzdF9leHBlY3Rfc3VjY2VzcyAnMTBhLWNoZWNrOiBPdmVyd3JpdGUgdW50cmFja2VkIHdpdGggbm9ybWFsIHJlbmFtZS9kZWxldGUnICcKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJzEwYTogT3ZlcndyaXRlIHVudHJhY2tlZCB3aXRoIG5vcm1hbCByZW5hbWUvZGVsZXRlJyAnCisJdGVzdF9zZXR1cF8xMGEgJiYKIAkoCiAJCWNkIDEwYSAmJgogCkBAIC0zMDIxLDcgKzMwNTksNyBAQAogIyAgICAgICAgICAgICB6L2NfMSAtPiB6L2RfMSByZW5hbWUgcmVjb3JkZWQgYXQgc3RhZ2UgMyBmb3IgeS9kICsKICMgICAgICAgRVJST1JfTVNHKHJlZnVzaW5nIHRvIGxvc2UgdW50cmFja2VkIGZpbGUgYXQgJ3kvZCcpCiAKLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJzEwYi1zZXR1cDogT3ZlcndyaXRlIHVudHJhY2tlZCB3aXRoIGRpciByZW5hbWUgKyBkZWxldGUnICcKK3Rlc3Rfc2V0dXBfMTBiICgpIHsKIAl0ZXN0X2NyZWF0ZV9yZXBvIDEwYiAmJgogCSgKIAkJY2QgMTBiICYmCkBAIC0zMDUwLDkgKzMwODgsMTAgQEAKIAkJdGVzdF90aWNrICYmCiAJCWdpdCBjb21taXQgLW0gIkIiCiAJKQotJworfQogCi10ZXN0X2V4cGVjdF9zdWNjZXNzICcxMGItY2hlY2s6IE92ZXJ3cml0ZSB1bnRyYWNrZWQgd2l0aCBkaXIgcmVuYW1lICsgZGVsZXRlJyAnCit0ZXN0X2V4cGVjdF9zdWNjZXNzICcxMGI6IE92ZXJ3cml0ZSB1bnRyYWNrZWQgd2l0aCBkaXIgcmVuYW1lICsgZGVsZXRlJyAnCisJdGVzdF9zZXR1cF8xMGIgJiYKIAkoCiAJCWNkIDEwYiAmJgogCkBAIC0zMDk4LDEwICszMTM3LDEwIEBACiAjICAgICAgICAgICAgIHkvY35CXjAgKwogIyAgICAgICAgICAgICBFUlJPUl9NU0coUmVmdXNpbmcgdG8gbG9zZSB1bnRyYWNrZWQgZmlsZSBhdCB5L2MpCiAKLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJzEwYy1zZXR1cDogT3ZlcndyaXRlIHVudHJhY2tlZCB3aXRoIGRpciByZW5hbWUvcmVuYW1lKDF0bzIpJyAnCi0JdGVzdF9jcmVhdGVfcmVwbyAxMGMgJiYKK3Rlc3Rfc2V0dXBfMTBjICgpIHsKKwl0ZXN0X2NyZWF0ZV9yZXBvIDEwY18kMSAmJgogCSgKLQkJY2QgMTBjICYmCisJCWNkIDEwY18kMSAmJgogCiAJCW1rZGlyIHogeCAmJgogCQllY2hvIGEgPnovYSAmJgpAQCAtMzEyOCwxMSArMzE2NywxMiBAQAogCQl0ZXN0X3RpY2sgJiYKIAkJZ2l0IGNvbW1pdCAtbSAiQiIKIAkpCi0nCit9CiAKLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJzEwYy1jaGVjazogT3ZlcndyaXRlIHVudHJhY2tlZCB3aXRoIGRpciByZW5hbWUvcmVuYW1lKDF0bzIpJyAnCit0ZXN0X2V4cGVjdF9zdWNjZXNzICcxMGMxOiBPdmVyd3JpdGUgdW50cmFja2VkIHdpdGggZGlyIHJlbmFtZS9yZW5hbWUoMXRvMiknICcKKwl0ZXN0X3NldHVwXzEwYyAxICYmCiAJKAotCQljZCAxMGMgJiYKKwkJY2QgMTBjXzEgJiYKIAogCQlnaXQgY2hlY2tvdXQgQV4wICYmCiAJCWVjaG8gaW1wb3J0YW50ID55L2MgJiYKQEAgLTMxNjMsOSArMzIwMywxMCBAQAogCSkKICcKIAotdGVzdF9leHBlY3Rfc3VjY2VzcyAnMTBjLWNoZWNrOiBPdmVyd3JpdGUgdW50cmFja2VkIHdpdGggZGlyIHJlbmFtZS9yZW5hbWUoMXRvMiksIG90aGVyIGRpcmVjdGlvbicgJwordGVzdF9leHBlY3Rfc3VjY2VzcyAnMTBjMjogT3ZlcndyaXRlIHVudHJhY2tlZCB3aXRoIGRpciByZW5hbWUvcmVuYW1lKDF0bzIpLCBvdGhlciBkaXJlY3Rpb24nICcKKwl0ZXN0X3NldHVwXzEwYyAyICYmCiAJKAotCQljZCAxMGMgJiYKKwkJY2QgMTBjXzIgJiYKIAogCQlnaXQgcmVzZXQgLS1oYXJkICYmCiAJCWdpdCBjbGVhbiAtZmRxeCAmJgpAQCAtMzIwOCw3ICszMjQ5LDcgQEAKICMgICAgICAgICAgICAgQ09ORkxJQ1QocmVuYW1lL3JlbmFtZSkgei9jXzEgdnMgeC9mXzIgLT4geS93aGFtCiAjICAgICAgICAgICAgIEVSUk9SX01TRyhSZWZ1c2luZyB0byBsb3NlIHVudHJhY2tlZCBmaWxlIGF0IHkvd2hhbSkKIAotdGVzdF9leHBlY3Rfc3VjY2VzcyAnMTBkLXNldHVwOiBEZWxldGUgdW50cmFja2VkIHdpdGggZGlyIHJlbmFtZS9yZW5hbWUoMnRvMSknICcKK3Rlc3Rfc2V0dXBfMTBkICgpIHsKIAl0ZXN0X2NyZWF0ZV9yZXBvIDEwZCAmJgogCSgKIAkJY2QgMTBkICYmCkBAIC0zMjQwLDkgKzMyODEsMTAgQEAKIAkJdGVzdF90aWNrICYmCiAJCWdpdCBjb21taXQgLW0gIkIiCiAJKQotJworfQogCi10ZXN0X2V4cGVjdF9zdWNjZXNzICcxMGQtY2hlY2s6IERlbGV0ZSB1bnRyYWNrZWQgd2l0aCBkaXIgcmVuYW1lL3JlbmFtZSgydG8xKScgJwordGVzdF9leHBlY3Rfc3VjY2VzcyAnMTBkOiBEZWxldGUgdW50cmFja2VkIHdpdGggZGlyIHJlbmFtZS9yZW5hbWUoMnRvMSknICcKKwl0ZXN0X3NldHVwXzEwZCAmJgogCSgKIAkJY2QgMTBkICYmCiAKQEAgLTMyOTAsNyArMzMzMiw3IEBACiAjICAgQ29tbWl0IEI6IHove2EsYixjfQogIyAgIEV4cGVjdGVkOiB5L3thLGIsY30gKyB1bnRyYWNrZWQgei9jCiAKLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJzEwZS1zZXR1cDogRG9lcyBnaXQgY29tcGxhaW4gYWJvdXQgdW50cmFja2VkIGZpbGUgdGhhdCBpcyBub3QgcmVhbGx5IGluIHRoZSB3YXk/JyAnCit0ZXN0X3NldHVwXzEwZSAoKSB7CiAJdGVzdF9jcmVhdGVfcmVwbyAxMGUgJiYKIAkoCiAJCWNkIDEwZSAmJgpAQCAtMzMxNyw5ICszMzU5LDkgQEAKIAkJdGVzdF90aWNrICYmCiAJCWdpdCBjb21taXQgLW0gIkIiCiAJKQotJworfQogCi10ZXN0X2V4cGVjdF9mYWlsdXJlICcxMGUtY2hlY2s6IERvZXMgZ2l0IGNvbXBsYWluIGFib3V0IHVudHJhY2tlZCBmaWxlIHRoYXQgaXMgbm90IHJlYWxseSBpbiB0aGUgd2F5PycgJwordGVzdF9leHBlY3RfZmFpbHVyZSAnMTBlOiBEb2VzIGdpdCBjb21wbGFpbiBhYm91dCB1bnRyYWNrZWQgZmlsZSB0aGF0IGlzIG5vdCByZWFsbHkgaW4gdGhlIHdheT8nICcKIAkoCiAJCWNkIDEwZSAmJgogCkBAIC0zMzcxLDcgKzM0MTMsNyBAQAogIyAgICAgICAgICAgICB6L2N+SEVBRCB3aXRoIGNvbnRlbnRzIG9mIEI6ei9iX3YyLAogIyAgICAgICAgICAgICB6L2Mgd2l0aCB1bmNvbW1pdHRlZCBtb2RzIG9uIHRvcCBvZiBBOnovY192MQogCi10ZXN0X2V4cGVjdF9zdWNjZXNzICcxMWEtc2V0dXA6IEF2b2lkIGxvc2luZyBkaXJ0eSBjb250ZW50cyB3aXRoIHNpbXBsZSByZW5hbWUnICcKK3Rlc3Rfc2V0dXBfMTFhICgpIHsKIAl0ZXN0X2NyZWF0ZV9yZXBvIDExYSAmJgogCSgKIAkJY2QgMTFhICYmCkBAIC0zMzk4LDkgKzM0NDAsMTAgQEAKIAkJdGVzdF90aWNrICYmCiAJCWdpdCBjb21taXQgLW0gIkIiCiAJKQotJworfQogCi10ZXN0X2V4cGVjdF9zdWNjZXNzICcxMWEtY2hlY2s6IEF2b2lkIGxvc2luZyBkaXJ0eSBjb250ZW50cyB3aXRoIHNpbXBsZSByZW5hbWUnICcKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJzExYTogQXZvaWQgbG9zaW5nIGRpcnR5IGNvbnRlbnRzIHdpdGggc2ltcGxlIHJlbmFtZScgJworCXRlc3Rfc2V0dXBfMTFhICYmCiAJKAogCQljZCAxMWEgJiYKIApAQCAtMzQ0MSw3ICszNDg0LDcgQEAKICMgICAgICAgICAgICAgRVJST1JfTVNHKFJlZnVzaW5nIHRvIGxvc2UgZGlydHkgZmlsZSBhdCB6L2MpCiAKIAotdGVzdF9leHBlY3Rfc3VjY2VzcyAnMTFiLXNldHVwOiBBdm9pZCBsb3NpbmcgZGlydHkgZmlsZSBpbnZvbHZlZCBpbiBkaXJlY3RvcnkgcmVuYW1lJyAnCit0ZXN0X3NldHVwXzExYiAoKSB7CiAJdGVzdF9jcmVhdGVfcmVwbyAxMWIgJiYKIAkoCiAJCWNkIDExYiAmJgpAQCAtMzQ3MCw5ICszNTEzLDEwIEBACiAJCXRlc3RfdGljayAmJgogCQlnaXQgY29tbWl0IC1tICJCIgogCSkKLScKK30KIAotdGVzdF9leHBlY3Rfc3VjY2VzcyAnMTFiLWNoZWNrOiBBdm9pZCBsb3NpbmcgZGlydHkgZmlsZSBpbnZvbHZlZCBpbiBkaXJlY3RvcnkgcmVuYW1lJyAnCit0ZXN0X2V4cGVjdF9zdWNjZXNzICcxMWI6IEF2b2lkIGxvc2luZyBkaXJ0eSBmaWxlIGludm9sdmVkIGluIGRpcmVjdG9yeSByZW5hbWUnICcKKwl0ZXN0X3NldHVwXzExYiAmJgogCSgKIAkJY2QgMTFiICYmCiAKQEAgLTM1MTUsNyArMzU1OSw3IEBACiAjICAgRXhwZWN0ZWQ6IEFib3J0X21zZygiZm9sbG93aW5nIGZpbGVzIHdvdWxkIGJlIG92ZXJ3cml0dGVuIGJ5IG1lcmdlIikgKwogIyAgICAgICAgICAgICB5L2MgbGVmdCB1bnRvdWNoZWQgKHN0aWxsIGhhcyB1bmNvbW1pdHRlZCBtb2RzKQogCi10ZXN0X2V4cGVjdF9zdWNjZXNzICcxMWMtc2V0dXA6IEF2b2lkIGxvc2luZyBub3QtdXB0b2RhdGUgd2l0aCByZW5hbWUgKyBEL0YgY29uZmxpY3QnICcKK3Rlc3Rfc2V0dXBfMTFjICgpIHsKIAl0ZXN0X2NyZWF0ZV9yZXBvIDExYyAmJgogCSgKIAkJY2QgMTFjICYmCkBAIC0zNTQ1LDkgKzM1ODksMTAgQEAKIAkJdGVzdF90aWNrICYmCiAJCWdpdCBjb21taXQgLW0gIkIiCiAJKQotJworfQogCi10ZXN0X2V4cGVjdF9zdWNjZXNzICcxMWMtY2hlY2s6IEF2b2lkIGxvc2luZyBub3QtdXB0b2RhdGUgd2l0aCByZW5hbWUgKyBEL0YgY29uZmxpY3QnICcKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJzExYzogQXZvaWQgbG9zaW5nIG5vdC11cHRvZGF0ZSB3aXRoIHJlbmFtZSArIEQvRiBjb25mbGljdCcgJworCXRlc3Rfc2V0dXBfMTFjICYmCiAJKAogCQljZCAxMWMgJiYKIApAQCAtMzU4MSw3ICszNjI2LDcgQEAKICMgICAgICAgICAgICAgV2FybmluZ19Nc2coIlJlZnVzaW5nIHRvIGxvc2UgZGlydHkgZmlsZSBhdCB6L2MpICsKICMgICAgICAgICAgICAgeS97YSxjfkhFQUQsYy9kfSwgeC9iLCBub3ctdW50cmFja2VkIHovY192MSB3aXRoIHVuY29tbWl0dGVkIG1vZHMKIAotdGVzdF9leHBlY3Rfc3VjY2VzcyAnMTFkLXNldHVwOiBBdm9pZCBsb3Npbmcgbm90LXVwdG9kYXRlIHdpdGggcmVuYW1lICsgRC9GIGNvbmZsaWN0JyAnCit0ZXN0X3NldHVwXzExZCAoKSB7CiAJdGVzdF9jcmVhdGVfcmVwbyAxMWQgJiYKIAkoCiAJCWNkIDExZCAmJgpAQCAtMzYxMiw5ICszNjU3LDEwIEBACiAJCXRlc3RfdGljayAmJgogCQlnaXQgY29tbWl0IC1tICJCIgogCSkKLScKK30KIAotdGVzdF9leHBlY3Rfc3VjY2VzcyAnMTFkLWNoZWNrOiBBdm9pZCBsb3Npbmcgbm90LXVwdG9kYXRlIHdpdGggcmVuYW1lICsgRC9GIGNvbmZsaWN0JyAnCit0ZXN0X2V4cGVjdF9zdWNjZXNzICcxMWQ6IEF2b2lkIGxvc2luZyBub3QtdXB0b2RhdGUgd2l0aCByZW5hbWUgKyBEL0YgY29uZmxpY3QnICcKKwl0ZXN0X3NldHVwXzExZCAmJgogCSgKIAkJY2QgMTFkICYmCiAKQEAgLTM2NTksNyArMzcwNSw3IEBACiAjICAgICAgICAgICAgIHkvY35IRUFEIGhhcyBBOnkvY18yIGNvbnRlbnRzCiAjICAgICAgICAgICAgIHkvYyBoYXMgZGlydHkgZmlsZSBmcm9tIGJlZm9yZSBtZXJnZQogCi10ZXN0X2V4cGVjdF9zdWNjZXNzICcxMWUtc2V0dXA6IEF2b2lkIGRlbGV0aW5nIG5vdC11cHRvZGF0ZSB3aXRoIGRpciByZW5hbWUvcmVuYW1lKDF0bzIpL2FkZCcgJwordGVzdF9zZXR1cF8xMWUgKCkgewogCXRlc3RfY3JlYXRlX3JlcG8gMTFlICYmCiAJKAogCQljZCAxMWUgJiYKQEAgLTM2OTEsOSArMzczNywxMCBAQAogCQl0ZXN0X3RpY2sgJiYKIAkJZ2l0IGNvbW1pdCAtbSAiQiIKIAkpCi0nCit9CiAKLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJzExZS1jaGVjazogQXZvaWQgZGVsZXRpbmcgbm90LXVwdG9kYXRlIHdpdGggZGlyIHJlbmFtZS9yZW5hbWUoMXRvMikvYWRkJyAnCit0ZXN0X2V4cGVjdF9zdWNjZXNzICcxMWU6IEF2b2lkIGRlbGV0aW5nIG5vdC11cHRvZGF0ZSB3aXRoIGRpciByZW5hbWUvcmVuYW1lKDF0bzIpL2FkZCcgJworCXRlc3Rfc2V0dXBfMTFlICYmCiAJKAogCQljZCAxMWUgJiYKIApAQCAtMzc0NCw3ICszNzkxLDcgQEAKICMgICAgICAgICAgICAgQ09ORkxJQ1QocmVuYW1lL3JlbmFtZSkgeC9jIHZzIHgvZCAtPiB5L3doYW0KICMgICAgICAgICAgICAgRVJST1JfTVNHKFJlZnVzaW5nIHRvIGxvc2UgZGlydHkgZmlsZSBhdCB5L3doYW0pCiAKLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJzExZi1zZXR1cDogQXZvaWQgZGVsZXRpbmcgbm90LXVwdG9kYXRlIHdpdGggZGlyIHJlbmFtZS9yZW5hbWUoMnRvMSknICcKK3Rlc3Rfc2V0dXBfMTFmICgpIHsKIAl0ZXN0X2NyZWF0ZV9yZXBvIDExZiAmJgogCSgKIAkJY2QgMTFmICYmCkBAIC0zNzczLDkgKzM4MjAsMTAgQEAKIAkJdGVzdF90aWNrICYmCiAJCWdpdCBjb21taXQgLW0gIkIiCiAJKQotJworfQogCi10ZXN0X2V4cGVjdF9zdWNjZXNzICcxMWYtY2hlY2s6IEF2b2lkIGRlbGV0aW5nIG5vdC11cHRvZGF0ZSB3aXRoIGRpciByZW5hbWUvcmVuYW1lKDJ0bzEpJyAnCit0ZXN0X2V4cGVjdF9zdWNjZXNzICcxMWY6IEF2b2lkIGRlbGV0aW5nIG5vdC11cHRvZGF0ZSB3aXRoIGRpciByZW5hbWUvcmVuYW1lKDJ0bzEpJyAnCisJdGVzdF9zZXR1cF8xMWYgJiYKIAkoCiAJCWNkIDExZiAmJgogCkBAIC0zODMyLDcgKzM4ODAsNyBAQAogIyAgIENvbW1pdCBCOiBub2RlMS97bGVhZjEsbGVhZjIsbGVhZjV9LCBub2RlMi97bGVhZjMsbGVhZjQsbGVhZjZ9CiAjICAgRXhwZWN0ZWQ6IG5vZGUxL3tsZWFmMSxsZWFmMixsZWFmNSxub2RlMi97bGVhZjMsbGVhZjQsbGVhZjZ9fQogCi10ZXN0X2V4cGVjdF9zdWNjZXNzICcxMmEtc2V0dXA6IE1vdmluZyBvbmUgZGlyZWN0b3J5IGhpZXJhcmNoeSBpbnRvIGFub3RoZXInICcKK3Rlc3Rfc2V0dXBfMTJhICgpIHsKIAl0ZXN0X2NyZWF0ZV9yZXBvIDEyYSAmJgogCSgKIAkJY2QgMTJhICYmCkBAIC0zODYyLDkgKzM5MTAsMTAgQEAKIAkJdGVzdF90aWNrICYmCiAJCWdpdCBjb21taXQgLW0gIkIiCiAJKQotJworfQogCi10ZXN0X2V4cGVjdF9zdWNjZXNzICcxMmEtY2hlY2s6IE1vdmluZyBvbmUgZGlyZWN0b3J5IGhpZXJhcmNoeSBpbnRvIGFub3RoZXInICcKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJzEyYTogTW92aW5nIG9uZSBkaXJlY3RvcnkgaGllcmFyY2h5IGludG8gYW5vdGhlcicgJworCXRlc3Rfc2V0dXBfMTJhICYmCiAJKAogCQljZCAxMmEgJiYKIApAQCAtMzkxMCw3ICszOTU5LDcgQEAKICMgICAgICAgICBUbyB3aGljaCwgSSBjYW4gZG8gbm8gbW9yZSB0aGFuIHNocnVnIG15IHNob3VsZGVycyBhbmQgc2F5IHRoYXQKICMgICAgICAgICBldmVuIHNpbXBsZSBydWxlcyBnaXZlIHdlaXJkIHJlc3VsdHMgd2hlbiBnaXZlbiB3ZWlyZCBpbnB1dHMuCiAKLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJzEyYi1zZXR1cDogTW92aW5nIHR3byBkaXJlY3RvcnkgaGllcmFyY2hpZXMgaW50byBlYWNoIG90aGVyJyAnCit0ZXN0X3NldHVwXzEyYiAoKSB7CiAJdGVzdF9jcmVhdGVfcmVwbyAxMmIgJiYKIAkoCiAJCWNkIDEyYiAmJgpAQCAtMzkzOCw5ICszOTg3LDEwIEBACiAJCXRlc3RfdGljayAmJgogCQlnaXQgY29tbWl0IC1tICJCIgogCSkKLScKK30KIAotdGVzdF9leHBlY3Rfc3VjY2VzcyAnMTJiLWNoZWNrOiBNb3ZpbmcgdHdvIGRpcmVjdG9yeSBoaWVyYXJjaGllcyBpbnRvIGVhY2ggb3RoZXInICcKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJzEyYjogTW92aW5nIHR3byBkaXJlY3RvcnkgaGllcmFyY2hpZXMgaW50byBlYWNoIG90aGVyJyAnCisJdGVzdF9zZXR1cF8xMmIgJiYKIAkoCiAJCWNkIDEyYiAmJgogCkBAIC0zOTc2LDcgKzQwMjYsNyBAQAogIyAgIE5PVEU6IFRoaXMgaXMgKmV4YWN0bHkqIGxpa2UgMTJjLCBleGNlcHQgdGhhdCBldmVyeSBwYXRoIGlzIG1vZGlmaWVkIG9uCiAjICAgICAgICAgZWFjaCBzaWRlIG9mIHRoZSBtZXJnZS4KIAotdGVzdF9leHBlY3Rfc3VjY2VzcyAnMTJjLXNldHVwOiBNb3Zpbmcgb25lIGRpcmVjdG9yeSBoaWVyYXJjaHkgaW50byBhbm90aGVyIHcvIGNvbnRlbnQgbWVyZ2UnICcKK3Rlc3Rfc2V0dXBfMTJjICgpIHsKIAl0ZXN0X2NyZWF0ZV9yZXBvIDEyYyAmJgogCSgKIAkJY2QgMTJjICYmCkBAIC00MDA4LDkgKzQwNTgsMTAgQEAKIAkJdGVzdF90aWNrICYmCiAJCWdpdCBjb21taXQgLW0gIkIiCiAJKQotJworfQogCi10ZXN0X2V4cGVjdF9zdWNjZXNzICcxMmMtY2hlY2s6IE1vdmluZyBvbmUgZGlyZWN0b3J5IGhpZXJhcmNoeSBpbnRvIGFub3RoZXIgdy8gY29udGVudCBtZXJnZScgJwordGVzdF9leHBlY3Rfc3VjY2VzcyAnMTJjOiBNb3Zpbmcgb25lIGRpcmVjdG9yeSBoaWVyYXJjaHkgaW50byBhbm90aGVyIHcvIGNvbnRlbnQgbWVyZ2UnICcKKwl0ZXN0X3NldHVwXzEyYyAmJgogCSgKIAkJY2QgMTJjICYmCiAKQEAgLTQwNTEsNiArNDEwMiwxMjIgQEAKIAkpCiAnCiAKKyMgVGVzdGNhc2UgMTJkLCBSZW5hbWUvbWVyZ2Ugb2Ygc3ViZGlyZWN0b3J5IGludG8gdGhlIHJvb3QKKyMgICBDb21taXQgTzogYS9iL3N1YmRpci9mb28KKyMgICBDb21taXQgQTogc3ViZGlyL2ZvbworIyAgIENvbW1pdCBCOiBhL2Ivc3ViZGlyL2ZvbywgYS9iL2JhcgorIyAgIEV4cGVjdGVkOiBzdWJkaXIvZm9vLCBiYXIKKwordGVzdF9zZXR1cF8xMmQgKCkgeworCXRlc3RfY3JlYXRlX3JlcG8gMTJkICYmCisJKAorCQljZCAxMmQgJiYKKworCQlta2RpciAtcCBhL2Ivc3ViZGlyICYmCisJCXRlc3RfY29tbWl0IGEvYi9zdWJkaXIvZm9vICYmCisKKwkJZ2l0IGJyYW5jaCBPICYmCisJCWdpdCBicmFuY2ggQSAmJgorCQlnaXQgYnJhbmNoIEIgJiYKKworCQlnaXQgY2hlY2tvdXQgQSAmJgorCQlta2RpciBzdWJkaXIgJiYKKwkJZ2l0IG12IGEvYi9zdWJkaXIvZm9vLnQgc3ViZGlyL2Zvby50ICYmCisJCXRlc3RfdGljayAmJgorCQlnaXQgY29tbWl0IC1tICJBIiAmJgorCisJCWdpdCBjaGVja291dCBCICYmCisJCXRlc3RfY29tbWl0IGEvYi9iYXIKKwkpCit9CisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJzEyZDogUmVuYW1lL21lcmdlIHN1YmRpciBpbnRvIHRoZSByb290LCB2YXJpYW50IDEnICcKKwl0ZXN0X3NldHVwXzEyZCAmJgorCSgKKwkJY2QgMTJkICYmCisKKwkJZ2l0IGNoZWNrb3V0IEFeMCAmJgorCisJCWdpdCAtYyBtZXJnZS5kaXJlY3RvcnlSZW5hbWVzPXRydWUgbWVyZ2UgLXMgcmVjdXJzaXZlIEJeMCAmJgorCisJCWdpdCBscy1maWxlcyAtcyA+b3V0ICYmCisJCXRlc3RfbGluZV9jb3VudCA9IDIgb3V0ICYmCisKKwkJZ2l0IHJldi1wYXJzZSA+YWN0dWFsIFwKKwkJCUhFQUQ6c3ViZGlyL2Zvby50ICAgSEVBRDpiYXIudCAmJgorCQlnaXQgcmV2LXBhcnNlID5leHBlY3QgXAorCQkJTzphL2Ivc3ViZGlyL2Zvby50ICBCOmEvYi9iYXIudCAmJgorCQl0ZXN0X2NtcCBleHBlY3QgYWN0dWFsICYmCisKKwkJZ2l0IGhhc2gtb2JqZWN0IGJhci50ID5hY3R1YWwgJiYKKwkJZ2l0IHJldi1wYXJzZSBCOmEvYi9iYXIudCA+ZXhwZWN0ICYmCisJCXRlc3RfY21wIGV4cGVjdCBhY3R1YWwgJiYKKworCQl0ZXN0X211c3RfZmFpbCBnaXQgcmV2LXBhcnNlIEhFQUQ6YS9iL3N1YmRpci9mb28udCAmJgorCQl0ZXN0X211c3RfZmFpbCBnaXQgcmV2LXBhcnNlIEhFQUQ6YS9iL2Jhci50ICYmCisJCXRlc3RfcGF0aF9pc19taXNzaW5nIGEvICYmCisJCXRlc3RfcGF0aF9pc19maWxlIGJhci50CisJKQorJworCisjIFRlc3RjYXNlIDEyZSwgUmVuYW1lL21lcmdlIG9mIHN1YmRpcmVjdG9yeSBpbnRvIHRoZSByb290CisjICAgQ29tbWl0IE86IGEvYi9mb28KKyMgICBDb21taXQgQTogZm9vCisjICAgQ29tbWl0IEI6IGEvYi9mb28sIGEvYi9iYXIKKyMgICBFeHBlY3RlZDogZm9vLCBiYXIKKwordGVzdF9zZXR1cF8xMmUgKCkgeworCXRlc3RfY3JlYXRlX3JlcG8gMTJlICYmCisJKAorCQljZCAxMmUgJiYKKworCQlta2RpciAtcCBhL2IgJiYKKwkJdGVzdF9jb21taXQgYS9iL2ZvbyAmJgorCisJCWdpdCBicmFuY2ggTyAmJgorCQlnaXQgYnJhbmNoIEEgJiYKKwkJZ2l0IGJyYW5jaCBCICYmCisKKwkJZ2l0IGNoZWNrb3V0IEEgJiYKKwkJbWtkaXIgc3ViZGlyICYmCisJCWdpdCBtdiBhL2IvZm9vLnQgZm9vLnQgJiYKKwkJdGVzdF90aWNrICYmCisJCWdpdCBjb21taXQgLW0gIkEiICYmCisKKwkJZ2l0IGNoZWNrb3V0IEIgJiYKKwkJdGVzdF9jb21taXQgYS9iL2JhcgorCSkKK30KKwordGVzdF9leHBlY3Rfc3VjY2VzcyAnMTJlOiBSZW5hbWUvbWVyZ2Ugc3ViZGlyIGludG8gdGhlIHJvb3QsIHZhcmlhbnQgMicgJworCXRlc3Rfc2V0dXBfMTJlICYmCisJKAorCQljZCAxMmUgJiYKKworCQlnaXQgY2hlY2tvdXQgQV4wICYmCisKKwkJZ2l0IC1jIG1lcmdlLmRpcmVjdG9yeVJlbmFtZXM9dHJ1ZSBtZXJnZSAtcyByZWN1cnNpdmUgQl4wICYmCisKKwkJZ2l0IGxzLWZpbGVzIC1zID5vdXQgJiYKKwkJdGVzdF9saW5lX2NvdW50ID0gMiBvdXQgJiYKKworCQlnaXQgcmV2LXBhcnNlID5hY3R1YWwgXAorCQkJSEVBRDpmb28udCAgIEhFQUQ6YmFyLnQgJiYKKwkJZ2l0IHJldi1wYXJzZSA+ZXhwZWN0IFwKKwkJCU86YS9iL2Zvby50ICBCOmEvYi9iYXIudCAmJgorCQl0ZXN0X2NtcCBleHBlY3QgYWN0dWFsICYmCisKKwkJZ2l0IGhhc2gtb2JqZWN0IGJhci50ID5hY3R1YWwgJiYKKwkJZ2l0IHJldi1wYXJzZSBCOmEvYi9iYXIudCA+ZXhwZWN0ICYmCisJCXRlc3RfY21wIGV4cGVjdCBhY3R1YWwgJiYKKworCQl0ZXN0X211c3RfZmFpbCBnaXQgcmV2LXBhcnNlIEhFQUQ6YS9iL2Zvby50ICYmCisJCXRlc3RfbXVzdF9mYWlsIGdpdCByZXYtcGFyc2UgSEVBRDphL2IvYmFyLnQgJiYKKwkJdGVzdF9wYXRoX2lzX21pc3NpbmcgYS8gJiYKKwkJdGVzdF9wYXRoX2lzX2ZpbGUgYmFyLnQKKwkpCisnCisKICMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIwogIyBTRUNUSU9OIDEzOiBDaGVja2luZyBpbmZvcm1hdGlvbmFsIGFuZCBjb25mbGljdCBtZXNzYWdlcwogIwpAQCAtNDA2OCwxMCArNDIzNSwxMCBAQAogIyAgIENvbW1pdCBCOiB6L3tiLGMsZCxlL2Z9CiAjICAgRXhwZWN0ZWQ6IHkve2IsYyxkLGUvZn0sIHdpdGggbm90aWNlcy9jb25mbGljdHMgZm9yIGJvdGggeS9kIGFuZCB5L2UvZgogCi10ZXN0X2V4cGVjdF9zdWNjZXNzICcxM2Etc2V0dXA6IG1lc3NhZ2VzIGZvciBuZXdseSBhZGRlZCBmaWxlcycgJwotCXRlc3RfY3JlYXRlX3JlcG8gMTNhICYmCit0ZXN0X3NldHVwXzEzYSAoKSB7CisJdGVzdF9jcmVhdGVfcmVwbyAxM2FfJDEgJiYKIAkoCi0JCWNkIDEzYSAmJgorCQljZCAxM2FfJDEgJiYKIAogCQlta2RpciB6ICYmCiAJCWVjaG8gYiA+ei9iICYmCkBAIC00MDk3LDExICs0MjY0LDEyIEBACiAJCXRlc3RfdGljayAmJgogCQlnaXQgY29tbWl0IC1tICJCIgogCSkKLScKK30KIAotdGVzdF9leHBlY3Rfc3VjY2VzcyAnMTNhLWNoZWNrKGNvbmZsaWN0KTogbWVzc2FnZXMgZm9yIG5ld2x5IGFkZGVkIGZpbGVzJyAnCit0ZXN0X2V4cGVjdF9zdWNjZXNzICcxM2EoY29uZmxpY3QpOiBtZXNzYWdlcyBmb3IgbmV3bHkgYWRkZWQgZmlsZXMnICcKKwl0ZXN0X3NldHVwXzEzYSBjb25mbGljdCAmJgogCSgKLQkJY2QgMTNhICYmCisJCWNkIDEzYV9jb25mbGljdCAmJgogCiAJCWdpdCBjaGVja291dCBBXjAgJiYKIApAQCAtNDEyMSw5ICs0Mjg5LDEwIEBACiAJKQogJwogCi10ZXN0X2V4cGVjdF9zdWNjZXNzICcxM2EtY2hlY2soaW5mbyk6IG1lc3NhZ2VzIGZvciBuZXdseSBhZGRlZCBmaWxlcycgJwordGVzdF9leHBlY3Rfc3VjY2VzcyAnMTNhKGluZm8pOiBtZXNzYWdlcyBmb3IgbmV3bHkgYWRkZWQgZmlsZXMnICcKKwl0ZXN0X3NldHVwXzEzYSBpbmZvICYmCiAJKAotCQljZCAxM2EgJiYKKwkJY2QgMTNhX2luZm8gJiYKIAogCQlnaXQgcmVzZXQgLS1oYXJkICYmCiAJCWdpdCBjaGVja291dCBBXjAgJiYKQEAgLTQxNTMsMTAgKzQzMjIsMTAgQEAKICMgICBFeHBlY3RlZDogeS97YixjLGRfbWVyZ2VkfSwgd2l0aCB0d28gY29uZmxpY3QgbWVzc2FnZXMgZm9yIHkvZCwKICMgICAgICAgICAgICAgb25lIGFib3V0IGNvbnRlbnQsIGFuZCBvbmUgYWJvdXQgZmlsZSBsb2NhdGlvbgogCi10ZXN0X2V4cGVjdF9zdWNjZXNzICcxM2Itc2V0dXA6IG1lc3NhZ2VzIGZvciB0cmFuc2l0aXZlIHJlbmFtZSB3aXRoIGNvbmZsaWN0ZWQgY29udGVudCcgJwotCXRlc3RfY3JlYXRlX3JlcG8gMTNiICYmCit0ZXN0X3NldHVwXzEzYiAoKSB7CisJdGVzdF9jcmVhdGVfcmVwbyAxM2JfJDEgJiYKIAkoCi0JCWNkIDEzYiAmJgorCQljZCAxM2JfJDEgJiYKIAogCQlta2RpciB4ICYmCiAJCW1rZGlyIHogJiYKQEAgLTQxODUsMTEgKzQzNTQsMTIgQEAKIAkJdGVzdF90aWNrICYmCiAJCWdpdCBjb21taXQgLW0gIkIiCiAJKQotJworfQogCi10ZXN0X2V4cGVjdF9zdWNjZXNzICcxM2ItY2hlY2soY29uZmxpY3QpOiBtZXNzYWdlcyBmb3IgdHJhbnNpdGl2ZSByZW5hbWUgd2l0aCBjb25mbGljdGVkIGNvbnRlbnQnICcKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJzEzYihjb25mbGljdCk6IG1lc3NhZ2VzIGZvciB0cmFuc2l0aXZlIHJlbmFtZSB3aXRoIGNvbmZsaWN0ZWQgY29udGVudCcgJworCXRlc3Rfc2V0dXBfMTNiIGNvbmZsaWN0ICYmCiAJKAotCQljZCAxM2IgJiYKKwkJY2QgMTNiX2NvbmZsaWN0ICYmCiAKIAkJZ2l0IGNoZWNrb3V0IEFeMCAmJgogCkBAIC00MjA3LDkgKzQzNzcsMTAgQEAKIAkpCiAnCiAKLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJzEzYi1jaGVjayhpbmZvKTogbWVzc2FnZXMgZm9yIHRyYW5zaXRpdmUgcmVuYW1lIHdpdGggY29uZmxpY3RlZCBjb250ZW50JyAnCit0ZXN0X2V4cGVjdF9zdWNjZXNzICcxM2IoaW5mbyk6IG1lc3NhZ2VzIGZvciB0cmFuc2l0aXZlIHJlbmFtZSB3aXRoIGNvbmZsaWN0ZWQgY29udGVudCcgJworCXRlc3Rfc2V0dXBfMTNiIGluZm8gJiYKIAkoCi0JCWNkIDEzYiAmJgorCQljZCAxM2JfaW5mbyAmJgogCiAJCWdpdCByZXNldCAtLWhhcmQgJiYKIAkJZ2l0IGNoZWNrb3V0IEFeMCAmJgpAQCAtNDIzOCwxMCArNDQwOSwxMCBAQAogIyAgICAgICAgICAgICBkIGFuZCBCIGhhZCBmdWxsIGtub3dsZWRnZSwgYnV0IHRoYXQncyBhIHNsaXBwZXJ5IHNsb3BlIGFzCiAjICAgICAgICAgICAgIHNob3duIGluIHRlc3RjYXNlIDEzZC4KIAotdGVzdF9leHBlY3Rfc3VjY2VzcyAnMTNjLXNldHVwOiBtZXNzYWdlcyBmb3IgcmVuYW1lL3JlbmFtZSgxdG8xKSB2aWEgdHJhbnNpdGl2ZSByZW5hbWUnICcKLQl0ZXN0X2NyZWF0ZV9yZXBvIDEzYyAmJgordGVzdF9zZXR1cF8xM2MgKCkgeworCXRlc3RfY3JlYXRlX3JlcG8gMTNjXyQxICYmCiAJKAotCQljZCAxM2MgJiYKKwkJY2QgMTNjXyQxICYmCiAKIAkJbWtkaXIgeCAmJgogCQlta2RpciB6ICYmCkBAIC00MjY5LDExICs0NDQwLDEyIEBACiAJCXRlc3RfdGljayAmJgogCQlnaXQgY29tbWl0IC1tICJCIgogCSkKLScKK30KIAotdGVzdF9leHBlY3Rfc3VjY2VzcyAnMTNjLWNoZWNrKGNvbmZsaWN0KTogbWVzc2FnZXMgZm9yIHJlbmFtZS9yZW5hbWUoMXRvMSkgdmlhIHRyYW5zaXRpdmUgcmVuYW1lJyAnCit0ZXN0X2V4cGVjdF9zdWNjZXNzICcxM2MoY29uZmxpY3QpOiBtZXNzYWdlcyBmb3IgcmVuYW1lL3JlbmFtZSgxdG8xKSB2aWEgdHJhbnNpdGl2ZSByZW5hbWUnICcKKwl0ZXN0X3NldHVwXzEzYyBjb25mbGljdCAmJgogCSgKLQkJY2QgMTNjICYmCisJCWNkIDEzY19jb25mbGljdCAmJgogCiAJCWdpdCBjaGVja291dCBBXjAgJiYKIApAQCAtNDI5MCw5ICs0NDYyLDEwIEBACiAJKQogJwogCi10ZXN0X2V4cGVjdF9zdWNjZXNzICcxM2MtY2hlY2soaW5mbyk6IG1lc3NhZ2VzIGZvciByZW5hbWUvcmVuYW1lKDF0bzEpIHZpYSB0cmFuc2l0aXZlIHJlbmFtZScgJwordGVzdF9leHBlY3Rfc3VjY2VzcyAnMTNjKGluZm8pOiBtZXNzYWdlcyBmb3IgcmVuYW1lL3JlbmFtZSgxdG8xKSB2aWEgdHJhbnNpdGl2ZSByZW5hbWUnICcKKwl0ZXN0X3NldHVwXzEzYyBpbmZvICYmCiAJKAotCQljZCAxM2MgJiYKKwkJY2QgMTNjX2luZm8gJiYKIAogCQlnaXQgcmVzZXQgLS1oYXJkICYmCiAJCWdpdCBjaGVja291dCBBXjAgJiYKQEAgLTQzMjQsMTAgKzQ0OTcsMTAgQEAKICMgICAgICAgICAgICAgICAqIEIgcmVuYW1lcyBhL3kgdG8gYy95LCBhbmQgQSByZW5hbWVzIGMvLT5kLyA9PiBhL3kgLT4gZC95CiAjICAgICAgICAgICAgICAgTm8gY29uZmxpY3QgaW4gd2hlcmUgYS95IGVuZHMgdXAsIHNvIHB1dCBpdCBpbiBkL3kuCiAKLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJzEzZC1zZXR1cDogbWVzc2FnZXMgZm9yIHJlbmFtZS9yZW5hbWUoMXRvMSkgdmlhIGR1YWwgdHJhbnNpdGl2ZSByZW5hbWUnICcKLQl0ZXN0X2NyZWF0ZV9yZXBvIDEzZCAmJgordGVzdF9zZXR1cF8xM2QgKCkgeworCXRlc3RfY3JlYXRlX3JlcG8gMTNkXyQxICYmCiAJKAotCQljZCAxM2QgJiYKKwkJY2QgMTNkXyQxICYmCiAKIAkJbWtkaXIgYSAmJgogCQlta2RpciBiICYmCkBAIC00MzU2LDExICs0NTI5LDEyIEBACiAJCXRlc3RfdGljayAmJgogCQlnaXQgY29tbWl0IC1tICJCIgogCSkKLScKK30KIAotdGVzdF9leHBlY3Rfc3VjY2VzcyAnMTNkLWNoZWNrKGNvbmZsaWN0KTogbWVzc2FnZXMgZm9yIHJlbmFtZS9yZW5hbWUoMXRvMSkgdmlhIGR1YWwgdHJhbnNpdGl2ZSByZW5hbWUnICcKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJzEzZChjb25mbGljdCk6IG1lc3NhZ2VzIGZvciByZW5hbWUvcmVuYW1lKDF0bzEpIHZpYSBkdWFsIHRyYW5zaXRpdmUgcmVuYW1lJyAnCisJdGVzdF9zZXR1cF8xM2QgY29uZmxpY3QgJiYKIAkoCi0JCWNkIDEzZCAmJgorCQljZCAxM2RfY29uZmxpY3QgJiYKIAogCQlnaXQgY2hlY2tvdXQgQV4wICYmCiAKQEAgLTQzODAsOSArNDU1NCwxMCBAQAogCSkKICcKIAotdGVzdF9leHBlY3Rfc3VjY2VzcyAnMTNkLWNoZWNrKGluZm8pOiBtZXNzYWdlcyBmb3IgcmVuYW1lL3JlbmFtZSgxdG8xKSB2aWEgZHVhbCB0cmFuc2l0aXZlIHJlbmFtZScgJwordGVzdF9leHBlY3Rfc3VjY2VzcyAnMTNkKGluZm8pOiBtZXNzYWdlcyBmb3IgcmVuYW1lL3JlbmFtZSgxdG8xKSB2aWEgZHVhbCB0cmFuc2l0aXZlIHJlbmFtZScgJworCXRlc3Rfc2V0dXBfMTNkIGluZm8gJiYKIAkoCi0JCWNkIDEzZCAmJgorCQljZCAxM2RfaW5mbyAmJgogCiAJCWdpdCByZXNldCAtLWhhcmQgJiYKIAkJZ2l0IGNoZWNrb3V0IEFeMCAmJgpAQCAtNDQ0OCw3ICs0NjIzLDcgQEAKICMgICAgICAgICAgaW4gdGhlIG91dGVyIG1lcmdlIGZvciB0aGlzIHNwZWNpYWwga2luZCBvZiBzZXR1cCwgYnV0IGl0IGF0CiAjICAgICAgICAgIGxlYXN0IGF2b2lkcyBoaXR0aW5nIGEgQlVHKCkuCiAjCi10ZXN0X2V4cGVjdF9zdWNjZXNzICcxM2Utc2V0dXA6IGRpcmVjdG9yeSByZW5hbWUgZGV0ZWN0aW9uIGluIHJlY3Vyc2l2ZSBjYXNlJyAnCit0ZXN0X3NldHVwXzEzZSAoKSB7CiAJdGVzdF9jcmVhdGVfcmVwbyAxM2UgJiYKIAkoCiAJCWNkIDEzZSAmJgpAQCAtNDQ5Myw5ICs0NjY4LDEwIEBACiAJCXRlc3RfdGljayAmJgogCQlnaXQgY29tbWl0IC1tICJEIgogCSkKLScKK30KIAotdGVzdF9leHBlY3Rfc3VjY2VzcyAnMTNlLWNoZWNrOiBkaXJlY3RvcnkgcmVuYW1lIGRldGVjdGlvbiBpbiByZWN1cnNpdmUgY2FzZScgJwordGVzdF9leHBlY3Rfc3VjY2VzcyAnMTNlOiBkaXJlY3RvcnkgcmVuYW1lIGRldGVjdGlvbiBpbiByZWN1cnNpdmUgY2FzZScgJworCXRlc3Rfc2V0dXBfMTNlICYmCiAJKAogCQljZCAxM2UgJiYKIApkaWZmIC0tZ2l0IGEvdC90NjA0Ni1tZXJnZS1za2lwLXVubmVlZGVkLXVwZGF0ZXMuc2ggYi90L3Q2MDQ2LW1lcmdlLXNraXAtdW5uZWVkZWQtdXBkYXRlcy5zaAppbmRleCAzYTQ3NjIzLi5iN2U0NjY5IDEwMDc1NQotLS0gYS90L3Q2MDQ2LW1lcmdlLXNraXAtdW5uZWVkZWQtdXBkYXRlcy5zaAorKysgYi90L3Q2MDQ2LW1lcmdlLXNraXAtdW5uZWVkZWQtdXBkYXRlcy5zaApAQCAtMzYsMTAgKzM2LDEwIEBACiAjICAgQ29tbWl0IEI6IGJfMwogIyAgIEV4cGVjdGVkOiBiXzIKIAotdGVzdF9leHBlY3Rfc3VjY2VzcyAnMWEtc2V0dXA6IE1vZGlmeShBKS9Nb2RpZnkoQiksIGNoYW5nZSBvbiBCIHN1YnNldCBvZiBBJyAnCi0JdGVzdF9jcmVhdGVfcmVwbyAxYSAmJgordGVzdF9zZXR1cF8xYSAoKSB7CisJdGVzdF9jcmVhdGVfcmVwbyAxYV8kMSAmJgogCSgKLQkJY2QgMWEgJiYKKwkJY2QgMWFfJDEgJiYKIAogCQl0ZXN0X3dyaXRlX2xpbmVzIDEgMiAzIDQgNSA2IDcgOCA5IDEwID5iICYmCiAJCWdpdCBhZGQgYiAmJgpAQCAtNjIsMTMgKzYyLDEyIEBACiAJCXRlc3RfdGljayAmJgogCQlnaXQgY29tbWl0IC1tICJCIgogCSkKLScKK30KIAotdGVzdF9leHBlY3Rfc3VjY2VzcyAnMWEtY2hlY2stTDogTW9kaWZ5KEEpL01vZGlmeShCKSwgY2hhbmdlIG9uIEIgc3Vic2V0IG9mIEEnICcKLQl0ZXN0X3doZW5fZmluaXNoZWQgImdpdCAtQyAxYSByZXNldCAtLWhhcmQiICYmCi0JdGVzdF93aGVuX2ZpbmlzaGVkICJnaXQgLUMgMWEgY2xlYW4gLWZkIiAmJgordGVzdF9leHBlY3Rfc3VjY2VzcyAnMWEtTDogTW9kaWZ5KEEpL01vZGlmeShCKSwgY2hhbmdlIG9uIEIgc3Vic2V0IG9mIEEnICcKKwl0ZXN0X3NldHVwXzFhIEwgJiYKIAkoCi0JCWNkIDFhICYmCisJCWNkIDFhX0wgJiYKIAogCQlnaXQgY2hlY2tvdXQgQV4wICYmCiAKQEAgLTk2LDExICs5NSwxMCBAQAogCSkKICcKIAotdGVzdF9leHBlY3Rfc3VjY2VzcyAnMWEtY2hlY2stUjogTW9kaWZ5KEEpL01vZGlmeShCKSwgY2hhbmdlIG9uIEIgc3Vic2V0IG9mIEEnICcKLQl0ZXN0X3doZW5fZmluaXNoZWQgImdpdCAtQyAxYSByZXNldCAtLWhhcmQiICYmCi0JdGVzdF93aGVuX2ZpbmlzaGVkICJnaXQgLUMgMWEgY2xlYW4gLWZkIiAmJgordGVzdF9leHBlY3Rfc3VjY2VzcyAnMWEtUjogTW9kaWZ5KEEpL01vZGlmeShCKSwgY2hhbmdlIG9uIEIgc3Vic2V0IG9mIEEnICcKKwl0ZXN0X3NldHVwXzFhIFIgJiYKIAkoCi0JCWNkIDFhICYmCisJCWNkIDFhX1IgJiYKIAogCQlnaXQgY2hlY2tvdXQgQl4wICYmCiAKQEAgLTEzMywxMCArMTMxLDEwIEBACiAjICAgQ29tbWl0IEI6IGNfMQogIyAgIEV4cGVjdGVkOiBjXzIKIAotdGVzdF9leHBlY3Rfc3VjY2VzcyAnMmEtc2V0dXA6IE1vZGlmeShBKS9yZW5hbWUoQiknICcKLQl0ZXN0X2NyZWF0ZV9yZXBvIDJhICYmCit0ZXN0X3NldHVwXzJhICgpIHsKKwl0ZXN0X2NyZWF0ZV9yZXBvIDJhXyQxICYmCiAJKAotCQljZCAyYSAmJgorCQljZCAyYV8kMSAmJgogCiAJCXRlc3Rfc2VxIDEgMTAgPmIgJiYKIAkJZ2l0IGFkZCBiICYmCkBAIC0xNTgsMTMgKzE1NiwxMiBAQAogCQl0ZXN0X3RpY2sgJiYKIAkJZ2l0IGNvbW1pdCAtbSAiQiIKIAkpCi0nCit9CiAKLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJzJhLWNoZWNrLUw6IE1vZGlmeS9yZW5hbWUsIG1lcmdlIGludG8gbW9kaWZ5IHNpZGUnICcKLQl0ZXN0X3doZW5fZmluaXNoZWQgImdpdCAtQyAyYSByZXNldCAtLWhhcmQiICYmCi0JdGVzdF93aGVuX2ZpbmlzaGVkICJnaXQgLUMgMmEgY2xlYW4gLWZkIiAmJgordGVzdF9leHBlY3Rfc3VjY2VzcyAnMmEtTDogTW9kaWZ5L3JlbmFtZSwgbWVyZ2UgaW50byBtb2RpZnkgc2lkZScgJworCXRlc3Rfc2V0dXBfMmEgTCAmJgogCSgKLQkJY2QgMmEgJiYKKwkJY2QgMmFfTCAmJgogCiAJCWdpdCBjaGVja291dCBBXjAgJiYKIApAQCAtMTg5LDExICsxODYsMTAgQEAKIAkpCiAnCiAKLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJzJhLWNoZWNrLVI6IE1vZGlmeS9yZW5hbWUsIG1lcmdlIGludG8gcmVuYW1lIHNpZGUnICcKLQl0ZXN0X3doZW5fZmluaXNoZWQgImdpdCAtQyAyYSByZXNldCAtLWhhcmQiICYmCi0JdGVzdF93aGVuX2ZpbmlzaGVkICJnaXQgLUMgMmEgY2xlYW4gLWZkIiAmJgordGVzdF9leHBlY3Rfc3VjY2VzcyAnMmEtUjogTW9kaWZ5L3JlbmFtZSwgbWVyZ2UgaW50byByZW5hbWUgc2lkZScgJworCXRlc3Rfc2V0dXBfMmEgUiAmJgogCSgKLQkJY2QgMmEgJiYKKwkJY2QgMmFfUiAmJgogCiAJCWdpdCBjaGVja291dCBCXjAgJiYKIApAQCAtMjI0LDEwICsyMjAsMTAgQEAKICMgICBDb21taXQgQjogYl8zCiAjICAgRXhwZWN0ZWQ6IGNfMgogCi10ZXN0X2V4cGVjdF9zdWNjZXNzICcyYi1zZXR1cDogUmVuYW1lK01vZChBKS9Nb2QoQiksIEIgbW9kcyBzdWJzZXQgb2YgQScgJwotCXRlc3RfY3JlYXRlX3JlcG8gMmIgJiYKK3Rlc3Rfc2V0dXBfMmIgKCkgeworCXRlc3RfY3JlYXRlX3JlcG8gMmJfJDEgJiYKIAkoCi0JCWNkIDJiICYmCisJCWNkIDJiXyQxICYmCiAKIAkJdGVzdF93cml0ZV9saW5lcyAxIDIgMyA0IDUgNiA3IDggOSAxMCA+YiAmJgogCQlnaXQgYWRkIGIgJiYKQEAgLTI1MSwxMyArMjQ3LDEyIEBACiAJCXRlc3RfdGljayAmJgogCQlnaXQgY29tbWl0IC1tICJCIgogCSkKLScKK30KIAotdGVzdF9leHBlY3Rfc3VjY2VzcyAnMmItY2hlY2stTDogUmVuYW1lK01vZChBKS9Nb2QoQiksIEIgbW9kcyBzdWJzZXQgb2YgQScgJwotCXRlc3Rfd2hlbl9maW5pc2hlZCAiZ2l0IC1DIDJiIHJlc2V0IC0taGFyZCIgJiYKLQl0ZXN0X3doZW5fZmluaXNoZWQgImdpdCAtQyAyYiBjbGVhbiAtZmQiICYmCit0ZXN0X2V4cGVjdF9zdWNjZXNzICcyYi1MOiBSZW5hbWUrTW9kKEEpL01vZChCKSwgQiBtb2RzIHN1YnNldCBvZiBBJyAnCisJdGVzdF9zZXR1cF8yYiBMICYmCiAJKAotCQljZCAyYiAmJgorCQljZCAyYl9MICYmCiAKIAkJZ2l0IGNoZWNrb3V0IEFeMCAmJgogCkBAIC0yODgsMTEgKzI4MywxMCBAQAogCSkKICcKIAotdGVzdF9leHBlY3Rfc3VjY2VzcyAnMmItY2hlY2stUjogUmVuYW1lK01vZChBKS9Nb2QoQiksIEIgbW9kcyBzdWJzZXQgb2YgQScgJwotCXRlc3Rfd2hlbl9maW5pc2hlZCAiZ2l0IC1DIDJiIHJlc2V0IC0taGFyZCIgJiYKLQl0ZXN0X3doZW5fZmluaXNoZWQgImdpdCAtQyAyYiBjbGVhbiAtZmQiICYmCit0ZXN0X2V4cGVjdF9zdWNjZXNzICcyYi1SOiBSZW5hbWUrTW9kKEEpL01vZChCKSwgQiBtb2RzIHN1YnNldCBvZiBBJyAnCisJdGVzdF9zZXR1cF8yYiBSICYmCiAJKAotCQljZCAyYiAmJgorCQljZCAyYl9SICYmCiAKIAkJZ2l0IGNoZWNrb3V0IEJeMCAmJgogCkBAIC0zMzIsNyArMzI2LDcgQEAKICMgICAgICAgICBza2lwIHRoZSB1cGRhdGUsIHRoZW4gd2UncmUgaW4gdHJvdWJsZS4gIFRoaXMgdGVzdCB2ZXJpZmllcyB3ZSBkbwogIyAgICAgICAgIG5vdCBtYWtlIHRoYXQgcGFydGljdWxhciBtaXN0YWtlLgogCi10ZXN0X2V4cGVjdF9zdWNjZXNzICcyYy1zZXR1cDogTW9kaWZ5IGIgJiBhZGQgYyBWUyByZW5hbWUgYi0+YycgJwordGVzdF9zZXR1cF8yYyAoKSB7CiAJdGVzdF9jcmVhdGVfcmVwbyAyYyAmJgogCSgKIAkJY2QgMmMgJiYKQEAgLTM1OCw5ICszNTIsMTAgQEAKIAkJdGVzdF90aWNrICYmCiAJCWdpdCBjb21taXQgLW0gIkIiCiAJKQotJworfQogCi10ZXN0X2V4cGVjdF9zdWNjZXNzICcyYy1jaGVjazogTW9kaWZ5IGIgJiBhZGQgYyBWUyByZW5hbWUgYi0+YycgJwordGVzdF9leHBlY3Rfc3VjY2VzcyAnMmM6IE1vZGlmeSBiICYgYWRkIGMgVlMgcmVuYW1lIGItPmMnICcKKwl0ZXN0X3NldHVwXzJjICYmCiAJKAogCQljZCAyYyAmJgogCkBAIC00MjgsMTAgKzQyMywxMCBAQAogIyAgIENvbW1pdCBCOiBicV8xLCBiYXIvd2hhdGV2ZXIKICMgICBFeHBlY3RlZDogYmFyL3ticV8yLCB3aGF0ZXZlcn0KIAotdGVzdF9leHBlY3Rfc3VjY2VzcyAnM2Etc2V0dXA6IGJxXzEtPmZvby9icV8yIG9uIEEsIGZvby8tPmJhci8gb24gQicgJwotCXRlc3RfY3JlYXRlX3JlcG8gM2EgJiYKK3Rlc3Rfc2V0dXBfM2EgKCkgeworCXRlc3RfY3JlYXRlX3JlcG8gM2FfJDEgJiYKIAkoCi0JCWNkIDNhICYmCisJCWNkIDNhXyQxICYmCiAKIAkJbWtkaXIgZm9vICYmCiAJCXRlc3Rfc2VxIDEgMTAgPmJxICYmCkBAIC00NTYsMTMgKzQ1MSwxMiBAQAogCQl0ZXN0X3RpY2sgJiYKIAkJZ2l0IGNvbW1pdCAtbSAiQiIKIAkpCi0nCit9CiAKLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJzNhLWNoZWNrLUw6IGJxXzEtPmZvby9icV8yIG9uIEEsIGZvby8tPmJhci8gb24gQicgJwotCXRlc3Rfd2hlbl9maW5pc2hlZCAiZ2l0IC1DIDNhIHJlc2V0IC0taGFyZCIgJiYKLQl0ZXN0X3doZW5fZmluaXNoZWQgImdpdCAtQyAzYSBjbGVhbiAtZmQiICYmCit0ZXN0X2V4cGVjdF9zdWNjZXNzICczYS1MOiBicV8xLT5mb28vYnFfMiBvbiBBLCBmb28vLT5iYXIvIG9uIEInICcKKwl0ZXN0X3NldHVwXzNhIEwgJiYKIAkoCi0JCWNkIDNhICYmCisJCWNkIDNhX0wgJiYKIAogCQlnaXQgY2hlY2tvdXQgQV4wICYmCiAKQEAgLTQ4NywxMSArNDgxLDEwIEBACiAJKQogJwogCi10ZXN0X2V4cGVjdF9zdWNjZXNzICczYS1jaGVjay1SOiBicV8xLT5mb28vYnFfMiBvbiBBLCBmb28vLT5iYXIvIG9uIEInICcKLQl0ZXN0X3doZW5fZmluaXNoZWQgImdpdCAtQyAzYSByZXNldCAtLWhhcmQiICYmCi0JdGVzdF93aGVuX2ZpbmlzaGVkICJnaXQgLUMgM2EgY2xlYW4gLWZkIiAmJgordGVzdF9leHBlY3Rfc3VjY2VzcyAnM2EtUjogYnFfMS0+Zm9vL2JxXzIgb24gQSwgZm9vLy0+YmFyLyBvbiBCJyAnCisJdGVzdF9zZXR1cF8zYSBSICYmCiAJKAotCQljZCAzYSAmJgorCQljZCAzYV9SICYmCiAKIAkJZ2l0IGNoZWNrb3V0IEJeMCAmJgogCkBAIC01MjIsMTAgKzUxNSwxMCBAQAogIyAgIENvbW1pdCBCOiBicV8yLCBiYXIvd2hhdGV2ZXIKICMgICBFeHBlY3RlZDogYmFyL3ticV8yLCB3aGF0ZXZlcn0KIAotdGVzdF9leHBlY3Rfc3VjY2VzcyAnM2Itc2V0dXA6IGJxXzEtPmZvby9icV8yIG9uIEEsIGZvby8tPmJhci8gb24gQicgJwotCXRlc3RfY3JlYXRlX3JlcG8gM2IgJiYKK3Rlc3Rfc2V0dXBfM2IgKCkgeworCXRlc3RfY3JlYXRlX3JlcG8gM2JfJDEgJiYKIAkoCi0JCWNkIDNiICYmCisJCWNkIDNiXyQxICYmCiAKIAkJbWtkaXIgZm9vICYmCiAJCXRlc3Rfc2VxIDEgMTAgPmJxICYmCkBAIC01NTAsMTMgKzU0MywxMiBAQAogCQl0ZXN0X3RpY2sgJiYKIAkJZ2l0IGNvbW1pdCAtbSAiQiIKIAkpCi0nCit9CiAKLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJzNiLWNoZWNrLUw6IGJxXzEtPmZvby9icV8yIG9uIEEsIGZvby8tPmJhci8gb24gQicgJwotCXRlc3Rfd2hlbl9maW5pc2hlZCAiZ2l0IC1DIDNiIHJlc2V0IC0taGFyZCIgJiYKLQl0ZXN0X3doZW5fZmluaXNoZWQgImdpdCAtQyAzYiBjbGVhbiAtZmQiICYmCit0ZXN0X2V4cGVjdF9zdWNjZXNzICczYi1MOiBicV8xLT5mb28vYnFfMiBvbiBBLCBmb28vLT5iYXIvIG9uIEInICcKKwl0ZXN0X3NldHVwXzNiIEwgJiYKIAkoCi0JCWNkIDNiICYmCisJCWNkIDNiX0wgJiYKIAogCQlnaXQgY2hlY2tvdXQgQV4wICYmCiAKQEAgLTU4MSwxMSArNTczLDEwIEBACiAJKQogJwogCi10ZXN0X2V4cGVjdF9zdWNjZXNzICczYi1jaGVjay1SOiBicV8xLT5mb28vYnFfMiBvbiBBLCBmb28vLT5iYXIvIG9uIEInICcKLQl0ZXN0X3doZW5fZmluaXNoZWQgImdpdCAtQyAzYiByZXNldCAtLWhhcmQiICYmCi0JdGVzdF93aGVuX2ZpbmlzaGVkICJnaXQgLUMgM2IgY2xlYW4gLWZkIiAmJgordGVzdF9leHBlY3Rfc3VjY2VzcyAnM2ItUjogYnFfMS0+Zm9vL2JxXzIgb24gQSwgZm9vLy0+YmFyLyBvbiBCJyAnCisJdGVzdF9zZXR1cF8zYiBSICYmCiAJKAotCQljZCAzYiAmJgorCQljZCAzYl9SICYmCiAKIAkJZ2l0IGNoZWNrb3V0IEJeMCAmJgogCkBAIC02MjEsNyArNjEyLDcgQEAKICMgICBXb3JraW5nIGNvcHk6IGJfNAogIyAgIEV4cGVjdGVkOiBiXzIgZm9yIG1lcmdlLCBiXzQgaW4gd29ya2luZyBjb3B5CiAKLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJzRhLXNldHVwOiBDaGFuZ2Ugb24gQSwgY2hhbmdlIG9uIEIgc3Vic2V0IG9mIEEsIGRpcnR5IG1vZHMgcHJlc2VudCcgJwordGVzdF9zZXR1cF80YSAoKSB7CiAJdGVzdF9jcmVhdGVfcmVwbyA0YSAmJgogCSgKIAkJY2QgNGEgJiYKQEAgLTY0Nyw3ICs2MzgsNyBAQAogCQl0ZXN0X3RpY2sgJiYKIAkJZ2l0IGNvbW1pdCAtbSAiQiIKIAkpCi0nCit9CiAKICMgTk9URTogRm9yIGFzIGxvbmcgYXMgd2UgY29udGludWUgdXNpbmcgdW5wYWNrX3RyZWVzKCkgd2l0aG91dCBpbmRleF9vbmx5CiAjICAgc2V0IHRvIHRydWUsIGl0IHdpbGwgZXJyb3Igb3V0IG9uIGEgY2FzZSBsaWtlIHRoaXMgY2xhaW1pbmcgdGhlIHRoZSBsb2NhbGx5CkBAIC02NTUsOSArNjQ2LDggQEAKICMgICBjb3JyZWN0IHJlcXVpcmVzIGRvaW5nIHRoZSBtZXJnZSBpbi1tZW1vcnkgZmlyc3QsIHRoZW4gcmVhbGl6aW5nIHRoYXQgbm8KICMgICB1cGRhdGVzIHRvIHRoZSBmaWxlIGFyZSBuZWNlc3NhcnksIGFuZCB0aHVzIHRoYXQgd2UgY2FuIGp1c3QgbGVhdmUgdGhlIHBhdGgKICMgICBhbG9uZS4KLXRlc3RfZXhwZWN0X2ZhaWx1cmUgJzRhLWNoZWNrOiBDaGFuZ2Ugb24gQSwgY2hhbmdlIG9uIEIgc3Vic2V0IG9mIEEsIGRpcnR5IG1vZHMgcHJlc2VudCcgJwotCXRlc3Rfd2hlbl9maW5pc2hlZCAiZ2l0IC1DIDRhIHJlc2V0IC0taGFyZCIgJiYKLQl0ZXN0X3doZW5fZmluaXNoZWQgImdpdCAtQyA0YSBjbGVhbiAtZmQiICYmCit0ZXN0X2V4cGVjdF9mYWlsdXJlICc0YTogQ2hhbmdlIG9uIEEsIGNoYW5nZSBvbiBCIHN1YnNldCBvZiBBLCBkaXJ0eSBtb2RzIHByZXNlbnQnICcKKwl0ZXN0X3NldHVwXzRhICYmCiAJKAogCQljZCA0YSAmJgogCkBAIC02OTUsNyArNjg1LDcgQEAKICMgICBXb3JraW5nIGNvcHk6IGNfNAogIyAgIEV4cGVjdGVkOiBjXzIKIAotdGVzdF9leHBlY3Rfc3VjY2VzcyAnNGItc2V0dXA6IFJlbmFtZStNb2QoQSkvTW9kKEIpLCBjaGFuZ2Ugb24gQiBzdWJzZXQgb2YgQSwgZGlydHkgbW9kcyBwcmVzZW50JyAnCit0ZXN0X3NldHVwXzRiICgpIHsKIAl0ZXN0X2NyZWF0ZV9yZXBvIDRiICYmCiAJKAogCQljZCA0YiAmJgpAQCAtNzIyLDExICs3MTIsMTAgQEAKIAkJdGVzdF90aWNrICYmCiAJCWdpdCBjb21taXQgLW0gIkIiCiAJKQotJworfQogCi10ZXN0X2V4cGVjdF9zdWNjZXNzICc0Yi1jaGVjazogUmVuYW1lK01vZChBKS9Nb2QoQiksIGNoYW5nZSBvbiBCIHN1YnNldCBvZiBBLCBkaXJ0eSBtb2RzIHByZXNlbnQnICcKLQl0ZXN0X3doZW5fZmluaXNoZWQgImdpdCAtQyA0YiByZXNldCAtLWhhcmQiICYmCi0JdGVzdF93aGVuX2ZpbmlzaGVkICJnaXQgLUMgNGIgY2xlYW4gLWZkIiAmJgordGVzdF9leHBlY3Rfc3VjY2VzcyAnNGI6IFJlbmFtZStNb2QoQSkvTW9kKEIpLCBjaGFuZ2Ugb24gQiBzdWJzZXQgb2YgQSwgZGlydHkgbW9kcyBwcmVzZW50JyAnCisJdGVzdF9zZXR1cF80YiAmJgogCSgKIAkJY2QgNGIgJiYKIApkaWZmIC0tZ2l0IGEvdC90NjA0Ny1kaWZmMy1jb25mbGljdC1tYXJrZXJzLnNoIGIvdC90NjA0Ny1kaWZmMy1jb25mbGljdC1tYXJrZXJzLnNoCm5ldyBmaWxlIG1vZGUgMTAwNzU1CmluZGV4IDAwMDAwMDAuLjg2MDU0MmEKLS0tIC9kZXYvbnVsbAorKysgYi90L3Q2MDQ3LWRpZmYzLWNvbmZsaWN0LW1hcmtlcnMuc2gKQEAgLTAsMCArMSwyMDIgQEAKKyMhL2Jpbi9zaAorCit0ZXN0X2Rlc2NyaXB0aW9uPSdyZWN1cnNpdmUgbWVyZ2UgZGlmZjMgc3R5bGUgY29uZmxpY3QgbWFya2VycycKKworLiAuL3Rlc3QtbGliLnNoCisKKyMgU2V0dXA6CisjICAgICAgICAgIEwxCisjICAgICAgICAgICAgXAorIyAgICAgICAgICAgICA/CisjICAgICAgICAgICAgLworIyAgICAgICAgICBSMQorIworIyBXaGVyZToKKyMgICBMMSBhbmQgUjEgYm90aCBoYXZlIGEgZmlsZSBuYW1lZCAnY29udGVudCcgYnV0IGhhdmUgbm8gY29tbW9uIGhpc3RvcnkKKyMKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAnc2V0dXAgbm8gbWVyZ2UgYmFzZScgJworCXRlc3RfY3JlYXRlX3JlcG8gbm9fbWVyZ2VfYmFzZSAmJgorCSgKKwkJY2Qgbm9fbWVyZ2VfYmFzZSAmJgorCisJCWdpdCBjaGVja291dCAtYiBMICYmCisJCXRlc3RfY29tbWl0IEEgY29udGVudCBBICYmCisKKwkJZ2l0IGNoZWNrb3V0IC0tb3JwaGFuIFIgJiYKKwkJdGVzdF9jb21taXQgQiBjb250ZW50IEIKKwkpCisnCisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2NoZWNrIG5vIG1lcmdlIGJhc2UnICcKKwkoCisJCWNkIG5vX21lcmdlX2Jhc2UgJiYKKworCQlnaXQgY2hlY2tvdXQgTF4wICYmCisKKwkJdGVzdF9tdXN0X2ZhaWwgZ2l0IC1jIG1lcmdlLmNvbmZsaWN0c3R5bGU9ZGlmZjMgbWVyZ2UgLS1hbGxvdy11bnJlbGF0ZWQtaGlzdG9yaWVzIC1zIHJlY3Vyc2l2ZSBSXjAgJiYKKworCQlncmVwICJ8fHx8fHwgZW1wdHkgdHJlZSIgY29udGVudAorCSkKKycKKworIyBTZXR1cDoKKyMgICAgICAgICAgTDEKKyMgICAgICAgICAvICBcCisjICAgbWFzdGVyICAgID8KKyMgICAgICAgICBcICAvCisjICAgICAgICAgIFIxCisjCisjIFdoZXJlOgorIyAgIEwxIGFuZCBSMSBoYXZlIG1vZGlmaWVkIHRoZSBzYW1lIGZpbGUgKCdjb250ZW50JykgaW4gY29uZmxpY3Rpbmcgd2F5cworIworCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdzZXR1cCB1bmlxdWUgbWVyZ2UgYmFzZScgJworCXRlc3RfY3JlYXRlX3JlcG8gdW5pcXVlX21lcmdlX2Jhc2UgJiYKKwkoCisJCWNkIHVuaXF1ZV9tZXJnZV9iYXNlICYmCisKKwkJdGVzdF9jb21taXQgYmFzZSBjb250ZW50ICIxCisyCiszCis0Cis1CisiICYmCisKKwkJZ2l0IGJyYW5jaCBMICYmCisJCWdpdCBicmFuY2ggUiAmJgorCisJCWdpdCBjaGVja291dCBMICYmCisJCXRlc3RfY29tbWl0IEwgY29udGVudCAiMQorMgorMworNAorNQorNyIgJiYKKworCQlnaXQgY2hlY2tvdXQgUiAmJgorCQlnaXQgcm0gY29udGVudCAmJgorCQl0ZXN0X2NvbW1pdCBSIHJlbmFtZWQgIjEKKzIKKzMKKzQKKzUKK3NpeCIKKwkpCisnCisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2NoZWNrIHVuaXF1ZSBtZXJnZSBiYXNlJyAnCisJKAorCQljZCB1bmlxdWVfbWVyZ2VfYmFzZSAmJgorCisJCWdpdCBjaGVja291dCBMXjAgJiYKKwkJTUFTVEVSPSQoZ2l0IHJldi1wYXJzZSAtLXNob3J0IG1hc3RlcikgJiYKKworCQl0ZXN0X211c3RfZmFpbCBnaXQgLWMgbWVyZ2UuY29uZmxpY3RzdHlsZT1kaWZmMyBtZXJnZSAtcyByZWN1cnNpdmUgUl4wICYmCisKKwkJZ3JlcCAifHx8fHx8ICRNQVNURVI6Y29udGVudCIgcmVuYW1lZAorCSkKKycKKworIyBTZXR1cDoKKyMgICAgICAgICAgTDEtLS1MMi0tTDMKKyMgICAgICAgICAvICBcIC8gICAgICBcCisjICAgbWFzdGVyICAgIFgxICAgICAgID8KKyMgICAgICAgICBcICAvIFwgICAgICAvCisjICAgICAgICAgIFIxLS0tUjItLVIzCisjCisjIFdoZXJlOgorIyAgIGNvbW1pdHMgTDEgYW5kIFIxIGhhdmUgbW9kaWZpZWQgdGhlIHNhbWUgZmlsZSBpbiBub24tY29uZmxpY3Rpbmcgd2F5cworIyAgIFgxIGlzIGFuIGF1dG8tZ2VuZXJhdGVkIG1lcmdlLWJhc2UgdXNlZCB3aGVuIG1lcmdpbmcgTDEgYW5kIFIxCisjICAgY29tbWl0cyBMMiBhbmQgUjIgYXJlIG1lcmdlcyBvZiBSMSBhbmQgTDEgaW50byBMMSBhbmQgUjEsIHJlc3BlY3RpdmVseQorIyAgIGNvbW1pdHMgTDMgYW5kIFIzIGJvdGggbW9kaWZ5ICdjb250ZW50JyBpbiBjb25mbGljdGluZyB3YXlzCisjCisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3NldHVwIG11bHRpcGxlIG1lcmdlIGJhc2VzJyAnCisJdGVzdF9jcmVhdGVfcmVwbyBtdWx0aXBsZV9tZXJnZV9iYXNlcyAmJgorCSgKKwkJY2QgbXVsdGlwbGVfbWVyZ2VfYmFzZXMgJiYKKworCQl0ZXN0X2NvbW1pdCBpbml0aWFsIGNvbnRlbnQgIjEKKzIKKzMKKzQKKzUiICYmCisKKwkJZ2l0IGJyYW5jaCBMICYmCisJCWdpdCBicmFuY2ggUiAmJgorCisJCSMgQ3JlYXRlIEwxCisJCWdpdCBjaGVja291dCBMICYmCisJCXRlc3RfY29tbWl0IEwxIGNvbnRlbnQgIjAKKzEKKzIKKzMKKzQKKzUiICYmCisKKwkJIyBDcmVhdGUgUjEKKwkJZ2l0IGNoZWNrb3V0IFIgJiYKKwkJdGVzdF9jb21taXQgUjEgY29udGVudCAiMQorMgorMworNAorNQorNiIgJiYKKworCQkjIENyZWF0ZSBMMgorCQlnaXQgY2hlY2tvdXQgTCAmJgorCQlnaXQgbWVyZ2UgUjEgJiYKKworCQkjIENyZWF0ZSBSMgorCQlnaXQgY2hlY2tvdXQgUiAmJgorCQlnaXQgbWVyZ2UgTDEgJiYKKworCQkjIENyZWF0ZSBMMworCQlnaXQgY2hlY2tvdXQgTCAmJgorCQl0ZXN0X2NvbW1pdCBMMyBjb250ZW50ICIwCisxCisyCiszCis0Cis1CitBIiAmJgorCisJCSMgQ3JlYXRlIFIzCisJCWdpdCBjaGVja291dCBSICYmCisJCWdpdCBybSBjb250ZW50ICYmCisJCXRlc3RfY29tbWl0IFIzIHJlbmFtZWQgIjAKKzIKKzMKKzQKKzUKK3NpeCIKKwkpCisnCisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2NoZWNrIG11bHRpcGxlIG1lcmdlIGJhc2VzJyAnCisJKAorCQljZCBtdWx0aXBsZV9tZXJnZV9iYXNlcyAmJgorCisJCWdpdCBjaGVja291dCBMXjAgJiYKKworCQl0ZXN0X211c3RfZmFpbCBnaXQgLWMgbWVyZ2UuY29uZmxpY3RzdHlsZT1kaWZmMyBtZXJnZSAtcyByZWN1cnNpdmUgUl4wICYmCisKKwkJZ3JlcCAifHx8fHx8IG1lcmdlZCBjb21tb24gYW5jZXN0b3JzOmNvbnRlbnQiIHJlbmFtZWQKKwkpCisnCisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3JlYmFzZSBkZXNjcmliZXMgZmFrZSBhbmNlc3RvciBiYXNlJyAnCisJdGVzdF9jcmVhdGVfcmVwbyByZWJhc2UgJiYKKwkoCisJCWNkIHJlYmFzZSAmJgorCQl0ZXN0X2NvbW1pdCBiYXNlIGZpbGUgJiYKKwkJdGVzdF9jb21taXQgbWFzdGVyIGZpbGUgJiYKKwkJZ2l0IGNoZWNrb3V0IC1iIHNpZGUgSEVBRF4gJiYKKwkJdGVzdF9jb21taXQgc2lkZSBmaWxlICYmCisJCXRlc3RfbXVzdF9mYWlsIGdpdCAtYyBtZXJnZS5jb25mbGljdHN0eWxlPWRpZmYzIHJlYmFzZSBtYXN0ZXIgJiYKKwkJZ3JlcCAifHx8fHx8fCBjb25zdHJ1Y3RlZCBtZXJnZSBiYXNlIiBmaWxlCisJKQorJworCit0ZXN0X2RvbmUKZGlmZiAtLWdpdCBhL3QvdDYxMDItcmV2LWxpc3QtdW5leHBlY3RlZC1vYmplY3RzLnNoIGIvdC90NjEwMi1yZXYtbGlzdC11bmV4cGVjdGVkLW9iamVjdHMuc2gKaW5kZXggMjg2MTFjOS4uNTJjZGUwOSAxMDA3NTUKLS0tIGEvdC90NjEwMi1yZXYtbGlzdC11bmV4cGVjdGVkLW9iamVjdHMuc2gKKysrIGIvdC90NjEwMi1yZXYtbGlzdC11bmV4cGVjdGVkLW9iamVjdHMuc2gKQEAgLTUyLDcgKzUyLDcgQEAKICcKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAndHJhdmVyc2UgdW5leHBlY3RlZCBub24tY29tbWl0IHBhcmVudCAoc2VlbiknICcKLQl0ZXN0X211c3RfZmFpbCBnaXQgcmV2LWxpc3QgLS1vYmplY3RzICRjb21taXQgJGJyb2tlbl9jb21taXQgXAorCXRlc3RfbXVzdF9mYWlsIGdpdCByZXYtbGlzdCAtLW9iamVjdHMgJGJsb2IgJGJyb2tlbl9jb21taXQgXAogCQk+b3V0cHV0IDI+JjEgJiYKIAl0ZXN0X2kxOG5ncmVwICJub3QgYSBjb21taXQiIG91dHB1dAogJwpkaWZmIC0tZ2l0IGEvdC90NjExMi1yZXYtbGlzdC1maWx0ZXJzLW9iamVjdHMuc2ggYi90L3Q2MTEyLXJldi1saXN0LWZpbHRlcnMtb2JqZWN0cy5zaAppbmRleCBhY2Q3ZjVhLi5kZTBlNWE1IDEwMDc1NQotLS0gYS90L3Q2MTEyLXJldi1saXN0LWZpbHRlcnMtb2JqZWN0cy5zaAorKysgYi90L3Q2MTEyLXJldi1saXN0LWZpbHRlcnMtb2JqZWN0cy5zaApAQCAtMjc4LDcgKzI3OCwxOSBAQAogCXRlc3RfbGluZV9jb3VudCA9IDIgYWN0dWFsICYmCiAKIAkjIE1ha2Ugc3VyZSBubyBvdGhlciB0cmVlcyB3ZXJlIGNvbnNpZGVyZWQgYmVzaWRlcyB0aGUgcm9vdC4KLQkhIGdyZXAgIlNraXBwaW5nIGNvbnRlbnRzIG9mIHRyZWUgW14uXSIgZmlsdGVyX3RyYWNlCisJISBncmVwICJTa2lwcGluZyBjb250ZW50cyBvZiB0cmVlIFteLl0iIGZpbHRlcl90cmFjZSAmJgorCisJIyBUcnkgdGhpcyBhZ2FpbiB3aXRoICJjb21iaW5lOiIuIElmIGJvdGggc3ViLWZpbHRlcnMgYXJlIHNraXBwaW5nCisJIyB0cmVlcywgdGhlIGNvbXBvc2l0ZSBmaWx0ZXIgc2hvdWxkIGFsc28gc2tpcCB0cmVlcy4gVGhpcyBpcyBub3QKKwkjIGltcG9ydGFudCB1bmxlc3MgdGhlIHVzZXIgZG9lcyBjb21iaW5lOnRyZWU6WCt0cmVlOlkgb3IgYW5vdGhlciBmaWx0ZXIKKwkjIGJlc2lkZXMgInRyZWU6IiBpcyBpbXBsZW1lbnRlZCBpbiB0aGUgZnV0dXJlIHdoaWNoIGNhbiBza2lwIHRyZWVzLgorCUdJVF9UUkFDRT0xIGdpdCAtQyByMyByZXYtbGlzdCBcCisJCS0tb2JqZWN0cyAtLWZpbHRlcj1jb21iaW5lOnRyZWU6MSt0cmVlOjMgSEVBRCAyPmZpbHRlcl90cmFjZSAmJgorCisJIyBPbmx5IHNraXAgdGhlIGRpcjEvIHRyZWUsIHdoaWNoIGlzIHNoYXJlZCBiZXR3ZWVuIHRoZSB0d28gY29tbWl0cy4KKwlncmVwICJTa2lwcGluZyBjb250ZW50cyBvZiB0cmVlICIgZmlsdGVyX3RyYWNlID5hY3R1YWwgJiYKKwl0ZXN0X3dyaXRlX2xpbmVzICJTa2lwcGluZyBjb250ZW50cyBvZiB0cmVlIGRpcjEvLi4uIiA+ZXhwZWN0ZWQgJiYKKwl0ZXN0X2NtcCBleHBlY3RlZCBhY3R1YWwKICcKIAogIyBUZXN0IHRyZWU6IyBmaWx0ZXJzLgpAQCAtMzMwLDYgKzM0MiwxNDggQEAKIAl0ZXN0X2xpbmVfY291bnQgPSAxMCBhY3R1YWwKICcKIAordGVzdF9leHBlY3Rfc3VjY2VzcyAnY29tYmluZTouLi4gZm9yIGEgc2ltcGxlIGNvbWJpbmF0aW9uJyAnCisJZ2l0IC1DIHIzIHJldi1saXN0IC0tb2JqZWN0cyAtLWZpbHRlcj1jb21iaW5lOnRyZWU6MitibG9iOm5vbmUgSEVBRCBcCisJCT5hY3R1YWwgJiYKKworCWV4cGVjdF9oYXMgSEVBRCAiIiAmJgorCWV4cGVjdF9oYXMgSEVBRH4xICIiICYmCisJZXhwZWN0X2hhcyBIRUFEIGRpcjEgJiYKKworCSMgVGhlcmUgYXJlIGFsc28gMiBjb21taXQgb2JqZWN0cworCXRlc3RfbGluZV9jb3VudCA9IDUgYWN0dWFsICYmCisKKwljcCBhY3R1YWwgZXhwZWN0ZWQgJiYKKworCSMgVHJ5IGFnYWluIHVzaW5nIHJlcGVhdGVkIC0tZmlsdGVyIC0gdGhpcyBpcyBlcXVpdmFsZW50IHRvIGEgbWFudWFsCisJIyBjb21iaW5lIHdpdGggImNvbWJpbmU6Li4uKy4uLiIKKwlnaXQgLUMgcjMgcmV2LWxpc3QgLS1vYmplY3RzIC0tZmlsdGVyPWNvbWJpbmU6dHJlZToyIFwKKwkJLS1maWx0ZXI9YmxvYjpub25lIEhFQUQgPmFjdHVhbCAmJgorCisJdGVzdF9jbXAgZXhwZWN0ZWQgYWN0dWFsCisnCisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2NvbWJpbmU6Li4uIHdpdGggVVJMIGVuY29kaW5nJyAnCisJZ2l0IC1DIHIzIHJldi1saXN0IC0tb2JqZWN0cyBcCisJCS0tZmlsdGVyPWNvbWJpbmU6dHJlZSUzYTIrYmxvYjolNkVvbiU2NSBIRUFEID5hY3R1YWwgJiYKKworCWV4cGVjdF9oYXMgSEVBRCAiIiAmJgorCWV4cGVjdF9oYXMgSEVBRH4xICIiICYmCisJZXhwZWN0X2hhcyBIRUFEIGRpcjEgJiYKKworCSMgVGhlcmUgYXJlIGFsc28gMiBjb21taXQgb2JqZWN0cworCXRlc3RfbGluZV9jb3VudCA9IDUgYWN0dWFsCisnCisKK2V4cGVjdF9pbnZhbGlkX2ZpbHRlcl9zcGVjICgpIHsKKwlzcGVjPSIkMSIgJiYKKwllcnI9IiQyIiAmJgorCisJdGVzdF9tdXN0X2ZhaWwgZ2l0IC1DIHIzIHJldi1saXN0IC0tb2JqZWN0cyAtLWZpbHRlcj0iJHNwZWMiIEhFQUQgXAorCQk+YWN0dWFsIDI+YWN0dWFsX3N0ZGVyciAmJgorCXRlc3RfbXVzdF9iZV9lbXB0eSBhY3R1YWwgJiYKKwl0ZXN0X2kxOG5ncmVwICIkZXJyIiBhY3R1YWxfc3RkZXJyCit9CisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2NvbWJpbmU6Li4uIHdoaWxlIFVSTC1lbmNvZGluZyB0aGluZ3MgdGhhdCBzaG91bGQgbm90IGJlJyAnCisJZXhwZWN0X2ludmFsaWRfZmlsdGVyX3NwZWMgY29tYmluZSUzQXRyZWU6MitibG9iOm5vbmUgXAorCQkiaW52YWxpZCBmaWx0ZXItc3BlYyIKKycKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAnY29tYmluZTogd2l0aCBub3RoaW5nIGFmdGVyIHRoZSA6JyAnCisJZXhwZWN0X2ludmFsaWRfZmlsdGVyX3NwZWMgY29tYmluZTogImV4cGVjdGVkIHNvbWV0aGluZyBhZnRlciBjb21iaW5lOiIKKycKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAncGFyc2UgZXJyb3IgaW4gZmlyc3Qgc3ViLWZpbHRlciBpbiBjb21iaW5lOicgJworCWV4cGVjdF9pbnZhbGlkX2ZpbHRlcl9zcGVjIGNvbWJpbmU6dHJlZTphc2RmK2Jsb2I6bm9uZSBcCisJCSJleHBlY3RlZCAudHJlZTo8ZGVwdGg+LiIKKycKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAnY29tYmluZTouLi4gd2l0aCBub24tZW5jb2RlZCByZXNlcnZlZCBjaGFycycgJworCWV4cGVjdF9pbnZhbGlkX2ZpbHRlcl9zcGVjIGNvbWJpbmU6dHJlZToyK3NwYXJzZTpAeHl6IFwKKwkJIm11c3QgZXNjYXBlIGNoYXIgaW4gc3ViLWZpbHRlci1zcGVjOiAuQC4iICYmCisJZXhwZWN0X2ludmFsaWRfZmlsdGVyX3NwZWMgY29tYmluZTp0cmVlOjIrc3BhcnNlOlxgIFwKKwkJIm11c3QgZXNjYXBlIGNoYXIgaW4gc3ViLWZpbHRlci1zcGVjOiAuXGAuIiAmJgorCWV4cGVjdF9pbnZhbGlkX2ZpbHRlcl9zcGVjIGNvbWJpbmU6dHJlZToyK3NwYXJzZTp+YWJjIFwKKwkJIm11c3QgZXNjYXBlIGNoYXIgaW4gc3ViLWZpbHRlci1zcGVjOiAuXH4uIgorJworCit0ZXN0X2V4cGVjdF9zdWNjZXNzICd2YWxpZGF0ZSBlcnIgbXNnIGZvciAiY29tYmluZTo8dmFsaWQtZmlsdGVyPisiJyAnCisJZXhwZWN0X2ludmFsaWRfZmlsdGVyX3NwZWMgY29tYmluZTp0cmVlOjIrICJleHBlY3RlZCAudHJlZTo8ZGVwdGg+LiIKKycKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAnY29tYmluZTouLi4gd2l0aCBlZGdlLWNhc2UgaGV4IGRpZ2l0czogRmYgQWEgMCA5JyAnCisJZ2l0IC1DIHIzIHJldi1saXN0IC0tb2JqZWN0cyAtLWZpbHRlcj0iY29tYmluZTp0cmVlOjIrYmwlNkZiOm4lNmZuZSIgXAorCQlIRUFEID5hY3R1YWwgJiYKKwl0ZXN0X2xpbmVfY291bnQgPSA1IGFjdHVhbCAmJgorCWdpdCAtQyByMyByZXYtbGlzdCAtLW9iamVjdHMgLS1maWx0ZXI9ImNvbWJpbmU6dHJlZSUzQTIrYmxvYiUzYW5vbmUiIFwKKwkJSEVBRCA+YWN0dWFsICYmCisJdGVzdF9saW5lX2NvdW50ID0gNSBhY3R1YWwgJiYKKwlnaXQgLUMgcjMgcmV2LWxpc3QgLS1vYmplY3RzIC0tZmlsdGVyPSJjb21iaW5lOnRyZWU6JTMwIiBIRUFEID5hY3R1YWwgJiYKKwl0ZXN0X2xpbmVfY291bnQgPSAyIGFjdHVhbCAmJgorCWdpdCAtQyByMyByZXYtbGlzdCAtLW9iamVjdHMgLS1maWx0ZXI9ImNvbWJpbmU6dHJlZTolMzkrYmxvYjpub25lIiBcCisJCUhFQUQgPmFjdHVhbCAmJgorCXRlc3RfbGluZV9jb3VudCA9IDUgYWN0dWFsCisnCisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2FkZCBzcGFyc2UgcGF0dGVybiBibG9icyB3aG9zZSBwYXRocyBoYXZlIHJlc2VydmVkIGNoYXJzJyAnCisJY3AgcjMvcGF0dGVybiByMy9wYXR0ZXJuMStyZW5hbWVkJSAmJgorCWNwIHIzL3BhdHRlcm4gInIzL3A7YXQldGVyK24iICYmCisJY3AgcjMvcGF0dGVybiByMy9efnBhdHRlcm4gJiYKKwlnaXQgLUMgcjMgYWRkIHBhdHRlcm4xK3JlbmFtZWQlICJwO2F0JXRlcituIiBefnBhdHRlcm4gJiYKKwlnaXQgLUMgcjMgY29tbWl0IC1tICJhZGQgc3BhcnNlIHBhdHRlcm4gZmlsZXMgd2l0aCByZXNlcnZlZCBjaGFycyIKKycKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAnY29tYmluZTouLi4gd2l0aCBtb3JlIHRoYW4gdHdvIHN1Yi1maWx0ZXJzJyAnCisJZ2l0IC1DIHIzIHJldi1saXN0IC0tb2JqZWN0cyBcCisJCS0tZmlsdGVyPWNvbWJpbmU6dHJlZTozK2Jsb2I6bGltaXQ9NDArc3BhcnNlOm9pZD1tYXN0ZXI6cGF0dGVybiBcCisJCUhFQUQgPmFjdHVhbCAmJgorCisJZXhwZWN0X2hhcyBIRUFEICIiICYmCisJZXhwZWN0X2hhcyBIRUFEfjEgIiIgJiYKKwlleHBlY3RfaGFzIEhFQUR+MiAiIiAmJgorCWV4cGVjdF9oYXMgSEVBRCBkaXIxICYmCisJZXhwZWN0X2hhcyBIRUFEIGRpcjEvc3BhcnNlMSAmJgorCWV4cGVjdF9oYXMgSEVBRCBkaXIxL3NwYXJzZTIgJiYKKworCSMgU2hvdWxkIGFsc28gaGF2ZSAzIGNvbW1pdHMKKwl0ZXN0X2xpbmVfY291bnQgPSA5IGFjdHVhbCAmJgorCisJIyBUcnkgYWdhaW4sIHRoaXMgdGltZSBtYWtpbmcgc3VyZSB0aGUgbGFzdCBzdWItZmlsdGVyIGlzIG9ubHkKKwkjIFVSTC1kZWNvZGVkIG9uY2UuCisJY3AgYWN0dWFsIGV4cGVjdCAmJgorCisJZ2l0IC1DIHIzIHJldi1saXN0IC0tb2JqZWN0cyBcCisJCS0tZmlsdGVyPWNvbWJpbmU6dHJlZTozK2Jsb2I6bGltaXQ9NDArc3BhcnNlOm9pZD1tYXN0ZXI6cGF0dGVybjElMmJyZW5hbWVkJTI1IFwKKwkJSEVBRCA+YWN0dWFsICYmCisJdGVzdF9jbXAgZXhwZWN0IGFjdHVhbCAmJgorCisJIyBVc2UgdGhlIHNhbWUgY29tcG9zaXRlIGZpbHRlciBhZ2FpbiwgYnV0IHdpdGggYSBwYXR0ZXJuIGZpbGUgbmFtZSB0aGF0CisJIyByZXF1aXJlcyBlbmNvZGluZyBtdWx0aXBsZSBjaGFyYWN0ZXJzLCBhbmQgdXNlIGltcGxpY2l0IGZpbHRlcgorCSMgY29tYmluaW5nLgorCXRlc3Rfd2hlbl9maW5pc2hlZCAicm0gLWYgdHJhY2UxIiAmJgorCUdJVF9UUkFDRT0kKHB3ZCkvdHJhY2UxIGdpdCAtQyByMyByZXYtbGlzdCAtLW9iamVjdHMgXAorCQktLWZpbHRlcj10cmVlOjMgLS1maWx0ZXI9YmxvYjpsaW1pdD00MCBcCisJCS0tZmlsdGVyPXNwYXJzZTpvaWQ9Im1hc3RlcjpwO2F0JXRlcituIiBcCisJCUhFQUQgPmFjdHVhbCAmJgorCisJdGVzdF9jbXAgZXhwZWN0IGFjdHVhbCAmJgorCWdyZXAgIkFkZCB0byBjb21iaW5lIGZpbHRlci1zcGVjOiBzcGFyc2U6b2lkPW1hc3RlcjpwJTNiYXQlMjV0ZXIlMmJuIiBcCisJCXRyYWNlMSAmJgorCisJIyBSZXBlYXQgdGhlIGFib3ZlIHRlc3QsIGJ1dCB0aGlzIHRpbWUsIHRoZSBjaGFyYWN0ZXJzIHRvIGVuY29kZSBhcmUgaW4KKwkjIHRoZSBMSFMgb2YgdGhlIGNvbWJpbmVkIGZpbHRlci4KKwl0ZXN0X3doZW5fZmluaXNoZWQgInJtIC1mIHRyYWNlMiIgJiYKKwlHSVRfVFJBQ0U9JChwd2QpL3RyYWNlMiBnaXQgLUMgcjMgcmV2LWxpc3QgLS1vYmplY3RzIFwKKwkJLS1maWx0ZXI9c3BhcnNlOm9pZD1tYXN0ZXI6Xn5wYXR0ZXJuIFwKKwkJLS1maWx0ZXI9dHJlZTozIC0tZmlsdGVyPWJsb2I6bGltaXQ9NDAgXAorCQlIRUFEID5hY3R1YWwgJiYKKworCXRlc3RfY21wIGV4cGVjdCBhY3R1YWwgJiYKKwlncmVwICJBZGQgdG8gY29tYmluZSBmaWx0ZXItc3BlYzogc3BhcnNlOm9pZD1tYXN0ZXI6JTVlJTdlcGF0dGVybiIgXAorCQl0cmFjZTIKKycKKwogIyBUZXN0IHByb3Zpc2lvbmFsIG9taXQgY29sbGVjdGlvbiBsb2dpYyB3aXRoIGEgcmVwbyB0aGF0IGhhcyBvYmplY3RzIGFwcGVhcmluZwogIyBhdCBtdWx0aXBsZSBkZXB0aHMgLSBmaXJzdCBkZWVwZXIgdGhhbiB0aGUgZmlsdGVyJ3MgdGhyZXNob2xkLCB0aGVuIHNoYWxsb3cuCiAKQEAgLTM3Myw2ICs1MjcsMzcgQEAKIAl0ZXN0X2NtcCBleHBlY3QgYWN0dWFsCiAnCiAKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3NldHVwIHI1JyAnCisJZ2l0IGluaXQgcjUgJiYKKwlta2RpciAtcCByNS9zdWJkaXIgJiYKKworCWVjaG8gMSAgICAgPnI1L3Nob3J0LXJvb3QgICAgICAgICAgJiYKKwllY2hvIDEyMzQ1ID5yNS9sb25nLXJvb3QgICAgICAgICAgICYmCisJZWNobyBhICAgICA+cjUvc3ViZGlyL3Nob3J0LXN1YmRpciAmJgorCWVjaG8gYWJjZGUgPnI1L3N1YmRpci9sb25nLXN1YmRpciAgJiYKKworCWdpdCAtQyByNSBhZGQgc2hvcnQtcm9vdCBsb25nLXJvb3Qgc3ViZGlyICYmCisJZ2l0IC1DIHI1IGNvbW1pdCAtbSAiY29tbWl0IG1zZyIKKycKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAndmVyaWZ5IGNvbGxlY3Rpbmcgb21pdHMgaW4gY29tYmluZWQ6IGZpbHRlcicgJworCSMgTm90ZSB0aGF0IHRoaXMgdGVzdCBndWFyZHMgYWdhaW5zdCB0aGUgbmFpdmUgaW1wbGVtZW50YXRpb24gb2Ygc2ltcGx5CisJIyBnaXZpbmcgYm90aCBmaWx0ZXJzIHRoZSBzYW1lICJvbWl0cyIgc2V0IGFuZCBleHBlY3RpbmcgaXQgdG8KKwkjIGF1dG9tYXRpY2FsbHkgbWVyZ2UgdGhlbS4KKwlnaXQgLUMgcjUgcmV2LWxpc3QgLS1vYmplY3RzIC0tcXVpZXQgLS1maWx0ZXItcHJpbnQtb21pdHRlZCBcCisJCS0tZmlsdGVyPWNvbWJpbmU6dHJlZToyK2Jsb2I6bGltaXQ9MyBIRUFEID5hY3R1YWwgJiYKKworCSMgRXhwZWN0IDAgdHJlZXMvY29tbWl0cywgMyBibG9icyBvbWl0dGVkIChhbGwgYmxvYnMgZXhjZXB0IHNob3J0LXJvb3QpCisJb21pdHRlZF8xPSQoZWNobyAxMjM0NSB8IGdpdCBoYXNoLW9iamVjdCAtLXN0ZGluKSAmJgorCW9taXR0ZWRfMj0kKGVjaG8gYSAgICAgfCBnaXQgaGFzaC1vYmplY3QgLS1zdGRpbikgJiYKKwlvbWl0dGVkXzM9JChlY2hvIGFiY2RlIHwgZ2l0IGhhc2gtb2JqZWN0IC0tc3RkaW4pICYmCisKKwlncmVwIH4kb21pdHRlZF8xIGFjdHVhbCAmJgorCWdyZXAgfiRvbWl0dGVkXzIgYWN0dWFsICYmCisJZ3JlcCB+JG9taXR0ZWRfMyBhY3R1YWwgJiYKKwl0ZXN0X2xpbmVfY291bnQgPSAzIGFjdHVhbAorJworCiAjIFRlc3QgdHJlZTo8ZGVwdGg+IHdoZXJlIGEgdHJlZSBpcyBpdGVyYXRlZCB0byB0d2ljZSAtIG9uY2Ugd2hlcmUgYSBzdWJlbnRyeSBpcwogIyB0b28gZGVlcCB0byBiZSBpbmNsdWRlZCwgYW5kIGFnYWluIHdoZXJlIHRoZSBibG9iIGluc2lkZSBpdCBpcyBzaGFsbG93IGVub3VnaAogIyB0byBiZSBpbmNsdWRlZC4gVGhpcyBtYWtlcyBzdXJlIHdlIGRvbid0IHVzZSBMT0ZSX01BUktfU0VFTiBpbmNvcnJlY3RseSAod2UKQEAgLTQ0MSwxMSArNjI2LDQgQEAKIAlncmVwICJibG9iOmxpbWl0PTEwMjQiIHRyYWNlCiAnCiAKLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2V4cGFuZCB0cmVlIGRlcHRoIGxpbWl0IGluIHByb3RvY29sJyAnCi0JR0lUX1RSQUNFX1BBQ0tFVD0iJChwd2QpL3RyZWVfdHJhY2UiIGdpdCAtYyBwcm90b2NvbC52ZXJzaW9uPTIgY2xvbmUgXAotCQktLWZpbHRlcj10cmVlOjBrICJmaWxlOi8vJChwd2QpL3IyIiB0cmVlICYmCi0JISBncmVwICJ0cmVlOjBrIiB0cmVlX3RyYWNlICYmCi0JZ3JlcCAidHJlZTowIiB0cmVlX3RyYWNlCi0nCi0KIHRlc3RfZG9uZQpkaWZmIC0tZ2l0IGEvdC90NjEyMC1kZXNjcmliZS5zaCBiL3QvdDYxMjAtZGVzY3JpYmUuc2gKaW5kZXggMmI4ODNkOC4uNDUwNDdkMCAxMDA3NTUKLS0tIGEvdC90NjEyMC1kZXNjcmliZS5zaAorKysgYi90L3Q2MTIwLWRlc2NyaWJlLnNoCkBAIC00MjQsNCArNDI0LDE5IEBACiAJdGVzdF9tdXN0X2ZhaWwgZ2l0IGRlc2NyaWJlICRaRVJPX09JRAogJwogCit0ZXN0X2V4cGVjdF9zdWNjZXNzICduYW1lLXJldiBhIHJldiBzaG9ydGx5IGFmdGVyIGVwb2NoJyAnCisJdGVzdF93aGVuX2ZpbmlzaGVkICJnaXQgY2hlY2tvdXQgbWFzdGVyIiAmJgorCisJZ2l0IGNoZWNrb3V0IC0tb3JwaGFuIG5vLXRpbWVzdGFtcC11bmRlcmZsb3cgJiYKKwkjIEFueSBkYXRlIGNsb3NlciB0byBlcG9jaCB0aGFuIHRoZSBDVVRPRkZfREFURV9TTE9QIGNvbnN0YW50CisJIyBpbiBidWlsdGluL25hbWUtcmV2LmMuCisJR0lUX0NPTU1JVFRFUl9EQVRFPSJAMTIzNCArMDAwMCIgXAorCWdpdCBjb21taXQgLW0gImNvbW1pdHRlciBkYXRlIHNob3J0bHkgYWZ0ZXIgZXBvY2giICYmCisJb2xkX2NvbW1pdF9vaWQ9JChnaXQgcmV2LXBhcnNlIEhFQUQpICYmCisKKwllY2hvICIkb2xkX2NvbW1pdF9vaWQgbm8tdGltZXN0YW1wLXVuZGVyZmxvdyIgPmV4cGVjdCAmJgorCWdpdCBuYW1lLXJldiAkb2xkX2NvbW1pdF9vaWQgPmFjdHVhbCAmJgorCXRlc3RfY21wIGV4cGVjdCBhY3R1YWwKKycKKwogdGVzdF9kb25lCmRpZmYgLS1naXQgYS90L3Q2MzAwLWZvci1lYWNoLXJlZi5zaCBiL3QvdDYzMDAtZm9yLWVhY2gtcmVmLnNoCmluZGV4IGFiNjlhYTEuLjljOTEwY2UgMTAwNzU1Ci0tLSBhL3QvdDYzMDAtZm9yLWVhY2gtcmVmLnNoCisrKyBiL3QvdDYzMDAtZm9yLWVhY2gtcmVmLnNoCkBAIC01MjYsNiArNTI2LDI1IEBACiAJdGVzdF9jbXAgZXhwZWN0ZWQgYWN0dWFsCiAnCiAKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2NyZWF0ZSB0YWcgd2l0aG91dCB0YWdnZXInICcKKwlnaXQgdGFnIC1hIC1tICJCcm9rZW4gdGFnIiB0YWdnZXJsZXNzICYmCisJZ2l0IHRhZyAtZiB0YWdnZXJsZXNzICQoZ2l0IGNhdC1maWxlIHRhZyB0YWdnZXJsZXNzIHwKKwkJc2VkIC1lICIvXnRhZ2dlciAvZCIgfAorCQlnaXQgaGFzaC1vYmplY3QgLS1zdGRpbiAtdyAtdCB0YWcpCisnCisKK3Rlc3RfYXRvbSByZWZzL3RhZ3MvdGFnZ2VybGVzcyB0eXBlICdjb21taXQnCit0ZXN0X2F0b20gcmVmcy90YWdzL3RhZ2dlcmxlc3MgdGFnICd0YWdnZXJsZXNzJwordGVzdF9hdG9tIHJlZnMvdGFncy90YWdnZXJsZXNzIHRhZ2dlciAnJwordGVzdF9hdG9tIHJlZnMvdGFncy90YWdnZXJsZXNzIHRhZ2dlcm5hbWUgJycKK3Rlc3RfYXRvbSByZWZzL3RhZ3MvdGFnZ2VybGVzcyB0YWdnZXJlbWFpbCAnJwordGVzdF9hdG9tIHJlZnMvdGFncy90YWdnZXJsZXNzIHRhZ2dlcmRhdGUgJycKK3Rlc3RfYXRvbSByZWZzL3RhZ3MvdGFnZ2VybGVzcyBjb21taXR0ZXIgJycKK3Rlc3RfYXRvbSByZWZzL3RhZ3MvdGFnZ2VybGVzcyBjb21taXR0ZXJuYW1lICcnCit0ZXN0X2F0b20gcmVmcy90YWdzL3RhZ2dlcmxlc3MgY29tbWl0dGVyZW1haWwgJycKK3Rlc3RfYXRvbSByZWZzL3RhZ3MvdGFnZ2VybGVzcyBjb21taXR0ZXJkYXRlICcnCit0ZXN0X2F0b20gcmVmcy90YWdzL3RhZ2dlcmxlc3Mgc3ViamVjdCAnQnJva2VuIHRhZycKKwogdGVzdF9leHBlY3Rfc3VjY2VzcyAnYW4gdW51c3VhbCB0YWcgd2l0aCBhbiBpbmNvbXBsZXRlIGxpbmUnICcKIAogCWdpdCB0YWcgLW0gImJvZ28iIGJvZ28gJiYKZGlmZiAtLWdpdCBhL3QvdDY1MDEtZnJlc2hlbi1vYmplY3RzLnNoIGIvdC90NjUwMS1mcmVzaGVuLW9iamVjdHMuc2gKaW5kZXggMDMzODcxZS4uZjMwYjQ4NCAxMDA3NTUKLS0tIGEvdC90NjUwMS1mcmVzaGVuLW9iamVjdHMuc2gKKysrIGIvdC90NjUwMS1mcmVzaGVuLW9iamVjdHMuc2gKQEAgLTEzNyw3ICsxMzcsNyBAQAogCXNvbWUgbWVzc2FnZQogCUVPRgogCWNvbW1pdD0kKGdpdCBoYXNoLW9iamVjdCAtdCBjb21taXQgLXcgYnJva2VuLWNvbW1pdCkgJiYKLQlnaXQgZ2MgMj5zdGRlcnIgJiYKKwlnaXQgZ2MgLXEgMj5zdGRlcnIgJiYKIAl2ZXJib3NlIGdpdCBjYXQtZmlsZSAtZSAkY29tbWl0ICYmCiAJdGVzdF9tdXN0X2JlX2VtcHR5IHN0ZGVycgogJwpAQCAtMTQ3LDcgKzE0Nyw3IEBACiAJMTAwNjQ0IGJsb2IgMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMwlmb28KIAlFT0YKIAl0cmVlPSQoZ2l0IG1rdHJlZSAtLW1pc3NpbmcgPGJyb2tlbi10cmVlKSAmJgotCWdpdCBnYyAyPnN0ZGVyciAmJgorCWdpdCBnYyAtcSAyPnN0ZGVyciAmJgogCWdpdCBjYXQtZmlsZSAtZSAkdHJlZSAmJgogCXRlc3RfbXVzdF9iZV9lbXB0eSBzdGRlcnIKICcKQEAgLTE2Miw3ICsxNjIsNyBAQAogCXRoaXMgaXMgYSBicm9rZW4gdGFnCiAJRU9GCiAJdGFnPSQoZ2l0IGhhc2gtb2JqZWN0IC10IHRhZyAtdyBicm9rZW4tdGFnKSAmJgotCWdpdCBnYyAyPnN0ZGVyciAmJgorCWdpdCBnYyAtcSAyPnN0ZGVyciAmJgogCWdpdCBjYXQtZmlsZSAtZSAkdGFnICYmCiAJdGVzdF9tdXN0X2JlX2VtcHR5IHN0ZGVycgogJwpkaWZmIC0tZ2l0IGEvdC90NzAwNC10YWcuc2ggYi90L3Q3MDA0LXRhZy5zaAppbmRleCA4MGViMTNkLi40YTA5YmVhIDEwMDc1NQotLS0gYS90L3Q3MDA0LXRhZy5zaAorKysgYi90L3Q3MDA0LXRhZy5zaApAQCAtMjI3LDEwICsyMjcsMTAgQEAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgXAogCSd0cnlpbmcgdG8gZGVsZXRlIHR3byB0YWdzLCBleGlzdGluZyBhbmQgbm90LCBzaG91bGQgZmFpbCBpbiB0aGUgMm5kJyAnCiAJdGFnX2V4aXN0cyBteXRhZyAmJgotCSEgdGFnX2V4aXN0cyBteWhlYWQgJiYKLQl0ZXN0X211c3RfZmFpbCBnaXQgdGFnIC1kIG15dGFnIGFub3RoZXJ0YWcgJiYKKwkhIHRhZ19leGlzdHMgbm9uZXhpc3Rpbmd0YWcgJiYKKwl0ZXN0X211c3RfZmFpbCBnaXQgdGFnIC1kIG15dGFnIG5vbmV4aXN0aW5ndGFnICYmCiAJISB0YWdfZXhpc3RzIG15dGFnICYmCi0JISB0YWdfZXhpc3RzIG15aGVhZAorCSEgdGFnX2V4aXN0cyBub25leGlzdGluZ3RhZwogJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICd0cnlpbmcgdG8gZGVsZXRlIGFuIGFscmVhZHkgZGVsZXRlZCB0YWcgc2hvdWxkIGZhaWwnIFwKQEAgLTE0MjAsNyArMTQyMCw3IEBACiBnZXRfdGFnX2hlYWRlciByZXVzZSAkY29tbWl0IGNvbW1pdCAkdGltZSA+ZXhwZWN0CiBlY2hvICJBbiBhbm5vdGF0aW9uIHRvIGJlIHJldXNlZCIgPj4gZXhwZWN0CiB0ZXN0X2V4cGVjdF9zdWNjZXNzIFwKLQknb3ZlcndyaXRpbmcgYW4gYW5ub3RlZCB0YWcgc2hvdWxkIHVzZSBpdHMgcHJldmlvdXMgYm9keScgJworCSdvdmVyd3JpdGluZyBhbiBhbm5vdGF0ZWQgdGFnIHNob3VsZCB1c2UgaXRzIHByZXZpb3VzIGJvZHknICcKIAlnaXQgdGFnIC1hIC1tICJBbiBhbm5vdGF0aW9uIHRvIGJlIHJldXNlZCIgcmV1c2UgJiYKIAlHSVRfRURJVE9SPXRydWUgZ2l0IHRhZyAtZiAtYSByZXVzZSAmJgogCWdldF90YWdfbXNnIHJldXNlID5hY3R1YWwgJiYKZGlmZiAtLWdpdCBhL3QvdDcwMDktZmlsdGVyLWJyYW5jaC1udWxsLXNoYTEuc2ggYi90L3Q3MDA4LWZpbHRlci1icmFuY2gtbnVsbC1zaGExLnNoCnNpbWlsYXJpdHkgaW5kZXggMTAwJQpyZW5hbWUgZnJvbSB0L3Q3MDA5LWZpbHRlci1icmFuY2gtbnVsbC1zaGExLnNoCnJlbmFtZSB0byB0L3Q3MDA4LWZpbHRlci1icmFuY2gtbnVsbC1zaGExLnNoCmRpZmYgLS1naXQgYS90L3Q3MDA4LWdyZXAtYmluYXJ5LnNoIGIvdC90NzAwOC1ncmVwLWJpbmFyeS5zaApkZWxldGVkIGZpbGUgbW9kZSAxMDA3NTUKaW5kZXggMmQ4N2M0OS4uMDAwMDAwMAotLS0gYS90L3Q3MDA4LWdyZXAtYmluYXJ5LnNoCisrKyAvZGV2L251bGwKQEAgLTEsMjQ5ICswLDAgQEAKLSMhL2Jpbi9zaAotCi10ZXN0X2Rlc2NyaXB0aW9uPSdnaXQgZ3JlcCBpbiBiaW5hcnkgZmlsZXMnCi0KLS4gLi90ZXN0LWxpYi5zaAotCi1udWxfbWF0Y2ggKCkgewotCW1hdGNoZXM9JDEKLQlmbGFncz0kMgotCXBhdHRlcm49JDMKLQlwYXR0ZXJuX2h1bWFuPSQoZWNobyAiJHBhdHRlcm4iIHwgc2VkICdzL1EvPE5VTD4vZycpCi0KLQlpZiB0ZXN0ICIkbWF0Y2hlcyIgPSAxCi0JdGhlbgotCQl0ZXN0X2V4cGVjdF9zdWNjZXNzICJnaXQgZ3JlcCAtZiBmICRmbGFncyAnJHBhdHRlcm5faHVtYW4nIGEiICIKLQkJCXByaW50ZiAnJHBhdHRlcm4nIHwgcV90b19udWwgPmYgJiYKLQkJCWdpdCBncmVwIC1mIGYgJGZsYWdzIGEKLQkJIgotCWVsaWYgdGVzdCAiJG1hdGNoZXMiID0gMAotCXRoZW4KLQkJdGVzdF9leHBlY3Rfc3VjY2VzcyAiZ2l0IGdyZXAgLWYgZiAkZmxhZ3MgJyRwYXR0ZXJuX2h1bWFuJyBhIiAiCi0JCQlwcmludGYgJyRwYXR0ZXJuJyB8IHFfdG9fbnVsID5mICYmCi0JCQl0ZXN0X211c3RfZmFpbCBnaXQgZ3JlcCAtZiBmICRmbGFncyBhCi0JCSIKLQllbGlmIHRlc3QgIiRtYXRjaGVzIiA9IFQxCi0JdGhlbgotCQl0ZXN0X2V4cGVjdF9mYWlsdXJlICJnaXQgZ3JlcCAtZiBmICRmbGFncyAnJHBhdHRlcm5faHVtYW4nIGEiICIKLQkJCXByaW50ZiAnJHBhdHRlcm4nIHwgcV90b19udWwgPmYgJiYKLQkJCWdpdCBncmVwIC1mIGYgJGZsYWdzIGEKLQkJIgotCWVsaWYgdGVzdCAiJG1hdGNoZXMiID0gVDAKLQl0aGVuCi0JCXRlc3RfZXhwZWN0X2ZhaWx1cmUgImdpdCBncmVwIC1mIGYgJGZsYWdzICckcGF0dGVybl9odW1hbicgYSIgIgotCQkJcHJpbnRmICckcGF0dGVybicgfCBxX3RvX251bCA+ZiAmJgotCQkJdGVzdF9tdXN0X2ZhaWwgZ2l0IGdyZXAgLWYgZiAkZmxhZ3MgYQotCQkiCi0JZWxzZQotCQl0ZXN0X2V4cGVjdF9zdWNjZXNzICJQQU5JQzogVGVzdCBmcmFtZXdvcmsgZXJyb3IuIFVua25vd24gbWF0Y2hlcyB2YWx1ZSAkbWF0Y2hlcyIgJ2ZhbHNlJwotCWZpCi19Ci0KLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3NldHVwJyAiCi0JZWNobyAnYmluYXJ5UWZpbGVRbVsqXWNRKsOmUcOwJyB8IHFfdG9fbnVsID5hICYmCi0JZ2l0IGFkZCBhICYmCi0JZ2l0IGNvbW1pdCAtbS4KLSIKLQotdGVzdF9leHBlY3Rfc3VjY2VzcyAnZ2l0IGdyZXAgaW5hIGEnICcKLQllY2hvIEJpbmFyeSBmaWxlIGEgbWF0Y2hlcyA+ZXhwZWN0ICYmCi0JZ2l0IGdyZXAgaW5hIGEgPmFjdHVhbCAmJgotCXRlc3RfY21wIGV4cGVjdCBhY3R1YWwKLScKLQotdGVzdF9leHBlY3Rfc3VjY2VzcyAnZ2l0IGdyZXAgLWFoIGluYSBhJyAnCi0JZ2l0IGdyZXAgLWFoIGluYSBhID5hY3R1YWwgJiYKLQl0ZXN0X2NtcCBhIGFjdHVhbAotJwotCi10ZXN0X2V4cGVjdF9zdWNjZXNzICdnaXQgZ3JlcCAtSSBpbmEgYScgJwotCXRlc3RfbXVzdF9mYWlsIGdpdCBncmVwIC1JIGluYSBhID5hY3R1YWwgJiYKLQl0ZXN0X211c3RfYmVfZW1wdHkgYWN0dWFsCi0nCi0KLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2dpdCBncmVwIC1jIGluYSBhJyAnCi0JZWNobyBhOjEgPmV4cGVjdCAmJgotCWdpdCBncmVwIC1jIGluYSBhID5hY3R1YWwgJiYKLQl0ZXN0X2NtcCBleHBlY3QgYWN0dWFsCi0nCi0KLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2dpdCBncmVwIC1sIGluYSBhJyAnCi0JZWNobyBhID5leHBlY3QgJiYKLQlnaXQgZ3JlcCAtbCBpbmEgYSA+YWN0dWFsICYmCi0JdGVzdF9jbXAgZXhwZWN0IGFjdHVhbAotJwotCi10ZXN0X2V4cGVjdF9zdWNjZXNzICdnaXQgZ3JlcCAtTCBiYXIgYScgJwotCWVjaG8gYSA+ZXhwZWN0ICYmCi0JZ2l0IGdyZXAgLUwgYmFyIGEgPmFjdHVhbCAmJgotCXRlc3RfY21wIGV4cGVjdCBhY3R1YWwKLScKLQotdGVzdF9leHBlY3Rfc3VjY2VzcyAnZ2l0IGdyZXAgLXEgaW5hIGEnICcKLQlnaXQgZ3JlcCAtcSBpbmEgYSA+YWN0dWFsICYmCi0JdGVzdF9tdXN0X2JlX2VtcHR5IGFjdHVhbAotJwotCi10ZXN0X2V4cGVjdF9zdWNjZXNzICdnaXQgZ3JlcCAtRiBpbGUgYScgJwotCWdpdCBncmVwIC1GIGlsZSBhCi0nCi0KLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2dpdCBncmVwIC1GaSBpTEUgYScgJwotCWdpdCBncmVwIC1GaSBpTEUgYQotJwotCi0jIFRoaXMgdGVzdCBhY3R1YWxseSBwYXNzZXMgb24gcGxhdGZvcm1zIHdoZXJlIHJlZ2V4ZWMoKSBzdXBwb3J0cyB0aGUKLSMgZmxhZyBSRUdfU1RBUlRFTkQuCi10ZXN0X2V4cGVjdF9zdWNjZXNzICdnaXQgZ3JlcCBpbGUgYScgJwotCWdpdCBncmVwIGlsZSBhCi0nCi0KLXRlc3RfZXhwZWN0X2ZhaWx1cmUgJ2dpdCBncmVwIC5maSBhJyAnCi0JZ2l0IGdyZXAgLmZpIGEKLScKLQotbnVsX21hdGNoIDEgJy1GJyAneVFmJwotbnVsX21hdGNoIDAgJy1GJyAneVF4JwotbnVsX21hdGNoIDEgJy1GaScgJ1lRZicKLW51bF9tYXRjaCAwICctRmknICdZUXgnCi1udWxfbWF0Y2ggMSAnJyAneVFmJwotbnVsX21hdGNoIDAgJycgJ3lReCcKLW51bF9tYXRjaCAxICcnICfDplHDsCcKLW51bF9tYXRjaCAxICctRicgJ2VRbVsqXWMnCi1udWxfbWF0Y2ggMSAnLUZpJyAnRVFNWypdQycKLQotIyBSZWdleCBwYXR0ZXJucyB0aGF0IHdvdWxkIG1hdGNoIGJ1dCBzaG91bGRuJ3Qgd2l0aCAtRgotbnVsX21hdGNoIDAgJy1GJyAneVFbZl0nCi1udWxfbWF0Y2ggMCAnLUYnICdbeV1RZicKLW51bF9tYXRjaCAwICctRmknICdZUVtGXScKLW51bF9tYXRjaCAwICctRmknICdbWV1RRicKLW51bF9tYXRjaCAwICctRicgJ8OmUVvDsF0nCi1udWxfbWF0Y2ggMCAnLUYnICdbw6ZdUcOwJwotbnVsX21hdGNoIDAgJy1GaScgJ8OGUVvDkF0nCi1udWxfbWF0Y2ggMCAnLUZpJyAnW8OGXVHDkCcKLQotIyBrd3NldCBpcyBkaXNhYmxlZCBvbiAtaSAmIG5vbi1BU0NJSS4gTm8gd2F5IHRvIG1hdGNoIG5vbi1BU0NJSSBcMAotIyBwYXR0ZXJucyBjYXNlLWluc2Vuc2l0aXZlbHkuCi1udWxfbWF0Y2ggVDEgJy1pJyAnw4ZRw5AnCi0KLSMgXDAgaW1wbGljaXRseSBkaXNhYmxlcyByZWdleGVzLiBUaGlzIGlzIGFuIHVuZG9jdW1lbnRlZCBpbnRlcm5hbAotIyBsaW1pdGF0aW9uLgotbnVsX21hdGNoIFQxICcnICd5UVtmXScKLW51bF9tYXRjaCBUMSAnJyAnW3ldUWYnCi1udWxfbWF0Y2ggVDEgJy1pJyAnWVFbRl0nCi1udWxfbWF0Y2ggVDEgJy1pJyAnW1ldUWYnCi1udWxfbWF0Y2ggVDEgJycgJ8OmUVvDsF0nCi1udWxfbWF0Y2ggVDEgJycgJ1vDpl1Rw7AnCi1udWxfbWF0Y2ggVDEgJy1pJyAnw4ZRW8OQXScKLQotIyAuLi4gYmVjYXVzZSBvZiBcMCBpbXBsaWNpdGx5IGRpc2FibGluZyByZWdleGVzIHJlZ2V4ZXMgdGhhdAotIyBzaG91bGQvc2hvdWxkbid0IG1hdGNoIGRvbid0IGRvIHRoZSByaWdodCB0aGluZy4KLW51bF9tYXRjaCBUMSAnJyAnZVFtLipjUScKLW51bF9tYXRjaCBUMSAnLWknICdFUU0uKmNRJwotbnVsX21hdGNoIFQwICcnICdlUW1bKl1jJwotbnVsX21hdGNoIFQwICctaScgJ0VRTVsqXUMnCi0KLSMgRHVlIHRvIHRoZSBSRUdfU1RBUlRFTkQgZXh0ZW5zaW9uIHdoZW4ga3dzZXQoKSBpcyBkaXNhYmxlZCBvbiAtaSAmCi0jIG5vbi1BU0NJSSB0aGUgc3RyaW5nIHdpbGwgYmUgbWF0Y2hlZCBpbiBpdHMgZW50aXJldHksIGJ1dCB0aGUKLSMgcGF0dGVybiB3aWxsIGJlIGN1dCBvZmYgYXQgdGhlIGZpcnN0IFwwLgotbnVsX21hdGNoIDAgJy1pJyAnTk9NQVRDSFHDsCcKLW51bF9tYXRjaCBUMCAnLWknICdbw4ZdUU5PTUFUQ0gnCi1udWxfbWF0Y2ggVDAgJy1pJyAnW8OmXVFOT01BVENIJwotIyBNYXRjaGVzLCBidXQgZm9yIHRoZSB3cm9uZyByZWFzb25zLCBqdXN0IHN0b3BzIGF0IFvDpl0KLW51bF9tYXRjaCAxICctaScgJ1vDhl1Rw7AnCi1udWxfbWF0Y2ggMSAnLWknICdbw6ZdUcOwJwotCi0jIEVuc3VyZSB0aGF0IHRoZSBtYXRjaGVyIGRvZXNuJ3QgcmVncmVzcyB0byBzb21ldGhpbmcgdGhhdCBzdG9wcyBhdAotIyBcMAotbnVsX21hdGNoIDAgJy1GJyAneVFbZl0nCi1udWxfbWF0Y2ggMCAnLUZpJyAnWVFbRl0nCi1udWxfbWF0Y2ggMCAnJyAneVFOT01BVENIJwotbnVsX21hdGNoIDAgJycgJ1FOT01BVENIJwotbnVsX21hdGNoIDAgJy1pJyAnWVFOT01BVENIJwotbnVsX21hdGNoIDAgJy1pJyAnUU5PTUFUQ0gnCi1udWxfbWF0Y2ggMCAnLUYnICfDplFbw7BdJwotbnVsX21hdGNoIDAgJy1GaScgJ8OGUVvDkF0nCi1udWxfbWF0Y2ggMCAnJyAneVFOw5NNQVRDSCcKLW51bF9tYXRjaCAwICcnICdRTsOTTUFUQ0gnCi1udWxfbWF0Y2ggMCAnLWknICdZUU7Dk01BVENIJwotbnVsX21hdGNoIDAgJy1pJyAnUU7Dk01BVENIJwotCi10ZXN0X2V4cGVjdF9zdWNjZXNzICdncmVwIHJlc3BlY3RzIGJpbmFyeSBkaWZmIGF0dHJpYnV0ZScgJwotCWVjaG8gdGV4dCA+dCAmJgotCWdpdCBhZGQgdCAmJgotCWVjaG8gdDp0ZXh0ID5leHBlY3QgJiYKLQlnaXQgZ3JlcCB0ZXh0IHQgPmFjdHVhbCAmJgotCXRlc3RfY21wIGV4cGVjdCBhY3R1YWwgJiYKLQllY2hvICJ0IC1kaWZmIiA+LmdpdGF0dHJpYnV0ZXMgJiYKLQllY2hvICJCaW5hcnkgZmlsZSB0IG1hdGNoZXMiID5leHBlY3QgJiYKLQlnaXQgZ3JlcCB0ZXh0IHQgPmFjdHVhbCAmJgotCXRlc3RfY21wIGV4cGVjdCBhY3R1YWwKLScKLQotdGVzdF9leHBlY3Rfc3VjY2VzcyAnZ3JlcCAtLWNhY2hlZCByZXNwZWN0cyBiaW5hcnkgZGlmZiBhdHRyaWJ1dGUnICcKLQlnaXQgZ3JlcCAtLWNhY2hlZCB0ZXh0IHQgPmFjdHVhbCAmJgotCXRlc3RfY21wIGV4cGVjdCBhY3R1YWwKLScKLQotdGVzdF9leHBlY3Rfc3VjY2VzcyAnZ3JlcCAtLWNhY2hlZCByZXNwZWN0cyBiaW5hcnkgZGlmZiBhdHRyaWJ1dGUgKDIpJyAnCi0JZ2l0IGFkZCAuZ2l0YXR0cmlidXRlcyAmJgotCXJtIC5naXRhdHRyaWJ1dGVzICYmCi0JZ2l0IGdyZXAgLS1jYWNoZWQgdGV4dCB0ID5hY3R1YWwgJiYKLQl0ZXN0X3doZW5fZmluaXNoZWQgImdpdCBybSAtLWNhY2hlZCAuZ2l0YXR0cmlidXRlcyIgJiYKLQl0ZXN0X3doZW5fZmluaXNoZWQgImdpdCBjaGVja291dCAuZ2l0YXR0cmlidXRlcyIgJiYKLQl0ZXN0X2NtcCBleHBlY3QgYWN0dWFsCi0nCi0KLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2dyZXAgcmV2aXNpb24gcmVzcGVjdHMgYmluYXJ5IGRpZmYgYXR0cmlidXRlJyAnCi0JZ2l0IGNvbW1pdCAtbSBuZXcgJiYKLQllY2hvICJCaW5hcnkgZmlsZSBIRUFEOnQgbWF0Y2hlcyIgPmV4cGVjdCAmJgotCWdpdCBncmVwIHRleHQgSEVBRCAtLSB0ID5hY3R1YWwgJiYKLQl0ZXN0X3doZW5fZmluaXNoZWQgImdpdCByZXNldCBIRUFEXiIgJiYKLQl0ZXN0X2NtcCBleHBlY3QgYWN0dWFsCi0nCi0KLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2dyZXAgcmVzcGVjdHMgbm90LWJpbmFyeSBkaWZmIGF0dHJpYnV0ZScgJwotCWVjaG8gYmluUWFyeSB8IHFfdG9fbnVsID5iICYmCi0JZ2l0IGFkZCBiICYmCi0JZWNobyAiQmluYXJ5IGZpbGUgYiBtYXRjaGVzIiA+ZXhwZWN0ICYmCi0JZ2l0IGdyZXAgYmluIGIgPmFjdHVhbCAmJgotCXRlc3RfY21wIGV4cGVjdCBhY3R1YWwgJiYKLQllY2hvICJiIGRpZmYiID4uZ2l0YXR0cmlidXRlcyAmJgotCWVjaG8gImI6YmluUWFyeSIgPmV4cGVjdCAmJgotCWdpdCBncmVwIGJpbiBiID5hY3R1YWwucmF3ICYmCi0JbnVsX3RvX3EgPGFjdHVhbC5yYXcgPmFjdHVhbCAmJgotCXRlc3RfY21wIGV4cGVjdCBhY3R1YWwKLScKLQotY2F0ID5udWxfdG9fcV90ZXh0Y29udiA8PCdFT0YnCi0jIS9iaW4vc2gKLSIkUEVSTF9QQVRIIiAtcGUgJ3kvXDAwMC9RLycgPCAiJDEiCi1FT0YKLWNobW9kICt4IG51bF90b19xX3RleHRjb252Ci0KLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3NldHVwIHRleHRjb252IGZpbHRlcnMnICcKLQllY2hvIGEgZGlmZj1mb28gPi5naXRhdHRyaWJ1dGVzICYmCi0JZ2l0IGNvbmZpZyBkaWZmLmZvby50ZXh0Y29udiAiXCIkKHB3ZClcIiIvbnVsX3RvX3FfdGV4dGNvbnYKLScKLQotdGVzdF9leHBlY3Rfc3VjY2VzcyAnZ3JlcCBkb2VzIG5vdCBob25vciB0ZXh0Y29udicgJwotCXRlc3RfbXVzdF9mYWlsIGdpdCBncmVwIFFmaWxlCi0nCi0KLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2dyZXAgLS10ZXh0Y29udiBob25vcnMgdGV4dGNvbnYnICcKLQllY2hvICJhOmJpbmFyeVFmaWxlUW1bKl1jUSrDplHDsCIgPmV4cGVjdCAmJgotCWdpdCBncmVwIC0tdGV4dGNvbnYgUWZpbGUgPmFjdHVhbCAmJgotCXRlc3RfY21wIGV4cGVjdCBhY3R1YWwKLScKLQotdGVzdF9leHBlY3Rfc3VjY2VzcyAnZ3JlcCAtLW5vLXRleHRjb252IGRvZXMgbm90IGhvbm9yIHRleHRjb252JyAnCi0JdGVzdF9tdXN0X2ZhaWwgZ2l0IGdyZXAgLS1uby10ZXh0Y29udiBRZmlsZQotJwotCi10ZXN0X2V4cGVjdF9zdWNjZXNzICdncmVwIC0tdGV4dGNvbnYgYmxvYiBob25vcnMgdGV4dGNvbnYnICcKLQllY2hvICJIRUFEOmE6YmluYXJ5UWZpbGVRbVsqXWNRKsOmUcOwIiA+ZXhwZWN0ICYmCi0JZ2l0IGdyZXAgLS10ZXh0Y29udiBRZmlsZSBIRUFEOmEgPmFjdHVhbCAmJgotCXRlc3RfY21wIGV4cGVjdCBhY3R1YWwKLScKLQotdGVzdF9kb25lCmRpZmYgLS1naXQgYS90L3Q3MDEyLXNraXAtd29ya3RyZWUtd3JpdGluZy5zaCBiL3QvdDcwMTItc2tpcC13b3JrdHJlZS13cml0aW5nLnNoCmluZGV4IDlkMWFiZTUuLjc0NzY3ODEgMTAwNzU1Ci0tLSBhL3QvdDcwMTItc2tpcC13b3JrdHJlZS13cml0aW5nLnNoCisrKyBiL3QvdDcwMTItc2tpcC13b3JrdHJlZS13cml0aW5nLnNoCkBAIC0xMzQsNiArMTM0LDIxIEBACiAJdGVzdF9pMThuY21wIGV4cGVjdGVkIHJlc3VsdAogJwogCit0ZXN0X2V4cGVjdF9zdWNjZXNzICctLWlnbm9yZS1za2lwLXdvcmt0cmVlLWVudHJpZXMgbGVhdmVzIHdvcmt0cmVlIGFsb25lJyAnCisJdGVzdF9jb21taXQga2VlcC1tZSAmJgorCWdpdCB1cGRhdGUtaW5kZXggLS1za2lwLXdvcmt0cmVlIGtlZXAtbWUudCAmJgorCXJtIGtlZXAtbWUudCAmJgorCisJOiBpZ25vcmluZyB0aGUgd29ya3RyZWUgJiYKKwlnaXQgdXBkYXRlLWluZGV4IC0tcmVtb3ZlIC0taWdub3JlLXNraXAtd29ya3RyZWUtZW50cmllcyBrZWVwLW1lLnQgJiYKKwlnaXQgZGlmZi1pbmRleCAtLWNhY2hlZCAtLWV4aXQtY29kZSBIRUFEICYmCisKKwk6IG5vdCBpZ25vcmluZyB0aGUgd29ya3RyZWUsIGEgZGVsZXRpb24gaXMgc3RhZ2VkICYmCisJZ2l0IHVwZGF0ZS1pbmRleCAtLXJlbW92ZSBrZWVwLW1lLnQgJiYKKwl0ZXN0X211c3RfZmFpbCBnaXQgZGlmZi1pbmRleCAtLWNhY2hlZCAtLWV4aXQtY29kZSBIRUFEIFwKKwkJLS1kaWZmLWZpbHRlcj1EIC0tIGtlZXAtbWUudAorJworCiAjVE9ETyB0ZXN0X2V4cGVjdF9mYWlsdXJlICdnaXQtYXBwbHkgYWRkcyBmaWxlJyBmYWxzZQogI1RPRE8gdGVzdF9leHBlY3RfZmFpbHVyZSAnZ2l0LWFwcGx5IHVwZGF0ZXMgZmlsZScgZmFsc2UKICNUT0RPIHRlc3RfZXhwZWN0X2ZhaWx1cmUgJ2dpdC1hcHBseSByZW1vdmVzIGZpbGUnIGZhbHNlCmRpZmYgLS1naXQgYS90L3Q3MDMwLXZlcmlmeS10YWcuc2ggYi90L3Q3MDMwLXZlcmlmeS10YWcuc2gKaW5kZXggMDQxZTMxOS4uOGYwNzdiZSAxMDA3NTUKLS0tIGEvdC90NzAzMC12ZXJpZnktdGFnLnNoCisrKyBiL3QvdDcwMzAtdmVyaWZ5LXRhZy5zaApAQCAtNDQsOCArNDQsOCBAQAogdGVzdF9leHBlY3Rfc3VjY2VzcyBHUEdTTSAnY3JlYXRlIHNpZ25lZCB0YWdzIHg1MDkgJyAnCiAJdGVzdF9jb25maWcgZ3BnLmZvcm1hdCB4NTA5ICYmCiAJdGVzdF9jb25maWcgdXNlci5zaWduaW5na2V5ICRHSVRfQ09NTUlUVEVSX0VNQUlMICYmCi0JZWNobyA5ID5maWxlICYmIHRlc3RfdGljayAmJiBnaXQgY29tbWl0IC1hIC1tICJuaW5ldGggZ3Bnc20tc2lnbmVkIiAmJgotCWdpdCB0YWcgLXMgLW0gbmluZXRoIG5pbmV0aC1zaWduZWQteDUwOQorCWVjaG8gOSA+ZmlsZSAmJiB0ZXN0X3RpY2sgJiYgZ2l0IGNvbW1pdCAtYSAtbSAibmludGggZ3Bnc20tc2lnbmVkIiAmJgorCWdpdCB0YWcgLXMgLW0gbmludGggbmludGgtc2lnbmVkLXg1MDkKICcKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyBHUEcgJ3ZlcmlmeSBhbmQgc2hvdyBzaWduYXR1cmVzJyAnCkBAIC04MCwxMCArODAsMTAgQEAKICcKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyBHUEdTTSAndmVyaWZ5IGFuZCBzaG93IHNpZ25hdHVyZXMgeDUwOScgJwotCWdpdCB2ZXJpZnktdGFnIG5pbmV0aC1zaWduZWQteDUwOSAyPmFjdHVhbCAmJgorCWdpdCB2ZXJpZnktdGFnIG5pbnRoLXNpZ25lZC14NTA5IDI+YWN0dWFsICYmCiAJZ3JlcCAiR29vZCBzaWduYXR1cmUgZnJvbSIgYWN0dWFsICYmCiAJISBncmVwICJCQUQgc2lnbmF0dXJlIGZyb20iIGFjdHVhbCAmJgotCWVjaG8gbmluZXRoLXNpZ25lZC14NTA5IE9LCisJZWNobyBuaW50aC1zaWduZWQteDUwOSBPSwogJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzIEdQRyAnZGV0ZWN0IGZ1ZGdlZCBzaWduYXR1cmUnICcKQEAgLTEyNywxMCArMTI3LDEwIEBACiAnCiAKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgR1BHU00gJ3ZlcmlmeSBzaWduYXR1cmVzIHdpdGggLS1yYXcgeDUwOScgJwotCWdpdCB2ZXJpZnktdGFnIC0tcmF3IG5pbmV0aC1zaWduZWQteDUwOSAyPmFjdHVhbCAmJgorCWdpdCB2ZXJpZnktdGFnIC0tcmF3IG5pbnRoLXNpZ25lZC14NTA5IDI+YWN0dWFsICYmCiAJZ3JlcCAiR09PRFNJRyIgYWN0dWFsICYmCiAJISBncmVwICJCQURTSUciIGFjdHVhbCAmJgotCWVjaG8gbmluZXRoLXNpZ25lZC14NTA5IE9LCisJZWNobyBuaW50aC1zaWduZWQteDUwOSBPSwogJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzIEdQRyAndmVyaWZ5IG11bHRpcGxlIHRhZ3MnICcKQEAgLTE0Nyw3ICsxNDcsNyBAQAogJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzIEdQR1NNICd2ZXJpZnkgbXVsdGlwbGUgdGFncyB4NTA5JyAnCi0JdGFncz0ic2V2ZW50aC1zaWduZWQgbmluZXRoLXNpZ25lZC14NTA5IiAmJgorCXRhZ3M9InNldmVudGgtc2lnbmVkIG5pbnRoLXNpZ25lZC14NTA5IiAmJgogCWZvciBpIGluICR0YWdzCiAJZG8KIAkJZ2l0IHZlcmlmeS10YWcgLXYgLS1yYXcgJGkgfHwgcmV0dXJuIDEKZGlmZiAtLWdpdCBhL3QvdDcxMDUtcmVzZXQtcGF0Y2guc2ggYi90L3Q3MTA1LXJlc2V0LXBhdGNoLnNoCmluZGV4IGJkMTBhOTYuLmZjMmE2Y2YgMTAwNzU1Ci0tLSBhL3QvdDcxMDUtcmVzZXQtcGF0Y2guc2gKKysrIGIvdC90NzEwNS1yZXNldC1wYXRjaC5zaApAQCAtMzgsNiArMzgsMjcgQEAKIAl0ZXN0X2kxOG5ncmVwICJBcHBseSIgb3V0cHV0CiAnCiAKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgUEVSTCAnZ2l0IHJlc2V0IC1wIEhFQUReXnt0cmVlfScgJworCXRlc3Rfd3JpdGVfbGluZXMgbiB5IHwgZ2l0IHJlc2V0IC1wIEhFQUReXnt0cmVlfSA+b3V0cHV0ICYmCisJdmVyaWZ5X3N0YXRlIGRpci9mb28gd29yayBwYXJlbnQgJiYKKwl2ZXJpZnlfc2F2ZWRfc3RhdGUgYmFyICYmCisJdGVzdF9pMThuZ3JlcCAiQXBwbHkiIG91dHB1dAorJworCit0ZXN0X2V4cGVjdF9zdWNjZXNzIFBFUkwgJ2dpdCByZXNldCAtcCBIRUFEXjpkaXIvZm9vIChibG9iIGZhaWxzKScgJworCXNldF9hbmRfc2F2ZV9zdGF0ZSBkaXIvZm9vIHdvcmsgd29yayAmJgorCXRlc3RfbXVzdF9mYWlsIGdpdCByZXNldCAtcCBIRUFEXjpkaXIvZm9vICYmCisJdmVyaWZ5X3NhdmVkX3N0YXRlIGRpci9mb28gJiYKKwl2ZXJpZnlfc2F2ZWRfc3RhdGUgYmFyCisnCisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgUEVSTCAnZ2l0IHJlc2V0IC1wIGFhYWFhYWFhICh1bmtub3duIGZhaWxzKScgJworCXNldF9hbmRfc2F2ZV9zdGF0ZSBkaXIvZm9vIHdvcmsgd29yayAmJgorCXRlc3RfbXVzdF9mYWlsIGdpdCByZXNldCAtcCBhYWFhYWFhYSAmJgorCXZlcmlmeV9zYXZlZF9zdGF0ZSBkaXIvZm9vICYmCisJdmVyaWZ5X3NhdmVkX3N0YXRlIGJhcgorJworCiAjIFRoZSBpZGVhIGluIHRoZSByZXN0IGlzIHRoYXQgYmFyIHNvcnRzIGZpcnN0LCBzbyB3ZSBhbHdheXMgc2F5ICd5JwogIyBmaXJzdCBhbmQgaWYgdGhlIHBhdGggbGltaXRlciBmYWlscyBpdCdsbCBhcHBseSB0byBiYXIgaW5zdGVhZCBvZgogIyBkaXIvZm9vLiAgVGhlcmUncyBhbHdheXMgYW4gZXh0cmEgJ24nIHRvIHJlamVjdCBlZGl0cyB0byBkaXIvZm9vIGluCmRpZmYgLS1naXQgYS90L3Q3MzAwLWNsZWFuLnNoIGIvdC90NzMwMC1jbGVhbi5zaAppbmRleCBhMmM0NWQxLi42ZTZkMjRjIDEwMDc1NQotLS0gYS90L3Q3MzAwLWNsZWFuLnNoCisrKyBiL3QvdDczMDAtY2xlYW4uc2gKQEAgLTExNyw2ICsxMTcsNyBAQAogCXdvdWxkX2NsZWFuPSQoCiAJCWNkIGRvY3MgJiYKIAkJZ2l0IGNsZWFuIC1uIC4uL3NyYyB8CisJCWdyZXAgcGFydDMgfAogCQlzZWQgLW4gLWUgInN8XldvdWxkIHJlbW92ZSB8fHAiCiAJKSAmJgogCXZlcmJvc2UgdGVzdCAiJHdvdWxkX2NsZWFuIiA9IC4uL3NyYy9wYXJ0My5jCkBAIC0xMjksNiArMTMwLDcgQEAKIAl3b3VsZF9jbGVhbj0kKAogCQljZCBkb2NzICYmCiAJCWdpdCBjbGVhbiAtbiAiJChwd2QpLy4uL3NyYyIgfAorCQlncmVwIHBhcnQzIHwKIAkJc2VkIC1uIC1lICJzfF5Xb3VsZCByZW1vdmUgfHxwIgogCSkgJiYKIAl2ZXJib3NlIHRlc3QgIiR3b3VsZF9jbGVhbiIgPSAuLi9zcmMvcGFydDMuYwpAQCAtNTQ3LDcgKzU0OSw3IEBACiAJdGVzdF9wYXRoX2lzX21pc3Npbmcgc3RyYW5nZV9iYXJlCiAnCiAKLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2dpdmluZyBwYXRoIGluIG5lc3RlZCBnaXQgd29yayB0cmVlIHdpbGwgcmVtb3ZlIGl0JyAnCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdnaXZpbmcgcGF0aCBpbiBuZXN0ZWQgZ2l0IHdvcmsgdHJlZSB3aWxsIE5PVCByZW1vdmUgaXQnICcKIAlybSAtZnIgcmVwbyAmJgogCW1rZGlyIHJlcG8gJiYKIAkoCkBAIC01NTksNyArNTYxLDcgQEAKIAlnaXQgY2xlYW4gLWYgLWQgcmVwby9iYXIvYmF6ICYmCiAJdGVzdF9wYXRoX2lzX2ZpbGUgcmVwby8uZ2l0L0hFQUQgJiYKIAl0ZXN0X3BhdGhfaXNfZGlyIHJlcG8vYmFyLyAmJgotCXRlc3RfcGF0aF9pc19taXNzaW5nIHJlcG8vYmFyL2JhegorCXRlc3RfcGF0aF9pc19maWxlIHJlcG8vYmFyL2Jhei9oZWxsby53b3JsZAogJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdnaXZpbmcgcGF0aCB0byBuZXN0ZWQgLmdpdCB3aWxsIG5vdCByZW1vdmUgaXQnICcKQEAgLTU3Nyw3ICs1NzksNyBAQAogCXRlc3RfcGF0aF9pc19kaXIgdW50cmFja2VkLwogJwogCi10ZXN0X2V4cGVjdF9zdWNjZXNzICdnaXZpbmcgcGF0aCB0byBuZXN0ZWQgLmdpdC8gd2lsbCByZW1vdmUgY29udGVudHMnICcKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2dpdmluZyBwYXRoIHRvIG5lc3RlZCAuZ2l0LyB3aWxsIE5PVCByZW1vdmUgY29udGVudHMnICcKIAlybSAtZnIgcmVwbyB1bnRyYWNrZWQgJiYKIAlta2RpciByZXBvIHVudHJhY2tlZCAmJgogCSgKQEAgLTU4Nyw3ICs1ODksNyBAQAogCSkgJiYKIAlnaXQgY2xlYW4gLWYgLWQgcmVwby8uZ2l0LyAmJgogCXRlc3RfcGF0aF9pc19kaXIgcmVwby8uZ2l0ICYmCi0JdGVzdF9kaXJfaXNfZW1wdHkgcmVwby8uZ2l0ICYmCisJdGVzdF9wYXRoX2lzX2ZpbGUgcmVwby8uZ2l0L0hFQUQgJiYKIAl0ZXN0X3BhdGhfaXNfZGlyIHVudHJhY2tlZC8KICcKIApAQCAtNjY5LDYgKzY3MSw2MCBAQAogCXRlc3RfcGF0aF9pc19taXNzaW5nIGZvby9iL2JiCiAnCiAKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2dpdCBjbGVhbiAtZCBza2lwcyBuZXN0ZWQgcmVwbyBjb250YWluaW5nIGlnbm9yZWQgZmlsZXMnICcKKwl0ZXN0X3doZW5fZmluaXNoZWQgInJtIC1yZiBuZXN0ZWQtcmVwby13aXRoLWlnbm9yZWQtZmlsZSIgJiYKKworCWdpdCBpbml0IG5lc3RlZC1yZXBvLXdpdGgtaWdub3JlZC1maWxlICYmCisJKAorCQljZCBuZXN0ZWQtcmVwby13aXRoLWlnbm9yZWQtZmlsZSAmJgorCQk+ZmlsZSAmJgorCQlnaXQgYWRkIGZpbGUgJiYKKwkJZ2l0IGNvbW1pdCAtbSBJbml0aWFsICYmCisKKwkJIyBUaGlzIGZpbGUgaXMgaWdub3JlZCBieSBhIC5naXRpZ25vcmUgcnVsZSBpbiB0aGUgb3V0ZXIgcmVwbworCQkjIGFkZGVkIGluIHRoZSBwcmV2aW91cyB0ZXN0LgorCQk+aWdub3JlbWUKKwkpICYmCisKKwlnaXQgY2xlYW4gLWZkICYmCisKKwl0ZXN0X3BhdGhfaXNfZmlsZSBuZXN0ZWQtcmVwby13aXRoLWlnbm9yZWQtZmlsZS8uZ2l0L2luZGV4ICYmCisJdGVzdF9wYXRoX2lzX2ZpbGUgbmVzdGVkLXJlcG8td2l0aC1pZ25vcmVkLWZpbGUvaWdub3JlbWUgJiYKKwl0ZXN0X3BhdGhfaXNfZmlsZSBuZXN0ZWQtcmVwby13aXRoLWlnbm9yZWQtZmlsZS9maWxlCisnCisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2dpdCBjbGVhbiBoYW5kbGVzIGJlaW5nIHRvbGQgd2hhdCB0byBjbGVhbicgJworCW1rZGlyIC1wIGQxIGQyICYmCisJdG91Y2ggZDEvdXQgZDIvdXQgJiYKKwlnaXQgY2xlYW4gLWYgKi91dCAmJgorCXRlc3RfcGF0aF9pc19taXNzaW5nIGQxL3V0ICYmCisJdGVzdF9wYXRoX2lzX21pc3NpbmcgZDIvdXQKKycKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAnZ2l0IGNsZWFuIGhhbmRsZXMgYmVpbmcgdG9sZCB3aGF0IHRvIGNsZWFuLCB3aXRoIC1kJyAnCisJbWtkaXIgLXAgZDEgZDIgJiYKKwl0b3VjaCBkMS91dCBkMi91dCAmJgorCWdpdCBjbGVhbiAtZmZkICovdXQgJiYKKwl0ZXN0X3BhdGhfaXNfbWlzc2luZyBkMS91dCAmJgorCXRlc3RfcGF0aF9pc19taXNzaW5nIGQyL3V0CisnCisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2dpdCBjbGVhbiB3b3JrcyBpZiBhIGdsb2IgaXMgcGFzc2VkIHdpdGhvdXQgLWQnICcKKwlta2RpciAtcCBkMSBkMiAmJgorCXRvdWNoIGQxL3V0IGQyL3V0ICYmCisJZ2l0IGNsZWFuIC1mICIqdXQiICYmCisJdGVzdF9wYXRoX2lzX21pc3NpbmcgZDEvdXQgJiYKKwl0ZXN0X3BhdGhfaXNfbWlzc2luZyBkMi91dAorJworCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdnaXQgY2xlYW4gd29ya3MgaWYgYSBnbG9iIGlzIHBhc3NlZCB3aXRoIC1kJyAnCisJbWtkaXIgLXAgZDEgZDIgJiYKKwl0b3VjaCBkMS91dCBkMi91dCAmJgorCWdpdCBjbGVhbiAtZmZkICIqdXQiICYmCisJdGVzdF9wYXRoX2lzX21pc3NpbmcgZDEvdXQgJiYKKwl0ZXN0X3BhdGhfaXNfbWlzc2luZyBkMi91dAorJworCiB0ZXN0X2V4cGVjdF9zdWNjZXNzIE1JTkdXICdoYW5kbGUgY2xlYW4gJiBjb3JlLmxvbmdwYXRocyA9IGZhbHNlIG5pY2VseScgJwogCXRlc3RfY29uZmlnIGNvcmUubG9uZ3BhdGhzIGZhbHNlICYmCiAJYTUwPWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhICYmCmRpZmYgLS1naXQgYS90L3Q3NDAwLXN1Ym1vZHVsZS1iYXNpYy5zaCBiL3QvdDc0MDAtc3VibW9kdWxlLWJhc2ljLnNoCmluZGV4IGEyMDhjYjIuLjdmNzViYjEgMTAwNzU1Ci0tLSBhL3QvdDc0MDAtc3VibW9kdWxlLWJhc2ljLnNoCisrKyBiL3QvdDc0MDAtc3VibW9kdWxlLWJhc2ljLnNoCkBAIC0zNTYsNiArMzU2LDI4IEBACiAJdGVzdF9saW5lX2NvdW50ID0gMSBsaW5lcwogJwogCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdzdGF0dXMgZnJvbSBzdWJkaXJlY3Rvcnkgc2hvdWxkIGhhdmUgdGhlIHNhbWUgU0hBMScgJworCXRlc3Rfd2hlbl9maW5pc2hlZCAicm1kaXIgYWRkdGVzdC9zdWJkaXIiICYmCisJKAorCQljZCBhZGR0ZXN0ICYmCisJCW1rZGlyIHN1YmRpciAmJgorCQlnaXQgc3VibW9kdWxlIHN0YXR1cyA+b3V0cHV0ICYmCisJCWF3ayAie3ByaW50IFwkMX0iIDxvdXRwdXQgPmV4cGVjdCAmJgorCQljZCBzdWJkaXIgJiYKKwkJZ2l0IHN1Ym1vZHVsZSBzdGF0dXMgPi4uL291dHB1dCAmJgorCQlhd2sgIntwcmludCBcJDF9IiA8Li4vb3V0cHV0ID4uLi9hY3R1YWwgJiYKKwkJdGVzdF9jbXAgLi4vZXhwZWN0IC4uL2FjdHVhbCAmJgorCQlnaXQgLUMgLi4vc3VibW9kIGNoZWNrb3V0IEhFQUReICYmCisJCWdpdCBzdWJtb2R1bGUgc3RhdHVzID4uLi9vdXRwdXQgJiYKKwkJYXdrICJ7cHJpbnQgXCQxfSIgPC4uL291dHB1dCA+Li4vYWN0dWFsMiAmJgorCQljZCAuLiAmJgorCQlnaXQgc3VibW9kdWxlIHN0YXR1cyA+b3V0cHV0ICYmCisJCWF3ayAie3ByaW50IFwkMX0iIDxvdXRwdXQgPmV4cGVjdDIgJiYKKwkJdGVzdF9jbXAgZXhwZWN0MiBhY3R1YWwyICYmCisJCSEgdGVzdF9jbXAgYWN0dWFsIGFjdHVhbDIKKwkpCisnCisKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3NldHVwIC0gZmV0Y2ggY29tbWl0IG5hbWUgZnJvbSBzdWJtb2R1bGUnICcKIAlyZXYxPSQoY2QgLnN1YnJlcG8gJiYgZ2l0IHJldi1wYXJzZSBIRUFEKSAmJgogCXByaW50ZiAicmV2MTogJXNcbiIgIiRyZXYxIiAmJgpAQCAtNTI3LDcgKzU0OSw2IEBACiAJdGVzdF9tdXN0X2ZhaWwgZ2l0IGNvbmZpZyBzdWJtb2R1bGUuZXhhbXBsZS51cmwgJiYKIAogCWdpdCBzdWJtb2R1bGUgdXBkYXRlIGluaXQgMj4gdXBkYXRlLm91dCAmJgotCWNhdCB1cGRhdGUub3V0ICYmCiAJdGVzdF9pMThuZ3JlcCAibm90IGluaXRpYWxpemVkIiB1cGRhdGUub3V0ICYmCiAJdGVzdF9tdXN0X2ZhaWwgZ2l0IHJldi1wYXJzZSAtLXJlc29sdmUtZ2l0LWRpciBpbml0Ly5naXQgJiYKIApAQCAtNTQ1LDcgKzU2Niw2IEBACiAJKAogCQljZCBzdWIgJiYKIAkJZ2l0IHN1Ym1vZHVsZSB1cGRhdGUgLi4vaW5pdCAyPnVwZGF0ZS5vdXQgJiYKLQkJY2F0IHVwZGF0ZS5vdXQgJiYKIAkJdGVzdF9pMThuZ3JlcCAibm90IGluaXRpYWxpemVkIiB1cGRhdGUub3V0ICYmCiAJCXRlc3RfbXVzdF9mYWlsIGdpdCByZXYtcGFyc2UgLS1yZXNvbHZlLWdpdC1kaXIgLi4vaW5pdC8uZ2l0ICYmCiAKZGlmZiAtLWdpdCBhL3QvdDc0MDYtc3VibW9kdWxlLXVwZGF0ZS5zaCBiL3QvdDc0MDYtc3VibW9kdWxlLXVwZGF0ZS5zaAppbmRleCBjOTczMjc4Li5kZjM0Yzk5IDEwMDc1NQotLS0gYS90L3Q3NDA2LXN1Ym1vZHVsZS11cGRhdGUuc2gKKysrIGIvdC90NzQwNi1zdWJtb2R1bGUtdXBkYXRlLnNoCkBAIC0xNTgsNyArMTU4LDYgQEAKIAl0ZXN0X2kxOG5jbXAgZXhwZWN0MiBhY3R1YWwyCiAnCiAKLWFwb3M9IiciOwogdGVzdF9leHBlY3Rfc3VjY2VzcyAnc3VibW9kdWxlIHVwZGF0ZSBkb2VzIG5vdCBmZXRjaCBhbHJlYWR5IHByZXNlbnQgY29tbWl0cycgJwogCShjZCBzdWJtb2R1bGUgJiYKIAkgIGVjaG8gbGluZTMgPj4gZmlsZSAmJgpAQCAtMTY4LDcgKzE2Nyw3IEBACiAJKSAmJgogCShjZCBzdXBlci9zdWJtb2R1bGUgJiYKIAkgIGhlYWQ9JChnaXQgcmV2LXBhcnNlIC0tdmVyaWZ5IEhFQUQpICYmCi0JICBlY2hvICJTdWJtb2R1bGUgcGF0aCAke2Fwb3N9c3VibW9kdWxlJGFwb3M6IGNoZWNrZWQgb3V0ICRhcG9zJGhlYWQkYXBvcyIgPiAuLi8uLi9leHBlY3RlZCAmJgorCSAgZWNobyAiU3VibW9kdWxlIHBhdGggJHtTUX1zdWJtb2R1bGUkU1E6IGNoZWNrZWQgb3V0ICRTUSRoZWFkJFNRIiA+IC4uLy4uL2V4cGVjdGVkICYmCiAJICBnaXQgcmVzZXQgLS1oYXJkIEhFQUR+MQogCSkgJiYKIAkoY2Qgc3VwZXIgJiYKZGlmZiAtLWdpdCBhL3QvdDc0MTktc3VibW9kdWxlLXNldC1icmFuY2guc2ggYi90L3Q3NDE5LXN1Ym1vZHVsZS1zZXQtYnJhbmNoLnNoCmluZGV4IGM0YjM3MGUuLmZkMjVmNzggMTAwNzU1Ci0tLSBhL3QvdDc0MTktc3VibW9kdWxlLXNldC1icmFuY2guc2gKKysrIGIvdC90NzQxOS1zdWJtb2R1bGUtc2V0LWJyYW5jaC5zaApAQCAtMzQsNyArMzQsNyBAQAogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdlbnN1cmUgc3VibW9kdWxlIGJyYW5jaCBpcyB1bnNldCcgJwogCShjZCBzdXBlciAmJgotCQl0ZXN0X211c3RfZmFpbCBncmVwIGJyYW5jaCAuZ2l0bW9kdWxlcworCQkhIGdyZXAgYnJhbmNoIC5naXRtb2R1bGVzCiAJKQogJwogCkBAIC01NCw3ICs1NCw3IEBACiB0ZXN0X2V4cGVjdF9zdWNjZXNzICd0ZXN0IHN1Ym1vZHVsZSBzZXQtYnJhbmNoIC0tZGVmYXVsdCcgJwogCShjZCBzdXBlciAmJgogCQlnaXQgc3VibW9kdWxlIHNldC1icmFuY2ggLS1kZWZhdWx0IHN1Ym1vZHVsZSAmJgotCQl0ZXN0X211c3RfZmFpbCBncmVwIGJyYW5jaCAuZ2l0bW9kdWxlcyAmJgorCQkhIGdyZXAgYnJhbmNoIC5naXRtb2R1bGVzICYmCiAJCWdpdCBzdWJtb2R1bGUgdXBkYXRlIC0tcmVtb3RlICYmCiAJCWNhdCA8PC1cRU9GID5leHBlY3QgJiYKIAkJYQpAQCAtODAsNyArODAsNyBAQAogdGVzdF9leHBlY3Rfc3VjY2VzcyAndGVzdCBzdWJtb2R1bGUgc2V0LWJyYW5jaCAtZCcgJwogCShjZCBzdXBlciAmJgogCQlnaXQgc3VibW9kdWxlIHNldC1icmFuY2ggLWQgc3VibW9kdWxlICYmCi0JCXRlc3RfbXVzdF9mYWlsIGdyZXAgYnJhbmNoIC5naXRtb2R1bGVzICYmCisJCSEgZ3JlcCBicmFuY2ggLmdpdG1vZHVsZXMgJiYKIAkJZ2l0IHN1Ym1vZHVsZSB1cGRhdGUgLS1yZW1vdGUgJiYKIAkJY2F0IDw8LVxFT0YgPmV4cGVjdCAmJgogCQlhCmRpZmYgLS1naXQgYS90L3Q3NTAzLXByZS1jb21taXQtYW5kLXByZS1tZXJnZS1jb21taXQtaG9va3Muc2ggYi90L3Q3NTAzLXByZS1jb21taXQtYW5kLXByZS1tZXJnZS1jb21taXQtaG9va3Muc2gKbmV3IGZpbGUgbW9kZSAxMDA3NTUKaW5kZXggMDAwMDAwMC4uYjM0ODU0NQotLS0gL2Rldi9udWxsCisrKyBiL3QvdDc1MDMtcHJlLWNvbW1pdC1hbmQtcHJlLW1lcmdlLWNvbW1pdC1ob29rcy5zaApAQCAtMCwwICsxLDI4MSBAQAorIyEvYmluL3NoCisKK3Rlc3RfZGVzY3JpcHRpb249J3ByZS1jb21taXQgYW5kIHByZS1tZXJnZS1jb21taXQgaG9va3MnCisKKy4gLi90ZXN0LWxpYi5zaAorCitIT09LRElSPSIkKGdpdCByZXYtcGFyc2UgLS1naXQtZGlyKS9ob29rcyIKK1BSRUNPTU1JVD0iJEhPT0tESVIvcHJlLWNvbW1pdCIKK1BSRU1FUkdFPSIkSE9PS0RJUi9wcmUtbWVyZ2UtY29tbWl0IgorCisjIFByZXBhcmUgc2FtcGxlIHNjcmlwdHMgdGhhdCB3cml0ZSB0aGVpciAkMCB0byBhY3R1YWxfaG9va3MKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3NhbXBsZSBzY3JpcHQgc2V0dXAnICcKKwlta2RpciAtcCAiJEhPT0tESVIiICYmCisJd3JpdGVfc2NyaXB0ICIkSE9PS0RJUi9zdWNjZXNzLnNhbXBsZSIgPDwtXEVPRiAmJgorCWVjaG8gJDAgPj5hY3R1YWxfaG9va3MKKwlleGl0IDAKKwlFT0YKKwl3cml0ZV9zY3JpcHQgIiRIT09LRElSL2ZhaWwuc2FtcGxlIiA8PC1cRU9GICYmCisJZWNobyAkMCA+PmFjdHVhbF9ob29rcworCWV4aXQgMQorCUVPRgorCXdyaXRlX3NjcmlwdCAiJEhPT0tESVIvbm9uLWV4ZWMuc2FtcGxlIiA8PC1cRU9GICYmCisJZWNobyAkMCA+PmFjdHVhbF9ob29rcworCWV4aXQgMQorCUVPRgorCWNobW9kIC14ICIkSE9PS0RJUi9ub24tZXhlYy5zYW1wbGUiICYmCisJd3JpdGVfc2NyaXB0ICIkSE9PS0RJUi9yZXF1aXJlLXByZWZpeC5zYW1wbGUiIDw8LVxFT0YgJiYKKwllY2hvICQwID4+YWN0dWFsX2hvb2tzCisJdGVzdCAkR0lUX1BSRUZJWCA9ICJzdWNjZXNzLyIKKwlFT0YKKwl3cml0ZV9zY3JpcHQgIiRIT09LRElSL2NoZWNrLWF1dGhvci5zYW1wbGUiIDw8LVxFT0YKKwllY2hvICQwID4+YWN0dWFsX2hvb2tzCisJdGVzdCAiJEdJVF9BVVRIT1JfTkFNRSIgPSAiTmV3IEF1dGhvciIgJiYKKwl0ZXN0ICIkR0lUX0FVVEhPUl9FTUFJTCIgPSAibmV3YXV0aG9yQGV4YW1wbGUuY29tIgorCUVPRgorJworCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdyb290IGNvbW1pdCcgJworCWVjaG8gInJvb3QiID5maWxlICYmCisJZ2l0IGFkZCBmaWxlICYmCisJZ2l0IGNvbW1pdCAtbSAiemVyb3RoIiAmJgorCWdpdCBjaGVja291dCAtYiBzaWRlICYmCisJZWNobyAiZm9vIiA+Zm9vICYmCisJZ2l0IGFkZCBmb28gJiYKKwlnaXQgY29tbWl0IC1tICJtYWtlIGl0IG5vbi1mZiIgJiYKKwlnaXQgYnJhbmNoIHNpZGUtb3JpZyBzaWRlICYmCisJZ2l0IGNoZWNrb3V0IG1hc3RlcgorJworCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdzZXR1cCBjb25mbGljdGluZyBicmFuY2hlcycgJworCXRlc3Rfd2hlbl9maW5pc2hlZCAiZ2l0IGNoZWNrb3V0IG1hc3RlciIgJiYKKwlnaXQgY2hlY2tvdXQgLWIgY29uZmxpY3RpbmctYSBtYXN0ZXIgJiYKKwllY2hvIGEgPmNvbmZsaWN0aW5nICYmCisJZ2l0IGFkZCBjb25mbGljdGluZyAmJgorCWdpdCBjb21taXQgLW0gY29uZmxpY3RpbmctYSAmJgorCWdpdCBjaGVja291dCAtYiBjb25mbGljdGluZy1iIG1hc3RlciAmJgorCWVjaG8gYiA+Y29uZmxpY3RpbmcgJiYKKwlnaXQgYWRkIGNvbmZsaWN0aW5nICYmCisJZ2l0IGNvbW1pdCAtbSBjb25mbGljdGluZy1iCisnCisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3dpdGggbm8gaG9vaycgJworCXRlc3Rfd2hlbl9maW5pc2hlZCAicm0gLWYgYWN0dWFsX2hvb2tzIiAmJgorCWVjaG8gImZvbyIgPmZpbGUgJiYKKwlnaXQgYWRkIGZpbGUgJiYKKwlnaXQgY29tbWl0IC1tICJmaXJzdCIgJiYKKwl0ZXN0X3BhdGhfaXNfbWlzc2luZyBhY3R1YWxfaG9va3MKKycKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAnd2l0aCBubyBob29rIChtZXJnZSknICcKKwl0ZXN0X3doZW5fZmluaXNoZWQgInJtIC1mIGFjdHVhbF9ob29rcyIgJiYKKwlnaXQgYnJhbmNoIC1mIHNpZGUgc2lkZS1vcmlnICYmCisJZ2l0IGNoZWNrb3V0IHNpZGUgJiYKKwlnaXQgbWVyZ2UgLW0gIm1lcmdlIG1hc3RlciIgbWFzdGVyICYmCisJZ2l0IGNoZWNrb3V0IG1hc3RlciAmJgorCXRlc3RfcGF0aF9pc19taXNzaW5nIGFjdHVhbF9ob29rcworJworCit0ZXN0X2V4cGVjdF9zdWNjZXNzICctLW5vLXZlcmlmeSB3aXRoIG5vIGhvb2snICcKKwl0ZXN0X3doZW5fZmluaXNoZWQgInJtIC1mIGFjdHVhbF9ob29rcyIgJiYKKwllY2hvICJiYXIiID5maWxlICYmCisJZ2l0IGFkZCBmaWxlICYmCisJZ2l0IGNvbW1pdCAtLW5vLXZlcmlmeSAtbSAiYmFyIiAmJgorCXRlc3RfcGF0aF9pc19taXNzaW5nIGFjdHVhbF9ob29rcworJworCit0ZXN0X2V4cGVjdF9zdWNjZXNzICctLW5vLXZlcmlmeSB3aXRoIG5vIGhvb2sgKG1lcmdlKScgJworCXRlc3Rfd2hlbl9maW5pc2hlZCAicm0gLWYgYWN0dWFsX2hvb2tzIiAmJgorCWdpdCBicmFuY2ggLWYgc2lkZSBzaWRlLW9yaWcgJiYKKwlnaXQgY2hlY2tvdXQgc2lkZSAmJgorCWdpdCBtZXJnZSAtLW5vLXZlcmlmeSAtbSAibWVyZ2UgbWFzdGVyIiBtYXN0ZXIgJiYKKwlnaXQgY2hlY2tvdXQgbWFzdGVyICYmCisJdGVzdF9wYXRoX2lzX21pc3NpbmcgYWN0dWFsX2hvb2tzCisnCisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3dpdGggc3VjY2VlZGluZyBob29rJyAnCisJdGVzdF93aGVuX2ZpbmlzaGVkICJybSAtZiBcIiRQUkVDT01NSVRcIiBleHBlY3RlZF9ob29rcyBhY3R1YWxfaG9va3MiICYmCisJY3AgIiRIT09LRElSL3N1Y2Nlc3Muc2FtcGxlIiAiJFBSRUNPTU1JVCIgJiYKKwllY2hvICIkUFJFQ09NTUlUIiA+ZXhwZWN0ZWRfaG9va3MgJiYKKwllY2hvICJtb3JlIiA+PmZpbGUgJiYKKwlnaXQgYWRkIGZpbGUgJiYKKwlnaXQgY29tbWl0IC1tICJtb3JlIiAmJgorCXRlc3RfY21wIGV4cGVjdGVkX2hvb2tzIGFjdHVhbF9ob29rcworJworCit0ZXN0X2V4cGVjdF9zdWNjZXNzICd3aXRoIHN1Y2NlZWRpbmcgaG9vayAobWVyZ2UpJyAnCisJdGVzdF93aGVuX2ZpbmlzaGVkICJybSAtZiBcIiRQUkVNRVJHRVwiIGV4cGVjdGVkX2hvb2tzIGFjdHVhbF9ob29rcyIgJiYKKwljcCAiJEhPT0tESVIvc3VjY2Vzcy5zYW1wbGUiICIkUFJFTUVSR0UiICYmCisJZWNobyAiJFBSRU1FUkdFIiA+ZXhwZWN0ZWRfaG9va3MgJiYKKwlnaXQgY2hlY2tvdXQgc2lkZSAmJgorCWdpdCBtZXJnZSAtbSAibWVyZ2UgbWFzdGVyIiBtYXN0ZXIgJiYKKwlnaXQgY2hlY2tvdXQgbWFzdGVyICYmCisJdGVzdF9jbXAgZXhwZWN0ZWRfaG9va3MgYWN0dWFsX2hvb2tzCisnCisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2F1dG9tYXRpYyBtZXJnZSBmYWlsczsgYm90aCBob29rcyBhcmUgYXZhaWxhYmxlJyAnCisJdGVzdF93aGVuX2ZpbmlzaGVkICJybSAtZiBcIiRQUkVNRVJHRVwiIFwiJFBSRUNPTU1JVFwiIiAmJgorCXRlc3Rfd2hlbl9maW5pc2hlZCAicm0gLWYgZXhwZWN0ZWRfaG9va3MgYWN0dWFsX2hvb2tzIiAmJgorCXRlc3Rfd2hlbl9maW5pc2hlZCAiZ2l0IGNoZWNrb3V0IG1hc3RlciIgJiYKKwljcCAiJEhPT0tESVIvc3VjY2Vzcy5zYW1wbGUiICIkUFJFTUVSR0UiICYmCisJY3AgIiRIT09LRElSL3N1Y2Nlc3Muc2FtcGxlIiAiJFBSRUNPTU1JVCIgJiYKKworCWdpdCBjaGVja291dCBjb25mbGljdGluZy1hICYmCisJdGVzdF9tdXN0X2ZhaWwgZ2l0IG1lcmdlIC1tICJtZXJnZSBjb25mbGljdGluZy1iIiBjb25mbGljdGluZy1iICYmCisJdGVzdF9wYXRoX2lzX21pc3NpbmcgYWN0dWFsX2hvb2tzICYmCisKKwllY2hvICIkUFJFQ09NTUlUIiA+ZXhwZWN0ZWRfaG9va3MgJiYKKwllY2hvIGErYiA+Y29uZmxpY3RpbmcgJiYKKwlnaXQgYWRkIGNvbmZsaWN0aW5nICYmCisJZ2l0IGNvbW1pdCAtbSAicmVzb2x2ZSBjb25mbGljdCIgJiYKKwl0ZXN0X2NtcCBleHBlY3RlZF9ob29rcyBhY3R1YWxfaG9va3MKKycKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAnLS1uby12ZXJpZnkgd2l0aCBzdWNjZWVkaW5nIGhvb2snICcKKwl0ZXN0X3doZW5fZmluaXNoZWQgInJtIC1mIFwiJFBSRUNPTU1JVFwiIGFjdHVhbF9ob29rcyIgJiYKKwljcCAiJEhPT0tESVIvc3VjY2Vzcy5zYW1wbGUiICIkUFJFQ09NTUlUIiAmJgorCWVjaG8gImV2ZW4gbW9yZSIgPj5maWxlICYmCisJZ2l0IGFkZCBmaWxlICYmCisJZ2l0IGNvbW1pdCAtLW5vLXZlcmlmeSAtbSAiZXZlbiBtb3JlIiAmJgorCXRlc3RfcGF0aF9pc19taXNzaW5nIGFjdHVhbF9ob29rcworJworCit0ZXN0X2V4cGVjdF9zdWNjZXNzICctLW5vLXZlcmlmeSB3aXRoIHN1Y2NlZWRpbmcgaG9vayAobWVyZ2UpJyAnCisJdGVzdF93aGVuX2ZpbmlzaGVkICJybSAtZiBcIiRQUkVNRVJHRVwiIGFjdHVhbF9ob29rcyIgJiYKKwljcCAiJEhPT0tESVIvc3VjY2Vzcy5zYW1wbGUiICIkUFJFTUVSR0UiICYmCisJZ2l0IGJyYW5jaCAtZiBzaWRlIHNpZGUtb3JpZyAmJgorCWdpdCBjaGVja291dCBzaWRlICYmCisJZ2l0IG1lcmdlIC0tbm8tdmVyaWZ5IC1tICJtZXJnZSBtYXN0ZXIiIG1hc3RlciAmJgorCWdpdCBjaGVja291dCBtYXN0ZXIgJiYKKwl0ZXN0X3BhdGhfaXNfbWlzc2luZyBhY3R1YWxfaG9va3MKKycKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAnd2l0aCBmYWlsaW5nIGhvb2snICcKKwl0ZXN0X3doZW5fZmluaXNoZWQgInJtIC1mIFwiJFBSRUNPTU1JVFwiIGV4cGVjdGVkX2hvb2tzIGFjdHVhbF9ob29rcyIgJiYKKwljcCAiJEhPT0tESVIvZmFpbC5zYW1wbGUiICIkUFJFQ09NTUlUIiAmJgorCWVjaG8gIiRQUkVDT01NSVQiID5leHBlY3RlZF9ob29rcyAmJgorCWVjaG8gImFub3RoZXIiID4+ZmlsZSAmJgorCWdpdCBhZGQgZmlsZSAmJgorCXRlc3RfbXVzdF9mYWlsIGdpdCBjb21taXQgLW0gImFub3RoZXIiICYmCisJdGVzdF9jbXAgZXhwZWN0ZWRfaG9va3MgYWN0dWFsX2hvb2tzCisnCisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJy0tbm8tdmVyaWZ5IHdpdGggZmFpbGluZyBob29rJyAnCisJdGVzdF93aGVuX2ZpbmlzaGVkICJybSAtZiBcIiRQUkVDT01NSVRcIiBhY3R1YWxfaG9va3MiICYmCisJY3AgIiRIT09LRElSL2ZhaWwuc2FtcGxlIiAiJFBSRUNPTU1JVCIgJiYKKwllY2hvICJzdHVmZiIgPj5maWxlICYmCisJZ2l0IGFkZCBmaWxlICYmCisJZ2l0IGNvbW1pdCAtLW5vLXZlcmlmeSAtbSAic3R1ZmYiICYmCisJdGVzdF9wYXRoX2lzX21pc3NpbmcgYWN0dWFsX2hvb2tzCisnCisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3dpdGggZmFpbGluZyBob29rIChtZXJnZSknICcKKwl0ZXN0X3doZW5fZmluaXNoZWQgInJtIC1mIFwiJFBSRU1FUkdFXCIgZXhwZWN0ZWRfaG9va3MgYWN0dWFsX2hvb2tzIiAmJgorCWNwICIkSE9PS0RJUi9mYWlsLnNhbXBsZSIgIiRQUkVNRVJHRSIgJiYKKwllY2hvICIkUFJFTUVSR0UiID5leHBlY3RlZF9ob29rcyAmJgorCWdpdCBjaGVja291dCBzaWRlICYmCisJdGVzdF9tdXN0X2ZhaWwgZ2l0IG1lcmdlIC1tICJtZXJnZSBtYXN0ZXIiIG1hc3RlciAmJgorCWdpdCBjaGVja291dCBtYXN0ZXIgJiYKKwl0ZXN0X2NtcCBleHBlY3RlZF9ob29rcyBhY3R1YWxfaG9va3MKKycKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAnLS1uby12ZXJpZnkgd2l0aCBmYWlsaW5nIGhvb2sgKG1lcmdlKScgJworCXRlc3Rfd2hlbl9maW5pc2hlZCAicm0gLWYgXCIkUFJFTUVSR0VcIiBhY3R1YWxfaG9va3MiICYmCisJY3AgIiRIT09LRElSL2ZhaWwuc2FtcGxlIiAiJFBSRU1FUkdFIiAmJgorCWdpdCBicmFuY2ggLWYgc2lkZSBzaWRlLW9yaWcgJiYKKwlnaXQgY2hlY2tvdXQgc2lkZSAmJgorCWdpdCBtZXJnZSAtLW5vLXZlcmlmeSAtbSAibWVyZ2UgbWFzdGVyIiBtYXN0ZXIgJiYKKwlnaXQgY2hlY2tvdXQgbWFzdGVyICYmCisJdGVzdF9wYXRoX2lzX21pc3NpbmcgYWN0dWFsX2hvb2tzCisnCisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgUE9TSVhQRVJNICd3aXRoIG5vbi1leGVjdXRhYmxlIGhvb2snICcKKwl0ZXN0X3doZW5fZmluaXNoZWQgInJtIC1mIFwiJFBSRUNPTU1JVFwiIGFjdHVhbF9ob29rcyIgJiYKKwljcCAiJEhPT0tESVIvbm9uLWV4ZWMuc2FtcGxlIiAiJFBSRUNPTU1JVCIgJiYKKwllY2hvICJjb250ZW50IiA+PmZpbGUgJiYKKwlnaXQgYWRkIGZpbGUgJiYKKwlnaXQgY29tbWl0IC1tICJjb250ZW50IiAmJgorCXRlc3RfcGF0aF9pc19taXNzaW5nIGFjdHVhbF9ob29rcworJworCit0ZXN0X2V4cGVjdF9zdWNjZXNzIFBPU0lYUEVSTSAnLS1uby12ZXJpZnkgd2l0aCBub24tZXhlY3V0YWJsZSBob29rJyAnCisJdGVzdF93aGVuX2ZpbmlzaGVkICJybSAtZiBcIiRQUkVDT01NSVRcIiBhY3R1YWxfaG9va3MiICYmCisJY3AgIiRIT09LRElSL25vbi1leGVjLnNhbXBsZSIgIiRQUkVDT01NSVQiICYmCisJZWNobyAibW9yZSBjb250ZW50IiA+PmZpbGUgJiYKKwlnaXQgYWRkIGZpbGUgJiYKKwlnaXQgY29tbWl0IC0tbm8tdmVyaWZ5IC1tICJtb3JlIGNvbnRlbnQiICYmCisJdGVzdF9wYXRoX2lzX21pc3NpbmcgYWN0dWFsX2hvb2tzCisnCisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgUE9TSVhQRVJNICd3aXRoIG5vbi1leGVjdXRhYmxlIGhvb2sgKG1lcmdlKScgJworCXRlc3Rfd2hlbl9maW5pc2hlZCAicm0gLWYgXCIkUFJFTUVSR0VcIiBhY3R1YWxfaG9va3MiICYmCisJY3AgIiRIT09LRElSL25vbi1leGVjLnNhbXBsZSIgIiRQUkVNRVJHRSIgJiYKKwlnaXQgYnJhbmNoIC1mIHNpZGUgc2lkZS1vcmlnICYmCisJZ2l0IGNoZWNrb3V0IHNpZGUgJiYKKwlnaXQgbWVyZ2UgLW0gIm1lcmdlIG1hc3RlciIgbWFzdGVyICYmCisJZ2l0IGNoZWNrb3V0IG1hc3RlciAmJgorCXRlc3RfcGF0aF9pc19taXNzaW5nIGFjdHVhbF9ob29rcworJworCit0ZXN0X2V4cGVjdF9zdWNjZXNzIFBPU0lYUEVSTSAnLS1uby12ZXJpZnkgd2l0aCBub24tZXhlY3V0YWJsZSBob29rIChtZXJnZSknICcKKwl0ZXN0X3doZW5fZmluaXNoZWQgInJtIC1mIFwiJFBSRU1FUkdFXCIgYWN0dWFsX2hvb2tzIiAmJgorCWNwICIkSE9PS0RJUi9ub24tZXhlYy5zYW1wbGUiICIkUFJFTUVSR0UiICYmCisJZ2l0IGJyYW5jaCAtZiBzaWRlIHNpZGUtb3JpZyAmJgorCWdpdCBjaGVja291dCBzaWRlICYmCisJZ2l0IG1lcmdlIC0tbm8tdmVyaWZ5IC1tICJtZXJnZSBtYXN0ZXIiIG1hc3RlciAmJgorCWdpdCBjaGVja291dCBtYXN0ZXIgJiYKKwl0ZXN0X3BhdGhfaXNfbWlzc2luZyBhY3R1YWxfaG9va3MKKycKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAnd2l0aCBob29rIHJlcXVpcmluZyBHSVRfUFJFRklYJyAnCisJdGVzdF93aGVuX2ZpbmlzaGVkICJybSAtcmYgXCIkUFJFQ09NTUlUXCIgZXhwZWN0ZWRfaG9va3MgYWN0dWFsX2hvb2tzIHN1Y2Nlc3MiICYmCisJY3AgIiRIT09LRElSL3JlcXVpcmUtcHJlZml4LnNhbXBsZSIgIiRQUkVDT01NSVQiICYmCisJZWNobyAiJFBSRUNPTU1JVCIgPmV4cGVjdGVkX2hvb2tzICYmCisJZWNobyAibW9yZSBjb250ZW50IiA+PmZpbGUgJiYKKwlnaXQgYWRkIGZpbGUgJiYKKwlta2RpciBzdWNjZXNzICYmCisJKAorCQljZCBzdWNjZXNzICYmCisJCWdpdCBjb21taXQgLW0gImhvb2sgcmVxdWlyZXMgR0lUX1BSRUZJWCA9IHN1Y2Nlc3MvIgorCSkgJiYKKwl0ZXN0X2NtcCBleHBlY3RlZF9ob29rcyBhY3R1YWxfaG9va3MKKycKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAnd2l0aCBmYWlsaW5nIGhvb2sgcmVxdWlyaW5nIEdJVF9QUkVGSVgnICcKKwl0ZXN0X3doZW5fZmluaXNoZWQgInJtIC1yZiBcIiRQUkVDT01NSVRcIiBleHBlY3RlZF9ob29rcyBhY3R1YWxfaG9va3MgZmFpbCIgJiYKKwljcCAiJEhPT0tESVIvcmVxdWlyZS1wcmVmaXguc2FtcGxlIiAiJFBSRUNPTU1JVCIgJiYKKwllY2hvICIkUFJFQ09NTUlUIiA+ZXhwZWN0ZWRfaG9va3MgJiYKKwllY2hvICJtb3JlIGNvbnRlbnQiID4+ZmlsZSAmJgorCWdpdCBhZGQgZmlsZSAmJgorCW1rZGlyIGZhaWwgJiYKKwkoCisJCWNkIGZhaWwgJiYKKwkJdGVzdF9tdXN0X2ZhaWwgZ2l0IGNvbW1pdCAtbSAiaG9vayBtdXN0IGZhaWwiCisJKSAmJgorCWdpdCBjaGVja291dCAtLSBmaWxlICYmCisJdGVzdF9jbXAgZXhwZWN0ZWRfaG9va3MgYWN0dWFsX2hvb2tzCisnCisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2NoZWNrIHRoZSBhdXRob3IgaW4gaG9vaycgJworCXRlc3Rfd2hlbl9maW5pc2hlZCAicm0gLWYgXCIkUFJFQ09NTUlUXCIgZXhwZWN0ZWRfaG9va3MgYWN0dWFsX2hvb2tzIiAmJgorCWNwICIkSE9PS0RJUi9jaGVjay1hdXRob3Iuc2FtcGxlIiAiJFBSRUNPTU1JVCIgJiYKKwljYXQgPmV4cGVjdGVkX2hvb2tzIDw8LUVPRiAmJgorCSRQUkVDT01NSVQKKwkkUFJFQ09NTUlUCisJJFBSRUNPTU1JVAorCUVPRgorCXRlc3RfbXVzdF9mYWlsIGdpdCBjb21taXQgLS1hbGxvdy1lbXB0eSAtbSAiYnkgYS51LnRob3IiICYmCisJKAorCQlHSVRfQVVUSE9SX05BTUU9Ik5ldyBBdXRob3IiICYmCisJCUdJVF9BVVRIT1JfRU1BSUw9Im5ld2F1dGhvckBleGFtcGxlLmNvbSIgJiYKKwkJZXhwb3J0IEdJVF9BVVRIT1JfTkFNRSBHSVRfQVVUSE9SX0VNQUlMICYmCisJCWdpdCBjb21taXQgLS1hbGxvdy1lbXB0eSAtbSAiYnkgbmV3LmF1dGhvciB2aWEgZW52IiAmJgorCQlnaXQgc2hvdyAtcworCSkgJiYKKwlnaXQgY29tbWl0IC0tYXV0aG9yPSJOZXcgQXV0aG9yIDxuZXdhdXRob3JAZXhhbXBsZS5jb20+IiBcCisJCS0tYWxsb3ctZW1wdHkgLW0gImJ5IG5ldy5hdXRob3IgdmlhIGNvbW1hbmQgbGluZSIgJiYKKwlnaXQgc2hvdyAtcyAmJgorCXRlc3RfY21wIGV4cGVjdGVkX2hvb2tzIGFjdHVhbF9ob29rcworJworCit0ZXN0X2RvbmUKZGlmZiAtLWdpdCBhL3QvdDc1MDMtcHJlLWNvbW1pdC1ob29rLnNoIGIvdC90NzUwMy1wcmUtY29tbWl0LWhvb2suc2gKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNzU1CmluZGV4IDk4NDg4OWIuLjAwMDAwMDAKLS0tIGEvdC90NzUwMy1wcmUtY29tbWl0LWhvb2suc2gKKysrIC9kZXYvbnVsbApAQCAtMSwxMzkgKzAsMCBAQAotIyEvYmluL3NoCi0KLXRlc3RfZGVzY3JpcHRpb249J3ByZS1jb21taXQgaG9vaycKLQotLiAuL3Rlc3QtbGliLnNoCi0KLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3dpdGggbm8gaG9vaycgJwotCi0JZWNobyAiZm9vIiA+IGZpbGUgJiYKLQlnaXQgYWRkIGZpbGUgJiYKLQlnaXQgY29tbWl0IC1tICJmaXJzdCIKLQotJwotCi10ZXN0X2V4cGVjdF9zdWNjZXNzICctLW5vLXZlcmlmeSB3aXRoIG5vIGhvb2snICcKLQotCWVjaG8gImJhciIgPiBmaWxlICYmCi0JZ2l0IGFkZCBmaWxlICYmCi0JZ2l0IGNvbW1pdCAtLW5vLXZlcmlmeSAtbSAiYmFyIgotCi0nCi0KLSMgbm93IGluc3RhbGwgaG9vayB0aGF0IGFsd2F5cyBzdWNjZWVkcwotSE9PS0RJUj0iJChnaXQgcmV2LXBhcnNlIC0tZ2l0LWRpcikvaG9va3MiCi1IT09LPSIkSE9PS0RJUi9wcmUtY29tbWl0IgotbWtkaXIgLXAgIiRIT09LRElSIgotY2F0ID4gIiRIT09LIiA8PEVPRgotIyEvYmluL3NoCi1leGl0IDAKLUVPRgotY2htb2QgK3ggIiRIT09LIgotCi10ZXN0X2V4cGVjdF9zdWNjZXNzICd3aXRoIHN1Y2NlZWRpbmcgaG9vaycgJwotCi0JZWNobyAibW9yZSIgPj4gZmlsZSAmJgotCWdpdCBhZGQgZmlsZSAmJgotCWdpdCBjb21taXQgLW0gIm1vcmUiCi0KLScKLQotdGVzdF9leHBlY3Rfc3VjY2VzcyAnLS1uby12ZXJpZnkgd2l0aCBzdWNjZWVkaW5nIGhvb2snICcKLQotCWVjaG8gImV2ZW4gbW9yZSIgPj4gZmlsZSAmJgotCWdpdCBhZGQgZmlsZSAmJgotCWdpdCBjb21taXQgLS1uby12ZXJpZnkgLW0gImV2ZW4gbW9yZSIKLQotJwotCi0jIG5vdyBhIGhvb2sgdGhhdCBmYWlscwotY2F0ID4gIiRIT09LIiA8PEVPRgotIyEvYmluL3NoCi1leGl0IDEKLUVPRgotCi10ZXN0X2V4cGVjdF9zdWNjZXNzICd3aXRoIGZhaWxpbmcgaG9vaycgJwotCi0JZWNobyAiYW5vdGhlciIgPj4gZmlsZSAmJgotCWdpdCBhZGQgZmlsZSAmJgotCXRlc3RfbXVzdF9mYWlsIGdpdCBjb21taXQgLW0gImFub3RoZXIiCi0KLScKLQotdGVzdF9leHBlY3Rfc3VjY2VzcyAnLS1uby12ZXJpZnkgd2l0aCBmYWlsaW5nIGhvb2snICcKLQotCWVjaG8gInN0dWZmIiA+PiBmaWxlICYmCi0JZ2l0IGFkZCBmaWxlICYmCi0JZ2l0IGNvbW1pdCAtLW5vLXZlcmlmeSAtbSAic3R1ZmYiCi0KLScKLQotY2htb2QgLXggIiRIT09LIgotdGVzdF9leHBlY3Rfc3VjY2VzcyBQT1NJWFBFUk0gJ3dpdGggbm9uLWV4ZWN1dGFibGUgaG9vaycgJwotCi0JZWNobyAiY29udGVudCIgPj4gZmlsZSAmJgotCWdpdCBhZGQgZmlsZSAmJgotCWdpdCBjb21taXQgLW0gImNvbnRlbnQiCi0KLScKLQotdGVzdF9leHBlY3Rfc3VjY2VzcyBQT1NJWFBFUk0gJy0tbm8tdmVyaWZ5IHdpdGggbm9uLWV4ZWN1dGFibGUgaG9vaycgJwotCi0JZWNobyAibW9yZSBjb250ZW50IiA+PiBmaWxlICYmCi0JZ2l0IGFkZCBmaWxlICYmCi0JZ2l0IGNvbW1pdCAtLW5vLXZlcmlmeSAtbSAibW9yZSBjb250ZW50IgotCi0nCi1jaG1vZCAreCAiJEhPT0siCi0KLSMgYSBob29rIHRoYXQgY2hlY2tzICRHSVRfUFJFRklYIGFuZCBzdWNjZWVkcyBpbnNpZGUgdGhlCi0jIHN1Y2Nlc3MvIHN1YmRpcmVjdG9yeSBvbmx5Ci1jYXQgPiAiJEhPT0siIDw8RU9GCi0jIS9iaW4vc2gKLXRlc3QgXCRHSVRfUFJFRklYID0gc3VjY2Vzcy8KLUVPRgotCi10ZXN0X2V4cGVjdF9zdWNjZXNzICd3aXRoIGhvb2sgcmVxdWlyaW5nIEdJVF9QUkVGSVgnICcKLQotCWVjaG8gIm1vcmUgY29udGVudCIgPj4gZmlsZSAmJgotCWdpdCBhZGQgZmlsZSAmJgotCW1rZGlyIHN1Y2Nlc3MgJiYKLQkoCi0JCWNkIHN1Y2Nlc3MgJiYKLQkJZ2l0IGNvbW1pdCAtbSAiaG9vayByZXF1aXJlcyBHSVRfUFJFRklYID0gc3VjY2Vzcy8iCi0JKSAmJgotCXJtZGlyIHN1Y2Nlc3MKLScKLQotdGVzdF9leHBlY3Rfc3VjY2VzcyAnd2l0aCBmYWlsaW5nIGhvb2sgcmVxdWlyaW5nIEdJVF9QUkVGSVgnICcKLQotCWVjaG8gIm1vcmUgY29udGVudCIgPj4gZmlsZSAmJgotCWdpdCBhZGQgZmlsZSAmJgotCW1rZGlyIGZhaWwgJiYKLQkoCi0JCWNkIGZhaWwgJiYKLQkJdGVzdF9tdXN0X2ZhaWwgZ2l0IGNvbW1pdCAtbSAiaG9vayBtdXN0IGZhaWwiCi0JKSAmJgotCXJtZGlyIGZhaWwgJiYKLQlnaXQgY2hlY2tvdXQgLS0gZmlsZQotJwotCi10ZXN0X2V4cGVjdF9zdWNjZXNzICdjaGVjayB0aGUgYXV0aG9yIGluIGhvb2snICcKLQl3cml0ZV9zY3JpcHQgIiRIT09LIiA8PC1cRU9GICYmCi0JdGVzdCAiJEdJVF9BVVRIT1JfTkFNRSIgPSAiTmV3IEF1dGhvciIgJiYKLQl0ZXN0ICIkR0lUX0FVVEhPUl9FTUFJTCIgPSAibmV3YXV0aG9yQGV4YW1wbGUuY29tIgotCUVPRgotCXRlc3RfbXVzdF9mYWlsIGdpdCBjb21taXQgLS1hbGxvdy1lbXB0eSAtbSAiYnkgYS51LnRob3IiICYmCi0JKAotCQlHSVRfQVVUSE9SX05BTUU9Ik5ldyBBdXRob3IiICYmCi0JCUdJVF9BVVRIT1JfRU1BSUw9Im5ld2F1dGhvckBleGFtcGxlLmNvbSIgJiYKLQkJZXhwb3J0IEdJVF9BVVRIT1JfTkFNRSBHSVRfQVVUSE9SX0VNQUlMICYmCi0JCWdpdCBjb21taXQgLS1hbGxvdy1lbXB0eSAtbSAiYnkgbmV3LmF1dGhvciB2aWEgZW52IiAmJgotCQlnaXQgc2hvdyAtcwotCSkgJiYKLQlnaXQgY29tbWl0IC0tYXV0aG9yPSJOZXcgQXV0aG9yIDxuZXdhdXRob3JAZXhhbXBsZS5jb20+IiBcCi0JCS0tYWxsb3ctZW1wdHkgLW0gImJ5IG5ldy5hdXRob3IgdmlhIGNvbW1hbmQgbGluZSIgJiYKLQlnaXQgc2hvdyAtcwotJwotCi10ZXN0X2RvbmUKZGlmZiAtLWdpdCBhL3QvdDc1MDUtcHJlcGFyZS1jb21taXQtbXNnLWhvb2suc2ggYi90L3Q3NTA1LXByZXBhcmUtY29tbWl0LW1zZy1ob29rLnNoCmluZGV4IGJhOGJkMWIuLjk0Zjg1Y2QgMTAwNzU1Ci0tLSBhL3QvdDc1MDUtcHJlcGFyZS1jb21taXQtbXNnLWhvb2suc2gKKysrIGIvdC90NzUwNS1wcmVwYXJlLWNvbW1pdC1tc2ctaG9vay5zaApAQCAtMjQxLDEzICsyNDEsNyBAQAogCQkJZ2l0IGFkZCBiICYmCiAJCQlnaXQgcmViYXNlIC0tY29udGludWUKIAkJKSAmJgotCQlpZiB0ZXN0ICIkbW9kZSIgPSAtcCAjIHJld29yZCBhbWVuZGVkIGFmdGVyIHBpY2sKLQkJdGhlbgotCQkJbj0xOAotCQllbHNlCi0JCQluPTE3Ci0JCWZpICYmCi0JCWdpdCBsb2cgLS1wcmV0dHk9JXMgLWcgLW4kbiBIRUFEQHsxfSA+YWN0dWFsICYmCisJCWdpdCBsb2cgLS1wcmV0dHk9JXMgLWcgLW4xOCBIRUFEQHsxfSA+YWN0dWFsICYmCiAJCXRlc3RfY21wICIkVEVTVF9ESVJFQ1RPUlkvdDc1MDUvZXhwZWN0ZWQtcmViYXNlJHttb2RlOi0taX0iIGFjdHVhbAogCScKIH0KZGlmZiAtLWdpdCBhL3QvdDc1MDUvZXhwZWN0ZWQtcmViYXNlLWkgYi90L3Q3NTA1L2V4cGVjdGVkLXJlYmFzZS1pCmluZGV4IGM1MTRiZGIuLjkzYmFkYTUgMTAwNjQ0Ci0tLSBhL3QvdDc1MDUvZXhwZWN0ZWQtcmViYXNlLWkKKysrIGIvdC90NzUwNS9leHBlY3RlZC1yZWJhc2UtaQpAQCAtNyw3ICs3LDggQEAKIG1lc3NhZ2UgW2ZpeHVwIHJlYmFzZS05XQogbWVzc2FnZSAobm8gZWRpdG9yKSBbZml4dXAgcmViYXNlLThdCiBtZXNzYWdlIChubyBlZGl0b3IpIFtzcXVhc2ggcmViYXNlLTddCi1tZXNzYWdlIFtyZXdvcmQgcmViYXNlLTZdCitIRUFEIFtyZXdvcmQgcmViYXNlLTZdCittZXNzYWdlIChubyBlZGl0b3IpIFtyZXdvcmQgcmViYXNlLTZdCiBtZXNzYWdlIFtzcXVhc2ggcmViYXNlLTVdCiBtZXNzYWdlIChubyBlZGl0b3IpIFtmaXh1cCByZWJhc2UtNF0KIG1lc3NhZ2UgKG5vIGVkaXRvcikgW3BpY2sgcmViYXNlLTNdCmRpZmYgLS1naXQgYS90L3Q3NTA4LXN0YXR1cy5zaCBiL3QvdDc1MDgtc3RhdHVzLnNoCmluZGV4IDRlNjc2Y2QuLjQ4MmNlMzUgMTAwNzU1Ci0tLSBhL3QvdDc1MDgtc3RhdHVzLnNoCisrKyBiL3QvdDc1MDgtc3RhdHVzLnNoCkBAIC0xNTcxLDcgKzE1NzEsNyBAQAogCXRlc3RfY21wIGV4cGVjdGVkX3dpdGhvdXRfc3Rhc2ggYWN0dWFsCiAnCiAKLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ25vIGFkZGl0aW9ubmFsIGluZm8gaWYgbm8gc3Rhc2ggZW50cmllcycgJwordGVzdF9leHBlY3Rfc3VjY2VzcyAnbm8gYWRkaXRpb25hbCBpbmZvIGlmIG5vIHN0YXNoIGVudHJpZXMnICcKIAlnaXQgc3Rhc2ggY2xlYXIgJiYKIAlnaXQgLWMgc3RhdHVzLnNob3dTdGFzaD10cnVlIHN0YXR1cyA+YWN0dWFsICYmCiAJdGVzdF9jbXAgZXhwZWN0ZWRfd2l0aG91dF9zdGFzaCBhY3R1YWwKZGlmZiAtLWdpdCBhL3QvdDc1MTItc3RhdHVzLWhlbHAuc2ggYi90L3Q3NTEyLXN0YXR1cy1oZWxwLnNoCmluZGV4IGUwMWMyODUuLjY2ZDdhNjIgMTAwNzU1Ci0tLSBhL3QvdDc1MTItc3RhdHVzLWhlbHAuc2gKKysrIGIvdC90NzUxMi1zdGF0dXMtaGVscC5zaApAQCAtNzMzLDYgKzczMyw3IEBACiBPbiBicmFuY2ggY2hlcnJ5X2JyYW5jaAogWW91IGFyZSBjdXJyZW50bHkgY2hlcnJ5LXBpY2tpbmcgY29tbWl0ICRUT19DSEVSUllfUElDSy4KICAgKGZpeCBjb25mbGljdHMgYW5kIHJ1biAiZ2l0IGNoZXJyeS1waWNrIC0tY29udGludWUiKQorICAodXNlICJnaXQgY2hlcnJ5LXBpY2sgLS1za2lwIiB0byBza2lwIHRoaXMgcGF0Y2gpCiAgICh1c2UgImdpdCBjaGVycnktcGljayAtLWFib3J0IiB0byBjYW5jZWwgdGhlIGNoZXJyeS1waWNrIG9wZXJhdGlvbikKIAogVW5tZXJnZWQgcGF0aHM6CkBAIC03NTcsNiArNzU4LDcgQEAKIE9uIGJyYW5jaCBjaGVycnlfYnJhbmNoCiBZb3UgYXJlIGN1cnJlbnRseSBjaGVycnktcGlja2luZyBjb21taXQgJFRPX0NIRVJSWV9QSUNLLgogICAoYWxsIGNvbmZsaWN0cyBmaXhlZDogcnVuICJnaXQgY2hlcnJ5LXBpY2sgLS1jb250aW51ZSIpCisgICh1c2UgImdpdCBjaGVycnktcGljayAtLXNraXAiIHRvIHNraXAgdGhpcyBwYXRjaCkKICAgKHVzZSAiZ2l0IGNoZXJyeS1waWNrIC0tYWJvcnQiIHRvIGNhbmNlbCB0aGUgY2hlcnJ5LXBpY2sgb3BlcmF0aW9uKQogCiBDaGFuZ2VzIHRvIGJlIGNvbW1pdHRlZDoKQEAgLTc3OCw2ICs3ODAsNyBAQAogT24gYnJhbmNoIGNoZXJyeV9icmFuY2gKIENoZXJyeS1waWNrIGN1cnJlbnRseSBpbiBwcm9ncmVzcy4KICAgKHJ1biAiZ2l0IGNoZXJyeS1waWNrIC0tY29udGludWUiIHRvIGNvbnRpbnVlKQorICAodXNlICJnaXQgY2hlcnJ5LXBpY2sgLS1za2lwIiB0byBza2lwIHRoaXMgcGF0Y2gpCiAgICh1c2UgImdpdCBjaGVycnktcGljayAtLWFib3J0IiB0byBjYW5jZWwgdGhlIGNoZXJyeS1waWNrIG9wZXJhdGlvbikKIAogbm90aGluZyB0byBjb21taXQgKHVzZSAtdSB0byBzaG93IHVudHJhY2tlZCBmaWxlcykKQEAgLTgzNSw2ICs4MzgsNyBAQAogT24gYnJhbmNoIG1hc3RlcgogWW91IGFyZSBjdXJyZW50bHkgcmV2ZXJ0aW5nIGNvbW1pdCAkVE9fUkVWRVJULgogICAoZml4IGNvbmZsaWN0cyBhbmQgcnVuICJnaXQgcmV2ZXJ0IC0tY29udGludWUiKQorICAodXNlICJnaXQgcmV2ZXJ0IC0tc2tpcCIgdG8gc2tpcCB0aGlzIHBhdGNoKQogICAodXNlICJnaXQgcmV2ZXJ0IC0tYWJvcnQiIHRvIGNhbmNlbCB0aGUgcmV2ZXJ0IG9wZXJhdGlvbikKIAogVW5tZXJnZWQgcGF0aHM6CkBAIC04NTUsNiArODU5LDcgQEAKIE9uIGJyYW5jaCBtYXN0ZXIKIFlvdSBhcmUgY3VycmVudGx5IHJldmVydGluZyBjb21taXQgJFRPX1JFVkVSVC4KICAgKGFsbCBjb25mbGljdHMgZml4ZWQ6IHJ1biAiZ2l0IHJldmVydCAtLWNvbnRpbnVlIikKKyAgKHVzZSAiZ2l0IHJldmVydCAtLXNraXAiIHRvIHNraXAgdGhpcyBwYXRjaCkKICAgKHVzZSAiZ2l0IHJldmVydCAtLWFib3J0IiB0byBjYW5jZWwgdGhlIHJldmVydCBvcGVyYXRpb24pCiAKIENoYW5nZXMgdG8gYmUgY29tbWl0dGVkOgpAQCAtODg3LDYgKzg5Miw3IEBACiBPbiBicmFuY2ggbWFzdGVyCiBSZXZlcnQgY3VycmVudGx5IGluIHByb2dyZXNzLgogICAocnVuICJnaXQgcmV2ZXJ0IC0tY29udGludWUiIHRvIGNvbnRpbnVlKQorICAodXNlICJnaXQgcmV2ZXJ0IC0tc2tpcCIgdG8gc2tpcCB0aGlzIHBhdGNoKQogICAodXNlICJnaXQgcmV2ZXJ0IC0tYWJvcnQiIHRvIGNhbmNlbCB0aGUgcmV2ZXJ0IG9wZXJhdGlvbikKIAogbm90aGluZyB0byBjb21taXQgKHVzZSAtdSB0byBzaG93IHVudHJhY2tlZCBmaWxlcykKZGlmZiAtLWdpdCBhL3QvdDc1MTMtaW50ZXJwcmV0LXRyYWlsZXJzLnNoIGIvdC90NzUxMy1pbnRlcnByZXQtdHJhaWxlcnMuc2gKaW5kZXggZjE5MjAyYi4uNjYwMjc5MCAxMDA3NTUKLS0tIGEvdC90NzUxMy1pbnRlcnByZXQtdHJhaWxlcnMuc2gKKysrIGIvdC90NzUxMy1pbnRlcnByZXQtdHJhaWxlcnMuc2gKQEAgLTEyMzQsNyArMTIzNCw3IEBACiAJdGVzdF9jbXAgZXhwZWN0ZWQgYWN0dWFsCiAnCiAKLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3dpdGggY29tbWFuZCB1c2luZyBjb21taXRlciBpbmZvcm1hdGlvbicgJwordGVzdF9leHBlY3Rfc3VjY2VzcyAnd2l0aCBjb21tYW5kIHVzaW5nIGNvbW1pdHRlciBpbmZvcm1hdGlvbicgJwogCWdpdCBjb25maWcgdHJhaWxlci5zaWduLmlmRXhpc3RzICJhZGRJZkRpZmZlcmVudCIgJiYKIAlnaXQgY29uZmlnIHRyYWlsZXIuc2lnbi5jb21tYW5kICJlY2hvIFwiXCRHSVRfQ09NTUlUVEVSX05BTUUgPFwkR0lUX0NPTU1JVFRFUl9FTUFJTD5cIiIgJiYKIAljYXQgY29tcGxleF9tZXNzYWdlX2JvZHkgPmV4cGVjdGVkICYmCmRpZmYgLS1naXQgYS90L3Q3NTE5LXN0YXR1cy1mc21vbml0b3Iuc2ggYi90L3Q3NTE5LXN0YXR1cy1mc21vbml0b3Iuc2gKaW5kZXggODdjZjFkZC4uY2YwZmRhMiAxMDA3NTUKLS0tIGEvdC90NzUxOS1zdGF0dXMtZnNtb25pdG9yLnNoCisrKyBiL3QvdDc1MTktc3RhdHVzLWZzbW9uaXRvci5zaApAQCAtMjk5LDcgKzI5OSw3IEBACiAJZG9uZQogZG9uZQogCi0jIHRlc3QgdGhhdCBzcGxpdHRpbmcgdGhlIGluZGV4IGRvc24ndCBpbnRlcmZlcmUKKyMgdGVzdCB0aGF0IHNwbGl0dGluZyB0aGUgaW5kZXggZG9lc24ndCBpbnRlcmZlcmUKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3NwbGl0dGluZyB0aGUgaW5kZXggcmVzdWx0cyBpbiB0aGUgc2FtZSBzdGF0ZScgJwogCXdyaXRlX2ludGVncmF0aW9uX3NjcmlwdCAmJgogCWRpcnR5X3JlcG8gJiYKZGlmZiAtLWdpdCBhL3QvdDc1MTkvZnNtb25pdG9yLXdhdGNobWFuIGIvdC90NzUxOS9mc21vbml0b3Itd2F0Y2htYW4KaW5kZXggNTUxNGVkYy4uZDhlN2ExZSAxMDA3NTUKLS0tIGEvdC90NzUxOS9mc21vbml0b3Itd2F0Y2htYW4KKysrIGIvdC90NzUxOS9mc21vbml0b3Itd2F0Y2htYW4KQEAgLTIzLDcgKzIzLDggQEAKIAogaWYgKCR2ZXJzaW9uID09IDEpIHsKIAkjIGNvbnZlcnQgbmFub3NlY29uZHMgdG8gc2Vjb25kcwotCSR0aW1lID0gaW50ICR0aW1lIC8gMTAwMDAwMDAwMDsKKwkjIHN1YnRyYWN0IG9uZSBzZWNvbmQgdG8gbWFrZSBzdXJlIHdhdGNobWFuIHdpbGwgcmV0dXJuIGFsbCBjaGFuZ2VzCisJJHRpbWUgPSBpbnQgKCR0aW1lIC8gMTAwMDAwMDAwMCkgLSAxOwogfSBlbHNlIHsKIAlkaWUgIlVuc3VwcG9ydGVkIHF1ZXJ5LWZzbW9uaXRvciBob29rIHZlcnNpb24gJyR2ZXJzaW9uJy5cbiIgLgogCSAgICAiRmFsbGluZyBiYWNrIHRvIHNjYW5uaW5nLi4uXG4iOwpAQCAtNTQsMTggKzU1LDEyIEBACiAJIwogCSMgVG8gYWNjb21wbGlzaCB0aGlzLCB3ZSdyZSB1c2luZyB0aGUgInNpbmNlIiBnZW5lcmF0b3IgdG8gdXNlIHRoZQogCSMgcmVjZW5jeSBpbmRleCB0byBzZWxlY3QgY2FuZGlkYXRlIG5vZGVzIGFuZCAiZmllbGRzIiB0byBsaW1pdCB0aGUKLQkjIG91dHB1dCB0byBmaWxlIG5hbWVzIG9ubHkuIFRoZW4gd2UncmUgdXNpbmcgdGhlICJleHByZXNzaW9uIiB0ZXJtIHRvCi0JIyBmdXJ0aGVyIGNvbnN0cmFpbiB0aGUgcmVzdWx0cy4KLQkjCi0JIyBUaGUgY2F0ZWdvcnkgb2YgdHJhbnNpZW50IGZpbGVzIHRoYXQgd2Ugd2FudCB0byBpZ25vcmUgd2lsbCBoYXZlIGEKLQkjIGNyZWF0aW9uIGNsb2NrIChjY2xvY2spIG5ld2VyIHRoYW4gJHRpbWVfdCB2YWx1ZSBhbmQgd2lsbCBhbHNvIG5vdAotCSMgY3VycmVudGx5IGV4aXN0LgorCSMgb3V0cHV0IHRvIGZpbGUgbmFtZXMgb25seS4KIAogCW15ICRxdWVyeSA9IDw8IglFTkQiOwogCQlbInF1ZXJ5IiwgIiRnaXRfd29ya190cmVlIiwgewogCQkJInNpbmNlIjogJHRpbWUsCi0JCQkiZmllbGRzIjogWyJuYW1lIl0sCi0JCQkiZXhwcmVzc2lvbiI6IFsibm90IiwgWyJhbGxvZiIsIFsic2luY2UiLCAkdGltZSwgImNjbG9jayJdLCBbIm5vdCIsICJleGlzdHMiXV1dCisJCQkiZmllbGRzIjogWyJuYW1lIl0KIAkJfV0KIAlFTkQKIAkKZGlmZiAtLWdpdCBhL3QvdDc4MTItZ3JlcC1pY2FzZS1ub24tYXNjaWkuc2ggYi90L3Q3ODEyLWdyZXAtaWNhc2Utbm9uLWFzY2lpLnNoCmluZGV4IDBjNjg1ZDMuLjUzMWViNTkgMTAwNzU1Ci0tLSBhL3QvdDc4MTItZ3JlcC1pY2FzZS1ub24tYXNjaWkuc2gKKysrIGIvdC90NzgxMi1ncmVwLWljYXNlLW5vbi1hc2NpaS5zaApAQCAtNTMsNCArNTMsMzIgQEAKIAl0ZXN0X2NtcCBleHBlY3RlZCBhY3R1YWwKICcKIAordGVzdF9leHBlY3Rfc3VjY2VzcyBHRVRURVhUX0xPQ0FMRSxMSUJQQ1JFMiAnUENSRSB2Mjogc2V0dXAgaW52YWxpZCBVVEYtOCBkYXRhJyAnCisJcHJpbnRmICJcXDIwMFxcbiIgPmludmFsaWQtMHg4MCAmJgorCWVjaG8gIsOmdmFyIiA+ZXhwZWN0ZWQgJiYKKwljYXQgZXhwZWN0ZWQgPj5pbnZhbGlkLTB4ODAgJiYKKwlnaXQgYWRkIGludmFsaWQtMHg4MAorJworCit0ZXN0X2V4cGVjdF9zdWNjZXNzIEdFVFRFWFRfTE9DQUxFLExJQlBDUkUyICdQQ1JFIHYyOiBncmVwIEFTQ0lJIGZyb20gaW52YWxpZCBVVEYtOCBkYXRhJyAnCisJZ2l0IGdyZXAgLWggInZhciIgaW52YWxpZC0weDgwID5hY3R1YWwgJiYKKwl0ZXN0X2NtcCBleHBlY3RlZCBhY3R1YWwgJiYKKwlnaXQgZ3JlcCAtaCAiKCpOT19KSVQpdmFyIiBpbnZhbGlkLTB4ODAgPmFjdHVhbCAmJgorCXRlc3RfY21wIGV4cGVjdGVkIGFjdHVhbAorJworCit0ZXN0X2V4cGVjdF9zdWNjZXNzIEdFVFRFWFRfTE9DQUxFLExJQlBDUkUyICdQQ1JFIHYyOiBncmVwIG5vbi1BU0NJSSBmcm9tIGludmFsaWQgVVRGLTggZGF0YScgJworCWdpdCBncmVwIC1oICLDpiIgaW52YWxpZC0weDgwID5hY3R1YWwgJiYKKwl0ZXN0X2NtcCBleHBlY3RlZCBhY3R1YWwgJiYKKwlnaXQgZ3JlcCAtaCAiKCpOT19KSVQpw6YiIGludmFsaWQtMHg4MCAmJgorCXRlc3RfY21wIGV4cGVjdGVkIGFjdHVhbAorJworCit0ZXN0X2V4cGVjdF9zdWNjZXNzIEdFVFRFWFRfTE9DQUxFLExJQlBDUkUyICdQQ1JFIHYyOiBncmVwIG5vbi1BU0NJSSBmcm9tIGludmFsaWQgVVRGLTggZGF0YSB3aXRoIC1pJyAnCisJdGVzdF9taWdodF9mYWlsIGdpdCBncmVwIC1oaSAiw4YiIGludmFsaWQtMHg4MCA+YWN0dWFsICYmCisJdGVzdF9jbXAgZXhwZWN0ZWQgYWN0dWFsICYmCisJdGVzdF9tdXN0X2ZhaWwgZ2l0IGdyZXAgLWhpICIoKk5PX0pJVCnDhiIgaW52YWxpZC0weDgwICYmCisJdGVzdF9jbXAgZXhwZWN0ZWQgYWN0dWFsCisnCisKIHRlc3RfZG9uZQpkaWZmIC0tZ2l0IGEvdC90NzgxNC1ncmVwLXJlY3Vyc2Utc3VibW9kdWxlcy5zaCBiL3QvdDc4MTQtZ3JlcC1yZWN1cnNlLXN1Ym1vZHVsZXMuc2gKaW5kZXggYTExMzY2Yi4uOTQ2ZjkxZiAxMDA3NTUKLS0tIGEvdC90NzgxNC1ncmVwLXJlY3Vyc2Utc3VibW9kdWxlcy5zaAorKysgYi90L3Q3ODE0LWdyZXAtcmVjdXJzZS1zdWJtb2R1bGVzLnNoCkBAIC00MDgsNCArNDA4LDI1IEBACiAJdGVzdF9jbXAgZXhwZWN0IGFjdHVhbAogJwogCityZXNldF9hbmRfY2xlYW4gKCkgeworCWdpdCByZXNldCAtLWhhcmQgJiYKKwlnaXQgY2xlYW4gLWZkICYmCisJZ2l0IHN1Ym1vZHVsZSBmb3JlYWNoIC0tcmVjdXJzaXZlICdnaXQgcmVzZXQgLS1oYXJkJyAmJgorCWdpdCBzdWJtb2R1bGUgZm9yZWFjaCAtLXJlY3Vyc2l2ZSAnZ2l0IGNsZWFuIC1mZCcKK30KKwordGVzdF9leHBlY3Rfc3VjY2VzcyAnZ3JlcCAtLXJlY3Vyc2Utc3VibW9kdWxlcyB3aXRob3V0IC0tY2FjaGVkIGNvbnNpZGVycyB3b3JrdHJlZSBtb2RpZmljYXRpb25zJyAnCisJcmVzZXRfYW5kX2NsZWFuICYmCisJZWNobyAiQSBtb2RpZmllZCBsaW5lIGluIHN1Ym1vZHVsZSIgPj5zdWJtb2R1bGUvYSAmJgorCWVjaG8gInN1Ym1vZHVsZS9hOkEgbW9kaWZpZWQgbGluZSBpbiBzdWJtb2R1bGUiID5leHBlY3QgJiYKKwlnaXQgZ3JlcCAtLXJlY3Vyc2Utc3VibW9kdWxlcyAiQSBtb2RpZmllZCBsaW5lIGluIHN1Ym1vZHVsZSIgPmFjdHVhbCAmJgorCXRlc3RfY21wIGV4cGVjdCBhY3R1YWwKKycKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAnZ3JlcCAtLXJlY3Vyc2Utc3VibW9kdWxlcyB3aXRoIC0tY2FjaGVkIGlnbm9yZXMgd29ya3RyZWUgbW9kaWZpY2F0aW9ucycgJworCXJlc2V0X2FuZF9jbGVhbiAmJgorCWVjaG8gIkEgbW9kaWZpZWQgbGluZSBpbiBzdWJtb2R1bGUiID4+c3VibW9kdWxlL2EgJiYKKwl0ZXN0X211c3RfZmFpbCBnaXQgZ3JlcCAtLXJlY3Vyc2Utc3VibW9kdWxlcyAtLWNhY2hlZCAiQSBtb2RpZmllZCBsaW5lIGluIHN1Ym1vZHVsZSIgPmFjdHVhbCAyPiYxICYmCisJdGVzdF9tdXN0X2JlX2VtcHR5IGFjdHVhbAorJwogdGVzdF9kb25lCmRpZmYgLS1naXQgYS90L3Q3ODE1LWdyZXAtYmluYXJ5LnNoIGIvdC90NzgxNS1ncmVwLWJpbmFyeS5zaApuZXcgZmlsZSBtb2RlIDEwMDc1NQppbmRleCAwMDAwMDAwLi45MGViYjY0Ci0tLSAvZGV2L251bGwKKysrIGIvdC90NzgxNS1ncmVwLWJpbmFyeS5zaApAQCAtMCwwICsxLDE0OCBAQAorIyEvYmluL3NoCisKK3Rlc3RfZGVzY3JpcHRpb249J2dpdCBncmVwIGluIGJpbmFyeSBmaWxlcycKKworLiAuL3Rlc3QtbGliLnNoCisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3NldHVwJyAiCisJZWNobyAnYmluYXJ5UWZpbGVRbVsqXWNRKsOmUcOwJyB8IHFfdG9fbnVsID5hICYmCisJZ2l0IGFkZCBhICYmCisJZ2l0IGNvbW1pdCAtbS4KKyIKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAnZ2l0IGdyZXAgaW5hIGEnICcKKwllY2hvIEJpbmFyeSBmaWxlIGEgbWF0Y2hlcyA+ZXhwZWN0ICYmCisJZ2l0IGdyZXAgaW5hIGEgPmFjdHVhbCAmJgorCXRlc3RfY21wIGV4cGVjdCBhY3R1YWwKKycKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAnZ2l0IGdyZXAgLWFoIGluYSBhJyAnCisJZ2l0IGdyZXAgLWFoIGluYSBhID5hY3R1YWwgJiYKKwl0ZXN0X2NtcCBhIGFjdHVhbAorJworCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdnaXQgZ3JlcCAtSSBpbmEgYScgJworCXRlc3RfbXVzdF9mYWlsIGdpdCBncmVwIC1JIGluYSBhID5hY3R1YWwgJiYKKwl0ZXN0X211c3RfYmVfZW1wdHkgYWN0dWFsCisnCisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2dpdCBncmVwIC1jIGluYSBhJyAnCisJZWNobyBhOjEgPmV4cGVjdCAmJgorCWdpdCBncmVwIC1jIGluYSBhID5hY3R1YWwgJiYKKwl0ZXN0X2NtcCBleHBlY3QgYWN0dWFsCisnCisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2dpdCBncmVwIC1sIGluYSBhJyAnCisJZWNobyBhID5leHBlY3QgJiYKKwlnaXQgZ3JlcCAtbCBpbmEgYSA+YWN0dWFsICYmCisJdGVzdF9jbXAgZXhwZWN0IGFjdHVhbAorJworCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdnaXQgZ3JlcCAtTCBiYXIgYScgJworCWVjaG8gYSA+ZXhwZWN0ICYmCisJZ2l0IGdyZXAgLUwgYmFyIGEgPmFjdHVhbCAmJgorCXRlc3RfY21wIGV4cGVjdCBhY3R1YWwKKycKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAnZ2l0IGdyZXAgLXEgaW5hIGEnICcKKwlnaXQgZ3JlcCAtcSBpbmEgYSA+YWN0dWFsICYmCisJdGVzdF9tdXN0X2JlX2VtcHR5IGFjdHVhbAorJworCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdnaXQgZ3JlcCAtRiBpbGUgYScgJworCWdpdCBncmVwIC1GIGlsZSBhCisnCisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2dpdCBncmVwIC1GaSBpTEUgYScgJworCWdpdCBncmVwIC1GaSBpTEUgYQorJworCisjIFRoaXMgdGVzdCBhY3R1YWxseSBwYXNzZXMgb24gcGxhdGZvcm1zIHdoZXJlIHJlZ2V4ZWMoKSBzdXBwb3J0cyB0aGUKKyMgZmxhZyBSRUdfU1RBUlRFTkQuCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdnaXQgZ3JlcCBpbGUgYScgJworCWdpdCBncmVwIGlsZSBhCisnCisKK3Rlc3RfZXhwZWN0X2ZhaWx1cmUgJ2dpdCBncmVwIC5maSBhJyAnCisJZ2l0IGdyZXAgLmZpIGEKKycKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAnZ3JlcCByZXNwZWN0cyBiaW5hcnkgZGlmZiBhdHRyaWJ1dGUnICcKKwllY2hvIHRleHQgPnQgJiYKKwlnaXQgYWRkIHQgJiYKKwllY2hvIHQ6dGV4dCA+ZXhwZWN0ICYmCisJZ2l0IGdyZXAgdGV4dCB0ID5hY3R1YWwgJiYKKwl0ZXN0X2NtcCBleHBlY3QgYWN0dWFsICYmCisJZWNobyAidCAtZGlmZiIgPi5naXRhdHRyaWJ1dGVzICYmCisJZWNobyAiQmluYXJ5IGZpbGUgdCBtYXRjaGVzIiA+ZXhwZWN0ICYmCisJZ2l0IGdyZXAgdGV4dCB0ID5hY3R1YWwgJiYKKwl0ZXN0X2NtcCBleHBlY3QgYWN0dWFsCisnCisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2dyZXAgLS1jYWNoZWQgcmVzcGVjdHMgYmluYXJ5IGRpZmYgYXR0cmlidXRlJyAnCisJZ2l0IGdyZXAgLS1jYWNoZWQgdGV4dCB0ID5hY3R1YWwgJiYKKwl0ZXN0X2NtcCBleHBlY3QgYWN0dWFsCisnCisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2dyZXAgLS1jYWNoZWQgcmVzcGVjdHMgYmluYXJ5IGRpZmYgYXR0cmlidXRlICgyKScgJworCWdpdCBhZGQgLmdpdGF0dHJpYnV0ZXMgJiYKKwlybSAuZ2l0YXR0cmlidXRlcyAmJgorCWdpdCBncmVwIC0tY2FjaGVkIHRleHQgdCA+YWN0dWFsICYmCisJdGVzdF93aGVuX2ZpbmlzaGVkICJnaXQgcm0gLS1jYWNoZWQgLmdpdGF0dHJpYnV0ZXMiICYmCisJdGVzdF93aGVuX2ZpbmlzaGVkICJnaXQgY2hlY2tvdXQgLmdpdGF0dHJpYnV0ZXMiICYmCisJdGVzdF9jbXAgZXhwZWN0IGFjdHVhbAorJworCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdncmVwIHJldmlzaW9uIHJlc3BlY3RzIGJpbmFyeSBkaWZmIGF0dHJpYnV0ZScgJworCWdpdCBjb21taXQgLW0gbmV3ICYmCisJZWNobyAiQmluYXJ5IGZpbGUgSEVBRDp0IG1hdGNoZXMiID5leHBlY3QgJiYKKwlnaXQgZ3JlcCB0ZXh0IEhFQUQgLS0gdCA+YWN0dWFsICYmCisJdGVzdF93aGVuX2ZpbmlzaGVkICJnaXQgcmVzZXQgSEVBRF4iICYmCisJdGVzdF9jbXAgZXhwZWN0IGFjdHVhbAorJworCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdncmVwIHJlc3BlY3RzIG5vdC1iaW5hcnkgZGlmZiBhdHRyaWJ1dGUnICcKKwllY2hvIGJpblFhcnkgfCBxX3RvX251bCA+YiAmJgorCWdpdCBhZGQgYiAmJgorCWVjaG8gIkJpbmFyeSBmaWxlIGIgbWF0Y2hlcyIgPmV4cGVjdCAmJgorCWdpdCBncmVwIGJpbiBiID5hY3R1YWwgJiYKKwl0ZXN0X2NtcCBleHBlY3QgYWN0dWFsICYmCisJZWNobyAiYiBkaWZmIiA+LmdpdGF0dHJpYnV0ZXMgJiYKKwllY2hvICJiOmJpblFhcnkiID5leHBlY3QgJiYKKwlnaXQgZ3JlcCBiaW4gYiA+YWN0dWFsLnJhdyAmJgorCW51bF90b19xIDxhY3R1YWwucmF3ID5hY3R1YWwgJiYKKwl0ZXN0X2NtcCBleHBlY3QgYWN0dWFsCisnCisKK2NhdCA+bnVsX3RvX3FfdGV4dGNvbnYgPDwnRU9GJworIyEvYmluL3NoCisiJFBFUkxfUEFUSCIgLXBlICd5L1wwMDAvUS8nIDwgIiQxIgorRU9GCitjaG1vZCAreCBudWxfdG9fcV90ZXh0Y29udgorCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdzZXR1cCB0ZXh0Y29udiBmaWx0ZXJzJyAnCisJZWNobyBhIGRpZmY9Zm9vID4uZ2l0YXR0cmlidXRlcyAmJgorCWdpdCBjb25maWcgZGlmZi5mb28udGV4dGNvbnYgIlwiJChwd2QpXCIiL251bF90b19xX3RleHRjb252CisnCisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2dyZXAgZG9lcyBub3QgaG9ub3IgdGV4dGNvbnYnICcKKwl0ZXN0X211c3RfZmFpbCBnaXQgZ3JlcCBRZmlsZQorJworCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdncmVwIC0tdGV4dGNvbnYgaG9ub3JzIHRleHRjb252JyAnCisJZWNobyAiYTpiaW5hcnlRZmlsZVFtWypdY1Eqw6ZRw7AiID5leHBlY3QgJiYKKwlnaXQgZ3JlcCAtLXRleHRjb252IFFmaWxlID5hY3R1YWwgJiYKKwl0ZXN0X2NtcCBleHBlY3QgYWN0dWFsCisnCisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2dyZXAgLS1uby10ZXh0Y29udiBkb2VzIG5vdCBob25vciB0ZXh0Y29udicgJworCXRlc3RfbXVzdF9mYWlsIGdpdCBncmVwIC0tbm8tdGV4dGNvbnYgUWZpbGUKKycKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAnZ3JlcCAtLXRleHRjb252IGJsb2IgaG9ub3JzIHRleHRjb252JyAnCisJZWNobyAiSEVBRDphOmJpbmFyeVFmaWxlUW1bKl1jUSrDplHDsCIgPmV4cGVjdCAmJgorCWdpdCBncmVwIC0tdGV4dGNvbnYgUWZpbGUgSEVBRDphID5hY3R1YWwgJiYKKwl0ZXN0X2NtcCBleHBlY3QgYWN0dWFsCisnCisKK3Rlc3RfZG9uZQpkaWZmIC0tZ2l0IGEvdC90NzgxNi1ncmVwLWJpbmFyeS1wYXR0ZXJuLnNoIGIvdC90NzgxNi1ncmVwLWJpbmFyeS1wYXR0ZXJuLnNoCm5ldyBmaWxlIG1vZGUgMTAwNzU1CmluZGV4IDAwMDAwMDAuLjYwYmFiMjkKLS0tIC9kZXYvbnVsbAorKysgYi90L3Q3ODE2LWdyZXAtYmluYXJ5LXBhdHRlcm4uc2gKQEAgLTAsMCArMSwxMjcgQEAKKyMhL2Jpbi9zaAorCit0ZXN0X2Rlc2NyaXB0aW9uPSdnaXQgZ3JlcCB3aXRoIGEgYmluYXJ5IHBhdHRlcm4gZmlsZXMnCisKKy4gLi9saWItZ2V0dGV4dC5zaAorCitudWxfbWF0Y2hfaW50ZXJuYWwgKCkgeworCW1hdGNoZXM9JDEKKwlwcmVyZXFzPSQyCisJbGNfYWxsPSQzCisJZXh0cmFfZmxhZ3M9JDQKKwlmbGFncz0kNQorCXBhdHRlcm49JDYKKwlwYXR0ZXJuX2h1bWFuPSQoZWNobyAiJHBhdHRlcm4iIHwgc2VkICdzL1EvPE5VTD4vZycpCisKKwlpZiB0ZXN0ICIkbWF0Y2hlcyIgPSAxCisJdGhlbgorCQl0ZXN0X2V4cGVjdF9zdWNjZXNzICRwcmVyZXFzICJMQ19BTEw9JyRsY19hbGwnIGdpdCBncmVwICRleHRyYV9mbGFncyAtZiBmICRmbGFncyAnJHBhdHRlcm5faHVtYW4nIGEiICIKKwkJCXByaW50ZiAnJHBhdHRlcm4nIHwgcV90b19udWwgPmYgJiYKKwkJCUxDX0FMTD0nJGxjX2FsbCcgZ2l0IGdyZXAgJGV4dHJhX2ZsYWdzIC1mIGYgJGZsYWdzIGEKKwkJIgorCWVsaWYgdGVzdCAiJG1hdGNoZXMiID0gMAorCXRoZW4KKwkJdGVzdF9leHBlY3Rfc3VjY2VzcyAkcHJlcmVxcyAiTENfQUxMPSckbGNfYWxsJyBnaXQgZ3JlcCAkZXh0cmFfZmxhZ3MgLWYgZiAkZmxhZ3MgJyRwYXR0ZXJuX2h1bWFuJyBhIiAiCisJCQk+c3RkZXJyICYmCisJCQlwcmludGYgJyRwYXR0ZXJuJyB8IHFfdG9fbnVsID5mICYmCisJCQl0ZXN0X211c3RfZmFpbCBlbnYgTENfQUxMPVwiJGxjX2FsbFwiIGdpdCBncmVwICRleHRyYV9mbGFncyAtZiBmICRmbGFncyBhIDI+c3RkZXJyICYmCisJCQl0ZXN0X2kxOG5ncmVwICEgJ1RoaXMgaXMgb25seSBzdXBwb3J0ZWQgd2l0aCAtUCB1bmRlciBQQ1JFIHYyJyBzdGRlcnIKKwkJIgorCWVsaWYgdGVzdCAiJG1hdGNoZXMiID0gUAorCXRoZW4KKwkJdGVzdF9leHBlY3Rfc3VjY2VzcyAkcHJlcmVxcyAiZXJyb3IsIFBDUkUgdjIgb25seTogTENfQUxMPSckbGNfYWxsJyBnaXQgZ3JlcCAtZiBmICRmbGFncyAnJHBhdHRlcm5faHVtYW4nIGEiICIKKwkJCT5zdGRlcnIgJiYKKwkJCXByaW50ZiAnJHBhdHRlcm4nIHwgcV90b19udWwgPmYgJiYKKwkJCXRlc3RfbXVzdF9mYWlsIGVudiBMQ19BTEw9XCIkbGNfYWxsXCIgZ2l0IGdyZXAgLWYgZiAkZmxhZ3MgYSAyPnN0ZGVyciAmJgorCQkJdGVzdF9pMThuZ3JlcCAnVGhpcyBpcyBvbmx5IHN1cHBvcnRlZCB3aXRoIC1QIHVuZGVyIFBDUkUgdjInIHN0ZGVycgorCQkiCisJZWxzZQorCQl0ZXN0X2V4cGVjdF9zdWNjZXNzICJQQU5JQzogVGVzdCBmcmFtZXdvcmsgZXJyb3IuIFVua25vd24gbWF0Y2hlcyB2YWx1ZSAkbWF0Y2hlcyIgJ2ZhbHNlJworCWZpCit9CisKK251bF9tYXRjaCAoKSB7CisJbWF0Y2hlcz0kMQorCW1hdGNoZXNfcGNyZTI9JDIKKwltYXRjaGVzX3BjcmUyX2xvY2FsZT0kMworCWZsYWdzPSQ0CisJcGF0dGVybj0kNQorCXBhdHRlcm5faHVtYW49JChlY2hvICIkcGF0dGVybiIgfCBzZWQgJ3MvUS88TlVMPi9nJykKKworCW51bF9tYXRjaF9pbnRlcm5hbCAiJG1hdGNoZXMiICIiICJDIiAiIiAiJGZsYWdzIiAiJHBhdHRlcm4iCisJbnVsX21hdGNoX2ludGVybmFsICIkbWF0Y2hlc19wY3JlMiIgIkxJQlBDUkUyIiAiQyIgIi1QIiAiJGZsYWdzIiAiJHBhdHRlcm4iCisJbnVsX21hdGNoX2ludGVybmFsICIkbWF0Y2hlc19wY3JlMl9sb2NhbGUiICJMSUJQQ1JFMixHRVRURVhUX0xPQ0FMRSIgIiRpc19JU19sb2NhbGUiICItUCIgIiRmbGFncyIgIiRwYXR0ZXJuIgorfQorCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdzZXR1cCcgIgorCWVjaG8gJ2JpbmFyeVFmaWxlUW1bKl1jUSrDplHDsCcgfCBxX3RvX251bCA+YSAmJgorCWdpdCBhZGQgYSAmJgorCWdpdCBjb21taXQgLW0uCisiCisKKyMgU2ltcGxlIGZpeGVkLXN0cmluZyBtYXRjaGluZyB0aGF0IGNhbiB1c2Uga3dzZXQgKG5vIC1pICYmIG5vbi1BU0NJSSkKK251bF9tYXRjaCBQIFAgUCAnLUYnICd5UWYnCitudWxfbWF0Y2ggUCBQIFAgJy1GJyAneVF4JworbnVsX21hdGNoIFAgUCBQICctRmknICdZUWYnCitudWxfbWF0Y2ggUCBQIFAgJy1GaScgJ1lReCcKK251bF9tYXRjaCBQIFAgMSAnJyAneVFmJworbnVsX21hdGNoIFAgUCAwICcnICd5UXgnCitudWxfbWF0Y2ggUCBQIDEgJycgJ8OmUcOwJworbnVsX21hdGNoIFAgUCBQICctRicgJ2VRbVsqXWMnCitudWxfbWF0Y2ggUCBQIFAgJy1GaScgJ0VRTVsqXUMnCisKKyMgUmVnZXggcGF0dGVybnMgdGhhdCB3b3VsZCBtYXRjaCBidXQgc2hvdWxkbid0IHdpdGggLUYKK251bF9tYXRjaCBQIFAgUCAnLUYnICd5UVtmXScKK251bF9tYXRjaCBQIFAgUCAnLUYnICdbeV1RZicKK251bF9tYXRjaCBQIFAgUCAnLUZpJyAnWVFbRl0nCitudWxfbWF0Y2ggUCBQIFAgJy1GaScgJ1tZXVFGJworbnVsX21hdGNoIFAgUCBQICctRicgJ8OmUVvDsF0nCitudWxfbWF0Y2ggUCBQIFAgJy1GJyAnW8OmXVHDsCcKKworIyBUaGUgLUYga3dzZXQgY29kZXBhdGggY2FuJ3QgaGFuZGxlIC1pICYmIG5vbi1BU0NJSS4uLgorbnVsX21hdGNoIFAgMSAxICctaScgJ1vDpl1Rw7AnCisKKyMgLi4uUENSRSB2MiBvbmx5IG1hdGNoZXMgbm9uLUFTQ0lJIHdpdGggLWkgY2FzZWZvbGRpbmcgdW5kZXIgVVRGLTgKKyMgc2VtYW50aWNzCitudWxfbWF0Y2ggUCBQIFAgJy1GaScgJ8OGUVvDkF0nCitudWxfbWF0Y2ggUCAwIDEgJy1pJyAgJ8OGUVvDkF0nCitudWxfbWF0Y2ggUCAwIDEgJy1pJyAgJ1vDhl1Rw5AnCitudWxfbWF0Y2ggUCAwIDEgJy1pJyAnW8OGXVHDsCcKK251bF9tYXRjaCBQIDAgMSAnLWknICfDhlHDkCcKKworIyBcMCBpbiByZWdleGVzIGNhbiBvbmx5IHdvcmsgd2l0aCAtUCAmIFBDUkUgdjIKK251bF9tYXRjaCBQIFAgMSAnJyAneVFbZl0nCitudWxfbWF0Y2ggUCBQIDEgJycgJ1t5XVFmJworbnVsX21hdGNoIFAgUCAxICctaScgJ1lRW0ZdJworbnVsX21hdGNoIFAgUCAxICctaScgJ1tZXVFmJworbnVsX21hdGNoIFAgUCAxICcnICfDplFbw7BdJworbnVsX21hdGNoIFAgUCAxICcnICdbw6ZdUcOwJworbnVsX21hdGNoIFAgUCAxICctaScgJ8OGUVvDkF0nCitudWxfbWF0Y2ggUCBQIDEgJycgJ2VRbS4qY1EnCitudWxfbWF0Y2ggUCBQIDEgJy1pJyAnRVFNLipjUScKK251bF9tYXRjaCBQIFAgMCAnJyAnZVFtWypdYycKK251bF9tYXRjaCBQIFAgMCAnLWknICdFUU1bKl1DJworCisjIEFzc2VydCB0aGF0IHdlJ3JlIHVzaW5nIFJFR19TVEFSVEVORCBhbmQgdGhlIHBhdHRlcm4gZG9lc24ndCBtYXRjaAorIyBqdXN0IGJlY2F1c2UgaXQncyBjdXQgb2ZmIGF0IHRoZSBmaXJzdCBcMC4KK251bF9tYXRjaCBQIFAgMCAnLWknICdOT01BVENIUcOwJworbnVsX21hdGNoIFAgUCAwICctaScgJ1vDhl1RTk9NQVRDSCcKK251bF9tYXRjaCBQIFAgMCAnLWknICdbw6ZdUU5PTUFUQ0gnCisKKyMgRW5zdXJlIHRoYXQgdGhlIG1hdGNoZXIgZG9lc24ndCByZWdyZXNzIHRvIHNvbWV0aGluZyB0aGF0IHN0b3BzIGF0CisjIFwwCitudWxfbWF0Y2ggUCBQIFAgJy1GJyAneVFbZl0nCitudWxfbWF0Y2ggUCBQIFAgJy1GaScgJ1lRW0ZdJworbnVsX21hdGNoIFAgUCAwICcnICd5UU5PTUFUQ0gnCitudWxfbWF0Y2ggUCBQIDAgJycgJ1FOT01BVENIJworbnVsX21hdGNoIFAgUCAwICctaScgJ1lRTk9NQVRDSCcKK251bF9tYXRjaCBQIFAgMCAnLWknICdRTk9NQVRDSCcKK251bF9tYXRjaCBQIFAgUCAnLUYnICfDplFbw7BdJworbnVsX21hdGNoIFAgUCBQICctRmknICfDhlFbw5BdJworbnVsX21hdGNoIFAgUCAxICctaScgJ8OGUVvDkF0nCitudWxfbWF0Y2ggUCBQIDAgJycgJ3lRTsOTTUFUQ0gnCitudWxfbWF0Y2ggUCBQIDAgJycgJ1FOw5NNQVRDSCcKK251bF9tYXRjaCBQIFAgMCAnLWknICdZUU7Dk01BVENIJworbnVsX21hdGNoIFAgUCAwICctaScgJ1FOw5NNQVRDSCcKKwordGVzdF9kb25lCmRpZmYgLS1naXQgYS90L3Q5MDAxLXNlbmQtZW1haWwuc2ggYi90L3Q5MDAxLXNlbmQtZW1haWwuc2gKaW5kZXggOTk3ZjkwYi4uYmQ5NDc3OSAxMDA3NTUKLS0tIGEvdC90OTAwMS1zZW5kLWVtYWlsLnNoCisrKyBiL3QvdDkwMDEtc2VuZC1lbWFpbC5zaApAQCAtMTI2MCw3ICsxMjYwLDcgQEAKIAlncmVwICJUbzogZGVmYXVsdEBleGFtcGxlLmNvbSIgc3Rkb3V0CiAnCiAKLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJFBSRVJFUSAnc2VuZGVtYWlsLmlkZW50aXR5OiBib29sIGlkZW50aXR5IHZhcmlhYmxlIGV4aXN0YW5jZSBvdmVycmlkZXMnICcKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJFBSRVJFUSAnc2VuZGVtYWlsLmlkZW50aXR5OiBib29sIGlkZW50aXR5IHZhcmlhYmxlIGV4aXN0ZW5jZSBvdmVycmlkZXMnICcKIAlnaXQgLWMgc2VuZGVtYWlsLmlkZW50aXR5PWNsb3VkIFwKIAkJLWMgc2VuZGVtYWlsLnhtYWlsZXI9dHJ1ZSBcCiAJCS1jIHNlbmRlbWFpbC5jbG91ZC54bWFpbGVyPWZhbHNlIFwKZGlmZiAtLWdpdCBhL3QvdDkzMDAtZmFzdC1pbXBvcnQuc2ggYi90L3Q5MzAwLWZhc3QtaW1wb3J0LnNoCmluZGV4IDE0MWI3ZmEuLmU3MDdmYjggMTAwNzU1Ci0tLSBhL3QvdDkzMDAtZmFzdC1pbXBvcnQuc2gKKysrIGIvdC90OTMwMC1mYXN0LWltcG9ydC5zaApAQCAtODUsNiArODUsMzYgQEAKIAlBbiBhbm5vdGF0ZWQgdGFnIHRoYXQgYW5ub3RhdGVzIGEgYmxvYi4KIAlFT0YKIAorCXRhZyB0by1iZS1kZWxldGVkCisJZnJvbSA6MworCWRhdGEgPDxFT0YKKwlBbm90aGVyIGFubm90YXRlZCB0YWcgdGhhdCBhbm5vdGF0ZXMgYSBibG9iLgorCUVPRgorCisJcmVzZXQgcmVmcy90YWdzL3RvLWJlLWRlbGV0ZWQKKwlmcm9tIDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAKKworCXRhZyBuZXN0ZWQKKwltYXJrIDo2CisJZnJvbSA6NAorCWRhdGEgPDxFT0YKKwlUYWcgb2Ygb3VyIGxvdmVseSBjb21taXQKKwlFT0YKKworCXJlc2V0IHJlZnMvdGFncy9uZXN0ZWQKKwlmcm9tIDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAKKworCXRhZyBuZXN0ZWQKKwltYXJrIDo3CisJZnJvbSA6NgorCWRhdGEgPDxFT0YKKwlUYWcgb2YgdGFnIG9mIG91ciBsb3ZlbHkgY29tbWl0CisJRU9GCisKKwlhbGlhcworCW1hcmsgOjgKKwl0byA6NQorCiAJSU5QVVRfRU5ECiAJZ2l0IGZhc3QtaW1wb3J0IC0tZXhwb3J0LW1hcmtzPW1hcmtzLm91dCA8aW5wdXQgJiYKIAlnaXQgd2hhdGNoYW5nZWQgbWFzdGVyCkBAIC0xNTcsMTIgKzE4NywxOSBAQAogCXRlc3RfY21wIGV4cGVjdCBhY3R1YWwKICcKIAordGVzdF9leHBlY3Rfc3VjY2VzcyAnQTogdmVyaWZ5IHRhZyBkZWxldGlvbiBpcyBzdWNjZXNzZnVsJyAnCisJdGVzdF9tdXN0X2ZhaWwgZ2l0IHJldi1wYXJzZSAtLXZlcmlmeSByZWZzL3RhZ3MvdG8tYmUtZGVsZXRlZAorJworCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICdBOiB2ZXJpZnkgbWFya3Mgb3V0cHV0JyAnCiAJY2F0ID5leHBlY3QgPDwtRU9GICYmCiAJOjIgJChnaXQgcmV2LXBhcnNlIC0tdmVyaWZ5IG1hc3RlcjpmaWxlMikKIAk6MyAkKGdpdCByZXYtcGFyc2UgLS12ZXJpZnkgbWFzdGVyOmZpbGUzKQogCTo0ICQoZ2l0IHJldi1wYXJzZSAtLXZlcmlmeSBtYXN0ZXI6ZmlsZTQpCiAJOjUgJChnaXQgcmV2LXBhcnNlIC0tdmVyaWZ5IG1hc3Rlcl4wKQorCTo2ICQoZ2l0IGNhdC1maWxlIHRhZyBuZXN0ZWQgfCBncmVwIG9iamVjdCB8IGN1dCAtZCIgIiAtZiAyKQorCTo3ICQoZ2l0IHJldi1wYXJzZSAtLXZlcmlmeSBuZXN0ZWQpCisJOjggJChnaXQgcmV2LXBhcnNlIC0tdmVyaWZ5IG1hc3Rlcl4wKQogCUVPRgogCXRlc3RfY21wIGV4cGVjdCBtYXJrcy5vdXQKICcKQEAgLTI3ODEsNyArMjgxOCw2IEBACiAJQ09NTUlUCiAJTSAxMDA2NDQgOjQwM3ggaGVsbG8uYwogCUVPRgotCWNhdCBlcnIgJiYKIAl0ZXN0X2kxOG5ncmVwICJzcGFjZSBhZnRlciBtYXJrIiBlcnIKICcKIApAQCAtMjc5OCw3ICsyODM0LDYgQEAKIAlpbmxpbmUKIAlCTE9CCiAJRU9GCi0JY2F0IGVyciAmJgogCXRlc3RfaTE4bmdyZXAgIm52YWxpZCBkYXRhcmVmIiBlcnIKICcKIApAQCAtMjgxMiw3ICsyODQ3LDYgQEAKIAlDT01NSVQKIAlNIDEwMDY0NCAke3NoYTF9eCBoZWxsby5jCiAJRU9GCi0JY2F0IGVyciAmJgogCXRlc3RfaTE4bmdyZXAgInNwYWNlIGFmdGVyIFNIQTEiIGVycgogJwogCkBAIC0yODI4LDcgKzI4NjIsNiBAQAogCUNPTU1JVAogCU4gOjIwMnggOjMwMgogCUVPRgotCWNhdCBlcnIgJiYKIAl0ZXN0X2kxOG5ncmVwICJzcGFjZSBhZnRlciBtYXJrIiBlcnIKICcKIApAQCAtMjg0NCw3ICsyODc3LDYgQEAKIAlub3RlIGJsb2IKIAlCTE9CCiAJRU9GCi0JY2F0IGVyciAmJgogCXRlc3RfaTE4bmdyZXAgIm52YWxpZCBkYXRhcmVmIiBlcnIKICcKIApAQCAtMjg1OCw3ICsyODkwLDYgQEAKIAlDT01NSVQKIAlOICR7c2hhMX14IDozMDIKIAlFT0YKLQljYXQgZXJyICYmCiAJdGVzdF9pMThuZ3JlcCAic3BhY2UgYWZ0ZXIgU0hBMSIgZXJyCiAnCiAKQEAgLTI4NzQsNyArMjkwNSw2IEBACiAJQ09NTUlUCiAJTiA6MjAyIDozMDJ4CiAJRU9GCi0JY2F0IGVyciAmJgogCXRlc3RfaTE4bmdyZXAgImFmdGVyIG1hcmsiIGVycgogJwogCkBAIC0yOTA4LDcgKzI5MzgsNiBAQAogCUVPRgogCiAJIyBub3cgZXZhbHVhdGUgdGhlIGVycm9yCi0JY2F0IGVyciAmJgogCXRlc3RfaTE4bmdyZXAgImFmdGVyIG1hcmsiIGVycgogJwogCkBAIC0yOTI4LDcgKzI5NTcsNiBAQAogCW1lcmdlIDozMDN4CiAJTSAxMDA2NDQgOjQwMyBoZWxsby5jCiAJRU9GCi0JY2F0IGVyciAmJgogCXRlc3RfaTE4bmdyZXAgImFmdGVyIG1hcmsiIGVycgogJwogCkBAIC0yOTQ0LDcgKzI5NzIsNiBAQAogCXRhZyBTCiAJVEFHCiAJRU9GCi0JY2F0IGVyciAmJgogCXRlc3RfaTE4bmdyZXAgImFmdGVyIG1hcmsiIGVycgogJwogCkBAIC0yOTU1LDcgKzI5ODIsNiBAQAogCXRlc3RfbXVzdF9mYWlsIGdpdCBmYXN0LWltcG9ydCAtLWltcG9ydC1tYXJrcz1tYXJrcyA8PC1FT0YgMj5lcnIgJiYKIAljYXQtYmxvYiA6NDAzeAogCUVPRgotCWNhdCBlcnIgJiYKIAl0ZXN0X2kxOG5ncmVwICJhZnRlciBtYXJrIiBlcnIKICcKIApAQCAtMjk2Niw3ICsyOTkyLDYgQEAKIAl0ZXN0X211c3RfZmFpbCBnaXQgZmFzdC1pbXBvcnQgLS1pbXBvcnQtbWFya3M9bWFya3MgPDwtRU9GIDI+ZXJyICYmCiAJbHMgOjMwMnggaGVsbG8uYwogCUVPRgotCWNhdCBlcnIgJiYKIAl0ZXN0X2kxOG5ncmVwICJzcGFjZSBhZnRlciBtYXJrIiBlcnIKICcKIApAQCAtMjk3NSw3ICszMDAwLDYgQEAKIAl0ZXN0X211c3RfZmFpbCBnaXQgZmFzdC1pbXBvcnQgLS1pbXBvcnQtbWFya3M9bWFya3MgPDwtRU9GIDI+ZXJyICYmCiAJbHMgJHtzaGExfXggaGVsbG8uYwogCUVPRgotCWNhdCBlcnIgJiYKIAl0ZXN0X2kxOG5ncmVwICJzcGFjZSBhZnRlciB0cmVlLWlzaCIgZXJyCiAnCiAKZGlmZiAtLWdpdCBhL3QvdDkzMDEtZmFzdC1pbXBvcnQtbm90ZXMuc2ggYi90L3Q5MzAxLWZhc3QtaW1wb3J0LW5vdGVzLnNoCmluZGV4IGRhZGM3MGIuLmNhMjIzZGMgMTAwNzU1Ci0tLSBhL3QvdDkzMDEtZmFzdC1pbXBvcnQtbm90ZXMuc2gKKysrIGIvdC90OTMwMS1mYXN0LWltcG9ydC1ub3Rlcy5zaApAQCAtMjc1LDcgKzI3NSw3IEBACiAgICAgdGhpcmQgbm90ZSBmb3IgZmlyc3QgY29tbWl0CiBFWFBFQ1RfRU5ECiAKLXRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2FkZCBjb25jYXRlbnRhdGlvbiBub3RlcyB3aXRoIE0gY29tbWFuZCcgJwordGVzdF9leHBlY3Rfc3VjY2VzcyAnYWRkIGNvbmNhdGVuYXRpb24gbm90ZXMgd2l0aCBNIGNvbW1hbmQnICcKIAogCWdpdCBmYXN0LWltcG9ydCA8aW5wdXQgJiYKIAlHSVRfTk9URVNfUkVGPXJlZnMvbm90ZXMvdGVzdCBnaXQgbG9nIHwgZ3JlcCAiXiAgICAiID4gYWN0dWFsICYmCmRpZmYgLS1naXQgYS90L3Q5MzUwLWZhc3QtZXhwb3J0LnNoIGIvdC90OTM1MC1mYXN0LWV4cG9ydC5zaAppbmRleCBiNDAwNGUwLi5kYjA4NGZlIDEwMDc1NQotLS0gYS90L3Q5MzUwLWZhc3QtZXhwb3J0LnNoCisrKyBiL3QvdDkzNTAtZmFzdC1leHBvcnQuc2gKQEAgLTUzLDYgKzUzLDMzIEBACiAKICcKIAordGVzdF9leHBlY3Rfc3VjY2VzcyAnZmFzdC1leHBvcnQgXm11c3Nee2NvbW1pdH0gbXVzcycgJworCWdpdCBmYXN0LWV4cG9ydCAtLXRhZy1vZi1maWx0ZXJlZC1vYmplY3Q9cmV3cml0ZSBebXVzc157Y29tbWl0fSBtdXNzID5hY3R1YWwgJiYKKwljYXQgPmV4cGVjdGVkIDw8LUVPRiAmJgorCXRhZyBtdXNzCisJZnJvbSAkKGdpdCByZXYtcGFyc2UgLS12ZXJpZnkgbXVzc157Y29tbWl0fSkKKwkkKGdpdCBjYXQtZmlsZSB0YWcgbXVzcyB8IGdyZXAgdGFnZ2VyKQorCWRhdGEgOQorCXZhbGVudGluCisKKwlFT0YKKwl0ZXN0X2NtcCBleHBlY3RlZCBhY3R1YWwKKycKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAnZmFzdC1leHBvcnQgLS1tYXJrLXRhZ3MgXm11c3Nee2NvbW1pdH0gbXVzcycgJworCWdpdCBmYXN0LWV4cG9ydCAtLW1hcmstdGFncyAtLXRhZy1vZi1maWx0ZXJlZC1vYmplY3Q9cmV3cml0ZSBebXVzc157Y29tbWl0fSBtdXNzID5hY3R1YWwgJiYKKwljYXQgPmV4cGVjdGVkIDw8LUVPRiAmJgorCXRhZyBtdXNzCisJbWFyayA6MQorCWZyb20gJChnaXQgcmV2LXBhcnNlIC0tdmVyaWZ5IG11c3Nee2NvbW1pdH0pCisJJChnaXQgY2F0LWZpbGUgdGFnIG11c3MgfCBncmVwIHRhZ2dlcikKKwlkYXRhIDkKKwl2YWxlbnRpbgorCisJRU9GCisJdGVzdF9jbXAgZXhwZWN0ZWQgYWN0dWFsCisnCisKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2Zhc3QtZXhwb3J0IG1hc3Rlcn4yLi5tYXN0ZXInICcKIAogCWdpdCBmYXN0LWV4cG9ydCBtYXN0ZXJ+Mi4ubWFzdGVyID5hY3R1YWwgJiYKQEAgLTUxMywxMCArNTQwLDQxIEBACiAnCiAKICMgTkVFRFNXT1JLOiBub3QganVzdCBjaGVjayByZXR1cm4gc3RhdHVzLCBidXQgdmFsaWRhdGUgdGhlIG91dHB1dAorIyBOb3RlIHRoYXQgdGhlc2UgdGVzdHMgRE8gTk9USElORyBvdGhlciB0aGFuIHByaW50IGEgd2FybmluZyB0aGF0CisjIHRoZXkgYXJlIG9taXR0aW5nIHRoZSBvbmUgdGFnIHdlIGFza2VkIHRoZW0gdG8gZXhwb3J0IChiZWNhdXNlIHRoZQorIyB0YWdzIHJlc29sdmUgdG8gYSB0cmVlKS4gIFRoZXkgZXhpc3QganVzdCB0byBtYWtlIHN1cmUgd2UgZG8gbm90CisjIGFib3J0IGJ1dCBpbnN0ZWFkIGp1c3Qgd2Fybi4KIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ3RyZWVfdGFnLW9iaicgICAgJ2dpdCBmYXN0LWV4cG9ydCB0cmVlX3RhZy1vYmonCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICd0YWctb2JqX3RhZycgICAgICdnaXQgZmFzdC1leHBvcnQgdGFnLW9ial90YWcnCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICd0YWctb2JqX3RhZy1vYmonICdnaXQgZmFzdC1leHBvcnQgdGFnLW9ial90YWctb2JqJwogCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdoYW5kbGluZyB0YWdzIG9mIGJsb2JzJyAnCisJZ2l0IHRhZyAtYSAtbSAiVGFnIG9mIGEgYmxvYiIgYmxvYnRhZyAkKGdpdCByZXYtcGFyc2UgbWFzdGVyOmZpbGUpICYmCisJZ2l0IGZhc3QtZXhwb3J0IGJsb2J0YWcgPmFjdHVhbCAmJgorCWNhdCA+ZXhwZWN0IDw8LUVPRiAmJgorCWJsb2IKKwltYXJrIDoxCisJZGF0YSA5CisJZGllIEx1ZnQKKworCXRhZyBibG9idGFnCisJZnJvbSA6MQorCXRhZ2dlciAkR0lUX0NPTU1JVFRFUl9OQU1FIDwkR0lUX0NPTU1JVFRFUl9FTUFJTD4gJEdJVF9DT01NSVRURVJfREFURQorCWRhdGEgMTQKKwlUYWcgb2YgYSBibG9iCisKKwlFT0YKKwl0ZXN0X2NtcCBleHBlY3QgYWN0dWFsCisnCisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2hhbmRsaW5nIG5lc3RlZCB0YWdzJyAnCisJZ2l0IHRhZyAtYSAtbSAiVGhpcyBpcyBhIG5lc3RlZCB0YWciIG5lc3RlZCBtdXNzICYmCisJZ2l0IGZhc3QtZXhwb3J0IC0tbWFyay10YWdzIG5lc3RlZCA+b3V0cHV0ICYmCisJZ3JlcCAiXmZyb20gJFpFUk9fT0lEJCIgb3V0cHV0ICYmCisJZ3JlcCAiXnRhZyBuZXN0ZWQkIiBvdXRwdXQgPnRhZ19saW5lcyAmJgorCXRlc3RfbGluZV9jb3VudCA9IDIgdGFnX2xpbmVzCisnCisKIHRlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2RpcmVjdG9yeSBiZWNvbWVzIHN5bWxpbmsnICAgICAgICAnCiAJZ2l0IGluaXQgZGlydG9zeW1saW5rICYmCiAJZ2l0IGluaXQgcmVzdWx0ICYmCkBAIC01NjcsMTcgKzYyNSwxNSBAQAogJwogCiB0ZXN0X2V4cGVjdF9zdWNjZXNzICd0ZXN0IGJpZGlyZWN0aW9uYWxpdHknICcKLQk+bWFya3MtY3VyICYmCi0JPm1hcmtzLW5ldyAmJgogCWdpdCBpbml0IG1hcmtzLXRlc3QgJiYKLQlnaXQgZmFzdC1leHBvcnQgLS1leHBvcnQtbWFya3M9bWFya3MtY3VyIC0taW1wb3J0LW1hcmtzPW1hcmtzLWN1ciAtLWJyYW5jaGVzIHwgXAotCWdpdCAtLWdpdC1kaXI9bWFya3MtdGVzdC8uZ2l0IGZhc3QtaW1wb3J0IC0tZXhwb3J0LW1hcmtzPW1hcmtzLW5ldyAtLWltcG9ydC1tYXJrcz1tYXJrcy1uZXcgJiYKKwlnaXQgZmFzdC1leHBvcnQgLS1leHBvcnQtbWFya3M9bWFya3MtY3VyIC0taW1wb3J0LW1hcmtzLWlmLWV4aXN0cz1tYXJrcy1jdXIgLS1icmFuY2hlcyB8IFwKKwlnaXQgLS1naXQtZGlyPW1hcmtzLXRlc3QvLmdpdCBmYXN0LWltcG9ydCAtLWV4cG9ydC1tYXJrcz1tYXJrcy1uZXcgLS1pbXBvcnQtbWFya3MtaWYtZXhpc3RzPW1hcmtzLW5ldyAmJgogCShjZCBtYXJrcy10ZXN0ICYmCiAJZ2l0IHJlc2V0IC0taGFyZCAmJgogCWVjaG8gV29obGF1ZiA+IGZpbGUgJiYKIAlnaXQgY29tbWl0IC1hIC1tICJiYWNrIGluIHRpbWUiKSAmJgotCWdpdCAtLWdpdC1kaXI9bWFya3MtdGVzdC8uZ2l0IGZhc3QtZXhwb3J0IC0tZXhwb3J0LW1hcmtzPW1hcmtzLW5ldyAtLWltcG9ydC1tYXJrcz1tYXJrcy1uZXcgLS1icmFuY2hlcyB8IFwKLQlnaXQgZmFzdC1pbXBvcnQgLS1leHBvcnQtbWFya3M9bWFya3MtY3VyIC0taW1wb3J0LW1hcmtzPW1hcmtzLWN1cgorCWdpdCAtLWdpdC1kaXI9bWFya3MtdGVzdC8uZ2l0IGZhc3QtZXhwb3J0IC0tZXhwb3J0LW1hcmtzPW1hcmtzLW5ldyAtLWltcG9ydC1tYXJrcy1pZi1leGlzdHM9bWFya3MtbmV3IC0tYnJhbmNoZXMgfCBcCisJZ2l0IGZhc3QtaW1wb3J0IC0tZXhwb3J0LW1hcmtzPW1hcmtzLWN1ciAtLWltcG9ydC1tYXJrcy1pZi1leGlzdHM9bWFya3MtY3VyCiAnCiAKIGNhdCA+IGV4cGVjdGVkIDw8IEVPRgpkaWZmIC0tZ2l0IGEvdC90OTUwMi1naXR3ZWItc3RhbmRhbG9uZS1wYXJzZS1vdXRwdXQuc2ggYi90L3Q5NTAyLWdpdHdlYi1zdGFuZGFsb25lLXBhcnNlLW91dHB1dC5zaAppbmRleCAwNzk2YTQzLi5lMzhjYmM5IDEwMDc1NQotLS0gYS90L3Q5NTAyLWdpdHdlYi1zdGFuZGFsb25lLXBhcnNlLW91dHB1dC5zaAorKysgYi90L3Q5NTAyLWdpdHdlYi1zdGFuZGFsb25lLXBhcnNlLW91dHB1dC5zaApAQCAtMTg4LDggKzE4OCw4IEBACiAnCiAKIHhzcygpIHsKLQllY2hvID4mMiAiQ2hlY2tpbmcgJDEuLi4iICYmCi0JZ2l0d2ViX3J1biAiJDEiICYmCisJZWNobyA+JjIgIkNoZWNraW5nICQqLi4uIiAmJgorCWdpdHdlYl9ydW4gIiRAIiAmJgogCWlmIGdyZXAgIiRUQUciIGdpdHdlYi5ib2R5OyB0aGVuCiAJCWVjaG8gPiYyICJ4c3M6ICRUQUcgc2hvdWxkIGhhdmUgYmVlbiBxdW90ZWQgaW4gb3V0cHV0IgogCQlyZXR1cm4gMQpAQCAtMjAwLDcgKzIwMCw4IEBACiB0ZXN0X2V4cGVjdF9zdWNjZXNzICd4c3MgY2hlY2tzJyAnCiAJVEFHPSI8bWFnaWMteHNzLXRhZz4iICYmCiAJeHNzICJhPXJzcyZwPSRUQUciICYmCi0JeHNzICJhPXJzcyZwPWZvby5naXQmZj0kVEFHIgorCXhzcyAiYT1yc3MmcD1mb28uZ2l0JmY9JFRBRyIgJiYKKwl4c3MgIiIgIiRUQUcrIgogJwogCiB0ZXN0X2RvbmUKZGlmZiAtLWdpdCBhL3QvdDk4MDktZ2l0LXA0LWNsaWVudC12aWV3LnNoIGIvdC90OTgwOS1naXQtcDQtY2xpZW50LXZpZXcuc2gKaW5kZXggM2NmZjFmYy4uOWM5NzEwZCAxMDA3NTUKLS0tIGEvdC90OTgwOS1naXQtcDQtY2xpZW50LXZpZXcuc2gKKysrIGIvdC90OTgwOS1naXQtcDQtY2xpZW50LXZpZXcuc2gKQEAgLTQwNyw3ICs0MDcsNyBAQAogJwogCiAjCi0jIFdoYXQgaGFwcGVucyB3aGVuIHR3byBmaWxlcyBvZiB0aGUgc2FtZSBuYW1lIGFyZSBvdmVybGF5ZWQgdG9nZXRoZXI/CisjIFdoYXQgaGFwcGVucyB3aGVuIHR3byBmaWxlcyBvZiB0aGUgc2FtZSBuYW1lIGFyZSBvdmVybGFpZCB0b2dldGhlcj8KICMgVGhlIGxhc3QtbGlzdGVkIGZpbGUgc2hvdWxkIHRha2UgcHJlZmVyZW5jZS4KICMKICMgLy9kZXBvdApkaWZmIC0tZ2l0IGEvdC90OTkwMi1jb21wbGV0aW9uLnNoIGIvdC90OTkwMi1jb21wbGV0aW9uLnNoCmluZGV4IDc1NTEyYzMuLmVjM2VjY2YgMTAwNzU1Ci0tLSBhL3QvdDk5MDItY29tcGxldGlvbi5zaAorKysgYi90L3Q5OTAyLWNvbXBsZXRpb24uc2gKQEAgLTI4LDEwICsyOCwxMCBAQAogIwogIyAoMikgQSB0ZXN0IG1ha2VzIHN1cmUgdGhhdCBjb21tb24gc3ViY29tbWFuZHMgYXJlIGluY2x1ZGVkIGluIHRoZQogIyAgICAgY29tcGxldGlvbiBmb3IgImdpdCA8VEFCPiIsIGFuZCBhIHBsdW1iaW5nIGlzIGV4Y2x1ZGVkLiAgImFkZCIsCi0jICAgICAiZmlsdGVyLWJyYW5jaCIgYW5kICJscy1maWxlcyIgYXJlIGxpc3RlZCBmb3IgdGhpcy4KKyMgICAgICJyZWJhc2UiIGFuZCAibHMtZmlsZXMiIGFyZSBsaXN0ZWQgZm9yIHRoaXMuCiAKLUdJVF9URVNUSU5HX0FMTF9DT01NQU5EX0xJU1Q9J2FkZCBjaGVja291dCBjaGVjay1hdHRyIGZpbHRlci1icmFuY2ggbHMtZmlsZXMnCi1HSVRfVEVTVElOR19QT1JDRUxBSU5fQ09NTUFORF9MSVNUPSdhZGQgY2hlY2tvdXQgZmlsdGVyLWJyYW5jaCcKK0dJVF9URVNUSU5HX0FMTF9DT01NQU5EX0xJU1Q9J2FkZCBjaGVja291dCBjaGVjay1hdHRyIHJlYmFzZSBscy1maWxlcycKK0dJVF9URVNUSU5HX1BPUkNFTEFJTl9DT01NQU5EX0xJU1Q9J2FkZCBjaGVja291dCByZWJhc2UnCiAKIC4gIiRHSVRfQlVJTERfRElSL2NvbnRyaWIvY29tcGxldGlvbi9naXQtY29tcGxldGlvbi5iYXNoIgogCkBAIC0zNzgsNyArMzc4LDcgQEAKICcKIAogCi10ZXN0X2V4cGVjdF9zdWNjZXNzICdfX2dpdGRpciAtIHJldHVybnMgZXJyb3Igd2hlbiBjYW50IGZpbmQgcmVwbycgJwordGVzdF9leHBlY3Rfc3VjY2VzcyAnX19naXRkaXIgLSByZXR1cm5zIGVycm9yIHdoZW4gY2Fubm90IGZpbmQgcmVwbycgJwogCSgKIAkJX19naXRfZGlyPSJub24tZXhpc3RpbmciICYmCiAJCXRlc3RfbXVzdF9mYWlsIF9fZ2l0ZGlyID4iJGFjdHVhbCIKQEAgLTk0NSw3ICs5NDUsNyBAQAogCXJtIC1mIC5naXQvRkVUQ0hfSEVBRAogJwogCi10ZXN0X2V4cGVjdF9zdWNjZXNzICdfX2dpdF9yZWZzIC0gZG9udCBmaWx0ZXIgcmVmcyB1bmxlc3MgdG9sZCBzbycgJwordGVzdF9leHBlY3Rfc3VjY2VzcyAnX19naXRfcmVmcyAtIGRvIG5vdCBmaWx0ZXIgcmVmcyB1bmxlc3MgdG9sZCBzbycgJwogCWNhdCA+ZXhwZWN0ZWQgPDwtRU9GICYmCiAJSEVBRAogCW1hc3RlcgpAQCAtMTI1Nyw3ICsxMjU3LDcgQEAKIAkJIyBJbiB0aGUgZm9sbG93aW5nIHRlc3RzIGNhbGxpbmcgdGhpcyBmdW5jdGlvbiB3ZSBvbmx5CiAJCSMgY2FyZSBhYm91dCBob3cgX19naXRfY29tcGxldGVfaW5kZXhfZmlsZSgpIGRlYWxzIHdpdGgKIAkJIyB1bnVzdWFsIGNoYXJhY3RlcnMgaW4gcGF0aCBuYW1lcy4gIEJ5IHJlcXVlc3Rpbmcgb25seQotCQkjIHVudHJhY2tlZCBmaWxlcyB3ZSBkb250IGhhdmUgdG8gYm90aGVyIGFkZGluZyBhbnkKKwkJIyB1bnRyYWNrZWQgZmlsZXMgd2UgZG8gbm90IGhhdmUgdG8gYm90aGVyIGFkZGluZyBhbnkKIAkJIyBwYXRocyB0byB0aGUgaW5kZXggaW4gdGhvc2UgdGVzdHMuCiAJCV9fZ2l0X2NvbXBsZXRlX2luZGV4X2ZpbGUgLS1vdGhlcnMgJiYKIAkJcHJpbnRfY29tcApAQCAtMTM5MiwxMiArMTM5MiwxMiBAQAogCSMgYnVpbHQtaW4KIAlncmVwIC1xICJeYWRkIFwkIiBvdXQgJiYKIAkjIHNjcmlwdAotCWdyZXAgLXEgIl5maWx0ZXItYnJhbmNoIFwkIiBvdXQgJiYKKwlncmVwIC1xICJecmViYXNlIFwkIiBvdXQgJiYKIAkjIHBsdW1iaW5nCiAJISBncmVwIC1xICJebHMtZmlsZXMgXCQiIG91dCAmJgogCi0JcnVuX2NvbXBsZXRpb24gImdpdCBmIiAmJgotCSEgZ3JlcCAtcSAtdiAiXmYiIG91dAorCXJ1bl9jb21wbGV0aW9uICJnaXQgciIgJiYKKwkhIGdyZXAgLXEgLXYgIl5yIiBvdXQKICcKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyAnZG91YmxlIGRhc2ggImdpdCIgaXRzZWxmJyAnCkBAIC0xNTQ4LDcgKzE1NDgsMTAgQEAKICcKIAogdGVzdF9leHBlY3Rfc3VjY2VzcyBQRVJMICdzZW5kLWVtYWlsJyAnCi0JdGVzdF9jb21wbGV0aW9uICJnaXQgc2VuZC1lbWFpbCAtLWNvdiIgIi0tY292ZXItbGV0dGVyICIgJiYKKwl0ZXN0X2NvbXBsZXRpb24gImdpdCBzZW5kLWVtYWlsIC0tY292IiA8PC1cRU9GICYmCisJLS1jb3Zlci1mcm9tLWRlc2NyaXB0aW9uPVoKKwktLWNvdmVyLWxldHRlciBaCisJRU9GCiAJdGVzdF9jb21wbGV0aW9uICJnaXQgc2VuZC1lbWFpbCBtYSIgIm1hc3RlciAiCiAnCiAKQEAgLTE2OTgsNiArMTcwMSw2OSBAQAogCScKIGRvbmUKIAordGVzdF9leHBlY3Rfc3VjY2VzcyAnZ2l0IGNvbmZpZyAtIHNlY3Rpb24nICcKKwl0ZXN0X2NvbXBsZXRpb24gImdpdCBjb25maWcgYnIiIDw8LVxFT0YKKwlicmFuY2guWgorCWJyb3dzZXIuWgorCUVPRgorJworCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdnaXQgY29uZmlnIC0gdmFyaWFibGUgbmFtZScgJworCXRlc3RfY29tcGxldGlvbiAiZ2l0IGNvbmZpZyBsb2cuZCIgPDwtXEVPRgorCWxvZy5kYXRlIFoKKwlsb2cuZGVjb3JhdGUgWgorCUVPRgorJworCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdnaXQgY29uZmlnIC0gdmFsdWUnICcKKwl0ZXN0X2NvbXBsZXRpb24gImdpdCBjb25maWcgY29sb3IucGFnZXIgIiA8PC1cRU9GCisJZmFsc2UgWgorCXRydWUgWgorCUVPRgorJworCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdnaXQgLWMgLSBzZWN0aW9uJyAnCisJdGVzdF9jb21wbGV0aW9uICJnaXQgLWMgYnIiIDw8LVxFT0YKKwlicmFuY2guWgorCWJyb3dzZXIuWgorCUVPRgorJworCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdnaXQgLWMgLSB2YXJpYWJsZSBuYW1lJyAnCisJdGVzdF9jb21wbGV0aW9uICJnaXQgLWMgbG9nLmQiIDw8LVxFT0YKKwlsb2cuZGF0ZT1aCisJbG9nLmRlY29yYXRlPVoKKwlFT0YKKycKKwordGVzdF9leHBlY3Rfc3VjY2VzcyAnZ2l0IC1jIC0gdmFsdWUnICcKKwl0ZXN0X2NvbXBsZXRpb24gImdpdCAtYyBjb2xvci5wYWdlcj0iIDw8LVxFT0YKKwlmYWxzZSBaCisJdHJ1ZSBaCisJRU9GCisnCisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2dpdCBjbG9uZSAtLWNvbmZpZz0gLSBzZWN0aW9uJyAnCisJdGVzdF9jb21wbGV0aW9uICJnaXQgY2xvbmUgLS1jb25maWc9YnIiIDw8LVxFT0YKKwlicmFuY2guWgorCWJyb3dzZXIuWgorCUVPRgorJworCit0ZXN0X2V4cGVjdF9zdWNjZXNzICdnaXQgY2xvbmUgLS1jb25maWc9IC0gdmFyaWFibGUgbmFtZScgJworCXRlc3RfY29tcGxldGlvbiAiZ2l0IGNsb25lIC0tY29uZmlnPWxvZy5kIiA8PC1cRU9GCisJbG9nLmRhdGU9WgorCWxvZy5kZWNvcmF0ZT1aCisJRU9GCisnCisKK3Rlc3RfZXhwZWN0X3N1Y2Nlc3MgJ2dpdCBjbG9uZSAtLWNvbmZpZz0gLSB2YWx1ZScgJworCXRlc3RfY29tcGxldGlvbiAiZ2l0IGNsb25lIC0tY29uZmlnPWNvbG9yLnBhZ2VyPSIgPDwtXEVPRgorCWZhbHNlIFoKKwl0cnVlIFoKKwlFT0YKKycKKwogdGVzdF9leHBlY3Rfc3VjY2VzcyAnc291cmNpbmcgdGhlIGNvbXBsZXRpb24gc2NyaXB0IGNsZWFycyBjYWNoZWQgY29tbWFuZHMnICcKIAlfX2dpdF9jb21wdXRlX2FsbF9jb21tYW5kcyAmJgogCXZlcmJvc2UgdGVzdCAtbiAiJF9fZ2l0X2FsbF9jb21tYW5kcyIgJiYKZGlmZiAtLWdpdCBhL3QvdGVzdC1saWItZnVuY3Rpb25zLnNoIGIvdC90ZXN0LWxpYi1mdW5jdGlvbnMuc2gKaW5kZXggZTBiM2YyOC4uZGM3YTA0MSAxMDA2NDQKLS0tIGEvdC90ZXN0LWxpYi1mdW5jdGlvbnMuc2gKKysrIGIvdC90ZXN0LWxpYi1mdW5jdGlvbnMuc2gKQEAgLTIyOCw5ICsyMjgsMTEgQEAKICMgY2FuIGJlIGEgdGFnIHBvaW50aW5nIHRvIHRoZSBjb21taXQtdG8tbWVyZ2UuCiAKIHRlc3RfbWVyZ2UgKCkgeworCWxhYmVsPSIkMSIgJiYKKwlzaGlmdCAmJgogCXRlc3RfdGljayAmJgotCWdpdCBtZXJnZSAtbSAiJDEiICIkMiIgJiYKLQlnaXQgdGFnICIkMSIKKwlnaXQgbWVyZ2UgLW0gIiRsYWJlbCIgIiRAIiAmJgorCWdpdCB0YWcgIiRsYWJlbCIKIH0KIAogIyBFZmZpY2llbnRseSBjcmVhdGUgPG5yPiBjb21taXRzLCBlYWNoIHdpdGggYSB1bmlxdWUgbnVtYmVyIChmcm9tIDEgdG8gPG5yPgpAQCAtNTgwLDcgKzU4Miw3IEBACiAJZXhwb3J0IHRlc3RfcHJlcmVxCiAJaWYgISB0ZXN0X3NraXAgIiRAIgogCXRoZW4KLQkJc2F5ID4mMyAiY2hlY2tpbmcga25vd24gYnJlYWthZ2U6ICQyIgorCQlzYXkgPiYzICJjaGVja2luZyBrbm93biBicmVha2FnZSBvZiAkVEVTVF9OVU1CRVIuJHRlc3RfY291bnQgJyQxJzogJDIiCiAJCWlmIHRlc3RfcnVuXyAiJDIiIGV4cGVjdGluZ19mYWlsdXJlCiAJCXRoZW4KIAkJCXRlc3Rfa25vd25fYnJva2VuX29rXyAiJDEiCkBAIC02MDAsNyArNjAyLDcgQEAKIAlleHBvcnQgdGVzdF9wcmVyZXEKIAlpZiAhIHRlc3Rfc2tpcCAiJEAiCiAJdGhlbgotCQlzYXkgPiYzICJleHBlY3Rpbmcgc3VjY2VzczogJDIiCisJCXNheSA+JjMgImV4cGVjdGluZyBzdWNjZXNzIG9mICRURVNUX05VTUJFUi4kdGVzdF9jb3VudCAnJDEnOiAkMiIKIAkJaWYgdGVzdF9ydW5fICIkMiIKIAkJdGhlbgogCQkJdGVzdF9va18gIiQxIgpAQCAtMTAxMCwxOSArMTAxMiwzMCBAQAogCWZpCiB9CiAKLSMgVGVzdHMgdGhhdCBpdHMgdHdvIHBhcmFtZXRlcnMgcmVmZXIgdG8gdGhlIHNhbWUgcmV2aXNpb24KKyMgVGVzdHMgdGhhdCBpdHMgdHdvIHBhcmFtZXRlcnMgcmVmZXIgdG8gdGhlIHNhbWUgcmV2aXNpb24sIG9yIGlmICchJyBpcworIyBwcm92aWRlZCBmaXJzdCwgdGhhdCBpdHMgb3RoZXIgdHdvIHBhcmFtZXRlcnMgcmVmZXIgdG8gZGlmZmVyZW50CisjIHJldmlzaW9ucy4KIHRlc3RfY21wX3JldiAoKSB7CisJbG9jYWwgb3A9Jz0nIHdyb25nX3Jlc3VsdD1kaWZmZXJlbnQKKworCWlmIHRlc3QgJCMgLWdlIDEgJiYgdGVzdCAieCQxIiA9ICd4IScKKwl0aGVuCisJICAgIG9wPSchPScKKwkgICAgd3JvbmdfcmVzdWx0PSd0aGUgc2FtZScKKwkgICAgc2hpZnQKKwlmaQogCWlmIHRlc3QgJCMgIT0gMgogCXRoZW4KIAkJZXJyb3IgImJ1ZyBpbiB0aGUgdGVzdCBzY3JpcHQ6IHRlc3RfY21wX3JldiByZXF1aXJlcyB0d28gcmV2aXNpb25zLCBidXQgZ290ICQjIgogCWVsc2UKIAkJbG9jYWwgcjEgcjIKIAkJcjE9JChnaXQgcmV2LXBhcnNlIC0tdmVyaWZ5ICIkMSIpICYmCi0JCXIyPSQoZ2l0IHJldi1wYXJzZSAtLXZlcmlmeSAiJDIiKSAmJgotCQlpZiB0ZXN0ICIkcjEiICE9ICIkcjIiCisJCXIyPSQoZ2l0IHJldi1wYXJzZSAtLXZlcmlmeSAiJDIiKSB8fCByZXR1cm4gMQorCisJCWlmICEgdGVzdCAiJHIxIiAiJG9wIiAiJHIyIgogCQl0aGVuCiAJCQljYXQgPiY0IDw8LUVPRgotCQkJZXJyb3I6IHR3byByZXZpc2lvbnMgcG9pbnQgdG8gZGlmZmVyZW50IG9iamVjdHM6CisJCQllcnJvcjogdHdvIHJldmlzaW9ucyBwb2ludCB0byAkd3JvbmdfcmVzdWx0IG9iamVjdHM6CiAJCQkgICckMSc6ICRyMQogCQkJICAnJDInOiAkcjIKIAkJCUVPRgpAQCAtMTE3Myw2ICsxMTg2LDM0IEBACiAJY29tbWFuZCAiJFBFUkxfUEFUSCIgIiRAIiAyPiY3CiB9IDc+JjIgMj4mNAogCisjIEdpdmVuIHRoZSBuYW1lIG9mIGFuIGVudmlyb25tZW50IHZhcmlhYmxlIHdpdGggYSBib29sIHZhbHVlLCBub3JtYWxpemUKKyMgaXRzIHZhbHVlIHRvIGEgMCAodHJ1ZSkgb3IgMSAoZmFsc2Ugb3IgZW1wdHkgc3RyaW5nKSByZXR1cm4gY29kZS4KKyMKKyMgICB0ZXN0X2Jvb2xfZW52IEdJVF9URVNUX0hUVFBEIDxkZWZhdWx0LXZhbHVlPgorIworIyBSZXR1cm4gd2l0aCBjb2RlIGNvcnJlc3BvbmRpbmcgdG8gdGhlIGdpdmVuIGRlZmF1bHQgdmFsdWUgaWYgdGhlIHZhcmlhYmxlCisjIGlzIHVuc2V0LgorIyBBYm9ydCB0aGUgdGVzdCBzY3JpcHQgaWYgZWl0aGVyIHRoZSB2YWx1ZSBvZiB0aGUgdmFyaWFibGUgb3IgdGhlIGRlZmF1bHQKKyMgYXJlIG5vdCB2YWxpZCBib29sIHZhbHVlcy4KKwordGVzdF9ib29sX2VudiAoKSB7CisJaWYgdGVzdCAkIyAhPSAyCisJdGhlbgorCQlCVUcgInRlc3RfYm9vbF9lbnYgcmVxdWlyZXMgdHdvIHBhcmFtZXRlcnMgKHZhcmlhYmxlIG5hbWUgYW5kIGRlZmF1bHQgdmFsdWUpIgorCWZpCisKKwlnaXQgZW52LS1oZWxwZXIgLS10eXBlPWJvb2wgLS1kZWZhdWx0PSIkMiIgLS1leGl0LWNvZGUgIiQxIgorCXJldD0kPworCWNhc2UgJHJldCBpbgorCTB8MSkJIyB1bnNldCBvciB2YWxpZCBib29sIHZhbHVlCisJCTs7CisJKikJIyBpbnZhbGlkIGJvb2wgdmFsdWUgb3Igc29tZXRoaW5nIHVuZXhwZWN0ZWQKKwkJZXJyb3IgPiY3ICJ0ZXN0X2Jvb2xfZW52IHJlcXVpcmVzIGJvb2wgdmFsdWVzIGJvdGggZm9yIFwkJDEgYW5kIGZvciB0aGUgZGVmYXVsdCBmYWxsYmFjayIKKwkJOzsKKwllc2FjCisJcmV0dXJuICRyZXQKK30KKwogIyBFeGl0IHRoZSB0ZXN0IHN1aXRlLCBlaXRoZXIgYnkgc2tpcHBpbmcgYWxsIHJlbWFpbmluZyB0ZXN0cyBvciBieQogIyBleGl0aW5nIHdpdGggYW4gZXJyb3IuIElmIG91ciBwcmVyZXF1aXNpdGUgdmFyaWFibGUgJDEgZmFsbHMgYmFjawogIyBvbiBhIGRlZmF1bHQgYXNzdW1lIHdlIHdlcmUgb3Bwb3J0dW5pc3RpY2FsbHkgdHJ5aW5nIHRvIHNldCB1cCBzb21lCkBAIC0xMTgxLDcgKzEyMjIsNyBAQAogIyBUaGUgZXJyb3Ivc2tpcCBtZXNzYWdlIHNob3VsZCBiZSBnaXZlbiBieSAkMi4KICMKIHRlc3Rfc2tpcF9vcl9kaWUgKCkgewotCWlmICEgZ2l0IGVudi0taGVscGVyIC0tdHlwZT1ib29sIC0tZGVmYXVsdD1mYWxzZSAtLWV4aXQtY29kZSAkMQorCWlmICEgdGVzdF9ib29sX2VudiAiJDEiIGZhbHNlCiAJdGhlbgogCQlza2lwX2FsbD0kMgogCQl0ZXN0X2RvbmUKZGlmZiAtLWdpdCBhL3QvdGVzdC1saWIuc2ggYi90L3Rlc3QtbGliLnNoCmluZGV4IDMwYjA3ZTMuLjVmYmY0ZDIgMTAwNjQ0Ci0tLSBhL3QvdGVzdC1saWIuc2gKKysrIGIvdC90ZXN0LWxpYi5zaApAQCAtMjEyLDYgKzIxMiw4IEBACiAKIFRFU1RfU1RSRVNTX0pPQl9TRlg9IiR7R0lUX1RFU1RfU1RSRVNTX0pPQl9OUjorLnN0cmVzcy0kR0lUX1RFU1RfU1RSRVNTX0pPQl9OUn0iCiBURVNUX05BTUU9IiQoYmFzZW5hbWUgIiQwIiAuc2gpIgorVEVTVF9OVU1CRVI9IiR7VEVTVF9OQU1FJSUtKn0iCitURVNUX05VTUJFUj0iJHtURVNUX05VTUJFUiN0fSIKIFRFU1RfUkVTVUxUU19ESVI9IiRURVNUX09VVFBVVF9ESVJFQ1RPUlkvdGVzdC1yZXN1bHRzIgogVEVTVF9SRVNVTFRTX0JBU0U9IiRURVNUX1JFU1VMVFNfRElSLyRURVNUX05BTUUkVEVTVF9TVFJFU1NfSk9CX1NGWCIKIFRSQVNIX0RJUkVDVE9SWT0idHJhc2ggZGlyZWN0b3J5LiRURVNUX05BTUUkVEVTVF9TVFJFU1NfSk9CX1NGWCIKQEAgLTQwMiw5ICs0MDQsMTMgQEAKIHVuc2V0IFhER19DQUNIRV9IT01FCiB1bnNldCBYREdfQ09ORklHX0hPTUUKIHVuc2V0IEdJVFBFUkxMSUIKLUdJVF9BVVRIT1JfRU1BSUw9YXV0aG9yQGV4YW1wbGUuY29tCitURVNUX0FVVEhPUl9MT0NBTE5BTUU9YXV0aG9yCitURVNUX0FVVEhPUl9ET01BSU49ZXhhbXBsZS5jb20KK0dJVF9BVVRIT1JfRU1BSUw9JHtURVNUX0FVVEhPUl9MT0NBTE5BTUV9QCR7VEVTVF9BVVRIT1JfRE9NQUlOfQogR0lUX0FVVEhPUl9OQU1FPSdBIFUgVGhvcicKLUdJVF9DT01NSVRURVJfRU1BSUw9Y29tbWl0dGVyQGV4YW1wbGUuY29tCitURVNUX0NPTU1JVFRFUl9MT0NBTE5BTUU9Y29tbWl0dGVyCitURVNUX0NPTU1JVFRFUl9ET01BSU49ZXhhbXBsZS5jb20KK0dJVF9DT01NSVRURVJfRU1BSUw9JHtURVNUX0NPTU1JVFRFUl9MT0NBTE5BTUV9QCR7VEVTVF9DT01NSVRURVJfRE9NQUlOfQogR0lUX0NPTU1JVFRFUl9OQU1FPSdDIE8gTWl0dGVyJwogR0lUX01FUkdFX1ZFUkJPU0lUWT01CiBHSVRfTUVSR0VfQVVUT0VESVQ9bm8KQEAgLTUwNyw2ICs1MTMsOSBAQAogTEY9JwogJwogCisjIFNpbmdsZSBxdW90ZQorU1E9XCcKKwogIyBVVEYtOCBaRVJPIFdJRFRIIE5PTi1KT0lORVIsIHdoaWNoIEhGUysgaWdub3JlcwogIyB3aGVuIGNhc2UtZm9sZGluZyBmaWxlbmFtZXMKIHUyMDBjPSQocHJpbnRmICdcMzQyXDIwMFwyMTQnKQpAQCAtNTY3LDYgKzU3Niw3IEBACiAKIGVycm9yICgpIHsKIAlzYXlfY29sb3IgZXJyb3IgImVycm9yOiAkKiIKKwlmaW5hbGl6ZV9qdW5pdF94bWwKIAlHSVRfRVhJVF9PSz10CiAJZXhpdCAxCiB9CkBAIC02OTUsNyArNzA1LDcgQEAKIAlzYXlfY29sb3IgZXJyb3IgIm5vdCBvayAkdGVzdF9jb3VudCAtICQxIgogCXNoaWZ0CiAJcHJpbnRmICclc1xuJyAiJCoiIHwgc2VkIC1lICdzL14vIwkvJwotCXRlc3QgIiRpbW1lZGlhdGUiID0gIiIgfHwgeyBHSVRfRVhJVF9PSz10OyBleGl0IDE7IH0KKwl0ZXN0ICIkaW1tZWRpYXRlIiA9ICIiIHx8IHsgZmluYWxpemVfanVuaXRfeG1sOyBHSVRfRVhJVF9PSz10OyBleGl0IDE7IH0KIH0KIAogdGVzdF9rbm93bl9icm9rZW5fb2tfICgpIHsKQEAgLTk5NCw2ICsxMDA0LDEyIEBACiAJCXRvX3NraXA9dAogCQlza2lwcGVkX3JlYXNvbj0iR0lUX1NLSVBfVEVTVFMiCiAJZmkKKwlpZiB0ZXN0IC16ICIkdG9fc2tpcCIgJiYgdGVzdCAtbiAiJHJ1bl9saXN0IiAmJgorCSAgICEgbWF0Y2hfdGVzdF9zZWxlY3Rvcl9saXN0ICctLXJ1bicgJHRlc3RfY291bnQgIiRydW5fbGlzdCIKKwl0aGVuCisJCXRvX3NraXA9dAorCQlza2lwcGVkX3JlYXNvbj0iLS1ydW4iCisJZmkKIAlpZiB0ZXN0IC16ICIkdG9fc2tpcCIgJiYgdGVzdCAtbiAiJHRlc3RfcHJlcmVxIiAmJgogCSAgICEgdGVzdF9oYXZlX3ByZXJlcSAiJHRlc3RfcHJlcmVxIgogCXRoZW4KQEAgLTEwMDYsMTIgKzEwMjIsNiBAQAogCQlmaQogCQlza2lwcGVkX3JlYXNvbj0ibWlzc2luZyAkbWlzc2luZ19wcmVyZXEke29mX3ByZXJlcX0iCiAJZmkKLQlpZiB0ZXN0IC16ICIkdG9fc2tpcCIgJiYgdGVzdCAtbiAiJHJ1bl9saXN0IiAmJgotCQkhIG1hdGNoX3Rlc3Rfc2VsZWN0b3JfbGlzdCAnLS1ydW4nICR0ZXN0X2NvdW50ICIkcnVuX2xpc3QiCi0JdGhlbgotCQl0b19za2lwPXQKLQkJc2tpcHBlZF9yZWFzb249Ii0tcnVuIgotCWZpCiAKIAljYXNlICIkdG9fc2tpcCIgaW4KIAl0KQpAQCAtMTA2Myw2ICsxMDczLDI1IEBACiAJanVuaXRfaGF2ZV90ZXN0Y2FzZT10CiB9CiAKK2ZpbmFsaXplX2p1bml0X3htbCAoKSB7CisJaWYgdGVzdCAtbiAiJHdyaXRlX2p1bml0X3htbCIgJiYgdGVzdCAtbiAiJGp1bml0X3htbF9wYXRoIgorCXRoZW4KKwkJdGVzdCAtbiAiJGp1bml0X2hhdmVfdGVzdGNhc2UiIHx8IHsKKwkJCWp1bml0X3N0YXJ0PSQodGVzdC10b29sIGRhdGUgZ2V0bmFub3MpCisJCQl3cml0ZV9qdW5pdF94bWxfdGVzdGNhc2UgImFsbCB0ZXN0cyBza2lwcGVkIgorCQl9CisKKwkJIyBhZGp1c3QgdGhlIG92ZXJhbGwgdGltZQorCQlqdW5pdF90aW1lPSQodGVzdC10b29sIGRhdGUgZ2V0bmFub3MgJGp1bml0X3N1aXRlX3N0YXJ0KQorCQlzZWQgInMvPHRlc3RzdWl0ZSBbXj5dKi8mIHRpbWU9XCIkanVuaXRfdGltZVwiLyIgXAorCQkJPCIkanVuaXRfeG1sX3BhdGgiID4iJGp1bml0X3htbF9wYXRoLm5ldyIKKwkJbXYgIiRqdW5pdF94bWxfcGF0aC5uZXciICIkanVuaXRfeG1sX3BhdGgiCisKKwkJd3JpdGVfanVuaXRfeG1sICIgIDwvdGVzdHN1aXRlPiIgIjwvdGVzdHN1aXRlcz4iCisJCXdyaXRlX2p1bml0X3htbD0KKwlmaQorfQorCiB0ZXN0X2F0ZXhpdF9jbGVhbnVwPToKIHRlc3RfYXRleGl0X2hhbmRsZXIgKCkgewogCSMgSW4gYSBzdWNjZWVkaW5nIHRlc3Qgc2NyaXB0ICd0ZXN0X2F0ZXhpdF9oYW5kbGVyJyBpcyBpbnZva2VkCkBAIC0xMDg1LDIxICsxMTE0LDcgQEAKIAkjIHJlbW92ZWQsIHNvIHRoZSBjb21tYW5kcyBjYW4gYWNjZXNzIHBpZGZpbGVzIGFuZCBzb2NrZXQgZmlsZXMuCiAJdGVzdF9hdGV4aXRfaGFuZGxlcgogCi0JaWYgdGVzdCAtbiAiJHdyaXRlX2p1bml0X3htbCIgJiYgdGVzdCAtbiAiJGp1bml0X3htbF9wYXRoIgotCXRoZW4KLQkJdGVzdCAtbiAiJGp1bml0X2hhdmVfdGVzdGNhc2UiIHx8IHsKLQkJCWp1bml0X3N0YXJ0PSQodGVzdC10b29sIGRhdGUgZ2V0bmFub3MpCi0JCQl3cml0ZV9qdW5pdF94bWxfdGVzdGNhc2UgImFsbCB0ZXN0cyBza2lwcGVkIgotCQl9Ci0KLQkJIyBhZGp1c3QgdGhlIG92ZXJhbGwgdGltZQotCQlqdW5pdF90aW1lPSQodGVzdC10b29sIGRhdGUgZ2V0bmFub3MgJGp1bml0X3N1aXRlX3N0YXJ0KQotCQlzZWQgInMvPHRlc3RzdWl0ZSBbXj5dKi8mIHRpbWU9XCIkanVuaXRfdGltZVwiLyIgXAotCQkJPCIkanVuaXRfeG1sX3BhdGgiID4iJGp1bml0X3htbF9wYXRoLm5ldyIKLQkJbXYgIiRqdW5pdF94bWxfcGF0aC5uZXciICIkanVuaXRfeG1sX3BhdGgiCi0KLQkJd3JpdGVfanVuaXRfeG1sICIgIDwvdGVzdHN1aXRlPiIgIjwvdGVzdHN1aXRlcz4iCi0JZmkKKwlmaW5hbGl6ZV9qdW5pdF94bWwKIAogCWlmIHRlc3QgLXogIiRIQVJORVNTX0FDVElWRSIKIAl0aGVuCkBAIC0xMzkxLDE5ICsxNDA2LDE5IEBACiAjIFRoZSBHSVRfVEVTVF9GQUlMX1BSRVJFUVMgY29kZSBob29rcyBpbnRvIHRlc3Rfc2V0X3ByZXJlcSgpLCBhbmQKICMgdGh1cyBuZWVkcyB0byBiZSBzZXQgdXAgcmVhbGx5IGVhcmx5LCBhbmQgc2V0IGFuIGludGVybmFsIHZhcmlhYmxlCiAjIGZvciBjb252ZW5pZW5jZSBzbyB0aGUgaG90IHRlc3Rfc2V0X3ByZXJlcSgpIGNvZGVwYXRoIGRvZXNuJ3QgbmVlZAotIyB0byBjYWxsICJnaXQgZW52LS1oZWxwZXIiLiBPbmx5IGRvIHRoYXQgd29yayBpZiBuZWVkZWQgYnkgc2VlaW5nIGlmCi0jIEdJVF9URVNUX0ZBSUxfUFJFUkVRUyBpcyBzZXQgYXQgYWxsLgorIyB0byBjYWxsICJnaXQgZW52LS1oZWxwZXIiICh2aWEgdGVzdF9ib29sX2VudikuIE9ubHkgZG8gdGhhdCB3b3JrCisjIGlmIG5lZWRlZCBieSBzZWVpbmcgaWYgR0lUX1RFU1RfRkFJTF9QUkVSRVFTIGlzIHNldCBhdCBhbGwuCiBHSVRfVEVTVF9GQUlMX1BSRVJFUVNfSU5URVJOQUw9CiBpZiB0ZXN0IC1uICIkR0lUX1RFU1RfRkFJTF9QUkVSRVFTIgogdGhlbgotCWlmIGdpdCBlbnYtLWhlbHBlciAtLXR5cGU9Ym9vbCAtLWRlZmF1bHQ9MCAtLWV4aXQtY29kZSBHSVRfVEVTVF9GQUlMX1BSRVJFUVMKKwlpZiB0ZXN0X2Jvb2xfZW52IEdJVF9URVNUX0ZBSUxfUFJFUkVRUyBmYWxzZQogCXRoZW4KIAkJR0lUX1RFU1RfRkFJTF9QUkVSRVFTX0lOVEVSTkFMPXRydWUKIAkJdGVzdF9zZXRfcHJlcmVxIEZBSUxfUFJFUkVRUwogCWZpCiBlbHNlCiAJdGVzdF9sYXp5X3ByZXJlcSBGQUlMX1BSRVJFUVMgJwotCQlnaXQgZW52LS1oZWxwZXIgLS10eXBlPWJvb2wgLS1kZWZhdWx0PTAgLS1leGl0LWNvZGUgR0lUX1RFU1RfRkFJTF9QUkVSRVFTCisJCXRlc3RfYm9vbF9lbnYgR0lUX1RFU1RfRkFJTF9QUkVSRVFTIGZhbHNlCiAJJwogZmkKIApAQCAtMTQ2Miw3ICsxNDc3LDcgQEAKIGZpCiAKIHRlc3RfbGF6eV9wcmVyZXEgQ19MT0NBTEVfT1VUUFVUICcKLQkhIGdpdCBlbnYtLWhlbHBlciAtLXR5cGU9Ym9vbCAtLWRlZmF1bHQ9MCAtLWV4aXQtY29kZSBHSVRfVEVTVF9HRVRURVhUX1BPSVNPTgorCSEgdGVzdF9ib29sX2VudiBHSVRfVEVTVF9HRVRURVhUX1BPSVNPTiBmYWxzZQogJwogCiBpZiB0ZXN0IC16ICIkR0lUX1RFU1RfQ0hFQ0tfQ0FDSEVfVFJFRSIKZGlmZiAtLWdpdCBhL3RhZy5jIGIvdGFnLmMKaW5kZXggNWRiODcwZS4uNzFiNTQ0NCAxMDA2NDQKLS0tIGEvdGFnLmMKKysrIGIvdGFnLmMKQEAgLTE0MSw3ICsxNDEsMTYgQEAKIAogCWlmIChpdGVtLT5vYmplY3QucGFyc2VkKQogCQlyZXR1cm4gMDsKLQlpdGVtLT5vYmplY3QucGFyc2VkID0gMTsKKworCWlmIChpdGVtLT50YWcpIHsKKwkJLyoKKwkJICogUHJlc3VtYWJseSBsZWZ0IG92ZXIgZnJvbSBhIHByZXZpb3VzIGZhaWxlZCBwYXJzZTsKKwkJICogY2xlYXIgaXQgb3V0IGluIHByZXBhcmF0aW9uIGZvciByZS1wYXJzaW5nICh3ZSdsbCBwcm9iYWJseQorCQkgKiBoaXQgdGhlIHNhbWUgZXJyb3IsIHdoaWNoIGxldHMgdXMgdGVsbCBvdXIgY3VycmVudCBjYWxsZXIKKwkJICogYWJvdXQgdGhlIHByb2JsZW0pLgorCQkgKi8KKwkJRlJFRV9BTkRfTlVMTChpdGVtLT50YWcpOworCX0KIAogCWlmIChzaXplIDwgdGhlX2hhc2hfYWxnby0+aGV4c3ogKyAyNCkKIAkJcmV0dXJuIC0xOwpAQCAtMTY3LDEwICsxNzYsMTUgQEAKIAl9IGVsc2UgaWYgKCFzdHJjbXAodHlwZSwgdGFnX3R5cGUpKSB7CiAJCWl0ZW0tPnRhZ2dlZCA9IChzdHJ1Y3Qgb2JqZWN0ICopbG9va3VwX3RhZyhyLCAmb2lkKTsKIAl9IGVsc2UgewotCQllcnJvcigiVW5rbm93biB0eXBlICVzIiwgdHlwZSk7Ci0JCWl0ZW0tPnRhZ2dlZCA9IE5VTEw7CisJCXJldHVybiBlcnJvcigidW5rbm93biB0YWcgdHlwZSAnJXMnIGluICVzIiwKKwkJCSAgICAgdHlwZSwgb2lkX3RvX2hleCgmaXRlbS0+b2JqZWN0Lm9pZCkpOwogCX0KIAorCWlmICghaXRlbS0+dGFnZ2VkKQorCQlyZXR1cm4gZXJyb3IoImJhZCB0YWcgcG9pbnRlciB0byAlcyBpbiAlcyIsCisJCQkgICAgIG9pZF90b19oZXgoJm9pZCksCisJCQkgICAgIG9pZF90b19oZXgoJml0ZW0tPm9iamVjdC5vaWQpKTsKKwogCWlmIChidWZwdHIgKyA0IDwgdGFpbCAmJiBzdGFydHNfd2l0aChidWZwdHIsICJ0YWcgIikpCiAJCTsgCQkvKiBnb29kICovCiAJZWxzZQpAQCAtMTg3LDYgKzIwMSw3IEBACiAJZWxzZQogCQlpdGVtLT5kYXRlID0gMDsKIAorCWl0ZW0tPm9iamVjdC5wYXJzZWQgPSAxOwogCXJldHVybiAwOwogfQogCkBAIC0yMTIsMyArMjI3LDEwIEBACiAJZnJlZShkYXRhKTsKIAlyZXR1cm4gcmV0OwogfQorCitzdHJ1Y3Qgb2JqZWN0X2lkICpnZXRfdGFnZ2VkX29pZChzdHJ1Y3QgdGFnICp0YWcpCit7CisJaWYgKCF0YWctPnRhZ2dlZCkKKwkJZGllKCJiYWQgdGFnIik7CisJcmV0dXJuICZ0YWctPnRhZ2dlZC0+b2lkOworfQpkaWZmIC0tZ2l0IGEvdGFnLmggYi90YWcuaAppbmRleCAwMzI2NWZiLi4zY2U4ZTcyIDEwMDY0NAotLS0gYS90YWcuaAorKysgYi90YWcuaApAQCAtMTksNSArMTksNiBAQAogc3RydWN0IG9iamVjdCAqZGVyZWZfdGFnX25vdmVyaWZ5KHN0cnVjdCBvYmplY3QgKik7CiBpbnQgZ3BnX3ZlcmlmeV90YWcoY29uc3Qgc3RydWN0IG9iamVjdF9pZCAqb2lkLAogCQkgICBjb25zdCBjaGFyICpuYW1lX3RvX3JlcG9ydCwgdW5zaWduZWQgZmxhZ3MpOworc3RydWN0IG9iamVjdF9pZCAqZ2V0X3RhZ2dlZF9vaWQoc3RydWN0IHRhZyAqdGFnKTsKIAogI2VuZGlmIC8qIFRBR19IICovCmRpZmYgLS1naXQgYS90YXIuaCBiL3Rhci5oCmluZGV4IDM0Njc3MDUuLjZiMjU4YzQgMTAwNjQ0Ci0tLSBhL3Rhci5oCisrKyBiL3Rhci5oCkBAIC0xLDMgKzEsNiBAQAorI2lmbmRlZiBUQVJfSAorI2RlZmluZSBUQVJfSAorCiAjZGVmaW5lIFRZUEVGTEFHX0FVVE8JCSdcMCcKICNkZWZpbmUgVFlQRUZMQUdfUkVHCQknMCcKICNkZWZpbmUgVFlQRUZMQUdfTE5LCQknMicKQEAgLTIzLDMgKzI2LDUgQEAKIAljaGFyIGRldm1pbm9yWzhdOwkvKiAzMzcgKi8KIAljaGFyIHByZWZpeFsxNTVdOwkvKiAzNDUgKi8KIH07CisKKyNlbmRpZiAvKiBUQVJfSCAqLwpkaWZmIC0tZ2l0IGEvdGVtcGxhdGVzL2hvb2tzLS1mc21vbml0b3Itd2F0Y2htYW4uc2FtcGxlIGIvdGVtcGxhdGVzL2hvb2tzLS1mc21vbml0b3Itd2F0Y2htYW4uc2FtcGxlCmluZGV4IGU2NzNiYjMuLmVmOTRmYTIgMTAwNzU1Ci0tLSBhL3RlbXBsYXRlcy9ob29rcy0tZnNtb25pdG9yLXdhdGNobWFuLnNhbXBsZQorKysgYi90ZW1wbGF0ZXMvaG9va3MtLWZzbW9uaXRvci13YXRjaG1hbi5zYW1wbGUKQEAgLTIyLDcgKzIyLDggQEAKIAogaWYgKCR2ZXJzaW9uID09IDEpIHsKIAkjIGNvbnZlcnQgbmFub3NlY29uZHMgdG8gc2Vjb25kcwotCSR0aW1lID0gaW50ICR0aW1lIC8gMTAwMDAwMDAwMDsKKwkjIHN1YnRyYWN0IG9uZSBzZWNvbmQgdG8gbWFrZSBzdXJlIHdhdGNobWFuIHdpbGwgcmV0dXJuIGFsbCBjaGFuZ2VzCisJJHRpbWUgPSBpbnQgKCR0aW1lIC8gMTAwMDAwMDAwMCkgLSAxOwogfSBlbHNlIHsKIAlkaWUgIlVuc3VwcG9ydGVkIHF1ZXJ5LWZzbW9uaXRvciBob29rIHZlcnNpb24gJyR2ZXJzaW9uJy5cbiIgLgogCSAgICAiRmFsbGluZyBiYWNrIHRvIHNjYW5uaW5nLi4uXG4iOwpAQCAtNTMsMTggKzU0LDEyIEBACiAJIwogCSMgVG8gYWNjb21wbGlzaCB0aGlzLCB3ZSdyZSB1c2luZyB0aGUgInNpbmNlIiBnZW5lcmF0b3IgdG8gdXNlIHRoZQogCSMgcmVjZW5jeSBpbmRleCB0byBzZWxlY3QgY2FuZGlkYXRlIG5vZGVzIGFuZCAiZmllbGRzIiB0byBsaW1pdCB0aGUKLQkjIG91dHB1dCB0byBmaWxlIG5hbWVzIG9ubHkuIFRoZW4gd2UncmUgdXNpbmcgdGhlICJleHByZXNzaW9uIiB0ZXJtIHRvCi0JIyBmdXJ0aGVyIGNvbnN0cmFpbiB0aGUgcmVzdWx0cy4KLQkjCi0JIyBUaGUgY2F0ZWdvcnkgb2YgdHJhbnNpZW50IGZpbGVzIHRoYXQgd2Ugd2FudCB0byBpZ25vcmUgd2lsbCBoYXZlIGEKLQkjIGNyZWF0aW9uIGNsb2NrIChjY2xvY2spIG5ld2VyIHRoYW4gJHRpbWVfdCB2YWx1ZSBhbmQgd2lsbCBhbHNvIG5vdAotCSMgY3VycmVudGx5IGV4aXN0LgorCSMgb3V0cHV0IHRvIGZpbGUgbmFtZXMgb25seS4KIAogCW15ICRxdWVyeSA9IDw8IglFTkQiOwogCQlbInF1ZXJ5IiwgIiRnaXRfd29ya190cmVlIiwgewogCQkJInNpbmNlIjogJHRpbWUsCi0JCQkiZmllbGRzIjogWyJuYW1lIl0sCi0JCQkiZXhwcmVzc2lvbiI6IFsibm90IiwgWyJhbGxvZiIsIFsic2luY2UiLCAkdGltZSwgImNjbG9jayJdLCBbIm5vdCIsICJleGlzdHMiXV1dCisJCQkiZmllbGRzIjogWyJuYW1lIl0KIAkJfV0KIAlFTkQKIApkaWZmIC0tZ2l0IGEvdGVtcGxhdGVzL2hvb2tzLS1wcmUtbWVyZ2UtY29tbWl0LnNhbXBsZSBiL3RlbXBsYXRlcy9ob29rcy0tcHJlLW1lcmdlLWNvbW1pdC5zYW1wbGUKbmV3IGZpbGUgbW9kZSAxMDA3NTUKaW5kZXggMDAwMDAwMC4uMzk5ZWFiMQotLS0gL2Rldi9udWxsCisrKyBiL3RlbXBsYXRlcy9ob29rcy0tcHJlLW1lcmdlLWNvbW1pdC5zYW1wbGUKQEAgLTAsMCArMSwxMyBAQAorIyEvYmluL3NoCisjCisjIEFuIGV4YW1wbGUgaG9vayBzY3JpcHQgdG8gdmVyaWZ5IHdoYXQgaXMgYWJvdXQgdG8gYmUgY29tbWl0dGVkLgorIyBDYWxsZWQgYnkgImdpdCBtZXJnZSIgd2l0aCBubyBhcmd1bWVudHMuICBUaGUgaG9vayBzaG91bGQKKyMgZXhpdCB3aXRoIG5vbi16ZXJvIHN0YXR1cyBhZnRlciBpc3N1aW5nIGFuIGFwcHJvcHJpYXRlIG1lc3NhZ2UgdG8KKyMgc3RkZXJyIGlmIGl0IHdhbnRzIHRvIHN0b3AgdGhlIG1lcmdlIGNvbW1pdC4KKyMKKyMgVG8gZW5hYmxlIHRoaXMgaG9vaywgcmVuYW1lIHRoaXMgZmlsZSB0byAicHJlLW1lcmdlLWNvbW1pdCIuCisKKy4gZ2l0LXNoLXNldHVwCit0ZXN0IC14ICIkR0lUX0RJUi9ob29rcy9wcmUtY29tbWl0IiAmJgorICAgICAgICBleGVjICIkR0lUX0RJUi9ob29rcy9wcmUtY29tbWl0IgorOgpkaWZmIC0tZ2l0IGEvdHJhY2UuYyBiL3RyYWNlLmMKaW5kZXggZmE0YTJlNy4uYjNlZjBlNiAxMDA2NDQKLS0tIGEvdHJhY2UuYworKysgYi90cmFjZS5jCkBAIC04OCw4ICs4OCw2IEBACiAJaWYgKCF0cmFjZV93YW50KGtleSkpCiAJCXJldHVybiAwOwogCi0Jc2V0X3RyeV90b19mcmVlX3JvdXRpbmUoTlVMTCk7CS8qIGlzIG5ldmVyIHJlc2V0ICovCi0KIAkvKiB1bml0IHRlc3RzIG1heSB3YW50IHRvIGRpc2FibGUgYWRkaXRpb25hbCB0cmFjZSBvdXRwdXQgKi8KIAlpZiAodHJhY2Vfd2FudCgmdHJhY2VfYmFyZSkpCiAJCXJldHVybiAxOwpkaWZmIC0tZ2l0IGEvdHJhY2UyL3RyMl9kc3QuYyBiL3RyYWNlMi90cjJfZHN0LmMKaW5kZXggNWRkYTBjYS4uYWUwNTJhMCAxMDA2NDQKLS0tIGEvdHJhY2UyL3RyMl9kc3QuYworKysgYi90cmFjZTIvdHIyX2RzdC5jCkBAIC04LDYgKzgsMTkgQEAKICAqLwogI2RlZmluZSBNQVhfQVVUT19BVFRFTVBUUyAxMAogCisvKgorICogU2VudGluZWwgZmlsZSB1c2VkIHRvIGRldGVjdCB3aGVuIHdlIHNob3VsZCBkaXNjYXJkIG5ldyB0cmFjZXMgdG8gYXZvaWQKKyAqIHdyaXRpbmcgdG9vIG1hbnkgdHJhY2UgZmlsZXMgdG8gYSBkaXJlY3RvcnkuCisgKi8KKyNkZWZpbmUgRElTQ0FSRF9TRU5USU5FTF9OQU1FICJnaXQtdHJhY2UyLWRpc2NhcmQiCisKKy8qCisgKiBXaGVuIHNldCB0byB6ZXJvLCBkaXNhYmxlcyBkaXJlY3RvcnkgZmlsZSBjb3VudCBjaGVja3MuIE90aGVyd2lzZSwgY29udHJvbHMKKyAqIGhvdyBtYW55IGZpbGVzIHdlIGNhbiB3cml0ZSB0byBhIGRpcmVjdG9yeSBiZWZvcmUgZW50ZXJpbmcgZGlzY2FyZCBtb2RlLgorICogVGhpcyBjYW4gYmUgb3ZlcnJpZGRlbiB2aWEgdGhlIFRSMl9TWVNFTlZfTUFYX0ZJTEVTIHNldHRpbmcuCisgKi8KK3N0YXRpYyBpbnQgdHIyZW52X21heF9maWxlcyA9IDA7CisKIHN0YXRpYyBpbnQgdHIyX2RzdF93YW50X3dhcm5pbmcodm9pZCkKIHsKIAlzdGF0aWMgaW50IHRyMmVudl9kc3RfZGVidWcgPSAtMTsKQEAgLTMyLDkgKzQ1LDc1IEBACiAJZHN0LT5uZWVkX2Nsb3NlID0gMDsKIH0KIAorLyoKKyAqIENoZWNrIHRvIG1ha2Ugc3VyZSB3ZSdyZSBub3Qgb3ZlcmxvYWRpbmcgdGhlIHRhcmdldCBkaXJlY3Rvcnkgd2l0aCB0b28gbWFueQorICogZmlsZXMuIEZpcnN0IGdldCB0aGUgdGhyZXNob2xkIChpZiBwcmVzZW50KSBmcm9tIHRoZSBjb25maWcgb3IgZW52dmFyLiBJZgorICogaXQncyB6ZXJvIG9yIHVuc2V0LCBkaXNhYmxlIHRoaXMgY2hlY2suIE5leHQgY2hlY2sgZm9yIHRoZSBwcmVzZW5jZSBvZiBhCisgKiBzZW50aW5lbCBmaWxlLCB0aGVuIGNoZWNrIGZpbGUgY291bnQuCisgKgorICogUmV0dXJucyAwIGlmIHRyYWNpbmcgc2hvdWxkIHByb2NlZWQgYXMgbm9ybWFsLiBSZXR1cm5zIDEgaWYgdGhlIHNlbnRpbmVsIGZpbGUKKyAqIGFscmVhZHkgZXhpc3RzLCB3aGljaCBtZWFucyB0cmFjaW5nIHNob3VsZCBiZSBkaXNhYmxlZC4gUmV0dXJucyAtMSBpZiB0aGVyZQorICogYXJlIHRvbyBtYW55IGZpbGVzIGJ1dCB0aGVyZSB3YXMgbm8gc2VudGluZWwgZmlsZSwgd2hpY2ggbWVhbnMgd2UgaGF2ZQorICogY3JlYXRlZCBhbmQgc2hvdWxkIHdyaXRlIHRyYWNlcyB0byB0aGUgc2VudGluZWwgZmlsZS4KKyAqCisgKiBXZSBleHBlY3QgdGhhdCBzb21lIHRyYWNlIHByb2Nlc3Npbmcgc3lzdGVtIGlzIGdyYWR1YWxseSBjb2xsZWN0aW5nIGZpbGVzCisgKiBmcm9tIHRoZSB0YXJnZXQgZGlyZWN0b3J5OyBhZnRlciBpdCByZW1vdmVzIHRoZSBzZW50aW5lbCBmaWxlIHdlJ2xsIHN0YXJ0CisgKiB3cml0aW5nIHRyYWNlcyBhZ2Fpbi4KKyAqLworc3RhdGljIGludCB0cjJfZHN0X3Rvb19tYW55X2ZpbGVzKHN0cnVjdCB0cjJfZHN0ICpkc3QsIGNvbnN0IGNoYXIgKnRndF9wcmVmaXgpCit7CisJaW50IGZpbGVfY291bnQgPSAwLCBtYXhfZmlsZXMgPSAwLCByZXQgPSAwOworCWNvbnN0IGNoYXIgKm1heF9maWxlc192YXI7CisJRElSICpkaXJwOworCXN0cnVjdCBzdHJidWYgcGF0aCA9IFNUUkJVRl9JTklULCBzZW50aW5lbF9wYXRoID0gU1RSQlVGX0lOSVQ7CisJc3RydWN0IHN0YXQgc3RhdGJ1ZjsKKworCS8qIEdldCB0aGUgY29uZmlnIG9yIGVudnZhciBhbmQgZGVjaWRlIGlmIHdlIHNob3VsZCBjb250aW51ZSB0aGlzIGNoZWNrICovCisJbWF4X2ZpbGVzX3ZhciA9IHRyMl9zeXNlbnZfZ2V0KFRSMl9TWVNFTlZfTUFYX0ZJTEVTKTsKKwlpZiAobWF4X2ZpbGVzX3ZhciAmJiAqbWF4X2ZpbGVzX3ZhciAmJiAoKG1heF9maWxlcyA9IGF0b2kobWF4X2ZpbGVzX3ZhcikpID49IDApKQorCQl0cjJlbnZfbWF4X2ZpbGVzID0gbWF4X2ZpbGVzOworCisJaWYgKCF0cjJlbnZfbWF4X2ZpbGVzKSB7CisJCXJldCA9IDA7CisJCWdvdG8gY2xlYW51cDsKKwl9CisKKwlzdHJidWZfYWRkc3RyKCZwYXRoLCB0Z3RfcHJlZml4KTsKKwlpZiAoIWlzX2Rpcl9zZXAocGF0aC5idWZbcGF0aC5sZW4gLSAxXSkpIHsKKwkJc3RyYnVmX2FkZGNoKCZwYXRoLCAnLycpOworCX0KKworCS8qIGNoZWNrIHNlbnRpbmVsICovCisJc3RyYnVmX2FkZGJ1Zigmc2VudGluZWxfcGF0aCwgJnBhdGgpOworCXN0cmJ1Zl9hZGRzdHIoJnNlbnRpbmVsX3BhdGgsIERJU0NBUkRfU0VOVElORUxfTkFNRSk7CisJaWYgKCFzdGF0KHNlbnRpbmVsX3BhdGguYnVmLCAmc3RhdGJ1ZikpIHsKKwkJcmV0ID0gMTsKKwkJZ290byBjbGVhbnVwOworCX0KKworCS8qIGNoZWNrIGZpbGUgY291bnQgKi8KKwlkaXJwID0gb3BlbmRpcihwYXRoLmJ1Zik7CisJd2hpbGUgKGZpbGVfY291bnQgPCB0cjJlbnZfbWF4X2ZpbGVzICYmIGRpcnAgJiYgcmVhZGRpcihkaXJwKSkKKwkJZmlsZV9jb3VudCsrOworCWlmIChkaXJwKQorCQljbG9zZWRpcihkaXJwKTsKKworCWlmIChmaWxlX2NvdW50ID49IHRyMmVudl9tYXhfZmlsZXMpIHsKKwkJZHN0LT50b29fbWFueV9maWxlcyA9IDE7CisJCWRzdC0+ZmQgPSBvcGVuKHNlbnRpbmVsX3BhdGguYnVmLCBPX1dST05MWSB8IE9fQ1JFQVQgfCBPX0VYQ0wsIDA2NjYpOworCQlyZXQgPSAtMTsKKwkJZ290byBjbGVhbnVwOworCX0KKworY2xlYW51cDoKKwlzdHJidWZfcmVsZWFzZSgmcGF0aCk7CisJc3RyYnVmX3JlbGVhc2UoJnNlbnRpbmVsX3BhdGgpOworCXJldHVybiByZXQ7Cit9CisKIHN0YXRpYyBpbnQgdHIyX2RzdF90cnlfYXV0b19wYXRoKHN0cnVjdCB0cjJfZHN0ICpkc3QsIGNvbnN0IGNoYXIgKnRndF9wcmVmaXgpCiB7Ci0JaW50IGZkOworCWludCB0b29fbWFueV9maWxlczsKIAljb25zdCBjaGFyICpsYXN0X3NsYXNoLCAqc2lkID0gdHIyX3NpZF9nZXQoKTsKIAlzdHJ1Y3Qgc3RyYnVmIHBhdGggPSBTVFJCVUZfSU5JVDsKIAlzaXplX3QgYmFzZV9wYXRoX2xlbjsKQEAgLTUwLDE4ICsxMjksMjkgQEAKIAlzdHJidWZfYWRkc3RyKCZwYXRoLCBzaWQpOwogCWJhc2VfcGF0aF9sZW4gPSBwYXRoLmxlbjsKIAotCWZvciAoYXR0ZW1wdF9jb3VudCA9IDA7IGF0dGVtcHRfY291bnQgPCBNQVhfQVVUT19BVFRFTVBUUzsgYXR0ZW1wdF9jb3VudCsrKSB7Ci0JCWlmIChhdHRlbXB0X2NvdW50ID4gMCkgewotCQkJc3RyYnVmX3NldGxlbigmcGF0aCwgYmFzZV9wYXRoX2xlbik7Ci0JCQlzdHJidWZfYWRkZigmcGF0aCwgIi4lZCIsIGF0dGVtcHRfY291bnQpOwotCQl9CisJdG9vX21hbnlfZmlsZXMgPSB0cjJfZHN0X3Rvb19tYW55X2ZpbGVzKGRzdCwgdGd0X3ByZWZpeCk7CisJaWYgKCF0b29fbWFueV9maWxlcykgeworCQlmb3IgKGF0dGVtcHRfY291bnQgPSAwOyBhdHRlbXB0X2NvdW50IDwgTUFYX0FVVE9fQVRURU1QVFM7IGF0dGVtcHRfY291bnQrKykgeworCQkJaWYgKGF0dGVtcHRfY291bnQgPiAwKSB7CisJCQkJc3RyYnVmX3NldGxlbigmcGF0aCwgYmFzZV9wYXRoX2xlbik7CisJCQkJc3RyYnVmX2FkZGYoJnBhdGgsICIuJWQiLCBhdHRlbXB0X2NvdW50KTsKKwkJCX0KIAotCQlmZCA9IG9wZW4ocGF0aC5idWYsIE9fV1JPTkxZIHwgT19DUkVBVCB8IE9fRVhDTCwgMDY2Nik7Ci0JCWlmIChmZCAhPSAtMSkKLQkJCWJyZWFrOworCQkJZHN0LT5mZCA9IG9wZW4ocGF0aC5idWYsIE9fV1JPTkxZIHwgT19DUkVBVCB8IE9fRVhDTCwgMDY2Nik7CisJCQlpZiAoZHN0LT5mZCAhPSAtMSkKKwkJCQlicmVhazsKKwkJfQorCX0gZWxzZSBpZiAodG9vX21hbnlfZmlsZXMgPT0gMSkgeworCQlzdHJidWZfcmVsZWFzZSgmcGF0aCk7CisJCWlmICh0cjJfZHN0X3dhbnRfd2FybmluZygpKQorCQkJd2FybmluZygidHJhY2UyOiBub3Qgb3BlbmluZyAlcyB0cmFjZSBmaWxlIGR1ZSB0byB0b28gIgorCQkJCSJtYW55IGZpbGVzIGluIHRhcmdldCBkaXJlY3RvcnkgJXMiLAorCQkJCXRyMl9zeXNlbnZfZGlzcGxheV9uYW1lKGRzdC0+c3lzZW52X3ZhciksCisJCQkJdGd0X3ByZWZpeCk7CisJCXJldHVybiAwOwogCX0KIAotCWlmIChmZCA9PSAtMSkgeworCWlmIChkc3QtPmZkID09IC0xKSB7CiAJCWlmICh0cjJfZHN0X3dhbnRfd2FybmluZygpKQogCQkJd2FybmluZygidHJhY2UyOiBjb3VsZCBub3Qgb3BlbiAnJS4qcycgZm9yICclcycgdHJhY2luZzogJXMiLAogCQkJCShpbnQpIGJhc2VfcGF0aF9sZW4sIHBhdGguYnVmLApAQCAtNzUsNyArMTY1LDYgQEAKIAogCXN0cmJ1Zl9yZWxlYXNlKCZwYXRoKTsKIAotCWRzdC0+ZmQgPSBmZDsKIAlkc3QtPm5lZWRfY2xvc2UgPSAxOwogCWRzdC0+aW5pdGlhbGl6ZWQgPSAxOwogCkBAIC0yMTUsMTMgKzMwNCw4IEBACiBzdGF0aWMgdm9pZCB0cjJfZHN0X21hbGZvcm1lZF93YXJuaW5nKHN0cnVjdCB0cjJfZHN0ICpkc3QsCiAJCQkJICAgICAgY29uc3QgY2hhciAqdGd0X3ZhbHVlKQogewotCXN0cnVjdCBzdHJidWYgYnVmID0gU1RSQlVGX0lOSVQ7Ci0KLQlzdHJidWZfYWRkZigmYnVmLCAidHJhY2UyOiB1bmtub3duIHZhbHVlIGZvciAnJXMnOiAnJXMnIiwKLQkJICAgIHRyMl9zeXNlbnZfZGlzcGxheV9uYW1lKGRzdC0+c3lzZW52X3ZhciksIHRndF92YWx1ZSk7Ci0Jd2FybmluZygiJXMiLCBidWYuYnVmKTsKLQotCXN0cmJ1Zl9yZWxlYXNlKCZidWYpOworCXdhcm5pbmcoInRyYWNlMjogdW5rbm93biB2YWx1ZSBmb3IgJyVzJzogJyVzJyIsCisJCXRyMl9zeXNlbnZfZGlzcGxheV9uYW1lKGRzdC0+c3lzZW52X3ZhciksIHRndF92YWx1ZSk7CiB9CiAKIGludCB0cjJfZHN0X2dldF90cmFjZV9mZChzdHJ1Y3QgdHIyX2RzdCAqZHN0KQpkaWZmIC0tZ2l0IGEvdHJhY2UyL3RyMl9kc3QuaCBiL3RyYWNlMi90cjJfZHN0LmgKaW5kZXggM2FkZjNiYS4uYjFhOGMxNCAxMDA2NDQKLS0tIGEvdHJhY2UyL3RyMl9kc3QuaAorKysgYi90cmFjZTIvdHIyX2RzdC5oCkBAIC05LDYgKzksNyBAQAogCWludCBmZDsKIAl1bnNpZ25lZCBpbnQgaW5pdGlhbGl6ZWQgOiAxOwogCXVuc2lnbmVkIGludCBuZWVkX2Nsb3NlIDogMTsKKwl1bnNpZ25lZCBpbnQgdG9vX21hbnlfZmlsZXMgOiAxOwogfTsKIAogLyoKZGlmZiAtLWdpdCBhL3RyYWNlMi90cjJfc2lkLmMgYi90cmFjZTIvdHIyX3NpZC5jCmluZGV4IDY5NDhmZDQuLmRjNmU3NWUgMTAwNjQ0Ci0tLSBhL3RyYWNlMi90cjJfc2lkLmMKKysrIGIvdHJhY2UyL3RyMl9zaWQuYwpAQCAtMTksNyArMTksNyBAQAogICogICAgIkg8Zmlyc3RfOF9jaGFyc19vZl9zaGExX29mX2hvc3RuYW1lPiIKICAqICAgICJMb2NhbGhvc3QiIHdoZW4gbm8gaG9zdG5hbWUuCiAgKgotICogd2hlcmUgPHByb2Nlc3M+IGlzIGEgOSBjaGFyYWN0ZXIgc3RyaW5nIGNvbnRhaW5pbmcgdGhlIGxlYXN0IHNpZ25pZmNhbnQKKyAqIHdoZXJlIDxwcm9jZXNzPiBpcyBhIDkgY2hhcmFjdGVyIHN0cmluZyBjb250YWluaW5nIHRoZSBsZWFzdCBzaWduaWZpY2FudAogICogMzIgYml0cyBpbiB0aGUgcHJvY2Vzcy1pZC4KICAqICAgICJQPHBpZD4iCiAgKiAoVGhpcyBpcyBhbiBhYnJpYnJhcnkgY2hvaWNlLiAgT24gbW9zdCBzeXN0ZW1zIHBpZF90IGlzIGEgMzIgYml0IHZhbHVlLApkaWZmIC0tZ2l0IGEvdHJhY2UyL3RyMl9zeXNlbnYuYyBiL3RyYWNlMi90cjJfc3lzZW52LmMKaW5kZXggNTk1OGNmYy4uM2MzNzkyZSAxMDA2NDQKLS0tIGEvdHJhY2UyL3RyMl9zeXNlbnYuYworKysgYi90cmFjZTIvdHIyX3N5c2Vudi5jCkBAIC00OSw2ICs0OSw5IEBACiAJCQkJICAgICAgICJ0cmFjZTIucGVyZnRhcmdldCIgfSwKIAlbVFIyX1NZU0VOVl9QRVJGX0JSSUVGXSAgICA9IHsgIkdJVF9UUkFDRTJfUEVSRl9CUklFRiIsCiAJCQkJICAgICAgICJ0cmFjZTIucGVyZmJyaWVmIiB9LAorCisJW1RSMl9TWVNFTlZfTUFYX0ZJTEVTXSAgICAgPSB7ICJHSVRfVFJBQ0UyX01BWF9GSUxFUyIsCisJCQkJICAgICAgICJ0cmFjZTIubWF4ZmlsZXMiIH0sCiB9OwogLyogY2xhbmctZm9ybWF0IG9uICovCiAKZGlmZiAtLWdpdCBhL3RyYWNlMi90cjJfc3lzZW52LmggYi90cmFjZTIvdHIyX3N5c2Vudi5oCmluZGV4IDhkZDgyYTcuLmQ0MzY0YTcgMTAwNjQ0Ci0tLSBhL3RyYWNlMi90cjJfc3lzZW52LmgKKysrIGIvdHJhY2UyL3RyMl9zeXNlbnYuaApAQCAtMjQsNiArMjQsOCBAQAogCVRSMl9TWVNFTlZfUEVSRiwKIAlUUjJfU1lTRU5WX1BFUkZfQlJJRUYsCiAKKwlUUjJfU1lTRU5WX01BWF9GSUxFUywKKwogCVRSMl9TWVNFTlZfTVVTVF9CRV9MQVNUCiB9OwogCmRpZmYgLS1naXQgYS90cmFjZTIvdHIyX3RndF9ldmVudC5jIGIvdHJhY2UyL3RyMl90Z3RfZXZlbnQuYwppbmRleCBjMjg1MmQxLi42MzUzZThhIDEwMDY0NAotLS0gYS90cmFjZTIvdHIyX3RndF9ldmVudC5jCisrKyBiL3RyYWNlMi90cjJfdGd0X2V2ZW50LmMKQEAgLTEwLDE2ICsxMCwxNyBAQAogI2luY2x1ZGUgInRyYWNlMi90cjJfdGd0LmgiCiAjaW5jbHVkZSAidHJhY2UyL3RyMl90bHMuaCIKIAotc3RhdGljIHN0cnVjdCB0cjJfZHN0IHRyMmRzdF9ldmVudCA9IHsgVFIyX1NZU0VOVl9FVkVOVCwgMCwgMCwgMCB9Oworc3RhdGljIHN0cnVjdCB0cjJfZHN0IHRyMmRzdF9ldmVudCA9IHsgVFIyX1NZU0VOVl9FVkVOVCwgMCwgMCwgMCwgMCB9OwogCiAvKgotICogVGhlIHZlcnNpb24gbnVtYmVyIG9mIHRoZSBKU09OIGRhdGEgZ2VuZXJhdGVkIGJ5IHRoZSBFVkVOVCB0YXJnZXQKLSAqIGluIHRoaXMgc291cmNlIGZpbGUuICBVcGRhdGUgdGhpcyBpZiB5b3UgbWFrZSBhIHNpZ25pZmljYW50IGNoYW5nZQotICogdG8gdGhlIEpTT04gZmllbGRzIG9yIG1lc3NhZ2Ugc3RydWN0dXJlLiAgWW91IHByb2JhYmx5IGRvIG5vdCBuZWVkCi0gKiB0byB1cGRhdGUgdGhpcyBpZiB5b3UganVzdCBhZGQgYW5vdGhlciBjYWxsIHRvIG9uZSBvZiB0aGUgZXhpc3RpbmcKLSAqIFRSQUNFMiBBUEkgbWV0aG9kcy4KKyAqIFRoZSB2ZXJzaW9uIG51bWJlciBvZiB0aGUgSlNPTiBkYXRhIGdlbmVyYXRlZCBieSB0aGUgRVZFTlQgdGFyZ2V0IGluIHRoaXMKKyAqIHNvdXJjZSBmaWxlLiBUaGUgdmVyc2lvbiBzaG91bGQgYmUgaW5jcmVtZW50ZWQgaWYgbmV3IGV2ZW50IHR5cGVzIGFyZSBhZGRlZCwKKyAqIGlmIGV4aXN0aW5nIGZpZWxkcyBhcmUgcmVtb3ZlZCwgb3IgaWYgdGhlcmUgYXJlIHNpZ25pZmljYW50IGNoYW5nZXMgaW4KKyAqIGludGVycHJldGF0aW9uIG9mIGV4aXN0aW5nIGV2ZW50cyBvciBmaWVsZHMuIFNtYWxsZXIgY2hhbmdlcywgc3VjaCBhcyBhZGRpbmcKKyAqIGEgbmV3IGZpZWxkIHRvIGFuIGV4aXN0aW5nIGV2ZW50LCBkbyBub3QgcmVxdWlyZSBhbiBpbmNyZW1lbnQgdG8gdGhlIEVWRU5UCisgKiBmb3JtYXQgdmVyc2lvbi4KICAqLwotI2RlZmluZSBUUjJfRVZFTlRfVkVSU0lPTiAiMSIKKyNkZWZpbmUgVFIyX0VWRU5UX1ZFUlNJT04gIjIiCiAKIC8qCiAgKiBSZWdpb24gbmVzdGluZyBsaW1pdCBmb3IgbWVzc2FnZXMgd3JpdHRlbiB0byB0aGUgZXZlbnQgdGFyZ2V0LgpAQCAtMTA3LDYgKzEwOCwxOSBAQAogCQlqd19vYmplY3RfaW50bWF4KGp3LCAicmVwbyIsIHJlcG8tPnRyYWNlMl9yZXBvX2lkKTsKIH0KIAorc3RhdGljIHZvaWQgZm5fdG9vX21hbnlfZmlsZXNfZmwoY29uc3QgY2hhciAqZmlsZSwgaW50IGxpbmUpCit7CisJY29uc3QgY2hhciAqZXZlbnRfbmFtZSA9ICJ0b29fbWFueV9maWxlcyI7CisJc3RydWN0IGpzb25fd3JpdGVyIGp3ID0gSlNPTl9XUklURVJfSU5JVDsKKworCWp3X29iamVjdF9iZWdpbigmancsIDApOworCWV2ZW50X2ZtdF9wcmVwYXJlKGV2ZW50X25hbWUsIGZpbGUsIGxpbmUsIE5VTEwsICZqdyk7CisJandfZW5kKCZqdyk7CisKKwl0cjJfZHN0X3dyaXRlX2xpbmUoJnRyMmRzdF9ldmVudCwgJmp3Lmpzb24pOworCWp3X3JlbGVhc2UoJmp3KTsKK30KKwogc3RhdGljIHZvaWQgZm5fdmVyc2lvbl9mbChjb25zdCBjaGFyICpmaWxlLCBpbnQgbGluZSkKIHsKIAljb25zdCBjaGFyICpldmVudF9uYW1lID0gInZlcnNpb24iOwpAQCAtMTIwLDYgKzEzNCw5IEBACiAKIAl0cjJfZHN0X3dyaXRlX2xpbmUoJnRyMmRzdF9ldmVudCwgJmp3Lmpzb24pOwogCWp3X3JlbGVhc2UoJmp3KTsKKworCWlmICh0cjJkc3RfZXZlbnQudG9vX21hbnlfZmlsZXMpCisJCWZuX3Rvb19tYW55X2ZpbGVzX2ZsKGZpbGUsIGxpbmUpOwogfQogCiBzdGF0aWMgdm9pZCBmbl9zdGFydF9mbChjb25zdCBjaGFyICpmaWxlLCBpbnQgbGluZSwKQEAgLTIwNSwxMSArMjIyLDYgQEAKIAkJc3RyYnVmX3JlbGVhc2UoJmJ1Zik7CiAJCXJldHVybjsKIAl9Ci0KLQlpZiAoZm10ICYmICpmbXQpIHsKLQkJandfb2JqZWN0X3N0cmluZyhqdywgZmllbGRfbmFtZSwgZm10KTsKLQkJcmV0dXJuOwotCX0KIH0KIAogc3RhdGljIHZvaWQgZm5fZXJyb3JfdmFfZmwoY29uc3QgY2hhciAqZmlsZSwgaW50IGxpbmUsIGNvbnN0IGNoYXIgKmZtdCwKZGlmZiAtLWdpdCBhL3RyYWNlMi90cjJfdGd0X25vcm1hbC5jIGIvdHJhY2UyL3RyMl90Z3Rfbm9ybWFsLmMKaW5kZXggMDBiMTE2ZC4uMzFiNjAyYyAxMDA2NDQKLS0tIGEvdHJhY2UyL3RyMl90Z3Rfbm9ybWFsLmMKKysrIGIvdHJhY2UyL3RyMl90Z3Rfbm9ybWFsLmMKQEAgLTksNyArOSw3IEBACiAjaW5jbHVkZSAidHJhY2UyL3RyMl90Z3QuaCIKICNpbmNsdWRlICJ0cmFjZTIvdHIyX3Rscy5oIgogCi1zdGF0aWMgc3RydWN0IHRyMl9kc3QgdHIyZHN0X25vcm1hbCA9IHsgVFIyX1NZU0VOVl9OT1JNQUwsIDAsIDAsIDAgfTsKK3N0YXRpYyBzdHJ1Y3QgdHIyX2RzdCB0cjJkc3Rfbm9ybWFsID0geyBUUjJfU1lTRU5WX05PUk1BTCwgMCwgMCwgMCwgMCB9OwogCiAvKgogICogVXNlIHRoZSBUUjJfU1lTRU5WX05PUk1BTF9CUklFRiBzZXR0aW5nIHRvIG9taXQgdGhlICI8dGltZT4gPGZpbGU+OjxsaW5lPiIKQEAgLTg3LDcgKzg3LDcgQEAKIAlzdHJ1Y3Qgc3RyYnVmIGJ1Zl9wYXlsb2FkID0gU1RSQlVGX0lOSVQ7CiAKIAlzdHJidWZfYWRkc3RyKCZidWZfcGF5bG9hZCwgInN0YXJ0ICIpOwotCXNxX3F1b3RlX2FyZ3ZfcHJldHR5KCZidWZfcGF5bG9hZCwgYXJndik7CisJc3FfYXBwZW5kX3F1b3RlX2FyZ3ZfcHJldHR5KCZidWZfcGF5bG9hZCwgYXJndik7CiAJbm9ybWFsX2lvX3dyaXRlX2ZsKGZpbGUsIGxpbmUsICZidWZfcGF5bG9hZCk7CiAJc3RyYnVmX3JlbGVhc2UoJmJ1Zl9wYXlsb2FkKTsKIH0KQEAgLTEzNSwxMSArMTM1LDYgQEAKIAkJdmFfZW5kKGNvcHlfYXApOwogCQlyZXR1cm47CiAJfQotCi0JaWYgKGZtdCAmJiAqZm10KSB7Ci0JCXN0cmJ1Zl9hZGRzdHIoYnVmLCBmbXQpOwotCQlyZXR1cm47Ci0JfQogfQogCiBzdGF0aWMgdm9pZCBmbl9lcnJvcl92YV9mbChjb25zdCBjaGFyICpmaWxlLCBpbnQgbGluZSwgY29uc3QgY2hhciAqZm10LApAQCAtMTQ3LDggKzE0MiwxMSBAQAogewogCXN0cnVjdCBzdHJidWYgYnVmX3BheWxvYWQgPSBTVFJCVUZfSU5JVDsKIAotCXN0cmJ1Zl9hZGRzdHIoJmJ1Zl9wYXlsb2FkLCAiZXJyb3IgIik7Ci0JbWF5YmVfYXBwZW5kX3N0cmluZ192YSgmYnVmX3BheWxvYWQsIGZtdCwgYXApOworCXN0cmJ1Zl9hZGRzdHIoJmJ1Zl9wYXlsb2FkLCAiZXJyb3IiKTsKKwlpZiAoZm10ICYmICpmbXQpIHsKKwkJc3RyYnVmX2FkZGNoKCZidWZfcGF5bG9hZCwgJyAnKTsKKwkJbWF5YmVfYXBwZW5kX3N0cmluZ192YSgmYnVmX3BheWxvYWQsIGZtdCwgYXApOworCX0KIAlub3JtYWxfaW9fd3JpdGVfZmwoZmlsZSwgbGluZSwgJmJ1Zl9wYXlsb2FkKTsKIAlzdHJidWZfcmVsZWFzZSgmYnVmX3BheWxvYWQpOwogfQpAQCAtMTg4LDggKzE4Niw4IEBACiB7CiAJc3RydWN0IHN0cmJ1ZiBidWZfcGF5bG9hZCA9IFNUUkJVRl9JTklUOwogCi0Jc3RyYnVmX2FkZGYoJmJ1Zl9wYXlsb2FkLCAiYWxpYXMgJXMgLT4iLCBhbGlhcyk7Ci0Jc3FfcXVvdGVfYXJndl9wcmV0dHkoJmJ1Zl9wYXlsb2FkLCBhcmd2KTsKKwlzdHJidWZfYWRkZigmYnVmX3BheWxvYWQsICJhbGlhcyAlcyAtPiAiLCBhbGlhcyk7CisJc3FfYXBwZW5kX3F1b3RlX2FyZ3ZfcHJldHR5KCZidWZfcGF5bG9hZCwgYXJndik7CiAJbm9ybWFsX2lvX3dyaXRlX2ZsKGZpbGUsIGxpbmUsICZidWZfcGF5bG9hZCk7CiAJc3RyYnVmX3JlbGVhc2UoJmJ1Zl9wYXlsb2FkKTsKIH0KQEAgLTIwMCwxMiArMTk4LDEyIEBACiB7CiAJc3RydWN0IHN0cmJ1ZiBidWZfcGF5bG9hZCA9IFNUUkJVRl9JTklUOwogCi0Jc3RyYnVmX2FkZGYoJmJ1Zl9wYXlsb2FkLCAiY2hpbGRfc3RhcnRbJWRdICIsIGNtZC0+dHJhY2UyX2NoaWxkX2lkKTsKKwlzdHJidWZfYWRkZigmYnVmX3BheWxvYWQsICJjaGlsZF9zdGFydFslZF0iLCBjbWQtPnRyYWNlMl9jaGlsZF9pZCk7CiAKIAlpZiAoY21kLT5kaXIpIHsKLQkJc3RyYnVmX2FkZHN0cigmYnVmX3BheWxvYWQsICIgY2QiKTsKKwkJc3RyYnVmX2FkZHN0cigmYnVmX3BheWxvYWQsICIgY2QgIik7CiAJCXNxX3F1b3RlX2J1Zl9wcmV0dHkoJmJ1Zl9wYXlsb2FkLCBjbWQtPmRpcik7Ci0JCXN0cmJ1Zl9hZGRzdHIoJmJ1Zl9wYXlsb2FkLCAiOyAiKTsKKwkJc3RyYnVmX2FkZHN0cigmYnVmX3BheWxvYWQsICI7Iik7CiAJfQogCiAJLyoKQEAgLTIxMyw5ICsyMTEsMTAgQEAKIAkgKiBTZWUgdHJhY2VfYWRkX2VudigpIGluIHJ1bi1jb21tYW5kLmMgYXMgdXNlZCBieSBvcmlnaW5hbCB0cmFjZS5jCiAJICovCiAKKwlzdHJidWZfYWRkY2goJmJ1Zl9wYXlsb2FkLCAnICcpOwogCWlmIChjbWQtPmdpdF9jbWQpCi0JCXN0cmJ1Zl9hZGRzdHIoJmJ1Zl9wYXlsb2FkLCAiZ2l0Iik7Ci0Jc3FfcXVvdGVfYXJndl9wcmV0dHkoJmJ1Zl9wYXlsb2FkLCBjbWQtPmFyZ3YpOworCQlzdHJidWZfYWRkc3RyKCZidWZfcGF5bG9hZCwgImdpdCAiKTsKKwlzcV9hcHBlbmRfcXVvdGVfYXJndl9wcmV0dHkoJmJ1Zl9wYXlsb2FkLCBjbWQtPmFyZ3YpOwogCiAJbm9ybWFsX2lvX3dyaXRlX2ZsKGZpbGUsIGxpbmUsICZidWZfcGF5bG9hZCk7CiAJc3RyYnVmX3JlbGVhc2UoJmJ1Zl9wYXlsb2FkKTsKQEAgLTI0MCw5ICsyMzksMTEgQEAKIAlzdHJ1Y3Qgc3RyYnVmIGJ1Zl9wYXlsb2FkID0gU1RSQlVGX0lOSVQ7CiAKIAlzdHJidWZfYWRkZigmYnVmX3BheWxvYWQsICJleGVjWyVkXSAiLCBleGVjX2lkKTsKLQlpZiAoZXhlKQorCWlmIChleGUpIHsKIAkJc3RyYnVmX2FkZHN0cigmYnVmX3BheWxvYWQsIGV4ZSk7Ci0Jc3FfcXVvdGVfYXJndl9wcmV0dHkoJmJ1Zl9wYXlsb2FkLCBhcmd2KTsKKwkJc3RyYnVmX2FkZGNoKCZidWZfcGF5bG9hZCwgJyAnKTsKKwl9CisJc3FfYXBwZW5kX3F1b3RlX2FyZ3ZfcHJldHR5KCZidWZfcGF5bG9hZCwgYXJndik7CiAJbm9ybWFsX2lvX3dyaXRlX2ZsKGZpbGUsIGxpbmUsICZidWZfcGF5bG9hZCk7CiAJc3RyYnVmX3JlbGVhc2UoJmJ1Zl9wYXlsb2FkKTsKIH0KZGlmZiAtLWdpdCBhL3RyYWNlMi90cjJfdGd0X3BlcmYuYyBiL3RyYWNlMi90cjJfdGd0X3BlcmYuYwppbmRleCBlYTBjYmJlLi5hODAxOGYxIDEwMDY0NAotLS0gYS90cmFjZTIvdHIyX3RndF9wZXJmLmMKKysrIGIvdHJhY2UyL3RyMl90Z3RfcGVyZi5jCkBAIC0xMSw3ICsxMSw3IEBACiAjaW5jbHVkZSAidHJhY2UyL3RyMl90Z3QuaCIKICNpbmNsdWRlICJ0cmFjZTIvdHIyX3Rscy5oIgogCi1zdGF0aWMgc3RydWN0IHRyMl9kc3QgdHIyZHN0X3BlcmYgPSB7IFRSMl9TWVNFTlZfUEVSRiwgMCwgMCwgMCB9Oworc3RhdGljIHN0cnVjdCB0cjJfZHN0IHRyMmRzdF9wZXJmID0geyBUUjJfU1lTRU5WX1BFUkYsIDAsIDAsIDAsIDAgfTsKIAogLyoKICAqIFVzZSBUUjJfU1lTRU5WX1BFUkZfQlJJRUYgdG8gb21pdCB0aGUgIjx0aW1lPiA8ZmlsZT46PGxpbmU+IgpAQCAtMjEsMTcgKzIxLDE0IEBACiAgKi8KIHN0YXRpYyBpbnQgdHIyZW52X3BlcmZfYmVfYnJpZWY7CiAKLSNkZWZpbmUgVFIyRk1UX1BFUkZfRkxfV0lEVEggKDUwKQorI2RlZmluZSBUUjJGTVRfUEVSRl9GTF9XSURUSCAoMjgpCiAjZGVmaW5lIFRSMkZNVF9QRVJGX01BWF9FVkVOVF9OQU1FICgxMikKLSNkZWZpbmUgVFIyRk1UX1BFUkZfUkVQT19XSURUSCAoNCkKLSNkZWZpbmUgVFIyRk1UX1BFUkZfQ0FURUdPUllfV0lEVEggKDEwKQorI2RlZmluZSBUUjJGTVRfUEVSRl9SRVBPX1dJRFRIICgzKQorI2RlZmluZSBUUjJGTVRfUEVSRl9DQVRFR09SWV9XSURUSCAoMTIpCiAKLSNkZWZpbmUgVFIyX0RPVFNfQlVGRkVSX1NJWkUgKDEwMCkKICNkZWZpbmUgVFIyX0lOREVOVCAoMikKICNkZWZpbmUgVFIyX0lOREVOVF9MRU5HVEgoY3R4KSAoKChjdHgpLT5ucl9vcGVuX3JlZ2lvbnMgLSAxKSAqIFRSMl9JTkRFTlQpCiAKLXN0YXRpYyBzdHJ1Y3Qgc3RyYnVmIGRvdHMgPSBTVFJCVUZfSU5JVDsKLQogc3RhdGljIGludCBmbl9pbml0KHZvaWQpCiB7CiAJaW50IHdhbnQgPSB0cjJfZHN0X3RyYWNlX3dhbnQoJnRyMmRzdF9wZXJmKTsKQEAgLTQxLDggKzM4LDYgQEAKIAlpZiAoIXdhbnQpCiAJCXJldHVybiB3YW50OwogCi0Jc3RyYnVmX2FkZGNoYXJzKCZkb3RzLCAnLicsIFRSMl9ET1RTX0JVRkZFUl9TSVpFKTsKLQogCWJyaWVmID0gdHIyX3N5c2Vudl9nZXQoVFIyX1NZU0VOVl9QRVJGX0JSSUVGKTsKIAlpZiAoYnJpZWYgJiYgKmJyaWVmICYmCiAJICAgICgod2FudF9icmllZiA9IGdpdF9wYXJzZV9tYXliZV9ib29sKGJyaWVmKSkgIT0gLTEpKQpAQCAtNTQsOCArNDksNiBAQAogc3RhdGljIHZvaWQgZm5fdGVybSh2b2lkKQogewogCXRyMl9kc3RfdHJhY2VfZGlzYWJsZSgmdHIyZHN0X3BlcmYpOwotCi0Jc3RyYnVmX3JlbGVhc2UoJmRvdHMpOwogfQogCiAvKgpAQCAtNzksMTcgKzcyLDM2IEBACiAKIAlpZiAoIXRyMmVudl9wZXJmX2JlX2JyaWVmKSB7CiAJCXN0cnVjdCB0cjJfdGJ1ZiB0Yl9ub3c7CisJCXNpemVfdCBmbF9lbmRfY29sOwogCiAJCXRyMl90YnVmX2xvY2FsX3RpbWUoJnRiX25vdyk7CiAJCXN0cmJ1Zl9hZGRzdHIoYnVmLCB0Yl9ub3cuYnVmKTsKIAkJc3RyYnVmX2FkZGNoKGJ1ZiwgJyAnKTsKIAotCQlpZiAoZmlsZSAmJiAqZmlsZSkKLQkJCXN0cmJ1Zl9hZGRmKGJ1ZiwgIiVzOiVkICIsIGZpbGUsIGxpbmUpOwotCQl3aGlsZSAoYnVmLT5sZW4gPCBUUjJGTVRfUEVSRl9GTF9XSURUSCkKKwkJZmxfZW5kX2NvbCA9IGJ1Zi0+bGVuICsgVFIyRk1UX1BFUkZfRkxfV0lEVEg7CisKKwkJaWYgKGZpbGUgJiYgKmZpbGUpIHsKKwkJCXN0cnVjdCBzdHJidWYgYnVmX2ZsID0gU1RSQlVGX0lOSVQ7CisKKwkJCXN0cmJ1Zl9hZGRmKCZidWZfZmwsICIlczolZCIsIGZpbGUsIGxpbmUpOworCisJCQlpZiAoYnVmX2ZsLmxlbiA8PSBUUjJGTVRfUEVSRl9GTF9XSURUSCkKKwkJCQlzdHJidWZfYWRkYnVmKGJ1ZiwgJmJ1Zl9mbCk7CisJCQllbHNlIHsKKwkJCQlzaXplX3QgYXZhaWwgPSBUUjJGTVRfUEVSRl9GTF9XSURUSCAtIDM7CisJCQkJc3RyYnVmX2FkZHN0cihidWYsICIuLi4iKTsKKwkJCQlzdHJidWZfYWRkKGJ1ZiwKKwkJCQkJICAgJmJ1Zl9mbC5idWZbYnVmX2ZsLmxlbiAtIGF2YWlsXSwKKwkJCQkJICAgYXZhaWwpOworCQkJfQorCisJCQlzdHJidWZfcmVsZWFzZSgmYnVmX2ZsKTsKKwkJfQorCisJCXdoaWxlIChidWYtPmxlbiA8IGZsX2VuZF9jb2wpCiAJCQlzdHJidWZfYWRkY2goYnVmLCAnICcpOwogCi0JCXN0cmJ1Zl9hZGRzdHIoYnVmLCAifCAiKTsKKwkJc3RyYnVmX2FkZHN0cihidWYsICIgfCAiKTsKIAl9CiAKIAlzdHJidWZfYWRkZihidWYsICJkJWQgfCAiLCB0cjJfc2lkX2RlcHRoKCkpOwpAQCAtMTAyLDcgKzExNCw3IEBACiAJCXN0cmJ1Zl9hZGRmKGJ1ZiwgInIlZCAiLCByZXBvLT50cmFjZTJfcmVwb19pZCk7CiAJd2hpbGUgKGJ1Zi0+bGVuIDwgbGVuKQogCQlzdHJidWZfYWRkY2goYnVmLCAnICcpOwotCXN0cmJ1Zl9hZGRzdHIoYnVmLCAifCAiKTsKKwlzdHJidWZfYWRkc3RyKGJ1ZiwgIiB8ICIpOwogCiAJaWYgKHBfdXNfZWxhcHNlZF9hYnNvbHV0ZSkKIAkJc3RyYnVmX2FkZGYoYnVmLCAiJTkuNmYgfCAiLApAQCAtMTE2LDE3ICsxMjgsMTEgQEAKIAllbHNlCiAJCXN0cmJ1Zl9hZGRmKGJ1ZiwgIiU5cyB8ICIsICIgIik7CiAKLQlzdHJidWZfYWRkZihidWYsICIlLSpzIHwgIiwgVFIyRk1UX1BFUkZfQ0FURUdPUllfV0lEVEgsCi0JCSAgICAoY2F0ZWdvcnkgPyBjYXRlZ29yeSA6ICIiKSk7CisJc3RyYnVmX2FkZGYoYnVmLCAiJS0qLipzIHwgIiwgVFIyRk1UX1BFUkZfQ0FURUdPUllfV0lEVEgsCisJCSAgICBUUjJGTVRfUEVSRl9DQVRFR09SWV9XSURUSCwgKGNhdGVnb3J5ID8gY2F0ZWdvcnkgOiAiIikpOwogCi0JaWYgKGN0eC0+bnJfb3Blbl9yZWdpb25zID4gMCkgewotCQlpbnQgbGVuX2luZGVudCA9IFRSMl9JTkRFTlRfTEVOR1RIKGN0eCk7Ci0JCXdoaWxlIChsZW5faW5kZW50ID4gZG90cy5sZW4pIHsKLQkJCXN0cmJ1Zl9hZGRidWYoYnVmLCAmZG90cyk7Ci0JCQlsZW5faW5kZW50IC09IGRvdHMubGVuOwotCQl9Ci0JCXN0cmJ1Zl9hZGRmKGJ1ZiwgIiUuKnMiLCBsZW5faW5kZW50LCBkb3RzLmJ1Zik7Ci0JfQorCWlmIChjdHgtPm5yX29wZW5fcmVnaW9ucyA+IDApCisJCXN0cmJ1Zl9hZGRjaGFycyhidWYsICcuJywgVFIyX0lOREVOVF9MRU5HVEgoY3R4KSk7CiB9CiAKIHN0YXRpYyB2b2lkIHBlcmZfaW9fd3JpdGVfZmwoY29uc3QgY2hhciAqZmlsZSwgaW50IGxpbmUsIGNvbnN0IGNoYXIgKmV2ZW50X25hbWUsCkBAIC0xNjUsNyArMTcxLDcgQEAKIAljb25zdCBjaGFyICpldmVudF9uYW1lID0gInN0YXJ0IjsKIAlzdHJ1Y3Qgc3RyYnVmIGJ1Zl9wYXlsb2FkID0gU1RSQlVGX0lOSVQ7CiAKLQlzcV9xdW90ZV9hcmd2X3ByZXR0eSgmYnVmX3BheWxvYWQsIGFyZ3YpOworCXNxX2FwcGVuZF9xdW90ZV9hcmd2X3ByZXR0eSgmYnVmX3BheWxvYWQsIGFyZ3YpOwogCiAJcGVyZl9pb193cml0ZV9mbChmaWxlLCBsaW5lLCBldmVudF9uYW1lLCBOVUxMLCAmdXNfZWxhcHNlZF9hYnNvbHV0ZSwKIAkJCSBOVUxMLCBOVUxMLCAmYnVmX3BheWxvYWQpOwpAQCAtMjIwLDExICsyMjYsNiBAQAogCQl2YV9lbmQoY29weV9hcCk7CiAJCXJldHVybjsKIAl9Ci0KLQlpZiAoZm10ICYmICpmbXQpIHsKLQkJc3RyYnVmX2FkZHN0cihidWYsIGZtdCk7Ci0JCXJldHVybjsKLQl9CiB9CiAKIHN0YXRpYyB2b2lkIGZuX2Vycm9yX3ZhX2ZsKGNvbnN0IGNoYXIgKmZpbGUsIGludCBsaW5lLCBjb25zdCBjaGFyICpmbXQsCkBAIC0yODUsOCArMjg2LDkgQEAKIAljb25zdCBjaGFyICpldmVudF9uYW1lID0gImFsaWFzIjsKIAlzdHJ1Y3Qgc3RyYnVmIGJ1Zl9wYXlsb2FkID0gU1RSQlVGX0lOSVQ7CiAKLQlzdHJidWZfYWRkZigmYnVmX3BheWxvYWQsICJhbGlhczolcyBhcmd2OiIsIGFsaWFzKTsKLQlzcV9xdW90ZV9hcmd2X3ByZXR0eSgmYnVmX3BheWxvYWQsIGFyZ3YpOworCXN0cmJ1Zl9hZGRmKCZidWZfcGF5bG9hZCwgImFsaWFzOiVzIGFyZ3Y6WyIsIGFsaWFzKTsKKwlzcV9hcHBlbmRfcXVvdGVfYXJndl9wcmV0dHkoJmJ1Zl9wYXlsb2FkLCBhcmd2KTsKKwlzdHJidWZfYWRkY2goJmJ1Zl9wYXlsb2FkLCAnXScpOwogCiAJcGVyZl9pb193cml0ZV9mbChmaWxlLCBsaW5lLCBldmVudF9uYW1lLCBOVUxMLCBOVUxMLCBOVUxMLCBOVUxMLAogCQkJICZidWZfcGF5bG9hZCk7CkBAIC0zMTUsMTAgKzMxNywxNCBAQAogCQlzcV9xdW90ZV9idWZfcHJldHR5KCZidWZfcGF5bG9hZCwgY21kLT5kaXIpOwogCX0KIAotCXN0cmJ1Zl9hZGRzdHIoJmJ1Zl9wYXlsb2FkLCAiIGFyZ3Y6Iik7Ci0JaWYgKGNtZC0+Z2l0X2NtZCkKLQkJc3RyYnVmX2FkZHN0cigmYnVmX3BheWxvYWQsICIgZ2l0Iik7Ci0Jc3FfcXVvdGVfYXJndl9wcmV0dHkoJmJ1Zl9wYXlsb2FkLCBjbWQtPmFyZ3YpOworCXN0cmJ1Zl9hZGRzdHIoJmJ1Zl9wYXlsb2FkLCAiIGFyZ3Y6WyIpOworCWlmIChjbWQtPmdpdF9jbWQpIHsKKwkJc3RyYnVmX2FkZHN0cigmYnVmX3BheWxvYWQsICJnaXQiKTsKKwkJaWYgKGNtZC0+YXJndlswXSkKKwkJCXN0cmJ1Zl9hZGRjaCgmYnVmX3BheWxvYWQsICcgJyk7CisJfQorCXNxX2FwcGVuZF9xdW90ZV9hcmd2X3ByZXR0eSgmYnVmX3BheWxvYWQsIGNtZC0+YXJndik7CisJc3RyYnVmX2FkZGNoKCZidWZfcGF5bG9hZCwgJ10nKTsKIAogCXBlcmZfaW9fd3JpdGVfZmwoZmlsZSwgbGluZSwgZXZlbnRfbmFtZSwgTlVMTCwgJnVzX2VsYXBzZWRfYWJzb2x1dGUsCiAJCQkgTlVMTCwgTlVMTCwgJmJ1Zl9wYXlsb2FkKTsKQEAgLTM2OSwxMCArMzc1LDE0IEBACiAJc3RydWN0IHN0cmJ1ZiBidWZfcGF5bG9hZCA9IFNUUkJVRl9JTklUOwogCiAJc3RyYnVmX2FkZGYoJmJ1Zl9wYXlsb2FkLCAiaWQ6JWQgIiwgZXhlY19pZCk7Ci0Jc3RyYnVmX2FkZHN0cigmYnVmX3BheWxvYWQsICJhcmd2OiIpOwotCWlmIChleGUpCi0JCXN0cmJ1Zl9hZGRmKCZidWZfcGF5bG9hZCwgIiAlcyIsIGV4ZSk7Ci0Jc3FfcXVvdGVfYXJndl9wcmV0dHkoJmJ1Zl9wYXlsb2FkLCBhcmd2KTsKKwlzdHJidWZfYWRkc3RyKCZidWZfcGF5bG9hZCwgImFyZ3Y6WyIpOworCWlmIChleGUpIHsKKwkJc3RyYnVmX2FkZHN0cigmYnVmX3BheWxvYWQsIGV4ZSk7CisJCWlmIChhcmd2WzBdKQorCQkJc3RyYnVmX2FkZGNoKCZidWZfcGF5bG9hZCwgJyAnKTsKKwl9CisJc3FfYXBwZW5kX3F1b3RlX2FyZ3ZfcHJldHR5KCZidWZfcGF5bG9hZCwgYXJndik7CisJc3RyYnVmX2FkZGNoKCZidWZfcGF5bG9hZCwgJ10nKTsKIAogCXBlcmZfaW9fd3JpdGVfZmwoZmlsZSwgbGluZSwgZXZlbnRfbmFtZSwgTlVMTCwgJnVzX2VsYXBzZWRfYWJzb2x1dGUsCiAJCQkgTlVMTCwgTlVMTCwgJmJ1Zl9wYXlsb2FkKTsKQEAgLTQzMyw4ICs0NDMsMTEgQEAKIAlzdHJ1Y3Qgc3RyYnVmIGJ1Zl9wYXlsb2FkID0gU1RSQlVGX0lOSVQ7CiAKIAlpZiAobGFiZWwpCi0JCXN0cmJ1Zl9hZGRmKCZidWZfcGF5bG9hZCwgImxhYmVsOiVzICIsIGxhYmVsKTsKLQltYXliZV9hcHBlbmRfc3RyaW5nX3ZhKCZidWZfcGF5bG9hZCwgZm10LCBhcCk7CisJCXN0cmJ1Zl9hZGRmKCZidWZfcGF5bG9hZCwgImxhYmVsOiVzIiwgbGFiZWwpOworCWlmIChmbXQgJiYgKmZtdCkgeworCQlzdHJidWZfYWRkY2goJmJ1Zl9wYXlsb2FkLCAnICcpOworCQltYXliZV9hcHBlbmRfc3RyaW5nX3ZhKCZidWZfcGF5bG9hZCwgZm10LCBhcCk7CisJfQogCiAJcGVyZl9pb193cml0ZV9mbChmaWxlLCBsaW5lLCBldmVudF9uYW1lLCByZXBvLCAmdXNfZWxhcHNlZF9hYnNvbHV0ZSwKIAkJCSBOVUxMLCBjYXRlZ29yeSwgJmJ1Zl9wYXlsb2FkKTsKQEAgLTQ1MCw4ICs0NjMsMTEgQEAKIAlzdHJ1Y3Qgc3RyYnVmIGJ1Zl9wYXlsb2FkID0gU1RSQlVGX0lOSVQ7CiAKIAlpZiAobGFiZWwpCi0JCXN0cmJ1Zl9hZGRmKCZidWZfcGF5bG9hZCwgImxhYmVsOiVzICIsIGxhYmVsKTsKLQltYXliZV9hcHBlbmRfc3RyaW5nX3ZhKCZidWZfcGF5bG9hZCwgZm10LCBhcCk7CisJCXN0cmJ1Zl9hZGRmKCZidWZfcGF5bG9hZCwgImxhYmVsOiVzIiwgbGFiZWwpOworCWlmIChmbXQgJiYgKmZtdCkgeworCQlzdHJidWZfYWRkY2goJmJ1Zl9wYXlsb2FkLCAnICcgKTsKKwkJbWF5YmVfYXBwZW5kX3N0cmluZ192YSgmYnVmX3BheWxvYWQsIGZtdCwgYXApOworCX0KIAogCXBlcmZfaW9fd3JpdGVfZmwoZmlsZSwgbGluZSwgZXZlbnRfbmFtZSwgcmVwbywgJnVzX2VsYXBzZWRfYWJzb2x1dGUsCiAJCQkgJnVzX2VsYXBzZWRfcmVnaW9uLCBjYXRlZ29yeSwgJmJ1Zl9wYXlsb2FkKTsKZGlmZiAtLWdpdCBhL3RyYW5zcG9ydC1oZWxwZXIuYyBiL3RyYW5zcG9ydC1oZWxwZXIuYwppbmRleCA2YjA1YTg4Li5hOWQ2OTAyIDEwMDY0NAotLS0gYS90cmFuc3BvcnQtaGVscGVyLmMKKysrIGIvdHJhbnNwb3J0LWhlbHBlci5jCkBAIC0zMyw2ICszMywxNiBAQAogCQljaGVja19jb25uZWN0aXZpdHkgOiAxLAogCQlub19kaXNjb25uZWN0X3JlcSA6IDEsCiAJCW5vX3ByaXZhdGVfdXBkYXRlIDogMTsKKworCS8qCisJICogQXMgYW4gb3B0aW1pemF0aW9uLCB0aGUgdHJhbnNwb3J0IGNvZGUgbWF5IGludm9rZSBmZXRjaCBiZWZvcmUKKwkgKiBnZXRfcmVmc19saXN0LiBJZiB0aGlzIGhhcHBlbnMsIGFuZCBpZiB0aGUgdHJhbnNwb3J0IGhlbHBlciBkb2Vzbid0CisJICogc3VwcG9ydCBjb25uZWN0IG9yIHN0YXRlbGVzc19jb25uZWN0LCB3ZSBuZWVkIHRvIGludm9rZQorCSAqIGdldF9yZWZzX2xpc3Qgb3Vyc2VsdmVzIGlmIHdlIGhhdmVuJ3QgYWxyZWFkeSBkb25lIHNvLiBLZWVwIHRyYWNrIG9mCisJICogd2hldGhlciB3ZSBoYXZlIGludm9rZWQgZ2V0X3JlZnNfbGlzdC4KKwkgKi8KKwl1bnNpZ25lZCBnZXRfcmVmc19saXN0X2NhbGxlZCA6IDE7CisKIAljaGFyICpleHBvcnRfbWFya3M7CiAJY2hhciAqaW1wb3J0X21hcmtzOwogCS8qIFRoZXNlIGdvIGZyb20gcmVtb3RlIG5hbWUgKGFzIGluICJsaXN0IikgdG8gcHJpdmF0ZSBuYW1lICovCkBAIC02NTIsMTcgKzY2MiwyNSBAQAogCXJldHVybiAwOwogfQogCitzdGF0aWMgc3RydWN0IHJlZiAqZ2V0X3JlZnNfbGlzdF91c2luZ19saXN0KHN0cnVjdCB0cmFuc3BvcnQgKnRyYW5zcG9ydCwKKwkJCQkJICAgIGludCBmb3JfcHVzaCk7CisKIHN0YXRpYyBpbnQgZmV0Y2goc3RydWN0IHRyYW5zcG9ydCAqdHJhbnNwb3J0LAogCQkgaW50IG5yX2hlYWRzLCBzdHJ1Y3QgcmVmICoqdG9fZmV0Y2gpCiB7CiAJc3RydWN0IGhlbHBlcl9kYXRhICpkYXRhID0gdHJhbnNwb3J0LT5kYXRhOwogCWludCBpLCBjb3VudDsKIAorCWdldF9oZWxwZXIodHJhbnNwb3J0KTsKKwogCWlmIChwcm9jZXNzX2Nvbm5lY3QodHJhbnNwb3J0LCAwKSkgewogCQlkb190YWtlX292ZXIodHJhbnNwb3J0KTsKIAkJcmV0dXJuIHRyYW5zcG9ydC0+dnRhYmxlLT5mZXRjaCh0cmFuc3BvcnQsIG5yX2hlYWRzLCB0b19mZXRjaCk7CiAJfQogCisJaWYgKCFkYXRhLT5nZXRfcmVmc19saXN0X2NhbGxlZCkKKwkJZ2V0X3JlZnNfbGlzdF91c2luZ19saXN0KHRyYW5zcG9ydCwgMCk7CisKIAljb3VudCA9IDA7CiAJZm9yIChpID0gMDsgaSA8IG5yX2hlYWRzOyBpKyspCiAJCWlmICghKHRvX2ZldGNoW2ldLT5zdGF0dXMgJiBSRUZfU1RBVFVTX1VQVE9EQVRFKSkKQEAgLTY4MiwxMyArNzAwLDkgQEAKIAkJc2V0X2hlbHBlcl9vcHRpb24odHJhbnNwb3J0LCAidXBkYXRlLXNoYWxsb3ciLCAidHJ1ZSIpOwogCiAJaWYgKGRhdGEtPnRyYW5zcG9ydF9vcHRpb25zLmZpbHRlcl9vcHRpb25zLmNob2ljZSkgewotCQlzdHJ1Y3Qgc3RyYnVmIGV4cGFuZGVkX2ZpbHRlcl9zcGVjID0gU1RSQlVGX0lOSVQ7Ci0JCWV4cGFuZF9saXN0X29iamVjdHNfZmlsdGVyX3NwZWMoCi0JCQkmZGF0YS0+dHJhbnNwb3J0X29wdGlvbnMuZmlsdGVyX29wdGlvbnMsCi0JCQkmZXhwYW5kZWRfZmlsdGVyX3NwZWMpOwotCQlzZXRfaGVscGVyX29wdGlvbih0cmFuc3BvcnQsICJmaWx0ZXIiLAotCQkJCSAgZXhwYW5kZWRfZmlsdGVyX3NwZWMuYnVmKTsKLQkJc3RyYnVmX3JlbGVhc2UoJmV4cGFuZGVkX2ZpbHRlcl9zcGVjKTsKKwkJY29uc3QgY2hhciAqc3BlYyA9IGV4cGFuZF9saXN0X29iamVjdHNfZmlsdGVyX3NwZWMoCisJCQkmZGF0YS0+dHJhbnNwb3J0X29wdGlvbnMuZmlsdGVyX29wdGlvbnMpOworCQlzZXRfaGVscGVyX29wdGlvbih0cmFuc3BvcnQsICJmaWx0ZXIiLCBzcGVjKTsKIAl9CiAKIAlpZiAoZGF0YS0+dHJhbnNwb3J0X29wdGlvbnMubmVnb3RpYXRpb25fdGlwcykKQEAgLTg0MCw2ICs4NTQsMTAgQEAKIAkJCWRpZShfKCJoZWxwZXIgJXMgZG9lcyBub3Qgc3VwcG9ydCAtLXNpZ25lZD1pZi1hc2tlZCIpLCBuYW1lKTsKIAl9CiAKKwlpZiAoZmxhZ3MgJiBUUkFOU1BPUlRfUFVTSF9BVE9NSUMpCisJCWlmIChzZXRfaGVscGVyX29wdGlvbih0cmFuc3BvcnQsIFRSQU5TX09QVF9BVE9NSUMsICJ0cnVlIikgIT0gMCkKKwkJCWRpZShfKCJoZWxwZXIgJXMgZG9lcyBub3Qgc3VwcG9ydCAtLWF0b21pYyIpLCBuYW1lKTsKKwogCWlmIChmbGFncyAmIFRSQU5TUE9SVF9QVVNIX09QVElPTlMpIHsKIAkJc3RydWN0IHN0cmluZ19saXN0X2l0ZW0gKml0ZW07CiAJCWZvcl9lYWNoX3N0cmluZ19saXN0X2l0ZW0oaXRlbSwgdHJhbnNwb3J0LT5wdXNoX29wdGlvbnMpCkBAIC0xMDU5LDYgKzEwNzcsMTkgQEAKIHN0YXRpYyBzdHJ1Y3QgcmVmICpnZXRfcmVmc19saXN0KHN0cnVjdCB0cmFuc3BvcnQgKnRyYW5zcG9ydCwgaW50IGZvcl9wdXNoLAogCQkJCSBjb25zdCBzdHJ1Y3QgYXJndl9hcnJheSAqcmVmX3ByZWZpeGVzKQogeworCWdldF9oZWxwZXIodHJhbnNwb3J0KTsKKworCWlmIChwcm9jZXNzX2Nvbm5lY3QodHJhbnNwb3J0LCBmb3JfcHVzaCkpIHsKKwkJZG9fdGFrZV9vdmVyKHRyYW5zcG9ydCk7CisJCXJldHVybiB0cmFuc3BvcnQtPnZ0YWJsZS0+Z2V0X3JlZnNfbGlzdCh0cmFuc3BvcnQsIGZvcl9wdXNoLCByZWZfcHJlZml4ZXMpOworCX0KKworCXJldHVybiBnZXRfcmVmc19saXN0X3VzaW5nX2xpc3QodHJhbnNwb3J0LCBmb3JfcHVzaCk7Cit9CisKK3N0YXRpYyBzdHJ1Y3QgcmVmICpnZXRfcmVmc19saXN0X3VzaW5nX2xpc3Qoc3RydWN0IHRyYW5zcG9ydCAqdHJhbnNwb3J0LAorCQkJCQkgICAgaW50IGZvcl9wdXNoKQorewogCXN0cnVjdCBoZWxwZXJfZGF0YSAqZGF0YSA9IHRyYW5zcG9ydC0+ZGF0YTsKIAlzdHJ1Y3QgY2hpbGRfcHJvY2VzcyAqaGVscGVyOwogCXN0cnVjdCByZWYgKnJldCA9IE5VTEw7CkBAIC0xMDY2LDEzICsxMDk3LDkgQEAKIAlzdHJ1Y3QgcmVmICpwb3NuOwogCXN0cnVjdCBzdHJidWYgYnVmID0gU1RSQlVGX0lOSVQ7CiAKKwlkYXRhLT5nZXRfcmVmc19saXN0X2NhbGxlZCA9IDE7CiAJaGVscGVyID0gZ2V0X2hlbHBlcih0cmFuc3BvcnQpOwogCi0JaWYgKHByb2Nlc3NfY29ubmVjdCh0cmFuc3BvcnQsIGZvcl9wdXNoKSkgewotCQlkb190YWtlX292ZXIodHJhbnNwb3J0KTsKLQkJcmV0dXJuIHRyYW5zcG9ydC0+dnRhYmxlLT5nZXRfcmVmc19saXN0KHRyYW5zcG9ydCwgZm9yX3B1c2gsIHJlZl9wcmVmaXhlcyk7Ci0JfQotCiAJaWYgKGRhdGEtPnB1c2ggJiYgZm9yX3B1c2gpCiAJCXdyaXRlX3N0cl9pbl9mdWxsKGhlbHBlci0+aW4sICJsaXN0IGZvci1wdXNoXG4iKTsKIAllbHNlCkBAIC0xMTE5LDcgKzExNDYsNiBAQAogfQogCiBzdGF0aWMgc3RydWN0IHRyYW5zcG9ydF92dGFibGUgdnRhYmxlID0gewotCTAsCiAJc2V0X2hlbHBlcl9vcHRpb24sCiAJZ2V0X3JlZnNfbGlzdCwKIAlmZXRjaCwKZGlmZiAtLWdpdCBhL3RyYW5zcG9ydC1pbnRlcm5hbC5oIGIvdHJhbnNwb3J0LWludGVybmFsLmgKaW5kZXggMDA0YmVlNS4uMWNkZTYyNSAxMDA2NDQKLS0tIGEvdHJhbnNwb3J0LWludGVybmFsLmgKKysrIGIvdHJhbnNwb3J0LWludGVybmFsLmgKQEAgLTcsMTIgKzcsNiBAQAogCiBzdHJ1Y3QgdHJhbnNwb3J0X3Z0YWJsZSB7CiAJLyoqCi0JICogVGhpcyB0cmFuc3BvcnQgc3VwcG9ydHMgdGhlIGZldGNoKCkgZnVuY3Rpb24gYmVpbmcgY2FsbGVkCi0JICogd2l0aG91dCBnZXRfcmVmc19saXN0KCkgZmlyc3QgYmVpbmcgY2FsbGVkLgotCSAqLwotCXVuc2lnbmVkIGZldGNoX3dpdGhvdXRfbGlzdCA6IDE7Ci0KLQkvKioKIAkgKiBSZXR1cm5zIDAgaWYgc3VjY2Vzc2Z1bCwgcG9zaXRpdmUgaWYgdGhlIG9wdGlvbiBpcyBub3QKIAkgKiByZWNvZ25pemVkIG9yIGlzIGluYXBwbGljYWJsZSwgYW5kIG5lZ2F0aXZlIGlmIHRoZSBvcHRpb24KIAkgKiBpcyBhcHBsaWNhYmxlIGJ1dCB0aGUgdmFsdWUgaXMgaW52YWxpZC4KZGlmZiAtLWdpdCBhL3RyYW5zcG9ydC5jIGIvdHJhbnNwb3J0LmMKaW5kZXggNzc4YzYwYi4uODMzNzlhMCAxMDA2NDQKLS0tIGEvdHJhbnNwb3J0LmMKKysrIGIvdHJhbnNwb3J0LmMKQEAgLTEyMiw2ICsxMjIsNyBAQAogc3RydWN0IGJ1bmRsZV90cmFuc3BvcnRfZGF0YSB7CiAJaW50IGZkOwogCXN0cnVjdCBidW5kbGVfaGVhZGVyIGhlYWRlcjsKKwl1bnNpZ25lZCBnZXRfcmVmc19mcm9tX2J1bmRsZV9jYWxsZWQgOiAxOwogfTsKIAogc3RhdGljIHN0cnVjdCByZWYgKmdldF9yZWZzX2Zyb21fYnVuZGxlKHN0cnVjdCB0cmFuc3BvcnQgKnRyYW5zcG9ydCwKQEAgLTEzNSw2ICsxMzYsOCBAQAogCWlmIChmb3JfcHVzaCkKIAkJcmV0dXJuIE5VTEw7CiAKKwlkYXRhLT5nZXRfcmVmc19mcm9tX2J1bmRsZV9jYWxsZWQgPSAxOworCiAJaWYgKGRhdGEtPmZkID4gMCkKIAkJY2xvc2UoZGF0YS0+ZmQpOwogCWRhdGEtPmZkID0gcmVhZF9idW5kbGVfaGVhZGVyKHRyYW5zcG9ydC0+dXJsLCAmZGF0YS0+aGVhZGVyKTsKQEAgLTE1NCw2ICsxNTcsOSBAQAogCQkJICAgICAgIGludCBucl9oZWFkcywgc3RydWN0IHJlZiAqKnRvX2ZldGNoKQogewogCXN0cnVjdCBidW5kbGVfdHJhbnNwb3J0X2RhdGEgKmRhdGEgPSB0cmFuc3BvcnQtPmRhdGE7CisKKwlpZiAoIWRhdGEtPmdldF9yZWZzX2Zyb21fYnVuZGxlX2NhbGxlZCkKKwkJZ2V0X3JlZnNfZnJvbV9idW5kbGUodHJhbnNwb3J0LCAwLCBOVUxMKTsKIAlyZXR1cm4gdW5idW5kbGUodGhlX3JlcG9zaXRvcnksICZkYXRhLT5oZWFkZXIsIGRhdGEtPmZkLAogCQkJdHJhbnNwb3J0LT5wcm9ncmVzcyA/IEJVTkRMRV9WRVJCT1NFIDogMCk7CiB9CkBAIC0yMjQsNiArMjMwLDcgQEAKIAkJb3B0cy0+bm9fZGVwZW5kZW50cyA9ICEhdmFsdWU7CiAJCXJldHVybiAwOwogCX0gZWxzZSBpZiAoIXN0cmNtcChuYW1lLCBUUkFOU19PUFRfTElTVF9PQkpFQ1RTX0ZJTFRFUikpIHsKKwkJbGlzdF9vYmplY3RzX2ZpbHRlcl9kaWVfaWZfcG9wdWxhdGVkKCZvcHRzLT5maWx0ZXJfb3B0aW9ucyk7CiAJCXBhcnNlX2xpc3Rfb2JqZWN0c19maWx0ZXIoJm9wdHMtPmZpbHRlcl9vcHRpb25zLCB2YWx1ZSk7CiAJCXJldHVybiAwOwogCX0KQEAgLTc0Miw3ICs3NDksNiBAQAogfQogCiBzdGF0aWMgc3RydWN0IHRyYW5zcG9ydF92dGFibGUgdGFrZW5fb3Zlcl92dGFibGUgPSB7Ci0JMSwKIAlOVUxMLAogCWdldF9yZWZzX3ZpYV9jb25uZWN0LAogCWZldGNoX3JlZnNfdmlhX3BhY2ssCkBAIC04OTIsNyArODk4LDYgQEAKIH0KIAogc3RhdGljIHN0cnVjdCB0cmFuc3BvcnRfdnRhYmxlIGJ1bmRsZV92dGFibGUgPSB7Ci0JMCwKIAlOVUxMLAogCWdldF9yZWZzX2Zyb21fYnVuZGxlLAogCWZldGNoX3JlZnNfZnJvbV9idW5kbGUsCkBAIC05MDIsNyArOTA3LDYgQEAKIH07CiAKIHN0YXRpYyBzdHJ1Y3QgdHJhbnNwb3J0X3Z0YWJsZSBidWlsdGluX3NtYXJ0X3Z0YWJsZSA9IHsKLQkxLAogCU5VTEwsCiAJZ2V0X3JlZnNfdmlhX2Nvbm5lY3QsCiAJZmV0Y2hfcmVmc192aWFfcGFjaywKQEAgLTExNDEsOCArMTE0NSwxMCBAQAogCiAJCXJlZnNwZWNfcmVmX3ByZWZpeGVzKHJzLCAmcmVmX3ByZWZpeGVzKTsKIAorCQl0cmFjZTJfcmVnaW9uX2VudGVyKCJ0cmFuc3BvcnRfcHVzaCIsICJnZXRfcmVmc19saXN0Iiwgcik7CiAJCXJlbW90ZV9yZWZzID0gdHJhbnNwb3J0LT52dGFibGUtPmdldF9yZWZzX2xpc3QodHJhbnNwb3J0LCAxLAogCQkJCQkJCSAgICAgICAmcmVmX3ByZWZpeGVzKTsKKwkJdHJhY2UyX3JlZ2lvbl9sZWF2ZSgidHJhbnNwb3J0X3B1c2giLCAiZ2V0X3JlZnNfbGlzdCIsIHIpOwogCiAJCWFyZ3ZfYXJyYXlfY2xlYXIoJnJlZl9wcmVmaXhlcyk7CiAKQEAgLTExNzgsNiArMTE4NCw3IEBACiAJCQlzdHJ1Y3QgcmVmICpyZWYgPSByZW1vdGVfcmVmczsKIAkJCXN0cnVjdCBvaWRfYXJyYXkgY29tbWl0cyA9IE9JRF9BUlJBWV9JTklUOwogCisJCQl0cmFjZTJfcmVnaW9uX2VudGVyKCJ0cmFuc3BvcnRfcHVzaCIsICJwdXNoX3N1Ym1vZHVsZXMiLCByKTsKIAkJCWZvciAoOyByZWY7IHJlZiA9IHJlZi0+bmV4dCkKIAkJCQlpZiAoIWlzX251bGxfb2lkKCZyZWYtPm5ld19vaWQpKQogCQkJCQlvaWRfYXJyYXlfYXBwZW5kKCZjb21taXRzLApAQCAtMTE5MCw5ICsxMTk3LDExIEBACiAJCQkJCQkgICAgICB0cmFuc3BvcnQtPnB1c2hfb3B0aW9ucywKIAkJCQkJCSAgICAgIHByZXRlbmQpKSB7CiAJCQkJb2lkX2FycmF5X2NsZWFyKCZjb21taXRzKTsKKwkJCQl0cmFjZTJfcmVnaW9uX2xlYXZlKCJ0cmFuc3BvcnRfcHVzaCIsICJwdXNoX3N1Ym1vZHVsZXMiLCByKTsKIAkJCQlkaWUoXygiZmFpbGVkIHRvIHB1c2ggYWxsIG5lZWRlZCBzdWJtb2R1bGVzIikpOwogCQkJfQogCQkJb2lkX2FycmF5X2NsZWFyKCZjb21taXRzKTsKKwkJCXRyYWNlMl9yZWdpb25fbGVhdmUoInRyYW5zcG9ydF9wdXNoIiwgInB1c2hfc3VibW9kdWxlcyIsIHIpOwogCQl9CiAKIAkJaWYgKCgoZmxhZ3MgJiBUUkFOU1BPUlRfUkVDVVJTRV9TVUJNT0RVTEVTX0NIRUNLKSB8fApAQCAtMTIwMyw2ICsxMjEyLDcgQEAKIAkJCXN0cnVjdCBzdHJpbmdfbGlzdCBuZWVkc19wdXNoaW5nID0gU1RSSU5HX0xJU1RfSU5JVF9EVVA7CiAJCQlzdHJ1Y3Qgb2lkX2FycmF5IGNvbW1pdHMgPSBPSURfQVJSQVlfSU5JVDsKIAorCQkJdHJhY2UyX3JlZ2lvbl9lbnRlcigidHJhbnNwb3J0X3B1c2giLCAiY2hlY2tfc3VibW9kdWxlcyIsIHIpOwogCQkJZm9yICg7IHJlZjsgcmVmID0gcmVmLT5uZXh0KQogCQkJCWlmICghaXNfbnVsbF9vaWQoJnJlZi0+bmV3X29pZCkpCiAJCQkJCW9pZF9hcnJheV9hcHBlbmQoJmNvbW1pdHMsCkBAIC0xMjEzLDE1ICsxMjIzLDE5IEBACiAJCQkJCQkgICAgIHRyYW5zcG9ydC0+cmVtb3RlLT5uYW1lLAogCQkJCQkJICAgICAmbmVlZHNfcHVzaGluZykpIHsKIAkJCQlvaWRfYXJyYXlfY2xlYXIoJmNvbW1pdHMpOworCQkJCXRyYWNlMl9yZWdpb25fbGVhdmUoInRyYW5zcG9ydF9wdXNoIiwgImNoZWNrX3N1Ym1vZHVsZXMiLCByKTsKIAkJCQlkaWVfd2l0aF91bnB1c2hlZF9zdWJtb2R1bGVzKCZuZWVkc19wdXNoaW5nKTsKIAkJCX0KIAkJCXN0cmluZ19saXN0X2NsZWFyKCZuZWVkc19wdXNoaW5nLCAwKTsKIAkJCW9pZF9hcnJheV9jbGVhcigmY29tbWl0cyk7CisJCQl0cmFjZTJfcmVnaW9uX2xlYXZlKCJ0cmFuc3BvcnRfcHVzaCIsICJjaGVja19zdWJtb2R1bGVzIiwgcik7CiAJCX0KIAotCQlpZiAoIShmbGFncyAmIFRSQU5TUE9SVF9SRUNVUlNFX1NVQk1PRFVMRVNfT05MWSkpCisJCWlmICghKGZsYWdzICYgVFJBTlNQT1JUX1JFQ1VSU0VfU1VCTU9EVUxFU19PTkxZKSkgeworCQkJdHJhY2UyX3JlZ2lvbl9lbnRlcigidHJhbnNwb3J0X3B1c2giLCAicHVzaF9yZWZzIiwgcik7CiAJCQlwdXNoX3JldCA9IHRyYW5zcG9ydC0+dnRhYmxlLT5wdXNoX3JlZnModHJhbnNwb3J0LCByZW1vdGVfcmVmcywgZmxhZ3MpOwotCQllbHNlCisJCQl0cmFjZTJfcmVnaW9uX2xlYXZlKCJ0cmFuc3BvcnRfcHVzaCIsICJwdXNoX3JlZnMiLCByKTsKKwkJfSBlbHNlCiAJCQlwdXNoX3JldCA9IDA7CiAJCWVyciA9IHB1c2hfaGFkX2Vycm9ycyhyZW1vdGVfcmVmcyk7CiAJCXJldCA9IHB1c2hfcmV0IHwgZXJyOwpAQCAtMTI4NSwxNSArMTI5OSw2IEBACiAJc3RydWN0IHJlZiAqKmhlYWRzID0gTlVMTDsKIAlzdHJ1Y3QgcmVmICpybTsKIAotCWlmICghdHJhbnNwb3J0LT52dGFibGUtPmZldGNoX3dpdGhvdXRfbGlzdCkKLQkJLyoKLQkJICogU29tZSB0cmFuc3BvcnRzIChlLmcuIHRoZSBidWlsdC1pbiBidW5kbGUgdHJhbnNwb3J0IGFuZCB0aGUKLQkJICogdHJhbnNwb3J0IGhlbHBlciBpbnRlcmZhY2UpIGRvIG5vdCB3b3JrIHdoZW4gZmV0Y2hpbmcgaXMKLQkJICogZG9uZSBpbW1lZGlhdGVseSBhZnRlciB0cmFuc3BvcnQgY3JlYXRpb24uIExpc3QgdGhlIHJlbW90ZQotCQkgKiByZWZzIGFueXdheSAoaWYgbm90IGFscmVhZHkgbGlzdGVkKSBhcyBhIHdvcmthcm91bmQuCi0JCSAqLwotCQl0cmFuc3BvcnRfZ2V0X3JlbW90ZV9yZWZzKHRyYW5zcG9ydCwgTlVMTCk7Ci0KIAlmb3IgKHJtID0gcmVmczsgcm07IHJtID0gcm0tPm5leHQpIHsKIAkJbnJfcmVmcysrOwogCQlpZiAocm0tPnBlZXJfcmVmICYmCmRpZmYgLS1naXQgYS90cmFuc3BvcnQuaCBiL3RyYW5zcG9ydC5oCmluZGV4IDBiNWY3ODAuLmUwMTMxZGEgMTAwNjQ0Ci0tLSBhL3RyYW5zcG9ydC5oCisrKyBiL3RyYW5zcG9ydC5oCkBAIC0yMDgsNiArMjA4LDkgQEAKIC8qIEZpbHRlciBvYmplY3RzIGZvciBwYXJ0aWFsIGNsb25lIGFuZCBmZXRjaCAqLwogI2RlZmluZSBUUkFOU19PUFRfTElTVF9PQkpFQ1RTX0ZJTFRFUiAiZmlsdGVyIgogCisvKiBSZXF1ZXN0IGF0b21pYyAoYWxsLW9yLW5vdGhpbmcpIHVwZGF0ZXMgd2hlbiBwdXNoaW5nICovCisjZGVmaW5lIFRSQU5TX09QVF9BVE9NSUMgImF0b21pYyIKKwogLyoqCiAgKiBSZXR1cm5zIDAgaWYgdGhlIG9wdGlvbiB3YXMgdXNlZCwgbm9uLXplcm8gb3RoZXJ3aXNlLiBQcmludHMgYQogICogbWVzc2FnZSB0byBzdGRlcnIgaWYgdGhlIG9wdGlvbiBpcyBub3QgdXNlZC4KZGlmZiAtLWdpdCBhL3RyZWUtd2Fsay5jIGIvdHJlZS13YWxrLmMKaW5kZXggYzIwYjYyZi4uYmVhODE5ZCAxMDA2NDQKLS0tIGEvdHJlZS13YWxrLmMKKysrIGIvdHJlZS13YWxrLmMKQEAgLTE3MCw0MCArMTcwLDYxIEBACiAKIHZvaWQgc2V0dXBfdHJhdmVyc2VfaW5mbyhzdHJ1Y3QgdHJhdmVyc2VfaW5mbyAqaW5mbywgY29uc3QgY2hhciAqYmFzZSkKIHsKLQlpbnQgcGF0aGxlbiA9IHN0cmxlbihiYXNlKTsKKwlzaXplX3QgcGF0aGxlbiA9IHN0cmxlbihiYXNlKTsKIAlzdGF0aWMgc3RydWN0IHRyYXZlcnNlX2luZm8gZHVtbXk7CiAKIAltZW1zZXQoaW5mbywgMCwgc2l6ZW9mKCppbmZvKSk7CiAJaWYgKHBhdGhsZW4gJiYgYmFzZVtwYXRobGVuLTFdID09ICcvJykKIAkJcGF0aGxlbi0tOwogCWluZm8tPnBhdGhsZW4gPSBwYXRobGVuID8gcGF0aGxlbiArIDEgOiAwOwotCWluZm8tPm5hbWUucGF0aCA9IGJhc2U7Ci0JaW5mby0+bmFtZS5wYXRobGVuID0gcGF0aGxlbjsKLQlpZiAocGF0aGxlbikgewotCQloYXNoY3B5KGluZm8tPm5hbWUub2lkLmhhc2gsIChjb25zdCB1bnNpZ25lZCBjaGFyICopYmFzZSArIHBhdGhsZW4gKyAxKTsKKwlpbmZvLT5uYW1lID0gYmFzZTsKKwlpbmZvLT5uYW1lbGVuID0gcGF0aGxlbjsKKwlpZiAocGF0aGxlbikKIAkJaW5mby0+cHJldiA9ICZkdW1teTsKLQl9CiB9CiAKLWNoYXIgKm1ha2VfdHJhdmVyc2VfcGF0aChjaGFyICpwYXRoLCBjb25zdCBzdHJ1Y3QgdHJhdmVyc2VfaW5mbyAqaW5mbywgY29uc3Qgc3RydWN0IG5hbWVfZW50cnkgKm4pCitjaGFyICptYWtlX3RyYXZlcnNlX3BhdGgoY2hhciAqcGF0aCwgc2l6ZV90IHBhdGhsZW4sCisJCQkgY29uc3Qgc3RydWN0IHRyYXZlcnNlX2luZm8gKmluZm8sCisJCQkgY29uc3QgY2hhciAqbmFtZSwgc2l6ZV90IG5hbWVsZW4pCiB7Ci0JaW50IGxlbiA9IHRyZWVfZW50cnlfbGVuKG4pOwotCWludCBwYXRobGVuID0gaW5mby0+cGF0aGxlbjsKKwkvKiBBbHdheXMgcG9pbnRzIHRvIHRoZSBlbmQgb2YgdGhlIG5hbWUgd2UncmUgYWJvdXQgdG8gYWRkICovCisJc2l6ZV90IHBvcyA9IHN0X2FkZChpbmZvLT5wYXRobGVuLCBuYW1lbGVuKTsKIAotCXBhdGhbcGF0aGxlbiArIGxlbl0gPSAwOworCWlmIChwb3MgPj0gcGF0aGxlbikKKwkJQlVHKCJ0b28gc21hbGwgYnVmZmVyIHBhc3NlZCB0byBtYWtlX3RyYXZlcnNlX3BhdGgiKTsKKworCXBhdGhbcG9zXSA9IDA7CiAJZm9yICg7OykgewotCQltZW1jcHkocGF0aCArIHBhdGhsZW4sIG4tPnBhdGgsIGxlbik7Ci0JCWlmICghcGF0aGxlbikKKwkJaWYgKHBvcyA8IG5hbWVsZW4pCisJCQlCVUcoInRyYXZlcnNlX2luZm8gcGF0aGxlbiBkb2VzIG5vdCBtYXRjaCBzdHJpbmdzIik7CisJCXBvcyAtPSBuYW1lbGVuOworCQltZW1jcHkocGF0aCArIHBvcywgbmFtZSwgbmFtZWxlbik7CisKKwkJaWYgKCFwb3MpCiAJCQlicmVhazsKLQkJcGF0aFstLXBhdGhsZW5dID0gJy8nOwotCQluID0gJmluZm8tPm5hbWU7Ci0JCWxlbiA9IHRyZWVfZW50cnlfbGVuKG4pOworCQlwYXRoWy0tcG9zXSA9ICcvJzsKKworCQlpZiAoIWluZm8pCisJCQlCVUcoInRyYXZlcnNlX2luZm8gcmFuIG91dCBvZiBsaXN0IGl0ZW1zIik7CisJCW5hbWUgPSBpbmZvLT5uYW1lOworCQluYW1lbGVuID0gaW5mby0+bmFtZWxlbjsKIAkJaW5mbyA9IGluZm8tPnByZXY7Ci0JCXBhdGhsZW4gLT0gbGVuOwogCX0KIAlyZXR1cm4gcGF0aDsKIH0KIAordm9pZCBzdHJidWZfbWFrZV90cmF2ZXJzZV9wYXRoKHN0cnVjdCBzdHJidWYgKm91dCwKKwkJCSAgICAgICBjb25zdCBzdHJ1Y3QgdHJhdmVyc2VfaW5mbyAqaW5mbywKKwkJCSAgICAgICBjb25zdCBjaGFyICpuYW1lLCBzaXplX3QgbmFtZWxlbikKK3sKKwlzaXplX3QgbGVuID0gdHJhdmVyc2VfcGF0aF9sZW4oaW5mbywgbmFtZWxlbik7CisKKwlzdHJidWZfZ3JvdyhvdXQsIGxlbik7CisJbWFrZV90cmF2ZXJzZV9wYXRoKG91dC0+YnVmICsgb3V0LT5sZW4sIG91dC0+YWxsb2MgLSBvdXQtPmxlbiwKKwkJCSAgIGluZm8sIG5hbWUsIG5hbWVsZW4pOworCXN0cmJ1Zl9zZXRsZW4ob3V0LCBvdXQtPmxlbiArIGxlbik7Cit9CisKIHN0cnVjdCB0cmVlX2Rlc2Nfc2tpcCB7CiAJc3RydWN0IHRyZWVfZGVzY19za2lwICpwcmV2OwogCWNvbnN0IHZvaWQgKnB0cjsKQEAgLTQwMCwxMyArNDIxLDEyIEBACiAJCXR4W2ldLmQgPSB0W2ldOwogCiAJaWYgKGluZm8tPnByZXYpIHsKLQkJc3RyYnVmX2dyb3coJmJhc2UsIGluZm8tPnBhdGhsZW4pOwotCQltYWtlX3RyYXZlcnNlX3BhdGgoYmFzZS5idWYsIGluZm8tPnByZXYsICZpbmZvLT5uYW1lKTsKLQkJYmFzZS5idWZbaW5mby0+cGF0aGxlbi0xXSA9ICcvJzsKLQkJc3RyYnVmX3NldGxlbigmYmFzZSwgaW5mby0+cGF0aGxlbik7Ci0JCXRyYXZlcnNlX3BhdGggPSB4c3RybmR1cChiYXNlLmJ1ZiwgaW5mby0+cGF0aGxlbik7CisJCXN0cmJ1Zl9tYWtlX3RyYXZlcnNlX3BhdGgoJmJhc2UsIGluZm8tPnByZXYsCisJCQkJCSAgaW5mby0+bmFtZSwgaW5mby0+bmFtZWxlbik7CisJCXN0cmJ1Zl9hZGRjaCgmYmFzZSwgJy8nKTsKKwkJdHJhdmVyc2VfcGF0aCA9IHhzdHJuZHVwKGJhc2UuYnVmLCBiYXNlLmxlbik7CiAJfSBlbHNlIHsKLQkJdHJhdmVyc2VfcGF0aCA9IHhzdHJuZHVwKGluZm8tPm5hbWUucGF0aCwgaW5mby0+cGF0aGxlbik7CisJCXRyYXZlcnNlX3BhdGggPSB4c3RybmR1cChpbmZvLT5uYW1lLCBpbmZvLT5wYXRobGVuKTsKIAl9CiAJaW5mby0+dHJhdmVyc2VfcGF0aCA9IHRyYXZlcnNlX3BhdGg7CiAJZm9yICg7OykgewpkaWZmIC0tZ2l0IGEvdHJlZS13YWxrLmggYi90cmVlLXdhbGsuaAppbmRleCAyYTVkYjI5Li5hYmUyY2FmIDEwMDY0NAotLS0gYS90cmVlLXdhbGsuaAorKysgYi90cmVlLXdhbGsuaApAQCAtNTgsOCArNTgsMTEgQEAKIHN0cnVjdCB0cmF2ZXJzZV9pbmZvIHsKIAljb25zdCBjaGFyICp0cmF2ZXJzZV9wYXRoOwogCXN0cnVjdCB0cmF2ZXJzZV9pbmZvICpwcmV2OwotCXN0cnVjdCBuYW1lX2VudHJ5IG5hbWU7Ci0JaW50IHBhdGhsZW47CisJY29uc3QgY2hhciAqbmFtZTsKKwlzaXplX3QgbmFtZWxlbjsKKwl1bnNpZ25lZCBtb2RlOworCisJc2l6ZV90IHBhdGhsZW47CiAJc3RydWN0IHBhdGhzcGVjICpwYXRoc3BlYzsKIAogCXVuc2lnbmVkIGxvbmcgZGZfY29uZmxpY3RzOwpAQCAtNjksMTIgKzcyLDE3IEBACiB9OwogCiBpbnQgZ2V0X3RyZWVfZW50cnkoc3RydWN0IHJlcG9zaXRvcnkgKiwgY29uc3Qgc3RydWN0IG9iamVjdF9pZCAqLCBjb25zdCBjaGFyICosIHN0cnVjdCBvYmplY3RfaWQgKiwgdW5zaWduZWQgc2hvcnQgKik7Ci1jaGFyICptYWtlX3RyYXZlcnNlX3BhdGgoY2hhciAqcGF0aCwgY29uc3Qgc3RydWN0IHRyYXZlcnNlX2luZm8gKmluZm8sIGNvbnN0IHN0cnVjdCBuYW1lX2VudHJ5ICpuKTsKK2NoYXIgKm1ha2VfdHJhdmVyc2VfcGF0aChjaGFyICpwYXRoLCBzaXplX3QgcGF0aGxlbiwgY29uc3Qgc3RydWN0IHRyYXZlcnNlX2luZm8gKmluZm8sCisJCQkgY29uc3QgY2hhciAqbmFtZSwgc2l6ZV90IG5hbWVsZW4pOwordm9pZCBzdHJidWZfbWFrZV90cmF2ZXJzZV9wYXRoKHN0cnVjdCBzdHJidWYgKm91dCwKKwkJCSAgICAgICBjb25zdCBzdHJ1Y3QgdHJhdmVyc2VfaW5mbyAqaW5mbywKKwkJCSAgICAgICBjb25zdCBjaGFyICpuYW1lLCBzaXplX3QgbmFtZWxlbik7CiB2b2lkIHNldHVwX3RyYXZlcnNlX2luZm8oc3RydWN0IHRyYXZlcnNlX2luZm8gKmluZm8sIGNvbnN0IGNoYXIgKmJhc2UpOwogCi1zdGF0aWMgaW5saW5lIGludCB0cmF2ZXJzZV9wYXRoX2xlbihjb25zdCBzdHJ1Y3QgdHJhdmVyc2VfaW5mbyAqaW5mbywgY29uc3Qgc3RydWN0IG5hbWVfZW50cnkgKm4pCitzdGF0aWMgaW5saW5lIHNpemVfdCB0cmF2ZXJzZV9wYXRoX2xlbihjb25zdCBzdHJ1Y3QgdHJhdmVyc2VfaW5mbyAqaW5mbywKKwkJCQkgICAgICAgc2l6ZV90IG5hbWVsZW4pCiB7Ci0JcmV0dXJuIGluZm8tPnBhdGhsZW4gKyB0cmVlX2VudHJ5X2xlbihuKTsKKwlyZXR1cm4gc3RfYWRkKGluZm8tPnBhdGhsZW4sIG5hbWVsZW4pOwogfQogCiAvKiBpbiBnZW5lcmFsLCBwb3NpdGl2ZSBtZWFucyAia2luZCBvZiBpbnRlcmVzdGluZyIgKi8KZGlmZiAtLWdpdCBhL3RyZWUuYyBiL3RyZWUuYwppbmRleCA0NzIwOTQ1Li4xNDY2YmNjIDEwMDY0NAotLS0gYS90cmVlLmMKKysrIGIvdHJlZS5jCkBAIC0yNDQsMTkgKzI0NCw3IEBACiAKIHN0cnVjdCB0cmVlICpwYXJzZV90cmVlX2luZGlyZWN0KGNvbnN0IHN0cnVjdCBvYmplY3RfaWQgKm9pZCkKIHsKLQlzdHJ1Y3Qgb2JqZWN0ICpvYmogPSBwYXJzZV9vYmplY3QodGhlX3JlcG9zaXRvcnksIG9pZCk7Ci0JZG8gewotCQlpZiAoIW9iaikKLQkJCXJldHVybiBOVUxMOwotCQlpZiAob2JqLT50eXBlID09IE9CSl9UUkVFKQotCQkJcmV0dXJuIChzdHJ1Y3QgdHJlZSAqKSBvYmo7Ci0JCWVsc2UgaWYgKG9iai0+dHlwZSA9PSBPQkpfQ09NTUlUKQotCQkJb2JqID0gJihnZXRfY29tbWl0X3RyZWUoKChzdHJ1Y3QgY29tbWl0ICopb2JqKSktPm9iamVjdCk7Ci0JCWVsc2UgaWYgKG9iai0+dHlwZSA9PSBPQkpfVEFHKQotCQkJb2JqID0gKChzdHJ1Y3QgdGFnICopIG9iaiktPnRhZ2dlZDsKLQkJZWxzZQotCQkJcmV0dXJuIE5VTEw7Ci0JCWlmICghb2JqLT5wYXJzZWQpCi0JCQlwYXJzZV9vYmplY3QodGhlX3JlcG9zaXRvcnksICZvYmotPm9pZCk7Ci0JfSB3aGlsZSAoMSk7CisJc3RydWN0IHJlcG9zaXRvcnkgKnIgPSB0aGVfcmVwb3NpdG9yeTsKKwlzdHJ1Y3Qgb2JqZWN0ICpvYmogPSBwYXJzZV9vYmplY3Qociwgb2lkKTsKKwlyZXR1cm4gKHN0cnVjdCB0cmVlICopcmVwb19wZWVsX3RvX3R5cGUociwgTlVMTCwgMCwgb2JqLCBPQkpfVFJFRSk7CiB9CmRpZmYgLS1naXQgYS91bnBhY2stdHJlZXMuYyBiL3VucGFjay10cmVlcy5jCmluZGV4IDM1MzEzZDEuLmM2NDdhNWUgMTAwNjQ0Ci0tLSBhL3VucGFjay10cmVlcy5jCisrKyBiL3VucGFjay10cmVlcy5jCkBAIC0xMSwxMiArMTEsMTEgQEAKICNpbmNsdWRlICJyZWZzLmgiCiAjaW5jbHVkZSAiYXR0ci5oIgogI2luY2x1ZGUgInNwbGl0LWluZGV4LmgiCi0jaW5jbHVkZSAiZGlyLmgiCiAjaW5jbHVkZSAic3VibW9kdWxlLmgiCiAjaW5jbHVkZSAic3VibW9kdWxlLWNvbmZpZy5oIgogI2luY2x1ZGUgImZzbW9uaXRvci5oIgogI2luY2x1ZGUgIm9iamVjdC1zdG9yZS5oIgotI2luY2x1ZGUgImZldGNoLW9iamVjdC5oIgorI2luY2x1ZGUgInByb21pc29yLXJlbW90ZS5oIgogCiAvKgogICogRXJyb3IgbWVzc2FnZXMgZXhwZWN0ZWQgYnkgc2NyaXB0cyBvdXQgb2YgcGx1bWJpbmcgY29tbWFuZHMgc3VjaCBhcwpAQCAtMjc2LDkgKzI3NSw5IEBACiB9CiAKIC8qCi0gKiBQcmVmb3JtIHRoZSBsb2FkaW5nIG9mIHRoZSByZXBvc2l0b3J5J3MgZ2l0bW9kdWxlcyBmaWxlLiAgVGhpcyBmdW5jdGlvbiBpcworICogUGVyZm9ybSB0aGUgbG9hZGluZyBvZiB0aGUgcmVwb3NpdG9yeSdzIGdpdG1vZHVsZXMgZmlsZS4gIFRoaXMgZnVuY3Rpb24gaXMKICAqIHVzZWQgYnkgJ2NoZWNrX3VwZGF0ZSgpJyB0byBwZXJmb3JtIGxvYWRpbmcgb2YgdGhlIGdpdG1vZHVsZXMgZmlsZSBpbiB0d28KLSAqIGRpZmZlcm50IHNpdHVhdGlvbnM6CisgKiBkaWZmZXJlbnQgc2l0dWF0aW9uczoKICAqICgxKSBiZWZvcmUgcmVtb3ZpbmcgZW50cmllcyBmcm9tIHRoZSB3b3JraW5nIHRyZWUgaWYgdGhlIGdpdG1vZHVsZXMgZmlsZSBoYXMKICAqICAgICBiZWVuIG1hcmtlZCBmb3IgcmVtb3ZhbC4gIFRoaXMgc2l0dWF0aW9uIGlzIHNwZWNpZmllZCBieSAnc3RhdGUnID09IE5VTEwuCiAgKiAoMikgYmVmb3JlIGNoZWNraW5nIG91dCBlbnRyaWVzIHRvIHRoZSB3b3JraW5nIHRyZWUgaWYgdGhlIGdpdG1vZHVsZXMgZmlsZQpAQCAtNDAwLDcgKzM5OSw3IEBACiAJCWxvYWRfZ2l0bW9kdWxlc19maWxlKGluZGV4LCAmc3RhdGUpOwogCiAJZW5hYmxlX2RlbGF5ZWRfY2hlY2tvdXQoJnN0YXRlKTsKLQlpZiAocmVwb3NpdG9yeV9mb3JtYXRfcGFydGlhbF9jbG9uZSAmJiBvLT51cGRhdGUgJiYgIW8tPmRyeV9ydW4pIHsKKwlpZiAoaGFzX3Byb21pc29yX3JlbW90ZSgpICYmIG8tPnVwZGF0ZSAmJiAhby0+ZHJ5X3J1bikgewogCQkvKgogCQkgKiBQcmVmZXRjaCB0aGUgb2JqZWN0cyB0aGF0IGFyZSB0byBiZSBjaGVja2VkIG91dCBpbiB0aGUgbG9vcAogCQkgKiBiZWxvdy4KQEAgLTQxOSw4ICs0MTgsOCBAQAogCQkJb2lkX2FycmF5X2FwcGVuZCgmdG9fZmV0Y2gsICZjZS0+b2lkKTsKIAkJfQogCQlpZiAodG9fZmV0Y2gubnIpCi0JCQlmZXRjaF9vYmplY3RzKHJlcG9zaXRvcnlfZm9ybWF0X3BhcnRpYWxfY2xvbmUsCi0JCQkJICAgICAgdG9fZmV0Y2gub2lkLCB0b19mZXRjaC5ucik7CisJCQlwcm9taXNvcl9yZW1vdGVfZ2V0X2RpcmVjdCh0aGVfcmVwb3NpdG9yeSwKKwkJCQkJCSAgIHRvX2ZldGNoLm9pZCwgdG9fZmV0Y2gubnIpOwogCQlvaWRfYXJyYXlfY2xlYXIoJnRvX2ZldGNoKTsKIAl9CiAJZm9yIChpID0gMDsgaSA8IGluZGV4LT5jYWNoZV9ucjsgaSsrKSB7CkBAIC02MzIsNyArNjMxLDcgQEAKIAlyZXR1cm4gcmV0OwogfQogCi1zdGF0aWMgaW50IGZpbmRfY2FjaGVfcG9zKHN0cnVjdCB0cmF2ZXJzZV9pbmZvICosIGNvbnN0IHN0cnVjdCBuYW1lX2VudHJ5ICopOworc3RhdGljIGludCBmaW5kX2NhY2hlX3BvcyhzdHJ1Y3QgdHJhdmVyc2VfaW5mbyAqLCBjb25zdCBjaGFyICpwLCBzaXplX3QgbGVuKTsKIAogc3RhdGljIHZvaWQgcmVzdG9yZV9jYWNoZV9ib3R0b20oc3RydWN0IHRyYXZlcnNlX2luZm8gKmluZm8sIGludCBib3R0b20pCiB7CkBAIC02NTEsNyArNjUwLDcgQEAKIAlpZiAoby0+ZGlmZl9pbmRleF9jYWNoZWQpCiAJCXJldHVybiAwOwogCXJldCA9IG8tPmNhY2hlX2JvdHRvbTsKLQlwb3MgPSBmaW5kX2NhY2hlX3BvcyhpbmZvLT5wcmV2LCAmaW5mby0+bmFtZSk7CisJcG9zID0gZmluZF9jYWNoZV9wb3MoaW5mby0+cHJldiwgaW5mby0+bmFtZSwgaW5mby0+bmFtZWxlbik7CiAKIAlpZiAocG9zIDwgLTEpCiAJCW8tPmNhY2hlX2JvdHRvbSA9IC0yIC0gcG9zOwpAQCAtNjg2LDIxICs2ODUsMTkgQEAKIAkJCQkgICAgICBzdHJ1Y3QgdHJhdmVyc2VfaW5mbyAqaW5mbykKIHsKIAlzdHJ1Y3QgdW5wYWNrX3RyZWVzX29wdGlvbnMgKm8gPSBpbmZvLT5kYXRhOwotCWludCBsZW4gPSB0cmF2ZXJzZV9wYXRoX2xlbihpbmZvLCBuYW1lcyk7Ci0JY2hhciAqbmFtZSA9IHhtYWxsb2MobGVuICsgMSAvKiBzbGFzaCAqLyArIDEgLyogTlVMICovKTsKKwlzdHJ1Y3Qgc3RyYnVmIG5hbWUgPSBTVFJCVUZfSU5JVDsKIAlpbnQgcG9zOwogCi0JbWFrZV90cmF2ZXJzZV9wYXRoKG5hbWUsIGluZm8sIG5hbWVzKTsKLQluYW1lW2xlbisrXSA9ICcvJzsKLQluYW1lW2xlbl0gPSAnXDAnOwotCXBvcyA9IGluZGV4X25hbWVfcG9zKG8tPnNyY19pbmRleCwgbmFtZSwgbGVuKTsKKwlzdHJidWZfbWFrZV90cmF2ZXJzZV9wYXRoKCZuYW1lLCBpbmZvLCBuYW1lcy0+cGF0aCwgbmFtZXMtPnBhdGhsZW4pOworCXN0cmJ1Zl9hZGRjaCgmbmFtZSwgJy8nKTsKKwlwb3MgPSBpbmRleF9uYW1lX3BvcyhvLT5zcmNfaW5kZXgsIG5hbWUuYnVmLCBuYW1lLmxlbik7CiAJaWYgKHBvcyA+PSAwKQogCQlCVUcoIlRoaXMgaXMgYSBkaXJlY3RvcnkgYW5kIHNob3VsZCBub3QgZXhpc3QgaW4gaW5kZXgiKTsKIAlwb3MgPSAtcG9zIC0gMTsKLQlpZiAoIXN0YXJ0c193aXRoKG8tPnNyY19pbmRleC0+Y2FjaGVbcG9zXS0+bmFtZSwgbmFtZSkgfHwKLQkgICAgKHBvcyA+IDAgJiYgc3RhcnRzX3dpdGgoby0+c3JjX2luZGV4LT5jYWNoZVtwb3MtMV0tPm5hbWUsIG5hbWUpKSkKKwlpZiAoIXN0YXJ0c193aXRoKG8tPnNyY19pbmRleC0+Y2FjaGVbcG9zXS0+bmFtZSwgbmFtZS5idWYpIHx8CisJICAgIChwb3MgPiAwICYmIHN0YXJ0c193aXRoKG8tPnNyY19pbmRleC0+Y2FjaGVbcG9zLTFdLT5uYW1lLCBuYW1lLmJ1ZikpKQogCQlCVUcoInBvcyBtdXN0IHBvaW50IGF0IHRoZSBmaXJzdCBlbnRyeSBpbiB0aGlzIGRpcmVjdG9yeSIpOwotCWZyZWUobmFtZSk7CisJc3RyYnVmX3JlbGVhc2UoJm5hbWUpOwogCXJldHVybiBwb3M7CiB9CiAKQEAgLTgxMSw4ICs4MDgsMTAgQEAKIAluZXdpbmZvID0gKmluZm87CiAJbmV3aW5mby5wcmV2ID0gaW5mbzsKIAluZXdpbmZvLnBhdGhzcGVjID0gaW5mby0+cGF0aHNwZWM7Ci0JbmV3aW5mby5uYW1lID0gKnA7Ci0JbmV3aW5mby5wYXRobGVuICs9IHRyZWVfZW50cnlfbGVuKHApICsgMTsKKwluZXdpbmZvLm5hbWUgPSBwLT5wYXRoOworCW5ld2luZm8ubmFtZWxlbiA9IHAtPnBhdGhsZW47CisJbmV3aW5mby5tb2RlID0gcC0+bW9kZTsKKwluZXdpbmZvLnBhdGhsZW4gPSBzdF9hZGQzKG5ld2luZm8ucGF0aGxlbiwgdHJlZV9lbnRyeV9sZW4ocCksIDEpOwogCW5ld2luZm8uZGZfY29uZmxpY3RzIHw9IGRmX2NvbmZsaWN0czsKIAogCS8qCkBAIC04NjMsMTQgKzg2MiwxOCBAQAogICogaXRzZWxmIC0gdGhlIGNhbGxlciBuZWVkcyB0byBkbyB0aGUgZmluYWwgY2hlY2sgZm9yIHRoZSBjYWNoZQogICogZW50cnkgaGF2aW5nIG1vcmUgZGF0YSBhdCB0aGUgZW5kIQogICovCi1zdGF0aWMgaW50IGRvX2NvbXBhcmVfZW50cnlfcGllY2V3aXNlKGNvbnN0IHN0cnVjdCBjYWNoZV9lbnRyeSAqY2UsIGNvbnN0IHN0cnVjdCB0cmF2ZXJzZV9pbmZvICppbmZvLCBjb25zdCBzdHJ1Y3QgbmFtZV9lbnRyeSAqbikKK3N0YXRpYyBpbnQgZG9fY29tcGFyZV9lbnRyeV9waWVjZXdpc2UoY29uc3Qgc3RydWN0IGNhY2hlX2VudHJ5ICpjZSwKKwkJCQkgICAgICBjb25zdCBzdHJ1Y3QgdHJhdmVyc2VfaW5mbyAqaW5mbywKKwkJCQkgICAgICBjb25zdCBjaGFyICpuYW1lLCBzaXplX3QgbmFtZWxlbiwKKwkJCQkgICAgICB1bnNpZ25lZCBtb2RlKQogewotCWludCBsZW4sIHBhdGhsZW4sIGNlX2xlbjsKKwlpbnQgcGF0aGxlbiwgY2VfbGVuOwogCWNvbnN0IGNoYXIgKmNlX25hbWU7CiAKIAlpZiAoaW5mby0+cHJldikgewogCQlpbnQgY21wID0gZG9fY29tcGFyZV9lbnRyeV9waWVjZXdpc2UoY2UsIGluZm8tPnByZXYsCi0JCQkJCQkgICAgICZpbmZvLT5uYW1lKTsKKwkJCQkJCSAgICAgaW5mby0+bmFtZSwgaW5mby0+bmFtZWxlbiwKKwkJCQkJCSAgICAgaW5mby0+bW9kZSk7CiAJCWlmIChjbXApCiAJCQlyZXR1cm4gY21wOwogCX0KQEAgLTg4NCwxNSArODg3LDE1IEBACiAJY2VfbGVuIC09IHBhdGhsZW47CiAJY2VfbmFtZSA9IGNlLT5uYW1lICsgcGF0aGxlbjsKIAotCWxlbiA9IHRyZWVfZW50cnlfbGVuKG4pOwotCXJldHVybiBkZl9uYW1lX2NvbXBhcmUoY2VfbmFtZSwgY2VfbGVuLCBTX0lGUkVHLCBuLT5wYXRoLCBsZW4sIG4tPm1vZGUpOworCXJldHVybiBkZl9uYW1lX2NvbXBhcmUoY2VfbmFtZSwgY2VfbGVuLCBTX0lGUkVHLCBuYW1lLCBuYW1lbGVuLCBtb2RlKTsKIH0KIAogc3RhdGljIGludCBkb19jb21wYXJlX2VudHJ5KGNvbnN0IHN0cnVjdCBjYWNoZV9lbnRyeSAqY2UsCiAJCQkgICAgY29uc3Qgc3RydWN0IHRyYXZlcnNlX2luZm8gKmluZm8sCi0JCQkgICAgY29uc3Qgc3RydWN0IG5hbWVfZW50cnkgKm4pCisJCQkgICAgY29uc3QgY2hhciAqbmFtZSwgc2l6ZV90IG5hbWVsZW4sCisJCQkgICAgdW5zaWduZWQgbW9kZSkKIHsKLQlpbnQgbGVuLCBwYXRobGVuLCBjZV9sZW47CisJaW50IHBhdGhsZW4sIGNlX2xlbjsKIAljb25zdCBjaGFyICpjZV9uYW1lOwogCWludCBjbXA7CiAKQEAgLTkwMiw3ICs5MDUsNyBAQAogCSAqIGl0IGlzIHF1aWNrZXIgdG8gdXNlIHRoZSBwcmVjb21wdXRlZCB2ZXJzaW9uLgogCSAqLwogCWlmICghaW5mby0+dHJhdmVyc2VfcGF0aCkKLQkJcmV0dXJuIGRvX2NvbXBhcmVfZW50cnlfcGllY2V3aXNlKGNlLCBpbmZvLCBuKTsKKwkJcmV0dXJuIGRvX2NvbXBhcmVfZW50cnlfcGllY2V3aXNlKGNlLCBpbmZvLCBuYW1lLCBuYW1lbGVuLCBtb2RlKTsKIAogCWNtcCA9IHN0cm5jbXAoY2UtPm5hbWUsIGluZm8tPnRyYXZlcnNlX3BhdGgsIGluZm8tPnBhdGhsZW4pOwogCWlmIChjbXApCkBAIC05MTcsMTMgKzkyMCwxMiBAQAogCWNlX2xlbiAtPSBwYXRobGVuOwogCWNlX25hbWUgPSBjZS0+bmFtZSArIHBhdGhsZW47CiAKLQlsZW4gPSB0cmVlX2VudHJ5X2xlbihuKTsKLQlyZXR1cm4gZGZfbmFtZV9jb21wYXJlKGNlX25hbWUsIGNlX2xlbiwgU19JRlJFRywgbi0+cGF0aCwgbGVuLCBuLT5tb2RlKTsKKwlyZXR1cm4gZGZfbmFtZV9jb21wYXJlKGNlX25hbWUsIGNlX2xlbiwgU19JRlJFRywgbmFtZSwgbmFtZWxlbiwgbW9kZSk7CiB9CiAKIHN0YXRpYyBpbnQgY29tcGFyZV9lbnRyeShjb25zdCBzdHJ1Y3QgY2FjaGVfZW50cnkgKmNlLCBjb25zdCBzdHJ1Y3QgdHJhdmVyc2VfaW5mbyAqaW5mbywgY29uc3Qgc3RydWN0IG5hbWVfZW50cnkgKm4pCiB7Ci0JaW50IGNtcCA9IGRvX2NvbXBhcmVfZW50cnkoY2UsIGluZm8sIG4pOworCWludCBjbXAgPSBkb19jb21wYXJlX2VudHJ5KGNlLCBpbmZvLCBuLT5wYXRoLCBuLT5wYXRobGVuLCBuLT5tb2RlKTsKIAlpZiAoY21wKQogCQlyZXR1cm4gY21wOwogCkBAIC05MzEsNyArOTMzLDcgQEAKIAkgKiBFdmVuIGlmIHRoZSBiZWdpbm5pbmcgY29tcGFyZWQgaWRlbnRpY2FsbHksIHRoZSBjZSBzaG91bGQKIAkgKiBjb21wYXJlIGFzIGJpZ2dlciB0aGFuIGEgZGlyZWN0b3J5IGxlYWRpbmcgdXAgdG8gaXQhCiAJICovCi0JcmV0dXJuIGNlX25hbWVsZW4oY2UpID4gdHJhdmVyc2VfcGF0aF9sZW4oaW5mbywgbik7CisJcmV0dXJuIGNlX25hbWVsZW4oY2UpID4gdHJhdmVyc2VfcGF0aF9sZW4oaW5mbywgdHJlZV9lbnRyeV9sZW4obikpOwogfQogCiBzdGF0aWMgaW50IGNlX2luX3RyYXZlcnNlX3BhdGgoY29uc3Qgc3RydWN0IGNhY2hlX2VudHJ5ICpjZSwKQEAgLTkzOSw3ICs5NDEsOCBAQAogewogCWlmICghaW5mby0+cHJldikKIAkJcmV0dXJuIDE7Ci0JaWYgKGRvX2NvbXBhcmVfZW50cnkoY2UsIGluZm8tPnByZXYsICZpbmZvLT5uYW1lKSkKKwlpZiAoZG9fY29tcGFyZV9lbnRyeShjZSwgaW5mby0+cHJldiwKKwkJCSAgICAgaW5mby0+bmFtZSwgaW5mby0+bmFtZWxlbiwgaW5mby0+bW9kZSkpCiAJCXJldHVybiAwOwogCS8qCiAJICogSWYgY2UgKGJsb2IpIGlzIHRoZSBzYW1lIG5hbWUgYXMgdGhlIHBhdGggKHdoaWNoIGlzIGEgdHJlZQpAQCAtOTU0LDcgKzk1Nyw3IEBACiAJc3RydWN0IGluZGV4X3N0YXRlICppc3RhdGUsCiAJaW50IGlzX3RyYW5zaWVudCkKIHsKLQlpbnQgbGVuID0gdHJhdmVyc2VfcGF0aF9sZW4oaW5mbywgbik7CisJc2l6ZV90IGxlbiA9IHRyYXZlcnNlX3BhdGhfbGVuKGluZm8sIHRyZWVfZW50cnlfbGVuKG4pKTsKIAlzdHJ1Y3QgY2FjaGVfZW50cnkgKmNlID0KIAkJaXNfdHJhbnNpZW50ID8KIAkJbWFrZV9lbXB0eV90cmFuc2llbnRfY2FjaGVfZW50cnkobGVuKSA6CkBAIC05NjQsNyArOTY3LDggQEAKIAljZS0+Y2VfZmxhZ3MgPSBjcmVhdGVfY2VfZmxhZ3Moc3RhZ2UpOwogCWNlLT5jZV9uYW1lbGVuID0gbGVuOwogCW9pZGNweSgmY2UtPm9pZCwgJm4tPm9pZCk7Ci0JbWFrZV90cmF2ZXJzZV9wYXRoKGNlLT5uYW1lLCBpbmZvLCBuKTsKKwkvKiBsZW4rMSBiZWNhdXNlIHRoZSBjYWNoZV9lbnRyeSBhbGxvY2F0ZXMgc3BhY2UgZm9yIE5VTCAqLworCW1ha2VfdHJhdmVyc2VfcGF0aChjZS0+bmFtZSwgbGVuICsgMSwgaW5mbywgbi0+cGF0aCwgbi0+cGF0aGxlbik7CiAKIAlyZXR1cm4gY2U7CiB9CkBAIC0xMDU3LDEzICsxMDYxLDEyIEBACiAgKiB0aGUgZGlyZWN0b3J5LgogICovCiBzdGF0aWMgaW50IGZpbmRfY2FjaGVfcG9zKHN0cnVjdCB0cmF2ZXJzZV9pbmZvICppbmZvLAotCQkJICBjb25zdCBzdHJ1Y3QgbmFtZV9lbnRyeSAqcCkKKwkJCSAgY29uc3QgY2hhciAqcCwgc2l6ZV90IHBfbGVuKQogewogCWludCBwb3M7CiAJc3RydWN0IHVucGFja190cmVlc19vcHRpb25zICpvID0gaW5mby0+ZGF0YTsKIAlzdHJ1Y3QgaW5kZXhfc3RhdGUgKmluZGV4ID0gby0+c3JjX2luZGV4OwogCWludCBwZnhsZW4gPSBpbmZvLT5wYXRobGVuOwotCWludCBwX2xlbiA9IHRyZWVfZW50cnlfbGVuKHApOwogCiAJZm9yIChwb3MgPSBvLT5jYWNoZV9ib3R0b207IHBvcyA8IGluZGV4LT5jYWNoZV9ucjsgcG9zKyspIHsKIAkJY29uc3Qgc3RydWN0IGNhY2hlX2VudHJ5ICpjZSA9IGluZGV4LT5jYWNoZVtwb3NdOwpAQCAtMTA5OSw3ICsxMTAyLDcgQEAKIAkJCWNlX2xlbiA9IGNlX3NsYXNoIC0gY2VfbmFtZTsKIAkJZWxzZQogCQkJY2VfbGVuID0gY2VfbmFtZWxlbihjZSkgLSBwZnhsZW47Ci0JCWNtcCA9IG5hbWVfY29tcGFyZShwLT5wYXRoLCBwX2xlbiwgY2VfbmFtZSwgY2VfbGVuKTsKKwkJY21wID0gbmFtZV9jb21wYXJlKHAsIHBfbGVuLCBjZV9uYW1lLCBjZV9sZW4pOwogCQkvKgogCQkgKiBFeGFjdCBtYXRjaDsgaWYgd2UgaGF2ZSBhIGRpcmVjdG9yeSB3ZSBuZWVkIHRvCiAJCSAqIGRlbGF5IHJldHVybmluZyBpdC4KQEAgLTExMTQsNyArMTExNyw3IEBACiAJCSAqIEUuZy4gIGNlX25hbWUgPT0gInQtaSIsIGFuZCBwLT5wYXRoID09ICJ0Ijsgd2UgbWF5CiAJCSAqIGhhdmUgInQvYSIgaW4gdGhlIGluZGV4LgogCQkgKi8KLQkJaWYgKHBfbGVuIDwgY2VfbGVuICYmICFtZW1jbXAoY2VfbmFtZSwgcC0+cGF0aCwgcF9sZW4pICYmCisJCWlmIChwX2xlbiA8IGNlX2xlbiAmJiAhbWVtY21wKGNlX25hbWUsIHAsIHBfbGVuKSAmJgogCQkgICAgY2VfbmFtZVtwX2xlbl0gPCAnLycpCiAJCQljb250aW51ZTsgLyoga2VlcCBsb29raW5nICovCiAJCWJyZWFrOwpAQCAtMTEyNSw3ICsxMTI4LDcgQEAKIHN0YXRpYyBzdHJ1Y3QgY2FjaGVfZW50cnkgKmZpbmRfY2FjaGVfZW50cnkoc3RydWN0IHRyYXZlcnNlX2luZm8gKmluZm8sCiAJCQkJCSAgICBjb25zdCBzdHJ1Y3QgbmFtZV9lbnRyeSAqcCkKIHsKLQlpbnQgcG9zID0gZmluZF9jYWNoZV9wb3MoaW5mbywgcCk7CisJaW50IHBvcyA9IGZpbmRfY2FjaGVfcG9zKGluZm8sIHAtPnBhdGgsIHAtPnBhdGhsZW4pOwogCXN0cnVjdCB1bnBhY2tfdHJlZXNfb3B0aW9ucyAqbyA9IGluZm8tPmRhdGE7CiAKIAlpZiAoMCA8PSBwb3MpCkBAIC0xMTM4LDEwICsxMTQxLDEwIEBACiB7CiAJaWYgKGluZm8tPnByZXYpIHsKIAkJZGVidWdfcGF0aChpbmZvLT5wcmV2KTsKLQkJaWYgKCppbmZvLT5wcmV2LT5uYW1lLnBhdGgpCisJCWlmICgqaW5mby0+cHJldi0+bmFtZSkKIAkJCXB1dGNoYXIoJy8nKTsKIAl9Ci0JcHJpbnRmKCIlcyIsIGluZm8tPm5hbWUucGF0aCk7CisJcHJpbnRmKCIlcyIsIGluZm8tPm5hbWUpOwogfQogCiBzdGF0aWMgdm9pZCBkZWJ1Z19uYW1lX2VudHJ5KGludCBpLCBzdHJ1Y3QgbmFtZV9lbnRyeSAqbikKQEAgLTEyNjUsNyArMTI2OCw4IEBACiAJCQkgICAgc3RydWN0IGNhY2hlX2VudHJ5ICoqY2FjaGUsIGludCBuciwKIAkJCSAgICBzdHJ1Y3Qgc3RyYnVmICpwcmVmaXgsCiAJCQkgICAgaW50IHNlbGVjdF9tYXNrLCBpbnQgY2xlYXJfbWFzaywKLQkJCSAgICBzdHJ1Y3QgZXhjbHVkZV9saXN0ICplbCwgaW50IGRlZnZhbCk7CisJCQkgICAgc3RydWN0IHBhdHRlcm5fbGlzdCAqcGwsCisJCQkgICAgZW51bSBwYXR0ZXJuX21hdGNoX3Jlc3VsdCBkZWZhdWx0X21hdGNoKTsKIAogLyogV2hvbGUgZGlyZWN0b3J5IG1hdGNoaW5nICovCiBzdGF0aWMgaW50IGNsZWFyX2NlX2ZsYWdzX2RpcihzdHJ1Y3QgaW5kZXhfc3RhdGUgKmlzdGF0ZSwKQEAgLTEyNzMsMTkgKzEyNzcsMjEgQEAKIAkJCSAgICAgIHN0cnVjdCBzdHJidWYgKnByZWZpeCwKIAkJCSAgICAgIGNoYXIgKmJhc2VuYW1lLAogCQkJICAgICAgaW50IHNlbGVjdF9tYXNrLCBpbnQgY2xlYXJfbWFzaywKLQkJCSAgICAgIHN0cnVjdCBleGNsdWRlX2xpc3QgKmVsLCBpbnQgZGVmdmFsKQorCQkJICAgICAgc3RydWN0IHBhdHRlcm5fbGlzdCAqcGwsCisJCQkgICAgICBlbnVtIHBhdHRlcm5fbWF0Y2hfcmVzdWx0IGRlZmF1bHRfbWF0Y2gpCiB7CiAJc3RydWN0IGNhY2hlX2VudHJ5ICoqY2FjaGVfZW5kOwogCWludCBkdHlwZSA9IERUX0RJUjsKLQlpbnQgcmV0ID0gaXNfZXhjbHVkZWRfZnJvbV9saXN0KHByZWZpeC0+YnVmLCBwcmVmaXgtPmxlbiwKLQkJCQkJYmFzZW5hbWUsICZkdHlwZSwgZWwsIGlzdGF0ZSk7CiAJaW50IHJjOworCWVudW0gcGF0dGVybl9tYXRjaF9yZXN1bHQgcmV0OworCXJldCA9IHBhdGhfbWF0Y2hlc19wYXR0ZXJuX2xpc3QocHJlZml4LT5idWYsIHByZWZpeC0+bGVuLAorCQkJCQliYXNlbmFtZSwgJmR0eXBlLCBwbCwgaXN0YXRlKTsKIAogCXN0cmJ1Zl9hZGRjaChwcmVmaXgsICcvJyk7CiAKIAkvKiBJZiB1bmRlY2lkZWQsIHVzZSBtYXRjaGluZyByZXN1bHQgb2YgcGFyZW50IGRpciBpbiBkZWZ2YWwgKi8KLQlpZiAocmV0IDwgMCkKLQkJcmV0ID0gZGVmdmFsOworCWlmIChyZXQgPT0gVU5ERUNJREVEKQorCQlyZXQgPSBkZWZhdWx0X21hdGNoOwogCiAJZm9yIChjYWNoZV9lbmQgPSBjYWNoZTsgY2FjaGVfZW5kICE9IGNhY2hlICsgbnI7IGNhY2hlX2VuZCsrKSB7CiAJCXN0cnVjdCBjYWNoZV9lbnRyeSAqY2UgPSAqY2FjaGVfZW5kOwpAQCAtMTI5NCwyMyArMTMwMCwyMyBAQAogCX0KIAogCS8qCi0JICogVE9ETzogY2hlY2sgZWwsIGlmIHRoZXJlIGFyZSBubyBwYXR0ZXJucyB0aGF0IG1heSBjb25mbGljdAorCSAqIFRPRE86IGNoZWNrIHBsLCBpZiB0aGVyZSBhcmUgbm8gcGF0dGVybnMgdGhhdCBtYXkgY29uZmxpY3QKIAkgKiB3aXRoIHJldCAoaW93LCB3ZSBrbm93IGluIGFkdmFuY2UgdGhlIGluY2wvZXhjbAogCSAqIGRlY2lzaW9uIGZvciB0aGUgZW50aXJlIGRpcmVjdG9yeSksIGNsZWFyIGZsYWcgaGVyZSB3aXRob3V0CiAJICogY2FsbGluZyBjbGVhcl9jZV9mbGFnc18xKCkuIFRoYXQgZnVuY3Rpb24gd2lsbCBjYWxsCi0JICogdGhlIGV4cGVuc2l2ZSBpc19leGNsdWRlZF9mcm9tX2xpc3QoKSBvbiBldmVyeSBlbnRyeS4KKwkgKiB0aGUgZXhwZW5zaXZlIHBhdGhfbWF0Y2hlc19wYXR0ZXJuX2xpc3QoKSBvbiBldmVyeSBlbnRyeS4KIAkgKi8KIAlyYyA9IGNsZWFyX2NlX2ZsYWdzXzEoaXN0YXRlLCBjYWNoZSwgY2FjaGVfZW5kIC0gY2FjaGUsCiAJCQkgICAgICBwcmVmaXgsCiAJCQkgICAgICBzZWxlY3RfbWFzaywgY2xlYXJfbWFzaywKLQkJCSAgICAgIGVsLCByZXQpOworCQkJICAgICAgcGwsIHJldCk7CiAJc3RyYnVmX3NldGxlbihwcmVmaXgsIHByZWZpeC0+bGVuIC0gMSk7CiAJcmV0dXJuIHJjOwogfQogCiAvKgogICogVHJhdmVyc2UgdGhlIGluZGV4LCBmaW5kIGV2ZXJ5IGVudHJ5IHRoYXQgbWF0Y2hlcyBhY2NvcmRpbmcgdG8KLSAqIG8tPmVsLiBEbyAiY2VfZmxhZ3MgJj0gfmNsZWFyX21hc2siIG9uIHRob3NlIGVudHJpZXMuIFJldHVybiB0aGUKKyAqIG8tPnBsLiBEbyAiY2VfZmxhZ3MgJj0gfmNsZWFyX21hc2siIG9uIHRob3NlIGVudHJpZXMuIFJldHVybiB0aGUKICAqIG51bWJlciBvZiB0cmF2ZXJzZWQgZW50cmllcy4KICAqCiAgKiBJZiBzZWxlY3RfbWFzayBpcyBub24temVybywgb25seSBlbnRyaWVzIHdob3NlIGNlX2ZsYWdzIGhhcyBvbiBvZgpAQCAtMTMyNyw3ICsxMzMzLDggQEAKIAkJCSAgICBzdHJ1Y3QgY2FjaGVfZW50cnkgKipjYWNoZSwgaW50IG5yLAogCQkJICAgIHN0cnVjdCBzdHJidWYgKnByZWZpeCwKIAkJCSAgICBpbnQgc2VsZWN0X21hc2ssIGludCBjbGVhcl9tYXNrLAotCQkJICAgIHN0cnVjdCBleGNsdWRlX2xpc3QgKmVsLCBpbnQgZGVmdmFsKQorCQkJICAgIHN0cnVjdCBwYXR0ZXJuX2xpc3QgKnBsLAorCQkJICAgIGVudW0gcGF0dGVybl9tYXRjaF9yZXN1bHQgZGVmYXVsdF9tYXRjaCkKIHsKIAlzdHJ1Y3QgY2FjaGVfZW50cnkgKipjYWNoZV9lbmQgPSBjYWNoZSArIG5yOwogCkBAIC0xMzM4LDcgKzEzNDUsOCBAQAogCXdoaWxlKGNhY2hlICE9IGNhY2hlX2VuZCkgewogCQlzdHJ1Y3QgY2FjaGVfZW50cnkgKmNlID0gKmNhY2hlOwogCQljb25zdCBjaGFyICpuYW1lLCAqc2xhc2g7Ci0JCWludCBsZW4sIGR0eXBlLCByZXQ7CisJCWludCBsZW4sIGR0eXBlOworCQllbnVtIHBhdHRlcm5fbWF0Y2hfcmVzdWx0IHJldDsKIAogCQlpZiAoc2VsZWN0X21hc2sgJiYgIShjZS0+Y2VfZmxhZ3MgJiBzZWxlY3RfbWFzaykpIHsKIAkJCWNhY2hlKys7CkBAIC0xMzYyLDcgKzEzNzAsNyBAQAogCQkJCQkJICAgICAgIHByZWZpeCwKIAkJCQkJCSAgICAgICBwcmVmaXgtPmJ1ZiArIHByZWZpeC0+bGVuIC0gbGVuLAogCQkJCQkJICAgICAgIHNlbGVjdF9tYXNrLCBjbGVhcl9tYXNrLAotCQkJCQkJICAgICAgIGVsLCBkZWZ2YWwpOworCQkJCQkJICAgICAgIHBsLCBkZWZhdWx0X21hdGNoKTsKIAogCQkJLyogY2xlYXJfY19mX2RpciBlYXRzIGEgd2hvbGUgZGlyIGFscmVhZHk/ICovCiAJCQlpZiAocHJvY2Vzc2VkKSB7CkBAIC0xMzc0LDE4ICsxMzgyLDIwIEBACiAJCQlzdHJidWZfYWRkY2gocHJlZml4LCAnLycpOwogCQkJY2FjaGUgKz0gY2xlYXJfY2VfZmxhZ3NfMShpc3RhdGUsIGNhY2hlLCBjYWNoZV9lbmQgLSBjYWNoZSwKIAkJCQkJCSAgcHJlZml4LAotCQkJCQkJICBzZWxlY3RfbWFzaywgY2xlYXJfbWFzaywgZWwsIGRlZnZhbCk7CisJCQkJCQkgIHNlbGVjdF9tYXNrLCBjbGVhcl9tYXNrLCBwbCwKKwkJCQkJCSAgZGVmYXVsdF9tYXRjaCk7CiAJCQlzdHJidWZfc2V0bGVuKHByZWZpeCwgcHJlZml4LT5sZW4gLSBsZW4gLSAxKTsKIAkJCWNvbnRpbnVlOwogCQl9CiAKIAkJLyogTm9uLWRpcmVjdG9yeSAqLwogCQlkdHlwZSA9IGNlX3RvX2R0eXBlKGNlKTsKLQkJcmV0ID0gaXNfZXhjbHVkZWRfZnJvbV9saXN0KGNlLT5uYW1lLCBjZV9uYW1lbGVuKGNlKSwKLQkJCQkJICAgIG5hbWUsICZkdHlwZSwgZWwsIGlzdGF0ZSk7Ci0JCWlmIChyZXQgPCAwKQotCQkJcmV0ID0gZGVmdmFsOwotCQlpZiAocmV0ID4gMCkKKwkJcmV0ID0gcGF0aF9tYXRjaGVzX3BhdHRlcm5fbGlzdChjZS0+bmFtZSwKKwkJCQkJCWNlX25hbWVsZW4oY2UpLAorCQkJCQkJbmFtZSwgJmR0eXBlLCBwbCwgaXN0YXRlKTsKKwkJaWYgKHJldCA9PSBVTkRFQ0lERUQpCisJCQlyZXQgPSBkZWZhdWx0X21hdGNoOworCQlpZiAocmV0ID09IE1BVENIRUQpCiAJCQljZS0+Y2VfZmxhZ3MgJj0gfmNsZWFyX21hc2s7CiAJCWNhY2hlKys7CiAJfQpAQCAtMTM5NCw3ICsxNDA0LDcgQEAKIAogc3RhdGljIGludCBjbGVhcl9jZV9mbGFncyhzdHJ1Y3QgaW5kZXhfc3RhdGUgKmlzdGF0ZSwKIAkJCSAgaW50IHNlbGVjdF9tYXNrLCBpbnQgY2xlYXJfbWFzaywKLQkJCSAgc3RydWN0IGV4Y2x1ZGVfbGlzdCAqZWwpCisJCQkgIHN0cnVjdCBwYXR0ZXJuX2xpc3QgKnBsKQogewogCXN0YXRpYyBzdHJ1Y3Qgc3RyYnVmIHByZWZpeCA9IFNUUkJVRl9JTklUOwogCkBAIC0xNDA1LDEzICsxNDE1LDEzIEBACiAJCQkJaXN0YXRlLT5jYWNoZV9uciwKIAkJCQkmcHJlZml4LAogCQkJCXNlbGVjdF9tYXNrLCBjbGVhcl9tYXNrLAotCQkJCWVsLCAwKTsKKwkJCQlwbCwgMCk7CiB9CiAKIC8qCiAgKiBTZXQvQ2xlYXIgQ0VfTkVXX1NLSVBfV09SS1RSRUUgYWNjb3JkaW5nIHRvICRHSVRfRElSL2luZm8vc3BhcnNlLWNoZWNrb3V0CiAgKi8KLXN0YXRpYyB2b2lkIG1hcmtfbmV3X3NraXBfd29ya3RyZWUoc3RydWN0IGV4Y2x1ZGVfbGlzdCAqZWwsCitzdGF0aWMgdm9pZCBtYXJrX25ld19za2lwX3dvcmt0cmVlKHN0cnVjdCBwYXR0ZXJuX2xpc3QgKnBsLAogCQkJCSAgIHN0cnVjdCBpbmRleF9zdGF0ZSAqaXN0YXRlLAogCQkJCSAgIGludCBzZWxlY3RfZmxhZywgaW50IHNraXBfd3RfZmxhZykKIHsKQEAgLTE0MzcsNyArMTQ0Nyw3IEBACiAJICogMi4gV2lkZW4gd29ya3RyZWUgYWNjb3JkaW5nIHRvIHNwYXJzZS1jaGVja291dCBmaWxlLgogCSAqIE1hdGNoZWQgZW50cmllcyB3aWxsIGhhdmUgc2tpcF93dF9mbGFnIGNsZWFyZWQgKGkuZS4gImluIikKIAkgKi8KLQljbGVhcl9jZV9mbGFncyhpc3RhdGUsIHNlbGVjdF9mbGFnLCBza2lwX3d0X2ZsYWcsIGVsKTsKKwljbGVhcl9jZV9mbGFncyhpc3RhdGUsIHNlbGVjdF9mbGFnLCBza2lwX3d0X2ZsYWcsIHBsKTsKIH0KIAogc3RhdGljIGludCB2ZXJpZnlfYWJzZW50KGNvbnN0IHN0cnVjdCBjYWNoZV9lbnRyeSAqLApAQCAtMTQ1MywyMSArMTQ2MywyMSBAQAogewogCWludCBpLCByZXQ7CiAJc3RhdGljIHN0cnVjdCBjYWNoZV9lbnRyeSAqZGZjOwotCXN0cnVjdCBleGNsdWRlX2xpc3QgZWw7CisJc3RydWN0IHBhdHRlcm5fbGlzdCBwbDsKIAogCWlmIChsZW4gPiBNQVhfVU5QQUNLX1RSRUVTKQogCQlkaWUoInVucGFja190cmVlcyB0YWtlcyBhdCBtb3N0ICVkIHRyZWVzIiwgTUFYX1VOUEFDS19UUkVFUyk7CiAKIAl0cmFjZV9wZXJmb3JtYW5jZV9lbnRlcigpOwotCW1lbXNldCgmZWwsIDAsIHNpemVvZihlbCkpOworCW1lbXNldCgmcGwsIDAsIHNpemVvZihwbCkpOwogCWlmICghY29yZV9hcHBseV9zcGFyc2VfY2hlY2tvdXQgfHwgIW8tPnVwZGF0ZSkKIAkJby0+c2tpcF9zcGFyc2VfY2hlY2tvdXQgPSAxOwogCWlmICghby0+c2tpcF9zcGFyc2VfY2hlY2tvdXQpIHsKIAkJY2hhciAqc3BhcnNlID0gZ2l0X3BhdGhkdXAoImluZm8vc3BhcnNlLWNoZWNrb3V0Iik7Ci0JCWlmIChhZGRfZXhjbHVkZXNfZnJvbV9maWxlX3RvX2xpc3Qoc3BhcnNlLCAiIiwgMCwgJmVsLCBOVUxMKSA8IDApCisJCWlmIChhZGRfcGF0dGVybnNfZnJvbV9maWxlX3RvX2xpc3Qoc3BhcnNlLCAiIiwgMCwgJnBsLCBOVUxMKSA8IDApCiAJCQlvLT5za2lwX3NwYXJzZV9jaGVja291dCA9IDE7CiAJCWVsc2UKLQkJCW8tPmVsID0gJmVsOworCQkJby0+cGwgPSAmcGw7CiAJCWZyZWUoc3BhcnNlKTsKIAl9CiAKQEAgLTE1MDEsNyArMTUxMSw3IEBACiAJICogU3BhcnNlIGNoZWNrb3V0IGxvb3AgIzE6IHNldCBORVdfU0tJUF9XT1JLVFJFRSBvbiBleGlzdGluZyBlbnRyaWVzCiAJICovCiAJaWYgKCFvLT5za2lwX3NwYXJzZV9jaGVja291dCkKLQkJbWFya19uZXdfc2tpcF93b3JrdHJlZShvLT5lbCwgby0+c3JjX2luZGV4LCAwLCBDRV9ORVdfU0tJUF9XT1JLVFJFRSk7CisJCW1hcmtfbmV3X3NraXBfd29ya3RyZWUoby0+cGwsIG8tPnNyY19pbmRleCwgMCwgQ0VfTkVXX1NLSVBfV09SS1RSRUUpOwogCiAJaWYgKCFkZmMpCiAJCWRmYyA9IHhjYWxsb2MoMSwgY2FjaGVfZW50cnlfc2l6ZSgwKSk7CkBAIC0xNTY2LDcgKzE1NzYsNyBAQAogCQkgKiBJZiB0aGUgd2lsbCBoYXZlIE5FV19TS0lQX1dPUktUUkVFLCBhbHNvIHNldCBDRV9TS0lQX1dPUktUUkVFCiAJCSAqIHNvIGFwcGx5X3NwYXJzZV9jaGVja291dCgpIHdvbid0IGF0dGVtcHQgdG8gcmVtb3ZlIGl0IGZyb20gd29ya3RyZWUKIAkJICovCi0JCW1hcmtfbmV3X3NraXBfd29ya3RyZWUoby0+ZWwsICZvLT5yZXN1bHQsIENFX0FEREVELCBDRV9TS0lQX1dPUktUUkVFIHwgQ0VfTkVXX1NLSVBfV09SS1RSRUUpOworCQltYXJrX25ld19za2lwX3dvcmt0cmVlKG8tPnBsLCAmby0+cmVzdWx0LCBDRV9BRERFRCwgQ0VfU0tJUF9XT1JLVFJFRSB8IENFX05FV19TS0lQX1dPUktUUkVFKTsKIAogCQlyZXQgPSAwOwogCQlmb3IgKGkgPSAwOyBpIDwgby0+cmVzdWx0LmNhY2hlX25yOyBpKyspIHsKQEAgLTE2MzQsNyArMTY0NCw3IEBACiAKIGRvbmU6CiAJdHJhY2VfcGVyZm9ybWFuY2VfbGVhdmUoInVucGFja190cmVlcyIpOwotCWNsZWFyX2V4Y2x1ZGVfbGlzdCgmZWwpOworCWNsZWFyX3BhdHRlcm5fbGlzdCgmcGwpOwogCXJldHVybiByZXQ7CiAKIHJldHVybl9mYWlsZWQ6CmRpZmYgLS1naXQgYS91bnBhY2stdHJlZXMuaCBiL3VucGFjay10cmVlcy5oCmluZGV4IGQzNDRkN2QuLmYyZWVlMGMgMTAwNjQ0Ci0tLSBhL3VucGFjay10cmVlcy5oCisrKyBiL3VucGFjay10cmVlcy5oCkBAIC0xMCw3ICsxMCw3IEBACiAKIHN0cnVjdCBjYWNoZV9lbnRyeTsKIHN0cnVjdCB1bnBhY2tfdHJlZXNfb3B0aW9uczsKLXN0cnVjdCBleGNsdWRlX2xpc3Q7CitzdHJ1Y3QgcGF0dGVybl9saXN0OwogCiB0eXBlZGVmIGludCAoKm1lcmdlX2ZuX3QpKGNvbnN0IHN0cnVjdCBjYWNoZV9lbnRyeSAqIGNvbnN0ICpzcmMsCiAJCXN0cnVjdCB1bnBhY2tfdHJlZXNfb3B0aW9ucyAqb3B0aW9ucyk7CkBAIC04Myw3ICs4Myw3IEBACiAJc3RydWN0IGluZGV4X3N0YXRlICpzcmNfaW5kZXg7CiAJc3RydWN0IGluZGV4X3N0YXRlIHJlc3VsdDsKIAotCXN0cnVjdCBleGNsdWRlX2xpc3QgKmVsOyAvKiBmb3IgaW50ZXJuYWwgdXNlICovCisJc3RydWN0IHBhdHRlcm5fbGlzdCAqcGw7IC8qIGZvciBpbnRlcm5hbCB1c2UgKi8KIH07CiAKIGludCB1bnBhY2tfdHJlZXModW5zaWduZWQgbiwgc3RydWN0IHRyZWVfZGVzYyAqdCwKZGlmZiAtLWdpdCBhL3VwbG9hZC1wYWNrLmMgYi91cGxvYWQtcGFjay5jCmluZGV4IDIyMmNkM2EuLmEwMGQ3ZWMgMTAwNjQ0Ci0tLSBhL3VwbG9hZC1wYWNrLmMKKysrIGIvdXBsb2FkLXBhY2suYwpAQCAtMTQwLDE4ICsxNDAsMTcgQEAKIAkJYXJndl9hcnJheV9wdXNoKCZwYWNrX29iamVjdHMuYXJncywgIi0tZGVsdGEtYmFzZS1vZmZzZXQiKTsKIAlpZiAodXNlX2luY2x1ZGVfdGFnKQogCQlhcmd2X2FycmF5X3B1c2goJnBhY2tfb2JqZWN0cy5hcmdzLCAiLS1pbmNsdWRlLXRhZyIpOwotCWlmIChmaWx0ZXJfb3B0aW9ucy5maWx0ZXJfc3BlYykgewotCQlzdHJ1Y3Qgc3RyYnVmIGV4cGFuZGVkX2ZpbHRlcl9zcGVjID0gU1RSQlVGX0lOSVQ7Ci0JCWV4cGFuZF9saXN0X29iamVjdHNfZmlsdGVyX3NwZWMoJmZpbHRlcl9vcHRpb25zLAotCQkJCQkJJmV4cGFuZGVkX2ZpbHRlcl9zcGVjKTsKKwlpZiAoZmlsdGVyX29wdGlvbnMuY2hvaWNlKSB7CisJCWNvbnN0IGNoYXIgKnNwZWMgPQorCQkJZXhwYW5kX2xpc3Rfb2JqZWN0c19maWx0ZXJfc3BlYygmZmlsdGVyX29wdGlvbnMpOwogCQlpZiAocGFja19vYmplY3RzLnVzZV9zaGVsbCkgewogCQkJc3RydWN0IHN0cmJ1ZiBidWYgPSBTVFJCVUZfSU5JVDsKLQkJCXNxX3F1b3RlX2J1ZigmYnVmLCBleHBhbmRlZF9maWx0ZXJfc3BlYy5idWYpOworCQkJc3FfcXVvdGVfYnVmKCZidWYsIHNwZWMpOwogCQkJYXJndl9hcnJheV9wdXNoZigmcGFja19vYmplY3RzLmFyZ3MsICItLWZpbHRlcj0lcyIsIGJ1Zi5idWYpOwogCQkJc3RyYnVmX3JlbGVhc2UoJmJ1Zik7CiAJCX0gZWxzZSB7CiAJCQlhcmd2X2FycmF5X3B1c2hmKCZwYWNrX29iamVjdHMuYXJncywgIi0tZmlsdGVyPSVzIiwKLQkJCQkJIGV4cGFuZGVkX2ZpbHRlcl9zcGVjLmJ1Zik7CisJCQkJCSBzcGVjKTsKIAkJfQogCX0KIApAQCAtNzIyLDcgKzcyMSw3IEBACiB7CiAJc3RydWN0IGNvbW1pdF9saXN0ICpyZXN1bHQ7CiAKLQljbG9zZV9jb21taXRfZ3JhcGgodGhlX3JlcG9zaXRvcnktPm9iamVjdHMpOworCWRpc2FibGVfY29tbWl0X2dyYXBoKHRoZV9yZXBvc2l0b3J5KTsKIAlyZXN1bHQgPSBnZXRfc2hhbGxvd19jb21taXRzX2J5X3Jldl9saXN0KGFjLCBhdiwgU0hBTExPVywgTk9UX1NIQUxMT1cpOwogCXNlbmRfc2hhbGxvdyh3cml0ZXIsIHJlc3VsdCk7CiAJZnJlZV9jb21taXRfbGlzdChyZXN1bHQpOwpAQCAtODg0LDYgKzg4Myw3IEBACiAJCWlmIChza2lwX3ByZWZpeChyZWFkZXItPmxpbmUsICJmaWx0ZXIgIiwgJmFyZykpIHsKIAkJCWlmICghZmlsdGVyX2NhcGFiaWxpdHlfcmVxdWVzdGVkKQogCQkJCWRpZSgiZ2l0IHVwbG9hZC1wYWNrOiBmaWx0ZXJpbmcgY2FwYWJpbGl0eSBub3QgbmVnb3RpYXRlZCIpOworCQkJbGlzdF9vYmplY3RzX2ZpbHRlcl9kaWVfaWZfcG9wdWxhdGVkKCZmaWx0ZXJfb3B0aW9ucyk7CiAJCQlwYXJzZV9saXN0X29iamVjdHNfZmlsdGVyKCZmaWx0ZXJfb3B0aW9ucywgYXJnKTsKIAkJCWNvbnRpbnVlOwogCQl9CkBAIC0xMzA1LDYgKzEzMDUsNyBAQAogCQl9CiAKIAkJaWYgKGFsbG93X2ZpbHRlciAmJiBza2lwX3ByZWZpeChhcmcsICJmaWx0ZXIgIiwgJnApKSB7CisJCQlsaXN0X29iamVjdHNfZmlsdGVyX2RpZV9pZl9wb3B1bGF0ZWQoJmZpbHRlcl9vcHRpb25zKTsKIAkJCXBhcnNlX2xpc3Rfb2JqZWN0c19maWx0ZXIoJmZpbHRlcl9vcHRpb25zLCBwKTsKIAkJCWNvbnRpbnVlOwogCQl9CmRpZmYgLS1naXQgYS91cmwuYyBiL3VybC5jCmluZGV4IDFiOGVmNzguLmUwNGJkNjAgMTAwNjQ0Ci0tLSBhL3VybC5jCisrKyBiL3VybC5jCkBAIC01LDcgKzUsNyBAQAogewogCS8qCiAJICogVGhlIHNldCBvZiB2YWxpZCBVUkwgc2NoZW1lcywgYXMgcGVyIFNURDY2IChSRkMzOTg2KSBpcwotCSAqICdbQS1aYS16XVtBLVphLXowLTkrLi1dKicuIEJ1dCB1c2Ugc2lnaHRseSBsb29zZXIgY2hlY2sKKwkgKiAnW0EtWmEtel1bQS1aYS16MC05Ky4tXSonLiBCdXQgdXNlIHNsaWdodGx5IGxvb3NlciBjaGVjawogCSAqIG9mICdbQS1aYS16MC05XVtBLVphLXowLTkrLi1dKicgYmVjYXVzZSBlYXJsaWVyIHZlcnNpb24KIAkgKiBvZiBjaGVjayB1c2VkICdbQS1aYS16MC05XSsnIHNvIG5vdCB0byBicmVhayBhbnkgcmVtb3RlCiAJICogaGVscGVycy4KQEAgLTg2LDYgKzg2LDEyIEBACiAJcmV0dXJuIHVybF9kZWNvZGVfaW50ZXJuYWwoJnVybCwgbGVuLCBOVUxMLCAmb3V0LCAwKTsKIH0KIAorY2hhciAqdXJsX3BlcmNlbnRfZGVjb2RlKGNvbnN0IGNoYXIgKmVuY29kZWQpCit7CisJc3RydWN0IHN0cmJ1ZiBvdXQgPSBTVFJCVUZfSU5JVDsKKwlyZXR1cm4gdXJsX2RlY29kZV9pbnRlcm5hbCgmZW5jb2RlZCwgc3RybGVuKGVuY29kZWQpLCBOVUxMLCAmb3V0LCAwKTsKK30KKwogY2hhciAqdXJsX2RlY29kZV9wYXJhbWV0ZXJfbmFtZShjb25zdCBjaGFyICoqcXVlcnkpCiB7CiAJc3RydWN0IHN0cmJ1ZiBvdXQgPSBTVFJCVUZfSU5JVDsKZGlmZiAtLWdpdCBhL3VybC5oIGIvdXJsLmgKaW5kZXggMDBiN2Q1OC4uMmEyN2MzNCAxMDA2NDQKLS0tIGEvdXJsLmgKKysrIGIvdXJsLmgKQEAgLTcsNiArNywxNCBAQAogaW50IGlzX3VybHNjaGVtZWNoYXIoaW50IGZpcnN0X2ZsYWcsIGludCBjaCk7CiBjaGFyICp1cmxfZGVjb2RlKGNvbnN0IGNoYXIgKnVybCk7CiBjaGFyICp1cmxfZGVjb2RlX21lbShjb25zdCBjaGFyICp1cmwsIGludCBsZW4pOworCisvKgorICogU2ltaWxhciB0byB0aGUgdXJsX2RlY29kZV97LG1lbX0gbWV0aG9kcyBhYm92ZSwgYnV0IGRvZXNuJ3QgYXNzdW1lIHRoZXJlCisgKiBpcyBhIHNjaGVtZSBmb2xsb3dlZCBieSBhIDogYXQgdGhlIHN0YXJ0IG9mIHRoZSBzdHJpbmcuIEluc3RlYWQsICUtc2VxdWVuY2VzCisgKiBiZWZvcmUgYW55IDogYXJlIGFsc28gcGFyc2VkLgorICovCitjaGFyICp1cmxfcGVyY2VudF9kZWNvZGUoY29uc3QgY2hhciAqZW5jb2RlZCk7CisKIGNoYXIgKnVybF9kZWNvZGVfcGFyYW1ldGVyX25hbWUoY29uc3QgY2hhciAqKnF1ZXJ5KTsKIGNoYXIgKnVybF9kZWNvZGVfcGFyYW1ldGVyX3ZhbHVlKGNvbnN0IGNoYXIgKipxdWVyeSk7CiAKZGlmZiAtLWdpdCBhL3VzYWdlLmMgYi91c2FnZS5jCmluZGV4IDJmZGIyMDAuLjU4ZmI1ZmYgMTAwNjQ0Ci0tLSBhL3VzYWdlLmMKKysrIGIvdXNhZ2UuYwpAQCAtOSwxNCArOSwyNiBAQAogdm9pZCB2cmVwb3J0Zihjb25zdCBjaGFyICpwcmVmaXgsIGNvbnN0IGNoYXIgKmVyciwgdmFfbGlzdCBwYXJhbXMpCiB7CiAJY2hhciBtc2dbNDA5Nl07Ci0JY2hhciAqcDsKKwljaGFyICpwLCAqcGVuZCA9IG1zZyArIHNpemVvZihtc2cpOworCXNpemVfdCBwcmVmaXhfbGVuID0gc3RybGVuKHByZWZpeCk7CiAKLQl2c25wcmludGYobXNnLCBzaXplb2YobXNnKSwgZXJyLCBwYXJhbXMpOwotCWZvciAocCA9IG1zZzsgKnA7IHArKykgeworCWlmIChzaXplb2YobXNnKSA8PSBwcmVmaXhfbGVuKSB7CisJCWZwcmludGYoc3RkZXJyLCAiQlVHISEhIHRvbyBsb25nIGEgcHJlZml4ICclcydcbiIsIHByZWZpeCk7CisJCWFib3J0KCk7CisJfQorCW1lbWNweShtc2csIHByZWZpeCwgcHJlZml4X2xlbik7CisJcCA9IG1zZyArIHByZWZpeF9sZW47CisJaWYgKHZzbnByaW50ZihwLCBwZW5kIC0gcCwgZXJyLCBwYXJhbXMpIDwgMCkKKwkJKnAgPSAnXDAnOyAvKiB2c25wcmludGYoKSBmYWlsZWQsIGNsaXAgYXQgcHJlZml4ICovCisKKwlmb3IgKDsgcCAhPSBwZW5kIC0gMSAmJiAqcDsgcCsrKSB7CiAJCWlmIChpc2NudHJsKCpwKSAmJiAqcCAhPSAnXHQnICYmICpwICE9ICdcbicpCiAJCQkqcCA9ICc/JzsKIAl9Ci0JZnByaW50ZihzdGRlcnIsICIlcyVzXG4iLCBwcmVmaXgsIG1zZyk7CisKKwkqKHArKykgPSAnXG4nOyAvKiB3ZSBubyBsb25nZXIgbmVlZCBhIE5VTCAqLworCWZmbHVzaChzdGRlcnIpOworCXdyaXRlX2luX2Z1bGwoMiwgbXNnLCBwIC0gbXNnKTsKIH0KIAogc3RhdGljIE5PUkVUVVJOIHZvaWQgdXNhZ2VfYnVpbHRpbihjb25zdCBjaGFyICplcnIsIHZhX2xpc3QgcGFyYW1zKQpkaWZmIC0tZ2l0IGEvdXNlcmRpZmYuYyBiL3VzZXJkaWZmLmMKaW5kZXggZTc0YTZkNC4uMzI0OTE2ZiAxMDA2NDQKLS0tIGEvdXNlcmRpZmYuYworKysgYi91c2VyZGlmZi5jCkBAIC0yMyw2ICsyMywyNyBAQAogCSAiW2EtekEtWl1bYS16QS1aMC05X10qIgogCSAifFstK10/WzAtOV1bMC05I18uYUFiQmNDZERlRWZGXSooW2VFXVsrLV0/WzAtOV9dKyk/IgogCSAifD0+fFxcLlxcLnxcXCpcXCp8Oj18Lz18Pj18PD18PDx8Pj58PD4iKSwKK1BBVFRFUk5TKCJkdHMiLAorCSAiITtcbiIKKwkgIiE9XG4iCisJIC8qIGxpbmVzIGJlZ2lubmluZyB3aXRoIGEgd29yZCBvcHRpb25hbGx5IHByZWNlZGVkIGJ5ICcmJyBvciB0aGUgcm9vdCAqLworCSAiXlsgXHRdKigoL1sgXHRdKlxce3wmP1thLXpBLVpfXSkuKikiLAorCSAvKiAtLSAqLworCSAvKiBQcm9wZXJ0eSBuYW1lcyBhbmQgbWF0aCBvcGVyYXRvcnMgKi8KKwkgIlthLXpBLVowLTksLl8rPyMtXSsiCisJICJ8Wy0rKi8lJl58IX5dfD4+fDw8fCYmfFxcfFxcfCIpLAorUEFUVEVSTlMoImVsaXhpciIsCisJICJeWyBcdF0qKChkZWYobWFjcm98bW9kdWxlfGltcGx8cHJvdG9jb2x8cCk/fHRlc3QpWyBcdF0uKikkIiwKKwkgLyogQXRvbXMsIG5hbWVzLCBhbmQgbW9kdWxlIGF0dHJpYnV0ZXMgKi8KKwkgInxbQDpdP1thLXpBLVowLTlAXz8hXSsiCisJIC8qIE51bWJlcnMgd2l0aCBzcGVjaWZpYyBiYXNlICovCisJICJ8Wy0rXT8wW3hvYl1bMC05YS1mQS1GXSsiCisJIC8qIE51bWJlcnMgKi8KKwkgInxbLStdP1swLTldWzAtOV8uXSooW2VFXVstK10/WzAtOV9dKyk/IgorCSAvKiBPcGVyYXRvcnMgYW5kIGF0b21zIHRoYXQgcmVwcmVzZW50IHRoZW0gKi8KKwkgInw6PyhcXCtcXCt8LS18XFwuXFwufH5+fnw8PnxcXF5cXF5cXF58PD9cXHw+fDw8PD98Pj8+Pnw8PD9+fH4+Pz58PH4+fDw9fD49fD09PT98IT09P3w9fnwmJiY/fFxcfFxcfFxcfD98PT58PC18XFxcXFxcXFx8LT4pIgorCSAvKiBOb3QgcmVhbCBvcGVyYXRvcnMsIGJ1dCBzaG91bGQgYmUgZ3JvdXBlZCAqLworCSAifDo/JVtBLVphLXowLTlfLl1cXHtcXH0/IiksCiBJUEFUVEVSTigiZm9ydHJhbiIsCiAJICIhXihbQypdfFsgXHRdKiEpXG4iCiAJICIhXlsgXHRdKk1PRFVMRVsgXHRdK1BST0NFRFVSRVsgXHRdXG4iCkBAIC0xMjQsNyArMTQ1LDcgQEAKIAkgIlthLXpBLVpfXVthLXpBLVowLTlfXSoiCiAJICJ8Wy0rMC05LmVdK3wwW3hYYkJdP1swLTlhLWZBLUZdKyIKIAkgInxbLSsqLzw+JSZefD0hLl09fC0tfFxcK1xcK3w8PD0/fD4+PT98PT09fCYmfFxcfFxcfHw6OnwtPiIpLAotUEFUVEVSTlMoInB5dGhvbiIsICJeWyBcdF0qKChjbGFzc3xkZWYpWyBcdF0uKikkIiwKK1BBVFRFUk5TKCJweXRob24iLCAiXlsgXHRdKigoY2xhc3N8KGFzeW5jWyBcdF0rKT9kZWYpWyBcdF0uKikkIiwKIAkgLyogLS0gKi8KIAkgIlthLXpBLVpfXVthLXpBLVowLTlfXSoiCiAJICJ8Wy0rMC05LmVdK1tqSmxMXT98MFt4WF0/WzAtOWEtZkEtRl0rW2xMXT8iCmRpZmYgLS1naXQgYS91dGY4LmMgYi91dGY4LmMKaW5kZXggM2I0MmZhZC4uNWIzOTM2MSAxMDA2NDQKLS0tIGEvdXRmOC5jCisrKyBiL3V0ZjguYwpAQCAtOTUsMTMgKzk1LDExIEBACiAJCXJldHVybiAtMTsKIAogCS8qIGJpbmFyeSBzZWFyY2ggaW4gdGFibGUgb2Ygbm9uLXNwYWNpbmcgY2hhcmFjdGVycyAqLwotCWlmIChiaXNlYXJjaChjaCwgemVyb193aWR0aCwgc2l6ZW9mKHplcm9fd2lkdGgpCi0JCQkJLyBzaXplb2Yoc3RydWN0IGludGVydmFsKSAtIDEpKQorCWlmIChiaXNlYXJjaChjaCwgemVyb193aWR0aCwgQVJSQVlfU0laRSh6ZXJvX3dpZHRoKSAtIDEpKQogCQlyZXR1cm4gMDsKIAogCS8qIGJpbmFyeSBzZWFyY2ggaW4gdGFibGUgb2YgZG91YmxlIHdpZHRoIGNoYXJhY3RlcnMgKi8KLQlpZiAoYmlzZWFyY2goY2gsIGRvdWJsZV93aWR0aCwgc2l6ZW9mKGRvdWJsZV93aWR0aCkKLQkJCQkvIHNpemVvZihzdHJ1Y3QgaW50ZXJ2YWwpIC0gMSkpCisJaWYgKGJpc2VhcmNoKGNoLCBkb3VibGVfd2lkdGgsIEFSUkFZX1NJWkUoZG91YmxlX3dpZHRoKSAtIDEpKQogCQlyZXR1cm4gMjsKIAogCXJldHVybiAxOwpAQCAtNDEzLDExICs0MTEsMTAgQEAKICAqLwogc3RhdGljIGludCBzYW1lX3V0Zl9lbmNvZGluZyhjb25zdCBjaGFyICpzcmMsIGNvbnN0IGNoYXIgKmRzdCkKIHsKLQlpZiAoaXN0YXJ0c193aXRoKHNyYywgInV0ZiIpICYmIGlzdGFydHNfd2l0aChkc3QsICJ1dGYiKSkgewotCQkvKiBzcmNbM10gb3IgZHN0WzNdIG1pZ2h0IGJlICdcMCcgKi8KLQkJaW50IGkgPSAoc3JjWzNdID09ICctJyA/IDQgOiAzKTsKLQkJaW50IGogPSAoZHN0WzNdID09ICctJyA/IDQgOiAzKTsKLQkJcmV0dXJuICFzdHJjYXNlY21wKHNyYytpLCBkc3Qraik7CisJaWYgKHNraXBfaXByZWZpeChzcmMsICJ1dGYiLCAmc3JjKSAmJiBza2lwX2lwcmVmaXgoZHN0LCAidXRmIiwgJmRzdCkpIHsKKwkJc2tpcF9wcmVmaXgoc3JjLCAiLSIsICZzcmMpOworCQlza2lwX3ByZWZpeChkc3QsICItIiwgJmRzdCk7CisJCXJldHVybiAhc3RyY2FzZWNtcChzcmMsIGRzdCk7CiAJfQogCXJldHVybiAwOwogfQpkaWZmIC0tZ2l0IGEvd3JhcHBlci5jIGIvd3JhcHBlci5jCmluZGV4IDFlNDVhYjcuLmUxZWFlZjIgMTAwNjQ0Ci0tLSBhL3dyYXBwZXIuYworKysgYi93cmFwcGVyLmMKQEAgLTQsMTIgKzQsNiBAQAogI2luY2x1ZGUgImNhY2hlLmgiCiAjaW5jbHVkZSAiY29uZmlnLmgiCiAKLXN0YXRpYyB2b2lkIGRvX25vdGhpbmcoc2l6ZV90IHNpemUpCi17Ci19Ci0KLXN0YXRpYyB2b2lkICgqdHJ5X3RvX2ZyZWVfcm91dGluZSkoc2l6ZV90IHNpemUpID0gZG9fbm90aGluZzsKLQogc3RhdGljIGludCBtZW1vcnlfbGltaXRfY2hlY2soc2l6ZV90IHNpemUsIGludCBnZW50bGUpCiB7CiAJc3RhdGljIHNpemVfdCBsaW1pdCA9IDA7CkBAIC0zMCwyNCArMjQsMTEgQEAKIAlyZXR1cm4gMDsKIH0KIAotdHJ5X3RvX2ZyZWVfdCBzZXRfdHJ5X3RvX2ZyZWVfcm91dGluZSh0cnlfdG9fZnJlZV90IHJvdXRpbmUpCi17Ci0JdHJ5X3RvX2ZyZWVfdCBvbGQgPSB0cnlfdG9fZnJlZV9yb3V0aW5lOwotCWlmICghcm91dGluZSkKLQkJcm91dGluZSA9IGRvX25vdGhpbmc7Ci0JdHJ5X3RvX2ZyZWVfcm91dGluZSA9IHJvdXRpbmU7Ci0JcmV0dXJuIG9sZDsKLX0KLQogY2hhciAqeHN0cmR1cChjb25zdCBjaGFyICpzdHIpCiB7CiAJY2hhciAqcmV0ID0gc3RyZHVwKHN0cik7Ci0JaWYgKCFyZXQpIHsKLQkJdHJ5X3RvX2ZyZWVfcm91dGluZShzdHJsZW4oc3RyKSArIDEpOwotCQlyZXQgPSBzdHJkdXAoc3RyKTsKLQkJaWYgKCFyZXQpCi0JCQlkaWUoIk91dCBvZiBtZW1vcnksIHN0cmR1cCBmYWlsZWQiKTsKLQl9CisJaWYgKCFyZXQpCisJCWRpZSgiT3V0IG9mIG1lbW9yeSwgc3RyZHVwIGZhaWxlZCIpOwogCXJldHVybiByZXQ7CiB9CiAKQEAgLTYxLDE5ICs0MiwxMyBAQAogCWlmICghcmV0ICYmICFzaXplKQogCQlyZXQgPSBtYWxsb2MoMSk7CiAJaWYgKCFyZXQpIHsKLQkJdHJ5X3RvX2ZyZWVfcm91dGluZShzaXplKTsKLQkJcmV0ID0gbWFsbG9jKHNpemUpOwotCQlpZiAoIXJldCAmJiAhc2l6ZSkKLQkJCXJldCA9IG1hbGxvYygxKTsKLQkJaWYgKCFyZXQpIHsKLQkJCWlmICghZ2VudGxlKQotCQkJCWRpZSgiT3V0IG9mIG1lbW9yeSwgbWFsbG9jIGZhaWxlZCAodHJpZWQgdG8gYWxsb2NhdGUgJWx1IGJ5dGVzKSIsCi0JCQkJICAgICh1bnNpZ25lZCBsb25nKXNpemUpOwotCQkJZWxzZSB7Ci0JCQkJZXJyb3IoIk91dCBvZiBtZW1vcnksIG1hbGxvYyBmYWlsZWQgKHRyaWVkIHRvIGFsbG9jYXRlICVsdSBieXRlcykiLAotCQkJCSAgICAgICh1bnNpZ25lZCBsb25nKXNpemUpOwotCQkJCXJldHVybiBOVUxMOwotCQkJfQorCQlpZiAoIWdlbnRsZSkKKwkJCWRpZSgiT3V0IG9mIG1lbW9yeSwgbWFsbG9jIGZhaWxlZCAodHJpZWQgdG8gYWxsb2NhdGUgJWx1IGJ5dGVzKSIsCisJCQkgICAgKHVuc2lnbmVkIGxvbmcpc2l6ZSk7CisJCWVsc2UgeworCQkJZXJyb3IoIk91dCBvZiBtZW1vcnksIG1hbGxvYyBmYWlsZWQgKHRyaWVkIHRvIGFsbG9jYXRlICVsdSBieXRlcykiLAorCQkJICAgICAgKHVuc2lnbmVkIGxvbmcpc2l6ZSk7CisJCQlyZXR1cm4gTlVMTDsKIAkJfQogCX0KICNpZmRlZiBYTUFMTE9DX1BPSVNPTgpAQCAtMTM4LDE0ICsxMTMsOCBAQAogCXJldCA9IHJlYWxsb2MocHRyLCBzaXplKTsKIAlpZiAoIXJldCAmJiAhc2l6ZSkKIAkJcmV0ID0gcmVhbGxvYyhwdHIsIDEpOwotCWlmICghcmV0KSB7Ci0JCXRyeV90b19mcmVlX3JvdXRpbmUoc2l6ZSk7Ci0JCXJldCA9IHJlYWxsb2MocHRyLCBzaXplKTsKLQkJaWYgKCFyZXQgJiYgIXNpemUpCi0JCQlyZXQgPSByZWFsbG9jKHB0ciwgMSk7Ci0JCWlmICghcmV0KQotCQkJZGllKCJPdXQgb2YgbWVtb3J5LCByZWFsbG9jIGZhaWxlZCIpOwotCX0KKwlpZiAoIXJldCkKKwkJZGllKCJPdXQgb2YgbWVtb3J5LCByZWFsbG9jIGZhaWxlZCIpOwogCXJldHVybiByZXQ7CiB9CiAKQEAgLTE2MCwxNCArMTI5LDggQEAKIAlyZXQgPSBjYWxsb2Mobm1lbWIsIHNpemUpOwogCWlmICghcmV0ICYmICghbm1lbWIgfHwgIXNpemUpKQogCQlyZXQgPSBjYWxsb2MoMSwgMSk7Ci0JaWYgKCFyZXQpIHsKLQkJdHJ5X3RvX2ZyZWVfcm91dGluZShubWVtYiAqIHNpemUpOwotCQlyZXQgPSBjYWxsb2Mobm1lbWIsIHNpemUpOwotCQlpZiAoIXJldCAmJiAoIW5tZW1iIHx8ICFzaXplKSkKLQkJCXJldCA9IGNhbGxvYygxLCAxKTsKLQkJaWYgKCFyZXQpCi0JCQlkaWUoIk91dCBvZiBtZW1vcnksIGNhbGxvYyBmYWlsZWQiKTsKLQl9CisJaWYgKCFyZXQpCisJCWRpZSgiT3V0IG9mIG1lbW9yeSwgY2FsbG9jIGZhaWxlZCIpOwogCXJldHVybiByZXQ7CiB9CiAKQEAgLTQ3OCw3ICs0NDEsOSBAQAogCQkiYWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXoiCiAJCSJBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWiIKIAkJIjAxMjM0NTY3ODkiOwotCXN0YXRpYyBjb25zdCBpbnQgbnVtX2xldHRlcnMgPSA2MjsKKwlzdGF0aWMgY29uc3QgaW50IG51bV9sZXR0ZXJzID0gQVJSQVlfU0laRShsZXR0ZXJzKSAtIDE7CisJc3RhdGljIGNvbnN0IGNoYXIgeF9wYXR0ZXJuW10gPSAiWFhYWFhYIjsKKwlzdGF0aWMgY29uc3QgaW50IG51bV94ID0gQVJSQVlfU0laRSh4X3BhdHRlcm4pIC0gMTsKIAl1aW50NjRfdCB2YWx1ZTsKIAlzdHJ1Y3QgdGltZXZhbCB0djsKIAljaGFyICpmaWxlbmFtZV90ZW1wbGF0ZTsKQEAgLTQ4NywxMiArNDUyLDEyIEBACiAKIAlsZW4gPSBzdHJsZW4ocGF0dGVybik7CiAKLQlpZiAobGVuIDwgNiArIHN1ZmZpeF9sZW4pIHsKKwlpZiAobGVuIDwgbnVtX3ggKyBzdWZmaXhfbGVuKSB7CiAJCWVycm5vID0gRUlOVkFMOwogCQlyZXR1cm4gLTE7CiAJfQogCi0JaWYgKHN0cm5jbXAoJnBhdHRlcm5bbGVuIC0gNiAtIHN1ZmZpeF9sZW5dLCAiWFhYWFhYIiwgNikpIHsKKwlpZiAoc3RybmNtcCgmcGF0dGVybltsZW4gLSBudW1feCAtIHN1ZmZpeF9sZW5dLCB4X3BhdHRlcm4sIG51bV94KSkgewogCQllcnJubyA9IEVJTlZBTDsKIAkJcmV0dXJuIC0xOwogCX0KQEAgLTUwMywxNiArNDY4LDE1IEBACiAJICovCiAJZ2V0dGltZW9mZGF5KCZ0diwgTlVMTCk7CiAJdmFsdWUgPSAoKHVpbnQ2NF90KXR2LnR2X3VzZWMgPDwgMTYpIF4gdHYudHZfc2VjIF4gZ2V0cGlkKCk7Ci0JZmlsZW5hbWVfdGVtcGxhdGUgPSAmcGF0dGVybltsZW4gLSA2IC0gc3VmZml4X2xlbl07CisJZmlsZW5hbWVfdGVtcGxhdGUgPSAmcGF0dGVybltsZW4gLSBudW1feCAtIHN1ZmZpeF9sZW5dOwogCWZvciAoY291bnQgPSAwOyBjb3VudCA8IFRNUF9NQVg7ICsrY291bnQpIHsKIAkJdWludDY0X3QgdiA9IHZhbHVlOworCQlpbnQgaTsKIAkJLyogRmlsbCBpbiB0aGUgcmFuZG9tIGJpdHMuICovCi0JCWZpbGVuYW1lX3RlbXBsYXRlWzBdID0gbGV0dGVyc1t2ICUgbnVtX2xldHRlcnNdOyB2IC89IG51bV9sZXR0ZXJzOwotCQlmaWxlbmFtZV90ZW1wbGF0ZVsxXSA9IGxldHRlcnNbdiAlIG51bV9sZXR0ZXJzXTsgdiAvPSBudW1fbGV0dGVyczsKLQkJZmlsZW5hbWVfdGVtcGxhdGVbMl0gPSBsZXR0ZXJzW3YgJSBudW1fbGV0dGVyc107IHYgLz0gbnVtX2xldHRlcnM7Ci0JCWZpbGVuYW1lX3RlbXBsYXRlWzNdID0gbGV0dGVyc1t2ICUgbnVtX2xldHRlcnNdOyB2IC89IG51bV9sZXR0ZXJzOwotCQlmaWxlbmFtZV90ZW1wbGF0ZVs0XSA9IGxldHRlcnNbdiAlIG51bV9sZXR0ZXJzXTsgdiAvPSBudW1fbGV0dGVyczsKLQkJZmlsZW5hbWVfdGVtcGxhdGVbNV0gPSBsZXR0ZXJzW3YgJSBudW1fbGV0dGVyc107IHYgLz0gbnVtX2xldHRlcnM7CisJCWZvciAoaSA9IDA7IGkgPCBudW1feDsgaSsrKSB7CisJCQlmaWxlbmFtZV90ZW1wbGF0ZVtpXSA9IGxldHRlcnNbdiAlIG51bV9sZXR0ZXJzXTsKKwkJCXYgLz0gbnVtX2xldHRlcnM7CisJCX0KIAogCQlmZCA9IG9wZW4ocGF0dGVybiwgT19DUkVBVCB8IE9fRVhDTCB8IE9fUkRXUiwgbW9kZSk7CiAJCWlmIChmZCA+PSAwKQpkaWZmIC0tZ2l0IGEvd3Qtc3RhdHVzLmMgYi93dC1zdGF0dXMuYwppbmRleCA5ZjZjNjVhLi5jYzZmOTQ1IDEwMDY0NAotLS0gYS93dC1zdGF0dXMuYworKysgYi93dC1zdGF0dXMuYwpAQCAtMTQzNCw2ICsxNDM0LDggQEAKIAkJCXN0YXR1c19wcmludGZfbG4ocywgY29sb3IsCiAJCQkJXygiICAoYWxsIGNvbmZsaWN0cyBmaXhlZDogcnVuIFwiZ2l0IGNoZXJyeS1waWNrIC0tY29udGludWVcIikiKSk7CiAJCXN0YXR1c19wcmludGZfbG4ocywgY29sb3IsCisJCQlfKCIgICh1c2UgXCJnaXQgY2hlcnJ5LXBpY2sgLS1za2lwXCIgdG8gc2tpcCB0aGlzIHBhdGNoKSIpKTsKKwkJc3RhdHVzX3ByaW50Zl9sbihzLCBjb2xvciwKIAkJCV8oIiAgKHVzZSBcImdpdCBjaGVycnktcGljayAtLWFib3J0XCIgdG8gY2FuY2VsIHRoZSBjaGVycnktcGljayBvcGVyYXRpb24pIikpOwogCX0KIAl3dF9sb25nc3RhdHVzX3ByaW50X3RyYWlsZXIocyk7CkBAIC0xNDYxLDYgKzE0NjMsOCBAQAogCQkJc3RhdHVzX3ByaW50Zl9sbihzLCBjb2xvciwKIAkJCQlfKCIgIChhbGwgY29uZmxpY3RzIGZpeGVkOiBydW4gXCJnaXQgcmV2ZXJ0IC0tY29udGludWVcIikiKSk7CiAJCXN0YXR1c19wcmludGZfbG4ocywgY29sb3IsCisJCQlfKCIgICh1c2UgXCJnaXQgcmV2ZXJ0IC0tc2tpcFwiIHRvIHNraXAgdGhpcyBwYXRjaCkiKSk7CisJCXN0YXR1c19wcmludGZfbG4ocywgY29sb3IsCiAJCQlfKCIgICh1c2UgXCJnaXQgcmV2ZXJ0IC0tYWJvcnRcIiB0byBjYW5jZWwgdGhlIHJldmVydCBvcGVyYXRpb24pIikpOwogCX0KIAl3dF9sb25nc3RhdHVzX3ByaW50X3RyYWlsZXIocyk7CkBAIC0yMDI1LDcgKzIwMjksNyBAQAogCWNoYXIgZW9sID0gcy0+bnVsbF90ZXJtaW5hdGlvbiA/ICdcMCcgOiAnXG4nOwogCiAJZnByaW50ZihzLT5mcCwgIiMgYnJhbmNoLm9pZCAlcyVjIiwKLQkJCShzLT5pc19pbml0aWFsID8gIihpbml0aWFsKSIgOiBzaGExX3RvX2hleChzLT5zaGExX2NvbW1pdCkpLAorCQkJKHMtPmlzX2luaXRpYWwgPyAiKGluaXRpYWwpIiA6IG9pZF90b19oZXgoJnMtPm9pZF9jb21taXQpKSwKIAkJCWVvbCk7CiAKIAlpZiAoIXMtPmJyYW5jaCkKZGlmZiAtLWdpdCBhL3d0LXN0YXR1cy5oIGIvd3Qtc3RhdHVzLmgKaW5kZXggNzdkYWQ1Yi4uNzFjM2YyNSAxMDA2NDQKLS0tIGEvd3Qtc3RhdHVzLmgKKysrIGIvd3Qtc3RhdHVzLmgKQEAgLTExNiw3ICsxMTYsNyBAQAogCWludCByZW5hbWVfbGltaXQ7CiAJZW51bSB3dF9zdGF0dXNfZm9ybWF0IHN0YXR1c19mb3JtYXQ7CiAJc3RydWN0IHd0X3N0YXR1c19zdGF0ZSBzdGF0ZTsKLQl1bnNpZ25lZCBjaGFyIHNoYTFfY29tbWl0W0dJVF9NQVhfUkFXU1pdOyAvKiB3aGVuIG5vdCBJbml0aWFsICovCisJc3RydWN0IG9iamVjdF9pZCBvaWRfY29tbWl0OyAvKiB3aGVuIG5vdCBJbml0aWFsICovCiAKIAkvKiBUaGVzZSBhcmUgY29tcHV0ZWQgZHVyaW5nIHByb2Nlc3Npbmcgb2YgdGhlIGluZGl2aWR1YWwgc2VjdGlvbnMgKi8KIAlpbnQgY29tbWl0dGFibGU7CmRpZmYgLS1naXQgYS94ZGlmZi1pbnRlcmZhY2UuaCBiL3hkaWZmLWludGVyZmFjZS5oCmluZGV4IGVkZTQyNDYuLjkzZGYyNjkgMTAwNjQ0Ci0tLSBhL3hkaWZmLWludGVyZmFjZS5oCisrKyBiL3hkaWZmLWludGVyZmFjZS5oCkBAIC00NCw3ICs0NCw3IEBACiAgKiBDb21wYXJlIHRoZSBzdHJpbmdzIGwxIHdpdGggbDIgd2hpY2ggYXJlIG9mIHNpemUgczEgYW5kIHMyIHJlc3BlY3RpdmVseS4KICAqIFJldHVybnMgMSBpZiB0aGUgc3RyaW5ncyBhcmUgZGVlbWVkIGVxdWFsLCAwIG90aGVyd2lzZS4KICAqIFRoZSBgZmxhZ3NgIGdpdmVuIGFzIFhERl9XSElURVNQQUNFX0ZMQUdTIGRldGVybWluZSBob3cgd2hpdGUgc3BhY2VzCi0gKiBhcmUgdHJlYXRlZCBmb3IgdGhlIGNvbXBhcmlzaW9uLgorICogYXJlIHRyZWF0ZWQgZm9yIHRoZSBjb21wYXJpc29uLgogICovCiBpbnQgeGRpZmZfY29tcGFyZV9saW5lcyhjb25zdCBjaGFyICpsMSwgbG9uZyBzMSwKIAkJCWNvbnN0IGNoYXIgKmwyLCBsb25nIHMyLCBsb25nIGZsYWdzKTsKZGlmZiAtLWdpdCBhL3hkaWZmL3hkaWZmaS5jIGIveGRpZmYveGRpZmZpLmMKaW5kZXggMWYxZjRhMy4uYmQwMzUxMyAxMDA2NDQKLS0tIGEveGRpZmYveGRpZmZpLmMKKysrIGIveGRpZmYveGRpZmZpLmMKQEAgLTM4LDkgKzM4LDkgQEAKICAqIEJhc2ljYWxseSBjb25zaWRlcnMgYSAiYm94IiAob2ZmMSwgb2ZmMiwgbGltMSwgbGltMikgYW5kIHNjYW4gZnJvbSBib3RoCiAgKiB0aGUgZm9yd2FyZCBkaWFnb25hbCBzdGFydGluZyBmcm9tIChvZmYxLCBvZmYyKSBhbmQgdGhlIGJhY2t3YXJkIGRpYWdvbmFsCiAgKiBzdGFydGluZyBmcm9tIChsaW0xLCBsaW0yKS4gSWYgdGhlIEsgdmFsdWVzIG9uIHRoZSBzYW1lIGRpYWdvbmFsIGNyb3NzZXMKLSAqIHJldHVybnMgdGhlIGZ1cnRoZXN0IHBvaW50IG9mIHJlYWNoLiBXZSBtaWdodCBlbmQgdXAgaGF2aW5nIHRvIGV4cGVuc2l2ZQotICogY2FzZXMgdXNpbmcgdGhpcyBhbGdvcml0aG0gaXMgZnVsbCwgc28gYSBsaXR0bGUgYml0IG9mIGhldXJpc3RpYyBpcyBuZWVkZWQKLSAqIHRvIGN1dCB0aGUgc2VhcmNoIGFuZCB0byByZXR1cm4gYSBzdWJvcHRpbWFsIHBvaW50LgorICogcmV0dXJucyB0aGUgZnVydGhlc3QgcG9pbnQgb2YgcmVhY2guIFdlIG1pZ2h0IGVuY291bnRlciBleHBlbnNpdmUgZWRnZSBjYXNlcworICogdXNpbmcgdGhpcyBhbGdvcml0aG0sIHNvIGEgbGl0dGxlIGJpdCBvZiBoZXVyaXN0aWMgaXMgbmVlZGVkIHRvIGN1dCB0aGUKKyAqIHNlYXJjaCBhbmQgdG8gcmV0dXJuIGEgc3Vib3B0aW1hbCBwb2ludC4KICAqLwogc3RhdGljIGxvbmcgeGRsX3NwbGl0KHVuc2lnbmVkIGxvbmcgY29uc3QgKmhhMSwgbG9uZyBvZmYxLCBsb25nIGxpbTEsCiAJCSAgICAgIHVuc2lnbmVkIGxvbmcgY29uc3QgKmhhMiwgbG9uZyBvZmYyLCBsb25nIGxpbTIsCkBAIC02MywxMSArNjMsMTMgQEAKIAkJaW50IGdvdF9zbmFrZSA9IDA7CiAKIAkJLyoKLQkJICogV2UgbmVlZCB0byBleHRlbnQgdGhlIGRpYWdvbmFsICJkb21haW4iIGJ5IG9uZS4gSWYgdGhlIG5leHQKKwkJICogV2UgbmVlZCB0byBleHRlbmQgdGhlIGRpYWdvbmFsICJkb21haW4iIGJ5IG9uZS4gSWYgdGhlIG5leHQKIAkJICogdmFsdWVzIGV4aXRzIHRoZSBib3ggYm91bmRhcmllcyB3ZSBuZWVkIHRvIGNoYW5nZSBpdCBpbiB0aGUKLQkJICogb3Bwb3NpdGUgZGlyZWN0aW9uIGJlY2F1c2UgKG1heCAtIG1pbikgbXVzdCBiZSBhIHBvd2VyIG9mIHR3by4KKwkJICogb3Bwb3NpdGUgZGlyZWN0aW9uIGJlY2F1c2UgKG1heCAtIG1pbikgbXVzdCBiZSBhIHBvd2VyIG9mCisJCSAqIHR3by4KKwkJICoKIAkJICogQWxzbyB3ZSBpbml0aWFsaXplIHRoZSBleHRlcm5hbCBLIHZhbHVlIHRvIC0xIHNvIHRoYXQgd2UgY2FuCi0JCSAqIGF2b2lkIGV4dHJhIGNvbmRpdGlvbnMgY2hlY2sgaW5zaWRlIHRoZSBjb3JlIGxvb3AuCisJCSAqIGF2b2lkIGV4dHJhIGNvbmRpdGlvbnMgaW4gdGhlIGNoZWNrIGluc2lkZSB0aGUgY29yZSBsb29wLgogCQkgKi8KIAkJaWYgKGZtaW4gPiBkbWluKQogCQkJa3ZkZlstLWZtaW4gLSAxXSA9IC0xOwpAQCAtOTgsMTEgKzEwMCwxMyBAQAogCQl9CiAKIAkJLyoKLQkJICogV2UgbmVlZCB0byBleHRlbnQgdGhlIGRpYWdvbmFsICJkb21haW4iIGJ5IG9uZS4gSWYgdGhlIG5leHQKKwkJICogV2UgbmVlZCB0byBleHRlbmQgdGhlIGRpYWdvbmFsICJkb21haW4iIGJ5IG9uZS4gSWYgdGhlIG5leHQKIAkJICogdmFsdWVzIGV4aXRzIHRoZSBib3ggYm91bmRhcmllcyB3ZSBuZWVkIHRvIGNoYW5nZSBpdCBpbiB0aGUKLQkJICogb3Bwb3NpdGUgZGlyZWN0aW9uIGJlY2F1c2UgKG1heCAtIG1pbikgbXVzdCBiZSBhIHBvd2VyIG9mIHR3by4KKwkJICogb3Bwb3NpdGUgZGlyZWN0aW9uIGJlY2F1c2UgKG1heCAtIG1pbikgbXVzdCBiZSBhIHBvd2VyIG9mCisJCSAqIHR3by4KKwkJICoKIAkJICogQWxzbyB3ZSBpbml0aWFsaXplIHRoZSBleHRlcm5hbCBLIHZhbHVlIHRvIC0xIHNvIHRoYXQgd2UgY2FuCi0JCSAqIGF2b2lkIGV4dHJhIGNvbmRpdGlvbnMgY2hlY2sgaW5zaWRlIHRoZSBjb3JlIGxvb3AuCisJCSAqIGF2b2lkIGV4dHJhIGNvbmRpdGlvbnMgaW4gdGhlIGNoZWNrIGluc2lkZSB0aGUgY29yZSBsb29wLgogCQkgKi8KIAkJaWYgKGJtaW4gPiBkbWluKQogCQkJa3ZkYlstLWJtaW4gLSAxXSA9IFhETF9MSU5FX01BWDsKQEAgLTEzOCw3ICsxNDIsNyBAQAogCQkvKgogCQkgKiBJZiB0aGUgZWRpdCBjb3N0IGlzIGFib3ZlIHRoZSBoZXVyaXN0aWMgdHJpZ2dlciBhbmQgaWYKIAkJICogd2UgZ290IGEgZ29vZCBzbmFrZSwgd2Ugc2FtcGxlIGN1cnJlbnQgZGlhZ29uYWxzIHRvIHNlZQotCQkgKiBpZiBzb21lIG9mIHRoZSwgaGF2ZSByZWFjaGVkIGFuICJpbnRlcmVzdGluZyIgcGF0aC4gT3VyCisJCSAqIGlmIHNvbWUgb2YgdGhlbSBoYXZlIHJlYWNoZWQgYW4gImludGVyZXN0aW5nIiBwYXRoLiBPdXIKIAkJICogbWVhc3VyZSBpcyBhIGZ1bmN0aW9uIG9mIHRoZSBkaXN0YW5jZSBmcm9tIHRoZSBkaWFnb25hbAogCQkgKiBjb3JuZXIgKGkxICsgaTIpIHBlbmFsaXplZCB3aXRoIHRoZSBkaXN0YW5jZSBmcm9tIHRoZQogCQkgKiBtaWQgZGlhZ29uYWwgaXRzZWxmLiBJZiB0aGlzIHZhbHVlIGlzIGFib3ZlIHRoZSBjdXJyZW50CkBAIC0xOTYsOCArMjAwLDkgQEAKIAkJfQogCiAJCS8qCi0JCSAqIEVub3VnaCBpcyBlbm91Z2guIFdlIHNwZW50IHRvbyBtdWNoIHRpbWUgaGVyZSBhbmQgbm93IHdlIGNvbGxlY3QKLQkJICogdGhlIGZ1cnRoZXN0IHJlYWNoaW5nIHBhdGggdXNpbmcgdGhlIChpMSArIGkyKSBtZWFzdXJlLgorCQkgKiBFbm91Z2ggaXMgZW5vdWdoLiBXZSBzcGVudCB0b28gbXVjaCB0aW1lIGhlcmUgYW5kIG5vdyB3ZQorCQkgKiBjb2xsZWN0IHRoZSBmdXJ0aGVzdCByZWFjaGluZyBwYXRoIHVzaW5nIHRoZSAoaTEgKyBpMikKKwkJICogbWVhc3VyZS4KIAkJICovCiAJCWlmIChlYyA+PSB4ZW52LT5teGNvc3QpIHsKIAkJCWxvbmcgZmJlc3QsIGZiZXN0MSwgYmJlc3QsIGJiZXN0MTsKQEAgLTI0NCw5ICsyNDksOSBAQAogCiAKIC8qCi0gKiBSdWxlOiAiRGl2aWRlIGV0IEltcGVyYSIuIFJlY3Vyc2l2ZWx5IHNwbGl0IHRoZSBib3ggaW4gc3ViLWJveGVzIGJ5IGNhbGxpbmcKLSAqIHRoZSBib3ggc3BsaXR0aW5nIGZ1bmN0aW9uLiBOb3RlIHRoYXQgdGhlIHJlYWwgam9iIChtYXJraW5nIGNoYW5nZWQgbGluZXMpCi0gKiBpcyBkb25lIGluIHRoZSB0d28gYm91bmRhcnkgcmVhY2hpbmcgY2hlY2tzLgorICogUnVsZTogIkRpdmlkZSBldCBJbXBlcmEiIChkaXZpZGUgJiBjb25xdWVyKS4gUmVjdXJzaXZlbHkgc3BsaXQgdGhlIGJveCBpbgorICogc3ViLWJveGVzIGJ5IGNhbGxpbmcgdGhlIGJveCBzcGxpdHRpbmcgZnVuY3Rpb24uIE5vdGUgdGhhdCB0aGUgcmVhbCBqb2IKKyAqIChtYXJraW5nIGNoYW5nZWQgbGluZXMpIGlzIGRvbmUgaW4gdGhlIHR3byBib3VuZGFyeSByZWFjaGluZyBjaGVja3MuCiAgKi8KIGludCB4ZGxfcmVjc19jbXAoZGlmZmRhdGFfdCAqZGQxLCBsb25nIG9mZjEsIGxvbmcgbGltMSwKIAkJIGRpZmZkYXRhX3QgKmRkMiwgbG9uZyBvZmYyLCBsb25nIGxpbTIsCkBAIC0zMjMsNyArMzI4LDkgQEAKIAl9CiAKIAkvKgotCSAqIEFsbG9jYXRlIGFuZCBzZXR1cCBLIHZlY3RvcnMgdG8gYmUgdXNlZCBieSB0aGUgZGlmZmVyZW50aWFsIGFsZ29yaXRobS4KKwkgKiBBbGxvY2F0ZSBhbmQgc2V0dXAgSyB2ZWN0b3JzIHRvIGJlIHVzZWQgYnkgdGhlIGRpZmZlcmVudGlhbAorCSAqIGFsZ29yaXRobS4KKwkgKgogCSAqIE9uZSBpcyB0byBzdG9yZSB0aGUgZm9yd2FyZCBwYXRoIGFuZCBvbmUgdG8gc3RvcmUgdGhlIGJhY2t3YXJkIHBhdGguCiAJICovCiAJbmRpYWdzID0geGUtPnhkZjEubnJlZmYgKyB4ZS0+eGRmMi5ucmVmZiArIDM7CkBAIC0zOTQsOCArNDAxLDggQEAKIC8qCiAgKiBJZiBhIGxpbmUgaXMgaW5kZW50ZWQgbW9yZSB0aGFuIHRoaXMsIGdldF9pbmRlbnQoKSBqdXN0IHJldHVybnMgdGhpcyB2YWx1ZS4KICAqIFRoaXMgYXZvaWRzIGhhdmluZyB0byBkbyBhYnN1cmQgYW1vdW50cyBvZiB3b3JrIGZvciBkYXRhIHRoYXQgYXJlIG5vdAotICogaHVtYW4tcmVhZGFibGUgdGV4dCwgYW5kIGFsc28gZW5zdXJlcyB0aGF0IHRoZSBvdXRwdXQgb2YgZ2V0X2luZGVudCBmaXRzIHdpdGhpbgotICogYW4gaW50LgorICogaHVtYW4tcmVhZGFibGUgdGV4dCwgYW5kIGFsc28gZW5zdXJlcyB0aGF0IHRoZSBvdXRwdXQgb2YgZ2V0X2luZGVudCBmaXRzCisgKiB3aXRoaW4gYW4gaW50LgogICovCiAjZGVmaW5lIE1BWF9JTkRFTlQgMjAwCiAKQEAgLTQyOSw5ICs0MzYsOSBAQAogfQogCiAvKgotICogSWYgbW9yZSB0aGFuIHRoaXMgbnVtYmVyIG9mIGNvbnNlY3V0aXZlIGJsYW5rIHJvd3MgYXJlIGZvdW5kLCBqdXN0IHJldHVybiB0aGlzCi0gKiB2YWx1ZS4gVGhpcyBhdm9pZHMgcmVxdWlyaW5nIE8oTl4yKSB3b3JrIGZvciBwYXRob2xvZ2ljYWwgY2FzZXMsIGFuZCBhbHNvCi0gKiBlbnN1cmVzIHRoYXQgdGhlIG91dHB1dCBvZiBzY29yZV9zcGxpdCBmaXRzIGluIGFuIGludC4KKyAqIElmIG1vcmUgdGhhbiB0aGlzIG51bWJlciBvZiBjb25zZWN1dGl2ZSBibGFuayByb3dzIGFyZSBmb3VuZCwganVzdCByZXR1cm4KKyAqIHRoaXMgdmFsdWUuIFRoaXMgYXZvaWRzIHJlcXVpcmluZyBPKE5eMikgd29yayBmb3IgcGF0aG9sb2dpY2FsIGNhc2VzLCBhbmQKKyAqIGFsc28gZW5zdXJlcyB0aGF0IHRoZSBvdXRwdXQgb2Ygc2NvcmVfc3BsaXQgZml0cyBpbiBhbiBpbnQuCiAgKi8KICNkZWZpbmUgTUFYX0JMQU5LUyAyMAogCkBAIC00NDMsOCArNDUwLDggQEAKIAlpbnQgZW5kX29mX2ZpbGU7CiAKIAkvKgotCSAqIEhvdyBtdWNoIGlzIHRoZSBsaW5lIGltbWVkaWF0ZWx5IGZvbGxvd2luZyB0aGUgc3BsaXQgaW5kZW50ZWQgKG9yIC0xIGlmCi0JICogdGhlIGxpbmUgaXMgYmxhbmspOgorCSAqIEhvdyBtdWNoIGlzIHRoZSBsaW5lIGltbWVkaWF0ZWx5IGZvbGxvd2luZyB0aGUgc3BsaXQgaW5kZW50ZWQgKG9yIC0xCisJICogaWYgdGhlIGxpbmUgaXMgYmxhbmspOgogCSAqLwogCWludCBpbmRlbnQ7CiAKQEAgLTQ1NCw4ICs0NjEsOCBAQAogCWludCBwcmVfYmxhbms7CiAKIAkvKgotCSAqIEhvdyBtdWNoIGlzIHRoZSBuZWFyZXN0IG5vbi1ibGFuayBsaW5lIGFib3ZlIHRoZSBzcGxpdCBpbmRlbnRlZCAob3IgLTEKLQkgKiBpZiB0aGVyZSBpcyBubyBzdWNoIGxpbmUpPworCSAqIEhvdyBtdWNoIGlzIHRoZSBuZWFyZXN0IG5vbi1ibGFuayBsaW5lIGFib3ZlIHRoZSBzcGxpdCBpbmRlbnRlZCAob3IKKwkgKiAtMSBpZiB0aGVyZSBpcyBubyBzdWNoIGxpbmUpPwogCSAqLwogCWludCBwcmVfaW5kZW50OwogCkBAIC01ODEsMTMgKzU4OCwxMyBAQAogCiAvKgogICogQ29tcHV0ZSBhIGJhZG5lc3Mgc2NvcmUgZm9yIHRoZSBoeXBvdGhldGljYWwgc3BsaXQgd2hvc2UgbWVhc3VyZW1lbnRzIGFyZQotICogc3RvcmVkIGluIG0uIFRoZSB3ZWlnaHQgZmFjdG9ycyB3ZXJlIGRldGVybWluZWQgZW1waXJpY2FsbHkgdXNpbmcgdGhlIHRvb2xzIGFuZAotICogY29ycHVzIGRlc2NyaWJlZCBpbgorICogc3RvcmVkIGluIG0uIFRoZSB3ZWlnaHQgZmFjdG9ycyB3ZXJlIGRldGVybWluZWQgZW1waXJpY2FsbHkgdXNpbmcgdGhlIHRvb2xzCisgKiBhbmQgY29ycHVzIGRlc2NyaWJlZCBpbgogICoKICAqICAgICBodHRwczovL2dpdGh1Yi5jb20vbWhhZ2dlci9kaWZmLXNsaWRlci10b29scwogICoKLSAqIEFsc28gc2VlIHRoYXQgcHJvamVjdCBpZiB5b3Ugd2FudCB0byBpbXByb3ZlIHRoZSB3ZWlnaHRzIGJhc2VkIG9uLCBmb3IgZXhhbXBsZSwKLSAqIGEgbGFyZ2VyIG9yIG1vcmUgZGl2ZXJzZSBjb3JwdXMuCisgKiBBbHNvIHNlZSB0aGF0IHByb2plY3QgaWYgeW91IHdhbnQgdG8gaW1wcm92ZSB0aGUgd2VpZ2h0cyBiYXNlZCBvbiwgZm9yCisgKiBleGFtcGxlLCBhIGxhcmdlciBvciBtb3JlIGRpdmVyc2UgY29ycHVzLgogICovCiBzdGF0aWMgdm9pZCBzY29yZV9hZGRfc3BsaXQoY29uc3Qgc3RydWN0IHNwbGl0X21lYXN1cmVtZW50ICptLCBzdHJ1Y3Qgc3BsaXRfc2NvcmUgKnMpCiB7CkBAIC04MDksMTMgKzgxNiwxNiBAQAogCWdyb3VwX2luaXQoeGRmbywgJmdvKTsKIAogCXdoaWxlICgxKSB7Ci0JCS8qIElmIHRoZSBncm91cCBpcyBlbXB0eSBpbiB0aGUgdG8tYmUtY29tcGFjdGVkIGZpbGUsIHNraXAgaXQ6ICovCisJCS8qCisJCSAqIElmIHRoZSBncm91cCBpcyBlbXB0eSBpbiB0aGUgdG8tYmUtY29tcGFjdGVkIGZpbGUsIHNraXAgaXQ6CisJCSAqLwogCQlpZiAoZy5lbmQgPT0gZy5zdGFydCkKIAkJCWdvdG8gbmV4dDsKIAogCQkvKgogCQkgKiBOb3cgc2hpZnQgdGhlIGNoYW5nZSB1cCBhbmQgdGhlbiBkb3duIGFzIGZhciBhcyBwb3NzaWJsZSBpbgotCQkgKiBlYWNoIGRpcmVjdGlvbi4gSWYgaXQgYnVtcHMgaW50byBhbnkgb3RoZXIgY2hhbmdlcywgbWVyZ2UgdGhlbS4KKwkJICogZWFjaCBkaXJlY3Rpb24uIElmIGl0IGJ1bXBzIGludG8gYW55IG90aGVyIGNoYW5nZXMsIG1lcmdlCisJCSAqIHRoZW0uCiAJCSAqLwogCQlkbyB7CiAJCQlncm91cHNpemUgPSBnLmVuZCAtIGcuc3RhcnQ7CkBAIC04NTgsMTcgKzg2OCwxNyBAQAogCQkgKiBJZiB0aGUgZ3JvdXAgY2FuIGJlIHNoaWZ0ZWQsIHRoZW4gd2UgY2FuIHBvc3NpYmx5IHVzZSB0aGlzCiAJCSAqIGZyZWVkb20gdG8gcHJvZHVjZSBhIG1vcmUgaW50dWl0aXZlIGRpZmYuCiAJCSAqCi0JCSAqIFRoZSBncm91cCBpcyBjdXJyZW50bHkgc2hpZnRlZCBhcyBmYXIgZG93biBhcyBwb3NzaWJsZSwgc28gdGhlCi0JCSAqIGhldXJpc3RpY3MgYmVsb3cgb25seSBoYXZlIHRvIGhhbmRsZSB1cHdhcmRzIHNoaWZ0cy4KKwkJICogVGhlIGdyb3VwIGlzIGN1cnJlbnRseSBzaGlmdGVkIGFzIGZhciBkb3duIGFzIHBvc3NpYmxlLCBzbworCQkgKiB0aGUgaGV1cmlzdGljcyBiZWxvdyBvbmx5IGhhdmUgdG8gaGFuZGxlIHVwd2FyZHMgc2hpZnRzLgogCQkgKi8KIAogCQlpZiAoZy5lbmQgPT0gZWFybGllc3RfZW5kKSB7CiAJCQkvKiBubyBzaGlmdGluZyB3YXMgcG9zc2libGUgKi8KIAkJfSBlbHNlIGlmIChlbmRfbWF0Y2hpbmdfb3RoZXIgIT0gLTEpIHsKIAkJCS8qCi0JCQkgKiBNb3ZlIHRoZSBwb3NzaWJseSBtZXJnZWQgZ3JvdXAgb2YgY2hhbmdlcyBiYWNrIHRvIGxpbmUKLQkJCSAqIHVwIHdpdGggdGhlIGxhc3QgZ3JvdXAgb2YgY2hhbmdlcyBmcm9tIHRoZSBvdGhlciBmaWxlCi0JCQkgKiB0aGF0IGl0IGNhbiBhbGlnbiB3aXRoLgorCQkJICogTW92ZSB0aGUgcG9zc2libHkgbWVyZ2VkIGdyb3VwIG9mIGNoYW5nZXMgYmFjayB0bworCQkJICogbGluZSB1cCB3aXRoIHRoZSBsYXN0IGdyb3VwIG9mIGNoYW5nZXMgZnJvbSB0aGUKKwkJCSAqIG90aGVyIGZpbGUgdGhhdCBpdCBjYW4gYWxpZ24gd2l0aC4KIAkJCSAqLwogCQkJd2hpbGUgKGdvLmVuZCA9PSBnby5zdGFydCkgewogCQkJCWlmIChncm91cF9zbGlkZV91cCh4ZGYsICZnLCBmbGFncykpCkBAIC04NzksMTQgKzg4OSwxNSBAQAogCQl9IGVsc2UgaWYgKGZsYWdzICYgWERGX0lOREVOVF9IRVVSSVNUSUMpIHsKIAkJCS8qCiAJCQkgKiBJbmRlbnQgaGV1cmlzdGljOiBhIGdyb3VwIG9mIHB1cmUgYWRkL2RlbGV0ZSBsaW5lcwotCQkJICogaW1wbGllcyB0d28gc3BsaXRzLCBvbmUgYmV0d2VlbiB0aGUgZW5kIG9mIHRoZSAiYmVmb3JlIgotCQkJICogY29udGV4dCBhbmQgdGhlIHN0YXJ0IG9mIHRoZSBncm91cCwgYW5kIGFub3RoZXIgYmV0d2VlbgotCQkJICogdGhlIGVuZCBvZiB0aGUgZ3JvdXAgYW5kIHRoZSBiZWdpbm5pbmcgb2YgdGhlICJhZnRlciIKLQkJCSAqIGNvbnRleHQuIFNvbWUgc3BsaXRzIGFyZSBhZXN0aGV0aWNhbGx5IGJldHRlciBhbmQgc29tZQotCQkJICogYXJlIHdvcnNlLiBXZSBjb21wdXRlIGEgYmFkbmVzcyAic2NvcmUiIGZvciBlYWNoIHNwbGl0LAotCQkJICogYW5kIGFkZCB0aGUgc2NvcmVzIGZvciB0aGUgdHdvIHNwbGl0cyB0byBkZWZpbmUgYQotCQkJICogInNjb3JlIiBmb3IgZWFjaCBwb3NpdGlvbiB0aGF0IHRoZSBncm91cCBjYW4gYmUgc2hpZnRlZAotCQkJICogdG8uIFRoZW4gd2UgcGljayB0aGUgc2hpZnQgd2l0aCB0aGUgbG93ZXN0IHNjb3JlLgorCQkJICogaW1wbGllcyB0d28gc3BsaXRzLCBvbmUgYmV0d2VlbiB0aGUgZW5kIG9mIHRoZQorCQkJICogImJlZm9yZSIgY29udGV4dCBhbmQgdGhlIHN0YXJ0IG9mIHRoZSBncm91cCwgYW5kCisJCQkgKiBhbm90aGVyIGJldHdlZW4gdGhlIGVuZCBvZiB0aGUgZ3JvdXAgYW5kIHRoZQorCQkJICogYmVnaW5uaW5nIG9mIHRoZSAiYWZ0ZXIiIGNvbnRleHQuIFNvbWUgc3BsaXRzIGFyZQorCQkJICogYWVzdGhldGljYWxseSBiZXR0ZXIgYW5kIHNvbWUgYXJlIHdvcnNlLiBXZSBjb21wdXRlCisJCQkgKiBhIGJhZG5lc3MgInNjb3JlIiBmb3IgZWFjaCBzcGxpdCwgYW5kIGFkZCB0aGUgc2NvcmVzCisJCQkgKiBmb3IgdGhlIHR3byBzcGxpdHMgdG8gZGVmaW5lIGEgInNjb3JlIiBmb3IgZWFjaAorCQkJICogcG9zaXRpb24gdGhhdCB0aGUgZ3JvdXAgY2FuIGJlIHNoaWZ0ZWQgdG8uIFRoZW4gd2UKKwkJCSAqIHBpY2sgdGhlIHNoaWZ0IHdpdGggdGhlIGxvd2VzdCBzY29yZS4KIAkJCSAqLwogCQkJbG9uZyBzaGlmdCwgYmVzdF9zaGlmdCA9IC0xOwogCQkJc3RydWN0IHNwbGl0X3Njb3JlIGJlc3Rfc2NvcmU7Cg==